diff --git a/.agents/skills/README.md b/.agents/skills/README.md
new file mode 100644
index 0000000000..116779084a
--- /dev/null
+++ b/.agents/skills/README.md
@@ -0,0 +1,11 @@
+# Agent Skills Directory
+
+This directory contains specialized agent skills (recipes) to guide AI coding agents (like Antigravity or Claude Code) in extending the codebase cleanly and consistently.
+
+## Available Skills
+
+- [Core Guidelines](./core-guidelines/SKILL.md) — Symmetrical architecture, conventions, and model rules.
+- [Add Native Extension](./add-native-extension/SKILL.md) — C++ operations and JSI bindings.
+- [Add Task Pipeline](./add-task-pipeline/SKILL.md) — TypeScript task pipelines and React hooks.
+- [Model Schema Validation](./model-schema-validation/SKILL.md) — SymbolicTensor schemas and validation.
+- [Verify and Build](./verify-and-build/SKILL.md) — TypeScript typechecking, native rebuilding, and troubleshooting.
diff --git a/.agents/skills/add-native-extension/SKILL.md b/.agents/skills/add-native-extension/SKILL.md
new file mode 100644
index 0000000000..cbd751d0c1
--- /dev/null
+++ b/.agents/skills/add-native-extension/SKILL.md
@@ -0,0 +1,201 @@
+---
+name: add-native-extension
+description: Use when adding a C++ extension, writing native JSI host functions, registering functions in C++ install maps, or compiling native code.
+metadata:
+  id: add_native_extension
+  scope: cpp/extensions/*, src/extensions/*
+---
+
+# Skill: Add a Native C++ Extension & JSI Bindings
+
+Use this guide to add custom, performance-critical native operations in C++ and expose them to TypeScript via React Native JSI.
+
+---
+
+## 🚦 Architectural Guidelines
+
+Before writing any C++ code, ensure you adhere to the following principles:
+
+1. **Amdahl's Law & Premature Optimization**:
+   * Evaluate what percentage of total inference/pipeline time the processing step occupies. If the preprocessing/postprocessing step takes `< 5%` of the total inference budget, write it in **pure TypeScript** to reduce codebase complexity and maintenance overhead.
+
+2. **Destination Tensors & Local Memory**:
+   * **Local Memory is Allowed**: You can allocate temporary native C++ memory (such as stack variables, `std::vector`s, or dynamic memory cleaned up before the function exits) for intermediate calculations.
+   * **Destination Tensors**: If the operation writes dense output, the destination tensor must be pre-allocated by the caller (in TypeScript) and passed as an argument (e.g., `sigmoid(src, dst)`).
+   * **Primitive Array Returns**: If the operation produces variable-sized non-dense outputs (like bounding box indices in Non-Maximum Suppression (NMS)), return a plain `jsi::Array` of primitives (like indices or coordinates).
+     * *Example*: `nms(boxes, scores, options)` returns a `jsi::Array` of indices (e.g., `[0, 4, 12]`) rather than a new tensor. This avoids all native memory management overhead for variable-sized outputs.
+
+## 🚫 Avoid / Anti-Patterns
+
+* **Do NOT return implicitly allocated JSI Tensors:** Never return newly created `TensorHostObject` instances from C++. This forces the JavaScript layer to reason about their garbage collection and manual lifetimes, leading to native memory leaks.
+* **Do NOT define default parameters in C++:** Native C++ functions must never define default argument values (e.g. `axis = -1`). Define all default values explicitly in the TypeScript wrapper layer instead.
+* **Do NOT perform in-place mutation without safety checks:** Never allow inputs and outputs to share the same underlying instance.
+
+---
+
+---
+
+## 🛠️ Step-by-Step Implementation
+
+### Step 1: Create the Native Operation Files
+Under `cpp/extensions/<domain>/`, create or modify the header and implementation files for your operations:
+
+#### 1. Header (`cpp/extensions/<domain>/operations.h`)
+Keep the header clean and specify exact JSI install functions:
+```cpp
+#pragma once
+#include <jsi/jsi.h>
+
+namespace rnexecutorch::extensions::<domain>
+{
+    void install_customOp(facebook::jsi::Runtime &rt, facebook::jsi::Object &module);
+}
+```
+
+#### 2. Source (`cpp/extensions/<domain>/operations.cpp`)
+* Extract input and output tensors as `TensorHostObject` pointers.
+* Check bounds, shapes, types, and verify that the output tensor is **not the same instance** as the input (no unsafely managed in-place mutation).
+* Lock tensors using `std::shared_lock` (for inputs) and `std::unique_lock` (for outputs).
+
+```cpp
+#include "operations.h"
+#include "core/tensor.h"
+#include <algorithm>
+
+namespace rnexecutorch::extensions::<domain>
+{
+    namespace jsi = facebook::jsi;
+    using TensorHostObject = rnexecutorch::core::tensor::TensorHostObject;
+
+    void install_customOp(jsi::Runtime &rt, jsi::Object &module)
+    {
+        auto name = "customOp";
+        auto fnBody = [](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args, size_t count) -> jsi::Value
+        {
+            // 1. Strict argument count validation (No default values here!)
+            if (count != 3)
+            {
+                throw jsi::JSError(rt, "Usage: customOp(src, dst, factor)");
+            }
+
+            // 2. Validate input and output types
+            auto srcObj = args[0].asObject(rt);
+            auto dstObj = args[1].asObject(rt);
+            if (!srcObj.isHostObject<TensorHostObject>(rt) || !dstObj.isHostObject<TensorHostObject>(rt))
+            {
+                throw jsi::JSError(rt, "customOp: Arguments src and dst must be Tensors");
+            }
+
+            auto src = srcObj.getHostObject<TensorHostObject>(rt);
+            auto dst = dstObj.getHostObject<TensorHostObject>(rt);
+            double factor = args[2].asNumber();
+
+            // 3. Prevent in-place mutations
+            if (src.get() == dst.get())
+            {
+                throw jsi::JSError(rt, "customOp: In-place operations (src == dst) are not supported.");
+            }
+
+            // 4. Validate metadata compatibility
+            if (src->shape_ != dst->shape_ || src->dtype_ != dst->dtype_)
+            {
+                throw jsi::JSError(rt, "customOp: src and dst shape and dtype must match");
+            }
+
+            // 5. Lock underlying buffers
+            std::shared_lock<std::shared_mutex> src_lock(src->mutex_, std::try_to_lock);
+            std::unique_lock<std::shared_mutex> dst_lock(dst->mutex_, std::try_to_lock);
+            if (!src_lock.owns_lock() || !dst_lock.owns_lock())
+            {
+                throw jsi::JSError(rt, "customOp: Tensors are currently in use");
+            }
+
+            if (!src->data_ || !dst->data_)
+            {
+                throw jsi::JSError(rt, "customOp: Tensor has been disposed");
+            }
+
+            // 6. Perform the computation
+            const float *srcData = reinterpret_cast<const float *>(src->data_.get());
+            float *dstData = reinterpret_cast<float *>(dst->data_.get());
+            size_t size = src->size();
+
+            for (size_t i = 0; i < size; ++i)
+            {
+                dstData[i] = srcData[i] * static_cast<float>(factor);
+            }
+
+            // Always return the destination tensor (args[1]) as the JSI result
+            return jsi::Value(rt, args[1]);
+        };
+
+        module.setProperty(rt, name, jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, name), 3, fnBody));
+    }
+}
+```
+
+---
+
+### Step 2: Register in Extension and Core JSI Installs
+
+1. **Extension Register** (`cpp/extensions/<domain>/install.cpp`):
+   ```cpp
+   #include "install.h"
+   #include "operations.h"
+
+   namespace rnexecutorch::extensions::<domain>
+   {
+       void install(facebook::jsi::Runtime &rt, facebook::jsi::Object &module)
+       {
+           facebook::jsi::Object subModule(rt);
+           install_customOp(rt, subModule);
+           module.setProperty(rt, "<domain>", subModule);
+       }
+   }
+   ```
+
+2. **Core Register** ([cpp/RnExecutorch.cpp](../cpp/RnExecutorch.cpp)):
+   ```cpp
+   #include "extensions/<domain>/install.h"
+   // ... inside rnexecutorch::install ...
+   rnexecutorch::extensions::<domain>::install(jsiRuntime, myModule);
+   ```
+
+---
+
+### Step 3: TypeScript Bridge & Wrappers
+Under `src/extensions/<domain>.ts` or `src/extensions/<domain>/index.ts`:
+* **Use the `rnexecutorchJsi` Symbol**: You must import and interact with native bindings using the `rnexecutorchJsi` symbol exported from [src/native/bridge.ts](../src/native/bridge.ts). **Do not** reference the global `__rnexecutorch_jsi__` directly throughout your wrapper files.
+* Expose the TypeScript wrapper.
+* Handle default values here instead of the C++ layer.
+* Mark wrapper functions with the `"worklet";` directive.
+
+```typescript
+import { rnexecutorchJsi } from '../native/bridge';
+import { type Tensor } from '../core/tensor';
+
+/**
+ * Applies a custom operation scaling the src tensor by factor.
+ * @param src Input Tensor.
+ * @param dst Pre-allocated Destination Tensor.
+ * @param factor Scale factor. Defaults to 1.0.
+ */
+export function customOp(src: Tensor, dst: Tensor, factor: number = 1.0): Tensor {
+  'worklet';
+  return rnexecutorchJsi.<domain>.customOp(src, dst, factor);
+}
+```
+
+---
+
+## 📋 Verification Checklist
+
+When adding a native extension, verify that:
+- [ ] You only implemented in C++ if the operation takes `> 5%` of the total inference budget.
+- [ ] No JSI Tensors are implicitly allocated and returned in the C++ code.
+- [ ] Input and output tensors are locked using `std::shared_lock` and `std::unique_lock` respectively.
+- [ ] In-place mutation is explicitly prevented by checking that `src != dst`.
+- [ ] No default parameter values are defined in the C++ header/source files.
+- [ ] The custom operation install function is registered in both the domain `install` function and core [cpp/RnExecutorch.cpp](../cpp/RnExecutorch.cpp).
+- [ ] The TypeScript wrapper imports and uses `rnexecutorchJsi` instead of the global `__rnexecutorch_jsi__`.
+- [ ] The TypeScript wrapper is marked with the `"worklet";` directive and defines all default parameter values.
diff --git a/.agents/skills/add-task-pipeline/SKILL.md b/.agents/skills/add-task-pipeline/SKILL.md
new file mode 100644
index 0000000000..ad1872ac06
--- /dev/null
+++ b/.agents/skills/add-task-pipeline/SKILL.md
@@ -0,0 +1,227 @@
+---
+name: add-task-pipeline
+description: Use when creating a TypeScript task pipeline, implementing image preprocessing/postprocessing, loading models, or wrapping pipelines in React hooks.
+metadata:
+  id: add_task_pipeline
+  scope: src/extensions/*/tasks/*, src/hooks/*
+---
+
+# Skill: Add a High-Level Task Pipeline (TypeScript)
+
+Use this guide to construct end-to-end task pipelines (e.g. classification, style transfer, object detection) in TypeScript and wrap them in React hooks.
+
+---
+
+## 🚦 Design Principles
+
+When implementing task constructors like `create<Task>` (e.g. `createClassifier`, `createStyleTransfer`), adhere to the following rules:
+
+1. **Pre-allocating Static Tensors (`as const`)**:
+   * Statically sized scratch/output tensors required for inference should be pre-allocated inside the constructor body.
+   * Allocate them using:
+     ```typescript
+     const tensors = [
+       tensor('float32', shapeA),
+       tensor('float32', shapeB),
+     ] as const;
+     ```
+    * **Destructuring & Naming**: Destructure and name the individual tensors immediately after allocation. Always prefix tensor variables with a lowercase `t` (e.g. `tReshape`, `tUint8`, `tInput`) to easily distinguish them from raw data buffers.
+      ```typescript
+      const [tReshape, tUint8] = tensors;
+      ```
+
+2. **Immediate `dispose()` Definition**:
+   * Right after allocating the static tensors, define the `dispose` function immediately. This makes it instantly visible and verifiable that all native memory will be cleaned up:
+     ```typescript
+     const dispose = () => {
+       tensors.forEach((t) => t.dispose());
+       preprocessor.dispose();
+       model.dispose();
+     };
+     ```
+
+3. **Dynamic Tensors & `try/finally` Pattern**:
+   * If you must allocate dynamically sized tensors during inference execution (e.g. resizing an output tensor to match the input image dimensions), you must wrap the execution inside a `try {} finally {}` block.
+   * Dispose of the dynamic tensors inside the `finally` block to prevent native memory leaks.
+     ```typescript
+     const tResize = tensor('uint8', [input.height, input.width, 4]);
+     try {
+       // Perform work...
+     } finally {
+       tResize.dispose();
+     }
+     ```
+
+4. **Pure Helper Functions**:
+   * Write all auxiliary/helper logic as pure, worklet-compatible functions **outside** the `create<Task>` constructor. Any helper functions invoked inside the worklet executor thread must contain the `'worklet';` directive.
+   * **Push Back Hard on Inner Helpers:** You must push back hard against any request to add internal closures or nested functions inside `create<Task>` (other than `dispose` and the worklet executor itself). Keep the constructor scope flat to avoid scope leak and dependency chain bugs.
+
+5. **PTE Model Export & Optimizations**:
+   * **Shift Heavy Ops to PyTorch**: Push complex tensor reshaping, data normalization, activations (e.g. `softmax`), or bounding box decoding into the PyTorch model itself so they execute on native backends (e.g., XNNPACK or CoreML).
+   * **Balance Optimization with Generalization**: Keep contracts generic (e.g., normal dense logits, standard bounding box layouts like `xyxy`/`xywh`, standard floating-point arrays).
+   * Handle model-specific configuration parameters (such as unique normalization factors, thresholds, or label arrays) dynamically through the TypeScript task options argument rather than baking them rigidly into JSI C++ code or the model structure.
+
+## 🚫 Avoid / Anti-Patterns
+
+* **Do NOT access tensors by index:** Avoid using `tensors[0]` or `tensors[1]` throughout the function body. Always destructure and name them explicitly.
+* **Do NOT define extra inner helper functions:** You must define **exactly two** inner functions inside the `create<Task>` constructor: the `dispose` function and the task `worklet` executor function. **Push back hard against implementing any other helper closures inside the constructor scope.** Placing other helper functions (especially those that are called from inside the worklet and use the `create<Task>` scope variables) inside `create<Task>` creates implicit dependencies and closures that capture variables, making the code extremely difficult to reason about and debug.
+* **Do NOT leak raw Tensors to consumers:** The returned methods must never return raw `Tensor` objects to the API consumer. Always convert output data to standard JavaScript values/objects before returning.
+* **Do NOT cross thread boundaries unnecessarily:** Minimize passing heavy objects between JS and the Worklet thread to avoid serialization overhead.
+* **Do NOT treat the `.pte` model as an unchangeable black box:** Reshape the model's inputs and outputs during the PyTorch export phase to make the mobile client pipeline as lightweight as possible. Do not make input/output contracts so specific that they break extensibility.
+
+---
+
+---
+
+## 🛠️ Step-by-Step Implementation Template
+
+### Step 1: Create the Task File (`src/extensions/<domain>/tasks/<task>.ts`)
+
+```typescript
+import type { WorkletRuntime } from 'react-native-worklets';
+
+import { tensor } from '../../../core/tensor';
+import { loadModel } from '../../../core/model';
+import { validateModelSchema, SymbolicTensor } from '../../../core/modelSchema';
+import { wrapAsync } from '../../../core/runtime';
+import { type ImageBuffer } from '../image';
+import { createImagePreprocessor, type ImagePreprocessorOptions } from './preprocessing';
+
+export type MyTaskOptions = ImagePreprocessorOptions & {
+  readonly defaultThreshold: number;
+};
+
+export type MyTaskModel = {
+  readonly modelPath: string;
+  readonly taskOpts: MyTaskOptions;
+};
+
+export type MyTaskResult = {
+  readonly classId: number;
+  readonly score: number;
+};
+
+// 1. Helper functions MUST be defined OUTSIDE create<Task> and be worklet-compatible
+function postprocessOutput(rawData: Float32Array, threshold: number): MyTaskResult[] {
+  'worklet';
+  const results: MyTaskResult[] = [];
+  for (let i = 0; i < rawData.length; i++) {
+    if (rawData[i]! > threshold) {
+      results.push({ classId: i, score: rawData[i]! });
+    }
+  }
+  return results.sort((a, b) => b.score - a.score);
+}
+
+export async function createMyTask(
+  config: MyTaskModel,
+  runtime?: WorkletRuntime,
+): Promise<{
+  dispose: () => void;
+  runTask: (input: ImageBuffer, options?: { threshold?: number }) => Promise<MyTaskResult[]>;
+  runTaskWorklet: (input: ImageBuffer, options?: { threshold?: number }) => MyTaskResult[];
+}> {
+  const { modelPath, taskOpts } = config;
+  const model = await wrapAsync(loadModel, runtime)(modelPath);
+
+  // Validate model schema
+  const meta = validateModelSchema(
+    model,
+    'forward',
+    [SymbolicTensor('float32', [1, 3, 'H', 'W'], [3, 'H', 'W'])],
+    [SymbolicTensor('float32', [1, 10], [10])],
+  );
+  const inpShape = meta.inputTensorMeta[0]!.shape;
+  const outShape = meta.outputTensorMeta[0]!.shape;
+
+  // 2. Pre-allocate static tensors
+  const tensors = [
+    tensor('float32', outShape),
+  ] as const;
+
+  // Idiomatic destructuring and naming with "t" prefix
+  const [tOutput] = tensors;
+  const preprocessor = createImagePreprocessor(taskOpts, inpShape);
+
+  // 3. Define dispose() immediately after allocation
+  const dispose = () => {
+    preprocessor.dispose();
+    tensors.forEach((t) => t.dispose());
+    model.dispose();
+  };
+
+  // 4. Define exactly two inner functions (dispose & runTaskWorklet)
+  const runTaskWorklet = (
+    input: ImageBuffer,
+    options?: { threshold?: number }
+  ): MyTaskResult[] => {
+    'worklet';
+    
+    // Process input buffer to input tensor
+    const tInput = preprocessor.process(input);
+    model.execute('forward', [tInput], [tOutput]);
+
+    const data = tOutput.getData(new Float32Array(tOutput.numel));
+    const threshold = options?.threshold ?? taskOpts.defaultThreshold;
+    
+    // 5. Return standard JS object, never raw Tensor
+    return postprocessOutput(data, threshold);
+  };
+
+  const runTask = wrapAsync(runTaskWorklet, runtime);
+
+  return { runTask, runTaskWorklet, dispose };
+}
+```
+
+### Step 2: Create the React Hook Wrapper (`src/hooks/use<Task>.ts`)
+
+Wrap the task pipeline in a custom React Hook using the core hooks `useModelDownload` and `useModel`. This manages downloading, compilation, error tracking, and automatic cleanup of the native memory upon unmounting or config changes.
+
+```typescript
+import { useModel } from './useModel';
+import { useModelDownload } from './useModelDownload';
+import { createMyTask, type MyTaskModel } from '../extensions/<domain>/tasks/<task>';
+
+export function useMyTask(
+  config: MyTaskModel, 
+  options?: { preventLoad?: boolean }
+) {
+  // 1. Resolve remote or local asset model path and download progress
+  const { localPath, downloadProgress, downloadError } = useModelDownload(
+    config.modelPath,
+    options?.preventLoad,
+  );
+
+  // 2. Instantiate and compile the task pipeline (with automatic lifecycle cleanup)
+  const { model, error } = useModel(
+    createMyTask,
+    localPath ? { ...config, modelPath: localPath } : null,
+    [localPath],
+  );
+
+  return {
+    isReady: !!model,
+    error: downloadError || error,
+    downloadProgress,
+    localPath,
+    runTask: model?.runTask,
+    runTaskWorklet: model?.runTaskWorklet,
+  };
+}
+```
+
+---
+
+## 📋 Verification Checklist
+
+When adding a task pipeline or React hook, verify that:
+- [ ] Scratch/output tensors are pre-allocated using `tensor() as const` and prefixed with lowercase `t` (e.g. `tInput`).
+- [ ] Static tensors are destructured and named (no index-based access in the body).
+- [ ] The `dispose` function is defined immediately after static allocations.
+- [ ] Any dynamically allocated tensors are wrapped in `try/finally` and disposed of inside `finally`.
+- [ ] The constructor contains exactly two inner functions (the `dispose` function and the worklet executor).
+- [ ] Auxiliary helpers are defined outside the constructor and marked with the `'worklet';` directive if run on the worklet runtime.
+- [ ] Raw `Tensor` objects are never returned to the consumer.
+- [ ] Data configurations (e.g. thresholds, labels) are configurable dynamically via the TypeScript task options.
+- [ ] The React Hook utilizes `useModel` and properly returns progress, ready state, errors, and task execution bindings.
diff --git a/.agents/skills/core-guidelines/SKILL.md b/.agents/skills/core-guidelines/SKILL.md
new file mode 100644
index 0000000000..06745e617b
--- /dev/null
+++ b/.agents/skills/core-guidelines/SKILL.md
@@ -0,0 +1,117 @@
+---
+name: core-guidelines
+description: Use when learning the codebase architecture, design patterns, core/extension symmetry, file structure, or general coding standards.
+metadata:
+  id: core_guidelines
+  scope: general
+---
+
+# RNET-POC Agent Skills & Architecture Guide
+
+Welcome, Agent! This directory contains specialized "skills" (recipes) designed to help you extend this codebase in an idiomatic, clean, and consistent manner. 
+
+Before implementing any feature or modifying code, please find the corresponding skill folder in `.agents/skills/` and read its `SKILL.md` using the `IsSkillFile: true` option to ensure you follow the correct patterns.
+
+---
+
+## 🎯 Design Philosophy
+
+The library is designed around the separation of responsibilities into two distinct layers:
+1. **Lower-Level API (Flexible & Domain-Agnostic)**: Exposes raw bindings to native ExecuTorch capabilities (tensors, models, runtime execution, and basic math/CV operations) in C++ without task-specific code. This layer is designed to be highly flexible, allowing developer customization directly in TypeScript.
+2. **Higher-Level API (Transparent & Orchestrated)**: Built as orchestration layers **entirely in TypeScript** on top of the lower-level native bindings. Preprocessing, running model inference, and output postprocessing are composed dynamically in TS. 
+
+* **Why this matters**: In contrast to opaque native pipelines, implementing pipelines in TypeScript makes them transparent, easy to debug, highly customizable, and easy to extend without writing complex native C++ code.
+
+---
+
+## 🏛️ Symmetrical Architecture (Core vs. Extensions)
+
+This library is strictly structured using a symmetrical layout between the native C++ layer (`cpp/`) and the TypeScript layer (`src/`). When adding a new capability, you will typically need to modify or add files in both layers under their respective subfolders:
+
+```text
+cpp/                                    │ src/
+├── core/                               │ ├── core/
+│   ├── install.h                       │ │   ├── model.ts
+│   ├── tensor.h                        │ │   ├── tensor.ts
+│   └── ...                             │ │   └── ...
+└── extensions/                         │ ├── extensions/
+    ├── math/                           │ │   ├── math.ts
+    │   ├── install.h                   │ │   └── cv/
+    │   └── operations.h                │ │       ├── image.ts
+    └── cv/                             │ │       └── tasks/
+        ├── install.h                   │ │           └── classification.ts
+        └── image_ops.h                 │ └── hooks/
+                                        │     └── useClassifier.ts
+```
+
+### 1. Core (`cpp/core/` and `src/core/`)
+* **Purpose**: Implements the absolute bare minimum required for the lower-level API.
+* **Responsibilities**: Primitives for `Tensor` and `Model` management, JSI bindings, and the ExecuTorch runtime execution logic.
+* **Rule**: Core is domain-agnostic. **Do not** add task-specific or domain-specific code (like computer vision ops, tokenizers, or speech preprocessing) here.
+
+### 2. Extensions (`cpp/extensions/` and `src/extensions/`)
+* **Purpose**: Contains all domain-specific logic, organized by domain (e.g., `cv`, `math`, `llm`, `speech`).
+* **Symmetry Rules**:
+  * **Native operations** (e.g. image transformations, box math) go under `cpp/extensions/<domain>/`.
+  * **JSI Installation** is registered via `cpp/extensions/<domain>/install.cpp` and exposed on the global JSI object under `__rnexecutorch_jsi__.<domain>`.
+  * **TypeScript wrappers** for these native operations go in `src/extensions/<domain>.ts` or `src/extensions/<domain>/`.
+  * **Higher-level task pipelines** (orchestration of model loading, input pre-processing, running inference, and output post-processing) are written entirely in TypeScript under `src/extensions/<domain>/tasks/`.
+  * **React Hooks** (lightweight state/lifecycle wrappers around task pipelines) go in `src/hooks/`.
+
+---
+
+## 📂 Skills Index
+
+Use the following index to locate the specific procedural guides for your task:
+
+| I want to... | Use this Skill File | Description |
+| :--- | :--- | :--- |
+| **Add a new native operator or C++ binding** | [SKILL.md](../add-native-extension/SKILL.md) | Procedural guide to implementing C++ functions, exposing them via JSI, and writing TypeScript bridge wrappers. |
+| **Create a task pipeline or hook** | [SKILL.md](../add-task-pipeline/SKILL.md) | Guide to building end-to-end TS pipelines (e.g. object detection) and exposing them via React hooks. |
+| **Verify, rebuild, or troubleshoot changes** | [SKILL.md](../verify-and-build/SKILL.md) | Workflows for rebuilding TS/C++ and resolving common JSI runtime errors. |
+| **Validate model constraints & schemas** | [SKILL.md](../model-schema-validation/SKILL.md) | Guide on specifying SymbolicTensor constraints and shapes for model signature validation. |
+
+---
+
+## 💡 Key Coding Conventions for Agents
+
+* **Worklets**: Ensure all TypeScript functions directly wrapping native JSI calls start with the `"worklet";` directive so they are compatible with worklet-based libraries (e.g., React Native Reanimated).
+* **Memory Management**: When writing native C++ code with JSI, pay close attention to JSI reference management and handle ExecuTorch lifecycle states safely.
+* **Keep Core Clean**: Always build on top of core primitives. Do not modify files in `cpp/core/` or `src/core/` unless you are fixing a bug in the foundational runtime.
+
+---
+
+## 📢 Package Registration & Exports
+
+Whenever you add a new extension, task pipeline, or hook, you **must** register and export them at the package level to make them accessible to users:
+1. **TypeScript Exports** ([src/index.ts](../src/index.ts)): Export the new task pipelines (e.g. `export * from './extensions/cv/tasks/myTask'`) and hooks (e.g. `export * from './hooks/useMyTask'`).
+2. **Model Configurations** ([src/models.ts](../src/models.ts)) & **Constants** ([src/constants.ts](../src/constants.ts)):
+   * These **two files are the sole source of truth** for defining pre-exported models, their options, and their label structures. Do not define models or options ad-hoc anywhere else.
+   * **Model Registry Rule**: You must **only export the single `models` object registry** from `models.ts`. Do not export individual model configuration constants. Define them as internal (private) `const` variables inside `models.ts` and register them under the appropriate category nested inside the exported `models` registry object.
+   * If you are introducing a standard pre-configured model, add its metadata config and HuggingFace/local URI endpoint mapping here.
+
+---
+
+## 🔍 Model Inspection & Testing via the Example App
+
+The example app under `example/` is the primary playground for inspecting models and testing your pipelines on-device:
+1. **Inspect Screen** ([InspectScreen.tsx](../example/src/InspectScreen.tsx)): Paste any arbitrary `.pte` model URL to load and print its metadata, inputs, and outputs dynamically.
+2. **Gallery Screen** ([GalleryScreen.tsx](../example/src/GalleryScreen.tsx)): Test task pipelines (classification, detection, style transfer, segmentation) on static assets/images. When adding a new task, you should add a corresponding interactive testing card/flow here.
+3. **Camera Screen** ([CameraScreen.tsx](../example/src/CameraScreen.tsx)): Run real-time camera-based inferences using the task pipelines.
+
+---
+
+## 🛠️ Verification & Rebuilding Checklist
+
+To test and compile your changes:
+1. **TS Build & Typecheck**:
+   * **Verify Types (Fast)**: `yarn typecheck`
+   * **Build Bundles**: `yarn prepare` *(runs `react-native-builder-bob` to bundle TS source into the `lib/` directory)*
+2. **Native Rebuilding (iOS)**:
+   Whenever native C++ files are added or modified:
+   ```bash
+   cd example/ios && pod install && cd ../..
+   ```
+   *Then run the example app using `yarn example ios` (or `yarn ios` from `example/`).*
+3. **Native Rebuilding (Android)**:
+   *Android builds handle C++ file changes automatically upon triggering `yarn example android` (or `yarn android` from `example/`).*
diff --git a/.agents/skills/model-schema-validation/SKILL.md b/.agents/skills/model-schema-validation/SKILL.md
new file mode 100644
index 0000000000..21a2f70bc3
--- /dev/null
+++ b/.agents/skills/model-schema-validation/SKILL.md
@@ -0,0 +1,123 @@
+---
+name: model-schema-validation
+description: Use when defining SymbolicTensor constraints, validating ExecuTorch model shapes, checking method signatures, or verifying dynamic tensor dimensions.
+metadata:
+  id: model_schema_validation
+  scope: src/core/modelSchema.ts, src/extensions/*/tasks/*
+---
+
+# Skill: Model Schema Validation Guide
+
+Use this guide to define and enforce structural constraints (shapes and data types) on loaded ExecuTorch `.pte` models using `validateModelSchema`.
+
+---
+
+## 🔍 Why Validate Model Schemas?
+
+Every ExecuTorch model exposes metadata about its execution methods (typically `'forward'`), including:
+* Input and output argument counts.
+* The expected types (primitives like `number`/`boolean` or `Tensor`).
+* The data type (`float32`, `int32`, etc.) and the shape arrays of tensors.
+
+To prevent runtime crashes and memory allocation mismatches in C++, the TypeScript task pipeline must validate that the provided model matches its expected execution signature *before* allocating static tensors or executing inference.
+
+---
+
+## 🛠️ Validation API Reference
+
+```typescript
+import { validateModelSchema, SymbolicTensor } from '../../../core/modelSchema';
+
+const meta = validateModelSchema(
+  model,
+  methodName,
+  expectedInputs,
+  expectedOutputs
+);
+```
+
+### Constraints Types:
+* **Primitives**: `'number' | 'boolean' | 'null'`
+* **Tensors**: Defined via the `SymbolicTensor(dtype?, ...shapes)` helper.
+
+---
+
+## 📏 Symbolic Dimensions & Dynamic Shapes
+
+Tensors often support dynamic dimensions (such as varying image sizes `'H'`, `'W'` or dynamic batch/prediction counts `'N'`).
+The `SymbolicTensor` helper supports specifying **Symbolic Shapes** where integers are static matching constraints, and string names act as runtime variables.
+
+### How Symbolic Matching Works:
+1. **Numbers (Static Match)**:
+   If a dimension is defined as a number, the loaded model's tensor dimension must match that exact integer.
+   * *Example*: `[1, 3, 'H', 'W']` requires the batch dimension to be exactly `1`, and channels to be exactly `3`.
+
+2. **Strings (Symbolic Match)**:
+   If a dimension is defined as a string (e.g., `'H'`), the validator binds the actual dimension size to that symbol name.
+   * *Symbolic Constraint Rules*: Within a single tensor, if a symbol (e.g., `'H'`) appears multiple times, the corresponding dimensions must be equal.
+
+3. **Multiple Alternative Shapes**:
+   You can provide multiple shape variations to `SymbolicTensor` to support models compiled in different layouts (e.g., channels-first vs. channels-last).
+   * *Example*: `SymbolicTensor('float32', [1, 3, 'H', 'W'], [3, 'H', 'W'])` allows either 4D or 3D float32 layouts.
+
+---
+
+## 📋 Common Validation Recipes
+
+### 1. Classification
+Accepts an image tensor and outputs a 2D class probabilities array:
+```typescript
+const meta = validateModelSchema(
+  model,
+  'forward',
+  [SymbolicTensor('float32', [1, 3, 'H', 'W'], [3, 'H', 'W'])], // Input
+  [SymbolicTensor('float32', [1, 'N'], ['N'])]                  // Output: logits / probs
+);
+
+const inpShape = meta.inputTensorMeta[0]!.shape;
+const outShape = meta.outputTensorMeta[0]!.shape;
+```
+
+### 2. Image-to-Image / Style Transfer
+Accepts an image tensor and returns a modified image tensor with identical dimensions:
+```typescript
+const meta = validateModelSchema(
+  model,
+  'forward',
+  [SymbolicTensor('float32', [1, 3, 'H', 'W'], [3, 'H', 'W'])], // Input
+  [SymbolicTensor('float32', [1, 3, 'H', 'W'], [3, 'H', 'W'])]  // Output
+);
+```
+
+### 3. Object Detection (Dynamic Boxes Count)
+Accepts an image tensor, and outputs boxes, scores, and class labels for `N` dynamic detections:
+```typescript
+const meta = validateModelSchema(
+  model,
+  'forward',
+  [SymbolicTensor('float32', [1, 3, 'H', 'W'], [3, 'H', 'W'])],
+  [
+    SymbolicTensor('float32', ['N', 4]), // Bounding boxes (xyxy / xywh)
+    SymbolicTensor('float32', ['N']),    // Prediction confidence scores
+    SymbolicTensor('float32', ['N']),    // Predicted class labels
+  ]
+);
+```
+
+---
+
+## 🚫 Avoid / Anti-Patterns
+
+* **Do NOT write imperative size/type checks manually:** Avoid writing custom shape/type assertion blocks (e.g., `if (tensor.shape[0] !== 1)`). Always use the declarative `validateModelSchema` utility, which reports unified, readable mismatch errors.
+* **Do NOT use hardcoded integers for dynamic dimensions:** If a shape can vary (e.g., dynamic height, width, or batch sizes), use a string symbol (like `'H'`, `'W'`, `'N'`) to allow dynamic matching.
+* **Do NOT skip validation at startup:** Always validate the model schema *before* creating pre-allocated static tensors, preventing native memory crashes from mismatched layouts.
+
+---
+
+## 📋 Verification Checklist
+
+When specifying model schema validations, verify that:
+- [ ] Schema validation is performed immediately after model loading and before tensor initialization.
+- [ ] All dynamic dimensions (e.g., dynamic box counts, channels-last heights/widths) are defined as string symbols.
+- [ ] Multiple shape variations are provided to `SymbolicTensor` if channels-first and channels-last layouts are both supported.
+- [ ] Input and output constraints map accurately to standard model specifications (e.g. dense logits, standard bounding boxes layouts).
diff --git a/.agents/skills/verify-and-build/SKILL.md b/.agents/skills/verify-and-build/SKILL.md
new file mode 100644
index 0000000000..0fc3cf3ae6
--- /dev/null
+++ b/.agents/skills/verify-and-build/SKILL.md
@@ -0,0 +1,148 @@
+---
+name: verify-and-build
+description: Use when compiling TS/C++, rebuilding iOS pods, troubleshooting JSI runtime errors, debugging native crashes, or sync'ing Android Gradle.
+metadata:
+  id: verify_and_build
+  scope: general development, example/
+---
+
+# Skill: Verification, Compilation & Troubleshooting
+
+Use this guide to compile, test, verify, and troubleshoot your modifications to the library (both JS/TS and native C++).
+
+---
+
+## 🛠️ Verification & Compilation Workflows
+
+### 1. Build and Typecheck TypeScript
+To check types and compile the TypeScript source code:
+* **Verify Types (Fast)**:
+  ```bash
+  yarn typecheck
+  ```
+* **Build Bundles**:
+  ```bash
+  yarn prepare
+  ```
+  *This cleans target directories and builds modules into the `lib/` directory using `react-native-builder-bob`.*
+* **When**: After adding/updating TypeScript files under `src/`.
+* **Verification**: Ensure no compiler or type-checking errors are raised.
+
+### 2. Native Rebuilding
+
+#### iOS Development
+Whenever you modify native files under `cpp/` or update `.podspec`:
+```bash
+cd example/ios && pod install && cd ../..
+```
+* **Rebuilding**: Re-run the app from the root workspace or from the `example/` folder:
+  ```bash
+  # From root:
+  yarn example ios
+  # OR from example/ directory:
+  yarn ios
+  ```
+* **Clean Build**: If files aren't being picked up:
+  * In Xcode: `Product` > `Clean Build Folder` (Cmd + Shift + K).
+
+#### Android Development
+Android compiles C++ source files on-demand during application builds:
+```bash
+# From root:
+yarn example android
+# OR from example/ directory:
+yarn android
+```
+* **Clean Build**: If caching issues occur:
+  ```bash
+  cd android && ./gradlew clean && cd ..
+  ```
+
+---
+
+## 🔍 Debugging & Log Access
+
+### 1. TypeScript & Worklet Logging
+Logging inside worklets (functions annotated with `'worklet';`) behaves slightly differently as they run on a separate runtime thread.
+* Use standard `console.log(...)` inside worklets.
+* **Caution**: Worklet logs are piped back to the JS console, but passing complex circular objects to `console.log` from a worklet can fail or freeze. Stringify or log specific primitive properties instead.
+
+### 2. Native C++ Debugging
+Native JSI crashes, standard outputs, or ExecuTorch errors can be caught in the native log streams:
+* **iOS**: Watch outputs directly inside the Xcode Console while running the example target.
+* **Android**: Use Android Studio's logcat or run:
+  ```bash
+  adb logcat *:S ReactNative:V ReactNativeJS:V rnexecutorch:V
+  ```
+
+---
+
+## 🚦 Common JSI Troubleshooting
+
+### Symptom: `Error: JSI global object '__rnexecutorch_jsi__' is not registered.`
+* **Cause 1**: The native code wasn't linked or JSI installation failed during loading.
+  * *Fix*: Verify that you have registered your new extension/module in [cpp/RnExecutorch.cpp](../cpp/RnExecutorch.cpp).
+  * *Fix*: Re-run `pod install` (for iOS) or perform a Gradle sync/clean (for Android) to ensure your C++ changes compiled.
+* **Cause 2**: The bridge did not invoke the native installation.
+  * *Fix*: Ensure the JS entrypoint triggers the load (see [src/native/bridge.ts](../src/native/bridge.ts)).
+
+### Symptom: `TypeError: Cannot read property '<extension>' of undefined`
+* **Cause**: You added an extension in C++ but forgot to register it in your TypeScript bridge bindings.
+  * *Fix*: Check that `module.setProperty(rt, "<extension>", subModule)` is called in your native `install.cpp` and that your TS wrapper exports and references it under `rnexecutorchJsi.<extension>`.
+
+---
+
+## 📂 Model Hosting & Download Caching
+
+This project does **not** bundle local `.pte` model files inside the React Native application package. Instead, the standard workflow is:
+
+1. **Upload to Hugging Face**:
+   * Upload compiled/exported `.pte` models directly to our Hugging Face repository bucket.
+   * **Naming Convention**: All `.pte` files must follow the strict name contract:
+     `modelname_optionalsize_backend_precision.pte`
+     * *Example*: `efficientnet_v2_s_xnnpack_int8.pte`
+     * *Example*: `style_transfer_candy_xnnpack_fp32.pte`
+
+2. **Define in Models Manifest** ([src/models.ts](../src/models.ts)):
+   * **Single Export Registry Rule**: Define the new model configuration as an internal (private) `const` inside `models.ts`. **Do not** export individual model configuration constants. Instead, expose them solely by registering them under the appropriate category nested inside the main `models` registry object, which is the only exported symbol from `models.ts`.
+   * *Example*:
+     ```typescript
+     // Defined internally (private)
+     const MY_MODEL_XNNPACK_FP32: MyTaskModel = { ... };
+
+     // Registered in the exported models object
+     export const models = {
+       ...
+       myTask: {
+         MY_MODEL: {
+           XNNPACK_FP32: MY_MODEL_XNNPACK_FP32,
+         }
+       }
+     };
+     ```
+
+3. **Runtime Downloading & Caching**:
+   * The custom hook `useModelDownload(config.modelPath)` handles checks automatically:
+     * If the model file is not already in the device cache directory, it downloads it from the Hugging Face URL to `RNFS.CachesDirectoryPath`.
+     * If the model file exists in the cache, it bypasses the download and returns the cached local path immediately to load the model.
+
+---
+
+## 🚫 Avoid / Anti-Patterns
+
+* **Do NOT run code without verification:** Do not test TypeScript changes in the example app without first running `yarn typecheck` (verify types) and `yarn prepare` (build target bundles).
+* **Do NOT skip native rebuilds after C++ edits:** If any C++ files or config bindings are added/modified, do not attempt to run the app without executing `pod install` (for iOS) or letting Gradle sync (for Android).
+* **Do NOT log complex objects inside worklets:** Avoid passing complex circular objects directly to `console.log()` inside functions annotated with `'worklet';` as it can hang or crash the worklet runtime thread.
+* **Do NOT bundle local `.pte` files in the repository:** Do not commit heavy model binaries to the git repository. Always host them on Hugging Face and register their metadata in `src/models.ts`.
+
+---
+
+## 📋 Verification Checklist
+
+When verifying or compiling your modifications, check that:
+- [ ] TypeScript typechecking passes without errors (`yarn typecheck`).
+- [ ] Bundles compile successfully (`yarn prepare`).
+- [ ] `pod install` has been run inside `example/ios/` after any native C++ edits.
+- [ ] No `.pte` files are staged or added to git history.
+- [ ] Model configurations are registered inside the single `models` object registry in `src/models.ts`.
+- [ ] Native runtime issues have been investigated using Xcode Console or `adb logcat`.
diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000000..1598380163
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,16 @@
+# clang-format configuration for the react-native-executorch C/C++/Objective-C
+# sources. LLVM-based with attached braces, 4-space indentation, and no fixed
+# column limit: clang-format's aggressive wrapping to satisfy a column limit
+# tends to produce awkward, less-readable breaks, so developers handle line
+# breaks for long lines manually. See issue #1217 and the PR #1256 discussion.
+BasedOnStyle: LLVM
+Standard: c++20
+UseTab: Never
+IndentWidth: 4
+TabWidth: 4
+ColumnLimit: 0
+AccessModifierOffset: -4
+AllowShortIfStatementsOnASingleLine: false
+IndentCaseLabels: false
+FixNamespaceComments: false
+InsertNewlineAtEOF: true
diff --git a/.cspell-wordlist.txt b/.cspell-wordlist.txt
index 3837e96955..bba6f6b6dd 100644
--- a/.cspell-wordlist.txt
+++ b/.cspell-wordlist.txt
@@ -132,6 +132,12 @@ detr
 metaprogramming
 ktlint
 lefthook
+dtype
+numel
+metas
+Metas
+ndim
+nbytes
 espeak
 KOMODO
 DUNGENESS
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index a06b1c5f58..880570040f 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -4,7 +4,6 @@ updates:
     directories:
       - "/"
       - "/packages/*"
-      - "/apps/*"
       - "/docs"
     schedule:
       interval: "monthly"
diff --git a/.github/workflows/build-android-llm-example.yml b/.github/workflows/build-android-llm-example.yml
deleted file mode 100644
index 3b4c95bf58..0000000000
--- a/.github/workflows/build-android-llm-example.yml
+++ /dev/null
@@ -1,79 +0,0 @@
-name: LLM Example app Android build check
-on:
-  pull_request:
-    paths:
-      - .github/workflows/build-android-llm-example.yml
-      - apps/llm/**
-      - packages/react-native-executorch/**
-  push:
-    branches:
-      - main
-    paths:
-      - .github/workflows/build-android-llm-example.yml
-      - apps/llm/**
-      - packages/react-native-executorch/**
-  workflow_dispatch:
-jobs:
-  build:
-    if: github.repository == 'software-mansion/react-native-executorch'
-    runs-on: ubuntu-latest
-    env:
-      WORKING_DIRECTORY: apps/llm
-    concurrency:
-      group: android-${{ github.ref }}
-      cancel-in-progress: true
-    steps:
-      - name: Free Disk Space (Manual)
-        run: |
-          sudo rm -rf /usr/share/dotnet
-          sudo rm -rf /opt/ghc
-          sudo rm -rf /opt/hostedtoolcache/CodeQL
-          sudo docker system prune -af
-
-      - name: Check out Git repository
-        uses: actions/checkout@v6
-        with:
-          submodules: recursive
-      - name: Setup Node.js
-        uses: actions/setup-node@v6
-        with:
-          node-version: "24"
-          cache: "yarn"
-      - name: Setup Java 17
-        uses: actions/setup-java@v5
-        with:
-          distribution: "zulu"
-          java-version: 17
-          cache: "gradle"
-      - name: Install root dependencies
-        run: yarn install --immutable
-      - name: Install Expo CLI
-        run: |
-          npm install -g @expo/cli
-          echo "$(npm prefix -g)/bin" >> $GITHUB_PATH
-      - name: Generate native Android project
-        working-directory: ${{ env.WORKING_DIRECTORY }}
-        run: |
-          rm -rf android
-          npx expo prebuild --platform android --no-install
-      - name: Cache Gradle
-        uses: actions/cache@v5
-        with:
-          path: |
-            ~/.gradle/caches
-            ~/.gradle/wrapper
-            ${{ env.WORKING_DIRECTORY }}/android/.gradle
-          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
-          restore-keys: |
-            ${{ runner.os }}-gradle-
-      - name: Build app
-        working-directory: ${{ env.WORKING_DIRECTORY }}/android
-        run: |
-          ./gradlew assembleDebug \
-            --build-cache \
-            --parallel \
-            --daemon \
-            --configure-on-demand \
-            -PreactNativeArchitectures=arm64-v8a \
-            -Dorg.gradle.jvmargs="-Xmx4g -XX:+HeapDumpOnOutOfMemoryError" \
-            -Dorg.gradle.workers.max=4
diff --git a/.github/workflows/build-ios-llm-example.yml b/.github/workflows/build-ios-llm-example.yml
deleted file mode 100644
index 4a2b2b9b99..0000000000
--- a/.github/workflows/build-ios-llm-example.yml
+++ /dev/null
@@ -1,66 +0,0 @@
-name: LLM Example app iOS build check
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - ".github/workflows/build-ios-llm-example.yml"
-      - "*.podspec"
-      - "apps/llm/**"
-      - "packages/react-native-executorch/**"
-  pull_request:
-    paths:
-      - ".github/workflows/build-ios-llm-example.yml"
-      - "*.podspec"
-      - "apps/llm/**"
-      - "packages/react-native-executorch/**"
-  workflow_dispatch:
-jobs:
-  build:
-    if: github.repository == 'software-mansion/react-native-executorch'
-    runs-on: macos-latest
-    concurrency:
-      group: ios-${{ github.ref }}
-      cancel-in-progress: true
-    steps:
-      - uses: maxim-lobanov/setup-xcode@v1
-        with:
-          xcode-version: latest-stable
-      - name: Check out Git repository
-        uses: actions/checkout@v6
-        with:
-          submodules: recursive
-      - name: Setup Node.js
-        uses: actions/setup-node@v6
-        with:
-          node-version: "24"
-          cache: "yarn"
-      - name: Install root dependencies
-        run: yarn install --immutable
-      - name: Install Expo CLI
-        run: |
-          npm install -g @expo/cli
-          echo "$(npm prefix -g)/bin" >> $GITHUB_PATH
-      - name: Generate native iOS project
-        working-directory: apps/llm
-        run: |
-          rm -rf ios
-          npx expo prebuild --platform ios --no-install
-      - name: Install CocoaPods dependencies
-        working-directory: apps/llm/ios
-        run: |
-          pod install
-      - name: Build app
-        working-directory: apps/llm/ios
-        run: |
-          set -o pipefail && xcodebuild \
-            -workspace llm.xcworkspace \
-            -scheme llm \
-            -sdk iphonesimulator \
-            -configuration Debug \
-            -destination 'platform=iOS Simulator,name=iPhone 16 Pro' \
-            build \
-            CODE_SIGNING_ALLOWED=NO \
-            -jobs $(sysctl -n hw.ncpu) \
-            COMPILER_INDEX_STORE_ENABLE=NO \
-            ONLY_ACTIVE_ARCH=YES | xcbeautify
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a02381a3b8..bc595841d3 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -3,9 +3,11 @@ on:
   push:
     branches:
       - main
+      - rne-rewrite
   pull_request:
     branches:
       - main
+      - rne-rewrite
   merge_group:
     types:
       - checks_requested
@@ -24,15 +26,7 @@ jobs:
         run: yarn lint
 
       - name: Typecheck files
-        run: yarn workspaces foreach --all --topological-dev run prepare && yarn typecheck
-
-      - name: Verify error codes are up to date
-        run: |
-          yarn codegen:errors
-          git diff --exit-code -- \
-            packages/react-native-executorch/src/errors/ErrorCodes.ts \
-            packages/react-native-executorch/common/rnexecutorch/ErrorCodes.h \
-            || { echo "::error::Error codes are stale. Run 'yarn codegen:errors' and commit the result."; exit 1; }
+        run: yarn workspaces foreach --all --exclude react-native-executorch-bare-resource-fetcher --exclude react-native-executorch-expo-resource-fetcher --exclude react-native-executorch-webrtc --topological-dev run prepare && yarn typecheck
 
   build-library:
     runs-on: ubuntu-latest
@@ -44,4 +38,4 @@ jobs:
         uses: ./.github/actions/setup
 
       - name: Build all packages
-        run: yarn workspaces foreach --all --topological-dev run prepare
+        run: yarn workspaces foreach --all --exclude react-native-executorch-bare-resource-fetcher --exclude react-native-executorch-expo-resource-fetcher --exclude react-native-executorch-webrtc --topological-dev run prepare
diff --git a/.gitignore b/.gitignore
index 86ce3a9042..9595a23273 100644
--- a/.gitignore
+++ b/.gitignore
@@ -88,22 +88,18 @@ lib/
 ios/generated
 android/generated
 apps/*/ios/
-!apps/bare_rn/ios/
 apps/*/android/
-!apps/bare_rn/android/
 
 # generated TypeDoc API reference (regenerated at build time)
 docs/docs/06-api-reference/
 
-# integration test model assets
-packages/react-native-executorch/common/rnexecutorch/tests/integration/assets/models/
-
 # custom
 *.tgz
 Makefile
 *.pte
 
-.agents
+.agents/*
+!.agents/skills/
 .claude
 skills-lock.json
 
diff --git a/apps/bare-rn/.bundle/config b/apps/bare-rn/.bundle/config
deleted file mode 100644
index 848943bb52..0000000000
--- a/apps/bare-rn/.bundle/config
+++ /dev/null
@@ -1,2 +0,0 @@
-BUNDLE_PATH: "vendor/bundle"
-BUNDLE_FORCE_RUBY_PLATFORM: 1
diff --git a/apps/bare-rn/.eslintrc.js b/apps/bare-rn/.eslintrc.js
deleted file mode 100644
index 1d1d89f4b4..0000000000
--- a/apps/bare-rn/.eslintrc.js
+++ /dev/null
@@ -1,7 +0,0 @@
-module.exports = {
-  root: true,
-  extends: '@react-native',
-  parserOptions: {
-    requireConfigFile: false,
-  },
-};
diff --git a/apps/bare-rn/.gitignore b/apps/bare-rn/.gitignore
deleted file mode 100644
index 874daf3051..0000000000
--- a/apps/bare-rn/.gitignore
+++ /dev/null
@@ -1,80 +0,0 @@
-# OSX
-#
-.DS_Store
-
-# Xcode
-#
-build/
-*.pbxuser
-!default.pbxuser
-*.mode1v3
-!default.mode1v3
-*.mode2v3
-!default.mode2v3
-*.perspectivev3
-!default.perspectivev3
-xcuserdata
-*.xccheckout
-*.moved-aside
-DerivedData
-*.hmap
-*.ipa
-*.xcuserstate
-**/.xcode.env.local
-
-# Android/IntelliJ
-#
-build/
-.idea
-.gradle
-local.properties
-*.iml
-*.hprof
-.cxx/
-*.keystore
-!debug.keystore
-.kotlin/
-
-# node.js
-#
-node_modules/
-npm-debug.log
-yarn-error.log
-
-# fastlane
-#
-# It is recommended to not store the screenshots in the git repo. Instead, use fastlane to re-generate the
-# screenshots whenever they are needed.
-# For more information about the recommended setup visit:
-# https://docs.fastlane.tools/best-practices/source-control/
-
-**/fastlane/report.xml
-**/fastlane/Preview.html
-**/fastlane/screenshots
-**/fastlane/test_output
-
-# Bundle artifact
-*.jsbundle
-
-# Ruby / CocoaPods
-**/Pods/
-/vendor/bundle/
-
-# Temporary files created by Metro to check the health of the file watcher
-.metro-health-check*
-
-# testing
-/coverage
-
-# Yarn
-.yarn/*
-!.yarn/patches
-!.yarn/plugins
-!.yarn/releases
-!.yarn/sdks
-!.yarn/versions
-
-# Custom
-!/ios/
-!/android/
-/assets/ai-models/
diff --git a/apps/bare-rn/.prettierrc.js b/apps/bare-rn/.prettierrc.js
deleted file mode 100644
index 06860c8d1b..0000000000
--- a/apps/bare-rn/.prettierrc.js
+++ /dev/null
@@ -1,5 +0,0 @@
-module.exports = {
-  arrowParens: 'avoid',
-  singleQuote: true,
-  trailingComma: 'all',
-};
diff --git a/apps/bare-rn/.watchmanconfig b/apps/bare-rn/.watchmanconfig
deleted file mode 100644
index 0967ef424b..0000000000
--- a/apps/bare-rn/.watchmanconfig
+++ /dev/null
@@ -1 +0,0 @@
-{}
diff --git a/apps/bare-rn/App.tsx b/apps/bare-rn/App.tsx
deleted file mode 100644
index cb6af0aa33..0000000000
--- a/apps/bare-rn/App.tsx
+++ /dev/null
@@ -1,405 +0,0 @@
-import React, { useEffect, useRef, useState } from 'react';
-import {
-  ActivityIndicator,
-  Keyboard,
-  KeyboardAvoidingView,
-  Modal,
-  Platform,
-  ScrollView,
-  StyleSheet,
-  Text,
-  TextInput,
-  TouchableOpacity,
-  TouchableWithoutFeedback,
-  View,
-} from 'react-native';
-import { models, initExecutorch, useLLM } from 'react-native-executorch';
-import { BareResourceFetcher } from 'react-native-executorch-bare-resource-fetcher';
-import { setConfig } from '@kesha-antonov/react-native-background-downloader';
-import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
-
-// Configure Background Downloader logging
-setConfig({
-  isLogsEnabled: true,
-  logCallback: log => {
-    console.log('[BackgroundDownloader]', log);
-  },
-});
-
-// Initialize Executorch with bare adapter
-initExecutorch({
-  resourceFetcher: BareResourceFetcher,
-});
-
-const ColorPalette = {
-  primary: '#001A72',
-  blueLight: '#C1C6E5',
-  blueDark: '#6676AA',
-  white: '#FFFFFF',
-  gray100: '#F5F5F5',
-  gray200: '#E0E0E0',
-};
-
-function Spinner({
-  visible,
-  textContent,
-}: {
-  visible: boolean;
-  textContent: string;
-}) {
-  return (
-    <Modal transparent={true} animationType="fade" visible={visible}>
-      <View style={spinnerStyles.overlay}>
-        <View style={spinnerStyles.container}>
-          <ActivityIndicator size="large" color="#FFFFFF" />
-          <Text style={spinnerStyles.text}>{textContent}</Text>
-        </View>
-      </View>
-    </Modal>
-  );
-}
-
-const spinnerStyles = StyleSheet.create({
-  overlay: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-    backgroundColor: 'rgba(0, 0, 0, 0.5)',
-  },
-  container: {
-    padding: 25,
-    alignItems: 'center',
-    justifyContent: 'center',
-  },
-  text: {
-    marginTop: 15,
-    color: ColorPalette.white,
-    fontSize: 18,
-    fontWeight: 'bold',
-  },
-});
-
-function ErrorBanner({
-  message,
-  onDismiss,
-}: {
-  message: string | null;
-  onDismiss: () => void;
-}) {
-  if (!message) return null;
-  return (
-    <View style={errorBannerStyles.container}>
-      <Text style={errorBannerStyles.message} numberOfLines={3}>
-        {message}
-      </Text>
-      <TouchableOpacity
-        onPress={onDismiss}
-        style={errorBannerStyles.closeButton}
-      >
-        <Text style={errorBannerStyles.closeText}>✕</Text>
-      </TouchableOpacity>
-    </View>
-  );
-}
-
-const errorBannerStyles = StyleSheet.create({
-  container: {
-    backgroundColor: '#FEE2E2',
-    borderLeftWidth: 4,
-    borderLeftColor: '#EF4444',
-    borderRadius: 8,
-    marginHorizontal: 16,
-    marginVertical: 8,
-    paddingVertical: 10,
-    paddingLeft: 12,
-    paddingRight: 8,
-    flexDirection: 'row',
-    alignItems: 'center',
-  },
-  message: {
-    flex: 1,
-    color: '#991B1B',
-    fontSize: 14,
-    lineHeight: 20,
-  },
-  closeButton: {
-    padding: 4,
-    marginLeft: 8,
-  },
-  closeText: {
-    color: '#991B1B',
-    fontSize: 16,
-    fontWeight: '600',
-  },
-});
-
-function App() {
-  const [userInput, setUserInput] = useState('');
-  const [isTextInputFocused, setIsTextInputFocused] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-  const textInputRef = useRef<TextInput>(null);
-  const scrollViewRef = useRef<ScrollView>(null);
-
-  const llm = useLLM({
-    model: models.llm.lfm2_5_1_2b_instruct(),
-  });
-  // Alternatively, to use a custom local model, uncomment below:
-  // const llm = useLLM({ model: {
-  //   modelSource: require('./assets/ai-models/smolLm2/smolLm2_135M/smolLm2_135M_bf16.pte'),
-  //   tokenizerSource: require('./assets/ai-models/smolLm2/tokenizer.json'),
-  //   tokenizerConfigSource: require('./assets/ai-models/smolLm2/tokenizer_config.json'),
-  // } });
-
-  useEffect(() => {
-    if (llm.error) setError(String(llm.error));
-  }, [llm.error]);
-
-  const sendMessage = async () => {
-    if (!userInput.trim()) return;
-
-    setUserInput('');
-    textInputRef.current?.clear();
-    try {
-      await llm.sendMessage(userInput);
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-    }
-  };
-
-  return (
-    <SafeAreaProvider>
-      <KeyboardAvoidingView
-        style={styles.container}
-        behavior={Platform.OS === 'ios' ? 'padding' : undefined}
-        keyboardVerticalOffset={Platform.OS === 'ios' ? 100 : 0}
-      >
-        <Spinner
-          visible={!llm.isReady && !llm.error}
-          textContent={`Loading model ${(llm.downloadProgress * 100).toFixed(0)}%`}
-        />
-
-        <SafeAreaView style={styles.content}>
-          <ErrorBanner message={error} onDismiss={() => setError(null)} />
-          {llm.messageHistory.length > 0 || llm.isGenerating ? (
-            <ScrollView
-              ref={scrollViewRef}
-              style={styles.chatContainer}
-              contentContainerStyle={styles.chatContent}
-              onContentSizeChange={() =>
-                scrollViewRef.current?.scrollToEnd({ animated: true })
-              }
-              keyboardShouldPersistTaps="handled"
-            >
-              {llm.messageHistory.map((message, index) => (
-                <View
-                  key={index}
-                  style={[
-                    styles.messageBubble,
-                    message.role === 'user'
-                      ? styles.userMessage
-                      : styles.aiMessage,
-                  ]}
-                >
-                  <Text
-                    style={[
-                      styles.messageText,
-                      message.role === 'user'
-                        ? styles.userMessageText
-                        : styles.aiMessageText,
-                    ]}
-                  >
-                    {message.content}
-                  </Text>
-                </View>
-              ))}
-              {llm.isGenerating && llm.response && (
-                <View style={[styles.messageBubble, styles.aiMessage]}>
-                  <Text style={styles.aiMessageText}>{llm.response}</Text>
-                  <ActivityIndicator
-                    size="small"
-                    color={ColorPalette.primary}
-                  />
-                </View>
-              )}
-            </ScrollView>
-          ) : (
-            <TouchableWithoutFeedback onPress={Keyboard.dismiss}>
-              <View style={styles.welcomeContainer}>
-                <Text style={styles.welcomeTitle}>Hello! 👋</Text>
-                <Text style={styles.welcomeSubtitle}>
-                  What can I help you with?
-                </Text>
-                <View style={styles.suggestionsContainer}>
-                  {[
-                    'Explain quantum computing in simple terms',
-                    'Write a short poem about coding',
-                    'What are the benefits of on-device AI?',
-                    'Give me 3 fun facts about space',
-                  ].map((prompt, i) => (
-                    <TouchableOpacity
-                      key={i}
-                      style={styles.suggestionChip}
-                      onPress={() => setUserInput(prompt)}
-                    >
-                      <Text style={styles.suggestionChipText}>{prompt}</Text>
-                    </TouchableOpacity>
-                  ))}
-                </View>
-              </View>
-            </TouchableWithoutFeedback>
-          )}
-
-          <View style={styles.inputContainer}>
-            <TextInput
-              ref={textInputRef}
-              style={[
-                styles.textInput,
-                {
-                  borderColor: isTextInputFocused
-                    ? ColorPalette.blueDark
-                    : ColorPalette.blueLight,
-                },
-              ]}
-              placeholder="Your message"
-              placeholderTextColor={ColorPalette.blueLight}
-              multiline
-              onFocus={() => setIsTextInputFocused(true)}
-              onBlur={() => setIsTextInputFocused(false)}
-              onChangeText={setUserInput}
-              value={userInput}
-            />
-            {userInput.trim() && !llm.isGenerating && (
-              <View style={styles.sendButton}>
-                <Text style={styles.sendButtonText} onPress={sendMessage}>
-                  Send
-                </Text>
-              </View>
-            )}
-            {llm.isGenerating && (
-              <View style={styles.sendButton}>
-                <Text style={styles.sendButtonText} onPress={llm.interrupt}>
-                  Stop
-                </Text>
-              </View>
-            )}
-          </View>
-        </SafeAreaView>
-      </KeyboardAvoidingView>
-    </SafeAreaProvider>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    backgroundColor: ColorPalette.white,
-  },
-  content: {
-    flex: 1,
-  },
-  chatContainer: {
-    flex: 1,
-    width: '100%',
-  },
-  chatContent: {
-    padding: 16,
-    flexGrow: 1,
-  },
-  welcomeContainer: {
-    flex: 1,
-    alignItems: 'center',
-    justifyContent: 'center',
-    padding: 20,
-  },
-  welcomeTitle: {
-    fontSize: 32,
-    fontWeight: 'bold',
-    color: ColorPalette.primary,
-    marginBottom: 12,
-  },
-  welcomeSubtitle: {
-    fontSize: 18,
-    color: ColorPalette.blueDark,
-    textAlign: 'center',
-  },
-  suggestionsContainer: {
-    flexDirection: 'row',
-    flexWrap: 'wrap',
-    justifyContent: 'center',
-    gap: 8,
-    paddingTop: 16,
-  },
-  suggestionChip: {
-    borderWidth: 1,
-    borderColor: ColorPalette.blueLight,
-    borderRadius: 20,
-    paddingHorizontal: 14,
-    paddingVertical: 8,
-    backgroundColor: '#fafbff',
-  },
-  suggestionChipText: {
-    fontSize: 13,
-    color: ColorPalette.primary,
-  },
-  messageBubble: {
-    maxWidth: '80%',
-    padding: 12,
-    borderRadius: 16,
-    marginBottom: 8,
-  },
-  userMessage: {
-    alignSelf: 'flex-end',
-    backgroundColor: ColorPalette.primary,
-  },
-  aiMessage: {
-    alignSelf: 'flex-start',
-    backgroundColor: ColorPalette.gray100,
-    borderWidth: 1,
-    borderColor: ColorPalette.gray200,
-  },
-  messageText: {
-    fontSize: 15,
-    lineHeight: 20,
-  },
-  userMessageText: {
-    color: ColorPalette.white,
-  },
-  aiMessageText: {
-    color: ColorPalette.primary,
-  },
-  inputContainer: {
-    flexDirection: 'row',
-    padding: 16,
-    borderTopWidth: 1,
-    borderTopColor: ColorPalette.gray200,
-    alignItems: 'flex-end',
-    backgroundColor: ColorPalette.white,
-  },
-  textInput: {
-    flex: 1,
-    borderWidth: 1,
-    borderRadius: 20,
-    paddingHorizontal: 16,
-    paddingVertical: 10,
-    fontSize: 15,
-    color: ColorPalette.primary,
-    maxHeight: 100,
-    marginRight: 8,
-  },
-  sendButton: {
-    backgroundColor: ColorPalette.primary,
-    paddingHorizontal: 20,
-    paddingVertical: 10,
-    borderRadius: 20,
-    minWidth: 70,
-    alignItems: 'center',
-    justifyContent: 'center',
-  },
-  sendButtonText: {
-    color: ColorPalette.white,
-    fontSize: 16,
-    fontWeight: '600',
-  },
-});
-
-export default App;
diff --git a/apps/bare-rn/Gemfile b/apps/bare-rn/Gemfile
deleted file mode 100644
index c717940f18..0000000000
--- a/apps/bare-rn/Gemfile
+++ /dev/null
@@ -1,16 +0,0 @@
-source 'https://rubygems.org'
-
-# You may use http://rbenv.org/ or https://rvm.io/ to install and use this version
-ruby ">= 2.6.10"
-
-# Exclude problematic versions of cocoapods and activesupport that causes build failures.
-# CocoaPods >= 1.16.0 fixes Ruby 3.4 compatibility (kconv removal).
-gem 'cocoapods', '>= 1.16.2'
-gem 'activesupport', '>= 6.1.7.5', '!= 7.1.0'
-gem 'concurrent-ruby', '< 1.3.4'
-
-# Ruby 3.4.0 has removed some libraries from the standard library.
-gem 'bigdecimal'
-gem 'logger'
-gem 'benchmark'
-gem 'mutex_m'
diff --git a/apps/bare-rn/Gemfile.lock b/apps/bare-rn/Gemfile.lock
deleted file mode 100644
index 130a52d752..0000000000
--- a/apps/bare-rn/Gemfile.lock
+++ /dev/null
@@ -1,119 +0,0 @@
-GEM
-  remote: https://rubygems.org/
-  specs:
-    CFPropertyList (3.0.8)
-    activesupport (7.2.3.1)
-      base64
-      benchmark (>= 0.3)
-      bigdecimal
-      concurrent-ruby (~> 1.0, >= 1.3.1)
-      connection_pool (>= 2.2.5)
-      drb
-      i18n (>= 1.6, < 2)
-      logger (>= 1.4.2)
-      minitest (>= 5.1, < 6)
-      securerandom (>= 0.3)
-      tzinfo (~> 2.0, >= 2.0.5)
-    addressable (2.9.0)
-      public_suffix (>= 2.0.2, < 8.0)
-    algoliasearch (1.27.5)
-      httpclient (~> 2.8, >= 2.8.3)
-      json (>= 1.5.1)
-    atomos (0.1.3)
-    base64 (0.3.0)
-    benchmark (0.5.0)
-    bigdecimal (4.0.1)
-    claide (1.1.0)
-    cocoapods (1.16.2)
-      addressable (~> 2.8)
-      claide (>= 1.0.2, < 2.0)
-      cocoapods-core (= 1.16.2)
-      cocoapods-deintegrate (>= 1.0.3, < 2.0)
-      cocoapods-downloader (>= 2.1, < 3.0)
-      cocoapods-plugins (>= 1.0.0, < 2.0)
-      cocoapods-search (>= 1.0.0, < 2.0)
-      cocoapods-trunk (>= 1.6.0, < 2.0)
-      cocoapods-try (>= 1.1.0, < 2.0)
-      colored2 (~> 3.1)
-      escape (~> 0.0.4)
-      fourflusher (>= 2.3.0, < 3.0)
-      gh_inspector (~> 1.0)
-      molinillo (~> 0.8.0)
-      nap (~> 1.0)
-      ruby-macho (>= 2.3.0, < 3.0)
-      xcodeproj (>= 1.27.0, < 2.0)
-    cocoapods-core (1.16.2)
-      activesupport (>= 5.0, < 8)
-      addressable (~> 2.8)
-      algoliasearch (~> 1.0)
-      concurrent-ruby (~> 1.1)
-      fuzzy_match (~> 2.0.4)
-      nap (~> 1.0)
-      netrc (~> 0.11)
-      public_suffix (~> 4.0)
-      typhoeus (~> 1.0)
-    cocoapods-deintegrate (1.0.5)
-    cocoapods-downloader (2.1)
-    cocoapods-plugins (1.0.0)
-      nap
-    cocoapods-search (1.0.1)
-    cocoapods-trunk (1.6.0)
-      nap (>= 0.8, < 2.0)
-      netrc (~> 0.11)
-    cocoapods-try (1.2.0)
-    colored2 (3.1.2)
-    concurrent-ruby (1.3.3)
-    connection_pool (3.0.2)
-    drb (2.2.3)
-    escape (0.0.4)
-    ethon (0.15.0)
-      ffi (>= 1.15.0)
-    ffi (1.17.3)
-    fourflusher (2.3.1)
-    fuzzy_match (2.0.4)
-    gh_inspector (1.1.3)
-    httpclient (2.9.0)
-      mutex_m
-    i18n (1.14.8)
-      concurrent-ruby (~> 1.0)
-    json (2.19.2)
-    logger (1.7.0)
-    minitest (5.27.0)
-    molinillo (0.8.0)
-    mutex_m (0.3.0)
-    nanaimo (0.4.0)
-    nap (1.1.0)
-    netrc (0.11.0)
-    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)
-      concurrent-ruby (~> 1.0)
-    xcodeproj (1.27.0)
-      CFPropertyList (>= 2.3.3, < 4.0)
-      atomos (~> 0.1.3)
-      claide (>= 1.0.2, < 2.0)
-      colored2 (~> 3.1)
-      nanaimo (~> 0.4.0)
-      rexml (>= 3.3.6, < 4.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  activesupport (>= 6.1.7.5, != 7.1.0)
-  benchmark
-  bigdecimal
-  cocoapods (>= 1.16.2)
-  concurrent-ruby (< 1.3.4)
-  logger
-  mutex_m
-
-RUBY VERSION
-   ruby 3.4.5p51
-
-BUNDLED WITH
-   2.6.9
diff --git a/apps/bare-rn/__tests__/App.test.tsx b/apps/bare-rn/__tests__/App.test.tsx
deleted file mode 100644
index e532f701ee..0000000000
--- a/apps/bare-rn/__tests__/App.test.tsx
+++ /dev/null
@@ -1,13 +0,0 @@
-/**
- * @format
- */
-
-import React from 'react';
-import ReactTestRenderer from 'react-test-renderer';
-import App from '../App';
-
-test('renders correctly', async () => {
-  await ReactTestRenderer.act(() => {
-    ReactTestRenderer.create(<App />);
-  });
-});
diff --git a/apps/bare-rn/android/app/build.gradle b/apps/bare-rn/android/app/build.gradle
deleted file mode 100644
index b17658e36c..0000000000
--- a/apps/bare-rn/android/app/build.gradle
+++ /dev/null
@@ -1,119 +0,0 @@
-apply plugin: "com.android.application"
-apply plugin: "org.jetbrains.kotlin.android"
-apply plugin: "com.facebook.react"
-
-/**
- * This is the configuration block to customize your React Native Android app.
- * By default you don't need to apply any configuration, just uncomment the lines you need.
- */
-react {
-    /* Folders */
-    //   The root of your project, i.e. where "package.json" lives. Default is '../..'
-    root = file("../../")
-    //   The folder where the react-native NPM package is. Default is ../../node_modules/react-native
-    reactNativeDir = file("../../node_modules/react-native")
-    //   The folder where the react-native Codegen package is. Default is ../../node_modules/@react-native/codegen
-    codegenDir = file("../../node_modules/@react-native/codegen")
-    //   The cli.js file which is the React Native CLI entrypoint. Default is ../../node_modules/react-native/cli.js
-    cliFile = file("../../node_modules/react-native/cli.js")
-
-    /* Variants */
-    //   The list of variants to that are debuggable. For those we're going to
-    //   skip the bundling of the JS bundle and the assets. Default is "debug", "debugOptimized".
-    //   If you add flavors like lite, prod, etc. you'll have to list your debuggableVariants.
-    // debuggableVariants = ["liteDebug", "liteDebugOptimized", "prodDebug", "prodDebugOptimized"]
-
-    /* Bundling */
-    //   A list containing the node command and its flags. Default is just 'node'.
-    // nodeExecutableAndArgs = ["node"]
-    //
-    //   The command to run when bundling. By default is 'bundle'
-    // bundleCommand = "ram-bundle"
-    //
-    //   The path to the CLI configuration file. Default is empty.
-    // bundleConfig = file(../rn-cli.config.js)
-    //
-    //   The name of the generated asset file containing your JS bundle
-    // bundleAssetName = "MyApplication.android.bundle"
-    //
-    //   The entry file for bundle generation. Default is 'index.android.js' or 'index.js'
-    // entryFile = file("../js/MyApplication.android.js")
-    //
-    //   A list of extra flags to pass to the 'bundle' commands.
-    //   See https://github.com/react-native-community/cli/blob/main/docs/commands.md#bundle
-    // extraPackagerArgs = []
-
-    /* Hermes Commands */
-    //   The hermes compiler command to run. By default it is 'hermesc'
-    // hermesCommand = "$rootDir/my-custom-hermesc/bin/hermesc"
-    //
-    //   The list of flags to pass to the Hermes compiler. By default is "-O", "-output-source-map"
-    // hermesFlags = ["-O", "-output-source-map"]
-
-    /* Autolinking */
-    autolinkLibrariesWithApp()
-}
-
-/**
- * Set this to true to Run Proguard on Release builds to minify the Java bytecode.
- */
-def enableProguardInReleaseBuilds = false
-
-/**
- * The preferred build flavor of JavaScriptCore (JSC)
- *
- * For example, to use the international variant, you can use:
- * `def jscFlavor = io.github.react-native-community:jsc-android-intl:2026004.+`
- *
- * The international variant includes ICU i18n library and necessary data
- * allowing to use e.g. `Date.toLocaleString` and `String.localeCompare` that
- * give correct results when using with locales other than en-US. Note that
- * this variant is about 6MiB larger per architecture than default.
- */
-def jscFlavor = 'io.github.react-native-community:jsc-android:2026004.+'
-
-android {
-    ndkVersion rootProject.ext.ndkVersion
-    buildToolsVersion rootProject.ext.buildToolsVersion
-    compileSdk rootProject.ext.compileSdkVersion
-
-    namespace "com.barern"
-    defaultConfig {
-        applicationId "com.barern"
-        minSdkVersion rootProject.ext.minSdkVersion
-        targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 1
-        versionName "1.0"
-    }
-    signingConfigs {
-        debug {
-            storeFile file('debug.keystore')
-            storePassword 'android'
-            keyAlias 'androiddebugkey'
-            keyPassword 'android'
-        }
-    }
-    buildTypes {
-        debug {
-            signingConfig signingConfigs.debug
-        }
-        release {
-            // Caution! In production, you need to generate your own keystore file.
-            // see https://reactnative.dev/docs/signed-apk-android.
-            signingConfig signingConfigs.debug
-            minifyEnabled enableProguardInReleaseBuilds
-            proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"
-        }
-    }
-}
-
-dependencies {
-    // The version of react-native is set by the React Native Gradle Plugin
-    implementation("com.facebook.react:react-android")
-
-    if (hermesEnabled.toBoolean()) {
-        implementation("com.facebook.react:hermes-android")
-    } else {
-        implementation jscFlavor
-    }
-}
diff --git a/apps/bare-rn/android/app/debug.keystore b/apps/bare-rn/android/app/debug.keystore
deleted file mode 100644
index 364e105ed3..0000000000
Binary files a/apps/bare-rn/android/app/debug.keystore and /dev/null differ
diff --git a/apps/bare-rn/android/app/proguard-rules.pro b/apps/bare-rn/android/app/proguard-rules.pro
deleted file mode 100644
index 11b025724a..0000000000
--- a/apps/bare-rn/android/app/proguard-rules.pro
+++ /dev/null
@@ -1,10 +0,0 @@
-# Add project specific ProGuard rules here.
-# By default, the flags in this file are appended to flags specified
-# in /usr/local/Cellar/android-sdk/24.3.3/tools/proguard/proguard-android.txt
-# You can edit the include path and order by changing the proguardFiles
-# directive in build.gradle.
-#
-# For more details, see
-#   http://developer.android.com/guide/developing/tools/proguard.html
-
-# Add any project specific keep options here:
diff --git a/apps/bare-rn/android/app/src/main/AndroidManifest.xml b/apps/bare-rn/android/app/src/main/AndroidManifest.xml
deleted file mode 100644
index fb78f39746..0000000000
--- a/apps/bare-rn/android/app/src/main/AndroidManifest.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
-
-    <uses-permission android:name="android.permission.INTERNET" />
-
-    <application
-      android:name=".MainApplication"
-      android:label="@string/app_name"
-      android:icon="@mipmap/ic_launcher"
-      android:roundIcon="@mipmap/ic_launcher_round"
-      android:allowBackup="false"
-      android:theme="@style/AppTheme"
-      android:usesCleartextTraffic="${usesCleartextTraffic}"
-      android:supportsRtl="true">
-      <activity
-        android:name=".MainActivity"
-        android:label="@string/app_name"
-        android:configChanges="keyboard|keyboardHidden|orientation|screenLayout|screenSize|smallestScreenSize|uiMode"
-        android:launchMode="singleTask"
-        android:windowSoftInputMode="adjustResize"
-        android:exported="true">
-        <intent-filter>
-            <action android:name="android.intent.action.MAIN" />
-            <category android:name="android.intent.category.LAUNCHER" />
-        </intent-filter>
-      </activity>
-    </application>
-</manifest>
diff --git a/apps/bare-rn/android/app/src/main/java/com/barern/MainActivity.kt b/apps/bare-rn/android/app/src/main/java/com/barern/MainActivity.kt
deleted file mode 100644
index 7ee40e43b4..0000000000
--- a/apps/bare-rn/android/app/src/main/java/com/barern/MainActivity.kt
+++ /dev/null
@@ -1,20 +0,0 @@
-package com.barern
-
-import com.facebook.react.ReactActivity
-import com.facebook.react.ReactActivityDelegate
-import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint.fabricEnabled
-import com.facebook.react.defaults.DefaultReactActivityDelegate
-
-class MainActivity : ReactActivity() {
-  /**
-   * Returns the name of the main component registered from JavaScript. This is used to schedule
-   * rendering of the component.
-   */
-  override fun getMainComponentName(): String = "bare-rn"
-
-  /**
-   * Returns the instance of the [ReactActivityDelegate]. We use [DefaultReactActivityDelegate]
-   * which allows you to enable New Architecture with a single boolean flags [fabricEnabled]
-   */
-  override fun createReactActivityDelegate(): ReactActivityDelegate = DefaultReactActivityDelegate(this, mainComponentName, fabricEnabled)
-}
diff --git a/apps/bare-rn/android/app/src/main/java/com/barern/MainApplication.kt b/apps/bare-rn/android/app/src/main/java/com/barern/MainApplication.kt
deleted file mode 100644
index 39f296c224..0000000000
--- a/apps/bare-rn/android/app/src/main/java/com/barern/MainApplication.kt
+++ /dev/null
@@ -1,50 +0,0 @@
-package com.barern
-
-import android.app.Application
-import com.barern.BuildConfig
-import com.facebook.react.PackageList
-import com.facebook.react.ReactApplication
-import com.facebook.react.ReactHost
-import com.facebook.react.ReactNativeApplicationEntryPoint.loadReactNative
-import com.facebook.react.ReactNativeHost
-import com.facebook.react.defaults.DefaultReactHost.getDefaultReactHost
-import com.facebook.react.defaults.DefaultReactNativeHost
-import com.facebook.react.runtime.JSRuntimeFactory
-import com.facebook.react.runtime.hermes.HermesInstance
-
-class MainApplication :
-  Application(),
-  ReactApplication {
-  @Suppress("DEPRECATION")
-  override val reactNativeHost: ReactNativeHost by lazy {
-    object : DefaultReactNativeHost(this) {
-      override fun getPackages() =
-        PackageList(this).packages.apply {
-          // Packages that cannot be autolinked yet can be added manually here
-        }
-
-      override fun getJSMainModuleName() = "index"
-
-      override fun getUseDeveloperSupport() = BuildConfig.DEBUG
-
-      override val isNewArchEnabled: Boolean = true
-    }
-  }
-
-  override val reactHost: ReactHost by lazy {
-    getDefaultReactHost(
-      context = applicationContext,
-      packageList =
-        PackageList(this).packages.apply {
-          // Packages that cannot be autolinked yet can be added manually here
-        },
-      jsMainModulePath = "index",
-      jsRuntimeFactory = HermesInstance(),
-    )
-  }
-
-  override fun onCreate() {
-    super.onCreate()
-    loadReactNative(this)
-  }
-}
diff --git a/apps/bare-rn/android/app/src/main/res/drawable/rn_edit_text_material.xml b/apps/bare-rn/android/app/src/main/res/drawable/rn_edit_text_material.xml
deleted file mode 100644
index 5c25e728ea..0000000000
--- a/apps/bare-rn/android/app/src/main/res/drawable/rn_edit_text_material.xml
+++ /dev/null
@@ -1,37 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2014 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<inset xmlns:android="http://schemas.android.com/apk/res/android"
-       android:insetLeft="@dimen/abc_edit_text_inset_horizontal_material"
-       android:insetRight="@dimen/abc_edit_text_inset_horizontal_material"
-       android:insetTop="@dimen/abc_edit_text_inset_top_material"
-       android:insetBottom="@dimen/abc_edit_text_inset_bottom_material"
-       >
-
-    <selector>
-        <!--
-          This file is a copy of abc_edit_text_material (https://bit.ly/3k8fX7I).
-          The item below with state_pressed="false" and state_focused="false" causes a NullPointerException.
-          NullPointerException:tempt to invoke virtual method 'android.graphics.drawable.Drawable android.graphics.drawable.Drawable$ConstantState.newDrawable(android.content.res.Resources)'
-
-          <item android:state_pressed="false" android:state_focused="false" android:drawable="@drawable/abc_textfield_default_mtrl_alpha"/>
-
-          For more info, see https://bit.ly/3CdLStv (react-native/pull/29452) and https://bit.ly/3nxOMoR.
-        -->
-        <item android:state_enabled="false" android:drawable="@drawable/abc_textfield_default_mtrl_alpha"/>
-        <item android:drawable="@drawable/abc_textfield_activated_mtrl_alpha"/>
-    </selector>
-
-</inset>
diff --git a/apps/bare-rn/android/app/src/main/res/mipmap-hdpi/ic_launcher.png b/apps/bare-rn/android/app/src/main/res/mipmap-hdpi/ic_launcher.png
deleted file mode 100644
index a2f5908281..0000000000
Binary files a/apps/bare-rn/android/app/src/main/res/mipmap-hdpi/ic_launcher.png and /dev/null differ
diff --git a/apps/bare-rn/android/app/src/main/res/mipmap-hdpi/ic_launcher_round.png b/apps/bare-rn/android/app/src/main/res/mipmap-hdpi/ic_launcher_round.png
deleted file mode 100644
index 1b52399808..0000000000
Binary files a/apps/bare-rn/android/app/src/main/res/mipmap-hdpi/ic_launcher_round.png and /dev/null differ
diff --git a/apps/bare-rn/android/app/src/main/res/mipmap-mdpi/ic_launcher.png b/apps/bare-rn/android/app/src/main/res/mipmap-mdpi/ic_launcher.png
deleted file mode 100644
index ff10afd6e1..0000000000
Binary files a/apps/bare-rn/android/app/src/main/res/mipmap-mdpi/ic_launcher.png and /dev/null differ
diff --git a/apps/bare-rn/android/app/src/main/res/mipmap-mdpi/ic_launcher_round.png b/apps/bare-rn/android/app/src/main/res/mipmap-mdpi/ic_launcher_round.png
deleted file mode 100644
index 115a4c768a..0000000000
Binary files a/apps/bare-rn/android/app/src/main/res/mipmap-mdpi/ic_launcher_round.png and /dev/null differ
diff --git a/apps/bare-rn/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png b/apps/bare-rn/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png
deleted file mode 100644
index dcd3cd8083..0000000000
Binary files a/apps/bare-rn/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png and /dev/null differ
diff --git a/apps/bare-rn/android/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png b/apps/bare-rn/android/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png
deleted file mode 100644
index 459ca609d3..0000000000
Binary files a/apps/bare-rn/android/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png and /dev/null differ
diff --git a/apps/bare-rn/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png b/apps/bare-rn/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png
deleted file mode 100644
index 8ca12fe024..0000000000
Binary files a/apps/bare-rn/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png and /dev/null differ
diff --git a/apps/bare-rn/android/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png b/apps/bare-rn/android/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png
deleted file mode 100644
index 8e19b410a1..0000000000
Binary files a/apps/bare-rn/android/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png and /dev/null differ
diff --git a/apps/bare-rn/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png b/apps/bare-rn/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png
deleted file mode 100644
index b824ebdd48..0000000000
Binary files a/apps/bare-rn/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png and /dev/null differ
diff --git a/apps/bare-rn/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png b/apps/bare-rn/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png
deleted file mode 100644
index 4c19a13c23..0000000000
Binary files a/apps/bare-rn/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png and /dev/null differ
diff --git a/apps/bare-rn/android/app/src/main/res/values/strings.xml b/apps/bare-rn/android/app/src/main/res/values/strings.xml
deleted file mode 100644
index 6a435ace24..0000000000
--- a/apps/bare-rn/android/app/src/main/res/values/strings.xml
+++ /dev/null
@@ -1,3 +0,0 @@
-<resources>
-    <string name="app_name">bare_rn</string>
-</resources>
diff --git a/apps/bare-rn/android/app/src/main/res/values/styles.xml b/apps/bare-rn/android/app/src/main/res/values/styles.xml
deleted file mode 100644
index 7ba83a2ad5..0000000000
--- a/apps/bare-rn/android/app/src/main/res/values/styles.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-<resources>
-
-    <!-- Base application theme. -->
-    <style name="AppTheme" parent="Theme.AppCompat.DayNight.NoActionBar">
-        <!-- Customize your theme here. -->
-        <item name="android:editTextBackground">@drawable/rn_edit_text_material</item>
-    </style>
-
-</resources>
diff --git a/apps/bare-rn/android/build.gradle b/apps/bare-rn/android/build.gradle
deleted file mode 100644
index dad99b022a..0000000000
--- a/apps/bare-rn/android/build.gradle
+++ /dev/null
@@ -1,21 +0,0 @@
-buildscript {
-    ext {
-        buildToolsVersion = "36.0.0"
-        minSdkVersion = 24
-        compileSdkVersion = 36
-        targetSdkVersion = 36
-        ndkVersion = "27.1.12297006"
-        kotlinVersion = "2.1.20"
-    }
-    repositories {
-        google()
-        mavenCentral()
-    }
-    dependencies {
-        classpath("com.android.tools.build:gradle")
-        classpath("com.facebook.react:react-native-gradle-plugin")
-        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin")
-    }
-}
-
-apply plugin: "com.facebook.react.rootproject"
diff --git a/apps/bare-rn/android/gradle.properties b/apps/bare-rn/android/gradle.properties
deleted file mode 100644
index 9afe61598f..0000000000
--- a/apps/bare-rn/android/gradle.properties
+++ /dev/null
@@ -1,44 +0,0 @@
-# Project-wide Gradle settings.
-
-# IDE (e.g. Android Studio) users:
-# Gradle settings configured through the IDE *will override*
-# any settings specified in this file.
-
-# For more details on how to configure your build environment visit
-# http://www.gradle.org/docs/current/userguide/build_environment.html
-
-# Specifies the JVM arguments used for the daemon process.
-# The setting is particularly useful for tweaking memory settings.
-# Default value: -Xmx512m -XX:MaxMetaspaceSize=256m
-org.gradle.jvmargs=-Xmx2048m -XX:MaxMetaspaceSize=512m
-
-# When configured, Gradle will run in incubating parallel mode.
-# This option should only be used with decoupled projects. More details, visit
-# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
-# org.gradle.parallel=true
-
-# AndroidX package structure to make it clearer which packages are bundled with the
-# Android operating system, and which are packaged with your app's APK
-# https://developer.android.com/topic/libraries/support-library/androidx-rn
-android.useAndroidX=true
-
-# Use this property to specify which architecture you want to build.
-# You can also override it from the CLI using
-# ./gradlew <task> -PreactNativeArchitectures=x86_64
-reactNativeArchitectures=armeabi-v7a,arm64-v8a,x86,x86_64
-
-# Use this property to enable support to the new architecture.
-# This will allow you to use TurboModules and the Fabric render in
-# your application. You should enable this flag either if you want
-# to write custom TurboModules/Fabric components OR use libraries that
-# are providing them.
-newArchEnabled=true
-
-# Use this property to enable or disable the Hermes JS engine.
-# If set to false, you will be using JSC instead.
-hermesEnabled=true
-
-# Use this property to enable edge-to-edge display support.
-# This allows your app to draw behind system bars for an immersive UI.
-# Note: Only works with ReactActivity and should not be used with custom Activity.
-edgeToEdgeEnabled=false
diff --git a/apps/bare-rn/android/gradle/wrapper/gradle-wrapper.jar b/apps/bare-rn/android/gradle/wrapper/gradle-wrapper.jar
deleted file mode 100644
index 8bdaf60c75..0000000000
Binary files a/apps/bare-rn/android/gradle/wrapper/gradle-wrapper.jar and /dev/null differ
diff --git a/apps/bare-rn/android/gradle/wrapper/gradle-wrapper.properties b/apps/bare-rn/android/gradle/wrapper/gradle-wrapper.properties
deleted file mode 100644
index 2a84e188b8..0000000000
--- a/apps/bare-rn/android/gradle/wrapper/gradle-wrapper.properties
+++ /dev/null
@@ -1,7 +0,0 @@
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.0.0-bin.zip
-networkTimeout=10000
-validateDistributionUrl=true
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists
diff --git a/apps/bare-rn/android/gradlew b/apps/bare-rn/android/gradlew
deleted file mode 100755
index ef07e0162b..0000000000
--- a/apps/bare-rn/android/gradlew
+++ /dev/null
@@ -1,251 +0,0 @@
-#!/bin/sh
-
-#
-# Copyright © 2015 the original authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-# SPDX-License-Identifier: Apache-2.0
-#
-
-##############################################################################
-#
-#   Gradle start up script for POSIX generated by Gradle.
-#
-#   Important for running:
-#
-#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
-#       noncompliant, but you have some other compliant shell such as ksh or
-#       bash, then to run this script, type that shell name before the whole
-#       command line, like:
-#
-#           ksh Gradle
-#
-#       Busybox and similar reduced shells will NOT work, because this script
-#       requires all of these POSIX shell features:
-#         * functions;
-#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
-#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
-#         * compound commands having a testable exit status, especially «case»;
-#         * various built-in commands including «command», «set», and «ulimit».
-#
-#   Important for patching:
-#
-#   (2) This script targets any POSIX shell, so it avoids extensions provided
-#       by Bash, Ksh, etc; in particular arrays are avoided.
-#
-#       The "traditional" practice of packing multiple parameters into a
-#       space-separated string is a well documented source of bugs and security
-#       problems, so this is (mostly) avoided, by progressively accumulating
-#       options in "$@", and eventually passing that to Java.
-#
-#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
-#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
-#       see the in-line comments for details.
-#
-#       There are tweaks for specific operating systems such as AIX, CygWin,
-#       Darwin, MinGW, and NonStop.
-#
-#   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
-#       within the Gradle project.
-#
-#       You can find Gradle at https://github.com/gradle/gradle/.
-#
-##############################################################################
-
-# Attempt to set APP_HOME
-
-# Resolve links: $0 may be a link
-app_path=$0
-
-# Need this for daisy-chained symlinks.
-while
-    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
-    [ -h "$app_path" ]
-do
-    ls=$( ls -ld "$app_path" )
-    link=${ls#*' -> '}
-    case $link in             #(
-      /*)   app_path=$link ;; #(
-      *)    app_path=$APP_HOME$link ;;
-    esac
-done
-
-# This is normally unused
-# shellcheck disable=SC2034
-APP_BASE_NAME=${0##*/}
-# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD=maximum
-
-warn () {
-    echo "$*"
-} >&2
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-} >&2
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "$( uname )" in                #(
-  CYGWIN* )         cygwin=true  ;; #(
-  Darwin* )         darwin=true  ;; #(
-  MSYS* | MINGW* )  msys=true    ;; #(
-  NONSTOP* )        nonstop=true ;;
-esac
-
-CLASSPATH="\\\"\\\""
-
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD=$JAVA_HOME/jre/sh/java
-    else
-        JAVACMD=$JAVA_HOME/bin/java
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD=java
-    if ! command -v java >/dev/null 2>&1
-    then
-        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-fi
-
-# Increase the maximum file descriptors if we can.
-if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
-    case $MAX_FD in #(
-      max*)
-        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC2039,SC3045
-        MAX_FD=$( ulimit -H -n ) ||
-            warn "Could not query maximum file descriptor limit"
-    esac
-    case $MAX_FD in  #(
-      '' | soft) :;; #(
-      *)
-        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC2039,SC3045
-        ulimit -n "$MAX_FD" ||
-            warn "Could not set maximum file descriptor limit to $MAX_FD"
-    esac
-fi
-
-# Collect all arguments for the java command, stacking in reverse order:
-#   * args from the command line
-#   * the main class name
-#   * -classpath
-#   * -D...appname settings
-#   * --module-path (only if needed)
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if "$cygwin" || "$msys" ; then
-    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
-
-    JAVACMD=$( cygpath --unix "$JAVACMD" )
-
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    for arg do
-        if
-            case $arg in                                #(
-              -*)   false ;;                            # don't mess with options #(
-              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
-                    [ -e "$t" ] ;;                      #(
-              *)    false ;;
-            esac
-        then
-            arg=$( cygpath --path --ignore --mixed "$arg" )
-        fi
-        # Roll the args list around exactly as many times as the number of
-        # args, so each arg winds up back in the position where it started, but
-        # possibly modified.
-        #
-        # NB: a `for` loop captures its iteration list before it begins, so
-        # changing the positional parameters here affects neither the number of
-        # iterations, nor the values presented in `arg`.
-        shift                   # remove old arg
-        set -- "$@" "$arg"      # push replacement arg
-    done
-fi
-
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
-
-# Collect all arguments for the java command:
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
-#     and any embedded shellness will be escaped.
-#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
-#     treated as '${Hostname}' itself on the command line.
-
-set -- \
-        "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
-        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
-        "$@"
-
-# Stop when "xargs" is not available.
-if ! command -v xargs >/dev/null 2>&1
-then
-    die "xargs is not available"
-fi
-
-# Use "xargs" to parse quoted args.
-#
-# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
-#
-# In Bash we could simply go:
-#
-#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
-#   set -- "${ARGS[@]}" "$@"
-#
-# but POSIX shell has neither arrays nor command substitution, so instead we
-# post-process each arg (as a line of input to sed) to backslash-escape any
-# character that might be a shell metacharacter, then use eval to reverse
-# that process (while maintaining the separation between arguments), and wrap
-# the whole thing up as a single "set" statement.
-#
-# This will of course break if any of these variables contains a newline or
-# an unmatched quote.
-#
-
-eval "set -- $(
-        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
-        xargs -n1 |
-        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
-        tr '\n' ' '
-    )" '"$@"'
-
-exec "$JAVACMD" "$@"
diff --git a/apps/bare-rn/android/gradlew.bat b/apps/bare-rn/android/gradlew.bat
deleted file mode 100644
index dd2b8eedbd..0000000000
--- a/apps/bare-rn/android/gradlew.bat
+++ /dev/null
@@ -1,99 +0,0 @@
-@REM Copyright (c) Meta Platforms, Inc. and affiliates.
-@REM
-@REM This source code is licensed under the MIT license found in the
-@REM LICENSE file in the root directory of this source tree.
-
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-@rem SPDX-License-Identifier: Apache-2.0
-@rem
-
-@if "%DEBUG%"=="" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%"=="" set DIRNAME=.
-@rem This is normally unused
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if %ERRORLEVEL% equ 0 goto execute
-
-echo. 1>&2
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto execute
-
-echo. 1>&2
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
-
-goto fail
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=
-
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
-
-:end
-@rem End local scope for the variables with windows NT shell
-if %ERRORLEVEL% equ 0 goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-set EXIT_CODE=%ERRORLEVEL%
-if %EXIT_CODE% equ 0 set EXIT_CODE=1
-if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
-exit /b %EXIT_CODE%
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega
diff --git a/apps/bare-rn/android/settings.gradle b/apps/bare-rn/android/settings.gradle
deleted file mode 100644
index 56ad61524f..0000000000
--- a/apps/bare-rn/android/settings.gradle
+++ /dev/null
@@ -1,11 +0,0 @@
-pluginManagement { includeBuild("../node_modules/@react-native/gradle-plugin") }
-plugins { id("com.facebook.react.settings") }
-extensions.configure(com.facebook.react.ReactSettingsExtension){ ex ->
-    // bare-rn pins its own React Native via installConfig.hoistingLimits in package.json,
-    // so its deps live in apps/bare-rn/node_modules/ rather than the workspace root.
-    def cliFile = new File(settings.rootDir, "../node_modules/@react-native-community/cli/build/bin.js").absolutePath
-    ex.autolinkLibrariesFromCommand(["node", cliFile, "config"], new File(settings.rootDir, "../"))
-}
-rootProject.name = 'bare_rn'
-include ':app'
-includeBuild('../node_modules/@react-native/gradle-plugin')
diff --git a/apps/bare-rn/app.json b/apps/bare-rn/app.json
deleted file mode 100644
index 0a3ed9b0a2..0000000000
--- a/apps/bare-rn/app.json
+++ /dev/null
@@ -1,4 +0,0 @@
-{
-  "name": "bare-rn",
-  "displayName": "bare-rn"
-}
diff --git a/apps/bare-rn/babel.config.js b/apps/bare-rn/babel.config.js
deleted file mode 100644
index b243a0ffa4..0000000000
--- a/apps/bare-rn/babel.config.js
+++ /dev/null
@@ -1,4 +0,0 @@
-module.exports = {
-  presets: ['module:@react-native/babel-preset'],
-  plugins: ['@babel/plugin-transform-export-namespace-from'],
-};
diff --git a/apps/bare-rn/index.js b/apps/bare-rn/index.js
deleted file mode 100644
index 9b73932914..0000000000
--- a/apps/bare-rn/index.js
+++ /dev/null
@@ -1,9 +0,0 @@
-/**
- * @format
- */
-
-import { AppRegistry } from 'react-native';
-import App from './App';
-import { name as appName } from './app.json';
-
-AppRegistry.registerComponent(appName, () => App);
diff --git a/apps/bare-rn/ios/.xcode.env b/apps/bare-rn/ios/.xcode.env
deleted file mode 100644
index 3d5782c715..0000000000
--- a/apps/bare-rn/ios/.xcode.env
+++ /dev/null
@@ -1,11 +0,0 @@
-# This `.xcode.env` file is versioned and is used to source the environment
-# used when running script phases inside Xcode.
-# To customize your local environment, you can create an `.xcode.env.local`
-# file that is not versioned.
-
-# NODE_BINARY variable contains the PATH to the node executable.
-#
-# Customize the NODE_BINARY variable here.
-# For example, to use nvm with brew, add the following line
-# . "$(brew --prefix nvm)/nvm.sh" --no-use
-export NODE_BINARY=$(command -v node)
diff --git a/apps/bare-rn/ios/Podfile b/apps/bare-rn/ios/Podfile
deleted file mode 100644
index cdcb24c068..0000000000
--- a/apps/bare-rn/ios/Podfile
+++ /dev/null
@@ -1,51 +0,0 @@
-# Resolve react_native_pods.rb with node to allow for hoisting
-require Pod::Executable.execute_command('node', ['-p',
-  'require.resolve(
-    "react-native/scripts/react_native_pods.rb",
-    {paths: [process.argv[1]]},
-  )', __dir__]).strip
-
-platform :ios, '17.0'
-prepare_react_native_project!
-
-linkage = ENV['USE_FRAMEWORKS']
-if linkage != nil
-  Pod::UI.puts "Configuring Pod with #{linkage}ally linked Frameworks".green
-  use_frameworks! :linkage => linkage.to_sym
-end
-
-target 'bare-rn' do
-  config = use_native_modules!
-
-  use_react_native!(
-    :path => config[:reactNativePath],
-    # An absolute path to your application root.
-    :app_path => "#{Pod::Config.instance.installation_root}/.."
-  )
-
-  post_install do |installer|
-    react_native_post_install(
-      installer,
-      config[:reactNativePath],
-      :mac_catalyst_enabled => false,
-      # :ccache_enabled => true
-    )
-
-    # Workaround for Xcode 26.4 + Apple clang 21's stricter consteval
-    # enforcement breaking fmt 9.x (vendored by RCT-Folly in RN 0.81.x).
-    # See facebook/react-native#55601, fmtlib/fmt#4740. Forcing the fmt and
-    # RCT-Folly pod targets to C++17 makes fmt's `__cplusplus >= 202002L`
-    # gate fail, so `FMT_CONSTEVAL` resolves to empty inside fmt's cached
-    # clang module — consumers (Yoga, React-performancetimeline, etc.) then
-    # import a non-consteval module and the basic_format_string call site
-    # compiles. Applies to fmt/RCT-Folly only; remove once upstream lands.
-    installer.pods_project.targets.each do |target|
-      next unless target.name == 'fmt' || target.name == 'RCT-Folly'
-      target.build_configurations.each do |config|
-        config.build_settings['CLANG_CXX_LANGUAGE_STANDARD'] = 'c++17'
-        config.build_settings['GCC_PREPROCESSOR_DEFINITIONS'] ||= ['$(inherited)']
-        config.build_settings['GCC_PREPROCESSOR_DEFINITIONS'] << 'FMT_USE_CONSTEVAL=0'
-      end
-    end
-  end
-end
diff --git a/apps/bare-rn/ios/Podfile.lock b/apps/bare-rn/ios/Podfile.lock
deleted file mode 100644
index 7d7f408088..0000000000
--- a/apps/bare-rn/ios/Podfile.lock
+++ /dev/null
@@ -1,2758 +0,0 @@
-PODS:
-  - boost (1.84.0)
-  - DoubleConversion (1.1.6)
-  - fast_float (8.0.0)
-  - FBLazyVector (0.81.5)
-  - fmt (11.0.2)
-  - glog (0.3.5)
-  - hermes-engine (0.81.5):
-    - hermes-engine/Pre-built (= 0.81.5)
-  - hermes-engine/Pre-built (0.81.5)
-  - MMKV (2.3.0):
-    - MMKVCore (~> 2.3.0)
-  - MMKVCore (2.3.0)
-  - opencv-rne (4.11.0)
-  - RCT-Folly (2024.11.18.00):
-    - boost
-    - DoubleConversion
-    - fast_float (= 8.0.0)
-    - fmt (= 11.0.2)
-    - glog
-    - RCT-Folly/Default (= 2024.11.18.00)
-  - RCT-Folly/Default (2024.11.18.00):
-    - boost
-    - DoubleConversion
-    - fast_float (= 8.0.0)
-    - fmt (= 11.0.2)
-    - glog
-  - RCT-Folly/Fabric (2024.11.18.00):
-    - boost
-    - DoubleConversion
-    - fast_float (= 8.0.0)
-    - fmt (= 11.0.2)
-    - glog
-  - RCTDeprecation (0.81.5)
-  - RCTRequired (0.81.5)
-  - RCTTypeSafety (0.81.5):
-    - FBLazyVector (= 0.81.5)
-    - RCTRequired (= 0.81.5)
-    - React-Core (= 0.81.5)
-  - React (0.81.5):
-    - React-Core (= 0.81.5)
-    - React-Core/DevSupport (= 0.81.5)
-    - React-Core/RCTWebSocket (= 0.81.5)
-    - React-RCTActionSheet (= 0.81.5)
-    - React-RCTAnimation (= 0.81.5)
-    - React-RCTBlob (= 0.81.5)
-    - React-RCTImage (= 0.81.5)
-    - React-RCTLinking (= 0.81.5)
-    - React-RCTNetwork (= 0.81.5)
-    - React-RCTSettings (= 0.81.5)
-    - React-RCTText (= 0.81.5)
-    - React-RCTVibration (= 0.81.5)
-  - React-callinvoker (0.81.5)
-  - React-Core (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTDeprecation
-    - React-Core/Default (= 0.81.5)
-    - React-cxxreact
-    - React-featureflags
-    - React-hermes
-    - React-jsi
-    - React-jsiexecutor
-    - React-jsinspector
-    - React-jsinspectorcdp
-    - React-jsitooling
-    - React-perflogger
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - SocketRocket
-    - Yoga
-  - React-Core/CoreModulesHeaders (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTDeprecation
-    - React-Core/Default
-    - React-cxxreact
-    - React-featureflags
-    - React-hermes
-    - React-jsi
-    - React-jsiexecutor
-    - React-jsinspector
-    - React-jsinspectorcdp
-    - React-jsitooling
-    - React-perflogger
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - SocketRocket
-    - Yoga
-  - React-Core/Default (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTDeprecation
-    - React-cxxreact
-    - React-featureflags
-    - React-hermes
-    - React-jsi
-    - React-jsiexecutor
-    - React-jsinspector
-    - React-jsinspectorcdp
-    - React-jsitooling
-    - React-perflogger
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - SocketRocket
-    - Yoga
-  - React-Core/DevSupport (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTDeprecation
-    - React-Core/Default (= 0.81.5)
-    - React-Core/RCTWebSocket (= 0.81.5)
-    - React-cxxreact
-    - React-featureflags
-    - React-hermes
-    - React-jsi
-    - React-jsiexecutor
-    - React-jsinspector
-    - React-jsinspectorcdp
-    - React-jsitooling
-    - React-perflogger
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - SocketRocket
-    - Yoga
-  - React-Core/RCTActionSheetHeaders (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTDeprecation
-    - React-Core/Default
-    - React-cxxreact
-    - React-featureflags
-    - React-hermes
-    - React-jsi
-    - React-jsiexecutor
-    - React-jsinspector
-    - React-jsinspectorcdp
-    - React-jsitooling
-    - React-perflogger
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - SocketRocket
-    - Yoga
-  - React-Core/RCTAnimationHeaders (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTDeprecation
-    - React-Core/Default
-    - React-cxxreact
-    - React-featureflags
-    - React-hermes
-    - React-jsi
-    - React-jsiexecutor
-    - React-jsinspector
-    - React-jsinspectorcdp
-    - React-jsitooling
-    - React-perflogger
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - SocketRocket
-    - Yoga
-  - React-Core/RCTBlobHeaders (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTDeprecation
-    - React-Core/Default
-    - React-cxxreact
-    - React-featureflags
-    - React-hermes
-    - React-jsi
-    - React-jsiexecutor
-    - React-jsinspector
-    - React-jsinspectorcdp
-    - React-jsitooling
-    - React-perflogger
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - SocketRocket
-    - Yoga
-  - React-Core/RCTImageHeaders (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTDeprecation
-    - React-Core/Default
-    - React-cxxreact
-    - React-featureflags
-    - React-hermes
-    - React-jsi
-    - React-jsiexecutor
-    - React-jsinspector
-    - React-jsinspectorcdp
-    - React-jsitooling
-    - React-perflogger
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - SocketRocket
-    - Yoga
-  - React-Core/RCTLinkingHeaders (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTDeprecation
-    - React-Core/Default
-    - React-cxxreact
-    - React-featureflags
-    - React-hermes
-    - React-jsi
-    - React-jsiexecutor
-    - React-jsinspector
-    - React-jsinspectorcdp
-    - React-jsitooling
-    - React-perflogger
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - SocketRocket
-    - Yoga
-  - React-Core/RCTNetworkHeaders (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTDeprecation
-    - React-Core/Default
-    - React-cxxreact
-    - React-featureflags
-    - React-hermes
-    - React-jsi
-    - React-jsiexecutor
-    - React-jsinspector
-    - React-jsinspectorcdp
-    - React-jsitooling
-    - React-perflogger
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - SocketRocket
-    - Yoga
-  - React-Core/RCTSettingsHeaders (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTDeprecation
-    - React-Core/Default
-    - React-cxxreact
-    - React-featureflags
-    - React-hermes
-    - React-jsi
-    - React-jsiexecutor
-    - React-jsinspector
-    - React-jsinspectorcdp
-    - React-jsitooling
-    - React-perflogger
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - SocketRocket
-    - Yoga
-  - React-Core/RCTTextHeaders (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTDeprecation
-    - React-Core/Default
-    - React-cxxreact
-    - React-featureflags
-    - React-hermes
-    - React-jsi
-    - React-jsiexecutor
-    - React-jsinspector
-    - React-jsinspectorcdp
-    - React-jsitooling
-    - React-perflogger
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - SocketRocket
-    - Yoga
-  - React-Core/RCTVibrationHeaders (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTDeprecation
-    - React-Core/Default
-    - React-cxxreact
-    - React-featureflags
-    - React-hermes
-    - React-jsi
-    - React-jsiexecutor
-    - React-jsinspector
-    - React-jsinspectorcdp
-    - React-jsitooling
-    - React-perflogger
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - SocketRocket
-    - Yoga
-  - React-Core/RCTWebSocket (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTDeprecation
-    - React-Core/Default (= 0.81.5)
-    - React-cxxreact
-    - React-featureflags
-    - React-hermes
-    - React-jsi
-    - React-jsiexecutor
-    - React-jsinspector
-    - React-jsinspectorcdp
-    - React-jsitooling
-    - React-perflogger
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - SocketRocket
-    - Yoga
-  - React-CoreModules (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTTypeSafety (= 0.81.5)
-    - React-Core/CoreModulesHeaders (= 0.81.5)
-    - React-jsi (= 0.81.5)
-    - React-jsinspector
-    - React-jsinspectorcdp
-    - React-jsinspectortracing
-    - React-NativeModulesApple
-    - React-RCTBlob
-    - React-RCTFBReactNativeSpec
-    - React-RCTImage (= 0.81.5)
-    - React-runtimeexecutor
-    - ReactCommon
-    - SocketRocket
-  - React-cxxreact (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-callinvoker (= 0.81.5)
-    - React-debug (= 0.81.5)
-    - React-jsi (= 0.81.5)
-    - React-jsinspector
-    - React-jsinspectorcdp
-    - React-jsinspectortracing
-    - React-logger (= 0.81.5)
-    - React-perflogger (= 0.81.5)
-    - React-runtimeexecutor
-    - React-timing (= 0.81.5)
-    - SocketRocket
-  - React-debug (0.81.5)
-  - React-defaultsnativemodule (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-domnativemodule
-    - React-featureflagsnativemodule
-    - React-idlecallbacksnativemodule
-    - React-jsi
-    - React-jsiexecutor
-    - React-microtasksnativemodule
-    - React-RCTFBReactNativeSpec
-    - SocketRocket
-  - React-domnativemodule (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-Fabric
-    - React-Fabric/bridging
-    - React-FabricComponents
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-RCTFBReactNativeSpec
-    - React-runtimeexecutor
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-    - Yoga
-  - React-Fabric (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-Fabric/animations (= 0.81.5)
-    - React-Fabric/attributedstring (= 0.81.5)
-    - React-Fabric/bridging (= 0.81.5)
-    - React-Fabric/componentregistry (= 0.81.5)
-    - React-Fabric/componentregistrynative (= 0.81.5)
-    - React-Fabric/components (= 0.81.5)
-    - React-Fabric/consistency (= 0.81.5)
-    - React-Fabric/core (= 0.81.5)
-    - React-Fabric/dom (= 0.81.5)
-    - React-Fabric/imagemanager (= 0.81.5)
-    - React-Fabric/leakchecker (= 0.81.5)
-    - React-Fabric/mounting (= 0.81.5)
-    - React-Fabric/observers (= 0.81.5)
-    - React-Fabric/scheduler (= 0.81.5)
-    - React-Fabric/telemetry (= 0.81.5)
-    - React-Fabric/templateprocessor (= 0.81.5)
-    - React-Fabric/uimanager (= 0.81.5)
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-Fabric/animations (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-Fabric/attributedstring (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-Fabric/bridging (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-Fabric/componentregistry (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-Fabric/componentregistrynative (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-Fabric/components (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-Fabric/components/legacyviewmanagerinterop (= 0.81.5)
-    - React-Fabric/components/root (= 0.81.5)
-    - React-Fabric/components/scrollview (= 0.81.5)
-    - React-Fabric/components/view (= 0.81.5)
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-Fabric/components/legacyviewmanagerinterop (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-Fabric/components/root (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-Fabric/components/scrollview (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-Fabric/components/view (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-renderercss
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-    - Yoga
-  - React-Fabric/consistency (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-Fabric/core (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-Fabric/dom (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-Fabric/imagemanager (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-Fabric/leakchecker (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-Fabric/mounting (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-Fabric/observers (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-Fabric/observers/events (= 0.81.5)
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-Fabric/observers/events (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-Fabric/scheduler (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-Fabric/observers/events
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-performancetimeline
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-Fabric/telemetry (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-Fabric/templateprocessor (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-Fabric/uimanager (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-Fabric/uimanager/consistency (= 0.81.5)
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-rendererconsistency
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-Fabric/uimanager/consistency (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-rendererconsistency
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-FabricComponents (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-Fabric
-    - React-FabricComponents/components (= 0.81.5)
-    - React-FabricComponents/textlayoutmanager (= 0.81.5)
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-RCTFBReactNativeSpec
-    - React-rendererdebug
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-    - Yoga
-  - React-FabricComponents/components (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-Fabric
-    - React-FabricComponents/components/inputaccessory (= 0.81.5)
-    - React-FabricComponents/components/iostextinput (= 0.81.5)
-    - React-FabricComponents/components/modal (= 0.81.5)
-    - React-FabricComponents/components/rncore (= 0.81.5)
-    - React-FabricComponents/components/safeareaview (= 0.81.5)
-    - React-FabricComponents/components/scrollview (= 0.81.5)
-    - React-FabricComponents/components/switch (= 0.81.5)
-    - React-FabricComponents/components/text (= 0.81.5)
-    - React-FabricComponents/components/textinput (= 0.81.5)
-    - React-FabricComponents/components/unimplementedview (= 0.81.5)
-    - React-FabricComponents/components/virtualview (= 0.81.5)
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-RCTFBReactNativeSpec
-    - React-rendererdebug
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-    - Yoga
-  - React-FabricComponents/components/inputaccessory (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-Fabric
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-RCTFBReactNativeSpec
-    - React-rendererdebug
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-    - Yoga
-  - React-FabricComponents/components/iostextinput (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-Fabric
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-RCTFBReactNativeSpec
-    - React-rendererdebug
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-    - Yoga
-  - React-FabricComponents/components/modal (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-Fabric
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-RCTFBReactNativeSpec
-    - React-rendererdebug
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-    - Yoga
-  - React-FabricComponents/components/rncore (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-Fabric
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-RCTFBReactNativeSpec
-    - React-rendererdebug
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-    - Yoga
-  - React-FabricComponents/components/safeareaview (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-Fabric
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-RCTFBReactNativeSpec
-    - React-rendererdebug
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-    - Yoga
-  - React-FabricComponents/components/scrollview (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-Fabric
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-RCTFBReactNativeSpec
-    - React-rendererdebug
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-    - Yoga
-  - React-FabricComponents/components/switch (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-Fabric
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-RCTFBReactNativeSpec
-    - React-rendererdebug
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-    - Yoga
-  - React-FabricComponents/components/text (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-Fabric
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-RCTFBReactNativeSpec
-    - React-rendererdebug
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-    - Yoga
-  - React-FabricComponents/components/textinput (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-Fabric
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-RCTFBReactNativeSpec
-    - React-rendererdebug
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-    - Yoga
-  - React-FabricComponents/components/unimplementedview (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-Fabric
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-RCTFBReactNativeSpec
-    - React-rendererdebug
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-    - Yoga
-  - React-FabricComponents/components/virtualview (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-Fabric
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-RCTFBReactNativeSpec
-    - React-rendererdebug
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-    - Yoga
-  - React-FabricComponents/textlayoutmanager (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-cxxreact
-    - React-debug
-    - React-Fabric
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-logger
-    - React-RCTFBReactNativeSpec
-    - React-rendererdebug
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-    - Yoga
-  - React-FabricImage (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired (= 0.81.5)
-    - RCTTypeSafety (= 0.81.5)
-    - React-Fabric
-    - React-featureflags
-    - React-graphics
-    - React-ImageManager
-    - React-jsi
-    - React-jsiexecutor (= 0.81.5)
-    - React-logger
-    - React-rendererdebug
-    - React-utils
-    - ReactCommon
-    - SocketRocket
-    - Yoga
-  - React-featureflags (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - SocketRocket
-  - React-featureflagsnativemodule (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-featureflags
-    - React-jsi
-    - React-jsiexecutor
-    - React-RCTFBReactNativeSpec
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-graphics (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-jsi
-    - React-jsiexecutor
-    - React-utils
-    - SocketRocket
-  - React-hermes (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-cxxreact (= 0.81.5)
-    - React-jsi
-    - React-jsiexecutor (= 0.81.5)
-    - React-jsinspector
-    - React-jsinspectorcdp
-    - React-jsinspectortracing
-    - React-perflogger (= 0.81.5)
-    - React-runtimeexecutor
-    - SocketRocket
-  - React-idlecallbacksnativemodule (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-jsi
-    - React-jsiexecutor
-    - React-RCTFBReactNativeSpec
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-ImageManager (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-Core/Default
-    - React-debug
-    - React-Fabric
-    - React-graphics
-    - React-rendererdebug
-    - React-utils
-    - SocketRocket
-  - React-jserrorhandler (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-cxxreact
-    - React-debug
-    - React-featureflags
-    - React-jsi
-    - ReactCommon/turbomodule/bridging
-    - SocketRocket
-  - React-jsi (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - SocketRocket
-  - React-jsiexecutor (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-cxxreact (= 0.81.5)
-    - React-jsi (= 0.81.5)
-    - React-jsinspector
-    - React-jsinspectorcdp
-    - React-jsinspectortracing
-    - React-perflogger (= 0.81.5)
-    - React-runtimeexecutor
-    - SocketRocket
-  - React-jsinspector (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-featureflags
-    - React-jsi
-    - React-jsinspectorcdp
-    - React-jsinspectornetwork
-    - React-jsinspectortracing
-    - React-oscompat
-    - React-perflogger (= 0.81.5)
-    - React-runtimeexecutor
-    - SocketRocket
-  - React-jsinspectorcdp (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - SocketRocket
-  - React-jsinspectornetwork (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-featureflags
-    - React-jsinspectorcdp
-    - React-performancetimeline
-    - React-timing
-    - SocketRocket
-  - React-jsinspectortracing (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-oscompat
-    - React-timing
-    - SocketRocket
-  - React-jsitooling (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-cxxreact (= 0.81.5)
-    - React-jsi (= 0.81.5)
-    - React-jsinspector
-    - React-jsinspectorcdp
-    - React-jsinspectortracing
-    - React-runtimeexecutor
-    - SocketRocket
-  - React-jsitracing (0.81.5):
-    - React-jsi
-  - React-logger (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - SocketRocket
-  - React-Mapbuffer (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-debug
-    - SocketRocket
-  - React-microtasksnativemodule (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-jsi
-    - React-jsiexecutor
-    - React-RCTFBReactNativeSpec
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - react-native-background-downloader (4.5.2):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - MMKV
-    - 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-executorch (0.9.0):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - opencv-rne (~> 4.11.0)
-    - 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.7.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-native-safe-area-context/common (= 5.7.0)
-    - react-native-safe-area-context/fabric (= 5.7.0)
-    - React-NativeModulesApple
-    - React-RCTFabric
-    - React-renderercss
-    - React-rendererdebug
-    - React-utils
-    - ReactCodegen
-    - ReactCommon/turbomodule/bridging
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-    - Yoga
-  - react-native-safe-area-context/common (5.7.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/fabric (5.7.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-native-safe-area-context/common
-    - React-NativeModulesApple
-    - React-RCTFabric
-    - React-renderercss
-    - React-rendererdebug
-    - React-utils
-    - ReactCodegen
-    - ReactCommon/turbomodule/bridging
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-    - Yoga
-  - React-NativeModulesApple (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-callinvoker
-    - React-Core
-    - React-cxxreact
-    - React-featureflags
-    - React-jsi
-    - React-jsinspector
-    - React-jsinspectorcdp
-    - React-runtimeexecutor
-    - ReactCommon/turbomodule/bridging
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - React-oscompat (0.81.5)
-  - React-perflogger (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - SocketRocket
-  - React-performancetimeline (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-featureflags
-    - React-jsinspectortracing
-    - React-perflogger
-    - React-timing
-    - SocketRocket
-  - React-RCTActionSheet (0.81.5):
-    - React-Core/RCTActionSheetHeaders (= 0.81.5)
-  - React-RCTAnimation (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTTypeSafety
-    - React-Core/RCTAnimationHeaders
-    - React-featureflags
-    - React-jsi
-    - React-NativeModulesApple
-    - React-RCTFBReactNativeSpec
-    - ReactCommon
-    - SocketRocket
-  - React-RCTAppDelegate (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-CoreModules
-    - React-debug
-    - React-defaultsnativemodule
-    - React-Fabric
-    - React-featureflags
-    - React-graphics
-    - React-hermes
-    - React-jsitooling
-    - React-NativeModulesApple
-    - React-RCTFabric
-    - React-RCTFBReactNativeSpec
-    - React-RCTImage
-    - React-RCTNetwork
-    - React-RCTRuntime
-    - React-rendererdebug
-    - React-RuntimeApple
-    - React-RuntimeCore
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - ReactCommon
-    - SocketRocket
-  - React-RCTBlob (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-Core/RCTBlobHeaders
-    - React-Core/RCTWebSocket
-    - React-jsi
-    - React-jsinspector
-    - React-jsinspectorcdp
-    - React-NativeModulesApple
-    - React-RCTFBReactNativeSpec
-    - React-RCTNetwork
-    - ReactCommon
-    - SocketRocket
-  - React-RCTFabric (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-Core
-    - React-debug
-    - React-Fabric
-    - React-FabricComponents
-    - React-FabricImage
-    - React-featureflags
-    - React-graphics
-    - React-ImageManager
-    - React-jsi
-    - React-jsinspector
-    - React-jsinspectorcdp
-    - React-jsinspectornetwork
-    - React-jsinspectortracing
-    - React-performancetimeline
-    - React-RCTAnimation
-    - React-RCTFBReactNativeSpec
-    - React-RCTImage
-    - React-RCTText
-    - React-rendererconsistency
-    - React-renderercss
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - SocketRocket
-    - Yoga
-  - React-RCTFBReactNativeSpec (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-jsi
-    - React-NativeModulesApple
-    - React-RCTFBReactNativeSpec/components (= 0.81.5)
-    - ReactCommon
-    - SocketRocket
-  - React-RCTFBReactNativeSpec/components (0.81.5):
-    - 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-jsi
-    - React-NativeModulesApple
-    - React-rendererdebug
-    - React-utils
-    - ReactCommon
-    - SocketRocket
-    - Yoga
-  - React-RCTImage (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTTypeSafety
-    - React-Core/RCTImageHeaders
-    - React-jsi
-    - React-NativeModulesApple
-    - React-RCTFBReactNativeSpec
-    - React-RCTNetwork
-    - ReactCommon
-    - SocketRocket
-  - React-RCTLinking (0.81.5):
-    - React-Core/RCTLinkingHeaders (= 0.81.5)
-    - React-jsi (= 0.81.5)
-    - React-NativeModulesApple
-    - React-RCTFBReactNativeSpec
-    - ReactCommon
-    - ReactCommon/turbomodule/core (= 0.81.5)
-  - React-RCTNetwork (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTTypeSafety
-    - React-Core/RCTNetworkHeaders
-    - React-featureflags
-    - React-jsi
-    - React-jsinspectorcdp
-    - React-jsinspectornetwork
-    - React-NativeModulesApple
-    - React-RCTFBReactNativeSpec
-    - ReactCommon
-    - SocketRocket
-  - React-RCTRuntime (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-Core
-    - React-jsi
-    - React-jsinspector
-    - React-jsinspectorcdp
-    - React-jsinspectortracing
-    - React-jsitooling
-    - React-RuntimeApple
-    - React-RuntimeCore
-    - React-runtimeexecutor
-    - React-RuntimeHermes
-    - SocketRocket
-  - React-RCTSettings (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTTypeSafety
-    - React-Core/RCTSettingsHeaders
-    - React-jsi
-    - React-NativeModulesApple
-    - React-RCTFBReactNativeSpec
-    - ReactCommon
-    - SocketRocket
-  - React-RCTText (0.81.5):
-    - React-Core/RCTTextHeaders (= 0.81.5)
-    - Yoga
-  - React-RCTVibration (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-Core/RCTVibrationHeaders
-    - React-jsi
-    - React-NativeModulesApple
-    - React-RCTFBReactNativeSpec
-    - ReactCommon
-    - SocketRocket
-  - React-rendererconsistency (0.81.5)
-  - React-renderercss (0.81.5):
-    - React-debug
-    - React-utils
-  - React-rendererdebug (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-debug
-    - SocketRocket
-  - React-RuntimeApple (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-callinvoker
-    - React-Core/Default
-    - React-CoreModules
-    - React-cxxreact
-    - React-featureflags
-    - React-jserrorhandler
-    - React-jsi
-    - React-jsiexecutor
-    - React-jsinspector
-    - React-jsitooling
-    - React-Mapbuffer
-    - React-NativeModulesApple
-    - React-RCTFabric
-    - React-RCTFBReactNativeSpec
-    - React-RuntimeCore
-    - React-runtimeexecutor
-    - React-RuntimeHermes
-    - React-runtimescheduler
-    - React-utils
-    - SocketRocket
-  - React-RuntimeCore (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-cxxreact
-    - React-Fabric
-    - React-featureflags
-    - React-jserrorhandler
-    - React-jsi
-    - React-jsiexecutor
-    - React-jsinspector
-    - React-jsitooling
-    - React-performancetimeline
-    - React-runtimeexecutor
-    - React-runtimescheduler
-    - React-utils
-    - SocketRocket
-  - React-runtimeexecutor (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-debug
-    - React-featureflags
-    - React-jsi (= 0.81.5)
-    - React-utils
-    - SocketRocket
-  - React-RuntimeHermes (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-featureflags
-    - React-hermes
-    - React-jsi
-    - React-jsinspector
-    - React-jsinspectorcdp
-    - React-jsinspectortracing
-    - React-jsitooling
-    - React-jsitracing
-    - React-RuntimeCore
-    - React-runtimeexecutor
-    - React-utils
-    - SocketRocket
-  - React-runtimescheduler (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-callinvoker
-    - React-cxxreact
-    - React-debug
-    - React-featureflags
-    - React-jsi
-    - React-jsinspectortracing
-    - React-performancetimeline
-    - React-rendererconsistency
-    - React-rendererdebug
-    - React-runtimeexecutor
-    - React-timing
-    - React-utils
-    - SocketRocket
-  - React-timing (0.81.5):
-    - React-debug
-  - React-utils (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-debug
-    - React-jsi (= 0.81.5)
-    - SocketRocket
-  - ReactAppDependencyProvider (0.81.5):
-    - ReactCodegen
-  - ReactCodegen (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - RCTRequired
-    - RCTTypeSafety
-    - React-Core
-    - React-debug
-    - React-Fabric
-    - React-FabricImage
-    - React-featureflags
-    - React-graphics
-    - React-jsi
-    - React-jsiexecutor
-    - React-NativeModulesApple
-    - React-RCTAppDelegate
-    - React-rendererdebug
-    - React-utils
-    - ReactCommon/turbomodule/bridging
-    - ReactCommon/turbomodule/core
-    - SocketRocket
-  - ReactCommon (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - ReactCommon/turbomodule (= 0.81.5)
-    - SocketRocket
-  - ReactCommon/turbomodule (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-callinvoker (= 0.81.5)
-    - React-cxxreact (= 0.81.5)
-    - React-jsi (= 0.81.5)
-    - React-logger (= 0.81.5)
-    - React-perflogger (= 0.81.5)
-    - ReactCommon/turbomodule/bridging (= 0.81.5)
-    - ReactCommon/turbomodule/core (= 0.81.5)
-    - SocketRocket
-  - ReactCommon/turbomodule/bridging (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-callinvoker (= 0.81.5)
-    - React-cxxreact (= 0.81.5)
-    - React-jsi (= 0.81.5)
-    - React-logger (= 0.81.5)
-    - React-perflogger (= 0.81.5)
-    - SocketRocket
-  - ReactCommon/turbomodule/core (0.81.5):
-    - boost
-    - DoubleConversion
-    - fast_float
-    - fmt
-    - glog
-    - hermes-engine
-    - RCT-Folly
-    - RCT-Folly/Fabric
-    - React-callinvoker (= 0.81.5)
-    - React-cxxreact (= 0.81.5)
-    - React-debug (= 0.81.5)
-    - React-featureflags (= 0.81.5)
-    - React-jsi (= 0.81.5)
-    - React-logger (= 0.81.5)
-    - React-perflogger (= 0.81.5)
-    - React-utils (= 0.81.5)
-    - SocketRocket
-  - ReactNativeFs (2.37.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
-  - SocketRocket (0.7.1)
-  - Yoga (0.0.0)
-
-DEPENDENCIES:
-  - boost (from `../node_modules/react-native/third-party-podspecs/boost.podspec`)
-  - DoubleConversion (from `../node_modules/react-native/third-party-podspecs/DoubleConversion.podspec`)
-  - fast_float (from `../node_modules/react-native/third-party-podspecs/fast_float.podspec`)
-  - FBLazyVector (from `../node_modules/react-native/Libraries/FBLazyVector`)
-  - fmt (from `../node_modules/react-native/third-party-podspecs/fmt.podspec`)
-  - glog (from `../node_modules/react-native/third-party-podspecs/glog.podspec`)
-  - hermes-engine (from `../node_modules/react-native/sdks/hermes-engine/hermes-engine.podspec`)
-  - RCT-Folly (from `../node_modules/react-native/third-party-podspecs/RCT-Folly.podspec`)
-  - RCTDeprecation (from `../node_modules/react-native/ReactApple/Libraries/RCTFoundation/RCTDeprecation`)
-  - RCTRequired (from `../node_modules/react-native/Libraries/Required`)
-  - RCTTypeSafety (from `../node_modules/react-native/Libraries/TypeSafety`)
-  - React (from `../node_modules/react-native/`)
-  - React-callinvoker (from `../node_modules/react-native/ReactCommon/callinvoker`)
-  - React-Core (from `../node_modules/react-native/`)
-  - React-Core/RCTWebSocket (from `../node_modules/react-native/`)
-  - React-CoreModules (from `../node_modules/react-native/React/CoreModules`)
-  - React-cxxreact (from `../node_modules/react-native/ReactCommon/cxxreact`)
-  - React-debug (from `../node_modules/react-native/ReactCommon/react/debug`)
-  - React-defaultsnativemodule (from `../node_modules/react-native/ReactCommon/react/nativemodule/defaults`)
-  - React-domnativemodule (from `../node_modules/react-native/ReactCommon/react/nativemodule/dom`)
-  - React-Fabric (from `../node_modules/react-native/ReactCommon`)
-  - React-FabricComponents (from `../node_modules/react-native/ReactCommon`)
-  - React-FabricImage (from `../node_modules/react-native/ReactCommon`)
-  - React-featureflags (from `../node_modules/react-native/ReactCommon/react/featureflags`)
-  - React-featureflagsnativemodule (from `../node_modules/react-native/ReactCommon/react/nativemodule/featureflags`)
-  - React-graphics (from `../node_modules/react-native/ReactCommon/react/renderer/graphics`)
-  - React-hermes (from `../node_modules/react-native/ReactCommon/hermes`)
-  - React-idlecallbacksnativemodule (from `../node_modules/react-native/ReactCommon/react/nativemodule/idlecallbacks`)
-  - React-ImageManager (from `../node_modules/react-native/ReactCommon/react/renderer/imagemanager/platform/ios`)
-  - React-jserrorhandler (from `../node_modules/react-native/ReactCommon/jserrorhandler`)
-  - React-jsi (from `../node_modules/react-native/ReactCommon/jsi`)
-  - React-jsiexecutor (from `../node_modules/react-native/ReactCommon/jsiexecutor`)
-  - React-jsinspector (from `../node_modules/react-native/ReactCommon/jsinspector-modern`)
-  - React-jsinspectorcdp (from `../node_modules/react-native/ReactCommon/jsinspector-modern/cdp`)
-  - React-jsinspectornetwork (from `../node_modules/react-native/ReactCommon/jsinspector-modern/network`)
-  - React-jsinspectortracing (from `../node_modules/react-native/ReactCommon/jsinspector-modern/tracing`)
-  - React-jsitooling (from `../node_modules/react-native/ReactCommon/jsitooling`)
-  - React-jsitracing (from `../node_modules/react-native/ReactCommon/hermes/executor/`)
-  - React-logger (from `../node_modules/react-native/ReactCommon/logger`)
-  - React-Mapbuffer (from `../node_modules/react-native/ReactCommon`)
-  - React-microtasksnativemodule (from `../node_modules/react-native/ReactCommon/react/nativemodule/microtasks`)
-  - "react-native-background-downloader (from `../node_modules/@kesha-antonov/react-native-background-downloader`)"
-  - react-native-executorch (from `../node_modules/react-native-executorch`)
-  - react-native-safe-area-context (from `../node_modules/react-native-safe-area-context`)
-  - React-NativeModulesApple (from `../node_modules/react-native/ReactCommon/react/nativemodule/core/platform/ios`)
-  - React-oscompat (from `../node_modules/react-native/ReactCommon/oscompat`)
-  - React-perflogger (from `../node_modules/react-native/ReactCommon/reactperflogger`)
-  - React-performancetimeline (from `../node_modules/react-native/ReactCommon/react/performance/timeline`)
-  - React-RCTActionSheet (from `../node_modules/react-native/Libraries/ActionSheetIOS`)
-  - React-RCTAnimation (from `../node_modules/react-native/Libraries/NativeAnimation`)
-  - React-RCTAppDelegate (from `../node_modules/react-native/Libraries/AppDelegate`)
-  - React-RCTBlob (from `../node_modules/react-native/Libraries/Blob`)
-  - React-RCTFabric (from `../node_modules/react-native/React`)
-  - React-RCTFBReactNativeSpec (from `../node_modules/react-native/React`)
-  - React-RCTImage (from `../node_modules/react-native/Libraries/Image`)
-  - React-RCTLinking (from `../node_modules/react-native/Libraries/LinkingIOS`)
-  - React-RCTNetwork (from `../node_modules/react-native/Libraries/Network`)
-  - React-RCTRuntime (from `../node_modules/react-native/React/Runtime`)
-  - React-RCTSettings (from `../node_modules/react-native/Libraries/Settings`)
-  - React-RCTText (from `../node_modules/react-native/Libraries/Text`)
-  - React-RCTVibration (from `../node_modules/react-native/Libraries/Vibration`)
-  - React-rendererconsistency (from `../node_modules/react-native/ReactCommon/react/renderer/consistency`)
-  - React-renderercss (from `../node_modules/react-native/ReactCommon/react/renderer/css`)
-  - React-rendererdebug (from `../node_modules/react-native/ReactCommon/react/renderer/debug`)
-  - React-RuntimeApple (from `../node_modules/react-native/ReactCommon/react/runtime/platform/ios`)
-  - React-RuntimeCore (from `../node_modules/react-native/ReactCommon/react/runtime`)
-  - React-runtimeexecutor (from `../node_modules/react-native/ReactCommon/runtimeexecutor`)
-  - React-RuntimeHermes (from `../node_modules/react-native/ReactCommon/react/runtime`)
-  - React-runtimescheduler (from `../node_modules/react-native/ReactCommon/react/renderer/runtimescheduler`)
-  - React-timing (from `../node_modules/react-native/ReactCommon/react/timing`)
-  - React-utils (from `../node_modules/react-native/ReactCommon/react/utils`)
-  - ReactAppDependencyProvider (from `build/generated/ios`)
-  - ReactCodegen (from `build/generated/ios`)
-  - ReactCommon/turbomodule/core (from `../node_modules/react-native/ReactCommon`)
-  - "ReactNativeFs (from `../node_modules/@dr.pogodin/react-native-fs`)"
-  - SocketRocket (~> 0.7.1)
-  - Yoga (from `../node_modules/react-native/ReactCommon/yoga`)
-
-SPEC REPOS:
-  trunk:
-    - MMKV
-    - MMKVCore
-    - opencv-rne
-    - SocketRocket
-
-EXTERNAL SOURCES:
-  boost:
-    :podspec: "../node_modules/react-native/third-party-podspecs/boost.podspec"
-  DoubleConversion:
-    :podspec: "../node_modules/react-native/third-party-podspecs/DoubleConversion.podspec"
-  fast_float:
-    :podspec: "../node_modules/react-native/third-party-podspecs/fast_float.podspec"
-  FBLazyVector:
-    :path: "../node_modules/react-native/Libraries/FBLazyVector"
-  fmt:
-    :podspec: "../node_modules/react-native/third-party-podspecs/fmt.podspec"
-  glog:
-    :podspec: "../node_modules/react-native/third-party-podspecs/glog.podspec"
-  hermes-engine:
-    :podspec: "../node_modules/react-native/sdks/hermes-engine/hermes-engine.podspec"
-    :tag: hermes-2025-07-07-RNv0.81.0-e0fc67142ec0763c6b6153ca2bf96df815539782
-  RCT-Folly:
-    :podspec: "../node_modules/react-native/third-party-podspecs/RCT-Folly.podspec"
-  RCTDeprecation:
-    :path: "../node_modules/react-native/ReactApple/Libraries/RCTFoundation/RCTDeprecation"
-  RCTRequired:
-    :path: "../node_modules/react-native/Libraries/Required"
-  RCTTypeSafety:
-    :path: "../node_modules/react-native/Libraries/TypeSafety"
-  React:
-    :path: "../node_modules/react-native/"
-  React-callinvoker:
-    :path: "../node_modules/react-native/ReactCommon/callinvoker"
-  React-Core:
-    :path: "../node_modules/react-native/"
-  React-CoreModules:
-    :path: "../node_modules/react-native/React/CoreModules"
-  React-cxxreact:
-    :path: "../node_modules/react-native/ReactCommon/cxxreact"
-  React-debug:
-    :path: "../node_modules/react-native/ReactCommon/react/debug"
-  React-defaultsnativemodule:
-    :path: "../node_modules/react-native/ReactCommon/react/nativemodule/defaults"
-  React-domnativemodule:
-    :path: "../node_modules/react-native/ReactCommon/react/nativemodule/dom"
-  React-Fabric:
-    :path: "../node_modules/react-native/ReactCommon"
-  React-FabricComponents:
-    :path: "../node_modules/react-native/ReactCommon"
-  React-FabricImage:
-    :path: "../node_modules/react-native/ReactCommon"
-  React-featureflags:
-    :path: "../node_modules/react-native/ReactCommon/react/featureflags"
-  React-featureflagsnativemodule:
-    :path: "../node_modules/react-native/ReactCommon/react/nativemodule/featureflags"
-  React-graphics:
-    :path: "../node_modules/react-native/ReactCommon/react/renderer/graphics"
-  React-hermes:
-    :path: "../node_modules/react-native/ReactCommon/hermes"
-  React-idlecallbacksnativemodule:
-    :path: "../node_modules/react-native/ReactCommon/react/nativemodule/idlecallbacks"
-  React-ImageManager:
-    :path: "../node_modules/react-native/ReactCommon/react/renderer/imagemanager/platform/ios"
-  React-jserrorhandler:
-    :path: "../node_modules/react-native/ReactCommon/jserrorhandler"
-  React-jsi:
-    :path: "../node_modules/react-native/ReactCommon/jsi"
-  React-jsiexecutor:
-    :path: "../node_modules/react-native/ReactCommon/jsiexecutor"
-  React-jsinspector:
-    :path: "../node_modules/react-native/ReactCommon/jsinspector-modern"
-  React-jsinspectorcdp:
-    :path: "../node_modules/react-native/ReactCommon/jsinspector-modern/cdp"
-  React-jsinspectornetwork:
-    :path: "../node_modules/react-native/ReactCommon/jsinspector-modern/network"
-  React-jsinspectortracing:
-    :path: "../node_modules/react-native/ReactCommon/jsinspector-modern/tracing"
-  React-jsitooling:
-    :path: "../node_modules/react-native/ReactCommon/jsitooling"
-  React-jsitracing:
-    :path: "../node_modules/react-native/ReactCommon/hermes/executor/"
-  React-logger:
-    :path: "../node_modules/react-native/ReactCommon/logger"
-  React-Mapbuffer:
-    :path: "../node_modules/react-native/ReactCommon"
-  React-microtasksnativemodule:
-    :path: "../node_modules/react-native/ReactCommon/react/nativemodule/microtasks"
-  react-native-background-downloader:
-    :path: "../node_modules/@kesha-antonov/react-native-background-downloader"
-  react-native-executorch:
-    :path: "../node_modules/react-native-executorch"
-  react-native-safe-area-context:
-    :path: "../node_modules/react-native-safe-area-context"
-  React-NativeModulesApple:
-    :path: "../node_modules/react-native/ReactCommon/react/nativemodule/core/platform/ios"
-  React-oscompat:
-    :path: "../node_modules/react-native/ReactCommon/oscompat"
-  React-perflogger:
-    :path: "../node_modules/react-native/ReactCommon/reactperflogger"
-  React-performancetimeline:
-    :path: "../node_modules/react-native/ReactCommon/react/performance/timeline"
-  React-RCTActionSheet:
-    :path: "../node_modules/react-native/Libraries/ActionSheetIOS"
-  React-RCTAnimation:
-    :path: "../node_modules/react-native/Libraries/NativeAnimation"
-  React-RCTAppDelegate:
-    :path: "../node_modules/react-native/Libraries/AppDelegate"
-  React-RCTBlob:
-    :path: "../node_modules/react-native/Libraries/Blob"
-  React-RCTFabric:
-    :path: "../node_modules/react-native/React"
-  React-RCTFBReactNativeSpec:
-    :path: "../node_modules/react-native/React"
-  React-RCTImage:
-    :path: "../node_modules/react-native/Libraries/Image"
-  React-RCTLinking:
-    :path: "../node_modules/react-native/Libraries/LinkingIOS"
-  React-RCTNetwork:
-    :path: "../node_modules/react-native/Libraries/Network"
-  React-RCTRuntime:
-    :path: "../node_modules/react-native/React/Runtime"
-  React-RCTSettings:
-    :path: "../node_modules/react-native/Libraries/Settings"
-  React-RCTText:
-    :path: "../node_modules/react-native/Libraries/Text"
-  React-RCTVibration:
-    :path: "../node_modules/react-native/Libraries/Vibration"
-  React-rendererconsistency:
-    :path: "../node_modules/react-native/ReactCommon/react/renderer/consistency"
-  React-renderercss:
-    :path: "../node_modules/react-native/ReactCommon/react/renderer/css"
-  React-rendererdebug:
-    :path: "../node_modules/react-native/ReactCommon/react/renderer/debug"
-  React-RuntimeApple:
-    :path: "../node_modules/react-native/ReactCommon/react/runtime/platform/ios"
-  React-RuntimeCore:
-    :path: "../node_modules/react-native/ReactCommon/react/runtime"
-  React-runtimeexecutor:
-    :path: "../node_modules/react-native/ReactCommon/runtimeexecutor"
-  React-RuntimeHermes:
-    :path: "../node_modules/react-native/ReactCommon/react/runtime"
-  React-runtimescheduler:
-    :path: "../node_modules/react-native/ReactCommon/react/renderer/runtimescheduler"
-  React-timing:
-    :path: "../node_modules/react-native/ReactCommon/react/timing"
-  React-utils:
-    :path: "../node_modules/react-native/ReactCommon/react/utils"
-  ReactAppDependencyProvider:
-    :path: build/generated/ios
-  ReactCodegen:
-    :path: build/generated/ios
-  ReactCommon:
-    :path: "../node_modules/react-native/ReactCommon"
-  ReactNativeFs:
-    :path: "../node_modules/@dr.pogodin/react-native-fs"
-  Yoga:
-    :path: "../node_modules/react-native/ReactCommon/yoga"
-
-SPEC CHECKSUMS:
-  boost: 7e761d76ca2ce687f7cc98e698152abd03a18f90
-  DoubleConversion: cb417026b2400c8f53ae97020b2be961b59470cb
-  fast_float: b32c788ed9c6a8c584d114d0047beda9664e7cc6
-  FBLazyVector: 5beb8028d5a2e75dd9634917f23e23d3a061d2aa
-  fmt: a40bb5bd0294ea969aaaba240a927bd33d878cdd
-  glog: 5683914934d5b6e4240e497e0f4a3b42d1854183
-  hermes-engine: 9f4dfe93326146a1c99eb535b1cb0b857a3cd172
-  MMKV: c953dbaac0da392c24b005e763c03ce2638b4ed7
-  MMKVCore: d078dce7d6586a888b2c2ef5343b6242678e3ee8
-  opencv-rne: 2305807573b6e29c8c87e3416ab096d09047a7a0
-  RCT-Folly: 846fda9475e61ec7bcbf8a3fe81edfcaeb090669
-  RCTDeprecation: 5eb1d2eeff5fb91151e8a8eef45b6c7658b6c897
-  RCTRequired: cebcf9442fc296c9b89ac791dfd463021d9f6f23
-  RCTTypeSafety: b99aa872829ee18f6e777e0ef55852521c5a6788
-  React: 914f8695f9bf38e6418228c2ffb70021e559f92f
-  React-callinvoker: 23cd4e33928608bd0cc35357597568b8b9a5f068
-  React-Core: 6a0a97598e9455348113bfe4c573fe8edac34469
-  React-CoreModules: a88a6ca48b668401b9780e272e2a607e70f9f955
-  React-cxxreact: 06265fd7e8d5c3b6b49e00d328ef76e5f1ae9c8b
-  React-debug: 039d3dbd3078613e02e3960439bbf52f6d321bc4
-  React-defaultsnativemodule: 09efbfa17b15445907689c577e371558d8b08135
-  React-domnativemodule: 6284a09207d8e0e974affb0d84b43a0c1aee2554
-  React-Fabric: 5ffa7f2a10fb3bf835f97990d341419ae338963d
-  React-FabricComponents: 25173bc205a6b7c18d87121891f3acef1c329b04
-  React-FabricImage: aa90e4b2b34a79f9b4ee56328ad9222cb672f1f3
-  React-featureflags: 7bdaca8af1def3ec9203743c91b11ac7c2cb2574
-  React-featureflagsnativemodule: 6840bc359820d5e44f1de1f9ba69706e0a88a60b
-  React-graphics: b0a76138e325f9c5dfcc8fbc62491ab252ca736c
-  React-hermes: a852be3ab9e1f515e46ba3ea9f48c31d4a9df437
-  React-idlecallbacksnativemodule: 38895fd946b2dcb0af387f2176f5f2e578b14277
-  React-ImageManager: 44409a10adff7091c9e678b97ee59c7b0576b8ae
-  React-jserrorhandler: 3852205bbfc68277cd4e7392ad1fa74a170150fd
-  React-jsi: 7b53959aea60909ac6bbe4dd0bdec6c10d7dc597
-  React-jsiexecutor: 19938072af05ade148474bac41e0324a2d733f44
-  React-jsinspector: 0aecd79939adf576c6dd7bbbddf90b630e7827e4
-  React-jsinspectorcdp: 8245973529c78d150aebddd2c497ee290349faf0
-  React-jsinspectornetwork: 496a12dbc80835fac10acf29b9c4386ddcc472f1
-  React-jsinspectortracing: 1939b3e0cec087983384c5561bf925f35287d760
-  React-jsitooling: 86c70336d5c371b4289499e9303b6da118ad3eeb
-  React-jsitracing: 8eb0d50d7874886fb3ec7f85e0567f1964a20075
-  React-logger: a913317214a26565cd4c045347edf1bcacb80a3f
-  React-Mapbuffer: 94f4264de2cb156960cd82b338a403f4653f2fd9
-  React-microtasksnativemodule: 6c4ee39a36958c39c97b074d28f360246a335e84
-  react-native-background-downloader: 114f96122822fa97b06ea0f2250b8e8270696995
-  react-native-executorch: 273c1ffd131a92738c35267c7af737275e8b32a5
-  react-native-safe-area-context: befb5404eb8a16fdc07fa2bebab3568ecabcbb8a
-  React-NativeModulesApple: ebf2ce72b35870036900d6498b33724386540a71
-  React-oscompat: eb0626e8ba1a2c61673c991bf9dc21834898475d
-  React-perflogger: 509e1f9a3ee28df71b0a66de806ac515ce951246
-  React-performancetimeline: 43a1ea36ac47853b479ae85e04c1c339721e99f1
-  React-RCTActionSheet: 30fe8f9f8d86db4a25ff34595a658ecd837485fc
-  React-RCTAnimation: 3126eb1cb8e7a6ca33a52fd833d8018aa9311af1
-  React-RCTAppDelegate: b03981c790aa40cf26e0f78cc0f1f2df8287ead4
-  React-RCTBlob: 53c35e85c85d6bdaa55dc81a0b290d4e78431095
-  React-RCTFabric: 4e2a4176f99b6b8f2d2eda9fc82453a3e6c3ef8e
-  React-RCTFBReactNativeSpec: 947126c649e04b95457a40bc97c4b2a76206534b
-  React-RCTImage: 074b2faa71a152a456c974e118b60c9eeda94a64
-  React-RCTLinking: e5ca17a4f7ae2ad7b0c0483be77e1b383ecd0a8a
-  React-RCTNetwork: c508d7548c9eceac30a8100a846ea00033a03366
-  React-RCTRuntime: 6813778046c775c124179d9e4d7b33d4129bbd84
-  React-RCTSettings: dd84c857a4fce42c1e08c1dabcda894e25af4a6e
-  React-RCTText: 6e4b177d047f98bccb90d6fb1ebdd3391cf8b299
-  React-RCTVibration: 9572d4a06a0c92650bcc62913e50eb2a89f19fb6
-  React-rendererconsistency: 6f0622076d7b26eda57a582db5ffd8b05fe94652
-  React-renderercss: c00b6db35f01e2f17e496d1d0793fc0be89d4f7b
-  React-rendererdebug: 17f707ba5ba1ed7a10dd997a2e27b2431b24a180
-  React-RuntimeApple: b9b9a53afd594eb49c3e6891f84327d1834a2c5e
-  React-RuntimeCore: 5a0c78665206a44c4a030e2b4af0c8d6ad05ae77
-  React-runtimeexecutor: 7f56789cd23bd4ea1f95595eb5c27e08cee3a19e
-  React-RuntimeHermes: b2d6bc03f4cc9d2eb7ee0a1bfe16c226cb2114ce
-  React-runtimescheduler: 5cc5c0568bf216e1ee8f3c2c0a1cff2ef3091b32
-  React-timing: b1e27e61bd184fab3792947685bebdb2dc55af9a
-  React-utils: ddf52534853a3b5f19d4615b1a1f172b504673f2
-  ReactAppDependencyProvider: 1bcd3527ac0390a1c898c114f81ff954be35ed79
-  ReactCodegen: 6c26f8c25d0b5ae66f86a1cce1777076ac8bcbd8
-  ReactCommon: 5f0e5c09a64a2717215dd84380e1a747810406f2
-  ReactNativeFs: 5fc447c96bcf90d038b79695d721628fc7bb0170
-  SocketRocket: d4aabe649be1e368d1318fdf28a022d714d65748
-  Yoga: 728df40394d49f3f471688747cf558158b3a3bd1
-
-PODFILE CHECKSUM: 421dcdee6cbb1e2a032c3b2e3ffc9371849b2199
-
-COCOAPODS: 1.16.2
diff --git a/apps/bare-rn/ios/bare-rn.xcodeproj/project.pbxproj b/apps/bare-rn/ios/bare-rn.xcodeproj/project.pbxproj
deleted file mode 100644
index 2a603318fc..0000000000
--- a/apps/bare-rn/ios/bare-rn.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,482 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 54;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		0AF1DC9B7BF72575F4599DF4 /* PrivacyInfo.xcprivacy in Resources */ = {isa = PBXBuildFile; fileRef = 13B07FB81A68108700A75B9A /* PrivacyInfo.xcprivacy */; };
-		0C80B921A6F3F58F76C31292 /* libPods-bare-rn.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5DCACB8F33CDC322A6C60F78 /* libPods-bare-rn.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 */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXFileReference section */
-		13B07F961A680F5B00A75B9A /* bare-rn.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = "bare-rn.app"; sourceTree = BUILT_PRODUCTS_DIR; };
-		13B07FB51A68108700A75B9A /* Images.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; name = Images.xcassets; path = "bare-rn/Images.xcassets"; sourceTree = "<group>"; };
-		13B07FB61A68108700A75B9A /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = Info.plist; path = "bare-rn/Info.plist"; sourceTree = "<group>"; };
-		13B07FB81A68108700A75B9A /* PrivacyInfo.xcprivacy */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = PrivacyInfo.xcprivacy; path = "bare-rn/PrivacyInfo.xcprivacy"; sourceTree = "<group>"; };
-		3B4392A12AC88292D35C810B /* Pods-bare-rn.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-bare-rn.debug.xcconfig"; path = "Target Support Files/Pods-bare-rn/Pods-bare-rn.debug.xcconfig"; sourceTree = "<group>"; };
-		5709B34CF0A7D63546082F79 /* Pods-bare-rn.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-bare-rn.release.xcconfig"; path = "Target Support Files/Pods-bare-rn/Pods-bare-rn.release.xcconfig"; sourceTree = "<group>"; };
-		5DCACB8F33CDC322A6C60F78 /* libPods-bare-rn.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libPods-bare-rn.a"; sourceTree = BUILT_PRODUCTS_DIR; };
-		761780EC2CA45674006654EE /* AppDelegate.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = AppDelegate.swift; path = "bare-rn/AppDelegate.swift"; sourceTree = "<group>"; };
-		81AB9BB72411601600AC10FF /* LaunchScreen.storyboard */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = file.storyboard; name = LaunchScreen.storyboard; path = "bare-rn/LaunchScreen.storyboard"; sourceTree = "<group>"; };
-		ED297162215061F000B7C4FE /* JavaScriptCore.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = JavaScriptCore.framework; path = System/Library/Frameworks/JavaScriptCore.framework; sourceTree = SDKROOT; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		13B07F8C1A680F5B00A75B9A /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				0C80B921A6F3F58F76C31292 /* libPods-bare-rn.a in Frameworks */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		13B07FAE1A68108700A75B9A /* bare-rn */ = {
-			isa = PBXGroup;
-			children = (
-				13B07FB51A68108700A75B9A /* Images.xcassets */,
-				761780EC2CA45674006654EE /* AppDelegate.swift */,
-				13B07FB61A68108700A75B9A /* Info.plist */,
-				81AB9BB72411601600AC10FF /* LaunchScreen.storyboard */,
-				13B07FB81A68108700A75B9A /* PrivacyInfo.xcprivacy */,
-			);
-			name = "bare-rn";
-			sourceTree = "<group>";
-		};
-		2D16E6871FA4F8E400B85C8A /* Frameworks */ = {
-			isa = PBXGroup;
-			children = (
-				ED297162215061F000B7C4FE /* JavaScriptCore.framework */,
-				5DCACB8F33CDC322A6C60F78 /* libPods-bare-rn.a */,
-			);
-			name = Frameworks;
-			sourceTree = "<group>";
-		};
-		832341AE1AAA6A7D00B99B32 /* Libraries */ = {
-			isa = PBXGroup;
-			children = (
-			);
-			name = Libraries;
-			sourceTree = "<group>";
-		};
-		83CBB9F61A601CBA00E9B192 = {
-			isa = PBXGroup;
-			children = (
-				13B07FAE1A68108700A75B9A /* bare-rn */,
-				832341AE1AAA6A7D00B99B32 /* Libraries */,
-				83CBBA001A601CBA00E9B192 /* Products */,
-				2D16E6871FA4F8E400B85C8A /* Frameworks */,
-				BBD78D7AC51CEA395F1C20DB /* Pods */,
-			);
-			indentWidth = 2;
-			sourceTree = "<group>";
-			tabWidth = 2;
-			usesTabs = 0;
-		};
-		83CBBA001A601CBA00E9B192 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				13B07F961A680F5B00A75B9A /* bare-rn.app */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		BBD78D7AC51CEA395F1C20DB /* Pods */ = {
-			isa = PBXGroup;
-			children = (
-				3B4392A12AC88292D35C810B /* Pods-bare-rn.debug.xcconfig */,
-				5709B34CF0A7D63546082F79 /* Pods-bare-rn.release.xcconfig */,
-			);
-			path = Pods;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXNativeTarget section */
-		13B07F861A680F5B00A75B9A /* bare-rn */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 13B07F931A680F5B00A75B9A /* Build configuration list for PBXNativeTarget "bare-rn" */;
-			buildPhases = (
-				C38B50BA6285516D6DCD4F65 /* [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 */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = "bare-rn";
-			productName = "bare-rn";
-			productReference = 13B07F961A680F5B00A75B9A /* bare-rn.app */;
-			productType = "com.apple.product-type.application";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		83CBB9F71A601CBA00E9B192 /* Project object */ = {
-			isa = PBXProject;
-			attributes = {
-				LastUpgradeCheck = 1210;
-				TargetAttributes = {
-					13B07F861A680F5B00A75B9A = {
-						LastSwiftMigration = 1120;
-					};
-				};
-			};
-			buildConfigurationList = 83CBB9FA1A601CBA00E9B192 /* Build configuration list for PBXProject "bare-rn" */;
-			compatibilityVersion = "Xcode 12.0";
-			developmentRegion = en;
-			hasScannedForEncodings = 0;
-			knownRegions = (
-				en,
-				Base,
-			);
-			mainGroup = 83CBB9F61A601CBA00E9B192;
-			productRefGroup = 83CBBA001A601CBA00E9B192 /* Products */;
-			projectDirPath = "";
-			projectRoot = "";
-			targets = (
-				13B07F861A680F5B00A75B9A /* bare-rn */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXResourcesBuildPhase section */
-		13B07F8E1A680F5B00A75B9A /* Resources */ = {
-			isa = PBXResourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				81AB9BB82411601600AC10FF /* LaunchScreen.storyboard in Resources */,
-				13B07FBF1A68108700A75B9A /* Images.xcassets in Resources */,
-				0AF1DC9B7BF72575F4599DF4 /* PrivacyInfo.xcprivacy in Resources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXResourcesBuildPhase section */
-
-/* Begin PBXShellScriptBuildPhase section */
-		00DD1BFF1BD5951E006B06BC /* Bundle React Native code and images */ = {
-			isa = PBXShellScriptBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			inputPaths = (
-				"$(SRCROOT)/.xcode.env.local",
-				"$(SRCROOT)/.xcode.env",
-			);
-			name = "Bundle React Native code and images";
-			outputPaths = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-			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 */ = {
-			isa = PBXShellScriptBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			inputFileListPaths = (
-				"${PODS_ROOT}/Target Support Files/Pods-bare-rn/Pods-bare-rn-frameworks-${CONFIGURATION}-input-files.xcfilelist",
-			);
-			name = "[CP] Embed Pods Frameworks";
-			outputFileListPaths = (
-				"${PODS_ROOT}/Target Support Files/Pods-bare-rn/Pods-bare-rn-frameworks-${CONFIGURATION}-output-files.xcfilelist",
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-			shellPath = /bin/sh;
-			shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-bare-rn/Pods-bare-rn-frameworks.sh\"\n";
-			showEnvVarsInLog = 0;
-		};
-		C38B50BA6285516D6DCD4F65 /* [CP] Check Pods Manifest.lock */ = {
-			isa = PBXShellScriptBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			inputFileListPaths = (
-			);
-			inputPaths = (
-				"${PODS_PODFILE_DIR_PATH}/Podfile.lock",
-				"${PODS_ROOT}/Manifest.lock",
-			);
-			name = "[CP] Check Pods Manifest.lock";
-			outputFileListPaths = (
-			);
-			outputPaths = (
-				"$(DERIVED_FILE_DIR)/Pods-bare-rn-checkManifestLockResult.txt",
-			);
-			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";
-			showEnvVarsInLog = 0;
-		};
-		E235C05ADACE081382539298 /* [CP] Copy Pods Resources */ = {
-			isa = PBXShellScriptBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			inputFileListPaths = (
-				"${PODS_ROOT}/Target Support Files/Pods-bare-rn/Pods-bare-rn-resources-${CONFIGURATION}-input-files.xcfilelist",
-			);
-			name = "[CP] Copy Pods Resources";
-			outputFileListPaths = (
-				"${PODS_ROOT}/Target Support Files/Pods-bare-rn/Pods-bare-rn-resources-${CONFIGURATION}-output-files.xcfilelist",
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-			shellPath = /bin/sh;
-			shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-bare-rn/Pods-bare-rn-resources.sh\"\n";
-			showEnvVarsInLog = 0;
-		};
-/* End PBXShellScriptBuildPhase section */
-
-/* Begin PBXSourcesBuildPhase section */
-		13B07F871A680F5B00A75B9A /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				761780ED2CA45674006654EE /* AppDelegate.swift in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin XCBuildConfiguration section */
-		13B07F941A680F5B00A75B9A /* Debug */ = {
-			isa = XCBuildConfiguration;
-			baseConfigurationReference = 3B4392A12AC88292D35C810B /* Pods-bare-rn.debug.xcconfig */;
-			buildSettings = {
-				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
-				CLANG_ENABLE_MODULES = YES;
-				CURRENT_PROJECT_VERSION = 1;
-				ENABLE_BITCODE = NO;
-				INFOPLIST_FILE = "bare-rn/Info.plist";
-				IPHONEOS_DEPLOYMENT_TARGET = 17.0;
-				LD_RUNPATH_SEARCH_PATHS = (
-					"$(inherited)",
-					"@executable_path/Frameworks",
-				);
-				MARKETING_VERSION = 1.0;
-				OTHER_LDFLAGS = (
-					"$(inherited)",
-					"-ObjC",
-					"-lc++",
-				);
-				PRODUCT_BUNDLE_IDENTIFIER = "org.reactjs.native.example.$(PRODUCT_NAME:rfc1034identifier)";
-				PRODUCT_NAME = "bare-rn";
-				SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
-				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
-				SWIFT_VERSION = 5.0;
-				TARGETED_DEVICE_FAMILY = "1,2";
-				VERSIONING_SYSTEM = "apple-generic";
-			};
-			name = Debug;
-		};
-		13B07F951A680F5B00A75B9A /* Release */ = {
-			isa = XCBuildConfiguration;
-			baseConfigurationReference = 5709B34CF0A7D63546082F79 /* Pods-bare-rn.release.xcconfig */;
-			buildSettings = {
-				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
-				CLANG_ENABLE_MODULES = YES;
-				CURRENT_PROJECT_VERSION = 1;
-				INFOPLIST_FILE = "bare-rn/Info.plist";
-				IPHONEOS_DEPLOYMENT_TARGET = 17.0;
-				LD_RUNPATH_SEARCH_PATHS = (
-					"$(inherited)",
-					"@executable_path/Frameworks",
-				);
-				MARKETING_VERSION = 1.0;
-				OTHER_LDFLAGS = (
-					"$(inherited)",
-					"-ObjC",
-					"-lc++",
-				);
-				PRODUCT_BUNDLE_IDENTIFIER = "org.reactjs.native.example.$(PRODUCT_NAME:rfc1034identifier)";
-				PRODUCT_NAME = "bare-rn";
-				SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
-				SWIFT_VERSION = 5.0;
-				TARGETED_DEVICE_FAMILY = "1,2";
-				VERSIONING_SYSTEM = "apple-generic";
-			};
-			name = Release;
-		};
-		83CBBA201A601CBA00E9B192 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES;
-				CLANG_CXX_LANGUAGE_STANDARD = "c++20";
-				CLANG_CXX_LIBRARY = "libc++";
-				CLANG_ENABLE_MODULES = YES;
-				CLANG_ENABLE_OBJC_ARC = YES;
-				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
-				CLANG_WARN_BOOL_CONVERSION = YES;
-				CLANG_WARN_COMMA = YES;
-				CLANG_WARN_CONSTANT_CONVERSION = YES;
-				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
-				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
-				CLANG_WARN_EMPTY_BODY = YES;
-				CLANG_WARN_ENUM_CONVERSION = YES;
-				CLANG_WARN_INFINITE_RECURSION = YES;
-				CLANG_WARN_INT_CONVERSION = YES;
-				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
-				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
-				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
-				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
-				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
-				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
-				CLANG_WARN_STRICT_PROTOTYPES = YES;
-				CLANG_WARN_SUSPICIOUS_MOVE = YES;
-				CLANG_WARN_UNREACHABLE_CODE = YES;
-				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
-				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
-				COPY_PHASE_STRIP = NO;
-				ENABLE_STRICT_OBJC_MSGSEND = YES;
-				ENABLE_TESTABILITY = YES;
-				"EXCLUDED_ARCHS[sdk=iphonesimulator*]" = "";
-				GCC_C_LANGUAGE_STANDARD = gnu99;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_NO_COMMON_BLOCKS = YES;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					"DEBUG=1",
-					"$(inherited)",
-				);
-				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
-				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
-				GCC_WARN_UNDECLARED_SELECTOR = YES;
-				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
-				GCC_WARN_UNUSED_FUNCTION = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				IPHONEOS_DEPLOYMENT_TARGET = 17.0;
-				LD_RUNPATH_SEARCH_PATHS = (
-					/usr/lib/swift,
-					"$(inherited)",
-				);
-				LIBRARY_SEARCH_PATHS = (
-					"\"$(SDKROOT)/usr/lib/swift\"",
-					"\"$(TOOLCHAIN_DIR)/usr/lib/swift/$(PLATFORM_NAME)\"",
-					"\"$(inherited)\"",
-				);
-				MTL_ENABLE_DEBUG_INFO = YES;
-				ONLY_ACTIVE_ARCH = YES;
-				OTHER_CPLUSPLUSFLAGS = (
-					"$(OTHER_CFLAGS)",
-					"-DFOLLY_NO_CONFIG",
-					"-DFOLLY_MOBILE=1",
-					"-DFOLLY_USE_LIBCPP=1",
-					"-DFOLLY_CFG_NO_COROUTINES=1",
-					"-DFOLLY_HAVE_CLOCK_GETTIME=1",
-				);
-				REACT_NATIVE_PATH = "${PODS_ROOT}/../../node_modules/react-native";
-				SDKROOT = iphoneos;
-				SWIFT_ACTIVE_COMPILATION_CONDITIONS = "$(inherited) DEBUG";
-				USE_HERMES = true;
-			};
-			name = Debug;
-		};
-		83CBBA211A601CBA00E9B192 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES;
-				CLANG_CXX_LANGUAGE_STANDARD = "c++20";
-				CLANG_CXX_LIBRARY = "libc++";
-				CLANG_ENABLE_MODULES = YES;
-				CLANG_ENABLE_OBJC_ARC = YES;
-				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
-				CLANG_WARN_BOOL_CONVERSION = YES;
-				CLANG_WARN_COMMA = YES;
-				CLANG_WARN_CONSTANT_CONVERSION = YES;
-				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
-				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
-				CLANG_WARN_EMPTY_BODY = YES;
-				CLANG_WARN_ENUM_CONVERSION = YES;
-				CLANG_WARN_INFINITE_RECURSION = YES;
-				CLANG_WARN_INT_CONVERSION = YES;
-				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
-				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
-				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
-				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
-				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
-				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
-				CLANG_WARN_STRICT_PROTOTYPES = YES;
-				CLANG_WARN_SUSPICIOUS_MOVE = YES;
-				CLANG_WARN_UNREACHABLE_CODE = YES;
-				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
-				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
-				COPY_PHASE_STRIP = YES;
-				ENABLE_NS_ASSERTIONS = NO;
-				ENABLE_STRICT_OBJC_MSGSEND = YES;
-				"EXCLUDED_ARCHS[sdk=iphonesimulator*]" = "";
-				GCC_C_LANGUAGE_STANDARD = gnu99;
-				GCC_NO_COMMON_BLOCKS = YES;
-				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
-				GCC_WARN_UNDECLARED_SELECTOR = YES;
-				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
-				GCC_WARN_UNUSED_FUNCTION = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				IPHONEOS_DEPLOYMENT_TARGET = 17.0;
-				LD_RUNPATH_SEARCH_PATHS = (
-					/usr/lib/swift,
-					"$(inherited)",
-				);
-				LIBRARY_SEARCH_PATHS = (
-					"\"$(SDKROOT)/usr/lib/swift\"",
-					"\"$(TOOLCHAIN_DIR)/usr/lib/swift/$(PLATFORM_NAME)\"",
-					"\"$(inherited)\"",
-				);
-				MTL_ENABLE_DEBUG_INFO = NO;
-				OTHER_CPLUSPLUSFLAGS = (
-					"$(OTHER_CFLAGS)",
-					"-DFOLLY_NO_CONFIG",
-					"-DFOLLY_MOBILE=1",
-					"-DFOLLY_USE_LIBCPP=1",
-					"-DFOLLY_CFG_NO_COROUTINES=1",
-					"-DFOLLY_HAVE_CLOCK_GETTIME=1",
-				);
-				REACT_NATIVE_PATH = "${PODS_ROOT}/../../node_modules/react-native";
-				SDKROOT = iphoneos;
-				USE_HERMES = true;
-				VALIDATE_PRODUCT = YES;
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		13B07F931A680F5B00A75B9A /* Build configuration list for PBXNativeTarget "bare-rn" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				13B07F941A680F5B00A75B9A /* Debug */,
-				13B07F951A680F5B00A75B9A /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		83CBB9FA1A601CBA00E9B192 /* Build configuration list for PBXProject "bare-rn" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				83CBBA201A601CBA00E9B192 /* Debug */,
-				83CBBA211A601CBA00E9B192 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 83CBB9F71A601CBA00E9B192 /* Project object */;
-}
diff --git a/apps/bare-rn/ios/bare-rn.xcodeproj/xcshareddata/xcschemes/bare-rn.xcscheme b/apps/bare-rn/ios/bare-rn.xcodeproj/xcshareddata/xcschemes/bare-rn.xcscheme
deleted file mode 100644
index 6106d33b22..0000000000
--- a/apps/bare-rn/ios/bare-rn.xcodeproj/xcshareddata/xcschemes/bare-rn.xcscheme
+++ /dev/null
@@ -1,88 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Scheme
-   LastUpgradeVersion = "1210"
-   version = "1.3">
-   <BuildAction
-      parallelizeBuildables = "YES"
-      buildImplicitDependencies = "YES">
-      <BuildActionEntries>
-         <BuildActionEntry
-            buildForTesting = "YES"
-            buildForRunning = "YES"
-            buildForProfiling = "YES"
-            buildForArchiving = "YES"
-            buildForAnalyzing = "YES">
-            <BuildableReference
-               BuildableIdentifier = "primary"
-               BlueprintIdentifier = "13B07F861A680F5B00A75B9A"
-               BuildableName = "bare-rn.app"
-               BlueprintName = "bare-rn"
-               ReferencedContainer = "container:bare-rn.xcodeproj">
-            </BuildableReference>
-         </BuildActionEntry>
-      </BuildActionEntries>
-   </BuildAction>
-   <TestAction
-      buildConfiguration = "Debug"
-      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
-      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      shouldUseLaunchSchemeArgsEnv = "YES">
-      <Testables>
-         <TestableReference
-            skipped = "NO">
-            <BuildableReference
-               BuildableIdentifier = "primary"
-               BlueprintIdentifier = "00E356ED1AD99517003FC87E"
-               BuildableName = "bare-rnTests.xctest"
-               BlueprintName = "bare-rnTests"
-               ReferencedContainer = "container:bare-rn.xcodeproj">
-            </BuildableReference>
-         </TestableReference>
-      </Testables>
-   </TestAction>
-   <LaunchAction
-      buildConfiguration = "Debug"
-      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
-      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      launchStyle = "0"
-      useCustomWorkingDirectory = "NO"
-      ignoresPersistentStateOnLaunch = "NO"
-      debugDocumentVersioning = "YES"
-      debugServiceExtension = "internal"
-      allowLocationSimulation = "YES">
-      <BuildableProductRunnable
-         runnableDebuggingMode = "0">
-         <BuildableReference
-            BuildableIdentifier = "primary"
-            BlueprintIdentifier = "13B07F861A680F5B00A75B9A"
-            BuildableName = "bare-rn.app"
-            BlueprintName = "bare-rn"
-            ReferencedContainer = "container:bare-rn.xcodeproj">
-         </BuildableReference>
-      </BuildableProductRunnable>
-   </LaunchAction>
-   <ProfileAction
-      buildConfiguration = "Release"
-      shouldUseLaunchSchemeArgsEnv = "YES"
-      savedToolIdentifier = ""
-      useCustomWorkingDirectory = "NO"
-      debugDocumentVersioning = "YES">
-      <BuildableProductRunnable
-         runnableDebuggingMode = "0">
-         <BuildableReference
-            BuildableIdentifier = "primary"
-            BlueprintIdentifier = "13B07F861A680F5B00A75B9A"
-            BuildableName = "bare-rn.app"
-            BlueprintName = "bare-rn"
-            ReferencedContainer = "container:bare-rn.xcodeproj">
-         </BuildableReference>
-      </BuildableProductRunnable>
-   </ProfileAction>
-   <AnalyzeAction
-      buildConfiguration = "Debug">
-   </AnalyzeAction>
-   <ArchiveAction
-      buildConfiguration = "Release"
-      revealArchiveInOrganizer = "YES">
-   </ArchiveAction>
-</Scheme>
diff --git a/apps/bare-rn/ios/bare-rn.xcworkspace/contents.xcworkspacedata b/apps/bare-rn/ios/bare-rn.xcworkspace/contents.xcworkspacedata
deleted file mode 100644
index 190b831198..0000000000
--- a/apps/bare-rn/ios/bare-rn.xcworkspace/contents.xcworkspacedata
+++ /dev/null
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Workspace
-   version = "1.0">
-   <FileRef
-      location = "group:bare-rn.xcodeproj">
-   </FileRef>
-   <FileRef
-      location = "group:Pods/Pods.xcodeproj">
-   </FileRef>
-</Workspace>
diff --git a/apps/bare-rn/ios/bare-rn/AppDelegate.swift b/apps/bare-rn/ios/bare-rn/AppDelegate.swift
deleted file mode 100644
index 4fb4ca4833..0000000000
--- a/apps/bare-rn/ios/bare-rn/AppDelegate.swift
+++ /dev/null
@@ -1,48 +0,0 @@
-import UIKit
-import React
-import React_RCTAppDelegate
-import ReactAppDependencyProvider
-
-@main
-class AppDelegate: UIResponder, UIApplicationDelegate {
-  var window: UIWindow?
-
-  var reactNativeDelegate: ReactNativeDelegate?
-  var reactNativeFactory: RCTReactNativeFactory?
-
-  func application(
-    _ application: UIApplication,
-    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil
-  ) -> Bool {
-    let delegate = ReactNativeDelegate()
-    let factory = RCTReactNativeFactory(delegate: delegate)
-    delegate.dependencyProvider = RCTAppDependencyProvider()
-
-    reactNativeDelegate = delegate
-    reactNativeFactory = factory
-
-    window = UIWindow(frame: UIScreen.main.bounds)
-
-    factory.startReactNative(
-      withModuleName: "bare-rn",
-      in: window,
-      launchOptions: launchOptions
-    )
-
-    return true
-  }
-}
-
-class ReactNativeDelegate: RCTDefaultReactNativeFactoryDelegate {
-  override func sourceURL(for bridge: RCTBridge) -> URL? {
-    self.bundleURL()
-  }
-
-  override func bundleURL() -> URL? {
-#if DEBUG
-    RCTBundleURLProvider.sharedSettings().jsBundleURL(forBundleRoot: "index")
-#else
-    Bundle.main.url(forResource: "main", withExtension: "jsbundle")
-#endif
-  }
-}
diff --git a/apps/bare-rn/ios/bare-rn/Images.xcassets/AppIcon.appiconset/Contents.json b/apps/bare-rn/ios/bare-rn/Images.xcassets/AppIcon.appiconset/Contents.json
deleted file mode 100644
index ddd7fca89e..0000000000
--- a/apps/bare-rn/ios/bare-rn/Images.xcassets/AppIcon.appiconset/Contents.json
+++ /dev/null
@@ -1,53 +0,0 @@
-{
-  "images": [
-    {
-      "idiom": "iphone",
-      "scale": "2x",
-      "size": "20x20"
-    },
-    {
-      "idiom": "iphone",
-      "scale": "3x",
-      "size": "20x20"
-    },
-    {
-      "idiom": "iphone",
-      "scale": "2x",
-      "size": "29x29"
-    },
-    {
-      "idiom": "iphone",
-      "scale": "3x",
-      "size": "29x29"
-    },
-    {
-      "idiom": "iphone",
-      "scale": "2x",
-      "size": "40x40"
-    },
-    {
-      "idiom": "iphone",
-      "scale": "3x",
-      "size": "40x40"
-    },
-    {
-      "idiom": "iphone",
-      "scale": "2x",
-      "size": "60x60"
-    },
-    {
-      "idiom": "iphone",
-      "scale": "3x",
-      "size": "60x60"
-    },
-    {
-      "idiom": "ios-marketing",
-      "scale": "1x",
-      "size": "1024x1024"
-    }
-  ],
-  "info": {
-    "author": "xcode",
-    "version": 1
-  }
-}
diff --git a/apps/bare-rn/ios/bare-rn/Images.xcassets/Contents.json b/apps/bare-rn/ios/bare-rn/Images.xcassets/Contents.json
deleted file mode 100644
index 97a8662ebd..0000000000
--- a/apps/bare-rn/ios/bare-rn/Images.xcassets/Contents.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "info": {
-    "version": 1,
-    "author": "xcode"
-  }
-}
diff --git a/apps/bare-rn/ios/bare-rn/Info.plist b/apps/bare-rn/ios/bare-rn/Info.plist
deleted file mode 100644
index 37fc9b5e77..0000000000
--- a/apps/bare-rn/ios/bare-rn/Info.plist
+++ /dev/null
@@ -1,60 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CADisableMinimumFrameDurationOnPhone</key>
-	<true/>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>en</string>
-	<key>CFBundleDisplayName</key>
-	<string>bare-rn</string>
-	<key>CFBundleExecutable</key>
-	<string>$(EXECUTABLE_NAME)</string>
-	<key>CFBundleIdentifier</key>
-	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundleName</key>
-	<string>$(PRODUCT_NAME)</string>
-	<key>CFBundlePackageType</key>
-	<string>APPL</string>
-	<key>CFBundleShortVersionString</key>
-	<string>$(MARKETING_VERSION)</string>
-	<key>CFBundleSignature</key>
-	<string>????</string>
-	<key>CFBundleVersion</key>
-	<string>$(CURRENT_PROJECT_VERSION)</string>
-	<key>LSRequiresIPhoneOS</key>
-	<true/>
-	<key>NSAppTransportSecurity</key>
-	<dict>
-		<key>NSAllowsArbitraryLoads</key>
-		<false/>
-		<key>NSAllowsLocalNetworking</key>
-		<true/>
-	</dict>
-	<key>NSLocationWhenInUseUsageDescription</key>
-	<string></string>
-	<key>RCTNewArchEnabled</key>
-	<true/>
-	<key>UILaunchStoryboardName</key>
-	<string>LaunchScreen</string>
-	<key>UIRequiredDeviceCapabilities</key>
-	<array>
-		<string>arm64</string>
-	</array>
-	<key>UISupportedInterfaceOrientations</key>
-	<array>
-		<string>UIInterfaceOrientationPortrait</string>
-	</array>
-	<key>UISupportedInterfaceOrientations~ipad</key>
-	<array>
-		<string>UIInterfaceOrientationLandscapeLeft</string>
-		<string>UIInterfaceOrientationLandscapeRight</string>
-		<string>UIInterfaceOrientationPortrait</string>
-		<string>UIInterfaceOrientationPortraitUpsideDown</string>
-	</array>
-	<key>UIViewControllerBasedStatusBarAppearance</key>
-	<false/>
-</dict>
-</plist>
diff --git a/apps/bare-rn/ios/bare-rn/LaunchScreen.storyboard b/apps/bare-rn/ios/bare-rn/LaunchScreen.storyboard
deleted file mode 100644
index 4bc47247dc..0000000000
--- a/apps/bare-rn/ios/bare-rn/LaunchScreen.storyboard
+++ /dev/null
@@ -1,47 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="15702" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" useTraitCollections="YES" useSafeAreas="YES" colorMatched="YES" initialViewController="01J-lp-oVM">
-    <device id="retina4_7" orientation="portrait" appearance="light"/>
-    <dependencies>
-        <deployment identifier="iOS"/>
-        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="15704"/>
-        <capability name="Safe area layout guides" minToolsVersion="9.0"/>
-        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
-    </dependencies>
-    <scenes>
-        <!--View Controller-->
-        <scene sceneID="EHf-IW-A2E">
-            <objects>
-                <viewController id="01J-lp-oVM" sceneMemberID="viewController">
-                    <view key="view" contentMode="scaleToFill" id="Ze5-6b-2t3">
-                        <rect key="frame" x="0.0" y="0.0" width="375" height="667"/>
-                        <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
-                        <subviews>
-                            <label opaque="NO" clipsSubviews="YES" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="bare-rn" textAlignment="center" lineBreakMode="middleTruncation" baselineAdjustment="alignBaselines" minimumFontSize="18" translatesAutoresizingMaskIntoConstraints="NO" id="GJd-Yh-RWb">
-                                <rect key="frame" x="0.0" y="202" width="375" height="43"/>
-                                <fontDescription key="fontDescription" type="boldSystem" pointSize="36"/>
-                                <nil key="highlightedColor"/>
-                            </label>
-                            <label opaque="NO" clipsSubviews="YES" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="Powered by React Native" textAlignment="center" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" minimumFontSize="9" translatesAutoresizingMaskIntoConstraints="NO" id="MN2-I3-ftu">
-                                <rect key="frame" x="0.0" y="626" width="375" height="21"/>
-                                <fontDescription key="fontDescription" type="system" pointSize="17"/>
-                                <nil key="highlightedColor"/>
-                            </label>
-                        </subviews>
-                        <color key="backgroundColor" systemColor="systemBackgroundColor" cocoaTouchSystemColor="whiteColor"/>
-                        <constraints>
-                            <constraint firstItem="Bcu-3y-fUS" firstAttribute="bottom" secondItem="MN2-I3-ftu" secondAttribute="bottom" constant="20" id="OZV-Vh-mqD"/>
-                            <constraint firstItem="Bcu-3y-fUS" firstAttribute="centerX" secondItem="GJd-Yh-RWb" secondAttribute="centerX" id="Q3B-4B-g5h"/>
-                            <constraint firstItem="MN2-I3-ftu" firstAttribute="centerX" secondItem="Bcu-3y-fUS" secondAttribute="centerX" id="akx-eg-2ui"/>
-                            <constraint firstItem="MN2-I3-ftu" firstAttribute="leading" secondItem="Bcu-3y-fUS" secondAttribute="leading" id="i1E-0Y-4RG"/>
-                            <constraint firstItem="GJd-Yh-RWb" firstAttribute="centerY" secondItem="Ze5-6b-2t3" secondAttribute="bottom" multiplier="1/3" constant="1" id="moa-c2-u7t"/>
-                            <constraint firstItem="GJd-Yh-RWb" firstAttribute="leading" secondItem="Bcu-3y-fUS" secondAttribute="leading" symbolic="YES" id="x7j-FC-K8j"/>
-                        </constraints>
-                        <viewLayoutGuide key="safeArea" id="Bcu-3y-fUS"/>
-                    </view>
-                </viewController>
-                <placeholder placeholderIdentifier="IBFirstResponder" id="iYj-Kq-Ea1" userLabel="First Responder" sceneMemberID="firstResponder"/>
-            </objects>
-            <point key="canvasLocation" x="52.173913043478265" y="375"/>
-        </scene>
-    </scenes>
-</document>
diff --git a/apps/bare-rn/ios/bare-rn/PrivacyInfo.xcprivacy b/apps/bare-rn/ios/bare-rn/PrivacyInfo.xcprivacy
deleted file mode 100644
index 41da7af967..0000000000
--- a/apps/bare-rn/ios/bare-rn/PrivacyInfo.xcprivacy
+++ /dev/null
@@ -1,47 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>NSPrivacyAccessedAPITypes</key>
-	<array>
-		<dict>
-			<key>NSPrivacyAccessedAPIType</key>
-			<string>NSPrivacyAccessedAPICategoryFileTimestamp</string>
-			<key>NSPrivacyAccessedAPITypeReasons</key>
-			<array>
-				<string>C617.1</string>
-				<string>0A2A.1</string>
-			</array>
-		</dict>
-		<dict>
-			<key>NSPrivacyAccessedAPIType</key>
-			<string>NSPrivacyAccessedAPICategoryUserDefaults</string>
-			<key>NSPrivacyAccessedAPITypeReasons</key>
-			<array>
-				<string>CA92.1</string>
-			</array>
-		</dict>
-		<dict>
-			<key>NSPrivacyAccessedAPIType</key>
-			<string>NSPrivacyAccessedAPICategoryDiskSpace</string>
-			<key>NSPrivacyAccessedAPITypeReasons</key>
-			<array>
-				<string>85F4.1</string>
-				<string>E174.1</string>
-			</array>
-		</dict>
-		<dict>
-			<key>NSPrivacyAccessedAPIType</key>
-			<string>NSPrivacyAccessedAPICategorySystemBootTime</string>
-			<key>NSPrivacyAccessedAPITypeReasons</key>
-			<array>
-				<string>35F9.1</string>
-			</array>
-		</dict>
-	</array>
-	<key>NSPrivacyCollectedDataTypes</key>
-	<array/>
-	<key>NSPrivacyTracking</key>
-	<false/>
-</dict>
-</plist>
diff --git a/apps/bare-rn/jest.config.js b/apps/bare-rn/jest.config.js
deleted file mode 100644
index 8eb675e9bc..0000000000
--- a/apps/bare-rn/jest.config.js
+++ /dev/null
@@ -1,3 +0,0 @@
-module.exports = {
-  preset: 'react-native',
-};
diff --git a/apps/bare-rn/metro.config.js b/apps/bare-rn/metro.config.js
deleted file mode 100644
index facaedca93..0000000000
--- a/apps/bare-rn/metro.config.js
+++ /dev/null
@@ -1,30 +0,0 @@
-const path = require('path');
-const { getDefaultConfig, mergeConfig } = require('@react-native/metro-config');
-
-const workspaceRoot = path.resolve(__dirname, '../../'); // Adjust the path to your monorepo root
-const projectRoot = __dirname;
-const defaultConfig = getDefaultConfig(projectRoot);
-
-const config = {
-  watchFolders: [
-    workspaceRoot, // Watch the entire monorepo
-  ],
-  resolver: {
-    // Workspace packages (react-native-executorch, bare-resource-fetcher) declare
-    // their own `react` devDependency, so yarn installs a second React copy at
-    // packages/*/node_modules/react. Without disabling hierarchical lookup, Metro
-    // resolves `react` per-file and the bundle ends up with two React instances —
-    // useState's dispatcher comes back null at runtime.
-    disableHierarchicalLookup: true,
-    nodeModulesPaths: [
-      path.resolve(projectRoot, 'node_modules'),
-      path.resolve(workspaceRoot, 'node_modules'),
-    ],
-    assetExts: [
-      ...defaultConfig.resolver.assetExts,
-      'pte', // ExecuTorch model files
-    ],
-  },
-};
-
-module.exports = mergeConfig(defaultConfig, config);
diff --git a/apps/bare-rn/package.json b/apps/bare-rn/package.json
deleted file mode 100644
index e9201874bd..0000000000
--- a/apps/bare-rn/package.json
+++ /dev/null
@@ -1,49 +0,0 @@
-{
-  "name": "bare-rn",
-  "version": "0.0.1",
-  "private": true,
-  "scripts": {
-    "android": "react-native run-android",
-    "ios": "react-native run-ios",
-    "typecheck": "tsc",
-    "lint": "eslint . --ext .ts,.tsx --fix",
-    "start": "react-native start",
-    "test": "jest"
-  },
-  "dependencies": {
-    "@dr.pogodin/react-native-fs": "^2.36.2",
-    "@kesha-antonov/react-native-background-downloader": "^4.4.5",
-    "react": "19.1.0",
-    "react-native": "0.81.5",
-    "react-native-executorch": "workspace:*",
-    "react-native-executorch-bare-resource-fetcher": "workspace:*",
-    "react-native-safe-area-context": "^5.5.2"
-  },
-  "devDependencies": {
-    "@babel/core": "^7.25.2",
-    "@babel/plugin-transform-export-namespace-from": "^7.25.2",
-    "@babel/preset-env": "^7.25.3",
-    "@babel/runtime": "^7.25.0",
-    "@react-native-community/cli": "20.0.0",
-    "@react-native-community/cli-platform-android": "20.0.0",
-    "@react-native-community/cli-platform-ios": "20.0.0",
-    "@react-native/babel-preset": "0.81.5",
-    "@react-native/eslint-config": "0.81.5",
-    "@react-native/metro-config": "0.81.5",
-    "@react-native/typescript-config": "0.81.5",
-    "@types/jest": "^29.5.13",
-    "@types/react": "^19.1.0",
-    "@types/react-test-renderer": "^19.1.0",
-    "eslint": "^8.19.0",
-    "jest": "^29.6.3",
-    "prettier": "2.8.8",
-    "react-test-renderer": "19.1.0",
-    "typescript": "^5.8.3"
-  },
-  "engines": {
-    "node": ">=22"
-  },
-  "installConfig": {
-    "hoistingLimits": "workspaces"
-  }
-}
diff --git a/apps/bare-rn/tsconfig.json b/apps/bare-rn/tsconfig.json
deleted file mode 100644
index 4fe6f139ef..0000000000
--- a/apps/bare-rn/tsconfig.json
+++ /dev/null
@@ -1,17 +0,0 @@
-{
-  "compilerOptions": {
-    "allowJs": true,
-    "allowSyntheticDefaultImports": true,
-    "esModuleInterop": true,
-    "jsx": "react-native",
-    "lib": ["es2022"],
-    "moduleResolution": "bundler",
-    "noEmit": true,
-    "resolveJsonModule": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "target": "esnext"
-  },
-  "include": ["**/*.ts", "**/*.tsx"],
-  "exclude": ["**/node_modules", "**/Pods", "**/__tests__"]
-}
diff --git a/apps/computer-vision/.gitignore b/apps/computer-vision/.gitignore
deleted file mode 100644
index f779c900a7..0000000000
--- a/apps/computer-vision/.gitignore
+++ /dev/null
@@ -1,38 +0,0 @@
-# Learn more https://docs.github.com/en/get-started/getting-started-with-git/ignoring-files
-
-# dependencies
-node_modules/
-
-# Expo
-.expo/
-dist/
-web-build/
-expo-env.d.ts
-
-# Native
-*.orig.*
-*.jks
-*.p8
-*.p12
-*.key
-*.mobileprovision
-
-# Metro
-.metro-health-check*
-
-# debug
-npm-debug.*
-yarn-debug.*
-yarn-error.*
-
-# macOS
-.DS_Store
-*.pem
-
-# local env files
-.env*.local
-
-# typescript
-*.tsbuildinfo
-
-.yarn
diff --git a/apps/computer-vision/ScreenWrapper.tsx b/apps/computer-vision/ScreenWrapper.tsx
deleted file mode 100644
index 31f70e4442..0000000000
--- a/apps/computer-vision/ScreenWrapper.tsx
+++ /dev/null
@@ -1,8 +0,0 @@
-import { useIsFocused } from 'expo-router';
-import { PropsWithChildren } from 'react';
-
-export default function ScreenWrapper({ children }: PropsWithChildren) {
-  const isFocused = useIsFocused();
-
-  return isFocused ? <>{children}</> : null;
-}
diff --git a/apps/computer-vision/app.json b/apps/computer-vision/app.json
deleted file mode 100644
index 6aef6ff728..0000000000
--- a/apps/computer-vision/app.json
+++ /dev/null
@@ -1,50 +0,0 @@
-{
-  "expo": {
-    "name": "computer-vision",
-    "slug": "computer-vision",
-    "version": "1.0.0",
-    "orientation": "portrait",
-    "icon": "./assets/icons/icon.png",
-    "userInterfaceStyle": "light",
-    "newArchEnabled": true,
-    "scheme": "rne-computer-vision",
-    "splash": {
-      "image": "./assets/icons/splash.png",
-      "resizeMode": "contain",
-      "backgroundColor": "#ffffff"
-    },
-    "ios": {
-      "supportsTablet": true,
-      "bundleIdentifier": "com.anonymous.computervision",
-      "infoPlist": {
-        "NSCameraUsageDescription": "Process photo from camera"
-      }
-    },
-    "android": {
-      "adaptiveIcon": {
-        "foregroundImage": "./assets/icons/adaptive-icon.png",
-        "backgroundColor": "#ffffff"
-      },
-      "package": "com.anonymous.computervision",
-      "permissions": ["android.permission.CAMERA"]
-    },
-    "web": {
-      "favicon": "./assets/icons/favicon.png"
-    },
-    "plugins": [
-      "expo-font",
-      "expo-router",
-      [
-        "expo-build-properties",
-        {
-          "android": {
-            "minSdkVersion": 26
-          },
-          "ios": {
-            "deploymentTarget": "17.0"
-          }
-        }
-      ]
-    ]
-  }
-}
diff --git a/apps/computer-vision/app/_layout.tsx b/apps/computer-vision/app/_layout.tsx
deleted file mode 100644
index 5d5c67dca1..0000000000
--- a/apps/computer-vision/app/_layout.tsx
+++ /dev/null
@@ -1,211 +0,0 @@
-import { Drawer } from 'expo-router/drawer';
-import { initExecutorch } from 'react-native-executorch';
-import { ExpoResourceFetcher } from 'react-native-executorch-expo-resource-fetcher';
-
-import ColorPalette from '../colors';
-import React, { useState } from 'react';
-import {
-  Text,
-  StyleSheet,
-  View,
-  TouchableOpacity,
-  type ColorValue,
-} from 'react-native';
-
-import {
-  type DrawerContentComponentProps,
-  DrawerContentScrollView,
-  DrawerItemList,
-} from 'expo-router/build/react-navigation/drawer';
-import { DrawerActions } from 'expo-router/build/react-navigation/routers';
-import { useNavigation } from 'expo-router';
-import Svg, { Rect } from 'react-native-svg';
-import { GeneratingContext } from '../context';
-
-initExecutorch({
-  resourceFetcher: ExpoResourceFetcher,
-});
-
-function HamburgerIcon({ tintColor }: { tintColor?: ColorValue }) {
-  const navigation = useNavigation();
-  const fill = typeof tintColor === 'string' ? tintColor : '#000';
-  return (
-    <TouchableOpacity
-      onPress={() => navigation.dispatch(DrawerActions.toggleDrawer())}
-      style={styles.hamburger}
-    >
-      <Svg width={24} height={24} viewBox="0 0 24 24">
-        <Rect x={2} y={4} width={20} height={2} rx={1} fill={fill} />
-        <Rect x={2} y={11} width={20} height={2} rx={1} fill={fill} />
-        <Rect x={2} y={18} width={20} height={2} rx={1} fill={fill} />
-      </Svg>
-    </TouchableOpacity>
-  );
-}
-
-interface CustomDrawerProps extends DrawerContentComponentProps {
-  isGenerating: boolean;
-}
-
-function CustomDrawerContent(props: CustomDrawerProps) {
-  const { isGenerating, ...otherProps } = props;
-  return (
-    <DrawerContentScrollView {...otherProps}>
-      {!isGenerating ? (
-        <DrawerItemList {...otherProps} />
-      ) : (
-        <View style={styles.centerContent}>
-          <Text style={styles.mainText}>Model is generating...</Text>
-          <Text style={styles.subText}>Interrupt before switching model</Text>
-        </View>
-      )}
-    </DrawerContentScrollView>
-  );
-}
-
-export default function _layout() {
-  const [isGenerating, setIsGenerating] = useState(false);
-
-  return (
-    <GeneratingContext
-      value={{
-        setGlobalGenerating: (newState: boolean) => {
-          setIsGenerating(newState);
-        },
-      }}
-    >
-      <Drawer
-        drawerContent={(props) => (
-          <CustomDrawerContent {...props} isGenerating={isGenerating} />
-        )}
-        screenOptions={{
-          drawerActiveTintColor: ColorPalette.primary,
-          drawerInactiveTintColor: '#888',
-          headerTintColor: ColorPalette.primary,
-          headerTitleStyle: { color: ColorPalette.primary },
-          headerLeft: (props) => <HamburgerIcon tintColor={props.tintColor} />,
-        }}
-      >
-        <Drawer.Screen
-          name="index"
-          options={{
-            drawerLabel: () => null,
-            title: 'Main Menu',
-            drawerItemStyle: { display: 'none' },
-          }}
-        />
-        <Drawer.Screen
-          name="vision_camera/index"
-          options={{
-            drawerLabel: 'Vision Camera',
-            title: 'Vision Camera',
-            headerShown: false,
-            headerTitleStyle: { color: ColorPalette.primary },
-          }}
-        />
-        <Drawer.Screen
-          name="classification/index"
-          options={{
-            drawerLabel: 'Classification',
-            title: 'Classification',
-            headerTitleStyle: { color: ColorPalette.primary },
-          }}
-        />
-        <Drawer.Screen
-          name="semantic_segmentation/index"
-          options={{
-            drawerLabel: 'Semantic Segmentation',
-            title: 'Semantic Segmentation',
-            headerTitleStyle: { color: ColorPalette.primary },
-          }}
-        />
-        <Drawer.Screen
-          name="instance_segmentation/index"
-          options={{
-            drawerLabel: 'Instance Segmentation',
-            title: 'Instance Segmentation',
-            headerTitleStyle: { color: ColorPalette.primary },
-          }}
-        />
-        <Drawer.Screen
-          name="object_detection/index"
-          options={{
-            drawerLabel: 'Object Detection',
-            title: 'Object Detection',
-            headerTitleStyle: { color: ColorPalette.primary },
-          }}
-        />
-        <Drawer.Screen
-          name="pose_estimation/index"
-          options={{
-            drawerLabel: 'Pose Estimation',
-            title: 'Pose Estimation',
-            headerTitleStyle: { color: ColorPalette.primary },
-          }}
-        />
-        <Drawer.Screen
-          name="ocr/index"
-          options={{
-            drawerLabel: 'OCR',
-            title: 'OCR',
-            headerTitleStyle: { color: ColorPalette.primary },
-          }}
-        />
-        <Drawer.Screen
-          name="ocr_vertical/index"
-          options={{
-            drawerLabel: 'OCR Vertical',
-            title: 'Vertical OCR',
-            headerTitleStyle: { color: ColorPalette.primary },
-          }}
-        />
-        <Drawer.Screen
-          name="style_transfer/index"
-          options={{
-            drawerLabel: 'Style Transfer',
-            title: 'Style Transfer',
-            headerTitleStyle: { color: ColorPalette.primary },
-          }}
-        />
-        <Drawer.Screen
-          name="text_to_image/index"
-          options={{
-            drawerLabel: 'Image Generation',
-            title: 'Image Generation',
-            headerTitleStyle: { color: ColorPalette.primary },
-          }}
-        />
-        <Drawer.Screen
-          name="segment_anything/index"
-          options={{
-            drawerLabel: 'Segment Anything',
-            title: 'Segment Anything',
-            headerTitleStyle: { color: ColorPalette.primary },
-          }}
-        />
-      </Drawer>
-    </GeneratingContext>
-  );
-}
-
-const styles = StyleSheet.create({
-  hamburger: {
-    marginLeft: 12,
-  },
-  centerContent: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-    padding: 20,
-  },
-  mainText: {
-    fontSize: 18,
-    fontWeight: 'bold',
-    marginBottom: 10,
-    color: ColorPalette.primary,
-  },
-  subText: {
-    fontSize: 14,
-    color: ColorPalette.strongPrimary,
-  },
-});
diff --git a/apps/computer-vision/app/classification/index.tsx b/apps/computer-vision/app/classification/index.tsx
deleted file mode 100644
index 55a42f7422..0000000000
--- a/apps/computer-vision/app/classification/index.tsx
+++ /dev/null
@@ -1,197 +0,0 @@
-import Spinner from '../../components/Spinner';
-import { getImage } from '../../utils';
-import {
-  models,
-  useClassification,
-  ClassificationModelSources,
-} from 'react-native-executorch';
-import { ModelPicker, ModelOption } from '../../components/ModelPicker';
-const classification = models.classification;
-
-const MODELS: ModelOption<ClassificationModelSources>[] = [
-  {
-    label: 'EfficientNet V2 S Quantized',
-    value: classification.efficientnet_v2_s(),
-  },
-  {
-    label: 'EfficientNet V2 S',
-    value: classification.efficientnet_v2_s({ quant: false }),
-  },
-];
-import { View, StyleSheet, Image, Text, ScrollView } from 'react-native';
-import { BottomBar } from '../../components/BottomBar';
-import React, { useContext, useEffect, useState } from 'react';
-import { GeneratingContext } from '../../context';
-import ScreenWrapper from '../../ScreenWrapper';
-import { StatsBar } from '../../components/StatsBar';
-import ErrorBanner from '../../components/ErrorBanner';
-
-export default function ClassificationScreen() {
-  const [selectedModel, setSelectedModel] =
-    useState<ClassificationModelSources>(classification.efficientnet_v2_s());
-  const [results, setResults] = useState<{ label: string; score: number }[]>(
-    []
-  );
-  const [imageUri, setImageUri] = useState('');
-  const [inferenceTime, setInferenceTime] = useState<number | null>(null);
-
-  const [error, setError] = useState<string | null>(null);
-
-  const model = useClassification({ model: selectedModel });
-  const { setGlobalGenerating } = useContext(GeneratingContext);
-
-  useEffect(() => {
-    setGlobalGenerating(model.isGenerating);
-  }, [model.isGenerating, setGlobalGenerating]);
-
-  useEffect(() => {
-    if (model.error) setError(String(model.error));
-  }, [model.error]);
-
-  const handleCameraPress = async (isCamera: boolean) => {
-    const image = await getImage(isCamera);
-    const uri = image?.uri;
-    if (typeof uri === 'string') {
-      setImageUri(uri as string);
-      setResults([]);
-      setInferenceTime(null);
-    }
-  };
-
-  const runForward = async () => {
-    if (imageUri) {
-      try {
-        const start = Date.now();
-        const output = await model.forward(imageUri);
-        setInferenceTime(Date.now() - start);
-        const top10 = Object.entries(output)
-          .sort(([, a], [, b]) => (b as number) - (a as number))
-          .slice(0, 10)
-          .map(([label, score]) => ({ label, score: score as number }));
-        setResults(top10);
-      } catch (e) {
-        setError(e instanceof Error ? e.message : String(e));
-      }
-    }
-  };
-
-  if (!model.isReady && !model.error) {
-    return (
-      <Spinner
-        visible={true}
-        textContent={`Loading the model ${(model.downloadProgress * 100).toFixed(0)} %`}
-      />
-    );
-  }
-
-  return (
-    <ScreenWrapper>
-      <ErrorBanner message={error} onDismiss={() => setError(null)} />
-
-      <View style={styles.imageContainer}>
-        <Image
-          style={styles.image}
-          resizeMode="contain"
-          source={
-            imageUri
-              ? { uri: imageUri }
-              : require('../../assets/icons/executorch_logo.png')
-          }
-        />
-        {!imageUri && (
-          <View style={styles.infoContainer}>
-            <Text style={styles.infoTitle}>Image Classification</Text>
-            <Text style={styles.infoText}>
-              This model analyzes an image and returns the top 10 most likely
-              labels with confidence scores. Use the gallery or camera icons
-              below to pick an image, then tap the button to run the model.
-            </Text>
-          </View>
-        )}
-        {results.length > 0 && (
-          <View style={styles.results}>
-            <Text style={styles.resultHeader}>Results Top 10</Text>
-            <ScrollView style={styles.resultsList}>
-              {results.map(({ label, score }) => (
-                <View key={label} style={styles.resultRecord}>
-                  <Text style={styles.resultLabel}>{label}</Text>
-                  <Text>{score.toFixed(3)}</Text>
-                </View>
-              ))}
-            </ScrollView>
-          </View>
-        )}
-      </View>
-      <ModelPicker
-        models={MODELS}
-        selectedModel={selectedModel}
-        disabled={model.isGenerating}
-        onSelect={(m) => {
-          setSelectedModel(m);
-          setResults([]);
-        }}
-      />
-      <StatsBar inferenceTime={inferenceTime} />
-      <BottomBar
-        handleCameraPress={handleCameraPress}
-        runForward={runForward}
-        hasImage={!!imageUri}
-        isGenerating={model.isGenerating}
-      />
-    </ScreenWrapper>
-  );
-}
-
-const styles = StyleSheet.create({
-  imageContainer: {
-    flex: 6,
-    width: '100%',
-    padding: 16,
-  },
-  image: {
-    flex: 2,
-    borderRadius: 8,
-    width: '100%',
-  },
-  results: {
-    flex: 1,
-    alignItems: 'center',
-    justifyContent: 'center',
-    gap: 4,
-    padding: 4,
-  },
-  resultHeader: {
-    fontSize: 18,
-    color: 'navy',
-  },
-  resultsList: {
-    flex: 1,
-  },
-  resultRecord: {
-    flexDirection: 'row',
-    width: '100%',
-    justifyContent: 'space-between',
-    padding: 8,
-    borderBottomWidth: 1,
-  },
-  resultLabel: {
-    flex: 1,
-    marginRight: 4,
-  },
-  infoContainer: {
-    alignItems: 'center',
-    padding: 16,
-    gap: 8,
-  },
-  infoTitle: {
-    fontSize: 18,
-    fontWeight: '600',
-    color: 'navy',
-  },
-  infoText: {
-    fontSize: 14,
-    color: '#555',
-    textAlign: 'center',
-    lineHeight: 20,
-  },
-});
diff --git a/apps/computer-vision/app/index.tsx b/apps/computer-vision/app/index.tsx
deleted file mode 100644
index e67e7eb5cb..0000000000
--- a/apps/computer-vision/app/index.tsx
+++ /dev/null
@@ -1,123 +0,0 @@
-import { useRouter } from 'expo-router';
-import { View, Text, StyleSheet, TouchableOpacity } from 'react-native';
-import ColorPalette from '../colors';
-import ExecutorchLogo from '../assets/icons/executorch.svg';
-
-export default function Home() {
-  const router = useRouter();
-
-  return (
-    <View style={styles.container}>
-      <ExecutorchLogo width={64} height={64} />
-      <Text style={styles.headerText}>Select a demo model</Text>
-      <View style={styles.buttonContainer}>
-        <TouchableOpacity
-          style={styles.button}
-          onPress={() => router.navigate('vision_camera/')}
-        >
-          <Text style={styles.buttonText}>Vision Camera</Text>
-        </TouchableOpacity>
-        <TouchableOpacity
-          style={styles.button}
-          onPress={() => router.navigate('classification/')}
-        >
-          <Text style={styles.buttonText}>Classification</Text>
-        </TouchableOpacity>
-        <TouchableOpacity
-          style={styles.button}
-          onPress={() => router.navigate('semantic_segmentation/')}
-        >
-          <Text style={styles.buttonText}>Semantic Segmentation</Text>
-        </TouchableOpacity>
-        <TouchableOpacity
-          style={styles.button}
-          onPress={() => router.navigate('object_detection/')}
-        >
-          <Text style={styles.buttonText}>Object Detection</Text>
-        </TouchableOpacity>
-        <TouchableOpacity
-          style={styles.button}
-          onPress={() => router.navigate('instance_segmentation/')}
-        >
-          <Text style={styles.buttonText}>Instance Segmentation</Text>
-        </TouchableOpacity>
-        <TouchableOpacity
-          style={styles.button}
-          onPress={() => router.navigate('pose_estimation/')}
-        >
-          <Text style={styles.buttonText}>Pose Estimation</Text>
-        </TouchableOpacity>
-        <TouchableOpacity
-          style={styles.button}
-          onPress={() => router.navigate('segment_anything/')}
-        >
-          <Text style={styles.buttonText}>Segment Anything</Text>
-        </TouchableOpacity>
-        <TouchableOpacity
-          style={styles.button}
-          onPress={() => router.navigate('ocr/')}
-        >
-          <Text style={styles.buttonText}>OCR</Text>
-        </TouchableOpacity>
-        <TouchableOpacity
-          style={styles.button}
-          onPress={() => router.navigate('ocr_vertical/')}
-        >
-          <Text style={styles.buttonText}>OCR Vertical</Text>
-        </TouchableOpacity>
-        <TouchableOpacity
-          style={styles.button}
-          onPress={() => router.navigate('style_transfer/')}
-        >
-          <Text style={styles.buttonText}>Style Transfer</Text>
-        </TouchableOpacity>
-        <TouchableOpacity
-          style={styles.button}
-          onPress={() => router.navigate('text_to_image/')}
-        >
-          <Text style={styles.buttonText}>Image Generation</Text>
-        </TouchableOpacity>
-      </View>
-    </View>
-  );
-}
-
-export const fontSizes = {
-  xxl: 34,
-  xl: 22,
-  lg: 18,
-  md: 16,
-  sm: 14,
-  xs: 12,
-  xxs: 10,
-};
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-    backgroundColor: '#fff',
-  },
-  headerText: {
-    fontSize: fontSizes.lg,
-    color: ColorPalette.strongPrimary,
-    margin: 20,
-  },
-  buttonContainer: {
-    width: '80%',
-    justifyContent: 'space-evenly',
-    marginBottom: 20,
-  },
-  button: {
-    backgroundColor: ColorPalette.strongPrimary,
-    borderRadius: 8,
-    padding: 10,
-    alignItems: 'center',
-    marginBottom: 10,
-  },
-  buttonText: {
-    color: 'white',
-    fontSize: fontSizes.md,
-  },
-});
diff --git a/apps/computer-vision/app/instance_segmentation/index.tsx b/apps/computer-vision/app/instance_segmentation/index.tsx
deleted file mode 100644
index fea9698eb3..0000000000
--- a/apps/computer-vision/app/instance_segmentation/index.tsx
+++ /dev/null
@@ -1,367 +0,0 @@
-import Spinner from '../../components/Spinner';
-import { BottomBar } from '../../components/BottomBar';
-import { getImage } from '../../utils';
-import { ModelPicker, ModelOption } from '../../components/ModelPicker';
-import {
-  models,
-  useInstanceSegmentation,
-  InstanceSegmentationModelSources,
-} from 'react-native-executorch';
-import {
-  View,
-  StyleSheet,
-  ScrollView,
-  Text,
-  TouchableOpacity,
-} from 'react-native';
-import React, { useContext, useEffect, useState } from 'react';
-import { GeneratingContext } from '../../context';
-import ScreenWrapper from '../../ScreenWrapper';
-import ImageWithMasks, {
-  buildDisplayInstances,
-  DisplayInstance,
-} from '../../components/ImageWithMasks';
-import { StatsBar } from '../../components/StatsBar';
-const instanceSegmentation = models.instance_segmentation;
-
-const MODELS: ModelOption<InstanceSegmentationModelSources>[] = [
-  { label: 'Yolo26N', value: instanceSegmentation.yolo26n() },
-  { label: 'Yolo26S', value: instanceSegmentation.yolo26s() },
-  { label: 'Yolo26M', value: instanceSegmentation.yolo26m() },
-  { label: 'Yolo26L', value: instanceSegmentation.yolo26l() },
-  { label: 'Yolo26X', value: instanceSegmentation.yolo26x() },
-  {
-    label: 'RF-DeTR Nano',
-    value: instanceSegmentation.rf_detr_nano(),
-  },
-  { label: 'FastSAM-S', value: instanceSegmentation.fastsam_s() },
-  { label: 'FastSAM-X', value: instanceSegmentation.fastsam_x() },
-];
-
-export default function InstanceSegmentationScreen() {
-  const [selectedModel, setSelectedModel] =
-    useState<InstanceSegmentationModelSources>(instanceSegmentation.yolo26n());
-  const [inferenceTime, setInferenceTime] = useState<number | null>(null);
-
-  const { setGlobalGenerating } = useContext(GeneratingContext);
-
-  const {
-    isReady,
-    isGenerating,
-    downloadProgress,
-    forward,
-    error,
-    getAvailableInputSizes,
-  } = useInstanceSegmentation({
-    model: selectedModel,
-  });
-
-  const [imageUri, setImageUri] = useState('');
-  const [imageSize, setImageSize] = useState({ width: 0, height: 0 });
-  const [instances, setInstances] = useState<DisplayInstance[]>([]);
-  const [selectedInputSize, setSelectedInputSize] = useState<number | null>(
-    null
-  );
-
-  const availableInputSizes = getAvailableInputSizes();
-
-  useEffect(() => {
-    setGlobalGenerating(isGenerating);
-  }, [isGenerating, setGlobalGenerating]);
-
-  // Set default input size when model is ready
-  useEffect(() => {
-    if (!isReady) return;
-
-    if (availableInputSizes && availableInputSizes.length > 0) {
-      setSelectedInputSize((prev) => {
-        if (typeof prev === 'number' && availableInputSizes.includes(prev)) {
-          return prev;
-        }
-        return availableInputSizes[0];
-      });
-      return;
-    }
-
-    setSelectedInputSize(null);
-  }, [isReady, availableInputSizes]);
-
-  const handleCameraPress = async (isCamera: boolean) => {
-    const image = await getImage(isCamera);
-    if (!image?.uri) return;
-    setImageUri(image.uri);
-    setImageSize({
-      width: image.width ?? 0,
-      height: image.height ?? 0,
-    });
-    setInstances([]);
-    setInferenceTime(null);
-  };
-
-  const runForward = async () => {
-    if (!imageUri || imageSize.width === 0 || imageSize.height === 0) return;
-
-    const inputSize =
-      availableInputSizes &&
-      typeof selectedInputSize === 'number' &&
-      availableInputSizes.includes(selectedInputSize)
-        ? selectedInputSize
-        : undefined;
-
-    try {
-      const start = Date.now();
-      const output = await forward(imageUri, {
-        confidenceThreshold: 0.5,
-        iouThreshold: 0.55,
-        maxInstances: 20,
-        returnMaskAtOriginalResolution: true,
-        inputSize,
-      });
-
-      setInferenceTime(Date.now() - start);
-
-      // Convert raw masks → small Skia images immediately.
-      // Raw Uint8Array mask buffers (backed by native OwningArrayBuffer)
-      // go out of scope here and become eligible for GC right away.
-      setInstances(buildDisplayInstances(output));
-    } catch (e) {
-      console.error(e);
-    }
-  };
-
-  if (!isReady && error) {
-    return (
-      <ScreenWrapper>
-        <View style={styles.errorContainer}>
-          <Text style={styles.errorTitle}>Error Loading Model</Text>
-          <Text style={styles.errorText}>
-            {error?.message || 'Unknown error occurred'}
-          </Text>
-          <Text style={styles.errorCode}>Code: {error?.code || 'N/A'}</Text>
-        </View>
-      </ScreenWrapper>
-    );
-  }
-
-  if (!isReady) {
-    return (
-      <Spinner
-        visible={!isReady}
-        textContent={`Loading the model ${(downloadProgress * 100).toFixed(0)} %`}
-      />
-    );
-  }
-
-  return (
-    <ScreenWrapper>
-      <View style={styles.container}>
-        <View style={styles.imageContainer}>
-          <ImageWithMasks
-            imageUri={imageUri}
-            instances={instances}
-            imageWidth={imageSize.width}
-            imageHeight={imageSize.height}
-          />
-          {!imageUri && (
-            <View style={styles.infoContainer}>
-              <Text style={styles.infoTitle}>Instance Segmentation</Text>
-              <Text style={styles.infoText}>
-                This model detects individual objects and draws a precise mask
-                over each one. Pick an image from your gallery or take one with
-                your camera to get started.
-              </Text>
-            </View>
-          )}
-        </View>
-
-        {imageUri && availableInputSizes && availableInputSizes.length > 0 && (
-          <View style={styles.inputSizeContainer}>
-            <Text style={styles.inputSizeLabel}>Input Size:</Text>
-            <ScrollView
-              horizontal
-              showsHorizontalScrollIndicator={false}
-              style={styles.inputSizeScroll}
-            >
-              {availableInputSizes.map((size) => (
-                <TouchableOpacity
-                  key={size}
-                  style={[
-                    styles.sizeButton,
-                    selectedInputSize === size && styles.sizeButtonActive,
-                  ]}
-                  onPress={() => setSelectedInputSize(size)}
-                >
-                  <Text
-                    style={[
-                      styles.sizeButtonText,
-                      selectedInputSize === size && styles.sizeButtonTextActive,
-                    ]}
-                  >
-                    {size}
-                  </Text>
-                </TouchableOpacity>
-              ))}
-            </ScrollView>
-          </View>
-        )}
-
-        {instances.length > 0 && (
-          <View style={styles.resultsContainer}>
-            <Text style={styles.resultsHeader}>
-              Detected {instances.length} instance(s)
-            </Text>
-            <ScrollView style={styles.resultsList}>
-              {instances.map((instance, idx) => (
-                <View key={idx} style={styles.resultRow}>
-                  <Text style={styles.resultText}>
-                    {instance.label || 'Unknown'} (
-                    {(instance.score * 100).toFixed(1)}%)
-                  </Text>
-                </View>
-              ))}
-            </ScrollView>
-          </View>
-        )}
-      </View>
-
-      <ModelPicker
-        models={MODELS}
-        selectedModel={selectedModel}
-        disabled={isGenerating}
-        onSelect={(m) => {
-          setSelectedModel(m);
-          setInstances([]);
-          setInferenceTime(null);
-        }}
-      />
-
-      <StatsBar
-        inferenceTime={inferenceTime}
-        detectionCount={instances.length > 0 ? instances.length : null}
-      />
-
-      <BottomBar
-        handleCameraPress={handleCameraPress}
-        runForward={runForward}
-        hasImage={!!imageUri}
-        isGenerating={isGenerating}
-      />
-    </ScreenWrapper>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 6,
-    width: '100%',
-  },
-  imageContainer: {
-    flex: 1,
-    width: '100%',
-    padding: 16,
-  },
-  inputSizeContainer: {
-    paddingHorizontal: 16,
-    paddingVertical: 12,
-    backgroundColor: '#fff',
-    borderTopWidth: 1,
-    borderTopColor: '#e0e0e0',
-  },
-  inputSizeLabel: {
-    fontSize: 14,
-    fontWeight: '600',
-    color: '#333',
-    marginBottom: 8,
-  },
-  inputSizeScroll: {
-    flexDirection: 'row',
-  },
-  sizeButton: {
-    paddingHorizontal: 16,
-    paddingVertical: 8,
-    marginRight: 8,
-    borderRadius: 6,
-    backgroundColor: '#f0f0f0',
-  },
-  sizeButtonActive: {
-    backgroundColor: '#007AFF',
-  },
-  sizeButtonText: {
-    fontSize: 14,
-    fontWeight: '600',
-    color: '#666',
-  },
-  sizeButtonTextActive: {
-    color: '#fff',
-  },
-  resultsContainer: {
-    maxHeight: 200,
-    paddingHorizontal: 16,
-    paddingVertical: 12,
-    backgroundColor: '#fff',
-    borderTopWidth: 1,
-    borderTopColor: '#e0e0e0',
-  },
-  resultsHeader: {
-    fontSize: 16,
-    fontWeight: '600',
-    marginBottom: 8,
-    color: '#333',
-  },
-  resultsList: {
-    flex: 1,
-  },
-  resultRow: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    paddingVertical: 6,
-    paddingHorizontal: 8,
-    marginBottom: 4,
-    backgroundColor: '#f9f9f9',
-    borderRadius: 6,
-  },
-  resultText: {
-    fontSize: 14,
-    fontWeight: '500',
-    color: '#333',
-  },
-  errorContainer: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-    padding: 32,
-  },
-  errorTitle: {
-    fontSize: 20,
-    fontWeight: '700',
-    color: '#e74c3c',
-    marginBottom: 12,
-  },
-  errorText: {
-    fontSize: 14,
-    color: '#555',
-    textAlign: 'center',
-    marginBottom: 8,
-  },
-  errorCode: {
-    fontSize: 12,
-    color: '#999',
-    fontFamily: 'Courier',
-  },
-  infoContainer: {
-    alignItems: 'center',
-    padding: 16,
-    gap: 8,
-  },
-  infoTitle: {
-    fontSize: 18,
-    fontWeight: '600',
-    color: 'navy',
-  },
-  infoText: {
-    fontSize: 14,
-    color: '#555',
-    textAlign: 'center',
-    lineHeight: 20,
-  },
-});
diff --git a/apps/computer-vision/app/object_detection/index.tsx b/apps/computer-vision/app/object_detection/index.tsx
deleted file mode 100644
index 1ed3c136ba..0000000000
--- a/apps/computer-vision/app/object_detection/index.tsx
+++ /dev/null
@@ -1,181 +0,0 @@
-import Spinner from '../../components/Spinner';
-import { BottomBar } from '../../components/BottomBar';
-import { ModelPicker, ModelOption } from '../../components/ModelPicker';
-import { getImage } from '../../utils';
-import {
-  models,
-  Detection,
-  useObjectDetection,
-  ObjectDetectionModelSources,
-} from 'react-native-executorch';
-import { View, StyleSheet, Image, Text } from 'react-native';
-import ImageWithBboxes from '../../components/ImageWithBboxes';
-import React, { useContext, useEffect, useState } from 'react';
-import { GeneratingContext } from '../../context';
-import ScreenWrapper from '../../ScreenWrapper';
-import { StatsBar } from '../../components/StatsBar';
-const objectDetection = models.object_detection;
-
-const MODELS: ModelOption<ObjectDetectionModelSources>[] = [
-  {
-    label: 'RF-DeTR Nano',
-    value: objectDetection.rf_detr_nano(),
-  },
-  {
-    label: 'SSDLite MobileNet',
-    value: objectDetection.ssdlite_320_mobilenet_v3_large(),
-  },
-  { label: 'YOLO26N', value: objectDetection.yolo26n() },
-  { label: 'YOLO26S', value: objectDetection.yolo26s() },
-  { label: 'YOLO26M', value: objectDetection.yolo26m() },
-  { label: 'YOLO26L', value: objectDetection.yolo26l() },
-  { label: 'YOLO26X', value: objectDetection.yolo26x() },
-];
-import ErrorBanner from '../../components/ErrorBanner';
-
-export default function ObjectDetectionScreen() {
-  const [imageUri, setImageUri] = useState('');
-  const [results, setResults] = useState<Detection[]>([]);
-  const [error, setError] = useState<string | null>(null);
-  const [imageDimensions, setImageDimensions] = useState<{
-    width: number;
-    height: number;
-  }>();
-  const [selectedModel, setSelectedModel] =
-    useState<ObjectDetectionModelSources>(objectDetection.rf_detr_nano());
-  const [inferenceTime, setInferenceTime] = useState<number | null>(null);
-
-  const model = useObjectDetection({ model: selectedModel });
-  const { setGlobalGenerating } = useContext(GeneratingContext);
-  useEffect(() => {
-    setGlobalGenerating(model.isGenerating);
-  }, [model.isGenerating, setGlobalGenerating]);
-
-  useEffect(() => {
-    if (model.error) setError(String(model.error));
-  }, [model.error]);
-
-  const handleCameraPress = async (isCamera: boolean) => {
-    const image = await getImage(isCamera);
-    const uri = image?.uri;
-    const width = image?.width;
-    const height = image?.height;
-
-    if (uri && width && height) {
-      setImageUri(image.uri as string);
-      setImageDimensions({ width: width as number, height: height as number });
-      setResults([]);
-      setInferenceTime(null);
-    }
-  };
-
-  const runForward = async () => {
-    if (imageUri) {
-      try {
-        const start = Date.now();
-        const output = await model.forward(imageUri);
-        setInferenceTime(Date.now() - start);
-        setResults(output);
-      } catch (e) {
-        setError(e instanceof Error ? e.message : String(e));
-      }
-    }
-  };
-
-  if (!model.isReady) {
-    return (
-      <Spinner
-        visible={!model.isReady}
-        textContent={`Loading the model ${(model.downloadProgress * 100).toFixed(0)} %`}
-      />
-    );
-  }
-
-  return (
-    <ScreenWrapper>
-      <ErrorBanner message={error} onDismiss={() => setError(null)} />
-      <View style={styles.imageContainer}>
-        <View style={styles.image}>
-          {imageUri && imageDimensions?.width && imageDimensions?.height ? (
-            <ImageWithBboxes
-              imageUri={
-                imageUri || require('../../assets/icons/executorch_logo.png')
-              }
-              imageWidth={imageDimensions.width}
-              imageHeight={imageDimensions.height}
-              detections={results}
-            />
-          ) : (
-            <Image
-              style={styles.fullSizeImage}
-              resizeMode="contain"
-              source={require('../../assets/icons/executorch_logo.png')}
-            />
-          )}
-        </View>
-        {!imageUri && (
-          <View style={styles.infoContainer}>
-            <Text style={styles.infoTitle}>Object Detection</Text>
-            <Text style={styles.infoText}>
-              This model detects objects in an image and draws bounding boxes
-              around them with class labels and confidence scores. Pick an image
-              from your gallery or take one with your camera to get started.
-            </Text>
-          </View>
-        )}
-      </View>
-      <ModelPicker
-        models={MODELS}
-        selectedModel={selectedModel}
-        disabled={model.isGenerating}
-        onSelect={(m) => {
-          setSelectedModel(m);
-          setResults([]);
-        }}
-      />
-      <StatsBar
-        inferenceTime={inferenceTime}
-        detectionCount={results.length > 0 ? results.length : null}
-      />
-      <BottomBar
-        handleCameraPress={handleCameraPress}
-        runForward={runForward}
-        hasImage={!!imageUri}
-        isGenerating={model.isGenerating}
-      />
-    </ScreenWrapper>
-  );
-}
-
-const styles = StyleSheet.create({
-  imageContainer: {
-    flex: 6,
-    width: '100%',
-    padding: 16,
-  },
-  image: {
-    flex: 2,
-    borderRadius: 8,
-    width: '100%',
-  },
-  fullSizeImage: {
-    width: '100%',
-    height: '100%',
-  },
-  infoContainer: {
-    alignItems: 'center',
-    padding: 16,
-    gap: 8,
-  },
-  infoTitle: {
-    fontSize: 18,
-    fontWeight: '600',
-    color: 'navy',
-  },
-  infoText: {
-    fontSize: 14,
-    color: '#555',
-    textAlign: 'center',
-    lineHeight: 20,
-  },
-});
diff --git a/apps/computer-vision/app/ocr/index.tsx b/apps/computer-vision/app/ocr/index.tsx
deleted file mode 100644
index b81b57326c..0000000000
--- a/apps/computer-vision/app/ocr/index.tsx
+++ /dev/null
@@ -1,212 +0,0 @@
-import Spinner from '../../components/Spinner';
-import { BottomBar } from '../../components/BottomBar';
-import { ModelPicker, ModelOption } from '../../components/ModelPicker';
-import { getImage } from '../../utils';
-import { models, useOCR, OCRProps } from 'react-native-executorch';
-import { View, StyleSheet, Image, Text, ScrollView } from 'react-native';
-import ImageWithBboxes2 from '../../components/ImageWithOCRBboxes';
-import React, { useContext, useEffect, useState } from 'react';
-import { GeneratingContext } from '../../context';
-import ScreenWrapper from '../../ScreenWrapper';
-import { StatsBar } from '../../components/StatsBar';
-
-type OCRModelSources = OCRProps['model'];
-
-const ocr = models.ocr.craft;
-
-const MODELS: ModelOption<OCRModelSources>[] = [
-  { label: 'English', value: ocr({ language: 'en' }) },
-  { label: 'German', value: ocr({ language: 'de' }) },
-  { label: 'French', value: ocr({ language: 'fr' }) },
-  { label: 'Spanish', value: ocr({ language: 'es' }) },
-  { label: 'Italian', value: ocr({ language: 'it' }) },
-  { label: 'Japanese', value: ocr({ language: 'ja' }) },
-  { label: 'Korean', value: ocr({ language: 'ko' }) },
-];
-import ErrorBanner from '../../components/ErrorBanner';
-
-export default function OCRScreen() {
-  const [imageUri, setImageUri] = useState('');
-  const [results, setResults] = useState<any[]>([]);
-  const [error, setError] = useState<string | null>(null);
-  const [imageDimensions, setImageDimensions] = useState<{
-    width: number;
-    height: number;
-  }>();
-  const [selectedModel, setSelectedModel] = useState<OCRModelSources>(
-    ocr({ language: 'en' })
-  );
-  const [inferenceTime, setInferenceTime] = useState<number | null>(null);
-
-  const model = useOCR({
-    model: selectedModel,
-  });
-  const { setGlobalGenerating } = useContext(GeneratingContext);
-  useEffect(() => {
-    setGlobalGenerating(model.isGenerating);
-  }, [model.isGenerating, setGlobalGenerating]);
-
-  useEffect(() => {
-    if (model.error) setError(String(model.error));
-  }, [model.error]);
-
-  const handleCameraPress = async (isCamera: boolean) => {
-    const image = await getImage(isCamera);
-    const width = image?.width;
-    const height = image?.height;
-    setImageDimensions({ width: width as number, height: height as number });
-    const uri = image?.uri;
-    if (typeof uri === 'string') {
-      setImageUri(uri as string);
-      setResults([]);
-      setInferenceTime(null);
-    }
-  };
-
-  const runForward = async () => {
-    try {
-      const start = Date.now();
-      const output = await model.forward(imageUri);
-      setInferenceTime(Date.now() - start);
-      setResults(output);
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-    }
-  };
-
-  if (!model.isReady && !model.error) {
-    return (
-      <Spinner
-        visible={true}
-        textContent={`Loading the model ${(model.downloadProgress * 100).toFixed(0)} %`}
-      />
-    );
-  }
-
-  return (
-    <ScreenWrapper>
-      <ErrorBanner message={error} onDismiss={() => setError(null)} />
-      <View style={styles.container}>
-        <View style={styles.imageContainer}>
-          {imageUri && imageDimensions?.width && imageDimensions?.height ? (
-            <ImageWithBboxes2
-              detections={results}
-              imageWidth={imageDimensions?.width}
-              imageHeight={imageDimensions?.height}
-              imageUri={
-                imageUri || require('../../assets/icons/executorch_logo.png')
-              }
-            />
-          ) : (
-            <Image
-              style={styles.image}
-              resizeMode="contain"
-              source={require('../../assets/icons/executorch_logo.png')}
-            />
-          )}
-        </View>
-        {!imageUri && (
-          <View style={styles.infoContainer}>
-            <Text style={styles.infoTitle}>OCR</Text>
-            <Text style={styles.infoText}>
-              This model reads and extracts text from images, returning each
-              detected text region with its bounding box and confidence score.
-              Pick an image from your gallery or take one with your camera to
-              get started.
-            </Text>
-          </View>
-        )}
-        {results.length > 0 && (
-          <View style={styles.results}>
-            <Text style={styles.resultHeader}>Results</Text>
-            <ScrollView style={styles.resultsList}>
-              {results.map(({ text, score }, index) => (
-                <View key={index} style={styles.resultRecord}>
-                  <Text style={styles.resultLabel}>{text}</Text>
-                  <Text>{score.toFixed(3)}</Text>
-                </View>
-              ))}
-            </ScrollView>
-          </View>
-        )}
-      </View>
-      <ModelPicker
-        models={MODELS}
-        selectedModel={selectedModel}
-        disabled={model.isGenerating}
-        onSelect={(m) => {
-          setSelectedModel(m);
-          setResults([]);
-        }}
-      />
-      <StatsBar
-        inferenceTime={inferenceTime}
-        detectionCount={results.length > 0 ? results.length : null}
-      />
-      <BottomBar
-        handleCameraPress={handleCameraPress}
-        runForward={runForward}
-        hasImage={!!imageUri}
-        isGenerating={model.isGenerating}
-      />
-    </ScreenWrapper>
-  );
-}
-
-const styles = StyleSheet.create({
-  imageContainer: {
-    flex: 2,
-    borderRadius: 8,
-    width: '100%',
-  },
-  container: {
-    flex: 6,
-    width: '100%',
-    padding: 16,
-  },
-  image: {
-    width: '100%',
-    height: '100%',
-  },
-  results: {
-    flex: 1,
-    alignItems: 'center',
-    justifyContent: 'center',
-    gap: 4,
-    padding: 4,
-  },
-  resultHeader: {
-    fontSize: 18,
-    color: 'navy',
-  },
-  resultsList: {
-    flex: 1,
-  },
-  resultRecord: {
-    flexDirection: 'row',
-    width: '100%',
-    justifyContent: 'space-between',
-    padding: 8,
-    borderBottomWidth: 1,
-  },
-  resultLabel: {
-    flex: 1,
-    marginRight: 4,
-  },
-  infoContainer: {
-    alignItems: 'center',
-    padding: 16,
-    gap: 8,
-  },
-  infoTitle: {
-    fontSize: 18,
-    fontWeight: '600',
-    color: 'navy',
-  },
-  infoText: {
-    fontSize: 14,
-    color: '#555',
-    textAlign: 'center',
-    lineHeight: 20,
-  },
-});
diff --git a/apps/computer-vision/app/ocr_vertical/index.tsx b/apps/computer-vision/app/ocr_vertical/index.tsx
deleted file mode 100644
index f1a015eb01..0000000000
--- a/apps/computer-vision/app/ocr_vertical/index.tsx
+++ /dev/null
@@ -1,199 +0,0 @@
-import Spinner from '../../components/Spinner';
-import { BottomBar } from '../../components/BottomBar';
-import { getImage } from '../../utils';
-import { models, useVerticalOCR } from 'react-native-executorch';
-import { View, StyleSheet, Image, Text, ScrollView } from 'react-native';
-import ImageWithBboxes2 from '../../components/ImageWithOCRBboxes';
-import React, { useContext, useEffect, useState } from 'react';
-import { GeneratingContext } from '../../context';
-import ScreenWrapper from '../../ScreenWrapper';
-import { StatsBar } from '../../components/StatsBar';
-import ErrorBanner from '../../components/ErrorBanner';
-
-export default function VerticalOCRScreen() {
-  const [imageUri, setImageUri] = useState('');
-  const [results, setResults] = useState<any[]>([]);
-  const [imageDimensions, setImageDimensions] = useState<{
-    width: number;
-    height: number;
-  }>();
-  const [inferenceTime, setInferenceTime] = useState<number | null>(null);
-
-  const [error, setError] = useState<string | null>(null);
-
-  const model = useVerticalOCR({
-    model: models.ocr.craft({ language: 'en' }),
-    independentCharacters: true,
-  });
-
-  const { setGlobalGenerating } = useContext(GeneratingContext);
-
-  useEffect(() => {
-    setGlobalGenerating(model.isGenerating);
-  }, [model.isGenerating, setGlobalGenerating]);
-
-  useEffect(() => {
-    if (model.error) setError(String(model.error));
-  }, [model.error]);
-
-  const handleCameraPress = async (isCamera: boolean) => {
-    const image = await getImage(isCamera);
-    const width = image?.width;
-    const height = image?.height;
-    setImageDimensions({ width: width as number, height: height as number });
-    const uri = image?.uri;
-    if (typeof uri === 'string') {
-      setImageUri(uri as string);
-      setResults([]);
-      setInferenceTime(null);
-    }
-  };
-
-  const runForward = async () => {
-    try {
-      const start = Date.now();
-      const output = await model.forward(imageUri);
-      setInferenceTime(Date.now() - start);
-      setResults(output);
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-    }
-  };
-
-  if (!model.isReady && !model.error) {
-    return (
-      <Spinner
-        visible={true}
-        textContent={`Loading the model ${(model.downloadProgress * 100).toFixed(0)} %`}
-      />
-    );
-  }
-
-  return (
-    <ScreenWrapper>
-      <View style={styles.container}>
-        <ErrorBanner message={error} onDismiss={() => setError(null)} />
-
-        <View style={styles.imageContainer}>
-          {imageUri && imageDimensions?.width && imageDimensions?.height ? (
-            <ImageWithBboxes2
-              detections={results}
-              imageWidth={imageDimensions?.width}
-              imageHeight={imageDimensions?.height}
-              imageUri={
-                imageUri || require('../../assets/icons/executorch_logo.png')
-              }
-            />
-          ) : (
-            <Image
-              style={styles.image}
-              resizeMode="contain"
-              source={require('../../assets/icons/executorch_logo.png')}
-            />
-          )}
-        </View>
-        {!imageUri && (
-          <View style={styles.infoContainer}>
-            <Text style={styles.infoTitle}>Vertical OCR</Text>
-            <Text style={styles.infoText}>
-              This model reads vertical text (e.g. Japanese, Korean, Chinese
-              columns) from images, returning each detected text region with its
-              bounding box and confidence score. Pick an image from your gallery
-              or take one with your camera to get started.
-            </Text>
-          </View>
-        )}
-        {imageUri && inferenceTime !== null && results.length === 0 && (
-          <View style={styles.infoContainer}>
-            <Text style={styles.infoTitle}>No text detected</Text>
-            <Text style={styles.infoText}>
-              The model did not find any vertical text in this image. Try an
-              image containing vertical Japanese, Korean, or Chinese text.
-            </Text>
-          </View>
-        )}
-        {results.length > 0 && (
-          <View style={styles.results}>
-            <Text style={styles.resultHeader}>Results</Text>
-            <ScrollView style={styles.resultsList}>
-              {results.map(({ text, score }, index) => (
-                <View key={index} style={styles.resultRecord}>
-                  <Text style={styles.resultLabel}>{text}</Text>
-                  <Text>{score?.toFixed(3)}</Text>
-                </View>
-              ))}
-            </ScrollView>
-          </View>
-        )}
-      </View>
-      <StatsBar
-        inferenceTime={inferenceTime}
-        detectionCount={results.length > 0 ? results.length : null}
-      />
-      <BottomBar
-        handleCameraPress={handleCameraPress}
-        runForward={runForward}
-        hasImage={!!imageUri}
-        isGenerating={model.isGenerating}
-      />
-    </ScreenWrapper>
-  );
-}
-
-const styles = StyleSheet.create({
-  imageContainer: {
-    flex: 2,
-    borderRadius: 8,
-    width: '100%',
-  },
-  container: {
-    flex: 6,
-    width: '100%',
-    padding: 16,
-  },
-  image: {
-    width: '100%',
-    height: '100%',
-  },
-  results: {
-    flex: 1,
-    alignItems: 'center',
-    justifyContent: 'center',
-    gap: 4,
-    padding: 4,
-  },
-  resultHeader: {
-    fontSize: 18,
-    color: 'navy',
-  },
-  resultsList: {
-    flex: 1,
-  },
-  resultRecord: {
-    flexDirection: 'row',
-    width: '100%',
-    justifyContent: 'space-between',
-    padding: 8,
-    borderBottomWidth: 1,
-  },
-  resultLabel: {
-    flex: 1,
-    marginRight: 4,
-  },
-  infoContainer: {
-    alignItems: 'center',
-    padding: 16,
-    gap: 8,
-  },
-  infoTitle: {
-    fontSize: 18,
-    fontWeight: '600',
-    color: 'navy',
-  },
-  infoText: {
-    fontSize: 14,
-    color: '#555',
-    textAlign: 'center',
-    lineHeight: 20,
-  },
-});
diff --git a/apps/computer-vision/app/pose_estimation/index.tsx b/apps/computer-vision/app/pose_estimation/index.tsx
deleted file mode 100644
index 4546b628fa..0000000000
--- a/apps/computer-vision/app/pose_estimation/index.tsx
+++ /dev/null
@@ -1,259 +0,0 @@
-import Spinner from '../../components/Spinner';
-import { BottomBar } from '../../components/BottomBar';
-import { getImage } from '../../utils';
-import {
-  models,
-  usePoseEstimation,
-  PoseDetections,
-  RnExecutorchError,
-  RnExecutorchErrorCode,
-} from 'react-native-executorch';
-import { View, StyleSheet, Image, Text } from 'react-native';
-import React, { useContext, useEffect, useState } from 'react';
-import { GeneratingContext } from '../../context';
-import ScreenWrapper from '../../ScreenWrapper';
-import { StatsBar } from '../../components/StatsBar';
-import Svg, { Circle, Line } from 'react-native-svg';
-import ErrorBanner from '../../components/ErrorBanner';
-import { COCO_SKELETON_CONNECTIONS } from '../../components/utils/cocoSkeleton';
-
-// Colors for different people
-const PERSON_COLORS = ['lime', 'cyan', 'magenta', 'yellow', 'orange', 'pink'];
-
-export default function PoseEstimationScreen() {
-  const [imageUri, setImageUri] = useState('');
-  const [results, setResults] = useState<PoseDetections>([]);
-  const [error, setError] = useState<string | null>(null);
-  const [imageDimensions, setImageDimensions] = useState<{
-    width: number;
-    height: number;
-  }>();
-  const [inferenceTime, setInferenceTime] = useState<number | null>(null);
-  const [layout, setLayout] = useState({ width: 0, height: 0 });
-
-  const model = usePoseEstimation({ model: models.pose_estimation.yolo26n() });
-  const { setGlobalGenerating } = useContext(GeneratingContext);
-
-  useEffect(() => {
-    setGlobalGenerating(model.isGenerating);
-  }, [model.isGenerating, setGlobalGenerating]);
-
-  useEffect(() => {
-    if (model.error) setError(String(model.error));
-  }, [model.error]);
-
-  const handleCameraPress = async (isCamera: boolean) => {
-    const image = await getImage(isCamera);
-    const uri = image?.uri;
-    const width = image?.width;
-    const height = image?.height;
-
-    if (uri && width && height) {
-      setImageUri(image.uri as string);
-      setImageDimensions({ width, height });
-      setResults([]);
-      setInferenceTime(null);
-    }
-  };
-
-  const runForward = async () => {
-    if (imageUri) {
-      try {
-        const start = Date.now();
-        const output = await model.forward(imageUri, { inputSize: 384 });
-        setInferenceTime(Date.now() - start);
-        setResults(output);
-      } catch (e) {
-        if (e instanceof RnExecutorchError) {
-          switch (e.code) {
-            case RnExecutorchErrorCode.FileReadFailed:
-              setError('Could not read the selected image.');
-              break;
-            case RnExecutorchErrorCode.ModelGenerating:
-              setError('Model is busy — wait for the current run to finish.');
-              break;
-            case RnExecutorchErrorCode.InvalidUserInput:
-            case RnExecutorchErrorCode.InvalidArgument:
-              setError(`Invalid input: ${e.message}`);
-              break;
-            default:
-              setError(e.message);
-          }
-        } else {
-          setError(e instanceof Error ? e.message : String(e));
-        }
-      }
-    }
-  };
-
-  if (!model.isReady) {
-    return (
-      <Spinner
-        visible={!model.isReady}
-        textContent={`Loading the model ${(model.downloadProgress * 100).toFixed(0)} %`}
-      />
-    );
-  }
-
-  return (
-    <ScreenWrapper>
-      <ErrorBanner message={error} onDismiss={() => setError(null)} />
-      <View style={styles.imageContainer}>
-        <View style={styles.image}>
-          {imageUri && imageDimensions?.width && imageDimensions?.height ? (
-            <View
-              style={styles.imageWrapper}
-              onLayout={(e) =>
-                setLayout({
-                  width: e.nativeEvent.layout.width,
-                  height: e.nativeEvent.layout.height,
-                })
-              }
-            >
-              <Image
-                source={{ uri: imageUri }}
-                style={styles.fullSizeImage}
-                resizeMode="contain"
-              />
-              {results.length > 0 &&
-                layout.width > 0 &&
-                layout.height > 0 &&
-                (() => {
-                  // Account for resizeMode="contain" letterboxing: the image's
-                  // displayed area is smaller than the container in one axis.
-                  const imageRatio =
-                    imageDimensions.width / imageDimensions.height;
-                  const layoutRatio = layout.width / layout.height;
-                  let scaleX: number, scaleY: number;
-                  if (imageRatio > layoutRatio) {
-                    scaleX = layout.width / imageDimensions.width;
-                    scaleY = layout.width / imageRatio / imageDimensions.height;
-                  } else {
-                    scaleY = layout.height / imageDimensions.height;
-                    scaleX =
-                      (layout.height * imageRatio) / imageDimensions.width;
-                  }
-                  const offsetX =
-                    (layout.width - imageDimensions.width * scaleX) / 2;
-                  const offsetY =
-                    (layout.height - imageDimensions.height * scaleY) / 2;
-                  const isInBounds = (kp: { x: number; y: number }) =>
-                    kp.x >= 0 &&
-                    kp.y >= 0 &&
-                    kp.x <= imageDimensions.width &&
-                    kp.y <= imageDimensions.height;
-                  return (
-                    <Svg style={StyleSheet.absoluteFill}>
-                      {results.map((personKeypoints, personIdx) => {
-                        const color =
-                          PERSON_COLORS[personIdx % PERSON_COLORS.length];
-                        return (
-                          <React.Fragment key={`person-${personIdx}`}>
-                            {COCO_SKELETON_CONNECTIONS.map(
-                              ([from, to], lineIdx) => {
-                                const kp1 = personKeypoints[from];
-                                const kp2 = personKeypoints[to];
-                                if (!kp1 || !kp2) return null;
-                                if (!isInBounds(kp1) || !isInBounds(kp2))
-                                  return null;
-                                return (
-                                  <Line
-                                    key={`person-${personIdx}-line-${lineIdx}`}
-                                    x1={kp1.x * scaleX + offsetX}
-                                    y1={kp1.y * scaleY + offsetY}
-                                    x2={kp2.x * scaleX + offsetX}
-                                    y2={kp2.y * scaleY + offsetY}
-                                    stroke={color}
-                                    strokeWidth="2"
-                                  />
-                                );
-                              }
-                            )}
-                            {Object.entries(personKeypoints)
-                              .filter(([, kp]) => isInBounds(kp))
-                              .map(([name, kp]) => (
-                                <Circle
-                                  key={`person-${personIdx}-kp-${name}`}
-                                  cx={kp.x * scaleX + offsetX}
-                                  cy={kp.y * scaleY + offsetY}
-                                  r="4"
-                                  fill="red"
-                                />
-                              ))}
-                          </React.Fragment>
-                        );
-                      })}
-                    </Svg>
-                  );
-                })()}
-            </View>
-          ) : (
-            <Image
-              style={styles.fullSizeImage}
-              resizeMode="contain"
-              source={require('../../assets/icons/executorch_logo.png')}
-            />
-          )}
-        </View>
-        {!imageUri && (
-          <View style={styles.infoContainer}>
-            <Text style={styles.infoTitle}>Pose Estimation</Text>
-            <Text style={styles.infoText}>
-              This model detects human body keypoints (17 COCO keypoints) and
-              draws a skeleton overlay. Pick an image from your gallery or take
-              one with your camera to get started.
-            </Text>
-          </View>
-        )}
-      </View>
-      <StatsBar
-        inferenceTime={inferenceTime}
-        detectionCount={results.length > 0 ? results.length : null}
-      />
-      <BottomBar
-        handleCameraPress={handleCameraPress}
-        runForward={runForward}
-        hasImage={!!imageUri}
-        isGenerating={model.isGenerating}
-      />
-    </ScreenWrapper>
-  );
-}
-
-const styles = StyleSheet.create({
-  imageContainer: {
-    flex: 6,
-    width: '100%',
-    padding: 16,
-  },
-  image: {
-    flex: 2,
-    borderRadius: 8,
-    width: '100%',
-  },
-  imageWrapper: {
-    flex: 1,
-    width: '100%',
-    height: '100%',
-  },
-  fullSizeImage: {
-    width: '100%',
-    height: '100%',
-  },
-  infoContainer: {
-    alignItems: 'center',
-    padding: 16,
-    gap: 8,
-  },
-  infoTitle: {
-    fontSize: 18,
-    fontWeight: '600',
-    color: 'navy',
-  },
-  infoText: {
-    fontSize: 14,
-    color: '#555',
-    textAlign: 'center',
-    lineHeight: 20,
-  },
-});
diff --git a/apps/computer-vision/app/segment_anything/index.tsx b/apps/computer-vision/app/segment_anything/index.tsx
deleted file mode 100644
index ac7bbd06b5..0000000000
--- a/apps/computer-vision/app/segment_anything/index.tsx
+++ /dev/null
@@ -1,615 +0,0 @@
-import React, { useContext, useEffect, useRef, useState } from 'react';
-import {
-  View,
-  StyleSheet,
-  Text,
-  TextInput,
-  TouchableOpacity,
-  TouchableWithoutFeedback,
-  GestureResponderEvent,
-  Keyboard,
-  KeyboardAvoidingView,
-  Platform,
-} from 'react-native';
-import {
-  Canvas,
-  Rect,
-  Skia,
-  useImage,
-  type SkImage,
-  ColorType,
-  AlphaType,
-} from '@shopify/react-native-skia';
-import {
-  models,
-  useInstanceSegmentation,
-  useImageEmbeddings,
-  useTextEmbeddings,
-  InstanceSegmentationModelSources,
-  SegmentedInstance,
-  FastSAMLabel,
-  selectByPoint,
-  selectByBox,
-  selectByText,
-  Bbox,
-} from 'react-native-executorch';
-import { GeneratingContext } from '../../context';
-import { ModelPicker, ModelOption } from '../../components/ModelPicker';
-import { BottomBar } from '../../components/BottomBar';
-import { StatsBar } from '../../components/StatsBar';
-import Spinner from '../../components/Spinner';
-import ScreenWrapper from '../../ScreenWrapper';
-import ImageWithMasks, {
-  buildDisplayInstances,
-  DisplayInstance,
-} from '../../components/ImageWithMasks';
-import { getImage } from '../../utils';
-import ColorPalette from '../../colors';
-const instanceSegmentation = models.instance_segmentation;
-
-type PromptMode = 'point' | 'box' | 'text';
-
-const MODELS: ModelOption<InstanceSegmentationModelSources>[] = [
-  { label: 'FastSAM-S', value: instanceSegmentation.fastsam_s() },
-  { label: 'FastSAM-X', value: instanceSegmentation.fastsam_x() },
-];
-
-export default function SegmentAnythingScreen() {
-  const { setGlobalGenerating } = useContext(GeneratingContext);
-
-  const [selectedModel, setSelectedModel] =
-    useState<InstanceSegmentationModelSources>(
-      instanceSegmentation.fastsam_s()
-    );
-  const [mode, setMode] = useState<PromptMode>('point');
-  const [inferenceTime, setInferenceTime] = useState<number | null>(null);
-
-  const [imageUri, setImageUri] = useState('');
-  const [imageSize, setImageSize] = useState({ width: 0, height: 0 });
-
-  const rawInstancesRef = useRef<SegmentedInstance<typeof FastSAMLabel>[]>([]);
-  const [selection, setSelection] = useState<DisplayInstance[]>([]);
-
-  const [draftBox, setDraftBox] = useState<Bbox | null>(null);
-  const boxStartRef = useRef<{ x: number; y: number } | null>(null);
-  const layoutRef = useRef({ width: 0, height: 0 });
-
-  const { isReady, isGenerating, downloadProgress, forward, error } =
-    useInstanceSegmentation({ model: selectedModel });
-
-  const clipImage = useImageEmbeddings({
-    model: models.image_embedding.clip_vit_base_patch32_image(),
-  });
-  const clipText = useTextEmbeddings({
-    model: models.text_embedding.clip_vit_base_patch32_text(),
-  });
-  const skiaSource = useImage(imageUri || null);
-
-  const [textPrompt, setTextPrompt] = useState('');
-  const [textBusy, setTextBusy] = useState(false);
-  const [embeddingProgress, setEmbeddingProgress] = useState<{
-    done: number;
-    total: number;
-  } | null>(null);
-  const instanceEmbeddingsRef = useRef<Float32Array[] | null>(null);
-
-  useEffect(() => {
-    setGlobalGenerating(isGenerating);
-  }, [isGenerating, setGlobalGenerating]);
-
-  function applyMatch(
-    match: SegmentedInstance<typeof FastSAMLabel> | null
-  ): void {
-    setSelection(match ? buildDisplayInstances([match]) : []);
-  }
-
-  function touchToImageCoords(touchX: number, touchY: number) {
-    const { width: cw, height: ch } = layoutRef.current;
-    const { width: iw, height: ih } = imageSize;
-    if (iw === 0 || ih === 0) return null;
-    const scale = Math.min(cw / iw, ch / ih);
-    return {
-      x: (touchX - (cw - iw * scale) / 2) / scale,
-      y: (touchY - (ch - ih * scale) / 2) / scale,
-    };
-  }
-
-  function handleTap(e: GestureResponderEvent) {
-    if (mode !== 'point' || rawInstancesRef.current.length === 0) return;
-    const c = touchToImageCoords(
-      e.nativeEvent.locationX,
-      e.nativeEvent.locationY
-    );
-    if (!c) return;
-    applyMatch(
-      selectByPoint(rawInstancesRef.current, Math.round(c.x), Math.round(c.y))
-    );
-  }
-
-  function handleBoxStart(e: GestureResponderEvent) {
-    if (mode !== 'box') return;
-    const c = touchToImageCoords(
-      e.nativeEvent.locationX,
-      e.nativeEvent.locationY
-    );
-    if (!c) return;
-    boxStartRef.current = c;
-    setDraftBox({ x1: c.x, y1: c.y, x2: c.x, y2: c.y });
-  }
-
-  function handleBoxMove(e: GestureResponderEvent) {
-    if (mode !== 'box' || !boxStartRef.current) return;
-    const c = touchToImageCoords(
-      e.nativeEvent.locationX,
-      e.nativeEvent.locationY
-    );
-    if (!c) return;
-    const s = boxStartRef.current;
-    setDraftBox({
-      x1: Math.min(s.x, c.x),
-      y1: Math.min(s.y, c.y),
-      x2: Math.max(s.x, c.x),
-      y2: Math.max(s.y, c.y),
-    });
-  }
-
-  function handleBoxEnd(e: GestureResponderEvent) {
-    if (mode !== 'box' || !boxStartRef.current) return;
-    const c = touchToImageCoords(
-      e.nativeEvent.locationX,
-      e.nativeEvent.locationY
-    );
-    const s = boxStartRef.current;
-    boxStartRef.current = null;
-    setDraftBox(null);
-    if (!c || rawInstancesRef.current.length === 0) return;
-    applyMatch(
-      selectByBox(rawInstancesRef.current, {
-        x1: Math.min(s.x, c.x),
-        y1: Math.min(s.y, c.y),
-        x2: Math.max(s.x, c.x),
-        y2: Math.max(s.y, c.y),
-      })
-    );
-  }
-
-  async function runTextPrompt() {
-    Keyboard.dismiss();
-    const instances = rawInstancesRef.current;
-    if (
-      !textPrompt.trim() ||
-      instances.length === 0 ||
-      !skiaSource ||
-      !clipImage.isReady ||
-      !clipText.isReady ||
-      textBusy
-    ) {
-      return;
-    }
-    setTextBusy(true);
-    try {
-      if (!instanceEmbeddingsRef.current) {
-        setEmbeddingProgress({ done: 0, total: instances.length });
-        const embeddings: Float32Array[] = [];
-        for (let i = 0; i < instances.length; i++) {
-          const inst = instances[i]!;
-          embeddings.push(
-            await cropAndEmbed(
-              skiaSource,
-              inst.bbox,
-              inst.mask,
-              inst.maskWidth,
-              inst.maskHeight,
-              clipImage.forward
-            )
-          );
-          setEmbeddingProgress({ done: i + 1, total: instances.length });
-        }
-        instanceEmbeddingsRef.current = embeddings;
-        setEmbeddingProgress(null);
-      }
-      const textEmb = await clipText.forward(textPrompt);
-      const match = selectByText(
-        instances,
-        instanceEmbeddingsRef.current,
-        textEmb
-      );
-      applyMatch(match);
-    } catch (e) {
-      console.error(e);
-    } finally {
-      setTextBusy(false);
-    }
-  }
-
-  const handleCameraPress = async (isCamera: boolean) => {
-    Keyboard.dismiss();
-    const image = await getImage(isCamera);
-    if (!image?.uri) return;
-    setImageUri(image.uri);
-    setImageSize({ width: image.width ?? 0, height: image.height ?? 0 });
-    rawInstancesRef.current = [];
-    instanceEmbeddingsRef.current = null;
-    setSelection([]);
-    setInferenceTime(null);
-  };
-
-  const runForward = async () => {
-    Keyboard.dismiss();
-    if (!imageUri) return;
-    try {
-      const start = Date.now();
-      const output = await forward(imageUri, {
-        confidenceThreshold: 0.4,
-        iouThreshold: 0.9,
-        maxInstances: 50,
-        returnMaskAtOriginalResolution: true,
-      });
-      setInferenceTime(Date.now() - start);
-      rawInstancesRef.current = output;
-      instanceEmbeddingsRef.current = null;
-      setSelection([]);
-    } catch (e) {
-      console.error(e);
-    }
-  };
-
-  if (!isReady && error) {
-    return (
-      <ScreenWrapper>
-        <View style={styles.errorContainer}>
-          <Text style={styles.errorTitle}>Error Loading Model</Text>
-          <Text style={styles.errorText}>{error.message}</Text>
-        </View>
-      </ScreenWrapper>
-    );
-  }
-
-  if (!isReady) {
-    return (
-      <Spinner
-        visible
-        textContent={`Loading the model ${(downloadProgress * 100).toFixed(0)} %`}
-      />
-    );
-  }
-
-  const { width: cw, height: ch } = layoutRef.current;
-  const { width: iw, height: ih } = imageSize;
-  const drawScale = iw > 0 && ih > 0 ? Math.min(cw / iw, ch / ih) : 1;
-  const offsetX = (cw - iw * drawScale) / 2;
-  const offsetY = (ch - ih * drawScale) / 2;
-
-  const stepHint = !imageUri
-    ? null
-    : inferenceTime === null
-      ? 'Tap Run to detect instances'
-      : rawInstancesRef.current.length === 0
-        ? 'No instances detected — try another image'
-        : selection.length === 0
-          ? 'Tap a point, draw a box, or describe an object'
-          : null;
-
-  return (
-    <ScreenWrapper>
-      <TouchableWithoutFeedback onPress={Keyboard.dismiss}>
-        <KeyboardAvoidingView
-          style={styles.flex}
-          contentContainerStyle={styles.flex}
-          collapsable={false}
-          behavior={Platform.OS === 'ios' ? 'position' : undefined}
-          keyboardVerticalOffset={Platform.OS === 'ios' ? 120 : 40}
-        >
-          <View style={styles.container}>
-            <View style={styles.imageContainer}>
-              <View
-                style={styles.imageTouchArea}
-                onLayout={(e) => {
-                  layoutRef.current = {
-                    width: e.nativeEvent.layout.width,
-                    height: e.nativeEvent.layout.height,
-                  };
-                }}
-                onTouchStart={(e) => {
-                  Keyboard.dismiss();
-                  if (mode === 'point') handleTap(e);
-                  else if (mode === 'box') handleBoxStart(e);
-                }}
-                onTouchMove={handleBoxMove}
-                onTouchEnd={handleBoxEnd}
-              >
-                <ImageWithMasks
-                  imageUri={imageUri}
-                  instances={selection}
-                  imageWidth={imageSize.width}
-                  imageHeight={imageSize.height}
-                />
-                {draftBox && iw > 0 && (
-                  <Canvas style={StyleSheet.absoluteFill} pointerEvents="none">
-                    <Rect
-                      x={draftBox.x1 * drawScale + offsetX}
-                      y={draftBox.y1 * drawScale + offsetY}
-                      width={(draftBox.x2 - draftBox.x1) * drawScale}
-                      height={(draftBox.y2 - draftBox.y1) * drawScale}
-                      style="stroke"
-                      strokeWidth={2}
-                      color="rgba(0,200,255,1)"
-                    />
-                  </Canvas>
-                )}
-              </View>
-              {!imageUri && (
-                <View style={styles.infoContainer}>
-                  <Text style={styles.infoTitle}>Segment Anything</Text>
-                  <Text style={styles.infoText}>
-                    Segment any object in an image. (1) Pick an image, (2) tap
-                    Run to detect instances, (3) tap a point, draw a box, or
-                    describe an object to segment it.
-                  </Text>
-                </View>
-              )}
-            </View>
-          </View>
-
-          {stepHint && <Text style={styles.stepHint}>{stepHint}</Text>}
-
-          <View style={styles.modeRow}>
-            {(['point', 'box', 'text'] as PromptMode[]).map((m) => {
-              const promptDisabled = rawInstancesRef.current.length === 0;
-              return (
-                <TouchableOpacity
-                  key={m}
-                  style={[
-                    styles.modeBtn,
-                    mode === m && styles.modeBtnActive,
-                    promptDisabled && styles.modeBtnDisabled,
-                  ]}
-                  onPress={() => {
-                    if (m !== 'text') Keyboard.dismiss();
-                    setMode(m);
-                  }}
-                  disabled={promptDisabled}
-                >
-                  <Text
-                    style={[
-                      styles.modeBtnText,
-                      mode === m && styles.modeBtnTextActive,
-                      promptDisabled && styles.modeBtnTextDisabled,
-                    ]}
-                  >
-                    {m[0]!.toUpperCase() + m.slice(1)}
-                  </Text>
-                </TouchableOpacity>
-              );
-            })}
-          </View>
-
-          {mode === 'text' && (
-            <View style={styles.textRow}>
-              <TextInput
-                style={styles.textInput}
-                placeholder="Describe an object…"
-                value={textPrompt}
-                onChangeText={setTextPrompt}
-                onSubmitEditing={runTextPrompt}
-                returnKeyType="search"
-              />
-              {(() => {
-                const findInactive =
-                  !textPrompt.trim() ||
-                  rawInstancesRef.current.length === 0 ||
-                  !clipImage.isReady ||
-                  !clipText.isReady;
-                return (
-                  <TouchableOpacity
-                    style={[
-                      styles.textBtn,
-                      findInactive && styles.textBtnDisabled,
-                    ]}
-                    onPress={runTextPrompt}
-                    disabled={findInactive || textBusy}
-                  >
-                    <Text style={styles.textBtnLabel}>Find</Text>
-                  </TouchableOpacity>
-                );
-              })()}
-            </View>
-          )}
-          {mode === 'text' && embeddingProgress && (
-            <Text style={styles.statusLine}>
-              Embedding instances {embeddingProgress.done}/
-              {embeddingProgress.total} (subsequent text queries are instant)
-            </Text>
-          )}
-
-          <ModelPicker
-            models={MODELS}
-            selectedModel={selectedModel}
-            disabled={isGenerating}
-            onSelect={(m) => {
-              if (m.modelName === selectedModel.modelName) return;
-              setSelectedModel(m);
-              rawInstancesRef.current = [];
-              instanceEmbeddingsRef.current = null;
-              setSelection([]);
-              setInferenceTime(null);
-            }}
-          />
-
-          <StatsBar
-            inferenceTime={inferenceTime}
-            detectionCount={
-              rawInstancesRef.current.length > 0
-                ? rawInstancesRef.current.length
-                : null
-            }
-          />
-
-          <BottomBar
-            handleCameraPress={handleCameraPress}
-            runForward={runForward}
-            hasImage={!!imageUri}
-            isGenerating={isGenerating}
-          />
-        </KeyboardAvoidingView>
-      </TouchableWithoutFeedback>
-    </ScreenWrapper>
-  );
-}
-
-async function cropAndEmbed(
-  image: SkImage,
-  bbox: Bbox,
-  mask: Uint8Array,
-  maskWidth: number,
-  maskHeight: number,
-  forward: (input: string) => Promise<Float32Array>
-): Promise<Float32Array> {
-  const imgW = image.width();
-  const imgH = image.height();
-  const surface = Skia.Surface.MakeOffscreen(imgW, imgH);
-  if (!surface) throw new Error('Failed to create offscreen Skia surface');
-  const canvas = surface.getCanvas();
-  canvas.clear(Skia.Color('white'));
-
-  const x1 = Math.max(0, Math.round(bbox.x1));
-  const y1 = Math.max(0, Math.round(bbox.y1));
-  const x2 = Math.min(imgW, Math.round(bbox.x2));
-  const y2 = Math.min(imgH, Math.round(bbox.y2));
-  const w = x2 - x1;
-  const h = y2 - y1;
-  if (w > 0 && h > 0) {
-    canvas.drawImageRect(
-      image,
-      { x: x1, y: y1, width: w, height: h },
-      { x: x1, y: y1, width: w, height: h },
-      Skia.Paint()
-    );
-  }
-
-  const inversePixels = new Uint8Array(mask.length * 4);
-  for (let i = 0; i < mask.length; i++) {
-    const outside = mask[i]! === 0;
-    const idx = i * 4;
-    inversePixels[idx] = outside ? 255 : 0;
-    inversePixels[idx + 1] = outside ? 255 : 0;
-    inversePixels[idx + 2] = outside ? 255 : 0;
-    inversePixels[idx + 3] = outside ? 255 : 0;
-  }
-  const inverseData = Skia.Data.fromBytes(inversePixels);
-  const inverseMaskImg = Skia.Image.MakeImage(
-    {
-      width: maskWidth,
-      height: maskHeight,
-      colorType: ColorType.RGBA_8888,
-      alphaType: AlphaType.Premul,
-    },
-    inverseData,
-    maskWidth * 4
-  );
-  if (inverseMaskImg) {
-    canvas.drawImageRect(
-      inverseMaskImg,
-      { x: 0, y: 0, width: maskWidth, height: maskHeight },
-      {
-        x: bbox.x1,
-        y: bbox.y1,
-        width: bbox.x2 - bbox.x1,
-        height: bbox.y2 - bbox.y1,
-      },
-      Skia.Paint()
-    );
-  }
-
-  const base64 = surface.makeImageSnapshot().encodeToBase64();
-  inverseData.dispose();
-  return forward(`data:image/png;base64,${base64}`);
-}
-
-const styles = StyleSheet.create({
-  flex: { flex: 1 },
-  container: { flex: 6, width: '100%' },
-  imageContainer: { flex: 1, width: '100%', padding: 16 },
-  imageTouchArea: { flex: 1, position: 'relative' },
-  infoContainer: { alignItems: 'center', padding: 16, gap: 8 },
-  infoTitle: { fontSize: 18, fontWeight: '600', color: 'navy' },
-  infoText: {
-    fontSize: 14,
-    color: '#555',
-    textAlign: 'center',
-    lineHeight: 20,
-  },
-  modeRow: {
-    flexDirection: 'row',
-    justifyContent: 'center',
-    paddingVertical: 8,
-    gap: 8,
-  },
-  modeBtn: {
-    paddingHorizontal: 18,
-    paddingVertical: 8,
-    borderRadius: 8,
-    borderWidth: 1,
-    borderColor: ColorPalette.primary,
-    backgroundColor: '#fff',
-  },
-  modeBtnActive: { backgroundColor: ColorPalette.primary },
-  modeBtnDisabled: { borderColor: '#cbd5e1', backgroundColor: '#f8fafc' },
-  modeBtnText: { fontSize: 14, fontWeight: '600', color: ColorPalette.primary },
-  modeBtnTextActive: { color: '#fff' },
-  modeBtnTextDisabled: { color: '#cbd5e1' },
-  textRow: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    paddingHorizontal: 16,
-    paddingBottom: 8,
-    gap: 8,
-  },
-  textInput: {
-    flex: 1,
-    backgroundColor: '#fff',
-    borderWidth: 1,
-    borderColor: ColorPalette.primary,
-    borderRadius: 12,
-    paddingHorizontal: 14,
-    paddingVertical: 12,
-    fontSize: 16,
-    color: '#0f172a',
-  },
-  textBtn: {
-    backgroundColor: ColorPalette.primary,
-    borderRadius: 12,
-    paddingVertical: 14,
-    width: 80,
-    alignItems: 'center',
-  },
-  textBtnDisabled: { backgroundColor: '#cbd5e1' },
-  textBtnLabel: { color: '#fff', fontWeight: '700', fontSize: 16 },
-  statusLine: {
-    paddingHorizontal: 16,
-    paddingBottom: 6,
-    fontSize: 12,
-    color: '#64748b',
-  },
-  stepHint: {
-    paddingHorizontal: 16,
-    paddingTop: 6,
-    fontSize: 13,
-    fontWeight: '500',
-    color: ColorPalette.primary,
-    textAlign: 'center',
-  },
-  errorContainer: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-    padding: 32,
-  },
-  errorTitle: {
-    fontSize: 20,
-    fontWeight: '700',
-    color: '#e74c3c',
-    marginBottom: 12,
-  },
-  errorText: { fontSize: 14, color: '#555', textAlign: 'center' },
-});
diff --git a/apps/computer-vision/app/semantic_segmentation/index.tsx b/apps/computer-vision/app/semantic_segmentation/index.tsx
deleted file mode 100644
index f77c8de9c8..0000000000
--- a/apps/computer-vision/app/semantic_segmentation/index.tsx
+++ /dev/null
@@ -1,263 +0,0 @@
-import Spinner from '../../components/Spinner';
-import { BottomBar } from '../../components/BottomBar';
-import { ModelPicker, ModelOption } from '../../components/ModelPicker';
-import { getImage } from '../../utils';
-import {
-  models,
-  useSemanticSegmentation,
-  SemanticSegmentationModelSources,
-} from 'react-native-executorch';
-import {
-  Canvas,
-  Image as SkiaImage,
-  Skia,
-  AlphaType,
-  ColorType,
-  SkImage,
-} from '@shopify/react-native-skia';
-import { View, StyleSheet, Image, Text } from 'react-native';
-import React, { useContext, useEffect, useState } from 'react';
-import { GeneratingContext } from '../../context';
-import ScreenWrapper from '../../ScreenWrapper';
-import { StatsBar } from '../../components/StatsBar';
-import ErrorBanner from '../../components/ErrorBanner';
-const semanticSegmentation = models.semantic_segmentation;
-
-const numberToColor: number[][] = [
-  [255, 87, 51], // 0 Red
-  [51, 255, 87], // 1 Green
-  [51, 87, 255], // 2 Blue
-  [255, 51, 246], // 3 Magenta
-  [51, 255, 246], // 4 Cyan
-  [243, 255, 51], // 5 Yellow
-  [141, 51, 255], // 6 Purple
-  [255, 131, 51], // 7 Orange
-  [51, 255, 131], // 8 Spring Green
-  [131, 51, 255], // 9 Violet
-  [255, 255, 51], // 10 Bright Yellow
-  [51, 255, 255], // 11 Aqua
-  [255, 51, 143], // 12 Deep Pink
-  [127, 51, 255], // 13 Dark Orchid
-  [51, 255, 175], // 14 Medium Spring Green
-  [255, 175, 51], // 15 Sandy Brown
-  [179, 255, 51], // 16 Chartreuse
-  [255, 87, 51], // 17 Red (darker shade)
-  [255, 51, 162], // 18 Hot Pink
-  [51, 162, 255], // 19 Sky Blue
-  [162, 51, 255], // 20 Amethyst
-];
-
-const MODELS: ModelOption<SemanticSegmentationModelSources>[] = [
-  {
-    label: 'DeepLab MobileNet',
-    value: semanticSegmentation.deeplab_v3_mobilenet_v3_large(),
-  },
-  {
-    label: 'DeepLab ResNet50',
-    value: semanticSegmentation.deeplab_v3_resnet50(),
-  },
-  {
-    label: 'DeepLab ResNet101',
-    value: semanticSegmentation.deeplab_v3_resnet101(),
-  },
-  {
-    label: 'LRASPP MobileNet',
-    value: semanticSegmentation.lraspp_mobilenet_v3_large(),
-  },
-  {
-    label: 'FCN ResNet50',
-    value: semanticSegmentation.fcn_resnet50(),
-  },
-  {
-    label: 'FCN ResNet101',
-    value: semanticSegmentation.fcn_resnet101(),
-  },
-  {
-    label: 'Selfie Segmentation',
-    value: semanticSegmentation.selfie_segmentation(),
-  },
-];
-
-export default function SemanticSegmentationScreen() {
-  const { setGlobalGenerating } = useContext(GeneratingContext);
-  const [selectedModel, setSelectedModel] =
-    useState<SemanticSegmentationModelSources>(
-      semanticSegmentation.deeplab_v3_mobilenet_v3_large()
-    );
-
-  const {
-    isReady,
-    isGenerating,
-    downloadProgress,
-    forward,
-    error: modelError,
-  } = useSemanticSegmentation({ model: selectedModel });
-
-  const [imageUri, setImageUri] = useState('');
-  const [imageSize, setImageSize] = useState({ width: 0, height: 0 });
-  const [segImage, setSegImage] = useState<SkImage | null>(null);
-  const [canvasSize, setCanvasSize] = useState({ width: 0, height: 0 });
-  const [inferenceTime, setInferenceTime] = useState<number | null>(null);
-  const [error, setError] = useState<string | null>(null);
-
-  useEffect(() => {
-    setGlobalGenerating(isGenerating);
-  }, [isGenerating, setGlobalGenerating]);
-
-  useEffect(() => {
-    if (modelError) setError(String(modelError));
-  }, [modelError]);
-
-  const handleCameraPress = async (isCamera: boolean) => {
-    const image = await getImage(isCamera);
-    if (!image?.uri) return;
-    setImageUri(image.uri);
-    setImageSize({ width: image.width ?? 0, height: image.height ?? 0 });
-    setSegImage(null);
-    setInferenceTime(null);
-  };
-
-  const runForward = async () => {
-    if (!imageUri || imageSize.width === 0 || imageSize.height === 0) return;
-    try {
-      const start = Date.now();
-      const { width, height } = imageSize;
-      const output = await forward(imageUri, [], true);
-      const argmax = output.ARGMAX || [];
-      const pixels = new Uint8Array(width * height * 4);
-
-      for (let row = 0; row < height; row++) {
-        for (let col = 0; col < width; col++) {
-          const idx = row * width + col;
-          const color = numberToColor[argmax[idx]] || [0, 0, 0];
-          pixels[idx * 4] = color[0];
-          pixels[idx * 4 + 1] = color[1];
-          pixels[idx * 4 + 2] = color[2];
-          pixels[idx * 4 + 3] = 255;
-        }
-      }
-
-      const data = Skia.Data.fromBytes(pixels);
-      const img = Skia.Image.MakeImage(
-        {
-          width,
-          height,
-          alphaType: AlphaType.Opaque,
-          colorType: ColorType.RGBA_8888,
-        },
-        data,
-        width * 4
-      );
-      setSegImage(img);
-      setInferenceTime(Date.now() - start);
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-    }
-  };
-
-  if (!isReady && !modelError) {
-    return (
-      <Spinner
-        visible={true}
-        textContent={`Loading the model ${(downloadProgress * 100).toFixed(0)} %`}
-      />
-    );
-  }
-
-  return (
-    <ScreenWrapper>
-      <ErrorBanner message={error} onDismiss={() => setError(null)} />
-      <View style={styles.imageCanvasContainer}>
-        <View style={styles.imageContainer}>
-          <Image
-            style={styles.image}
-            resizeMode="contain"
-            source={
-              imageUri
-                ? { uri: imageUri }
-                : require('../../assets/icons/executorch_logo.png')
-            }
-          />
-          {!imageUri && (
-            <View style={styles.infoContainer}>
-              <Text style={styles.infoTitle}>Semantic Segmentation</Text>
-              <Text style={styles.infoText}>
-                This model assigns a class label to every pixel in an image,
-                painting each region with a distinct color. Pick an image from
-                your gallery or take one with your camera to get started.
-              </Text>
-            </View>
-          )}
-        </View>
-        {segImage && (
-          <View
-            style={styles.canvasContainer}
-            onLayout={(e) =>
-              setCanvasSize({
-                width: e.nativeEvent.layout.width,
-                height: e.nativeEvent.layout.height,
-              })
-            }
-          >
-            <Canvas style={styles.canvas}>
-              <SkiaImage
-                image={segImage}
-                fit="contain"
-                x={0}
-                y={0}
-                width={canvasSize.width}
-                height={canvasSize.height}
-              />
-            </Canvas>
-          </View>
-        )}
-      </View>
-      <ModelPicker
-        models={MODELS}
-        selectedModel={selectedModel}
-        disabled={isGenerating}
-        onSelect={(m) => {
-          setSelectedModel(m);
-          setSegImage(null);
-        }}
-      />
-      <StatsBar inferenceTime={inferenceTime} />
-      <BottomBar
-        handleCameraPress={handleCameraPress}
-        runForward={runForward}
-        hasImage={!!imageUri}
-        isGenerating={isGenerating}
-      />
-    </ScreenWrapper>
-  );
-}
-
-const styles = StyleSheet.create({
-  imageCanvasContainer: { flex: 6, width: '100%', padding: 16 },
-  imageContainer: { flex: 1, width: '100%' },
-  image: { flex: 1, borderRadius: 8, width: '100%' },
-  canvasContainer: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-    gap: 4,
-    padding: 4,
-  },
-  canvas: { width: '100%', height: '100%' },
-  infoContainer: {
-    alignItems: 'center',
-    padding: 16,
-    gap: 8,
-  },
-  infoTitle: {
-    fontSize: 18,
-    fontWeight: '600',
-    color: 'navy',
-  },
-  infoText: {
-    fontSize: 14,
-    color: '#555',
-    textAlign: 'center',
-    lineHeight: 20,
-  },
-});
diff --git a/apps/computer-vision/app/style_transfer/index.tsx b/apps/computer-vision/app/style_transfer/index.tsx
deleted file mode 100644
index d8eda655f7..0000000000
--- a/apps/computer-vision/app/style_transfer/index.tsx
+++ /dev/null
@@ -1,153 +0,0 @@
-import Spinner from '../../components/Spinner';
-import { BottomBar } from '../../components/BottomBar';
-import { ModelPicker, ModelOption } from '../../components/ModelPicker';
-import { getImage } from '../../utils';
-import {
-  models,
-  useStyleTransfer,
-  StyleTransferModelName,
-  ResourceSource,
-} from 'react-native-executorch';
-
-import { View, StyleSheet, Image, Text } from 'react-native';
-
-import React, { useContext, useEffect, useState } from 'react';
-import { GeneratingContext } from '../../context';
-import ScreenWrapper from '../../ScreenWrapper';
-import { StatsBar } from '../../components/StatsBar';
-const styleTransfer = models.style_transfer;
-
-type StyleTransferModelSources = {
-  modelName: StyleTransferModelName;
-  modelSource: ResourceSource;
-};
-
-const MODELS: ModelOption<StyleTransferModelSources>[] = [
-  { label: 'Candy', value: styleTransfer.candy() },
-  { label: 'Mosaic', value: styleTransfer.mosaic() },
-  {
-    label: 'Rain Princess',
-    value: styleTransfer.rain_princess(),
-  },
-  { label: 'Udnie', value: styleTransfer.udnie() },
-];
-import ErrorBanner from '../../components/ErrorBanner';
-
-export default function StyleTransferScreen() {
-  const [selectedModel, setSelectedModel] = useState<StyleTransferModelSources>(
-    styleTransfer.candy()
-  );
-
-  const model = useStyleTransfer({ model: selectedModel });
-  const { setGlobalGenerating } = useContext(GeneratingContext);
-  useEffect(() => {
-    setGlobalGenerating(model.isGenerating);
-  }, [model.isGenerating, setGlobalGenerating]);
-
-  useEffect(() => {
-    if (model.error) setError(String(model.error));
-  }, [model.error]);
-
-  const [imageUri, setImageUri] = useState('');
-  const [styledUri, setStyledUri] = useState('');
-  const [inferenceTime, setInferenceTime] = useState<number | null>(null);
-  const [error, setError] = useState<string | null>(null);
-
-  const handleCameraPress = async (isCamera: boolean) => {
-    const image = await getImage(isCamera);
-    const uri = image?.uri;
-    if (typeof uri === 'string') {
-      setImageUri(uri);
-      setStyledUri('');
-      setInferenceTime(null);
-    }
-  };
-
-  const runForward = async () => {
-    if (imageUri) {
-      try {
-        const start = Date.now();
-        const uri = await model.forward(imageUri, 'url');
-        setInferenceTime(Date.now() - start);
-        setStyledUri(uri);
-      } catch (e) {
-        setError(e instanceof Error ? e.message : String(e));
-      }
-    }
-  };
-
-  if (!model.isReady && !model.error) {
-    return (
-      <Spinner
-        visible={true}
-        textContent={`Loading the model ${(model.downloadProgress * 100).toFixed(0)} %`}
-      />
-    );
-  }
-
-  return (
-    <ScreenWrapper>
-      <ErrorBanner message={error} onDismiss={() => setError(null)} />
-      <View style={styles.imageContainer}>
-        <Image
-          style={styles.image}
-          resizeMode="contain"
-          source={
-            styledUri
-              ? { uri: styledUri }
-              : imageUri
-                ? { uri: imageUri }
-                : require('../../assets/icons/executorch_logo.png')
-          }
-        />
-        {!imageUri && (
-          <View style={styles.infoContainer}>
-            <Text style={styles.infoTitle}>Style Transfer</Text>
-            <Text style={styles.infoText}>
-              This model applies artistic styles to your images, transforming
-              them to look like famous paintings. Pick an image from your
-              gallery or take one with your camera to get started.
-            </Text>
-          </View>
-        )}
-      </View>
-      <ModelPicker
-        models={MODELS}
-        selectedModel={selectedModel}
-        disabled={model.isGenerating}
-        onSelect={(m) => {
-          setSelectedModel(m);
-          setStyledUri('');
-        }}
-      />
-      <StatsBar inferenceTime={inferenceTime} />
-      <BottomBar
-        handleCameraPress={handleCameraPress}
-        runForward={runForward}
-        hasImage={!!imageUri}
-        isGenerating={model.isGenerating}
-      />
-    </ScreenWrapper>
-  );
-}
-
-const styles = StyleSheet.create({
-  imageContainer: { flex: 6, width: '100%', padding: 16 },
-  image: { flex: 1, borderRadius: 8, width: '100%' },
-  infoContainer: {
-    alignItems: 'center',
-    padding: 16,
-    gap: 8,
-  },
-  infoTitle: {
-    fontSize: 18,
-    fontWeight: '600',
-    color: 'navy',
-  },
-  infoText: {
-    fontSize: 14,
-    color: '#555',
-    textAlign: 'center',
-    lineHeight: 20,
-  },
-});
diff --git a/apps/computer-vision/app/text_to_image/index.tsx b/apps/computer-vision/app/text_to_image/index.tsx
deleted file mode 100644
index 0d61ea05e6..0000000000
--- a/apps/computer-vision/app/text_to_image/index.tsx
+++ /dev/null
@@ -1,332 +0,0 @@
-import {
-  View,
-  StyleSheet,
-  Text,
-  Image,
-  Keyboard,
-  TextInput,
-  TouchableOpacity,
-  TouchableWithoutFeedback,
-  KeyboardAvoidingView,
-  Platform,
-} from 'react-native';
-import React, { useContext, useEffect, useState } from 'react';
-import { useSafeAreaInsets } from 'react-native-safe-area-context';
-import Spinner from '../../components/Spinner';
-import {
-  models,
-  useTextToImage,
-  TextToImageProps,
-} from 'react-native-executorch';
-import { ModelPicker, ModelOption } from '../../components/ModelPicker';
-import { GeneratingContext } from '../../context';
-import ColorPalette from '../../colors';
-import ProgressBar from '../../components/ProgressBar';
-import { Ionicons } from '@expo/vector-icons';
-import { StatsBar } from '../../components/StatsBar';
-import ErrorBanner from '../../components/ErrorBanner';
-const imageGeneration = models.image_generation;
-
-type TextToImageModelSources = TextToImageProps['model'];
-
-const MODELS: ModelOption<TextToImageModelSources>[] = [
-  {
-    label: 'BK-SDM 256',
-    value: imageGeneration.bk_sdm_tiny_vpred_256(),
-  },
-  {
-    label: 'BK-SDM 512',
-    value: imageGeneration.bk_sdm_tiny_vpred_512(),
-  },
-];
-
-export default function TextToImageScreen() {
-  const { bottom } = useSafeAreaInsets();
-  const [inferenceStepIdx, setInferenceStepIdx] = useState<number>(0);
-  const [image, setImage] = useState<string | null>(null);
-  const [steps, setSteps] = useState<number>(40);
-
-  const [input, setInput] = useState('');
-  const [selectedModel, setSelectedModel] = useState<TextToImageModelSources>(
-    imageGeneration.bk_sdm_tiny_vpred_256()
-  );
-  const [generationTime, setGenerationTime] = useState<number | null>(null);
-
-  const [keyboardVisible, setKeyboardVisible] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-  const [imageTitle, setImageTitle] = useState<string | null>(null);
-
-  const imageSize = 224;
-  const model = useTextToImage({
-    model: selectedModel,
-    inferenceCallback: (x) => setInferenceStepIdx(x),
-  });
-
-  const { setGlobalGenerating } = useContext(GeneratingContext);
-
-  useEffect(() => {
-    setGlobalGenerating(model.isGenerating);
-  }, [model.isGenerating, setGlobalGenerating]);
-
-  useEffect(() => {
-    if (model.error) setError(String(model.error));
-  }, [model.error]);
-
-  useEffect(() => {
-    const showSub = Keyboard.addListener('keyboardDidShow', () => {
-      setKeyboardVisible(true);
-    });
-    const hideSub = Keyboard.addListener('keyboardDidHide', () => {
-      setKeyboardVisible(false);
-    });
-    return () => {
-      showSub.remove();
-      hideSub.remove();
-    };
-  }, []);
-
-  const runForward = async () => {
-    if (!input.trim()) return;
-
-    setImageTitle(input);
-
-    try {
-      const start = Date.now();
-      const output = await model.generate(input, imageSize, steps);
-
-      if (output.length) {
-        setImage(output);
-        setGenerationTime(Date.now() - start);
-      }
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-      setImageTitle(null);
-    } finally {
-      setInferenceStepIdx(0);
-    }
-  };
-
-  if (!model.isReady && !model.error) {
-    return (
-      <Spinner
-        visible={true}
-        textContent={`Loading the model ${(model.downloadProgress * 100).toFixed(0)} %`}
-      />
-    );
-  }
-
-  return (
-    <TouchableWithoutFeedback
-      onPress={() => {
-        Keyboard.dismiss();
-      }}
-    >
-      <KeyboardAvoidingView
-        style={styles.container}
-        behavior={Platform.OS === 'ios' ? 'padding' : undefined}
-      >
-        {keyboardVisible && <View style={styles.overlay} />}
-
-        <ErrorBanner message={error} onDismiss={() => setError(null)} />
-
-        <View style={styles.titleContainer}>
-          {imageTitle && <Text style={styles.titleText}>{imageTitle}</Text>}
-        </View>
-
-        <View style={styles.imageContainer}>
-          {model.isGenerating ? (
-            <View style={styles.progressContainer}>
-              <Text style={styles.text}>Generating...</Text>
-              <ProgressBar numSteps={steps} currentStep={inferenceStepIdx} />
-            </View>
-          ) : image?.length ? (
-            <Image
-              style={styles.image}
-              resizeMode="contain"
-              source={{ uri: image }}
-            />
-          ) : (
-            <View style={styles.infoContainer}>
-              <Text style={styles.infoTitle}>Text to Image</Text>
-              <Text style={styles.infoText}>
-                This model generates images from text descriptions using a
-                diffusion process. Type a prompt below and tap the send button
-                to generate an image.
-              </Text>
-            </View>
-          )}
-        </View>
-
-        <ModelPicker
-          models={MODELS}
-          selectedModel={selectedModel}
-          disabled={model.isGenerating}
-          onSelect={(m) => {
-            setSelectedModel(m);
-            setImage(null);
-            setGenerationTime(null);
-          }}
-        />
-
-        <View style={styles.stepsRow}>
-          <Text style={styles.stepsLabel}>Steps: {steps}</Text>
-          <TouchableOpacity
-            style={styles.stepButton}
-            onPress={() => setSteps((s) => Math.max(5, s - 5))}
-          >
-            <Text style={styles.stepButtonText}>−</Text>
-          </TouchableOpacity>
-          <TouchableOpacity
-            style={styles.stepButton}
-            onPress={() => setSteps((s) => Math.min(50, s + 5))}
-          >
-            <Text style={styles.stepButtonText}>+</Text>
-          </TouchableOpacity>
-        </View>
-
-        <StatsBar inferenceTime={generationTime} />
-
-        <View style={[styles.inputRow, { marginBottom: bottom || 12 }]}>
-          <TextInput
-            style={styles.textInput}
-            placeholder="Enter prompt..."
-            placeholderTextColor="#aaa"
-            value={input}
-            onChangeText={setInput}
-            onSubmitEditing={runForward}
-            returnKeyType="send"
-          />
-          {model.isGenerating ? (
-            <TouchableOpacity
-              style={styles.sendButton}
-              onPress={model.interrupt}
-            >
-              <Ionicons name="stop" size={20} color="#fff" />
-            </TouchableOpacity>
-          ) : (
-            <TouchableOpacity
-              style={[
-                styles.sendButton,
-                !input.trim() && styles.sendButtonDisabled,
-              ]}
-              onPress={runForward}
-              disabled={!input.trim()}
-            >
-              <Ionicons name="send" size={20} color="#fff" />
-            </TouchableOpacity>
-          )}
-        </View>
-      </KeyboardAvoidingView>
-    </TouchableWithoutFeedback>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    width: '100%',
-  },
-  overlay: {
-    ...StyleSheet.absoluteFill,
-    backgroundColor: 'rgba(0,0,0,0.1)',
-    zIndex: 1,
-  },
-  titleContainer: {
-    paddingHorizontal: 16,
-    paddingTop: 8,
-    alignItems: 'center',
-  },
-  titleText: {
-    fontSize: 18,
-    fontWeight: '600',
-    color: '#333',
-    textAlign: 'center',
-  },
-  imageContainer: {
-    flex: 1,
-    alignItems: 'center',
-    justifyContent: 'center',
-    padding: 16,
-    zIndex: 0,
-  },
-  image: {
-    width: 256,
-    height: 256,
-  },
-  progressContainer: {
-    alignItems: 'center',
-    gap: 12,
-  },
-  text: {
-    fontSize: 16,
-    color: ColorPalette.primary,
-  },
-  stepsRow: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    paddingHorizontal: 16,
-    paddingVertical: 6,
-    gap: 8,
-  },
-  stepsLabel: {
-    flex: 1,
-    fontSize: 14,
-    color: ColorPalette.primary,
-  },
-  stepButton: {
-    width: 36,
-    height: 36,
-    borderRadius: 8,
-    backgroundColor: ColorPalette.primary,
-    alignItems: 'center',
-    justifyContent: 'center',
-  },
-  stepButtonText: {
-    color: '#fff',
-    fontSize: 20,
-    lineHeight: 22,
-  },
-  inputRow: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    margin: 12,
-    gap: 8,
-  },
-  textInput: {
-    flex: 1,
-    borderWidth: 1,
-    borderColor: '#C1C6E5',
-    borderRadius: 8,
-    paddingHorizontal: 12,
-    paddingVertical: 10,
-    fontSize: 14,
-    color: ColorPalette.primary,
-  },
-  sendButton: {
-    width: 44,
-    height: 44,
-    borderRadius: 8,
-    backgroundColor: ColorPalette.primary,
-    alignItems: 'center',
-    justifyContent: 'center',
-  },
-  sendButtonDisabled: {
-    backgroundColor: '#888',
-  },
-  infoContainer: {
-    alignItems: 'center',
-    padding: 16,
-    gap: 8,
-  },
-  infoTitle: {
-    fontSize: 18,
-    fontWeight: '600',
-    color: 'navy',
-  },
-  infoText: {
-    fontSize: 14,
-    color: '#555',
-    textAlign: 'center',
-    lineHeight: 20,
-  },
-});
diff --git a/apps/computer-vision/app/vision_camera/index.tsx b/apps/computer-vision/app/vision_camera/index.tsx
deleted file mode 100644
index 65febb5ac8..0000000000
--- a/apps/computer-vision/app/vision_camera/index.tsx
+++ /dev/null
@@ -1,567 +0,0 @@
-import React, { useCallback, useContext, useEffect, useState } from 'react';
-import {
-  ScrollView,
-  StatusBar,
-  StyleSheet,
-  Text,
-  TouchableOpacity,
-  View,
-} from 'react-native';
-import { useSafeAreaInsets } from 'react-native-safe-area-context';
-import { useIsFocused } from 'expo-router';
-import {
-  Camera,
-  useCameraDevices,
-  useCameraPermission,
-  useFrameOutput,
-} from 'react-native-vision-camera';
-import { createSynchronizable } from 'react-native-worklets';
-import Svg, { Path, Polygon } from 'react-native-svg';
-import { useRouter } from 'expo-router';
-import { Ionicons } from '@expo/vector-icons';
-import { GeneratingContext } from '../../context';
-import Spinner from '../../components/Spinner';
-import ColorPalette from '../../colors';
-import ClassificationTask from '../../components/vision_camera/tasks/ClassificationTask';
-import ObjectDetectionTask from '../../components/vision_camera/tasks/ObjectDetectionTask';
-import SegmentationTask from '../../components/vision_camera/tasks/SegmentationTask';
-import InstanceSegmentationTask from '../../components/vision_camera/tasks/InstanceSegmentationTask';
-import OCRTask from '../../components/vision_camera/tasks/OCRTask';
-import StyleTransferTask from '../../components/vision_camera/tasks/StyleTransferTask';
-import PoseEstimationTask from '../../components/vision_camera/tasks/PoseEstimationTask';
-// 1. Import ErrorBanner
-import ErrorBanner from '../../components/ErrorBanner';
-
-type TaskId =
-  | 'classification'
-  | 'objectDetection'
-  | 'segmentation'
-  | 'instanceSegmentation'
-  | 'poseEstimation'
-  | 'ocr'
-  | 'styleTransfer';
-type ModelId =
-  | 'classification'
-  | 'objectDetectionSsdlite'
-  | 'objectDetectionRfdetr'
-  | 'objectDetectionYolo26n'
-  | 'segmentationDeeplabResnet50'
-  | 'segmentationDeeplabResnet101'
-  | 'segmentationDeeplabMobilenet'
-  | 'segmentationLraspp'
-  | 'segmentationFcnResnet50'
-  | 'segmentationFcnResnet101'
-  | 'segmentationSelfie'
-  | 'instanceSegmentationYolo26n'
-  | 'instanceSegmentationRfdetr'
-  | 'instanceSegmentationFastsamS'
-  | 'instanceSegmentationFastsamX'
-  | 'poseEstimationYolo26n'
-  | 'ocr'
-  | 'styleTransferCandy'
-  | 'styleTransferMosaic';
-
-type TaskVariant = { id: ModelId; label: string };
-type Task = { id: TaskId; label: string; variants: TaskVariant[] };
-
-const TASKS: Task[] = [
-  {
-    id: 'classification',
-    label: 'Classify',
-    variants: [{ id: 'classification', label: 'EfficientNet V2 S' }],
-  },
-  {
-    id: 'segmentation',
-    label: 'Segment',
-    variants: [
-      { id: 'segmentationDeeplabResnet50', label: 'DeepLab ResNet50' },
-      { id: 'segmentationDeeplabResnet101', label: 'DeepLab ResNet101' },
-      { id: 'segmentationDeeplabMobilenet', label: 'DeepLab MobileNet' },
-      { id: 'segmentationLraspp', label: 'LRASPP MobileNet' },
-      { id: 'segmentationFcnResnet50', label: 'FCN ResNet50' },
-      { id: 'segmentationFcnResnet101', label: 'FCN ResNet101' },
-      { id: 'segmentationSelfie', label: 'Selfie' },
-    ],
-  },
-  {
-    id: 'instanceSegmentation',
-    label: 'Inst Seg',
-    variants: [
-      { id: 'instanceSegmentationYolo26n', label: 'YOLO26N Seg' },
-      { id: 'instanceSegmentationRfdetr', label: 'RF-DETR Nano Seg' },
-      { id: 'instanceSegmentationFastsamS', label: 'FastSAM-S' },
-      { id: 'instanceSegmentationFastsamX', label: 'FastSAM-X' },
-    ],
-  },
-  {
-    id: 'poseEstimation',
-    label: 'Pose',
-    variants: [{ id: 'poseEstimationYolo26n', label: 'YOLO26N Pose' }],
-  },
-  {
-    id: 'objectDetection',
-    label: 'Detect',
-    variants: [
-      { id: 'objectDetectionSsdlite', label: 'SSDLite MobileNet' },
-      { id: 'objectDetectionRfdetr', label: 'RF-DETR Nano' },
-      { id: 'objectDetectionYolo26n', label: 'YOLO26N' },
-    ],
-  },
-  {
-    id: 'ocr',
-    label: 'OCR',
-    variants: [{ id: 'ocr', label: 'English' }],
-  },
-  {
-    id: 'styleTransfer',
-    label: 'Style',
-    variants: [
-      { id: 'styleTransferCandy', label: 'Candy' },
-      { id: 'styleTransferMosaic', label: 'Mosaic' },
-    ],
-  },
-];
-
-export default function VisionCameraScreen() {
-  const insets = useSafeAreaInsets();
-  const router = useRouter();
-  const [frameKillSwitch] = useState(() => createSynchronizable(false));
-  const [cameraPositionSync] = useState(() =>
-    createSynchronizable<'front' | 'back'>('back')
-  );
-  const [activeTask, setActiveTask] = useState<TaskId>('classification');
-  const [activeModel, setActiveModel] = useState<ModelId>('classification');
-  const [canvasSize, setCanvasSize] = useState({ width: 1, height: 1 });
-  const [cameraPosition, setCameraPosition] = useState<'front' | 'back'>(
-    'back'
-  );
-  const [fps, setFps] = useState(0);
-  const [frameMs, setFrameMs] = useState(0);
-  const [isReady, setIsReady] = useState(false);
-  const [downloadProgress, setDownloadProgress] = useState(0);
-  const [frameOutput, setFrameOutput] = useState<ReturnType<
-    typeof useFrameOutput
-  > | null>(null);
-
-  const [error, setError] = useState<string | null>(null);
-
-  const { setGlobalGenerating } = useContext(GeneratingContext);
-
-  const isFocused = useIsFocused();
-  const cameraPermission = useCameraPermission();
-  const devices = useCameraDevices();
-  const device =
-    devices.find((d) => d.position === cameraPosition) ?? devices[0];
-  useEffect(() => {
-    frameKillSwitch.setBlocking(true);
-    setError(null);
-    const id = setTimeout(() => {
-      frameKillSwitch.setBlocking(false);
-    }, 300);
-    return () => clearTimeout(id);
-  }, [activeModel, frameKillSwitch]);
-
-  useEffect(() => {
-    cameraPositionSync.setBlocking(cameraPosition);
-  }, [cameraPosition, cameraPositionSync]);
-
-  const handleFpsChange = useCallback((newFps: number, newMs: number) => {
-    setFps(newFps);
-    setFrameMs(newMs);
-  }, []);
-
-  const handleGeneratingChange = useCallback(
-    (generating: boolean) => {
-      setGlobalGenerating(generating);
-    },
-    [setGlobalGenerating]
-  );
-
-  const handleErrorChange = useCallback((errorMessage: string | null) => {
-    setError(errorMessage);
-  }, []);
-
-  if (!cameraPermission.hasPermission) {
-    return (
-      <View style={styles.centered}>
-        <Text style={styles.message}>Camera access needed</Text>
-        <TouchableOpacity
-          onPress={() => cameraPermission.requestPermission()}
-          style={styles.button}
-        >
-          <Text style={styles.buttonText}>Grant Permission</Text>
-        </TouchableOpacity>
-      </View>
-    );
-  }
-
-  if (device == null) {
-    return (
-      <View style={styles.centered}>
-        <Text style={styles.message}>No camera device found</Text>
-      </View>
-    );
-  }
-
-  const activeTaskInfo = TASKS.find((t) => t.id === activeTask)!;
-  const activeVariantLabel =
-    activeTaskInfo.variants.find((v) => v.id === activeModel)?.label ??
-    activeTaskInfo.variants[0]!.label;
-
-  const taskProps = {
-    activeModel,
-    canvasSize,
-    cameraPositionSync,
-    frameKillSwitch,
-    onFrameOutputChange: setFrameOutput,
-    onReadyChange: setIsReady,
-    onProgressChange: setDownloadProgress,
-    onGeneratingChange: handleGeneratingChange,
-    onFpsChange: handleFpsChange,
-    onErrorChange: handleErrorChange,
-  };
-
-  return (
-    <View style={styles.container}>
-      <StatusBar barStyle="light-content" translucent />
-
-      <View style={[styles.errorOverlay, { paddingTop: insets.top }]}>
-        <ErrorBanner message={error} onDismiss={() => setError(null)} />
-      </View>
-
-      <Camera
-        style={StyleSheet.absoluteFill}
-        device={device}
-        outputs={frameOutput ? [frameOutput] : []}
-        isActive={isFocused}
-        // Segmentation draws a 2D mask that the native side rotates into the
-        // activity's coord system (portrait, since the activity is locked).
-        // Pin the preview to that same coord system so mask + preview can't
-        // drift apart when the phone is tilted. Other tasks render coords
-        // (bboxes/points) and tolerate the device-rotated preview fine.
-        orientationSource={
-          activeTask === 'segmentation' ? 'interface' : 'device'
-        }
-        onError={(e) => {
-          console.warn('[Camera] onError', e);
-          setError(e.message);
-        }}
-        onStarted={() => console.log('[Camera] session started')}
-        onPreviewStarted={() => console.log('[Camera] preview got first frame')}
-      />
-
-      <View
-        style={StyleSheet.absoluteFill}
-        pointerEvents="none"
-        onLayout={(e) =>
-          setCanvasSize({
-            width: e.nativeEvent.layout.width,
-            height: e.nativeEvent.layout.height,
-          })
-        }
-      />
-
-      {activeTask === 'classification' && <ClassificationTask {...taskProps} />}
-      {activeTask === 'objectDetection' && (
-        <ObjectDetectionTask
-          {...taskProps}
-          activeModel={
-            activeModel as
-              | 'objectDetectionSsdlite'
-              | 'objectDetectionRfdetr'
-              | 'objectDetectionYolo26n'
-          }
-        />
-      )}
-      {activeTask === 'segmentation' && (
-        <SegmentationTask
-          {...taskProps}
-          activeModel={
-            activeModel as
-              | 'segmentationDeeplabResnet50'
-              | 'segmentationDeeplabResnet101'
-              | 'segmentationDeeplabMobilenet'
-              | 'segmentationLraspp'
-              | 'segmentationFcnResnet50'
-              | 'segmentationFcnResnet101'
-              | 'segmentationSelfie'
-          }
-        />
-      )}
-      {activeTask === 'instanceSegmentation' && (
-        <InstanceSegmentationTask
-          {...taskProps}
-          activeModel={
-            activeModel as
-              | 'instanceSegmentationYolo26n'
-              | 'instanceSegmentationRfdetr'
-              | 'instanceSegmentationFastsamS'
-              | 'instanceSegmentationFastsamX'
-          }
-        />
-      )}
-      {activeTask === 'poseEstimation' && (
-        <PoseEstimationTask
-          {...taskProps}
-          activeModel={activeModel as 'poseEstimationYolo26n'}
-        />
-      )}
-      {activeTask === 'ocr' && <OCRTask {...taskProps} />}
-      {activeTask === 'styleTransfer' && (
-        <StyleTransferTask
-          {...taskProps}
-          activeModel={
-            activeModel as 'styleTransferCandy' | 'styleTransferMosaic'
-          }
-        />
-      )}
-
-      {!isReady && !error && (
-        <View style={styles.loadingOverlay}>
-          <Spinner
-            visible
-            textContent={`Loading ${activeTaskInfo.label} ${(downloadProgress * 100).toFixed(0)}%`}
-          />
-        </View>
-      )}
-
-      <View
-        style={[styles.topOverlay, { paddingTop: insets.top + 8 }]}
-        pointerEvents="box-none"
-      >
-        <TouchableOpacity
-          style={[styles.backButton, { top: insets.top + 8 }]}
-          onPress={() => router.navigate('/')}
-        >
-          <Ionicons name="chevron-back" size={24} color="white" />
-        </TouchableOpacity>
-
-        <View style={styles.titleRow} pointerEvents="none">
-          <Text style={styles.modelTitle}>{activeVariantLabel}</Text>
-          <Text style={styles.fpsText}>
-            {fps} FPS – {frameMs.toFixed(0)} ms
-          </Text>
-        </View>
-
-        <ScrollView
-          horizontal
-          showsHorizontalScrollIndicator={false}
-          contentContainerStyle={styles.tabsContent}
-        >
-          {TASKS.map((t) => (
-            <TouchableOpacity
-              key={t.id}
-              style={[styles.tab, activeTask === t.id && styles.tabActive]}
-              onPress={() => {
-                setActiveTask(t.id);
-                setActiveModel(t.variants[0]!.id);
-              }}
-            >
-              <Text
-                style={[
-                  styles.tabText,
-                  activeTask === t.id && styles.tabTextActive,
-                ]}
-              >
-                {t.label}
-              </Text>
-            </TouchableOpacity>
-          ))}
-        </ScrollView>
-
-        <ScrollView
-          horizontal
-          showsHorizontalScrollIndicator={false}
-          contentContainerStyle={styles.chipsContent}
-        >
-          {activeTaskInfo.variants.map((v) => (
-            <TouchableOpacity
-              key={v.id}
-              style={[
-                styles.variantChip,
-                activeModel === v.id && styles.variantChipActive,
-              ]}
-              onPress={() => setActiveModel(v.id)}
-            >
-              <Text
-                style={[
-                  styles.variantChipText,
-                  activeModel === v.id && styles.variantChipTextActive,
-                ]}
-              >
-                {v.label}
-              </Text>
-            </TouchableOpacity>
-          ))}
-        </ScrollView>
-      </View>
-
-      <View
-        style={[styles.bottomOverlay, { paddingBottom: insets.bottom + 16 }]}
-        pointerEvents="box-none"
-      >
-        <TouchableOpacity
-          style={styles.flipButton}
-          onPress={() =>
-            setCameraPosition((p) => (p === 'back' ? 'front' : 'back'))
-          }
-        >
-          <Svg width={28} height={28} viewBox="0 0 24 24" fill="none">
-            <Path
-              d="M23 19a2 2 0 0 1-2 2H3a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h4l2-3h6l2 3h4a2 2 0 0 1 2 2z"
-              stroke="white"
-              strokeWidth={1.8}
-              strokeLinecap="round"
-              strokeLinejoin="round"
-            />
-            <Path
-              d="M9 13.5a3 3 0 1 0 3-3"
-              stroke="white"
-              strokeWidth={1.8}
-              strokeLinecap="round"
-            />
-            <Polygon points="8,11 9,13.5 11,12" fill="white" />
-          </Svg>
-        </TouchableOpacity>
-      </View>
-    </View>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: { flex: 1, backgroundColor: 'black' },
-  errorOverlay: {
-    position: 'absolute',
-    top: 0,
-    left: 0,
-    right: 0,
-    zIndex: 100,
-  },
-  centered: {
-    flex: 1,
-    backgroundColor: 'black',
-    justifyContent: 'center',
-    alignItems: 'center',
-    gap: 16,
-  },
-  message: { color: 'white', fontSize: 18 },
-  button: {
-    paddingHorizontal: 24,
-    paddingVertical: 12,
-    backgroundColor: ColorPalette.primary,
-    borderRadius: 24,
-  },
-  buttonText: { color: 'white', fontSize: 15, fontWeight: '600' },
-  loadingOverlay: {
-    ...StyleSheet.absoluteFill,
-    backgroundColor: 'rgba(0,0,0,0.6)',
-    justifyContent: 'center',
-    alignItems: 'center',
-    zIndex: 10,
-  },
-  topOverlay: {
-    position: 'absolute',
-    top: 0,
-    left: 0,
-    right: 0,
-    alignItems: 'center',
-    gap: 8,
-    zIndex: 5,
-  },
-  titleRow: {
-    alignItems: 'center',
-    paddingHorizontal: 16,
-  },
-  modelTitle: {
-    color: 'white',
-    fontSize: 22,
-    fontWeight: '700',
-    textShadowColor: 'rgba(0,0,0,0.7)',
-    textShadowOffset: { width: 0, height: 1 },
-    textShadowRadius: 4,
-  },
-  fpsText: {
-    color: 'rgba(255,255,255,0.85)',
-    fontSize: 14,
-    fontWeight: '500',
-    marginTop: 2,
-    textShadowColor: 'rgba(0,0,0,0.7)',
-    textShadowOffset: { width: 0, height: 1 },
-    textShadowRadius: 4,
-  },
-  tabsContent: {
-    paddingHorizontal: 12,
-    gap: 6,
-  },
-  tab: {
-    paddingHorizontal: 18,
-    paddingVertical: 7,
-    borderRadius: 20,
-    backgroundColor: 'rgba(0,0,0,0.45)',
-    borderWidth: 1,
-    borderColor: 'rgba(255,255,255,0.25)',
-  },
-  tabActive: {
-    backgroundColor: 'rgba(255,255,255,0.2)',
-    borderColor: 'white',
-  },
-  tabText: {
-    color: 'rgba(255,255,255,0.7)',
-    fontSize: 14,
-    fontWeight: '600',
-  },
-  tabTextActive: { color: 'white' },
-  chipsContent: {
-    paddingHorizontal: 12,
-    gap: 6,
-  },
-  variantChip: {
-    paddingHorizontal: 14,
-    paddingVertical: 5,
-    borderRadius: 16,
-    backgroundColor: 'rgba(0,0,0,0.35)',
-    borderWidth: 1,
-    borderColor: 'rgba(255,255,255,0.15)',
-  },
-  variantChipActive: {
-    backgroundColor: ColorPalette.primary,
-    borderColor: ColorPalette.primary,
-  },
-  variantChipText: {
-    color: 'rgba(255,255,255,0.6)',
-    fontSize: 12,
-    fontWeight: '500',
-  },
-  variantChipTextActive: { color: 'white' },
-  bottomOverlay: {
-    position: 'absolute',
-    bottom: 0,
-    left: 0,
-    right: 0,
-    alignItems: 'center',
-    zIndex: 5,
-  },
-  flipButton: {
-    width: 56,
-    height: 56,
-    borderRadius: 28,
-    backgroundColor: 'rgba(255,255,255,0.2)',
-    justifyContent: 'center',
-    alignItems: 'center',
-    borderWidth: 1.5,
-    borderColor: 'rgba(255,255,255,0.4)',
-  },
-  backButton: {
-    position: 'absolute',
-    left: 12,
-    width: 40,
-    height: 40,
-    borderRadius: 20,
-    backgroundColor: 'rgba(0,0,0,0.45)',
-    justifyContent: 'center',
-    alignItems: 'center',
-    borderWidth: 1,
-    borderColor: 'rgba(255,255,255,0.25)',
-    zIndex: 10,
-  },
-});
diff --git a/apps/computer-vision/assets/fonts/Aeonik-Medium.otf b/apps/computer-vision/assets/fonts/Aeonik-Medium.otf
deleted file mode 100644
index cd9981f439..0000000000
Binary files a/apps/computer-vision/assets/fonts/Aeonik-Medium.otf and /dev/null differ
diff --git a/apps/computer-vision/assets/fonts/Aeonik-Regular.otf b/apps/computer-vision/assets/fonts/Aeonik-Regular.otf
deleted file mode 100644
index 9bd378ed2b..0000000000
Binary files a/apps/computer-vision/assets/fonts/Aeonik-Regular.otf and /dev/null differ
diff --git a/apps/computer-vision/assets/icons/adaptive-icon.png b/apps/computer-vision/assets/icons/adaptive-icon.png
deleted file mode 100644
index 03d6f6b6c6..0000000000
Binary files a/apps/computer-vision/assets/icons/adaptive-icon.png and /dev/null differ
diff --git a/apps/computer-vision/assets/icons/executorch.svg b/apps/computer-vision/assets/icons/executorch.svg
deleted file mode 100644
index e548ea4201..0000000000
--- a/apps/computer-vision/assets/icons/executorch.svg
+++ /dev/null
@@ -1,9 +0,0 @@
-<svg width="65" height="64" viewBox="0 0 65 64" fill="none" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
-<path d="M0.5 4C0.5 1.79086 2.29086 0 4.5 0H60.5C62.7091 0 64.5 1.79086 64.5 4V60C64.5 62.2091 62.7091 64 60.5 64H4.5C2.29086 64 0.5 62.2091 0.5 60V4Z" fill="url(#pattern0_13229_4194)"/>
-<defs>
-<pattern id="pattern0_13229_4194" patternContentUnits="objectBoundingBox" width="1" height="1">
-<use xlink:href="#image0_13229_4194" transform="translate(-0.000263435) scale(0.00052687)"/>
-</pattern>
-<image id="image0_13229_4194" width="1899" height="1898" preserveAspectRatio="none" xlink:href="data:image/png;base64,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"/>
-</defs>
-</svg>
diff --git a/apps/computer-vision/assets/icons/executorch_logo.png b/apps/computer-vision/assets/icons/executorch_logo.png
deleted file mode 100644
index 73bdec1b7c..0000000000
Binary files a/apps/computer-vision/assets/icons/executorch_logo.png and /dev/null differ
diff --git a/apps/computer-vision/assets/icons/favicon.png b/apps/computer-vision/assets/icons/favicon.png
deleted file mode 100644
index e75f697b18..0000000000
Binary files a/apps/computer-vision/assets/icons/favicon.png and /dev/null differ
diff --git a/apps/computer-vision/assets/icons/icon.png b/apps/computer-vision/assets/icons/icon.png
deleted file mode 100644
index a0b1526fc7..0000000000
Binary files a/apps/computer-vision/assets/icons/icon.png and /dev/null differ
diff --git a/apps/computer-vision/assets/icons/splash.png b/apps/computer-vision/assets/icons/splash.png
deleted file mode 100644
index 0e89705a94..0000000000
Binary files a/apps/computer-vision/assets/icons/splash.png and /dev/null differ
diff --git a/apps/computer-vision/assets/icons/swm_icon.svg b/apps/computer-vision/assets/icons/swm_icon.svg
deleted file mode 100644
index 8c62f039be..0000000000
--- a/apps/computer-vision/assets/icons/swm_icon.svg
+++ /dev/null
@@ -1,13 +0,0 @@
-<svg width="47" height="25" viewBox="0 0 47 25" fill="none" xmlns="http://www.w3.org/2000/svg">
-<g clip-path="url(#clip0_2_550)">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M0.575378 0.0757751H1.14095H38.7328H38.9679L39.1338 0.24327L46.1469 7.3266L46.3114 7.49283V7.72729V24.2424V24.8106H45.7459H8.19177H7.9575L7.79185 24.6442L0.741031 17.5609L0.575378 17.3945V17.1591V0.643957V0.0757751ZM1.70653 2.01567V16.9238L7.62618 22.8707V7.96262L1.70653 2.01567ZM2.50637 1.21214L8.42604 7.15911H44.3856L38.4976 1.21214H2.50637ZM45.1803 23.6743H8.75733V8.29548H45.1803V23.6743Z" fill="#001A72"/>
-<path d="M17.9197 17.6137C17.9197 18.8637 17.1279 19.9243 15.1295 19.9243C14.2623 19.9243 13.5836 19.7349 12.9426 19.4697V17.7652C13.5836 18.1061 14.3754 18.2955 15.0918 18.2955C15.7328 18.2955 16.0721 18.1061 16.0721 17.7273C16.0721 16.5909 12.9426 16.9318 12.9426 14.5833C12.9426 13.144 14.1115 12.2349 15.6951 12.2349C16.3738 12.2349 16.9771 12.3864 17.618 12.7652V14.5833C16.7508 14.053 16.1475 13.8637 15.6574 13.8637C15.0541 13.8637 14.7525 14.0909 14.7525 14.4318C14.7148 15.5303 17.9197 15.1137 17.9197 17.6137Z" fill="#001A72"/>
-<path d="M30.4 12.4242L28.0246 19.7727H26.2147L24.6311 14.697L23.0098 19.7348H21.2L18.8246 12.3864H20.8607L22.1803 17.3106L23.7262 12.3864H25.5361L27.082 17.3106L28.4016 12.3864H30.4V12.4242Z" fill="#001A72"/>
-<path d="M41.7492 14.9243V19.7727H39.9394V15.2273C39.9394 14.4318 39.3738 13.9773 38.7705 13.9773C38.1295 13.9773 37.6017 14.4318 37.6017 15.2273V19.7727H35.7918V15.2273C35.7918 14.4318 35.2263 13.9773 34.623 13.9773C33.982 13.9773 33.4541 14.4318 33.4541 15.2273V19.7727H31.6443V12.4243H33.341V12.9546C33.8689 12.4243 34.4345 12.2349 35.1131 12.2349C35.8672 12.2349 36.5459 12.5758 36.9984 13.1818C37.6017 12.5379 38.3558 12.2349 39.223 12.2349C40.6935 12.2727 41.7492 13.3333 41.7492 14.9243Z" fill="#001A72"/>
-</g>
-<defs>
-<clipPath id="clip0_2_550">
-<rect width="46" height="25" fill="white" transform="translate(0.5)"/>
-</clipPath>
-</defs>
-</svg>
diff --git a/apps/computer-vision/babel.config.js b/apps/computer-vision/babel.config.js
deleted file mode 100644
index 6b2006979c..0000000000
--- a/apps/computer-vision/babel.config.js
+++ /dev/null
@@ -1,7 +0,0 @@
-module.exports = function (api) {
-  api.cache(true);
-  return {
-    presets: ['babel-preset-expo'],
-    plugins: ['react-native-worklets/plugin'],
-  };
-};
diff --git a/apps/computer-vision/colors.ts b/apps/computer-vision/colors.ts
deleted file mode 100644
index feb75ac336..0000000000
--- a/apps/computer-vision/colors.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-const ColorPalette = {
-  primary: '#001A72',
-  strongPrimary: '#020F3C',
-};
-
-export default ColorPalette;
diff --git a/apps/computer-vision/components/BottomBar.tsx b/apps/computer-vision/components/BottomBar.tsx
deleted file mode 100644
index 617abe11fc..0000000000
--- a/apps/computer-vision/components/BottomBar.tsx
+++ /dev/null
@@ -1,82 +0,0 @@
-import ColorPalette from '../colors';
-import FontAwesome from '@expo/vector-icons/FontAwesome';
-import { View, TouchableOpacity, StyleSheet, Text } from 'react-native';
-import { useSafeAreaInsets } from 'react-native-safe-area-context';
-import DeviceInfo from 'react-native-device-info';
-
-const isDevice = !DeviceInfo.isEmulatorSync();
-
-export const BottomBar = ({
-  handleCameraPress,
-  runForward,
-  hasImage = true,
-  isGenerating = false,
-}: {
-  handleCameraPress: (isCamera: boolean) => void;
-  runForward: () => void;
-  hasImage?: boolean;
-  isGenerating?: boolean;
-}) => {
-  const { bottom } = useSafeAreaInsets();
-  const disabled = !hasImage || isGenerating;
-  return (
-    <View style={[styles.bottomContainer, { paddingBottom: bottom || 16 }]}>
-      <View style={styles.bottomIconsContainer}>
-        <TouchableOpacity onPress={() => handleCameraPress(false)}>
-          <FontAwesome name="photo" size={24} color={ColorPalette.primary} />
-        </TouchableOpacity>
-        <TouchableOpacity onPress={() => isDevice && handleCameraPress(true)}>
-          <FontAwesome
-            name="camera"
-            size={24}
-            color={isDevice ? ColorPalette.primary : '#888'}
-          />
-        </TouchableOpacity>
-      </View>
-      <TouchableOpacity
-        style={[styles.button, disabled && styles.buttonDisabled]}
-        onPress={runForward}
-        disabled={disabled}
-      >
-        <Text style={styles.buttonText}>
-          {isGenerating
-            ? 'Running...'
-            : hasImage
-              ? 'Run model'
-              : 'Pick an image to run the model'}
-        </Text>
-      </TouchableOpacity>
-    </View>
-  );
-};
-
-const styles = StyleSheet.create({
-  bottomContainer: {
-    width: '100%',
-    gap: 15,
-    alignItems: 'center',
-    paddingTop: 16,
-    paddingHorizontal: 16,
-  },
-  bottomIconsContainer: {
-    flexDirection: 'row',
-    justifyContent: 'space-evenly',
-    width: '100%',
-  },
-  button: {
-    width: '100%',
-    height: 50,
-    justifyContent: 'center',
-    alignItems: 'center',
-    backgroundColor: ColorPalette.primary,
-    color: '#fff',
-    borderRadius: 8,
-  },
-  buttonDisabled: {
-    backgroundColor: '#888',
-  },
-  buttonText: {
-    color: '#fff',
-    fontSize: 16,
-  },
-});
diff --git a/apps/computer-vision/components/BottomBarWithTextInput.tsx b/apps/computer-vision/components/BottomBarWithTextInput.tsx
deleted file mode 100644
index 8cffec3958..0000000000
--- a/apps/computer-vision/components/BottomBarWithTextInput.tsx
+++ /dev/null
@@ -1,168 +0,0 @@
-import React, { useState } from 'react';
-import {
-  View,
-  Text,
-  TextInput,
-  TouchableOpacity,
-  StyleSheet,
-  KeyboardAvoidingView,
-  Platform,
-} from 'react-native';
-import { Ionicons } from '@expo/vector-icons';
-import ColorPalette from '../colors';
-
-interface BottomBarProps {
-  runModel: (input: string, numSteps: number) => void;
-  stopModel: () => void;
-  numSteps: number;
-  setSteps: React.Dispatch<React.SetStateAction<number>>;
-  isGenerating?: boolean;
-  isReady?: boolean;
-  showTextInput: boolean;
-  setShowTextInput: React.Dispatch<React.SetStateAction<boolean>>;
-  keyboardVisible: boolean;
-}
-
-export const BottomBarWithTextInput = ({
-  runModel,
-  stopModel,
-  numSteps,
-  setSteps,
-  isGenerating,
-  isReady,
-  showTextInput,
-  setShowTextInput,
-  keyboardVisible,
-}: BottomBarProps) => {
-  const [input, setInput] = useState('');
-
-  const decreaseSteps = () => setSteps((prev) => Math.max(5, prev - 5));
-  const increaseSteps = () => setSteps((prev) => Math.min(50, prev + 5));
-
-  if (!showTextInput) {
-    if (isGenerating) {
-      return (
-        <TouchableOpacity
-          style={styles.button}
-          onPress={stopModel}
-          disabled={!isReady}
-        >
-          <Text style={styles.buttonText}>Stop model</Text>
-        </TouchableOpacity>
-      );
-    } else {
-      return (
-        <TouchableOpacity
-          style={styles.button}
-          onPress={() => setShowTextInput(true)}
-          disabled={!isReady}
-        >
-          <Text style={styles.buttonText}>Run model</Text>
-        </TouchableOpacity>
-      );
-    }
-  }
-
-  return (
-    <KeyboardAvoidingView
-      style={styles.container}
-      collapsable={false}
-      behavior={Platform.OS === 'ios' ? 'padding' : undefined}
-      keyboardVerticalOffset={Platform.OS === 'ios' ? 120 : 40}
-    >
-      <View style={styles.inputContainer}>
-        <TextInput
-          style={styles.input}
-          placeholder="Enter prompt..."
-          value={input}
-          onChangeText={setInput}
-        />
-        <TouchableOpacity
-          style={[styles.button, styles.iconButton]}
-          onPress={() => {
-            setShowTextInput(false);
-            setInput('');
-            runModel(input, numSteps);
-          }}
-          disabled={!isReady || isGenerating}
-        >
-          <Ionicons name="send" size={20} color="#fff" />
-        </TouchableOpacity>
-      </View>
-
-      <View style={styles.stepsContainer}>
-        <Text style={[styles.text, keyboardVisible && styles.textWhite]}>
-          Steps: {numSteps}
-        </Text>
-        <View style={styles.stepsButtons}>
-          <TouchableOpacity
-            style={[styles.button, styles.iconButton]}
-            onPress={decreaseSteps}
-          >
-            <Text style={styles.buttonText}>-</Text>
-          </TouchableOpacity>
-          <TouchableOpacity
-            style={[styles.button, styles.iconButton]}
-            onPress={increaseSteps}
-          >
-            <Text style={styles.buttonText}>+</Text>
-          </TouchableOpacity>
-        </View>
-      </View>
-    </KeyboardAvoidingView>
-  );
-};
-
-const styles = StyleSheet.create({
-  container: {
-    alignItems: 'center',
-  },
-  inputContainer: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    justifyContent: 'center',
-  },
-  input: {
-    flex: 1,
-    borderRadius: 6,
-    padding: 8,
-    marginRight: 8,
-    backgroundColor: '#fff',
-    color: '#000',
-  },
-  stepsContainer: {
-    width: '100%',
-    flexDirection: 'row',
-    alignItems: 'center',
-    justifyContent: 'space-between',
-    marginTop: 10,
-  },
-  stepsButtons: {
-    flexDirection: 'row',
-  },
-  button: {
-    width: '100%',
-    height: 40,
-    justifyContent: 'center',
-    alignItems: 'center',
-    backgroundColor: ColorPalette.primary,
-    borderRadius: 8,
-  },
-  buttonText: {
-    color: '#fff',
-    fontSize: 16,
-    textAlign: 'center',
-  },
-  iconButton: {
-    marginHorizontal: 5,
-    width: 40,
-  },
-  text: {
-    flex: 1,
-    fontSize: 16,
-    color: '#000',
-  },
-  textWhite: {
-    color: '#fff',
-  },
-});
diff --git a/apps/computer-vision/components/BoundingBoxes.tsx b/apps/computer-vision/components/BoundingBoxes.tsx
deleted file mode 100644
index 0c1e41c261..0000000000
--- a/apps/computer-vision/components/BoundingBoxes.tsx
+++ /dev/null
@@ -1,90 +0,0 @@
-import React from 'react';
-import { StyleSheet, Text, View } from 'react-native';
-import { Detection, LabelEnum } from 'react-native-executorch';
-import { labelColor, labelColorBg } from './utils/colors';
-
-interface Props<L extends LabelEnum> {
-  detections: Detection<L>[];
-  scaleX: number;
-  scaleY: number;
-  offsetX: number;
-  offsetY: number;
-  mirrorLabels?: boolean;
-  containerWidth?: number;
-}
-
-export default function BoundingBoxes<L extends LabelEnum>({
-  detections,
-  scaleX,
-  scaleY,
-  offsetX,
-  offsetY,
-  mirrorLabels = false,
-  containerWidth,
-}: Props<L>) {
-  return (
-    <>
-      {detections.map((det, i) => {
-        const left = det.bbox.x1 * scaleX + offsetX;
-        const top = det.bbox.y1 * scaleY + offsetY;
-        const width = (det.bbox.x2 - det.bbox.x1) * scaleX;
-        const height = (det.bbox.y2 - det.bbox.y1) * scaleY;
-        const labelTop = top < 26 ? top + height + 2 : top - 26;
-
-        return (
-          <React.Fragment key={i}>
-            <View
-              style={[
-                styles.bbox,
-                {
-                  left,
-                  top,
-                  width,
-                  height,
-                  borderColor: labelColor(det.label as string),
-                },
-              ]}
-            />
-            <View
-              style={[
-                styles.label,
-                {
-                  left,
-                  top: labelTop,
-                  backgroundColor: labelColorBg(det.label as string),
-                  ...(containerWidth !== undefined && {
-                    maxWidth: containerWidth - left,
-                  }),
-                },
-                mirrorLabels && { transform: [{ scaleX: -1 }] },
-              ]}
-            >
-              <Text style={styles.labelText} numberOfLines={1}>
-                {String(det.label)} ({(det.score * 100).toFixed(1)}%)
-              </Text>
-            </View>
-          </React.Fragment>
-        );
-      })}
-    </>
-  );
-}
-
-const styles = StyleSheet.create({
-  bbox: {
-    position: 'absolute',
-    borderWidth: 2,
-    borderRadius: 4,
-  },
-  label: {
-    position: 'absolute',
-    paddingHorizontal: 6,
-    paddingVertical: 2,
-    borderRadius: 4,
-  },
-  labelText: {
-    color: 'white',
-    fontSize: 11,
-    fontWeight: '600',
-  },
-});
diff --git a/apps/computer-vision/components/ErrorBanner.tsx b/apps/computer-vision/components/ErrorBanner.tsx
deleted file mode 100644
index a5bebc504f..0000000000
--- a/apps/computer-vision/components/ErrorBanner.tsx
+++ /dev/null
@@ -1,53 +0,0 @@
-import React from 'react';
-import { View, Text, TouchableOpacity, StyleSheet } from 'react-native';
-
-interface ErrorBannerProps {
-  message: string | null;
-  onDismiss: () => void;
-}
-
-export default function ErrorBanner({ message, onDismiss }: ErrorBannerProps) {
-  if (!message) return null;
-
-  return (
-    <View style={styles.container}>
-      <Text style={styles.message} numberOfLines={3}>
-        {message}
-      </Text>
-      <TouchableOpacity onPress={onDismiss} style={styles.closeButton}>
-        <Text style={styles.closeText}>✕</Text>
-      </TouchableOpacity>
-    </View>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: {
-    backgroundColor: '#FEE2E2',
-    borderLeftWidth: 4,
-    borderLeftColor: '#EF4444',
-    borderRadius: 8,
-    marginHorizontal: 16,
-    marginVertical: 8,
-    paddingVertical: 10,
-    paddingLeft: 12,
-    paddingRight: 8,
-    flexDirection: 'row',
-    alignItems: 'center',
-  },
-  message: {
-    flex: 1,
-    color: '#991B1B',
-    fontSize: 14,
-    lineHeight: 20,
-  },
-  closeButton: {
-    padding: 4,
-    marginLeft: 8,
-  },
-  closeText: {
-    color: '#991B1B',
-    fontSize: 16,
-    fontWeight: '600',
-  },
-});
diff --git a/apps/computer-vision/components/ImageWithBboxes.tsx b/apps/computer-vision/components/ImageWithBboxes.tsx
deleted file mode 100644
index 9b13f314c6..0000000000
--- a/apps/computer-vision/components/ImageWithBboxes.tsx
+++ /dev/null
@@ -1,85 +0,0 @@
-import React from 'react';
-import { Image, StyleSheet, View } from 'react-native';
-import { Detection } from 'react-native-executorch';
-import BoundingBoxes from './BoundingBoxes';
-
-interface Props {
-  imageUri: string;
-  detections: Detection[];
-  imageWidth: number;
-  imageHeight: number;
-}
-
-export default function ImageWithBboxes({
-  imageUri,
-  detections,
-  imageWidth,
-  imageHeight,
-}: Props) {
-  const [layout, setLayout] = React.useState({ width: 0, height: 0 });
-
-  const calculateAdjustedDimensions = () => {
-    const imageRatio = imageWidth / imageHeight;
-    const layoutRatio = layout.width / layout.height;
-
-    let sx, sy;
-    if (imageRatio > layoutRatio) {
-      // image is more "wide"
-      sx = layout.width / imageWidth;
-      sy = layout.width / imageRatio / imageHeight;
-    } else {
-      // image is more "tall"
-      sy = layout.height / imageHeight;
-      sx = (layout.height * imageRatio) / imageWidth;
-    }
-
-    return {
-      scaleX: sx,
-      scaleY: sy,
-      offsetX: (layout.width - imageWidth * sx) / 2,
-      offsetY: (layout.height - imageHeight * sy) / 2,
-    };
-  };
-
-  const { scaleX, scaleY, offsetX, offsetY } = calculateAdjustedDimensions();
-
-  return (
-    <View
-      style={styles.container}
-      onLayout={(event) => {
-        const { width, height } = event.nativeEvent.layout;
-        setLayout({ width, height });
-      }}
-    >
-      <Image
-        style={styles.image}
-        resizeMode="contain"
-        source={
-          imageUri
-            ? { uri: imageUri }
-            : require('../assets/icons/executorch_logo.png')
-        }
-      />
-      <BoundingBoxes
-        detections={detections}
-        scaleX={scaleX}
-        scaleY={scaleY}
-        offsetX={offsetX}
-        offsetY={offsetY}
-        containerWidth={layout.width}
-      />
-    </View>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    position: 'relative',
-  },
-  image: {
-    flex: 1,
-    width: '100%',
-    height: '100%',
-  },
-});
diff --git a/apps/computer-vision/components/ImageWithMasks.tsx b/apps/computer-vision/components/ImageWithMasks.tsx
deleted file mode 100644
index 53f7152100..0000000000
--- a/apps/computer-vision/components/ImageWithMasks.tsx
+++ /dev/null
@@ -1,258 +0,0 @@
-import React, { useState } from 'react';
-import { Image, StyleSheet, View, Text } from 'react-native';
-import {
-  Canvas,
-  Image as SkiaImage,
-  Skia,
-  AlphaType,
-  ColorType,
-  SkImage,
-  Rect,
-  Group,
-} from '@shopify/react-native-skia';
-
-const INSTANCE_COLORS = [
-  [255, 87, 51, 180],
-  [51, 255, 87, 180],
-  [51, 87, 255, 180],
-  [255, 51, 246, 180],
-  [51, 255, 246, 180],
-  [243, 255, 51, 180],
-  [141, 51, 255, 180],
-  [255, 131, 51, 180],
-  [51, 255, 131, 180],
-  [131, 51, 255, 180],
-];
-
-const MAX_MASK_DIM = 256;
-
-/** Display-only data — no raw mask buffers. */
-export interface DisplayInstance {
-  bbox: { x1: number; y1: number; x2: number; y2: number };
-  label: string;
-  score: number;
-  maskImage: SkImage;
-}
-
-/**
- * Convert raw segmentation output into lightweight display instances.
- * Call this eagerly (in the forward callback) so raw Uint8Array masks
- * can be garbage-collected immediately.
- * @param rawInstances - Array of raw segmentation instances with mask buffers to convert.
- * @returns Array of lightweight {@link DisplayInstance} objects with pre-rendered Skia images.
- */
-export function buildDisplayInstances(
-  rawInstances: {
-    bbox: { x1: number; y1: number; x2: number; y2: number };
-    mask: Uint8Array;
-    maskWidth: number;
-    maskHeight: number;
-    label: string | number;
-    score: number;
-  }[]
-): DisplayInstance[] {
-  return rawInstances
-    .map((inst, i) => {
-      const color = INSTANCE_COLORS[i % INSTANCE_COLORS.length];
-      const img = createMaskImage(
-        inst.mask,
-        inst.maskWidth,
-        inst.maskHeight,
-        color
-      );
-      if (!img) return null;
-      return {
-        bbox: inst.bbox,
-        label: String(inst.label),
-        score: inst.score,
-        maskImage: img,
-      };
-    })
-    .filter((d): d is DisplayInstance => d !== null);
-}
-
-function createMaskImage(
-  mask: Uint8Array,
-  srcW: number,
-  srcH: number,
-  color: number[]
-): SkImage | null {
-  const downscale = Math.min(1, MAX_MASK_DIM / Math.max(srcW, srcH));
-  const dstW = Math.max(1, Math.round(srcW * downscale));
-  const dstH = Math.max(1, Math.round(srcH * downscale));
-
-  const pixels = new Uint8Array(dstW * dstH * 4);
-  const r = color[0],
-    g = color[1],
-    b = color[2],
-    a = color[3];
-
-  for (let dy = 0; dy < dstH; dy++) {
-    const sy = Math.min(Math.floor(dy / downscale), srcH - 1);
-    for (let dx = 0; dx < dstW; dx++) {
-      const sx = Math.min(Math.floor(dx / downscale), srcW - 1);
-      if (mask[sy * srcW + sx] > 0) {
-        const idx = (dy * dstW + dx) * 4;
-        pixels[idx] = r;
-        pixels[idx + 1] = g;
-        pixels[idx + 2] = b;
-        pixels[idx + 3] = a;
-      }
-    }
-  }
-
-  const data = Skia.Data.fromBytes(pixels);
-  const image = Skia.Image.MakeImage(
-    {
-      width: dstW,
-      height: dstH,
-      alphaType: AlphaType.Premul,
-      colorType: ColorType.RGBA_8888,
-    },
-    data,
-    dstW * 4
-  );
-  data.dispose();
-  return image;
-}
-
-interface Props {
-  imageUri: string;
-  instances: DisplayInstance[];
-  imageWidth: number;
-  imageHeight: number;
-}
-
-export default function ImageWithMasks({
-  imageUri,
-  instances,
-  imageWidth,
-  imageHeight,
-}: Props) {
-  const [layout, setLayout] = useState({ width: 0, height: 0 });
-
-  const scaleX = layout.width / (imageWidth || 1);
-  const scaleY = layout.height / (imageHeight || 1);
-  const scale = Math.min(scaleX, scaleY);
-  const offsetX = (layout.width - imageWidth * scale) / 2;
-  const offsetY = (layout.height - imageHeight * scale) / 2;
-
-  return (
-    <View
-      style={styles.container}
-      onLayout={(e) => {
-        const { width, height } = e.nativeEvent.layout;
-        setLayout({ width, height });
-      }}
-    >
-      <Image
-        style={styles.image}
-        resizeMode="contain"
-        source={
-          imageUri
-            ? { uri: imageUri }
-            : require('../assets/icons/executorch_logo.png')
-        }
-      />
-
-      {instances.length > 0 && (
-        <View style={styles.overlay} pointerEvents="none">
-          <Canvas style={styles.canvas}>
-            {instances.map((inst, idx) => {
-              const mx = inst.bbox.x1 * scale + offsetX;
-              const my = inst.bbox.y1 * scale + offsetY;
-              const mw = (inst.bbox.x2 - inst.bbox.x1) * scale;
-              const mh = (inst.bbox.y2 - inst.bbox.y1) * scale;
-              return (
-                <SkiaImage
-                  key={`mask-${idx}`}
-                  image={inst.maskImage}
-                  fit="fill"
-                  x={mx}
-                  y={my}
-                  width={mw}
-                  height={mh}
-                />
-              );
-            })}
-
-            {instances.map((inst, idx) => {
-              const color = INSTANCE_COLORS[idx % INSTANCE_COLORS.length];
-              const bboxX = inst.bbox.x1 * scale + offsetX;
-              const bboxY = inst.bbox.y1 * scale + offsetY;
-              const bboxW = (inst.bbox.x2 - inst.bbox.x1) * scale;
-              const bboxH = (inst.bbox.y2 - inst.bbox.y1) * scale;
-
-              return (
-                <Group key={`bbox-${idx}`}>
-                  <Rect
-                    x={bboxX}
-                    y={bboxY}
-                    width={bboxW}
-                    height={bboxH}
-                    style="stroke"
-                    strokeWidth={2}
-                    color={`rgba(${color[0]}, ${color[1]}, ${color[2]}, 1)`}
-                  />
-                </Group>
-              );
-            })}
-          </Canvas>
-
-          {instances.map((inst, idx) => {
-            const color = INSTANCE_COLORS[idx % INSTANCE_COLORS.length];
-            const bboxX = inst.bbox.x1 * scale + offsetX;
-            const bboxY = inst.bbox.y1 * scale + offsetY;
-
-            return (
-              <View
-                key={`label-${idx}`}
-                style={[
-                  styles.labelContainer,
-                  {
-                    left: bboxX,
-                    top: bboxY - 20,
-                    backgroundColor: `rgba(${color[0]}, ${color[1]}, ${color[2]}, 0.9)`,
-                  },
-                ]}
-              >
-                <Text style={styles.labelText}>
-                  {inst.label || 'Unknown'} {(inst.score * 100).toFixed(0)}%
-                </Text>
-              </View>
-            );
-          })}
-        </View>
-      )}
-    </View>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    position: 'relative',
-  },
-  image: {
-    width: '100%',
-    height: '100%',
-  },
-  overlay: {
-    ...StyleSheet.absoluteFill,
-  },
-  canvas: {
-    width: '100%',
-    height: '100%',
-  },
-  labelContainer: {
-    position: 'absolute',
-    paddingHorizontal: 6,
-    paddingVertical: 2,
-    borderRadius: 4,
-  },
-  labelText: {
-    color: 'white',
-    fontSize: 12,
-    fontWeight: '600',
-  },
-});
diff --git a/apps/computer-vision/components/ImageWithOCRBboxes.tsx b/apps/computer-vision/components/ImageWithOCRBboxes.tsx
deleted file mode 100644
index eb1f9acbf6..0000000000
--- a/apps/computer-vision/components/ImageWithOCRBboxes.tsx
+++ /dev/null
@@ -1,104 +0,0 @@
-// Import necessary components
-import React from 'react';
-import { Image, StyleSheet, View } from 'react-native';
-import Svg, { Polygon } from 'react-native-svg';
-import { OCRDetection } from 'react-native-executorch';
-
-interface Props {
-  imageUri: string;
-  detections: OCRDetection[];
-  imageWidth: number;
-  imageHeight: number;
-}
-
-export default function ImageWithOCRBboxes({
-  imageUri,
-  detections,
-  imageWidth,
-  imageHeight,
-}: Props) {
-  const [layout, setLayout] = React.useState({ width: 0, height: 0 });
-
-  const calculateAdjustedDimensions = () => {
-    const imageRatio = imageWidth / imageHeight;
-    const layoutRatio = layout.width / layout.height;
-    let sx, sy;
-    if (imageRatio > layoutRatio) {
-      sx = layout.width / imageWidth;
-      sy = layout.width / imageRatio / imageHeight;
-    } else {
-      sy = layout.height / imageHeight;
-      sx = (layout.height * imageRatio) / imageWidth;
-    }
-    return {
-      scaleX: sx,
-      scaleY: sy,
-      offsetX: (layout.width - imageWidth * sx) / 2,
-      offsetY: (layout.height - imageHeight * sy) / 2,
-    };
-  };
-
-  return (
-    <View
-      style={styles.container}
-      onLayout={(event) => {
-        const { width, height } = event.nativeEvent.layout;
-        setLayout({ width, height });
-      }}
-    >
-      <Image
-        style={styles.image}
-        resizeMode="contain"
-        source={
-          imageUri
-            ? { uri: imageUri }
-            : require('../assets/icons/executorch_logo.png')
-        }
-      />
-      <Svg style={styles.svgContainer}>
-        {detections.map((detection, index) => {
-          const { scaleX, scaleY, offsetX, offsetY } =
-            calculateAdjustedDimensions();
-          const { x1, y1, x2, y2 } = detection.bbox;
-          const pointsString = [
-            [x1, y1],
-            [x2, y1],
-            [x2, y2],
-            [x1, y2],
-          ]
-            .map(([x, y]) => `${x * scaleX + offsetX},${y * scaleY + offsetY}`)
-            .join(' ');
-
-          return (
-            <Polygon
-              key={index}
-              points={pointsString}
-              fill="none"
-              stroke="red"
-              strokeWidth="2"
-            />
-          );
-        })}
-      </Svg>
-    </View>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    position: 'relative',
-  },
-  image: {
-    flex: 1,
-    width: '100%',
-    height: '100%',
-  },
-  svgContainer: {
-    position: 'absolute',
-    top: 0,
-    left: 0,
-    right: 0,
-    bottom: 0,
-  },
-});
diff --git a/apps/computer-vision/components/ModelPicker.tsx b/apps/computer-vision/components/ModelPicker.tsx
deleted file mode 100644
index 94a848596e..0000000000
--- a/apps/computer-vision/components/ModelPicker.tsx
+++ /dev/null
@@ -1,216 +0,0 @@
-import React, { useEffect, useRef, useState } from 'react';
-import {
-  Dimensions,
-  Modal,
-  ScrollView,
-  StyleSheet,
-  Text,
-  TouchableOpacity,
-  View,
-} from 'react-native';
-
-export type ModelOption<T> = {
-  label: string;
-  value: T;
-};
-
-type Props<T> = {
-  models: ModelOption<T>[];
-  selectedModel: T;
-  onSelect: (model: T) => void;
-  label?: string;
-  disabled?: boolean;
-};
-
-const DROPDOWN_MAX_HEIGHT = 200;
-
-export function ModelPicker<T>({
-  models,
-  selectedModel,
-  onSelect,
-  label,
-  disabled,
-}: Props<T>) {
-  const [open, setOpen] = useState(false);
-  const [triggerHeight, setTriggerHeight] = useState(0);
-  const [expandUp, setExpandUp] = useState(false);
-  const [dropdownTop, setDropdownTop] = useState(0);
-  const triggerRef = useRef<React.ComponentRef<typeof TouchableOpacity>>(null);
-  const selected = models.find((m) => m.value === selectedModel);
-
-  useEffect(() => {
-    if (disabled) setOpen(false);
-  }, [disabled]);
-
-  const handlePress = () => {
-    if (disabled) return;
-    if (open) {
-      setOpen(false);
-      return;
-    }
-    triggerRef.current?.measure(
-      (
-        _x: number,
-        _y: number,
-        _width: number,
-        height: number,
-        _pageX: number,
-        pageY: number
-      ) => {
-        setTriggerHeight(height);
-        const spaceBelow = Dimensions.get('window').height - (pageY + height);
-        setExpandUp(spaceBelow < DROPDOWN_MAX_HEIGHT);
-        setDropdownTop(pageY);
-        setOpen(true);
-      }
-    );
-  };
-
-  const dropdownStylePosition = expandUp
-    ? {
-        bottom: Dimensions.get('window').height - dropdownTop,
-        left: 12,
-        right: 12,
-      }
-    : {
-        top: dropdownTop + triggerHeight + 2,
-        left: 12,
-        right: 12,
-      };
-
-  return (
-    <>
-      <View style={styles.container}>
-        <TouchableOpacity
-          ref={triggerRef}
-          style={[styles.trigger, disabled && styles.triggerDisabled]}
-          onPress={handlePress}
-          activeOpacity={disabled ? 1 : 0.7}
-        >
-          {label && <Text style={styles.label}>{label}</Text>}
-          <Text style={styles.triggerText}>{selected?.label ?? '—'}</Text>
-          <Text style={styles.chevron}>{open ? '▲' : '▼'}</Text>
-        </TouchableOpacity>
-      </View>
-
-      {open && (
-        <Modal
-          transparent
-          visible={open}
-          onRequestClose={() => setOpen(false)}
-          animationType="none"
-        >
-          <TouchableOpacity
-            style={styles.modalBackdrop}
-            activeOpacity={1}
-            onPress={() => setOpen(false)}
-          />
-          <View style={[styles.dropdown, dropdownStylePosition]}>
-            <ScrollView
-              nestedScrollEnabled
-              keyboardShouldPersistTaps="handled"
-              showsVerticalScrollIndicator={true}
-            >
-              {models.map((item) => {
-                const isSelected = item.value === selectedModel;
-                return (
-                  <TouchableOpacity
-                    key={item.label}
-                    style={[styles.option, isSelected && styles.optionSelected]}
-                    onPress={() => {
-                      onSelect(item.value);
-                      setOpen(false);
-                    }}
-                    activeOpacity={0.7}
-                  >
-                    <Text
-                      style={[
-                        styles.optionText,
-                        isSelected && styles.optionTextSelected,
-                      ]}
-                    >
-                      {item.label}
-                    </Text>
-                  </TouchableOpacity>
-                );
-              })}
-            </ScrollView>
-          </View>
-        </Modal>
-      )}
-    </>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: {
-    marginHorizontal: 12,
-    marginVertical: 4,
-    alignSelf: 'stretch',
-    zIndex: 100,
-  },
-  trigger: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    borderWidth: 1,
-    borderColor: '#C1C6E5',
-    borderRadius: 8,
-    paddingHorizontal: 12,
-    paddingVertical: 10,
-    backgroundColor: '#f5f5f5',
-  },
-  triggerDisabled: {
-    opacity: 0.4,
-  },
-  label: {
-    fontSize: 12,
-    color: '#888',
-    marginRight: 6,
-  },
-  triggerText: {
-    flex: 1,
-    fontSize: 14,
-    color: '#001A72',
-    fontWeight: '500',
-  },
-  chevron: {
-    fontSize: 10,
-    color: '#888',
-    marginLeft: 6,
-  },
-  modalBackdrop: {
-    flex: 1,
-    backgroundColor: 'rgba(0, 0, 0, 0.3)',
-  },
-  dropdown: {
-    position: 'absolute',
-    borderWidth: 1,
-    borderColor: '#C1C6E5',
-    borderRadius: 8,
-    backgroundColor: '#fff',
-    maxHeight: DROPDOWN_MAX_HEIGHT,
-    zIndex: 1000,
-    elevation: 5,
-    shadowColor: '#000',
-    shadowOffset: { width: 0, height: 4 },
-    shadowOpacity: 0.15,
-    shadowRadius: 6,
-  },
-  option: {
-    paddingHorizontal: 12,
-    paddingVertical: 10,
-    borderBottomWidth: 1,
-    borderBottomColor: '#f0f0f0',
-  },
-  optionSelected: {
-    backgroundColor: '#e8ecf8',
-  },
-  optionText: {
-    fontSize: 14,
-    color: '#333',
-  },
-  optionTextSelected: {
-    color: '#001A72',
-    fontWeight: '600',
-  },
-});
diff --git a/apps/computer-vision/components/ProgressBar.tsx b/apps/computer-vision/components/ProgressBar.tsx
deleted file mode 100644
index fe2850de91..0000000000
--- a/apps/computer-vision/components/ProgressBar.tsx
+++ /dev/null
@@ -1,59 +0,0 @@
-import React from 'react';
-import { View, StyleSheet } from 'react-native';
-import ColorPalette from '../colors';
-
-type ProgressBarProps = {
-  numSteps: number;
-  currentStep: number;
-};
-
-export default function ProgressBar({
-  numSteps,
-  currentStep,
-}: ProgressBarProps) {
-  return (
-    <View style={styles.progressBarContainer}>
-      {Array.from({ length: numSteps }).map((_, i) => (
-        <View
-          key={i}
-          style={[
-            styles.progressStep,
-            i < currentStep
-              ? styles.progressStepActive
-              : styles.progressStepInactive,
-            i === 0 && styles.progressStepFirst,
-            i === numSteps - 1 && styles.progressStepLast,
-          ]}
-        />
-      ))}
-    </View>
-  );
-}
-
-const styles = StyleSheet.create({
-  progressBarContainer: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    justifyContent: 'center',
-    marginVertical: 16,
-    width: '80%',
-  },
-  progressStep: {
-    flex: 1,
-    height: 15,
-  },
-  progressStepActive: {
-    backgroundColor: ColorPalette.primary,
-  },
-  progressStepInactive: {
-    backgroundColor: '#e0e0e0',
-  },
-  progressStepFirst: {
-    borderTopLeftRadius: 8,
-    borderBottomLeftRadius: 8,
-  },
-  progressStepLast: {
-    borderTopRightRadius: 8,
-    borderBottomRightRadius: 8,
-  },
-});
diff --git a/apps/computer-vision/components/Spinner.tsx b/apps/computer-vision/components/Spinner.tsx
deleted file mode 100644
index f436869ab8..0000000000
--- a/apps/computer-vision/components/Spinner.tsx
+++ /dev/null
@@ -1,43 +0,0 @@
-import React from 'react';
-import { View, Text, StyleSheet, ActivityIndicator, Modal } from 'react-native';
-import ColorPalette from '../colors';
-
-interface SpinnerProps {
-  visible: boolean;
-  textContent: string;
-}
-
-const Spinner = ({ visible, textContent }: SpinnerProps) => {
-  return (
-    <Modal transparent={true} animationType="fade" visible={visible}>
-      <View style={styles.overlay}>
-        <View style={styles.container}>
-          <ActivityIndicator size="large" color="#FFFFFF" />
-          <Text style={styles.text}>{textContent}</Text>
-        </View>
-      </View>
-    </Modal>
-  );
-};
-
-const styles = StyleSheet.create({
-  overlay: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-    backgroundColor: 'rgba(0, 0, 0, 0.1)',
-  },
-  container: {
-    padding: 25,
-    alignItems: 'center',
-    justifyContent: 'center',
-  },
-  text: {
-    marginTop: 15,
-    color: ColorPalette.primary,
-    fontSize: 18,
-    fontWeight: 'bold',
-  },
-});
-
-export default Spinner;
diff --git a/apps/computer-vision/components/StatsBar.tsx b/apps/computer-vision/components/StatsBar.tsx
deleted file mode 100644
index 621ecd21d1..0000000000
--- a/apps/computer-vision/components/StatsBar.tsx
+++ /dev/null
@@ -1,44 +0,0 @@
-import React from 'react';
-import { View, Text, StyleSheet } from 'react-native';
-
-interface Props {
-  inferenceTime: number | null;
-  detectionCount?: number | null;
-}
-
-export function StatsBar({ inferenceTime, detectionCount }: Props) {
-  if (inferenceTime === null) return null;
-
-  return (
-    <View style={styles.container}>
-      <Text style={styles.stat}>Inference: {inferenceTime} ms</Text>
-      {detectionCount != null && (
-        <>
-          <Text style={styles.separator}>·</Text>
-          <Text style={styles.stat}>
-            {detectionCount} detection{detectionCount !== 1 ? 's' : ''}
-          </Text>
-        </>
-      )}
-    </View>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: {
-    flexDirection: 'row',
-    justifyContent: 'center',
-    alignItems: 'center',
-    gap: 8,
-    paddingVertical: 6,
-  },
-  stat: {
-    fontSize: 13,
-    color: '#334155',
-    fontWeight: '500',
-  },
-  separator: {
-    fontSize: 13,
-    color: '#94A3B8',
-  },
-});
diff --git a/apps/computer-vision/components/utils/cocoSkeleton.ts b/apps/computer-vision/components/utils/cocoSkeleton.ts
deleted file mode 100644
index 9f1e051ab3..0000000000
--- a/apps/computer-vision/components/utils/cocoSkeleton.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-export const COCO_SKELETON_CONNECTIONS = [
-  ['NOSE', 'LEFT_EYE'],
-  ['NOSE', 'RIGHT_EYE'],
-  ['LEFT_EYE', 'LEFT_EAR'],
-  ['RIGHT_EYE', 'RIGHT_EAR'],
-  ['LEFT_SHOULDER', 'RIGHT_SHOULDER'],
-  ['LEFT_SHOULDER', 'LEFT_ELBOW'],
-  ['LEFT_ELBOW', 'LEFT_WRIST'],
-  ['RIGHT_SHOULDER', 'RIGHT_ELBOW'],
-  ['RIGHT_ELBOW', 'RIGHT_WRIST'],
-  ['LEFT_SHOULDER', 'LEFT_HIP'],
-  ['RIGHT_SHOULDER', 'RIGHT_HIP'],
-  ['LEFT_HIP', 'RIGHT_HIP'],
-  ['LEFT_HIP', 'LEFT_KNEE'],
-  ['LEFT_KNEE', 'LEFT_ANKLE'],
-  ['RIGHT_HIP', 'RIGHT_KNEE'],
-  ['RIGHT_KNEE', 'RIGHT_ANKLE'],
-] as const;
diff --git a/apps/computer-vision/components/utils/colors.ts b/apps/computer-vision/components/utils/colors.ts
deleted file mode 100644
index c38493a3b0..0000000000
--- a/apps/computer-vision/components/utils/colors.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-export const CLASS_COLORS: number[][] = [
-  [0, 0, 0, 0],
-  [51, 255, 87, 180],
-  [51, 87, 255, 180],
-  [255, 51, 246, 180],
-  [51, 255, 246, 180],
-  [243, 255, 51, 180],
-  [141, 51, 255, 180],
-  [255, 131, 51, 180],
-  [51, 255, 131, 180],
-  [131, 51, 255, 180],
-  [255, 255, 51, 180],
-  [51, 255, 255, 180],
-  [255, 51, 143, 180],
-  [127, 51, 255, 180],
-  [51, 255, 175, 180],
-  [255, 175, 51, 180],
-  [179, 255, 51, 180],
-  [255, 87, 51, 180],
-  [255, 51, 162, 180],
-  [51, 162, 255, 180],
-  [162, 51, 255, 180],
-];
-
-export function hashLabel(label: string): number {
-  let hash = 5381;
-  for (let i = 0; i < label.length; i++) {
-    hash = (hash + hash * 32 + label.charCodeAt(i)) % 1000003;
-  }
-  return 1 + (Math.abs(hash) % (CLASS_COLORS.length - 1));
-}
-
-export function labelColor(label: string): string {
-  const color = CLASS_COLORS[hashLabel(label)]!;
-  return `rgba(${color[0]},${color[1]},${color[2]},1)`;
-}
-
-export function labelColorBg(label: string): string {
-  const color = CLASS_COLORS[hashLabel(label)]!;
-  return `rgba(${color[0]},${color[1]},${color[2]},0.75)`;
-}
diff --git a/apps/computer-vision/components/vision_camera/tasks/ClassificationTask.tsx b/apps/computer-vision/components/vision_camera/tasks/ClassificationTask.tsx
deleted file mode 100644
index f108bb4aa5..0000000000
--- a/apps/computer-vision/components/vision_camera/tasks/ClassificationTask.tsx
+++ /dev/null
@@ -1,132 +0,0 @@
-import React, { useCallback, useEffect, useRef, useState } from 'react';
-import { StyleSheet, Text, View } from 'react-native';
-import { Frame, useFrameOutput } from 'react-native-vision-camera';
-import { scheduleOnRN } from 'react-native-worklets';
-import { models, useClassification } from 'react-native-executorch';
-import { FRAME_TARGET_RESOLUTION, TaskProps } from './types';
-
-type Props = Omit<
-  TaskProps,
-  'activeModel' | 'canvasSize' | 'cameraPositionSync'
->;
-
-export default function ClassificationTask({
-  frameKillSwitch,
-  onFrameOutputChange,
-  onReadyChange,
-  onProgressChange,
-  onGeneratingChange,
-  onFpsChange,
-  onErrorChange,
-}: Props) {
-  const model = useClassification({
-    model: models.classification.efficientnet_v2_s(),
-  });
-  const [classResult, setClassResult] = useState({ label: '', score: 0 });
-  const lastFrameTimeRef = useRef(Date.now());
-
-  useEffect(() => {
-    onErrorChange(model.error ? String(model.error) : null);
-  }, [model.error, onErrorChange]);
-
-  useEffect(() => {
-    onReadyChange(model.isReady);
-  }, [model.isReady, onReadyChange]);
-
-  useEffect(() => {
-    onProgressChange(model.downloadProgress);
-  }, [model.downloadProgress, onProgressChange]);
-
-  useEffect(() => {
-    onGeneratingChange(model.isGenerating);
-  }, [model.isGenerating, onGeneratingChange]);
-
-  const classRof = model.runOnFrame;
-
-  const updateClass = useCallback(
-    (r: { label: string; score: number }) => {
-      setClassResult(r);
-      const now = Date.now();
-      const diff = now - lastFrameTimeRef.current;
-      if (diff > 0) onFpsChange(Math.round(1000 / diff), diff);
-      lastFrameTimeRef.current = now;
-    },
-    [onFpsChange]
-  );
-
-  const frameOutput = useFrameOutput({
-    targetResolution: FRAME_TARGET_RESOLUTION,
-    pixelFormat: 'rgb',
-    dropFramesWhileBusy: true,
-    enablePreviewSizedOutputBuffers: true,
-    onFrame: useCallback(
-      (frame: Frame) => {
-        'worklet';
-        if (frameKillSwitch.getDirty()) {
-          frame.dispose();
-          return;
-        }
-        try {
-          if (!classRof) return;
-          const result = classRof(frame);
-          if (result) {
-            let bestLabel = '';
-            let bestScore = -1;
-            const entries = Object.entries(result);
-            for (let i = 0; i < entries.length; i++) {
-              const [label, score] = entries[i]!;
-              if ((score as number) > bestScore) {
-                bestScore = score as number;
-                bestLabel = label;
-              }
-            }
-            scheduleOnRN(updateClass, { label: bestLabel, score: bestScore });
-          }
-        } catch {
-          // Frame may be disposed before processing completes — transient, safe to ignore.
-        } finally {
-          frame.dispose();
-        }
-      },
-      [classRof, frameKillSwitch, updateClass]
-    ),
-  });
-
-  useEffect(() => {
-    onFrameOutputChange(frameOutput);
-  }, [frameOutput, onFrameOutputChange]);
-
-  return classResult.label ? (
-    <View style={styles.overlay} pointerEvents="none">
-      <Text style={styles.label}>{classResult.label}</Text>
-      <Text style={styles.score}>{(classResult.score * 100).toFixed(1)}%</Text>
-    </View>
-  ) : null;
-}
-
-const styles = StyleSheet.create({
-  overlay: {
-    ...StyleSheet.absoluteFill,
-    justifyContent: 'center',
-    alignItems: 'center',
-  },
-  label: {
-    color: 'white',
-    fontSize: 28,
-    fontWeight: '700',
-    textAlign: 'center',
-    textShadowColor: 'rgba(0,0,0,0.8)',
-    textShadowOffset: { width: 0, height: 1 },
-    textShadowRadius: 6,
-    paddingHorizontal: 24,
-  },
-  score: {
-    color: 'rgba(255,255,255,0.75)',
-    fontSize: 18,
-    fontWeight: '500',
-    marginTop: 4,
-    textShadowColor: 'rgba(0,0,0,0.8)',
-    textShadowOffset: { width: 0, height: 1 },
-    textShadowRadius: 6,
-  },
-});
diff --git a/apps/computer-vision/components/vision_camera/tasks/InstanceSegmentationTask.tsx b/apps/computer-vision/components/vision_camera/tasks/InstanceSegmentationTask.tsx
deleted file mode 100644
index cd203eeb66..0000000000
--- a/apps/computer-vision/components/vision_camera/tasks/InstanceSegmentationTask.tsx
+++ /dev/null
@@ -1,253 +0,0 @@
-import React, { useCallback, useEffect, useRef, useState } from 'react';
-import { StyleSheet, Text, View } from 'react-native';
-import { Frame, useFrameOutput } from 'react-native-vision-camera';
-import { scheduleOnRN } from 'react-native-worklets';
-import {
-  models,
-  SegmentedInstance,
-  useInstanceSegmentation,
-  CocoLabel,
-  CocoLabelYolo,
-  FastSAMLabel,
-} from 'react-native-executorch';
-import { Canvas, Image as SkiaImage } from '@shopify/react-native-skia';
-import { labelColor, labelColorBg } from '../../utils/colors';
-import { FRAME_TARGET_RESOLUTION, TaskProps } from './types';
-import {
-  buildDisplayInstances,
-  DisplayInstance,
-} from '../../../components/ImageWithMasks';
-const instanceSegmentation = models.instance_segmentation;
-
-type InstSegModelId =
-  | 'instanceSegmentationYolo26n'
-  | 'instanceSegmentationRfdetr'
-  | 'instanceSegmentationFastsamS'
-  | 'instanceSegmentationFastsamX';
-
-type Props = TaskProps & { activeModel: InstSegModelId };
-
-export default function InstanceSegmentationTask({
-  activeModel,
-  canvasSize,
-  cameraPositionSync,
-  frameKillSwitch,
-  onFrameOutputChange,
-  onReadyChange,
-  onProgressChange,
-  onGeneratingChange,
-  onFpsChange,
-  onErrorChange,
-}: Props) {
-  const yolo26n = useInstanceSegmentation({
-    model: instanceSegmentation.yolo26n(),
-    preventLoad: activeModel !== 'instanceSegmentationYolo26n',
-  });
-  const rfdetr = useInstanceSegmentation({
-    model: instanceSegmentation.rf_detr_nano(),
-    preventLoad: activeModel !== 'instanceSegmentationRfdetr',
-  });
-  const fastsamS = useInstanceSegmentation({
-    model: instanceSegmentation.fastsam_s(),
-    preventLoad: activeModel !== 'instanceSegmentationFastsamS',
-  });
-  const fastsamX = useInstanceSegmentation({
-    model: instanceSegmentation.fastsam_x(),
-    preventLoad: activeModel !== 'instanceSegmentationFastsamX',
-  });
-
-  const active = {
-    instanceSegmentationYolo26n: yolo26n,
-    instanceSegmentationRfdetr: rfdetr,
-    instanceSegmentationFastsamS: fastsamS,
-    instanceSegmentationFastsamX: fastsamX,
-  }[activeModel];
-
-  const [instances, setInstances] = useState<DisplayInstance[]>([]);
-  const [imageSize, setImageSize] = useState({ width: 1, height: 1 });
-  const lastFrameTimeRef = useRef(Date.now());
-
-  useEffect(() => {
-    onErrorChange(active.error ? String(active.error) : null);
-  }, [active.error, onErrorChange]);
-
-  useEffect(() => {
-    onReadyChange(active.isReady);
-  }, [active.isReady, onReadyChange]);
-
-  useEffect(() => {
-    onProgressChange(active.downloadProgress);
-  }, [active.downloadProgress, onProgressChange]);
-
-  useEffect(() => {
-    onGeneratingChange(active.isGenerating);
-  }, [active.isGenerating, onGeneratingChange]);
-
-  const instSegRof = active.runOnFrame;
-
-  const updateInstances = useCallback(
-    (p: {
-      results:
-        | SegmentedInstance<typeof CocoLabel>[]
-        | SegmentedInstance<typeof CocoLabelYolo>[]
-        | SegmentedInstance<typeof FastSAMLabel>[];
-      imageWidth: number;
-      imageHeight: number;
-    }) => {
-      const displayInstances = buildDisplayInstances(
-        p.results.map((inst) => ({
-          ...inst,
-          label: String(inst.label),
-        }))
-      );
-      setInstances((prev) => {
-        // Dispose old mask images
-        prev.forEach((inst) => inst.maskImage.dispose());
-        return displayInstances;
-      });
-      setImageSize({ width: p.imageWidth, height: p.imageHeight });
-      const now = Date.now();
-      const diff = now - lastFrameTimeRef.current;
-      if (diff > 0) onFpsChange(Math.round(1000 / diff), diff);
-      lastFrameTimeRef.current = now;
-    },
-    [onFpsChange]
-  );
-
-  const frameOutput = useFrameOutput({
-    targetResolution: FRAME_TARGET_RESOLUTION,
-    pixelFormat: 'rgb',
-    dropFramesWhileBusy: true,
-    enablePreviewSizedOutputBuffers: true,
-    onFrame: useCallback(
-      (frame: Frame) => {
-        'worklet';
-        if (frameKillSwitch.getDirty()) {
-          frame.dispose();
-          return;
-        }
-        try {
-          if (!instSegRof) return;
-          const isFrontCamera = cameraPositionSync.getDirty() === 'front';
-          const iw = frame.width > frame.height ? frame.height : frame.width;
-          const ih = frame.width > frame.height ? frame.width : frame.height;
-          const result = instSegRof(frame, isFrontCamera, {
-            confidenceThreshold: 0.5,
-            iouThreshold: 0.5,
-            maxInstances: 5,
-            returnMaskAtOriginalResolution: false,
-            ...(activeModel === 'instanceSegmentationYolo26n' && {
-              inputSize: 384,
-            }),
-          });
-          if (result) {
-            scheduleOnRN(updateInstances, {
-              results: result,
-              imageWidth: iw,
-              imageHeight: ih,
-            });
-          }
-        } catch {
-          // ignore
-        } finally {
-          frame.dispose();
-        }
-      },
-      [
-        instSegRof,
-        frameKillSwitch,
-        updateInstances,
-        activeModel,
-        cameraPositionSync,
-      ]
-    ),
-  });
-
-  useEffect(() => {
-    onFrameOutputChange(frameOutput);
-  }, [frameOutput, onFrameOutputChange]);
-
-  const scale = Math.max(
-    canvasSize.width / imageSize.width,
-    canvasSize.height / imageSize.height
-  );
-  const offsetX = (canvasSize.width - imageSize.width * scale) / 2;
-  const offsetY = (canvasSize.height - imageSize.height * scale) / 2;
-
-  return (
-    <View style={StyleSheet.absoluteFill} pointerEvents="none">
-      {/* Render masks */}
-      <Canvas style={StyleSheet.absoluteFill} pointerEvents="none">
-        {instances.map((inst, i) => {
-          const x = inst.bbox.x1 * scale + offsetX;
-          const y = inst.bbox.y1 * scale + offsetY;
-          const w = (inst.bbox.x2 - inst.bbox.x1) * scale;
-          const h = (inst.bbox.y2 - inst.bbox.y1) * scale;
-          return (
-            <SkiaImage
-              key={`mask-${i}`}
-              image={inst.maskImage}
-              x={x}
-              y={y}
-              width={w}
-              height={h}
-              fit="fill"
-            />
-          );
-        })}
-      </Canvas>
-      {/* Render bounding boxes */}
-      {instances.map((inst, i) => {
-        const left = inst.bbox.x1 * scale + offsetX;
-        const top = inst.bbox.y1 * scale + offsetY;
-        const w = (inst.bbox.x2 - inst.bbox.x1) * scale;
-        const h = (inst.bbox.y2 - inst.bbox.y1) * scale;
-        const label = String(inst.label);
-        return (
-          <View
-            key={i}
-            style={[
-              styles.bbox,
-              {
-                left,
-                top,
-                width: w,
-                height: h,
-                borderColor: labelColor(label),
-              },
-            ]}
-          >
-            <View
-              style={[
-                styles.bboxLabel,
-                { backgroundColor: labelColorBg(label) },
-              ]}
-            >
-              <Text style={styles.bboxLabelText}>
-                {label} {(inst.score * 100).toFixed(1)}
-              </Text>
-            </View>
-          </View>
-        );
-      })}
-    </View>
-  );
-}
-
-const styles = StyleSheet.create({
-  bbox: {
-    position: 'absolute',
-    borderWidth: 2,
-    borderColor: 'cyan',
-    borderRadius: 4,
-  },
-  bboxLabel: {
-    position: 'absolute',
-    top: -22,
-    left: -2,
-    paddingHorizontal: 6,
-    paddingVertical: 2,
-    borderRadius: 4,
-  },
-  bboxLabelText: { color: 'white', fontSize: 11, fontWeight: '600' },
-});
diff --git a/apps/computer-vision/components/vision_camera/tasks/OCRTask.tsx b/apps/computer-vision/components/vision_camera/tasks/OCRTask.tsx
deleted file mode 100644
index 54e73161a1..0000000000
--- a/apps/computer-vision/components/vision_camera/tasks/OCRTask.tsx
+++ /dev/null
@@ -1,142 +0,0 @@
-import React, { useCallback, useEffect, useRef, useState } from 'react';
-import { StyleSheet, View } from 'react-native';
-import { Frame, useFrameOutput } from 'react-native-vision-camera';
-import { scheduleOnRN } from 'react-native-worklets';
-import { models, OCRDetection, useOCR } from 'react-native-executorch';
-import Svg, { Polygon, Text as SvgText } from 'react-native-svg';
-import { FRAME_TARGET_RESOLUTION, TaskProps } from './types';
-
-type Props = Omit<TaskProps, 'activeModel'>;
-
-export default function OCRTask({
-  canvasSize,
-  cameraPositionSync,
-  frameKillSwitch,
-  onFrameOutputChange,
-  onReadyChange,
-  onProgressChange,
-  onGeneratingChange,
-  onFpsChange,
-  onErrorChange,
-}: Props) {
-  const model = useOCR({ model: models.ocr.craft({ language: 'en' }) });
-  const [detections, setDetections] = useState<OCRDetection[]>([]);
-  const [imageSize, setImageSize] = useState({ width: 1, height: 1 });
-  const lastFrameTimeRef = useRef(Date.now());
-
-  useEffect(() => {
-    onErrorChange(model.error ? String(model.error) : null);
-  }, [model.error, onErrorChange]);
-
-  useEffect(() => {
-    onReadyChange(model.isReady);
-  }, [model.isReady, onReadyChange]);
-
-  useEffect(() => {
-    onProgressChange(model.downloadProgress);
-  }, [model.downloadProgress, onProgressChange]);
-
-  useEffect(() => {
-    onGeneratingChange(model.isGenerating);
-  }, [model.isGenerating, onGeneratingChange]);
-
-  const ocrRof = model.runOnFrame;
-
-  const updateDetections = useCallback(
-    (p: { results: OCRDetection[]; frameW: number; frameH: number }) => {
-      setDetections(p.results);
-      setImageSize({ width: p.frameW, height: p.frameH });
-      const now = Date.now();
-      const diff = now - lastFrameTimeRef.current;
-      if (diff > 0) onFpsChange(Math.round(1000 / diff), diff);
-      lastFrameTimeRef.current = now;
-    },
-    [onFpsChange]
-  );
-
-  const frameOutput = useFrameOutput({
-    targetResolution: FRAME_TARGET_RESOLUTION,
-    pixelFormat: 'rgb',
-    dropFramesWhileBusy: true,
-    enablePreviewSizedOutputBuffers: true,
-    onFrame: useCallback(
-      (frame: Frame) => {
-        'worklet';
-        if (frameKillSwitch.getDirty()) {
-          frame.dispose();
-          return;
-        }
-        try {
-          if (!ocrRof) return;
-          const isFrontCamera = cameraPositionSync.getDirty() === 'front';
-          const result = ocrRof(frame, isFrontCamera);
-          if (result) {
-            // Sensor frames are landscape-native, so width/height are swapped
-            // relative to portrait screen orientation.
-            scheduleOnRN(updateDetections, {
-              results: result,
-              frameW: frame.height,
-              frameH: frame.width,
-            });
-          }
-        } catch {
-          // Frame may be disposed before processing completes — transient, safe to ignore.
-        } finally {
-          frame.dispose();
-        }
-      },
-      [cameraPositionSync, frameKillSwitch, ocrRof, updateDetections]
-    ),
-  });
-
-  useEffect(() => {
-    onFrameOutputChange(frameOutput);
-  }, [frameOutput, onFrameOutputChange]);
-
-  const scale = Math.max(
-    canvasSize.width / imageSize.width,
-    canvasSize.height / imageSize.height
-  );
-  const offsetX = (canvasSize.width - imageSize.width * scale) / 2;
-  const offsetY = (canvasSize.height - imageSize.height * scale) / 2;
-
-  if (!detections.length) return null;
-
-  return (
-    <View style={StyleSheet.absoluteFill} pointerEvents="none">
-      <Svg
-        width={canvasSize.width}
-        height={canvasSize.height}
-        style={StyleSheet.absoluteFill}
-      >
-        {detections.map((det, i) => {
-          const { x1, y1, x2, y2 } = det.bbox;
-          const pts = [
-            [x1, y1],
-            [x2, y1],
-            [x2, y2],
-            [x1, y2],
-          ]
-            .map(([x, y]) => `${x * scale + offsetX},${y * scale + offsetY}`)
-            .join(' ');
-          const labelX = x1 * scale + offsetX;
-          const labelY = y1 * scale + offsetY - 4;
-          return (
-            <React.Fragment key={i}>
-              <Polygon points={pts} fill="none" stroke="cyan" strokeWidth={2} />
-              <SvgText
-                x={labelX}
-                y={labelY}
-                fill="white"
-                fontSize={12}
-                fontWeight="bold"
-              >
-                {det.text}
-              </SvgText>
-            </React.Fragment>
-          );
-        })}
-      </Svg>
-    </View>
-  );
-}
diff --git a/apps/computer-vision/components/vision_camera/tasks/ObjectDetectionTask.tsx b/apps/computer-vision/components/vision_camera/tasks/ObjectDetectionTask.tsx
deleted file mode 100644
index e05de26105..0000000000
--- a/apps/computer-vision/components/vision_camera/tasks/ObjectDetectionTask.tsx
+++ /dev/null
@@ -1,165 +0,0 @@
-import React, { useCallback, useEffect, useRef, useState } from 'react';
-import { StyleSheet, View } from 'react-native';
-import { Frame, useFrameOutput } from 'react-native-vision-camera';
-import { scheduleOnRN } from 'react-native-worklets';
-import {
-  models,
-  Detection,
-  useObjectDetection,
-  CocoLabel,
-  CocoLabelYolo,
-} from 'react-native-executorch';
-import BoundingBoxes from '../../BoundingBoxes';
-import { FRAME_TARGET_RESOLUTION, TaskProps } from './types';
-const objectDetection = models.object_detection;
-
-type ObjModelId =
-  | 'objectDetectionSsdlite'
-  | 'objectDetectionRfdetr'
-  | 'objectDetectionYolo26n';
-
-type Props = TaskProps & { activeModel: ObjModelId };
-
-export default function ObjectDetectionTask({
-  activeModel,
-  canvasSize,
-  cameraPositionSync,
-  frameKillSwitch,
-  onFrameOutputChange,
-  onReadyChange,
-  onProgressChange,
-  onGeneratingChange,
-  onFpsChange,
-  onErrorChange,
-}: Props) {
-  const ssdlite = useObjectDetection({
-    model: objectDetection.ssdlite_320_mobilenet_v3_large(),
-    preventLoad: activeModel !== 'objectDetectionSsdlite',
-  });
-  const rfdetr = useObjectDetection({
-    model: objectDetection.rf_detr_nano(),
-    preventLoad: activeModel !== 'objectDetectionRfdetr',
-  });
-  const yolo26n = useObjectDetection({
-    model: objectDetection.yolo26n(),
-    preventLoad: activeModel !== 'objectDetectionYolo26n',
-  });
-
-  const active =
-    activeModel === 'objectDetectionSsdlite'
-      ? ssdlite
-      : activeModel === 'objectDetectionRfdetr'
-        ? rfdetr
-        : yolo26n;
-
-  type CommonDetection = Omit<Detection, 'label'> & { label: string };
-
-  const [detections, setDetections] = useState<CommonDetection[]>([]);
-  const [imageSize, setImageSize] = useState({ width: 1, height: 1 });
-  const lastFrameTimeRef = useRef(Date.now());
-
-  useEffect(() => {
-    onErrorChange(active.error ? String(active.error) : null);
-  }, [active.error, onErrorChange]);
-
-  useEffect(() => {
-    onReadyChange(active.isReady);
-  }, [active.isReady, onReadyChange]);
-
-  useEffect(() => {
-    onProgressChange(active.downloadProgress);
-  }, [active.downloadProgress, onProgressChange]);
-
-  useEffect(() => {
-    onGeneratingChange(active.isGenerating);
-  }, [active.isGenerating, onGeneratingChange]);
-
-  const detRof = active.runOnFrame;
-
-  const updateDetections = useCallback(
-    (p: {
-      results:
-        | Detection<typeof CocoLabel>[]
-        | Detection<typeof CocoLabelYolo>[];
-      imageWidth: number;
-      imageHeight: number;
-    }) => {
-      setDetections(
-        p.results.map((det) => ({
-          ...det,
-          label: String(det.label),
-        }))
-      );
-      setImageSize({ width: p.imageWidth, height: p.imageHeight });
-      const now = Date.now();
-      const diff = now - lastFrameTimeRef.current;
-      if (diff > 0) onFpsChange(Math.round(1000 / diff), diff);
-      lastFrameTimeRef.current = now;
-    },
-    [onFpsChange]
-  );
-
-  const frameOutput = useFrameOutput({
-    targetResolution: FRAME_TARGET_RESOLUTION,
-    pixelFormat: 'rgb',
-    dropFramesWhileBusy: true,
-    enablePreviewSizedOutputBuffers: true,
-
-    onFrame: useCallback(
-      (frame: Frame) => {
-        'worklet';
-        if (frameKillSwitch.getDirty()) {
-          frame.dispose();
-          return;
-        }
-        try {
-          if (!detRof) return;
-          const isFrontCamera = cameraPositionSync.getDirty() === 'front';
-          const result = detRof(frame, isFrontCamera, {
-            detectionThreshold: 0.5,
-          });
-          // Sensor frames are landscape-native, so width/height are swapped
-          // relative to portrait screen orientation.
-          const screenW = frame.height;
-          const screenH = frame.width;
-          if (result) {
-            scheduleOnRN(updateDetections, {
-              results: result,
-              imageWidth: screenW,
-              imageHeight: screenH,
-            });
-          }
-        } catch {
-          // Frame may be disposed before processing completes — transient, safe to ignore.
-        } finally {
-          frame.dispose();
-        }
-      },
-      [cameraPositionSync, detRof, frameKillSwitch, updateDetections]
-    ),
-  });
-
-  useEffect(() => {
-    onFrameOutputChange(frameOutput);
-  }, [frameOutput, onFrameOutputChange]);
-
-  const scale = Math.max(
-    canvasSize.width / imageSize.width,
-    canvasSize.height / imageSize.height
-  );
-  const offsetX = (canvasSize.width - imageSize.width * scale) / 2;
-  const offsetY = (canvasSize.height - imageSize.height * scale) / 2;
-
-  return (
-    <View style={[StyleSheet.absoluteFill]} pointerEvents="none">
-      <BoundingBoxes
-        detections={detections}
-        scaleX={scale}
-        scaleY={scale}
-        offsetX={offsetX}
-        offsetY={offsetY}
-        containerWidth={canvasSize.width}
-      />
-    </View>
-  );
-}
diff --git a/apps/computer-vision/components/vision_camera/tasks/PoseEstimationTask.tsx b/apps/computer-vision/components/vision_camera/tasks/PoseEstimationTask.tsx
deleted file mode 100644
index a357881da0..0000000000
--- a/apps/computer-vision/components/vision_camera/tasks/PoseEstimationTask.tsx
+++ /dev/null
@@ -1,178 +0,0 @@
-import React, { useCallback, useEffect, useRef, useState } from 'react';
-import { StyleSheet, View } from 'react-native';
-import { Frame, useFrameOutput } from 'react-native-vision-camera';
-import { scheduleOnRN } from 'react-native-worklets';
-import Svg, { Circle, Line } from 'react-native-svg';
-import {
-  models,
-  usePoseEstimation,
-  PoseDetections,
-} from 'react-native-executorch';
-import { TaskProps } from './types';
-import { COCO_SKELETON_CONNECTIONS } from '../../utils/cocoSkeleton';
-
-type Props = TaskProps & { activeModel: 'poseEstimationYolo26n' };
-
-// Colors for different people
-const PERSON_COLORS = ['lime', 'cyan', 'magenta', 'yellow', 'orange', 'pink'];
-
-export default function PoseEstimationTask({
-  activeModel,
-  canvasSize,
-  cameraPositionSync,
-  frameKillSwitch,
-  onFrameOutputChange,
-  onReadyChange,
-  onProgressChange,
-  onGeneratingChange,
-  onFpsChange,
-  onErrorChange,
-}: Props) {
-  const poseModel = usePoseEstimation({
-    model: models.pose_estimation.yolo26n(),
-    preventLoad: activeModel !== 'poseEstimationYolo26n',
-  });
-
-  const [detections, setDetections] = useState<PoseDetections>([]);
-  const [imageSize, setImageSize] = useState({ width: 1, height: 1 });
-  const lastFrameTimeRef = useRef(Date.now());
-
-  useEffect(() => {
-    onErrorChange(poseModel.error ? String(poseModel.error) : null);
-  }, [poseModel.error, onErrorChange]);
-
-  useEffect(() => {
-    onReadyChange(poseModel.isReady);
-  }, [poseModel.isReady, onReadyChange]);
-
-  useEffect(() => {
-    onProgressChange(poseModel.downloadProgress);
-  }, [poseModel.downloadProgress, onProgressChange]);
-
-  useEffect(() => {
-    onGeneratingChange(poseModel.isGenerating);
-  }, [poseModel.isGenerating, onGeneratingChange]);
-
-  const poseRof = poseModel.runOnFrame;
-
-  const updateDetections = useCallback(
-    (p: {
-      results: PoseDetections;
-      imageWidth: number;
-      imageHeight: number;
-    }) => {
-      setDetections(p.results);
-      setImageSize({ width: p.imageWidth, height: p.imageHeight });
-      const now = Date.now();
-      const diff = now - lastFrameTimeRef.current;
-      if (diff > 0) onFpsChange(Math.round(1000 / diff), diff);
-      lastFrameTimeRef.current = now;
-    },
-    [onFpsChange]
-  );
-
-  const frameOutput = useFrameOutput({
-    pixelFormat: 'rgb',
-    dropFramesWhileBusy: true,
-    enablePreviewSizedOutputBuffers: true,
-
-    onFrame: useCallback(
-      (frame: Frame) => {
-        'worklet';
-        if (frameKillSwitch.getDirty()) {
-          frame.dispose();
-          return;
-        }
-        try {
-          if (!poseRof) return;
-          const isFrontCamera = cameraPositionSync.getDirty() === 'front';
-          const result = poseRof(frame, isFrontCamera, {
-            detectionThreshold: 0.5,
-          });
-          const screenW = frame.height;
-          const screenH = frame.width;
-          if (result) {
-            scheduleOnRN(updateDetections, {
-              results: result,
-              imageWidth: screenW,
-              imageHeight: screenH,
-            });
-          }
-        } catch {
-          // Frame may be disposed before processing completes
-        } finally {
-          frame.dispose();
-        }
-      },
-      [cameraPositionSync, poseRof, frameKillSwitch, updateDetections]
-    ),
-  });
-
-  useEffect(() => {
-    onFrameOutputChange(frameOutput);
-  }, [frameOutput, onFrameOutputChange]);
-
-  const scale = Math.max(
-    canvasSize.width / imageSize.width,
-    canvasSize.height / imageSize.height
-  );
-  const offsetX = (canvasSize.width - imageSize.width * scale) / 2;
-  const offsetY = (canvasSize.height - imageSize.height * scale) / 2;
-
-  return (
-    <View style={StyleSheet.absoluteFill} pointerEvents="none">
-      <Svg style={StyleSheet.absoluteFill}>
-        {detections.map((personKeypoints, personIdx) => {
-          const color = PERSON_COLORS[personIdx % PERSON_COLORS.length];
-          const isVisible = (kp: { x: number; y: number }) =>
-            kp.x >= 0 &&
-            kp.y >= 0 &&
-            kp.x <= imageSize.width &&
-            kp.y <= imageSize.height;
-          return (
-            <React.Fragment key={`person-${personIdx}`}>
-              {/* Draw skeleton lines */}
-              {COCO_SKELETON_CONNECTIONS.map(([from, to], lineIdx) => {
-                const kp1 = personKeypoints[from];
-                const kp2 = personKeypoints[to];
-                if (!kp1 || !kp2) return null;
-                if (!isVisible(kp1) || !isVisible(kp2)) return null;
-                const x1 = kp1.x * scale + offsetX;
-                const y1 = kp1.y * scale + offsetY;
-                const x2 = kp2.x * scale + offsetX;
-                const y2 = kp2.y * scale + offsetY;
-                return (
-                  <Line
-                    key={`person-${personIdx}-line-${lineIdx}`}
-                    x1={x1}
-                    y1={y1}
-                    x2={x2}
-                    y2={y2}
-                    stroke={color}
-                    strokeWidth={3}
-                  />
-                );
-              })}
-              {/* Draw keypoints */}
-              {Object.entries(personKeypoints)
-                .filter(([, kp]) => isVisible(kp))
-                .map(([name, kp]) => {
-                  const cx = kp.x * scale + offsetX;
-                  const cy = kp.y * scale + offsetY;
-                  return (
-                    <Circle
-                      key={`person-${personIdx}-kp-${name}`}
-                      cx={cx}
-                      cy={cy}
-                      r={5}
-                      fill="red"
-                    />
-                  );
-                })}
-            </React.Fragment>
-          );
-        })}
-      </Svg>
-    </View>
-  );
-}
diff --git a/apps/computer-vision/components/vision_camera/tasks/SegmentationTask.tsx b/apps/computer-vision/components/vision_camera/tasks/SegmentationTask.tsx
deleted file mode 100644
index 8c499d977a..0000000000
--- a/apps/computer-vision/components/vision_camera/tasks/SegmentationTask.tsx
+++ /dev/null
@@ -1,238 +0,0 @@
-import React, { useCallback, useEffect, useRef, useState } from 'react';
-import { StyleSheet, View } from 'react-native';
-import { Frame, useFrameOutput } from 'react-native-vision-camera';
-import { scheduleOnRN } from 'react-native-worklets';
-import { models, useSemanticSegmentation } from 'react-native-executorch';
-import {
-  AlphaType,
-  Canvas,
-  ColorType,
-  Image as SkiaImage,
-  Skia,
-  SkImage,
-} from '@shopify/react-native-skia';
-import { CLASS_COLORS } from '../../utils/colors';
-import { FRAME_TARGET_RESOLUTION, TaskProps } from './types';
-const semanticSegmentation = models.semantic_segmentation;
-
-type SegModelId =
-  | 'segmentationDeeplabResnet50'
-  | 'segmentationDeeplabResnet101'
-  | 'segmentationDeeplabMobilenet'
-  | 'segmentationLraspp'
-  | 'segmentationFcnResnet50'
-  | 'segmentationFcnResnet101'
-  | 'segmentationSelfie';
-
-type Props = TaskProps & { activeModel: SegModelId };
-
-export default function SegmentationTask({
-  activeModel,
-  canvasSize,
-  cameraPositionSync,
-  frameKillSwitch,
-  onFrameOutputChange,
-  onReadyChange,
-  onProgressChange,
-  onGeneratingChange,
-  onFpsChange,
-  onErrorChange,
-}: Props) {
-  const segDeeplabResnet50 = useSemanticSegmentation({
-    model: semanticSegmentation.deeplab_v3_resnet50(),
-    preventLoad: activeModel !== 'segmentationDeeplabResnet50',
-  });
-  const segDeeplabResnet101 = useSemanticSegmentation({
-    model: semanticSegmentation.deeplab_v3_resnet101(),
-    preventLoad: activeModel !== 'segmentationDeeplabResnet101',
-  });
-  const segDeeplabMobilenet = useSemanticSegmentation({
-    model: semanticSegmentation.deeplab_v3_mobilenet_v3_large(),
-    preventLoad: activeModel !== 'segmentationDeeplabMobilenet',
-  });
-  const segLraspp = useSemanticSegmentation({
-    model: semanticSegmentation.lraspp_mobilenet_v3_large(),
-    preventLoad: activeModel !== 'segmentationLraspp',
-  });
-  const segFcnResnet50 = useSemanticSegmentation({
-    model: semanticSegmentation.fcn_resnet50(),
-    preventLoad: activeModel !== 'segmentationFcnResnet50',
-  });
-  const segFcnResnet101 = useSemanticSegmentation({
-    model: semanticSegmentation.fcn_resnet101(),
-    preventLoad: activeModel !== 'segmentationFcnResnet101',
-  });
-  const segSelfie = useSemanticSegmentation({
-    model: semanticSegmentation.selfie_segmentation(),
-    preventLoad: activeModel !== 'segmentationSelfie',
-  });
-
-  const active = {
-    segmentationDeeplabResnet50: segDeeplabResnet50,
-    segmentationDeeplabResnet101: segDeeplabResnet101,
-    segmentationDeeplabMobilenet: segDeeplabMobilenet,
-    segmentationLraspp: segLraspp,
-    segmentationFcnResnet50: segFcnResnet50,
-    segmentationFcnResnet101: segFcnResnet101,
-    segmentationSelfie: segSelfie,
-  }[activeModel];
-
-  const [maskImage, setMaskImage] = useState<SkImage | null>(null);
-  const [imageSize, setImageSize] = useState({ width: 1, height: 1 });
-  const lastFrameTimeRef = useRef(Date.now());
-
-  useEffect(() => {
-    onErrorChange(active.error ? String(active.error) : null);
-  }, [active.error, onErrorChange]);
-
-  useEffect(() => {
-    onReadyChange(active.isReady);
-  }, [active.isReady, onReadyChange]);
-
-  useEffect(() => {
-    onProgressChange(active.downloadProgress);
-  }, [active.downloadProgress, onProgressChange]);
-
-  useEffect(() => {
-    onGeneratingChange(active.isGenerating);
-  }, [active.isGenerating, onGeneratingChange]);
-
-  // Clear stale mask when the segmentation model variant changes
-  useEffect(() => {
-    setMaskImage((prev) => {
-      prev?.dispose();
-      return null;
-    });
-  }, [activeModel]);
-
-  // Dispose native Skia image on unmount to prevent memory leaks
-  useEffect(() => {
-    return () => {
-      setMaskImage((prev) => {
-        prev?.dispose();
-        return null;
-      });
-    };
-  }, []);
-
-  const segRof = active.runOnFrame;
-
-  const updateMask = useCallback(
-    (p: { img: SkImage; screenW: number; screenH: number }) => {
-      setMaskImage((prev) => {
-        prev?.dispose();
-        return p.img;
-      });
-      setImageSize({ width: p.screenW, height: p.screenH });
-      const now = Date.now();
-      const diff = now - lastFrameTimeRef.current;
-      if (diff > 0) onFpsChange(Math.round(1000 / diff), diff);
-      lastFrameTimeRef.current = now;
-    },
-    [onFpsChange]
-  );
-
-  // CLASS_COLORS captured directly in closure — worklets cannot import modules
-  const colors = CLASS_COLORS;
-
-  const frameOutput = useFrameOutput({
-    targetResolution: FRAME_TARGET_RESOLUTION,
-    pixelFormat: 'rgb',
-    dropFramesWhileBusy: true,
-    enablePreviewSizedOutputBuffers: true,
-    onFrame: useCallback(
-      (frame: Frame) => {
-        'worklet';
-        if (frameKillSwitch.getDirty()) {
-          frame.dispose();
-          return;
-        }
-        try {
-          if (!segRof) return;
-          const isFrontCamera = cameraPositionSync.getDirty() === 'front';
-          const result = segRof(frame, isFrontCamera, [], false);
-          if (result?.ARGMAX) {
-            const argmax: Int32Array = result.ARGMAX;
-            // Both the preview and the mask live in a portrait coord system:
-            // the activity is portrait-locked (so CameraX's PreviewView always
-            // renders the preview in portrait orientation regardless of how
-            // the device is physically tilted), and the native side runs
-            // `inverseRotateMat` which always converts the mask into the same
-            // portrait coord system. Treat sensor-native dims as portrait by
-            // swapping height/width — same convention as the sibling OCR and
-            // ObjectDetection tasks.
-            const screenW = frame.height;
-            const screenH = frame.width;
-            // Mask buffer dims: the C++ side returns the mask at model output
-            // resolution (the `resizeToInput=false` arg below). All built-in
-            // segmentation models output a square spatial map (e.g. 520×520),
-            // so sqrt(length) recovers the side. Non-square model outputs
-            // would need dims exposed from native.
-            const maskSide = Math.round(Math.sqrt(argmax.length));
-            const maskW = maskSide;
-            const maskH = maskSide;
-            const pixels = new Uint8Array(maskW * maskH * 4);
-            for (let i = 0; i < argmax.length; i++) {
-              const color = colors[argmax[i]!] ?? [0, 0, 0, 0];
-              pixels[i * 4] = color[0]!;
-              pixels[i * 4 + 1] = color[1]!;
-              pixels[i * 4 + 2] = color[2]!;
-              pixels[i * 4 + 3] = color[3]!;
-            }
-            const skData = Skia.Data.fromBytes(pixels);
-            const img = Skia.Image.MakeImage(
-              {
-                width: maskW,
-                height: maskH,
-                alphaType: AlphaType.Unpremul,
-                colorType: ColorType.RGBA_8888,
-              },
-              skData,
-              maskW * 4
-            );
-            if (img) scheduleOnRN(updateMask, { img, screenW, screenH });
-          }
-        } catch {
-          // Frame may be disposed before processing completes — transient, safe to ignore.
-        } finally {
-          frame.dispose();
-        }
-      },
-      [cameraPositionSync, colors, frameKillSwitch, segRof, updateMask]
-    ),
-  });
-
-  useEffect(() => {
-    onFrameOutputChange(frameOutput);
-  }, [frameOutput, onFrameOutputChange]);
-
-  if (!maskImage) return null;
-
-  // Match the camera preview's cover-scale + center layout so the mask
-  // aligns pixel-for-pixel with what the user sees. `fit="fill"` lets the
-  // (square) mask stretch into the preview rect — which is computed in
-  // screen-space dims rather than the sensor-native ones.
-  const scale = Math.max(
-    canvasSize.width / imageSize.width,
-    canvasSize.height / imageSize.height
-  );
-  const dstW = imageSize.width * scale;
-  const dstH = imageSize.height * scale;
-  const offsetX = (canvasSize.width - dstW) / 2;
-  const offsetY = (canvasSize.height - dstH) / 2;
-
-  return (
-    <View style={StyleSheet.absoluteFill} pointerEvents="none">
-      <Canvas style={StyleSheet.absoluteFill}>
-        <SkiaImage
-          image={maskImage}
-          fit="fill"
-          x={offsetX}
-          y={offsetY}
-          width={dstW}
-          height={dstH}
-        />
-      </Canvas>
-    </View>
-  );
-}
diff --git a/apps/computer-vision/components/vision_camera/tasks/StyleTransferTask.tsx b/apps/computer-vision/components/vision_camera/tasks/StyleTransferTask.tsx
deleted file mode 100644
index d5f8578272..0000000000
--- a/apps/computer-vision/components/vision_camera/tasks/StyleTransferTask.tsx
+++ /dev/null
@@ -1,156 +0,0 @@
-import React, { useCallback, useEffect, useRef, useState } from 'react';
-import { StyleSheet, View } from 'react-native';
-import { Frame, useFrameOutput } from 'react-native-vision-camera';
-import { scheduleOnRN } from 'react-native-worklets';
-import { models, useStyleTransfer } from 'react-native-executorch';
-import {
-  AlphaType,
-  Canvas,
-  ColorType,
-  Image as SkiaImage,
-  Skia,
-  SkImage,
-} from '@shopify/react-native-skia';
-import { FRAME_TARGET_RESOLUTION, TaskProps } from './types';
-const styleTransfer = models.style_transfer;
-
-type StyleModelId = 'styleTransferCandy' | 'styleTransferMosaic';
-
-type Props = TaskProps & { activeModel: StyleModelId };
-
-export default function StyleTransferTask({
-  activeModel,
-  canvasSize,
-  cameraPositionSync,
-  frameKillSwitch,
-  onFrameOutputChange,
-  onReadyChange,
-  onProgressChange,
-  onGeneratingChange,
-  onFpsChange,
-  onErrorChange,
-}: Props) {
-  const candy = useStyleTransfer({
-    model: styleTransfer.candy(),
-    preventLoad: activeModel !== 'styleTransferCandy',
-  });
-  const mosaic = useStyleTransfer({
-    model: styleTransfer.mosaic(),
-    preventLoad: activeModel !== 'styleTransferMosaic',
-  });
-
-  const active = activeModel === 'styleTransferCandy' ? candy : mosaic;
-
-  const [styledImage, setStyledImage] = useState<SkImage | null>(null);
-  const lastFrameTimeRef = useRef(Date.now());
-
-  useEffect(() => {
-    onErrorChange(active.error ? String(active.error) : null);
-  }, [active.error, onErrorChange]);
-
-  useEffect(() => {
-    onReadyChange(active.isReady);
-  }, [active.isReady, onReadyChange]);
-
-  useEffect(() => {
-    onProgressChange(active.downloadProgress);
-  }, [active.downloadProgress, onProgressChange]);
-
-  useEffect(() => {
-    onGeneratingChange(active.isGenerating);
-  }, [active.isGenerating, onGeneratingChange]);
-
-  useEffect(() => {
-    setStyledImage((prev) => {
-      prev?.dispose();
-      return null;
-    });
-  }, [activeModel]);
-
-  useEffect(() => {
-    return () => {
-      setStyledImage((prev) => {
-        prev?.dispose();
-        return null;
-      });
-    };
-  }, []);
-
-  const styleRof = active.runOnFrame;
-
-  const updateImage = useCallback(
-    (img: SkImage) => {
-      setStyledImage((prev) => {
-        prev?.dispose();
-        return img;
-      });
-      const now = Date.now();
-      const diff = now - lastFrameTimeRef.current;
-      if (diff > 0) onFpsChange(Math.round(1000 / diff), diff);
-      lastFrameTimeRef.current = now;
-    },
-    [onFpsChange]
-  );
-
-  const frameOutput = useFrameOutput({
-    targetResolution: FRAME_TARGET_RESOLUTION,
-    pixelFormat: 'rgb',
-    dropFramesWhileBusy: true,
-    enablePreviewSizedOutputBuffers: true,
-    onFrame: useCallback(
-      (frame: Frame) => {
-        'worklet';
-        if (frameKillSwitch.getDirty()) {
-          frame.dispose();
-          return;
-        }
-        try {
-          if (!styleRof) return;
-          const isFrontCamera = cameraPositionSync.getDirty() === 'front';
-          const result = styleRof(frame, isFrontCamera);
-          if (result) {
-            const pixels = new Uint8Array(result.dataPtr.buffer);
-            const skData = Skia.Data.fromBytes(pixels);
-            const img = Skia.Image.MakeImage(
-              {
-                width: result.sizes[1]!,
-                height: result.sizes[0]!,
-                alphaType: AlphaType.Unpremul,
-                colorType: ColorType.RGBA_8888,
-              },
-              skData,
-              result.sizes[1]! * 4
-            );
-            if (img) scheduleOnRN(updateImage, img);
-          }
-        } catch {
-          // Frame may be disposed before processing completes — transient, safe to ignore.
-        } finally {
-          frame.dispose();
-        }
-      },
-      [cameraPositionSync, frameKillSwitch, styleRof, updateImage]
-    ),
-  });
-
-  useEffect(() => {
-    onFrameOutputChange(frameOutput);
-  }, [frameOutput, onFrameOutputChange]);
-
-  if (!styledImage) return null;
-
-  return (
-    <View style={StyleSheet.absoluteFill} pointerEvents="none">
-      <Canvas style={StyleSheet.absoluteFill}>
-        <SkiaImage
-          image={styledImage}
-          fit="cover"
-          x={0}
-          y={0}
-          width={canvasSize.width}
-          height={canvasSize.height}
-        />
-      </Canvas>
-    </View>
-  );
-}
diff --git a/apps/computer-vision/components/vision_camera/tasks/types.ts b/apps/computer-vision/components/vision_camera/tasks/types.ts
deleted file mode 100644
index 53aca25570..0000000000
--- a/apps/computer-vision/components/vision_camera/tasks/types.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-import { useFrameOutput } from 'react-native-vision-camera';
-import { createSynchronizable } from 'react-native-worklets';
-
-export const FRAME_TARGET_RESOLUTION = { width: 1280, height: 720 } as const;
-
-export type TaskProps = {
-  activeModel: string;
-  canvasSize: { width: number; height: number };
-  cameraPositionSync: ReturnType<typeof createSynchronizable<'front' | 'back'>>;
-  frameKillSwitch: ReturnType<typeof createSynchronizable<boolean>>;
-  onFrameOutputChange: (frameOutput: ReturnType<typeof useFrameOutput>) => void;
-  onReadyChange: (isReady: boolean) => void;
-  onProgressChange: (progress: number) => void;
-  onGeneratingChange: (isGenerating: boolean) => void;
-  onFpsChange: (fps: number, frameMs: number) => void;
-  onErrorChange: (error: string | null) => void;
-};
diff --git a/apps/computer-vision/context.ts b/apps/computer-vision/context.ts
deleted file mode 100644
index 0eb0560768..0000000000
--- a/apps/computer-vision/context.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-import { createContext } from 'react';
-
-export const GeneratingContext = createContext({
-  setGlobalGenerating: (_newState: boolean) => {},
-});
diff --git a/apps/computer-vision/declarations.d.ts b/apps/computer-vision/declarations.d.ts
deleted file mode 100644
index 85e178f497..0000000000
--- a/apps/computer-vision/declarations.d.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-declare module '*.svg' {
-  import { SvgProps } from 'react-native-svg';
-  const content: React.FV<SvgProps>;
-  export default content;
-}
diff --git a/apps/computer-vision/index.ts b/apps/computer-vision/index.ts
deleted file mode 100644
index 3f443dcf95..0000000000
--- a/apps/computer-vision/index.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-import { registerRootComponent } from 'expo';
-
-import App from './app';
-
-// registerRootComponent calls AppRegistry.registerComponent('main', () => App);
-// It also ensures that whether you load the app in Expo Go or in a native build,
-// the environment is set up appropriately
-registerRootComponent(App);
diff --git a/apps/computer-vision/metro.config.js b/apps/computer-vision/metro.config.js
deleted file mode 100644
index f8ab2ab96d..0000000000
--- a/apps/computer-vision/metro.config.js
+++ /dev/null
@@ -1,21 +0,0 @@
-// Learn more https://docs.expo.io/guides/customizing-metro
-const { getDefaultConfig } = require('expo/metro-config');
-
-/** @type {import('expo/metro-config').MetroConfig} */
-const config = getDefaultConfig(__dirname);
-
-const { transformer, resolver } = config;
-
-config.transformer = {
-  ...transformer,
-  babelTransformerPath: require.resolve('react-native-svg-transformer/expo'),
-};
-config.resolver = {
-  ...resolver,
-  assetExts: resolver.assetExts.filter((ext) => ext !== 'svg'),
-  sourceExts: [...resolver.sourceExts, 'svg'],
-};
-
-config.resolver.assetExts.push('pte');
-
-module.exports = config;
diff --git a/apps/computer-vision/package.json b/apps/computer-vision/package.json
deleted file mode 100644
index be06efc27a..0000000000
--- a/apps/computer-vision/package.json
+++ /dev/null
@@ -1,55 +0,0 @@
-{
-  "name": "computer-vision",
-  "version": "1.0.0",
-  "main": "expo-router/entry",
-  "scripts": {
-    "start": "expo start",
-    "android": "expo run:android",
-    "ios": "expo run:ios",
-    "web": "expo start --web",
-    "typecheck": "tsc",
-    "lint": "eslint . --ext .ts,.tsx --fix"
-  },
-  "dependencies": {
-    "@expo/log-box": "~56.0.12",
-    "@expo/vector-icons": "^15.0.2",
-    "@react-native/metro-config": "^0.85.3",
-    "@react-navigation/drawer": "^7.9.4",
-    "@react-navigation/native": "^7.2.2",
-    "@shopify/react-native-skia": "2.6.2",
-    "expo": "~56.0.9",
-    "expo-build-properties": "~56.0.17",
-    "expo-constants": "~56.0.17",
-    "expo-font": "~56.0.5",
-    "expo-linking": "~56.0.13",
-    "expo-router": "~56.2.9",
-    "expo-status-bar": "~56.0.4",
-    "metro-config": "^0.84.0",
-    "react": "19.2.3",
-    "react-native": "0.85.3",
-    "react-native-device-info": "^15.0.2",
-    "react-native-executorch": "workspace:*",
-    "react-native-executorch-expo-resource-fetcher": "workspace:*",
-    "react-native-gesture-handler": "~2.31.1",
-    "react-native-image-picker": "^8.2.1",
-    "react-native-loading-spinner-overlay": "^3.0.1",
-    "react-native-nitro-image": "0.13.1",
-    "react-native-nitro-modules": "0.35.4",
-    "react-native-reanimated": "4.3.1",
-    "react-native-safe-area-context": "~5.7.0",
-    "react-native-screens": "~4.25.2",
-    "react-native-svg": "15.15.4",
-    "react-native-svg-transformer": "^1.5.3",
-    "react-native-vision-camera": "^5.0.6",
-    "react-native-vision-camera-worklets": "^5.0.6",
-    "react-native-worklets": "0.8.3"
-  },
-  "devDependencies": {
-    "@babel/core": "^7.29.0",
-    "@types/react": "~19.2.0",
-    "@types/react-refresh": "^0",
-    "babel-preset-expo": "~56.0.14",
-    "react-refresh": "^0.18.0"
-  },
-  "private": true
-}
diff --git a/apps/computer-vision/tsconfig.json b/apps/computer-vision/tsconfig.json
deleted file mode 100644
index bfe226172e..0000000000
--- a/apps/computer-vision/tsconfig.json
+++ /dev/null
@@ -1,18 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "strict": true,
-    "allowJs": true,
-    "module": "preserve",
-    "moduleDetection": "force",
-    "moduleResolution": "bundler",
-    "customConditions": ["react-native"],
-    "noEmit": true,
-    "paths": {
-      "react-native-executorch": ["../../packages/react-native-executorch/src"],
-      "react-native-executorch-expo-resource-fetcher": [
-        "../../packages/expo-resource-fetcher/src"
-      ]
-    }
-  }
-}
diff --git a/apps/computer-vision/utils.ts b/apps/computer-vision/utils.ts
deleted file mode 100644
index 3af8d7920e..0000000000
--- a/apps/computer-vision/utils.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import {
-  CameraOptions,
-  launchCamera,
-  launchImageLibrary,
-} from 'react-native-image-picker';
-
-export const getImage = async (useCamera: boolean) => {
-  const options: CameraOptions = {
-    mediaType: 'photo',
-  };
-  try {
-    const output = useCamera
-      ? await launchCamera(options)
-      : await launchImageLibrary(options);
-
-    if (!output.assets || output.assets.length === 0) return;
-
-    return output.assets[0];
-  } catch (err) {
-    console.error(err);
-  }
-};
diff --git a/apps/llm/.gitignore b/apps/llm/.gitignore
deleted file mode 100644
index f779c900a7..0000000000
--- a/apps/llm/.gitignore
+++ /dev/null
@@ -1,38 +0,0 @@
-# Learn more https://docs.github.com/en/get-started/getting-started-with-git/ignoring-files
-
-# dependencies
-node_modules/
-
-# Expo
-.expo/
-dist/
-web-build/
-expo-env.d.ts
-
-# Native
-*.orig.*
-*.jks
-*.p8
-*.p12
-*.key
-*.mobileprovision
-
-# Metro
-.metro-health-check*
-
-# debug
-npm-debug.*
-yarn-debug.*
-yarn-error.*
-
-# macOS
-.DS_Store
-*.pem
-
-# local env files
-.env*.local
-
-# typescript
-*.tsbuildinfo
-
-.yarn
diff --git a/apps/llm/app.json b/apps/llm/app.json
deleted file mode 100644
index 43f497d703..0000000000
--- a/apps/llm/app.json
+++ /dev/null
@@ -1,87 +0,0 @@
-{
-  "expo": {
-    "name": "llm",
-    "slug": "llm",
-    "version": "1.0.0",
-    "orientation": "portrait",
-    "icon": "./assets/icons/icon.png",
-    "userInterfaceStyle": "light",
-    "scheme": "rne-llm",
-    "plugins": [
-      [
-        "expo-font",
-        {
-          "fonts": [
-            "./assets/fonts/Aeonik-Regular.otf",
-            "./assets/fonts/Aeonik-Medium.otf"
-          ]
-        }
-      ],
-      [
-        "expo-calendar",
-        {
-          "calendarPermission": "The app needs to access your calendar."
-        }
-      ],
-      "expo-router",
-      [
-        "react-native-audio-api",
-        {
-          "iosBackgroundMode": true,
-          "iosMicrophonePermission": "This app requires access to the microphone to record audio.",
-          "androidPermissions": [
-            "android.permission.MODIFY_AUDIO_SETTINGS",
-            "android.permission.FOREGROUND_SERVICE",
-            "android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK",
-            "android.permission.RECORD_AUDIO"
-          ],
-          "androidForegroundService": true,
-          "androidFSTypes": ["mediaPlayback"]
-        }
-      ],
-      [
-        "expo-build-properties",
-        {
-          "ios": {
-            "deploymentTarget": "17.0"
-          }
-        }
-      ]
-    ],
-    "newArchEnabled": true,
-    "splash": {
-      "image": "./assets/icons/splash.png",
-      "resizeMode": "contain",
-      "backgroundColor": "#ffffff"
-    },
-    "ios": {
-      "supportsTablet": true,
-      "bundleIdentifier": "com.anonymous.llm",
-      "infoPlist": {
-        "NSMicrophoneUsageDescription": "This app needs access to your microphone to record audio.",
-        "NSCalendarsUsageDescription": "This app needs access to your calendar to manage events."
-      },
-      "entitlements": {
-        "com.apple.developer.kernel.increased-memory-limit": true
-      }
-    },
-    "android": {
-      "adaptiveIcon": {
-        "foregroundImage": "./assets/icons/adaptive-icon.png",
-        "backgroundColor": "#ffffff"
-      },
-      "package": "com.anonymous.llm",
-      "permissions": [
-        "android.permission.READ_CALENDAR",
-        "android.permission.WRITE_CALENDAR",
-        "android.permission.MODIFY_AUDIO_SETTINGS",
-        "android.permission.FOREGROUND_SERVICE",
-        "android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK",
-        "android.permission.RECORD_AUDIO"
-      ]
-    },
-    "web": {
-      "favicon": "./assets/icons/favicon.png"
-    }
-  }
-}
diff --git a/apps/llm/app/_layout.tsx b/apps/llm/app/_layout.tsx
deleted file mode 100644
index 2cbf4c8c73..0000000000
--- a/apps/llm/app/_layout.tsx
+++ /dev/null
@@ -1,160 +0,0 @@
-import { Drawer } from 'expo-router/drawer';
-import { initExecutorch } from 'react-native-executorch';
-import { ExpoResourceFetcher } from 'react-native-executorch-expo-resource-fetcher';
-import ColorPalette from '../colors';
-import React, { useState } from 'react';
-import {
-  Text,
-  StyleSheet,
-  View,
-  TouchableOpacity,
-  type ColorValue,
-} from 'react-native';
-import {
-  type DrawerContentComponentProps,
-  DrawerContentScrollView,
-  DrawerItemList,
-} from 'expo-router/build/react-navigation/drawer';
-import { DrawerActions } from 'expo-router/build/react-navigation/routers';
-import { useNavigation } from 'expo-router';
-import Svg, { Rect } from 'react-native-svg';
-import { GeneratingContext } from '../context';
-
-function HamburgerIcon({ tintColor }: { tintColor?: ColorValue }) {
-  const navigation = useNavigation();
-  const fill = typeof tintColor === 'string' ? tintColor : '#000';
-  return (
-    <TouchableOpacity
-      onPress={() => navigation.dispatch(DrawerActions.toggleDrawer())}
-      style={styles.hamburger}
-    >
-      <Svg width={24} height={24} viewBox="0 0 24 24">
-        <Rect x={2} y={4} width={20} height={2} rx={1} fill={fill} />
-        <Rect x={2} y={11} width={20} height={2} rx={1} fill={fill} />
-        <Rect x={2} y={18} width={20} height={2} rx={1} fill={fill} />
-      </Svg>
-    </TouchableOpacity>
-  );
-}
-
-initExecutorch({
-  resourceFetcher: ExpoResourceFetcher,
-});
-
-interface CustomDrawerProps extends DrawerContentComponentProps {
-  isGenerating: boolean;
-}
-
-function CustomDrawerContent(props: CustomDrawerProps) {
-  const { isGenerating, ...otherProps } = props;
-  return (
-    <DrawerContentScrollView {...otherProps}>
-      {!isGenerating ? (
-        <DrawerItemList {...otherProps} />
-      ) : (
-        <View style={styles.centerContent}>
-          <Text style={styles.mainText}>Model is generating...</Text>
-          <Text style={styles.subText}>Interrupt before switching model</Text>
-        </View>
-      )}
-    </DrawerContentScrollView>
-  );
-}
-
-export default function _layout() {
-  const [isGenerating, setIsGenerating] = useState(false);
-
-  return (
-    <GeneratingContext
-      value={{
-        setGlobalGenerating: (newState: boolean) => {
-          setIsGenerating(newState);
-        },
-      }}
-    >
-      <Drawer
-        drawerContent={(props) => (
-          <CustomDrawerContent {...props} isGenerating={isGenerating} />
-        )}
-        screenOptions={{
-          drawerActiveTintColor: ColorPalette.primary,
-          drawerInactiveTintColor: '#888',
-          headerTintColor: ColorPalette.primary,
-          headerTitleStyle: { color: ColorPalette.primary },
-          headerLeft: (props) => <HamburgerIcon tintColor={props.tintColor} />,
-        }}
-      >
-        <Drawer.Screen
-          name="index"
-          options={{
-            drawerLabel: () => null,
-            title: 'Main Menu',
-            drawerItemStyle: { display: 'none' },
-          }}
-        />
-        <Drawer.Screen
-          name="llm/index"
-          options={{
-            drawerLabel: 'LLM',
-            title: 'LLM',
-            headerTitleStyle: { color: ColorPalette.primary },
-          }}
-        />
-        <Drawer.Screen
-          name="llm_tool_calling/index"
-          options={{
-            drawerLabel: 'LLM Tool Calling',
-            title: 'LLM Tool Calling',
-            headerTitleStyle: { color: ColorPalette.primary },
-          }}
-        />
-        <Drawer.Screen
-          name="llm_structured_output/index"
-          options={{
-            drawerLabel: 'LLM Structured Output',
-            title: 'LLM Structured Output',
-            headerTitleStyle: { color: ColorPalette.primary },
-          }}
-        />
-        <Drawer.Screen
-          name="multimodal_llm/index"
-          options={{
-            drawerLabel: 'Multimodal LLM (VLM)',
-            title: 'Multimodal LLM',
-            headerTitleStyle: { color: ColorPalette.primary },
-          }}
-        />
-        <Drawer.Screen
-          name="privacy_filter/index"
-          options={{
-            drawerLabel: 'Privacy Filter (PII)',
-            title: 'Privacy Filter',
-            headerTitleStyle: { color: ColorPalette.primary },
-          }}
-        />
-      </Drawer>
-    </GeneratingContext>
-  );
-}
-
-const styles = StyleSheet.create({
-  hamburger: {
-    marginLeft: 12,
-  },
-  centerContent: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-    padding: 20,
-  },
-  mainText: {
-    fontSize: 18,
-    fontWeight: 'bold',
-    marginBottom: 10,
-    color: ColorPalette.primary,
-  },
-  subText: {
-    fontSize: 14,
-    color: ColorPalette.strongPrimary,
-  },
-});
diff --git a/apps/llm/app/index.tsx b/apps/llm/app/index.tsx
deleted file mode 100644
index b67b3fa7ce..0000000000
--- a/apps/llm/app/index.tsx
+++ /dev/null
@@ -1,87 +0,0 @@
-import { useRouter } from 'expo-router';
-import { View, Text, StyleSheet, TouchableOpacity } from 'react-native';
-import ColorPalette from '../colors';
-import ExecutorchLogo from '../assets/icons/executorch.svg';
-
-export default function Home() {
-  const router = useRouter();
-
-  return (
-    <View style={styles.container}>
-      <ExecutorchLogo width={64} height={64} />
-      <Text style={styles.headerText}>Select a demo model</Text>
-      <View style={styles.buttonContainer}>
-        <TouchableOpacity
-          style={styles.button}
-          onPress={() => router.navigate('llm/')}
-        >
-          <Text style={styles.buttonText}>LLM</Text>
-        </TouchableOpacity>
-        <TouchableOpacity
-          style={styles.button}
-          onPress={() => router.navigate('llm_tool_calling/')}
-        >
-          <Text style={styles.buttonText}>LLM Tool Calling</Text>
-        </TouchableOpacity>
-        <TouchableOpacity
-          style={styles.button}
-          onPress={() => router.navigate('llm_structured_output/')}
-        >
-          <Text style={styles.buttonText}>LLM Structured Output</Text>
-        </TouchableOpacity>
-        <TouchableOpacity
-          style={styles.button}
-          onPress={() => router.navigate('multimodal_llm/')}
-        >
-          <Text style={styles.buttonText}>Multimodal LLM (VLM)</Text>
-        </TouchableOpacity>
-        <TouchableOpacity
-          style={styles.button}
-          onPress={() => router.navigate('privacy_filter/')}
-        >
-          <Text style={styles.buttonText}>Privacy Filter (PII)</Text>
-        </TouchableOpacity>
-      </View>
-    </View>
-  );
-}
-
-export const fontSizes = {
-  xxl: 34,
-  xl: 22,
-  lg: 18,
-  md: 16,
-  sm: 14,
-  xs: 12,
-  xxs: 10,
-};
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-    backgroundColor: '#fff',
-  },
-  headerText: {
-    fontSize: fontSizes.lg,
-    color: ColorPalette.strongPrimary,
-    margin: 20,
-  },
-  buttonContainer: {
-    width: '80%',
-    justifyContent: 'space-evenly',
-    marginBottom: 20,
-  },
-  button: {
-    backgroundColor: ColorPalette.strongPrimary,
-    borderRadius: 8,
-    padding: 10,
-    alignItems: 'center',
-    marginBottom: 10,
-  },
-  buttonText: {
-    color: 'white',
-    fontSize: fontSizes.md,
-  },
-});
diff --git a/apps/llm/app/llm/index.tsx b/apps/llm/app/llm/index.tsx
deleted file mode 100644
index 8bc0afb623..0000000000
--- a/apps/llm/app/llm/index.tsx
+++ /dev/null
@@ -1,222 +0,0 @@
-import { useContext, useEffect, useRef, useState } from 'react';
-import {
-  Keyboard,
-  KeyboardAvoidingView,
-  StyleSheet,
-  Text,
-  TextInput,
-  Platform,
-  TouchableOpacity,
-  TouchableWithoutFeedback,
-  View,
-} from 'react-native';
-import SendIcon from '../../assets/icons/send_icon.svg';
-import { models, useLLM } from 'react-native-executorch';
-import { ModelPicker } from '../../components/ModelPicker';
-import { LLM_MODELS, LLMModelSources } from '../../components/llmModels';
-import PauseIcon from '../../assets/icons/pause_icon.svg';
-import ColorPalette from '../../colors';
-import Messages from '../../components/Messages';
-import { useIsFocused } from 'expo-router';
-import { useSafeAreaInsets } from 'react-native-safe-area-context';
-import { GeneratingContext } from '../../context';
-import Spinner from '../../components/Spinner';
-import SuggestedPrompts from '../../components/SuggestedPrompts';
-
-const SUGGESTED_PROMPTS = [
-  'Explain quantum computing in simple terms',
-  'Write a short poem about coding',
-  'What are the benefits of on-device AI?',
-  'Give me 3 fun facts about space',
-];
-import { useLLMStats } from '../../hooks/useLLMStats';
-import { StatsBar } from '../../components/StatsBar';
-import ErrorBanner from '../../components/ErrorBanner';
-
-export default function LLMScreenWrapper() {
-  const isFocused = useIsFocused();
-  return isFocused ? <LLMScreen /> : null;
-}
-
-function LLMScreen() {
-  const { bottom } = useSafeAreaInsets();
-  const [isTextInputFocused, setIsTextInputFocused] = useState(false);
-  const [userInput, setUserInput] = useState('');
-  const [selectedModel, setSelectedModel] = useState<LLMModelSources>(
-    models.llm.lfm2_5_1_2b_instruct()
-  );
-  const textInputRef = useRef<TextInput>(null);
-  const { setGlobalGenerating } = useContext(GeneratingContext);
-
-  const llm = useLLM({ model: selectedModel });
-  const tokenCount = llm.isReady ? llm.getGeneratedTokenCount() : 0;
-  const { stats, onMessageSend } = useLLMStats(
-    llm.response,
-    llm.isGenerating,
-    tokenCount
-  );
-  const [error, setError] = useState<string | null>(null);
-
-  useEffect(() => {
-    if (llm.error) setError(String(llm.error));
-  }, [llm.error]);
-
-  useEffect(() => {
-    setGlobalGenerating(llm.isGenerating);
-  }, [llm.isGenerating, setGlobalGenerating]);
-
-  const sendMessage = async () => {
-    onMessageSend();
-    setUserInput('');
-    textInputRef.current?.clear();
-    try {
-      await llm.sendMessage(userInput);
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-    }
-  };
-
-  return !llm.isReady && !llm.error ? (
-    <Spinner
-      visible={true}
-      textContent={`Loading the model ${(llm.downloadProgress * 100).toFixed(0)} %`}
-    />
-  ) : (
-    <TouchableWithoutFeedback onPress={Keyboard.dismiss}>
-      <KeyboardAvoidingView
-        style={styles.container}
-        collapsable={false}
-        behavior={Platform.OS === 'ios' ? 'padding' : undefined}
-        keyboardVerticalOffset={Platform.OS === 'ios' ? 120 : 40}
-      >
-        <View style={styles.container}>
-          <ErrorBanner message={error} onDismiss={() => setError(null)} />
-          {llm.messageHistory.length ? (
-            <View style={styles.chatContainer}>
-              <Messages
-                chatHistory={llm.messageHistory}
-                llmResponse={llm.response}
-                isGenerating={llm.isGenerating}
-                deleteMessage={llm.deleteMessage}
-              />
-            </View>
-          ) : (
-            <View style={styles.helloMessageContainer}>
-              <Text style={styles.helloText}>Hello! 👋</Text>
-              <Text style={styles.bottomHelloText}>
-                What can I help you with?
-              </Text>
-              <SuggestedPrompts
-                prompts={SUGGESTED_PROMPTS}
-                onSelect={setUserInput}
-              />
-            </View>
-          )}
-
-          <ModelPicker
-            models={LLM_MODELS}
-            selectedModel={selectedModel}
-            onSelect={(m) => setSelectedModel(m)}
-            disabled={llm.isGenerating}
-          />
-          <StatsBar stats={stats} />
-          <View
-            style={[
-              styles.bottomContainer,
-              Platform.OS === 'android' && {
-                paddingBottom: bottom || 16,
-                height: 100 + (bottom || 16),
-              },
-            ]}
-          >
-            <TextInput
-              autoCorrect={false}
-              onFocus={() => setIsTextInputFocused(true)}
-              onBlur={() => setIsTextInputFocused(false)}
-              style={{
-                ...styles.textInput,
-                borderColor: isTextInputFocused
-                  ? ColorPalette.blueDark
-                  : ColorPalette.blueLight,
-              }}
-              placeholder={isTextInputFocused ? '' : 'Your message'}
-              placeholderTextColor={'#C1C6E5'}
-              multiline={true}
-              ref={textInputRef}
-              value={userInput}
-              onChangeText={(text: string) => setUserInput(text)}
-            />
-            {userInput && (
-              <TouchableOpacity
-                style={styles.sendChatTouchable}
-                onPress={async () => !llm.isGenerating && (await sendMessage())}
-              >
-                <SendIcon height={24} width={24} padding={4} margin={8} />
-              </TouchableOpacity>
-            )}
-            {llm.isGenerating && (
-              <TouchableOpacity
-                style={styles.sendChatTouchable}
-                onPress={llm.interrupt}
-              >
-                <PauseIcon height={24} width={24} padding={4} margin={8} />
-              </TouchableOpacity>
-            )}
-          </View>
-        </View>
-      </KeyboardAvoidingView>
-    </TouchableWithoutFeedback>
-  );
-}
-
-const styles = StyleSheet.create({
-  keyboardAvoidingView: {
-    flex: 1,
-    paddingBottom: Platform.OS === 'android' ? 20 : 0,
-  },
-  container: { flex: 1 },
-  chatContainer: { flex: 10, width: '100%' },
-  helloMessageContainer: {
-    flex: 10,
-    width: '100%',
-    alignItems: 'center',
-    justifyContent: 'center',
-    overflow: 'hidden',
-  },
-  helloText: {
-    fontFamily: 'medium',
-    fontSize: 30,
-    color: ColorPalette.primary,
-  },
-  bottomHelloText: {
-    fontFamily: 'regular',
-    fontSize: 20,
-    lineHeight: 28,
-    textAlign: 'center',
-    color: ColorPalette.primary,
-  },
-  bottomContainer: {
-    height: 100,
-    width: '100%',
-    flexDirection: 'row',
-    justifyContent: 'space-between',
-    alignItems: 'center',
-    paddingHorizontal: 16,
-  },
-  textInput: {
-    flex: 1,
-    borderWidth: 1,
-    borderRadius: 8,
-    lineHeight: 19.6,
-    fontFamily: 'regular',
-    fontSize: 14,
-    color: ColorPalette.primary,
-    padding: 16,
-  },
-  sendChatTouchable: {
-    height: '100%',
-    width: 48,
-    justifyContent: 'center',
-    alignItems: 'flex-end',
-  },
-});
diff --git a/apps/llm/app/llm_structured_output/index.tsx b/apps/llm/app/llm_structured_output/index.tsx
deleted file mode 100644
index fc1474fa9c..0000000000
--- a/apps/llm/app/llm_structured_output/index.tsx
+++ /dev/null
@@ -1,297 +0,0 @@
-import { useContext, useEffect, useRef, useState } from 'react';
-import {
-  Keyboard,
-  KeyboardAvoidingView,
-  StyleSheet,
-  Text,
-  TextInput,
-  Platform,
-  TouchableOpacity,
-  TouchableWithoutFeedback,
-  View,
-} from 'react-native';
-import SendIcon from '../../assets/icons/send_icon.svg';
-import Spinner from '../../components/Spinner';
-import SuggestedPrompts from '../../components/SuggestedPrompts';
-
-const SUGGESTED_PROMPTS = [
-  "I'm John. Is this damaged? I offer $100.",
-  "Hi, I'm Alice! How old is it? Offering $250 USD.",
-  "I'm Bob. Does it have warranty? I'll pay €50.",
-  "Name's Sara. What condition? My bid is $75.",
-];
-import { useLLMStats } from '../../hooks/useLLMStats';
-import { StatsBar } from '../../components/StatsBar';
-import ErrorBanner from '../../components/ErrorBanner';
-import {
-  models,
-  useLLM,
-  fixAndValidateStructuredOutput,
-  getStructuredOutputPrompt,
-} from 'react-native-executorch';
-import { ModelPicker } from '../../components/ModelPicker';
-import { LLM_MODELS, LLMModelSources } from '../../components/llmModels';
-import PauseIcon from '../../assets/icons/pause_icon.svg';
-import ColorPalette from '../../colors';
-import Messages from '../../components/Messages';
-import { useIsFocused } from 'expo-router';
-import { GeneratingContext } from '../../context';
-import { Schema } from 'jsonschema';
-import * as z from 'zod/v4';
-
-// Defining schemas
-const responseSchema: Schema = {
-  properties: {
-    username: {
-      type: 'string',
-      description: 'Name of user, that is asking a question.',
-    },
-    question: {
-      type: 'string',
-      description: 'Question that user asks.',
-    },
-    bid: {
-      type: 'number',
-      description: 'Amount of money, that user offers.',
-    },
-    currency: {
-      type: 'string',
-      description: 'Currency of offer.',
-    },
-  },
-  required: ['username', 'bid'],
-  type: 'object',
-};
-
-const responseSchemaWithZod = z.object({
-  username: z
-    .string()
-    .meta({ description: 'Name of user, that is asking a question.' }),
-  question: z.optional(
-    z.string().meta({ description: 'Question that user asks.' })
-  ),
-  bid: z.number().meta({ description: 'Amount of money, that user offers.' }),
-  currency: z.optional(z.string().meta({ description: 'Currency of offer.' })),
-});
-
-export default function LLMScreenWrapper() {
-  const isFocused = useIsFocused();
-
-  return isFocused ? <LLMScreen /> : null;
-}
-
-function LLMScreen() {
-  const [isTextInputFocused, setIsTextInputFocused] = useState(false);
-  const [userInput, setUserInput] = useState('');
-  const [selectedModel, setSelectedModel] = useState<LLMModelSources>(
-    models.llm.qwen3_1_7b()
-  );
-  const textInputRef = useRef<TextInput>(null);
-  const { setGlobalGenerating } = useContext(GeneratingContext);
-
-  const llm = useLLM({ model: selectedModel });
-  const tokenCount = llm.isReady ? llm.getGeneratedTokenCount() : 0;
-  const { stats, onMessageSend } = useLLMStats(
-    llm.response,
-    llm.isGenerating,
-    tokenCount
-  );
-  const [error, setError] = useState<string | null>(null);
-
-  useEffect(() => {
-    setGlobalGenerating(llm.isGenerating);
-  }, [llm.isGenerating, setGlobalGenerating]);
-
-  const { configure } = llm;
-  useEffect(() => {
-    const formattingInstructions = getStructuredOutputPrompt(responseSchema);
-    const prompt = `Your goal is to parse user's messages and return them in JSON format. Don't respond to user. Simply return JSON with user's question parsed. \n${formattingInstructions}\n /no_think`;
-
-    configure({
-      chatConfig: {
-        systemPrompt: prompt,
-      },
-    });
-  }, [configure]);
-
-  useEffect(() => {
-    const lastMessage = llm.messageHistory.at(-1);
-    if (!llm.isGenerating && lastMessage?.role === 'assistant') {
-      try {
-        const formattedOutput = fixAndValidateStructuredOutput(
-          lastMessage.content,
-          responseSchema
-        );
-        const formattedOutputWithZod = fixAndValidateStructuredOutput(
-          lastMessage.content,
-          responseSchemaWithZod
-        );
-        console.log(
-          'Formatted output:',
-          formattedOutput,
-          formattedOutputWithZod
-        );
-      } catch (e) {
-        console.log(
-          "Error parsing output and/or output doesn't match required schema!",
-          e
-        );
-      }
-    }
-  }, [llm.messageHistory, llm.isGenerating]);
-
-  useEffect(() => {
-    if (llm.error) setError(String(llm.error));
-  }, [llm.error]);
-
-  const sendMessage = async () => {
-    onMessageSend();
-    setUserInput('');
-    textInputRef.current?.clear();
-    try {
-      await llm.sendMessage(userInput);
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-    }
-  };
-
-  return !llm.isReady && !llm.error ? (
-    <Spinner
-      visible={true}
-      textContent={`Loading the model ${(llm.downloadProgress * 100).toFixed(0)} %`}
-    />
-  ) : (
-    <TouchableWithoutFeedback onPress={Keyboard.dismiss}>
-      <KeyboardAvoidingView
-        style={{
-          ...styles.container,
-        }}
-        collapsable={false}
-        behavior={Platform.OS === 'ios' ? 'padding' : undefined}
-        keyboardVerticalOffset={Platform.OS === 'ios' ? 120 : 40}
-      >
-        <View style={styles.container}>
-          <ErrorBanner message={error} onDismiss={() => setError(null)} />
-          {llm.messageHistory.length ? (
-            <View style={styles.chatContainer}>
-              <Messages
-                chatHistory={llm.messageHistory}
-                llmResponse={llm.response}
-                isGenerating={llm.isGenerating}
-                deleteMessage={llm.deleteMessage}
-              />
-            </View>
-          ) : (
-            <View style={styles.helloMessageContainer}>
-              <Text style={styles.helloText}>Hello! 👋</Text>
-              <Text style={styles.bottomHelloText}>
-                I can parse user's questions! Introduce yourself, ask questions
-                and offer a price for some product.
-              </Text>
-              <SuggestedPrompts
-                prompts={SUGGESTED_PROMPTS}
-                onSelect={setUserInput}
-              />
-            </View>
-          )}
-
-          <ModelPicker
-            models={LLM_MODELS}
-            selectedModel={selectedModel}
-            onSelect={(m) => setSelectedModel(m)}
-            disabled={llm.isGenerating}
-          />
-          <StatsBar stats={stats} />
-          <View style={styles.bottomContainer}>
-            <TextInput
-              autoCorrect={false}
-              onFocus={() => setIsTextInputFocused(true)}
-              onBlur={() => setIsTextInputFocused(false)}
-              style={{
-                ...styles.textInput,
-                borderColor: isTextInputFocused
-                  ? ColorPalette.blueDark
-                  : ColorPalette.blueLight,
-              }}
-              placeholder={
-                isTextInputFocused
-                  ? ''
-                  : "Your message e.g. I'm John. Is this product damaged? I can give you $100 for this."
-              }
-              placeholderTextColor={'#C1C6E5'}
-              multiline={true}
-              ref={textInputRef}
-              value={userInput}
-              onChangeText={(text: string) => setUserInput(text)}
-            />
-            {userInput && (
-              <TouchableOpacity
-                style={styles.sendChatTouchable}
-                onPress={async () => !llm.isGenerating && (await sendMessage())}
-              >
-                <SendIcon height={24} width={24} padding={4} margin={8} />
-              </TouchableOpacity>
-            )}
-            {llm.isGenerating && (
-              <TouchableOpacity
-                style={styles.sendChatTouchable}
-                onPress={llm.interrupt}
-              >
-                <PauseIcon height={24} width={24} padding={4} margin={8} />
-              </TouchableOpacity>
-            )}
-          </View>
-        </View>
-      </KeyboardAvoidingView>
-    </TouchableWithoutFeedback>
-  );
-}
-
-const styles = StyleSheet.create({
-  keyboardAvoidingView: { flex: 1 },
-  container: { flex: 1, paddingBottom: Platform.OS === 'android' ? 20 : 0 },
-  chatContainer: { flex: 10, width: '100%' },
-  helloMessageContainer: {
-    flex: 10,
-    width: '100%',
-    alignItems: 'center',
-    justifyContent: 'center',
-  },
-  helloText: {
-    fontFamily: 'medium',
-    fontSize: 30,
-    color: ColorPalette.primary,
-  },
-  bottomHelloText: {
-    padding: 20,
-    fontFamily: 'regular',
-    fontSize: 20,
-    lineHeight: 28,
-    textAlign: 'center',
-    color: ColorPalette.primary,
-  },
-  bottomContainer: {
-    height: 100,
-    width: '100%',
-    flexDirection: 'row',
-    justifyContent: 'space-between',
-    alignItems: 'center',
-    paddingHorizontal: 16,
-  },
-  textInput: {
-    flex: 1,
-    borderWidth: 1,
-    borderRadius: 8,
-    lineHeight: 19.6,
-    fontFamily: 'regular',
-    fontSize: 14,
-    color: ColorPalette.primary,
-    padding: 16,
-  },
-  sendChatTouchable: {
-    height: '100%',
-    width: 48,
-    justifyContent: 'center',
-    alignItems: 'flex-end',
-  },
-});
diff --git a/apps/llm/app/llm_tool_calling/index.tsx b/apps/llm/app/llm_tool_calling/index.tsx
deleted file mode 100644
index 7ca42d2adc..0000000000
--- a/apps/llm/app/llm_tool_calling/index.tsx
+++ /dev/null
@@ -1,354 +0,0 @@
-import { useContext, useEffect, useRef, useState } from 'react';
-import {
-  Keyboard,
-  KeyboardAvoidingView,
-  Platform,
-  StyleSheet,
-  Text,
-  TextInput,
-  TouchableOpacity,
-  TouchableWithoutFeedback,
-  View,
-  Linking,
-  Alert,
-  AppState,
-} from 'react-native';
-import SWMIcon from '../../assets/icons/swm_icon.svg';
-import SendIcon from '../../assets/icons/send_icon.svg';
-import Spinner from '../../components/Spinner';
-import ErrorBanner from '../../components/ErrorBanner';
-import { models, useLLM, DEFAULT_SYSTEM_PROMPT } from 'react-native-executorch';
-import { ModelPicker } from '../../components/ModelPicker';
-import { LLM_MODELS, LLMModelSources } from '../../components/llmModels';
-import PauseIcon from '../../assets/icons/pause_icon.svg';
-import ColorPalette from '../../colors';
-import Messages from '../../components/Messages';
-import * as Brightness from 'expo-brightness';
-import * as Calendar from 'expo-calendar';
-import { PermissionStatus } from 'expo';
-import { executeTool, TOOL_DEFINITIONS_PHONE } from '../../utils/tools';
-import { useIsFocused } from 'expo-router';
-import { GeneratingContext } from '../../context';
-import SuggestedPrompts from '../../components/SuggestedPrompts';
-
-const SUGGESTED_PROMPTS = [
-  'What events do I have today?',
-  'Add a meeting tomorrow at 2pm',
-  'Set screen brightness to 50%',
-  'What do I have scheduled this week?',
-];
-import { useLLMStats } from '../../hooks/useLLMStats';
-import { StatsBar } from '../../components/StatsBar';
-
-export default function LLMToolCallingScreenWrapper() {
-  const isFocused = useIsFocused();
-
-  return isFocused ? <LLMToolCallingScreen /> : null;
-}
-
-function LLMToolCallingScreen() {
-  const [isTextInputFocused, setIsTextInputFocused] = useState(false);
-  const [userInput, setUserInput] = useState('');
-  const [hasCalendarPermission, setHasCalendarPermission] = useState(true);
-  const [hasBrightnessPermission, setHasBrightnessPermission] = useState(true);
-  const [selectedModel, setSelectedModel] = useState<LLMModelSources>(
-    models.llm.hammer2_1_1_5b()
-  );
-  const textInputRef = useRef<TextInput>(null);
-  const { setGlobalGenerating } = useContext(GeneratingContext);
-
-  const llm = useLLM({ model: selectedModel });
-  const tokenCount = llm.isReady ? llm.getGeneratedTokenCount() : 0;
-  const { stats, onMessageSend } = useLLMStats(
-    llm.response,
-    llm.isGenerating,
-    tokenCount
-  );
-  const [error, setError] = useState<string | null>(null);
-
-  useEffect(() => {
-    setGlobalGenerating(llm.isGenerating);
-  }, [llm.isGenerating, setGlobalGenerating]);
-
-  const { configure } = llm;
-  useEffect(() => {
-    configure({
-      chatConfig: {
-        systemPrompt: `${DEFAULT_SYSTEM_PROMPT} Current time and date: ${new Date().toString()}`,
-      },
-      toolsConfig: {
-        tools: TOOL_DEFINITIONS_PHONE,
-        executeToolCallback: executeTool,
-        displayToolCalls: true,
-      },
-    });
-  }, [configure]);
-
-  useEffect(() => {
-    if (llm.error) setError(String(llm.error));
-  }, [llm.error]);
-
-  const requestCalendarPermission = async () => {
-    const { status, canAskAgain } =
-      await Calendar.getCalendarPermissionsAsync();
-
-    if (status === PermissionStatus.GRANTED) {
-      setHasCalendarPermission(true);
-      return;
-    }
-
-    if (status === PermissionStatus.UNDETERMINED || canAskAgain) {
-      const { status: nextStatus } =
-        await Calendar.requestCalendarPermissionsAsync();
-      setHasCalendarPermission(nextStatus === PermissionStatus.GRANTED);
-      return;
-    }
-
-    setHasCalendarPermission(false);
-    Alert.alert(
-      'Calendar Permission Required',
-      'To read or add events, the app requires "Full Access" to your calendar. Please enable this in your device settings.',
-      [
-        { text: 'Cancel', style: 'cancel' },
-        { text: 'Open Settings', onPress: () => Linking.openSettings() },
-      ]
-    );
-  };
-
-  const requestBrightnessPermission = async () => {
-    const { status, canAskAgain } = await Brightness.getPermissionsAsync();
-
-    if (status === Brightness.PermissionStatus.GRANTED) {
-      setHasBrightnessPermission(true);
-      return;
-    }
-
-    if (status === Brightness.PermissionStatus.UNDETERMINED || canAskAgain) {
-      const { status: nextStatus } = await Brightness.requestPermissionsAsync();
-      setHasBrightnessPermission(
-        nextStatus === Brightness.PermissionStatus.GRANTED
-      );
-      return;
-    }
-
-    setHasBrightnessPermission(false);
-    Alert.alert(
-      'Brightness Permission Required',
-      'To change screen brightness, the app requires permission. Please enable this in your device settings.',
-      [
-        { text: 'Cancel', style: 'cancel' },
-        { text: 'Open Settings', onPress: () => Linking.openSettings() },
-      ]
-    );
-  };
-
-  useEffect(() => {
-    requestCalendarPermission();
-    requestBrightnessPermission();
-  }, []);
-
-  useEffect(() => {
-    const subscription = AppState.addEventListener('change', (nextAppState) => {
-      if (nextAppState === 'active') {
-        requestCalendarPermission();
-        requestBrightnessPermission();
-      }
-    });
-
-    return () => {
-      subscription.remove();
-    };
-  }, []);
-
-  const sendMessage = async () => {
-    onMessageSend();
-    setUserInput('');
-    textInputRef.current?.clear();
-    try {
-      await llm.sendMessage(userInput);
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-    }
-  };
-
-  return !llm.isReady && !llm.error ? (
-    <Spinner
-      visible={true}
-      textContent={`Loading the model ${(llm.downloadProgress * 100).toFixed(0)} %`}
-    />
-  ) : (
-    <TouchableWithoutFeedback onPress={Keyboard.dismiss}>
-      <View style={styles.container}>
-        <KeyboardAvoidingView
-          style={{ ...styles.container }}
-          collapsable={false}
-          behavior={Platform.OS === 'ios' ? 'padding' : undefined}
-          keyboardVerticalOffset={Platform.OS === 'ios' ? 120 : 40}
-        >
-          <View style={styles.topContainer}>
-            <SWMIcon width={45} height={45} />
-          </View>
-          <ErrorBanner message={error} onDismiss={() => setError(null)} />
-          {llm.messageHistory.length ? (
-            <View style={styles.chatContainer}>
-              <Messages
-                chatHistory={llm.messageHistory}
-                llmResponse={llm.response}
-                isGenerating={llm.isGenerating}
-                deleteMessage={llm.deleteMessage}
-              />
-            </View>
-          ) : (
-            <View style={styles.helloMessageContainer}>
-              <Text style={styles.helloText}>Hello! 👋</Text>
-              <Text style={styles.bottomHelloText}>
-                I can use calendar! Ask me to check it or add an event for you!
-              </Text>
-              <SuggestedPrompts
-                prompts={SUGGESTED_PROMPTS}
-                onSelect={setUserInput}
-              />
-            </View>
-          )}
-
-          {!hasCalendarPermission && (
-            <TouchableOpacity
-              style={styles.permissionBanner}
-              onPress={requestCalendarPermission}
-            >
-              <Text style={styles.permissionBannerText}>
-                Calendar access is required.{' '}
-                <Text style={styles.permissionBannerLink}>Grant Access</Text>
-              </Text>
-            </TouchableOpacity>
-          )}
-          {!hasBrightnessPermission && (
-            <TouchableOpacity
-              style={styles.permissionBanner}
-              onPress={requestBrightnessPermission}
-            >
-              <Text style={styles.permissionBannerText}>
-                Brightness access is required.{' '}
-                <Text style={styles.permissionBannerLink}>Grant Access</Text>
-              </Text>
-            </TouchableOpacity>
-          )}
-
-          <ModelPicker
-            models={LLM_MODELS}
-            selectedModel={selectedModel}
-            onSelect={(m) => setSelectedModel(m)}
-            disabled={llm.isGenerating}
-          />
-          <StatsBar stats={stats} />
-          <View style={styles.bottomContainer}>
-            <TextInput
-              autoCorrect={false}
-              onFocus={() => setIsTextInputFocused(true)}
-              onBlur={() => setIsTextInputFocused(false)}
-              style={{
-                ...styles.textInput,
-                borderColor: isTextInputFocused
-                  ? ColorPalette.blueDark
-                  : ColorPalette.blueLight,
-              }}
-              placeholder={isTextInputFocused ? '' : 'Your message'}
-              placeholderTextColor={'#C1C6E5'}
-              multiline={true}
-              ref={textInputRef}
-              value={userInput}
-              onChangeText={(text: string) => setUserInput(text)}
-            />
-            {userInput && (
-              <TouchableOpacity
-                style={styles.sendChatTouchable}
-                onPress={async () => !llm.isGenerating && (await sendMessage())}
-              >
-                <SendIcon height={24} width={24} padding={4} margin={8} />
-              </TouchableOpacity>
-            )}
-            {llm.isGenerating && (
-              <TouchableOpacity
-                style={styles.sendChatTouchable}
-                onPress={llm.interrupt}
-              >
-                <PauseIcon height={24} width={24} padding={4} margin={8} />
-              </TouchableOpacity>
-            )}
-          </View>
-        </KeyboardAvoidingView>
-      </View>
-    </TouchableWithoutFeedback>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: { flex: 1, paddingBottom: Platform.OS === 'android' ? 20 : 0 },
-  keyboardAvoidingView: { flex: 1 },
-  topContainer: {
-    height: 68,
-    width: '100%',
-    alignItems: 'center',
-    justifyContent: 'center',
-  },
-  chatContainer: { flex: 10, width: '100%' },
-  textModelName: { color: ColorPalette.primary },
-  helloMessageContainer: {
-    flex: 10,
-    width: '100%',
-    alignItems: 'center',
-    justifyContent: 'center',
-  },
-  helloText: {
-    fontFamily: 'medium',
-    fontSize: 30,
-    color: ColorPalette.primary,
-  },
-  bottomHelloText: {
-    padding: 20,
-    fontFamily: 'regular',
-    fontSize: 20,
-    lineHeight: 28,
-    textAlign: 'center',
-    color: ColorPalette.primary,
-  },
-  bottomContainer: {
-    height: 100,
-    width: '100%',
-    flexDirection: 'row',
-    justifyContent: 'space-between',
-    alignItems: 'center',
-    paddingHorizontal: 16,
-  },
-  textInput: {
-    flex: 1,
-    borderWidth: 1,
-    borderRadius: 8,
-    lineHeight: 19.6,
-    fontFamily: 'regular',
-    fontSize: 14,
-    color: ColorPalette.primary,
-    padding: 16,
-  },
-  sendChatTouchable: {
-    height: '100%',
-    width: 48,
-    justifyContent: 'center',
-    alignItems: 'flex-end',
-  },
-  permissionBanner: {
-    backgroundColor: '#FFF3CD',
-    paddingVertical: 10,
-    paddingHorizontal: 16,
-    alignItems: 'center',
-  },
-  permissionBannerText: {
-    fontFamily: 'regular',
-    fontSize: 13,
-    color: '#856404',
-  },
-  permissionBannerLink: {
-    fontFamily: 'medium',
-    color: ColorPalette.blueDark,
-  },
-});
diff --git a/apps/llm/app/multimodal_llm/index.tsx b/apps/llm/app/multimodal_llm/index.tsx
deleted file mode 100644
index a7e5ef712a..0000000000
--- a/apps/llm/app/multimodal_llm/index.tsx
+++ /dev/null
@@ -1,585 +0,0 @@
-import { useContext, useEffect, useRef, useState } from 'react';
-import {
-  Image,
-  Keyboard,
-  KeyboardAvoidingView,
-  Platform,
-  StyleSheet,
-  Text,
-  TextInput,
-  TouchableOpacity,
-  TouchableWithoutFeedback,
-  View,
-} from 'react-native';
-import { launchImageLibrary } from 'react-native-image-picker';
-import {
-  AudioManager,
-  AudioRecorder,
-  AudioContext,
-} from 'react-native-audio-api';
-import { useIsFocused } from 'expo-router';
-import { useSafeAreaInsets } from 'react-native-safe-area-context';
-import { models, useLLM } from 'react-native-executorch';
-import SendIcon from '../../assets/icons/send_icon.svg';
-import PauseIcon from '../../assets/icons/pause_icon.svg';
-import ColorPalette from '../../colors';
-import Messages from '../../components/Messages';
-import Spinner from '../../components/Spinner';
-import { GeneratingContext } from '../../context';
-import SuggestedPrompts from '../../components/SuggestedPrompts';
-import ErrorBanner from '../../components/ErrorBanner';
-import AudioWaveform from '../../components/AudioWaveform';
-
-const SUGGESTED_PROMPTS = [
-  "What's in this image?",
-  'Describe this scene in detail',
-  'What objects can you see?',
-  'What text appears in this image?',
-  'Transcribe the audio',
-];
-import { useLLMStats } from '../../hooks/useLLMStats';
-import { StatsBar } from '../../components/StatsBar';
-
-export default function MultimodalLLMScreenWrapper() {
-  const isFocused = useIsFocused();
-  return isFocused ? <MultimodalLLMScreen /> : null;
-}
-
-function MultimodalLLMScreen() {
-  const { bottom } = useSafeAreaInsets();
-  const [imageUri, setImageUri] = useState<string | null>(null);
-  const [userInput, setUserInput] = useState('');
-  const [isTextInputFocused, setIsTextInputFocused] = useState(false);
-  const textInputRef = useRef<TextInput>(null);
-  const { setGlobalGenerating } = useContext(GeneratingContext);
-
-  const [audioBuffer, setAudioBuffer] = useState<Float32Array | null>(null);
-  const [audioLabel, setAudioLabel] = useState<string | null>(null);
-  const [audioUrl, setAudioUrl] = useState('');
-  const [isFetchingAudio, setIsFetchingAudio] = useState(false);
-  const [isRecording, setIsRecording] = useState(false);
-  const [hasMicPermission, setHasMicPermission] = useState(false);
-  const recorder = useRef(new AudioRecorder());
-  const recordChunks = useRef<Float32Array[]>([]);
-
-  const [error, setError] = useState<string | null>(null);
-  const model = models.llm.gemma4_e2b_multimodal();
-  const vlm = useLLM({ model: model });
-  const tokenCount = vlm.isReady ? vlm.getGeneratedTokenCount() : 0;
-  const { stats, onMessageSend } = useLLMStats(
-    vlm.response,
-    vlm.isGenerating,
-    tokenCount
-  );
-
-  useEffect(() => {
-    setGlobalGenerating(vlm.isGenerating);
-  }, [vlm.isGenerating, setGlobalGenerating]);
-
-  // Updated to use local error state
-  useEffect(() => {
-    if (vlm.error) setError(String(vlm.error));
-  }, [vlm.error]);
-
-  useEffect(() => {
-    AudioManager.setAudioSessionOptions({
-      iosCategory: 'playAndRecord',
-      iosMode: 'spokenAudio',
-      iosOptions: ['allowBluetoothHFP', 'defaultToSpeaker'],
-    });
-    (async () => {
-      const status = await AudioManager.requestRecordingPermissions();
-      setHasMicPermission(status === 'Granted');
-    })();
-
-    return () => {
-      if (vlm.isGenerating) vlm.interrupt();
-      // eslint-disable-next-line react-hooks/exhaustive-deps
-      recorder.current.stop();
-      AudioManager.setAudioSessionActivity(false);
-    };
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []);
-
-  const loadAudioFromUrl = async () => {
-    const url = audioUrl.trim();
-    if (!url) return;
-    setIsFetchingAudio(true);
-    try {
-      const ctx = new AudioContext({ sampleRate: 16000 });
-      const decoded = await ctx.decodeAudioData(url);
-      const pcm = decoded.getChannelData(0);
-      const name = url.split('/').pop() || 'audio';
-      setAudioBuffer(pcm);
-      setAudioLabel(`${name} · ${(pcm.length / 16000).toFixed(1)}s`);
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-    } finally {
-      setIsFetchingAudio(false);
-    }
-  };
-
-  const startRecording = async () => {
-    if (!hasMicPermission) {
-      setError('Microphone permission denied. Please enable it in Settings.');
-      return;
-    }
-    recordChunks.current = [];
-    const sampleRate = 16000;
-    recorder.current.onAudioReady(
-      { sampleRate, bufferLength: 0.1 * sampleRate, channelCount: 1 },
-      ({ buffer }) => {
-        recordChunks.current.push(new Float32Array(buffer.getChannelData(0)));
-      }
-    );
-    try {
-      const ok = await AudioManager.setAudioSessionActivity(true);
-      if (!ok) {
-        setError('Cannot start audio session');
-        return;
-      }
-      const result = recorder.current.start();
-      if (result.status === 'error') {
-        setError(`Recording problems: ${result.message}`);
-        return;
-      }
-      setIsRecording(true);
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-    }
-  };
-
-  const stopRecording = () => {
-    recorder.current.stop();
-    setIsRecording(false);
-    const total = recordChunks.current.reduce((n, c) => n + c.length, 0);
-    if (total === 0) return;
-    const pcm = new Float32Array(total);
-    let off = 0;
-    for (const c of recordChunks.current) {
-      pcm.set(c, off);
-      off += c.length;
-    }
-    recordChunks.current = [];
-    setAudioBuffer(pcm);
-    setAudioLabel(`Recording · ${(pcm.length / 16000).toFixed(1)}s`);
-  };
-
-  const clearAudio = () => {
-    setAudioBuffer(null);
-    setAudioLabel(null);
-  };
-
-  const pickImage = async () => {
-    try {
-      const result = await launchImageLibrary({ mediaType: 'photo' });
-      if (result.assets && result.assets.length > 0) {
-        const uri = result.assets[0]?.uri;
-        if (uri) setImageUri(uri);
-      }
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-    }
-  };
-
-  const sendMessage = async () => {
-    if (!(imageUri || audioBuffer || userInput.trim()) || vlm.isGenerating)
-      return;
-    onMessageSend();
-    const text = userInput.trim();
-    setUserInput('');
-    textInputRef.current?.clear();
-    Keyboard.dismiss();
-    const currentImageUri = imageUri;
-    const currentAudio = audioBuffer;
-    setImageUri(null);
-    setAudioBuffer(null);
-    setAudioLabel(null);
-    try {
-      const media =
-        currentImageUri || currentAudio
-          ? {
-              ...(currentImageUri ? { imagePath: currentImageUri } : {}),
-              ...(currentAudio ? { audioBuffer: currentAudio } : {}),
-            }
-          : undefined;
-      await vlm.sendMessage(text, media);
-    } catch (e) {
-      // Updated to set UI error instead of just console.error
-      setError(e instanceof Error ? e.message : String(e));
-    }
-  };
-
-  // Updated Spinner check so it doesn't block the ErrorBanner if loading fails
-  if (!vlm.isReady && !vlm.error) {
-    return (
-      <Spinner
-        visible={true}
-        textContent={`Loading model ${(vlm.downloadProgress * 100).toFixed(0)}%`}
-      />
-    );
-  }
-
-  return (
-    <TouchableWithoutFeedback onPress={Keyboard.dismiss}>
-      <KeyboardAvoidingView
-        style={styles.container}
-        collapsable={false}
-        behavior={Platform.OS === 'ios' ? 'padding' : undefined}
-        keyboardVerticalOffset={Platform.OS === 'ios' ? 120 : 40}
-      >
-        <View style={styles.container}>
-          {/* Injected ErrorBanner here */}
-          <ErrorBanner message={error} onDismiss={() => setError(null)} />
-
-          {vlm.messageHistory.length ? (
-            <View style={styles.chatContainer}>
-              <Messages
-                chatHistory={vlm.messageHistory}
-                llmResponse={vlm.response}
-                isGenerating={vlm.isGenerating}
-                deleteMessage={vlm.deleteMessage}
-              />
-            </View>
-          ) : (
-            <View style={styles.helloMessageContainer}>
-              <Text style={styles.helloText}>Hello! 👋</Text>
-              <Text style={styles.bottomHelloText}>
-                {model.capabilities.find((c) => c === 'audio')
-                  ? 'Say hi, or pick an image, and ask me anything about it.'
-                  : 'Pick an image and ask me anything about it.'}
-              </Text>
-              <SuggestedPrompts
-                prompts={SUGGESTED_PROMPTS}
-                onSelect={setUserInput}
-              />
-            </View>
-          )}
-
-          {/* Image thumbnail strip */}
-          {imageUri && (
-            <TouchableOpacity
-              style={styles.imageThumbnailContainer}
-              onPress={pickImage}
-            >
-              <Image
-                source={{ uri: imageUri }}
-                style={styles.imageThumbnail}
-                resizeMode="cover"
-              />
-              <Text style={styles.imageThumbnailHint}>Tap to change</Text>
-            </TouchableOpacity>
-          )}
-
-          {/* Audio URL input */}
-          <View style={styles.audioUrlRow}>
-            <TextInput
-              placeholder="Audio URL (mp3/wav/…)"
-              placeholderTextColor="#C1C6E5"
-              style={styles.audioUrlInput}
-              value={audioUrl}
-              onChangeText={setAudioUrl}
-              autoCapitalize="none"
-              autoCorrect={false}
-            />
-            <TouchableOpacity
-              style={[
-                styles.audioUrlButton,
-                (!audioUrl.trim() || isFetchingAudio || vlm.isGenerating) &&
-                  styles.disabled,
-              ]}
-              onPress={loadAudioFromUrl}
-              disabled={!audioUrl.trim() || isFetchingAudio || vlm.isGenerating}
-            >
-              <Text style={styles.audioUrlButtonText}>
-                {isFetchingAudio ? '…' : 'Load'}
-              </Text>
-            </TouchableOpacity>
-          </View>
-
-          {/* Audio attachment strip */}
-          {audioLabel && (
-            <View style={styles.audioAttachmentContainer}>
-              <View style={styles.audioAttachmentRow}>
-                <Text style={styles.audioAttachmentText}>🎵 {audioLabel}</Text>
-                <TouchableOpacity onPress={clearAudio}>
-                  <Text style={styles.audioAttachmentClear}>✕</Text>
-                </TouchableOpacity>
-              </View>
-              <AudioWaveform
-                buffer={audioBuffer}
-                style={styles.audioWaveform}
-              />
-            </View>
-          )}
-
-          <StatsBar stats={stats} />
-          <View
-            style={[
-              styles.bottomContainer,
-              Platform.OS === 'android' && {
-                paddingBottom: bottom || 16,
-                height: 100 + (bottom || 16),
-              },
-            ]}
-          >
-            {/* Image picker button */}
-            <TouchableOpacity
-              style={styles.imageButton}
-              onPress={pickImage}
-              disabled={vlm.isGenerating}
-            >
-              <Text style={styles.imageButtonText}>📷</Text>
-            </TouchableOpacity>
-
-            {/* Mic record / stop button */}
-            <TouchableOpacity
-              style={styles.imageButton}
-              onPress={isRecording ? stopRecording : startRecording}
-              disabled={vlm.isGenerating}
-            >
-              <Text style={styles.imageButtonText}>
-                {isRecording ? '⏹️' : '🎤'}
-              </Text>
-            </TouchableOpacity>
-
-            <TextInput
-              autoCorrect={false}
-              ref={textInputRef}
-              onFocus={() => setIsTextInputFocused(true)}
-              onBlur={() => setIsTextInputFocused(false)}
-              style={[
-                styles.textInput,
-                {
-                  borderColor: isTextInputFocused
-                    ? ColorPalette.blueDark
-                    : ColorPalette.blueLight,
-                },
-              ]}
-              placeholder={imageUri ? 'Ask about the image…' : 'Your message'}
-              placeholderTextColor="#C1C6E5"
-              multiline
-              value={userInput}
-              onChangeText={setUserInput}
-            />
-
-            {(imageUri || audioBuffer || userInput.trim()) &&
-              !vlm.isGenerating && (
-                <TouchableOpacity
-                  style={styles.sendChatTouchable}
-                  onPress={sendMessage}
-                >
-                  <SendIcon height={24} width={24} padding={4} margin={8} />
-                </TouchableOpacity>
-              )}
-            {vlm.isGenerating && (
-              <TouchableOpacity
-                style={styles.sendChatTouchable}
-                onPress={vlm.interrupt}
-              >
-                <PauseIcon height={24} width={24} padding={4} margin={8} />
-              </TouchableOpacity>
-            )}
-          </View>
-        </View>
-      </KeyboardAvoidingView>
-    </TouchableWithoutFeedback>
-  );
-}
-
-const styles = StyleSheet.create({
-  // Setup phase
-  setupContainer: {
-    flex: 1,
-    padding: 24,
-    backgroundColor: '#fff',
-    justifyContent: 'center',
-  },
-  setupTitle: {
-    fontSize: 20,
-    fontFamily: 'medium',
-    color: ColorPalette.primary,
-    marginBottom: 8,
-  },
-  setupHint: {
-    fontSize: 13,
-    fontFamily: 'regular',
-    color: ColorPalette.blueDark,
-    marginBottom: 32,
-    lineHeight: 18,
-  },
-  filePickerRow: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    borderWidth: 1,
-    borderColor: ColorPalette.blueLight,
-    borderRadius: 10,
-    padding: 14,
-    marginBottom: 12,
-    backgroundColor: '#fafbff',
-  },
-  filePickerInfo: { flex: 1 },
-  filePickerLabel: {
-    fontSize: 12,
-    fontFamily: 'medium',
-    color: ColorPalette.blueDark,
-    marginBottom: 2,
-  },
-  filePickerValue: { fontSize: 14, fontFamily: 'regular' },
-  filePickerValueSet: { color: ColorPalette.primary },
-  filePickerValueEmpty: { color: ColorPalette.blueLight },
-  filePickerChevron: {
-    fontSize: 24,
-    color: ColorPalette.blueLight,
-    marginLeft: 8,
-  },
-  loadButton: {
-    marginTop: 16,
-    backgroundColor: ColorPalette.strongPrimary,
-    borderRadius: 10,
-    padding: 14,
-    alignItems: 'center',
-  },
-  loadButtonDisabled: { backgroundColor: ColorPalette.blueLight },
-  loadButtonText: { color: '#fff', fontFamily: 'medium', fontSize: 15 },
-
-  // Chat phase
-  container: { flex: 1 },
-  chatContainer: { flex: 10, width: '100%' },
-  helloMessageContainer: {
-    flex: 10,
-    width: '100%',
-    alignItems: 'center',
-    justifyContent: 'center',
-    overflow: 'hidden',
-  },
-  helloText: {
-    fontFamily: 'medium',
-    fontSize: 30,
-    color: ColorPalette.primary,
-  },
-  bottomHelloText: {
-    fontFamily: 'regular',
-    fontSize: 20,
-    lineHeight: 28,
-    textAlign: 'center',
-    color: ColorPalette.primary,
-    paddingHorizontal: 24,
-  },
-  imageThumbnailContainer: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    paddingHorizontal: 16,
-    paddingVertical: 6,
-    gap: 8,
-  },
-  imageThumbnail: {
-    width: 48,
-    height: 48,
-    borderRadius: 8,
-    borderWidth: 1,
-    borderColor: ColorPalette.blueLight,
-  },
-  imageThumbnailHint: {
-    fontSize: 12,
-    fontFamily: 'regular',
-    color: ColorPalette.blueDark,
-  },
-  audioAttachmentContainer: {
-    flexDirection: 'column',
-    paddingHorizontal: 16,
-    paddingVertical: 8,
-    marginHorizontal: 16,
-    marginBottom: 4,
-    borderRadius: 8,
-    borderWidth: 1,
-    borderColor: ColorPalette.blueLight,
-    backgroundColor: '#fafbff',
-  },
-  audioAttachmentRow: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    justifyContent: 'space-between',
-  },
-  audioAttachmentText: {
-    fontSize: 13,
-    fontFamily: 'regular',
-    color: ColorPalette.blueDark,
-  },
-  audioAttachmentClear: {
-    fontSize: 16,
-    color: ColorPalette.blueDark,
-    paddingHorizontal: 8,
-  },
-  audioWaveform: {
-    marginTop: 6,
-    minWidth: 0,
-  },
-  audioUrlRow: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    marginHorizontal: 16,
-    marginBottom: 4,
-  },
-  audioUrlInput: {
-    flex: 1,
-    padding: 10,
-    borderTopLeftRadius: 8,
-    borderBottomLeftRadius: 8,
-    borderWidth: 1,
-    borderColor: ColorPalette.blueLight,
-    borderRightWidth: 0,
-    fontFamily: 'regular',
-    fontSize: 13,
-    color: ColorPalette.primary,
-  },
-  audioUrlButton: {
-    paddingVertical: 10,
-    paddingHorizontal: 16,
-    backgroundColor: ColorPalette.strongPrimary,
-    borderTopRightRadius: 8,
-    borderBottomRightRadius: 8,
-    justifyContent: 'center',
-    alignItems: 'center',
-  },
-  audioUrlButtonText: {
-    color: '#fff',
-    fontFamily: 'medium',
-    fontSize: 13,
-  },
-  disabled: {
-    opacity: 0.5,
-  },
-  bottomContainer: {
-    height: 100,
-    width: '100%',
-    flexDirection: 'row',
-    justifyContent: 'space-between',
-    alignItems: 'center',
-    paddingHorizontal: 16,
-  },
-  imageButton: {
-    width: 40,
-    height: 40,
-    justifyContent: 'center',
-    alignItems: 'center',
-    marginRight: 4,
-  },
-  imageButtonText: { fontSize: 22 },
-  textInput: {
-    flex: 1,
-    borderWidth: 1,
-    borderRadius: 8,
-    lineHeight: 19.6,
-    fontFamily: 'regular',
-    fontSize: 14,
-    color: ColorPalette.primary,
-    padding: 16,
-  },
-  sendChatTouchable: {
-    height: '100%',
-    width: 48,
-    justifyContent: 'center',
-    alignItems: 'flex-end',
-  },
-});
diff --git a/apps/llm/app/privacy_filter/index.tsx b/apps/llm/app/privacy_filter/index.tsx
deleted file mode 100644
index 05870921a1..0000000000
--- a/apps/llm/app/privacy_filter/index.tsx
+++ /dev/null
@@ -1,255 +0,0 @@
-import { useMemo, useState } from 'react';
-import {
-  ActivityIndicator,
-  ScrollView,
-  StyleSheet,
-  Text,
-  TouchableOpacity,
-  View,
-} from 'react-native';
-import { useIsFocused } from 'expo-router';
-import { useSafeAreaInsets } from 'react-native-safe-area-context';
-import {
-  models,
-  PiiEntity,
-  PrivacyFilterModelSources,
-  usePrivacyFilter,
-} from 'react-native-executorch';
-
-const privacyFilter = models.privacy_filter;
-import ColorPalette from '../../colors';
-import { ModelOption, ModelPicker } from '../../components/ModelPicker';
-import {
-  buildSegments,
-  colorForLabel,
-  matchEntities,
-} from '../../utils/piiMatching';
-
-/* cspell:disable */
-// Sample tuned for the OpenAI base model — exercises the 8 entity types it
-// recognizes (person, email, phone, account_number, address, date, url,
-// secret).
-const OPENAI_SAMPLE = `My name is Sarah Chen and I work as a senior engineer at Acme Corp. You can reach me at sarah.chen@acmecorp.io or call my direct line at (415) 923-0847. For billing inquiries, my account number is ACC-8821-4490-3371.
-
-I've been living at 17 Birchwood Lane, Portland, OR 97201 since October 3rd, 2019. Before that I was at 8 Rue de Rivoli, Paris, 75001, France. My personal website is https://sarahchen.dev and my GitHub is https://github.com/schen-eng. Feel free to connect — I usually respond within a business day.
-
-My date of birth is June 12, 1991, and my backup email is s.chen.personal@gmail.com in case the primary address is unreachable. This message also contains a confidential API key: sk-T93kXpLm2NvBqR7dYwZ4. Please do not share it outside the team. You can also reach my colleague James Okonkwo at j.okonkwo@acmecorp.io or at his mobile +44 7911 123456.`;
-// Sample tuned for the OpenMed Nemotron model — covers categories the base
-// OpenAI model doesn't have (medical, financial, technical, demographic).
-
-const NEMOTRON_SAMPLE = `Patient intake for Maria Lopez, female, age 47, blood type O+, born 1978-05-12. MRN 994-2210-AB; health plan beneficiary number HPBN-552-9931 with Aetna. SSN 412-55-7821, national ID DNI 88-7762-X. Primary occupation: registered nurse, currently employed full-time at Mercy General. Religion: Catholic; political view: independent.
-
-Reach her at maria.lopez@example.com or +1 (415) 555-0142. Mailing address: 84 Cedar Hill Road, Apt 3B, Berkeley, CA 94703, United States. Vehicle plate 7XKL922; driver license CA-D1294883.
-
-Payment for last visit: Visa ending 4992-1133-7820-4419, expires 11/28, CVV 884. Bank routing 021000089, SWIFT BIC CHASUS33. Employer EIN tax ID 47-3320118. Customer ID CUST-553201, employee ID EMP-A0093.
-
-Workstation MAC 3C:22:FB:8E:01:9A, IPv4 10.0.42.118, device IMEI 359888061234560. Service account API key sk-live-Tn8x3pLm2NvBqR7dYwZ4QF, password Hunter2!Spring. Session cookie sid=eyJ1c2VyIjoiOTk0MjIxMCJ9.`;
-/* cspell:enable */
-
-const MODEL_OPTIONS: ModelOption<PrivacyFilterModelSources>[] = [
-  {
-    label: 'OpenAI Privacy Filter (8 entities)',
-    value: privacyFilter.openai(),
-  },
-  {
-    label: 'OpenMed Nemotron (55 entities)',
-    value: privacyFilter.nemotron(),
-  },
-];
-
-// Pick the right sample to display/run based on the active model.
-function sampleFor(model: PrivacyFilterModelSources): string {
-  return model.modelName === privacyFilter.nemotron().modelName
-    ? NEMOTRON_SAMPLE
-    : OPENAI_SAMPLE;
-}
-
-function HighlightedText({
-  source,
-  entities,
-}: {
-  source: string;
-  entities: PiiEntity[];
-}) {
-  const segments = useMemo(
-    () => buildSegments(source, matchEntities(source, entities)),
-    [source, entities]
-  );
-  return (
-    <Text style={styles.sampleText}>
-      {segments.map((seg, i) =>
-        seg.label ? (
-          <Text
-            key={i}
-            style={[
-              styles.highlight,
-              { backgroundColor: colorForLabel(seg.label) },
-            ]}
-          >
-            {seg.text}
-          </Text>
-        ) : (
-          <Text key={i}>{seg.text}</Text>
-        )
-      )}
-    </Text>
-  );
-}
-
-function PrivacyFilterScreen() {
-  const { bottom } = useSafeAreaInsets();
-  const [entities, setEntities] = useState<PiiEntity[] | null>(null);
-  const [runError, setRunError] = useState<string | null>(null);
-  const [inferenceMs, setInferenceMs] = useState<number | null>(null);
-  const [selectedModel, setSelectedModel] = useState<PrivacyFilterModelSources>(
-    privacyFilter.openai()
-  );
-
-  const filter = usePrivacyFilter({ model: selectedModel });
-  const sampleText = sampleFor(selectedModel);
-
-  const onRun = async () => {
-    setRunError(null);
-    setEntities(null);
-    setInferenceMs(null);
-    const startedAt = Date.now();
-    try {
-      const result = await filter.generate(sampleText);
-      const elapsed = Date.now() - startedAt;
-      setInferenceMs(elapsed);
-      setEntities(result);
-    } catch (e) {
-      setRunError(e instanceof Error ? e.message : String(e));
-    }
-  };
-
-  const disabled = !filter.isReady || filter.isGenerating;
-
-  return (
-    <View style={[styles.container, { paddingBottom: bottom + 8 }]}>
-      <ModelPicker
-        models={MODEL_OPTIONS}
-        selectedModel={selectedModel}
-        onSelect={(m) => {
-          setEntities(null);
-          setRunError(null);
-          setInferenceMs(null);
-          setSelectedModel(m);
-        }}
-        label="Model"
-        disabled={filter.isGenerating}
-      />
-
-      {filter.error && (
-        <View style={styles.errorBanner}>
-          <Text style={styles.errorText}>
-            Load error: {filter.error.message}
-          </Text>
-        </View>
-      )}
-
-      {!filter.isReady && !filter.error && (
-        <View style={styles.centerBlock}>
-          <ActivityIndicator color={ColorPalette.primary} />
-          <Text style={styles.muted}>
-            Downloading model…{' '}
-            {Math.round((filter.downloadProgress ?? 0) * 100)}%
-          </Text>
-        </View>
-      )}
-
-      <ScrollView style={styles.textBox}>
-        {entities ? (
-          <HighlightedText source={sampleText} entities={entities} />
-        ) : (
-          <Text style={styles.sampleText}>{sampleText}</Text>
-        )}
-      </ScrollView>
-
-      <TouchableOpacity
-        style={[styles.runButton, disabled && styles.buttonDisabled]}
-        onPress={onRun}
-        disabled={disabled}
-      >
-        {filter.isGenerating ? (
-          <ActivityIndicator color="#fff" />
-        ) : (
-          <Text style={styles.runButtonText}>
-            Detect PII
-            {inferenceMs !== null && ` · ${inferenceMs} ms`}
-          </Text>
-        )}
-      </TouchableOpacity>
-
-      {runError && (
-        <View style={styles.errorBanner}>
-          <Text style={styles.errorText}>Run error: {runError}</Text>
-        </View>
-      )}
-    </View>
-  );
-}
-
-export default function PrivacyFilterScreenWrapper() {
-  const isFocused = useIsFocused();
-  return isFocused ? <PrivacyFilterScreen /> : null;
-}
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    padding: 16,
-    backgroundColor: '#fff',
-    gap: 10,
-  },
-  textBox: {
-    flex: 1,
-    borderWidth: 1,
-    borderColor: '#e0e0e0',
-    borderRadius: 8,
-    padding: 10,
-  },
-  sampleText: {
-    fontSize: 13,
-    color: '#222',
-    lineHeight: 19,
-  },
-  highlight: {
-    fontWeight: '600',
-    borderRadius: 3,
-  },
-  runButton: {
-    backgroundColor: ColorPalette.primary,
-    borderRadius: 8,
-    paddingVertical: 12,
-    alignItems: 'center',
-  },
-  runButtonText: {
-    color: '#fff',
-    fontSize: 15,
-    fontWeight: '600',
-  },
-  buttonDisabled: {
-    opacity: 0.5,
-  },
-  centerBlock: {
-    alignItems: 'center',
-    gap: 6,
-    paddingVertical: 8,
-  },
-  muted: {
-    color: '#666',
-    fontSize: 12,
-  },
-  errorBanner: {
-    backgroundColor: '#fdecea',
-    borderColor: '#f5c6cb',
-    borderWidth: 1,
-    borderRadius: 6,
-    padding: 8,
-  },
-  errorText: {
-    color: '#a94442',
-    fontSize: 12,
-  },
-});
diff --git a/apps/llm/assets/fonts/Aeonik-Medium.otf b/apps/llm/assets/fonts/Aeonik-Medium.otf
deleted file mode 100644
index cd9981f439..0000000000
Binary files a/apps/llm/assets/fonts/Aeonik-Medium.otf and /dev/null differ
diff --git a/apps/llm/assets/fonts/Aeonik-Regular.otf b/apps/llm/assets/fonts/Aeonik-Regular.otf
deleted file mode 100644
index 9bd378ed2b..0000000000
Binary files a/apps/llm/assets/fonts/Aeonik-Regular.otf and /dev/null differ
diff --git a/apps/llm/assets/icons/adaptive-icon.png b/apps/llm/assets/icons/adaptive-icon.png
deleted file mode 100644
index 03d6f6b6c6..0000000000
Binary files a/apps/llm/assets/icons/adaptive-icon.png and /dev/null differ
diff --git a/apps/llm/assets/icons/executorch.svg b/apps/llm/assets/icons/executorch.svg
deleted file mode 100644
index e548ea4201..0000000000
--- a/apps/llm/assets/icons/executorch.svg
+++ /dev/null
@@ -1,9 +0,0 @@
-<svg width="65" height="64" viewBox="0 0 65 64" fill="none" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
-<path d="M0.5 4C0.5 1.79086 2.29086 0 4.5 0H60.5C62.7091 0 64.5 1.79086 64.5 4V60C64.5 62.2091 62.7091 64 60.5 64H4.5C2.29086 64 0.5 62.2091 0.5 60V4Z" fill="url(#pattern0_13229_4194)"/>
-<defs>
-<pattern id="pattern0_13229_4194" patternContentUnits="objectBoundingBox" width="1" height="1">
-<use xlink:href="#image0_13229_4194" transform="translate(-0.000263435) scale(0.00052687)"/>
-</pattern>
-<image id="image0_13229_4194" width="1899" height="1898" preserveAspectRatio="none" xlink:href="data:image/png;base64,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"/>
-</defs>
-</svg>
diff --git a/apps/llm/assets/icons/favicon.png b/apps/llm/assets/icons/favicon.png
deleted file mode 100644
index e75f697b18..0000000000
Binary files a/apps/llm/assets/icons/favicon.png and /dev/null differ
diff --git a/apps/llm/assets/icons/icon.png b/apps/llm/assets/icons/icon.png
deleted file mode 100644
index a0b1526fc7..0000000000
Binary files a/apps/llm/assets/icons/icon.png and /dev/null differ
diff --git a/apps/llm/assets/icons/llama_icon.svg b/apps/llm/assets/icons/llama_icon.svg
deleted file mode 100644
index 99e29696ec..0000000000
--- a/apps/llm/assets/icons/llama_icon.svg
+++ /dev/null
@@ -1,48 +0,0 @@
-<?xml version="1.0" encoding="iso-8859-1"?>
-<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
-<svg fill="#000000" height="800px" width="800px" version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" 
-	 viewBox="0 0 512 512" xml:space="preserve">
-<g>
-	<g>
-		<path d="M451.616,165.935c19.927-17.358,32.558-42.887,32.558-71.326C484.174,42.441,441.732,0,389.565,0H372.87v49.641
-			c-4.068-1.719-8.208-3.094-12.158-4.403c-5.339-1.769-10.384-3.439-14.346-5.621c-3.071-1.691-6.736-4.993-10.616-8.49
-			c-7.811-7.041-17.534-15.803-30.946-18.904c-3.131-0.724-6.467-1.092-9.916-1.092c-8.123,0-15.657,1.94-22.944,3.818
-			c-5.862,1.509-11.4,2.936-15.944,2.936c-4.545,0-10.081-1.426-15.943-2.936c-7.286-1.878-14.821-3.818-22.945-3.818
-			c-3.448,0-6.784,0.367-9.915,1.092c-13.417,3.102-23.138,11.865-30.95,18.906c-3.879,3.498-7.543,6.8-10.614,8.49
-			c-3.961,2.182-9.006,3.852-14.345,5.621c-3.95,1.309-8.09,2.685-12.157,4.402V0h-16.696C70.268,0,27.826,42.441,27.826,94.609
-			c0,28.439,12.631,53.968,32.558,71.326c-26.002,14.159-43.688,41.737-43.688,73.37c0,46.03,37.448,83.478,83.478,83.478
-			c0.467,0,0.927-0.028,1.392-0.034c9.055,52.429,26.66,97.313,51.314,130.543C180.966,491.15,217.589,512,256,512
-			s75.032-20.85,103.12-58.709c24.653-33.23,42.258-78.115,51.312-130.543c0.465,0.007,0.926,0.034,1.394,0.034
-			c46.03,0,83.478-37.448,83.478-83.478C495.304,207.672,477.618,180.094,451.616,165.935z M406.261,35.705
-			c25.667,7.285,44.522,30.933,44.522,58.903s-18.855,51.619-44.522,58.903V35.705z M146.014,84.12
-			c2.038-2.636,9.334-5.052,15.771-7.184c6.234-2.064,13.3-4.404,19.953-8.067c6.453-3.553,11.746-8.324,16.865-12.938
-			c5.717-5.153,11.117-10.021,16.117-11.177c0.668-0.155,1.471-0.233,2.391-0.233c3.893,0,9.102,1.341,14.618,2.761
-			c7.264,1.871,15.497,3.991,24.272,3.991c8.775,0,17.008-2.12,24.272-3.991c5.515-1.42,10.724-2.761,14.615-2.761
-			c0.919,0,1.724,0.078,2.393,0.233c4.998,1.155,10.397,6.022,16.114,11.174c5.12,4.615,10.414,9.387,16.867,12.939
-			c6.653,3.663,13.718,6.004,19.952,8.067c6.438,2.133,13.734,4.549,15.772,7.185c3.213,4.154,2.587,12.611,1.923,21.563
-			c-0.297,4.011-0.604,8.161-0.604,12.375s0.307,8.363,0.604,12.375c0.663,8.951,1.291,17.408-1.923,21.563
-			c-2.037,2.635-9.333,5.051-15.77,7.182c-6.234,2.064-13.301,4.404-19.954,8.067c-6.455,3.553-11.748,8.326-16.867,12.94
-			c-5.717,5.152-11.115,10.02-16.114,11.175c-0.668,0.155-1.471,0.233-2.39,0.233h-0.001c-3.892,0-9.102-1.342-14.618-2.761
-			c-7.264-1.871-15.497-3.991-24.272-3.991c-8.775,0-17.008,2.12-24.272,3.991c-5.515,1.42-10.724,2.761-14.615,2.761
-			c-0.919,0-1.724-0.078-2.393-0.233c-4.998-1.155-10.397-6.023-16.114-11.175c-5.119-4.614-10.413-9.385-16.865-12.938
-			c-6.654-3.664-13.72-6.005-19.956-8.068c-6.437-2.131-13.733-4.548-15.771-7.184c-3.213-4.154-2.587-12.611-1.923-21.563
-			c0.297-4.011,0.605-8.161,0.605-12.375c-0.002-4.214-0.309-8.362-0.608-12.375C143.427,96.731,142.799,88.274,146.014,84.12z
-			 M105.739,35.705v117.807c-25.668-7.285-44.522-30.933-44.522-58.903S80.071,42.99,105.739,35.705z M100.174,189.217
-			c21.766,0,40.322,13.959,47.215,33.391H52.959C59.851,203.176,78.408,189.217,100.174,189.217z M100.174,289.391
-			c-21.766,0-40.323-13.959-47.215-33.391h32.539c3.922,3.453,9.05,5.565,14.674,5.565h0.002c5.624,0,10.752-2.113,14.675-5.565
-			h32.54C140.497,275.433,121.94,289.391,100.174,289.391z M332.302,433.396c-8.775,11.828-20.964,24.952-36.425,34.002
-			c-10.735-0.539-22.742-4.748-23.159-37.148c8.212-7.4,15.358-18.806,18.899-29.555c2.703-9.071-4.282-16.577-15.583-16.696
-			c-13.357,0-26.713,0-40.07,0c-11.3,0.119-18.285,7.625-15.583,16.696c3.542,10.747,10.686,22.154,18.898,29.555
-			c-0.416,32.401-12.424,36.609-23.159,37.148c-15.461-9.05-27.65-22.174-36.425-34.002c-21.799-29.383-37.414-69.941-45.49-117.895
-			c29.108-13.054,49.446-42.286,49.446-76.197c0-12.232-2.667-23.847-7.414-34.326c0.003,0.004,0.008,0.008,0.011,0.011
-			c7.811,7.04,17.534,15.803,30.947,18.904c3.131,0.724,6.467,1.091,9.916,1.091c8.123,0,15.657-1.94,22.944-3.818
-			c5.862-1.509,11.4-2.936,15.944-2.936c4.543,0,10.082,1.426,15.944,2.936c7.286,1.877,14.821,3.818,22.944,3.818
-			c0.001,0,0.001,0,0.001,0c3.448,0,6.784-0.367,9.915-1.091c13.416-3.102,23.137-11.865,30.947-18.905
-			c0.003-0.003,0.007-0.006,0.009-0.009c-4.748,10.478-7.414,22.093-7.414,34.325c0,33.911,20.336,63.143,49.444,76.196
-			C369.716,363.454,354.103,404.013,332.302,433.396z M411.826,289.391c-21.766,0-40.323-13.959-47.215-33.391h32.539
-			c3.922,3.453,9.05,5.565,14.674,5.565h0.002c5.624,0,10.752-2.113,14.675-5.565h32.54
-			C452.149,275.433,433.592,289.391,411.826,289.391z M364.611,222.609c6.892-19.433,25.45-33.391,47.215-33.391
-			c21.766,0,40.323,13.959,47.215,33.391H364.611z"/>
-	</g>
-</g>
-</svg>
\ No newline at end of file
diff --git a/apps/llm/assets/icons/mic_icon.svg b/apps/llm/assets/icons/mic_icon.svg
deleted file mode 100644
index 955808bfba..0000000000
--- a/apps/llm/assets/icons/mic_icon.svg
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?><!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
-<svg width="800px" height="800px" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M20 12V13C20 17.4183 16.4183 21 12 21C7.58172 21 4 17.4183 4 13V12M12 17C9.79086 17 8 15.2091 8 13V7C8 4.79086 9.79086 3 12 3C14.2091 3 16 4.79086 16 7V13C16 15.2091 14.2091 17 12 17Z" stroke="#000000" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
-</svg>
\ No newline at end of file
diff --git a/apps/llm/assets/icons/pause_icon.svg b/apps/llm/assets/icons/pause_icon.svg
deleted file mode 100644
index 2f5164d284..0000000000
--- a/apps/llm/assets/icons/pause_icon.svg
+++ /dev/null
@@ -1,12 +0,0 @@
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-
-<!-- Uploaded to: SVG Repo, www.svgrepo.com, Transformed by: SVG Repo Mixer Tools -->
-<svg width="800px" height="800px" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
-
-<g id="SVGRepo_bgCarrier" stroke-width="0"/>
-
-<g id="SVGRepo_tracerCarrier" stroke-linecap="round" stroke-linejoin="round"/>
-
-<g id="SVGRepo_iconCarrier"> <circle cx="12" cy="12" r="10" stroke="#1C274C" stroke-width="1.5"/> <path d="M8 9.5C8 9.03406 8 8.80109 8.07612 8.61732C8.17761 8.37229 8.37229 8.17761 8.61732 8.07612C8.80109 8 9.03406 8 9.5 8C9.96594 8 10.1989 8 10.3827 8.07612C10.6277 8.17761 10.8224 8.37229 10.9239 8.61732C11 8.80109 11 9.03406 11 9.5V14.5C11 14.9659 11 15.1989 10.9239 15.3827C10.8224 15.6277 10.6277 15.8224 10.3827 15.9239C10.1989 16 9.96594 16 9.5 16C9.03406 16 8.80109 16 8.61732 15.9239C8.37229 15.8224 8.17761 15.6277 8.07612 15.3827C8 15.1989 8 14.9659 8 14.5V9.5Z" stroke="#1C274C" stroke-width="1.5"/> <path d="M13 9.5C13 9.03406 13 8.80109 13.0761 8.61732C13.1776 8.37229 13.3723 8.17761 13.6173 8.07612C13.8011 8 14.0341 8 14.5 8C14.9659 8 15.1989 8 15.3827 8.07612C15.6277 8.17761 15.8224 8.37229 15.9239 8.61732C16 8.80109 16 9.03406 16 9.5V14.5C16 14.9659 16 15.1989 15.9239 15.3827C15.8224 15.6277 15.6277 15.8224 15.3827 15.9239C15.1989 16 14.9659 16 14.5 16C14.0341 16 13.8011 16 13.6173 15.9239C13.3723 15.8224 13.1776 15.6277 13.0761 15.3827C13 15.1989 13 14.9659 13 14.5V9.5Z" stroke="#1C274C" stroke-width="1.5"/> </g>
-
-</svg>
\ No newline at end of file
diff --git a/apps/llm/assets/icons/send_icon.svg b/apps/llm/assets/icons/send_icon.svg
deleted file mode 100644
index dfe227a3b2..0000000000
--- a/apps/llm/assets/icons/send_icon.svg
+++ /dev/null
@@ -1,4 +0,0 @@
-<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M20 4L3 11L10 14L13 21L20 4Z" stroke="#001A72" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
-<path d="M20 4L10 14" stroke="#001A72" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
-</svg>
diff --git a/apps/llm/assets/icons/splash.png b/apps/llm/assets/icons/splash.png
deleted file mode 100644
index 0e89705a94..0000000000
Binary files a/apps/llm/assets/icons/splash.png and /dev/null differ
diff --git a/apps/llm/assets/icons/stop_icon.svg b/apps/llm/assets/icons/stop_icon.svg
deleted file mode 100644
index cb051899fe..0000000000
--- a/apps/llm/assets/icons/stop_icon.svg
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?><!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
-<svg width="800px" height="800px" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M11.9426 1.25H12.0574C14.3658 1.24999 16.1748 1.24998 17.5863 1.43975C19.031 1.63399 20.1711 2.03933 21.0659 2.93414C21.9607 3.82895 22.366 4.96897 22.5603 6.41371C22.75 7.82519 22.75 9.63423 22.75 11.9426V12.0574C22.75 14.3658 22.75 16.1748 22.5603 17.5863C22.366 19.031 21.9607 20.1711 21.0659 21.0659C20.1711 21.9607 19.031 22.366 17.5863 22.5603C16.1748 22.75 14.3658 22.75 12.0574 22.75H11.9426C9.63423 22.75 7.82519 22.75 6.41371 22.5603C4.96897 22.366 3.82895 21.9607 2.93414 21.0659C2.03933 20.1711 1.63399 19.031 1.43975 17.5863C1.24998 16.1748 1.24999 14.3658 1.25 12.0574V11.9426C1.24999 9.63423 1.24998 7.82519 1.43975 6.41371C1.63399 4.96897 2.03933 3.82895 2.93414 2.93414C3.82895 2.03933 4.96897 1.63399 6.41371 1.43975C7.82519 1.24998 9.63423 1.24999 11.9426 1.25ZM6.61358 2.92637C5.33517 3.09825 4.56445 3.42514 3.9948 3.9948C3.42514 4.56445 3.09825 5.33517 2.92637 6.61358C2.75159 7.91356 2.75 9.62178 2.75 12C2.75 14.3782 2.75159 16.0864 2.92637 17.3864C3.09825 18.6648 3.42514 19.4355 3.9948 20.0052C4.56445 20.5749 5.33517 20.9018 6.61358 21.0736C7.91356 21.2484 9.62178 21.25 12 21.25C14.3782 21.25 16.0864 21.2484 17.3864 21.0736C18.6648 20.9018 19.4355 20.5749 20.0052 20.0052C20.5749 19.4355 20.9018 18.6648 21.0736 17.3864C21.2484 16.0864 21.25 14.3782 21.25 12C21.25 9.62178 21.2484 7.91356 21.0736 6.61358C20.9018 5.33517 20.5749 4.56445 20.0052 3.9948C19.4355 3.42514 18.6648 3.09825 17.3864 2.92637C16.0864 2.75159 14.3782 2.75 12 2.75C9.62178 2.75 7.91356 2.75159 6.61358 2.92637Z" fill="#1C274C"/>
-</svg>
\ No newline at end of file
diff --git a/apps/llm/assets/icons/swm_icon.svg b/apps/llm/assets/icons/swm_icon.svg
deleted file mode 100644
index 8c62f039be..0000000000
--- a/apps/llm/assets/icons/swm_icon.svg
+++ /dev/null
@@ -1,13 +0,0 @@
-<svg width="47" height="25" viewBox="0 0 47 25" fill="none" xmlns="http://www.w3.org/2000/svg">
-<g clip-path="url(#clip0_2_550)">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M0.575378 0.0757751H1.14095H38.7328H38.9679L39.1338 0.24327L46.1469 7.3266L46.3114 7.49283V7.72729V24.2424V24.8106H45.7459H8.19177H7.9575L7.79185 24.6442L0.741031 17.5609L0.575378 17.3945V17.1591V0.643957V0.0757751ZM1.70653 2.01567V16.9238L7.62618 22.8707V7.96262L1.70653 2.01567ZM2.50637 1.21214L8.42604 7.15911H44.3856L38.4976 1.21214H2.50637ZM45.1803 23.6743H8.75733V8.29548H45.1803V23.6743Z" fill="#001A72"/>
-<path d="M17.9197 17.6137C17.9197 18.8637 17.1279 19.9243 15.1295 19.9243C14.2623 19.9243 13.5836 19.7349 12.9426 19.4697V17.7652C13.5836 18.1061 14.3754 18.2955 15.0918 18.2955C15.7328 18.2955 16.0721 18.1061 16.0721 17.7273C16.0721 16.5909 12.9426 16.9318 12.9426 14.5833C12.9426 13.144 14.1115 12.2349 15.6951 12.2349C16.3738 12.2349 16.9771 12.3864 17.618 12.7652V14.5833C16.7508 14.053 16.1475 13.8637 15.6574 13.8637C15.0541 13.8637 14.7525 14.0909 14.7525 14.4318C14.7148 15.5303 17.9197 15.1137 17.9197 17.6137Z" fill="#001A72"/>
-<path d="M30.4 12.4242L28.0246 19.7727H26.2147L24.6311 14.697L23.0098 19.7348H21.2L18.8246 12.3864H20.8607L22.1803 17.3106L23.7262 12.3864H25.5361L27.082 17.3106L28.4016 12.3864H30.4V12.4242Z" fill="#001A72"/>
-<path d="M41.7492 14.9243V19.7727H39.9394V15.2273C39.9394 14.4318 39.3738 13.9773 38.7705 13.9773C38.1295 13.9773 37.6017 14.4318 37.6017 15.2273V19.7727H35.7918V15.2273C35.7918 14.4318 35.2263 13.9773 34.623 13.9773C33.982 13.9773 33.4541 14.4318 33.4541 15.2273V19.7727H31.6443V12.4243H33.341V12.9546C33.8689 12.4243 34.4345 12.2349 35.1131 12.2349C35.8672 12.2349 36.5459 12.5758 36.9984 13.1818C37.6017 12.5379 38.3558 12.2349 39.223 12.2349C40.6935 12.2727 41.7492 13.3333 41.7492 14.9243Z" fill="#001A72"/>
-</g>
-<defs>
-<clipPath id="clip0_2_550">
-<rect width="46" height="25" fill="white" transform="translate(0.5)"/>
-</clipPath>
-</defs>
-</svg>
diff --git a/apps/llm/babel.config.js b/apps/llm/babel.config.js
deleted file mode 100644
index d872de3f55..0000000000
--- a/apps/llm/babel.config.js
+++ /dev/null
@@ -1,7 +0,0 @@
-module.exports = function (api) {
-  api.cache(true);
-  return {
-    presets: ['babel-preset-expo'],
-    plugins: ['react-native-reanimated/plugin'],
-  };
-};
diff --git a/apps/llm/colors.ts b/apps/llm/colors.ts
deleted file mode 100644
index 03defcda9e..0000000000
--- a/apps/llm/colors.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-const ColorPalette = {
-  primary: '#001A72',
-  seaBlueLight: '#E1F3FA',
-  seaBlueMedium: '#B5E1F1',
-  seaBlueDark: '#87CCE8',
-  blueLight: '#C1C6E5',
-  blueDark: '#6676AA',
-  strongPrimary: '#020F3C',
-};
-
-export default ColorPalette;
diff --git a/apps/llm/components/AnimatedChatLoading.tsx b/apps/llm/components/AnimatedChatLoading.tsx
deleted file mode 100644
index 2a5641fd39..0000000000
--- a/apps/llm/components/AnimatedChatLoading.tsx
+++ /dev/null
@@ -1,50 +0,0 @@
-import { StyleSheet, View } from 'react-native';
-import Animated, {
-  interpolateColor,
-  useAnimatedStyle,
-  useSharedValue,
-  withRepeat,
-  withTiming,
-} from 'react-native-reanimated';
-import ColorPalette from '../colors';
-
-export default function AnimatedChatLoading() {
-  const progress = useSharedValue(0);
-  progress.value = withRepeat(withTiming(1, { duration: 500 }), -1, true);
-
-  const animatedStyle = useAnimatedStyle(() => {
-    return {
-      backgroundColor: interpolateColor(
-        progress.value,
-        [0, 1],
-        [
-          ColorPalette.seaBlueLight,
-          ColorPalette.seaBlueMedium,
-          ColorPalette.seaBlueDark,
-        ]
-      ),
-    };
-  });
-
-  return (
-    <View style={styles.messageLoadingContainer}>
-      <Animated.View style={[styles.loadingDot, animatedStyle]} />
-      <Animated.View style={[styles.loadingDot, animatedStyle]} />
-      <Animated.View style={[styles.loadingDot, animatedStyle]} />
-    </View>
-  );
-}
-
-const styles = StyleSheet.create({
-  messageLoadingContainer: {
-    flex: 1,
-    flexDirection: 'row',
-    justifyContent: 'space-between',
-    alignItems: 'center',
-  },
-  loadingDot: {
-    width: 8,
-    height: 8,
-    borderRadius: 4,
-  },
-});
diff --git a/apps/llm/components/AudioWaveform.tsx b/apps/llm/components/AudioWaveform.tsx
deleted file mode 100644
index cac4035614..0000000000
--- a/apps/llm/components/AudioWaveform.tsx
+++ /dev/null
@@ -1,57 +0,0 @@
-import { useMemo } from 'react';
-import { StyleProp, StyleSheet, View, ViewStyle } from 'react-native';
-import ColorPalette from '../colors';
-
-interface AudioWaveformProps {
-  buffer: Float32Array | null | undefined;
-  style?: StyleProp<ViewStyle>;
-}
-
-const NUM_BARS = 32;
-
-export default function AudioWaveform({ buffer, style }: AudioWaveformProps) {
-  const bars = useMemo(() => {
-    if (!buffer || buffer.length === 0) return null;
-    const chunkSize = Math.max(1, Math.floor(buffer.length / NUM_BARS));
-    const peaks: number[] = [];
-    let max = 0;
-    for (let i = 0; i < NUM_BARS; i++) {
-      const start = i * chunkSize;
-      const end = Math.min(start + chunkSize, buffer.length);
-      let peak = 0;
-      for (let j = start; j < end; j++) {
-        const v = Math.abs(buffer[j] ?? 0);
-        if (v > peak) peak = v;
-      }
-      peaks.push(peak);
-      if (peak > max) max = peak;
-    }
-    return max > 0 ? peaks.map((p) => p / max) : peaks;
-  }, [buffer]);
-
-  if (!bars) return null;
-
-  return (
-    <View style={[styles.container, style]}>
-      {bars.map((amp, i) => (
-        <View key={i} style={[styles.bar, { height: 2 + amp * 14 }]} />
-      ))}
-    </View>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    height: 16,
-    minWidth: 160,
-    gap: 2,
-  },
-  bar: {
-    flex: 1,
-    borderRadius: 1,
-    backgroundColor: ColorPalette.blueDark,
-    opacity: 0.35,
-  },
-});
diff --git a/apps/llm/components/ErrorBanner.tsx b/apps/llm/components/ErrorBanner.tsx
deleted file mode 100644
index a5bebc504f..0000000000
--- a/apps/llm/components/ErrorBanner.tsx
+++ /dev/null
@@ -1,53 +0,0 @@
-import React from 'react';
-import { View, Text, TouchableOpacity, StyleSheet } from 'react-native';
-
-interface ErrorBannerProps {
-  message: string | null;
-  onDismiss: () => void;
-}
-
-export default function ErrorBanner({ message, onDismiss }: ErrorBannerProps) {
-  if (!message) return null;
-
-  return (
-    <View style={styles.container}>
-      <Text style={styles.message} numberOfLines={3}>
-        {message}
-      </Text>
-      <TouchableOpacity onPress={onDismiss} style={styles.closeButton}>
-        <Text style={styles.closeText}>✕</Text>
-      </TouchableOpacity>
-    </View>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: {
-    backgroundColor: '#FEE2E2',
-    borderLeftWidth: 4,
-    borderLeftColor: '#EF4444',
-    borderRadius: 8,
-    marginHorizontal: 16,
-    marginVertical: 8,
-    paddingVertical: 10,
-    paddingLeft: 12,
-    paddingRight: 8,
-    flexDirection: 'row',
-    alignItems: 'center',
-  },
-  message: {
-    flex: 1,
-    color: '#991B1B',
-    fontSize: 14,
-    lineHeight: 20,
-  },
-  closeButton: {
-    padding: 4,
-    marginLeft: 8,
-  },
-  closeText: {
-    color: '#991B1B',
-    fontSize: 16,
-    fontWeight: '600',
-  },
-});
diff --git a/apps/llm/components/MarkdownComponent.tsx b/apps/llm/components/MarkdownComponent.tsx
deleted file mode 100644
index 111019a363..0000000000
--- a/apps/llm/components/MarkdownComponent.tsx
+++ /dev/null
@@ -1,32 +0,0 @@
-import { Platform } from 'react-native';
-import Markdown from 'react-native-markdown-display';
-import ColorPalette from '../colors';
-
-interface MarkdownComponentProps {
-  text: string;
-}
-
-export default function MarkdownComponent({ text }: MarkdownComponentProps) {
-  const fontSize = Platform.OS === 'ios' ? 16 : 14;
-  return (
-    <Markdown
-      style={{
-        body: {
-          color: ColorPalette.primary,
-          fontFamily: 'regular',
-          lineHeight: 19.6,
-          fontSize: fontSize,
-        },
-        paragraph: {
-          marginTop: 0,
-          marginBottom: 0,
-        },
-        heading1: { fontSize: 14 },
-        heading2: { fontSize: 14 },
-        strong: { fontFamily: 'medium' },
-      }}
-    >
-      {text}
-    </Markdown>
-  );
-}
diff --git a/apps/llm/components/MessageItem.tsx b/apps/llm/components/MessageItem.tsx
deleted file mode 100644
index cda8609885..0000000000
--- a/apps/llm/components/MessageItem.tsx
+++ /dev/null
@@ -1,143 +0,0 @@
-import React, { memo } from 'react';
-import {
-  View,
-  StyleSheet,
-  TouchableOpacity,
-  Text,
-  Image,
-  Platform,
-} from 'react-native';
-import MarkdownComponent from './MarkdownComponent';
-import LlamaIcon from '../assets/icons/llama_icon.svg';
-import ColorPalette from '../colors';
-import { Message } from 'react-native-executorch';
-import AudioWaveform from './AudioWaveform';
-
-interface MessageItemProps {
-  message: Message;
-  deleteMessage: () => void;
-}
-
-const MessageItem = memo(({ message, deleteMessage }: MessageItemProps) => {
-  if (message.role === 'assistant') {
-    return (
-      <View style={styles.aiMessage}>
-        <View style={styles.aiMessageIconContainer}>
-          <LlamaIcon width={24} height={24} />
-        </View>
-        <View style={styles.aiMessageContent}>
-          <MarkdownComponent text={message.content} />
-        </View>
-        <CloseButton deleteMessage={deleteMessage} role={message.role} />
-      </View>
-    );
-  }
-
-  return (
-    <View style={styles.userMessageWrapper}>
-      <CloseButton deleteMessage={deleteMessage} role={message.role} />
-      <View style={styles.userMessageBubble}>
-        {message.mediaPath && (
-          <Image
-            source={{ uri: message.mediaPath }}
-            style={styles.userMessageImage}
-            resizeMode="contain"
-          />
-        )}
-        {message.audioWaveform && (
-          <AudioWaveform
-            buffer={message.audioWaveform}
-            style={styles.userMessageWaveform}
-          />
-        )}
-        <MarkdownComponent text={message.content} />
-      </View>
-    </View>
-  );
-});
-
-const CloseButton = ({
-  deleteMessage,
-  role,
-}: {
-  deleteMessage: () => void;
-  role: string;
-}) => {
-  return (
-    <TouchableOpacity
-      style={[
-        styles.closeButton,
-        role === 'assistant' ? styles.closeButtonRight : styles.closeButtonLeft,
-      ]}
-      onPress={deleteMessage}
-    >
-      <Text style={styles.buttonText}>✕</Text>
-    </TouchableOpacity>
-  );
-};
-
-export default MessageItem;
-
-const styles = StyleSheet.create({
-  aiMessage: {
-    flexDirection: 'row',
-    maxWidth: '75%',
-    alignSelf: 'flex-start',
-    marginVertical: 8,
-    alignItems: 'center',
-  },
-  aiMessageContent: {
-    flex: 1,
-  },
-  userMessageWrapper: {
-    flexDirection: 'row-reverse',
-    marginRight: 8,
-    marginVertical: 8,
-    maxWidth: '75%',
-    alignSelf: 'flex-end',
-    alignItems: 'flex-start',
-  },
-  userMessageBubble: {
-    flexDirection: 'column',
-    paddingHorizontal: 12,
-    paddingVertical: 8,
-    borderRadius: 8,
-    backgroundColor: ColorPalette.seaBlueLight,
-  },
-  userMessageImage: {
-    width: 200,
-    height: 200,
-    borderRadius: 6,
-    marginBottom: 6,
-  },
-  userMessageWaveform: {
-    marginBottom: 6,
-  },
-  aiMessageIconContainer: {
-    backgroundColor: ColorPalette.seaBlueLight,
-    height: 32,
-    width: 32,
-    alignItems: 'center',
-    justifyContent: 'center',
-    borderRadius: 16,
-    marginHorizontal: 7,
-  },
-  closeButton: {
-    borderRadius: 11,
-    backgroundColor: ColorPalette.blueLight,
-    alignItems: 'center',
-    justifyContent: 'center',
-    width: 22,
-    height: 22,
-  },
-  closeButtonRight: {
-    marginLeft: 8,
-  },
-  closeButtonLeft: {
-    marginRight: 8,
-  },
-  buttonText: {
-    fontSize: Platform.OS === 'ios' ? 16 : 14,
-    color: '#000',
-  },
-});
diff --git a/apps/llm/components/Messages.tsx b/apps/llm/components/Messages.tsx
deleted file mode 100644
index a1848c1deb..0000000000
--- a/apps/llm/components/Messages.tsx
+++ /dev/null
@@ -1,82 +0,0 @@
-import { useRef } from 'react';
-import { ScrollView, StyleSheet, View, Text } from 'react-native';
-import AnimatedChatLoading from './AnimatedChatLoading';
-import LlamaIcon from '../assets/icons/llama_icon.svg';
-import ColorPalette from '../colors';
-import MessageItem from './MessageItem';
-import { Message } from 'react-native-executorch';
-
-interface MessagesComponentProps {
-  chatHistory: Message[];
-  llmResponse: string;
-  isGenerating: boolean;
-  deleteMessage: (index: number) => void;
-}
-
-export default function Messages({
-  chatHistory,
-  llmResponse,
-  isGenerating,
-  deleteMessage,
-}: MessagesComponentProps) {
-  const scrollViewRef = useRef<ScrollView>(null);
-
-  return (
-    <View style={styles.chatContainer}>
-      <ScrollView
-        ref={scrollViewRef}
-        onContentSizeChange={() => scrollViewRef?.current?.scrollToEnd()}
-      >
-        <View onStartShouldSetResponder={() => true}>
-          {chatHistory.map((message, index) => (
-            <MessageItem
-              key={index}
-              message={message}
-              deleteMessage={() => deleteMessage(index)}
-            />
-          ))}
-          {isGenerating && (
-            <View style={styles.aiMessage}>
-              <View style={styles.aiMessageIconContainer}>
-                <LlamaIcon width={24} height={24} />
-              </View>
-              {!llmResponse ? (
-                <View style={styles.messageLoadingContainer}>
-                  <AnimatedChatLoading />
-                </View>
-              ) : (
-                <Text style={styles.messageText}> {llmResponse.trim()}</Text>
-              )}
-            </View>
-          )}
-        </View>
-      </ScrollView>
-    </View>
-  );
-}
-
-const styles = StyleSheet.create({
-  chatContainer: { flex: 1, width: '100%' },
-  aiMessage: {
-    flexDirection: 'row',
-    maxWidth: '80%',
-    alignSelf: 'flex-start',
-    marginVertical: 8,
-  },
-  messageLoadingContainer: { width: 28 },
-  aiMessageIconContainer: {
-    backgroundColor: ColorPalette.seaBlueLight,
-    height: 32,
-    width: 32,
-    alignItems: 'center',
-    justifyContent: 'center',
-    borderRadius: 16,
-    marginHorizontal: 7,
-  },
-  messageText: {
-    fontSize: 14,
-    lineHeight: 19.6,
-    color: ColorPalette.primary,
-    fontFamily: 'regular',
-  },
-});
diff --git a/apps/llm/components/ModelPicker.tsx b/apps/llm/components/ModelPicker.tsx
deleted file mode 100644
index 94a848596e..0000000000
--- a/apps/llm/components/ModelPicker.tsx
+++ /dev/null
@@ -1,216 +0,0 @@
-import React, { useEffect, useRef, useState } from 'react';
-import {
-  Dimensions,
-  Modal,
-  ScrollView,
-  StyleSheet,
-  Text,
-  TouchableOpacity,
-  View,
-} from 'react-native';
-
-export type ModelOption<T> = {
-  label: string;
-  value: T;
-};
-
-type Props<T> = {
-  models: ModelOption<T>[];
-  selectedModel: T;
-  onSelect: (model: T) => void;
-  label?: string;
-  disabled?: boolean;
-};
-
-const DROPDOWN_MAX_HEIGHT = 200;
-
-export function ModelPicker<T>({
-  models,
-  selectedModel,
-  onSelect,
-  label,
-  disabled,
-}: Props<T>) {
-  const [open, setOpen] = useState(false);
-  const [triggerHeight, setTriggerHeight] = useState(0);
-  const [expandUp, setExpandUp] = useState(false);
-  const [dropdownTop, setDropdownTop] = useState(0);
-  const triggerRef = useRef<React.ComponentRef<typeof TouchableOpacity>>(null);
-  const selected = models.find((m) => m.value === selectedModel);
-
-  useEffect(() => {
-    if (disabled) setOpen(false);
-  }, [disabled]);
-
-  const handlePress = () => {
-    if (disabled) return;
-    if (open) {
-      setOpen(false);
-      return;
-    }
-    triggerRef.current?.measure(
-      (
-        _x: number,
-        _y: number,
-        _width: number,
-        height: number,
-        _pageX: number,
-        pageY: number
-      ) => {
-        setTriggerHeight(height);
-        const spaceBelow = Dimensions.get('window').height - (pageY + height);
-        setExpandUp(spaceBelow < DROPDOWN_MAX_HEIGHT);
-        setDropdownTop(pageY);
-        setOpen(true);
-      }
-    );
-  };
-
-  const dropdownStylePosition = expandUp
-    ? {
-        bottom: Dimensions.get('window').height - dropdownTop,
-        left: 12,
-        right: 12,
-      }
-    : {
-        top: dropdownTop + triggerHeight + 2,
-        left: 12,
-        right: 12,
-      };
-
-  return (
-    <>
-      <View style={styles.container}>
-        <TouchableOpacity
-          ref={triggerRef}
-          style={[styles.trigger, disabled && styles.triggerDisabled]}
-          onPress={handlePress}
-          activeOpacity={disabled ? 1 : 0.7}
-        >
-          {label && <Text style={styles.label}>{label}</Text>}
-          <Text style={styles.triggerText}>{selected?.label ?? '—'}</Text>
-          <Text style={styles.chevron}>{open ? '▲' : '▼'}</Text>
-        </TouchableOpacity>
-      </View>
-
-      {open && (
-        <Modal
-          transparent
-          visible={open}
-          onRequestClose={() => setOpen(false)}
-          animationType="none"
-        >
-          <TouchableOpacity
-            style={styles.modalBackdrop}
-            activeOpacity={1}
-            onPress={() => setOpen(false)}
-          />
-          <View style={[styles.dropdown, dropdownStylePosition]}>
-            <ScrollView
-              nestedScrollEnabled
-              keyboardShouldPersistTaps="handled"
-              showsVerticalScrollIndicator={true}
-            >
-              {models.map((item) => {
-                const isSelected = item.value === selectedModel;
-                return (
-                  <TouchableOpacity
-                    key={item.label}
-                    style={[styles.option, isSelected && styles.optionSelected]}
-                    onPress={() => {
-                      onSelect(item.value);
-                      setOpen(false);
-                    }}
-                    activeOpacity={0.7}
-                  >
-                    <Text
-                      style={[
-                        styles.optionText,
-                        isSelected && styles.optionTextSelected,
-                      ]}
-                    >
-                      {item.label}
-                    </Text>
-                  </TouchableOpacity>
-                );
-              })}
-            </ScrollView>
-          </View>
-        </Modal>
-      )}
-    </>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: {
-    marginHorizontal: 12,
-    marginVertical: 4,
-    alignSelf: 'stretch',
-    zIndex: 100,
-  },
-  trigger: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    borderWidth: 1,
-    borderColor: '#C1C6E5',
-    borderRadius: 8,
-    paddingHorizontal: 12,
-    paddingVertical: 10,
-    backgroundColor: '#f5f5f5',
-  },
-  triggerDisabled: {
-    opacity: 0.4,
-  },
-  label: {
-    fontSize: 12,
-    color: '#888',
-    marginRight: 6,
-  },
-  triggerText: {
-    flex: 1,
-    fontSize: 14,
-    color: '#001A72',
-    fontWeight: '500',
-  },
-  chevron: {
-    fontSize: 10,
-    color: '#888',
-    marginLeft: 6,
-  },
-  modalBackdrop: {
-    flex: 1,
-    backgroundColor: 'rgba(0, 0, 0, 0.3)',
-  },
-  dropdown: {
-    position: 'absolute',
-    borderWidth: 1,
-    borderColor: '#C1C6E5',
-    borderRadius: 8,
-    backgroundColor: '#fff',
-    maxHeight: DROPDOWN_MAX_HEIGHT,
-    zIndex: 1000,
-    elevation: 5,
-    shadowColor: '#000',
-    shadowOffset: { width: 0, height: 4 },
-    shadowOpacity: 0.15,
-    shadowRadius: 6,
-  },
-  option: {
-    paddingHorizontal: 12,
-    paddingVertical: 10,
-    borderBottomWidth: 1,
-    borderBottomColor: '#f0f0f0',
-  },
-  optionSelected: {
-    backgroundColor: '#e8ecf8',
-  },
-  optionText: {
-    fontSize: 14,
-    color: '#333',
-  },
-  optionTextSelected: {
-    color: '#001A72',
-    fontWeight: '600',
-  },
-});
diff --git a/apps/llm/components/Spinner.tsx b/apps/llm/components/Spinner.tsx
deleted file mode 100644
index f436869ab8..0000000000
--- a/apps/llm/components/Spinner.tsx
+++ /dev/null
@@ -1,43 +0,0 @@
-import React from 'react';
-import { View, Text, StyleSheet, ActivityIndicator, Modal } from 'react-native';
-import ColorPalette from '../colors';
-
-interface SpinnerProps {
-  visible: boolean;
-  textContent: string;
-}
-
-const Spinner = ({ visible, textContent }: SpinnerProps) => {
-  return (
-    <Modal transparent={true} animationType="fade" visible={visible}>
-      <View style={styles.overlay}>
-        <View style={styles.container}>
-          <ActivityIndicator size="large" color="#FFFFFF" />
-          <Text style={styles.text}>{textContent}</Text>
-        </View>
-      </View>
-    </Modal>
-  );
-};
-
-const styles = StyleSheet.create({
-  overlay: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-    backgroundColor: 'rgba(0, 0, 0, 0.1)',
-  },
-  container: {
-    padding: 25,
-    alignItems: 'center',
-    justifyContent: 'center',
-  },
-  text: {
-    marginTop: 15,
-    color: ColorPalette.primary,
-    fontSize: 18,
-    fontWeight: 'bold',
-  },
-});
-
-export default Spinner;
diff --git a/apps/llm/components/StatsBar.tsx b/apps/llm/components/StatsBar.tsx
deleted file mode 100644
index 20bad6cfa1..0000000000
--- a/apps/llm/components/StatsBar.tsx
+++ /dev/null
@@ -1,40 +0,0 @@
-import React from 'react';
-import { View, Text, StyleSheet } from 'react-native';
-import { LLMStats } from '../hooks/useLLMStats';
-
-interface Props {
-  stats: LLMStats | null;
-}
-
-export function StatsBar({ stats }: Props) {
-  if (!stats) return null;
-
-  return (
-    <View style={styles.container}>
-      <Text style={styles.stat}>TTFT: {stats.ttft} ms</Text>
-      <Text style={styles.separator}>·</Text>
-      <Text style={styles.stat}>{stats.tokensPerSec} tok/s</Text>
-      <Text style={styles.separator}>·</Text>
-      <Text style={styles.stat}>{stats.totalTokens} tokens</Text>
-    </View>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: {
-    flexDirection: 'row',
-    justifyContent: 'center',
-    alignItems: 'center',
-    gap: 8,
-    paddingVertical: 6,
-  },
-  stat: {
-    fontSize: 13,
-    color: '#334155',
-    fontWeight: '500',
-  },
-  separator: {
-    fontSize: 13,
-    color: '#94A3B8',
-  },
-});
diff --git a/apps/llm/components/SuggestedPrompts.tsx b/apps/llm/components/SuggestedPrompts.tsx
deleted file mode 100644
index 7f66379b48..0000000000
--- a/apps/llm/components/SuggestedPrompts.tsx
+++ /dev/null
@@ -1,47 +0,0 @@
-import { StyleSheet, Text, TouchableOpacity, View } from 'react-native';
-import ColorPalette from '../colors';
-
-interface Props {
-  prompts: string[];
-  onSelect: (prompt: string) => void;
-}
-
-export default function SuggestedPrompts({ prompts, onSelect }: Props) {
-  return (
-    <View style={styles.container}>
-      {prompts.map((prompt, i) => (
-        <TouchableOpacity
-          key={i}
-          style={styles.chip}
-          onPress={() => onSelect(prompt)}
-        >
-          <Text style={styles.chipText}>{prompt}</Text>
-        </TouchableOpacity>
-      ))}
-    </View>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: {
-    flexDirection: 'row',
-    flexWrap: 'wrap',
-    justifyContent: 'center',
-    gap: 8,
-    paddingHorizontal: 16,
-    paddingTop: 16,
-  },
-  chip: {
-    borderWidth: 1,
-    borderColor: ColorPalette.blueLight,
-    borderRadius: 20,
-    paddingHorizontal: 14,
-    paddingVertical: 8,
-    backgroundColor: '#fafbff',
-  },
-  chipText: {
-    fontFamily: 'regular',
-    fontSize: 13,
-    color: ColorPalette.primary,
-  },
-});
diff --git a/apps/llm/components/llmModels.ts b/apps/llm/components/llmModels.ts
deleted file mode 100644
index 58b8c01d74..0000000000
--- a/apps/llm/components/llmModels.ts
+++ /dev/null
@@ -1,151 +0,0 @@
-import {
-  models,
-  LLAMA3_2_1B_QLORA,
-  LLAMA3_2_3B_QLORA,
-  LLMProps,
-} from 'react-native-executorch';
-import { ModelOption } from './ModelPicker';
-const llm = models.llm;
-
-export type LLMModelSources = LLMProps['model'];
-
-export const LLM_MODELS: ModelOption<LLMModelSources>[] = [
-  //Gemma 4
-  {
-    label: 'Gemma 4 E2B',
-    value: llm.gemma4_e2b(),
-  },
-  // Llama 3.2
-  {
-    label: 'Llama 3.2 1B',
-    value: llm.llama3_2_1b({ quant: false }),
-  },
-  { label: 'Llama 3.2 1B QLoRA', value: LLAMA3_2_1B_QLORA },
-  { label: 'Llama 3.2 1B SpinQuant', value: llm.llama3_2_1b() },
-  {
-    label: 'Llama 3.2 3B',
-    value: llm.llama3_2_3b({ quant: false }),
-  },
-  { label: 'Llama 3.2 3B QLoRA', value: LLAMA3_2_3B_QLORA },
-  { label: 'Llama 3.2 3B SpinQuant', value: llm.llama3_2_3b() },
-  // Qwen3
-  {
-    label: 'Qwen3 0.6B',
-    value: llm.qwen3_0_6b({ quant: false }),
-  },
-  { label: 'Qwen3 0.6B Quantized', value: llm.qwen3_0_6b() },
-  {
-    label: 'Qwen3 1.7B',
-    value: llm.qwen3_1_7b({ quant: false }),
-  },
-  { label: 'Qwen3 1.7B Quantized', value: llm.qwen3_1_7b() },
-  { label: 'Qwen3 4B', value: llm.qwen3_4b({ quant: false }) },
-  { label: 'Qwen3 4B Quantized', value: llm.qwen3_4b() },
-  // Hammer 2.1
-  {
-    label: 'Hammer 2.1 0.5B',
-    value: llm.hammer2_1_0_5b({ quant: false }),
-  },
-  {
-    label: 'Hammer 2.1 0.5B Quantized',
-    value: llm.hammer2_1_0_5b(),
-  },
-  {
-    label: 'Hammer 2.1 1.5B',
-    value: llm.hammer2_1_1_5b({ quant: false }),
-  },
-  {
-    label: 'Hammer 2.1 1.5B Quantized',
-    value: llm.hammer2_1_1_5b(),
-  },
-  {
-    label: 'Hammer 2.1 3B',
-    value: llm.hammer2_1_3b({ quant: false }),
-  },
-  {
-    label: 'Hammer 2.1 3B Quantized',
-    value: llm.hammer2_1_3b(),
-  },
-  // SmolLM2
-  {
-    label: 'SmolLM2 135M',
-    value: llm.smollm2_1_135m({ quant: false }),
-  },
-  {
-    label: 'SmolLM2 135M Quantized',
-    value: llm.smollm2_1_135m(),
-  },
-  {
-    label: 'SmolLM2 360M',
-    value: llm.smollm2_1_360m({ quant: false }),
-  },
-  {
-    label: 'SmolLM2 360M Quantized',
-    value: llm.smollm2_1_360m(),
-  },
-  {
-    label: 'SmolLM2 1.7B',
-    value: llm.smollm2_1_1_7b({ quant: false }),
-  },
-  {
-    label: 'SmolLM2 1.7B Quantized',
-    value: llm.smollm2_1_1_7b(),
-  },
-  // Qwen2.5
-  {
-    label: 'Qwen2.5 0.5B',
-    value: llm.qwen2_5_0_5b({ quant: false }),
-  },
-  {
-    label: 'Qwen2.5 0.5B Quantized',
-    value: llm.qwen2_5_0_5b(),
-  },
-  {
-    label: 'Qwen2.5 1.5B',
-    value: llm.qwen2_5_1_5b({ quant: false }),
-  },
-  {
-    label: 'Qwen2.5 1.5B Quantized',
-    value: llm.qwen2_5_1_5b(),
-  },
-  {
-    label: 'Qwen2.5 3B',
-    value: llm.qwen2_5_3b({ quant: false }),
-  },
-  { label: 'Qwen2.5 3B Quantized', value: llm.qwen2_5_3b() },
-  // Qwen3.5
-  { label: 'Qwen3.5 0.8B Quantized', value: llm.qwen3_5_0_8b() },
-  { label: 'Qwen3.5 2B Quantized', value: llm.qwen3_5_2b() },
-  // Phi-4
-  {
-    label: 'Phi-4 Mini 4B',
-    value: llm.phi_4_mini_4b({ quant: false }),
-  },
-  {
-    label: 'Phi-4 Mini 4B Quantized',
-    value: llm.phi_4_mini_4b(),
-  },
-  // LFM2.5
-  {
-    label: 'LFM2.5 350M',
-    value: llm.lfm2_5_350m({ quant: false }),
-  },
-  { label: 'LFM2.5 350M Quantized', value: llm.lfm2_5_350m() },
-  {
-    label: 'LFM2.5 1.2B Instruct',
-    value: llm.lfm2_5_1_2b_instruct({ quant: false }),
-  },
-  {
-    label: 'LFM2.5 1.2B Instruct Quantized',
-    value: llm.lfm2_5_1_2b_instruct(),
-  },
-  // Bielik v3.0
-  {
-    label: 'Bielik v3.0 1.5B',
-    value: llm.bielik_v3_0_1_5b({ quant: false }),
-  },
-  {
-    label: 'Bielik v3.0 1.5B Quantized',
-    value: llm.bielik_v3_0_1_5b(),
-  },
-];
diff --git a/apps/llm/context.ts b/apps/llm/context.ts
deleted file mode 100644
index 0eb0560768..0000000000
--- a/apps/llm/context.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-import { createContext } from 'react';
-
-export const GeneratingContext = createContext({
-  setGlobalGenerating: (_newState: boolean) => {},
-});
diff --git a/apps/llm/declarations.d.ts b/apps/llm/declarations.d.ts
deleted file mode 100644
index 85e178f497..0000000000
--- a/apps/llm/declarations.d.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-declare module '*.svg' {
-  import { SvgProps } from 'react-native-svg';
-  const content: React.FV<SvgProps>;
-  export default content;
-}
diff --git a/apps/llm/hooks/useLLMStats.ts b/apps/llm/hooks/useLLMStats.ts
deleted file mode 100644
index 4cb6e7abdb..0000000000
--- a/apps/llm/hooks/useLLMStats.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-import { useEffect, useRef, useState } from 'react';
-
-export interface LLMStats {
-  ttft: number;
-  tokensPerSec: number;
-  totalTokens: number;
-}
-
-export function useLLMStats(
-  response: string,
-  isGenerating: boolean,
-  totalTokens: number
-) {
-  const sendTimeRef = useRef<number | null>(null);
-  const firstTokenTimeRef = useRef<number | null>(null);
-  const lastResponseRef = useRef<string>('');
-  const [stats, setStats] = useState<LLMStats | null>(null);
-
-  useEffect(() => {
-    if (isGenerating && response.length > 0) {
-      lastResponseRef.current = response;
-      if (firstTokenTimeRef.current === null && sendTimeRef.current !== null) {
-        firstTokenTimeRef.current = Date.now();
-      }
-    }
-  }, [response, isGenerating, totalTokens]);
-
-  useEffect(() => {
-    if (
-      !isGenerating &&
-      sendTimeRef.current !== null &&
-      firstTokenTimeRef.current !== null
-    ) {
-      const endTime = Date.now();
-      const ttft = firstTokenTimeRef.current - sendTimeRef.current;
-      const totalTime = (endTime - firstTokenTimeRef.current) / 1000;
-      const tokensPerSec =
-        totalTime > 0 ? Math.round(totalTokens / totalTime) : 0;
-      setStats({ ttft, tokensPerSec, totalTokens });
-      sendTimeRef.current = null;
-      firstTokenTimeRef.current = null;
-    }
-  }, [isGenerating, totalTokens]);
-
-  const onMessageSend = () => {
-    sendTimeRef.current = Date.now();
-    firstTokenTimeRef.current = null;
-    lastResponseRef.current = '';
-    setStats(null);
-  };
-
-  return { stats, onMessageSend };
-}
diff --git a/apps/llm/index.ts b/apps/llm/index.ts
deleted file mode 100644
index 3f443dcf95..0000000000
--- a/apps/llm/index.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-import { registerRootComponent } from 'expo';
-
-import App from './app';
-
-// registerRootComponent calls AppRegistry.registerComponent('main', () => App);
-// It also ensures that whether you load the app in Expo Go or in a native build,
-// the environment is set up appropriately
-registerRootComponent(App);
diff --git a/apps/llm/metro.config.js b/apps/llm/metro.config.js
deleted file mode 100644
index f58bbc2131..0000000000
--- a/apps/llm/metro.config.js
+++ /dev/null
@@ -1,19 +0,0 @@
-const { getDefaultConfig } = require('expo/metro-config');
-
-const config = getDefaultConfig(__dirname);
-
-const { transformer, resolver } = config;
-
-config.transformer = {
-  ...transformer,
-  babelTransformerPath: require.resolve('react-native-svg-transformer/expo'),
-};
-config.resolver = {
-  ...resolver,
-  assetExts: resolver.assetExts.filter((ext) => ext !== 'svg'),
-  sourceExts: [...resolver.sourceExts, 'svg'],
-};
-
-config.resolver.assetExts.push('pte');
-
-module.exports = config;
diff --git a/apps/llm/package.json b/apps/llm/package.json
deleted file mode 100644
index daca936e36..0000000000
--- a/apps/llm/package.json
+++ /dev/null
@@ -1,54 +0,0 @@
-{
-  "name": "llm",
-  "version": "1.0.0",
-  "main": "expo-router/entry",
-  "scripts": {
-    "start": "expo start",
-    "android": "expo run:android",
-    "ios": "expo run:ios",
-    "web": "expo start --web",
-    "typecheck": "tsc",
-    "lint": "eslint . --ext .ts,.tsx --fix"
-  },
-  "dependencies": {
-    "@expo/log-box": "~56.0.12",
-    "@react-native/metro-config": "^0.85.3",
-    "@react-navigation/drawer": "^7.9.4",
-    "@react-navigation/native": "^7.2.2",
-    "expo": "^56.0.8",
-    "expo-brightness": "~56.0.5",
-    "expo-build-properties": "~56.0.16",
-    "expo-calendar": "~56.0.8",
-    "expo-constants": "~56.0.16",
-    "expo-document-picker": "~56.0.4",
-    "expo-font": "~56.0.5",
-    "expo-linking": "~56.0.13",
-    "expo-router": "~56.2.8",
-    "expo-status-bar": "~56.0.4",
-    "metro-config": "^0.84.0",
-    "react": "19.2.3",
-    "react-native": "0.85.3",
-    "react-native-audio-api": "0.12.2",
-    "react-native-device-info": "^15.0.2",
-    "react-native-executorch": "workspace:*",
-    "react-native-executorch-expo-resource-fetcher": "workspace:*",
-    "react-native-gesture-handler": "~2.31.1",
-    "react-native-image-picker": "^8.2.1",
-    "react-native-loading-spinner-overlay": "^3.0.1",
-    "react-native-markdown-display": "^7.0.2",
-    "react-native-reanimated": "~4.3.0",
-    "react-native-safe-area-context": "~5.7.0",
-    "react-native-screens": "~4.25.2",
-    "react-native-svg": "15.15.4",
-    "react-native-svg-transformer": "^1.5.3",
-    "react-native-worklets": "0.8.1"
-  },
-  "devDependencies": {
-    "@babel/core": "^7.29.0",
-    "@types/react": "~19.2.14",
-    "@types/react-refresh": "^0",
-    "babel-preset-expo": "~56.0.14",
-    "react-refresh": "^0.18.0"
-  },
-  "private": true
-}
diff --git a/apps/llm/tsconfig.json b/apps/llm/tsconfig.json
deleted file mode 100644
index bfe226172e..0000000000
--- a/apps/llm/tsconfig.json
+++ /dev/null
@@ -1,18 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "strict": true,
-    "allowJs": true,
-    "module": "preserve",
-    "moduleDetection": "force",
-    "moduleResolution": "bundler",
-    "customConditions": ["react-native"],
-    "noEmit": true,
-    "paths": {
-      "react-native-executorch": ["../../packages/react-native-executorch/src"],
-      "react-native-executorch-expo-resource-fetcher": [
-        "../../packages/expo-resource-fetcher/src"
-      ]
-    }
-  }
-}
diff --git a/apps/llm/utils/piiMatching.ts b/apps/llm/utils/piiMatching.ts
deleted file mode 100644
index 1f4a8adf1e..0000000000
--- a/apps/llm/utils/piiMatching.ts
+++ /dev/null
@@ -1,132 +0,0 @@
-import { PiiEntity } from 'react-native-executorch';
-
-/**
- * A detected entity span pinned to a character range in the source text.
- */
-export interface EntityMatch {
-  start: number;
-  end: number;
-  label: string;
-}
-
-const escapeRegex = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-
-// Word-boundary-anchored search so e.g. "John" doesn't match the "John"
-// inside "Johnson".
-function findWordBounded(source: string, needle: string, from: number): number {
-  const re = new RegExp(`\\b${escapeRegex(needle)}\\b`);
-  const match = re.exec(source.slice(from));
-  return match ? from + match.index : -1;
-}
-
-/**
- * Map detected entities (which carry decoded text only) onto character
- * ranges in the source text by scanning forward.
- *
- * The native runner's `text` field is the BPE-detokenized form of the
- * entity, which often differs from the source by whitespace, punctuation
- * spacing, or stripped specials. Strategy:
- *   1) Try a word-bounded match for the whole entity from the cursor onward.
- *   2) On miss, fall back to each non-trivial word from the entity text
- *      individually so we still highlight most of the span.
- *
- * Order-preserving: cursor advances after each successful match so
- * duplicate strings resolve left-to-right.
- * @param source - The full text the model was run against.
- * @param entities - Entities returned by the native runner.
- * @returns Sorted, non-overlapping char-range matches.
- */
-export function matchEntities(
-  source: string,
-  entities: PiiEntity[]
-): EntityMatch[] {
-  const matches: EntityMatch[] = [];
-  let cursor = 0;
-  for (const e of entities) {
-    if (!e.text) continue;
-    const exact = findWordBounded(source, e.text, cursor);
-    if (exact !== -1) {
-      matches.push({
-        start: exact,
-        end: exact + e.text.length,
-        label: e.label,
-      });
-      cursor = exact + e.text.length;
-      continue;
-    }
-    const words = e.text.split(/\s+/).filter((w) => w.length > 1);
-    let localCursor = cursor;
-    for (const w of words) {
-      const idx = findWordBounded(source, w, localCursor);
-      if (idx === -1) continue;
-      matches.push({ start: idx, end: idx + w.length, label: e.label });
-      localCursor = idx + w.length;
-    }
-    if (localCursor > cursor) cursor = localCursor;
-  }
-  matches.sort((a, b) => a.start - b.start);
-  return matches;
-}
-
-export interface Segment {
-  text: string;
-  label: string | null;
-}
-
-/**
- * Slice the source text into alternating plain / labeled runs based on the
- * matched entity ranges. Overlaps are dropped (the earlier match wins).
- * @param source - The full text to slice.
- * @param matches - Char-range matches from {@link matchEntities}.
- * @returns An ordered array of segments covering the entire source.
- */
-export function buildSegments(
-  source: string,
-  matches: EntityMatch[]
-): Segment[] {
-  const segments: Segment[] = [];
-  let pos = 0;
-  for (const m of matches) {
-    if (m.start < pos) continue;
-    if (m.start > pos) {
-      segments.push({ text: source.slice(pos, m.start), label: null });
-    }
-    segments.push({ text: source.slice(m.start, m.end), label: m.label });
-    pos = m.end;
-  }
-  if (pos < source.length) {
-    segments.push({ text: source.slice(pos), label: null });
-  }
-  return segments;
-}
-
-/**
- * Pastel color palette + stable label-to-color mapping. Same label always
- * gets the same color across renders / runs.
- */
-const PALETTE = [
-  '#ffd4a8',
-  '#b8e1ff',
-  '#d4c5f9',
-  '#c3e8c3',
-  '#ffe8b8',
-  '#f8c6c6',
-  '#e3c8a8',
-  '#ff9aa2',
-  '#b6e3d4',
-  '#ffd6e0',
-  '#cdb4db',
-  '#ffc8a2',
-  '#a2d2ff',
-  '#bde0fe',
-  '#fcd5ce',
-];
-
-export function colorForLabel(label: string): string {
-  let hash = 0;
-  for (let i = 0; i < label.length; i++) {
-    // eslint-disable-next-line no-bitwise
-    hash = (hash * 31 + label.charCodeAt(i)) | 0;
-  }
-  return PALETTE[Math.abs(hash) % PALETTE.length] as string;
-}
diff --git a/apps/llm/utils/tools.ts b/apps/llm/utils/tools.ts
deleted file mode 100644
index 765859ef87..0000000000
--- a/apps/llm/utils/tools.ts
+++ /dev/null
@@ -1,226 +0,0 @@
-import * as Calendar from 'expo-calendar';
-import * as Brightness from 'expo-brightness';
-import { PermissionStatus } from 'expo';
-import { clamp } from 'react-native-reanimated';
-import { Platform } from 'react-native';
-import { ToolCall } from 'react-native-executorch';
-
-export const executeTool: (call: ToolCall) => Promise<string | null> = async (
-  call
-) => {
-  switch (call.toolName) {
-    case 'brightness':
-      return await brightness(call);
-    case 'read_calendar':
-      return await readCalendar(call);
-    case 'add_event_to_calendar':
-      return await addEventToCalendar(call);
-    default:
-      console.error(`Wrong function! We don't handle it!`);
-      return null;
-  }
-};
-
-export const TOOL_DEFINITIONS_PHONE = [
-  {
-    name: 'brightness',
-    description:
-      'Change screen brightness. Change can be relative (higher/lower) or set to minimal or maximal.',
-    parameters: {
-      type: 'dict',
-      properties: {
-        relativeChange: {
-          type: 'number',
-          description:
-            'Relative change of brightness (from 0 to 100). Change should be negative if user asks for less bright screen.',
-        },
-        targetBrightness: {
-          type: 'number',
-          description: 'Relative change of brightness (from 0 to 100).',
-        },
-      },
-    },
-  },
-  {
-    name: 'read_calendar',
-    description:
-      'Read calendar events from now up to given point in time. If nothing is specified leave both empty.',
-    parameters: {
-      type: 'dict',
-      properties: {
-        timeStart: {
-          type: 'string',
-          description: 'Date and time from which we want to read calendar.',
-        },
-        timeEnd: {
-          type: 'string',
-          description: 'Date and time to which we want to read calendar.',
-        },
-      },
-      required: [],
-    },
-  },
-  {
-    name: 'add_event_to_calendar',
-    description: 'Schedules event in your calendar at given time.',
-    parameters: {
-      type: 'dict',
-      properties: {
-        time: {
-          type: 'string',
-          description: 'Date and time of an event.',
-        },
-        title: {
-          type: 'string',
-          description: 'Title of an event',
-        },
-      },
-      required: ['time', 'title'],
-    },
-  },
-];
-
-const brightness = async (call: ToolCall) => {
-  console.log('Changing brightness!', call);
-  const { status } = await Brightness.getPermissionsAsync();
-  if (status !== Brightness.PermissionStatus.GRANTED) {
-    return 'Brightness permission denied. Inform the user they need to grant brightness access in the app.';
-  }
-  if (
-    'targetBrightness' in call.arguments &&
-    typeof call.arguments.targetBrightness === 'number'
-  ) {
-    await Brightness.setBrightnessAsync(call.arguments.targetBrightness / 100);
-  } else if (
-    'relativeChange' in call.arguments &&
-    typeof call.arguments.relativeChange === 'number'
-  ) {
-    await Brightness.setBrightnessAsync(
-      clamp(
-        (await Brightness.getBrightnessAsync()) +
-          call.arguments.relativeChange / 100,
-        0,
-        1
-      )
-    );
-  }
-  return null;
-};
-
-const readCalendar = async (call: ToolCall) => {
-  console.log('Reading calendar!', call);
-  const { status } = await Calendar.getCalendarPermissionsAsync();
-  if (status !== PermissionStatus.GRANTED) {
-    return 'Calendar permission denied. Inform the user they need to grant calendar access in the app.';
-  }
-
-  let startTime = Date.parse(
-    'timeStart' in call.arguments &&
-      typeof call.arguments.timeStart === 'string'
-      ? call.arguments.timeStart
-      : ''
-  );
-  let endTime = Date.parse(
-    'timeEnd' in call.arguments && typeof call.arguments.timeEnd === 'string'
-      ? call.arguments.timeEnd
-      : ''
-  );
-
-  if (
-    startTime === endTime ||
-    (Number.isNaN(startTime) && Number.isNaN(endTime))
-  ) {
-    // default to today for empty function calls
-    let date;
-    if (Number.isNaN(startTime)) {
-      date = new Date();
-    } else {
-      date = new Date(startTime);
-    }
-    // Set the time to 00:00:00 for the start of the day
-    startTime = new Date(
-      date.getFullYear(),
-      date.getMonth(),
-      date.getDate(),
-      0,
-      0,
-      0
-    ).valueOf();
-
-    // Set the time to 23:59:59 for the end of the day
-    endTime = new Date(
-      date.getFullYear(),
-      date.getMonth(),
-      date.getDate(),
-      23,
-      59,
-      59
-    ).valueOf();
-  } else if (Number.isNaN(startTime) || Number.isNaN(endTime)) {
-    if (Number.isNaN(startTime)) {
-      const today = new Date();
-      startTime = new Date(
-        today.getFullYear(),
-        today.getMonth(),
-        today.getDate(),
-        0,
-        0,
-        0
-      ).valueOf();
-    } else if (Number.isNaN(endTime)) {
-      const today = new Date();
-
-      endTime = new Date(
-        today.getFullYear(),
-        today.getMonth(),
-        today.getDate(),
-        23,
-        59,
-        59
-      ).valueOf();
-    }
-  }
-  const startDate = new Date(startTime);
-  const endDate = new Date(endTime);
-  const calendars = await Calendar.getCalendarsAsync(
-    Platform.OS === 'ios' ? Calendar.EntityTypes.EVENT : undefined
-  );
-  const events = await Calendar.getEventsAsync(
-    calendars.map((calendar) => calendar.id),
-    startDate,
-    endDate
-  );
-
-  const eventsStringRepresentation = events.map(
-    (event) => `${event.title}, from: ${event.startDate}, to: ${event.endDate}`
-  );
-  return eventsStringRepresentation.join('\n');
-};
-
-const addEventToCalendar = async (call: ToolCall) => {
-  console.log('Adding event to calendar!', call);
-  const { status } = await Calendar.getCalendarPermissionsAsync();
-  if (status !== PermissionStatus.GRANTED) {
-    return 'Calendar permission denied. Inform the user they need to grant calendar access in the app.';
-  }
-  if (
-    'time' in call.arguments &&
-    typeof call.arguments.time === 'string' &&
-    'title' in call.arguments &&
-    typeof call.arguments.title === 'string'
-  ) {
-    const calendars = await Calendar.getCalendarsAsync(
-      Platform.OS === 'ios' ? Calendar.EntityTypes.EVENT : undefined
-    );
-    let startDate = new Date(Date.parse(call.arguments.time));
-    const endDate = new Date(startDate);
-    endDate.setHours(endDate.getHours() + 1);
-
-    await Calendar.createEventAsync(calendars[0].id, {
-      title: call.arguments.title,
-      startDate: startDate,
-      endDate: endDate,
-    });
-  }
-  return null;
-};
diff --git a/apps/speech/.gitignore b/apps/speech/.gitignore
deleted file mode 100644
index 4a2f68b457..0000000000
--- a/apps/speech/.gitignore
+++ /dev/null
@@ -1,39 +0,0 @@
-# Learn more https://docs.github.com/en/get-started/getting-started-with-git/ignoring-files
-
-# dependencies
-node_modules/
-
-# Expo
-.expo/
-dist/
-web-build/
-expo-env.d.ts
-
-# Native
-*.orig.*
-*.jks
-*.p8
-*.p12
-*.key
-*.mobileprovision
-
-# Metro
-.metro-health-check*
-
-# debug
-npm-debug.*
-yarn-debug.*
-yarn-error.*
-
-# macOS
-.DS_Store
-*.pem
-
-# local env files
-.env*.local
-
-# typescript
-*.tsbuildinfo
-
-.yarn
-
diff --git a/apps/speech/App.tsx b/apps/speech/App.tsx
deleted file mode 100644
index 3532fbce1a..0000000000
--- a/apps/speech/App.tsx
+++ /dev/null
@@ -1,127 +0,0 @@
-import React, { useState } from 'react';
-import { View, Text, StyleSheet, TouchableOpacity } from 'react-native';
-import { TextToSpeechScreen } from './screens/TextToSpeechScreen';
-import { SpeechToTextScreen } from './screens/SpeechToTextScreen';
-import { VoiceActivityDetectionScreen } from './screens/VoiceActivityDetectionScreen';
-import ColorPalette from './colors';
-import ExecutorchLogo from './assets/executorch.svg';
-import { Quiz } from './screens/Quiz';
-import { TextToSpeechLLMScreen } from './screens/TextToSpeechLLMScreen';
-import { initExecutorch } from 'react-native-executorch';
-import { ExpoResourceFetcher } from 'react-native-executorch-expo-resource-fetcher';
-
-initExecutorch({
-  resourceFetcher: ExpoResourceFetcher,
-});
-
-export default function App() {
-  const [currentScreen, setCurrentScreen] = useState<
-    | 'menu'
-    | 'speech-to-text'
-    | 'text-to-speech'
-    | 'quiz'
-    | 'text-to-speech-llm'
-    | 'vad'
-  >('menu');
-
-  const goToMenu = () => setCurrentScreen('menu');
-
-  if (currentScreen === 'text-to-speech') {
-    return <TextToSpeechScreen onBack={goToMenu} />;
-  }
-
-  if (currentScreen === 'speech-to-text') {
-    return <SpeechToTextScreen onBack={goToMenu} />;
-  }
-
-  if (currentScreen === 'vad') {
-    return <VoiceActivityDetectionScreen onBack={goToMenu} />;
-  }
-
-  if (currentScreen === 'quiz') {
-    return <Quiz onBack={goToMenu} />;
-  }
-
-  if (currentScreen === 'text-to-speech-llm') {
-    return <TextToSpeechLLMScreen onBack={goToMenu} />;
-  }
-
-  return (
-    <View style={styles.container}>
-      <ExecutorchLogo width={64} height={64} />
-      <Text style={styles.headerText}>Select a demo model</Text>
-      <View style={styles.buttonContainer}>
-        <TouchableOpacity
-          style={styles.button}
-          onPress={() => setCurrentScreen('speech-to-text')}
-        >
-          <Text style={styles.buttonText}>Speech to Text</Text>
-        </TouchableOpacity>
-        <TouchableOpacity
-          style={styles.button}
-          onPress={() => setCurrentScreen('vad')}
-        >
-          <Text style={styles.buttonText}>Voice Activity Detection</Text>
-        </TouchableOpacity>
-        <TouchableOpacity
-          style={styles.button}
-          onPress={() => setCurrentScreen('text-to-speech')}
-        >
-          <Text style={styles.buttonText}>Text to Speech</Text>
-        </TouchableOpacity>
-        <TouchableOpacity
-          style={styles.button}
-          onPress={() => setCurrentScreen('quiz')}
-        >
-          <Text style={styles.buttonText}>Text to Speech - Quiz</Text>
-        </TouchableOpacity>
-        <TouchableOpacity
-          style={styles.button}
-          onPress={() => setCurrentScreen('text-to-speech-llm')}
-        >
-          <Text style={styles.buttonText}>Text to Speech - LLM Streaming</Text>
-        </TouchableOpacity>
-      </View>
-    </View>
-  );
-}
-
-export const fontSizes = {
-  xxl: 34,
-  xl: 22,
-  lg: 18,
-  md: 16,
-  sm: 14,
-  xs: 12,
-  xxs: 10,
-};
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-    backgroundColor: '#fff',
-  },
-  headerText: {
-    fontSize: fontSizes.lg,
-    color: ColorPalette.strongPrimary,
-    margin: 20,
-  },
-  buttonContainer: {
-    width: '80%',
-    justifyContent: 'space-evenly',
-    marginBottom: 20,
-  },
-  button: {
-    backgroundColor: ColorPalette.strongPrimary,
-    borderRadius: 8,
-    padding: 10,
-    alignItems: 'center',
-    marginBottom: 10,
-  },
-  buttonText: {
-    color: 'white',
-    fontSize: fontSizes.md,
-  },
-});
diff --git a/apps/speech/app.json b/apps/speech/app.json
deleted file mode 100644
index 170d1a20c7..0000000000
--- a/apps/speech/app.json
+++ /dev/null
@@ -1,68 +0,0 @@
-{
-  "expo": {
-    "name": "speech",
-    "slug": "speech",
-    "version": "1.0.0",
-    "orientation": "portrait",
-    "icon": "./assets/icon.png",
-    "userInterfaceStyle": "light",
-    "newArchEnabled": true,
-    "splash": {
-      "image": "./assets/splash-icon.png",
-      "resizeMode": "contain",
-      "backgroundColor": "#ffffff"
-    },
-    "ios": {
-      "supportsTablet": true,
-      "bundleIdentifier": "com.anonymous.speech",
-      "infoPlist": {
-        "NSMicrophoneUsageDescription": "This app needs access to your microphone to record audio."
-      },
-      "entitlements": {
-        "com.apple.developer.kernel.increased-memory-limit": true
-      }
-    },
-    "android": {
-      "adaptiveIcon": {
-        "foregroundImage": "./assets/adaptive-icon.png",
-        "backgroundColor": "#ffffff"
-      },
-      "package": "com.anonymous.speech",
-      "permissions": [
-        "android.permission.RECORD_AUDIO",
-        "android.permission.MODIFY_AUDIO_SETTINGS",
-        "android.permission.FOREGROUND_SERVICE",
-        "android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK"
-      ]
-    },
-    "web": {
-      "favicon": "./assets/favicon.png"
-    },
-    "plugins": [
-      "expo-font",
-      [
-        "react-native-audio-api",
-        {
-          "iosBackgroundMode": true,
-          "iosMicrophonePermission": "This app requires access to the microphone to record audio.",
-          "androidPermissions": [
-            "android.permission.MODIFY_AUDIO_SETTINGS",
-            "android.permission.FOREGROUND_SERVICE",
-            "android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK",
-            "android.permission.RECORD_AUDIO"
-          ],
-          "androidForegroundService": true,
-          "androidFSTypes": ["mediaPlayback", "microphone"]
-        }
-      ],
-      [
-        "expo-build-properties",
-        {
-          "ios": {
-            "deploymentTarget": "17.0"
-          }
-        }
-      ]
-    ]
-  }
-}
diff --git a/apps/speech/assets/adaptive-icon.png b/apps/speech/assets/adaptive-icon.png
deleted file mode 100644
index 03d6f6b6c6..0000000000
Binary files a/apps/speech/assets/adaptive-icon.png and /dev/null differ
diff --git a/apps/speech/assets/executorch.svg b/apps/speech/assets/executorch.svg
deleted file mode 100644
index e548ea4201..0000000000
--- a/apps/speech/assets/executorch.svg
+++ /dev/null
@@ -1,9 +0,0 @@
-<svg width="65" height="64" viewBox="0 0 65 64" fill="none" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
-<path d="M0.5 4C0.5 1.79086 2.29086 0 4.5 0H60.5C62.7091 0 64.5 1.79086 64.5 4V60C64.5 62.2091 62.7091 64 60.5 64H4.5C2.29086 64 0.5 62.2091 0.5 60V4Z" fill="url(#pattern0_13229_4194)"/>
-<defs>
-<pattern id="pattern0_13229_4194" patternContentUnits="objectBoundingBox" width="1" height="1">
-<use xlink:href="#image0_13229_4194" transform="translate(-0.000263435) scale(0.00052687)"/>
-</pattern>
-<image id="image0_13229_4194" width="1899" height="1898" preserveAspectRatio="none" xlink:href="data:image/png;base64,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"/>
-</defs>
-</svg>
diff --git a/apps/speech/assets/favicon.png b/apps/speech/assets/favicon.png
deleted file mode 100644
index e75f697b18..0000000000
Binary files a/apps/speech/assets/favicon.png and /dev/null differ
diff --git a/apps/speech/assets/icon.png b/apps/speech/assets/icon.png
deleted file mode 100644
index a0b1526fc7..0000000000
Binary files a/apps/speech/assets/icon.png and /dev/null differ
diff --git a/apps/speech/assets/quiz-data.ts b/apps/speech/assets/quiz-data.ts
deleted file mode 100644
index 71cfdc5445..0000000000
--- a/apps/speech/assets/quiz-data.ts
+++ /dev/null
@@ -1,864 +0,0 @@
-// --- Data ---
-// cspell:ignoreRegExp /export const QUESTIONS = \[[\s\S]*?\];/
-export const QUESTIONS = [
-  {
-    q: 'What is the capital of Japan?',
-    a: ['Beijing', 'Seoul', 'Tokyo', 'Kyoto'],
-    c: 2,
-    e: 'Tokyo is the capital of Japan.',
-    context:
-      "Tokyo, formerly known as Edo, became the capital of Japan in 1868. It is one of the world's most populous cities and a major center for finance, culture, and technology. Tokyo hosts the Imperial Palace and is famous for its blend of traditional and modern architecture.",
-  },
-  {
-    q: 'Who wrote "Romeo and Juliet"?',
-    a: ['Mark Twain', 'William Shakespeare', 'Charles Dickens', 'Jane Austen'],
-    c: 1,
-    e: 'William Shakespeare wrote Romeo and Juliet.',
-    context:
-      'William Shakespeare was an English playwright and poet, widely regarded as the greatest writer in the English language. "Romeo and Juliet" is one of his most famous tragedies, exploring themes of love, fate, and family conflict in Renaissance Italy.',
-  },
-  {
-    q: 'Which planet has the most moons in our solar system?',
-    a: ['Mars', 'Earth', 'Jupiter', 'Venus'],
-    c: 2,
-    e: 'Jupiter has the most known moons.',
-    context:
-      'Jupiter has over 90 known moons, including Ganymede, the largest moon in the solar system. Its strong gravity allows it to capture many objects as moons. Saturn also has many moons, but Jupiter currently holds the record.',
-  },
-  {
-    q: 'What gas do plants use for photosynthesis?',
-    a: ['Oxygen', 'Carbon dioxide', 'Nitrogen', 'Helium'],
-    c: 1,
-    e: 'Plants use carbon dioxide for photosynthesis.',
-    context:
-      'Photosynthesis is the process by which plants convert carbon dioxide and water into glucose and oxygen using sunlight. This process is essential for life on Earth, as it provides oxygen and food for many organisms.',
-  },
-  {
-    q: 'Who painted the Sistine Chapel ceiling?',
-    a: ['Raphael', 'Leonardo da Vinci', 'Michelangelo', 'Donatello'],
-    c: 2,
-    e: 'Michelangelo painted the Sistine Chapel ceiling.',
-    context:
-      'Michelangelo was an Italian Renaissance artist known for his sculptures and paintings. The Sistine Chapel ceiling, painted between 1508 and 1512, features scenes from the Book of Genesis and is considered a masterpiece of Western art.',
-  },
-  {
-    q: 'What is the largest continent by land area?',
-    a: ['Africa', 'Asia', 'Europe', 'Antarctica'],
-    c: 1,
-    e: 'Asia is the largest continent by land area.',
-    context:
-      "Asia covers about 30% of Earth's land area and is home to more than half of the world's population. It includes diverse regions such as the Middle East, South Asia, East Asia, and Siberia.",
-  },
-  {
-    q: 'Which element has the chemical symbol "O"?',
-    a: ['Gold', 'Oxygen', 'Silver', 'Iron'],
-    c: 1,
-    e: 'O is the symbol for oxygen.',
-    context:
-      "Oxygen is a vital element for life, making up about 21% of Earth's atmosphere. It is essential for respiration in most living organisms and is highly reactive, forming compounds with many other elements.",
-  },
-  {
-    q: 'In which year did the first man land on the moon?',
-    a: ['1969', '1959', '1979', '1965'],
-    c: 0,
-    e: 'The first moon landing was in 1969.',
-    context:
-      'Apollo 11 was the mission that first landed humans on the Moon. Neil Armstrong and Buzz Aldrin walked on the lunar surface, while Michael Collins orbited above. The event marked a major milestone in space exploration.',
-  },
-  {
-    q: 'What is the smallest prime number?',
-    a: ['0', '1', '2', '3'],
-    c: 2,
-    e: '2 is the smallest prime number.',
-    context:
-      'A prime number is a natural number greater than 1 that has no positive divisors other than 1 and itself. 2 is the only even prime number, as all other even numbers are divisible by 2.',
-  },
-  {
-    q: 'Which ocean lies on the east coast of the United States?',
-    a: ['Pacific', 'Atlantic', 'Indian', 'Arctic'],
-    c: 1,
-    e: 'The Atlantic Ocean is on the east coast.',
-    context:
-      'The Atlantic Ocean is the second-largest ocean and separates North America from Europe and Africa. Major cities like New York, Miami, and Boston are located along its coast.',
-  },
-  {
-    q: 'What currency is used in the United Kingdom?',
-    a: ['Euro', 'Pound', 'Dollar', 'Franc'],
-    c: 1,
-    e: 'The British pound is the currency of the UK.',
-    context:
-      'The pound sterling, commonly known as the pound, is the official currency of the United Kingdom. It is one of the oldest currencies still in use and is subdivided into 100 pence.',
-  },
-  {
-    q: 'Who discovered penicillin?',
-    a: ['Alexander Fleming', 'Marie Curie', 'Louis Pasteur', 'Gregor Mendel'],
-    c: 0,
-    e: 'Alexander Fleming discovered penicillin.',
-    context:
-      'Penicillin was the first true antibiotic discovered by Alexander Fleming in 1928. It has saved countless lives by effectively treating bacterial infections.',
-  },
-  {
-    q: 'What is the human body organ that pumps blood?',
-    a: ['Liver', 'Lung', 'Heart', 'Kidney'],
-    c: 2,
-    e: 'The heart pumps blood in the body.',
-    context:
-      'The heart is a muscular organ about the size of a fist, located slightly left of the center of the chest. It pumps blood through the circulatory system, supplying oxygen and nutrients to the body.',
-  },
-  {
-    q: 'Which country is known for the pyramids at Giza?',
-    a: ['Mexico', 'Peru', 'Egypt', 'Sudan'],
-    c: 2,
-    e: 'Egypt is famous for the pyramids at Giza.',
-    context:
-      'The Giza pyramid complex is one of the most famous archaeological sites in the world. The Great Pyramid of Giza is the largest pyramid in Egypt and one of the Seven Wonders of the Ancient World.',
-  },
-  {
-    q: 'Which language has the most native speakers worldwide?',
-    a: ['English', 'Spanish', 'Mandarin', 'Hindi'],
-    c: 2,
-    e: 'Mandarin Chinese has the most native speakers.',
-    context:
-      'Mandarin is the most widely spoken language in the world, with over a billion native speakers. It is the official language of China and Taiwan, and one of the official languages of Singapore.',
-  },
-  {
-    q: 'What is H2O commonly called?',
-    a: ['Salt', 'Hydrogen', 'Water', 'Oxygen'],
-    c: 2,
-    e: 'H2O is the chemical formula for water.',
-    context:
-      "Water is essential for all known forms of life. It covers about 71% of Earth's surface and is vital for drinking, agriculture, and industry.",
-  },
-  {
-    q: 'Which metal is liquid at room temperature?',
-    a: ['Mercury', 'Gold', 'Silver', 'Copper'],
-    c: 0,
-    e: 'Mercury is liquid at room temperature.',
-    context:
-      'Mercury is the only metal that is liquid at standard conditions for temperature and pressure. It is used in thermometers, barometers, and some electrical switches.',
-  },
-  {
-    q: 'What is the fastest land animal?',
-    a: ['Lion', 'Cheetah', 'Horse', 'Kangaroo'],
-    c: 1,
-    e: 'The cheetah is the fastest land animal.',
-    context:
-      'The cheetah can reach speeds of up to 75 miles per hour (120 kilometers per hour) in short bursts covering distances up to 500 meters. It is built for speed with a lightweight body and long legs.',
-  },
-  {
-    q: 'Which organ in plants makes food using sunlight?',
-    a: ['Root', 'Stem', 'Leaf', 'Flower'],
-    c: 2,
-    e: 'Leaves perform photosynthesis to make food.',
-    context:
-      'Photosynthesis occurs in the chloroplasts of plant cells, which contain chlorophyll that captures sunlight. This process converts carbon dioxide and water into glucose and oxygen.',
-  },
-  {
-    q: 'Who composed the Fifth Symphony known as "fate"?',
-    a: ['Mozart', 'Beethoven', 'Bach', 'Chopin'],
-    c: 1,
-    e: 'Beethoven composed the Fifth Symphony.',
-    context:
-      'Ludwig van Beethoven was a German composer and pianist. His Fifth Symphony, composed between 1804 and 1808, is one of the most performed symphonies and is known for its distinctive four-note motif.',
-  },
-  {
-    q: 'What is the boiling point of water at sea level in Celsius?',
-    a: ['90', '95', '100', '105'],
-    c: 2,
-    e: 'Water boils at 100 degrees Celsius at sea level.',
-    context:
-      'The boiling point of water can change depending on the atmospheric pressure. At higher altitudes, water boils at a lower temperature due to reduced pressure.',
-  },
-  {
-    q: 'Which city is known as the Big Apple?',
-    a: ['Los Angeles', 'Chicago', 'New York', 'Miami'],
-    c: 2,
-    e: 'New York City is nicknamed the Big Apple.',
-    context:
-      'The nickname "The Big Apple" originally referred to New York City\'s horse racing tracks. It later became popularized in the 1970s and is now a widely recognized nickname for the city.',
-  },
-  {
-    q: 'What is the longest river in the world by length?',
-    a: ['Nile', 'Amazon', 'Yangtze', 'Mississippi'],
-    c: 0,
-    e: 'The Nile has long been considered the longest.',
-    context:
-      'The Nile River in Africa is approximately 6650 kilometers (4130 miles) long. It flows through eleven countries and is essential for agriculture and water supply in the region.',
-  },
-  {
-    q: 'Which planet is closest to the Sun?',
-    a: ['Venus', 'Mercury', 'Earth', 'Mars'],
-    c: 1,
-    e: 'Mercury is the planet closest to the Sun.',
-    context:
-      'Mercury is the smallest planet in our solar system and orbits the Sun at an average distance of about 57.91 million kilometers (36 million miles).',
-  },
-  {
-    q: 'Who developed the theory of relativity?',
-    a: ['Isaac Newton', 'Albert Einstein', 'Niels Bohr', 'Galileo'],
-    c: 1,
-    e: 'Albert Einstein developed the theory of relativity.',
-    context:
-      "Einstein's theory of relativity, published in 1905, revolutionized our understanding of space, time, and gravity. It introduced the famous equation E=mc², linking energy and mass.",
-  },
-  {
-    q: 'What is the main language spoken in Brazil?',
-    a: ['Spanish', 'Portuguese', 'French', 'English'],
-    c: 1,
-    e: 'Portuguese is the main language in Brazil.',
-    context:
-      "Brazil is the largest country in South America and the only one in the region where Portuguese is the official language. This is due to Brazil's colonization by Portugal in the 16th century.",
-  },
-  {
-    q: 'What instrument has keys, pedals, and strings?',
-    a: ['Guitar', 'Violin', 'Piano', 'Flute'],
-    c: 2,
-    e: 'The piano has keys, pedals, and strings.',
-    context:
-      'The piano is a musical instrument played by pressing keys that cause hammers to strike strings, producing sound. It is widely used in classical and popular music.',
-  },
-  {
-    q: 'Which country gifted the Statue of Liberty to the USA?',
-    a: ['Germany', 'France', 'Italy', 'Spain'],
-    c: 1,
-    e: 'France gifted the Statue of Liberty to the USA.',
-    context:
-      'The Statue of Liberty was a gift from the people of France to the United States, dedicated in 1886. It was designed by French sculptor Frédéric Auguste Bartholdi and symbolizes freedom and democracy.',
-  },
-  {
-    q: "Which gas is most abundant in Earth's atmosphere?",
-    a: ['Oxygen', 'Carbon dioxide', 'Nitrogen', 'Argon'],
-    c: 2,
-    e: 'Nitrogen is the most abundant gas in the atmosphere.',
-    context:
-      "Nitrogen makes up about 78% of Earth's atmosphere by volume. It is a colorless, odorless gas that is essential for life, as it is a key component of amino acids and nucleic acids.",
-  },
-  {
-    q: 'What is the chemical symbol for gold?',
-    a: ['Au', 'Ag', 'Gd', 'Go'],
-    c: 0,
-    e: 'Au is the chemical symbol for gold.',
-    context:
-      'Gold is a dense, malleable metal with the chemical symbol Au (from Latin: aurum) and atomic number 79. It is highly valued for its use in jewelry, currency, and other arts.',
-  },
-  {
-    q: 'Who painted "The Starry Night"?',
-    a: ['Paul Cezanne', 'Vincent van Gogh', 'Pablo Picasso', 'Claude Monet'],
-    c: 1,
-    e: 'Vincent van Gogh painted The Starry Night.',
-    context:
-      "The Starry Night is one of Vincent van Gogh's most famous paintings, created in 1889. It depicts a swirling night sky over a quiet town, expressing van Gogh's emotional turmoil and fascination with the night.",
-  },
-  {
-    q: 'Which year did World War 2 end?',
-    a: ['1944', '1945', '1946', '1947'],
-    c: 1,
-    e: 'World War 2 ended in 1945.',
-    context:
-      "World War 2 was a global conflict that lasted from 1939 to 1945. It involved most of the world's nations and resulted in significant changes to the global political and social landscape.",
-  },
-  {
-    q: 'What is the largest mammal?',
-    a: ['Elephant', 'Blue whale', 'Giraffe', 'Hippopotamus'],
-    c: 1,
-    e: 'The blue whale is the largest mammal.',
-    context:
-      'The blue whale is the largest animal known to have ever existed, reaching lengths of up to 100 feet (30 meters) and weights of up to 200 tons. They are found in oceans worldwide and primarily eat small shrimp-like animals called krill.',
-  },
-  {
-    q: 'Which element is needed to make steel?',
-    a: ['Carbon', 'Helium', 'Nitrogen', 'Neon'],
-    c: 0,
-    e: 'Carbon is combined with iron to make steel.',
-    context:
-      'Steel is an alloy made primarily of iron and carbon. The carbon content determines the hardness and strength of the steel. Other elements may also be added to create different types of steel.',
-  },
-  {
-    q: 'Who is the author of the Harry Potter series?',
-    a: ['C S Lewis', 'J R R Tolkien', 'J K Rowling', 'Philip Pullman'],
-    c: 2,
-    e: 'J K Rowling wrote the Harry Potter series.',
-    context:
-      'The Harry Potter series is a globally popular fantasy book series written by J.K. Rowling. It follows the life and adventures of a young wizard, Harry Potter, and his friends.',
-  },
-  {
-    q: 'Which country uses the Yen as its currency?',
-    a: ['China', 'Japan', 'South Korea', 'Vietnam'],
-    c: 1,
-    e: 'Japan uses the Yen as its currency.',
-    context:
-      'The yen is the official currency of Japan, introduced in 1871. It is one of the most traded currencies in the world and is known for its stability.',
-  },
-  {
-    q: 'Which vitamin is produced when skin is exposed to sunlight?',
-    a: ['Vitamin A', 'Vitamin B', 'Vitamin C', 'Vitamin D'],
-    c: 3,
-    e: 'Vitamin D is produced in skin after sunlight exposure.',
-    context:
-      'Vitamin D is essential for maintaining healthy bones and teeth, and it plays a role in immune system function. The body produces vitamin D in response to skin being exposed to sunlight.',
-  },
-  {
-    q: 'What is the tallest mountain in the world above sea level?',
-    a: ['K2', 'Kangchenjunga', 'Mount Everest', 'Lhotse'],
-    c: 2,
-    e: 'Mount Everest is the tallest above sea level.',
-    context:
-      "Mount Everest, located in the Himalayas on the border of Nepal and the Tibet Autonomous Region of China, is the Earth's highest mountain above sea level, with a peak at 8848.86 meters (29031.7 ft).",
-  },
-  {
-    q: 'What device converts alternating current to direct current?',
-    a: ['Transformer', 'Rectifier', 'Generator', 'Inverter'],
-    c: 1,
-    e: 'A rectifier converts AC to DC.',
-    context:
-      'A rectifier is an electrical device that converts alternating current (AC) to direct current (DC). It allows current to flow in one direction only, effectively converting the AC waveform to a DC waveform.',
-  },
-  {
-    q: 'Which two colors make green when mixed in paint?',
-    a: ['Red and Blue', 'Blue and Yellow', 'Red and Yellow', 'Blue and Green'],
-    c: 1,
-    e: 'Blue and yellow mix to make green.',
-    context:
-      'In color theory, blue and yellow are primary colors that, when mixed together, create green, which is a secondary color. This is due to the way our eyes perceive color and the way light wavelengths combine.',
-  },
-  {
-    q: 'Who was the first president of United States?',
-    a: [
-      'Abraham Lincoln',
-      'George Washington',
-      'Thomas Jefferson',
-      'John Adams',
-    ],
-    c: 1,
-    e: 'George Washington was the first president of United States.',
-    context:
-      'George Washington was unanimously elected as the first President of the United States in 1788. He served two terms from 1789 to 1797 and is often called the "Father of His Country".',
-  },
-  {
-    q: 'Which organ breaks down food and absorbs nutrients?',
-    a: ['Lung', 'Kidney', 'Stomach and intestine', 'Heart'],
-    c: 2,
-    e: 'Stomach and intestines digest and absorb nutrients.',
-    context:
-      'The digestive system breaks down food into smaller molecules, which are then absorbed into the bloodstream through the walls of the intestines. The stomach and intestines play key roles in this process.',
-  },
-  {
-    q: 'Which bird is known for its ability to mimic human speech?',
-    a: ['Eagle', 'Parrot', 'Sparrow', 'Ostrich'],
-    c: 1,
-    e: 'Parrots can mimic human speech.',
-    context:
-      'Some species of parrots are known for their ability to imitate human speech and other sounds. This ability varies among individual birds and is thought to be a form of social learning.',
-  },
-  {
-    q: 'What is the study of past human activity called?',
-    a: ['Anthropology', 'Archaeology', 'Sociology', 'Geology'],
-    c: 1,
-    e: 'Archaeology studies past human activity.',
-    context:
-      'Archaeology is the scientific study of ancient cultures and human activity through the examination of artifacts, structures, and other physical remains.',
-  },
-  {
-    q: 'Which substance makes up the majority of the Sun?',
-    a: ['Iron', 'Hydrogen', 'Carbon', 'Silicon'],
-    c: 1,
-    e: 'Hydrogen is the main element in the Sun.',
-    context:
-      'The Sun is composed of about 74% hydrogen, 24% helium, and 2% heavier elements. Hydrogen is the primary fuel for the nuclear fusion reactions that power the Sun.',
-  },
-  {
-    q: 'Who invented the telephone?',
-    a: [
-      'Thomas Edison',
-      'Alexander Graham Bell',
-      'Nikola Tesla',
-      'Guglielmo Marconi',
-    ],
-    c: 1,
-    e: 'Alexander Graham Bell is credited with the telephone.',
-    context:
-      'Alexander Graham Bell was a Scottish-born inventor, scientist, and teacher who is credited with inventing the first practical telephone. He was awarded the first US patent for the invention of the telephone.',
-  },
-  {
-    q: 'What is the capital of Canada?',
-    a: ['Toronto', 'Montreal', 'Vancouver', 'Ottawa'],
-    c: 3,
-    e: 'Ottawa is the capital of Canada.',
-    context:
-      'Ottawa is the capital city of Canada, located in the province of Ontario. It became the capital in 1857 and is home to many national institutions, including the Parliament of Canada.',
-  },
-  {
-    q: 'Which planet is known for its rings?',
-    a: ['Mars', 'Jupiter', 'Saturn', 'Uranus'],
-    c: 2,
-    e: 'Saturn is famous for its rings.',
-    context:
-      "Saturn is the sixth planet from the Sun and is known for its prominent ring system, which is made up of ice particles, rocky debris, and dust. The rings are thought to be remnants of moons or comets that were torn apart by Saturn's gravity.",
-  },
-  {
-    q: 'Which chemical is used as table salt?',
-    a: ['Sodium chloride', 'Potassium', 'Magnesium', 'Calcium'],
-    c: 0,
-    e: 'Table salt is sodium chloride.',
-    context:
-      'Table salt is chemically known as sodium chloride (NaCl). It is composed of sodium ions and chloride ions and is used in food preparation and preservation.',
-  },
-  {
-    q: 'Who painted "Guernica"?',
-    a: ['Salvador Dali', 'Pablo Picasso', 'Henri Matisse', 'Jackson Pollock'],
-    c: 1,
-    e: 'Pablo Picasso painted Guernica.',
-    context:
-      'Guernica is a mural-sized oil painting on canvas by Spanish artist Pablo Picasso, completed in 1937. It is one of the most famous anti-war artworks, depicting the suffering caused by war and violence.',
-  },
-  {
-    q: 'What is the largest desert in the world?',
-    a: ['Sahara', 'Gobi', 'Arabian', 'Antarctic desert'],
-    c: 3,
-    e: 'The Antarctic is the largest desert by area.',
-    context:
-      'The Antarctic Desert is the largest desert in the world, covering an area of about 14 million square kilometers (5.5 million square miles). It is classified as a desert due to its extremely low humidity and precipitation.',
-  },
-  {
-    q: 'Which sport uses a shuttlecock?',
-    a: ['Tennis', 'Badminton', 'Squash', 'Table tennis'],
-    c: 1,
-    e: 'Badminton uses a shuttlecock.',
-    context:
-      "Badminton is a racquet sport played using shuttlecocks and a lightweight racquet. The game is played on a rectangular court divided by a net, and the objective is to hit the shuttlecock over the net and into the opponent's court.",
-  },
-  {
-    q: 'What is the freezing point of water in Fahrenheit?',
-    a: ['0', '32', '100', '212'],
-    c: 1,
-    e: 'Water freezes at 32 degrees Fahrenheit.',
-    context:
-      'The freezing point of water is 32 degrees Fahrenheit (0 degrees Celsius) at standard atmospheric pressure. At this temperature, water molecules slow down and form a crystalline structure, resulting in ice.',
-  },
-  {
-    q: 'Which continent has the most countries?',
-    a: ['Asia', 'Africa', 'Europe', 'South America'],
-    c: 1,
-    e: 'Africa has the most countries of any continent.',
-    context:
-      'Africa is the second-largest and second-most populous continent, with 54 recognized sovereign states. It has a diverse range of cultures, languages, and ecosystems.',
-  },
-  {
-    q: 'What is the main ingredient in traditional sushi?',
-    a: ['Beef', 'Rice', 'Potatoes', 'Cheese'],
-    c: 1,
-    e: 'Rice is the main ingredient in sushi.',
-    context:
-      'Sushi is a Japanese dish typically made with vinegared rice, raw fish, and other ingredients like vegetables and seaweed. The rice is the essential component that defines sushi.',
-  },
-  {
-    q: 'Which famous physicist wrote "A Brief History of Time"?',
-    a: ['Richard Feynman', 'Stephen Hawking', 'Carl Sagan', 'Brian Cox'],
-    c: 1,
-    e: 'Stephen Hawking wrote A Brief History of Time.',
-    context:
-      'A Brief History of Time is a popular science book written by physicist Stephen Hawking. It explains complex concepts in cosmology, such as the Big Bang, black holes, and light cones, in accessible language.',
-  },
-  {
-    q: 'Which city is the capital of Australia?',
-    a: ['Sydney', 'Melbourne', 'Canberra', 'Perth'],
-    c: 2,
-    e: 'Canberra is the capital of Australia.',
-    context:
-      'Canberra is the capital city of Australia, located in the Australian Capital Territory. It was selected as the capital in 1908 as a compromise between rivals Sydney and Melbourne.',
-  },
-  {
-    q: 'What is the largest organ in the human body?',
-    a: ['Liver', 'Skin', 'Heart', 'Brain'],
-    c: 1,
-    e: 'Skin is the largest organ of the human body.',
-    context:
-      "The skin is the body's largest organ, covering an area of about 2 square meters (22 square feet) in adults. It protects internal organs, regulates temperature, and enables the sense of touch.",
-  },
-  {
-    q: 'Which gas do humans inhale to survive?',
-    a: ['Carbon dioxide', 'Nitrogen', 'Oxygen', 'Helium'],
-    c: 2,
-    e: 'Humans inhale oxygen to survive.',
-    context:
-      'Oxygen is essential for human survival as it is required for cellular respiration, the process by which cells produce energy. Humans inhale air containing oxygen through the respiratory system.',
-  },
-  {
-    q: 'Who developed the theory of evolution by natural selection?',
-    a: ['Gregor Mendel', 'Charles Darwin', 'Louis Pasteur', 'Alfred Wallace'],
-    c: 1,
-    e: 'Charles Darwin proposed natural selection.',
-    context:
-      'Charles Darwin was an English naturalist, geologist, and biologist best known for his contributions to the science of evolution. He proposed the theory of natural selection as the mechanism of evolution.',
-  },
-  {
-    q: 'What instrument measures temperature?',
-    a: ['Barometer', 'Thermometer', 'Hygrometer', 'Ammeter'],
-    c: 1,
-    e: 'A thermometer measures temperature.',
-    context:
-      'A thermometer is a device that measures temperature, typically using a glass tube filled with mercury or alcohol that expands and contracts with temperature changes.',
-  },
-  {
-    q: 'Which country has the largest population?',
-    a: ['India', 'United States', 'China', 'Russia'],
-    c: 2,
-    e: 'China has the largest population.',
-    context:
-      'China is the most populous country in the world, with a population of over 1.4 billion people. It is followed by India, the United States, and Indonesia.',
-  },
-  {
-    q: 'What is the chemical formula for table sugar (sucrose)?',
-    a: ['C6H12O6', 'C12H22O11', 'H2O', 'CO2'],
-    c: 1,
-    e: 'Sucrose has formula C12H22O11.',
-    context:
-      'Table sugar, or sucrose, is a carbohydrate composed of glucose and fructose units. It is commonly used as a sweetener in food and drinks.',
-  },
-  {
-    q: 'Which author wrote "Pride and Prejudice"?',
-    a: ['Emily Bronte', 'Charlotte Bronte', 'Jane Austen', 'Mary Shelley'],
-    c: 2,
-    e: 'Jane Austen wrote Pride and Prejudice.',
-    context:
-      'Pride and Prejudice is a novel written by Jane Austen, published in 1813. It is a romantic fiction that critiques the British landed gentry at the end of the 18th century.',
-  },
-  {
-    q: 'What is the largest island in the world?',
-    a: ['Greenland', 'Madagascar', 'Borneo', 'New Guinea'],
-    c: 0,
-    e: 'Greenland is the largest island.',
-    context:
-      "Greenland is the world's largest island that is not a continent. It is located between the Arctic and Atlantic Oceans and is an autonomous territory within the Kingdom of Denmark.",
-  },
-  {
-    q: 'Which planet is known as the Red Planet?',
-    a: ['Earth', 'Mars', 'Venus', 'Mercury'],
-    c: 1,
-    e: 'Mars is known as the Red Planet.',
-    context:
-      'Mars is often called the Red Planet because of its reddish appearance, which is due to iron oxide (rust) on its surface. It is the fourth planet from the Sun and has the largest dust storms in the solar system.',
-  },
-  {
-    q: 'Who is credited with inventing the light bulb?',
-    a: ['Nikola Tesla', 'Thomas Edison', 'Alexander Graham Bell', 'James Watt'],
-    c: 1,
-    e: 'Thomas Edison is commonly credited for the light bulb.',
-    context:
-      'Thomas Edison was an American inventor and businessman who is credited with developing the first commercially successful incandescent light bulb.',
-  },
-  {
-    q: 'What is the capital of Italy?',
-    a: ['Milan', 'Naples', 'Rome', 'Florence'],
-    c: 2,
-    e: 'Rome is the capital of Italy.',
-    context:
-      'Rome, the "Eternal City", is the capital of Italy and of the Lazio region. It is known for its nearly 3000 years of globally influential art, architecture, and culture.',
-  },
-  {
-    q: 'Which metal has the highest electrical conductivity?',
-    a: ['Gold', 'Silver', 'Copper', 'Aluminum'],
-    c: 1,
-    e: 'Silver has the highest conductivity of common metals.',
-    context:
-      'Silver is a metal known for its high electrical conductivity, thermal conductivity, and reflectivity. It is used in electrical contacts, conductors, and in various electronic devices.',
-  },
-  {
-    q: 'What is the largest city in India by population?',
-    a: ['Delhi', 'Mumbai', 'Bangalore', 'Kolkata'],
-    c: 1,
-    e: 'Mumbai is the largest city by population in India.',
-    context:
-      'Mumbai, formerly known as Bombay, is the most populous city in India and the seventh most populous city in the world. It is the financial, commercial, and entertainment hub of India.',
-  },
-  {
-    q: 'Which mountain range includes Mount Kilimanjaro?',
-    a: [
-      'Andes',
-      'Himalayas',
-      'Kilimanjaro is a standalone mountain',
-      'Rockies',
-    ],
-    c: 2,
-    e: 'Kilimanjaro is a free standing mountain, not part of a range.',
-    context:
-      'Mount Kilimanjaro is a dormant stratovolcano located in Tanzania. It is the highest mountain in Africa, standing at 5895 meters (19341 feet) above sea level.',
-  },
-  {
-    q: 'Which animal is known as the king of the jungle?',
-    a: ['Tiger', 'Elephant', 'Lion', 'Bear'],
-    c: 2,
-    e: 'The lion is often called the king of the jungle.',
-    context:
-      'The lion is a large cat species found in Africa and India. It is known for its strength, courage, and majestic appearance. The term "king of the jungle" is a colloquial expression and lions actually inhabit grasslands and savannas.',
-  },
-  {
-    q: 'What is the primary language of Egypt?',
-    a: ['Arabic', 'English', 'French', 'Greek'],
-    c: 0,
-    e: 'Arabic is the primary language in Egypt.',
-    context:
-      'Arabic is the official language of Egypt and is spoken by the vast majority of the population. Egypt is also known for its ancient civilization and historical monuments.',
-  },
-  {
-    q: 'Which country has the largest area in the world?',
-    a: ['United States', 'China', 'Russia', 'Canada'],
-    c: 2,
-    e: 'Russia is the largest country by area.',
-    context:
-      'Russia is the largest country in the world by land area, covering more than 17 million square kilometers. It spans Eastern Europe and northern Asia, and has a wide range of environments and landscapes.',
-  },
-  {
-    q: 'Who painted the Mona Lisa?',
-    a: ['Michelangelo', 'Leonardo da Vinci', 'Rembrandt', 'Raphael'],
-    c: 1,
-    e: 'Leonardo da Vinci painted the Mona Lisa.',
-    context:
-      'The Mona Lisa is a half-length portrait painting by the Italian Renaissance artist Leonardo da Vinci. It is considered an archetypal masterpiece of the Italian Renaissance and is one of the most famous paintings in the world.',
-  },
-  {
-    q: 'Which chemical element has atomic number 1?',
-    a: ['Helium', 'Hydrogen', 'Oxygen', 'Lithium'],
-    c: 1,
-    e: 'Hydrogen has atomic number 1.',
-    context:
-      'Hydrogen is the chemical element with the symbol H and atomic number 1. It is the lightest and most abundant element in the universe, making up about 75% of its elemental mass.',
-  },
-  {
-    q: 'What is the capital of Germany?',
-    a: ['Munich', 'Frankfurt', 'Berlin', 'Hamburg'],
-    c: 2,
-    e: 'Berlin is the capital of Germany.',
-    context:
-      'Berlin is the capital and largest city of Germany, located in the northeastern part of the country. It is known for its cultural heritage, modern architecture, and vibrant arts scene.',
-  },
-  {
-    q: 'Which famous scientist formulated the laws of motion?',
-    a: ['Albert Einstein', 'Isaac Newton', 'Galileo Galilei', 'Max Planck'],
-    c: 1,
-    e: 'Isaac Newton formulated the classical laws of motion.',
-    context:
-      'Isaac Newton was an English mathematician, physicist, and astronomer who is widely recognized for formulating the laws of motion and universal gravitation.',
-  },
-  {
-    q: 'What is the main ingredient in hummus?',
-    a: ['Lentils', 'Chickpeas', 'Beans', 'Peas'],
-    c: 1,
-    e: 'Hummus is made primarily from chickpeas.',
-    context:
-      'Hummus is a spread made from cooked, mashed chickpeas or other beans, and is a common part of Levantine and Middle Eastern cuisines. It is often served with pita bread.',
-  },
-  {
-    q: 'What is the largest lake by area in Africa?',
-    a: ['Lake Victoria', 'Lake Tanganyika', 'Lake Malawi', 'Lake Turkana'],
-    c: 0,
-    e: 'Lake Victoria is the largest lake in Africa by area.',
-    context:
-      'Lake Victoria is the largest lake in Africa and the second-largest freshwater lake in the world by surface area. It is bordered by three countries: Tanzania, Uganda, and Kenya.',
-  },
-  {
-    q: 'Which composer wrote the opera La Traviata?',
-    a: ['Wagner', 'Verdi', 'Puccini', 'Mozart'],
-    c: 1,
-    e: 'Giuseppe Verdi composed La Traviata.',
-    context:
-      'La Traviata is an opera in three acts by Giuseppe Verdi, premiered in 1853. It is based on the novel "La Dame aux Camélias" by Alexandre Dumas fils and is one of the most performed operas worldwide.',
-  },
-  {
-    q: 'Which city is home to the Colosseum?',
-    a: ['Athens', 'Rome', 'Istanbul', 'Naples'],
-    c: 1,
-    e: 'The Colosseum is located in Rome.',
-    context:
-      'The Colosseum, also known as the Flavian Amphitheatre, is an ancient oval amphitheatre located in the center of Rome. It is the largest amphitheatre ever built and is considered one of the greatest works of Roman architecture and engineering.',
-  },
-  {
-    q: 'What is the capital of Spain?',
-    a: ['Valencia', 'Seville', 'Madrid', 'Barcelona'],
-    c: 2,
-    e: 'Madrid is the capital of Spain.',
-    context:
-      'Madrid is the capital and largest city of Spain, located in the center of the country. It is known for its cultural and artistic heritage, as well as its vibrant nightlife.',
-  },
-  {
-    q: 'Which planet has a day longer than its year?',
-    a: ['Mercury', 'Venus', 'Mars', 'Earth'],
-    c: 1,
-    e: 'Venus rotates slowly so its day is longer than its year.',
-    context:
-      'Venus is the second planet from the Sun and has a very slow rotation on its axis, taking about 243 Earth days to complete one rotation. However, its orbit around the Sun takes only about 225 Earth days.',
-  },
-  {
-    q: 'Who wrote "The Odyssey"?',
-    a: ['Homer', 'Virgil', 'Sophocles', 'Plato'],
-    c: 0,
-    e: 'Homer is attributed as the author of The Odyssey.',
-    context:
-      'The Odyssey is an ancient Greek epic poem attributed to Homer. It is one of the two major ancient Greek epic poems, the other being the Iliad, and it consists of 24 books.',
-  },
-  {
-    q: 'Which organ is primarily responsible for detoxifying chemicals?',
-    a: ['Heart', 'Lung', 'Liver', 'Spleen'],
-    c: 2,
-    e: 'The liver detoxifies many chemicals in the body.',
-    context:
-      'The liver is a vital organ that plays a key role in metabolism, digestion, and detoxification. It filters blood coming from the digestive tract and detoxifies chemicals, metabolizes drugs, and secretes bile.',
-  },
-  {
-    q: 'Which country is famous for maple syrup?',
-    a: ['United States', 'Canada', 'Norway', 'Sweden'],
-    c: 1,
-    e: 'Canada is famous for maple syrup.',
-    context:
-      'Canada is the largest producer of maple syrup in the world, accounting for about 71% of the global market share. Maple syrup is a traditional Canadian sweetener made from the sap of sugar maple trees.',
-  },
-  {
-    q: 'What is the common name for sodium bicarbonate?',
-    a: ['Baking soda', 'Table salt', 'Vinegar', 'Baking powder'],
-    c: 0,
-    e: 'Sodium bicarbonate is known as baking soda.',
-    context:
-      'Sodium bicarbonate, commonly known as baking soda, is a chemical compound with the formula NaHCO₃. It is used in baking as a leavening agent, and also has various household and industrial uses.',
-  },
-  {
-    q: 'Which sea creature has eight arms?',
-    a: ['Shark', 'Octopus', 'Dolphin', 'Jellyfish'],
-    c: 1,
-    e: 'An octopus has eight arms.',
-    context:
-      'Octopuses are marine animals known for their eight arms, which are lined with sensitive suckers. They are intelligent creatures and can change color and texture to blend in with their surroundings.',
-  },
-  {
-    q: 'What is the capital of Russia?',
-    a: ['Saint Petersburg', 'Moscow', 'Novosibirsk', 'Sochi'],
-    c: 1,
-    e: 'Moscow is the capital of Russia.',
-    context:
-      'Moscow is the capital and largest city of Russia, located in the western part of the country. It is known for its rich cultural history, architecture, and as a major political, economic, and scientific center.',
-  },
-  {
-    q: 'Which instrument is primarily used in jazz as a brass reed instrument?',
-    a: ['Violin', 'Saxophone', 'Clarinet', 'Oboe'],
-    c: 1,
-    e: 'The saxophone is a common brass reed instrument in jazz.',
-    context:
-      'The saxophone is a musical instrument invented by Adolphe Sax in the 1840s. It is a key instrument in jazz music, known for its expressive range and timbre.',
-  },
-  {
-    q: 'What is the largest planet in our solar system?',
-    a: ['Earth', 'Saturn', 'Jupiter', 'Neptune'],
-    c: 2,
-    e: 'Jupiter is the largest planet in the solar system.',
-    context:
-      'Jupiter is the fifth planet from the Sun and is more than twice as massive as all the other planets in the solar system combined. It has a thick atmosphere made up mostly of hydrogen and helium.',
-  },
-  {
-    q: 'Which chemical element is liquid and used in thermometers?',
-    a: ['Mercury', 'Lead', 'Sodium', 'Iron'],
-    c: 0,
-    e: 'Mercury is used in some thermometers.',
-    context:
-      'Mercury is a chemical element with the symbol Hg and atomic number 80. It is a heavy, silvery-white liquid metal that is used in thermometers, barometers, and other scientific instruments.',
-  },
-  {
-    q: 'Who is known as the father of modern physics and developed the laws of motion?',
-    a: ['Benjamin Franklin', 'Isaac Newton', 'Albert Einstein', 'Nikola Tesla'],
-    c: 1,
-    e: 'Isaac Newton developed the laws of motion.',
-    context:
-      'Isaac Newton is often referred to as the father of modern physics for his groundbreaking work in the 17th century. He formulated the laws of motion and universal gravitation, laying the foundation for classical mechanics.',
-  },
-  {
-    q: 'Which country is famous for the tango dance?',
-    a: ['Brazil', 'Argentina', 'Mexico', 'Chile'],
-    c: 1,
-    e: 'Argentina is famous for the tango.',
-    context:
-      'The tango is a partner dance that originated in the 1880s along the River Plate, the natural border between Argentina and Uruguay. It is now popular worldwide and is known for its passionate and dramatic style.',
-  },
-  {
-    q: 'What is the capital of South Africa (one of them)?',
-    a: ['Cape Town', 'Pretoria', 'Johannesburg', 'Durban'],
-    c: 1,
-    e: "Pretoria is one of South Africa's capitals (administrative).",
-    context:
-      'South Africa has three capital cities: Pretoria (administrative), Cape Town (legislative), and Bloemfontein (judicial). Pretoria is known for its diplomatic missions and embassies.',
-  },
-  {
-    q: 'Which substance is needed for combustion?',
-    a: ['Oxygen', 'Helium', 'Nitrogen', 'Carbon dioxide'],
-    c: 0,
-    e: 'Oxygen supports combustion.',
-    context:
-      'Combustion is a chemical process that occurs when a substance reacts rapidly with oxygen and releases energy in the form of light and heat. Oxygen is essential for combustion to occur.',
-  },
-  {
-    q: 'Who wrote the novel "Moby Dick"?',
-    a: [
-      'Herman Melville',
-      'Ernest Hemingway',
-      'F Scott Fitzgerald',
-      'Mark Twain',
-    ],
-    c: 0,
-    e: 'Herman Melville is the author of Moby Dick.',
-    context:
-      "Moby Dick is an 1851 novel by Herman Melville. The book is the sailor Ishmael's narrative of the obsessive quest of Ahab, captain of the whaling ship Pequod, for revenge on Moby Dick.",
-  },
-  {
-    q: 'What is the primary material used to make glass?',
-    a: ['Iron', 'Sand', 'Wood', 'Clay'],
-    c: 1,
-    e: 'Glass is primarily made from silica sand.',
-    context:
-      'Glass is a solid material that is typically made from silica (silicon dioxide) sand, soda ash, and limestone. It is used in windows, bottles, and many other applications.',
-  },
-  {
-    q: 'Which famous tower leans and is in Italy?',
-    a: ['Eiffel Tower', 'Leaning Tower of Pisa', 'Big Ben', 'CN Tower'],
-    c: 1,
-    e: 'The Leaning Tower of Pisa is in Italy.',
-    context:
-      'The Leaning Tower of Pisa is a freestanding bell tower located in Pisa, Italy. It is famous for its unintended tilt, which began during its construction in the 12th century.',
-  },
-  {
-    q: 'Which organ controls the nervous system?',
-    a: ['Heart', 'Brain', 'Liver', 'Kidney'],
-    c: 1,
-    e: 'The brain controls the nervous system.',
-    context:
-      'The brain is the central organ of the human nervous system, and with the spinal cord, it makes up the central nervous system (CNS). It is responsible for processing sensory information and coordinating bodily functions.',
-  },
-  {
-    q: 'What is the capital of Turkey?',
-    a: ['Istanbul', 'Ankara', 'Izmir', 'Bursa'],
-    c: 1,
-    e: 'Ankara is the capital of Turkey.',
-    context:
-      'Ankara is the capital of Turkey, located in the central part of the country. It became the capital in 1923, replacing Istanbul as the capital of the Republic of Turkey.',
-  },
-  {
-    q: 'Which sport is played at Wimbledon?',
-    a: ['Cricket', 'Tennis', 'Football', 'Rugby'],
-    c: 1,
-    e: 'Wimbledon is a major tennis tournament.',
-    context:
-      'The Wimbledon Championships is the oldest tennis tournament in the world, and is considered the most prestigious. It has been held at the All England Club in Wimbledon, London, since 1877.',
-  },
-  {
-    q: 'What metal is primarily used to make aircraft bodies due to its light weight?',
-    a: ['Steel', 'Titanium', 'Aluminum', 'Copper'],
-    c: 2,
-    e: 'Aluminum is widely used for aircraft bodies.',
-    context:
-      'Aluminum is a lightweight, durable metal that is resistant to corrosion, making it ideal for aircraft construction. It is used in the manufacture of aircraft bodies, wings, and other components.',
-  },
-  {
-    q: 'Which ocean is between Africa and Australia?',
-    a: ['Atlantic', 'Pacific', 'Indian', 'Arctic'],
-    c: 2,
-    e: 'The Indian Ocean lies between Africa and Australia.',
-    context:
-      "The Indian Ocean is the third-largest ocean, covering about 20% of the Earth's water surface. It is bounded by Africa, Asia, Australia, and the Indian subcontinent.",
-  },
-];
diff --git a/apps/speech/assets/splash-icon.png b/apps/speech/assets/splash-icon.png
deleted file mode 100644
index 03d6f6b6c6..0000000000
Binary files a/apps/speech/assets/splash-icon.png and /dev/null differ
diff --git a/apps/speech/assets/swm_icon.svg b/apps/speech/assets/swm_icon.svg
deleted file mode 100644
index 8c62f039be..0000000000
--- a/apps/speech/assets/swm_icon.svg
+++ /dev/null
@@ -1,13 +0,0 @@
-<svg width="47" height="25" viewBox="0 0 47 25" fill="none" xmlns="http://www.w3.org/2000/svg">
-<g clip-path="url(#clip0_2_550)">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M0.575378 0.0757751H1.14095H38.7328H38.9679L39.1338 0.24327L46.1469 7.3266L46.3114 7.49283V7.72729V24.2424V24.8106H45.7459H8.19177H7.9575L7.79185 24.6442L0.741031 17.5609L0.575378 17.3945V17.1591V0.643957V0.0757751ZM1.70653 2.01567V16.9238L7.62618 22.8707V7.96262L1.70653 2.01567ZM2.50637 1.21214L8.42604 7.15911H44.3856L38.4976 1.21214H2.50637ZM45.1803 23.6743H8.75733V8.29548H45.1803V23.6743Z" fill="#001A72"/>
-<path d="M17.9197 17.6137C17.9197 18.8637 17.1279 19.9243 15.1295 19.9243C14.2623 19.9243 13.5836 19.7349 12.9426 19.4697V17.7652C13.5836 18.1061 14.3754 18.2955 15.0918 18.2955C15.7328 18.2955 16.0721 18.1061 16.0721 17.7273C16.0721 16.5909 12.9426 16.9318 12.9426 14.5833C12.9426 13.144 14.1115 12.2349 15.6951 12.2349C16.3738 12.2349 16.9771 12.3864 17.618 12.7652V14.5833C16.7508 14.053 16.1475 13.8637 15.6574 13.8637C15.0541 13.8637 14.7525 14.0909 14.7525 14.4318C14.7148 15.5303 17.9197 15.1137 17.9197 17.6137Z" fill="#001A72"/>
-<path d="M30.4 12.4242L28.0246 19.7727H26.2147L24.6311 14.697L23.0098 19.7348H21.2L18.8246 12.3864H20.8607L22.1803 17.3106L23.7262 12.3864H25.5361L27.082 17.3106L28.4016 12.3864H30.4V12.4242Z" fill="#001A72"/>
-<path d="M41.7492 14.9243V19.7727H39.9394V15.2273C39.9394 14.4318 39.3738 13.9773 38.7705 13.9773C38.1295 13.9773 37.6017 14.4318 37.6017 15.2273V19.7727H35.7918V15.2273C35.7918 14.4318 35.2263 13.9773 34.623 13.9773C33.982 13.9773 33.4541 14.4318 33.4541 15.2273V19.7727H31.6443V12.4243H33.341V12.9546C33.8689 12.4243 34.4345 12.2349 35.1131 12.2349C35.8672 12.2349 36.5459 12.5758 36.9984 13.1818C37.6017 12.5379 38.3558 12.2349 39.223 12.2349C40.6935 12.2727 41.7492 13.3333 41.7492 14.9243Z" fill="#001A72"/>
-</g>
-<defs>
-<clipPath id="clip0_2_550">
-<rect width="46" height="25" fill="white" transform="translate(0.5)"/>
-</clipPath>
-</defs>
-</svg>
diff --git a/apps/speech/colors.ts b/apps/speech/colors.ts
deleted file mode 100644
index feb75ac336..0000000000
--- a/apps/speech/colors.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-const ColorPalette = {
-  primary: '#001A72',
-  strongPrimary: '#020F3C',
-};
-
-export default ColorPalette;
diff --git a/apps/speech/components/ErrorBanner.tsx b/apps/speech/components/ErrorBanner.tsx
deleted file mode 100644
index a5bebc504f..0000000000
--- a/apps/speech/components/ErrorBanner.tsx
+++ /dev/null
@@ -1,53 +0,0 @@
-import React from 'react';
-import { View, Text, TouchableOpacity, StyleSheet } from 'react-native';
-
-interface ErrorBannerProps {
-  message: string | null;
-  onDismiss: () => void;
-}
-
-export default function ErrorBanner({ message, onDismiss }: ErrorBannerProps) {
-  if (!message) return null;
-
-  return (
-    <View style={styles.container}>
-      <Text style={styles.message} numberOfLines={3}>
-        {message}
-      </Text>
-      <TouchableOpacity onPress={onDismiss} style={styles.closeButton}>
-        <Text style={styles.closeText}>✕</Text>
-      </TouchableOpacity>
-    </View>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: {
-    backgroundColor: '#FEE2E2',
-    borderLeftWidth: 4,
-    borderLeftColor: '#EF4444',
-    borderRadius: 8,
-    marginHorizontal: 16,
-    marginVertical: 8,
-    paddingVertical: 10,
-    paddingLeft: 12,
-    paddingRight: 8,
-    flexDirection: 'row',
-    alignItems: 'center',
-  },
-  message: {
-    flex: 1,
-    color: '#991B1B',
-    fontSize: 14,
-    lineHeight: 20,
-  },
-  closeButton: {
-    padding: 4,
-    marginLeft: 8,
-  },
-  closeText: {
-    color: '#991B1B',
-    fontSize: 16,
-    fontWeight: '600',
-  },
-});
diff --git a/apps/speech/components/ModelPicker.tsx b/apps/speech/components/ModelPicker.tsx
deleted file mode 100644
index f06d156329..0000000000
--- a/apps/speech/components/ModelPicker.tsx
+++ /dev/null
@@ -1,201 +0,0 @@
-import React, { useEffect, useRef, useState } from 'react';
-import {
-  Dimensions,
-  Modal,
-  ScrollView,
-  StyleSheet,
-  Text,
-  TouchableOpacity,
-  TouchableWithoutFeedback,
-  View,
-} from 'react-native';
-
-export type ModelOption<T> = {
-  label: string;
-  value: T;
-};
-
-type Props<T> = {
-  models: ModelOption<T>[];
-  selectedModel: T;
-  onSelect: (model: T) => void;
-  label?: string;
-  disabled?: boolean;
-};
-
-const DROPDOWN_MAX_HEIGHT = 300;
-
-export function ModelPicker<T>({
-  models,
-  selectedModel,
-  onSelect,
-  label,
-  disabled,
-}: Props<T>) {
-  const [open, setOpen] = useState(false);
-  const [dropdownLayout, setDropdownLayout] = useState({
-    x: 0,
-    y: 0,
-    width: 0,
-  });
-  const triggerRef = useRef<React.ComponentRef<typeof TouchableOpacity>>(null);
-  const selected = models.find((m) => m.value === selectedModel);
-
-  useEffect(() => {
-    if (disabled) setOpen(false);
-  }, [disabled]);
-
-  const handlePress = () => {
-    if (disabled) return;
-    if (open) {
-      setOpen(false);
-      return;
-    }
-    triggerRef.current?.measure(
-      (
-        _x: number,
-        _y: number,
-        width: number,
-        height: number,
-        pageX: number,
-        pageY: number
-      ) => {
-        const spaceBelow = Dimensions.get('window').height - (pageY + height);
-        const y =
-          spaceBelow >= DROPDOWN_MAX_HEIGHT
-            ? pageY + height + 2
-            : pageY - Math.min(DROPDOWN_MAX_HEIGHT, models.length * 42) - 2;
-        setDropdownLayout({ x: pageX, y, width });
-        setOpen(true);
-      }
-    );
-  };
-
-  return (
-    <View style={styles.container}>
-      <TouchableOpacity
-        ref={triggerRef}
-        style={[styles.trigger, disabled && styles.triggerDisabled]}
-        onPress={handlePress}
-        activeOpacity={disabled ? 1 : 0.7}
-      >
-        {label && <Text style={styles.label}>{label}</Text>}
-        <Text style={styles.triggerText}>{selected?.label ?? '—'}</Text>
-        <Text style={styles.chevron}>{open ? '▲' : '▼'}</Text>
-      </TouchableOpacity>
-
-      <Modal
-        visible={open}
-        transparent
-        animationType="none"
-        onRequestClose={() => setOpen(false)}
-      >
-        <TouchableWithoutFeedback onPress={() => setOpen(false)}>
-          <View style={StyleSheet.absoluteFill}>
-            <ScrollView
-              style={[
-                styles.dropdown,
-                {
-                  top: dropdownLayout.y,
-                  left: dropdownLayout.x,
-                  width: dropdownLayout.width,
-                },
-              ]}
-              keyboardShouldPersistTaps="handled"
-            >
-              {models.map((item) => {
-                const isSelected = item.value === selectedModel;
-                return (
-                  <TouchableOpacity
-                    key={item.label}
-                    style={[styles.option, isSelected && styles.optionSelected]}
-                    onPress={() => {
-                      onSelect(item.value);
-                      setOpen(false);
-                    }}
-                  >
-                    <Text
-                      style={[
-                        styles.optionText,
-                        isSelected && styles.optionTextSelected,
-                      ]}
-                    >
-                      {item.label}
-                    </Text>
-                  </TouchableOpacity>
-                );
-              })}
-            </ScrollView>
-          </View>
-        </TouchableWithoutFeedback>
-      </Modal>
-    </View>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: {
-    marginHorizontal: 12,
-    marginVertical: 4,
-    alignSelf: 'stretch',
-  },
-  trigger: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    borderWidth: 1,
-    borderColor: '#C1C6E5',
-    borderRadius: 8,
-    paddingHorizontal: 12,
-    paddingVertical: 10,
-    backgroundColor: '#f5f5f5',
-  },
-  triggerDisabled: {
-    opacity: 0.4,
-  },
-  label: {
-    fontSize: 12,
-    color: '#888',
-    marginRight: 6,
-  },
-  triggerText: {
-    flex: 1,
-    fontSize: 14,
-    color: '#001A72',
-    fontWeight: '500',
-  },
-  chevron: {
-    fontSize: 10,
-    color: '#888',
-    marginLeft: 6,
-  },
-  dropdown: {
-    position: 'absolute',
-    borderWidth: 1,
-    borderColor: '#C1C6E5',
-    borderRadius: 8,
-    backgroundColor: '#fff',
-    maxHeight: DROPDOWN_MAX_HEIGHT,
-    elevation: 8,
-    shadowColor: '#000',
-    shadowOffset: { width: 0, height: 2 },
-    shadowOpacity: 0.15,
-    shadowRadius: 4,
-  },
-  option: {
-    paddingHorizontal: 12,
-    paddingVertical: 10,
-    borderBottomWidth: 1,
-    borderBottomColor: '#f0f0f0',
-  },
-  optionSelected: {
-    backgroundColor: '#e8ecf8',
-  },
-  optionText: {
-    fontSize: 14,
-    color: '#333',
-  },
-  optionTextSelected: {
-    color: '#001A72',
-    fontWeight: '600',
-  },
-});
diff --git a/apps/speech/components/VerboseTranscription.tsx b/apps/speech/components/VerboseTranscription.tsx
deleted file mode 100644
index 1093b2bd1c..0000000000
--- a/apps/speech/components/VerboseTranscription.tsx
+++ /dev/null
@@ -1,241 +0,0 @@
-import React from 'react';
-import { View, Text, StyleSheet } from 'react-native';
-import { TranscriptionResult } from 'react-native-executorch';
-
-export const VerboseTranscription = ({
-  data,
-}: {
-  data: TranscriptionResult;
-}) => {
-  if (!data) return null;
-
-  const hasSegments = Array.isArray(data.segments) && data.segments.length > 0;
-
-  const hasLanguage =
-    !!data.language && data.language !== 'N/A' && data.language.trim() !== '';
-
-  const hasDuration = typeof data.duration === 'number' && data.duration > 0;
-
-  const hasMetadata = hasLanguage || hasDuration;
-
-  return (
-    <View style={styles.container}>
-      <View style={styles.metaContainer}>
-        <Text style={styles.label}>Full Text:</Text>
-        <Text style={styles.text}>{data.text || ''}</Text>
-
-        {hasMetadata && (
-          <View style={styles.row}>
-            {hasLanguage && (
-              <Text style={styles.metaItem}>Language: {data.language}</Text>
-            )}
-            {hasDuration && (
-              <Text style={styles.metaItem}>
-                Duration: {data.duration?.toFixed(2)}s
-              </Text>
-            )}
-          </View>
-        )}
-      </View>
-
-      {hasSegments && (
-        <>
-          <Text style={styles.sectionHeader}>
-            Segments ({data.segments?.length})
-          </Text>
-
-          {data.segments?.map((seg, index) => (
-            <View key={index} style={styles.segmentCard}>
-              <View style={styles.segmentHeader}>
-                <Text style={styles.timeBadge}>
-                  {seg.start.toFixed(2)}s - {seg.end.toFixed(2)}s
-                </Text>
-                <Text style={styles.segmentId}>ID: {index}</Text>
-              </View>
-
-              <Text style={styles.segmentText}>"{seg.text}"</Text>
-
-              {seg.words && seg.words.length > 0 && (
-                <View style={styles.wordsContainer}>
-                  <Text style={styles.statLabel}>Word Timestamps:</Text>
-                  <View style={styles.wordsGrid}>
-                    {seg.words.map((w, wIdx) => (
-                      <View key={wIdx} style={styles.wordChip}>
-                        <Text style={styles.wordText}>{w.word.trim()}</Text>
-                        <Text style={styles.wordTime}>
-                          {w.start.toFixed(2)}s
-                        </Text>
-                      </View>
-                    ))}
-                  </View>
-                </View>
-              )}
-
-              <View style={styles.statsGrid}>
-                <View style={styles.statItem}>
-                  <Text style={styles.statLabel}>Avg LogProb</Text>
-                  <Text style={styles.statValue}>
-                    {data.task === 'transcribe'
-                      ? seg.avgLogprob?.toFixed(4)
-                      : 'N/A'}
-                  </Text>
-                </View>
-                <View style={styles.statItem}>
-                  <Text style={styles.statLabel}>Temp</Text>
-                  <Text style={styles.statValue}>
-                    {data.task === 'transcribe'
-                      ? seg.temperature?.toFixed(2)
-                      : 'N/A'}
-                  </Text>
-                </View>
-                <View style={styles.statItem}>
-                  {/*eslint-disable-next-line @cspell/spellchecker*/}
-                  <Text style={styles.statLabel}>Compr.</Text>
-                  <Text style={styles.statValue}>
-                    {data.task === 'transcribe'
-                      ? seg.compressionRatio?.toFixed(2)
-                      : 'N/A'}
-                  </Text>
-                </View>
-              </View>
-            </View>
-          ))}
-        </>
-      )}
-    </View>
-  );
-};
-
-const styles = StyleSheet.create({
-  container: {
-    padding: 4,
-  },
-  metaContainer: {
-    marginBottom: 16,
-    padding: 12,
-    backgroundColor: '#f0f2f5',
-    borderRadius: 8,
-  },
-  label: {
-    fontWeight: 'bold',
-    color: '#0f186e',
-    marginBottom: 4,
-  },
-  text: {
-    fontSize: 16,
-    color: '#333',
-    marginBottom: 8,
-  },
-  row: {
-    flexDirection: 'row',
-    gap: 10,
-    marginTop: 8,
-  },
-  metaItem: {
-    fontSize: 12,
-    color: '#666',
-    backgroundColor: '#e1e4e8',
-    paddingHorizontal: 8,
-    paddingVertical: 2,
-    borderRadius: 4,
-    overflow: 'hidden',
-  },
-  sectionHeader: {
-    fontSize: 18,
-    fontWeight: 'bold',
-    color: '#0f186e',
-    marginBottom: 8,
-    marginTop: 8,
-  },
-  segmentCard: {
-    backgroundColor: '#fff',
-    borderRadius: 8,
-    borderWidth: 1,
-    borderColor: '#e1e4e8',
-    marginBottom: 12,
-    padding: 12,
-    shadowColor: '#000',
-    shadowOffset: { width: 0, height: 1 },
-    shadowOpacity: 0.1,
-    shadowRadius: 2,
-    elevation: 2,
-  },
-  segmentHeader: {
-    flexDirection: 'row',
-    justifyContent: 'space-between',
-    marginBottom: 8,
-  },
-  timeBadge: {
-    fontSize: 12,
-    fontWeight: 'bold',
-    color: '#fff',
-    backgroundColor: '#0f186e',
-    paddingHorizontal: 8,
-    paddingVertical: 2,
-    borderRadius: 12,
-    overflow: 'hidden',
-  },
-  segmentId: {
-    fontSize: 12,
-    color: '#888',
-  },
-  segmentText: {
-    fontSize: 15,
-    fontStyle: 'italic',
-    color: '#333',
-    marginBottom: 12,
-  },
-  statsGrid: {
-    flexDirection: 'row',
-    flexWrap: 'wrap',
-    gap: 8,
-    borderTopWidth: 1,
-    borderTopColor: '#f0f0f0',
-    paddingTop: 8,
-  },
-  statItem: {
-    flex: 1,
-    minWidth: '45%',
-    flexDirection: 'row',
-    justifyContent: 'space-between',
-  },
-  statLabel: {
-    fontSize: 11,
-    color: '#888',
-  },
-  statValue: {
-    fontSize: 11,
-    fontWeight: '600',
-    color: '#444',
-  },
-  wordsContainer: {
-    marginVertical: 8,
-    backgroundColor: '#f8f9fa',
-    padding: 8,
-    borderRadius: 6,
-  },
-  wordsGrid: {
-    flexDirection: 'row',
-    flexWrap: 'wrap',
-    gap: 6,
-    marginTop: 4,
-  },
-  wordChip: {
-    backgroundColor: '#ffffff',
-    borderWidth: 1,
-    borderColor: '#e1e4e8',
-    borderRadius: 4,
-    paddingHorizontal: 6,
-    paddingVertical: 2,
-    alignItems: 'center',
-  },
-  wordText: {
-    fontSize: 12,
-    color: '#333',
-  },
-  wordTime: {
-    fontSize: 9,
-    color: '#888',
-    marginTop: 1,
-  },
-});
diff --git a/apps/speech/declarations.d.ts b/apps/speech/declarations.d.ts
deleted file mode 100644
index 85e178f497..0000000000
--- a/apps/speech/declarations.d.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-declare module '*.svg' {
-  import { SvgProps } from 'react-native-svg';
-  const content: React.FV<SvgProps>;
-  export default content;
-}
diff --git a/apps/speech/index.ts b/apps/speech/index.ts
deleted file mode 100644
index 1d6e981ef6..0000000000
--- a/apps/speech/index.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-import { registerRootComponent } from 'expo';
-
-import App from './App';
-
-// registerRootComponent calls AppRegistry.registerComponent('main', () => App);
-// It also ensures that whether you load the app in Expo Go or in a native build,
-// the environment is set up appropriately
-registerRootComponent(App);
diff --git a/apps/speech/metro.config.js b/apps/speech/metro.config.js
deleted file mode 100644
index f58bbc2131..0000000000
--- a/apps/speech/metro.config.js
+++ /dev/null
@@ -1,19 +0,0 @@
-const { getDefaultConfig } = require('expo/metro-config');
-
-const config = getDefaultConfig(__dirname);
-
-const { transformer, resolver } = config;
-
-config.transformer = {
-  ...transformer,
-  babelTransformerPath: require.resolve('react-native-svg-transformer/expo'),
-};
-config.resolver = {
-  ...resolver,
-  assetExts: resolver.assetExts.filter((ext) => ext !== 'svg'),
-  sourceExts: [...resolver.sourceExts, 'svg'],
-};
-
-config.resolver.assetExts.push('pte');
-
-module.exports = config;
diff --git a/apps/speech/package.json b/apps/speech/package.json
deleted file mode 100644
index 9a06a3e3e4..0000000000
--- a/apps/speech/package.json
+++ /dev/null
@@ -1,42 +0,0 @@
-{
-  "name": "speech",
-  "version": "1.0.0",
-  "main": "index.ts",
-  "scripts": {
-    "start": "expo start",
-    "android": "expo run:android",
-    "ios": "expo run:ios",
-    "web": "expo start --web",
-    "typecheck": "tsc",
-    "lint": "eslint . --ext .ts,.tsx --fix"
-  },
-  "dependencies": {
-    "@expo/vector-icons": "^15.0.2",
-    "@react-native/metro-config": "^0.85.3",
-    "buffer": "^6.0.3",
-    "expo": "~56.0.9",
-    "expo-build-properties": "~56.0.17",
-    "expo-font": "~56.0.5",
-    "expo-status-bar": "~56.0.4",
-    "metro-config": "^0.84.0",
-    "react": "19.2.3",
-    "react-native": "0.85.3",
-    "react-native-audio-api": "0.12.2",
-    "react-native-device-info": "^15.0.2",
-    "react-native-executorch": "workspace:*",
-    "react-native-executorch-expo-resource-fetcher": "workspace:*",
-    "react-native-reanimated": "4.3.1",
-    "react-native-safe-area-context": "~5.7.0",
-    "react-native-svg": "15.15.4",
-    "react-native-svg-transformer": "^1.5.3",
-    "react-native-worklets": "0.8.3"
-  },
-  "devDependencies": {
-    "@babel/core": "^7.29.0",
-    "@types/react": "~19.2.14",
-    "@types/react-refresh": "^0",
-    "babel-preset-expo": "~56.0.14",
-    "react-refresh": "^0.18.0"
-  },
-  "private": true
-}
diff --git a/apps/speech/screens/Quiz.tsx b/apps/speech/screens/Quiz.tsx
deleted file mode 100644
index ffd574d96d..0000000000
--- a/apps/speech/screens/Quiz.tsx
+++ /dev/null
@@ -1,506 +0,0 @@
-import React, { useEffect, useRef, useState, useCallback } from 'react';
-import {
-  Text,
-  View,
-  StyleSheet,
-  TouchableOpacity,
-  Platform,
-  ScrollView,
-  KeyboardAvoidingView,
-} from 'react-native';
-import Animated, {
-  useSharedValue,
-  useAnimatedStyle,
-  withTiming,
-  withSequence,
-  withDelay,
-  runOnJS,
-} from 'react-native-reanimated';
-import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
-import { models, useTextToSpeech } from 'react-native-executorch';
-import {
-  AudioManager,
-  AudioContext,
-  AudioBuffer,
-} from 'react-native-audio-api';
-import FontAwesome from '@expo/vector-icons/FontAwesome';
-import SWMIcon from '../assets/swm_icon.svg';
-import { QUESTIONS } from '../assets/quiz-data';
-
-// Shuffle helper
-function shuffleArray<T>(array: T[]): T[] {
-  const arr = array.slice();
-  for (let i = arr.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [arr[i], arr[j]] = [arr[j], arr[i]];
-  }
-  return arr;
-}
-
-// --- Audio Helper ---
-const createAudioBufferFromVector = (
-  audioVector: Float32Array,
-  audioContext: AudioContext | null = null,
-  sampleRate: number = 24000
-): AudioBuffer => {
-  if (audioContext == null) audioContext = new AudioContext({ sampleRate });
-  const audioBuffer = audioContext.createBuffer(
-    1,
-    audioVector.length,
-    sampleRate
-  );
-  const channelData = audioBuffer.getChannelData(0);
-  channelData.set(audioVector);
-  return audioBuffer;
-};
-
-export const Quiz = ({ onBack }: { onBack: () => void }) => {
-  // --- Hooks & State ---
-  const model = useTextToSpeech(models.text_to_speech.kokoro.en_us.santa());
-
-  const [shuffledQuestions] = useState(() => shuffleArray(QUESTIONS));
-  const [currentIndex, setCurrentIndex] = useState(0);
-  const [selectedAnswer, setSelectedAnswer] = useState<number | null>(null);
-  const [isAnswerCorrect, setIsAnswerCorrect] = useState<boolean | null>(null);
-  const [showNext, setShowNext] = useState(false);
-  const [isSpeaking, setIsSpeaking] = useState(false);
-  const fadeAnim = useSharedValue(1);
-  const feedbackAnim = useSharedValue(0);
-  const nextButtonAnim = useSharedValue(0);
-  const buttonsInactiveAnim = useSharedValue(1);
-
-  const audioContextRef = useRef<AudioContext | null>(null);
-  const currentSourceRef = useRef<any>(null);
-  const isTransitioningRef = useRef(false);
-  const autoSpeakRef = useRef(true);
-
-  // Animated Styles
-  const containerStyle = useAnimatedStyle(() => ({
-    opacity: fadeAnim.value,
-  }));
-
-  const feedbackStyle = useAnimatedStyle(() => ({
-    opacity: feedbackAnim.value,
-  }));
-
-  const nextButtonStyle = useAnimatedStyle(() => ({
-    opacity: nextButtonAnim.value * buttonsInactiveAnim.value,
-    transform: [
-      {
-        translateY: (1 - nextButtonAnim.value) * 12,
-      },
-    ],
-  }));
-
-  // --- Audio Setup ---
-  useEffect(() => {
-    AudioManager.setAudioSessionOptions({
-      iosCategory: 'playAndRecord',
-      iosMode: 'spokenAudio',
-      iosOptions: ['defaultToSpeaker'],
-    });
-
-    audioContextRef.current = new AudioContext({ sampleRate: 24000 });
-    audioContextRef.current.suspend();
-
-    return () => {
-      audioContextRef.current?.close();
-      audioContextRef.current = null;
-    };
-  }, []);
-
-  // --- TTS Function ---
-  const speak = useCallback(
-    async (text: string) => {
-      if (!text.trim() || !model.isReady) {
-        setIsSpeaking(false);
-        return;
-      }
-
-      // Stop previous audio if any
-      if (currentSourceRef.current) {
-        try {
-          currentSourceRef.current.stop();
-        } catch (e) {}
-      }
-
-      setIsSpeaking(true);
-      try {
-        const audioContext = audioContextRef.current;
-        if (!audioContext) return;
-        if (audioContext.state === 'suspended') await audioContext.resume();
-
-        const onNext = async (audioVec: Float32Array) => {
-          return new Promise<void>((resolve) => {
-            const audioBuffer = createAudioBufferFromVector(
-              audioVec,
-              audioContext,
-              24000
-            );
-            const source = audioContext.createBufferSource();
-            source.buffer = audioBuffer;
-            source.connect(audioContext.destination);
-            currentSourceRef.current = source;
-            source.onEnded = () => resolve();
-            source.start();
-          });
-        };
-
-        await model.stream({ text, speed: 0.9, onNext, onEnd: async () => {} });
-      } catch (e) {
-        console.error(e);
-      } finally {
-        setIsSpeaking(false);
-      }
-    },
-    [model]
-  );
-
-  // --- Game Logic ---
-  const currentQ = shuffledQuestions[currentIndex];
-
-  // Speak question on load
-  useEffect(() => {
-    if (!model.isReady) return;
-    if (!autoSpeakRef.current) {
-      autoSpeakRef.current = true;
-      return;
-    }
-    setIsSpeaking(true);
-    const t = setTimeout(() => speak(currentQ.q), 500);
-    return () => clearTimeout(t);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [currentIndex, model.isReady]);
-
-  const handleAnswer = async (index: number) => {
-    if (selectedAnswer !== null || isSpeaking) return; // Prevent double taps or clicks while reading
-
-    setSelectedAnswer(index);
-    const correct = index === currentQ.c;
-    setIsAnswerCorrect(correct);
-
-    // 1. Visual Feedback Animation (1s)
-    feedbackAnim.value = withSequence(
-      withTiming(1, { duration: 200 }),
-      withDelay(1000, withTiming(0, { duration: 200 }))
-    );
-
-    // 2. Audio Feedback
-    if (correct) {
-      await speak('Correct!');
-    } else {
-      // Play "Incorrect" and explanation as one string
-      await speak(`Incorrect. ${currentQ.e}`);
-    }
-
-    // 3. Show Next Button
-    setShowNext(true);
-  };
-
-  const updateQuestionState = (nextIdx: number) => {
-    setSelectedAnswer(null);
-    setIsAnswerCorrect(null);
-    setCurrentIndex(nextIdx);
-
-    setTimeout(() => {
-      isTransitioningRef.current = false;
-      fadeAnim.value = withTiming(1, { duration: 500 });
-    }, 500);
-  };
-
-  const handleNext = () => {
-    const nextIdx = (currentIndex + 1) % shuffledQuestions.length;
-    buttonsInactiveAnim.value = 1; // Ensure buttons are active for next round
-    autoSpeakRef.current = false;
-    speak(shuffledQuestions[nextIdx].q);
-
-    isTransitioningRef.current = true;
-    setShowNext(false);
-
-    fadeAnim.value = withTiming(0, { duration: 500 }, (finished) => {
-      if (finished) {
-        runOnJS(updateQuestionState)(nextIdx);
-      }
-    });
-  };
-
-  const handleLearnMore = async () => {
-    if (isSpeaking) return;
-
-    buttonsInactiveAnim.value = withTiming(0.5, { duration: 800 });
-
-    // Play the context for the current question
-    await speak(currentQ.context);
-
-    buttonsInactiveAnim.value = withTiming(1, { duration: 800 });
-  };
-
-  const getButtonColor = (index: number) => {
-    if (selectedAnswer === null) return styles.optionButton;
-
-    if (index === currentQ.c) return styles.correctButton; // Highlight correct answer always if answered
-    if (index === selectedAnswer && !isAnswerCorrect) return styles.wrongButton; // Highlight mistake
-
-    return styles.disabledOption;
-  };
-
-  // Animate next button appearance
-  useEffect(() => {
-    nextButtonAnim.value = withTiming(showNext ? 1 : 0, {
-      duration: 450,
-    });
-  }, [showNext, nextButtonAnim]);
-
-  return (
-    <SafeAreaProvider>
-      <SafeAreaView style={styles.container}>
-        <View style={styles.header}>
-          <TouchableOpacity onPress={onBack} style={styles.backButton}>
-            <FontAwesome name="chevron-left" size={20} color="#0f186e" />
-          </TouchableOpacity>
-          <SWMIcon width={40} height={40} />
-          <Text style={styles.headerText}>Text to Speech - Quiz</Text>
-        </View>
-
-        {!model.isReady ? (
-          <View style={styles.centerContainer}>
-            <Text style={styles.loadingText}>
-              Loading Model: {Math.round(model.downloadProgress * 100)}%
-            </Text>
-          </View>
-        ) : (
-          <KeyboardAvoidingView
-            style={styles.flex1}
-            behavior={Platform.OS === 'ios' ? 'padding' : undefined}
-          >
-            <ScrollView contentContainerStyle={styles.scrollContent}>
-              <Animated.View style={[styles.quizContainer, containerStyle]}>
-                <View style={styles.questionCard}>
-                  <Text style={styles.questionIndex}>
-                    Question {currentIndex + 1}
-                  </Text>
-                  <Text style={styles.questionText}>{currentQ.q}</Text>
-                </View>
-
-                <View style={styles.optionsContainer}>
-                  {currentQ.a.map((opt, idx) => (
-                    <TouchableOpacity
-                      key={idx}
-                      style={[styles.baseOption, getButtonColor(idx)]}
-                      onPress={() => handleAnswer(idx)}
-                      disabled={selectedAnswer !== null || isSpeaking}
-                    >
-                      <Text style={styles.optionText}>{opt}</Text>
-                    </TouchableOpacity>
-                  ))}
-                </View>
-
-                {/* Feedback Animation Overlay Text */}
-                {selectedAnswer !== null && (
-                  <Animated.View
-                    style={[styles.feedbackContainer, feedbackStyle]}
-                  >
-                    <Text
-                      style={[
-                        styles.feedbackText,
-                        isAnswerCorrect
-                          ? styles.feedbackTextCorrect
-                          : styles.feedbackTextIncorrect,
-                      ]}
-                    >
-                      {isAnswerCorrect ? 'Correct!' : 'Incorrect'}
-                    </Text>
-                  </Animated.View>
-                )}
-              </Animated.View>
-            </ScrollView>
-
-            {showNext && (
-              <Animated.View
-                style={[styles.bottomContainer, nextButtonStyle]}
-                pointerEvents={showNext && !isSpeaking ? 'auto' : 'none'}
-              >
-                <TouchableOpacity
-                  onPress={handleNext}
-                  style={styles.nextButton}
-                >
-                  <Text style={styles.nextButtonText}>Next Question</Text>
-                  <FontAwesome name="arrow-right" size={20} color="white" />
-                </TouchableOpacity>
-
-                <TouchableOpacity
-                  onPress={handleLearnMore}
-                  style={[styles.nextButton, styles.learnMoreButton]}
-                >
-                  <Text
-                    style={[styles.nextButtonText, styles.learnMoreButtonText]}
-                  >
-                    Learn More
-                  </Text>
-                  <FontAwesome
-                    name="graduation-cap"
-                    size={20}
-                    color="#0f186e"
-                  />
-                </TouchableOpacity>
-              </Animated.View>
-            )}
-          </KeyboardAvoidingView>
-        )}
-      </SafeAreaView>
-    </SafeAreaProvider>
-  );
-};
-
-// Reuse stylistic approach from TextToSpeechScreen
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    backgroundColor: 'white',
-  },
-  centerContainer: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-  },
-  loadingText: {
-    fontSize: 18,
-    color: '#0f186e',
-  },
-  header: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    padding: 16,
-    borderBottomWidth: 1,
-    borderBottomColor: '#eee',
-    position: 'relative',
-  },
-  backButton: {
-    paddingRight: 15,
-  },
-  headerText: {
-    fontSize: 20,
-    fontWeight: 'bold',
-    color: '#0f186e',
-    marginLeft: 10,
-  },
-  scrollContent: {
-    padding: 20,
-    paddingBottom: 160, // Space for bottom container
-    flexGrow: 1, // Ensures content scales to screen height
-    justifyContent: 'center',
-  },
-  quizContainer: {
-    width: '100%',
-  },
-  questionCard: {
-    backgroundColor: '#0f186e',
-    borderRadius: 16,
-    padding: 24,
-    marginBottom: 24,
-    minHeight: 150,
-    justifyContent: 'center',
-  },
-  questionIndex: {
-    color: 'rgba(255,255,255,0.7)',
-    fontSize: 14,
-    marginBottom: 8,
-    textTransform: 'uppercase',
-    fontWeight: 'bold',
-  },
-  questionText: {
-    color: 'white',
-    fontSize: 22,
-    fontWeight: '600',
-    lineHeight: 30,
-  },
-  optionsContainer: {
-    gap: 12,
-  },
-  baseOption: {
-    padding: 16,
-    borderRadius: 12,
-    borderWidth: 2,
-    flexDirection: 'row',
-    alignItems: 'center',
-  },
-  // States of options
-  optionButton: {
-    backgroundColor: 'white',
-    borderColor: '#e0e0e0',
-  },
-  correctButton: {
-    backgroundColor: '#E8F5E9',
-    borderColor: '#4CAF50',
-  },
-  wrongButton: {
-    backgroundColor: '#FFEBEE',
-    borderColor: '#F44336',
-  },
-  disabledOption: {
-    backgroundColor: '#f5f5f5',
-    borderColor: '#eee',
-    opacity: 0.6,
-  },
-
-  optionText: {
-    fontSize: 18,
-    color: '#333',
-    fontWeight: '500',
-  },
-  feedbackContainer: {
-    alignItems: 'center',
-    marginVertical: 10,
-  },
-  feedbackText: {
-    fontSize: 24,
-    fontWeight: 'bold',
-    marginVertical: 10,
-  },
-  feedbackTextCorrect: {
-    color: '#4CAF50',
-  },
-  feedbackTextIncorrect: {
-    color: '#F44336',
-  },
-  nextButton: {
-    // Removed marginTop to rely on container padding
-    backgroundColor: '#0f186e',
-    paddingVertical: 16,
-    paddingHorizontal: 32,
-    borderRadius: 30,
-    flexDirection: 'row',
-    justifyContent: 'center',
-    alignItems: 'center',
-    gap: 10,
-    alignSelf: 'center',
-    width: '100%',
-  },
-  learnMoreButton: {
-    marginTop: 0,
-    backgroundColor: 'white',
-    borderWidth: 2,
-    borderColor: '#0f186e',
-  },
-  nextButtonText: {
-    color: 'white',
-    fontSize: 18,
-    fontWeight: 'bold',
-  },
-  learnMoreButtonText: {
-    color: '#0f186e',
-  },
-  bottomContainer: {
-    position: 'absolute',
-    bottom: 0,
-    left: 0,
-    right: 0,
-    padding: 20,
-    gap: 12,
-    alignItems: 'center',
-    backgroundColor: 'rgba(255,255,255,0.95)',
-  },
-  flex1: {
-    flex: 1,
-  },
-});
diff --git a/apps/speech/screens/SpeechToTextScreen.tsx b/apps/speech/screens/SpeechToTextScreen.tsx
deleted file mode 100644
index 909c2da57f..0000000000
--- a/apps/speech/screens/SpeechToTextScreen.tsx
+++ /dev/null
@@ -1,610 +0,0 @@
-import React, { useEffect, useRef, useState } from 'react';
-import {
-  Text,
-  View,
-  StyleSheet,
-  TouchableOpacity,
-  ScrollView,
-  TextInput,
-  KeyboardAvoidingView,
-  Platform,
-  Switch,
-  Keyboard,
-} from 'react-native';
-import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
-import {
-  models,
-  useSpeechToText,
-  TranscriptionResult,
-  SpeechToTextProps,
-} from 'react-native-executorch';
-import { ModelPicker, ModelOption } from '../components/ModelPicker';
-const speechToText = models.speech_to_text;
-const vad = models.vad;
-
-const isSimulator = DeviceInfo.isEmulatorSync();
-const backend = Platform.OS === 'ios' && !isSimulator ? 'coreml' : 'xnnpack';
-
-type STTModelSources = SpeechToTextProps['model'];
-
-const MODELS: ModelOption<STTModelSources>[] = [
-  {
-    label: 'Whisper Tiny EN',
-    value: speechToText.whisper_tiny_en({ backend }),
-  },
-  {
-    label: 'Whisper Base EN',
-    value: speechToText.whisper_base_en({ backend }),
-  },
-  {
-    label: 'Whisper Small EN',
-    value: speechToText.whisper_small_en({ backend }),
-  },
-];
-import FontAwesome from '@expo/vector-icons/FontAwesome';
-import {
-  AudioManager,
-  AudioRecorder,
-  AudioContext,
-} from 'react-native-audio-api';
-import * as FileSystem from 'expo-file-system/legacy';
-import SWMIcon from '../assets/swm_icon.svg';
-import DeviceInfo from 'react-native-device-info';
-
-import { VerboseTranscription } from '../components/VerboseTranscription';
-import ErrorBanner from '../components/ErrorBanner';
-
-export const SpeechToTextScreen = ({ onBack }: { onBack: () => void }) => {
-  const [selectedModel, setSelectedModel] = useState<STTModelSources>(
-    Platform.OS === 'ios' && !isSimulator
-      ? speechToText.whisper_base_en({ backend })
-      : speechToText.whisper_tiny_en()
-  );
-
-  const model = useSpeechToText({
-    model: selectedModel,
-    vad: vad.fsmn_vad(),
-  });
-
-  const [transcription, setTranscription] =
-    useState<TranscriptionResult | null>(null);
-  const [transcriptionTime, setTranscriptionTime] = useState<number | null>(
-    null
-  );
-
-  const [liveResult, setLiveResult] = useState<{
-    fullText: string;
-    segments: any[];
-  } | null>(null);
-
-  const [enableTimestamps, setEnableTimestamps] = useState(false);
-  const [useVAD, setUseVAD] = useState(true);
-  const [error, setError] = useState<string | null>(null);
-  const [audioURL, setAudioURL] = useState('');
-  const [hasMicPermission, setHasMicPermission] = useState(false);
-
-  const isRecordingRef = useRef(false);
-  const [liveTranscribing, setLiveTranscribing] = useState(false);
-  const scrollViewRef = useRef<ScrollView>(null);
-
-  const recorder = useRef(new AudioRecorder());
-
-  useEffect(() => {
-    AudioManager.setAudioSessionOptions({
-      iosCategory: 'playAndRecord',
-      iosMode: 'spokenAudio',
-      iosOptions: ['allowBluetoothHFP', 'defaultToSpeaker'],
-    });
-    const checkPerms = async () => {
-      const status = await AudioManager.requestRecordingPermissions();
-      setHasMicPermission(status === 'Granted');
-    };
-    checkPerms();
-  }, []);
-
-  async function getAudioFile(sourceUri: string) {
-    const destination = FileSystem.cacheDirectory + 'audio_file.wav';
-
-    if (sourceUri.startsWith('http')) {
-      const { uri } = await FileSystem.downloadAsync(sourceUri, destination);
-      return uri;
-    } else {
-      await FileSystem.copyAsync({
-        from: sourceUri,
-        to: destination,
-      });
-      return destination;
-    }
-  }
-
-  const handleTranscribeFromURL = async () => {
-    if (!audioURL.trim() || model.isGenerating) {
-      if (!audioURL.trim()) {
-        console.warn('Please provide a valid audio file URL');
-      }
-      return;
-    }
-
-    Keyboard.dismiss();
-
-    // Reset previous states
-    setTranscription(null);
-    setLiveResult(null);
-
-    try {
-      const uri = await getAudioFile(audioURL);
-      const audioContext = new AudioContext({ sampleRate: 16000 });
-      const decodedAudioData = await audioContext.decodeAudioData(uri);
-      const audioBuffer = decodedAudioData.getChannelData(0);
-      const start = Date.now();
-      const result = await model.transcribe(audioBuffer, {
-        verbose: enableTimestamps,
-      });
-      setTranscriptionTime(Date.now() - start);
-      setTranscription(result);
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-      return;
-    }
-  };
-
-  const handleStartTranscribeFromMicrophone = async () => {
-    if (!hasMicPermission || model.isGenerating || liveTranscribing) {
-      if (!hasMicPermission) {
-        setError('Microphone permission denied. Please enable it in Settings.');
-      }
-      return;
-    }
-
-    isRecordingRef.current = true;
-    setLiveTranscribing(true);
-
-    setTranscription(null);
-    setLiveResult({ fullText: '', segments: [] });
-
-    const sampleRate = 16000;
-
-    recorder.current.onAudioReady(
-      {
-        sampleRate,
-        bufferLength: 0.1 * sampleRate, // 100 ms
-        channelCount: 1,
-      },
-      ({ buffer }) => {
-        model.streamInsert(buffer.getChannelData(0));
-      }
-    );
-
-    try {
-      const success = await AudioManager.setAudioSessionActivity(true);
-      if (!success) {
-        setError('Cannot start audio session correctly');
-      }
-      const result = recorder.current.start();
-      if (result.status === 'error') {
-        setError(`Recording problems: ${result.message}`);
-      }
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-      isRecordingRef.current = false;
-      setLiveTranscribing(false);
-      return;
-    }
-
-    let accumulatedText = '';
-    let accumulatedSegments: any[] = [];
-
-    try {
-      const streamIter = model.stream({
-        verbose: enableTimestamps,
-        timeout: 200,
-        useVAD: useVAD,
-        vadDetectionMargin: 1200,
-      });
-
-      for await (const { committed, nonCommitted } of streamIter) {
-        if (!isRecordingRef.current) break;
-
-        if (committed.text) {
-          accumulatedText += committed.text;
-        }
-        if (committed.segments) {
-          accumulatedSegments = [...accumulatedSegments, ...committed.segments];
-        }
-
-        const currentDisplay = {
-          fullText: accumulatedText + nonCommitted.text,
-          segments: [...accumulatedSegments, ...(nonCommitted.segments || [])],
-        };
-
-        setLiveResult(currentDisplay);
-      }
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-    } finally {
-      setLiveTranscribing(false);
-    }
-  };
-
-  const handleStopTranscribeFromMicrophone = () => {
-    isRecordingRef.current = false;
-
-    recorder.current.stop();
-    model.streamStop();
-    console.log('Live transcription stopped');
-    setLiveTranscribing(false);
-
-    if (liveResult) {
-      setTranscription({
-        text: liveResult.fullText,
-        segments: liveResult.segments,
-        language: 'en',
-        duration: 0,
-      });
-      setLiveResult(null);
-    }
-  };
-
-  const getModelStatus = () => {
-    if (model.isGenerating) return 'Transcribing...';
-    if (model.isReady) return 'Ready to transcribe';
-    return `Loading model: ${(100 * model.downloadProgress).toFixed(2)}%`;
-  };
-
-  useEffect(() => {
-    if (model.error) setError(String(model.error));
-  }, [model.error]);
-
-  const readyToTranscribe = !model.isGenerating && model.isReady;
-  const recordingButtonDisabled = isSimulator || !readyToTranscribe;
-
-  const getDisplayData = (): TranscriptionResult | null => {
-    if (liveTranscribing && liveResult) {
-      return {
-        text: liveResult.fullText,
-        segments: liveResult.segments,
-        language: 'en',
-        duration: 0,
-      };
-    }
-    return transcription;
-  };
-
-  const displayData = getDisplayData();
-
-  return (
-    <SafeAreaProvider>
-      <SafeAreaView style={styles.container}>
-        <KeyboardAvoidingView
-          style={styles.keyboardAvoidingView}
-          behavior={Platform.OS === 'ios' ? 'padding' : undefined}
-        >
-          <View style={styles.header}>
-            <TouchableOpacity style={styles.backButton} onPress={onBack}>
-              <FontAwesome name="chevron-left" size={20} color="#0f186e" />
-            </TouchableOpacity>
-            <SWMIcon width={60} height={60} />
-            <Text style={styles.headerText}>React Native ExecuTorch</Text>
-            <Text style={styles.headerText}>Speech to Text</Text>
-          </View>
-
-          <View style={styles.statusContainer}>
-            <Text>Status: {getModelStatus()}</Text>
-            {transcriptionTime !== null && (
-              <Text style={styles.statsText}>
-                Transcription: {transcriptionTime} ms
-              </Text>
-            )}
-          </View>
-          <ErrorBanner message={error} onDismiss={() => setError(null)} />
-
-          <ModelPicker
-            models={MODELS}
-            selectedModel={selectedModel}
-            onSelect={(m) => {
-              setSelectedModel(m);
-              setTranscription(null);
-              setLiveResult(null);
-            }}
-          />
-
-          <View style={styles.toggleContainer}>
-            <Text style={styles.toggleLabel}>Enable Timestamps (Verbose)</Text>
-            <Switch
-              value={enableTimestamps}
-              onValueChange={(val) => {
-                setEnableTimestamps(val);
-                setTranscription(null);
-                setLiveResult(null);
-              }}
-              trackColor={{ false: '#767577', true: '#0f186e' }}
-              thumbColor={enableTimestamps ? '#fff' : '#f4f3f4'}
-              disabled={model.isGenerating}
-            />
-          </View>
-
-          <View style={styles.transcriptionContainer}>
-            <Text style={styles.transcriptionLabel}>Transcription</Text>
-            <ScrollView
-              ref={scrollViewRef}
-              style={styles.transcriptionScrollContainer}
-              onContentSizeChange={() =>
-                scrollViewRef.current?.scrollToEnd({ animated: true })
-              }
-            >
-              {displayData ? (
-                <VerboseTranscription data={displayData} />
-              ) : (
-                <Text style={styles.placeholderText}>
-                  {liveTranscribing
-                    ? 'Listening...'
-                    : 'No transcription yet...'}
-                </Text>
-              )}
-            </ScrollView>
-          </View>
-
-          <View style={styles.inputContainer}>
-            <View style={styles.urlTranscriptionContainer}>
-              <TextInput
-                placeholder="Audio file URL to transcribe"
-                placeholderTextColor="#aaa"
-                style={styles.urlTranscriptionInput}
-                value={audioURL}
-                onChangeText={setAudioURL}
-              />
-              <TouchableOpacity
-                disabled={!readyToTranscribe}
-                onPress={handleTranscribeFromURL}
-                style={[
-                  styles.urlTranscriptionButton,
-                  !readyToTranscribe && styles.disabled,
-                ]}
-              >
-                <Text style={styles.buttonText}>Start</Text>
-              </TouchableOpacity>
-            </View>
-
-            {liveTranscribing ? (
-              <TouchableOpacity
-                onPress={handleStopTranscribeFromMicrophone}
-                style={[styles.liveTranscriptionButton, styles.backgroundRed]}
-              >
-                <FontAwesome name="microphone-slash" size={22} color="white" />
-                <Text style={styles.buttonText}> Stop Live Transcription</Text>
-              </TouchableOpacity>
-            ) : (
-              <View style={styles.buttonRow}>
-                <TouchableOpacity
-                  disabled={recordingButtonDisabled}
-                  onPress={handleStartTranscribeFromMicrophone}
-                  style={[
-                    styles.liveTranscriptionButton,
-                    styles.backgroundBlue,
-                    styles.flex1,
-                    recordingButtonDisabled && styles.disabled,
-                  ]}
-                >
-                  <FontAwesome name="microphone" size={20} color="white" />
-                  <Text style={styles.buttonText}>
-                    {isSimulator ? 'No Mic' : 'Start Live'}
-                  </Text>
-                </TouchableOpacity>
-
-                <TouchableOpacity
-                  onPress={() => setUseVAD(!useVAD)}
-                  activeOpacity={0.7}
-                  accessibilityRole="switch"
-                  accessibilityState={{ checked: useVAD }}
-                  accessibilityLabel={`Voice Activity Detection ${useVAD ? 'on' : 'off'}`}
-                  style={[
-                    styles.vadButton,
-                    useVAD ? styles.vadActive : styles.vadInactive,
-                    recordingButtonDisabled && styles.disabled,
-                  ]}
-                >
-                  <FontAwesome
-                    name={useVAD ? 'check-circle' : 'circle-o'}
-                    size={18}
-                    color={useVAD ? '#ffffff' : '#94a3b8'}
-                  />
-                  <View style={styles.vadTextContainer}>
-                    <Text
-                      style={[
-                        styles.vadButtonLabel,
-                        useVAD
-                          ? styles.vadButtonLabelActive
-                          : styles.vadButtonLabelInactive,
-                      ]}
-                    >
-                      VAD
-                    </Text>
-                    <Text
-                      style={[
-                        styles.vadButtonState,
-                        useVAD
-                          ? styles.vadButtonStateActive
-                          : styles.vadButtonStateInactive,
-                      ]}
-                    >
-                      {useVAD ? 'ON' : 'OFF'}
-                    </Text>
-                  </View>
-                </TouchableOpacity>
-              </View>
-            )}
-          </View>
-        </KeyboardAvoidingView>
-      </SafeAreaView>
-    </SafeAreaProvider>
-  );
-};
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    alignItems: 'center',
-    backgroundColor: 'white',
-    paddingHorizontal: 16,
-  },
-  keyboardAvoidingView: {
-    flex: 1,
-    width: '100%',
-  },
-  header: {
-    alignItems: 'center',
-    position: 'relative',
-    width: '100%',
-  },
-  backButton: {
-    position: 'absolute',
-    left: 0,
-    top: 10,
-    padding: 10,
-    zIndex: 1,
-  },
-  headerText: {
-    fontSize: 22,
-    fontWeight: 'bold',
-    color: '#0f186e',
-  },
-  statusContainer: {
-    marginTop: 12,
-    alignItems: 'center',
-  },
-  statsText: {
-    fontSize: 13,
-    color: '#334155',
-    fontWeight: '500',
-    marginTop: 4,
-  },
-  toggleContainer: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    marginTop: 10,
-    marginBottom: 5,
-  },
-  toggleLabel: {
-    fontSize: 16,
-    marginRight: 10,
-    color: '#0f186e',
-  },
-  transcriptionContainer: {
-    flex: 1,
-    width: '100%',
-    marginVertical: 12,
-  },
-  transcriptionLabel: {
-    marginLeft: 12,
-    marginBottom: 4,
-    color: '#0f186e',
-  },
-  transcriptionScrollContainer: {
-    borderRadius: 12,
-    borderWidth: 1,
-    borderColor: '#0f186e',
-    padding: 12,
-    maxHeight: 400,
-  },
-  placeholderText: {
-    color: '#aaa',
-    fontStyle: 'italic',
-  },
-  inputContainer: {
-    marginBottom: 12,
-  },
-  urlTranscriptionContainer: {
-    width: '100%',
-    flexDirection: 'row',
-  },
-  urlTranscriptionInput: {
-    flex: 1,
-    padding: 12,
-    borderTopLeftRadius: 12,
-    borderBottomLeftRadius: 12,
-    borderWidth: 1,
-    borderColor: '#0f186e',
-    borderRightWidth: 0,
-    color: '#0f186e',
-  },
-  urlTranscriptionButton: {
-    backgroundColor: '#0f186e',
-    justifyContent: 'center',
-    alignItems: 'center',
-    padding: 12,
-    borderTopRightRadius: 12,
-    borderBottomRightRadius: 12,
-  },
-  buttonText: {
-    color: 'white',
-    fontWeight: '600',
-    letterSpacing: -0.5,
-    fontSize: 16,
-  },
-  liveTranscriptionButton: {
-    flexDirection: 'row',
-    justifyContent: 'center',
-    alignItems: 'center',
-    padding: 12,
-    borderRadius: 12,
-    marginTop: 12,
-    gap: 8,
-  },
-  backgroundRed: {
-    backgroundColor: 'red',
-  },
-  backgroundBlue: {
-    backgroundColor: '#0f186e',
-  },
-  buttonRow: {
-    flexDirection: 'row',
-    gap: 8,
-    marginTop: 12,
-  },
-  flex1: {
-    flex: 1,
-    marginTop: 0,
-  },
-  vadButton: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    justifyContent: 'center',
-    paddingHorizontal: 14,
-    borderRadius: 12,
-    gap: 10,
-  },
-  vadActive: {
-    backgroundColor: '#0f186e',
-  },
-  vadInactive: {
-    backgroundColor: '#f1f5f9',
-  },
-  vadTextContainer: {
-    alignItems: 'flex-start',
-  },
-  vadButtonLabel: {
-    fontWeight: '800',
-    fontSize: 13,
-    letterSpacing: 0.5,
-  },
-  vadButtonLabelActive: {
-    color: 'white',
-  },
-  vadButtonLabelInactive: {
-    color: '#64748b',
-  },
-  vadButtonState: {
-    fontWeight: '700',
-    fontSize: 10,
-    letterSpacing: 1,
-  },
-  vadButtonStateActive: {
-    color: '#bbf7d0',
-  },
-  vadButtonStateInactive: {
-    color: '#94a3b8',
-  },
-  disabled: {
-    opacity: 0.5,
-  },
-});
diff --git a/apps/speech/screens/TextToSpeechLLMScreen.tsx b/apps/speech/screens/TextToSpeechLLMScreen.tsx
deleted file mode 100644
index b90bcad577..0000000000
--- a/apps/speech/screens/TextToSpeechLLMScreen.tsx
+++ /dev/null
@@ -1,318 +0,0 @@
-import React, { useEffect, useState, useRef } from 'react';
-import {
-  View,
-  Text,
-  StyleSheet,
-  TouchableOpacity,
-  ScrollView,
-} from 'react-native';
-import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
-import FontAwesome from '@expo/vector-icons/FontAwesome';
-import SWMIcon from '../assets/swm_icon.svg';
-import { models, useLLM, useTextToSpeech } from 'react-native-executorch';
-import {
-  AudioManager,
-  AudioContext,
-  AudioBuffer,
-  AudioBufferSourceNode,
-} from 'react-native-audio-api';
-
-interface TextToSpeechLLMProps {
-  onBack: () => void;
-}
-
-/**
- * Converts an audio vector (Float32Array) to an AudioBuffer for playback
- * @param audioVector - The generated audio samples from the model
- * @param audioContext - The audio context used to create the buffer.
- * @param sampleRate - The sample rate (default: 24000 Hz for Kokoro)
- * @returns AudioBuffer ready for playback
- */
-const createAudioBufferFromVector = (
-  audioVector: Float32Array,
-  audioContext: AudioContext,
-  sampleRate: number = 24000
-): AudioBuffer => {
-  const audioBuffer = audioContext.createBuffer(
-    1,
-    audioVector.length,
-    sampleRate
-  );
-  const channelData = audioBuffer.getChannelData(0);
-  channelData.set(audioVector);
-
-  return audioBuffer;
-};
-
-export const TextToSpeechLLMScreen = ({ onBack }: TextToSpeechLLMProps) => {
-  const [displayText, setDisplayText] = useState('');
-  const [isTtsStreaming, setIsTtsStreaming] = useState(false);
-  const llm = useLLM({ model: models.llm.llama3_2_1b() });
-  const tts = useTextToSpeech(models.text_to_speech.kokoro.en_us.heart());
-
-  const processedLengthRef = useRef(0);
-  const audioContextRef = useRef<AudioContext | null>(null);
-  const sourceRef = useRef<AudioBufferSourceNode>(null);
-
-  useEffect(() => {
-    AudioManager.setAudioSessionOptions({
-      iosCategory: 'playAndRecord',
-      iosMode: 'spokenAudio',
-      iosOptions: ['defaultToSpeaker'],
-    });
-
-    audioContextRef.current = new AudioContext({ sampleRate: 24000 });
-    audioContextRef.current.suspend();
-
-    return () => {
-      audioContextRef.current?.close();
-      audioContextRef.current = null;
-    };
-  }, []);
-
-  // Update displayText gradually as response gets generated and insert new text chunks into TTS stream
-  useEffect(() => {
-    if (llm.response && tts.isReady) {
-      setDisplayText(llm.response);
-
-      const previousLength = processedLengthRef.current;
-      if (llm.response.length > previousLength && isTtsStreaming) {
-        const newChunk = llm.response.slice(previousLength);
-        tts.streamInsert(newChunk);
-        processedLengthRef.current = llm.response.length;
-      }
-    } else {
-      processedLengthRef.current = 0;
-    }
-  }, [llm.response, tts, isTtsStreaming]);
-
-  const handleGenerate = async () => {
-    setDisplayText('');
-    processedLengthRef.current = 0;
-    setIsTtsStreaming(true);
-
-    const startTTS = async () => {
-      try {
-        const audioContext = audioContextRef.current;
-        if (!audioContext) return;
-
-        if (audioContext.state === 'suspended') {
-          await audioContext.resume();
-        }
-
-        const onNext = async (audioVec: Float32Array) => {
-          return new Promise<void>((resolve) => {
-            const audioBuffer = createAudioBufferFromVector(
-              audioVec,
-              audioContext,
-              24000
-            );
-
-            const source = (sourceRef.current =
-              audioContext.createBufferSource());
-            source.buffer = audioBuffer;
-            source.connect(audioContext.destination);
-
-            source.onEnded = () => resolve();
-
-            source.start();
-          });
-        };
-
-        await tts.stream({
-          speed: 0.9,
-          stopAutomatically: false,
-          onNext,
-        });
-      } catch (e) {
-        console.error('TTS streaming error:', e);
-      } finally {
-        setIsTtsStreaming(false);
-      }
-    };
-
-    const ttsPromise = startTTS();
-
-    try {
-      await llm.sendMessage(
-        'Generate a short story about a robot learning to paint. The story should be around 200 words long.'
-      );
-    } catch (e) {
-      console.error('Generation failed:', e);
-    } finally {
-      // LLM finished — partition any trailing un-terminated tail so it gets
-      // synthesized before the stream closes.
-      tts.streamFlush();
-      tts.streamStop(false);
-      await ttsPromise;
-
-      if (
-        audioContextRef.current &&
-        audioContextRef.current.state === 'running'
-      ) {
-        await audioContextRef.current.suspend();
-      }
-    }
-  };
-
-  const handleStop = () => {
-    llm.interrupt();
-    tts.streamStop(true);
-    if (sourceRef.current) {
-      try {
-        sourceRef.current.stop();
-      } catch (e) {
-        // Source might have already stopped or disconnected
-      }
-    }
-  };
-
-  const isProcessing = llm.isGenerating || isTtsStreaming;
-  const isModelsReady = llm.isReady && tts.isReady;
-
-  const getModelStatus = () => {
-    if (llm.error) return `LLM Error: ${llm.error.message}`;
-    if (tts.error) return `TTS Error: ${tts.error.message}`;
-    if (!llm.isReady)
-      return `Loading LLM: ${(100 * llm.downloadProgress).toFixed(2)}%`;
-    if (!tts.isReady)
-      return `Loading TTS: ${(100 * tts.downloadProgress).toFixed(2)}%`;
-    if (isProcessing) return 'Generating/Streaming...';
-    return 'Ready';
-  };
-
-  return (
-    <SafeAreaProvider>
-      <SafeAreaView style={styles.container}>
-        <View style={styles.header}>
-          <TouchableOpacity style={styles.backButton} onPress={onBack}>
-            <FontAwesome name="chevron-left" size={20} color="#0f186e" />
-          </TouchableOpacity>
-          <SWMIcon width={60} height={60} />
-          <Text style={styles.headerText}>React Native ExecuTorch</Text>
-          <Text style={styles.headerText}>LLM to Speech Demo</Text>
-        </View>
-
-        <View style={styles.statusContainer}>
-          <Text>Status: {getModelStatus()}</Text>
-        </View>
-
-        <View style={styles.contentContainer}>
-          <Text style={styles.label}>Generated Story</Text>
-          <View style={styles.responseContainer}>
-            <ScrollView contentContainerStyle={styles.responseContent}>
-              <Text style={styles.responseText}>
-                {displayText ||
-                  (isModelsReady
-                    ? 'Press the button to generate a story and hear it spoken aloud.'
-                    : 'Please wait for models to load...')}
-              </Text>
-            </ScrollView>
-          </View>
-        </View>
-
-        <View style={styles.buttonContainer}>
-          {isProcessing ? (
-            <TouchableOpacity
-              style={[styles.actionButton, styles.stopButton]}
-              onPress={handleStop}
-            >
-              <FontAwesome name="stop" size={20} color="white" />
-              <Text style={styles.buttonText}>Stop Generation</Text>
-            </TouchableOpacity>
-          ) : (
-            <TouchableOpacity
-              disabled={!isModelsReady}
-              onPress={handleGenerate}
-              style={[styles.actionButton, !isModelsReady && styles.disabled]}
-            >
-              <FontAwesome name="magic" size={20} color="white" />
-              <Text style={styles.buttonText}>Generate & Stream Speech</Text>
-            </TouchableOpacity>
-          )}
-        </View>
-      </SafeAreaView>
-    </SafeAreaProvider>
-  );
-};
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    alignItems: 'center',
-    backgroundColor: 'white',
-    paddingHorizontal: 16,
-  },
-  header: {
-    alignItems: 'center',
-    position: 'relative',
-    width: '100%',
-  },
-  backButton: {
-    position: 'absolute',
-    left: 0,
-    top: 10,
-    padding: 10,
-    zIndex: 1,
-  },
-  headerText: {
-    fontSize: 22,
-    fontWeight: 'bold',
-    color: '#0f186e',
-  },
-  statusContainer: {
-    marginTop: 12,
-    alignItems: 'center',
-  },
-  contentContainer: {
-    width: '100%',
-    marginTop: 24,
-    flex: 1,
-    marginBottom: 24,
-  },
-  label: {
-    marginLeft: 12,
-    marginBottom: 4,
-    color: '#0f186e',
-    fontWeight: '600',
-  },
-  responseContainer: {
-    borderRadius: 12,
-    borderWidth: 1,
-    borderColor: '#0f186e',
-    flex: 1,
-  },
-  responseContent: {
-    padding: 12,
-  },
-  responseText: {
-    fontSize: 16,
-    color: '#333',
-    lineHeight: 24,
-  },
-  buttonContainer: {
-    marginBottom: 24,
-    width: '100%',
-  },
-  actionButton: {
-    backgroundColor: '#0f186e',
-    flexDirection: 'row',
-    justifyContent: 'center',
-    alignItems: 'center',
-    padding: 12,
-    borderRadius: 12,
-    gap: 8,
-  },
-  stopButton: {
-    backgroundColor: '#ff4444',
-  },
-  buttonText: {
-    color: 'white',
-    fontWeight: '600',
-    letterSpacing: -0.5,
-    fontSize: 16,
-  },
-  disabled: {
-    opacity: 0.5,
-  },
-});
diff --git a/apps/speech/screens/TextToSpeechScreen.tsx b/apps/speech/screens/TextToSpeechScreen.tsx
deleted file mode 100644
index 919076dc35..0000000000
--- a/apps/speech/screens/TextToSpeechScreen.tsx
+++ /dev/null
@@ -1,328 +0,0 @@
-import React, { useEffect, useRef, useState } from 'react';
-import {
-  Text,
-  View,
-  StyleSheet,
-  TouchableOpacity,
-  TextInput,
-  KeyboardAvoidingView,
-  Platform,
-  Keyboard,
-} from 'react-native';
-import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
-import {
-  models,
-  useTextToSpeech,
-  TextToSpeechModelConfig,
-} from 'react-native-executorch';
-import { ModelPicker, ModelOption } from '../components/ModelPicker';
-
-const tts = models.text_to_speech.kokoro;
-
-const VOICES: ModelOption<TextToSpeechModelConfig>[] = [
-  { label: '🇺🇸 AF Heart', value: tts.en_us.heart() },
-  { label: '🇺🇸 AF River', value: tts.en_us.river() },
-  { label: '🇺🇸 AF Sarah', value: tts.en_us.sarah() },
-  { label: '🇺🇸 AM Adam', value: tts.en_us.adam() },
-  { label: '🇺🇸 AM Michael', value: tts.en_us.michael() },
-  { label: '🇺🇸 AM Santa', value: tts.en_us.santa() },
-  { label: '🇬🇧 BF Emma', value: tts.en_gb.emma() },
-  { label: '🇬🇧 BM Daniel', value: tts.en_gb.daniel() },
-  { label: '🇫🇷 FF Siwis', value: tts.fr.siwis() },
-  { label: '🇪🇸 EF Dora', value: tts.es.dora() },
-  { label: '🇪🇸 EM Alex', value: tts.es.alex() },
-  { label: '🇮🇹 IF Sara', value: tts.it.sara() },
-  { label: '🇮🇹 IM Nicola', value: tts.it.nicola() },
-  { label: '🇵🇹 PF Dora', value: tts.pt.dora() },
-  { label: '🇵🇹 PM Santa', value: tts.pt.santa() },
-  { label: '🇩🇪 DF Anna', value: tts.de.anna() },
-  { label: '🇵🇱 PM Mateusz', value: tts.pl.mateusz() },
-  { label: '🇮🇳 HF Alpha', value: tts.hi.alpha() },
-  { label: '🇮🇳 HM Omega', value: tts.hi.omega() },
-  { label: '🇮🇳 HM Psi', value: tts.hi.psi() },
-];
-
-import FontAwesome from '@expo/vector-icons/FontAwesome';
-import {
-  AudioManager,
-  AudioContext,
-  AudioBuffer,
-  AudioBufferSourceNode,
-} from 'react-native-audio-api';
-import SWMIcon from '../assets/swm_icon.svg';
-import ErrorBanner from '../components/ErrorBanner';
-
-/**
- * Converts an audio vector (Float32Array) to an AudioBuffer for playback
- * @param audioVector - The generated audio samples from the model
- * @param audioContext - An optional AudioContext to create the buffer in. If not provided, a new one will be created.
- * @param sampleRate - The sample rate (default: 24000 Hz for Kokoro)
- * @returns AudioBuffer ready for playback
- */
-const createAudioBufferFromVector = (
-  audioVector: Float32Array,
-  audioContext: AudioContext | null = null,
-  sampleRate: number = 24000
-): AudioBuffer => {
-  if (audioContext == null) audioContext = new AudioContext({ sampleRate });
-
-  const audioBuffer = audioContext.createBuffer(
-    1,
-    audioVector.length,
-    sampleRate
-  );
-  const channelData = audioBuffer.getChannelData(0);
-  channelData.set(audioVector);
-
-  return audioBuffer;
-};
-
-export const TextToSpeechScreen = ({ onBack }: { onBack: () => void }) => {
-  const [selectedSpeaker, setSelectedSpeaker] =
-    useState<TextToSpeechModelConfig>(tts.en_us.heart());
-
-  const model = useTextToSpeech(selectedSpeaker);
-
-  const [inputText, setInputText] = useState('');
-  const [isPlaying, setIsPlaying] = useState(false);
-  const [readyToGenerate, setReadyToGenerate] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-
-  const audioContextRef = useRef<AudioContext | null>(null);
-  const gainNodeRef = useRef<any>(null);
-  const sourceRef = useRef<AudioBufferSourceNode>(null);
-
-  useEffect(() => {
-    AudioManager.setAudioSessionOptions({
-      iosCategory: 'playAndRecord',
-      iosMode: 'spokenAudio',
-      iosOptions: ['defaultToSpeaker'],
-    });
-
-    const context = new AudioContext({ sampleRate: 24000 });
-    audioContextRef.current = context;
-    context.suspend();
-
-    // Increase the audio volume
-    const gainNode = context.createGain();
-    gainNode.gain.value = 2.0; // Increase volume by 2x
-    gainNode.connect(context.destination);
-    gainNodeRef.current = gainNode;
-
-    return () => {
-      audioContextRef.current?.close();
-      audioContextRef.current = null;
-      gainNodeRef.current = null;
-    };
-  }, []);
-
-  useEffect(() => {
-    setReadyToGenerate(!model.isGenerating && model.isReady && !isPlaying);
-  }, [model.isGenerating, model.isReady, isPlaying]);
-
-  const handlePlayAudio = async () => {
-    if (!inputText.trim()) {
-      return;
-    }
-
-    Keyboard.dismiss();
-    setIsPlaying(true);
-
-    try {
-      const audioContext = audioContextRef.current;
-      if (!audioContext) return;
-
-      if (audioContext.state === 'suspended') {
-        await audioContext.resume();
-      }
-
-      const onNext = async (audioVec: Float32Array) => {
-        return new Promise<void>((resolve) => {
-          const audioBuffer = createAudioBufferFromVector(
-            audioVec,
-            audioContext,
-            24000
-          );
-
-          const source = (sourceRef.current =
-            audioContext.createBufferSource());
-          source.buffer = audioBuffer;
-
-          if (gainNodeRef.current) {
-            source.connect(gainNodeRef.current);
-          } else {
-            source.connect(audioContext.destination);
-          }
-
-          source.onEnded = () => resolve();
-
-          source.start();
-        });
-      };
-
-      const onEnd = async () => {
-        setIsPlaying(false);
-        await audioContext.suspend();
-      };
-
-      await model.stream({
-        text: inputText,
-        speed: 0.9,
-        phonemize: true,
-        onNext,
-        onEnd,
-      });
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-      setIsPlaying(false);
-    }
-  };
-
-  const getModelStatus = () => {
-    if (model.isGenerating) return 'Generating audio...';
-    if (model.isReady) return 'Ready to synthesize';
-    return `Loading model: ${(100 * model.downloadProgress).toFixed(2)}%`;
-  };
-
-  useEffect(() => {
-    if (model.error) setError(String(model.error));
-  }, [model.error]);
-
-  return (
-    <SafeAreaProvider>
-      <SafeAreaView style={styles.container}>
-        <KeyboardAvoidingView
-          style={styles.keyboardAvoidingView}
-          behavior={Platform.OS === 'ios' ? 'padding' : undefined}
-        >
-          <View style={styles.header}>
-            <TouchableOpacity style={styles.backButton} onPress={onBack}>
-              <FontAwesome name="chevron-left" size={20} color="#0f186e" />
-            </TouchableOpacity>
-            <SWMIcon width={60} height={60} />
-            <Text style={styles.headerText}>React Native ExecuTorch</Text>
-            <Text style={styles.headerText}>Text to Speech</Text>
-          </View>
-
-          <View style={styles.statusContainer}>
-            <Text>Status: {getModelStatus()}</Text>
-          </View>
-          <ErrorBanner message={error} onDismiss={() => setError(null)} />
-
-          <ModelPicker
-            label="Voice"
-            models={VOICES}
-            selectedModel={selectedSpeaker}
-            disabled={model.isGenerating}
-            onSelect={(m) => setSelectedSpeaker(m)}
-          />
-
-          <View style={styles.inputContainer}>
-            <Text style={styles.inputLabel}>Enter text to synthesize</Text>
-            <TextInput
-              placeholder="Type something..."
-              placeholderTextColor="#aaa"
-              style={styles.textInput}
-              value={inputText}
-              onChangeText={setInputText}
-              multiline
-              numberOfLines={4}
-              textAlignVertical="top"
-            />
-          </View>
-
-          <View style={styles.buttonContainer}>
-            <TouchableOpacity
-              disabled={!readyToGenerate}
-              onPress={handlePlayAudio}
-              style={[styles.playButton, !readyToGenerate && styles.disabled]}
-            >
-              <FontAwesome
-                name={isPlaying ? 'volume-up' : 'play'}
-                size={20}
-                color="white"
-              />
-              <Text style={styles.buttonText}>
-                {isPlaying ? 'Playing...' : 'Generate & Play'}
-              </Text>
-            </TouchableOpacity>
-          </View>
-        </KeyboardAvoidingView>
-      </SafeAreaView>
-    </SafeAreaProvider>
-  );
-};
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    alignItems: 'center',
-    backgroundColor: 'white',
-    paddingHorizontal: 16,
-  },
-  keyboardAvoidingView: {
-    flex: 1,
-    width: '100%',
-  },
-  header: {
-    alignItems: 'center',
-    position: 'relative',
-    width: '100%',
-  },
-  backButton: {
-    position: 'absolute',
-    left: 0,
-    top: 10,
-    padding: 10,
-    zIndex: 1,
-  },
-  headerText: {
-    fontSize: 22,
-    fontWeight: 'bold',
-    color: '#0f186e',
-  },
-  statusContainer: {
-    marginTop: 12,
-    alignItems: 'center',
-  },
-  inputContainer: {
-    width: '100%',
-    marginTop: 24,
-  },
-  inputLabel: {
-    marginLeft: 12,
-    marginBottom: 4,
-    color: '#0f186e',
-    fontWeight: '600',
-  },
-  textInput: {
-    borderRadius: 12,
-    borderWidth: 1,
-    borderColor: '#0f186e',
-    padding: 12,
-    minHeight: 120,
-    fontSize: 16,
-    color: '#0f186e',
-  },
-  buttonContainer: {
-    marginTop: 24,
-  },
-  playButton: {
-    backgroundColor: '#0f186e',
-    flexDirection: 'row',
-    justifyContent: 'center',
-    alignItems: 'center',
-    padding: 12,
-    borderRadius: 12,
-    gap: 8,
-  },
-  buttonText: {
-    color: 'white',
-    fontWeight: '600',
-    letterSpacing: -0.5,
-    fontSize: 16,
-  },
-  disabled: {
-    opacity: 0.5,
-  },
-});
diff --git a/apps/speech/screens/VoiceActivityDetectionScreen.tsx b/apps/speech/screens/VoiceActivityDetectionScreen.tsx
deleted file mode 100644
index 724ea52500..0000000000
--- a/apps/speech/screens/VoiceActivityDetectionScreen.tsx
+++ /dev/null
@@ -1,329 +0,0 @@
-import React, { useEffect, useRef, useState } from 'react';
-import {
-  Text,
-  View,
-  StyleSheet,
-  TouchableOpacity,
-  ScrollView,
-  Platform,
-} from 'react-native';
-import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
-import {
-  models,
-  useVAD 
-} from 'react-native-executorch';
-import FontAwesome from '@expo/vector-icons/FontAwesome';
-import { AudioManager, AudioRecorder } from 'react-native-audio-api';
-import SWMIcon from '../assets/swm_icon.svg';
-import DeviceInfo from 'react-native-device-info';
-import ErrorBanner from '../components/ErrorBanner';
-
-const isSimulator = DeviceInfo.isEmulatorSync();
-
-export const VoiceActivityDetectionScreen = ({
-  onBack,
-}: {
-  onBack: () => void;
-}) => {
-  const model = useVAD({
-    model: models.vad.fsmn_vad(),
-  });
-
-  const [isSpeaking, setIsSpeaking] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-  const [hasMicPermission, setHasMicPermission] = useState(false);
-  const [isStreaming, setIsStreaming] = useState(false);
-
-  const recorder = useRef(new AudioRecorder());
-  const logScrollRef = useRef<ScrollView>(null);
-  const [logs, setLogs] = useState<string[]>([]);
-
-  const addLog = (msg: string) => {
-    setLogs((prev) => [...prev, `${new Date().toLocaleTimeString()}: ${msg}`]);
-  };
-
-  useEffect(() => {
-    AudioManager.setAudioSessionOptions({
-      iosCategory: 'playAndRecord',
-      iosMode: 'spokenAudio',
-      iosOptions: ['allowBluetoothHFP', 'defaultToSpeaker'],
-    });
-    const checkPerms = async () => {
-      const status = await AudioManager.requestRecordingPermissions();
-      setHasMicPermission(status === 'Granted');
-    };
-    checkPerms();
-  }, []);
-
-  const handleStartStreaming = async () => {
-    if (isStreaming || model.isGenerating || !model.isReady) {
-      return;
-    }
-
-    setIsStreaming(true);
-    if (!hasMicPermission) {
-      setError('Microphone permission denied. Please enable it in Settings.');
-      setIsStreaming(false);
-      return;
-    }
-
-    setLogs([]);
-    addLog('Starting VAD stream...');
-
-    const sampleRate = 16000;
-
-    recorder.current.onAudioReady(
-      {
-        sampleRate,
-        bufferLength: 0.1 * sampleRate,
-        channelCount: 1,
-      },
-      ({ buffer }) => {
-        model.streamInsert(buffer.getChannelData(0));
-      }
-    );
-
-    try {
-      const success = await AudioManager.setAudioSessionActivity(true);
-      if (!success) {
-        setError('Cannot start audio session correctly');
-      }
-      const result = recorder.current.start();
-      if (result.status === 'error') {
-        setError(`Recording problems: ${result.status}`);
-      }
-
-      await model.stream({
-        onSpeechBegin: () => {
-          setIsSpeaking(true);
-          addLog('Speech detected (Begin)');
-        },
-        onSpeechEnd: () => {
-          setIsSpeaking(false);
-          addLog('Silence detected (End)');
-        },
-        options: {
-          timeout: 100,
-          detectionMargin: 300,
-        },
-      });
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-      setIsStreaming(false);
-    }
-  };
-
-  const handleStopStreaming = () => {
-    recorder.current.stop();
-    model.streamStop();
-    setIsStreaming(false);
-    setIsSpeaking(false);
-    addLog('VAD stream stopped');
-  };
-
-  const getModelStatus = () => {
-    if (isStreaming || model.isGenerating) return 'Processing...';
-    if (model.isReady) return 'Ready';
-    return `Loading model: ${(100 * model.downloadProgress).toFixed(2)}%`;
-  };
-
-  useEffect(() => {
-    if (model.error) setError(String(model.error));
-  }, [model.error]);
-
-  const readyToStream = model.isReady;
-  const recordingButtonDisabled =
-    isSimulator || !readyToStream || model.isGenerating;
-
-  return (
-    <SafeAreaProvider>
-      <SafeAreaView style={styles.container}>
-        <View style={styles.header}>
-          <TouchableOpacity style={styles.backButton} onPress={onBack}>
-            <FontAwesome name="chevron-left" size={20} color="#0f186e" />
-          </TouchableOpacity>
-          <SWMIcon width={60} height={60} />
-          <Text style={styles.headerText}>React Native ExecuTorch</Text>
-          <Text style={styles.headerText}>Voice Activity Detection</Text>
-        </View>
-
-        <View style={styles.statusContainer}>
-          <Text>Status: {getModelStatus()}</Text>
-        </View>
-
-        <ErrorBanner message={error} onDismiss={() => setError(null)} />
-
-        <View style={styles.visualizerContainer}>
-          <FontAwesome
-            name="volume-up"
-            size={100}
-            color={
-              isSpeaking ? styles.speakingText.color : styles.silentText.color
-            }
-          />
-          <Text
-            style={[
-              styles.visualizerText,
-              isSpeaking ? styles.speakingText : styles.silentText,
-            ]}
-          >
-            {isSpeaking ? 'SPEAKING' : 'SILENT'}
-          </Text>
-        </View>
-
-        <View style={styles.logContainer}>
-          <Text style={styles.logLabel}>VAD Events</Text>
-          <ScrollView
-            ref={logScrollRef}
-            style={styles.logScrollContainer}
-            onContentSizeChange={() =>
-              logScrollRef.current?.scrollToEnd({ animated: true })
-            }
-          >
-            {logs.length > 0 ? (
-              logs.map((log, i) => (
-                <Text key={i} style={styles.logText}>
-                  {log}
-                </Text>
-              ))
-            ) : (
-              <Text style={styles.placeholderText}>
-                No events logged yet...
-              </Text>
-            )}
-          </ScrollView>
-        </View>
-
-        <View style={styles.inputContainer}>
-          {isStreaming ? (
-            <TouchableOpacity
-              onPress={handleStopStreaming}
-              style={[styles.liveButton, styles.backgroundRed]}
-            >
-              <FontAwesome name="microphone-slash" size={22} color="white" />
-              <Text style={styles.buttonText}> Stop VAD Stream</Text>
-            </TouchableOpacity>
-          ) : (
-            <TouchableOpacity
-              disabled={recordingButtonDisabled}
-              onPress={handleStartStreaming}
-              style={[
-                styles.liveButton,
-                styles.backgroundBlue,
-                recordingButtonDisabled && styles.disabled,
-              ]}
-            >
-              <FontAwesome name="microphone" size={20} color="white" />
-              <Text style={styles.buttonText}>
-                {isSimulator
-                  ? 'Recording not available on Simulator'
-                  : 'Start VAD Stream'}
-              </Text>
-            </TouchableOpacity>
-          )}
-        </View>
-      </SafeAreaView>
-    </SafeAreaProvider>
-  );
-};
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    alignItems: 'center',
-    backgroundColor: 'white',
-    paddingHorizontal: 16,
-  },
-  header: {
-    alignItems: 'center',
-    position: 'relative',
-    width: '100%',
-  },
-  backButton: {
-    position: 'absolute',
-    left: 0,
-    top: 10,
-    padding: 10,
-    zIndex: 1,
-  },
-  headerText: {
-    fontSize: 22,
-    fontWeight: 'bold',
-    color: '#0f186e',
-  },
-  statusContainer: {
-    marginTop: 12,
-    alignItems: 'center',
-  },
-  visualizerContainer: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-  },
-  visualizerText: {
-    marginTop: 20,
-    fontSize: 24,
-    fontWeight: '800',
-    letterSpacing: 2,
-  },
-  speakingText: {
-    color: '#22c55e',
-  },
-  silentText: {
-    color: '#ef4444',
-  },
-  logContainer: {
-    height: 150,
-    width: '100%',
-    marginVertical: 12,
-  },
-  logLabel: {
-    marginLeft: 12,
-    marginBottom: 4,
-    color: '#0f186e',
-    fontWeight: '600',
-  },
-  logScrollContainer: {
-    borderRadius: 12,
-    borderWidth: 1,
-    borderColor: '#0f186e',
-    padding: 12,
-    backgroundColor: '#f8fafc',
-  },
-  logText: {
-    fontSize: 12,
-    fontFamily: Platform.OS === 'ios' ? 'Menlo' : 'monospace',
-    color: '#334155',
-    marginBottom: 2,
-  },
-  placeholderText: {
-    color: '#aaa',
-    fontStyle: 'italic',
-  },
-  inputContainer: {
-    marginBottom: 30,
-    width: '100%',
-  },
-  liveButton: {
-    flexDirection: 'row',
-    justifyContent: 'center',
-    alignItems: 'center',
-    padding: 16,
-    borderRadius: 12,
-    gap: 8,
-  },
-  backgroundRed: {
-    backgroundColor: '#ef4444',
-  },
-  backgroundBlue: {
-    backgroundColor: '#0f186e',
-  },
-  buttonText: {
-    color: 'white',
-    fontWeight: '600',
-    fontSize: 16,
-  },
-  disabled: {
-    opacity: 0.5,
-  },
-});
diff --git a/apps/speech/tsconfig.json b/apps/speech/tsconfig.json
deleted file mode 100644
index bfe226172e..0000000000
--- a/apps/speech/tsconfig.json
+++ /dev/null
@@ -1,18 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "strict": true,
-    "allowJs": true,
-    "module": "preserve",
-    "moduleDetection": "force",
-    "moduleResolution": "bundler",
-    "customConditions": ["react-native"],
-    "noEmit": true,
-    "paths": {
-      "react-native-executorch": ["../../packages/react-native-executorch/src"],
-      "react-native-executorch-expo-resource-fetcher": [
-        "../../packages/expo-resource-fetcher/src"
-      ]
-    }
-  }
-}
diff --git a/apps/text-embeddings/.gitignore b/apps/text-embeddings/.gitignore
deleted file mode 100644
index d7eba44af8..0000000000
--- a/apps/text-embeddings/.gitignore
+++ /dev/null
@@ -1,39 +0,0 @@
-# Learn more https://docs.github.com/en/get-started/getting-started-with-git/ignoring-files
-
-# dependencies
-node_modules/
-
-# Expo
-.expo/
-dist/
-web-build/
-expo-env.d.ts
-
-# Native
-*.orig.*
-*.jks
-*.p8
-*.p12
-*.key
-*.mobileprovision
-
-# Metro
-.metro-health-check*
-
-# debug
-npm-debug.*
-yarn-debug.*
-yarn-error.*
-
-# macOS
-.DS_Store
-*.pem
-
-# local env files
-.env*.local
-
-# typescript
-*.tsbuildinfo
-
-# yarn
-.yarn
\ No newline at end of file
diff --git a/apps/text-embeddings/app.json b/apps/text-embeddings/app.json
deleted file mode 100644
index 6fe3a043b9..0000000000
--- a/apps/text-embeddings/app.json
+++ /dev/null
@@ -1,42 +0,0 @@
-{
-  "expo": {
-    "name": "text-embeddings",
-    "slug": "text-embeddings",
-    "version": "1.0.0",
-    "orientation": "portrait",
-    "icon": "./assets/icon.png",
-    "userInterfaceStyle": "light",
-    "newArchEnabled": true,
-    "scheme": "rne-embeddings",
-    "splash": {
-      "image": "./assets/splash-icon.png",
-      "resizeMode": "contain",
-      "backgroundColor": "#ffffff"
-    },
-    "ios": {
-      "supportsTablet": true,
-      "bundleIdentifier": "com.anonymous.text-embeddings"
-    },
-    "android": {
-      "adaptiveIcon": {
-        "foregroundImage": "./assets/adaptive-icon.png",
-        "backgroundColor": "#ffffff"
-      },
-      "package": "com.anonymous.textembeddings"
-    },
-    "web": {
-      "favicon": "./assets/favicon.png"
-    },
-    "plugins": [
-      "expo-router",
-      [
-        "expo-build-properties",
-        {
-          "ios": {
-            "deploymentTarget": "17.0"
-          }
-        }
-      ]
-    ]
-  }
-}
diff --git a/apps/text-embeddings/app/_layout.tsx b/apps/text-embeddings/app/_layout.tsx
deleted file mode 100644
index bb8e1deeb8..0000000000
--- a/apps/text-embeddings/app/_layout.tsx
+++ /dev/null
@@ -1,137 +0,0 @@
-import { Drawer } from 'expo-router/drawer';
-import { initExecutorch } from 'react-native-executorch';
-import { ExpoResourceFetcher } from 'react-native-executorch-expo-resource-fetcher';
-import ColorPalette from '../colors';
-import React, { useState } from 'react';
-import {
-  Text,
-  StyleSheet,
-  View,
-  TouchableOpacity,
-  type ColorValue,
-} from 'react-native';
-
-import {
-  type DrawerContentComponentProps,
-  DrawerContentScrollView,
-  DrawerItemList,
-} from 'expo-router/build/react-navigation/drawer';
-import { DrawerActions } from 'expo-router/build/react-navigation/routers';
-import { useNavigation } from 'expo-router';
-import Svg, { Rect } from 'react-native-svg';
-import { GeneratingContext } from '../context';
-
-function HamburgerIcon({ tintColor }: { tintColor?: ColorValue }) {
-  const navigation = useNavigation();
-  const fill = typeof tintColor === 'string' ? tintColor : '#000';
-  return (
-    <TouchableOpacity
-      onPress={() => navigation.dispatch(DrawerActions.toggleDrawer())}
-      style={styles.hamburger}
-    >
-      <Svg width={24} height={24} viewBox="0 0 24 24">
-        <Rect x={2} y={4} width={20} height={2} rx={1} fill={fill} />
-        <Rect x={2} y={11} width={20} height={2} rx={1} fill={fill} />
-        <Rect x={2} y={18} width={20} height={2} rx={1} fill={fill} />
-      </Svg>
-    </TouchableOpacity>
-  );
-}
-
-initExecutorch({
-  resourceFetcher: ExpoResourceFetcher,
-});
-
-interface CustomDrawerProps extends DrawerContentComponentProps {
-  isGenerating: boolean;
-}
-
-function CustomDrawerContent(props: CustomDrawerProps) {
-  const { isGenerating, ...otherProps } = props;
-  return (
-    <DrawerContentScrollView {...otherProps}>
-      {!isGenerating ? (
-        <DrawerItemList {...otherProps} />
-      ) : (
-        <View style={styles.centerContent}>
-          <Text style={styles.mainText}>Model is generating...</Text>
-          <Text style={styles.subText}>Interrupt before switching model</Text>
-        </View>
-      )}
-    </DrawerContentScrollView>
-  );
-}
-
-export default function _layout() {
-  const [isGenerating, setIsGenerating] = useState(false);
-
-  return (
-    <GeneratingContext
-      value={{
-        setGlobalGenerating: (newState: boolean) => {
-          setIsGenerating(newState);
-        },
-      }}
-    >
-      <Drawer
-        drawerContent={(props: DrawerContentComponentProps) => (
-          <CustomDrawerContent {...props} isGenerating={isGenerating} />
-        )}
-        screenOptions={{
-          drawerActiveTintColor: ColorPalette.primary,
-          drawerInactiveTintColor: '#888',
-          headerTintColor: ColorPalette.primary,
-          headerTitleStyle: { color: ColorPalette.primary },
-          headerLeft: (props) => <HamburgerIcon tintColor={props.tintColor} />,
-        }}
-      >
-        <Drawer.Screen
-          name="index"
-          options={{
-            drawerLabel: () => null,
-            title: 'Main Menu',
-            drawerItemStyle: { display: 'none' },
-          }}
-        />
-        <Drawer.Screen
-          name="text-embeddings/index"
-          options={{
-            drawerLabel: 'Text embeddings',
-            title: 'Text embeddings',
-            headerTitleStyle: { color: ColorPalette.primary },
-          }}
-        />
-        <Drawer.Screen
-          name="clip-embeddings/index"
-          options={{
-            drawerLabel: 'CLIP embeddings',
-            title: 'CLIP embeddings',
-            headerTitleStyle: { color: ColorPalette.primary },
-          }}
-        />
-      </Drawer>
-    </GeneratingContext>
-  );
-}
-
-const styles = StyleSheet.create({
-  hamburger: {
-    marginLeft: 12,
-  },
-  centerContent: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-    padding: 20,
-  },
-  mainText: {
-    fontSize: 18,
-    fontWeight: 'bold',
-    marginBottom: 10,
-    color: ColorPalette.primary,
-  },
-  subText: {
-    fontSize: 14,
-    color: ColorPalette.strongPrimary,
-  },
-});
diff --git a/apps/text-embeddings/app/clip-embeddings/index.tsx b/apps/text-embeddings/app/clip-embeddings/index.tsx
deleted file mode 100644
index 02a8a9c656..0000000000
--- a/apps/text-embeddings/app/clip-embeddings/index.tsx
+++ /dev/null
@@ -1,397 +0,0 @@
-import { useState } from 'react';
-import {
-  StyleSheet,
-  Text,
-  TextInput,
-  TouchableOpacity,
-  View,
-  SafeAreaView,
-  ScrollView,
-  Image,
-  KeyboardAvoidingView,
-  Platform,
-} from 'react-native';
-import { Ionicons } from '@expo/vector-icons';
-import {
-  models,
-  useTextEmbeddings,
-  useImageEmbeddings,
-  ImageEmbeddingsProps,
-} from 'react-native-executorch';
-
-type ImageEmbeddingModel = ImageEmbeddingsProps['model'];
-
-const IMAGE_MODELS: { label: string; value: ImageEmbeddingModel }[] = [
-  {
-    label: 'ViT-B/32 Quantized',
-    value: models.image_embedding.clip_vit_base_patch32_image(),
-  },
-  {
-    label: 'ViT-B/32 FP32',
-    value: models.image_embedding.clip_vit_base_patch32_image({
-      quant: false,
-    }),
-  },
-];
-import { launchImageLibrary } from 'react-native-image-picker';
-import { useIsFocused } from 'expo-router';
-import { dotProduct } from '../../utils/math';
-import { ModelPicker } from '../../components/ModelPicker';
-
-const DEFAULT_LABELS = [
-  'a photo of a dog',
-  'a photo of a cat',
-  'a landscape photo',
-  'a photo of food',
-  'a photo of people',
-];
-
-export default function ClipEmbeddingsScreenWrapper() {
-  const isFocused = useIsFocused();
-
-  return isFocused ? <ClipEmbeddingsScreen /> : null;
-}
-
-function ClipEmbeddingsScreen() {
-  const [selectedImageModel, setSelectedImageModel] =
-    useState<ImageEmbeddingModel>(
-      models.image_embedding.clip_vit_base_patch32_image()
-    );
-
-  const textModel = useTextEmbeddings({
-    model: models.text_embedding.clip_vit_base_patch32_text(),
-  });
-  const imageModel = useImageEmbeddings({ model: selectedImageModel });
-
-  const [imageUri, setImageUri] = useState<string | null>(null);
-  const [newLabel, setNewLabel] = useState('');
-  const [labels, setLabels] = useState<string[]>(DEFAULT_LABELS);
-  const [results, setResults] = useState<
-    { label: string; similarity: number }[]
-  >([]);
-  const [imageEmbeddingTime, setImageEmbeddingTime] = useState<number | null>(
-    null
-  );
-  const [textEmbeddingTime, setTextEmbeddingTime] = useState<number | null>(
-    null
-  );
-
-  const getModelStatusText = (model: typeof textModel | typeof imageModel) => {
-    if (model.error) return `Oops! ${model.error}`;
-    if (!model.isReady)
-      return `Loading ${(model.downloadProgress * 100).toFixed(0)}%`;
-    return model.isGenerating ? 'Generating…' : 'Ready';
-  };
-
-  const pickImage = async () => {
-    const output = await launchImageLibrary({ mediaType: 'photo' });
-    if (!output.assets?.[0]?.uri) return;
-    setImageUri(output.assets[0].uri);
-    setResults([]);
-  };
-
-  const classify = async () => {
-    if (!imageUri || !imageModel.isReady || !textModel.isReady) return;
-
-    try {
-      const imgStart = Date.now();
-      const imageEmbedding = await imageModel.forward(imageUri);
-      setImageEmbeddingTime(Date.now() - imgStart);
-
-      const txtStart = Date.now();
-      const scored: { label: string; similarity: number }[] = [];
-      for (const label of labels) {
-        const textEmbedding = await textModel.forward(label);
-        scored.push({
-          label,
-          similarity: dotProduct(imageEmbedding, textEmbedding),
-        });
-      }
-      setTextEmbeddingTime(Math.round((Date.now() - txtStart) / labels.length));
-
-      scored.sort((a, b) => b.similarity - a.similarity);
-      setResults(scored);
-    } catch (e) {
-      console.error('Error during classification:', e);
-    }
-  };
-
-  const addLabel = () => {
-    const trimmed = newLabel.trim();
-    if (!trimmed || labels.includes(trimmed)) return;
-    setLabels((prev) => [...prev, trimmed]);
-    setNewLabel('');
-    setResults([]);
-  };
-
-  const removeLabel = (label: string) => {
-    setLabels((prev) => prev.filter((l) => l !== label));
-    setResults((prev) => prev.filter((r) => r.label !== label));
-  };
-
-  const modelsReady = textModel.isReady && imageModel.isReady;
-
-  return (
-    <SafeAreaView style={styles.container}>
-      <KeyboardAvoidingView
-        style={styles.flex}
-        behavior={Platform.OS === 'ios' ? 'padding' : undefined}
-      >
-        <ScrollView
-          contentContainerStyle={styles.scrollContainer}
-          keyboardShouldPersistTaps="handled"
-        >
-          <Text style={styles.heading}>CLIP Image Embeddings</Text>
-
-          <View style={styles.statusRow}>
-            <Text style={styles.statusText}>
-              Text model: {getModelStatusText(textModel)}
-            </Text>
-            <Text style={styles.statusText}>
-              Image model: {getModelStatusText(imageModel)}
-            </Text>
-          </View>
-
-          <ModelPicker
-            models={IMAGE_MODELS}
-            selectedModel={selectedImageModel}
-            onSelect={(m) => {
-              setSelectedImageModel(m);
-              setResults([]);
-            }}
-          />
-
-          {/* Image picker */}
-          <TouchableOpacity style={styles.imagePicker} onPress={pickImage}>
-            {imageUri ? (
-              <Image
-                source={{ uri: imageUri }}
-                style={styles.image}
-                resizeMode="cover"
-              />
-            ) : (
-              <View style={styles.imagePlaceholder}>
-                <Ionicons name="image-outline" size={48} color="#94A3B8" />
-                <Text style={styles.imagePlaceholderText}>
-                  Tap to pick an image
-                </Text>
-              </View>
-            )}
-          </TouchableOpacity>
-
-          {/* Classify button */}
-          <TouchableOpacity
-            style={[
-              styles.classifyButton,
-              (!imageUri || !modelsReady) && styles.buttonDisabled,
-            ]}
-            onPress={classify}
-            disabled={!imageUri || !modelsReady}
-          >
-            <Ionicons
-              name="sparkles-outline"
-              size={18}
-              color={imageUri && modelsReady ? 'white' : 'gray'}
-            />
-            <Text
-              style={[
-                styles.classifyButtonText,
-                (!imageUri || !modelsReady) && styles.buttonTextDisabled,
-              ]}
-            >
-              {!imageUri ? 'Pick an image first' : 'Find best matching label'}
-            </Text>
-          </TouchableOpacity>
-
-          {/* Results */}
-          {results.length > 0 && (
-            <View style={styles.card}>
-              <Text style={styles.sectionTitle}>Results</Text>
-              {results.map((item, index) => (
-                <View key={item.label} style={styles.resultRow}>
-                  <Text
-                    style={[
-                      styles.resultLabel,
-                      index === 0 && styles.topResultLabel,
-                    ]}
-                  >
-                    {index === 0 ? '🥇 ' : ''}
-                    {item.label}
-                  </Text>
-                  <Text style={styles.resultScore}>
-                    {item.similarity.toFixed(3)}
-                  </Text>
-                </View>
-              ))}
-              {(imageEmbeddingTime !== null || textEmbeddingTime !== null) && (
-                <View style={styles.statsContainer}>
-                  {imageEmbeddingTime !== null && (
-                    <Text style={styles.statsText}>
-                      Image embedding: {imageEmbeddingTime} ms
-                    </Text>
-                  )}
-                  {textEmbeddingTime !== null && (
-                    <Text style={styles.statsText}>
-                      Text embeddings: {textEmbeddingTime} ms
-                    </Text>
-                  )}
-                </View>
-              )}
-            </View>
-          )}
-
-          {/* Labels */}
-          <View style={styles.card}>
-            <Text style={styles.sectionTitle}>Text Labels</Text>
-            {labels.map((label) => (
-              <View key={label} style={styles.labelRow}>
-                <Text style={styles.labelText}>{label}</Text>
-                <TouchableOpacity onPress={() => removeLabel(label)}>
-                  <Ionicons
-                    name="close-circle-outline"
-                    size={20}
-                    color="#94A3B8"
-                  />
-                </TouchableOpacity>
-              </View>
-            ))}
-            <View style={styles.addLabelRow}>
-              <TextInput
-                style={styles.input}
-                placeholder="Add a label…"
-                placeholderTextColor="#94A3B8"
-                value={newLabel}
-                onChangeText={setNewLabel}
-                onSubmitEditing={addLabel}
-                returnKeyType="done"
-              />
-              <TouchableOpacity
-                style={[
-                  styles.addButton,
-                  !newLabel.trim() && styles.buttonDisabled,
-                ]}
-                onPress={addLabel}
-                disabled={!newLabel.trim()}
-              >
-                <Ionicons
-                  name="add"
-                  size={20}
-                  color={newLabel.trim() ? 'white' : 'gray'}
-                />
-              </TouchableOpacity>
-            </View>
-          </View>
-        </ScrollView>
-      </KeyboardAvoidingView>
-    </SafeAreaView>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: { flex: 1, backgroundColor: '#F8FAFC' },
-  flex: { flex: 1 },
-  scrollContainer: { padding: 20, alignItems: 'center', flexGrow: 1 },
-  heading: {
-    fontSize: 24,
-    fontWeight: '500',
-    marginBottom: 12,
-    color: '#0F172A',
-  },
-  statusRow: {
-    width: '100%',
-    marginBottom: 16,
-    gap: 2,
-  },
-  statusText: { fontSize: 13, color: '#64748B' },
-  imagePicker: {
-    width: '100%',
-    height: 220,
-    borderRadius: 16,
-    overflow: 'hidden',
-    marginBottom: 20,
-    borderWidth: 2,
-    borderColor: '#E2E8F0',
-    backgroundColor: '#fff',
-  },
-  image: { width: '100%', height: '100%' },
-  imagePlaceholder: {
-    flex: 1,
-    alignItems: 'center',
-    justifyContent: 'center',
-    gap: 8,
-  },
-  imagePlaceholderText: { fontSize: 14, color: '#94A3B8' },
-  card: {
-    backgroundColor: '#FFFFFF',
-    width: '100%',
-    padding: 16,
-    borderRadius: 16,
-    borderColor: '#E2E8F0',
-    borderWidth: 2,
-    marginBottom: 20,
-  },
-  sectionTitle: {
-    fontSize: 16,
-    fontWeight: '600',
-    marginBottom: 12,
-    color: '#1E293B',
-  },
-  labelRow: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    justifyContent: 'space-between',
-    paddingVertical: 6,
-    borderBottomWidth: 1,
-    borderBottomColor: '#F1F5F9',
-  },
-  labelText: { fontSize: 14, color: '#334155', flex: 1 },
-  addLabelRow: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    gap: 8,
-    marginTop: 12,
-  },
-  input: {
-    flex: 1,
-    backgroundColor: '#F1F5F9',
-    borderRadius: 10,
-    padding: 10,
-    fontSize: 14,
-    color: '#0F172A',
-  },
-  addButton: {
-    backgroundColor: 'navy',
-    borderRadius: 10,
-    width: 40,
-    height: 40,
-    alignItems: 'center',
-    justifyContent: 'center',
-  },
-  classifyButton: {
-    width: '100%',
-    backgroundColor: 'navy',
-    padding: 14,
-    borderRadius: 12,
-    flexDirection: 'row',
-    alignItems: 'center',
-    justifyContent: 'center',
-    gap: 8,
-    marginBottom: 20,
-  },
-  classifyButtonText: { color: 'white', fontWeight: '600', fontSize: 15 },
-  buttonDisabled: { backgroundColor: '#f0f0f0', borderColor: '#d3d3d3' },
-  buttonTextDisabled: { color: 'gray' },
-  resultRow: {
-    flexDirection: 'row',
-    justifyContent: 'space-between',
-    alignItems: 'center',
-    paddingVertical: 6,
-    borderBottomWidth: 1,
-    borderBottomColor: '#F1F5F9',
-  },
-  resultLabel: { fontSize: 14, color: '#334155', flex: 1 },
-  topResultLabel: { fontWeight: '700', color: '#0F172A' },
-  resultScore: { fontSize: 13, color: '#64748B', marginLeft: 8 },
-  statsContainer: { marginTop: 12, gap: 2 },
-  statsText: { fontSize: 12, color: '#94A3B8' },
-});
diff --git a/apps/text-embeddings/app/index.tsx b/apps/text-embeddings/app/index.tsx
deleted file mode 100644
index f661e44978..0000000000
--- a/apps/text-embeddings/app/index.tsx
+++ /dev/null
@@ -1,69 +0,0 @@
-import { useRouter } from 'expo-router';
-import { View, Text, StyleSheet, TouchableOpacity } from 'react-native';
-import ColorPalette from '../colors';
-import ExecutorchLogo from '../assets/executorch.svg';
-
-export default function Home() {
-  const router = useRouter();
-
-  return (
-    <View style={styles.container}>
-      <ExecutorchLogo width={64} height={64} />
-      <Text style={styles.headerText}>Select a demo model</Text>
-      <View style={styles.buttonContainer}>
-        <TouchableOpacity
-          style={styles.button}
-          onPress={() => router.navigate('text-embeddings/')}
-        >
-          <Text style={styles.buttonText}>Text embeddings</Text>
-        </TouchableOpacity>
-        <TouchableOpacity
-          style={styles.button}
-          onPress={() => router.navigate('clip-embeddings/')}
-        >
-          <Text style={styles.buttonText}>Clip embeddings</Text>
-        </TouchableOpacity>
-      </View>
-    </View>
-  );
-}
-
-export const fontSizes = {
-  xxl: 34,
-  xl: 22,
-  lg: 18,
-  md: 16,
-  sm: 14,
-  xs: 12,
-  xxs: 10,
-};
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-    backgroundColor: '#fff',
-  },
-  headerText: {
-    fontSize: fontSizes.lg,
-    color: ColorPalette.strongPrimary,
-    margin: 20,
-  },
-  buttonContainer: {
-    width: '80%',
-    justifyContent: 'space-evenly',
-    marginBottom: 20,
-  },
-  button: {
-    backgroundColor: ColorPalette.strongPrimary,
-    borderRadius: 8,
-    padding: 10,
-    alignItems: 'center',
-    marginBottom: 10,
-  },
-  buttonText: {
-    color: 'white',
-    fontSize: fontSizes.md,
-  },
-});
diff --git a/apps/text-embeddings/app/text-embeddings/index.tsx b/apps/text-embeddings/app/text-embeddings/index.tsx
deleted file mode 100644
index 88e39ce063..0000000000
--- a/apps/text-embeddings/app/text-embeddings/index.tsx
+++ /dev/null
@@ -1,399 +0,0 @@
-import { useEffect, useState } from 'react';
-import {
-  StyleSheet,
-  Text,
-  TextInput,
-  TouchableOpacity,
-  View,
-  SafeAreaView,
-  ScrollView,
-  KeyboardAvoidingView,
-  Platform,
-} from 'react-native';
-import { Ionicons } from '@expo/vector-icons';
-import { ModelPicker } from '../../components/ModelPicker';
-import {
-  models,
-  useTextEmbeddings,
-  TextEmbeddingsProps,
-} from 'react-native-executorch';
-const textEmbedding = models.text_embedding;
-
-type TextEmbeddingModel = TextEmbeddingsProps['model'];
-
-const MODELS: { label: string; value: TextEmbeddingModel }[] = [
-  { label: 'MiniLM L6', value: textEmbedding.all_minilm_l6_v2() },
-  {
-    label: 'MPNet Base',
-    value: textEmbedding.all_mpnet_base_v2(),
-  },
-  {
-    label: 'MultiQA MiniLM',
-    value: textEmbedding.multi_qa_minilm_l6_cos_v1(),
-  },
-  {
-    label: 'MultiQA MPNet',
-    value: textEmbedding.multi_qa_mpnet_base_dot_v1(),
-  },
-  {
-    label: 'Multilingual DistilUSE',
-    value: textEmbedding.distiluse_base_multilingual_cased_v2(),
-  },
-  {
-    label: 'Multilingual Paraphrase',
-    value: textEmbedding.paraphrase_multilingual_minilm_l12_v2(),
-  },
-];
-import { useIsFocused } from 'expo-router';
-import { dotProduct } from '../../utils/math';
-import ErrorBanner from '../../components/ErrorBanner';
-
-export default function TextEmbeddingsScreenWrapper() {
-  const isFocused = useIsFocused();
-
-  return isFocused ? <TextEmbeddingsScreen /> : null;
-}
-
-function TextEmbeddingsScreen() {
-  const [selectedModel, setSelectedModel] = useState<TextEmbeddingModel>(
-    textEmbedding.all_minilm_l6_v2()
-  );
-  const model = useTextEmbeddings({ model: selectedModel });
-  const [error, setError] = useState<string | null>(null);
-
-  const [inputSentence, setInputSentence] = useState('');
-  const [sentencesWithEmbeddings, setSentencesWithEmbeddings] = useState<
-    { sentence: string; embedding: Float32Array }[]
-  >([]);
-  const [topMatches, setTopMatches] = useState<
-    { sentence: string; similarity: number }[]
-  >([]);
-  const [embeddingTime, setEmbeddingTime] = useState<number | null>(null);
-
-  useEffect(
-    () => {
-      const computeEmbeddings = async () => {
-        if (!model.isReady) return;
-
-        const sentences = [
-          'The weather is lovely today.',
-          "It's so sunny outside!",
-          'He drove to the stadium.',
-        ];
-
-        try {
-          const embeddings = [];
-          for (const sentence of sentences) {
-            const embedding = await model.forward(sentence);
-            embeddings.push({ sentence, embedding });
-          }
-
-          setSentencesWithEmbeddings(embeddings);
-        } catch (e) {
-          setError(e instanceof Error ? e.message : String(e));
-        }
-      };
-
-      computeEmbeddings();
-    },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [model.isReady]
-  );
-
-  const checkSimilarities = async () => {
-    if (!model.isReady || !inputSentence.trim()) return;
-
-    try {
-      const start = Date.now();
-      const inputEmbedding = await model.forward(inputSentence);
-      setEmbeddingTime(Date.now() - start);
-      const matches = sentencesWithEmbeddings.map(
-        ({ sentence, embedding }) => ({
-          sentence,
-          similarity: dotProduct(inputEmbedding, embedding),
-        })
-      );
-      matches.sort((a, b) => b.similarity - a.similarity);
-      setTopMatches(matches.slice(0, 3));
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-    }
-  };
-
-  const addToSentences = async () => {
-    if (!model.isReady || !inputSentence.trim()) return;
-
-    try {
-      const start = Date.now();
-      const embedding = await model.forward(inputSentence);
-      setEmbeddingTime(Date.now() - start);
-      setSentencesWithEmbeddings((prev) => [
-        ...prev,
-        { sentence: inputSentence, embedding },
-      ]);
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-    }
-
-    setInputSentence('');
-    setTopMatches([]);
-  };
-
-  const clearList = async () => {
-    if (!model.isReady) return;
-    try {
-      setSentencesWithEmbeddings([]);
-    } catch (e) {
-      setError(e instanceof Error ? e.message : String(e));
-    }
-  };
-
-  const getModelStatusText = () => {
-    if (model.error) {
-      return `Oops! Error: ${model.error}`;
-    }
-    if (!model.isReady) {
-      return `Loading model ${(model.downloadProgress * 100).toFixed(2)}%`;
-    }
-    return model.isGenerating ? 'Generating...' : 'Model is ready';
-  };
-
-  return (
-    <SafeAreaView style={styles.container}>
-      <KeyboardAvoidingView
-        style={styles.flexContainer}
-        behavior={Platform.OS === 'ios' ? 'padding' : undefined}
-      >
-        <ScrollView contentContainerStyle={styles.scrollContainer}>
-          <Text style={styles.heading}>Text Embeddings Playground</Text>
-          <Text style={styles.sectionTitle}>{getModelStatusText()}</Text>
-          <ModelPicker
-            models={MODELS}
-            selectedModel={selectedModel}
-            onSelect={(m) => {
-              setSelectedModel(m);
-              setSentencesWithEmbeddings([]);
-              setTopMatches([]);
-            }}
-          />
-          <ErrorBanner message={error} onDismiss={() => setError(null)} />
-
-          <View style={styles.card}>
-            <Text style={styles.sectionTitle}>List of Existing Sentences</Text>
-            {sentencesWithEmbeddings.map((item, index) => (
-              <Text key={index} style={styles.sentenceText}>
-                - {item.sentence}
-              </Text>
-            ))}
-          </View>
-          <View style={styles.card}>
-            <Text style={styles.sectionTitle}>Try Your Sentence</Text>
-            <TextInput
-              placeholder="Type your sentence here..."
-              placeholderTextColor="#94A3B8"
-              style={styles.input}
-              value={inputSentence}
-              onChangeText={setInputSentence}
-              multiline
-            />
-            <View style={styles.buttonContainer}>
-              <TouchableOpacity
-                onPress={checkSimilarities}
-                style={[
-                  styles.buttonPrimary,
-                  !inputSentence && styles.buttonDisabled,
-                ]}
-                disabled={!inputSentence}
-              >
-                <Ionicons
-                  name="search"
-                  size={16}
-                  color={!inputSentence ? 'gray' : 'white'}
-                />
-                <Text
-                  style={[
-                    styles.buttonText,
-                    !inputSentence && styles.buttonTextDisabled,
-                  ]}
-                >
-                  Find Similar
-                </Text>
-              </TouchableOpacity>
-              <View style={styles.buttonGroup}>
-                <TouchableOpacity
-                  onPress={addToSentences}
-                  style={[
-                    styles.buttonSecondary,
-                    !inputSentence && styles.buttonDisabled,
-                  ]}
-                  disabled={!inputSentence}
-                >
-                  <Ionicons
-                    name="add-circle-outline"
-                    size={16}
-                    color={!inputSentence ? 'gray' : 'navy'}
-                  />
-                  <Text
-                    style={[
-                      styles.buttonTextOutline,
-                      !inputSentence && styles.buttonTextDisabled,
-                    ]}
-                  >
-                    Add to List
-                  </Text>
-                </TouchableOpacity>
-                <TouchableOpacity
-                  onPress={clearList}
-                  style={[
-                    styles.buttonSecondary,
-                    sentencesWithEmbeddings.length === 0 &&
-                      styles.buttonDisabled,
-                  ]}
-                  disabled={sentencesWithEmbeddings.length === 0}
-                >
-                  <Ionicons
-                    name="close-outline"
-                    size={16}
-                    color={
-                      sentencesWithEmbeddings.length === 0 ? 'gray' : 'navy'
-                    }
-                  />
-                  <Text
-                    style={[
-                      styles.buttonTextOutline,
-                      sentencesWithEmbeddings.length === 0 &&
-                        styles.buttonTextDisabled,
-                    ]}
-                  >
-                    Clear List
-                  </Text>
-                </TouchableOpacity>
-              </View>
-            </View>
-            {embeddingTime !== null && (
-              <Text style={styles.statsText}>
-                Embedding time: {embeddingTime} ms
-              </Text>
-            )}
-            {topMatches.length > 0 && (
-              <View style={styles.topMatchesContainer}>
-                <Text style={styles.sectionTitle}>Top Matches</Text>
-                {topMatches.map((item, index) => (
-                  <Text key={index} style={styles.sentenceText}>
-                    {item.sentence} ({item.similarity.toFixed(2)})
-                  </Text>
-                ))}
-              </View>
-            )}
-          </View>
-        </ScrollView>
-      </KeyboardAvoidingView>
-    </SafeAreaView>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    backgroundColor: '#F8FAFC',
-  },
-  scrollContainer: {
-    padding: 20,
-    alignItems: 'center',
-    flexGrow: 1,
-  },
-  heading: {
-    fontSize: 24,
-    fontWeight: '500',
-    marginBottom: 20,
-    color: '#0F172A',
-  },
-  card: {
-    backgroundColor: '#FFFFFF',
-    width: '100%',
-    padding: 16,
-    borderRadius: 16,
-    borderColor: '#E2E8F0',
-    borderWidth: 2,
-    marginBottom: 20,
-  },
-  sectionTitle: {
-    fontSize: 18,
-    fontWeight: '500',
-    marginBottom: 12,
-    color: '#1E293B',
-  },
-  sentenceText: {
-    fontSize: 14,
-    marginBottom: 6,
-    color: '#334155',
-  },
-  input: {
-    backgroundColor: '#F1F5F9',
-    borderRadius: 10,
-    padding: 10,
-    marginBottom: 10,
-    fontSize: 16,
-    color: '#0F172A',
-    minHeight: 40,
-    textAlignVertical: 'top',
-  },
-  buttonContainer: {
-    width: '100%',
-    gap: 10,
-  },
-  buttonGroup: {
-    flexDirection: 'row',
-    justifyContent: 'space-between',
-    gap: 10,
-  },
-  buttonPrimary: {
-    flex: 1,
-    backgroundColor: 'navy',
-    padding: 12,
-    borderRadius: 10,
-    flexDirection: 'row',
-    alignItems: 'center',
-    justifyContent: 'center',
-  },
-  buttonSecondary: {
-    flex: 1,
-    backgroundColor: 'transparent',
-    borderWidth: 2,
-    borderColor: 'navy',
-    padding: 12,
-    borderRadius: 10,
-    flexDirection: 'row',
-    alignItems: 'center',
-    justifyContent: 'center',
-  },
-  buttonDisabled: {
-    backgroundColor: '#f0f0f0',
-    borderColor: '#d3d3d3',
-  },
-  buttonText: {
-    color: 'white',
-    textAlign: 'center',
-    fontWeight: '500',
-  },
-  buttonTextOutline: {
-    color: 'navy',
-    textAlign: 'center',
-    fontWeight: '500',
-  },
-  buttonTextDisabled: {
-    color: 'gray',
-  },
-  topMatchesContainer: {
-    marginTop: 20,
-  },
-  statsText: {
-    fontSize: 13,
-    color: '#64748B',
-    marginTop: 8,
-    textAlign: 'center',
-  },
-  flexContainer: {
-    flex: 1,
-  },
-});
diff --git a/apps/text-embeddings/assets/adaptive-icon.png b/apps/text-embeddings/assets/adaptive-icon.png
deleted file mode 100644
index 03d6f6b6c6..0000000000
Binary files a/apps/text-embeddings/assets/adaptive-icon.png and /dev/null differ
diff --git a/apps/text-embeddings/assets/executorch.svg b/apps/text-embeddings/assets/executorch.svg
deleted file mode 100644
index e548ea4201..0000000000
--- a/apps/text-embeddings/assets/executorch.svg
+++ /dev/null
@@ -1,9 +0,0 @@
-<svg width="65" height="64" viewBox="0 0 65 64" fill="none" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
-<path d="M0.5 4C0.5 1.79086 2.29086 0 4.5 0H60.5C62.7091 0 64.5 1.79086 64.5 4V60C64.5 62.2091 62.7091 64 60.5 64H4.5C2.29086 64 0.5 62.2091 0.5 60V4Z" fill="url(#pattern0_13229_4194)"/>
-<defs>
-<pattern id="pattern0_13229_4194" patternContentUnits="objectBoundingBox" width="1" height="1">
-<use xlink:href="#image0_13229_4194" transform="translate(-0.000263435) scale(0.00052687)"/>
-</pattern>
-<image id="image0_13229_4194" width="1899" height="1898" preserveAspectRatio="none" xlink:href="data:image/png;base64,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"/>
-</defs>
-</svg>
diff --git a/apps/text-embeddings/assets/favicon.png b/apps/text-embeddings/assets/favicon.png
deleted file mode 100644
index e75f697b18..0000000000
Binary files a/apps/text-embeddings/assets/favicon.png and /dev/null differ
diff --git a/apps/text-embeddings/assets/icon.png b/apps/text-embeddings/assets/icon.png
deleted file mode 100644
index a0b1526fc7..0000000000
Binary files a/apps/text-embeddings/assets/icon.png and /dev/null differ
diff --git a/apps/text-embeddings/assets/splash-icon.png b/apps/text-embeddings/assets/splash-icon.png
deleted file mode 100644
index 03d6f6b6c6..0000000000
Binary files a/apps/text-embeddings/assets/splash-icon.png and /dev/null differ
diff --git a/apps/text-embeddings/babel.config.js b/apps/text-embeddings/babel.config.js
deleted file mode 100644
index 9d89e13119..0000000000
--- a/apps/text-embeddings/babel.config.js
+++ /dev/null
@@ -1,6 +0,0 @@
-module.exports = function (api) {
-  api.cache(true);
-  return {
-    presets: ['babel-preset-expo'],
-  };
-};
diff --git a/apps/text-embeddings/colors.ts b/apps/text-embeddings/colors.ts
deleted file mode 100644
index 03defcda9e..0000000000
--- a/apps/text-embeddings/colors.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-const ColorPalette = {
-  primary: '#001A72',
-  seaBlueLight: '#E1F3FA',
-  seaBlueMedium: '#B5E1F1',
-  seaBlueDark: '#87CCE8',
-  blueLight: '#C1C6E5',
-  blueDark: '#6676AA',
-  strongPrimary: '#020F3C',
-};
-
-export default ColorPalette;
diff --git a/apps/text-embeddings/components/ErrorBanner.tsx b/apps/text-embeddings/components/ErrorBanner.tsx
deleted file mode 100644
index a5bebc504f..0000000000
--- a/apps/text-embeddings/components/ErrorBanner.tsx
+++ /dev/null
@@ -1,53 +0,0 @@
-import React from 'react';
-import { View, Text, TouchableOpacity, StyleSheet } from 'react-native';
-
-interface ErrorBannerProps {
-  message: string | null;
-  onDismiss: () => void;
-}
-
-export default function ErrorBanner({ message, onDismiss }: ErrorBannerProps) {
-  if (!message) return null;
-
-  return (
-    <View style={styles.container}>
-      <Text style={styles.message} numberOfLines={3}>
-        {message}
-      </Text>
-      <TouchableOpacity onPress={onDismiss} style={styles.closeButton}>
-        <Text style={styles.closeText}>✕</Text>
-      </TouchableOpacity>
-    </View>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: {
-    backgroundColor: '#FEE2E2',
-    borderLeftWidth: 4,
-    borderLeftColor: '#EF4444',
-    borderRadius: 8,
-    marginHorizontal: 16,
-    marginVertical: 8,
-    paddingVertical: 10,
-    paddingLeft: 12,
-    paddingRight: 8,
-    flexDirection: 'row',
-    alignItems: 'center',
-  },
-  message: {
-    flex: 1,
-    color: '#991B1B',
-    fontSize: 14,
-    lineHeight: 20,
-  },
-  closeButton: {
-    padding: 4,
-    marginLeft: 8,
-  },
-  closeText: {
-    color: '#991B1B',
-    fontSize: 16,
-    fontWeight: '600',
-  },
-});
diff --git a/apps/text-embeddings/components/ModelPicker.tsx b/apps/text-embeddings/components/ModelPicker.tsx
deleted file mode 100644
index 94a848596e..0000000000
--- a/apps/text-embeddings/components/ModelPicker.tsx
+++ /dev/null
@@ -1,216 +0,0 @@
-import React, { useEffect, useRef, useState } from 'react';
-import {
-  Dimensions,
-  Modal,
-  ScrollView,
-  StyleSheet,
-  Text,
-  TouchableOpacity,
-  View,
-} from 'react-native';
-
-export type ModelOption<T> = {
-  label: string;
-  value: T;
-};
-
-type Props<T> = {
-  models: ModelOption<T>[];
-  selectedModel: T;
-  onSelect: (model: T) => void;
-  label?: string;
-  disabled?: boolean;
-};
-
-const DROPDOWN_MAX_HEIGHT = 200;
-
-export function ModelPicker<T>({
-  models,
-  selectedModel,
-  onSelect,
-  label,
-  disabled,
-}: Props<T>) {
-  const [open, setOpen] = useState(false);
-  const [triggerHeight, setTriggerHeight] = useState(0);
-  const [expandUp, setExpandUp] = useState(false);
-  const [dropdownTop, setDropdownTop] = useState(0);
-  const triggerRef = useRef<React.ComponentRef<typeof TouchableOpacity>>(null);
-  const selected = models.find((m) => m.value === selectedModel);
-
-  useEffect(() => {
-    if (disabled) setOpen(false);
-  }, [disabled]);
-
-  const handlePress = () => {
-    if (disabled) return;
-    if (open) {
-      setOpen(false);
-      return;
-    }
-    triggerRef.current?.measure(
-      (
-        _x: number,
-        _y: number,
-        _width: number,
-        height: number,
-        _pageX: number,
-        pageY: number
-      ) => {
-        setTriggerHeight(height);
-        const spaceBelow = Dimensions.get('window').height - (pageY + height);
-        setExpandUp(spaceBelow < DROPDOWN_MAX_HEIGHT);
-        setDropdownTop(pageY);
-        setOpen(true);
-      }
-    );
-  };
-
-  const dropdownStylePosition = expandUp
-    ? {
-        bottom: Dimensions.get('window').height - dropdownTop,
-        left: 12,
-        right: 12,
-      }
-    : {
-        top: dropdownTop + triggerHeight + 2,
-        left: 12,
-        right: 12,
-      };
-
-  return (
-    <>
-      <View style={styles.container}>
-        <TouchableOpacity
-          ref={triggerRef}
-          style={[styles.trigger, disabled && styles.triggerDisabled]}
-          onPress={handlePress}
-          activeOpacity={disabled ? 1 : 0.7}
-        >
-          {label && <Text style={styles.label}>{label}</Text>}
-          <Text style={styles.triggerText}>{selected?.label ?? '—'}</Text>
-          <Text style={styles.chevron}>{open ? '▲' : '▼'}</Text>
-        </TouchableOpacity>
-      </View>
-
-      {open && (
-        <Modal
-          transparent
-          visible={open}
-          onRequestClose={() => setOpen(false)}
-          animationType="none"
-        >
-          <TouchableOpacity
-            style={styles.modalBackdrop}
-            activeOpacity={1}
-            onPress={() => setOpen(false)}
-          />
-          <View style={[styles.dropdown, dropdownStylePosition]}>
-            <ScrollView
-              nestedScrollEnabled
-              keyboardShouldPersistTaps="handled"
-              showsVerticalScrollIndicator={true}
-            >
-              {models.map((item) => {
-                const isSelected = item.value === selectedModel;
-                return (
-                  <TouchableOpacity
-                    key={item.label}
-                    style={[styles.option, isSelected && styles.optionSelected]}
-                    onPress={() => {
-                      onSelect(item.value);
-                      setOpen(false);
-                    }}
-                    activeOpacity={0.7}
-                  >
-                    <Text
-                      style={[
-                        styles.optionText,
-                        isSelected && styles.optionTextSelected,
-                      ]}
-                    >
-                      {item.label}
-                    </Text>
-                  </TouchableOpacity>
-                );
-              })}
-            </ScrollView>
-          </View>
-        </Modal>
-      )}
-    </>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: {
-    marginHorizontal: 12,
-    marginVertical: 4,
-    alignSelf: 'stretch',
-    zIndex: 100,
-  },
-  trigger: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    borderWidth: 1,
-    borderColor: '#C1C6E5',
-    borderRadius: 8,
-    paddingHorizontal: 12,
-    paddingVertical: 10,
-    backgroundColor: '#f5f5f5',
-  },
-  triggerDisabled: {
-    opacity: 0.4,
-  },
-  label: {
-    fontSize: 12,
-    color: '#888',
-    marginRight: 6,
-  },
-  triggerText: {
-    flex: 1,
-    fontSize: 14,
-    color: '#001A72',
-    fontWeight: '500',
-  },
-  chevron: {
-    fontSize: 10,
-    color: '#888',
-    marginLeft: 6,
-  },
-  modalBackdrop: {
-    flex: 1,
-    backgroundColor: 'rgba(0, 0, 0, 0.3)',
-  },
-  dropdown: {
-    position: 'absolute',
-    borderWidth: 1,
-    borderColor: '#C1C6E5',
-    borderRadius: 8,
-    backgroundColor: '#fff',
-    maxHeight: DROPDOWN_MAX_HEIGHT,
-    zIndex: 1000,
-    elevation: 5,
-    shadowColor: '#000',
-    shadowOffset: { width: 0, height: 4 },
-    shadowOpacity: 0.15,
-    shadowRadius: 6,
-  },
-  option: {
-    paddingHorizontal: 12,
-    paddingVertical: 10,
-    borderBottomWidth: 1,
-    borderBottomColor: '#f0f0f0',
-  },
-  optionSelected: {
-    backgroundColor: '#e8ecf8',
-  },
-  optionText: {
-    fontSize: 14,
-    color: '#333',
-  },
-  optionTextSelected: {
-    color: '#001A72',
-    fontWeight: '600',
-  },
-});
diff --git a/apps/text-embeddings/context.ts b/apps/text-embeddings/context.ts
deleted file mode 100644
index 0eb0560768..0000000000
--- a/apps/text-embeddings/context.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-import { createContext } from 'react';
-
-export const GeneratingContext = createContext({
-  setGlobalGenerating: (_newState: boolean) => {},
-});
diff --git a/apps/text-embeddings/declarations.d.ts b/apps/text-embeddings/declarations.d.ts
deleted file mode 100644
index 85e178f497..0000000000
--- a/apps/text-embeddings/declarations.d.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-declare module '*.svg' {
-  import { SvgProps } from 'react-native-svg';
-  const content: React.FV<SvgProps>;
-  export default content;
-}
diff --git a/apps/text-embeddings/index.ts b/apps/text-embeddings/index.ts
deleted file mode 100644
index 3f443dcf95..0000000000
--- a/apps/text-embeddings/index.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-import { registerRootComponent } from 'expo';
-
-import App from './app';
-
-// registerRootComponent calls AppRegistry.registerComponent('main', () => App);
-// It also ensures that whether you load the app in Expo Go or in a native build,
-// the environment is set up appropriately
-registerRootComponent(App);
diff --git a/apps/text-embeddings/metro.config.js b/apps/text-embeddings/metro.config.js
deleted file mode 100644
index f8ab2ab96d..0000000000
--- a/apps/text-embeddings/metro.config.js
+++ /dev/null
@@ -1,21 +0,0 @@
-// Learn more https://docs.expo.io/guides/customizing-metro
-const { getDefaultConfig } = require('expo/metro-config');
-
-/** @type {import('expo/metro-config').MetroConfig} */
-const config = getDefaultConfig(__dirname);
-
-const { transformer, resolver } = config;
-
-config.transformer = {
-  ...transformer,
-  babelTransformerPath: require.resolve('react-native-svg-transformer/expo'),
-};
-config.resolver = {
-  ...resolver,
-  assetExts: resolver.assetExts.filter((ext) => ext !== 'svg'),
-  sourceExts: [...resolver.sourceExts, 'svg'],
-};
-
-config.resolver.assetExts.push('pte');
-
-module.exports = config;
diff --git a/apps/text-embeddings/package.json b/apps/text-embeddings/package.json
deleted file mode 100644
index f49ff45e3f..0000000000
--- a/apps/text-embeddings/package.json
+++ /dev/null
@@ -1,46 +0,0 @@
-{
-  "name": "text-embeddings",
-  "version": "1.0.0",
-  "main": "expo-router/entry",
-  "scripts": {
-    "start": "expo start",
-    "android": "expo run:android",
-    "ios": "expo run:ios",
-    "web": "expo start --web",
-    "typecheck": "tsc",
-    "lint": "eslint . --ext .ts,.tsx --fix"
-  },
-  "dependencies": {
-    "@expo/log-box": "~56.0.12",
-    "@expo/vector-icons": "^15.0.2",
-    "@react-native/metro-config": "^0.85.3",
-    "@react-navigation/drawer": "^7.9.4",
-    "@react-navigation/native": "^7.2.2",
-    "expo": "~56.0.9",
-    "expo-build-properties": "~56.0.17",
-    "expo-constants": "~56.0.17",
-    "expo-font": "~56.0.5",
-    "expo-linking": "~56.0.13",
-    "expo-router": "~56.2.9",
-    "expo-status-bar": "~56.0.4",
-    "react": "19.2.3",
-    "react-native": "0.85.3",
-    "react-native-executorch": "workspace:*",
-    "react-native-executorch-expo-resource-fetcher": "workspace:*",
-    "react-native-gesture-handler": "~2.31.1",
-    "react-native-image-picker": "^8.2.1",
-    "react-native-reanimated": "4.3.1",
-    "react-native-safe-area-context": "~5.7.0",
-    "react-native-screens": "~4.25.2",
-    "react-native-svg": "15.15.4",
-    "react-native-worklets": "0.8.3"
-  },
-  "devDependencies": {
-    "@babel/core": "^7.29.0",
-    "@types/react": "~19.2.14",
-    "@types/react-refresh": "^0",
-    "babel-preset-expo": "~56.0.14",
-    "react-refresh": "^0.18.0"
-  },
-  "private": true
-}
diff --git a/apps/text-embeddings/tsconfig.json b/apps/text-embeddings/tsconfig.json
deleted file mode 100644
index bfe226172e..0000000000
--- a/apps/text-embeddings/tsconfig.json
+++ /dev/null
@@ -1,18 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "strict": true,
-    "allowJs": true,
-    "module": "preserve",
-    "moduleDetection": "force",
-    "moduleResolution": "bundler",
-    "customConditions": ["react-native"],
-    "noEmit": true,
-    "paths": {
-      "react-native-executorch": ["../../packages/react-native-executorch/src"],
-      "react-native-executorch-expo-resource-fetcher": [
-        "../../packages/expo-resource-fetcher/src"
-      ]
-    }
-  }
-}
diff --git a/apps/text-embeddings/utils/math.ts b/apps/text-embeddings/utils/math.ts
deleted file mode 100644
index 50c70d1f92..0000000000
--- a/apps/text-embeddings/utils/math.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import {
-  RnExecutorchError,
-  RnExecutorchErrorCode,
-} from 'react-native-executorch';
-
-export const dotProduct = (a: Float32Array, b: Float32Array) => {
-  if (a.length !== b.length) {
-    throw new RnExecutorchError(
-      RnExecutorchErrorCode.WrongDimensions,
-      `dotProduct needs both vector to have the same length: got a: ${a.length}, b: ${b.length}`
-    );
-  }
-
-  let sum = 0;
-  for (let i = 0; i < a.length; i++) {
-    sum += a[i] * b[i];
-  }
-  return sum;
-};
diff --git a/docs/docs/01-fundamentals/01-getting-started.md b/docs/docs/01-fundamentals/01-getting-started.md
deleted file mode 100644
index 2506c8cd65..0000000000
--- a/docs/docs/01-fundamentals/01-getting-started.md
+++ /dev/null
@@ -1,216 +0,0 @@
----
-title: Getting Started
-slug: /fundamentals/getting-started
-keywords:
-  [
-    react native,
-    react native ai,
-    react native llm,
-    react native qwen,
-    react native llama,
-    react native executorch,
-    executorch,
-    on-device ai,
-    pytorch,
-    mobile ai,
-  ]
-description: 'Get started with React Native ExecuTorch - a framework for running AI models on-device in your React Native applications.'
----
-
-import Tabs from '@theme/Tabs';
-import TabItem from '@theme/TabItem';
-
-## What is ExecuTorch?
-
-[ExecuTorch](https://executorch.ai) is a novel AI framework developed by Meta, designed to streamline deploying PyTorch models on a variety of devices, including mobile phones and microcontrollers. This framework enables exporting models into standalone binaries, allowing them to run locally without requiring API calls. ExecuTorch achieves state-of-the-art performance through optimizations and delegates such as Core ML and XNNPACK. It provides a seamless export process with robust debugging options, making it easier to resolve issues if they arise.
-
-## React Native ExecuTorch
-
-React Native ExecuTorch is our way of bringing ExecuTorch into the React Native world. Our API is built to be simple, declarative, and efficient. Additionally, we provide a set of pre-exported models for common use cases, so you don't have to worry about handling exports yourself. With just a few lines of JavaScript, you can run AI models (even LLMs 👀) right on your device—keeping user data private and saving on cloud costs.
-
-## Compatibility
-
-React Native Executorch supports only the [New React Native architecture](https://reactnative.dev/architecture/landing-page).
-
-If your app still runs on the old architecture, please consider upgrading to the New Architecture.
-
-For supported React Native and Expo versions, see the [Compatibility table](../07-other/01-compatibility.mdx).
-
-## Installation
-
-Installation takes two steps: install the core package, then install a resource fetcher adapter that matches your project type. If you want to implement your own model fetching logic instead, see [this document](../08-resource-fetcher/02-custom-adapter.md).
-
-### 1. Install the core package
-
-<Tabs groupId="package-manager">
-  <TabItem value="npm" label="npm">
-
-    ```bash
-    npm install react-native-executorch
-    ```
-
-  </TabItem>
-  <TabItem value="pnpm" label="pnpm">
-
-    ```bash
-    pnpm add react-native-executorch
-    ```
-
-  </TabItem>
-  <TabItem value="yarn" label="yarn">
-
-    ```bash
-    yarn add react-native-executorch
-    ```
-
-  </TabItem>
-</Tabs>
-
-### 2. Install a resource fetcher
-
-Pick the adapter that matches your project. We recommend the Expo adapter when your app uses Expo; use the bare adapter for projects without Expo.
-
-#### Expo projects
-
-<Tabs groupId="package-manager">
-  <TabItem value="npm" label="npm">
-
-    ```bash
-    npm install react-native-executorch-expo-resource-fetcher expo-file-system expo-asset
-    ```
-
-  </TabItem>
-  <TabItem value="pnpm" label="pnpm">
-
-    ```bash
-    pnpm add react-native-executorch-expo-resource-fetcher expo-file-system expo-asset
-    ```
-
-  </TabItem>
-  <TabItem value="yarn" label="yarn">
-
-    ```bash
-    yarn add react-native-executorch-expo-resource-fetcher expo-file-system expo-asset
-    ```
-
-  </TabItem>
-</Tabs>
-
-#### Bare React Native projects
-
-<Tabs groupId="package-manager">
-  <TabItem value="npm" label="npm">
-
-    ```bash
-    npm install react-native-executorch-bare-resource-fetcher @dr.pogodin/react-native-fs @kesha-antonov/react-native-background-downloader
-    ```
-
-  </TabItem>
-  <TabItem value="pnpm" label="pnpm">
-
-    ```bash
-    pnpm add react-native-executorch-bare-resource-fetcher @dr.pogodin/react-native-fs @kesha-antonov/react-native-background-downloader
-    ```
-
-  </TabItem>
-  <TabItem value="yarn" label="yarn">
-
-    ```bash
-    yarn add react-native-executorch-bare-resource-fetcher @dr.pogodin/react-native-fs @kesha-antonov/react-native-background-downloader
-    ```
-
-  </TabItem>
-</Tabs>
-
-:::warning
-Before using any other API, you must call `initExecutorch` with a resource fetcher adapter at the entry point of your app:
-
-```js
-import { initExecutorch } from 'react-native-executorch';
-import { ExpoResourceFetcher } from 'react-native-executorch-expo-resource-fetcher'; // Use /legacy import if you're using Expo SDK < 54
-// or BareResourceFetcher for bare react-native projects
-
-initExecutorch({ resourceFetcher: ExpoResourceFetcher });
-```
-
-Calling any library API without initializing first will throw a `ResourceFetcherAdapterNotInitialized` error.
-:::
-
-Our library offers support for both bare React Native and Expo projects. Please follow the instructions from [Loading models section](./02-loading-models.md) to make sure you setup your project correctly. We encourage you to use Expo project if possible. If you are planning to migrate from bare React Native to Expo project, the link (https://docs.expo.dev/bare/installing-expo-modules/) offers a guidance on setting up Expo Modules in a bare React Native environment.
-
-If you plan on using your models via require() instead of fetching them from a url, you also need to add following lines to your `metro.config.js`:
-
-```json
-// metro.config.js
-...
-    defaultConfig.resolver.assetExts.push('pte')
-    defaultConfig.resolver.assetExts.push('bin')
-...
-```
-
-This allows us to use binaries, such as exported models or tokenizers for LLMs.
-
-:::warning
-When using Expo, please note that you need to use a custom development build of your app, not the standard Expo Go app. This is because we rely on native modules, which Expo Go doesn’t support.
-:::
-
-:::info
-Because we are using ExecuTorch under the hood, you won't be able to build iOS app for release with simulator selected as the target device. Make sure to test release builds on real devices.
-:::
-
-Running the app with the library:
-
-<Tabs groupId="package-manager">
-  <TabItem value="npm" label="npm">
-
-    ```bash
-    npm run <ios|android> -- -d
-    ```
-
-  </TabItem>
-  <TabItem value="pnpm" label="pnpm">
-
-    ```bash
-    pnpm <ios|android> -d
-    ```
-
-  </TabItem>
-  <TabItem value="yarn" label="yarn">
-
-    ```bash
-    yarn <ios|android> -d
-    ```
-
-  </TabItem>
-</Tabs>
-
-## Building from source
-
-To build the library from source instead, clone the repository and initialize submodules:
-
-```bash
-git clone -b release/0.9 https://github.com/software-mansion/react-native-executorch.git
-cd react-native-executorch
-
-git submodule update --init --recursive packages/react-native-executorch/third-party/common
-
-yarn
-```
-
-## Supporting new models in React Native ExecuTorch
-
-Adding new functionality to the library follows a consistent three-step integration pipeline:
-
-1. **Model Serialization:** Export PyTorch model for a specific task (e.g. object detection) into the `*.pte` format, which is optimized for the ExecuTorch runtime.
-
-2. **Native Implementation:** Develop a C++ execution layer that interfaces with the ExecuTorch runtime to handle inference. This layer also manages model-dependent logic, such as data pre-processing and post-processing.
-
-3. **TS Bindings:** Finally, implement a TypeScript API that bridges the JavaScript environment to the native C++ logic, providing a clean, typed interface for the end user.
-
-## Good reads
-
-If you want to dive deeper into ExecuTorch or our previous work with the framework, we highly encourage you to check out the following resources:
-
-- [ExecuTorch docs](https://pytorch.org/executorch/stable/index.html)
-- [React Native RAG](https://blog.swmansion.com/introducing-react-native-rag-fbb62efa4991)
-- [Offline Text Recognition on Mobile: How We Brought EasyOCR to React Native ExecuTorch](https://blog.swmansion.com/bringing-easyocr-to-react-native-executorch-2401c09c2d0c)
diff --git a/docs/docs/01-fundamentals/02-loading-models.md b/docs/docs/01-fundamentals/02-loading-models.md
deleted file mode 100644
index f80a484104..0000000000
--- a/docs/docs/01-fundamentals/02-loading-models.md
+++ /dev/null
@@ -1,133 +0,0 @@
----
-title: Loading Models
----
-
-import Tabs from '@theme/Tabs';
-import TabItem from '@theme/TabItem';
-
-There are three different methods available for loading model files, depending on their size and location.
-
-## Prerequisites
-
-In our library, you can use two different resource fetching mechanisms. One is implemented using Expo FileSystem, the other one uses external library. We encourage you to use implementation utilizing Expo if possible.
-
-To use the Expo adapter, please add these libraries:
-
-<Tabs groupId="package-manager">
-  <TabItem value="npm" label="npm">
-
-    ```bash
-    npm install react-native-executorch-expo-resource-fetcher expo-file-system expo-asset
-    ```
-
-  </TabItem>
-  <TabItem value="pnpm" label="pnpm">
-
-    ```bash
-    pnpm add react-native-executorch-expo-resource-fetcher expo-file-system expo-asset
-    ```
-
-  </TabItem>
-  <TabItem value="yarn" label="yarn">
-
-    ```bash
-    yarn add react-native-executorch-expo-resource-fetcher expo-file-system expo-asset
-    ```
-
-  </TabItem>
-</Tabs>
-
-and then add the following code in your React Native app:
-
-```typescript
-import { initExecutorch } from 'react-native-executorch';
-import { ExpoResourceFetcher } from 'react-native-executorch-expo-resource-fetcher'; // Use /legacy import if you're using Expo SDK < 54
-
-initExecutorch({
-  resourceFetcher: ExpoResourceFetcher,
-});
-```
-
-If you cannot use Expo in your project, proceed with the following steps:
-
-<Tabs groupId="package-manager">
-  <TabItem value="npm" label="npm">
-
-    ```bash
-    npm install react-native-executorch-bare-resource-fetcher @dr.pogodin/react-native-fs @kesha-antonov/react-native-background-downloader
-    ```
-
-  </TabItem>
-  <TabItem value="pnpm" label="pnpm">
-
-    ```bash
-    pnpm add react-native-executorch-bare-resource-fetcher @dr.pogodin/react-native-fs @kesha-antonov/react-native-background-downloader
-    ```
-
-  </TabItem>
-  <TabItem value="yarn" label="yarn">
-
-    ```bash
-    yarn add react-native-executorch-bare-resource-fetcher @dr.pogodin/react-native-fs @kesha-antonov/react-native-background-downloader
-    ```
-
-  </TabItem>
-</Tabs>
-
-and
-
-```typescript
-import { initExecutorch } from 'react-native-executorch';
-import { BareResourceFetcher } from 'react-native-executorch-bare-resource-fetcher';
-
-initExecutorch({
-  resourceFetcher: BareResourceFetcher,
-});
-```
-
-## Loading
-
-### Load from React Native assets folder (for files < 512MB)
-
-```typescript
-useExecutorchModule({
-  modelSource: require('../assets/lfm2_5.pte'),
-});
-```
-
-### Load from remote URL
-
-For files larger than 512MB or when you want to keep size of the app smaller, you can load the model from a remote URL (e.g. HuggingFace).
-
-```typescript
-useExecutorchModule({
-  modelSource: 'https://.../lfm2_5.pte',
-});
-```
-
-### Load from local file system
-
-If you prefer to delegate the process of obtaining and loading model and tokenizer files to the user, you can use the following method:
-
-```typescript
-useExecutorchModule({
-  modelSource: 'file:///var/mobile/.../lfm2_5.pte',
-});
-```
-
-:::note
-The downloaded files are stored in documents directory of your application.
-:::
-
-## Predefined Models
-
-Our library offers out-of-the-box support for multiple models. To make things easier, we created aliases for our model exported to `pte` format. For full list of aliases, check out: [API Reference](../06-api-reference/index.md#models---classification)
-
-## Example
-
-The following code snippet demonstrates how to load model and tokenizer files using `useLLM` hook:
-
-```typescript
-import { models, useLLM } from 'react-native-executorch';
-const llm = useLLM({ model: models.llm.lfm2_5_1_2b_instruct() });
-```
diff --git a/docs/docs/01-fundamentals/03-frequently-asked-questions.md b/docs/docs/01-fundamentals/03-frequently-asked-questions.md
deleted file mode 100644
index 69e3792d41..0000000000
--- a/docs/docs/01-fundamentals/03-frequently-asked-questions.md
+++ /dev/null
@@ -1,50 +0,0 @@
----
-title: Frequently Asked Questions
----
-
-This section is meant to answer some common community inquiries, especially regarding the ExecuTorch runtime or adding your own models. If you can't see an answer to your question, feel free to open up a [discussion](https://github.com/software-mansion/react-native-executorch/discussions/new/choose).
-
-### What models are supported?
-
-Each hook documentation subpage (useClassification, useLLM, etc.) contains a supported models section, which lists the models that are runnable within the library with close to no setup. For running your custom models, refer to `ExecuTorchModule` or `useExecuTorchModule`.
-
-### How can I run my own AI model?
-
-To run your own model, you need to directly access the underlying [ExecuTorch Module API](https://pytorch.org/executorch/stable/extension-module.html). We provide [React hook](../03-hooks/03-executorch-bindings/useExecutorchModule.md) along with a [TypeScript alternative](../04-typescript-api/03-executorch-bindings/ExecutorchModule.md), which serve as a way to use the aforementioned API without the need of diving into native code. In order to get a model in a format runnable by the runtime, you'll need to get your hands dirty with some ExecuTorch knowledge. For more guides on exporting models, please refer to the [ExecuTorch tutorials](https://pytorch.org/executorch/stable/tutorials/export-to-executorch-tutorial.html). Once you obtain your model in a `.pte` format, you can run it with `useExecuTorchModule` and `ExecuTorchModule`.
-
-### How React Native ExecuTorch works under the hood?
-
-The general workflow for each functionality in our library goes like this:
-
-- You call a functionality from TypeScript
-- TypeScript calls C++ function like model inference or data processing via JSI
-- C++ returns result to TypeScript back via JSI
-- You get results in TypeScript
-
-Using JSI enables us using **zero-copy data transfer** and **fast, low-level C++**.
-
-### Can you do function calling with useLLM?
-
-If your model supports tool calling (i.e. its chat template can process tools) you can use the method explained on the [useLLM page](../03-hooks/01-natural-language-processing/useLLM.md).
-
-If your model doesn't support it, you can still work around it using context. For details, refer to [this comment](https://github.com/software-mansion/react-native-executorch/issues/173#issuecomment-2775082278).
-
-### Can I use React Native ExecuTorch in bare React Native apps?
-
-Yes, staring from version `0.8.x` you can use React Native ExecuTorch in bare React Native apps. You just need to use bare React Native resource fetcher instead of Expo one, see: [Loading models section](./02-loading-models.md) for more details.
-
-### Do you support the old architecture?
-
-The old architecture is not supported and we're currently not planning to add support.
-
-### Can I run GGUF models using the library?
-
-No, as of now ExecuTorch runtime doesn't provide a reliable way to use GGUF models, hence it is not possible.
-
-### Are the models leveraging GPU acceleration?
-
-While it is possible to run some models using Core ML on iOS, which is a backend that utilizes CPU, GPU and ANE, we currently don't have many models exported to Core ML. For Android, the current state of GPU acceleration is pretty limited. As of now, there are attempts of running the models using a Vulkan backend. However the operator support is very limited meaning that the resulting performance is often inferior to XNNPACK. Hence, most of the models use XNNPACK, which is a highly optimized and mature CPU backend that runs on both Android and iOS.
-
-### Does this library support XNNPACK and Core ML?
-
-Yes, all of the backends are linked, therefore the only thing that needs to be done on your end is to export the model with the backend that you're interested in using.
diff --git a/docs/docs/01-fundamentals/04-glossary-of-terms.md b/docs/docs/01-fundamentals/04-glossary-of-terms.md
deleted file mode 100644
index 40d7e049e7..0000000000
--- a/docs/docs/01-fundamentals/04-glossary-of-terms.md
+++ /dev/null
@@ -1,59 +0,0 @@
-# Glossary of Terms
-
-This glossary defines key concepts used throughout the React Native ExecuTorch ecosystem, covering high-level machine learning terms and library-specific components.
-
-## Backend
-
-The execution engine responsible for running the actual computations of a model on specific hardware.
-
-- **XNNPACK:** A highly optimized library for floating-point neural network inference on ARM, x86, and WebAssembly. It is the default CPU backend for ExecuTorch.
-
-- **Core ML:** Apple's framework for optimizing and running machine learning models on iOS, macOS, and iPadOS devices. Using the Core ML backend allows ExecuTorch to delegate operations to the Apple Neural Engine (ANE) for significantly faster and more energy-efficient inference.
-
-## Forward Function
-
-The primary method of a PyTorch module (usually `forward()`) that defines the computation performed at every call. In the context of ExecuTorch, this is the logic that gets exported and compiled. When you run inference in React Native, you are essentially invoking this compiled forward function with new inputs.
-
-## Inference
-
-The process of using a trained machine learning model to make predictions or generate outputs for given input data.
-
-## Out-of-the-Box Support
-
-Refers to features, models, or architectures that work immediately with React Native ExecuTorch without requiring custom compilation, manual kernel registration, or complex configuration. For example, standard Llama architectures have out-of-the-box support, meaning you can download the `.pte` file and run it instantly.
-
-## Prefill
-
-The initial phase of generating text with an LLM (Large Language Model) where the model processes the entire input prompt (context) at once.
-
-- **Why it matters:** This step is computationally intensive because the model must "understand" all provided tokens simultaneously.
-
-- **Performance Metric:** "Time to First Token" (TTFT) usually measures the speed of the prefill phase.
-
-## Quantization
-
-A technique to reduce the size of a model and speed up inference by representing weights and activations with lower-precision data types (e.g., converting 32-bit floating-point numbers to 8-bit integers).
-
-- **Benefits:** Drastically lowers memory usage (RAM) and saves battery life on mobile devices.
-
-- **Trade-off:** Slight reduction in model accuracy, though often negligible for deployment.
-
-## Tensor
-
-The fundamental data structure in PyTorch and ExecuTorch. A tensor is a multi-dimensional array (like a matrix) that holds the inputs, weights, and outputs of a model.
-
-- **Example:** An image might be represented as a tensor of shape `[3, 224, 224]` (3 color channels, 224 pixels high, 224 pixels wide).
-
-## Token
-
-The basic unit of text that an LLM reads and generates. A token can be a word, part of a word, or even a single character.
-
-- **Rule of thumb:** 1,000 tokens is roughly equivalent to 750 words in English.
-
-- **Context:** Models have a "Context Window" limit (e.g., 2048 tokens), which is the maximum number of tokens they can remember from the conversation history.
-
-## Tokenization
-
-The process of converting raw text (strings) into a sequence of numerical IDs (tokens) that the model can understand.
-
-- **TokenizerModule (Component):** In React Native ExecuTorch, the `Tokenizer` is a utility class that handles encoding text into tensors and decoding output tensors back into readable text strings.
diff --git a/docs/docs/01-fundamentals/_category_.json b/docs/docs/01-fundamentals/_category_.json
deleted file mode 100644
index e3fddcbebd..0000000000
--- a/docs/docs/01-fundamentals/_category_.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "label": "Fundamentals",
-  "link": {
-    "type": "generated-index"
-  }
-}
diff --git a/docs/docs/02-benchmarks/_category_.json b/docs/docs/02-benchmarks/_category_.json
deleted file mode 100644
index 6ea5e9670a..0000000000
--- a/docs/docs/02-benchmarks/_category_.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "label": "Benchmarks",
-  "link": {
-    "type": "generated-index"
-  }
-}
diff --git a/docs/docs/02-benchmarks/inference-time.md b/docs/docs/02-benchmarks/inference-time.md
deleted file mode 100644
index 24923bffde..0000000000
--- a/docs/docs/02-benchmarks/inference-time.md
+++ /dev/null
@@ -1,255 +0,0 @@
----
-title: Inference Time
----
-
-:::info
-Times presented in the tables are measured as consecutive runs of the model.
-Initial run times may be up to 2x longer due to model loading and
-initialization.
-
-Inference times are measured directly from native C++ code, wrapping only the
-model's forward pass, excluding input-dependent pre- and post-processing (e.g.
-image resizing, normalization) and any overhead from React Native runtime.
-:::
-
-## Classification
-
-:::note
-For this model all input images, whether larger or smaller, are resized before
-processing. Resizing is typically fast for small images but may be noticeably
-slower for very large images, which can increase total time.
-:::
-
-| Model / Device                   | iPhone 17 Pro [ms] | Google Pixel 10 [ms] |
-| :------------------------------- | :----------------: | :------------------: |
-| EFFICIENTNET_V2_S (XNNPACK FP32) |         70         |         100          |
-| EFFICIENTNET_V2_S (XNNPACK INT8) |         22         |          38          |
-| EFFICIENTNET_V2_S (Core ML FP32) |         12         |          -           |
-| EFFICIENTNET_V2_S (Core ML FP16) |         5          |          -           |
-
-## Object Detection
-
-:::note
-For this model all input images, whether larger or smaller, are resized before
-processing. Resizing is typically fast for small images but may be noticeably
-slower for very large images, which can increase total time.
-
-Times presented in the tables are measured for YOLO models with input size equal to 512. Other input sizes may yield slower or faster inference times. RF-DETR Nano uses a fixed resolution of 312×312.
-:::
-
-| Model / Device                                | iPhone 17 Pro [ms] | Google Pixel 10 [ms] |
-| :-------------------------------------------- | :----------------: | :------------------: |
-| SSDLITE_320_MOBILENET_V3_LARGE (XNNPACK FP32) |         20         |          18          |
-| SSDLITE_320_MOBILENET_V3_LARGE (Core ML FP32) |         18         |          -           |
-| SSDLITE_320_MOBILENET_V3_LARGE (Core ML FP16) |         8          |          -           |
-| RF_DETR_NANO (XNNPACK FP32)                   |        101         |         277          |
-| YOLO26N (XNNPACK FP32)                        |         29         |          38          |
-| YOLO26S (XNNPACK FP32)                        |         60         |          72          |
-| YOLO26M (XNNPACK FP32)                        |        134         |         177          |
-| YOLO26L (XNNPACK FP32)                        |        169         |         216          |
-| YOLO26X (XNNPACK FP32)                        |        371         |         434          |
-
-## Style Transfer
-
-:::note
-For this model all input images, whether larger or smaller, are resized before
-processing. Resizing is typically fast for small images but may be noticeably
-slower for very large images, which can increase total time.
-:::
-
-| Model / Device                              | iPhone 17 Pro [ms] | Google Pixel 10 [ms] |
-| :------------------------------------------ | :----------------: | :------------------: |
-| STYLE_TRANSFER_CANDY (XNNPACK FP32)         |        1192        |         1025         |
-| STYLE_TRANSFER_CANDY (XNNPACK INT8)         |        272         |         430          |
-| STYLE_TRANSFER_CANDY (Core ML FP32)         |        100         |          -           |
-| STYLE_TRANSFER_CANDY (Core ML FP16)         |        150         |          -           |
-| STYLE_TRANSFER_MOSAIC (XNNPACK FP32)        |        1192        |         1025         |
-| STYLE_TRANSFER_MOSAIC (XNNPACK INT8)        |        272         |         430          |
-| STYLE_TRANSFER_MOSAIC (Core ML FP32)        |        100         |          -           |
-| STYLE_TRANSFER_MOSAIC (Core ML FP16)        |        150         |          -           |
-| STYLE_TRANSFER_UDNIE (XNNPACK FP32)         |        1192        |         1025         |
-| STYLE_TRANSFER_UDNIE (XNNPACK INT8)         |        272         |         430          |
-| STYLE_TRANSFER_UDNIE (Core ML FP32)         |        100         |          -           |
-| STYLE_TRANSFER_UDNIE (Core ML FP16)         |        150         |          -           |
-| STYLE_TRANSFER_RAIN_PRINCESS (XNNPACK FP32) |        1192        |         1025         |
-| STYLE_TRANSFER_RAIN_PRINCESS (XNNPACK INT8) |        272         |         430          |
-| STYLE_TRANSFER_RAIN_PRINCESS (Core ML FP32) |        100         |          -           |
-| STYLE_TRANSFER_RAIN_PRINCESS (Core ML FP16) |        150         |          -           |
-
-## OCR
-
-Notice that the recognizer models were executed between 3 and 7 times during a single recognition.
-The values below represent the averages across all runs for the benchmark image.
-
-| Model                           | iPhone 17 Pro [ms] | iPhone 16 Pro [ms] | iPhone SE 3 | Samsung Galaxy S24 [ms] | OnePlus 12 [ms] |
-| ------------------------------- | ------------------ | ------------------ | ----------- | ----------------------- | --------------- |
-| **Total Inference Time**        | 652                | 600                | 2855        | 1092                    | 1034            |
-| Detector (CRAFT) `forward_800`  | 220                | 221                | 1740        | 521                     | 492             |
-| Recognizer (CRNN) `forward_512` | 45                 | 38                 | 110         | 40                      | 38              |
-| Recognizer (CRNN) `forward_256` | 21                 | 18                 | 54          | 20                      | 19              |
-| Recognizer (CRNN) `forward_128` | 11                 | 9                  | 27          | 10                      | 10              |
-
-## Vertical OCR
-
-:::note
-Recognizer models, as well as detector's `forward_320` method, were executed between 4 and 21 times during a single recognition.
-:::
-The values below represent the averages across all runs for the benchmark image.
-
-| Model                           | iPhone 17 Pro <br /> [ms] | iPhone 16 Pro <br /> [ms] | iPhone SE 3 | Samsung Galaxy S24 <br /> [ms] | OnePlus 12 <br /> [ms] |
-| ------------------------------- | ------------------------- | ------------------------- | ----------- | ------------------------------ | ---------------------- |
-| **Total Inference Time**        | 1104                      | 1113                      | 8840        | 2845                           | 2640                   |
-| Detector (CRAFT) `forward_1280` | 501                       | 507                       | 4317        | 1405                           | 1275                   |
-| Detector (CRAFT) `forward_320`  | 125                       | 121                       | 1060        | 338                            | 299                    |
-| Recognizer (CRNN) `forward_512` | 46                        | 42                        | 109         | 47                             | 37                     |
-| Recognizer (CRNN) `forward_64`  | 5                         | 6                         | 14          | 7                              | 6                      |
-
-## LLMs
-
-| Model                          | Google Pixel 10 (XNNPACK) [tokens/s] | iPhone 17 Pro (XNNPACK) [tokens/s] | OnePlus 12 (XNNPACK) [tokens/s] | iPhone SE 3 (XNNPACK) [tokens/s] |
-| ------------------------------ | :----------------------------------: | :--------------------------------: | :-----------------------------: | :------------------------------: |
-| LLAMA3_2_1B                    |                  8                   |                 8                  |               15                |               N/A                |
-| LLAMA3_2_1B_QLORA              |                  22                  |                 22                 |               45                |                19                |
-| LLAMA3_2_1B_SPINQUANT          |                  24                  |                 36                 |               48                |                17                |
-| LLAMA3_2_3B                    |                  2                   |                 3                  |                6                |               N/A                |
-| LLAMA3_2_3B_QLORA              |                  8                   |                 7                  |               17                |               N/A                |
-| LLAMA3_2_3B_SPINQUANT          |                  11                  |                 12                 |               18                |               N/A                |
-| QWEN3_0_6B                     |                  7                   |                 9                  |               15                |                9                 |
-| QWEN3_0_6B_QUANTIZED           |                  20                  |                 27                 |               37                |                35                |
-| QWEN3_1_7B                     |                  3                   |                 5                  |                8                |               N/A                |
-| QWEN3_1_7B_QUANTIZED           |                  10                  |                 14                 |               20                |                13                |
-| QWEN3_4B                       |                  2                   |                N/A                 |                4                |               N/A                |
-| QWEN3_4B_QUANTIZED             |                  5                   |                 7                  |               10                |               N/A                |
-| HAMMER2_1_0_5B                 |                  13                  |                 13                 |               25                |                16                |
-| HAMMER2_1_0_5B_QUANTIZED       |                  34                  |                 97                 |               72                |                56                |
-| HAMMER2_1_1_5B                 |                  5                   |                 5                  |               10                |               N/A                |
-| HAMMER2_1_1_5B_QUANTIZED       |                  14                  |                 16                 |               36                |                22                |
-| HAMMER2_1_3B                   |                  2                   |                 3                  |                5                |               N/A                |
-| HAMMER2_1_3B_QUANTIZED         |                  9                   |                 10                 |               20                |               N/A                |
-| SMOLLM2_1_135M                 |                  25                  |                 24                 |               33                |                42                |
-| SMOLLM2_1_135M_QUANTIZED       |                  20                  |                 32                 |               64                |                47                |
-| SMOLLM2_1_360M                 |                  12                  |                 13                 |               20                |                15                |
-| SMOLLM2_1_360M_QUANTIZED       |                  12                  |                 15                 |               29                |                18                |
-| SMOLLM2_1_1_7B                 |                  3                   |                 5                  |                7                |               N/A                |
-| SMOLLM2_1_1_7B_QUANTIZED       |                  12                  |                 14                 |               27                |                23                |
-| QWEN2_5_0_5B                   |                  12                  |                 12                 |               21                |                15                |
-| QWEN2_5_0_5B_QUANTIZED         |                  33                  |                 31                 |               55                |                48                |
-| QWEN2_5_1_5B                   |                  5                   |                 5                  |                9                |               N/A                |
-| QWEN2_5_1_5B_QUANTIZED         |                  15                  |                 15                 |               28                |                16                |
-| QWEN2_5_3B                     |                  2                   |                 3                  |                5                |               N/A                |
-| QWEN2_5_3B_QUANTIZED           |                  9                   |                 10                 |               18                |               N/A                |
-| PHI_4_MINI_4B                  |                  2                   |                 3                  |                4                |               N/A                |
-| PHI_4_MINI_4B_QUANTIZED        |                  4                   |                 7                  |               10                |               N/A                |
-| LFM2_5_350M                    |                  16                  |                 26                 |               34                |                21                |
-| LFM2_5_350M_QUANTIZED          |                  58                  |                 67                 |               103               |                51                |
-| LFM2_5_1_2B_INSTRUCT           |                  6                   |                 10                 |               13                |               N/A                |
-| LFM2_5_1_2B_INSTRUCT_QUANTIZED |                  8                   |                 26                 |               47                |                24                |
-
-❌ - Insufficient RAM.
-
-## Speech to Text
-
-### Encoding
-
-Average time for encoding audio of given length over 10 runs. For `Whisper` model we only list 30 sec audio chunks since `Whisper` does not accept other lengths (for shorter audio the audio needs to be padded to 30sec with silence).
-
-| Model              | iPhone 17 Pro (XNNPACK) [ms] | iPhone 16 Pro (XNNPACK) [ms] | iPhone SE 3 (XNNPACK) [ms] | Samsung Galaxy S24 (XNNPACK) [ms] | OnePlus 12 (XNNPACK) [ms] |
-| ------------------ | :--------------------------: | :--------------------------: | :------------------------: | :-------------------------------: | :-----------------------: |
-| Whisper-tiny (30s) |              89              |              93              |            403             |                277                |            260            |
-
-### Decoding
-
-Average time for decoding one token in sequence of approximately 100 tokens, with encoding context is obtained from audio of noted length.
-
-| Model              | iPhone 17 Pro (XNNPACK) [ms] | iPhone 16 Pro (XNNPACK) [ms] | iPhone SE 3 (XNNPACK) [ms] | Samsung Galaxy S24 (XNNPACK) [ms] | OnePlus 12 (XNNPACK) [ms] |
-| ------------------ | :--------------------------: | :--------------------------: | :------------------------: | :-------------------------------: | :-----------------------: |
-| Whisper-tiny (30s) |              6               |              6               |             40             |                28                 |            25             |
-
-## Text to Speech
-
-Average time to synthesize speech from an input text of approximately 60 tokens, resulting in 2 to 5 seconds of audio depending on the input and selected voice.
-
-| Model         | iPhone 17 Pro (XNNPACK) [ms] | OnePlus 12 (XNNPACK) [ms] |
-| ------------- | :--------------------------: | :-----------------------: |
-| Kokoro-small  |             2051             |           1548            |
-| Kokoro-medium |             2124             |           1625            |
-
-## Text Embeddings
-
-:::note
-Benchmark times for text embeddings are highly dependent on the sentence length. The numbers below are based on a sentence of around 80 tokens. For shorter or longer sentences, inference time may vary accordingly.
-:::
-
-| Model / Device                                        | iPhone 17 Pro [ms] | OnePlus 12 [ms] |
-| ----------------------------------------------------- | :----------------: | :-------------: |
-| ALL_MINILM_L6_V2 (XNNPACK)                            |         7          |       21        |
-| ALL_MPNET_BASE_V2 (XNNPACK)                           |         24         |       90        |
-| MULTI_QA_MINILM_L6_COS_V1 (XNNPACK)                   |         7          |       19        |
-| MULTI_QA_MPNET_BASE_DOT_V1 (XNNPACK)                  |         24         |       88        |
-| CLIP_VIT_BASE_PATCH32_TEXT (XNNPACK)                  |         14         |       39        |
-| DISTILUSE_BASE_MULTILINGUAL_CASED_V2 (XNNPACK 8da4w)  |         16         |       15        |
-| DISTILUSE_BASE_MULTILINGUAL_CASED_V2 (Core ML FP32)   |         15         |        -        |
-| PARAPHRASE_MULTILINGUAL_MINILM_L12_V2 (XNNPACK 8da4w) |         14         |       15        |
-
-## Image Embeddings
-
-:::note
-For this model all input images, whether larger or smaller, are resized before
-processing. Resizing is typically fast for small images but may be noticeably
-slower for very large images, which can increase total time.
-:::
-
-| Model / Device                             | iPhone 17 Pro [ms] | Google Pixel 10 [ms] |
-| :----------------------------------------- | :----------------: | :------------------: |
-| CLIP_VIT_BASE_PATCH32_IMAGE (XNNPACK FP32) |         14         |          68          |
-| CLIP_VIT_BASE_PATCH32_IMAGE (XNNPACK INT8) |         11         |          31          |
-
-## Semantic Segmentation
-
-:::note
-For this model all input images, whether larger or smaller, are resized before
-processing. Resizing is typically fast for small images but may be noticeably
-slower for very large images, which can increase total time.
-:::
-
-| Model / Device                               | iPhone 17 Pro [ms] | Google Pixel 10 [ms] |
-| :------------------------------------------- | :----------------: | :------------------: |
-| DEEPLAB_V3_RESNET50 (XNNPACK FP32)           |        2000        |         2200         |
-| DEEPLAB_V3_RESNET50 (XNNPACK INT8)           |        118         |         380          |
-| DEEPLAB_V3_RESNET101 (XNNPACK FP32)          |        2900        |         3300         |
-| DEEPLAB_V3_RESNET101 (XNNPACK INT8)          |        174         |         660          |
-| DEEPLAB_V3_MOBILENET_V3_LARGE (XNNPACK FP32) |        131         |         153          |
-| DEEPLAB_V3_MOBILENET_V3_LARGE (XNNPACK INT8) |         17         |          40          |
-| LRASPP_MOBILENET_V3_LARGE (XNNPACK FP32)     |         13         |          36          |
-| LRASPP_MOBILENET_V3_LARGE (XNNPACK INT8)     |         12         |          20          |
-| FCN_RESNET50 (XNNPACK FP32)                  |        1800        |         2160         |
-| FCN_RESNET50 (XNNPACK INT8)                  |        100         |         320          |
-| FCN_RESNET101 (XNNPACK FP32)                 |        2600        |         3160         |
-| FCN_RESNET101 (XNNPACK INT8)                 |        160         |         620          |
-
-## Instance Segmentation
-
-:::note
-Times presented in the tables are measured for YOLO models with input size equal
-to 512. Other input sizes may yield slower or faster inference times. RF-DETR
-Nano Seg uses a fixed resolution of 312×312.
-:::
-
-| Model                      | Samsung Galaxy S24 [ms] | Iphone 17 pro [ms] | Pixel 10 [ms] |
-| :------------------------- | :---------------------: | :----------------: | :-----------: |
-| YOLO26N_SEG (XNNPACK)      |           92            |         90         |      93       |
-| YOLO26S_SEG (XNNPACK)      |           220           |        188         |      193      |
-| YOLO26M_SEG (XNNPACK)      |           570           |        550         |      481      |
-| YOLO26L_SEG (XNNPACK)      |           680           |        608         |      582      |
-| YOLO26X_SEG (XNNPACK)      |          1410           |        1338        |     1191      |
-| RF_DETR_NANO_SEG (XNNPACK) |           549           |        330         |      428      |
-| FASTSAM_S (XNNPACK)        |           184           |         30         |      286      |
-| FASTSAM_X (XNNPACK)        |          1886           |        2520        |     1993      |
-| FASTSAM_S (Core ML)        |            -            |         51         |       -       |
-| FASTSAM_X (Core ML)        |            -            |         72         |       -       |
-
-## Text to image
-
-| Model                 | iPhone 17 Pro (XNNPACK) [ms] | iPhone 16 Pro (XNNPACK) [ms] | iPhone SE 3 (XNNPACK) [ms] | Samsung Galaxy S24 (XNNPACK) [ms] | OnePlus 12 (XNNPACK) [ms] |
-| --------------------- | :--------------------------: | :--------------------------: | :------------------------: | :-------------------------------: | :-----------------------: |
-| BK_SDM_TINY_VPRED_256 |            21184             |            21021             |             ❌             |               18834               |           16617           |
diff --git a/docs/docs/02-benchmarks/memory-usage.md b/docs/docs/02-benchmarks/memory-usage.md
deleted file mode 100644
index c685955061..0000000000
--- a/docs/docs/02-benchmarks/memory-usage.md
+++ /dev/null
@@ -1,154 +0,0 @@
----
-title: Memory Usage
----
-
-:::info
-Memory usage values represent the peak memory increase observed while the model was
-loaded and actively running inference, relative to the baseline app memory
-before model initialization.
-:::
-
-## Classification
-
-| Model / Device                   | iPhone 17 Pro [MB] | Google Pixel 10 [MB] |
-| -------------------------------- | :----------------: | :------------------: |
-| EFFICIENTNET_V2_S (XNNPACK FP32) |        101         |         122          |
-| EFFICIENTNET_V2_S (XNNPACK INT8) |         62         |          78          |
-| EFFICIENTNET_V2_S (Core ML FP32) |        101         |          -           |
-| EFFICIENTNET_V2_S (Core ML FP16) |         87         |          -           |
-
-## Object Detection
-
-:::note
-Data presented for YOLO models is based on inference with `forward_640` method.
-:::
-
-| Model / Device                                | iPhone 17 Pro [MB] | Google Pixel 10 [MB] |
-| --------------------------------------------- | :----------------: | :------------------: |
-| SSDLITE_320_MOBILENET_V3_LARGE (XNNPACK FP32) |         94         |         104          |
-| SSDLITE_320_MOBILENET_V3_LARGE (Core ML FP32) |         83         |          -           |
-| SSDLITE_320_MOBILENET_V3_LARGE (Core ML FP16) |         62         |          -           |
-| RF_DETR_NANO (XNNPACK FP32)                   |        145         |         162          |
-| YOLO26N (XNNPACK FP32)                        |         36         |          44          |
-| YOLO26S (XNNPACK FP32)                        |         81         |          82          |
-| YOLO26M (XNNPACK FP32)                        |        123         |         158          |
-| YOLO26L (XNNPACK FP32)                        |        170         |         172          |
-| YOLO26X (XNNPACK FP32)                        |        320         |         309          |
-
-## Style Transfer
-
-| Model / Device                              | iPhone 17 Pro [MB] | Google Pixel 10 [MB] |
-| ------------------------------------------- | :----------------: | :------------------: |
-| STYLE_TRANSFER_CANDY (XNNPACK FP32)         |        1200        |         1200         |
-| STYLE_TRANSFER_CANDY (XNNPACK INT8)         |        800         |         800          |
-| STYLE_TRANSFER_CANDY (Core ML FP32)         |        400         |          -           |
-| STYLE_TRANSFER_CANDY (Core ML FP16)         |        380         |          -           |
-| STYLE_TRANSFER_MOSAIC (XNNPACK FP32)        |        1200        |         1200         |
-| STYLE_TRANSFER_MOSAIC (XNNPACK INT8)        |        800         |         800          |
-| STYLE_TRANSFER_MOSAIC (Core ML FP32)        |        400         |          -           |
-| STYLE_TRANSFER_MOSAIC (Core ML FP16)        |        380         |          -           |
-| STYLE_TRANSFER_UDNIE (XNNPACK FP32)         |        1200        |         1200         |
-| STYLE_TRANSFER_UDNIE (XNNPACK INT8)         |        800         |         800          |
-| STYLE_TRANSFER_UDNIE (Core ML FP32)         |        400         |          -           |
-| STYLE_TRANSFER_UDNIE (Core ML FP16)         |        380         |          -           |
-| STYLE_TRANSFER_RAIN_PRINCESS (XNNPACK FP32) |        1200        |         1200         |
-| STYLE_TRANSFER_RAIN_PRINCESS (XNNPACK INT8) |        800         |         800          |
-| STYLE_TRANSFER_RAIN_PRINCESS (Core ML FP32) |        400         |          -           |
-| STYLE_TRANSFER_RAIN_PRINCESS (Core ML FP16) |        380         |          -           |
-
-## OCR
-
-| Model / Device                                      | iPhone 17 Pro [MB] | OnePlus 12 [MB] |
-| --------------------------------------------------- | :----------------: | :-------------: |
-| Detector (CRAFT) + Recognizer (CRNN) (XNNPACK FP32) |        1320        |      1400       |
-
-## Vertical OCR
-
-| Model / Device                                      | iPhone 17 Pro [MB] | OnePlus 12 [MB] |
-| --------------------------------------------------- | :----------------: | :-------------: |
-| Detector (CRAFT) + Recognizer (CRNN) (XNNPACK FP32) |     1000-1500      |    1000-1600    |
-
-## LLMs
-
-| Model / Device                  | iPhone 17 Pro [GB] | OnePlus 12 [GB] |
-| ------------------------------- | :----------------: | :-------------: |
-| LLAMA3_2_1B (XNNPACK)           |        3.1         |       3.3       |
-| LLAMA3_2_1B_SPINQUANT (XNNPACK) |        2.4         |       1.9       |
-| LLAMA3_2_1B_QLORA (XNNPACK)     |        2.8         |       2.7       |
-| LLAMA3_2_3B (XNNPACK)           |        7.3         |       7.1       |
-| LLAMA3_2_3B_SPINQUANT (XNNPACK) |        3.8         |       3.7       |
-| LLAMA3_2_3B_QLORA (XNNPACK)     |        4.0         |       3.9       |
-
-## Speech to Text
-
-| Model / Device         | iPhone 17 Pro [MB] | OnePlus 12 [MB] |
-| ---------------------- | :----------------: | :-------------: |
-| WHISPER_TINY (XNNPACK) |        375         |       410       |
-
-## Text to Speech
-
-:::note
-The reported memory usage values include the memory footprint of the Phonemis package, which is used for phonemizing input text. Currently, this can range from 100 to 150 MB depending on the device.
-:::
-
-| Model / Device          | iPhone 17 Pro [MB] | OnePlus 12 [MB] |
-| ----------------------- | :----------------: | :-------------: |
-| KOKORO_SMALL (XNNPACK)  |        820         |       820       |
-| KOKORO_MEDIUM (XNNPACK) |        1100        |      1140       |
-
-## Text Embeddings
-
-| Model / Device                                        | iPhone 17 Pro [MB] | OnePlus 12 [MB] |
-| ----------------------------------------------------- | :----------------: | :-------------: |
-| ALL_MINILM_L6_V2 (XNNPACK)                            |        110         |       95        |
-| ALL_MPNET_BASE_V2 (XNNPACK)                           |        455         |       405       |
-| MULTI_QA_MINILM_L6_COS_V1 (XNNPACK)                   |        140         |       120       |
-| MULTI_QA_MPNET_BASE_DOT_V1 (XNNPACK)                  |        455         |       435       |
-| CLIP_VIT_BASE_PATCH32_TEXT (XNNPACK)                  |        280         |       200       |
-| DISTILUSE_BASE_MULTILINGUAL_CASED_V2 (XNNPACK 8da4w)  |         36         |       44        |
-| DISTILUSE_BASE_MULTILINGUAL_CASED_V2 (Core ML FP32)   |         55         |        -        |
-| PARAPHRASE_MULTILINGUAL_MINILM_L12_V2 (XNNPACK 8da4w) |        131         |       141       |
-
-## Image Embeddings
-
-| Model / Device                             | iPhone 17 Pro [MB] | Google Pixel 10 [MB] |
-| ------------------------------------------ | :----------------: | :------------------: |
-| CLIP_VIT_BASE_PATCH32_IMAGE (XNNPACK FP32) |        340         |         345          |
-
-## Semantic Segmentation
-
-:::note
-Data presented in the following sections is based on inference with non-resized
-output. When resize is enabled, expect higher memory usage and inference time
-with higher resolutions.
-:::
-
-| Model / Device               | iPhone 17 Pro [MB] | OnePlus 12 [MB] |
-| ---------------------------- | :----------------: | :-------------: |
-| DEEPLABV3_RESNET50 (XNNPACK) |        660         |       930       |
-
-## Instance Segmentation
-
-:::note
-Data presented in the following sections is based on inference with 640x640 input.
-:::
-
-| Model / Device             | iPhone 17 Pro [MB] | OnePlus 12 [MB] |
-| -------------------------- | :----------------: | :-------------: |
-| YOLO26N_SEG (XNNPACK)      |        668         |       92        |
-| YOLO26S_SEG (XNNPACK)      |        712         |       220       |
-| YOLO26M_SEG (XNNPACK)      |        815         |       570       |
-| YOLO26L_SEG (XNNPACK)      |        1024        |       680       |
-| YOLO26X_SEG (XNNPACK)      |        1450        |      1410       |
-| RF_DETR_NANO_SEG (XNNPACK) |        603         |       620       |
-| FASTSAM_S (XNNPACK FP32)   |        535         |       567       |
-| FASTSAM_X (XNNPACK FP32)   |        760         |       792       |
-| FASTSAM_S (Core ML FP16)   |        523         |        -        |
-| FASTSAM_X (Core ML FP16)   |        684         |        -        |
-
-## Text to Image
-
-| Model / Device                  | iPhone 17 Pro [MB] | OnePlus 12 [MB] |
-| ------------------------------- | :----------------: | :-------------: |
-| BK_SDM_TINY_VPRED_256 (XNNPACK) |        2400        |      2400       |
-| BK_SDM_TINY_VPRED (XNNPACK)     |        6050        |      6210       |
diff --git a/docs/docs/02-benchmarks/model-size.md b/docs/docs/02-benchmarks/model-size.md
deleted file mode 100644
index cfa58823e1..0000000000
--- a/docs/docs/02-benchmarks/model-size.md
+++ /dev/null
@@ -1,161 +0,0 @@
----
-title: Model Size
----
-
-## Classification
-
-| Model             | XNNPACK FP32 [MB] | XNNPACK INT8 [MB] | Core ML FP32 [MB] | Core ML FP16 [MB] |
-| :---------------- | :---------------: | :---------------: | :---------------: | :---------------: |
-| EFFICIENTNET_V2_S |       85.7        |       22.9        |       86.5        |       43.9        |
-
-## Object Detection
-
-| Model                          | XNNPACK FP32 [MB] | Core ML FP32 [MB] | Core ML FP16 [MB] |
-| ------------------------------ | :---------------: | :---------------: | :---------------: |
-| SSDLITE_320_MOBILENET_V3_LARGE |       13.9        |       15.6        |       8.46        |
-| RF_DETR_NANO                   |        112        |         -         |         -         |
-| YOLO26N                        |       10.3        |         -         |         -         |
-| YOLO26S                        |       38.6        |         -         |         -         |
-| YOLO26M                        |       82.3        |         -         |         -         |
-| YOLO26L                        |        100        |         -         |         -         |
-| YOLO26X                        |        224        |         -         |         -         |
-
-## Instance Segmentation
-
-| Model            | XNNPACK [MB] | Core ML FP32 [MB] | Core ML FP16 [MB] |
-| ---------------- | :----------: | :---------------: | :---------------: |
-| YOLO26N_SEG      |     11.6     |         -         |         -         |
-| YOLO26S_SEG      |     42.3     |         -         |         -         |
-| YOLO26M_SEG      |     95.4     |         -         |         -         |
-| YOLO26L_SEG      |     113      |         -         |         -         |
-| YOLO26X_SEG      |     252      |         -         |         -         |
-| RF_DETR_NANO_SEG |     124      |         -         |         -         |
-| FASTSAM_S        |     47.3     |       47.8        |       24.2        |
-| FASTSAM_X        |     289      |        290        |        145        |
-
-## Style Transfer
-
-| Model                        | XNNPACK FP32 [MB] | XNNPACK INT8 [MB] | Core ML FP32 [MB] | Core ML FP16 [MB] |
-| ---------------------------- | :---------------: | :---------------: | :---------------: | :---------------: |
-| STYLE_TRANSFER_CANDY         |       6.82        |       1.84        |       7.12        |       3.79        |
-| STYLE_TRANSFER_MOSAIC        |       6.82        |       1.84        |       7.12        |       3.79        |
-| STYLE_TRANSFER_UDNIE         |       6.82        |       1.84        |       7.12        |       3.79        |
-| STYLE_TRANSFER_RAIN_PRINCESS |       6.82        |       1.84        |       7.12        |       3.79        |
-
-## OCR
-
-| Model                      | XNNPACK [MB]  |
-| -------------------------- | :-----------: |
-| Detector (CRAFT_QUANTIZED) |     20.9      |
-| Recognizer (CRNN)          | 18.5 - 25.2\* |
-
-\* - The model weights vary depending on the language.
-
-## Vertical OCR
-
-| Model                      | XNNPACK [MB]  |
-| -------------------------- | :-----------: |
-| Detector (CRAFT_QUANTIZED) |     20.9      |
-| Recognizer (CRNN)          | 18.5 - 25.2\* |
-
-\* - The model weights vary depending on the language.
-
-## LLMs
-
-| Model                          | XNNPACK [GB] |
-| ------------------------------ | :----------: |
-| LLAMA3_2_1B                    |     2.47     |
-| LLAMA3_2_1B_SPINQUANT          |     1.14     |
-| LLAMA3_2_1B_QLORA              |     1.18     |
-| LLAMA3_2_3B                    |     6.43     |
-| LLAMA3_2_3B_SPINQUANT          |     2.55     |
-| LLAMA3_2_3B_QLORA              |     2.65     |
-| QWEN3_0.6B                     |     1.11     |
-| QWEN3_0.6B_QUANTIZED           |     0.47     |
-| QWEN3_1.7B                     |     3.21     |
-| QWEN3_1.7B_QUANTIZED           |     1.21     |
-| QWEN3_4B                       |     7.49     |
-| QWEN3_4B_QUANTIZED             |     2.50     |
-| QWEN2_5_0.5B                   |     0.92     |
-| QWEN2_5_0.5B_QUANTIZED         |     0.39     |
-| QWEN2_5_1.5B                   |     2.88     |
-| QWEN2_5_1.5B_QUANTIZED         |     1.06     |
-| QWEN2_5_3B                     |     5.75     |
-| QWEN2_5_3B_QUANTIZED           |     1.95     |
-| HAMMER2_1_0.5B                 |     0.92     |
-| HAMMER2_1_0.5B_QUANTIZED       |     0.39     |
-| HAMMER2_1_1.5B                 |     2.88     |
-| HAMMER2_1_1.5B_QUANTIZED       |     1.06     |
-| HAMMER2_1_3B                   |     5.75     |
-| HAMMER2_1_3B_QUANTIZED         |     1.91     |
-| PHI4_MINI                      |     7.15     |
-| PHI4_MINI_QUANTIZED            |     2.62     |
-| SMOLLM2_135M                   |     0.25     |
-| SMOLLM2_135M_QUANTIZED         |     0.52     |
-| SMOLLM2_360M                   |     0.67     |
-| SMOLLM2_360M_QUANTIZED         |     1.27     |
-| SMOLLM2_1.7B                   |     3.19     |
-| SMOLLM2_1.7B_QUANTIZED         |     0.95     |
-| LFM2_5_1.2B_INSTRUCT           |     2.43     |
-| LFM2_5_1.2B_INSTRUCT_QUANTIZED |     0.74     |
-| LFM2_5_350M_FP16               |     0.79     |
-| LFM2_5_350M_QUANTIZED          |     0.26     |
-
-## Speech to text
-
-| Model            | XNNPACK [MB] |
-| ---------------- | :----------: |
-| WHISPER_TINY_EN  |     151      |
-| WHISPER_TINY     |     151      |
-| WHISPER_BASE_EN  |    290.6     |
-| WHISPER_BASE     |    290.6     |
-| WHISPER_SMALL_EN |     968      |
-| WHISPER_SMALL    |     968      |
-
-## Text to speech
-
-| Model         | XNNPACK [MB] |
-| ------------- | :----------: |
-| KOKORO_SMALL  |    329.6     |
-| KOKORO_MEDIUM |    334.4     |
-
-## Text Embeddings
-
-| Model                                           | Size [MB] |
-| ----------------------------------------------- | :-------: |
-| ALL_MINILM_L6_V2                                |    91     |
-| ALL_MPNET_BASE_V2                               |    438    |
-| MULTI_QA_MINILM_L6_COS_V1                       |    91     |
-| MULTI_QA_MPNET_BASE_DOT_V1                      |    438    |
-| CLIP_VIT_BASE_PATCH32_TEXT                      |    254    |
-| DISTILUSE_BASE_MULTILINGUAL_CASED_V2_8DA4W      |    393    |
-| PARAPHRASE_MULTILINGUAL_MINILM_L12_V2_QUANTIZED |    397    |
-
-## Image Embeddings
-
-| Model                       | XNNPACK FP32 [MB] | XNNPACK INT8 [MB] |
-| --------------------------- | :---------------: | :---------------: |
-| CLIP_VIT_BASE_PATCH32_IMAGE |        352        |       96.4        |
-
-## Semantic Segmentation
-
-| Model                         | XNNPACK FP32 [MB] | XNNPACK INT8 [MB] |
-| ----------------------------- | :---------------: | :---------------: |
-| DEEPLAB_V3_RESNET50           |        168        |       42.4        |
-| DEEPLAB_V3_RESNET101          |        244        |       61.7        |
-| DEEPLAB_V3_MOBILENET_V3_LARGE |       44.1        |       11.4        |
-| LRASPP_MOBILENET_V3_LARGE     |       12.9        |       3.53        |
-| FCN_RESNET50                  |        141        |       35.7        |
-| FCN_RESNET101                 |        217        |        55         |
-
-## Text to image
-
-| Model             | Text encoder (XNNPACK) [MB] | UNet (XNNPACK) [MB] | VAE decoder (XNNPACK) [MB] |
-| ----------------- | --------------------------- | ------------------- | -------------------------- |
-| BK_SDM_TINY_VPRED | 492                         | 1290                | 198                        |
-
-## Voice Activity Detection (VAD)
-
-| Model    | XNNPACK [MB] |
-| -------- | :----------: |
-| FSMN_VAD |     1.83     |
diff --git a/docs/docs/03-hooks/01-natural-language-processing/_category_.json b/docs/docs/03-hooks/01-natural-language-processing/_category_.json
deleted file mode 100644
index 0314f315d2..0000000000
--- a/docs/docs/03-hooks/01-natural-language-processing/_category_.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "label": "Natural Language Processing",
-  "link": {
-    "type": "generated-index"
-  }
-}
diff --git a/docs/docs/03-hooks/01-natural-language-processing/useLLM.md b/docs/docs/03-hooks/01-natural-language-processing/useLLM.md
deleted file mode 100644
index 29b1be4d72..0000000000
--- a/docs/docs/03-hooks/01-natural-language-processing/useLLM.md
+++ /dev/null
@@ -1,580 +0,0 @@
----
-title: useLLM
-keywords:
-  [
-    react native,
-    react native ai,
-    react native llm,
-    react native qwen,
-    react native llama,
-    react native executorch,
-    executorch,
-    pytorch,
-    on-device ai,
-    mobile ai,
-    llama 3,
-    qwen,
-    text generation,
-    tool calling,
-    function calling,
-  ]
-description: "Learn how to use LLMs in your React Native applications with React Native ExecuTorch's useLLM hook."
----
-
-React Native ExecuTorch supports a variety of LLMs (checkout our [HuggingFace repository](https://huggingface.co/software-mansion) for model already converted to ExecuTorch format) including Llama 3.2. Before getting started, you’ll need to obtain the .pte binary—a serialized model, the tokenizer and tokenizer config JSON files. There are various ways to accomplish this:
-
-:::info
-It is recommended to use models provided by us, which are available at our [HuggingFace repository](https://huggingface.co/collections/software-mansion/llm). You can also use [constants](../../06-api-reference/index.md#models---llm) shipped with our library.
-
-Alternatively, follow the official [tutorial](https://docs.pytorch.org/executorch/stable/llm/export-llm.html) made by ExecuTorch team to export an arbitrary LLM model.
-:::
-
-:::warning
-Lower-end devices might not be able to fit LLMs into memory. We recommend using quantized models to reduce the memory footprint.
-:::
-
-## API Reference
-
-- For detailed API Reference for `useLLM` see: [`useLLM` API Reference](../../06-api-reference/functions/useLLM.md).
-- For all LLM models available out-of-the-box in React Native ExecuTorch see: [LLM Models](../../06-api-reference/index.md#models---llm).
-- For useful LLM utility functionalities please refer to the following link: [LLM Utility Functionalities](../../06-api-reference/index.md#utilities---llm).
-
-## Initializing
-
-In order to load a model into the app, you need to run the following code:
-
-```typescript
-import { models, useLLM } from 'react-native-executorch';
-const llm = useLLM({ model: models.llm.lfm2_5_1_2b_instruct() });
-```
-
-<br/>
-
-The code snippet above fetches the model from the specified URL, loads it into memory, and returns an object with various functions and properties for controlling the model. You can monitor the loading progress by checking the [`llm.downloadProgress`](../../06-api-reference/interfaces/LLMType.md#downloadprogress) and [`llm.isReady`](../../06-api-reference/interfaces/LLMType.md#isready) property, and if anything goes wrong, the [`llm.error`](../../06-api-reference/interfaces/LLMType.md#error) property will contain the error message.
-
-### Arguments
-
-`useLLM` takes [`LLMProps`](../../06-api-reference/interfaces/LLMProps.md) that consists of:
-
-- [model](../../06-api-reference/interfaces/LLMModel.md).
-- An optional flag [`preventLoad`](../../06-api-reference/interfaces/SpeechToTextProps.md#preventload) which prevents auto-loading of the model.
-
-You need more details? Check the following resources:
-
-- For detailed information about `useLLM` arguments check this section: [`useLLM` arguments](../../06-api-reference/functions/useLLM.md#parameters).
-- For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-- For available LLM models please check out the following list: [LLM Models](../../06-api-reference/index.md#models---llm).
-
-### Returns
-
-`useLLM` returns [`LLMType`](../../06-api-reference/interfaces/LLMType.md) which provides:
-
-- State properties: [`response`](../../06-api-reference/interfaces/LLMType.md#response), [`token`](../../06-api-reference/interfaces/LLMType.md#token), [`isReady`](../../06-api-reference/interfaces/LLMType.md#isready), [`isGenerating`](../../06-api-reference/interfaces/LLMType.md#isgenerating), [`downloadProgress`](../../06-api-reference/interfaces/LLMType.md#downloadprogress), [`error`](../../06-api-reference/interfaces/LLMType.md#error), [`messageHistory`](../../06-api-reference/interfaces/LLMType.md#messagehistory)
-- Generation methods: [`generate`](../../06-api-reference/interfaces/LLMType.md#generate), [`sendMessage`](../../06-api-reference/interfaces/LLMType.md#sendmessage), [`interrupt`](../../06-api-reference/interfaces/LLMType.md#interrupt)
-- Configuration: [`configure`](../../06-api-reference/interfaces/LLMType.md#configure), [`deleteMessage`](../../06-api-reference/interfaces/LLMType.md#deletemessage)
-- Token counting: [`getGeneratedTokenCount`](../../06-api-reference/interfaces/LLMType.md#getgeneratedtokencount), [`getPromptTokenCount`](../../06-api-reference/interfaces/LLMType.md#getprompttokencount), [`getTotalTokenCount`](../../06-api-reference/interfaces/LLMType.md#gettotaltokencount)
-
-For complete details, see the [LLMType API Reference](../../06-api-reference/interfaces/LLMType.md).
-
-## Functional vs managed
-
-You can use functions returned from this hooks in two manners:
-
-1. Functional/pure - we will not keep any state for you. You'll need to keep conversation history and handle function calling yourself. Use [`generate`](../../06-api-reference/interfaces/LLMType.md#generate) and [`response`](../../06-api-reference/interfaces/LLMType.md#response). Note that you don't need to run [`configure`](../../06-api-reference/interfaces/LLMType.md#configure) to use those. Furthermore, [`chatConfig`](../../06-api-reference/interfaces/LLMConfig.md#chatconfig) and [`toolsConfig`](../../06-api-reference/interfaces/LLMConfig.md#toolsconfig) will not have any effect on those functions.
-
-2. Managed/stateful - we will manage conversation state. Tool calls will be parsed and called automatically after passing appropriate callbacks. See more at [managed LLM chat](#managed-llm-chat).
-
-## Functional way
-
-### Simple generation
-
-To perform chat completion you can use the [`generate`](../../06-api-reference/interfaces/LLMType.md#generate) function. The [`response`](../../06-api-reference/interfaces/LLMType.md#response) value is updated with each token as it's generated, and the function returns a promise that resolves to the complete response when generation finishes.
-
-```tsx
-const llm = useLLM({ model: models.llm.lfm2_5_1_2b_instruct() });
-
-const handleGenerate = async () => {
-  const chat: Message[] = [
-    { role: 'system', content: 'You are a helpful assistant' },
-    { role: 'user', content: 'Hi!' },
-    { role: 'assistant', content: 'Hi!, how can I help you?' },
-    { role: 'user', content: 'What is the meaning of life?' },
-  ];
-
-  // Chat completion - returns the generated response
-  const response = await llm.generate(chat);
-  console.log('Complete response:', response);
-};
-
-return (
-  <View>
-    <Button onPress={handleGenerate} title="Generate!" />
-    <Text>{llm.response}</Text>
-  </View>
-);
-```
-
-### Interrupting the model
-
-Sometimes, you might want to stop the model while it’s generating. To do this, you can use [`interrupt`](../../06-api-reference/interfaces/LLMType.md#interrupt), which will halt the model and update the response one last time.
-
-There are also cases when you need to check if tokens are being generated, such as to conditionally render a stop button. We’ve made this easy with the [`isGenerating`](../../06-api-reference/interfaces/LLMType.md#isgenerating) property.
-
-:::warning
-If you try to dismount the component using this hook while generation is still going on, it will result in crash.
-You'll need to interrupt the model first and wait until [`isGenerating`](../../06-api-reference/interfaces/LLMType.md#isgenerating) is set to false.
-:::
-
-### Reasoning
-
-Some models ship with a built-in "reasoning" or "thinking" mode, but this is model-specific, not a feature of our library. If the model you're using supports disabling reasoning, follow the instructions provided by the model authors. For example, Qwen 3 lets you disable reasoning by adding the `/no_think` suffix to your prompts - [source](https://qwenlm.github.io/blog/qwen3/#advanced-usages).
-
-### Tool calling
-
-Sometimes text processing capabilities of LLMs are not enough. That's when you may want to introduce tool calling (also called function calling). It allows model to use external tools to perform its tasks. The tools may be any arbitrary function that you want your model to run. It may retrieve some data from 3rd party API. It may do an action inside an app like pressing buttons or filling forms, or it may use system APIs to interact with your phone (turning on flashlight, adding events to your calendar, changing volume etc.).
-
-```tsx
-const TOOL_DEFINITIONS: LLMTool[] = [
-  {
-    name: 'get_weather',
-    description: 'Get/check weather in given location.',
-    parameters: {
-      type: 'dict',
-      properties: {
-        location: {
-          type: 'string',
-          description: 'Location where user wants to check weather',
-        },
-      },
-      required: ['location'],
-    },
-  },
-];
-
-const llm = useLLM({ model: models.llm.hammer2_1_1_5b() });
-
-const handleGenerate = () => {
-  const chat: Message[] = [
-    {
-      role: 'system',
-      content: `You are a helpful assistant. Current time and date: ${new Date().toString()}`,
-    },
-    {
-      role: 'user',
-      content: `Hi, what's the weather like in Cracow right now?`,
-    },
-  ];
-
-  // Chat completion
-  llm.generate(chat, TOOL_DEFINITIONS);
-};
-
-useEffect(() => {
-  // Parse response and call tools accordingly
-  // ...
-}, [llm.response]);
-
-return (
-  <View>
-    <Button onPress={handleGenerate} title="Generate!" />
-    <Text>{llm.response}</Text>
-  </View>
-);
-```
-
-## Managed LLM Chat
-
-### Configuring the model
-
-To configure model (i.e. change system prompt, load initial conversation history or manage tool calling, set generation settings) you can use
-[`configure`](../../06-api-reference/classes/LLMModule.md#configure) method. [**`chatConfig`**](../../06-api-reference/interfaces/LLMConfig.md#chatconfig) and [**`toolsConfig`**](../../06-api-reference/interfaces/LLMConfig.md#toolsconfig) is only applied to managed chats i.e. when using [`sendMessage`](../../06-api-reference/classes/LLMModule.md#sendmessage) (see: [Functional vs managed](../../03-hooks/01-natural-language-processing/useLLM.md#functional-vs-managed)) It accepts object with following fields:
-
-- [`chatConfig`](../../06-api-reference/interfaces/LLMConfig.md#chatconfig) - Object configuring chat management that contains:
-  - [`systemPrompt`](../../06-api-reference/interfaces/ChatConfig.md#systemprompt) - Often used to tell the model what is its purpose, for example - "Be a helpful translator".
-
-  - [`initialMessageHistory`](../../06-api-reference/interfaces/ChatConfig.md#initialmessagehistory) - Object that represent the conversation history. This can be used to provide initial context to the model.
-
-  - [`contextStrategy`](../../06-api-reference/interfaces/ChatConfig.md#contextstrategy) - Object implementing [`ContextStrategy`](../../06-api-reference/interfaces/ContextStrategy.md) interface used to manage conversation context, including trimming history if necessary. Custom strategies can be implemented or one of the built-in options can be used (e.g. [`NoopContextStrategy`](../../06-api-reference/classes/NoopContextStrategy.md), [`MessageCountContextStrategy`](../../06-api-reference/classes/MessageCountContextStrategy.md) or the default [`SlidingWindowContextStrategy`](../../06-api-reference/classes/SlidingWindowContextStrategy.md)).
-
-- [`toolsConfig`](../../06-api-reference/interfaces/LLMConfig.md#toolsconfig) - Object configuring options for enabling and managing tool use. **It will only have effect if your model's chat template support it**. Contains following properties:
-  - [`tools`](../../06-api-reference/interfaces/ToolsConfig.md#tools) - List of objects defining tools.
-
-  - [`executeToolCallback`](../../06-api-reference/interfaces/ToolsConfig.md#executetoolcallback) - Function that accepts [`ToolCall`](../../06-api-reference/interfaces/ToolCall.md), executes tool and returns the string to model.
-
-  - [`displayToolCalls`](../../06-api-reference/interfaces/ToolsConfig.md#displaytoolcalls) - If set to `true`, JSON tool calls will be displayed in chat. If `false`, only answers will be displayed.
-
-- [`generationConfig`](../../06-api-reference/interfaces/LLMConfig.md#generationconfig) - Object configuring generation settings with following properties:
-  - [`outputTokenBatchSize`](../../06-api-reference/interfaces/GenerationConfig.md#batchtimeinterval) - Soft upper limit on the number of tokens in each token batch (in certain cases there can be more tokens in given batch, i.e. when the batch would end with special emoji join character).
-
-  - [`batchTimeInterval`](../../06-api-reference/interfaces/GenerationConfig.md#batchtimeinterval) - Upper limit on the time interval between consecutive token batches.
-
-  - [`temperature`](../../06-api-reference/interfaces/GenerationConfig.md#temperature) - Scales output logits by the inverse of temperature. Controls the randomness / creativity of text generation.
-
-  - [`topP`](../../06-api-reference/interfaces/GenerationConfig.md#topp) - Only samples from the smallest set of tokens whose cumulative probability exceeds topP. Range `[0, 1]`. Values of `0` or `1` disable top-p filtering.
-
-  - [`minP`](../../06-api-reference/interfaces/GenerationConfig.md#minp) - Minimum-probability threshold applied after softmax: tokens whose probability is below `minP * max_prob` are excluded from sampling. Range `[0, 1]`. Default `0` disables the filter. Stacks with `topP` when both are set.
-
-  - [`repetitionPenalty`](../../06-api-reference/interfaces/GenerationConfig.md#repetitionpenalty) - Multiplicative penalty applied to logits of tokens that already appeared in the prompt or the generated text. Values greater than `1` discourage repetition; default `1` disables the penalty.
-
-:::info[Built-in models ship with sampling defaults]
-Model presets expose an optional [`generationConfig`](../../06-api-reference/interfaces/LLMProps.md) on the `model` prop. Whenever the upstream model card publishes recommended values (currently Qwen3 and LFM2-VL) the preset carries them and `useLLM` applies them automatically before `isReady` flips — you don't need to call `configure` just to get sensible defaults. Any fields you then pass to `configure` still override on a per-field basis.
-:::
-
-### Model configuration example
-
-```tsx
-import { useEffect } from 'react';
-import {
-  models,
-  MessageCountContextStrategy,
-  DEFAULT_SYSTEM_PROMPT,
-  ToolCall,
-  useLLM,
-} from 'react-native-executorch';
-const TOOL_DEFINITIONS: LLMTool[] = [
-  {
-    name: 'get_weather',
-    description: 'Get/check weather in given location.',
-    parameters: {
-      type: 'dict',
-      properties: {
-        location: {
-          type: 'string',
-          description: 'Location where user wants to check weather',
-        },
-      },
-      required: ['location'],
-    },
-  },
-];
-
-const getWeather = async (_call: ToolCall) => {
-  return 'The weather is great!';
-};
-
-const executeTool: (call: ToolCall) => Promise<string | null> = async (
-  call
-) => {
-  switch (call.toolName) {
-    case 'get_weather':
-      return await getWeather(call);
-    default:
-      console.error(`Wrong function! We don't handle it!`);
-      return null;
-  }
-};
-
-const llm = useLLM({ model: models.llm.lfm2_5_1_2b_instruct() });
-
-const { configure } = llm;
-useEffect(() => {
-  configure({
-    chatConfig: {
-      systemPrompt: `${DEFAULT_SYSTEM_PROMPT} Current time and date: ${new Date().toString()}`,
-      initialMessageHistory: [
-        {
-          role: 'user',
-          content: 'What is the current time and date?',
-        },
-      ],
-      contextStrategy: new MessageCountContextStrategy(6),
-    },
-    toolsConfig: {
-      tools: TOOL_DEFINITIONS,
-      executeToolCallback: executeTool,
-      displayToolCalls: true,
-    },
-    generationConfig: {
-      outputTokenBatchSize: 15,
-      batchTimeInterval: 100,
-      temperature: 0.7,
-      topP: 0.9,
-      minP: 0.05,
-      repetitionPenalty: 1.05,
-    },
-  });
-}, [configure]);
-```
-
-### Sending a message
-
-In order to send a message to the model, one can use the following code:
-
-```tsx
-const llm = useLLM({ model: models.llm.lfm2_5_1_2b_instruct() });
-
-const send = () => {
-  const message = 'Hi, who are you?';
-  llm.sendMessage(message);
-};
-
-return <Button onPress={send} title="Generate!" />;
-```
-
-### Accessing conversation history
-
-Behind the scenes, tokens are generated one by one, and the [`response`](../../06-api-reference/interfaces/LLMType.md#response) property is updated with each token as it’s created.
-If you want to get entire conversation you can use [`messageHistory`](../../06-api-reference/interfaces/LLMType.md#messagehistory) field:
-
-```tsx
-return (
-  <View>
-    {llm.messageHistory.map((message) => (
-      <Text>{message.content}</Text>
-    ))}
-  </View>
-);
-```
-
-### Tool calling example
-
-```tsx
-const TOOL_DEFINITIONS: LLMTool[] = [
-  {
-    name: 'get_weather',
-    description: 'Get/check weather in given location.',
-    parameters: {
-      type: 'dict',
-      properties: {
-        location: {
-          type: 'string',
-          description: 'Location where user wants to check weather',
-        },
-      },
-      required: ['location'],
-    },
-  },
-];
-
-const llm = useLLM({ model: models.llm.hammer2_1_1_5b() });
-
-useEffect(() => {
-  llm.configure({
-    chatConfig: {
-      systemPrompt: `You are helpful assistant. Current time and date: ${new Date().toString()}`,
-    },
-    toolsConfig: {
-      tools: TOOL_DEFINITIONS,
-      executeToolCallback: async (call) => {
-        if (call.toolName === 'get_weather') {
-          console.log('Checking weather!');
-          // perform call to weather API
-          // ...
-          const mockResults = 'Weather is great!';
-          return mockResults;
-        }
-        return null;
-      },
-      displayToolCalls: true,
-    },
-  });
-}, []);
-
-const send = () => {
-  const message = `Hi, what's the weather like in Cracow right now?`;
-  llm.sendMessage(message);
-};
-
-return (
-  <View>
-    <Button onPress={send} title="Generate!" />
-    <Text>{llm.response}</Text>
-  </View>
-);
-```
-
-### Structured output example
-
-```tsx
-import { Schema } from 'jsonschema';
-
-const responseSchema: Schema = {
-  properties: {
-    username: {
-      type: 'string',
-      description: 'Name of user, that is asking a question.',
-    },
-    question: {
-      type: 'string',
-      description: 'Question that user asks.',
-    },
-    bid: {
-      type: 'number',
-      description: 'Amount of money, that user offers.',
-    },
-    currency: {
-      type: 'string',
-      description: 'Currency of offer.',
-    },
-  },
-  required: ['username', 'bid'],
-  type: 'object',
-};
-
-// alternatively use Zod
-import * as z from 'zod/v4';
-const responseSchemaWithZod = z.object({
-  username: z
-    .string()
-    .meta({ description: 'Name of user, that is asking a question.' }),
-  question: z.optional(
-    z.string().meta({ description: 'Question that user asks.' })
-  ),
-  bid: z.number().meta({ description: 'Amount of money, that user offers.' }),
-  currency: z.optional(z.string().meta({ description: 'Currency of offer.' })),
-});
-
-const llm = useLLM({ model: models.llm.qwen3_4b() });
-
-useEffect(() => {
-  const formattingInstructions = getStructuredOutputPrompt(responseSchema);
-  // alternatively pass schema defined with Zod
-  //  const formattingInstructions = getStructuredOutputPrompt(responseSchemaWithZod);
-
-  // Some extra prompting to improve quality of response.
-  const prompt = `Your goal is to parse user's messages and return them in JSON format. Don't respond to user. Simply return JSON with user's question parsed. \n${formattingInstructions}\n /no_think`;
-
-  llm.configure({
-    chatConfig: {
-      systemPrompt: prompt,
-    },
-  });
-}, []);
-
-useEffect(() => {
-  const lastMessage = llm.messageHistory.at(-1);
-  if (!llm.isGenerating && lastMessage?.role === 'assistant') {
-    try {
-      const formattedOutput = fixAndValidateStructuredOutput(
-        lastMessage.content,
-        responseSchemaWithZod
-      );
-      // Zod will allow you to correctly type output
-      const formattedOutputWithZod = fixAndValidateStructuredOutput(
-        lastMessage.content,
-        responseSchema
-      );
-      console.log('Formatted output:', formattedOutput, formattedOutputWithZod);
-    } catch (e) {
-      console.log(
-        "Error parsing output and/or output doesn't match required schema!",
-        e
-      );
-    }
-  }
-}, [llm.messageHistory, llm.isGenerating]);
-
-const send = () => {
-  const message = `I'm John. Is this product damaged? I can give you $100 for this.`;
-  llm.sendMessage(message);
-};
-
-return (
-  <View>
-    <Button onPress={send} title="Generate!" />
-    <Text>{llm.response}</Text>
-  </View>
-);
-```
-
-The response should include JSON:
-
-```json
-{
-  "username": "John",
-  "question": "Is this product damaged?",
-  "bid": 100,
-  "currency": "USD"
-}
-```
-
-## Token Batching
-
-Depending on selected model and the user's device generation speed can be above 60 tokens per second. If the [`tokenCallback`](../../06-api-reference/classes/LLMModule.md#tokencallback) from [`LLMModule`](../../06-api-reference/classes/LLMModule.md), which is used under the hood, triggers rerenders and is invoked on every single token it can significantly decrease the app's performance. To alleviate this and help improve performance we've implemented token batching. To configure this you need to call [`configure`](../../06-api-reference/interfaces/LLMType.md#configure) method and pass [`generationConfig`](../../06-api-reference/interfaces/LLMConfig.md#generationconfig). You can check what you can configure [Configuring the Model](../../03-hooks/01-natural-language-processing/useLLM.md#configuring-the-model). They set the size of the batch before tokens are emitted and the maximum time interval between consecutive batches respectively. Each batch is emitted if either `timeInterval` elapses since last batch or `countInterval` number of tokens are generated. This allows for smooth generation even if model lags during generation. Default parameters are set to 10 tokens and 80ms for time interval (~12 batches per second).
-
-## Vision-Language Models (VLM)
-
-Some models support multimodal input — text, images and/or audio together. To use them, pass a `capabilities` array when loading the model.
-
-### Loading a VLM
-
-```tsx
-import { models, useLLM } from 'react-native-executorch';
-const llm = useLLM({ model: models.llm.gemma4_e2b_multimodal() });
-```
-
-The `capabilities` field is already set on the model constant. You can also construct the model object explicitly:
-
-```tsx
-const llm = useLLM({
-  model: {
-    modelSource: '...',
-    tokenizerSource: '...',
-    tokenizerConfigSource: '...',
-    capabilities: ['vision', 'audio'],
-  },
-});
-```
-
-Passing `capabilities` unlocks the typed `media` argument on `sendMessage`.
-
-### Sending a message with an image or audio recording
-
-```tsx
-const llm = useLLM({ model: models.llm.gemma4_e2b_multimodal() });
-
-const send = () => {
-  llm.sendMessage('What is in this image?', {
-    imagePath: '/path/to/image.jpg',
-  });
-  // or
-  llm.sendMessage('What can you hear?', {
-    audioBuffer: audioRecording,
-  });
-};
-
-return (
-  <View>
-    <Button onPress={send} title="Send!" />
-    <Text>{llm.response}</Text>
-  </View>
-);
-```
-
-The `imagePath` should be a local file path on the device.
-The `audioBuffer` should be a `Float32Array` with 16kHz waveform.
-
-### Functional generation with images
-
-You can also use `generate` directly by setting `mediaPath` on user messages:
-
-```tsx
-const llm = useLLM({ model: models.llm.lfm2_5_vl_1_6b() });
-
-const handleGenerate = async () => {
-  const chat: Message[] = [
-    {
-      role: 'user',
-      content: 'Describe this image.',
-      mediaPath: '/path/to/image.jpg',
-    },
-  ];
-
-  const response = await llm.generate(chat);
-  console.log(response);
-};
-```
-
-## Available models
-
-| Model Family                                                                               |            Sizes             | Quantized | Capabilities |
-| ------------------------------------------------------------------------------------------ | :--------------------------: | :-------: | :----------: |
-| [Hammer 2.1](https://huggingface.co/software-mansion/react-native-executorch-hammer-2.1)   |        0.5B, 1.5B, 3B        |    ✅     |      -       |
-| [Qwen 2.5](https://huggingface.co/software-mansion/react-native-executorch-qwen-2.5)       |        0.5B, 1.5B, 3B        |    ✅     |      -       |
-| [Qwen 3](https://huggingface.co/software-mansion/react-native-executorch-qwen-3)           |        0.6B, 1.7B, 4B        |    ✅     |      -       |
-| [Qwen 3.5](https://huggingface.co/software-mansion/react-native-executorch-qwen-3.5)       |           0.8B, 2B           |    ✅     |      -       |
-| [Phi 4 Mini](https://huggingface.co/software-mansion/react-native-executorch-phi-4-mini)   |              4B              |    ✅     |      -       |
-| [SmolLM 2](https://huggingface.co/software-mansion/react-native-executorch-smolLm-2)       |       135M, 360M, 1.7B       |    ✅     |      -       |
-| [LLaMA 3.2](https://huggingface.co/software-mansion/react-native-executorch-llama-3.2)     |            1B, 3B            |    ✅     |      -       |
-| [Bielik v3.0](https://huggingface.co/software-mansion/react-native-executorch-bielik-v3.0) |             1.5B             |    ✅     |      -       |
-| [LFM2.5](https://huggingface.co/software-mansion/react-native-executorch-lfm-2.5)          | 350M, 450M-VL, 1.2B, 1.6B-VL |    ✅     |    vision    |
diff --git a/docs/docs/03-hooks/01-natural-language-processing/usePrivacyFilter.md b/docs/docs/03-hooks/01-natural-language-processing/usePrivacyFilter.md
deleted file mode 100644
index f7b6699e85..0000000000
--- a/docs/docs/03-hooks/01-natural-language-processing/usePrivacyFilter.md
+++ /dev/null
@@ -1,142 +0,0 @@
----
-title: usePrivacyFilter
-keywords:
-  [
-    privacy filter,
-    pii detection,
-    pii,
-    personally identifiable information,
-    privacy,
-    redaction,
-    react native,
-    executorch,
-    ai,
-    machine learning,
-    on-device,
-    mobile ai,
-  ]
-description: "Detect personally identifiable information (PII) in text on-device with React Native ExecuTorch's usePrivacyFilter hook."
----
-
-Privacy Filter is a token-level model that scans text for personally identifiable information (PII) — names, emails, phone numbers, addresses, SSNs, secrets, and more — and returns the detected spans together with the entity type. Inference runs entirely on-device, so the input text never leaves the user's phone.
-
-:::info
-It is recommended to use models provided by us, which are available at our [Hugging Face repository](https://huggingface.co/collections/software-mansion/privacy-filter). You can also use [constants](https://github.com/software-mansion/react-native-executorch/blob/main/packages/react-native-executorch/src/constants/modelUrls.ts) shipped with our library.
-:::
-
-## API Reference
-
-- For detailed API Reference for `usePrivacyFilter` see: [`usePrivacyFilter` API Reference](../../06-api-reference/functions/usePrivacyFilter.md).
-- For all Privacy Filter models available out-of-the-box in React Native ExecuTorch see: [Privacy Filter Models](../../06-api-reference/index.md#models---privacy-filter).
-
-## High Level Overview
-
-```typescript
-import { models, usePrivacyFilter } from 'react-native-executorch';
-const model = usePrivacyFilter({ model: models.privacy_filter.openai() });
-
-try {
-  const entities = await model.generate(
-    'My name is Sarah Chen and my email is sarah@example.com.'
-  );
-  console.log(entities);
-  // [
-  //   { label: 'private_person', text: 'Sarah Chen', startToken: 3, endToken: 5 },
-  //   { label: 'private_email',  text: 'sarah@example.com', startToken: 11, endToken: 14 },
-  // ]
-} catch (error) {
-  console.error(error);
-}
-```
-
-### Arguments
-
-`usePrivacyFilter` takes [`PrivacyFilterProps`](../../06-api-reference/interfaces/PrivacyFilterProps.md) that consists of:
-
-- `model` of type [`PrivacyFilterModelSources`](../../06-api-reference/type-aliases/PrivacyFilterModelSources.md) — a built-in preset (`modelName` + `modelSource` + `tokenizerSource`). The label list and Viterbi defaults are resolved from `modelName`; for custom fine-tunes use [`PrivacyFilterModule.fromCustomModel`](../../04-typescript-api/01-natural-language-processing/PrivacyFilterModule.md) directly.
-- An optional flag [`preventLoad`](../../06-api-reference/interfaces/PrivacyFilterProps.md#preventload) which prevents auto-loading of the model.
-
-You need more details? Check the following resources:
-
-- For detailed information about `usePrivacyFilter` arguments check this section: [`usePrivacyFilter` arguments](../../06-api-reference/functions/usePrivacyFilter.md#parameters).
-- For all Privacy Filter models available out-of-the-box in React Native ExecuTorch see: [Privacy Filter Models](../../06-api-reference/index.md#models---privacy-filter).
-- For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-### Returns
-
-`usePrivacyFilter` returns an object called `PrivacyFilterType` containing a `generate` function for running detection. To get more details please read: [`PrivacyFilterType` API Reference](../../06-api-reference/interfaces/PrivacyFilterType.md).
-
-## Running the model
-
-To run the model, call the [`generate`](../../06-api-reference/interfaces/PrivacyFilterType.md#generate) method with the text you want to scan. The method returns a promise that resolves to an array of [`PiiEntity`](../../06-api-reference/interfaces/PiiEntity.md) objects, each describing one detected span (`label`, decoded `text`, and inclusive `startToken` / exclusive `endToken` indices into the tokenized input).
-
-Inputs are processed in sliding windows with 50% overlap (the window size matches the model's exported `forward` input shape), so there is no length limit — long documents are scanned end-to-end without truncation.
-
-:::note
-Token indices in returned entities are positions in the tokenizer's output (the unpadded `encode()` stream), not character offsets in the original string. Use the entity's decoded `text` field if you want to display or redact spans verbatim.
-:::
-
-### Tuning precision and recall
-
-Built-in presets run with neutral, validity-only Viterbi decoding. To shift the precision/recall tradeoff, load the model directly through [`PrivacyFilterModule.fromCustomModel`](../../04-typescript-api/01-natural-language-processing/PrivacyFilterModule.md) (reusing the preset's `modelSource` / `tokenizerSource` and label list) and pass a [`viterbiBiases`](../../06-api-reference/interfaces/ViterbiBiases.md) object — six floats matching the operating-point schema in OpenAI's `viterbi_calibration.json`. Negative `backgroundToStart` makes the decoder enter spans more eagerly (higher recall); positive `backgroundStay` keeps it in the background label more often (higher precision).
-
-## Example
-
-```tsx
-import React, { useState } from 'react';
-import { Button, Text, View, TextInput, ScrollView } from 'react-native';
-import { models, usePrivacyFilter, PiiEntity } from 'react-native-executorch';
-export default function App() {
-  const model = usePrivacyFilter({ model: models.privacy_filter.openai() });
-  const [text, setText] = useState(
-    'My name is Sarah Chen and you can reach me at sarah.chen@example.com.'
-  );
-  const [entities, setEntities] = useState<PiiEntity[]>([]);
-
-  const handleScan = async () => {
-    if (!model.isReady) {
-      console.error('Privacy Filter model is not loaded yet.');
-      return;
-    }
-    try {
-      const detected = await model.generate(text);
-      setEntities(detected);
-    } catch (error) {
-      console.error('Error during running Privacy Filter model', error);
-    }
-  };
-
-  return (
-    <ScrollView>
-      <TextInput
-        multiline
-        value={text}
-        onChangeText={setText}
-        style={{ borderWidth: 1, padding: 8, minHeight: 120 }}
-      />
-      <Button
-        onPress={handleScan}
-        title="Detect PII"
-        disabled={!model.isReady}
-      />
-      {entities.map((entity, idx) => (
-        <View key={idx} style={{ paddingVertical: 4 }}>
-          <Text>
-            {entity.label}:{' '}
-            <Text style={{ fontWeight: 'bold' }}>{entity.text}</Text>
-          </Text>
-        </View>
-      ))}
-    </ScrollView>
-  );
-}
-```
-
-## Supported models
-
-| Model                                                                                          | Categories | Description                                                                                                                                                           |
-| ---------------------------------------------------------------------------------------------- | :--------: | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| [openai/privacy-filter](https://huggingface.co/openai/privacy-filter)                          |     8      | OpenAI's base PII detector. Covers names, emails, phone numbers, addresses, dates of birth, URLs, and generic secrets / API keys.                                     |
-| [OpenMed/privacy-filter-nemotron](https://huggingface.co/OpenMed/privacy-filter-nemotron-base) |    55+     | Fine-tune of the base model with a much wider label space — adds medical, financial, demographic, technical, and government-document categories on top of the base 8. |
-
-**`Categories`** — The number of distinct entity types the model can emit. Both models share the same backbone (256-token windows, 128-token banded attention) and tokenizer (o200k); they differ only in the BIOES label space.
diff --git a/docs/docs/03-hooks/01-natural-language-processing/useSpeechToText.md b/docs/docs/03-hooks/01-natural-language-processing/useSpeechToText.md
deleted file mode 100644
index 53869c6fd5..0000000000
--- a/docs/docs/03-hooks/01-natural-language-processing/useSpeechToText.md
+++ /dev/null
@@ -1,225 +0,0 @@
----
-title: useSpeechToText
-keywords:
-  [
-    speech to text,
-    stt,
-    voice recognition,
-    transcription,
-    whisper,
-    react native,
-    executorch,
-    ai,
-    machine learning,
-    on-device,
-    mobile ai,
-  ]
-description: "Learn how to use speech-to-text models in your React Native applications with React Native ExecuTorch's useSpeechToText hook."
----
-
-Speech to text (STT) converts spoken audio into written text. This hook allows you to implement features like voice assistants, real-time transcription, and audio file processing directly on-device.
-
-:::info
-We recommend using our optimized models available on [Hugging Face](https://huggingface.co/collections/software-mansion/speech-to-text-68d0ec99ed794250491b8bbe). You can also use pre-defined [constants](https://github.com/software-mansion/react-native-executorch/blob/main/packages/react-native-executorch/src/constants/modelUrls.ts) included in the library.
-:::
-
-## API Reference
-
-- [`useSpeechToText` API Reference](../../06-api-reference/functions/useSpeechToText.md)
-- [STT Models List](../../06-api-reference/index.md#models---speech-to-text)
-
-## Basic Usage (File Transcription)
-
-Use `transcribe` for processing pre-recorded audio or short clips. The input should be a `Float32Array` of audio samples at **16 kHz**.
-
-### Transcribe Options
-
-The `transcribe()` function accepts an optional configuration object:
-
-- `language`: The language code (e.g., `'es'`, `'fr'`). Required for multilingual models.
-- `verbose`: If `true`, the method returns a detailed `TranscriptionResult` object following the OpenAI Whisper `verbose_json` format (including segments and word-level timestamps).
-
-In this example, we use [`react-native-audio-api`](https://docs.swmansion.com/react-native-audio-api/) to decode an audio file into the required format.
-
-### Example
-
-```typescript
-import { models, useSpeechToText } from 'react-native-executorch';
-import { AudioContext } from 'react-native-audio-api';
-import * as FileSystem from 'expo-file-system';
-
-const model = useSpeechToText({
-  model: models.speech_to_text.whisper_tiny_en(), // Use whisper_tiny_en for English or whisper_tiny for multilingual support
-});
-
-// 1. Get audio file
-const { uri } = await FileSystem.downloadAsync(
-  'https://some-audio-url.com/file.mp3',
-  `${FileSystem.cacheDirectory}audio_file`
-);
-
-// 2. Decode to 16kHz PCM Float32Array
-const audioContext = new AudioContext({ sampleRate: 16000 });
-const decodedAudioData = await audioContext.decodeAudioData(uri);
-const audioBuffer = decodedAudioData.getChannelData(0);
-
-// 3. Transcribe
-try {
-  const result = await model.transcribe(audioBuffer);
-  console.log('Transcription:', result.text);
-} catch (error) {
-  console.error('Transcription failed:', error);
-}
-```
-
-## Live Streaming Transcription
-
-For real-time applications or audio streams of arbitrary length, use the **Streaming API**. This is optimized for live input, handling the 30-second window limitation of Whisper models automatically to ensure context isn't lost between chunks.
-
-### How it works:
-
-1.  **Feed audio**: Use `streamInsert` to push small chunks of audio (e.g., 100ms) as they arrive from the microphone.
-2.  **Get results**: The `stream` generator yields two types of text:
-    - `committed`: Finalized text that won't change.
-    - `nonCommitted`: Temporary text that might update as the model gets more context from the audio.
-
-### Streaming Options
-
-The `stream()` function accepts several optional parameters:
-
-- `language`: The language code (e.g., `'es'`, `'fr'`). Required for multilingual models.
-- `verbose`: If `true`, includes word-level timestamps and segment metadata in the result objects.
-- `useVAD`: Enable the Voice Activity Detection submodule (if configured in `useSpeechToText` props) to optimize performance by filtering silence. Defaults to `false`.
-- `timeout`: (Advanced) The interval (in milliseconds) between processing consecutive audio chunks in streaming mode. Lower values provide more frequent updates and lower latency, while higher values reduce CPU consumption. Defaults to `100`.
-- `vadDetectionMargin`: (Advanced) The duration of silence (in milliseconds) required after speech is detected before "committing" a segment. Defaults to `500`. Only active when VAD module is used.
-
-### Voice Activity Detection (VAD)
-
-Integrating a VAD submodule is highly recommended for streaming. It improves performance by automatically removing silence, which reduces CPU usage, saves battery, and prevents the model from "hallucinating" text during silent periods.
-
-### Example
-
-```tsx
-import React, { useEffect, useState, useRef } from 'react';
-import { Text, Button, View, SafeAreaView } from 'react-native';
-import { models, useSpeechToText } from 'react-native-executorch';
-import { AudioManager, AudioRecorder } from 'react-native-audio-api';
-
-export default function LiveTranscriber() {
-  const model = useSpeechToText({
-    model: models.speech_to_text.whisper_tiny_en(),
-    vad: models.vad.fsmn_vad(),
-  });
-  const [text, setText] = useState('');
-  const isRecordingRef = useRef(false);
-  const [recorder] = useState(() => new AudioRecorder());
-
-  const startLiveStreaming = async () => {
-    isRecordingRef.current = true;
-    setText('');
-
-    // 2. Capture microphone input
-    recorder.onAudioReady(
-      { sampleRate: 16000, bufferLength: 1600, channelCount: 1 },
-      (chunk) => model.streamInsert(chunk.buffer.getChannelData(0))
-    );
-
-    await recorder.start();
-
-    // 3. Process the stream with VAD enabled
-    try {
-      let finalizedText = '';
-      const streamIter = model.stream({
-        verbose: false,
-        useVAD: true, // Enable VAD filter
-        vadDetectionMargin: 500, // Wait for 500ms of silence before committing
-      });
-
-      for await (const { committed, nonCommitted } of streamIter) {
-        if (!isRecordingRef.current) break;
-
-        if (committed.text) finalizedText += committed.text;
-        setText(finalizedText + nonCommitted.text);
-      }
-    } catch (error) {
-      console.error('Streaming error:', error);
-    }
-  };
-
-  const stopLiveStreaming = () => {
-    isRecordingRef.current = false;
-    recorder.stop();
-    model.streamStop();
-  };
-
-  return (
-    <SafeAreaView>
-      <Text>{text || 'Press start and speak...'}</Text>
-      <Button
-        onPress={startLiveStreaming}
-        title="Start Live"
-        disabled={model.isGenerating}
-      />
-      <Button onPress={stopLiveStreaming} title="Stop" color="red" />
-    </SafeAreaView>
-  );
-}
-```
-
-## Advanced Features
-
-### Multilingual Transcription
-
-To transcribe languages other than English, use a multilingual model (e.g., `models.speech_to_text.whisper_tiny()`) and specify the corresponding language code:
-
-```typescript
-// Transcribe in Spanish
-const model = useSpeechToText({
-  model: models.speech_to_text.whisper_tiny(),
-});
-const result = await model.transcribe(spanishAudio, { language: 'es' });
-```
-
-### Timestamps & Metadata
-
-Set `verbose: true` to receive word-level timestamps and confidence scores. The output follows the OpenAI Whisper `verbose_json` format.
-
-```typescript
-const result = await model.transcribe(audioBuffer, { verbose: true });
-// result.segments[0].words -> [{ word: "Hello", start: 0.5, end: 1.0 }, ...]
-```
-
-## Configuration
-
-### Arguments
-
-`useSpeechToText` accepts a configuration object:
-
-- `model`: Model source and tokenizer settings (see [ModelConfig](../../06-api-reference/interfaces/SpeechToTextModelConfig.md)).
-- `preventLoad`: (Optional) If `true`, the model won't load until you call `load()`.
-
-### Returns
-
-The hook returns a [`SpeechToTextType`](../../06-api-reference/interfaces/SpeechToTextType.md) object containing:
-
-- `error`: `null | RnExecutorchError` - Contains the error message if the model failed to load.
-- `isReady`: `boolean` - Indicates whether the model has successfully loaded and is ready for inference.
-- `isGenerating`: `boolean` - Indicates whether the model is currently processing an inference.
-- `downloadProgress`: `number` - Tracks the progress of the model download process as a value between `0` and `1`.
-- `transcribe(audio, options)`: Starts a transcription process for a given input array, which should be a waveform at 16kHz. Returns a promise resolving to a [`TranscriptionResult`](../../06-api-reference/interfaces/TranscriptionResult.md).
-- `stream(options)`: Starts a streaming transcription process. Asynchronous generator that yields objects containing `committed` and `nonCommitted` transcriptions, both of type [`TranscriptionResult`](../../06-api-reference/interfaces/TranscriptionResult.md).
-- `streamInsert(audio)`: Inserts a chunk of audio data (sampled at 16kHz) into the ongoing streaming transcription.
-- `streamStop()`: Stops the ongoing streaming transcription process.
-- `encode(audio)`: Runs the encoding part of the model on the provided waveform. Returns a promise resolving to the encoded `Float32Array`.
-- `decode(tokens, encoderOutput)`: Runs the decoder of the model with the given tokens (`Int32Array`) and encoder output (`Float32Array`). Returns a promise resolving to the decoded `Float32Array`.
-
-## Supported models
-
-| Model                                                              |   Language   |
-| ------------------------------------------------------------------ | :----------: |
-| [whisper-tiny.en](https://huggingface.co/openai/whisper-tiny.en)   |   English    |
-| [whisper-tiny](https://huggingface.co/openai/whisper-tiny)         | Multilingual |
-| [whisper-base.en](https://huggingface.co/openai/whisper-base.en)   |   English    |
-| [whisper-base](https://huggingface.co/openai/whisper-base)         | Multilingual |
-| [whisper-small.en](https://huggingface.co/openai/whisper-small.en) |   English    |
-| [whisper-small](https://huggingface.co/openai/whisper-small)       | Multilingual |
diff --git a/docs/docs/03-hooks/01-natural-language-processing/useTextEmbeddings.md b/docs/docs/03-hooks/01-natural-language-processing/useTextEmbeddings.md
deleted file mode 100644
index b9ba8c41b9..0000000000
--- a/docs/docs/03-hooks/01-natural-language-processing/useTextEmbeddings.md
+++ /dev/null
@@ -1,122 +0,0 @@
----
-title: useTextEmbeddings
-keywords:
-  [
-    text embedding,
-    text embeddings,
-    embeddings,
-    react native,
-    executorch,
-    ai,
-    machine learning,
-    on-device,
-    mobile ai,
-  ]
-description: "Learn how to use text embeddings models in your React Native applications with React Native ExecuTorch's useTextEmbeddings hook."
----
-
-Text Embedding is the process of converting text into a numerical representation. This representation can be used for various natural language processing tasks, such as semantic search, text classification, and clustering.
-
-:::info
-It is recommended to use models provided by us, which are available at our [Hugging Face repository](https://huggingface.co/collections/software-mansion/text-embeddings-68d0ed42f8ca0200d0283362). You can also use [constants](https://github.com/software-mansion/react-native-executorch/blob/main/packages/react-native-executorch/src/constants/modelUrls.ts) shipped with our library.
-:::
-
-## API Reference
-
-- For detailed API Reference for `useTextEmbeddings` see: [`useTextEmbeddings` API Reference](../../06-api-reference/functions/useTextEmbeddings.md).
-- For all text embeddings models available out-of-the-box in React Native ExecuTorch see: [Text Embeddings Models](../../06-api-reference/index.md#models---text-embeddings).
-
-## High Level Overview
-
-```typescript
-import { models, useTextEmbeddings } from 'react-native-executorch';
-const model = useTextEmbeddings({
-  model: models.text_embedding.all_minilm_l6_v2(),
-});
-
-try {
-  const embedding = await model.forward('Hello World!');
-} catch (error) {
-  console.error(error);
-}
-```
-
-### Arguments
-
-`useTextEmbeddings` takes [`TextEmbeddingsProps`](../../06-api-reference/interfaces/TextEmbeddingsProps.md) that consists of:
-
-- `model` of type `object` containing the [model source](../../06-api-reference/interfaces/TextEmbeddingsProps.md#modelsource) and [tokenizer source](../../06-api-reference/interfaces/TextEmbeddingsProps.md#tokenizersource).
-- An optional flag [`preventLoad`](../../06-api-reference/interfaces/TextEmbeddingsProps.md#preventload) which prevents auto-loading of the model.
-
-You need more details? Check the following resources:
-
-- For detailed information about `useTextEmbeddings` arguments check this section: [`useTextEmbeddings` arguments](../../06-api-reference/functions/useTextEmbeddings.md#parameters).
-- For all text embeddings models available out-of-the-box in React Native ExecuTorch see: [Text Embeddings Models](../../06-api-reference/index.md#models---text-embeddings).
-- For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-### Returns
-
-`useTextEmbeddings` returns an object called `TextEmbeddingsType` containing bunch of functions to interact with text embedding. To get more details please read: [`TextEmbeddingsType` API Reference](../../06-api-reference/interfaces/TextEmbeddingsType.md).
-
-## Running the model
-
-To run the model, you can use the [`forward`](../../06-api-reference/interfaces/TextEmbeddingsType.md#forward) method. It accepts one argument, which is a string representing the text you want to embed. The function returns a promise, which can resolve either to an error or an array of numbers representing the embedding.
-
-## Example
-
-```typescript
-import { models, useTextEmbeddings } from 'react-native-executorch';
-const dotProduct = (a: number[], b: number[]) =>
-  a.reduce((sum, val, i) => sum + val * b[i], 0);
-
-const cosineSimilarity = (a: number[], b: number[]) => {
-  const dot = dotProduct(a, b);
-  const normA = Math.sqrt(dotProduct(a, a));
-  const normB = Math.sqrt(dotProduct(b, b));
-  return dot / (normA * normB);
-};
-
-function App() {
-  const model = useTextEmbeddings({
-    model: models.text_embedding.all_minilm_l6_v2(),
-  });
-
-  // ...
-
-  try {
-    const helloWorldEmbedding = await model.forward('Hello World!');
-    const goodMorningEmbedding = await model.forward('Good Morning!');
-
-    const similarity = cosineSimilarity(
-      helloWorldEmbedding,
-      goodMorningEmbedding
-    );
-
-    console.log(`Cosine similarity: ${similarity}`);
-  } catch (error) {
-    console.error(error);
-  }
-
-  // ...
-}
-```
-
-## Supported models
-
-| Model                                                                                                                       |   Language    | Max Tokens | Embedding Dimensions | Description                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| --------------------------------------------------------------------------------------------------------------------------- | :-----------: | :--------: | :------------------: | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| [all-MiniLM-L6-v2](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2)                                           |    English    |    254     |         384          | All-round model tuned for many use-cases. Trained on a large and diverse dataset of over 1 billion training pairs.                                                                                                                                                                                                                                                                                                               |
-| [all-mpnet-base-v2](https://huggingface.co/sentence-transformers/all-mpnet-base-v2)                                         |    English    |    382     |         768          | All-round model tuned for many use-cases. Trained on a large and diverse dataset of over 1 billion training pairs.                                                                                                                                                                                                                                                                                                               |
-| [multi-qa-MiniLM-L6-cos-v1](https://huggingface.co/sentence-transformers/multi-qa-MiniLM-L6-cos-v1)                         |    English    |    509     |         384          | This model was tuned for semantic search: Given a query/question, it can find relevant passages. It was trained on a large and diverse set of (question, answer) pairs.                                                                                                                                                                                                                                                          |
-| [multi-qa-mpnet-base-dot-v1](https://huggingface.co/sentence-transformers/multi-qa-mpnet-base-dot-v1)                       |    English    |    510     |         768          | This model was tuned for semantic search: Given a query/question, it can find relevant passages. It was trained on a large and diverse set of (question, answer) pairs.                                                                                                                                                                                                                                                          |
-| [distiluse-base-multilingual-cased-v2](https://huggingface.co/sentence-transformers/distiluse-base-multilingual-cased-v2)   | 50+ languages |    126     |         512          | Multilingual DistilBERT with a 768→512 projection head. Recommended when broader language coverage matters more than the exact English quality of MiniLM/MPNet.                                                                                                                                                                                                                                                                  |
-| [paraphrase-multilingual-MiniLM-L12-v2](https://huggingface.co/sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2) | 50+ languages |    126     |         384          | Multilingual MiniLM-L12 distilled from paraphrase-multilingual-mpnet-base-v2. Compact (≈118 M params) sentence encoder for cross-lingual semantic similarity and retrieval across 50+ languages.                                                                                                                                                                                                                                 |
-| [clip-vit-base-patch32-text](https://huggingface.co/openai/clip-vit-base-patch32)                                           |    English    |     74     |         512          | CLIP (Contrastive Language-Image Pre-Training) is a neural network trained on a variety of (image, text) pairs. CLIP allows to embed images and text into the same vector space. This allows to find similar images as well as to implement image search. This is the text encoder part of the CLIP model. To embed images checkout [clip-vit-base-patch32-image](../02-computer-vision/useImageEmbeddings.md#supported-models). |
-
-**`Max Tokens`** - The maximum number of tokens that can be processed by the model. If the input text exceeds this limit, it will be truncated.
-
-**`Embedding Dimensions`** - The size of the output embedding vector. This is the number of dimensions in the vector representation of the input text.
-
-:::note
-For the supported models, the returned embedding vector is normalized, meaning that its length is equal to 1. This allows for easier comparison of vectors using cosine similarity, just calculate the dot product of two vectors to get the cosine similarity score.
-:::
diff --git a/docs/docs/03-hooks/01-natural-language-processing/useTextToSpeech.md b/docs/docs/03-hooks/01-natural-language-processing/useTextToSpeech.md
deleted file mode 100644
index 9598ab75a6..0000000000
--- a/docs/docs/03-hooks/01-natural-language-processing/useTextToSpeech.md
+++ /dev/null
@@ -1,223 +0,0 @@
----
-title: useTextToSpeech
-keywords: [
-    text to speech
-    tts,
-    voice synthesizer,
-    transcription,
-    kokoro,
-    react native,
-    executorch,
-    ai,
-    machine learning,
-    on-device,
-    mobile ai,
-  ]
-description: "Learn how to use text-to-speech models in your React Native applications with React Native ExecuTorch's useTextToSpeech hook."
----
-
-Text to speech is a task that allows to transform written text into spoken language. It is commonly used to implement features such as voice assistants, accessibility tools, or audiobooks.
-
-:::info
-It is recommended to use models provided by us, which are available at our [Hugging Face repository](https://huggingface.co/software-mansion/react-native-executorch-kokoro). You can also use [constants](https://github.com/software-mansion/react-native-executorch/blob/main/packages/react-native-executorch/src/constants/modelUrls.ts) shipped with our library.
-:::
-
-## API Reference
-
-- For detailed API Reference for `useTextToSpeech` see: [`useTextToSpeech` API Reference](../../06-api-reference/functions/useTextToSpeech.md).
-- For all text to speech models available out-of-the-box in React Native ExecuTorch see: [TTS Models](../../06-api-reference/index.md#models---text-to-speech).
-- For all supported voices in `useTextToSpeech` please refer to: [Supported Voices](../../06-api-reference/index.md#tts-supported-voices)
-
-## High Level Overview
-
-You can play the generated waveform in any way most suitable to you; however, in the snippet below we utilize the react-native-audio-api library to play synthesized speech.
-
-```typescript
-import { models, useTextToSpeech } from 'react-native-executorch';
-import { AudioContext } from 'react-native-audio-api';
-
-const model = useTextToSpeech(models.text_to_speech.kokoro.en_us.heart());
-
-const audioContext = new AudioContext({ sampleRate: 24000 });
-
-const handleSpeech = async (text: string) => {
-  const speed = 1.0;
-  const waveform = await model.forward({ text, speed });
-
-  const audioBuffer = audioContext.createBuffer(1, waveform.length, 24000);
-  audioBuffer.getChannelData(0).set(waveform);
-
-  const source = audioContext.createBufferSource();
-  source.buffer = audioBuffer;
-  source.connect(audioContext.destination);
-  source.start();
-};
-```
-
-### Arguments
-
-`useTextToSpeech` takes [`TextToSpeechModelConfig`](../../06-api-reference/interfaces/TextToSpeechModelConfig.md) that consists of:
-
-- `model` of type [`TextToSpeechModelSources`](../../06-api-reference/type-aliases/TextToSpeechModelSources.md) containing the [`durationPredictorSource`](../../06-api-reference/type-aliases/TextToSpeechModelSources.md#durationpredictorsource), [`synthesizerSource`](../../06-api-reference/type-aliases/TextToSpeechModelSources.md#synthesizersource), and [`modelName`](../../06-api-reference/type-aliases/TextToSpeechModelSources.md#modelname).
-- [`voiceSource`](../../06-api-reference/interfaces/TextToSpeechModelConfig.md#voicesource) of type [`ResourceSource`](../../06-api-reference/type-aliases/ResourceSource.md) - configuration of specific voice used in TTS.
-- [`phonemizerConfig`](../../06-api-reference/interfaces/TextToSpeechModelConfig.md#phonemizerconfig) of type [`TextToSpeechPhonemizerConfig`](../../06-api-reference/interfaces/TextToSpeechPhonemizerConfig.md) - configuration of the phonemizer.
-
-`useTextToSpeech`'s second optional argument is an object with:
-
-- `preventLoad` which prevents auto-loading of the model.
-
-You need more details? Check the following resources:
-
-- For detailed information about `useTextToSpeech` arguments check this section: [`useTextToSpeech` arguments](../../06-api-reference/functions/useTextToSpeech.md#parameters).
-- For all text to speech models available out-of-the-box in React Native ExecuTorch see: [Text to Speech Models](../../06-api-reference/index.md#models---text-to-speech).
-- For all supported voices in `useTextToSpeech` please refer to: [Supported Voices](../../06-api-reference/index.md#tts-supported-voices)
-- For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-### Returns
-
-`useTextToSpeech` returns an object called `TextToSpeechType` containing bunch of functions to interact with TTS. To get more details please read: [`TextToSpeechType` API Reference](../../06-api-reference/interfaces/TextToSpeechType.md).
-
-## Running the model
-
-The module provides two ways to generate speech using either raw text or pre-generated phonemes:
-
-### Using Text
-
-1.  [**`forward({ text, speed, phonemize })`**](../../06-api-reference/interfaces/TextToSpeechType.md#forward): Generates the complete audio waveform at once. Returns a promise resolving to a `Float32Array`.
-2.  [**`stream({ speed, phonemize, stopAutomatically, onNext, ... })`**](../../06-api-reference/interfaces/TextToSpeechType.md#stream): An async generator-like functionality (managed via callbacks like `onNext`) that yields chunks of audio as they are computed.
-    This is ideal for reducing the "time to first audio" for long sentences. You can also dynamically insert text during the generation process using `streamInsert(text)`, force-partition trailing content without an end-of-sentence character via `streamFlush()`, and stop the stream with `streamStop(instant)`.
-
-:::tip Recommendation
-In most cases, the **`stream()`** method is recommended over `forward()`. It significantly reduces latency by allowing audio playback to begin as soon as the first chunk is synthesized, rather than waiting for the entire text to be processed.
-:::
-
-Both methods accept a `phonemize` parameter (defaults to `true`). When set to `true`, the input `text` is treated as raw text and converted to phonemes internally. When set to `false`, the input is expected to be a string of IPA phonemes.
-
-### Using Phonemes
-
-If you have pre-computed phonemes (e.g., from an external dictionary or a custom G2P model), you can skip the internal phoneme generation step:
-
-1.  [**`forward({ text, phonemize: false, speed })`**](../../06-api-reference/interfaces/TextToSpeechType.md#forward): Generates the complete audio waveform from a phoneme string.
-2.  [**`stream({ text, phonemize: false, speed, onNext, ... })`**](../../06-api-reference/interfaces/TextToSpeechType.md#stream): Streams audio chunks generated from a phoneme string.
-
-:::note
-Since `forward` and `stream` process the input, they might take a significant amount of time to produce audio for long inputs.
-:::
-
-## Example
-
-### Speech Synthesis
-
-```tsx
-import React from 'react';
-import { Button, View } from 'react-native';
-import { models, useTextToSpeech } from 'react-native-executorch';
-import { AudioContext } from 'react-native-audio-api';
-
-export default function App() {
-  const tts = useTextToSpeech(models.text_to_speech.kokoro.en_us.heart());
-
-  const generateAudio = async () => {
-    const audioData = await tts.forward({
-      text: 'Hello world! This is a sample text.',
-    });
-
-    // Playback example
-    const ctx = new AudioContext({ sampleRate: 24000 });
-    const buffer = ctx.createBuffer(1, audioData.length, 24000);
-    buffer.getChannelData(0).set(audioData);
-
-    const source = ctx.createBufferSource();
-    source.buffer = buffer;
-    source.connect(ctx.destination);
-    source.start();
-  };
-
-  return (
-    <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
-      <Button title="Speak" onPress={generateAudio} disabled={!tts.isReady} />
-    </View>
-  );
-}
-```
-
-### Streaming Synthesis
-
-```tsx
-import React, { useRef } from 'react';
-import { Button, View } from 'react-native';
-import { models, useTextToSpeech } from 'react-native-executorch';
-import { AudioContext } from 'react-native-audio-api';
-
-export default function App() {
-  const tts = useTextToSpeech(models.text_to_speech.kokoro.en_us.heart());
-
-  const contextRef = useRef(new AudioContext({ sampleRate: 24000 }));
-
-  const generateStream = async () => {
-    const ctx = contextRef.current;
-
-    await tts.stream({
-      text: "This is a longer text, which is being streamed chunk by chunk. Let's see how it works!",
-      onNext: async (chunk) => {
-        return new Promise((resolve) => {
-          const buffer = ctx.createBuffer(1, chunk.length, 24000);
-          buffer.getChannelData(0).set(chunk);
-
-          const source = ctx.createBufferSource();
-          source.buffer = buffer;
-          source.connect(ctx.destination);
-          source.onEnded = () => resolve();
-          source.start();
-        });
-      },
-    });
-  };
-
-  return (
-    <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
-      <Button title="Stream" onPress={generateStream} disabled={!tts.isReady} />
-    </View>
-  );
-}
-```
-
-### Synthesis from Phonemes
-
-If you already have a phoneme string obtained from an external source (e.g. the Python `phonemizer` library,
-`espeak-ng`, or any custom phonemizer), you can use `forward` or `stream` with the `phonemize: false` flag to synthesize audio directly, skipping the phoneme generation stage.
-
-```tsx
-import React from 'react';
-import { Button, View } from 'react-native';
-import { models, useTextToSpeech } from 'react-native-executorch';
-export default function App() {
-  const tts = useTextToSpeech(models.text_to_speech.kokoro.en_us.heart());
-
-  const synthesizePhonemes = async () => {
-    // Example phonemes for "Hello"
-    const audioData = await tts.forward({
-      text: 'ɐ mˈæn hˌu dˈʌzᵊnt tɹˈʌst hɪmsˈɛlf, kæn nˈɛvəɹ ɹˈiᵊli tɹˈʌst ˈɛniwˌʌn ˈɛls.',
-      phonemize: false,
-    });
-
-    // ... process or play audioData ...
-  };
-
-  return (
-    <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
-      <Button
-        title="Synthesize Phonemes"
-        onPress={synthesizePhonemes}
-        disabled={!tts.isReady}
-      />
-    </View>
-  );
-}
-```
-
-## Supported models
-
-| Model                                                                            |                               Language                               |
-| -------------------------------------------------------------------------------- | :------------------------------------------------------------------: |
-| [Kokoro](https://huggingface.co/software-mansion/react-native-executorch-kokoro) | English, French, German, Spanish, Portuguese, Italian, Polish, Hindi |
diff --git a/docs/docs/03-hooks/01-natural-language-processing/useTokenizer.md b/docs/docs/03-hooks/01-natural-language-processing/useTokenizer.md
deleted file mode 100644
index ba3516638e..0000000000
--- a/docs/docs/03-hooks/01-natural-language-processing/useTokenizer.md
+++ /dev/null
@@ -1,104 +0,0 @@
----
-title: useTokenizer
-keywords:
-  [
-    tokenizer,
-    text tokenizer,
-    tokenization,
-    react native,
-    executorch,
-    ai,
-    machine learning,
-    on-device,
-    mobile ai,
-  ]
-description: "Learn how to tokenize your text in your React Native applications using React Native ExecuTorch's useTokenizer hook."
----
-
-Tokenization is the process of breaking down text into smaller units called tokens. It’s a crucial step in natural language processing that
-converts text into a format that machine learning models can understand.
-
-:::note
-We are using [Hugging Face Tokenizers](https://huggingface.co/docs/tokenizers/index) under the hood, ensuring compatibility with the Hugging Face ecosystem.
-:::
-
-## API Reference
-
-- For detailed API Reference for `useTokenizer` see: [`useTokenizer` API Reference](../../06-api-reference/functions/useTokenizer.md).
-
-## High Level Overview
-
-```typescript
-import { models, useTokenizer } from 'react-native-executorch';
-
-const tokenizer = useTokenizer({
-  tokenizer: models.text_embedding.all_minilm_l6_v2(),
-});
-
-const text = 'Hello, world!';
-
-try {
-  // Tokenize the text
-  const tokens = await tokenizer.encode(text);
-  console.log('Tokens:', tokens);
-
-  // Decode the tokens back to text
-  const decodedText = await tokenizer.decode(tokens);
-  console.log('Decoded text:', decodedText);
-} catch (error) {
-  console.error('Error tokenizing text:', error);
-}
-```
-
-### Arguments
-
-`useTokenizer` takes [`TokenizerProps`](../../06-api-reference/interfaces/TokenizerProps.md) that consists of:
-
-- `tokenizer` — an object containing [`tokenizerSource`](../../06-api-reference/interfaces/TokenizerProps.md#tokenizersource).
-- An optional flag [`preventLoad`](../../06-api-reference/interfaces/TokenizerProps.md#preventload) which prevents auto-loading of the model.
-
-You need more details? Check the following resources:
-
-- For detailed information about `useTokenizer` arguments check this section: [`useTokenizer` arguments](../../06-api-reference/functions/useTokenizer.md#parameters).
-- For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-### Returns
-
-`useTokenizer` returns an object called `TokenizerType` containing bunch of functions to interact with Tokenizers. To get more details please read: [`TokenizerType` API Reference](../../06-api-reference/interfaces/TokenizerType.md).
-
-## Example
-
-```typescript
-import { models, useTokenizer } from 'react-native-executorch';
-
-function App() {
-  const tokenizer = useTokenizer({
-    tokenizer: models.text_embedding.all_minilm_l6_v2(),
-  });
-
-  // ...
-
-  try {
-    const text = 'Hello, world!';
-
-    const vocabSize = await tokenizer.getVocabSize();
-    console.log('Vocabulary size:', vocabSize);
-
-    const tokens = await tokenizer.encode(text);
-    console.log('Token IDs:', tokens);
-
-    const decoded = await tokenizer.decode(tokens);
-    console.log('Decoded text:', decoded);
-
-    const tokenId = await tokenizer.tokenToId('hello');
-    console.log('Token ID for "Hello":', tokenId);
-
-    const token = await tokenizer.idToToken(tokenId);
-    console.log('Token for ID:', token);
-  } catch (error) {
-    console.error(error);
-  }
-
-  // ...
-}
-```
diff --git a/docs/docs/03-hooks/01-natural-language-processing/useVAD.md b/docs/docs/03-hooks/01-natural-language-processing/useVAD.md
deleted file mode 100644
index 99d41f1608..0000000000
--- a/docs/docs/03-hooks/01-natural-language-processing/useVAD.md
+++ /dev/null
@@ -1,97 +0,0 @@
----
-title: useVAD
----
-
-Voice Activity Detection (VAD) is the task of analyzing an audio signal to identify time segments containing human speech, separating them from non-speech sections like silence and background noise.
-
-:::info
-It is recommended to use models provided by us, which are available at our [Hugging Face repository](https://huggingface.co/software-mansion/react-native-executorch-fsmn-vad). You can also use [constants](https://github.com/software-mansion/react-native-executorch/blob/main/packages/react-native-executorch/src/constants/modelUrls.ts) shipped with our library.
-:::
-
-## API Reference
-
-- For detailed API Reference for `useVAD` see: [`useVAD` API Reference](../../06-api-reference/functions/useVAD.md).
-- For all VAD models available out-of-the-box in React Native ExecuTorch see: [VAD Models](../../06-api-reference/index.md#models---voice-activity-detection).
-
-## Static Audio (Batch) processing
-
-This mode is best suited for processing pre-recorded audio files or existing buffers. You provide a full waveform to the `forward` method, which returns an array of detected speech segments.
-
-```typescript
-import { useVAD, models } from 'react-native-executorch';
-
-const model = useVAD({ model: models.vad.fsmn_vad() });
-
-// ... obtain audioBuffer (Float32Array) at 16kHz ...
-
-try {
-  const speechSegments = await model.forward(audioBuffer);
-  console.log('Speech detected at:', speechSegments);
-} catch (error) {
-  console.error('VAD Error:', error);
-}
-```
-
-:::note
-Timestamps in `Segment[]` correspond to the indices of the input array. Divide them by your sampling rate (usually 16000) to get results in seconds.
-:::
-
-## Live Streaming (Real-time detection)
-
-Live streaming allows you to process audio in real-time as it arrives from a microphone or network stream. It uses an internal state to track speech transitions across chunks.
-
-### How it works
-
-1.  **Start the session**: Call `model.stream()` with callbacks for speech events. This returns a promise that stays active until the stream is stopped.
-2.  **Feed audio**: Periodically push audio chunks using `model.streamInsert()`.
-3.  **Handle events**: Use `onSpeechBegin` and `onSpeechEnd` callbacks to trigger UI updates or toggle recording for other tasks (like STT).
-4.  **End the session**: Call `model.streamStop()` to clean up.
-
-### Configuration Options
-
-You can fine-tune the streaming behavior via the `options` object:
-
-- **`timeout`** (default: `100`ms): Specifies the interval between consecutive VAD inferences. A lower value makes the detection more responsive but increases CPU usage.
-- **`detectionMargin`** (default: `100`ms): Specifies the maximum allowed gap between the last detected speech segment and the current time to still consider the speech as "ongoing." This value determines how much silence is tolerated before `onSpeechEnd` is triggered.
-
-```tsx
-import { useVAD, models } from 'react-native-executorch';
-import { AudioRecorder } from 'react-native-audio-api';
-
-const model = useVAD({ model: models.vad.fsmn_vad() });
-const recorder = new AudioRecorder();
-
-const startLiveVAD = async () => {
-  // Start the continuous streaming listener
-  model.stream({
-    onSpeechBegin: () => console.log('User started speaking'),
-    onSpeechEnd: () => console.log('User stopped speaking'),
-    options: {
-      timeout: 100, // Checks every 100ms
-      detectionMargin: 500, // 500ms of silence before ending speech
-    },
-  });
-
-  // Capture microphone input at 16kHz
-  recorder.onAudioReady(
-    { sampleRate: 16000, bufferLength: 1600, channelCount: 1 },
-    (chunk) => model.streamInsert(chunk.buffer.getChannelData(0))
-  );
-
-  await recorder.start();
-};
-
-const stopLiveVAD = () => {
-  recorder.stop();
-  model.streamStop();
-};
-```
-
-### Arguments & Returns
-
-- **Arguments**: `useVAD` takes a [`VADProps`](../../06-api-reference/interfaces/VADProps.md) object containing the `model` and an optional `preventLoad` flag.
-- **Returns**: A [`VADType`](../../06-api-reference/interfaces/VADType.md) object providing `forward`, `stream`, `streamInsert`, and `streamStop` methods, along with `error`, `isReady`, `isGenerating`, and `downloadProgress` states.
-
-## Supported models
-
-- [fsmn-vad](https://huggingface.co/collections/software-mansion/voice-activity-detection)
diff --git a/docs/docs/03-hooks/02-computer-vision/_category_.json b/docs/docs/03-hooks/02-computer-vision/_category_.json
deleted file mode 100644
index 930e814ef7..0000000000
--- a/docs/docs/03-hooks/02-computer-vision/_category_.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "label": "Computer Vision",
-  "link": {
-    "type": "generated-index"
-  }
-}
diff --git a/docs/docs/03-hooks/02-computer-vision/useClassification.md b/docs/docs/03-hooks/02-computer-vision/useClassification.md
deleted file mode 100644
index 7db709dd9a..0000000000
--- a/docs/docs/03-hooks/02-computer-vision/useClassification.md
+++ /dev/null
@@ -1,107 +0,0 @@
----
-title: useClassification
----
-
-Image classification is the process of assigning a label to an image that best describes its contents. For example, when given an image of a puppy, the image classifier should assign the puppy class to that image.
-
-:::note
-Usually, the class with the highest probability is the one that is assigned to an image. However, if there are multiple classes with comparatively high probabilities, this may indicate that the model is not confident in its prediction.
-:::
-
-:::info
-It is recommended to use models provided by us, which are available at our [Hugging Face repository](https://huggingface.co/collections/software-mansion/classification-68d0ea49b5c7de8a3cae1e68). You can also use [constants](https://github.com/software-mansion/react-native-executorch/blob/main/packages/react-native-executorch/src/constants/modelUrls.ts) shipped with our library.
-:::
-
-## API Reference
-
-- For detailed API Reference for `useClassification` see: [`useClassification` API Reference](../../06-api-reference/functions/useClassification.md).
-- For all classification models available out-of-the-box in React Native ExecuTorch see: [Classification Models](../../06-api-reference/index.md#models---classification).
-
-## High Level Overview
-
-```typescript
-import { models, useClassification } from 'react-native-executorch';
-const model = useClassification({
-  model: models.classification.efficientnet_v2_s(),
-});
-
-const imageUri = 'file::///Users/.../cute_puppy.png';
-
-try {
-  const classesWithProbabilities = await model.forward(imageUri);
-} catch (error) {
-  console.error(error);
-}
-```
-
-### Arguments
-
-`useClassification` takes [`ClassificationProps`](../../06-api-reference/interfaces/ClassificationProps.md) that consists of:
-
-- `model` - An object containing:
-  - `modelName` - The name of a built-in model. See [`ClassificationModelSources`](../../06-api-reference/interfaces/ClassificationProps.md) for the list of supported models.
-  - `modelSource` - The location of the model binary (a URL or a bundled resource).
-- An optional flag [`preventLoad`](../../06-api-reference/interfaces/ClassificationProps.md#preventload) which prevents auto-loading of the model.
-
-The hook is generic over the model config — TypeScript automatically infers the correct label type based on the `modelName` you provide. No explicit generic parameter is needed.
-
-You need more details? Check the following resources:
-
-- For detailed information about `useClassification` arguments check this section: [`useClassification` arguments](../../06-api-reference/functions/useClassification.md#parameters).
-- For all classification models available out-of-the-box in React Native ExecuTorch see: [Classification Models](../../06-api-reference/index.md#models---classification).
-- For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-### Returns
-
-`useClassification` returns a [`ClassificationType`](../../06-api-reference/interfaces/ClassificationType.md) object containing:
-
-- `isReady` - Whether the model is loaded and ready to process images.
-- `isGenerating` - Whether the model is currently processing an image.
-- `error` - An error object if the model failed to load or encountered a runtime error.
-- `downloadProgress` - A value between 0 and 1 representing the download progress of the model binary.
-- `forward` - A function to run inference on an image.
-
-## Running the model
-
-To run the model, use the [`forward`](../../06-api-reference/interfaces/ClassificationType.md#forward) method. It accepts one argument — the image to classify. The image can be a remote URL, a local file URI, a base64-encoded image (whole URI or only raw base64), or a [`PixelData`](../../06-api-reference/interfaces/PixelData.md) object (raw RGB pixel buffer). The function returns a promise resolving to an object mapping label keys to their probabilities.
-
-:::info
-Images from external sources are stored in your application's temporary directory.
-:::
-
-## VisionCamera integration
-
-See the full guide: [VisionCamera Integration](./visioncamera-integration.md).
-
-## Example
-
-```typescript
-import { models, useClassification } from 'react-native-executorch';
-function App() {
-  const model = useClassification({
-    model: models.classification.efficientnet_v2_s(),
-  });
-
-  // ...
-  const imageUri = 'file:///Users/.../cute_puppy.png';
-
-  try {
-    const classesWithProbabilities = await model.forward(imageUri);
-
-    // Extract three classes with the highest probabilities
-    const topThreeClasses = Object.entries(classesWithProbabilities)
-      .sort(([, a], [, b]) => b - a)
-      .slice(0, 3)
-      .map(([label, score]) => ({ label, score }));
-  } catch (error) {
-    console.error(error);
-  }
-  // ...
-}
-```
-
-## Supported models
-
-| Model                                                                                                  | Number of classes | Class list                                                                                                                                              | Quantized |
-| ------------------------------------------------------------------------------------------------------ | ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | :-------: |
-| [efficientnet_v2_s](https://huggingface.co/software-mansion/react-native-executorch-efficientnet-v2-s) | 1000              | [ImageNet1k_v1](https://github.com/software-mansion/react-native-executorch/blob/main/packages/react-native-executorch/src/constants/classification.ts) |    ✅     |
diff --git a/docs/docs/03-hooks/02-computer-vision/useImageEmbeddings.md b/docs/docs/03-hooks/02-computer-vision/useImageEmbeddings.md
deleted file mode 100644
index 13947a96f2..0000000000
--- a/docs/docs/03-hooks/02-computer-vision/useImageEmbeddings.md
+++ /dev/null
@@ -1,108 +0,0 @@
----
-title: useImageEmbeddings
-keywords:
-  [
-    image embedding,
-    image embeddings,
-    embeddings,
-    react native,
-    executorch,
-    ai,
-    machine learning,
-    on-device,
-    mobile ai,
-    clip,
-  ]
-description: "Learn how to use image embeddings models in your React Native applications with React Native ExecuTorch's useImageEmbeddings hook."
----
-
-Image Embedding is the process of converting an image into a numerical representation. This representation can be used for tasks, such as classification, clustering and (using contrastive learning like e.g. CLIP model) image search.
-
-:::info
-It is recommended to use models provided by us, which are available at our [Hugging Face repository](https://huggingface.co/collections/software-mansion/image-embeddings-68d0eda599a9d37caaaf1ad0). You can also use [constants](https://github.com/software-mansion/react-native-executorch/blob/main/packages/react-native-executorch/src/constants/modelUrls.ts) shipped with our library.
-:::
-
-## API Reference
-
-- For detailed API Reference for `useImageEmbeddings` see: [`useImageEmbeddings` API Reference](../../06-api-reference/functions/useImageEmbeddings.md).
-- For all image embeddings models available out-of-the-box in React Native ExecuTorch see: [Image Embeddings Models](../../06-api-reference/index.md#models---image-embeddings).
-
-## High Level Overview
-
-```typescript
-import { models, useImageEmbeddings } from 'react-native-executorch';
-const model = useImageEmbeddings({
-  model: models.image_embedding.clip_vit_base_patch32_image(),
-});
-
-try {
-  const imageEmbedding = await model.forward('https://url-to-image.jpg');
-} catch (error) {
-  console.error(error);
-}
-```
-
-### Arguments
-
-`useImageEmbeddings` takes [`ImageEmbeddingsProps`](../../06-api-reference/interfaces/ImageEmbeddingsProps.md) that consists of:
-
-- `model` containing [`modelSource`](../../06-api-reference/interfaces/ImageEmbeddingsProps.md#modelsource).
-- An optional flag [`preventLoad`](../../06-api-reference/interfaces/ImageEmbeddingsProps.md#preventload) which prevents auto-loading of the model.
-
-You need more details? Check the following resources:
-
-- For detailed information about `useImageEmbeddings` arguments check this section: [`useImageEmbeddings` arguments](../../06-api-reference/functions/useImageEmbeddings.md#parameters).
-- For all image embeddings models available out-of-the-box in React Native ExecuTorch see: [Image Embeddings Models](../../06-api-reference/index.md#models---image-embeddings).
-- For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-### Returns
-
-`useImageEmbeddings` returns an object called `ImageEmbeddingsType` containing bunch of functions to interact with image embeddings models. To get more details please read: [`ImageEmbeddingsType` API Reference](../../06-api-reference/interfaces/ImageEmbeddingsType.md).
-
-## Running the model
-
-To run the model, use the [`forward`](../../06-api-reference/interfaces/ImageEmbeddingsType.md#forward) method. It accepts one argument — the image to embed. The image can be a remote URL, a local file URI, a base64-encoded image (whole URI or only raw base64), or a [`PixelData`](../../06-api-reference/interfaces/PixelData.md) object (raw RGB pixel buffer). The function returns a promise resolving to a `Float32Array` representing the embedding.
-
-## VisionCamera integration
-
-See the full guide: [VisionCamera Integration](./visioncamera-integration.md).
-
-## Example
-
-```typescript
-const dotProduct = (a: Float32Array, b: Float32Array) =>
-  a.reduce((sum, val, i) => sum + val * b[i], 0);
-
-const cosineSimilarity = (a: Float32Array, b: Float32Array) => {
-  const dot = dotProduct(a, b);
-  const normA = Math.sqrt(dotProduct(a, a));
-  const normB = Math.sqrt(dotProduct(b, b));
-  return dot / (normA * normB);
-};
-
-try {
-  // we assume you've provided catImage and dogImage
-  const catImageEmbedding = await model.forward(catImage);
-  const dogImageEmbedding = await model.forward(dogImage);
-
-  const similarity = cosineSimilarity(catImageEmbedding, dogImageEmbedding);
-
-  console.log(`Cosine similarity: ${similarity}`);
-} catch (error) {
-  console.error(error);
-}
-```
-
-## Supported models
-
-| Model                                                                                               | Language | Image size | Embedding dimensions | Description                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| --------------------------------------------------------------------------------------------------- | :------: | :--------: | :------------------: | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| [clip-vit-base-patch32-image](https://huggingface.co/collections/software-mansion/image-embeddings) | English  |  224×224   |         512          | CLIP (Contrastive Language-Image Pre-Training) is a neural network trained on a variety of (image, text) pairs. CLIP allows to embed images and text into the same vector space. This allows to find similar images as well as to implement image search. This is the image encoder part of the CLIP model. To embed text checkout [clip-vit-base-patch32-text](../01-natural-language-processing/useTextEmbeddings.md#supported-models). |
-
-**`Image size`** - The size of an image that the model takes as an input. Resize will happen automatically.
-
-**`Embedding Dimensions`** - The size of the output embedding vector. This is the number of dimensions in the vector representation of the input image.
-
-:::info
-For the supported models, the returned embedding vector is normalized, meaning that its length is equal to 1. This allows for easier comparison of vectors using cosine similarity, just calculate the dot product of two vectors to get the cosine similarity score.
-:::
diff --git a/docs/docs/03-hooks/02-computer-vision/useInstanceSegmentation.md b/docs/docs/03-hooks/02-computer-vision/useInstanceSegmentation.md
deleted file mode 100644
index 671bba5596..0000000000
--- a/docs/docs/03-hooks/02-computer-vision/useInstanceSegmentation.md
+++ /dev/null
@@ -1,191 +0,0 @@
----
-title: useInstanceSegmentation
----
-
-Instance segmentation is a computer vision technique that detects individual objects within an image and produces a per-pixel segmentation mask for each one. Unlike object detection (which only returns bounding boxes), instance segmentation provides precise object boundaries. React Native ExecuTorch offers a dedicated hook `useInstanceSegmentation` for this task.
-
-:::info
-It is recommended to use models provided by us, which are available at our [Hugging Face repository](https://huggingface.co/collections/software-mansion/instance-segmentation).
-:::
-
-## API Reference
-
-- For detailed API Reference for `useInstanceSegmentation` see: [`useInstanceSegmentation` API Reference](../../06-api-reference/functions/useInstanceSegmentation.md).
-
-## High Level Overview
-
-```typescript
-import { models, useInstanceSegmentation } from 'react-native-executorch';
-const model = useInstanceSegmentation({
-  model: models.instance_segmentation.yolo26n(),
-});
-
-const imageUri = 'file:///Users/.../photo.jpg';
-
-try {
-  const instances = await model.forward(imageUri);
-  // instances is an array of SegmentedInstance objects
-} catch (error) {
-  console.error(error);
-}
-```
-
-### Arguments
-
-`useInstanceSegmentation` takes [`InstanceSegmentationProps`](../../06-api-reference/interfaces/InstanceSegmentationProps.md) that consists of:
-
-- `model` - An object containing:
-  - `modelName` - The name of a built-in model. See [`InstanceSegmentationModelName`](../../06-api-reference/type-aliases/InstanceSegmentationModelName.md) for the list of supported models.
-  - `modelSource` - The location of the model binary (a URL or a bundled resource).
-- An optional flag [`preventLoad`](../../06-api-reference/interfaces/InstanceSegmentationProps.md#preventload) which prevents auto-loading of the model.
-
-The hook is generic over the model config — TypeScript automatically infers the correct label type based on the `modelName` you provide. No explicit generic parameter is needed.
-
-For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-### Returns
-
-`useInstanceSegmentation` returns an [`InstanceSegmentationType`](../../06-api-reference/interfaces/InstanceSegmentationType.md) object containing:
-
-- `isReady` - Whether the model is loaded and ready to process images.
-- `isGenerating` - Whether the model is currently processing an image.
-- `error` - An error object if the model failed to load or encountered a runtime error.
-- `downloadProgress` - A value between 0 and 1 representing the download progress of the model binary.
-- `forward` - A function to run inference on an image.
-- `getAvailableInputSizes` - Returns the available input sizes for the loaded model, or `undefined` if the model accepts only a single input size. Use this to populate UI controls for selecting the input resolution.
-- `runOnFrame` - A synchronous worklet function for real-time VisionCamera frame processing. See [VisionCamera Integration](./visioncamera-integration.md) for usage.
-
-## Running the model
-
-To run the model, use the [`forward`](../../06-api-reference/interfaces/InstanceSegmentationType.md#forward) method. It accepts two arguments:
-
-- `imageSource` (required) - The image to process. Can be a remote URL, a local file URI, a base64-encoded image (whole URI or only raw base64), or a [`PixelData`](../../06-api-reference/interfaces/PixelData.md) object (raw RGB pixel buffer).
-- `options` (optional) - An [`InstanceSegmentationOptions`](../../06-api-reference/interfaces/InstanceSegmentationOptions.md) object with the following fields:
-  - `confidenceThreshold` - Minimum confidence score for including instances. Defaults to the model's configured threshold (typically `0.5`).
-  - `iouThreshold` - IoU threshold for non-maximum suppression. Defaults to `0.5`.
-  - `maxInstances` - Maximum number of instances to return. Defaults to `100`.
-  - `classesOfInterest` - Filter results to include only specific classes (e.g. `['PERSON', 'CAR']`). Use label names from the model's label enum (e.g. [`CocoLabelYolo`](../../06-api-reference/enumerations/CocoLabelYolo.md) for YOLO models).
-  - `returnMaskAtOriginalResolution` - Whether to resize masks to the original image resolution. Defaults to `true`.
-  - `inputSize` - Input size for the model (e.g. `384`, `512`, `640`). Must be one of the model's available input sizes. If the model has only one forward method (i.e. no `availableInputSizes` configured), this option is not needed.
-
-`forward` returns a promise resolving to an array of [`SegmentedInstance`](../../06-api-reference/interfaces/SegmentedInstance.md) objects, each containing:
-
-- `bbox` - A [`Bbox`](../../06-api-reference/interfaces/Bbox.md) object with `x1`, `y1` (top-left corner) and `x2`, `y2` (bottom-right corner) coordinates in the original image's pixel space.
-- `label` - The class name of the detected instance, typed to the label map of the chosen model.
-- `score` - The confidence score of the detection, between 0 and 1.
-- `mask` - A `Uint8Array` binary mask (0 or 1) representing the instance's segmentation.
-- `maskWidth` - Width of the mask array.
-- `maskHeight` - Height of the mask array.
-
-## Example
-
-```typescript
-import { models, useInstanceSegmentation } from 'react-native-executorch';
-function App() {
-  const model = useInstanceSegmentation({
-    model: models.instance_segmentation.yolo26n(),
-  });
-
-  const handleSegment = async () => {
-    if (!model.isReady) return;
-
-    const imageUri = 'file:///Users/.../photo.jpg';
-
-    try {
-      const instances = await model.forward(imageUri, {
-        confidenceThreshold: 0.5,
-        inputSize: 640,
-      });
-
-      for (const instance of instances) {
-        console.log('Label:', instance.label);
-        console.log('Score:', instance.score);
-        console.log('Bounding box:', instance.bbox);
-        console.log('Mask size:', instance.maskWidth, 'x', instance.maskHeight);
-      }
-    } catch (error) {
-      console.error(error);
-    }
-  };
-
-  // ...
-}
-```
-
-## VisionCamera integration
-
-See the full guide: [VisionCamera Integration](./visioncamera-integration.md).
-
-## Supported models
-
-:::info
-YOLO models use the [`CocoLabelYolo`](../../06-api-reference/enumerations/CocoLabelYolo.md) enum (80 classes, 0-indexed), which differs from [`CocoLabel`](../../06-api-reference/enumerations/CocoLabel.md) used by RF-DETR and SSDLite object detection models (91 classes, 1-indexed). When filtering with `classesOfInterest`, use the label names from `CocoLabelYolo`.
-:::
-
-| Model           | Number of classes | Class list                                                          | Available input sizes |
-| --------------- | ----------------- | ------------------------------------------------------------------- | --------------------- |
-| yolo26n-seg     | 80                | [COCO (YOLO)](../../06-api-reference/enumerations/CocoLabelYolo.md) | 384, 512, 640         |
-| yolo26s-seg     | 80                | [COCO (YOLO)](../../06-api-reference/enumerations/CocoLabelYolo.md) | 384, 512, 640         |
-| yolo26m-seg     | 80                | [COCO (YOLO)](../../06-api-reference/enumerations/CocoLabelYolo.md) | 384, 512, 640         |
-| yolo26l-seg     | 80                | [COCO (YOLO)](../../06-api-reference/enumerations/CocoLabelYolo.md) | 384, 512, 640         |
-| yolo26x-seg     | 80                | [COCO (YOLO)](../../06-api-reference/enumerations/CocoLabelYolo.md) | 384, 512, 640         |
-| rfdetr-nano-seg | 91                | [COCO](../../06-api-reference/enumerations/CocoLabel.md)            | 312 (fixed)           |
-| fastsam-s       | 1                 | [FastSAMLabel](../../06-api-reference/enumerations/FastSAMLabel.md) | 640 (fixed)           |
-| fastsam-x       | 1                 | [FastSAMLabel](../../06-api-reference/enumerations/FastSAMLabel.md) | 640 (fixed)           |
-
-:::tip
-FastSAM models are class-agnostic, so they segment every instance without classifying it. That makes them a good fit for promptable selection workflows.
-:::
-
-## Promptable selection
-
-Instance segmentation models return a list of segmented instances. After `forward()`, you can use prompt-based selectors to pick the instance you want. Use point selection for tap-to-select or cutout tools, box selection for drag-to-outline workflows, and text selection for search or describe-it-in-words flows. For example, a photo-editing app can use point selection to isolate a person, create custom sticker or background-removal flow can use box selection, and a shopping app can use text selection to find a product by name or description:
-
-1. Load an instance segmentation model with `useInstanceSegmentation`.
-2. Run `forward(image)` once to get the detected instances.
-3. Use a selector to pick the instance or instances matching the user's prompt.
-4. Re-run the selector when the prompt changes; you do not need to call `forward` again unless the image changes.
-
-```typescript
-import {
-  models,
-  useInstanceSegmentation,
-  selectByPoint,
-  selectByBox,
-  selectByText,
-} from 'react-native-executorch';
-const model = useInstanceSegmentation({
-  model: models.instance_segmentation.fastsam_x(),
-});
-
-try {
-  const instances = await model.forward(imageUri);
-
-  // Point: the smallest instance whose mask covers (x, y).
-  const pointMatch = selectByPoint(instances, x, y);
-  console.log('point match:', pointMatch?.bbox);
-
-  // Box: the instance with highest IoU with the prompt box.
-  const boxMatch = selectByBox(instances, { x1, y1, x2, y2 });
-  console.log('box match:', boxMatch?.bbox);
-
-  // Text: highest cosine similarity between text and per-instance image
-  // embeddings (you must provide the embeddings, e.g. with CLIP).
-  const textMatch = selectByText(instances, instanceEmbeddings, textEmbedding);
-  console.log('text match:', textMatch?.bbox);
-} catch (error) {
-  console.error(error);
-}
-```
-
-For detailed API Reference for `selectByPoint`, `selectByBox`, and `selectByText` see their respective documentation pages:
-
-- [`selectByPoint` API Reference](../../06-api-reference/functions/selectByPoint.md)
-- [`selectByBox` API Reference](../../06-api-reference/functions/selectByBox.md)
-- [`selectByText` API Reference](../../06-api-reference/functions/selectByText.md)
-
-:::tip
-Use FastSAM-S for faster performance on simple images with non-overlapping
-instances and FastSAM-X for better accuracy on complex scenes with many
-overlapping objects.
-:::
diff --git a/docs/docs/03-hooks/02-computer-vision/useOCR.md b/docs/docs/03-hooks/02-computer-vision/useOCR.md
deleted file mode 100644
index eaf9798fe5..0000000000
--- a/docs/docs/03-hooks/02-computer-vision/useOCR.md
+++ /dev/null
@@ -1,121 +0,0 @@
----
-title: useOCR
----
-
-Optical character recognition (OCR) is a computer vision technique that detects and recognizes text within the image. It's commonly used to convert different types of documents, such as scanned paper documents, PDF files, or images captured by a digital camera, into editable and searchable data.
-
-:::info
-It is recommended to use models provided by us, which are available at our [Hugging Face repository](https://huggingface.co/collections/software-mansion/ocr-68d0eb320ae6d20b5f901ea9). You can also use [constants](https://github.com/software-mansion/react-native-executorch/blob/main/packages/react-native-executorch/src/constants/modelUrls.ts) shipped with our library.
-:::
-
-## API Reference
-
-- For detailed API Reference for `useOCR` see: [`useOCR` API Reference](../../06-api-reference/functions/useOCR.md).
-- For all alphabets available in ocr out-of-the-box in React Native ExecuTorch see: [OCR Supported Alphabets](../../06-api-reference/index.md#ocr-supported-alphabets).
-
-## High Level Overview
-
-```tsx
-import { models, useOCR } from 'react-native-executorch';
-function App() {
-  const model = useOCR({ model: models.ocr.craft({ language: 'en' }) });
-
-  // ...
-  for (const ocrDetection of await model.forward('https://url-to-image.jpg')) {
-    console.log('Bounding box: ', ocrDetection.bbox);
-    console.log('Bounding label: ', ocrDetection.text);
-    console.log('Bounding score: ', ocrDetection.score);
-  }
-  // ...
-}
-```
-
-### Arguments
-
-`useOCR` takes [`OCRProps`](../../06-api-reference/interfaces/OCRProps.md) that consists of:
-
-- `model` containing [`detectorSource`](../../06-api-reference/interfaces/OCRProps.md#detectorsource), [`recognizerSource`](../../06-api-reference/interfaces/OCRProps.md#recognizersource), and [`language`](../../06-api-reference/interfaces/OCRProps.md#language).
-- An optional flag [`preventLoad`](../../06-api-reference/interfaces/OCRProps.md#preventload) which prevents auto-loading of the model.
-
-You need more details? Check the following resources:
-
-- For detailed information about `useOCR` arguments check this section: [`useOCR` arguments](../../06-api-reference/functions/useOCR.md#parameters).
-- For all alphabets available in ocr out-of-the-box in React Native ExecuTorch see: [OCR Supported Alphabets](../../06-api-reference/index.md#ocr-supported-alphabets).
-- For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-### Returns
-
-`useOCR` returns an object called `OCRType` containing bunch of functions to interact with OCR models. To get more details please read: [`OCRType` API Reference](../../06-api-reference/interfaces/OCRType.md).
-
-## Running the model
-
-To run the model, use the [`forward`](../../06-api-reference/interfaces/OCRType.md#forward) method. It accepts one argument — the image to recognize. The image can be a remote URL, a local file URI, a base64-encoded image (whole URI or only raw base64), or a [`PixelData`](../../06-api-reference/interfaces/PixelData.md) object (raw RGB pixel buffer). The function returns an array of [`OCRDetection`](../../06-api-reference/interfaces/OCRDetection.md) objects, each containing the bounding box, recognized text, and confidence score.
-
-## VisionCamera integration
-
-See the full guide: [VisionCamera Integration](./visioncamera-integration.md).
-
-## Detection object
-
-The detection object is specified as follows:
-
-```typescript
-interface Bbox {
-  x1: number;
-  y1: number;
-  x2: number;
-  y2: number;
-}
-
-interface OCRDetection {
-  bbox: Bbox;
-  text: string;
-  score: number;
-}
-```
-
-The `bbox` property contains the axis-aligned bounding box of the detected text region. `x1`/`y1` is the top-left corner and `x2`/`y2` is the bottom-right corner.
-The `text` property contains the text recognized within detected text region. The `score` represents the confidence score of the recognized text.
-
-## Example
-
-```tsx
-import { models, useOCR } from 'react-native-executorch';
-function App() {
-  const model = useOCR({ model: models.ocr.craft({ language: 'en' }) });
-
-  const runModel = async () => {
-    const ocrDetections = await model.forward('https://url-to-image.jpg');
-
-    for (const ocrDetection of ocrDetections) {
-      console.log('Bounding box: ', ocrDetection.bbox);
-      console.log('Bounding text: ', ocrDetection.text);
-      console.log('Bounding score: ', ocrDetection.score);
-    }
-  };
-}
-```
-
-## Alphabet-Specific Recognizers
-
-Each supported alphabet requires its own recognizer model. The built-in constants, such as `RECOGNIZER_LATIN_CRNN` or `RECOGNIZER_CYRILLIC_CRNN`, point to specific models trained for a particular alphabet.
-
-> For example:
->
-> - To recognize text in languages using the **Latin** alphabet (like Polish, or German), use:
->   - `RECOGNIZER_LATIN_CRNN`
-> - To recognize text in languages using the **Cyrillic** alphabet (like Russian or Ukrainian), use:
->   - `RECOGNIZER_CYRILLIC_CRNN`
-
-You need to make sure the recognizer model you pass in [`recognizerSource`](../../06-api-reference/interfaces/OCRProps.md#recognizersource) matches the alphabet of the [`language`](../../06-api-reference/interfaces/OCRProps.md#language) you specify.
-
-## Supported languages
-
-For all alphabets available in ocr out-of-the-box in React Native ExecuTorch see: [OCR Supported Alphabets](../../06-api-reference/index.md#ocr-supported-alphabets).
-
-## Supported models
-
-| Model                                             |    Type    |
-| ------------------------------------------------- | :--------: |
-| [CRAFT](https://github.com/clovaai/CRAFT-pytorch) |  Detector  |
-| [CRNN](https://www.jaided.ai/easyocr/modelhub/)   | Recognizer |
diff --git a/docs/docs/03-hooks/02-computer-vision/useObjectDetection.md b/docs/docs/03-hooks/02-computer-vision/useObjectDetection.md
deleted file mode 100644
index 317c00c3b7..0000000000
--- a/docs/docs/03-hooks/02-computer-vision/useObjectDetection.md
+++ /dev/null
@@ -1,128 +0,0 @@
----
-title: useObjectDetection
----
-
-Object detection is a computer vision technique that identifies and locates objects within images. Unlike image classification, which assigns a single label to the whole image, object detection returns a list of detected objects — each with a bounding box, a class label, and a confidence score. React Native ExecuTorch offers a dedicated hook `useObjectDetection` for this task.
-
-:::info
-It is recommended to use models provided by us, which are available at our [Hugging Face repository](https://huggingface.co/collections/software-mansion/object-detection-68d0ea936cd0906843cbba7d). You can also use [constants](https://github.com/software-mansion/react-native-executorch/blob/main/packages/react-native-executorch/src/constants/modelUrls.ts) shipped with our library.
-:::
-
-## API Reference
-
-- For detailed API Reference for `useObjectDetection` see: [`useObjectDetection` API Reference](../../06-api-reference/functions/useObjectDetection.md).
-- For all object detection models available out-of-the-box in React Native ExecuTorch see: [Object Detection Models](../../06-api-reference/index.md#models---object-detection).
-
-## High Level Overview
-
-```typescript
-import { models, useObjectDetection } from 'react-native-executorch';
-const model = useObjectDetection({
-  model: models.object_detection.ssdlite_320_mobilenet_v3_large(),
-});
-
-const imageUri = 'file:///Users/.../photo.jpg';
-
-try {
-  const detections = await model.forward(imageUri);
-  // detections is an array of Detection objects
-} catch (error) {
-  console.error(error);
-}
-```
-
-### Arguments
-
-`useObjectDetection` takes [`ObjectDetectionProps`](../../06-api-reference/interfaces/ObjectDetectionProps.md) that consists of:
-
-- `model` - An object containing:
-  - `modelName` - The name of a built-in model. See [`ObjectDetectionModelSources`](../../06-api-reference/interfaces/ObjectDetectionProps.md) for the list of supported models.
-  - `modelSource` - The location of the model binary (a URL or a bundled resource).
-- An optional flag [`preventLoad`](../../06-api-reference/interfaces/ObjectDetectionProps.md#preventload) which prevents auto-loading of the model.
-
-The hook is generic over the model config — TypeScript automatically infers the correct label type based on the `modelName` you provide. No explicit generic parameter is needed.
-
-You need more details? Check the following resources:
-
-- For detailed information about `useObjectDetection` arguments check this section: [`useObjectDetection` arguments](../../06-api-reference/functions/useObjectDetection.md#parameters).
-- For all object detection models available out-of-the-box in React Native ExecuTorch see: [Object Detection Models](../../06-api-reference/index.md#models---object-detection).
-- For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-### Returns
-
-`useObjectDetection` returns an [`ObjectDetectionType`](../../06-api-reference/interfaces/ObjectDetectionType.md) object containing:
-
-- `isReady` - Whether the model is loaded and ready to process images.
-- `isGenerating` - Whether the model is currently processing an image.
-- `error` - An error object if the model failed to load or encountered a runtime error.
-- `downloadProgress` - A value between 0 and 1 representing the download progress of the model binary.
-- `forward` - A function to run inference on an image.
-- `getAvailableInputSizes` - A function that returns available input sizes for multi-method models (YOLO). Returns `undefined` for single-method models.
-- `runOnFrame` - A synchronous worklet function for real-time VisionCamera frame processing. See [VisionCamera Integration](./visioncamera-integration.md) for usage.
-
-## Running the model
-
-To run the model, use the [`forward`](../../06-api-reference/interfaces/ObjectDetectionType.md#forward) method. It accepts two arguments:
-
-- `input` (required) - The image to process. Can be a remote URL, a local file URI, a base64-encoded image (whole URI or only raw base64), or a [`PixelData`](../../06-api-reference/interfaces/PixelData.md) object (raw RGB pixel buffer).
-- `options` (optional) - An [`ObjectDetectionOptions`](../../06-api-reference/interfaces/ObjectDetectionOptions.md) object with the following properties:
-  - `detectionThreshold` (optional) - A number between 0 and 1 representing the minimum confidence score. Defaults to model-specific value (typically `0.7`).
-  - `iouThreshold` (optional) - IoU threshold for non-maximum suppression (0-1). Defaults to model-specific value (typically `0.55`).
-  - `inputSize` (optional) - For multi-method models like YOLO, specify the input resolution (`384`, `512`, or `640`). Defaults to `384` for YOLO models.
-  - `classesOfInterest` (optional) - Array of class labels to filter detections. Only detections matching these classes will be returned.
-
-`forward` returns a promise resolving to an array of [`Detection`](../../06-api-reference/interfaces/Detection.md) objects, each containing:
-
-- `bbox` - A [`Bbox`](../../06-api-reference/interfaces/Bbox.md) object with `x1`, `y1` (top-left corner) and `x2`, `y2` (bottom-right corner) coordinates in the original image's pixel space.
-- `label` - The class name of the detected object, typed to the label map of the chosen model.
-- `score` - The confidence score of the detection, between 0 and 1.
-
-## Example
-
-```typescript
-import { models, useObjectDetection } from 'react-native-executorch';
-function App() {
-  const model = useObjectDetection({
-    model: models.object_detection.yolo26n(),
-  });
-
-  const handleDetect = async () => {
-    if (!model.isReady) return;
-
-    const imageUri = 'file:///Users/.../photo.jpg';
-
-    try {
-      const detections = await model.forward(imageUri, {
-        detectionThreshold: 0.5,
-        inputSize: 640,
-      });
-
-      console.log('Detected:', detections.length, 'objects');
-    } catch (error) {
-      console.error(error);
-    }
-  };
-
-  // ...
-}
-```
-
-## VisionCamera integration
-
-See the full guide: [VisionCamera Integration](./visioncamera-integration.md).
-
-## Supported models
-
-| Model                                                                                                                         | Number of classes | Class list                                                    | Multi-size Support  |
-| ----------------------------------------------------------------------------------------------------------------------------- | ----------------- | ------------------------------------------------------------- | ------------------- |
-| [SSDLite320 MobileNetV3 Large](https://huggingface.co/software-mansion/react-native-executorch-ssdlite320-mobilenet-v3-large) | 91                | [COCO](../../06-api-reference/enumerations/CocoLabel.md)      | No (fixed: 320×320) |
-| [RF-DETR Nano](https://huggingface.co/software-mansion/react-native-executorch-rf-detr-nano)                                  | 80                | [COCO](../../06-api-reference/enumerations/CocoLabel.md)      | No (fixed: 384×384) |
-| [YOLO26N](https://huggingface.co/software-mansion/react-native-executorch-yolo26)                                             | 80                | [COCO YOLO](../../06-api-reference/enumerations/CocoLabel.md) | Yes (384/512/640)   |
-| [YOLO26S](https://huggingface.co/software-mansion/react-native-executorch-yolo26)                                             | 80                | [COCO YOLO](../../06-api-reference/enumerations/CocoLabel.md) | Yes (384/512/640)   |
-| [YOLO26M](https://huggingface.co/software-mansion/react-native-executorch-yolo26)                                             | 80                | [COCO YOLO](../../06-api-reference/enumerations/CocoLabel.md) | Yes (384/512/640)   |
-| [YOLO26L](https://huggingface.co/software-mansion/react-native-executorch-yolo26)                                             | 80                | [COCO YOLO](../../06-api-reference/enumerations/CocoLabel.md) | Yes (384/512/640)   |
-| [YOLO26X](https://huggingface.co/software-mansion/react-native-executorch-yolo26)                                             | 80                | [COCO YOLO](../../06-api-reference/enumerations/CocoLabel.md) | Yes (384/512/640)   |
-
-:::tip
-YOLO models support multiple input sizes (384px, 512px, 640px). Smaller sizes are faster but less accurate, while larger sizes are more accurate but slower. Choose based on your speed/accuracy requirements.
-:::
diff --git a/docs/docs/03-hooks/02-computer-vision/usePoseEstimation.md b/docs/docs/03-hooks/02-computer-vision/usePoseEstimation.md
deleted file mode 100644
index 465a0ab6a6..0000000000
--- a/docs/docs/03-hooks/02-computer-vision/usePoseEstimation.md
+++ /dev/null
@@ -1,138 +0,0 @@
----
-title: usePoseEstimation
----
-
-Pose estimation is a computer vision technique that detects human bodies in an image and locates a fixed set of keypoints (e.g. nose, shoulders, knees) for each detected person. Unlike object detection, which produces a class label and a bounding box, pose estimation produces a structured set of named keypoints per person. React Native ExecuTorch offers a dedicated hook `usePoseEstimation` for this task.
-
-:::info
-It is recommended to use models provided by us, which are available at our [Hugging Face repository](https://huggingface.co/software-mansion/react-native-executorch-yolo26-pose). You can also use [constants](https://github.com/software-mansion/react-native-executorch/blob/main/packages/react-native-executorch/src/constants/modelUrls.ts) shipped with our library.
-:::
-
-## API Reference
-
-- For detailed API Reference for `usePoseEstimation` see: [`usePoseEstimation` API Reference](../../06-api-reference/functions/usePoseEstimation.md).
-- For all pose estimation models available out-of-the-box in React Native ExecuTorch see: [Pose Estimation Models](../../06-api-reference/index.md#models---pose-estimation).
-
-## High Level Overview
-
-```typescript
-import { models, usePoseEstimation } from 'react-native-executorch';
-const model = usePoseEstimation({
-  model: models.pose_estimation.yolo26n(),
-});
-
-const imageUri = 'file:///Users/.../photo.jpg';
-
-try {
-  const detections = await model.forward(imageUri);
-  // detections is an array of PersonKeypoints, keyed by name (e.g. detections[0].NOSE)
-} catch (error) {
-  console.error(error);
-}
-```
-
-### Arguments
-
-`usePoseEstimation` takes [`PoseEstimationProps`](../../06-api-reference/interfaces/PoseEstimationProps.md) that consists of:
-
-- `model` - An object containing:
-  - `modelName` - The name of a built-in model. See [`PoseEstimationModelSources`](../../06-api-reference/interfaces/PoseEstimationProps.md) for the list of supported models.
-  - `modelSource` - The location of the model binary (a URL or a bundled resource).
-- An optional flag [`preventLoad`](../../06-api-reference/interfaces/PoseEstimationProps.md#preventload) which prevents auto-loading of the model.
-
-The hook is generic over the model config — TypeScript automatically infers the correct keypoint type based on the `modelName` you provide. No explicit generic parameter is needed.
-
-You need more details? Check the following resources:
-
-- For detailed information about `usePoseEstimation` arguments check this section: [`usePoseEstimation` arguments](../../06-api-reference/functions/usePoseEstimation.md#parameters).
-- For all pose estimation models available out-of-the-box in React Native ExecuTorch see: [Pose Estimation Models](../../06-api-reference/index.md#models---pose-estimation).
-- For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-### Returns
-
-`usePoseEstimation` returns a [`PoseEstimationType`](../../06-api-reference/interfaces/PoseEstimationType.md) object containing:
-
-- `isReady` - Whether the model is loaded and ready to process images.
-- `isGenerating` - Whether the model is currently processing an image.
-- `error` - An error object if the model failed to load or encountered a runtime error.
-- `downloadProgress` - A value between 0 and 1 representing the download progress of the model binary.
-- `forward` - A function to run inference on an image.
-- `getAvailableInputSizes` - A function that returns available input sizes for multi-method models (YOLO). Returns `undefined` for single-method models.
-- `runOnFrame` - A synchronous worklet function for real-time VisionCamera frame processing. See [VisionCamera Integration](./visioncamera-integration.md) for usage.
-
-## Running the model
-
-To run the model, use the [`forward`](../../06-api-reference/interfaces/PoseEstimationType.md#forward) method. It accepts two arguments:
-
-- `input` (required) - The image to process. Can be a remote URL, a local file URI, a base64-encoded image (whole URI or only raw base64), or a [`PixelData`](../../06-api-reference/interfaces/PixelData.md) object (raw RGB pixel buffer).
-- `options` (optional) - A [`PoseEstimationOptions`](../../06-api-reference/interfaces/PoseEstimationOptions.md) object with the following properties:
-  - `detectionThreshold` (optional) - A number between 0 and 1 representing the minimum confidence score for a detected person. Defaults to model-specific value (typically `0.5`).
-  - `keypointThreshold` (optional) - Per-keypoint visibility threshold (0-1). Keypoints whose model-reported visibility falls below this are emitted as `(-1, -1)` so consumers can skip them. Defaults to model-specific value.
-  - `inputSize` (optional) - For multi-method models like YOLO, specify the input resolution (`384`, `512`, or `640`). Defaults to `384` for YOLO models.
-
-`forward` returns a promise resolving to an array of [`PersonKeypoints`](../../06-api-reference/type-aliases/PersonKeypoints.md) — one entry per detected person. Each entry is an object keyed by the model's keypoint names (typed against the model's keypoint map), where each value is a [`Keypoint`](../../06-api-reference/interfaces/Keypoint.md) with:
-
-- `x` - The x coordinate in the original image's pixel space.
-- `y` - The y coordinate in the original image's pixel space.
-
-:::info
-Keypoints whose visibility falls below `keypointThreshold` (or that the model considers off-image) are returned as `{ x: -1, y: -1 }`. Filter them out before drawing — e.g. `if (kp.x < 0 || kp.y < 0) skip;`.
-:::
-
-For example, with a COCO-keypoint model:
-
-```typescript
-const detections = await model.forward(imageUri);
-const firstPerson = detections[0];
-firstPerson.NOSE; // { x, y }
-firstPerson.LEFT_SHOULDER; // { x, y }
-```
-
-The keypoint names available on each person are determined by the model's keypoint map and are checked at compile time.
-
-## Example
-
-```typescript
-import { models, usePoseEstimation } from 'react-native-executorch';
-function App() {
-  const model = usePoseEstimation({
-    model: models.pose_estimation.yolo26n(),
-  });
-
-  const handleDetect = async () => {
-    if (!model.isReady) return;
-
-    const imageUri = 'file:///Users/.../photo.jpg';
-
-    try {
-      const detections = await model.forward(imageUri, {
-        detectionThreshold: 0.5,
-        inputSize: 640,
-      });
-
-      console.log('Detected:', detections.length, 'people');
-      for (const person of detections) {
-        console.log('Nose at', person.NOSE.x, person.NOSE.y);
-      }
-    } catch (error) {
-      console.error(error);
-    }
-  };
-
-  // ...
-}
-```
-
-## VisionCamera integration
-
-See the full guide: [VisionCamera Integration](./visioncamera-integration.md).
-
-## Supported models
-
-| Model                                                                                       | Number of keypoints | Keypoint list                                               | Multi-size Support |
-| ------------------------------------------------------------------------------------------- | ------------------- | ----------------------------------------------------------- | ------------------ |
-| [YOLO26N-Pose](https://huggingface.co/software-mansion/react-native-executorch-yolo26-pose) | 17                  | [COCO](../../06-api-reference/enumerations/CocoKeypoint.md) | Yes (384/512/640)  |
-
-:::tip
-YOLO models support multiple input sizes (384px, 512px, 640px). Smaller sizes are faster but less accurate, while larger sizes are more accurate but slower. Choose based on your speed/accuracy requirements.
-:::
diff --git a/docs/docs/03-hooks/02-computer-vision/useSemanticSegmentation.md b/docs/docs/03-hooks/02-computer-vision/useSemanticSegmentation.md
deleted file mode 100644
index dd059cc4b6..0000000000
--- a/docs/docs/03-hooks/02-computer-vision/useSemanticSegmentation.md
+++ /dev/null
@@ -1,127 +0,0 @@
----
-title: useSemanticSegmentation
----
-
-Semantic semantic segmentation, akin to image classification, tries to assign the content of the image to one of the predefined classes. However, in case of segmentation this classification is done on a per-pixel basis, so as the result the model provides an image-sized array of scores for each of the classes. You can then use this information to detect objects on a per-pixel basis. React Native ExecuTorch offers a dedicated hook `useSemanticSegmentation` for this task.
-
-:::info
-It is recommended to use models provided by us which are available at our [Hugging Face repository](https://huggingface.co/collections/software-mansion/semantic-segmentation-68d5291bdf4a30bee0220f4f), you can also use [constants](https://github.com/software-mansion/react-native-executorch/blob/main/packages/react-native-executorch/src/constants/modelUrls.ts) shipped with our library.
-:::
-
-## API Reference
-
-- For detailed API Reference for `useSemanticSegmentation` see: [`useSemanticSegmentation` API Reference](../../06-api-reference/functions/useSemanticSegmentation.md).
-- For all semantic segmentation models available out-of-the-box in React Native ExecuTorch see: [Semantic Segmentation Models](../../06-api-reference/index.md#models---semantic-segmentation).
-
-## High Level Overview
-
-```typescript
-import { models, useSemanticSegmentation } from 'react-native-executorch';
-const model = useSemanticSegmentation({
-  model: models.semantic_segmentation.deeplab_v3_resnet50(),
-});
-
-const imageUri = 'file::///Users/.../cute_cat.png';
-
-try {
-  const result = await model.forward(imageUri);
-  // result.ARGMAX is an Int32Array of per-pixel class indices
-} catch (error) {
-  console.error(error);
-}
-```
-
-### Arguments
-
-`useSemanticSegmentation` takes [`SemanticSegmentationProps`](../../06-api-reference/interfaces/SemanticSegmentationProps.md) that consists of:
-
-- `model` - An object containing:
-  - `modelName` - The name of a built-in model. See [`SemanticSegmentationModelSources`](../../06-api-reference/type-aliases/SemanticSegmentationModelSources.md) for the list of supported models.
-  - `modelSource` - The location of the model binary (a URL or a bundled resource).
-- An optional flag [`preventLoad`](../../06-api-reference/interfaces/SemanticSegmentationProps.md#preventload) which prevents auto-loading of the model.
-
-The hook is generic over the model config — TypeScript automatically infers the correct label type based on the `modelName` you provide. No explicit generic parameter is needed.
-
-You need more details? Check the following resources:
-
-- For detailed information about `useSemanticSegmentation` arguments check this section: [`useSemanticSegmentation` arguments](../../06-api-reference/functions/useSemanticSegmentation.md#parameters).
-- For all semantic segmentation models available out-of-the-box in React Native ExecuTorch see: [Semantic Segmentation Models](../../06-api-reference/index.md#models---semantic-segmentation).
-- For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-### Returns
-
-`useSemanticSegmentation` returns an [`SemanticSegmentationType`](../../06-api-reference/interfaces/SemanticSegmentationType.md) object containing:
-
-- `isReady` - Whether the model is loaded and ready to process images.
-- `isGenerating` - Whether the model is currently processing an image.
-- `error` - An error object if the model failed to load or encountered a runtime error.
-- `downloadProgress` - A value between 0 and 1 representing the download progress of the model binary.
-- `forward` - A function to run inference on an image.
-
-## Running the model
-
-To run the model, use the [`forward`](../../06-api-reference/interfaces/SemanticSegmentationType.md#forward) method. It accepts three arguments:
-
-- [`input`](../../06-api-reference/interfaces/SemanticSegmentationType.md#forward) (required) - The image to segment. Can be a remote URL, a local file URI, a base64-encoded image (whole URI or only raw base64), or a [`PixelData`](../../06-api-reference/interfaces/PixelData.md) object (raw RGB pixel buffer).
-- [`classesOfInterest`](../../06-api-reference/interfaces/SemanticSegmentationType.md#forward) (optional) - An array of label keys indicating which per-class probability masks to include in the output. Defaults to `[]` (no class masks). The `ARGMAX` map is always returned regardless of this parameter.
-- [`resizeToInput`](../../06-api-reference/interfaces/SemanticSegmentationType.md#forward) (optional) - Whether to resize the output masks to the original input image dimensions. Defaults to `true`. If `false`, returns the raw model output dimensions (e.g. 224x224 for `DEEPLAB_V3_RESNET50`).
-
-:::tip
-Setting `resizeToInput` to `false` will make `forward` faster.
-:::
-
-`forward` returns a promise resolving to an object containing:
-
-- `ARGMAX` - An `Int32Array` where each element is the class index with the highest probability for that pixel.
-- For each label included in `classesOfInterest`, a `Float32Array` of per-pixel probabilities for that class.
-
-The return type is fully typed — TypeScript narrows it based on the labels you pass in `classesOfInterest`.
-
-## Example
-
-```typescript
-import {
-  models,
-  useSemanticSegmentation,
-  DeeplabLabel,
-} from 'react-native-executorch';
-function App() {
-  const model = useSemanticSegmentation({
-    model: models.semantic_segmentation.deeplab_v3_resnet50(),
-  });
-
-  const handleSegment = async () => {
-    if (!model.isReady) return;
-
-    const imageUri = 'file::///Users/.../cute_cat.png';
-
-    try {
-      const result = await model.forward(imageUri, ['CAT', 'PERSON'], true);
-
-      // result.ARGMAX — Int32Array of per-pixel class indices
-      // result.CAT — Float32Array of per-pixel probabilities for CAT
-      // result.PERSON — Float32Array of per-pixel probabilities for PERSON
-    } catch (error) {
-      console.error(error);
-    }
-  };
-
-  // ...
-}
-```
-
-## VisionCamera integration
-
-See the full guide: [VisionCamera Integration](./visioncamera-integration.md).
-
-## Supported models
-
-| Model                                                                                                       | Number of classes | Class list                                                                                | Quantized |
-| ----------------------------------------------------------------------------------------------------------- | ----------------- | ----------------------------------------------------------------------------------------- | :-------: |
-| [deeplab-v3-resnet50](https://huggingface.co/software-mansion/react-native-executorch-deeplab-v3)           | 21                | [DeeplabLabel](../../06-api-reference/enumerations/DeeplabLabel.md)                       |    ✅     |
-| [deeplab-v3-resnet101](https://huggingface.co/software-mansion/react-native-executorch-deeplab-v3)          | 21                | [DeeplabLabel](../../06-api-reference/enumerations/DeeplabLabel.md)                       |    ✅     |
-| [deeplab-v3-mobilenet-v3-large](https://huggingface.co/software-mansion/react-native-executorch-deeplab-v3) | 21                | [DeeplabLabel](../../06-api-reference/enumerations/DeeplabLabel.md)                       |    ✅     |
-| [lraspp-mobilenet-v3-large](https://huggingface.co/software-mansion/react-native-executorch-lraspp)         | 21                | [DeeplabLabel](../../06-api-reference/enumerations/DeeplabLabel.md)                       |    ✅     |
-| [fcn-resnet50](https://huggingface.co/software-mansion/react-native-executorch-fcn)                         | 21                | [DeeplabLabel](../../06-api-reference/enumerations/DeeplabLabel.md)                       |    ✅     |
-| [fcn-resnet101](https://huggingface.co/software-mansion/react-native-executorch-fcn)                        | 21                | [DeeplabLabel](../../06-api-reference/enumerations/DeeplabLabel.md)                       |    ✅     |
-| [selfie-segmentation](https://huggingface.co/software-mansion/react-native-executorch-selfie-segmentation)  | 2                 | [SelfieSegmentationLabel](../../06-api-reference/enumerations/SelfieSegmentationLabel.md) |    No     |
diff --git a/docs/docs/03-hooks/02-computer-vision/useStyleTransfer.md b/docs/docs/03-hooks/02-computer-vision/useStyleTransfer.md
deleted file mode 100644
index f76693fdc4..0000000000
--- a/docs/docs/03-hooks/02-computer-vision/useStyleTransfer.md
+++ /dev/null
@@ -1,102 +0,0 @@
----
-title: useStyleTransfer
----
-
-Style transfer is a technique used in computer graphics and machine learning where the visual style of one image is applied to the content of another. This is achieved using algorithms that manipulate data from both images, typically with the aid of a neural network. The result is a new image that combines the artistic elements of one picture with the structural details of another, effectively merging art with traditional imagery. React Native ExecuTorch offers a dedicated hook `useStyleTransfer`, for this task. However before you start you'll need to obtain ExecuTorch-compatible model binary.
-
-:::info
-It is recommended to use models provided by us which are available at our [Hugging Face repository](https://huggingface.co/collections/software-mansion/style-transfer-68d0eab2b0767a20e7efeaf5), you can also use [constants](https://github.com/software-mansion/react-native-executorch/blob/main/packages/react-native-executorch/src/constants/modelUrls.ts) shipped with our library.
-:::
-
-## API Reference
-
-- For detailed API Reference for `useStyleTransfer` see: [`useStyleTransfer` API Reference](../../06-api-reference/functions/useStyleTransfer.md).
-- For all style transfer models available out-of-the-box in React Native ExecuTorch see: [Style Transfer Models](../../06-api-reference/index.md#models---style-transfer).
-
-## High Level Overview
-
-```typescript
-import { models, useStyleTransfer } from 'react-native-executorch';
-const model = useStyleTransfer({ model: models.style_transfer.candy() });
-
-const imageUri = 'file:///Users/.../cute_cat.png';
-
-try {
-  // Returns a file URI string
-  const uri = await model.forward(imageUri, 'url');
-  // Or returns raw PixelData (default)
-  const pixels = await model.forward(imageUri);
-} catch (error) {
-  console.error(error);
-}
-```
-
-### Arguments
-
-`useStyleTransfer` takes [`StyleTransferProps`](../../06-api-reference/interfaces/StyleTransferProps.md) that consists of:
-
-- `model` containing [`modelSource`](../../06-api-reference/interfaces/StyleTransferProps.md#modelsource).
-- An optional flag [`preventLoad`](../../06-api-reference/interfaces/StyleTransferProps.md#preventload) which prevents auto-loading of the model.
-
-You need more details? Check the following resources:
-
-- For detailed information about `useStyleTransfer` arguments check this section: [`useStyleTransfer` arguments](../../06-api-reference/functions/useStyleTransfer.md#parameters).
-- For all style transfer models available out-of-the-box in React Native ExecuTorch see: [Style Transfer Models](../../06-api-reference/index.md#models---style-transfer).
-- For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-### Returns
-
-`useStyleTransfer` returns an object called `StyleTransferType` containing bunch of functions to interact with style transfer models. To get more details please read: [`StyleTransferType` API Reference](../../06-api-reference/interfaces/StyleTransferType.md).
-
-## Running the model
-
-To run the model, use the [`forward`](../../06-api-reference/interfaces/StyleTransferType.md#forward) method. It accepts two arguments:
-
-- `input` (required) — The image to stylize. Can be a remote URL, a local file URI, a base64-encoded image (whole URI or only raw base64), or a [`PixelData`](../../06-api-reference/interfaces/PixelData.md) object (raw RGB pixel buffer).
-- `outputType` (optional) — Controls the return format:
-  - `'pixelData'` (default) — Returns a `PixelData` object with raw RGB pixels. No file is written.
-  - `'url'` — Saves the result to a temp file and returns its URI as a `string`.
-
-:::info
-When `outputType` is `'url'`, the generated image is stored in your application's temporary directory.
-:::
-
-## Example
-
-```typescript
-import { models, useStyleTransfer } from 'react-native-executorch';
-function App() {
-  const model = useStyleTransfer({ model: models.style_transfer.candy() });
-
-  // Returns a file URI — easy to pass to <Image source={{ uri }} />
-  const runWithUrl = async (imageUri: string) => {
-    try {
-      const uri = await model.forward(imageUri, 'url');
-      console.log('Styled image saved at:', uri);
-    } catch (error) {
-      console.error(error);
-    }
-  };
-
-  // Returns raw PixelData — useful for further processing or frame pipelines
-  const runWithPixelData = async (imageUri: string) => {
-    try {
-      const pixels = await model.forward(imageUri);
-      // pixels.dataPtr is a Uint8Array of RGB bytes
-    } catch (error) {
-      console.error(error);
-    }
-  };
-}
-```
-
-## VisionCamera integration
-
-See the full guide: [VisionCamera Integration](./visioncamera-integration.md).
-
-## Supported models
-
-- [Candy](https://github.com/pytorch/examples/tree/main/fast_neural_style)
-- [Mosaic](https://github.com/pytorch/examples/tree/main/fast_neural_style)
-- [Udnie](https://github.com/pytorch/examples/tree/main/fast_neural_style)
-- [Rain princess](https://github.com/pytorch/examples/tree/main/fast_neural_style)
diff --git a/docs/docs/03-hooks/02-computer-vision/useTextToImage.md b/docs/docs/03-hooks/02-computer-vision/useTextToImage.md
deleted file mode 100644
index 5315979983..0000000000
--- a/docs/docs/03-hooks/02-computer-vision/useTextToImage.md
+++ /dev/null
@@ -1,98 +0,0 @@
----
-title: useTextToImage
-keywords: [image generation]
-description: "Learn how to use image generation models in your React Native applications with React Native ExecuTorch's useTextToImage hook."
----
-
-Text-to-image is a process of generating images directly from a description in natural language by conditioning a model on the provided text input. Our implementation follows the Stable Diffusion pipeline, which applies the diffusion process in a lower-dimensional latent space to reduce memory requirements. The pipeline combines a text encoder to preprocess the prompt, a U-Net that iteratively denoises latent representations, and a VAE decoder to reconstruct the final image. React Native ExecuTorch offers a dedicated hook, `useTextToImage`, for this task.
-
-:::info
-It is recommended to use models provided by us which are available at our [Hugging Face repository](https://huggingface.co/collections/software-mansion/text-to-image-68d0edf50ae6d20b5f9076cd), you can also use [constants](https://github.com/software-mansion/react-native-executorch/blob/main/packages/react-native-executorch/src/constants/modelUrls.ts) shipped with our library.
-:::
-
-## API Reference
-
-- For detailed API Reference for `useTextToImage` see: [`useTextToImage` API Reference](../../06-api-reference/functions/useTextToImage.md).
-- For all text to image models available out-of-the-box in React Native ExecuTorch see: [Text to Image Models](../../06-api-reference/index.md#models---image-generation).
-
-## High Level Overview
-
-```typescript
-import { models, useTextToImage } from 'react-native-executorch';
-const model = useTextToImage({
-  model: models.image_generation.bk_sdm_tiny_vpred_256(),
-});
-
-const input = 'a castle';
-
-try {
-  const image = await model.generate(input);
-} catch (error) {
-  console.error(error);
-}
-```
-
-### Arguments
-
-`useTextToImage` takes [`TextToImageProps`](../../06-api-reference/interfaces/TextToImageProps.md) that consists of:
-
-- `model` containing [`schedulerSource`](../../06-api-reference/interfaces/TextToImageProps.md#schedulersource), [`tokenizerSource`](../../06-api-reference/interfaces/TextToImageProps.md#tokenizersource), [`encoderSource`](../../06-api-reference/interfaces/TextToImageProps.md#encodersource), [`unetSource`](../../06-api-reference/interfaces/TextToImageProps.md#unetsource), and [`decoderSource`](../../06-api-reference/interfaces/TextToImageProps.md#decodersource).
-- An inference callback [`inferenceCallback`](../../06-api-reference/interfaces/TextToImageProps.md#inferencecallback).
-- An optional flag [`preventLoad`](../../06-api-reference/interfaces/TextToImageProps.md#preventload) which prevents auto-loading of the model.
-
-You need more details? Check the following resources:
-
-- For detailed information about `useTextToImage` arguments check this section: [`useTextToImage` arguments](../../06-api-reference/functions/useTextToImage.md#parameters).
-- For all text to image models available out-of-the-box in React Native ExecuTorch see: [Text to Image Models](../../06-api-reference/index.md#models---image-generation).
-- For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-### Returns
-
-`useTextToImage` returns an object called `TextToImageType` containing bunch of functions to interact with text to image models. To get more details please read: [`TextToImageType` API Reference](../../06-api-reference/interfaces/TextToImageType.md).
-
-## Running the model
-
-To run the model, you can use the [`generate`](../../06-api-reference/interfaces/TextToImageType.md#generate) method. It accepts four arguments: a text prompt describing the requested image, a size of the image in pixels, a number of denoising steps, and an optional seed value, which enables reproducibility of the results.
-
-The image size must be a multiple of 32 due to the architecture of the U-Net and VAE models. The seed should be a positive integer.
-
-:::warning
-Larger imageSize values require significantly more memory to run the model.
-:::
-
-## Example
-
-```tsx
-import { models, useTextToImage } from 'react-native-executorch';
-function App() {
-  const model = useTextToImage({
-    model: models.image_generation.bk_sdm_tiny_vpred_256(),
-  });
-
-  //...
-  const input = 'a medieval castle by the sea shore';
-
-  const imageSize = 256;
-  const numSteps = 25;
-
-  try {
-    image = await model.generate(input, imageSize, numSteps);
-  } catch (error) {
-    console.error(error);
-  }
-  //...
-
-  // `generate` returns a `file://` URI to the PNG saved on disk.
-  return <Image source={{ uri: image }} />;
-}
-```
-
-| ![Castle 256x256](/img/castle256.png) | ![Castle 512x512](/img/castle512.png) |
-| ------------------------------------- | ------------------------------------- |
-| Image of size 256×256                 | Image of size 512×512                 |
-
-## Supported models
-
-| Model                                                               | Parameters [B] | Description                                                                                                                                                                                                                                                                                                  |
-| ------------------------------------------------------------------- | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| [bk-sdm-tiny-vpred](https://huggingface.co/vivym/bk-sdm-tiny-vpred) | 0.5            | BK-SDM (Block-removed Knowledge-distilled Stable Diffusion Model) is a compressed version of Stable Diffusion v1.4 with several residual and attention blocks removed. The BK-SDM-Tiny is a v-prediction variant of the model, obtained through further block removal, built around a 0.33B-parameter U-Net. |
diff --git a/docs/docs/03-hooks/02-computer-vision/useVerticalOCR.md b/docs/docs/03-hooks/02-computer-vision/useVerticalOCR.md
deleted file mode 100644
index 82c983d900..0000000000
--- a/docs/docs/03-hooks/02-computer-vision/useVerticalOCR.md
+++ /dev/null
@@ -1,132 +0,0 @@
----
-title: useVerticalOCR
----
-
-:::danger Experimental
-The `useVerticalOCR` hook is currently in an experimental phase. We appreciate feedback from users as we continue to refine and enhance its functionality.
-:::
-
-Optical Character Recognition (OCR) is a computer vision technique used to detect and recognize text within images. It is commonly utilized to convert a variety of documents, such as scanned paper documents, PDF files, or images captured by a digital camera, into editable and searchable data. Traditionally, OCR technology has been optimized for recognizing horizontal text, and integrating support for vertical text recognition often requires significant additional effort from developers. To simplify this, we introduce `useVerticalOCR`, a tool designed to abstract the complexities of vertical text OCR, enabling seamless integration into your applications.
-
-:::info
-It is recommended to use models provided by us, which are available at our [Hugging Face repository](https://huggingface.co/collections/software-mansion/ocr-68d0eb320ae6d20b5f901ea9). You can also use [constants](https://github.com/software-mansion/react-native-executorch/blob/main/packages/react-native-executorch/src/constants/modelUrls.ts) shipped with our library.
-:::
-
-## API Reference
-
-- For detailed API Reference for `useVerticalOCR` see: [`useVerticalOCR` API Reference](../../06-api-reference/functions/useVerticalOCR.md).
-- For all alphabets available in ocr out-of-the-box in React Native ExecuTorch see: [OCR Supported Alphabets](../../06-api-reference/index.md#ocr-supported-alphabets).
-
-## High Level Overview
-
-```tsx
-import { models, useVerticalOCR } from 'react-native-executorch';
-function App() {
-  const model = useVerticalOCR({
-    model: models.ocr.craft({ language: 'en' }),
-    independentCharacters: true,
-  });
-
-  // ...
-  for (const ocrDetection of await model.forward('https://url-to-image.jpg')) {
-    console.log('Bounding box: ', ocrDetection.bbox);
-    console.log('Bounding label: ', ocrDetection.text);
-    console.log('Bounding score: ', ocrDetection.score);
-  }
-  // ...
-}
-```
-
-### Arguments
-
-`useVerticalOCR` takes [`VerticalOCRProps`](../../06-api-reference/interfaces/VerticalOCRProps.md) that consists of:
-
-- `model` containing [`detectorSource`](../../06-api-reference/interfaces/VerticalOCRProps.md#detectorsource), [`recognizerSource`](../../06-api-reference/interfaces/VerticalOCRProps.md#recognizersource), and [`language`](../../06-api-reference/interfaces/VerticalOCRProps.md#language).
-- An optional flag [`preventLoad`](../../06-api-reference/interfaces/VerticalOCRProps.md#preventload) which prevents auto-loading of the model.
-- An optional flag [`independentCharacters`](../../06-api-reference/interfaces/VerticalOCRProps.md#independentcharacters) indicating either to treat characters as independent or words.
-
-You need more details? Check the following resources:
-
-- For detailed information about `useVerticalOCR` arguments check this section: [`useVerticalOCR` arguments](../../06-api-reference/functions/useVerticalOCR.md#parameters).
-- For all alphabets available in ocr out-of-the-box in React Native ExecuTorch see: [OCR Supported Alphabets](../../06-api-reference/index.md#ocr-supported-alphabets).
-- For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-### Returns
-
-`useVerticalOCR` returns an object called `OCRType` containing bunch of functions to interact with Vertical OCR models. To get more details please read: [`OCRType` API Reference](../../06-api-reference/interfaces/OCRType.md).
-
-## Running the model
-
-To run the model, use the [`forward`](../../06-api-reference/interfaces/OCRType.md#forward) method. It accepts one argument — the image to recognize. The image can be a remote URL, a local file URI, a base64-encoded image (whole URI or only raw base64), or a [`PixelData`](../../06-api-reference/interfaces/PixelData.md) object (raw RGB pixel buffer). The function returns an array of [`OCRDetection`](../../06-api-reference/interfaces/OCRDetection.md) objects, each containing the bounding box, recognized text, and confidence score.
-
-## VisionCamera integration
-
-See the full guide: [VisionCamera Integration](./visioncamera-integration.md).
-
-## Detection object
-
-The detection object is specified as follows:
-
-```typescript
-interface Bbox {
-  x1: number;
-  y1: number;
-  x2: number;
-  y2: number;
-}
-
-interface OCRDetection {
-  bbox: Bbox;
-  text: string;
-  score: number;
-}
-```
-
-The `bbox` property contains the axis-aligned bounding box of the detected text region. `x1`/`y1` is the top-left corner and `x2`/`y2` is the bottom-right corner.
-The `text` property contains the text recognized within detected text region. The `score` represents the confidence score of the recognized text.
-
-## Example
-
-```tsx
-import { models, useVerticalOCR } from 'react-native-executorch';
-function App() {
-  const model = useVerticalOCR({
-    model: models.ocr.craft({ language: 'en' }),
-    independentCharacters: true,
-  });
-
-  const runModel = async () => {
-    const ocrDetections = await model.forward('https://url-to-image.jpg');
-
-    for (const ocrDetection of ocrDetections) {
-      console.log('Bounding box: ', ocrDetection.bbox);
-      console.log('Bounding text: ', ocrDetection.text);
-      console.log('Bounding score: ', ocrDetection.score);
-    }
-  };
-}
-```
-
-## Alphabet-Specific Recognizers
-
-Each supported alphabet requires its own recognizer model. The built-in constants, such as `RECOGNIZER_LATIN_CRNN` or `RECOGNIZER_CYRILLIC_CRNN`, point to specific models trained for a particular alphabet.
-
-> For example:
->
-> - To recognize text in languages using the **Latin** alphabet (like Polish, or German), use:
->   - `RECOGNIZER_LATIN_CRNN`
-> - To recognize text in languages using the **Cyrillic** alphabet (like Russian or Ukrainian), use:
->   - `RECOGNIZER_CYRILLIC_CRNN`
-
-You need to make sure the recognizer model you pass in [`recognizerSource`](../../06-api-reference/interfaces/VerticalOCRProps.md#recognizersource) matches the alphabet of the [`language`](../../06-api-reference/interfaces/VerticalOCRProps.md#language) you specify.
-
-## Supported languages
-
-For all alphabets available in ocr out-of-the-box in React Native ExecuTorch see: [OCR Supported Alphabets](../../06-api-reference/index.md#ocr-supported-alphabets).
-
-## Supported models
-
-| Model                                             |    Type    |
-| ------------------------------------------------- | :--------: |
-| [CRAFT](https://github.com/clovaai/CRAFT-pytorch) |  Detector  |
-| [CRNN](https://www.jaided.ai/easyocr/modelhub/)   | Recognizer |
diff --git a/docs/docs/03-hooks/02-computer-vision/visioncamera-integration.md b/docs/docs/03-hooks/02-computer-vision/visioncamera-integration.md
deleted file mode 100644
index b421047552..0000000000
--- a/docs/docs/03-hooks/02-computer-vision/visioncamera-integration.md
+++ /dev/null
@@ -1,315 +0,0 @@
----
-title: VisionCamera Integration
----
-
-React Native ExecuTorch vision models support real-time frame processing via [VisionCamera v5](https://visioncamera.margelo.com) using the `runOnFrame` worklet. This page explains how to set it up and what to watch out for.
-
-## Prerequisites
-
-Make sure you have the following packages installed:
-
-- [`react-native-vision-camera`](https://visioncamera.margelo.com) v5
-- [`react-native-worklets`](https://docs.swmansion.com/react-native-worklets/)
-
-## Which models support runOnFrame?
-
-The following hooks expose `runOnFrame`:
-
-- [`useClassification`](./useClassification.md)
-- [`useImageEmbeddings`](./useImageEmbeddings.md)
-- [`useOCR`](./useOCR.md)
-- [`useVerticalOCR`](./useVerticalOCR.md)
-- [`useObjectDetection`](./useObjectDetection.md)
-- [`useInstanceSegmentation`](./useInstanceSegmentation.md)
-- [`useSemanticSegmentation`](./useSemanticSegmentation.md)
-- [`useStyleTransfer`](./useStyleTransfer.md)
-- [`usePoseEstimation`](./usePoseEstimation.md)
-
-## runOnFrame vs forward
-
-|          | `runOnFrame`         | `forward`                  |
-| -------- | -------------------- | -------------------------- |
-| Thread   | JS (worklet)         | Background thread          |
-| Input    | VisionCamera `Frame` | `string` URI / `PixelData` |
-| Output   | Model result (sync)  | `Promise<result>`          |
-| Use case | Real-time camera     | Single image               |
-
-Use `runOnFrame` when you need to process every camera frame. Use `forward` for one-off image inference.
-
-## How it works
-
-VisionCamera v5 delivers frames via [`useFrameOutput`](https://visioncamera.margelo.com/docs/frame-output). Inside the `onFrame` worklet you call `runOnFrame(frame, isFrontCamera)` synchronously, then use `scheduleOnRN` from `react-native-worklets` to post the result back to React state on the main thread.
-
-The `isFrontCamera` parameter tells the native side whether the front camera is active so it can correctly mirror the results. The library handles all device orientation rotation internally — results are always returned in screen-space coordinates regardless of how the user holds their device.
-
-:::warning
-
-- You **must** set `pixelFormat: 'rgb'` in `useFrameOutput`. Our extraction pipeline expects RGB pixel data — any other format (e.g. the default `yuv`) will produce incorrect results.
-- `runOnFrame` is synchronous and runs on the JS worklet thread. For models with longer inference times, use `dropFramesWhileBusy: true` to skip frames and avoid blocking the camera pipeline. For more control, see VisionCamera's [async frame processing guide](https://visioncamera.margelo.com/docs/async-frame-processing).
-- Always call `frame.dispose()` after processing to release the frame buffer. Wrap your inference in a `try/finally` to ensure it's always called even if `runOnFrame` throws.
-  :::
-
-## Camera configuration
-
-The `Camera` component requires specific props for correct orientation handling:
-
-```tsx
-<Camera
-  device={device}
-  outputs={[frameOutput]}
-  isActive
-  orientationSource="device"
-/>
-```
-
-- **`orientationSource="device"`** — ensures frame orientation metadata reflects the physical device orientation, which the library uses to rotate model inputs and outputs correctly.
-- **Do not set `enablePhysicalBufferRotation`** — this prop must remain `false` (the default). If enabled, VisionCamera pre-rotates the pixel buffer, which conflicts with the library's own orientation handling and produces incorrect results.
-
-## Full example (Object Detection)
-
-```tsx
-import { useState, useCallback, useRef } from 'react';
-import { StyleSheet, View, Text } from 'react-native';
-import {
-  Camera,
-  Frame,
-  useCameraDevices,
-  useCameraPermission,
-  useFrameOutput,
-} from 'react-native-vision-camera';
-import { scheduleOnRN } from 'react-native-worklets';
-import { models, Detection, useObjectDetection } from 'react-native-executorch';
-export default function App() {
-  const { hasPermission, requestPermission } = useCameraPermission();
-  const devices = useCameraDevices();
-  const device = devices.find((d) => d.position === 'back');
-  const model = useObjectDetection({
-    model: models.object_detection.ssdlite_320_mobilenet_v3_large(),
-  });
-  const [detections, setDetections] = useState<Detection[]>([]);
-
-  const detRof = model.runOnFrame;
-
-  const updateDetections = useCallback((results: Detection[]) => {
-    setDetections(results);
-  }, []);
-
-  const frameOutput = useFrameOutput({
-    pixelFormat: 'rgb',
-    dropFramesWhileBusy: true,
-    onFrame: useCallback(
-      (frame: Frame) => {
-        'worklet';
-        try {
-          if (!detRof) return;
-          const isFrontCamera = false; // using back camera
-          const result = detRof(frame, isFrontCamera, 0.5);
-          if (result) {
-            scheduleOnRN(updateDetections, result);
-          }
-        } finally {
-          frame.dispose();
-        }
-      },
-      [detRof, updateDetections]
-    ),
-  });
-
-  if (!hasPermission) {
-    requestPermission();
-    return null;
-  }
-
-  if (!device) return null;
-
-  return (
-    <View style={styles.container}>
-      <Camera
-        style={StyleSheet.absoluteFill}
-        device={device}
-        outputs={[frameOutput]}
-        isActive
-        orientationSource="device"
-      />
-      {detections.map((det, i) => (
-        <Text key={i} style={styles.label}>
-          {det.label} {(det.score * 100).toFixed(1)}%
-        </Text>
-      ))}
-    </View>
-  );
-}
-
-const styles = StyleSheet.create({
-  container: { flex: 1 },
-  label: {
-    position: 'absolute',
-    bottom: 40,
-    alignSelf: 'center',
-    color: 'white',
-    fontSize: 16,
-  },
-});
-```
-
-For a complete example showing how to render bounding boxes, segmentation masks, OCR overlays, and style transfer results on top of the camera preview, see the [example app's VisionCamera tasks](https://github.com/software-mansion/react-native-executorch/tree/main/apps/computer-vision/components/vision_camera).
-
-## Handling front/back camera
-
-When switching between front and back cameras, you need to pass the correct `isFrontCamera` value to `runOnFrame`. Since worklets cannot read React state directly, use a `Synchronizable` from `react-native-worklets`:
-
-```tsx
-import { createSynchronizable } from 'react-native-worklets';
-
-// Create outside the component so it's stable across renders
-const cameraPositionSync = createSynchronizable<'front' | 'back'>('back');
-
-export default function App() {
-  const [cameraPosition, setCameraPosition] = useState<'front' | 'back'>(
-    'back'
-  );
-
-  // Keep the synchronizable in sync with React state
-  useEffect(() => {
-    cameraPositionSync.setBlocking(cameraPosition);
-  }, [cameraPosition]);
-
-  const frameOutput = useFrameOutput({
-    pixelFormat: 'rgb',
-    dropFramesWhileBusy: true,
-    onFrame: useCallback((frame: Frame) => {
-      'worklet';
-      try {
-        if (!runOnFrame) return;
-        const isFrontCamera = cameraPositionSync.getDirty() === 'front';
-        const result = runOnFrame(frame, isFrontCamera);
-        // ... handle result
-      } finally {
-        frame.dispose();
-      }
-    }, []),
-  });
-
-  // ...
-}
-```
-
-## Using the Module API
-
-If you use the TypeScript Module API (e.g. `ClassificationModule`) directly instead of a hook, `runOnFrame` is a worklet function and **cannot** be passed directly to `useState` — React would invoke it as a state initializer. Use the functional updater form `() => module.runOnFrame`:
-
-```tsx
-import { useState, useEffect, useCallback } from 'react';
-import { Text, View } from 'react-native';
-import {
-  Camera,
-  useCameraDevice,
-  useCameraPermission,
-  useFrameOutput,
-} from 'react-native-vision-camera';
-import { scheduleOnRN } from 'react-native-worklets';
-import { models, ClassificationModule } from 'react-native-executorch';
-export default function App() {
-  const { hasPermission, requestPermission } = useCameraPermission();
-  const device = useCameraDevice('back');
-  const [runOnFrame, setRunOnFrame] = useState<any>(null);
-  const [topLabels, setTopLabels] = useState<any[]>([]);
-
-  useEffect(() => {
-    if (!hasPermission) requestPermission();
-  }, [hasPermission, requestPermission]);
-
-  useEffect(() => {
-    ClassificationModule.fromModelName(
-      models.classification.efficientnet_v2_s()
-    ).then((module) => {
-      // () => module.runOnFrame is required — passing module.runOnFrame directly
-      // would cause React to call it as a state initializer function
-      setRunOnFrame(() => module.runOnFrame);
-    });
-  }, []);
-
-  const frameOutput = useFrameOutput({
-    pixelFormat: 'rgb',
-    dropFramesWhileBusy: true,
-    onFrame: useCallback(
-      (frame) => {
-        'worklet';
-        if (!runOnFrame) return;
-        try {
-          const isFrontCamera = false;
-          const result = runOnFrame(frame, isFrontCamera);
-          if (result) {
-            const sorted = Object.entries(result)
-              .map(([label, score]) => ({ label, score: score as number }))
-              .sort((a, b) => b.score - a.score)
-              .slice(0, 5);
-            scheduleOnRN(setTopLabels, sorted);
-          }
-        } finally {
-          frame.dispose();
-        }
-      },
-      [runOnFrame]
-    ),
-  });
-
-  if (!device || !hasPermission)
-    return (
-      <Text>
-        {!hasPermission ? 'No camera permission' : 'No camera device'}
-      </Text>
-    );
-
-  return (
-    <View style={{ flex: 1 }}>
-      <Camera
-        style={{ flex: 1 }}
-        outputs={[frameOutput]}
-        isActive
-        device={device}
-        orientationSource="device"
-      />
-      <View style={{ position: 'absolute', bottom: 40, left: 16 }}>
-        {topLabels.map(({ label, score }) => (
-          <Text key={label} style={{ color: 'black', fontSize: 16 }}>
-            {label}: {(score * 100).toFixed(1)}%
-          </Text>
-        ))}
-      </View>
-    </View>
-  );
-}
-```
-
-## Common issues
-
-#### Bounding boxes or masks are rotated / misaligned
-
-Make sure you have set `orientationSource="device"` on the `Camera` component. Without it, the frame orientation metadata won't match the actual device orientation, causing misaligned results.
-
-Also verify that `enablePhysicalBufferRotation` is **not** set to `true` — this conflicts with the library's orientation handling.
-
-#### Results look wrong or scrambled
-
-You forgot to set `pixelFormat: 'rgb'`. The default VisionCamera pixel format is `yuv` — our frame extraction works only with RGB data.
-
-#### Results are mirrored on front camera
-
-You are not passing `isFrontCamera: true` when using the front camera. See [Handling front/back camera](#handling-frontback-camera) above.
-
-#### App freezes or camera drops frames
-
-Your model's inference time exceeds the frame interval. Enable `dropFramesWhileBusy: true` in `useFrameOutput`, or move inference off the worklet thread using VisionCamera's [async frame processing](https://visioncamera.margelo.com/docs/async-frame-processing).
-
-#### Memory leak / crash after many frames
-
-You are not calling `frame.dispose()`. Always dispose the frame in a `finally` block.
-
-#### `runOnFrame` is always null
-
-The model hasn't finished loading yet. Guard with `if (!runOnFrame) return` inside `onFrame`, or check `model.isReady` before enabling the camera.
-
-#### TypeError: `module.runOnFrame` is not a function (Module API)
-
-You passed `module.runOnFrame` directly to `setState` instead of `() => module.runOnFrame`. React invoked it as a state initializer — see the [Module API section](#using-the-module-api) above.
diff --git a/docs/docs/03-hooks/03-executorch-bindings/_category_.json b/docs/docs/03-hooks/03-executorch-bindings/_category_.json
deleted file mode 100644
index 1e89535929..0000000000
--- a/docs/docs/03-hooks/03-executorch-bindings/_category_.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "label": "ExecuTorch Bindings",
-  "link": {
-    "type": "generated-index"
-  }
-}
diff --git a/docs/docs/03-hooks/03-executorch-bindings/useExecutorchModule.md b/docs/docs/03-hooks/03-executorch-bindings/useExecutorchModule.md
deleted file mode 100644
index 7429b4b60e..0000000000
--- a/docs/docs/03-hooks/03-executorch-bindings/useExecutorchModule.md
+++ /dev/null
@@ -1,106 +0,0 @@
----
-title: useExecutorchModule
----
-
-useExecutorchModule provides React Native bindings to the ExecuTorch [Module API](https://pytorch.org/executorch/stable/extension-module.html) directly from JavaScript.
-
-:::info
-These bindings are primarily intended for custom model integration where no dedicated hook exists. If you are considering using a provided model, first verify whether a dedicated hook is available. Dedicated hooks simplify the implementation process by managing necessary pre and post-processing automatically. Utilizing these can save you effort and reduce complexity, ensuring you do not implement additional handling that is already covered.
-:::
-
-## API Reference
-
-- For detailed API Reference for `useExecutorchModule` see: [`useExecutorchModule` API Reference](../../06-api-reference/functions/useExecutorchModule.md).
-
-## Initializing ExecuTorch Module
-
-You can initialize the ExecuTorch module in your JavaScript application using the `useExecutorchModule` hook. This hook facilitates the loading of models from the specified source and prepares them for use.
-
-```typescript
-import { useExecutorchModule } from 'react-native-executorch';
-const executorchModule = useExecutorchModule({
-  modelSource: require('../assets/models/model.pte'),
-});
-```
-
-The [`modelSource`](../../06-api-reference/interfaces/ExecutorchModuleProps.md#modelsource) parameter expects a location string pointing to the model binary.
-
-For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-### Arguments
-
-`useExecutorchModule` takes [`ExecutorchModuleProps`](../../06-api-reference/interfaces/ExecutorchModuleProps.md) that consists of:
-
-- `model` containing [`modelSource`](../../06-api-reference/interfaces/ExecutorchModuleProps.md#modelsource).
-- An optional flag [`preventLoad`](../../06-api-reference/interfaces/ExecutorchModuleProps.md#preventload) which prevents auto-loading of the model.
-
-You need more details? Check the following resources:
-
-- For detailed information about `useExecutorchModule` arguments check this section: [`useExecutorchModule` arguments](../../06-api-reference/functions/useExecutorchModule.md#parameters).
-- For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-### Returns
-
-`useExecutorchModule` returns an object called `ExecutorchModuleType` containing bunch of functions to interact with arbitrarily chosen models. To get more details please read: [`ExecutorchModuleType` API Reference](../../06-api-reference/interfaces/ExecutorchModuleType.md).
-
-## TensorPtr
-
-[`TensorPtr`](../../06-api-reference/interfaces/TensorPtr.md) is a JS representation of the underlying tensor, which is then passed to the model. You can read more about creating tensors [here](https://docs.pytorch.org/executorch/stable/extension-tensor.html). On JS side, the TensorPtr holds the following information:
-
-[`dataPtr`](../../06-api-reference/interfaces/TensorPtr.md#dataptr) - Represents a data buffer that will be used to create a tensor on the native side. This can be either an `ArrayBuffer` or a `TypedArray`. If your model takes in a datatype which is not covered by any of the `TypedArray` types, just pass an `ArrayBuffer` here.
-
-[`sizes`](../../06-api-reference/interfaces/TensorPtr.md#sizes) - Represents a shape of a given tensor, i.e. for a 640x640 RGB image with a batch size of 1, you would need to pass `[1, 3, 640, 640]` here.
-
-[`scalarType`](../../06-api-reference/interfaces/TensorPtr.md#scalartype) - An enum resembling the ExecuTorch's `ScalarType`. For example, if your model was exported with float32 as an input, you will need to pass `ScalarType.FLOAT` here.
-
-## End to end example
-
-This example demonstrates the integration and usage of the ExecuTorch bindings with a [style transfer model](../../03-hooks/02-computer-vision/useStyleTransfer.md). Specifically, we'll be using the `STYLE_TRANSFER_CANDY` model, which applies artistic style transfer to an input image.
-
-### Importing the Module and loading the model
-
-First, import the necessary functions from the `react-native-executorch` package and initialize the ExecuTorch module with the specified style transfer model.
-
-```typescript
-import {
-  models,
-  useExecutorchModule,
-  ScalarType,
-} from 'react-native-executorch';
-// Initialize the executorch module with the predefined style transfer model.
-const executorchModule = useExecutorchModule({
-  modelSource: models.style_transfer.candy(),
-});
-```
-
-### Setting up input parameters
-
-To prepare the model input, define the tensor shape according to your model's requirements (defined by the model export process). For example, the `STYLE_TRANSFER_CANDY` model expects a tensor with shape `[1, 3, 640, 640]` — representing a batch size of 1, 3 color channels (RGB), and 640×640 pixel dimensions.
-
-```typescript
-const inputTensor = {
-  dataPtr: new Float32Array(1 * 3 * 640 * 640), // or other TypedArray / ArrayBuffer
-  sizes: [1, 3, 640, 640],
-  scalarType: ScalarType.FLOAT,
-};
-```
-
-### Performing inference
-
-After passing input to the forward function, you'll receive an array of TensorPtr objects. Each TensorPtr contains its [`dataPtr`](../../06-api-reference/interfaces/TensorPtr.md#dataptr) as an ArrayBuffer. Since ArrayBuffer represents raw binary data, you'll need to interpret it according to the tensor's underlying data type (e.g., creating a Float32Array view for float32 tensors, Int32Array for int32 tensors, etc.).
-
-:::info
-This code assumes that you have handled preprocessing of the input image (scaling, normalization) and postprocessing of the output (interpreting the raw output data) according to the model's requirements. Make sure to adjust these parts depending on your specific data and model outputs.
-:::
-
-```typescript
-try {
-  // Perform the forward operation and receive the stylized image output.
-  const output = await executorchModule.forward([inputTensor]);
-  // Interpret the output ArrayBuffer
-  // foo(output[0].dataPtr);
-} catch (error) {
-  // Log any errors that occur during the forward pass.
-  console.error('Error during model execution:', error);
-}
-```
diff --git a/docs/docs/03-hooks/_category_.json b/docs/docs/03-hooks/_category_.json
deleted file mode 100644
index 556f743826..0000000000
--- a/docs/docs/03-hooks/_category_.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "label": "Hooks",
-  "link": {
-    "type": "generated-index"
-  }
-}
diff --git a/docs/docs/04-typescript-api/01-natural-language-processing/LLMModule.md b/docs/docs/04-typescript-api/01-natural-language-processing/LLMModule.md
deleted file mode 100644
index 48b3395f87..0000000000
--- a/docs/docs/04-typescript-api/01-natural-language-processing/LLMModule.md
+++ /dev/null
@@ -1,199 +0,0 @@
----
-title: LLMModule
----
-
-TypeScript API implementation of the [useLLM](../../03-hooks/01-natural-language-processing/useLLM.md) hook.
-
-## API Reference
-
-- For detailed API Reference for `LLMModule` see: [`LLMModule` API Reference](../../06-api-reference/classes/LLMModule.md).
-- For all LLM models available out-of-the-box in React Native ExecuTorch see: [LLM Models](../../06-api-reference/index.md#models---llm).
-- For useful LLM utility functionalities please refer to the following link: [LLM Utility Functionalities](../../06-api-reference/index.md#utilities---llm).
-
-## High Level Overview
-
-```typescript
-import { models, LLMModule } from 'react-native-executorch';
-// Creating an instance and loading the model
-const llm = await LLMModule.fromModelName(
-  models.llm.lfm2_5_1_2b_instruct(),
-  (progress) => console.log(progress),
-  (token) => console.log(token),
-  (messages) => console.log(messages)
-);
-
-// Running the model - returns the generated response
-const response = await llm.sendMessage('Hello, World!');
-console.log('Response:', response);
-
-// Interrupting the model (to actually interrupt the generation it has to be called when sendMessage or generate is running)
-llm.interrupt();
-
-// Deleting the model from memory
-llm.delete();
-```
-
-### Methods
-
-All methods of `LLMModule` are explained in details here: [LLMModule API Reference](../../06-api-reference/classes/LLMModule.md).
-
-## Loading the model
-
-Use the static [`fromModelName`](../../06-api-reference/classes/LLMModule.md#frommodelname) factory method:
-
-```typescript
-const llm = await LLMModule.fromModelName(
-  models.llm.lfm2_5_1_2b_instruct(), // model config constant
-  onDownloadProgress, // optional, progress 0–1
-  tokenCallback, // optional, called on every token
-  messageHistoryCallback // optional, called when generation finishes
-);
-```
-
-The model config object contains `modelSource`, `tokenizerSource`, `tokenizerConfigSource`, and optional `capabilities`. Pass one of the built-in constants (e.g. `LFM2_5_1_2B_INSTRUCT`) or construct it manually.
-
-This method returns a promise resolving to an `LLMModule` instance.
-
-For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-## Listening for download progress
-
-To subscribe to the download progress event, you can pass the `onDownloadProgress` callback as the second argument to [`fromModelName`](../../06-api-reference/classes/LLMModule.md#frommodelname). This function is called whenever the download progress changes.
-
-## Running the model
-
-To run the model, you can use [`generate`](../../06-api-reference/classes/LLMModule.md#generate) method. It allows you to pass chat messages and receive completion from the model. It doesn't provide any message history management.
-
-Alternatively in managed chat (see: [Functional vs managed](../../03-hooks/01-natural-language-processing/useLLM.md#functional-vs-managed)), you can use the [`sendMessage`](../../06-api-reference/classes/LLMModule.md#sendmessage) method. It accepts the user message and returns a promise that resolves to the generated response. Additionally, it will call [`messageHistoryCallback`](../../06-api-reference/classes/LLMModule.md#messagehistorycallback) with the updated message history containing both user message and model response.
-
-If you need raw model access without any wrappers, you can use [`forward`](../../06-api-reference/classes/LLMModule.md#forward). It provides direct access to the model, so the input string is passed straight into the model and returns the generated response. It may be useful to work with models that aren't finetuned for chat completions. If you're not sure what are implications of that (e.g. that you have to include special model tokens), you're better off with [`sendMessage`](../../06-api-reference/classes/LLMModule.md#sendmessage).
-
-## Listening for generated tokens
-
-To subscribe to the token generation event, you can pass [`tokenCallback`](../../06-api-reference/classes/LLMModule.md#tokencallback) or [`messageHistoryCallback`](../../06-api-reference/classes/LLMModule.md#messagehistorycallback) functions to the constructor. [`tokenCallback`](../../06-api-reference/classes/LLMModule.md#tokencallback) is called on every token and contains only the most recent token. [`messageHistoryCallback`](../../06-api-reference/classes/LLMModule.md#messagehistorycallback) is called whenever model finishes generation and contains all message history including user's and model's last messages.
-
-## Interrupting the model
-
-In order to interrupt the model, you can use the [`interrupt`](../../06-api-reference/classes/LLMModule.md#interrupt) method.
-
-## Token Batching
-
-Depending on selected model and the user's device generation speed can be above 60 tokens per second. If the [`tokenCallback`](../../06-api-reference/classes/LLMModule.md#tokencallback) triggers rerenders and is invoked on every single token it can significantly decrease the app's performance. To alleviate this and help improve performance we've implemented token batching. To configure this you need to call [`configure`](../../06-api-reference/classes/LLMModule.md#configure) method and pass [`generationConfig`](../../06-api-reference/interfaces/LLMConfig.md#generationconfig). In the next section, there are listed what you can tweak with this config.
-
-## Configuring the model
-
-To configure model (i.e. change system prompt, load initial conversation history or manage tool calling, set generation settings) you can use
-[`configure`](../../06-api-reference/classes/LLMModule.md#configure) method. [**`chatConfig`**](../../06-api-reference/interfaces/LLMConfig.md#chatconfig) and [**`toolsConfig`**](../../06-api-reference/interfaces/LLMConfig.md#toolsconfig) is only applied to managed chats i.e. when using [`sendMessage`](../../06-api-reference/classes/LLMModule.md#sendmessage) (see: [Functional vs managed](../../03-hooks/01-natural-language-processing/useLLM.md#functional-vs-managed)) It accepts object with following fields:
-
-- [`chatConfig`](../../06-api-reference/interfaces/LLMConfig.md#chatconfig) - Object configuring chat management that contains:
-  - [`systemPrompt`](../../06-api-reference/interfaces/ChatConfig.md#systemprompt) - Often used to tell the model what is its purpose, for example - "Be a helpful translator".
-
-  - [`initialMessageHistory`](../../06-api-reference/interfaces/ChatConfig.md#initialmessagehistory) - Object that represent the conversation history. This can be used to provide initial context to the model.
-
-  - [`contextStrategy`](../../06-api-reference/interfaces/ChatConfig.md#contextstrategy) - Object implementing [`ContextStrategy`](../../06-api-reference/interfaces/ContextStrategy.md) interface used to manage conversation context, including trimming history if necessary. Custom strategies can be implemented or one of the built-in options can be used (e.g. [`NoopContextStrategy`](../../06-api-reference/classes/NoopContextStrategy.md), [`MessageCountContextStrategy`](../../06-api-reference/classes/MessageCountContextStrategy.md) or the default [`SlidingWindowContextStrategy`](../../06-api-reference/classes/SlidingWindowContextStrategy.md)).
-
-- [`toolsConfig`](../../06-api-reference/interfaces/ToolsConfig.md) - Object configuring options for enabling and managing tool use. **It will only have effect if your model's chat template support it**. Contains following properties:
-  - [`tools`](../../06-api-reference/interfaces/ToolsConfig.md#tools) - List of objects defining tools.
-
-  - [`executeToolCallback`](../../06-api-reference/interfaces/ToolsConfig.md#executetoolcallback) - Function that accepts [`ToolCall`](../../06-api-reference/interfaces/ToolCall.md), executes tool and returns the string to model.
-
-  - [`displayToolCalls`](../../06-api-reference/interfaces/ToolsConfig.md#displaytoolcalls) - If set to `true`, JSON tool calls will be displayed in chat. If `false`, only answers will be displayed.
-
-- [`generationConfig`](../../06-api-reference/interfaces/LLMConfig.md#generationconfig) - Object configuring generation settings with following properties:
-  - [`outputTokenBatchSize`](../../06-api-reference/interfaces/GenerationConfig.md#batchtimeinterval) - Soft upper limit on the number of tokens in each token batch (in certain cases there can be more tokens in given batch, i.e. when the batch would end with special emoji join character).
-
-  - [`batchTimeInterval`](../../06-api-reference/interfaces/GenerationConfig.md#batchtimeinterval) - Upper limit on the time interval between consecutive token batches.
-
-  - [`temperature`](../../06-api-reference/interfaces/GenerationConfig.md#temperature) - Scales output logits by the inverse of temperature. Controls the randomness / creativity of text generation.
-
-  - [`topP`](../../06-api-reference/interfaces/GenerationConfig.md#topp) - Only samples from the smallest set of tokens whose cumulative probability exceeds topP. Range `[0, 1]`. Values of `0` or `1` disable top-p filtering.
-
-  - [`minP`](../../06-api-reference/interfaces/GenerationConfig.md#minp) - Minimum-probability threshold applied after softmax: tokens whose probability is below `minP * max_prob` are excluded from sampling. Range `[0, 1]`. Default `0` disables the filter. Stacks with `topP` when both are set.
-
-  - [`repetitionPenalty`](../../06-api-reference/interfaces/GenerationConfig.md#repetitionpenalty) - Multiplicative penalty applied to logits of tokens that already appeared in the prompt or the generated text. Values greater than `1` discourage repetition; default `1` disables the penalty.
-
-:::info[Built-in models ship with sampling defaults]
-Model presets expose an optional `generationConfig` that `LLMModule.fromModelName` applies automatically when available — for Qwen3 and LFM2-VL this means the model-card recommended sampling settings are in effect without any explicit `configure` call. Any fields you pass to `configure` still override on a per-field basis.
-:::
-
-## Vision-Language Models (VLM)
-
-Some models support multimodal input — text, images and/or audio together. To use them, pass `capabilities` in the model object when calling [`fromModelName`](../../06-api-reference/classes/LLMModule.md#frommodelname):
-
-```typescript
-import { models, LLMModule } from 'react-native-executorch';
-const llm = await LLMModule.fromModelName(
-  models.llm.gemma4_e2b_multimodal(),
-  undefined,
-  (token) => console.log(token)
-);
-```
-
-The `capabilities` field is already set on the model constant. You can also construct the model object explicitly:
-
-```typescript
-const llm = await LLMModule.fromModelName({
-  modelName: 'gemma4-e2b-multimodal',
-  modelSource: require('./path/to/model.pte'),
-  tokenizerSource: require('./path/to/tokenizer.json'),
-  tokenizerConfigSource: require('./path/to/tokenizer_config.json'),
-  capabilities: ['vision', 'audio'],
-});
-```
-
-Once loaded, pass `imagePath` or `audioBuffer` to [`sendMessage`](../../06-api-reference/classes/LLMModule.md#sendmessage):
-
-```typescript
-const response = await llm.sendMessage('What is in this image?', {
-  imagePath: '/path/to/image.jpg',
-});
-// or
-const response = await llm.sendMessage('What can you hear?', {
-  audioBuffer: audioRecording, //expected as waveform 16kHz
-});
-```
-
-Or use [`generate`](../../06-api-reference/classes/LLMModule.md#generate) with `mediaPath` on the message:
-
-```typescript
-const chat: Message[] = [
-  {
-    role: 'user',
-    content: 'Describe this image.',
-    mediaPath: '/path/to/image.jpg',
-  },
-];
-// or
-const chat: Message[] = [
-  {
-    role: 'user',
-    content: 'Transcribe the recording.',
-    audioWaveform: audioRecording,
-  },
-];
-const response = await llm.generate(chat);
-```
-
-## Using a custom model
-
-Use [`fromCustomModel`](../../06-api-reference/classes/LLMModule.md#fromcustommodel) to load your own exported LLM instead of a built-in preset:
-
-```typescript
-import { LLMModule } from 'react-native-executorch';
-const llm = await LLMModule.fromCustomModel(
-  'https://example.com/model.pte',
-  'https://example.com/tokenizer.json',
-  'https://example.com/tokenizer_config.json',
-  (progress) => console.log(progress),
-  (token) => console.log(token),
-  (messages) => console.log(messages)
-);
-```
-
-### Required model contract
-
-The `.pte` model binary must be exported following the [ExecuTorch LLM export process](https://docs.pytorch.org/executorch/1.1/llm/export-llm.html). The native runner expects the standard ExecuTorch text-generation interface — KV-cache management, prefill/decode phases, and logit sampling are all handled by the runtime.
-
-## Deleting the model from memory
-
-To delete the model from memory, you can use the [`delete`](../../06-api-reference/classes/LLMModule.md#delete) method.
diff --git a/docs/docs/04-typescript-api/01-natural-language-processing/PrivacyFilterModule.md b/docs/docs/04-typescript-api/01-natural-language-processing/PrivacyFilterModule.md
deleted file mode 100644
index 8a9b24d263..0000000000
--- a/docs/docs/04-typescript-api/01-natural-language-processing/PrivacyFilterModule.md
+++ /dev/null
@@ -1,51 +0,0 @@
----
-title: PrivacyFilterModule
----
-
-TypeScript API implementation of the [usePrivacyFilter](../../03-hooks/01-natural-language-processing/usePrivacyFilter.md) hook.
-
-## API Reference
-
-- For detailed API Reference for `PrivacyFilterModule` see: [`PrivacyFilterModule` API Reference](../../06-api-reference/classes/PrivacyFilterModule.md).
-- For all Privacy Filter models available out-of-the-box in React Native ExecuTorch see: [Privacy Filter Models](../../06-api-reference/index.md#models---privacy-filter).
-
-## High Level Overview
-
-```typescript
-import { models, PrivacyFilterModule } from 'react-native-executorch';
-const model = await PrivacyFilterModule.fromModelName(
-  models.privacy_filter.openai(),
-  (progress) => console.log(progress)
-);
-
-const entities = await model.generate('My name is Sarah Chen.');
-```
-
-### Methods
-
-All methods of `PrivacyFilterModule` are explained in details here: [`PrivacyFilterModule` API Reference](../../06-api-reference/classes/PrivacyFilterModule.md)
-
-## Loading the model
-
-To create a ready-to-use instance for a built-in preset, call the static [`fromModelName`](../../06-api-reference/classes/PrivacyFilterModule.md#frommodelname) factory with the following parameters:
-
-- `namedSources` — Object containing:
-  - `modelName` — Built-in preset identifier (`'privacy-filter-openai'` or `'privacy-filter-nemotron'`). The runner resolves the matching BIOES label list from this value.
-  - `modelSource` — Location of the `.pte` model binary.
-  - `tokenizerSource` — Location of the `tokenizer.json` file.
-
-- `onDownloadProgress` — Optional callback to track download progress (value between 0 and 1).
-
-The factory returns a promise that resolves to a loaded `PrivacyFilterModule` instance.
-
-For custom-exported models with a non-standard label space, use [`fromCustomModel`](../../06-api-reference/classes/PrivacyFilterModule.md#fromcustommodel) instead. It takes `modelSource`, `tokenizerSource`, and a `labelNames` array (BIOES; index 0 must be `"O"`, the rest must follow the model's `id2label` mapping exactly), plus an optional `options` object with `viterbiBiases` (six-field bias struct that shifts the decoder's precision/recall tradeoff; defaults to neutral validity-only Viterbi) and `onDownloadProgress`.
-
-For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-## Running the model
-
-To run the model, call the [`generate`](../../06-api-reference/classes/PrivacyFilterModule.md#generate) method on the module object with the text you want to scan. The method returns a promise that resolves to an array of detected PII entity spans. Long inputs are processed in sliding windows with 50% overlap (window size derived from the model's exported `forward` input shape); no truncation.
-
-## Managing memory
-
-The module is a regular JavaScript object, and as such its lifespan will be managed by the garbage collector. In most cases this should be enough, and you should not worry about freeing the memory of the module yourself, but in some cases you may want to release the memory occupied by the module before the garbage collector steps in. In this case use the method [`delete`](../../06-api-reference/classes/PrivacyFilterModule.md#delete) on the module object you will no longer use, and want to remove from the memory. Note that you cannot use [`generate`](../../06-api-reference/classes/PrivacyFilterModule.md#generate) after [`delete`](../../06-api-reference/classes/PrivacyFilterModule.md#delete) unless you load the module again.
diff --git a/docs/docs/04-typescript-api/01-natural-language-processing/SpeechToTextModule.md b/docs/docs/04-typescript-api/01-natural-language-processing/SpeechToTextModule.md
deleted file mode 100644
index 989fc4fe6e..0000000000
--- a/docs/docs/04-typescript-api/01-natural-language-processing/SpeechToTextModule.md
+++ /dev/null
@@ -1,181 +0,0 @@
----
-title: SpeechToTextModule
----
-
-The `SpeechToTextModule` class provides a direct interface to the library's speech-to-text (STT) capabilities. While [`useSpeechToText`](../../03-hooks/01-natural-language-processing/useSpeechToText.md) is the preferred way for React components, this module offers full control over the model's lifecycle and is suitable for non-React contexts or advanced use cases.
-
-## API Reference
-
-- [`SpeechToTextModule` API Reference](../../06-api-reference/classes/SpeechToTextModule.md)
-- [STT Models List](../../06-api-reference/index.md#models---speech-to-text)
-
-## High Level Overview
-
-You can transcribe audio in two ways: **one-shot** (for files/short clips) and **streaming** (for live microphone input).
-
-```typescript
-import { SpeechToTextModule, models } from 'react-native-executorch';
-
-// Initialize the model with VAD submodule
-const model = await SpeechToTextModule.fromModelName(
-  models.speech_to_text.whisper_tiny_en(),
-  models.vad.fsmn_vad(), // Optional VAD submodule
-  (progress) => {
-    console.log(`Loading: ${progress * 100}%`);
-  }
-);
-
-// 1. One-shot transcription (returns TranscriptionResult)
-const result = await model.transcribe(waveform);
-console.log(result.text);
-
-// 2. Live streaming (yields partial/stable results)
-model.streamInsert(audioChunk);
-const stream = model.stream({ useVAD: true }); // Enable VAD logic
-for await (const { committed, nonCommitted } of stream) {
-  // Update UI live with stable and partial text
-}
-```
-
-## Loading the model
-
-Use the static [`fromModelName`](../../06-api-reference/classes/SpeechToTextModule.md#frommodelname) factory method. It accepts a configuration object with the following fields:
-
-- [`isMultilingual`](../../06-api-reference/interfaces/SpeechToTextModelConfig.md#ismultilingual) - Flag indicating if model is multilingual.
-- [`modelSource`](../../06-api-reference/interfaces/SpeechToTextModelConfig.md#modelsource) - The location of the used model (bundled encoder + decoder functionality).
-- [`tokenizerSource`](../../06-api-reference/interfaces/SpeechToTextModelConfig.md#tokenizersource) - The location of the used tokenizer.
-
-And an optional second argument:
-
-- `onDownloadProgress` - Callback to track download progress (returns a value between 0 and 1).
-
-For more information on resource management, see [loading models](../../01-fundamentals/02-loading-models.md).
-
-## Transcription (Files & Short Clips)
-
-To run transcription on a complete audio clip, use the [`transcribe`](../../06-api-reference/classes/SpeechToTextModule.md#transcribe) method. It accepts a `Float32Array` representing a waveform at **16kHz sampling rate**.
-
-### Transcribe Options
-
-The `transcribe()` function accepts an optional configuration object:
-
-- `language`: The language code (e.g., `'es'`, `'fr'`). Required for multilingual models.
-- `verbose`: If `true`, the method returns a detailed `TranscriptionResult` object following the OpenAI Whisper `verbose_json` format (including segments and word-level timestamps).
-
-## Live Streaming Transcription
-
-The **Streaming API** is optimized for live microphone input or real-time audio feeds. It handles audio inputs of arbitrary length by automatically managing context windows to bypass the standard 30-second limit.
-
-### Streaming Options
-
-The `stream()` function accepts several optional parameters:
-
-- `language`: The language code (e.g., `'es'`, `'fr'`). Required for multilingual models.
-- `verbose`: If `true`, includes word-level timestamps and segment metadata in the result objects.
-- `timeout`: (Advanced) The interval (in milliseconds) between processing consecutive audio chunks. Lower values provide more frequent updates, while higher values reduce CPU consumption. Defaults to `100`.
-- `useVAD`: Enable the Voice Activity Detection submodule (if configured during load) to improve performance by skipping silence.
-
-:::info
-
-- **`committed`**: Finalized transcription that is stable and will not change. Useful for building a persistent transcript record.
-- **`nonCommitted`**: Partial transcription that is still being processed and may update as more context arrives. Useful for live UI updates.
-  :::
-
-### Live Example
-
-In this example, we use [`react-native-audio-api`](https://docs.swmansion.com/react-native-audio-api/) to feed live audio into the model.
-
-```tsx
-import { SpeechToTextModule, models } from 'react-native-executorch';
-import { AudioManager, AudioRecorder } from 'react-native-audio-api';
-
-const model = await SpeechToTextModule.fromModelName(
-  models.speech_to_text.whisper_tiny_en(),
-  models.vad.fsmn_vad()
-);
-
-// 1. Configure audio session & permissions
-AudioManager.setAudioSessionOptions({
-  iosCategory: 'playAndRecord',
-  iosMode: 'spokenAudio',
-  iosOptions: ['allowBluetoothHFP', 'defaultToSpeaker'],
-});
-await AudioManager.requestRecordingPermissions();
-
-// 2. Setup Audio Recorder
-const recorder = new AudioRecorder();
-
-recorder.onAudioReady(
-  { sampleRate: 16000, bufferLength: 1600, channelCount: 1 },
-  (chunk) => {
-    // Feed chunks directly into the model's buffer
-    model.streamInsert(chunk.buffer.getChannelData(0));
-  }
-);
-
-await recorder.start();
-
-// 3. Process the Stream
-try {
-  let stableTranscript = '';
-  const streamIter = model.stream({ useVAD: true });
-
-  for await (const { committed, nonCommitted } of streamIter) {
-    if (committed.text) stableTranscript += committed.text;
-
-    // UI should display: stableTranscript + nonCommitted.text
-    console.log('Live Transcript:', stableTranscript + nonCommitted.text);
-  }
-} catch (error) {
-  console.error('Streaming error:', error);
-}
-
-// 4. Cleanup
-model.streamStop();
-recorder.stop();
-```
-
-## Advanced Features
-
-### VAD Integration (Recommended for Live)
-
-Integrating **Voice Activity Detection (VAD)** as a submodule improves streaming performance by automatically removing silence. This reduces CPU usage, saves battery, and prevents hallucinations during silent periods.
-
-To use it, provide the VAD model configuration when loading the module and enable `useVAD` in the stream options:
-
-```typescript
-const model = await SpeechToTextModule.fromModelName(
-  models.speech_to_text.whisper_tiny_en(),
-  models.vad.fsmn_vad()
-);
-
-// Enable VAD logic in the stream context
-const stream = model.stream({ useVAD: true });
-```
-
-### Multilingual Transcription
-
-If you aim to obtain a transcription in languages other than English, use a multilingual Whisper model. To get the output in your desired language, pass the [`DecodingOptions`](../../06-api-reference/interfaces/DecodingOptions.md) object with the [`language`](../../06-api-reference/interfaces/DecodingOptions.md#language) field set to the target language code.
-
-```typescript
-const transcription = await model.transcribe(spanishAudio, { language: 'es' });
-```
-
-### Timestamps & Detailed Results
-
-Set `verbose: true` in the options to obtain word-level timestamps and other parameters. The result mimics the _verbose_json_ format from OpenAI Whisper API.
-
-```typescript
-const result = await model.transcribe(audioBuffer, { verbose: true });
-```
-
-## Supported models
-
-| Model                                                              |   Language   |
-| ------------------------------------------------------------------ | :----------: |
-| [whisper-tiny.en](https://huggingface.co/openai/whisper-tiny.en)   |   English    |
-| [whisper-tiny](https://huggingface.co/openai/whisper-tiny)         | Multilingual |
-| [whisper-base.en](https://huggingface.co/openai/whisper-base.en)   |   English    |
-| [whisper-base](https://huggingface.co/openai/whisper-base)         | Multilingual |
-| [whisper-small.en](https://huggingface.co/openai/whisper-small.en) |   English    |
-| [whisper-small](https://huggingface.co/openai/whisper-small)       | Multilingual |
diff --git a/docs/docs/04-typescript-api/01-natural-language-processing/TextEmbeddingsModule.md b/docs/docs/04-typescript-api/01-natural-language-processing/TextEmbeddingsModule.md
deleted file mode 100644
index aa563c213d..0000000000
--- a/docs/docs/04-typescript-api/01-natural-language-processing/TextEmbeddingsModule.md
+++ /dev/null
@@ -1,42 +0,0 @@
----
-title: TextEmbeddingsModule
----
-
-TypeScript API implementation of the [useTextEmbeddings](../../03-hooks/01-natural-language-processing/useTextEmbeddings.md) hook.
-
-## API Reference
-
-- For detailed API Reference for `TextEmbeddingsModule` see: [`TextEmbeddingsModule` API Reference](../../06-api-reference/classes/TextEmbeddingsModule.md).
-- For all text embeddings models available out-of-the-box in React Native ExecuTorch see: [Text Embeddings Models](../../06-api-reference/index.md#models---text-embeddings).
-
-## High Level Overview
-
-```typescript
-import { models, TextEmbeddingsModule } from 'react-native-executorch';
-// Creating an instance and loading the model
-const textEmbeddingsModule = await TextEmbeddingsModule.fromModelName(
-  models.text_embedding.all_minilm_l6_v2()
-);
-
-// Running the model
-const embedding = await textEmbeddingsModule.forward('Hello World!');
-```
-
-### Methods
-
-All methods of `TextEmbeddingsModule` are explained in details here: [`TextEmbeddingsModule` API Reference](../../06-api-reference/classes/TextEmbeddingsModule.md)
-
-## Loading the model
-
-Use the static [`fromModelName`](../../06-api-reference/classes/TextEmbeddingsModule.md#frommodelname) factory method. It accepts a model config object (e.g. `ALL_MINILM_L6_V2`) containing:
-
-- [`modelSource`](../../06-api-reference/classes/TextEmbeddingsModule.md#modelsource) - Location of the used model.
-- [`tokenizerSource`](../../06-api-reference/classes/TextEmbeddingsModule.md#tokenizersource) - Location of the used tokenizer.
-
-And an optional `onDownloadProgress` callback. It returns a promise resolving to a `TextEmbeddingsModule` instance.
-
-For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-## Running the model
-
-To run the model, you can use the [`forward`](../../06-api-reference/classes/TextEmbeddingsModule.md#forward) method. It accepts one argument, which is the text you want to embed. The method returns a promise, which can resolve either to an error or an array of numbers representing the embedding.
diff --git a/docs/docs/04-typescript-api/01-natural-language-processing/TextToSpeechModule.md b/docs/docs/04-typescript-api/01-natural-language-processing/TextToSpeechModule.md
deleted file mode 100644
index f18abe1029..0000000000
--- a/docs/docs/04-typescript-api/01-natural-language-processing/TextToSpeechModule.md
+++ /dev/null
@@ -1,145 +0,0 @@
----
-title: TextToSpeechModule
----
-
-TypeScript API implementation of the [useTextToSpeech](../../03-hooks/01-natural-language-processing/useTextToSpeech.md) hook.
-
-## API Reference
-
-- For detailed API Reference for `TextToSpeechModule` see: [`TextToSpeechModule` API Reference](../../06-api-reference/classes/TextToSpeechModule.md).
-- For all text to speech models available out-of-the-box in React Native ExecuTorch see: [TTS Models](../../06-api-reference/index.md#models---text-to-speech).
-- For all supported voices in `TextToSpeechModule` please refer to: [Supported Voices](../../06-api-reference/index.md#tts-supported-voices)
-
-## High Level Overview
-
-```typescript
-import { models, TextToSpeechModule } from 'react-native-executorch';
-const model = await TextToSpeechModule.fromModelName(
-  models.text_to_speech.kokoro.en_us.heart(),
-  (progress) => console.log(progress)
-);
-
-await model.forward(text, 1.0);
-```
-
-### Methods
-
-All methods of `TextToSpeechModule` are explained in details here: [`TextToSpeechModule` API Reference](../../06-api-reference/classes/TextToSpeechModule.md)
-
-## Loading the model
-
-Use the static [`fromModelName`](../../06-api-reference/classes/TextToSpeechModule.md#frommodelname) factory method with the following parameters:
-
-- [`config`](../../06-api-reference/interfaces/TextToSpeechModelConfig.md) - Object containing:
-  - [`model`](../../06-api-reference/interfaces/TextToSpeechModelConfig.md#model) - Model configuration.
-  - [`voiceSource`](../../06-api-reference/interfaces/TextToSpeechModelConfig.md#voicesource) - Voice resource source.
-  - [`phonemizerConfig`](../../06-api-reference/interfaces/TextToSpeechModelConfig.md#phonemizerconfig) - Phonemizer configuration.
-
-- [`onDownloadProgress`](../../06-api-reference/classes/TextToSpeechModule.md#frommodelname) - Optional callback to track download progress (value between 0 and 1).
-
-This method returns a promise that resolves to a `TextToSpeechModule` instance once the assets are downloaded and loaded into memory.
-
-For more information on resource sources, see [loading models](../../01-fundamentals/02-loading-models.md).
-
-## Running the model
-
-The module provides a way to generate speech using either raw text or pre-generated phonemes.
-
-### Methods
-
-1.  [**`forward(text, speed, phonemize)`**](../../06-api-reference/classes/TextToSpeechModule.md#forward): Generates the complete audio waveform at once. Returns a promise resolving to a `Float32Array`.
-    - `phonemize` defaults to `true`. When set to `false`, the input is expected to be a string of IPA phonemes.
-2.  [**`stream({ speed, phonemize, stopAutomatically, ... })`**](../../06-api-reference/classes/TextToSpeechModule.md#stream): An async generator that yields chunks of audio as they are computed. This is ideal for reducing the "time to first audio" for long sentences. In contrast to `forward`, it enables inserting text chunks dynamically into the processing buffer with [**`streamInsert(text)`**](../../06-api-reference/classes/TextToSpeechModule.md#streaminsert), force-partitioning trailing un-terminated content via [**`streamFlush()`**](../../06-api-reference/classes/TextToSpeechModule.md#streamflush), and stopping generation early with [**`streamStop(instant)`**](../../06-api-reference/classes/TextToSpeechModule.md#streamstop).
-
-### Using Phonemes
-
-If you have pre-computed phonemes (e.g., from an external dictionary or a custom G2P model), you can skip the internal phoneme generation step by setting `phonemize: false` in the `forward` or `stream` methods.
-
-:::note
-Since `forward` processes the entire input at once, it might take a significant amount of time to produce audio for long inputs.
-:::
-
-## Example
-
-### Speech Synthesis
-
-```typescript
-import { models, TextToSpeechModule } from 'react-native-executorch';
-import { AudioContext } from 'react-native-audio-api';
-
-const tts = await TextToSpeechModule.fromModelName(
-  models.text_to_speech.kokoro.en_us.heart()
-);
-const audioContext = new AudioContext({ sampleRate: 24000 });
-
-try {
-  const waveform = await tts.forward('Hello from ExecuTorch!', 1.0);
-
-  // Create audio buffer and play
-  const audioBuffer = audioContext.createBuffer(1, waveform.length, 24000);
-  audioBuffer.getChannelData(0).set(waveform);
-
-  const source = audioContext.createBufferSource();
-  source.buffer = audioBuffer;
-  source.connect(audioContext.destination);
-  source.start();
-} catch (error) {
-  console.error('Text-to-speech failed:', error);
-}
-```
-
-### Streaming Synthesis
-
-```typescript
-import { models, TextToSpeechModule } from 'react-native-executorch';
-import { AudioContext } from 'react-native-audio-api';
-
-const tts = await TextToSpeechModule.fromModelName(
-  models.text_to_speech.kokoro.en_us.heart()
-);
-const audioContext = new AudioContext({ sampleRate: 24000 });
-
-try {
-  for await (const chunk of tts.stream({
-    text: 'This is a streaming test, with a sample input.',
-    speed: 1.0,
-  })) {
-    // Play each chunk sequentially
-    await new Promise<void>((resolve) => {
-      const audioBuffer = audioContext.createBuffer(1, chunk.length, 24000);
-      audioBuffer.getChannelData(0).set(chunk);
-
-      const source = audioContext.createBufferSource();
-      source.buffer = audioBuffer;
-      source.connect(audioContext.destination);
-      source.onEnded = () => resolve();
-      source.start();
-    });
-  }
-} catch (error) {
-  console.error('Streaming failed:', error);
-}
-```
-
-### Synthesis from Phonemes
-
-If you already have a phoneme string (e.g., from an external library), you can use `forward` or `stream` with the `phonemize: false` flag to synthesize audio directly, skipping the internal phonemizer stage.
-
-```typescript
-import { models, TextToSpeechModule } from 'react-native-executorch';
-const tts = await TextToSpeechModule.fromModelName(
-  models.text_to_speech.kokoro.en_us.heart()
-);
-
-// Example phonemes for "ExecuTorch"
-const waveform = await tts.forward('həlˈO wˈɜɹld!', 1.0, false);
-
-// Or stream from phonemes
-for await (const chunk of tts.stream({
-  text: 'ɐ mˈæn hˌu dˈʌzᵊnt tɹˈʌst hɪmsˈɛlf, kæn nˈɛvəɹ ɹˈiᵊli tɹˈʌst ˈɛniwˌʌn ˈɛls.',
-  speed: 1.0,
-  phonemize: false,
-})) {
-  // ... process chunk ...
-}
-```
diff --git a/docs/docs/04-typescript-api/01-natural-language-processing/TokenizerModule.md b/docs/docs/04-typescript-api/01-natural-language-processing/TokenizerModule.md
deleted file mode 100644
index f85178fe09..0000000000
--- a/docs/docs/04-typescript-api/01-natural-language-processing/TokenizerModule.md
+++ /dev/null
@@ -1,47 +0,0 @@
----
-title: TokenizerModule
----
-
-TypeScript API implementation of the [useTokenizer](../../03-hooks/01-natural-language-processing/useTokenizer.md) hook.
-
-## API Reference
-
-- For detailed API Reference for `TokenizerModule` see: [`TokenizerModule` API Reference](../../06-api-reference/classes/TokenizerModule.md).
-
-## High Level Overview
-
-```typescript
-import { models, TokenizerModule } from 'react-native-executorch';
-// Creating an instance
-const tokenizerModule = new TokenizerModule();
-
-// Load the tokenizer
-await tokenizerModule.load(models.text_embedding.all_minilm_l6_v2());
-console.log('Tokenizer loaded');
-
-// Get tokenizers vocabulary size
-const vocabSize = await tokenizerModule.getVocabSize();
-console.log('Vocabulary size:', vocabSize);
-
-const text = 'Hello, world!';
-
-// Tokenize the text
-const tokens = await tokenizerModule.encode(text);
-console.log('Token IDs:', tokens);
-
-// Decode the tokens back to text
-const decoded = await tokenizerModule.decode(tokens);
-console.log('Decoded text:', decoded);
-
-// Get the token ID for a specific token
-const tokenId = await tokenizerModule.tokenToId('hello');
-console.log('Token ID for "Hello":', tokenId);
-
-// Get the token for a specific ID
-const token = await tokenizerModule.idToToken(tokenId);
-console.log('Token for ID:', token);
-```
-
-### Methods
-
-All methods of `TokenizerModule` are explained in details here: [`TokenizerModule API Reference`](../../06-api-reference/classes/TokenizerModule.md)
diff --git a/docs/docs/04-typescript-api/01-natural-language-processing/VADModule.md b/docs/docs/04-typescript-api/01-natural-language-processing/VADModule.md
deleted file mode 100644
index c9113b561b..0000000000
--- a/docs/docs/04-typescript-api/01-natural-language-processing/VADModule.md
+++ /dev/null
@@ -1,59 +0,0 @@
----
-title: VADModule
----
-
-TypeScript API implementation of the [useVAD](../../03-hooks/01-natural-language-processing/useVAD.md) hook.
-
-## API Reference
-
-- For detailed API Reference for `VADModule` see: [`VADModule` API Reference](../../06-api-reference/classes/VADModule.md).
-- For all VAD models available out-of-the-box in React Native ExecuTorch see: [VAD Models](../../06-api-reference/index.md#models---voice-activity-detection).
-
-## High Level Overview
-
-```typescript
-import { models, VADModule } from 'react-native-executorch';
-const model = await VADModule.fromModelName(models.vad.fsmn_vad(), (progress) =>
-  console.log(progress)
-);
-
-await model.forward(waveform);
-```
-
-### Methods
-
-All methods of `VADModule` are explained in detail here: [`VADModule` API Reference](../../06-api-reference/classes/VADModule.md)
-
-## Loading the model
-
-To create a ready-to-use instance, call the static [`fromModelName`](../../06-api-reference/classes/VADModule.md#frommodelname) factory with the following parameters:
-
-- `namedSources` - Object containing:
-  - `modelName` - Model name identifier.
-  - `modelSource` - Location of the model binary.
-
-- `onDownloadProgress` - Optional callback to track download progress (value between 0 and 1).
-
-The factory returns a promise that resolves to a loaded `VADModule` instance.
-
-For more information on loading resources, take a look at the [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-## Running the model
-
-### File Processing
-
-To process a full audio buffer at once, use the [`forward`](../../06-api-reference/classes/VADModule.md#forward) method. Before calling [`forward`](../../06-api-reference/classes/VADModule.md#forward), ensure you have the audio waveform sampled at 16 kHz. Pass the waveform as an argument; the method returns a promise that resolves to an array of detected speech segments.
-
-### Live Streaming
-
-For real-time applications, `VADModule` supports a streaming mode that identifies speech events as audio arrives.
-
-1.  **Initialize the stream**: Call [`stream`](../../06-api-reference/classes/VADModule.md#stream) with `onSpeechBegin` and `onSpeechEnd` callbacks.
-2.  **Insert audio**: Use [`streamInsert`](../../06-api-reference/classes/VADModule.md#streaminsert) to push new audio chunks into the internal buffer.
-3.  **Stop the stream**: Use [`streamStop`](../../06-api-reference/classes/VADModule.md#streamstop) to finish detection and release resources.
-
-Refer to the [`useVAD`](../../03-hooks/01-natural-language-processing/useVAD.md#live-streaming-real-time-detection) hook documentation for a detailed example of the streaming architecture.
-
-## Managing memory
-
-The module is a regular JavaScript object, and as such its lifespan will be managed by the garbage collector. In most cases this should be enough, and you should not worry about freeing the memory of the module yourself, but in some cases you may want to release the memory occupied by the module before the garbage collector steps in. In this case use the method [`delete`](../../06-api-reference/classes/VADModule.md#delete) on the module object you will no longer use, and want to remove from the memory. Note that you cannot use [`forward`](../../06-api-reference/classes/VADModule.md#forward) after [`delete`](../../06-api-reference/classes/VADModule.md#delete) unless you load the module again.
diff --git a/docs/docs/04-typescript-api/01-natural-language-processing/_category_.json b/docs/docs/04-typescript-api/01-natural-language-processing/_category_.json
deleted file mode 100644
index 0314f315d2..0000000000
--- a/docs/docs/04-typescript-api/01-natural-language-processing/_category_.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "label": "Natural Language Processing",
-  "link": {
-    "type": "generated-index"
-  }
-}
diff --git a/docs/docs/04-typescript-api/02-computer-vision/ClassificationModule.md b/docs/docs/04-typescript-api/02-computer-vision/ClassificationModule.md
deleted file mode 100644
index 8f7802686c..0000000000
--- a/docs/docs/04-typescript-api/02-computer-vision/ClassificationModule.md
+++ /dev/null
@@ -1,73 +0,0 @@
----
-title: ClassificationModule
----
-
-TypeScript API implementation of the [useClassification](../../03-hooks/02-computer-vision/useClassification.md) hook.
-
-## API Reference
-
-- For detailed API Reference for `ClassificationModule` see: [`ClassificationModule` API Reference](../../06-api-reference/classes/ClassificationModule.md).
-- For all classification models available out-of-the-box in React Native ExecuTorch see: [Classification Models](../../06-api-reference/index.md#models---classification).
-
-## High Level Overview
-
-```typescript
-import { models, ClassificationModule } from 'react-native-executorch';
-const imageUri = 'path/to/image.png';
-
-// Creating and loading the module
-const classificationModule = await ClassificationModule.fromModelName(
-  models.classification.efficientnet_v2_s()
-);
-
-// Running the model
-const classesWithProbabilities = await classificationModule.forward(imageUri);
-```
-
-### Methods
-
-All methods of `ClassificationModule` are explained in details here: [`ClassificationModule` API Reference](../../06-api-reference/classes/ClassificationModule.md)
-
-## Loading the model
-
-Use the static [`fromModelName`](../../06-api-reference/classes/ClassificationModule.md#frommodelname) factory method. It accepts a model config object (e.g. `EFFICIENTNET_V2_S`) and an optional `onDownloadProgress` callback. It returns a promise resolving to a `ClassificationModule` instance.
-
-For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-## Running the model
-
-To run the model, use the [`forward`](../../06-api-reference/classes/ClassificationModule.md#forward) method. It accepts one argument — the image to classify. The image can be a remote URL, a local file URI, a base64-encoded image (whole URI or only raw base64), or a [`PixelData`](../../06-api-reference/interfaces/PixelData.md) object (raw RGB pixel buffer). The method returns a promise resolving to an object mapping label keys to their probabilities.
-
-For real-time frame processing, use [`runOnFrame`](../../03-hooks/02-computer-vision/visioncamera-integration.md) instead.
-
-## Using a custom model
-
-Use [`fromCustomModel`](../../06-api-reference/classes/ClassificationModule.md#fromcustommodel) to load your own exported model binary instead of a built-in preset.
-
-```typescript
-import { ClassificationModule } from 'react-native-executorch';
-const MyLabels = { CAT: 0, DOG: 1, BIRD: 2 } as const;
-
-const classifier = await ClassificationModule.fromCustomModel(
-  'https://example.com/custom_classifier.pte',
-  { labelMap: MyLabels },
-  (progress) => console.log(progress)
-);
-
-const result = await classifier.forward(imageUri);
-// result is typed as Record<'CAT' | 'DOG' | 'BIRD', number>
-```
-
-### Required model contract
-
-The `.pte` binary must expose a single `forward` method with the following interface:
-
-**Input:** one `float32` tensor of shape `[1, 3, H, W]` — a single RGB image, values in `[0, 1]` after optional per-channel normalization `(pixel − mean) / std`. H and W are read from the model's declared input shape at load time.
-
-**Output:** one `float32` tensor of shape `[1, C]` containing raw logits — one value per class, in the same order as the entries in your `labelMap`. Softmax is applied by the native runtime.
-
-Preprocessing (resize → normalize) is handled by the native runtime — your model only needs to produce the raw logits.
-
-## Managing memory
-
-The module is a regular JavaScript object, and as such its lifespan will be managed by the garbage collector. In most cases this should be enough, and you should not worry about freeing the memory of the module yourself, but in some cases you may want to release the memory occupied by the module before the garbage collector steps in. In this case use the method [`delete`](../../06-api-reference/classes/ClassificationModule.md#delete) on the module object you will no longer use, and want to remove from the memory. Note that you cannot use [`forward`](../../06-api-reference/classes/ClassificationModule.md#forward) after [`delete`](../../06-api-reference/classes/ClassificationModule.md#delete) unless you load the module again.
diff --git a/docs/docs/04-typescript-api/02-computer-vision/ImageEmbeddingsModule.md b/docs/docs/04-typescript-api/02-computer-vision/ImageEmbeddingsModule.md
deleted file mode 100644
index 132245a3f5..0000000000
--- a/docs/docs/04-typescript-api/02-computer-vision/ImageEmbeddingsModule.md
+++ /dev/null
@@ -1,49 +0,0 @@
----
-title: ImageEmbeddingsModule
----
-
-TypeScript API implementation of the [useImageEmbeddings](../../03-hooks/02-computer-vision/useImageEmbeddings.md) hook.
-
-## API Reference
-
-- For detailed API Reference for `ImageEmbeddingsModule` see: [`ImageEmbeddingsModule` API Reference](../../06-api-reference/classes/ImageEmbeddingsModule.md).
-- For all image embeddings models available out-of-the-box in React Native ExecuTorch see: [Image Embeddings Models](../../06-api-reference/index.md#models---image-embeddings).
-
-## High Level Overview
-
-```typescript
-import { models, ImageEmbeddingsModule } from 'react-native-executorch';
-// Creating and loading the module
-const imageEmbeddingsModule = await ImageEmbeddingsModule.fromModelName(
-  models.image_embedding.clip_vit_base_patch32_image()
-);
-
-// Running the model
-const embedding = await imageEmbeddingsModule.forward(
-  'https://url-to-image.jpg'
-);
-```
-
-### Methods
-
-All methods of `ImageEmbeddingsModule` are explained in details here: [`ImageEmbeddingsModule` API Reference](../../06-api-reference/classes/ImageEmbeddingsModule.md)
-
-## Loading the model
-
-To create a ready-to-use instance, call the static [`fromModelName`](../../06-api-reference/classes/ImageEmbeddingsModule.md#frommodelname) factory with the following parameters:
-
-- `namedSources` - Object containing:
-  - `modelName` - Model name identifier.
-  - `modelSource` - Location of the model binary.
-
-- `onDownloadProgress` - Optional callback to track download progress (value between 0 and 1).
-
-The factory returns a promise that resolves to a loaded `ImageEmbeddingsModule` instance.
-
-For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-## Running the model
-
-[`forward`](../../06-api-reference/classes/ImageEmbeddingsModule.md#forward) accepts one argument — the image to embed. The image can be a remote URL, a local file URI, a base64-encoded image (whole URI or only raw base64), or a [`PixelData`](../../06-api-reference/interfaces/PixelData.md) object (raw RGB pixel buffer). The method returns a promise resolving to a `Float32Array` representing the embedding.
-
-For real-time frame processing, use [`runOnFrame`](../../03-hooks/02-computer-vision/visioncamera-integration.md) instead.
diff --git a/docs/docs/04-typescript-api/02-computer-vision/InstanceSegmentationModule.md b/docs/docs/04-typescript-api/02-computer-vision/InstanceSegmentationModule.md
deleted file mode 100644
index 4220173dd3..0000000000
--- a/docs/docs/04-typescript-api/02-computer-vision/InstanceSegmentationModule.md
+++ /dev/null
@@ -1,120 +0,0 @@
----
-title: InstanceSegmentationModule
----
-
-TypeScript API implementation of the [useInstanceSegmentation](../../03-hooks/02-computer-vision/useInstanceSegmentation.md) hook.
-
-## API Reference
-
-- For detailed API Reference for `InstanceSegmentationModule` see: [`InstanceSegmentationModule` API Reference](../../06-api-reference/classes/InstanceSegmentationModule.md).
-
-## High Level Overview
-
-```typescript
-import { models, InstanceSegmentationModule } from 'react-native-executorch';
-const imageUri = 'path/to/image.png';
-
-// Creating an instance from a built-in model
-const segmentation = await InstanceSegmentationModule.fromModelName(
-  models.instance_segmentation.yolo26n()
-);
-
-// Running the model
-const instances = await segmentation.forward(imageUri);
-```
-
-### Methods
-
-All methods of `InstanceSegmentationModule` are explained in details here: [`InstanceSegmentationModule` API Reference](../../06-api-reference/classes/InstanceSegmentationModule.md)
-
-## Loading the model
-
-There are two ways to create an `InstanceSegmentationModule`:
-
-### From a built-in model
-
-Use [`fromModelName`](../../06-api-reference/classes/InstanceSegmentationModule.md#frommodelname) for pre-configured models. It accepts:
-
-- `config` - A model configuration object (e.g. `YOLO26N_SEG`, `YOLO26S_SEG`) imported from the library, containing:
-  - `modelName` - The name of a built-in model.
-  - `modelSource` - Location of the model binary (a URL or a bundled resource).
-- `onDownloadProgress` (optional) - Callback to track download progress, receiving a value between 0 and 1.
-
-```typescript
-import { models, InstanceSegmentationModule } from 'react-native-executorch';
-const segmentation = await InstanceSegmentationModule.fromModelName(
-  models.instance_segmentation.yolo26n()
-);
-```
-
-### From a custom config
-
-Use [`fromCustomModel`](../../06-api-reference/classes/InstanceSegmentationModule.md#fromcustommodel) for custom-exported models with your own label map. It accepts:
-
-- `modelSource` - Location of the model binary.
-- `config` - An [`InstanceSegmentationConfig`](../../06-api-reference/type-aliases/InstanceSegmentationConfig.md) object with:
-  - `labelMap` - An enum-like object mapping class names to indices.
-  - `preprocessorConfig` (optional) - Normalization parameters (`normMean`, `normStd`).
-  - `postprocessorConfig` (optional) - Postprocessing settings (`applyNMS`).
-  - `defaultConfidenceThreshold` (optional) - Default confidence threshold.
-  - `defaultIouThreshold` (optional) - Default IoU threshold.
-  - `availableInputSizes` (optional) - Array of supported input sizes (e.g., `[384, 512, 640]`). **Required** if your model exports multiple forward methods.
-  - `defaultInputSize` (optional) - The input size to use when `options.inputSize` is not provided. **Required** if `availableInputSizes` is specified.
-- `onDownloadProgress` (optional) - Callback to track download progress.
-
-:::tip
-If your model supports **multiple input sizes**, you must specify both `availableInputSizes` (an array of supported sizes) and `defaultInputSize` (the default size to use when no `inputSize` is provided in options). The model must expose separate methods named `forward_{inputSize}` for each size.
-
-If your model supports only **one input size**, omit both fields and export a single `forward` method.
-:::
-
-```typescript
-const MyLabels = { GRAPE_GREEN: 0, GRAPE_RED: 1, LEAF: 2 } as const;
-
-const segmentation = await InstanceSegmentationModule.fromCustomModel(
-  'https://huggingface.co/.../grape_seg.pte',
-  {
-    labelMap: MyLabels,
-    availableInputSizes: [640],
-    defaultInputSize: 640,
-    defaultConfidenceThreshold: 0.4,
-    postprocessorConfig: { applyNMS: true },
-  }
-);
-```
-
-For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-## Custom model output contract
-
-If you want to use a custom-exported model, it must conform to the following output contract:
-
-The model must produce **3 output tensors**:
-
-| Tensor      | Shape          | Description                                                     |
-| ----------- | -------------- | --------------------------------------------------------------- |
-| bboxes      | `[1, N, 4]`    | Bounding boxes as `[x1, y1, x2, y2]` in model input coordinates |
-| scores      | `[1, N, 2]`    | `[max_score, class_id]` — scores must be post-sigmoid           |
-| mask_logits | `[1, N, H, W]` | Per-detection binary mask logits — pre-sigmoid                  |
-
-### Method naming convention
-
-- If the model supports **multiple input sizes**, it must expose separate methods named `forward_{inputSize}` (e.g. `forward_384`, `forward_512`, `forward_640`).
-- If the model supports **only one input size**, it should expose a single `forward` method.
-
-## Running the model
-
-To run the model, use the [`forward`](../../06-api-reference/classes/InstanceSegmentationModule.md#forward) method. It accepts two arguments:
-
-- `imageSource` (required) - The image to process. Can be a remote URL, a local file URI, a base64-encoded image (whole URI or only raw base64), or a [`PixelData`](../../06-api-reference/interfaces/PixelData.md) object (raw RGB pixel buffer).
-- `options` (optional) - An [`InstanceSegmentationOptions`](../../06-api-reference/interfaces/InstanceSegmentationOptions.md) object for configuring the segmentation (confidence threshold, IoU threshold, input size, classes of interest, etc.).
-
-The method returns a promise resolving to an array of [`SegmentedInstance`](../../06-api-reference/interfaces/SegmentedInstance.md) objects. Each object contains bounding box coordinates, a binary segmentation mask, a string `label` (resolved from the model's label enum), and the confidence score.
-
-:::info
-Built-in YOLO models use [`CocoLabelYolo`](../../06-api-reference/enumerations/CocoLabelYolo.md) (80 classes, 0-indexed), not [`CocoLabel`](../../06-api-reference/enumerations/CocoLabel.md) (91 classes, 1-indexed, used by RF-DETR / SSDLite). When filtering with `classesOfInterest`, use the key names from `CocoLabelYolo`.
-:::
-
-## Managing memory
-
-The module is a regular JavaScript object, and as such its lifespan will be managed by the garbage collector. In most cases this should be enough, and you should not worry about freeing the memory of the module yourself, but in some cases you may want to release the memory occupied by the module before the garbage collector steps in. In this case use the method [`delete`](../../06-api-reference/classes/InstanceSegmentationModule.md#delete) on the module object you will no longer use, and want to remove from the memory. Note that you cannot use [`forward`](../../06-api-reference/classes/InstanceSegmentationModule.md#forward) after [`delete`](../../06-api-reference/classes/InstanceSegmentationModule.md#delete) unless you load the module again.
diff --git a/docs/docs/04-typescript-api/02-computer-vision/OCRModule.md b/docs/docs/04-typescript-api/02-computer-vision/OCRModule.md
deleted file mode 100644
index a1fac72f5c..0000000000
--- a/docs/docs/04-typescript-api/02-computer-vision/OCRModule.md
+++ /dev/null
@@ -1,48 +0,0 @@
----
-title: OCRModule
----
-
-TypeScript API implementation of the [useOCR](../../03-hooks/02-computer-vision/useOCR.md) hook.
-
-## API Reference
-
-- For detailed API Reference for `OCRModule` see: [`OCRModule` API Reference](../../06-api-reference/classes/OCRModule.md).
-- For all alphabets available in ocr out-of-the-box in React Native ExecuTorch see: [OCR Supported Alphabets](../../06-api-reference/index.md#ocr-supported-alphabets).
-
-## High Level Overview
-
-```typescript
-import { models, OCRModule } from 'react-native-executorch';
-const imageUri = 'path/to/image.png';
-
-// Creating an instance and loading the model
-const ocrModule = await OCRModule.fromModelName(
-  models.ocr.craft({ language: 'en' })
-);
-
-// Running the model
-const detections = await ocrModule.forward(imageUri);
-```
-
-### Methods
-
-All methods of `OCRModule` are explained in details here: [`OCRModule` API Reference](../../06-api-reference/classes/OCRModule.md)
-
-## Loading the model
-
-Use the static [`fromModelName`](../../06-api-reference/classes/OCRModule.md#frommodelname) factory method. It accepts a `namedSources` object (e.g. `OCR_ENGLISH`) containing:
-
-- `modelName` - Model name identifier.
-- [`detectorSource`](../../06-api-reference/classes/OCRModule.md#detectorsource) - Location of the used detector.
-- [`recognizerSource`](../../06-api-reference/classes/OCRModule.md#recognizersource) - Location of the used recognizer.
-- [`language`](../../06-api-reference/classes/OCRModule.md#recognizersource) - Language used in OCR.
-
-And an optional `onDownloadProgress` callback. It returns a promise resolving to an `OCRModule` instance.
-
-For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-## Running the model
-
-To run the model, use the [`forward`](../../06-api-reference/classes/OCRModule.md#forward) method. It accepts one argument — the image to recognize. The image can be a remote URL, a local file URI, a base64-encoded image (whole URI or only raw base64), or a [`PixelData`](../../06-api-reference/interfaces/PixelData.md) object (raw RGB pixel buffer). The method returns a promise resolving to an array of [`OCRDetection`](../../06-api-reference/interfaces/OCRDetection.md) objects, each containing the bounding box, recognized text, and confidence score.
-
-For real-time frame processing, use [`runOnFrame`](../../03-hooks/02-computer-vision/visioncamera-integration.md) instead.
diff --git a/docs/docs/04-typescript-api/02-computer-vision/ObjectDetectionModule.md b/docs/docs/04-typescript-api/02-computer-vision/ObjectDetectionModule.md
deleted file mode 100644
index 4b1e19982f..0000000000
--- a/docs/docs/04-typescript-api/02-computer-vision/ObjectDetectionModule.md
+++ /dev/null
@@ -1,93 +0,0 @@
----
-title: ObjectDetectionModule
----
-
-TypeScript API implementation of the [useObjectDetection](../../03-hooks/02-computer-vision/useObjectDetection.md) hook.
-
-## API Reference
-
-- For detailed API Reference for `ObjectDetectionModule` see: [`ObjectDetectionModule` API Reference](../../06-api-reference/classes/ObjectDetectionModule.md).
-- For all object detection models available out-of-the-box in React Native ExecuTorch see: [Object Detection Models](../../06-api-reference/index.md#models---object-detection).
-
-## High Level Overview
-
-```typescript
-import { models, ObjectDetectionModule } from 'react-native-executorch';
-const imageUri = 'path/to/image.png';
-
-// Creating an instance and loading the model
-const objectDetectionModule = await ObjectDetectionModule.fromModelName(
-  models.object_detection.ssdlite_320_mobilenet_v3_large()
-);
-
-// Running the model
-const detections = await objectDetectionModule.forward(imageUri);
-```
-
-### Methods
-
-All methods of `ObjectDetectionModule` are explained in details here: [`ObjectDetectionModule` API Reference](../../06-api-reference/classes/ObjectDetectionModule.md)
-
-## Loading the model
-
-Use the static [`fromModelName`](../../06-api-reference/classes/ObjectDetectionModule.md#frommodelname) factory method. It accepts a model config object (e.g. `SSDLITE_320_MOBILENET_V3_LARGE`) and an optional `onDownloadProgress` callback. It returns a promise resolving to an `ObjectDetectionModule` instance.
-
-For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-## Running the model
-
-To run the model, use the [`forward`](../../06-api-reference/classes/ObjectDetectionModule.md#forward) method. It accepts two arguments:
-
-- `input` (required) - The image to process. Can be a remote URL, a local file URI, a base64-encoded image (whole URI or only raw base64), or a [`PixelData`](../../06-api-reference/interfaces/PixelData.md) object (raw RGB pixel buffer).
-- `options` (optional) - An [`ObjectDetectionOptions`](../../06-api-reference/interfaces/ObjectDetectionOptions.md) object with:
-  - `detectionThreshold` (optional) - Minimum confidence score (0-1). Defaults to model-specific value.
-  - `iouThreshold` (optional) - IoU threshold for NMS (0-1). Defaults to model-specific value.
-  - `inputSize` (optional) - For YOLO models: `384`, `512`, or `640`. Defaults to `384`.
-  - `classesOfInterest` (optional) - Array of class labels to filter detections.
-
-The method returns a promise resolving to an array of [`Detection`](../../06-api-reference/interfaces/Detection.md) objects, each containing the bounding box, label, and confidence score.
-
-For real-time frame processing, use [`runOnFrame`](../../03-hooks/02-computer-vision/visioncamera-integration.md) instead.
-
-### Example with Options
-
-```typescript
-const detections = await model.forward(imageUri, {
-  detectionThreshold: 0.5,
-  inputSize: 640, // YOLO models only
-  classesOfInterest: ['PERSON', 'CAR'],
-});
-```
-
-## Using a custom model
-
-Use [`fromCustomModel`](../../06-api-reference/classes/ObjectDetectionModule.md#fromcustommodel) to load your own exported model binary instead of a built-in preset.
-
-```typescript
-import { ObjectDetectionModule } from 'react-native-executorch';
-const MyLabels = { BACKGROUND: 0, CAT: 1, DOG: 2 } as const;
-
-const detector = await ObjectDetectionModule.fromCustomModel(
-  'https://example.com/custom_detector.pte',
-  { labelMap: MyLabels },
-  (progress) => console.log(progress)
-);
-```
-
-### Required model contract
-
-The `.pte` binary must expose a single `forward` method with the following interface:
-
-**Input:** one `float32` tensor of shape `[1, 3, H, W]` — a single RGB image, values in `[0, 1]` after optional per-channel normalization `(pixel − mean) / std`. H and W are read from the model's declared input shape at load time.
-
-**Outputs:** exactly three `float32` tensors, in this order:
-
-1. **Bounding boxes** — flat `[4·N]` array of `(x1, y1, x2, y2)` coordinates in model-input pixel space.
-2. **Confidence scores** — flat `[N]` array of values in `[0, 1]`.
-3. **Class indices** — flat `[N]` array of `float32`-encoded integer class indices (0-based, matching the order of entries in your `labelMap`).
-
-Preprocessing (resize → normalize) and postprocessing (coordinate rescaling, threshold filtering, NMS) are handled by the native runtime.
-
-## Managing memory
-
-The module is a regular JavaScript object, and as such its lifespan will be managed by the garbage collector. In most cases this should be enough, and you should not worry about freeing the memory of the module yourself, but in some cases you may want to release the memory occupied by the module before the garbage collector steps in. In this case use the method [`delete`](../../06-api-reference/classes/ObjectDetectionModule.md#delete) on the module object you will no longer use, and want to remove from the memory. Note that you cannot use [`forward`](../../06-api-reference/classes/ObjectDetectionModule.md#forward) after [`delete`](../../06-api-reference/classes/ObjectDetectionModule.md#delete) unless you load the module again.
diff --git a/docs/docs/04-typescript-api/02-computer-vision/PoseEstimationModule.md b/docs/docs/04-typescript-api/02-computer-vision/PoseEstimationModule.md
deleted file mode 100644
index f8c2c7a173..0000000000
--- a/docs/docs/04-typescript-api/02-computer-vision/PoseEstimationModule.md
+++ /dev/null
@@ -1,110 +0,0 @@
----
-title: PoseEstimationModule
----
-
-TypeScript API implementation of the [usePoseEstimation](../../03-hooks/02-computer-vision/usePoseEstimation.md) hook.
-
-## API Reference
-
-- For detailed API Reference for `PoseEstimationModule` see: [`PoseEstimationModule` API Reference](../../06-api-reference/classes/PoseEstimationModule.md).
-- For all pose estimation models available out-of-the-box in React Native ExecuTorch see: [Pose Estimation Models](../../06-api-reference/index.md#models---pose-estimation).
-
-## High Level Overview
-
-```typescript
-import { models, PoseEstimationModule } from 'react-native-executorch';
-const imageUri = 'path/to/image.png';
-
-// Creating an instance and loading the model
-const poseEstimationModule = await PoseEstimationModule.fromModelName(
-  models.pose_estimation.yolo26n()
-);
-
-// Running the model
-const detections = await poseEstimationModule.forward(imageUri);
-detections[0].NOSE; // { x, y }
-```
-
-### Methods
-
-All methods of `PoseEstimationModule` are explained in details here: [`PoseEstimationModule` API Reference](../../06-api-reference/classes/PoseEstimationModule.md)
-
-## Loading the model
-
-Use the static [`fromModelName`](../../06-api-reference/classes/PoseEstimationModule.md#frommodelname) factory method. It accepts a model config object (with `modelName` and `modelSource`) and an optional `onDownloadProgress` callback. It returns a promise resolving to a `PoseEstimationModule` instance whose return type is statically tied to the model's keypoint map.
-
-For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-## Running the model
-
-To run the model, use the [`forward`](../../06-api-reference/classes/PoseEstimationModule.md#forward) method. It accepts two arguments:
-
-- `input` (required) - The image to process. Can be a remote URL, a local file URI, a base64-encoded image (whole URI or only raw base64), or a [`PixelData`](../../06-api-reference/interfaces/PixelData.md) object (raw RGB pixel buffer).
-- `options` (optional) - A [`PoseEstimationOptions`](../../06-api-reference/interfaces/PoseEstimationOptions.md) object with:
-  - `detectionThreshold` (optional) - Minimum confidence score for a detected person (0-1). Defaults to model-specific value.
-  - `keypointThreshold` (optional) - Per-keypoint visibility threshold (0-1). Keypoints whose model-reported visibility falls below this are reported as `(-1, -1)` so consumers can skip them. Defaults to model-specific value.
-  - `inputSize` (optional) - For YOLO models: `384`, `512`, or `640`. Defaults to `384`.
-
-The method returns a promise resolving to an array of [`PersonKeypoints`](../../06-api-reference/type-aliases/PersonKeypoints.md). Each entry is an object keyed by the model's keypoint names (e.g. `NOSE`, `LEFT_SHOULDER`), where each value is a [`Keypoint`](../../06-api-reference/interfaces/Keypoint.md) with `x` and `y` coordinates in the original image's pixel space.
-
-:::info
-Keypoints whose visibility falls below `keypointThreshold` (or that the model considers off-image) are returned as `{ x: -1, y: -1 }`. Filter them out before drawing — e.g. `if (kp.x < 0 || kp.y < 0) skip;`.
-:::
-
-For real-time frame processing, use [`runOnFrame`](../../03-hooks/02-computer-vision/visioncamera-integration.md) instead.
-
-### Example with Options
-
-```typescript
-const detections = await model.forward(imageUri, {
-  detectionThreshold: 0.5,
-  inputSize: 640, // YOLO models only
-});
-
-for (const person of detections) {
-  console.log('Nose at', person.NOSE.x, person.NOSE.y);
-}
-```
-
-## Using a custom model
-
-Use [`fromCustomModel`](../../06-api-reference/classes/PoseEstimationModule.md#fromcustommodel) to load your own exported model binary instead of a built-in preset. You provide the keypoint map; `forward`'s return type is automatically derived from it, so each detected person is typed as a record keyed by the names you defined.
-
-```typescript
-import { PoseEstimationModule } from 'react-native-executorch';
-const HandKeypoints = {
-  WRIST: 0,
-  THUMB_TIP: 1,
-  INDEX_TIP: 2,
-  MIDDLE_TIP: 3,
-  RING_TIP: 4,
-  PINKY_TIP: 5,
-} as const;
-
-const detector = await PoseEstimationModule.fromCustomModel(
-  'https://example.com/custom_pose.pte',
-  { keypointMap: HandKeypoints },
-  (progress) => console.log(progress)
-);
-
-const detections = await detector.forward(imageUri);
-detections[0].THUMB_TIP; // { x, y }
-```
-
-### Required model contract
-
-The `.pte` binary must expose a `forward` method (or per-input-size methods such as `forward_384`, `forward_512`, `forward_640` for multi-resolution models) with the following interface:
-
-**Input:** one `float32` tensor of shape `[1, 3, H, W]` — a single RGB image, values in `[0, 1]` after optional per-channel normalization `(pixel − mean) / std`. H and W are read from the model's declared input shape at load time. The mean and std vectors are supplied via `preprocessorConfig.normMean` and `preprocessorConfig.normStd` on the [`PoseEstimationConfig`](../../06-api-reference/type-aliases/PoseEstimationConfig.md) you pass to `fromCustomModel`; if omitted, the runtime feeds the resized image without normalization.
-
-**Outputs:** exactly three `float32` tensors, in this order:
-
-1. **Bounding boxes** — shape `[Q, 4]`, `(x1, y1, x2, y2)` per detection in model-input pixel space, where `Q` is the number of candidate detections.
-2. **Confidence scores** — shape `[Q]`, person confidence in `[0, 1]`.
-3. **Keypoints** — shape `[Q, K, 3]`, where `K` is the number of keypoints (must match the size of your `keypointMap`) and the last dimension is `(x, y, visibility)` per keypoint, in model-input pixel space.
-
-Preprocessing (resize → normalize) and postprocessing (coordinate rescaling, threshold filtering, mapping keypoints to your named keypoint map) are handled by the native runtime — your model only needs to produce the raw detections above.
-
-## Managing memory
-
-The module is a regular JavaScript object, and as such its lifespan will be managed by the garbage collector. In most cases this should be enough, and you should not worry about freeing the memory of the module yourself, but in some cases you may want to release the memory occupied by the module before the garbage collector steps in. In this case use the method [`delete`](../../06-api-reference/classes/PoseEstimationModule.md#delete) on the module object you will no longer use, and want to remove from the memory. Note that you cannot use [`forward`](../../06-api-reference/classes/PoseEstimationModule.md#forward) after [`delete`](../../06-api-reference/classes/PoseEstimationModule.md#delete) unless you load the module again.
diff --git a/docs/docs/04-typescript-api/02-computer-vision/SemanticSegmentationModule.md b/docs/docs/04-typescript-api/02-computer-vision/SemanticSegmentationModule.md
deleted file mode 100644
index fffe2a7ba1..0000000000
--- a/docs/docs/04-typescript-api/02-computer-vision/SemanticSegmentationModule.md
+++ /dev/null
@@ -1,117 +0,0 @@
----
-title: SemanticSegmentationModule
----
-
-TypeScript API implementation of the [useSemanticSegmentation](../../03-hooks/02-computer-vision/useSemanticSegmentation.md) hook.
-
-## API Reference
-
-- For detailed API Reference for `SemanticSegmentationModule` see: [`SemanticSegmentationModule` API Reference](../../06-api-reference/classes/SemanticSegmentationModule.md).
-- For all semantic segmentation models available out-of-the-box in React Native ExecuTorch see: [Semantic Segmentation Models](../../06-api-reference/index.md#models---semantic-segmentation).
-
-## High Level Overview
-
-```typescript
-import { models, SemanticSegmentationModule } from 'react-native-executorch';
-const imageUri = 'path/to/image.png';
-
-// Creating an instance from a built-in model
-const segmentation = await SemanticSegmentationModule.fromModelName(
-  models.semantic_segmentation.deeplab_v3_resnet50()
-);
-
-// Running the model
-const result = await segmentation.forward(imageUri);
-// result.ARGMAX — Int32Array of per-pixel class indices
-```
-
-### Methods
-
-All methods of `SemanticSegmentationModule` are explained in details here: [`SemanticSegmentationModule` API Reference](../../06-api-reference/classes/SemanticSegmentationModule.md)
-
-## Loading the model
-
-`SemanticSegmentationModule` uses static factory methods instead of `new()` + `load()`. There are two ways to create an instance:
-
-### Built-in models — `fromModelName`
-
-Use [`fromModelName`](../../06-api-reference/classes/SemanticSegmentationModule.md#frommodelname) for models that ship with built-in label maps and preprocessing configs:
-
-```typescript
-const segmentation = await SemanticSegmentationModule.fromModelName(
-  models.semantic_segmentation.deeplab_v3_resnet50(),
-  (progress) => console.log(`Download: ${Math.round(progress * 100)}%`)
-);
-```
-
-The `config` parameter is a discriminated union — TypeScript ensures you provide the correct fields for each model name. Available built-in models: `'deeplab-v3-resnet50'`, `'deeplab-v3-resnet50-quantized'`, `'deeplab-v3-resnet101'`, `'deeplab-v3-resnet101-quantized'`, `'deeplab-v3-mobilenet-v3-large'`, `'deeplab-v3-mobilenet-v3-large-quantized'`, `'lraspp-mobilenet-v3-large'`, `'lraspp-mobilenet-v3-large-quantized'`, `'fcn-resnet50'`, `'fcn-resnet50-quantized'`, `'fcn-resnet101'`, `'fcn-resnet101-quantized'`, and `'selfie-segmentation'`.
-
-### Custom models — `fromCustomModel`
-
-Use [`fromCustomModel`](../../06-api-reference/classes/SemanticSegmentationModule.md#fromcustommodel) for custom-exported segmentation models with your own label map:
-
-```typescript
-const MyLabels = { BACKGROUND: 0, FOREGROUND: 1 } as const;
-
-const segmentation = await SemanticSegmentationModule.fromCustomModel(
-  'https://example.com/custom_model.pte',
-  {
-    labelMap: MyLabels,
-    preprocessorConfig: {
-      normMean: [0.485, 0.456, 0.406],
-      normStd: [0.229, 0.224, 0.225],
-    },
-  }
-);
-```
-
-The `preprocessorConfig` is optional. If omitted, no input normalization is applied. The module instance will be typed to your custom label map — `forward` will accept and return keys from `MyLabels`.
-
-### Required model contract
-
-The `.pte` binary must expose a single `forward` method with the following interface:
-
-**Input:** one `float32` tensor of shape `[1, 3, H, W]` — a single RGB image, values in `[0, 1]` after optional per-channel normalization `(pixel − mean) / std`. H and W are read from the model's declared input shape at load time.
-
-**Output:** one `float32` tensor of shape `[1, C, H_out, W_out]` (NCHW) containing raw logits — one channel per class, in the same order as the entries in your `labelMap`. For binary segmentation a single-channel output is also supported: channel 0 is treated as the foreground probability and a synthetic background channel is added automatically.
-
-Preprocessing (resize → normalize) and postprocessing (softmax, argmax, resize back to original dimensions) are handled by the native runtime.
-
-For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-## Running the model
-
-To run the model, use the [`forward`](../../06-api-reference/classes/SemanticSegmentationModule.md#forward) method. It accepts three arguments:
-
-- [`input`](../../06-api-reference/classes/SemanticSegmentationModule.md#forward) (required) - The image to segment. Can be a remote URL, a local file URI, a base64-encoded image (whole URI or only raw base64), or a [`PixelData`](../../06-api-reference/interfaces/PixelData.md) object (raw RGB pixel buffer).
-- [`classesOfInterest`](../../06-api-reference/classes/SemanticSegmentationModule.md#forward) (optional) - An array of label keys indicating which per-class probability masks to include in the output. Defaults to `[]`. The `ARGMAX` map is always returned regardless.
-- [`resizeToInput`](../../06-api-reference/classes/SemanticSegmentationModule.md#forward) (optional) - Whether to resize the output masks to the original input image dimensions. Defaults to `true`. If `false`, returns the raw model output dimensions.
-
-:::tip
-Setting `resizeToInput` to `false` will make `forward` faster.
-:::
-
-`forward` returns a promise resolving to an object containing:
-
-- `ARGMAX` - An `Int32Array` where each element is the class index with the highest probability for that pixel.
-- For each label included in `classesOfInterest`, a `Float32Array` of per-pixel probabilities for that class.
-
-The return type narrows based on the labels passed in `classesOfInterest`:
-
-```typescript
-// Only ARGMAX in the result
-const result = await segmentation.forward(imageUri);
-result.ARGMAX; // Int32Array
-
-// ARGMAX + requested class masks
-const result = await segmentation.forward(imageUri, ['CAT', 'DOG']);
-result.ARGMAX; // Int32Array
-result.CAT; // Float32Array
-result.DOG; // Float32Array
-```
-
-For real-time frame processing, use [`runOnFrame`](../../03-hooks/02-computer-vision/visioncamera-integration.md) instead.
-
-## Managing memory
-
-The module is a regular JavaScript object, and as such its lifespan will be managed by the garbage collector. In most cases this should be enough, and you should not worry about freeing the memory of the module yourself, but in some cases you may want to release the memory occupied by the module before the garbage collector steps in. In this case use the method [`delete`](../../06-api-reference/classes/SemanticSegmentationModule.md#delete) on the module object you will no longer use, and want to remove from the memory. Note that you cannot use [`forward`](../../06-api-reference/classes/SemanticSegmentationModule.md#forward) after [`delete`](../../06-api-reference/classes/SemanticSegmentationModule.md#delete) unless you create a new instance.
diff --git a/docs/docs/04-typescript-api/02-computer-vision/StyleTransferModule.md b/docs/docs/04-typescript-api/02-computer-vision/StyleTransferModule.md
deleted file mode 100644
index 966cdff58b..0000000000
--- a/docs/docs/04-typescript-api/02-computer-vision/StyleTransferModule.md
+++ /dev/null
@@ -1,58 +0,0 @@
----
-title: StyleTransferModule
----
-
-TypeScript API implementation of the [useStyleTransfer](../../03-hooks/02-computer-vision/useStyleTransfer.md) hook.
-
-## API Reference
-
-- For detailed API Reference for `StyleTransferModule` see: [`StyleTransferModule` API Reference](../../06-api-reference/classes/StyleTransferModule.md).
-- For all style transfer models available out-of-the-box in React Native ExecuTorch see: [Style Transfer Models](../../06-api-reference/index.md#models---style-transfer).
-
-## High Level Overview
-
-```typescript
-import { models, StyleTransferModule } from 'react-native-executorch';
-const imageUri = 'path/to/image.png';
-
-// Creating and loading the module
-const styleTransferModule = await StyleTransferModule.fromModelName(
-  models.style_transfer.candy()
-);
-
-// Running the model
-const generatedImageUrl = await styleTransferModule.forward(imageUri);
-```
-
-### Methods
-
-All methods of `StyleTransferModule` are explained in details here: [`StyleTransferModule` API Reference](../../06-api-reference/classes/StyleTransferModule.md)
-
-## Loading the model
-
-To create a ready-to-use instance, call the static [`fromModelName`](../../06-api-reference/classes/StyleTransferModule.md#frommodelname) factory with the following parameters:
-
-- `namedSources` - Object containing:
-  - `modelName` - Model name identifier.
-  - `modelSource` - Location of the model binary.
-
-- `onDownloadProgress` - Optional callback to track download progress (value between 0 and 1).
-
-The factory returns a promise that resolves to a loaded `StyleTransferModule` instance.
-
-For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-## Running the model
-
-To run the model, use the [`forward`](../../06-api-reference/classes/StyleTransferModule.md#forward) method. It accepts two arguments:
-
-- `input` (required) — The image to stylize. Can be a remote URL, a local file URI, a base64-encoded image (whole URI or only raw base64), or a [`PixelData`](../../06-api-reference/interfaces/PixelData.md) object (raw RGB pixel buffer).
-- `outputType` (optional) — Controls the return format:
-  - `'pixelData'` (default) — Returns a `PixelData` object with raw RGB pixels. No file is written.
-  - `'url'` — Saves the result to a temp file and returns its URI as a `string`.
-
-For real-time frame processing, use [`runOnFrame`](../../03-hooks/02-computer-vision/visioncamera-integration.md) instead.
-
-## Managing memory
-
-The module is a regular JavaScript object, and as such its lifespan will be managed by the garbage collector. In most cases this should be enough, and you should not worry about freeing the memory of the module yourself, but in some cases you may want to release the memory occupied by the module before the garbage collector steps in. In this case use the method [`delete`](../../06-api-reference/classes/StyleTransferModule.md#delete) on the module object you will no longer use, and want to remove from the memory. Note that you cannot use [`forward`](../../06-api-reference/classes/StyleTransferModule.md#forward) after [`delete`](../../06-api-reference/classes/StyleTransferModule.md#delete) unless you load the module again.
diff --git a/docs/docs/04-typescript-api/02-computer-vision/TextToImageModule.md b/docs/docs/04-typescript-api/02-computer-vision/TextToImageModule.md
deleted file mode 100644
index cf73eee019..0000000000
--- a/docs/docs/04-typescript-api/02-computer-vision/TextToImageModule.md
+++ /dev/null
@@ -1,60 +0,0 @@
----
-title: TextToImageModule
----
-
-TypeScript API implementation of the [useTextToImage](../../03-hooks/02-computer-vision/useTextToImage.md) hook.
-
-## API Reference
-
-- For detailed API Reference for `TextToImageModule` see: [`TextToImageModule` API Reference](../../06-api-reference/classes/TextToImageModule.md).
-- For all text to image models available out-of-the-box in React Native ExecuTorch see: [Text to Image Models](../../06-api-reference/index.md#models---image-generation).
-
-## High Level Overview
-
-```typescript
-import { models, TextToImageModule } from 'react-native-executorch';
-const input = 'a castle';
-
-// Creating an instance and loading the model
-const textToImageModule = await TextToImageModule.fromModelName(
-  models.image_generation.bk_sdm_tiny_vpred_256()
-);
-
-// Running the model
-const image = await textToImageModule.forward(input);
-```
-
-### Methods
-
-All methods of `TextToImageModule` are explained in details here: [`TextToImageModule` API Reference](../../06-api-reference/classes/TextToImageModule.md)
-
-## Loading the model
-
-Use the static [`fromModelName`](../../06-api-reference/classes/TextToImageModule.md#frommodelname) factory method. It accepts a model config object (e.g. `BK_SDM_TINY_VPRED_256`) containing:
-
-- [`schedulerSource`](../../06-api-reference/classes/TextToImageModule.md#schedulersource) - Location of the used scheduler.
-- [`tokenizerSource`](../../06-api-reference/classes/TextToImageModule.md#tokenizersource) - Location of the used tokenizer.
-- [`encoderSource`](../../06-api-reference/classes/TextToImageModule.md#encodersource) - Location of the used encoder.
-- [`unetSource`](../../06-api-reference/classes/TextToImageModule.md#unetsource) - Location of the used unet.
-- [`decoderSource`](../../06-api-reference/classes/TextToImageModule.md#decodersource) - Location of the used decoder.
-- [`inferenceCallback`](../../06-api-reference/classes/TextToImageModule.md#inferencecallback) - Optional callback invoked at each denoising step.
-
-And an optional `onDownloadProgress` callback. It returns a promise resolving to a `TextToImageModule` instance.
-
-For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-## Running the model
-
-To run the model, you can use the [`forward`](../../06-api-reference/classes/TextToImageModule.md#forward) method. It accepts four arguments: a text prompt describing the requested image, a size of the image in pixels, a number of denoising steps, and an optional seed value, which enables reproducibility of the results.
-
-The image size must fall within the range from 128 to 512 unless specified differently, and be a multiple of 32 due to the architecture of the U-Net and VAE models.
-
-The seed value should be a positive integer.
-
-## Listening for inference steps
-
-To monitor the progress of image generation, you can pass an [`inferenceCallback`](../../06-api-reference/classes/TextToImageModule.md#inferencecallback) in the model config object passed to `fromModelName`. The callback is invoked at each denoising step (for a total of `numSteps + 1` times), yielding the current step index that can be used, for example, to display a progress bar.
-
-## Deleting the model from memory
-
-To delete the model from memory, you can use the [`delete`](../../06-api-reference/classes/TextToImageModule.md#delete) method.
diff --git a/docs/docs/04-typescript-api/02-computer-vision/VerticalOCRModule.md b/docs/docs/04-typescript-api/02-computer-vision/VerticalOCRModule.md
deleted file mode 100644
index 59eaacfbb8..0000000000
--- a/docs/docs/04-typescript-api/02-computer-vision/VerticalOCRModule.md
+++ /dev/null
@@ -1,49 +0,0 @@
----
-title: VerticalOCRModule
----
-
-TypeScript API implementation of the [useVerticalOCR](../../03-hooks/02-computer-vision/useVerticalOCR.md) hook.
-
-## API Reference
-
-- For detailed API Reference for `VerticalOCRModule` see: [`VerticalOCRModule` API Reference](../../06-api-reference/classes/VerticalOCRModule.md).
-- For all alphabets available in ocr out-of-the-box in React Native ExecuTorch see: [OCR Supported Alphabets](../../06-api-reference/index.md#ocr-supported-alphabets).
-
-## High Level Overview
-
-```typescript
-import { models, VerticalOCRModule } from 'react-native-executorch';
-const imageUri = 'path/to/image.png';
-
-// Creating an instance and loading the model
-const verticalOCRModule = await VerticalOCRModule.fromModelName(
-  models.ocr.craft({ language: 'en' })
-);
-
-// Running the model
-const detections = await verticalOCRModule.forward(imageUri);
-```
-
-### Methods
-
-All methods of `VerticalOCRModule` are explained in details here: [`VerticalOCRModule` API Reference](../../06-api-reference/classes/VerticalOCRModule.md)
-
-## Loading the model
-
-Use the static [`fromModelName`](../../06-api-reference/classes/VerticalOCRModule.md#frommodelname) factory method. It accepts a `namedSources` object (e.g. `{ ...OCR_ENGLISH, independentCharacters: true }`) containing:
-
-- `modelName` - Model name identifier.
-- [`detectorSource`](../../06-api-reference/classes/VerticalOCRModule.md#detectorsource) - Location of the used detector.
-- [`recognizerSource`](../../06-api-reference/classes/VerticalOCRModule.md#recognizersource) - Location of the used recognizer.
-- [`language`](../../06-api-reference/classes/VerticalOCRModule.md#recognizersource) - Language used in OCR.
-- [`independentCharacters`](../../06-api-reference/classes/VerticalOCRModule.md#independentcharacters) - Flag indicating whether to treat characters as independent.
-
-And an optional `onDownloadProgress` callback. It returns a promise resolving to a `VerticalOCRModule` instance.
-
-For more information on loading resources, take a look at [loading models](../../01-fundamentals/02-loading-models.md) page.
-
-## Running the model
-
-To run the model, use the [`forward`](../../06-api-reference/classes/VerticalOCRModule.md#forward) method. It accepts one argument — the image to recognize. The image can be a remote URL, a local file URI, a base64-encoded image (whole URI or only raw base64), or a [`PixelData`](../../06-api-reference/interfaces/PixelData.md) object (raw RGB pixel buffer). The method returns a promise resolving to an array of [`OCRDetection`](../../06-api-reference/interfaces/OCRDetection.md) objects, each containing the bounding box, recognized text, and confidence score.
-
-For real-time frame processing, use [`runOnFrame`](../../03-hooks/02-computer-vision/visioncamera-integration.md) instead.
diff --git a/docs/docs/04-typescript-api/02-computer-vision/_category_.json b/docs/docs/04-typescript-api/02-computer-vision/_category_.json
deleted file mode 100644
index 930e814ef7..0000000000
--- a/docs/docs/04-typescript-api/02-computer-vision/_category_.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "label": "Computer Vision",
-  "link": {
-    "type": "generated-index"
-  }
-}
diff --git a/docs/docs/04-typescript-api/03-executorch-bindings/ExecutorchModule.md b/docs/docs/04-typescript-api/03-executorch-bindings/ExecutorchModule.md
deleted file mode 100644
index 252f7fa74a..0000000000
--- a/docs/docs/04-typescript-api/03-executorch-bindings/ExecutorchModule.md
+++ /dev/null
@@ -1,102 +0,0 @@
----
-title: ExecutorchModule
----
-
-ExecutorchModule provides TypeScript bindings for the underlying ExecuTorch [Module API](https://pytorch.org/executorch/stable/extension-module.html).
-
-:::tip
-For React applications, consider using the [`useExecutorchModule`](../../03-hooks/03-executorch-bindings/useExecutorchModule.md) hook instead, which provides automatic state management, loading progress tracking, and cleanup on unmount.
-:::
-
-## API Reference
-
-- For detailed API Reference for `ExecutorchModule` see: [`ExecutorchModule` API Reference](../../06-api-reference/classes/ExecutorchModule.md).
-
-## High Level Overview
-
-```typescript
-import { models, ExecutorchModule, ScalarType } from 'react-native-executorch';
-// Creating the input array
-const inputTensor = {
-  dataPtr: new Float32Array(1 * 3 * 640 * 640),
-  sizes: [1, 3, 640, 640],
-  scalarType: ScalarType.FLOAT,
-};
-
-// Creating an instance
-const model = new ExecutorchModule();
-
-// Loading the model
-await model.load(models.style_transfer.candy());
-
-// Running the forward method
-const output = await model.forward([inputTensor]);
-```
-
-### Methods
-
-All methods of `ExecutorchModule` are explained in details here: [`ExecutorchModule` API Reference](../../06-api-reference/classes/ExecutorchModule.md)
-
-## TensorPtr
-
-TensorPtr is a JS representation of the underlying tensor, which is then passed to the model. You can read more about creating tensors [here](https://docs.pytorch.org/executorch/stable/extension-tensor.html). On JS side, the [`TensorPtr`](../../06-api-reference/interfaces/TensorPtr.md) holds the following information:
-
-- [`dataPtr`](../../06-api-reference/interfaces/TensorPtr.md#dataptr) - Represents a data buffer that will be used to create a tensor on the native side. This can be either an `ArrayBuffer` or a `TypedArray`. If your model takes in a datatype which is not covered by any of the `TypedArray` types, just pass an `ArrayBuffer` here.
-
-- [`sizes`](../../06-api-reference/interfaces/TensorPtr.md#sizes) - Represents the shape of a given tensor, i.e. for a 640x640 RGB image with a batch size of 1, you would need to pass `[1, 3, 640, 640]` here.
-
-- [`scalarType`](../../06-api-reference/interfaces/TensorPtr.md#scalartype) - An enum resembling the ExecuTorch's [`ScalarType`](../../06-api-reference/enumerations/ScalarType.md). For example, if your model was exported with float32 as an input, you will need to pass [`ScalarType.FLOAT`](../../06-api-reference/enumerations/ScalarType.md#float) here.
-
-## End to end example
-
-This example demonstrates the integration and usage of the ExecuTorch bindings with a [style transfer model](../../03-hooks/02-computer-vision/useStyleTransfer.md). Specifically, we'll be using the `STYLE_TRANSFER_CANDY` model, which applies artistic style transfer to an input image.
-
-### Importing the Module and loading the model
-
-First, import the necessary functions from the `react-native-executorch` package and initialize the ExecuTorch module with the specified style transfer model.
-
-```typescript
-import { models, ExecutorchModule, ScalarType } from 'react-native-executorch';
-// Initialize the executorch module
-const executorchModule = new ExecutorchModule();
-
-// Load the model with optional download progress callback
-await executorchModule.load(models.style_transfer.candy(), (progress) => {
-  console.log(`Download progress: ${progress}%`);
-});
-```
-
-### Setting up input parameters
-
-To prepare the model input, define the tensor shape according to your model's requirements (defined by the model export process). For example, the `STYLE_TRANSFER_CANDY` model expects a tensor with shape `[1, 3, 640, 640]` — representing a batch size of 1, 3 color channels (RGB), and 640×640 pixel dimensions.
-
-```typescript
-const inputTensor = {
-  dataPtr: new Float32Array(1 * 3 * 640 * 640), // or other TypedArray / ArrayBuffer
-  sizes: [1, 3, 640, 640],
-  scalarType: ScalarType.FLOAT,
-};
-```
-
-### Performing inference
-
-After passing input to the forward function, you'll receive an array of [`TensorPtr`](../../06-api-reference/interfaces/TensorPtr.md) objects. Each TensorPtr contains its [`dataPtr`](../../06-api-reference/interfaces/TensorPtr.md#dataptr) field as an `ArrayBuffer`. Since `ArrayBuffer` represents raw binary data, you'll need to interpret it according to the tensor's underlying data type (e.g., creating a `Float32Array` view for float32 tensors, `Int32Array` for int32 tensors, etc.).
-
-:::info
-This code assumes that you have handled preprocessing of the input image (scaling, normalization) and postprocessing of the output (interpreting the raw output data) according to the model's requirements. Make sure to adjust these parts depending on your specific data and model outputs.
-:::
-
-```typescript
-try {
-  // Perform the forward operation and receive the stylized image output.
-  const output = await executorchModule.forward([inputTensor]);
-  // Interpret the output ArrayBuffer
-  // foo(output[0].dataPtr);
-} catch (error) {
-  // Log any errors that occur during the forward pass.
-  console.error('Error during model execution:', error);
-}
-
-// Clean up resources when done
-executorchModule.delete();
-```
diff --git a/docs/docs/04-typescript-api/03-executorch-bindings/_category_.json b/docs/docs/04-typescript-api/03-executorch-bindings/_category_.json
deleted file mode 100644
index 1e89535929..0000000000
--- a/docs/docs/04-typescript-api/03-executorch-bindings/_category_.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "label": "ExecuTorch Bindings",
-  "link": {
-    "type": "generated-index"
-  }
-}
diff --git a/docs/docs/04-typescript-api/_category_.json b/docs/docs/04-typescript-api/_category_.json
deleted file mode 100644
index 5d1c80c51d..0000000000
--- a/docs/docs/04-typescript-api/_category_.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "label": "TypeScript API",
-  "link": {
-    "type": "generated-index"
-  }
-}
diff --git a/docs/docs/05-utilities/04-error-handling.md b/docs/docs/05-utilities/04-error-handling.md
deleted file mode 100644
index 568e9ab877..0000000000
--- a/docs/docs/05-utilities/04-error-handling.md
+++ /dev/null
@@ -1,187 +0,0 @@
----
-title: Error handling
----
-
-## Overview
-
-In order to handle different types of errors, you can use `instanceof` with our exported class `RnExecutorchError` and its `code` property. This allows you to check what exactly went wrong and act accordingly.
-
-This example uses the `LLMModule`, and then tries to change its `generationConfig`. As the topp param has to be a value between 0 and 1 (inclusive), the `.configure()` method will throw an error with a code InvalidConfig.
-
-```typescript
-import {
-  models,
-  LLMModule,
-  RnExecutorchError,
-  RnExecutorchErrorCode,
-} from 'react-native-executorch';
-
-const llm = await LLMModule.fromModelName(
-  models.llm.lfm2_5_1_2b_instruct(),
-  (progress) => console.log(progress),
-  (token) => console.log(token),
-  (messages) => console.log(messages)
-);
-
-// Try to set an invalid configuration
-try {
-  await llm.configure({ topp: 1.5 }); // This will throw InvalidConfig error
-} catch (err) {
-  if (
-    err instanceof RnExecutorchError &&
-    err.code === RnExecutorchErrorCode.InvalidConfig
-  ) {
-    console.error('Invalid configuration:', err.message);
-    // Handle the invalid config - set default values
-    await llm.configure({ topp: 0.9 });
-  } else {
-    throw err;
-  }
-}
-
-// Running the model
-try {
-  await llm.sendMessage('Hello, World!');
-} catch (err) {
-  if (err instanceof RnExecutorchError) {
-    if (err.code === RnExecutorchErrorCode.ModuleNotLoaded) {
-      console.error('Model not loaded:', err.message);
-      // Load the model first
-    } else if (err.code === RnExecutorchErrorCode.ModelGenerating) {
-      console.error('Model is already generating:', err.message);
-      // Wait for current generation to complete
-    } else {
-      console.error('Generation error:', err.message);
-      throw err;
-    }
-  } else {
-    throw err;
-  }
-}
-
-// Interrupting the model (to actually interrupt the generation it has to be called when sendMessage or generate is running)
-llm.interrupt();
-
-// Deleting the model from memory
-llm.delete();
-```
-
-## Reference
-
-All errors in React Native ExecuTorch inherit from `RnExecutorchError` and include a `code` property. The code is typed as `RnExecutorchErrorCode | number`: in practice you'll almost always see a member of the enum, but the codes are generated from a shared config into both the C++ and TS sources, and if those generated files drift the raw numeric value flows through unchanged. When switching on `err.code`, always include a `default` branch.
-
-Below is a comprehensive list of all possible errors, organized by category.
-
-### Module State Errors
-
-These errors occur when trying to perform operations on a model in an invalid state.
-
-| Error Code        | Description                           | When It Occurs                                                                        | How to Handle                                                              |
-| ----------------- | ------------------------------------- | ------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- |
-| `ModuleNotLoaded` | Model is not loaded into memory       | Calling `forward()`, `generate()`, or other inference methods before calling `load()` | Load the model first with `load()`                                         |
-| `ModelGenerating` | Model is already processing a request | Calling `generate()` or `forward()` while another inference is running                | Wait for current generation to complete, or use `interrupt()` to cancel it |
-
-### Configuration Errors
-
-These errors occur when invalid configuration or input is provided.
-
-| Error Code             | Description                          | When It Occurs                                                                          | How to Handle                                                 |
-| ---------------------- | ------------------------------------ | --------------------------------------------------------------------------------------- | ------------------------------------------------------------- |
-| `InvalidConfig`        | Configuration parameters are invalid | Setting parameters outside valid ranges (e.g., `topp` outside [0, 1])                   | Check parameter constraints and provide valid values          |
-| `InvalidUserInput`     | Input provided to API is invalid     | Passing empty arrays, null values, or malformed data to methods                         | Validate input before calling methods                         |
-| `InvalidModelSource`   | Model source type is invalid         | Providing wrong type for model source (e.g., object when string expected)               | Ensure model source matches expected type                     |
-| `LanguageNotSupported` | Language not supported by model      | Passing unsupported language to multilingual OCR or Speech-to-Text models               | Use a supported language or different model                   |
-| `PlatformNotSupported` | Current platform is not supported    | Using features (e.g., camera frame processing) on an unsupported platform or OS version | Ensure you're running on a supported platform/OS version      |
-| `WrongDimensions`      | Input tensor dimensions don't match  | Providing input with incorrect shape for the model                                      | Check model's expected input dimensions                       |
-| `UnexpectedNumInputs`  | Wrong number of inputs provided      | Passing more or fewer inputs than model expects                                         | Verify the expected model I/O contract in docs or source code |
-
-### File Operations Errors
-
-These errors occur during file read/write operations.
-
-| Error Code        | Description                 | When It Occurs                                               | How to Handle                                 |
-| ----------------- | --------------------------- | ------------------------------------------------------------ | --------------------------------------------- |
-| `FileReadFailed`  | File read operation failed  | Invalid image URL, unsupported format, or file doesn't exist | Verify file path and format are correct       |
-| `FileWriteFailed` | File write operation failed | Saving result image or output file fails                     | Check storage permissions and available space |
-
-### Download & Resource Fetcher Errors
-
-These errors occur during model download and resource management.
-
-| Error Code                                | Description                                                         | When It Occurs                                                       | How to Handle                                                                                 |
-| ----------------------------------------- | ------------------------------------------------------------------- | -------------------------------------------------------------------- | --------------------------------------------------------------------------------------------- |
-| `DownloadInterrupted`                     | Download was interrupted                                            | Not all files were downloaded successfully                           | Retry the download                                                                            |
-| `ResourceFetcherDownloadFailed`           | Resource download failed                                            | Network error, invalid URL, or server error                          | Check network connection and URL validity, retry with exponential backoff                     |
-| `ResourceFetcherDownloadInProgress`       | Download already in progress                                        | Calling `fetch()` for same resource while downloading                | Wait for current download to complete                                                         |
-| `ResourceFetcherAlreadyPaused`            | Download already paused                                             | Calling `pauseFetching()` on already paused download                 | Check download state before pausing                                                           |
-| `ResourceFetcherAlreadyOngoing`           | Download already ongoing                                            | Calling `resumeFetching()` on active download                        | No action needed, download is already running                                                 |
-| `ResourceFetcherNotActive`                | No active download found                                            | Calling pause/resume/cancel on non-existent download                 | Verify download was started before trying to control it                                       |
-| `ResourceFetcherMissingUri`               | Required URI information missing                                    | Internal state error during download operations                      | Restart the download from beginning                                                           |
-| `ResourceFetcherAdapterNotInitialized`    | Resource fetcher not initialized                                    | Trying to load resources without calling `initExecutorch()` first    | Call `initExecutorch({ resourceFetcher: ... })` before loading models                         |
-| `ResourceFetcherPlatformNotSupported`     | Platform not supported by resource fetcher                          | Using a resource fetcher feature unavailable on the current platform | Use a platform-appropriate fetcher or avoid the unsupported operation                         |
-| `ResourceFetcherFileSystemApiUnavailable` | Expo FileSystem API is unavailable (occurs for ExpoResourceFetcher) | When importing a non-existing Expo FS module                         | If you're using Expo 54 and below, make sure to use `/legacy` import for ExpoResourceFetcher. |
-
-### Speech-to-Text Streaming Errors
-
-These errors are specific to streaming transcription operations.
-
-| Error Code                  | Description                         | When It Occurs                                                                            | How to Handle                                                   |
-| --------------------------- | ----------------------------------- | ----------------------------------------------------------------------------------------- | --------------------------------------------------------------- |
-| `MultilingualConfiguration` | Multilingual configuration mismatch | Setting language on non-multilingual model, or not setting language on multilingual model | Check if model is multilingual and provide language accordingly |
-| `MissingDataChunk`          | Audio data chunk missing            | Streaming transcription without providing audio data                                      | Ensure audio data is provided to streaming methods              |
-| `StreamingNotStarted`       | Stream not started                  | Calling `stop()` or `insertData()` without calling `start()` first                        | Call `start()` before other streaming operations                |
-| `StreamingInProgress`       | Stream already in progress          | Calling `start()` while another stream is active                                          | Stop current stream before starting a new one                   |
-
-### Model Execution Errors
-
-These errors come from the ExecuTorch runtime during model execution.
-
-| Error Code           | Description                      | When It Occurs                                 | How to Handle                                               |
-| -------------------- | -------------------------------- | ---------------------------------------------- | ----------------------------------------------------------- |
-| `InvalidModelOutput` | Model output size unexpected     | Model produces output of wrong size            | Verify model's expected I/O contract in docs or source code |
-| `ThreadPoolError`    | Threadpool operation failed      | Internal threading issue                       | Restart the model or app                                    |
-| `TokenizerError`     | Tokenizer or tokenization failed | Tokenizer initialization or processing error   | Check tokenizer files and model compatibility               |
-| `UnknownError`       | Unexpected error occurred        | 3rd-party library error or unhandled exception | Check logs for details, report if reproducible              |
-
-### ExecuTorch Runtime Errors
-
-These errors are mapped directly from the ExecuTorch runtime. They typically indicate lower-level execution issues.
-
-#### System Errors
-
-| Error Code      | Description                         |
-| --------------- | ----------------------------------- |
-| `Ok`            | Operation successful (not an error) |
-| `Internal`      | Internal ExecuTorch error           |
-| `InvalidState`  | Operation called in invalid state   |
-| `EndOfMethod`   | End of method reached               |
-| `AlreadyLoaded` | Resource has already been loaded    |
-
-#### Logical Errors
-
-| Error Code        | Description                          |
-| ----------------- | ------------------------------------ |
-| `NotSupported`    | Operation not supported by model     |
-| `NotImplemented`  | Feature not implemented              |
-| `InvalidArgument` | Invalid argument passed to operation |
-| `InvalidType`     | Type mismatch in operation           |
-| `OperatorMissing` | Required operator missing from model |
-
-#### Resource Errors
-
-| Error Code               | Description                |
-| ------------------------ | -------------------------- |
-| `NotFound`               | Resource not found         |
-| `MemoryAllocationFailed` | Memory allocation failed   |
-| `AccessFailed`           | Access to resource failed  |
-| `InvalidProgram`         | Model program is invalid   |
-| `InvalidExternalData`    | External data is invalid   |
-| `OutOfResources`         | System resources exhausted |
-
-#### Delegate Errors
-
-| Error Code                       | Description                        |
-| -------------------------------- | ---------------------------------- |
-| `DelegateInvalidCompatibility`   | Delegate not compatible with model |
-| `DelegateMemoryAllocationFailed` | Delegate memory allocation failed  |
-| `DelegateInvalidHandle`          | Invalid delegate handle            |
diff --git a/docs/docs/05-utilities/_category_.json b/docs/docs/05-utilities/_category_.json
deleted file mode 100644
index dc9848f399..0000000000
--- a/docs/docs/05-utilities/_category_.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "label": "Utilities",
-  "link": {
-    "type": "generated-index"
-  }
-}
diff --git a/docs/docs/05-utilities/model-registry.md b/docs/docs/05-utilities/model-registry.md
deleted file mode 100644
index 3611731235..0000000000
--- a/docs/docs/05-utilities/model-registry.md
+++ /dev/null
@@ -1,143 +0,0 @@
----
-title: Model Registry
----
-
-The Model Registry is a typed, grouped index of every model shipped with React Native ExecuTorch. It removes the need to memorize per-model constant names: pick a capability group, pick a model, and optionally opt out of quantization or override the backend.
-
-```typescript
-import { models } from 'react-native-executorch';
-
-// Default (quantized when available, platform-default backend).
-const llm = useLLM({ model: models.llm.llama3_2_3b() });
-
-// Non-quantized variant.
-const llmBase = useLLM({ model: models.llm.llama3_2_3b({ quant: false }) });
-```
-
-Each leaf is a **function**. Call it (optionally with `{ quant, backend }`) to get the resolved model config. Accessors are not readable as values — this avoids a class of React state pitfalls (`useState` lazy-init, `useMemo`/`useCallback` deps), and pickers can fall back to plain `===` reference equality on the returned config.
-
-## Shape
-
-`models` is grouped by capability. Each leaf is a callable accessor.
-
-| Group                   | Examples                                                                                                                                                                                                                                                                                    |
-| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `llm`                   | `llama3_2_3b`, `qwen3_4b`, `smollm2_1_1_7b`, `phi_4_mini_4b`, `bielik_v3_0_1_5b`, `lfm2_5_1_2b_instruct`, `lfm2_5_vl_1_6b`, `lfm2_5_vl_450m`, …                                                                                                                                             |
-| `classification`        | `efficientnet_v2_s`                                                                                                                                                                                                                                                                         |
-| `privacy_filter`        | `openai`, `nemotron`                                                                                                                                                                                                                                                                        |
-| `object_detection`      | `ssdlite_320_mobilenet_v3_large`, `yolo26n` … `yolo26x`, `rf_detr_nano`                                                                                                                                                                                                                     |
-| `pose_estimation`       | `yolo26n`                                                                                                                                                                                                                                                                                   |
-| `semantic_segmentation` | `deeplab_v3_resnet50`, `lraspp_mobilenet_v3_large`, `fcn_resnet101`, `selfie_segmentation`, …                                                                                                                                                                                               |
-| `instance_segmentation` | `yolo26n` … `yolo26x`, `rf_detr_nano`, `fastsam_s`, `fastsam_x`                                                                                                                                                                                                                             |
-| `style_transfer`        | `candy`, `mosaic`, `rain_princess`, `udnie`                                                                                                                                                                                                                                                 |
-| `speech_to_text`        | `whisper_tiny_en`, `whisper_base`, `whisper_small_en`, …                                                                                                                                                                                                                                    |
-| `text_to_speech`        | nested by model family + language: `kokoro.en_us.{heart, river, sarah, adam, …}`, `kokoro.en_gb.{emma, daniel}`, `kokoro.fr.siwis`, `kokoro.es.{dora, alex}`, `kokoro.it.{sara, nicola}`, `kokoro.pt.{dora, santa}`, `kokoro.hi.{alpha, omega, psi}`, `kokoro.pl.mateusz`, `kokoro.de.anna` |
-| `text_embedding`        | `all_minilm_l6_v2`, `all_mpnet_base_v2`, `clip_vit_base_patch32_text`, …                                                                                                                                                                                                                    |
-| `image_embedding`       | `clip_vit_base_patch32_image`                                                                                                                                                                                                                                                               |
-| `image_generation`      | `bk_sdm_tiny_vpred_256`, `bk_sdm_tiny_vpred_512`                                                                                                                                                                                                                                            |
-| `vad`                   | `fsmn_vad`                                                                                                                                                                                                                                                                                  |
-| `ocr`                   | nested by detector: `craft({ language: 'en' })` — see [§OCR](#ocr) below                                                                                                                                                                                                                    |
-
-## Options
-
-```typescript
-type ModelOpts<B extends Backend = Backend> = {
-  quant?: boolean; // Pick the non-quantized variant when false. Defaults to the quantized variant when one is published.
-  backend?: B; // Explicit backend; the set of allowed values is per-model.
-};
-```
-
-- `quant` defaults to the quantized variant for models that publish one (e.g. `llama3_2_3b` → SpinQuant, `efficientnet_v2_s` → int8). Pass `{ quant: false }` to get the full-precision variant. For models with a single variant, `quant` is accepted but has no effect.
-- `backend` selects an explicit backend. The accessor's call signature is typed to exactly the backends the model ships with, so requesting one the model doesn't publish is a compile-time error (e.g. `models.llm.llama3_2_3b({ backend: 'coreml' })` does not type-check — Llama 3.2 is xnnpack-only). When `backend` is omitted, the platform-default applies: CoreML on iOS and XNNPACK on Android whenever the model ships that backend. Models that ship only one backend (e.g. xnnpack-only LLMs) use that one on both platforms.
-
-## Usage patterns
-
-### Default model
-
-```typescript
-import { models } from 'react-native-executorch';
-
-const llm = useLLM({ model: models.llm.llama3_2_3b() });
-const classifier = useClassification({
-  model: models.classification.efficientnet_v2_s(),
-});
-const stt = useSpeechToText({
-  model: models.speech_to_text.whisper_tiny_en(),
-});
-```
-
-### Non-quantized variant
-
-```typescript
-const llm = useLLM({ model: models.llm.qwen3_4b({ quant: false }) });
-const classifier = useClassification({
-  model: models.classification.efficientnet_v2_s({ quant: false }),
-});
-```
-
-### Explicit backend
-
-```typescript
-// Force XNNPACK on iOS (overrides the CoreML default).
-const detector = useObjectDetection({
-  model: models.object_detection.rf_detr_nano({ backend: 'xnnpack' }),
-});
-
-// Combine `quant` and `backend`.
-const styled = useStyleTransfer({
-  model: models.style_transfer.candy({ backend: 'coreml', quant: false }),
-});
-```
-
-### Text-to-speech
-
-`text_to_speech` is grouped by model family then by language code (`kokoro.en_us`, `kokoro.en_gb`, `kokoro.fr`, `kokoro.es`, `kokoro.it`, `kokoro.pt`, `kokoro.hi`, `kokoro.pl`, `kokoro.de`). Each leaf returns a complete Kokoro preset bundling the model, voice, and phonemizer — pass the whole result to `useTextToSpeech`. The `kokoro` level reserves room for a future TTS family without forcing a breaking rename.
-
-```typescript
-import { models, useTextToSpeech } from 'react-native-executorch';
-
-const tts = useTextToSpeech(models.text_to_speech.kokoro.en_us.heart());
-// Other languages:
-//   models.text_to_speech.kokoro.en_gb.emma()
-//   models.text_to_speech.kokoro.fr.siwis()
-//   models.text_to_speech.kokoro.pl.mateusz()
-```
-
-### OCR
-
-OCR is nested by detector family and parameterized by language. `craft` is the current pipeline (CRAFT detector + per-alphabet CRNN recognizer); future detectors land as siblings so the call site stays stable.
-
-```typescript
-const ocr = useOcr({
-  model: models.ocr.craft({ language: 'en' }),
-});
-```
-
-The `language` parameter is type-narrowed to supported tokens (`'en'`, `'es'`, `'ja'`, `'ko'`, …). See the OCR docs for the full list.
-
-### Direct imports still work
-
-Every model is also exported as a top-level constant. Either style is supported:
-
-```typescript
-import { LFM2_5_1_2B_INSTRUCT, models } from 'react-native-executorch';
-
-useLLM({ model: LFM2_5_1_2B_INSTRUCT });
-useLLM({ model: models.llm.lfm2_5_1_2b_instruct() });
-```
-
-## Migration from the previous registry
-
-Earlier releases exposed `MODEL_REGISTRY` as a flat value-only registry (`MODEL_REGISTRY.ALL_MODELS.<NAME>`) and shipped each precision/quantization variant as its own top-level constant. That has been replaced with a function-only, capability-grouped, lowercase `models` export that takes `{ quant, backend }` opts.
-
-```typescript
-// Before — flat value-only registry, one constant per variant.
-useLLM({ model: MODEL_REGISTRY.ALL_MODELS.LLAMA3_2_3B });
-useLLM({ model: MODEL_REGISTRY.ALL_MODELS.LLAMA3_2_3B_SPINQUANT });
-
-// After — callable accessor; pick the variant with opts.
-useLLM({ model: models.llm.llama3_2_3b() }); // quantized by default
-useLLM({ model: models.llm.llama3_2_3b({ quant: false }) }); // full precision
-```
-
-Individual constant imports (`LLAMA3_2_3B`, `WHISPER_TINY_EN`, …) are unchanged.
diff --git a/docs/docs/07-other/01-compatibility.mdx b/docs/docs/07-other/01-compatibility.mdx
deleted file mode 100644
index 65e1a9fdee..0000000000
--- a/docs/docs/07-other/01-compatibility.mdx
+++ /dev/null
@@ -1,140 +0,0 @@
----
-title: Compatibility
-slug: /other/compatibility
-description: 'React Native ExecuTorch compatibility table showing which versions of React Native are supported.'
----
-
-import styles from '@site/src/components/CompatibilityTable/styles.module.css';
-
-## New Architecture (Fabric)
-
-React Native ExecuTorch supports only the [New Architecture](https://reactnative.dev/architecture/landing-page) of React Native.
-
-## react-native-executorch
-
-<div className={styles.compatibility}>
-  <table>
-    <thead>
-      <tr>
-        <th rowSpan={2}>React Native ExecuTorch</th>
-        <th colSpan={8}>React Native version</th>
-      </tr>
-      <tr>
-        <th>0.78</th>
-        <th>0.79</th>
-        <th>0.80</th>
-        <th>0.81</th>
-        <th>0.82</th>
-        <th>0.83</th>
-        <th>0.84</th>
-        <th>0.85</th>
-      </tr>
-    </thead>
-    <tbody>
-      <tr>
-        <td><div className={styles.version}>0.8.x</div></td>
-        <td><div className={styles.notSupported}>no</div></td>
-        <td><div className={styles.notSupported}>no</div></td>
-        <td><div className={styles.notSupported}>no</div></td>
-        <td><div className={styles.supported}>yes</div></td>
-        <td><div className={styles.supported}>yes</div></td>
-        <td><div className={styles.supported}>yes</div></td>
-        <td><div className={styles.supported}>yes</div></td>
-        <td><div className={styles.supported}>yes</div></td>
-      </tr>
-      <tr>
-        <td><div className={styles.version}>0.9.x</div></td>
-        <td><div className={styles.notSupported}>no</div></td>
-        <td><div className={styles.notSupported}>no</div></td>
-        <td><div className={styles.notSupported}>no</div></td>
-        <td><div className={styles.supported}>yes</div></td>
-        <td><div className={styles.supported}>yes</div></td>
-        <td><div className={styles.supported}>yes</div></td>
-        <td><div className={styles.supported}>yes</div></td>
-        <td><div className={styles.supported}>yes</div></td>
-      </tr>
-    </tbody>
-  </table>
-</div>
-
-## react-native-executorch-bare-resource-fetcher
-
-<div className={styles.compatibility}>
-  <table>
-    <thead>
-      <tr>
-        <th rowSpan={2}>Bare Resource Fetcher</th>
-        <th colSpan={8}>React Native version</th>
-      </tr>
-      <tr>
-        <th>0.78</th>
-        <th>0.79</th>
-        <th>0.80</th>
-        <th>0.81</th>
-        <th>0.82</th>
-        <th>0.83</th>
-        <th>0.84</th>
-        <th>0.85</th>
-      </tr>
-    </thead>
-    <tbody>
-      <tr>
-        <td><div className={styles.version}>0.8.x</div></td>
-        <td><div className={styles.notSupported}>no</div></td>
-        <td><div className={styles.notSupported}>no</div></td>
-        <td><div className={styles.notSupported}>no</div></td>
-        <td><div className={styles.supported}>yes</div></td>
-        <td><div className={styles.supported}>yes</div></td>
-        <td><div className={styles.supported}>yes</div></td>
-        <td><div className={styles.supported}>yes</div></td>
-        <td><div className={styles.supported}>yes</div></td>
-      </tr>
-      <tr>
-        <td><div className={styles.version}>0.9.x</div></td>
-        <td><div className={styles.notSupported}>no</div></td>
-        <td><div className={styles.notSupported}>no</div></td>
-        <td><div className={styles.notSupported}>no</div></td>
-        <td><div className={styles.supported}>yes</div></td>
-        <td><div className={styles.supported}>yes</div></td>
-        <td><div className={styles.supported}>yes</div></td>
-        <td><div className={styles.supported}>yes</div></td>
-        <td><div className={styles.supported}>yes</div></td>
-      </tr>
-    </tbody>
-  </table>
-</div>
-
-## react-native-executorch-expo-resource-fetcher
-
-<div className={styles.compatibility}>
-  <table>
-    <thead>
-      <tr>
-        <th rowSpan={2}>Expo Resource Fetcher</th>
-        <th colSpan={4}>Expo SDK version</th>
-      </tr>
-      <tr>
-        <th>52</th>
-        <th>53</th>
-        <th>54</th>
-        <th>55</th>
-      </tr>
-    </thead>
-    <tbody>
-      <tr>
-        <td><div className={styles.version}>0.8.x</div></td>
-        <td><div className={styles.notSupported}>no</div></td>
-        <td><div className={styles.notSupported}>no</div></td>
-        <td><div className={styles.supported}>yes</div></td>
-        <td><div className={styles.supported}>yes</div></td>
-      </tr>
-      <tr>
-        <td><div className={styles.version}>0.9.x</div></td>
-        <td><div className={styles.notSupported}>no</div></td>
-        <td><div className={styles.notSupported}>no</div></td>
-        <td><div className={styles.supported}>yes</div></td>
-        <td><div className={styles.supported}>yes</div></td>
-      </tr>
-    </tbody>
-  </table>
-</div>
diff --git a/docs/docs/07-other/_category_.json b/docs/docs/07-other/_category_.json
deleted file mode 100644
index 211d3dc36e..0000000000
--- a/docs/docs/07-other/_category_.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "label": "Other",
-  "link": {
-    "type": "generated-index"
-  }
-}
diff --git a/docs/docs/08-resource-fetcher/01-usage.md b/docs/docs/08-resource-fetcher/01-usage.md
deleted file mode 100644
index 46efd47686..0000000000
--- a/docs/docs/08-resource-fetcher/01-usage.md
+++ /dev/null
@@ -1,236 +0,0 @@
----
-title: Usage
----
-
-This page documents the resource fetcher APIs exposed by `react-native-executorch-expo-resource-fetcher` and `react-native-executorch-bare-resource-fetcher`. These adapters handle downloading and managing model files on disk.
-
-:::info
-All examples below use `ExpoResourceFetcher`. If you're on bare React Native, replace the import with:
-
-```typescript
-import { BareResourceFetcher } from 'react-native-executorch-bare-resource-fetcher';
-```
-
-The public API is identical between both adapters.
-:::
-
-## fetch
-
-Fetches resources (remote URLs, local files, or embedded assets) and stores them locally for use by React Native ExecuTorch.
-
-### Reference
-
-```typescript
-import { ExpoResourceFetcher } from 'react-native-executorch-expo-resource-fetcher';
-
-const uris = await ExpoResourceFetcher.fetch(
-  (progress) => console.log('Total progress:', progress),
-  'https://.../lfm2_5.pte',
-  'https://.../tokenizer.json'
-);
-```
-
-### Parameters
-
-- `callback: (downloadProgress: number) => void` - Optional callback to track progress of all downloads, reported between 0 and 1.
-- `...sources: ResourceSource[]` - Multiple resources that can be strings, asset references, or objects.
-
-### Returns
-
-`Promise<string[] | null>`:
-
-- If the fetch was successful, it returns a promise which resolves to an array of local file paths for the downloaded/stored resources (without `file://` prefix).
-- If the fetch was interrupted by `pauseFetching` or `cancelFetching`, it returns a promise which resolves to `null`.
-
-:::info
-If the resource is an object, it will be saved as a JSON file on disk.
-:::
-
-## pauseFetching
-
-Pauses an ongoing download.
-
-:::info
-Bare Resource Fetcher doesn't support this feature on Android.
-:::
-
-### Reference
-
-```typescript
-import { ExpoResourceFetcher } from 'react-native-executorch-expo-resource-fetcher';
-
-const uris = ExpoResourceFetcher.fetch(
-  (progress) => console.log('Total progress:', progress),
-  'https://.../lfm2_5.pte',
-  'https://.../tokenizer.json'
-).then((uris) => {
-  console.log('URI resolved to: ', uris); // null, since we paused
-});
-
-await ExpoResourceFetcher.pauseFetching(
-  'https://.../lfm2_5.pte',
-  'https://.../tokenizer.json'
-);
-```
-
-### Parameters
-
-- `...sources: ResourceSource[]` - The resource identifiers used when calling `fetch`.
-
-### Returns
-
-`Promise<void>` – A promise that resolves once the download is paused.
-
-## resumeFetching
-
-:::info
-Bare Resource Fetcher doesn't support this feature on Android.
-:::
-
-Resumes a paused download.
-
-### Reference
-
-```typescript
-import { ExpoResourceFetcher } from 'react-native-executorch-expo-resource-fetcher';
-
-const uris = ExpoResourceFetcher.fetch(
-  (progress) => console.log('Total progress:', progress),
-  'https://.../lfm2_5.pte',
-  'https://.../tokenizer.json'
-).then((uris) => {
-  console.log('URI resolved as: ', uris); // null, since we paused
-});
-
-await ExpoResourceFetcher.pauseFetching(
-  'https://.../lfm2_5.pte',
-  'https://.../tokenizer.json'
-);
-
-const resolvedUris = await ExpoResourceFetcher.resumeFetching(
-  'https://.../lfm2_5.pte',
-  'https://.../tokenizer.json'
-);
-// resolvedUris resolves to file paths, unless paused/cancelled again
-```
-
-### Parameters
-
-- `...sources: ResourceSource[]` - The resource identifiers used when calling `fetch`.
-
-### Returns
-
-`Promise<string[] | null>`:
-
-- If the fetch was successful, it returns a promise which resolves to an array of local file paths for the downloaded resources (without `file://` prefix).
-- If the fetch was again interrupted by `pauseFetching` or `cancelFetching`, it returns a promise which resolves to `null`.
-
-:::info
-You can also resume a paused download by calling `fetch` again with the same sources. However, `resumeFetching` is faster as it resumes from where it left off.
-:::
-
-## cancelFetching
-
-Cancels an ongoing or paused download.
-
-### Reference
-
-```typescript
-import { ExpoResourceFetcher } from 'react-native-executorch-expo-resource-fetcher';
-
-const uris = ExpoResourceFetcher.fetch(
-  (progress) => console.log('Total progress:', progress),
-  'https://.../lfm2_5.pte',
-  'https://.../tokenizer.json'
-).then((uris) => {
-  console.log('URI resolved as: ', uris); // null, since we cancelled
-});
-
-await ExpoResourceFetcher.cancelFetching(
-  'https://.../lfm2_5.pte',
-  'https://.../tokenizer.json'
-);
-```
-
-### Parameters
-
-- `...sources: ResourceSource[]` - The resource identifiers used when calling `fetch()`.
-
-### Returns
-
-`Promise<void>` – A promise that resolves once the download is cancelled.
-
-## deleteResources
-
-Deletes downloaded resources from the local filesystem.
-
-### Reference
-
-```typescript
-import { ExpoResourceFetcher } from 'react-native-executorch-expo-resource-fetcher';
-
-await ExpoResourceFetcher.deleteResources('https://.../lfm2_5.pte');
-```
-
-### Parameters
-
-- `...sources: ResourceSource[]` - The resource identifiers used when calling `fetch`.
-
-### Returns
-
-`Promise<void>` – A promise that resolves once all specified resources have been removed.
-
-## getFilesTotalSize
-
-Fetches the combined size of remote files. Works only for remote URLs.
-
-### Reference
-
-```typescript
-import { ExpoResourceFetcher } from 'react-native-executorch-expo-resource-fetcher';
-
-const totalSize = await ExpoResourceFetcher.getFilesTotalSize(
-  'https://.../lfm2_5.pte',
-  'https://.../tokenizer.json'
-);
-```
-
-### Parameters
-
-- `...sources: ResourceSource[]` - The resource identifiers (URLs).
-
-### Returns
-
-`Promise<number>` – A promise that resolves to the combined size of files in bytes.
-
-## listDownloadedFiles
-
-Lists all files downloaded by React Native ExecuTorch.
-
-### Reference
-
-```typescript
-import { ExpoResourceFetcher } from 'react-native-executorch-expo-resource-fetcher';
-
-const filesUris = await ExpoResourceFetcher.listDownloadedFiles();
-```
-
-### Returns
-
-`Promise<string[]>` - A promise that resolves to an array of URIs for all downloaded files.
-
-## listDownloadedModels
-
-Lists all downloaded model files (`.pte`).
-
-### Reference
-
-```typescript
-import { ExpoResourceFetcher } from 'react-native-executorch-expo-resource-fetcher';
-
-const modelsUris = await ExpoResourceFetcher.listDownloadedModels();
-```
-
-### Returns
-
-`Promise<string[]>` - A promise that resolves to an array of URIs for all downloaded model files.
diff --git a/docs/docs/08-resource-fetcher/02-custom-adapter.md b/docs/docs/08-resource-fetcher/02-custom-adapter.md
deleted file mode 100644
index 36d25a888d..0000000000
--- a/docs/docs/08-resource-fetcher/02-custom-adapter.md
+++ /dev/null
@@ -1,56 +0,0 @@
----
-title: Custom Adapter
----
-
-If the built-in `BareResourceFetcher` and `ExpoResourceFetcher` don't fit your needs, you can implement your own adapter and plug it into React Native ExecuTorch. This is useful if you want to use a different download library, fetch from a private server, or add custom caching logic.
-
-## The ResourceFetcherAdapter interface
-
-Your adapter must implement the `ResourceFetcherAdapter` interface exported from `react-native-executorch`. This interface defines every method which is used under the hood by React Native ExecuTorch:
-
-```typescript
-import {
-  ResourceFetcherAdapter,
-  ResourceSource,
-} from 'react-native-executorch';
-
-interface ResourceFetcherAdapter {
-  fetch(
-    callback: (downloadProgress: number) => void,
-    ...sources: ResourceSource[]
-  ): Promise<string[] | null>;
-
-  readAsString(path: string): Promise<string>;
-}
-```
-
-### `fetch`
-
-This is the core method called by every model hook and module whenever it needs to resolve a model or resource to a local file path.
-
-- `callback` — called with a progress value between `0` and `1` as downloads proceed. Called with `1` when complete.
-- `...sources` — one or more `ResourceSource` values:
-  - `string` — a remote URL or an absolute local file path.
-  - `number` — a bundled asset reference from `require('./model.pte')`.
-  - `object` — an inline JS object (e.g. a tokenizer config) that should be JSON-serialized and written to disk. Your adapter is responsible for stringifying it and saving it as a file, then returning the local path. This allows callers to pass configs inline instead of hosting them at a URL.
-- **Returns** an array of absolute local file paths (without `file://` prefix), one per source, in the same order. Return `null` if the fetch was intentionally interrupted (e.g. cancelled by the user).
-
-### `readAsString`
-
-Called internally to read configuration files (e.g. tokenizer configs) that were previously downloaded via `fetch`.
-
-- `path` — absolute path to the file on disk.
-- **Returns** the file contents as a UTF-8 string.
-
-## Registering your adapter
-
-Pass your adapter to `initExecutorch` at the entry point of your app, before any other library API is called:
-
-```typescript
-import { initExecutorch } from 'react-native-executorch';
-import { MyCustomFetcher } from './MyCustomFetcher';
-
-initExecutorch({ resourceFetcher: MyCustomFetcher });
-```
-
-Any model hook or module used after this point will route all resource fetching through your adapter.
diff --git a/docs/docs/08-resource-fetcher/_category_.json b/docs/docs/08-resource-fetcher/_category_.json
deleted file mode 100644
index e6f56e8790..0000000000
--- a/docs/docs/08-resource-fetcher/_category_.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "label": "Resource Fetcher",
-  "link": {
-    "type": "generated-index"
-  }
-}
diff --git a/lefthook.yml b/lefthook.yml
index b14f81d10b..99bb1b2655 100644
--- a/lefthook.yml
+++ b/lefthook.yml
@@ -12,11 +12,6 @@ pre-commit:
       run: npx prettier --write {staged_files} && git add {staged_files}
     format-objc:
       glob: '*.{h,hpp,m,mm,c,cpp}'
-      # ErrorCodes.h is generated verbatim by `yarn codegen:errors` and verified
-      # in CI with a raw diff; clang-format would rewrap its comments and break
-      # that check, so it is excluded here.
-      exclude:
-        - 'packages/react-native-executorch/common/rnexecutorch/ErrorCodes.h'
       run: clang-format -i {staged_files} && git add {staged_files}
     format-kotlin:
       glob: '*.{kt}'
diff --git a/package.json b/package.json
index 5000175231..f1f15edb2c 100644
--- a/package.json
+++ b/package.json
@@ -9,10 +9,9 @@
     ]
   },
   "scripts": {
-    "prepare": "yarn workspaces foreach --all --topological-dev run prepare",
-    "lint": "yarn workspaces foreach --all --parallel run lint",
-    "typecheck": "yarn workspaces foreach --all --parallel run typecheck",
-    "codegen:errors": "npx ts-node scripts/generate-errors.ts"
+    "prepare": "yarn workspaces foreach --all --exclude react-native-executorch-bare-resource-fetcher --exclude react-native-executorch-expo-resource-fetcher --exclude react-native-executorch-webrtc --topological-dev run prepare",
+    "lint": "yarn workspaces foreach --all --exclude react-native-executorch-bare-resource-fetcher --exclude react-native-executorch-expo-resource-fetcher --exclude react-native-executorch-webrtc --parallel run lint",
+    "typecheck": "yarn workspaces foreach --all --exclude react-native-executorch-bare-resource-fetcher --exclude react-native-executorch-expo-resource-fetcher --exclude react-native-executorch-webrtc --parallel run typecheck"
   },
   "private": true,
   "devDependencies": {
diff --git a/packages/react-native-executorch/.gitignore b/packages/react-native-executorch/.gitignore
deleted file mode 100644
index 696276e65b..0000000000
--- a/packages/react-native-executorch/.gitignore
+++ /dev/null
@@ -1,3 +0,0 @@
-*.tsbuildinfo
-
-third-party/ios/ExecutorchLib/output
\ No newline at end of file
diff --git a/packages/react-native-executorch/.watchmanconfig b/packages/react-native-executorch/.watchmanconfig
deleted file mode 100644
index 0967ef424b..0000000000
--- a/packages/react-native-executorch/.watchmanconfig
+++ /dev/null
@@ -1 +0,0 @@
-{}
diff --git a/packages/react-native-executorch/android/CMakeLists.txt b/packages/react-native-executorch/android/CMakeLists.txt
index 038335f7e2..101aa4b45b 100644
--- a/packages/react-native-executorch/android/CMakeLists.txt
+++ b/packages/react-native-executorch/android/CMakeLists.txt
@@ -1,33 +1,40 @@
-cmake_minimum_required(VERSION 3.13)
+cmake_minimum_required(VERSION 3.10)
 project(RnExecutorch)
 
-set (CMAKE_VERBOSE_MAKEFILE ON)
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
-set (CMAKE_CXX_STANDARD 20)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
 
-include("${REACT_NATIVE_DIR}/ReactAndroid/cmake-utils/folly-flags.cmake")
-add_compile_options(${folly_FLAGS})
+set(EXEC_LIB_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../third-party/android/jniLibs/${ANDROID_ABI}/libexecutorch.so")
 
+add_library(executorch SHARED IMPORTED)
+set_target_properties(executorch PROPERTIES IMPORTED_LOCATION ${EXEC_LIB_PATH})
 
-if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 80)
-  include("${REACT_NATIVE_DIR}/ReactCommon/cmake-utils/react-native-flags.cmake")
-  target_compile_reactnative_options(react-native-executorch PRIVATE)
-else()
-  string(APPEND CMAKE_CXX_FLAGS " -O2 -fstack-protector-all -fexceptions -frtti -std=c++${CMAKE_CXX_STANDARD} -Wall")
-endif()
+find_package(ReactAndroid REQUIRED CONFIG)
 
-string(APPEND CMAKE_CXX_FLAGS " -DRCT_NEW_ARCH_ENABLED")
+file(GLOB CORE_SOURCES ../cpp/core/*.cpp)
 
-set(ANDROID_CPP_DIR "${CMAKE_SOURCE_DIR}/src/main/cpp")
-set(COMMON_CPP_DIR "${CMAKE_SOURCE_DIR}/../common")
-set(LIBS_DIR "${CMAKE_SOURCE_DIR}/../third-party/android/libs")
-set(COMMON_THIRD_PARTY_DIR "${CMAKE_SOURCE_DIR}/../third-party/common")
-set(TOKENIZERS_DIR "${CMAKE_SOURCE_DIR}/../third-party/include/executorch/extension/llm/tokenizers/include")
-set(INCLUDE_DIR "${CMAKE_SOURCE_DIR}/../third-party/include")
+add_library(${CMAKE_PROJECT_NAME} SHARED
+    ../cpp/RnExecutorch.cpp
+    ${CORE_SOURCES}
+    cpp-adapter.cpp
+)
 
-# Treat third-party headers as system headers to suppress deprecation warnings
-include_directories(SYSTEM "${INCLUDE_DIR}")
-include_directories(SYSTEM "${INCLUDE_DIR}/cpuinfo")
-include_directories(SYSTEM "${INCLUDE_DIR}/pthreadpool")
+target_compile_definitions(${CMAKE_PROJECT_NAME} PRIVATE
+    C10_USING_CUSTOM_GENERATED_MACROS=1
+    EXECUTORCH_ENABLE_EXECUTION_PROFILING=1
+)
 
-add_subdirectory("${ANDROID_CPP_DIR}")
+target_include_directories(${CMAKE_PROJECT_NAME} PRIVATE
+    ../cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/../third-party/include
+)
+
+# Ensure executorch is linked with WHOLE_ARCHIVE so all static initializers are included
+target_link_options(${CMAKE_PROJECT_NAME} PRIVATE -Wl,--whole-archive)
+target_link_libraries(${CMAKE_PROJECT_NAME} executorch)
+target_link_options(${CMAKE_PROJECT_NAME} PRIVATE -Wl,--no-whole-archive)
+
+target_link_libraries(${CMAKE_PROJECT_NAME}
+    ReactAndroid::jsi
+    log
+)
diff --git a/packages/react-native-executorch/android/build.gradle b/packages/react-native-executorch/android/build.gradle
deleted file mode 100644
index 5b1cfd2973..0000000000
--- a/packages/react-native-executorch/android/build.gradle
+++ /dev/null
@@ -1,172 +0,0 @@
-import org.apache.tools.ant.taskdefs.condition.Os
-
-buildscript {
-  ext {
-    agp_version = '8.4.2'
-  }
-
-  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
-  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["RnExecutorch_kotlinVersion"]
-
-  repositories {
-    google()
-    mavenCentral()
-    maven { url 'https://jitpack.io' }
-  }
-
-  dependencies {
-    classpath "com.android.tools.build:gradle:$agp_version"
-    // noinspection DifferentKotlinGradleVersion
-    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-  }
-}
-
-def reactNativeArchitectures() {
-  def value = rootProject.getProperties().get("reactNativeArchitectures")
-  // react-native-executorch supports only these architectures. This is due to
-  // Executorch not supporting anything else.
-  def defaultArchitectures = ["x86_64", "arm64-v8a"]
-  if(!value) {
-    return defaultArchitectures
-  }
-  def architectures = value.split(",")
-  return architectures.findAll { it in defaultArchitectures }
-}
-
-apply plugin: "com.android.library"
-apply plugin: "kotlin-android"
-apply plugin: "com.facebook.react"
-
-
-def getExtOrDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["RnExecutorch_" + name]
-}
-
-def getExtOrIntegerDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["RnExecutorch_" + name]).toInteger()
-}
-
-def supportsNamespace() {
-  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
-  def major = parsed[0].toInteger()
-  def minor = parsed[1].toInteger()
-
-  // Namespace support was added in 7.3.0
-  return (major == 7 && minor >= 3) || major >= 8
-}
-
-def safeAppExtGet(prop, fallback) {
-  def appProject = rootProject.allprojects.find { it.plugins.hasPlugin('com.android.application') }
-  appProject?.ext?.has(prop) ? appProject.ext.get(prop) : fallback
-}
-
-def toPlatformFileString(String path) {
-  if (Os.isFamily(Os.FAMILY_WINDOWS)) {
-      path = path.replace(File.separatorChar, '/' as char)
-  }
-  return path
-}
-
-def resolveReactNativeDirectory() {
-  def reactNativeLocation = safeAppExtGet("REACT_NATIVE_NODE_MODULES_DIR", null)
-
-  if (reactNativeLocation !== null) {
-    return file(reactNativeLocation)
-  }
-
-  // Fallback to node resolver for custom directory structures like monorepos.
-  def reactNativePackage = file(["node", "--print", "require.resolve('react-native/package.json')"].execute(null, rootDir).text.trim())
-  if(reactNativePackage.exists()) {
-      return reactNativePackage.parentFile
-  }
-
-  throw new GradleException(
-      "[RnExecutorch] Unable to resolve react-native location in node_modules. You should project extension property (in `app/build.gradle`) `REACT_NATIVE_NODE_MODULES_DIR` with path to react-native."
-  )
-}
-
-def reactNativeRootDir = resolveReactNativeDirectory()
-
-android {
-  if (supportsNamespace()) {
-    namespace "com.swmansion.rnexecutorch"
-
-    sourceSets {
-      main {
-        manifest.srcFile "src/main/AndroidManifestNew.xml"
-      }
-    }
-  }
-
-  buildFeatures {
-    prefab true
-    prefabPublishing true
-    buildConfig true
-  }
-
-  prefab {
-    "react-native-executorch" {
-      headers "src/main/cpp"
-    }
-  }
-
-  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
-
-  defaultConfig {
-    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
-    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
-    externalNativeBuild {
-        cmake {
-          abiFilters (*reactNativeArchitectures())
-          arguments "-DANDROID_STL=c++_shared",
-                    "-DREACT_NATIVE_DIR=${toPlatformFileString(reactNativeRootDir.path)}",
-                    "-DBUILD_DIR=${project.buildDir}",
-                    "-DANDROID_TOOLCHAIN=clang",
-                    "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
-      }
-    }
-  }
-
-
-  externalNativeBuild {
-    cmake {
-      path "CMakeLists.txt"
-    }
-  }
-
-  buildTypes {
-    release {
-      minifyEnabled false
-    }
-  }
-
-  lintOptions {
-    disable "GradleCompatible"
-  }
-
-  compileOptions {
-    sourceCompatibility JavaVersion.VERSION_1_8
-    targetCompatibility JavaVersion.VERSION_1_8
-  }
-
-}
-
-repositories {
-  mavenCentral()
-  google()
-  maven { url 'https://jitpack.io' }
-}
-
-def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["RnExecutorch_kotlinVersion"]
-
-dependencies {
-  // For < 0.71, this will be from the local maven repo
-  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
-  //noinspection GradleDynamicVersion
-  implementation "com.facebook.react:react-android:+"
-  implementation "com.facebook.react:react-native:+"
-  implementation 'com.facebook.fbjni:fbjni:0.6.0'
-  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation files('libs/classes.jar')
-  implementation("com.squareup.okhttp3:okhttp:4.9.2")
-}
diff --git a/packages/react-native-executorch/android/build.gradle.kts b/packages/react-native-executorch/android/build.gradle.kts
new file mode 100644
index 0000000000..793f8322e1
--- /dev/null
+++ b/packages/react-native-executorch/android/build.gradle.kts
@@ -0,0 +1,97 @@
+plugins {
+    id("com.android.library")
+    id("org.jetbrains.kotlin.android")
+    id("com.facebook.react")
+}
+
+/**
+ * Helper function to get variables from the root project (App level) 
+ * or fall back to local project properties.
+ */
+fun getExtOrDefault(name: String, default: Any): Any {
+    return if (rootProject.ext.has(name)) {
+        rootProject.ext.get(name)!!
+    } else if (project.properties.containsKey(name)) {
+        project.properties[name]!!
+    } else {
+        default
+    }
+}
+
+android {
+    namespace = "com.swmansion.rnexecutorch"
+    compileSdk = (getExtOrDefault("compileSdkVersion", 34) as Number).toInt()
+
+    defaultConfig {
+        minSdk = (getExtOrDefault("minSdkVersion", 21) as Number).toInt()
+        targetSdk = (getExtOrDefault("targetSdkVersion", 34) as Number).toInt()
+
+        externalNativeBuild {
+            cmake {
+                cppFlags("-fexceptions", "-frtti", "-std=c++20", "-Wall")
+                arguments("-DANDROID_STL=c++_shared")
+                
+                // CRITICAL: Only include ABIs you actually have binaries for
+                // Since you only have arm64-v8a in third-party, we pin it here.
+                abiFilters.add("arm64-v8a")
+            }
+        }
+    }
+
+    externalNativeBuild {
+        cmake {
+            path = file("CMakeLists.txt")
+        }
+    }
+
+    sourceSets {
+        getByName("main") {
+            // Pointing to your centralized third-party binaries
+            jniLibs.srcDirs("../third-party/android/jniLibs")
+            // Include generated codegen if using TurboModules
+            java.srcDirs("${project.buildDir}/generated/source/codegen/java")
+        }
+    }
+
+    buildFeatures {
+        buildConfig = true
+        prefab = true // Required for modern C++ / JNI linking
+    }
+
+    packaging {
+        // Prevents "Duplicate Library" errors with the React Native JSI engine
+        resources.excludes.add("**/libjsi.so")
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    // React Native Android Engine
+    implementation("com.facebook.react:react-android")
+
+    // The ExecuTorch Java/Kotlin wrapper from your third-party folder
+    implementation(files("../third-party/android/libs/executorch.jar"))
+
+    // Recommended for modern Kotlin Android development
+    implementation("androidx.core:core-ktx:1.12.0")
+}
+
+// React Native Codegen Configuration
+extensions.configure<com.facebook.react.ReactExtension>("react") {
+    jsRootDir = file("../src/")
+    libraryName = "RnExecutorch"
+    codegenJavaPackageName = "com.swmansion.rnexecutorch"
+}
\ No newline at end of file
diff --git a/packages/react-native-executorch/android/cpp-adapter.cpp b/packages/react-native-executorch/android/cpp-adapter.cpp
new file mode 100644
index 0000000000..78bc088674
--- /dev/null
+++ b/packages/react-native-executorch/android/cpp-adapter.cpp
@@ -0,0 +1,9 @@
+#include "RnExecutorch.h"
+#include <jni.h>
+#include <jsi/jsi.h>
+
+extern "C" JNIEXPORT void JNICALL Java_com_swmansion_rnexecutorch_RnExecutorchModule_nativeInstall(
+    JNIEnv *env, jclass clazz, jlong jsi) {
+    facebook::jsi::Runtime *runtime = reinterpret_cast<facebook::jsi::Runtime *>(jsi);
+    rnexecutorch::install(*runtime);
+}
diff --git a/packages/react-native-executorch/android/gradle.properties b/packages/react-native-executorch/android/gradle.properties
deleted file mode 100644
index 97cdd1854c..0000000000
--- a/packages/react-native-executorch/android/gradle.properties
+++ /dev/null
@@ -1,5 +0,0 @@
-RnExecutorch_kotlinVersion=1.7.0
-RnExecutorch_minSdkVersion=26
-RnExecutorch_targetSdkVersion=31
-RnExecutorch_compileSdkVersion=31
-RnExecutorch_ndkversion=21.4.7075529
\ No newline at end of file
diff --git a/packages/react-native-executorch/android/gradle/wrapper/gradle-wrapper.jar b/packages/react-native-executorch/android/gradle/wrapper/gradle-wrapper.jar
deleted file mode 100644
index d64cd49177..0000000000
Binary files a/packages/react-native-executorch/android/gradle/wrapper/gradle-wrapper.jar and /dev/null differ
diff --git a/packages/react-native-executorch/android/gradle/wrapper/gradle-wrapper.properties b/packages/react-native-executorch/android/gradle/wrapper/gradle-wrapper.properties
deleted file mode 100644
index 49334c2bf5..0000000000
--- a/packages/react-native-executorch/android/gradle/wrapper/gradle-wrapper.properties
+++ /dev/null
@@ -1,8 +0,0 @@
-#Tue Mar 11 09:36:23 CET 2025
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
-networkTimeout=10000
-validateDistributionUrl=true
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists
diff --git a/packages/react-native-executorch/android/libs/classes.jar b/packages/react-native-executorch/android/libs/classes.jar
deleted file mode 100644
index 81eee28f71..0000000000
Binary files a/packages/react-native-executorch/android/libs/classes.jar and /dev/null differ
diff --git a/packages/react-native-executorch/android/src/main/AndroidManifest.xml b/packages/react-native-executorch/android/src/main/AndroidManifest.xml
index d3aa5b73cc..a2f47b6057 100644
--- a/packages/react-native-executorch/android/src/main/AndroidManifest.xml
+++ b/packages/react-native-executorch/android/src/main/AndroidManifest.xml
@@ -1,3 +1,2 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.swmansion.rnexecutorch">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
 </manifest>
diff --git a/packages/react-native-executorch/android/src/main/AndroidManifestNew.xml b/packages/react-native-executorch/android/src/main/AndroidManifestNew.xml
deleted file mode 100644
index a2f47b6057..0000000000
--- a/packages/react-native-executorch/android/src/main/AndroidManifestNew.xml
+++ /dev/null
@@ -1,2 +0,0 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
-</manifest>
diff --git a/packages/react-native-executorch/android/src/main/cpp/CMakeLists.txt b/packages/react-native-executorch/android/src/main/cpp/CMakeLists.txt
deleted file mode 100644
index dfbf74ae3e..0000000000
--- a/packages/react-native-executorch/android/src/main/cpp/CMakeLists.txt
+++ /dev/null
@@ -1,112 +0,0 @@
-cmake_minimum_required(VERSION 3.13)
-
-file(GLOB_RECURSE ANDROID_CPP_SOURCES CONFIGURE_DEPENDS "${ANDROID_CPP_DIR}/*.cpp")
-file(GLOB_RECURSE COMMON_CPP_SOURCES CONFIGURE_DEPENDS "${COMMON_CPP_DIR}/*.cpp")
-file(GLOB_RECURSE COMMON_C_SOURCES CONFIGURE_DEPENDS "${COMMON_CPP_DIR}/*.c")
-file(GLOB_RECURSE TEST_CPP_SOURCES "${COMMON_CPP_DIR}/rnexecutorch/tests/*.cpp")
-list(REMOVE_ITEM COMMON_CPP_SOURCES ${TEST_CPP_SOURCES})
-
-add_library(react-native-executorch SHARED ${ANDROID_CPP_SOURCES} ${COMMON_CPP_SOURCES} ${COMMON_C_SOURCES})
-
-find_package(ReactAndroid REQUIRED CONFIG)
-find_package(fbjni REQUIRED CONFIG)
-
-target_include_directories(
-  react-native-executorch
-  PUBLIC
-  "${COMMON_CPP_DIR}"
-  "${ANDROID_CPP_DIR}"
-  "${INCLUDE_DIR}"
-  "${TOKENIZERS_DIR}"
-  "${REACT_NATIVE_DIR}/ReactCommon"
-  "${REACT_NATIVE_DIR}/ReactAndroid/src/main/jni/react/turbomodule"
-  "${REACT_NATIVE_DIR}/ReactCommon/callinvoker"
-)
-
-set(LINK_LIBRARIES
-  ReactAndroid::jsi
-  fbjni::fbjni
-  android
-  log
-)
-
-set(RN_VERSION_LINK_LIBRARIES
-  ReactAndroid::reactnative
-)
-
-# Dependencies:
-
-# ------- Executorch -------
-
-add_library(executorch SHARED IMPORTED)
-
-set_target_properties(executorch PROPERTIES
-                      IMPORTED_LOCATION "${LIBS_DIR}/executorch/${ANDROID_ABI}/libexecutorch.so")
-
-
-if(ANDROID_ABI STREQUAL "arm64-v8a")
-  target_compile_definitions(react-native-executorch PRIVATE ARCH_ARM64)
-
-  # ------- pthreadpool -------
-  add_library(pthreadpool SHARED IMPORTED)
-
-  set_target_properties(pthreadpool PROPERTIES
-                        IMPORTED_LOCATION "${LIBS_DIR}/pthreadpool/${ANDROID_ABI}/libpthreadpool.so")
-
-  # ------- cpuinfo -------
-  add_library(cpuinfo SHARED IMPORTED)
-
-  set_target_properties(cpuinfo PROPERTIES
-                        IMPORTED_LOCATION "${LIBS_DIR}/cpuinfo/${ANDROID_ABI}/libcpuinfo.so")
-  set(EXECUTORCH_LIBS
-    "pthreadpool"
-    "cpuinfo"
-  )
-endif()
-
-# ------- OpenCV -------
-
-set(OPENCV_LIBS
-  "${LIBS_DIR}/opencv/${ANDROID_ABI}/libopencv_core.a"
-  "${LIBS_DIR}/opencv/${ANDROID_ABI}/libopencv_features2d.a"
-  "${LIBS_DIR}/opencv/${ANDROID_ABI}/libopencv_highgui.a"
-  "${LIBS_DIR}/opencv/${ANDROID_ABI}/libopencv_imgproc.a"
-  "${LIBS_DIR}/opencv/${ANDROID_ABI}/libopencv_photo.a"
-  "${LIBS_DIR}/opencv/${ANDROID_ABI}/libopencv_video.a"
-)
-
-if(ANDROID_ABI STREQUAL "arm64-v8a")
-  set(OPENCV_THIRD_PARTY_LIBS
-    "${LIBS_DIR}/opencv-third-party/${ANDROID_ABI}/libkleidicv_hal.a"
-    "${LIBS_DIR}/opencv-third-party/${ANDROID_ABI}/libkleidicv_thread.a"
-    "${LIBS_DIR}/opencv-third-party/${ANDROID_ABI}/libkleidicv.a"
-  )
-elseif(ANDROID_ABI STREQUAL "x86_64")
-  set(OPENCV_THIRD_PARTY_LIBS "")
-endif()
-
-
-# ------- phonemis -------
-
-set(PHONEMIS_DIR "${COMMON_THIRD_PARTY_DIR}/phonemis")
-add_subdirectory(${PHONEMIS_DIR} ${CMAKE_BINARY_DIR}/phonemis)
-
-target_compile_definitions(phonemis PRIVATE ET_ON)  # Phonemis uses ET_ON flag to detect available ExecuTorch build (NeuralPhonemizer)
-target_include_directories(phonemis PRIVATE "${INCLUDE_DIR}")  # ExecuTorch headers
-target_include_directories(react-native-executorch PUBLIC "${PHONEMIS_DIR}/src")
-
-# --------------
-
-target_link_options(react-native-executorch PRIVATE -fopenmp -static-openmp)
-
-target_link_libraries(
-  react-native-executorch
-  ${LINK_LIBRARIES}
-  ${RN_VERSION_LINK_LIBRARIES}
-  ${OPENCV_LIBS}
-  ${OPENCV_THIRD_PARTY_LIBS}
-  phonemis
-  executorch
-  ${EXECUTORCH_LIBS}
-  z
-)
diff --git a/packages/react-native-executorch/android/src/main/cpp/ETInstallerModule.cpp b/packages/react-native-executorch/android/src/main/cpp/ETInstallerModule.cpp
deleted file mode 100644
index 1a637b15d1..0000000000
--- a/packages/react-native-executorch/android/src/main/cpp/ETInstallerModule.cpp
+++ /dev/null
@@ -1,80 +0,0 @@
-#include "ETInstallerModule.h"
-
-#include <rnexecutorch/RnExecutorchInstaller.h>
-
-#include "EmulatorDetection.h"
-
-#include <jni.h>
-#include <jsi/jsi.h>
-
-namespace rnexecutorch {
-JavaVM *java_machine;
-using namespace facebook::jni;
-
-ETInstallerModule::ETInstallerModule(
-    jni::alias_ref<ETInstallerModule::jhybridobject> &jThis,
-    jsi::Runtime *jsiRuntime,
-    const std::shared_ptr<facebook::react::CallInvoker> &jsCallInvoker)
-    : javaPart_(make_global(jThis)), jsiRuntime_(jsiRuntime),
-      jsCallInvoker_(jsCallInvoker) {}
-
-jni::local_ref<ETInstallerModule::jhybriddata> ETInstallerModule::initHybrid(
-    jni::alias_ref<jhybridobject> jThis, jlong jsContext,
-    jni::alias_ref<facebook::react::CallInvokerHolder::javaobject>
-        jsCallInvokerHolder) {
-  auto jsCallInvoker = jsCallInvokerHolder->cthis()->getCallInvoker();
-  auto rnRuntime = reinterpret_cast<jsi::Runtime *>(jsContext);
-  return makeCxxInstance(jThis, rnRuntime, jsCallInvoker);
-}
-
-void ETInstallerModule::registerNatives() {
-  registerHybrid({
-      makeNativeMethod("initHybrid", ETInstallerModule::initHybrid),
-      makeNativeMethod("injectJSIBindings",
-                       ETInstallerModule::injectJSIBindings),
-  });
-}
-
-void ETInstallerModule::injectJSIBindings() {
-  // Grab a function for fetching images via URL from Java
-  auto fetchDataByUrl = [](std::string url) {
-    // Attaching Current Thread to JVM
-
-    JNIEnv *env = nullptr;
-    int getEnvStat = java_machine->GetEnv((void **)&env, JNI_VERSION_1_6);
-    if (getEnvStat == JNI_EDETACHED) {
-      if (java_machine->AttachCurrentThread(&env, nullptr) != 0) {
-        throw std::runtime_error("Failed to attach thread to JVM");
-      }
-    }
-    static jclass cls = javaClassStatic().get();
-    static jmethodID method = env->GetStaticMethodID(
-        cls, "fetchByteDataFromUrl", "(Ljava/lang/String;)[B");
-
-    jstring jUrl = env->NewStringUTF(url.c_str());
-    jbyteArray byteData =
-        (jbyteArray)env->CallStaticObjectMethod(cls, method, jUrl);
-
-    if (env->IsSameObject(byteData, NULL)) {
-      throw std::runtime_error("Error fetching data from a url");
-    }
-
-    int size = env->GetArrayLength(byteData);
-    jbyte *bytes = env->GetByteArrayElements(byteData, JNI_FALSE);
-    std::byte *dataBytePtr = reinterpret_cast<std::byte *>(bytes);
-
-    return std::vector<std::byte>(dataBytePtr, dataBytePtr + size);
-  };
-
-  auto _isEmulator = isEmulator();
-
-  RnExecutorchInstaller::injectJSIBindings(jsiRuntime_, jsCallInvoker_,
-                                           fetchDataByUrl, _isEmulator);
-}
-} // namespace rnexecutorch
-
-JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
-  rnexecutorch::java_machine = vm;
-  return facebook::jni::initialize(
-      vm, [] { rnexecutorch::ETInstallerModule::registerNatives(); });
-}
\ No newline at end of file
diff --git a/packages/react-native-executorch/android/src/main/cpp/ETInstallerModule.h b/packages/react-native-executorch/android/src/main/cpp/ETInstallerModule.h
deleted file mode 100644
index 82531ac9d5..0000000000
--- a/packages/react-native-executorch/android/src/main/cpp/ETInstallerModule.h
+++ /dev/null
@@ -1,42 +0,0 @@
-#pragma once
-
-#include <ReactCommon/CallInvokerHolder.h>
-#include <fbjni/fbjni.h>
-#include <react/jni/JMessageQueueThread.h>
-
-#include <memory>
-#include <utility>
-
-namespace rnexecutorch {
-
-using namespace facebook;
-using namespace react;
-
-class ETInstallerModule : public jni::HybridClass<ETInstallerModule> {
-public:
-  static auto constexpr kJavaDescriptor =
-      "Lcom/swmansion/rnexecutorch/ETInstaller;";
-
-  static jni::local_ref<ETInstallerModule::jhybriddata>
-  initHybrid(jni::alias_ref<jhybridobject> jThis, jlong jsContext,
-             jni::alias_ref<facebook::react::CallInvokerHolder::javaobject>
-                 jsCallInvokerHolder);
-
-  static void registerNatives();
-
-  void injectJSIBindings();
-
-private:
-  friend HybridBase;
-
-  jni::global_ref<ETInstallerModule::javaobject> javaPart_;
-  jsi::Runtime *jsiRuntime_;
-  std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker_;
-
-  explicit ETInstallerModule(
-      jni::alias_ref<ETInstallerModule::jhybridobject> &jThis,
-      jsi::Runtime *jsiRuntime,
-      const std::shared_ptr<facebook::react::CallInvoker> &jsCallInvoker);
-};
-
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/android/src/main/cpp/EmulatorDetection.h b/packages/react-native-executorch/android/src/main/cpp/EmulatorDetection.h
deleted file mode 100644
index 63cc17e398..0000000000
--- a/packages/react-native-executorch/android/src/main/cpp/EmulatorDetection.h
+++ /dev/null
@@ -1,36 +0,0 @@
-#pragma once
-
-#include <string>
-#include <sys/system_properties.h>
-
-namespace rnexecutorch {
-
-inline bool isEmulator() {
-  auto readProp = [](const char *key) -> std::string {
-#if __ANDROID_API__ >= 26
-    const prop_info *pi = __system_property_find(key);
-    if (pi == nullptr) {
-      return "";
-    }
-    std::string result;
-    __system_property_read_callback(
-        pi,
-        [](void *cookie, const char * /*__name*/, const char *value,
-           uint32_t /*__serial*/) {
-          *static_cast<std::string *>(cookie) = value;
-        },
-        &result);
-    return result;
-#else
-    char value[PROP_VALUE_MAX] = {0};
-    __system_property_get(key, value);
-    return {value};
-#endif
-  };
-
-  std::string fp = readProp("ro.build.fingerprint");
-  std::string hw = readProp("ro.hardware");
-  return fp.find("generic") == 0 || hw == "goldfish" || hw == "ranchu";
-}
-
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/android/src/main/java/com/swmansion/rnexecutorch/ETInstaller.kt b/packages/react-native-executorch/android/src/main/java/com/swmansion/rnexecutorch/ETInstaller.kt
deleted file mode 100644
index acc43c0a9e..0000000000
--- a/packages/react-native-executorch/android/src/main/java/com/swmansion/rnexecutorch/ETInstaller.kt
+++ /dev/null
@@ -1,66 +0,0 @@
-package com.swmansion.rnexecutorch
-
-import com.facebook.jni.HybridData
-import com.facebook.proguard.annotations.DoNotStrip
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.common.annotations.FrameworkAPI
-import com.facebook.react.module.annotations.ReactModule
-import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
-import java.io.InputStream
-import java.net.URL
-
-@OptIn(FrameworkAPI::class)
-@ReactModule(name = ETInstaller.NAME)
-class ETInstaller(
-  reactContext: ReactApplicationContext,
-) : NativeETInstallerSpec(reactContext) {
-  companion object {
-    const val NAME = NativeETInstallerSpec.NAME
-
-    @JvmStatic
-    @DoNotStrip
-    @Throws(Exception::class)
-    fun fetchByteDataFromUrl(source: String): ByteArray? {
-      try {
-        val url = URL(source)
-        val connection = url.openConnection()
-        connection.connect()
-
-        val inputStream: InputStream = connection.getInputStream()
-        val data = inputStream.readBytes()
-        inputStream.close()
-
-        return data
-      } catch (exception: Throwable) {
-        return null
-      }
-    }
-  }
-
-  private val mHybridData: HybridData
-
-  external fun initHybrid(
-    jsContext: Long,
-    callInvoker: CallInvokerHolderImpl,
-  ): HybridData
-
-  private external fun injectJSIBindings()
-
-  init {
-    try {
-      System.loadLibrary("executorch")
-      System.loadLibrary("react-native-executorch")
-      val jsCallInvokerHolder = reactContext.jsCallInvokerHolder as CallInvokerHolderImpl
-      mHybridData = initHybrid(reactContext.javaScriptContextHolder!!.get(), jsCallInvokerHolder)
-    } catch (exception: UnsatisfiedLinkError) {
-      throw RuntimeException("Could not load native module ETInstaller", exception)
-    }
-  }
-
-  @ReactMethod(isBlockingSynchronousMethod = true)
-  override fun install(): Boolean {
-    injectJSIBindings()
-    return true
-  }
-}
diff --git a/packages/react-native-executorch/android/src/main/java/com/swmansion/rnexecutorch/ETInstallerUnavailable.kt b/packages/react-native-executorch/android/src/main/java/com/swmansion/rnexecutorch/ETInstallerUnavailable.kt
deleted file mode 100644
index 0b4c57bb60..0000000000
--- a/packages/react-native-executorch/android/src/main/java/com/swmansion/rnexecutorch/ETInstallerUnavailable.kt
+++ /dev/null
@@ -1,27 +0,0 @@
-package com.swmansion.rnexecutorch
-
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.common.annotations.FrameworkAPI
-import com.facebook.react.module.annotations.ReactModule
-
-/**
- * Fallback TurboModule returned when native ExecuTorch libraries cannot be
- * loaded (e.g. 32-bit Android devices where only arm64-v8a binaries are
- * shipped). Extends the same spec as ETInstaller so JS sees a real linked
- * module, but install() returns false to signal unavailability.
- */
-@OptIn(FrameworkAPI::class)
-@ReactModule(name = ETInstallerUnavailable.NAME)
-class ETInstallerUnavailable(
-  reactContext: ReactApplicationContext,
-) : NativeETInstallerSpec(reactContext) {
-  companion object {
-    const val NAME = NativeETInstallerSpec.NAME
-  }
-
-  @ReactMethod(isBlockingSynchronousMethod = true)
-  override fun install(): Boolean {
-    return false
-  }
-}
diff --git a/packages/react-native-executorch/android/src/main/java/com/swmansion/rnexecutorch/RnExecutorchModule.kt b/packages/react-native-executorch/android/src/main/java/com/swmansion/rnexecutorch/RnExecutorchModule.kt
new file mode 100644
index 0000000000..12ac5b8d5c
--- /dev/null
+++ b/packages/react-native-executorch/android/src/main/java/com/swmansion/rnexecutorch/RnExecutorchModule.kt
@@ -0,0 +1,28 @@
+package com.swmansion.rnexecutorch
+
+import com.facebook.react.bridge.JavaScriptContextHolder
+import com.facebook.react.bridge.ReactApplicationContext
+
+class RnExecutorchModule(reactContext: ReactApplicationContext) : RnExecutorchSpec(reactContext) {
+
+  override fun getName(): String = NAME
+
+  override fun install(): Boolean {
+    val contextHolder: JavaScriptContextHolder =
+      reactApplicationContext.javaScriptContextHolder ?: return false
+    nativeInstall(contextHolder.get())
+    return true
+  }
+
+  companion object {
+    const val NAME = "RnExecutorch"
+
+    init {
+      System.loadLibrary("executorch")
+      System.loadLibrary("RnExecutorch")
+    }
+
+    @JvmStatic
+    external fun nativeInstall(jsi: Long)
+  }
+}
diff --git a/packages/react-native-executorch/android/src/main/java/com/swmansion/rnexecutorch/RnExecutorchPackage.kt b/packages/react-native-executorch/android/src/main/java/com/swmansion/rnexecutorch/RnExecutorchPackage.kt
index 46abca85d7..092ad2de20 100644
--- a/packages/react-native-executorch/android/src/main/java/com/swmansion/rnexecutorch/RnExecutorchPackage.kt
+++ b/packages/react-native-executorch/android/src/main/java/com/swmansion/rnexecutorch/RnExecutorchPackage.kt
@@ -1,50 +1,28 @@
 package com.swmansion.rnexecutorch
 
-import com.facebook.react.TurboReactPackage
+import com.facebook.react.BaseReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.module.model.ReactModuleInfo
 import com.facebook.react.module.model.ReactModuleInfoProvider
-import com.facebook.react.uimanager.ViewManager
 
-class RnExecutorchPackage : TurboReactPackage() {
-  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> = listOf()
+class RnExecutorchPackage : BaseReactPackage() {
 
-  override fun getModule(
-    name: String,
-    reactContext: ReactApplicationContext,
-  ): NativeModule? =
-    if (name == ETInstaller.NAME) {
-      try {
-        ETInstaller(reactContext)
-      } catch (e: RuntimeException) {
-        if (e.cause is UnsatisfiedLinkError) {
-          // Native library not available (e.g. 32-bit device without arm64-v8a .so).
-          // Return a fallback module whose install() returns false so JS can
-          // distinguish "unsupported ABI" from "package not linked."
-          ETInstallerUnavailable(reactContext)
-        } else {
-          throw e
-        }
-      }
-    } else {
-      null
-    }
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
+    if (name == RnExecutorchModule.NAME) RnExecutorchModule(reactContext) else null
 
   override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
     ReactModuleInfoProvider {
-      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
-      moduleInfos[ETInstaller.NAME] =
-        ReactModuleInfo(
-          ETInstaller.NAME,
-          ETInstaller.NAME,
+      mapOf(
+        RnExecutorchModule.NAME to ReactModuleInfo(
+          RnExecutorchModule.NAME,
+          RnExecutorchModule.NAME,
           false, // canOverrideExistingModule
           false, // needsEagerInit
-          true, // hasConstants
+          true,  // hasConstants
           false, // isCxxModule
-          true,
+          true   // isTurboModule
         )
-
-      moduleInfos
+      )
     }
 }
diff --git a/packages/react-native-executorch/android/src/main/java/com/swmansion/rnexecutorch/RnExecutorchSpec.kt b/packages/react-native-executorch/android/src/main/java/com/swmansion/rnexecutorch/RnExecutorchSpec.kt
new file mode 100644
index 0000000000..86953f76d6
--- /dev/null
+++ b/packages/react-native-executorch/android/src/main/java/com/swmansion/rnexecutorch/RnExecutorchSpec.kt
@@ -0,0 +1,7 @@
+package com.swmansion.rnexecutorch
+
+import com.facebook.react.bridge.ReactApplicationContext
+
+abstract class RnExecutorchSpec(reactContext: ReactApplicationContext) : NativeRnExecutorchSpec(reactContext) {
+  abstract override fun getName(): String
+}
diff --git a/packages/react-native-executorch/babel.config.js b/packages/react-native-executorch/babel.config.js
new file mode 100644
index 0000000000..0c05fd6963
--- /dev/null
+++ b/packages/react-native-executorch/babel.config.js
@@ -0,0 +1,12 @@
+module.exports = {
+  overrides: [
+    {
+      exclude: /\/node_modules\//,
+      presets: ['module:react-native-builder-bob/babel-preset'],
+    },
+    {
+      include: /\/node_modules\//,
+      presets: ['module:@react-native/babel-preset'],
+    },
+  ],
+};
diff --git a/packages/react-native-executorch/common/ada/ada.cpp b/packages/react-native-executorch/common/ada/ada.cpp
deleted file mode 100644
index 2f9263a1fd..0000000000
--- a/packages/react-native-executorch/common/ada/ada.cpp
+++ /dev/null
@@ -1,17406 +0,0 @@
-/* auto-generated on 2025-01-30 14:25:38 -0500. Do not edit! */
-/* begin file src/ada.cpp */
-#include "ada.h"
-/* begin file src/checkers.cpp */
-
-#include <algorithm>
-#include <array>
-#include <string_view>
-
-namespace ada::checkers {
-
-ada_really_inline constexpr bool is_ipv4(std::string_view view) noexcept {
-  // The string is not empty and does not contain upper case ASCII characters.
-  //
-  // Optimization. To be considered as a possible ipv4, the string must end
-  // with 'x' or a lowercase hex character.
-  // Most of the time, this will be false so this simple check will save a lot
-  // of effort.
-  // If the address ends with a dot, we need to prune it (special case).
-  if (view.ends_with('.')) {
-    view.remove_suffix(1);
-    if (view.empty()) {
-      return false;
-    }
-  }
-  char last_char = view.back();
-  bool possible_ipv4 = (last_char >= '0' && last_char <= '9') ||
-                       (last_char >= 'a' && last_char <= 'f') ||
-                       last_char == 'x';
-  if (!possible_ipv4) {
-    return false;
-  }
-  // From the last character, find the last dot.
-  size_t last_dot = view.rfind('.');
-  if (last_dot != std::string_view::npos) {
-    // We have at least one dot.
-    view = view.substr(last_dot + 1);
-  }
-  /** Optimization opportunity: we have basically identified the last number of
-     the ipv4 if we return true here. We might as well parse it and have at
-     least one number parsed when we get to parse_ipv4. */
-  if (std::ranges::all_of(view, ada::checkers::is_digit)) {
-    return true;
-  }
-  // It could be hex (0x), but not if there is a single character.
-  if (view.size() == 1) {
-    return false;
-  }
-  // It must start with 0x.
-  if (!view.starts_with("0x")) {
-    return false;
-  }
-  // We must allow "0x".
-  if (view.size() == 2) {
-    return true;
-  }
-  // We have 0x followed by some characters, we need to check that they are
-  // hexadecimals.
-  return std::all_of(view.begin() + 2, view.end(),
-                     ada::unicode::is_lowercase_hex);
-}
-
-// for use with path_signature, we include all characters that need percent
-// encoding.
-static constexpr std::array<uint8_t, 256> path_signature_table =
-    []() consteval {
-      std::array<uint8_t, 256> result{};
-      for (size_t i = 0; i < 256; i++) {
-        if (i <= 0x20 || i == 0x22 || i == 0x23 || i == 0x3c || i == 0x3e ||
-            i == 0x3f || i == 0x60 || i == 0x7b || i == 0x7d || i > 0x7e) {
-          result[i] = 1;
-        } else if (i == 0x25) {
-          result[i] = 8;
-        } else if (i == 0x2e) {
-          result[i] = 4;
-        } else if (i == 0x5c) {
-          result[i] = 2;
-        } else {
-          result[i] = 0;
-        }
-      }
-      return result;
-    }();
-
-ada_really_inline constexpr uint8_t
-path_signature(std::string_view input) noexcept {
-  // The path percent-encode set is the query percent-encode set and U+003F (?),
-  // U+0060 (`), U+007B ({), and U+007D (}). The query percent-encode set is the
-  // C0 control percent-encode set and U+0020 SPACE, U+0022 ("), U+0023 (#),
-  // U+003C (<), and U+003E (>). The C0 control percent-encode set are the C0
-  // controls and all code points greater than U+007E (~).
-  size_t i = 0;
-  uint8_t accumulator{};
-  for (; i + 7 < input.size(); i += 8) {
-    accumulator |= uint8_t(path_signature_table[uint8_t(input[i])] |
-                           path_signature_table[uint8_t(input[i + 1])] |
-                           path_signature_table[uint8_t(input[i + 2])] |
-                           path_signature_table[uint8_t(input[i + 3])] |
-                           path_signature_table[uint8_t(input[i + 4])] |
-                           path_signature_table[uint8_t(input[i + 5])] |
-                           path_signature_table[uint8_t(input[i + 6])] |
-                           path_signature_table[uint8_t(input[i + 7])]);
-  }
-  for (; i < input.size(); i++) {
-    accumulator |= uint8_t(path_signature_table[uint8_t(input[i])]);
-  }
-  return accumulator;
-}
-
-ada_really_inline constexpr bool
-verify_dns_length(std::string_view input) noexcept {
-  if (input.back() == '.') {
-    if (input.size() > 254)
-      return false;
-  } else if (input.size() > 253)
-    return false;
-
-  size_t start = 0;
-  while (start < input.size()) {
-    auto dot_location = input.find('.', start);
-    // If not found, it's likely the end of the domain
-    if (dot_location == std::string_view::npos)
-      dot_location = input.size();
-
-    auto label_size = dot_location - start;
-    if (label_size > 63 || label_size == 0)
-      return false;
-
-    start = dot_location + 1;
-  }
-
-  return true;
-}
-} // namespace ada::checkers
-/* end file src/checkers.cpp */
-/* begin file src/unicode.cpp */
-
-ADA_PUSH_DISABLE_ALL_WARNINGS
-/* begin file src/ada_idna.cpp */
-/* auto-generated on 2024-12-18 09:44:34 -0500. Do not edit! */
-/* begin file src/idna.cpp */
-/* begin file src/unicode_transcoding.cpp */
-
-#include <algorithm>
-#include <cstdint>
-#include <cstring>
-
-namespace ada::idna {
-
-size_t utf8_to_utf32(const char *buf, size_t len, char32_t *utf32_output) {
-  const uint8_t *data = reinterpret_cast<const uint8_t *>(buf);
-  size_t pos = 0;
-  char32_t *start{utf32_output};
-  while (pos < len) {
-    // 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;
-      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) {
-        size_t final_pos = pos + 16;
-        while (pos < final_pos) {
-          *utf32_output++ = char32_t(buf[pos]);
-          pos++;
-        }
-        continue;
-      }
-    }
-    uint8_t leading_byte = 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 | (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 ((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;
-      }
-      *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 ((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;
-      }
-      *utf32_output++ = char32_t(code_point);
-      pos += 4;
-    } else {
-      return 0;
-    }
-  }
-  return utf32_output - start;
-}
-
-size_t utf8_length_from_utf32(const char32_t *buf, size_t len) {
-  // We are not BOM aware.
-  const uint32_t *p = reinterpret_cast<const uint32_t *>(buf);
-  size_t counter{0};
-  for (size_t i = 0; i != len; ++i) {
-    ++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;
-}
-
-size_t utf32_length_from_utf8(const char *buf, size_t len) {
-  const int8_t *p = reinterpret_cast<const int8_t *>(buf);
-  return std::count_if(p, std::next(p, len), [](int8_t c) {
-    // -65 is 0b10111111, anything larger in two-complement's
-    // should start a new code point.
-    return c > -65;
-  });
-}
-
-size_t utf32_to_utf8(const char32_t *buf, size_t len, char *utf8_output) {
-  const uint32_t *data = reinterpret_cast<const uint32_t *>(buf);
-  size_t pos = 0;
-  char *start{utf8_output};
-  while (pos < len) {
-    // 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;
-      std::memcpy(&v, data + pos, sizeof(uint64_t));
-      if ((v & 0xFFFFFF80FFFFFF80) == 0) {
-        *utf8_output++ = char(buf[pos]);
-        *utf8_output++ = char(buf[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;
-}
-} // namespace ada::idna
-/* end file src/unicode_transcoding.cpp */
-/* begin file src/mapping.cpp */
-
-#include <algorithm>
-#include <array>
-#include <string>
-
-/* begin file src/mapping_tables.cpp */
-// IDNA  15.1.0
-
-// clang-format off
-#ifndef ADA_IDNA_TABLES_H
-#define ADA_IDNA_TABLES_H
-#include <cstdint>
-
-namespace ada::idna {
-
-const uint32_t mappings[5165] =
-{
-	97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
-	114, 115, 116, 117, 118, 119, 120, 121, 122, 32, 32, 776, 32, 772, 50, 51, 32, 769,
-	956, 32, 807, 49, 49, 8260, 52, 49, 8260, 50, 51, 8260, 52, 224, 225, 226, 227,
-	228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243,
-	244, 245, 246, 248, 249, 250, 251, 252, 253, 254, 257, 259, 261, 263, 265, 267,
-	269, 271, 273, 275, 277, 279, 281, 283, 285, 287, 289, 291, 293, 295, 297, 299,
-	301, 303, 105, 775, 309, 311, 314, 316, 318, 108, 183, 322, 324, 326, 328, 700,
-	110, 331, 333, 335, 337, 339, 341, 343, 345, 347, 349, 351, 353, 355, 357, 359,
-	361, 363, 365, 367, 369, 371, 373, 375, 255, 378, 380, 382, 595, 387, 389, 596,
-	392, 598, 599, 396, 477, 601, 603, 402, 608, 611, 617, 616, 409, 623, 626, 629,
-	417, 419, 421, 640, 424, 643, 429, 648, 432, 650, 651, 436, 438, 658, 441, 445,
-	100, 382, 108, 106, 110, 106, 462, 464, 466, 468, 470, 472, 474, 476, 479, 481,
-	483, 485, 487, 489, 491, 493, 495, 100, 122, 501, 405, 447, 505, 507, 509, 511,
-	513, 515, 517, 519, 521, 523, 525, 527, 529, 531, 533, 535, 537, 539, 541, 543,
-	414, 547, 549, 551, 553, 555, 557, 559, 561, 563, 11365, 572, 410, 11366, 578, 384,
-	649, 652, 583, 585, 587, 589, 591, 614, 633, 635, 641, 32, 774, 32, 775, 32, 778,
-	32, 808, 32, 771, 32, 779, 661, 768, 787, 776, 769, 953, 881, 883, 697, 887, 32,
-	953, 59, 1011, 32, 776, 769, 940, 941, 942, 943, 972, 973, 974, 945, 946, 947, 948,
-	949, 950, 951, 952, 954, 955, 957, 958, 959, 960, 961, 963, 964, 965, 966, 967,
-	968, 969, 970, 971, 983, 985, 987, 989, 991, 993, 995, 997, 999, 1001, 1003, 1005,
-	1007, 1016, 1019, 891, 892, 893, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111,
-	1112, 1113, 1114, 1115, 1116, 1117, 1118, 1119, 1072, 1073, 1074, 1075, 1076, 1077,
-	1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091,
-	1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, 1121, 1123,
-	1125, 1127, 1129, 1131, 1133, 1135, 1137, 1139, 1141, 1143, 1145, 1147, 1149, 1151,
-	1153, 1163, 1165, 1167, 1169, 1171, 1173, 1175, 1177, 1179, 1181, 1183, 1185, 1187,
-	1189, 1191, 1193, 1195, 1197, 1199, 1201, 1203, 1205, 1207, 1209, 1211, 1213, 1215,
-	1218, 1220, 1222, 1224, 1226, 1228, 1230, 1233, 1235, 1237, 1239, 1241, 1243, 1245,
-	1247, 1249, 1251, 1253, 1255, 1257, 1259, 1261, 1263, 1265, 1267, 1269, 1271, 1273,
-	1275, 1277, 1279, 1281, 1283, 1285, 1287, 1289, 1291, 1293, 1295, 1297, 1299, 1301,
-	1303, 1305, 1307, 1309, 1311, 1313, 1315, 1317, 1319, 1321, 1323, 1325, 1327, 1377,
-	1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385, 1386, 1387, 1388, 1389, 1390, 1391,
-	1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401, 1402, 1403, 1404, 1405,
-	1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 1381, 1410, 1575, 1652, 1608,
-	1652, 1735, 1652, 1610, 1652, 2325, 2364, 2326, 2364, 2327, 2364, 2332, 2364, 2337,
-	2364, 2338, 2364, 2347, 2364, 2351, 2364, 2465, 2492, 2466, 2492, 2479, 2492, 2610,
-	2620, 2616, 2620, 2582, 2620, 2583, 2620, 2588, 2620, 2603, 2620, 2849, 2876, 2850,
-	2876, 3661, 3634, 3789, 3762, 3755, 3737, 3755, 3745, 3851, 3906, 4023, 3916, 4023,
-	3921, 4023, 3926, 4023, 3931, 4023, 3904, 4021, 3953, 3954, 3953, 3956, 4018, 3968,
-	4018, 3953, 3968, 4019, 3968, 4019, 3953, 3968, 3986, 4023, 3996, 4023, 4001, 4023,
-	4006, 4023, 4011, 4023, 3984, 4021, 11559, 11565, 4316, 5104, 5105, 5106, 5107,
-	5108, 5109, 42571, 4304, 4305, 4306, 4307, 4308, 4309, 4310, 4311, 4312, 4313, 4314,
-	4315, 4317, 4318, 4319, 4320, 4321, 4322, 4323, 4324, 4325, 4326, 4327, 4328, 4329,
-	4330, 4331, 4332, 4333, 4334, 4335, 4336, 4337, 4338, 4339, 4340, 4341, 4342, 4343,
-	4344, 4345, 4346, 4349, 4350, 4351, 592, 593, 7426, 604, 7446, 7447, 7453, 7461,
-	594, 597, 607, 609, 613, 618, 7547, 669, 621, 7557, 671, 625, 624, 627, 628, 632,
-	642, 427, 7452, 656, 657, 7681, 7683, 7685, 7687, 7689, 7691, 7693, 7695, 7697,
-	7699, 7701, 7703, 7705, 7707, 7709, 7711, 7713, 7715, 7717, 7719, 7721, 7723, 7725,
-	7727, 7729, 7731, 7733, 7735, 7737, 7739, 7741, 7743, 7745, 7747, 7749, 7751, 7753,
-	7755, 7757, 7759, 7761, 7763, 7765, 7767, 7769, 7771, 7773, 7775, 7777, 7779, 7781,
-	7783, 7785, 7787, 7789, 7791, 7793, 7795, 7797, 7799, 7801, 7803, 7805, 7807, 7809,
-	7811, 7813, 7815, 7817, 7819, 7821, 7823, 7825, 7827, 7829, 97, 702, 223, 7841,
-	7843, 7845, 7847, 7849, 7851, 7853, 7855, 7857, 7859, 7861, 7863, 7865, 7867, 7869,
-	7871, 7873, 7875, 7877, 7879, 7881, 7883, 7885, 7887, 7889, 7891, 7893, 7895, 7897,
-	7899, 7901, 7903, 7905, 7907, 7909, 7911, 7913, 7915, 7917, 7919, 7921, 7923, 7925,
-	7927, 7929, 7931, 7933, 7935, 7936, 7937, 7938, 7939, 7940, 7941, 7942, 7943, 7952,
-	7953, 7954, 7955, 7956, 7957, 7968, 7969, 7970, 7971, 7972, 7973, 7974, 7975, 7984,
-	7985, 7986, 7987, 7988, 7989, 7990, 7991, 8000, 8001, 8002, 8003, 8004, 8005, 8017,
-	8019, 8021, 8023, 8032, 8033, 8034, 8035, 8036, 8037, 8038, 8039, 7936, 953, 7937,
-	953, 7938, 953, 7939, 953, 7940, 953, 7941, 953, 7942, 953, 7943, 953, 7968, 953,
-	7969, 953, 7970, 953, 7971, 953, 7972, 953, 7973, 953, 7974, 953, 7975, 953, 8032,
-	953, 8033, 953, 8034, 953, 8035, 953, 8036, 953, 8037, 953, 8038, 953, 8039, 953,
-	8048, 953, 945, 953, 940, 953, 8118, 953, 8112, 8113, 32, 787, 32, 834, 32, 776,
-	834, 8052, 953, 951, 953, 942, 953, 8134, 953, 8050, 32, 787, 768, 32, 787, 769,
-	32, 787, 834, 912, 8144, 8145, 8054, 32, 788, 768, 32, 788, 769, 32, 788, 834, 944,
-	8160, 8161, 8058, 8165, 32, 776, 768, 96, 8060, 953, 969, 953, 974, 953, 8182, 953,
-	8056, 8208, 32, 819, 8242, 8242, 8242, 8242, 8242, 8245, 8245, 8245, 8245, 8245,
-	33, 33, 32, 773, 63, 63, 63, 33, 33, 63, 48, 53, 54, 55, 56, 57, 43, 8722, 61, 40,
-	41, 97, 47, 99, 97, 47, 115, 176, 99, 99, 47, 111, 99, 47, 117, 176, 102, 115, 109,
-	116, 101, 108, 116, 109, 1488, 1489, 1490, 1491, 102, 97, 120, 8721, 49, 8260, 55,
-	49, 8260, 57, 49, 8260, 49, 48, 49, 8260, 51, 50, 8260, 51, 49, 8260, 53, 50, 8260,
-	53, 51, 8260, 53, 52, 8260, 53, 49, 8260, 54, 53, 8260, 54, 49, 8260, 56, 51, 8260,
-	56, 53, 8260, 56, 55, 8260, 56, 105, 105, 105, 105, 105, 105, 118, 118, 105, 118,
-	105, 105, 118, 105, 105, 105, 105, 120, 120, 105, 120, 105, 105, 48, 8260, 51, 8747,
-	8747, 8747, 8747, 8747, 8750, 8750, 8750, 8750, 8750, 12296, 12297, 49, 50, 49,
-	51, 49, 52, 49, 53, 49, 54, 49, 55, 49, 56, 49, 57, 50, 48, 40, 49, 41, 40, 50,
-	41, 40, 51, 41, 40, 52, 41, 40, 53, 41, 40, 54, 41, 40, 55, 41, 40, 56, 41, 40,
-	57, 41, 40, 49, 48, 41, 40, 49, 49, 41, 40, 49, 50, 41, 40, 49, 51, 41, 40, 49,
-	52, 41, 40, 49, 53, 41, 40, 49, 54, 41, 40, 49, 55, 41, 40, 49, 56, 41, 40, 49,
-	57, 41, 40, 50, 48, 41, 40, 97, 41, 40, 98, 41, 40, 99, 41, 40, 100, 41, 40, 101,
-	41, 40, 102, 41, 40, 103, 41, 40, 104, 41, 40, 105, 41, 40, 106, 41, 40, 107, 41,
-	40, 108, 41, 40, 109, 41, 40, 110, 41, 40, 111, 41, 40, 112, 41, 40, 113, 41, 40,
-	114, 41, 40, 115, 41, 40, 116, 41, 40, 117, 41, 40, 118, 41, 40, 119, 41, 40, 120,
-	41, 40, 121, 41, 40, 122, 41, 58, 58, 61, 61, 61, 10973, 824, 11312, 11313, 11314,
-	11315, 11316, 11317, 11318, 11319, 11320, 11321, 11322, 11323, 11324, 11325, 11326,
-	11327, 11328, 11329, 11330, 11331, 11332, 11333, 11334, 11335, 11336, 11337, 11338,
-	11339, 11340, 11341, 11342, 11343, 11344, 11345, 11346, 11347, 11348, 11349, 11350,
-	11351, 11352, 11353, 11354, 11355, 11356, 11357, 11358, 11359, 11361, 619, 7549,
-	637, 11368, 11370, 11372, 11379, 11382, 575, 576, 11393, 11395, 11397, 11399, 11401,
-	11403, 11405, 11407, 11409, 11411, 11413, 11415, 11417, 11419, 11421, 11423, 11425,
-	11427, 11429, 11431, 11433, 11435, 11437, 11439, 11441, 11443, 11445, 11447, 11449,
-	11451, 11453, 11455, 11457, 11459, 11461, 11463, 11465, 11467, 11469, 11471, 11473,
-	11475, 11477, 11479, 11481, 11483, 11485, 11487, 11489, 11491, 11500, 11502, 11507,
-	11617, 27597, 40863, 19968, 20008, 20022, 20031, 20057, 20101, 20108, 20128, 20154,
-	20799, 20837, 20843, 20866, 20886, 20907, 20960, 20981, 20992, 21147, 21241, 21269,
-	21274, 21304, 21313, 21340, 21353, 21378, 21430, 21448, 21475, 22231, 22303, 22763,
-	22786, 22794, 22805, 22823, 22899, 23376, 23424, 23544, 23567, 23586, 23608, 23662,
-	23665, 24027, 24037, 24049, 24062, 24178, 24186, 24191, 24308, 24318, 24331, 24339,
-	24400, 24417, 24435, 24515, 25096, 25142, 25163, 25903, 25908, 25991, 26007, 26020,
-	26041, 26080, 26085, 26352, 26376, 26408, 27424, 27490, 27513, 27571, 27595, 27604,
-	27611, 27663, 27668, 27700, 28779, 29226, 29238, 29243, 29247, 29255, 29273, 29275,
-	29356, 29572, 29577, 29916, 29926, 29976, 29983, 29992, 30000, 30091, 30098, 30326,
-	30333, 30382, 30399, 30446, 30683, 30690, 30707, 31034, 31160, 31166, 31348, 31435,
-	31481, 31859, 31992, 32566, 32593, 32650, 32701, 32769, 32780, 32786, 32819, 32895,
-	32905, 33251, 33258, 33267, 33276, 33292, 33307, 33311, 33390, 33394, 33400, 34381,
-	34411, 34880, 34892, 34915, 35198, 35211, 35282, 35328, 35895, 35910, 35925, 35960,
-	35997, 36196, 36208, 36275, 36523, 36554, 36763, 36784, 36789, 37009, 37193, 37318,
-	37324, 37329, 38263, 38272, 38428, 38582, 38585, 38632, 38737, 38750, 38754, 38761,
-	38859, 38893, 38899, 38913, 39080, 39131, 39135, 39318, 39321, 39340, 39592, 39640,
-	39647, 39717, 39727, 39730, 39740, 39770, 40165, 40565, 40575, 40613, 40635, 40643,
-	40653, 40657, 40697, 40701, 40718, 40723, 40736, 40763, 40778, 40786, 40845, 40860,
-	40864, 46, 12306, 21316, 21317, 32, 12441, 32, 12442, 12424, 12426, 12467, 12488,
-	4352, 4353, 4522, 4354, 4524, 4525, 4355, 4356, 4357, 4528, 4529, 4530, 4531, 4532,
-	4533, 4378, 4358, 4359, 4360, 4385, 4361, 4362, 4363, 4364, 4365, 4366, 4367, 4368,
-	4369, 4370, 4449, 4450, 4451, 4452, 4453, 4454, 4455, 4456, 4457, 4458, 4459, 4460,
-	4461, 4462, 4463, 4464, 4465, 4466, 4467, 4468, 4469, 4372, 4373, 4551, 4552, 4556,
-	4558, 4563, 4567, 4569, 4380, 4573, 4575, 4381, 4382, 4384, 4386, 4387, 4391, 4393,
-	4395, 4396, 4397, 4398, 4399, 4402, 4406, 4416, 4423, 4428, 4593, 4594, 4439, 4440,
-	4441, 4484, 4485, 4488, 4497, 4498, 4500, 4510, 4513, 19977, 22235, 19978, 20013,
-	19979, 30002, 19993, 19969, 22825, 22320, 40, 4352, 41, 40, 4354, 41, 40, 4355,
-	41, 40, 4357, 41, 40, 4358, 41, 40, 4359, 41, 40, 4361, 41, 40, 4363, 41, 40, 4364,
-	41, 40, 4366, 41, 40, 4367, 41, 40, 4368, 41, 40, 4369, 41, 40, 4370, 41, 40, 44032,
-	41, 40, 45208, 41, 40, 45796, 41, 40, 46972, 41, 40, 47560, 41, 40, 48148, 41, 40,
-	49324, 41, 40, 50500, 41, 40, 51088, 41, 40, 52264, 41, 40, 52852, 41, 40, 53440,
-	41, 40, 54028, 41, 40, 54616, 41, 40, 51452, 41, 40, 50724, 51204, 41, 40, 50724,
-	54980, 41, 40, 19968, 41, 40, 20108, 41, 40, 19977, 41, 40, 22235, 41, 40, 20116,
-	41, 40, 20845, 41, 40, 19971, 41, 40, 20843, 41, 40, 20061, 41, 40, 21313, 41, 40,
-	26376, 41, 40, 28779, 41, 40, 27700, 41, 40, 26408, 41, 40, 37329, 41, 40, 22303,
-	41, 40, 26085, 41, 40, 26666, 41, 40, 26377, 41, 40, 31038, 41, 40, 21517, 41, 40,
-	29305, 41, 40, 36001, 41, 40, 31069, 41, 40, 21172, 41, 40, 20195, 41, 40, 21628,
-	41, 40, 23398, 41, 40, 30435, 41, 40, 20225, 41, 40, 36039, 41, 40, 21332, 41, 40,
-	31085, 41, 40, 20241, 41, 40, 33258, 41, 40, 33267, 41, 21839, 24188, 31631, 112,
-	116, 101, 50, 50, 50, 52, 50, 53, 50, 54, 50, 55, 50, 56, 50, 57, 51, 48, 51, 51,
-	51, 52, 51, 53, 52280, 44256, 51452, 51032, 50864, 31192, 30007, 36969, 20778, 21360,
-	27880, 38917, 20889, 27491, 24038, 21491, 21307, 23447, 22812, 51, 54, 51, 55, 51,
-	56, 51, 57, 52, 48, 52, 52, 52, 53, 52, 54, 52, 55, 52, 56, 52, 57, 53, 48, 49,
-	26376, 50, 26376, 51, 26376, 52, 26376, 53, 26376, 54, 26376, 55, 26376, 56, 26376,
-	57, 26376, 49, 48, 26376, 49, 49, 26376, 49, 50, 26376, 104, 103, 101, 114, 103,
-	101, 118, 108, 116, 100, 12450, 12452, 12454, 12456, 12458, 12459, 12461, 12463,
-	12465, 12469, 12471, 12473, 12475, 12477, 12479, 12481, 12484, 12486, 12490, 12491,
-	12492, 12493, 12494, 12495, 12498, 12501, 12504, 12507, 12510, 12511, 12512, 12513,
-	12514, 12516, 12518, 12520, 12521, 12522, 12523, 12524, 12525, 12527, 12528, 12529,
-	12530, 20196, 21644, 12450, 12497, 12540, 12488, 12450, 12523, 12501, 12449, 12450,
-	12531, 12506, 12450, 12450, 12540, 12523, 12452, 12491, 12531, 12464, 12452, 12531,
-	12481, 12454, 12457, 12531, 12456, 12473, 12463, 12540, 12489, 12456, 12540, 12459,
-	12540, 12458, 12531, 12473, 12458, 12540, 12512, 12459, 12452, 12522, 12459, 12521,
-	12483, 12488, 12459, 12525, 12522, 12540, 12460, 12525, 12531, 12460, 12531, 12510,
-	12462, 12460, 12462, 12491, 12540, 12461, 12517, 12522, 12540, 12462, 12523, 12480,
-	12540, 12461, 12525, 12461, 12525, 12464, 12521, 12512, 12461, 12525, 12513, 12540,
-	12488, 12523, 12461, 12525, 12527, 12483, 12488, 12464, 12521, 12512, 12488, 12531,
-	12463, 12523, 12476, 12452, 12525, 12463, 12525, 12540, 12493, 12465, 12540, 12473,
-	12467, 12523, 12490, 12467, 12540, 12509, 12469, 12452, 12463, 12523, 12469, 12531,
-	12481, 12540, 12512, 12471, 12522, 12531, 12464, 12475, 12531, 12481, 12475, 12531,
-	12488, 12480, 12540, 12473, 12487, 12471, 12489, 12523, 12490, 12494, 12494, 12483,
-	12488, 12495, 12452, 12484, 12497, 12540, 12475, 12531, 12488, 12497, 12540, 12484,
-	12496, 12540, 12524, 12523, 12500, 12450, 12473, 12488, 12523, 12500, 12463, 12523,
-	12500, 12467, 12499, 12523, 12501, 12449, 12521, 12483, 12489, 12501, 12451, 12540,
-	12488, 12502, 12483, 12471, 12455, 12523, 12501, 12521, 12531, 12504, 12463, 12479,
-	12540, 12523, 12506, 12477, 12506, 12491, 12498, 12504, 12523, 12484, 12506, 12531,
-	12473, 12506, 12540, 12472, 12505, 12540, 12479, 12509, 12452, 12531, 12488, 12508,
-	12523, 12488, 12507, 12531, 12509, 12531, 12489, 12507, 12540, 12523, 12507, 12540,
-	12531, 12510, 12452, 12463, 12525, 12510, 12452, 12523, 12510, 12483, 12495, 12510,
-	12523, 12463, 12510, 12531, 12471, 12519, 12531, 12511, 12463, 12525, 12531, 12511,
-	12522, 12511, 12522, 12496, 12540, 12523, 12513, 12460, 12513, 12460, 12488, 12531,
-	12516, 12540, 12489, 12516, 12540, 12523, 12518, 12450, 12531, 12522, 12483, 12488,
-	12523, 12522, 12521, 12523, 12500, 12540, 12523, 12540, 12502, 12523, 12524, 12512,
-	12524, 12531, 12488, 12466, 12531, 48, 28857, 49, 28857, 50, 28857, 51, 28857, 52,
-	28857, 53, 28857, 54, 28857, 55, 28857, 56, 28857, 57, 28857, 49, 48, 28857, 49,
-	49, 28857, 49, 50, 28857, 49, 51, 28857, 49, 52, 28857, 49, 53, 28857, 49, 54, 28857,
-	49, 55, 28857, 49, 56, 28857, 49, 57, 28857, 50, 48, 28857, 50, 49, 28857, 50, 50,
-	28857, 50, 51, 28857, 50, 52, 28857, 104, 112, 97, 100, 97, 97, 117, 98, 97, 114,
-	111, 118, 112, 99, 100, 109, 100, 109, 50, 100, 109, 51, 105, 117, 24179, 25104,
-	26157, 21644, 22823, 27491, 26126, 27835, 26666, 24335, 20250, 31038, 110, 97, 956,
-	97, 109, 97, 107, 97, 107, 98, 109, 98, 103, 98, 99, 97, 108, 107, 99, 97, 108,
-	112, 102, 110, 102, 956, 102, 956, 103, 109, 103, 107, 103, 104, 122, 107, 104,
-	122, 109, 104, 122, 116, 104, 122, 956, 108, 109, 108, 100, 108, 102, 109, 110,
-	109, 956, 109, 109, 109, 99, 109, 107, 109, 109, 109, 50, 99, 109, 50, 107, 109,
-	50, 109, 109, 51, 99, 109, 51, 107, 109, 51, 109, 8725, 115, 109, 8725, 115, 50,
-	107, 112, 97, 109, 112, 97, 103, 112, 97, 114, 97, 100, 114, 97, 100, 8725, 115,
-	114, 97, 100, 8725, 115, 50, 112, 115, 110, 115, 956, 115, 109, 115, 112, 118, 110,
-	118, 956, 118, 109, 118, 107, 118, 112, 119, 110, 119, 956, 119, 109, 119, 107,
-	119, 107, 969, 109, 969, 98, 113, 99, 8725, 107, 103, 100, 98, 103, 121, 104, 97,
-	105, 110, 107, 107, 107, 116, 108, 110, 108, 111, 103, 108, 120, 109, 105, 108,
-	109, 111, 108, 112, 104, 112, 112, 109, 112, 114, 115, 118, 119, 98, 118, 8725,
-	109, 97, 8725, 109, 49, 26085, 50, 26085, 51, 26085, 52, 26085, 53, 26085, 54, 26085,
-	55, 26085, 56, 26085, 57, 26085, 49, 48, 26085, 49, 49, 26085, 49, 50, 26085, 49,
-	51, 26085, 49, 52, 26085, 49, 53, 26085, 49, 54, 26085, 49, 55, 26085, 49, 56, 26085,
-	49, 57, 26085, 50, 48, 26085, 50, 49, 26085, 50, 50, 26085, 50, 51, 26085, 50, 52,
-	26085, 50, 53, 26085, 50, 54, 26085, 50, 55, 26085, 50, 56, 26085, 50, 57, 26085,
-	51, 48, 26085, 51, 49, 26085, 103, 97, 108, 42561, 42563, 42565, 42567, 42569, 42573,
-	42575, 42577, 42579, 42581, 42583, 42585, 42587, 42589, 42591, 42593, 42595, 42597,
-	42599, 42601, 42603, 42605, 42625, 42627, 42629, 42631, 42633, 42635, 42637, 42639,
-	42641, 42643, 42645, 42647, 42649, 42651, 42787, 42789, 42791, 42793, 42795, 42797,
-	42799, 42803, 42805, 42807, 42809, 42811, 42813, 42815, 42817, 42819, 42821, 42823,
-	42825, 42827, 42829, 42831, 42833, 42835, 42837, 42839, 42841, 42843, 42845, 42847,
-	42849, 42851, 42853, 42855, 42857, 42859, 42861, 42863, 42874, 42876, 7545, 42879,
-	42881, 42883, 42885, 42887, 42892, 42897, 42899, 42903, 42905, 42907, 42909, 42911,
-	42913, 42915, 42917, 42919, 42921, 620, 670, 647, 43859, 42933, 42935, 42937, 42939,
-	42941, 42943, 42945, 42947, 42900, 7566, 42952, 42954, 42961, 42967, 42969, 42998,
-	43831, 43858, 653, 5024, 5025, 5026, 5027, 5028, 5029, 5030, 5031, 5032, 5033, 5034,
-	5035, 5036, 5037, 5038, 5039, 5040, 5041, 5042, 5043, 5044, 5045, 5046, 5047, 5048,
-	5049, 5050, 5051, 5052, 5053, 5054, 5055, 5056, 5057, 5058, 5059, 5060, 5061, 5062,
-	5063, 5064, 5065, 5066, 5067, 5068, 5069, 5070, 5071, 5072, 5073, 5074, 5075, 5076,
-	5077, 5078, 5079, 5080, 5081, 5082, 5083, 5084, 5085, 5086, 5087, 5088, 5089, 5090,
-	5091, 5092, 5093, 5094, 5095, 5096, 5097, 5098, 5099, 5100, 5101, 5102, 5103, 35912,
-	26356, 36040, 28369, 20018, 21477, 22865, 21895, 22856, 25078, 30313, 32645, 34367,
-	34746, 35064, 37007, 27138, 27931, 28889, 29662, 33853, 37226, 39409, 20098, 21365,
-	27396, 29211, 34349, 40478, 23888, 28651, 34253, 35172, 25289, 33240, 34847, 24266,
-	26391, 28010, 29436, 37070, 20358, 20919, 21214, 25796, 27347, 29200, 30439, 34310,
-	34396, 36335, 38706, 39791, 40442, 30860, 31103, 32160, 33737, 37636, 35542, 22751,
-	24324, 31840, 32894, 29282, 30922, 36034, 38647, 22744, 23650, 27155, 28122, 28431,
-	32047, 32311, 38475, 21202, 32907, 20956, 20940, 31260, 32190, 33777, 38517, 35712,
-	25295, 35582, 20025, 23527, 24594, 29575, 30064, 21271, 30971, 20415, 24489, 19981,
-	27852, 25976, 32034, 21443, 22622, 30465, 33865, 35498, 27578, 27784, 25342, 33509,
-	25504, 30053, 20142, 20841, 20937, 26753, 31975, 33391, 35538, 37327, 21237, 21570,
-	24300, 26053, 28670, 31018, 38317, 39530, 40599, 40654, 26310, 27511, 36706, 24180,
-	24976, 25088, 25754, 28451, 29001, 29833, 31178, 32244, 32879, 36646, 34030, 36899,
-	37706, 21015, 21155, 21693, 28872, 35010, 24265, 24565, 25467, 27566, 31806, 29557,
-	22265, 23994, 24604, 29618, 29801, 32666, 32838, 37428, 38646, 38728, 38936, 20363,
-	31150, 37300, 38584, 24801, 20102, 20698, 23534, 23615, 26009, 29134, 30274, 34044,
-	36988, 26248, 38446, 21129, 26491, 26611, 27969, 28316, 29705, 30041, 30827, 32016,
-	39006, 25134, 38520, 20523, 23833, 28138, 36650, 24459, 24900, 26647, 38534, 21033,
-	21519, 23653, 26131, 26446, 26792, 27877, 29702, 30178, 32633, 35023, 35041, 38626,
-	21311, 28346, 21533, 29136, 29848, 34298, 38563, 40023, 40607, 26519, 28107, 33256,
-	31520, 31890, 29376, 28825, 35672, 20160, 33590, 21050, 20999, 24230, 25299, 31958,
-	23429, 27934, 26292, 36667, 38477, 24275, 20800, 21952, 22618, 26228, 20958, 29482,
-	30410, 31036, 31070, 31077, 31119, 38742, 31934, 34322, 35576, 36920, 37117, 39151,
-	39164, 39208, 40372, 37086, 38583, 20398, 20711, 20813, 21193, 21220, 21329, 21917,
-	22022, 22120, 22592, 22696, 23652, 24724, 24936, 24974, 25074, 25935, 26082, 26257,
-	26757, 28023, 28186, 28450, 29038, 29227, 29730, 30865, 31049, 31048, 31056, 31062,
-	31117, 31118, 31296, 31361, 31680, 32265, 32321, 32626, 32773, 33261, 33401, 33879,
-	35088, 35222, 35585, 35641, 36051, 36104, 36790, 38627, 38911, 38971, 24693, 148206,
-	33304, 20006, 20917, 20840, 20352, 20805, 20864, 21191, 21242, 21845, 21913, 21986,
-	22707, 22852, 22868, 23138, 23336, 24274, 24281, 24425, 24493, 24792, 24910, 24840,
-	24928, 25140, 25540, 25628, 25682, 25942, 26395, 26454, 28379, 28363, 28702, 30631,
-	29237, 29359, 29809, 29958, 30011, 30237, 30239, 30427, 30452, 30538, 30528, 30924,
-	31409, 31867, 32091, 32574, 33618, 33775, 34681, 35137, 35206, 35519, 35531, 35565,
-	35722, 36664, 36978, 37273, 37494, 38524, 38875, 38923, 39698, 141386, 141380, 144341,
-	15261, 16408, 16441, 152137, 154832, 163539, 40771, 40846, 102, 102, 102, 105, 102,
-	108, 102, 102, 108, 1396, 1398, 1396, 1381, 1396, 1387, 1406, 1398, 1396, 1389,
-	1497, 1460, 1522, 1463, 1506, 1492, 1499, 1500, 1501, 1512, 1514, 1513, 1473, 1513,
-	1474, 1513, 1468, 1473, 1513, 1468, 1474, 1488, 1463, 1488, 1464, 1488, 1468, 1489,
-	1468, 1490, 1468, 1491, 1468, 1492, 1468, 1493, 1468, 1494, 1468, 1496, 1468, 1497,
-	1468, 1498, 1468, 1499, 1468, 1500, 1468, 1502, 1468, 1504, 1468, 1505, 1468, 1507,
-	1468, 1508, 1468, 1510, 1468, 1511, 1468, 1512, 1468, 1514, 1468, 1493, 1465, 1489,
-	1471, 1499, 1471, 1508, 1471, 1488, 1500, 1649, 1659, 1662, 1664, 1658, 1663, 1657,
-	1700, 1702, 1668, 1667, 1670, 1671, 1677, 1676, 1678, 1672, 1688, 1681, 1705, 1711,
-	1715, 1713, 1722, 1723, 1728, 1729, 1726, 1746, 1747, 1709, 1734, 1736, 1739, 1733,
-	1737, 1744, 1609, 1574, 1575, 1574, 1749, 1574, 1608, 1574, 1735, 1574, 1734, 1574,
-	1736, 1574, 1744, 1574, 1609, 1740, 1574, 1580, 1574, 1581, 1574, 1605, 1574, 1610,
-	1576, 1580, 1576, 1581, 1576, 1582, 1576, 1605, 1576, 1609, 1576, 1610, 1578, 1580,
-	1578, 1581, 1578, 1582, 1578, 1605, 1578, 1609, 1578, 1610, 1579, 1580, 1579, 1605,
-	1579, 1609, 1579, 1610, 1580, 1581, 1580, 1605, 1581, 1605, 1582, 1580, 1582, 1581,
-	1582, 1605, 1587, 1580, 1587, 1581, 1587, 1582, 1587, 1605, 1589, 1581, 1589, 1605,
-	1590, 1580, 1590, 1581, 1590, 1582, 1590, 1605, 1591, 1581, 1591, 1605, 1592, 1605,
-	1593, 1580, 1593, 1605, 1594, 1580, 1594, 1605, 1601, 1580, 1601, 1581, 1601, 1582,
-	1601, 1605, 1601, 1609, 1601, 1610, 1602, 1581, 1602, 1605, 1602, 1609, 1602, 1610,
-	1603, 1575, 1603, 1580, 1603, 1581, 1603, 1582, 1603, 1604, 1603, 1605, 1603, 1609,
-	1603, 1610, 1604, 1580, 1604, 1581, 1604, 1582, 1604, 1605, 1604, 1609, 1604, 1610,
-	1605, 1580, 1605, 1605, 1605, 1609, 1605, 1610, 1606, 1580, 1606, 1581, 1606, 1582,
-	1606, 1605, 1606, 1609, 1606, 1610, 1607, 1580, 1607, 1605, 1607, 1609, 1607, 1610,
-	1610, 1581, 1610, 1582, 1610, 1609, 1584, 1648, 1585, 1648, 1609, 1648, 32, 1612,
-	1617, 32, 1613, 1617, 32, 1614, 1617, 32, 1615, 1617, 32, 1616, 1617, 32, 1617,
-	1648, 1574, 1585, 1574, 1586, 1574, 1606, 1576, 1585, 1576, 1586, 1576, 1606, 1578,
-	1585, 1578, 1586, 1578, 1606, 1579, 1585, 1579, 1586, 1579, 1606, 1605, 1575, 1606,
-	1585, 1606, 1586, 1606, 1606, 1610, 1585, 1610, 1586, 1574, 1582, 1574, 1607, 1576,
-	1607, 1578, 1607, 1589, 1582, 1604, 1607, 1606, 1607, 1607, 1648, 1579, 1607, 1587,
-	1607, 1588, 1605, 1588, 1607, 1600, 1614, 1617, 1600, 1615, 1617, 1600, 1616, 1617,
-	1591, 1609, 1591, 1610, 1593, 1609, 1593, 1610, 1594, 1609, 1594, 1610, 1587, 1609,
-	1587, 1610, 1588, 1609, 1588, 1610, 1581, 1609, 1580, 1609, 1580, 1610, 1582, 1609,
-	1589, 1609, 1589, 1610, 1590, 1609, 1590, 1610, 1588, 1580, 1588, 1581, 1588, 1582,
-	1588, 1585, 1587, 1585, 1589, 1585, 1590, 1585, 1575, 1611, 1578, 1580, 1605, 1578,
-	1581, 1580, 1578, 1581, 1605, 1578, 1582, 1605, 1578, 1605, 1580, 1578, 1605, 1581,
-	1578, 1605, 1582, 1581, 1605, 1610, 1581, 1605, 1609, 1587, 1581, 1580, 1587, 1580,
-	1581, 1587, 1580, 1609, 1587, 1605, 1581, 1587, 1605, 1580, 1587, 1605, 1605, 1589,
-	1581, 1581, 1589, 1605, 1605, 1588, 1581, 1605, 1588, 1580, 1610, 1588, 1605, 1582,
-	1588, 1605, 1605, 1590, 1581, 1609, 1590, 1582, 1605, 1591, 1605, 1581, 1591, 1605,
-	1605, 1591, 1605, 1610, 1593, 1580, 1605, 1593, 1605, 1605, 1593, 1605, 1609, 1594,
-	1605, 1605, 1594, 1605, 1610, 1594, 1605, 1609, 1601, 1582, 1605, 1602, 1605, 1581,
-	1602, 1605, 1605, 1604, 1581, 1605, 1604, 1581, 1610, 1604, 1581, 1609, 1604, 1580,
-	1580, 1604, 1582, 1605, 1604, 1605, 1581, 1605, 1581, 1580, 1605, 1581, 1610, 1605,
-	1580, 1581, 1605, 1582, 1605, 1605, 1580, 1582, 1607, 1605, 1580, 1607, 1605, 1605,
-	1606, 1581, 1605, 1606, 1581, 1609, 1606, 1580, 1605, 1606, 1580, 1609, 1606, 1605,
-	1610, 1606, 1605, 1609, 1610, 1605, 1605, 1576, 1582, 1610, 1578, 1580, 1610, 1578,
-	1580, 1609, 1578, 1582, 1610, 1578, 1582, 1609, 1578, 1605, 1610, 1578, 1605, 1609,
-	1580, 1605, 1610, 1580, 1581, 1609, 1580, 1605, 1609, 1587, 1582, 1609, 1589, 1581,
-	1610, 1588, 1581, 1610, 1590, 1581, 1610, 1604, 1580, 1610, 1604, 1605, 1610, 1610,
-	1580, 1610, 1610, 1605, 1610, 1605, 1605, 1610, 1602, 1605, 1610, 1606, 1581, 1610,
-	1593, 1605, 1610, 1603, 1605, 1610, 1606, 1580, 1581, 1605, 1582, 1610, 1604, 1580,
-	1605, 1603, 1605, 1605, 1580, 1581, 1610, 1581, 1580, 1610, 1605, 1580, 1610, 1601,
-	1605, 1610, 1576, 1581, 1610, 1587, 1582, 1610, 1606, 1580, 1610, 1589, 1604, 1746,
-	1602, 1604, 1746, 1575, 1604, 1604, 1607, 1575, 1603, 1576, 1585, 1605, 1581, 1605,
-	1583, 1589, 1604, 1593, 1605, 1585, 1587, 1608, 1604, 1593, 1604, 1610, 1607, 1608,
-	1587, 1604, 1605, 1589, 1604, 1609, 1589, 1604, 1609, 32, 1575, 1604, 1604, 1607,
-	32, 1593, 1604, 1610, 1607, 32, 1608, 1587, 1604, 1605, 1580, 1604, 32, 1580, 1604,
-	1575, 1604, 1607, 1585, 1740, 1575, 1604, 44, 12289, 12310, 12311, 8212, 8211, 95,
-	123, 125, 12308, 12309, 12304, 12305, 12298, 12299, 12300, 12301, 12302, 12303,
-	91, 93, 35, 38, 42, 45, 60, 62, 92, 36, 37, 64, 32, 1611, 1600, 1611, 1600, 1617,
-	32, 1618, 1600, 1618, 1569, 1570, 1571, 1572, 1573, 1577, 1604, 1570, 1604, 1571,
-	1604, 1573, 34, 39, 94, 124, 126, 10629, 10630, 12539, 12453, 12515, 162, 163, 172,
-	166, 165, 8361, 9474, 8592, 8593, 8594, 8595, 9632, 9675, 66600, 66601, 66602, 66603,
-	66604, 66605, 66606, 66607, 66608, 66609, 66610, 66611, 66612, 66613, 66614, 66615,
-	66616, 66617, 66618, 66619, 66620, 66621, 66622, 66623, 66624, 66625, 66626, 66627,
-	66628, 66629, 66630, 66631, 66632, 66633, 66634, 66635, 66636, 66637, 66638, 66639,
-	66776, 66777, 66778, 66779, 66780, 66781, 66782, 66783, 66784, 66785, 66786, 66787,
-	66788, 66789, 66790, 66791, 66792, 66793, 66794, 66795, 66796, 66797, 66798, 66799,
-	66800, 66801, 66802, 66803, 66804, 66805, 66806, 66807, 66808, 66809, 66810, 66811,
-	66967, 66968, 66969, 66970, 66971, 66972, 66973, 66974, 66975, 66976, 66977, 66979,
-	66980, 66981, 66982, 66983, 66984, 66985, 66986, 66987, 66988, 66989, 66990, 66991,
-	66992, 66993, 66995, 66996, 66997, 66998, 66999, 67000, 67001, 67003, 67004, 720,
-	721, 665, 675, 43878, 677, 676, 7569, 600, 606, 681, 612, 610, 667, 668, 615, 644,
-	682, 683, 122628, 42894, 622, 122629, 654, 122630, 630, 631, 634, 122632, 638, 680,
-	678, 43879, 679, 11377, 655, 673, 674, 664, 448, 449, 450, 122634, 122654, 68800,
-	68801, 68802, 68803, 68804, 68805, 68806, 68807, 68808, 68809, 68810, 68811, 68812,
-	68813, 68814, 68815, 68816, 68817, 68818, 68819, 68820, 68821, 68822, 68823, 68824,
-	68825, 68826, 68827, 68828, 68829, 68830, 68831, 68832, 68833, 68834, 68835, 68836,
-	68837, 68838, 68839, 68840, 68841, 68842, 68843, 68844, 68845, 68846, 68847, 68848,
-	68849, 68850, 71872, 71873, 71874, 71875, 71876, 71877, 71878, 71879, 71880, 71881,
-	71882, 71883, 71884, 71885, 71886, 71887, 71888, 71889, 71890, 71891, 71892, 71893,
-	71894, 71895, 71896, 71897, 71898, 71899, 71900, 71901, 71902, 71903, 93792, 93793,
-	93794, 93795, 93796, 93797, 93798, 93799, 93800, 93801, 93802, 93803, 93804, 93805,
-	93806, 93807, 93808, 93809, 93810, 93811, 93812, 93813, 93814, 93815, 93816, 93817,
-	93818, 93819, 93820, 93821, 93822, 93823, 119127, 119141, 119128, 119141, 119128,
-	119141, 119150, 119128, 119141, 119151, 119128, 119141, 119152, 119128, 119141,
-	119153, 119128, 119141, 119154, 119225, 119141, 119226, 119141, 119225, 119141,
-	119150, 119226, 119141, 119150, 119225, 119141, 119151, 119226, 119141, 119151,
-	305, 567, 8711, 8706, 1231, 125218, 125219, 125220, 125221, 125222, 125223, 125224,
-	125225, 125226, 125227, 125228, 125229, 125230, 125231, 125232, 125233, 125234,
-	125235, 125236, 125237, 125238, 125239, 125240, 125241, 125242, 125243, 125244,
-	125245, 125246, 125247, 125248, 125249, 125250, 125251, 1646, 1697, 1647, 48, 44,
-	49, 44, 50, 44, 51, 44, 52, 44, 53, 44, 54, 44, 55, 44, 56, 44, 57, 44, 12308, 115,
-	12309, 119, 122, 104, 118, 115, 100, 115, 115, 112, 112, 118, 119, 99, 109, 114,
-	100, 106, 12411, 12363, 12467, 12467, 23383, 21452, 22810, 35299, 20132, 26144,
-	28961, 21069, 24460, 20877, 26032, 21021, 32066, 36009, 22768, 21561, 28436, 25237,
-	25429, 36938, 25351, 25171, 31105, 31354, 21512, 28288, 30003, 21106, 21942, 37197,
-	12308, 26412, 12309, 12308, 19977, 12309, 12308, 20108, 12309, 12308, 23433, 12309,
-	12308, 28857, 12309, 12308, 25171, 12309, 12308, 30423, 12309, 12308, 21213, 12309,
-	12308, 25943, 12309, 24471, 21487, 20029, 20024, 20033, 131362, 20320, 20411, 20482,
-	20602, 20633, 20687, 13470, 132666, 20820, 20836, 20855, 132380, 13497, 20839, 132427,
-	20887, 20900, 20172, 20908, 168415, 20995, 13535, 21051, 21062, 21111, 13589, 21253,
-	21254, 21321, 21338, 21363, 21373, 21375, 133676, 28784, 21450, 21471, 133987, 21483,
-	21489, 21510, 21662, 21560, 21576, 21608, 21666, 21750, 21776, 21843, 21859, 21892,
-	21931, 21939, 21954, 22294, 22295, 22097, 22132, 22766, 22478, 22516, 22541, 22411,
-	22578, 22577, 22700, 136420, 22770, 22775, 22790, 22818, 22882, 136872, 136938,
-	23020, 23067, 23079, 23000, 23142, 14062, 23304, 23358, 137672, 23491, 23512, 23539,
-	138008, 23551, 23558, 14209, 23648, 23744, 23693, 138724, 23875, 138726, 23918,
-	23915, 23932, 24033, 24034, 14383, 24061, 24104, 24125, 24169, 14434, 139651, 14460,
-	24240, 24243, 24246, 172946, 140081, 33281, 24354, 14535, 144056, 156122, 24418,
-	24427, 14563, 24474, 24525, 24535, 24569, 24705, 14650, 14620, 141012, 24775, 24904,
-	24908, 24954, 25010, 24996, 25007, 25054, 25115, 25181, 25265, 25300, 25424, 142092,
-	25405, 25340, 25448, 25475, 25572, 142321, 25634, 25541, 25513, 14894, 25705, 25726,
-	25757, 25719, 14956, 25964, 143370, 26083, 26360, 26185, 15129, 15112, 15076, 20882,
-	20885, 26368, 26268, 32941, 17369, 26401, 26462, 26451, 144323, 15177, 26618, 26501,
-	26706, 144493, 26766, 26655, 26900, 26946, 27043, 27114, 27304, 145059, 27355, 15384,
-	27425, 145575, 27476, 15438, 27506, 27551, 27579, 146061, 138507, 146170, 27726,
-	146620, 27839, 27853, 27751, 27926, 27966, 28009, 28024, 28037, 146718, 27956, 28207,
-	28270, 15667, 28359, 147153, 28153, 28526, 147294, 147342, 28614, 28729, 28699,
-	15766, 28746, 28797, 28791, 28845, 132389, 28997, 148067, 29084, 29224, 29264, 149000,
-	29312, 29333, 149301, 149524, 29562, 29579, 16044, 29605, 16056, 29767, 29788, 29829,
-	29898, 16155, 29988, 150582, 30014, 150674, 139679, 30224, 151457, 151480, 151620,
-	16380, 16392, 151795, 151794, 151833, 151859, 30494, 30495, 30603, 16454, 16534,
-	152605, 30798, 16611, 153126, 153242, 153285, 31211, 16687, 31306, 31311, 153980,
-	154279, 16898, 154539, 31686, 31689, 16935, 154752, 31954, 17056, 31976, 31971,
-	32000, 155526, 32099, 17153, 32199, 32258, 32325, 17204, 156200, 156231, 17241,
-	156377, 32634, 156478, 32661, 32762, 156890, 156963, 32864, 157096, 32880, 144223,
-	17365, 32946, 33027, 17419, 33086, 23221, 157607, 157621, 144275, 144284, 33284,
-	36766, 17515, 33425, 33419, 33437, 21171, 33457, 33459, 33469, 33510, 158524, 33565,
-	33635, 33709, 33571, 33725, 33767, 33619, 33738, 33740, 33756, 158774, 159083, 158933,
-	17707, 34033, 34035, 34070, 160714, 34148, 159532, 17757, 17761, 159665, 159954,
-	17771, 34384, 34407, 34409, 34473, 34440, 34574, 34530, 34600, 34667, 34694, 34785,
-	34817, 17913, 34912, 161383, 35031, 35038, 17973, 35066, 13499, 161966, 162150,
-	18110, 18119, 35488, 162984, 36011, 36033, 36123, 36215, 163631, 133124, 36299,
-	36284, 36336, 133342, 36564, 165330, 165357, 37012, 37105, 37137, 165678, 37147,
-	37432, 37591, 37592, 37500, 37881, 37909, 166906, 38283, 18837, 38327, 167287, 18918,
-	38595, 23986, 38691, 168261, 168474, 19054, 19062, 38880, 168970, 19122, 169110,
-	38953, 169398, 39138, 19251, 39209, 39335, 39362, 39422, 19406, 170800, 40000, 40189,
-	19662, 19693, 40295, 172238, 19704, 172293, 172558, 172689, 19798, 40702, 40709,
-	40719, 40726, 173568,
-
-};
-const uint32_t table[8002][2] =
-{
-	{0, 1}, {65, 16777219}, {66, 16777475}, {67, 16777731},
-	{68, 16777987}, {69, 16778243}, {70, 16778499}, {71, 16778755},
-	{72, 16779011}, {73, 16779267}, {74, 16779523}, {75, 16779779},
-	{76, 16780035}, {77, 16780291}, {78, 16780547}, {79, 16780803},
-	{80, 16781059}, {81, 16781315}, {82, 16781571}, {83, 16781827},
-	{84, 16782083}, {85, 16782339}, {86, 16782595}, {87, 16782851},
-	{88, 16783107}, {89, 16783363}, {90, 16783619}, {91, 1},
-	{128, 2}, {160, 16783875}, {161, 1}, {168, 33561347},
-	{169, 1}, {170, 16777219}, {171, 1}, {173, 0},
-	{174, 1}, {175, 33561859}, {176, 1}, {178, 16785155},
-	{179, 16785411}, {180, 33562883}, {181, 16786179}, {182, 1},
-	{184, 33563651}, {185, 16786947}, {186, 16780803}, {187, 1},
-	{188, 50341635}, {189, 50342403}, {190, 50343171}, {191, 1},
-	{192, 16789507}, {193, 16789763}, {194, 16790019}, {195, 16790275},
-	{196, 16790531}, {197, 16790787}, {198, 16791043}, {199, 16791299},
-	{200, 16791555}, {201, 16791811}, {202, 16792067}, {203, 16792323},
-	{204, 16792579}, {205, 16792835}, {206, 16793091}, {207, 16793347},
-	{208, 16793603}, {209, 16793859}, {210, 16794115}, {211, 16794371},
-	{212, 16794627}, {213, 16794883}, {214, 16795139}, {215, 1},
-	{216, 16795395}, {217, 16795651}, {218, 16795907}, {219, 16796163},
-	{220, 16796419}, {221, 16796675}, {222, 16796931}, {223, 1},
-	{256, 16797187}, {257, 1}, {258, 16797443}, {259, 1},
-	{260, 16797699}, {261, 1}, {262, 16797955}, {263, 1},
-	{264, 16798211}, {265, 1}, {266, 16798467}, {267, 1},
-	{268, 16798723}, {269, 1}, {270, 16798979}, {271, 1},
-	{272, 16799235}, {273, 1}, {274, 16799491}, {275, 1},
-	{276, 16799747}, {277, 1}, {278, 16800003}, {279, 1},
-	{280, 16800259}, {281, 1}, {282, 16800515}, {283, 1},
-	{284, 16800771}, {285, 1}, {286, 16801027}, {287, 1},
-	{288, 16801283}, {289, 1}, {290, 16801539}, {291, 1},
-	{292, 16801795}, {293, 1}, {294, 16802051}, {295, 1},
-	{296, 16802307}, {297, 1}, {298, 16802563}, {299, 1},
-	{300, 16802819}, {301, 1}, {302, 16803075}, {303, 1},
-	{304, 33580547}, {305, 1}, {306, 33556483}, {308, 16803843},
-	{309, 1}, {310, 16804099}, {311, 1}, {313, 16804355},
-	{314, 1}, {315, 16804611}, {316, 1}, {317, 16804867},
-	{318, 1}, {319, 33582339}, {321, 16805635}, {322, 1},
-	{323, 16805891}, {324, 1}, {325, 16806147}, {326, 1},
-	{327, 16806403}, {328, 1}, {329, 33583875}, {330, 16807171},
-	{331, 1}, {332, 16807427}, {333, 1}, {334, 16807683},
-	{335, 1}, {336, 16807939}, {337, 1}, {338, 16808195},
-	{339, 1}, {340, 16808451}, {341, 1}, {342, 16808707},
-	{343, 1}, {344, 16808963}, {345, 1}, {346, 16809219},
-	{347, 1}, {348, 16809475}, {349, 1}, {350, 16809731},
-	{351, 1}, {352, 16809987}, {353, 1}, {354, 16810243},
-	{355, 1}, {356, 16810499}, {357, 1}, {358, 16810755},
-	{359, 1}, {360, 16811011}, {361, 1}, {362, 16811267},
-	{363, 1}, {364, 16811523}, {365, 1}, {366, 16811779},
-	{367, 1}, {368, 16812035}, {369, 1}, {370, 16812291},
-	{371, 1}, {372, 16812547}, {373, 1}, {374, 16812803},
-	{375, 1}, {376, 16813059}, {377, 16813315}, {378, 1},
-	{379, 16813571}, {380, 1}, {381, 16813827}, {382, 1},
-	{383, 16781827}, {384, 1}, {385, 16814083}, {386, 16814339},
-	{387, 1}, {388, 16814595}, {389, 1}, {390, 16814851},
-	{391, 16815107}, {392, 1}, {393, 16815363}, {394, 16815619},
-	{395, 16815875}, {396, 1}, {398, 16816131}, {399, 16816387},
-	{400, 16816643}, {401, 16816899}, {402, 1}, {403, 16817155},
-	{404, 16817411}, {405, 1}, {406, 16817667}, {407, 16817923},
-	{408, 16818179}, {409, 1}, {412, 16818435}, {413, 16818691},
-	{414, 1}, {415, 16818947}, {416, 16819203}, {417, 1},
-	{418, 16819459}, {419, 1}, {420, 16819715}, {421, 1},
-	{422, 16819971}, {423, 16820227}, {424, 1}, {425, 16820483},
-	{426, 1}, {428, 16820739}, {429, 1}, {430, 16820995},
-	{431, 16821251}, {432, 1}, {433, 16821507}, {434, 16821763},
-	{435, 16822019}, {436, 1}, {437, 16822275}, {438, 1},
-	{439, 16822531}, {440, 16822787}, {441, 1}, {444, 16823043},
-	{445, 1}, {452, 33600515}, {455, 33601027}, {458, 33601539},
-	{461, 16824835}, {462, 1}, {463, 16825091}, {464, 1},
-	{465, 16825347}, {466, 1}, {467, 16825603}, {468, 1},
-	{469, 16825859}, {470, 1}, {471, 16826115}, {472, 1},
-	{473, 16826371}, {474, 1}, {475, 16826627}, {476, 1},
-	{478, 16826883}, {479, 1}, {480, 16827139}, {481, 1},
-	{482, 16827395}, {483, 1}, {484, 16827651}, {485, 1},
-	{486, 16827907}, {487, 1}, {488, 16828163}, {489, 1},
-	{490, 16828419}, {491, 1}, {492, 16828675}, {493, 1},
-	{494, 16828931}, {495, 1}, {497, 33606403}, {500, 16829699},
-	{501, 1}, {502, 16829955}, {503, 16830211}, {504, 16830467},
-	{505, 1}, {506, 16830723}, {507, 1}, {508, 16830979},
-	{509, 1}, {510, 16831235}, {511, 1}, {512, 16831491},
-	{513, 1}, {514, 16831747}, {515, 1}, {516, 16832003},
-	{517, 1}, {518, 16832259}, {519, 1}, {520, 16832515},
-	{521, 1}, {522, 16832771}, {523, 1}, {524, 16833027},
-	{525, 1}, {526, 16833283}, {527, 1}, {528, 16833539},
-	{529, 1}, {530, 16833795}, {531, 1}, {532, 16834051},
-	{533, 1}, {534, 16834307}, {535, 1}, {536, 16834563},
-	{537, 1}, {538, 16834819}, {539, 1}, {540, 16835075},
-	{541, 1}, {542, 16835331}, {543, 1}, {544, 16835587},
-	{545, 1}, {546, 16835843}, {547, 1}, {548, 16836099},
-	{549, 1}, {550, 16836355}, {551, 1}, {552, 16836611},
-	{553, 1}, {554, 16836867}, {555, 1}, {556, 16837123},
-	{557, 1}, {558, 16837379}, {559, 1}, {560, 16837635},
-	{561, 1}, {562, 16837891}, {563, 1}, {570, 16838147},
-	{571, 16838403}, {572, 1}, {573, 16838659}, {574, 16838915},
-	{575, 1}, {577, 16839171}, {578, 1}, {579, 16839427},
-	{580, 16839683}, {581, 16839939}, {582, 16840195}, {583, 1},
-	{584, 16840451}, {585, 1}, {586, 16840707}, {587, 1},
-	{588, 16840963}, {589, 1}, {590, 16841219}, {591, 1},
-	{688, 16779011}, {689, 16841475}, {690, 16779523}, {691, 16781571},
-	{692, 16841731}, {693, 16841987}, {694, 16842243}, {695, 16782851},
-	{696, 16783363}, {697, 1}, {728, 33619715}, {729, 33620227},
-	{730, 33620739}, {731, 33621251}, {732, 33621763}, {733, 33622275},
-	{734, 1}, {736, 16817411}, {737, 16780035}, {738, 16781827},
-	{739, 16783107}, {740, 16845571}, {741, 1}, {832, 16845827},
-	{833, 16785923}, {834, 1}, {835, 16846083}, {836, 33623555},
-	{837, 16846851}, {838, 1}, {847, 0}, {848, 1},
-	{880, 16847107}, {881, 1}, {882, 16847363}, {883, 1},
-	{884, 16847619}, {885, 1}, {886, 16847875}, {887, 1},
-	{888, 2}, {890, 33625347}, {891, 1}, {894, 16848643},
-	{895, 16848899}, {896, 2}, {900, 33562883}, {901, 50403587},
-	{902, 16849923}, {903, 16805379}, {904, 16850179}, {905, 16850435},
-	{906, 16850691}, {907, 2}, {908, 16850947}, {909, 2},
-	{910, 16851203}, {911, 16851459}, {912, 1}, {913, 16851715},
-	{914, 16851971}, {915, 16852227}, {916, 16852483}, {917, 16852739},
-	{918, 16852995}, {919, 16853251}, {920, 16853507}, {921, 16846851},
-	{922, 16853763}, {923, 16854019}, {924, 16786179}, {925, 16854275},
-	{926, 16854531}, {927, 16854787}, {928, 16855043}, {929, 16855299},
-	{930, 2}, {931, 16855555}, {932, 16855811}, {933, 16856067},
-	{934, 16856323}, {935, 16856579}, {936, 16856835}, {937, 16857091},
-	{938, 16857347}, {939, 16857603}, {940, 1}, {975, 16857859},
-	{976, 16851971}, {977, 16853507}, {978, 16856067}, {979, 16851203},
-	{980, 16857603}, {981, 16856323}, {982, 16855043}, {983, 1},
-	{984, 16858115}, {985, 1}, {986, 16858371}, {987, 1},
-	{988, 16858627}, {989, 1}, {990, 16858883}, {991, 1},
-	{992, 16859139}, {993, 1}, {994, 16859395}, {995, 1},
-	{996, 16859651}, {997, 1}, {998, 16859907}, {999, 1},
-	{1000, 16860163}, {1001, 1}, {1002, 16860419}, {1003, 1},
-	{1004, 16860675}, {1005, 1}, {1006, 16860931}, {1007, 1},
-	{1008, 16853763}, {1009, 16855299}, {1010, 16855555}, {1011, 1},
-	{1012, 16853507}, {1013, 16852739}, {1014, 1}, {1015, 16861187},
-	{1016, 1}, {1017, 16855555}, {1018, 16861443}, {1019, 1},
-	{1021, 16861699}, {1022, 16861955}, {1023, 16862211}, {1024, 16862467},
-	{1025, 16862723}, {1026, 16862979}, {1027, 16863235}, {1028, 16863491},
-	{1029, 16863747}, {1030, 16864003}, {1031, 16864259}, {1032, 16864515},
-	{1033, 16864771}, {1034, 16865027}, {1035, 16865283}, {1036, 16865539},
-	{1037, 16865795}, {1038, 16866051}, {1039, 16866307}, {1040, 16866563},
-	{1041, 16866819}, {1042, 16867075}, {1043, 16867331}, {1044, 16867587},
-	{1045, 16867843}, {1046, 16868099}, {1047, 16868355}, {1048, 16868611},
-	{1049, 16868867}, {1050, 16869123}, {1051, 16869379}, {1052, 16869635},
-	{1053, 16869891}, {1054, 16870147}, {1055, 16870403}, {1056, 16870659},
-	{1057, 16870915}, {1058, 16871171}, {1059, 16871427}, {1060, 16871683},
-	{1061, 16871939}, {1062, 16872195}, {1063, 16872451}, {1064, 16872707},
-	{1065, 16872963}, {1066, 16873219}, {1067, 16873475}, {1068, 16873731},
-	{1069, 16873987}, {1070, 16874243}, {1071, 16874499}, {1072, 1},
-	{1120, 16874755}, {1121, 1}, {1122, 16875011}, {1123, 1},
-	{1124, 16875267}, {1125, 1}, {1126, 16875523}, {1127, 1},
-	{1128, 16875779}, {1129, 1}, {1130, 16876035}, {1131, 1},
-	{1132, 16876291}, {1133, 1}, {1134, 16876547}, {1135, 1},
-	{1136, 16876803}, {1137, 1}, {1138, 16877059}, {1139, 1},
-	{1140, 16877315}, {1141, 1}, {1142, 16877571}, {1143, 1},
-	{1144, 16877827}, {1145, 1}, {1146, 16878083}, {1147, 1},
-	{1148, 16878339}, {1149, 1}, {1150, 16878595}, {1151, 1},
-	{1152, 16878851}, {1153, 1}, {1162, 16879107}, {1163, 1},
-	{1164, 16879363}, {1165, 1}, {1166, 16879619}, {1167, 1},
-	{1168, 16879875}, {1169, 1}, {1170, 16880131}, {1171, 1},
-	{1172, 16880387}, {1173, 1}, {1174, 16880643}, {1175, 1},
-	{1176, 16880899}, {1177, 1}, {1178, 16881155}, {1179, 1},
-	{1180, 16881411}, {1181, 1}, {1182, 16881667}, {1183, 1},
-	{1184, 16881923}, {1185, 1}, {1186, 16882179}, {1187, 1},
-	{1188, 16882435}, {1189, 1}, {1190, 16882691}, {1191, 1},
-	{1192, 16882947}, {1193, 1}, {1194, 16883203}, {1195, 1},
-	{1196, 16883459}, {1197, 1}, {1198, 16883715}, {1199, 1},
-	{1200, 16883971}, {1201, 1}, {1202, 16884227}, {1203, 1},
-	{1204, 16884483}, {1205, 1}, {1206, 16884739}, {1207, 1},
-	{1208, 16884995}, {1209, 1}, {1210, 16885251}, {1211, 1},
-	{1212, 16885507}, {1213, 1}, {1214, 16885763}, {1215, 1},
-	{1216, 2}, {1217, 16886019}, {1218, 1}, {1219, 16886275},
-	{1220, 1}, {1221, 16886531}, {1222, 1}, {1223, 16886787},
-	{1224, 1}, {1225, 16887043}, {1226, 1}, {1227, 16887299},
-	{1228, 1}, {1229, 16887555}, {1230, 1}, {1232, 16887811},
-	{1233, 1}, {1234, 16888067}, {1235, 1}, {1236, 16888323},
-	{1237, 1}, {1238, 16888579}, {1239, 1}, {1240, 16888835},
-	{1241, 1}, {1242, 16889091}, {1243, 1}, {1244, 16889347},
-	{1245, 1}, {1246, 16889603}, {1247, 1}, {1248, 16889859},
-	{1249, 1}, {1250, 16890115}, {1251, 1}, {1252, 16890371},
-	{1253, 1}, {1254, 16890627}, {1255, 1}, {1256, 16890883},
-	{1257, 1}, {1258, 16891139}, {1259, 1}, {1260, 16891395},
-	{1261, 1}, {1262, 16891651}, {1263, 1}, {1264, 16891907},
-	{1265, 1}, {1266, 16892163}, {1267, 1}, {1268, 16892419},
-	{1269, 1}, {1270, 16892675}, {1271, 1}, {1272, 16892931},
-	{1273, 1}, {1274, 16893187}, {1275, 1}, {1276, 16893443},
-	{1277, 1}, {1278, 16893699}, {1279, 1}, {1280, 16893955},
-	{1281, 1}, {1282, 16894211}, {1283, 1}, {1284, 16894467},
-	{1285, 1}, {1286, 16894723}, {1287, 1}, {1288, 16894979},
-	{1289, 1}, {1290, 16895235}, {1291, 1}, {1292, 16895491},
-	{1293, 1}, {1294, 16895747}, {1295, 1}, {1296, 16896003},
-	{1297, 1}, {1298, 16896259}, {1299, 1}, {1300, 16896515},
-	{1301, 1}, {1302, 16896771}, {1303, 1}, {1304, 16897027},
-	{1305, 1}, {1306, 16897283}, {1307, 1}, {1308, 16897539},
-	{1309, 1}, {1310, 16897795}, {1311, 1}, {1312, 16898051},
-	{1313, 1}, {1314, 16898307}, {1315, 1}, {1316, 16898563},
-	{1317, 1}, {1318, 16898819}, {1319, 1}, {1320, 16899075},
-	{1321, 1}, {1322, 16899331}, {1323, 1}, {1324, 16899587},
-	{1325, 1}, {1326, 16899843}, {1327, 1}, {1328, 2},
-	{1329, 16900099}, {1330, 16900355}, {1331, 16900611}, {1332, 16900867},
-	{1333, 16901123}, {1334, 16901379}, {1335, 16901635}, {1336, 16901891},
-	{1337, 16902147}, {1338, 16902403}, {1339, 16902659}, {1340, 16902915},
-	{1341, 16903171}, {1342, 16903427}, {1343, 16903683}, {1344, 16903939},
-	{1345, 16904195}, {1346, 16904451}, {1347, 16904707}, {1348, 16904963},
-	{1349, 16905219}, {1350, 16905475}, {1351, 16905731}, {1352, 16905987},
-	{1353, 16906243}, {1354, 16906499}, {1355, 16906755}, {1356, 16907011},
-	{1357, 16907267}, {1358, 16907523}, {1359, 16907779}, {1360, 16908035},
-	{1361, 16908291}, {1362, 16908547}, {1363, 16908803}, {1364, 16909059},
-	{1365, 16909315}, {1366, 16909571}, {1367, 2}, {1369, 1},
-	{1415, 33687043}, {1416, 1}, {1419, 2}, {1421, 1},
-	{1424, 2}, {1425, 1}, {1480, 2}, {1488, 1},
-	{1515, 2}, {1519, 1}, {1525, 2}, {1542, 1},
-	{1564, 2}, {1565, 1}, {1653, 33687555}, {1654, 33688067},
-	{1655, 33688579}, {1656, 33689091}, {1657, 1}, {1757, 2},
-	{1758, 1}, {1806, 2}, {1808, 1}, {1867, 2},
-	{1869, 1}, {1970, 2}, {1984, 1}, {2043, 2},
-	{2045, 1}, {2094, 2}, {2096, 1}, {2111, 2},
-	{2112, 1}, {2140, 2}, {2142, 1}, {2143, 2},
-	{2144, 1}, {2155, 2}, {2160, 1}, {2191, 2},
-	{2200, 1}, {2274, 2}, {2275, 1}, {2392, 33689603},
-	{2393, 33690115}, {2394, 33690627}, {2395, 33691139}, {2396, 33691651},
-	{2397, 33692163}, {2398, 33692675}, {2399, 33693187}, {2400, 1},
-	{2436, 2}, {2437, 1}, {2445, 2}, {2447, 1},
-	{2449, 2}, {2451, 1}, {2473, 2}, {2474, 1},
-	{2481, 2}, {2482, 1}, {2483, 2}, {2486, 1},
-	{2490, 2}, {2492, 1}, {2501, 2}, {2503, 1},
-	{2505, 2}, {2507, 1}, {2511, 2}, {2519, 1},
-	{2520, 2}, {2524, 33693699}, {2525, 33694211}, {2526, 2},
-	{2527, 33694723}, {2528, 1}, {2532, 2}, {2534, 1},
-	{2559, 2}, {2561, 1}, {2564, 2}, {2565, 1},
-	{2571, 2}, {2575, 1}, {2577, 2}, {2579, 1},
-	{2601, 2}, {2602, 1}, {2609, 2}, {2610, 1},
-	{2611, 33695235}, {2612, 2}, {2613, 1}, {2614, 33695747},
-	{2615, 2}, {2616, 1}, {2618, 2}, {2620, 1},
-	{2621, 2}, {2622, 1}, {2627, 2}, {2631, 1},
-	{2633, 2}, {2635, 1}, {2638, 2}, {2641, 1},
-	{2642, 2}, {2649, 33696259}, {2650, 33696771}, {2651, 33697283},
-	{2652, 1}, {2653, 2}, {2654, 33697795}, {2655, 2},
-	{2662, 1}, {2679, 2}, {2689, 1}, {2692, 2},
-	{2693, 1}, {2702, 2}, {2703, 1}, {2706, 2},
-	{2707, 1}, {2729, 2}, {2730, 1}, {2737, 2},
-	{2738, 1}, {2740, 2}, {2741, 1}, {2746, 2},
-	{2748, 1}, {2758, 2}, {2759, 1}, {2762, 2},
-	{2763, 1}, {2766, 2}, {2768, 1}, {2769, 2},
-	{2784, 1}, {2788, 2}, {2790, 1}, {2802, 2},
-	{2809, 1}, {2816, 2}, {2817, 1}, {2820, 2},
-	{2821, 1}, {2829, 2}, {2831, 1}, {2833, 2},
-	{2835, 1}, {2857, 2}, {2858, 1}, {2865, 2},
-	{2866, 1}, {2868, 2}, {2869, 1}, {2874, 2},
-	{2876, 1}, {2885, 2}, {2887, 1}, {2889, 2},
-	{2891, 1}, {2894, 2}, {2901, 1}, {2904, 2},
-	{2908, 33698307}, {2909, 33698819}, {2910, 2}, {2911, 1},
-	{2916, 2}, {2918, 1}, {2936, 2}, {2946, 1},
-	{2948, 2}, {2949, 1}, {2955, 2}, {2958, 1},
-	{2961, 2}, {2962, 1}, {2966, 2}, {2969, 1},
-	{2971, 2}, {2972, 1}, {2973, 2}, {2974, 1},
-	{2976, 2}, {2979, 1}, {2981, 2}, {2984, 1},
-	{2987, 2}, {2990, 1}, {3002, 2}, {3006, 1},
-	{3011, 2}, {3014, 1}, {3017, 2}, {3018, 1},
-	{3022, 2}, {3024, 1}, {3025, 2}, {3031, 1},
-	{3032, 2}, {3046, 1}, {3067, 2}, {3072, 1},
-	{3085, 2}, {3086, 1}, {3089, 2}, {3090, 1},
-	{3113, 2}, {3114, 1}, {3130, 2}, {3132, 1},
-	{3141, 2}, {3142, 1}, {3145, 2}, {3146, 1},
-	{3150, 2}, {3157, 1}, {3159, 2}, {3160, 1},
-	{3163, 2}, {3165, 1}, {3166, 2}, {3168, 1},
-	{3172, 2}, {3174, 1}, {3184, 2}, {3191, 1},
-	{3213, 2}, {3214, 1}, {3217, 2}, {3218, 1},
-	{3241, 2}, {3242, 1}, {3252, 2}, {3253, 1},
-	{3258, 2}, {3260, 1}, {3269, 2}, {3270, 1},
-	{3273, 2}, {3274, 1}, {3278, 2}, {3285, 1},
-	{3287, 2}, {3293, 1}, {3295, 2}, {3296, 1},
-	{3300, 2}, {3302, 1}, {3312, 2}, {3313, 1},
-	{3316, 2}, {3328, 1}, {3341, 2}, {3342, 1},
-	{3345, 2}, {3346, 1}, {3397, 2}, {3398, 1},
-	{3401, 2}, {3402, 1}, {3408, 2}, {3412, 1},
-	{3428, 2}, {3430, 1}, {3456, 2}, {3457, 1},
-	{3460, 2}, {3461, 1}, {3479, 2}, {3482, 1},
-	{3506, 2}, {3507, 1}, {3516, 2}, {3517, 1},
-	{3518, 2}, {3520, 1}, {3527, 2}, {3530, 1},
-	{3531, 2}, {3535, 1}, {3541, 2}, {3542, 1},
-	{3543, 2}, {3544, 1}, {3552, 2}, {3558, 1},
-	{3568, 2}, {3570, 1}, {3573, 2}, {3585, 1},
-	{3635, 33699331}, {3636, 1}, {3643, 2}, {3647, 1},
-	{3676, 2}, {3713, 1}, {3715, 2}, {3716, 1},
-	{3717, 2}, {3718, 1}, {3723, 2}, {3724, 1},
-	{3748, 2}, {3749, 1}, {3750, 2}, {3751, 1},
-	{3763, 33699843}, {3764, 1}, {3774, 2}, {3776, 1},
-	{3781, 2}, {3782, 1}, {3783, 2}, {3784, 1},
-	{3791, 2}, {3792, 1}, {3802, 2}, {3804, 33700355},
-	{3805, 33700867}, {3806, 1}, {3808, 2}, {3840, 1},
-	{3852, 16924163}, {3853, 1}, {3907, 33701635}, {3908, 1},
-	{3912, 2}, {3913, 1}, {3917, 33702147}, {3918, 1},
-	{3922, 33702659}, {3923, 1}, {3927, 33703171}, {3928, 1},
-	{3932, 33703683}, {3933, 1}, {3945, 33704195}, {3946, 1},
-	{3949, 2}, {3953, 1}, {3955, 33704707}, {3956, 1},
-	{3957, 33705219}, {3958, 33705731}, {3959, 50483459}, {3960, 33707011},
-	{3961, 50484739}, {3962, 1}, {3969, 33706499}, {3970, 1},
-	{3987, 33708291}, {3988, 1}, {3992, 2}, {3993, 1},
-	{3997, 33708803}, {3998, 1}, {4002, 33709315}, {4003, 1},
-	{4007, 33709827}, {4008, 1}, {4012, 33710339}, {4013, 1},
-	{4025, 33710851}, {4026, 1}, {4029, 2}, {4030, 1},
-	{4045, 2}, {4046, 1}, {4059, 2}, {4096, 1},
-	{4256, 2}, {4295, 16934147}, {4296, 2}, {4301, 16934403},
-	{4302, 2}, {4304, 1}, {4348, 16934659}, {4349, 1},
-	{4447, 2}, {4449, 1}, {4681, 2}, {4682, 1},
-	{4686, 2}, {4688, 1}, {4695, 2}, {4696, 1},
-	{4697, 2}, {4698, 1}, {4702, 2}, {4704, 1},
-	{4745, 2}, {4746, 1}, {4750, 2}, {4752, 1},
-	{4785, 2}, {4786, 1}, {4790, 2}, {4792, 1},
-	{4799, 2}, {4800, 1}, {4801, 2}, {4802, 1},
-	{4806, 2}, {4808, 1}, {4823, 2}, {4824, 1},
-	{4881, 2}, {4882, 1}, {4886, 2}, {4888, 1},
-	{4955, 2}, {4957, 1}, {4989, 2}, {4992, 1},
-	{5018, 2}, {5024, 1}, {5110, 2}, {5112, 16934915},
-	{5113, 16935171}, {5114, 16935427}, {5115, 16935683}, {5116, 16935939},
-	{5117, 16936195}, {5118, 2}, {5120, 1}, {5760, 2},
-	{5761, 1}, {5789, 2}, {5792, 1}, {5881, 2},
-	{5888, 1}, {5910, 2}, {5919, 1}, {5943, 2},
-	{5952, 1}, {5972, 2}, {5984, 1}, {5997, 2},
-	{5998, 1}, {6001, 2}, {6002, 1}, {6004, 2},
-	{6016, 1}, {6068, 2}, {6070, 1}, {6110, 2},
-	{6112, 1}, {6122, 2}, {6128, 1}, {6138, 2},
-	{6144, 1}, {6150, 2}, {6151, 1}, {6155, 0},
-	{6158, 2}, {6159, 0}, {6160, 1}, {6170, 2},
-	{6176, 1}, {6265, 2}, {6272, 1}, {6315, 2},
-	{6320, 1}, {6390, 2}, {6400, 1}, {6431, 2},
-	{6432, 1}, {6444, 2}, {6448, 1}, {6460, 2},
-	{6464, 1}, {6465, 2}, {6468, 1}, {6510, 2},
-	{6512, 1}, {6517, 2}, {6528, 1}, {6572, 2},
-	{6576, 1}, {6602, 2}, {6608, 1}, {6619, 2},
-	{6622, 1}, {6684, 2}, {6686, 1}, {6751, 2},
-	{6752, 1}, {6781, 2}, {6783, 1}, {6794, 2},
-	{6800, 1}, {6810, 2}, {6816, 1}, {6830, 2},
-	{6832, 1}, {6863, 2}, {6912, 1}, {6989, 2},
-	{6992, 1}, {7039, 2}, {7040, 1}, {7156, 2},
-	{7164, 1}, {7224, 2}, {7227, 1}, {7242, 2},
-	{7245, 1}, {7296, 16867075}, {7297, 16867587}, {7298, 16870147},
-	{7299, 16870915}, {7300, 16871171}, {7302, 16873219}, {7303, 16875011},
-	{7304, 16936451}, {7305, 2}, {7312, 16936707}, {7313, 16936963},
-	{7314, 16937219}, {7315, 16937475}, {7316, 16937731}, {7317, 16937987},
-	{7318, 16938243}, {7319, 16938499}, {7320, 16938755}, {7321, 16939011},
-	{7322, 16939267}, {7323, 16939523}, {7324, 16934659}, {7325, 16939779},
-	{7326, 16940035}, {7327, 16940291}, {7328, 16940547}, {7329, 16940803},
-	{7330, 16941059}, {7331, 16941315}, {7332, 16941571}, {7333, 16941827},
-	{7334, 16942083}, {7335, 16942339}, {7336, 16942595}, {7337, 16942851},
-	{7338, 16943107}, {7339, 16943363}, {7340, 16943619}, {7341, 16943875},
-	{7342, 16944131}, {7343, 16944387}, {7344, 16944643}, {7345, 16944899},
-	{7346, 16945155}, {7347, 16945411}, {7348, 16945667}, {7349, 16945923},
-	{7350, 16946179}, {7351, 16946435}, {7352, 16946691}, {7353, 16946947},
-	{7354, 16947203}, {7355, 2}, {7357, 16947459}, {7358, 16947715},
-	{7359, 16947971}, {7360, 1}, {7368, 2}, {7376, 1},
-	{7419, 2}, {7424, 1}, {7468, 16777219}, {7469, 16791043},
-	{7470, 16777475}, {7471, 1}, {7472, 16777987}, {7473, 16778243},
-	{7474, 16816131}, {7475, 16778755}, {7476, 16779011}, {7477, 16779267},
-	{7478, 16779523}, {7479, 16779779}, {7480, 16780035}, {7481, 16780291},
-	{7482, 16780547}, {7483, 1}, {7484, 16780803}, {7485, 16835843},
-	{7486, 16781059}, {7487, 16781571}, {7488, 16782083}, {7489, 16782339},
-	{7490, 16782851}, {7491, 16777219}, {7492, 16948227}, {7493, 16948483},
-	{7494, 16948739}, {7495, 16777475}, {7496, 16777987}, {7497, 16778243},
-	{7498, 16816387}, {7499, 16816643}, {7500, 16948995}, {7501, 16778755},
-	{7502, 1}, {7503, 16779779}, {7504, 16780291}, {7505, 16807171},
-	{7506, 16780803}, {7507, 16814851}, {7508, 16949251}, {7509, 16949507},
-	{7510, 16781059}, {7511, 16782083}, {7512, 16782339}, {7513, 16949763},
-	{7514, 16818435}, {7515, 16782595}, {7516, 16950019}, {7517, 16851971},
-	{7518, 16852227}, {7519, 16852483}, {7520, 16856323}, {7521, 16856579},
-	{7522, 16779267}, {7523, 16781571}, {7524, 16782339}, {7525, 16782595},
-	{7526, 16851971}, {7527, 16852227}, {7528, 16855299}, {7529, 16856323},
-	{7530, 16856579}, {7531, 1}, {7544, 16869891}, {7545, 1},
-	{7579, 16950275}, {7580, 16777731}, {7581, 16950531}, {7582, 16793603},
-	{7583, 16948995}, {7584, 16778499}, {7585, 16950787}, {7586, 16951043},
-	{7587, 16951299}, {7588, 16817923}, {7589, 16817667}, {7590, 16951555},
-	{7591, 16951811}, {7592, 16952067}, {7593, 16952323}, {7594, 16952579},
-	{7595, 16952835}, {7596, 16953091}, {7597, 16953347}, {7598, 16818691},
-	{7599, 16953603}, {7600, 16953859}, {7601, 16818947}, {7602, 16954115},
-	{7603, 16954371}, {7604, 16820483}, {7605, 16954627}, {7606, 16839683},
-	{7607, 16821507}, {7608, 16954883}, {7609, 16821763}, {7610, 16839939},
-	{7611, 16783619}, {7612, 16955139}, {7613, 16955395}, {7614, 16822531},
-	{7615, 16853507}, {7616, 1}, {7680, 16955651}, {7681, 1},
-	{7682, 16955907}, {7683, 1}, {7684, 16956163}, {7685, 1},
-	{7686, 16956419}, {7687, 1}, {7688, 16956675}, {7689, 1},
-	{7690, 16956931}, {7691, 1}, {7692, 16957187}, {7693, 1},
-	{7694, 16957443}, {7695, 1}, {7696, 16957699}, {7697, 1},
-	{7698, 16957955}, {7699, 1}, {7700, 16958211}, {7701, 1},
-	{7702, 16958467}, {7703, 1}, {7704, 16958723}, {7705, 1},
-	{7706, 16958979}, {7707, 1}, {7708, 16959235}, {7709, 1},
-	{7710, 16959491}, {7711, 1}, {7712, 16959747}, {7713, 1},
-	{7714, 16960003}, {7715, 1}, {7716, 16960259}, {7717, 1},
-	{7718, 16960515}, {7719, 1}, {7720, 16960771}, {7721, 1},
-	{7722, 16961027}, {7723, 1}, {7724, 16961283}, {7725, 1},
-	{7726, 16961539}, {7727, 1}, {7728, 16961795}, {7729, 1},
-	{7730, 16962051}, {7731, 1}, {7732, 16962307}, {7733, 1},
-	{7734, 16962563}, {7735, 1}, {7736, 16962819}, {7737, 1},
-	{7738, 16963075}, {7739, 1}, {7740, 16963331}, {7741, 1},
-	{7742, 16963587}, {7743, 1}, {7744, 16963843}, {7745, 1},
-	{7746, 16964099}, {7747, 1}, {7748, 16964355}, {7749, 1},
-	{7750, 16964611}, {7751, 1}, {7752, 16964867}, {7753, 1},
-	{7754, 16965123}, {7755, 1}, {7756, 16965379}, {7757, 1},
-	{7758, 16965635}, {7759, 1}, {7760, 16965891}, {7761, 1},
-	{7762, 16966147}, {7763, 1}, {7764, 16966403}, {7765, 1},
-	{7766, 16966659}, {7767, 1}, {7768, 16966915}, {7769, 1},
-	{7770, 16967171}, {7771, 1}, {7772, 16967427}, {7773, 1},
-	{7774, 16967683}, {7775, 1}, {7776, 16967939}, {7777, 1},
-	{7778, 16968195}, {7779, 1}, {7780, 16968451}, {7781, 1},
-	{7782, 16968707}, {7783, 1}, {7784, 16968963}, {7785, 1},
-	{7786, 16969219}, {7787, 1}, {7788, 16969475}, {7789, 1},
-	{7790, 16969731}, {7791, 1}, {7792, 16969987}, {7793, 1},
-	{7794, 16970243}, {7795, 1}, {7796, 16970499}, {7797, 1},
-	{7798, 16970755}, {7799, 1}, {7800, 16971011}, {7801, 1},
-	{7802, 16971267}, {7803, 1}, {7804, 16971523}, {7805, 1},
-	{7806, 16971779}, {7807, 1}, {7808, 16972035}, {7809, 1},
-	{7810, 16972291}, {7811, 1}, {7812, 16972547}, {7813, 1},
-	{7814, 16972803}, {7815, 1}, {7816, 16973059}, {7817, 1},
-	{7818, 16973315}, {7819, 1}, {7820, 16973571}, {7821, 1},
-	{7822, 16973827}, {7823, 1}, {7824, 16974083}, {7825, 1},
-	{7826, 16974339}, {7827, 1}, {7828, 16974595}, {7829, 1},
-	{7834, 33752067}, {7835, 16967939}, {7836, 1}, {7838, 16975363},
-	{7839, 1}, {7840, 16975619}, {7841, 1}, {7842, 16975875},
-	{7843, 1}, {7844, 16976131}, {7845, 1}, {7846, 16976387},
-	{7847, 1}, {7848, 16976643}, {7849, 1}, {7850, 16976899},
-	{7851, 1}, {7852, 16977155}, {7853, 1}, {7854, 16977411},
-	{7855, 1}, {7856, 16977667}, {7857, 1}, {7858, 16977923},
-	{7859, 1}, {7860, 16978179}, {7861, 1}, {7862, 16978435},
-	{7863, 1}, {7864, 16978691}, {7865, 1}, {7866, 16978947},
-	{7867, 1}, {7868, 16979203}, {7869, 1}, {7870, 16979459},
-	{7871, 1}, {7872, 16979715}, {7873, 1}, {7874, 16979971},
-	{7875, 1}, {7876, 16980227}, {7877, 1}, {7878, 16980483},
-	{7879, 1}, {7880, 16980739}, {7881, 1}, {7882, 16980995},
-	{7883, 1}, {7884, 16981251}, {7885, 1}, {7886, 16981507},
-	{7887, 1}, {7888, 16981763}, {7889, 1}, {7890, 16982019},
-	{7891, 1}, {7892, 16982275}, {7893, 1}, {7894, 16982531},
-	{7895, 1}, {7896, 16982787}, {7897, 1}, {7898, 16983043},
-	{7899, 1}, {7900, 16983299}, {7901, 1}, {7902, 16983555},
-	{7903, 1}, {7904, 16983811}, {7905, 1}, {7906, 16984067},
-	{7907, 1}, {7908, 16984323}, {7909, 1}, {7910, 16984579},
-	{7911, 1}, {7912, 16984835}, {7913, 1}, {7914, 16985091},
-	{7915, 1}, {7916, 16985347}, {7917, 1}, {7918, 16985603},
-	{7919, 1}, {7920, 16985859}, {7921, 1}, {7922, 16986115},
-	{7923, 1}, {7924, 16986371}, {7925, 1}, {7926, 16986627},
-	{7927, 1}, {7928, 16986883}, {7929, 1}, {7930, 16987139},
-	{7931, 1}, {7932, 16987395}, {7933, 1}, {7934, 16987651},
-	{7935, 1}, {7944, 16987907}, {7945, 16988163}, {7946, 16988419},
-	{7947, 16988675}, {7948, 16988931}, {7949, 16989187}, {7950, 16989443},
-	{7951, 16989699}, {7952, 1}, {7958, 2}, {7960, 16989955},
-	{7961, 16990211}, {7962, 16990467}, {7963, 16990723}, {7964, 16990979},
-	{7965, 16991235}, {7966, 2}, {7968, 1}, {7976, 16991491},
-	{7977, 16991747}, {7978, 16992003}, {7979, 16992259}, {7980, 16992515},
-	{7981, 16992771}, {7982, 16993027}, {7983, 16993283}, {7984, 1},
-	{7992, 16993539}, {7993, 16993795}, {7994, 16994051}, {7995, 16994307},
-	{7996, 16994563}, {7997, 16994819}, {7998, 16995075}, {7999, 16995331},
-	{8000, 1}, {8006, 2}, {8008, 16995587}, {8009, 16995843},
-	{8010, 16996099}, {8011, 16996355}, {8012, 16996611}, {8013, 16996867},
-	{8014, 2}, {8016, 1}, {8024, 2}, {8025, 16997123},
-	{8026, 2}, {8027, 16997379}, {8028, 2}, {8029, 16997635},
-	{8030, 2}, {8031, 16997891}, {8032, 1}, {8040, 16998147},
-	{8041, 16998403}, {8042, 16998659}, {8043, 16998915}, {8044, 16999171},
-	{8045, 16999427}, {8046, 16999683}, {8047, 16999939}, {8048, 1},
-	{8049, 16849923}, {8050, 1}, {8051, 16850179}, {8052, 1},
-	{8053, 16850435}, {8054, 1}, {8055, 16850691}, {8056, 1},
-	{8057, 16850947}, {8058, 1}, {8059, 16851203}, {8060, 1},
-	{8061, 16851459}, {8062, 2}, {8064, 33777411}, {8065, 33777923},
-	{8066, 33778435}, {8067, 33778947}, {8068, 33779459}, {8069, 33779971},
-	{8070, 33780483}, {8071, 33780995}, {8072, 33777411}, {8073, 33777923},
-	{8074, 33778435}, {8075, 33778947}, {8076, 33779459}, {8077, 33779971},
-	{8078, 33780483}, {8079, 33780995}, {8080, 33781507}, {8081, 33782019},
-	{8082, 33782531}, {8083, 33783043}, {8084, 33783555}, {8085, 33784067},
-	{8086, 33784579}, {8087, 33785091}, {8088, 33781507}, {8089, 33782019},
-	{8090, 33782531}, {8091, 33783043}, {8092, 33783555}, {8093, 33784067},
-	{8094, 33784579}, {8095, 33785091}, {8096, 33785603}, {8097, 33786115},
-	{8098, 33786627}, {8099, 33787139}, {8100, 33787651}, {8101, 33788163},
-	{8102, 33788675}, {8103, 33789187}, {8104, 33785603}, {8105, 33786115},
-	{8106, 33786627}, {8107, 33787139}, {8108, 33787651}, {8109, 33788163},
-	{8110, 33788675}, {8111, 33789187}, {8112, 1}, {8114, 33789699},
-	{8115, 33790211}, {8116, 33790723}, {8117, 2}, {8118, 1},
-	{8119, 33791235}, {8120, 17014531}, {8121, 17014787}, {8122, 17012483},
-	{8123, 16849923}, {8124, 33790211}, {8125, 33792259}, {8126, 16846851},
-	{8127, 33792259}, {8128, 33792771}, {8129, 50570499}, {8130, 33794051},
-	{8131, 33794563}, {8132, 33795075}, {8133, 2}, {8134, 1},
-	{8135, 33795587}, {8136, 17018883}, {8137, 16850179}, {8138, 17016835},
-	{8139, 16850435}, {8140, 33794563}, {8141, 50573571}, {8142, 50574339},
-	{8143, 50575107}, {8144, 1}, {8147, 17021443}, {8148, 2},
-	{8150, 1}, {8152, 17021699}, {8153, 17021955}, {8154, 17022211},
-	{8155, 16850691}, {8156, 2}, {8157, 50576899}, {8158, 50577667},
-	{8159, 50578435}, {8160, 1}, {8163, 17024771}, {8164, 1},
-	{8168, 17025027}, {8169, 17025283}, {8170, 17025539}, {8171, 16851203},
-	{8172, 17025795}, {8173, 50580483}, {8174, 50403587}, {8175, 17026819},
-	{8176, 2}, {8178, 33804291}, {8179, 33804803}, {8180, 33805315},
-	{8181, 2}, {8182, 1}, {8183, 33805827}, {8184, 17029123},
-	{8185, 16850947}, {8186, 17027075}, {8187, 16851459}, {8188, 33804803},
-	{8189, 33562883}, {8190, 33799683}, {8191, 2}, {8192, 16783875},
-	{8203, 0}, {8204, 1}, {8206, 2}, {8208, 1},
-	{8209, 17029379}, {8210, 1}, {8215, 33806851}, {8216, 1},
-	{8228, 2}, {8231, 1}, {8232, 2}, {8239, 16783875},
-	{8240, 1}, {8243, 33807363}, {8244, 50585091}, {8245, 1},
-	{8246, 33808643}, {8247, 50586371}, {8248, 1}, {8252, 33809923},
-	{8253, 1}, {8254, 33810435}, {8255, 1}, {8263, 33810947},
-	{8264, 33811459}, {8265, 33811971}, {8266, 1}, {8279, 67361795},
-	{8280, 1}, {8287, 16783875}, {8288, 0}, {8289, 2},
-	{8292, 0}, {8293, 2}, {8304, 17035267}, {8305, 16779267},
-	{8306, 2}, {8308, 16787715}, {8309, 17035523}, {8310, 17035779},
-	{8311, 17036035}, {8312, 17036291}, {8313, 17036547}, {8314, 17036803},
-	{8315, 17037059}, {8316, 17037315}, {8317, 17037571}, {8318, 17037827},
-	{8319, 16780547}, {8320, 17035267}, {8321, 16786947}, {8322, 16785155},
-	{8323, 16785411}, {8324, 16787715}, {8325, 17035523}, {8326, 17035779},
-	{8327, 17036035}, {8328, 17036291}, {8329, 17036547}, {8330, 17036803},
-	{8331, 17037059}, {8332, 17037315}, {8333, 17037571}, {8334, 17037827},
-	{8335, 2}, {8336, 16777219}, {8337, 16778243}, {8338, 16780803},
-	{8339, 16783107}, {8340, 16816387}, {8341, 16779011}, {8342, 16779779},
-	{8343, 16780035}, {8344, 16780291}, {8345, 16780547}, {8346, 16781059},
-	{8347, 16781827}, {8348, 16782083}, {8349, 2}, {8352, 1},
-	{8360, 33558787}, {8361, 1}, {8385, 2}, {8400, 1},
-	{8433, 2}, {8448, 50592515}, {8449, 50593283}, {8450, 16777731},
-	{8451, 33816835}, {8452, 1}, {8453, 50594563}, {8454, 50595331},
-	{8455, 16816643}, {8456, 1}, {8457, 33818883}, {8458, 16778755},
-	{8459, 16779011}, {8463, 16802051}, {8464, 16779267}, {8466, 16780035},
-	{8468, 1}, {8469, 16780547}, {8470, 33557763}, {8471, 1},
-	{8473, 16781059}, {8474, 16781315}, {8475, 16781571}, {8478, 1},
-	{8480, 33819395}, {8481, 50597123}, {8482, 33820675}, {8483, 1},
-	{8484, 16783619}, {8485, 1}, {8486, 16857091}, {8487, 1},
-	{8488, 16783619}, {8489, 1}, {8490, 16779779}, {8491, 16790787},
-	{8492, 16777475}, {8493, 16777731}, {8494, 1}, {8495, 16778243},
-	{8497, 16778499}, {8498, 2}, {8499, 16780291}, {8500, 16780803},
-	{8501, 17043971}, {8502, 17044227}, {8503, 17044483}, {8504, 17044739},
-	{8505, 16779267}, {8506, 1}, {8507, 50599427}, {8508, 16855043},
-	{8509, 16852227}, {8511, 16855043}, {8512, 17045763}, {8513, 1},
-	{8517, 16777987}, {8519, 16778243}, {8520, 16779267}, {8521, 16779523},
-	{8522, 1}, {8528, 50600451}, {8529, 50601219}, {8530, 67379203},
-	{8531, 50603011}, {8532, 50603779}, {8533, 50604547}, {8534, 50605315},
-	{8535, 50606083}, {8536, 50606851}, {8537, 50607619}, {8538, 50608387},
-	{8539, 50609155}, {8540, 50609923}, {8541, 50610691}, {8542, 50611459},
-	{8543, 33564419}, {8544, 16779267}, {8545, 33835011}, {8546, 50612739},
-	{8547, 33836291}, {8548, 16782595}, {8549, 33836803}, {8550, 50614531},
-	{8551, 67392515}, {8552, 33839107}, {8553, 16783107}, {8554, 33839619},
-	{8555, 50617347}, {8556, 16780035}, {8557, 16777731}, {8558, 16777987},
-	{8559, 16780291}, {8560, 16779267}, {8561, 33835011}, {8562, 50612227},
-	{8563, 33836291}, {8564, 16782595}, {8565, 33836803}, {8566, 50614531},
-	{8567, 67392515}, {8568, 33839107}, {8569, 16783107}, {8570, 33839619},
-	{8571, 50617347}, {8572, 16780035}, {8573, 16777731}, {8574, 16777987},
-	{8575, 16780291}, {8576, 1}, {8579, 2}, {8580, 1},
-	{8585, 50618115}, {8586, 1}, {8588, 2}, {8592, 1},
-	{8748, 33841667}, {8749, 50619395}, {8750, 1}, {8751, 33842947},
-	{8752, 50620675}, {8753, 1}, {9001, 17067011}, {9002, 17067267},
-	{9003, 1}, {9255, 2}, {9280, 1}, {9291, 2},
-	{9312, 16786947}, {9313, 16785155}, {9314, 16785411}, {9315, 16787715},
-	{9316, 17035523}, {9317, 17035779}, {9318, 17036035}, {9319, 17036291},
-	{9320, 17036547}, {9321, 33825283}, {9322, 33564163}, {9323, 33844739},
-	{9324, 33845251}, {9325, 33845763}, {9326, 33846275}, {9327, 33846787},
-	{9328, 33847299}, {9329, 33847811}, {9330, 33848323}, {9331, 33848835},
-	{9332, 50626563}, {9333, 50627331}, {9334, 50628099}, {9335, 50628867},
-	{9336, 50629635}, {9337, 50630403}, {9338, 50631171}, {9339, 50631939},
-	{9340, 50632707}, {9341, 67410691}, {9342, 67411715}, {9343, 67412739},
-	{9344, 67413763}, {9345, 67414787}, {9346, 67415811}, {9347, 67416835},
-	{9348, 67417859}, {9349, 67418883}, {9350, 67419907}, {9351, 67420931},
-	{9352, 2}, {9372, 50644739}, {9373, 50645507}, {9374, 50646275},
-	{9375, 50647043}, {9376, 50647811}, {9377, 50648579}, {9378, 50649347},
-	{9379, 50650115}, {9380, 50650883}, {9381, 50651651}, {9382, 50652419},
-	{9383, 50653187}, {9384, 50653955}, {9385, 50654723}, {9386, 50655491},
-	{9387, 50656259}, {9388, 50657027}, {9389, 50657795}, {9390, 50658563},
-	{9391, 50659331}, {9392, 50660099}, {9393, 50660867}, {9394, 50661635},
-	{9395, 50662403}, {9396, 50663171}, {9397, 50663939}, {9398, 16777219},
-	{9399, 16777475}, {9400, 16777731}, {9401, 16777987}, {9402, 16778243},
-	{9403, 16778499}, {9404, 16778755}, {9405, 16779011}, {9406, 16779267},
-	{9407, 16779523}, {9408, 16779779}, {9409, 16780035}, {9410, 16780291},
-	{9411, 16780547}, {9412, 16780803}, {9413, 16781059}, {9414, 16781315},
-	{9415, 16781571}, {9416, 16781827}, {9417, 16782083}, {9418, 16782339},
-	{9419, 16782595}, {9420, 16782851}, {9421, 16783107}, {9422, 16783363},
-	{9423, 16783619}, {9424, 16777219}, {9425, 16777475}, {9426, 16777731},
-	{9427, 16777987}, {9428, 16778243}, {9429, 16778499}, {9430, 16778755},
-	{9431, 16779011}, {9432, 16779267}, {9433, 16779523}, {9434, 16779779},
-	{9435, 16780035}, {9436, 16780291}, {9437, 16780547}, {9438, 16780803},
-	{9439, 16781059}, {9440, 16781315}, {9441, 16781571}, {9442, 16781827},
-	{9443, 16782083}, {9444, 16782339}, {9445, 16782595}, {9446, 16782851},
-	{9447, 16783107}, {9448, 16783363}, {9449, 16783619}, {9450, 17035267},
-	{9451, 1}, {10764, 67396099}, {10765, 1}, {10868, 50664707},
-	{10869, 33888259}, {10870, 50665219}, {10871, 1}, {10972, 33888771},
-	{10973, 1}, {11124, 2}, {11126, 1}, {11158, 2},
-	{11159, 1}, {11264, 17112067}, {11265, 17112323}, {11266, 17112579},
-	{11267, 17112835}, {11268, 17113091}, {11269, 17113347}, {11270, 17113603},
-	{11271, 17113859}, {11272, 17114115}, {11273, 17114371}, {11274, 17114627},
-	{11275, 17114883}, {11276, 17115139}, {11277, 17115395}, {11278, 17115651},
-	{11279, 17115907}, {11280, 17116163}, {11281, 17116419}, {11282, 17116675},
-	{11283, 17116931}, {11284, 17117187}, {11285, 17117443}, {11286, 17117699},
-	{11287, 17117955}, {11288, 17118211}, {11289, 17118467}, {11290, 17118723},
-	{11291, 17118979}, {11292, 17119235}, {11293, 17119491}, {11294, 17119747},
-	{11295, 17120003}, {11296, 17120259}, {11297, 17120515}, {11298, 17120771},
-	{11299, 17121027}, {11300, 17121283}, {11301, 17121539}, {11302, 17121795},
-	{11303, 17122051}, {11304, 17122307}, {11305, 17122563}, {11306, 17122819},
-	{11307, 17123075}, {11308, 17123331}, {11309, 17123587}, {11310, 17123843},
-	{11311, 17124099}, {11312, 1}, {11360, 17124355}, {11361, 1},
-	{11362, 17124611}, {11363, 17124867}, {11364, 17125123}, {11365, 1},
-	{11367, 17125379}, {11368, 1}, {11369, 17125635}, {11370, 1},
-	{11371, 17125891}, {11372, 1}, {11373, 16948483}, {11374, 16953091},
-	{11375, 16948227}, {11376, 16950275}, {11377, 1}, {11378, 17126147},
-	{11379, 1}, {11381, 17126403}, {11382, 1}, {11388, 16779523},
-	{11389, 16782595}, {11390, 17126659}, {11391, 17126915}, {11392, 17127171},
-	{11393, 1}, {11394, 17127427}, {11395, 1}, {11396, 17127683},
-	{11397, 1}, {11398, 17127939}, {11399, 1}, {11400, 17128195},
-	{11401, 1}, {11402, 17128451}, {11403, 1}, {11404, 17128707},
-	{11405, 1}, {11406, 17128963}, {11407, 1}, {11408, 17129219},
-	{11409, 1}, {11410, 17129475}, {11411, 1}, {11412, 17129731},
-	{11413, 1}, {11414, 17129987}, {11415, 1}, {11416, 17130243},
-	{11417, 1}, {11418, 17130499}, {11419, 1}, {11420, 17130755},
-	{11421, 1}, {11422, 17131011}, {11423, 1}, {11424, 17131267},
-	{11425, 1}, {11426, 17131523}, {11427, 1}, {11428, 17131779},
-	{11429, 1}, {11430, 17132035}, {11431, 1}, {11432, 17132291},
-	{11433, 1}, {11434, 17132547}, {11435, 1}, {11436, 17132803},
-	{11437, 1}, {11438, 17133059}, {11439, 1}, {11440, 17133315},
-	{11441, 1}, {11442, 17133571}, {11443, 1}, {11444, 17133827},
-	{11445, 1}, {11446, 17134083}, {11447, 1}, {11448, 17134339},
-	{11449, 1}, {11450, 17134595}, {11451, 1}, {11452, 17134851},
-	{11453, 1}, {11454, 17135107}, {11455, 1}, {11456, 17135363},
-	{11457, 1}, {11458, 17135619}, {11459, 1}, {11460, 17135875},
-	{11461, 1}, {11462, 17136131}, {11463, 1}, {11464, 17136387},
-	{11465, 1}, {11466, 17136643}, {11467, 1}, {11468, 17136899},
-	{11469, 1}, {11470, 17137155}, {11471, 1}, {11472, 17137411},
-	{11473, 1}, {11474, 17137667}, {11475, 1}, {11476, 17137923},
-	{11477, 1}, {11478, 17138179}, {11479, 1}, {11480, 17138435},
-	{11481, 1}, {11482, 17138691}, {11483, 1}, {11484, 17138947},
-	{11485, 1}, {11486, 17139203}, {11487, 1}, {11488, 17139459},
-	{11489, 1}, {11490, 17139715}, {11491, 1}, {11499, 17139971},
-	{11500, 1}, {11501, 17140227}, {11502, 1}, {11506, 17140483},
-	{11507, 1}, {11508, 2}, {11513, 1}, {11558, 2},
-	{11559, 1}, {11560, 2}, {11565, 1}, {11566, 2},
-	{11568, 1}, {11624, 2}, {11631, 17140739}, {11632, 1},
-	{11633, 2}, {11647, 1}, {11671, 2}, {11680, 1},
-	{11687, 2}, {11688, 1}, {11695, 2}, {11696, 1},
-	{11703, 2}, {11704, 1}, {11711, 2}, {11712, 1},
-	{11719, 2}, {11720, 1}, {11727, 2}, {11728, 1},
-	{11735, 2}, {11736, 1}, {11743, 2}, {11744, 1},
-	{11870, 2}, {11904, 1}, {11930, 2}, {11931, 1},
-	{11935, 17140995}, {11936, 1}, {12019, 17141251}, {12020, 2},
-	{12032, 17141507}, {12033, 17141763}, {12034, 17142019}, {12035, 17142275},
-	{12036, 17142531}, {12037, 17142787}, {12038, 17143043}, {12039, 17143299},
-	{12040, 17143555}, {12041, 17143811}, {12042, 17144067}, {12043, 17144323},
-	{12044, 17144579}, {12045, 17144835}, {12046, 17145091}, {12047, 17145347},
-	{12048, 17145603}, {12049, 17145859}, {12050, 17146115}, {12051, 17146371},
-	{12052, 17146627}, {12053, 17146883}, {12054, 17147139}, {12055, 17147395},
-	{12056, 17147651}, {12057, 17147907}, {12058, 17148163}, {12059, 17148419},
-	{12060, 17148675}, {12061, 17148931}, {12062, 17149187}, {12063, 17149443},
-	{12064, 17149699}, {12065, 17149955}, {12066, 17150211}, {12067, 17150467},
-	{12068, 17150723}, {12069, 17150979}, {12070, 17151235}, {12071, 17151491},
-	{12072, 17151747}, {12073, 17152003}, {12074, 17152259}, {12075, 17152515},
-	{12076, 17152771}, {12077, 17153027}, {12078, 17153283}, {12079, 17153539},
-	{12080, 17153795}, {12081, 17154051}, {12082, 17154307}, {12083, 17154563},
-	{12084, 17154819}, {12085, 17155075}, {12086, 17155331}, {12087, 17155587},
-	{12088, 17155843}, {12089, 17156099}, {12090, 17156355}, {12091, 17156611},
-	{12092, 17156867}, {12093, 17157123}, {12094, 17157379}, {12095, 17157635},
-	{12096, 17157891}, {12097, 17158147}, {12098, 17158403}, {12099, 17158659},
-	{12100, 17158915}, {12101, 17159171}, {12102, 17159427}, {12103, 17159683},
-	{12104, 17159939}, {12105, 17160195}, {12106, 17160451}, {12107, 17160707},
-	{12108, 17160963}, {12109, 17161219}, {12110, 17161475}, {12111, 17161731},
-	{12112, 17161987}, {12113, 17162243}, {12114, 17162499}, {12115, 17162755},
-	{12116, 17163011}, {12117, 17163267}, {12118, 17163523}, {12119, 17163779},
-	{12120, 17164035}, {12121, 17164291}, {12122, 17164547}, {12123, 17164803},
-	{12124, 17165059}, {12125, 17165315}, {12126, 17165571}, {12127, 17165827},
-	{12128, 17166083}, {12129, 17166339}, {12130, 17166595}, {12131, 17166851},
-	{12132, 17167107}, {12133, 17167363}, {12134, 17167619}, {12135, 17167875},
-	{12136, 17168131}, {12137, 17168387}, {12138, 17168643}, {12139, 17168899},
-	{12140, 17169155}, {12141, 17169411}, {12142, 17169667}, {12143, 17169923},
-	{12144, 17170179}, {12145, 17170435}, {12146, 17170691}, {12147, 17170947},
-	{12148, 17171203}, {12149, 17171459}, {12150, 17171715}, {12151, 17171971},
-	{12152, 17172227}, {12153, 17172483}, {12154, 17172739}, {12155, 17172995},
-	{12156, 17173251}, {12157, 17173507}, {12158, 17173763}, {12159, 17174019},
-	{12160, 17174275}, {12161, 17174531}, {12162, 17174787}, {12163, 17175043},
-	{12164, 17175299}, {12165, 17175555}, {12166, 17175811}, {12167, 17176067},
-	{12168, 17176323}, {12169, 17176579}, {12170, 17176835}, {12171, 17177091},
-	{12172, 17177347}, {12173, 17177603}, {12174, 17177859}, {12175, 17178115},
-	{12176, 17178371}, {12177, 17178627}, {12178, 17178883}, {12179, 17179139},
-	{12180, 17179395}, {12181, 17179651}, {12182, 17179907}, {12183, 17180163},
-	{12184, 17180419}, {12185, 17180675}, {12186, 17180931}, {12187, 17181187},
-	{12188, 17181443}, {12189, 17181699}, {12190, 17181955}, {12191, 17182211},
-	{12192, 17182467}, {12193, 17182723}, {12194, 17182979}, {12195, 17183235},
-	{12196, 17183491}, {12197, 17183747}, {12198, 17184003}, {12199, 17184259},
-	{12200, 17184515}, {12201, 17184771}, {12202, 17185027}, {12203, 17185283},
-	{12204, 17185539}, {12205, 17185795}, {12206, 17186051}, {12207, 17186307},
-	{12208, 17186563}, {12209, 17186819}, {12210, 17187075}, {12211, 17187331},
-	{12212, 17187587}, {12213, 17187843}, {12214, 17188099}, {12215, 17188355},
-	{12216, 17188611}, {12217, 17188867}, {12218, 17189123}, {12219, 17189379},
-	{12220, 17189635}, {12221, 17189891}, {12222, 17190147}, {12223, 17190403},
-	{12224, 17190659}, {12225, 17190915}, {12226, 17191171}, {12227, 17191427},
-	{12228, 17191683}, {12229, 17191939}, {12230, 17192195}, {12231, 17192451},
-	{12232, 17192707}, {12233, 17192963}, {12234, 17193219}, {12235, 17193475},
-	{12236, 17193731}, {12237, 17193987}, {12238, 17194243}, {12239, 17194499},
-	{12240, 17194755}, {12241, 17195011}, {12242, 17195267}, {12243, 17195523},
-	{12244, 17195779}, {12245, 17196035}, {12246, 2}, {12288, 16783875},
-	{12289, 1}, {12290, 17196291}, {12291, 1}, {12342, 17196547},
-	{12343, 1}, {12344, 17147395}, {12345, 17196803}, {12346, 17197059},
-	{12347, 1}, {12352, 2}, {12353, 1}, {12439, 2},
-	{12441, 1}, {12443, 33974531}, {12444, 33975043}, {12445, 1},
-	{12447, 33975555}, {12448, 1}, {12543, 33976067}, {12544, 2},
-	{12549, 1}, {12592, 2}, {12593, 17199363}, {12594, 17199619},
-	{12595, 17199875}, {12596, 17200131}, {12597, 17200387}, {12598, 17200643},
-	{12599, 17200899}, {12600, 17201155}, {12601, 17201411}, {12602, 17201667},
-	{12603, 17201923}, {12604, 17202179}, {12605, 17202435}, {12606, 17202691},
-	{12607, 17202947}, {12608, 17203203}, {12609, 17203459}, {12610, 17203715},
-	{12611, 17203971}, {12612, 17204227}, {12613, 17204483}, {12614, 17204739},
-	{12615, 17204995}, {12616, 17205251}, {12617, 17205507}, {12618, 17205763},
-	{12619, 17206019}, {12620, 17206275}, {12621, 17206531}, {12622, 17206787},
-	{12623, 17207043}, {12624, 17207299}, {12625, 17207555}, {12626, 17207811},
-	{12627, 17208067}, {12628, 17208323}, {12629, 17208579}, {12630, 17208835},
-	{12631, 17209091}, {12632, 17209347}, {12633, 17209603}, {12634, 17209859},
-	{12635, 17210115}, {12636, 17210371}, {12637, 17210627}, {12638, 17210883},
-	{12639, 17211139}, {12640, 17211395}, {12641, 17211651}, {12642, 17211907},
-	{12643, 17212163}, {12644, 2}, {12645, 17212419}, {12646, 17212675},
-	{12647, 17212931}, {12648, 17213187}, {12649, 17213443}, {12650, 17213699},
-	{12651, 17213955}, {12652, 17214211}, {12653, 17214467}, {12654, 17214723},
-	{12655, 17214979}, {12656, 17215235}, {12657, 17215491}, {12658, 17215747},
-	{12659, 17216003}, {12660, 17216259}, {12661, 17216515}, {12662, 17216771},
-	{12663, 17217027}, {12664, 17217283}, {12665, 17217539}, {12666, 17217795},
-	{12667, 17218051}, {12668, 17218307}, {12669, 17218563}, {12670, 17218819},
-	{12671, 17219075}, {12672, 17219331}, {12673, 17219587}, {12674, 17219843},
-	{12675, 17220099}, {12676, 17220355}, {12677, 17220611}, {12678, 17220867},
-	{12679, 17221123}, {12680, 17221379}, {12681, 17221635}, {12682, 17221891},
-	{12683, 17222147}, {12684, 17222403}, {12685, 17222659}, {12686, 17222915},
-	{12687, 2}, {12688, 1}, {12690, 17141507}, {12691, 17143043},
-	{12692, 17223171}, {12693, 17223427}, {12694, 17223683}, {12695, 17223939},
-	{12696, 17224195}, {12697, 17224451}, {12698, 17142531}, {12699, 17224707},
-	{12700, 17224963}, {12701, 17225219}, {12702, 17225475}, {12703, 17143555},
-	{12704, 1}, {12772, 2}, {12784, 1}, {12800, 50780163},
-	{12801, 50780931}, {12802, 50781699}, {12803, 50782467}, {12804, 50783235},
-	{12805, 50784003}, {12806, 50784771}, {12807, 50785539}, {12808, 50786307},
-	{12809, 50787075}, {12810, 50787843}, {12811, 50788611}, {12812, 50789379},
-	{12813, 50790147}, {12814, 50790915}, {12815, 50791683}, {12816, 50792451},
-	{12817, 50793219}, {12818, 50793987}, {12819, 50794755}, {12820, 50795523},
-	{12821, 50796291}, {12822, 50797059}, {12823, 50797827}, {12824, 50798595},
-	{12825, 50799363}, {12826, 50800131}, {12827, 50800899}, {12828, 50801667},
-	{12829, 67579651}, {12830, 67580675}, {12831, 2}, {12832, 50804483},
-	{12833, 50805251}, {12834, 50806019}, {12835, 50806787}, {12836, 50807555},
-	{12837, 50808323}, {12838, 50809091}, {12839, 50809859}, {12840, 50810627},
-	{12841, 50811395}, {12842, 50812163}, {12843, 50812931}, {12844, 50813699},
-	{12845, 50814467}, {12846, 50815235}, {12847, 50816003}, {12848, 50816771},
-	{12849, 50817539}, {12850, 50818307}, {12851, 50819075}, {12852, 50819843},
-	{12853, 50820611}, {12854, 50821379}, {12855, 50822147}, {12856, 50822915},
-	{12857, 50823683}, {12858, 50824451}, {12859, 50825219}, {12860, 50825987},
-	{12861, 50826755}, {12862, 50827523}, {12863, 50828291}, {12864, 50829059},
-	{12865, 50829827}, {12866, 50830595}, {12867, 50831363}, {12868, 17277699},
-	{12869, 17277955}, {12870, 17158403}, {12871, 17278211}, {12872, 1},
-	{12880, 50832899}, {12881, 33844995}, {12882, 34056451}, {12883, 33562371},
-	{12884, 34056963}, {12885, 34057475}, {12886, 34057987}, {12887, 34058499},
-	{12888, 34059011}, {12889, 34059523}, {12890, 34060035}, {12891, 33827075},
-	{12892, 33826307}, {12893, 34060547}, {12894, 34061059}, {12895, 34061571},
-	{12896, 17199363}, {12897, 17200131}, {12898, 17200899}, {12899, 17201411},
-	{12900, 17203459}, {12901, 17203715}, {12902, 17204483}, {12903, 17204995},
-	{12904, 17205251}, {12905, 17205763}, {12906, 17206019}, {12907, 17206275},
-	{12908, 17206531}, {12909, 17206787}, {12910, 17236739}, {12911, 17237507},
-	{12912, 17238275}, {12913, 17239043}, {12914, 17239811}, {12915, 17240579},
-	{12916, 17241347}, {12917, 17242115}, {12918, 17242883}, {12919, 17243651},
-	{12920, 17244419}, {12921, 17245187}, {12922, 17245955}, {12923, 17246723},
-	{12924, 34062083}, {12925, 34062595}, {12926, 17285891}, {12927, 1},
-	{12928, 17141507}, {12929, 17143043}, {12930, 17223171}, {12931, 17223427},
-	{12932, 17253379}, {12933, 17254147}, {12934, 17254915}, {12935, 17144323},
-	{12936, 17256451}, {12937, 17147395}, {12938, 17160195}, {12939, 17163267},
-	{12940, 17163011}, {12941, 17160451}, {12942, 17184003}, {12943, 17149443},
-	{12944, 17159683}, {12945, 17263363}, {12946, 17264131}, {12947, 17264899},
-	{12948, 17265667}, {12949, 17266435}, {12950, 17267203}, {12951, 17267971},
-	{12952, 17268739}, {12953, 17286147}, {12954, 17286403}, {12955, 17150979},
-	{12956, 17286659}, {12957, 17286915}, {12958, 17287171}, {12959, 17287427},
-	{12960, 17287683}, {12961, 17275651}, {12962, 17287939}, {12963, 17288195},
-	{12964, 17223683}, {12965, 17223939}, {12966, 17224195}, {12967, 17288451},
-	{12968, 17288707}, {12969, 17288963}, {12970, 17289219}, {12971, 17271043},
-	{12972, 17271811}, {12973, 17272579}, {12974, 17273347}, {12975, 17274115},
-	{12976, 17289475}, {12977, 34066947}, {12978, 34067459}, {12979, 34067971},
-	{12980, 34068483}, {12981, 34068995}, {12982, 33564931}, {12983, 34057219},
-	{12984, 34061315}, {12985, 34069507}, {12986, 34070019}, {12987, 34070531},
-	{12988, 34071043}, {12989, 34071555}, {12990, 34072067}, {12991, 34072579},
-	{12992, 34073091}, {12993, 34073603}, {12994, 34074115}, {12995, 34074627},
-	{12996, 34075139}, {12997, 34075651}, {12998, 34076163}, {12999, 34076675},
-	{13000, 34077187}, {13001, 50854915}, {13002, 50855683}, {13003, 50856451},
-	{13004, 34080003}, {13005, 50857731}, {13006, 34081283}, {13007, 50859011},
-	{13008, 17305347}, {13009, 17305603}, {13010, 17305859}, {13011, 17306115},
-	{13012, 17306371}, {13013, 17306627}, {13014, 17306883}, {13015, 17307139},
-	{13016, 17307395}, {13017, 17198851}, {13018, 17307651}, {13019, 17307907},
-	{13020, 17308163}, {13021, 17308419}, {13022, 17308675}, {13023, 17308931},
-	{13024, 17309187}, {13025, 17309443}, {13026, 17309699}, {13027, 17199107},
-	{13028, 17309955}, {13029, 17310211}, {13030, 17310467}, {13031, 17310723},
-	{13032, 17310979}, {13033, 17311235}, {13034, 17311491}, {13035, 17311747},
-	{13036, 17312003}, {13037, 17312259}, {13038, 17312515}, {13039, 17312771},
-	{13040, 17313027}, {13041, 17313283}, {13042, 17313539}, {13043, 17313795},
-	{13044, 17314051}, {13045, 17314307}, {13046, 17314563}, {13047, 17314819},
-	{13048, 17315075}, {13049, 17315331}, {13050, 17315587}, {13051, 17315843},
-	{13052, 17316099}, {13053, 17316355}, {13054, 17316611}, {13055, 34094083},
-	{13056, 67649027}, {13057, 67650051}, {13058, 67651075}, {13059, 50874883},
-	{13060, 67652867}, {13061, 50876675}, {13062, 50877443}, {13063, 84432643},
-	{13064, 67656707}, {13065, 50880515}, {13066, 50881283}, {13067, 50882051},
-	{13068, 67660035}, {13069, 67661059}, {13070, 50884867}, {13071, 50885635},
-	{13072, 34109187}, {13073, 50886915}, {13074, 67664899}, {13075, 67665923},
-	{13076, 34112515}, {13077, 84444675}, {13078, 101223171}, {13079, 84447491},
-	{13080, 50890755}, {13081, 84448771}, {13082, 84450051}, {13083, 67674115},
-	{13084, 50897923}, {13085, 50898691}, {13086, 50899459}, {13087, 67677443},
-	{13088, 84455683}, {13089, 67679747}, {13090, 50903555}, {13091, 50904323},
-	{13092, 50905091}, {13093, 34128643}, {13094, 34129155}, {13095, 34117891},
-	{13096, 34129667}, {13097, 50907395}, {13098, 50908163}, {13099, 84463363},
-	{13100, 50910211}, {13101, 67688195}, {13102, 84466435}, {13103, 50913283},
-	{13104, 34136835}, {13105, 34137347}, {13106, 84469507}, {13107, 67693571},
-	{13108, 84471811}, {13109, 50918659}, {13110, 84473859}, {13111, 34143491},
-	{13112, 50921219}, {13113, 50921987}, {13114, 50922755}, {13115, 50923523},
-	{13116, 50924291}, {13117, 67702275}, {13118, 50926083}, {13119, 34149635},
-	{13120, 50927363}, {13121, 50928131}, {13122, 50928899}, {13123, 67706883},
-	{13124, 50930691}, {13125, 50931459}, {13126, 50932227}, {13127, 84487427},
-	{13128, 67711491}, {13129, 34158083}, {13130, 84490243}, {13131, 34159875},
-	{13132, 67714819}, {13133, 67669251}, {13134, 50938627}, {13135, 50939395},
-	{13136, 50940163}, {13137, 67718147}, {13138, 34164739}, {13139, 50942467},
-	{13140, 67720451}, {13141, 34167043}, {13142, 84499203}, {13143, 50893571},
-	{13144, 34168835}, {13145, 34169347}, {13146, 34169859}, {13147, 34170371},
-	{13148, 34170883}, {13149, 34171395}, {13150, 34171907}, {13151, 34172419},
-	{13152, 34172931}, {13153, 34173443}, {13154, 50951171}, {13155, 50951939},
-	{13156, 50952707}, {13157, 50953475}, {13158, 50954243}, {13159, 50955011},
-	{13160, 50955779}, {13161, 50956547}, {13162, 50957315}, {13163, 50958083},
-	{13164, 50958851}, {13165, 50959619}, {13166, 50960387}, {13167, 50961155},
-	{13168, 50961923}, {13169, 50962691}, {13170, 34186243}, {13171, 34186755},
-	{13172, 50964483}, {13173, 34188035}, {13174, 34188547}, {13175, 34189059},
-	{13176, 50966787}, {13177, 50967555}, {13178, 34191107}, {13179, 34191619},
-	{13180, 34192131}, {13181, 34192643}, {13182, 34193155}, {13183, 67748099},
-	{13184, 34185731}, {13185, 34194691}, {13186, 34195203}, {13187, 34195715},
-	{13188, 34196227}, {13189, 34196739}, {13190, 34197251}, {13191, 34197763},
-	{13192, 50975491}, {13193, 67753475}, {13194, 34200067}, {13195, 34200579},
-	{13196, 34201091}, {13197, 34201603}, {13198, 34202115}, {13199, 34202627},
-	{13200, 34203139}, {13201, 50980867}, {13202, 50981635}, {13203, 50980099},
-	{13204, 50982403}, {13205, 34205955}, {13206, 34206467}, {13207, 34206979},
-	{13208, 33556995}, {13209, 34207491}, {13210, 34208003}, {13211, 34208515},
-	{13212, 34209027}, {13213, 34209539}, {13214, 34210051}, {13215, 50987779},
-	{13216, 50988547}, {13217, 34189827}, {13218, 50989315}, {13219, 50990083},
-	{13220, 50990851}, {13221, 34190595}, {13222, 50991619}, {13223, 50992387},
-	{13224, 67770371}, {13225, 34185731}, {13226, 50994179}, {13227, 50994947},
-	{13228, 50995715}, {13229, 50996483}, {13230, 84551683}, {13231, 101330179},
-	{13232, 34222851}, {13233, 34223363}, {13234, 34223875}, {13235, 34224387},
-	{13236, 34224899}, {13237, 34225411}, {13238, 34225923}, {13239, 34226435},
-	{13240, 34226947}, {13241, 34226435}, {13242, 34227459}, {13243, 34227971},
-	{13244, 34228483}, {13245, 34228995}, {13246, 34229507}, {13247, 34228995},
-	{13248, 34230019}, {13249, 34230531}, {13250, 2}, {13251, 34231043},
-	{13252, 33817091}, {13253, 33554947}, {13254, 67785987}, {13255, 2},
-	{13256, 34232579}, {13257, 34233091}, {13258, 34233603}, {13259, 34185475},
-	{13260, 34234115}, {13261, 34234627}, {13262, 34210051}, {13263, 34235139},
-	{13264, 33557251}, {13265, 34235651}, {13266, 51013379}, {13267, 34236931},
-	{13268, 34197251}, {13269, 51014659}, {13270, 51015427}, {13271, 34238979},
-	{13272, 2}, {13273, 51016707}, {13274, 34240259}, {13275, 34221059},
-	{13276, 34240771}, {13277, 34241283}, {13278, 51019011}, {13279, 51019779},
-	{13280, 34243331}, {13281, 34243843}, {13282, 34244355}, {13283, 34244867},
-	{13284, 34245379}, {13285, 34245891}, {13286, 34246403}, {13287, 34246915},
-	{13288, 34247427}, {13289, 51025155}, {13290, 51025923}, {13291, 51026691},
-	{13292, 51027459}, {13293, 51028227}, {13294, 51028995}, {13295, 51029763},
-	{13296, 51030531}, {13297, 51031299}, {13298, 51032067}, {13299, 51032835},
-	{13300, 51033603}, {13301, 51034371}, {13302, 51035139}, {13303, 51035907},
-	{13304, 51036675}, {13305, 51037443}, {13306, 51038211}, {13307, 51038979},
-	{13308, 51039747}, {13309, 51040515}, {13310, 51041283}, {13311, 51042051},
-	{13312, 1}, {42125, 2}, {42128, 1}, {42183, 2},
-	{42192, 1}, {42540, 2}, {42560, 17488387}, {42561, 1},
-	{42562, 17488643}, {42563, 1}, {42564, 17488899}, {42565, 1},
-	{42566, 17489155}, {42567, 1}, {42568, 17489411}, {42569, 1},
-	{42570, 16936451}, {42571, 1}, {42572, 17489667}, {42573, 1},
-	{42574, 17489923}, {42575, 1}, {42576, 17490179}, {42577, 1},
-	{42578, 17490435}, {42579, 1}, {42580, 17490691}, {42581, 1},
-	{42582, 17490947}, {42583, 1}, {42584, 17491203}, {42585, 1},
-	{42586, 17491459}, {42587, 1}, {42588, 17491715}, {42589, 1},
-	{42590, 17491971}, {42591, 1}, {42592, 17492227}, {42593, 1},
-	{42594, 17492483}, {42595, 1}, {42596, 17492739}, {42597, 1},
-	{42598, 17492995}, {42599, 1}, {42600, 17493251}, {42601, 1},
-	{42602, 17493507}, {42603, 1}, {42604, 17493763}, {42605, 1},
-	{42624, 17494019}, {42625, 1}, {42626, 17494275}, {42627, 1},
-	{42628, 17494531}, {42629, 1}, {42630, 17494787}, {42631, 1},
-	{42632, 17495043}, {42633, 1}, {42634, 17495299}, {42635, 1},
-	{42636, 17495555}, {42637, 1}, {42638, 17495811}, {42639, 1},
-	{42640, 17496067}, {42641, 1}, {42642, 17496323}, {42643, 1},
-	{42644, 17496579}, {42645, 1}, {42646, 17496835}, {42647, 1},
-	{42648, 17497091}, {42649, 1}, {42650, 17497347}, {42651, 1},
-	{42652, 16873219}, {42653, 16873731}, {42654, 1}, {42744, 2},
-	{42752, 1}, {42786, 17497603}, {42787, 1}, {42788, 17497859},
-	{42789, 1}, {42790, 17498115}, {42791, 1}, {42792, 17498371},
-	{42793, 1}, {42794, 17498627}, {42795, 1}, {42796, 17498883},
-	{42797, 1}, {42798, 17499139}, {42799, 1}, {42802, 17499395},
-	{42803, 1}, {42804, 17499651}, {42805, 1}, {42806, 17499907},
-	{42807, 1}, {42808, 17500163}, {42809, 1}, {42810, 17500419},
-	{42811, 1}, {42812, 17500675}, {42813, 1}, {42814, 17500931},
-	{42815, 1}, {42816, 17501187}, {42817, 1}, {42818, 17501443},
-	{42819, 1}, {42820, 17501699}, {42821, 1}, {42822, 17501955},
-	{42823, 1}, {42824, 17502211}, {42825, 1}, {42826, 17502467},
-	{42827, 1}, {42828, 17502723}, {42829, 1}, {42830, 17502979},
-	{42831, 1}, {42832, 17503235}, {42833, 1}, {42834, 17503491},
-	{42835, 1}, {42836, 17503747}, {42837, 1}, {42838, 17504003},
-	{42839, 1}, {42840, 17504259}, {42841, 1}, {42842, 17504515},
-	{42843, 1}, {42844, 17504771}, {42845, 1}, {42846, 17505027},
-	{42847, 1}, {42848, 17505283}, {42849, 1}, {42850, 17505539},
-	{42851, 1}, {42852, 17505795}, {42853, 1}, {42854, 17506051},
-	{42855, 1}, {42856, 17506307}, {42857, 1}, {42858, 17506563},
-	{42859, 1}, {42860, 17506819}, {42861, 1}, {42862, 17507075},
-	{42863, 1}, {42864, 17507075}, {42865, 1}, {42873, 17507331},
-	{42874, 1}, {42875, 17507587}, {42876, 1}, {42877, 17507843},
-	{42878, 17508099}, {42879, 1}, {42880, 17508355}, {42881, 1},
-	{42882, 17508611}, {42883, 1}, {42884, 17508867}, {42885, 1},
-	{42886, 17509123}, {42887, 1}, {42891, 17509379}, {42892, 1},
-	{42893, 16951299}, {42894, 1}, {42896, 17509635}, {42897, 1},
-	{42898, 17509891}, {42899, 1}, {42902, 17510147}, {42903, 1},
-	{42904, 17510403}, {42905, 1}, {42906, 17510659}, {42907, 1},
-	{42908, 17510915}, {42909, 1}, {42910, 17511171}, {42911, 1},
-	{42912, 17511427}, {42913, 1}, {42914, 17511683}, {42915, 1},
-	{42916, 17511939}, {42917, 1}, {42918, 17512195}, {42919, 1},
-	{42920, 17512451}, {42921, 1}, {42922, 16841475}, {42923, 16948995},
-	{42924, 16951043}, {42925, 17512707}, {42926, 16951555}, {42927, 1},
-	{42928, 17512963}, {42929, 17513219}, {42930, 16952067}, {42931, 17513475},
-	{42932, 17513731}, {42933, 1}, {42934, 17513987}, {42935, 1},
-	{42936, 17514243}, {42937, 1}, {42938, 17514499}, {42939, 1},
-	{42940, 17514755}, {42941, 1}, {42942, 17515011}, {42943, 1},
-	{42944, 17515267}, {42945, 1}, {42946, 17515523}, {42947, 1},
-	{42948, 17515779}, {42949, 16954371}, {42950, 17516035}, {42951, 17516291},
-	{42952, 1}, {42953, 17516547}, {42954, 1}, {42955, 2},
-	{42960, 17516803}, {42961, 1}, {42962, 2}, {42963, 1},
-	{42964, 2}, {42965, 1}, {42966, 17517059}, {42967, 1},
-	{42968, 17517315}, {42969, 1}, {42970, 2}, {42994, 16777731},
-	{42995, 16778499}, {42996, 16781315}, {42997, 17517571}, {42998, 1},
-	{43000, 16802051}, {43001, 16808195}, {43002, 1}, {43053, 2},
-	{43056, 1}, {43066, 2}, {43072, 1}, {43128, 2},
-	{43136, 1}, {43206, 2}, {43214, 1}, {43226, 2},
-	{43232, 1}, {43348, 2}, {43359, 1}, {43389, 2},
-	{43392, 1}, {43470, 2}, {43471, 1}, {43482, 2},
-	{43486, 1}, {43519, 2}, {43520, 1}, {43575, 2},
-	{43584, 1}, {43598, 2}, {43600, 1}, {43610, 2},
-	{43612, 1}, {43715, 2}, {43739, 1}, {43767, 2},
-	{43777, 1}, {43783, 2}, {43785, 1}, {43791, 2},
-	{43793, 1}, {43799, 2}, {43808, 1}, {43815, 2},
-	{43816, 1}, {43823, 2}, {43824, 1}, {43868, 17498115},
-	{43869, 17517827}, {43870, 17124611}, {43871, 17518083}, {43872, 1},
-	{43881, 17518339}, {43882, 1}, {43884, 2}, {43888, 17518595},
-	{43889, 17518851}, {43890, 17519107}, {43891, 17519363}, {43892, 17519619},
-	{43893, 17519875}, {43894, 17520131}, {43895, 17520387}, {43896, 17520643},
-	{43897, 17520899}, {43898, 17521155}, {43899, 17521411}, {43900, 17521667},
-	{43901, 17521923}, {43902, 17522179}, {43903, 17522435}, {43904, 17522691},
-	{43905, 17522947}, {43906, 17523203}, {43907, 17523459}, {43908, 17523715},
-	{43909, 17523971}, {43910, 17524227}, {43911, 17524483}, {43912, 17524739},
-	{43913, 17524995}, {43914, 17525251}, {43915, 17525507}, {43916, 17525763},
-	{43917, 17526019}, {43918, 17526275}, {43919, 17526531}, {43920, 17526787},
-	{43921, 17527043}, {43922, 17527299}, {43923, 17527555}, {43924, 17527811},
-	{43925, 17528067}, {43926, 17528323}, {43927, 17528579}, {43928, 17528835},
-	{43929, 17529091}, {43930, 17529347}, {43931, 17529603}, {43932, 17529859},
-	{43933, 17530115}, {43934, 17530371}, {43935, 17530627}, {43936, 17530883},
-	{43937, 17531139}, {43938, 17531395}, {43939, 17531651}, {43940, 17531907},
-	{43941, 17532163}, {43942, 17532419}, {43943, 17532675}, {43944, 17532931},
-	{43945, 17533187}, {43946, 17533443}, {43947, 17533699}, {43948, 17533955},
-	{43949, 17534211}, {43950, 17534467}, {43951, 17534723}, {43952, 17534979},
-	{43953, 17535235}, {43954, 17535491}, {43955, 17535747}, {43956, 17536003},
-	{43957, 17536259}, {43958, 17536515}, {43959, 17536771}, {43960, 17537027},
-	{43961, 17537283}, {43962, 17537539}, {43963, 17537795}, {43964, 17538051},
-	{43965, 17538307}, {43966, 17538563}, {43967, 17538819}, {43968, 1},
-	{44014, 2}, {44016, 1}, {44026, 2}, {44032, 1},
-	{55204, 2}, {55216, 1}, {55239, 2}, {55243, 1},
-	{55292, 2}, {63744, 17539075}, {63745, 17539331}, {63746, 17181955},
-	{63747, 17539587}, {63748, 17539843}, {63749, 17540099}, {63750, 17540355},
-	{63751, 17195779}, {63753, 17540611}, {63754, 17184003}, {63755, 17540867},
-	{63756, 17541123}, {63757, 17541379}, {63758, 17541635}, {63759, 17541891},
-	{63760, 17542147}, {63761, 17542403}, {63762, 17542659}, {63763, 17542915},
-	{63764, 17543171}, {63765, 17543427}, {63766, 17543683}, {63767, 17543939},
-	{63768, 17544195}, {63769, 17544451}, {63770, 17544707}, {63771, 17544963},
-	{63772, 17545219}, {63773, 17545475}, {63774, 17545731}, {63775, 17545987},
-	{63776, 17546243}, {63777, 17546499}, {63778, 17546755}, {63779, 17547011},
-	{63780, 17547267}, {63781, 17547523}, {63782, 17547779}, {63783, 17548035},
-	{63784, 17548291}, {63785, 17548547}, {63786, 17548803}, {63787, 17549059},
-	{63788, 17549315}, {63789, 17549571}, {63790, 17549827}, {63791, 17550083},
-	{63792, 17550339}, {63793, 17550595}, {63794, 17550851}, {63795, 17551107},
-	{63796, 17173251}, {63797, 17551363}, {63798, 17551619}, {63799, 17551875},
-	{63800, 17552131}, {63801, 17552387}, {63802, 17552643}, {63803, 17552899},
-	{63804, 17553155}, {63805, 17553411}, {63806, 17553667}, {63807, 17553923},
-	{63808, 17191939}, {63809, 17554179}, {63810, 17554435}, {63811, 17554691},
-	{63812, 17554947}, {63813, 17555203}, {63814, 17555459}, {63815, 17555715},
-	{63816, 17555971}, {63817, 17556227}, {63818, 17556483}, {63819, 17556739},
-	{63820, 17556995}, {63821, 17557251}, {63822, 17557507}, {63823, 17557763},
-	{63824, 17558019}, {63825, 17558275}, {63826, 17558531}, {63827, 17558787},
-	{63828, 17559043}, {63829, 17559299}, {63830, 17559555}, {63831, 17559811},
-	{63832, 17560067}, {63833, 17560323}, {63834, 17560579}, {63835, 17560835},
-	{63836, 17543171}, {63837, 17561091}, {63838, 17561347}, {63839, 17561603},
-	{63840, 17561859}, {63841, 17562115}, {63842, 17562371}, {63843, 17562627},
-	{63844, 17562883}, {63845, 17563139}, {63846, 17563395}, {63847, 17563651},
-	{63848, 17563907}, {63849, 17564163}, {63850, 17564419}, {63851, 17564675},
-	{63852, 17564931}, {63853, 17565187}, {63854, 17565443}, {63855, 17565699},
-	{63856, 17565955}, {63857, 17182467}, {63858, 17566211}, {63859, 17566467},
-	{63860, 17566723}, {63861, 17566979}, {63862, 17567235}, {63863, 17567491},
-	{63864, 17567747}, {63865, 17568003}, {63866, 17568259}, {63867, 17568515},
-	{63868, 17568771}, {63869, 17569027}, {63870, 17569283}, {63871, 17569539},
-	{63872, 17569795}, {63873, 17150979}, {63874, 17570051}, {63875, 17570307},
-	{63876, 17570563}, {63877, 17570819}, {63878, 17571075}, {63879, 17571331},
-	{63880, 17571587}, {63881, 17571843}, {63882, 17146115}, {63883, 17572099},
-	{63884, 17572355}, {63885, 17572611}, {63886, 17572867}, {63887, 17573123},
-	{63888, 17573379}, {63889, 17573635}, {63890, 17573891}, {63891, 17574147},
-	{63892, 17574403}, {63893, 17574659}, {63894, 17574915}, {63895, 17575171},
-	{63896, 17575427}, {63897, 17575683}, {63898, 17575939}, {63899, 17576195},
-	{63900, 17576451}, {63901, 17576707}, {63902, 17576963}, {63903, 17577219},
-	{63904, 17577475}, {63905, 17565699}, {63906, 17577731}, {63907, 17577987},
-	{63908, 17578243}, {63909, 17578499}, {63910, 17578755}, {63911, 17579011},
-	{63912, 17316867}, {63913, 17579267}, {63914, 17561603}, {63915, 17579523},
-	{63916, 17579779}, {63917, 17580035}, {63918, 17580291}, {63919, 17580547},
-	{63920, 17580803}, {63921, 17581059}, {63922, 17581315}, {63923, 17581571},
-	{63924, 17581827}, {63925, 17582083}, {63926, 17582339}, {63927, 17582595},
-	{63928, 17582851}, {63929, 17583107}, {63930, 17583363}, {63931, 17583619},
-	{63932, 17583875}, {63933, 17584131}, {63934, 17584387}, {63935, 17543171},
-	{63936, 17584643}, {63937, 17584899}, {63938, 17585155}, {63939, 17585411},
-	{63940, 17195523}, {63941, 17585667}, {63942, 17585923}, {63943, 17586179},
-	{63944, 17586435}, {63945, 17586691}, {63946, 17586947}, {63947, 17587203},
-	{63948, 17587459}, {63949, 17587715}, {63950, 17587971}, {63951, 17588227},
-	{63952, 17588483}, {63953, 17254147}, {63954, 17588739}, {63955, 17588995},
-	{63956, 17589251}, {63957, 17589507}, {63958, 17589763}, {63959, 17590019},
-	{63960, 17590275}, {63961, 17590531}, {63962, 17590787}, {63963, 17562115},
-	{63964, 17591043}, {63965, 17591299}, {63966, 17591555}, {63967, 17591811},
-	{63968, 17592067}, {63969, 17592323}, {63970, 17592579}, {63971, 17592835},
-	{63972, 17593091}, {63973, 17593347}, {63974, 17593603}, {63975, 17593859},
-	{63976, 17594115}, {63977, 17183747}, {63978, 17594371}, {63979, 17594627},
-	{63980, 17594883}, {63981, 17595139}, {63982, 17595395}, {63983, 17595651},
-	{63984, 17595907}, {63985, 17596163}, {63986, 17596419}, {63987, 17596675},
-	{63988, 17596931}, {63989, 17597187}, {63990, 17597443}, {63991, 17171203},
-	{63992, 17597699}, {63993, 17597955}, {63994, 17598211}, {63995, 17598467},
-	{63996, 17598723}, {63997, 17598979}, {63998, 17599235}, {63999, 17599491},
-	{64000, 17599747}, {64001, 17600003}, {64002, 17600259}, {64003, 17600515},
-	{64004, 17600771}, {64005, 17601027}, {64006, 17601283}, {64007, 17601539},
-	{64008, 17178115}, {64009, 17601795}, {64010, 17178883}, {64011, 17602051},
-	{64012, 17602307}, {64013, 17602563}, {64014, 1}, {64016, 17602819},
-	{64017, 1}, {64018, 17603075}, {64019, 1}, {64021, 17603331},
-	{64022, 17603587}, {64023, 17603843}, {64024, 17604099}, {64025, 17604355},
-	{64026, 17604611}, {64027, 17604867}, {64028, 17605123}, {64029, 17605379},
-	{64030, 17172995}, {64031, 1}, {64032, 17605635}, {64033, 1},
-	{64034, 17605891}, {64035, 1}, {64037, 17606147}, {64038, 17606403},
-	{64039, 1}, {64042, 17606659}, {64043, 17606915}, {64044, 17607171},
-	{64045, 17607427}, {64046, 17607683}, {64047, 17607939}, {64048, 17608195},
-	{64049, 17608451}, {64050, 17608707}, {64051, 17608963}, {64052, 17609219},
-	{64053, 17609475}, {64054, 17609731}, {64055, 17609987}, {64056, 17610243},
-	{64057, 17610499}, {64058, 17610755}, {64059, 17611011}, {64060, 17152771},
-	{64061, 17611267}, {64062, 17611523}, {64063, 17611779}, {64064, 17612035},
-	{64065, 17612291}, {64066, 17612547}, {64067, 17612803}, {64068, 17613059},
-	{64069, 17613315}, {64070, 17613571}, {64071, 17613827}, {64072, 17614083},
-	{64073, 17614339}, {64074, 17614595}, {64075, 17614851}, {64076, 17264899},
-	{64077, 17615107}, {64078, 17615363}, {64079, 17615619}, {64080, 17615875},
-	{64081, 17267971}, {64082, 17616131}, {64083, 17616387}, {64084, 17616643},
-	{64085, 17616899}, {64086, 17617155}, {64087, 17574915}, {64088, 17617411},
-	{64089, 17617667}, {64090, 17617923}, {64091, 17618179}, {64092, 17618435},
-	{64093, 17618691}, {64095, 17618947}, {64096, 17619203}, {64097, 17619459},
-	{64098, 17619715}, {64099, 17619971}, {64100, 17620227}, {64101, 17620483},
-	{64102, 17620739}, {64103, 17606147}, {64104, 17620995}, {64105, 17621251},
-	{64106, 17621507}, {64107, 17621763}, {64108, 17622019}, {64109, 17622275},
-	{64110, 2}, {64112, 17622531}, {64113, 17622787}, {64114, 17623043},
-	{64115, 17623299}, {64116, 17623555}, {64117, 17623811}, {64118, 17624067},
-	{64119, 17624323}, {64120, 17609731}, {64121, 17624579}, {64122, 17624835},
-	{64123, 17625091}, {64124, 17602819}, {64125, 17625347}, {64126, 17625603},
-	{64127, 17625859}, {64128, 17626115}, {64129, 17626371}, {64130, 17626627},
-	{64131, 17626883}, {64132, 17627139}, {64133, 17627395}, {64134, 17627651},
-	{64135, 17627907}, {64136, 17628163}, {64137, 17611779}, {64138, 17628419},
-	{64139, 17612035}, {64140, 17628675}, {64141, 17628931}, {64142, 17629187},
-	{64143, 17629443}, {64144, 17629699}, {64145, 17603075}, {64146, 17548547},
-	{64147, 17629955}, {64148, 17630211}, {64149, 17161219}, {64150, 17565955},
-	{64151, 17586947}, {64152, 17630467}, {64153, 17630723}, {64154, 17613827},
-	{64155, 17630979}, {64156, 17614083}, {64157, 17631235}, {64158, 17631491},
-	{64159, 17631747}, {64160, 17603587}, {64161, 17632003}, {64162, 17632259},
-	{64163, 17632515}, {64164, 17632771}, {64165, 17633027}, {64166, 17603843},
-	{64167, 17633283}, {64168, 17633539}, {64169, 17633795}, {64170, 17634051},
-	{64171, 17634307}, {64172, 17634563}, {64173, 17617155}, {64174, 17634819},
-	{64175, 17635075}, {64176, 17574915}, {64177, 17635331}, {64178, 17618179},
-	{64179, 17635587}, {64180, 17635843}, {64181, 17636099}, {64182, 17636355},
-	{64183, 17636611}, {64184, 17619459}, {64185, 17636867}, {64186, 17605891},
-	{64187, 17637123}, {64188, 17619715}, {64189, 17561091}, {64190, 17637379},
-	{64191, 17619971}, {64192, 17637635}, {64193, 17620483}, {64194, 17637891},
-	{64195, 17638147}, {64196, 17638403}, {64197, 17638659}, {64198, 17638915},
-	{64199, 17620995}, {64200, 17605123}, {64201, 17639171}, {64202, 17621251},
-	{64203, 17639427}, {64204, 17621507}, {64205, 17639683}, {64206, 17195779},
-	{64207, 17639939}, {64208, 17640195}, {64209, 17640451}, {64210, 17640707},
-	{64211, 17640963}, {64212, 17641219}, {64213, 17641475}, {64214, 17641731},
-	{64215, 17641987}, {64216, 17642243}, {64217, 17642499}, {64218, 2},
-	{64256, 34419971}, {64257, 34420483}, {64258, 34420995}, {64259, 51197443},
-	{64260, 51198723}, {64261, 33559043}, {64263, 2}, {64275, 34422275},
-	{64276, 34422787}, {64277, 34423299}, {64278, 34423811}, {64279, 34424323},
-	{64280, 2}, {64285, 34424835}, {64286, 1}, {64287, 34425347},
-	{64288, 17648643}, {64289, 17043971}, {64290, 17044739}, {64291, 17648899},
-	{64292, 17649155}, {64293, 17649411}, {64294, 17649667}, {64295, 17649923},
-	{64296, 17650179}, {64297, 17036803}, {64298, 34427651}, {64299, 34428163},
-	{64300, 51205891}, {64301, 51206659}, {64302, 34430211}, {64303, 34430723},
-	{64304, 34431235}, {64305, 34431747}, {64306, 34432259}, {64307, 34432771},
-	{64308, 34433283}, {64309, 34433795}, {64310, 34434307}, {64311, 2},
-	{64312, 34434819}, {64313, 34435331}, {64314, 34435843}, {64315, 34436355},
-	{64316, 34436867}, {64317, 2}, {64318, 34437379}, {64319, 2},
-	{64320, 34437891}, {64321, 34438403}, {64322, 2}, {64323, 34438915},
-	{64324, 34439427}, {64325, 2}, {64326, 34439939}, {64327, 34440451},
-	{64328, 34440963}, {64329, 34428675}, {64330, 34441475}, {64331, 34441987},
-	{64332, 34442499}, {64333, 34443011}, {64334, 34443523}, {64335, 34444035},
-	{64336, 17667331}, {64338, 17667587}, {64342, 17667843}, {64346, 17668099},
-	{64350, 17668355}, {64354, 17668611}, {64358, 17668867}, {64362, 17669123},
-	{64366, 17669379}, {64370, 17669635}, {64374, 17669891}, {64378, 17670147},
-	{64382, 17670403}, {64386, 17670659}, {64388, 17670915}, {64390, 17671171},
-	{64392, 17671427}, {64394, 17671683}, {64396, 17671939}, {64398, 17672195},
-	{64402, 17672451}, {64406, 17672707}, {64410, 17672963}, {64414, 17673219},
-	{64416, 17673475}, {64420, 17673731}, {64422, 17673987}, {64426, 17674243},
-	{64430, 17674499}, {64432, 17674755}, {64434, 1}, {64451, 2},
-	{64467, 17675011}, {64471, 16911363}, {64473, 17675267}, {64475, 17675523},
-	{64477, 33688579}, {64478, 17675779}, {64480, 17676035}, {64482, 17676291},
-	{64484, 17676547}, {64488, 17676803}, {64490, 34454275}, {64492, 34454787},
-	{64494, 34455299}, {64496, 34455811}, {64498, 34456323}, {64500, 34456835},
-	{64502, 34457347}, {64505, 34457859}, {64508, 17681155}, {64512, 34458627},
-	{64513, 34459139}, {64514, 34459651}, {64515, 34457859}, {64516, 34460163},
-	{64517, 34460675}, {64518, 34461187}, {64519, 34461699}, {64520, 34462211},
-	{64521, 34462723}, {64522, 34463235}, {64523, 34463747}, {64524, 34464259},
-	{64525, 34464771}, {64526, 34465283}, {64527, 34465795}, {64528, 34466307},
-	{64529, 34466819}, {64530, 34467331}, {64531, 34467843}, {64532, 34468355},
-	{64533, 34468867}, {64534, 34469379}, {64535, 34469123}, {64536, 34469891},
-	{64537, 34470403}, {64538, 34470915}, {64539, 34471427}, {64540, 34471939},
-	{64541, 34472451}, {64542, 34472963}, {64543, 34473475}, {64544, 34473987},
-	{64545, 34474499}, {64546, 34475011}, {64547, 34475523}, {64548, 34476035},
-	{64549, 34476547}, {64550, 34477059}, {64551, 34477571}, {64552, 34478083},
-	{64553, 34478595}, {64554, 34479107}, {64555, 34479619}, {64556, 34480131},
-	{64557, 34480643}, {64558, 34481155}, {64559, 34481667}, {64560, 34482179},
-	{64561, 34482691}, {64562, 34483203}, {64563, 34483715}, {64564, 34484227},
-	{64565, 34484739}, {64566, 34485251}, {64567, 34485763}, {64568, 34486275},
-	{64569, 34486787}, {64570, 34487299}, {64571, 34487811}, {64572, 34488323},
-	{64573, 34488835}, {64574, 34489347}, {64575, 34489859}, {64576, 34490371},
-	{64577, 34490883}, {64578, 34491395}, {64579, 34491907}, {64580, 34492419},
-	{64581, 34492931}, {64582, 34469635}, {64583, 34470147}, {64584, 34493443},
-	{64585, 34493955}, {64586, 34494467}, {64587, 34494979}, {64588, 34495491},
-	{64589, 34496003}, {64590, 34496515}, {64591, 34497027}, {64592, 34497539},
-	{64593, 34498051}, {64594, 34498563}, {64595, 34499075}, {64596, 34499587},
-	{64597, 34468611}, {64598, 34500099}, {64599, 34500611}, {64600, 34492675},
-	{64601, 34501123}, {64602, 34499843}, {64603, 34501635}, {64604, 34502147},
-	{64605, 34502659}, {64606, 51280387}, {64607, 51281155}, {64608, 51281923},
-	{64609, 51282691}, {64610, 51283459}, {64611, 51284227}, {64612, 34507779},
-	{64613, 34508291}, {64614, 34459651}, {64615, 34508803}, {64616, 34457859},
-	{64617, 34460163}, {64618, 34509315}, {64619, 34509827}, {64620, 34462211},
-	{64621, 34510339}, {64622, 34462723}, {64623, 34463235}, {64624, 34510851},
-	{64625, 34511363}, {64626, 34465283}, {64627, 34511875}, {64628, 34465795},
-	{64629, 34466307}, {64630, 34512387}, {64631, 34512899}, {64632, 34467331},
-	{64633, 34513411}, {64634, 34467843}, {64635, 34468355}, {64636, 34482691},
-	{64637, 34483203}, {64638, 34484739}, {64639, 34485251}, {64640, 34485763},
-	{64641, 34487811}, {64642, 34488323}, {64643, 34488835}, {64644, 34489347},
-	{64645, 34491395}, {64646, 34491907}, {64647, 34492419}, {64648, 34513923},
-	{64649, 34493443}, {64650, 34514435}, {64651, 34514947}, {64652, 34496515},
-	{64653, 34515459}, {64654, 34497027}, {64655, 34497539}, {64656, 34502659},
-	{64657, 34515971}, {64658, 34516483}, {64659, 34492675}, {64660, 34494723},
-	{64661, 34501123}, {64662, 34499843}, {64663, 34458627}, {64664, 34459139},
-	{64665, 34516995}, {64666, 34459651}, {64667, 34517507}, {64668, 34460675},
-	{64669, 34461187}, {64670, 34461699}, {64671, 34462211}, {64672, 34518019},
-	{64673, 34463747}, {64674, 34464259}, {64675, 34464771}, {64676, 34465283},
-	{64677, 34518531}, {64678, 34467331}, {64679, 34468867}, {64680, 34469379},
-	{64681, 34469123}, {64682, 34469891}, {64683, 34470403}, {64684, 34471427},
-	{64685, 34471939}, {64686, 34472451}, {64687, 34472963}, {64688, 34473475},
-	{64689, 34473987}, {64690, 34519043}, {64691, 34474499}, {64692, 34475011},
-	{64693, 34475523}, {64694, 34476035}, {64695, 34476547}, {64696, 34477059},
-	{64697, 34478083}, {64698, 34478595}, {64699, 34479107}, {64700, 34479619},
-	{64701, 34480131}, {64702, 34480643}, {64703, 34481155}, {64704, 34481667},
-	{64705, 34482179}, {64706, 34483715}, {64707, 34484227}, {64708, 34486275},
-	{64709, 34486787}, {64710, 34487299}, {64711, 34487811}, {64712, 34488323},
-	{64713, 34489859}, {64714, 34490371}, {64715, 34490883}, {64716, 34491395},
-	{64717, 34519555}, {64718, 34492931}, {64719, 34469635}, {64720, 34470147},
-	{64721, 34493443}, {64722, 34494979}, {64723, 34495491}, {64724, 34496003},
-	{64725, 34496515}, {64726, 34520067}, {64727, 34498051}, {64728, 34498563},
-	{64729, 34520579}, {64730, 34468611}, {64731, 34500099}, {64732, 34500611},
-	{64733, 34492675}, {64734, 34497795}, {64735, 34459651}, {64736, 34517507},
-	{64737, 34462211}, {64738, 34518019}, {64739, 34465283}, {64740, 34518531},
-	{64741, 34467331}, {64742, 34521091}, {64743, 34473475}, {64744, 34521603},
-	{64745, 34522115}, {64746, 34522627}, {64747, 34487811}, {64748, 34488323},
-	{64749, 34491395}, {64750, 34496515}, {64751, 34520067}, {64752, 34492675},
-	{64753, 34497795}, {64754, 51300355}, {64755, 51301123}, {64756, 51301891},
-	{64757, 34525443}, {64758, 34525955}, {64759, 34526467}, {64760, 34526979},
-	{64761, 34527491}, {64762, 34528003}, {64763, 34528515}, {64764, 34529027},
-	{64765, 34529539}, {64766, 34530051}, {64767, 34530563}, {64768, 34500355},
-	{64769, 34531075}, {64770, 34531587}, {64771, 34532099}, {64772, 34500867},
-	{64773, 34532611}, {64774, 34533123}, {64775, 34533635}, {64776, 34534147},
-	{64777, 34534659}, {64778, 34535171}, {64779, 34535683}, {64780, 34522115},
-	{64781, 34536195}, {64782, 34536707}, {64783, 34537219}, {64784, 34537731},
-	{64785, 34525443}, {64786, 34525955}, {64787, 34526467}, {64788, 34526979},
-	{64789, 34527491}, {64790, 34528003}, {64791, 34528515}, {64792, 34529027},
-	{64793, 34529539}, {64794, 34530051}, {64795, 34530563}, {64796, 34500355},
-	{64797, 34531075}, {64798, 34531587}, {64799, 34532099}, {64800, 34500867},
-	{64801, 34532611}, {64802, 34533123}, {64803, 34533635}, {64804, 34534147},
-	{64805, 34534659}, {64806, 34535171}, {64807, 34535683}, {64808, 34522115},
-	{64809, 34536195}, {64810, 34536707}, {64811, 34537219}, {64812, 34537731},
-	{64813, 34534659}, {64814, 34535171}, {64815, 34535683}, {64816, 34522115},
-	{64817, 34521603}, {64818, 34522627}, {64819, 34477571}, {64820, 34471939},
-	{64821, 34472451}, {64822, 34472963}, {64823, 34534659}, {64824, 34535171},
-	{64825, 34535683}, {64826, 34477571}, {64827, 34478083}, {64828, 34538243},
-	{64830, 1}, {64848, 51315971}, {64849, 51316739}, {64851, 51317507},
-	{64852, 51318275}, {64853, 51319043}, {64854, 51319811}, {64855, 51320579},
-	{64856, 51246595}, {64858, 51321347}, {64859, 51322115}, {64860, 51322883},
-	{64861, 51323651}, {64862, 51324419}, {64863, 51325187}, {64865, 51325955},
-	{64866, 51326723}, {64868, 51327491}, {64870, 51328259}, {64871, 51329027},
-	{64873, 51329795}, {64874, 51330563}, {64876, 51331331}, {64878, 51332099},
-	{64879, 51332867}, {64881, 51333635}, {64883, 51334403}, {64884, 51335171},
-	{64885, 51335939}, {64886, 51336707}, {64888, 51337475}, {64889, 51338243},
-	{64890, 51339011}, {64891, 51339779}, {64892, 51340547}, {64894, 51341315},
-	{64895, 51342083}, {64896, 51342851}, {64897, 51343619}, {64898, 51344387},
-	{64899, 51345155}, {64901, 51345923}, {64903, 51346691}, {64905, 51347459},
-	{64906, 51246851}, {64907, 51348227}, {64908, 51348995}, {64909, 51270147},
-	{64910, 51247363}, {64911, 51349763}, {64912, 2}, {64914, 51350531},
-	{64915, 51351299}, {64916, 51352067}, {64917, 51352835}, {64918, 51353603},
-	{64919, 51354371}, {64921, 51355139}, {64922, 51355907}, {64923, 51356675},
-	{64924, 51357443}, {64926, 51358211}, {64927, 51358979}, {64928, 51359747},
-	{64929, 51360515}, {64930, 51361283}, {64931, 51362051}, {64932, 51362819},
-	{64933, 51363587}, {64934, 51364355}, {64935, 51365123}, {64936, 51365891},
-	{64937, 51366659}, {64938, 51367427}, {64939, 51368195}, {64940, 51368963},
-	{64941, 51369731}, {64942, 51277315}, {64943, 51370499}, {64944, 51371267},
-	{64945, 51372035}, {64946, 51372803}, {64947, 51373571}, {64948, 51341315},
-	{64949, 51342851}, {64950, 51374339}, {64951, 51375107}, {64952, 51375875},
-	{64953, 51376643}, {64954, 51377411}, {64955, 51378179}, {64956, 51377411},
-	{64957, 51375875}, {64958, 51378947}, {64959, 51379715}, {64960, 51380483},
-	{64961, 51381251}, {64962, 51382019}, {64963, 51378179}, {64964, 51335939},
-	{64965, 51328259}, {64966, 51382787}, {64967, 51383555}, {64968, 2},
-	{64975, 1}, {64976, 2}, {65008, 51384323}, {65009, 51385091},
-	{65010, 68163075}, {65011, 68164099}, {65012, 68165123}, {65013, 68166147},
-	{65014, 68167171}, {65015, 68168195}, {65016, 68169219}, {65017, 51393027},
-	{65018, 303052035}, {65019, 135284483}, {65020, 68177667}, {65021, 1},
-	{65024, 0}, {65040, 17847043}, {65041, 17847299}, {65042, 2},
-	{65043, 17110275}, {65044, 16848643}, {65045, 17032707}, {65046, 17033731},
-	{65047, 17847555}, {65048, 17847811}, {65049, 2}, {65056, 1},
-	{65072, 2}, {65073, 17848067}, {65074, 17848323}, {65075, 17848579},
-	{65077, 17037571}, {65078, 17037827}, {65079, 17848835}, {65080, 17849091},
-	{65081, 17849347}, {65082, 17849603}, {65083, 17849859}, {65084, 17850115},
-	{65085, 17850371}, {65086, 17850627}, {65087, 17067011}, {65088, 17067267},
-	{65089, 17850883}, {65090, 17851139}, {65091, 17851395}, {65092, 17851651},
-	{65093, 1}, {65095, 17851907}, {65096, 17852163}, {65097, 33810435},
-	{65101, 17848579}, {65104, 17847043}, {65105, 17847299}, {65106, 2},
-	{65108, 16848643}, {65109, 17110275}, {65110, 17033731}, {65111, 17032707},
-	{65112, 17848067}, {65113, 17037571}, {65114, 17037827}, {65115, 17848835},
-	{65116, 17849091}, {65117, 17849347}, {65118, 17849603}, {65119, 17852419},
-	{65120, 17852675}, {65121, 17852931}, {65122, 17036803}, {65123, 17853187},
-	{65124, 17853443}, {65125, 17853699}, {65126, 17037315}, {65127, 2},
-	{65128, 17853955}, {65129, 17854211}, {65130, 17854467}, {65131, 17854723},
-	{65132, 2}, {65136, 34632195}, {65137, 34632707}, {65138, 34503171},
-	{65139, 1}, {65140, 34503939}, {65141, 2}, {65142, 34504707},
-	{65143, 34523139}, {65144, 34505475}, {65145, 34523907}, {65146, 34506243},
-	{65147, 34524675}, {65148, 34507011}, {65149, 34633219}, {65150, 34633731},
-	{65151, 34634243}, {65152, 17857539}, {65153, 17857795}, {65155, 17858051},
-	{65157, 17858307}, {65159, 17858563}, {65161, 17677059}, {65165, 16910339},
-	{65167, 17683459}, {65171, 17858819}, {65173, 17686531}, {65177, 17689603},
-	{65181, 17681667}, {65185, 17682179}, {65189, 17684739}, {65193, 17834243},
-	{65195, 17724419}, {65197, 17724931}, {65199, 17731331}, {65201, 17694723},
-	{65205, 17744899}, {65209, 17696771}, {65213, 17697795}, {65217, 17699843},
-	{65221, 17700867}, {65225, 17701379}, {65229, 17702403}, {65233, 17703427},
-	{65237, 17706499}, {65241, 17708547}, {65245, 17710851}, {65249, 17682691},
-	{65253, 17717763}, {65257, 17720835}, {65261, 16910851}, {65263, 17676803},
-	{65265, 16911875}, {65269, 34636291}, {65271, 34636803}, {65273, 34637315},
-	{65275, 34622211}, {65277, 2}, {65279, 0}, {65280, 2},
-	{65281, 17032707}, {65282, 17860611}, {65283, 17852419}, {65284, 17854211},
-	{65285, 17854467}, {65286, 17852675}, {65287, 17860867}, {65288, 17037571},
-	{65289, 17037827}, {65290, 17852931}, {65291, 17036803}, {65292, 17847043},
-	{65293, 17853187}, {65294, 17196291}, {65295, 17038339}, {65296, 17035267},
-	{65297, 16786947}, {65298, 16785155}, {65299, 16785411}, {65300, 16787715},
-	{65301, 17035523}, {65302, 17035779}, {65303, 17036035}, {65304, 17036291},
-	{65305, 17036547}, {65306, 17110275}, {65307, 16848643}, {65308, 17853443},
-	{65309, 17037315}, {65310, 17853699}, {65311, 17033731}, {65312, 17854723},
-	{65313, 16777219}, {65314, 16777475}, {65315, 16777731}, {65316, 16777987},
-	{65317, 16778243}, {65318, 16778499}, {65319, 16778755}, {65320, 16779011},
-	{65321, 16779267}, {65322, 16779523}, {65323, 16779779}, {65324, 16780035},
-	{65325, 16780291}, {65326, 16780547}, {65327, 16780803}, {65328, 16781059},
-	{65329, 16781315}, {65330, 16781571}, {65331, 16781827}, {65332, 16782083},
-	{65333, 16782339}, {65334, 16782595}, {65335, 16782851}, {65336, 16783107},
-	{65337, 16783363}, {65338, 16783619}, {65339, 17851907}, {65340, 17853955},
-	{65341, 17852163}, {65342, 17861123}, {65343, 17848579}, {65344, 17026819},
-	{65345, 16777219}, {65346, 16777475}, {65347, 16777731}, {65348, 16777987},
-	{65349, 16778243}, {65350, 16778499}, {65351, 16778755}, {65352, 16779011},
-	{65353, 16779267}, {65354, 16779523}, {65355, 16779779}, {65356, 16780035},
-	{65357, 16780291}, {65358, 16780547}, {65359, 16780803}, {65360, 16781059},
-	{65361, 16781315}, {65362, 16781571}, {65363, 16781827}, {65364, 16782083},
-	{65365, 16782339}, {65366, 16782595}, {65367, 16782851}, {65368, 16783107},
-	{65369, 16783363}, {65370, 16783619}, {65371, 17848835}, {65372, 17861379},
-	{65373, 17849091}, {65374, 17861635}, {65375, 17861891}, {65376, 17862147},
-	{65377, 17196291}, {65378, 17850883}, {65379, 17851139}, {65380, 17847299},
-	{65381, 17862403}, {65382, 17316611}, {65383, 17319171}, {65384, 17362179},
-	{65385, 17862659}, {65386, 17363715}, {65387, 17323267}, {65388, 17862915},
-	{65389, 17333507}, {65390, 17379331}, {65391, 17328899}, {65392, 17317891},
-	{65393, 17305347}, {65394, 17305603}, {65395, 17305859}, {65396, 17306115},
-	{65397, 17306371}, {65398, 17306627}, {65399, 17306883}, {65400, 17307139},
-	{65401, 17307395}, {65402, 17198851}, {65403, 17307651}, {65404, 17307907},
-	{65405, 17308163}, {65406, 17308419}, {65407, 17308675}, {65408, 17308931},
-	{65409, 17309187}, {65410, 17309443}, {65411, 17309699}, {65412, 17199107},
-	{65413, 17309955}, {65414, 17310211}, {65415, 17310467}, {65416, 17310723},
-	{65417, 17310979}, {65418, 17311235}, {65419, 17311491}, {65420, 17311747},
-	{65421, 17312003}, {65422, 17312259}, {65423, 17312515}, {65424, 17312771},
-	{65425, 17313027}, {65426, 17313283}, {65427, 17313539}, {65428, 17313795},
-	{65429, 17314051}, {65430, 17314307}, {65431, 17314563}, {65432, 17314819},
-	{65433, 17315075}, {65434, 17315331}, {65435, 17315587}, {65436, 17315843},
-	{65437, 17319683}, {65438, 17197571}, {65439, 17198083}, {65440, 2},
-	{65441, 17199363}, {65442, 17199619}, {65443, 17199875}, {65444, 17200131},
-	{65445, 17200387}, {65446, 17200643}, {65447, 17200899}, {65448, 17201155},
-	{65449, 17201411}, {65450, 17201667}, {65451, 17201923}, {65452, 17202179},
-	{65453, 17202435}, {65454, 17202691}, {65455, 17202947}, {65456, 17203203},
-	{65457, 17203459}, {65458, 17203715}, {65459, 17203971}, {65460, 17204227},
-	{65461, 17204483}, {65462, 17204739}, {65463, 17204995}, {65464, 17205251},
-	{65465, 17205507}, {65466, 17205763}, {65467, 17206019}, {65468, 17206275},
-	{65469, 17206531}, {65470, 17206787}, {65471, 2}, {65474, 17207043},
-	{65475, 17207299}, {65476, 17207555}, {65477, 17207811}, {65478, 17208067},
-	{65479, 17208323}, {65480, 2}, {65482, 17208579}, {65483, 17208835},
-	{65484, 17209091}, {65485, 17209347}, {65486, 17209603}, {65487, 17209859},
-	{65488, 2}, {65490, 17210115}, {65491, 17210371}, {65492, 17210627},
-	{65493, 17210883}, {65494, 17211139}, {65495, 17211395}, {65496, 2},
-	{65498, 17211651}, {65499, 17211907}, {65500, 17212163}, {65501, 2},
-	{65504, 17863171}, {65505, 17863427}, {65506, 17863683}, {65507, 33561859},
-	{65508, 17863939}, {65509, 17864195}, {65510, 17864451}, {65511, 2},
-	{65512, 17864707}, {65513, 17864963}, {65514, 17865219}, {65515, 17865475},
-	{65516, 17865731}, {65517, 17865987}, {65518, 17866243}, {65519, 2},
-	{65536, 1}, {65548, 2}, {65549, 1}, {65575, 2},
-	{65576, 1}, {65595, 2}, {65596, 1}, {65598, 2},
-	{65599, 1}, {65614, 2}, {65616, 1}, {65630, 2},
-	{65664, 1}, {65787, 2}, {65792, 1}, {65795, 2},
-	{65799, 1}, {65844, 2}, {65847, 1}, {65935, 2},
-	{65936, 1}, {65949, 2}, {65952, 1}, {65953, 2},
-	{66000, 1}, {66046, 2}, {66176, 1}, {66205, 2},
-	{66208, 1}, {66257, 2}, {66272, 1}, {66300, 2},
-	{66304, 1}, {66340, 2}, {66349, 1}, {66379, 2},
-	{66384, 1}, {66427, 2}, {66432, 1}, {66462, 2},
-	{66463, 1}, {66500, 2}, {66504, 1}, {66518, 2},
-	{66560, 17866499}, {66561, 17866755}, {66562, 17867011}, {66563, 17867267},
-	{66564, 17867523}, {66565, 17867779}, {66566, 17868035}, {66567, 17868291},
-	{66568, 17868547}, {66569, 17868803}, {66570, 17869059}, {66571, 17869315},
-	{66572, 17869571}, {66573, 17869827}, {66574, 17870083}, {66575, 17870339},
-	{66576, 17870595}, {66577, 17870851}, {66578, 17871107}, {66579, 17871363},
-	{66580, 17871619}, {66581, 17871875}, {66582, 17872131}, {66583, 17872387},
-	{66584, 17872643}, {66585, 17872899}, {66586, 17873155}, {66587, 17873411},
-	{66588, 17873667}, {66589, 17873923}, {66590, 17874179}, {66591, 17874435},
-	{66592, 17874691}, {66593, 17874947}, {66594, 17875203}, {66595, 17875459},
-	{66596, 17875715}, {66597, 17875971}, {66598, 17876227}, {66599, 17876483},
-	{66600, 1}, {66718, 2}, {66720, 1}, {66730, 2},
-	{66736, 17876739}, {66737, 17876995}, {66738, 17877251}, {66739, 17877507},
-	{66740, 17877763}, {66741, 17878019}, {66742, 17878275}, {66743, 17878531},
-	{66744, 17878787}, {66745, 17879043}, {66746, 17879299}, {66747, 17879555},
-	{66748, 17879811}, {66749, 17880067}, {66750, 17880323}, {66751, 17880579},
-	{66752, 17880835}, {66753, 17881091}, {66754, 17881347}, {66755, 17881603},
-	{66756, 17881859}, {66757, 17882115}, {66758, 17882371}, {66759, 17882627},
-	{66760, 17882883}, {66761, 17883139}, {66762, 17883395}, {66763, 17883651},
-	{66764, 17883907}, {66765, 17884163}, {66766, 17884419}, {66767, 17884675},
-	{66768, 17884931}, {66769, 17885187}, {66770, 17885443}, {66771, 17885699},
-	{66772, 2}, {66776, 1}, {66812, 2}, {66816, 1},
-	{66856, 2}, {66864, 1}, {66916, 2}, {66927, 1},
-	{66928, 17885955}, {66929, 17886211}, {66930, 17886467}, {66931, 17886723},
-	{66932, 17886979}, {66933, 17887235}, {66934, 17887491}, {66935, 17887747},
-	{66936, 17888003}, {66937, 17888259}, {66938, 17888515}, {66939, 2},
-	{66940, 17888771}, {66941, 17889027}, {66942, 17889283}, {66943, 17889539},
-	{66944, 17889795}, {66945, 17890051}, {66946, 17890307}, {66947, 17890563},
-	{66948, 17890819}, {66949, 17891075}, {66950, 17891331}, {66951, 17891587},
-	{66952, 17891843}, {66953, 17892099}, {66954, 17892355}, {66955, 2},
-	{66956, 17892611}, {66957, 17892867}, {66958, 17893123}, {66959, 17893379},
-	{66960, 17893635}, {66961, 17893891}, {66962, 17894147}, {66963, 2},
-	{66964, 17894403}, {66965, 17894659}, {66966, 2}, {66967, 1},
-	{66978, 2}, {66979, 1}, {66994, 2}, {66995, 1},
-	{67002, 2}, {67003, 1}, {67005, 2}, {67072, 1},
-	{67383, 2}, {67392, 1}, {67414, 2}, {67424, 1},
-	{67432, 2}, {67456, 1}, {67457, 17894915}, {67458, 17895171},
-	{67459, 16791043}, {67460, 17895427}, {67461, 16814083}, {67462, 2},
-	{67463, 17895683}, {67464, 17895939}, {67465, 17896195}, {67466, 17896451},
-	{67467, 16815363}, {67468, 16815619}, {67469, 17896707}, {67470, 17896963},
-	{67471, 17897219}, {67472, 17897475}, {67473, 17897731}, {67474, 17897987},
-	{67475, 16817155}, {67476, 17898243}, {67477, 16802051}, {67478, 17898499},
-	{67479, 17898755}, {67480, 17899011}, {67481, 17899267}, {67482, 17899523},
-	{67483, 17512707}, {67484, 17899779}, {67485, 17900035}, {67486, 17900291},
-	{67487, 17900547}, {67488, 17900803}, {67489, 17901059}, {67490, 16795395},
-	{67491, 17901315}, {67492, 17901571}, {67493, 16781315}, {67494, 17901827},
-	{67495, 17902083}, {67496, 17125123}, {67497, 17902339}, {67498, 16819971},
-	{67499, 17902595}, {67500, 17902851}, {67501, 17903107}, {67502, 17903363},
-	{67503, 16820995}, {67504, 17903619}, {67505, 2}, {67506, 17903875},
-	{67507, 17904131}, {67508, 17904387}, {67509, 17904643}, {67510, 17904899},
-	{67511, 17905155}, {67512, 17905411}, {67513, 17905667}, {67514, 17905923},
-	{67515, 2}, {67584, 1}, {67590, 2}, {67592, 1},
-	{67593, 2}, {67594, 1}, {67638, 2}, {67639, 1},
-	{67641, 2}, {67644, 1}, {67645, 2}, {67647, 1},
-	{67670, 2}, {67671, 1}, {67743, 2}, {67751, 1},
-	{67760, 2}, {67808, 1}, {67827, 2}, {67828, 1},
-	{67830, 2}, {67835, 1}, {67868, 2}, {67871, 1},
-	{67898, 2}, {67903, 1}, {67904, 2}, {67968, 1},
-	{68024, 2}, {68028, 1}, {68048, 2}, {68050, 1},
-	{68100, 2}, {68101, 1}, {68103, 2}, {68108, 1},
-	{68116, 2}, {68117, 1}, {68120, 2}, {68121, 1},
-	{68150, 2}, {68152, 1}, {68155, 2}, {68159, 1},
-	{68169, 2}, {68176, 1}, {68185, 2}, {68192, 1},
-	{68256, 2}, {68288, 1}, {68327, 2}, {68331, 1},
-	{68343, 2}, {68352, 1}, {68406, 2}, {68409, 1},
-	{68438, 2}, {68440, 1}, {68467, 2}, {68472, 1},
-	{68498, 2}, {68505, 1}, {68509, 2}, {68521, 1},
-	{68528, 2}, {68608, 1}, {68681, 2}, {68736, 17906179},
-	{68737, 17906435}, {68738, 17906691}, {68739, 17906947}, {68740, 17907203},
-	{68741, 17907459}, {68742, 17907715}, {68743, 17907971}, {68744, 17908227},
-	{68745, 17908483}, {68746, 17908739}, {68747, 17908995}, {68748, 17909251},
-	{68749, 17909507}, {68750, 17909763}, {68751, 17910019}, {68752, 17910275},
-	{68753, 17910531}, {68754, 17910787}, {68755, 17911043}, {68756, 17911299},
-	{68757, 17911555}, {68758, 17911811}, {68759, 17912067}, {68760, 17912323},
-	{68761, 17912579}, {68762, 17912835}, {68763, 17913091}, {68764, 17913347},
-	{68765, 17913603}, {68766, 17913859}, {68767, 17914115}, {68768, 17914371},
-	{68769, 17914627}, {68770, 17914883}, {68771, 17915139}, {68772, 17915395},
-	{68773, 17915651}, {68774, 17915907}, {68775, 17916163}, {68776, 17916419},
-	{68777, 17916675}, {68778, 17916931}, {68779, 17917187}, {68780, 17917443},
-	{68781, 17917699}, {68782, 17917955}, {68783, 17918211}, {68784, 17918467},
-	{68785, 17918723}, {68786, 17918979}, {68787, 2}, {68800, 1},
-	{68851, 2}, {68858, 1}, {68904, 2}, {68912, 1},
-	{68922, 2}, {69216, 1}, {69247, 2}, {69248, 1},
-	{69290, 2}, {69291, 1}, {69294, 2}, {69296, 1},
-	{69298, 2}, {69373, 1}, {69416, 2}, {69424, 1},
-	{69466, 2}, {69488, 1}, {69514, 2}, {69552, 1},
-	{69580, 2}, {69600, 1}, {69623, 2}, {69632, 1},
-	{69710, 2}, {69714, 1}, {69750, 2}, {69759, 1},
-	{69821, 2}, {69822, 1}, {69827, 2}, {69840, 1},
-	{69865, 2}, {69872, 1}, {69882, 2}, {69888, 1},
-	{69941, 2}, {69942, 1}, {69960, 2}, {69968, 1},
-	{70007, 2}, {70016, 1}, {70112, 2}, {70113, 1},
-	{70133, 2}, {70144, 1}, {70162, 2}, {70163, 1},
-	{70210, 2}, {70272, 1}, {70279, 2}, {70280, 1},
-	{70281, 2}, {70282, 1}, {70286, 2}, {70287, 1},
-	{70302, 2}, {70303, 1}, {70314, 2}, {70320, 1},
-	{70379, 2}, {70384, 1}, {70394, 2}, {70400, 1},
-	{70404, 2}, {70405, 1}, {70413, 2}, {70415, 1},
-	{70417, 2}, {70419, 1}, {70441, 2}, {70442, 1},
-	{70449, 2}, {70450, 1}, {70452, 2}, {70453, 1},
-	{70458, 2}, {70459, 1}, {70469, 2}, {70471, 1},
-	{70473, 2}, {70475, 1}, {70478, 2}, {70480, 1},
-	{70481, 2}, {70487, 1}, {70488, 2}, {70493, 1},
-	{70500, 2}, {70502, 1}, {70509, 2}, {70512, 1},
-	{70517, 2}, {70656, 1}, {70748, 2}, {70749, 1},
-	{70754, 2}, {70784, 1}, {70856, 2}, {70864, 1},
-	{70874, 2}, {71040, 1}, {71094, 2}, {71096, 1},
-	{71134, 2}, {71168, 1}, {71237, 2}, {71248, 1},
-	{71258, 2}, {71264, 1}, {71277, 2}, {71296, 1},
-	{71354, 2}, {71360, 1}, {71370, 2}, {71424, 1},
-	{71451, 2}, {71453, 1}, {71468, 2}, {71472, 1},
-	{71495, 2}, {71680, 1}, {71740, 2}, {71840, 17919235},
-	{71841, 17919491}, {71842, 17919747}, {71843, 17920003}, {71844, 17920259},
-	{71845, 17920515}, {71846, 17920771}, {71847, 17921027}, {71848, 17921283},
-	{71849, 17921539}, {71850, 17921795}, {71851, 17922051}, {71852, 17922307},
-	{71853, 17922563}, {71854, 17922819}, {71855, 17923075}, {71856, 17923331},
-	{71857, 17923587}, {71858, 17923843}, {71859, 17924099}, {71860, 17924355},
-	{71861, 17924611}, {71862, 17924867}, {71863, 17925123}, {71864, 17925379},
-	{71865, 17925635}, {71866, 17925891}, {71867, 17926147}, {71868, 17926403},
-	{71869, 17926659}, {71870, 17926915}, {71871, 17927171}, {71872, 1},
-	{71923, 2}, {71935, 1}, {71943, 2}, {71945, 1},
-	{71946, 2}, {71948, 1}, {71956, 2}, {71957, 1},
-	{71959, 2}, {71960, 1}, {71990, 2}, {71991, 1},
-	{71993, 2}, {71995, 1}, {72007, 2}, {72016, 1},
-	{72026, 2}, {72096, 1}, {72104, 2}, {72106, 1},
-	{72152, 2}, {72154, 1}, {72165, 2}, {72192, 1},
-	{72264, 2}, {72272, 1}, {72355, 2}, {72368, 1},
-	{72441, 2}, {72448, 1}, {72458, 2}, {72704, 1},
-	{72713, 2}, {72714, 1}, {72759, 2}, {72760, 1},
-	{72774, 2}, {72784, 1}, {72813, 2}, {72816, 1},
-	{72848, 2}, {72850, 1}, {72872, 2}, {72873, 1},
-	{72887, 2}, {72960, 1}, {72967, 2}, {72968, 1},
-	{72970, 2}, {72971, 1}, {73015, 2}, {73018, 1},
-	{73019, 2}, {73020, 1}, {73022, 2}, {73023, 1},
-	{73032, 2}, {73040, 1}, {73050, 2}, {73056, 1},
-	{73062, 2}, {73063, 1}, {73065, 2}, {73066, 1},
-	{73103, 2}, {73104, 1}, {73106, 2}, {73107, 1},
-	{73113, 2}, {73120, 1}, {73130, 2}, {73440, 1},
-	{73465, 2}, {73472, 1}, {73489, 2}, {73490, 1},
-	{73531, 2}, {73534, 1}, {73562, 2}, {73648, 1},
-	{73649, 2}, {73664, 1}, {73714, 2}, {73727, 1},
-	{74650, 2}, {74752, 1}, {74863, 2}, {74864, 1},
-	{74869, 2}, {74880, 1}, {75076, 2}, {77712, 1},
-	{77811, 2}, {77824, 1}, {78896, 2}, {78912, 1},
-	{78934, 2}, {82944, 1}, {83527, 2}, {92160, 1},
-	{92729, 2}, {92736, 1}, {92767, 2}, {92768, 1},
-	{92778, 2}, {92782, 1}, {92863, 2}, {92864, 1},
-	{92874, 2}, {92880, 1}, {92910, 2}, {92912, 1},
-	{92918, 2}, {92928, 1}, {92998, 2}, {93008, 1},
-	{93018, 2}, {93019, 1}, {93026, 2}, {93027, 1},
-	{93048, 2}, {93053, 1}, {93072, 2}, {93760, 17927427},
-	{93761, 17927683}, {93762, 17927939}, {93763, 17928195}, {93764, 17928451},
-	{93765, 17928707}, {93766, 17928963}, {93767, 17929219}, {93768, 17929475},
-	{93769, 17929731}, {93770, 17929987}, {93771, 17930243}, {93772, 17930499},
-	{93773, 17930755}, {93774, 17931011}, {93775, 17931267}, {93776, 17931523},
-	{93777, 17931779}, {93778, 17932035}, {93779, 17932291}, {93780, 17932547},
-	{93781, 17932803}, {93782, 17933059}, {93783, 17933315}, {93784, 17933571},
-	{93785, 17933827}, {93786, 17934083}, {93787, 17934339}, {93788, 17934595},
-	{93789, 17934851}, {93790, 17935107}, {93791, 17935363}, {93792, 1},
-	{93851, 2}, {93952, 1}, {94027, 2}, {94031, 1},
-	{94088, 2}, {94095, 1}, {94112, 2}, {94176, 1},
-	{94181, 2}, {94192, 1}, {94194, 2}, {94208, 1},
-	{100344, 2}, {100352, 1}, {101590, 2}, {101632, 1},
-	{101641, 2}, {110576, 1}, {110580, 2}, {110581, 1},
-	{110588, 2}, {110589, 1}, {110591, 2}, {110592, 1},
-	{110883, 2}, {110898, 1}, {110899, 2}, {110928, 1},
-	{110931, 2}, {110933, 1}, {110934, 2}, {110948, 1},
-	{110952, 2}, {110960, 1}, {111356, 2}, {113664, 1},
-	{113771, 2}, {113776, 1}, {113789, 2}, {113792, 1},
-	{113801, 2}, {113808, 1}, {113818, 2}, {113820, 1},
-	{113824, 0}, {113828, 2}, {118528, 1}, {118574, 2},
-	{118576, 1}, {118599, 2}, {118608, 1}, {118724, 2},
-	{118784, 1}, {119030, 2}, {119040, 1}, {119079, 2},
-	{119081, 1}, {119134, 34712835}, {119135, 34713347}, {119136, 51491075},
-	{119137, 51491843}, {119138, 51492611}, {119139, 51493379}, {119140, 51494147},
-	{119141, 1}, {119155, 2}, {119163, 1}, {119227, 34717699},
-	{119228, 34718211}, {119229, 51495939}, {119230, 51496707}, {119231, 51497475},
-	{119232, 51498243}, {119233, 1}, {119275, 2}, {119296, 1},
-	{119366, 2}, {119488, 1}, {119508, 2}, {119520, 1},
-	{119540, 2}, {119552, 1}, {119639, 2}, {119648, 1},
-	{119673, 2}, {119808, 16777219}, {119809, 16777475}, {119810, 16777731},
-	{119811, 16777987}, {119812, 16778243}, {119813, 16778499}, {119814, 16778755},
-	{119815, 16779011}, {119816, 16779267}, {119817, 16779523}, {119818, 16779779},
-	{119819, 16780035}, {119820, 16780291}, {119821, 16780547}, {119822, 16780803},
-	{119823, 16781059}, {119824, 16781315}, {119825, 16781571}, {119826, 16781827},
-	{119827, 16782083}, {119828, 16782339}, {119829, 16782595}, {119830, 16782851},
-	{119831, 16783107}, {119832, 16783363}, {119833, 16783619}, {119834, 16777219},
-	{119835, 16777475}, {119836, 16777731}, {119837, 16777987}, {119838, 16778243},
-	{119839, 16778499}, {119840, 16778755}, {119841, 16779011}, {119842, 16779267},
-	{119843, 16779523}, {119844, 16779779}, {119845, 16780035}, {119846, 16780291},
-	{119847, 16780547}, {119848, 16780803}, {119849, 16781059}, {119850, 16781315},
-	{119851, 16781571}, {119852, 16781827}, {119853, 16782083}, {119854, 16782339},
-	{119855, 16782595}, {119856, 16782851}, {119857, 16783107}, {119858, 16783363},
-	{119859, 16783619}, {119860, 16777219}, {119861, 16777475}, {119862, 16777731},
-	{119863, 16777987}, {119864, 16778243}, {119865, 16778499}, {119866, 16778755},
-	{119867, 16779011}, {119868, 16779267}, {119869, 16779523}, {119870, 16779779},
-	{119871, 16780035}, {119872, 16780291}, {119873, 16780547}, {119874, 16780803},
-	{119875, 16781059}, {119876, 16781315}, {119877, 16781571}, {119878, 16781827},
-	{119879, 16782083}, {119880, 16782339}, {119881, 16782595}, {119882, 16782851},
-	{119883, 16783107}, {119884, 16783363}, {119885, 16783619}, {119886, 16777219},
-	{119887, 16777475}, {119888, 16777731}, {119889, 16777987}, {119890, 16778243},
-	{119891, 16778499}, {119892, 16778755}, {119893, 2}, {119894, 16779267},
-	{119895, 16779523}, {119896, 16779779}, {119897, 16780035}, {119898, 16780291},
-	{119899, 16780547}, {119900, 16780803}, {119901, 16781059}, {119902, 16781315},
-	{119903, 16781571}, {119904, 16781827}, {119905, 16782083}, {119906, 16782339},
-	{119907, 16782595}, {119908, 16782851}, {119909, 16783107}, {119910, 16783363},
-	{119911, 16783619}, {119912, 16777219}, {119913, 16777475}, {119914, 16777731},
-	{119915, 16777987}, {119916, 16778243}, {119917, 16778499}, {119918, 16778755},
-	{119919, 16779011}, {119920, 16779267}, {119921, 16779523}, {119922, 16779779},
-	{119923, 16780035}, {119924, 16780291}, {119925, 16780547}, {119926, 16780803},
-	{119927, 16781059}, {119928, 16781315}, {119929, 16781571}, {119930, 16781827},
-	{119931, 16782083}, {119932, 16782339}, {119933, 16782595}, {119934, 16782851},
-	{119935, 16783107}, {119936, 16783363}, {119937, 16783619}, {119938, 16777219},
-	{119939, 16777475}, {119940, 16777731}, {119941, 16777987}, {119942, 16778243},
-	{119943, 16778499}, {119944, 16778755}, {119945, 16779011}, {119946, 16779267},
-	{119947, 16779523}, {119948, 16779779}, {119949, 16780035}, {119950, 16780291},
-	{119951, 16780547}, {119952, 16780803}, {119953, 16781059}, {119954, 16781315},
-	{119955, 16781571}, {119956, 16781827}, {119957, 16782083}, {119958, 16782339},
-	{119959, 16782595}, {119960, 16782851}, {119961, 16783107}, {119962, 16783363},
-	{119963, 16783619}, {119964, 16777219}, {119965, 2}, {119966, 16777731},
-	{119967, 16777987}, {119968, 2}, {119970, 16778755}, {119971, 2},
-	{119973, 16779523}, {119974, 16779779}, {119975, 2}, {119977, 16780547},
-	{119978, 16780803}, {119979, 16781059}, {119980, 16781315}, {119981, 2},
-	{119982, 16781827}, {119983, 16782083}, {119984, 16782339}, {119985, 16782595},
-	{119986, 16782851}, {119987, 16783107}, {119988, 16783363}, {119989, 16783619},
-	{119990, 16777219}, {119991, 16777475}, {119992, 16777731}, {119993, 16777987},
-	{119994, 2}, {119995, 16778499}, {119996, 2}, {119997, 16779011},
-	{119998, 16779267}, {119999, 16779523}, {120000, 16779779}, {120001, 16780035},
-	{120002, 16780291}, {120003, 16780547}, {120004, 2}, {120005, 16781059},
-	{120006, 16781315}, {120007, 16781571}, {120008, 16781827}, {120009, 16782083},
-	{120010, 16782339}, {120011, 16782595}, {120012, 16782851}, {120013, 16783107},
-	{120014, 16783363}, {120015, 16783619}, {120016, 16777219}, {120017, 16777475},
-	{120018, 16777731}, {120019, 16777987}, {120020, 16778243}, {120021, 16778499},
-	{120022, 16778755}, {120023, 16779011}, {120024, 16779267}, {120025, 16779523},
-	{120026, 16779779}, {120027, 16780035}, {120028, 16780291}, {120029, 16780547},
-	{120030, 16780803}, {120031, 16781059}, {120032, 16781315}, {120033, 16781571},
-	{120034, 16781827}, {120035, 16782083}, {120036, 16782339}, {120037, 16782595},
-	{120038, 16782851}, {120039, 16783107}, {120040, 16783363}, {120041, 16783619},
-	{120042, 16777219}, {120043, 16777475}, {120044, 16777731}, {120045, 16777987},
-	{120046, 16778243}, {120047, 16778499}, {120048, 16778755}, {120049, 16779011},
-	{120050, 16779267}, {120051, 16779523}, {120052, 16779779}, {120053, 16780035},
-	{120054, 16780291}, {120055, 16780547}, {120056, 16780803}, {120057, 16781059},
-	{120058, 16781315}, {120059, 16781571}, {120060, 16781827}, {120061, 16782083},
-	{120062, 16782339}, {120063, 16782595}, {120064, 16782851}, {120065, 16783107},
-	{120066, 16783363}, {120067, 16783619}, {120068, 16777219}, {120069, 16777475},
-	{120070, 2}, {120071, 16777987}, {120072, 16778243}, {120073, 16778499},
-	{120074, 16778755}, {120075, 2}, {120077, 16779523}, {120078, 16779779},
-	{120079, 16780035}, {120080, 16780291}, {120081, 16780547}, {120082, 16780803},
-	{120083, 16781059}, {120084, 16781315}, {120085, 2}, {120086, 16781827},
-	{120087, 16782083}, {120088, 16782339}, {120089, 16782595}, {120090, 16782851},
-	{120091, 16783107}, {120092, 16783363}, {120093, 2}, {120094, 16777219},
-	{120095, 16777475}, {120096, 16777731}, {120097, 16777987}, {120098, 16778243},
-	{120099, 16778499}, {120100, 16778755}, {120101, 16779011}, {120102, 16779267},
-	{120103, 16779523}, {120104, 16779779}, {120105, 16780035}, {120106, 16780291},
-	{120107, 16780547}, {120108, 16780803}, {120109, 16781059}, {120110, 16781315},
-	{120111, 16781571}, {120112, 16781827}, {120113, 16782083}, {120114, 16782339},
-	{120115, 16782595}, {120116, 16782851}, {120117, 16783107}, {120118, 16783363},
-	{120119, 16783619}, {120120, 16777219}, {120121, 16777475}, {120122, 2},
-	{120123, 16777987}, {120124, 16778243}, {120125, 16778499}, {120126, 16778755},
-	{120127, 2}, {120128, 16779267}, {120129, 16779523}, {120130, 16779779},
-	{120131, 16780035}, {120132, 16780291}, {120133, 2}, {120134, 16780803},
-	{120135, 2}, {120138, 16781827}, {120139, 16782083}, {120140, 16782339},
-	{120141, 16782595}, {120142, 16782851}, {120143, 16783107}, {120144, 16783363},
-	{120145, 2}, {120146, 16777219}, {120147, 16777475}, {120148, 16777731},
-	{120149, 16777987}, {120150, 16778243}, {120151, 16778499}, {120152, 16778755},
-	{120153, 16779011}, {120154, 16779267}, {120155, 16779523}, {120156, 16779779},
-	{120157, 16780035}, {120158, 16780291}, {120159, 16780547}, {120160, 16780803},
-	{120161, 16781059}, {120162, 16781315}, {120163, 16781571}, {120164, 16781827},
-	{120165, 16782083}, {120166, 16782339}, {120167, 16782595}, {120168, 16782851},
-	{120169, 16783107}, {120170, 16783363}, {120171, 16783619}, {120172, 16777219},
-	{120173, 16777475}, {120174, 16777731}, {120175, 16777987}, {120176, 16778243},
-	{120177, 16778499}, {120178, 16778755}, {120179, 16779011}, {120180, 16779267},
-	{120181, 16779523}, {120182, 16779779}, {120183, 16780035}, {120184, 16780291},
-	{120185, 16780547}, {120186, 16780803}, {120187, 16781059}, {120188, 16781315},
-	{120189, 16781571}, {120190, 16781827}, {120191, 16782083}, {120192, 16782339},
-	{120193, 16782595}, {120194, 16782851}, {120195, 16783107}, {120196, 16783363},
-	{120197, 16783619}, {120198, 16777219}, {120199, 16777475}, {120200, 16777731},
-	{120201, 16777987}, {120202, 16778243}, {120203, 16778499}, {120204, 16778755},
-	{120205, 16779011}, {120206, 16779267}, {120207, 16779523}, {120208, 16779779},
-	{120209, 16780035}, {120210, 16780291}, {120211, 16780547}, {120212, 16780803},
-	{120213, 16781059}, {120214, 16781315}, {120215, 16781571}, {120216, 16781827},
-	{120217, 16782083}, {120218, 16782339}, {120219, 16782595}, {120220, 16782851},
-	{120221, 16783107}, {120222, 16783363}, {120223, 16783619}, {120224, 16777219},
-	{120225, 16777475}, {120226, 16777731}, {120227, 16777987}, {120228, 16778243},
-	{120229, 16778499}, {120230, 16778755}, {120231, 16779011}, {120232, 16779267},
-	{120233, 16779523}, {120234, 16779779}, {120235, 16780035}, {120236, 16780291},
-	{120237, 16780547}, {120238, 16780803}, {120239, 16781059}, {120240, 16781315},
-	{120241, 16781571}, {120242, 16781827}, {120243, 16782083}, {120244, 16782339},
-	{120245, 16782595}, {120246, 16782851}, {120247, 16783107}, {120248, 16783363},
-	{120249, 16783619}, {120250, 16777219}, {120251, 16777475}, {120252, 16777731},
-	{120253, 16777987}, {120254, 16778243}, {120255, 16778499}, {120256, 16778755},
-	{120257, 16779011}, {120258, 16779267}, {120259, 16779523}, {120260, 16779779},
-	{120261, 16780035}, {120262, 16780291}, {120263, 16780547}, {120264, 16780803},
-	{120265, 16781059}, {120266, 16781315}, {120267, 16781571}, {120268, 16781827},
-	{120269, 16782083}, {120270, 16782339}, {120271, 16782595}, {120272, 16782851},
-	{120273, 16783107}, {120274, 16783363}, {120275, 16783619}, {120276, 16777219},
-	{120277, 16777475}, {120278, 16777731}, {120279, 16777987}, {120280, 16778243},
-	{120281, 16778499}, {120282, 16778755}, {120283, 16779011}, {120284, 16779267},
-	{120285, 16779523}, {120286, 16779779}, {120287, 16780035}, {120288, 16780291},
-	{120289, 16780547}, {120290, 16780803}, {120291, 16781059}, {120292, 16781315},
-	{120293, 16781571}, {120294, 16781827}, {120295, 16782083}, {120296, 16782339},
-	{120297, 16782595}, {120298, 16782851}, {120299, 16783107}, {120300, 16783363},
-	{120301, 16783619}, {120302, 16777219}, {120303, 16777475}, {120304, 16777731},
-	{120305, 16777987}, {120306, 16778243}, {120307, 16778499}, {120308, 16778755},
-	{120309, 16779011}, {120310, 16779267}, {120311, 16779523}, {120312, 16779779},
-	{120313, 16780035}, {120314, 16780291}, {120315, 16780547}, {120316, 16780803},
-	{120317, 16781059}, {120318, 16781315}, {120319, 16781571}, {120320, 16781827},
-	{120321, 16782083}, {120322, 16782339}, {120323, 16782595}, {120324, 16782851},
-	{120325, 16783107}, {120326, 16783363}, {120327, 16783619}, {120328, 16777219},
-	{120329, 16777475}, {120330, 16777731}, {120331, 16777987}, {120332, 16778243},
-	{120333, 16778499}, {120334, 16778755}, {120335, 16779011}, {120336, 16779267},
-	{120337, 16779523}, {120338, 16779779}, {120339, 16780035}, {120340, 16780291},
-	{120341, 16780547}, {120342, 16780803}, {120343, 16781059}, {120344, 16781315},
-	{120345, 16781571}, {120346, 16781827}, {120347, 16782083}, {120348, 16782339},
-	{120349, 16782595}, {120350, 16782851}, {120351, 16783107}, {120352, 16783363},
-	{120353, 16783619}, {120354, 16777219}, {120355, 16777475}, {120356, 16777731},
-	{120357, 16777987}, {120358, 16778243}, {120359, 16778499}, {120360, 16778755},
-	{120361, 16779011}, {120362, 16779267}, {120363, 16779523}, {120364, 16779779},
-	{120365, 16780035}, {120366, 16780291}, {120367, 16780547}, {120368, 16780803},
-	{120369, 16781059}, {120370, 16781315}, {120371, 16781571}, {120372, 16781827},
-	{120373, 16782083}, {120374, 16782339}, {120375, 16782595}, {120376, 16782851},
-	{120377, 16783107}, {120378, 16783363}, {120379, 16783619}, {120380, 16777219},
-	{120381, 16777475}, {120382, 16777731}, {120383, 16777987}, {120384, 16778243},
-	{120385, 16778499}, {120386, 16778755}, {120387, 16779011}, {120388, 16779267},
-	{120389, 16779523}, {120390, 16779779}, {120391, 16780035}, {120392, 16780291},
-	{120393, 16780547}, {120394, 16780803}, {120395, 16781059}, {120396, 16781315},
-	{120397, 16781571}, {120398, 16781827}, {120399, 16782083}, {120400, 16782339},
-	{120401, 16782595}, {120402, 16782851}, {120403, 16783107}, {120404, 16783363},
-	{120405, 16783619}, {120406, 16777219}, {120407, 16777475}, {120408, 16777731},
-	{120409, 16777987}, {120410, 16778243}, {120411, 16778499}, {120412, 16778755},
-	{120413, 16779011}, {120414, 16779267}, {120415, 16779523}, {120416, 16779779},
-	{120417, 16780035}, {120418, 16780291}, {120419, 16780547}, {120420, 16780803},
-	{120421, 16781059}, {120422, 16781315}, {120423, 16781571}, {120424, 16781827},
-	{120425, 16782083}, {120426, 16782339}, {120427, 16782595}, {120428, 16782851},
-	{120429, 16783107}, {120430, 16783363}, {120431, 16783619}, {120432, 16777219},
-	{120433, 16777475}, {120434, 16777731}, {120435, 16777987}, {120436, 16778243},
-	{120437, 16778499}, {120438, 16778755}, {120439, 16779011}, {120440, 16779267},
-	{120441, 16779523}, {120442, 16779779}, {120443, 16780035}, {120444, 16780291},
-	{120445, 16780547}, {120446, 16780803}, {120447, 16781059}, {120448, 16781315},
-	{120449, 16781571}, {120450, 16781827}, {120451, 16782083}, {120452, 16782339},
-	{120453, 16782595}, {120454, 16782851}, {120455, 16783107}, {120456, 16783363},
-	{120457, 16783619}, {120458, 16777219}, {120459, 16777475}, {120460, 16777731},
-	{120461, 16777987}, {120462, 16778243}, {120463, 16778499}, {120464, 16778755},
-	{120465, 16779011}, {120466, 16779267}, {120467, 16779523}, {120468, 16779779},
-	{120469, 16780035}, {120470, 16780291}, {120471, 16780547}, {120472, 16780803},
-	{120473, 16781059}, {120474, 16781315}, {120475, 16781571}, {120476, 16781827},
-	{120477, 16782083}, {120478, 16782339}, {120479, 16782595}, {120480, 16782851},
-	{120481, 16783107}, {120482, 16783363}, {120483, 16783619}, {120484, 17944579},
-	{120485, 17944835}, {120486, 2}, {120488, 16851715}, {120489, 16851971},
-	{120490, 16852227}, {120491, 16852483}, {120492, 16852739}, {120493, 16852995},
-	{120494, 16853251}, {120495, 16853507}, {120496, 16846851}, {120497, 16853763},
-	{120498, 16854019}, {120499, 16786179}, {120500, 16854275}, {120501, 16854531},
-	{120502, 16854787}, {120503, 16855043}, {120504, 16855299}, {120505, 16853507},
-	{120506, 16855555}, {120507, 16855811}, {120508, 16856067}, {120509, 16856323},
-	{120510, 16856579}, {120511, 16856835}, {120512, 16857091}, {120513, 17945091},
-	{120514, 16851715}, {120515, 16851971}, {120516, 16852227}, {120517, 16852483},
-	{120518, 16852739}, {120519, 16852995}, {120520, 16853251}, {120521, 16853507},
-	{120522, 16846851}, {120523, 16853763}, {120524, 16854019}, {120525, 16786179},
-	{120526, 16854275}, {120527, 16854531}, {120528, 16854787}, {120529, 16855043},
-	{120530, 16855299}, {120531, 16855555}, {120533, 16855811}, {120534, 16856067},
-	{120535, 16856323}, {120536, 16856579}, {120537, 16856835}, {120538, 16857091},
-	{120539, 17945347}, {120540, 16852739}, {120541, 16853507}, {120542, 16853763},
-	{120543, 16856323}, {120544, 16855299}, {120545, 16855043}, {120546, 16851715},
-	{120547, 16851971}, {120548, 16852227}, {120549, 16852483}, {120550, 16852739},
-	{120551, 16852995}, {120552, 16853251}, {120553, 16853507}, {120554, 16846851},
-	{120555, 16853763}, {120556, 16854019}, {120557, 16786179}, {120558, 16854275},
-	{120559, 16854531}, {120560, 16854787}, {120561, 16855043}, {120562, 16855299},
-	{120563, 16853507}, {120564, 16855555}, {120565, 16855811}, {120566, 16856067},
-	{120567, 16856323}, {120568, 16856579}, {120569, 16856835}, {120570, 16857091},
-	{120571, 17945091}, {120572, 16851715}, {120573, 16851971}, {120574, 16852227},
-	{120575, 16852483}, {120576, 16852739}, {120577, 16852995}, {120578, 16853251},
-	{120579, 16853507}, {120580, 16846851}, {120581, 16853763}, {120582, 16854019},
-	{120583, 16786179}, {120584, 16854275}, {120585, 16854531}, {120586, 16854787},
-	{120587, 16855043}, {120588, 16855299}, {120589, 16855555}, {120591, 16855811},
-	{120592, 16856067}, {120593, 16856323}, {120594, 16856579}, {120595, 16856835},
-	{120596, 16857091}, {120597, 17945347}, {120598, 16852739}, {120599, 16853507},
-	{120600, 16853763}, {120601, 16856323}, {120602, 16855299}, {120603, 16855043},
-	{120604, 16851715}, {120605, 16851971}, {120606, 16852227}, {120607, 16852483},
-	{120608, 16852739}, {120609, 16852995}, {120610, 16853251}, {120611, 16853507},
-	{120612, 16846851}, {120613, 16853763}, {120614, 16854019}, {120615, 16786179},
-	{120616, 16854275}, {120617, 16854531}, {120618, 16854787}, {120619, 16855043},
-	{120620, 16855299}, {120621, 16853507}, {120622, 16855555}, {120623, 16855811},
-	{120624, 16856067}, {120625, 16856323}, {120626, 16856579}, {120627, 16856835},
-	{120628, 16857091}, {120629, 17945091}, {120630, 16851715}, {120631, 16851971},
-	{120632, 16852227}, {120633, 16852483}, {120634, 16852739}, {120635, 16852995},
-	{120636, 16853251}, {120637, 16853507}, {120638, 16846851}, {120639, 16853763},
-	{120640, 16854019}, {120641, 16786179}, {120642, 16854275}, {120643, 16854531},
-	{120644, 16854787}, {120645, 16855043}, {120646, 16855299}, {120647, 16855555},
-	{120649, 16855811}, {120650, 16856067}, {120651, 16856323}, {120652, 16856579},
-	{120653, 16856835}, {120654, 16857091}, {120655, 17945347}, {120656, 16852739},
-	{120657, 16853507}, {120658, 16853763}, {120659, 16856323}, {120660, 16855299},
-	{120661, 16855043}, {120662, 16851715}, {120663, 16851971}, {120664, 16852227},
-	{120665, 16852483}, {120666, 16852739}, {120667, 16852995}, {120668, 16853251},
-	{120669, 16853507}, {120670, 16846851}, {120671, 16853763}, {120672, 16854019},
-	{120673, 16786179}, {120674, 16854275}, {120675, 16854531}, {120676, 16854787},
-	{120677, 16855043}, {120678, 16855299}, {120679, 16853507}, {120680, 16855555},
-	{120681, 16855811}, {120682, 16856067}, {120683, 16856323}, {120684, 16856579},
-	{120685, 16856835}, {120686, 16857091}, {120687, 17945091}, {120688, 16851715},
-	{120689, 16851971}, {120690, 16852227}, {120691, 16852483}, {120692, 16852739},
-	{120693, 16852995}, {120694, 16853251}, {120695, 16853507}, {120696, 16846851},
-	{120697, 16853763}, {120698, 16854019}, {120699, 16786179}, {120700, 16854275},
-	{120701, 16854531}, {120702, 16854787}, {120703, 16855043}, {120704, 16855299},
-	{120705, 16855555}, {120707, 16855811}, {120708, 16856067}, {120709, 16856323},
-	{120710, 16856579}, {120711, 16856835}, {120712, 16857091}, {120713, 17945347},
-	{120714, 16852739}, {120715, 16853507}, {120716, 16853763}, {120717, 16856323},
-	{120718, 16855299}, {120719, 16855043}, {120720, 16851715}, {120721, 16851971},
-	{120722, 16852227}, {120723, 16852483}, {120724, 16852739}, {120725, 16852995},
-	{120726, 16853251}, {120727, 16853507}, {120728, 16846851}, {120729, 16853763},
-	{120730, 16854019}, {120731, 16786179}, {120732, 16854275}, {120733, 16854531},
-	{120734, 16854787}, {120735, 16855043}, {120736, 16855299}, {120737, 16853507},
-	{120738, 16855555}, {120739, 16855811}, {120740, 16856067}, {120741, 16856323},
-	{120742, 16856579}, {120743, 16856835}, {120744, 16857091}, {120745, 17945091},
-	{120746, 16851715}, {120747, 16851971}, {120748, 16852227}, {120749, 16852483},
-	{120750, 16852739}, {120751, 16852995}, {120752, 16853251}, {120753, 16853507},
-	{120754, 16846851}, {120755, 16853763}, {120756, 16854019}, {120757, 16786179},
-	{120758, 16854275}, {120759, 16854531}, {120760, 16854787}, {120761, 16855043},
-	{120762, 16855299}, {120763, 16855555}, {120765, 16855811}, {120766, 16856067},
-	{120767, 16856323}, {120768, 16856579}, {120769, 16856835}, {120770, 16857091},
-	{120771, 17945347}, {120772, 16852739}, {120773, 16853507}, {120774, 16853763},
-	{120775, 16856323}, {120776, 16855299}, {120777, 16855043}, {120778, 16858627},
-	{120780, 2}, {120782, 17035267}, {120783, 16786947}, {120784, 16785155},
-	{120785, 16785411}, {120786, 16787715}, {120787, 17035523}, {120788, 17035779},
-	{120789, 17036035}, {120790, 17036291}, {120791, 17036547}, {120792, 17035267},
-	{120793, 16786947}, {120794, 16785155}, {120795, 16785411}, {120796, 16787715},
-	{120797, 17035523}, {120798, 17035779}, {120799, 17036035}, {120800, 17036291},
-	{120801, 17036547}, {120802, 17035267}, {120803, 16786947}, {120804, 16785155},
-	{120805, 16785411}, {120806, 16787715}, {120807, 17035523}, {120808, 17035779},
-	{120809, 17036035}, {120810, 17036291}, {120811, 17036547}, {120812, 17035267},
-	{120813, 16786947}, {120814, 16785155}, {120815, 16785411}, {120816, 16787715},
-	{120817, 17035523}, {120818, 17035779}, {120819, 17036035}, {120820, 17036291},
-	{120821, 17036547}, {120822, 17035267}, {120823, 16786947}, {120824, 16785155},
-	{120825, 16785411}, {120826, 16787715}, {120827, 17035523}, {120828, 17035779},
-	{120829, 17036035}, {120830, 17036291}, {120831, 17036547}, {120832, 1},
-	{121484, 2}, {121499, 1}, {121504, 2}, {121505, 1},
-	{121520, 2}, {122624, 1}, {122655, 2}, {122661, 1},
-	{122667, 2}, {122880, 1}, {122887, 2}, {122888, 1},
-	{122905, 2}, {122907, 1}, {122914, 2}, {122915, 1},
-	{122917, 2}, {122918, 1}, {122923, 2}, {122928, 16866563},
-	{122929, 16866819}, {122930, 16867075}, {122931, 16867331}, {122932, 16867587},
-	{122933, 16867843}, {122934, 16868099}, {122935, 16868355}, {122936, 16868611},
-	{122937, 16869123}, {122938, 16869379}, {122939, 16869635}, {122940, 16870147},
-	{122941, 16870403}, {122942, 16870659}, {122943, 16870915}, {122944, 16871171},
-	{122945, 16871427}, {122946, 16871683}, {122947, 16871939}, {122948, 16872195},
-	{122949, 16872451}, {122950, 16872707}, {122951, 16873475}, {122952, 16873987},
-	{122953, 16874243}, {122954, 17495043}, {122955, 16888835}, {122956, 16864003},
-	{122957, 16864515}, {122958, 16890883}, {122959, 16883715}, {122960, 17945603},
-	{122961, 16866563}, {122962, 16866819}, {122963, 16867075}, {122964, 16867331},
-	{122965, 16867587}, {122966, 16867843}, {122967, 16868099}, {122968, 16868355},
-	{122969, 16868611}, {122970, 16869123}, {122971, 16869379}, {122972, 16870147},
-	{122973, 16870403}, {122974, 16870915}, {122975, 16871427}, {122976, 16871683},
-	{122977, 16871939}, {122978, 16872195}, {122979, 16872451}, {122980, 16872707},
-	{122981, 16873219}, {122982, 16873475}, {122983, 16879875}, {122984, 16864003},
-	{122985, 16863747}, {122986, 16866307}, {122987, 16883203}, {122988, 17490179},
-	{122989, 16883971}, {122990, 2}, {123023, 1}, {123024, 2},
-	{123136, 1}, {123181, 2}, {123184, 1}, {123198, 2},
-	{123200, 1}, {123210, 2}, {123214, 1}, {123216, 2},
-	{123536, 1}, {123567, 2}, {123584, 1}, {123642, 2},
-	{123647, 1}, {123648, 2}, {124112, 1}, {124154, 2},
-	{124896, 1}, {124903, 2}, {124904, 1}, {124908, 2},
-	{124909, 1}, {124911, 2}, {124912, 1}, {124927, 2},
-	{124928, 1}, {125125, 2}, {125127, 1}, {125143, 2},
-	{125184, 17945859}, {125185, 17946115}, {125186, 17946371}, {125187, 17946627},
-	{125188, 17946883}, {125189, 17947139}, {125190, 17947395}, {125191, 17947651},
-	{125192, 17947907}, {125193, 17948163}, {125194, 17948419}, {125195, 17948675},
-	{125196, 17948931}, {125197, 17949187}, {125198, 17949443}, {125199, 17949699},
-	{125200, 17949955}, {125201, 17950211}, {125202, 17950467}, {125203, 17950723},
-	{125204, 17950979}, {125205, 17951235}, {125206, 17951491}, {125207, 17951747},
-	{125208, 17952003}, {125209, 17952259}, {125210, 17952515}, {125211, 17952771},
-	{125212, 17953027}, {125213, 17953283}, {125214, 17953539}, {125215, 17953795},
-	{125216, 17954051}, {125217, 17954307}, {125218, 1}, {125260, 2},
-	{125264, 1}, {125274, 2}, {125278, 1}, {125280, 2},
-	{126065, 1}, {126133, 2}, {126209, 1}, {126270, 2},
-	{126464, 16910339}, {126465, 17683459}, {126466, 17681667}, {126467, 17834243},
-	{126468, 2}, {126469, 16910851}, {126470, 17731331}, {126471, 17682179},
-	{126472, 17699843}, {126473, 16911875}, {126474, 17708547}, {126475, 17710851},
-	{126476, 17682691}, {126477, 17717763}, {126478, 17694723}, {126479, 17701379},
-	{126480, 17703427}, {126481, 17696771}, {126482, 17706499}, {126483, 17724931},
-	{126484, 17744899}, {126485, 17686531}, {126486, 17689603}, {126487, 17684739},
-	{126488, 17724419}, {126489, 17697795}, {126490, 17700867}, {126491, 17702403},
-	{126492, 17954563}, {126493, 17673219}, {126494, 17954819}, {126495, 17955075},
-	{126496, 2}, {126497, 17683459}, {126498, 17681667}, {126499, 2},
-	{126500, 17720835}, {126501, 2}, {126503, 17682179}, {126504, 2},
-	{126505, 16911875}, {126506, 17708547}, {126507, 17710851}, {126508, 17682691},
-	{126509, 17717763}, {126510, 17694723}, {126511, 17701379}, {126512, 17703427},
-	{126513, 17696771}, {126514, 17706499}, {126515, 2}, {126516, 17744899},
-	{126517, 17686531}, {126518, 17689603}, {126519, 17684739}, {126520, 2},
-	{126521, 17697795}, {126522, 2}, {126523, 17702403}, {126524, 2},
-	{126530, 17681667}, {126531, 2}, {126535, 17682179}, {126536, 2},
-	{126537, 16911875}, {126538, 2}, {126539, 17710851}, {126540, 2},
-	{126541, 17717763}, {126542, 17694723}, {126543, 17701379}, {126544, 2},
-	{126545, 17696771}, {126546, 17706499}, {126547, 2}, {126548, 17744899},
-	{126549, 2}, {126551, 17684739}, {126552, 2}, {126553, 17697795},
-	{126554, 2}, {126555, 17702403}, {126556, 2}, {126557, 17673219},
-	{126558, 2}, {126559, 17955075}, {126560, 2}, {126561, 17683459},
-	{126562, 17681667}, {126563, 2}, {126564, 17720835}, {126565, 2},
-	{126567, 17682179}, {126568, 17699843}, {126569, 16911875}, {126570, 17708547},
-	{126571, 2}, {126572, 17682691}, {126573, 17717763}, {126574, 17694723},
-	{126575, 17701379}, {126576, 17703427}, {126577, 17696771}, {126578, 17706499},
-	{126579, 2}, {126580, 17744899}, {126581, 17686531}, {126582, 17689603},
-	{126583, 17684739}, {126584, 2}, {126585, 17697795}, {126586, 17700867},
-	{126587, 17702403}, {126588, 17954563}, {126589, 2}, {126590, 17954819},
-	{126591, 2}, {126592, 16910339}, {126593, 17683459}, {126594, 17681667},
-	{126595, 17834243}, {126596, 17720835}, {126597, 16910851}, {126598, 17731331},
-	{126599, 17682179}, {126600, 17699843}, {126601, 16911875}, {126602, 2},
-	{126603, 17710851}, {126604, 17682691}, {126605, 17717763}, {126606, 17694723},
-	{126607, 17701379}, {126608, 17703427}, {126609, 17696771}, {126610, 17706499},
-	{126611, 17724931}, {126612, 17744899}, {126613, 17686531}, {126614, 17689603},
-	{126615, 17684739}, {126616, 17724419}, {126617, 17697795}, {126618, 17700867},
-	{126619, 17702403}, {126620, 2}, {126625, 17683459}, {126626, 17681667},
-	{126627, 17834243}, {126628, 2}, {126629, 16910851}, {126630, 17731331},
-	{126631, 17682179}, {126632, 17699843}, {126633, 16911875}, {126634, 2},
-	{126635, 17710851}, {126636, 17682691}, {126637, 17717763}, {126638, 17694723},
-	{126639, 17701379}, {126640, 17703427}, {126641, 17696771}, {126642, 17706499},
-	{126643, 17724931}, {126644, 17744899}, {126645, 17686531}, {126646, 17689603},
-	{126647, 17684739}, {126648, 17724419}, {126649, 17697795}, {126650, 17700867},
-	{126651, 17702403}, {126652, 2}, {126704, 1}, {126706, 2},
-	{126976, 1}, {127020, 2}, {127024, 1}, {127124, 2},
-	{127136, 1}, {127151, 2}, {127153, 1}, {127168, 2},
-	{127169, 1}, {127184, 2}, {127185, 1}, {127222, 2},
-	{127233, 34732547}, {127234, 34733059}, {127235, 34733571}, {127236, 34734083},
-	{127237, 34734595}, {127238, 34735107}, {127239, 34735619}, {127240, 34736131},
-	{127241, 34736643}, {127242, 34737155}, {127243, 1}, {127248, 50644739},
-	{127249, 50645507}, {127250, 50646275}, {127251, 50647043}, {127252, 50647811},
-	{127253, 50648579}, {127254, 50649347}, {127255, 50650115}, {127256, 50650883},
-	{127257, 50651651}, {127258, 50652419}, {127259, 50653187}, {127260, 50653955},
-	{127261, 50654723}, {127262, 50655491}, {127263, 50656259}, {127264, 50657027},
-	{127265, 50657795}, {127266, 50658563}, {127267, 50659331}, {127268, 50660099},
-	{127269, 50660867}, {127270, 50661635}, {127271, 50662403}, {127272, 50663171},
-	{127273, 50663939}, {127274, 51514883}, {127275, 16777731}, {127276, 16781571},
-	{127277, 33554947}, {127278, 34738435}, {127279, 1}, {127280, 16777219},
-	{127281, 16777475}, {127282, 16777731}, {127283, 16777987}, {127284, 16778243},
-	{127285, 16778499}, {127286, 16778755}, {127287, 16779011}, {127288, 16779267},
-	{127289, 16779523}, {127290, 16779779}, {127291, 16780035}, {127292, 16780291},
-	{127293, 16780547}, {127294, 16780803}, {127295, 16781059}, {127296, 16781315},
-	{127297, 16781571}, {127298, 16781827}, {127299, 16782083}, {127300, 16782339},
-	{127301, 16782595}, {127302, 16782851}, {127303, 16783107}, {127304, 16783363},
-	{127305, 16783619}, {127306, 34738947}, {127307, 34226435}, {127308, 34739459},
-	{127309, 34739971}, {127310, 51517699}, {127311, 34741251}, {127312, 1},
-	{127338, 34209283}, {127339, 34189315}, {127340, 34741763}, {127341, 1},
-	{127376, 34742275}, {127377, 1}, {127406, 2}, {127462, 1},
-	{127488, 34742787}, {127489, 34743299}, {127490, 17307651}, {127491, 2},
-	{127504, 17157635}, {127505, 17966595}, {127506, 17966851}, {127507, 17351427},
-	{127508, 17143043}, {127509, 17967107}, {127510, 17967363}, {127511, 17225219},
-	{127512, 17967619}, {127513, 17967875}, {127514, 17968131}, {127515, 17584387},
-	{127516, 17968387}, {127517, 17968643}, {127518, 17968899}, {127519, 17969155},
-	{127520, 17969411}, {127521, 17969667}, {127522, 17166851}, {127523, 17969923},
-	{127524, 17970179}, {127525, 17970435}, {127526, 17970691}, {127527, 17970947},
-	{127528, 17971203}, {127529, 17141507}, {127530, 17223171}, {127531, 17971459},
-	{127532, 17288451}, {127533, 17223939}, {127534, 17288707}, {127535, 17971715},
-	{127536, 17181187}, {127537, 17971971}, {127538, 17972227}, {127539, 17972483},
-	{127540, 17972739}, {127541, 17972995}, {127542, 17264131}, {127543, 17160195},
-	{127544, 17973251}, {127545, 17973507}, {127546, 17973763}, {127547, 17974019},
-	{127548, 2}, {127552, 51528707}, {127553, 51529475}, {127554, 51530243},
-	{127555, 51531011}, {127556, 51531779}, {127557, 51532547}, {127558, 51533315},
-	{127559, 51534083}, {127560, 51534851}, {127561, 2}, {127568, 17981187},
-	{127569, 17981443}, {127570, 2}, {127584, 1}, {127590, 2},
-	{127744, 1}, {128728, 2}, {128732, 1}, {128749, 2},
-	{128752, 1}, {128765, 2}, {128768, 1}, {128887, 2},
-	{128891, 1}, {128986, 2}, {128992, 1}, {129004, 2},
-	{129008, 1}, {129009, 2}, {129024, 1}, {129036, 2},
-	{129040, 1}, {129096, 2}, {129104, 1}, {129114, 2},
-	{129120, 1}, {129160, 2}, {129168, 1}, {129198, 2},
-	{129200, 1}, {129202, 2}, {129280, 1}, {129620, 2},
-	{129632, 1}, {129646, 2}, {129648, 1}, {129661, 2},
-	{129664, 1}, {129673, 2}, {129680, 1}, {129726, 2},
-	{129727, 1}, {129734, 2}, {129742, 1}, {129756, 2},
-	{129760, 1}, {129769, 2}, {129776, 1}, {129785, 2},
-	{129792, 1}, {129939, 2}, {129940, 1}, {129995, 2},
-	{130032, 17035267}, {130033, 16786947}, {130034, 16785155}, {130035, 16785411},
-	{130036, 16787715}, {130037, 17035523}, {130038, 17035779}, {130039, 17036035},
-	{130040, 17036291}, {130041, 17036547}, {130042, 2}, {131072, 1},
-	{173792, 2}, {173824, 1}, {177978, 2}, {177984, 1},
-	{178206, 2}, {178208, 1}, {183970, 2}, {183984, 1},
-	{191457, 2}, {191472, 1}, {192094, 2}, {194560, 17981699},
-	{194561, 17981955}, {194562, 17982211}, {194563, 17982467}, {194564, 17982723},
-	{194565, 17608195}, {194566, 17982979}, {194567, 17983235}, {194568, 17983491},
-	{194569, 17983747}, {194570, 17608451}, {194571, 17984003}, {194572, 17984259},
-	{194573, 17984515}, {194574, 17608707}, {194575, 17984771}, {194576, 17985027},
-	{194577, 17985283}, {194578, 17985539}, {194579, 17985795}, {194580, 17986051},
-	{194581, 17968899}, {194582, 17986307}, {194583, 17986563}, {194584, 17986819},
-	{194585, 17987075}, {194586, 17987331}, {194587, 17622787}, {194588, 17987587},
-	{194589, 17145603}, {194590, 17987843}, {194591, 17988099}, {194592, 17988355},
-	{194593, 17988611}, {194594, 17973507}, {194595, 17988867}, {194596, 17989123},
-	{194597, 17624067}, {194598, 17608963}, {194599, 17609219}, {194600, 17624323},
-	{194601, 17989379}, {194602, 17989635}, {194603, 17562627}, {194604, 17989891},
-	{194605, 17609475}, {194606, 17990147}, {194607, 17990403}, {194608, 17990659},
-	{194609, 17990915}, {194612, 17991171}, {194613, 17991427}, {194614, 17991683},
-	{194615, 17991939}, {194616, 17992195}, {194617, 17992451}, {194618, 17992707},
-	{194619, 17992963}, {194620, 17993219}, {194621, 17993475}, {194622, 17993731},
-	{194623, 17993987}, {194624, 17994243}, {194625, 17994499}, {194626, 17994755},
-	{194627, 17995011}, {194628, 17995267}, {194629, 17995523}, {194631, 17624835},
-	{194632, 17995779}, {194633, 17996035}, {194634, 17996291}, {194635, 17996547},
-	{194636, 17609987}, {194637, 17996803}, {194638, 17997059}, {194639, 17997315},
-	{194640, 17599747}, {194641, 17997571}, {194642, 17997827}, {194643, 17998083},
-	{194644, 17998339}, {194645, 17998595}, {194646, 17998851}, {194647, 17999107},
-	{194648, 17999363}, {194649, 17999619}, {194650, 17999875}, {194651, 18000131},
-	{194652, 18000387}, {194653, 17967107}, {194654, 18000643}, {194655, 18000899},
-	{194656, 18001155}, {194657, 18001411}, {194658, 18001667}, {194659, 18001923},
-	{194660, 18002179}, {194661, 18002435}, {194662, 18002691}, {194663, 18002947},
-	{194664, 2}, {194665, 18003203}, {194666, 18003459}, {194668, 18003715},
-	{194669, 18003971}, {194670, 18004227}, {194671, 17561603}, {194672, 18004483},
-	{194673, 18004739}, {194674, 18004995}, {194675, 18005251}, {194676, 2},
-	{194677, 17152259}, {194678, 18005507}, {194679, 18005763}, {194680, 17152771},
-	{194681, 18006019}, {194682, 18006275}, {194683, 18006531}, {194684, 18006787},
-	{194685, 18007043}, {194686, 18007299}, {194687, 18007555}, {194688, 18007811},
-	{194689, 18008067}, {194690, 18008323}, {194691, 18008579}, {194692, 18008835},
-	{194693, 18009091}, {194694, 18009347}, {194695, 18009603}, {194696, 18009859},
-	{194697, 18010115}, {194698, 18010371}, {194699, 18010627}, {194700, 18010883},
-	{194701, 18011139}, {194702, 17548291}, {194703, 18011395}, {194704, 17155331},
-	{194705, 18011651}, {194707, 18011907}, {194708, 18012163}, {194710, 18012419},
-	{194711, 18012675}, {194712, 18012931}, {194713, 18013187}, {194714, 18013443},
-	{194715, 18013699}, {194716, 18013955}, {194717, 18014211}, {194718, 18014467},
-	{194719, 18014723}, {194720, 18014979}, {194721, 18015235}, {194722, 18015491},
-	{194723, 17611267}, {194724, 18015747}, {194725, 18016003}, {194726, 18016259},
-	{194727, 18016515}, {194728, 17627907}, {194729, 18016515}, {194730, 18016771},
-	{194731, 17611779}, {194732, 18017027}, {194733, 18017283}, {194734, 18017539},
-	{194735, 18017795}, {194736, 17612035}, {194737, 17541379}, {194738, 17414659},
-	{194739, 18018051}, {194740, 18018307}, {194741, 18018563}, {194742, 18018819},
-	{194743, 18019075}, {194744, 18019331}, {194745, 18019587}, {194746, 18019843},
-	{194747, 18020099}, {194748, 18020355}, {194749, 18020611}, {194750, 18020867},
-	{194751, 18021123}, {194752, 18021379}, {194753, 18021635}, {194754, 18021891},
-	{194755, 18022147}, {194756, 18022403}, {194757, 18022659}, {194758, 18022915},
-	{194759, 18023171}, {194760, 17612291}, {194761, 18023427}, {194762, 18023683},
-	{194763, 18023939}, {194764, 18024195}, {194765, 18024451}, {194766, 18024707},
-	{194767, 17612803}, {194768, 18024963}, {194769, 18025219}, {194770, 18025475},
-	{194771, 18025731}, {194772, 18025987}, {194773, 18026243}, {194774, 18026499},
-	{194775, 18026755}, {194776, 17548547}, {194777, 17629955}, {194778, 18027011},
-	{194779, 18027267}, {194780, 18027523}, {194781, 18027779}, {194782, 18028035},
-	{194783, 18028291}, {194784, 18028547}, {194785, 18028803}, {194786, 17613059},
-	{194787, 18029059}, {194788, 18029315}, {194789, 18029571}, {194790, 18029827},
-	{194791, 17640707}, {194792, 18030083}, {194793, 18030339}, {194794, 18030595},
-	{194795, 18030851}, {194796, 18031107}, {194797, 18031363}, {194798, 18031619},
-	{194799, 18031875}, {194800, 18032131}, {194801, 18032387}, {194802, 18032643},
-	{194803, 18032899}, {194804, 18033155}, {194805, 17565955}, {194806, 18033411},
-	{194807, 18033667}, {194808, 18033923}, {194809, 18034179}, {194810, 18034435},
-	{194811, 18034691}, {194812, 18034947}, {194813, 18035203}, {194814, 18035459},
-	{194815, 18035715}, {194816, 18035971}, {194817, 17613315}, {194818, 17586947},
-	{194819, 18036227}, {194820, 18036483}, {194821, 18036739}, {194822, 18036995},
-	{194823, 18037251}, {194824, 18037507}, {194825, 18037763}, {194826, 18038019},
-	{194827, 17630723}, {194828, 18038275}, {194829, 18038531}, {194830, 18038787},
-	{194831, 18039043}, {194832, 18039299}, {194833, 18039555}, {194834, 18039811},
-	{194835, 18040067}, {194836, 17630979}, {194837, 18040323}, {194838, 18040579},
-	{194839, 18040835}, {194840, 18041091}, {194841, 18041347}, {194842, 18041603},
-	{194843, 18041859}, {194844, 18042115}, {194845, 18042371}, {194846, 18042627},
-	{194847, 2}, {194848, 18042883}, {194849, 17631491}, {194850, 18043139},
-	{194851, 18043395}, {194852, 18043651}, {194853, 18043907}, {194854, 18044163},
-	{194855, 18044419}, {194856, 18044675}, {194857, 18044931}, {194858, 18045187},
-	{194859, 18045443}, {194860, 18045699}, {194862, 18045955}, {194863, 18046211},
-	{194864, 17632003}, {194865, 18046467}, {194866, 18046723}, {194867, 18046979},
-	{194868, 18047235}, {194869, 18047491}, {194870, 18047747}, {194871, 18048003},
-	{194872, 17562371}, {194873, 18048259}, {194874, 18048515}, {194875, 18048771},
-	{194876, 18049027}, {194877, 18049283}, {194878, 18049539}, {194879, 18049795},
-	{194880, 17633539}, {194881, 18050051}, {194882, 18050307}, {194883, 18050563},
-	{194884, 18050819}, {194885, 18051075}, {194886, 18051331}, {194888, 17633795},
-	{194889, 17641219}, {194890, 18051587}, {194891, 18051843}, {194892, 18052099},
-	{194893, 18052355}, {194894, 18052611}, {194895, 17552899}, {194896, 17634307},
-	{194897, 18052867}, {194898, 18053123}, {194899, 17615875}, {194900, 18053379},
-	{194901, 18053635}, {194902, 17604867}, {194903, 18053891}, {194904, 18054147},
-	{194905, 17616643}, {194906, 18054403}, {194907, 18054659}, {194908, 18054915},
-	{194909, 18055171}, {194911, 2}, {194912, 18055427}, {194913, 18055683},
-	{194914, 18055939}, {194915, 18056195}, {194916, 18056451}, {194917, 18056707},
-	{194918, 18056963}, {194919, 18057219}, {194920, 18057475}, {194921, 18057731},
-	{194922, 18057987}, {194923, 18058243}, {194924, 18058499}, {194925, 18058755},
-	{194926, 18059011}, {194927, 18059267}, {194928, 18059523}, {194929, 18059779},
-	{194930, 18060035}, {194931, 18060291}, {194932, 18060547}, {194933, 18060803},
-	{194934, 18061059}, {194935, 18061315}, {194936, 18061571}, {194937, 18061827},
-	{194938, 17618179}, {194939, 18062083}, {194940, 18062339}, {194941, 18062595},
-	{194942, 18062851}, {194943, 18063107}, {194944, 18063363}, {194945, 18063619},
-	{194946, 18063875}, {194947, 18064131}, {194948, 18064387}, {194949, 18064643},
-	{194950, 18064899}, {194951, 18065155}, {194952, 18065411}, {194953, 18065667},
-	{194954, 18065923}, {194955, 18011907}, {194956, 18066179}, {194957, 18066435},
-	{194958, 18066691}, {194959, 18066947}, {194960, 18067203}, {194961, 18067459},
-	{194962, 18067715}, {194963, 18067971}, {194964, 18068227}, {194965, 18068483},
-	{194966, 18068739}, {194967, 18068995}, {194968, 17566723}, {194969, 18069251},
-	{194970, 18069507}, {194971, 18069763}, {194972, 18070019}, {194973, 18070275},
-	{194974, 18070531}, {194975, 17618947}, {194976, 18070787}, {194977, 18071043},
-	{194978, 18071299}, {194979, 18071555}, {194980, 18071811}, {194981, 18072067},
-	{194982, 18072323}, {194983, 18072579}, {194984, 18072835}, {194985, 18073091},
-	{194986, 18073347}, {194987, 18073603}, {194988, 18073859}, {194989, 18074115},
-	{194990, 18074371}, {194991, 18074627}, {194992, 18074883}, {194993, 18075139},
-	{194994, 18075395}, {194995, 18075651}, {194996, 17551619}, {194997, 18075907},
-	{194998, 18076163}, {194999, 18076419}, {195000, 18076675}, {195001, 18076931},
-	{195002, 18077187}, {195003, 17636099}, {195004, 18077443}, {195005, 18077699},
-	{195006, 18077955}, {195007, 2}, {195008, 18078211}, {195009, 18078467},
-	{195010, 18078723}, {195011, 18078979}, {195012, 17178371}, {195013, 18079235},
-	{195014, 18079491}, {195015, 18079747}, {195016, 18080003}, {195017, 18080259},
-	{195018, 18080515}, {195019, 18080771}, {195020, 18081027}, {195021, 18081283},
-	{195022, 18081539}, {195023, 18081795}, {195024, 17637379}, {195025, 17637635},
-	{195026, 17180163}, {195027, 18082051}, {195028, 18082307}, {195029, 18082563},
-	{195030, 18082819}, {195031, 18083075}, {195032, 18083331}, {195033, 18083587},
-	{195034, 18083843}, {195035, 18084099}, {195036, 18084355}, {195037, 18084611},
-	{195038, 18084867}, {195039, 17637891}, {195040, 18085123}, {195041, 18085379},
-	{195042, 18085635}, {195043, 18085891}, {195044, 18086147}, {195045, 18086403},
-	{195046, 18086659}, {195047, 18086915}, {195048, 18087171}, {195049, 18087427},
-	{195050, 18087683}, {195051, 18087939}, {195052, 18088195}, {195053, 18088451},
-	{195054, 18088707}, {195055, 18088963}, {195056, 18089219}, {195057, 18089475},
-	{195058, 18089731}, {195059, 18089987}, {195060, 18090243}, {195061, 18090499},
-	{195062, 18090755}, {195063, 18091011}, {195064, 18091267}, {195065, 18091523},
-	{195066, 18091779}, {195067, 18092035}, {195068, 18092291}, {195069, 18092547},
-	{195070, 17639427}, {195072, 18092803}, {195073, 18093059}, {195074, 18093315},
-	{195075, 18093571}, {195076, 18093827}, {195077, 18094083}, {195078, 18094339},
-	{195079, 18094595}, {195080, 18094851}, {195081, 18095107}, {195082, 17639683},
-	{195083, 18095363}, {195084, 18095619}, {195085, 18095875}, {195086, 18096131},
-	{195087, 18096387}, {195088, 18096643}, {195089, 18096899}, {195090, 18097155},
-	{195091, 18097411}, {195092, 18097667}, {195093, 17192451}, {195094, 18097923},
-	{195095, 17193475}, {195096, 18098179}, {195097, 18098435}, {195098, 18098691},
-	{195099, 18098947}, {195100, 17194755}, {195101, 18099203}, {195102, 2},
-	{196608, 1}, {201547, 2}, {201552, 1}, {205744, 2},
-	{917760, 0}, {918000, 2}
-};
-
-
-} // namespace ada::idna
-#endif // ADA_IDNA_TABLES_H
-/* end file src/mapping_tables.cpp */
-
-namespace ada::idna {
-
-// This can be greatly accelerated. For now we just use a simply
-// binary search. In practice, you should *not* do that.
-uint32_t find_range_index(uint32_t key) {
-  ////////////////
-  // This could be implemented with std::lower_bound, but we roll our own
-  // because we want to allow further optimizations in the future.
-  ////////////////
-  uint32_t len = std::size(table);
-  uint32_t low = 0;
-  uint32_t high = len - 1;
-  while (low <= high) {
-    uint32_t middle_index = (low + high) >> 1;  // cannot overflow
-    uint32_t middle_value = table[middle_index][0];
-    if (middle_value < key) {
-      low = middle_index + 1;
-    } else if (middle_value > key) {
-      high = middle_index - 1;
-    } else {
-      return middle_index;  // perfect match
-    }
-  }
-  return low == 0 ? 0 : low - 1;
-}
-
-bool ascii_has_upper_case(char* input, size_t length) {
-  auto broadcast = [](uint8_t v) -> uint64_t {
-    return 0x101010101010101ull * v;
-  };
-  uint64_t broadcast_80 = broadcast(0x80);
-  uint64_t broadcast_Ap = broadcast(128 - 'A');
-  uint64_t broadcast_Zp = broadcast(128 - 'Z' - 1);
-  size_t i = 0;
-
-  uint64_t runner{0};
-
-  for (; i + 7 < length; i += 8) {
-    uint64_t word{};
-    memcpy(&word, input + i, sizeof(word));
-    runner |= (((word + broadcast_Ap) ^ (word + broadcast_Zp)) & broadcast_80);
-  }
-  if (i < length) {
-    uint64_t word{};
-    memcpy(&word, input + i, length - i);
-    runner |= (((word + broadcast_Ap) ^ (word + broadcast_Zp)) & broadcast_80);
-  }
-  return runner != 0;
-}
-
-void ascii_map(char* input, size_t length) {
-  auto broadcast = [](uint8_t v) -> uint64_t {
-    return 0x101010101010101ull * v;
-  };
-  uint64_t broadcast_80 = broadcast(0x80);
-  uint64_t broadcast_Ap = broadcast(128 - 'A');
-  uint64_t broadcast_Zp = broadcast(128 - 'Z' - 1);
-  size_t i = 0;
-
-  for (; i + 7 < length; i += 8) {
-    uint64_t word{};
-    memcpy(&word, input + i, sizeof(word));
-    word ^=
-        (((word + broadcast_Ap) ^ (word + broadcast_Zp)) & broadcast_80) >> 2;
-    memcpy(input + i, &word, sizeof(word));
-  }
-  if (i < length) {
-    uint64_t word{};
-    memcpy(&word, input + i, length - i);
-    word ^=
-        (((word + broadcast_Ap) ^ (word + broadcast_Zp)) & broadcast_80) >> 2;
-    memcpy(input + i, &word, length - i);
-  }
-}
-
-// Map the characters according to IDNA, returning the empty string on error.
-std::u32string map(std::u32string_view input) {
-  //  [Map](https://www.unicode.org/reports/tr46/#ProcessingStepMap).
-  //  For each code point in the domain_name string, look up the status
-  //  value in Section 5, [IDNA Mapping
-  //  Table](https://www.unicode.org/reports/tr46/#IDNA_Mapping_Table),
-  //  and take the following actions:
-  //    * disallowed: Leave the code point unchanged in the string, and
-  //    record that there was an error.
-  //    * ignored: Remove the code point from the string. This is
-  //    equivalent to mapping the code point to an empty string.
-  //    * mapped: Replace the code point in the string by the value for
-  //    the mapping in Section 5, [IDNA Mapping
-  //    Table](https://www.unicode.org/reports/tr46/#IDNA_Mapping_Table).
-  //    * valid: Leave the code point unchanged in the string.
-  static std::u32string error = U"";
-  std::u32string answer;
-  answer.reserve(input.size());
-  for (char32_t x : input) {
-    size_t index = find_range_index(x);
-    uint32_t descriptor = table[index][1];
-    uint8_t code = uint8_t(descriptor);
-    switch (code) {
-      case 0:
-        break;  // nothing to do, ignored
-      case 1:
-        answer.push_back(x);  // valid, we just copy it to output
-        break;
-      case 2:
-        return error;  // disallowed
-      // case 3 :
-      default:
-        // We have a mapping
-        {
-          size_t char_count = (descriptor >> 24);
-          uint16_t char_index = uint16_t(descriptor >> 8);
-          for (size_t idx = char_index; idx < char_index + char_count; idx++) {
-            answer.push_back(mappings[idx]);
-          }
-        }
-    }
-  }
-  return answer;
-}
-}  // namespace ada::idna
-/* end file src/mapping.cpp */
-/* begin file src/normalization.cpp */
-/* begin file src/normalization_tables.cpp */
-// IDNA  15.0.0
-
-// clang-format off
-#ifndef ADA_IDNA_NORMALIZATION_TABLES_H
-#define ADA_IDNA_NORMALIZATION_TABLES_H
-#include <cstdint>
-
-/**
- * Unicode Standard Annex #15
- *
- * UNICODE NORMALIZATION FORMS
- * https://www.unicode.org/reports/tr15/
- *
- * See https://github.com/uni-algo/uni-algo/blob/c612968c5ed3ace39bde4c894c24286c5f2c7fe2/include/uni_algo/impl/data/data_norm.h for reference.
- */
-
-namespace ada::idna {
-
-const uint8_t decomposition_index[4352] = {
-    0,  1,  2,  3,  4,  5,  6,  7,  7,  8,  9,  10, 11, 12, 13, 14, 15, 7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  16, 7,  17, 18, 19, 20, 21, 22, 23, 24, 7,
-    7,  7,  7,  7,  25, 7,  26, 27, 28, 29, 30, 31, 32, 33, 7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  34, 35, 7,  7,  7,
-    36, 7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  37, 38, 39, 40, 41, 42, 43, 7,  7,  7,  7,  7,  7,  7,  44, 7,  7,
-    7,  7,  7,  7,  7,  7,  45, 46, 7,  47, 48, 49, 7,  7,  7,  50, 7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  51, 7,  52, 53, 54, 55, 56, 7,  7,  7,
-    7,  7,  7,  7,  7,  57, 7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  58,
-    59, 7,  60, 61, 62, 7,  7,  7,  7,  7,  7,  7,  7,  63, 7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    64, 65, 66, 7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
-    7};
-
-const uint16_t decomposition_block[67][257] = {
-    {4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,
-     4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,
-     4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,
-     4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,
-     4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,
-     4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,
-     4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,
-     4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,
-     4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,
-     4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   4,
-     4,   4,   4,   4,   4,   4,   4,   4,   4,   4,   5,   8,   8,   8,   8,
-     8,   8,   8,   9,   16,  17,  20,  20,  20,  20,  21,  28,  28,  29,  33,
-     37,  45,  48,  48,  49,  57,  61,  64,  65,  77,  89,  100, 100, 108, 116,
-     124, 132, 140, 148, 148, 156, 164, 172, 180, 188, 196, 204, 212, 220, 220,
-     228, 236, 244, 252, 260, 268, 268, 268, 276, 284, 292, 300, 308, 308, 308,
-     316, 324, 332, 340, 348, 356, 356, 364, 372, 380, 388, 396, 404, 412, 420,
-     428, 428, 436, 444, 452, 460, 468, 476, 476, 476, 484, 492, 500, 508, 516,
-     516, 524},
-    {524,  532,  540,  548,  556,  564,  572,  580,  588,  596,  604,  612,
-     620,  628,  636,  644,  652,  652,  652,  660,  668,  676,  684,  692,
-     700,  708,  716,  724,  732,  740,  748,  756,  764,  772,  780,  788,
-     796,  804,  812,  812,  812,  820,  828,  836,  844,  852,  860,  868,
-     876,  884,  885,  893,  900,  908,  916,  924,  932,  932,  940,  948,
-     956,  964,  972,  981,  989,  996,  996,  996,  1004, 1012, 1020, 1028,
-     1036, 1045, 1052, 1052, 1052, 1060, 1068, 1076, 1084, 1092, 1100, 1100,
-     1100, 1108, 1116, 1124, 1132, 1140, 1148, 1156, 1164, 1172, 1180, 1188,
-     1196, 1204, 1212, 1220, 1228, 1236, 1244, 1244, 1244, 1252, 1260, 1268,
-     1276, 1284, 1292, 1300, 1308, 1316, 1324, 1332, 1340, 1348, 1356, 1364,
-     1372, 1380, 1388, 1396, 1404, 1412, 1420, 1429, 1432, 1432, 1432, 1432,
-     1432, 1432, 1432, 1432, 1432, 1432, 1432, 1432, 1432, 1432, 1432, 1432,
-     1432, 1432, 1432, 1432, 1432, 1432, 1432, 1432, 1432, 1432, 1432, 1432,
-     1432, 1432, 1432, 1432, 1432, 1440, 1448, 1448, 1448, 1448, 1448, 1448,
-     1448, 1448, 1448, 1448, 1448, 1448, 1448, 1448, 1456, 1464, 1464, 1464,
-     1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464, 1464,
-     1464, 1464, 1464, 1464, 1465, 1477, 1489, 1501, 1509, 1517, 1525, 1533,
-     1541, 1548, 1556, 1564, 1572, 1580, 1588, 1596, 1604, 1612, 1624, 1636,
-     1648, 1660, 1672, 1684, 1696, 1708, 1708, 1720, 1732, 1744, 1756, 1764,
-     1772, 1772, 1772, 1780, 1788, 1796, 1804, 1812, 1820, 1832, 1844, 1852,
-     1860, 1869, 1877, 1885, 1892, 1900, 1908, 1908, 1908, 1916, 1924, 1936,
-     1948, 1956, 1964, 1972, 1980},
-    {1980, 1988, 1996, 2004, 2012, 2020, 2028, 2036, 2044, 2052, 2060, 2068,
-     2076, 2084, 2092, 2100, 2108, 2116, 2124, 2132, 2140, 2148, 2156, 2164,
-     2172, 2180, 2188, 2196, 2204, 2204, 2204, 2212, 2220, 2220, 2220, 2220,
-     2220, 2220, 2220, 2228, 2236, 2244, 2252, 2264, 2276, 2288, 2300, 2308,
-     2316, 2328, 2340, 2348, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356,
-     2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356,
-     2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356,
-     2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356,
-     2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356,
-     2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356,
-     2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356,
-     2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356,
-     2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356,
-     2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356,
-     2356, 2356, 2356, 2356, 2356, 2356, 2356, 2356, 2357, 2361, 2365, 2369,
-     2373, 2377, 2381, 2385, 2389, 2392, 2392, 2392, 2392, 2392, 2392, 2392,
-     2392, 2392, 2392, 2392, 2392, 2392, 2392, 2392, 2392, 2392, 2392, 2392,
-     2392, 2392, 2392, 2392, 2392, 2392, 2392, 2392, 2392, 2392, 2392, 2392,
-     2393, 2401, 2409, 2417, 2425, 2433, 2440, 2440, 2441, 2445, 2449, 2453,
-     2457, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460,
-     2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460,
-     2460, 2460, 2460, 2460, 2460},
-    {2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460,
-     2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460,
-     2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460,
-     2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460,
-     2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460, 2460,
-     2460, 2460, 2460, 2460, 2460, 2464, 2468, 2468, 2472, 2480, 2480, 2480,
-     2480, 2480, 2480, 2480, 2480, 2480, 2480, 2480, 2480, 2480, 2480, 2480,
-     2480, 2480, 2480, 2480, 2480, 2480, 2480, 2480, 2480, 2480, 2480, 2480,
-     2480, 2480, 2480, 2480, 2480, 2480, 2480, 2480, 2480, 2480, 2480, 2480,
-     2480, 2480, 2480, 2480, 2480, 2480, 2480, 2480, 2480, 2484, 2484, 2484,
-     2484, 2484, 2485, 2492, 2492, 2492, 2492, 2496, 2496, 2496, 2496, 2496,
-     2497, 2506, 2512, 2520, 2524, 2532, 2540, 2548, 2548, 2556, 2556, 2564,
-     2572, 2584, 2584, 2584, 2584, 2584, 2584, 2584, 2584, 2584, 2584, 2584,
-     2584, 2584, 2584, 2584, 2584, 2584, 2584, 2584, 2584, 2584, 2584, 2584,
-     2584, 2584, 2584, 2592, 2600, 2608, 2616, 2624, 2632, 2644, 2644, 2644,
-     2644, 2644, 2644, 2644, 2644, 2644, 2644, 2644, 2644, 2644, 2644, 2644,
-     2644, 2644, 2644, 2644, 2644, 2644, 2644, 2644, 2644, 2644, 2644, 2652,
-     2660, 2668, 2676, 2684, 2685, 2689, 2693, 2698, 2706, 2713, 2717, 2720,
-     2720, 2720, 2720, 2720, 2720, 2720, 2720, 2720, 2720, 2720, 2720, 2720,
-     2720, 2720, 2720, 2720, 2720, 2720, 2720, 2720, 2720, 2720, 2720, 2720,
-     2721, 2725, 2729, 2732, 2733, 2737, 2740, 2740, 2740, 2741, 2744, 2744,
-     2744, 2744, 2744, 2744, 2744},
-    {2744, 2752, 2760, 2760, 2768, 2768, 2768, 2768, 2776, 2776, 2776, 2776,
-     2776, 2784, 2792, 2800, 2800, 2800, 2800, 2800, 2800, 2800, 2800, 2800,
-     2800, 2800, 2808, 2808, 2808, 2808, 2808, 2808, 2808, 2808, 2808, 2808,
-     2808, 2808, 2808, 2808, 2808, 2808, 2808, 2808, 2808, 2808, 2808, 2808,
-     2808, 2808, 2808, 2808, 2808, 2808, 2808, 2808, 2808, 2808, 2816, 2816,
-     2816, 2816, 2816, 2816, 2816, 2816, 2816, 2816, 2816, 2816, 2816, 2816,
-     2816, 2816, 2816, 2816, 2816, 2816, 2816, 2816, 2816, 2824, 2832, 2832,
-     2840, 2840, 2840, 2840, 2848, 2848, 2848, 2848, 2848, 2856, 2864, 2872,
-     2872, 2872, 2872, 2872, 2872, 2872, 2872, 2872, 2872, 2872, 2872, 2872,
-     2872, 2872, 2872, 2872, 2872, 2872, 2872, 2872, 2872, 2872, 2872, 2880,
-     2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888,
-     2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888,
-     2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888,
-     2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888,
-     2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888,
-     2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888,
-     2888, 2888, 2896, 2904, 2904, 2904, 2904, 2904, 2904, 2904, 2904, 2904,
-     2904, 2904, 2904, 2904, 2904, 2912, 2920, 2928, 2936, 2936, 2936, 2944,
-     2952, 2952, 2952, 2960, 2968, 2976, 2984, 2992, 3000, 3000, 3000, 3008,
-     3016, 3024, 3032, 3040, 3048, 3048, 3048, 3056, 3064, 3072, 3080, 3088,
-     3096, 3104, 3112, 3120, 3128, 3136, 3144, 3144, 3144, 3152, 3160, 3160,
-     3160, 3160, 3160, 3160, 3160},
-    {3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160,
-     3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160,
-     3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160,
-     3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160,
-     3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160,
-     3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160,
-     3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160,
-     3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160,
-     3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160,
-     3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160,
-     3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160, 3160,
-     3160, 3160, 3160, 3161, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168,
-     3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168,
-     3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168,
-     3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168,
-     3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168,
-     3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168,
-     3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168,
-     3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168,
-     3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168,
-     3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168,
-     3168, 3168, 3168, 3168, 3168},
-    {3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168,
-     3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168,
-     3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3168, 3176,
-     3184, 3192, 3200, 3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208,
-     3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208,
-     3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208,
-     3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208,
-     3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208,
-     3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208,
-     3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208, 3208, 3209, 3217, 3225,
-     3233, 3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240,
-     3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240,
-     3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240,
-     3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240,
-     3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240,
-     3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240, 3240,
-     3240, 3248, 3248, 3256, 3256, 3256, 3256, 3256, 3256, 3256, 3256, 3256,
-     3256, 3256, 3256, 3256, 3256, 3256, 3256, 3256, 3264, 3264, 3264, 3264,
-     3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264,
-     3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264,
-     3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264,
-     3264, 3264, 3264, 3264, 3264},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264,
-     3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264,
-     3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264, 3264,
-     3264, 3264, 3264, 3264, 3264, 3264, 3272, 3272, 3272, 3272, 3272, 3272,
-     3272, 3272, 3280, 3280, 3280, 3288, 3288, 3288, 3288, 3288, 3288, 3288,
-     3288, 3288, 3288, 3288, 3288, 3288, 3288, 3288, 3288, 3288, 3288, 3288,
-     3288, 3288, 3288, 3288, 3288, 3288, 3288, 3288, 3288, 3288, 3288, 3288,
-     3288, 3288, 3288, 3288, 3288, 3296, 3304, 3312, 3320, 3328, 3336, 3344,
-     3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352,
-     3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352,
-     3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352,
-     3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352,
-     3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352,
-     3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352,
-     3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352,
-     3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352,
-     3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352, 3352,
-     3360, 3368, 3368, 3368, 3368, 3368, 3368, 3368, 3368, 3368, 3368, 3368,
-     3368, 3368, 3368, 3368, 3368, 3376, 3384, 3384, 3392, 3392, 3392, 3392,
-     3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392,
-     3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392,
-     3392, 3392, 3392, 3392, 3392},
-    {3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392,
-     3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392,
-     3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392,
-     3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392, 3392,
-     3392, 3392, 3392, 3392, 3400, 3400, 3400, 3408, 3408, 3408, 3408, 3408,
-     3408, 3408, 3408, 3408, 3408, 3408, 3408, 3408, 3408, 3408, 3408, 3408,
-     3408, 3408, 3408, 3408, 3408, 3408, 3408, 3408, 3408, 3408, 3408, 3408,
-     3408, 3408, 3408, 3408, 3408, 3408, 3416, 3424, 3432, 3432, 3432, 3440,
-     3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440,
-     3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440,
-     3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440,
-     3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440,
-     3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440,
-     3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440,
-     3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440,
-     3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440,
-     3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440,
-     3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440,
-     3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440,
-     3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440,
-     3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440,
-     3440, 3440, 3440, 3440, 3440},
-    {3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440,
-     3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440,
-     3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440,
-     3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440,
-     3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440,
-     3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440, 3440,
-     3440, 3448, 3448, 3448, 3456, 3464, 3464, 3464, 3464, 3464, 3464, 3464,
-     3464, 3464, 3464, 3464, 3464, 3464, 3464, 3464, 3464, 3472, 3480, 3480,
-     3480, 3480, 3480, 3480, 3480, 3480, 3480, 3480, 3480, 3480, 3480, 3480,
-     3480, 3480, 3480, 3480, 3480, 3480, 3480, 3480, 3480, 3480, 3480, 3480,
-     3480, 3480, 3480, 3480, 3480, 3480, 3480, 3480, 3480, 3480, 3480, 3480,
-     3480, 3480, 3480, 3480, 3480, 3480, 3480, 3480, 3480, 3480, 3480, 3480,
-     3480, 3480, 3480, 3480, 3480, 3488, 3488, 3488, 3488, 3488, 3488, 3488,
-     3488, 3488, 3488, 3488, 3488, 3488, 3488, 3488, 3488, 3488, 3488, 3488,
-     3488, 3488, 3488, 3488, 3488, 3488, 3488, 3488, 3488, 3488, 3488, 3488,
-     3488, 3488, 3488, 3488, 3488, 3488, 3488, 3488, 3488, 3488, 3488, 3488,
-     3488, 3488, 3488, 3488, 3488, 3488, 3488, 3488, 3488, 3488, 3488, 3496,
-     3504, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512,
-     3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512,
-     3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512,
-     3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512,
-     3512, 3512, 3512, 3512, 3512},
-    {3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512,
-     3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512,
-     3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512,
-     3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512,
-     3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512,
-     3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512, 3512,
-     3512, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520,
-     3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520,
-     3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520,
-     3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520,
-     3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520,
-     3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520,
-     3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520,
-     3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520,
-     3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520,
-     3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520, 3520,
-     3520, 3528, 3528, 3528, 3528, 3528, 3528, 3528, 3536, 3544, 3544, 3552,
-     3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564,
-     3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564,
-     3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564,
-     3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564,
-     3564, 3564, 3564, 3564, 3564},
-    {3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564,
-     3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564,
-     3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564,
-     3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564,
-     3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564,
-     3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564, 3564,
-     3564, 3564, 3564, 3572, 3580, 3588, 3588, 3588, 3588, 3588, 3588, 3588,
-     3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588,
-     3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588,
-     3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588,
-     3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588,
-     3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588,
-     3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588,
-     3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588,
-     3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588,
-     3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588,
-     3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588,
-     3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588, 3588,
-     3588, 3588, 3588, 3596, 3596, 3604, 3616, 3624, 3624, 3624, 3624, 3624,
-     3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624,
-     3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624,
-     3624, 3624, 3624, 3624, 3624},
-    {3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624,
-     3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624,
-     3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624,
-     3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624, 3624,
-     3624, 3624, 3624, 3625, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632,
-     3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632,
-     3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632,
-     3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632,
-     3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632,
-     3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632,
-     3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632,
-     3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632,
-     3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632,
-     3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632,
-     3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3632, 3633,
-     3640, 3640, 3640, 3640, 3640, 3640, 3640, 3640, 3640, 3640, 3640, 3640,
-     3640, 3640, 3640, 3640, 3640, 3640, 3640, 3640, 3640, 3640, 3640, 3640,
-     3640, 3640, 3640, 3640, 3640, 3640, 3640, 3640, 3640, 3640, 3640, 3640,
-     3640, 3640, 3640, 3640, 3641, 3649, 3656, 3656, 3656, 3656, 3656, 3656,
-     3656, 3656, 3656, 3656, 3656, 3656, 3656, 3656, 3656, 3656, 3656, 3656,
-     3656, 3656, 3656, 3656, 3656, 3656, 3656, 3656, 3656, 3656, 3656, 3656,
-     3656, 3656, 3656, 3656, 3656},
-    {3656, 3656, 3656, 3656, 3656, 3656, 3656, 3656, 3656, 3656, 3656, 3656,
-     3657, 3660, 3660, 3660, 3660, 3660, 3660, 3660, 3660, 3660, 3660, 3660,
-     3660, 3660, 3660, 3660, 3660, 3660, 3660, 3660, 3660, 3660, 3660, 3660,
-     3660, 3660, 3660, 3660, 3660, 3660, 3660, 3660, 3660, 3660, 3660, 3660,
-     3660, 3660, 3660, 3660, 3660, 3660, 3660, 3660, 3660, 3660, 3660, 3660,
-     3660, 3660, 3660, 3660, 3660, 3660, 3660, 3660, 3668, 3668, 3668, 3668,
-     3668, 3668, 3668, 3668, 3668, 3668, 3676, 3676, 3676, 3676, 3676, 3684,
-     3684, 3684, 3684, 3684, 3692, 3692, 3692, 3692, 3692, 3700, 3700, 3700,
-     3700, 3700, 3700, 3700, 3700, 3700, 3700, 3700, 3700, 3700, 3708, 3708,
-     3708, 3708, 3708, 3708, 3708, 3708, 3708, 3708, 3716, 3716, 3724, 3733,
-     3744, 3753, 3764, 3764, 3764, 3764, 3764, 3764, 3764, 3764, 3772, 3772,
-     3772, 3772, 3772, 3772, 3772, 3772, 3772, 3772, 3772, 3772, 3772, 3772,
-     3772, 3772, 3772, 3772, 3780, 3780, 3780, 3780, 3780, 3780, 3780, 3780,
-     3780, 3780, 3788, 3788, 3788, 3788, 3788, 3796, 3796, 3796, 3796, 3796,
-     3804, 3804, 3804, 3804, 3804, 3812, 3812, 3812, 3812, 3812, 3812, 3812,
-     3812, 3812, 3812, 3812, 3812, 3812, 3820, 3820, 3820, 3820, 3820, 3820,
-     3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820,
-     3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820,
-     3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820,
-     3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820,
-     3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820,
-     3820, 3820, 3820, 3820, 3820},
-    {3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820,
-     3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820,
-     3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820, 3820,
-     3820, 3820, 3820, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828,
-     3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828,
-     3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828,
-     3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828,
-     3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828,
-     3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828,
-     3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828,
-     3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828,
-     3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828,
-     3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828,
-     3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828,
-     3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828,
-     3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828,
-     3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828,
-     3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828,
-     3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828,
-     3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828,
-     3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828, 3828,
-     3829, 3832, 3832, 3832, 3832},
-    {3832, 3832, 3832, 3832, 3832, 3832, 3832, 3840, 3840, 3848, 3848, 3856,
-     3856, 3864, 3864, 3872, 3872, 3872, 3872, 3880, 3880, 3880, 3880, 3880,
-     3880, 3880, 3880, 3880, 3880, 3880, 3880, 3880, 3880, 3880, 3880, 3880,
-     3880, 3880, 3880, 3880, 3880, 3880, 3880, 3880, 3880, 3880, 3880, 3880,
-     3880, 3880, 3880, 3880, 3880, 3880, 3880, 3880, 3880, 3880, 3880, 3880,
-     3888, 3888, 3896, 3896, 3896, 3904, 3912, 3912, 3920, 3920, 3920, 3920,
-     3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920,
-     3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920,
-     3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920,
-     3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920,
-     3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920,
-     3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920,
-     3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920,
-     3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920,
-     3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920,
-     3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920,
-     3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920,
-     3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920,
-     3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920,
-     3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920,
-     3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920,
-     3920, 3920, 3920, 3920, 3920},
-    {3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920,
-     3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920,
-     3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920,
-     3920, 3920, 3920, 3920, 3920, 3920, 3920, 3920, 3921, 3925, 3929, 3932,
-     3933, 3937, 3941, 3945, 3949, 3953, 3957, 3961, 3965, 3969, 3973, 3976,
-     3977, 3981, 3985, 3989, 3993, 3997, 4001, 4005, 4009, 4013, 4017, 4021,
-     4025, 4029, 4033, 4037, 4041, 4045, 4048, 4049, 4053, 4057, 4061, 4065,
-     4069, 4073, 4077, 4081, 4085, 4089, 4093, 4097, 4101, 4105, 4109, 4113,
-     4117, 4121, 4125, 4129, 4133, 4137, 4141, 4145, 4149, 4153, 4157, 4160,
-     4160, 4160, 4160, 4160, 4160, 4160, 4160, 4160, 4160, 4160, 4160, 4160,
-     4161, 4164, 4164, 4164, 4164, 4164, 4164, 4164, 4164, 4164, 4164, 4164,
-     4164, 4164, 4164, 4164, 4164, 4164, 4164, 4164, 4164, 4164, 4164, 4164,
-     4164, 4164, 4164, 4164, 4164, 4164, 4164, 4164, 4164, 4164, 4164, 4165,
-     4169, 4173, 4177, 4181, 4185, 4189, 4193, 4197, 4201, 4205, 4209, 4213,
-     4217, 4221, 4225, 4229, 4233, 4237, 4241, 4245, 4249, 4253, 4257, 4261,
-     4265, 4269, 4273, 4277, 4281, 4285, 4289, 4293, 4297, 4301, 4305, 4309,
-     4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312,
-     4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312,
-     4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312,
-     4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312,
-     4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312, 4312,
-     4312, 4312, 4312, 4312, 4312},
-    {4312, 4320, 4328, 4336, 4344, 4352, 4360, 4368, 4376, 4388, 4400, 4408,
-     4416, 4424, 4432, 4440, 4448, 4456, 4464, 4472, 4480, 4492, 4504, 4516,
-     4528, 4536, 4544, 4552, 4560, 4572, 4584, 4592, 4600, 4608, 4616, 4624,
-     4632, 4640, 4648, 4656, 4664, 4672, 4680, 4688, 4696, 4704, 4712, 4724,
-     4736, 4744, 4752, 4760, 4768, 4776, 4784, 4792, 4800, 4812, 4824, 4832,
-     4840, 4848, 4856, 4864, 4872, 4880, 4888, 4896, 4904, 4912, 4920, 4928,
-     4936, 4944, 4952, 4960, 4968, 4980, 4992, 5004, 5016, 5028, 5040, 5052,
-     5064, 5072, 5080, 5088, 5096, 5104, 5112, 5120, 5128, 5140, 5152, 5160,
-     5168, 5176, 5184, 5192, 5200, 5212, 5224, 5236, 5248, 5260, 5272, 5280,
-     5288, 5296, 5304, 5312, 5320, 5328, 5336, 5344, 5352, 5360, 5368, 5376,
-     5384, 5396, 5408, 5420, 5432, 5440, 5448, 5456, 5464, 5472, 5480, 5488,
-     5496, 5504, 5512, 5520, 5528, 5536, 5544, 5552, 5560, 5568, 5576, 5584,
-     5592, 5600, 5608, 5616, 5624, 5632, 5640, 5648, 5656, 5664, 5673, 5682,
-     5688, 5688, 5688, 5688, 5688, 5696, 5704, 5712, 5720, 5732, 5744, 5756,
-     5768, 5780, 5792, 5804, 5816, 5828, 5840, 5852, 5864, 5876, 5888, 5900,
-     5912, 5924, 5936, 5948, 5960, 5968, 5976, 5984, 5992, 6000, 6008, 6020,
-     6032, 6044, 6056, 6068, 6080, 6092, 6104, 6116, 6128, 6136, 6144, 6152,
-     6160, 6168, 6176, 6184, 6192, 6204, 6216, 6228, 6240, 6252, 6264, 6276,
-     6288, 6300, 6312, 6324, 6336, 6348, 6360, 6372, 6384, 6396, 6408, 6420,
-     6432, 6440, 6448, 6456, 6464, 6476, 6488, 6500, 6512, 6524, 6536, 6548,
-     6560, 6572, 6584, 6592, 6600, 6608, 6616, 6624, 6632, 6640, 6648, 6648,
-     6648, 6648, 6648, 6648, 6648},
-    {6648, 6656, 6664, 6676, 6688, 6700, 6712, 6724, 6736, 6744, 6752, 6764,
-     6776, 6788, 6800, 6812, 6824, 6832, 6840, 6852, 6864, 6876, 6888, 6888,
-     6888, 6896, 6904, 6916, 6928, 6940, 6952, 6952, 6952, 6960, 6968, 6980,
-     6992, 7004, 7016, 7028, 7040, 7048, 7056, 7068, 7080, 7092, 7104, 7116,
-     7128, 7136, 7144, 7156, 7168, 7180, 7192, 7204, 7216, 7224, 7232, 7244,
-     7256, 7268, 7280, 7292, 7304, 7312, 7320, 7332, 7344, 7356, 7368, 7368,
-     7368, 7376, 7384, 7396, 7408, 7420, 7432, 7432, 7432, 7440, 7448, 7460,
-     7472, 7484, 7496, 7508, 7520, 7520, 7528, 7528, 7540, 7540, 7552, 7552,
-     7564, 7572, 7580, 7592, 7604, 7616, 7628, 7640, 7652, 7660, 7668, 7680,
-     7692, 7704, 7716, 7728, 7740, 7748, 7756, 7764, 7772, 7780, 7788, 7796,
-     7804, 7812, 7820, 7828, 7836, 7844, 7852, 7852, 7852, 7864, 7876, 7892,
-     7908, 7924, 7940, 7956, 7972, 7984, 7996, 8012, 8028, 8044, 8060, 8076,
-     8092, 8104, 8116, 8132, 8148, 8164, 8180, 8196, 8212, 8224, 8236, 8252,
-     8268, 8284, 8300, 8316, 8332, 8344, 8356, 8372, 8388, 8404, 8420, 8436,
-     8452, 8464, 8476, 8492, 8508, 8524, 8540, 8556, 8572, 8580, 8588, 8600,
-     8608, 8620, 8620, 8628, 8640, 8648, 8656, 8664, 8672, 8681, 8688, 8693,
-     8701, 8710, 8716, 8728, 8736, 8748, 8748, 8756, 8768, 8776, 8784, 8792,
-     8800, 8810, 8818, 8826, 8832, 8840, 8848, 8860, 8872, 8872, 8872, 8880,
-     8892, 8900, 8908, 8916, 8924, 8926, 8934, 8942, 8948, 8956, 8964, 8976,
-     8988, 8996, 9004, 9012, 9024, 9032, 9040, 9048, 9056, 9066, 9074, 9080,
-     9084, 9084, 9084, 9096, 9104, 9116, 9116, 9124, 9136, 9144, 9152, 9160,
-     9168, 9178, 9181, 9188, 9190},
-    {9190, 9194, 9197, 9201, 9205, 9209, 9213, 9217, 9221, 9225, 9229, 9232,
-     9232, 9232, 9232, 9232, 9232, 9233, 9236, 9236, 9236, 9236, 9236, 9237,
-     9244, 9244, 9244, 9244, 9244, 9244, 9244, 9244, 9244, 9244, 9244, 9244,
-     9245, 9249, 9257, 9268, 9268, 9268, 9268, 9268, 9268, 9268, 9268, 9269,
-     9272, 9272, 9272, 9273, 9281, 9292, 9293, 9301, 9312, 9312, 9312, 9312,
-     9313, 9320, 9321, 9328, 9328, 9328, 9328, 9328, 9328, 9328, 9328, 9329,
-     9337, 9345, 9352, 9352, 9352, 9352, 9352, 9352, 9352, 9352, 9352, 9352,
-     9352, 9352, 9352, 9353, 9368, 9368, 9368, 9368, 9368, 9368, 9368, 9369,
-     9372, 9372, 9372, 9372, 9372, 9372, 9372, 9372, 9372, 9372, 9372, 9372,
-     9372, 9372, 9372, 9372, 9373, 9377, 9380, 9380, 9381, 9385, 9389, 9393,
-     9397, 9401, 9405, 9409, 9413, 9417, 9421, 9425, 9429, 9433, 9437, 9441,
-     9445, 9449, 9453, 9457, 9461, 9465, 9469, 9473, 9477, 9481, 9485, 9488,
-     9489, 9493, 9497, 9501, 9505, 9509, 9513, 9517, 9521, 9525, 9529, 9533,
-     9537, 9540, 9540, 9540, 9540, 9540, 9540, 9540, 9540, 9540, 9540, 9540,
-     9541, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548,
-     9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548,
-     9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548,
-     9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548,
-     9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548,
-     9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548,
-     9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548, 9548,
-     9548, 9548, 9548, 9548, 9549},
-    {9549,  9561,  9573,  9577,  9584,  9585,  9597,  9609,  9612,  9613,
-     9621,  9625,  9629,  9633,  9637,  9641,  9645,  9649,  9653,  9657,
-     9660,  9661,  9665,  9672,  9672,  9673,  9677,  9681,  9685,  9689,
-     9692,  9692,  9693,  9701,  9713,  9720,  9721,  9724,  9724,  9728,
-     9729,  9732,  9732,  9736,  9745,  9749,  9752,  9753,  9757,  9761,
-     9764,  9765,  9769,  9773,  9777,  9781,  9785,  9789,  9792,  9793,
-     9805,  9809,  9813,  9817,  9821,  9824,  9824,  9824,  9824,  9825,
-     9829,  9833,  9837,  9841,  9844,  9844,  9844,  9844,  9844,  9844,
-     9845,  9857,  9869,  9885,  9897,  9909,  9921,  9933,  9945,  9957,
-     9969,  9981,  9993,  10005, 10017, 10029, 10037, 10041, 10049, 10061,
-     10069, 10073, 10081, 10093, 10109, 10117, 10121, 10129, 10141, 10145,
-     10149, 10153, 10157, 10161, 10169, 10181, 10189, 10193, 10201, 10213,
-     10229, 10237, 10241, 10249, 10261, 10265, 10269, 10273, 10276, 10276,
-     10276, 10276, 10276, 10276, 10276, 10276, 10276, 10277, 10288, 10288,
-     10288, 10288, 10288, 10288, 10288, 10288, 10288, 10288, 10288, 10288,
-     10288, 10288, 10288, 10288, 10288, 10296, 10304, 10304, 10304, 10304,
-     10304, 10304, 10304, 10304, 10304, 10304, 10304, 10304, 10304, 10304,
-     10304, 10304, 10304, 10304, 10304, 10312, 10312, 10312, 10312, 10312,
-     10312, 10312, 10312, 10312, 10312, 10312, 10312, 10312, 10312, 10312,
-     10312, 10312, 10312, 10312, 10312, 10312, 10312, 10312, 10312, 10312,
-     10312, 10312, 10312, 10312, 10312, 10312, 10320, 10328, 10336, 10336,
-     10336, 10336, 10336, 10336, 10336, 10336, 10336, 10336, 10336, 10336,
-     10336, 10336, 10336, 10336, 10336, 10336, 10336, 10336, 10336, 10336,
-     10336, 10336, 10336, 10336, 10336, 10336, 10336, 10336, 10336, 10336,
-     10336, 10336, 10336, 10336, 10336, 10336, 10336, 10336, 10336, 10336,
-     10336, 10336, 10336, 10336, 10336, 10336, 10336},
-    {10336, 10336, 10336, 10336, 10336, 10344, 10344, 10344, 10344, 10344,
-     10352, 10352, 10352, 10360, 10360, 10360, 10360, 10360, 10360, 10360,
-     10360, 10360, 10360, 10360, 10360, 10360, 10360, 10360, 10360, 10360,
-     10360, 10360, 10360, 10360, 10360, 10360, 10360, 10368, 10368, 10376,
-     10376, 10376, 10376, 10376, 10377, 10385, 10396, 10397, 10405, 10416,
-     10416, 10416, 10416, 10416, 10416, 10416, 10416, 10416, 10416, 10416,
-     10416, 10416, 10416, 10416, 10416, 10416, 10424, 10424, 10424, 10432,
-     10432, 10432, 10440, 10440, 10448, 10448, 10448, 10448, 10448, 10448,
-     10448, 10448, 10448, 10448, 10448, 10448, 10448, 10448, 10448, 10448,
-     10448, 10448, 10448, 10448, 10448, 10448, 10448, 10456, 10456, 10464,
-     10464, 10464, 10464, 10464, 10464, 10464, 10464, 10464, 10464, 10464,
-     10472, 10480, 10488, 10496, 10504, 10504, 10504, 10512, 10520, 10520,
-     10520, 10528, 10536, 10536, 10536, 10536, 10536, 10536, 10536, 10544,
-     10552, 10552, 10552, 10560, 10568, 10568, 10568, 10576, 10584, 10584,
-     10584, 10584, 10584, 10584, 10584, 10584, 10584, 10584, 10584, 10584,
-     10584, 10584, 10584, 10584, 10584, 10584, 10584, 10584, 10584, 10584,
-     10584, 10584, 10584, 10584, 10584, 10584, 10584, 10584, 10584, 10584,
-     10584, 10584, 10584, 10592, 10600, 10608, 10616, 10616, 10616, 10616,
-     10616, 10616, 10616, 10616, 10616, 10616, 10616, 10616, 10616, 10616,
-     10616, 10616, 10616, 10616, 10616, 10616, 10616, 10616, 10616, 10616,
-     10616, 10616, 10616, 10616, 10616, 10616, 10616, 10616, 10616, 10616,
-     10616, 10616, 10616, 10616, 10616, 10616, 10616, 10616, 10616, 10616,
-     10616, 10616, 10616, 10616, 10616, 10624, 10632, 10640, 10648, 10648,
-     10648, 10648, 10648, 10648, 10648, 10656, 10664, 10672, 10680, 10680,
-     10680, 10680, 10680, 10680, 10680, 10680, 10680, 10680, 10680, 10680,
-     10680, 10680, 10680, 10680, 10680, 10680, 10680},
-    {10680, 10680, 10680, 10680, 10680, 10680, 10680, 10680, 10680, 10680,
-     10680, 10680, 10680, 10680, 10680, 10680, 10680, 10680, 10680, 10680,
-     10680, 10680, 10680, 10680, 10680, 10680, 10680, 10680, 10680, 10680,
-     10680, 10680, 10680, 10680, 10680, 10680, 10680, 10680, 10680, 10680,
-     10680, 10680, 10684, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688},
-    {10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688, 10688,
-     10688, 10688, 10688, 10688, 10688, 10688, 10689, 10693, 10697, 10701,
-     10705, 10709, 10713, 10717, 10721, 10725, 10733, 10741, 10749, 10757,
-     10765, 10773, 10781, 10789, 10797, 10805, 10813, 10825, 10837, 10849,
-     10861, 10873, 10885, 10897, 10909, 10921, 10937, 10953, 10969, 10985,
-     11001, 11017, 11033, 11049, 11065, 11081, 11097, 11105, 11113, 11121,
-     11129, 11137, 11145, 11153, 11161, 11169, 11181, 11193, 11205, 11217,
-     11229, 11241, 11253, 11265, 11277, 11289, 11301, 11313, 11325, 11337,
-     11349, 11361, 11373, 11385, 11397, 11409, 11421, 11433, 11445, 11457,
-     11469, 11481, 11493, 11505, 11517, 11529, 11541, 11553, 11565, 11577,
-     11589, 11601, 11613, 11617, 11621, 11625, 11629, 11633, 11637, 11641,
-     11645, 11649, 11653, 11657, 11661, 11665, 11669, 11673, 11677, 11681,
-     11685, 11689, 11693, 11697, 11701, 11705, 11709, 11713, 11717, 11721,
-     11725, 11729, 11733, 11737, 11741, 11745, 11749, 11753, 11757, 11761,
-     11765, 11769, 11773, 11777, 11781, 11785, 11789, 11793, 11797, 11801,
-     11805, 11809, 11813, 11817, 11821, 11824, 11824, 11824, 11824, 11824,
-     11824, 11824, 11824, 11824, 11824, 11824, 11824, 11824, 11824, 11824,
-     11824, 11824, 11824, 11824, 11824, 11824, 11824},
-    {11824, 11824, 11824, 11824, 11824, 11824, 11824, 11824, 11824, 11824,
-     11824, 11824, 11825, 11840, 11840, 11840, 11840, 11840, 11840, 11840,
-     11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840,
-     11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840,
-     11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840,
-     11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840,
-     11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840,
-     11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840,
-     11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840,
-     11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840,
-     11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840, 11840,
-     11840, 11840, 11840, 11840, 11840, 11840, 11841, 11853, 11861, 11872,
-     11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872,
-     11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872,
-     11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872,
-     11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872,
-     11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872,
-     11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872,
-     11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872,
-     11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872,
-     11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872,
-     11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872, 11872,
-     11872, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880,
-     11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880,
-     11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880,
-     11880, 11880, 11880, 11880, 11880, 11880, 11880},
-    {11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880,
-     11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880,
-     11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880,
-     11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880,
-     11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880,
-     11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880,
-     11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880,
-     11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880,
-     11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880,
-     11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880,
-     11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880,
-     11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880, 11880,
-     11880, 11880, 11880, 11880, 11881, 11885, 11888, 11888, 11888, 11888,
-     11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888,
-     11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888,
-     11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888,
-     11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888,
-     11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888,
-     11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888,
-     11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888,
-     11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888,
-     11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888,
-     11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888,
-     11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888,
-     11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888,
-     11888, 11888, 11888, 11888, 11888, 11888, 11888},
-    {11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888,
-     11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888,
-     11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888,
-     11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888,
-     11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888,
-     11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888,
-     11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888,
-     11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888,
-     11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888,
-     11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888,
-     11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888, 11888,
-     11888, 11889, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892},
-    {11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892,
-     11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11892, 11893,
-     11896, 11896, 11896, 11896, 11896, 11896, 11896, 11896, 11896, 11896,
-     11896, 11896, 11896, 11896, 11896, 11896, 11896, 11896, 11896, 11896,
-     11896, 11896, 11896, 11896, 11896, 11896, 11896, 11896, 11896, 11896,
-     11896, 11896, 11896, 11896, 11896, 11896, 11896, 11896, 11896, 11896,
-     11896, 11896, 11896, 11896, 11896, 11896, 11896, 11896, 11896, 11896,
-     11896, 11896, 11896, 11896, 11896, 11896, 11896, 11896, 11896, 11896,
-     11896, 11896, 11896, 11896, 11896, 11896, 11896, 11896, 11896, 11896,
-     11896, 11896, 11896, 11896, 11896, 11896, 11896, 11896, 11896, 11896,
-     11896, 11896, 11896, 11897, 11900, 11900, 11900, 11900, 11900, 11900,
-     11900, 11900, 11900, 11900, 11900, 11900, 11901},
-    {11901, 11905, 11909, 11913, 11917, 11921, 11925, 11929, 11933, 11937,
-     11941, 11945, 11949, 11953, 11957, 11961, 11965, 11969, 11973, 11977,
-     11981, 11985, 11989, 11993, 11997, 12001, 12005, 12009, 12013, 12017,
-     12021, 12025, 12029, 12033, 12037, 12041, 12045, 12049, 12053, 12057,
-     12061, 12065, 12069, 12073, 12077, 12081, 12085, 12089, 12093, 12097,
-     12101, 12105, 12109, 12113, 12117, 12121, 12125, 12129, 12133, 12137,
-     12141, 12145, 12149, 12153, 12157, 12161, 12165, 12169, 12173, 12177,
-     12181, 12185, 12189, 12193, 12197, 12201, 12205, 12209, 12213, 12217,
-     12221, 12225, 12229, 12233, 12237, 12241, 12245, 12249, 12253, 12257,
-     12261, 12265, 12269, 12273, 12277, 12281, 12285, 12289, 12293, 12297,
-     12301, 12305, 12309, 12313, 12317, 12321, 12325, 12329, 12333, 12337,
-     12341, 12345, 12349, 12353, 12357, 12361, 12365, 12369, 12373, 12377,
-     12381, 12385, 12389, 12393, 12397, 12401, 12405, 12409, 12413, 12417,
-     12421, 12425, 12429, 12433, 12437, 12441, 12445, 12449, 12453, 12457,
-     12461, 12465, 12469, 12473, 12477, 12481, 12485, 12489, 12493, 12497,
-     12501, 12505, 12509, 12513, 12517, 12521, 12525, 12529, 12533, 12537,
-     12541, 12545, 12549, 12553, 12557, 12561, 12565, 12569, 12573, 12577,
-     12581, 12585, 12589, 12593, 12597, 12601, 12605, 12609, 12613, 12617,
-     12621, 12625, 12629, 12633, 12637, 12641, 12645, 12649, 12653, 12657,
-     12661, 12665, 12669, 12673, 12677, 12681, 12685, 12689, 12693, 12697,
-     12701, 12705, 12709, 12713, 12717, 12721, 12725, 12729, 12733, 12737,
-     12741, 12745, 12749, 12753, 12756, 12756, 12756, 12756, 12756, 12756,
-     12756, 12756, 12756, 12756, 12756, 12756, 12756, 12756, 12756, 12756,
-     12756, 12756, 12756, 12756, 12756, 12756, 12756, 12756, 12756, 12756,
-     12756, 12756, 12756, 12756, 12756, 12756, 12756, 12756, 12756, 12756,
-     12756, 12756, 12756, 12756, 12756, 12756, 12757},
-    {12757, 12760, 12760, 12760, 12760, 12760, 12760, 12760, 12760, 12760,
-     12760, 12760, 12760, 12760, 12760, 12760, 12760, 12760, 12760, 12760,
-     12760, 12760, 12760, 12760, 12760, 12760, 12760, 12760, 12760, 12760,
-     12760, 12760, 12760, 12760, 12760, 12760, 12760, 12760, 12760, 12760,
-     12760, 12760, 12760, 12760, 12760, 12760, 12760, 12760, 12760, 12760,
-     12760, 12760, 12760, 12760, 12761, 12764, 12765, 12769, 12773, 12776,
-     12776, 12776, 12776, 12776, 12776, 12776, 12776, 12776, 12776, 12776,
-     12776, 12776, 12776, 12776, 12776, 12776, 12776, 12784, 12784, 12792,
-     12792, 12800, 12800, 12808, 12808, 12816, 12816, 12824, 12824, 12832,
-     12832, 12840, 12840, 12848, 12848, 12856, 12856, 12864, 12864, 12872,
-     12872, 12872, 12880, 12880, 12888, 12888, 12896, 12896, 12896, 12896,
-     12896, 12896, 12896, 12904, 12912, 12912, 12920, 12928, 12928, 12936,
-     12944, 12944, 12952, 12960, 12960, 12968, 12976, 12976, 12976, 12976,
-     12976, 12976, 12976, 12976, 12976, 12976, 12976, 12976, 12976, 12976,
-     12976, 12976, 12976, 12976, 12976, 12976, 12976, 12976, 12976, 12984,
-     12984, 12984, 12984, 12984, 12984, 12985, 12993, 13000, 13000, 13009,
-     13016, 13016, 13016, 13016, 13016, 13016, 13016, 13016, 13016, 13016,
-     13016, 13016, 13016, 13024, 13024, 13032, 13032, 13040, 13040, 13048,
-     13048, 13056, 13056, 13064, 13064, 13072, 13072, 13080, 13080, 13088,
-     13088, 13096, 13096, 13104, 13104, 13112, 13112, 13112, 13120, 13120,
-     13128, 13128, 13136, 13136, 13136, 13136, 13136, 13136, 13136, 13144,
-     13152, 13152, 13160, 13168, 13168, 13176, 13184, 13184, 13192, 13200,
-     13200, 13208, 13216, 13216, 13216, 13216, 13216, 13216, 13216, 13216,
-     13216, 13216, 13216, 13216, 13216, 13216, 13216, 13216, 13216, 13216,
-     13216, 13216, 13216, 13216, 13216, 13224, 13224, 13224, 13232, 13240,
-     13248, 13256, 13256, 13256, 13256, 13265, 13272},
-    {13272, 13272, 13272, 13272, 13272, 13272, 13272, 13272, 13272, 13272,
-     13272, 13272, 13272, 13272, 13272, 13272, 13272, 13272, 13272, 13272,
-     13272, 13272, 13272, 13272, 13272, 13272, 13272, 13272, 13272, 13272,
-     13272, 13272, 13272, 13272, 13272, 13272, 13272, 13272, 13272, 13272,
-     13272, 13272, 13272, 13272, 13272, 13272, 13272, 13272, 13272, 13273,
-     13277, 13281, 13285, 13289, 13293, 13297, 13301, 13305, 13309, 13313,
-     13317, 13321, 13325, 13329, 13333, 13337, 13341, 13345, 13349, 13353,
-     13357, 13361, 13365, 13369, 13373, 13377, 13381, 13385, 13389, 13393,
-     13397, 13401, 13405, 13409, 13413, 13417, 13421, 13425, 13429, 13433,
-     13437, 13441, 13445, 13449, 13453, 13457, 13461, 13465, 13469, 13473,
-     13477, 13481, 13485, 13489, 13493, 13497, 13501, 13505, 13509, 13513,
-     13517, 13521, 13525, 13529, 13533, 13537, 13541, 13545, 13549, 13553,
-     13557, 13561, 13565, 13569, 13573, 13577, 13581, 13585, 13589, 13593,
-     13597, 13601, 13605, 13609, 13613, 13617, 13621, 13625, 13629, 13633,
-     13637, 13641, 13645, 13648, 13648, 13648, 13649, 13653, 13657, 13661,
-     13665, 13669, 13673, 13677, 13681, 13685, 13689, 13693, 13697, 13701,
-     13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704,
-     13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704,
-     13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704,
-     13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704,
-     13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704,
-     13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704,
-     13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704,
-     13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704,
-     13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704, 13704,
-     13704, 13704, 13704, 13704, 13704, 13704, 13705},
-    {13705, 13717, 13729, 13741, 13753, 13765, 13777, 13789, 13801, 13813,
-     13825, 13837, 13849, 13861, 13873, 13889, 13905, 13921, 13937, 13953,
-     13969, 13985, 14001, 14017, 14033, 14049, 14065, 14081, 14097, 14113,
-     14141, 14164, 14165, 14177, 14189, 14201, 14213, 14225, 14237, 14249,
-     14261, 14273, 14285, 14297, 14309, 14321, 14333, 14345, 14357, 14369,
-     14381, 14393, 14405, 14417, 14429, 14441, 14453, 14465, 14477, 14489,
-     14501, 14513, 14525, 14537, 14549, 14561, 14573, 14585, 14597, 14601,
-     14605, 14609, 14612, 14612, 14612, 14612, 14612, 14612, 14612, 14612,
-     14613, 14625, 14633, 14641, 14649, 14657, 14665, 14673, 14681, 14689,
-     14697, 14705, 14713, 14721, 14729, 14737, 14745, 14749, 14753, 14757,
-     14761, 14765, 14769, 14773, 14777, 14781, 14785, 14789, 14793, 14797,
-     14801, 14809, 14817, 14825, 14833, 14841, 14849, 14857, 14865, 14873,
-     14881, 14889, 14897, 14905, 14913, 14933, 14949, 14956, 14957, 14961,
-     14965, 14969, 14973, 14977, 14981, 14985, 14989, 14993, 14997, 15001,
-     15005, 15009, 15013, 15017, 15021, 15025, 15029, 15033, 15037, 15041,
-     15045, 15049, 15053, 15057, 15061, 15065, 15069, 15073, 15077, 15081,
-     15085, 15089, 15093, 15097, 15101, 15105, 15109, 15113, 15117, 15121,
-     15125, 15129, 15133, 15137, 15141, 15145, 15149, 15153, 15161, 15169,
-     15177, 15185, 15193, 15201, 15209, 15217, 15225, 15233, 15241, 15249,
-     15257, 15265, 15273, 15281, 15289, 15297, 15305, 15313, 15321, 15329,
-     15337, 15345, 15357, 15369, 15381, 15389, 15401, 15409, 15421, 15425,
-     15429, 15433, 15437, 15441, 15445, 15449, 15453, 15457, 15461, 15465,
-     15469, 15473, 15477, 15481, 15485, 15489, 15493, 15497, 15501, 15505,
-     15509, 15513, 15517, 15521, 15525, 15529, 15533, 15537, 15541, 15545,
-     15549, 15553, 15557, 15561, 15565, 15569, 15573, 15577, 15581, 15585,
-     15589, 15593, 15597, 15601, 15605, 15609, 15617},
-    {15617, 15637, 15653, 15673, 15685, 15705, 15717, 15729, 15753, 15769,
-     15781, 15793, 15805, 15821, 15837, 15853, 15869, 15885, 15901, 15917,
-     15941, 15949, 15973, 15997, 16017, 16033, 16057, 16081, 16097, 16109,
-     16121, 16137, 16153, 16173, 16193, 16205, 16217, 16233, 16245, 16257,
-     16265, 16273, 16285, 16297, 16321, 16337, 16357, 16381, 16397, 16409,
-     16421, 16445, 16461, 16485, 16497, 16517, 16529, 16545, 16557, 16573,
-     16593, 16609, 16629, 16645, 16653, 16673, 16685, 16697, 16713, 16725,
-     16737, 16749, 16769, 16785, 16793, 16817, 16829, 16849, 16865, 16881,
-     16893, 16905, 16921, 16929, 16945, 16965, 16973, 16997, 17009, 17017,
-     17025, 17033, 17041, 17049, 17057, 17065, 17073, 17081, 17089, 17101,
-     17113, 17125, 17137, 17149, 17161, 17173, 17185, 17197, 17209, 17221,
-     17233, 17245, 17257, 17269, 17281, 17289, 17297, 17309, 17317, 17325,
-     17333, 17345, 17357, 17365, 17373, 17381, 17389, 17397, 17413, 17421,
-     17429, 17437, 17445, 17453, 17461, 17469, 17477, 17489, 17505, 17513,
-     17521, 17529, 17537, 17545, 17553, 17561, 17573, 17585, 17597, 17609,
-     17617, 17625, 17633, 17641, 17649, 17657, 17665, 17673, 17681, 17689,
-     17701, 17713, 17721, 17733, 17745, 17757, 17765, 17777, 17789, 17805,
-     17813, 17825, 17837, 17849, 17861, 17881, 17905, 17913, 17921, 17929,
-     17937, 17945, 17953, 17961, 17969, 17977, 17985, 17993, 18001, 18009,
-     18017, 18025, 18033, 18041, 18049, 18065, 18073, 18081, 18089, 18105,
-     18117, 18125, 18133, 18141, 18149, 18157, 18165, 18173, 18181, 18189,
-     18197, 18209, 18217, 18225, 18237, 18249, 18257, 18273, 18285, 18293,
-     18301, 18309, 18317, 18329, 18341, 18349, 18357, 18365, 18373, 18381,
-     18389, 18397, 18405, 18413, 18425, 18437, 18449, 18461, 18473, 18485,
-     18497, 18509, 18521, 18533, 18545, 18557, 18569, 18581, 18593, 18605,
-     18617, 18629, 18641, 18653, 18665, 18677, 18688},
-    {18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688,
-     18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688,
-     18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688,
-     18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688,
-     18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688,
-     18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688,
-     18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688,
-     18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688,
-     18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688,
-     18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688,
-     18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688,
-     18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688,
-     18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688,
-     18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688,
-     18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688, 18688,
-     18688, 18688, 18688, 18688, 18688, 18688, 18689, 18693, 18696, 18696,
-     18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696,
-     18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696,
-     18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696,
-     18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696,
-     18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696,
-     18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696,
-     18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696,
-     18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696,
-     18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696,
-     18696, 18696, 18696, 18696, 18696, 18696, 18696},
-    {18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696,
-     18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696,
-     18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696,
-     18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696,
-     18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696,
-     18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696,
-     18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696,
-     18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696,
-     18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696,
-     18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696,
-     18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696, 18696,
-     18696, 18696, 18697, 18700, 18700, 18700, 18700, 18700, 18700, 18700,
-     18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700,
-     18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700,
-     18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700,
-     18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700,
-     18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700,
-     18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700,
-     18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700,
-     18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700,
-     18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700,
-     18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700,
-     18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700,
-     18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700, 18700,
-     18700, 18700, 18701, 18705, 18709, 18712, 18712, 18712, 18713, 18717,
-     18720, 18720, 18720, 18720, 18720, 18720, 18720},
-    {18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720,
-     18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720,
-     18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720,
-     18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720,
-     18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720,
-     18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720,
-     18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720,
-     18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720,
-     18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720, 18720,
-     18720, 18720, 18721, 18725, 18729, 18733, 18736, 18736, 18736, 18736,
-     18736, 18736, 18736, 18736, 18736, 18737, 18740, 18740, 18740, 18740,
-     18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740,
-     18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740,
-     18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740,
-     18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740,
-     18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740,
-     18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740,
-     18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740,
-     18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740,
-     18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740,
-     18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740,
-     18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740,
-     18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740,
-     18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740,
-     18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740, 18740,
-     18740, 18740, 18740, 18740, 18740, 18740, 18740},
-    {18740, 18744, 18748, 18752, 18756, 18760, 18764, 18768, 18772, 18776,
-     18780, 18784, 18788, 18792, 18796, 18800, 18804, 18808, 18812, 18816,
-     18820, 18824, 18828, 18832, 18836, 18840, 18844, 18848, 18852, 18856,
-     18860, 18864, 18868, 18872, 18876, 18880, 18884, 18888, 18892, 18896,
-     18900, 18904, 18908, 18912, 18916, 18920, 18924, 18928, 18932, 18936,
-     18940, 18944, 18948, 18952, 18956, 18960, 18964, 18968, 18972, 18976,
-     18980, 18984, 18988, 18992, 18996, 19000, 19004, 19008, 19012, 19016,
-     19020, 19024, 19028, 19032, 19036, 19040, 19044, 19048, 19052, 19056,
-     19060, 19064, 19068, 19072, 19076, 19080, 19084, 19088, 19092, 19096,
-     19100, 19104, 19108, 19112, 19116, 19120, 19124, 19128, 19132, 19136,
-     19140, 19144, 19148, 19152, 19156, 19160, 19164, 19168, 19172, 19176,
-     19180, 19184, 19188, 19192, 19196, 19200, 19204, 19208, 19212, 19216,
-     19220, 19224, 19228, 19232, 19236, 19240, 19244, 19248, 19252, 19256,
-     19260, 19264, 19268, 19272, 19276, 19280, 19284, 19288, 19292, 19296,
-     19300, 19304, 19308, 19312, 19316, 19320, 19324, 19328, 19332, 19336,
-     19340, 19344, 19348, 19352, 19356, 19360, 19364, 19368, 19372, 19376,
-     19380, 19384, 19388, 19392, 19396, 19400, 19404, 19408, 19412, 19416,
-     19420, 19424, 19428, 19432, 19436, 19440, 19444, 19448, 19452, 19456,
-     19460, 19464, 19468, 19472, 19476, 19480, 19484, 19488, 19492, 19496,
-     19500, 19504, 19508, 19512, 19516, 19520, 19524, 19528, 19532, 19536,
-     19540, 19544, 19548, 19552, 19556, 19560, 19564, 19568, 19572, 19576,
-     19580, 19584, 19588, 19592, 19596, 19600, 19604, 19608, 19612, 19616,
-     19620, 19624, 19628, 19632, 19636, 19640, 19644, 19648, 19652, 19656,
-     19660, 19664, 19668, 19672, 19676, 19680, 19684, 19688, 19692, 19696,
-     19700, 19704, 19708, 19712, 19716, 19720, 19724, 19728, 19732, 19736,
-     19740, 19744, 19748, 19752, 19756, 19760, 19764},
-    {19764, 19768, 19772, 19776, 19780, 19784, 19788, 19792, 19796, 19800,
-     19804, 19808, 19812, 19816, 19820, 19820, 19820, 19824, 19824, 19828,
-     19828, 19828, 19832, 19836, 19840, 19844, 19848, 19852, 19856, 19860,
-     19864, 19868, 19868, 19872, 19872, 19876, 19876, 19876, 19880, 19884,
-     19884, 19884, 19884, 19888, 19892, 19896, 19900, 19904, 19908, 19912,
-     19916, 19920, 19924, 19928, 19932, 19936, 19940, 19944, 19948, 19952,
-     19956, 19960, 19964, 19968, 19972, 19976, 19980, 19984, 19988, 19992,
-     19996, 20000, 20004, 20008, 20012, 20016, 20020, 20024, 20028, 20032,
-     20036, 20040, 20044, 20048, 20052, 20056, 20060, 20064, 20068, 20072,
-     20076, 20080, 20084, 20088, 20092, 20096, 20100, 20104, 20108, 20112,
-     20116, 20120, 20124, 20128, 20132, 20136, 20140, 20144, 20148, 20152,
-     20156, 20156, 20156, 20160, 20164, 20168, 20172, 20176, 20180, 20184,
-     20188, 20192, 20196, 20200, 20204, 20208, 20212, 20216, 20220, 20224,
-     20228, 20232, 20236, 20240, 20244, 20248, 20252, 20256, 20260, 20264,
-     20268, 20272, 20276, 20280, 20284, 20288, 20292, 20296, 20300, 20304,
-     20308, 20312, 20316, 20320, 20324, 20328, 20332, 20336, 20340, 20344,
-     20348, 20352, 20356, 20360, 20364, 20368, 20372, 20376, 20380, 20384,
-     20388, 20392, 20396, 20400, 20404, 20408, 20412, 20416, 20420, 20424,
-     20428, 20432, 20436, 20440, 20444, 20448, 20452, 20456, 20460, 20464,
-     20468, 20472, 20476, 20480, 20484, 20488, 20492, 20496, 20500, 20504,
-     20508, 20512, 20516, 20520, 20524, 20528, 20532, 20536, 20540, 20544,
-     20548, 20552, 20556, 20560, 20564, 20568, 20572, 20576, 20580, 20580,
-     20580, 20580, 20580, 20580, 20580, 20580, 20580, 20580, 20580, 20580,
-     20580, 20580, 20580, 20580, 20580, 20580, 20580, 20580, 20580, 20580,
-     20580, 20580, 20580, 20580, 20580, 20580, 20580, 20580, 20580, 20580,
-     20580, 20580, 20580, 20580, 20580, 20580, 20581},
-    {20581, 20589, 20597, 20605, 20617, 20629, 20637, 20644, 20644, 20644,
-     20644, 20644, 20644, 20644, 20644, 20644, 20644, 20644, 20644, 20645,
-     20653, 20661, 20669, 20677, 20684, 20684, 20684, 20684, 20684, 20684,
-     20692, 20692, 20701, 20705, 20709, 20713, 20717, 20721, 20725, 20729,
-     20733, 20737, 20740, 20748, 20756, 20768, 20780, 20788, 20796, 20804,
-     20812, 20820, 20828, 20836, 20844, 20852, 20852, 20860, 20868, 20876,
-     20884, 20892, 20892, 20900, 20900, 20908, 20916, 20916, 20924, 20932,
-     20932, 20940, 20948, 20956, 20964, 20972, 20980, 20988, 20996, 21005,
-     21013, 21017, 21021, 21025, 21029, 21033, 21037, 21041, 21045, 21049,
-     21053, 21057, 21061, 21065, 21069, 21073, 21077, 21081, 21085, 21089,
-     21093, 21097, 21101, 21105, 21109, 21113, 21117, 21121, 21125, 21129,
-     21133, 21137, 21141, 21145, 21149, 21153, 21157, 21161, 21165, 21169,
-     21173, 21177, 21181, 21185, 21189, 21193, 21197, 21201, 21205, 21209,
-     21213, 21217, 21221, 21225, 21229, 21233, 21237, 21241, 21245, 21249,
-     21253, 21257, 21261, 21265, 21269, 21273, 21277, 21281, 21285, 21289,
-     21293, 21297, 21301, 21305, 21309, 21313, 21317, 21321, 21325, 21329,
-     21333, 21337, 21341, 21345, 21349, 21357, 21365, 21369, 21373, 21377,
-     21381, 21385, 21389, 21393, 21397, 21401, 21405, 21413, 21420, 21420,
-     21420, 21420, 21420, 21420, 21420, 21420, 21420, 21420, 21420, 21420,
-     21420, 21420, 21420, 21420, 21420, 21420, 21420, 21420, 21420, 21420,
-     21420, 21420, 21420, 21420, 21420, 21420, 21420, 21420, 21420, 21420,
-     21420, 21421, 21425, 21429, 21433, 21437, 21441, 21445, 21449, 21453,
-     21457, 21461, 21469, 21473, 21477, 21481, 21485, 21489, 21493, 21497,
-     21501, 21505, 21509, 21513, 21517, 21529, 21541, 21553, 21565, 21577,
-     21589, 21601, 21613, 21625, 21637, 21649, 21661, 21673, 21685, 21697,
-     21709, 21721, 21733, 21737, 21741, 21745, 21749},
-    {21749, 21761, 21773, 21785, 21797, 21809, 21817, 21825, 21833, 21841,
-     21849, 21857, 21865, 21873, 21881, 21889, 21897, 21905, 21913, 21921,
-     21929, 21937, 21945, 21953, 21961, 21969, 21977, 21985, 21993, 22001,
-     22009, 22017, 22025, 22033, 22041, 22049, 22057, 22065, 22073, 22081,
-     22089, 22097, 22105, 22113, 22121, 22129, 22137, 22145, 22153, 22161,
-     22169, 22177, 22185, 22193, 22201, 22209, 22217, 22225, 22233, 22241,
-     22249, 22257, 22265, 22273, 22281, 22289, 22297, 22305, 22313, 22321,
-     22329, 22337, 22345, 22353, 22361, 22369, 22377, 22385, 22393, 22401,
-     22409, 22417, 22425, 22433, 22441, 22449, 22457, 22465, 22473, 22481,
-     22489, 22497, 22505, 22513, 22521, 22533, 22545, 22557, 22569, 22581,
-     22593, 22605, 22617, 22629, 22641, 22653, 22665, 22673, 22681, 22689,
-     22697, 22705, 22713, 22721, 22729, 22737, 22745, 22753, 22761, 22769,
-     22777, 22785, 22793, 22801, 22809, 22817, 22825, 22833, 22841, 22849,
-     22857, 22865, 22873, 22881, 22889, 22897, 22905, 22913, 22921, 22929,
-     22937, 22945, 22953, 22961, 22969, 22977, 22985, 22993, 23001, 23009,
-     23017, 23025, 23037, 23049, 23061, 23073, 23085, 23093, 23101, 23109,
-     23117, 23125, 23133, 23141, 23149, 23157, 23165, 23173, 23181, 23189,
-     23197, 23205, 23213, 23221, 23229, 23237, 23245, 23253, 23261, 23269,
-     23277, 23285, 23293, 23301, 23309, 23317, 23325, 23333, 23341, 23349,
-     23357, 23365, 23373, 23381, 23389, 23397, 23405, 23413, 23421, 23429,
-     23437, 23445, 23453, 23461, 23469, 23477, 23485, 23493, 23501, 23509,
-     23517, 23525, 23533, 23541, 23549, 23557, 23565, 23573, 23581, 23589,
-     23597, 23605, 23613, 23621, 23633, 23645, 23653, 23661, 23669, 23677,
-     23685, 23693, 23701, 23709, 23717, 23725, 23733, 23741, 23749, 23757,
-     23765, 23773, 23781, 23793, 23805, 23817, 23825, 23833, 23841, 23849,
-     23857, 23865, 23873, 23881, 23889, 23897, 23905},
-    {23905, 23913, 23921, 23929, 23937, 23945, 23953, 23961, 23969, 23977,
-     23985, 23993, 24001, 24009, 24017, 24025, 24033, 24041, 24049, 24057,
-     24065, 24073, 24081, 24089, 24097, 24105, 24113, 24121, 24129, 24137,
-     24145, 24153, 24161, 24169, 24177, 24185, 24193, 24201, 24209, 24217,
-     24225, 24233, 24241, 24249, 24257, 24265, 24273, 24281, 24289, 24297,
-     24305, 24313, 24321, 24329, 24337, 24345, 24353, 24361, 24369, 24377,
-     24385, 24393, 24400, 24400, 24400, 24400, 24400, 24400, 24400, 24400,
-     24400, 24400, 24400, 24400, 24400, 24400, 24400, 24400, 24400, 24400,
-     24401, 24413, 24425, 24437, 24449, 24461, 24473, 24485, 24497, 24509,
-     24521, 24533, 24545, 24557, 24569, 24581, 24593, 24605, 24617, 24629,
-     24641, 24653, 24665, 24677, 24689, 24701, 24713, 24725, 24737, 24749,
-     24761, 24773, 24785, 24797, 24809, 24821, 24833, 24845, 24857, 24869,
-     24881, 24893, 24905, 24917, 24929, 24941, 24953, 24965, 24977, 24989,
-     25001, 25013, 25025, 25037, 25049, 25061, 25073, 25085, 25097, 25109,
-     25121, 25133, 25145, 25157, 25168, 25168, 25169, 25181, 25193, 25205,
-     25217, 25229, 25241, 25253, 25265, 25277, 25289, 25301, 25313, 25325,
-     25337, 25349, 25361, 25373, 25385, 25397, 25409, 25421, 25433, 25445,
-     25457, 25469, 25481, 25493, 25505, 25517, 25529, 25541, 25553, 25565,
-     25577, 25589, 25601, 25613, 25625, 25637, 25649, 25661, 25673, 25685,
-     25697, 25709, 25721, 25733, 25745, 25757, 25769, 25781, 25793, 25805,
-     25816, 25816, 25816, 25816, 25816, 25816, 25816, 25816, 25816, 25816,
-     25816, 25816, 25816, 25816, 25816, 25816, 25816, 25816, 25816, 25816,
-     25816, 25816, 25816, 25816, 25816, 25816, 25816, 25816, 25816, 25816,
-     25816, 25816, 25816, 25816, 25816, 25816, 25816, 25816, 25816, 25816,
-     25817, 25829, 25841, 25857, 25873, 25889, 25905, 25921, 25937, 25953,
-     25965, 26037, 26069, 26084, 26084, 26084, 26084},
-    {26084, 26084, 26084, 26084, 26084, 26084, 26084, 26084, 26084, 26084,
-     26084, 26084, 26084, 26084, 26084, 26084, 26085, 26089, 26093, 26097,
-     26101, 26105, 26109, 26113, 26117, 26121, 26132, 26132, 26132, 26132,
-     26132, 26132, 26132, 26132, 26132, 26132, 26132, 26132, 26132, 26132,
-     26132, 26132, 26132, 26132, 26132, 26132, 26132, 26132, 26133, 26141,
-     26145, 26149, 26153, 26157, 26161, 26165, 26169, 26173, 26177, 26181,
-     26185, 26189, 26193, 26197, 26201, 26205, 26209, 26213, 26217, 26220,
-     26220, 26221, 26225, 26229, 26237, 26245, 26253, 26261, 26265, 26269,
-     26273, 26277, 26281, 26284, 26285, 26289, 26293, 26297, 26301, 26305,
-     26309, 26313, 26317, 26321, 26325, 26329, 26333, 26337, 26341, 26345,
-     26349, 26353, 26357, 26360, 26361, 26365, 26369, 26373, 26376, 26376,
-     26376, 26376, 26377, 26385, 26393, 26400, 26401, 26408, 26409, 26417,
-     26425, 26433, 26441, 26449, 26457, 26465, 26473, 26481, 26489, 26493,
-     26501, 26509, 26517, 26525, 26533, 26541, 26549, 26557, 26565, 26573,
-     26581, 26589, 26593, 26597, 26601, 26605, 26609, 26613, 26617, 26621,
-     26625, 26629, 26633, 26637, 26641, 26645, 26649, 26653, 26657, 26661,
-     26665, 26669, 26673, 26677, 26681, 26685, 26689, 26693, 26697, 26701,
-     26705, 26709, 26713, 26717, 26721, 26725, 26729, 26733, 26737, 26741,
-     26745, 26749, 26753, 26757, 26761, 26765, 26769, 26773, 26777, 26781,
-     26785, 26789, 26793, 26797, 26801, 26805, 26809, 26813, 26817, 26821,
-     26825, 26829, 26833, 26837, 26841, 26845, 26849, 26853, 26857, 26861,
-     26865, 26869, 26873, 26877, 26881, 26885, 26889, 26893, 26897, 26901,
-     26905, 26909, 26913, 26917, 26921, 26925, 26929, 26933, 26937, 26941,
-     26945, 26949, 26953, 26957, 26961, 26965, 26969, 26973, 26977, 26981,
-     26985, 26989, 26993, 26997, 27001, 27005, 27017, 27029, 27041, 27053,
-     27065, 27077, 27085, 27092, 27092, 27092, 27092},
-    {27092, 27093, 27097, 27101, 27105, 27109, 27113, 27117, 27121, 27125,
-     27129, 27133, 27137, 27141, 27145, 27149, 27153, 27157, 27161, 27165,
-     27169, 27173, 27177, 27181, 27185, 27189, 27193, 27197, 27201, 27205,
-     27209, 27213, 27217, 27221, 27225, 27229, 27233, 27237, 27241, 27245,
-     27249, 27253, 27257, 27261, 27265, 27269, 27273, 27277, 27281, 27285,
-     27289, 27293, 27297, 27301, 27305, 27309, 27313, 27317, 27321, 27325,
-     27329, 27333, 27337, 27341, 27345, 27349, 27353, 27357, 27361, 27365,
-     27369, 27373, 27377, 27381, 27385, 27389, 27393, 27397, 27401, 27405,
-     27409, 27413, 27417, 27421, 27425, 27429, 27433, 27437, 27441, 27445,
-     27449, 27453, 27457, 27461, 27465, 27469, 27473, 27477, 27481, 27485,
-     27489, 27493, 27497, 27501, 27505, 27509, 27513, 27517, 27521, 27525,
-     27529, 27533, 27537, 27541, 27545, 27549, 27553, 27557, 27561, 27565,
-     27569, 27573, 27577, 27581, 27585, 27589, 27593, 27597, 27601, 27605,
-     27609, 27613, 27617, 27621, 27625, 27629, 27633, 27637, 27641, 27645,
-     27649, 27653, 27657, 27661, 27665, 27669, 27673, 27677, 27681, 27685,
-     27689, 27693, 27697, 27701, 27705, 27709, 27713, 27717, 27721, 27725,
-     27729, 27733, 27737, 27741, 27745, 27749, 27753, 27757, 27761, 27765,
-     27769, 27773, 27777, 27781, 27785, 27789, 27793, 27797, 27801, 27805,
-     27809, 27813, 27817, 27821, 27825, 27829, 27833, 27837, 27841, 27845,
-     27849, 27852, 27852, 27852, 27853, 27857, 27861, 27865, 27869, 27873,
-     27876, 27876, 27877, 27881, 27885, 27889, 27893, 27897, 27900, 27900,
-     27901, 27905, 27909, 27913, 27917, 27921, 27924, 27924, 27925, 27929,
-     27933, 27936, 27936, 27936, 27937, 27941, 27945, 27949, 27957, 27961,
-     27965, 27968, 27969, 27973, 27977, 27981, 27985, 27989, 27993, 27996,
-     27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996,
-     27996, 27996, 27996, 27996, 27996, 27996, 27996},
-    {27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996,
-     27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996,
-     27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996,
-     27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996,
-     27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996,
-     27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996,
-     27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996,
-     27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996,
-     27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996,
-     27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996,
-     27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996,
-     27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996,
-     27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27996, 27997,
-     28001, 28005, 28009, 28013, 28016, 28017, 28021, 28025, 28029, 28033,
-     28037, 28041, 28045, 28049, 28053, 28057, 28061, 28065, 28069, 28073,
-     28077, 28081, 28085, 28089, 28093, 28097, 28101, 28105, 28109, 28113,
-     28117, 28121, 28125, 28129, 28133, 28137, 28141, 28145, 28149, 28153,
-     28157, 28161, 28165, 28169, 28173, 28177, 28181, 28184, 28185, 28189,
-     28193, 28197, 28201, 28205, 28209, 28213, 28217, 28220, 28220, 28220,
-     28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220,
-     28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220,
-     28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220,
-     28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220,
-     28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220,
-     28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220,
-     28220, 28220, 28220, 28220, 28220, 28220, 28220},
-    {28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220,
-     28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220,
-     28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220,
-     28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220,
-     28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220,
-     28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220,
-     28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220,
-     28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220,
-     28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220,
-     28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220,
-     28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220,
-     28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220,
-     28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220,
-     28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220,
-     28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220, 28220,
-     28220, 28220, 28220, 28220, 28220, 28228, 28228, 28236, 28236, 28236,
-     28236, 28236, 28236, 28236, 28236, 28236, 28236, 28236, 28236, 28236,
-     28236, 28236, 28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244,
-     28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244,
-     28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244,
-     28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244,
-     28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244,
-     28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244,
-     28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244,
-     28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244,
-     28244, 28244, 28244, 28244, 28244, 28244, 28244},
-    {28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244,
-     28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244,
-     28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244,
-     28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244, 28244,
-     28244, 28244, 28244, 28244, 28244, 28244, 28244, 28252, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260},
-    {28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260, 28260,
-     28260, 28260, 28260, 28260, 28260, 28260, 28268, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276},
-    {28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276,
-     28276, 28276, 28276, 28276, 28276, 28276, 28276, 28276, 28284, 28292,
-     28292, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300,
-     28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300,
-     28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300,
-     28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300,
-     28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300,
-     28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300,
-     28300, 28300, 28300, 28300, 28300, 28300, 28300},
-    {28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300,
-     28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300,
-     28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300,
-     28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300,
-     28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300,
-     28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300,
-     28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300,
-     28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300,
-     28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300,
-     28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300,
-     28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300,
-     28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300,
-     28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300,
-     28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300,
-     28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300,
-     28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300,
-     28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300,
-     28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300, 28300,
-     28300, 28300, 28300, 28300, 28300, 28300, 28300, 28308, 28316, 28316,
-     28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316,
-     28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316,
-     28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316,
-     28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316,
-     28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316,
-     28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316,
-     28316, 28316, 28316, 28316, 28316, 28316, 28316},
-    {28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316,
-     28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316,
-     28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316,
-     28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316,
-     28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316, 28316,
-     28316, 28316, 28316, 28316, 28316, 28316, 28316, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324},
-    {28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324, 28324,
-     28324, 28324, 28324, 28324, 28324, 28332, 28340, 28352, 28364, 28376,
-     28388, 28400, 28400, 28400, 28400, 28400, 28400, 28400, 28400, 28400,
-     28400, 28400, 28400, 28400, 28400, 28400, 28400, 28400, 28400, 28400,
-     28400, 28400, 28400, 28400, 28400, 28400, 28400, 28400, 28400, 28400,
-     28400, 28400, 28400, 28400, 28400, 28400, 28400, 28400, 28400, 28400,
-     28400, 28400, 28400, 28400, 28400, 28400, 28400, 28400, 28400, 28400,
-     28400, 28400, 28400, 28400, 28400, 28400, 28400, 28400, 28400, 28400,
-     28400, 28400, 28400, 28400, 28400, 28400, 28400, 28400, 28400, 28400,
-     28400, 28400, 28400, 28400, 28400, 28400, 28400, 28400, 28400, 28400,
-     28400, 28400, 28400, 28400, 28400, 28400, 28400, 28400, 28408, 28416,
-     28428, 28440, 28452, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464},
-    {28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464, 28464,
-     28464, 28464, 28464, 28464, 28464, 28464, 28465},
-    {28465, 28469, 28473, 28477, 28481, 28485, 28489, 28493, 28497, 28501,
-     28505, 28509, 28513, 28517, 28521, 28525, 28529, 28533, 28537, 28541,
-     28545, 28549, 28553, 28557, 28561, 28565, 28569, 28573, 28577, 28581,
-     28585, 28589, 28593, 28597, 28601, 28605, 28609, 28613, 28617, 28621,
-     28625, 28629, 28633, 28637, 28641, 28645, 28649, 28653, 28657, 28661,
-     28665, 28669, 28673, 28677, 28681, 28685, 28689, 28693, 28697, 28701,
-     28705, 28709, 28713, 28717, 28721, 28725, 28729, 28733, 28737, 28741,
-     28745, 28749, 28753, 28757, 28761, 28765, 28769, 28773, 28777, 28781,
-     28785, 28789, 28793, 28797, 28801, 28804, 28805, 28809, 28813, 28817,
-     28821, 28825, 28829, 28833, 28837, 28841, 28845, 28849, 28853, 28857,
-     28861, 28865, 28869, 28873, 28877, 28881, 28885, 28889, 28893, 28897,
-     28901, 28905, 28909, 28913, 28917, 28921, 28925, 28929, 28933, 28937,
-     28941, 28945, 28949, 28953, 28957, 28961, 28965, 28969, 28973, 28977,
-     28981, 28985, 28989, 28993, 28997, 29001, 29005, 29009, 29013, 29017,
-     29021, 29025, 29029, 29033, 29037, 29041, 29045, 29049, 29053, 29057,
-     29061, 29065, 29069, 29073, 29077, 29081, 29085, 29088, 29089, 29093,
-     29096, 29096, 29097, 29100, 29100, 29101, 29105, 29108, 29108, 29109,
-     29113, 29117, 29121, 29124, 29125, 29129, 29133, 29137, 29141, 29145,
-     29149, 29153, 29157, 29161, 29165, 29169, 29172, 29173, 29176, 29177,
-     29181, 29185, 29189, 29193, 29197, 29201, 29204, 29205, 29209, 29213,
-     29217, 29221, 29225, 29229, 29233, 29237, 29241, 29245, 29249, 29253,
-     29257, 29261, 29265, 29269, 29273, 29277, 29281, 29285, 29289, 29293,
-     29297, 29301, 29305, 29309, 29313, 29317, 29321, 29325, 29329, 29333,
-     29337, 29341, 29345, 29349, 29353, 29357, 29361, 29365, 29369, 29373,
-     29377, 29381, 29385, 29389, 29393, 29397, 29401, 29405, 29409, 29413,
-     29417, 29421, 29425, 29429, 29433, 29437, 29441},
-    {29441, 29445, 29449, 29453, 29457, 29461, 29464, 29465, 29469, 29473,
-     29477, 29480, 29480, 29481, 29485, 29489, 29493, 29497, 29501, 29505,
-     29509, 29512, 29513, 29517, 29521, 29525, 29529, 29533, 29537, 29540,
-     29541, 29545, 29549, 29553, 29557, 29561, 29565, 29569, 29573, 29577,
-     29581, 29585, 29589, 29593, 29597, 29601, 29605, 29609, 29613, 29617,
-     29621, 29625, 29629, 29633, 29637, 29641, 29645, 29649, 29652, 29653,
-     29657, 29661, 29665, 29668, 29669, 29673, 29677, 29681, 29685, 29688,
-     29689, 29692, 29692, 29692, 29693, 29697, 29701, 29705, 29709, 29713,
-     29717, 29720, 29721, 29725, 29729, 29733, 29737, 29741, 29745, 29749,
-     29753, 29757, 29761, 29765, 29769, 29773, 29777, 29781, 29785, 29789,
-     29793, 29797, 29801, 29805, 29809, 29813, 29817, 29821, 29825, 29829,
-     29833, 29837, 29841, 29845, 29849, 29853, 29857, 29861, 29865, 29869,
-     29873, 29877, 29881, 29885, 29889, 29893, 29897, 29901, 29905, 29909,
-     29913, 29917, 29921, 29925, 29929, 29933, 29937, 29941, 29945, 29949,
-     29953, 29957, 29961, 29965, 29969, 29973, 29977, 29981, 29985, 29989,
-     29993, 29997, 30001, 30005, 30009, 30013, 30017, 30021, 30025, 30029,
-     30033, 30037, 30041, 30045, 30049, 30053, 30057, 30061, 30065, 30069,
-     30073, 30077, 30081, 30085, 30089, 30093, 30097, 30101, 30105, 30109,
-     30113, 30117, 30121, 30125, 30129, 30133, 30137, 30141, 30145, 30149,
-     30153, 30157, 30161, 30165, 30169, 30173, 30177, 30181, 30185, 30189,
-     30193, 30197, 30201, 30205, 30209, 30213, 30217, 30221, 30225, 30229,
-     30233, 30237, 30241, 30245, 30249, 30253, 30257, 30261, 30265, 30269,
-     30273, 30277, 30281, 30285, 30289, 30293, 30297, 30301, 30305, 30309,
-     30313, 30317, 30321, 30325, 30329, 30333, 30337, 30341, 30345, 30349,
-     30353, 30357, 30361, 30365, 30369, 30373, 30377, 30381, 30385, 30389,
-     30393, 30397, 30401, 30405, 30409, 30413, 30417},
-    {30417, 30421, 30425, 30429, 30433, 30437, 30441, 30445, 30449, 30453,
-     30457, 30461, 30465, 30469, 30473, 30477, 30481, 30485, 30489, 30493,
-     30497, 30501, 30505, 30509, 30513, 30517, 30521, 30525, 30529, 30533,
-     30537, 30541, 30545, 30549, 30553, 30557, 30561, 30565, 30569, 30573,
-     30577, 30581, 30585, 30589, 30593, 30597, 30601, 30605, 30609, 30613,
-     30617, 30621, 30625, 30629, 30633, 30637, 30641, 30645, 30649, 30653,
-     30657, 30661, 30665, 30669, 30673, 30677, 30681, 30685, 30689, 30693,
-     30697, 30701, 30705, 30709, 30713, 30717, 30721, 30725, 30729, 30733,
-     30737, 30741, 30745, 30749, 30753, 30757, 30761, 30765, 30769, 30773,
-     30777, 30781, 30785, 30789, 30793, 30797, 30801, 30805, 30809, 30813,
-     30817, 30821, 30825, 30829, 30833, 30837, 30841, 30845, 30849, 30853,
-     30857, 30861, 30865, 30869, 30873, 30877, 30881, 30885, 30889, 30893,
-     30897, 30901, 30905, 30909, 30913, 30917, 30921, 30925, 30929, 30933,
-     30937, 30941, 30945, 30949, 30953, 30957, 30961, 30965, 30969, 30973,
-     30977, 30981, 30985, 30989, 30993, 30997, 31001, 31005, 31009, 31013,
-     31017, 31021, 31025, 31029, 31033, 31037, 31041, 31045, 31049, 31053,
-     31057, 31061, 31065, 31069, 31073, 31077, 31080, 31080, 31081, 31085,
-     31089, 31093, 31097, 31101, 31105, 31109, 31113, 31117, 31121, 31125,
-     31129, 31133, 31137, 31141, 31145, 31149, 31153, 31157, 31161, 31165,
-     31169, 31173, 31177, 31181, 31185, 31189, 31193, 31197, 31201, 31205,
-     31209, 31213, 31217, 31221, 31225, 31229, 31233, 31237, 31241, 31245,
-     31249, 31253, 31257, 31261, 31265, 31269, 31273, 31277, 31281, 31285,
-     31289, 31293, 31297, 31301, 31305, 31309, 31313, 31317, 31321, 31325,
-     31329, 31333, 31337, 31341, 31345, 31349, 31353, 31357, 31361, 31365,
-     31369, 31373, 31377, 31381, 31385, 31389, 31393, 31397, 31401, 31405,
-     31409, 31413, 31417, 31421, 31425, 31429, 31433},
-    {31433, 31437, 31441, 31445, 31449, 31453, 31457, 31461, 31465, 31469,
-     31473, 31477, 31481, 31485, 31489, 31493, 31497, 31501, 31505, 31509,
-     31513, 31517, 31521, 31525, 31529, 31533, 31537, 31541, 31545, 31549,
-     31553, 31557, 31561, 31565, 31569, 31573, 31577, 31581, 31585, 31589,
-     31593, 31597, 31601, 31605, 31609, 31613, 31617, 31621, 31625, 31629,
-     31633, 31637, 31641, 31645, 31649, 31653, 31657, 31661, 31665, 31669,
-     31673, 31677, 31681, 31685, 31689, 31693, 31697, 31701, 31705, 31709,
-     31713, 31717, 31721, 31725, 31729, 31733, 31737, 31741, 31745, 31749,
-     31753, 31757, 31761, 31765, 31769, 31773, 31777, 31781, 31785, 31789,
-     31793, 31797, 31801, 31805, 31809, 31813, 31817, 31821, 31825, 31829,
-     31833, 31837, 31841, 31845, 31849, 31853, 31857, 31861, 31865, 31869,
-     31873, 31877, 31881, 31885, 31889, 31893, 31897, 31901, 31905, 31909,
-     31913, 31917, 31921, 31925, 31929, 31933, 31937, 31941, 31945, 31949,
-     31953, 31957, 31961, 31965, 31969, 31973, 31977, 31981, 31985, 31989,
-     31993, 31997, 32001, 32005, 32009, 32013, 32017, 32021, 32025, 32029,
-     32033, 32037, 32041, 32045, 32049, 32053, 32057, 32061, 32065, 32069,
-     32073, 32077, 32081, 32085, 32089, 32093, 32097, 32101, 32105, 32109,
-     32113, 32117, 32121, 32125, 32129, 32133, 32137, 32141, 32145, 32149,
-     32153, 32157, 32161, 32165, 32169, 32173, 32177, 32181, 32185, 32189,
-     32193, 32197, 32201, 32205, 32209, 32213, 32217, 32221, 32225, 32229,
-     32233, 32237, 32241, 32245, 32248, 32248, 32249, 32253, 32257, 32261,
-     32265, 32269, 32273, 32277, 32281, 32285, 32289, 32293, 32297, 32301,
-     32305, 32309, 32313, 32317, 32321, 32325, 32329, 32333, 32337, 32341,
-     32345, 32349, 32353, 32357, 32361, 32365, 32369, 32373, 32377, 32381,
-     32385, 32389, 32393, 32397, 32401, 32405, 32409, 32413, 32417, 32421,
-     32425, 32429, 32433, 32437, 32441, 32445, 32448},
-    {32448, 32448, 32448, 32448, 32448, 32448, 32448, 32448, 32448, 32448,
-     32448, 32448, 32448, 32448, 32448, 32448, 32448, 32448, 32448, 32448,
-     32448, 32448, 32448, 32448, 32448, 32448, 32448, 32448, 32448, 32448,
-     32448, 32448, 32448, 32448, 32448, 32448, 32448, 32448, 32448, 32448,
-     32448, 32448, 32448, 32448, 32448, 32448, 32448, 32448, 32449, 32453,
-     32457, 32461, 32465, 32469, 32473, 32477, 32481, 32485, 32489, 32493,
-     32497, 32501, 32505, 32509, 32513, 32517, 32521, 32525, 32529, 32533,
-     32537, 32541, 32545, 32549, 32553, 32557, 32561, 32565, 32569, 32573,
-     32577, 32581, 32585, 32589, 32593, 32597, 32601, 32605, 32609, 32613,
-     32617, 32621, 32625, 32629, 32633, 32637, 32641, 32645, 32649, 32653,
-     32657, 32661, 32665, 32669, 32673, 32677, 32681, 32685, 32689, 32693,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696},
-    {32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696, 32696,
-     32696, 32696, 32696, 32696, 32696, 32696, 32697},
-    {32697, 32701, 32705, 32709, 32712, 32713, 32717, 32721, 32725, 32729,
-     32733, 32737, 32741, 32745, 32749, 32753, 32757, 32761, 32765, 32769,
-     32773, 32777, 32781, 32785, 32789, 32793, 32797, 32801, 32805, 32809,
-     32813, 32817, 32820, 32821, 32825, 32828, 32829, 32832, 32832, 32833,
-     32836, 32837, 32841, 32845, 32849, 32853, 32857, 32861, 32865, 32869,
-     32873, 32876, 32877, 32881, 32885, 32889, 32892, 32893, 32896, 32897,
-     32900, 32900, 32900, 32900, 32900, 32900, 32901, 32904, 32904, 32904,
-     32904, 32905, 32908, 32909, 32912, 32913, 32916, 32917, 32921, 32925,
-     32928, 32929, 32933, 32936, 32937, 32940, 32940, 32941, 32944, 32945,
-     32948, 32949, 32952, 32953, 32956, 32957, 32960, 32961, 32965, 32968,
-     32969, 32972, 32972, 32973, 32977, 32981, 32985, 32988, 32989, 32993,
-     32997, 33001, 33005, 33009, 33013, 33016, 33017, 33021, 33025, 33029,
-     33032, 33033, 33037, 33041, 33045, 33048, 33049, 33052, 33053, 33057,
-     33061, 33065, 33069, 33073, 33077, 33081, 33085, 33089, 33092, 33093,
-     33097, 33101, 33105, 33109, 33113, 33117, 33121, 33125, 33129, 33133,
-     33137, 33141, 33145, 33149, 33153, 33157, 33160, 33160, 33160, 33160,
-     33160, 33161, 33165, 33169, 33172, 33173, 33177, 33181, 33185, 33189,
-     33192, 33193, 33197, 33201, 33205, 33209, 33213, 33217, 33221, 33225,
-     33229, 33233, 33237, 33241, 33245, 33249, 33253, 33257, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260},
-    {33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260, 33260,
-     33260, 33260, 33260, 33260, 33260, 33260, 33261},
-    {33261, 33269, 33277, 33285, 33293, 33301, 33309, 33317, 33325, 33333,
-     33341, 33348, 33348, 33348, 33348, 33348, 33349, 33361, 33373, 33385,
-     33397, 33409, 33421, 33433, 33445, 33457, 33469, 33481, 33493, 33505,
-     33517, 33529, 33541, 33553, 33565, 33577, 33589, 33601, 33613, 33625,
-     33637, 33649, 33661, 33673, 33677, 33681, 33689, 33696, 33697, 33701,
-     33705, 33709, 33713, 33717, 33721, 33725, 33729, 33733, 33737, 33741,
-     33745, 33749, 33753, 33757, 33761, 33765, 33769, 33773, 33777, 33781,
-     33785, 33789, 33793, 33797, 33801, 33809, 33817, 33825, 33833, 33845,
-     33852, 33852, 33852, 33852, 33852, 33852, 33852, 33852, 33852, 33852,
-     33852, 33852, 33852, 33852, 33852, 33852, 33852, 33852, 33852, 33852,
-     33852, 33852, 33852, 33852, 33852, 33852, 33853, 33861, 33869, 33876,
-     33876, 33876, 33876, 33876, 33876, 33876, 33876, 33876, 33876, 33876,
-     33876, 33876, 33876, 33876, 33876, 33876, 33876, 33876, 33876, 33876,
-     33876, 33876, 33876, 33876, 33876, 33876, 33876, 33876, 33876, 33876,
-     33876, 33876, 33876, 33876, 33877, 33884, 33884, 33884, 33884, 33884,
-     33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884,
-     33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884,
-     33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884,
-     33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884,
-     33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884,
-     33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884,
-     33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884,
-     33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884,
-     33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884,
-     33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884, 33884,
-     33884, 33884, 33884, 33884, 33884, 33884, 33885},
-    {33885, 33893, 33901, 33904, 33904, 33904, 33904, 33904, 33904, 33904,
-     33904, 33904, 33904, 33904, 33904, 33904, 33905, 33909, 33913, 33917,
-     33925, 33929, 33933, 33937, 33941, 33945, 33949, 33953, 33957, 33961,
-     33965, 33969, 33973, 33977, 33981, 33985, 33989, 33993, 33997, 34001,
-     34005, 34009, 34013, 34017, 34021, 34025, 34029, 34033, 34037, 34041,
-     34045, 34049, 34053, 34057, 34061, 34065, 34069, 34073, 34077, 34081,
-     34084, 34084, 34084, 34084, 34085, 34097, 34109, 34121, 34133, 34145,
-     34157, 34169, 34181, 34192, 34192, 34192, 34192, 34192, 34192, 34192,
-     34193, 34197, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200},
-    {34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200, 34200,
-     34201, 34205, 34209, 34213, 34217, 34221, 34225, 34229, 34233, 34237,
-     34240, 34240, 34240, 34240, 34240, 34240, 34240},
-    {34240, 34244, 34248, 34252, 34256, 34260, 34264, 34268, 34272, 34276,
-     34280, 34284, 34288, 34292, 34296, 34300, 34304, 34308, 34312, 34316,
-     34320, 34324, 34328, 34332, 34336, 34340, 34344, 34348, 34352, 34356,
-     34360, 34364, 34368, 34372, 34376, 34380, 34384, 34388, 34392, 34396,
-     34400, 34404, 34408, 34412, 34416, 34420, 34424, 34428, 34432, 34436,
-     34440, 34444, 34448, 34452, 34456, 34460, 34464, 34468, 34472, 34476,
-     34480, 34484, 34488, 34492, 34496, 34500, 34504, 34508, 34512, 34516,
-     34520, 34524, 34528, 34532, 34536, 34540, 34544, 34548, 34552, 34556,
-     34560, 34564, 34568, 34572, 34576, 34580, 34584, 34588, 34592, 34596,
-     34600, 34604, 34608, 34612, 34616, 34620, 34624, 34628, 34632, 34636,
-     34640, 34644, 34648, 34652, 34656, 34660, 34664, 34668, 34672, 34676,
-     34680, 34684, 34688, 34692, 34696, 34700, 34704, 34708, 34712, 34716,
-     34720, 34724, 34728, 34732, 34736, 34740, 34744, 34748, 34752, 34756,
-     34760, 34764, 34768, 34772, 34776, 34780, 34784, 34788, 34792, 34796,
-     34800, 34804, 34808, 34812, 34816, 34820, 34824, 34828, 34832, 34836,
-     34840, 34844, 34848, 34852, 34856, 34860, 34864, 34868, 34872, 34876,
-     34880, 34884, 34888, 34892, 34896, 34900, 34904, 34908, 34912, 34916,
-     34920, 34924, 34928, 34932, 34936, 34940, 34944, 34948, 34952, 34956,
-     34960, 34964, 34968, 34972, 34976, 34980, 34984, 34988, 34992, 34996,
-     35000, 35004, 35008, 35012, 35016, 35020, 35024, 35028, 35032, 35036,
-     35040, 35044, 35048, 35052, 35056, 35060, 35064, 35068, 35072, 35076,
-     35080, 35084, 35088, 35092, 35096, 35100, 35104, 35108, 35112, 35116,
-     35120, 35124, 35128, 35132, 35136, 35140, 35144, 35148, 35152, 35156,
-     35160, 35164, 35168, 35172, 35176, 35180, 35184, 35188, 35192, 35196,
-     35200, 35204, 35208, 35212, 35216, 35220, 35224, 35228, 35232, 35236,
-     35240, 35244, 35248, 35252, 35256, 35260, 35264},
-    {35264, 35268, 35272, 35276, 35280, 35284, 35288, 35292, 35296, 35300,
-     35304, 35308, 35312, 35316, 35320, 35324, 35328, 35332, 35336, 35340,
-     35344, 35348, 35352, 35356, 35360, 35364, 35368, 35372, 35376, 35380,
-     35384, 35388, 35392, 35396, 35400, 35404, 35408, 35412, 35416, 35420,
-     35424, 35428, 35432, 35436, 35440, 35444, 35448, 35452, 35456, 35460,
-     35464, 35468, 35472, 35476, 35480, 35484, 35488, 35492, 35496, 35500,
-     35504, 35508, 35512, 35516, 35520, 35524, 35528, 35532, 35536, 35540,
-     35544, 35548, 35552, 35556, 35560, 35564, 35568, 35572, 35576, 35580,
-     35584, 35588, 35592, 35596, 35600, 35604, 35608, 35612, 35616, 35620,
-     35624, 35628, 35632, 35636, 35640, 35644, 35648, 35652, 35656, 35660,
-     35664, 35668, 35672, 35676, 35680, 35684, 35688, 35692, 35696, 35700,
-     35704, 35708, 35712, 35716, 35720, 35724, 35728, 35732, 35736, 35740,
-     35744, 35748, 35752, 35756, 35760, 35764, 35768, 35772, 35776, 35780,
-     35784, 35788, 35792, 35796, 35800, 35804, 35808, 35812, 35816, 35820,
-     35824, 35828, 35832, 35836, 35840, 35844, 35848, 35852, 35856, 35860,
-     35864, 35868, 35872, 35876, 35880, 35884, 35888, 35892, 35896, 35900,
-     35904, 35908, 35912, 35916, 35920, 35924, 35928, 35932, 35936, 35940,
-     35944, 35948, 35952, 35956, 35960, 35964, 35968, 35972, 35976, 35980,
-     35984, 35988, 35992, 35996, 36000, 36004, 36008, 36012, 36016, 36020,
-     36024, 36028, 36032, 36036, 36040, 36044, 36048, 36052, 36056, 36060,
-     36064, 36068, 36072, 36076, 36080, 36084, 36088, 36092, 36096, 36100,
-     36104, 36108, 36112, 36116, 36120, 36124, 36128, 36132, 36136, 36140,
-     36144, 36148, 36152, 36156, 36160, 36164, 36168, 36172, 36176, 36180,
-     36184, 36188, 36192, 36196, 36200, 36204, 36208, 36212, 36216, 36220,
-     36224, 36228, 36232, 36236, 36240, 36244, 36248, 36252, 36256, 36260,
-     36264, 36268, 36272, 36276, 36280, 36284, 36288},
-    {36288, 36292, 36296, 36300, 36304, 36308, 36312, 36316, 36320, 36324,
-     36328, 36332, 36336, 36340, 36344, 36348, 36352, 36356, 36360, 36364,
-     36368, 36372, 36376, 36380, 36384, 36388, 36392, 36396, 36400, 36404,
-     36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408,
-     36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408,
-     36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408,
-     36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408,
-     36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408,
-     36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408,
-     36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408,
-     36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408,
-     36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408,
-     36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408,
-     36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408,
-     36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408,
-     36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408,
-     36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408,
-     36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408,
-     36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408,
-     36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408,
-     36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408,
-     36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408,
-     36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408,
-     36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408,
-     36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408, 36408,
-     36408, 36408, 36408, 36408, 36408, 36408, 36408}};
-const char32_t decomposition_data[9102] = {
-    0,      32,     32,     776,    97,     32,     772,    50,     51,
-    32,     769,    956,    32,     807,    49,     111,    49,     8260,
-    52,     49,     8260,   50,     51,     8260,   52,     65,     768,
-    65,     769,    65,     770,    65,     771,    65,     776,    65,
-    778,    67,     807,    69,     768,    69,     769,    69,     770,
-    69,     776,    73,     768,    73,     769,    73,     770,    73,
-    776,    78,     771,    79,     768,    79,     769,    79,     770,
-    79,     771,    79,     776,    85,     768,    85,     769,    85,
-    770,    85,     776,    89,     769,    97,     768,    97,     769,
-    97,     770,    97,     771,    97,     776,    97,     778,    99,
-    807,    101,    768,    101,    769,    101,    770,    101,    776,
-    105,    768,    105,    769,    105,    770,    105,    776,    110,
-    771,    111,    768,    111,    769,    111,    770,    111,    771,
-    111,    776,    117,    768,    117,    769,    117,    770,    117,
-    776,    121,    769,    121,    776,    65,     772,    97,     772,
-    65,     774,    97,     774,    65,     808,    97,     808,    67,
-    769,    99,     769,    67,     770,    99,     770,    67,     775,
-    99,     775,    67,     780,    99,     780,    68,     780,    100,
-    780,    69,     772,    101,    772,    69,     774,    101,    774,
-    69,     775,    101,    775,    69,     808,    101,    808,    69,
-    780,    101,    780,    71,     770,    103,    770,    71,     774,
-    103,    774,    71,     775,    103,    775,    71,     807,    103,
-    807,    72,     770,    104,    770,    73,     771,    105,    771,
-    73,     772,    105,    772,    73,     774,    105,    774,    73,
-    808,    105,    808,    73,     775,    73,     74,     105,    106,
-    74,     770,    106,    770,    75,     807,    107,    807,    76,
-    769,    108,    769,    76,     807,    108,    807,    76,     780,
-    108,    780,    76,     183,    108,    183,    78,     769,    110,
-    769,    78,     807,    110,    807,    78,     780,    110,    780,
-    700,    110,    79,     772,    111,    772,    79,     774,    111,
-    774,    79,     779,    111,    779,    82,     769,    114,    769,
-    82,     807,    114,    807,    82,     780,    114,    780,    83,
-    769,    115,    769,    83,     770,    115,    770,    83,     807,
-    115,    807,    83,     780,    115,    780,    84,     807,    116,
-    807,    84,     780,    116,    780,    85,     771,    117,    771,
-    85,     772,    117,    772,    85,     774,    117,    774,    85,
-    778,    117,    778,    85,     779,    117,    779,    85,     808,
-    117,    808,    87,     770,    119,    770,    89,     770,    121,
-    770,    89,     776,    90,     769,    122,    769,    90,     775,
-    122,    775,    90,     780,    122,    780,    115,    79,     795,
-    111,    795,    85,     795,    117,    795,    68,     90,     780,
-    68,     122,    780,    100,    122,    780,    76,     74,     76,
-    106,    108,    106,    78,     74,     78,     106,    110,    106,
-    65,     780,    97,     780,    73,     780,    105,    780,    79,
-    780,    111,    780,    85,     780,    117,    780,    85,     776,
-    772,    117,    776,    772,    85,     776,    769,    117,    776,
-    769,    85,     776,    780,    117,    776,    780,    85,     776,
-    768,    117,    776,    768,    65,     776,    772,    97,     776,
-    772,    65,     775,    772,    97,     775,    772,    198,    772,
-    230,    772,    71,     780,    103,    780,    75,     780,    107,
-    780,    79,     808,    111,    808,    79,     808,    772,    111,
-    808,    772,    439,    780,    658,    780,    106,    780,    68,
-    90,     68,     122,    100,    122,    71,     769,    103,    769,
-    78,     768,    110,    768,    65,     778,    769,    97,     778,
-    769,    198,    769,    230,    769,    216,    769,    248,    769,
-    65,     783,    97,     783,    65,     785,    97,     785,    69,
-    783,    101,    783,    69,     785,    101,    785,    73,     783,
-    105,    783,    73,     785,    105,    785,    79,     783,    111,
-    783,    79,     785,    111,    785,    82,     783,    114,    783,
-    82,     785,    114,    785,    85,     783,    117,    783,    85,
-    785,    117,    785,    83,     806,    115,    806,    84,     806,
-    116,    806,    72,     780,    104,    780,    65,     775,    97,
-    775,    69,     807,    101,    807,    79,     776,    772,    111,
-    776,    772,    79,     771,    772,    111,    771,    772,    79,
-    775,    111,    775,    79,     775,    772,    111,    775,    772,
-    89,     772,    121,    772,    104,    614,    106,    114,    633,
-    635,    641,    119,    121,    32,     774,    32,     775,    32,
-    778,    32,     808,    32,     771,    32,     779,    611,    108,
-    115,    120,    661,    768,    769,    787,    776,    769,    697,
-    32,     837,    59,     32,     769,    168,    769,    913,    769,
-    183,    917,    769,    919,    769,    921,    769,    927,    769,
-    933,    769,    937,    769,    953,    776,    769,    921,    776,
-    933,    776,    945,    769,    949,    769,    951,    769,    953,
-    769,    965,    776,    769,    953,    776,    965,    776,    959,
-    769,    965,    769,    969,    769,    946,    952,    933,    978,
-    769,    978,    776,    966,    960,    954,    961,    962,    920,
-    949,    931,    1045,   768,    1045,   776,    1043,   769,    1030,
-    776,    1050,   769,    1048,   768,    1059,   774,    1048,   774,
-    1080,   774,    1077,   768,    1077,   776,    1075,   769,    1110,
-    776,    1082,   769,    1080,   768,    1091,   774,    1140,   783,
-    1141,   783,    1046,   774,    1078,   774,    1040,   774,    1072,
-    774,    1040,   776,    1072,   776,    1045,   774,    1077,   774,
-    1240,   776,    1241,   776,    1046,   776,    1078,   776,    1047,
-    776,    1079,   776,    1048,   772,    1080,   772,    1048,   776,
-    1080,   776,    1054,   776,    1086,   776,    1256,   776,    1257,
-    776,    1069,   776,    1101,   776,    1059,   772,    1091,   772,
-    1059,   776,    1091,   776,    1059,   779,    1091,   779,    1063,
-    776,    1095,   776,    1067,   776,    1099,   776,    1381,   1410,
-    1575,   1619,   1575,   1620,   1608,   1620,   1575,   1621,   1610,
-    1620,   1575,   1652,   1608,   1652,   1735,   1652,   1610,   1652,
-    1749,   1620,   1729,   1620,   1746,   1620,   2344,   2364,   2352,
-    2364,   2355,   2364,   2325,   2364,   2326,   2364,   2327,   2364,
-    2332,   2364,   2337,   2364,   2338,   2364,   2347,   2364,   2351,
-    2364,   2503,   2494,   2503,   2519,   2465,   2492,   2466,   2492,
-    2479,   2492,   2610,   2620,   2616,   2620,   2582,   2620,   2583,
-    2620,   2588,   2620,   2603,   2620,   2887,   2902,   2887,   2878,
-    2887,   2903,   2849,   2876,   2850,   2876,   2962,   3031,   3014,
-    3006,   3015,   3006,   3014,   3031,   3142,   3158,   3263,   3285,
-    3270,   3285,   3270,   3286,   3270,   3266,   3270,   3266,   3285,
-    3398,   3390,   3399,   3390,   3398,   3415,   3545,   3530,   3545,
-    3535,   3545,   3535,   3530,   3545,   3551,   3661,   3634,   3789,
-    3762,   3755,   3737,   3755,   3745,   3851,   3906,   4023,   3916,
-    4023,   3921,   4023,   3926,   4023,   3931,   4023,   3904,   4021,
-    3953,   3954,   3953,   3956,   4018,   3968,   4018,   3953,   3968,
-    4019,   3968,   4019,   3953,   3968,   3953,   3968,   3986,   4023,
-    3996,   4023,   4001,   4023,   4006,   4023,   4011,   4023,   3984,
-    4021,   4133,   4142,   4316,   6917,   6965,   6919,   6965,   6921,
-    6965,   6923,   6965,   6925,   6965,   6929,   6965,   6970,   6965,
-    6972,   6965,   6974,   6965,   6975,   6965,   6978,   6965,   65,
-    198,    66,     68,     69,     398,    71,     72,     73,     74,
-    75,     76,     77,     78,     79,     546,    80,     82,     84,
-    85,     87,     97,     592,    593,    7426,   98,     100,    101,
-    601,    603,    604,    103,    107,    109,    331,    111,    596,
-    7446,   7447,   112,    116,    117,    7453,   623,    118,    7461,
-    946,    947,    948,    966,    967,    105,    114,    117,    118,
-    946,    947,    961,    966,    967,    1085,   594,    99,     597,
-    240,    604,    102,    607,    609,    613,    616,    617,    618,
-    7547,   669,    621,    7557,   671,    625,    624,    626,    627,
-    628,    629,    632,    642,    643,    427,    649,    650,    7452,
-    651,    652,    122,    656,    657,    658,    952,    65,     805,
-    97,     805,    66,     775,    98,     775,    66,     803,    98,
-    803,    66,     817,    98,     817,    67,     807,    769,    99,
-    807,    769,    68,     775,    100,    775,    68,     803,    100,
-    803,    68,     817,    100,    817,    68,     807,    100,    807,
-    68,     813,    100,    813,    69,     772,    768,    101,    772,
-    768,    69,     772,    769,    101,    772,    769,    69,     813,
-    101,    813,    69,     816,    101,    816,    69,     807,    774,
-    101,    807,    774,    70,     775,    102,    775,    71,     772,
-    103,    772,    72,     775,    104,    775,    72,     803,    104,
-    803,    72,     776,    104,    776,    72,     807,    104,    807,
-    72,     814,    104,    814,    73,     816,    105,    816,    73,
-    776,    769,    105,    776,    769,    75,     769,    107,    769,
-    75,     803,    107,    803,    75,     817,    107,    817,    76,
-    803,    108,    803,    76,     803,    772,    108,    803,    772,
-    76,     817,    108,    817,    76,     813,    108,    813,    77,
-    769,    109,    769,    77,     775,    109,    775,    77,     803,
-    109,    803,    78,     775,    110,    775,    78,     803,    110,
-    803,    78,     817,    110,    817,    78,     813,    110,    813,
-    79,     771,    769,    111,    771,    769,    79,     771,    776,
-    111,    771,    776,    79,     772,    768,    111,    772,    768,
-    79,     772,    769,    111,    772,    769,    80,     769,    112,
-    769,    80,     775,    112,    775,    82,     775,    114,    775,
-    82,     803,    114,    803,    82,     803,    772,    114,    803,
-    772,    82,     817,    114,    817,    83,     775,    115,    775,
-    83,     803,    115,    803,    83,     769,    775,    115,    769,
-    775,    83,     780,    775,    115,    780,    775,    83,     803,
-    775,    115,    803,    775,    84,     775,    116,    775,    84,
-    803,    116,    803,    84,     817,    116,    817,    84,     813,
-    116,    813,    85,     804,    117,    804,    85,     816,    117,
-    816,    85,     813,    117,    813,    85,     771,    769,    117,
-    771,    769,    85,     772,    776,    117,    772,    776,    86,
-    771,    118,    771,    86,     803,    118,    803,    87,     768,
-    119,    768,    87,     769,    119,    769,    87,     776,    119,
-    776,    87,     775,    119,    775,    87,     803,    119,    803,
-    88,     775,    120,    775,    88,     776,    120,    776,    89,
-    775,    121,    775,    90,     770,    122,    770,    90,     803,
-    122,    803,    90,     817,    122,    817,    104,    817,    116,
-    776,    119,    778,    121,    778,    97,     702,    383,    775,
-    65,     803,    97,     803,    65,     777,    97,     777,    65,
-    770,    769,    97,     770,    769,    65,     770,    768,    97,
-    770,    768,    65,     770,    777,    97,     770,    777,    65,
-    770,    771,    97,     770,    771,    65,     803,    770,    97,
-    803,    770,    65,     774,    769,    97,     774,    769,    65,
-    774,    768,    97,     774,    768,    65,     774,    777,    97,
-    774,    777,    65,     774,    771,    97,     774,    771,    65,
-    803,    774,    97,     803,    774,    69,     803,    101,    803,
-    69,     777,    101,    777,    69,     771,    101,    771,    69,
-    770,    769,    101,    770,    769,    69,     770,    768,    101,
-    770,    768,    69,     770,    777,    101,    770,    777,    69,
-    770,    771,    101,    770,    771,    69,     803,    770,    101,
-    803,    770,    73,     777,    105,    777,    73,     803,    105,
-    803,    79,     803,    111,    803,    79,     777,    111,    777,
-    79,     770,    769,    111,    770,    769,    79,     770,    768,
-    111,    770,    768,    79,     770,    777,    111,    770,    777,
-    79,     770,    771,    111,    770,    771,    79,     803,    770,
-    111,    803,    770,    79,     795,    769,    111,    795,    769,
-    79,     795,    768,    111,    795,    768,    79,     795,    777,
-    111,    795,    777,    79,     795,    771,    111,    795,    771,
-    79,     795,    803,    111,    795,    803,    85,     803,    117,
-    803,    85,     777,    117,    777,    85,     795,    769,    117,
-    795,    769,    85,     795,    768,    117,    795,    768,    85,
-    795,    777,    117,    795,    777,    85,     795,    771,    117,
-    795,    771,    85,     795,    803,    117,    795,    803,    89,
-    768,    121,    768,    89,     803,    121,    803,    89,     777,
-    121,    777,    89,     771,    121,    771,    945,    787,    945,
-    788,    945,    787,    768,    945,    788,    768,    945,    787,
-    769,    945,    788,    769,    945,    787,    834,    945,    788,
-    834,    913,    787,    913,    788,    913,    787,    768,    913,
-    788,    768,    913,    787,    769,    913,    788,    769,    913,
-    787,    834,    913,    788,    834,    949,    787,    949,    788,
-    949,    787,    768,    949,    788,    768,    949,    787,    769,
-    949,    788,    769,    917,    787,    917,    788,    917,    787,
-    768,    917,    788,    768,    917,    787,    769,    917,    788,
-    769,    951,    787,    951,    788,    951,    787,    768,    951,
-    788,    768,    951,    787,    769,    951,    788,    769,    951,
-    787,    834,    951,    788,    834,    919,    787,    919,    788,
-    919,    787,    768,    919,    788,    768,    919,    787,    769,
-    919,    788,    769,    919,    787,    834,    919,    788,    834,
-    953,    787,    953,    788,    953,    787,    768,    953,    788,
-    768,    953,    787,    769,    953,    788,    769,    953,    787,
-    834,    953,    788,    834,    921,    787,    921,    788,    921,
-    787,    768,    921,    788,    768,    921,    787,    769,    921,
-    788,    769,    921,    787,    834,    921,    788,    834,    959,
-    787,    959,    788,    959,    787,    768,    959,    788,    768,
-    959,    787,    769,    959,    788,    769,    927,    787,    927,
-    788,    927,    787,    768,    927,    788,    768,    927,    787,
-    769,    927,    788,    769,    965,    787,    965,    788,    965,
-    787,    768,    965,    788,    768,    965,    787,    769,    965,
-    788,    769,    965,    787,    834,    965,    788,    834,    933,
-    788,    933,    788,    768,    933,    788,    769,    933,    788,
-    834,    969,    787,    969,    788,    969,    787,    768,    969,
-    788,    768,    969,    787,    769,    969,    788,    769,    969,
-    787,    834,    969,    788,    834,    937,    787,    937,    788,
-    937,    787,    768,    937,    788,    768,    937,    787,    769,
-    937,    788,    769,    937,    787,    834,    937,    788,    834,
-    945,    768,    945,    769,    949,    768,    949,    769,    951,
-    768,    951,    769,    953,    768,    953,    769,    959,    768,
-    959,    769,    965,    768,    965,    769,    969,    768,    969,
-    769,    945,    787,    837,    945,    788,    837,    945,    787,
-    768,    837,    945,    788,    768,    837,    945,    787,    769,
-    837,    945,    788,    769,    837,    945,    787,    834,    837,
-    945,    788,    834,    837,    913,    787,    837,    913,    788,
-    837,    913,    787,    768,    837,    913,    788,    768,    837,
-    913,    787,    769,    837,    913,    788,    769,    837,    913,
-    787,    834,    837,    913,    788,    834,    837,    951,    787,
-    837,    951,    788,    837,    951,    787,    768,    837,    951,
-    788,    768,    837,    951,    787,    769,    837,    951,    788,
-    769,    837,    951,    787,    834,    837,    951,    788,    834,
-    837,    919,    787,    837,    919,    788,    837,    919,    787,
-    768,    837,    919,    788,    768,    837,    919,    787,    769,
-    837,    919,    788,    769,    837,    919,    787,    834,    837,
-    919,    788,    834,    837,    969,    787,    837,    969,    788,
-    837,    969,    787,    768,    837,    969,    788,    768,    837,
-    969,    787,    769,    837,    969,    788,    769,    837,    969,
-    787,    834,    837,    969,    788,    834,    837,    937,    787,
-    837,    937,    788,    837,    937,    787,    768,    837,    937,
-    788,    768,    837,    937,    787,    769,    837,    937,    788,
-    769,    837,    937,    787,    834,    837,    937,    788,    834,
-    837,    945,    774,    945,    772,    945,    768,    837,    945,
-    837,    945,    769,    837,    945,    834,    945,    834,    837,
-    913,    774,    913,    772,    913,    768,    913,    769,    913,
-    837,    32,     787,    953,    32,     787,    32,     834,    168,
-    834,    951,    768,    837,    951,    837,    951,    769,    837,
-    951,    834,    951,    834,    837,    917,    768,    917,    769,
-    919,    768,    919,    769,    919,    837,    8127,   768,    8127,
-    769,    8127,   834,    953,    774,    953,    772,    953,    776,
-    768,    953,    776,    769,    953,    834,    953,    776,    834,
-    921,    774,    921,    772,    921,    768,    921,    769,    8190,
-    768,    8190,   769,    8190,   834,    965,    774,    965,    772,
-    965,    776,    768,    965,    776,    769,    961,    787,    961,
-    788,    965,    834,    965,    776,    834,    933,    774,    933,
-    772,    933,    768,    933,    769,    929,    788,    168,    768,
-    168,    769,    96,     969,    768,    837,    969,    837,    969,
-    769,    837,    969,    834,    969,    834,    837,    927,    768,
-    927,    769,    937,    768,    937,    769,    937,    837,    180,
-    32,     788,    8194,   8195,   32,     32,     32,     32,     32,
-    32,     32,     32,     32,     8208,   32,     819,    46,     46,
-    46,     46,     46,     46,     32,     8242,   8242,   8242,   8242,
-    8242,   8245,   8245,   8245,   8245,   8245,   33,     33,     32,
-    773,    63,     63,     63,     33,     33,     63,     8242,   8242,
-    8242,   8242,   32,     48,     105,    52,     53,     54,     55,
-    56,     57,     43,     8722,   61,     40,     41,     110,    48,
-    49,     50,     51,     52,     53,     54,     55,     56,     57,
-    43,     8722,   61,     40,     41,     97,     101,    111,    120,
-    601,    104,    107,    108,    109,    110,    112,    115,    116,
-    82,     115,    97,     47,     99,     97,     47,     115,    67,
-    176,    67,     99,     47,     111,    99,     47,     117,    400,
-    176,    70,     103,    72,     72,     72,     104,    295,    73,
-    73,     76,     108,    78,     78,     111,    80,     81,     82,
-    82,     82,     83,     77,     84,     69,     76,     84,     77,
-    90,     937,    90,     75,     65,     778,    66,     67,     101,
-    69,     70,     77,     111,    1488,   1489,   1490,   1491,   105,
-    70,     65,     88,     960,    947,    915,    928,    8721,   68,
-    100,    101,    105,    106,    49,     8260,   55,     49,     8260,
-    57,     49,     8260,   49,     48,     49,     8260,   51,     50,
-    8260,   51,     49,     8260,   53,     50,     8260,   53,     51,
-    8260,   53,     52,     8260,   53,     49,     8260,   54,     53,
-    8260,   54,     49,     8260,   56,     51,     8260,   56,     53,
-    8260,   56,     55,     8260,   56,     49,     8260,   73,     73,
-    73,     73,     73,     73,     73,     86,     86,     86,     73,
-    86,     73,     73,     86,     73,     73,     73,     73,     88,
-    88,     88,     73,     88,     73,     73,     76,     67,     68,
-    77,     105,    105,    105,    105,    105,    105,    105,    118,
-    118,    118,    105,    118,    105,    105,    118,    105,    105,
-    105,    105,    120,    120,    120,    105,    120,    105,    105,
-    108,    99,     100,    109,    48,     8260,   51,     8592,   824,
-    8594,   824,    8596,   824,    8656,   824,    8660,   824,    8658,
-    824,    8707,   824,    8712,   824,    8715,   824,    8739,   824,
-    8741,   824,    8747,   8747,   8747,   8747,   8747,   8750,   8750,
-    8750,   8750,   8750,   8764,   824,    8771,   824,    8773,   824,
-    8776,   824,    61,     824,    8801,   824,    8781,   824,    60,
-    824,    62,     824,    8804,   824,    8805,   824,    8818,   824,
-    8819,   824,    8822,   824,    8823,   824,    8826,   824,    8827,
-    824,    8834,   824,    8835,   824,    8838,   824,    8839,   824,
-    8866,   824,    8872,   824,    8873,   824,    8875,   824,    8828,
-    824,    8829,   824,    8849,   824,    8850,   824,    8882,   824,
-    8883,   824,    8884,   824,    8885,   824,    12296,  12297,  49,
-    50,     51,     52,     53,     54,     55,     56,     57,     49,
-    48,     49,     49,     49,     50,     49,     51,     49,     52,
-    49,     53,     49,     54,     49,     55,     49,     56,     49,
-    57,     50,     48,     40,     49,     41,     40,     50,     41,
-    40,     51,     41,     40,     52,     41,     40,     53,     41,
-    40,     54,     41,     40,     55,     41,     40,     56,     41,
-    40,     57,     41,     40,     49,     48,     41,     40,     49,
-    49,     41,     40,     49,     50,     41,     40,     49,     51,
-    41,     40,     49,     52,     41,     40,     49,     53,     41,
-    40,     49,     54,     41,     40,     49,     55,     41,     40,
-    49,     56,     41,     40,     49,     57,     41,     40,     50,
-    48,     41,     49,     46,     50,     46,     51,     46,     52,
-    46,     53,     46,     54,     46,     55,     46,     56,     46,
-    57,     46,     49,     48,     46,     49,     49,     46,     49,
-    50,     46,     49,     51,     46,     49,     52,     46,     49,
-    53,     46,     49,     54,     46,     49,     55,     46,     49,
-    56,     46,     49,     57,     46,     50,     48,     46,     40,
-    97,     41,     40,     98,     41,     40,     99,     41,     40,
-    100,    41,     40,     101,    41,     40,     102,    41,     40,
-    103,    41,     40,     104,    41,     40,     105,    41,     40,
-    106,    41,     40,     107,    41,     40,     108,    41,     40,
-    109,    41,     40,     110,    41,     40,     111,    41,     40,
-    112,    41,     40,     113,    41,     40,     114,    41,     40,
-    115,    41,     40,     116,    41,     40,     117,    41,     40,
-    118,    41,     40,     119,    41,     40,     120,    41,     40,
-    121,    41,     40,     122,    41,     65,     66,     67,     68,
-    69,     70,     71,     72,     73,     74,     75,     76,     77,
-    78,     79,     80,     81,     82,     83,     84,     85,     86,
-    87,     88,     89,     90,     97,     98,     99,     100,    101,
-    102,    103,    104,    105,    106,    107,    108,    109,    110,
-    111,    112,    113,    114,    115,    116,    117,    118,    119,
-    120,    121,    122,    48,     8747,   8747,   8747,   8747,   58,
-    58,     61,     61,     61,     61,     61,     61,     10973,  824,
-    106,    86,     11617,  27597,  40863,  19968,  20008,  20022,  20031,
-    20057,  20101,  20108,  20128,  20154,  20799,  20837,  20843,  20866,
-    20886,  20907,  20960,  20981,  20992,  21147,  21241,  21269,  21274,
-    21304,  21313,  21340,  21353,  21378,  21430,  21448,  21475,  22231,
-    22303,  22763,  22786,  22794,  22805,  22823,  22899,  23376,  23424,
-    23544,  23567,  23586,  23608,  23662,  23665,  24027,  24037,  24049,
-    24062,  24178,  24186,  24191,  24308,  24318,  24331,  24339,  24400,
-    24417,  24435,  24515,  25096,  25142,  25163,  25903,  25908,  25991,
-    26007,  26020,  26041,  26080,  26085,  26352,  26376,  26408,  27424,
-    27490,  27513,  27571,  27595,  27604,  27611,  27663,  27668,  27700,
-    28779,  29226,  29238,  29243,  29247,  29255,  29273,  29275,  29356,
-    29572,  29577,  29916,  29926,  29976,  29983,  29992,  30000,  30091,
-    30098,  30326,  30333,  30382,  30399,  30446,  30683,  30690,  30707,
-    31034,  31160,  31166,  31348,  31435,  31481,  31859,  31992,  32566,
-    32593,  32650,  32701,  32769,  32780,  32786,  32819,  32895,  32905,
-    33251,  33258,  33267,  33276,  33292,  33307,  33311,  33390,  33394,
-    33400,  34381,  34411,  34880,  34892,  34915,  35198,  35211,  35282,
-    35328,  35895,  35910,  35925,  35960,  35997,  36196,  36208,  36275,
-    36523,  36554,  36763,  36784,  36789,  37009,  37193,  37318,  37324,
-    37329,  38263,  38272,  38428,  38582,  38585,  38632,  38737,  38750,
-    38754,  38761,  38859,  38893,  38899,  38913,  39080,  39131,  39135,
-    39318,  39321,  39340,  39592,  39640,  39647,  39717,  39727,  39730,
-    39740,  39770,  40165,  40565,  40575,  40613,  40635,  40643,  40653,
-    40657,  40697,  40701,  40718,  40723,  40736,  40763,  40778,  40786,
-    40845,  40860,  40864,  32,     12306,  21313,  21316,  21317,  12363,
-    12441,  12365,  12441,  12367,  12441,  12369,  12441,  12371,  12441,
-    12373,  12441,  12375,  12441,  12377,  12441,  12379,  12441,  12381,
-    12441,  12383,  12441,  12385,  12441,  12388,  12441,  12390,  12441,
-    12392,  12441,  12399,  12441,  12399,  12442,  12402,  12441,  12402,
-    12442,  12405,  12441,  12405,  12442,  12408,  12441,  12408,  12442,
-    12411,  12441,  12411,  12442,  12358,  12441,  32,     12441,  32,
-    12442,  12445,  12441,  12424,  12426,  12459,  12441,  12461,  12441,
-    12463,  12441,  12465,  12441,  12467,  12441,  12469,  12441,  12471,
-    12441,  12473,  12441,  12475,  12441,  12477,  12441,  12479,  12441,
-    12481,  12441,  12484,  12441,  12486,  12441,  12488,  12441,  12495,
-    12441,  12495,  12442,  12498,  12441,  12498,  12442,  12501,  12441,
-    12501,  12442,  12504,  12441,  12504,  12442,  12507,  12441,  12507,
-    12442,  12454,  12441,  12527,  12441,  12528,  12441,  12529,  12441,
-    12530,  12441,  12541,  12441,  12467,  12488,  4352,   4353,   4522,
-    4354,   4524,   4525,   4355,   4356,   4357,   4528,   4529,   4530,
-    4531,   4532,   4533,   4378,   4358,   4359,   4360,   4385,   4361,
-    4362,   4363,   4364,   4365,   4366,   4367,   4368,   4369,   4370,
-    4449,   4450,   4451,   4452,   4453,   4454,   4455,   4456,   4457,
-    4458,   4459,   4460,   4461,   4462,   4463,   4464,   4465,   4466,
-    4467,   4468,   4469,   4448,   4372,   4373,   4551,   4552,   4556,
-    4558,   4563,   4567,   4569,   4380,   4573,   4575,   4381,   4382,
-    4384,   4386,   4387,   4391,   4393,   4395,   4396,   4397,   4398,
-    4399,   4402,   4406,   4416,   4423,   4428,   4593,   4594,   4439,
-    4440,   4441,   4484,   4485,   4488,   4497,   4498,   4500,   4510,
-    4513,   19968,  20108,  19977,  22235,  19978,  20013,  19979,  30002,
-    20057,  19993,  19969,  22825,  22320,  20154,  40,     4352,   41,
-    40,     4354,   41,     40,     4355,   41,     40,     4357,   41,
-    40,     4358,   41,     40,     4359,   41,     40,     4361,   41,
-    40,     4363,   41,     40,     4364,   41,     40,     4366,   41,
-    40,     4367,   41,     40,     4368,   41,     40,     4369,   41,
-    40,     4370,   41,     40,     4352,   4449,   41,     40,     4354,
-    4449,   41,     40,     4355,   4449,   41,     40,     4357,   4449,
-    41,     40,     4358,   4449,   41,     40,     4359,   4449,   41,
-    40,     4361,   4449,   41,     40,     4363,   4449,   41,     40,
-    4364,   4449,   41,     40,     4366,   4449,   41,     40,     4367,
-    4449,   41,     40,     4368,   4449,   41,     40,     4369,   4449,
-    41,     40,     4370,   4449,   41,     40,     4364,   4462,   41,
-    40,     4363,   4457,   4364,   4453,   4523,   41,     40,     4363,
-    4457,   4370,   4462,   41,     40,     19968,  41,     40,     20108,
-    41,     40,     19977,  41,     40,     22235,  41,     40,     20116,
-    41,     40,     20845,  41,     40,     19971,  41,     40,     20843,
-    41,     40,     20061,  41,     40,     21313,  41,     40,     26376,
-    41,     40,     28779,  41,     40,     27700,  41,     40,     26408,
-    41,     40,     37329,  41,     40,     22303,  41,     40,     26085,
-    41,     40,     26666,  41,     40,     26377,  41,     40,     31038,
-    41,     40,     21517,  41,     40,     29305,  41,     40,     36001,
-    41,     40,     31069,  41,     40,     21172,  41,     40,     20195,
-    41,     40,     21628,  41,     40,     23398,  41,     40,     30435,
-    41,     40,     20225,  41,     40,     36039,  41,     40,     21332,
-    41,     40,     31085,  41,     40,     20241,  41,     40,     33258,
-    41,     40,     33267,  41,     21839,  24188,  25991,  31631,  80,
-    84,     69,     50,     49,     50,     50,     50,     51,     50,
-    52,     50,     53,     50,     54,     50,     55,     50,     56,
-    50,     57,     51,     48,     51,     49,     51,     50,     51,
-    51,     51,     52,     51,     53,     4352,   4354,   4355,   4357,
-    4358,   4359,   4361,   4363,   4364,   4366,   4367,   4368,   4369,
-    4370,   4352,   4449,   4354,   4449,   4355,   4449,   4357,   4449,
-    4358,   4449,   4359,   4449,   4361,   4449,   4363,   4449,   4364,
-    4449,   4366,   4449,   4367,   4449,   4368,   4449,   4369,   4449,
-    4370,   4449,   4366,   4449,   4535,   4352,   4457,   4364,   4462,
-    4363,   4468,   4363,   4462,   19968,  20108,  19977,  22235,  20116,
-    20845,  19971,  20843,  20061,  21313,  26376,  28779,  27700,  26408,
-    37329,  22303,  26085,  26666,  26377,  31038,  21517,  29305,  36001,
-    31069,  21172,  31192,  30007,  22899,  36969,  20778,  21360,  27880,
-    38917,  20241,  20889,  27491,  19978,  20013,  19979,  24038,  21491,
-    21307,  23447,  23398,  30435,  20225,  36039,  21332,  22812,  51,
-    54,     51,     55,     51,     56,     51,     57,     52,     48,
-    52,     49,     52,     50,     52,     51,     52,     52,     52,
-    53,     52,     54,     52,     55,     52,     56,     52,     57,
-    53,     48,     49,     26376,  50,     26376,  51,     26376,  52,
-    26376,  53,     26376,  54,     26376,  55,     26376,  56,     26376,
-    57,     26376,  49,     48,     26376,  49,     49,     26376,  49,
-    50,     26376,  72,     103,    101,    114,    103,    101,    86,
-    76,     84,     68,     12450,  12452,  12454,  12456,  12458,  12459,
-    12461,  12463,  12465,  12467,  12469,  12471,  12473,  12475,  12477,
-    12479,  12481,  12484,  12486,  12488,  12490,  12491,  12492,  12493,
-    12494,  12495,  12498,  12501,  12504,  12507,  12510,  12511,  12512,
-    12513,  12514,  12516,  12518,  12520,  12521,  12522,  12523,  12524,
-    12525,  12527,  12528,  12529,  12530,  20196,  21644,  12450,  12495,
-    12442,  12540,  12488,  12450,  12523,  12501,  12449,  12450,  12531,
-    12504,  12442,  12450,  12450,  12540,  12523,  12452,  12491,  12531,
-    12463,  12441,  12452,  12531,  12481,  12454,  12457,  12531,  12456,
-    12473,  12463,  12540,  12488,  12441,  12456,  12540,  12459,  12540,
-    12458,  12531,  12473,  12458,  12540,  12512,  12459,  12452,  12522,
-    12459,  12521,  12483,  12488,  12459,  12525,  12522,  12540,  12459,
-    12441,  12525,  12531,  12459,  12441,  12531,  12510,  12461,  12441,
-    12459,  12441,  12461,  12441,  12491,  12540,  12461,  12517,  12522,
-    12540,  12461,  12441,  12523,  12479,  12441,  12540,  12461,  12525,
-    12461,  12525,  12463,  12441,  12521,  12512,  12461,  12525,  12513,
-    12540,  12488,  12523,  12461,  12525,  12527,  12483,  12488,  12463,
-    12441,  12521,  12512,  12463,  12441,  12521,  12512,  12488,  12531,
-    12463,  12523,  12475,  12441,  12452,  12525,  12463,  12525,  12540,
-    12493,  12465,  12540,  12473,  12467,  12523,  12490,  12467,  12540,
-    12507,  12442,  12469,  12452,  12463,  12523,  12469,  12531,  12481,
-    12540,  12512,  12471,  12522,  12531,  12463,  12441,  12475,  12531,
-    12481,  12475,  12531,  12488,  12479,  12441,  12540,  12473,  12486,
-    12441,  12471,  12488,  12441,  12523,  12488,  12531,  12490,  12494,
-    12494,  12483,  12488,  12495,  12452,  12484,  12495,  12442,  12540,
-    12475,  12531,  12488,  12495,  12442,  12540,  12484,  12495,  12441,
-    12540,  12524,  12523,  12498,  12442,  12450,  12473,  12488,  12523,
-    12498,  12442,  12463,  12523,  12498,  12442,  12467,  12498,  12441,
-    12523,  12501,  12449,  12521,  12483,  12488,  12441,  12501,  12451,
-    12540,  12488,  12501,  12441,  12483,  12471,  12455,  12523,  12501,
-    12521,  12531,  12504,  12463,  12479,  12540,  12523,  12504,  12442,
-    12477,  12504,  12442,  12491,  12498,  12504,  12523,  12484,  12504,
-    12442,  12531,  12473,  12504,  12442,  12540,  12471,  12441,  12504,
-    12441,  12540,  12479,  12507,  12442,  12452,  12531,  12488,  12507,
-    12441,  12523,  12488,  12507,  12531,  12507,  12442,  12531,  12488,
-    12441,  12507,  12540,  12523,  12507,  12540,  12531,  12510,  12452,
-    12463,  12525,  12510,  12452,  12523,  12510,  12483,  12495,  12510,
-    12523,  12463,  12510,  12531,  12471,  12519,  12531,  12511,  12463,
-    12525,  12531,  12511,  12522,  12511,  12522,  12495,  12441,  12540,
-    12523,  12513,  12459,  12441,  12513,  12459,  12441,  12488,  12531,
-    12513,  12540,  12488,  12523,  12516,  12540,  12488,  12441,  12516,
-    12540,  12523,  12518,  12450,  12531,  12522,  12483,  12488,  12523,
-    12522,  12521,  12523,  12498,  12442,  12540,  12523,  12540,  12501,
-    12441,  12523,  12524,  12512,  12524,  12531,  12488,  12465,  12441,
-    12531,  12527,  12483,  12488,  48,     28857,  49,     28857,  50,
-    28857,  51,     28857,  52,     28857,  53,     28857,  54,     28857,
-    55,     28857,  56,     28857,  57,     28857,  49,     48,     28857,
-    49,     49,     28857,  49,     50,     28857,  49,     51,     28857,
-    49,     52,     28857,  49,     53,     28857,  49,     54,     28857,
-    49,     55,     28857,  49,     56,     28857,  49,     57,     28857,
-    50,     48,     28857,  50,     49,     28857,  50,     50,     28857,
-    50,     51,     28857,  50,     52,     28857,  104,    80,     97,
-    100,    97,     65,     85,     98,     97,     114,    111,    86,
-    112,    99,     100,    109,    100,    109,    50,     100,    109,
-    51,     73,     85,     24179,  25104,  26157,  21644,  22823,  27491,
-    26126,  27835,  26666,  24335,  20250,  31038,  112,    65,     110,
-    65,     956,    65,     109,    65,     107,    65,     75,     66,
-    77,     66,     71,     66,     99,     97,     108,    107,    99,
-    97,     108,    112,    70,     110,    70,     956,    70,     956,
-    103,    109,    103,    107,    103,    72,     122,    107,    72,
-    122,    77,     72,     122,    71,     72,     122,    84,     72,
-    122,    956,    108,    109,    108,    100,    108,    107,    108,
-    102,    109,    110,    109,    956,    109,    109,    109,    99,
-    109,    107,    109,    109,    109,    50,     99,     109,    50,
-    109,    50,     107,    109,    50,     109,    109,    51,     99,
-    109,    51,     109,    51,     107,    109,    51,     109,    8725,
-    115,    109,    8725,   115,    50,     80,     97,     107,    80,
-    97,     77,     80,     97,     71,     80,     97,     114,    97,
-    100,    114,    97,     100,    8725,   115,    114,    97,     100,
-    8725,   115,    50,     112,    115,    110,    115,    956,    115,
-    109,    115,    112,    86,     110,    86,     956,    86,     109,
-    86,     107,    86,     77,     86,     112,    87,     110,    87,
-    956,    87,     109,    87,     107,    87,     77,     87,     107,
-    937,    77,     937,    97,     46,     109,    46,     66,     113,
-    99,     99,     99,     100,    67,     8725,   107,    103,    67,
-    111,    46,     100,    66,     71,     121,    104,    97,     72,
-    80,     105,    110,    75,     75,     75,     77,     107,    116,
-    108,    109,    108,    110,    108,    111,    103,    108,    120,
-    109,    98,     109,    105,    108,    109,    111,    108,    80,
-    72,     112,    46,     109,    46,     80,     80,     77,     80,
-    82,     115,    114,    83,     118,    87,     98,     86,     8725,
-    109,    65,     8725,   109,    49,     26085,  50,     26085,  51,
-    26085,  52,     26085,  53,     26085,  54,     26085,  55,     26085,
-    56,     26085,  57,     26085,  49,     48,     26085,  49,     49,
-    26085,  49,     50,     26085,  49,     51,     26085,  49,     52,
-    26085,  49,     53,     26085,  49,     54,     26085,  49,     55,
-    26085,  49,     56,     26085,  49,     57,     26085,  50,     48,
-    26085,  50,     49,     26085,  50,     50,     26085,  50,     51,
-    26085,  50,     52,     26085,  50,     53,     26085,  50,     54,
-    26085,  50,     55,     26085,  50,     56,     26085,  50,     57,
-    26085,  51,     48,     26085,  51,     49,     26085,  103,    97,
-    108,    1098,   1100,   42863,  67,     70,     81,     294,    339,
-    42791,  43831,  619,    43858,  653,    35912,  26356,  36554,  36040,
-    28369,  20018,  21477,  40860,  40860,  22865,  37329,  21895,  22856,
-    25078,  30313,  32645,  34367,  34746,  35064,  37007,  27138,  27931,
-    28889,  29662,  33853,  37226,  39409,  20098,  21365,  27396,  29211,
-    34349,  40478,  23888,  28651,  34253,  35172,  25289,  33240,  34847,
-    24266,  26391,  28010,  29436,  37070,  20358,  20919,  21214,  25796,
-    27347,  29200,  30439,  32769,  34310,  34396,  36335,  38706,  39791,
-    40442,  30860,  31103,  32160,  33737,  37636,  40575,  35542,  22751,
-    24324,  31840,  32894,  29282,  30922,  36034,  38647,  22744,  23650,
-    27155,  28122,  28431,  32047,  32311,  38475,  21202,  32907,  20956,
-    20940,  31260,  32190,  33777,  38517,  35712,  25295,  27138,  35582,
-    20025,  23527,  24594,  29575,  30064,  21271,  30971,  20415,  24489,
-    19981,  27852,  25976,  32034,  21443,  22622,  30465,  33865,  35498,
-    27578,  36784,  27784,  25342,  33509,  25504,  30053,  20142,  20841,
-    20937,  26753,  31975,  33391,  35538,  37327,  21237,  21570,  22899,
-    24300,  26053,  28670,  31018,  38317,  39530,  40599,  40654,  21147,
-    26310,  27511,  36706,  24180,  24976,  25088,  25754,  28451,  29001,
-    29833,  31178,  32244,  32879,  36646,  34030,  36899,  37706,  21015,
-    21155,  21693,  28872,  35010,  35498,  24265,  24565,  25467,  27566,
-    31806,  29557,  20196,  22265,  23527,  23994,  24604,  29618,  29801,
-    32666,  32838,  37428,  38646,  38728,  38936,  20363,  31150,  37300,
-    38584,  24801,  20102,  20698,  23534,  23615,  26009,  27138,  29134,
-    30274,  34044,  36988,  40845,  26248,  38446,  21129,  26491,  26611,
-    27969,  28316,  29705,  30041,  30827,  32016,  39006,  20845,  25134,
-    38520,  20523,  23833,  28138,  36650,  24459,  24900,  26647,  29575,
-    38534,  21033,  21519,  23653,  26131,  26446,  26792,  27877,  29702,
-    30178,  32633,  35023,  35041,  37324,  38626,  21311,  28346,  21533,
-    29136,  29848,  34298,  38563,  40023,  40607,  26519,  28107,  33256,
-    31435,  31520,  31890,  29376,  28825,  35672,  20160,  33590,  21050,
-    20999,  24230,  25299,  31958,  23429,  27934,  26292,  36667,  34892,
-    38477,  35211,  24275,  20800,  21952,  22618,  26228,  20958,  29482,
-    30410,  31036,  31070,  31077,  31119,  38742,  31934,  32701,  34322,
-    35576,  36920,  37117,  39151,  39164,  39208,  40372,  37086,  38583,
-    20398,  20711,  20813,  21193,  21220,  21329,  21917,  22022,  22120,
-    22592,  22696,  23652,  23662,  24724,  24936,  24974,  25074,  25935,
-    26082,  26257,  26757,  28023,  28186,  28450,  29038,  29227,  29730,
-    30865,  31038,  31049,  31048,  31056,  31062,  31069,  31117,  31118,
-    31296,  31361,  31680,  32244,  32265,  32321,  32626,  32773,  33261,
-    33401,  33401,  33879,  35088,  35222,  35585,  35641,  36051,  36104,
-    36790,  36920,  38627,  38911,  38971,  24693,  148206, 33304,  20006,
-    20917,  20840,  20352,  20805,  20864,  21191,  21242,  21917,  21845,
-    21913,  21986,  22618,  22707,  22852,  22868,  23138,  23336,  24274,
-    24281,  24425,  24493,  24792,  24910,  24840,  24974,  24928,  25074,
-    25140,  25540,  25628,  25682,  25942,  26228,  26391,  26395,  26454,
-    27513,  27578,  27969,  28379,  28363,  28450,  28702,  29038,  30631,
-    29237,  29359,  29482,  29809,  29958,  30011,  30237,  30239,  30410,
-    30427,  30452,  30538,  30528,  30924,  31409,  31680,  31867,  32091,
-    32244,  32574,  32773,  33618,  33775,  34681,  35137,  35206,  35222,
-    35519,  35576,  35531,  35585,  35582,  35565,  35641,  35722,  36104,
-    36664,  36978,  37273,  37494,  38524,  38627,  38742,  38875,  38911,
-    38923,  38971,  39698,  40860,  141386, 141380, 144341, 15261,  16408,
-    16441,  152137, 154832, 163539, 40771,  40846,  102,    102,    102,
-    105,    102,    108,    102,    102,    105,    102,    102,    108,
-    115,    116,    115,    116,    1396,   1398,   1396,   1381,   1396,
-    1387,   1406,   1398,   1396,   1389,   1497,   1460,   1522,   1463,
-    1506,   1488,   1491,   1492,   1499,   1500,   1501,   1512,   1514,
-    43,     1513,   1473,   1513,   1474,   1513,   1468,   1473,   1513,
-    1468,   1474,   1488,   1463,   1488,   1464,   1488,   1468,   1489,
-    1468,   1490,   1468,   1491,   1468,   1492,   1468,   1493,   1468,
-    1494,   1468,   1496,   1468,   1497,   1468,   1498,   1468,   1499,
-    1468,   1500,   1468,   1502,   1468,   1504,   1468,   1505,   1468,
-    1507,   1468,   1508,   1468,   1510,   1468,   1511,   1468,   1512,
-    1468,   1513,   1468,   1514,   1468,   1493,   1465,   1489,   1471,
-    1499,   1471,   1508,   1471,   1488,   1500,   1649,   1649,   1659,
-    1659,   1659,   1659,   1662,   1662,   1662,   1662,   1664,   1664,
-    1664,   1664,   1658,   1658,   1658,   1658,   1663,   1663,   1663,
-    1663,   1657,   1657,   1657,   1657,   1700,   1700,   1700,   1700,
-    1702,   1702,   1702,   1702,   1668,   1668,   1668,   1668,   1667,
-    1667,   1667,   1667,   1670,   1670,   1670,   1670,   1671,   1671,
-    1671,   1671,   1677,   1677,   1676,   1676,   1678,   1678,   1672,
-    1672,   1688,   1688,   1681,   1681,   1705,   1705,   1705,   1705,
-    1711,   1711,   1711,   1711,   1715,   1715,   1715,   1715,   1713,
-    1713,   1713,   1713,   1722,   1722,   1723,   1723,   1723,   1723,
-    1749,   1620,   1749,   1620,   1729,   1729,   1729,   1729,   1726,
-    1726,   1726,   1726,   1746,   1746,   1746,   1620,   1746,   1620,
-    1709,   1709,   1709,   1709,   1735,   1735,   1734,   1734,   1736,
-    1736,   1735,   1652,   1739,   1739,   1733,   1733,   1737,   1737,
-    1744,   1744,   1744,   1744,   1609,   1609,   1610,   1620,   1575,
-    1610,   1620,   1575,   1610,   1620,   1749,   1610,   1620,   1749,
-    1610,   1620,   1608,   1610,   1620,   1608,   1610,   1620,   1735,
-    1610,   1620,   1735,   1610,   1620,   1734,   1610,   1620,   1734,
-    1610,   1620,   1736,   1610,   1620,   1736,   1610,   1620,   1744,
-    1610,   1620,   1744,   1610,   1620,   1744,   1610,   1620,   1609,
-    1610,   1620,   1609,   1610,   1620,   1609,   1740,   1740,   1740,
-    1740,   1610,   1620,   1580,   1610,   1620,   1581,   1610,   1620,
-    1605,   1610,   1620,   1609,   1610,   1620,   1610,   1576,   1580,
-    1576,   1581,   1576,   1582,   1576,   1605,   1576,   1609,   1576,
-    1610,   1578,   1580,   1578,   1581,   1578,   1582,   1578,   1605,
-    1578,   1609,   1578,   1610,   1579,   1580,   1579,   1605,   1579,
-    1609,   1579,   1610,   1580,   1581,   1580,   1605,   1581,   1580,
-    1581,   1605,   1582,   1580,   1582,   1581,   1582,   1605,   1587,
-    1580,   1587,   1581,   1587,   1582,   1587,   1605,   1589,   1581,
-    1589,   1605,   1590,   1580,   1590,   1581,   1590,   1582,   1590,
-    1605,   1591,   1581,   1591,   1605,   1592,   1605,   1593,   1580,
-    1593,   1605,   1594,   1580,   1594,   1605,   1601,   1580,   1601,
-    1581,   1601,   1582,   1601,   1605,   1601,   1609,   1601,   1610,
-    1602,   1581,   1602,   1605,   1602,   1609,   1602,   1610,   1603,
-    1575,   1603,   1580,   1603,   1581,   1603,   1582,   1603,   1604,
-    1603,   1605,   1603,   1609,   1603,   1610,   1604,   1580,   1604,
-    1581,   1604,   1582,   1604,   1605,   1604,   1609,   1604,   1610,
-    1605,   1580,   1605,   1581,   1605,   1582,   1605,   1605,   1605,
-    1609,   1605,   1610,   1606,   1580,   1606,   1581,   1606,   1582,
-    1606,   1605,   1606,   1609,   1606,   1610,   1607,   1580,   1607,
-    1605,   1607,   1609,   1607,   1610,   1610,   1580,   1610,   1581,
-    1610,   1582,   1610,   1605,   1610,   1609,   1610,   1610,   1584,
-    1648,   1585,   1648,   1609,   1648,   32,     1612,   1617,   32,
-    1613,   1617,   32,     1614,   1617,   32,     1615,   1617,   32,
-    1616,   1617,   32,     1617,   1648,   1610,   1620,   1585,   1610,
-    1620,   1586,   1610,   1620,   1605,   1610,   1620,   1606,   1610,
-    1620,   1609,   1610,   1620,   1610,   1576,   1585,   1576,   1586,
-    1576,   1605,   1576,   1606,   1576,   1609,   1576,   1610,   1578,
-    1585,   1578,   1586,   1578,   1605,   1578,   1606,   1578,   1609,
-    1578,   1610,   1579,   1585,   1579,   1586,   1579,   1605,   1579,
-    1606,   1579,   1609,   1579,   1610,   1601,   1609,   1601,   1610,
-    1602,   1609,   1602,   1610,   1603,   1575,   1603,   1604,   1603,
-    1605,   1603,   1609,   1603,   1610,   1604,   1605,   1604,   1609,
-    1604,   1610,   1605,   1575,   1605,   1605,   1606,   1585,   1606,
-    1586,   1606,   1605,   1606,   1606,   1606,   1609,   1606,   1610,
-    1609,   1648,   1610,   1585,   1610,   1586,   1610,   1605,   1610,
-    1606,   1610,   1609,   1610,   1610,   1610,   1620,   1580,   1610,
-    1620,   1581,   1610,   1620,   1582,   1610,   1620,   1605,   1610,
-    1620,   1607,   1576,   1580,   1576,   1581,   1576,   1582,   1576,
-    1605,   1576,   1607,   1578,   1580,   1578,   1581,   1578,   1582,
-    1578,   1605,   1578,   1607,   1579,   1605,   1580,   1581,   1580,
-    1605,   1581,   1580,   1581,   1605,   1582,   1580,   1582,   1605,
-    1587,   1580,   1587,   1581,   1587,   1582,   1587,   1605,   1589,
-    1581,   1589,   1582,   1589,   1605,   1590,   1580,   1590,   1581,
-    1590,   1582,   1590,   1605,   1591,   1581,   1592,   1605,   1593,
-    1580,   1593,   1605,   1594,   1580,   1594,   1605,   1601,   1580,
-    1601,   1581,   1601,   1582,   1601,   1605,   1602,   1581,   1602,
-    1605,   1603,   1580,   1603,   1581,   1603,   1582,   1603,   1604,
-    1603,   1605,   1604,   1580,   1604,   1581,   1604,   1582,   1604,
-    1605,   1604,   1607,   1605,   1580,   1605,   1581,   1605,   1582,
-    1605,   1605,   1606,   1580,   1606,   1581,   1606,   1582,   1606,
-    1605,   1606,   1607,   1607,   1580,   1607,   1605,   1607,   1648,
-    1610,   1580,   1610,   1581,   1610,   1582,   1610,   1605,   1610,
-    1607,   1610,   1620,   1605,   1610,   1620,   1607,   1576,   1605,
-    1576,   1607,   1578,   1605,   1578,   1607,   1579,   1605,   1579,
-    1607,   1587,   1605,   1587,   1607,   1588,   1605,   1588,   1607,
-    1603,   1604,   1603,   1605,   1604,   1605,   1606,   1605,   1606,
-    1607,   1610,   1605,   1610,   1607,   1600,   1614,   1617,   1600,
-    1615,   1617,   1600,   1616,   1617,   1591,   1609,   1591,   1610,
-    1593,   1609,   1593,   1610,   1594,   1609,   1594,   1610,   1587,
-    1609,   1587,   1610,   1588,   1609,   1588,   1610,   1581,   1609,
-    1581,   1610,   1580,   1609,   1580,   1610,   1582,   1609,   1582,
-    1610,   1589,   1609,   1589,   1610,   1590,   1609,   1590,   1610,
-    1588,   1580,   1588,   1581,   1588,   1582,   1588,   1605,   1588,
-    1585,   1587,   1585,   1589,   1585,   1590,   1585,   1591,   1609,
-    1591,   1610,   1593,   1609,   1593,   1610,   1594,   1609,   1594,
-    1610,   1587,   1609,   1587,   1610,   1588,   1609,   1588,   1610,
-    1581,   1609,   1581,   1610,   1580,   1609,   1580,   1610,   1582,
-    1609,   1582,   1610,   1589,   1609,   1589,   1610,   1590,   1609,
-    1590,   1610,   1588,   1580,   1588,   1581,   1588,   1582,   1588,
-    1605,   1588,   1585,   1587,   1585,   1589,   1585,   1590,   1585,
-    1588,   1580,   1588,   1581,   1588,   1582,   1588,   1605,   1587,
-    1607,   1588,   1607,   1591,   1605,   1587,   1580,   1587,   1581,
-    1587,   1582,   1588,   1580,   1588,   1581,   1588,   1582,   1591,
-    1605,   1592,   1605,   1575,   1611,   1575,   1611,   1578,   1580,
-    1605,   1578,   1581,   1580,   1578,   1581,   1580,   1578,   1581,
-    1605,   1578,   1582,   1605,   1578,   1605,   1580,   1578,   1605,
-    1581,   1578,   1605,   1582,   1580,   1605,   1581,   1580,   1605,
-    1581,   1581,   1605,   1610,   1581,   1605,   1609,   1587,   1581,
-    1580,   1587,   1580,   1581,   1587,   1580,   1609,   1587,   1605,
-    1581,   1587,   1605,   1581,   1587,   1605,   1580,   1587,   1605,
-    1605,   1587,   1605,   1605,   1589,   1581,   1581,   1589,   1581,
-    1581,   1589,   1605,   1605,   1588,   1581,   1605,   1588,   1581,
-    1605,   1588,   1580,   1610,   1588,   1605,   1582,   1588,   1605,
-    1582,   1588,   1605,   1605,   1588,   1605,   1605,   1590,   1581,
-    1609,   1590,   1582,   1605,   1590,   1582,   1605,   1591,   1605,
-    1581,   1591,   1605,   1581,   1591,   1605,   1605,   1591,   1605,
-    1610,   1593,   1580,   1605,   1593,   1605,   1605,   1593,   1605,
-    1605,   1593,   1605,   1609,   1594,   1605,   1605,   1594,   1605,
-    1610,   1594,   1605,   1609,   1601,   1582,   1605,   1601,   1582,
-    1605,   1602,   1605,   1581,   1602,   1605,   1605,   1604,   1581,
-    1605,   1604,   1581,   1610,   1604,   1581,   1609,   1604,   1580,
-    1580,   1604,   1580,   1580,   1604,   1582,   1605,   1604,   1582,
-    1605,   1604,   1605,   1581,   1604,   1605,   1581,   1605,   1581,
-    1580,   1605,   1581,   1605,   1605,   1581,   1610,   1605,   1580,
-    1581,   1605,   1580,   1605,   1605,   1582,   1580,   1605,   1582,
-    1605,   1605,   1580,   1582,   1607,   1605,   1580,   1607,   1605,
-    1605,   1606,   1581,   1605,   1606,   1581,   1609,   1606,   1580,
-    1605,   1606,   1580,   1605,   1606,   1580,   1609,   1606,   1605,
-    1610,   1606,   1605,   1609,   1610,   1605,   1605,   1610,   1605,
-    1605,   1576,   1582,   1610,   1578,   1580,   1610,   1578,   1580,
-    1609,   1578,   1582,   1610,   1578,   1582,   1609,   1578,   1605,
-    1610,   1578,   1605,   1609,   1580,   1605,   1610,   1580,   1581,
-    1609,   1580,   1605,   1609,   1587,   1582,   1609,   1589,   1581,
-    1610,   1588,   1581,   1610,   1590,   1581,   1610,   1604,   1580,
-    1610,   1604,   1605,   1610,   1610,   1581,   1610,   1610,   1580,
-    1610,   1610,   1605,   1610,   1605,   1605,   1610,   1602,   1605,
-    1610,   1606,   1581,   1610,   1602,   1605,   1581,   1604,   1581,
-    1605,   1593,   1605,   1610,   1603,   1605,   1610,   1606,   1580,
-    1581,   1605,   1582,   1610,   1604,   1580,   1605,   1603,   1605,
-    1605,   1604,   1580,   1605,   1606,   1580,   1581,   1580,   1581,
-    1610,   1581,   1580,   1610,   1605,   1580,   1610,   1601,   1605,
-    1610,   1576,   1581,   1610,   1603,   1605,   1605,   1593,   1580,
-    1605,   1589,   1605,   1605,   1587,   1582,   1610,   1606,   1580,
-    1610,   1589,   1604,   1746,   1602,   1604,   1746,   1575,   1604,
-    1604,   1607,   1575,   1603,   1576,   1585,   1605,   1581,   1605,
-    1583,   1589,   1604,   1593,   1605,   1585,   1587,   1608,   1604,
-    1593,   1604,   1610,   1607,   1608,   1587,   1604,   1605,   1589,
-    1604,   1609,   1589,   1604,   1609,   32,     1575,   1604,   1604,
-    1607,   32,     1593,   1604,   1610,   1607,   32,     1608,   1587,
-    1604,   1605,   1580,   1604,   32,     1580,   1604,   1575,   1604,
-    1607,   1585,   1740,   1575,   1604,   44,     12289,  12290,  58,
-    59,     33,     63,     12310,  12311,  46,     46,     46,     46,
-    46,     8212,   8211,   95,     95,     40,     41,     123,    125,
-    12308,  12309,  12304,  12305,  12298,  12299,  12296,  12297,  12300,
-    12301,  12302,  12303,  91,     93,     32,     773,    32,     773,
-    32,     773,    32,     773,    95,     95,     95,     44,     12289,
-    46,     59,     58,     63,     33,     8212,   40,     41,     123,
-    125,    12308,  12309,  35,     38,     42,     43,     45,     60,
-    62,     61,     92,     36,     37,     64,     32,     1611,   1600,
-    1611,   32,     1612,   32,     1613,   32,     1614,   1600,   1614,
-    32,     1615,   1600,   1615,   32,     1616,   1600,   1616,   32,
-    1617,   1600,   1617,   32,     1618,   1600,   1618,   1569,   1575,
-    1619,   1575,   1619,   1575,   1620,   1575,   1620,   1608,   1620,
-    1608,   1620,   1575,   1621,   1575,   1621,   1610,   1620,   1610,
-    1620,   1610,   1620,   1610,   1620,   1575,   1575,   1576,   1576,
-    1576,   1576,   1577,   1577,   1578,   1578,   1578,   1578,   1579,
-    1579,   1579,   1579,   1580,   1580,   1580,   1580,   1581,   1581,
-    1581,   1581,   1582,   1582,   1582,   1582,   1583,   1583,   1584,
-    1584,   1585,   1585,   1586,   1586,   1587,   1587,   1587,   1587,
-    1588,   1588,   1588,   1588,   1589,   1589,   1589,   1589,   1590,
-    1590,   1590,   1590,   1591,   1591,   1591,   1591,   1592,   1592,
-    1592,   1592,   1593,   1593,   1593,   1593,   1594,   1594,   1594,
-    1594,   1601,   1601,   1601,   1601,   1602,   1602,   1602,   1602,
-    1603,   1603,   1603,   1603,   1604,   1604,   1604,   1604,   1605,
-    1605,   1605,   1605,   1606,   1606,   1606,   1606,   1607,   1607,
-    1607,   1607,   1608,   1608,   1609,   1609,   1610,   1610,   1610,
-    1610,   1604,   1575,   1619,   1604,   1575,   1619,   1604,   1575,
-    1620,   1604,   1575,   1620,   1604,   1575,   1621,   1604,   1575,
-    1621,   1604,   1575,   1604,   1575,   33,     34,     35,     36,
-    37,     38,     39,     40,     41,     42,     43,     44,     45,
-    46,     47,     48,     49,     50,     51,     52,     53,     54,
-    55,     56,     57,     58,     59,     60,     61,     62,     63,
-    64,     65,     66,     67,     68,     69,     70,     71,     72,
-    73,     74,     75,     76,     77,     78,     79,     80,     81,
-    82,     83,     84,     85,     86,     87,     88,     89,     90,
-    91,     92,     93,     94,     95,     96,     97,     98,     99,
-    100,    101,    102,    103,    104,    105,    106,    107,    108,
-    109,    110,    111,    112,    113,    114,    115,    116,    117,
-    118,    119,    120,    121,    122,    123,    124,    125,    126,
-    10629,  10630,  12290,  12300,  12301,  12289,  12539,  12530,  12449,
-    12451,  12453,  12455,  12457,  12515,  12517,  12519,  12483,  12540,
-    12450,  12452,  12454,  12456,  12458,  12459,  12461,  12463,  12465,
-    12467,  12469,  12471,  12473,  12475,  12477,  12479,  12481,  12484,
-    12486,  12488,  12490,  12491,  12492,  12493,  12494,  12495,  12498,
-    12501,  12504,  12507,  12510,  12511,  12512,  12513,  12514,  12516,
-    12518,  12520,  12521,  12522,  12523,  12524,  12525,  12527,  12531,
-    12441,  12442,  4448,   4352,   4353,   4522,   4354,   4524,   4525,
-    4355,   4356,   4357,   4528,   4529,   4530,   4531,   4532,   4533,
-    4378,   4358,   4359,   4360,   4385,   4361,   4362,   4363,   4364,
-    4365,   4366,   4367,   4368,   4369,   4370,   4449,   4450,   4451,
-    4452,   4453,   4454,   4455,   4456,   4457,   4458,   4459,   4460,
-    4461,   4462,   4463,   4464,   4465,   4466,   4467,   4468,   4469,
-    162,    163,    172,    32,     772,    166,    165,    8361,   9474,
-    8592,   8593,   8594,   8595,   9632,   9675,   720,    721,    230,
-    665,    595,    675,    43878,  677,    676,    598,    599,    7569,
-    600,    606,    681,    612,    610,    608,    667,    295,    668,
-    615,    644,    682,    683,    620,    122628, 42894,  622,    122629,
-    654,    122630, 248,    630,    631,    113,    634,    122632, 637,
-    638,    640,    680,    678,    43879,  679,    648,    11377,  655,
-    673,    674,    664,    448,    449,    450,    122634, 122654, 69785,
-    69818,  69787,  69818,  69797,  69818,  69937,  69927,  69938,  69927,
-    70471,  70462,  70471,  70487,  70841,  70842,  70841,  70832,  70841,
-    70845,  71096,  71087,  71097,  71087,  71989,  71984,  119127, 119141,
-    119128, 119141, 119128, 119141, 119150, 119128, 119141, 119151, 119128,
-    119141, 119152, 119128, 119141, 119153, 119128, 119141, 119154, 119225,
-    119141, 119226, 119141, 119225, 119141, 119150, 119226, 119141, 119150,
-    119225, 119141, 119151, 119226, 119141, 119151, 65,     66,     67,
-    68,     69,     70,     71,     72,     73,     74,     75,     76,
-    77,     78,     79,     80,     81,     82,     83,     84,     85,
-    86,     87,     88,     89,     90,     97,     98,     99,     100,
-    101,    102,    103,    104,    105,    106,    107,    108,    109,
-    110,    111,    112,    113,    114,    115,    116,    117,    118,
-    119,    120,    121,    122,    65,     66,     67,     68,     69,
-    70,     71,     72,     73,     74,     75,     76,     77,     78,
-    79,     80,     81,     82,     83,     84,     85,     86,     87,
-    88,     89,     90,     97,     98,     99,     100,    101,    102,
-    103,    105,    106,    107,    108,    109,    110,    111,    112,
-    113,    114,    115,    116,    117,    118,    119,    120,    121,
-    122,    65,     66,     67,     68,     69,     70,     71,     72,
-    73,     74,     75,     76,     77,     78,     79,     80,     81,
-    82,     83,     84,     85,     86,     87,     88,     89,     90,
-    97,     98,     99,     100,    101,    102,    103,    104,    105,
-    106,    107,    108,    109,    110,    111,    112,    113,    114,
-    115,    116,    117,    118,    119,    120,    121,    122,    65,
-    67,     68,     71,     74,     75,     78,     79,     80,     81,
-    83,     84,     85,     86,     87,     88,     89,     90,     97,
-    98,     99,     100,    102,    104,    105,    106,    107,    108,
-    109,    110,    112,    113,    114,    115,    116,    117,    118,
-    119,    120,    121,    122,    65,     66,     67,     68,     69,
-    70,     71,     72,     73,     74,     75,     76,     77,     78,
-    79,     80,     81,     82,     83,     84,     85,     86,     87,
-    88,     89,     90,     97,     98,     99,     100,    101,    102,
-    103,    104,    105,    106,    107,    108,    109,    110,    111,
-    112,    113,    114,    115,    116,    117,    118,    119,    120,
-    121,    122,    65,     66,     68,     69,     70,     71,     74,
-    75,     76,     77,     78,     79,     80,     81,     83,     84,
-    85,     86,     87,     88,     89,     97,     98,     99,     100,
-    101,    102,    103,    104,    105,    106,    107,    108,    109,
-    110,    111,    112,    113,    114,    115,    116,    117,    118,
-    119,    120,    121,    122,    65,     66,     68,     69,     70,
-    71,     73,     74,     75,     76,     77,     79,     83,     84,
-    85,     86,     87,     88,     89,     97,     98,     99,     100,
-    101,    102,    103,    104,    105,    106,    107,    108,    109,
-    110,    111,    112,    113,    114,    115,    116,    117,    118,
-    119,    120,    121,    122,    65,     66,     67,     68,     69,
-    70,     71,     72,     73,     74,     75,     76,     77,     78,
-    79,     80,     81,     82,     83,     84,     85,     86,     87,
-    88,     89,     90,     97,     98,     99,     100,    101,    102,
-    103,    104,    105,    106,    107,    108,    109,    110,    111,
-    112,    113,    114,    115,    116,    117,    118,    119,    120,
-    121,    122,    65,     66,     67,     68,     69,     70,     71,
-    72,     73,     74,     75,     76,     77,     78,     79,     80,
-    81,     82,     83,     84,     85,     86,     87,     88,     89,
-    90,     97,     98,     99,     100,    101,    102,    103,    104,
-    105,    106,    107,    108,    109,    110,    111,    112,    113,
-    114,    115,    116,    117,    118,    119,    120,    121,    122,
-    65,     66,     67,     68,     69,     70,     71,     72,     73,
-    74,     75,     76,     77,     78,     79,     80,     81,     82,
-    83,     84,     85,     86,     87,     88,     89,     90,     97,
-    98,     99,     100,    101,    102,    103,    104,    105,    106,
-    107,    108,    109,    110,    111,    112,    113,    114,    115,
-    116,    117,    118,    119,    120,    121,    122,    65,     66,
-    67,     68,     69,     70,     71,     72,     73,     74,     75,
-    76,     77,     78,     79,     80,     81,     82,     83,     84,
-    85,     86,     87,     88,     89,     90,     97,     98,     99,
-    100,    101,    102,    103,    104,    105,    106,    107,    108,
-    109,    110,    111,    112,    113,    114,    115,    116,    117,
-    118,    119,    120,    121,    122,    65,     66,     67,     68,
-    69,     70,     71,     72,     73,     74,     75,     76,     77,
-    78,     79,     80,     81,     82,     83,     84,     85,     86,
-    87,     88,     89,     90,     97,     98,     99,     100,    101,
-    102,    103,    104,    105,    106,    107,    108,    109,    110,
-    111,    112,    113,    114,    115,    116,    117,    118,    119,
-    120,    121,    122,    65,     66,     67,     68,     69,     70,
-    71,     72,     73,     74,     75,     76,     77,     78,     79,
-    80,     81,     82,     83,     84,     85,     86,     87,     88,
-    89,     90,     97,     98,     99,     100,    101,    102,    103,
-    104,    105,    106,    107,    108,    109,    110,    111,    112,
-    113,    114,    115,    116,    117,    118,    119,    120,    121,
-    122,    305,    567,    913,    914,    915,    916,    917,    918,
-    919,    920,    921,    922,    923,    924,    925,    926,    927,
-    928,    929,    920,    931,    932,    933,    934,    935,    936,
-    937,    8711,   945,    946,    947,    948,    949,    950,    951,
-    952,    953,    954,    955,    956,    957,    958,    959,    960,
-    961,    962,    963,    964,    965,    966,    967,    968,    969,
-    8706,   949,    952,    954,    966,    961,    960,    913,    914,
-    915,    916,    917,    918,    919,    920,    921,    922,    923,
-    924,    925,    926,    927,    928,    929,    920,    931,    932,
-    933,    934,    935,    936,    937,    8711,   945,    946,    947,
-    948,    949,    950,    951,    952,    953,    954,    955,    956,
-    957,    958,    959,    960,    961,    962,    963,    964,    965,
-    966,    967,    968,    969,    8706,   949,    952,    954,    966,
-    961,    960,    913,    914,    915,    916,    917,    918,    919,
-    920,    921,    922,    923,    924,    925,    926,    927,    928,
-    929,    920,    931,    932,    933,    934,    935,    936,    937,
-    8711,   945,    946,    947,    948,    949,    950,    951,    952,
-    953,    954,    955,    956,    957,    958,    959,    960,    961,
-    962,    963,    964,    965,    966,    967,    968,    969,    8706,
-    949,    952,    954,    966,    961,    960,    913,    914,    915,
-    916,    917,    918,    919,    920,    921,    922,    923,    924,
-    925,    926,    927,    928,    929,    920,    931,    932,    933,
-    934,    935,    936,    937,    8711,   945,    946,    947,    948,
-    949,    950,    951,    952,    953,    954,    955,    956,    957,
-    958,    959,    960,    961,    962,    963,    964,    965,    966,
-    967,    968,    969,    8706,   949,    952,    954,    966,    961,
-    960,    913,    914,    915,    916,    917,    918,    919,    920,
-    921,    922,    923,    924,    925,    926,    927,    928,    929,
-    920,    931,    932,    933,    934,    935,    936,    937,    8711,
-    945,    946,    947,    948,    949,    950,    951,    952,    953,
-    954,    955,    956,    957,    958,    959,    960,    961,    962,
-    963,    964,    965,    966,    967,    968,    969,    8706,   949,
-    952,    954,    966,    961,    960,    988,    989,    48,     49,
-    50,     51,     52,     53,     54,     55,     56,     57,     48,
-    49,     50,     51,     52,     53,     54,     55,     56,     57,
-    48,     49,     50,     51,     52,     53,     54,     55,     56,
-    57,     48,     49,     50,     51,     52,     53,     54,     55,
-    56,     57,     48,     49,     50,     51,     52,     53,     54,
-    55,     56,     57,     1072,   1073,   1074,   1075,   1076,   1077,
-    1078,   1079,   1080,   1082,   1083,   1084,   1086,   1087,   1088,
-    1089,   1090,   1091,   1092,   1093,   1094,   1095,   1096,   1099,
-    1101,   1102,   42633,  1241,   1110,   1112,   1257,   1199,   1231,
-    1072,   1073,   1074,   1075,   1076,   1077,   1078,   1079,   1080,
-    1082,   1083,   1086,   1087,   1089,   1091,   1092,   1093,   1094,
-    1095,   1096,   1098,   1099,   1169,   1110,   1109,   1119,   1195,
-    42577,  1201,   1575,   1576,   1580,   1583,   1608,   1586,   1581,
-    1591,   1610,   1603,   1604,   1605,   1606,   1587,   1593,   1601,
-    1589,   1602,   1585,   1588,   1578,   1579,   1582,   1584,   1590,
-    1592,   1594,   1646,   1722,   1697,   1647,   1576,   1580,   1607,
-    1581,   1610,   1603,   1604,   1605,   1606,   1587,   1593,   1601,
-    1589,   1602,   1588,   1578,   1579,   1582,   1590,   1594,   1580,
-    1581,   1610,   1604,   1606,   1587,   1593,   1589,   1602,   1588,
-    1582,   1590,   1594,   1722,   1647,   1576,   1580,   1607,   1581,
-    1591,   1610,   1603,   1605,   1606,   1587,   1593,   1601,   1589,
-    1602,   1588,   1578,   1579,   1582,   1590,   1592,   1594,   1646,
-    1697,   1575,   1576,   1580,   1583,   1607,   1608,   1586,   1581,
-    1591,   1610,   1604,   1605,   1606,   1587,   1593,   1601,   1589,
-    1602,   1585,   1588,   1578,   1579,   1582,   1584,   1590,   1592,
-    1594,   1576,   1580,   1583,   1608,   1586,   1581,   1591,   1610,
-    1604,   1605,   1606,   1587,   1593,   1601,   1589,   1602,   1585,
-    1588,   1578,   1579,   1582,   1584,   1590,   1592,   1594,   48,
-    46,     48,     44,     49,     44,     50,     44,     51,     44,
-    52,     44,     53,     44,     54,     44,     55,     44,     56,
-    44,     57,     44,     40,     65,     41,     40,     66,     41,
-    40,     67,     41,     40,     68,     41,     40,     69,     41,
-    40,     70,     41,     40,     71,     41,     40,     72,     41,
-    40,     73,     41,     40,     74,     41,     40,     75,     41,
-    40,     76,     41,     40,     77,     41,     40,     78,     41,
-    40,     79,     41,     40,     80,     41,     40,     81,     41,
-    40,     82,     41,     40,     83,     41,     40,     84,     41,
-    40,     85,     41,     40,     86,     41,     40,     87,     41,
-    40,     88,     41,     40,     89,     41,     40,     90,     41,
-    12308,  83,     12309,  67,     82,     67,     68,     87,     90,
-    65,     66,     67,     68,     69,     70,     71,     72,     73,
-    74,     75,     76,     77,     78,     79,     80,     81,     82,
-    83,     84,     85,     86,     87,     88,     89,     90,     72,
-    86,     77,     86,     83,     68,     83,     83,     80,     80,
-    86,     87,     67,     77,     67,     77,     68,     77,     82,
-    68,     74,     12411,  12363,  12467,  12467,  12469,  25163,  23383,
-    21452,  12486,  12441,  20108,  22810,  35299,  22825,  20132,  26144,
-    28961,  26009,  21069,  24460,  20877,  26032,  21021,  32066,  29983,
-    36009,  22768,  21561,  28436,  25237,  25429,  19968,  19977,  36938,
-    24038,  20013,  21491,  25351,  36208,  25171,  31105,  31354,  21512,
-    28288,  26377,  26376,  30003,  21106,  21942,  37197,  12308,  26412,
-    12309,  12308,  19977,  12309,  12308,  20108,  12309,  12308,  23433,
-    12309,  12308,  28857,  12309,  12308,  25171,  12309,  12308,  30423,
-    12309,  12308,  21213,  12309,  12308,  25943,  12309,  24471,  21487,
-    48,     49,     50,     51,     52,     53,     54,     55,     56,
-    57,     20029,  20024,  20033,  131362, 20320,  20398,  20411,  20482,
-    20602,  20633,  20711,  20687,  13470,  132666, 20813,  20820,  20836,
-    20855,  132380, 13497,  20839,  20877,  132427, 20887,  20900,  20172,
-    20908,  20917,  168415, 20981,  20995,  13535,  21051,  21062,  21106,
-    21111,  13589,  21191,  21193,  21220,  21242,  21253,  21254,  21271,
-    21321,  21329,  21338,  21363,  21373,  21375,  21375,  21375,  133676,
-    28784,  21450,  21471,  133987, 21483,  21489,  21510,  21662,  21560,
-    21576,  21608,  21666,  21750,  21776,  21843,  21859,  21892,  21892,
-    21913,  21931,  21939,  21954,  22294,  22022,  22295,  22097,  22132,
-    20999,  22766,  22478,  22516,  22541,  22411,  22578,  22577,  22700,
-    136420, 22770,  22775,  22790,  22810,  22818,  22882,  136872, 136938,
-    23020,  23067,  23079,  23000,  23142,  14062,  14076,  23304,  23358,
-    23358,  137672, 23491,  23512,  23527,  23539,  138008, 23551,  23558,
-    24403,  23586,  14209,  23648,  23662,  23744,  23693,  138724, 23875,
-    138726, 23918,  23915,  23932,  24033,  24034,  14383,  24061,  24104,
-    24125,  24169,  14434,  139651, 14460,  24240,  24243,  24246,  24266,
-    172946, 24318,  140081, 140081, 33281,  24354,  24354,  14535,  144056,
-    156122, 24418,  24427,  14563,  24474,  24525,  24535,  24569,  24705,
-    14650,  14620,  24724,  141012, 24775,  24904,  24908,  24910,  24908,
-    24954,  24974,  25010,  24996,  25007,  25054,  25074,  25078,  25104,
-    25115,  25181,  25265,  25300,  25424,  142092, 25405,  25340,  25448,
-    25475,  25572,  142321, 25634,  25541,  25513,  14894,  25705,  25726,
-    25757,  25719,  14956,  25935,  25964,  143370, 26083,  26360,  26185,
-    15129,  26257,  15112,  15076,  20882,  20885,  26368,  26268,  32941,
-    17369,  26391,  26395,  26401,  26462,  26451,  144323, 15177,  26618,
-    26501,  26706,  26757,  144493, 26766,  26655,  26900,  15261,  26946,
-    27043,  27114,  27304,  145059, 27355,  15384,  27425,  145575, 27476,
-    15438,  27506,  27551,  27578,  27579,  146061, 138507, 146170, 27726,
-    146620, 27839,  27853,  27751,  27926,  27966,  28023,  27969,  28009,
-    28024,  28037,  146718, 27956,  28207,  28270,  15667,  28363,  28359,
-    147153, 28153,  28526,  147294, 147342, 28614,  28729,  28702,  28699,
-    15766,  28746,  28797,  28791,  28845,  132389, 28997,  148067, 29084,
-    148395, 29224,  29237,  29264,  149000, 29312,  29333,  149301, 149524,
-    29562,  29579,  16044,  29605,  16056,  16056,  29767,  29788,  29809,
-    29829,  29898,  16155,  29988,  150582, 30014,  150674, 30064,  139679,
-    30224,  151457, 151480, 151620, 16380,  16392,  30452,  151795, 151794,
-    151833, 151859, 30494,  30495,  30495,  30538,  16441,  30603,  16454,
-    16534,  152605, 30798,  30860,  30924,  16611,  153126, 31062,  153242,
-    153285, 31119,  31211,  16687,  31296,  31306,  31311,  153980, 154279,
-    154279, 31470,  16898,  154539, 31686,  31689,  16935,  154752, 31954,
-    17056,  31976,  31971,  32000,  155526, 32099,  17153,  32199,  32258,
-    32325,  17204,  156200, 156231, 17241,  156377, 32634,  156478, 32661,
-    32762,  32773,  156890, 156963, 32864,  157096, 32880,  144223, 17365,
-    32946,  33027,  17419,  33086,  23221,  157607, 157621, 144275, 144284,
-    33281,  33284,  36766,  17515,  33425,  33419,  33437,  21171,  33457,
-    33459,  33469,  33510,  158524, 33509,  33565,  33635,  33709,  33571,
-    33725,  33767,  33879,  33619,  33738,  33740,  33756,  158774, 159083,
-    158933, 17707,  34033,  34035,  34070,  160714, 34148,  159532, 17757,
-    17761,  159665, 159954, 17771,  34384,  34396,  34407,  34409,  34473,
-    34440,  34574,  34530,  34681,  34600,  34667,  34694,  17879,  34785,
-    34817,  17913,  34912,  34915,  161383, 35031,  35038,  17973,  35066,
-    13499,  161966, 162150, 18110,  18119,  35488,  35565,  35722,  35925,
-    162984, 36011,  36033,  36123,  36215,  163631, 133124, 36299,  36284,
-    36336,  133342, 36564,  36664,  165330, 165357, 37012,  37105,  37137,
-    165678, 37147,  37432,  37591,  37592,  37500,  37881,  37909,  166906,
-    38283,  18837,  38327,  167287, 18918,  38595,  23986,  38691,  168261,
-    168474, 19054,  19062,  38880,  168970, 19122,  169110, 38923,  38923,
-    38953,  169398, 39138,  19251,  39209,  39335,  39362,  39422,  19406,
-    170800, 39698,  40000,  40189,  19662,  19693,  40295,  172238, 19704,
-    172293, 172558, 172689, 40635,  19798,  40697,  40702,  40709,  40719,
-    40726,  40763,  173568};
-
-const uint8_t canonical_combining_class_index[4352] = {
-    0,  0,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 0,  0,
-    15, 0,  0,  0,  16, 17, 18, 19, 20, 21, 22, 0,  0,  23, 0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  24, 25, 0,  0,  26, 0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  27, 0,  28, 29, 30,
-    31, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  32, 0,  0,  33, 0,  0,  34, 35, 36, 0,  0,  0,  0,  0,  0,
-    37, 0,  0,  38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 0,  52,
-    53, 0,  54, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  55, 56, 0,  0,  0,  57, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  58, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  59, 60, 0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  61, 56, 62, 0,  63, 0,  0,  0,  64, 65, 0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0};
-const uint8_t canonical_combining_class_block[67][256] = {
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
-     230, 230, 230, 230, 230, 230, 232, 220, 220, 220, 220, 232, 216, 220, 220,
-     220, 220, 220, 202, 202, 220, 220, 220, 220, 202, 202, 220, 220, 220, 220,
-     220, 220, 220, 220, 220, 220, 220, 1,   1,   1,   1,   1,   220, 220, 220,
-     220, 230, 230, 230, 230, 230, 230, 230, 230, 240, 230, 220, 220, 220, 230,
-     230, 230, 220, 220, 0,   230, 230, 230, 220, 220, 220, 220, 230, 232, 220,
-     220, 230, 233, 234, 234, 233, 234, 234, 233, 230, 230, 230, 230, 230, 230,
-     230, 230, 230, 230, 230, 230, 230, 0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0},
-    {0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 230,
-     230, 230, 230, 230, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   220, 230, 230, 230, 230,
-     220, 230, 230, 230, 222, 220, 230, 230, 230, 230, 230, 230, 220, 220, 220,
-     220, 220, 220, 230, 230, 220, 230, 230, 222, 228, 230, 10,  11,  12,  13,
-     14,  15,  16,  17,  18,  19,  19,  20,  21,  22,  0,   23,  0,   24,  25,
-     0,   230, 220, 0,   18,  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0},
-    {0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   230, 230, 230, 230, 230, 230, 230, 230, 30,  31,  32,  0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     27,  28,  29,  30,  31,  32,  33,  34,  230, 230, 220, 220, 230, 230, 230,
-     230, 230, 220, 230, 230, 220, 0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   35,  0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   230, 230, 230, 230, 230, 230, 230, 0,   0,   230, 230,
-     230, 230, 220, 230, 0,   0,   230, 230, 0,   220, 230, 230, 220, 0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0},
-    {0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   36,  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   230, 220, 230, 230, 220, 230, 230, 220, 220, 220, 230, 220,
-     220, 230, 220, 230, 230, 230, 220, 230, 220, 230, 220, 230, 220, 230, 230,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   230, 230, 230, 230, 230,
-     230, 230, 220, 230, 0,   0,   0,   0,   0,   0,   0,   0,   0,   220, 0,
-     0},
-    {0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   230, 230, 230, 230, 0,   230, 230, 230,
-     230, 230, 230, 230, 230, 230, 0,   230, 230, 230, 0,   230, 230, 230, 230,
-     230, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   220,
-     220, 220, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   230, 220, 220, 220, 230, 230, 230, 230, 0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   230, 230, 230, 230, 230, 220, 220, 220,
-     220, 220, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
-     230, 0,   220, 230, 230, 220, 230, 230, 220, 230, 230, 230, 220, 220, 220,
-     27,  28,  29,  230, 230, 230, 220, 230, 230, 220, 220, 230, 230, 230, 230,
-     230},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0,   0,   0,   0,   0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0,   0,   0,   0,   0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0,   7,   0,   0,   0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0,   0, 0, 230, 220, 230, 230, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0,   0,   0,   0,   0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0,   0,   0,   0,   0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0,   0,   0,   0,   0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0,   0,   0,   0,   0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7,   0, 0, 0,   0,   0,   0,   0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0,   0, 0, 0,   0,   0,   0,   0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0,   0,   0,   0,   0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 230, 0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 84, 91, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 7, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0,  0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   103, 103, 9,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     107, 107, 107, 107, 0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0,   118, 118, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   122, 122, 122, 122, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0},
-    {0,   0, 0,   0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   0, 0,
-     0,   0, 0,   0,   0,   0,   0, 0, 0,   220, 220, 0,   0,   0, 0,
-     0,   0, 0,   0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   0, 0,
-     0,   0, 0,   0,   0,   0,   0, 0, 220, 0,   220, 0,   216, 0, 0,
-     0,   0, 0,   0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   0, 0,
-     0,   0, 0,   0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   0, 0,
-     0,   0, 0,   0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   0, 0,
-     0,   0, 0,   0,   0,   0,   0, 0, 129, 130, 0,   132, 0,   0, 0,
-     0,   0, 130, 130, 130, 130, 0, 0, 130, 0,   230, 230, 9,   0, 230,
-     230, 0, 0,   0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   0, 0,
-     0,   0, 0,   0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   0, 0,
-     0,   0, 0,   0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   0, 0,
-     0,   0, 0,   0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   0, 0,
-     0,   0, 0,   220, 0,   0,   0, 0, 0,   0,   0,   0,   0,   0, 0,
-     0,   0, 0,   0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   0, 0,
-     0,   0, 0,   0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   0, 0,
-     0,   0, 0,   0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   0, 0,
-     0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0,
-     0, 0, 0, 0, 0, 0, 0, 7, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 220, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0, 0, 0, 0, 0, 0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 230, 230, 230, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0,   0,   0,   0, 0, 0, 0, 0, 0},
-    {0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0,
-     0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 9, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 230, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 222, 230, 220, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   230, 220, 0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   9,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   230, 230, 230,
-     230, 230, 230, 230, 230, 0,   0,   220, 0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   230, 230, 230, 230,
-     230, 220, 220, 220, 220, 220, 220, 230, 230, 220, 0,   220, 220, 230, 230,
-     220, 220, 230, 230, 230, 230, 230, 220, 230, 230, 230, 230, 0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0},
-    {0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   7,   0,   0,   0,   0,
-     0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 230, 220, 230, 230, 230, 230, 230,
-     230, 230, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   9,
-     9,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,
-     0,   0,   7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   9,   9,   0,   0,   0,
-     0,   0,   0, 0, 0, 0, 0, 0, 0},
-    {0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   7,   0,   0,   0,   0,
-     0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   230, 230,
-     230, 0, 1, 220, 220, 220, 220, 220, 230, 230, 220, 220, 220, 220, 230,
-     0,   1, 1, 1,   1,   1,   1,   1,   0,   0,   0,   0,   220, 0,   0,
-     0,   0, 0, 0,   230, 0,   0,   0,   230, 230, 0,   0,   0,   0,   0,
-     0},
-    {0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   230, 230, 220,
-     230, 230, 230, 230, 230, 230, 230, 220, 230, 230, 234, 214, 220, 202, 230,
-     230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
-     230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
-     230, 230, 230, 230, 230, 230, 232, 228, 228, 220, 218, 230, 233, 220, 230,
-     220},
-    {0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,
-     230, 230, 1, 1, 230, 230, 230, 230, 1,   1,   1, 230, 230, 0,   0,   0,
-     0,   230, 0, 0, 0,   1,   1,   230, 220, 230, 1, 1,   220, 220, 220, 220,
-     230, 0,   0, 0, 0,   0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 230, 230, 230,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   9,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   230,
-     230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
-     230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
-     230},
-    {0, 0, 0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 218, 228, 232, 222, 224, 224, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 0, 0,
-     0, 0, 0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0},
-    {0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   230,
-     0,   0,   0, 0, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 0,   0,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   230, 230,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     230, 230, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0},
-    {0,   0,   0,   0,   0,   0,   9,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   9,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   9,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   230,
-     230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
-     230, 230, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0},
-    {0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 220,
-     220, 220, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0,
-     0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0,
-     0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0,   0,   0, 0,   0, 0,   0, 0,   0,   0,   0, 0, 0,   0,   0, 0, 0, 0, 0,
-     0,   0,   0, 0,   0, 0,   0, 0,   0,   0,   0, 0, 0,   0,   0, 0, 0, 0, 0,
-     0,   0,   0, 0,   0, 0,   0, 0,   0,   0,   0, 0, 0,   0,   0, 0, 0, 0, 0,
-     0,   0,   0, 0,   0, 0,   0, 0,   0,   0,   0, 0, 0,   0,   0, 0, 0, 0, 0,
-     0,   0,   0, 0,   0, 0,   0, 0,   0,   0,   0, 0, 0,   0,   0, 0, 0, 0, 0,
-     0,   0,   0, 0,   0, 0,   0, 0,   0,   0,   0, 0, 0,   0,   0, 0, 0, 0, 0,
-     0,   0,   0, 0,   0, 0,   0, 0,   0,   0,   0, 0, 0,   0,   0, 0, 0, 0, 0,
-     0,   0,   0, 0,   0, 0,   0, 0,   0,   0,   0, 0, 0,   0,   0, 0, 0, 0, 0,
-     0,   0,   0, 0,   0, 0,   0, 0,   0,   0,   0, 0, 0,   0,   0, 0, 0, 0, 0,
-     0,   0,   0, 0,   0, 230, 0, 230, 230, 220, 0, 0, 230, 230, 0, 0, 0, 0, 0,
-     230, 230, 0, 230, 0, 0,   0, 0,   0,   0,   0, 0, 0,   0,   0, 0, 0, 0, 0,
-     0,   0,   0, 0,   0, 0,   0, 0,   0,   0,   0, 0, 0,   0,   0, 0, 0, 0, 0,
-     0,   0,   0, 0,   0, 0,   0, 0,   0,   0,   0, 0, 0,   0,   0, 0, 0, 0, 9,
-     0,   0,   0, 0,   0, 0,   0, 0,   0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   230, 230, 230, 230, 230, 230, 230, 220, 220, 220, 220, 220, 220,
-     220, 230, 230, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 220, 0, 0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 220, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 230, 230, 230, 230, 230, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 220, 0, 230, 0,   0, 0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0,   0, 0,   0,   0, 0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0,   0, 0,   230, 1, 220, 0,
-     0, 0, 0, 9, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0,   0, 0,   0,   0, 0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0,   0, 0,   0,   0, 0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0,   0, 0,   0,   0, 0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0,   0, 0,   0,   0, 0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0,   0, 0,   0,   0, 0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0,   0, 0,   0,   0, 0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0,   0, 0,   0,   0, 0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0,   0, 0,   0,   0, 0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 230, 220, 0, 0, 0,   0, 0,   0,   0, 0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0,   0, 0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 230, 230, 230, 230, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,  0, 0, 0, 0,   0,   0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,  0, 0, 0, 0,   0,   0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,  0, 0, 0, 0,   0,   0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,  0, 0, 0, 0,   0,   0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,  0, 0, 0, 0,   0,   0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,  0, 0, 0, 0,   0,   0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,  0, 0, 0, 0,   0,   0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,  0, 0, 0, 230, 230, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,  0, 0, 0, 0,   0,   0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,  0, 0, 0, 0,   0,   0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,  0, 0, 0, 0,   0,   0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 220, 220, 220},
-    {0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 220, 220,
-     230, 230, 230, 220, 230, 220, 220, 220, 220, 0, 0, 0, 0, 0, 0, 0, 0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0,   0,
-     0,   0,   0,   0,   230, 220, 230, 220, 0,   0, 0, 0, 0, 0, 0, 0, 0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0,   0,
-     0,   0,   0,   0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 7, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {230, 230, 230, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0,
-     0,   0,   0,   0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 9, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 9, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0,
-     0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0,
-     0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0,
-     0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,   7,   7,   0, 0, 0,
-     0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,   0,   0,   9, 0, 0,
-     0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0,
-     0,   0,   0,   0,   0,   0, 230, 230, 230, 230, 230, 230, 230, 0, 0, 0,
-     230, 230, 230, 230, 230, 0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0,
-     0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0,
-     0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0,
-     0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0,
-     0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0,
-     0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0,
-     0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0,
-     0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0,
-     0,   0,   0,   0,   0,   0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 7,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 230, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,
-     0, 0, 9, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9,
-     7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 7, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0, 0, 7, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 9, 9, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 230, 230, 230, 230, 230, 230, 230, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0, 0, 216, 216, 1,   1,   1,   0,   0,   0,   226, 216, 216,
-     216, 216, 216, 0, 0, 0,   0,   0,   0,   0,   0,   220, 220, 220, 220, 220,
-     220, 220, 220, 0, 0, 230, 230, 230, 230, 230, 220, 220, 0,   0,   0,   0,
-     0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   230, 230, 230, 230, 0,   0,
-     0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0, 0, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0},
-    {0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     230, 230, 230, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {230, 230, 230, 230, 230, 230, 230, 0,   230, 230, 230, 230, 230, 230, 230,
-     230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 0,   0,   230, 230, 230,
-     230, 230, 230, 230, 0,   230, 230, 0,   230, 230, 230, 230, 230, 0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   230, 0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   230, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 230, 230, 230, 230, 0,   0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 232, 232, 220, 230, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 220, 220, 220, 220, 220, 220, 220, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0,   0},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 230, 230, 230, 230, 230, 230, 7, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0,   0,   0,   0, 0}};
-
-const uint8_t composition_index[4352] = {
-    0, 1, 2, 3, 4,  5,  6, 5, 5,  7,  5, 8,  9,  10, 5, 5, 11, 5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  12, 5, 5, 13, 14, 5, 15, 16, 5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 17, 5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 18, 19, 5, 20, 21, 22, 5, 5, 5,  23, 5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5,  5, 5, 5, 5,
-    5, 5, 5, 5, 5,  5,  5, 5, 5,  5,  5, 5,  5,  5,  5, 5, 5,  5};
-const uint16_t composition_block[67][257] = {
-    {1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
-     1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
-     1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
-     1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
-     1,   3,   5,   7,   7,   7,   39,  45,  55,  67,  101, 103, 117, 131, 161,
-     163, 173, 185, 191, 209, 241, 245, 245, 261, 275, 289, 327, 331, 343, 347,
-     365, 377, 377, 377, 377, 377, 377, 377, 409, 415, 425, 437, 471, 473, 487,
-     503, 531, 535, 545, 557, 563, 581, 613, 617, 617, 633, 647, 663, 701, 705,
-     719, 723, 743, 755, 755, 755, 755, 755, 755, 755, 755, 755, 755, 755, 755,
-     755, 755, 755, 755, 755, 755, 755, 755, 755, 755, 755, 755, 755, 755, 755,
-     755, 755, 755, 755, 755, 755, 755, 755, 755, 755, 755, 755, 755, 755, 755,
-     755, 755, 755, 755, 761, 761, 761, 761, 761, 761, 761, 761, 761, 761, 761,
-     761, 761, 761, 761, 761, 761, 761, 761, 761, 761, 761, 761, 761, 761, 761,
-     769, 769, 771, 773, 777, 779, 779, 779, 787, 787, 787, 787, 787, 789, 789,
-     789, 789, 789, 797, 803, 805, 805, 807, 807, 807, 807, 815, 815, 815, 815,
-     815, 815, 823, 823, 825, 827, 831, 833, 833, 833, 841, 841, 841, 841, 841,
-     843, 843, 843, 843, 843, 851, 857, 859, 859, 861, 861, 861, 861, 869, 869,
-     869, 869},
-    {869, 869, 869, 877, 885, 885, 885, 885, 885, 885, 885, 885, 885, 885, 885,
-     885, 885, 885, 885, 889, 893, 893, 893, 893, 893, 893, 893, 893, 893, 893,
-     893, 893, 893, 893, 893, 893, 893, 893, 893, 893, 893, 893, 893, 893, 893,
-     893, 893, 893, 893, 893, 893, 893, 893, 893, 893, 893, 893, 893, 893, 893,
-     893, 893, 893, 893, 893, 893, 893, 893, 893, 893, 893, 893, 893, 893, 893,
-     893, 893, 897, 901, 901, 901, 901, 901, 901, 901, 901, 901, 901, 901, 901,
-     901, 903, 905, 905, 905, 905, 905, 907, 909, 909, 909, 909, 909, 909, 909,
-     911, 913, 915, 917, 917, 917, 917, 917, 917, 917, 917, 917, 917, 917, 917,
-     917, 917, 917, 917, 917, 917, 917, 917, 919, 919, 919, 919, 919, 919, 919,
-     919, 919, 919, 919, 919, 919, 919, 919, 919, 919, 919, 919, 919, 919, 919,
-     919, 919, 919, 919, 919, 919, 919, 919, 919, 919, 919, 929, 939, 939, 939,
-     939, 939, 939, 939, 939, 939, 939, 939, 939, 939, 939, 949, 959, 959, 959,
-     959, 959, 959, 959, 961, 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
-     961, 961, 961, 961, 961, 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
-     961, 961, 961, 961, 961, 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
-     961, 961, 961, 961, 961, 961, 961, 961, 961, 961, 963, 965, 965, 965, 965,
-     965, 965, 965, 965, 965, 965, 965, 965, 965, 965, 965, 965, 965, 965, 965,
-     965, 965},
-    {965, 965, 965, 965, 965, 965, 965, 965, 965, 965, 965, 965, 965, 965, 965,
-     965, 965, 965, 965, 965, 965, 965, 965, 965, 965, 965, 965, 965, 965, 965,
-     965, 965, 965, 965, 965, 965, 965, 965, 965, 967, 969, 971, 973, 973, 973,
-     973, 973, 975, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977,
-     977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977,
-     977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977,
-     977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977,
-     977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977,
-     977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977,
-     977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 977, 979, 979, 979,
-     979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979,
-     979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979,
-     979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979,
-     979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979,
-     979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979,
-     979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979,
-     979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979,
-     979, 979},
-    {979,  979,  979,  979,  979,  979,  979,  979,  979,  979,  979,  979,
-     979,  979,  979,  979,  979,  979,  979,  979,  979,  979,  979,  979,
-     979,  979,  979,  979,  979,  979,  979,  979,  979,  979,  979,  979,
-     979,  979,  979,  979,  979,  979,  979,  979,  979,  979,  979,  979,
-     979,  979,  979,  979,  979,  979,  979,  979,  979,  979,  979,  979,
-     979,  979,  979,  979,  979,  979,  979,  979,  979,  979,  979,  979,
-     979,  979,  979,  979,  979,  979,  979,  979,  979,  979,  979,  979,
-     979,  979,  979,  979,  979,  979,  979,  979,  979,  979,  979,  979,
-     979,  979,  979,  979,  979,  979,  979,  979,  979,  979,  979,  979,
-     979,  979,  979,  979,  979,  979,  979,  979,  979,  979,  979,  979,
-     979,  979,  979,  979,  979,  979,  979,  979,  979,  979,  979,  979,
-     979,  979,  979,  979,  979,  979,  979,  979,  979,  979,  979,  979,
-     979,  979,  993,  993,  993,  993,  1001, 1001, 1011, 1011, 1025, 1025,
-     1025, 1025, 1025, 1025, 1033, 1033, 1035, 1035, 1035, 1035, 1047, 1047,
-     1047, 1047, 1057, 1057, 1057, 1059, 1059, 1061, 1061, 1061, 1077, 1077,
-     1077, 1077, 1085, 1085, 1097, 1097, 1113, 1113, 1113, 1113, 1113, 1113,
-     1121, 1121, 1125, 1125, 1125, 1125, 1141, 1141, 1141, 1141, 1153, 1159,
-     1165, 1165, 1165, 1167, 1167, 1167, 1167, 1171, 1171, 1171, 1171, 1171,
-     1171, 1171, 1171, 1171, 1171, 1171, 1171, 1171, 1171, 1171, 1171, 1171,
-     1171, 1171, 1171, 1171, 1171, 1171, 1171, 1171, 1171, 1171, 1171, 1171,
-     1171, 1171, 1171, 1171, 1171, 1171, 1171, 1171, 1171, 1171, 1171, 1171,
-     1171, 1171, 1171, 1171, 1171},
-    {1171, 1171, 1171, 1171, 1171, 1171, 1171, 1173, 1173, 1173, 1173, 1173,
-     1173, 1173, 1173, 1173, 1173, 1177, 1177, 1177, 1179, 1179, 1185, 1189,
-     1191, 1199, 1199, 1201, 1201, 1201, 1201, 1203, 1203, 1203, 1203, 1203,
-     1211, 1211, 1211, 1211, 1213, 1213, 1213, 1213, 1215, 1215, 1217, 1217,
-     1217, 1221, 1221, 1221, 1223, 1223, 1229, 1233, 1235, 1243, 1243, 1245,
-     1245, 1245, 1245, 1247, 1247, 1247, 1247, 1247, 1255, 1255, 1255, 1255,
-     1257, 1257, 1257, 1257, 1259, 1259, 1261, 1261, 1261, 1261, 1261, 1261,
-     1261, 1261, 1261, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263,
-     1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263,
-     1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1263, 1265, 1267, 1267,
-     1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267,
-     1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267,
-     1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267,
-     1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267,
-     1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267,
-     1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267,
-     1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267,
-     1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267, 1267,
-     1267, 1269, 1271, 1271, 1271, 1271, 1271, 1271, 1271, 1271, 1271, 1271,
-     1271, 1271, 1271, 1271, 1271, 1273, 1275, 1275, 1275, 1275, 1275, 1275,
-     1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275,
-     1275, 1275, 1275, 1275, 1275},
-    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275,
-     1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275,
-     1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275,
-     1275, 1275, 1275, 1275, 1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281,
-     1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281,
-     1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281,
-     1281, 1283, 1283, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
-     1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
-     1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
-     1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
-     1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
-     1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
-     1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
-     1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
-     1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
-     1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285, 1285,
-     1285, 1285, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
-     1287, 1287, 1287, 1287, 1287, 1287, 1287, 1289, 1289, 1289, 1291, 1291,
-     1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291,
-     1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291,
-     1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291,
-     1291, 1291, 1291, 1291, 1291},
-    {1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291,
-     1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291,
-     1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291, 1291,
-     1291, 1291, 1291, 1291, 1291, 1293, 1293, 1293, 1293, 1293, 1293, 1293,
-     1293, 1295, 1295, 1295, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297,
-     1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297,
-     1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297,
-     1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297,
-     1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297,
-     1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297,
-     1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297,
-     1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297,
-     1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297,
-     1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297,
-     1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297,
-     1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297,
-     1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1301, 1301, 1301, 1301,
-     1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301,
-     1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301,
-     1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301,
-     1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301,
-     1301, 1301, 1301, 1301, 1301},
-    {1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301,
-     1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301,
-     1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301,
-     1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301,
-     1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301,
-     1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301, 1301,
-     1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307,
-     1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307,
-     1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307,
-     1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307,
-     1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307,
-     1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307,
-     1307, 1307, 1307, 1309, 1309, 1309, 1309, 1309, 1309, 1309, 1309, 1309,
-     1309, 1309, 1309, 1309, 1309, 1309, 1309, 1309, 1309, 1309, 1309, 1309,
-     1309, 1309, 1309, 1309, 1309, 1309, 1309, 1309, 1309, 1309, 1309, 1309,
-     1309, 1309, 1309, 1309, 1309, 1309, 1309, 1309, 1309, 1309, 1309, 1309,
-     1309, 1309, 1309, 1309, 1309, 1309, 1309, 1313, 1315, 1315, 1315, 1315,
-     1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315,
-     1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315,
-     1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315,
-     1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315,
-     1315, 1315, 1315, 1315, 1315},
-    {1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315,
-     1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315,
-     1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315,
-     1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315,
-     1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315,
-     1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1315, 1317,
-     1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317,
-     1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317,
-     1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317,
-     1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317,
-     1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317,
-     1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317,
-     1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317,
-     1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317,
-     1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317,
-     1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317, 1317,
-     1319, 1319, 1319, 1319, 1319, 1319, 1319, 1325, 1325, 1325, 1325, 1327,
-     1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327,
-     1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327,
-     1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327,
-     1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327,
-     1327, 1327, 1327, 1327, 1327},
-    {1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327,
-     1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327,
-     1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327,
-     1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327,
-     1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327,
-     1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1327, 1331,
-     1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333,
-     1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333,
-     1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333,
-     1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333,
-     1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333,
-     1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333,
-     1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333,
-     1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333,
-     1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333,
-     1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333,
-     1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333,
-     1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333, 1333,
-     1333, 1333, 1339, 1339, 1339, 1341, 1341, 1341, 1341, 1341, 1341, 1341,
-     1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341,
-     1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341,
-     1341, 1341, 1341, 1341, 1341},
-    {1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341,
-     1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341,
-     1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341, 1341,
-     1341, 1341, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343,
-     1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343,
-     1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343,
-     1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343,
-     1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343,
-     1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343,
-     1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343,
-     1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343,
-     1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343,
-     1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343,
-     1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343,
-     1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343,
-     1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343,
-     1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343,
-     1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343,
-     1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343,
-     1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343,
-     1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343, 1343,
-     1343, 1343, 1343, 1343, 1343},
-    {1343, 1343, 1343, 1343, 1343, 1343, 1345, 1345, 1347, 1347, 1349, 1349,
-     1351, 1351, 1353, 1353, 1353, 1353, 1355, 1355, 1355, 1355, 1355, 1355,
-     1355, 1355, 1355, 1355, 1355, 1355, 1355, 1355, 1355, 1355, 1355, 1355,
-     1355, 1355, 1355, 1355, 1355, 1355, 1355, 1355, 1355, 1355, 1355, 1355,
-     1355, 1355, 1355, 1355, 1355, 1355, 1355, 1355, 1355, 1355, 1355, 1357,
-     1357, 1359, 1359, 1361, 1363, 1363, 1363, 1365, 1365, 1365, 1365, 1365,
-     1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365,
-     1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365,
-     1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365,
-     1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365,
-     1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365,
-     1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365,
-     1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365,
-     1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365,
-     1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365,
-     1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365,
-     1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365,
-     1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365,
-     1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365,
-     1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365,
-     1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365,
-     1365, 1365, 1365, 1365, 1365},
-    {1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365,
-     1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365,
-     1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365,
-     1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365, 1365,
-     1365, 1365, 1365, 1365, 1365, 1365, 1365, 1367, 1369, 1369, 1369, 1369,
-     1369, 1369, 1369, 1369, 1369, 1369, 1369, 1369, 1369, 1369, 1369, 1369,
-     1369, 1369, 1369, 1369, 1369, 1369, 1369, 1369, 1369, 1369, 1369, 1369,
-     1369, 1369, 1369, 1369, 1369, 1369, 1369, 1371, 1373, 1373, 1373, 1373,
-     1373, 1373, 1373, 1375, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377,
-     1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377,
-     1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377,
-     1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377,
-     1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377,
-     1377, 1377, 1377, 1377, 1377, 1381, 1385, 1385, 1385, 1385, 1385, 1385,
-     1385, 1385, 1385, 1385, 1385, 1385, 1385, 1385, 1385, 1385, 1385, 1385,
-     1385, 1385, 1385, 1385, 1385, 1387, 1389, 1389, 1389, 1389, 1389, 1389,
-     1389, 1389, 1389, 1389, 1389, 1389, 1389, 1389, 1389, 1389, 1389, 1389,
-     1389, 1391, 1393, 1393, 1393, 1393, 1393, 1393, 1393, 1393, 1393, 1393,
-     1393, 1393, 1393, 1393, 1393, 1393, 1393, 1393, 1393, 1393, 1393, 1393,
-     1393, 1393, 1393, 1393, 1393, 1393, 1393, 1393, 1393, 1393, 1393, 1393,
-     1393, 1393, 1393, 1393, 1393, 1393, 1393, 1393, 1393, 1393, 1393, 1393,
-     1393, 1393, 1393, 1393, 1393},
-    {1393, 1401, 1409, 1411, 1413, 1415, 1417, 1419, 1421, 1429, 1437, 1439,
-     1441, 1443, 1445, 1447, 1449, 1453, 1457, 1457, 1457, 1457, 1457, 1457,
-     1457, 1461, 1465, 1465, 1465, 1465, 1465, 1465, 1465, 1473, 1481, 1483,
-     1485, 1487, 1489, 1491, 1493, 1501, 1509, 1511, 1513, 1515, 1517, 1519,
-     1521, 1527, 1533, 1533, 1533, 1533, 1533, 1533, 1533, 1539, 1545, 1545,
-     1545, 1545, 1545, 1545, 1545, 1549, 1553, 1553, 1553, 1553, 1553, 1553,
-     1553, 1557, 1561, 1561, 1561, 1561, 1561, 1561, 1561, 1567, 1573, 1573,
-     1573, 1573, 1573, 1573, 1573, 1573, 1579, 1579, 1579, 1579, 1579, 1579,
-     1579, 1587, 1595, 1597, 1599, 1601, 1603, 1605, 1607, 1615, 1623, 1625,
-     1627, 1629, 1631, 1633, 1635, 1637, 1637, 1637, 1637, 1639, 1639, 1639,
-     1639, 1639, 1639, 1639, 1639, 1641, 1641, 1641, 1641, 1641, 1641, 1641,
-     1641, 1641, 1641, 1641, 1641, 1641, 1641, 1641, 1641, 1641, 1641, 1641,
-     1641, 1641, 1641, 1641, 1641, 1641, 1641, 1641, 1641, 1641, 1641, 1641,
-     1641, 1641, 1641, 1641, 1641, 1641, 1641, 1641, 1641, 1641, 1641, 1641,
-     1641, 1641, 1641, 1641, 1641, 1641, 1641, 1641, 1641, 1641, 1641, 1641,
-     1641, 1641, 1641, 1643, 1643, 1643, 1643, 1643, 1643, 1643, 1643, 1643,
-     1649, 1649, 1649, 1649, 1649, 1649, 1649, 1651, 1651, 1651, 1651, 1651,
-     1651, 1651, 1651, 1651, 1651, 1651, 1651, 1651, 1651, 1651, 1651, 1651,
-     1651, 1651, 1651, 1651, 1651, 1651, 1651, 1651, 1651, 1651, 1651, 1651,
-     1651, 1651, 1651, 1651, 1651, 1651, 1651, 1651, 1651, 1651, 1651, 1651,
-     1651, 1651, 1651, 1651, 1651, 1651, 1651, 1653, 1653, 1653, 1653, 1653,
-     1653, 1653, 1653, 1659, 1659},
-    {1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659,
-     1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659,
-     1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659,
-     1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659,
-     1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659,
-     1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659,
-     1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659,
-     1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659,
-     1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659,
-     1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659,
-     1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659,
-     1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659, 1659,
-     1659, 1661, 1661, 1663, 1663, 1665, 1665, 1665, 1665, 1665, 1665, 1665,
-     1665, 1665, 1665, 1665, 1665, 1665, 1665, 1665, 1665, 1665, 1665, 1665,
-     1665, 1665, 1665, 1665, 1665, 1665, 1665, 1665, 1665, 1665, 1665, 1665,
-     1665, 1665, 1665, 1665, 1665, 1665, 1665, 1665, 1665, 1665, 1665, 1665,
-     1665, 1665, 1665, 1665, 1665, 1665, 1665, 1665, 1665, 1665, 1665, 1665,
-     1665, 1665, 1665, 1665, 1665, 1667, 1667, 1669, 1669, 1671, 1671, 1671,
-     1671, 1671, 1671, 1671, 1671, 1671, 1671, 1671, 1671, 1671, 1671, 1671,
-     1671, 1671, 1671, 1671, 1671, 1671, 1671, 1671, 1671, 1671, 1671, 1671,
-     1671, 1671, 1671, 1671, 1671, 1671, 1671, 1671, 1671, 1671, 1671, 1671,
-     1671, 1671, 1671, 1671, 1671},
-    {1671, 1671, 1671, 1671, 1673, 1673, 1673, 1673, 1673, 1675, 1675, 1675,
-     1677, 1677, 1677, 1677, 1677, 1677, 1677, 1677, 1677, 1677, 1677, 1677,
-     1677, 1677, 1677, 1677, 1677, 1677, 1677, 1677, 1677, 1677, 1677, 1677,
-     1679, 1679, 1681, 1681, 1681, 1681, 1681, 1681, 1681, 1681, 1681, 1681,
-     1681, 1681, 1681, 1681, 1681, 1681, 1681, 1681, 1681, 1681, 1681, 1681,
-     1681, 1683, 1683, 1683, 1683, 1683, 1683, 1683, 1685, 1685, 1687, 1687,
-     1687, 1689, 1689, 1689, 1689, 1689, 1691, 1691, 1691, 1691, 1691, 1691,
-     1691, 1691, 1691, 1691, 1691, 1691, 1691, 1691, 1691, 1691, 1691, 1691,
-     1691, 1691, 1693, 1693, 1693, 1695, 1697, 1697, 1697, 1697, 1697, 1697,
-     1697, 1697, 1697, 1697, 1697, 1697, 1697, 1699, 1701, 1701, 1701, 1703,
-     1705, 1705, 1705, 1707, 1709, 1711, 1713, 1713, 1713, 1713, 1713, 1715,
-     1717, 1717, 1717, 1719, 1721, 1721, 1721, 1721, 1721, 1721, 1721, 1721,
-     1721, 1721, 1723, 1725, 1725, 1725, 1725, 1725, 1725, 1725, 1725, 1725,
-     1725, 1725, 1725, 1725, 1725, 1725, 1725, 1727, 1727, 1727, 1727, 1727,
-     1727, 1729, 1731, 1731, 1733, 1733, 1733, 1733, 1733, 1733, 1733, 1735,
-     1737, 1739, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741,
-     1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741,
-     1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741,
-     1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741,
-     1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741,
-     1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741,
-     1741, 1741, 1741, 1741, 1741},
-    {1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741,
-     1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741,
-     1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741,
-     1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741,
-     1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741,
-     1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1741, 1743,
-     1743, 1743, 1743, 1743, 1745, 1745, 1747, 1747, 1749, 1749, 1751, 1751,
-     1753, 1753, 1755, 1755, 1757, 1757, 1759, 1759, 1761, 1761, 1763, 1763,
-     1765, 1765, 1767, 1767, 1767, 1769, 1769, 1771, 1771, 1773, 1773, 1773,
-     1773, 1773, 1773, 1773, 1777, 1777, 1777, 1781, 1781, 1781, 1785, 1785,
-     1785, 1789, 1789, 1789, 1793, 1793, 1793, 1793, 1793, 1793, 1793, 1793,
-     1793, 1793, 1793, 1793, 1793, 1793, 1793, 1793, 1793, 1793, 1793, 1793,
-     1793, 1793, 1793, 1793, 1793, 1793, 1793, 1793, 1793, 1793, 1793, 1793,
-     1793, 1793, 1795, 1795, 1795, 1795, 1795, 1795, 1795, 1795, 1795, 1797,
-     1797, 1797, 1797, 1797, 1799, 1799, 1801, 1801, 1803, 1803, 1805, 1805,
-     1807, 1807, 1809, 1809, 1811, 1811, 1813, 1813, 1815, 1815, 1817, 1817,
-     1819, 1819, 1821, 1821, 1821, 1823, 1823, 1825, 1825, 1827, 1827, 1827,
-     1827, 1827, 1827, 1827, 1831, 1831, 1831, 1835, 1835, 1835, 1839, 1839,
-     1839, 1843, 1843, 1843, 1847, 1847, 1847, 1847, 1847, 1847, 1847, 1847,
-     1847, 1847, 1847, 1847, 1847, 1847, 1847, 1847, 1847, 1847, 1847, 1847,
-     1849, 1851, 1853, 1855, 1855, 1855, 1855, 1855, 1855, 1855, 1855, 1855,
-     1855, 1855, 1857, 1857, 1857},
-    {1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857,
-     1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857,
-     1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857,
-     1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857,
-     1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857,
-     1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857,
-     1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857,
-     1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857,
-     1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857,
-     1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857,
-     1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857,
-     1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857,
-     1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1857, 1859, 1859,
-     1861, 1861, 1861, 1861, 1861, 1861, 1861, 1861, 1861, 1861, 1863, 1863,
-     1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863,
-     1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863,
-     1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863,
-     1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863,
-     1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863,
-     1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863,
-     1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863,
-     1863, 1863, 1863, 1863, 1863},
-    {1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863,
-     1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863,
-     1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863,
-     1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863, 1863,
-     1863, 1863, 1865, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867,
-     1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867,
-     1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867,
-     1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867,
-     1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867,
-     1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867,
-     1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867,
-     1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867,
-     1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867,
-     1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867,
-     1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867,
-     1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867,
-     1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867,
-     1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867,
-     1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867,
-     1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867,
-     1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867,
-     1867, 1867, 1867, 1867, 1867},
-    {1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867,
-     1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867,
-     1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867,
-     1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867,
-     1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867,
-     1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867, 1867,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871},
-    {1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871, 1871,
-     1871, 1871, 1871, 1871, 1871, 1871, 1877, 1877, 1877, 1877, 1877, 1877,
-     1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877,
-     1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877,
-     1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877,
-     1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877,
-     1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877,
-     1877, 1877, 1877, 1877, 1877},
-    {1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877,
-     1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877,
-     1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877,
-     1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877,
-     1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877,
-     1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877,
-     1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877,
-     1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877,
-     1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877,
-     1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877,
-     1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877,
-     1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877,
-     1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877,
-     1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877,
-     1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877,
-     1877, 1877, 1877, 1877, 1877, 1879, 1881, 1881, 1881, 1881, 1881, 1881,
-     1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881,
-     1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881,
-     1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881,
-     1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881,
-     1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881,
-     1881, 1881, 1881, 1881, 1881},
-    {1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881,
-     1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881,
-     1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881,
-     1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881, 1881,
-     1881, 1881, 1881, 1881, 1881, 1881, 1883, 1883, 1883, 1883, 1883, 1883,
-     1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883,
-     1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883,
-     1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883,
-     1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883,
-     1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883,
-     1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883,
-     1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883,
-     1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883,
-     1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883,
-     1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883,
-     1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883,
-     1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883,
-     1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883,
-     1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883,
-     1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883,
-     1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883, 1883,
-     1883, 1883, 1883, 1883, 1883}};
-const char32_t composition_data[1883] = {
-    0,     824,   8814,  824,   8800,  824,   8815,  768,   192,   769,   193,
-    770,   194,   771,   195,   772,   256,   774,   258,   775,   550,   776,
-    196,   777,   7842,  778,   197,   780,   461,   783,   512,   785,   514,
-    803,   7840,  805,   7680,  808,   260,   775,   7682,  803,   7684,  817,
-    7686,  769,   262,   770,   264,   775,   266,   780,   268,   807,   199,
-    775,   7690,  780,   270,   803,   7692,  807,   7696,  813,   7698,  817,
-    7694,  768,   200,   769,   201,   770,   202,   771,   7868,  772,   274,
-    774,   276,   775,   278,   776,   203,   777,   7866,  780,   282,   783,
-    516,   785,   518,   803,   7864,  807,   552,   808,   280,   813,   7704,
-    816,   7706,  775,   7710,  769,   500,   770,   284,   772,   7712,  774,
-    286,   775,   288,   780,   486,   807,   290,   770,   292,   775,   7714,
-    776,   7718,  780,   542,   803,   7716,  807,   7720,  814,   7722,  768,
-    204,   769,   205,   770,   206,   771,   296,   772,   298,   774,   300,
-    775,   304,   776,   207,   777,   7880,  780,   463,   783,   520,   785,
-    522,   803,   7882,  808,   302,   816,   7724,  770,   308,   769,   7728,
-    780,   488,   803,   7730,  807,   310,   817,   7732,  769,   313,   780,
-    317,   803,   7734,  807,   315,   813,   7740,  817,   7738,  769,   7742,
-    775,   7744,  803,   7746,  768,   504,   769,   323,   771,   209,   775,
-    7748,  780,   327,   803,   7750,  807,   325,   813,   7754,  817,   7752,
-    768,   210,   769,   211,   770,   212,   771,   213,   772,   332,   774,
-    334,   775,   558,   776,   214,   777,   7886,  779,   336,   780,   465,
-    783,   524,   785,   526,   795,   416,   803,   7884,  808,   490,   769,
-    7764,  775,   7766,  769,   340,   775,   7768,  780,   344,   783,   528,
-    785,   530,   803,   7770,  807,   342,   817,   7774,  769,   346,   770,
-    348,   775,   7776,  780,   352,   803,   7778,  806,   536,   807,   350,
-    775,   7786,  780,   356,   803,   7788,  806,   538,   807,   354,   813,
-    7792,  817,   7790,  768,   217,   769,   218,   770,   219,   771,   360,
-    772,   362,   774,   364,   776,   220,   777,   7910,  778,   366,   779,
-    368,   780,   467,   783,   532,   785,   534,   795,   431,   803,   7908,
-    804,   7794,  808,   370,   813,   7798,  816,   7796,  771,   7804,  803,
-    7806,  768,   7808,  769,   7810,  770,   372,   775,   7814,  776,   7812,
-    803,   7816,  775,   7818,  776,   7820,  768,   7922,  769,   221,   770,
-    374,   771,   7928,  772,   562,   775,   7822,  776,   376,   777,   7926,
-    803,   7924,  769,   377,   770,   7824,  775,   379,   780,   381,   803,
-    7826,  817,   7828,  768,   224,   769,   225,   770,   226,   771,   227,
-    772,   257,   774,   259,   775,   551,   776,   228,   777,   7843,  778,
-    229,   780,   462,   783,   513,   785,   515,   803,   7841,  805,   7681,
-    808,   261,   775,   7683,  803,   7685,  817,   7687,  769,   263,   770,
-    265,   775,   267,   780,   269,   807,   231,   775,   7691,  780,   271,
-    803,   7693,  807,   7697,  813,   7699,  817,   7695,  768,   232,   769,
-    233,   770,   234,   771,   7869,  772,   275,   774,   277,   775,   279,
-    776,   235,   777,   7867,  780,   283,   783,   517,   785,   519,   803,
-    7865,  807,   553,   808,   281,   813,   7705,  816,   7707,  775,   7711,
-    769,   501,   770,   285,   772,   7713,  774,   287,   775,   289,   780,
-    487,   807,   291,   770,   293,   775,   7715,  776,   7719,  780,   543,
-    803,   7717,  807,   7721,  814,   7723,  817,   7830,  768,   236,   769,
-    237,   770,   238,   771,   297,   772,   299,   774,   301,   776,   239,
-    777,   7881,  780,   464,   783,   521,   785,   523,   803,   7883,  808,
-    303,   816,   7725,  770,   309,   780,   496,   769,   7729,  780,   489,
-    803,   7731,  807,   311,   817,   7733,  769,   314,   780,   318,   803,
-    7735,  807,   316,   813,   7741,  817,   7739,  769,   7743,  775,   7745,
-    803,   7747,  768,   505,   769,   324,   771,   241,   775,   7749,  780,
-    328,   803,   7751,  807,   326,   813,   7755,  817,   7753,  768,   242,
-    769,   243,   770,   244,   771,   245,   772,   333,   774,   335,   775,
-    559,   776,   246,   777,   7887,  779,   337,   780,   466,   783,   525,
-    785,   527,   795,   417,   803,   7885,  808,   491,   769,   7765,  775,
-    7767,  769,   341,   775,   7769,  780,   345,   783,   529,   785,   531,
-    803,   7771,  807,   343,   817,   7775,  769,   347,   770,   349,   775,
-    7777,  780,   353,   803,   7779,  806,   537,   807,   351,   775,   7787,
-    776,   7831,  780,   357,   803,   7789,  806,   539,   807,   355,   813,
-    7793,  817,   7791,  768,   249,   769,   250,   770,   251,   771,   361,
-    772,   363,   774,   365,   776,   252,   777,   7911,  778,   367,   779,
-    369,   780,   468,   783,   533,   785,   535,   795,   432,   803,   7909,
-    804,   7795,  808,   371,   813,   7799,  816,   7797,  771,   7805,  803,
-    7807,  768,   7809,  769,   7811,  770,   373,   775,   7815,  776,   7813,
-    778,   7832,  803,   7817,  775,   7819,  776,   7821,  768,   7923,  769,
-    253,   770,   375,   771,   7929,  772,   563,   775,   7823,  776,   255,
-    777,   7927,  778,   7833,  803,   7925,  769,   378,   770,   7825,  775,
-    380,   780,   382,   803,   7827,  817,   7829,  768,   8173,  769,   901,
-    834,   8129,  768,   7846,  769,   7844,  771,   7850,  777,   7848,  772,
-    478,   769,   506,   769,   508,   772,   482,   769,   7688,  768,   7872,
-    769,   7870,  771,   7876,  777,   7874,  769,   7726,  768,   7890,  769,
-    7888,  771,   7894,  777,   7892,  769,   7756,  772,   556,   776,   7758,
-    772,   554,   769,   510,   768,   475,   769,   471,   772,   469,   780,
-    473,   768,   7847,  769,   7845,  771,   7851,  777,   7849,  772,   479,
-    769,   507,   769,   509,   772,   483,   769,   7689,  768,   7873,  769,
-    7871,  771,   7877,  777,   7875,  769,   7727,  768,   7891,  769,   7889,
-    771,   7895,  777,   7893,  769,   7757,  772,   557,   776,   7759,  772,
-    555,   769,   511,   768,   476,   769,   472,   772,   470,   780,   474,
-    768,   7856,  769,   7854,  771,   7860,  777,   7858,  768,   7857,  769,
-    7855,  771,   7861,  777,   7859,  768,   7700,  769,   7702,  768,   7701,
-    769,   7703,  768,   7760,  769,   7762,  768,   7761,  769,   7763,  775,
-    7780,  775,   7781,  775,   7782,  775,   7783,  769,   7800,  769,   7801,
-    776,   7802,  776,   7803,  775,   7835,  768,   7900,  769,   7898,  771,
-    7904,  777,   7902,  803,   7906,  768,   7901,  769,   7899,  771,   7905,
-    777,   7903,  803,   7907,  768,   7914,  769,   7912,  771,   7918,  777,
-    7916,  803,   7920,  768,   7915,  769,   7913,  771,   7919,  777,   7917,
-    803,   7921,  780,   494,   772,   492,   772,   493,   772,   480,   772,
-    481,   774,   7708,  774,   7709,  772,   560,   772,   561,   780,   495,
-    768,   8122,  769,   902,   772,   8121,  774,   8120,  787,   7944,  788,
-    7945,  837,   8124,  768,   8136,  769,   904,   787,   7960,  788,   7961,
-    768,   8138,  769,   905,   787,   7976,  788,   7977,  837,   8140,  768,
-    8154,  769,   906,   772,   8153,  774,   8152,  776,   938,   787,   7992,
-    788,   7993,  768,   8184,  769,   908,   787,   8008,  788,   8009,  788,
-    8172,  768,   8170,  769,   910,   772,   8169,  774,   8168,  776,   939,
-    788,   8025,  768,   8186,  769,   911,   787,   8040,  788,   8041,  837,
-    8188,  837,   8116,  837,   8132,  768,   8048,  769,   940,   772,   8113,
-    774,   8112,  787,   7936,  788,   7937,  834,   8118,  837,   8115,  768,
-    8050,  769,   941,   787,   7952,  788,   7953,  768,   8052,  769,   942,
-    787,   7968,  788,   7969,  834,   8134,  837,   8131,  768,   8054,  769,
-    943,   772,   8145,  774,   8144,  776,   970,   787,   7984,  788,   7985,
-    834,   8150,  768,   8056,  769,   972,   787,   8000,  788,   8001,  787,
-    8164,  788,   8165,  768,   8058,  769,   973,   772,   8161,  774,   8160,
-    776,   971,   787,   8016,  788,   8017,  834,   8166,  768,   8060,  769,
-    974,   787,   8032,  788,   8033,  834,   8182,  837,   8179,  768,   8146,
-    769,   912,   834,   8151,  768,   8162,  769,   944,   834,   8167,  837,
-    8180,  769,   979,   776,   980,   776,   1031,  774,   1232,  776,   1234,
-    769,   1027,  768,   1024,  774,   1238,  776,   1025,  774,   1217,  776,
-    1244,  776,   1246,  768,   1037,  772,   1250,  774,   1049,  776,   1252,
-    769,   1036,  776,   1254,  772,   1262,  774,   1038,  776,   1264,  779,
-    1266,  776,   1268,  776,   1272,  776,   1260,  774,   1233,  776,   1235,
-    769,   1107,  768,   1104,  774,   1239,  776,   1105,  774,   1218,  776,
-    1245,  776,   1247,  768,   1117,  772,   1251,  774,   1081,  776,   1253,
-    769,   1116,  776,   1255,  772,   1263,  774,   1118,  776,   1265,  779,
-    1267,  776,   1269,  776,   1273,  776,   1261,  776,   1111,  783,   1142,
-    783,   1143,  776,   1242,  776,   1243,  776,   1258,  776,   1259,  1619,
-    1570,  1620,  1571,  1621,  1573,  1620,  1572,  1620,  1574,  1620,  1730,
-    1620,  1747,  1620,  1728,  2364,  2345,  2364,  2353,  2364,  2356,  2494,
-    2507,  2519,  2508,  2878,  2891,  2902,  2888,  2903,  2892,  3031,  2964,
-    3006,  3018,  3031,  3020,  3006,  3019,  3158,  3144,  3285,  3264,  3266,
-    3274,  3285,  3271,  3286,  3272,  3285,  3275,  3390,  3402,  3415,  3404,
-    3390,  3403,  3530,  3546,  3535,  3548,  3551,  3550,  3530,  3549,  4142,
-    4134,  6965,  6918,  6965,  6920,  6965,  6922,  6965,  6924,  6965,  6926,
-    6965,  6930,  6965,  6971,  6965,  6973,  6965,  6976,  6965,  6977,  6965,
-    6979,  772,   7736,  772,   7737,  772,   7772,  772,   7773,  775,   7784,
-    775,   7785,  770,   7852,  774,   7862,  770,   7853,  774,   7863,  770,
-    7878,  770,   7879,  770,   7896,  770,   7897,  768,   7938,  769,   7940,
-    834,   7942,  837,   8064,  768,   7939,  769,   7941,  834,   7943,  837,
-    8065,  837,   8066,  837,   8067,  837,   8068,  837,   8069,  837,   8070,
-    837,   8071,  768,   7946,  769,   7948,  834,   7950,  837,   8072,  768,
-    7947,  769,   7949,  834,   7951,  837,   8073,  837,   8074,  837,   8075,
-    837,   8076,  837,   8077,  837,   8078,  837,   8079,  768,   7954,  769,
-    7956,  768,   7955,  769,   7957,  768,   7962,  769,   7964,  768,   7963,
-    769,   7965,  768,   7970,  769,   7972,  834,   7974,  837,   8080,  768,
-    7971,  769,   7973,  834,   7975,  837,   8081,  837,   8082,  837,   8083,
-    837,   8084,  837,   8085,  837,   8086,  837,   8087,  768,   7978,  769,
-    7980,  834,   7982,  837,   8088,  768,   7979,  769,   7981,  834,   7983,
-    837,   8089,  837,   8090,  837,   8091,  837,   8092,  837,   8093,  837,
-    8094,  837,   8095,  768,   7986,  769,   7988,  834,   7990,  768,   7987,
-    769,   7989,  834,   7991,  768,   7994,  769,   7996,  834,   7998,  768,
-    7995,  769,   7997,  834,   7999,  768,   8002,  769,   8004,  768,   8003,
-    769,   8005,  768,   8010,  769,   8012,  768,   8011,  769,   8013,  768,
-    8018,  769,   8020,  834,   8022,  768,   8019,  769,   8021,  834,   8023,
-    768,   8027,  769,   8029,  834,   8031,  768,   8034,  769,   8036,  834,
-    8038,  837,   8096,  768,   8035,  769,   8037,  834,   8039,  837,   8097,
-    837,   8098,  837,   8099,  837,   8100,  837,   8101,  837,   8102,  837,
-    8103,  768,   8042,  769,   8044,  834,   8046,  837,   8104,  768,   8043,
-    769,   8045,  834,   8047,  837,   8105,  837,   8106,  837,   8107,  837,
-    8108,  837,   8109,  837,   8110,  837,   8111,  837,   8114,  837,   8130,
-    837,   8178,  837,   8119,  768,   8141,  769,   8142,  834,   8143,  837,
-    8135,  837,   8183,  768,   8157,  769,   8158,  834,   8159,  824,   8602,
-    824,   8603,  824,   8622,  824,   8653,  824,   8655,  824,   8654,  824,
-    8708,  824,   8713,  824,   8716,  824,   8740,  824,   8742,  824,   8769,
-    824,   8772,  824,   8775,  824,   8777,  824,   8813,  824,   8802,  824,
-    8816,  824,   8817,  824,   8820,  824,   8821,  824,   8824,  824,   8825,
-    824,   8832,  824,   8833,  824,   8928,  824,   8929,  824,   8836,  824,
-    8837,  824,   8840,  824,   8841,  824,   8930,  824,   8931,  824,   8876,
-    824,   8877,  824,   8878,  824,   8879,  824,   8938,  824,   8939,  824,
-    8940,  824,   8941,  12441, 12436, 12441, 12364, 12441, 12366, 12441, 12368,
-    12441, 12370, 12441, 12372, 12441, 12374, 12441, 12376, 12441, 12378, 12441,
-    12380, 12441, 12382, 12441, 12384, 12441, 12386, 12441, 12389, 12441, 12391,
-    12441, 12393, 12441, 12400, 12442, 12401, 12441, 12403, 12442, 12404, 12441,
-    12406, 12442, 12407, 12441, 12409, 12442, 12410, 12441, 12412, 12442, 12413,
-    12441, 12446, 12441, 12532, 12441, 12460, 12441, 12462, 12441, 12464, 12441,
-    12466, 12441, 12468, 12441, 12470, 12441, 12472, 12441, 12474, 12441, 12476,
-    12441, 12478, 12441, 12480, 12441, 12482, 12441, 12485, 12441, 12487, 12441,
-    12489, 12441, 12496, 12442, 12497, 12441, 12499, 12442, 12500, 12441, 12502,
-    12442, 12503, 12441, 12505, 12442, 12506, 12441, 12508, 12442, 12509, 12441,
-    12535, 12441, 12536, 12441, 12537, 12441, 12538, 12441, 12542, 69818, 69786,
-    69818, 69788, 69818, 69803, 69927, 69934, 69927, 69935, 70462, 70475, 70487,
-    70476, 70832, 70844, 70842, 70843, 70845, 70846, 71087, 71098, 71087, 71099,
-    71984, 71992};
-
-}  // namespace ada::idna
-#endif  // ADA_IDNA_NORMALIZATION_TABLES_H
-/* end file src/normalization_tables.cpp */
-
-namespace ada::idna {
-
-// See
-// https://github.com/uni-algo/uni-algo/blob/c612968c5ed3ace39bde4c894c24286c5f2c7fe2/include/uni_algo/impl/impl_norm.h#L467
-constexpr char32_t hangul_sbase = 0xAC00;
-constexpr char32_t hangul_tbase = 0x11A7;
-constexpr char32_t hangul_vbase = 0x1161;
-constexpr char32_t hangul_lbase = 0x1100;
-constexpr char32_t hangul_lcount = 19;
-constexpr char32_t hangul_vcount = 21;
-constexpr char32_t hangul_tcount = 28;
-constexpr char32_t hangul_ncount = hangul_vcount * hangul_tcount;
-constexpr char32_t hangul_scount =
-    hangul_lcount * hangul_vcount * hangul_tcount;
-
-std::pair<bool, size_t> compute_decomposition_length(
-    const std::u32string_view input) noexcept {
-  bool decomposition_needed{false};
-  size_t additional_elements{0};
-  for (char32_t current_character : input) {
-    size_t decomposition_length{0};
-
-    if (current_character >= hangul_sbase &&
-        current_character < hangul_sbase + hangul_scount) {
-      decomposition_length = 2;
-      if ((current_character - hangul_sbase) % hangul_tcount) {
-        decomposition_length = 3;
-      }
-    } else if (current_character < 0x110000) {
-      const uint8_t di = decomposition_index[current_character >> 8];
-      const uint16_t* const decomposition =
-          decomposition_block[di] + (current_character % 256);
-      decomposition_length = (decomposition[1] >> 2) - (decomposition[0] >> 2);
-      if ((decomposition_length > 0) && (decomposition[0] & 1)) {
-        decomposition_length = 0;
-      }
-    }
-    if (decomposition_length != 0) {
-      decomposition_needed = true;
-      additional_elements += decomposition_length - 1;
-    }
-  }
-  return {decomposition_needed, additional_elements};
-}
-
-void decompose(std::u32string& input, size_t additional_elements) {
-  input.resize(input.size() + additional_elements);
-  for (size_t descending_idx = input.size(),
-              input_count = descending_idx - additional_elements;
-       input_count--;) {
-    if (input[input_count] >= hangul_sbase &&
-        input[input_count] < hangul_sbase + hangul_scount) {
-      // Hangul decomposition.
-      char32_t s_index = input[input_count] - hangul_sbase;
-      if (s_index % hangul_tcount != 0) {
-        input[--descending_idx] = hangul_tbase + s_index % hangul_tcount;
-      }
-      input[--descending_idx] =
-          hangul_vbase + (s_index % hangul_ncount) / hangul_tcount;
-      input[--descending_idx] = hangul_lbase + s_index / hangul_ncount;
-    } else if (input[input_count] < 0x110000) {
-      // Check decomposition_data.
-      const uint16_t* decomposition =
-          decomposition_block[decomposition_index[input[input_count] >> 8]] +
-          (input[input_count] % 256);
-      uint16_t decomposition_length =
-          (decomposition[1] >> 2) - (decomposition[0] >> 2);
-      if (decomposition_length > 0 && (decomposition[0] & 1)) {
-        decomposition_length = 0;
-      }
-      if (decomposition_length > 0) {
-        // Non-recursive decomposition.
-        while (decomposition_length-- > 0) {
-          input[--descending_idx] = decomposition_data[(decomposition[0] >> 2) +
-                                                       decomposition_length];
-        }
-      } else {
-        // No decomposition.
-        input[--descending_idx] = input[input_count];
-      }
-    } else {
-      // Non-Unicode character.
-      input[--descending_idx] = input[input_count];
-    }
-  }
-}
-
-uint8_t get_ccc(char32_t c) noexcept {
-  return c < 0x110000 ? canonical_combining_class_block
-                            [canonical_combining_class_index[c >> 8]][c % 256]
-                      : 0;
-}
-
-void sort_marks(std::u32string& input) {
-  for (size_t idx = 1; idx < input.size(); idx++) {
-    uint8_t ccc = get_ccc(input[idx]);
-    if (ccc == 0) {
-      continue;
-    }  // Skip non-combining characters.
-    auto current_character = input[idx];
-    size_t back_idx = idx;
-    while (back_idx != 0 && get_ccc(input[back_idx - 1]) > ccc) {
-      input[back_idx] = input[back_idx - 1];
-      back_idx--;
-    }
-    input[back_idx] = current_character;
-  }
-}
-
-void decompose_nfc(std::u32string& input) {
-  /**
-   * Decompose the domain_name string to Unicode Normalization Form C.
-   * @see https://www.unicode.org/reports/tr46/#ProcessingStepDecompose
-   */
-  auto [decomposition_needed, additional_elements] =
-      compute_decomposition_length(input);
-  if (decomposition_needed) {
-    decompose(input, additional_elements);
-  }
-  sort_marks(input);
-}
-
-void compose(std::u32string& input) {
-  /**
-   * Compose the domain_name string to Unicode Normalization Form C.
-   * @see https://www.unicode.org/reports/tr46/#ProcessingStepCompose
-   */
-  size_t input_count{0};
-  size_t composition_count{0};
-  for (; input_count < input.size(); input_count++, composition_count++) {
-    input[composition_count] = input[input_count];
-    if (input[input_count] >= hangul_lbase &&
-        input[input_count] < hangul_lbase + hangul_lcount) {
-      if (input_count + 1 < input.size() &&
-          input[input_count + 1] >= hangul_vbase &&
-          input[input_count + 1] < hangul_vbase + hangul_vcount) {
-        input[composition_count] =
-            hangul_sbase +
-            ((input[input_count] - hangul_lbase) * hangul_vcount +
-             input[input_count + 1] - hangul_vbase) *
-                hangul_tcount;
-        input_count++;
-        if (input_count + 1 < input.size() &&
-            input[input_count + 1] > hangul_tbase &&
-            input[input_count + 1] < hangul_tbase + hangul_tcount) {
-          input[composition_count] += input[++input_count] - hangul_tbase;
-        }
-      }
-    } else if (input[input_count] >= hangul_sbase &&
-               input[input_count] < hangul_sbase + hangul_scount) {
-      if ((input[input_count] - hangul_sbase) % hangul_tcount &&
-          input_count + 1 < input.size() &&
-          input[input_count + 1] > hangul_tbase &&
-          input[input_count + 1] < hangul_tbase + hangul_tcount) {
-        input[composition_count] += input[++input_count] - hangul_tbase;
-      }
-    } else if (input[input_count] < 0x110000) {
-      const uint16_t* composition =
-          &composition_block[composition_index[input[input_count] >> 8]]
-                            [input[input_count] % 256];
-      size_t initial_composition_count = composition_count;
-      for (int32_t previous_ccc = -1; input_count + 1 < input.size();
-           input_count++) {
-        uint8_t ccc = get_ccc(input[input_count + 1]);
-
-        if (composition[1] != composition[0] && previous_ccc < ccc) {
-          // Try finding a composition.
-          uint16_t left = composition[0];
-          uint16_t right = composition[1];
-          while (left + 2 < right) {
-            // mean without overflow
-            uint16_t middle = left + (((right - left) >> 1) & ~1);
-            if (composition_data[middle] <= input[input_count + 1]) {
-              left = middle;
-            }
-            if (composition_data[middle] >= input[input_count + 1]) {
-              right = middle;
-            }
-          }
-          if (composition_data[left] == input[input_count + 1]) {
-            input[initial_composition_count] = composition_data[left + 1];
-            composition =
-                &composition_block
-                    [composition_index[composition_data[left + 1] >> 8]]
-                    [composition_data[left + 1] % 256];
-            continue;
-          }
-        }
-
-        if (ccc == 0) {
-          break;
-        }  // Not a combining character.
-        previous_ccc = ccc;
-        input[++composition_count] = input[input_count + 1];
-      }
-    }
-  }
-
-  if (composition_count < input_count) {
-    input.resize(composition_count);
-  }
-}
-
-void normalize(std::u32string& input) {
-  /**
-   * Normalize the domain_name string to Unicode Normalization Form C.
-   * @see https://www.unicode.org/reports/tr46/#ProcessingStepNormalize
-   */
-  decompose_nfc(input);
-  compose(input);
-}
-
-}  // namespace ada::idna
-/* end file src/normalization.cpp */
-/* begin file src/punycode.cpp */
-
-#include <cstdint>
-
-namespace ada::idna {
-
-constexpr int32_t base = 36;
-constexpr int32_t tmin = 1;
-constexpr int32_t tmax = 26;
-constexpr int32_t skew = 38;
-constexpr int32_t damp = 700;
-constexpr int32_t initial_bias = 72;
-constexpr uint32_t initial_n = 128;
-
-static constexpr int32_t char_to_digit_value(char value) {
-  if (value >= 'a' && value <= 'z') return value - 'a';
-  if (value >= '0' && value <= '9') return value - '0' + 26;
-  return -1;
-}
-
-static constexpr char digit_to_char(int32_t digit) {
-  return digit < 26 ? char(digit + 97) : char(digit + 22);
-}
-
-static constexpr int32_t adapt(int32_t d, int32_t n, bool firsttime) {
-  if (firsttime) {
-    d = d / damp;
-  } else {
-    d = d / 2;
-  }
-  d += d / n;
-  int32_t k = 0;
-  while (d > ((base - tmin) * tmax) / 2) {
-    d /= base - tmin;
-    k += base;
-  }
-  return k + (((base - tmin + 1) * d) / (d + skew));
-}
-
-bool punycode_to_utf32(std::string_view input, std::u32string &out) {
-  int32_t written_out{0};
-  out.reserve(out.size() + input.size());
-  uint32_t n = initial_n;
-  int32_t i = 0;
-  int32_t bias = initial_bias;
-  // grab ascii content
-  size_t end_of_ascii = input.find_last_of('-');
-  if (end_of_ascii != std::string_view::npos) {
-    for (uint8_t c : input.substr(0, end_of_ascii)) {
-      if (c >= 0x80) {
-        return false;
-      }
-      out.push_back(c);
-      written_out++;
-    }
-    input.remove_prefix(end_of_ascii + 1);
-  }
-  while (!input.empty()) {
-    int32_t oldi = i;
-    int32_t w = 1;
-    for (int32_t k = base;; k += base) {
-      if (input.empty()) {
-        return false;
-      }
-      uint8_t code_point = input.front();
-      input.remove_prefix(1);
-      int32_t digit = char_to_digit_value(code_point);
-      if (digit < 0) {
-        return false;
-      }
-      if (digit > (0x7fffffff - i) / w) {
-        return false;
-      }
-      i = i + digit * w;
-      int32_t t = k <= bias ? tmin : k >= bias + tmax ? tmax : k - bias;
-      if (digit < t) {
-        break;
-      }
-      if (w > 0x7fffffff / (base - t)) {
-        return false;
-      }
-      w = w * (base - t);
-    }
-    bias = adapt(i - oldi, written_out + 1, oldi == 0);
-    if (i / (written_out + 1) > int32_t(0x7fffffff - n)) {
-      return false;
-    }
-    n = n + i / (written_out + 1);
-    i = i % (written_out + 1);
-    if (n < 0x80) {
-      return false;
-    }
-    out.insert(out.begin() + i, n);
-    written_out++;
-    ++i;
-  }
-
-  return true;
-}
-
-bool verify_punycode(std::string_view input) {
-  size_t written_out{0};
-  uint32_t n = initial_n;
-  int32_t i = 0;
-  int32_t bias = initial_bias;
-  // grab ascii content
-  size_t end_of_ascii = input.find_last_of('-');
-  if (end_of_ascii != std::string_view::npos) {
-    for (uint8_t c : input.substr(0, end_of_ascii)) {
-      if (c >= 0x80) {
-        return false;
-      }
-      written_out++;
-    }
-    input.remove_prefix(end_of_ascii + 1);
-  }
-  while (!input.empty()) {
-    int32_t oldi = i;
-    int32_t w = 1;
-    for (int32_t k = base;; k += base) {
-      if (input.empty()) {
-        return false;
-      }
-      uint8_t code_point = input.front();
-      input.remove_prefix(1);
-      int32_t digit = char_to_digit_value(code_point);
-      if (digit < 0) {
-        return false;
-      }
-      if (digit > (0x7fffffff - i) / w) {
-        return false;
-      }
-      i = i + digit * w;
-      int32_t t = k <= bias ? tmin : k >= bias + tmax ? tmax : k - bias;
-      if (digit < t) {
-        break;
-      }
-      if (w > 0x7fffffff / (base - t)) {
-        return false;
-      }
-      w = w * (base - t);
-    }
-    bias = adapt(i - oldi, int32_t(written_out + 1), oldi == 0);
-    if (i / (written_out + 1) > 0x7fffffff - n) {
-      return false;
-    }
-    n = n + i / int32_t(written_out + 1);
-    i = i % int32_t(written_out + 1);
-    if (n < 0x80) {
-      return false;
-    }
-    written_out++;
-    ++i;
-  }
-
-  return true;
-}
-
-bool utf32_to_punycode(std::u32string_view input, std::string &out) {
-  out.reserve(input.size() + out.size());
-  uint32_t n = initial_n;
-  int32_t d = 0;
-  int32_t bias = initial_bias;
-  size_t h = 0;
-  // first push the ascii content
-  for (uint32_t c : input) {
-    if (c < 0x80) {
-      ++h;
-      out.push_back(char(c));
-    }
-    if (c > 0x10ffff || (c >= 0xd880 && c < 0xe000)) {
-      return false;
-    }
-  }
-  size_t b = h;
-  if (b > 0) {
-    out.push_back('-');
-  }
-  while (h < input.size()) {
-    uint32_t m = 0x10FFFF;
-    for (auto code_point : input) {
-      if (code_point >= n && code_point < m) m = code_point;
-    }
-
-    if ((m - n) > (0x7fffffff - d) / (h + 1)) {
-      return false;
-    }
-    d = d + int32_t((m - n) * (h + 1));
-    n = m;
-    for (auto c : input) {
-      if (c < n) {
-        if (d == 0x7fffffff) {
-          return false;
-        }
-        ++d;
-      }
-      if (c == n) {
-        int32_t q = d;
-        for (int32_t k = base;; k += base) {
-          int32_t t = k <= bias ? tmin : k >= bias + tmax ? tmax : k - bias;
-
-          if (q < t) {
-            break;
-          }
-          out.push_back(digit_to_char(t + ((q - t) % (base - t))));
-          q = (q - t) / (base - t);
-        }
-        out.push_back(digit_to_char(q));
-        bias = adapt(d, int32_t(h + 1), h == b);
-        d = 0;
-        ++h;
-      }
-    }
-    ++d;
-    ++n;
-  }
-  return true;
-}
-
-}  // namespace ada::idna
-/* end file src/punycode.cpp */
-/* begin file src/validity.cpp */
-#include <algorithm>
-#include <string_view>
-
-namespace ada::idna {
-
-enum direction : uint8_t {
-  NONE,
-  BN,
-  CS,
-  ES,
-  ON,
-  EN,
-  L,
-  R,
-  NSM,
-  AL,
-  AN,
-  ET,
-  WS,
-  RLO,
-  LRO,
-  PDF,
-  RLE,
-  RLI,
-  FSI,
-  PDI,
-  LRI,
-  B,
-  S,
-  LRE
-};
-
-struct directions {
-  uint32_t start_code;
-  uint32_t final_code;
-  direction direct;
-};
-
-static directions dir_table[] = {
-    {0x0, 0x8, direction::BN},          {0x9, 0x9, direction::S},
-    {0xa, 0xa, direction::B},           {0xb, 0xb, direction::S},
-    {0xc, 0xc, direction::WS},          {0xd, 0xd, direction::B},
-    {0xe, 0x1b, direction::BN},         {0x1c, 0x1e, direction::B},
-    {0x1f, 0x1f, direction::S},         {0x20, 0x20, direction::WS},
-    {0x21, 0x22, direction::ON},        {0x23, 0x25, direction::ET},
-    {0x26, 0x2a, direction::ON},        {0x2b, 0x2b, direction::ES},
-    {0x2c, 0x2c, direction::CS},        {0x2d, 0x2d, direction::ES},
-    {0x2e, 0x2f, direction::CS},        {0x30, 0x39, direction::EN},
-    {0x3a, 0x3a, direction::CS},        {0x3b, 0x40, direction::ON},
-    {0x41, 0x5a, direction::L},         {0x5b, 0x60, direction::ON},
-    {0x61, 0x7a, direction::L},         {0x7b, 0x7e, direction::ON},
-    {0x7f, 0x84, direction::BN},        {0x85, 0x85, direction::B},
-    {0x86, 0x9f, direction::BN},        {0xa0, 0xa0, direction::CS},
-    {0xa1, 0xa1, direction::ON},        {0xa2, 0xa5, direction::ET},
-    {0xa6, 0xa9, direction::ON},        {0xaa, 0xaa, direction::L},
-    {0xab, 0xac, direction::ON},        {0xad, 0xad, direction::BN},
-    {0xae, 0xaf, direction::ON},        {0xb0, 0xb1, direction::ET},
-    {0xb2, 0xb3, direction::EN},        {0xb4, 0xb4, direction::ON},
-    {0xb5, 0xb5, direction::L},         {0xb6, 0xb8, direction::ON},
-    {0xb9, 0xb9, direction::EN},        {0xba, 0xba, direction::L},
-    {0xbb, 0xbf, direction::ON},        {0xc0, 0xd6, direction::L},
-    {0xd7, 0xd7, direction::ON},        {0xd8, 0xf6, direction::L},
-    {0xf7, 0xf7, direction::ON},        {0xf8, 0x2b8, direction::L},
-    {0x2b9, 0x2ba, direction::ON},      {0x2bb, 0x2c1, direction::L},
-    {0x2c2, 0x2cf, direction::ON},      {0x2d0, 0x2d1, direction::L},
-    {0x2d2, 0x2df, direction::ON},      {0x2e0, 0x2e4, direction::L},
-    {0x2e5, 0x2ed, direction::ON},      {0x2ee, 0x2ee, direction::L},
-    {0x2ef, 0x2ff, direction::ON},      {0x300, 0x36f, direction::NSM},
-    {0x370, 0x373, direction::L},       {0x374, 0x375, direction::ON},
-    {0x376, 0x377, direction::L},       {0x37a, 0x37d, direction::L},
-    {0x37e, 0x37e, direction::ON},      {0x37f, 0x37f, direction::L},
-    {0x384, 0x385, direction::ON},      {0x386, 0x386, direction::L},
-    {0x387, 0x387, direction::ON},      {0x388, 0x38a, direction::L},
-    {0x38c, 0x38c, direction::L},       {0x38e, 0x3a1, direction::L},
-    {0x3a3, 0x3f5, direction::L},       {0x3f6, 0x3f6, direction::ON},
-    {0x3f7, 0x482, direction::L},       {0x483, 0x489, direction::NSM},
-    {0x48a, 0x52f, direction::L},       {0x531, 0x556, direction::L},
-    {0x559, 0x589, direction::L},       {0x58a, 0x58a, direction::ON},
-    {0x58d, 0x58e, direction::ON},      {0x58f, 0x58f, direction::ET},
-    {0x591, 0x5bd, direction::NSM},     {0x5be, 0x5be, direction::R},
-    {0x5bf, 0x5bf, direction::NSM},     {0x5c0, 0x5c0, direction::R},
-    {0x5c1, 0x5c2, direction::NSM},     {0x5c3, 0x5c3, direction::R},
-    {0x5c4, 0x5c5, direction::NSM},     {0x5c6, 0x5c6, direction::R},
-    {0x5c7, 0x5c7, direction::NSM},     {0x5d0, 0x5ea, direction::R},
-    {0x5ef, 0x5f4, direction::R},       {0x600, 0x605, direction::AN},
-    {0x606, 0x607, direction::ON},      {0x608, 0x608, direction::AL},
-    {0x609, 0x60a, direction::ET},      {0x60b, 0x60b, direction::AL},
-    {0x60c, 0x60c, direction::CS},      {0x60d, 0x60d, direction::AL},
-    {0x60e, 0x60f, direction::ON},      {0x610, 0x61a, direction::NSM},
-    {0x61b, 0x61c, direction::AL},      {0x61e, 0x64a, direction::AL},
-    {0x64b, 0x65f, direction::NSM},     {0x660, 0x669, direction::AN},
-    {0x66a, 0x66a, direction::ET},      {0x66b, 0x66c, direction::AN},
-    {0x66d, 0x66f, direction::AL},      {0x670, 0x670, direction::NSM},
-    {0x671, 0x6d5, direction::AL},      {0x6d6, 0x6dc, direction::NSM},
-    {0x6dd, 0x6dd, direction::AN},      {0x6de, 0x6de, direction::ON},
-    {0x6df, 0x6e4, direction::NSM},     {0x6e5, 0x6e6, direction::AL},
-    {0x6e7, 0x6e8, direction::NSM},     {0x6e9, 0x6e9, direction::ON},
-    {0x6ea, 0x6ed, direction::NSM},     {0x6ee, 0x6ef, direction::AL},
-    {0x6f0, 0x6f9, direction::EN},      {0x6fa, 0x70d, direction::AL},
-    {0x70f, 0x710, direction::AL},      {0x711, 0x711, direction::NSM},
-    {0x712, 0x72f, direction::AL},      {0x730, 0x74a, direction::NSM},
-    {0x74d, 0x7a5, direction::AL},      {0x7a6, 0x7b0, direction::NSM},
-    {0x7b1, 0x7b1, direction::AL},      {0x7c0, 0x7ea, direction::R},
-    {0x7eb, 0x7f3, direction::NSM},     {0x7f4, 0x7f5, direction::R},
-    {0x7f6, 0x7f9, direction::ON},      {0x7fa, 0x7fa, direction::R},
-    {0x7fd, 0x7fd, direction::NSM},     {0x7fe, 0x815, direction::R},
-    {0x816, 0x819, direction::NSM},     {0x81a, 0x81a, direction::R},
-    {0x81b, 0x823, direction::NSM},     {0x824, 0x824, direction::R},
-    {0x825, 0x827, direction::NSM},     {0x828, 0x828, direction::R},
-    {0x829, 0x82d, direction::NSM},     {0x830, 0x83e, direction::R},
-    {0x840, 0x858, direction::R},       {0x859, 0x85b, direction::NSM},
-    {0x85e, 0x85e, direction::R},       {0x860, 0x86a, direction::AL},
-    {0x8a0, 0x8b4, direction::AL},      {0x8b6, 0x8c7, direction::AL},
-    {0x8d3, 0x8e1, direction::NSM},     {0x8e2, 0x8e2, direction::AN},
-    {0x8e3, 0x902, direction::NSM},     {0x903, 0x939, direction::L},
-    {0x93a, 0x93a, direction::NSM},     {0x93b, 0x93b, direction::L},
-    {0x93c, 0x93c, direction::NSM},     {0x93d, 0x940, direction::L},
-    {0x941, 0x948, direction::NSM},     {0x949, 0x94c, direction::L},
-    {0x94d, 0x94d, direction::NSM},     {0x94e, 0x950, direction::L},
-    {0x951, 0x957, direction::NSM},     {0x958, 0x961, direction::L},
-    {0x962, 0x963, direction::NSM},     {0x964, 0x980, direction::L},
-    {0x981, 0x981, direction::NSM},     {0x982, 0x983, direction::L},
-    {0x985, 0x98c, direction::L},       {0x98f, 0x990, direction::L},
-    {0x993, 0x9a8, direction::L},       {0x9aa, 0x9b0, direction::L},
-    {0x9b2, 0x9b2, direction::L},       {0x9b6, 0x9b9, direction::L},
-    {0x9bc, 0x9bc, direction::NSM},     {0x9bd, 0x9c0, direction::L},
-    {0x9c1, 0x9c4, direction::NSM},     {0x9c7, 0x9c8, direction::L},
-    {0x9cb, 0x9cc, direction::L},       {0x9cd, 0x9cd, direction::NSM},
-    {0x9ce, 0x9ce, direction::L},       {0x9d7, 0x9d7, direction::L},
-    {0x9dc, 0x9dd, direction::L},       {0x9df, 0x9e1, direction::L},
-    {0x9e2, 0x9e3, direction::NSM},     {0x9e6, 0x9f1, direction::L},
-    {0x9f2, 0x9f3, direction::ET},      {0x9f4, 0x9fa, direction::L},
-    {0x9fb, 0x9fb, direction::ET},      {0x9fc, 0x9fd, direction::L},
-    {0x9fe, 0x9fe, direction::NSM},     {0xa01, 0xa02, direction::NSM},
-    {0xa03, 0xa03, direction::L},       {0xa05, 0xa0a, direction::L},
-    {0xa0f, 0xa10, direction::L},       {0xa13, 0xa28, direction::L},
-    {0xa2a, 0xa30, direction::L},       {0xa32, 0xa33, direction::L},
-    {0xa35, 0xa36, direction::L},       {0xa38, 0xa39, direction::L},
-    {0xa3c, 0xa3c, direction::NSM},     {0xa3e, 0xa40, direction::L},
-    {0xa41, 0xa42, direction::NSM},     {0xa47, 0xa48, direction::NSM},
-    {0xa4b, 0xa4d, direction::NSM},     {0xa51, 0xa51, direction::NSM},
-    {0xa59, 0xa5c, direction::L},       {0xa5e, 0xa5e, direction::L},
-    {0xa66, 0xa6f, direction::L},       {0xa70, 0xa71, direction::NSM},
-    {0xa72, 0xa74, direction::L},       {0xa75, 0xa75, direction::NSM},
-    {0xa76, 0xa76, direction::L},       {0xa81, 0xa82, direction::NSM},
-    {0xa83, 0xa83, direction::L},       {0xa85, 0xa8d, direction::L},
-    {0xa8f, 0xa91, direction::L},       {0xa93, 0xaa8, direction::L},
-    {0xaaa, 0xab0, direction::L},       {0xab2, 0xab3, direction::L},
-    {0xab5, 0xab9, direction::L},       {0xabc, 0xabc, direction::NSM},
-    {0xabd, 0xac0, direction::L},       {0xac1, 0xac5, direction::NSM},
-    {0xac7, 0xac8, direction::NSM},     {0xac9, 0xac9, direction::L},
-    {0xacb, 0xacc, direction::L},       {0xacd, 0xacd, direction::NSM},
-    {0xad0, 0xad0, direction::L},       {0xae0, 0xae1, direction::L},
-    {0xae2, 0xae3, direction::NSM},     {0xae6, 0xaf0, direction::L},
-    {0xaf1, 0xaf1, direction::ET},      {0xaf9, 0xaf9, direction::L},
-    {0xafa, 0xaff, direction::NSM},     {0xb01, 0xb01, direction::NSM},
-    {0xb02, 0xb03, direction::L},       {0xb05, 0xb0c, direction::L},
-    {0xb0f, 0xb10, direction::L},       {0xb13, 0xb28, direction::L},
-    {0xb2a, 0xb30, direction::L},       {0xb32, 0xb33, direction::L},
-    {0xb35, 0xb39, direction::L},       {0xb3c, 0xb3c, direction::NSM},
-    {0xb3d, 0xb3e, direction::L},       {0xb3f, 0xb3f, direction::NSM},
-    {0xb40, 0xb40, direction::L},       {0xb41, 0xb44, direction::NSM},
-    {0xb47, 0xb48, direction::L},       {0xb4b, 0xb4c, direction::L},
-    {0xb4d, 0xb4d, direction::NSM},     {0xb55, 0xb56, direction::NSM},
-    {0xb57, 0xb57, direction::L},       {0xb5c, 0xb5d, direction::L},
-    {0xb5f, 0xb61, direction::L},       {0xb62, 0xb63, direction::NSM},
-    {0xb66, 0xb77, direction::L},       {0xb82, 0xb82, direction::NSM},
-    {0xb83, 0xb83, direction::L},       {0xb85, 0xb8a, direction::L},
-    {0xb8e, 0xb90, direction::L},       {0xb92, 0xb95, direction::L},
-    {0xb99, 0xb9a, direction::L},       {0xb9c, 0xb9c, direction::L},
-    {0xb9e, 0xb9f, direction::L},       {0xba3, 0xba4, direction::L},
-    {0xba8, 0xbaa, direction::L},       {0xbae, 0xbb9, direction::L},
-    {0xbbe, 0xbbf, direction::L},       {0xbc0, 0xbc0, direction::NSM},
-    {0xbc1, 0xbc2, direction::L},       {0xbc6, 0xbc8, direction::L},
-    {0xbca, 0xbcc, direction::L},       {0xbcd, 0xbcd, direction::NSM},
-    {0xbd0, 0xbd0, direction::L},       {0xbd7, 0xbd7, direction::L},
-    {0xbe6, 0xbf2, direction::L},       {0xbf3, 0xbf8, direction::ON},
-    {0xbf9, 0xbf9, direction::ET},      {0xbfa, 0xbfa, direction::ON},
-    {0xc00, 0xc00, direction::NSM},     {0xc01, 0xc03, direction::L},
-    {0xc04, 0xc04, direction::NSM},     {0xc05, 0xc0c, direction::L},
-    {0xc0e, 0xc10, direction::L},       {0xc12, 0xc28, direction::L},
-    {0xc2a, 0xc39, direction::L},       {0xc3d, 0xc3d, direction::L},
-    {0xc3e, 0xc40, direction::NSM},     {0xc41, 0xc44, direction::L},
-    {0xc46, 0xc48, direction::NSM},     {0xc4a, 0xc4d, direction::NSM},
-    {0xc55, 0xc56, direction::NSM},     {0xc58, 0xc5a, direction::L},
-    {0xc60, 0xc61, direction::L},       {0xc62, 0xc63, direction::NSM},
-    {0xc66, 0xc6f, direction::L},       {0xc77, 0xc77, direction::L},
-    {0xc78, 0xc7e, direction::ON},      {0xc7f, 0xc80, direction::L},
-    {0xc81, 0xc81, direction::NSM},     {0xc82, 0xc8c, direction::L},
-    {0xc8e, 0xc90, direction::L},       {0xc92, 0xca8, direction::L},
-    {0xcaa, 0xcb3, direction::L},       {0xcb5, 0xcb9, direction::L},
-    {0xcbc, 0xcbc, direction::NSM},     {0xcbd, 0xcc4, direction::L},
-    {0xcc6, 0xcc8, direction::L},       {0xcca, 0xccb, direction::L},
-    {0xccc, 0xccd, direction::NSM},     {0xcd5, 0xcd6, direction::L},
-    {0xcde, 0xcde, direction::L},       {0xce0, 0xce1, direction::L},
-    {0xce2, 0xce3, direction::NSM},     {0xce6, 0xcef, direction::L},
-    {0xcf1, 0xcf2, direction::L},       {0xd00, 0xd01, direction::NSM},
-    {0xd02, 0xd0c, direction::L},       {0xd0e, 0xd10, direction::L},
-    {0xd12, 0xd3a, direction::L},       {0xd3b, 0xd3c, direction::NSM},
-    {0xd3d, 0xd40, direction::L},       {0xd41, 0xd44, direction::NSM},
-    {0xd46, 0xd48, direction::L},       {0xd4a, 0xd4c, direction::L},
-    {0xd4d, 0xd4d, direction::NSM},     {0xd4e, 0xd4f, direction::L},
-    {0xd54, 0xd61, direction::L},       {0xd62, 0xd63, direction::NSM},
-    {0xd66, 0xd7f, direction::L},       {0xd81, 0xd81, direction::NSM},
-    {0xd82, 0xd83, direction::L},       {0xd85, 0xd96, direction::L},
-    {0xd9a, 0xdb1, direction::L},       {0xdb3, 0xdbb, direction::L},
-    {0xdbd, 0xdbd, direction::L},       {0xdc0, 0xdc6, direction::L},
-    {0xdca, 0xdca, direction::NSM},     {0xdcf, 0xdd1, direction::L},
-    {0xdd2, 0xdd4, direction::NSM},     {0xdd6, 0xdd6, direction::NSM},
-    {0xdd8, 0xddf, direction::L},       {0xde6, 0xdef, direction::L},
-    {0xdf2, 0xdf4, direction::L},       {0xe01, 0xe30, direction::L},
-    {0xe31, 0xe31, direction::NSM},     {0xe32, 0xe33, direction::L},
-    {0xe34, 0xe3a, direction::NSM},     {0xe3f, 0xe3f, direction::ET},
-    {0xe40, 0xe46, direction::L},       {0xe47, 0xe4e, direction::NSM},
-    {0xe4f, 0xe5b, direction::L},       {0xe81, 0xe82, direction::L},
-    {0xe84, 0xe84, direction::L},       {0xe86, 0xe8a, direction::L},
-    {0xe8c, 0xea3, direction::L},       {0xea5, 0xea5, direction::L},
-    {0xea7, 0xeb0, direction::L},       {0xeb1, 0xeb1, direction::NSM},
-    {0xeb2, 0xeb3, direction::L},       {0xeb4, 0xebc, direction::NSM},
-    {0xebd, 0xebd, direction::L},       {0xec0, 0xec4, direction::L},
-    {0xec6, 0xec6, direction::L},       {0xec8, 0xecd, direction::NSM},
-    {0xed0, 0xed9, direction::L},       {0xedc, 0xedf, direction::L},
-    {0xf00, 0xf17, direction::L},       {0xf18, 0xf19, direction::NSM},
-    {0xf1a, 0xf34, direction::L},       {0xf35, 0xf35, direction::NSM},
-    {0xf36, 0xf36, direction::L},       {0xf37, 0xf37, direction::NSM},
-    {0xf38, 0xf38, direction::L},       {0xf39, 0xf39, direction::NSM},
-    {0xf3a, 0xf3d, direction::ON},      {0xf3e, 0xf47, direction::L},
-    {0xf49, 0xf6c, direction::L},       {0xf71, 0xf7e, direction::NSM},
-    {0xf7f, 0xf7f, direction::L},       {0xf80, 0xf84, direction::NSM},
-    {0xf85, 0xf85, direction::L},       {0xf86, 0xf87, direction::NSM},
-    {0xf88, 0xf8c, direction::L},       {0xf8d, 0xf97, direction::NSM},
-    {0xf99, 0xfbc, direction::NSM},     {0xfbe, 0xfc5, direction::L},
-    {0xfc6, 0xfc6, direction::NSM},     {0xfc7, 0xfcc, direction::L},
-    {0xfce, 0xfda, direction::L},       {0x1000, 0x102c, direction::L},
-    {0x102d, 0x1030, direction::NSM},   {0x1031, 0x1031, direction::L},
-    {0x1032, 0x1037, direction::NSM},   {0x1038, 0x1038, direction::L},
-    {0x1039, 0x103a, direction::NSM},   {0x103b, 0x103c, direction::L},
-    {0x103d, 0x103e, direction::NSM},   {0x103f, 0x1057, direction::L},
-    {0x1058, 0x1059, direction::NSM},   {0x105a, 0x105d, direction::L},
-    {0x105e, 0x1060, direction::NSM},   {0x1061, 0x1070, direction::L},
-    {0x1071, 0x1074, direction::NSM},   {0x1075, 0x1081, direction::L},
-    {0x1082, 0x1082, direction::NSM},   {0x1083, 0x1084, direction::L},
-    {0x1085, 0x1086, direction::NSM},   {0x1087, 0x108c, direction::L},
-    {0x108d, 0x108d, direction::NSM},   {0x108e, 0x109c, direction::L},
-    {0x109d, 0x109d, direction::NSM},   {0x109e, 0x10c5, direction::L},
-    {0x10c7, 0x10c7, direction::L},     {0x10cd, 0x10cd, direction::L},
-    {0x10d0, 0x1248, direction::L},     {0x124a, 0x124d, direction::L},
-    {0x1250, 0x1256, direction::L},     {0x1258, 0x1258, direction::L},
-    {0x125a, 0x125d, direction::L},     {0x1260, 0x1288, direction::L},
-    {0x128a, 0x128d, direction::L},     {0x1290, 0x12b0, direction::L},
-    {0x12b2, 0x12b5, direction::L},     {0x12b8, 0x12be, direction::L},
-    {0x12c0, 0x12c0, direction::L},     {0x12c2, 0x12c5, direction::L},
-    {0x12c8, 0x12d6, direction::L},     {0x12d8, 0x1310, direction::L},
-    {0x1312, 0x1315, direction::L},     {0x1318, 0x135a, direction::L},
-    {0x135d, 0x135f, direction::NSM},   {0x1360, 0x137c, direction::L},
-    {0x1380, 0x138f, direction::L},     {0x1390, 0x1399, direction::ON},
-    {0x13a0, 0x13f5, direction::L},     {0x13f8, 0x13fd, direction::L},
-    {0x1400, 0x1400, direction::ON},    {0x1401, 0x167f, direction::L},
-    {0x1680, 0x1680, direction::WS},    {0x1681, 0x169a, direction::L},
-    {0x169b, 0x169c, direction::ON},    {0x16a0, 0x16f8, direction::L},
-    {0x1700, 0x170c, direction::L},     {0x170e, 0x1711, direction::L},
-    {0x1712, 0x1714, direction::NSM},   {0x1720, 0x1731, direction::L},
-    {0x1732, 0x1734, direction::NSM},   {0x1735, 0x1736, direction::L},
-    {0x1740, 0x1751, direction::L},     {0x1752, 0x1753, direction::NSM},
-    {0x1760, 0x176c, direction::L},     {0x176e, 0x1770, direction::L},
-    {0x1772, 0x1773, direction::NSM},   {0x1780, 0x17b3, direction::L},
-    {0x17b4, 0x17b5, direction::NSM},   {0x17b6, 0x17b6, direction::L},
-    {0x17b7, 0x17bd, direction::NSM},   {0x17be, 0x17c5, direction::L},
-    {0x17c6, 0x17c6, direction::NSM},   {0x17c7, 0x17c8, direction::L},
-    {0x17c9, 0x17d3, direction::NSM},   {0x17d4, 0x17da, direction::L},
-    {0x17db, 0x17db, direction::ET},    {0x17dc, 0x17dc, direction::L},
-    {0x17dd, 0x17dd, direction::NSM},   {0x17e0, 0x17e9, direction::L},
-    {0x17f0, 0x17f9, direction::ON},    {0x1800, 0x180a, direction::ON},
-    {0x180b, 0x180d, direction::NSM},   {0x180e, 0x180e, direction::BN},
-    {0x1810, 0x1819, direction::L},     {0x1820, 0x1878, direction::L},
-    {0x1880, 0x1884, direction::L},     {0x1885, 0x1886, direction::NSM},
-    {0x1887, 0x18a8, direction::L},     {0x18a9, 0x18a9, direction::NSM},
-    {0x18aa, 0x18aa, direction::L},     {0x18b0, 0x18f5, direction::L},
-    {0x1900, 0x191e, direction::L},     {0x1920, 0x1922, direction::NSM},
-    {0x1923, 0x1926, direction::L},     {0x1927, 0x1928, direction::NSM},
-    {0x1929, 0x192b, direction::L},     {0x1930, 0x1931, direction::L},
-    {0x1932, 0x1932, direction::NSM},   {0x1933, 0x1938, direction::L},
-    {0x1939, 0x193b, direction::NSM},   {0x1940, 0x1940, direction::ON},
-    {0x1944, 0x1945, direction::ON},    {0x1946, 0x196d, direction::L},
-    {0x1970, 0x1974, direction::L},     {0x1980, 0x19ab, direction::L},
-    {0x19b0, 0x19c9, direction::L},     {0x19d0, 0x19da, direction::L},
-    {0x19de, 0x19ff, direction::ON},    {0x1a00, 0x1a16, direction::L},
-    {0x1a17, 0x1a18, direction::NSM},   {0x1a19, 0x1a1a, direction::L},
-    {0x1a1b, 0x1a1b, direction::NSM},   {0x1a1e, 0x1a55, direction::L},
-    {0x1a56, 0x1a56, direction::NSM},   {0x1a57, 0x1a57, direction::L},
-    {0x1a58, 0x1a5e, direction::NSM},   {0x1a60, 0x1a60, direction::NSM},
-    {0x1a61, 0x1a61, direction::L},     {0x1a62, 0x1a62, direction::NSM},
-    {0x1a63, 0x1a64, direction::L},     {0x1a65, 0x1a6c, direction::NSM},
-    {0x1a6d, 0x1a72, direction::L},     {0x1a73, 0x1a7c, direction::NSM},
-    {0x1a7f, 0x1a7f, direction::NSM},   {0x1a80, 0x1a89, direction::L},
-    {0x1a90, 0x1a99, direction::L},     {0x1aa0, 0x1aad, direction::L},
-    {0x1ab0, 0x1ac0, direction::NSM},   {0x1b00, 0x1b03, direction::NSM},
-    {0x1b04, 0x1b33, direction::L},     {0x1b34, 0x1b34, direction::NSM},
-    {0x1b35, 0x1b35, direction::L},     {0x1b36, 0x1b3a, direction::NSM},
-    {0x1b3b, 0x1b3b, direction::L},     {0x1b3c, 0x1b3c, direction::NSM},
-    {0x1b3d, 0x1b41, direction::L},     {0x1b42, 0x1b42, direction::NSM},
-    {0x1b43, 0x1b4b, direction::L},     {0x1b50, 0x1b6a, direction::L},
-    {0x1b6b, 0x1b73, direction::NSM},   {0x1b74, 0x1b7c, direction::L},
-    {0x1b80, 0x1b81, direction::NSM},   {0x1b82, 0x1ba1, direction::L},
-    {0x1ba2, 0x1ba5, direction::NSM},   {0x1ba6, 0x1ba7, direction::L},
-    {0x1ba8, 0x1ba9, direction::NSM},   {0x1baa, 0x1baa, direction::L},
-    {0x1bab, 0x1bad, direction::NSM},   {0x1bae, 0x1be5, direction::L},
-    {0x1be6, 0x1be6, direction::NSM},   {0x1be7, 0x1be7, direction::L},
-    {0x1be8, 0x1be9, direction::NSM},   {0x1bea, 0x1bec, direction::L},
-    {0x1bed, 0x1bed, direction::NSM},   {0x1bee, 0x1bee, direction::L},
-    {0x1bef, 0x1bf1, direction::NSM},   {0x1bf2, 0x1bf3, direction::L},
-    {0x1bfc, 0x1c2b, direction::L},     {0x1c2c, 0x1c33, direction::NSM},
-    {0x1c34, 0x1c35, direction::L},     {0x1c36, 0x1c37, direction::NSM},
-    {0x1c3b, 0x1c49, direction::L},     {0x1c4d, 0x1c88, direction::L},
-    {0x1c90, 0x1cba, direction::L},     {0x1cbd, 0x1cc7, direction::L},
-    {0x1cd0, 0x1cd2, direction::NSM},   {0x1cd3, 0x1cd3, direction::L},
-    {0x1cd4, 0x1ce0, direction::NSM},   {0x1ce1, 0x1ce1, direction::L},
-    {0x1ce2, 0x1ce8, direction::NSM},   {0x1ce9, 0x1cec, direction::L},
-    {0x1ced, 0x1ced, direction::NSM},   {0x1cee, 0x1cf3, direction::L},
-    {0x1cf4, 0x1cf4, direction::NSM},   {0x1cf5, 0x1cf7, direction::L},
-    {0x1cf8, 0x1cf9, direction::NSM},   {0x1cfa, 0x1cfa, direction::L},
-    {0x1d00, 0x1dbf, direction::L},     {0x1dc0, 0x1df9, direction::NSM},
-    {0x1dfb, 0x1dff, direction::NSM},   {0x1e00, 0x1f15, direction::L},
-    {0x1f18, 0x1f1d, direction::L},     {0x1f20, 0x1f45, direction::L},
-    {0x1f48, 0x1f4d, direction::L},     {0x1f50, 0x1f57, direction::L},
-    {0x1f59, 0x1f59, direction::L},     {0x1f5b, 0x1f5b, direction::L},
-    {0x1f5d, 0x1f5d, direction::L},     {0x1f5f, 0x1f7d, direction::L},
-    {0x1f80, 0x1fb4, direction::L},     {0x1fb6, 0x1fbc, direction::L},
-    {0x1fbd, 0x1fbd, direction::ON},    {0x1fbe, 0x1fbe, direction::L},
-    {0x1fbf, 0x1fc1, direction::ON},    {0x1fc2, 0x1fc4, direction::L},
-    {0x1fc6, 0x1fcc, direction::L},     {0x1fcd, 0x1fcf, direction::ON},
-    {0x1fd0, 0x1fd3, direction::L},     {0x1fd6, 0x1fdb, direction::L},
-    {0x1fdd, 0x1fdf, direction::ON},    {0x1fe0, 0x1fec, direction::L},
-    {0x1fed, 0x1fef, direction::ON},    {0x1ff2, 0x1ff4, direction::L},
-    {0x1ff6, 0x1ffc, direction::L},     {0x1ffd, 0x1ffe, direction::ON},
-    {0x2000, 0x200a, direction::WS},    {0x200b, 0x200d, direction::BN},
-    {0x200e, 0x200e, direction::L},     {0x200f, 0x200f, direction::R},
-    {0x2010, 0x2027, direction::ON},    {0x2028, 0x2028, direction::WS},
-    {0x2029, 0x2029, direction::B},     {0x202a, 0x202a, direction::LRE},
-    {0x202b, 0x202b, direction::RLE},   {0x202c, 0x202c, direction::PDF},
-    {0x202d, 0x202d, direction::LRO},   {0x202e, 0x202e, direction::RLO},
-    {0x202f, 0x202f, direction::CS},    {0x2030, 0x2034, direction::ET},
-    {0x2035, 0x2043, direction::ON},    {0x2044, 0x2044, direction::CS},
-    {0x2045, 0x205e, direction::ON},    {0x205f, 0x205f, direction::WS},
-    {0x2060, 0x2064, direction::BN},    {0x2066, 0x2066, direction::LRI},
-    {0x2067, 0x2067, direction::RLI},   {0x2068, 0x2068, direction::FSI},
-    {0x2069, 0x2069, direction::PDI},   {0x206a, 0x206f, direction::BN},
-    {0x2070, 0x2070, direction::EN},    {0x2071, 0x2071, direction::L},
-    {0x2074, 0x2079, direction::EN},    {0x207a, 0x207b, direction::ES},
-    {0x207c, 0x207e, direction::ON},    {0x207f, 0x207f, direction::L},
-    {0x2080, 0x2089, direction::EN},    {0x208a, 0x208b, direction::ES},
-    {0x208c, 0x208e, direction::ON},    {0x2090, 0x209c, direction::L},
-    {0x20a0, 0x20bf, direction::ET},    {0x20d0, 0x20f0, direction::NSM},
-    {0x2100, 0x2101, direction::ON},    {0x2102, 0x2102, direction::L},
-    {0x2103, 0x2106, direction::ON},    {0x2107, 0x2107, direction::L},
-    {0x2108, 0x2109, direction::ON},    {0x210a, 0x2113, direction::L},
-    {0x2114, 0x2114, direction::ON},    {0x2115, 0x2115, direction::L},
-    {0x2116, 0x2118, direction::ON},    {0x2119, 0x211d, direction::L},
-    {0x211e, 0x2123, direction::ON},    {0x2124, 0x2124, direction::L},
-    {0x2125, 0x2125, direction::ON},    {0x2126, 0x2126, direction::L},
-    {0x2127, 0x2127, direction::ON},    {0x2128, 0x2128, direction::L},
-    {0x2129, 0x2129, direction::ON},    {0x212a, 0x212d, direction::L},
-    {0x212e, 0x212e, direction::ET},    {0x212f, 0x2139, direction::L},
-    {0x213a, 0x213b, direction::ON},    {0x213c, 0x213f, direction::L},
-    {0x2140, 0x2144, direction::ON},    {0x2145, 0x2149, direction::L},
-    {0x214a, 0x214d, direction::ON},    {0x214e, 0x214f, direction::L},
-    {0x2150, 0x215f, direction::ON},    {0x2160, 0x2188, direction::L},
-    {0x2189, 0x218b, direction::ON},    {0x2190, 0x2211, direction::ON},
-    {0x2212, 0x2212, direction::ES},    {0x2213, 0x2213, direction::ET},
-    {0x2214, 0x2335, direction::ON},    {0x2336, 0x237a, direction::L},
-    {0x237b, 0x2394, direction::ON},    {0x2395, 0x2395, direction::L},
-    {0x2396, 0x2426, direction::ON},    {0x2440, 0x244a, direction::ON},
-    {0x2460, 0x2487, direction::ON},    {0x2488, 0x249b, direction::EN},
-    {0x249c, 0x24e9, direction::L},     {0x24ea, 0x26ab, direction::ON},
-    {0x26ac, 0x26ac, direction::L},     {0x26ad, 0x27ff, direction::ON},
-    {0x2800, 0x28ff, direction::L},     {0x2900, 0x2b73, direction::ON},
-    {0x2b76, 0x2b95, direction::ON},    {0x2b97, 0x2bff, direction::ON},
-    {0x2c00, 0x2c2e, direction::L},     {0x2c30, 0x2c5e, direction::L},
-    {0x2c60, 0x2ce4, direction::L},     {0x2ce5, 0x2cea, direction::ON},
-    {0x2ceb, 0x2cee, direction::L},     {0x2cef, 0x2cf1, direction::NSM},
-    {0x2cf2, 0x2cf3, direction::L},     {0x2cf9, 0x2cff, direction::ON},
-    {0x2d00, 0x2d25, direction::L},     {0x2d27, 0x2d27, direction::L},
-    {0x2d2d, 0x2d2d, direction::L},     {0x2d30, 0x2d67, direction::L},
-    {0x2d6f, 0x2d70, direction::L},     {0x2d7f, 0x2d7f, direction::NSM},
-    {0x2d80, 0x2d96, direction::L},     {0x2da0, 0x2da6, direction::L},
-    {0x2da8, 0x2dae, direction::L},     {0x2db0, 0x2db6, direction::L},
-    {0x2db8, 0x2dbe, direction::L},     {0x2dc0, 0x2dc6, direction::L},
-    {0x2dc8, 0x2dce, direction::L},     {0x2dd0, 0x2dd6, direction::L},
-    {0x2dd8, 0x2dde, direction::L},     {0x2de0, 0x2dff, direction::NSM},
-    {0x2e00, 0x2e52, direction::ON},    {0x2e80, 0x2e99, direction::ON},
-    {0x2e9b, 0x2ef3, direction::ON},    {0x2f00, 0x2fd5, direction::ON},
-    {0x2ff0, 0x2ffb, direction::ON},    {0x3000, 0x3000, direction::WS},
-    {0x3001, 0x3004, direction::ON},    {0x3005, 0x3007, direction::L},
-    {0x3008, 0x3020, direction::ON},    {0x3021, 0x3029, direction::L},
-    {0x302a, 0x302d, direction::NSM},   {0x302e, 0x302f, direction::L},
-    {0x3030, 0x3030, direction::ON},    {0x3031, 0x3035, direction::L},
-    {0x3036, 0x3037, direction::ON},    {0x3038, 0x303c, direction::L},
-    {0x303d, 0x303f, direction::ON},    {0x3041, 0x3096, direction::L},
-    {0x3099, 0x309a, direction::NSM},   {0x309b, 0x309c, direction::ON},
-    {0x309d, 0x309f, direction::L},     {0x30a0, 0x30a0, direction::ON},
-    {0x30a1, 0x30fa, direction::L},     {0x30fb, 0x30fb, direction::ON},
-    {0x30fc, 0x30ff, direction::L},     {0x3105, 0x312f, direction::L},
-    {0x3131, 0x318e, direction::L},     {0x3190, 0x31bf, direction::L},
-    {0x31c0, 0x31e3, direction::ON},    {0x31f0, 0x321c, direction::L},
-    {0x321d, 0x321e, direction::ON},    {0x3220, 0x324f, direction::L},
-    {0x3250, 0x325f, direction::ON},    {0x3260, 0x327b, direction::L},
-    {0x327c, 0x327e, direction::ON},    {0x327f, 0x32b0, direction::L},
-    {0x32b1, 0x32bf, direction::ON},    {0x32c0, 0x32cb, direction::L},
-    {0x32cc, 0x32cf, direction::ON},    {0x32d0, 0x3376, direction::L},
-    {0x3377, 0x337a, direction::ON},    {0x337b, 0x33dd, direction::L},
-    {0x33de, 0x33df, direction::ON},    {0x33e0, 0x33fe, direction::L},
-    {0x33ff, 0x33ff, direction::ON},    {0x3400, 0x4dbf, direction::L},
-    {0x4dc0, 0x4dff, direction::ON},    {0x4e00, 0x9ffc, direction::L},
-    {0xa000, 0xa48c, direction::L},     {0xa490, 0xa4c6, direction::ON},
-    {0xa4d0, 0xa60c, direction::L},     {0xa60d, 0xa60f, direction::ON},
-    {0xa610, 0xa62b, direction::L},     {0xa640, 0xa66e, direction::L},
-    {0xa66f, 0xa672, direction::NSM},   {0xa673, 0xa673, direction::ON},
-    {0xa674, 0xa67d, direction::NSM},   {0xa67e, 0xa67f, direction::ON},
-    {0xa680, 0xa69d, direction::L},     {0xa69e, 0xa69f, direction::NSM},
-    {0xa6a0, 0xa6ef, direction::L},     {0xa6f0, 0xa6f1, direction::NSM},
-    {0xa6f2, 0xa6f7, direction::L},     {0xa700, 0xa721, direction::ON},
-    {0xa722, 0xa787, direction::L},     {0xa788, 0xa788, direction::ON},
-    {0xa789, 0xa7bf, direction::L},     {0xa7c2, 0xa7ca, direction::L},
-    {0xa7f5, 0xa801, direction::L},     {0xa802, 0xa802, direction::NSM},
-    {0xa803, 0xa805, direction::L},     {0xa806, 0xa806, direction::NSM},
-    {0xa807, 0xa80a, direction::L},     {0xa80b, 0xa80b, direction::NSM},
-    {0xa80c, 0xa824, direction::L},     {0xa825, 0xa826, direction::NSM},
-    {0xa827, 0xa827, direction::L},     {0xa828, 0xa82b, direction::ON},
-    {0xa82c, 0xa82c, direction::NSM},   {0xa830, 0xa837, direction::L},
-    {0xa838, 0xa839, direction::ET},    {0xa840, 0xa873, direction::L},
-    {0xa874, 0xa877, direction::ON},    {0xa880, 0xa8c3, direction::L},
-    {0xa8c4, 0xa8c5, direction::NSM},   {0xa8ce, 0xa8d9, direction::L},
-    {0xa8e0, 0xa8f1, direction::NSM},   {0xa8f2, 0xa8fe, direction::L},
-    {0xa8ff, 0xa8ff, direction::NSM},   {0xa900, 0xa925, direction::L},
-    {0xa926, 0xa92d, direction::NSM},   {0xa92e, 0xa946, direction::L},
-    {0xa947, 0xa951, direction::NSM},   {0xa952, 0xa953, direction::L},
-    {0xa95f, 0xa97c, direction::L},     {0xa980, 0xa982, direction::NSM},
-    {0xa983, 0xa9b2, direction::L},     {0xa9b3, 0xa9b3, direction::NSM},
-    {0xa9b4, 0xa9b5, direction::L},     {0xa9b6, 0xa9b9, direction::NSM},
-    {0xa9ba, 0xa9bb, direction::L},     {0xa9bc, 0xa9bd, direction::NSM},
-    {0xa9be, 0xa9cd, direction::L},     {0xa9cf, 0xa9d9, direction::L},
-    {0xa9de, 0xa9e4, direction::L},     {0xa9e5, 0xa9e5, direction::NSM},
-    {0xa9e6, 0xa9fe, direction::L},     {0xaa00, 0xaa28, direction::L},
-    {0xaa29, 0xaa2e, direction::NSM},   {0xaa2f, 0xaa30, direction::L},
-    {0xaa31, 0xaa32, direction::NSM},   {0xaa33, 0xaa34, direction::L},
-    {0xaa35, 0xaa36, direction::NSM},   {0xaa40, 0xaa42, direction::L},
-    {0xaa43, 0xaa43, direction::NSM},   {0xaa44, 0xaa4b, direction::L},
-    {0xaa4c, 0xaa4c, direction::NSM},   {0xaa4d, 0xaa4d, direction::L},
-    {0xaa50, 0xaa59, direction::L},     {0xaa5c, 0xaa7b, direction::L},
-    {0xaa7c, 0xaa7c, direction::NSM},   {0xaa7d, 0xaaaf, direction::L},
-    {0xaab0, 0xaab0, direction::NSM},   {0xaab1, 0xaab1, direction::L},
-    {0xaab2, 0xaab4, direction::NSM},   {0xaab5, 0xaab6, direction::L},
-    {0xaab7, 0xaab8, direction::NSM},   {0xaab9, 0xaabd, direction::L},
-    {0xaabe, 0xaabf, direction::NSM},   {0xaac0, 0xaac0, direction::L},
-    {0xaac1, 0xaac1, direction::NSM},   {0xaac2, 0xaac2, direction::L},
-    {0xaadb, 0xaaeb, direction::L},     {0xaaec, 0xaaed, direction::NSM},
-    {0xaaee, 0xaaf5, direction::L},     {0xaaf6, 0xaaf6, direction::NSM},
-    {0xab01, 0xab06, direction::L},     {0xab09, 0xab0e, direction::L},
-    {0xab11, 0xab16, direction::L},     {0xab20, 0xab26, direction::L},
-    {0xab28, 0xab2e, direction::L},     {0xab30, 0xab69, direction::L},
-    {0xab6a, 0xab6b, direction::ON},    {0xab70, 0xabe4, direction::L},
-    {0xabe5, 0xabe5, direction::NSM},   {0xabe6, 0xabe7, direction::L},
-    {0xabe8, 0xabe8, direction::NSM},   {0xabe9, 0xabec, direction::L},
-    {0xabed, 0xabed, direction::NSM},   {0xabf0, 0xabf9, direction::L},
-    {0xac00, 0xd7a3, direction::L},     {0xd7b0, 0xd7c6, direction::L},
-    {0xd7cb, 0xd7fb, direction::L},     {0xd800, 0xfa6d, direction::L},
-    {0xfa70, 0xfad9, direction::L},     {0xfb00, 0xfb06, direction::L},
-    {0xfb13, 0xfb17, direction::L},     {0xfb1d, 0xfb1d, direction::R},
-    {0xfb1e, 0xfb1e, direction::NSM},   {0xfb1f, 0xfb28, direction::R},
-    {0xfb29, 0xfb29, direction::ES},    {0xfb2a, 0xfb36, direction::R},
-    {0xfb38, 0xfb3c, direction::R},     {0xfb3e, 0xfb3e, direction::R},
-    {0xfb40, 0xfb41, direction::R},     {0xfb43, 0xfb44, direction::R},
-    {0xfb46, 0xfb4f, direction::R},     {0xfb50, 0xfbc1, direction::AL},
-    {0xfbd3, 0xfd3d, direction::AL},    {0xfd3e, 0xfd3f, direction::ON},
-    {0xfd50, 0xfd8f, direction::AL},    {0xfd92, 0xfdc7, direction::AL},
-    {0xfdf0, 0xfdfc, direction::AL},    {0xfdfd, 0xfdfd, direction::ON},
-    {0xfe00, 0xfe0f, direction::NSM},   {0xfe10, 0xfe19, direction::ON},
-    {0xfe20, 0xfe2f, direction::NSM},   {0xfe30, 0xfe4f, direction::ON},
-    {0xfe50, 0xfe50, direction::CS},    {0xfe51, 0xfe51, direction::ON},
-    {0xfe52, 0xfe52, direction::CS},    {0xfe54, 0xfe54, direction::ON},
-    {0xfe55, 0xfe55, direction::CS},    {0xfe56, 0xfe5e, direction::ON},
-    {0xfe5f, 0xfe5f, direction::ET},    {0xfe60, 0xfe61, direction::ON},
-    {0xfe62, 0xfe63, direction::ES},    {0xfe64, 0xfe66, direction::ON},
-    {0xfe68, 0xfe68, direction::ON},    {0xfe69, 0xfe6a, direction::ET},
-    {0xfe6b, 0xfe6b, direction::ON},    {0xfe70, 0xfe74, direction::AL},
-    {0xfe76, 0xfefc, direction::AL},    {0xfeff, 0xfeff, direction::BN},
-    {0xff01, 0xff02, direction::ON},    {0xff03, 0xff05, direction::ET},
-    {0xff06, 0xff0a, direction::ON},    {0xff0b, 0xff0b, direction::ES},
-    {0xff0c, 0xff0c, direction::CS},    {0xff0d, 0xff0d, direction::ES},
-    {0xff0e, 0xff0f, direction::CS},    {0xff10, 0xff19, direction::EN},
-    {0xff1a, 0xff1a, direction::CS},    {0xff1b, 0xff20, direction::ON},
-    {0xff21, 0xff3a, direction::L},     {0xff3b, 0xff40, direction::ON},
-    {0xff41, 0xff5a, direction::L},     {0xff5b, 0xff65, direction::ON},
-    {0xff66, 0xffbe, direction::L},     {0xffc2, 0xffc7, direction::L},
-    {0xffca, 0xffcf, direction::L},     {0xffd2, 0xffd7, direction::L},
-    {0xffda, 0xffdc, direction::L},     {0xffe0, 0xffe1, direction::ET},
-    {0xffe2, 0xffe4, direction::ON},    {0xffe5, 0xffe6, direction::ET},
-    {0xffe8, 0xffee, direction::ON},    {0xfff9, 0xfffd, direction::ON},
-    {0x10000, 0x1000b, direction::L},   {0x1000d, 0x10026, direction::L},
-    {0x10028, 0x1003a, direction::L},   {0x1003c, 0x1003d, direction::L},
-    {0x1003f, 0x1004d, direction::L},   {0x10050, 0x1005d, direction::L},
-    {0x10080, 0x100fa, direction::L},   {0x10100, 0x10100, direction::L},
-    {0x10101, 0x10101, direction::ON},  {0x10102, 0x10102, direction::L},
-    {0x10107, 0x10133, direction::L},   {0x10137, 0x1013f, direction::L},
-    {0x10140, 0x1018c, direction::ON},  {0x1018d, 0x1018e, direction::L},
-    {0x10190, 0x1019c, direction::ON},  {0x101a0, 0x101a0, direction::ON},
-    {0x101d0, 0x101fc, direction::L},   {0x101fd, 0x101fd, direction::NSM},
-    {0x10280, 0x1029c, direction::L},   {0x102a0, 0x102d0, direction::L},
-    {0x102e0, 0x102e0, direction::NSM}, {0x102e1, 0x102fb, direction::EN},
-    {0x10300, 0x10323, direction::L},   {0x1032d, 0x1034a, direction::L},
-    {0x10350, 0x10375, direction::L},   {0x10376, 0x1037a, direction::NSM},
-    {0x10380, 0x1039d, direction::L},   {0x1039f, 0x103c3, direction::L},
-    {0x103c8, 0x103d5, direction::L},   {0x10400, 0x1049d, direction::L},
-    {0x104a0, 0x104a9, direction::L},   {0x104b0, 0x104d3, direction::L},
-    {0x104d8, 0x104fb, direction::L},   {0x10500, 0x10527, direction::L},
-    {0x10530, 0x10563, direction::L},   {0x1056f, 0x1056f, direction::L},
-    {0x10600, 0x10736, direction::L},   {0x10740, 0x10755, direction::L},
-    {0x10760, 0x10767, direction::L},   {0x10800, 0x10805, direction::R},
-    {0x10808, 0x10808, direction::R},   {0x1080a, 0x10835, direction::R},
-    {0x10837, 0x10838, direction::R},   {0x1083c, 0x1083c, direction::R},
-    {0x1083f, 0x10855, direction::R},   {0x10857, 0x1089e, direction::R},
-    {0x108a7, 0x108af, direction::R},   {0x108e0, 0x108f2, direction::R},
-    {0x108f4, 0x108f5, direction::R},   {0x108fb, 0x1091b, direction::R},
-    {0x1091f, 0x1091f, direction::ON},  {0x10920, 0x10939, direction::R},
-    {0x1093f, 0x1093f, direction::R},   {0x10980, 0x109b7, direction::R},
-    {0x109bc, 0x109cf, direction::R},   {0x109d2, 0x10a00, direction::R},
-    {0x10a01, 0x10a03, direction::NSM}, {0x10a05, 0x10a06, direction::NSM},
-    {0x10a0c, 0x10a0f, direction::NSM}, {0x10a10, 0x10a13, direction::R},
-    {0x10a15, 0x10a17, direction::R},   {0x10a19, 0x10a35, direction::R},
-    {0x10a38, 0x10a3a, direction::NSM}, {0x10a3f, 0x10a3f, direction::NSM},
-    {0x10a40, 0x10a48, direction::R},   {0x10a50, 0x10a58, direction::R},
-    {0x10a60, 0x10a9f, direction::R},   {0x10ac0, 0x10ae4, direction::R},
-    {0x10ae5, 0x10ae6, direction::NSM}, {0x10aeb, 0x10af6, direction::R},
-    {0x10b00, 0x10b35, direction::R},   {0x10b39, 0x10b3f, direction::ON},
-    {0x10b40, 0x10b55, direction::R},   {0x10b58, 0x10b72, direction::R},
-    {0x10b78, 0x10b91, direction::R},   {0x10b99, 0x10b9c, direction::R},
-    {0x10ba9, 0x10baf, direction::R},   {0x10c00, 0x10c48, direction::R},
-    {0x10c80, 0x10cb2, direction::R},   {0x10cc0, 0x10cf2, direction::R},
-    {0x10cfa, 0x10cff, direction::R},   {0x10d00, 0x10d23, direction::AL},
-    {0x10d24, 0x10d27, direction::NSM}, {0x10d30, 0x10d39, direction::AN},
-    {0x10e60, 0x10e7e, direction::AN},  {0x10e80, 0x10ea9, direction::R},
-    {0x10eab, 0x10eac, direction::NSM}, {0x10ead, 0x10ead, direction::R},
-    {0x10eb0, 0x10eb1, direction::R},   {0x10f00, 0x10f27, direction::R},
-    {0x10f30, 0x10f45, direction::AL},  {0x10f46, 0x10f50, direction::NSM},
-    {0x10f51, 0x10f59, direction::AL},  {0x10fb0, 0x10fcb, direction::R},
-    {0x10fe0, 0x10ff6, direction::R},   {0x11000, 0x11000, direction::L},
-    {0x11001, 0x11001, direction::NSM}, {0x11002, 0x11037, direction::L},
-    {0x11038, 0x11046, direction::NSM}, {0x11047, 0x1104d, direction::L},
-    {0x11052, 0x11065, direction::ON},  {0x11066, 0x1106f, direction::L},
-    {0x1107f, 0x11081, direction::NSM}, {0x11082, 0x110b2, direction::L},
-    {0x110b3, 0x110b6, direction::NSM}, {0x110b7, 0x110b8, direction::L},
-    {0x110b9, 0x110ba, direction::NSM}, {0x110bb, 0x110c1, direction::L},
-    {0x110cd, 0x110cd, direction::L},   {0x110d0, 0x110e8, direction::L},
-    {0x110f0, 0x110f9, direction::L},   {0x11100, 0x11102, direction::NSM},
-    {0x11103, 0x11126, direction::L},   {0x11127, 0x1112b, direction::NSM},
-    {0x1112c, 0x1112c, direction::L},   {0x1112d, 0x11134, direction::NSM},
-    {0x11136, 0x11147, direction::L},   {0x11150, 0x11172, direction::L},
-    {0x11173, 0x11173, direction::NSM}, {0x11174, 0x11176, direction::L},
-    {0x11180, 0x11181, direction::NSM}, {0x11182, 0x111b5, direction::L},
-    {0x111b6, 0x111be, direction::NSM}, {0x111bf, 0x111c8, direction::L},
-    {0x111c9, 0x111cc, direction::NSM}, {0x111cd, 0x111ce, direction::L},
-    {0x111cf, 0x111cf, direction::NSM}, {0x111d0, 0x111df, direction::L},
-    {0x111e1, 0x111f4, direction::L},   {0x11200, 0x11211, direction::L},
-    {0x11213, 0x1122e, direction::L},   {0x1122f, 0x11231, direction::NSM},
-    {0x11232, 0x11233, direction::L},   {0x11234, 0x11234, direction::NSM},
-    {0x11235, 0x11235, direction::L},   {0x11236, 0x11237, direction::NSM},
-    {0x11238, 0x1123d, direction::L},   {0x1123e, 0x1123e, direction::NSM},
-    {0x11280, 0x11286, direction::L},   {0x11288, 0x11288, direction::L},
-    {0x1128a, 0x1128d, direction::L},   {0x1128f, 0x1129d, direction::L},
-    {0x1129f, 0x112a9, direction::L},   {0x112b0, 0x112de, direction::L},
-    {0x112df, 0x112df, direction::NSM}, {0x112e0, 0x112e2, direction::L},
-    {0x112e3, 0x112ea, direction::NSM}, {0x112f0, 0x112f9, direction::L},
-    {0x11300, 0x11301, direction::NSM}, {0x11302, 0x11303, direction::L},
-    {0x11305, 0x1130c, direction::L},   {0x1130f, 0x11310, direction::L},
-    {0x11313, 0x11328, direction::L},   {0x1132a, 0x11330, direction::L},
-    {0x11332, 0x11333, direction::L},   {0x11335, 0x11339, direction::L},
-    {0x1133b, 0x1133c, direction::NSM}, {0x1133d, 0x1133f, direction::L},
-    {0x11340, 0x11340, direction::NSM}, {0x11341, 0x11344, direction::L},
-    {0x11347, 0x11348, direction::L},   {0x1134b, 0x1134d, direction::L},
-    {0x11350, 0x11350, direction::L},   {0x11357, 0x11357, direction::L},
-    {0x1135d, 0x11363, direction::L},   {0x11366, 0x1136c, direction::NSM},
-    {0x11370, 0x11374, direction::NSM}, {0x11400, 0x11437, direction::L},
-    {0x11438, 0x1143f, direction::NSM}, {0x11440, 0x11441, direction::L},
-    {0x11442, 0x11444, direction::NSM}, {0x11445, 0x11445, direction::L},
-    {0x11446, 0x11446, direction::NSM}, {0x11447, 0x1145b, direction::L},
-    {0x1145d, 0x1145d, direction::L},   {0x1145e, 0x1145e, direction::NSM},
-    {0x1145f, 0x11461, direction::L},   {0x11480, 0x114b2, direction::L},
-    {0x114b3, 0x114b8, direction::NSM}, {0x114b9, 0x114b9, direction::L},
-    {0x114ba, 0x114ba, direction::NSM}, {0x114bb, 0x114be, direction::L},
-    {0x114bf, 0x114c0, direction::NSM}, {0x114c1, 0x114c1, direction::L},
-    {0x114c2, 0x114c3, direction::NSM}, {0x114c4, 0x114c7, direction::L},
-    {0x114d0, 0x114d9, direction::L},   {0x11580, 0x115b1, direction::L},
-    {0x115b2, 0x115b5, direction::NSM}, {0x115b8, 0x115bb, direction::L},
-    {0x115bc, 0x115bd, direction::NSM}, {0x115be, 0x115be, direction::L},
-    {0x115bf, 0x115c0, direction::NSM}, {0x115c1, 0x115db, direction::L},
-    {0x115dc, 0x115dd, direction::NSM}, {0x11600, 0x11632, direction::L},
-    {0x11633, 0x1163a, direction::NSM}, {0x1163b, 0x1163c, direction::L},
-    {0x1163d, 0x1163d, direction::NSM}, {0x1163e, 0x1163e, direction::L},
-    {0x1163f, 0x11640, direction::NSM}, {0x11641, 0x11644, direction::L},
-    {0x11650, 0x11659, direction::L},   {0x11660, 0x1166c, direction::ON},
-    {0x11680, 0x116aa, direction::L},   {0x116ab, 0x116ab, direction::NSM},
-    {0x116ac, 0x116ac, direction::L},   {0x116ad, 0x116ad, direction::NSM},
-    {0x116ae, 0x116af, direction::L},   {0x116b0, 0x116b5, direction::NSM},
-    {0x116b6, 0x116b6, direction::L},   {0x116b7, 0x116b7, direction::NSM},
-    {0x116b8, 0x116b8, direction::L},   {0x116c0, 0x116c9, direction::L},
-    {0x11700, 0x1171a, direction::L},   {0x1171d, 0x1171f, direction::NSM},
-    {0x11720, 0x11721, direction::L},   {0x11722, 0x11725, direction::NSM},
-    {0x11726, 0x11726, direction::L},   {0x11727, 0x1172b, direction::NSM},
-    {0x11730, 0x1173f, direction::L},   {0x11800, 0x1182e, direction::L},
-    {0x1182f, 0x11837, direction::NSM}, {0x11838, 0x11838, direction::L},
-    {0x11839, 0x1183a, direction::NSM}, {0x1183b, 0x1183b, direction::L},
-    {0x118a0, 0x118f2, direction::L},   {0x118ff, 0x11906, direction::L},
-    {0x11909, 0x11909, direction::L},   {0x1190c, 0x11913, direction::L},
-    {0x11915, 0x11916, direction::L},   {0x11918, 0x11935, direction::L},
-    {0x11937, 0x11938, direction::L},   {0x1193b, 0x1193c, direction::NSM},
-    {0x1193d, 0x1193d, direction::L},   {0x1193e, 0x1193e, direction::NSM},
-    {0x1193f, 0x11942, direction::L},   {0x11943, 0x11943, direction::NSM},
-    {0x11944, 0x11946, direction::L},   {0x11950, 0x11959, direction::L},
-    {0x119a0, 0x119a7, direction::L},   {0x119aa, 0x119d3, direction::L},
-    {0x119d4, 0x119d7, direction::NSM}, {0x119da, 0x119db, direction::NSM},
-    {0x119dc, 0x119df, direction::L},   {0x119e0, 0x119e0, direction::NSM},
-    {0x119e1, 0x119e4, direction::L},   {0x11a00, 0x11a00, direction::L},
-    {0x11a01, 0x11a06, direction::NSM}, {0x11a07, 0x11a08, direction::L},
-    {0x11a09, 0x11a0a, direction::NSM}, {0x11a0b, 0x11a32, direction::L},
-    {0x11a33, 0x11a38, direction::NSM}, {0x11a39, 0x11a3a, direction::L},
-    {0x11a3b, 0x11a3e, direction::NSM}, {0x11a3f, 0x11a46, direction::L},
-    {0x11a47, 0x11a47, direction::NSM}, {0x11a50, 0x11a50, direction::L},
-    {0x11a51, 0x11a56, direction::NSM}, {0x11a57, 0x11a58, direction::L},
-    {0x11a59, 0x11a5b, direction::NSM}, {0x11a5c, 0x11a89, direction::L},
-    {0x11a8a, 0x11a96, direction::NSM}, {0x11a97, 0x11a97, direction::L},
-    {0x11a98, 0x11a99, direction::NSM}, {0x11a9a, 0x11aa2, direction::L},
-    {0x11ac0, 0x11af8, direction::L},   {0x11c00, 0x11c08, direction::L},
-    {0x11c0a, 0x11c2f, direction::L},   {0x11c30, 0x11c36, direction::NSM},
-    {0x11c38, 0x11c3d, direction::NSM}, {0x11c3e, 0x11c45, direction::L},
-    {0x11c50, 0x11c6c, direction::L},   {0x11c70, 0x11c8f, direction::L},
-    {0x11c92, 0x11ca7, direction::NSM}, {0x11ca9, 0x11ca9, direction::L},
-    {0x11caa, 0x11cb0, direction::NSM}, {0x11cb1, 0x11cb1, direction::L},
-    {0x11cb2, 0x11cb3, direction::NSM}, {0x11cb4, 0x11cb4, direction::L},
-    {0x11cb5, 0x11cb6, direction::NSM}, {0x11d00, 0x11d06, direction::L},
-    {0x11d08, 0x11d09, direction::L},   {0x11d0b, 0x11d30, direction::L},
-    {0x11d31, 0x11d36, direction::NSM}, {0x11d3a, 0x11d3a, direction::NSM},
-    {0x11d3c, 0x11d3d, direction::NSM}, {0x11d3f, 0x11d45, direction::NSM},
-    {0x11d46, 0x11d46, direction::L},   {0x11d47, 0x11d47, direction::NSM},
-    {0x11d50, 0x11d59, direction::L},   {0x11d60, 0x11d65, direction::L},
-    {0x11d67, 0x11d68, direction::L},   {0x11d6a, 0x11d8e, direction::L},
-    {0x11d90, 0x11d91, direction::NSM}, {0x11d93, 0x11d94, direction::L},
-    {0x11d95, 0x11d95, direction::NSM}, {0x11d96, 0x11d96, direction::L},
-    {0x11d97, 0x11d97, direction::NSM}, {0x11d98, 0x11d98, direction::L},
-    {0x11da0, 0x11da9, direction::L},   {0x11ee0, 0x11ef2, direction::L},
-    {0x11ef3, 0x11ef4, direction::NSM}, {0x11ef5, 0x11ef8, direction::L},
-    {0x11fb0, 0x11fb0, direction::L},   {0x11fc0, 0x11fd4, direction::L},
-    {0x11fd5, 0x11fdc, direction::ON},  {0x11fdd, 0x11fe0, direction::ET},
-    {0x11fe1, 0x11ff1, direction::ON},  {0x11fff, 0x12399, direction::L},
-    {0x12400, 0x1246e, direction::L},   {0x12470, 0x12474, direction::L},
-    {0x12480, 0x12543, direction::L},   {0x13000, 0x1342e, direction::L},
-    {0x13430, 0x13438, direction::L},   {0x14400, 0x14646, direction::L},
-    {0x16800, 0x16a38, direction::L},   {0x16a40, 0x16a5e, direction::L},
-    {0x16a60, 0x16a69, direction::L},   {0x16a6e, 0x16a6f, direction::L},
-    {0x16ad0, 0x16aed, direction::L},   {0x16af0, 0x16af4, direction::NSM},
-    {0x16af5, 0x16af5, direction::L},   {0x16b00, 0x16b2f, direction::L},
-    {0x16b30, 0x16b36, direction::NSM}, {0x16b37, 0x16b45, direction::L},
-    {0x16b50, 0x16b59, direction::L},   {0x16b5b, 0x16b61, direction::L},
-    {0x16b63, 0x16b77, direction::L},   {0x16b7d, 0x16b8f, direction::L},
-    {0x16e40, 0x16e9a, direction::L},   {0x16f00, 0x16f4a, direction::L},
-    {0x16f4f, 0x16f4f, direction::NSM}, {0x16f50, 0x16f87, direction::L},
-    {0x16f8f, 0x16f92, direction::NSM}, {0x16f93, 0x16f9f, direction::L},
-    {0x16fe0, 0x16fe1, direction::L},   {0x16fe2, 0x16fe2, direction::ON},
-    {0x16fe3, 0x16fe3, direction::L},   {0x16fe4, 0x16fe4, direction::NSM},
-    {0x16ff0, 0x16ff1, direction::L},   {0x17000, 0x187f7, direction::L},
-    {0x18800, 0x18cd5, direction::L},   {0x18d00, 0x18d08, direction::L},
-    {0x1b000, 0x1b11e, direction::L},   {0x1b150, 0x1b152, direction::L},
-    {0x1b164, 0x1b167, direction::L},   {0x1b170, 0x1b2fb, direction::L},
-    {0x1bc00, 0x1bc6a, direction::L},   {0x1bc70, 0x1bc7c, direction::L},
-    {0x1bc80, 0x1bc88, direction::L},   {0x1bc90, 0x1bc99, direction::L},
-    {0x1bc9c, 0x1bc9c, direction::L},   {0x1bc9d, 0x1bc9e, direction::NSM},
-    {0x1bc9f, 0x1bc9f, direction::L},   {0x1bca0, 0x1bca3, direction::BN},
-    {0x1d000, 0x1d0f5, direction::L},   {0x1d100, 0x1d126, direction::L},
-    {0x1d129, 0x1d166, direction::L},   {0x1d167, 0x1d169, direction::NSM},
-    {0x1d16a, 0x1d172, direction::L},   {0x1d173, 0x1d17a, direction::BN},
-    {0x1d17b, 0x1d182, direction::NSM}, {0x1d183, 0x1d184, direction::L},
-    {0x1d185, 0x1d18b, direction::NSM}, {0x1d18c, 0x1d1a9, direction::L},
-    {0x1d1aa, 0x1d1ad, direction::NSM}, {0x1d1ae, 0x1d1e8, direction::L},
-    {0x1d200, 0x1d241, direction::ON},  {0x1d242, 0x1d244, direction::NSM},
-    {0x1d245, 0x1d245, direction::ON},  {0x1d2e0, 0x1d2f3, direction::L},
-    {0x1d300, 0x1d356, direction::ON},  {0x1d360, 0x1d378, direction::L},
-    {0x1d400, 0x1d454, direction::L},   {0x1d456, 0x1d49c, direction::L},
-    {0x1d49e, 0x1d49f, direction::L},   {0x1d4a2, 0x1d4a2, direction::L},
-    {0x1d4a5, 0x1d4a6, direction::L},   {0x1d4a9, 0x1d4ac, direction::L},
-    {0x1d4ae, 0x1d4b9, direction::L},   {0x1d4bb, 0x1d4bb, direction::L},
-    {0x1d4bd, 0x1d4c3, direction::L},   {0x1d4c5, 0x1d505, direction::L},
-    {0x1d507, 0x1d50a, direction::L},   {0x1d50d, 0x1d514, direction::L},
-    {0x1d516, 0x1d51c, direction::L},   {0x1d51e, 0x1d539, direction::L},
-    {0x1d53b, 0x1d53e, direction::L},   {0x1d540, 0x1d544, direction::L},
-    {0x1d546, 0x1d546, direction::L},   {0x1d54a, 0x1d550, direction::L},
-    {0x1d552, 0x1d6a5, direction::L},   {0x1d6a8, 0x1d6da, direction::L},
-    {0x1d6db, 0x1d6db, direction::ON},  {0x1d6dc, 0x1d714, direction::L},
-    {0x1d715, 0x1d715, direction::ON},  {0x1d716, 0x1d74e, direction::L},
-    {0x1d74f, 0x1d74f, direction::ON},  {0x1d750, 0x1d788, direction::L},
-    {0x1d789, 0x1d789, direction::ON},  {0x1d78a, 0x1d7c2, direction::L},
-    {0x1d7c3, 0x1d7c3, direction::ON},  {0x1d7c4, 0x1d7cb, direction::L},
-    {0x1d7ce, 0x1d7ff, direction::EN},  {0x1d800, 0x1d9ff, direction::L},
-    {0x1da00, 0x1da36, direction::NSM}, {0x1da37, 0x1da3a, direction::L},
-    {0x1da3b, 0x1da6c, direction::NSM}, {0x1da6d, 0x1da74, direction::L},
-    {0x1da75, 0x1da75, direction::NSM}, {0x1da76, 0x1da83, direction::L},
-    {0x1da84, 0x1da84, direction::NSM}, {0x1da85, 0x1da8b, direction::L},
-    {0x1da9b, 0x1da9f, direction::NSM}, {0x1daa1, 0x1daaf, direction::NSM},
-    {0x1e000, 0x1e006, direction::NSM}, {0x1e008, 0x1e018, direction::NSM},
-    {0x1e01b, 0x1e021, direction::NSM}, {0x1e023, 0x1e024, direction::NSM},
-    {0x1e026, 0x1e02a, direction::NSM}, {0x1e100, 0x1e12c, direction::L},
-    {0x1e130, 0x1e136, direction::NSM}, {0x1e137, 0x1e13d, direction::L},
-    {0x1e140, 0x1e149, direction::L},   {0x1e14e, 0x1e14f, direction::L},
-    {0x1e2c0, 0x1e2eb, direction::L},   {0x1e2ec, 0x1e2ef, direction::NSM},
-    {0x1e2f0, 0x1e2f9, direction::L},   {0x1e2ff, 0x1e2ff, direction::ET},
-    {0x1e800, 0x1e8c4, direction::R},   {0x1e8c7, 0x1e8cf, direction::R},
-    {0x1e8d0, 0x1e8d6, direction::NSM}, {0x1e900, 0x1e943, direction::R},
-    {0x1e944, 0x1e94a, direction::NSM}, {0x1e94b, 0x1e94b, direction::R},
-    {0x1e950, 0x1e959, direction::R},   {0x1e95e, 0x1e95f, direction::R},
-    {0x1ec71, 0x1ecb4, direction::AL},  {0x1ed01, 0x1ed3d, direction::AL},
-    {0x1ee00, 0x1ee03, direction::AL},  {0x1ee05, 0x1ee1f, direction::AL},
-    {0x1ee21, 0x1ee22, direction::AL},  {0x1ee24, 0x1ee24, direction::AL},
-    {0x1ee27, 0x1ee27, direction::AL},  {0x1ee29, 0x1ee32, direction::AL},
-    {0x1ee34, 0x1ee37, direction::AL},  {0x1ee39, 0x1ee39, direction::AL},
-    {0x1ee3b, 0x1ee3b, direction::AL},  {0x1ee42, 0x1ee42, direction::AL},
-    {0x1ee47, 0x1ee47, direction::AL},  {0x1ee49, 0x1ee49, direction::AL},
-    {0x1ee4b, 0x1ee4b, direction::AL},  {0x1ee4d, 0x1ee4f, direction::AL},
-    {0x1ee51, 0x1ee52, direction::AL},  {0x1ee54, 0x1ee54, direction::AL},
-    {0x1ee57, 0x1ee57, direction::AL},  {0x1ee59, 0x1ee59, direction::AL},
-    {0x1ee5b, 0x1ee5b, direction::AL},  {0x1ee5d, 0x1ee5d, direction::AL},
-    {0x1ee5f, 0x1ee5f, direction::AL},  {0x1ee61, 0x1ee62, direction::AL},
-    {0x1ee64, 0x1ee64, direction::AL},  {0x1ee67, 0x1ee6a, direction::AL},
-    {0x1ee6c, 0x1ee72, direction::AL},  {0x1ee74, 0x1ee77, direction::AL},
-    {0x1ee79, 0x1ee7c, direction::AL},  {0x1ee7e, 0x1ee7e, direction::AL},
-    {0x1ee80, 0x1ee89, direction::AL},  {0x1ee8b, 0x1ee9b, direction::AL},
-    {0x1eea1, 0x1eea3, direction::AL},  {0x1eea5, 0x1eea9, direction::AL},
-    {0x1eeab, 0x1eebb, direction::AL},  {0x1eef0, 0x1eef1, direction::ON},
-    {0x1f000, 0x1f02b, direction::ON},  {0x1f030, 0x1f093, direction::ON},
-    {0x1f0a0, 0x1f0ae, direction::ON},  {0x1f0b1, 0x1f0bf, direction::ON},
-    {0x1f0c1, 0x1f0cf, direction::ON},  {0x1f0d1, 0x1f0f5, direction::ON},
-    {0x1f100, 0x1f10a, direction::EN},  {0x1f10b, 0x1f10f, direction::ON},
-    {0x1f110, 0x1f12e, direction::L},   {0x1f12f, 0x1f12f, direction::ON},
-    {0x1f130, 0x1f169, direction::L},   {0x1f16a, 0x1f16f, direction::ON},
-    {0x1f170, 0x1f1ac, direction::L},   {0x1f1ad, 0x1f1ad, direction::ON},
-    {0x1f1e6, 0x1f202, direction::L},   {0x1f210, 0x1f23b, direction::L},
-    {0x1f240, 0x1f248, direction::L},   {0x1f250, 0x1f251, direction::L},
-    {0x1f260, 0x1f265, direction::ON},  {0x1f300, 0x1f6d7, direction::ON},
-    {0x1f6e0, 0x1f6ec, direction::ON},  {0x1f6f0, 0x1f6fc, direction::ON},
-    {0x1f700, 0x1f773, direction::ON},  {0x1f780, 0x1f7d8, direction::ON},
-    {0x1f7e0, 0x1f7eb, direction::ON},  {0x1f800, 0x1f80b, direction::ON},
-    {0x1f810, 0x1f847, direction::ON},  {0x1f850, 0x1f859, direction::ON},
-    {0x1f860, 0x1f887, direction::ON},  {0x1f890, 0x1f8ad, direction::ON},
-    {0x1f8b0, 0x1f8b1, direction::ON},  {0x1f900, 0x1f978, direction::ON},
-    {0x1f97a, 0x1f9cb, direction::ON},  {0x1f9cd, 0x1fa53, direction::ON},
-    {0x1fa60, 0x1fa6d, direction::ON},  {0x1fa70, 0x1fa74, direction::ON},
-    {0x1fa78, 0x1fa7a, direction::ON},  {0x1fa80, 0x1fa86, direction::ON},
-    {0x1fa90, 0x1faa8, direction::ON},  {0x1fab0, 0x1fab6, direction::ON},
-    {0x1fac0, 0x1fac2, direction::ON},  {0x1fad0, 0x1fad6, direction::ON},
-    {0x1fb00, 0x1fb92, direction::ON},  {0x1fb94, 0x1fbca, direction::ON},
-    {0x1fbf0, 0x1fbf9, direction::EN},  {0x20000, 0x2a6dd, direction::L},
-    {0x2a700, 0x2b734, direction::L},   {0x2b740, 0x2b81d, direction::L},
-    {0x2b820, 0x2cea1, direction::L},   {0x2ceb0, 0x2ebe0, direction::L},
-    {0x2f800, 0x2fa1d, direction::L},   {0x30000, 0x3134a, direction::L},
-    {0xe0001, 0xe0001, direction::BN},  {0xe0020, 0xe007f, direction::BN},
-    {0xe0100, 0xe01ef, direction::NSM}, {0xf0000, 0xffffd, direction::L},
-    {0x100000, 0x10fffd, direction::L}};
-
-// CheckJoiners and CheckBidi are true for URL specification.
-
-inline static direction find_direction(uint32_t code_point) noexcept {
-  auto it = std::lower_bound(
-      std::begin(dir_table), std::end(dir_table), code_point,
-      [](const directions& d, uint32_t c) { return d.final_code < c; });
-
-  // next check is almost surely in vain, but we use it for safety.
-  if (it == std::end(dir_table)) {
-    return direction::NONE;
-  }
-  // We have that d.final_code >= c.
-  if (code_point >= it->start_code) {
-    return it->direct;
-  }
-  return direction::NONE;
-}
-
-inline static size_t find_last_not_of_nsm(
-    const std::u32string_view label) noexcept {
-  for (int i = label.size() - 1; i >= 0; i--)
-    if (find_direction(label[i]) != direction::NSM) return i;
-
-  return std::u32string_view::npos;
-}
-
-// An RTL label is a label that contains at least one character of type R, AL,
-// or AN. https://www.rfc-editor.org/rfc/rfc5893#section-2
-inline static bool is_rtl_label(const std::u32string_view label) noexcept {
-  const size_t mask =
-      (1u << direction::R) | (1u << direction::AL) | (1u << direction::AN);
-
-  size_t directions = 0;
-  for (size_t i = 0; i < label.size(); i++) {
-    directions |= 1u << find_direction(label[i]);
-  }
-  return (directions & mask) != 0;
-}
-
-bool is_label_valid(const std::u32string_view label) {
-  if (label.empty()) {
-    return true;
-  }
-
-  ///////////////
-  // We have a normalization step which ensures that we are in NFC.
-  // If we receive punycode, we normalize and check that the normalized
-  // version matches the original.
-  // --------------------------------------
-  // The label must be in Unicode Normalization Form NFC.
-
-  // Current URL standard indicatest that CheckHyphens is set to false.
-  // ---------------------------------------
-  // If CheckHyphens, the label must not contain a U+002D HYPHEN-MINUS character
-  // in both the third and fourth positions. If CheckHyphens, the label must
-  // neither begin nor end with a U+002D HYPHEN-MINUS character.
-
-  // This is not necessary because we segment the
-  // labels by '.'.
-  // ---------------------------------------
-  // The label must not contain a U+002E ( . ) FULL STOP.
-  // if (label.find('.') != std::string_view::npos) return false;
-
-  // The label must not begin with a combining mark, that is:
-  // General_Category=Mark.
-  constexpr static uint32_t combining[] = {
-      0x300,   0x301,   0x302,   0x303,   0x304,   0x305,   0x306,   0x307,
-      0x308,   0x309,   0x30a,   0x30b,   0x30c,   0x30d,   0x30e,   0x30f,
-      0x310,   0x311,   0x312,   0x313,   0x314,   0x315,   0x316,   0x317,
-      0x318,   0x319,   0x31a,   0x31b,   0x31c,   0x31d,   0x31e,   0x31f,
-      0x320,   0x321,   0x322,   0x323,   0x324,   0x325,   0x326,   0x327,
-      0x328,   0x329,   0x32a,   0x32b,   0x32c,   0x32d,   0x32e,   0x32f,
-      0x330,   0x331,   0x332,   0x333,   0x334,   0x335,   0x336,   0x337,
-      0x338,   0x339,   0x33a,   0x33b,   0x33c,   0x33d,   0x33e,   0x33f,
-      0x340,   0x341,   0x342,   0x343,   0x344,   0x345,   0x346,   0x347,
-      0x348,   0x349,   0x34a,   0x34b,   0x34c,   0x34d,   0x34e,   0x34f,
-      0x350,   0x351,   0x352,   0x353,   0x354,   0x355,   0x356,   0x357,
-      0x358,   0x359,   0x35a,   0x35b,   0x35c,   0x35d,   0x35e,   0x35f,
-      0x360,   0x361,   0x362,   0x363,   0x364,   0x365,   0x366,   0x367,
-      0x368,   0x369,   0x36a,   0x36b,   0x36c,   0x36d,   0x36e,   0x36f,
-      0x483,   0x484,   0x485,   0x486,   0x487,   0x488,   0x489,   0x591,
-      0x592,   0x593,   0x594,   0x595,   0x596,   0x597,   0x598,   0x599,
-      0x59a,   0x59b,   0x59c,   0x59d,   0x59e,   0x59f,   0x5a0,   0x5a1,
-      0x5a2,   0x5a3,   0x5a4,   0x5a5,   0x5a6,   0x5a7,   0x5a8,   0x5a9,
-      0x5aa,   0x5ab,   0x5ac,   0x5ad,   0x5ae,   0x5af,   0x5b0,   0x5b1,
-      0x5b2,   0x5b3,   0x5b4,   0x5b5,   0x5b6,   0x5b7,   0x5b8,   0x5b9,
-      0x5ba,   0x5bb,   0x5bc,   0x5bd,   0x5bf,   0x5c1,   0x5c2,   0x5c4,
-      0x5c5,   0x5c7,   0x610,   0x611,   0x612,   0x613,   0x614,   0x615,
-      0x616,   0x617,   0x618,   0x619,   0x61a,   0x64b,   0x64c,   0x64d,
-      0x64e,   0x64f,   0x650,   0x651,   0x652,   0x653,   0x654,   0x655,
-      0x656,   0x657,   0x658,   0x659,   0x65a,   0x65b,   0x65c,   0x65d,
-      0x65e,   0x65f,   0x670,   0x6d6,   0x6d7,   0x6d8,   0x6d9,   0x6da,
-      0x6db,   0x6dc,   0x6df,   0x6e0,   0x6e1,   0x6e2,   0x6e3,   0x6e4,
-      0x6e7,   0x6e8,   0x6ea,   0x6eb,   0x6ec,   0x6ed,   0x711,   0x730,
-      0x731,   0x732,   0x733,   0x734,   0x735,   0x736,   0x737,   0x738,
-      0x739,   0x73a,   0x73b,   0x73c,   0x73d,   0x73e,   0x73f,   0x740,
-      0x741,   0x742,   0x743,   0x744,   0x745,   0x746,   0x747,   0x748,
-      0x749,   0x74a,   0x7a6,   0x7a7,   0x7a8,   0x7a9,   0x7aa,   0x7ab,
-      0x7ac,   0x7ad,   0x7ae,   0x7af,   0x7b0,   0x7eb,   0x7ec,   0x7ed,
-      0x7ee,   0x7ef,   0x7f0,   0x7f1,   0x7f2,   0x7f3,   0x7fd,   0x816,
-      0x817,   0x818,   0x819,   0x81b,   0x81c,   0x81d,   0x81e,   0x81f,
-      0x820,   0x821,   0x822,   0x823,   0x825,   0x826,   0x827,   0x829,
-      0x82a,   0x82b,   0x82c,   0x82d,   0x859,   0x85a,   0x85b,   0x8d3,
-      0x8d4,   0x8d5,   0x8d6,   0x8d7,   0x8d8,   0x8d9,   0x8da,   0x8db,
-      0x8dc,   0x8dd,   0x8de,   0x8df,   0x8e0,   0x8e1,   0x8e3,   0x8e4,
-      0x8e5,   0x8e6,   0x8e7,   0x8e8,   0x8e9,   0x8ea,   0x8eb,   0x8ec,
-      0x8ed,   0x8ee,   0x8ef,   0x8f0,   0x8f1,   0x8f2,   0x8f3,   0x8f4,
-      0x8f5,   0x8f6,   0x8f7,   0x8f8,   0x8f9,   0x8fa,   0x8fb,   0x8fc,
-      0x8fd,   0x8fe,   0x8ff,   0x900,   0x901,   0x902,   0x903,   0x93a,
-      0x93b,   0x93c,   0x93e,   0x93f,   0x940,   0x941,   0x942,   0x943,
-      0x944,   0x945,   0x946,   0x947,   0x948,   0x949,   0x94a,   0x94b,
-      0x94c,   0x94d,   0x94e,   0x94f,   0x951,   0x952,   0x953,   0x954,
-      0x955,   0x956,   0x957,   0x962,   0x963,   0x981,   0x982,   0x983,
-      0x9bc,   0x9be,   0x9bf,   0x9c0,   0x9c1,   0x9c2,   0x9c3,   0x9c4,
-      0x9c7,   0x9c8,   0x9cb,   0x9cc,   0x9cd,   0x9d7,   0x9e2,   0x9e3,
-      0x9fe,   0xa01,   0xa02,   0xa03,   0xa3c,   0xa3e,   0xa3f,   0xa40,
-      0xa41,   0xa42,   0xa47,   0xa48,   0xa4b,   0xa4c,   0xa4d,   0xa51,
-      0xa70,   0xa71,   0xa75,   0xa81,   0xa82,   0xa83,   0xabc,   0xabe,
-      0xabf,   0xac0,   0xac1,   0xac2,   0xac3,   0xac4,   0xac5,   0xac7,
-      0xac8,   0xac9,   0xacb,   0xacc,   0xacd,   0xae2,   0xae3,   0xafa,
-      0xafb,   0xafc,   0xafd,   0xafe,   0xaff,   0xb01,   0xb02,   0xb03,
-      0xb3c,   0xb3e,   0xb3f,   0xb40,   0xb41,   0xb42,   0xb43,   0xb44,
-      0xb47,   0xb48,   0xb4b,   0xb4c,   0xb4d,   0xb55,   0xb56,   0xb57,
-      0xb62,   0xb63,   0xb82,   0xbbe,   0xbbf,   0xbc0,   0xbc1,   0xbc2,
-      0xbc6,   0xbc7,   0xbc8,   0xbca,   0xbcb,   0xbcc,   0xbcd,   0xbd7,
-      0xc00,   0xc01,   0xc02,   0xc03,   0xc04,   0xc3e,   0xc3f,   0xc40,
-      0xc41,   0xc42,   0xc43,   0xc44,   0xc46,   0xc47,   0xc48,   0xc4a,
-      0xc4b,   0xc4c,   0xc4d,   0xc55,   0xc56,   0xc62,   0xc63,   0xc81,
-      0xc82,   0xc83,   0xcbc,   0xcbe,   0xcbf,   0xcc0,   0xcc1,   0xcc2,
-      0xcc3,   0xcc4,   0xcc6,   0xcc7,   0xcc8,   0xcca,   0xccb,   0xccc,
-      0xccd,   0xcd5,   0xcd6,   0xce2,   0xce3,   0xd00,   0xd01,   0xd02,
-      0xd03,   0xd3b,   0xd3c,   0xd3e,   0xd3f,   0xd40,   0xd41,   0xd42,
-      0xd43,   0xd44,   0xd46,   0xd47,   0xd48,   0xd4a,   0xd4b,   0xd4c,
-      0xd4d,   0xd57,   0xd62,   0xd63,   0xd81,   0xd82,   0xd83,   0xdca,
-      0xdcf,   0xdd0,   0xdd1,   0xdd2,   0xdd3,   0xdd4,   0xdd6,   0xdd8,
-      0xdd9,   0xdda,   0xddb,   0xddc,   0xddd,   0xdde,   0xddf,   0xdf2,
-      0xdf3,   0xe31,   0xe34,   0xe35,   0xe36,   0xe37,   0xe38,   0xe39,
-      0xe3a,   0xe47,   0xe48,   0xe49,   0xe4a,   0xe4b,   0xe4c,   0xe4d,
-      0xe4e,   0xeb1,   0xeb4,   0xeb5,   0xeb6,   0xeb7,   0xeb8,   0xeb9,
-      0xeba,   0xebb,   0xebc,   0xec8,   0xec9,   0xeca,   0xecb,   0xecc,
-      0xecd,   0xf18,   0xf19,   0xf35,   0xf37,   0xf39,   0xf3e,   0xf3f,
-      0xf71,   0xf72,   0xf73,   0xf74,   0xf75,   0xf76,   0xf77,   0xf78,
-      0xf79,   0xf7a,   0xf7b,   0xf7c,   0xf7d,   0xf7e,   0xf7f,   0xf80,
-      0xf81,   0xf82,   0xf83,   0xf84,   0xf86,   0xf87,   0xf8d,   0xf8e,
-      0xf8f,   0xf90,   0xf91,   0xf92,   0xf93,   0xf94,   0xf95,   0xf96,
-      0xf97,   0xf99,   0xf9a,   0xf9b,   0xf9c,   0xf9d,   0xf9e,   0xf9f,
-      0xfa0,   0xfa1,   0xfa2,   0xfa3,   0xfa4,   0xfa5,   0xfa6,   0xfa7,
-      0xfa8,   0xfa9,   0xfaa,   0xfab,   0xfac,   0xfad,   0xfae,   0xfaf,
-      0xfb0,   0xfb1,   0xfb2,   0xfb3,   0xfb4,   0xfb5,   0xfb6,   0xfb7,
-      0xfb8,   0xfb9,   0xfba,   0xfbb,   0xfbc,   0xfc6,   0x102b,  0x102c,
-      0x102d,  0x102e,  0x102f,  0x1030,  0x1031,  0x1032,  0x1033,  0x1034,
-      0x1035,  0x1036,  0x1037,  0x1038,  0x1039,  0x103a,  0x103b,  0x103c,
-      0x103d,  0x103e,  0x1056,  0x1057,  0x1058,  0x1059,  0x105e,  0x105f,
-      0x1060,  0x1062,  0x1063,  0x1064,  0x1067,  0x1068,  0x1069,  0x106a,
-      0x106b,  0x106c,  0x106d,  0x1071,  0x1072,  0x1073,  0x1074,  0x1082,
-      0x1083,  0x1084,  0x1085,  0x1086,  0x1087,  0x1088,  0x1089,  0x108a,
-      0x108b,  0x108c,  0x108d,  0x108f,  0x109a,  0x109b,  0x109c,  0x109d,
-      0x135d,  0x135e,  0x135f,  0x1712,  0x1713,  0x1714,  0x1732,  0x1733,
-      0x1734,  0x1752,  0x1753,  0x1772,  0x1773,  0x17b4,  0x17b5,  0x17b6,
-      0x17b7,  0x17b8,  0x17b9,  0x17ba,  0x17bb,  0x17bc,  0x17bd,  0x17be,
-      0x17bf,  0x17c0,  0x17c1,  0x17c2,  0x17c3,  0x17c4,  0x17c5,  0x17c6,
-      0x17c7,  0x17c8,  0x17c9,  0x17ca,  0x17cb,  0x17cc,  0x17cd,  0x17ce,
-      0x17cf,  0x17d0,  0x17d1,  0x17d2,  0x17d3,  0x17dd,  0x180b,  0x180c,
-      0x180d,  0x1885,  0x1886,  0x18a9,  0x1920,  0x1921,  0x1922,  0x1923,
-      0x1924,  0x1925,  0x1926,  0x1927,  0x1928,  0x1929,  0x192a,  0x192b,
-      0x1930,  0x1931,  0x1932,  0x1933,  0x1934,  0x1935,  0x1936,  0x1937,
-      0x1938,  0x1939,  0x193a,  0x193b,  0x1a17,  0x1a18,  0x1a19,  0x1a1a,
-      0x1a1b,  0x1a55,  0x1a56,  0x1a57,  0x1a58,  0x1a59,  0x1a5a,  0x1a5b,
-      0x1a5c,  0x1a5d,  0x1a5e,  0x1a60,  0x1a61,  0x1a62,  0x1a63,  0x1a64,
-      0x1a65,  0x1a66,  0x1a67,  0x1a68,  0x1a69,  0x1a6a,  0x1a6b,  0x1a6c,
-      0x1a6d,  0x1a6e,  0x1a6f,  0x1a70,  0x1a71,  0x1a72,  0x1a73,  0x1a74,
-      0x1a75,  0x1a76,  0x1a77,  0x1a78,  0x1a79,  0x1a7a,  0x1a7b,  0x1a7c,
-      0x1a7f,  0x1ab0,  0x1ab1,  0x1ab2,  0x1ab3,  0x1ab4,  0x1ab5,  0x1ab6,
-      0x1ab7,  0x1ab8,  0x1ab9,  0x1aba,  0x1abb,  0x1abc,  0x1abd,  0x1abe,
-      0x1abf,  0x1ac0,  0x1b00,  0x1b01,  0x1b02,  0x1b03,  0x1b04,  0x1b34,
-      0x1b35,  0x1b36,  0x1b37,  0x1b38,  0x1b39,  0x1b3a,  0x1b3b,  0x1b3c,
-      0x1b3d,  0x1b3e,  0x1b3f,  0x1b40,  0x1b41,  0x1b42,  0x1b43,  0x1b44,
-      0x1b6b,  0x1b6c,  0x1b6d,  0x1b6e,  0x1b6f,  0x1b70,  0x1b71,  0x1b72,
-      0x1b73,  0x1b80,  0x1b81,  0x1b82,  0x1ba1,  0x1ba2,  0x1ba3,  0x1ba4,
-      0x1ba5,  0x1ba6,  0x1ba7,  0x1ba8,  0x1ba9,  0x1baa,  0x1bab,  0x1bac,
-      0x1bad,  0x1be6,  0x1be7,  0x1be8,  0x1be9,  0x1bea,  0x1beb,  0x1bec,
-      0x1bed,  0x1bee,  0x1bef,  0x1bf0,  0x1bf1,  0x1bf2,  0x1bf3,  0x1c24,
-      0x1c25,  0x1c26,  0x1c27,  0x1c28,  0x1c29,  0x1c2a,  0x1c2b,  0x1c2c,
-      0x1c2d,  0x1c2e,  0x1c2f,  0x1c30,  0x1c31,  0x1c32,  0x1c33,  0x1c34,
-      0x1c35,  0x1c36,  0x1c37,  0x1cd0,  0x1cd1,  0x1cd2,  0x1cd4,  0x1cd5,
-      0x1cd6,  0x1cd7,  0x1cd8,  0x1cd9,  0x1cda,  0x1cdb,  0x1cdc,  0x1cdd,
-      0x1cde,  0x1cdf,  0x1ce0,  0x1ce1,  0x1ce2,  0x1ce3,  0x1ce4,  0x1ce5,
-      0x1ce6,  0x1ce7,  0x1ce8,  0x1ced,  0x1cf4,  0x1cf7,  0x1cf8,  0x1cf9,
-      0x1dc0,  0x1dc1,  0x1dc2,  0x1dc3,  0x1dc4,  0x1dc5,  0x1dc6,  0x1dc7,
-      0x1dc8,  0x1dc9,  0x1dca,  0x1dcb,  0x1dcc,  0x1dcd,  0x1dce,  0x1dcf,
-      0x1dd0,  0x1dd1,  0x1dd2,  0x1dd3,  0x1dd4,  0x1dd5,  0x1dd6,  0x1dd7,
-      0x1dd8,  0x1dd9,  0x1dda,  0x1ddb,  0x1ddc,  0x1ddd,  0x1dde,  0x1ddf,
-      0x1de0,  0x1de1,  0x1de2,  0x1de3,  0x1de4,  0x1de5,  0x1de6,  0x1de7,
-      0x1de8,  0x1de9,  0x1dea,  0x1deb,  0x1dec,  0x1ded,  0x1dee,  0x1def,
-      0x1df0,  0x1df1,  0x1df2,  0x1df3,  0x1df4,  0x1df5,  0x1df6,  0x1df7,
-      0x1df8,  0x1df9,  0x1dfb,  0x1dfc,  0x1dfd,  0x1dfe,  0x1dff,  0x20d0,
-      0x20d1,  0x20d2,  0x20d3,  0x20d4,  0x20d5,  0x20d6,  0x20d7,  0x20d8,
-      0x20d9,  0x20da,  0x20db,  0x20dc,  0x20dd,  0x20de,  0x20df,  0x20e0,
-      0x20e1,  0x20e2,  0x20e3,  0x20e4,  0x20e5,  0x20e6,  0x20e7,  0x20e8,
-      0x20e9,  0x20ea,  0x20eb,  0x20ec,  0x20ed,  0x20ee,  0x20ef,  0x20f0,
-      0x2cef,  0x2cf0,  0x2cf1,  0x2d7f,  0x2de0,  0x2de1,  0x2de2,  0x2de3,
-      0x2de4,  0x2de5,  0x2de6,  0x2de7,  0x2de8,  0x2de9,  0x2dea,  0x2deb,
-      0x2dec,  0x2ded,  0x2dee,  0x2def,  0x2df0,  0x2df1,  0x2df2,  0x2df3,
-      0x2df4,  0x2df5,  0x2df6,  0x2df7,  0x2df8,  0x2df9,  0x2dfa,  0x2dfb,
-      0x2dfc,  0x2dfd,  0x2dfe,  0x2dff,  0x302a,  0x302b,  0x302c,  0x302d,
-      0x302e,  0x302f,  0x3099,  0x309a,  0xa66f,  0xa670,  0xa671,  0xa672,
-      0xa674,  0xa675,  0xa676,  0xa677,  0xa678,  0xa679,  0xa67a,  0xa67b,
-      0xa67c,  0xa67d,  0xa69e,  0xa69f,  0xa6f0,  0xa6f1,  0xa802,  0xa806,
-      0xa80b,  0xa823,  0xa824,  0xa825,  0xa826,  0xa827,  0xa82c,  0xa880,
-      0xa881,  0xa8b4,  0xa8b5,  0xa8b6,  0xa8b7,  0xa8b8,  0xa8b9,  0xa8ba,
-      0xa8bb,  0xa8bc,  0xa8bd,  0xa8be,  0xa8bf,  0xa8c0,  0xa8c1,  0xa8c2,
-      0xa8c3,  0xa8c4,  0xa8c5,  0xa8e0,  0xa8e1,  0xa8e2,  0xa8e3,  0xa8e4,
-      0xa8e5,  0xa8e6,  0xa8e7,  0xa8e8,  0xa8e9,  0xa8ea,  0xa8eb,  0xa8ec,
-      0xa8ed,  0xa8ee,  0xa8ef,  0xa8f0,  0xa8f1,  0xa8ff,  0xa926,  0xa927,
-      0xa928,  0xa929,  0xa92a,  0xa92b,  0xa92c,  0xa92d,  0xa947,  0xa948,
-      0xa949,  0xa94a,  0xa94b,  0xa94c,  0xa94d,  0xa94e,  0xa94f,  0xa950,
-      0xa951,  0xa952,  0xa953,  0xa980,  0xa981,  0xa982,  0xa983,  0xa9b3,
-      0xa9b4,  0xa9b5,  0xa9b6,  0xa9b7,  0xa9b8,  0xa9b9,  0xa9ba,  0xa9bb,
-      0xa9bc,  0xa9bd,  0xa9be,  0xa9bf,  0xa9c0,  0xa9e5,  0xaa29,  0xaa2a,
-      0xaa2b,  0xaa2c,  0xaa2d,  0xaa2e,  0xaa2f,  0xaa30,  0xaa31,  0xaa32,
-      0xaa33,  0xaa34,  0xaa35,  0xaa36,  0xaa43,  0xaa4c,  0xaa4d,  0xaa7b,
-      0xaa7c,  0xaa7d,  0xaab0,  0xaab2,  0xaab3,  0xaab4,  0xaab7,  0xaab8,
-      0xaabe,  0xaabf,  0xaac1,  0xaaeb,  0xaaec,  0xaaed,  0xaaee,  0xaaef,
-      0xaaf5,  0xaaf6,  0xabe3,  0xabe4,  0xabe5,  0xabe6,  0xabe7,  0xabe8,
-      0xabe9,  0xabea,  0xabec,  0xabed,  0xfb1e,  0xfe00,  0xfe01,  0xfe02,
-      0xfe03,  0xfe04,  0xfe05,  0xfe06,  0xfe07,  0xfe08,  0xfe09,  0xfe0a,
-      0xfe0b,  0xfe0c,  0xfe0d,  0xfe0e,  0xfe0f,  0xfe20,  0xfe21,  0xfe22,
-      0xfe23,  0xfe24,  0xfe25,  0xfe26,  0xfe27,  0xfe28,  0xfe29,  0xfe2a,
-      0xfe2b,  0xfe2c,  0xfe2d,  0xfe2e,  0xfe2f,  0x101fd, 0x102e0, 0x10376,
-      0x10377, 0x10378, 0x10379, 0x1037a, 0x10a01, 0x10a02, 0x10a03, 0x10a05,
-      0x10a06, 0x10a0c, 0x10a0d, 0x10a0e, 0x10a0f, 0x10a38, 0x10a39, 0x10a3a,
-      0x10a3f, 0x10ae5, 0x10ae6, 0x10d24, 0x10d25, 0x10d26, 0x10d27, 0x10eab,
-      0x10eac, 0x10f46, 0x10f47, 0x10f48, 0x10f49, 0x10f4a, 0x10f4b, 0x10f4c,
-      0x10f4d, 0x10f4e, 0x10f4f, 0x10f50, 0x11000, 0x11001, 0x11002, 0x11038,
-      0x11039, 0x1103a, 0x1103b, 0x1103c, 0x1103d, 0x1103e, 0x1103f, 0x11040,
-      0x11041, 0x11042, 0x11043, 0x11044, 0x11045, 0x11046, 0x1107f, 0x11080,
-      0x11081, 0x11082, 0x110b0, 0x110b1, 0x110b2, 0x110b3, 0x110b4, 0x110b5,
-      0x110b6, 0x110b7, 0x110b8, 0x110b9, 0x110ba, 0x11100, 0x11101, 0x11102,
-      0x11127, 0x11128, 0x11129, 0x1112a, 0x1112b, 0x1112c, 0x1112d, 0x1112e,
-      0x1112f, 0x11130, 0x11131, 0x11132, 0x11133, 0x11134, 0x11145, 0x11146,
-      0x11173, 0x11180, 0x11181, 0x11182, 0x111b3, 0x111b4, 0x111b5, 0x111b6,
-      0x111b7, 0x111b8, 0x111b9, 0x111ba, 0x111bb, 0x111bc, 0x111bd, 0x111be,
-      0x111bf, 0x111c0, 0x111c9, 0x111ca, 0x111cb, 0x111cc, 0x111ce, 0x111cf,
-      0x1122c, 0x1122d, 0x1122e, 0x1122f, 0x11230, 0x11231, 0x11232, 0x11233,
-      0x11234, 0x11235, 0x11236, 0x11237, 0x1123e, 0x112df, 0x112e0, 0x112e1,
-      0x112e2, 0x112e3, 0x112e4, 0x112e5, 0x112e6, 0x112e7, 0x112e8, 0x112e9,
-      0x112ea, 0x11300, 0x11301, 0x11302, 0x11303, 0x1133b, 0x1133c, 0x1133e,
-      0x1133f, 0x11340, 0x11341, 0x11342, 0x11343, 0x11344, 0x11347, 0x11348,
-      0x1134b, 0x1134c, 0x1134d, 0x11357, 0x11362, 0x11363, 0x11366, 0x11367,
-      0x11368, 0x11369, 0x1136a, 0x1136b, 0x1136c, 0x11370, 0x11371, 0x11372,
-      0x11373, 0x11374, 0x11435, 0x11436, 0x11437, 0x11438, 0x11439, 0x1143a,
-      0x1143b, 0x1143c, 0x1143d, 0x1143e, 0x1143f, 0x11440, 0x11441, 0x11442,
-      0x11443, 0x11444, 0x11445, 0x11446, 0x1145e, 0x114b0, 0x114b1, 0x114b2,
-      0x114b3, 0x114b4, 0x114b5, 0x114b6, 0x114b7, 0x114b8, 0x114b9, 0x114ba,
-      0x114bb, 0x114bc, 0x114bd, 0x114be, 0x114bf, 0x114c0, 0x114c1, 0x114c2,
-      0x114c3, 0x115af, 0x115b0, 0x115b1, 0x115b2, 0x115b3, 0x115b4, 0x115b5,
-      0x115b8, 0x115b9, 0x115ba, 0x115bb, 0x115bc, 0x115bd, 0x115be, 0x115bf,
-      0x115c0, 0x115dc, 0x115dd, 0x11630, 0x11631, 0x11632, 0x11633, 0x11634,
-      0x11635, 0x11636, 0x11637, 0x11638, 0x11639, 0x1163a, 0x1163b, 0x1163c,
-      0x1163d, 0x1163e, 0x1163f, 0x11640, 0x116ab, 0x116ac, 0x116ad, 0x116ae,
-      0x116af, 0x116b0, 0x116b1, 0x116b2, 0x116b3, 0x116b4, 0x116b5, 0x116b6,
-      0x116b7, 0x1171d, 0x1171e, 0x1171f, 0x11720, 0x11721, 0x11722, 0x11723,
-      0x11724, 0x11725, 0x11726, 0x11727, 0x11728, 0x11729, 0x1172a, 0x1172b,
-      0x1182c, 0x1182d, 0x1182e, 0x1182f, 0x11830, 0x11831, 0x11832, 0x11833,
-      0x11834, 0x11835, 0x11836, 0x11837, 0x11838, 0x11839, 0x1183a, 0x11930,
-      0x11931, 0x11932, 0x11933, 0x11934, 0x11935, 0x11937, 0x11938, 0x1193b,
-      0x1193c, 0x1193d, 0x1193e, 0x11940, 0x11942, 0x11943, 0x119d1, 0x119d2,
-      0x119d3, 0x119d4, 0x119d5, 0x119d6, 0x119d7, 0x119da, 0x119db, 0x119dc,
-      0x119dd, 0x119de, 0x119df, 0x119e0, 0x119e4, 0x11a01, 0x11a02, 0x11a03,
-      0x11a04, 0x11a05, 0x11a06, 0x11a07, 0x11a08, 0x11a09, 0x11a0a, 0x11a33,
-      0x11a34, 0x11a35, 0x11a36, 0x11a37, 0x11a38, 0x11a39, 0x11a3b, 0x11a3c,
-      0x11a3d, 0x11a3e, 0x11a47, 0x11a51, 0x11a52, 0x11a53, 0x11a54, 0x11a55,
-      0x11a56, 0x11a57, 0x11a58, 0x11a59, 0x11a5a, 0x11a5b, 0x11a8a, 0x11a8b,
-      0x11a8c, 0x11a8d, 0x11a8e, 0x11a8f, 0x11a90, 0x11a91, 0x11a92, 0x11a93,
-      0x11a94, 0x11a95, 0x11a96, 0x11a97, 0x11a98, 0x11a99, 0x11c2f, 0x11c30,
-      0x11c31, 0x11c32, 0x11c33, 0x11c34, 0x11c35, 0x11c36, 0x11c38, 0x11c39,
-      0x11c3a, 0x11c3b, 0x11c3c, 0x11c3d, 0x11c3e, 0x11c3f, 0x11c92, 0x11c93,
-      0x11c94, 0x11c95, 0x11c96, 0x11c97, 0x11c98, 0x11c99, 0x11c9a, 0x11c9b,
-      0x11c9c, 0x11c9d, 0x11c9e, 0x11c9f, 0x11ca0, 0x11ca1, 0x11ca2, 0x11ca3,
-      0x11ca4, 0x11ca5, 0x11ca6, 0x11ca7, 0x11ca9, 0x11caa, 0x11cab, 0x11cac,
-      0x11cad, 0x11cae, 0x11caf, 0x11cb0, 0x11cb1, 0x11cb2, 0x11cb3, 0x11cb4,
-      0x11cb5, 0x11cb6, 0x11d31, 0x11d32, 0x11d33, 0x11d34, 0x11d35, 0x11d36,
-      0x11d3a, 0x11d3c, 0x11d3d, 0x11d3f, 0x11d40, 0x11d41, 0x11d42, 0x11d43,
-      0x11d44, 0x11d45, 0x11d47, 0x11d8a, 0x11d8b, 0x11d8c, 0x11d8d, 0x11d8e,
-      0x11d90, 0x11d91, 0x11d93, 0x11d94, 0x11d95, 0x11d96, 0x11d97, 0x11ef3,
-      0x11ef4, 0x11ef5, 0x11ef6, 0x16af0, 0x16af1, 0x16af2, 0x16af3, 0x16af4,
-      0x16b30, 0x16b31, 0x16b32, 0x16b33, 0x16b34, 0x16b35, 0x16b36, 0x16f4f,
-      0x16f51, 0x16f52, 0x16f53, 0x16f54, 0x16f55, 0x16f56, 0x16f57, 0x16f58,
-      0x16f59, 0x16f5a, 0x16f5b, 0x16f5c, 0x16f5d, 0x16f5e, 0x16f5f, 0x16f60,
-      0x16f61, 0x16f62, 0x16f63, 0x16f64, 0x16f65, 0x16f66, 0x16f67, 0x16f68,
-      0x16f69, 0x16f6a, 0x16f6b, 0x16f6c, 0x16f6d, 0x16f6e, 0x16f6f, 0x16f70,
-      0x16f71, 0x16f72, 0x16f73, 0x16f74, 0x16f75, 0x16f76, 0x16f77, 0x16f78,
-      0x16f79, 0x16f7a, 0x16f7b, 0x16f7c, 0x16f7d, 0x16f7e, 0x16f7f, 0x16f80,
-      0x16f81, 0x16f82, 0x16f83, 0x16f84, 0x16f85, 0x16f86, 0x16f87, 0x16f8f,
-      0x16f90, 0x16f91, 0x16f92, 0x16fe4, 0x16ff0, 0x16ff1, 0x1bc9d, 0x1bc9e,
-      0x1d165, 0x1d166, 0x1d167, 0x1d168, 0x1d169, 0x1d16d, 0x1d16e, 0x1d16f,
-      0x1d170, 0x1d171, 0x1d172, 0x1d17b, 0x1d17c, 0x1d17d, 0x1d17e, 0x1d17f,
-      0x1d180, 0x1d181, 0x1d182, 0x1d185, 0x1d186, 0x1d187, 0x1d188, 0x1d189,
-      0x1d18a, 0x1d18b, 0x1d1aa, 0x1d1ab, 0x1d1ac, 0x1d1ad, 0x1d242, 0x1d243,
-      0x1d244, 0x1da00, 0x1da01, 0x1da02, 0x1da03, 0x1da04, 0x1da05, 0x1da06,
-      0x1da07, 0x1da08, 0x1da09, 0x1da0a, 0x1da0b, 0x1da0c, 0x1da0d, 0x1da0e,
-      0x1da0f, 0x1da10, 0x1da11, 0x1da12, 0x1da13, 0x1da14, 0x1da15, 0x1da16,
-      0x1da17, 0x1da18, 0x1da19, 0x1da1a, 0x1da1b, 0x1da1c, 0x1da1d, 0x1da1e,
-      0x1da1f, 0x1da20, 0x1da21, 0x1da22, 0x1da23, 0x1da24, 0x1da25, 0x1da26,
-      0x1da27, 0x1da28, 0x1da29, 0x1da2a, 0x1da2b, 0x1da2c, 0x1da2d, 0x1da2e,
-      0x1da2f, 0x1da30, 0x1da31, 0x1da32, 0x1da33, 0x1da34, 0x1da35, 0x1da36,
-      0x1da3b, 0x1da3c, 0x1da3d, 0x1da3e, 0x1da3f, 0x1da40, 0x1da41, 0x1da42,
-      0x1da43, 0x1da44, 0x1da45, 0x1da46, 0x1da47, 0x1da48, 0x1da49, 0x1da4a,
-      0x1da4b, 0x1da4c, 0x1da4d, 0x1da4e, 0x1da4f, 0x1da50, 0x1da51, 0x1da52,
-      0x1da53, 0x1da54, 0x1da55, 0x1da56, 0x1da57, 0x1da58, 0x1da59, 0x1da5a,
-      0x1da5b, 0x1da5c, 0x1da5d, 0x1da5e, 0x1da5f, 0x1da60, 0x1da61, 0x1da62,
-      0x1da63, 0x1da64, 0x1da65, 0x1da66, 0x1da67, 0x1da68, 0x1da69, 0x1da6a,
-      0x1da6b, 0x1da6c, 0x1da75, 0x1da84, 0x1da9b, 0x1da9c, 0x1da9d, 0x1da9e,
-      0x1da9f, 0x1daa1, 0x1daa2, 0x1daa3, 0x1daa4, 0x1daa5, 0x1daa6, 0x1daa7,
-      0x1daa8, 0x1daa9, 0x1daaa, 0x1daab, 0x1daac, 0x1daad, 0x1daae, 0x1daaf,
-      0x1e000, 0x1e001, 0x1e002, 0x1e003, 0x1e004, 0x1e005, 0x1e006, 0x1e008,
-      0x1e009, 0x1e00a, 0x1e00b, 0x1e00c, 0x1e00d, 0x1e00e, 0x1e00f, 0x1e010,
-      0x1e011, 0x1e012, 0x1e013, 0x1e014, 0x1e015, 0x1e016, 0x1e017, 0x1e018,
-      0x1e01b, 0x1e01c, 0x1e01d, 0x1e01e, 0x1e01f, 0x1e020, 0x1e021, 0x1e023,
-      0x1e024, 0x1e026, 0x1e027, 0x1e028, 0x1e029, 0x1e02a, 0x1e130, 0x1e131,
-      0x1e132, 0x1e133, 0x1e134, 0x1e135, 0x1e136, 0x1e2ec, 0x1e2ed, 0x1e2ee,
-      0x1e2ef, 0x1e8d0, 0x1e8d1, 0x1e8d2, 0x1e8d3, 0x1e8d4, 0x1e8d5, 0x1e8d6,
-      0x1e944, 0x1e945, 0x1e946, 0x1e947, 0x1e948, 0x1e949, 0x1e94a, 0xe0100,
-      0xe0101, 0xe0102, 0xe0103, 0xe0104, 0xe0105, 0xe0106, 0xe0107, 0xe0108,
-      0xe0109, 0xe010a, 0xe010b, 0xe010c, 0xe010d, 0xe010e, 0xe010f, 0xe0110,
-      0xe0111, 0xe0112, 0xe0113, 0xe0114, 0xe0115, 0xe0116, 0xe0117, 0xe0118,
-      0xe0119, 0xe011a, 0xe011b, 0xe011c, 0xe011d, 0xe011e, 0xe011f, 0xe0120,
-      0xe0121, 0xe0122, 0xe0123, 0xe0124, 0xe0125, 0xe0126, 0xe0127, 0xe0128,
-      0xe0129, 0xe012a, 0xe012b, 0xe012c, 0xe012d, 0xe012e, 0xe012f, 0xe0130,
-      0xe0131, 0xe0132, 0xe0133, 0xe0134, 0xe0135, 0xe0136, 0xe0137, 0xe0138,
-      0xe0139, 0xe013a, 0xe013b, 0xe013c, 0xe013d, 0xe013e, 0xe013f, 0xe0140,
-      0xe0141, 0xe0142, 0xe0143, 0xe0144, 0xe0145, 0xe0146, 0xe0147, 0xe0148,
-      0xe0149, 0xe014a, 0xe014b, 0xe014c, 0xe014d, 0xe014e, 0xe014f, 0xe0150,
-      0xe0151, 0xe0152, 0xe0153, 0xe0154, 0xe0155, 0xe0156, 0xe0157, 0xe0158,
-      0xe0159, 0xe015a, 0xe015b, 0xe015c, 0xe015d, 0xe015e, 0xe015f, 0xe0160,
-      0xe0161, 0xe0162, 0xe0163, 0xe0164, 0xe0165, 0xe0166, 0xe0167, 0xe0168,
-      0xe0169, 0xe016a, 0xe016b, 0xe016c, 0xe016d, 0xe016e, 0xe016f, 0xe0170,
-      0xe0171, 0xe0172, 0xe0173, 0xe0174, 0xe0175, 0xe0176, 0xe0177, 0xe0178,
-      0xe0179, 0xe017a, 0xe017b, 0xe017c, 0xe017d, 0xe017e, 0xe017f, 0xe0180,
-      0xe0181, 0xe0182, 0xe0183, 0xe0184, 0xe0185, 0xe0186, 0xe0187, 0xe0188,
-      0xe0189, 0xe018a, 0xe018b, 0xe018c, 0xe018d, 0xe018e, 0xe018f, 0xe0190,
-      0xe0191, 0xe0192, 0xe0193, 0xe0194, 0xe0195, 0xe0196, 0xe0197, 0xe0198,
-      0xe0199, 0xe019a, 0xe019b, 0xe019c, 0xe019d, 0xe019e, 0xe019f, 0xe01a0,
-      0xe01a1, 0xe01a2, 0xe01a3, 0xe01a4, 0xe01a5, 0xe01a6, 0xe01a7, 0xe01a8,
-      0xe01a9, 0xe01aa, 0xe01ab, 0xe01ac, 0xe01ad, 0xe01ae, 0xe01af, 0xe01b0,
-      0xe01b1, 0xe01b2, 0xe01b3, 0xe01b4, 0xe01b5, 0xe01b6, 0xe01b7, 0xe01b8,
-      0xe01b9, 0xe01ba, 0xe01bb, 0xe01bc, 0xe01bd, 0xe01be, 0xe01bf, 0xe01c0,
-      0xe01c1, 0xe01c2, 0xe01c3, 0xe01c4, 0xe01c5, 0xe01c6, 0xe01c7, 0xe01c8,
-      0xe01c9, 0xe01ca, 0xe01cb, 0xe01cc, 0xe01cd, 0xe01ce, 0xe01cf, 0xe01d0,
-      0xe01d1, 0xe01d2, 0xe01d3, 0xe01d4, 0xe01d5, 0xe01d6, 0xe01d7, 0xe01d8,
-      0xe01d9, 0xe01da, 0xe01db, 0xe01dc, 0xe01dd, 0xe01de, 0xe01df, 0xe01e0,
-      0xe01e1, 0xe01e2, 0xe01e3, 0xe01e4, 0xe01e5, 0xe01e6, 0xe01e7, 0xe01e8,
-      0xe01e9, 0xe01ea, 0xe01eb, 0xe01ec, 0xe01ed, 0xe01ee, 0xe01ef};
-  if (std::binary_search(std::begin(combining), std::end(combining),
-                         label.front())) {
-    return false;
-  }
-  // We verify this next step as part of the mapping:
-  // ---------------------------------------------
-  // Each code point in the label must only have certain status values
-  // according to Section 5, IDNA Mapping Table:
-  // - For Transitional Processing, each value must be valid.
-  // - For Nontransitional Processing, each value must be either valid or
-  // deviation.
-
-  // If CheckJoiners, the label must satisfy the ContextJ rules from Appendix
-  // A, in The Unicode Code Points and Internationalized Domain Names for
-  // Applications (IDNA) [IDNA2008].
-  constexpr static uint32_t virama[] = {
-      0x094D,  0x09CD,  0x0A4D,  0x0ACD,  0x0B4D,  0x0BCD,  0x0C4D,  0x0CCD,
-      0x0D3B,  0x0D3C,  0x0D4D,  0x0DCA,  0x0E3A,  0x0EBA,  0x0F84,  0x1039,
-      0x103A,  0x1714,  0x1734,  0x17D2,  0x1A60,  0x1B44,  0x1BAA,  0x1BAB,
-      0x1BF2,  0x1BF3,  0x2D7F,  0xA806,  0xA82C,  0xA8C4,  0xA953,  0xA9C0,
-      0xAAF6,  0xABED,  0x10A3F, 0x11046, 0x1107F, 0x110B9, 0x11133, 0x11134,
-      0x111C0, 0x11235, 0x112EA, 0x1134D, 0x11442, 0x114C2, 0x115BF, 0x1163F,
-      0x116B6, 0x1172B, 0x11839, 0x1193D, 0x1193E, 0x119E0, 0x11A34, 0x11A47,
-      0x11A99, 0x11C3F, 0x11D44, 0x11D45, 0x11D97};
-  constexpr static uint32_t R[] = {
-      0x622, 0x623, 0x624, 0x625, 0x627, 0x629, 0x62f, 0x630, 0x631,
-      0x632, 0x648, 0x671, 0x672, 0x673, 0x675, 0x676, 0x677, 0x688,
-      0x689, 0x68a, 0x68b, 0x68c, 0x68d, 0x68e, 0x68f, 0x690, 0x691,
-      0x692, 0x693, 0x694, 0x695, 0x696, 0x697, 0x698, 0x699, 0x6c0,
-      0x6c3, 0x6c4, 0x6c5, 0x6c6, 0x6c7, 0x6c8, 0x6c9, 0x6ca, 0x6cb,
-      0x6cd, 0x6cf, 0x6d2, 0x6d3, 0x6d5, 0x6ee, 0x6ef, 0x710, 0x715,
-      0x716, 0x717, 0x718, 0x719, 0x71e, 0x728, 0x72a, 0x72c, 0x72f,
-      0x74d, 0x759, 0x75a, 0x75b, 0x854, 0x8aa, 0x8ab, 0x8ac};
-  constexpr static uint32_t L[] = {0xa872};
-  constexpr static uint32_t D[] = {
-      0x620,  0x626,  0x628,  0x62a,  0x62b,  0x62c,  0x62d,  0x62e,  0x633,
-      0x634,  0x635,  0x636,  0x637,  0x638,  0x639,  0x63a,  0x63b,  0x63c,
-      0x63d,  0x63e,  0x63f,  0x641,  0x642,  0x643,  0x644,  0x645,  0x646,
-      0x647,  0x649,  0x64a,  0x66e,  0x66f,  0x678,  0x679,  0x67a,  0x67b,
-      0x67c,  0x67d,  0x67e,  0x67f,  0x680,  0x681,  0x682,  0x683,  0x684,
-      0x685,  0x686,  0x687,  0x69a,  0x69b,  0x69c,  0x69d,  0x69e,  0x69f,
-      0x6a0,  0x6a1,  0x6a2,  0x6a3,  0x6a4,  0x6a5,  0x6a6,  0x6a7,  0x6a8,
-      0x6a9,  0x6aa,  0x6ab,  0x6ac,  0x6ad,  0x6ae,  0x6af,  0x6b0,  0x6b1,
-      0x6b2,  0x6b3,  0x6b4,  0x6b5,  0x6b6,  0x6b7,  0x6b8,  0x6b9,  0x6ba,
-      0x6bb,  0x6bc,  0x6bd,  0x6be,  0x6bf,  0x6c1,  0x6c2,  0x6cc,  0x6ce,
-      0x6d0,  0x6d1,  0x6fa,  0x6fb,  0x6fc,  0x6ff,  0x712,  0x713,  0x714,
-      0x71a,  0x71b,  0x71c,  0x71d,  0x71f,  0x720,  0x721,  0x722,  0x723,
-      0x724,  0x725,  0x726,  0x727,  0x729,  0x72b,  0x72d,  0x72e,  0x74e,
-      0x74f,  0x750,  0x751,  0x752,  0x753,  0x754,  0x755,  0x756,  0x757,
-      0x758,  0x75c,  0x75d,  0x75e,  0x75f,  0x760,  0x761,  0x762,  0x763,
-      0x764,  0x765,  0x766,  0x850,  0x851,  0x852,  0x853,  0x855,  0x8a0,
-      0x8a2,  0x8a3,  0x8a4,  0x8a5,  0x8a6,  0x8a7,  0x8a8,  0x8a9,  0x1807,
-      0x1820, 0x1821, 0x1822, 0x1823, 0x1824, 0x1825, 0x1826, 0x1827, 0x1828,
-      0x1829, 0x182a, 0x182b, 0x182c, 0x182d, 0x182e, 0x182f, 0x1830, 0x1831,
-      0x1832, 0x1833, 0x1834, 0x1835, 0x1836, 0x1837, 0x1838, 0x1839, 0x183a,
-      0x183b, 0x183c, 0x183d, 0x183e, 0x183f, 0x1840, 0x1841, 0x1842, 0x1843,
-      0x1844, 0x1845, 0x1846, 0x1847, 0x1848, 0x1849, 0x184a, 0x184b, 0x184c,
-      0x184d, 0x184e, 0x184f, 0x1850, 0x1851, 0x1852, 0x1853, 0x1854, 0x1855,
-      0x1856, 0x1857, 0x1858, 0x1859, 0x185a, 0x185b, 0x185c, 0x185d, 0x185e,
-      0x185f, 0x1860, 0x1861, 0x1862, 0x1863, 0x1864, 0x1865, 0x1866, 0x1867,
-      0x1868, 0x1869, 0x186a, 0x186b, 0x186c, 0x186d, 0x186e, 0x186f, 0x1870,
-      0x1871, 0x1872, 0x1873, 0x1874, 0x1875, 0x1876, 0x1877, 0x1887, 0x1888,
-      0x1889, 0x188a, 0x188b, 0x188c, 0x188d, 0x188e, 0x188f, 0x1890, 0x1891,
-      0x1892, 0x1893, 0x1894, 0x1895, 0x1896, 0x1897, 0x1898, 0x1899, 0x189a,
-      0x189b, 0x189c, 0x189d, 0x189e, 0x189f, 0x18a0, 0x18a1, 0x18a2, 0x18a3,
-      0x18a4, 0x18a5, 0x18a6, 0x18a7, 0x18a8, 0x18aa, 0xa840, 0xa841, 0xa842,
-      0xa843, 0xa844, 0xa845, 0xa846, 0xa847, 0xa848, 0xa849, 0xa84a, 0xa84b,
-      0xa84c, 0xa84d, 0xa84e, 0xa84f, 0xa850, 0xa851, 0xa852, 0xa853, 0xa854,
-      0xa855, 0xa856, 0xa857, 0xa858, 0xa859, 0xa85a, 0xa85b, 0xa85c, 0xa85d,
-      0xa85e, 0xa85f, 0xa860, 0xa861, 0xa862, 0xa863, 0xa864, 0xa865, 0xa866,
-      0xa867, 0xa868, 0xa869, 0xa86a, 0xa86b, 0xa86c, 0xa86d, 0xa86e, 0xa86f,
-      0xa870, 0xa871};
-
-  for (size_t i = 0; i < label.size(); i++) {
-    uint32_t c = label[i];
-    if (c == 0x200c) {
-      if (i > 0) {
-        if (std::binary_search(std::begin(virama), std::end(virama),
-                               label[i - 1])) {
-          return true;
-        }
-      }
-      if ((i == 0) || (i + 1 >= label.size())) {
-        return false;
-      }
-      // we go backward looking for L or D
-      auto is_l_or_d = [](uint32_t code) {
-        return std::binary_search(std::begin(L), std::end(L), code) ||
-               std::binary_search(std::begin(D), std::end(D), code);
-      };
-      auto is_r_or_d = [](uint32_t code) {
-        return std::binary_search(std::begin(R), std::end(R), code) ||
-               std::binary_search(std::begin(D), std::end(D), code);
-      };
-      std::u32string_view before = label.substr(0, i);
-      std::u32string_view after = label.substr(i + 1);
-      return (std::find_if(before.begin(), before.end(), is_l_or_d) !=
-              before.end()) &&
-             (std::find_if(after.begin(), after.end(), is_r_or_d) !=
-              after.end());
-    } else if (c == 0x200d) {
-      if (i > 0) {
-        if (std::binary_search(std::begin(virama), std::end(virama),
-                               label[i - 1])) {
-          return true;
-        }
-      }
-      return false;
-    }
-  }
-
-  // If CheckBidi, and if the domain name is a  Bidi domain name, then the label
-  // must satisfy all six of the numbered conditions in [IDNA2008] RFC 5893,
-  // Section 2.
-
-  // The following rule, consisting of six conditions, applies to labels
-  // in Bidi domain names.  The requirements that this rule satisfies are
-  // described in Section 3.  All of the conditions must be satisfied for
-  // the rule to be satisfied.
-  //
-  //  1.  The first character must be a character with Bidi property L, R,
-  //     or AL.  If it has the R or AL property, it is an RTL label; if it
-  //     has the L property, it is an LTR label.
-  //
-  //  2.  In an RTL label, only characters with the Bidi properties R, AL,
-  //      AN, EN, ES, CS, ET, ON, BN, or NSM are allowed.
-  //
-  //   3.  In an RTL label, the end of the label must be a character with
-  //       Bidi property R, AL, EN, or AN, followed by zero or more
-  //       characters with Bidi property NSM.
-  //
-  //   4.  In an RTL label, if an EN is present, no AN may be present, and
-  //       vice versa.
-  //
-  //  5.  In an LTR label, only characters with the Bidi properties L, EN,
-  //       ES, CS, ET, ON, BN, or NSM are allowed.
-  //
-  //   6.  In an LTR label, the end of the label must be a character with
-  //       Bidi property L or EN, followed by zero or more characters with
-  //       Bidi property NSM.
-
-  size_t last_non_nsm_char = find_last_not_of_nsm(label);
-  if (last_non_nsm_char == std::u32string_view::npos) {
-    return false;
-  }
-
-  // A "Bidi domain name" is a domain name that contains at least one RTL label.
-  // The following rule, consisting of six conditions, applies to labels in Bidi
-  // domain names.
-  if (is_rtl_label(label)) {
-    // The first character must be a character with Bidi property L, R,
-    // or AL. If it has the R or AL property, it is an RTL label; if it
-    // has the L property, it is an LTR label.
-
-    if (find_direction(label[0]) == direction::L) {
-      // Eval as LTR
-
-      // In an LTR label, only characters with the Bidi properties L, EN,
-      // ES, CS, ET, ON, BN, or NSM are allowed.
-      for (size_t i = 0; i < last_non_nsm_char; i++) {
-        const direction d = find_direction(label[i]);
-        if (!(d == direction::L || d == direction::EN || d == direction::ES ||
-              d == direction::CS || d == direction::ET || d == direction::ON ||
-              d == direction::BN || d == direction::NSM)) {
-          return false;
-        }
-
-        if ((i == last_non_nsm_char) &&
-            !(d == direction::L || d == direction::EN)) {
-          return false;
-        }
-      }
-
-      return true;
-
-    } else {
-      // Eval as RTL
-
-      bool has_an = false;
-      bool has_en = false;
-      for (size_t i = 0; i <= last_non_nsm_char; i++) {
-        const direction d = find_direction(label[i]);
-
-        // In an RTL label, if an EN is present, no AN may be present, and vice
-        // versa.
-        if ((d == direction::EN && ((has_en = true) && has_an)) ||
-            (d == direction::AN && ((has_an = true) && has_en))) {
-          return false;
-        }
-
-        if (!(d == direction::R || d == direction::AL || d == direction::AN ||
-              d == direction::EN || d == direction::ES || d == direction::CS ||
-              d == direction::ET || d == direction::ON || d == direction::BN ||
-              d == direction::NSM)) {
-          return false;
-        }
-
-        if (i == last_non_nsm_char &&
-            !(d == direction::R || d == direction::AL || d == direction::AN ||
-              d == direction::EN)) {
-          return false;
-        }
-      }
-
-      return true;
-    }
-  }
-
-  return true;
-}
-
-}  // namespace ada::idna
-/* end file src/validity.cpp */
-/* begin file src/to_ascii.cpp */
-
-#include <algorithm>
-#include <cstdint>
-
-
-namespace ada::idna {
-
-bool constexpr is_ascii(std::u32string_view view) {
-  for (uint32_t c : view) {
-    if (c >= 0x80) {
-      return false;
-    }
-  }
-  return true;
-}
-
-bool constexpr is_ascii(std::string_view view) {
-  for (uint8_t c : view) {
-    if (c >= 0x80) {
-      return false;
-    }
-  }
-  return true;
-}
-
-constexpr static uint8_t is_forbidden_domain_code_point_table[] = {
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
-
-static_assert(sizeof(is_forbidden_domain_code_point_table) == 256);
-
-inline bool is_forbidden_domain_code_point(const char c) noexcept {
-  return is_forbidden_domain_code_point_table[uint8_t(c)];
-}
-
-bool contains_forbidden_domain_code_point(std::string_view view) {
-  return (
-      std::any_of(view.begin(), view.end(), is_forbidden_domain_code_point));
-}
-
-// We return "" on error.
-static std::string from_ascii_to_ascii(std::string_view ut8_string) {
-  static const std::string error = "";
-  // copy and map
-  // we could be more efficient by avoiding the copy when unnecessary.
-  std::string mapped_string = std::string(ut8_string);
-  ascii_map(mapped_string.data(), mapped_string.size());
-  std::string out;
-  size_t label_start = 0;
-
-  while (label_start != mapped_string.size()) {
-    size_t loc_dot = mapped_string.find('.', label_start);
-    bool is_last_label = (loc_dot == std::string_view::npos);
-    size_t label_size = is_last_label ? mapped_string.size() - label_start
-                                      : loc_dot - label_start;
-    size_t label_size_with_dot = is_last_label ? label_size : label_size + 1;
-    std::string_view label_view(mapped_string.data() + label_start, label_size);
-    label_start += label_size_with_dot;
-    if (label_size == 0) {
-      // empty label? Nothing to do.
-    } else if (label_view.starts_with("xn--")) {
-      // The xn-- part is the expensive game.
-      out.append(label_view);
-      std::string_view puny_segment_ascii(
-          out.data() + out.size() - label_view.size() + 4,
-          label_view.size() - 4);
-      std::u32string tmp_buffer;
-      bool is_ok = ada::idna::punycode_to_utf32(puny_segment_ascii, tmp_buffer);
-      if (!is_ok) {
-        return error;
-      }
-      std::u32string post_map = ada::idna::map(tmp_buffer);
-      if (tmp_buffer != post_map) {
-        return error;
-      }
-      std::u32string pre_normal = post_map;
-      normalize(post_map);
-      if (post_map != pre_normal) {
-        return error;
-      }
-      if (post_map.empty()) {
-        return error;
-      }
-      if (!is_label_valid(post_map)) {
-        return error;
-      }
-    } else {
-      out.append(label_view);
-    }
-    if (!is_last_label) {
-      out.push_back('.');
-    }
-  }
-  return out;
-}
-
-// We return "" on error.
-std::string to_ascii(std::string_view ut8_string) {
-  if (is_ascii(ut8_string)) {
-    return from_ascii_to_ascii(ut8_string);
-  }
-  static const std::string error = "";
-  // We convert to UTF-32
-  size_t utf32_length =
-      ada::idna::utf32_length_from_utf8(ut8_string.data(), ut8_string.size());
-  std::u32string utf32(utf32_length, '\0');
-  size_t actual_utf32_length = ada::idna::utf8_to_utf32(
-      ut8_string.data(), ut8_string.size(), utf32.data());
-  if (actual_utf32_length == 0) {
-    return error;
-  }
-  // mapping
-  utf32 = ada::idna::map(utf32);
-  normalize(utf32);
-  std::string out;
-  size_t label_start = 0;
-
-  while (label_start != utf32.size()) {
-    size_t loc_dot = utf32.find('.', label_start);
-    bool is_last_label = (loc_dot == std::string_view::npos);
-    size_t label_size =
-        is_last_label ? utf32.size() - label_start : loc_dot - label_start;
-    size_t label_size_with_dot = is_last_label ? label_size : label_size + 1;
-    std::u32string_view label_view(utf32.data() + label_start, label_size);
-    label_start += label_size_with_dot;
-    if (label_size == 0) {
-      // empty label? Nothing to do.
-    } else if (label_view.starts_with(U"xn--")) {
-      // we do not need to check, e.g., Xn-- because mapping goes to lower case
-      for (char32_t c : label_view) {
-        if (c >= 0x80) {
-          return error;
-        }
-        out += (unsigned char)(c);
-      }
-      std::string_view puny_segment_ascii(
-          out.data() + out.size() - label_view.size() + 4,
-          label_view.size() - 4);
-      std::u32string tmp_buffer;
-      bool is_ok = ada::idna::punycode_to_utf32(puny_segment_ascii, tmp_buffer);
-      if (!is_ok) {
-        return error;
-      }
-      std::u32string post_map = ada::idna::map(tmp_buffer);
-      if (tmp_buffer != post_map) {
-        return error;
-      }
-      std::u32string pre_normal = post_map;
-      normalize(post_map);
-      if (post_map != pre_normal) {
-        return error;
-      }
-      if (post_map.empty()) {
-        return error;
-      }
-      if (!is_label_valid(post_map)) {
-        return error;
-      }
-    } else {
-      // The fast path here is an ascii label.
-      if (is_ascii(label_view)) {
-        // no validation needed.
-        for (char32_t c : label_view) {
-          out += (unsigned char)(c);
-        }
-      } else {
-        // slow path.
-        // first check validity.
-        if (!is_label_valid(label_view)) {
-          return error;
-        }
-        // It is valid! So now we must encode it as punycode...
-        out.append("xn--");
-        bool is_ok = ada::idna::utf32_to_punycode(label_view, out);
-        if (!is_ok) {
-          return error;
-        }
-      }
-    }
-    if (!is_last_label) {
-      out.push_back('.');
-    }
-  }
-  return out;
-}
-}  // namespace ada::idna
-/* end file src/to_ascii.cpp */
-/* begin file src/to_unicode.cpp */
-
-#include <algorithm>
-#include <string>
-
-
-namespace ada::idna {
-std::string to_unicode(std::string_view input) {
-  std::string output;
-  output.reserve(input.size());
-
-  size_t label_start = 0;
-  while (label_start < input.size()) {
-    size_t loc_dot = input.find('.', label_start);
-    bool is_last_label = (loc_dot == std::string_view::npos);
-    size_t label_size =
-        is_last_label ? input.size() - label_start : loc_dot - label_start;
-    auto label_view = std::string_view(input.data() + label_start, label_size);
-
-    if (label_view.starts_with("xn--") && ada::idna::is_ascii(label_view)) {
-      label_view.remove_prefix(4);
-      if (ada::idna::verify_punycode(label_view)) {
-        std::u32string tmp_buffer;
-        if (ada::idna::punycode_to_utf32(label_view, tmp_buffer)) {
-          auto utf8_size = ada::idna::utf8_length_from_utf32(tmp_buffer.data(),
-                                                             tmp_buffer.size());
-          std::string final_utf8(utf8_size, '\0');
-          ada::idna::utf32_to_utf8(tmp_buffer.data(), tmp_buffer.size(),
-                                   final_utf8.data());
-          output.append(final_utf8);
-        } else {
-          // ToUnicode never fails.  If any step fails, then the original input
-          // sequence is returned immediately in that step.
-          output.append(
-              std::string_view(input.data() + label_start, label_size));
-        }
-      } else {
-        output.append(std::string_view(input.data() + label_start, label_size));
-      }
-    } else {
-      output.append(label_view);
-    }
-
-    if (!is_last_label) {
-      output.push_back('.');
-    }
-
-    label_start += label_size + 1;
-  }
-
-  return output;
-}
-}  // namespace ada::idna
-/* end file src/to_unicode.cpp */
-/* begin file src/identifier.cpp */
-
-#include <algorithm>
-#include <array>
-#include <string>
-
-/* begin file src/id_tables.cpp */
-// IDNA  15.1.0
-
-// clang-format off
-#ifndef ADA_IDNA_IDENTIFIER_TABLES_H
-#define ADA_IDNA_IDENTIFIER_TABLES_H
-#include <cstdint>
-
-namespace ada::idna {
-
-const uint32_t id_continue[1344][2] =
-{
-	{48, 57}, {65, 90}, {95, 95}, {97, 122},
-	{170, 170}, {181, 181}, {183, 183}, {186, 186},
-	{192, 214}, {216, 246}, {248, 442}, {443, 443},
-	{444, 447}, {448, 451}, {452, 659}, {660, 660},
-	{661, 687}, {688, 705}, {710, 721}, {736, 740},
-	{748, 748}, {750, 750}, {768, 879}, {880, 883},
-	{884, 884}, {886, 887}, {890, 890}, {891, 893},
-	{895, 895}, {902, 902}, {903, 903}, {904, 906},
-	{908, 908}, {910, 929}, {931, 1013}, {1015, 1153},
-	{1155, 1159}, {1162, 1327}, {1329, 1366}, {1369, 1369},
-	{1376, 1416}, {1425, 1469}, {1471, 1471}, {1473, 1474},
-	{1476, 1477}, {1479, 1479}, {1488, 1514}, {1519, 1522},
-	{1552, 1562}, {1568, 1599}, {1600, 1600}, {1601, 1610},
-	{1611, 1631}, {1632, 1641}, {1646, 1647}, {1648, 1648},
-	{1649, 1747}, {1749, 1749}, {1750, 1756}, {1759, 1764},
-	{1765, 1766}, {1767, 1768}, {1770, 1773}, {1774, 1775},
-	{1776, 1785}, {1786, 1788}, {1791, 1791}, {1808, 1808},
-	{1809, 1809}, {1810, 1839}, {1840, 1866}, {1869, 1957},
-	{1958, 1968}, {1969, 1969}, {1984, 1993}, {1994, 2026},
-	{2027, 2035}, {2036, 2037}, {2042, 2042}, {2045, 2045},
-	{2048, 2069}, {2070, 2073}, {2074, 2074}, {2075, 2083},
-	{2084, 2084}, {2085, 2087}, {2088, 2088}, {2089, 2093},
-	{2112, 2136}, {2137, 2139}, {2144, 2154}, {2160, 2183},
-	{2185, 2190}, {2200, 2207}, {2208, 2248}, {2249, 2249},
-	{2250, 2273}, {2275, 2306}, {2307, 2307}, {2308, 2361},
-	{2362, 2362}, {2363, 2363}, {2364, 2364}, {2365, 2365},
-	{2366, 2368}, {2369, 2376}, {2377, 2380}, {2381, 2381},
-	{2382, 2383}, {2384, 2384}, {2385, 2391}, {2392, 2401},
-	{2402, 2403}, {2406, 2415}, {2417, 2417}, {2418, 2432},
-	{2433, 2433}, {2434, 2435}, {2437, 2444}, {2447, 2448},
-	{2451, 2472}, {2474, 2480}, {2482, 2482}, {2486, 2489},
-	{2492, 2492}, {2493, 2493}, {2494, 2496}, {2497, 2500},
-	{2503, 2504}, {2507, 2508}, {2509, 2509}, {2510, 2510},
-	{2519, 2519}, {2524, 2525}, {2527, 2529}, {2530, 2531},
-	{2534, 2543}, {2544, 2545}, {2556, 2556}, {2558, 2558},
-	{2561, 2562}, {2563, 2563}, {2565, 2570}, {2575, 2576},
-	{2579, 2600}, {2602, 2608}, {2610, 2611}, {2613, 2614},
-	{2616, 2617}, {2620, 2620}, {2622, 2624}, {2625, 2626},
-	{2631, 2632}, {2635, 2637}, {2641, 2641}, {2649, 2652},
-	{2654, 2654}, {2662, 2671}, {2672, 2673}, {2674, 2676},
-	{2677, 2677}, {2689, 2690}, {2691, 2691}, {2693, 2701},
-	{2703, 2705}, {2707, 2728}, {2730, 2736}, {2738, 2739},
-	{2741, 2745}, {2748, 2748}, {2749, 2749}, {2750, 2752},
-	{2753, 2757}, {2759, 2760}, {2761, 2761}, {2763, 2764},
-	{2765, 2765}, {2768, 2768}, {2784, 2785}, {2786, 2787},
-	{2790, 2799}, {2809, 2809}, {2810, 2815}, {2817, 2817},
-	{2818, 2819}, {2821, 2828}, {2831, 2832}, {2835, 2856},
-	{2858, 2864}, {2866, 2867}, {2869, 2873}, {2876, 2876},
-	{2877, 2877}, {2878, 2878}, {2879, 2879}, {2880, 2880},
-	{2881, 2884}, {2887, 2888}, {2891, 2892}, {2893, 2893},
-	{2901, 2902}, {2903, 2903}, {2908, 2909}, {2911, 2913},
-	{2914, 2915}, {2918, 2927}, {2929, 2929}, {2946, 2946},
-	{2947, 2947}, {2949, 2954}, {2958, 2960}, {2962, 2965},
-	{2969, 2970}, {2972, 2972}, {2974, 2975}, {2979, 2980},
-	{2984, 2986}, {2990, 3001}, {3006, 3007}, {3008, 3008},
-	{3009, 3010}, {3014, 3016}, {3018, 3020}, {3021, 3021},
-	{3024, 3024}, {3031, 3031}, {3046, 3055}, {3072, 3072},
-	{3073, 3075}, {3076, 3076}, {3077, 3084}, {3086, 3088},
-	{3090, 3112}, {3114, 3129}, {3132, 3132}, {3133, 3133},
-	{3134, 3136}, {3137, 3140}, {3142, 3144}, {3146, 3149},
-	{3157, 3158}, {3160, 3162}, {3165, 3165}, {3168, 3169},
-	{3170, 3171}, {3174, 3183}, {3200, 3200}, {3201, 3201},
-	{3202, 3203}, {3205, 3212}, {3214, 3216}, {3218, 3240},
-	{3242, 3251}, {3253, 3257}, {3260, 3260}, {3261, 3261},
-	{3262, 3262}, {3263, 3263}, {3264, 3268}, {3270, 3270},
-	{3271, 3272}, {3274, 3275}, {3276, 3277}, {3285, 3286},
-	{3293, 3294}, {3296, 3297}, {3298, 3299}, {3302, 3311},
-	{3313, 3314}, {3315, 3315}, {3328, 3329}, {3330, 3331},
-	{3332, 3340}, {3342, 3344}, {3346, 3386}, {3387, 3388},
-	{3389, 3389}, {3390, 3392}, {3393, 3396}, {3398, 3400},
-	{3402, 3404}, {3405, 3405}, {3406, 3406}, {3412, 3414},
-	{3415, 3415}, {3423, 3425}, {3426, 3427}, {3430, 3439},
-	{3450, 3455}, {3457, 3457}, {3458, 3459}, {3461, 3478},
-	{3482, 3505}, {3507, 3515}, {3517, 3517}, {3520, 3526},
-	{3530, 3530}, {3535, 3537}, {3538, 3540}, {3542, 3542},
-	{3544, 3551}, {3558, 3567}, {3570, 3571}, {3585, 3632},
-	{3633, 3633}, {3634, 3635}, {3636, 3642}, {3648, 3653},
-	{3654, 3654}, {3655, 3662}, {3664, 3673}, {3713, 3714},
-	{3716, 3716}, {3718, 3722}, {3724, 3747}, {3749, 3749},
-	{3751, 3760}, {3761, 3761}, {3762, 3763}, {3764, 3772},
-	{3773, 3773}, {3776, 3780}, {3782, 3782}, {3784, 3790},
-	{3792, 3801}, {3804, 3807}, {3840, 3840}, {3864, 3865},
-	{3872, 3881}, {3893, 3893}, {3895, 3895}, {3897, 3897},
-	{3902, 3903}, {3904, 3911}, {3913, 3948}, {3953, 3966},
-	{3967, 3967}, {3968, 3972}, {3974, 3975}, {3976, 3980},
-	{3981, 3991}, {3993, 4028}, {4038, 4038}, {4096, 4138},
-	{4139, 4140}, {4141, 4144}, {4145, 4145}, {4146, 4151},
-	{4152, 4152}, {4153, 4154}, {4155, 4156}, {4157, 4158},
-	{4159, 4159}, {4160, 4169}, {4176, 4181}, {4182, 4183},
-	{4184, 4185}, {4186, 4189}, {4190, 4192}, {4193, 4193},
-	{4194, 4196}, {4197, 4198}, {4199, 4205}, {4206, 4208},
-	{4209, 4212}, {4213, 4225}, {4226, 4226}, {4227, 4228},
-	{4229, 4230}, {4231, 4236}, {4237, 4237}, {4238, 4238},
-	{4239, 4239}, {4240, 4249}, {4250, 4252}, {4253, 4253},
-	{4256, 4293}, {4295, 4295}, {4301, 4301}, {4304, 4346},
-	{4348, 4348}, {4349, 4351}, {4352, 4680}, {4682, 4685},
-	{4688, 4694}, {4696, 4696}, {4698, 4701}, {4704, 4744},
-	{4746, 4749}, {4752, 4784}, {4786, 4789}, {4792, 4798},
-	{4800, 4800}, {4802, 4805}, {4808, 4822}, {4824, 4880},
-	{4882, 4885}, {4888, 4954}, {4957, 4959}, {4969, 4977},
-	{4992, 5007}, {5024, 5109}, {5112, 5117}, {5121, 5740},
-	{5743, 5759}, {5761, 5786}, {5792, 5866}, {5870, 5872},
-	{5873, 5880}, {5888, 5905}, {5906, 5908}, {5909, 5909},
-	{5919, 5937}, {5938, 5939}, {5940, 5940}, {5952, 5969},
-	{5970, 5971}, {5984, 5996}, {5998, 6000}, {6002, 6003},
-	{6016, 6067}, {6068, 6069}, {6070, 6070}, {6071, 6077},
-	{6078, 6085}, {6086, 6086}, {6087, 6088}, {6089, 6099},
-	{6103, 6103}, {6108, 6108}, {6109, 6109}, {6112, 6121},
-	{6155, 6157}, {6159, 6159}, {6160, 6169}, {6176, 6210},
-	{6211, 6211}, {6212, 6264}, {6272, 6276}, {6277, 6278},
-	{6279, 6312}, {6313, 6313}, {6314, 6314}, {6320, 6389},
-	{6400, 6430}, {6432, 6434}, {6435, 6438}, {6439, 6440},
-	{6441, 6443}, {6448, 6449}, {6450, 6450}, {6451, 6456},
-	{6457, 6459}, {6470, 6479}, {6480, 6509}, {6512, 6516},
-	{6528, 6571}, {6576, 6601}, {6608, 6617}, {6618, 6618},
-	{6656, 6678}, {6679, 6680}, {6681, 6682}, {6683, 6683},
-	{6688, 6740}, {6741, 6741}, {6742, 6742}, {6743, 6743},
-	{6744, 6750}, {6752, 6752}, {6753, 6753}, {6754, 6754},
-	{6755, 6756}, {6757, 6764}, {6765, 6770}, {6771, 6780},
-	{6783, 6783}, {6784, 6793}, {6800, 6809}, {6823, 6823},
-	{6832, 6845}, {6847, 6862}, {6912, 6915}, {6916, 6916},
-	{6917, 6963}, {6964, 6964}, {6965, 6965}, {6966, 6970},
-	{6971, 6971}, {6972, 6972}, {6973, 6977}, {6978, 6978},
-	{6979, 6980}, {6981, 6988}, {6992, 7001}, {7019, 7027},
-	{7040, 7041}, {7042, 7042}, {7043, 7072}, {7073, 7073},
-	{7074, 7077}, {7078, 7079}, {7080, 7081}, {7082, 7082},
-	{7083, 7085}, {7086, 7087}, {7088, 7097}, {7098, 7141},
-	{7142, 7142}, {7143, 7143}, {7144, 7145}, {7146, 7148},
-	{7149, 7149}, {7150, 7150}, {7151, 7153}, {7154, 7155},
-	{7168, 7203}, {7204, 7211}, {7212, 7219}, {7220, 7221},
-	{7222, 7223}, {7232, 7241}, {7245, 7247}, {7248, 7257},
-	{7258, 7287}, {7288, 7293}, {7296, 7304}, {7312, 7354},
-	{7357, 7359}, {7376, 7378}, {7380, 7392}, {7393, 7393},
-	{7394, 7400}, {7401, 7404}, {7405, 7405}, {7406, 7411},
-	{7412, 7412}, {7413, 7414}, {7415, 7415}, {7416, 7417},
-	{7418, 7418}, {7424, 7467}, {7468, 7530}, {7531, 7543},
-	{7544, 7544}, {7545, 7578}, {7579, 7615}, {7616, 7679},
-	{7680, 7957}, {7960, 7965}, {7968, 8005}, {8008, 8013},
-	{8016, 8023}, {8025, 8025}, {8027, 8027}, {8029, 8029},
-	{8031, 8061}, {8064, 8116}, {8118, 8124}, {8126, 8126},
-	{8130, 8132}, {8134, 8140}, {8144, 8147}, {8150, 8155},
-	{8160, 8172}, {8178, 8180}, {8182, 8188}, {8204, 8205},
-	{8255, 8256}, {8276, 8276}, {8305, 8305}, {8319, 8319},
-	{8336, 8348}, {8400, 8412}, {8417, 8417}, {8421, 8432},
-	{8450, 8450}, {8455, 8455}, {8458, 8467}, {8469, 8469},
-	{8472, 8472}, {8473, 8477}, {8484, 8484}, {8486, 8486},
-	{8488, 8488}, {8490, 8493}, {8494, 8494}, {8495, 8500},
-	{8501, 8504}, {8505, 8505}, {8508, 8511}, {8517, 8521},
-	{8526, 8526}, {8544, 8578}, {8579, 8580}, {8581, 8584},
-	{11264, 11387}, {11388, 11389}, {11390, 11492}, {11499, 11502},
-	{11503, 11505}, {11506, 11507}, {11520, 11557}, {11559, 11559},
-	{11565, 11565}, {11568, 11623}, {11631, 11631}, {11647, 11647},
-	{11648, 11670}, {11680, 11686}, {11688, 11694}, {11696, 11702},
-	{11704, 11710}, {11712, 11718}, {11720, 11726}, {11728, 11734},
-	{11736, 11742}, {11744, 11775}, {12293, 12293}, {12294, 12294},
-	{12295, 12295}, {12321, 12329}, {12330, 12333}, {12334, 12335},
-	{12337, 12341}, {12344, 12346}, {12347, 12347}, {12348, 12348},
-	{12353, 12438}, {12441, 12442}, {12443, 12444}, {12445, 12446},
-	{12447, 12447}, {12449, 12538}, {12539, 12539}, {12540, 12542},
-	{12543, 12543}, {12549, 12591}, {12593, 12686}, {12704, 12735},
-	{12784, 12799}, {13312, 19903}, {19968, 40980}, {40981, 40981},
-	{40982, 42124}, {42192, 42231}, {42232, 42237}, {42240, 42507},
-	{42508, 42508}, {42512, 42527}, {42528, 42537}, {42538, 42539},
-	{42560, 42605}, {42606, 42606}, {42607, 42607}, {42612, 42621},
-	{42623, 42623}, {42624, 42651}, {42652, 42653}, {42654, 42655},
-	{42656, 42725}, {42726, 42735}, {42736, 42737}, {42775, 42783},
-	{42786, 42863}, {42864, 42864}, {42865, 42887}, {42888, 42888},
-	{42891, 42894}, {42895, 42895}, {42896, 42954}, {42960, 42961},
-	{42963, 42963}, {42965, 42969}, {42994, 42996}, {42997, 42998},
-	{42999, 42999}, {43000, 43001}, {43002, 43002}, {43003, 43009},
-	{43010, 43010}, {43011, 43013}, {43014, 43014}, {43015, 43018},
-	{43019, 43019}, {43020, 43042}, {43043, 43044}, {43045, 43046},
-	{43047, 43047}, {43052, 43052}, {43072, 43123}, {43136, 43137},
-	{43138, 43187}, {43188, 43203}, {43204, 43205}, {43216, 43225},
-	{43232, 43249}, {43250, 43255}, {43259, 43259}, {43261, 43262},
-	{43263, 43263}, {43264, 43273}, {43274, 43301}, {43302, 43309},
-	{43312, 43334}, {43335, 43345}, {43346, 43347}, {43360, 43388},
-	{43392, 43394}, {43395, 43395}, {43396, 43442}, {43443, 43443},
-	{43444, 43445}, {43446, 43449}, {43450, 43451}, {43452, 43453},
-	{43454, 43456}, {43471, 43471}, {43472, 43481}, {43488, 43492},
-	{43493, 43493}, {43494, 43494}, {43495, 43503}, {43504, 43513},
-	{43514, 43518}, {43520, 43560}, {43561, 43566}, {43567, 43568},
-	{43569, 43570}, {43571, 43572}, {43573, 43574}, {43584, 43586},
-	{43587, 43587}, {43588, 43595}, {43596, 43596}, {43597, 43597},
-	{43600, 43609}, {43616, 43631}, {43632, 43632}, {43633, 43638},
-	{43642, 43642}, {43643, 43643}, {43644, 43644}, {43645, 43645},
-	{43646, 43695}, {43696, 43696}, {43697, 43697}, {43698, 43700},
-	{43701, 43702}, {43703, 43704}, {43705, 43709}, {43710, 43711},
-	{43712, 43712}, {43713, 43713}, {43714, 43714}, {43739, 43740},
-	{43741, 43741}, {43744, 43754}, {43755, 43755}, {43756, 43757},
-	{43758, 43759}, {43762, 43762}, {43763, 43764}, {43765, 43765},
-	{43766, 43766}, {43777, 43782}, {43785, 43790}, {43793, 43798},
-	{43808, 43814}, {43816, 43822}, {43824, 43866}, {43868, 43871},
-	{43872, 43880}, {43881, 43881}, {43888, 43967}, {43968, 44002},
-	{44003, 44004}, {44005, 44005}, {44006, 44007}, {44008, 44008},
-	{44009, 44010}, {44012, 44012}, {44013, 44013}, {44016, 44025},
-	{44032, 55203}, {55216, 55238}, {55243, 55291}, {63744, 64109},
-	{64112, 64217}, {64256, 64262}, {64275, 64279}, {64285, 64285},
-	{64286, 64286}, {64287, 64296}, {64298, 64310}, {64312, 64316},
-	{64318, 64318}, {64320, 64321}, {64323, 64324}, {64326, 64433},
-	{64467, 64829}, {64848, 64911}, {64914, 64967}, {65008, 65019},
-	{65024, 65039}, {65056, 65071}, {65075, 65076}, {65101, 65103},
-	{65136, 65140}, {65142, 65276}, {65296, 65305}, {65313, 65338},
-	{65343, 65343}, {65345, 65370}, {65381, 65381}, {65382, 65391},
-	{65392, 65392}, {65393, 65437}, {65438, 65439}, {65440, 65470},
-	{65474, 65479}, {65482, 65487}, {65490, 65495}, {65498, 65500},
-	{65536, 65547}, {65549, 65574}, {65576, 65594}, {65596, 65597},
-	{65599, 65613}, {65616, 65629}, {65664, 65786}, {65856, 65908},
-	{66045, 66045}, {66176, 66204}, {66208, 66256}, {66272, 66272},
-	{66304, 66335}, {66349, 66368}, {66369, 66369}, {66370, 66377},
-	{66378, 66378}, {66384, 66421}, {66422, 66426}, {66432, 66461},
-	{66464, 66499}, {66504, 66511}, {66513, 66517}, {66560, 66639},
-	{66640, 66717}, {66720, 66729}, {66736, 66771}, {66776, 66811},
-	{66816, 66855}, {66864, 66915}, {66928, 66938}, {66940, 66954},
-	{66956, 66962}, {66964, 66965}, {66967, 66977}, {66979, 66993},
-	{66995, 67001}, {67003, 67004}, {67072, 67382}, {67392, 67413},
-	{67424, 67431}, {67456, 67461}, {67463, 67504}, {67506, 67514},
-	{67584, 67589}, {67592, 67592}, {67594, 67637}, {67639, 67640},
-	{67644, 67644}, {67647, 67669}, {67680, 67702}, {67712, 67742},
-	{67808, 67826}, {67828, 67829}, {67840, 67861}, {67872, 67897},
-	{67968, 68023}, {68030, 68031}, {68096, 68096}, {68097, 68099},
-	{68101, 68102}, {68108, 68111}, {68112, 68115}, {68117, 68119},
-	{68121, 68149}, {68152, 68154}, {68159, 68159}, {68192, 68220},
-	{68224, 68252}, {68288, 68295}, {68297, 68324}, {68325, 68326},
-	{68352, 68405}, {68416, 68437}, {68448, 68466}, {68480, 68497},
-	{68608, 68680}, {68736, 68786}, {68800, 68850}, {68864, 68899},
-	{68900, 68903}, {68912, 68921}, {69248, 69289}, {69291, 69292},
-	{69296, 69297}, {69373, 69375}, {69376, 69404}, {69415, 69415},
-	{69424, 69445}, {69446, 69456}, {69488, 69505}, {69506, 69509},
-	{69552, 69572}, {69600, 69622}, {69632, 69632}, {69633, 69633},
-	{69634, 69634}, {69635, 69687}, {69688, 69702}, {69734, 69743},
-	{69744, 69744}, {69745, 69746}, {69747, 69748}, {69749, 69749},
-	{69759, 69761}, {69762, 69762}, {69763, 69807}, {69808, 69810},
-	{69811, 69814}, {69815, 69816}, {69817, 69818}, {69826, 69826},
-	{69840, 69864}, {69872, 69881}, {69888, 69890}, {69891, 69926},
-	{69927, 69931}, {69932, 69932}, {69933, 69940}, {69942, 69951},
-	{69956, 69956}, {69957, 69958}, {69959, 69959}, {69968, 70002},
-	{70003, 70003}, {70006, 70006}, {70016, 70017}, {70018, 70018},
-	{70019, 70066}, {70067, 70069}, {70070, 70078}, {70079, 70080},
-	{70081, 70084}, {70089, 70092}, {70094, 70094}, {70095, 70095},
-	{70096, 70105}, {70106, 70106}, {70108, 70108}, {70144, 70161},
-	{70163, 70187}, {70188, 70190}, {70191, 70193}, {70194, 70195},
-	{70196, 70196}, {70197, 70197}, {70198, 70199}, {70206, 70206},
-	{70207, 70208}, {70209, 70209}, {70272, 70278}, {70280, 70280},
-	{70282, 70285}, {70287, 70301}, {70303, 70312}, {70320, 70366},
-	{70367, 70367}, {70368, 70370}, {70371, 70378}, {70384, 70393},
-	{70400, 70401}, {70402, 70403}, {70405, 70412}, {70415, 70416},
-	{70419, 70440}, {70442, 70448}, {70450, 70451}, {70453, 70457},
-	{70459, 70460}, {70461, 70461}, {70462, 70463}, {70464, 70464},
-	{70465, 70468}, {70471, 70472}, {70475, 70477}, {70480, 70480},
-	{70487, 70487}, {70493, 70497}, {70498, 70499}, {70502, 70508},
-	{70512, 70516}, {70656, 70708}, {70709, 70711}, {70712, 70719},
-	{70720, 70721}, {70722, 70724}, {70725, 70725}, {70726, 70726},
-	{70727, 70730}, {70736, 70745}, {70750, 70750}, {70751, 70753},
-	{70784, 70831}, {70832, 70834}, {70835, 70840}, {70841, 70841},
-	{70842, 70842}, {70843, 70846}, {70847, 70848}, {70849, 70849},
-	{70850, 70851}, {70852, 70853}, {70855, 70855}, {70864, 70873},
-	{71040, 71086}, {71087, 71089}, {71090, 71093}, {71096, 71099},
-	{71100, 71101}, {71102, 71102}, {71103, 71104}, {71128, 71131},
-	{71132, 71133}, {71168, 71215}, {71216, 71218}, {71219, 71226},
-	{71227, 71228}, {71229, 71229}, {71230, 71230}, {71231, 71232},
-	{71236, 71236}, {71248, 71257}, {71296, 71338}, {71339, 71339},
-	{71340, 71340}, {71341, 71341}, {71342, 71343}, {71344, 71349},
-	{71350, 71350}, {71351, 71351}, {71352, 71352}, {71360, 71369},
-	{71424, 71450}, {71453, 71455}, {71456, 71457}, {71458, 71461},
-	{71462, 71462}, {71463, 71467}, {71472, 71481}, {71488, 71494},
-	{71680, 71723}, {71724, 71726}, {71727, 71735}, {71736, 71736},
-	{71737, 71738}, {71840, 71903}, {71904, 71913}, {71935, 71942},
-	{71945, 71945}, {71948, 71955}, {71957, 71958}, {71960, 71983},
-	{71984, 71989}, {71991, 71992}, {71995, 71996}, {71997, 71997},
-	{71998, 71998}, {71999, 71999}, {72000, 72000}, {72001, 72001},
-	{72002, 72002}, {72003, 72003}, {72016, 72025}, {72096, 72103},
-	{72106, 72144}, {72145, 72147}, {72148, 72151}, {72154, 72155},
-	{72156, 72159}, {72160, 72160}, {72161, 72161}, {72163, 72163},
-	{72164, 72164}, {72192, 72192}, {72193, 72202}, {72203, 72242},
-	{72243, 72248}, {72249, 72249}, {72250, 72250}, {72251, 72254},
-	{72263, 72263}, {72272, 72272}, {72273, 72278}, {72279, 72280},
-	{72281, 72283}, {72284, 72329}, {72330, 72342}, {72343, 72343},
-	{72344, 72345}, {72349, 72349}, {72368, 72440}, {72704, 72712},
-	{72714, 72750}, {72751, 72751}, {72752, 72758}, {72760, 72765},
-	{72766, 72766}, {72767, 72767}, {72768, 72768}, {72784, 72793},
-	{72818, 72847}, {72850, 72871}, {72873, 72873}, {72874, 72880},
-	{72881, 72881}, {72882, 72883}, {72884, 72884}, {72885, 72886},
-	{72960, 72966}, {72968, 72969}, {72971, 73008}, {73009, 73014},
-	{73018, 73018}, {73020, 73021}, {73023, 73029}, {73030, 73030},
-	{73031, 73031}, {73040, 73049}, {73056, 73061}, {73063, 73064},
-	{73066, 73097}, {73098, 73102}, {73104, 73105}, {73107, 73108},
-	{73109, 73109}, {73110, 73110}, {73111, 73111}, {73112, 73112},
-	{73120, 73129}, {73440, 73458}, {73459, 73460}, {73461, 73462},
-	{73472, 73473}, {73474, 73474}, {73475, 73475}, {73476, 73488},
-	{73490, 73523}, {73524, 73525}, {73526, 73530}, {73534, 73535},
-	{73536, 73536}, {73537, 73537}, {73538, 73538}, {73552, 73561},
-	{73648, 73648}, {73728, 74649}, {74752, 74862}, {74880, 75075},
-	{77712, 77808}, {77824, 78895}, {78912, 78912}, {78913, 78918},
-	{78919, 78933}, {82944, 83526}, {92160, 92728}, {92736, 92766},
-	{92768, 92777}, {92784, 92862}, {92864, 92873}, {92880, 92909},
-	{92912, 92916}, {92928, 92975}, {92976, 92982}, {92992, 92995},
-	{93008, 93017}, {93027, 93047}, {93053, 93071}, {93760, 93823},
-	{93952, 94026}, {94031, 94031}, {94032, 94032}, {94033, 94087},
-	{94095, 94098}, {94099, 94111}, {94176, 94177}, {94179, 94179},
-	{94180, 94180}, {94192, 94193}, {94208, 100343}, {100352, 101589},
-	{101632, 101640}, {110576, 110579}, {110581, 110587}, {110589, 110590},
-	{110592, 110882}, {110898, 110898}, {110928, 110930}, {110933, 110933},
-	{110948, 110951}, {110960, 111355}, {113664, 113770}, {113776, 113788},
-	{113792, 113800}, {113808, 113817}, {113821, 113822}, {118528, 118573},
-	{118576, 118598}, {119141, 119142}, {119143, 119145}, {119149, 119154},
-	{119163, 119170}, {119173, 119179}, {119210, 119213}, {119362, 119364},
-	{119808, 119892}, {119894, 119964}, {119966, 119967}, {119970, 119970},
-	{119973, 119974}, {119977, 119980}, {119982, 119993}, {119995, 119995},
-	{119997, 120003}, {120005, 120069}, {120071, 120074}, {120077, 120084},
-	{120086, 120092}, {120094, 120121}, {120123, 120126}, {120128, 120132},
-	{120134, 120134}, {120138, 120144}, {120146, 120485}, {120488, 120512},
-	{120514, 120538}, {120540, 120570}, {120572, 120596}, {120598, 120628},
-	{120630, 120654}, {120656, 120686}, {120688, 120712}, {120714, 120744},
-	{120746, 120770}, {120772, 120779}, {120782, 120831}, {121344, 121398},
-	{121403, 121452}, {121461, 121461}, {121476, 121476}, {121499, 121503},
-	{121505, 121519}, {122624, 122633}, {122634, 122634}, {122635, 122654},
-	{122661, 122666}, {122880, 122886}, {122888, 122904}, {122907, 122913},
-	{122915, 122916}, {122918, 122922}, {122928, 122989}, {123023, 123023},
-	{123136, 123180}, {123184, 123190}, {123191, 123197}, {123200, 123209},
-	{123214, 123214}, {123536, 123565}, {123566, 123566}, {123584, 123627},
-	{123628, 123631}, {123632, 123641}, {124112, 124138}, {124139, 124139},
-	{124140, 124143}, {124144, 124153}, {124896, 124902}, {124904, 124907},
-	{124909, 124910}, {124912, 124926}, {124928, 125124}, {125136, 125142},
-	{125184, 125251}, {125252, 125258}, {125259, 125259}, {125264, 125273},
-	{126464, 126467}, {126469, 126495}, {126497, 126498}, {126500, 126500},
-	{126503, 126503}, {126505, 126514}, {126516, 126519}, {126521, 126521},
-	{126523, 126523}, {126530, 126530}, {126535, 126535}, {126537, 126537},
-	{126539, 126539}, {126541, 126543}, {126545, 126546}, {126548, 126548},
-	{126551, 126551}, {126553, 126553}, {126555, 126555}, {126557, 126557},
-	{126559, 126559}, {126561, 126562}, {126564, 126564}, {126567, 126570},
-	{126572, 126578}, {126580, 126583}, {126585, 126588}, {126590, 126590},
-	{126592, 126601}, {126603, 126619}, {126625, 126627}, {126629, 126633},
-	{126635, 126651}, {130032, 130041}, {131072, 173791}, {173824, 177977},
-	{177984, 178205}, {178208, 183969}, {183984, 191456}, {191472, 192093},
-	{194560, 195101}, {196608, 201546}, {201552, 205743}, {917760, 917999}
-};
-const uint32_t id_start[740][2] =
-{
-	{65, 90}, {97, 122}, {170, 170}, {181, 181},
-	{186, 186}, {192, 214}, {216, 246}, {248, 442},
-	{443, 443}, {444, 447}, {448, 451}, {452, 659},
-	{660, 660}, {661, 687}, {688, 705}, {710, 721},
-	{736, 740}, {748, 748}, {750, 750}, {880, 883},
-	{884, 884}, {886, 887}, {890, 890}, {891, 893},
-	{895, 895}, {902, 902}, {904, 906}, {908, 908},
-	{910, 929}, {931, 1013}, {1015, 1153}, {1162, 1327},
-	{1329, 1366}, {1369, 1369}, {1376, 1416}, {1488, 1514},
-	{1519, 1522}, {1568, 1599}, {1600, 1600}, {1601, 1610},
-	{1646, 1647}, {1649, 1747}, {1749, 1749}, {1765, 1766},
-	{1774, 1775}, {1786, 1788}, {1791, 1791}, {1808, 1808},
-	{1810, 1839}, {1869, 1957}, {1969, 1969}, {1994, 2026},
-	{2036, 2037}, {2042, 2042}, {2048, 2069}, {2074, 2074},
-	{2084, 2084}, {2088, 2088}, {2112, 2136}, {2144, 2154},
-	{2160, 2183}, {2185, 2190}, {2208, 2248}, {2249, 2249},
-	{2308, 2361}, {2365, 2365}, {2384, 2384}, {2392, 2401},
-	{2417, 2417}, {2418, 2432}, {2437, 2444}, {2447, 2448},
-	{2451, 2472}, {2474, 2480}, {2482, 2482}, {2486, 2489},
-	{2493, 2493}, {2510, 2510}, {2524, 2525}, {2527, 2529},
-	{2544, 2545}, {2556, 2556}, {2565, 2570}, {2575, 2576},
-	{2579, 2600}, {2602, 2608}, {2610, 2611}, {2613, 2614},
-	{2616, 2617}, {2649, 2652}, {2654, 2654}, {2674, 2676},
-	{2693, 2701}, {2703, 2705}, {2707, 2728}, {2730, 2736},
-	{2738, 2739}, {2741, 2745}, {2749, 2749}, {2768, 2768},
-	{2784, 2785}, {2809, 2809}, {2821, 2828}, {2831, 2832},
-	{2835, 2856}, {2858, 2864}, {2866, 2867}, {2869, 2873},
-	{2877, 2877}, {2908, 2909}, {2911, 2913}, {2929, 2929},
-	{2947, 2947}, {2949, 2954}, {2958, 2960}, {2962, 2965},
-	{2969, 2970}, {2972, 2972}, {2974, 2975}, {2979, 2980},
-	{2984, 2986}, {2990, 3001}, {3024, 3024}, {3077, 3084},
-	{3086, 3088}, {3090, 3112}, {3114, 3129}, {3133, 3133},
-	{3160, 3162}, {3165, 3165}, {3168, 3169}, {3200, 3200},
-	{3205, 3212}, {3214, 3216}, {3218, 3240}, {3242, 3251},
-	{3253, 3257}, {3261, 3261}, {3293, 3294}, {3296, 3297},
-	{3313, 3314}, {3332, 3340}, {3342, 3344}, {3346, 3386},
-	{3389, 3389}, {3406, 3406}, {3412, 3414}, {3423, 3425},
-	{3450, 3455}, {3461, 3478}, {3482, 3505}, {3507, 3515},
-	{3517, 3517}, {3520, 3526}, {3585, 3632}, {3634, 3635},
-	{3648, 3653}, {3654, 3654}, {3713, 3714}, {3716, 3716},
-	{3718, 3722}, {3724, 3747}, {3749, 3749}, {3751, 3760},
-	{3762, 3763}, {3773, 3773}, {3776, 3780}, {3782, 3782},
-	{3804, 3807}, {3840, 3840}, {3904, 3911}, {3913, 3948},
-	{3976, 3980}, {4096, 4138}, {4159, 4159}, {4176, 4181},
-	{4186, 4189}, {4193, 4193}, {4197, 4198}, {4206, 4208},
-	{4213, 4225}, {4238, 4238}, {4256, 4293}, {4295, 4295},
-	{4301, 4301}, {4304, 4346}, {4348, 4348}, {4349, 4351},
-	{4352, 4680}, {4682, 4685}, {4688, 4694}, {4696, 4696},
-	{4698, 4701}, {4704, 4744}, {4746, 4749}, {4752, 4784},
-	{4786, 4789}, {4792, 4798}, {4800, 4800}, {4802, 4805},
-	{4808, 4822}, {4824, 4880}, {4882, 4885}, {4888, 4954},
-	{4992, 5007}, {5024, 5109}, {5112, 5117}, {5121, 5740},
-	{5743, 5759}, {5761, 5786}, {5792, 5866}, {5870, 5872},
-	{5873, 5880}, {5888, 5905}, {5919, 5937}, {5952, 5969},
-	{5984, 5996}, {5998, 6000}, {6016, 6067}, {6103, 6103},
-	{6108, 6108}, {6176, 6210}, {6211, 6211}, {6212, 6264},
-	{6272, 6276}, {6277, 6278}, {6279, 6312}, {6314, 6314},
-	{6320, 6389}, {6400, 6430}, {6480, 6509}, {6512, 6516},
-	{6528, 6571}, {6576, 6601}, {6656, 6678}, {6688, 6740},
-	{6823, 6823}, {6917, 6963}, {6981, 6988}, {7043, 7072},
-	{7086, 7087}, {7098, 7141}, {7168, 7203}, {7245, 7247},
-	{7258, 7287}, {7288, 7293}, {7296, 7304}, {7312, 7354},
-	{7357, 7359}, {7401, 7404}, {7406, 7411}, {7413, 7414},
-	{7418, 7418}, {7424, 7467}, {7468, 7530}, {7531, 7543},
-	{7544, 7544}, {7545, 7578}, {7579, 7615}, {7680, 7957},
-	{7960, 7965}, {7968, 8005}, {8008, 8013}, {8016, 8023},
-	{8025, 8025}, {8027, 8027}, {8029, 8029}, {8031, 8061},
-	{8064, 8116}, {8118, 8124}, {8126, 8126}, {8130, 8132},
-	{8134, 8140}, {8144, 8147}, {8150, 8155}, {8160, 8172},
-	{8178, 8180}, {8182, 8188}, {8305, 8305}, {8319, 8319},
-	{8336, 8348}, {8450, 8450}, {8455, 8455}, {8458, 8467},
-	{8469, 8469}, {8472, 8472}, {8473, 8477}, {8484, 8484},
-	{8486, 8486}, {8488, 8488}, {8490, 8493}, {8494, 8494},
-	{8495, 8500}, {8501, 8504}, {8505, 8505}, {8508, 8511},
-	{8517, 8521}, {8526, 8526}, {8544, 8578}, {8579, 8580},
-	{8581, 8584}, {11264, 11387}, {11388, 11389}, {11390, 11492},
-	{11499, 11502}, {11506, 11507}, {11520, 11557}, {11559, 11559},
-	{11565, 11565}, {11568, 11623}, {11631, 11631}, {11648, 11670},
-	{11680, 11686}, {11688, 11694}, {11696, 11702}, {11704, 11710},
-	{11712, 11718}, {11720, 11726}, {11728, 11734}, {11736, 11742},
-	{12293, 12293}, {12294, 12294}, {12295, 12295}, {12321, 12329},
-	{12337, 12341}, {12344, 12346}, {12347, 12347}, {12348, 12348},
-	{12353, 12438}, {12443, 12444}, {12445, 12446}, {12447, 12447},
-	{12449, 12538}, {12540, 12542}, {12543, 12543}, {12549, 12591},
-	{12593, 12686}, {12704, 12735}, {12784, 12799}, {13312, 19903},
-	{19968, 40980}, {40981, 40981}, {40982, 42124}, {42192, 42231},
-	{42232, 42237}, {42240, 42507}, {42508, 42508}, {42512, 42527},
-	{42538, 42539}, {42560, 42605}, {42606, 42606}, {42623, 42623},
-	{42624, 42651}, {42652, 42653}, {42656, 42725}, {42726, 42735},
-	{42775, 42783}, {42786, 42863}, {42864, 42864}, {42865, 42887},
-	{42888, 42888}, {42891, 42894}, {42895, 42895}, {42896, 42954},
-	{42960, 42961}, {42963, 42963}, {42965, 42969}, {42994, 42996},
-	{42997, 42998}, {42999, 42999}, {43000, 43001}, {43002, 43002},
-	{43003, 43009}, {43011, 43013}, {43015, 43018}, {43020, 43042},
-	{43072, 43123}, {43138, 43187}, {43250, 43255}, {43259, 43259},
-	{43261, 43262}, {43274, 43301}, {43312, 43334}, {43360, 43388},
-	{43396, 43442}, {43471, 43471}, {43488, 43492}, {43494, 43494},
-	{43495, 43503}, {43514, 43518}, {43520, 43560}, {43584, 43586},
-	{43588, 43595}, {43616, 43631}, {43632, 43632}, {43633, 43638},
-	{43642, 43642}, {43646, 43695}, {43697, 43697}, {43701, 43702},
-	{43705, 43709}, {43712, 43712}, {43714, 43714}, {43739, 43740},
-	{43741, 43741}, {43744, 43754}, {43762, 43762}, {43763, 43764},
-	{43777, 43782}, {43785, 43790}, {43793, 43798}, {43808, 43814},
-	{43816, 43822}, {43824, 43866}, {43868, 43871}, {43872, 43880},
-	{43881, 43881}, {43888, 43967}, {43968, 44002}, {44032, 55203},
-	{55216, 55238}, {55243, 55291}, {63744, 64109}, {64112, 64217},
-	{64256, 64262}, {64275, 64279}, {64285, 64285}, {64287, 64296},
-	{64298, 64310}, {64312, 64316}, {64318, 64318}, {64320, 64321},
-	{64323, 64324}, {64326, 64433}, {64467, 64829}, {64848, 64911},
-	{64914, 64967}, {65008, 65019}, {65136, 65140}, {65142, 65276},
-	{65313, 65338}, {65345, 65370}, {65382, 65391}, {65392, 65392},
-	{65393, 65437}, {65438, 65439}, {65440, 65470}, {65474, 65479},
-	{65482, 65487}, {65490, 65495}, {65498, 65500}, {65536, 65547},
-	{65549, 65574}, {65576, 65594}, {65596, 65597}, {65599, 65613},
-	{65616, 65629}, {65664, 65786}, {65856, 65908}, {66176, 66204},
-	{66208, 66256}, {66304, 66335}, {66349, 66368}, {66369, 66369},
-	{66370, 66377}, {66378, 66378}, {66384, 66421}, {66432, 66461},
-	{66464, 66499}, {66504, 66511}, {66513, 66517}, {66560, 66639},
-	{66640, 66717}, {66736, 66771}, {66776, 66811}, {66816, 66855},
-	{66864, 66915}, {66928, 66938}, {66940, 66954}, {66956, 66962},
-	{66964, 66965}, {66967, 66977}, {66979, 66993}, {66995, 67001},
-	{67003, 67004}, {67072, 67382}, {67392, 67413}, {67424, 67431},
-	{67456, 67461}, {67463, 67504}, {67506, 67514}, {67584, 67589},
-	{67592, 67592}, {67594, 67637}, {67639, 67640}, {67644, 67644},
-	{67647, 67669}, {67680, 67702}, {67712, 67742}, {67808, 67826},
-	{67828, 67829}, {67840, 67861}, {67872, 67897}, {67968, 68023},
-	{68030, 68031}, {68096, 68096}, {68112, 68115}, {68117, 68119},
-	{68121, 68149}, {68192, 68220}, {68224, 68252}, {68288, 68295},
-	{68297, 68324}, {68352, 68405}, {68416, 68437}, {68448, 68466},
-	{68480, 68497}, {68608, 68680}, {68736, 68786}, {68800, 68850},
-	{68864, 68899}, {69248, 69289}, {69296, 69297}, {69376, 69404},
-	{69415, 69415}, {69424, 69445}, {69488, 69505}, {69552, 69572},
-	{69600, 69622}, {69635, 69687}, {69745, 69746}, {69749, 69749},
-	{69763, 69807}, {69840, 69864}, {69891, 69926}, {69956, 69956},
-	{69959, 69959}, {69968, 70002}, {70006, 70006}, {70019, 70066},
-	{70081, 70084}, {70106, 70106}, {70108, 70108}, {70144, 70161},
-	{70163, 70187}, {70207, 70208}, {70272, 70278}, {70280, 70280},
-	{70282, 70285}, {70287, 70301}, {70303, 70312}, {70320, 70366},
-	{70405, 70412}, {70415, 70416}, {70419, 70440}, {70442, 70448},
-	{70450, 70451}, {70453, 70457}, {70461, 70461}, {70480, 70480},
-	{70493, 70497}, {70656, 70708}, {70727, 70730}, {70751, 70753},
-	{70784, 70831}, {70852, 70853}, {70855, 70855}, {71040, 71086},
-	{71128, 71131}, {71168, 71215}, {71236, 71236}, {71296, 71338},
-	{71352, 71352}, {71424, 71450}, {71488, 71494}, {71680, 71723},
-	{71840, 71903}, {71935, 71942}, {71945, 71945}, {71948, 71955},
-	{71957, 71958}, {71960, 71983}, {71999, 71999}, {72001, 72001},
-	{72096, 72103}, {72106, 72144}, {72161, 72161}, {72163, 72163},
-	{72192, 72192}, {72203, 72242}, {72250, 72250}, {72272, 72272},
-	{72284, 72329}, {72349, 72349}, {72368, 72440}, {72704, 72712},
-	{72714, 72750}, {72768, 72768}, {72818, 72847}, {72960, 72966},
-	{72968, 72969}, {72971, 73008}, {73030, 73030}, {73056, 73061},
-	{73063, 73064}, {73066, 73097}, {73112, 73112}, {73440, 73458},
-	{73474, 73474}, {73476, 73488}, {73490, 73523}, {73648, 73648},
-	{73728, 74649}, {74752, 74862}, {74880, 75075}, {77712, 77808},
-	{77824, 78895}, {78913, 78918}, {82944, 83526}, {92160, 92728},
-	{92736, 92766}, {92784, 92862}, {92880, 92909}, {92928, 92975},
-	{92992, 92995}, {93027, 93047}, {93053, 93071}, {93760, 93823},
-	{93952, 94026}, {94032, 94032}, {94099, 94111}, {94176, 94177},
-	{94179, 94179}, {94208, 100343}, {100352, 101589}, {101632, 101640},
-	{110576, 110579}, {110581, 110587}, {110589, 110590}, {110592, 110882},
-	{110898, 110898}, {110928, 110930}, {110933, 110933}, {110948, 110951},
-	{110960, 111355}, {113664, 113770}, {113776, 113788}, {113792, 113800},
-	{113808, 113817}, {119808, 119892}, {119894, 119964}, {119966, 119967},
-	{119970, 119970}, {119973, 119974}, {119977, 119980}, {119982, 119993},
-	{119995, 119995}, {119997, 120003}, {120005, 120069}, {120071, 120074},
-	{120077, 120084}, {120086, 120092}, {120094, 120121}, {120123, 120126},
-	{120128, 120132}, {120134, 120134}, {120138, 120144}, {120146, 120485},
-	{120488, 120512}, {120514, 120538}, {120540, 120570}, {120572, 120596},
-	{120598, 120628}, {120630, 120654}, {120656, 120686}, {120688, 120712},
-	{120714, 120744}, {120746, 120770}, {120772, 120779}, {122624, 122633},
-	{122634, 122634}, {122635, 122654}, {122661, 122666}, {122928, 122989},
-	{123136, 123180}, {123191, 123197}, {123214, 123214}, {123536, 123565},
-	{123584, 123627}, {124112, 124138}, {124139, 124139}, {124896, 124902},
-	{124904, 124907}, {124909, 124910}, {124912, 124926}, {124928, 125124},
-	{125184, 125251}, {125259, 125259}, {126464, 126467}, {126469, 126495},
-	{126497, 126498}, {126500, 126500}, {126503, 126503}, {126505, 126514},
-	{126516, 126519}, {126521, 126521}, {126523, 126523}, {126530, 126530},
-	{126535, 126535}, {126537, 126537}, {126539, 126539}, {126541, 126543},
-	{126545, 126546}, {126548, 126548}, {126551, 126551}, {126553, 126553},
-	{126555, 126555}, {126557, 126557}, {126559, 126559}, {126561, 126562},
-	{126564, 126564}, {126567, 126570}, {126572, 126578}, {126580, 126583},
-	{126585, 126588}, {126590, 126590}, {126592, 126601}, {126603, 126619},
-	{126625, 126627}, {126629, 126633}, {126635, 126651}, {131072, 173791},
-	{173824, 177977}, {177984, 178205}, {178208, 183969}, {183984, 191456},
-	{191472, 192093}, {194560, 195101}, {196608, 201546}, {201552, 205743}
-};
-
-
-} // namespace ada::idna
-#endif // ADA_IDNA_IDENTIFIER_TABLES_H
-
-/* end file src/id_tables.cpp */
-
-namespace ada::idna {
-// return 0xffffffff in case of error
-// We do not fully validate the input
-uint32_t get_first_code_point(std::string_view input) {
-  constexpr uint32_t error = 0xffffffff;
-  // Check if the input is empty
-  if (input.empty()) {
-    return error;
-  }
-
-  uint32_t code_point = 0;
-  size_t number_bytes = 0;
-  unsigned char first_byte = input[0];
-
-  if ((first_byte & 0x80) == 0) {
-    // 1-byte character (ASCII)
-    return first_byte;
-  } else if ((first_byte & 0xE0) == 0xC0) {
-    // 2-byte character
-    code_point = first_byte & 0x1F;
-    number_bytes = 2;
-  } else if ((first_byte & 0xF0) == 0xE0) {
-    // 3-byte character
-    code_point = first_byte & 0x0F;
-    number_bytes = 3;
-  } else if ((first_byte & 0xF8) == 0xF0) {
-    // 4-byte character
-    code_point = first_byte & 0x07;
-    number_bytes = 4;
-  } else {
-    return error;
-  }
-
-  // Decode the remaining bytes
-  for (size_t i = 1; i < number_bytes; ++i) {
-    if (i >= input.size()) {
-      return error;
-    }
-    unsigned char byte = input[i];
-    if ((byte & 0xC0) != 0x80) {
-      return error;
-    }
-    code_point = (code_point << 6) | (byte & 0x3F);
-  }
-  return code_point;
-}
-
-bool is_ascii_letter(char32_t c) {
-  return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
-}
-
-bool is_ascii_letter_or_digit(char32_t c) {
-  return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
-         (c >= '0' && c <= '9');
-}
-
-bool valid_name_code_point(char32_t code_point, bool first) {
-  // https://tc39.es/ecma262/#prod-IdentifierStart
-  // Fast paths:
-  if (first &&
-      (code_point == '$' || code_point == '_' || is_ascii_letter(code_point))) {
-    return true;
-  }
-  if (!first && (code_point == '$' || is_ascii_letter_or_digit(code_point))) {
-    return true;
-  }
-  // Slow path...
-  if (code_point == 0xffffffff) {
-    return false;  // minimal error handling
-  }
-  if (first) {
-    auto iter = std::lower_bound(
-        std::begin(ada::idna::id_start), std::end(ada::idna::id_start),
-        code_point, [](const uint32_t* range, uint32_t code_point) {
-          return range[1] < code_point;
-        });
-    return iter != std::end(id_start) && code_point >= (*iter)[0];
-  } else {
-    auto iter = std::lower_bound(
-        std::begin(id_continue), std::end(id_continue), code_point,
-        [](const uint32_t* range, uint32_t code_point) {
-          return range[1] < code_point;
-        });
-    return iter != std::end(id_start) && code_point >= (*iter)[0];
-  }
-}
-}  // namespace ada::idna
-/* end file src/identifier.cpp */
-/* end file src/idna.cpp */
-/* end file src/ada_idna.cpp */
-ADA_POP_DISABLE_WARNINGS
-
-#include <algorithm>
-#if ADA_NEON
-#include <arm_neon.h>
-#elif ADA_SSE2
-#include <emmintrin.h>
-#endif
-
-namespace ada::unicode {
-
-constexpr bool is_tabs_or_newline(char c) noexcept {
-  return c == '\r' || c == '\n' || c == '\t';
-}
-
-constexpr uint64_t broadcast(uint8_t v) noexcept {
-  return 0x101010101010101ull * v;
-}
-
-constexpr bool to_lower_ascii(char* input, size_t length) noexcept {
-  uint64_t broadcast_80 = broadcast(0x80);
-  uint64_t broadcast_Ap = broadcast(128 - 'A');
-  uint64_t broadcast_Zp = broadcast(128 - 'Z' - 1);
-  uint64_t non_ascii = 0;
-  size_t i = 0;
-
-  for (; i + 7 < length; i += 8) {
-    uint64_t word{};
-    memcpy(&word, input + i, sizeof(word));
-    non_ascii |= (word & broadcast_80);
-    word ^=
-        (((word + broadcast_Ap) ^ (word + broadcast_Zp)) & broadcast_80) >> 2;
-    memcpy(input + i, &word, sizeof(word));
-  }
-  if (i < length) {
-    uint64_t word{};
-    memcpy(&word, input + i, length - i);
-    non_ascii |= (word & broadcast_80);
-    word ^=
-        (((word + broadcast_Ap) ^ (word + broadcast_Zp)) & broadcast_80) >> 2;
-    memcpy(input + i, &word, length - i);
-  }
-  return non_ascii == 0;
-}
-#if ADA_NEON
-ada_really_inline bool has_tabs_or_newline(
-    std::string_view user_input) noexcept {
-  // first check for short strings in which case we do it naively.
-  if (user_input.size() < 16) {  // slow path
-    return std::any_of(user_input.begin(), user_input.end(),
-                       is_tabs_or_newline);
-  }
-  // fast path for long strings (expected to be common)
-  size_t i = 0;
-  /**
-   * The fastest way to check for `\t` (==9), '\n'(== 10) and `\r` (==13) relies
-   * on table lookup instruction. We notice that these are all unique numbers
-   * between 0..15. Let's prepare a special register, where we put '\t' in the
-   * 9th position, '\n' - 10th and '\r' - 13th. Then we shuffle this register by
-   * input register. If the input had `\t` in position X then this shuffled
-   * register will also have '\t' in that position. Comparing input with this
-   * shuffled register will mark us all interesting characters in the input.
-   *
-   * credit for algorithmic idea: @aqrit, credit for description:
-   * @DenisYaroshevskiy
-   */
-  static uint8_t rnt_array[16] = {1, 0, 0,  0, 0, 0,  0, 0,
-                                  0, 9, 10, 0, 0, 13, 0, 0};
-  const uint8x16_t rnt = vld1q_u8(rnt_array);
-  // m['0xd', '0xa', '0x9']
-  uint8x16_t running{0};
-  for (; i + 15 < user_input.size(); i += 16) {
-    uint8x16_t word = vld1q_u8((const uint8_t*)user_input.data() + i);
-
-    running = vorrq_u8(running, vceqq_u8(vqtbl1q_u8(rnt, word), word));
-  }
-  if (i < user_input.size()) {
-    uint8x16_t word =
-        vld1q_u8((const uint8_t*)user_input.data() + user_input.length() - 16);
-    running = vorrq_u8(running, vceqq_u8(vqtbl1q_u8(rnt, word), word));
-  }
-  return vmaxvq_u32(vreinterpretq_u32_u8(running)) != 0;
-}
-#elif ADA_SSE2
-ada_really_inline bool has_tabs_or_newline(
-    std::string_view user_input) noexcept {
-  // first check for short strings in which case we do it naively.
-  if (user_input.size() < 16) {  // slow path
-    return std::any_of(user_input.begin(), user_input.end(),
-                       is_tabs_or_newline);
-  }
-  // fast path for long strings (expected to be common)
-  size_t i = 0;
-  const __m128i mask1 = _mm_set1_epi8('\r');
-  const __m128i mask2 = _mm_set1_epi8('\n');
-  const __m128i mask3 = _mm_set1_epi8('\t');
-  // If we supported SSSE3, we could use the algorithm that we use for NEON.
-  __m128i running{0};
-  for (; i + 15 < user_input.size(); i += 16) {
-    __m128i word = _mm_loadu_si128((const __m128i*)(user_input.data() + i));
-    running = _mm_or_si128(
-        _mm_or_si128(running, _mm_or_si128(_mm_cmpeq_epi8(word, mask1),
-                                           _mm_cmpeq_epi8(word, mask2))),
-        _mm_cmpeq_epi8(word, mask3));
-  }
-  if (i < user_input.size()) {
-    __m128i word = _mm_loadu_si128(
-        (const __m128i*)(user_input.data() + user_input.length() - 16));
-    running = _mm_or_si128(
-        _mm_or_si128(running, _mm_or_si128(_mm_cmpeq_epi8(word, mask1),
-                                           _mm_cmpeq_epi8(word, mask2))),
-        _mm_cmpeq_epi8(word, mask3));
-  }
-  return _mm_movemask_epi8(running) != 0;
-}
-#else
-ada_really_inline bool has_tabs_or_newline(
-    std::string_view user_input) noexcept {
-  auto has_zero_byte = [](uint64_t v) {
-    return ((v - 0x0101010101010101) & ~(v) & 0x8080808080808080);
-  };
-  size_t i = 0;
-  uint64_t mask1 = broadcast('\r');
-  uint64_t mask2 = broadcast('\n');
-  uint64_t mask3 = broadcast('\t');
-  uint64_t running{0};
-  for (; i + 7 < user_input.size(); i += 8) {
-    uint64_t word{};
-    memcpy(&word, user_input.data() + i, sizeof(word));
-    uint64_t xor1 = word ^ mask1;
-    uint64_t xor2 = word ^ mask2;
-    uint64_t xor3 = word ^ mask3;
-    running |= has_zero_byte(xor1) | has_zero_byte(xor2) | has_zero_byte(xor3);
-  }
-  if (i < user_input.size()) {
-    uint64_t word{};
-    memcpy(&word, user_input.data() + i, user_input.size() - i);
-    uint64_t xor1 = word ^ mask1;
-    uint64_t xor2 = word ^ mask2;
-    uint64_t xor3 = word ^ mask3;
-    running |= has_zero_byte(xor1) | has_zero_byte(xor2) | has_zero_byte(xor3);
-  }
-  return running;
-}
-#endif
-
-// A forbidden host code point is U+0000 NULL, U+0009 TAB, U+000A LF, U+000D CR,
-// U+0020 SPACE, U+0023 (#), U+002F (/), U+003A (:), U+003C (<), U+003E (>),
-// U+003F (?), U+0040 (@), U+005B ([), U+005C (\), U+005D (]), U+005E (^), or
-// U+007C (|).
-constexpr static std::array<uint8_t, 256> is_forbidden_host_code_point_table =
-    []() consteval {
-      std::array<uint8_t, 256> result{};
-      for (uint8_t c : {'\0', '\x09', '\x0a', '\x0d', ' ', '#', '/', ':', '<',
-                        '>', '?', '@', '[', '\\', ']', '^', '|'}) {
-        result[c] = true;
-      }
-      return result;
-    }();
-
-ada_really_inline constexpr bool is_forbidden_host_code_point(
-    const char c) noexcept {
-  return is_forbidden_host_code_point_table[uint8_t(c)];
-}
-
-constexpr static std::array<uint8_t, 256> is_forbidden_domain_code_point_table =
-    []() consteval {
-      std::array<uint8_t, 256> result{};
-      for (uint8_t c : {'\0', '\x09', '\x0a', '\x0d', ' ', '#', '/', ':', '<',
-                        '>', '?', '@', '[', '\\', ']', '^', '|', '%'}) {
-        result[c] = true;
-      }
-      for (uint8_t c = 0; c <= 32; c++) {
-        result[c] = true;
-      }
-      for (size_t c = 127; c < 255; c++) {
-        result[c] = true;
-      }
-      return result;
-    }();
-
-static_assert(sizeof(is_forbidden_domain_code_point_table) == 256);
-
-ada_really_inline constexpr bool is_forbidden_domain_code_point(
-    const char c) noexcept {
-  return is_forbidden_domain_code_point_table[uint8_t(c)];
-}
-
-ada_really_inline constexpr bool contains_forbidden_domain_code_point(
-    const char* input, size_t length) noexcept {
-  size_t i = 0;
-  uint8_t accumulator{};
-  for (; i + 4 <= length; i += 4) {
-    accumulator |= is_forbidden_domain_code_point_table[uint8_t(input[i])];
-    accumulator |= is_forbidden_domain_code_point_table[uint8_t(input[i + 1])];
-    accumulator |= is_forbidden_domain_code_point_table[uint8_t(input[i + 2])];
-    accumulator |= is_forbidden_domain_code_point_table[uint8_t(input[i + 3])];
-  }
-  for (; i < length; i++) {
-    accumulator |= is_forbidden_domain_code_point_table[uint8_t(input[i])];
-  }
-  return accumulator;
-}
-
-constexpr static std::array<uint8_t, 256>
-    is_forbidden_domain_code_point_table_or_upper = []() consteval {
-      std::array<uint8_t, 256> result{};
-      for (uint8_t c : {'\0', '\x09', '\x0a', '\x0d', ' ', '#', '/', ':', '<',
-                        '>', '?', '@', '[', '\\', ']', '^', '|', '%'}) {
-        result[c] = 1;
-      }
-      for (uint8_t c = 'A'; c <= 'Z'; c++) {
-        result[c] = 2;
-      }
-      for (uint8_t c = 0; c <= 32; c++) {
-        result[c] = 1;
-      }
-      for (size_t c = 127; c < 255; c++) {
-        result[c] = 1;
-      }
-      return result;
-    }();
-
-ada_really_inline constexpr uint8_t
-contains_forbidden_domain_code_point_or_upper(const char* input,
-                                              size_t length) noexcept {
-  size_t i = 0;
-  uint8_t accumulator{};
-  for (; i + 4 <= length; i += 4) {
-    accumulator |=
-        is_forbidden_domain_code_point_table_or_upper[uint8_t(input[i])];
-    accumulator |=
-        is_forbidden_domain_code_point_table_or_upper[uint8_t(input[i + 1])];
-    accumulator |=
-        is_forbidden_domain_code_point_table_or_upper[uint8_t(input[i + 2])];
-    accumulator |=
-        is_forbidden_domain_code_point_table_or_upper[uint8_t(input[i + 3])];
-  }
-  for (; i < length; i++) {
-    accumulator |=
-        is_forbidden_domain_code_point_table_or_upper[uint8_t(input[i])];
-  }
-  return accumulator;
-}
-
-// std::isalnum(c) || c == '+' || c == '-' || c == '.') is true for
-constexpr static std::array<bool, 256> is_alnum_plus_table = []() consteval {
-  std::array<bool, 256> result{};
-  for (size_t c = 0; c < 256; c++) {
-    result[c] = (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') ||
-                (c >= 'A' && c <= 'Z') || c == '+' || c == '-' || c == '.';
-  }
-  return result;
-}();
-
-ada_really_inline constexpr bool is_alnum_plus(const char c) noexcept {
-  return is_alnum_plus_table[uint8_t(c)];
-  // A table is almost surely much faster than the
-  // following under most compilers: return
-  // return (std::isalnum(c) || c == '+' || c == '-' || c == '.');
-}
-
-ada_really_inline constexpr bool is_ascii_hex_digit(const char c) noexcept {
-  return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') ||
-         (c >= 'a' && c <= 'f');
-}
-
-ada_really_inline constexpr bool is_ascii_digit(const char c) noexcept {
-  // An ASCII digit is a code point in the range U+0030 (0) to U+0039 (9),
-  // inclusive.
-  return (c >= '0' && c <= '9');
-}
-
-ada_really_inline constexpr bool is_ascii(const char32_t c) noexcept {
-  // If code point is between U+0000 and U+007F inclusive, then return true.
-  return c <= 0x7F;
-}
-
-ada_really_inline constexpr bool is_c0_control_or_space(const char c) noexcept {
-  return (unsigned char)c <= ' ';
-}
-
-ada_really_inline constexpr bool is_ascii_tab_or_newline(
-    const char c) noexcept {
-  return c == '\t' || c == '\n' || c == '\r';
-}
-
-constexpr std::string_view table_is_double_dot_path_segment[] = {
-    "..", "%2e.", ".%2e", "%2e%2e"};
-
-ada_really_inline constexpr bool is_double_dot_path_segment(
-    std::string_view input) noexcept {
-  // This will catch most cases:
-  // The length must be 2,4 or 6.
-  // We divide by two and require
-  // that the result be between 1 and 3 inclusively.
-  uint64_t half_length = uint64_t(input.size()) / 2;
-  if (half_length - 1 > 2) {
-    return false;
-  }
-  // We have a string of length 2, 4 or 6.
-  // We now check the first character:
-  if ((input[0] != '.') && (input[0] != '%')) {
-    return false;
-  }
-  // We are unlikely the get beyond this point.
-  int hash_value = (input.size() + (unsigned)(input[0])) & 3;
-  const std::string_view target = table_is_double_dot_path_segment[hash_value];
-  if (target.size() != input.size()) {
-    return false;
-  }
-  // We almost never get here.
-  // Optimizing the rest is relatively unimportant.
-  auto prefix_equal_unsafe = [](std::string_view a, std::string_view b) {
-    uint16_t A, B;
-    memcpy(&A, a.data(), sizeof(A));
-    memcpy(&B, b.data(), sizeof(B));
-    return A == B;
-  };
-  if (!prefix_equal_unsafe(input, target)) {
-    return false;
-  }
-  for (size_t i = 2; i < input.size(); i++) {
-    char c = input[i];
-    if ((uint8_t((c | 0x20) - 0x61) <= 25 ? (c | 0x20) : c) != target[i]) {
-      return false;
-    }
-  }
-  return true;
-  // The above code might be a bit better than the code below. Compilers
-  // are not stupid and may use the fact that these strings have length 2,4 and
-  // 6 and other tricks.
-  // return input == ".." ||
-  //  input == ".%2e" || input == ".%2E" ||
-  //  input == "%2e." || input == "%2E." ||
-  //  input == "%2e%2e" || input == "%2E%2E" || input == "%2E%2e" || input ==
-  //  "%2e%2E";
-}
-
-ada_really_inline constexpr bool is_single_dot_path_segment(
-    std::string_view input) noexcept {
-  return input == "." || input == "%2e" || input == "%2E";
-}
-
-ada_really_inline constexpr bool is_lowercase_hex(const char c) noexcept {
-  return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f');
-}
-
-constexpr static char hex_to_binary_table[] = {
-    0,  1,  2,  3,  4, 5, 6, 7, 8, 9, 0, 0,  0,  0,  0,  0,  0, 10, 11,
-    12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0,  0,  0,  0,  0,  0, 0,  0,
-    0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0, 10, 11, 12, 13, 14, 15};
-unsigned constexpr convert_hex_to_binary(const char c) noexcept {
-  return hex_to_binary_table[c - '0'];
-}
-
-std::string percent_decode(const std::string_view input, size_t first_percent) {
-  // next line is for safety only, we expect users to avoid calling
-  // percent_decode when first_percent is outside the range.
-  if (first_percent == std::string_view::npos) {
-    return std::string(input);
-  }
-  std::string dest;
-  dest.reserve(input.length());
-  dest.append(input.substr(0, first_percent));
-  const char* pointer = input.data() + first_percent;
-  const char* end = input.data() + input.size();
-  // Optimization opportunity: if the following code gets
-  // called often, it can be optimized quite a bit.
-  while (pointer < end) {
-    const char ch = pointer[0];
-    size_t remaining = end - pointer - 1;
-    if (ch != '%' || remaining < 2 ||
-        (  // ch == '%' && // It is unnecessary to check that ch == '%'.
-            (!is_ascii_hex_digit(pointer[1]) ||
-             !is_ascii_hex_digit(pointer[2])))) {
-      dest += ch;
-      pointer++;
-    } else {
-      unsigned a = convert_hex_to_binary(pointer[1]);
-      unsigned b = convert_hex_to_binary(pointer[2]);
-      char c = static_cast<char>(a * 16 + b);
-      dest += c;
-      pointer += 3;
-    }
-  }
-  return dest;
-}
-
-std::string percent_encode(const std::string_view input,
-                           const uint8_t character_set[]) {
-  auto pointer = std::ranges::find_if(input, [character_set](const char c) {
-    return character_sets::bit_at(character_set, c);
-  });
-  // Optimization: Don't iterate if percent encode is not required
-  if (pointer == input.end()) {
-    return std::string(input);
-  }
-
-  std::string result;
-  result.reserve(input.length());  // in the worst case, percent encoding might
-                                   // produce 3 characters.
-  result.append(input.substr(0, std::distance(input.begin(), pointer)));
-
-  for (; pointer != input.end(); pointer++) {
-    if (character_sets::bit_at(character_set, *pointer)) {
-      result.append(character_sets::hex + uint8_t(*pointer) * 4, 3);
-    } else {
-      result += *pointer;
-    }
-  }
-
-  return result;
-}
-
-template <bool append>
-bool percent_encode(const std::string_view input, const uint8_t character_set[],
-                    std::string& out) {
-  ada_log("percent_encode ", input, " to output string while ",
-          append ? "appending" : "overwriting");
-  auto pointer =
-      std::find_if(input.begin(), input.end(), [character_set](const char c) {
-        return character_sets::bit_at(character_set, c);
-      });
-  ada_log("percent_encode done checking, moved to ",
-          std::distance(input.begin(), pointer));
-
-  // Optimization: Don't iterate if percent encode is not required
-  if (pointer == input.end()) {
-    ada_log("percent_encode encoding not needed.");
-    return false;
-  }
-  if constexpr (!append) {
-    out.clear();
-  }
-  ada_log("percent_encode appending ", std::distance(input.begin(), pointer),
-          " bytes");
-  out.append(input.data(), std::distance(input.begin(), pointer));
-  ada_log("percent_encode processing ", std::distance(pointer, input.end()),
-          " bytes");
-  for (; pointer != input.end(); pointer++) {
-    if (character_sets::bit_at(character_set, *pointer)) {
-      out.append(character_sets::hex + uint8_t(*pointer) * 4, 3);
-    } else {
-      out += *pointer;
-    }
-  }
-  return true;
-}
-
-bool to_ascii(std::optional<std::string>& out, const std::string_view plain,
-              size_t first_percent) {
-  std::string percent_decoded_buffer;
-  std::string_view input = plain;
-  if (first_percent != std::string_view::npos) {
-    percent_decoded_buffer = unicode::percent_decode(plain, first_percent);
-    input = percent_decoded_buffer;
-  }
-  // input is a non-empty UTF-8 string, must be percent decoded
-  std::string idna_ascii = ada::idna::to_ascii(input);
-  if (idna_ascii.empty() || contains_forbidden_domain_code_point(
-                                idna_ascii.data(), idna_ascii.size())) {
-    return false;
-  }
-  out = std::move(idna_ascii);
-  return true;
-}
-
-std::string percent_encode(const std::string_view input,
-                           const uint8_t character_set[], size_t index) {
-  std::string out;
-  out.append(input.data(), index);
-  auto pointer = input.begin() + index;
-  for (; pointer != input.end(); pointer++) {
-    if (character_sets::bit_at(character_set, *pointer)) {
-      out.append(character_sets::hex + uint8_t(*pointer) * 4, 3);
-    } else {
-      out += *pointer;
-    }
-  }
-  return out;
-}
-
-}  // namespace ada::unicode
-/* end file src/unicode.cpp */
-/* begin file src/serializers.cpp */
-#include <array>
-#include <charconv>
-#include <string>
-
-namespace ada::serializers {
-
-void find_longest_sequence_of_ipv6_pieces(
-    const std::array<uint16_t, 8>& address, size_t& compress,
-    size_t& compress_length) noexcept {
-  for (size_t i = 0; i < 8; i++) {
-    if (address[i] == 0) {
-      size_t next = i + 1;
-      while (next != 8 && address[next] == 0) ++next;
-      const size_t count = next - i;
-      if (compress_length < count) {
-        compress_length = count;
-        compress = i;
-        if (next == 8) break;
-        i = next;
-      }
-    }
-  }
-}
-
-std::string ipv6(const std::array<uint16_t, 8>& address) noexcept {
-  size_t compress_length = 0;  // The length of a long sequence of zeros.
-  size_t compress = 0;         // The start of a long sequence of zeros.
-  find_longest_sequence_of_ipv6_pieces(address, compress, compress_length);
-
-  if (compress_length <= 1) {
-    // Optimization opportunity: Find a faster way then snprintf for imploding
-    // and return here.
-    compress = compress_length = 8;
-  }
-
-  std::string output(4 * 8 + 7 + 2, '\0');
-  size_t piece_index = 0;
-  char* point = output.data();
-  char* point_end = output.data() + output.size();
-  *point++ = '[';
-  while (true) {
-    if (piece_index == compress) {
-      *point++ = ':';
-      // If we skip a value initially, we need to write '::', otherwise
-      // a single ':' will do since it follows a previous ':'.
-      if (piece_index == 0) {
-        *point++ = ':';
-      }
-      piece_index += compress_length;
-      if (piece_index == 8) {
-        break;
-      }
-    }
-    point = std::to_chars(point, point_end, address[piece_index], 16).ptr;
-    piece_index++;
-    if (piece_index == 8) {
-      break;
-    }
-    *point++ = ':';
-  }
-  *point++ = ']';
-  output.resize(point - output.data());
-  return output;
-}
-
-std::string ipv4(const uint64_t address) noexcept {
-  std::string output(15, '\0');
-  char* point = output.data();
-  char* point_end = output.data() + output.size();
-  point = std::to_chars(point, point_end, uint8_t(address >> 24)).ptr;
-  for (int i = 2; i >= 0; i--) {
-    *point++ = '.';
-    point = std::to_chars(point, point_end, uint8_t(address >> (i * 8))).ptr;
-  }
-  output.resize(point - output.data());
-  return output;
-}
-
-}  // namespace ada::serializers
-/* end file src/serializers.cpp */
-/* begin file src/implementation.cpp */
-
-#include <string_view>
-
-
-namespace ada {
-
-template <class result_type>
-ada_warn_unused tl::expected<result_type, errors> parse(
-    std::string_view input, const result_type* base_url) {
-  result_type u =
-      ada::parser::parse_url_impl<result_type, true>(input, base_url);
-  if (!u.is_valid) {
-    return tl::unexpected(errors::type_error);
-  }
-  return u;
-}
-
-template ada::result<url> parse<url>(std::string_view input,
-                                     const url* base_url = nullptr);
-template ada::result<url_aggregator> parse<url_aggregator>(
-    std::string_view input, const url_aggregator* base_url = nullptr);
-
-std::string href_from_file(std::string_view input) {
-  // This is going to be much faster than constructing a URL.
-  std::string tmp_buffer;
-  std::string_view internal_input;
-  if (unicode::has_tabs_or_newline(input)) {
-    tmp_buffer = input;
-    helpers::remove_ascii_tab_or_newline(tmp_buffer);
-    internal_input = tmp_buffer;
-  } else {
-    internal_input = input;
-  }
-  std::string path;
-  if (internal_input.empty()) {
-    path = "/";
-  } else if ((internal_input[0] == '/') || (internal_input[0] == '\\')) {
-    helpers::parse_prepared_path(internal_input.substr(1),
-                                 ada::scheme::type::FILE, path);
-  } else {
-    helpers::parse_prepared_path(internal_input, ada::scheme::type::FILE, path);
-  }
-  return "file://" + path;
-}
-
-bool can_parse(std::string_view input, const std::string_view* base_input) {
-  ada::url_aggregator base_aggregator;
-  ada::url_aggregator* base_pointer = nullptr;
-
-  if (base_input != nullptr) {
-    base_aggregator = ada::parser::parse_url_impl<ada::url_aggregator, false>(
-        *base_input, nullptr);
-    if (!base_aggregator.is_valid) {
-      return false;
-    }
-    base_pointer = &base_aggregator;
-  }
-
-  ada::url_aggregator result =
-      ada::parser::parse_url_impl<ada::url_aggregator, false>(input,
-                                                              base_pointer);
-  return result.is_valid;
-}
-
-ada_warn_unused std::string to_string(ada::encoding_type type) {
-  switch (type) {
-    case ada::encoding_type::UTF8:
-      return "UTF-8";
-    case ada::encoding_type::UTF_16LE:
-      return "UTF-16LE";
-    case ada::encoding_type::UTF_16BE:
-      return "UTF-16BE";
-    default:
-      unreachable();
-  }
-}
-
-}  // namespace ada
-/* end file src/implementation.cpp */
-/* begin file src/helpers.cpp */
-
-#include <cstring>
-#include <sstream>
-
-namespace ada::helpers {
-
-template <typename out_iter>
-void encode_json(std::string_view view, out_iter out) {
-  // trivial implementation. could be faster.
-  const char* hexvalues =
-      "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f";
-  for (uint8_t c : view) {
-    if (c == '\\') {
-      *out++ = '\\';
-      *out++ = '\\';
-    } else if (c == '"') {
-      *out++ = '\\';
-      *out++ = '"';
-    } else if (c <= 0x1f) {
-      *out++ = '\\';
-      *out++ = 'u';
-      *out++ = '0';
-      *out++ = '0';
-      *out++ = hexvalues[2 * c];
-      *out++ = hexvalues[2 * c + 1];
-    } else {
-      *out++ = c;
-    }
-  }
-}
-
-ada_unused std::string get_state(ada::state s) {
-  switch (s) {
-    case ada::state::AUTHORITY:
-      return "Authority";
-    case ada::state::SCHEME_START:
-      return "Scheme Start";
-    case ada::state::SCHEME:
-      return "Scheme";
-    case ada::state::HOST:
-      return "Host";
-    case ada::state::NO_SCHEME:
-      return "No Scheme";
-    case ada::state::FRAGMENT:
-      return "Fragment";
-    case ada::state::RELATIVE_SCHEME:
-      return "Relative Scheme";
-    case ada::state::RELATIVE_SLASH:
-      return "Relative Slash";
-    case ada::state::FILE:
-      return "File";
-    case ada::state::FILE_HOST:
-      return "File Host";
-    case ada::state::FILE_SLASH:
-      return "File Slash";
-    case ada::state::PATH_OR_AUTHORITY:
-      return "Path or Authority";
-    case ada::state::SPECIAL_AUTHORITY_IGNORE_SLASHES:
-      return "Special Authority Ignore Slashes";
-    case ada::state::SPECIAL_AUTHORITY_SLASHES:
-      return "Special Authority Slashes";
-    case ada::state::SPECIAL_RELATIVE_OR_AUTHORITY:
-      return "Special Relative or Authority";
-    case ada::state::QUERY:
-      return "Query";
-    case ada::state::PATH:
-      return "Path";
-    case ada::state::PATH_START:
-      return "Path Start";
-    case ada::state::OPAQUE_PATH:
-      return "Opaque Path";
-    case ada::state::PORT:
-      return "Port";
-    default:
-      return "unknown state";
-  }
-}
-
-ada_really_inline std::optional<std::string_view> prune_hash(
-    std::string_view& input) noexcept {
-  // compiles down to 20--30 instructions including a class to memchr (C
-  // function). this function should be quite fast.
-  size_t location_of_first = input.find('#');
-  if (location_of_first == std::string_view::npos) {
-    return std::nullopt;
-  }
-  std::string_view hash = input;
-  hash.remove_prefix(location_of_first + 1);
-  input.remove_suffix(input.size() - location_of_first);
-  return hash;
-}
-
-ada_really_inline bool shorten_path(std::string& path,
-                                    ada::scheme::type type) noexcept {
-  // Let path be url's path.
-  // If url's scheme is "file", path's size is 1, and path[0] is a normalized
-  // Windows drive letter, then return.
-  if (type == ada::scheme::type::FILE &&
-      path.find('/', 1) == std::string_view::npos && !path.empty()) {
-    if (checkers::is_normalized_windows_drive_letter(
-            helpers::substring(path, 1))) {
-      return false;
-    }
-  }
-
-  // Remove path's last item, if any.
-  size_t last_delimiter = path.rfind('/');
-  if (last_delimiter != std::string::npos) {
-    path.erase(last_delimiter);
-    return true;
-  }
-
-  return false;
-}
-
-ada_really_inline bool shorten_path(std::string_view& path,
-                                    ada::scheme::type type) noexcept {
-  // Let path be url's path.
-  // If url's scheme is "file", path's size is 1, and path[0] is a normalized
-  // Windows drive letter, then return.
-  if (type == ada::scheme::type::FILE &&
-      path.find('/', 1) == std::string_view::npos && !path.empty()) {
-    if (checkers::is_normalized_windows_drive_letter(
-            helpers::substring(path, 1))) {
-      return false;
-    }
-  }
-
-  // Remove path's last item, if any.
-  if (!path.empty()) {
-    size_t slash_loc = path.rfind('/');
-    if (slash_loc != std::string_view::npos) {
-      path.remove_suffix(path.size() - slash_loc);
-      return true;
-    }
-  }
-
-  return false;
-}
-
-ada_really_inline void remove_ascii_tab_or_newline(
-    std::string& input) noexcept {
-  // if this ever becomes a performance issue, we could use an approach similar
-  // to has_tabs_or_newline
-  std::erase_if(input, ada::unicode::is_ascii_tab_or_newline);
-}
-
-ada_really_inline constexpr std::string_view substring(std::string_view input,
-                                                       size_t pos) noexcept {
-  ADA_ASSERT_TRUE(pos <= input.size());
-  // The following is safer but unneeded if we have the above line:
-  // return pos > input.size() ? std::string_view() : input.substr(pos);
-  return input.substr(pos);
-}
-
-ada_really_inline void resize(std::string_view& input, size_t pos) noexcept {
-  ADA_ASSERT_TRUE(pos <= input.size());
-  input.remove_suffix(input.size() - pos);
-}
-
-// computes the number of trailing zeroes
-// this is a private inline function only defined in this source file.
-ada_really_inline int trailing_zeroes(uint32_t input_num) noexcept {
-#ifdef ADA_REGULAR_VISUAL_STUDIO
-  unsigned long ret;
-  // Search the mask data from least significant bit (LSB)
-  // to the most significant bit (MSB) for a set bit (1).
-  _BitScanForward(&ret, input_num);
-  return (int)ret;
-#else   // ADA_REGULAR_VISUAL_STUDIO
-  return __builtin_ctzl(input_num);
-#endif  // ADA_REGULAR_VISUAL_STUDIO
-}
-
-// starting at index location, this finds the next location of a character
-// :, /, \\, ? or [. If none is found, view.size() is returned.
-// For use within get_host_delimiter_location.
-#if ADA_NEON
-// The ada_make_uint8x16_t macro is necessary because Visual Studio does not
-// support direct initialization of uint8x16_t. See
-// https://developercommunity.visualstudio.com/t/error-C2078:-too-many-initializers-whe/402911?q=backend+neon
-#ifndef ada_make_uint8x16_t
-#define ada_make_uint8x16_t(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, \
-                            x13, x14, x15, x16)                                \
-  ([=]() {                                                                     \
-    static uint8_t array[16] = {x1, x2,  x3,  x4,  x5,  x6,  x7,  x8,          \
-                                x9, x10, x11, x12, x13, x14, x15, x16};        \
-    return vld1q_u8(array);                                                    \
-  }())
-#endif
-
-ada_really_inline size_t find_next_host_delimiter_special(
-    std::string_view view, size_t location) noexcept {
-  // first check for short strings in which case we do it naively.
-  if (view.size() - location < 16) {  // slow path
-    for (size_t i = location; i < view.size(); i++) {
-      if (view[i] == ':' || view[i] == '/' || view[i] == '\\' ||
-          view[i] == '?' || view[i] == '[') {
-        return i;
-      }
-    }
-    return size_t(view.size());
-  }
-  auto to_bitmask = [](uint8x16_t input) -> uint16_t {
-    uint8x16_t bit_mask =
-        ada_make_uint8x16_t(0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80, 0x01,
-                            0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80);
-    uint8x16_t minput = vandq_u8(input, bit_mask);
-    uint8x16_t tmp = vpaddq_u8(minput, minput);
-    tmp = vpaddq_u8(tmp, tmp);
-    tmp = vpaddq_u8(tmp, tmp);
-    return vgetq_lane_u16(vreinterpretq_u16_u8(tmp), 0);
-  };
-
-  // fast path for long strings (expected to be common)
-  size_t i = location;
-  uint8x16_t low_mask =
-      ada_make_uint8x16_t(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                          0x00, 0x01, 0x04, 0x04, 0x00, 0x00, 0x03);
-  uint8x16_t high_mask =
-      ada_make_uint8x16_t(0x00, 0x00, 0x02, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00,
-                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
-  uint8x16_t fmask = vmovq_n_u8(0xf);
-  uint8x16_t zero{0};
-  for (; i + 15 < view.size(); i += 16) {
-    uint8x16_t word = vld1q_u8((const uint8_t*)view.data() + i);
-    uint8x16_t lowpart = vqtbl1q_u8(low_mask, vandq_u8(word, fmask));
-    uint8x16_t highpart = vqtbl1q_u8(high_mask, vshrq_n_u8(word, 4));
-    uint8x16_t classify = vandq_u8(lowpart, highpart);
-    if (vmaxvq_u32(vreinterpretq_u32_u8(classify)) != 0) {
-      uint8x16_t is_zero = vceqq_u8(classify, zero);
-      uint16_t is_non_zero = ~to_bitmask(is_zero);
-      return i + trailing_zeroes(is_non_zero);
-    }
-  }
-
-  if (i < view.size()) {
-    uint8x16_t word =
-        vld1q_u8((const uint8_t*)view.data() + view.length() - 16);
-    uint8x16_t lowpart = vqtbl1q_u8(low_mask, vandq_u8(word, fmask));
-    uint8x16_t highpart = vqtbl1q_u8(high_mask, vshrq_n_u8(word, 4));
-    uint8x16_t classify = vandq_u8(lowpart, highpart);
-    if (vmaxvq_u32(vreinterpretq_u32_u8(classify)) != 0) {
-      uint8x16_t is_zero = vceqq_u8(classify, zero);
-      uint16_t is_non_zero = ~to_bitmask(is_zero);
-      return view.length() - 16 + trailing_zeroes(is_non_zero);
-    }
-  }
-  return size_t(view.size());
-}
-#elif ADA_SSE2
-ada_really_inline size_t find_next_host_delimiter_special(
-    std::string_view view, size_t location) noexcept {
-  // first check for short strings in which case we do it naively.
-  if (view.size() - location < 16) {  // slow path
-    for (size_t i = location; i < view.size(); i++) {
-      if (view[i] == ':' || view[i] == '/' || view[i] == '\\' ||
-          view[i] == '?' || view[i] == '[') {
-        return i;
-      }
-    }
-    return size_t(view.size());
-  }
-  // fast path for long strings (expected to be common)
-  size_t i = location;
-  const __m128i mask1 = _mm_set1_epi8(':');
-  const __m128i mask2 = _mm_set1_epi8('/');
-  const __m128i mask3 = _mm_set1_epi8('\\');
-  const __m128i mask4 = _mm_set1_epi8('?');
-  const __m128i mask5 = _mm_set1_epi8('[');
-
-  for (; i + 15 < view.size(); i += 16) {
-    __m128i word = _mm_loadu_si128((const __m128i*)(view.data() + i));
-    __m128i m1 = _mm_cmpeq_epi8(word, mask1);
-    __m128i m2 = _mm_cmpeq_epi8(word, mask2);
-    __m128i m3 = _mm_cmpeq_epi8(word, mask3);
-    __m128i m4 = _mm_cmpeq_epi8(word, mask4);
-    __m128i m5 = _mm_cmpeq_epi8(word, mask5);
-    __m128i m = _mm_or_si128(
-        _mm_or_si128(_mm_or_si128(m1, m2), _mm_or_si128(m3, m4)), m5);
-    int mask = _mm_movemask_epi8(m);
-    if (mask != 0) {
-      return i + trailing_zeroes(mask);
-    }
-  }
-  if (i < view.size()) {
-    __m128i word =
-        _mm_loadu_si128((const __m128i*)(view.data() + view.length() - 16));
-    __m128i m1 = _mm_cmpeq_epi8(word, mask1);
-    __m128i m2 = _mm_cmpeq_epi8(word, mask2);
-    __m128i m3 = _mm_cmpeq_epi8(word, mask3);
-    __m128i m4 = _mm_cmpeq_epi8(word, mask4);
-    __m128i m5 = _mm_cmpeq_epi8(word, mask5);
-    __m128i m = _mm_or_si128(
-        _mm_or_si128(_mm_or_si128(m1, m2), _mm_or_si128(m3, m4)), m5);
-    int mask = _mm_movemask_epi8(m);
-    if (mask != 0) {
-      return view.length() - 16 + trailing_zeroes(mask);
-    }
-  }
-  return size_t(view.length());
-}
-#else
-// : / [ \\ ?
-static constexpr std::array<uint8_t, 256> special_host_delimiters =
-    []() consteval {
-      std::array<uint8_t, 256> result{};
-      for (int i : {':', '/', '[', '\\', '?'}) {
-        result[i] = 1;
-      }
-      return result;
-    }();
-// credit: @the-moisrex recommended a table-based approach
-ada_really_inline size_t find_next_host_delimiter_special(
-    std::string_view view, size_t location) noexcept {
-  auto const str = view.substr(location);
-  for (auto pos = str.begin(); pos != str.end(); ++pos) {
-    if (special_host_delimiters[(uint8_t)*pos]) {
-      return pos - str.begin() + location;
-    }
-  }
-  return size_t(view.size());
-}
-#endif
-
-// starting at index location, this finds the next location of a character
-// :, /, ? or [. If none is found, view.size() is returned.
-// For use within get_host_delimiter_location.
-#if ADA_NEON
-ada_really_inline size_t find_next_host_delimiter(std::string_view view,
-                                                  size_t location) noexcept {
-  // first check for short strings in which case we do it naively.
-  if (view.size() - location < 16) {  // slow path
-    for (size_t i = location; i < view.size(); i++) {
-      if (view[i] == ':' || view[i] == '/' || view[i] == '?' ||
-          view[i] == '[') {
-        return i;
-      }
-    }
-    return size_t(view.size());
-  }
-  auto to_bitmask = [](uint8x16_t input) -> uint16_t {
-    uint8x16_t bit_mask =
-        ada_make_uint8x16_t(0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80, 0x01,
-                            0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80);
-    uint8x16_t minput = vandq_u8(input, bit_mask);
-    uint8x16_t tmp = vpaddq_u8(minput, minput);
-    tmp = vpaddq_u8(tmp, tmp);
-    tmp = vpaddq_u8(tmp, tmp);
-    return vgetq_lane_u16(vreinterpretq_u16_u8(tmp), 0);
-  };
-
-  // fast path for long strings (expected to be common)
-  size_t i = location;
-  uint8x16_t low_mask =
-      ada_make_uint8x16_t(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                          0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x03);
-  uint8x16_t high_mask =
-      ada_make_uint8x16_t(0x00, 0x00, 0x02, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00,
-                          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
-  uint8x16_t fmask = vmovq_n_u8(0xf);
-  uint8x16_t zero{0};
-  for (; i + 15 < view.size(); i += 16) {
-    uint8x16_t word = vld1q_u8((const uint8_t*)view.data() + i);
-    uint8x16_t lowpart = vqtbl1q_u8(low_mask, vandq_u8(word, fmask));
-    uint8x16_t highpart = vqtbl1q_u8(high_mask, vshrq_n_u8(word, 4));
-    uint8x16_t classify = vandq_u8(lowpart, highpart);
-    if (vmaxvq_u32(vreinterpretq_u32_u8(classify)) != 0) {
-      uint8x16_t is_zero = vceqq_u8(classify, zero);
-      uint16_t is_non_zero = ~to_bitmask(is_zero);
-      return i + trailing_zeroes(is_non_zero);
-    }
-  }
-
-  if (i < view.size()) {
-    uint8x16_t word =
-        vld1q_u8((const uint8_t*)view.data() + view.length() - 16);
-    uint8x16_t lowpart = vqtbl1q_u8(low_mask, vandq_u8(word, fmask));
-    uint8x16_t highpart = vqtbl1q_u8(high_mask, vshrq_n_u8(word, 4));
-    uint8x16_t classify = vandq_u8(lowpart, highpart);
-    if (vmaxvq_u32(vreinterpretq_u32_u8(classify)) != 0) {
-      uint8x16_t is_zero = vceqq_u8(classify, zero);
-      uint16_t is_non_zero = ~to_bitmask(is_zero);
-      return view.length() - 16 + trailing_zeroes(is_non_zero);
-    }
-  }
-  return size_t(view.size());
-}
-#elif ADA_SSE2
-ada_really_inline size_t find_next_host_delimiter(std::string_view view,
-                                                  size_t location) noexcept {
-  // first check for short strings in which case we do it naively.
-  if (view.size() - location < 16) {  // slow path
-    for (size_t i = location; i < view.size(); i++) {
-      if (view[i] == ':' || view[i] == '/' || view[i] == '?' ||
-          view[i] == '[') {
-        return i;
-      }
-    }
-    return size_t(view.size());
-  }
-  // fast path for long strings (expected to be common)
-  size_t i = location;
-  const __m128i mask1 = _mm_set1_epi8(':');
-  const __m128i mask2 = _mm_set1_epi8('/');
-  const __m128i mask4 = _mm_set1_epi8('?');
-  const __m128i mask5 = _mm_set1_epi8('[');
-
-  for (; i + 15 < view.size(); i += 16) {
-    __m128i word = _mm_loadu_si128((const __m128i*)(view.data() + i));
-    __m128i m1 = _mm_cmpeq_epi8(word, mask1);
-    __m128i m2 = _mm_cmpeq_epi8(word, mask2);
-    __m128i m4 = _mm_cmpeq_epi8(word, mask4);
-    __m128i m5 = _mm_cmpeq_epi8(word, mask5);
-    __m128i m = _mm_or_si128(_mm_or_si128(m1, m2), _mm_or_si128(m4, m5));
-    int mask = _mm_movemask_epi8(m);
-    if (mask != 0) {
-      return i + trailing_zeroes(mask);
-    }
-  }
-  if (i < view.size()) {
-    __m128i word =
-        _mm_loadu_si128((const __m128i*)(view.data() + view.length() - 16));
-    __m128i m1 = _mm_cmpeq_epi8(word, mask1);
-    __m128i m2 = _mm_cmpeq_epi8(word, mask2);
-    __m128i m4 = _mm_cmpeq_epi8(word, mask4);
-    __m128i m5 = _mm_cmpeq_epi8(word, mask5);
-    __m128i m = _mm_or_si128(_mm_or_si128(m1, m2), _mm_or_si128(m4, m5));
-    int mask = _mm_movemask_epi8(m);
-    if (mask != 0) {
-      return view.length() - 16 + trailing_zeroes(mask);
-    }
-  }
-  return size_t(view.length());
-}
-#else
-// : / [ ?
-static constexpr std::array<uint8_t, 256> host_delimiters = []() consteval {
-  std::array<uint8_t, 256> result{};
-  for (int i : {':', '/', '?', '['}) {
-    result[i] = 1;
-  }
-  return result;
-}();
-// credit: @the-moisrex recommended a table-based approach
-ada_really_inline size_t find_next_host_delimiter(std::string_view view,
-                                                  size_t location) noexcept {
-  auto const str = view.substr(location);
-  for (auto pos = str.begin(); pos != str.end(); ++pos) {
-    if (host_delimiters[(uint8_t)*pos]) {
-      return pos - str.begin() + location;
-    }
-  }
-  return size_t(view.size());
-}
-#endif
-
-ada_really_inline std::pair<size_t, bool> get_host_delimiter_location(
-    const bool is_special, std::string_view& view) noexcept {
-  /**
-   * The spec at https://url.spec.whatwg.org/#hostname-state expects us to
-   * compute a variable called insideBrackets but this variable is only used
-   * once, to check whether a ':' character was found outside brackets. Exact
-   * text: "Otherwise, if c is U+003A (:) and insideBrackets is false, then:".
-   * It is conceptually simpler and arguably more efficient to just return a
-   * Boolean indicating whether ':' was found outside brackets.
-   */
-  const size_t view_size = view.size();
-  size_t location = 0;
-  bool found_colon = false;
-  /**
-   * Performance analysis:
-   *
-   * We are basically seeking the end of the hostname which can be indicated
-   * by the end of the view, or by one of the characters ':', '/', '?', '\\'
-   * (where '\\' is only applicable for special URLs). However, these must
-   * appear outside a bracket range. E.g., if you have [something?]fd: then the
-   * '?' does not count.
-   *
-   * So we can skip ahead to the next delimiter, as long as we include '[' in
-   * the set of delimiters, and that we handle it first.
-   *
-   * So the trick is to have a fast function that locates the next delimiter.
-   * Unless we find '[', then it only needs to be called once! Ideally, such a
-   * function would be provided by the C++ standard library, but it seems that
-   * find_first_of is not very fast, so we are forced to roll our own.
-   *
-   * We do not break into two loops for speed, but for clarity.
-   */
-  if (is_special) {
-    // We move to the next delimiter.
-    location = find_next_host_delimiter_special(view, location);
-    // Unless we find '[' then we are going only going to have to call
-    // find_next_host_delimiter_special once.
-    for (; location < view_size;
-         location = find_next_host_delimiter_special(view, location)) {
-      if (view[location] == '[') {
-        location = view.find(']', location);
-        if (location == std::string_view::npos) {
-          // performance: view.find might get translated to a memchr, which
-          // has no notion of std::string_view::npos, so the code does not
-          // reflect the assembly.
-          location = view_size;
-          break;
-        }
-      } else {
-        found_colon = view[location] == ':';
-        break;
-      }
-    }
-  } else {
-    // We move to the next delimiter.
-    location = find_next_host_delimiter(view, location);
-    // Unless we find '[' then we are going only going to have to call
-    // find_next_host_delimiter_special once.
-    for (; location < view_size;
-         location = find_next_host_delimiter(view, location)) {
-      if (view[location] == '[') {
-        location = view.find(']', location);
-        if (location == std::string_view::npos) {
-          // performance: view.find might get translated to a memchr, which
-          // has no notion of std::string_view::npos, so the code does not
-          // reflect the assembly.
-          location = view_size;
-          break;
-        }
-      } else {
-        found_colon = view[location] == ':';
-        break;
-      }
-    }
-  }
-  // performance: remove_suffix may translate into a single instruction.
-  view.remove_suffix(view_size - location);
-  return {location, found_colon};
-}
-
-void trim_c0_whitespace(std::string_view& input) noexcept {
-  while (!input.empty() &&
-         ada::unicode::is_c0_control_or_space(input.front())) {
-    input.remove_prefix(1);
-  }
-  while (!input.empty() && ada::unicode::is_c0_control_or_space(input.back())) {
-    input.remove_suffix(1);
-  }
-}
-
-ada_really_inline void parse_prepared_path(std::string_view input,
-                                           ada::scheme::type type,
-                                           std::string& path) {
-  ada_log("parse_prepared_path ", input);
-  uint8_t accumulator = checkers::path_signature(input);
-  // Let us first detect a trivial case.
-  // If it is special, we check that we have no dot, no %,  no \ and no
-  // character needing percent encoding. Otherwise, we check that we have no %,
-  // no dot, and no character needing percent encoding.
-  constexpr uint8_t need_encoding = 1;
-  constexpr uint8_t backslash_char = 2;
-  constexpr uint8_t dot_char = 4;
-  constexpr uint8_t percent_char = 8;
-  bool special = type != ada::scheme::NOT_SPECIAL;
-  bool may_need_slow_file_handling = (type == ada::scheme::type::FILE &&
-                                      checkers::is_windows_drive_letter(input));
-  bool trivial_path =
-      (special ? (accumulator == 0)
-               : ((accumulator & (need_encoding | dot_char | percent_char)) ==
-                  0)) &&
-      (!may_need_slow_file_handling);
-  if (accumulator == dot_char && !may_need_slow_file_handling) {
-    // '4' means that we have at least one dot, but nothing that requires
-    // percent encoding or decoding. The only part that is not trivial is
-    // that we may have single dots and double dots path segments.
-    // If we have such segments, then we either have a path that begins
-    // with '.' (easy to check), or we have the sequence './'.
-    // Note: input cannot be empty, it must at least contain one character ('.')
-    // Note: we know that '\' is not present.
-    if (input[0] != '.') {
-      size_t slashdot = input.find("/.");
-      if (slashdot == std::string_view::npos) {  // common case
-        trivial_path = true;
-      } else {  // uncommon
-        // only three cases matter: /./, /.. or a final /
-        trivial_path =
-            !(slashdot + 2 == input.size() || input[slashdot + 2] == '.' ||
-              input[slashdot + 2] == '/');
-      }
-    }
-  }
-  if (trivial_path) {
-    ada_log("parse_path trivial");
-    path += '/';
-    path += input;
-    return;
-  }
-  // We are going to need to look a bit at the path, but let us see if we can
-  // ignore percent encoding *and* backslashes *and* percent characters.
-  // Except for the trivial case, this is likely to capture 99% of paths out
-  // there.
-  bool fast_path =
-      (special &&
-       (accumulator & (need_encoding | backslash_char | percent_char)) == 0) &&
-      (type != ada::scheme::type::FILE);
-  if (fast_path) {
-    ada_log("parse_prepared_path fast");
-    // Here we don't need to worry about \ or percent encoding.
-    // We also do not have a file protocol. We might have dots, however,
-    // but dots must as appear as '.', and they cannot be encoded because
-    // the symbol '%' is not present.
-    size_t previous_location = 0;  // We start at 0.
-    do {
-      size_t new_location = input.find('/', previous_location);
-      // std::string_view path_view = input;
-      //  We process the last segment separately:
-      if (new_location == std::string_view::npos) {
-        std::string_view path_view = input.substr(previous_location);
-        if (path_view == "..") {  // The path ends with ..
-          // e.g., if you receive ".." with an empty path, you go to "/".
-          if (path.empty()) {
-            path = '/';
-            return;
-          }
-          // Fast case where we have nothing to do:
-          if (path.back() == '/') {
-            return;
-          }
-          // If you have the path "/joe/myfriend",
-          // then you delete 'myfriend'.
-          path.resize(path.rfind('/') + 1);
-          return;
-        }
-        path += '/';
-        if (path_view != ".") {
-          path.append(path_view);
-        }
-        return;
-      } else {
-        // This is a non-final segment.
-        std::string_view path_view =
-            input.substr(previous_location, new_location - previous_location);
-        previous_location = new_location + 1;
-        if (path_view == "..") {
-          size_t last_delimiter = path.rfind('/');
-          if (last_delimiter != std::string::npos) {
-            path.erase(last_delimiter);
-          }
-        } else if (path_view != ".") {
-          path += '/';
-          path.append(path_view);
-        }
-      }
-    } while (true);
-  } else {
-    ada_log("parse_path slow");
-    // we have reached the general case
-    bool needs_percent_encoding = (accumulator & 1);
-    std::string path_buffer_tmp;
-    do {
-      size_t location = (special && (accumulator & 2))
-                            ? input.find_first_of("/\\")
-                            : input.find('/');
-      std::string_view path_view = input;
-      if (location != std::string_view::npos) {
-        path_view.remove_suffix(path_view.size() - location);
-        input.remove_prefix(location + 1);
-      }
-      // path_buffer is either path_view or it might point at a percent encoded
-      // temporary file.
-      std::string_view path_buffer =
-          (needs_percent_encoding &&
-           ada::unicode::percent_encode<false>(
-               path_view, character_sets::PATH_PERCENT_ENCODE, path_buffer_tmp))
-              ? path_buffer_tmp
-              : path_view;
-      if (unicode::is_double_dot_path_segment(path_buffer)) {
-        if ((helpers::shorten_path(path, type) || special) &&
-            location == std::string_view::npos) {
-          path += '/';
-        }
-      } else if (unicode::is_single_dot_path_segment(path_buffer) &&
-                 (location == std::string_view::npos)) {
-        path += '/';
-      }
-      // Otherwise, if path_buffer is not a single-dot path segment, then:
-      else if (!unicode::is_single_dot_path_segment(path_buffer)) {
-        // If url's scheme is "file", url's path is empty, and path_buffer is a
-        // Windows drive letter, then replace the second code point in
-        // path_buffer with U+003A (:).
-        if (type == ada::scheme::type::FILE && path.empty() &&
-            checkers::is_windows_drive_letter(path_buffer)) {
-          path += '/';
-          path += path_buffer[0];
-          path += ':';
-          path_buffer.remove_prefix(2);
-          path.append(path_buffer);
-        } else {
-          // Append path_buffer to url's path.
-          path += '/';
-          path.append(path_buffer);
-        }
-      }
-      if (location == std::string_view::npos) {
-        return;
-      }
-    } while (true);
-  }
-}
-
-bool overlaps(std::string_view input1, const std::string& input2) noexcept {
-  ada_log("helpers::overlaps check if string_view '", input1, "' [",
-          input1.size(), " bytes] is part of string '", input2, "' [",
-          input2.size(), " bytes]");
-  return !input1.empty() && !input2.empty() && input1.data() >= input2.data() &&
-         input1.data() < input2.data() + input2.size();
-}
-
-template <class url_type>
-ada_really_inline void strip_trailing_spaces_from_opaque_path(
-    url_type& url) noexcept {
-  ada_log("helpers::strip_trailing_spaces_from_opaque_path");
-  if (!url.has_opaque_path) return;
-  if (url.has_hash()) return;
-  if (url.has_search()) return;
-
-  auto path = std::string(url.get_pathname());
-  while (!path.empty() && path.back() == ' ') {
-    path.resize(path.size() - 1);
-  }
-  url.update_base_pathname(path);
-}
-
-// @ / \\ ?
-static constexpr std::array<uint8_t, 256> authority_delimiter_special =
-    []() consteval {
-      std::array<uint8_t, 256> result{};
-      for (uint8_t i : {'@', '/', '\\', '?'}) {
-        result[i] = 1;
-      }
-      return result;
-    }();
-// credit: @the-moisrex recommended a table-based approach
-ada_really_inline size_t
-find_authority_delimiter_special(std::string_view view) noexcept {
-  // performance note: we might be able to gain further performance
-  // with SIMD instrinsics.
-  for (auto pos = view.begin(); pos != view.end(); ++pos) {
-    if (authority_delimiter_special[(uint8_t)*pos]) {
-      return pos - view.begin();
-    }
-  }
-  return size_t(view.size());
-}
-
-// @ / ?
-static constexpr std::array<uint8_t, 256> authority_delimiter = []() consteval {
-  std::array<uint8_t, 256> result{};
-  for (uint8_t i : {'@', '/', '?'}) {
-    result[i] = 1;
-  }
-  return result;
-}();
-// credit: @the-moisrex recommended a table-based approach
-ada_really_inline size_t
-find_authority_delimiter(std::string_view view) noexcept {
-  // performance note: we might be able to gain further performance
-  // with SIMD instrinsics.
-  for (auto pos = view.begin(); pos != view.end(); ++pos) {
-    if (authority_delimiter[(uint8_t)*pos]) {
-      return pos - view.begin();
-    }
-  }
-  return size_t(view.size());
-}
-
-}  // namespace ada::helpers
-
-namespace ada {
-ada_warn_unused std::string to_string(ada::state state) {
-  return ada::helpers::get_state(state);
-}
-#undef ada_make_uint8x16_t
-}  // namespace ada
-/* end file src/helpers.cpp */
-/* begin file src/url.cpp */
-
-#include <numeric>
-#include <algorithm>
-#include <string>
-#include <string_view>
-
-namespace ada {
-
-bool url::parse_opaque_host(std::string_view input) {
-  ada_log("parse_opaque_host ", input, " [", input.size(), " bytes]");
-  if (std::ranges::any_of(input.begin(), input.end(),
-                          ada::unicode::is_forbidden_host_code_point)) {
-    return is_valid = false;
-  }
-
-  // Return the result of running UTF-8 percent-encode on input using the C0
-  // control percent-encode set.
-  host = ada::unicode::percent_encode(
-      input, ada::character_sets::C0_CONTROL_PERCENT_ENCODE);
-  return true;
-}
-
-bool url::parse_ipv4(std::string_view input) {
-  ada_log("parse_ipv4 ", input, " [", input.size(), " bytes]");
-  if (input.back() == '.') {
-    input.remove_suffix(1);
-  }
-  size_t digit_count{0};
-  int pure_decimal_count = 0;  // entries that are decimal
-  std::string_view original_input =
-      input;  // we might use this if pure_decimal_count == 4.
-  uint64_t ipv4{0};
-  // we could unroll for better performance?
-  for (; (digit_count < 4) && !(input.empty()); digit_count++) {
-    uint32_t
-        segment_result{};  // If any number exceeds 32 bits, we have an error.
-    bool is_hex = checkers::has_hex_prefix(input);
-    if (is_hex && ((input.length() == 2) ||
-                   ((input.length() > 2) && (input[2] == '.')))) {
-      // special case
-      segment_result = 0;
-      input.remove_prefix(2);
-    } else {
-      std::from_chars_result r{};
-      if (is_hex) {
-        r = std::from_chars(input.data() + 2, input.data() + input.size(),
-                            segment_result, 16);
-      } else if ((input.length() >= 2) && input[0] == '0' &&
-                 checkers::is_digit(input[1])) {
-        r = std::from_chars(input.data() + 1, input.data() + input.size(),
-                            segment_result, 8);
-      } else {
-        pure_decimal_count++;
-        r = std::from_chars(input.data(), input.data() + input.size(),
-                            segment_result, 10);
-      }
-      if (r.ec != std::errc()) {
-        return is_valid = false;
-      }
-      input.remove_prefix(r.ptr - input.data());
-    }
-    if (input.empty()) {
-      // We have the last value.
-      // At this stage, ipv4 contains digit_count*8 bits.
-      // So we have 32-digit_count*8 bits left.
-      if (segment_result >= (uint64_t(1) << (32 - digit_count * 8))) {
-        return is_valid = false;
-      }
-      ipv4 <<= (32 - digit_count * 8);
-      ipv4 |= segment_result;
-      goto final;
-    } else {
-      // There is more, so that the value must no be larger than 255
-      // and we must have a '.'.
-      if ((segment_result > 255) || (input[0] != '.')) {
-        return is_valid = false;
-      }
-      ipv4 <<= 8;
-      ipv4 |= segment_result;
-      input.remove_prefix(1);  // remove '.'
-    }
-  }
-  if ((digit_count != 4) || (!input.empty())) {
-    return is_valid = false;
-  }
-final:
-  // We could also check r.ptr to see where the parsing ended.
-  if (pure_decimal_count == 4) {
-    host = original_input;  // The original input was already all decimal and we
-                            // validated it.
-  } else {
-    host = ada::serializers::ipv4(ipv4);  // We have to reserialize the address.
-  }
-  host_type = IPV4;
-  return true;
-}
-
-bool url::parse_ipv6(std::string_view input) {
-  ada_log("parse_ipv6 ", input, " [", input.size(), " bytes]");
-
-  if (input.empty()) {
-    return is_valid = false;
-  }
-  // Let address be a new IPv6 address whose IPv6 pieces are all 0.
-  std::array<uint16_t, 8> address{};
-
-  // Let pieceIndex be 0.
-  int piece_index = 0;
-
-  // Let compress be null.
-  std::optional<int> compress{};
-
-  // Let pointer be a pointer for input.
-  std::string_view::iterator pointer = input.begin();
-
-  // If c is U+003A (:), then:
-  if (input[0] == ':') {
-    // If remaining does not start with U+003A (:), validation error, return
-    // failure.
-    if (input.size() == 1 || input[1] != ':') {
-      ada_log("parse_ipv6 starts with : but the rest does not start with :");
-      return is_valid = false;
-    }
-
-    // Increase pointer by 2.
-    pointer += 2;
-
-    // Increase pieceIndex by 1 and then set compress to pieceIndex.
-    compress = ++piece_index;
-  }
-
-  // While c is not the EOF code point:
-  while (pointer != input.end()) {
-    // If pieceIndex is 8, validation error, return failure.
-    if (piece_index == 8) {
-      ada_log("parse_ipv6 piece_index == 8");
-      return is_valid = false;
-    }
-
-    // If c is U+003A (:), then:
-    if (*pointer == ':') {
-      // If compress is non-null, validation error, return failure.
-      if (compress.has_value()) {
-        ada_log("parse_ipv6 compress is non-null");
-        return is_valid = false;
-      }
-
-      // Increase pointer and pieceIndex by 1, set compress to pieceIndex, and
-      // then continue.
-      pointer++;
-      compress = ++piece_index;
-      continue;
-    }
-
-    // Let value and length be 0.
-    uint16_t value = 0, length = 0;
-
-    // While length is less than 4 and c is an ASCII hex digit,
-    // set value to value times 0x10 + c interpreted as hexadecimal number, and
-    // increase pointer and length by 1.
-    while (length < 4 && pointer != input.end() &&
-           unicode::is_ascii_hex_digit(*pointer)) {
-      // https://stackoverflow.com/questions/39060852/why-does-the-addition-of-two-shorts-return-an-int
-      value = uint16_t(value * 0x10 + unicode::convert_hex_to_binary(*pointer));
-      pointer++;
-      length++;
-    }
-
-    // If c is U+002E (.), then:
-    if (pointer != input.end() && *pointer == '.') {
-      // If length is 0, validation error, return failure.
-      if (length == 0) {
-        ada_log("parse_ipv6 length is 0");
-        return is_valid = false;
-      }
-
-      // Decrease pointer by length.
-      pointer -= length;
-
-      // If pieceIndex is greater than 6, validation error, return failure.
-      if (piece_index > 6) {
-        ada_log("parse_ipv6 piece_index > 6");
-        return is_valid = false;
-      }
-
-      // Let numbersSeen be 0.
-      int numbers_seen = 0;
-
-      // While c is not the EOF code point:
-      while (pointer != input.end()) {
-        // Let ipv4Piece be null.
-        std::optional<uint16_t> ipv4_piece{};
-
-        // If numbersSeen is greater than 0, then:
-        if (numbers_seen > 0) {
-          // If c is a U+002E (.) and numbersSeen is less than 4, then increase
-          // pointer by 1.
-          if (*pointer == '.' && numbers_seen < 4) {
-            pointer++;
-          }
-          // Otherwise, validation error, return failure.
-          else {
-            ada_log("parse_ipv6 Otherwise, validation error, return failure");
-            return is_valid = false;
-          }
-        }
-
-        // If c is not an ASCII digit, validation error, return failure.
-        if (pointer == input.end() || !checkers::is_digit(*pointer)) {
-          ada_log(
-              "parse_ipv6 If c is not an ASCII digit, validation error, return "
-              "failure");
-          return is_valid = false;
-        }
-
-        // While c is an ASCII digit:
-        while (pointer != input.end() && checkers::is_digit(*pointer)) {
-          // Let number be c interpreted as decimal number.
-          int number = *pointer - '0';
-
-          // If ipv4Piece is null, then set ipv4Piece to number.
-          if (!ipv4_piece.has_value()) {
-            ipv4_piece = number;
-          }
-          // Otherwise, if ipv4Piece is 0, validation error, return failure.
-          else if (ipv4_piece == 0) {
-            ada_log("parse_ipv6 if ipv4Piece is 0, validation error");
-            return is_valid = false;
-          }
-          // Otherwise, set ipv4Piece to ipv4Piece times 10 + number.
-          else {
-            ipv4_piece = *ipv4_piece * 10 + number;
-          }
-
-          // If ipv4Piece is greater than 255, validation error, return failure.
-          if (ipv4_piece > 255) {
-            ada_log("parse_ipv6 ipv4_piece > 255");
-            return is_valid = false;
-          }
-
-          // Increase pointer by 1.
-          pointer++;
-        }
-
-        // Set address[pieceIndex] to address[pieceIndex] times 0x100 +
-        // ipv4Piece.
-        // https://stackoverflow.com/questions/39060852/why-does-the-addition-of-two-shorts-return-an-int
-        address[piece_index] =
-            uint16_t(address[piece_index] * 0x100 + *ipv4_piece);
-
-        // Increase numbersSeen by 1.
-        numbers_seen++;
-
-        // If numbersSeen is 2 or 4, then increase pieceIndex by 1.
-        if (numbers_seen == 2 || numbers_seen == 4) {
-          piece_index++;
-        }
-      }
-
-      // If numbersSeen is not 4, validation error, return failure.
-      if (numbers_seen != 4) {
-        return is_valid = false;
-      }
-
-      // Break.
-      break;
-    }
-    // Otherwise, if c is U+003A (:):
-    else if ((pointer != input.end()) && (*pointer == ':')) {
-      // Increase pointer by 1.
-      pointer++;
-
-      // If c is the EOF code point, validation error, return failure.
-      if (pointer == input.end()) {
-        ada_log(
-            "parse_ipv6 If c is the EOF code point, validation error, return "
-            "failure");
-        return is_valid = false;
-      }
-    }
-    // Otherwise, if c is not the EOF code point, validation error, return
-    // failure.
-    else if (pointer != input.end()) {
-      ada_log(
-          "parse_ipv6 Otherwise, if c is not the EOF code point, validation "
-          "error, return failure");
-      return is_valid = false;
-    }
-
-    // Set address[pieceIndex] to value.
-    address[piece_index] = value;
-
-    // Increase pieceIndex by 1.
-    piece_index++;
-  }
-
-  // If compress is non-null, then:
-  if (compress.has_value()) {
-    // Let swaps be pieceIndex - compress.
-    int swaps = piece_index - *compress;
-
-    // Set pieceIndex to 7.
-    piece_index = 7;
-
-    // While pieceIndex is not 0 and swaps is greater than 0,
-    // swap address[pieceIndex] with address[compress + swaps - 1], and then
-    // decrease both pieceIndex and swaps by 1.
-    while (piece_index != 0 && swaps > 0) {
-      std::swap(address[piece_index], address[*compress + swaps - 1]);
-      piece_index--;
-      swaps--;
-    }
-  }
-  // Otherwise, if compress is null and pieceIndex is not 8, validation error,
-  // return failure.
-  else if (piece_index != 8) {
-    ada_log(
-        "parse_ipv6 if compress is null and pieceIndex is not 8, validation "
-        "error, return failure");
-    return is_valid = false;
-  }
-  host = ada::serializers::ipv6(address);
-  ada_log("parse_ipv6 ", *host);
-  host_type = IPV6;
-  return true;
-}
-
-template <bool has_state_override>
-ada_really_inline bool url::parse_scheme(const std::string_view input) {
-  auto parsed_type = ada::scheme::get_scheme_type(input);
-  bool is_input_special = (parsed_type != ada::scheme::NOT_SPECIAL);
-  /**
-   * In the common case, we will immediately recognize a special scheme (e.g.,
-   *http, https), in which case, we can go really fast.
-   **/
-  if (is_input_special) {  // fast path!!!
-    if constexpr (has_state_override) {
-      // If url's scheme is not a special scheme and buffer is a special scheme,
-      // then return.
-      if (is_special() != is_input_special) {
-        return false;
-      }
-
-      // If url includes credentials or has a non-null port, and buffer is
-      // "file", then return.
-      if ((has_credentials() || port.has_value()) &&
-          parsed_type == ada::scheme::type::FILE) {
-        return false;
-      }
-
-      // If url's scheme is "file" and its host is an empty host, then return.
-      // An empty host is the empty string.
-      if (type == ada::scheme::type::FILE && host.has_value() &&
-          host.value().empty()) {
-        return false;
-      }
-    }
-
-    type = parsed_type;
-
-    if constexpr (has_state_override) {
-      // This is uncommon.
-      uint16_t urls_scheme_port = get_special_port();
-
-      if (urls_scheme_port) {
-        // If url's port is url's scheme's default port, then set url's port to
-        // null.
-        if (port.has_value() && *port == urls_scheme_port) {
-          port = std::nullopt;
-        }
-      }
-    }
-  } else {  // slow path
-    std::string _buffer(input);
-    // Next function is only valid if the input is ASCII and returns false
-    // otherwise, but it seems that we always have ascii content so we do not
-    // need to check the return value.
-    // bool is_ascii =
-    unicode::to_lower_ascii(_buffer.data(), _buffer.size());
-
-    if constexpr (has_state_override) {
-      // If url's scheme is a special scheme and buffer is not a special scheme,
-      // then return. If url's scheme is not a special scheme and buffer is a
-      // special scheme, then return.
-      if (is_special() != ada::scheme::is_special(_buffer)) {
-        return true;
-      }
-
-      // If url includes credentials or has a non-null port, and buffer is
-      // "file", then return.
-      if ((has_credentials() || port.has_value()) && _buffer == "file") {
-        return true;
-      }
-
-      // If url's scheme is "file" and its host is an empty host, then return.
-      // An empty host is the empty string.
-      if (type == ada::scheme::type::FILE && host.has_value() &&
-          host.value().empty()) {
-        return true;
-      }
-    }
-
-    set_scheme(std::move(_buffer));
-
-    if constexpr (has_state_override) {
-      // This is uncommon.
-      uint16_t urls_scheme_port = get_special_port();
-
-      if (urls_scheme_port) {
-        // If url's port is url's scheme's default port, then set url's port to
-        // null.
-        if (port.has_value() && *port == urls_scheme_port) {
-          port = std::nullopt;
-        }
-      }
-    }
-  }
-
-  return true;
-}
-
-ada_really_inline bool url::parse_host(std::string_view input) {
-  ada_log("parse_host ", input, " [", input.size(), " bytes]");
-  if (input.empty()) {
-    return is_valid = false;
-  }  // technically unnecessary.
-  // If input starts with U+005B ([), then:
-  if (input[0] == '[') {
-    // If input does not end with U+005D (]), validation error, return failure.
-    if (input.back() != ']') {
-      return is_valid = false;
-    }
-    ada_log("parse_host ipv6");
-
-    // Return the result of IPv6 parsing input with its leading U+005B ([) and
-    // trailing U+005D (]) removed.
-    input.remove_prefix(1);
-    input.remove_suffix(1);
-    return parse_ipv6(input);
-  }
-
-  // If isNotSpecial is true, then return the result of opaque-host parsing
-  // input.
-  if (!is_special()) {
-    return parse_opaque_host(input);
-  }
-  // Let domain be the result of running UTF-8 decode without BOM on the
-  // percent-decoding of input. Let asciiDomain be the result of running domain
-  // to ASCII with domain and false. The most common case is an ASCII input, in
-  // which case we do not need to call the expensive 'to_ascii' if a few
-  // conditions are met: no '%' and no 'xn-' subsequence.
-  std::string buffer = std::string(input);
-  // This next function checks that the result is ascii, but we are going to
-  // to check anyhow with is_forbidden.
-  // bool is_ascii =
-  unicode::to_lower_ascii(buffer.data(), buffer.size());
-  bool is_forbidden = unicode::contains_forbidden_domain_code_point(
-      buffer.data(), buffer.size());
-  if (is_forbidden == 0 && buffer.find("xn-") == std::string_view::npos) {
-    // fast path
-    host = std::move(buffer);
-    if (checkers::is_ipv4(host.value())) {
-      ada_log("parse_host fast path ipv4");
-      return parse_ipv4(host.value());
-    }
-    ada_log("parse_host fast path ", *host);
-    return true;
-  }
-  ada_log("parse_host calling to_ascii");
-  is_valid = ada::unicode::to_ascii(host, input, input.find('%'));
-  if (!is_valid) {
-    ada_log("parse_host to_ascii returns false");
-    return is_valid = false;
-  }
-  ada_log("parse_host to_ascii succeeded ", *host, " [", host->size(),
-          " bytes]");
-
-  if (std::any_of(host.value().begin(), host.value().end(),
-                  ada::unicode::is_forbidden_domain_code_point)) {
-    host = std::nullopt;
-    return is_valid = false;
-  }
-
-  // If asciiDomain ends in a number, then return the result of IPv4 parsing
-  // asciiDomain.
-  if (checkers::is_ipv4(host.value())) {
-    ada_log("parse_host got ipv4 ", *host);
-    return parse_ipv4(host.value());
-  }
-
-  return true;
-}
-
-ada_really_inline void url::parse_path(std::string_view input) {
-  ada_log("parse_path ", input);
-  std::string tmp_buffer;
-  std::string_view internal_input;
-  if (unicode::has_tabs_or_newline(input)) {
-    tmp_buffer = input;
-    // Optimization opportunity: Instead of copying and then pruning, we could
-    // just directly build the string from user_input.
-    helpers::remove_ascii_tab_or_newline(tmp_buffer);
-    internal_input = tmp_buffer;
-  } else {
-    internal_input = input;
-  }
-
-  // If url is special, then:
-  if (is_special()) {
-    if (internal_input.empty()) {
-      path = "/";
-    } else if ((internal_input[0] == '/') || (internal_input[0] == '\\')) {
-      helpers::parse_prepared_path(internal_input.substr(1), type, path);
-    } else {
-      helpers::parse_prepared_path(internal_input, type, path);
-    }
-  } else if (!internal_input.empty()) {
-    if (internal_input[0] == '/') {
-      helpers::parse_prepared_path(internal_input.substr(1), type, path);
-    } else {
-      helpers::parse_prepared_path(internal_input, type, path);
-    }
-  } else {
-    if (!host.has_value()) {
-      path = "/";
-    }
-  }
-}
-
-[[nodiscard]] std::string url::to_string() const {
-  if (!is_valid) {
-    return "null";
-  }
-  std::string answer;
-  auto back = std::back_insert_iterator(answer);
-  answer.append("{\n");
-  answer.append("\t\"protocol\":\"");
-  helpers::encode_json(get_protocol(), back);
-  answer.append("\",\n");
-  if (has_credentials()) {
-    answer.append("\t\"username\":\"");
-    helpers::encode_json(username, back);
-    answer.append("\",\n");
-    answer.append("\t\"password\":\"");
-    helpers::encode_json(password, back);
-    answer.append("\",\n");
-  }
-  if (host.has_value()) {
-    answer.append("\t\"host\":\"");
-    helpers::encode_json(host.value(), back);
-    answer.append("\",\n");
-  }
-  if (port.has_value()) {
-    answer.append("\t\"port\":\"");
-    answer.append(std::to_string(port.value()));
-    answer.append("\",\n");
-  }
-  answer.append("\t\"path\":\"");
-  helpers::encode_json(path, back);
-  answer.append("\",\n");
-  answer.append("\t\"opaque path\":");
-  answer.append((has_opaque_path ? "true" : "false"));
-  if (has_search()) {
-    answer.append(",\n");
-    answer.append("\t\"query\":\"");
-    helpers::encode_json(query.value(), back);
-    answer.append("\"");
-  }
-  if (hash.has_value()) {
-    answer.append(",\n");
-    answer.append("\t\"hash\":\"");
-    helpers::encode_json(hash.value(), back);
-    answer.append("\"");
-  }
-  answer.append("\n}");
-  return answer;
-}
-
-[[nodiscard]] bool url::has_valid_domain() const noexcept {
-  if (!host.has_value()) {
-    return false;
-  }
-  return checkers::verify_dns_length(host.value());
-}
-
-[[nodiscard]] std::string url::get_origin() const noexcept {
-  if (is_special()) {
-    // Return a new opaque origin.
-    if (type == scheme::FILE) {
-      return "null";
-    }
-    return ada::helpers::concat(get_protocol(), "//", get_host());
-  }
-
-  if (non_special_scheme == "blob") {
-    if (!path.empty()) {
-      auto result = ada::parse<ada::url>(path);
-      if (result &&
-          (result->type == scheme::HTTP || result->type == scheme::HTTPS)) {
-        // If pathURL's scheme is not "http" and not "https", then return a
-        // new opaque origin.
-        return ada::helpers::concat(result->get_protocol(), "//",
-                                    result->get_host());
-      }
-    }
-  }
-
-  // Return a new opaque origin.
-  return "null";
-}
-
-[[nodiscard]] std::string url::get_protocol() const noexcept {
-  if (is_special()) {
-    return helpers::concat(ada::scheme::details::is_special_list[type], ":");
-  }
-  // We only move the 'scheme' if it is non-special.
-  return helpers::concat(non_special_scheme, ":");
-}
-
-[[nodiscard]] std::string url::get_host() const noexcept {
-  // If url's host is null, then return the empty string.
-  // If url's port is null, return url's host, serialized.
-  // Return url's host, serialized, followed by U+003A (:) and url's port,
-  // serialized.
-  if (!host.has_value()) {
-    return "";
-  }
-  if (port.has_value()) {
-    return host.value() + ":" + get_port();
-  }
-  return host.value();
-}
-
-[[nodiscard]] std::string url::get_hostname() const noexcept {
-  return host.value_or("");
-}
-
-[[nodiscard]] std::string url::get_search() const noexcept {
-  // If this's URL's query is either null or the empty string, then return the
-  // empty string. Return U+003F (?), followed by this's URL's query.
-  return (!query.has_value() || (query.value().empty())) ? ""
-                                                         : "?" + query.value();
-}
-
-[[nodiscard]] const std::string& url::get_username() const noexcept {
-  return username;
-}
-
-[[nodiscard]] const std::string& url::get_password() const noexcept {
-  return password;
-}
-
-[[nodiscard]] std::string url::get_port() const noexcept {
-  return port.has_value() ? std::to_string(port.value()) : "";
-}
-
-[[nodiscard]] std::string url::get_hash() const noexcept {
-  // If this's URL's fragment is either null or the empty string, then return
-  // the empty string. Return U+0023 (#), followed by this's URL's fragment.
-  return (!hash.has_value() || (hash.value().empty())) ? ""
-                                                       : "#" + hash.value();
-}
-
-template <bool override_hostname>
-bool url::set_host_or_hostname(const std::string_view input) {
-  if (has_opaque_path) {
-    return false;
-  }
-
-  std::optional<std::string> previous_host = host;
-  std::optional<uint16_t> previous_port = port;
-
-  size_t host_end_pos = input.find('#');
-  std::string _host(input.data(), host_end_pos != std::string_view::npos
-                                      ? host_end_pos
-                                      : input.size());
-  helpers::remove_ascii_tab_or_newline(_host);
-  std::string_view new_host(_host);
-
-  // If url's scheme is "file", then set state to file host state, instead of
-  // host state.
-  if (type != ada::scheme::type::FILE) {
-    std::string_view host_view(_host.data(), _host.length());
-    auto [location, found_colon] =
-        helpers::get_host_delimiter_location(is_special(), host_view);
-
-    // Otherwise, if c is U+003A (:) and insideBrackets is false, then:
-    // Note: the 'found_colon' value is true if and only if a colon was
-    // encountered while not inside brackets.
-    if (found_colon) {
-      if constexpr (override_hostname) {
-        return false;
-      }
-      std::string_view buffer = new_host.substr(location + 1);
-      if (!buffer.empty()) {
-        set_port(buffer);
-      }
-    }
-    // If url is special and host_view is the empty string, validation error,
-    // return failure. Otherwise, if state override is given, host_view is the
-    // empty string, and either url includes credentials or url's port is
-    // non-null, return.
-    else if (host_view.empty() &&
-             (is_special() || has_credentials() || port.has_value())) {
-      return false;
-    }
-
-    // Let host be the result of host parsing host_view with url is not special.
-    if (host_view.empty() && !is_special()) {
-      host = "";
-      return true;
-    }
-
-    bool succeeded = parse_host(host_view);
-    if (!succeeded) {
-      host = std::move(previous_host);
-      update_base_port(previous_port);
-    }
-    return succeeded;
-  }
-
-  size_t location = new_host.find_first_of("/\\?");
-  if (location != std::string_view::npos) {
-    new_host.remove_suffix(new_host.length() - location);
-  }
-
-  if (new_host.empty()) {
-    // Set url's host to the empty string.
-    host = "";
-  } else {
-    // Let host be the result of host parsing buffer with url is not special.
-    if (!parse_host(new_host)) {
-      host = std::move(previous_host);
-      update_base_port(previous_port);
-      return false;
-    }
-
-    // If host is "localhost", then set host to the empty string.
-    if (host == "localhost") {
-      host = "";
-    }
-  }
-  return true;
-}
-
-bool url::set_host(const std::string_view input) {
-  return set_host_or_hostname<false>(input);
-}
-
-bool url::set_hostname(const std::string_view input) {
-  return set_host_or_hostname<true>(input);
-}
-
-bool url::set_username(const std::string_view input) {
-  if (cannot_have_credentials_or_port()) {
-    return false;
-  }
-  username = ada::unicode::percent_encode(
-      input, character_sets::USERINFO_PERCENT_ENCODE);
-  return true;
-}
-
-bool url::set_password(const std::string_view input) {
-  if (cannot_have_credentials_or_port()) {
-    return false;
-  }
-  password = ada::unicode::percent_encode(
-      input, character_sets::USERINFO_PERCENT_ENCODE);
-  return true;
-}
-
-bool url::set_port(const std::string_view input) {
-  if (cannot_have_credentials_or_port()) {
-    return false;
-  }
-  std::string trimmed(input);
-  helpers::remove_ascii_tab_or_newline(trimmed);
-  if (trimmed.empty()) {
-    port = std::nullopt;
-    return true;
-  }
-
-  // Input should not start with a non-digit character.
-  if (!ada::unicode::is_ascii_digit(trimmed.front())) {
-    return false;
-  }
-
-  // Revert changes if parse_port fails.
-  std::optional<uint16_t> previous_port = port;
-  parse_port(trimmed);
-  if (is_valid) {
-    return true;
-  }
-  port = std::move(previous_port);
-  is_valid = true;
-  return false;
-}
-
-void url::set_hash(const std::string_view input) {
-  if (input.empty()) {
-    hash = std::nullopt;
-    helpers::strip_trailing_spaces_from_opaque_path(*this);
-    return;
-  }
-
-  std::string new_value;
-  new_value = input[0] == '#' ? input.substr(1) : input;
-  helpers::remove_ascii_tab_or_newline(new_value);
-  hash = unicode::percent_encode(new_value,
-                                 ada::character_sets::FRAGMENT_PERCENT_ENCODE);
-}
-
-void url::set_search(const std::string_view input) {
-  if (input.empty()) {
-    query = std::nullopt;
-    helpers::strip_trailing_spaces_from_opaque_path(*this);
-    return;
-  }
-
-  std::string new_value;
-  new_value = input[0] == '?' ? input.substr(1) : input;
-  helpers::remove_ascii_tab_or_newline(new_value);
-
-  auto query_percent_encode_set =
-      is_special() ? ada::character_sets::SPECIAL_QUERY_PERCENT_ENCODE
-                   : ada::character_sets::QUERY_PERCENT_ENCODE;
-
-  query = ada::unicode::percent_encode(new_value, query_percent_encode_set);
-}
-
-bool url::set_pathname(const std::string_view input) {
-  if (has_opaque_path) {
-    return false;
-  }
-  path.clear();
-  parse_path(input);
-  return true;
-}
-
-bool url::set_protocol(const std::string_view input) {
-  std::string view(input);
-  helpers::remove_ascii_tab_or_newline(view);
-  if (view.empty()) {
-    return true;
-  }
-
-  // Schemes should start with alpha values.
-  if (!checkers::is_alpha(view[0])) {
-    return false;
-  }
-
-  view.append(":");
-
-  std::string::iterator pointer =
-      std::ranges::find_if_not(view, unicode::is_alnum_plus);
-
-  if (pointer != view.end() && *pointer == ':') {
-    return parse_scheme<true>(
-        std::string_view(view.data(), pointer - view.begin()));
-  }
-  return false;
-}
-
-bool url::set_href(const std::string_view input) {
-  ada::result<ada::url> out = ada::parse<ada::url>(input);
-
-  if (out) {
-    *this = *out;
-  }
-
-  return out.has_value();
-}
-
-}  // namespace ada
-/* end file src/url.cpp */
-/* begin file src/parser.cpp */
-
-#include <limits>
-
-
-namespace ada::parser {
-
-template <class result_type, bool store_values>
-result_type parse_url_impl(std::string_view user_input,
-                           const result_type* base_url) {
-  // We can specialize the implementation per type.
-  // Important: result_type_is_ada_url is evaluated at *compile time*. This
-  // means that doing if constexpr(result_type_is_ada_url) { something } else {
-  // something else } is free (at runtime). This means that ada::url_aggregator
-  // and ada::url **do not have to support the exact same API**.
-  constexpr bool result_type_is_ada_url = std::is_same_v<url, result_type>;
-  constexpr bool result_type_is_ada_url_aggregator =
-      std::is_same_v<url_aggregator, result_type>;
-  static_assert(result_type_is_ada_url ||
-                result_type_is_ada_url_aggregator);  // We don't support
-                                                     // anything else for now.
-
-  ada_log("ada::parser::parse_url('", user_input, "' [", user_input.size(),
-          " bytes],", (base_url != nullptr ? base_url->to_string() : "null"),
-          ")");
-
-  state state = state::SCHEME_START;
-  result_type url{};
-
-  // We refuse to parse URL strings that exceed 4GB. Such strings are almost
-  // surely the result of a bug or are otherwise a security concern.
-  if (user_input.size() > std::numeric_limits<uint32_t>::max()) [[unlikely]] {
-    url.is_valid = false;
-  }
-  // Going forward, user_input.size() is in [0,
-  // std::numeric_limits<uint32_t>::max). If we are provided with an invalid
-  // base, or the optional_url was invalid, we must return.
-  if (base_url != nullptr) {
-    url.is_valid &= base_url->is_valid;
-  }
-  if (!url.is_valid) {
-    return url;
-  }
-  if constexpr (result_type_is_ada_url_aggregator && store_values) {
-    // Most of the time, we just need user_input.size().
-    // In some instances, we may need a bit more.
-    ///////////////////////////
-    // This is *very* important. This line should *not* be removed
-    // hastily. There are principled reasons why reserve is important
-    // for performance. If you have a benchmark with small inputs,
-    // it may not matter, but in other instances, it could.
-    ////
-    // This rounds up to the next power of two.
-    // We know that user_input.size() is in [0,
-    // std::numeric_limits<uint32_t>::max).
-    uint32_t reserve_capacity =
-        (0xFFFFFFFF >>
-         helpers::leading_zeroes(uint32_t(1 | user_input.size()))) +
-        1;
-    url.reserve(reserve_capacity);
-  }
-  std::string tmp_buffer;
-  std::string_view url_data;
-  if (unicode::has_tabs_or_newline(user_input)) [[unlikely]] {
-    tmp_buffer = user_input;
-    // Optimization opportunity: Instead of copying and then pruning, we could
-    // just directly build the string from user_input.
-    helpers::remove_ascii_tab_or_newline(tmp_buffer);
-    url_data = tmp_buffer;
-  } else [[likely]] {
-    url_data = user_input;
-  }
-
-  // Leading and trailing control characters are uncommon and easy to deal with
-  // (no performance concern).
-  helpers::trim_c0_whitespace(url_data);
-
-  // Optimization opportunity. Most websites do not have fragment.
-  std::optional<std::string_view> fragment = helpers::prune_hash(url_data);
-  // We add it last so that an implementation like ada::url_aggregator
-  // can append it last to its internal buffer, thus improving performance.
-
-  // Here url_data no longer has its fragment.
-  // We are going to access the data from url_data (it is immutable).
-  // At any given time, we are pointing at byte 'input_position' in url_data.
-  // The input_position variable should range from 0 to input_size.
-  // It is illegal to access url_data at input_size.
-  size_t input_position = 0;
-  const size_t input_size = url_data.size();
-  // Keep running the following state machine by switching on state.
-  // If after a run pointer points to the EOF code point, go to the next step.
-  // Otherwise, increase pointer by 1 and continue with the state machine.
-  // We never decrement input_position.
-  while (input_position <= input_size) {
-    ada_log("In parsing at ", input_position, " out of ", input_size,
-            " in state ", ada::to_string(state));
-    switch (state) {
-      case state::SCHEME_START: {
-        ada_log("SCHEME_START ", helpers::substring(url_data, input_position));
-        // If c is an ASCII alpha, append c, lowercased, to buffer, and set
-        // state to scheme state.
-        if ((input_position != input_size) &&
-            checkers::is_alpha(url_data[input_position])) {
-          state = state::SCHEME;
-          input_position++;
-        } else {
-          // Otherwise, if state override is not given, set state to no scheme
-          // state and decrease pointer by 1.
-          state = state::NO_SCHEME;
-        }
-        break;
-      }
-      case state::SCHEME: {
-        ada_log("SCHEME ", helpers::substring(url_data, input_position));
-        // If c is an ASCII alphanumeric, U+002B (+), U+002D (-), or U+002E (.),
-        // append c, lowercased, to buffer.
-        while ((input_position != input_size) &&
-               (unicode::is_alnum_plus(url_data[input_position]))) {
-          input_position++;
-        }
-        // Otherwise, if c is U+003A (:), then:
-        if ((input_position != input_size) &&
-            (url_data[input_position] == ':')) {
-          ada_log("SCHEME the scheme should be ",
-                  url_data.substr(0, input_position));
-          if constexpr (result_type_is_ada_url) {
-            if (!url.parse_scheme(url_data.substr(0, input_position))) {
-              return url;
-            }
-          } else {
-            // we pass the colon along instead of painfully adding it back.
-            if (!url.parse_scheme_with_colon(
-                    url_data.substr(0, input_position + 1))) {
-              return url;
-            }
-          }
-          ada_log("SCHEME the scheme is ", url.get_protocol());
-
-          // If url's scheme is "file", then:
-          if (url.type == scheme::type::FILE) {
-            // Set state to file state.
-            state = state::FILE;
-          }
-          // Otherwise, if url is special, base is non-null, and base's scheme
-          // is url's scheme: Note: Doing base_url->scheme is unsafe if base_url
-          // != nullptr is false.
-          else if (url.is_special() && base_url != nullptr &&
-                   base_url->type == url.type) {
-            // Set state to special relative or authority state.
-            state = state::SPECIAL_RELATIVE_OR_AUTHORITY;
-          }
-          // Otherwise, if url is special, set state to special authority
-          // slashes state.
-          else if (url.is_special()) {
-            state = state::SPECIAL_AUTHORITY_SLASHES;
-          }
-          // Otherwise, if remaining starts with an U+002F (/), set state to
-          // path or authority state and increase pointer by 1.
-          else if (input_position + 1 < input_size &&
-                   url_data[input_position + 1] == '/') {
-            state = state::PATH_OR_AUTHORITY;
-            input_position++;
-          }
-          // Otherwise, set url's path to the empty string and set state to
-          // opaque path state.
-          else {
-            state = state::OPAQUE_PATH;
-          }
-        }
-        // Otherwise, if state override is not given, set buffer to the empty
-        // string, state to no scheme state, and start over (from the first code
-        // point in input).
-        else {
-          state = state::NO_SCHEME;
-          input_position = 0;
-          break;
-        }
-        input_position++;
-        break;
-      }
-      case state::NO_SCHEME: {
-        ada_log("NO_SCHEME ", helpers::substring(url_data, input_position));
-        // If base is null, or base has an opaque path and c is not U+0023 (#),
-        // validation error, return failure.
-        if (base_url == nullptr ||
-            (base_url->has_opaque_path && !fragment.has_value())) {
-          ada_log("NO_SCHEME validation error");
-          url.is_valid = false;
-          return url;
-        }
-        // Otherwise, if base has an opaque path and c is U+0023 (#),
-        // set url's scheme to base's scheme, url's path to base's path, url's
-        // query to base's query, and set state to fragment state.
-        else if (base_url->has_opaque_path && fragment.has_value() &&
-                 input_position == input_size) {
-          ada_log("NO_SCHEME opaque base with fragment");
-          url.copy_scheme(*base_url);
-          url.has_opaque_path = base_url->has_opaque_path;
-
-          if constexpr (result_type_is_ada_url) {
-            url.path = base_url->path;
-            url.query = base_url->query;
-          } else {
-            url.update_base_pathname(base_url->get_pathname());
-            url.update_base_search(base_url->get_search());
-          }
-          url.update_unencoded_base_hash(*fragment);
-          return url;
-        }
-        // Otherwise, if base's scheme is not "file", set state to relative
-        // state and decrease pointer by 1.
-        else if (base_url->type != scheme::type::FILE) {
-          ada_log("NO_SCHEME non-file relative path");
-          state = state::RELATIVE_SCHEME;
-        }
-        // Otherwise, set state to file state and decrease pointer by 1.
-        else {
-          ada_log("NO_SCHEME file base type");
-          state = state::FILE;
-        }
-        break;
-      }
-      case state::AUTHORITY: {
-        ada_log("AUTHORITY ", helpers::substring(url_data, input_position));
-        // most URLs have no @. Having no @ tells us that we don't have to worry
-        // about AUTHORITY. Of course, we could have @ and still not have to
-        // worry about AUTHORITY.
-        // TODO: Instead of just collecting a bool, collect the location of the
-        // '@' and do something useful with it.
-        // TODO: We could do various processing early on, using a single pass
-        // over the string to collect information about it, e.g., telling us
-        // whether there is a @ and if so, where (or how many).
-
-        // Check if url data contains an @.
-        if (url_data.find('@', input_position) == std::string_view::npos) {
-          state = state::HOST;
-          break;
-        }
-        bool at_sign_seen{false};
-        bool password_token_seen{false};
-        /**
-         * We expect something of the sort...
-         * https://user:pass@example.com:1234/foo/bar?baz#quux
-         * --------^
-         */
-        do {
-          std::string_view view = url_data.substr(input_position);
-          // The delimiters are @, /, ? \\.
-          size_t location =
-              url.is_special() ? helpers::find_authority_delimiter_special(view)
-                               : helpers::find_authority_delimiter(view);
-          std::string_view authority_view = view.substr(0, location);
-          size_t end_of_authority = input_position + authority_view.size();
-          // If c is U+0040 (@), then:
-          if ((end_of_authority != input_size) &&
-              (url_data[end_of_authority] == '@')) {
-            // If atSignSeen is true, then prepend "%40" to buffer.
-            if (at_sign_seen) {
-              if (password_token_seen) {
-                if constexpr (result_type_is_ada_url) {
-                  url.password += "%40";
-                } else {
-                  url.append_base_password("%40");
-                }
-              } else {
-                if constexpr (result_type_is_ada_url) {
-                  url.username += "%40";
-                } else {
-                  url.append_base_username("%40");
-                }
-              }
-            }
-
-            at_sign_seen = true;
-
-            if (!password_token_seen) {
-              size_t password_token_location = authority_view.find(':');
-              password_token_seen =
-                  password_token_location != std::string_view::npos;
-
-              if constexpr (store_values) {
-                if (!password_token_seen) {
-                  if constexpr (result_type_is_ada_url) {
-                    url.username += unicode::percent_encode(
-                        authority_view,
-                        character_sets::USERINFO_PERCENT_ENCODE);
-                  } else {
-                    url.append_base_username(unicode::percent_encode(
-                        authority_view,
-                        character_sets::USERINFO_PERCENT_ENCODE));
-                  }
-                } else {
-                  if constexpr (result_type_is_ada_url) {
-                    url.username += unicode::percent_encode(
-                        authority_view.substr(0, password_token_location),
-                        character_sets::USERINFO_PERCENT_ENCODE);
-                    url.password += unicode::percent_encode(
-                        authority_view.substr(password_token_location + 1),
-                        character_sets::USERINFO_PERCENT_ENCODE);
-                  } else {
-                    url.append_base_username(unicode::percent_encode(
-                        authority_view.substr(0, password_token_location),
-                        character_sets::USERINFO_PERCENT_ENCODE));
-                    url.append_base_password(unicode::percent_encode(
-                        authority_view.substr(password_token_location + 1),
-                        character_sets::USERINFO_PERCENT_ENCODE));
-                  }
-                }
-              }
-            } else if constexpr (store_values) {
-              if constexpr (result_type_is_ada_url) {
-                url.password += unicode::percent_encode(
-                    authority_view, character_sets::USERINFO_PERCENT_ENCODE);
-              } else {
-                url.append_base_password(unicode::percent_encode(
-                    authority_view, character_sets::USERINFO_PERCENT_ENCODE));
-              }
-            }
-          }
-          // Otherwise, if one of the following is true:
-          // - c is the EOF code point, U+002F (/), U+003F (?), or U+0023 (#)
-          // - url is special and c is U+005C (\)
-          else if (end_of_authority == input_size ||
-                   url_data[end_of_authority] == '/' ||
-                   url_data[end_of_authority] == '?' ||
-                   (url.is_special() && url_data[end_of_authority] == '\\')) {
-            // If atSignSeen is true and authority_view is the empty string,
-            // validation error, return failure.
-            if (at_sign_seen && authority_view.empty()) {
-              url.is_valid = false;
-              return url;
-            }
-            state = state::HOST;
-            break;
-          }
-          if (end_of_authority == input_size) {
-            if constexpr (store_values) {
-              if (fragment.has_value()) {
-                url.update_unencoded_base_hash(*fragment);
-              }
-            }
-            return url;
-          }
-          input_position = end_of_authority + 1;
-        } while (true);
-
-        break;
-      }
-      case state::SPECIAL_RELATIVE_OR_AUTHORITY: {
-        ada_log("SPECIAL_RELATIVE_OR_AUTHORITY ",
-                helpers::substring(url_data, input_position));
-
-        // If c is U+002F (/) and remaining starts with U+002F (/),
-        // then set state to special authority ignore slashes state and increase
-        // pointer by 1.
-        if (url_data.substr(input_position, 2) == "//") {
-          state = state::SPECIAL_AUTHORITY_IGNORE_SLASHES;
-          input_position += 2;
-        } else {
-          // Otherwise, validation error, set state to relative state and
-          // decrease pointer by 1.
-          state = state::RELATIVE_SCHEME;
-        }
-
-        break;
-      }
-      case state::PATH_OR_AUTHORITY: {
-        ada_log("PATH_OR_AUTHORITY ",
-                helpers::substring(url_data, input_position));
-
-        // If c is U+002F (/), then set state to authority state.
-        if ((input_position != input_size) &&
-            (url_data[input_position] == '/')) {
-          state = state::AUTHORITY;
-          input_position++;
-        } else {
-          // Otherwise, set state to path state, and decrease pointer by 1.
-          state = state::PATH;
-        }
-
-        break;
-      }
-      case state::RELATIVE_SCHEME: {
-        ada_log("RELATIVE_SCHEME ",
-                helpers::substring(url_data, input_position));
-
-        // Set url's scheme to base's scheme.
-        url.copy_scheme(*base_url);
-
-        // If c is U+002F (/), then set state to relative slash state.
-        if ((input_position != input_size) &&
-            (url_data[input_position] == '/')) {
-          ada_log(
-              "RELATIVE_SCHEME if c is U+002F (/), then set state to relative "
-              "slash state");
-          state = state::RELATIVE_SLASH;
-        } else if (url.is_special() && (input_position != input_size) &&
-                   (url_data[input_position] == '\\')) {
-          // Otherwise, if url is special and c is U+005C (\), validation error,
-          // set state to relative slash state.
-          ada_log(
-              "RELATIVE_SCHEME  if url is special and c is U+005C, validation "
-              "error, set state to relative slash state");
-          state = state::RELATIVE_SLASH;
-        } else {
-          ada_log("RELATIVE_SCHEME otherwise");
-          // Set url's username to base's username, url's password to base's
-          // password, url's host to base's host, url's port to base's port,
-          // url's path to a clone of base's path, and url's query to base's
-          // query.
-          if constexpr (result_type_is_ada_url) {
-            url.username = base_url->username;
-            url.password = base_url->password;
-            url.host = base_url->host;
-            url.port = base_url->port;
-            // cloning the base path includes cloning the has_opaque_path flag
-            url.has_opaque_path = base_url->has_opaque_path;
-            url.path = base_url->path;
-            url.query = base_url->query;
-          } else {
-            url.update_base_authority(base_url->get_href(),
-                                      base_url->get_components());
-            url.update_host_to_base_host(base_url->get_hostname());
-            url.update_base_port(base_url->retrieve_base_port());
-            // cloning the base path includes cloning the has_opaque_path flag
-            url.has_opaque_path = base_url->has_opaque_path;
-            url.update_base_pathname(base_url->get_pathname());
-            url.update_base_search(base_url->get_search());
-          }
-
-          url.has_opaque_path = base_url->has_opaque_path;
-
-          // If c is U+003F (?), then set url's query to the empty string, and
-          // state to query state.
-          if ((input_position != input_size) &&
-              (url_data[input_position] == '?')) {
-            state = state::QUERY;
-          }
-          // Otherwise, if c is not the EOF code point:
-          else if (input_position != input_size) {
-            // Set url's query to null.
-            url.clear_search();
-            if constexpr (result_type_is_ada_url) {
-              // Shorten url's path.
-              helpers::shorten_path(url.path, url.type);
-            } else {
-              std::string_view path = url.get_pathname();
-              if (helpers::shorten_path(path, url.type)) {
-                url.update_base_pathname(std::move(std::string(path)));
-              }
-            }
-            // Set state to path state and decrease pointer by 1.
-            state = state::PATH;
-            break;
-          }
-        }
-        input_position++;
-        break;
-      }
-      case state::RELATIVE_SLASH: {
-        ada_log("RELATIVE_SLASH ",
-                helpers::substring(url_data, input_position));
-
-        // If url is special and c is U+002F (/) or U+005C (\), then:
-        if (url.is_special() && (input_position != input_size) &&
-            (url_data[input_position] == '/' ||
-             url_data[input_position] == '\\')) {
-          // Set state to special authority ignore slashes state.
-          state = state::SPECIAL_AUTHORITY_IGNORE_SLASHES;
-        }
-        // Otherwise, if c is U+002F (/), then set state to authority state.
-        else if ((input_position != input_size) &&
-                 (url_data[input_position] == '/')) {
-          state = state::AUTHORITY;
-        }
-        // Otherwise, set
-        // - url's username to base's username,
-        // - url's password to base's password,
-        // - url's host to base's host,
-        // - url's port to base's port,
-        // - state to path state, and then, decrease pointer by 1.
-        else {
-          if constexpr (result_type_is_ada_url) {
-            url.username = base_url->username;
-            url.password = base_url->password;
-            url.host = base_url->host;
-            url.port = base_url->port;
-          } else {
-            url.update_base_authority(base_url->get_href(),
-                                      base_url->get_components());
-            url.update_host_to_base_host(base_url->get_hostname());
-            url.update_base_port(base_url->retrieve_base_port());
-          }
-          state = state::PATH;
-          break;
-        }
-
-        input_position++;
-        break;
-      }
-      case state::SPECIAL_AUTHORITY_SLASHES: {
-        ada_log("SPECIAL_AUTHORITY_SLASHES ",
-                helpers::substring(url_data, input_position));
-
-        // If c is U+002F (/) and remaining starts with U+002F (/),
-        // then set state to special authority ignore slashes state and increase
-        // pointer by 1.
-        if (url_data.substr(input_position, 2) == "//") {
-          input_position += 2;
-        }
-
-        [[fallthrough]];
-      }
-      case state::SPECIAL_AUTHORITY_IGNORE_SLASHES: {
-        ada_log("SPECIAL_AUTHORITY_IGNORE_SLASHES ",
-                helpers::substring(url_data, input_position));
-
-        // If c is neither U+002F (/) nor U+005C (\), then set state to
-        // authority state and decrease pointer by 1.
-        while ((input_position != input_size) &&
-               ((url_data[input_position] == '/') ||
-                (url_data[input_position] == '\\'))) {
-          input_position++;
-        }
-        state = state::AUTHORITY;
-
-        break;
-      }
-      case state::QUERY: {
-        ada_log("QUERY ", helpers::substring(url_data, input_position));
-        if constexpr (store_values) {
-          // Let queryPercentEncodeSet be the special-query percent-encode set
-          // if url is special; otherwise the query percent-encode set.
-          const uint8_t* query_percent_encode_set =
-              url.is_special() ? character_sets::SPECIAL_QUERY_PERCENT_ENCODE
-                               : character_sets::QUERY_PERCENT_ENCODE;
-
-          // Percent-encode after encoding, with encoding, buffer, and
-          // queryPercentEncodeSet, and append the result to url's query.
-          url.update_base_search(url_data.substr(input_position),
-                                 query_percent_encode_set);
-          ada_log("QUERY update_base_search completed ");
-          if (fragment.has_value()) {
-            url.update_unencoded_base_hash(*fragment);
-          }
-        }
-        return url;
-      }
-      case state::HOST: {
-        ada_log("HOST ", helpers::substring(url_data, input_position));
-
-        std::string_view host_view = url_data.substr(input_position);
-        auto [location, found_colon] =
-            helpers::get_host_delimiter_location(url.is_special(), host_view);
-        input_position = (location != std::string_view::npos)
-                             ? input_position + location
-                             : input_size;
-        // Otherwise, if c is U+003A (:) and insideBrackets is false, then:
-        // Note: the 'found_colon' value is true if and only if a colon was
-        // encountered while not inside brackets.
-        if (found_colon) {
-          // If buffer is the empty string, validation error, return failure.
-          // Let host be the result of host parsing buffer with url is not
-          // special.
-          ada_log("HOST parsing ", host_view);
-          if (!url.parse_host(host_view)) {
-            return url;
-          }
-          ada_log("HOST parsing results in ", url.get_hostname());
-          // Set url's host to host, buffer to the empty string, and state to
-          // port state.
-          state = state::PORT;
-          input_position++;
-        }
-        // Otherwise, if one of the following is true:
-        // - c is the EOF code point, U+002F (/), U+003F (?), or U+0023 (#)
-        // - url is special and c is U+005C (\)
-        // The get_host_delimiter_location function either brings us to
-        // the colon outside of the bracket, or to one of those characters.
-        else {
-          // If url is special and host_view is the empty string, validation
-          // error, return failure.
-          if (host_view.empty() && url.is_special()) {
-            url.is_valid = false;
-            return url;
-          }
-          ada_log("HOST parsing ", host_view, " href=", url.get_href());
-          // Let host be the result of host parsing host_view with url is not
-          // special.
-          if (host_view.empty()) {
-            url.update_base_hostname("");
-          } else if (!url.parse_host(host_view)) {
-            return url;
-          }
-          ada_log("HOST parsing results in ", url.get_hostname(),
-                  " href=", url.get_href());
-
-          // Set url's host to host, and state to path start state.
-          state = state::PATH_START;
-        }
-
-        break;
-      }
-      case state::OPAQUE_PATH: {
-        ada_log("OPAQUE_PATH ", helpers::substring(url_data, input_position));
-        std::string_view view = url_data.substr(input_position);
-        // If c is U+003F (?), then set url's query to the empty string and
-        // state to query state.
-        size_t location = view.find('?');
-        if (location != std::string_view::npos) {
-          view.remove_suffix(view.size() - location);
-          state = state::QUERY;
-          input_position += location + 1;
-        } else {
-          input_position = input_size + 1;
-        }
-        url.has_opaque_path = true;
-        // This is a really unlikely scenario in real world. We should not seek
-        // to optimize it.
-        url.update_base_pathname(unicode::percent_encode(
-            view, character_sets::C0_CONTROL_PERCENT_ENCODE));
-        break;
-      }
-      case state::PORT: {
-        ada_log("PORT ", helpers::substring(url_data, input_position));
-        std::string_view port_view = url_data.substr(input_position);
-        input_position += url.parse_port(port_view, true);
-        if (!url.is_valid) {
-          return url;
-        }
-        state = state::PATH_START;
-        [[fallthrough]];
-      }
-      case state::PATH_START: {
-        ada_log("PATH_START ", helpers::substring(url_data, input_position));
-
-        // If url is special, then:
-        if (url.is_special()) {
-          // Set state to path state.
-          state = state::PATH;
-
-          // Optimization: Avoiding going into PATH state improves the
-          // performance of urls ending with /.
-          if (input_position == input_size) {
-            if constexpr (store_values) {
-              url.update_base_pathname("/");
-              if (fragment.has_value()) {
-                url.update_unencoded_base_hash(*fragment);
-              }
-            }
-            return url;
-          }
-          // If c is neither U+002F (/) nor U+005C (\), then decrease pointer
-          // by 1. We know that (input_position == input_size) is impossible
-          // here, because of the previous if-check.
-          if ((url_data[input_position] != '/') &&
-              (url_data[input_position] != '\\')) {
-            break;
-          }
-        }
-        // Otherwise, if state override is not given and c is U+003F (?),
-        // set url's query to the empty string and state to query state.
-        else if ((input_position != input_size) &&
-                 (url_data[input_position] == '?')) {
-          state = state::QUERY;
-        }
-        // Otherwise, if c is not the EOF code point:
-        else if (input_position != input_size) {
-          // Set state to path state.
-          state = state::PATH;
-
-          // If c is not U+002F (/), then decrease pointer by 1.
-          if (url_data[input_position] != '/') {
-            break;
-          }
-        }
-
-        input_position++;
-        break;
-      }
-      case state::PATH: {
-        ada_log("PATH ", helpers::substring(url_data, input_position));
-        std::string_view view = url_data.substr(input_position);
-
-        // Most time, we do not need percent encoding.
-        // Furthermore, we can immediately locate the '?'.
-        size_t locofquestionmark = view.find('?');
-        if (locofquestionmark != std::string_view::npos) {
-          state = state::QUERY;
-          view.remove_suffix(view.size() - locofquestionmark);
-          input_position += locofquestionmark + 1;
-        } else {
-          input_position = input_size + 1;
-        }
-        if constexpr (store_values) {
-          if constexpr (result_type_is_ada_url) {
-            helpers::parse_prepared_path(view, url.type, url.path);
-          } else {
-            url.consume_prepared_path(view);
-            ADA_ASSERT_TRUE(url.validate());
-          }
-        }
-        break;
-      }
-      case state::FILE_SLASH: {
-        ada_log("FILE_SLASH ", helpers::substring(url_data, input_position));
-
-        // If c is U+002F (/) or U+005C (\), then:
-        if ((input_position != input_size) &&
-            (url_data[input_position] == '/' ||
-             url_data[input_position] == '\\')) {
-          ada_log("FILE_SLASH c is U+002F or U+005C");
-          // Set state to file host state.
-          state = state::FILE_HOST;
-          input_position++;
-        } else {
-          ada_log("FILE_SLASH otherwise");
-          // If base is non-null and base's scheme is "file", then:
-          // Note: it is unsafe to do base_url->scheme unless you know that
-          // base_url_has_value() is true.
-          if (base_url != nullptr && base_url->type == scheme::type::FILE) {
-            // Set url's host to base's host.
-            if constexpr (result_type_is_ada_url) {
-              url.host = base_url->host;
-            } else {
-              url.update_host_to_base_host(base_url->get_host());
-            }
-            // If the code point substring from pointer to the end of input does
-            // not start with a Windows drive letter and base's path[0] is a
-            // normalized Windows drive letter, then append base's path[0] to
-            // url's path.
-            if (!base_url->get_pathname().empty()) {
-              if (!checkers::is_windows_drive_letter(
-                      url_data.substr(input_position))) {
-                std::string_view first_base_url_path =
-                    base_url->get_pathname().substr(1);
-                size_t loc = first_base_url_path.find('/');
-                if (loc != std::string_view::npos) {
-                  helpers::resize(first_base_url_path, loc);
-                }
-                if (checkers::is_normalized_windows_drive_letter(
-                        first_base_url_path)) {
-                  if constexpr (result_type_is_ada_url) {
-                    url.path += '/';
-                    url.path += first_base_url_path;
-                  } else {
-                    url.append_base_pathname(
-                        helpers::concat("/", first_base_url_path));
-                  }
-                }
-              }
-            }
-          }
-
-          // Set state to path state, and decrease pointer by 1.
-          state = state::PATH;
-        }
-
-        break;
-      }
-      case state::FILE_HOST: {
-        ada_log("FILE_HOST ", helpers::substring(url_data, input_position));
-        std::string_view view = url_data.substr(input_position);
-
-        size_t location = view.find_first_of("/\\?");
-        std::string_view file_host_buffer(
-            view.data(),
-            (location != std::string_view::npos) ? location : view.size());
-
-        if (checkers::is_windows_drive_letter(file_host_buffer)) {
-          state = state::PATH;
-        } else if (file_host_buffer.empty()) {
-          // Set url's host to the empty string.
-          if constexpr (result_type_is_ada_url) {
-            url.host = "";
-          } else {
-            url.update_base_hostname("");
-          }
-          // Set state to path start state.
-          state = state::PATH_START;
-        } else {
-          size_t consumed_bytes = file_host_buffer.size();
-          input_position += consumed_bytes;
-          // Let host be the result of host parsing buffer with url is not
-          // special.
-          if (!url.parse_host(file_host_buffer)) {
-            return url;
-          }
-
-          if constexpr (result_type_is_ada_url) {
-            // If host is "localhost", then set host to the empty string.
-            if (url.host.has_value() && url.host.value() == "localhost") {
-              url.host = "";
-            }
-          } else {
-            if (url.get_hostname() == "localhost") {
-              url.update_base_hostname("");
-            }
-          }
-
-          // Set buffer to the empty string and state to path start state.
-          state = state::PATH_START;
-        }
-
-        break;
-      }
-      case state::FILE: {
-        ada_log("FILE ", helpers::substring(url_data, input_position));
-        std::string_view file_view = url_data.substr(input_position);
-
-        url.set_protocol_as_file();
-        if constexpr (result_type_is_ada_url) {
-          // Set url's host to the empty string.
-          url.host = "";
-        } else {
-          url.update_base_hostname("");
-        }
-        // If c is U+002F (/) or U+005C (\), then:
-        if (input_position != input_size &&
-            (url_data[input_position] == '/' ||
-             url_data[input_position] == '\\')) {
-          ada_log("FILE c is U+002F or U+005C");
-          // Set state to file slash state.
-          state = state::FILE_SLASH;
-        }
-        // Otherwise, if base is non-null and base's scheme is "file":
-        else if (base_url != nullptr && base_url->type == scheme::type::FILE) {
-          // Set url's host to base's host, url's path to a clone of base's
-          // path, and url's query to base's query.
-          ada_log("FILE base non-null");
-          if constexpr (result_type_is_ada_url) {
-            url.host = base_url->host;
-            url.path = base_url->path;
-            url.query = base_url->query;
-          } else {
-            url.update_host_to_base_host(base_url->get_hostname());
-            url.update_base_pathname(base_url->get_pathname());
-            url.update_base_search(base_url->get_search());
-          }
-          url.has_opaque_path = base_url->has_opaque_path;
-
-          // If c is U+003F (?), then set url's query to the empty string and
-          // state to query state.
-          if (input_position != input_size && url_data[input_position] == '?') {
-            state = state::QUERY;
-          }
-          // Otherwise, if c is not the EOF code point:
-          else if (input_position != input_size) {
-            // Set url's query to null.
-            url.clear_search();
-            // If the code point substring from pointer to the end of input does
-            // not start with a Windows drive letter, then shorten url's path.
-            if (!checkers::is_windows_drive_letter(file_view)) {
-              if constexpr (result_type_is_ada_url) {
-                helpers::shorten_path(url.path, url.type);
-              } else {
-                std::string_view path = url.get_pathname();
-                if (helpers::shorten_path(path, url.type)) {
-                  url.update_base_pathname(std::move(std::string(path)));
-                }
-              }
-            }
-            // Otherwise:
-            else {
-              // Set url's path to an empty list.
-              url.clear_pathname();
-              url.has_opaque_path = true;
-            }
-
-            // Set state to path state and decrease pointer by 1.
-            state = state::PATH;
-            break;
-          }
-        }
-        // Otherwise, set state to path state, and decrease pointer by 1.
-        else {
-          ada_log("FILE go to path");
-          state = state::PATH;
-          break;
-        }
-
-        input_position++;
-        break;
-      }
-      default:
-        unreachable();
-    }
-  }
-  if constexpr (store_values) {
-    if (fragment.has_value()) {
-      url.update_unencoded_base_hash(*fragment);
-    }
-  }
-  return url;
-}
-
-template url parse_url_impl(std::string_view user_input,
-                            const url* base_url = nullptr);
-template url_aggregator parse_url_impl(
-    std::string_view user_input, const url_aggregator* base_url = nullptr);
-
-template <class result_type>
-result_type parse_url(std::string_view user_input,
-                      const result_type* base_url) {
-  return parse_url_impl<result_type, true>(user_input, base_url);
-}
-
-template url parse_url<url>(std::string_view user_input,
-                            const url* base_url = nullptr);
-template url_aggregator parse_url<url_aggregator>(
-    std::string_view user_input, const url_aggregator* base_url = nullptr);
-}  // namespace ada::parser
-/* end file src/parser.cpp */
-/* begin file src/url_components.cpp */
-
-#include <string>
-
-namespace ada {
-
-[[nodiscard]] std::string url_components::to_string() const {
-  std::string answer;
-  auto back = std::back_insert_iterator(answer);
-  answer.append("{\n");
-
-  answer.append("\t\"protocol_end\":\"");
-  helpers::encode_json(std::to_string(protocol_end), back);
-  answer.append("\",\n");
-
-  answer.append("\t\"username_end\":\"");
-  helpers::encode_json(std::to_string(username_end), back);
-  answer.append("\",\n");
-
-  answer.append("\t\"host_start\":\"");
-  helpers::encode_json(std::to_string(host_start), back);
-  answer.append("\",\n");
-
-  answer.append("\t\"host_end\":\"");
-  helpers::encode_json(std::to_string(host_end), back);
-  answer.append("\",\n");
-
-  answer.append("\t\"port\":\"");
-  helpers::encode_json(std::to_string(port), back);
-  answer.append("\",\n");
-
-  answer.append("\t\"pathname_start\":\"");
-  helpers::encode_json(std::to_string(pathname_start), back);
-  answer.append("\",\n");
-
-  answer.append("\t\"search_start\":\"");
-  helpers::encode_json(std::to_string(search_start), back);
-  answer.append("\",\n");
-
-  answer.append("\t\"hash_start\":\"");
-  helpers::encode_json(std::to_string(hash_start), back);
-  answer.append("\",\n");
-
-  answer.append("\n}");
-  return answer;
-}
-
-}  // namespace ada
-/* end file src/url_components.cpp */
-/* begin file src/url_aggregator.cpp */
-
-#include <string>
-#include <string_view>
-
-namespace ada {
-template <bool has_state_override>
-[[nodiscard]] ada_really_inline bool url_aggregator::parse_scheme_with_colon(
-    const std::string_view input_with_colon) {
-  ada_log("url_aggregator::parse_scheme_with_colon ", input_with_colon);
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input_with_colon, buffer));
-  std::string_view input{input_with_colon};
-  input.remove_suffix(1);
-  auto parsed_type = ada::scheme::get_scheme_type(input);
-  const bool is_input_special = (parsed_type != ada::scheme::NOT_SPECIAL);
-  /**
-   * In the common case, we will immediately recognize a special scheme (e.g.,
-   *http, https), in which case, we can go really fast.
-   **/
-  if (is_input_special) {  // fast path!!!
-    if constexpr (has_state_override) {
-      // If url's scheme is not a special scheme and buffer is a special scheme,
-      // then return.
-      if (is_special() != is_input_special) {
-        return false;
-      }
-
-      // If url includes credentials or has a non-null port, and buffer is
-      // "file", then return.
-      if ((has_credentials() || components.port != url_components::omitted) &&
-          parsed_type == ada::scheme::type::FILE) {
-        return false;
-      }
-
-      // If url's scheme is "file" and its host is an empty host, then return.
-      // An empty host is the empty string.
-      if (type == ada::scheme::type::FILE &&
-          components.host_start == components.host_end) {
-        return false;
-      }
-    }
-
-    type = parsed_type;
-    set_scheme_from_view_with_colon(input_with_colon);
-
-    if constexpr (has_state_override) {
-      // This is uncommon.
-      uint16_t urls_scheme_port = get_special_port();
-
-      // If url's port is url's scheme's default port, then set url's port to
-      // null.
-      if (components.port == urls_scheme_port) {
-        clear_port();
-      }
-    }
-  } else {  // slow path
-    std::string _buffer(input);
-    // Next function is only valid if the input is ASCII and returns false
-    // otherwise, but it seems that we always have ascii content so we do not
-    // need to check the return value.
-    unicode::to_lower_ascii(_buffer.data(), _buffer.size());
-
-    if constexpr (has_state_override) {
-      // If url's scheme is a special scheme and buffer is not a special scheme,
-      // then return. If url's scheme is not a special scheme and buffer is a
-      // special scheme, then return.
-      if (is_special() != ada::scheme::is_special(_buffer)) {
-        return true;
-      }
-
-      // If url includes credentials or has a non-null port, and buffer is
-      // "file", then return.
-      if ((has_credentials() || components.port != url_components::omitted) &&
-          _buffer == "file") {
-        return true;
-      }
-
-      // If url's scheme is "file" and its host is an empty host, then return.
-      // An empty host is the empty string.
-      if (type == ada::scheme::type::FILE &&
-          components.host_start == components.host_end) {
-        return true;
-      }
-    }
-
-    set_scheme(_buffer);
-
-    if constexpr (has_state_override) {
-      // This is uncommon.
-      uint16_t urls_scheme_port = get_special_port();
-
-      // If url's port is url's scheme's default port, then set url's port to
-      // null.
-      if (components.port == urls_scheme_port) {
-        clear_port();
-      }
-    }
-  }
-  ADA_ASSERT_TRUE(validate());
-  return true;
-}
-
-inline void url_aggregator::copy_scheme(const url_aggregator& u) noexcept {
-  ada_log("url_aggregator::copy_scheme ", u.buffer);
-  ADA_ASSERT_TRUE(validate());
-  // next line could overflow but unsigned arithmetic has well-defined
-  // overflows.
-  uint32_t new_difference = u.components.protocol_end - components.protocol_end;
-  type = u.type;
-  buffer.erase(0, components.protocol_end);
-  buffer.insert(0, u.get_protocol());
-  components.protocol_end = u.components.protocol_end;
-
-  // No need to update the components
-  if (new_difference == 0) {
-    return;
-  }
-
-  // Update the rest of the components.
-  components.username_end += new_difference;
-  components.host_start += new_difference;
-  components.host_end += new_difference;
-  components.pathname_start += new_difference;
-  if (components.search_start != url_components::omitted) {
-    components.search_start += new_difference;
-  }
-  if (components.hash_start != url_components::omitted) {
-    components.hash_start += new_difference;
-  }
-  ADA_ASSERT_TRUE(validate());
-}
-
-inline void url_aggregator::set_scheme_from_view_with_colon(
-    std::string_view new_scheme_with_colon) noexcept {
-  ada_log("url_aggregator::set_scheme_from_view_with_colon ",
-          new_scheme_with_colon);
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!new_scheme_with_colon.empty() &&
-                  new_scheme_with_colon.back() == ':');
-  // next line could overflow but unsigned arithmetic has well-defined
-  // overflows.
-  uint32_t new_difference =
-      uint32_t(new_scheme_with_colon.size()) - components.protocol_end;
-
-  if (buffer.empty()) {
-    buffer.append(new_scheme_with_colon);
-  } else {
-    buffer.erase(0, components.protocol_end);
-    buffer.insert(0, new_scheme_with_colon);
-  }
-  components.protocol_end += new_difference;
-
-  // Update the rest of the components.
-  components.username_end += new_difference;
-  components.host_start += new_difference;
-  components.host_end += new_difference;
-  components.pathname_start += new_difference;
-  if (components.search_start != url_components::omitted) {
-    components.search_start += new_difference;
-  }
-  if (components.hash_start != url_components::omitted) {
-    components.hash_start += new_difference;
-  }
-  ADA_ASSERT_TRUE(validate());
-}
-
-inline void url_aggregator::set_scheme(std::string_view new_scheme) noexcept {
-  ada_log("url_aggregator::set_scheme ", new_scheme);
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(new_scheme.empty() || new_scheme.back() != ':');
-  // next line could overflow but unsigned arithmetic has well-defined
-  // overflows.
-  uint32_t new_difference =
-      uint32_t(new_scheme.size()) - components.protocol_end + 1;
-
-  type = ada::scheme::get_scheme_type(new_scheme);
-  if (buffer.empty()) {
-    buffer.append(helpers::concat(new_scheme, ":"));
-  } else {
-    buffer.erase(0, components.protocol_end);
-    buffer.insert(0, helpers::concat(new_scheme, ":"));
-  }
-  components.protocol_end = uint32_t(new_scheme.size() + 1);
-
-  // Update the rest of the components.
-  components.username_end += new_difference;
-  components.host_start += new_difference;
-  components.host_end += new_difference;
-  components.pathname_start += new_difference;
-  if (components.search_start != url_components::omitted) {
-    components.search_start += new_difference;
-  }
-  if (components.hash_start != url_components::omitted) {
-    components.hash_start += new_difference;
-  }
-  ADA_ASSERT_TRUE(validate());
-}
-
-bool url_aggregator::set_protocol(const std::string_view input) {
-  ada_log("url_aggregator::set_protocol ", input);
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-  std::string view(input);
-  helpers::remove_ascii_tab_or_newline(view);
-  if (view.empty()) {
-    return true;
-  }
-
-  // Schemes should start with alpha values.
-  if (!checkers::is_alpha(view[0])) {
-    return false;
-  }
-
-  view.append(":");
-
-  std::string::iterator pointer =
-      std::ranges::find_if_not(view, unicode::is_alnum_plus);
-
-  if (pointer != view.end() && *pointer == ':') {
-    return parse_scheme_with_colon<true>(
-        std::string_view(view.data(), pointer - view.begin() + 1));
-  }
-  return false;
-}
-
-bool url_aggregator::set_username(const std::string_view input) {
-  ada_log("url_aggregator::set_username '", input, "' ");
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-  if (cannot_have_credentials_or_port()) {
-    return false;
-  }
-  size_t idx = ada::unicode::percent_encode_index(
-      input, character_sets::USERINFO_PERCENT_ENCODE);
-  if (idx == input.size()) {
-    update_base_username(input);
-  } else {
-    // We only create a temporary string if we have to!
-    update_base_username(ada::unicode::percent_encode(
-        input, character_sets::USERINFO_PERCENT_ENCODE, idx));
-  }
-  ADA_ASSERT_TRUE(validate());
-  return true;
-}
-
-bool url_aggregator::set_password(const std::string_view input) {
-  ada_log("url_aggregator::set_password '", input, "'");
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-  if (cannot_have_credentials_or_port()) {
-    return false;
-  }
-  size_t idx = ada::unicode::percent_encode_index(
-      input, character_sets::USERINFO_PERCENT_ENCODE);
-  if (idx == input.size()) {
-    update_base_password(input);
-  } else {
-    // We only create a temporary string if we have to!
-    update_base_password(ada::unicode::percent_encode(
-        input, character_sets::USERINFO_PERCENT_ENCODE, idx));
-  }
-  ADA_ASSERT_TRUE(validate());
-  return true;
-}
-
-bool url_aggregator::set_port(const std::string_view input) {
-  ada_log("url_aggregator::set_port ", input);
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-  if (cannot_have_credentials_or_port()) {
-    return false;
-  }
-  std::string trimmed(input);
-  helpers::remove_ascii_tab_or_newline(trimmed);
-  if (trimmed.empty()) {
-    clear_port();
-    return true;
-  }
-
-  // Input should not start with a non-digit character.
-  if (!ada::unicode::is_ascii_digit(trimmed.front())) {
-    return false;
-  }
-
-  // Revert changes if parse_port fails.
-  uint32_t previous_port = components.port;
-  parse_port(trimmed);
-  if (is_valid) {
-    return true;
-  }
-  update_base_port(previous_port);
-  is_valid = true;
-  ADA_ASSERT_TRUE(validate());
-  return false;
-}
-
-bool url_aggregator::set_pathname(const std::string_view input) {
-  ada_log("url_aggregator::set_pathname ", input);
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-  if (has_opaque_path) {
-    return false;
-  }
-  clear_pathname();
-  parse_path(input);
-  if (get_pathname().starts_with("//") && !has_authority() && !has_dash_dot()) {
-    buffer.insert(components.pathname_start, "/.");
-    components.pathname_start += 2;
-  }
-  ADA_ASSERT_TRUE(validate());
-  return true;
-}
-
-ada_really_inline void url_aggregator::parse_path(std::string_view input) {
-  ada_log("url_aggregator::parse_path ", input);
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-  std::string tmp_buffer;
-  std::string_view internal_input;
-  if (unicode::has_tabs_or_newline(input)) {
-    tmp_buffer = input;
-    // Optimization opportunity: Instead of copying and then pruning, we could
-    // just directly build the string from user_input.
-    helpers::remove_ascii_tab_or_newline(tmp_buffer);
-    internal_input = tmp_buffer;
-  } else {
-    internal_input = input;
-  }
-
-  // If url is special, then:
-  if (is_special()) {
-    if (internal_input.empty()) {
-      update_base_pathname("/");
-    } else if ((internal_input[0] == '/') || (internal_input[0] == '\\')) {
-      consume_prepared_path(internal_input.substr(1));
-    } else {
-      consume_prepared_path(internal_input);
-    }
-  } else if (!internal_input.empty()) {
-    if (internal_input[0] == '/') {
-      consume_prepared_path(internal_input.substr(1));
-    } else {
-      consume_prepared_path(internal_input);
-    }
-  } else {
-    // Non-special URLs with an empty host can have their paths erased
-    // Path-only URLs cannot have their paths erased
-    if (components.host_start == components.host_end && !has_authority()) {
-      update_base_pathname("/");
-    }
-  }
-  ADA_ASSERT_TRUE(validate());
-}
-
-void url_aggregator::set_search(const std::string_view input) {
-  ada_log("url_aggregator::set_search ", input);
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-  if (input.empty()) {
-    clear_search();
-    helpers::strip_trailing_spaces_from_opaque_path(*this);
-    return;
-  }
-
-  std::string new_value;
-  new_value = input[0] == '?' ? input.substr(1) : input;
-  helpers::remove_ascii_tab_or_newline(new_value);
-
-  auto query_percent_encode_set =
-      is_special() ? ada::character_sets::SPECIAL_QUERY_PERCENT_ENCODE
-                   : ada::character_sets::QUERY_PERCENT_ENCODE;
-
-  update_base_search(new_value, query_percent_encode_set);
-  ADA_ASSERT_TRUE(validate());
-}
-
-void url_aggregator::set_hash(const std::string_view input) {
-  ada_log("url_aggregator::set_hash ", input);
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-  if (input.empty()) {
-    if (components.hash_start != url_components::omitted) {
-      buffer.resize(components.hash_start);
-      components.hash_start = url_components::omitted;
-    }
-    helpers::strip_trailing_spaces_from_opaque_path(*this);
-    return;
-  }
-
-  std::string new_value;
-  new_value = input[0] == '#' ? input.substr(1) : input;
-  helpers::remove_ascii_tab_or_newline(new_value);
-  update_unencoded_base_hash(new_value);
-  ADA_ASSERT_TRUE(validate());
-}
-
-bool url_aggregator::set_href(const std::string_view input) {
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-  ada_log("url_aggregator::set_href ", input, " [", input.size(), " bytes]");
-  ada::result<url_aggregator> out = ada::parse<url_aggregator>(input);
-  ada_log("url_aggregator::set_href, success :", out.has_value());
-
-  if (out) {
-    ada_log("url_aggregator::set_href, parsed ", out->to_string());
-    // TODO: Figure out why the following line puts test to never finish.
-    *this = *out;
-  }
-
-  return out.has_value();
-}
-
-ada_really_inline bool url_aggregator::parse_host(std::string_view input) {
-  ada_log("url_aggregator:parse_host \"", input, "\" [", input.size(),
-          " bytes]");
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-  if (input.empty()) {
-    return is_valid = false;
-  }  // technically unnecessary.
-  // If input starts with U+005B ([), then:
-  if (input[0] == '[') {
-    // If input does not end with U+005D (]), validation error, return failure.
-    if (input.back() != ']') {
-      return is_valid = false;
-    }
-    ada_log("parse_host ipv6");
-
-    // Return the result of IPv6 parsing input with its leading U+005B ([) and
-    // trailing U+005D (]) removed.
-    input.remove_prefix(1);
-    input.remove_suffix(1);
-    return parse_ipv6(input);
-  }
-
-  // If isNotSpecial is true, then return the result of opaque-host parsing
-  // input.
-  if (!is_special()) {
-    return parse_opaque_host(input);
-  }
-  // Let domain be the result of running UTF-8 decode without BOM on the
-  // percent-decoding of input. Let asciiDomain be the result of running domain
-  // to ASCII with domain and false. The most common case is an ASCII input, in
-  // which case we do not need to call the expensive 'to_ascii' if a few
-  // conditions are met: no '%' and no 'xn-' subsequence.
-
-  // Often, the input does not contain any forbidden code points, and no upper
-  // case ASCII letter, then we can just copy it to the buffer. We want to
-  // optimize for such a common case.
-  uint8_t is_forbidden_or_upper =
-      unicode::contains_forbidden_domain_code_point_or_upper(input.data(),
-                                                             input.size());
-  // Minor optimization opportunity:
-  // contains_forbidden_domain_code_point_or_upper could be extend to check for
-  // the presence of characters that cannot appear in the ipv4 address and we
-  // could also check whether x and n and - are present, and so we could skip
-  // some of the checks below. However, the gains are likely to be small, and
-  // the code would be more complex.
-  if (is_forbidden_or_upper == 0 &&
-      input.find("xn-") == std::string_view::npos) {
-    // fast path
-    update_base_hostname(input);
-    if (checkers::is_ipv4(get_hostname())) {
-      ada_log("parse_host fast path ipv4");
-      return parse_ipv4(get_hostname(), true);
-    }
-    ada_log("parse_host fast path ", get_hostname());
-    return true;
-  }
-  // We have encountered at least one forbidden code point or the input contains
-  // 'xn-' (case insensitive), so we need to call 'to_ascii' to perform the full
-  // conversion.
-
-  ada_log("parse_host calling to_ascii");
-  std::optional<std::string> host = std::string(get_hostname());
-  is_valid = ada::unicode::to_ascii(host, input, input.find('%'));
-  if (!is_valid) {
-    ada_log("parse_host to_ascii returns false");
-    return is_valid = false;
-  }
-  ada_log("parse_host to_ascii succeeded ", *host, " [", host->size(),
-          " bytes]");
-
-  if (std::any_of(host.value().begin(), host.value().end(),
-                  ada::unicode::is_forbidden_domain_code_point)) {
-    return is_valid = false;
-  }
-
-  // If asciiDomain ends in a number, then return the result of IPv4 parsing
-  // asciiDomain.
-  if (checkers::is_ipv4(host.value())) {
-    ada_log("parse_host got ipv4 ", *host);
-    return parse_ipv4(host.value(), false);
-  }
-
-  update_base_hostname(host.value());
-  ADA_ASSERT_TRUE(validate());
-  return true;
-}
-
-template <bool override_hostname>
-bool url_aggregator::set_host_or_hostname(const std::string_view input) {
-  ada_log("url_aggregator::set_host_or_hostname ", input);
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-  if (has_opaque_path) {
-    return false;
-  }
-
-  std::string previous_host(get_hostname());
-  uint32_t previous_port = components.port;
-
-  size_t host_end_pos = input.find('#');
-  std::string _host(input.data(), host_end_pos != std::string_view::npos
-                                      ? host_end_pos
-                                      : input.size());
-  helpers::remove_ascii_tab_or_newline(_host);
-  std::string_view new_host(_host);
-
-  // If url's scheme is "file", then set state to file host state, instead of
-  // host state.
-  if (type != ada::scheme::type::FILE) {
-    std::string_view host_view(_host.data(), _host.length());
-    auto [location, found_colon] =
-        helpers::get_host_delimiter_location(is_special(), host_view);
-
-    // Otherwise, if c is U+003A (:) and insideBrackets is false, then:
-    // Note: the 'found_colon' value is true if and only if a colon was
-    // encountered while not inside brackets.
-    if (found_colon) {
-      if constexpr (override_hostname) {
-        return false;
-      }
-      std::string_view sub_buffer = new_host.substr(location + 1);
-      if (!sub_buffer.empty()) {
-        set_port(sub_buffer);
-      }
-    }
-    // If url is special and host_view is the empty string, validation error,
-    // return failure. Otherwise, if state override is given, host_view is the
-    // empty string, and either url includes credentials or url's port is
-    // non-null, return.
-    else if (host_view.empty() &&
-             (is_special() || has_credentials() || has_port())) {
-      return false;
-    }
-
-    // Let host be the result of host parsing host_view with url is not special.
-    if (host_view.empty() && !is_special()) {
-      if (has_hostname()) {
-        clear_hostname();  // easy!
-      } else if (has_dash_dot()) {
-        add_authority_slashes_if_needed();
-        delete_dash_dot();
-      }
-      return true;
-    }
-
-    bool succeeded = parse_host(host_view);
-    if (!succeeded) {
-      update_base_hostname(previous_host);
-      update_base_port(previous_port);
-    } else if (has_dash_dot()) {
-      // Should remove dash_dot from pathname
-      delete_dash_dot();
-    }
-    return succeeded;
-  }
-
-  size_t location = new_host.find_first_of("/\\?");
-  if (location != std::string_view::npos) {
-    new_host.remove_suffix(new_host.length() - location);
-  }
-
-  if (new_host.empty()) {
-    // Set url's host to the empty string.
-    clear_hostname();
-  } else {
-    // Let host be the result of host parsing buffer with url is not special.
-    if (!parse_host(new_host)) {
-      update_base_hostname(previous_host);
-      update_base_port(previous_port);
-      return false;
-    }
-
-    // If host is "localhost", then set host to the empty string.
-    if (helpers::substring(buffer, components.host_start,
-                           components.host_end) == "localhost") {
-      clear_hostname();
-    }
-  }
-  ADA_ASSERT_TRUE(validate());
-  return true;
-}
-
-bool url_aggregator::set_host(const std::string_view input) {
-  ada_log("url_aggregator::set_host '", input, "'");
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-  return set_host_or_hostname<false>(input);
-}
-
-bool url_aggregator::set_hostname(const std::string_view input) {
-  ada_log("url_aggregator::set_hostname '", input, "'");
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-  return set_host_or_hostname<true>(input);
-}
-
-[[nodiscard]] std::string url_aggregator::get_origin() const noexcept {
-  ada_log("url_aggregator::get_origin");
-  if (is_special()) {
-    // Return a new opaque origin.
-    if (type == scheme::FILE) {
-      return "null";
-    }
-
-    return helpers::concat(get_protocol(), "//", get_host());
-  }
-
-  if (get_protocol() == "blob:") {
-    std::string_view path = get_pathname();
-    if (!path.empty()) {
-      auto out = ada::parse<ada::url_aggregator>(path);
-      if (out && (out->type == scheme::HTTP || out->type == scheme::HTTPS)) {
-        // If pathURL's scheme is not "http" and not "https", then return a
-        // new opaque origin.
-        return helpers::concat(out->get_protocol(), "//", out->get_host());
-      }
-    }
-  }
-
-  // Return a new opaque origin.
-  return "null";
-}
-
-[[nodiscard]] std::string_view url_aggregator::get_username() const noexcept
-    ada_lifetime_bound {
-  ada_log("url_aggregator::get_username");
-  if (has_non_empty_username()) {
-    return helpers::substring(buffer, components.protocol_end + 2,
-                              components.username_end);
-  }
-  return "";
-}
-
-[[nodiscard]] std::string_view url_aggregator::get_password() const noexcept
-    ada_lifetime_bound {
-  ada_log("url_aggregator::get_password");
-  if (has_non_empty_password()) {
-    return helpers::substring(buffer, components.username_end + 1,
-                              components.host_start);
-  }
-  return "";
-}
-
-[[nodiscard]] std::string_view url_aggregator::get_port() const noexcept
-    ada_lifetime_bound {
-  ada_log("url_aggregator::get_port");
-  if (components.port == url_components::omitted) {
-    return "";
-  }
-  return helpers::substring(buffer, components.host_end + 1,
-                            components.pathname_start);
-}
-
-[[nodiscard]] std::string_view url_aggregator::get_hash() const noexcept
-    ada_lifetime_bound {
-  ada_log("url_aggregator::get_hash");
-  // If this's URL's fragment is either null or the empty string, then return
-  // the empty string. Return U+0023 (#), followed by this's URL's fragment.
-  if (components.hash_start == url_components::omitted) {
-    return "";
-  }
-  if (buffer.size() - components.hash_start <= 1) {
-    return "";
-  }
-  return helpers::substring(buffer, components.hash_start);
-}
-
-[[nodiscard]] std::string_view url_aggregator::get_host() const noexcept
-    ada_lifetime_bound {
-  ada_log("url_aggregator::get_host");
-  // Technically, we should check if there is a hostname, but
-  // the code below works even if there isn't.
-  // if(!has_hostname()) { return ""; }
-  size_t start = components.host_start;
-  if (components.host_end > components.host_start &&
-      buffer[components.host_start] == '@') {
-    start++;
-  }
-  // if we have an empty host, then the space between components.host_end and
-  // components.pathname_start may be occupied by /.
-  if (start == components.host_end) {
-    return {};
-  }
-  return helpers::substring(buffer, start, components.pathname_start);
-}
-
-[[nodiscard]] std::string_view url_aggregator::get_hostname() const noexcept
-    ada_lifetime_bound {
-  ada_log("url_aggregator::get_hostname");
-  // Technically, we should check if there is a hostname, but
-  // the code below works even if there isn't.
-  // if(!has_hostname()) { return ""; }
-  size_t start = components.host_start;
-  // So host_start is not where the host begins.
-  if (components.host_end > components.host_start &&
-      buffer[components.host_start] == '@') {
-    start++;
-  }
-  return helpers::substring(buffer, start, components.host_end);
-}
-
-[[nodiscard]] std::string_view url_aggregator::get_search() const noexcept
-    ada_lifetime_bound {
-  ada_log("url_aggregator::get_search");
-  // If this's URL's query is either null or the empty string, then return the
-  // empty string. Return U+003F (?), followed by this's URL's query.
-  if (components.search_start == url_components::omitted) {
-    return "";
-  }
-  auto ending_index = uint32_t(buffer.size());
-  if (components.hash_start != url_components::omitted) {
-    ending_index = components.hash_start;
-  }
-  if (ending_index - components.search_start <= 1) {
-    return "";
-  }
-  return helpers::substring(buffer, components.search_start, ending_index);
-}
-
-[[nodiscard]] std::string_view url_aggregator::get_protocol() const noexcept
-    ada_lifetime_bound {
-  ada_log("url_aggregator::get_protocol");
-  return helpers::substring(buffer, 0, components.protocol_end);
-}
-
-[[nodiscard]] std::string ada::url_aggregator::to_string() const {
-  ada_log("url_aggregator::to_string buffer:", buffer, " [", buffer.size(),
-          " bytes]");
-  if (!is_valid) {
-    return "null";
-  }
-
-  std::string answer;
-  auto back = std::back_insert_iterator(answer);
-  answer.append("{\n");
-
-  answer.append("\t\"buffer\":\"");
-  helpers::encode_json(buffer, back);
-  answer.append("\",\n");
-
-  answer.append("\t\"protocol\":\"");
-  helpers::encode_json(get_protocol(), back);
-  answer.append("\",\n");
-
-  if (has_credentials()) {
-    answer.append("\t\"username\":\"");
-    helpers::encode_json(get_username(), back);
-    answer.append("\",\n");
-    answer.append("\t\"password\":\"");
-    helpers::encode_json(get_password(), back);
-    answer.append("\",\n");
-  }
-
-  answer.append("\t\"host\":\"");
-  helpers::encode_json(get_host(), back);
-  answer.append("\",\n");
-
-  answer.append("\t\"path\":\"");
-  helpers::encode_json(get_pathname(), back);
-  answer.append("\",\n");
-  answer.append("\t\"opaque path\":");
-  answer.append((has_opaque_path ? "true" : "false"));
-  answer.append(",\n");
-
-  if (components.search_start != url_components::omitted) {
-    answer.append("\t\"query\":\"");
-    helpers::encode_json(get_search(), back);
-    answer.append("\",\n");
-  }
-  if (components.hash_start != url_components::omitted) {
-    answer.append("\t\"fragment\":\"");
-    helpers::encode_json(get_hash(), back);
-    answer.append("\",\n");
-  }
-
-  auto convert_offset_to_string = [](uint32_t offset) -> std::string {
-    if (offset == url_components::omitted) {
-      return "null";
-    } else {
-      return std::to_string(offset);
-    }
-  };
-
-  answer.append("\t\"protocol_end\":");
-  answer.append(convert_offset_to_string(components.protocol_end));
-  answer.append(",\n");
-
-  answer.append("\t\"username_end\":");
-  answer.append(convert_offset_to_string(components.username_end));
-  answer.append(",\n");
-
-  answer.append("\t\"host_start\":");
-  answer.append(convert_offset_to_string(components.host_start));
-  answer.append(",\n");
-
-  answer.append("\t\"host_end\":");
-  answer.append(convert_offset_to_string(components.host_end));
-  answer.append(",\n");
-
-  answer.append("\t\"port\":");
-  answer.append(convert_offset_to_string(components.port));
-  answer.append(",\n");
-
-  answer.append("\t\"pathname_start\":");
-  answer.append(convert_offset_to_string(components.pathname_start));
-  answer.append(",\n");
-
-  answer.append("\t\"search_start\":");
-  answer.append(convert_offset_to_string(components.search_start));
-  answer.append(",\n");
-
-  answer.append("\t\"hash_start\":");
-  answer.append(convert_offset_to_string(components.hash_start));
-  answer.append("\n}");
-
-  return answer;
-}
-
-[[nodiscard]] bool url_aggregator::has_valid_domain() const noexcept {
-  if (components.host_start == components.host_end) {
-    return false;
-  }
-  return checkers::verify_dns_length(get_hostname());
-}
-
-bool url_aggregator::parse_ipv4(std::string_view input, bool in_place) {
-  ada_log("parse_ipv4 ", input, " [", input.size(),
-          " bytes], overlaps with buffer: ",
-          helpers::overlaps(input, buffer) ? "yes" : "no");
-  ADA_ASSERT_TRUE(validate());
-  const bool trailing_dot = (input.back() == '.');
-  if (trailing_dot) {
-    input.remove_suffix(1);
-  }
-  size_t digit_count{0};
-  int pure_decimal_count = 0;  // entries that are decimal
-  uint64_t ipv4{0};
-  // we could unroll for better performance?
-  for (; (digit_count < 4) && !(input.empty()); digit_count++) {
-    uint32_t
-        segment_result{};  // If any number exceeds 32 bits, we have an error.
-    bool is_hex = checkers::has_hex_prefix(input);
-    if (is_hex && ((input.length() == 2) ||
-                   ((input.length() > 2) && (input[2] == '.')))) {
-      // special case
-      segment_result = 0;
-      input.remove_prefix(2);
-    } else {
-      std::from_chars_result r{};
-      if (is_hex) {
-        ada_log("parse_ipv4 trying to parse hex number");
-        r = std::from_chars(input.data() + 2, input.data() + input.size(),
-                            segment_result, 16);
-      } else if ((input.length() >= 2) && input[0] == '0' &&
-                 checkers::is_digit(input[1])) {
-        ada_log("parse_ipv4 trying to parse octal number");
-        r = std::from_chars(input.data() + 1, input.data() + input.size(),
-                            segment_result, 8);
-      } else {
-        ada_log("parse_ipv4 trying to parse decimal number");
-        pure_decimal_count++;
-        r = std::from_chars(input.data(), input.data() + input.size(),
-                            segment_result, 10);
-      }
-      if (r.ec != std::errc()) {
-        ada_log("parse_ipv4 parsing failed");
-        return is_valid = false;
-      }
-      ada_log("parse_ipv4 parsed ", segment_result);
-      input.remove_prefix(r.ptr - input.data());
-    }
-    if (input.empty()) {
-      // We have the last value.
-      // At this stage, ipv4 contains digit_count*8 bits.
-      // So we have 32-digit_count*8 bits left.
-      if (segment_result >= (uint64_t(1) << (32 - digit_count * 8))) {
-        return is_valid = false;
-      }
-      ipv4 <<= (32 - digit_count * 8);
-      ipv4 |= segment_result;
-      goto final;
-    } else {
-      // There is more, so that the value must no be larger than 255
-      // and we must have a '.'.
-      if ((segment_result > 255) || (input[0] != '.')) {
-        return is_valid = false;
-      }
-      ipv4 <<= 8;
-      ipv4 |= segment_result;
-      input.remove_prefix(1);  // remove '.'
-    }
-  }
-  if ((digit_count != 4) || (!input.empty())) {
-    ada_log("parse_ipv4 found invalid (more than 4 numbers or empty) ");
-    return is_valid = false;
-  }
-final:
-  ada_log("url_aggregator::parse_ipv4 completed ", get_href(),
-          " host: ", get_host());
-
-  // We could also check r.ptr to see where the parsing ended.
-  if (in_place && pure_decimal_count == 4 && !trailing_dot) {
-    ada_log(
-        "url_aggregator::parse_ipv4 completed and was already correct in the "
-        "buffer");
-    // The original input was already all decimal and we validated it. So we
-    // don't need to do anything.
-  } else {
-    ada_log("url_aggregator::parse_ipv4 completed and we need to update it");
-    // Optimization opportunity: Get rid of unnecessary string return in ipv4
-    // serializer.
-    // TODO: This is likely a bug because it goes back update_base_hostname, not
-    // what we want to do.
-    update_base_hostname(
-        ada::serializers::ipv4(ipv4));  // We have to reserialize the address.
-  }
-  host_type = IPV4;
-  ADA_ASSERT_TRUE(validate());
-  return true;
-}
-
-bool url_aggregator::parse_ipv6(std::string_view input) {
-  // TODO: Implement in_place optimization: we know that input points
-  // in the buffer, so we can just check whether the buffer is already
-  // well formatted.
-  // TODO: Find a way to merge parse_ipv6 with url.cpp implementation.
-  ada_log("parse_ipv6 ", input, " [", input.size(), " bytes]");
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-  if (input.empty()) {
-    return is_valid = false;
-  }
-  // Let address be a new IPv6 address whose IPv6 pieces are all 0.
-  std::array<uint16_t, 8> address{};
-
-  // Let pieceIndex be 0.
-  int piece_index = 0;
-
-  // Let compress be null.
-  std::optional<int> compress{};
-
-  // Let pointer be a pointer for input.
-  std::string_view::iterator pointer = input.begin();
-
-  // If c is U+003A (:), then:
-  if (input[0] == ':') {
-    // If remaining does not start with U+003A (:), validation error, return
-    // failure.
-    if (input.size() == 1 || input[1] != ':') {
-      ada_log("parse_ipv6 starts with : but the rest does not start with :");
-      return is_valid = false;
-    }
-
-    // Increase pointer by 2.
-    pointer += 2;
-
-    // Increase pieceIndex by 1 and then set compress to pieceIndex.
-    compress = ++piece_index;
-  }
-
-  // While c is not the EOF code point:
-  while (pointer != input.end()) {
-    // If pieceIndex is 8, validation error, return failure.
-    if (piece_index == 8) {
-      ada_log("parse_ipv6 piece_index == 8");
-      return is_valid = false;
-    }
-
-    // If c is U+003A (:), then:
-    if (*pointer == ':') {
-      // If compress is non-null, validation error, return failure.
-      if (compress.has_value()) {
-        ada_log("parse_ipv6 compress is non-null");
-        return is_valid = false;
-      }
-
-      // Increase pointer and pieceIndex by 1, set compress to pieceIndex, and
-      // then continue.
-      pointer++;
-      compress = ++piece_index;
-      continue;
-    }
-
-    // Let value and length be 0.
-    uint16_t value = 0, length = 0;
-
-    // While length is less than 4 and c is an ASCII hex digit,
-    // set value to value times 0x10 + c interpreted as hexadecimal number, and
-    // increase pointer and length by 1.
-    while (length < 4 && pointer != input.end() &&
-           unicode::is_ascii_hex_digit(*pointer)) {
-      // https://stackoverflow.com/questions/39060852/why-does-the-addition-of-two-shorts-return-an-int
-      value = uint16_t(value * 0x10 + unicode::convert_hex_to_binary(*pointer));
-      pointer++;
-      length++;
-    }
-
-    // If c is U+002E (.), then:
-    if (pointer != input.end() && *pointer == '.') {
-      // If length is 0, validation error, return failure.
-      if (length == 0) {
-        ada_log("parse_ipv6 length is 0");
-        return is_valid = false;
-      }
-
-      // Decrease pointer by length.
-      pointer -= length;
-
-      // If pieceIndex is greater than 6, validation error, return failure.
-      if (piece_index > 6) {
-        ada_log("parse_ipv6 piece_index > 6");
-        return is_valid = false;
-      }
-
-      // Let numbersSeen be 0.
-      int numbers_seen = 0;
-
-      // While c is not the EOF code point:
-      while (pointer != input.end()) {
-        // Let ipv4Piece be null.
-        std::optional<uint16_t> ipv4_piece{};
-
-        // If numbersSeen is greater than 0, then:
-        if (numbers_seen > 0) {
-          // If c is a U+002E (.) and numbersSeen is less than 4, then increase
-          // pointer by 1.
-          if (*pointer == '.' && numbers_seen < 4) {
-            pointer++;
-          } else {
-            // Otherwise, validation error, return failure.
-            ada_log("parse_ipv6 Otherwise, validation error, return failure");
-            return is_valid = false;
-          }
-        }
-
-        // If c is not an ASCII digit, validation error, return failure.
-        if (pointer == input.end() || !checkers::is_digit(*pointer)) {
-          ada_log(
-              "parse_ipv6 If c is not an ASCII digit, validation error, return "
-              "failure");
-          return is_valid = false;
-        }
-
-        // While c is an ASCII digit:
-        while (pointer != input.end() && checkers::is_digit(*pointer)) {
-          // Let number be c interpreted as decimal number.
-          int number = *pointer - '0';
-
-          // If ipv4Piece is null, then set ipv4Piece to number.
-          if (!ipv4_piece.has_value()) {
-            ipv4_piece = number;
-          }
-          // Otherwise, if ipv4Piece is 0, validation error, return failure.
-          else if (ipv4_piece == 0) {
-            ada_log("parse_ipv6 if ipv4Piece is 0, validation error");
-            return is_valid = false;
-          }
-          // Otherwise, set ipv4Piece to ipv4Piece times 10 + number.
-          else {
-            ipv4_piece = *ipv4_piece * 10 + number;
-          }
-
-          // If ipv4Piece is greater than 255, validation error, return failure.
-          if (ipv4_piece > 255) {
-            ada_log("parse_ipv6 ipv4_piece > 255");
-            return is_valid = false;
-          }
-
-          // Increase pointer by 1.
-          pointer++;
-        }
-
-        // Set address[pieceIndex] to address[pieceIndex] times 0x100 +
-        // ipv4Piece.
-        // https://stackoverflow.com/questions/39060852/why-does-the-addition-of-two-shorts-return-an-int
-        address[piece_index] =
-            uint16_t(address[piece_index] * 0x100 + *ipv4_piece);
-
-        // Increase numbersSeen by 1.
-        numbers_seen++;
-
-        // If numbersSeen is 2 or 4, then increase pieceIndex by 1.
-        if (numbers_seen == 2 || numbers_seen == 4) {
-          piece_index++;
-        }
-      }
-
-      // If numbersSeen is not 4, validation error, return failure.
-      if (numbers_seen != 4) {
-        return is_valid = false;
-      }
-
-      // Break.
-      break;
-    }
-    // Otherwise, if c is U+003A (:):
-    else if ((pointer != input.end()) && (*pointer == ':')) {
-      // Increase pointer by 1.
-      pointer++;
-
-      // If c is the EOF code point, validation error, return failure.
-      if (pointer == input.end()) {
-        ada_log(
-            "parse_ipv6 If c is the EOF code point, validation error, return "
-            "failure");
-        return is_valid = false;
-      }
-    }
-    // Otherwise, if c is not the EOF code point, validation error, return
-    // failure.
-    else if (pointer != input.end()) {
-      ada_log(
-          "parse_ipv6 Otherwise, if c is not the EOF code point, validation "
-          "error, return failure");
-      return is_valid = false;
-    }
-
-    // Set address[pieceIndex] to value.
-    address[piece_index] = value;
-
-    // Increase pieceIndex by 1.
-    piece_index++;
-  }
-
-  // If compress is non-null, then:
-  if (compress.has_value()) {
-    // Let swaps be pieceIndex - compress.
-    int swaps = piece_index - *compress;
-
-    // Set pieceIndex to 7.
-    piece_index = 7;
-
-    // While pieceIndex is not 0 and swaps is greater than 0,
-    // swap address[pieceIndex] with address[compress + swaps - 1], and then
-    // decrease both pieceIndex and swaps by 1.
-    while (piece_index != 0 && swaps > 0) {
-      std::swap(address[piece_index], address[*compress + swaps - 1]);
-      piece_index--;
-      swaps--;
-    }
-  }
-  // Otherwise, if compress is null and pieceIndex is not 8, validation error,
-  // return failure.
-  else if (piece_index != 8) {
-    ada_log(
-        "parse_ipv6 if compress is null and pieceIndex is not 8, validation "
-        "error, return failure");
-    return is_valid = false;
-  }
-  // TODO: Optimization opportunity: Get rid of unnecessary string creation.
-  // TODO: This is likely a bug because it goes back update_base_hostname, not
-  // what we want to do.
-  update_base_hostname(ada::serializers::ipv6(address));
-  ada_log("parse_ipv6 ", get_hostname());
-  ADA_ASSERT_TRUE(validate());
-  host_type = IPV6;
-  return true;
-}
-
-bool url_aggregator::parse_opaque_host(std::string_view input) {
-  ada_log("parse_opaque_host ", input, " [", input.size(), " bytes]");
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-  if (std::any_of(input.begin(), input.end(),
-                  ada::unicode::is_forbidden_host_code_point)) {
-    return is_valid = false;
-  }
-
-  // Return the result of running UTF-8 percent-encode on input using the C0
-  // control percent-encode set.
-  size_t idx = ada::unicode::percent_encode_index(
-      input, character_sets::C0_CONTROL_PERCENT_ENCODE);
-  if (idx == input.size()) {
-    update_base_hostname(input);
-  } else {
-    // We only create a temporary string if we need to.
-    update_base_hostname(ada::unicode::percent_encode(
-        input, character_sets::C0_CONTROL_PERCENT_ENCODE, idx));
-  }
-  ADA_ASSERT_TRUE(validate());
-  return true;
-}
-
-[[nodiscard]] std::string url_aggregator::to_diagram() const {
-  if (!is_valid) {
-    return "invalid";
-  }
-  std::string answer;
-  answer.append(buffer);
-  answer.append(" [");
-  answer.append(std::to_string(buffer.size()));
-  answer.append(" bytes]");
-  answer.append("\n");
-  // first line
-  std::string line1;
-  line1.resize(buffer.size(), ' ');
-  if (components.hash_start != url_components::omitted) {
-    line1[components.hash_start] = '|';
-  }
-  if (components.search_start != url_components::omitted) {
-    line1[components.search_start] = '|';
-  }
-  if (components.pathname_start != buffer.size()) {
-    line1[components.pathname_start] = '|';
-  }
-  if (components.host_end != buffer.size()) {
-    line1[components.host_end] = '|';
-  }
-  if (components.host_start != buffer.size()) {
-    line1[components.host_start] = '|';
-  }
-  if (components.username_end != buffer.size()) {
-    line1[components.username_end] = '|';
-  }
-  if (components.protocol_end != buffer.size()) {
-    line1[components.protocol_end] = '|';
-  }
-  answer.append(line1);
-  answer.append("\n");
-
-  std::string line2 = line1;
-  if (components.hash_start != url_components::omitted) {
-    line2[components.hash_start] = '`';
-    line1[components.hash_start] = ' ';
-
-    for (size_t i = components.hash_start + 1; i < line2.size(); i++) {
-      line2[i] = '-';
-    }
-    line2.append(" hash_start");
-    answer.append(line2);
-    answer.append("\n");
-  }
-
-  std::string line3 = line1;
-  if (components.search_start != url_components::omitted) {
-    line3[components.search_start] = '`';
-    line1[components.search_start] = ' ';
-
-    for (size_t i = components.search_start + 1; i < line3.size(); i++) {
-      line3[i] = '-';
-    }
-    line3.append(" search_start ");
-    line3.append(std::to_string(components.search_start));
-    answer.append(line3);
-    answer.append("\n");
-  }
-
-  std::string line4 = line1;
-  if (components.pathname_start != buffer.size()) {
-    line4[components.pathname_start] = '`';
-    line1[components.pathname_start] = ' ';
-    for (size_t i = components.pathname_start + 1; i < line4.size(); i++) {
-      line4[i] = '-';
-    }
-    line4.append(" pathname_start ");
-    line4.append(std::to_string(components.pathname_start));
-    answer.append(line4);
-    answer.append("\n");
-  }
-
-  std::string line5 = line1;
-  if (components.host_end != buffer.size()) {
-    line5[components.host_end] = '`';
-    line1[components.host_end] = ' ';
-
-    for (size_t i = components.host_end + 1; i < line5.size(); i++) {
-      line5[i] = '-';
-    }
-    line5.append(" host_end ");
-    line5.append(std::to_string(components.host_end));
-    answer.append(line5);
-    answer.append("\n");
-  }
-
-  std::string line6 = line1;
-  if (components.host_start != buffer.size()) {
-    line6[components.host_start] = '`';
-    line1[components.host_start] = ' ';
-
-    for (size_t i = components.host_start + 1; i < line6.size(); i++) {
-      line6[i] = '-';
-    }
-    line6.append(" host_start ");
-    line6.append(std::to_string(components.host_start));
-    answer.append(line6);
-    answer.append("\n");
-  }
-
-  std::string line7 = line1;
-  if (components.username_end != buffer.size()) {
-    line7[components.username_end] = '`';
-    line1[components.username_end] = ' ';
-
-    for (size_t i = components.username_end + 1; i < line7.size(); i++) {
-      line7[i] = '-';
-    }
-    line7.append(" username_end ");
-    line7.append(std::to_string(components.username_end));
-    answer.append(line7);
-    answer.append("\n");
-  }
-
-  std::string line8 = line1;
-  if (components.protocol_end != buffer.size()) {
-    line8[components.protocol_end] = '`';
-    line1[components.protocol_end] = ' ';
-
-    for (size_t i = components.protocol_end + 1; i < line8.size(); i++) {
-      line8[i] = '-';
-    }
-    line8.append(" protocol_end ");
-    line8.append(std::to_string(components.protocol_end));
-    answer.append(line8);
-    answer.append("\n");
-  }
-
-  if (components.hash_start == url_components::omitted) {
-    answer.append("note: hash omitted\n");
-  }
-  if (components.search_start == url_components::omitted) {
-    answer.append("note: search omitted\n");
-  }
-  if (components.protocol_end > buffer.size()) {
-    answer.append("warning: protocol_end overflows\n");
-  }
-  if (components.username_end > buffer.size()) {
-    answer.append("warning: username_end overflows\n");
-  }
-  if (components.host_start > buffer.size()) {
-    answer.append("warning: host_start overflows\n");
-  }
-  if (components.host_end > buffer.size()) {
-    answer.append("warning: host_end overflows\n");
-  }
-  if (components.pathname_start > buffer.size()) {
-    answer.append("warning: pathname_start overflows\n");
-  }
-  return answer;
-}
-
-void url_aggregator::delete_dash_dot() {
-  ada_log("url_aggregator::delete_dash_dot");
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(has_dash_dot());
-  buffer.erase(components.host_end, 2);
-  components.pathname_start -= 2;
-  if (components.search_start != url_components::omitted) {
-    components.search_start -= 2;
-  }
-  if (components.hash_start != url_components::omitted) {
-    components.hash_start -= 2;
-  }
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!has_dash_dot());
-}
-
-inline void url_aggregator::consume_prepared_path(std::string_view input) {
-  ada_log("url_aggregator::consume_prepared_path ", input);
-  /***
-   * This is largely duplicated code from helpers::parse_prepared_path, which is
-   * unfortunate. This particular function is nearly identical, except that it
-   * is a method on url_aggregator. The idea is that the trivial path (which is
-   * very common) merely appends to the buffer. This is the same trivial path as
-   * with helpers::parse_prepared_path, except that we have the additional check
-   * for is_at_path(). Otherwise, we grab a copy of the current path and we
-   * modify it, and then insert it back into the buffer.
-   */
-  uint8_t accumulator = checkers::path_signature(input);
-  // Let us first detect a trivial case.
-  // If it is special, we check that we have no dot, no %,  no \ and no
-  // character needing percent encoding. Otherwise, we check that we have no %,
-  // no dot, and no character needing percent encoding.
-  constexpr uint8_t need_encoding = 1;
-  constexpr uint8_t backslash_char = 2;
-  constexpr uint8_t dot_char = 4;
-  constexpr uint8_t percent_char = 8;
-  bool special = type != ada::scheme::NOT_SPECIAL;
-  bool may_need_slow_file_handling = (type == ada::scheme::type::FILE &&
-                                      checkers::is_windows_drive_letter(input));
-  bool trivial_path =
-      (special ? (accumulator == 0)
-               : ((accumulator & (need_encoding | dot_char | percent_char)) ==
-                  0)) &&
-      (!may_need_slow_file_handling);
-  if (accumulator == dot_char && !may_need_slow_file_handling) {
-    // '4' means that we have at least one dot, but nothing that requires
-    // percent encoding or decoding. The only part that is not trivial is
-    // that we may have single dots and double dots path segments.
-    // If we have such segments, then we either have a path that begins
-    // with '.' (easy to check), or we have the sequence './'.
-    // Note: input cannot be empty, it must at least contain one character ('.')
-    // Note: we know that '\' is not present.
-    if (input[0] != '.') {
-      size_t slashdot = input.find("/.");
-      if (slashdot == std::string_view::npos) {  // common case
-        trivial_path = true;
-      } else {  // uncommon
-        // only three cases matter: /./, /.. or a final /
-        trivial_path =
-            !(slashdot + 2 == input.size() || input[slashdot + 2] == '.' ||
-              input[slashdot + 2] == '/');
-      }
-    }
-  }
-  if (trivial_path && is_at_path()) {
-    ada_log("parse_path trivial");
-    buffer += '/';
-    buffer += input;
-    return;
-  }
-  std::string path = std::string(get_pathname());
-  // We are going to need to look a bit at the path, but let us see if we can
-  // ignore percent encoding *and* backslashes *and* percent characters.
-  // Except for the trivial case, this is likely to capture 99% of paths out
-  // there.
-  bool fast_path =
-      (special &&
-       (accumulator & (need_encoding | backslash_char | percent_char)) == 0) &&
-      (type != ada::scheme::type::FILE);
-  if (fast_path) {
-    ada_log("parse_prepared_path fast");
-    // Here we don't need to worry about \ or percent encoding.
-    // We also do not have a file protocol. We might have dots, however,
-    // but dots must as appear as '.', and they cannot be encoded because
-    // the symbol '%' is not present.
-    size_t previous_location = 0;  // We start at 0.
-    do {
-      size_t new_location = input.find('/', previous_location);
-      // std::string_view path_view = input;
-      //  We process the last segment separately:
-      if (new_location == std::string_view::npos) {
-        std::string_view path_view = input.substr(previous_location);
-        if (path_view == "..") {  // The path ends with ..
-          // e.g., if you receive ".." with an empty path, you go to "/".
-          if (path.empty()) {
-            path = '/';
-            update_base_pathname(path);
-            return;
-          }
-          // Fast case where we have nothing to do:
-          if (path.back() == '/') {
-            update_base_pathname(path);
-            return;
-          }
-          // If you have the path "/joe/myfriend",
-          // then you delete 'myfriend'.
-          path.resize(path.rfind('/') + 1);
-          update_base_pathname(path);
-          return;
-        }
-        path += '/';
-        if (path_view != ".") {
-          path.append(path_view);
-        }
-        update_base_pathname(path);
-        return;
-      } else {
-        // This is a non-final segment.
-        std::string_view path_view =
-            input.substr(previous_location, new_location - previous_location);
-        previous_location = new_location + 1;
-        if (path_view == "..") {
-          size_t last_delimiter = path.rfind('/');
-          if (last_delimiter != std::string::npos) {
-            path.erase(last_delimiter);
-          }
-        } else if (path_view != ".") {
-          path += '/';
-          path.append(path_view);
-        }
-      }
-    } while (true);
-  } else {
-    ada_log("parse_path slow");
-    // we have reached the general case
-    bool needs_percent_encoding = (accumulator & 1);
-    std::string path_buffer_tmp;
-    do {
-      size_t location = (special && (accumulator & 2))
-                            ? input.find_first_of("/\\")
-                            : input.find('/');
-      std::string_view path_view = input;
-      if (location != std::string_view::npos) {
-        path_view.remove_suffix(path_view.size() - location);
-        input.remove_prefix(location + 1);
-      }
-      // path_buffer is either path_view or it might point at a percent encoded
-      // temporary string.
-      std::string_view path_buffer =
-          (needs_percent_encoding &&
-           ada::unicode::percent_encode<false>(
-               path_view, character_sets::PATH_PERCENT_ENCODE, path_buffer_tmp))
-              ? path_buffer_tmp
-              : path_view;
-      if (unicode::is_double_dot_path_segment(path_buffer)) {
-        if ((helpers::shorten_path(path, type) || special) &&
-            location == std::string_view::npos) {
-          path += '/';
-        }
-      } else if (unicode::is_single_dot_path_segment(path_buffer) &&
-                 (location == std::string_view::npos)) {
-        path += '/';
-      }
-      // Otherwise, if path_buffer is not a single-dot path segment, then:
-      else if (!unicode::is_single_dot_path_segment(path_buffer)) {
-        // If url's scheme is "file", url's path is empty, and path_buffer is a
-        // Windows drive letter, then replace the second code point in
-        // path_buffer with U+003A (:).
-        if (type == ada::scheme::type::FILE && path.empty() &&
-            checkers::is_windows_drive_letter(path_buffer)) {
-          path += '/';
-          path += path_buffer[0];
-          path += ':';
-          path_buffer.remove_prefix(2);
-          path.append(path_buffer);
-        } else {
-          // Append path_buffer to url's path.
-          path += '/';
-          path.append(path_buffer);
-        }
-      }
-      if (location == std::string_view::npos) {
-        update_base_pathname(path);
-        return;
-      }
-    } while (true);
-  }
-}
-}  // namespace ada
-/* end file src/url_aggregator.cpp */
-/* begin file src/url_pattern.cpp */
-
-#include <algorithm>
-#include <optional>
-#include <string>
-
-namespace ada {
-
-tl::expected<url_pattern_init, errors> url_pattern_init::process(
-    url_pattern_init init, std::string_view type,
-    std::optional<std::string_view> protocol,
-    std::optional<std::string_view> username,
-    std::optional<std::string_view> password,
-    std::optional<std::string_view> hostname,
-    std::optional<std::string_view> port,
-    std::optional<std::string_view> pathname,
-    std::optional<std::string_view> search,
-    std::optional<std::string_view> hash) {
-  // Let result be the result of creating a new URLPatternInit.
-  auto result = url_pattern_init{};
-
-  // If protocol is not null, set result["protocol"] to protocol.
-  if (protocol.has_value()) result.protocol = *protocol;
-
-  // If username is not null, set result["username"] to username.
-  if (username.has_value()) result.username = *username;
-
-  // If password is not null, set result["password"] to password.
-  if (password.has_value()) result.password = *password;
-
-  // If hostname is not null, set result["hostname"] to hostname.
-  if (hostname.has_value()) result.hostname = *hostname;
-
-  // If port is not null, set result["port"] to port.
-  if (port.has_value()) result.port = *port;
-
-  // If pathname is not null, set result["pathname"] to pathname.
-  if (pathname.has_value()) result.pathname = *pathname;
-
-  // If search is not null, set result["search"] to search.
-  if (search.has_value()) result.search = *search;
-
-  // If hash is not null, set result["hash"] to hash.
-  if (hash.has_value()) result.hash = *hash;
-
-  // Let baseURL be null.
-  std::optional<url_aggregator> base_url{};
-
-  // If init["baseURL"] exists:
-  if (init.base_url.has_value()) {
-    // Set baseURL to the result of parsing init["baseURL"].
-    auto parsing_result = ada::parse<url_aggregator>(*init.base_url);
-    // If baseURL is failure, then throw a TypeError.
-    if (!parsing_result) {
-      return tl::unexpected(errors::type_error);
-    }
-    base_url = std::move(*parsing_result);
-
-    // If init["protocol"] does not exist, then set result["protocol"] to the
-    // result of processing a base URL string given baseURL’s scheme and type.
-    if (!init.protocol.has_value()) {
-      ADA_ASSERT_TRUE(base_url.has_value());
-      std::string_view base_url_protocol = base_url->get_protocol();
-      if (base_url_protocol.ends_with(":")) base_url_protocol.remove_suffix(1);
-      result.protocol =
-          url_pattern_helpers::process_base_url_string(base_url_protocol, type);
-    }
-
-    // If type is not "pattern" and init contains none of "protocol",
-    // "hostname", "port" and "username", then set result["username"] to the
-    // result of processing a base URL string given baseURL’s username and type.
-    if (type != "pattern" && !init.protocol && !init.hostname && !init.port &&
-        !init.username) {
-      result.username = url_pattern_helpers::process_base_url_string(
-          base_url->get_username(), type);
-    }
-
-    // TODO: Optimization opportunity: Merge this with the previous check.
-    // If type is not "pattern" and init contains none of "protocol",
-    // "hostname", "port", "username" and "password", then set
-    // result["password"] to the result of processing a base URL string given
-    // baseURL’s password and type.
-    if (type != "pattern" && !init.protocol && !init.hostname && !init.port &&
-        !init.username && !init.password) {
-      result.password = url_pattern_helpers::process_base_url_string(
-          base_url->get_password(), type);
-    }
-
-    // If init contains neither "protocol" nor "hostname", then:
-    if (!init.protocol && !init.hostname) {
-      // Let baseHost be baseURL’s host.
-      // If baseHost is null, then set baseHost to the empty string.
-      auto base_host = base_url->get_hostname();
-      // Set result["hostname"] to the result of processing a base URL string
-      // given baseHost and type.
-      result.hostname =
-          url_pattern_helpers::process_base_url_string(base_host, type);
-    }
-
-    // If init contains none of "protocol", "hostname", and "port", then:
-    if (!init.protocol && !init.hostname && !init.port) {
-      // If baseURL’s port is null, then set result["port"] to the empty string.
-      // Otherwise, set result["port"] to baseURL’s port, serialized.
-      result.port = base_url->get_port();
-    }
-
-    // If init contains none of "protocol", "hostname", "port", and "pathname",
-    // then set result["pathname"] to the result of processing a base URL string
-    // given the result of URL path serializing baseURL and type.
-    if (!init.protocol && !init.hostname && !init.port && !init.pathname) {
-      result.pathname = url_pattern_helpers::process_base_url_string(
-          base_url->get_pathname(), type);
-    }
-
-    // If init contains none of "protocol", "hostname", "port", "pathname", and
-    // "search", then:
-    if (!init.protocol && !init.hostname && !init.port && !init.pathname &&
-        !init.search) {
-      // Let baseQuery be baseURL’s query.
-      // Set result["search"] to the result of processing a base URL string
-      // given baseQuery and type.
-      result.search = url_pattern_helpers::process_base_url_string(
-          base_url->get_search(), type);
-    }
-
-    // If init contains none of "protocol", "hostname", "port", "pathname",
-    // "search", and "hash", then:
-    if (!init.protocol && !init.hostname && !init.port && !init.pathname &&
-        !init.search && !init.hash) {
-      // Let baseFragment be baseURL’s fragment.
-      // Set result["hash"] to the result of processing a base URL string given
-      // baseFragment and type.
-      result.hash = url_pattern_helpers::process_base_url_string(
-          base_url->get_hash(), type);
-    }
-  }
-
-  // If init["protocol"] exists, then set result["protocol"] to the result of
-  // process protocol for init given init["protocol"] and type.
-  if (init.protocol) {
-    auto process_result = process_protocol(*init.protocol, type);
-    if (!process_result) {
-      return tl::unexpected(process_result.error());
-    }
-    result.protocol = std::move(*process_result);
-  }
-
-  // If init["username"] exists, then set result["username"] to the result of
-  // process username for init given init["username"] and type.
-  if (init.username.has_value()) {
-    auto process_result = process_username(*init.username, type);
-    if (!process_result) {
-      return tl::unexpected(process_result.error());
-    }
-    result.username = std::move(*process_result);
-  }
-
-  // If init["password"] exists, then set result["password"] to the result of
-  // process password for init given init["password"] and type.
-  if (init.password.has_value()) {
-    auto process_result = process_password(*init.password, type);
-    if (!process_result) {
-      return tl::unexpected(process_result.error());
-    }
-    result.password = std::move(*process_result);
-  }
-
-  // If init["hostname"] exists, then set result["hostname"] to the result of
-  // process hostname for init given init["hostname"] and type.
-  if (init.hostname.has_value()) {
-    auto process_result = process_hostname(*init.hostname, type);
-    if (!process_result) {
-      return tl::unexpected(process_result.error());
-    }
-    result.hostname = std::move(*process_result);
-  }
-
-  // If init["port"] exists, then set result["port"] to the result of process
-  // port for init given init["port"], result["protocol"], and type.
-  if (init.port) {
-    auto process_result =
-        process_port(*init.port, result.protocol.value_or("fake"), type);
-    if (!process_result) {
-      return tl::unexpected(process_result.error());
-    }
-    result.port = std::move(*process_result);
-  }
-
-  // If init["pathname"] exists:
-  if (init.pathname.has_value()) {
-    // Set result["pathname"] to init["pathname"].
-    result.pathname = init.pathname;
-
-    // If the following are all true:
-    // - baseURL is not null;
-    // - baseURL has an opaque path; and
-    // - the result of running is an absolute pathname given result["pathname"]
-    // and type is false,
-    if (base_url && !base_url->has_opaque_path &&
-        !url_pattern_helpers::is_absolute_pathname(*result.pathname, type)) {
-      // Let baseURLPath be the result of running process a base URL string
-      // given the result of URL path serializing baseURL and type.
-      std::string base_url_path = url_pattern_helpers::process_base_url_string(
-          base_url->get_pathname(), type);
-
-      // Let slash index be the index of the last U+002F (/) code point found in
-      // baseURLPath, interpreted as a sequence of code points, or null if there
-      // are no instances of the code point.
-      auto slash_index = base_url_path.find_last_of('/');
-
-      // If slash index is not null:
-      if (slash_index != std::string::npos) {
-        // Let new pathname be the code point substring from 0 to slash index +
-        // 1 within baseURLPath.
-        std::string new_pathname = base_url_path.substr(0, slash_index + 1);
-        // Append result["pathname"] to the end of new pathname.
-        ADA_ASSERT_TRUE(result.pathname.has_value());
-        new_pathname.append(result.pathname.value());
-        // Set result["pathname"] to new pathname.
-        result.pathname = std::move(new_pathname);
-      }
-    }
-
-    // Set result["pathname"] to the result of process pathname for init given
-    // result["pathname"], result["protocol"], and type.
-    auto pathname_processing_result =
-        process_pathname(*result.pathname, result.protocol.value_or(""), type);
-    if (!pathname_processing_result) {
-      return tl::unexpected(pathname_processing_result.error());
-    }
-    result.pathname = std::move(*pathname_processing_result);
-  }
-
-  // If init["search"] exists then set result["search"] to the result of process
-  // search for init given init["search"] and type.
-  if (init.search) {
-    auto process_result = process_search(*init.search, type);
-    if (!process_result) {
-      return tl::unexpected(process_result.error());
-    }
-    result.search = std::move(*process_result);
-  }
-
-  // If init["hash"] exists then set result["hash"] to the result of process
-  // hash for init given init["hash"] and type.
-  if (init.hash) {
-    auto process_result = process_hash(*init.hash, type);
-    if (!process_result) {
-      return tl::unexpected(process_result.error());
-    }
-    result.hash = std::move(*process_result);
-  }
-  // Return result.
-  return result;
-}
-
-tl::expected<std::string, errors> url_pattern_init::process_protocol(
-    std::string_view value, std::string_view type) {
-  ada_log("process_protocol=", value, " [", type, "]");
-  // Let strippedValue be the given value with a single trailing U+003A (:)
-  // removed, if any.
-  if (value.ends_with(":")) {
-    value.remove_suffix(1);
-  }
-  // If type is "pattern" then return strippedValue.
-  if (type == "pattern") {
-    return std::string(value);
-  }
-  // Return the result of running canonicalize a protocol given strippedValue.
-  return url_pattern_helpers::canonicalize_protocol(value);
-}
-
-tl::expected<std::string, errors> url_pattern_init::process_username(
-    std::string_view value, std::string_view type) {
-  // If type is "pattern" then return value.
-  if (type == "pattern") {
-    return std::string(value);
-  }
-  // Return the result of running canonicalize a username given value.
-  return url_pattern_helpers::canonicalize_username(value);
-}
-
-tl::expected<std::string, errors> url_pattern_init::process_password(
-    std::string_view value, std::string_view type) {
-  // If type is "pattern" then return value.
-  if (type == "pattern") {
-    return std::string(value);
-  }
-  // Return the result of running canonicalize a password given value.
-  return url_pattern_helpers::canonicalize_password(value);
-}
-
-tl::expected<std::string, errors> url_pattern_init::process_hostname(
-    std::string_view value, std::string_view type) {
-  ada_log("process_hostname value=", value, " type=", type);
-  // If type is "pattern" then return value.
-  if (type == "pattern") {
-    return std::string(value);
-  }
-  // Return the result of running canonicalize a hostname given value.
-  return url_pattern_helpers::canonicalize_hostname(value);
-}
-
-tl::expected<std::string, errors> url_pattern_init::process_port(
-    std::string_view port, std::string_view protocol, std::string_view type) {
-  // If type is "pattern" then return portValue.
-  if (type == "pattern") {
-    return std::string(port);
-  }
-  // Return the result of running canonicalize a port given portValue and
-  // protocolValue.
-  return url_pattern_helpers::canonicalize_port_with_protocol(port, protocol);
-}
-
-tl::expected<std::string, errors> url_pattern_init::process_pathname(
-    std::string_view value, std::string_view protocol, std::string_view type) {
-  // If type is "pattern" then return pathnameValue.
-  if (type == "pattern") {
-    return std::string(value);
-  }
-
-  // If protocolValue is a special scheme or the empty string, then return the
-  // result of running canonicalize a pathname given pathnameValue.
-  if (protocol.empty() || scheme::is_special(protocol)) {
-    return url_pattern_helpers::canonicalize_pathname(value);
-  }
-
-  // Return the result of running canonicalize an opaque pathname given
-  // pathnameValue.
-  return url_pattern_helpers::canonicalize_opaque_pathname(value);
-}
-
-tl::expected<std::string, errors> url_pattern_init::process_search(
-    std::string_view value, std::string_view type) {
-  // Let strippedValue be the given value with a single leading U+003F (?)
-  // removed, if any.
-  if (value.starts_with("?")) {
-    value.remove_prefix(1);
-  }
-  ADA_ASSERT_TRUE(!value.starts_with("?"));
-  // If type is "pattern" then return strippedValue.
-  if (type == "pattern") {
-    return std::string(value);
-  }
-  // Return the result of running canonicalize a search given strippedValue.
-  return url_pattern_helpers::canonicalize_search(value);
-}
-
-tl::expected<std::string, errors> url_pattern_init::process_hash(
-    std::string_view value, std::string_view type) {
-  // Let strippedValue be the given value with a single leading U+0023 (#)
-  // removed, if any.
-  if (value.starts_with("#")) {
-    value.remove_prefix(1);
-  }
-  ADA_ASSERT_TRUE(!value.starts_with("#"));
-  // If type is "pattern" then return strippedValue.
-  if (type == "pattern") {
-    return std::string(value);
-  }
-  // Return the result of running canonicalize a hash given strippedValue.
-  return url_pattern_helpers::canonicalize_hash(value);
-}
-
-}  // namespace ada
-/* end file src/url_pattern.cpp */
-/* begin file src/url_pattern_helpers.cpp */
-
-#include <algorithm>
-#include <optional>
-#include <string>
-
-namespace ada::url_pattern_helpers {
-
-std::tuple<std::string, std::vector<std::string>>
-generate_regular_expression_and_name_list(
-    const std::vector<url_pattern_part>& part_list,
-    url_pattern_compile_component_options options) {
-  // Let result be "^"
-  std::string result = "^";
-
-  // Let name list be a new list
-  std::vector<std::string> name_list{};
-  const std::string full_wildcard_regexp_value = ".*";
-
-  // For each part of part list:
-  for (const url_pattern_part& part : part_list) {
-    // If part's type is "fixed-text":
-    if (part.type == url_pattern_part_type::FIXED_TEXT) {
-      // If part's modifier is "none"
-      if (part.modifier == url_pattern_part_modifier::none) {
-        // Append the result of running escape a regexp string given part's
-        // value
-        result += escape_regexp_string(part.value);
-      } else {
-        // A "fixed-text" part with a modifier uses a non capturing group
-        // (?:<fixed text>)<modifier>
-        // Append "(?:" to the end of result.
-        result.append("(?:");
-        // Append the result of running escape a regexp string given part’s
-        // value to the end of result.
-        result.append(escape_regexp_string(part.value));
-        // Append ")" to the end of result.
-        result.append(")");
-        // Append the result of running convert a modifier to a string given
-        // part’s modifier to the end of result.
-        result.append(convert_modifier_to_string(part.modifier));
-      }
-      continue;
-    }
-
-    // Assert: part's name is not the empty string
-    ADA_ASSERT_TRUE(!part.name.empty());
-
-    // Append part's name to name list
-    name_list.push_back(part.name);
-
-    // Let regexp value be part's value
-    std::string regexp_value = part.value;
-
-    // If part's type is "segment-wildcard"
-    if (part.type == url_pattern_part_type::SEGMENT_WILDCARD) {
-      // then set regexp value to the result of running generate a segment
-      // wildcard regexp given options.
-      regexp_value = generate_segment_wildcard_regexp(options);
-    }
-    // Otherwise if part's type is "full-wildcard"
-    else if (part.type == url_pattern_part_type::FULL_WILDCARD) {
-      // then set regexp value to full wildcard regexp value.
-      regexp_value = full_wildcard_regexp_value;
-    }
-
-    // If part's prefix is the empty string and part's suffix is the empty
-    // string
-    if (part.prefix.empty() && part.suffix.empty()) {
-      // If part's modifier is "none" or "optional"
-      if (part.modifier == url_pattern_part_modifier::none ||
-          part.modifier == url_pattern_part_modifier::optional) {
-        // (<regexp value>)<modifier>
-        result += "(" + regexp_value + ")" +
-                  convert_modifier_to_string(part.modifier);
-      } else {
-        // ((?:<regexp value>)<modifier>)
-        result += "((?:" + regexp_value + ")" +
-                  convert_modifier_to_string(part.modifier) + ")";
-      }
-      continue;
-    }
-
-    // If part's modifier is "none" or "optional"
-    if (part.modifier == url_pattern_part_modifier::none ||
-        part.modifier == url_pattern_part_modifier::optional) {
-      // (?:<prefix>(<regexp value>)<suffix>)<modifier>
-      result += "(?:" + escape_regexp_string(part.prefix) + "(" + regexp_value +
-                ")" + escape_regexp_string(part.suffix) + ")" +
-                convert_modifier_to_string(part.modifier);
-      continue;
-    }
-
-    // Assert: part's modifier is "zero-or-more" or "one-or-more"
-    ADA_ASSERT_TRUE(part.modifier == url_pattern_part_modifier::zero_or_more ||
-                    part.modifier == url_pattern_part_modifier::one_or_more);
-
-    // Assert: part's prefix is not the empty string or part's suffix is not the
-    // empty string
-    ADA_ASSERT_TRUE(!part.prefix.empty() || !part.suffix.empty());
-
-    // (?:<prefix>((?:<regexp value>)(?:<suffix><prefix>(?:<regexp
-    // value>))*)<suffix>)?
-    // Append "(?:" to the end of result.
-    result.append("(?:");
-    // Append the result of running escape a regexp string given part’s prefix
-    // to the end of result.
-    result.append(escape_regexp_string(part.prefix));
-    // Append "((?:" to the end of result.
-    result.append("((?:");
-    // Append regexp value to the end of result.
-    result.append(regexp_value);
-    // Append ")(?:" to the end of result.
-    result.append(")(?:");
-    // Append the result of running escape a regexp string given part’s suffix
-    // to the end of result.
-    result.append(escape_regexp_string(part.suffix));
-    // Append the result of running escape a regexp string given part’s prefix
-    // to the end of result.
-    result.append(escape_regexp_string(part.prefix));
-    // Append "(?:" to the end of result.
-    result.append("(?:");
-    // Append regexp value to the end of result.
-    result.append(regexp_value);
-    // Append "))*)" to the end of result.
-    result.append("))*)");
-    // Append the result of running escape a regexp string given part’s suffix
-    // to the end of result.
-    result.append(escape_regexp_string(part.suffix));
-    // Append ")" to the end of result.
-    result.append(")");
-
-    // If part's modifier is "zero-or-more" then append "?" to the end of result
-    if (part.modifier == url_pattern_part_modifier::zero_or_more) {
-      result += "?";
-    }
-  }
-
-  // Append "$" to the end of result
-  result += "$";
-
-  // Return (result, name list)
-  return {result, name_list};
-}
-
-bool is_ipv6_address(std::string_view input) noexcept {
-  // If input’s code point length is less than 2, then return false.
-  if (input.size() < 2) return false;
-
-  // Let input code points be input interpreted as a list of code points.
-  // If input code points[0] is U+005B ([), then return true.
-  if (input.front() == '[') return true;
-  // If input code points[0] is U+007B ({) and input code points[1] is U+005B
-  // ([), then return true.
-  if (input.starts_with("{[")) return true;
-  // If input code points[0] is U+005C (\) and input code points[1] is U+005B
-  // ([), then return true.
-  return input.starts_with("\\[");
-}
-
-std::string convert_modifier_to_string(url_pattern_part_modifier modifier) {
-  // TODO: Optimize this.
-  switch (modifier) {
-      // If modifier is "zero-or-more", then return "*".
-    case url_pattern_part_modifier::zero_or_more:
-      return "*";
-    // If modifier is "optional", then return "?".
-    case url_pattern_part_modifier::optional:
-      return "?";
-    // If modifier is "one-or-more", then return "+".
-    case url_pattern_part_modifier::one_or_more:
-      return "+";
-    // Return the empty string.
-    default:
-      return "";
-  }
-}
-
-std::string generate_segment_wildcard_regexp(
-    url_pattern_compile_component_options options) {
-  // Let result be "[^".
-  std::string result = "[^";
-  // Append the result of running escape a regexp string given options’s
-  // delimiter code point to the end of result.
-  result.append(escape_regexp_string(options.get_delimiter()));
-  // Append "]+?" to the end of result.
-  result.append("]+?");
-  // Return result.
-  ada_log("generate_segment_wildcard_regexp result: ", result);
-  return result;
-}
-
-tl::expected<std::string, errors> canonicalize_protocol(
-    std::string_view input) {
-  ada_log("canonicalize_protocol called with input=", input);
-  // If value is the empty string, return value.
-  if (input.empty()) [[unlikely]] {
-    return "";
-  }
-
-  // IMPORTANT: Deviation from the spec. We remove the trailing ':' here.
-  if (input.ends_with(":")) {
-    input.remove_suffix(1);
-  }
-
-  // Let dummyURL be a new URL record.
-  // Let parseResult be the result of running the basic URL parser given value
-  // followed by "://dummy.test", with dummyURL as url.
-  if (auto dummy_url = ada::parse<url_aggregator>(
-          std::string(input) + "://dummy.test", nullptr)) {
-    // IMPORTANT: Deviation from the spec. We remove the trailing ':' here.
-    // Since URL parser always return protocols ending with `:`
-    auto protocol = dummy_url->get_protocol();
-    protocol.remove_suffix(1);
-    return std::string(protocol);
-  }
-  // If parseResult is failure, then throw a TypeError.
-  return tl::unexpected(errors::type_error);
-}
-
-tl::expected<std::string, errors> canonicalize_username(
-    std::string_view input) {
-  // If value is the empty string, return value.
-  if (input.empty()) [[unlikely]] {
-    return "";
-  }
-  // Let dummyURL be a new URL record.
-  auto url = ada::parse<url_aggregator>("fake://dummy.test", nullptr);
-  ADA_ASSERT_TRUE(url.has_value());
-  // Set the username given dummyURL and value.
-  if (!url->set_username(input)) {
-    return tl::unexpected(errors::type_error);
-  }
-  // Return dummyURL’s username.
-  return std::string(url->get_username());
-}
-
-tl::expected<std::string, errors> canonicalize_password(
-    std::string_view input) {
-  // If value is the empty string, return value.
-  if (input.empty()) [[unlikely]] {
-    return "";
-  }
-  // Let dummyURL be a new URL record.
-  // Set the password given dummyURL and value.
-  auto url = ada::parse<url_aggregator>("fake://dummy.test", nullptr);
-
-  ADA_ASSERT_TRUE(url.has_value());
-  if (!url->set_password(input)) {
-    return tl::unexpected(errors::type_error);
-  }
-  // Return dummyURL’s password.
-  return std::string(url->get_password());
-}
-
-tl::expected<std::string, errors> canonicalize_hostname(
-    std::string_view input) {
-  ada_log("canonicalize_hostname input=", input);
-  // If value is the empty string, return value.
-  if (input.empty()) [[unlikely]] {
-    return "";
-  }
-  // Let dummyURL be a new URL record.
-  // Let parseResult be the result of running the basic URL parser given value
-  // with dummyURL as url and hostname state as state override.
-
-  // IMPORTANT: The protocol needs to be a special protocol, otherwise the
-  // hostname will not be converted using IDNA.
-  auto url = ada::parse<url_aggregator>("https://dummy.test", nullptr);
-  ADA_ASSERT_TRUE(url);
-  // if (!isValidHostnameInput(hostname)) return kj::none;
-  if (!url->set_hostname(input)) {
-    // If parseResult is failure, then throw a TypeError.
-    return tl::unexpected(errors::type_error);
-  }
-  // Return dummyURL’s host, serialized, or empty string if it is null.
-  return std::string(url->get_hostname());
-}
-
-tl::expected<std::string, errors> canonicalize_ipv6_hostname(
-    std::string_view input) {
-  ada_log("canonicalize_ipv6_hostname input=", input);
-  // TODO: Optimization opportunity: Use lookup table to speed up checking
-  if (std::ranges::any_of(input, [](char c) {
-        return c != '[' && c != ']' && c != ':' &&
-               !unicode::is_ascii_hex_digit(c);
-      })) {
-    return tl::unexpected(errors::type_error);
-  }
-  // Append the result of running ASCII lowercase given code point to the end of
-  // result.
-  auto hostname = std::string(input);
-  unicode::to_lower_ascii(hostname.data(), hostname.size());
-  return hostname;
-}
-
-tl::expected<std::string, errors> canonicalize_port(
-    std::string_view port_value) {
-  // If portValue is the empty string, return portValue.
-  if (port_value.empty()) [[unlikely]] {
-    return "";
-  }
-  // Let dummyURL be a new URL record.
-  // If protocolValue was given, then set dummyURL’s scheme to protocolValue.
-  // Let parseResult be the result of running basic URL parser given portValue
-  // with dummyURL as url and port state as state override.
-  auto url = ada::parse<url_aggregator>("fake://dummy.test", nullptr);
-  ADA_ASSERT_TRUE(url);
-  if (url->set_port(port_value)) {
-    // Return dummyURL’s port, serialized, or empty string if it is null.
-    return std::string(url->get_port());
-  }
-  // If parseResult is failure, then throw a TypeError.
-  return tl::unexpected(errors::type_error);
-}
-
-tl::expected<std::string, errors> canonicalize_port_with_protocol(
-    std::string_view port_value, std::string_view protocol) {
-  // If portValue is the empty string, return portValue.
-  if (port_value.empty()) [[unlikely]] {
-    return "";
-  }
-
-  // TODO: Remove this
-  // We have an empty protocol because get_protocol() returns an empty string
-  // We should handle this in the caller rather than here.
-  if (protocol.empty()) {
-    protocol = "fake";
-  } else if (protocol.ends_with(":")) {
-    protocol.remove_suffix(1);
-  }
-  // Let dummyURL be a new URL record.
-  // If protocolValue was given, then set dummyURL’s scheme to protocolValue.
-  // Let parseResult be the result of running basic URL parser given portValue
-  // with dummyURL as url and port state as state override.
-  auto url = ada::parse<url_aggregator>(std::string(protocol) + "://dummy.test",
-                                        nullptr);
-  // TODO: Remove has_port() check.
-  // This is actually a bug with url parser where set_port() returns true for
-  // "invalid80" port value.
-  if (url && url->set_port(port_value) && url->has_port()) {
-    // Return dummyURL’s port, serialized, or empty string if it is null.
-    return std::string(url->get_port());
-  }
-  // TODO: Remove this once the previous has_port() check is removed.
-  if (url) {
-    if (scheme::is_special(protocol) && url->get_port().empty()) {
-      return "";
-    }
-  }
-  // If parseResult is failure, then throw a TypeError.
-  return tl::unexpected(errors::type_error);
-}
-
-tl::expected<std::string, errors> canonicalize_pathname(
-    std::string_view input) {
-  // If value is the empty string, then return value.
-  if (input.empty()) [[unlikely]] {
-    return "";
-  }
-  // Let leading slash be true if the first code point in value is U+002F (/)
-  // and otherwise false.
-  const bool leading_slash = input.starts_with("/");
-  // Let modified value be "/-" if leading slash is false and otherwise the
-  // empty string.
-  const auto modified_value = leading_slash ? "" : "/-";
-  const auto full_url =
-      std::string("fake://fake-url") + modified_value + std::string(input);
-  if (auto url = ada::parse<url_aggregator>(full_url, nullptr)) {
-    const auto pathname = url->get_pathname();
-    // If leading slash is false, then set result to the code point substring
-    // from 2 to the end of the string within result.
-    return leading_slash ? std::string(pathname)
-                         : std::string(pathname.substr(2));
-  }
-  // If parseResult is failure, then throw a TypeError.
-  return tl::unexpected(errors::type_error);
-}
-
-tl::expected<std::string, errors> canonicalize_opaque_pathname(
-    std::string_view input) {
-  // If value is the empty string, return value.
-  if (input.empty()) [[unlikely]] {
-    return "";
-  }
-  // Let dummyURL be a new URL record.
-  // Set dummyURL’s path to the empty string.
-  // Let parseResult be the result of running URL parsing given value with
-  // dummyURL as url and opaque path state as state override.
-  if (auto url =
-          ada::parse<url_aggregator>("fake:" + std::string(input), nullptr)) {
-    // Return the result of URL path serializing dummyURL.
-    return std::string(url->get_pathname());
-  }
-  // If parseResult is failure, then throw a TypeError.
-  return tl::unexpected(errors::type_error);
-}
-
-tl::expected<std::string, errors> canonicalize_search(std::string_view input) {
-  // If value is the empty string, return value.
-  if (input.empty()) [[unlikely]] {
-    return "";
-  }
-  // Let dummyURL be a new URL record.
-  // Set dummyURL’s query to the empty string.
-  // Let parseResult be the result of running basic URL parser given value with
-  // dummyURL as url and query state as state override.
-  auto url = ada::parse<url_aggregator>("fake://dummy.test", nullptr);
-  ADA_ASSERT_TRUE(url.has_value());
-  url->set_search(input);
-  if (url->has_search()) {
-    const auto search = url->get_search();
-    return std::string(search.substr(1));
-  }
-  return tl::unexpected(errors::type_error);
-}
-
-tl::expected<std::string, errors> canonicalize_hash(std::string_view input) {
-  // If value is the empty string, return value.
-  if (input.empty()) [[unlikely]] {
-    return "";
-  }
-  // Let dummyURL be a new URL record.
-  // Set dummyURL’s fragment to the empty string.
-  // Let parseResult be the result of running basic URL parser given value with
-  // dummyURL as url and fragment state as state override.
-  auto url = ada::parse<url_aggregator>("fake://dummy.test", nullptr);
-  ADA_ASSERT_TRUE(url.has_value());
-  url->set_hash(input);
-  // Return dummyURL’s fragment.
-  if (url->has_hash()) {
-    const auto hash = url->get_hash();
-    return std::string(hash.substr(1));
-  }
-  return tl::unexpected(errors::type_error);
-}
-
-tl::expected<std::vector<token>, errors> tokenize(std::string_view input,
-                                                  token_policy policy) {
-  ada_log("tokenize input: ", input);
-  // Let tokenizer be a new tokenizer.
-  // Set tokenizer’s input to input.
-  // Set tokenizer’s policy to policy.
-  auto tokenizer = Tokenizer(input, policy);
-  // While tokenizer’s index is less than tokenizer’s input's code point length:
-  while (tokenizer.index < tokenizer.input.size()) {
-    // Run seek and get the next code point given tokenizer and tokenizer’s
-    // index.
-    tokenizer.seek_and_get_next_code_point(tokenizer.index);
-
-    // If tokenizer’s code point is U+002A (*):
-    if (tokenizer.code_point == '*') {
-      // Run add a token with default position and length given tokenizer and
-      // "asterisk".
-      tokenizer.add_token_with_defaults(token_type::ASTERISK);
-      ada_log("add ASTERISK token");
-      // Continue.
-      continue;
-    }
-
-    // If tokenizer’s code point is U+002B (+) or U+003F (?):
-    if (tokenizer.code_point == '+' || tokenizer.code_point == '?') {
-      // Run add a token with default position and length given tokenizer and
-      // "other-modifier".
-      tokenizer.add_token_with_defaults(token_type::OTHER_MODIFIER);
-      // Continue.
-      continue;
-    }
-
-    // If tokenizer’s code point is U+005C (\):
-    if (tokenizer.code_point == '\\') {
-      // If tokenizer’s index is equal to tokenizer’s input's code point length
-      // − 1:
-      if (tokenizer.index == tokenizer.input.size() - 1) {
-        // Run process a tokenizing error given tokenizer, tokenizer’s next
-        // index, and tokenizer’s index.
-        if (auto error = tokenizer.process_tokenizing_error(
-                tokenizer.next_index, tokenizer.index)) {
-          ada_log("process_tokenizing_error failed");
-          return tl::unexpected(*error);
-        }
-        continue;
-      }
-
-      // Let escaped index be tokenizer’s next index.
-      auto escaped_index = tokenizer.next_index;
-      // Run get the next code point given tokenizer.
-      tokenizer.get_next_code_point();
-      // Run add a token with default length given tokenizer, "escaped-char",
-      // tokenizer’s next index, and escaped index.
-      tokenizer.add_token_with_default_length(
-          token_type::ESCAPED_CHAR, tokenizer.next_index, escaped_index);
-      ada_log("add ESCAPED_CHAR token on next_index ", tokenizer.next_index,
-              " with escaped index ", escaped_index);
-      // Continue.
-      continue;
-    }
-
-    // If tokenizer’s code point is U+007B ({):
-    if (tokenizer.code_point == '{') {
-      // Run add a token with default position and length given tokenizer and
-      // "open".
-      tokenizer.add_token_with_defaults(token_type::OPEN);
-      ada_log("add OPEN token");
-      continue;
-    }
-
-    // If tokenizer’s code point is U+007D (}):
-    if (tokenizer.code_point == '}') {
-      // Run add a token with default position and length given tokenizer and
-      // "close".
-      tokenizer.add_token_with_defaults(token_type::CLOSE);
-      ada_log("add CLOSE token");
-      continue;
-    }
-
-    // If tokenizer’s code point is U+003A (:):
-    if (tokenizer.code_point == ':') {
-      // Let name position be tokenizer’s next index.
-      auto name_position = tokenizer.next_index;
-      // Let name start be name position.
-      auto name_start = name_position;
-      // While name position is less than tokenizer’s input's code point length:
-      while (name_position < tokenizer.input.size()) {
-        // Run seek and get the next code point given tokenizer and name
-        // position.
-        tokenizer.seek_and_get_next_code_point(name_position);
-        // Let first code point be true if name position equals name start and
-        // false otherwise.
-        bool first_code_point = name_position == name_start;
-        // Let valid code point be the result of running is a valid name code
-        // point given tokenizer’s code point and first code point.
-        auto valid_code_point =
-            idna::valid_name_code_point(tokenizer.code_point, first_code_point);
-        ada_log("tokenizer.code_point=", uint32_t(tokenizer.code_point),
-                " first_code_point=", first_code_point,
-                " valid_code_point=", valid_code_point);
-        // If valid code point is false break.
-        if (!valid_code_point) break;
-        // Set name position to tokenizer’s next index.
-        name_position = tokenizer.next_index;
-      }
-
-      // If name position is less than or equal to name start:
-      if (name_position <= name_start) {
-        // Run process a tokenizing error given tokenizer, name start, and
-        // tokenizer’s index.
-        if (auto error = tokenizer.process_tokenizing_error(name_start,
-                                                            tokenizer.index)) {
-          ada_log("process_tokenizing_error failed");
-          return tl::unexpected(*error);
-        }
-        // Continue
-        continue;
-      }
-
-      // Run add a token with default length given tokenizer, "name", name
-      // position, and name start.
-      tokenizer.add_token_with_default_length(token_type::NAME, name_position,
-                                              name_start);
-      continue;
-    }
-
-    // If tokenizer’s code point is U+0028 (():
-    if (tokenizer.code_point == '(') {
-      // Let depth be 1.
-      size_t depth = 1;
-      // Let regexp position be tokenizer’s next index.
-      auto regexp_position = tokenizer.next_index;
-      // Let regexp start be regexp position.
-      auto regexp_start = regexp_position;
-      // Let error be false.
-      bool error = false;
-
-      // While regexp position is less than tokenizer’s input's code point
-      // length:
-      while (regexp_position < tokenizer.input.size()) {
-        // Run seek and get the next code point given tokenizer and regexp
-        // position.
-        tokenizer.seek_and_get_next_code_point(regexp_position);
-
-        // TODO: Optimization opportunity: The next 2 if statements can be
-        // merged. If the result of running is ASCII given tokenizer’s code
-        // point is false:
-        if (!unicode::is_ascii(tokenizer.code_point)) {
-          // Run process a tokenizing error given tokenizer, regexp start, and
-          // tokenizer’s index.
-          if (auto process_error = tokenizer.process_tokenizing_error(
-                  regexp_start, tokenizer.index)) {
-            return tl::unexpected(*process_error);
-          }
-          // Set error to true.
-          error = true;
-          break;
-        }
-
-        // If regexp position equals regexp start and tokenizer’s code point is
-        // U+003F (?):
-        if (regexp_position == regexp_start && tokenizer.code_point == '?') {
-          // Run process a tokenizing error given tokenizer, regexp start, and
-          // tokenizer’s index.
-          if (auto process_error = tokenizer.process_tokenizing_error(
-                  regexp_start, tokenizer.index)) {
-            return tl::unexpected(*process_error);
-          }
-          // Set error to true;
-          error = true;
-          break;
-        }
-
-        // If tokenizer’s code point is U+005C (\):
-        if (tokenizer.code_point == '\\') {
-          // If regexp position equals tokenizer’s input's code point length − 1
-          if (regexp_position == tokenizer.input.size() - 1) {
-            // Run process a tokenizing error given tokenizer, regexp start, and
-            // tokenizer’s index.
-            if (auto process_error = tokenizer.process_tokenizing_error(
-                    regexp_start, tokenizer.index)) {
-              return tl::unexpected(*process_error);
-            }
-            // Set error to true.
-            error = true;
-            break;
-          }
-          // Run get the next code point given tokenizer.
-          tokenizer.get_next_code_point();
-          // If the result of running is ASCII given tokenizer’s code point is
-          // false:
-          if (!unicode::is_ascii(tokenizer.code_point)) {
-            // Run process a tokenizing error given tokenizer, regexp start, and
-            // tokenizer’s index.
-            if (auto process_error = tokenizer.process_tokenizing_error(
-                    regexp_start, tokenizer.index);
-                process_error.has_value()) {
-              return tl::unexpected(*process_error);
-            }
-            // Set error to true.
-            error = true;
-            break;
-          }
-          // Set regexp position to tokenizer’s next index.
-          regexp_position = tokenizer.next_index;
-          continue;
-        }
-
-        // If tokenizer’s code point is U+0029 ()):
-        if (tokenizer.code_point == ')') {
-          // Decrement depth by 1.
-          depth--;
-          // If depth is 0:
-          if (depth == 0) {
-            // Set regexp position to tokenizer’s next index.
-            regexp_position = tokenizer.next_index;
-            // Break.
-            break;
-          }
-        } else if (tokenizer.code_point == '(') {
-          // Otherwise if tokenizer’s code point is U+0028 (():
-          // Increment depth by 1.
-          depth++;
-          // If regexp position equals tokenizer’s input's code point length −
-          // 1:
-          if (regexp_position == tokenizer.input.size() - 1) {
-            // Run process a tokenizing error given tokenizer, regexp start, and
-            // tokenizer’s index.
-            if (auto process_error = tokenizer.process_tokenizing_error(
-                    regexp_start, tokenizer.index)) {
-              return tl::unexpected(*process_error);
-            }
-            // Set error to true.
-            error = true;
-            break;
-          }
-          // Let temporary position be tokenizer’s next index.
-          auto temporary_position = tokenizer.next_index;
-          // Run get the next code point given tokenizer.
-          tokenizer.get_next_code_point();
-          // If tokenizer’s code point is not U+003F (?):
-          if (tokenizer.code_point != '?') {
-            // Run process a tokenizing error given tokenizer, regexp start, and
-            // tokenizer’s index.
-            if (auto process_error = tokenizer.process_tokenizing_error(
-                    regexp_start, tokenizer.index)) {
-              return tl::unexpected(*process_error);
-            }
-            // Set error to true.
-            error = true;
-            break;
-          }
-          // Set tokenizer’s next index to temporary position.
-          tokenizer.next_index = temporary_position;
-        }
-        // Set regexp position to tokenizer’s next index.
-        regexp_position = tokenizer.next_index;
-      }
-
-      // If error is true continue.
-      if (error) continue;
-      // If depth is not zero:
-      if (depth != 0) {
-        // Run process a tokenizing error given tokenizer, regexp start, and
-        // tokenizer’s index.
-        if (auto process_error = tokenizer.process_tokenizing_error(
-                regexp_start, tokenizer.index)) {
-          return tl::unexpected(*process_error);
-        }
-        continue;
-      }
-      // Let regexp length be regexp position − regexp start − 1.
-      auto regexp_length = regexp_position - regexp_start - 1;
-      // If regexp length is zero:
-      if (regexp_length == 0) {
-        // Run process a tokenizing error given tokenizer, regexp start, and
-        // tokenizer’s index.
-        if (auto process_error = tokenizer.process_tokenizing_error(
-                regexp_start, tokenizer.index)) {
-          ada_log("process_tokenizing_error failed");
-          return tl::unexpected(*process_error);
-        }
-        continue;
-      }
-      // Run add a token given tokenizer, "regexp", regexp position, regexp
-      // start, and regexp length.
-      tokenizer.add_token(token_type::REGEXP, regexp_position, regexp_start,
-                          regexp_length);
-      continue;
-    }
-    // Run add a token with default position and length given tokenizer and
-    // "char".
-    tokenizer.add_token_with_defaults(token_type::CHAR);
-  }
-  // Run add a token with default length given tokenizer, "end", tokenizer’s
-  // index, and tokenizer’s index.
-  tokenizer.add_token_with_default_length(token_type::END, tokenizer.index,
-                                          tokenizer.index);
-
-  ada_log("tokenizer.token_list size is: ", tokenizer.token_list.size());
-  // Return tokenizer’s token list.
-  return tokenizer.token_list;
-}
-
-std::string escape_pattern_string(std::string_view input) {
-  ada_log("escape_pattern_string called with input=", input);
-  if (input.empty()) [[unlikely]] {
-    return "";
-  }
-  // Assert: input is an ASCII string.
-  ADA_ASSERT_TRUE(ada::idna::is_ascii(input));
-  // Let result be the empty string.
-  std::string result{};
-  result.reserve(input.size());
-
-  // TODO: Optimization opportunity: Use a lookup table
-  constexpr auto should_escape = [](const char c) {
-    return c == '+' || c == '*' || c == '?' || c == ':' || c == '{' ||
-           c == '}' || c == '(' || c == ')' || c == '\\';
-  };
-
-  // While index is less than input’s length:
-  for (const auto& c : input) {
-    if (should_escape(c)) {
-      // then append U+005C (\) to the end of result.
-      result.append("\\");
-    }
-
-    // Append c to the end of result.
-    result += c;
-  }
-  // Return result.
-  return result;
-}
-
-namespace {
-constexpr std::array<uint8_t, 256> escape_regexp_table = []() consteval {
-  std::array<uint8_t, 256> out{};
-  for (auto& c : {'.', '+', '*', '?', '^', '$', '{', '}', '(', ')', '[', ']',
-                  '|', '/', '\\'}) {
-    out[c] = 1;
-  }
-  return out;
-}();
-
-constexpr bool should_escape_regexp_char(char c) {
-  return escape_regexp_table[(uint8_t)c];
-}
-}  // namespace
-
-std::string escape_regexp_string(std::string_view input) {
-  // Assert: input is an ASCII string.
-  ADA_ASSERT_TRUE(idna::is_ascii(input));
-  // Let result be the empty string.
-  std::string result{};
-  result.reserve(input.size());
-  for (const auto& c : input) {
-    // TODO: Optimize this even further
-    if (should_escape_regexp_char(c)) {
-      result.append(std::string("\\") + c);
-    } else {
-      result.push_back(c);
-    }
-  }
-  return result;
-}
-
-std::string process_base_url_string(std::string_view input,
-                                    std::string_view type) {
-  // If type is not "pattern" return input.
-  if (type != "pattern") {
-    return std::string(input);
-  }
-  // Return the result of escaping a pattern string given input.
-  return escape_pattern_string(input);
-}
-
-constexpr bool is_absolute_pathname(std::string_view input,
-                                    std::string_view type) noexcept {
-  // If input is the empty string, then return false.
-  if (input.empty()) [[unlikely]] {
-    return false;
-  }
-  // If input[0] is U+002F (/), then return true.
-  if (input.starts_with("/")) return true;
-  // If type is "url", then return false.
-  if (type == "url") return false;
-  // If input’s code point length is less than 2, then return false.
-  if (input.size() < 2) return false;
-  // If input[0] is U+005C (\) and input[1] is U+002F (/), then return true.
-  if (input.starts_with("\\/")) return true;
-  // If input[0] is U+007B ({) and input[1] is U+002F (/), then return true.
-  if (input.starts_with("{/")) return true;
-  // Return false.
-  return false;
-}
-
-std::string generate_pattern_string(
-    std::vector<url_pattern_part>& part_list,
-    url_pattern_compile_component_options& options) {
-  // Let result be the empty string.
-  std::string result{};
-  // Let index list be the result of getting the indices for part list.
-  // For each index of index list:
-  for (size_t index = 0; index < part_list.size(); index++) {
-    // Let part be part list[index].
-    auto part = part_list[index];
-    // Let previous part be part list[index - 1] if index is greater than 0,
-    // otherwise let it be null.
-    // TODO: Optimization opportunity. Find a way to avoid making a copy here.
-    std::optional<url_pattern_part> previous_part =
-        index == 0 ? std::nullopt : std::optional(part_list[index - 1]);
-    // Let next part be part list[index + 1] if index is less than index list’s
-    // size - 1, otherwise let it be null.
-    std::optional<url_pattern_part> next_part =
-        index < part_list.size() - 1 ? std::optional(part_list[index + 1])
-                                     : std::nullopt;
-    // If part’s type is "fixed-text" then:
-    if (part.type == url_pattern_part_type::FIXED_TEXT) {
-      // If part’s modifier is "none" then:
-      if (part.modifier == url_pattern_part_modifier::none) {
-        // Append the result of running escape a pattern string given part’s
-        // value to the end of result.
-        result.append(escape_pattern_string(part.value));
-        continue;
-      }
-      // Append "{" to the end of result.
-      result += "{";
-      // Append the result of running escape a pattern string given part’s value
-      // to the end of result.
-      result.append(escape_pattern_string(part.value));
-      // Append "}" to the end of result.
-      result += "}";
-      // Append the result of running convert a modifier to a string given
-      // part’s modifier to the end of result.
-      result.append(convert_modifier_to_string(part.modifier));
-      continue;
-    }
-    // Let custom name be true if part’s name[0] is not an ASCII digit;
-    // otherwise false.
-    bool custom_name = !unicode::is_ascii_digit(part.name[0]);
-    // Let needs grouping be true if at least one of the following are true,
-    // otherwise let it be false:
-    // - part’s suffix is not the empty string.
-    // - part’s prefix is not the empty string and is not options’s prefix code
-    // point.
-    bool needs_grouping =
-        !part.suffix.empty() ||
-        (!part.prefix.empty() && part.prefix[0] != options.get_prefix()[0]);
-
-    // If all of the following are true:
-    // - needs grouping is false; and
-    // - custom name is true; and
-    // - part’s type is "segment-wildcard"; and
-    // - part’s modifier is "none"; and
-    // - next part is not null; and
-    // - next part’s prefix is the empty string; and
-    // - next part’s suffix is the empty string
-    if (!needs_grouping && custom_name &&
-        part.type == url_pattern_part_type::SEGMENT_WILDCARD &&
-        part.modifier == url_pattern_part_modifier::none &&
-        next_part.has_value() && next_part->prefix.empty() &&
-        next_part->suffix.empty()) {
-      // If next part’s type is "fixed-text":
-      if (next_part->type == url_pattern_part_type::FIXED_TEXT) {
-        // Set needs grouping to true if the result of running is a valid name
-        // code point given next part’s value's first code point and the boolean
-        // false is true.
-        if (idna::valid_name_code_point(next_part->value[0], false)) {
-          needs_grouping = true;
-        }
-      } else {
-        // Set needs grouping to true if next part’s name[0] is an ASCII digit.
-        needs_grouping = !next_part->name.empty() &&
-                         unicode::is_ascii_digit(next_part->name[0]);
-      }
-    }
-
-    // If all of the following are true:
-    // - needs grouping is false; and
-    // - part’s prefix is the empty string; and
-    // - previous part is not null; and
-    // - previous part’s type is "fixed-text"; and
-    // - previous part’s value's last code point is options’s prefix code point.
-    // then set needs grouping to true.
-    if (!needs_grouping && part.prefix.empty() && previous_part.has_value() &&
-        previous_part->type == url_pattern_part_type::FIXED_TEXT &&
-        !options.get_prefix().empty() &&
-        previous_part->value.at(previous_part->value.size() - 1) ==
-            options.get_prefix()[0]) {
-      needs_grouping = true;
-    }
-
-    // Assert: part’s name is not the empty string or null.
-    ADA_ASSERT_TRUE(!part.name.empty());
-
-    // If needs grouping is true, then append "{" to the end of result.
-    if (needs_grouping) {
-      result.append("{");
-    }
-
-    // Append the result of running escape a pattern string given part’s prefix
-    // to the end of result.
-    result.append(escape_pattern_string(part.prefix));
-
-    // If custom name is true:
-    if (custom_name) {
-      // Append ":" to the end of result.
-      result.append(":");
-      // Append part’s name to the end of result.
-      result.append(part.name);
-    }
-
-    // If part’s type is "regexp" then:
-    if (part.type == url_pattern_part_type::REGEXP) {
-      // Append "(" to the end of result.
-      result.append("(");
-      // Append part’s value to the end of result.
-      result.append(part.value);
-      // Append ")" to the end of result.
-      result.append(")");
-    } else if (part.type == url_pattern_part_type::SEGMENT_WILDCARD &&
-               !custom_name) {
-      // Otherwise if part’s type is "segment-wildcard" and custom name is
-      // false: Append "(" to the end of result.
-      result.append("(");
-      // Append the result of running generate a segment wildcard regexp given
-      // options to the end of result.
-      result.append(generate_segment_wildcard_regexp(options));
-      // Append ")" to the end of result.
-      result.append(")");
-    } else if (part.type == url_pattern_part_type::FULL_WILDCARD) {
-      // Otherwise if part’s type is "full-wildcard":
-      // If custom name is false and one of the following is true:
-      // - previous part is null; or
-      // - previous part’s type is "fixed-text"; or
-      // - previous part’s modifier is not "none"; or
-      // - needs grouping is true; or
-      // - part’s prefix is not the empty string
-      // - then append "*" to the end of result.
-      if (!custom_name &&
-          (!previous_part.has_value() ||
-           previous_part->type == url_pattern_part_type::FIXED_TEXT ||
-           previous_part->modifier != url_pattern_part_modifier::none ||
-           needs_grouping || !part.prefix.empty())) {
-        result.append("*");
-      } else {
-        // Append "(" to the end of result.
-        // Append full wildcard regexp value to the end of result.
-        // Append ")" to the end of result.
-        result.append("(.*)");
-      }
-    }
-
-    // If all of the following are true:
-    // - part’s type is "segment-wildcard"; and
-    // - custom name is true; and
-    // - part’s suffix is not the empty string; and
-    // - The result of running is a valid name code point given part’s suffix's
-    // first code point and the boolean false is true then append U+005C (\) to
-    // the end of result.
-    if (part.type == url_pattern_part_type::SEGMENT_WILDCARD && custom_name &&
-        !part.suffix.empty() &&
-        idna::valid_name_code_point(part.suffix[0], false)) {
-      result.append("\\");
-    }
-
-    // Append the result of running escape a pattern string given part’s suffix
-    // to the end of result.
-    result.append(escape_pattern_string(part.suffix));
-    // If needs grouping is true, then append "}" to the end of result.
-    if (needs_grouping) result.append("}");
-    // Append the result of running convert a modifier to a string given part’s
-    // modifier to the end of result.
-    result.append(convert_modifier_to_string(part.modifier));
-  }
-  // Return result.
-  return result;
-}
-}  // namespace ada::url_pattern_helpers
-/* end file src/url_pattern_helpers.cpp */
-/* begin file src/url_pattern_regex.cpp */
-
-namespace ada::url_pattern_regex {
-
-#ifdef ADA_USE_UNSAFE_STD_REGEX_PROVIDER
-std::optional<std::regex> std_regex_provider::create_instance(
-    std::string_view pattern, bool ignore_case) {
-  // Let flags be an empty string.
-  // If options’s ignore case is true then set flags to "vi".
-  // Otherwise set flags to "v"
-  auto flags = ignore_case
-                   ? std::regex::icase | std::regex_constants::ECMAScript
-                   : std::regex_constants::ECMAScript;
-  try {
-    return std::regex(pattern.data(), pattern.size(), flags);
-  } catch (const std::regex_error& e) {
-    (void)e;
-    ada_log("std_regex_provider::create_instance failed:", e.what());
-    return std::nullopt;
-  }
-}
-
-std::optional<std::vector<std::optional<std::string>>>
-std_regex_provider::regex_search(std::string_view input,
-                                 const std::regex& pattern) {
-  std::string input_str(
-      input.begin(),
-      input.end());  // Convert string_view to string for regex_search
-  std::smatch match_result;
-  if (!std::regex_search(input_str, match_result, pattern,
-                         std::regex_constants::match_any)) {
-    return std::nullopt;
-  }
-  std::vector<std::optional<std::string>> matches;
-  // If input is empty, let's assume the result will be empty as well.
-  if (input.empty() || match_result.empty()) {
-    return matches;
-  }
-  matches.reserve(match_result.size());
-  for (size_t i = 1; i < match_result.size(); ++i) {
-    if (auto entry = match_result[i]; entry.matched) {
-      matches.emplace_back(entry.str());
-    }
-  }
-  return matches;
-}
-
-bool std_regex_provider::regex_match(std::string_view input,
-                                     const std::regex& pattern) {
-  return std::regex_match(input.begin(), input.end(), pattern);
-}
-
-#endif  // ADA_USE_UNSAFE_STD_REGEX_PROVIDER
-
-}  // namespace ada::url_pattern_regex
-/* end file src/url_pattern_regex.cpp */
-/* begin file src/ada_c.cpp */
-
-ada::result<ada::url_aggregator>& get_instance(void* result) noexcept {
-  return *(ada::result<ada::url_aggregator>*)result;
-}
-
-extern "C" {
-typedef void* ada_url;
-typedef void* ada_url_search_params;
-typedef void* ada_strings;
-typedef void* ada_url_search_params_keys_iter;
-typedef void* ada_url_search_params_values_iter;
-typedef void* ada_url_search_params_entries_iter;
-
-struct ada_string {
-  const char* data;
-  size_t length;
-};
-
-struct ada_owned_string {
-  const char* data;
-  size_t length;
-};
-
-struct ada_string_pair {
-  ada_string key;
-  ada_string value;
-};
-
-ada_string ada_string_create(const char* data, size_t length) {
-  ada_string out{};
-  out.data = data;
-  out.length = length;
-  return out;
-}
-
-struct ada_url_components {
-  /*
-   * By using 32-bit integers, we implicitly assume that the URL string
-   * cannot exceed 4 GB.
-   *
-   * https://user:pass@example.com:1234/foo/bar?baz#quux
-   *       |     |    |          | ^^^^|       |   |
-   *       |     |    |          | |   |       |   `----- hash_start
-   *       |     |    |          | |   |       `--------- search_start
-   *       |     |    |          | |   `----------------- pathname_start
-   *       |     |    |          | `--------------------- port
-   *       |     |    |          `----------------------- host_end
-   *       |     |    `---------------------------------- host_start
-   *       |     `--------------------------------------- username_end
-   *       `--------------------------------------------- protocol_end
-   */
-  uint32_t protocol_end;
-  /**
-   * Username end is not `omitted` by default (-1) to make username and password
-   * getters less costly to implement.
-   */
-  uint32_t username_end;
-  uint32_t host_start;
-  uint32_t host_end;
-  uint32_t port;
-  uint32_t pathname_start;
-  uint32_t search_start;
-  uint32_t hash_start;
-};
-
-ada_url ada_parse(const char* input, size_t length) noexcept {
-  return new ada::result<ada::url_aggregator>(
-      ada::parse<ada::url_aggregator>(std::string_view(input, length)));
-}
-
-ada_url ada_parse_with_base(const char* input, size_t input_length,
-                            const char* base, size_t base_length) noexcept {
-  auto base_out =
-      ada::parse<ada::url_aggregator>(std::string_view(base, base_length));
-
-  if (!base_out) {
-    return new ada::result<ada::url_aggregator>(base_out);
-  }
-
-  return new ada::result<ada::url_aggregator>(ada::parse<ada::url_aggregator>(
-      std::string_view(input, input_length), &base_out.value()));
-}
-
-bool ada_can_parse(const char* input, size_t length) noexcept {
-  return ada::can_parse(std::string_view(input, length));
-}
-
-bool ada_can_parse_with_base(const char* input, size_t input_length,
-                             const char* base, size_t base_length) noexcept {
-  std::string_view base_view(base, base_length);
-  return ada::can_parse(std::string_view(input, input_length), &base_view);
-}
-
-void ada_free(ada_url result) noexcept {
-  auto* r = (ada::result<ada::url_aggregator>*)result;
-  delete r;
-}
-
-ada_url ada_copy(ada_url input) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(input);
-  return new ada::result<ada::url_aggregator>(r);
-}
-
-bool ada_is_valid(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  return r.has_value();
-}
-
-// caller must free the result with ada_free_owned_string
-ada_owned_string ada_get_origin(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  ada_owned_string owned{};
-  if (!r) {
-    owned.data = nullptr;
-    owned.length = 0;
-    return owned;
-  }
-  std::string out = r->get_origin();
-  owned.length = out.size();
-  owned.data = new char[owned.length];
-  memcpy((void*)owned.data, out.data(), owned.length);
-  return owned;
-}
-
-void ada_free_owned_string(ada_owned_string owned) noexcept {
-  delete[] owned.data;
-}
-
-ada_string ada_get_href(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return ada_string_create(nullptr, 0);
-  }
-  std::string_view out = r->get_href();
-  return ada_string_create(out.data(), out.length());
-}
-
-ada_string ada_get_username(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return ada_string_create(nullptr, 0);
-  }
-  std::string_view out = r->get_username();
-  return ada_string_create(out.data(), out.length());
-}
-
-ada_string ada_get_password(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return ada_string_create(nullptr, 0);
-  }
-  std::string_view out = r->get_password();
-  return ada_string_create(out.data(), out.length());
-}
-
-ada_string ada_get_port(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return ada_string_create(nullptr, 0);
-  }
-  std::string_view out = r->get_port();
-  return ada_string_create(out.data(), out.length());
-}
-
-ada_string ada_get_hash(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return ada_string_create(nullptr, 0);
-  }
-  std::string_view out = r->get_hash();
-  return ada_string_create(out.data(), out.length());
-}
-
-ada_string ada_get_host(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return ada_string_create(nullptr, 0);
-  }
-  std::string_view out = r->get_host();
-  return ada_string_create(out.data(), out.length());
-}
-
-ada_string ada_get_hostname(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return ada_string_create(nullptr, 0);
-  }
-  std::string_view out = r->get_hostname();
-  return ada_string_create(out.data(), out.length());
-}
-
-ada_string ada_get_pathname(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return ada_string_create(nullptr, 0);
-  }
-  std::string_view out = r->get_pathname();
-  return ada_string_create(out.data(), out.length());
-}
-
-ada_string ada_get_search(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return ada_string_create(nullptr, 0);
-  }
-  std::string_view out = r->get_search();
-  return ada_string_create(out.data(), out.length());
-}
-
-ada_string ada_get_protocol(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return ada_string_create(nullptr, 0);
-  }
-  std::string_view out = r->get_protocol();
-  return ada_string_create(out.data(), out.length());
-}
-
-uint8_t ada_get_host_type(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return 0;
-  }
-  return r->host_type;
-}
-
-uint8_t ada_get_scheme_type(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return 0;
-  }
-  return r->type;
-}
-
-bool ada_set_href(ada_url result, const char* input, size_t length) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return false;
-  }
-  return r->set_href(std::string_view(input, length));
-}
-
-bool ada_set_host(ada_url result, const char* input, size_t length) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return false;
-  }
-  return r->set_host(std::string_view(input, length));
-}
-
-bool ada_set_hostname(ada_url result, const char* input,
-                      size_t length) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return false;
-  }
-  return r->set_hostname(std::string_view(input, length));
-}
-
-bool ada_set_protocol(ada_url result, const char* input,
-                      size_t length) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return false;
-  }
-  return r->set_protocol(std::string_view(input, length));
-}
-
-bool ada_set_username(ada_url result, const char* input,
-                      size_t length) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return false;
-  }
-  return r->set_username(std::string_view(input, length));
-}
-
-bool ada_set_password(ada_url result, const char* input,
-                      size_t length) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return false;
-  }
-  return r->set_password(std::string_view(input, length));
-}
-
-bool ada_set_port(ada_url result, const char* input, size_t length) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return false;
-  }
-  return r->set_port(std::string_view(input, length));
-}
-
-bool ada_set_pathname(ada_url result, const char* input,
-                      size_t length) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return false;
-  }
-  return r->set_pathname(std::string_view(input, length));
-}
-
-/**
- * Update the search/query of the URL.
- *
- * If a URL has `?` as the search value, passing empty string to this function
- * does not remove the attribute. If you need to remove it, please use
- * `ada_clear_search` method.
- */
-void ada_set_search(ada_url result, const char* input, size_t length) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (r) {
-    r->set_search(std::string_view(input, length));
-  }
-}
-
-/**
- * Update the hash/fragment of the URL.
- *
- * If a URL has `#` as the hash value, passing empty string to this function
- * does not remove the attribute. If you need to remove it, please use
- * `ada_clear_hash` method.
- */
-void ada_set_hash(ada_url result, const char* input, size_t length) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (r) {
-    r->set_hash(std::string_view(input, length));
-  }
-}
-
-void ada_clear_port(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (r) {
-    r->clear_port();
-  }
-}
-
-/**
- * Removes the hash of the URL.
- *
- * Despite `ada_set_hash` method, this function allows the complete
- * removal of the hash attribute, even if it has a value of `#`.
- */
-void ada_clear_hash(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (r) {
-    r->clear_hash();
-  }
-}
-
-/**
- * Removes the search of the URL.
- *
- * Despite `ada_set_search` method, this function allows the complete
- * removal of the search attribute, even if it has a value of `?`.
- */
-void ada_clear_search(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (r) {
-    r->clear_search();
-  }
-}
-
-bool ada_has_credentials(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return false;
-  }
-  return r->has_credentials();
-}
-
-bool ada_has_empty_hostname(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return false;
-  }
-  return r->has_empty_hostname();
-}
-
-bool ada_has_hostname(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return false;
-  }
-  return r->has_hostname();
-}
-
-bool ada_has_non_empty_username(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return false;
-  }
-  return r->has_non_empty_username();
-}
-
-bool ada_has_non_empty_password(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return false;
-  }
-  return r->has_non_empty_password();
-}
-
-bool ada_has_port(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return false;
-  }
-  return r->has_port();
-}
-
-bool ada_has_password(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return false;
-  }
-  return r->has_password();
-}
-
-bool ada_has_hash(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return false;
-  }
-  return r->has_hash();
-}
-
-bool ada_has_search(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return false;
-  }
-  return r->has_search();
-}
-
-// returns a pointer to the internal url_aggregator::url_components
-const ada_url_components* ada_get_components(ada_url result) noexcept {
-  static_assert(sizeof(ada_url_components) == sizeof(ada::url_components));
-  ada::result<ada::url_aggregator>& r = get_instance(result);
-  if (!r) {
-    return nullptr;
-  }
-  return reinterpret_cast<const ada_url_components*>(&r->get_components());
-}
-
-ada_owned_string ada_idna_to_unicode(const char* input, size_t length) {
-  std::string out = ada::idna::to_unicode(std::string_view(input, length));
-  ada_owned_string owned{};
-  owned.length = out.length();
-  owned.data = new char[owned.length];
-  memcpy((void*)owned.data, out.data(), owned.length);
-  return owned;
-}
-
-ada_owned_string ada_idna_to_ascii(const char* input, size_t length) {
-  std::string out = ada::idna::to_ascii(std::string_view(input, length));
-  ada_owned_string owned{};
-  owned.length = out.size();
-  owned.data = new char[owned.length];
-  memcpy((void*)owned.data, out.data(), owned.length);
-  return owned;
-}
-
-ada_url_search_params ada_parse_search_params(const char* input,
-                                              size_t length) {
-  return new ada::result<ada::url_search_params>(
-      ada::url_search_params(std::string_view(input, length)));
-}
-
-void ada_free_search_params(ada_url_search_params result) {
-  auto* r = (ada::result<ada::url_search_params>*)result;
-  delete r;
-}
-
-ada_owned_string ada_search_params_to_string(ada_url_search_params result) {
-  ada::result<ada::url_search_params>& r =
-      *(ada::result<ada::url_search_params>*)result;
-  if (!r) return ada_owned_string{nullptr, 0};
-  std::string out = r->to_string();
-  ada_owned_string owned{};
-  owned.length = out.size();
-  owned.data = new char[owned.length];
-  memcpy((void*)owned.data, out.data(), owned.length);
-  return owned;
-}
-
-size_t ada_search_params_size(ada_url_search_params result) {
-  ada::result<ada::url_search_params>& r =
-      *(ada::result<ada::url_search_params>*)result;
-  if (!r) {
-    return 0;
-  }
-  return r->size();
-}
-
-void ada_search_params_sort(ada_url_search_params result) {
-  ada::result<ada::url_search_params>& r =
-      *(ada::result<ada::url_search_params>*)result;
-  if (r) {
-    r->sort();
-  }
-}
-
-void ada_search_params_reset(ada_url_search_params result, const char* input,
-                             size_t length) {
-  ada::result<ada::url_search_params>& r =
-      *(ada::result<ada::url_search_params>*)result;
-  if (r) {
-    r->reset(std::string_view(input, length));
-  }
-}
-
-void ada_search_params_append(ada_url_search_params result, const char* key,
-                              size_t key_length, const char* value,
-                              size_t value_length) {
-  ada::result<ada::url_search_params>& r =
-      *(ada::result<ada::url_search_params>*)result;
-  if (r) {
-    r->append(std::string_view(key, key_length),
-              std::string_view(value, value_length));
-  }
-}
-
-void ada_search_params_set(ada_url_search_params result, const char* key,
-                           size_t key_length, const char* value,
-                           size_t value_length) {
-  ada::result<ada::url_search_params>& r =
-      *(ada::result<ada::url_search_params>*)result;
-  if (r) {
-    r->set(std::string_view(key, key_length),
-           std::string_view(value, value_length));
-  }
-}
-
-void ada_search_params_remove(ada_url_search_params result, const char* key,
-                              size_t key_length) {
-  ada::result<ada::url_search_params>& r =
-      *(ada::result<ada::url_search_params>*)result;
-  if (r) {
-    r->remove(std::string_view(key, key_length));
-  }
-}
-
-void ada_search_params_remove_value(ada_url_search_params result,
-                                    const char* key, size_t key_length,
-                                    const char* value, size_t value_length) {
-  ada::result<ada::url_search_params>& r =
-      *(ada::result<ada::url_search_params>*)result;
-  if (r) {
-    r->remove(std::string_view(key, key_length),
-              std::string_view(value, value_length));
-  }
-}
-
-bool ada_search_params_has(ada_url_search_params result, const char* key,
-                           size_t key_length) {
-  ada::result<ada::url_search_params>& r =
-      *(ada::result<ada::url_search_params>*)result;
-  if (!r) {
-    return false;
-  }
-  return r->has(std::string_view(key, key_length));
-}
-
-bool ada_search_params_has_value(ada_url_search_params result, const char* key,
-                                 size_t key_length, const char* value,
-                                 size_t value_length) {
-  ada::result<ada::url_search_params>& r =
-      *(ada::result<ada::url_search_params>*)result;
-  if (!r) {
-    return false;
-  }
-  return r->has(std::string_view(key, key_length),
-                std::string_view(value, value_length));
-}
-
-ada_string ada_search_params_get(ada_url_search_params result, const char* key,
-                                 size_t key_length) {
-  ada::result<ada::url_search_params>& r =
-      *(ada::result<ada::url_search_params>*)result;
-  if (!r) {
-    return ada_string_create(nullptr, 0);
-  }
-  auto found = r->get(std::string_view(key, key_length));
-  if (!found.has_value()) {
-    return ada_string_create(nullptr, 0);
-  }
-  return ada_string_create(found->data(), found->length());
-}
-
-ada_strings ada_search_params_get_all(ada_url_search_params result,
-                                      const char* key, size_t key_length) {
-  ada::result<ada::url_search_params>& r =
-      *(ada::result<ada::url_search_params>*)result;
-  if (!r) {
-    return new ada::result<std::vector<std::string>>(
-        std::vector<std::string>());
-  }
-  return new ada::result<std::vector<std::string>>(
-      r->get_all(std::string_view(key, key_length)));
-}
-
-ada_url_search_params_keys_iter ada_search_params_get_keys(
-    ada_url_search_params result) {
-  ada::result<ada::url_search_params>& r =
-      *(ada::result<ada::url_search_params>*)result;
-  if (!r) {
-    return new ada::result<ada::url_search_params_keys_iter>(
-        ada::url_search_params_keys_iter());
-  }
-  return new ada::result<ada::url_search_params_keys_iter>(r->get_keys());
-}
-
-ada_url_search_params_values_iter ada_search_params_get_values(
-    ada_url_search_params result) {
-  ada::result<ada::url_search_params>& r =
-      *(ada::result<ada::url_search_params>*)result;
-  if (!r) {
-    return new ada::result<ada::url_search_params_values_iter>(
-        ada::url_search_params_values_iter());
-  }
-  return new ada::result<ada::url_search_params_values_iter>(r->get_values());
-}
-
-ada_url_search_params_entries_iter ada_search_params_get_entries(
-    ada_url_search_params result) {
-  ada::result<ada::url_search_params>& r =
-      *(ada::result<ada::url_search_params>*)result;
-  if (!r) {
-    return new ada::result<ada::url_search_params_entries_iter>(
-        ada::url_search_params_entries_iter());
-  }
-  return new ada::result<ada::url_search_params_entries_iter>(r->get_entries());
-}
-
-void ada_free_strings(ada_strings result) {
-  auto* r = (ada::result<std::vector<std::string>>*)result;
-  delete r;
-}
-
-size_t ada_strings_size(ada_strings result) {
-  auto* r = (ada::result<std::vector<std::string>>*)result;
-  if (!r) {
-    return 0;
-  }
-  return (*r)->size();
-}
-
-ada_string ada_strings_get(ada_strings result, size_t index) {
-  auto* r = (ada::result<std::vector<std::string>>*)result;
-  if (!r) {
-    return ada_string_create(nullptr, 0);
-  }
-  std::string_view view = (*r)->at(index);
-  return ada_string_create(view.data(), view.length());
-}
-
-void ada_free_search_params_keys_iter(ada_url_search_params_keys_iter result) {
-  auto* r = (ada::result<ada::url_search_params_keys_iter>*)result;
-  delete r;
-}
-
-ada_string ada_search_params_keys_iter_next(
-    ada_url_search_params_keys_iter result) {
-  auto* r = (ada::result<ada::url_search_params_keys_iter>*)result;
-  if (!r) {
-    return ada_string_create(nullptr, 0);
-  }
-  auto next = (*r)->next();
-  if (!next.has_value()) {
-    return ada_string_create(nullptr, 0);
-  }
-  return ada_string_create(next->data(), next->length());
-}
-
-bool ada_search_params_keys_iter_has_next(
-    ada_url_search_params_keys_iter result) {
-  auto* r = (ada::result<ada::url_search_params_keys_iter>*)result;
-  if (!r) {
-    return false;
-  }
-  return (*r)->has_next();
-}
-
-void ada_free_search_params_values_iter(
-    ada_url_search_params_values_iter result) {
-  auto* r = (ada::result<ada::url_search_params_values_iter>*)result;
-  delete r;
-}
-
-ada_string ada_search_params_values_iter_next(
-    ada_url_search_params_values_iter result) {
-  auto* r = (ada::result<ada::url_search_params_values_iter>*)result;
-  if (!r) {
-    return ada_string_create(nullptr, 0);
-  }
-  auto next = (*r)->next();
-  if (!next.has_value()) {
-    return ada_string_create(nullptr, 0);
-  }
-  return ada_string_create(next->data(), next->length());
-}
-
-bool ada_search_params_values_iter_has_next(
-    ada_url_search_params_values_iter result) {
-  auto* r = (ada::result<ada::url_search_params_values_iter>*)result;
-  if (!r) {
-    return false;
-  }
-  return (*r)->has_next();
-}
-
-void ada_free_search_params_entries_iter(
-    ada_url_search_params_entries_iter result) {
-  auto* r = (ada::result<ada::url_search_params_entries_iter>*)result;
-  delete r;
-}
-
-ada_string_pair ada_search_params_entries_iter_next(
-    ada_url_search_params_entries_iter result) {
-  auto* r = (ada::result<ada::url_search_params_entries_iter>*)result;
-  if (!r) return {ada_string_create(nullptr, 0), ada_string_create(nullptr, 0)};
-  auto next = (*r)->next();
-  if (!next.has_value()) {
-    return {ada_string_create(nullptr, 0), ada_string_create(nullptr, 0)};
-  }
-  return ada_string_pair{
-      ada_string_create(next->first.data(), next->first.length()),
-      ada_string_create(next->second.data(), next->second.length())};
-}
-
-bool ada_search_params_entries_iter_has_next(
-    ada_url_search_params_entries_iter result) {
-  auto* r = (ada::result<ada::url_search_params_entries_iter>*)result;
-  if (!r) {
-    return false;
-  }
-  return (*r)->has_next();
-}
-
-}  // extern "C"
-/* end file src/ada_c.cpp */
-/* end file src/ada.cpp */
diff --git a/packages/react-native-executorch/common/ada/ada.h b/packages/react-native-executorch/common/ada/ada.h
deleted file mode 100644
index b191694dcd..0000000000
--- a/packages/react-native-executorch/common/ada/ada.h
+++ /dev/null
@@ -1,10274 +0,0 @@
-/* auto-generated on 2025-01-30 14:25:38 -0500. Do not edit! */
-/* begin file include/ada.h */
-/**
- * @file ada.h
- * @brief Includes all definitions for Ada.
- */
-#ifndef ADA_H
-#define ADA_H
-
-/* begin file include/ada/ada_idna.h */
-/* auto-generated on 2024-12-18 09:44:34 -0500. Do not edit! */
-/* begin file include/idna.h */
-#ifndef ADA_IDNA_H
-#define ADA_IDNA_H
-
-/* begin file include/ada/idna/unicode_transcoding.h */
-#ifndef ADA_IDNA_UNICODE_TRANSCODING_H
-#define ADA_IDNA_UNICODE_TRANSCODING_H
-
-#include <string>
-#include <string_view>
-
-namespace ada::idna {
-
-size_t utf8_to_utf32(const char *buf, size_t len, char32_t *utf32_output);
-
-size_t utf8_length_from_utf32(const char32_t *buf, size_t len);
-
-size_t utf32_length_from_utf8(const char *buf, size_t len);
-
-size_t utf32_to_utf8(const char32_t *buf, size_t len, char *utf8_output);
-
-} // namespace ada::idna
-
-#endif // ADA_IDNA_UNICODE_TRANSCODING_H
-/* end file include/ada/idna/unicode_transcoding.h */
-/* begin file include/ada/idna/mapping.h */
-#ifndef ADA_IDNA_MAPPING_H
-#define ADA_IDNA_MAPPING_H
-
-#include <string>
-#include <string_view>
-
-namespace ada::idna {
-
-// If the input is ascii, then the mapping is just -> lower case.
-void ascii_map(char *input, size_t length);
-// check whether an ascii string needs mapping
-bool ascii_has_upper_case(char *input, size_t length);
-// Map the characters according to IDNA, returning the empty string on error.
-std::u32string map(std::u32string_view input);
-
-} // namespace ada::idna
-
-#endif
-/* end file include/ada/idna/mapping.h */
-/* begin file include/ada/idna/normalization.h */
-#ifndef ADA_IDNA_NORMALIZATION_H
-#define ADA_IDNA_NORMALIZATION_H
-
-#include <string>
-#include <string_view>
-
-namespace ada::idna {
-
-// Normalize the characters according to IDNA (Unicode Normalization Form C).
-void normalize(std::u32string &input);
-
-} // namespace ada::idna
-#endif
-/* end file include/ada/idna/normalization.h */
-/* begin file include/ada/idna/punycode.h */
-#ifndef ADA_IDNA_PUNYCODE_H
-#define ADA_IDNA_PUNYCODE_H
-
-#include <string>
-#include <string_view>
-
-namespace ada::idna {
-
-bool punycode_to_utf32(std::string_view input, std::u32string &out);
-bool verify_punycode(std::string_view input);
-bool utf32_to_punycode(std::u32string_view input, std::string &out);
-
-} // namespace ada::idna
-
-#endif // ADA_IDNA_PUNYCODE_H
-/* end file include/ada/idna/punycode.h */
-/* begin file include/ada/idna/validity.h */
-#ifndef ADA_IDNA_VALIDITY_H
-#define ADA_IDNA_VALIDITY_H
-
-#include <string>
-#include <string_view>
-
-namespace ada::idna {
-
-/**
- * @see https://www.unicode.org/reports/tr46/#Validity_Criteria
- */
-bool is_label_valid(std::u32string_view label);
-
-} // namespace ada::idna
-
-#endif // ADA_IDNA_VALIDITY_H
-/* end file include/ada/idna/validity.h */
-/* begin file include/ada/idna/to_ascii.h */
-#ifndef ADA_IDNA_TO_ASCII_H
-#define ADA_IDNA_TO_ASCII_H
-
-#include <string>
-#include <string_view>
-
-namespace ada::idna {
-
-// Converts a domain (e.g., www.google.com) possibly containing international
-// characters to an ascii domain (with punycode). It will not do percent
-// decoding: percent decoding should be done prior to calling this function. We
-// do not remove tabs and spaces, they should have been removed prior to calling
-// this function. We also do not trim control characters. We also assume that
-// the input is not empty. We return "" on error.
-//
-//
-// This function may accept or even produce invalid domains.
-std::string to_ascii(std::string_view ut8_string);
-
-// Returns true if the string contains a forbidden code point according to the
-// WHATGL URL specification:
-// https://url.spec.whatwg.org/#forbidden-domain-code-point
-bool contains_forbidden_domain_code_point(std::string_view ascii_string);
-
-bool constexpr is_ascii(std::u32string_view view);
-bool constexpr is_ascii(std::string_view view);
-
-} // namespace ada::idna
-
-#endif // ADA_IDNA_TO_ASCII_H
-/* end file include/ada/idna/to_ascii.h */
-/* begin file include/ada/idna/to_unicode.h */
-
-#ifndef ADA_IDNA_TO_UNICODE_H
-#define ADA_IDNA_TO_UNICODE_H
-
-#include <string_view>
-
-namespace ada::idna {
-
-std::string to_unicode(std::string_view input);
-
-} // namespace ada::idna
-
-#endif // ADA_IDNA_TO_UNICODE_H
-/* end file include/ada/idna/to_unicode.h */
-/* begin file include/ada/idna/identifier.h */
-#ifndef ADA_IDNA_IDENTIFIER_H
-#define ADA_IDNA_IDENTIFIER_H
-
-#include <string>
-#include <string_view>
-
-namespace ada::idna {
-
-// Access the first code point of the input string.
-// Verify if it is valid name code point given a Unicode code point and a
-// boolean first: If first is true return the result of checking if code point
-// is contained in the IdentifierStart set of code points. Otherwise return the
-// result of checking if code point is contained in the IdentifierPart set of
-// code points. Returns false if the input is empty or the code point is not
-// valid. There is minimal Unicode error handling: the input should be valid
-// UTF-8. https://urlpattern.spec.whatwg.org/#is-a-valid-name-code-point
-bool valid_name_code_point(char32_t input, bool first);
-
-} // namespace ada::idna
-
-#endif
-/* end file include/ada/idna/identifier.h */
-
-#endif
-/* end file include/idna.h */
-/* end file include/ada/ada_idna.h */
-/* begin file include/ada/character_sets.h */
-/**
- * @file character_sets.h
- * @brief Declaration of the character sets used by unicode functions.
- * @author Node.js
- * @see https://github.com/nodejs/node/blob/main/src/node_url_tables.cc
- */
-#ifndef ADA_CHARACTER_SETS_H
-#define ADA_CHARACTER_SETS_H
-
-/* begin file include/ada/common_defs.h */
-/**
- * @file common_defs.h
- * @brief Common definitions for cross-platform compiler support.
- */
-#ifndef ADA_COMMON_DEFS_H
-#define ADA_COMMON_DEFS_H
-
-// https://en.cppreference.com/w/cpp/feature_test#Library_features
-// detect C++20 features
-#include <version>
-
-#ifdef _MSC_VER
-#define ADA_VISUAL_STUDIO 1
-/**
- * We want to differentiate carefully between
- * clang under visual studio and regular visual
- * studio.
- */
-#ifdef __clang__
-// clang under visual studio
-#define ADA_CLANG_VISUAL_STUDIO 1
-#else
-// just regular visual studio (best guess)
-#define ADA_REGULAR_VISUAL_STUDIO 1
-#endif // __clang__
-#endif // _MSC_VER
-
-#if defined(__GNUC__)
-// Marks a block with a name so that MCA analysis can see it.
-#define ADA_BEGIN_DEBUG_BLOCK(name) __asm volatile("# LLVM-MCA-BEGIN " #name);
-#define ADA_END_DEBUG_BLOCK(name) __asm volatile("# LLVM-MCA-END " #name);
-#define ADA_DEBUG_BLOCK(name, block)                                           \
-  BEGIN_DEBUG_BLOCK(name);                                                     \
-  block;                                                                       \
-  END_DEBUG_BLOCK(name);
-#else
-#define ADA_BEGIN_DEBUG_BLOCK(name)
-#define ADA_END_DEBUG_BLOCK(name)
-#define ADA_DEBUG_BLOCK(name, block)
-#endif
-
-// Align to N-byte boundary
-#define ADA_ROUNDUP_N(a, n) (((a) + ((n) - 1)) & ~((n) - 1))
-#define ADA_ROUNDDOWN_N(a, n) ((a) & ~((n) - 1))
-
-#define ADA_ISALIGNED_N(ptr, n) (((uintptr_t)(ptr) & ((n) - 1)) == 0)
-
-#if defined(ADA_REGULAR_VISUAL_STUDIO)
-
-#define ada_really_inline __forceinline
-#define ada_never_inline __declspec(noinline)
-
-#define ada_unused
-#define ada_warn_unused
-
-#define ADA_PUSH_DISABLE_WARNINGS __pragma(warning(push))
-#define ADA_PUSH_DISABLE_ALL_WARNINGS __pragma(warning(push, 0))
-#define ADA_DISABLE_VS_WARNING(WARNING_NUMBER)                                 \
-  __pragma(warning(disable : WARNING_NUMBER))
-// Get rid of Intellisense-only warnings (Code Analysis)
-// Though __has_include is C++17, it is supported in Visual Studio 2017 or
-// better (_MSC_VER>=1910).
-#ifdef __has_include
-#if __has_include(<CppCoreCheck\Warnings.h>)
-#include <CppCoreCheck\Warnings.h>
-#define ADA_DISABLE_UNDESIRED_WARNINGS                                         \
-  ADA_DISABLE_VS_WARNING(ALL_CPPCORECHECK_WARNINGS)
-#endif
-#endif
-
-#ifndef ADA_DISABLE_UNDESIRED_WARNINGS
-#define ADA_DISABLE_UNDESIRED_WARNINGS
-#endif
-
-#define ADA_DISABLE_DEPRECATED_WARNING ADA_DISABLE_VS_WARNING(4996)
-#define ADA_DISABLE_STRICT_OVERFLOW_WARNING
-#define ADA_POP_DISABLE_WARNINGS __pragma(warning(pop))
-
-#else // ADA_REGULAR_VISUAL_STUDIO
-
-#define ada_really_inline inline __attribute__((always_inline))
-#define ada_never_inline inline __attribute__((noinline))
-
-#define ada_unused __attribute__((unused))
-#define ada_warn_unused __attribute__((warn_unused_result))
-
-#define ADA_PUSH_DISABLE_WARNINGS _Pragma("GCC diagnostic push")
-// gcc doesn't seem to disable all warnings with all and extra, add warnings
-// here as necessary
-#define ADA_PUSH_DISABLE_ALL_WARNINGS                                          \
-  ADA_PUSH_DISABLE_WARNINGS                                                    \
-  ADA_DISABLE_GCC_WARNING("-Weffc++")                                          \
-  ADA_DISABLE_GCC_WARNING("-Wall")                                             \
-  ADA_DISABLE_GCC_WARNING("-Wconversion")                                      \
-  ADA_DISABLE_GCC_WARNING("-Wextra")                                           \
-  ADA_DISABLE_GCC_WARNING("-Wattributes")                                      \
-  ADA_DISABLE_GCC_WARNING("-Wimplicit-fallthrough")                            \
-  ADA_DISABLE_GCC_WARNING("-Wnon-virtual-dtor")                                \
-  ADA_DISABLE_GCC_WARNING("-Wreturn-type")                                     \
-  ADA_DISABLE_GCC_WARNING("-Wshadow")                                          \
-  ADA_DISABLE_GCC_WARNING("-Wunused-parameter")                                \
-  ADA_DISABLE_GCC_WARNING("-Wunused-variable")
-#define ADA_PRAGMA(P) _Pragma(#P)
-#define ADA_DISABLE_GCC_WARNING(WARNING)                                       \
-  ADA_PRAGMA(GCC diagnostic ignored WARNING)
-#if defined(ADA_CLANG_VISUAL_STUDIO)
-#define ADA_DISABLE_UNDESIRED_WARNINGS                                         \
-  ADA_DISABLE_GCC_WARNING("-Wmicrosoft-include")
-#else
-#define ADA_DISABLE_UNDESIRED_WARNINGS
-#endif
-#define ADA_DISABLE_DEPRECATED_WARNING                                         \
-  ADA_DISABLE_GCC_WARNING("-Wdeprecated-declarations")
-#define ADA_DISABLE_STRICT_OVERFLOW_WARNING                                    \
-  ADA_DISABLE_GCC_WARNING("-Wstrict-overflow")
-#define ADA_POP_DISABLE_WARNINGS _Pragma("GCC diagnostic pop")
-
-#endif // MSC_VER
-
-#if defined(ADA_VISUAL_STUDIO)
-/**
- * It does not matter here whether you are using
- * the regular visual studio or clang under visual
- * studio.
- */
-#if ADA_USING_LIBRARY
-#define ADA_DLLIMPORTEXPORT __declspec(dllimport)
-#else
-#define ADA_DLLIMPORTEXPORT __declspec(dllexport)
-#endif
-#else
-#define ADA_DLLIMPORTEXPORT
-#endif
-
-/// If EXPR is an error, returns it.
-#define ADA_TRY(EXPR)                                                          \
-  {                                                                            \
-    auto _err = (EXPR);                                                        \
-    if (_err) {                                                                \
-      return _err;                                                             \
-    }                                                                          \
-  }
-
-// __has_cpp_attribute is part of C++20
-#if !defined(__has_cpp_attribute)
-#define __has_cpp_attribute(x) 0
-#endif
-
-#if __has_cpp_attribute(gnu::noinline)
-#define ADA_ATTRIBUTE_NOINLINE [[gnu::noinline]]
-#else
-#define ADA_ATTRIBUTE_NOINLINE
-#endif
-
-namespace ada {
-[[noreturn]] inline void unreachable() {
-#ifdef __GNUC__
-  __builtin_unreachable();
-#elif defined(_MSC_VER)
-  __assume(false);
-#else
-#endif
-}
-} // namespace ada
-
-// Unless the programmer has already set ADA_DEVELOPMENT_CHECKS,
-// we want to set it under debug builds. We detect a debug build
-// under Visual Studio when the _DEBUG macro is set. Under the other
-// compilers, we use the fact that they define __OPTIMIZE__ whenever
-// they allow optimizations.
-// It is possible that this could miss some cases where ADA_DEVELOPMENT_CHECKS
-// is helpful, but the programmer can set the macro ADA_DEVELOPMENT_CHECKS.
-// It could also wrongly set ADA_DEVELOPMENT_CHECKS (e.g., if the programmer
-// sets _DEBUG in a release build under Visual Studio, or if some compiler fails
-// to set the __OPTIMIZE__ macro).
-#if !defined(ADA_DEVELOPMENT_CHECKS) && !defined(NDEBUG)
-#ifdef _MSC_VER
-// Visual Studio seems to set _DEBUG for debug builds.
-#ifdef _DEBUG
-#define ADA_DEVELOPMENT_CHECKS 1
-#endif // _DEBUG
-#else  // _MSC_VER
-// All other compilers appear to set __OPTIMIZE__ to a positive integer
-// when the compiler is optimizing.
-#ifndef __OPTIMIZE__
-#define ADA_DEVELOPMENT_CHECKS 1
-#endif // __OPTIMIZE__
-#endif // _MSC_VER
-#endif // ADA_DEVELOPMENT_CHECKS
-
-#define ADA_STR(x) #x
-
-#if ADA_DEVELOPMENT_CHECKS
-#define ADA_REQUIRE(EXPR)                                                      \
-  {                                                                            \
-    if (!(EXPR) { abort(); })                                                  \
-  }
-
-#define ADA_FAIL(MESSAGE)                                                      \
-  do {                                                                         \
-    std::cerr << "FAIL: " << (MESSAGE) << std::endl;                           \
-    abort();                                                                   \
-  } while (0);
-#define ADA_ASSERT_EQUAL(LHS, RHS, MESSAGE)                                    \
-  do {                                                                         \
-    if (LHS != RHS) {                                                          \
-      std::cerr << "Mismatch: '" << LHS << "' - '" << RHS << "'" << std::endl; \
-      ADA_FAIL(MESSAGE);                                                       \
-    }                                                                          \
-  } while (0);
-#define ADA_ASSERT_TRUE(COND)                                                  \
-  do {                                                                         \
-    if (!(COND)) {                                                             \
-      std::cerr << "Assert at line " << __LINE__ << " of file " << __FILE__    \
-                << std::endl;                                                  \
-      ADA_FAIL(ADA_STR(COND));                                                 \
-    }                                                                          \
-  } while (0);
-#else
-#define ADA_FAIL(MESSAGE)
-#define ADA_ASSERT_EQUAL(LHS, RHS, MESSAGE)
-#define ADA_ASSERT_TRUE(COND)
-#endif
-
-#ifdef ADA_VISUAL_STUDIO
-#define ADA_ASSUME(COND) __assume(COND)
-#else
-#define ADA_ASSUME(COND)                                                       \
-  do {                                                                         \
-    if (!(COND)) {                                                             \
-      __builtin_unreachable();                                                 \
-    }                                                                          \
-  } while (0)
-#endif
-
-#if defined(__SSE2__) || defined(__x86_64__) || defined(__x86_64) ||           \
-    (defined(_M_AMD64) || defined(_M_X64) ||                                   \
-     (defined(_M_IX86_FP) && _M_IX86_FP == 2))
-#define ADA_SSE2 1
-#endif
-
-#if defined(__aarch64__) || defined(_M_ARM64)
-#define ADA_NEON 1
-#endif
-
-#ifndef __has_cpp_attribute
-#define ada_lifetime_bound
-#elif __has_cpp_attribute(msvc::lifetimebound)
-#define ada_lifetime_bound [[msvc::lifetimebound]]
-#elif __has_cpp_attribute(clang::lifetimebound)
-#define ada_lifetime_bound [[clang::lifetimebound]]
-#elif __has_cpp_attribute(lifetimebound)
-#define ada_lifetime_bound [[lifetimebound]]
-#else
-#define ada_lifetime_bound
-#endif
-
-#ifdef __cpp_lib_format
-#if __cpp_lib_format >= 202110L
-#include <format>
-#define ADA_HAS_FORMAT 1
-#endif
-#endif
-
-#endif // ADA_COMMON_DEFS_H
-/* end file include/ada/common_defs.h */
-#include <cstdint>
-
-/**
- * These functions are not part of our public API and may
- * change at any time.
- * @private
- * @namespace ada::character_sets
- * @brief Includes the definitions for unicode character sets.
- */
-namespace ada::character_sets {
-ada_really_inline constexpr bool bit_at(const uint8_t a[], uint8_t i);
-} // namespace ada::character_sets
-
-#endif // ADA_CHARACTER_SETS_H
-/* end file include/ada/character_sets.h */
-/* begin file include/ada/character_sets-inl.h */
-/**
- * @file character_sets-inl.h
- * @brief Definitions of the character sets used by unicode functions.
- * @author Node.js
- * @see https://github.com/nodejs/node/blob/main/src/node_url_tables.cc
- */
-#ifndef ADA_CHARACTER_SETS_INL_H
-#define ADA_CHARACTER_SETS_INL_H
-
-/**
- * These functions are not part of our public API and may
- * change at any time.
- * @private
- */
-namespace ada::character_sets {
-
-constexpr char hex[1024] = "%00\0%01\0%02\0%03\0%04\0%05\0%06\0%07\0"
-                           "%08\0%09\0%0A\0%0B\0%0C\0%0D\0%0E\0%0F\0"
-                           "%10\0%11\0%12\0%13\0%14\0%15\0%16\0%17\0"
-                           "%18\0%19\0%1A\0%1B\0%1C\0%1D\0%1E\0%1F\0"
-                           "%20\0%21\0%22\0%23\0%24\0%25\0%26\0%27\0"
-                           "%28\0%29\0%2A\0%2B\0%2C\0%2D\0%2E\0%2F\0"
-                           "%30\0%31\0%32\0%33\0%34\0%35\0%36\0%37\0"
-                           "%38\0%39\0%3A\0%3B\0%3C\0%3D\0%3E\0%3F\0"
-                           "%40\0%41\0%42\0%43\0%44\0%45\0%46\0%47\0"
-                           "%48\0%49\0%4A\0%4B\0%4C\0%4D\0%4E\0%4F\0"
-                           "%50\0%51\0%52\0%53\0%54\0%55\0%56\0%57\0"
-                           "%58\0%59\0%5A\0%5B\0%5C\0%5D\0%5E\0%5F\0"
-                           "%60\0%61\0%62\0%63\0%64\0%65\0%66\0%67\0"
-                           "%68\0%69\0%6A\0%6B\0%6C\0%6D\0%6E\0%6F\0"
-                           "%70\0%71\0%72\0%73\0%74\0%75\0%76\0%77\0"
-                           "%78\0%79\0%7A\0%7B\0%7C\0%7D\0%7E\0%7F\0"
-                           "%80\0%81\0%82\0%83\0%84\0%85\0%86\0%87\0"
-                           "%88\0%89\0%8A\0%8B\0%8C\0%8D\0%8E\0%8F\0"
-                           "%90\0%91\0%92\0%93\0%94\0%95\0%96\0%97\0"
-                           "%98\0%99\0%9A\0%9B\0%9C\0%9D\0%9E\0%9F\0"
-                           "%A0\0%A1\0%A2\0%A3\0%A4\0%A5\0%A6\0%A7\0"
-                           "%A8\0%A9\0%AA\0%AB\0%AC\0%AD\0%AE\0%AF\0"
-                           "%B0\0%B1\0%B2\0%B3\0%B4\0%B5\0%B6\0%B7\0"
-                           "%B8\0%B9\0%BA\0%BB\0%BC\0%BD\0%BE\0%BF\0"
-                           "%C0\0%C1\0%C2\0%C3\0%C4\0%C5\0%C6\0%C7\0"
-                           "%C8\0%C9\0%CA\0%CB\0%CC\0%CD\0%CE\0%CF\0"
-                           "%D0\0%D1\0%D2\0%D3\0%D4\0%D5\0%D6\0%D7\0"
-                           "%D8\0%D9\0%DA\0%DB\0%DC\0%DD\0%DE\0%DF\0"
-                           "%E0\0%E1\0%E2\0%E3\0%E4\0%E5\0%E6\0%E7\0"
-                           "%E8\0%E9\0%EA\0%EB\0%EC\0%ED\0%EE\0%EF\0"
-                           "%F0\0%F1\0%F2\0%F3\0%F4\0%F5\0%F6\0%F7\0"
-                           "%F8\0%F9\0%FA\0%FB\0%FC\0%FD\0%FE\0%FF";
-
-constexpr uint8_t C0_CONTROL_PERCENT_ENCODE[32] = {
-    // 00     01     02     03     04     05     06     07
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 08     09     0A     0B     0C     0D     0E     0F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 10     11     12     13     14     15     16     17
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 18     19     1A     1B     1C     1D     1E     1F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 20     21     22     23     24     25     26     27
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 28     29     2A     2B     2C     2D     2E     2F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 30     31     32     33     34     35     36     37
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 38     39     3A     3B     3C     3D     3E     3F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 40     41     42     43     44     45     46     47
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 48     49     4A     4B     4C     4D     4E     4F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 50     51     52     53     54     55     56     57
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 58     59     5A     5B     5C     5D     5E     5F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 60     61     62     63     64     65     66     67
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 68     69     6A     6B     6C     6D     6E     6F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 70     71     72     73     74     75     76     77
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 78     79     7A     7B     7C     7D     7E     7F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x80,
-    // 80     81     82     83     84     85     86     87
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 88     89     8A     8B     8C     8D     8E     8F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 90     91     92     93     94     95     96     97
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 98     99     9A     9B     9C     9D     9E     9F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // A0     A1     A2     A3     A4     A5     A6     A7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // A8     A9     AA     AB     AC     AD     AE     AF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // B0     B1     B2     B3     B4     B5     B6     B7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // B8     B9     BA     BB     BC     BD     BE     BF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // C0     C1     C2     C3     C4     C5     C6     C7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // C8     C9     CA     CB     CC     CD     CE     CF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // D0     D1     D2     D3     D4     D5     D6     D7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // D8     D9     DA     DB     DC     DD     DE     DF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // E0     E1     E2     E3     E4     E5     E6     E7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // E8     E9     EA     EB     EC     ED     EE     EF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // F0     F1     F2     F3     F4     F5     F6     F7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // F8     F9     FA     FB     FC     FD     FE     FF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80};
-
-constexpr uint8_t SPECIAL_QUERY_PERCENT_ENCODE[32] = {
-    // 00     01     02     03     04     05     06     07
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 08     09     0A     0B     0C     0D     0E     0F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 10     11     12     13     14     15     16     17
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 18     19     1A     1B     1C     1D     1E     1F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 20     21     22     23     24     25     26     27
-    0x01 | 0x00 | 0x04 | 0x08 | 0x00 | 0x00 | 0x00 | 0x80,
-    // 28     29     2A     2B     2C     2D     2E     2F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 30     31     32     33     34     35     36     37
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 38     39     3A     3B     3C     3D     3E     3F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x10 | 0x00 | 0x40 | 0x00,
-    // 40     41     42     43     44     45     46     47
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 48     49     4A     4B     4C     4D     4E     4F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 50     51     52     53     54     55     56     57
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 58     59     5A     5B     5C     5D     5E     5F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 60     61     62     63     64     65     66     67
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 68     69     6A     6B     6C     6D     6E     6F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 70     71     72     73     74     75     76     77
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 78     79     7A     7B     7C     7D     7E     7F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x80,
-    // 80     81     82     83     84     85     86     87
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 88     89     8A     8B     8C     8D     8E     8F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 90     91     92     93     94     95     96     97
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 98     99     9A     9B     9C     9D     9E     9F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // A0     A1     A2     A3     A4     A5     A6     A7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // A8     A9     AA     AB     AC     AD     AE     AF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // B0     B1     B2     B3     B4     B5     B6     B7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // B8     B9     BA     BB     BC     BD     BE     BF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // C0     C1     C2     C3     C4     C5     C6     C7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // C8     C9     CA     CB     CC     CD     CE     CF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // D0     D1     D2     D3     D4     D5     D6     D7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // D8     D9     DA     DB     DC     DD     DE     DF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // E0     E1     E2     E3     E4     E5     E6     E7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // E8     E9     EA     EB     EC     ED     EE     EF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // F0     F1     F2     F3     F4     F5     F6     F7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // F8     F9     FA     FB     FC     FD     FE     FF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80};
-
-constexpr uint8_t QUERY_PERCENT_ENCODE[32] = {
-    // 00     01     02     03     04     05     06     07
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 08     09     0A     0B     0C     0D     0E     0F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 10     11     12     13     14     15     16     17
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 18     19     1A     1B     1C     1D     1E     1F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 20     21     22     23     24     25     26     27
-    0x01 | 0x00 | 0x04 | 0x08 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 28     29     2A     2B     2C     2D     2E     2F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 30     31     32     33     34     35     36     37
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 38     39     3A     3B     3C     3D     3E     3F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x10 | 0x00 | 0x40 | 0x00,
-    // 40     41     42     43     44     45     46     47
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 48     49     4A     4B     4C     4D     4E     4F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 50     51     52     53     54     55     56     57
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 58     59     5A     5B     5C     5D     5E     5F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 60     61     62     63     64     65     66     67
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 68     69     6A     6B     6C     6D     6E     6F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 70     71     72     73     74     75     76     77
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 78     79     7A     7B     7C     7D     7E     7F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x80,
-    // 80     81     82     83     84     85     86     87
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 88     89     8A     8B     8C     8D     8E     8F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 90     91     92     93     94     95     96     97
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 98     99     9A     9B     9C     9D     9E     9F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // A0     A1     A2     A3     A4     A5     A6     A7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // A8     A9     AA     AB     AC     AD     AE     AF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // B0     B1     B2     B3     B4     B5     B6     B7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // B8     B9     BA     BB     BC     BD     BE     BF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // C0     C1     C2     C3     C4     C5     C6     C7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // C8     C9     CA     CB     CC     CD     CE     CF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // D0     D1     D2     D3     D4     D5     D6     D7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // D8     D9     DA     DB     DC     DD     DE     DF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // E0     E1     E2     E3     E4     E5     E6     E7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // E8     E9     EA     EB     EC     ED     EE     EF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // F0     F1     F2     F3     F4     F5     F6     F7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // F8     F9     FA     FB     FC     FD     FE     FF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80};
-
-constexpr uint8_t FRAGMENT_PERCENT_ENCODE[32] = {
-    // 00     01     02     03     04     05     06     07
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 08     09     0A     0B     0C     0D     0E     0F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 10     11     12     13     14     15     16     17
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 18     19     1A     1B     1C     1D     1E     1F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 20     21     22     23     24     25     26     27
-    0x01 | 0x00 | 0x04 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 28     29     2A     2B     2C     2D     2E     2F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 30     31     32     33     34     35     36     37
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 38     39     3A     3B     3C     3D     3E     3F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x10 | 0x00 | 0x40 | 0x00,
-    // 40     41     42     43     44     45     46     47
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 48     49     4A     4B     4C     4D     4E     4F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 50     51     52     53     54     55     56     57
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 58     59     5A     5B     5C     5D     5E     5F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 60     61     62     63     64     65     66     67
-    0x01 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 68     69     6A     6B     6C     6D     6E     6F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 70     71     72     73     74     75     76     77
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 78     79     7A     7B     7C     7D     7E     7F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x80,
-    // 80     81     82     83     84     85     86     87
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 88     89     8A     8B     8C     8D     8E     8F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 90     91     92     93     94     95     96     97
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 98     99     9A     9B     9C     9D     9E     9F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // A0     A1     A2     A3     A4     A5     A6     A7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // A8     A9     AA     AB     AC     AD     AE     AF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // B0     B1     B2     B3     B4     B5     B6     B7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // B8     B9     BA     BB     BC     BD     BE     BF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // C0     C1     C2     C3     C4     C5     C6     C7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // C8     C9     CA     CB     CC     CD     CE     CF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // D0     D1     D2     D3     D4     D5     D6     D7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // D8     D9     DA     DB     DC     DD     DE     DF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // E0     E1     E2     E3     E4     E5     E6     E7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // E8     E9     EA     EB     EC     ED     EE     EF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // F0     F1     F2     F3     F4     F5     F6     F7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // F8     F9     FA     FB     FC     FD     FE     FF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80};
-
-constexpr uint8_t USERINFO_PERCENT_ENCODE[32] = {
-    // 00     01     02     03     04     05     06     07
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 08     09     0A     0B     0C     0D     0E     0F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 10     11     12     13     14     15     16     17
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 18     19     1A     1B     1C     1D     1E     1F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 20     21     22     23     24     25     26     27
-    0x01 | 0x00 | 0x04 | 0x08 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 28     29     2A     2B     2C     2D     2E     2F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x80,
-    // 30     31     32     33     34     35     36     37
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 38     39     3A     3B     3C     3D     3E     3F
-    0x00 | 0x00 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 40     41     42     43     44     45     46     47
-    0x01 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 48     49     4A     4B     4C     4D     4E     4F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 50     51     52     53     54     55     56     57
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 58     59     5A     5B     5C     5D     5E     5F
-    0x00 | 0x00 | 0x00 | 0x08 | 0x10 | 0x20 | 0x40 | 0x00,
-    // 60     61     62     63     64     65     66     67
-    0x01 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 68     69     6A     6B     6C     6D     6E     6F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 70     71     72     73     74     75     76     77
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 78     79     7A     7B     7C     7D     7E     7F
-    0x00 | 0x00 | 0x00 | 0x08 | 0x10 | 0x20 | 0x00 | 0x80,
-    // 80     81     82     83     84     85     86     87
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 88     89     8A     8B     8C     8D     8E     8F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 90     91     92     93     94     95     96     97
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 98     99     9A     9B     9C     9D     9E     9F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // A0     A1     A2     A3     A4     A5     A6     A7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // A8     A9     AA     AB     AC     AD     AE     AF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // B0     B1     B2     B3     B4     B5     B6     B7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // B8     B9     BA     BB     BC     BD     BE     BF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // C0     C1     C2     C3     C4     C5     C6     C7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // C8     C9     CA     CB     CC     CD     CE     CF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // D0     D1     D2     D3     D4     D5     D6     D7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // D8     D9     DA     DB     DC     DD     DE     DF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // E0     E1     E2     E3     E4     E5     E6     E7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // E8     E9     EA     EB     EC     ED     EE     EF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // F0     F1     F2     F3     F4     F5     F6     F7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // F8     F9     FA     FB     FC     FD     FE     FF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80};
-
-constexpr uint8_t PATH_PERCENT_ENCODE[32] = {
-    // 00     01     02     03     04     05     06     07
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 08     09     0A     0B     0C     0D     0E     0F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 10     11     12     13     14     15     16     17
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 18     19     1A     1B     1C     1D     1E     1F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 20     21     22     23     24     25     26     27
-    0x01 | 0x00 | 0x04 | 0x08 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 28     29     2A     2B     2C     2D     2E     2F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 30     31     32     33     34     35     36     37
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 38     39     3A     3B     3C     3D     3E     3F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x10 | 0x00 | 0x40 | 0x80,
-    // 40     41     42     43     44     45     46     47
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 48     49     4A     4B     4C     4D     4E     4F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 50     51     52     53     54     55     56     57
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 58     59     5A     5B     5C     5D     5E     5F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 60     61     62     63     64     65     66     67
-    0x01 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 68     69     6A     6B     6C     6D     6E     6F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 70     71     72     73     74     75     76     77
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 78     79     7A     7B     7C     7D     7E     7F
-    0x00 | 0x00 | 0x00 | 0x08 | 0x00 | 0x20 | 0x00 | 0x80,
-    // 80     81     82     83     84     85     86     87
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 88     89     8A     8B     8C     8D     8E     8F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 90     91     92     93     94     95     96     97
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 98     99     9A     9B     9C     9D     9E     9F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // A0     A1     A2     A3     A4     A5     A6     A7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // A8     A9     AA     AB     AC     AD     AE     AF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // B0     B1     B2     B3     B4     B5     B6     B7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // B8     B9     BA     BB     BC     BD     BE     BF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // C0     C1     C2     C3     C4     C5     C6     C7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // C8     C9     CA     CB     CC     CD     CE     CF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // D0     D1     D2     D3     D4     D5     D6     D7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // D8     D9     DA     DB     DC     DD     DE     DF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // E0     E1     E2     E3     E4     E5     E6     E7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // E8     E9     EA     EB     EC     ED     EE     EF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // F0     F1     F2     F3     F4     F5     F6     F7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // F8     F9     FA     FB     FC     FD     FE     FF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80};
-
-constexpr uint8_t WWW_FORM_URLENCODED_PERCENT_ENCODE[32] = {
-    // 00     01     02     03     04     05     06     07
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 08     09     0A     0B     0C     0D     0E     0F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 10     11     12     13     14     15     16     17
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 18     19     1A     1B     1C     1D     1E     1F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 20     21     22     23     24     25     26     27
-    0x00 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 28     29     2A     2B     2C     2D     2E     2F
-    0x01 | 0x02 | 0x00 | 0x08 | 0x10 | 0x00 | 0x00 | 0x80,
-    // 30     31     32     33     34     35     36     37
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 38     39     3A     3B     3C     3D     3E     3F
-    0x00 | 0x00 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 40     41     42     43     44     45     46     47
-    0x01 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 48     49     4A     4B     4C     4D     4E     4F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 50     51     52     53     54     55     56     57
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 58     59     5A     5B     5C     5D     5E     5F
-    0x00 | 0x00 | 0x00 | 0x08 | 0x00 | 0x20 | 0x40 | 0x00,
-    // 60     61     62     63     64     65     66     67
-    0x01 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 68     69     6A     6B     6C     6D     6E     6F
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 70     71     72     73     74     75     76     77
-    0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00 | 0x00,
-    // 78     79     7A     7B     7C     7D     7E     7F
-    0x00 | 0x00 | 0x00 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 80     81     82     83     84     85     86     87
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 88     89     8A     8B     8C     8D     8E     8F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 90     91     92     93     94     95     96     97
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // 98     99     9A     9B     9C     9D     9E     9F
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // A0     A1     A2     A3     A4     A5     A6     A7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // A8     A9     AA     AB     AC     AD     AE     AF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // B0     B1     B2     B3     B4     B5     B6     B7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // B8     B9     BA     BB     BC     BD     BE     BF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // C0     C1     C2     C3     C4     C5     C6     C7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // C8     C9     CA     CB     CC     CD     CE     CF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // D0     D1     D2     D3     D4     D5     D6     D7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // D8     D9     DA     DB     DC     DD     DE     DF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // E0     E1     E2     E3     E4     E5     E6     E7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // E8     E9     EA     EB     EC     ED     EE     EF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // F0     F1     F2     F3     F4     F5     F6     F7
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80,
-    // F8     F9     FA     FB     FC     FD     FE     FF
-    0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40 | 0x80};
-
-ada_really_inline constexpr bool bit_at(const uint8_t a[], const uint8_t i) {
-  return !!(a[i >> 3] & (1 << (i & 7)));
-}
-
-} // namespace ada::character_sets
-
-#endif // ADA_CHARACTER_SETS_INL_H
-/* end file include/ada/character_sets-inl.h */
-/* begin file include/ada/checkers-inl.h */
-/**
- * @file checkers-inl.h
- * @brief Definitions for URL specific checkers used within Ada.
- */
-#ifndef ADA_CHECKERS_INL_H
-#define ADA_CHECKERS_INL_H
-
-#include <bit>
-#include <string_view>
-
-namespace ada::checkers {
-
-constexpr bool has_hex_prefix_unsafe(std::string_view input) {
-  // This is actually efficient code, see has_hex_prefix for the assembly.
-  constexpr bool is_little_endian = std::endian::native == std::endian::little;
-  constexpr uint16_t word0x = 0x7830;
-  uint16_t two_first_bytes =
-      static_cast<uint16_t>(input[0]) |
-      static_cast<uint16_t>((static_cast<uint16_t>(input[1]) << 8));
-  if constexpr (is_little_endian) {
-    two_first_bytes |= 0x2000;
-  } else {
-    two_first_bytes |= 0x020;
-  }
-  return two_first_bytes == word0x;
-}
-
-constexpr bool has_hex_prefix(std::string_view input) {
-  return input.size() >= 2 && has_hex_prefix_unsafe(input);
-}
-
-constexpr bool is_digit(char x) noexcept { return (x >= '0') & (x <= '9'); }
-
-constexpr char to_lower(char x) noexcept { return (x | 0x20); }
-
-constexpr bool is_alpha(char x) noexcept {
-  return (to_lower(x) >= 'a') && (to_lower(x) <= 'z');
-}
-
-constexpr bool is_windows_drive_letter(std::string_view input) noexcept {
-  return input.size() >= 2 &&
-         (is_alpha(input[0]) && ((input[1] == ':') || (input[1] == '|'))) &&
-         ((input.size() == 2) || (input[2] == '/' || input[2] == '\\' ||
-                                  input[2] == '?' || input[2] == '#'));
-}
-
-constexpr bool
-is_normalized_windows_drive_letter(std::string_view input) noexcept {
-  return input.size() >= 2 && (is_alpha(input[0]) && (input[1] == ':'));
-}
-
-} // namespace ada::checkers
-
-#endif // ADA_CHECKERS_INL_H
-/* end file include/ada/checkers-inl.h */
-/* begin file include/ada/log.h */
-/**
- * @file log.h
- * @brief Includes the definitions for logging.
- * @private Excluded from docs through the doxygen file.
- */
-#ifndef ADA_LOG_H
-#define ADA_LOG_H
-
-// To enable logging, set ADA_LOGGING to 1:
-#ifndef ADA_LOGGING
-#define ADA_LOGGING 0
-#endif
-
-#if ADA_LOGGING
-#include <iostream>
-#endif // ADA_LOGGING
-
-namespace ada {
-
-/**
- * Log a message. If you want to have no overhead when logging is disabled, use
- * the ada_log macro.
- * @private
- */
-template <typename... Args>
-constexpr ada_really_inline void log([[maybe_unused]] Args... args) {
-#if ADA_LOGGING
-  ((std::cout << "ADA_LOG: ") << ... << args) << std::endl;
-#endif // ADA_LOGGING
-}
-} // namespace ada
-
-#if ADA_LOGGING
-#ifndef ada_log
-#define ada_log(...)                                                           \
-  do {                                                                         \
-    ada::log(__VA_ARGS__);                                                     \
-  } while (0)
-#endif // ada_log
-#else
-#define ada_log(...)
-#endif // ADA_LOGGING
-
-#endif // ADA_LOG_H
-/* end file include/ada/log.h */
-/* begin file include/ada/encoding_type.h */
-/**
- * @file encoding_type.h
- * @brief Definition for supported encoding types.
- */
-#ifndef ADA_ENCODING_TYPE_H
-#define ADA_ENCODING_TYPE_H
-
-#include <string>
-
-namespace ada {
-
-/**
- * This specification defines three encodings with the same names as encoding
- * schemes defined in the Unicode standard: UTF-8, UTF-16LE, and UTF-16BE.
- *
- * @see https://encoding.spec.whatwg.org/#encodings
- */
-enum class encoding_type {
-  UTF8,
-  UTF_16LE,
-  UTF_16BE,
-};
-
-/**
- * Convert a encoding_type to string.
- */
-ada_warn_unused std::string to_string(encoding_type type);
-
-} // namespace ada
-
-#endif // ADA_ENCODING_TYPE_H
-/* end file include/ada/encoding_type.h */
-/* begin file include/ada/helpers.h */
-/**
- * @file helpers.h
- * @brief Definitions for helper functions used within Ada.
- */
-#ifndef ADA_HELPERS_H
-#define ADA_HELPERS_H
-
-/* begin file include/ada/url_base.h */
-/**
- * @file url_base.h
- * @brief Declaration for the basic URL definitions
- */
-#ifndef ADA_URL_BASE_H
-#define ADA_URL_BASE_H
-
-/* begin file include/ada/scheme.h */
-/**
- * @file scheme.h
- * @brief Declarations for the URL scheme.
- */
-#ifndef ADA_SCHEME_H
-#define ADA_SCHEME_H
-
-#include <string>
-
-/**
- * @namespace ada::scheme
- * @brief Includes the scheme declarations
- */
-namespace ada::scheme {
-
-/**
- * Type of the scheme as an enum.
- * Using strings to represent a scheme type is not ideal because
- * checking for types involves string comparisons. It is faster to use
- * a simple integer.
- * In C++11, we are allowed to specify the underlying type of the enum.
- * We pick an 8-bit integer (which allows up to 256 types). Specifying the
- * type of the enum may help integration with other systems if the type
- * variable is exposed (since its value will not depend on the compiler).
- */
-enum type : uint8_t {
-  HTTP = 0,
-  NOT_SPECIAL = 1,
-  HTTPS = 2,
-  WS = 3,
-  FTP = 4,
-  WSS = 5,
-  FILE = 6
-};
-
-/**
- * A special scheme is an ASCII string that is listed in the first column of the
- * following table. The default port for a special scheme is listed in the
- * second column on the same row. The default port for any other ASCII string is
- * null.
- *
- * @see https://url.spec.whatwg.org/#url-miscellaneous
- * @param scheme
- * @return If scheme is a special scheme
- */
-ada_really_inline constexpr bool is_special(std::string_view scheme);
-
-/**
- * A special scheme is an ASCII string that is listed in the first column of the
- * following table. The default port for a special scheme is listed in the
- * second column on the same row. The default port for any other ASCII string is
- * null.
- *
- * @see https://url.spec.whatwg.org/#url-miscellaneous
- * @param scheme
- * @return The special port
- */
-constexpr uint16_t get_special_port(std::string_view scheme) noexcept;
-
-/**
- * Returns the port number of a special scheme.
- * @see https://url.spec.whatwg.org/#special-scheme
- */
-constexpr uint16_t get_special_port(ada::scheme::type type) noexcept;
-/**
- * Returns the scheme of an input, or NOT_SPECIAL if it's not a special scheme
- * defined by the spec.
- */
-constexpr ada::scheme::type get_scheme_type(std::string_view scheme) noexcept;
-
-} // namespace ada::scheme
-
-#endif // ADA_SCHEME_H
-/* end file include/ada/scheme.h */
-
-#include <string_view>
-
-namespace ada {
-
-/**
- * Type of URL host as an enum.
- */
-enum url_host_type : uint8_t {
-  /**
-   * Represents common URLs such as "https://www.google.com"
-   */
-  DEFAULT = 0,
-  /**
-   * Represents ipv4 addresses such as "http://127.0.0.1"
-   */
-  IPV4 = 1,
-  /**
-   * Represents ipv6 addresses such as
-   * "http://[2001:db8:3333:4444:5555:6666:7777:8888]"
-   */
-  IPV6 = 2,
-};
-
-/**
- * @brief Base class of URL implementations
- *
- * @details A url_base contains a few attributes: is_valid, has_opaque_path and
- * type. All non-trivial implementation details are in derived classes such as
- * ada::url and ada::url_aggregator.
- *
- * It is an abstract class that cannot be instantiated directly.
- */
-struct url_base {
-  virtual ~url_base() = default;
-
-  /**
-   * Used for returning the validity from the result of the URL parser.
-   */
-  bool is_valid{true};
-
-  /**
-   * A URL has an opaque path if its path is a string.
-   */
-  bool has_opaque_path{false};
-
-  /**
-   * URL hosts type
-   */
-  url_host_type host_type = url_host_type::DEFAULT;
-
-  /**
-   * @private
-   */
-  ada::scheme::type type{ada::scheme::type::NOT_SPECIAL};
-
-  /**
-   * A URL is special if its scheme is a special scheme. A URL is not special if
-   * its scheme is not a special scheme.
-   */
-  [[nodiscard]] ada_really_inline constexpr bool is_special() const noexcept;
-
-  /**
-   * The origin getter steps are to return the serialization of this's URL's
-   * origin. [HTML]
-   * @return a newly allocated string.
-   * @see https://url.spec.whatwg.org/#concept-url-origin
-   */
-  [[nodiscard]] virtual std::string get_origin() const noexcept = 0;
-
-  /**
-   * Returns true if this URL has a valid domain as per RFC 1034 and
-   * corresponding specifications. Among other things, it requires
-   * that the domain string has fewer than 255 octets.
-   */
-  [[nodiscard]] virtual bool has_valid_domain() const noexcept = 0;
-
-  /**
-   * @private
-   *
-   * Return the 'special port' if the URL is special and not 'file'.
-   * Returns 0 otherwise.
-   */
-  [[nodiscard]] inline uint16_t get_special_port() const noexcept;
-
-  /**
-   * @private
-   *
-   * Get the default port if the url's scheme has one, returns 0 otherwise.
-   */
-  [[nodiscard]] ada_really_inline uint16_t scheme_default_port() const noexcept;
-
-  /**
-   * @private
-   *
-   * Parse a port (16-bit decimal digit) from the provided input.
-   * We assume that the input does not contain spaces or tabs
-   * within the ASCII digits.
-   * It returns how many bytes were consumed when a number is successfully
-   * parsed.
-   * @return On failure, it returns zero.
-   * @see https://url.spec.whatwg.org/#host-parsing
-   */
-  virtual size_t parse_port(std::string_view view,
-                            bool check_trailing_content) noexcept = 0;
-
-  virtual ada_really_inline size_t parse_port(std::string_view view) noexcept {
-    return this->parse_port(view, false);
-  }
-
-  /**
-   * Returns a JSON string representation of this URL.
-   */
-  [[nodiscard]] virtual std::string to_string() const = 0;
-
-  /** @private */
-  virtual inline void clear_pathname() = 0;
-
-  /** @private */
-  virtual inline void clear_search() = 0;
-
-  /** @private */
-  [[nodiscard]] virtual inline bool has_hash() const noexcept = 0;
-
-  /** @private */
-  [[nodiscard]] virtual inline bool has_search() const noexcept = 0;
-
-}; // url_base
-
-} // namespace ada
-
-#endif
-/* end file include/ada/url_base.h */
-
-#include <optional>
-#include <string_view>
-
-#if ADA_DEVELOPMENT_CHECKS
-#include <iostream>
-#endif // ADA_DEVELOPMENT_CHECKS
-
-/**
- * These functions are not part of our public API and may
- * change at any time.
- *
- * @private
- * @namespace ada::helpers
- * @brief Includes the definitions for helper functions
- */
-namespace ada::helpers {
-
-/**
- * @private
- */
-template <typename out_iter>
-void encode_json(std::string_view view, out_iter out);
-
-/**
- * @private
- * This function is used to prune a fragment from a url, and returning the
- * removed string if input has fragment.
- *
- * @details prune_hash seeks the first '#' and returns everything after it
- * as a string_view, and modifies (in place) the input so that it points at
- * everything before the '#'. If no '#' is found, the input is left unchanged
- * and std::nullopt is returned.
- *
- * @attention The function is non-allocating and it does not throw.
- * @returns Note that the returned string_view might be empty!
- */
-ada_really_inline std::optional<std::string_view>
-prune_hash(std::string_view &input) noexcept;
-
-/**
- * @private
- * Defined by the URL specification, shorten a URLs paths.
- * @see https://url.spec.whatwg.org/#shorten-a-urls-path
- * @returns Returns true if path is shortened.
- */
-ada_really_inline bool shorten_path(std::string &path,
-                                    ada::scheme::type type) noexcept;
-
-/**
- * @private
- * Defined by the URL specification, shorten a URLs paths.
- * @see https://url.spec.whatwg.org/#shorten-a-urls-path
- * @returns Returns true if path is shortened.
- */
-ada_really_inline bool shorten_path(std::string_view &path,
-                                    ada::scheme::type type) noexcept;
-
-/**
- * @private
- *
- * Parse the path from the provided input and append to the existing
- * (possibly empty) path. The input cannot contain tabs and spaces: it
- * is the user's responsibility to check.
- *
- * The input is expected to be UTF-8.
- *
- * @see https://url.spec.whatwg.org/
- */
-ada_really_inline void parse_prepared_path(std::string_view input,
-                                           ada::scheme::type type,
-                                           std::string &path);
-
-/**
- * @private
- * Remove and mutate all ASCII tab or newline characters from an input.
- */
-ada_really_inline void remove_ascii_tab_or_newline(std::string &input) noexcept;
-
-/**
- * @private
- * Return the substring from input going from index pos to the end.
- * This function cannot throw.
- */
-ada_really_inline constexpr std::string_view substring(std::string_view input,
-                                                       size_t pos) noexcept;
-
-/**
- * @private
- * Returns true if the string_view points within the string.
- */
-bool overlaps(std::string_view input1, const std::string &input2) noexcept;
-
-/**
- * @private
- * Return the substring from input going from index pos1 to the pos2 (non
- * included). The length of the substring is pos2 - pos1.
- */
-ada_really_inline constexpr std::string_view
-substring(std::string_view input, size_t pos1, size_t pos2) noexcept {
-#if ADA_DEVELOPMENT_CHECKS
-  if (pos2 < pos1) {
-    std::cerr << "Negative-length substring: [" << pos1 << " to " << pos2 << ")"
-              << std::endl;
-    abort();
-  }
-#endif
-  return input.substr(pos1, pos2 - pos1);
-}
-
-/**
- * @private
- * Modify the string_view so that it has the new size pos, assuming that pos <=
- * input.size(). This function cannot throw.
- */
-ada_really_inline void resize(std::string_view &input, size_t pos) noexcept;
-
-/**
- * @private
- * Returns a host's delimiter location depending on the state of the instance,
- * and whether a colon was found outside brackets. Used by the host parser.
- */
-ada_really_inline std::pair<size_t, bool>
-get_host_delimiter_location(bool is_special, std::string_view &view) noexcept;
-
-/**
- * @private
- * Removes leading and trailing C0 control and whitespace characters from
- * string.
- */
-void trim_c0_whitespace(std::string_view &input) noexcept;
-
-/**
- * @private
- * @see
- * https://url.spec.whatwg.org/#potentially-strip-trailing-spaces-from-an-opaque-path
- */
-template <class url_type>
-ada_really_inline void
-strip_trailing_spaces_from_opaque_path(url_type &url) noexcept;
-
-/**
- * @private
- * Finds the delimiter of a view in authority state.
- */
-ada_really_inline size_t
-find_authority_delimiter_special(std::string_view view) noexcept;
-
-/**
- * @private
- * Finds the delimiter of a view in authority state.
- */
-ada_really_inline size_t
-find_authority_delimiter(std::string_view view) noexcept;
-
-/**
- * @private
- */
-template <typename T, typename... Args>
-inline void inner_concat(std::string &buffer, T t) {
-  buffer.append(t);
-}
-
-/**
- * @private
- */
-template <typename T, typename... Args>
-inline void inner_concat(std::string &buffer, T t, Args... args) {
-  buffer.append(t);
-  return inner_concat(buffer, args...);
-}
-
-/**
- * @private
- * Concatenate the arguments and return a string.
- * @returns a string
- */
-template <typename... Args> std::string concat(Args... args) {
-  std::string answer;
-  inner_concat(answer, args...);
-  return answer;
-}
-
-/**
- * @private
- * @return Number of leading zeroes.
- */
-inline int leading_zeroes(uint32_t input_num) noexcept {
-#if ADA_REGULAR_VISUAL_STUDIO
-  unsigned long leading_zero(0);
-  unsigned long in(input_num);
-  return _BitScanReverse(&leading_zero, in) ? int(31 - leading_zero) : 32;
-#else
-  return __builtin_clz(input_num);
-#endif // ADA_REGULAR_VISUAL_STUDIO
-}
-
-/**
- * @private
- * Counts the number of decimal digits necessary to represent x.
- * faster than std::to_string(x).size().
- * @return digit count
- */
-inline int fast_digit_count(uint32_t x) noexcept {
-  auto int_log2 = [](uint32_t z) -> int {
-    return 31 - ada::helpers::leading_zeroes(z | 1);
-  };
-  // Compiles to very few instructions. Note that the
-  // table is static and thus effectively a constant.
-  // We leave it inside the function because it is meaningless
-  // outside of it (this comes at no performance cost).
-  const static uint64_t table[] = {
-      4294967296,  8589934582,  8589934582,  8589934582,  12884901788,
-      12884901788, 12884901788, 17179868184, 17179868184, 17179868184,
-      21474826480, 21474826480, 21474826480, 21474826480, 25769703776,
-      25769703776, 25769703776, 30063771072, 30063771072, 30063771072,
-      34349738368, 34349738368, 34349738368, 34349738368, 38554705664,
-      38554705664, 38554705664, 41949672960, 41949672960, 41949672960,
-      42949672960, 42949672960};
-  return int((x + table[int_log2(x)]) >> 32);
-}
-} // namespace ada::helpers
-
-#endif // ADA_HELPERS_H
-/* end file include/ada/helpers.h */
-/* begin file include/ada/parser.h */
-/**
- * @file parser.h
- * @brief Definitions for the parser.
- */
-#ifndef ADA_PARSER_H
-#define ADA_PARSER_H
-
-#include <string_view>
-#include <variant>
-
-/* begin file include/ada/expected.h */
-/**
- * @file expected.h
- * @brief Definitions for std::expected
- * @private Excluded from docs through the doxygen file.
- */
-///
-// expected - An implementation of std::expected with extensions
-// Written in 2017 by Sy Brand (tartanllama@gmail.com, @TartanLlama)
-//
-// Documentation available at http://tl.tartanllama.xyz/
-//
-// To the extent possible under law, the author(s) have dedicated all
-// copyright and related and neighboring rights to this software to the
-// public domain worldwide. This software is distributed without any warranty.
-//
-// You should have received a copy of the CC0 Public Domain Dedication
-// along with this software. If not, see
-// <http://creativecommons.org/publicdomain/zero/1.0/>.
-///
-
-#ifndef TL_EXPECTED_HPP
-#define TL_EXPECTED_HPP
-
-#define TL_EXPECTED_VERSION_MAJOR 1
-#define TL_EXPECTED_VERSION_MINOR 1
-#define TL_EXPECTED_VERSION_PATCH 0
-
-#include <exception>
-#include <functional>
-#include <type_traits>
-#include <utility>
-
-#if defined(__EXCEPTIONS) || defined(_CPPUNWIND)
-#define TL_EXPECTED_EXCEPTIONS_ENABLED
-#endif
-
-#if (defined(_MSC_VER) && _MSC_VER == 1900)
-#define TL_EXPECTED_MSVC2015
-#define TL_EXPECTED_MSVC2015_CONSTEXPR
-#else
-#define TL_EXPECTED_MSVC2015_CONSTEXPR constexpr
-#endif
-
-#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 &&              \
-     !defined(__clang__))
-#define TL_EXPECTED_GCC49
-#endif
-
-#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 4 &&              \
-     !defined(__clang__))
-#define TL_EXPECTED_GCC54
-#endif
-
-#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 5 &&              \
-     !defined(__clang__))
-#define TL_EXPECTED_GCC55
-#endif
-
-#if !defined(TL_ASSERT)
-// can't have assert in constexpr in C++11 and GCC 4.9 has a compiler bug
-#if (__cplusplus > 201103L) && !defined(TL_EXPECTED_GCC49)
-#include <cassert>
-#define TL_ASSERT(x) assert(x)
-#else
-#define TL_ASSERT(x)
-#endif
-#endif
-
-#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 &&              \
-     !defined(__clang__))
-// GCC < 5 doesn't support overloading on const&& for member functions
-
-#define TL_EXPECTED_NO_CONSTRR
-// GCC < 5 doesn't support some standard C++11 type traits
-#define TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)                         \
-  std::has_trivial_copy_constructor<T>
-#define TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T)                            \
-  std::has_trivial_copy_assign<T>
-
-// This one will be different for GCC 5.7 if it's ever supported
-#define TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T)                               \
-  std::is_trivially_destructible<T>
-
-// GCC 5 < v < 8 has a bug in is_trivially_copy_constructible which breaks
-// std::vector for non-copyable types
-#elif (defined(__GNUC__) && __GNUC__ < 8 && !defined(__clang__))
-#ifndef TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
-#define TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
-namespace tl {
-namespace detail {
-template <class T>
-struct is_trivially_copy_constructible
-    : std::is_trivially_copy_constructible<T> {};
-#ifdef _GLIBCXX_VECTOR
-template <class T, class A>
-struct is_trivially_copy_constructible<std::vector<T, A>> : std::false_type {};
-#endif
-} // namespace detail
-} // namespace tl
-#endif
-
-#define TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)                         \
-  tl::detail::is_trivially_copy_constructible<T>
-#define TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T)                            \
-  std::is_trivially_copy_assignable<T>
-#define TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T)                               \
-  std::is_trivially_destructible<T>
-#else
-#define TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)                         \
-  std::is_trivially_copy_constructible<T>
-#define TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T)                            \
-  std::is_trivially_copy_assignable<T>
-#define TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T)                               \
-  std::is_trivially_destructible<T>
-#endif
-
-#if __cplusplus > 201103L
-#define TL_EXPECTED_CXX14
-#endif
-
-#ifdef TL_EXPECTED_GCC49
-#define TL_EXPECTED_GCC49_CONSTEXPR
-#else
-#define TL_EXPECTED_GCC49_CONSTEXPR constexpr
-#endif
-
-#if (__cplusplus == 201103L || defined(TL_EXPECTED_MSVC2015) ||                \
-     defined(TL_EXPECTED_GCC49))
-#define TL_EXPECTED_11_CONSTEXPR
-#else
-#define TL_EXPECTED_11_CONSTEXPR constexpr
-#endif
-
-namespace tl {
-template <class T, class E> class expected;
-
-#ifndef TL_MONOSTATE_INPLACE_MUTEX
-#define TL_MONOSTATE_INPLACE_MUTEX
-class monostate {};
-
-struct in_place_t {
-  explicit in_place_t() = default;
-};
-static constexpr in_place_t in_place{};
-#endif
-
-template <class E> class unexpected {
-public:
-  static_assert(!std::is_same<E, void>::value, "E must not be void");
-
-  unexpected() = delete;
-  constexpr explicit unexpected(const E &e) : m_val(e) {}
-
-  constexpr explicit unexpected(E &&e) : m_val(std::move(e)) {}
-
-  template <class... Args, typename std::enable_if<std::is_constructible<
-                               E, Args &&...>::value>::type * = nullptr>
-  constexpr explicit unexpected(Args &&...args)
-      : m_val(std::forward<Args>(args)...) {}
-  template <
-      class U, class... Args,
-      typename std::enable_if<std::is_constructible<
-          E, std::initializer_list<U> &, Args &&...>::value>::type * = nullptr>
-  constexpr explicit unexpected(std::initializer_list<U> l, Args &&...args)
-      : m_val(l, std::forward<Args>(args)...) {}
-
-  constexpr const E &value() const & { return m_val; }
-  TL_EXPECTED_11_CONSTEXPR E &value() & { return m_val; }
-  TL_EXPECTED_11_CONSTEXPR E &&value() && { return std::move(m_val); }
-  constexpr const E &&value() const && { return std::move(m_val); }
-
-private:
-  E m_val;
-};
-
-#ifdef __cpp_deduction_guides
-template <class E> unexpected(E) -> unexpected<E>;
-#endif
-
-template <class E>
-constexpr bool operator==(const unexpected<E> &lhs, const unexpected<E> &rhs) {
-  return lhs.value() == rhs.value();
-}
-template <class E>
-constexpr bool operator!=(const unexpected<E> &lhs, const unexpected<E> &rhs) {
-  return lhs.value() != rhs.value();
-}
-template <class E>
-constexpr bool operator<(const unexpected<E> &lhs, const unexpected<E> &rhs) {
-  return lhs.value() < rhs.value();
-}
-template <class E>
-constexpr bool operator<=(const unexpected<E> &lhs, const unexpected<E> &rhs) {
-  return lhs.value() <= rhs.value();
-}
-template <class E>
-constexpr bool operator>(const unexpected<E> &lhs, const unexpected<E> &rhs) {
-  return lhs.value() > rhs.value();
-}
-template <class E>
-constexpr bool operator>=(const unexpected<E> &lhs, const unexpected<E> &rhs) {
-  return lhs.value() >= rhs.value();
-}
-
-template <class E>
-unexpected<typename std::decay<E>::type> make_unexpected(E &&e) {
-  return unexpected<typename std::decay<E>::type>(std::forward<E>(e));
-}
-
-struct unexpect_t {
-  unexpect_t() = default;
-};
-static constexpr unexpect_t unexpect{};
-
-namespace detail {
-template <typename E>
-[[noreturn]] TL_EXPECTED_11_CONSTEXPR void throw_exception(E &&e) {
-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
-  throw std::forward<E>(e);
-#else
-  (void)e;
-#ifdef _MSC_VER
-  __assume(0);
-#else
-  __builtin_unreachable();
-#endif
-#endif
-}
-
-#ifndef TL_TRAITS_MUTEX
-#define TL_TRAITS_MUTEX
-// C++14-style aliases for brevity
-template <class T> using remove_const_t = typename std::remove_const<T>::type;
-template <class T>
-using remove_reference_t = typename std::remove_reference<T>::type;
-template <class T> using decay_t = typename std::decay<T>::type;
-template <bool E, class T = void>
-using enable_if_t = typename std::enable_if<E, T>::type;
-template <bool B, class T, class F>
-using conditional_t = typename std::conditional<B, T, F>::type;
-
-// std::conjunction from C++17
-template <class...> struct conjunction : std::true_type {};
-template <class B> struct conjunction<B> : B {};
-template <class B, class... Bs>
-struct conjunction<B, Bs...>
-    : std::conditional<bool(B::value), conjunction<Bs...>, B>::type {};
-
-#if defined(_LIBCPP_VERSION) && __cplusplus == 201103L
-#define TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND
-#endif
-
-// In C++11 mode, there's an issue in libc++'s std::mem_fn
-// which results in a hard-error when using it in a noexcept expression
-// in some cases. This is a check to workaround the common failing case.
-#ifdef TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND
-template <class T>
-struct is_pointer_to_non_const_member_func : std::false_type {};
-template <class T, class Ret, class... Args>
-struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...)>
-    : std::true_type {};
-template <class T, class Ret, class... Args>
-struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) &>
-    : std::true_type {};
-template <class T, class Ret, class... Args>
-struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) &&>
-    : std::true_type {};
-template <class T, class Ret, class... Args>
-struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile>
-    : std::true_type {};
-template <class T, class Ret, class... Args>
-struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile &>
-    : std::true_type {};
-template <class T, class Ret, class... Args>
-struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile &&>
-    : std::true_type {};
-
-template <class T> struct is_const_or_const_ref : std::false_type {};
-template <class T> struct is_const_or_const_ref<T const &> : std::true_type {};
-template <class T> struct is_const_or_const_ref<T const> : std::true_type {};
-#endif
-
-// std::invoke from C++17
-// https://stackoverflow.com/questions/38288042/c11-14-invoke-workaround
-template <
-    typename Fn, typename... Args,
-#ifdef TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND
-    typename = enable_if_t<!(is_pointer_to_non_const_member_func<Fn>::value &&
-                             is_const_or_const_ref<Args...>::value)>,
-#endif
-    typename = enable_if_t<std::is_member_pointer<decay_t<Fn>>::value>, int = 0>
-constexpr auto invoke(Fn &&f, Args &&...args) noexcept(
-    noexcept(std::mem_fn(f)(std::forward<Args>(args)...)))
-    -> decltype(std::mem_fn(f)(std::forward<Args>(args)...)) {
-  return std::mem_fn(f)(std::forward<Args>(args)...);
-}
-
-template <typename Fn, typename... Args,
-          typename = enable_if_t<!std::is_member_pointer<decay_t<Fn>>::value>>
-constexpr auto invoke(Fn &&f, Args &&...args) noexcept(
-    noexcept(std::forward<Fn>(f)(std::forward<Args>(args)...)))
-    -> decltype(std::forward<Fn>(f)(std::forward<Args>(args)...)) {
-  return std::forward<Fn>(f)(std::forward<Args>(args)...);
-}
-
-// std::invoke_result from C++17
-template <class F, class, class... Us> struct invoke_result_impl;
-
-template <class F, class... Us>
-struct invoke_result_impl<
-    F,
-    decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...), void()),
-    Us...> {
-  using type =
-      decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...));
-};
-
-template <class F, class... Us>
-using invoke_result = invoke_result_impl<F, void, Us...>;
-
-template <class F, class... Us>
-using invoke_result_t = typename invoke_result<F, Us...>::type;
-
-#if defined(_MSC_VER) && _MSC_VER <= 1900
-// TODO make a version which works with MSVC 2015
-template <class T, class U = T> struct is_swappable : std::true_type {};
-
-template <class T, class U = T> struct is_nothrow_swappable : std::true_type {};
-#else
-// https://stackoverflow.com/questions/26744589/what-is-a-proper-way-to-implement-is-swappable-to-test-for-the-swappable-concept
-namespace swap_adl_tests {
-// if swap ADL finds this then it would call std::swap otherwise (same
-// signature)
-struct tag {};
-
-template <class T> tag swap(T &, T &);
-template <class T, std::size_t N> tag swap(T (&a)[N], T (&b)[N]);
-
-// helper functions to test if an unqualified swap is possible, and if it
-// becomes std::swap
-template <class, class> std::false_type can_swap(...) noexcept(false);
-template <class T, class U,
-          class = decltype(swap(std::declval<T &>(), std::declval<U &>()))>
-std::true_type can_swap(int) noexcept(noexcept(swap(std::declval<T &>(),
-                                                    std::declval<U &>())));
-
-template <class, class> std::false_type uses_std(...);
-template <class T, class U>
-std::is_same<decltype(swap(std::declval<T &>(), std::declval<U &>())), tag>
-uses_std(int);
-
-template <class T>
-struct is_std_swap_noexcept
-    : std::integral_constant<bool,
-                             std::is_nothrow_move_constructible<T>::value &&
-                                 std::is_nothrow_move_assignable<T>::value> {};
-
-template <class T, std::size_t N>
-struct is_std_swap_noexcept<T[N]> : is_std_swap_noexcept<T> {};
-
-template <class T, class U>
-struct is_adl_swap_noexcept
-    : std::integral_constant<bool, noexcept(can_swap<T, U>(0))> {};
-} // namespace swap_adl_tests
-
-template <class T, class U = T>
-struct is_swappable
-    : std::integral_constant<
-          bool,
-          decltype(detail::swap_adl_tests::can_swap<T, U>(0))::value &&
-              (!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value ||
-               (std::is_move_assignable<T>::value &&
-                std::is_move_constructible<T>::value))> {};
-
-template <class T, std::size_t N>
-struct is_swappable<T[N], T[N]>
-    : std::integral_constant<
-          bool,
-          decltype(detail::swap_adl_tests::can_swap<T[N], T[N]>(0))::value &&
-              (!decltype(detail::swap_adl_tests::uses_std<T[N], T[N]>(
-                   0))::value ||
-               is_swappable<T, T>::value)> {};
-
-template <class T, class U = T>
-struct is_nothrow_swappable
-    : std::integral_constant<
-          bool,
-          is_swappable<T, U>::value &&
-              ((decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value &&
-                detail::swap_adl_tests::is_std_swap_noexcept<T>::value) ||
-               (!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value &&
-                detail::swap_adl_tests::is_adl_swap_noexcept<T, U>::value))> {};
-#endif
-#endif
-
-// Trait for checking if a type is a tl::expected
-template <class T> struct is_expected_impl : std::false_type {};
-template <class T, class E>
-struct is_expected_impl<expected<T, E>> : std::true_type {};
-template <class T> using is_expected = is_expected_impl<decay_t<T>>;
-
-template <class T, class E, class U>
-using expected_enable_forward_value = detail::enable_if_t<
-    std::is_constructible<T, U &&>::value &&
-    !std::is_same<detail::decay_t<U>, in_place_t>::value &&
-    !std::is_same<expected<T, E>, detail::decay_t<U>>::value &&
-    !std::is_same<unexpected<E>, detail::decay_t<U>>::value>;
-
-template <class T, class E, class U, class G, class UR, class GR>
-using expected_enable_from_other = detail::enable_if_t<
-    std::is_constructible<T, UR>::value &&
-    std::is_constructible<E, GR>::value &&
-    !std::is_constructible<T, expected<U, G> &>::value &&
-    !std::is_constructible<T, expected<U, G> &&>::value &&
-    !std::is_constructible<T, const expected<U, G> &>::value &&
-    !std::is_constructible<T, const expected<U, G> &&>::value &&
-    !std::is_convertible<expected<U, G> &, T>::value &&
-    !std::is_convertible<expected<U, G> &&, T>::value &&
-    !std::is_convertible<const expected<U, G> &, T>::value &&
-    !std::is_convertible<const expected<U, G> &&, T>::value>;
-
-template <class T, class U>
-using is_void_or = conditional_t<std::is_void<T>::value, std::true_type, U>;
-
-template <class T>
-using is_copy_constructible_or_void =
-    is_void_or<T, std::is_copy_constructible<T>>;
-
-template <class T>
-using is_move_constructible_or_void =
-    is_void_or<T, std::is_move_constructible<T>>;
-
-template <class T>
-using is_copy_assignable_or_void = is_void_or<T, std::is_copy_assignable<T>>;
-
-template <class T>
-using is_move_assignable_or_void = is_void_or<T, std::is_move_assignable<T>>;
-
-} // namespace detail
-
-namespace detail {
-struct no_init_t {};
-static constexpr no_init_t no_init{};
-
-// Implements the storage of the values, and ensures that the destructor is
-// trivial if it can be.
-//
-// This specialization is for where neither `T` or `E` is trivially
-// destructible, so the destructors must be called on destruction of the
-// `expected`
-template <class T, class E, bool = std::is_trivially_destructible<T>::value,
-          bool = std::is_trivially_destructible<E>::value>
-struct expected_storage_base {
-  constexpr expected_storage_base() : m_val(T{}), m_has_val(true) {}
-  constexpr expected_storage_base(no_init_t) : m_no_init(), m_has_val(false) {}
-
-  template <class... Args,
-            detail::enable_if_t<std::is_constructible<T, Args &&...>::value> * =
-                nullptr>
-  constexpr expected_storage_base(in_place_t, Args &&...args)
-      : m_val(std::forward<Args>(args)...), m_has_val(true) {}
-
-  template <class U, class... Args,
-            detail::enable_if_t<std::is_constructible<
-                T, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-  constexpr expected_storage_base(in_place_t, std::initializer_list<U> il,
-                                  Args &&...args)
-      : m_val(il, std::forward<Args>(args)...), m_has_val(true) {}
-  template <class... Args,
-            detail::enable_if_t<std::is_constructible<E, Args &&...>::value> * =
-                nullptr>
-  constexpr explicit expected_storage_base(unexpect_t, Args &&...args)
-      : m_unexpect(std::forward<Args>(args)...), m_has_val(false) {}
-
-  template <class U, class... Args,
-            detail::enable_if_t<std::is_constructible<
-                E, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-  constexpr explicit expected_storage_base(unexpect_t,
-                                           std::initializer_list<U> il,
-                                           Args &&...args)
-      : m_unexpect(il, std::forward<Args>(args)...), m_has_val(false) {}
-
-  ~expected_storage_base() {
-    if (m_has_val) {
-      m_val.~T();
-    } else {
-      m_unexpect.~unexpected<E>();
-    }
-  }
-  union {
-    T m_val;
-    unexpected<E> m_unexpect;
-    char m_no_init;
-  };
-  bool m_has_val;
-};
-
-// This specialization is for when both `T` and `E` are trivially-destructible,
-// so the destructor of the `expected` can be trivial.
-template <class T, class E> struct expected_storage_base<T, E, true, true> {
-  constexpr expected_storage_base() : m_val(T{}), m_has_val(true) {}
-  constexpr expected_storage_base(no_init_t) : m_no_init(), m_has_val(false) {}
-
-  template <class... Args,
-            detail::enable_if_t<std::is_constructible<T, Args &&...>::value> * =
-                nullptr>
-  constexpr expected_storage_base(in_place_t, Args &&...args)
-      : m_val(std::forward<Args>(args)...), m_has_val(true) {}
-
-  template <class U, class... Args,
-            detail::enable_if_t<std::is_constructible<
-                T, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-  constexpr expected_storage_base(in_place_t, std::initializer_list<U> il,
-                                  Args &&...args)
-      : m_val(il, std::forward<Args>(args)...), m_has_val(true) {}
-  template <class... Args,
-            detail::enable_if_t<std::is_constructible<E, Args &&...>::value> * =
-                nullptr>
-  constexpr explicit expected_storage_base(unexpect_t, Args &&...args)
-      : m_unexpect(std::forward<Args>(args)...), m_has_val(false) {}
-
-  template <class U, class... Args,
-            detail::enable_if_t<std::is_constructible<
-                E, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-  constexpr explicit expected_storage_base(unexpect_t,
-                                           std::initializer_list<U> il,
-                                           Args &&...args)
-      : m_unexpect(il, std::forward<Args>(args)...), m_has_val(false) {}
-
-  ~expected_storage_base() = default;
-  union {
-    T m_val;
-    unexpected<E> m_unexpect;
-    char m_no_init;
-  };
-  bool m_has_val;
-};
-
-// T is trivial, E is not.
-template <class T, class E> struct expected_storage_base<T, E, true, false> {
-  constexpr expected_storage_base() : m_val(T{}), m_has_val(true) {}
-  TL_EXPECTED_MSVC2015_CONSTEXPR expected_storage_base(no_init_t)
-      : m_no_init(), m_has_val(false) {}
-
-  template <class... Args,
-            detail::enable_if_t<std::is_constructible<T, Args &&...>::value> * =
-                nullptr>
-  constexpr expected_storage_base(in_place_t, Args &&...args)
-      : m_val(std::forward<Args>(args)...), m_has_val(true) {}
-
-  template <class U, class... Args,
-            detail::enable_if_t<std::is_constructible<
-                T, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-  constexpr expected_storage_base(in_place_t, std::initializer_list<U> il,
-                                  Args &&...args)
-      : m_val(il, std::forward<Args>(args)...), m_has_val(true) {}
-  template <class... Args,
-            detail::enable_if_t<std::is_constructible<E, Args &&...>::value> * =
-                nullptr>
-  constexpr explicit expected_storage_base(unexpect_t, Args &&...args)
-      : m_unexpect(std::forward<Args>(args)...), m_has_val(false) {}
-
-  template <class U, class... Args,
-            detail::enable_if_t<std::is_constructible<
-                E, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-  constexpr explicit expected_storage_base(unexpect_t,
-                                           std::initializer_list<U> il,
-                                           Args &&...args)
-      : m_unexpect(il, std::forward<Args>(args)...), m_has_val(false) {}
-
-  ~expected_storage_base() {
-    if (!m_has_val) {
-      m_unexpect.~unexpected<E>();
-    }
-  }
-
-  union {
-    T m_val;
-    unexpected<E> m_unexpect;
-    char m_no_init;
-  };
-  bool m_has_val;
-};
-
-// E is trivial, T is not.
-template <class T, class E> struct expected_storage_base<T, E, false, true> {
-  constexpr expected_storage_base() : m_val(T{}), m_has_val(true) {}
-  constexpr expected_storage_base(no_init_t) : m_no_init(), m_has_val(false) {}
-
-  template <class... Args,
-            detail::enable_if_t<std::is_constructible<T, Args &&...>::value> * =
-                nullptr>
-  constexpr expected_storage_base(in_place_t, Args &&...args)
-      : m_val(std::forward<Args>(args)...), m_has_val(true) {}
-
-  template <class U, class... Args,
-            detail::enable_if_t<std::is_constructible<
-                T, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-  constexpr expected_storage_base(in_place_t, std::initializer_list<U> il,
-                                  Args &&...args)
-      : m_val(il, std::forward<Args>(args)...), m_has_val(true) {}
-  template <class... Args,
-            detail::enable_if_t<std::is_constructible<E, Args &&...>::value> * =
-                nullptr>
-  constexpr explicit expected_storage_base(unexpect_t, Args &&...args)
-      : m_unexpect(std::forward<Args>(args)...), m_has_val(false) {}
-
-  template <class U, class... Args,
-            detail::enable_if_t<std::is_constructible<
-                E, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-  constexpr explicit expected_storage_base(unexpect_t,
-                                           std::initializer_list<U> il,
-                                           Args &&...args)
-      : m_unexpect(il, std::forward<Args>(args)...), m_has_val(false) {}
-
-  ~expected_storage_base() {
-    if (m_has_val) {
-      m_val.~T();
-    }
-  }
-  union {
-    T m_val;
-    unexpected<E> m_unexpect;
-    char m_no_init;
-  };
-  bool m_has_val;
-};
-
-// `T` is `void`, `E` is trivially-destructible
-template <class E> struct expected_storage_base<void, E, false, true> {
-#if __GNUC__ <= 5
-// no constexpr for GCC 4/5 bug
-#else
-  TL_EXPECTED_MSVC2015_CONSTEXPR
-#endif
-  expected_storage_base() : m_has_val(true) {}
-
-  constexpr expected_storage_base(no_init_t) : m_val(), m_has_val(false) {}
-
-  constexpr expected_storage_base(in_place_t) : m_has_val(true) {}
-
-  template <class... Args,
-            detail::enable_if_t<std::is_constructible<E, Args &&...>::value> * =
-                nullptr>
-  constexpr explicit expected_storage_base(unexpect_t, Args &&...args)
-      : m_unexpect(std::forward<Args>(args)...), m_has_val(false) {}
-
-  template <class U, class... Args,
-            detail::enable_if_t<std::is_constructible<
-                E, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-  constexpr explicit expected_storage_base(unexpect_t,
-                                           std::initializer_list<U> il,
-                                           Args &&...args)
-      : m_unexpect(il, std::forward<Args>(args)...), m_has_val(false) {}
-
-  ~expected_storage_base() = default;
-  struct dummy {};
-  union {
-    unexpected<E> m_unexpect;
-    dummy m_val;
-  };
-  bool m_has_val;
-};
-
-// `T` is `void`, `E` is not trivially-destructible
-template <class E> struct expected_storage_base<void, E, false, false> {
-  constexpr expected_storage_base() : m_dummy(), m_has_val(true) {}
-  constexpr expected_storage_base(no_init_t) : m_dummy(), m_has_val(false) {}
-
-  constexpr expected_storage_base(in_place_t) : m_dummy(), m_has_val(true) {}
-
-  template <class... Args,
-            detail::enable_if_t<std::is_constructible<E, Args &&...>::value> * =
-                nullptr>
-  constexpr explicit expected_storage_base(unexpect_t, Args &&...args)
-      : m_unexpect(std::forward<Args>(args)...), m_has_val(false) {}
-
-  template <class U, class... Args,
-            detail::enable_if_t<std::is_constructible<
-                E, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-  constexpr explicit expected_storage_base(unexpect_t,
-                                           std::initializer_list<U> il,
-                                           Args &&...args)
-      : m_unexpect(il, std::forward<Args>(args)...), m_has_val(false) {}
-
-  ~expected_storage_base() {
-    if (!m_has_val) {
-      m_unexpect.~unexpected<E>();
-    }
-  }
-
-  union {
-    unexpected<E> m_unexpect;
-    char m_dummy;
-  };
-  bool m_has_val;
-};
-
-// This base class provides some handy member functions which can be used in
-// further derived classes
-template <class T, class E>
-struct expected_operations_base : expected_storage_base<T, E> {
-  using expected_storage_base<T, E>::expected_storage_base;
-
-  template <class... Args> void construct(Args &&...args) noexcept {
-    new (std::addressof(this->m_val)) T(std::forward<Args>(args)...);
-    this->m_has_val = true;
-  }
-
-  template <class Rhs> void construct_with(Rhs &&rhs) noexcept {
-    new (std::addressof(this->m_val)) T(std::forward<Rhs>(rhs).get());
-    this->m_has_val = true;
-  }
-
-  template <class... Args> void construct_error(Args &&...args) noexcept {
-    new (std::addressof(this->m_unexpect))
-        unexpected<E>(std::forward<Args>(args)...);
-    this->m_has_val = false;
-  }
-
-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
-
-  // These assign overloads ensure that the most efficient assignment
-  // implementation is used while maintaining the strong exception guarantee.
-  // The problematic case is where rhs has a value, but *this does not.
-  //
-  // This overload handles the case where we can just copy-construct `T`
-  // directly into place without throwing.
-  template <class U = T,
-            detail::enable_if_t<std::is_nothrow_copy_constructible<U>::value>
-                * = nullptr>
-  void assign(const expected_operations_base &rhs) noexcept {
-    if (!this->m_has_val && rhs.m_has_val) {
-      geterr().~unexpected<E>();
-      construct(rhs.get());
-    } else {
-      assign_common(rhs);
-    }
-  }
-
-  // This overload handles the case where we can attempt to create a copy of
-  // `T`, then no-throw move it into place if the copy was successful.
-  template <class U = T,
-            detail::enable_if_t<!std::is_nothrow_copy_constructible<U>::value &&
-                                std::is_nothrow_move_constructible<U>::value>
-                * = nullptr>
-  void assign(const expected_operations_base &rhs) noexcept {
-    if (!this->m_has_val && rhs.m_has_val) {
-      T tmp = rhs.get();
-      geterr().~unexpected<E>();
-      construct(std::move(tmp));
-    } else {
-      assign_common(rhs);
-    }
-  }
-
-  // This overload is the worst-case, where we have to move-construct the
-  // unexpected value into temporary storage, then try to copy the T into place.
-  // If the construction succeeds, then everything is fine, but if it throws,
-  // then we move the old unexpected value back into place before rethrowing the
-  // exception.
-  template <class U = T,
-            detail::enable_if_t<!std::is_nothrow_copy_constructible<U>::value &&
-                                !std::is_nothrow_move_constructible<U>::value>
-                * = nullptr>
-  void assign(const expected_operations_base &rhs) {
-    if (!this->m_has_val && rhs.m_has_val) {
-      auto tmp = std::move(geterr());
-      geterr().~unexpected<E>();
-
-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
-      try {
-        construct(rhs.get());
-      } catch (...) {
-        geterr() = std::move(tmp);
-        throw;
-      }
-#else
-      construct(rhs.get());
-#endif
-    } else {
-      assign_common(rhs);
-    }
-  }
-
-  // These overloads do the same as above, but for rvalues
-  template <class U = T,
-            detail::enable_if_t<std::is_nothrow_move_constructible<U>::value>
-                * = nullptr>
-  void assign(expected_operations_base &&rhs) noexcept {
-    if (!this->m_has_val && rhs.m_has_val) {
-      geterr().~unexpected<E>();
-      construct(std::move(rhs).get());
-    } else {
-      assign_common(std::move(rhs));
-    }
-  }
-
-  template <class U = T,
-            detail::enable_if_t<!std::is_nothrow_move_constructible<U>::value>
-                * = nullptr>
-  void assign(expected_operations_base &&rhs) {
-    if (!this->m_has_val && rhs.m_has_val) {
-      auto tmp = std::move(geterr());
-      geterr().~unexpected<E>();
-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
-      try {
-        construct(std::move(rhs).get());
-      } catch (...) {
-        geterr() = std::move(tmp);
-        throw;
-      }
-#else
-      construct(std::move(rhs).get());
-#endif
-    } else {
-      assign_common(std::move(rhs));
-    }
-  }
-
-#else
-
-  // If exceptions are disabled then we can just copy-construct
-  void assign(const expected_operations_base &rhs) noexcept {
-    if (!this->m_has_val && rhs.m_has_val) {
-      geterr().~unexpected<E>();
-      construct(rhs.get());
-    } else {
-      assign_common(rhs);
-    }
-  }
-
-  void assign(expected_operations_base &&rhs) noexcept {
-    if (!this->m_has_val && rhs.m_has_val) {
-      geterr().~unexpected<E>();
-      construct(std::move(rhs).get());
-    } else {
-      assign_common(std::move(rhs));
-    }
-  }
-
-#endif
-
-  // The common part of move/copy assigning
-  template <class Rhs> void assign_common(Rhs &&rhs) {
-    if (this->m_has_val) {
-      if (rhs.m_has_val) {
-        get() = std::forward<Rhs>(rhs).get();
-      } else {
-        destroy_val();
-        construct_error(std::forward<Rhs>(rhs).geterr());
-      }
-    } else {
-      if (!rhs.m_has_val) {
-        geterr() = std::forward<Rhs>(rhs).geterr();
-      }
-    }
-  }
-
-  bool has_value() const { return this->m_has_val; }
-
-  TL_EXPECTED_11_CONSTEXPR T &get() & { return this->m_val; }
-  constexpr const T &get() const & { return this->m_val; }
-  TL_EXPECTED_11_CONSTEXPR T &&get() && { return std::move(this->m_val); }
-#ifndef TL_EXPECTED_NO_CONSTRR
-  constexpr const T &&get() const && { return std::move(this->m_val); }
-#endif
-
-  TL_EXPECTED_11_CONSTEXPR unexpected<E> &geterr() & {
-    return this->m_unexpect;
-  }
-  constexpr const unexpected<E> &geterr() const & { return this->m_unexpect; }
-  TL_EXPECTED_11_CONSTEXPR unexpected<E> &&geterr() && {
-    return std::move(this->m_unexpect);
-  }
-#ifndef TL_EXPECTED_NO_CONSTRR
-  constexpr const unexpected<E> &&geterr() const && {
-    return std::move(this->m_unexpect);
-  }
-#endif
-
-  TL_EXPECTED_11_CONSTEXPR void destroy_val() { get().~T(); }
-};
-
-// This base class provides some handy member functions which can be used in
-// further derived classes
-template <class E>
-struct expected_operations_base<void, E> : expected_storage_base<void, E> {
-  using expected_storage_base<void, E>::expected_storage_base;
-
-  template <class... Args> void construct() noexcept { this->m_has_val = true; }
-
-  // This function doesn't use its argument, but needs it so that code in
-  // levels above this can work independently of whether T is void
-  template <class Rhs> void construct_with(Rhs &&) noexcept {
-    this->m_has_val = true;
-  }
-
-  template <class... Args> void construct_error(Args &&...args) noexcept {
-    new (std::addressof(this->m_unexpect))
-        unexpected<E>(std::forward<Args>(args)...);
-    this->m_has_val = false;
-  }
-
-  template <class Rhs> void assign(Rhs &&rhs) noexcept {
-    if (!this->m_has_val) {
-      if (rhs.m_has_val) {
-        geterr().~unexpected<E>();
-        construct();
-      } else {
-        geterr() = std::forward<Rhs>(rhs).geterr();
-      }
-    } else {
-      if (!rhs.m_has_val) {
-        construct_error(std::forward<Rhs>(rhs).geterr());
-      }
-    }
-  }
-
-  bool has_value() const { return this->m_has_val; }
-
-  TL_EXPECTED_11_CONSTEXPR unexpected<E> &geterr() & {
-    return this->m_unexpect;
-  }
-  constexpr const unexpected<E> &geterr() const & { return this->m_unexpect; }
-  TL_EXPECTED_11_CONSTEXPR unexpected<E> &&geterr() && {
-    return std::move(this->m_unexpect);
-  }
-#ifndef TL_EXPECTED_NO_CONSTRR
-  constexpr const unexpected<E> &&geterr() const && {
-    return std::move(this->m_unexpect);
-  }
-#endif
-
-  TL_EXPECTED_11_CONSTEXPR void destroy_val() {
-    // no-op
-  }
-};
-
-// This class manages conditionally having a trivial copy constructor
-// This specialization is for when T and E are trivially copy constructible
-template <class T, class E,
-          bool = is_void_or<T, TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(
-                                   T)>::value &&
-                 TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(E)::value>
-struct expected_copy_base : expected_operations_base<T, E> {
-  using expected_operations_base<T, E>::expected_operations_base;
-};
-
-// This specialization is for when T or E are not trivially copy constructible
-template <class T, class E>
-struct expected_copy_base<T, E, false> : expected_operations_base<T, E> {
-  using expected_operations_base<T, E>::expected_operations_base;
-
-  expected_copy_base() = default;
-  expected_copy_base(const expected_copy_base &rhs)
-      : expected_operations_base<T, E>(no_init) {
-    if (rhs.has_value()) {
-      this->construct_with(rhs);
-    } else {
-      this->construct_error(rhs.geterr());
-    }
-  }
-
-  expected_copy_base(expected_copy_base &&rhs) = default;
-  expected_copy_base &operator=(const expected_copy_base &rhs) = default;
-  expected_copy_base &operator=(expected_copy_base &&rhs) = default;
-};
-
-// This class manages conditionally having a trivial move constructor
-// Unfortunately there's no way to achieve this in GCC < 5 AFAIK, since it
-// doesn't implement an analogue to std::is_trivially_move_constructible. We
-// have to make do with a non-trivial move constructor even if T is trivially
-// move constructible
-#ifndef TL_EXPECTED_GCC49
-template <class T, class E,
-          bool =
-              is_void_or<T, std::is_trivially_move_constructible<T>>::value &&
-              std::is_trivially_move_constructible<E>::value>
-struct expected_move_base : expected_copy_base<T, E> {
-  using expected_copy_base<T, E>::expected_copy_base;
-};
-#else
-template <class T, class E, bool = false> struct expected_move_base;
-#endif
-template <class T, class E>
-struct expected_move_base<T, E, false> : expected_copy_base<T, E> {
-  using expected_copy_base<T, E>::expected_copy_base;
-
-  expected_move_base() = default;
-  expected_move_base(const expected_move_base &rhs) = default;
-
-  expected_move_base(expected_move_base &&rhs) noexcept(
-      std::is_nothrow_move_constructible<T>::value)
-      : expected_copy_base<T, E>(no_init) {
-    if (rhs.has_value()) {
-      this->construct_with(std::move(rhs));
-    } else {
-      this->construct_error(std::move(rhs.geterr()));
-    }
-  }
-  expected_move_base &operator=(const expected_move_base &rhs) = default;
-  expected_move_base &operator=(expected_move_base &&rhs) = default;
-};
-
-// This class manages conditionally having a trivial copy assignment operator
-template <
-    class T, class E,
-    bool =
-        is_void_or<
-            T, conjunction<TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T),
-                           TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T),
-                           TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T)>>::value &&
-        TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(E)::value &&
-        TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(E)::value &&
-        TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(E)::value>
-struct expected_copy_assign_base : expected_move_base<T, E> {
-  using expected_move_base<T, E>::expected_move_base;
-};
-
-template <class T, class E>
-struct expected_copy_assign_base<T, E, false> : expected_move_base<T, E> {
-  using expected_move_base<T, E>::expected_move_base;
-
-  expected_copy_assign_base() = default;
-  expected_copy_assign_base(const expected_copy_assign_base &rhs) = default;
-
-  expected_copy_assign_base(expected_copy_assign_base &&rhs) = default;
-  expected_copy_assign_base &operator=(const expected_copy_assign_base &rhs) {
-    this->assign(rhs);
-    return *this;
-  }
-  expected_copy_assign_base &
-  operator=(expected_copy_assign_base &&rhs) = default;
-};
-
-// This class manages conditionally having a trivial move assignment operator
-// Unfortunately there's no way to achieve this in GCC < 5 AFAIK, since it
-// doesn't implement an analogue to std::is_trivially_move_assignable. We have
-// to make do with a non-trivial move assignment operator even if T is trivially
-// move assignable
-#ifndef TL_EXPECTED_GCC49
-template <
-    class T, class E,
-    bool = is_void_or<
-               T, conjunction<std::is_trivially_destructible<T>,
-                              std::is_trivially_move_constructible<T>,
-                              std::is_trivially_move_assignable<T>>>::value &&
-           std::is_trivially_destructible<E>::value &&
-           std::is_trivially_move_constructible<E>::value &&
-           std::is_trivially_move_assignable<E>::value>
-struct expected_move_assign_base : expected_copy_assign_base<T, E> {
-  using expected_copy_assign_base<T, E>::expected_copy_assign_base;
-};
-#else
-template <class T, class E, bool = false> struct expected_move_assign_base;
-#endif
-
-template <class T, class E>
-struct expected_move_assign_base<T, E, false>
-    : expected_copy_assign_base<T, E> {
-  using expected_copy_assign_base<T, E>::expected_copy_assign_base;
-
-  expected_move_assign_base() = default;
-  expected_move_assign_base(const expected_move_assign_base &rhs) = default;
-
-  expected_move_assign_base(expected_move_assign_base &&rhs) = default;
-
-  expected_move_assign_base &
-  operator=(const expected_move_assign_base &rhs) = default;
-
-  expected_move_assign_base &
-  operator=(expected_move_assign_base &&rhs) noexcept(
-      std::is_nothrow_move_constructible<T>::value &&
-      std::is_nothrow_move_assignable<T>::value) {
-    this->assign(std::move(rhs));
-    return *this;
-  }
-};
-
-// expected_delete_ctor_base will conditionally delete copy and move
-// constructors depending on whether T is copy/move constructible
-template <class T, class E,
-          bool EnableCopy = (is_copy_constructible_or_void<T>::value &&
-                             std::is_copy_constructible<E>::value),
-          bool EnableMove = (is_move_constructible_or_void<T>::value &&
-                             std::is_move_constructible<E>::value)>
-struct expected_delete_ctor_base {
-  expected_delete_ctor_base() = default;
-  expected_delete_ctor_base(const expected_delete_ctor_base &) = default;
-  expected_delete_ctor_base(expected_delete_ctor_base &&) noexcept = default;
-  expected_delete_ctor_base &
-  operator=(const expected_delete_ctor_base &) = default;
-  expected_delete_ctor_base &
-  operator=(expected_delete_ctor_base &&) noexcept = default;
-};
-
-template <class T, class E>
-struct expected_delete_ctor_base<T, E, true, false> {
-  expected_delete_ctor_base() = default;
-  expected_delete_ctor_base(const expected_delete_ctor_base &) = default;
-  expected_delete_ctor_base(expected_delete_ctor_base &&) noexcept = delete;
-  expected_delete_ctor_base &
-  operator=(const expected_delete_ctor_base &) = default;
-  expected_delete_ctor_base &
-  operator=(expected_delete_ctor_base &&) noexcept = default;
-};
-
-template <class T, class E>
-struct expected_delete_ctor_base<T, E, false, true> {
-  expected_delete_ctor_base() = default;
-  expected_delete_ctor_base(const expected_delete_ctor_base &) = delete;
-  expected_delete_ctor_base(expected_delete_ctor_base &&) noexcept = default;
-  expected_delete_ctor_base &
-  operator=(const expected_delete_ctor_base &) = default;
-  expected_delete_ctor_base &
-  operator=(expected_delete_ctor_base &&) noexcept = default;
-};
-
-template <class T, class E>
-struct expected_delete_ctor_base<T, E, false, false> {
-  expected_delete_ctor_base() = default;
-  expected_delete_ctor_base(const expected_delete_ctor_base &) = delete;
-  expected_delete_ctor_base(expected_delete_ctor_base &&) noexcept = delete;
-  expected_delete_ctor_base &
-  operator=(const expected_delete_ctor_base &) = default;
-  expected_delete_ctor_base &
-  operator=(expected_delete_ctor_base &&) noexcept = default;
-};
-
-// expected_delete_assign_base will conditionally delete copy and move
-// constructors depending on whether T and E are copy/move constructible +
-// assignable
-template <class T, class E,
-          bool EnableCopy = (is_copy_constructible_or_void<T>::value &&
-                             std::is_copy_constructible<E>::value &&
-                             is_copy_assignable_or_void<T>::value &&
-                             std::is_copy_assignable<E>::value),
-          bool EnableMove = (is_move_constructible_or_void<T>::value &&
-                             std::is_move_constructible<E>::value &&
-                             is_move_assignable_or_void<T>::value &&
-                             std::is_move_assignable<E>::value)>
-struct expected_delete_assign_base {
-  expected_delete_assign_base() = default;
-  expected_delete_assign_base(const expected_delete_assign_base &) = default;
-  expected_delete_assign_base(expected_delete_assign_base &&) noexcept =
-      default;
-  expected_delete_assign_base &
-  operator=(const expected_delete_assign_base &) = default;
-  expected_delete_assign_base &
-  operator=(expected_delete_assign_base &&) noexcept = default;
-};
-
-template <class T, class E>
-struct expected_delete_assign_base<T, E, true, false> {
-  expected_delete_assign_base() = default;
-  expected_delete_assign_base(const expected_delete_assign_base &) = default;
-  expected_delete_assign_base(expected_delete_assign_base &&) noexcept =
-      default;
-  expected_delete_assign_base &
-  operator=(const expected_delete_assign_base &) = default;
-  expected_delete_assign_base &
-  operator=(expected_delete_assign_base &&) noexcept = delete;
-};
-
-template <class T, class E>
-struct expected_delete_assign_base<T, E, false, true> {
-  expected_delete_assign_base() = default;
-  expected_delete_assign_base(const expected_delete_assign_base &) = default;
-  expected_delete_assign_base(expected_delete_assign_base &&) noexcept =
-      default;
-  expected_delete_assign_base &
-  operator=(const expected_delete_assign_base &) = delete;
-  expected_delete_assign_base &
-  operator=(expected_delete_assign_base &&) noexcept = default;
-};
-
-template <class T, class E>
-struct expected_delete_assign_base<T, E, false, false> {
-  expected_delete_assign_base() = default;
-  expected_delete_assign_base(const expected_delete_assign_base &) = default;
-  expected_delete_assign_base(expected_delete_assign_base &&) noexcept =
-      default;
-  expected_delete_assign_base &
-  operator=(const expected_delete_assign_base &) = delete;
-  expected_delete_assign_base &
-  operator=(expected_delete_assign_base &&) noexcept = delete;
-};
-
-// This is needed to be able to construct the expected_default_ctor_base which
-// follows, while still conditionally deleting the default constructor.
-struct default_constructor_tag {
-  explicit constexpr default_constructor_tag() = default;
-};
-
-// expected_default_ctor_base will ensure that expected has a deleted default
-// consturctor if T is not default constructible.
-// This specialization is for when T is default constructible
-template <class T, class E,
-          bool Enable =
-              std::is_default_constructible<T>::value || std::is_void<T>::value>
-struct expected_default_ctor_base {
-  constexpr expected_default_ctor_base() noexcept = default;
-  constexpr expected_default_ctor_base(
-      expected_default_ctor_base const &) noexcept = default;
-  constexpr expected_default_ctor_base(expected_default_ctor_base &&) noexcept =
-      default;
-  expected_default_ctor_base &
-  operator=(expected_default_ctor_base const &) noexcept = default;
-  expected_default_ctor_base &
-  operator=(expected_default_ctor_base &&) noexcept = default;
-
-  constexpr explicit expected_default_ctor_base(default_constructor_tag) {}
-};
-
-// This specialization is for when T is not default constructible
-template <class T, class E> struct expected_default_ctor_base<T, E, false> {
-  constexpr expected_default_ctor_base() noexcept = delete;
-  constexpr expected_default_ctor_base(
-      expected_default_ctor_base const &) noexcept = default;
-  constexpr expected_default_ctor_base(expected_default_ctor_base &&) noexcept =
-      default;
-  expected_default_ctor_base &
-  operator=(expected_default_ctor_base const &) noexcept = default;
-  expected_default_ctor_base &
-  operator=(expected_default_ctor_base &&) noexcept = default;
-
-  constexpr explicit expected_default_ctor_base(default_constructor_tag) {}
-};
-} // namespace detail
-
-template <class E> class bad_expected_access : public std::exception {
-public:
-  explicit bad_expected_access(E e) : m_val(std::move(e)) {}
-
-  virtual const char *what() const noexcept override {
-    return "Bad expected access";
-  }
-
-  const E &error() const & { return m_val; }
-  E &error() & { return m_val; }
-  const E &&error() const && { return std::move(m_val); }
-  E &&error() && { return std::move(m_val); }
-
-private:
-  E m_val;
-};
-
-/// An `expected<T, E>` object is an object that contains the storage for
-/// another object and manages the lifetime of this contained object `T`.
-/// Alternatively it could contain the storage for another unexpected object
-/// `E`. The contained object may not be initialized after the expected object
-/// has been initialized, and may not be destroyed before the expected object
-/// has been destroyed. The initialization state of the contained object is
-/// tracked by the expected object.
-template <class T, class E>
-class expected : private detail::expected_move_assign_base<T, E>,
-                 private detail::expected_delete_ctor_base<T, E>,
-                 private detail::expected_delete_assign_base<T, E>,
-                 private detail::expected_default_ctor_base<T, E> {
-  static_assert(!std::is_reference<T>::value, "T must not be a reference");
-  static_assert(!std::is_same<T, std::remove_cv<in_place_t>::type>::value,
-                "T must not be in_place_t");
-  static_assert(!std::is_same<T, std::remove_cv<unexpect_t>::type>::value,
-                "T must not be unexpect_t");
-  static_assert(
-      !std::is_same<T, typename std::remove_cv<unexpected<E>>::type>::value,
-      "T must not be unexpected<E>");
-  static_assert(!std::is_reference<E>::value, "E must not be a reference");
-
-  T *valptr() { return std::addressof(this->m_val); }
-  const T *valptr() const { return std::addressof(this->m_val); }
-  unexpected<E> *errptr() { return std::addressof(this->m_unexpect); }
-  const unexpected<E> *errptr() const {
-    return std::addressof(this->m_unexpect);
-  }
-
-  template <class U = T,
-            detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
-  TL_EXPECTED_11_CONSTEXPR U &val() {
-    return this->m_val;
-  }
-  TL_EXPECTED_11_CONSTEXPR unexpected<E> &err() { return this->m_unexpect; }
-
-  template <class U = T,
-            detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
-  constexpr const U &val() const {
-    return this->m_val;
-  }
-  constexpr const unexpected<E> &err() const { return this->m_unexpect; }
-
-  using impl_base = detail::expected_move_assign_base<T, E>;
-  using ctor_base = detail::expected_default_ctor_base<T, E>;
-
-public:
-  typedef T value_type;
-  typedef E error_type;
-  typedef unexpected<E> unexpected_type;
-
-#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) &&               \
-    !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55)
-  template <class F> TL_EXPECTED_11_CONSTEXPR auto and_then(F &&f) & {
-    return and_then_impl(*this, std::forward<F>(f));
-  }
-  template <class F> TL_EXPECTED_11_CONSTEXPR auto and_then(F &&f) && {
-    return and_then_impl(std::move(*this), std::forward<F>(f));
-  }
-  template <class F> constexpr auto and_then(F &&f) const & {
-    return and_then_impl(*this, std::forward<F>(f));
-  }
-
-#ifndef TL_EXPECTED_NO_CONSTRR
-  template <class F> constexpr auto and_then(F &&f) const && {
-    return and_then_impl(std::move(*this), std::forward<F>(f));
-  }
-#endif
-
-#else
-  template <class F>
-  TL_EXPECTED_11_CONSTEXPR auto
-  and_then(F &&f) & -> decltype(and_then_impl(std::declval<expected &>(),
-                                              std::forward<F>(f))) {
-    return and_then_impl(*this, std::forward<F>(f));
-  }
-  template <class F>
-  TL_EXPECTED_11_CONSTEXPR auto
-  and_then(F &&f) && -> decltype(and_then_impl(std::declval<expected &&>(),
-                                               std::forward<F>(f))) {
-    return and_then_impl(std::move(*this), std::forward<F>(f));
-  }
-  template <class F>
-  constexpr auto and_then(F &&f) const & -> decltype(and_then_impl(
-      std::declval<expected const &>(), std::forward<F>(f))) {
-    return and_then_impl(*this, std::forward<F>(f));
-  }
-
-#ifndef TL_EXPECTED_NO_CONSTRR
-  template <class F>
-  constexpr auto and_then(F &&f) const && -> decltype(and_then_impl(
-      std::declval<expected const &&>(), std::forward<F>(f))) {
-    return and_then_impl(std::move(*this), std::forward<F>(f));
-  }
-#endif
-#endif
-
-#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) &&               \
-    !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55)
-  template <class F> TL_EXPECTED_11_CONSTEXPR auto map(F &&f) & {
-    return expected_map_impl(*this, std::forward<F>(f));
-  }
-  template <class F> TL_EXPECTED_11_CONSTEXPR auto map(F &&f) && {
-    return expected_map_impl(std::move(*this), std::forward<F>(f));
-  }
-  template <class F> constexpr auto map(F &&f) const & {
-    return expected_map_impl(*this, std::forward<F>(f));
-  }
-  template <class F> constexpr auto map(F &&f) const && {
-    return expected_map_impl(std::move(*this), std::forward<F>(f));
-  }
-#else
-  template <class F>
-  TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl(
-      std::declval<expected &>(), std::declval<F &&>()))
-  map(F &&f) & {
-    return expected_map_impl(*this, std::forward<F>(f));
-  }
-  template <class F>
-  TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl(std::declval<expected>(),
-                                                      std::declval<F &&>()))
-  map(F &&f) && {
-    return expected_map_impl(std::move(*this), std::forward<F>(f));
-  }
-  template <class F>
-  constexpr decltype(expected_map_impl(std::declval<const expected &>(),
-                                       std::declval<F &&>()))
-  map(F &&f) const & {
-    return expected_map_impl(*this, std::forward<F>(f));
-  }
-
-#ifndef TL_EXPECTED_NO_CONSTRR
-  template <class F>
-  constexpr decltype(expected_map_impl(std::declval<const expected &&>(),
-                                       std::declval<F &&>()))
-  map(F &&f) const && {
-    return expected_map_impl(std::move(*this), std::forward<F>(f));
-  }
-#endif
-#endif
-
-#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) &&               \
-    !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55)
-  template <class F> TL_EXPECTED_11_CONSTEXPR auto transform(F &&f) & {
-    return expected_map_impl(*this, std::forward<F>(f));
-  }
-  template <class F> TL_EXPECTED_11_CONSTEXPR auto transform(F &&f) && {
-    return expected_map_impl(std::move(*this), std::forward<F>(f));
-  }
-  template <class F> constexpr auto transform(F &&f) const & {
-    return expected_map_impl(*this, std::forward<F>(f));
-  }
-  template <class F> constexpr auto transform(F &&f) const && {
-    return expected_map_impl(std::move(*this), std::forward<F>(f));
-  }
-#else
-  template <class F>
-  TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl(
-      std::declval<expected &>(), std::declval<F &&>()))
-  transform(F &&f) & {
-    return expected_map_impl(*this, std::forward<F>(f));
-  }
-  template <class F>
-  TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl(std::declval<expected>(),
-                                                      std::declval<F &&>()))
-  transform(F &&f) && {
-    return expected_map_impl(std::move(*this), std::forward<F>(f));
-  }
-  template <class F>
-  constexpr decltype(expected_map_impl(std::declval<const expected &>(),
-                                       std::declval<F &&>()))
-  transform(F &&f) const & {
-    return expected_map_impl(*this, std::forward<F>(f));
-  }
-
-#ifndef TL_EXPECTED_NO_CONSTRR
-  template <class F>
-  constexpr decltype(expected_map_impl(std::declval<const expected &&>(),
-                                       std::declval<F &&>()))
-  transform(F &&f) const && {
-    return expected_map_impl(std::move(*this), std::forward<F>(f));
-  }
-#endif
-#endif
-
-#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) &&               \
-    !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55)
-  template <class F> TL_EXPECTED_11_CONSTEXPR auto map_error(F &&f) & {
-    return map_error_impl(*this, std::forward<F>(f));
-  }
-  template <class F> TL_EXPECTED_11_CONSTEXPR auto map_error(F &&f) && {
-    return map_error_impl(std::move(*this), std::forward<F>(f));
-  }
-  template <class F> constexpr auto map_error(F &&f) const & {
-    return map_error_impl(*this, std::forward<F>(f));
-  }
-  template <class F> constexpr auto map_error(F &&f) const && {
-    return map_error_impl(std::move(*this), std::forward<F>(f));
-  }
-#else
-  template <class F>
-  TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &>(),
-                                                   std::declval<F &&>()))
-  map_error(F &&f) & {
-    return map_error_impl(*this, std::forward<F>(f));
-  }
-  template <class F>
-  TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &&>(),
-                                                   std::declval<F &&>()))
-  map_error(F &&f) && {
-    return map_error_impl(std::move(*this), std::forward<F>(f));
-  }
-  template <class F>
-  constexpr decltype(map_error_impl(std::declval<const expected &>(),
-                                    std::declval<F &&>()))
-  map_error(F &&f) const & {
-    return map_error_impl(*this, std::forward<F>(f));
-  }
-
-#ifndef TL_EXPECTED_NO_CONSTRR
-  template <class F>
-  constexpr decltype(map_error_impl(std::declval<const expected &&>(),
-                                    std::declval<F &&>()))
-  map_error(F &&f) const && {
-    return map_error_impl(std::move(*this), std::forward<F>(f));
-  }
-#endif
-#endif
-#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) &&               \
-    !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55)
-  template <class F> TL_EXPECTED_11_CONSTEXPR auto transform_error(F &&f) & {
-    return map_error_impl(*this, std::forward<F>(f));
-  }
-  template <class F> TL_EXPECTED_11_CONSTEXPR auto transform_error(F &&f) && {
-    return map_error_impl(std::move(*this), std::forward<F>(f));
-  }
-  template <class F> constexpr auto transform_error(F &&f) const & {
-    return map_error_impl(*this, std::forward<F>(f));
-  }
-  template <class F> constexpr auto transform_error(F &&f) const && {
-    return map_error_impl(std::move(*this), std::forward<F>(f));
-  }
-#else
-  template <class F>
-  TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &>(),
-                                                   std::declval<F &&>()))
-  transform_error(F &&f) & {
-    return map_error_impl(*this, std::forward<F>(f));
-  }
-  template <class F>
-  TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &&>(),
-                                                   std::declval<F &&>()))
-  transform_error(F &&f) && {
-    return map_error_impl(std::move(*this), std::forward<F>(f));
-  }
-  template <class F>
-  constexpr decltype(map_error_impl(std::declval<const expected &>(),
-                                    std::declval<F &&>()))
-  transform_error(F &&f) const & {
-    return map_error_impl(*this, std::forward<F>(f));
-  }
-
-#ifndef TL_EXPECTED_NO_CONSTRR
-  template <class F>
-  constexpr decltype(map_error_impl(std::declval<const expected &&>(),
-                                    std::declval<F &&>()))
-  transform_error(F &&f) const && {
-    return map_error_impl(std::move(*this), std::forward<F>(f));
-  }
-#endif
-#endif
-  template <class F> expected TL_EXPECTED_11_CONSTEXPR or_else(F &&f) & {
-    return or_else_impl(*this, std::forward<F>(f));
-  }
-
-  template <class F> expected TL_EXPECTED_11_CONSTEXPR or_else(F &&f) && {
-    return or_else_impl(std::move(*this), std::forward<F>(f));
-  }
-
-  template <class F> expected constexpr or_else(F &&f) const & {
-    return or_else_impl(*this, std::forward<F>(f));
-  }
-
-#ifndef TL_EXPECTED_NO_CONSTRR
-  template <class F> expected constexpr or_else(F &&f) const && {
-    return or_else_impl(std::move(*this), std::forward<F>(f));
-  }
-#endif
-  constexpr expected() = default;
-  constexpr expected(const expected &rhs) = default;
-  constexpr expected(expected &&rhs) = default;
-  expected &operator=(const expected &rhs) = default;
-  expected &operator=(expected &&rhs) = default;
-
-  template <class... Args,
-            detail::enable_if_t<std::is_constructible<T, Args &&...>::value> * =
-                nullptr>
-  constexpr expected(in_place_t, Args &&...args)
-      : impl_base(in_place, std::forward<Args>(args)...),
-        ctor_base(detail::default_constructor_tag{}) {}
-
-  template <class U, class... Args,
-            detail::enable_if_t<std::is_constructible<
-                T, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-  constexpr expected(in_place_t, std::initializer_list<U> il, Args &&...args)
-      : impl_base(in_place, il, std::forward<Args>(args)...),
-        ctor_base(detail::default_constructor_tag{}) {}
-
-  template <class G = E,
-            detail::enable_if_t<std::is_constructible<E, const G &>::value> * =
-                nullptr,
-            detail::enable_if_t<!std::is_convertible<const G &, E>::value> * =
-                nullptr>
-  explicit constexpr expected(const unexpected<G> &e)
-      : impl_base(unexpect, e.value()),
-        ctor_base(detail::default_constructor_tag{}) {}
-
-  template <
-      class G = E,
-      detail::enable_if_t<std::is_constructible<E, const G &>::value> * =
-          nullptr,
-      detail::enable_if_t<std::is_convertible<const G &, E>::value> * = nullptr>
-  constexpr expected(unexpected<G> const &e)
-      : impl_base(unexpect, e.value()),
-        ctor_base(detail::default_constructor_tag{}) {}
-
-  template <
-      class G = E,
-      detail::enable_if_t<std::is_constructible<E, G &&>::value> * = nullptr,
-      detail::enable_if_t<!std::is_convertible<G &&, E>::value> * = nullptr>
-  explicit constexpr expected(unexpected<G> &&e) noexcept(
-      std::is_nothrow_constructible<E, G &&>::value)
-      : impl_base(unexpect, std::move(e.value())),
-        ctor_base(detail::default_constructor_tag{}) {}
-
-  template <
-      class G = E,
-      detail::enable_if_t<std::is_constructible<E, G &&>::value> * = nullptr,
-      detail::enable_if_t<std::is_convertible<G &&, E>::value> * = nullptr>
-  constexpr expected(unexpected<G> &&e) noexcept(
-      std::is_nothrow_constructible<E, G &&>::value)
-      : impl_base(unexpect, std::move(e.value())),
-        ctor_base(detail::default_constructor_tag{}) {}
-
-  template <class... Args,
-            detail::enable_if_t<std::is_constructible<E, Args &&...>::value> * =
-                nullptr>
-  constexpr explicit expected(unexpect_t, Args &&...args)
-      : impl_base(unexpect, std::forward<Args>(args)...),
-        ctor_base(detail::default_constructor_tag{}) {}
-
-  template <class U, class... Args,
-            detail::enable_if_t<std::is_constructible<
-                E, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-  constexpr explicit expected(unexpect_t, std::initializer_list<U> il,
-                              Args &&...args)
-      : impl_base(unexpect, il, std::forward<Args>(args)...),
-        ctor_base(detail::default_constructor_tag{}) {}
-
-  template <class U, class G,
-            detail::enable_if_t<!(std::is_convertible<U const &, T>::value &&
-                                  std::is_convertible<G const &, E>::value)> * =
-                nullptr,
-            detail::expected_enable_from_other<T, E, U, G, const U &, const G &>
-                * = nullptr>
-  explicit TL_EXPECTED_11_CONSTEXPR expected(const expected<U, G> &rhs)
-      : ctor_base(detail::default_constructor_tag{}) {
-    if (rhs.has_value()) {
-      this->construct(*rhs);
-    } else {
-      this->construct_error(rhs.error());
-    }
-  }
-
-  template <class U, class G,
-            detail::enable_if_t<(std::is_convertible<U const &, T>::value &&
-                                 std::is_convertible<G const &, E>::value)> * =
-                nullptr,
-            detail::expected_enable_from_other<T, E, U, G, const U &, const G &>
-                * = nullptr>
-  TL_EXPECTED_11_CONSTEXPR expected(const expected<U, G> &rhs)
-      : ctor_base(detail::default_constructor_tag{}) {
-    if (rhs.has_value()) {
-      this->construct(*rhs);
-    } else {
-      this->construct_error(rhs.error());
-    }
-  }
-
-  template <
-      class U, class G,
-      detail::enable_if_t<!(std::is_convertible<U &&, T>::value &&
-                            std::is_convertible<G &&, E>::value)> * = nullptr,
-      detail::expected_enable_from_other<T, E, U, G, U &&, G &&> * = nullptr>
-  explicit TL_EXPECTED_11_CONSTEXPR expected(expected<U, G> &&rhs)
-      : ctor_base(detail::default_constructor_tag{}) {
-    if (rhs.has_value()) {
-      this->construct(std::move(*rhs));
-    } else {
-      this->construct_error(std::move(rhs.error()));
-    }
-  }
-
-  template <
-      class U, class G,
-      detail::enable_if_t<(std::is_convertible<U &&, T>::value &&
-                           std::is_convertible<G &&, E>::value)> * = nullptr,
-      detail::expected_enable_from_other<T, E, U, G, U &&, G &&> * = nullptr>
-  TL_EXPECTED_11_CONSTEXPR expected(expected<U, G> &&rhs)
-      : ctor_base(detail::default_constructor_tag{}) {
-    if (rhs.has_value()) {
-      this->construct(std::move(*rhs));
-    } else {
-      this->construct_error(std::move(rhs.error()));
-    }
-  }
-
-  template <
-      class U = T,
-      detail::enable_if_t<!std::is_convertible<U &&, T>::value> * = nullptr,
-      detail::expected_enable_forward_value<T, E, U> * = nullptr>
-  explicit TL_EXPECTED_MSVC2015_CONSTEXPR expected(U &&v)
-      : expected(in_place, std::forward<U>(v)) {}
-
-  template <
-      class U = T,
-      detail::enable_if_t<std::is_convertible<U &&, T>::value> * = nullptr,
-      detail::expected_enable_forward_value<T, E, U> * = nullptr>
-  TL_EXPECTED_MSVC2015_CONSTEXPR expected(U &&v)
-      : expected(in_place, std::forward<U>(v)) {}
-
-  template <
-      class U = T, class G = T,
-      detail::enable_if_t<std::is_nothrow_constructible<T, U &&>::value> * =
-          nullptr,
-      detail::enable_if_t<!std::is_void<G>::value> * = nullptr,
-      detail::enable_if_t<
-          (!std::is_same<expected<T, E>, detail::decay_t<U>>::value &&
-           !detail::conjunction<std::is_scalar<T>,
-                                std::is_same<T, detail::decay_t<U>>>::value &&
-           std::is_constructible<T, U>::value &&
-           std::is_assignable<G &, U>::value &&
-           std::is_nothrow_move_constructible<E>::value)> * = nullptr>
-  expected &operator=(U &&v) {
-    if (has_value()) {
-      val() = std::forward<U>(v);
-    } else {
-      err().~unexpected<E>();
-      ::new (valptr()) T(std::forward<U>(v));
-      this->m_has_val = true;
-    }
-
-    return *this;
-  }
-
-  template <
-      class U = T, class G = T,
-      detail::enable_if_t<!std::is_nothrow_constructible<T, U &&>::value> * =
-          nullptr,
-      detail::enable_if_t<!std::is_void<U>::value> * = nullptr,
-      detail::enable_if_t<
-          (!std::is_same<expected<T, E>, detail::decay_t<U>>::value &&
-           !detail::conjunction<std::is_scalar<T>,
-                                std::is_same<T, detail::decay_t<U>>>::value &&
-           std::is_constructible<T, U>::value &&
-           std::is_assignable<G &, U>::value &&
-           std::is_nothrow_move_constructible<E>::value)> * = nullptr>
-  expected &operator=(U &&v) {
-    if (has_value()) {
-      val() = std::forward<U>(v);
-    } else {
-      auto tmp = std::move(err());
-      err().~unexpected<E>();
-
-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
-      try {
-        ::new (valptr()) T(std::forward<U>(v));
-        this->m_has_val = true;
-      } catch (...) {
-        err() = std::move(tmp);
-        throw;
-      }
-#else
-      ::new (valptr()) T(std::forward<U>(v));
-      this->m_has_val = true;
-#endif
-    }
-
-    return *this;
-  }
-
-  template <class G = E,
-            detail::enable_if_t<std::is_nothrow_copy_constructible<G>::value &&
-                                std::is_assignable<G &, G>::value> * = nullptr>
-  expected &operator=(const unexpected<G> &rhs) {
-    if (!has_value()) {
-      err() = rhs;
-    } else {
-      this->destroy_val();
-      ::new (errptr()) unexpected<E>(rhs);
-      this->m_has_val = false;
-    }
-
-    return *this;
-  }
-
-  template <class G = E,
-            detail::enable_if_t<std::is_nothrow_move_constructible<G>::value &&
-                                std::is_move_assignable<G>::value> * = nullptr>
-  expected &operator=(unexpected<G> &&rhs) noexcept {
-    if (!has_value()) {
-      err() = std::move(rhs);
-    } else {
-      this->destroy_val();
-      ::new (errptr()) unexpected<E>(std::move(rhs));
-      this->m_has_val = false;
-    }
-
-    return *this;
-  }
-
-  template <class... Args, detail::enable_if_t<std::is_nothrow_constructible<
-                               T, Args &&...>::value> * = nullptr>
-  void emplace(Args &&...args) {
-    if (has_value()) {
-      val().~T();
-    } else {
-      err().~unexpected<E>();
-      this->m_has_val = true;
-    }
-    ::new (valptr()) T(std::forward<Args>(args)...);
-  }
-
-  template <class... Args, detail::enable_if_t<!std::is_nothrow_constructible<
-                               T, Args &&...>::value> * = nullptr>
-  void emplace(Args &&...args) {
-    if (has_value()) {
-      val().~T();
-      ::new (valptr()) T(std::forward<Args>(args)...);
-    } else {
-      auto tmp = std::move(err());
-      err().~unexpected<E>();
-
-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
-      try {
-        ::new (valptr()) T(std::forward<Args>(args)...);
-        this->m_has_val = true;
-      } catch (...) {
-        err() = std::move(tmp);
-        throw;
-      }
-#else
-      ::new (valptr()) T(std::forward<Args>(args)...);
-      this->m_has_val = true;
-#endif
-    }
-  }
-
-  template <class U, class... Args,
-            detail::enable_if_t<std::is_nothrow_constructible<
-                T, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-  void emplace(std::initializer_list<U> il, Args &&...args) {
-    if (has_value()) {
-      T t(il, std::forward<Args>(args)...);
-      val() = std::move(t);
-    } else {
-      err().~unexpected<E>();
-      ::new (valptr()) T(il, std::forward<Args>(args)...);
-      this->m_has_val = true;
-    }
-  }
-
-  template <class U, class... Args,
-            detail::enable_if_t<!std::is_nothrow_constructible<
-                T, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-  void emplace(std::initializer_list<U> il, Args &&...args) {
-    if (has_value()) {
-      T t(il, std::forward<Args>(args)...);
-      val() = std::move(t);
-    } else {
-      auto tmp = std::move(err());
-      err().~unexpected<E>();
-
-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
-      try {
-        ::new (valptr()) T(il, std::forward<Args>(args)...);
-        this->m_has_val = true;
-      } catch (...) {
-        err() = std::move(tmp);
-        throw;
-      }
-#else
-      ::new (valptr()) T(il, std::forward<Args>(args)...);
-      this->m_has_val = true;
-#endif
-    }
-  }
-
-private:
-  using t_is_void = std::true_type;
-  using t_is_not_void = std::false_type;
-  using t_is_nothrow_move_constructible = std::true_type;
-  using move_constructing_t_can_throw = std::false_type;
-  using e_is_nothrow_move_constructible = std::true_type;
-  using move_constructing_e_can_throw = std::false_type;
-
-  void swap_where_both_have_value(expected & /*rhs*/, t_is_void) noexcept {
-    // swapping void is a no-op
-  }
-
-  void swap_where_both_have_value(expected &rhs, t_is_not_void) {
-    using std::swap;
-    swap(val(), rhs.val());
-  }
-
-  void swap_where_only_one_has_value(expected &rhs, t_is_void) noexcept(
-      std::is_nothrow_move_constructible<E>::value) {
-    ::new (errptr()) unexpected_type(std::move(rhs.err()));
-    rhs.err().~unexpected_type();
-    std::swap(this->m_has_val, rhs.m_has_val);
-  }
-
-  void swap_where_only_one_has_value(expected &rhs, t_is_not_void) {
-    swap_where_only_one_has_value_and_t_is_not_void(
-        rhs, typename std::is_nothrow_move_constructible<T>::type{},
-        typename std::is_nothrow_move_constructible<E>::type{});
-  }
-
-  void swap_where_only_one_has_value_and_t_is_not_void(
-      expected &rhs, t_is_nothrow_move_constructible,
-      e_is_nothrow_move_constructible) noexcept {
-    auto temp = std::move(val());
-    val().~T();
-    ::new (errptr()) unexpected_type(std::move(rhs.err()));
-    rhs.err().~unexpected_type();
-    ::new (rhs.valptr()) T(std::move(temp));
-    std::swap(this->m_has_val, rhs.m_has_val);
-  }
-
-  void swap_where_only_one_has_value_and_t_is_not_void(
-      expected &rhs, t_is_nothrow_move_constructible,
-      move_constructing_e_can_throw) {
-    auto temp = std::move(val());
-    val().~T();
-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
-    try {
-      ::new (errptr()) unexpected_type(std::move(rhs.err()));
-      rhs.err().~unexpected_type();
-      ::new (rhs.valptr()) T(std::move(temp));
-      std::swap(this->m_has_val, rhs.m_has_val);
-    } catch (...) {
-      val() = std::move(temp);
-      throw;
-    }
-#else
-    ::new (errptr()) unexpected_type(std::move(rhs.err()));
-    rhs.err().~unexpected_type();
-    ::new (rhs.valptr()) T(std::move(temp));
-    std::swap(this->m_has_val, rhs.m_has_val);
-#endif
-  }
-
-  void swap_where_only_one_has_value_and_t_is_not_void(
-      expected &rhs, move_constructing_t_can_throw,
-      e_is_nothrow_move_constructible) {
-    auto temp = std::move(rhs.err());
-    rhs.err().~unexpected_type();
-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
-    try {
-      ::new (rhs.valptr()) T(std::move(val()));
-      val().~T();
-      ::new (errptr()) unexpected_type(std::move(temp));
-      std::swap(this->m_has_val, rhs.m_has_val);
-    } catch (...) {
-      rhs.err() = std::move(temp);
-      throw;
-    }
-#else
-    ::new (rhs.valptr()) T(std::move(val()));
-    val().~T();
-    ::new (errptr()) unexpected_type(std::move(temp));
-    std::swap(this->m_has_val, rhs.m_has_val);
-#endif
-  }
-
-public:
-  template <class OT = T, class OE = E>
-  detail::enable_if_t<detail::is_swappable<OT>::value &&
-                      detail::is_swappable<OE>::value &&
-                      (std::is_nothrow_move_constructible<OT>::value ||
-                       std::is_nothrow_move_constructible<OE>::value)>
-  swap(expected &rhs) noexcept(std::is_nothrow_move_constructible<T>::value &&
-                               detail::is_nothrow_swappable<T>::value &&
-                               std::is_nothrow_move_constructible<E>::value &&
-                               detail::is_nothrow_swappable<E>::value) {
-    if (has_value() && rhs.has_value()) {
-      swap_where_both_have_value(rhs, typename std::is_void<T>::type{});
-    } else if (!has_value() && rhs.has_value()) {
-      rhs.swap(*this);
-    } else if (has_value()) {
-      swap_where_only_one_has_value(rhs, typename std::is_void<T>::type{});
-    } else {
-      using std::swap;
-      swap(err(), rhs.err());
-    }
-  }
-
-  constexpr const T *operator->() const {
-    TL_ASSERT(has_value());
-    return valptr();
-  }
-  TL_EXPECTED_11_CONSTEXPR T *operator->() {
-    TL_ASSERT(has_value());
-    return valptr();
-  }
-
-  template <class U = T,
-            detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
-  constexpr const U &operator*() const & {
-    TL_ASSERT(has_value());
-    return val();
-  }
-  template <class U = T,
-            detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
-  TL_EXPECTED_11_CONSTEXPR U &operator*() & {
-    TL_ASSERT(has_value());
-    return val();
-  }
-  template <class U = T,
-            detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
-  constexpr const U &&operator*() const && {
-    TL_ASSERT(has_value());
-    return std::move(val());
-  }
-  template <class U = T,
-            detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
-  TL_EXPECTED_11_CONSTEXPR U &&operator*() && {
-    TL_ASSERT(has_value());
-    return std::move(val());
-  }
-
-  constexpr bool has_value() const noexcept { return this->m_has_val; }
-  constexpr explicit operator bool() const noexcept { return this->m_has_val; }
-
-  template <class U = T,
-            detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
-  TL_EXPECTED_11_CONSTEXPR const U &value() const & {
-    if (!has_value())
-      detail::throw_exception(bad_expected_access<E>(err().value()));
-    return val();
-  }
-  template <class U = T,
-            detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
-  TL_EXPECTED_11_CONSTEXPR U &value() & {
-    if (!has_value())
-      detail::throw_exception(bad_expected_access<E>(err().value()));
-    return val();
-  }
-  template <class U = T,
-            detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
-  TL_EXPECTED_11_CONSTEXPR const U &&value() const && {
-    if (!has_value())
-      detail::throw_exception(bad_expected_access<E>(std::move(err()).value()));
-    return std::move(val());
-  }
-  template <class U = T,
-            detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
-  TL_EXPECTED_11_CONSTEXPR U &&value() && {
-    if (!has_value())
-      detail::throw_exception(bad_expected_access<E>(std::move(err()).value()));
-    return std::move(val());
-  }
-
-  constexpr const E &error() const & {
-    TL_ASSERT(!has_value());
-    return err().value();
-  }
-  TL_EXPECTED_11_CONSTEXPR E &error() & {
-    TL_ASSERT(!has_value());
-    return err().value();
-  }
-  constexpr const E &&error() const && {
-    TL_ASSERT(!has_value());
-    return std::move(err().value());
-  }
-  TL_EXPECTED_11_CONSTEXPR E &&error() && {
-    TL_ASSERT(!has_value());
-    return std::move(err().value());
-  }
-
-  template <class U> constexpr T value_or(U &&v) const & {
-    static_assert(std::is_copy_constructible<T>::value &&
-                      std::is_convertible<U &&, T>::value,
-                  "T must be copy-constructible and convertible to from U&&");
-    return bool(*this) ? **this : static_cast<T>(std::forward<U>(v));
-  }
-  template <class U> TL_EXPECTED_11_CONSTEXPR T value_or(U &&v) && {
-    static_assert(std::is_move_constructible<T>::value &&
-                      std::is_convertible<U &&, T>::value,
-                  "T must be move-constructible and convertible to from U&&");
-    return bool(*this) ? std::move(**this) : static_cast<T>(std::forward<U>(v));
-  }
-};
-
-namespace detail {
-template <class Exp> using exp_t = typename detail::decay_t<Exp>::value_type;
-template <class Exp> using err_t = typename detail::decay_t<Exp>::error_type;
-template <class Exp, class Ret> using ret_t = expected<Ret, err_t<Exp>>;
-
-#ifdef TL_EXPECTED_CXX14
-template <class Exp, class F,
-          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              *std::declval<Exp>()))>
-constexpr auto and_then_impl(Exp &&exp, F &&f) {
-  static_assert(detail::is_expected<Ret>::value, "F must return an expected");
-
-  return exp.has_value()
-             ? detail::invoke(std::forward<F>(f), *std::forward<Exp>(exp))
-             : Ret(unexpect, std::forward<Exp>(exp).error());
-}
-
-template <class Exp, class F,
-          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
-          class Ret = decltype(detail::invoke(std::declval<F>()))>
-constexpr auto and_then_impl(Exp &&exp, F &&f) {
-  static_assert(detail::is_expected<Ret>::value, "F must return an expected");
-
-  return exp.has_value() ? detail::invoke(std::forward<F>(f))
-                         : Ret(unexpect, std::forward<Exp>(exp).error());
-}
-#else
-template <class> struct TC;
-template <class Exp, class F,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              *std::declval<Exp>())),
-          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr>
-auto and_then_impl(Exp &&exp, F &&f) -> Ret {
-  static_assert(detail::is_expected<Ret>::value, "F must return an expected");
-
-  return exp.has_value()
-             ? detail::invoke(std::forward<F>(f), *std::forward<Exp>(exp))
-             : Ret(unexpect, std::forward<Exp>(exp).error());
-}
-
-template <class Exp, class F,
-          class Ret = decltype(detail::invoke(std::declval<F>())),
-          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr>
-constexpr auto and_then_impl(Exp &&exp, F &&f) -> Ret {
-  static_assert(detail::is_expected<Ret>::value, "F must return an expected");
-
-  return exp.has_value() ? detail::invoke(std::forward<F>(f))
-                         : Ret(unexpect, std::forward<Exp>(exp).error());
-}
-#endif
-
-#ifdef TL_EXPECTED_CXX14
-template <class Exp, class F,
-          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              *std::declval<Exp>())),
-          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-constexpr auto expected_map_impl(Exp &&exp, F &&f) {
-  using result = ret_t<Exp, detail::decay_t<Ret>>;
-  return exp.has_value() ? result(detail::invoke(std::forward<F>(f),
-                                                 *std::forward<Exp>(exp)))
-                         : result(unexpect, std::forward<Exp>(exp).error());
-}
-
-template <class Exp, class F,
-          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              *std::declval<Exp>())),
-          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-auto expected_map_impl(Exp &&exp, F &&f) {
-  using result = expected<void, err_t<Exp>>;
-  if (exp.has_value()) {
-    detail::invoke(std::forward<F>(f), *std::forward<Exp>(exp));
-    return result();
-  }
-
-  return result(unexpect, std::forward<Exp>(exp).error());
-}
-
-template <class Exp, class F,
-          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
-          class Ret = decltype(detail::invoke(std::declval<F>())),
-          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-constexpr auto expected_map_impl(Exp &&exp, F &&f) {
-  using result = ret_t<Exp, detail::decay_t<Ret>>;
-  return exp.has_value() ? result(detail::invoke(std::forward<F>(f)))
-                         : result(unexpect, std::forward<Exp>(exp).error());
-}
-
-template <class Exp, class F,
-          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
-          class Ret = decltype(detail::invoke(std::declval<F>())),
-          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-auto expected_map_impl(Exp &&exp, F &&f) {
-  using result = expected<void, err_t<Exp>>;
-  if (exp.has_value()) {
-    detail::invoke(std::forward<F>(f));
-    return result();
-  }
-
-  return result(unexpect, std::forward<Exp>(exp).error());
-}
-#else
-template <class Exp, class F,
-          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              *std::declval<Exp>())),
-          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-
-constexpr auto expected_map_impl(Exp &&exp, F &&f)
-    -> ret_t<Exp, detail::decay_t<Ret>> {
-  using result = ret_t<Exp, detail::decay_t<Ret>>;
-
-  return exp.has_value() ? result(detail::invoke(std::forward<F>(f),
-                                                 *std::forward<Exp>(exp)))
-                         : result(unexpect, std::forward<Exp>(exp).error());
-}
-
-template <class Exp, class F,
-          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              *std::declval<Exp>())),
-          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-
-auto expected_map_impl(Exp &&exp, F &&f) -> expected<void, err_t<Exp>> {
-  if (exp.has_value()) {
-    detail::invoke(std::forward<F>(f), *std::forward<Exp>(exp));
-    return {};
-  }
-
-  return unexpected<err_t<Exp>>(std::forward<Exp>(exp).error());
-}
-
-template <class Exp, class F,
-          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
-          class Ret = decltype(detail::invoke(std::declval<F>())),
-          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-
-constexpr auto expected_map_impl(Exp &&exp, F &&f)
-    -> ret_t<Exp, detail::decay_t<Ret>> {
-  using result = ret_t<Exp, detail::decay_t<Ret>>;
-
-  return exp.has_value() ? result(detail::invoke(std::forward<F>(f)))
-                         : result(unexpect, std::forward<Exp>(exp).error());
-}
-
-template <class Exp, class F,
-          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
-          class Ret = decltype(detail::invoke(std::declval<F>())),
-          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-
-auto expected_map_impl(Exp &&exp, F &&f) -> expected<void, err_t<Exp>> {
-  if (exp.has_value()) {
-    detail::invoke(std::forward<F>(f));
-    return {};
-  }
-
-  return unexpected<err_t<Exp>>(std::forward<Exp>(exp).error());
-}
-#endif
-
-#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) &&               \
-    !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55)
-template <class Exp, class F,
-          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              std::declval<Exp>().error())),
-          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-constexpr auto map_error_impl(Exp &&exp, F &&f) {
-  using result = expected<exp_t<Exp>, detail::decay_t<Ret>>;
-  return exp.has_value()
-             ? result(*std::forward<Exp>(exp))
-             : result(unexpect, detail::invoke(std::forward<F>(f),
-                                               std::forward<Exp>(exp).error()));
-}
-template <class Exp, class F,
-          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              std::declval<Exp>().error())),
-          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-auto map_error_impl(Exp &&exp, F &&f) {
-  using result = expected<exp_t<Exp>, monostate>;
-  if (exp.has_value()) {
-    return result(*std::forward<Exp>(exp));
-  }
-
-  detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
-  return result(unexpect, monostate{});
-}
-template <class Exp, class F,
-          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              std::declval<Exp>().error())),
-          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-constexpr auto map_error_impl(Exp &&exp, F &&f) {
-  using result = expected<exp_t<Exp>, detail::decay_t<Ret>>;
-  return exp.has_value()
-             ? result()
-             : result(unexpect, detail::invoke(std::forward<F>(f),
-                                               std::forward<Exp>(exp).error()));
-}
-template <class Exp, class F,
-          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              std::declval<Exp>().error())),
-          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-auto map_error_impl(Exp &&exp, F &&f) {
-  using result = expected<exp_t<Exp>, monostate>;
-  if (exp.has_value()) {
-    return result();
-  }
-
-  detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
-  return result(unexpect, monostate{});
-}
-#else
-template <class Exp, class F,
-          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              std::declval<Exp>().error())),
-          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-constexpr auto map_error_impl(Exp &&exp, F &&f)
-    -> expected<exp_t<Exp>, detail::decay_t<Ret>> {
-  using result = expected<exp_t<Exp>, detail::decay_t<Ret>>;
-
-  return exp.has_value()
-             ? result(*std::forward<Exp>(exp))
-             : result(unexpect, detail::invoke(std::forward<F>(f),
-                                               std::forward<Exp>(exp).error()));
-}
-
-template <class Exp, class F,
-          detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              std::declval<Exp>().error())),
-          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-auto map_error_impl(Exp &&exp, F &&f) -> expected<exp_t<Exp>, monostate> {
-  using result = expected<exp_t<Exp>, monostate>;
-  if (exp.has_value()) {
-    return result(*std::forward<Exp>(exp));
-  }
-
-  detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
-  return result(unexpect, monostate{});
-}
-
-template <class Exp, class F,
-          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              std::declval<Exp>().error())),
-          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-constexpr auto map_error_impl(Exp &&exp, F &&f)
-    -> expected<exp_t<Exp>, detail::decay_t<Ret>> {
-  using result = expected<exp_t<Exp>, detail::decay_t<Ret>>;
-
-  return exp.has_value()
-             ? result()
-             : result(unexpect, detail::invoke(std::forward<F>(f),
-                                               std::forward<Exp>(exp).error()));
-}
-
-template <class Exp, class F,
-          detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              std::declval<Exp>().error())),
-          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-auto map_error_impl(Exp &&exp, F &&f) -> expected<exp_t<Exp>, monostate> {
-  using result = expected<exp_t<Exp>, monostate>;
-  if (exp.has_value()) {
-    return result();
-  }
-
-  detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
-  return result(unexpect, monostate{});
-}
-#endif
-
-#ifdef TL_EXPECTED_CXX14
-template <class Exp, class F,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              std::declval<Exp>().error())),
-          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-constexpr auto or_else_impl(Exp &&exp, F &&f) {
-  static_assert(detail::is_expected<Ret>::value, "F must return an expected");
-  return exp.has_value() ? std::forward<Exp>(exp)
-                         : detail::invoke(std::forward<F>(f),
-                                          std::forward<Exp>(exp).error());
-}
-
-template <class Exp, class F,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              std::declval<Exp>().error())),
-          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-detail::decay_t<Exp> or_else_impl(Exp &&exp, F &&f) {
-  return exp.has_value() ? std::forward<Exp>(exp)
-                         : (detail::invoke(std::forward<F>(f),
-                                           std::forward<Exp>(exp).error()),
-                            std::forward<Exp>(exp));
-}
-#else
-template <class Exp, class F,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              std::declval<Exp>().error())),
-          detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-auto or_else_impl(Exp &&exp, F &&f) -> Ret {
-  static_assert(detail::is_expected<Ret>::value, "F must return an expected");
-  return exp.has_value() ? std::forward<Exp>(exp)
-                         : detail::invoke(std::forward<F>(f),
-                                          std::forward<Exp>(exp).error());
-}
-
-template <class Exp, class F,
-          class Ret = decltype(detail::invoke(std::declval<F>(),
-                                              std::declval<Exp>().error())),
-          detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-detail::decay_t<Exp> or_else_impl(Exp &&exp, F &&f) {
-  return exp.has_value() ? std::forward<Exp>(exp)
-                         : (detail::invoke(std::forward<F>(f),
-                                           std::forward<Exp>(exp).error()),
-                            std::forward<Exp>(exp));
-}
-#endif
-} // namespace detail
-
-template <class T, class E, class U, class F>
-constexpr bool operator==(const expected<T, E> &lhs,
-                          const expected<U, F> &rhs) {
-  return (lhs.has_value() != rhs.has_value())
-             ? false
-             : (!lhs.has_value() ? lhs.error() == rhs.error() : *lhs == *rhs);
-}
-template <class T, class E, class U, class F>
-constexpr bool operator!=(const expected<T, E> &lhs,
-                          const expected<U, F> &rhs) {
-  return (lhs.has_value() != rhs.has_value())
-             ? true
-             : (!lhs.has_value() ? lhs.error() != rhs.error() : *lhs != *rhs);
-}
-template <class E, class F>
-constexpr bool operator==(const expected<void, E> &lhs,
-                          const expected<void, F> &rhs) {
-  return (lhs.has_value() != rhs.has_value())
-             ? false
-             : (!lhs.has_value() ? lhs.error() == rhs.error() : true);
-}
-template <class E, class F>
-constexpr bool operator!=(const expected<void, E> &lhs,
-                          const expected<void, F> &rhs) {
-  return (lhs.has_value() != rhs.has_value())
-             ? true
-             : (!lhs.has_value() ? lhs.error() == rhs.error() : false);
-}
-
-template <class T, class E, class U>
-constexpr bool operator==(const expected<T, E> &x, const U &v) {
-  return x.has_value() ? *x == v : false;
-}
-template <class T, class E, class U>
-constexpr bool operator==(const U &v, const expected<T, E> &x) {
-  return x.has_value() ? *x == v : false;
-}
-template <class T, class E, class U>
-constexpr bool operator!=(const expected<T, E> &x, const U &v) {
-  return x.has_value() ? *x != v : true;
-}
-template <class T, class E, class U>
-constexpr bool operator!=(const U &v, const expected<T, E> &x) {
-  return x.has_value() ? *x != v : true;
-}
-
-template <class T, class E>
-constexpr bool operator==(const expected<T, E> &x, const unexpected<E> &e) {
-  return x.has_value() ? false : x.error() == e.value();
-}
-template <class T, class E>
-constexpr bool operator==(const unexpected<E> &e, const expected<T, E> &x) {
-  return x.has_value() ? false : x.error() == e.value();
-}
-template <class T, class E>
-constexpr bool operator!=(const expected<T, E> &x, const unexpected<E> &e) {
-  return x.has_value() ? true : x.error() != e.value();
-}
-template <class T, class E>
-constexpr bool operator!=(const unexpected<E> &e, const expected<T, E> &x) {
-  return x.has_value() ? true : x.error() != e.value();
-}
-
-template <class T, class E,
-          detail::enable_if_t<(std::is_void<T>::value ||
-                               std::is_move_constructible<T>::value) &&
-                              detail::is_swappable<T>::value &&
-                              std::is_move_constructible<E>::value &&
-                              detail::is_swappable<E>::value> * = nullptr>
-void swap(expected<T, E> &lhs,
-          expected<T, E> &rhs) noexcept(noexcept(lhs.swap(rhs))) {
-  lhs.swap(rhs);
-}
-} // namespace tl
-
-#endif
-/* end file include/ada/expected.h */
-/* begin file include/ada/url_pattern_regex.h */
-/**
- * @file url_search_params.h
- * @brief Declaration for the URL Search Params
- */
-#ifndef ADA_URL_PATTERN_REGEX_H
-#define ADA_URL_PATTERN_REGEX_H
-
-#ifdef ADA_USE_UNSAFE_STD_REGEX_PROVIDER
-#include <regex>
-#endif // ADA_USE_UNSAFE_STD_REGEX_PROVIDER
-
-namespace ada::url_pattern_regex {
-
-template <typename T>
-concept regex_concept = requires(T t, std::string_view pattern,
-                                 bool ignore_case, std::string_view input) {
-  // Ensure the class has a type alias 'regex_type'
-  typename T::regex_type;
-
-  // Function to create a regex instance
-  {
-    T::create_instance(pattern, ignore_case)
-  } -> std::same_as<std::optional<typename T::regex_type>>;
-
-  // Function to perform regex search
-  {
-    T::regex_search(input, std::declval<typename T::regex_type &>())
-  } -> std::same_as<std::optional<std::vector<std::optional<std::string>>>>;
-
-  // Function to match regex pattern
-  {
-    T::regex_match(input, std::declval<typename T::regex_type &>())
-  } -> std::same_as<bool>;
-
-  // Copy constructor
-  { T(std::declval<const T &>()) } -> std::same_as<T>;
-
-  // Move constructor
-  { T(std::declval<T &&>()) } -> std::same_as<T>;
-};
-
-#ifdef ADA_USE_UNSAFE_STD_REGEX_PROVIDER
-class std_regex_provider {
-public:
-  std_regex_provider() = default;
-  using regex_type = std::regex;
-  static std::optional<regex_type> create_instance(std::string_view pattern,
-                                                   bool ignore_case);
-  static std::optional<std::vector<std::optional<std::string>>>
-  regex_search(std::string_view input, const regex_type &pattern);
-  static bool regex_match(std::string_view input, const regex_type &pattern);
-};
-#endif // ADA_USE_UNSAFE_STD_REGEX_PROVIDER
-
-} // namespace ada::url_pattern_regex
-
-#endif // ADA_URL_PATTERN_REGEX_H
-/* end file include/ada/url_pattern_regex.h */
-/* begin file include/ada/url_pattern_init.h */
-/**
- * @file url_pattern_init.h
- * @brief Declaration for the url_pattern_init implementation.
- */
-#ifndef ADA_URL_PATTERN_INIT_H
-#define ADA_URL_PATTERN_INIT_H
-
-/* begin file include/ada/errors.h */
-/**
- * @file errors.h
- * @brief Definitions for the errors.
- */
-#ifndef ADA_ERRORS_H
-#define ADA_ERRORS_H
-
-#include <cstdint>
-namespace ada {
-enum class errors : uint8_t { type_error };
-} // namespace ada
-#endif // ADA_ERRORS_H
-/* end file include/ada/errors.h */
-
-#include <optional>
-#include <string>
-#include <string_view>
-
-#if ADA_TESTING
-#include <iostream>
-#endif // ADA_TESTING
-
-namespace ada {
-
-// Important: C++20 allows us to use concept rather than `using` or `typedef
-// and allows functions with second argument, which is optional (using either
-// std::nullopt or a parameter with default value)
-template <typename F>
-concept url_pattern_encoding_callback = requires(F f, std::string_view sv) {
-  { f(sv) } -> std::same_as<tl::expected<std::string, errors>>;
-};
-
-// A structure providing matching patterns for individual components
-// of a URL. When a URLPattern is created, or when a URLPattern is
-// used to match or test against a URL, the input can be given as
-// either a string or a URLPatternInit struct. If a string is given,
-// it will be parsed to create a URLPatternInit. The URLPatternInit
-// API is defined as part of the URLPattern specification.
-struct url_pattern_init {
-  // @see https://urlpattern.spec.whatwg.org/#process-a-urlpatterninit
-  static tl::expected<url_pattern_init, errors>
-  process(url_pattern_init init, std::string_view type,
-          std::optional<std::string_view> protocol = std::nullopt,
-          std::optional<std::string_view> username = std::nullopt,
-          std::optional<std::string_view> password = std::nullopt,
-          std::optional<std::string_view> hostname = std::nullopt,
-          std::optional<std::string_view> port = std::nullopt,
-          std::optional<std::string_view> pathname = std::nullopt,
-          std::optional<std::string_view> search = std::nullopt,
-          std::optional<std::string_view> hash = std::nullopt);
-
-  // @see https://urlpattern.spec.whatwg.org/#process-protocol-for-init
-  static tl::expected<std::string, errors>
-  process_protocol(std::string_view value, std::string_view type);
-
-  // @see https://urlpattern.spec.whatwg.org/#process-username-for-init
-  static tl::expected<std::string, errors>
-  process_username(std::string_view value, std::string_view type);
-
-  // @see https://urlpattern.spec.whatwg.org/#process-password-for-init
-  static tl::expected<std::string, errors>
-  process_password(std::string_view value, std::string_view type);
-
-  // @see https://urlpattern.spec.whatwg.org/#process-hostname-for-init
-  static tl::expected<std::string, errors>
-  process_hostname(std::string_view value, std::string_view type);
-
-  // @see https://urlpattern.spec.whatwg.org/#process-port-for-init
-  static tl::expected<std::string, errors>
-  process_port(std::string_view port, std::string_view protocol,
-               std::string_view type);
-
-  // @see https://urlpattern.spec.whatwg.org/#process-pathname-for-init
-  static tl::expected<std::string, errors>
-  process_pathname(std::string_view value, std::string_view protocol,
-                   std::string_view type);
-
-  // @see https://urlpattern.spec.whatwg.org/#process-search-for-init
-  static tl::expected<std::string, errors>
-  process_search(std::string_view value, std::string_view type);
-
-  // @see https://urlpattern.spec.whatwg.org/#process-hash-for-init
-  static tl::expected<std::string, errors> process_hash(std::string_view value,
-                                                        std::string_view type);
-
-#if ADA_TESTING
-  friend void PrintTo(const url_pattern_init &init, std::ostream *os) {
-    *os << "protocol: '" << init.protocol.value_or("undefined") << "', ";
-    *os << "username: '" << init.username.value_or("undefined") << "', ";
-    *os << "password: '" << init.password.value_or("undefined") << "', ";
-    *os << "hostname: '" << init.hostname.value_or("undefined") << "', ";
-    *os << "port: '" << init.port.value_or("undefined") << "', ";
-    *os << "pathname: '" << init.pathname.value_or("undefined") << "', ";
-    *os << "search: '" << init.search.value_or("undefined") << "', ";
-    *os << "hash: '" << init.hash.value_or("undefined") << "', ";
-    *os << "base_url: '" << init.base_url.value_or("undefined") << "', ";
-  }
-#endif // ADA_TESTING
-
-  bool operator==(const url_pattern_init &) const;
-
-  std::optional<std::string> protocol{};
-  std::optional<std::string> username{};
-  std::optional<std::string> password{};
-  std::optional<std::string> hostname{};
-  std::optional<std::string> port{};
-  std::optional<std::string> pathname{};
-  std::optional<std::string> search{};
-  std::optional<std::string> hash{};
-  std::optional<std::string> base_url{};
-};
-} // namespace ada
-
-#endif // ADA_URL_PATTERN_INIT_H
-/* end file include/ada/url_pattern_init.h */
-
-/**
- * @private
- */
-namespace ada {
-struct url_aggregator;
-struct url;
-template <url_pattern_regex::regex_concept regex_provider> class url_pattern;
-struct url_pattern_options;
-enum class errors : uint8_t;
-} // namespace ada
-
-/**
- * @namespace ada::parser
- * @brief Includes the definitions for supported parsers
- */
-namespace ada::parser {
-/**
- * Parses a url. The parameter user_input is the input to be parsed:
- * it should be a valid UTF-8 string. The parameter base_url is an optional
- * parameter that can be used to resolve relative URLs. If the base_url is
- * provided, the user_input is resolved against the base_url.
- */
-template <typename result_type = url_aggregator>
-result_type parse_url(std::string_view user_input,
-                      const result_type *base_url = nullptr);
-
-extern template url_aggregator
-parse_url<url_aggregator>(std::string_view user_input,
-                          const url_aggregator *base_url);
-extern template url parse_url<url>(std::string_view user_input,
-                                   const url *base_url);
-
-template <typename result_type = url_aggregator, bool store_values = true>
-result_type parse_url_impl(std::string_view user_input,
-                           const result_type *base_url = nullptr);
-
-extern template url_aggregator
-parse_url_impl<url_aggregator>(std::string_view user_input,
-                               const url_aggregator *base_url);
-extern template url parse_url_impl<url>(std::string_view user_input,
-                                        const url *base_url);
-
-template <url_pattern_regex::regex_concept regex_provider>
-tl::expected<url_pattern<regex_provider>, errors>
-parse_url_pattern_impl(std::variant<std::string_view, url_pattern_init> input,
-                       const std::string_view *base_url,
-                       const url_pattern_options *options);
-
-} // namespace ada::parser
-
-#endif // ADA_PARSER_H
-/* end file include/ada/parser.h */
-/* begin file include/ada/parser-inl.h */
-/**
- * @file parser-inl.h
- */
-#ifndef ADA_PARSER_INL_H
-#define ADA_PARSER_INL_H
-
-/* begin file include/ada/url_pattern.h */
-/**
- * @file url_pattern.h
- * @brief Declaration for the URLPattern implementation.
- */
-#ifndef ADA_URL_PATTERN_H
-#define ADA_URL_PATTERN_H
-
-/* begin file include/ada/implementation.h */
-/**
- * @file implementation.h
- * @brief Definitions for user facing functions for parsing URL and it's
- * components.
- */
-#ifndef ADA_IMPLEMENTATION_H
-#define ADA_IMPLEMENTATION_H
-
-#include <optional>
-#include <string_view>
-
-/* begin file include/ada/url.h */
-/**
- * @file url.h
- * @brief Declaration for the URL
- */
-#ifndef ADA_URL_H
-#define ADA_URL_H
-
-#include <algorithm>
-#include <optional>
-#include <string>
-#include <string_view>
-
-/* begin file include/ada/checkers.h */
-/**
- * @file checkers.h
- * @brief Declarations for URL specific checkers used within Ada.
- */
-#ifndef ADA_CHECKERS_H
-#define ADA_CHECKERS_H
-
-#include <cstring>
-#include <string_view>
-
-/**
- * These functions are not part of our public API and may
- * change at any time.
- * @private
- * @namespace ada::checkers
- * @brief Includes the definitions for validation functions
- */
-namespace ada::checkers {
-
-/**
- * @private
- * Assuming that x is an ASCII letter, this function returns the lower case
- * equivalent.
- * @details More likely to be inlined by the compiler and constexpr.
- */
-constexpr char to_lower(char x) noexcept;
-
-/**
- * @private
- * Returns true if the character is an ASCII letter. Equivalent to std::isalpha
- * but more likely to be inlined by the compiler.
- *
- * @attention std::isalpha is not constexpr generally.
- */
-constexpr bool is_alpha(char x) noexcept;
-
-/**
- * @private
- * Check whether a string starts with 0x or 0X. The function is only
- * safe if input.size() >=2.
- *
- * @see has_hex_prefix
- */
-constexpr bool has_hex_prefix_unsafe(std::string_view input);
-/**
- * @private
- * Check whether a string starts with 0x or 0X.
- */
-constexpr bool has_hex_prefix(std::string_view input);
-
-/**
- * @private
- * Check whether x is an ASCII digit. More likely to be inlined than
- * std::isdigit.
- */
-constexpr bool is_digit(char x) noexcept;
-
-/**
- * @private
- * @details A string starts with a Windows drive letter if all of the following
- * are true:
- *
- *   - its length is greater than or equal to 2
- *   - its first two code points are a Windows drive letter
- *   - its length is 2 or its third code point is U+002F (/), U+005C (\), U+003F
- * (?), or U+0023 (#).
- *
- * https://url.spec.whatwg.org/#start-with-a-windows-drive-letter
- */
-inline constexpr bool is_windows_drive_letter(std::string_view input) noexcept;
-
-/**
- * @private
- * @details A normalized Windows drive letter is a Windows drive letter of which
- * the second code point is U+003A (:).
- */
-inline constexpr bool
-is_normalized_windows_drive_letter(std::string_view input) noexcept;
-
-/**
- * @private
- * Returns true if an input is an ipv4 address. It is assumed that the string
- * does not contain uppercase ASCII characters (the input should have been
- * lowered cased before calling this function) and is not empty.
- */
-ada_really_inline constexpr bool is_ipv4(std::string_view view) noexcept;
-
-/**
- * @private
- * Returns a bitset. If the first bit is set, then at least one character needs
- * percent encoding. If the second bit is set, a \\ is found. If the third bit
- * is set then we have a dot. If the fourth bit is set, then we have a percent
- * character.
- */
-ada_really_inline constexpr uint8_t
-path_signature(std::string_view input) noexcept;
-
-/**
- * @private
- * Returns true if the length of the domain name and its labels are according to
- * the specifications. The length of the domain must be 255 octets (253
- * characters not including the last 2 which are the empty label reserved at the
- * end). When the empty label is included (a dot at the end), the domain name
- * can have 254 characters. The length of a label must be at least 1 and at most
- * 63 characters.
- * @see section 3.1. of https://www.rfc-editor.org/rfc/rfc1034
- * @see https://www.unicode.org/reports/tr46/#ToASCII
- */
-ada_really_inline constexpr bool
-verify_dns_length(std::string_view input) noexcept;
-
-} // namespace ada::checkers
-
-#endif // ADA_CHECKERS_H
-/* end file include/ada/checkers.h */
-/* begin file include/ada/url_components.h */
-/**
- * @file url_components.h
- * @brief Declaration for the URL Components
- */
-#ifndef ADA_URL_COMPONENTS_H
-#define ADA_URL_COMPONENTS_H
-
-namespace ada {
-
-/**
- * @brief URL Component representations using offsets.
- *
- * @details We design the url_components struct so that it is as small
- * and simple as possible. This version uses 32 bytes.
- *
- * This struct is used to extract components from a single 'href'.
- */
-struct url_components {
-  constexpr static uint32_t omitted = uint32_t(-1);
-
-  url_components() = default;
-  url_components(const url_components &u) = default;
-  url_components(url_components &&u) noexcept = default;
-  url_components &operator=(url_components &&u) noexcept = default;
-  url_components &operator=(const url_components &u) = default;
-  ~url_components() = default;
-
-  /*
-   * By using 32-bit integers, we implicitly assume that the URL string
-   * cannot exceed 4 GB.
-   *
-   * https://user:pass@example.com:1234/foo/bar?baz#quux
-   *       |     |    |          | ^^^^|       |   |
-   *       |     |    |          | |   |       |   `----- hash_start
-   *       |     |    |          | |   |       `--------- search_start
-   *       |     |    |          | |   `----------------- pathname_start
-   *       |     |    |          | `--------------------- port
-   *       |     |    |          `----------------------- host_end
-   *       |     |    `---------------------------------- host_start
-   *       |     `--------------------------------------- username_end
-   *       `--------------------------------------------- protocol_end
-   */
-  uint32_t protocol_end{0};
-  /**
-   * Username end is not `omitted` by default to make username and password
-   * getters less costly to implement.
-   */
-  uint32_t username_end{0};
-  uint32_t host_start{0};
-  uint32_t host_end{0};
-  uint32_t port{omitted};
-  uint32_t pathname_start{0};
-  uint32_t search_start{omitted};
-  uint32_t hash_start{omitted};
-
-  /**
-   * Check the following conditions:
-   * protocol_end < username_end < ... < hash_start,
-   * expect when a value is omitted. It also computes
-   * a lower bound on  the possible string length that may match these
-   * offsets.
-   * @return true if the offset values are
-   *  consistent with a possible URL string
-   */
-  [[nodiscard]] constexpr bool check_offset_consistency() const noexcept;
-
-  /**
-   * Converts a url_components to JSON stringified version.
-   */
-  [[nodiscard]] std::string to_string() const;
-
-}; // struct url_components
-} // namespace ada
-#endif
-/* end file include/ada/url_components.h */
-
-namespace ada {
-
-struct url_aggregator;
-
-// namespace parser {
-// template <typename result_type>
-// result_type parse_url(std::string_view user_input,
-//                       const result_type* base_url = nullptr);
-// template <typename result_type, bool store_values>
-// result_type parse_url_impl(std::string_view user_input,
-//                            const result_type* base_url = nullptr);
-// }
-
-/**
- * @brief Generic URL struct reliant on std::string instantiation.
- *
- * @details To disambiguate from a valid URL string it can also be referred to
- * as a URL record. A URL is a struct that represents a universal identifier.
- * Unlike the url_aggregator, the ada::url represents the different components
- * of a parsed URL as independent std::string instances. This makes the
- * structure heavier and more reliant on memory allocations. When getting
- * components from the parsed URL, a new std::string is typically constructed.
- *
- * @see https://url.spec.whatwg.org/#url-representation
- */
-struct url : url_base {
-  url() = default;
-  url(const url &u) = default;
-  url(url &&u) noexcept = default;
-  url &operator=(url &&u) noexcept = default;
-  url &operator=(const url &u) = default;
-  ~url() override = default;
-
-  /**
-   * @private
-   * A URL's username is an ASCII string identifying a username. It is initially
-   * the empty string.
-   */
-  std::string username{};
-
-  /**
-   * @private
-   * A URL's password is an ASCII string identifying a password. It is initially
-   * the empty string.
-   */
-  std::string password{};
-
-  /**
-   * @private
-   * A URL's host is null or a host. It is initially null.
-   */
-  std::optional<std::string> host{};
-
-  /**
-   * @private
-   * A URL's port is either null or a 16-bit unsigned integer that identifies a
-   * networking port. It is initially null.
-   */
-  std::optional<uint16_t> port{};
-
-  /**
-   * @private
-   * A URL's path is either an ASCII string or a list of zero or more ASCII
-   * strings, usually identifying a location.
-   */
-  std::string path{};
-
-  /**
-   * @private
-   * A URL's query is either null or an ASCII string. It is initially null.
-   */
-  std::optional<std::string> query{};
-
-  /**
-   * @private
-   * A URL's fragment is either null or an ASCII string that can be used for
-   * further processing on the resource the URL's other components identify. It
-   * is initially null.
-   */
-  std::optional<std::string> hash{};
-
-  /** @return true if it has an host but it is the empty string */
-  [[nodiscard]] inline bool has_empty_hostname() const noexcept;
-  /** @return true if the URL has a (non default) port */
-  [[nodiscard]] inline bool has_port() const noexcept;
-  /** @return true if it has a host (included an empty host) */
-  [[nodiscard]] inline bool has_hostname() const noexcept;
-  [[nodiscard]] bool has_valid_domain() const noexcept override;
-
-  /**
-   * Returns a JSON string representation of this URL.
-   */
-  [[nodiscard]] std::string to_string() const override;
-
-  /**
-   * @see https://url.spec.whatwg.org/#dom-url-href
-   * @see https://url.spec.whatwg.org/#concept-url-serializer
-   */
-  [[nodiscard]] ada_really_inline std::string get_href() const noexcept;
-
-  /**
-   * The origin getter steps are to return the serialization of this's URL's
-   * origin. [HTML]
-   * @return a newly allocated string.
-   * @see https://url.spec.whatwg.org/#concept-url-origin
-   */
-  [[nodiscard]] std::string get_origin() const noexcept override;
-
-  /**
-   * The protocol getter steps are to return this's URL's scheme, followed by
-   * U+003A (:).
-   * @return a newly allocated string.
-   * @see https://url.spec.whatwg.org/#dom-url-protocol
-   */
-  [[nodiscard]] std::string get_protocol() const noexcept;
-
-  /**
-   * Return url's host, serialized, followed by U+003A (:) and url's port,
-   * serialized.
-   * When there is no host, this function returns the empty string.
-   * @return a newly allocated string.
-   * @see https://url.spec.whatwg.org/#dom-url-host
-   */
-  [[nodiscard]] std::string get_host() const noexcept;
-
-  /**
-   * Return this's URL's host, serialized.
-   * When there is no host, this function returns the empty string.
-   * @return a newly allocated string.
-   * @see https://url.spec.whatwg.org/#dom-url-hostname
-   */
-  [[nodiscard]] std::string get_hostname() const noexcept;
-
-  /**
-   * The pathname getter steps are to return the result of URL path serializing
-   * this's URL.
-   * @return a newly allocated string.
-   * @see https://url.spec.whatwg.org/#dom-url-pathname
-   */
-  [[nodiscard]] constexpr std::string_view get_pathname() const noexcept;
-
-  /**
-   * Compute the pathname length in bytes without instantiating a view or a
-   * string.
-   * @return size of the pathname in bytes
-   * @see https://url.spec.whatwg.org/#dom-url-pathname
-   */
-  [[nodiscard]] ada_really_inline size_t get_pathname_length() const noexcept;
-
-  /**
-   * Return U+003F (?), followed by this's URL's query.
-   * @return a newly allocated string.
-   * @see https://url.spec.whatwg.org/#dom-url-search
-   */
-  [[nodiscard]] std::string get_search() const noexcept;
-
-  /**
-   * The username getter steps are to return this's URL's username.
-   * @return a constant reference to the underlying string.
-   * @see https://url.spec.whatwg.org/#dom-url-username
-   */
-  [[nodiscard]] const std::string &get_username() const noexcept;
-
-  /**
-   * @return Returns true on successful operation.
-   * @see https://url.spec.whatwg.org/#dom-url-username
-   */
-  bool set_username(std::string_view input);
-
-  /**
-   * @return Returns true on success.
-   * @see https://url.spec.whatwg.org/#dom-url-password
-   */
-  bool set_password(std::string_view input);
-
-  /**
-   * @return Returns true on success.
-   * @see https://url.spec.whatwg.org/#dom-url-port
-   */
-  bool set_port(std::string_view input);
-
-  /**
-   * This function always succeeds.
-   * @see https://url.spec.whatwg.org/#dom-url-hash
-   */
-  void set_hash(std::string_view input);
-
-  /**
-   * This function always succeeds.
-   * @see https://url.spec.whatwg.org/#dom-url-search
-   */
-  void set_search(std::string_view input);
-
-  /**
-   * @return Returns true on success.
-   * @see https://url.spec.whatwg.org/#dom-url-search
-   */
-  bool set_pathname(std::string_view input);
-
-  /**
-   * @return Returns true on success.
-   * @see https://url.spec.whatwg.org/#dom-url-host
-   */
-  bool set_host(std::string_view input);
-
-  /**
-   * @return Returns true on success.
-   * @see https://url.spec.whatwg.org/#dom-url-hostname
-   */
-  bool set_hostname(std::string_view input);
-
-  /**
-   * @return Returns true on success.
-   * @see https://url.spec.whatwg.org/#dom-url-protocol
-   */
-  bool set_protocol(std::string_view input);
-
-  /**
-   * @see https://url.spec.whatwg.org/#dom-url-href
-   */
-  bool set_href(std::string_view input);
-
-  /**
-   * The password getter steps are to return this's URL's password.
-   * @return a constant reference to the underlying string.
-   * @see https://url.spec.whatwg.org/#dom-url-password
-   */
-  [[nodiscard]] const std::string &get_password() const noexcept;
-
-  /**
-   * Return this's URL's port, serialized.
-   * @return a newly constructed string representing the port.
-   * @see https://url.spec.whatwg.org/#dom-url-port
-   */
-  [[nodiscard]] std::string get_port() const noexcept;
-
-  /**
-   * Return U+0023 (#), followed by this's URL's fragment.
-   * @return a newly constructed string representing the hash.
-   * @see https://url.spec.whatwg.org/#dom-url-hash
-   */
-  [[nodiscard]] std::string get_hash() const noexcept;
-
-  /**
-   * A URL includes credentials if its username or password is not the empty
-   * string.
-   */
-  [[nodiscard]] ada_really_inline bool has_credentials() const noexcept;
-
-  /**
-   * Useful for implementing efficient serialization for the URL.
-   *
-   * https://user:pass@example.com:1234/foo/bar?baz#quux
-   *       |     |    |          | ^^^^|       |   |
-   *       |     |    |          | |   |       |   `----- hash_start
-   *       |     |    |          | |   |       `--------- search_start
-   *       |     |    |          | |   `----------------- pathname_start
-   *       |     |    |          | `--------------------- port
-   *       |     |    |          `----------------------- host_end
-   *       |     |    `---------------------------------- host_start
-   *       |     `--------------------------------------- username_end
-   *       `--------------------------------------------- protocol_end
-   *
-   * Inspired after servo/url
-   *
-   * @return a newly constructed component.
-   *
-   * @see
-   * https://github.com/servo/rust-url/blob/b65a45515c10713f6d212e6726719a020203cc98/url/src/quirks.rs#L31
-   */
-  [[nodiscard]] ada_really_inline ada::url_components
-  get_components() const noexcept;
-  /** @return true if the URL has a hash component */
-  [[nodiscard]] constexpr bool has_hash() const noexcept override;
-  /** @return true if the URL has a search component */
-  [[nodiscard]] constexpr bool has_search() const noexcept override;
-
-private:
-  friend ada::url ada::parser::parse_url<ada::url>(std::string_view,
-                                                   const ada::url *);
-  friend ada::url_aggregator
-  ada::parser::parse_url<ada::url_aggregator>(std::string_view,
-                                              const ada::url_aggregator *);
-  friend void ada::helpers::strip_trailing_spaces_from_opaque_path<ada::url>(
-      ada::url &url) noexcept;
-
-  friend ada::url ada::parser::parse_url_impl<ada::url, true>(std::string_view,
-                                                              const ada::url *);
-  friend ada::url_aggregator
-  ada::parser::parse_url_impl<ada::url_aggregator, true>(
-      std::string_view, const ada::url_aggregator *);
-
-  inline void update_unencoded_base_hash(std::string_view input);
-  inline void update_base_hostname(std::string_view input);
-  inline void update_base_search(std::string_view input,
-                                 const uint8_t query_percent_encode_set[]);
-  inline void update_base_search(std::optional<std::string> &&input);
-  inline void update_base_pathname(std::string_view input);
-  inline void update_base_username(std::string_view input);
-  inline void update_base_password(std::string_view input);
-  inline void update_base_port(std::optional<uint16_t> input);
-
-  /**
-   * Sets the host or hostname according to override condition.
-   * Return true on success.
-   * @see https://url.spec.whatwg.org/#hostname-state
-   */
-  template <bool override_hostname = false>
-  bool set_host_or_hostname(std::string_view input);
-
-  /**
-   * Return true on success.
-   * @see https://url.spec.whatwg.org/#concept-ipv4-parser
-   */
-  [[nodiscard]] bool parse_ipv4(std::string_view input);
-
-  /**
-   * Return true on success.
-   * @see https://url.spec.whatwg.org/#concept-ipv6-parser
-   */
-  [[nodiscard]] bool parse_ipv6(std::string_view input);
-
-  /**
-   * Return true on success.
-   * @see https://url.spec.whatwg.org/#concept-opaque-host-parser
-   */
-  [[nodiscard]] bool parse_opaque_host(std::string_view input);
-
-  /**
-   * A URL's scheme is an ASCII string that identifies the type of URL and can
-   * be used to dispatch a URL for further processing after parsing. It is
-   * initially the empty string. We only set non_special_scheme when the scheme
-   * is non-special, otherwise we avoid constructing string.
-   *
-   * Special schemes are stored in ada::scheme::details::is_special_list so we
-   * typically do not need to store them in each url instance.
-   */
-  std::string non_special_scheme{};
-
-  /**
-   * A URL cannot have a username/password/port if its host is null or the empty
-   * string, or its scheme is "file".
-   */
-  [[nodiscard]] inline bool cannot_have_credentials_or_port() const;
-
-  ada_really_inline size_t parse_port(
-      std::string_view view, bool check_trailing_content) noexcept override;
-
-  ada_really_inline size_t parse_port(std::string_view view) noexcept override {
-    return this->parse_port(view, false);
-  }
-
-  /**
-   * Parse the host from the provided input. We assume that
-   * the input does not contain spaces or tabs. Control
-   * characters and spaces are not trimmed (they should have
-   * been removed if needed).
-   * Return true on success.
-   * @see https://url.spec.whatwg.org/#host-parsing
-   */
-  [[nodiscard]] ada_really_inline bool parse_host(std::string_view input);
-
-  template <bool has_state_override = false>
-  [[nodiscard]] ada_really_inline bool parse_scheme(std::string_view input);
-
-  constexpr void clear_pathname() override;
-  constexpr void clear_search() override;
-  constexpr void set_protocol_as_file();
-
-  /**
-   * Parse the path from the provided input.
-   * Return true on success. Control characters not
-   * trimmed from the ends (they should have
-   * been removed if needed).
-   *
-   * The input is expected to be UTF-8.
-   *
-   * @see https://url.spec.whatwg.org/
-   */
-  ada_really_inline void parse_path(std::string_view input);
-
-  /**
-   * Set the scheme for this URL. The provided scheme should be a valid
-   * scheme string, be lower-cased, not contain spaces or tabs. It should
-   * have no spurious trailing or leading content.
-   */
-  inline void set_scheme(std::string &&new_scheme) noexcept;
-
-  /**
-   * Take the scheme from another URL. The scheme string is moved from the
-   * provided url.
-   */
-  constexpr void copy_scheme(ada::url &&u) noexcept;
-
-  /**
-   * Take the scheme from another URL. The scheme string is copied from the
-   * provided url.
-   */
-  constexpr void copy_scheme(const ada::url &u);
-
-}; // struct url
-
-inline std::ostream &operator<<(std::ostream &out, const ada::url &u);
-} // namespace ada
-
-#endif // ADA_URL_H
-/* end file include/ada/url.h */
-
-namespace ada {
-
-template <class result_type = ada::url_aggregator>
-using result = tl::expected<result_type, ada::errors>;
-
-/**
- * The URL parser takes a scalar value string input, with an optional null or
- * base URL base (default null). The parser assumes the input is a valid ASCII
- * or UTF-8 string.
- *
- * @param input the string input to analyze (must be valid ASCII or UTF-8)
- * @param base_url the optional URL input to use as a base url.
- * @return a parsed URL.
- */
-template <class result_type = ada::url_aggregator>
-ada_warn_unused ada::result<result_type>
-parse(std::string_view input, const result_type *base_url = nullptr);
-
-extern template ada::result<url> parse<url>(std::string_view input,
-                                            const url *base_url);
-extern template ada::result<url_aggregator>
-parse<url_aggregator>(std::string_view input, const url_aggregator *base_url);
-
-/**
- * Verifies whether the URL strings can be parsed. The function assumes
- * that the inputs are valid ASCII or UTF-8 strings.
- * @see https://url.spec.whatwg.org/#dom-url-canparse
- * @return If URL can be parsed or not.
- */
-bool can_parse(std::string_view input,
-               const std::string_view *base_input = nullptr);
-
-/**
- * Implementation of the URL pattern parsing algorithm.
- * @see https://urlpattern.spec.whatwg.org
- *
- * @param input valid UTF-8 string or URLPatternInit struct
- * @param base_url an optional valid UTF-8 string
- * @param options an optional url_pattern_options struct
- * @return url_pattern instance
- */
-template <url_pattern_regex::regex_concept regex_provider>
-ada_warn_unused tl::expected<url_pattern<regex_provider>, errors>
-parse_url_pattern(std::variant<std::string_view, url_pattern_init> input,
-                  const std::string_view *base_url = nullptr,
-                  const url_pattern_options *options = nullptr);
-
-/**
- * Computes a href string from a file path. The function assumes
- * that the input is a valid ASCII or UTF-8 string.
- * @return a href string (starts with file:://)
- */
-std::string href_from_file(std::string_view path);
-} // namespace ada
-
-#endif // ADA_IMPLEMENTATION_H
-/* end file include/ada/implementation.h */
-
-#include <string>
-#include <unordered_map>
-#include <variant>
-#include <vector>
-
-#if ADA_TESTING
-#include <iostream>
-#endif // ADA_TESTING
-
-namespace ada {
-
-enum class url_pattern_part_type : uint8_t {
-  // The part represents a simple fixed text string.
-  FIXED_TEXT,
-  // The part represents a matching group with a custom regular expression.
-  REGEXP,
-  // The part represents a matching group that matches code points up to the
-  // next separator code point. This is typically used for a named group like
-  // ":foo" that does not have a custom regular expression.
-  SEGMENT_WILDCARD,
-  // The part represents a matching group that greedily matches all code points.
-  // This is typically used for the "*" wildcard matching group.
-  FULL_WILDCARD,
-};
-
-enum class url_pattern_part_modifier : uint8_t {
-  // The part does not have a modifier.
-  none,
-  // The part has an optional modifier indicated by the U+003F (?) code point.
-  optional,
-  // The part has a "zero or more" modifier indicated by the U+002A (*) code
-  // point.
-  zero_or_more,
-  // The part has a "one or more" modifier indicated by the U+002B (+) code
-  // point.
-  one_or_more,
-};
-
-// @see https://urlpattern.spec.whatwg.org/#part
-class url_pattern_part {
-public:
-  url_pattern_part(url_pattern_part_type _type, std::string &&_value,
-                   url_pattern_part_modifier _modifier)
-      : type(_type), value(_value), modifier(_modifier) {}
-
-  url_pattern_part(url_pattern_part_type _type, std::string &&_value,
-                   url_pattern_part_modifier _modifier, std::string &&_name,
-                   std::string &&_prefix, std::string &&_suffix)
-      : type(_type), value(_value), modifier(_modifier), name(_name),
-        prefix(_prefix), suffix(_suffix) {}
-  // A part has an associated type, a string, which must be set upon creation.
-  url_pattern_part_type type;
-  // A part has an associated value, a string, which must be set upon creation.
-  std::string value;
-  // A part has an associated modifier a string, which must be set upon
-  // creation.
-  url_pattern_part_modifier modifier;
-  // A part has an associated name, a string, initially the empty string.
-  std::string name{};
-  // A part has an associated prefix, a string, initially the empty string.
-  std::string prefix{};
-  // A part has an associated suffix, a string, initially the empty string.
-  std::string suffix{};
-
-  inline bool is_regexp() const noexcept;
-};
-
-// @see https://urlpattern.spec.whatwg.org/#options-header
-struct url_pattern_compile_component_options {
-  url_pattern_compile_component_options() = default;
-  explicit url_pattern_compile_component_options(
-      std::optional<char> new_delimiter = std::nullopt,
-      std::optional<char> new_prefix = std::nullopt)
-      : delimiter(new_delimiter), prefix(new_prefix) {}
-
-  inline std::string_view get_delimiter() const ada_warn_unused;
-  inline std::string_view get_prefix() const ada_warn_unused;
-
-  // @see https://urlpattern.spec.whatwg.org/#options-ignore-case
-  bool ignore_case = false;
-
-  static url_pattern_compile_component_options DEFAULT;
-  static url_pattern_compile_component_options HOSTNAME;
-  static url_pattern_compile_component_options PATHNAME;
-
-private:
-  // @see https://urlpattern.spec.whatwg.org/#options-delimiter-code-point
-  std::optional<char> delimiter{};
-  // @see https://urlpattern.spec.whatwg.org/#options-prefix-code-point
-  std::optional<char> prefix{};
-};
-
-// The default options is an options struct with delimiter code point set to
-// the empty string and prefix code point set to the empty string.
-inline url_pattern_compile_component_options
-    url_pattern_compile_component_options::DEFAULT(std::nullopt, std::nullopt);
-
-// The hostname options is an options struct with delimiter code point set
-// "." and prefix code point set to the empty string.
-inline url_pattern_compile_component_options
-    url_pattern_compile_component_options::HOSTNAME('.', std::nullopt);
-
-// The pathname options is an options struct with delimiter code point set
-// "/" and prefix code point set to "/".
-inline url_pattern_compile_component_options
-    url_pattern_compile_component_options::PATHNAME('/', '/');
-
-// A struct providing the URLPattern matching results for a single
-// URL component. The URLPatternComponentResult is only ever used
-// as a member attribute of a URLPatternResult struct. The
-// URLPatternComponentResult API is defined as part of the URLPattern
-// specification.
-struct url_pattern_component_result {
-  std::string input;
-  std::unordered_map<std::string, std::optional<std::string>> groups;
-
-  bool operator==(const url_pattern_component_result &) const;
-
-#if ADA_TESTING
-  friend void PrintTo(const url_pattern_component_result &result,
-                      std::ostream *os) {
-    *os << "input: '" << result.input << "', group: ";
-    for (const auto &group : result.groups) {
-      *os << "(" << group.first << ", " << group.second.value_or("undefined")
-          << ") ";
-    }
-  }
-#endif // ADA_TESTING
-};
-
-template <url_pattern_regex::regex_concept regex_provider>
-class url_pattern_component {
-public:
-  url_pattern_component() = default;
-
-  // This function explicitly takes a std::string because it is moved.
-  // To avoid unnecessary copy, move each value while calling the constructor.
-  url_pattern_component(std::string &&new_pattern,
-                        typename regex_provider::regex_type &&new_regexp,
-                        std::vector<std::string> &&new_group_name_list,
-                        bool new_has_regexp_groups)
-      : regexp(std::move(new_regexp)), pattern(std::move(new_pattern)),
-        group_name_list(new_group_name_list),
-        has_regexp_groups(new_has_regexp_groups) {}
-
-  // @see https://urlpattern.spec.whatwg.org/#compile-a-component
-  template <url_pattern_encoding_callback F>
-  static tl::expected<url_pattern_component, errors>
-  compile(std::string_view input, F &encoding_callback,
-          url_pattern_compile_component_options &options);
-
-  // @see https://urlpattern.spec.whatwg.org/#create-a-component-match-result
-  url_pattern_component_result create_component_match_result(
-      std::string_view input,
-      std::vector<std::optional<std::string>> &&exec_result);
-
-#if ADA_TESTING
-  friend void PrintTo(const url_pattern_component &component,
-                      std::ostream *os) {
-    *os << "pattern: '" << component.pattern
-        << "', has_regexp_groups: " << component.has_regexp_groups
-        << "group_name_list: ";
-    for (const auto &name : component.group_name_list) {
-      *os << name << ", ";
-    }
-  }
-#endif // ADA_TESTING
-
-  typename regex_provider::regex_type regexp{};
-  std::string pattern{};
-  std::vector<std::string> group_name_list{};
-  bool has_regexp_groups = false;
-};
-
-using url_pattern_input = std::variant<std::string_view, url_pattern_init>;
-
-// A struct providing the URLPattern matching results for all
-// components of a URL. The URLPatternResult API is defined as
-// part of the URLPattern specification.
-struct url_pattern_result {
-  std::vector<url_pattern_input> inputs;
-  url_pattern_component_result protocol;
-  url_pattern_component_result username;
-  url_pattern_component_result password;
-  url_pattern_component_result hostname;
-  url_pattern_component_result port;
-  url_pattern_component_result pathname;
-  url_pattern_component_result search;
-  url_pattern_component_result hash;
-};
-
-struct url_pattern_options {
-  bool ignore_case = false;
-
-#if ADA_TESTING
-  friend void PrintTo(const url_pattern_options &options, std::ostream *os) {
-    *os << "ignore_case: '" << options.ignore_case;
-  }
-#endif // ADA_TESTING
-};
-
-// URLPattern is a Web Platform standard API for matching URLs against a
-// pattern syntax (think of it as a regular expression for URLs). It is
-// defined in https://wicg.github.io/urlpattern.
-// More information about the URL Pattern syntax can be found at
-// https://developer.mozilla.org/en-US/docs/Web/API/URL_Pattern_API
-template <url_pattern_regex::regex_concept regex_provider> class url_pattern {
-public:
-  url_pattern() = default;
-
-  /**
-   * @see https://urlpattern.spec.whatwg.org/#dom-urlpattern-exec
-   */
-  result<std::optional<url_pattern_result>>
-  exec(const url_pattern_input &input,
-       const std::string_view *base_url = nullptr);
-
-  /**
-   * @see https://urlpattern.spec.whatwg.org/#dom-urlpattern-test
-   */
-  result<bool> test(const url_pattern_input &input,
-                    const std::string_view *base_url = nullptr);
-
-  /**
-   * @see https://urlpattern.spec.whatwg.org/#url-pattern-match
-   * This function expects a valid UTF-8 string if input is a string.
-   */
-  result<std::optional<url_pattern_result>>
-  match(const url_pattern_input &input,
-        const std::string_view *base_url_string = nullptr);
-
-  // @see https://urlpattern.spec.whatwg.org/#dom-urlpattern-protocol
-  [[nodiscard]] std::string_view get_protocol() const ada_lifetime_bound;
-  // @see https://urlpattern.spec.whatwg.org/#dom-urlpattern-username
-  [[nodiscard]] std::string_view get_username() const ada_lifetime_bound;
-  // @see https://urlpattern.spec.whatwg.org/#dom-urlpattern-password
-  [[nodiscard]] std::string_view get_password() const ada_lifetime_bound;
-  // @see https://urlpattern.spec.whatwg.org/#dom-urlpattern-hostname
-  [[nodiscard]] std::string_view get_hostname() const ada_lifetime_bound;
-  // @see https://urlpattern.spec.whatwg.org/#dom-urlpattern-port
-  [[nodiscard]] std::string_view get_port() const ada_lifetime_bound;
-  // @see https://urlpattern.spec.whatwg.org/#dom-urlpattern-pathname
-  [[nodiscard]] std::string_view get_pathname() const ada_lifetime_bound;
-  // @see https://urlpattern.spec.whatwg.org/#dom-urlpattern-search
-  [[nodiscard]] std::string_view get_search() const ada_lifetime_bound;
-  // @see https://urlpattern.spec.whatwg.org/#dom-urlpattern-hash
-  [[nodiscard]] std::string_view get_hash() const ada_lifetime_bound;
-
-  // If ignoreCase is true, the JavaScript regular expression created for each
-  // pattern must use the `vi` flag. Otherwise, they must use the `v` flag.
-  [[nodiscard]] bool ignore_case() const;
-
-  // @see https://urlpattern.spec.whatwg.org/#url-pattern-has-regexp-groups
-  [[nodiscard]] bool has_regexp_groups() const;
-
-#if ADA_TESTING
-  friend void PrintTo(const url_pattern &c, std::ostream *os) {
-    *os << "protocol_component: '" << c.get_protocol() << ", ";
-    *os << "username_component: '" << c.get_username() << ", ";
-    *os << "password_component: '" << c.get_password() << ", ";
-    *os << "hostname_component: '" << c.get_hostname() << ", ";
-    *os << "port_component: '" << c.get_port() << ", ";
-    *os << "pathname_component: '" << c.get_pathname() << ", ";
-    *os << "search_component: '" << c.get_search() << ", ";
-    *os << "hash_component: '" << c.get_hash();
-  }
-#endif // ADA_TESTING
-
-  template <url_pattern_regex::regex_concept P>
-  friend tl::expected<url_pattern<P>, errors> parser::parse_url_pattern_impl(
-      std::variant<std::string_view, url_pattern_init> input,
-      const std::string_view *base_url, const url_pattern_options *options);
-
-private:
-  url_pattern_component<regex_provider> protocol_component{};
-  url_pattern_component<regex_provider> username_component{};
-  url_pattern_component<regex_provider> password_component{};
-  url_pattern_component<regex_provider> hostname_component{};
-  url_pattern_component<regex_provider> port_component{};
-  url_pattern_component<regex_provider> pathname_component{};
-  url_pattern_component<regex_provider> search_component{};
-  url_pattern_component<regex_provider> hash_component{};
-  bool ignore_case_ = false;
-};
-
-} // namespace ada
-
-#endif
-/* end file include/ada/url_pattern.h */
-/* begin file include/ada/url_pattern_helpers.h */
-/**
- * @file url_pattern_helpers.h
- * @brief Declaration for the URLPattern helpers.
- */
-#ifndef ADA_URL_PATTERN_HELPERS_H
-#define ADA_URL_PATTERN_HELPERS_H
-
-#include <string>
-#include <tuple>
-#include <vector>
-
-namespace ada {
-enum class errors : uint8_t;
-}
-
-namespace ada::url_pattern_helpers {
-
-// @see https://urlpattern.spec.whatwg.org/#token
-enum class token_type : uint8_t {
-  INVALID_CHAR,   // 0
-  OPEN,           // 1
-  CLOSE,          // 2
-  REGEXP,         // 3
-  NAME,           // 4
-  CHAR,           // 5
-  ESCAPED_CHAR,   // 6
-  OTHER_MODIFIER, // 7
-  ASTERISK,       // 8
-  END,            // 9
-};
-
-std::string to_string(token_type type);
-
-// @see https://urlpattern.spec.whatwg.org/#tokenize-policy
-enum class token_policy {
-  strict,
-  lenient,
-};
-
-// @see https://urlpattern.spec.whatwg.org/#tokens
-class token {
-public:
-  token(token_type _type, size_t _index, std::string &&_value)
-      : type(_type), index(_index), value(std::move(_value)) {}
-
-  // A token has an associated type, a string, initially "invalid-char".
-  token_type type = token_type::INVALID_CHAR;
-
-  // A token has an associated index, a number, initially 0. It is the position
-  // of the first code point in the pattern string represented by the token.
-  size_t index = 0;
-
-  // A token has an associated value, a string, initially the empty string. It
-  // contains the code points from the pattern string represented by the token.
-  std::string value{};
-};
-
-// @see https://urlpattern.spec.whatwg.org/#pattern-parser
-template <url_pattern_encoding_callback F> class url_pattern_parser {
-public:
-  url_pattern_parser(F &encoding_callback_,
-                     std::string_view segment_wildcard_regexp_)
-      : encoding_callback(encoding_callback_),
-        segment_wildcard_regexp(segment_wildcard_regexp_) {}
-
-  bool can_continue() const { return index < tokens.size(); }
-
-  // @see https://urlpattern.spec.whatwg.org/#try-to-consume-a-token
-  token *try_consume_token(token_type type);
-  // @see https://urlpattern.spec.whatwg.org/#try-to-consume-a-modifier-token
-  token *try_consume_modifier_token();
-  // @see
-  // https://urlpattern.spec.whatwg.org/#try-to-consume-a-regexp-or-wildcard-token
-  token *try_consume_regexp_or_wildcard_token(const token *name_token);
-  // @see https://urlpattern.spec.whatwg.org/#consume-text
-  std::string consume_text();
-  // @see https://urlpattern.spec.whatwg.org/#consume-a-required-token
-  bool consume_required_token(token_type type);
-  // @see
-  // https://urlpattern.spec.whatwg.org/#maybe-add-a-part-from-the-pending-fixed-value
-  std::optional<errors>
-  maybe_add_part_from_the_pending_fixed_value() ada_warn_unused;
-  // @see https://urlpattern.spec.whatwg.org/#add-a-part
-  std::optional<errors> add_part(std::string_view prefix, token *name_token,
-                                 token *regexp_or_wildcard_token,
-                                 std::string_view suyffix,
-                                 token *modifier_token) ada_warn_unused;
-
-  std::vector<token> tokens{};
-  F &encoding_callback;
-  std::string segment_wildcard_regexp;
-  std::vector<url_pattern_part> parts{};
-  std::string pending_fixed_value{};
-  size_t index = 0;
-  size_t next_numeric_name = 0;
-};
-
-// @see https://urlpattern.spec.whatwg.org/#tokenizer
-class Tokenizer {
-public:
-  explicit Tokenizer(std::string_view new_input, token_policy new_policy)
-      : input(new_input), policy(new_policy) {}
-
-  // @see https://urlpattern.spec.whatwg.org/#get-the-next-code-point
-  void get_next_code_point();
-
-  // @see https://urlpattern.spec.whatwg.org/#seek-and-get-the-next-code-point
-  void seek_and_get_next_code_point(size_t index);
-
-  // @see https://urlpattern.spec.whatwg.org/#add-a-token
-
-  void add_token(token_type type, size_t next_position, size_t value_position,
-                 size_t value_length);
-
-  // @see https://urlpattern.spec.whatwg.org/#add-a-token-with-default-length
-  void add_token_with_default_length(token_type type, size_t next_position,
-                                     size_t value_position);
-
-  // @see
-  // https://urlpattern.spec.whatwg.org/#add-a-token-with-default-position-and-length
-  void add_token_with_defaults(token_type type);
-
-  // @see https://urlpattern.spec.whatwg.org/#process-a-tokenizing-error
-  std::optional<errors>
-  process_tokenizing_error(size_t next_position,
-                           size_t value_position) ada_warn_unused;
-
-  friend tl::expected<std::vector<token>, errors>
-  tokenize(std::string_view input, token_policy policy);
-
-private:
-  // has an associated input, a pattern string, initially the empty string.
-  std::string input;
-  // has an associated policy, a tokenize policy, initially "strict".
-  token_policy policy;
-  // has an associated token list, a token list, initially an empty list.
-  std::vector<token> token_list{};
-  // has an associated index, a number, initially 0.
-  size_t index = 0;
-  // has an associated next index, a number, initially 0.
-  size_t next_index = 0;
-  // has an associated code point, a Unicode code point, initially null.
-  char32_t code_point{};
-};
-
-// @see https://urlpattern.spec.whatwg.org/#constructor-string-parser
-template <url_pattern_regex::regex_concept regex_provider>
-struct constructor_string_parser {
-  explicit constructor_string_parser(std::string_view new_input,
-                                     std::vector<token> &&new_token_list)
-      : input(new_input), token_list(std::move(new_token_list)) {}
-
-  // @see https://urlpattern.spec.whatwg.org/#rewind
-  void rewind();
-
-  // @see https://urlpattern.spec.whatwg.org/#is-a-hash-prefix
-  bool is_hash_prefix();
-
-  // @see https://urlpattern.spec.whatwg.org/#is-a-search-prefix
-  bool is_search_prefix();
-
-  // @see https://urlpattern.spec.whatwg.org/#parse-a-constructor-string
-  static tl::expected<url_pattern_init, errors> parse(std::string_view input);
-
-  // @see https://urlpattern.spec.whatwg.org/#constructor-string-parser-state
-  enum class State {
-    INIT,
-    PROTOCOL,
-    AUTHORITY,
-    USERNAME,
-    PASSWORD,
-    HOSTNAME,
-    PORT,
-    PATHNAME,
-    SEARCH,
-    HASH,
-    DONE,
-  };
-
-  // @see https://urlpattern.spec.whatwg.org/#change-state
-  void change_state(State state, size_t skip);
-
-  // @see https://urlpattern.spec.whatwg.org/#is-a-group-open
-  bool is_group_open() const;
-
-  // @see https://urlpattern.spec.whatwg.org/#is-a-group-close
-  bool is_group_close() const;
-
-  // @see https://urlpattern.spec.whatwg.org/#is-a-protocol-suffix
-  bool is_protocol_suffix();
-
-  // @see
-  // https://urlpattern.spec.whatwg.org/#compute-protocol-matches-a-special-scheme-flag
-  std::optional<errors> compute_protocol_matches_special_scheme_flag();
-
-  // @see https://urlpattern.spec.whatwg.org/#next-is-authority-slashes
-  bool next_is_authority_slashes();
-
-  // @see https://urlpattern.spec.whatwg.org/#is-an-identity-terminator
-  bool is_an_identity_terminator();
-
-  // @see https://urlpattern.spec.whatwg.org/#is-a-pathname-start
-  bool is_pathname_start();
-
-  // @see https://urlpattern.spec.whatwg.org/#is-a-password-prefix
-  bool is_password_prefix();
-
-  // @see https://urlpattern.spec.whatwg.org/#is-an-ipv6-open
-  bool is_an_ipv6_open();
-
-  // @see https://urlpattern.spec.whatwg.org/#is-an-ipv6-close
-  bool is_an_ipv6_close();
-
-  // @see https://urlpattern.spec.whatwg.org/#is-a-port-prefix
-  bool is_port_prefix();
-
-private:
-  // @see https://urlpattern.spec.whatwg.org/#is-a-non-special-pattern-char
-  bool is_non_special_pattern_char(size_t index, std::string_view value);
-
-  // @see https://urlpattern.spec.whatwg.org/#get-a-safe-token
-  const token *get_safe_token(size_t index);
-
-  // @see https://urlpattern.spec.whatwg.org/#make-a-component-string
-  std::string make_component_string();
-  // has an associated input, a string, which must be set upon creation.
-  std::string input;
-  // has an associated token list, a token list, which must be set upon
-  // creation.
-  std::vector<token> token_list;
-  // has an associated result, a URLPatternInit, initially set to a new
-  // URLPatternInit.
-  url_pattern_init result{};
-  // has an associated component start, a number, initially set to 0.
-  size_t component_start = 0;
-  // has an associated token index, a number, initially set to 0.
-  size_t token_index = 0;
-  // has an associated token increment, a number, initially set to 1.
-  size_t token_increment = 1;
-  // has an associated group depth, a number, initially set to 0.
-  size_t group_depth = 0;
-  // has an associated hostname IPv6 bracket depth, a number, initially set to
-  // 0.
-  size_t hostname_ipv6_bracket_depth = 0;
-  // has an associated protocol matches a special scheme flag, a boolean,
-  // initially set to false.
-  bool protocol_matches_a_special_scheme_flag = false;
-  // has an associated state, a string, initially set to "init".
-  State state = State::INIT;
-};
-
-// @see https://urlpattern.spec.whatwg.org/#canonicalize-a-protocol
-tl::expected<std::string, errors> canonicalize_protocol(std::string_view input);
-
-// @see https://wicg.github.io/urlpattern/#canonicalize-a-username
-tl::expected<std::string, errors> canonicalize_username(std::string_view input);
-
-// @see https://wicg.github.io/urlpattern/#canonicalize-a-password
-tl::expected<std::string, errors> canonicalize_password(std::string_view input);
-
-// @see https://wicg.github.io/urlpattern/#canonicalize-a-password
-tl::expected<std::string, errors> canonicalize_hostname(std::string_view input);
-
-// @see https://wicg.github.io/urlpattern/#canonicalize-an-ipv6-hostname
-tl::expected<std::string, errors>
-canonicalize_ipv6_hostname(std::string_view input);
-
-// @see https://wicg.github.io/urlpattern/#canonicalize-a-port
-tl::expected<std::string, errors> canonicalize_port(std::string_view input);
-
-// @see https://wicg.github.io/urlpattern/#canonicalize-a-port
-tl::expected<std::string, errors>
-canonicalize_port_with_protocol(std::string_view input,
-                                std::string_view protocol);
-
-// @see https://wicg.github.io/urlpattern/#canonicalize-a-pathname
-tl::expected<std::string, errors> canonicalize_pathname(std::string_view input);
-
-// @see https://wicg.github.io/urlpattern/#canonicalize-an-opaque-pathname
-tl::expected<std::string, errors>
-canonicalize_opaque_pathname(std::string_view input);
-
-// @see https://wicg.github.io/urlpattern/#canonicalize-a-search
-tl::expected<std::string, errors> canonicalize_search(std::string_view input);
-
-// @see https://wicg.github.io/urlpattern/#canonicalize-a-hash
-tl::expected<std::string, errors> canonicalize_hash(std::string_view input);
-
-// @see https://urlpattern.spec.whatwg.org/#tokenize
-tl::expected<std::vector<token>, errors> tokenize(std::string_view input,
-                                                  token_policy policy);
-
-// @see https://urlpattern.spec.whatwg.org/#process-a-base-url-string
-std::string process_base_url_string(std::string_view input,
-                                    std::string_view type);
-
-// @see https://urlpattern.spec.whatwg.org/#escape-a-pattern-string
-std::string escape_pattern_string(std::string_view input);
-
-// @see https://urlpattern.spec.whatwg.org/#escape-a-regexp-string
-std::string escape_regexp_string(std::string_view input);
-
-// @see https://urlpattern.spec.whatwg.org/#is-an-absolute-pathname
-constexpr bool is_absolute_pathname(std::string_view input,
-                                    std::string_view type) noexcept;
-
-// @see https://urlpattern.spec.whatwg.org/#parse-a-pattern-string
-template <url_pattern_encoding_callback F>
-tl::expected<std::vector<url_pattern_part>, errors>
-parse_pattern_string(std::string_view input,
-                     url_pattern_compile_component_options &options,
-                     F &encoding_callback);
-
-// @see https://urlpattern.spec.whatwg.org/#generate-a-pattern-string
-std::string
-generate_pattern_string(std::vector<url_pattern_part> &part_list,
-                        url_pattern_compile_component_options &options);
-
-// @see
-// https://urlpattern.spec.whatwg.org/#generate-a-regular-expression-and-name-list
-std::tuple<std::string, std::vector<std::string>>
-generate_regular_expression_and_name_list(
-    const std::vector<url_pattern_part> &part_list,
-    url_pattern_compile_component_options options);
-
-// @see https://urlpattern.spec.whatwg.org/#hostname-pattern-is-an-ipv6-address
-bool is_ipv6_address(std::string_view input) noexcept;
-
-// @see
-// https://urlpattern.spec.whatwg.org/#protocol-component-matches-a-special-scheme
-template <url_pattern_regex::regex_concept regex_provider>
-bool protocol_component_matches_special_scheme(
-    ada::url_pattern_component<regex_provider> &input);
-
-// @see https://urlpattern.spec.whatwg.org/#convert-a-modifier-to-a-string
-std::string convert_modifier_to_string(url_pattern_part_modifier modifier);
-
-// @see https://urlpattern.spec.whatwg.org/#generate-a-segment-wildcard-regexp
-std::string
-generate_segment_wildcard_regexp(url_pattern_compile_component_options options);
-
-} // namespace ada::url_pattern_helpers
-
-#endif
-/* end file include/ada/url_pattern_helpers.h */
-
-#include <string_view>
-#include <variant>
-
-namespace ada::parser {
-template <url_pattern_regex::regex_concept regex_provider>
-tl::expected<url_pattern<regex_provider>, errors>
-parse_url_pattern_impl(std::variant<std::string_view, url_pattern_init> input,
-                       const std::string_view *base_url,
-                       const url_pattern_options *options) {
-  // Let init be null.
-  url_pattern_init init;
-
-  // If input is a scalar value string then:
-  if (std::holds_alternative<std::string_view>(input)) {
-    // Set init to the result of running parse a constructor string given input.
-    auto parse_result =
-        url_pattern_helpers::constructor_string_parser<regex_provider>::parse(
-            std::get<std::string_view>(input));
-    if (!parse_result) {
-      ada_log("constructor_string_parser::parse failed");
-      return tl::unexpected(parse_result.error());
-    }
-    init = std::move(*parse_result);
-    // If baseURL is null and init["protocol"] does not exist, then throw a
-    // TypeError.
-    if (!base_url && !init.protocol) {
-      ada_log("base url is null and protocol is not set");
-      return tl::unexpected(errors::type_error);
-    }
-
-    // If baseURL is not null, set init["baseURL"] to baseURL.
-    if (base_url) {
-      init.base_url = std::string(*base_url);
-    }
-  } else {
-    // Assert: input is a URLPatternInit.
-    ADA_ASSERT_TRUE(std::holds_alternative<url_pattern_init>(input));
-    // If baseURL is not null, then throw a TypeError.
-    if (base_url) {
-      ada_log("base url is not null");
-      return tl::unexpected(errors::type_error);
-    }
-    // Optimization: Avoid copy by moving the input value.
-    // Set init to input.
-    init = std::move(std::get<url_pattern_init>(input));
-  }
-
-  // Let processedInit be the result of process a URLPatternInit given init,
-  // "pattern", null, null, null, null, null, null, null, and null.
-  // TODO: Make "pattern" an enum to avoid creating a string everytime.
-  auto processed_init = url_pattern_init::process(init, "pattern");
-  if (!processed_init) {
-    ada_log("url_pattern_init::process failed for init and 'pattern'");
-    return tl::unexpected(processed_init.error());
-  }
-
-  // For each componentName of « "protocol", "username", "password", "hostname",
-  // "port", "pathname", "search", "hash" If processedInit[componentName] does
-  // not exist, then set processedInit[componentName] to "*".
-  ADA_ASSERT_TRUE(processed_init.has_value());
-  if (!processed_init->protocol)
-    processed_init->protocol = "*";
-  if (!processed_init->username)
-    processed_init->username = "*";
-  if (!processed_init->password)
-    processed_init->password = "*";
-  if (!processed_init->hostname)
-    processed_init->hostname = "*";
-  if (!processed_init->port)
-    processed_init->port = "*";
-  if (!processed_init->pathname)
-    processed_init->pathname = "*";
-  if (!processed_init->search)
-    processed_init->search = "*";
-  if (!processed_init->hash)
-    processed_init->hash = "*";
-
-  ada_log("-- processed_init->protocol: ", processed_init->protocol.value());
-  ada_log("-- processed_init->username: ", processed_init->username.value());
-  ada_log("-- processed_init->password: ", processed_init->password.value());
-  ada_log("-- processed_init->hostname: ", processed_init->hostname.value());
-  ada_log("-- processed_init->port: ", processed_init->port.value());
-  ada_log("-- processed_init->pathname: ", processed_init->pathname.value());
-  ada_log("-- processed_init->search: ", processed_init->search.value());
-  ada_log("-- processed_init->hash: ", processed_init->hash.value());
-
-  // If processedInit["protocol"] is a special scheme and processedInit["port"]
-  // is a string which represents its corresponding default port in radix-10
-  // using ASCII digits then set processedInit["port"] to the empty string.
-  // TODO: Optimization opportunity.
-  if (scheme::is_special(*processed_init->protocol)) {
-    std::string_view port = processed_init->port.value();
-    helpers::trim_c0_whitespace(port);
-    if (std::to_string(scheme::get_special_port(*processed_init->protocol)) ==
-        port) {
-      processed_init->port->clear();
-    }
-  }
-
-  // Let urlPattern be a new URL pattern.
-  url_pattern<regex_provider> url_pattern_{};
-
-  // Set urlPattern’s protocol component to the result of compiling a component
-  // given processedInit["protocol"], canonicalize a protocol, and default
-  // options.
-  auto protocol_component = url_pattern_component<regex_provider>::compile(
-      processed_init->protocol.value(),
-      url_pattern_helpers::canonicalize_protocol,
-      url_pattern_compile_component_options::DEFAULT);
-  if (!protocol_component) {
-    ada_log("url_pattern_component::compile failed for protocol ",
-            processed_init->protocol.value());
-    return tl::unexpected(protocol_component.error());
-  }
-  url_pattern_.protocol_component = std::move(*protocol_component);
-
-  // Set urlPattern’s username component to the result of compiling a component
-  // given processedInit["username"], canonicalize a username, and default
-  // options.
-  auto username_component = url_pattern_component<regex_provider>::compile(
-      processed_init->username.value(),
-      url_pattern_helpers::canonicalize_username,
-      url_pattern_compile_component_options::DEFAULT);
-  if (!username_component) {
-    ada_log("url_pattern_component::compile failed for username ",
-            processed_init->username.value());
-    return tl::unexpected(username_component.error());
-  }
-  url_pattern_.username_component = std::move(*username_component);
-
-  // Set urlPattern’s password component to the result of compiling a component
-  // given processedInit["password"], canonicalize a password, and default
-  // options.
-  auto password_component = url_pattern_component<regex_provider>::compile(
-      processed_init->password.value(),
-      url_pattern_helpers::canonicalize_password,
-      url_pattern_compile_component_options::DEFAULT);
-  if (!password_component) {
-    ada_log("url_pattern_component::compile failed for password ",
-            processed_init->password.value());
-    return tl::unexpected(password_component.error());
-  }
-  url_pattern_.password_component = std::move(*password_component);
-
-  // TODO: Optimization opportunity. The following if statement can be
-  // simplified.
-  // If the result running hostname pattern is an IPv6 address given
-  // processedInit["hostname"] is true, then set urlPattern’s hostname component
-  // to the result of compiling a component given processedInit["hostname"],
-  // canonicalize an IPv6 hostname, and hostname options.
-  if (url_pattern_helpers::is_ipv6_address(processed_init->hostname.value())) {
-    ada_log("processed_init->hostname is ipv6 address");
-    // then set urlPattern’s hostname component to the result of compiling a
-    // component given processedInit["hostname"], canonicalize an IPv6 hostname,
-    // and hostname options.
-    auto hostname_component = url_pattern_component<regex_provider>::compile(
-        processed_init->hostname.value(),
-        url_pattern_helpers::canonicalize_ipv6_hostname,
-        url_pattern_compile_component_options::DEFAULT);
-    if (!hostname_component) {
-      ada_log("url_pattern_component::compile failed for ipv6 hostname ",
-              processed_init->hostname.value());
-      return tl::unexpected(hostname_component.error());
-    }
-    url_pattern_.hostname_component = std::move(*hostname_component);
-  } else {
-    // Otherwise, set urlPattern’s hostname component to the result of compiling
-    // a component given processedInit["hostname"], canonicalize a hostname, and
-    // hostname options.
-    auto hostname_component = url_pattern_component<regex_provider>::compile(
-        processed_init->hostname.value(),
-        url_pattern_helpers::canonicalize_hostname,
-        url_pattern_compile_component_options::HOSTNAME);
-    if (!hostname_component) {
-      ada_log("url_pattern_component::compile failed for hostname ",
-              processed_init->hostname.value());
-      return tl::unexpected(hostname_component.error());
-    }
-    url_pattern_.hostname_component = std::move(*hostname_component);
-  }
-
-  // Set urlPattern’s port component to the result of compiling a component
-  // given processedInit["port"], canonicalize a port, and default options.
-  auto port_component = url_pattern_component<regex_provider>::compile(
-      processed_init->port.value(), url_pattern_helpers::canonicalize_port,
-      url_pattern_compile_component_options::DEFAULT);
-  if (!port_component) {
-    ada_log("url_pattern_component::compile failed for port ",
-            processed_init->port.value());
-    return tl::unexpected(port_component.error());
-  }
-  url_pattern_.port_component = std::move(*port_component);
-
-  // Let compileOptions be a copy of the default options with the ignore case
-  // property set to options["ignoreCase"].
-  auto compile_options = url_pattern_compile_component_options::DEFAULT;
-  if (options) {
-    compile_options.ignore_case = options->ignore_case;
-  }
-
-  // TODO: Optimization opportunity: Simplify this if statement.
-  // If the result of running protocol component matches a special scheme given
-  // urlPattern’s protocol component is true, then:
-  if (url_pattern_helpers::protocol_component_matches_special_scheme<
-          regex_provider>(url_pattern_.protocol_component)) {
-    // Let pathCompileOptions be copy of the pathname options with the ignore
-    // case property set to options["ignoreCase"].
-    auto path_compile_options = url_pattern_compile_component_options::PATHNAME;
-    if (options) {
-      path_compile_options.ignore_case = options->ignore_case;
-    }
-
-    // Set urlPattern’s pathname component to the result of compiling a
-    // component given processedInit["pathname"], canonicalize a pathname, and
-    // pathCompileOptions.
-    auto pathname_component = url_pattern_component<regex_provider>::compile(
-        processed_init->pathname.value(),
-        url_pattern_helpers::canonicalize_pathname, path_compile_options);
-    if (!pathname_component) {
-      ada_log("url_pattern_component::compile failed for pathname ",
-              processed_init->pathname.value());
-      return tl::unexpected(pathname_component.error());
-    }
-    url_pattern_.pathname_component = std::move(*pathname_component);
-  } else {
-    // Otherwise set urlPattern’s pathname component to the result of compiling
-    // a component given processedInit["pathname"], canonicalize an opaque
-    // pathname, and compileOptions.
-    auto pathname_component = url_pattern_component<regex_provider>::compile(
-        processed_init->pathname.value(),
-        url_pattern_helpers::canonicalize_opaque_pathname, compile_options);
-    if (!pathname_component) {
-      ada_log("url_pattern_component::compile failed for opaque pathname ",
-              processed_init->pathname.value());
-      return tl::unexpected(pathname_component.error());
-    }
-    url_pattern_.pathname_component = std::move(*pathname_component);
-  }
-
-  // Set urlPattern’s search component to the result of compiling a component
-  // given processedInit["search"], canonicalize a search, and compileOptions.
-  auto search_component = url_pattern_component<regex_provider>::compile(
-      processed_init->search.value(), url_pattern_helpers::canonicalize_search,
-      compile_options);
-  if (!search_component) {
-    ada_log("url_pattern_component::compile failed for search ",
-            processed_init->search.value());
-    return tl::unexpected(search_component.error());
-  }
-  url_pattern_.search_component = std::move(*search_component);
-
-  // Set urlPattern’s hash component to the result of compiling a component
-  // given processedInit["hash"], canonicalize a hash, and compileOptions.
-  auto hash_component = url_pattern_component<regex_provider>::compile(
-      processed_init->hash.value(), url_pattern_helpers::canonicalize_hash,
-      compile_options);
-  if (!hash_component) {
-    ada_log("url_pattern_component::compile failed for hash ",
-            processed_init->hash.value());
-    return tl::unexpected(hash_component.error());
-  }
-  url_pattern_.hash_component = std::move(*hash_component);
-
-  // Return urlPattern.
-  return url_pattern_;
-}
-
-} // namespace ada::parser
-
-#endif // ADA_PARSER_INL_H
-/* end file include/ada/parser-inl.h */
-/* begin file include/ada/scheme-inl.h */
-/**
- * @file scheme-inl.h
- * @brief Definitions for the URL scheme.
- */
-#ifndef ADA_SCHEME_INL_H
-#define ADA_SCHEME_INL_H
-
-namespace ada::scheme {
-
-/**
- * @namespace ada::scheme::details
- * @brief Includes the definitions for scheme specific entities
- */
-namespace details {
-// for use with is_special and get_special_port
-// Spaces, if present, are removed from URL.
-constexpr std::string_view is_special_list[] = {"http", " ",   "https", "ws",
-                                                "ftp",  "wss", "file",  " "};
-// for use with get_special_port
-constexpr uint16_t special_ports[] = {80, 0, 443, 80, 21, 443, 0, 0};
-} // namespace details
-
-/****
- * @private
- * In is_special, get_scheme_type, and get_special_port, we
- * use a standard hashing technique to find the index of the scheme in
- * the is_special_list. The hashing technique is based on the size of
- * the scheme and the first character of the scheme. It ensures that we
- * do at most one string comparison per call. If the protocol is
- * predictible (e.g., it is always "http"), we can get a better average
- * performance by using a simpler approach where we loop and compare
- * scheme with all possible protocols starting with the most likely
- * protocol. Doing multiple comparisons may have a poor worst case
- * performance, however. In this instance, we choose a potentially
- * slightly lower best-case performance for a better worst-case
- * performance. We can revisit this choice at any time.
- *
- * Reference:
- * Schmidt, Douglas C. "Gperf: A perfect hash function generator."
- * More C++ gems 17 (2000).
- *
- * Reference: https://en.wikipedia.org/wiki/Perfect_hash_function
- *
- * Reference: https://github.com/ada-url/ada/issues/617
- ****/
-
-ada_really_inline constexpr bool is_special(std::string_view scheme) {
-  if (scheme.empty()) {
-    return false;
-  }
-  int hash_value = (2 * scheme.size() + (unsigned)(scheme[0])) & 7;
-  const std::string_view target = details::is_special_list[hash_value];
-  return (target[0] == scheme[0]) && (target.substr(1) == scheme.substr(1));
-}
-constexpr uint16_t get_special_port(std::string_view scheme) noexcept {
-  if (scheme.empty()) {
-    return 0;
-  }
-  int hash_value = (2 * scheme.size() + (unsigned)(scheme[0])) & 7;
-  const std::string_view target = details::is_special_list[hash_value];
-  if ((target[0] == scheme[0]) && (target.substr(1) == scheme.substr(1))) {
-    return details::special_ports[hash_value];
-  } else {
-    return 0;
-  }
-}
-constexpr uint16_t get_special_port(ada::scheme::type type) noexcept {
-  return details::special_ports[int(type)];
-}
-constexpr ada::scheme::type get_scheme_type(std::string_view scheme) noexcept {
-  if (scheme.empty()) {
-    return ada::scheme::NOT_SPECIAL;
-  }
-  int hash_value = (2 * scheme.size() + (unsigned)(scheme[0])) & 7;
-  const std::string_view target = details::is_special_list[hash_value];
-  if ((target[0] == scheme[0]) && (target.substr(1) == scheme.substr(1))) {
-    return ada::scheme::type(hash_value);
-  } else {
-    return ada::scheme::NOT_SPECIAL;
-  }
-}
-
-} // namespace ada::scheme
-
-#endif // ADA_SCHEME_INL_H
-/* end file include/ada/scheme-inl.h */
-/* begin file include/ada/serializers.h */
-/**
- * @file serializers.h
- * @brief Definitions for the URL serializers.
- */
-#ifndef ADA_SERIALIZERS_H
-#define ADA_SERIALIZERS_H
-
-#include <array>
-#include <string>
-
-/**
- * @namespace ada::serializers
- * @brief Includes the definitions for URL serializers
- */
-namespace ada::serializers {
-
-/**
- * Finds and returns the longest sequence of 0 values in a ipv6 input.
- */
-void find_longest_sequence_of_ipv6_pieces(
-    const std::array<uint16_t, 8> &address, size_t &compress,
-    size_t &compress_length) noexcept;
-
-/**
- * Serializes an ipv6 address.
- * @details An IPv6 address is a 128-bit unsigned integer that identifies a
- * network address.
- * @see https://url.spec.whatwg.org/#concept-ipv6-serializer
- */
-std::string ipv6(const std::array<uint16_t, 8> &address) noexcept;
-
-/**
- * Serializes an ipv4 address.
- * @details An IPv4 address is a 32-bit unsigned integer that identifies a
- * network address.
- * @see https://url.spec.whatwg.org/#concept-ipv4-serializer
- */
-std::string ipv4(uint64_t address) noexcept;
-
-} // namespace ada::serializers
-
-#endif // ADA_SERIALIZERS_H
-/* end file include/ada/serializers.h */
-/* begin file include/ada/state.h */
-/**
- * @file state.h
- * @brief Definitions for the states of the URL state machine.
- */
-#ifndef ADA_STATE_H
-#define ADA_STATE_H
-
-#include <string>
-
-namespace ada {
-
-/**
- * @see https://url.spec.whatwg.org/#url-parsing
- */
-enum class state {
-  /**
-   * @see https://url.spec.whatwg.org/#authority-state
-   */
-  AUTHORITY,
-
-  /**
-   * @see https://url.spec.whatwg.org/#scheme-start-state
-   */
-  SCHEME_START,
-
-  /**
-   * @see https://url.spec.whatwg.org/#scheme-state
-   */
-  SCHEME,
-
-  /**
-   * @see https://url.spec.whatwg.org/#host-state
-   */
-  HOST,
-
-  /**
-   * @see https://url.spec.whatwg.org/#no-scheme-state
-   */
-  NO_SCHEME,
-
-  /**
-   * @see https://url.spec.whatwg.org/#fragment-state
-   */
-  FRAGMENT,
-
-  /**
-   * @see https://url.spec.whatwg.org/#relative-state
-   */
-  RELATIVE_SCHEME,
-
-  /**
-   * @see https://url.spec.whatwg.org/#relative-slash-state
-   */
-  RELATIVE_SLASH,
-
-  /**
-   * @see https://url.spec.whatwg.org/#file-state
-   */
-  FILE,
-
-  /**
-   * @see https://url.spec.whatwg.org/#file-host-state
-   */
-  FILE_HOST,
-
-  /**
-   * @see https://url.spec.whatwg.org/#file-slash-state
-   */
-  FILE_SLASH,
-
-  /**
-   * @see https://url.spec.whatwg.org/#path-or-authority-state
-   */
-  PATH_OR_AUTHORITY,
-
-  /**
-   * @see https://url.spec.whatwg.org/#special-authority-ignore-slashes-state
-   */
-  SPECIAL_AUTHORITY_IGNORE_SLASHES,
-
-  /**
-   * @see https://url.spec.whatwg.org/#special-authority-slashes-state
-   */
-  SPECIAL_AUTHORITY_SLASHES,
-
-  /**
-   * @see https://url.spec.whatwg.org/#special-relative-or-authority-state
-   */
-  SPECIAL_RELATIVE_OR_AUTHORITY,
-
-  /**
-   * @see https://url.spec.whatwg.org/#query-state
-   */
-  QUERY,
-
-  /**
-   * @see https://url.spec.whatwg.org/#path-state
-   */
-  PATH,
-
-  /**
-   * @see https://url.spec.whatwg.org/#path-start-state
-   */
-  PATH_START,
-
-  /**
-   * @see https://url.spec.whatwg.org/#cannot-be-a-base-url-path-state
-   */
-  OPAQUE_PATH,
-
-  /**
-   * @see https://url.spec.whatwg.org/#port-state
-   */
-  PORT,
-};
-
-/**
- * Stringify a URL state machine state.
- */
-ada_warn_unused std::string to_string(ada::state s);
-
-} // namespace ada
-
-#endif // ADA_STATE_H
-/* end file include/ada/state.h */
-/* begin file include/ada/unicode.h */
-/**
- * @file unicode.h
- * @brief Definitions for all unicode specific functions.
- */
-#ifndef ADA_UNICODE_H
-#define ADA_UNICODE_H
-
-#include <optional>
-#include <string>
-
-/**
- * Unicode operations. These functions are not part of our public API and may
- * change at any time.
- *
- * @private
- * @namespace ada::unicode
- * @brief Includes the definitions for unicode operations
- */
-namespace ada::unicode {
-
-/**
- * @private
- * We receive a UTF-8 string representing a domain name.
- * If the string is percent encoded, we apply percent decoding.
- *
- * Given a domain, we need to identify its labels.
- * They are separated by label-separators:
- *
- * U+002E (.) FULL STOP
- * U+FF0E FULLWIDTH FULL STOP
- * U+3002 IDEOGRAPHIC FULL STOP
- * U+FF61 HALFWIDTH IDEOGRAPHIC FULL STOP
- *
- * They are all mapped to U+002E.
- *
- * We process each label into a string that should not exceed 63 octets.
- * If the string is already punycode (starts with "xn--"), then we must
- * scan it to look for unallowed code points.
- * Otherwise, if the string is not pure ASCII, we need to transcode it
- * to punycode by following RFC 3454 which requires us to
- * - Map characters  (see section 3),
- * - Normalize (see section 4),
- * - Reject forbidden characters,
- * - Check for right-to-left characters and if so, check all requirements (see
- * section 6),
- * - Optionally reject based on unassigned code points (section 7).
- *
- * The Unicode standard provides a table of code points with a mapping, a list
- * of forbidden code points and so forth. This table is subject to change and
- * will vary based on the implementation. For Unicode 15, the table is at
- * https://www.unicode.org/Public/idna/15.0.0/IdnaMappingTable.txt
- * If you use ICU, they parse this table and map it to code using a Python
- * script.
- *
- * The resulting strings should not exceed 255 octets according to RFC 1035
- * section 2.3.4. ICU checks for label size and domain size, but these errors
- * are ignored.
- *
- * @see https://url.spec.whatwg.org/#concept-domain-to-ascii
- *
- */
-bool to_ascii(std::optional<std::string> &out, std::string_view plain,
-              size_t first_percent);
-
-/**
- * @private
- * Checks if the input has tab or newline characters.
- *
- * @attention The has_tabs_or_newline function is a bottleneck and it is simple
- * enough that compilers like GCC can 'autovectorize it'.
- */
-ada_really_inline bool
-has_tabs_or_newline(std::string_view user_input) noexcept;
-
-/**
- * @private
- * Checks if the input is a forbidden host code point.
- * @see https://url.spec.whatwg.org/#forbidden-host-code-point
- */
-ada_really_inline constexpr bool is_forbidden_host_code_point(char c) noexcept;
-
-/**
- * @private
- * Checks if the input contains a forbidden domain code point.
- * @see https://url.spec.whatwg.org/#forbidden-domain-code-point
- */
-ada_really_inline constexpr bool
-contains_forbidden_domain_code_point(const char *input, size_t length) noexcept;
-
-/**
- * @private
- * Checks if the input contains a forbidden domain code point in which case
- * the first bit is set to 1. If the input contains an upper case ASCII letter,
- * then the second bit is set to 1.
- * @see https://url.spec.whatwg.org/#forbidden-domain-code-point
- */
-ada_really_inline constexpr uint8_t
-contains_forbidden_domain_code_point_or_upper(const char *input,
-                                              size_t length) noexcept;
-
-/**
- * @private
- * Checks if the input is a forbidden domain code point.
- * @see https://url.spec.whatwg.org/#forbidden-domain-code-point
- */
-ada_really_inline constexpr bool
-is_forbidden_domain_code_point(char c) noexcept;
-
-/**
- * @private
- * Checks if the input is alphanumeric, '+', '-' or '.'
- */
-ada_really_inline constexpr bool is_alnum_plus(char c) noexcept;
-
-/**
- * @private
- * @details An ASCII hex digit is an ASCII upper hex digit or ASCII lower hex
- * digit. An ASCII upper hex digit is an ASCII digit or a code point in the
- * range U+0041 (A) to U+0046 (F), inclusive. An ASCII lower hex digit is an
- * ASCII digit or a code point in the range U+0061 (a) to U+0066 (f), inclusive.
- */
-ada_really_inline constexpr bool is_ascii_hex_digit(char c) noexcept;
-
-/**
- * @private
- * An ASCII digit is a code point in the range U+0030 (0) to U+0039 (9),
- * inclusive.
- */
-ada_really_inline constexpr bool is_ascii_digit(char c) noexcept;
-
-/**
- * @private
- * @details If a char is between U+0000 and U+007F inclusive, then it's an ASCII
- * character.
- */
-ada_really_inline constexpr bool is_ascii(char32_t c) noexcept;
-
-/**
- * @private
- * Checks if the input is a C0 control or space character.
- *
- * @details A C0 control or space is a C0 control or U+0020 SPACE.
- * A C0 control is a code point in the range U+0000 NULL to U+001F INFORMATION
- * SEPARATOR ONE, inclusive.
- */
-ada_really_inline constexpr bool is_c0_control_or_space(char c) noexcept;
-
-/**
- * @private
- * Checks if the input is a ASCII tab or newline character.
- *
- * @details An ASCII tab or newline is U+0009 TAB, U+000A LF, or U+000D CR.
- */
-ada_really_inline constexpr bool is_ascii_tab_or_newline(char c) noexcept;
-
-/**
- * @private
- * @details A double-dot path segment must be ".." or an ASCII case-insensitive
- * match for ".%2e", "%2e.", or "%2e%2e".
- */
-ada_really_inline constexpr bool
-is_double_dot_path_segment(std::string_view input) noexcept;
-
-/**
- * @private
- * @details A single-dot path segment must be "." or an ASCII case-insensitive
- * match for "%2e".
- */
-ada_really_inline constexpr bool
-is_single_dot_path_segment(std::string_view input) noexcept;
-
-/**
- * @private
- * @details ipv4 character might contain 0-9 or a-f character ranges.
- */
-ada_really_inline constexpr bool is_lowercase_hex(char c) noexcept;
-
-/**
- * @private
- * @details Convert hex to binary. Caller is responsible to ensure that
- * the parameter is an hexadecimal digit (0-9, A-F, a-f).
- */
-ada_really_inline unsigned constexpr convert_hex_to_binary(char c) noexcept;
-
-/**
- * @private
- * first_percent should be  = input.find('%')
- *
- * @todo It would be faster as noexcept maybe, but it could be unsafe since.
- * @author Node.js
- * @see https://github.com/nodejs/node/blob/main/src/node_url.cc#L245
- * @see https://encoding.spec.whatwg.org/#utf-8-decode-without-bom
- */
-std::string percent_decode(std::string_view input, size_t first_percent);
-
-/**
- * @private
- * Returns a percent-encoding string whether percent encoding was needed or not.
- * @see https://github.com/nodejs/node/blob/main/src/node_url.cc#L226
- */
-std::string percent_encode(std::string_view input,
-                           const uint8_t character_set[]);
-/**
- * @private
- * Returns a percent-encoded string version of input, while starting the percent
- * encoding at the provided index.
- * @see https://github.com/nodejs/node/blob/main/src/node_url.cc#L226
- */
-std::string percent_encode(std::string_view input,
-                           const uint8_t character_set[], size_t index);
-/**
- * @private
- * Returns true if percent encoding was needed, in which case, we store
- * the percent-encoded content in 'out'. If the boolean 'append' is set to
- * true, the content is appended to 'out'.
- * If percent encoding is not needed, out is left unchanged.
- * @see https://github.com/nodejs/node/blob/main/src/node_url.cc#L226
- */
-template <bool append>
-bool percent_encode(std::string_view input, const uint8_t character_set[],
-                    std::string &out);
-/**
- * @private
- * Returns the index at which percent encoding should start, or (equivalently),
- * the length of the prefix that does not require percent encoding.
- */
-ada_really_inline size_t percent_encode_index(std::string_view input,
-                                              const uint8_t character_set[]);
-/**
- * @private
- * Lowers the string in-place, assuming that the content is ASCII.
- * Return true if the content was ASCII.
- */
-constexpr bool to_lower_ascii(char *input, size_t length) noexcept;
-} // namespace ada::unicode
-
-#endif // ADA_UNICODE_H
-/* end file include/ada/unicode.h */
-/* begin file include/ada/url_base-inl.h */
-/**
- * @file url_base-inl.h
- * @brief Inline functions for url base
- */
-#ifndef ADA_URL_BASE_INL_H
-#define ADA_URL_BASE_INL_H
-
-#include <string>
-#if ADA_REGULAR_VISUAL_STUDIO
-#include <intrin.h>
-#endif // ADA_REGULAR_VISUAL_STUDIO
-
-namespace ada {
-
-[[nodiscard]] ada_really_inline constexpr bool
-url_base::is_special() const noexcept {
-  return type != ada::scheme::NOT_SPECIAL;
-}
-
-[[nodiscard]] inline uint16_t url_base::get_special_port() const noexcept {
-  return ada::scheme::get_special_port(type);
-}
-
-[[nodiscard]] ada_really_inline uint16_t
-url_base::scheme_default_port() const noexcept {
-  return scheme::get_special_port(type);
-}
-
-} // namespace ada
-
-#endif // ADA_URL_BASE_INL_H
-/* end file include/ada/url_base-inl.h */
-/* begin file include/ada/url-inl.h */
-/**
- * @file url-inl.h
- * @brief Definitions for the URL
- */
-#ifndef ADA_URL_INL_H
-#define ADA_URL_INL_H
-
-#include <charconv>
-#include <optional>
-#include <string>
-#if ADA_REGULAR_VISUAL_STUDIO
-#include <intrin.h>
-#endif // ADA_REGULAR_VISUAL_STUDIO
-
-namespace ada {
-[[nodiscard]] ada_really_inline bool url::has_credentials() const noexcept {
-  return !username.empty() || !password.empty();
-}
-[[nodiscard]] ada_really_inline bool url::has_port() const noexcept {
-  return port.has_value();
-}
-[[nodiscard]] inline bool url::cannot_have_credentials_or_port() const {
-  return !host.has_value() || host.value().empty() ||
-         type == ada::scheme::type::FILE;
-}
-[[nodiscard]] inline bool url::has_empty_hostname() const noexcept {
-  if (!host.has_value()) {
-    return false;
-  }
-  return host.value().empty();
-}
-[[nodiscard]] inline bool url::has_hostname() const noexcept {
-  return host.has_value();
-}
-inline std::ostream &operator<<(std::ostream &out, const ada::url &u) {
-  return out << u.to_string();
-}
-
-[[nodiscard]] size_t url::get_pathname_length() const noexcept {
-  return path.size();
-}
-
-[[nodiscard]] constexpr std::string_view url::get_pathname() const noexcept {
-  return path;
-}
-
-[[nodiscard]] ada_really_inline ada::url_components
-url::get_components() const noexcept {
-  url_components out{};
-
-  // protocol ends with ':'. for example: "https:"
-  out.protocol_end = uint32_t(get_protocol().size());
-
-  // Trailing index is always the next character of the current one.
-  size_t running_index = out.protocol_end;
-
-  if (host.has_value()) {
-    // 2 characters for "//" and 1 character for starting index
-    out.host_start = out.protocol_end + 2;
-
-    if (has_credentials()) {
-      out.username_end = uint32_t(out.host_start + username.size());
-
-      out.host_start += uint32_t(username.size());
-
-      if (!password.empty()) {
-        out.host_start += uint32_t(password.size() + 1);
-      }
-
-      out.host_end = uint32_t(out.host_start + host.value().size());
-    } else {
-      out.username_end = out.host_start;
-
-      // Host does not start with "@" if it does not include credentials.
-      out.host_end = uint32_t(out.host_start + host.value().size()) - 1;
-    }
-
-    running_index = out.host_end + 1;
-  } else {
-    // Update host start and end date to the same index, since it does not
-    // exist.
-    out.host_start = out.protocol_end;
-    out.host_end = out.host_start;
-
-    if (!has_opaque_path && path.starts_with("//")) {
-      // If url's host is null, url does not have an opaque path, url's path's
-      // size is greater than 1, and url's path[0] is the empty string, then
-      // append U+002F (/) followed by U+002E (.) to output.
-      running_index = out.protocol_end + 2;
-    } else {
-      running_index = out.protocol_end;
-    }
-  }
-
-  if (port.has_value()) {
-    out.port = *port;
-    running_index += helpers::fast_digit_count(*port) + 1; // Port omits ':'
-  }
-
-  out.pathname_start = uint32_t(running_index);
-
-  running_index += path.size();
-
-  if (query.has_value()) {
-    out.search_start = uint32_t(running_index);
-    running_index += get_search().size();
-    if (get_search().empty()) {
-      running_index++;
-    }
-  }
-
-  if (hash.has_value()) {
-    out.hash_start = uint32_t(running_index);
-  }
-
-  return out;
-}
-
-inline void url::update_base_hostname(std::string_view input) { host = input; }
-
-inline void url::update_unencoded_base_hash(std::string_view input) {
-  // We do the percent encoding
-  hash = unicode::percent_encode(input,
-                                 ada::character_sets::FRAGMENT_PERCENT_ENCODE);
-}
-
-inline void url::update_base_search(std::string_view input,
-                                    const uint8_t query_percent_encode_set[]) {
-  query = ada::unicode::percent_encode(input, query_percent_encode_set);
-}
-
-inline void url::update_base_search(std::optional<std::string> &&input) {
-  query = std::move(input);
-}
-
-inline void url::update_base_pathname(const std::string_view input) {
-  path = input;
-}
-
-inline void url::update_base_username(const std::string_view input) {
-  username = input;
-}
-
-inline void url::update_base_password(const std::string_view input) {
-  password = input;
-}
-
-inline void url::update_base_port(std::optional<uint16_t> input) {
-  port = input;
-}
-
-constexpr void url::clear_pathname() { path.clear(); }
-
-constexpr void url::clear_search() { query = std::nullopt; }
-
-[[nodiscard]] constexpr bool url::has_hash() const noexcept {
-  return hash.has_value();
-}
-
-[[nodiscard]] constexpr bool url::has_search() const noexcept {
-  return query.has_value();
-}
-
-constexpr void url::set_protocol_as_file() { type = ada::scheme::type::FILE; }
-
-inline void url::set_scheme(std::string &&new_scheme) noexcept {
-  type = ada::scheme::get_scheme_type(new_scheme);
-  // We only move the 'scheme' if it is non-special.
-  if (!is_special()) {
-    non_special_scheme = std::move(new_scheme);
-  }
-}
-
-constexpr void url::copy_scheme(ada::url &&u) noexcept {
-  non_special_scheme = u.non_special_scheme;
-  type = u.type;
-}
-
-constexpr void url::copy_scheme(const ada::url &u) {
-  non_special_scheme = u.non_special_scheme;
-  type = u.type;
-}
-
-[[nodiscard]] ada_really_inline std::string url::get_href() const noexcept {
-  std::string output = get_protocol();
-
-  if (host.has_value()) {
-    output += "//";
-    if (has_credentials()) {
-      output += username;
-      if (!password.empty()) {
-        output += ":" + get_password();
-      }
-      output += "@";
-    }
-    output += host.value();
-    if (port.has_value()) {
-      output += ":" + get_port();
-    }
-  } else if (!has_opaque_path && path.starts_with("//")) {
-    // If url's host is null, url does not have an opaque path, url's path's
-    // size is greater than 1, and url's path[0] is the empty string, then
-    // append U+002F (/) followed by U+002E (.) to output.
-    output += "/.";
-  }
-  output += path;
-  if (query.has_value()) {
-    output += "?" + query.value();
-  }
-  if (hash.has_value()) {
-    output += "#" + hash.value();
-  }
-  return output;
-}
-
-ada_really_inline size_t url::parse_port(std::string_view view,
-                                         bool check_trailing_content) noexcept {
-  ada_log("parse_port('", view, "') ", view.size());
-  if (!view.empty() && view[0] == '-') {
-    ada_log("parse_port: view[0] == '0' && view.size() > 1");
-    is_valid = false;
-    return 0;
-  }
-  uint16_t parsed_port{};
-  auto r = std::from_chars(view.data(), view.data() + view.size(), parsed_port);
-  if (r.ec == std::errc::result_out_of_range) {
-    ada_log("parse_port: r.ec == std::errc::result_out_of_range");
-    is_valid = false;
-    return 0;
-  }
-  ada_log("parse_port: ", parsed_port);
-  const auto consumed = size_t(r.ptr - view.data());
-  ada_log("parse_port: consumed ", consumed);
-  if (check_trailing_content) {
-    is_valid &=
-        (consumed == view.size() || view[consumed] == '/' ||
-         view[consumed] == '?' || (is_special() && view[consumed] == '\\'));
-  }
-  ada_log("parse_port: is_valid = ", is_valid);
-  if (is_valid) {
-    // scheme_default_port can return 0, and we should allow 0 as a base port.
-    auto default_port = scheme_default_port();
-    bool is_port_valid = (default_port == 0 && parsed_port == 0) ||
-                         (default_port != parsed_port);
-    port = (r.ec == std::errc() && is_port_valid) ? std::optional(parsed_port)
-                                                  : std::nullopt;
-  }
-  return consumed;
-}
-
-} // namespace ada
-
-#endif // ADA_URL_H
-/* end file include/ada/url-inl.h */
-/* begin file include/ada/url_components-inl.h */
-/**
- * @file url_components.h
- * @brief Declaration for the URL Components
- */
-#ifndef ADA_URL_COMPONENTS_INL_H
-#define ADA_URL_COMPONENTS_INL_H
-
-namespace ada {
-
-[[nodiscard]] constexpr bool
-url_components::check_offset_consistency() const noexcept {
-  /**
-   * https://user:pass@example.com:1234/foo/bar?baz#quux
-   *       |     |    |          | ^^^^|       |   |
-   *       |     |    |          | |   |       |   `----- hash_start
-   *       |     |    |          | |   |       `--------- search_start
-   *       |     |    |          | |   `----------------- pathname_start
-   *       |     |    |          | `--------------------- port
-   *       |     |    |          `----------------------- host_end
-   *       |     |    `---------------------------------- host_start
-   *       |     `--------------------------------------- username_end
-   *       `--------------------------------------------- protocol_end
-   */
-  // These conditions can be made more strict.
-  if (protocol_end == url_components::omitted) {
-    return false;
-  }
-  uint32_t index = protocol_end;
-
-  if (username_end == url_components::omitted) {
-    return false;
-  }
-  if (username_end < index) {
-    return false;
-  }
-  index = username_end;
-
-  if (host_start == url_components::omitted) {
-    return false;
-  }
-  if (host_start < index) {
-    return false;
-  }
-  index = host_start;
-
-  if (port != url_components::omitted) {
-    if (port > 0xffff) {
-      return false;
-    }
-    uint32_t port_length = helpers::fast_digit_count(port) + 1;
-    if (index + port_length < index) {
-      return false;
-    }
-    index += port_length;
-  }
-
-  if (pathname_start == url_components::omitted) {
-    return false;
-  }
-  if (pathname_start < index) {
-    return false;
-  }
-  index = pathname_start;
-
-  if (search_start != url_components::omitted) {
-    if (search_start < index) {
-      return false;
-    }
-    index = search_start;
-  }
-
-  if (hash_start != url_components::omitted) {
-    if (hash_start < index) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-} // namespace ada
-#endif
-/* end file include/ada/url_components-inl.h */
-/* begin file include/ada/url_aggregator.h */
-/**
- * @file url_aggregator.h
- * @brief Declaration for the basic URL definitions
- */
-#ifndef ADA_URL_AGGREGATOR_H
-#define ADA_URL_AGGREGATOR_H
-
-#include <string>
-#include <string_view>
-#include <variant>
-
-namespace ada {
-
-namespace parser {}
-
-/**
- * @brief Lightweight URL struct.
- *
- * @details The url_aggregator class aims to minimize temporary memory
- * allocation while representing a parsed URL. Internally, it contains a single
- * normalized URL (the href), and it makes available the components, mostly
- * using std::string_view.
- */
-struct url_aggregator : url_base {
-  url_aggregator() = default;
-  url_aggregator(const url_aggregator &u) = default;
-  url_aggregator(url_aggregator &&u) noexcept = default;
-  url_aggregator &operator=(url_aggregator &&u) noexcept = default;
-  url_aggregator &operator=(const url_aggregator &u) = default;
-  ~url_aggregator() override = default;
-
-  bool set_href(std::string_view input);
-  bool set_host(std::string_view input);
-  bool set_hostname(std::string_view input);
-  bool set_protocol(std::string_view input);
-  bool set_username(std::string_view input);
-  bool set_password(std::string_view input);
-  bool set_port(std::string_view input);
-  bool set_pathname(std::string_view input);
-  void set_search(std::string_view input);
-  void set_hash(std::string_view input);
-
-  [[nodiscard]] bool has_valid_domain() const noexcept override;
-  /**
-   * The origin getter steps are to return the serialization of this's URL's
-   * origin. [HTML]
-   * @return a newly allocated string.
-   * @see https://url.spec.whatwg.org/#concept-url-origin
-   */
-  [[nodiscard]] std::string get_origin() const noexcept override;
-  /**
-   * Return the normalized string.
-   * This function does not allocate memory.
-   * It is highly efficient.
-   * @return a constant reference to the underlying normalized URL.
-   * @see https://url.spec.whatwg.org/#dom-url-href
-   * @see https://url.spec.whatwg.org/#concept-url-serializer
-   */
-  [[nodiscard]] constexpr std::string_view
-  get_href() const noexcept ada_lifetime_bound;
-  /**
-   * The username getter steps are to return this's URL's username.
-   * This function does not allocate memory.
-   * @return a lightweight std::string_view.
-   * @see https://url.spec.whatwg.org/#dom-url-username
-   */
-  [[nodiscard]] std::string_view
-  get_username() const noexcept ada_lifetime_bound;
-  /**
-   * The password getter steps are to return this's URL's password.
-   * This function does not allocate memory.
-   * @return a lightweight std::string_view.
-   * @see https://url.spec.whatwg.org/#dom-url-password
-   */
-  [[nodiscard]] std::string_view
-  get_password() const noexcept ada_lifetime_bound;
-  /**
-   * Return this's URL's port, serialized.
-   * This function does not allocate memory.
-   * @return a lightweight std::string_view.
-   * @see https://url.spec.whatwg.org/#dom-url-port
-   */
-  [[nodiscard]] std::string_view get_port() const noexcept ada_lifetime_bound;
-  /**
-   * Return U+0023 (#), followed by this's URL's fragment.
-   * This function does not allocate memory.
-   * @return a lightweight std::string_view..
-   * @see https://url.spec.whatwg.org/#dom-url-hash
-   */
-  [[nodiscard]] std::string_view get_hash() const noexcept ada_lifetime_bound;
-  /**
-   * Return url's host, serialized, followed by U+003A (:) and url's port,
-   * serialized.
-   * This function does not allocate memory.
-   * When there is no host, this function returns the empty view.
-   * @return a lightweight std::string_view.
-   * @see https://url.spec.whatwg.org/#dom-url-host
-   */
-  [[nodiscard]] std::string_view get_host() const noexcept ada_lifetime_bound;
-  /**
-   * Return this's URL's host, serialized.
-   * This function does not allocate memory.
-   * When there is no host, this function returns the empty view.
-   * @return a lightweight std::string_view.
-   * @see https://url.spec.whatwg.org/#dom-url-hostname
-   */
-  [[nodiscard]] std::string_view
-  get_hostname() const noexcept ada_lifetime_bound;
-  /**
-   * The pathname getter steps are to return the result of URL path serializing
-   * this's URL.
-   * This function does not allocate memory.
-   * @return a lightweight std::string_view.
-   * @see https://url.spec.whatwg.org/#dom-url-pathname
-   */
-  [[nodiscard]] constexpr std::string_view
-  get_pathname() const noexcept ada_lifetime_bound;
-  /**
-   * Compute the pathname length in bytes without instantiating a view or a
-   * string.
-   * @return size of the pathname in bytes
-   * @see https://url.spec.whatwg.org/#dom-url-pathname
-   */
-  [[nodiscard]] ada_really_inline uint32_t get_pathname_length() const noexcept;
-  /**
-   * Return U+003F (?), followed by this's URL's query.
-   * This function does not allocate memory.
-   * @return a lightweight std::string_view.
-   * @see https://url.spec.whatwg.org/#dom-url-search
-   */
-  [[nodiscard]] std::string_view get_search() const noexcept ada_lifetime_bound;
-  /**
-   * The protocol getter steps are to return this's URL's scheme, followed by
-   * U+003A (:).
-   * This function does not allocate memory.
-   * @return a lightweight std::string_view.
-   * @see https://url.spec.whatwg.org/#dom-url-protocol
-   */
-  [[nodiscard]] std::string_view
-  get_protocol() const noexcept ada_lifetime_bound;
-
-  /**
-   * A URL includes credentials if its username or password is not the empty
-   * string.
-   */
-  [[nodiscard]] ada_really_inline constexpr bool
-  has_credentials() const noexcept;
-
-  /**
-   * Useful for implementing efficient serialization for the URL.
-   *
-   * https://user:pass@example.com:1234/foo/bar?baz#quux
-   *       |     |    |          | ^^^^|       |   |
-   *       |     |    |          | |   |       |   `----- hash_start
-   *       |     |    |          | |   |       `--------- search_start
-   *       |     |    |          | |   `----------------- pathname_start
-   *       |     |    |          | `--------------------- port
-   *       |     |    |          `----------------------- host_end
-   *       |     |    `---------------------------------- host_start
-   *       |     `--------------------------------------- username_end
-   *       `--------------------------------------------- protocol_end
-   *
-   * Inspired after servo/url
-   *
-   * @return a constant reference to the underlying component attribute.
-   *
-   * @see
-   * https://github.com/servo/rust-url/blob/b65a45515c10713f6d212e6726719a020203cc98/url/src/quirks.rs#L31
-   */
-  [[nodiscard]] ada_really_inline const url_components &
-  get_components() const noexcept;
-  /**
-   * Returns a string representation of this URL.
-   */
-  [[nodiscard]] std::string to_string() const override;
-  /**
-   * Returns a string diagram of this URL.
-   */
-  [[nodiscard]] std::string to_diagram() const;
-
-  /**
-   * Verifies that the parsed URL could be valid. Useful for debugging purposes.
-   * @return true if the URL is valid, otherwise return true of the offsets are
-   * possible.
-   */
-  [[nodiscard]] constexpr bool validate() const noexcept;
-
-  /** @return true if it has an host but it is the empty string */
-  [[nodiscard]] constexpr bool has_empty_hostname() const noexcept;
-  /** @return true if it has a host (included an empty host) */
-  [[nodiscard]] constexpr bool has_hostname() const noexcept;
-  /** @return true if the URL has a non-empty username */
-  [[nodiscard]] constexpr bool has_non_empty_username() const noexcept;
-  /** @return true if the URL has a non-empty password */
-  [[nodiscard]] constexpr bool has_non_empty_password() const noexcept;
-  /** @return true if the URL has a (non default) port */
-  [[nodiscard]] constexpr bool has_port() const noexcept;
-  /** @return true if the URL has a password */
-  [[nodiscard]] constexpr bool has_password() const noexcept;
-  /** @return true if the URL has a hash component */
-  [[nodiscard]] constexpr bool has_hash() const noexcept override;
-  /** @return true if the URL has a search component */
-  [[nodiscard]] constexpr bool has_search() const noexcept override;
-
-  inline void clear_port();
-  inline void clear_hash();
-  inline void clear_search() override;
-
-private:
-  // helper methods
-  friend void helpers::strip_trailing_spaces_from_opaque_path<url_aggregator>(
-      url_aggregator &url) noexcept;
-  // parse_url methods
-  friend url_aggregator
-  parser::parse_url<url_aggregator>(std::string_view, const url_aggregator *);
-
-  friend url_aggregator
-  parser::parse_url_impl<url_aggregator, true>(std::string_view,
-                                               const url_aggregator *);
-  friend url_aggregator
-  parser::parse_url_impl<url_aggregator, false>(std::string_view,
-                                                const url_aggregator *);
-  // url_pattern methods
-  template <url_pattern_regex::regex_concept regex_provider>
-  friend tl::expected<url_pattern<regex_provider>, errors>
-  parse_url_pattern_impl(std::variant<std::string_view, url_pattern_init> input,
-                         const std::string_view *base_url,
-                         const url_pattern_options *options);
-
-  std::string buffer{};
-  url_components components{};
-
-  /**
-   * Returns true if neither the search, nor the hash nor the pathname
-   * have been set.
-   * @return true if the buffer is ready to receive the path.
-   */
-  [[nodiscard]] ada_really_inline bool is_at_path() const noexcept;
-
-  inline void add_authority_slashes_if_needed() noexcept;
-
-  /**
-   * To optimize performance, you may indicate how much memory to allocate
-   * within this instance.
-   */
-  constexpr void reserve(uint32_t capacity);
-
-  ada_really_inline size_t parse_port(
-      std::string_view view, bool check_trailing_content) noexcept override;
-
-  ada_really_inline size_t parse_port(std::string_view view) noexcept override {
-    return this->parse_port(view, false);
-  }
-
-  /**
-   * Return true on success. The 'in_place' parameter indicates whether the
-   * the string_view input is pointing in the buffer. When in_place is false,
-   * we must nearly always update the buffer.
-   * @see https://url.spec.whatwg.org/#concept-ipv4-parser
-   */
-  [[nodiscard]] bool parse_ipv4(std::string_view input, bool in_place);
-
-  /**
-   * Return true on success.
-   * @see https://url.spec.whatwg.org/#concept-ipv6-parser
-   */
-  [[nodiscard]] bool parse_ipv6(std::string_view input);
-
-  /**
-   * Return true on success.
-   * @see https://url.spec.whatwg.org/#concept-opaque-host-parser
-   */
-  [[nodiscard]] bool parse_opaque_host(std::string_view input);
-
-  ada_really_inline void parse_path(std::string_view input);
-
-  /**
-   * A URL cannot have a username/password/port if its host is null or the empty
-   * string, or its scheme is "file".
-   */
-  [[nodiscard]] constexpr bool cannot_have_credentials_or_port() const;
-
-  template <bool override_hostname = false>
-  bool set_host_or_hostname(std::string_view input);
-
-  ada_really_inline bool parse_host(std::string_view input);
-
-  inline void update_base_authority(std::string_view base_buffer,
-                                    const url_components &base);
-  inline void update_unencoded_base_hash(std::string_view input);
-  inline void update_base_hostname(std::string_view input);
-  inline void update_base_search(std::string_view input);
-  inline void update_base_search(std::string_view input,
-                                 const uint8_t *query_percent_encode_set);
-  inline void update_base_pathname(std::string_view input);
-  inline void update_base_username(std::string_view input);
-  inline void append_base_username(std::string_view input);
-  inline void update_base_password(std::string_view input);
-  inline void append_base_password(std::string_view input);
-  inline void update_base_port(uint32_t input);
-  inline void append_base_pathname(std::string_view input);
-  [[nodiscard]] inline uint32_t retrieve_base_port() const;
-  constexpr void clear_hostname();
-  constexpr void clear_password();
-  constexpr void clear_pathname() override;
-  [[nodiscard]] constexpr bool has_dash_dot() const noexcept;
-  void delete_dash_dot();
-  inline void consume_prepared_path(std::string_view input);
-  template <bool has_state_override = false>
-  [[nodiscard]] ada_really_inline bool
-  parse_scheme_with_colon(std::string_view input);
-  ada_really_inline uint32_t replace_and_resize(uint32_t start, uint32_t end,
-                                                std::string_view input);
-  [[nodiscard]] constexpr bool has_authority() const noexcept;
-  constexpr void set_protocol_as_file();
-  inline void set_scheme(std::string_view new_scheme) noexcept;
-  /**
-   * Fast function to set the scheme from a view with a colon in the
-   * buffer, does not change type.
-   */
-  inline void set_scheme_from_view_with_colon(
-      std::string_view new_scheme_with_colon) noexcept;
-  inline void copy_scheme(const url_aggregator &u) noexcept;
-
-  inline void update_host_to_base_host(const std::string_view input) noexcept;
-
-}; // url_aggregator
-
-inline std::ostream &operator<<(std::ostream &out, const url &u);
-} // namespace ada
-
-#endif
-/* end file include/ada/url_aggregator.h */
-/* begin file include/ada/url_aggregator-inl.h */
-/**
- * @file url_aggregator-inl.h
- * @brief Inline functions for url aggregator
- */
-#ifndef ADA_URL_AGGREGATOR_INL_H
-#define ADA_URL_AGGREGATOR_INL_H
-
-/* begin file include/ada/unicode-inl.h */
-/**
- * @file unicode-inl.h
- * @brief Definitions for unicode operations.
- */
-#ifndef ADA_UNICODE_INL_H
-#define ADA_UNICODE_INL_H
-
-/**
- * Unicode operations. These functions are not part of our public API and may
- * change at any time.
- *
- * private
- * @namespace ada::unicode
- * @brief Includes the declarations for unicode operations
- */
-namespace ada::unicode {
-ada_really_inline size_t percent_encode_index(const std::string_view input,
-                                              const uint8_t character_set[]) {
-  const char *data = input.data();
-  const size_t size = input.size();
-
-  // Process 8 bytes at a time using unrolled loop
-  size_t i = 0;
-  for (; i + 8 <= size; i += 8) {
-    unsigned char chunk[8];
-    std::memcpy(&chunk, data + i,
-                8); // entices compiler to unconditionally process 8 characters
-
-    // Check 8 characters at once
-    for (size_t j = 0; j < 8; j++) {
-      if (character_sets::bit_at(character_set, chunk[j])) {
-        return i + j;
-      }
-    }
-  }
-
-  // Handle remaining bytes
-  for (; i < size; i++) {
-    if (character_sets::bit_at(character_set, data[i])) {
-      return i;
-    }
-  }
-
-  return size;
-}
-} // namespace ada::unicode
-
-#endif // ADA_UNICODE_INL_H
-/* end file include/ada/unicode-inl.h */
-
-#include <charconv>
-#include <string_view>
-
-namespace ada {
-
-inline void
-url_aggregator::update_base_authority(std::string_view base_buffer,
-                                      const ada::url_components &base) {
-  std::string_view input = base_buffer.substr(
-      base.protocol_end, base.host_start - base.protocol_end);
-  ada_log("url_aggregator::update_base_authority ", input);
-
-  bool input_starts_with_dash = input.starts_with("//");
-  uint32_t diff = components.host_start - components.protocol_end;
-
-  buffer.erase(components.protocol_end,
-               components.host_start - components.protocol_end);
-  components.username_end = components.protocol_end;
-
-  if (input_starts_with_dash) {
-    input.remove_prefix(2);
-    diff += 2; // add "//"
-    buffer.insert(components.protocol_end, "//");
-    components.username_end += 2;
-  }
-
-  size_t password_delimiter = input.find(':');
-
-  // Check if input contains both username and password by checking the
-  // delimiter: ":" A typical input that contains authority would be "user:pass"
-  if (password_delimiter != std::string_view::npos) {
-    // Insert both username and password
-    std::string_view username = input.substr(0, password_delimiter);
-    std::string_view password = input.substr(password_delimiter + 1);
-
-    buffer.insert(components.protocol_end + diff, username);
-    diff += uint32_t(username.size());
-    buffer.insert(components.protocol_end + diff, ":");
-    components.username_end = components.protocol_end + diff;
-    buffer.insert(components.protocol_end + diff + 1, password);
-    diff += uint32_t(password.size()) + 1;
-  } else if (!input.empty()) {
-    // Insert only username
-    buffer.insert(components.protocol_end + diff, input);
-    components.username_end =
-        components.protocol_end + diff + uint32_t(input.size());
-    diff += uint32_t(input.size());
-  }
-
-  components.host_start += diff;
-
-  if (buffer.size() > base.host_start && buffer[base.host_start] != '@') {
-    buffer.insert(components.host_start, "@");
-    diff++;
-  }
-  components.host_end += diff;
-  components.pathname_start += diff;
-  if (components.search_start != url_components::omitted) {
-    components.search_start += diff;
-  }
-  if (components.hash_start != url_components::omitted) {
-    components.hash_start += diff;
-  }
-}
-
-inline void url_aggregator::update_unencoded_base_hash(std::string_view input) {
-  ada_log("url_aggregator::update_unencoded_base_hash ", input, " [",
-          input.size(), " bytes], buffer is '", buffer, "' [", buffer.size(),
-          " bytes] components.hash_start = ", components.hash_start);
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-  if (components.hash_start != url_components::omitted) {
-    buffer.resize(components.hash_start);
-  }
-  components.hash_start = uint32_t(buffer.size());
-  buffer += "#";
-  bool encoding_required = unicode::percent_encode<true>(
-      input, ada::character_sets::FRAGMENT_PERCENT_ENCODE, buffer);
-  // When encoding_required is false, then buffer is left unchanged, and percent
-  // encoding was not deemed required.
-  if (!encoding_required) {
-    buffer.append(input);
-  }
-  ada_log("url_aggregator::update_unencoded_base_hash final buffer is '",
-          buffer, "' [", buffer.size(), " bytes]");
-  ADA_ASSERT_TRUE(validate());
-}
-
-ada_really_inline uint32_t url_aggregator::replace_and_resize(
-    uint32_t start, uint32_t end, std::string_view input) {
-  uint32_t current_length = end - start;
-  uint32_t input_size = uint32_t(input.size());
-  uint32_t new_difference = input_size - current_length;
-
-  if (current_length == 0) {
-    buffer.insert(start, input);
-  } else if (input_size == current_length) {
-    buffer.replace(start, input_size, input);
-  } else if (input_size < current_length) {
-    buffer.erase(start, current_length - input_size);
-    buffer.replace(start, input_size, input);
-  } else {
-    buffer.replace(start, current_length, input.substr(0, current_length));
-    buffer.insert(start + current_length, input.substr(current_length));
-  }
-
-  return new_difference;
-}
-
-inline void url_aggregator::update_base_hostname(const std::string_view input) {
-  ada_log("url_aggregator::update_base_hostname ", input, " [", input.size(),
-          " bytes], buffer is '", buffer, "' [", buffer.size(), " bytes]");
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-
-  // This next line is required for when parsing a URL like `foo://`
-  add_authority_slashes_if_needed();
-
-  bool has_credentials = components.protocol_end + 2 < components.host_start;
-  uint32_t new_difference =
-      replace_and_resize(components.host_start, components.host_end, input);
-
-  if (has_credentials) {
-    buffer.insert(components.host_start, "@");
-    new_difference++;
-  }
-  components.host_end += new_difference;
-  components.pathname_start += new_difference;
-  if (components.search_start != url_components::omitted) {
-    components.search_start += new_difference;
-  }
-  if (components.hash_start != url_components::omitted) {
-    components.hash_start += new_difference;
-  }
-  ADA_ASSERT_TRUE(validate());
-}
-
-[[nodiscard]] ada_really_inline uint32_t
-url_aggregator::get_pathname_length() const noexcept {
-  ada_log("url_aggregator::get_pathname_length");
-  uint32_t ending_index = uint32_t(buffer.size());
-  if (components.search_start != url_components::omitted) {
-    ending_index = components.search_start;
-  } else if (components.hash_start != url_components::omitted) {
-    ending_index = components.hash_start;
-  }
-  return ending_index - components.pathname_start;
-}
-
-[[nodiscard]] ada_really_inline bool
-url_aggregator::is_at_path() const noexcept {
-  return buffer.size() == components.pathname_start;
-}
-
-inline void url_aggregator::update_base_search(std::string_view input) {
-  ada_log("url_aggregator::update_base_search ", input);
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-  if (input.empty()) {
-    clear_search();
-    return;
-  }
-
-  if (input[0] == '?') {
-    input.remove_prefix(1);
-  }
-
-  if (components.hash_start == url_components::omitted) {
-    if (components.search_start == url_components::omitted) {
-      components.search_start = uint32_t(buffer.size());
-      buffer += "?";
-    } else {
-      buffer.resize(components.search_start + 1);
-    }
-
-    buffer.append(input);
-  } else {
-    if (components.search_start == url_components::omitted) {
-      components.search_start = components.hash_start;
-    } else {
-      buffer.erase(components.search_start,
-                   components.hash_start - components.search_start);
-      components.hash_start = components.search_start;
-    }
-
-    buffer.insert(components.search_start, "?");
-    buffer.insert(components.search_start + 1, input);
-    components.hash_start += uint32_t(input.size() + 1); // Do not forget `?`
-  }
-
-  ADA_ASSERT_TRUE(validate());
-}
-
-inline void
-url_aggregator::update_base_search(std::string_view input,
-                                   const uint8_t query_percent_encode_set[]) {
-  ada_log("url_aggregator::update_base_search ", input,
-          " with encoding parameter ", to_string(), "\n", to_diagram());
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-
-  if (components.hash_start == url_components::omitted) {
-    if (components.search_start == url_components::omitted) {
-      components.search_start = uint32_t(buffer.size());
-      buffer += "?";
-    } else {
-      buffer.resize(components.search_start + 1);
-    }
-
-    bool encoding_required =
-        unicode::percent_encode<true>(input, query_percent_encode_set, buffer);
-    // When encoding_required is false, then buffer is left unchanged, and
-    // percent encoding was not deemed required.
-    if (!encoding_required) {
-      buffer.append(input);
-    }
-  } else {
-    if (components.search_start == url_components::omitted) {
-      components.search_start = components.hash_start;
-    } else {
-      buffer.erase(components.search_start,
-                   components.hash_start - components.search_start);
-      components.hash_start = components.search_start;
-    }
-
-    buffer.insert(components.search_start, "?");
-    size_t idx =
-        ada::unicode::percent_encode_index(input, query_percent_encode_set);
-    if (idx == input.size()) {
-      buffer.insert(components.search_start + 1, input);
-      components.hash_start += uint32_t(input.size() + 1); // Do not forget `?`
-    } else {
-      buffer.insert(components.search_start + 1, input, 0, idx);
-      input.remove_prefix(idx);
-      // We only create a temporary string if we need percent encoding and
-      // we attempt to create as small a temporary string as we can.
-      std::string encoded =
-          ada::unicode::percent_encode(input, query_percent_encode_set);
-      buffer.insert(components.search_start + idx + 1, encoded);
-      components.hash_start +=
-          uint32_t(encoded.size() + idx + 1); // Do not forget `?`
-    }
-  }
-
-  ADA_ASSERT_TRUE(validate());
-}
-
-inline void url_aggregator::update_base_pathname(const std::string_view input) {
-  ada_log("url_aggregator::update_base_pathname '", input, "' [", input.size(),
-          " bytes] \n", to_diagram());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-  ADA_ASSERT_TRUE(validate());
-
-  const bool begins_with_dashdash = input.starts_with("//");
-  if (!begins_with_dashdash && has_dash_dot()) {
-    // We must delete the ./
-    delete_dash_dot();
-  }
-
-  if (begins_with_dashdash && !has_opaque_path && !has_authority() &&
-      !has_dash_dot()) {
-    // If url's host is null, url does not have an opaque path, url's path's
-    // size is greater than 1, then append U+002F (/) followed by U+002E (.) to
-    // output.
-    buffer.insert(components.pathname_start, "/.");
-    components.pathname_start += 2;
-  }
-
-  uint32_t difference = replace_and_resize(
-      components.pathname_start,
-      components.pathname_start + get_pathname_length(), input);
-  if (components.search_start != url_components::omitted) {
-    components.search_start += difference;
-  }
-  if (components.hash_start != url_components::omitted) {
-    components.hash_start += difference;
-  }
-  ADA_ASSERT_TRUE(validate());
-}
-
-inline void url_aggregator::append_base_pathname(const std::string_view input) {
-  ada_log("url_aggregator::append_base_pathname ", input, " ", to_string(),
-          "\n", to_diagram());
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-#if ADA_DEVELOPMENT_CHECKS
-  // computing the expected password.
-  std::string path_expected(get_pathname());
-  path_expected.append(input);
-#endif // ADA_DEVELOPMENT_CHECKS
-  uint32_t ending_index = uint32_t(buffer.size());
-  if (components.search_start != url_components::omitted) {
-    ending_index = components.search_start;
-  } else if (components.hash_start != url_components::omitted) {
-    ending_index = components.hash_start;
-  }
-  buffer.insert(ending_index, input);
-
-  if (components.search_start != url_components::omitted) {
-    components.search_start += uint32_t(input.size());
-  }
-  if (components.hash_start != url_components::omitted) {
-    components.hash_start += uint32_t(input.size());
-  }
-#if ADA_DEVELOPMENT_CHECKS
-  std::string path_after = std::string(get_pathname());
-  ADA_ASSERT_EQUAL(path_expected, path_after,
-                   "append_base_pathname problem after inserting " +
-                       std::string(input));
-#endif // ADA_DEVELOPMENT_CHECKS
-  ADA_ASSERT_TRUE(validate());
-}
-
-inline void url_aggregator::update_base_username(const std::string_view input) {
-  ada_log("url_aggregator::update_base_username '", input, "' ", to_string(),
-          "\n", to_diagram());
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-
-  add_authority_slashes_if_needed();
-
-  bool has_password = has_non_empty_password();
-  bool host_starts_with_at = buffer.size() > components.host_start &&
-                             buffer[components.host_start] == '@';
-  uint32_t diff = replace_and_resize(components.protocol_end + 2,
-                                     components.username_end, input);
-
-  components.username_end += diff;
-  components.host_start += diff;
-
-  if (!input.empty() && !host_starts_with_at) {
-    buffer.insert(components.host_start, "@");
-    diff++;
-  } else if (input.empty() && host_starts_with_at && !has_password) {
-    // Input is empty, there is no password, and we need to remove "@" from
-    // hostname
-    buffer.erase(components.host_start, 1);
-    diff--;
-  }
-
-  components.host_end += diff;
-  components.pathname_start += diff;
-  if (components.search_start != url_components::omitted) {
-    components.search_start += diff;
-  }
-  if (components.hash_start != url_components::omitted) {
-    components.hash_start += diff;
-  }
-  ADA_ASSERT_TRUE(validate());
-}
-
-inline void url_aggregator::append_base_username(const std::string_view input) {
-  ada_log("url_aggregator::append_base_username ", input);
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-#if ADA_DEVELOPMENT_CHECKS
-  // computing the expected password.
-  std::string username_expected(get_username());
-  username_expected.append(input);
-#endif // ADA_DEVELOPMENT_CHECKS
-  add_authority_slashes_if_needed();
-
-  // If input is empty, do nothing.
-  if (input.empty()) {
-    return;
-  }
-
-  uint32_t difference = uint32_t(input.size());
-  buffer.insert(components.username_end, input);
-  components.username_end += difference;
-  components.host_start += difference;
-
-  if (buffer[components.host_start] != '@' &&
-      components.host_start != components.host_end) {
-    buffer.insert(components.host_start, "@");
-    difference++;
-  }
-
-  components.host_end += difference;
-  components.pathname_start += difference;
-  if (components.search_start != url_components::omitted) {
-    components.search_start += difference;
-  }
-  if (components.hash_start != url_components::omitted) {
-    components.hash_start += difference;
-  }
-#if ADA_DEVELOPMENT_CHECKS
-  std::string username_after(get_username());
-  ADA_ASSERT_EQUAL(username_expected, username_after,
-                   "append_base_username problem after inserting " +
-                       std::string(input));
-#endif // ADA_DEVELOPMENT_CHECKS
-  ADA_ASSERT_TRUE(validate());
-}
-
-constexpr void url_aggregator::clear_password() {
-  ada_log("url_aggregator::clear_password ", to_string());
-  ADA_ASSERT_TRUE(validate());
-  if (!has_password()) {
-    return;
-  }
-
-  uint32_t diff = components.host_start - components.username_end;
-  buffer.erase(components.username_end, diff);
-  components.host_start -= diff;
-  components.host_end -= diff;
-  components.pathname_start -= diff;
-  if (components.search_start != url_components::omitted) {
-    components.search_start -= diff;
-  }
-  if (components.hash_start != url_components::omitted) {
-    components.hash_start -= diff;
-  }
-}
-
-inline void url_aggregator::update_base_password(const std::string_view input) {
-  ada_log("url_aggregator::update_base_password ", input);
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-
-  add_authority_slashes_if_needed();
-
-  // TODO: Optimization opportunity. Merge the following removal functions.
-  if (input.empty()) {
-    clear_password();
-
-    // Remove username too, if it is empty.
-    if (!has_non_empty_username()) {
-      update_base_username("");
-    }
-
-    return;
-  }
-
-  bool password_exists = has_password();
-  uint32_t difference = uint32_t(input.size());
-
-  if (password_exists) {
-    uint32_t current_length =
-        components.host_start - components.username_end - 1;
-    buffer.erase(components.username_end + 1, current_length);
-    difference -= current_length;
-  } else {
-    buffer.insert(components.username_end, ":");
-    difference++;
-  }
-
-  buffer.insert(components.username_end + 1, input);
-  components.host_start += difference;
-
-  // The following line is required to add "@" to hostname. When updating
-  // password if hostname does not start with "@", it is "update_base_password"s
-  // responsibility to set it.
-  if (buffer[components.host_start] != '@') {
-    buffer.insert(components.host_start, "@");
-    difference++;
-  }
-
-  components.host_end += difference;
-  components.pathname_start += difference;
-  if (components.search_start != url_components::omitted) {
-    components.search_start += difference;
-  }
-  if (components.hash_start != url_components::omitted) {
-    components.hash_start += difference;
-  }
-  ADA_ASSERT_TRUE(validate());
-}
-
-inline void url_aggregator::append_base_password(const std::string_view input) {
-  ada_log("url_aggregator::append_base_password ", input, " ", to_string(),
-          "\n", to_diagram());
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-#if ADA_DEVELOPMENT_CHECKS
-  // computing the expected password.
-  std::string password_expected = std::string(get_password());
-  password_expected.append(input);
-#endif // ADA_DEVELOPMENT_CHECKS
-  add_authority_slashes_if_needed();
-
-  // If input is empty, do nothing.
-  if (input.empty()) {
-    return;
-  }
-
-  uint32_t difference = uint32_t(input.size());
-  if (has_password()) {
-    buffer.insert(components.host_start, input);
-  } else {
-    difference++; // Increment for ":"
-    buffer.insert(components.username_end, ":");
-    buffer.insert(components.username_end + 1, input);
-  }
-  components.host_start += difference;
-
-  // The following line is required to add "@" to hostname. When updating
-  // password if hostname does not start with "@", it is "append_base_password"s
-  // responsibility to set it.
-  if (buffer[components.host_start] != '@') {
-    buffer.insert(components.host_start, "@");
-    difference++;
-  }
-
-  components.host_end += difference;
-  components.pathname_start += difference;
-  if (components.search_start != url_components::omitted) {
-    components.search_start += difference;
-  }
-  if (components.hash_start != url_components::omitted) {
-    components.hash_start += difference;
-  }
-#if ADA_DEVELOPMENT_CHECKS
-  std::string password_after(get_password());
-  ADA_ASSERT_EQUAL(password_expected, password_after,
-                   "append_base_password problem after inserting " +
-                       std::string(input));
-#endif // ADA_DEVELOPMENT_CHECKS
-  ADA_ASSERT_TRUE(validate());
-}
-
-inline void url_aggregator::update_base_port(uint32_t input) {
-  ada_log("url_aggregator::update_base_port");
-  ADA_ASSERT_TRUE(validate());
-  if (input == url_components::omitted) {
-    clear_port();
-    return;
-  }
-  // calling std::to_string(input.value()) is unfortunate given that the port
-  // value is probably already available as a string.
-  std::string value = helpers::concat(":", std::to_string(input));
-  uint32_t difference = uint32_t(value.size());
-
-  if (components.port != url_components::omitted) {
-    difference -= components.pathname_start - components.host_end;
-    buffer.erase(components.host_end,
-                 components.pathname_start - components.host_end);
-  }
-
-  buffer.insert(components.host_end, value);
-  components.pathname_start += difference;
-  if (components.search_start != url_components::omitted) {
-    components.search_start += difference;
-  }
-  if (components.hash_start != url_components::omitted) {
-    components.hash_start += difference;
-  }
-  components.port = input;
-  ADA_ASSERT_TRUE(validate());
-}
-
-inline void url_aggregator::clear_port() {
-  ada_log("url_aggregator::clear_port");
-  ADA_ASSERT_TRUE(validate());
-  if (components.port == url_components::omitted) {
-    return;
-  }
-  uint32_t length = components.pathname_start - components.host_end;
-  buffer.erase(components.host_end, length);
-  components.pathname_start -= length;
-  if (components.search_start != url_components::omitted) {
-    components.search_start -= length;
-  }
-  if (components.hash_start != url_components::omitted) {
-    components.hash_start -= length;
-  }
-  components.port = url_components::omitted;
-  ADA_ASSERT_TRUE(validate());
-}
-
-[[nodiscard]] inline uint32_t url_aggregator::retrieve_base_port() const {
-  ada_log("url_aggregator::retrieve_base_port");
-  return components.port;
-}
-
-inline void url_aggregator::clear_search() {
-  ada_log("url_aggregator::clear_search");
-  ADA_ASSERT_TRUE(validate());
-  if (components.search_start == url_components::omitted) {
-    return;
-  }
-
-  if (components.hash_start == url_components::omitted) {
-    buffer.resize(components.search_start);
-  } else {
-    buffer.erase(components.search_start,
-                 components.hash_start - components.search_start);
-    components.hash_start = components.search_start;
-  }
-
-  components.search_start = url_components::omitted;
-
-#if ADA_DEVELOPMENT_CHECKS
-  ADA_ASSERT_EQUAL(get_search(), "",
-                   "search should have been cleared on buffer=" + buffer +
-                       " with " + components.to_string() + "\n" + to_diagram());
-#endif
-  ADA_ASSERT_TRUE(validate());
-}
-
-inline void url_aggregator::clear_hash() {
-  ada_log("url_aggregator::clear_hash");
-  ADA_ASSERT_TRUE(validate());
-  if (components.hash_start == url_components::omitted) {
-    return;
-  }
-  buffer.resize(components.hash_start);
-  components.hash_start = url_components::omitted;
-
-#if ADA_DEVELOPMENT_CHECKS
-  ADA_ASSERT_EQUAL(get_hash(), "",
-                   "hash should have been cleared on buffer=" + buffer +
-                       " with " + components.to_string() + "\n" + to_diagram());
-#endif
-  ADA_ASSERT_TRUE(validate());
-}
-
-constexpr void url_aggregator::clear_pathname() {
-  ada_log("url_aggregator::clear_pathname");
-  ADA_ASSERT_TRUE(validate());
-  uint32_t ending_index = uint32_t(buffer.size());
-  if (components.search_start != url_components::omitted) {
-    ending_index = components.search_start;
-  } else if (components.hash_start != url_components::omitted) {
-    ending_index = components.hash_start;
-  }
-  uint32_t pathname_length = ending_index - components.pathname_start;
-  buffer.erase(components.pathname_start, pathname_length);
-  uint32_t difference = pathname_length;
-  if (components.pathname_start == components.host_end + 2 &&
-      buffer[components.host_end] == '/' &&
-      buffer[components.host_end + 1] == '.') {
-    components.pathname_start -= 2;
-    buffer.erase(components.host_end, 2);
-    difference += 2;
-  }
-  if (components.search_start != url_components::omitted) {
-    components.search_start -= difference;
-  }
-  if (components.hash_start != url_components::omitted) {
-    components.hash_start -= difference;
-  }
-  ada_log("url_aggregator::clear_pathname completed, running checks...");
-#if ADA_DEVELOPMENT_CHECKS
-  ADA_ASSERT_EQUAL(get_pathname(), "",
-                   "pathname should have been cleared on buffer=" + buffer +
-                       " with " + components.to_string() + "\n" + to_diagram());
-#endif
-  ADA_ASSERT_TRUE(validate());
-  ada_log("url_aggregator::clear_pathname completed, running checks... ok");
-}
-
-constexpr void url_aggregator::clear_hostname() {
-  ada_log("url_aggregator::clear_hostname");
-  ADA_ASSERT_TRUE(validate());
-  if (!has_authority()) {
-    return;
-  }
-  ADA_ASSERT_TRUE(has_authority());
-
-  uint32_t hostname_length = components.host_end - components.host_start;
-  uint32_t start = components.host_start;
-
-  // If hostname starts with "@", we should not remove that character.
-  if (hostname_length > 0 && buffer[start] == '@') {
-    start++;
-    hostname_length--;
-  }
-  buffer.erase(start, hostname_length);
-  components.host_end = start;
-  components.pathname_start -= hostname_length;
-  if (components.search_start != url_components::omitted) {
-    components.search_start -= hostname_length;
-  }
-  if (components.hash_start != url_components::omitted) {
-    components.hash_start -= hostname_length;
-  }
-#if ADA_DEVELOPMENT_CHECKS
-  ADA_ASSERT_EQUAL(get_hostname(), "",
-                   "hostname should have been cleared on buffer=" + buffer +
-                       " with " + components.to_string() + "\n" + to_diagram());
-#endif
-  ADA_ASSERT_TRUE(has_authority());
-  ADA_ASSERT_EQUAL(has_empty_hostname(), true,
-                   "hostname should have been cleared on buffer=" + buffer +
-                       " with " + components.to_string() + "\n" + to_diagram());
-  ADA_ASSERT_TRUE(validate());
-}
-
-[[nodiscard]] constexpr bool url_aggregator::has_hash() const noexcept {
-  ada_log("url_aggregator::has_hash");
-  return components.hash_start != url_components::omitted;
-}
-
-[[nodiscard]] constexpr bool url_aggregator::has_search() const noexcept {
-  ada_log("url_aggregator::has_search");
-  return components.search_start != url_components::omitted;
-}
-
-constexpr bool url_aggregator::has_credentials() const noexcept {
-  ada_log("url_aggregator::has_credentials");
-  return has_non_empty_username() || has_non_empty_password();
-}
-
-constexpr bool url_aggregator::cannot_have_credentials_or_port() const {
-  ada_log("url_aggregator::cannot_have_credentials_or_port");
-  return type == ada::scheme::type::FILE ||
-         components.host_start == components.host_end;
-}
-
-[[nodiscard]] ada_really_inline const ada::url_components &
-url_aggregator::get_components() const noexcept {
-  return components;
-}
-
-[[nodiscard]] constexpr bool
-ada::url_aggregator::has_authority() const noexcept {
-  ada_log("url_aggregator::has_authority");
-  // Performance: instead of doing this potentially expensive check, we could
-  // have a boolean in the struct.
-  return components.protocol_end + 2 <= components.host_start &&
-         helpers::substring(buffer, components.protocol_end,
-                            components.protocol_end + 2) == "//";
-}
-
-inline void ada::url_aggregator::add_authority_slashes_if_needed() noexcept {
-  ada_log("url_aggregator::add_authority_slashes_if_needed");
-  ADA_ASSERT_TRUE(validate());
-  // Protocol setter will insert `http:` to the URL. It is up to hostname setter
-  // to insert
-  // `//` initially to the buffer, since it depends on the hostname existence.
-  if (has_authority()) {
-    return;
-  }
-  // Performance: the common case is components.protocol_end == buffer.size()
-  // Optimization opportunity: in many cases, the "//" is part of the input and
-  // the insert could be fused with another insert.
-  buffer.insert(components.protocol_end, "//");
-  components.username_end += 2;
-  components.host_start += 2;
-  components.host_end += 2;
-  components.pathname_start += 2;
-  if (components.search_start != url_components::omitted) {
-    components.search_start += 2;
-  }
-  if (components.hash_start != url_components::omitted) {
-    components.hash_start += 2;
-  }
-  ADA_ASSERT_TRUE(validate());
-}
-
-constexpr void ada::url_aggregator::reserve(uint32_t capacity) {
-  buffer.reserve(capacity);
-}
-
-constexpr bool url_aggregator::has_non_empty_username() const noexcept {
-  ada_log("url_aggregator::has_non_empty_username");
-  return components.protocol_end + 2 < components.username_end;
-}
-
-constexpr bool url_aggregator::has_non_empty_password() const noexcept {
-  ada_log("url_aggregator::has_non_empty_password");
-  return components.host_start - components.username_end > 0;
-}
-
-constexpr bool url_aggregator::has_password() const noexcept {
-  ada_log("url_aggregator::has_password");
-  // This function does not care about the length of the password
-  return components.host_start > components.username_end &&
-         buffer[components.username_end] == ':';
-}
-
-constexpr bool url_aggregator::has_empty_hostname() const noexcept {
-  if (!has_hostname()) {
-    return false;
-  }
-  if (components.host_start == components.host_end) {
-    return true;
-  }
-  if (components.host_end > components.host_start + 1) {
-    return false;
-  }
-  return components.username_end != components.host_start;
-}
-
-constexpr bool url_aggregator::has_hostname() const noexcept {
-  return has_authority();
-}
-
-constexpr bool url_aggregator::has_port() const noexcept {
-  ada_log("url_aggregator::has_port");
-  // A URL cannot have a username/password/port if its host is null or the empty
-  // string, or its scheme is "file".
-  return has_hostname() && components.pathname_start != components.host_end;
-}
-
-[[nodiscard]] constexpr bool url_aggregator::has_dash_dot() const noexcept {
-  // If url's host is null, url does not have an opaque path, url's path's size
-  // is greater than 1, and url's path[0] is the empty string, then append
-  // U+002F (/) followed by U+002E (.) to output.
-  ada_log("url_aggregator::has_dash_dot");
-#if ADA_DEVELOPMENT_CHECKS
-  // If pathname_start and host_end are exactly two characters apart, then we
-  // either have a one-digit port such as http://test.com:5?param=1 or else we
-  // have a /.: sequence such as "non-spec:/.//". We test that this is the case.
-  if (components.pathname_start == components.host_end + 2) {
-    ADA_ASSERT_TRUE((buffer[components.host_end] == '/' &&
-                     buffer[components.host_end + 1] == '.') ||
-                    (buffer[components.host_end] == ':' &&
-                     checkers::is_digit(buffer[components.host_end + 1])));
-  }
-  if (components.pathname_start == components.host_end + 2 &&
-      buffer[components.host_end] == '/' &&
-      buffer[components.host_end + 1] == '.') {
-    ADA_ASSERT_TRUE(components.pathname_start + 1 < buffer.size());
-    ADA_ASSERT_TRUE(buffer[components.pathname_start] == '/');
-    ADA_ASSERT_TRUE(buffer[components.pathname_start + 1] == '/');
-  }
-#endif
-  // Performance: it should be uncommon for components.pathname_start ==
-  // components.host_end + 2 to be true. So we put this check first in the
-  // sequence. Most times, we do not have an opaque path. Checking for '/.' is
-  // more expensive, but should be uncommon.
-  return components.pathname_start == components.host_end + 2 &&
-         !has_opaque_path && buffer[components.host_end] == '/' &&
-         buffer[components.host_end + 1] == '.';
-}
-
-[[nodiscard]] constexpr std::string_view
-url_aggregator::get_href() const noexcept ada_lifetime_bound {
-  ada_log("url_aggregator::get_href");
-  return buffer;
-}
-
-ada_really_inline size_t url_aggregator::parse_port(
-    std::string_view view, bool check_trailing_content) noexcept {
-  ada_log("url_aggregator::parse_port('", view, "') ", view.size());
-  if (!view.empty() && view[0] == '-') {
-    ada_log("parse_port: view[0] == '0' && view.size() > 1");
-    is_valid = false;
-    return 0;
-  }
-  uint16_t parsed_port{};
-  auto r = std::from_chars(view.data(), view.data() + view.size(), parsed_port);
-  if (r.ec == std::errc::result_out_of_range) {
-    ada_log("parse_port: r.ec == std::errc::result_out_of_range");
-    is_valid = false;
-    return 0;
-  }
-  ada_log("parse_port: ", parsed_port);
-  const size_t consumed = size_t(r.ptr - view.data());
-  ada_log("parse_port: consumed ", consumed);
-  if (check_trailing_content) {
-    is_valid &=
-        (consumed == view.size() || view[consumed] == '/' ||
-         view[consumed] == '?' || (is_special() && view[consumed] == '\\'));
-  }
-  ada_log("parse_port: is_valid = ", is_valid);
-  if (is_valid) {
-    ada_log("parse_port", r.ec == std::errc());
-    // scheme_default_port can return 0, and we should allow 0 as a base port.
-    auto default_port = scheme_default_port();
-    bool is_port_valid = (default_port == 0 && parsed_port == 0) ||
-                         (default_port != parsed_port);
-    if (r.ec == std::errc() && is_port_valid) {
-      update_base_port(parsed_port);
-    } else {
-      clear_port();
-    }
-  }
-  return consumed;
-}
-
-constexpr void url_aggregator::set_protocol_as_file() {
-  ada_log("url_aggregator::set_protocol_as_file ");
-  ADA_ASSERT_TRUE(validate());
-  type = ada::scheme::type::FILE;
-  // next line could overflow but unsigned arithmetic has well-defined
-  // overflows.
-  uint32_t new_difference = 5 - components.protocol_end;
-
-  if (buffer.empty()) {
-    buffer.append("file:");
-  } else {
-    buffer.erase(0, components.protocol_end);
-    buffer.insert(0, "file:");
-  }
-  components.protocol_end = 5;
-
-  // Update the rest of the components.
-  components.username_end += new_difference;
-  components.host_start += new_difference;
-  components.host_end += new_difference;
-  components.pathname_start += new_difference;
-  if (components.search_start != url_components::omitted) {
-    components.search_start += new_difference;
-  }
-  if (components.hash_start != url_components::omitted) {
-    components.hash_start += new_difference;
-  }
-  ADA_ASSERT_TRUE(validate());
-}
-
-[[nodiscard]] constexpr bool url_aggregator::validate() const noexcept {
-  if (!is_valid) {
-    return true;
-  }
-  if (!components.check_offset_consistency()) {
-    ada_log("url_aggregator::validate inconsistent components \n",
-            to_diagram());
-    return false;
-  }
-  // We have a credible components struct, but let us investivate more
-  // carefully:
-  /**
-   * https://user:pass@example.com:1234/foo/bar?baz#quux
-   *       |     |    |          | ^^^^|       |   |
-   *       |     |    |          | |   |       |   `----- hash_start
-   *       |     |    |          | |   |       `--------- search_start
-   *       |     |    |          | |   `----------------- pathname_start
-   *       |     |    |          | `--------------------- port
-   *       |     |    |          `----------------------- host_end
-   *       |     |    `---------------------------------- host_start
-   *       |     `--------------------------------------- username_end
-   *       `--------------------------------------------- protocol_end
-   */
-  if (components.protocol_end == url_components::omitted) {
-    ada_log("url_aggregator::validate omitted protocol_end \n", to_diagram());
-    return false;
-  }
-  if (components.username_end == url_components::omitted) {
-    ada_log("url_aggregator::validate omitted username_end \n", to_diagram());
-    return false;
-  }
-  if (components.host_start == url_components::omitted) {
-    ada_log("url_aggregator::validate omitted host_start \n", to_diagram());
-    return false;
-  }
-  if (components.host_end == url_components::omitted) {
-    ada_log("url_aggregator::validate omitted host_end \n", to_diagram());
-    return false;
-  }
-  if (components.pathname_start == url_components::omitted) {
-    ada_log("url_aggregator::validate omitted pathname_start \n", to_diagram());
-    return false;
-  }
-
-  if (components.protocol_end > buffer.size()) {
-    ada_log("url_aggregator::validate protocol_end overflow \n", to_diagram());
-    return false;
-  }
-  if (components.username_end > buffer.size()) {
-    ada_log("url_aggregator::validate username_end overflow \n", to_diagram());
-    return false;
-  }
-  if (components.host_start > buffer.size()) {
-    ada_log("url_aggregator::validate host_start overflow \n", to_diagram());
-    return false;
-  }
-  if (components.host_end > buffer.size()) {
-    ada_log("url_aggregator::validate host_end overflow \n", to_diagram());
-    return false;
-  }
-  if (components.pathname_start > buffer.size()) {
-    ada_log("url_aggregator::validate pathname_start overflow \n",
-            to_diagram());
-    return false;
-  }
-
-  if (components.protocol_end > 0) {
-    if (buffer[components.protocol_end - 1] != ':') {
-      ada_log(
-          "url_aggregator::validate missing : at the end of the protocol \n",
-          to_diagram());
-      return false;
-    }
-  }
-
-  if (components.username_end != buffer.size() &&
-      components.username_end > components.protocol_end + 2) {
-    if (buffer[components.username_end] != ':' &&
-        buffer[components.username_end] != '@') {
-      ada_log(
-          "url_aggregator::validate missing : or @ at the end of the username "
-          "\n",
-          to_diagram());
-      return false;
-    }
-  }
-
-  if (components.host_start != buffer.size()) {
-    if (components.host_start > components.username_end) {
-      if (buffer[components.host_start] != '@') {
-        ada_log(
-            "url_aggregator::validate missing @ at the end of the password \n",
-            to_diagram());
-        return false;
-      }
-    } else if (components.host_start == components.username_end &&
-               components.host_end > components.host_start) {
-      if (components.host_start == components.protocol_end + 2) {
-        if (buffer[components.protocol_end] != '/' ||
-            buffer[components.protocol_end + 1] != '/') {
-          ada_log(
-              "url_aggregator::validate missing // between protocol and host "
-              "\n",
-              to_diagram());
-          return false;
-        }
-      } else {
-        if (components.host_start > components.protocol_end &&
-            buffer[components.host_start] != '@') {
-          ada_log(
-              "url_aggregator::validate missing @ at the end of the username "
-              "\n",
-              to_diagram());
-          return false;
-        }
-      }
-    } else {
-      if (components.host_end != components.host_start) {
-        ada_log("url_aggregator::validate expected omitted host \n",
-                to_diagram());
-        return false;
-      }
-    }
-  }
-  if (components.host_end != buffer.size() &&
-      components.pathname_start > components.host_end) {
-    if (components.pathname_start == components.host_end + 2 &&
-        buffer[components.host_end] == '/' &&
-        buffer[components.host_end + 1] == '.') {
-      if (components.pathname_start + 1 >= buffer.size() ||
-          buffer[components.pathname_start] != '/' ||
-          buffer[components.pathname_start + 1] != '/') {
-        ada_log(
-            "url_aggregator::validate expected the path to begin with // \n",
-            to_diagram());
-        return false;
-      }
-    } else if (buffer[components.host_end] != ':') {
-      ada_log("url_aggregator::validate missing : at the port \n",
-              to_diagram());
-      return false;
-    }
-  }
-  if (components.pathname_start != buffer.size() &&
-      components.pathname_start < components.search_start &&
-      components.pathname_start < components.hash_start && !has_opaque_path) {
-    if (buffer[components.pathname_start] != '/') {
-      ada_log("url_aggregator::validate missing / at the path \n",
-              to_diagram());
-      return false;
-    }
-  }
-  if (components.search_start != url_components::omitted) {
-    if (buffer[components.search_start] != '?') {
-      ada_log("url_aggregator::validate missing ? at the search \n",
-              to_diagram());
-      return false;
-    }
-  }
-  if (components.hash_start != url_components::omitted) {
-    if (buffer[components.hash_start] != '#') {
-      ada_log("url_aggregator::validate missing # at the hash \n",
-              to_diagram());
-      return false;
-    }
-  }
-
-  return true;
-}
-
-[[nodiscard]] constexpr std::string_view
-url_aggregator::get_pathname() const noexcept ada_lifetime_bound {
-  ada_log("url_aggregator::get_pathname pathname_start = ",
-          components.pathname_start, " buffer.size() = ", buffer.size(),
-          " components.search_start = ", components.search_start,
-          " components.hash_start = ", components.hash_start);
-  auto ending_index = uint32_t(buffer.size());
-  if (components.search_start != url_components::omitted) {
-    ending_index = components.search_start;
-  } else if (components.hash_start != url_components::omitted) {
-    ending_index = components.hash_start;
-  }
-  return helpers::substring(buffer, components.pathname_start, ending_index);
-}
-
-inline std::ostream &operator<<(std::ostream &out,
-                                const ada::url_aggregator &u) {
-  return out << u.to_string();
-}
-
-void url_aggregator::update_host_to_base_host(
-    const std::string_view input) noexcept {
-  ada_log("url_aggregator::update_host_to_base_host ", input);
-  ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
-  if (type != ada::scheme::type::FILE) {
-    // Let host be the result of host parsing host_view with url is not special.
-    if (input.empty() && !is_special()) {
-      if (has_hostname()) {
-        clear_hostname();
-      } else if (has_dash_dot()) {
-        add_authority_slashes_if_needed();
-        delete_dash_dot();
-      }
-      return;
-    }
-  }
-  update_base_hostname(input);
-  ADA_ASSERT_TRUE(validate());
-  return;
-}
-} // namespace ada
-
-#endif // ADA_URL_AGGREGATOR_INL_H
-/* end file include/ada/url_aggregator-inl.h */
-/* begin file include/ada/url_search_params.h */
-/**
- * @file url_search_params.h
- * @brief Declaration for the URL Search Params
- */
-#ifndef ADA_URL_SEARCH_PARAMS_H
-#define ADA_URL_SEARCH_PARAMS_H
-
-#include <optional>
-#include <string>
-#include <string_view>
-#include <vector>
-
-namespace ada {
-
-enum class url_search_params_iter_type {
-  KEYS,
-  VALUES,
-  ENTRIES,
-};
-
-template <typename T, url_search_params_iter_type Type>
-struct url_search_params_iter;
-
-typedef std::pair<std::string_view, std::string_view> key_value_view_pair;
-
-using url_search_params_keys_iter =
-    url_search_params_iter<std::string_view, url_search_params_iter_type::KEYS>;
-using url_search_params_values_iter =
-    url_search_params_iter<std::string_view,
-                           url_search_params_iter_type::VALUES>;
-using url_search_params_entries_iter =
-    url_search_params_iter<key_value_view_pair,
-                           url_search_params_iter_type::ENTRIES>;
-
-/**
- * @see https://url.spec.whatwg.org/#interface-urlsearchparams
- */
-struct url_search_params {
-  url_search_params() = default;
-
-  /**
-   * @see
-   * https://github.com/web-platform-tests/wpt/blob/master/url/urlsearchparams-constructor.any.js
-   */
-  explicit url_search_params(const std::string_view input) {
-    initialize(input);
-  }
-
-  url_search_params(const url_search_params &u) = default;
-  url_search_params(url_search_params &&u) noexcept = default;
-  url_search_params &operator=(url_search_params &&u) noexcept = default;
-  url_search_params &operator=(const url_search_params &u) = default;
-  ~url_search_params() = default;
-
-  [[nodiscard]] inline size_t size() const noexcept;
-
-  /**
-   * @see https://url.spec.whatwg.org/#dom-urlsearchparams-append
-   */
-  inline void append(std::string_view key, std::string_view value);
-
-  /**
-   * @see https://url.spec.whatwg.org/#dom-urlsearchparams-delete
-   */
-  inline void remove(std::string_view key);
-  inline void remove(std::string_view key, std::string_view value);
-
-  /**
-   * @see https://url.spec.whatwg.org/#dom-urlsearchparams-get
-   */
-  inline std::optional<std::string_view> get(std::string_view key);
-
-  /**
-   * @see https://url.spec.whatwg.org/#dom-urlsearchparams-getall
-   */
-  inline std::vector<std::string> get_all(std::string_view key);
-
-  /**
-   * @see https://url.spec.whatwg.org/#dom-urlsearchparams-has
-   */
-  inline bool has(std::string_view key) noexcept;
-  inline bool has(std::string_view key, std::string_view value) noexcept;
-
-  /**
-   * @see https://url.spec.whatwg.org/#dom-urlsearchparams-set
-   */
-  inline void set(std::string_view key, std::string_view value);
-
-  /**
-   * @see https://url.spec.whatwg.org/#dom-urlsearchparams-sort
-   */
-  inline void sort();
-
-  /**
-   * @see https://url.spec.whatwg.org/#urlsearchparams-stringification-behavior
-   */
-  inline std::string to_string() const;
-
-  /**
-   * Returns a simple JS-style iterator over all of the keys in this
-   * url_search_params. The keys in the iterator are not unique. The valid
-   * lifespan of the iterator is tied to the url_search_params. The iterator
-   * must be freed when you're done with it.
-   * @see https://url.spec.whatwg.org/#interface-urlsearchparams
-   */
-  inline url_search_params_keys_iter get_keys();
-
-  /**
-   * Returns a simple JS-style iterator over all of the values in this
-   * url_search_params. The valid lifespan of the iterator is tied to the
-   * url_search_params. The iterator must be freed when you're done with it.
-   * @see https://url.spec.whatwg.org/#interface-urlsearchparams
-   */
-  inline url_search_params_values_iter get_values();
-
-  /**
-   * Returns a simple JS-style iterator over all of the entries in this
-   * url_search_params. The entries are pairs of keys and corresponding values.
-   * The valid lifespan of the iterator is tied to the url_search_params. The
-   * iterator must be freed when you're done with it.
-   * @see https://url.spec.whatwg.org/#interface-urlsearchparams
-   */
-  inline url_search_params_entries_iter get_entries();
-
-  /**
-   * C++ style conventional iterator support. const only because we
-   * do not really want the params to be modified via the iterator.
-   */
-  inline auto begin() const { return params.begin(); }
-  inline auto end() const { return params.end(); }
-  inline auto front() const { return params.front(); }
-  inline auto back() const { return params.back(); }
-  inline auto operator[](size_t index) const { return params[index]; }
-
-  /**
-   * @private
-   * Used to reset the search params to a new input.
-   * Used primarily for C API.
-   * @param input
-   */
-  void reset(std::string_view input);
-
-private:
-  typedef std::pair<std::string, std::string> key_value_pair;
-  std::vector<key_value_pair> params{};
-
-  /**
-   * @see https://url.spec.whatwg.org/#concept-urlencoded-parser
-   */
-  void initialize(std::string_view init);
-
-  template <typename T, url_search_params_iter_type Type>
-  friend struct url_search_params_iter;
-}; // url_search_params
-
-/**
- * Implements a non-conventional iterator pattern that is closer in style to
- * JavaScript's definition of an iterator.
- *
- * @see https://webidl.spec.whatwg.org/#idl-iterable
- */
-template <typename T, url_search_params_iter_type Type>
-struct url_search_params_iter {
-  inline url_search_params_iter() : params(EMPTY) {}
-  url_search_params_iter(const url_search_params_iter &u) = default;
-  url_search_params_iter(url_search_params_iter &&u) noexcept = default;
-  url_search_params_iter &
-  operator=(url_search_params_iter &&u) noexcept = default;
-  url_search_params_iter &operator=(const url_search_params_iter &u) = default;
-  ~url_search_params_iter() = default;
-
-  /**
-   * Return the next item in the iterator or std::nullopt if done.
-   */
-  inline std::optional<T> next();
-
-  inline bool has_next() const;
-
-private:
-  static url_search_params EMPTY;
-  inline url_search_params_iter(url_search_params &params_) : params(params_) {}
-
-  url_search_params &params;
-  size_t pos = 0;
-
-  friend struct url_search_params;
-};
-
-} // namespace ada
-#endif
-/* end file include/ada/url_search_params.h */
-/* begin file include/ada/url_search_params-inl.h */
-/**
- * @file url_search_params-inl.h
- * @brief Inline declarations for the URL Search Params
- */
-#ifndef ADA_URL_SEARCH_PARAMS_INL_H
-#define ADA_URL_SEARCH_PARAMS_INL_H
-
-#include <algorithm>
-#include <optional>
-#include <ranges>
-#include <string>
-#include <string_view>
-#include <vector>
-
-namespace ada {
-
-// A default, empty url_search_params for use with empty iterators.
-template <typename T, ada::url_search_params_iter_type Type>
-url_search_params url_search_params_iter<T, Type>::EMPTY;
-
-inline void url_search_params::reset(std::string_view input) {
-  params.clear();
-  initialize(input);
-}
-
-inline void url_search_params::initialize(std::string_view input) {
-  if (!input.empty() && input.front() == '?') {
-    input.remove_prefix(1);
-  }
-
-  auto process_key_value = [&](const std::string_view current) {
-    auto equal = current.find('=');
-
-    if (equal == std::string_view::npos) {
-      std::string name(current);
-      std::ranges::replace(name, '+', ' ');
-      params.emplace_back(unicode::percent_decode(name, name.find('%')), "");
-    } else {
-      std::string name(current.substr(0, equal));
-      std::string value(current.substr(equal + 1));
-
-      std::ranges::replace(name, '+', ' ');
-      std::ranges::replace(value, '+', ' ');
-
-      params.emplace_back(unicode::percent_decode(name, name.find('%')),
-                          unicode::percent_decode(value, value.find('%')));
-    }
-  };
-
-  while (!input.empty()) {
-    auto ampersand_index = input.find('&');
-
-    if (ampersand_index == std::string_view::npos) {
-      if (!input.empty()) {
-        process_key_value(input);
-      }
-      break;
-    } else if (ampersand_index != 0) {
-      process_key_value(input.substr(0, ampersand_index));
-    }
-
-    input.remove_prefix(ampersand_index + 1);
-  }
-}
-
-inline void url_search_params::append(const std::string_view key,
-                                      const std::string_view value) {
-  params.emplace_back(key, value);
-}
-
-inline size_t url_search_params::size() const noexcept { return params.size(); }
-
-inline std::optional<std::string_view>
-url_search_params::get(const std::string_view key) {
-  auto entry = std::ranges::find_if(
-      params, [&key](const auto &param) { return param.first == key; });
-
-  if (entry == params.end()) {
-    return std::nullopt;
-  }
-
-  return entry->second;
-}
-
-inline std::vector<std::string>
-url_search_params::get_all(const std::string_view key) {
-  std::vector<std::string> out{};
-
-  for (auto &param : params) {
-    if (param.first == key) {
-      out.emplace_back(param.second);
-    }
-  }
-
-  return out;
-}
-
-inline bool url_search_params::has(const std::string_view key) noexcept {
-  auto entry = std::ranges::find_if(
-      params, [&key](const auto &param) { return param.first == key; });
-  return entry != params.end();
-}
-
-inline bool url_search_params::has(std::string_view key,
-                                   std::string_view value) noexcept {
-  auto entry = std::ranges::find_if(params, [&key, &value](const auto &param) {
-    return param.first == key && param.second == value;
-  });
-  return entry != params.end();
-}
-
-inline std::string url_search_params::to_string() const {
-  auto character_set = ada::character_sets::WWW_FORM_URLENCODED_PERCENT_ENCODE;
-  std::string out{};
-  for (size_t i = 0; i < params.size(); i++) {
-    auto key = ada::unicode::percent_encode(params[i].first, character_set);
-    auto value = ada::unicode::percent_encode(params[i].second, character_set);
-
-    // Performance optimization: Move this inside percent_encode.
-    std::ranges::replace(key, ' ', '+');
-    std::ranges::replace(value, ' ', '+');
-
-    if (i != 0) {
-      out += "&";
-    }
-    out.append(key);
-    out += "=";
-    out.append(value);
-  }
-  return out;
-}
-
-inline void url_search_params::set(const std::string_view key,
-                                   const std::string_view value) {
-  const auto find = [&key](const auto &param) { return param.first == key; };
-
-  auto it = std::ranges::find_if(params, find);
-
-  if (it == params.end()) {
-    params.emplace_back(key, value);
-  } else {
-    it->second = value;
-    params.erase(std::remove_if(std::next(it), params.end(), find),
-                 params.end());
-  }
-}
-
-inline void url_search_params::remove(const std::string_view key) {
-  std::erase_if(params,
-                [&key](const auto &param) { return param.first == key; });
-}
-
-inline void url_search_params::remove(const std::string_view key,
-                                      const std::string_view value) {
-  std::erase_if(params, [&key, &value](const auto &param) {
-    return param.first == key && param.second == value;
-  });
-}
-
-inline void url_search_params::sort() {
-  std::ranges::stable_sort(
-      params, [](const key_value_pair &lhs, const key_value_pair &rhs) {
-        return lhs.first < rhs.first;
-      });
-}
-
-inline url_search_params_keys_iter url_search_params::get_keys() {
-  return url_search_params_keys_iter(*this);
-}
-
-/**
- * @see https://url.spec.whatwg.org/#interface-urlsearchparams
- */
-inline url_search_params_values_iter url_search_params::get_values() {
-  return url_search_params_values_iter(*this);
-}
-
-/**
- * @see https://url.spec.whatwg.org/#interface-urlsearchparams
- */
-inline url_search_params_entries_iter url_search_params::get_entries() {
-  return url_search_params_entries_iter(*this);
-}
-
-template <typename T, url_search_params_iter_type Type>
-inline bool url_search_params_iter<T, Type>::has_next() const {
-  return pos < params.params.size();
-}
-
-template <>
-inline std::optional<std::string_view> url_search_params_keys_iter::next() {
-  if (!has_next()) {
-    return std::nullopt;
-  }
-  return params.params[pos++].first;
-}
-
-template <>
-inline std::optional<std::string_view> url_search_params_values_iter::next() {
-  if (!has_next()) {
-    return std::nullopt;
-  }
-  return params.params[pos++].second;
-}
-
-template <>
-inline std::optional<key_value_view_pair>
-url_search_params_entries_iter::next() {
-  if (!has_next()) {
-    return std::nullopt;
-  }
-  return params.params[pos++];
-}
-
-} // namespace ada
-
-#endif // ADA_URL_SEARCH_PARAMS_INL_H
-/* end file include/ada/url_search_params-inl.h */
-/* begin file include/ada/url_pattern-inl.h */
-/**
- * @file url_pattern-inl.h
- * @brief Declaration for the URLPattern inline functions.
- */
-#ifndef ADA_URL_PATTERN_INL_H
-#define ADA_URL_PATTERN_INL_H
-
-#include <string_view>
-
-namespace ada {
-
-inline bool url_pattern_init::operator==(const url_pattern_init &other) const {
-  return protocol == other.protocol && username == other.username &&
-         password == other.password && hostname == other.hostname &&
-         port == other.port && search == other.search && hash == other.hash &&
-         pathname == other.pathname;
-}
-
-inline bool url_pattern_component_result::operator==(
-    const url_pattern_component_result &other) const {
-  return input == other.input && groups == other.groups;
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-url_pattern_component_result
-url_pattern_component<regex_provider>::create_component_match_result(
-    std::string_view input,
-    std::vector<std::optional<std::string>> &&exec_result) {
-  // Let result be a new URLPatternComponentResult.
-  // Set result["input"] to input.
-  // Let groups be a record<USVString, (USVString or undefined)>.
-  auto result =
-      url_pattern_component_result{.input = std::string(input), .groups = {}};
-
-  // Optimization: Let's reserve the size.
-  result.groups.reserve(exec_result.size());
-
-  // We explicitly start iterating from 0 even though the spec
-  // says we should start from 1. This case is handled by the
-  // std_regex_provider.
-  for (size_t index = 0; index < exec_result.size(); index++) {
-    result.groups.insert({
-        group_name_list[index],
-        std::move(exec_result[index]),
-    });
-  }
-  return result;
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-std::string_view
-url_pattern<regex_provider>::get_protocol() const ada_lifetime_bound {
-  // Return this's associated URL pattern's protocol component's pattern string.
-  return protocol_component.pattern;
-}
-template <url_pattern_regex::regex_concept regex_provider>
-std::string_view
-url_pattern<regex_provider>::get_username() const ada_lifetime_bound {
-  // Return this's associated URL pattern's username component's pattern string.
-  return username_component.pattern;
-}
-template <url_pattern_regex::regex_concept regex_provider>
-std::string_view
-url_pattern<regex_provider>::get_password() const ada_lifetime_bound {
-  // Return this's associated URL pattern's password component's pattern string.
-  return password_component.pattern;
-}
-template <url_pattern_regex::regex_concept regex_provider>
-std::string_view
-url_pattern<regex_provider>::get_hostname() const ada_lifetime_bound {
-  // Return this's associated URL pattern's hostname component's pattern string.
-  return hostname_component.pattern;
-}
-template <url_pattern_regex::regex_concept regex_provider>
-std::string_view
-url_pattern<regex_provider>::get_port() const ada_lifetime_bound {
-  // Return this's associated URL pattern's port component's pattern string.
-  return port_component.pattern;
-}
-template <url_pattern_regex::regex_concept regex_provider>
-std::string_view
-url_pattern<regex_provider>::get_pathname() const ada_lifetime_bound {
-  // Return this's associated URL pattern's pathname component's pattern string.
-  return pathname_component.pattern;
-}
-template <url_pattern_regex::regex_concept regex_provider>
-std::string_view
-url_pattern<regex_provider>::get_search() const ada_lifetime_bound {
-  // Return this's associated URL pattern's search component's pattern string.
-  return search_component.pattern;
-}
-template <url_pattern_regex::regex_concept regex_provider>
-std::string_view
-url_pattern<regex_provider>::get_hash() const ada_lifetime_bound {
-  // Return this's associated URL pattern's hash component's pattern string.
-  return hash_component.pattern;
-}
-template <url_pattern_regex::regex_concept regex_provider>
-bool url_pattern<regex_provider>::ignore_case() const {
-  return ignore_case_;
-}
-template <url_pattern_regex::regex_concept regex_provider>
-bool url_pattern<regex_provider>::has_regexp_groups() const {
-  // If this's associated URL pattern's has regexp groups, then return true.
-  return protocol_component.has_regexp_groups ||
-         username_component.has_regexp_groups ||
-         password_component.has_regexp_groups ||
-         hostname_component.has_regexp_groups ||
-         port_component.has_regexp_groups ||
-         pathname_component.has_regexp_groups ||
-         search_component.has_regexp_groups || hash_component.has_regexp_groups;
-}
-
-inline bool url_pattern_part::is_regexp() const noexcept {
-  return type == url_pattern_part_type::REGEXP;
-}
-
-inline std::string_view
-url_pattern_compile_component_options::get_delimiter() const {
-  if (delimiter) {
-    return {&delimiter.value(), 1};
-  }
-  return {};
-}
-
-inline std::string_view
-url_pattern_compile_component_options::get_prefix() const {
-  if (prefix) {
-    return {&prefix.value(), 1};
-  }
-  return {};
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-template <url_pattern_encoding_callback F>
-tl::expected<url_pattern_component<regex_provider>, errors>
-url_pattern_component<regex_provider>::compile(
-    std::string_view input, F &encoding_callback,
-    url_pattern_compile_component_options &options) {
-  ada_log("url_pattern_component::compile input: ", input);
-  // Let part list be the result of running parse a pattern string given input,
-  // options, and encoding callback.
-  auto part_list = url_pattern_helpers::parse_pattern_string(input, options,
-                                                             encoding_callback);
-
-  if (!part_list) {
-    ada_log("parse_pattern_string failed");
-    return tl::unexpected(part_list.error());
-  }
-
-  // Let (regular expression string, name list) be the result of running
-  // generate a regular expression and name list given part list and options.
-  auto [regular_expression_string, name_list] =
-      url_pattern_helpers::generate_regular_expression_and_name_list(*part_list,
-                                                                     options);
-
-  ada_log("regular expression string: ", regular_expression_string);
-
-  // Let pattern string be the result of running generate a pattern
-  // string given part list and options.
-  auto pattern_string =
-      url_pattern_helpers::generate_pattern_string(*part_list, options);
-
-  // Let regular expression be RegExpCreate(regular expression string,
-  // flags). If this throws an exception, catch it, and throw a
-  // TypeError.
-  std::optional<typename regex_provider::regex_type> regular_expression =
-      regex_provider::create_instance(regular_expression_string,
-                                      options.ignore_case);
-
-  if (!regular_expression) {
-    return tl::unexpected(errors::type_error);
-  }
-
-  // For each part of part list:
-  // - If part’s type is "regexp", then set has regexp groups to true.
-  const auto has_regexp = [](const auto &part) { return part.is_regexp(); };
-  const bool has_regexp_groups = std::ranges::any_of(*part_list, has_regexp);
-
-  ada_log("has regexp groups: ", has_regexp_groups);
-
-  // Return a new component whose pattern string is pattern string, regular
-  // expression is regular expression, group name list is name list, and has
-  // regexp groups is has regexp groups.
-  return url_pattern_component<regex_provider>(
-      std::move(pattern_string), std::move(*regular_expression),
-      std::move(name_list), has_regexp_groups);
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-result<std::optional<url_pattern_result>>
-url_pattern<regex_provider>::exec(const url_pattern_input &input,
-                                  const std::string_view *base_url) {
-  // Return the result of match given this's associated URL pattern, input, and
-  // baseURL if given.
-  return match(input, base_url);
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-result<bool>
-url_pattern<regex_provider>::test(const url_pattern_input &input,
-                                  const std::string_view *base_url) {
-  // TODO: Optimization opportunity. Rather than returning `url_pattern_result`
-  // Implement a fast path just like `can_parse()` in ada_url.
-  // Let result be the result of match given this's associated URL pattern,
-  // input, and baseURL if given.
-  // If result is null, return false.
-  if (auto result = match(input, base_url); result.has_value()) {
-    return result->has_value();
-  }
-  return tl::unexpected(errors::type_error);
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-result<std::optional<url_pattern_result>>
-url_pattern<regex_provider>::match(const url_pattern_input &input,
-                                   const std::string_view *base_url_string) {
-  std::string protocol{};
-  std::string username{};
-  std::string password{};
-  std::string hostname{};
-  std::string port{};
-  std::string pathname{};
-  std::string search{};
-  std::string hash{};
-
-  // Let inputs be an empty list.
-  // Append input to inputs.
-  std::vector inputs{input};
-
-  // If input is a URLPatternInit then:
-  if (std::holds_alternative<url_pattern_init>(input)) {
-    ada_log(
-        "url_pattern::match called with url_pattern_init and base_url_string=",
-        base_url_string);
-    // If baseURLString was given, throw a TypeError.
-    if (base_url_string) {
-      ada_log("failed to match because base_url_string was given");
-      return tl::unexpected(errors::type_error);
-    }
-
-    // Let applyResult be the result of process a URLPatternInit given input,
-    // "url", protocol, username, password, hostname, port, pathname, search,
-    // and hash.
-    auto apply_result = url_pattern_init::process(
-        std::get<url_pattern_init>(input), "url", protocol, username, password,
-        hostname, port, pathname, search, hash);
-
-    // If this throws an exception, catch it, and return null.
-    if (!apply_result.has_value()) {
-      ada_log("match returned std::nullopt because process threw");
-      return std::nullopt;
-    }
-
-    // Set protocol to applyResult["protocol"].
-    ADA_ASSERT_TRUE(apply_result->protocol.has_value());
-    protocol = apply_result->protocol.value();
-
-    // Set username to applyResult["username"].
-    ADA_ASSERT_TRUE(apply_result->username.has_value());
-    username = apply_result->username.value();
-
-    // Set password to applyResult["password"].
-    ADA_ASSERT_TRUE(apply_result->password.has_value());
-    password = apply_result->password.value();
-
-    // Set hostname to applyResult["hostname"].
-    ADA_ASSERT_TRUE(apply_result->hostname.has_value());
-    hostname = apply_result->hostname.value();
-
-    // Set port to applyResult["port"].
-    ADA_ASSERT_TRUE(apply_result->port.has_value());
-    port = apply_result->port.value();
-
-    // Set pathname to applyResult["pathname"].
-    ADA_ASSERT_TRUE(apply_result->pathname.has_value());
-    pathname = apply_result->pathname.value();
-
-    // Set search to applyResult["search"].
-    ADA_ASSERT_TRUE(apply_result->search.has_value());
-    if (apply_result->search->starts_with("?")) {
-      search = apply_result->search->substr(1);
-    } else {
-      search = apply_result->search.value();
-    }
-
-    // Set hash to applyResult["hash"].
-    ADA_ASSERT_TRUE(apply_result->hash.has_value());
-    ADA_ASSERT_TRUE(!apply_result->hash->starts_with("#"));
-    hash = apply_result->hash.value();
-  } else {
-    ADA_ASSERT_TRUE(std::holds_alternative<std::string_view>(input));
-
-    // Let baseURL be null.
-    result<url_aggregator> base_url;
-
-    // If baseURLString was given, then:
-    if (base_url_string) {
-      // Let baseURL be the result of parsing baseURLString.
-      base_url = ada::parse<url_aggregator>(*base_url_string, nullptr);
-
-      // If baseURL is failure, return null.
-      if (!base_url) {
-        ada_log("match returned std::nullopt because failed to parse base_url=",
-                *base_url_string);
-        return std::nullopt;
-      }
-
-      // Append baseURLString to inputs.
-      inputs.emplace_back(*base_url_string);
-    }
-
-    url_aggregator *base_url_value =
-        base_url.has_value() ? &base_url.value() : nullptr;
-
-    // Set url to the result of parsing input given baseURL.
-    auto url = ada::parse<url_aggregator>(std::get<std::string_view>(input),
-                                          base_url_value);
-
-    // If url is failure, return null.
-    if (!url) {
-      ada_log("match returned std::nullopt because url failed");
-      return std::nullopt;
-    }
-
-    // Set protocol to url’s scheme.
-    // IMPORTANT: Not documented on the URLPattern spec, but protocol suffix ':'
-    // is removed. Similar work was done on workerd:
-    // https://github.com/cloudflare/workerd/blob/8620d14012513a6ce04d079e401d3becac3c67bd/src/workerd/jsg/url.c%2B%2B#L2038
-    protocol = url->get_protocol().substr(0, url->get_protocol().size() - 1);
-    // Set username to url’s username.
-    username = url->get_username();
-    // Set password to url’s password.
-    password = url->get_password();
-    // Set hostname to url’s host, serialized, or the empty string if the value
-    // is null.
-    hostname = url->get_hostname();
-    // Set port to url’s port, serialized, or the empty string if the value is
-    // null.
-    port = url->get_port();
-    // Set pathname to the result of URL path serializing url.
-    pathname = url->get_pathname();
-    // Set search to url’s query or the empty string if the value is null.
-    // IMPORTANT: Not documented on the URLPattern spec, but search prefix '?'
-    // is removed. Similar work was done on workerd:
-    // https://github.com/cloudflare/workerd/blob/8620d14012513a6ce04d079e401d3becac3c67bd/src/workerd/jsg/url.c%2B%2B#L2232
-    if (url->has_search()) {
-      ADA_ASSERT_TRUE(url->get_search().starts_with("?"));
-      search = url->get_search().substr(1);
-    } else {
-      search = "";
-    }
-    // Set hash to url’s fragment or the empty string if the value is null.
-    // IMPORTANT: Not documented on the URLPattern spec, but hash prefix '#' is
-    // removed. Similar work was done on workerd:
-    // https://github.com/cloudflare/workerd/blob/8620d14012513a6ce04d079e401d3becac3c67bd/src/workerd/jsg/url.c%2B%2B#L2242
-    if (url->has_hash()) {
-      ADA_ASSERT_TRUE(url->get_hash().starts_with("#"));
-      hash = url->get_hash().substr(1);
-    } else {
-      hash = "";
-    }
-  }
-
-  // Let protocolExecResult be RegExpBuiltinExec(urlPattern’s protocol
-  // component's regular expression, protocol).
-  auto protocol_exec_result =
-      regex_provider::regex_search(protocol, protocol_component.regexp);
-
-  // Let usernameExecResult be RegExpBuiltinExec(urlPattern’s username
-  // component's regular expression, username).
-  auto username_exec_result =
-      regex_provider::regex_search(username, username_component.regexp);
-
-  // Let passwordExecResult be RegExpBuiltinExec(urlPattern’s password
-  // component's regular expression, password).
-  auto password_exec_result =
-      regex_provider::regex_search(password, password_component.regexp);
-
-  // Let hostnameExecResult be RegExpBuiltinExec(urlPattern’s hostname
-  // component's regular expression, hostname).
-  auto hostname_exec_result =
-      regex_provider::regex_search(hostname, hostname_component.regexp);
-
-  // Let portExecResult be RegExpBuiltinExec(urlPattern’s port component's
-  // regular expression, port).
-  auto port_exec_result =
-      regex_provider::regex_search(port, port_component.regexp);
-
-  // Let pathnameExecResult be RegExpBuiltinExec(urlPattern’s pathname
-  // component's regular expression, pathname).
-  auto pathname_exec_result =
-      regex_provider::regex_search(pathname, pathname_component.regexp);
-
-  // Let searchExecResult be RegExpBuiltinExec(urlPattern’s search component's
-  // regular expression, search).
-  auto search_exec_result =
-      regex_provider::regex_search(search, search_component.regexp);
-
-  // Let hashExecResult be RegExpBuiltinExec(urlPattern’s hash component's
-  // regular expression, hash).
-  auto hash_exec_result =
-      regex_provider::regex_search(hash, hash_component.regexp);
-
-  // If protocolExecResult, usernameExecResult, passwordExecResult,
-  // hostnameExecResult, portExecResult, pathnameExecResult, searchExecResult,
-  // or hashExecResult are null then return null.
-  if (!protocol_exec_result || !username_exec_result || !password_exec_result ||
-      !hostname_exec_result || !port_exec_result || !pathname_exec_result ||
-      !search_exec_result || !hash_exec_result) {
-    return std::nullopt;
-  }
-
-  // Let result be a new URLPatternResult.
-  auto result = url_pattern_result{};
-  // Set result["inputs"] to inputs.
-  result.inputs = std::move(inputs);
-  // Set result["protocol"] to the result of creating a component match result
-  // given urlPattern’s protocol component, protocol, and protocolExecResult.
-  result.protocol = protocol_component.create_component_match_result(
-      protocol, std::move(*protocol_exec_result));
-
-  // Set result["username"] to the result of creating a component match result
-  // given urlPattern’s username component, username, and usernameExecResult.
-  result.username = username_component.create_component_match_result(
-      username, std::move(*username_exec_result));
-
-  // Set result["password"] to the result of creating a component match result
-  // given urlPattern’s password component, password, and passwordExecResult.
-  result.password = password_component.create_component_match_result(
-      password, std::move(*password_exec_result));
-
-  // Set result["hostname"] to the result of creating a component match result
-  // given urlPattern’s hostname component, hostname, and hostnameExecResult.
-  result.hostname = hostname_component.create_component_match_result(
-      hostname, std::move(*hostname_exec_result));
-
-  // Set result["port"] to the result of creating a component match result given
-  // urlPattern’s port component, port, and portExecResult.
-  result.port = port_component.create_component_match_result(
-      port, std::move(*port_exec_result));
-
-  // Set result["pathname"] to the result of creating a component match result
-  // given urlPattern’s pathname component, pathname, and pathnameExecResult.
-  result.pathname = pathname_component.create_component_match_result(
-      pathname, std::move(*pathname_exec_result));
-
-  // Set result["search"] to the result of creating a component match result
-  // given urlPattern’s search component, search, and searchExecResult.
-  result.search = search_component.create_component_match_result(
-      search, std::move(*search_exec_result));
-
-  // Set result["hash"] to the result of creating a component match result given
-  // urlPattern’s hash component, hash, and hashExecResult.
-  result.hash = hash_component.create_component_match_result(
-      hash, std::move(*hash_exec_result));
-
-  return result;
-}
-
-} // namespace ada
-
-#endif
-/* end file include/ada/url_pattern-inl.h */
-/* begin file include/ada/url_pattern_helpers-inl.h */
-/**
- * @file url_pattern_helpers-inl.h
- * @brief Declaration for the URLPattern helpers.
- */
-#ifndef ADA_URL_PATTERN_HELPERS_INL_H
-#define ADA_URL_PATTERN_HELPERS_INL_H
-
-#include <optional>
-#include <string_view>
-
-namespace ada::url_pattern_helpers {
-inline std::string to_string(token_type type) {
-  switch (type) {
-  case token_type::INVALID_CHAR:
-    return "INVALID_CHAR";
-  case token_type::OPEN:
-    return "OPEN";
-  case token_type::CLOSE:
-    return "CLOSE";
-  case token_type::REGEXP:
-    return "REGEXP";
-  case token_type::NAME:
-    return "NAME";
-  case token_type::CHAR:
-    return "CHAR";
-  case token_type::ESCAPED_CHAR:
-    return "ESCAPED_CHAR";
-  case token_type::OTHER_MODIFIER:
-    return "OTHER_MODIFIER";
-  case token_type::ASTERISK:
-    return "ASTERISK";
-  case token_type::END:
-    return "END";
-  default:
-    ada::unreachable();
-  }
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-void constructor_string_parser<regex_provider>::rewind() {
-  // Set parser’s token index to parser’s component start.
-  token_index = component_start;
-  // Set parser’s token increment to 0.
-  token_increment = 0;
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-bool constructor_string_parser<regex_provider>::is_hash_prefix() {
-  // Return the result of running is a non-special pattern char given parser,
-  // parser’s token index and "#".
-  return is_non_special_pattern_char(token_index, "#");
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-bool constructor_string_parser<regex_provider>::is_search_prefix() {
-  // If result of running is a non-special pattern char given parser, parser’s
-  // token index and "?" is true, then return true.
-  if (is_non_special_pattern_char(token_index, "?")) {
-    return true;
-  }
-
-  // If parser’s token list[parser’s token index]'s value is not "?", then
-  // return false.
-  if (token_list[token_index].value != "?") {
-    return false;
-  }
-
-  // If previous index is less than 0, then return true.
-  if (token_index == 0)
-    return true;
-  // Let previous index be parser’s token index − 1.
-  auto previous_index = token_index - 1;
-  // Let previous token be the result of running get a safe token given parser
-  // and previous index.
-  auto previous_token = get_safe_token(previous_index);
-  ADA_ASSERT_TRUE(previous_token);
-  // If any of the following are true, then return false:
-  // - previous token’s type is "name".
-  // - previous token’s type is "regexp".
-  // - previous token’s type is "close".
-  // - previous token’s type is "asterisk".
-  return !(previous_token->type == token_type::NAME ||
-           previous_token->type == token_type::REGEXP ||
-           previous_token->type == token_type::CLOSE ||
-           previous_token->type == token_type::ASTERISK);
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-bool constructor_string_parser<regex_provider>::is_non_special_pattern_char(
-    size_t index, std::string_view value) {
-  // Let token be the result of running get a safe token given parser and index.
-  auto token = get_safe_token(index);
-  ADA_ASSERT_TRUE(token);
-
-  // If token’s value is not value, then return false.
-  if (token->value != value) {
-    return false;
-  }
-
-  // If any of the following are true:
-  // - token’s type is "char";
-  // - token’s type is "escaped-char"; or
-  // - token’s type is "invalid-char",
-  // - then return true.
-  return token->type == token_type::CHAR ||
-         token->type == token_type::ESCAPED_CHAR ||
-         token->type == token_type::INVALID_CHAR;
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-const token *
-constructor_string_parser<regex_provider>::get_safe_token(size_t index) {
-  // If index is less than parser’s token list's size, then return parser’s
-  // token list[index].
-  if (index < token_list.size()) [[likely]] {
-    return &token_list[index];
-  }
-
-  // Assert: parser’s token list's size is greater than or equal to 1.
-  ADA_ASSERT_TRUE(!token_list.empty());
-
-  // Let token be parser’s token list[last index].
-  // Assert: token’s type is "end".
-  ADA_ASSERT_TRUE(token_list.back().type == token_type::END);
-
-  // Return token.
-  return &token_list.back();
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-bool constructor_string_parser<regex_provider>::is_group_open() const {
-  // If parser’s token list[parser’s token index]'s type is "open", then return
-  // true.
-  return token_list[token_index].type == token_type::OPEN;
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-bool constructor_string_parser<regex_provider>::is_group_close() const {
-  // If parser’s token list[parser’s token index]'s type is "close", then return
-  // true.
-  return token_list[token_index].type == token_type::CLOSE;
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-bool constructor_string_parser<regex_provider>::next_is_authority_slashes() {
-  // If the result of running is a non-special pattern char given parser,
-  // parser’s token index + 1, and "/" is false, then return false.
-  if (!is_non_special_pattern_char(token_index + 1, "/")) {
-    return false;
-  }
-  // If the result of running is a non-special pattern char given parser,
-  // parser’s token index + 2, and "/" is false, then return false.
-  if (!is_non_special_pattern_char(token_index + 2, "/")) {
-    return false;
-  }
-  return true;
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-bool constructor_string_parser<regex_provider>::is_protocol_suffix() {
-  // Return the result of running is a non-special pattern char given parser,
-  // parser’s token index, and ":".
-  return is_non_special_pattern_char(token_index, ":");
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-void constructor_string_parser<regex_provider>::change_state(State new_state,
-                                                             size_t skip) {
-  // If parser’s state is not "init", not "authority", and not "done", then set
-  // parser’s result[parser’s state] to the result of running make a component
-  // string given parser.
-  if (state != State::INIT && state != State::AUTHORITY &&
-      state != State::DONE) {
-    auto value = make_component_string();
-    // TODO: Simplify this.
-    switch (state) {
-    case State::PROTOCOL: {
-      result.protocol = value;
-      break;
-    }
-    case State::USERNAME: {
-      result.username = value;
-      break;
-    }
-    case State::PASSWORD: {
-      result.password = value;
-      break;
-    }
-    case State::HOSTNAME: {
-      result.hostname = value;
-      break;
-    }
-    case State::PORT: {
-      result.port = value;
-      break;
-    }
-    case State::PATHNAME: {
-      result.pathname = value;
-      break;
-    }
-    case State::SEARCH: {
-      result.search = value;
-      break;
-    }
-    case State::HASH: {
-      result.hash = value;
-      break;
-    }
-    default:
-      ada::unreachable();
-    }
-  }
-
-  // If parser’s state is not "init" and new state is not "done", then:
-  if (state != State::INIT && new_state != State::DONE) {
-    // If parser’s state is "protocol", "authority", "username", or "password";
-    // new state is "port", "pathname", "search", or "hash"; and parser’s
-    // result["hostname"] does not exist, then set parser’s result["hostname"]
-    // to the empty string.
-    if ((state == State::PROTOCOL || state == State::AUTHORITY ||
-         state == State::USERNAME || state == State::PASSWORD) &&
-        (new_state == State::PORT || new_state == State::PATHNAME ||
-         new_state == State::SEARCH || new_state == State::HASH) &&
-        !result.hostname)
-      result.hostname = "";
-  }
-
-  // If parser’s state is "protocol", "authority", "username", "password",
-  // "hostname", or "port"; new state is "search" or "hash"; and parser’s
-  // result["pathname"] does not exist, then:
-  if ((state == State::PROTOCOL || state == State::AUTHORITY ||
-       state == State::USERNAME || state == State::PASSWORD ||
-       state == State::HOSTNAME || state == State::PORT) &&
-      (new_state == State::SEARCH || new_state == State::HASH) &&
-      !result.pathname) {
-    if (protocol_matches_a_special_scheme_flag) {
-      result.pathname = "/";
-    } else {
-      // Otherwise, set parser’s result["pathname"] to the empty string.
-      result.pathname = "";
-    }
-  }
-
-  // If parser’s state is "protocol", "authority", "username", "password",
-  // "hostname", "port", or "pathname"; new state is "hash"; and parser’s
-  // result["search"] does not exist, then set parser’s result["search"] to
-  // the empty string.
-  if ((state == State::PROTOCOL || state == State::AUTHORITY ||
-       state == State::USERNAME || state == State::PASSWORD ||
-       state == State::HOSTNAME || state == State::PORT ||
-       state == State::PATHNAME) &&
-      new_state == State::HASH && !result.search) {
-    result.search = "";
-  }
-
-  // Set parser’s state to new state.
-  state = new_state;
-  // Increment parser’s token index by skip.
-  token_index += skip;
-  // Set parser’s component start to parser’s token index.
-  component_start = token_index;
-  // Set parser’s token increment to 0.
-  token_increment = 0;
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-std::string constructor_string_parser<regex_provider>::make_component_string() {
-  // Assert: parser’s token index is less than parser’s token list's size.
-  ADA_ASSERT_TRUE(token_index < token_list.size());
-
-  // Let token be parser’s token list[parser’s token index].
-  // Let end index be token’s index.
-  const auto end_index = token_list[token_index].index;
-  // Let component start token be the result of running get a safe token given
-  // parser and parser’s component start.
-  const auto component_start_token = get_safe_token(component_start);
-  ADA_ASSERT_TRUE(component_start_token);
-  // Let component start input index be component start token’s index.
-  const auto component_start_input_index = component_start_token->index;
-  // Return the code point substring from component start input index to end
-  // index within parser’s input.
-  return input.substr(component_start_input_index,
-                      end_index - component_start_input_index);
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-bool constructor_string_parser<regex_provider>::is_an_identity_terminator() {
-  // Return the result of running is a non-special pattern char given parser,
-  // parser’s token index, and "@".
-  return is_non_special_pattern_char(token_index, "@");
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-bool constructor_string_parser<regex_provider>::is_pathname_start() {
-  // Return the result of running is a non-special pattern char given parser,
-  // parser’s token index, and "/".
-  return is_non_special_pattern_char(token_index, "/");
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-bool constructor_string_parser<regex_provider>::is_password_prefix() {
-  // Return the result of running is a non-special pattern char given parser,
-  // parser’s token index, and ":".
-  return is_non_special_pattern_char(token_index, ":");
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-bool constructor_string_parser<regex_provider>::is_an_ipv6_open() {
-  // Return the result of running is a non-special pattern char given parser,
-  // parser’s token index, and "[".
-  return is_non_special_pattern_char(token_index, "[");
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-bool constructor_string_parser<regex_provider>::is_an_ipv6_close() {
-  // Return the result of running is a non-special pattern char given parser,
-  // parser’s token index, and "]".
-  return is_non_special_pattern_char(token_index, "]");
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-bool constructor_string_parser<regex_provider>::is_port_prefix() {
-  // Return the result of running is a non-special pattern char given parser,
-  // parser’s token index, and ":".
-  return is_non_special_pattern_char(token_index, ":");
-}
-
-inline void Tokenizer::get_next_code_point() {
-  ada_log("Tokenizer::get_next_code_point called with index=", next_index);
-  ADA_ASSERT_TRUE(next_index < input.size());
-  // this assumes that we have a valid, non-truncated UTF-8 stream.
-  code_point = 0;
-  size_t number_bytes = 0;
-  unsigned char first_byte = input[next_index];
-
-  if ((first_byte & 0x80) == 0) {
-    // 1-byte character (ASCII)
-    next_index++;
-    code_point = first_byte;
-    ada_log("Tokenizer::get_next_code_point returning ASCII code point=",
-            uint32_t(code_point));
-    ada_log("Tokenizer::get_next_code_point next_index =", next_index,
-            " input.size()=", input.size());
-    return;
-  }
-  ada_log("Tokenizer::get_next_code_point read first byte=",
-          uint32_t(first_byte));
-  if ((first_byte & 0xE0) == 0xC0) {
-    code_point = first_byte & 0x1F;
-    number_bytes = 2;
-    ada_log("Tokenizer::get_next_code_point two bytes");
-  } else if ((first_byte & 0xF0) == 0xE0) {
-    code_point = first_byte & 0x0F;
-    number_bytes = 3;
-    ada_log("Tokenizer::get_next_code_point three bytes");
-  } else if ((first_byte & 0xF8) == 0xF0) {
-    code_point = first_byte & 0x07;
-    number_bytes = 4;
-    ada_log("Tokenizer::get_next_code_point four bytes");
-  }
-  ADA_ASSERT_TRUE(number_bytes + next_index <= input.size());
-
-  for (size_t i = 1 + next_index; i < number_bytes + next_index; ++i) {
-    unsigned char byte = input[i];
-    ada_log("Tokenizer::get_next_code_point read byte=", uint32_t(byte));
-    code_point = (code_point << 6) | (byte & 0x3F);
-  }
-  ada_log("Tokenizer::get_next_code_point returning non-ASCII code point=",
-          uint32_t(code_point));
-  ada_log("Tokenizer::get_next_code_point next_index =", next_index,
-          " input.size()=", input.size());
-  next_index += number_bytes;
-}
-
-inline void Tokenizer::seek_and_get_next_code_point(size_t new_index) {
-  ada_log("Tokenizer::seek_and_get_next_code_point called with new_index=",
-          new_index);
-  // Set tokenizer’s next index to index.
-  next_index = new_index;
-  // Run get the next code point given tokenizer.
-  get_next_code_point();
-}
-
-inline void Tokenizer::add_token(token_type type, size_t next_position,
-                                 size_t value_position, size_t value_length) {
-  ada_log("Tokenizer::add_token called with type=", to_string(type),
-          " next_position=", next_position, " value_position=", value_position);
-  ADA_ASSERT_TRUE(next_position >= value_position);
-
-  // Let token be a new token.
-  // Set token’s type to type.
-  // Set token’s index to tokenizer’s index.
-  // Set token’s value to the code point substring from value position with
-  // length value length within tokenizer’s input.
-  // Append token to the back of tokenizer’s token list.
-  token_list.emplace_back(type, index,
-                          input.substr(value_position, value_length));
-  // Set tokenizer’s index to next position.
-  index = next_position;
-}
-
-inline void Tokenizer::add_token_with_default_length(token_type type,
-                                                     size_t next_position,
-                                                     size_t value_position) {
-  // Let computed length be next position − value position.
-  auto computed_length = next_position - value_position;
-  // Run add a token given tokenizer, type, next position, value position, and
-  // computed length.
-  add_token(type, next_position, value_position, computed_length);
-}
-
-inline void Tokenizer::add_token_with_defaults(token_type type) {
-  ada_log("Tokenizer::add_token_with_defaults called with type=",
-          to_string(type));
-  // Run add a token with default length given tokenizer, type, tokenizer’s next
-  // index, and tokenizer’s index.
-  add_token_with_default_length(type, next_index, index);
-}
-
-inline ada_warn_unused std::optional<errors>
-Tokenizer::process_tokenizing_error(size_t next_position,
-                                    size_t value_position) {
-  // If tokenizer’s policy is "strict", then throw a TypeError.
-  if (policy == token_policy::strict) {
-    ada_log("process_tokenizing_error failed with next_position=",
-            next_position, " value_position=", value_position);
-    return errors::type_error;
-  }
-  // Assert: tokenizer’s policy is "lenient".
-  ADA_ASSERT_TRUE(policy == token_policy::lenient);
-  // Run add a token with default length given tokenizer, "invalid-char", next
-  // position, and value position.
-  add_token_with_default_length(token_type::INVALID_CHAR, next_position,
-                                value_position);
-  return std::nullopt;
-}
-
-template <url_pattern_encoding_callback F>
-token *url_pattern_parser<F>::try_consume_modifier_token() {
-  // Let token be the result of running try to consume a token given parser and
-  // "other-modifier".
-  auto token = try_consume_token(token_type::OTHER_MODIFIER);
-  // If token is not null, then return token.
-  if (token)
-    return token;
-  // Set token to the result of running try to consume a token given parser and
-  // "asterisk".
-  // Return token.
-  return try_consume_token(token_type::ASTERISK);
-}
-
-template <url_pattern_encoding_callback F>
-token *url_pattern_parser<F>::try_consume_regexp_or_wildcard_token(
-    const token *name_token) {
-  // Let token be the result of running try to consume a token given parser and
-  // "regexp".
-  auto token = try_consume_token(token_type::REGEXP);
-  // If name token is null and token is null, then set token to the result of
-  // running try to consume a token given parser and "asterisk".
-  if (!name_token && !token) {
-    token = try_consume_token(token_type::ASTERISK);
-  }
-  // Return token.
-  return token;
-}
-
-template <url_pattern_encoding_callback F>
-token *url_pattern_parser<F>::try_consume_token(token_type type) {
-  ada_log("url_pattern_parser::try_consume_token called with type=",
-          to_string(type));
-  // Assert: parser’s index is less than parser’s token list size.
-  ADA_ASSERT_TRUE(index < tokens.size());
-  // Let next token be parser’s token list[parser’s index].
-  auto &next_token = tokens[index];
-  // If next token’s type is not type return null.
-  if (next_token.type != type)
-    return nullptr;
-  // Increase parser’s index by 1.
-  index++;
-  // Return next token.
-  return &next_token;
-}
-
-template <url_pattern_encoding_callback F>
-std::string url_pattern_parser<F>::consume_text() {
-  // Let result be the empty string.
-  std::string result{};
-  // While true:
-  while (true) {
-    // Let token be the result of running try to consume a token given parser
-    // and "char".
-    auto token = try_consume_token(token_type::CHAR);
-    // If token is null, then set token to the result of running try to consume
-    // a token given parser and "escaped-char".
-    if (!token)
-      token = try_consume_token(token_type::ESCAPED_CHAR);
-    // If token is null, then break.
-    if (!token)
-      break;
-    // Append token’s value to the end of result.
-    result.append(token->value);
-  }
-  // Return result.
-  return result;
-}
-
-template <url_pattern_encoding_callback F>
-bool url_pattern_parser<F>::consume_required_token(token_type type) {
-  ada_log("url_pattern_parser::consume_required_token called with type=",
-          to_string(type));
-  // Let result be the result of running try to consume a token given parser and
-  // type.
-  return try_consume_token(type) != nullptr;
-}
-
-template <url_pattern_encoding_callback F>
-std::optional<errors>
-url_pattern_parser<F>::maybe_add_part_from_the_pending_fixed_value() {
-  // If parser’s pending fixed value is the empty string, then return.
-  if (pending_fixed_value.empty()) {
-    ada_log("pending_fixed_value is empty");
-    return std::nullopt;
-  }
-  // Let encoded value be the result of running parser’s encoding callback given
-  // parser’s pending fixed value.
-  auto encoded_value = encoding_callback(pending_fixed_value);
-  if (!encoded_value) {
-    ada_log("failed to encode pending_fixed_value: ", pending_fixed_value);
-    return encoded_value.error();
-  }
-  // Set parser’s pending fixed value to the empty string.
-  pending_fixed_value.clear();
-  // Let part be a new part whose type is "fixed-text", value is encoded value,
-  // and modifier is "none".
-  // Append part to parser’s part list.
-  parts.emplace_back(url_pattern_part_type::FIXED_TEXT,
-                     std::move(*encoded_value),
-                     url_pattern_part_modifier::none);
-  return std::nullopt;
-}
-
-template <url_pattern_encoding_callback F>
-std::optional<errors> url_pattern_parser<F>::add_part(
-    std::string_view prefix, token *name_token, token *regexp_or_wildcard_token,
-    std::string_view suffix, token *modifier_token) {
-  // Let modifier be "none".
-  auto modifier = url_pattern_part_modifier::none;
-  // If modifier token is not null:
-  if (modifier_token) {
-    // If modifier token’s value is "?" then set modifier to "optional".
-    if (modifier_token->value == "?") {
-      modifier = url_pattern_part_modifier::optional;
-    } else if (modifier_token->value == "*") {
-      // Otherwise if modifier token’s value is "*" then set modifier to
-      // "zero-or-more".
-      modifier = url_pattern_part_modifier::zero_or_more;
-    } else if (modifier_token->value == "+") {
-      // Otherwise if modifier token’s value is "+" then set modifier to
-      // "one-or-more".
-      modifier = url_pattern_part_modifier::one_or_more;
-    }
-  }
-  // If name token is null and regexp or wildcard token is null and modifier
-  // is "none":
-  if (!name_token && !regexp_or_wildcard_token &&
-      modifier == url_pattern_part_modifier::none) {
-    // Append prefix to the end of parser’s pending fixed value.
-    pending_fixed_value.append(prefix);
-    return std::nullopt;
-  }
-  // Run maybe add a part from the pending fixed value given parser.
-  if (auto error = maybe_add_part_from_the_pending_fixed_value()) {
-    return *error;
-  }
-  // If name token is null and regexp or wildcard token is null:
-  if (!name_token && !regexp_or_wildcard_token) {
-    // Assert: suffix is the empty string.
-    ADA_ASSERT_TRUE(suffix.empty());
-    // If prefix is the empty string, then return.
-    if (prefix.empty())
-      return std::nullopt;
-    // Let encoded value be the result of running parser’s encoding callback
-    // given prefix.
-    auto encoded_value = encoding_callback(prefix);
-    if (!encoded_value) {
-      return encoded_value.error();
-    }
-    // Let part be a new part whose type is "fixed-text", value is encoded
-    // value, and modifier is modifier.
-    // Append part to parser’s part list.
-    parts.emplace_back(url_pattern_part_type::FIXED_TEXT,
-                       std::move(*encoded_value), modifier);
-    return std::nullopt;
-  }
-  // Let regexp value be the empty string.
-  std::string regexp_value{};
-  // If regexp or wildcard token is null, then set regexp value to parser’s
-  // segment wildcard regexp.
-  if (!regexp_or_wildcard_token) {
-    regexp_value = segment_wildcard_regexp;
-  } else if (regexp_or_wildcard_token->type == token_type::ASTERISK) {
-    // Otherwise if regexp or wildcard token’s type is "asterisk", then set
-    // regexp value to the full wildcard regexp value.
-    regexp_value = ".*";
-  } else {
-    // Otherwise set regexp value to regexp or wildcard token’s value.
-    regexp_value = regexp_or_wildcard_token->value;
-  }
-  // Let type be "regexp".
-  auto type = url_pattern_part_type::REGEXP;
-  // If regexp value is parser’s segment wildcard regexp:
-  if (regexp_value == segment_wildcard_regexp) {
-    // Set type to "segment-wildcard".
-    type = url_pattern_part_type::SEGMENT_WILDCARD;
-    // Set regexp value to the empty string.
-    regexp_value.clear();
-  } else if (regexp_value == ".*") {
-    // Otherwise if regexp value is the full wildcard regexp value:
-    // Set type to "full-wildcard".
-    type = url_pattern_part_type::FULL_WILDCARD;
-    // Set regexp value to the empty string.
-    regexp_value.clear();
-  }
-  // Let name be the empty string.
-  std::string name{};
-  // If name token is not null, then set name to name token’s value.
-  if (name_token) {
-    name = name_token->value;
-  } else if (regexp_or_wildcard_token) {
-    // Otherwise if regexp or wildcard token is not null:
-    // Set name to parser’s next numeric name, serialized.
-    // TODO: Make sure this is correct.
-    name = std::to_string(next_numeric_name);
-    // Increment parser’s next numeric name by 1.
-    next_numeric_name++;
-  }
-  // If the result of running is a duplicate name given parser and name is
-  // true, then throw a TypeError.
-  if (std::ranges::any_of(
-          parts, [&name](const auto &part) { return part.name == name; })) {
-    return errors::type_error;
-  }
-  // Let encoded prefix be the result of running parser’s encoding callback
-  // given prefix.
-  auto encoded_prefix = encoding_callback(prefix);
-  if (!encoded_prefix)
-    return encoded_prefix.error();
-  // Let encoded suffix be the result of running parser’s encoding callback
-  // given suffix.
-  auto encoded_suffix = encoding_callback(suffix);
-  if (!encoded_suffix)
-    return encoded_suffix.error();
-  // Let part be a new part whose type is type, value is regexp value,
-  // modifier is modifier, name is name, prefix is encoded prefix, and suffix
-  // is encoded suffix.
-  // Append part to parser’s part list.
-  parts.emplace_back(type, std::move(regexp_value), modifier, std::move(name),
-                     std::move(*encoded_prefix), std::move(*encoded_suffix));
-  return std::nullopt;
-}
-
-template <url_pattern_encoding_callback F>
-tl::expected<std::vector<url_pattern_part>, errors>
-parse_pattern_string(std::string_view input,
-                     url_pattern_compile_component_options &options,
-                     F &encoding_callback) {
-  ada_log("parse_pattern_string input=", input);
-  // Let parser be a new pattern parser whose encoding callback is encoding
-  // callback and segment wildcard regexp is the result of running generate a
-  // segment wildcard regexp given options.
-  auto parser = url_pattern_parser<F>(
-      encoding_callback, generate_segment_wildcard_regexp(options));
-  // Set parser’s token list to the result of running tokenize given input and
-  // "strict".
-  auto tokenize_result = tokenize(input, token_policy::strict);
-  if (!tokenize_result) {
-    ada_log("parse_pattern_string tokenize failed");
-    return tl::unexpected(tokenize_result.error());
-  }
-  parser.tokens = std::move(*tokenize_result);
-
-  // While parser’s index is less than parser’s token list's size:
-  while (parser.can_continue()) {
-    // Let char token be the result of running try to consume a token given
-    // parser and "char".
-    auto char_token = parser.try_consume_token(token_type::CHAR);
-    // Let name token be the result of running try to consume a token given
-    // parser and "name".
-    auto name_token = parser.try_consume_token(token_type::NAME);
-    // Let regexp or wildcard token be the result of running try to consume a
-    // regexp or wildcard token given parser and name token.
-    auto regexp_or_wildcard_token =
-        parser.try_consume_regexp_or_wildcard_token(name_token);
-    // If name token is not null or regexp or wildcard token is not null:
-    if (name_token || regexp_or_wildcard_token) {
-      // Let prefix be the empty string.
-      std::string prefix{};
-      // If char token is not null then set prefix to char token’s value.
-      if (char_token)
-        prefix = char_token->value;
-      // If prefix is not the empty string and not options’s prefix code point:
-      if (!prefix.empty() && prefix != options.get_prefix()) {
-        // Append prefix to the end of parser’s pending fixed value.
-        parser.pending_fixed_value.append(prefix);
-        // Set prefix to the empty string.
-        prefix.clear();
-      }
-      // Run maybe add a part from the pending fixed value given parser.
-      if (auto error = parser.maybe_add_part_from_the_pending_fixed_value()) {
-        ada_log("maybe_add_part_from_the_pending_fixed_value failed");
-        return tl::unexpected(*error);
-      }
-      // Let modifier token be the result of running try to consume a modifier
-      // token given parser.
-      auto modifier_token = parser.try_consume_modifier_token();
-      // Run add a part given parser, prefix, name token, regexp or wildcard
-      // token, the empty string, and modifier token.
-      if (auto error =
-              parser.add_part(prefix, name_token, regexp_or_wildcard_token, "",
-                              modifier_token)) {
-        ada_log("parser.add_part failed");
-        return tl::unexpected(*error);
-      }
-      // Continue.
-      continue;
-    }
-
-    // Let fixed token be char token.
-    auto fixed_token = char_token;
-    // If fixed token is null, then set fixed token to the result of running try
-    // to consume a token given parser and "escaped-char".
-    if (!fixed_token)
-      fixed_token = parser.try_consume_token(token_type::ESCAPED_CHAR);
-    // If fixed token is not null:
-    if (fixed_token) {
-      // Append fixed token’s value to parser’s pending fixed value.
-      parser.pending_fixed_value.append(fixed_token->value);
-      // Continue.
-      continue;
-    }
-    // Let open token be the result of running try to consume a token given
-    // parser and "open".
-    auto open_token = parser.try_consume_token(token_type::OPEN);
-    // If open token is not null:
-    if (open_token) {
-      // Set prefix be the result of running consume text given parser.
-      auto prefix_ = parser.consume_text();
-      // Set name token to the result of running try to consume a token given
-      // parser and "name".
-      name_token = parser.try_consume_token(token_type::NAME);
-      // Set regexp or wildcard token to the result of running try to consume a
-      // regexp or wildcard token given parser and name token.
-      regexp_or_wildcard_token =
-          parser.try_consume_regexp_or_wildcard_token(name_token);
-      // Let suffix be the result of running consume text given parser.
-      auto suffix_ = parser.consume_text();
-      // Run consume a required token given parser and "close".
-      if (!parser.consume_required_token(token_type::CLOSE)) {
-        ada_log("parser.consume_required_token failed");
-        return tl::unexpected(errors::type_error);
-      }
-      // Set modifier token to the result of running try to consume a modifier
-      // token given parser.
-      auto modifier_token = parser.try_consume_modifier_token();
-      // Run add a part given parser, prefix, name token, regexp or wildcard
-      // token, suffix, and modifier token.
-      if (auto error =
-              parser.add_part(prefix_, name_token, regexp_or_wildcard_token,
-                              suffix_, modifier_token)) {
-        return tl::unexpected(*error);
-      }
-      // Continue.
-      continue;
-    }
-    // Run maybe add a part from the pending fixed value given parser.
-    if (auto error = parser.maybe_add_part_from_the_pending_fixed_value()) {
-      ada_log("maybe_add_part_from_the_pending_fixed_value failed on line 992");
-      return tl::unexpected(*error);
-    }
-    // Run consume a required token given parser and "end".
-    if (!parser.consume_required_token(token_type::END)) {
-      return tl::unexpected(errors::type_error);
-    }
-  }
-  ada_log("parser.parts size is: ", parser.parts.size());
-  // Return parser’s part list.
-  return parser.parts;
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-bool protocol_component_matches_special_scheme(
-    url_pattern_component<regex_provider> &component) {
-  // let's avoid unnecessary copy here.
-  auto &regex = component.regexp;
-  return regex_provider::regex_match("http", regex) ||
-         regex_provider::regex_match("https", regex) ||
-         regex_provider::regex_match("ws", regex) ||
-         regex_provider::regex_match("wss", regex) ||
-         regex_provider::regex_match("ftp", regex);
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-inline std::optional<errors> constructor_string_parser<
-    regex_provider>::compute_protocol_matches_special_scheme_flag() {
-  ada_log("constructor_string_parser::compute_protocol_matches_special_scheme_"
-          "flag");
-  // Let protocol string be the result of running make a component string given
-  // parser.
-  auto protocol_string = make_component_string();
-  // Let protocol component be the result of compiling a component given
-  // protocol string, canonicalize a protocol, and default options.
-  auto protocol_component = url_pattern_component<regex_provider>::compile(
-      protocol_string, canonicalize_protocol,
-      url_pattern_compile_component_options::DEFAULT);
-  if (!protocol_component) {
-    ada_log("url_pattern_component::compile failed for protocol_string ",
-            protocol_string);
-    return protocol_component.error();
-  }
-  // If the result of running protocol component matches a special scheme given
-  // protocol component is true, then set parser’s protocol matches a special
-  // scheme flag to true.
-  if (protocol_component_matches_special_scheme(*protocol_component)) {
-    protocol_matches_a_special_scheme_flag = true;
-  }
-  return std::nullopt;
-}
-
-template <url_pattern_regex::regex_concept regex_provider>
-tl::expected<url_pattern_init, errors>
-constructor_string_parser<regex_provider>::parse(std::string_view input) {
-  ada_log("constructor_string_parser::parse input=", input);
-  // Let parser be a new constructor string parser whose input is input and
-  // token list is the result of running tokenize given input and "lenient".
-  auto token_list = tokenize(input, token_policy::lenient);
-  if (!token_list) {
-    return tl::unexpected(token_list.error());
-  }
-  auto parser = constructor_string_parser(input, std::move(*token_list));
-
-  // While parser’s token index is less than parser’s token list size:
-  while (parser.token_index < parser.token_list.size()) {
-    // Set parser’s token increment to 1.
-    parser.token_increment = 1;
-
-    // If parser’s token list[parser’s token index]'s type is "end" then:
-    if (parser.token_list[parser.token_index].type == token_type::END) {
-      // If parser’s state is "init":
-      if (parser.state == State::INIT) {
-        // Run rewind given parser.
-        parser.rewind();
-        // If the result of running is a hash prefix given parser is true, then
-        // run change state given parser, "hash" and 1.
-        if (parser.is_hash_prefix()) {
-          parser.change_state(State::HASH, 1);
-        } else if (parser.is_search_prefix()) {
-          // Otherwise if the result of running is a search prefix given parser
-          // is true: Run change state given parser, "search" and 1.
-          parser.change_state(State::SEARCH, 1);
-        } else {
-          // Run change state given parser, "pathname" and 0.
-          parser.change_state(State::PATHNAME, 0);
-        }
-        // Increment parser’s token index by parser’s token increment.
-        parser.token_index += parser.token_increment;
-        // Continue.
-        continue;
-      }
-
-      if (parser.state == State::AUTHORITY) {
-        // If parser’s state is "authority":
-        // Run rewind and set state given parser, and "hostname".
-        parser.rewind();
-        parser.change_state(State::HOSTNAME, 0);
-        // Increment parser’s token index by parser’s token increment.
-        parser.token_index += parser.token_increment;
-        // Continue.
-        continue;
-      }
-
-      // Run change state given parser, "done" and 0.
-      parser.change_state(State::DONE, 0);
-      // Break.
-      break;
-    }
-
-    // If the result of running is a group open given parser is true:
-    if (parser.is_group_open()) {
-      // Increment parser’s group depth by 1.
-      parser.group_depth += 1;
-      // Increment parser’s token index by parser’s token increment.
-      parser.token_index += parser.token_increment;
-    }
-
-    // If parser’s group depth is greater than 0:
-    if (parser.group_depth > 0) {
-      // If the result of running is a group close given parser is true, then
-      // decrement parser’s group depth by 1.
-      if (parser.is_group_close()) {
-        parser.group_depth -= 1;
-      } else {
-        // Increment parser’s token index by parser’s token increment.
-        parser.token_index += parser.token_increment;
-        continue;
-      }
-    }
-
-    // Switch on parser’s state and run the associated steps:
-    switch (parser.state) {
-    case State::INIT: {
-      // If the result of running is a protocol suffix given parser is true:
-      if (parser.is_protocol_suffix()) {
-        // Run rewind and set state given parser and "protocol".
-        parser.rewind();
-        parser.change_state(State::PROTOCOL, 0);
-      }
-      break;
-    }
-    case State::PROTOCOL: {
-      // If the result of running is a protocol suffix given parser is true:
-      if (parser.is_protocol_suffix()) {
-        // Run compute protocol matches a special scheme flag given parser.
-        if (const auto error =
-                parser.compute_protocol_matches_special_scheme_flag()) {
-          ada_log("compute_protocol_matches_special_scheme_flag failed");
-          return tl::unexpected(*error);
-        }
-        // Let next state be "pathname".
-        auto next_state = State::PATHNAME;
-        // Let skip be 1.
-        auto skip = 1;
-        // If the result of running next is authority slashes given parser is
-        // true:
-        if (parser.next_is_authority_slashes()) {
-          // Set next state to "authority".
-          next_state = State::AUTHORITY;
-          // Set skip to 3.
-          skip = 3;
-        } else if (parser.protocol_matches_a_special_scheme_flag) {
-          // Otherwise if parser’s protocol matches a special scheme flag is
-          // true, then set next state to "authority".
-          next_state = State::AUTHORITY;
-        }
-
-        // Run change state given parser, next state, and skip.
-        parser.change_state(next_state, skip);
-      }
-      break;
-    }
-    case State::AUTHORITY: {
-      // If the result of running is an identity terminator given parser is
-      // true, then run rewind and set state given parser and "username".
-      if (parser.is_an_identity_terminator()) {
-        parser.rewind();
-        parser.change_state(State::USERNAME, 0);
-      } else if (parser.is_pathname_start() || parser.is_search_prefix() ||
-                 parser.is_hash_prefix()) {
-        // Otherwise if any of the following are true:
-        // - the result of running is a pathname start given parser;
-        // - the result of running is a search prefix given parser; or
-        // - the result of running is a hash prefix given parser,
-        // then run rewind and set state given parser and "hostname".
-        parser.rewind();
-        parser.change_state(State::HOSTNAME, 0);
-      }
-      break;
-    }
-    case State::USERNAME: {
-      // If the result of running is a password prefix given parser is true,
-      // then run change state given parser, "password", and 1.
-      if (parser.is_password_prefix()) {
-        parser.change_state(State::PASSWORD, 1);
-      } else if (parser.is_an_identity_terminator()) {
-        // Otherwise if the result of running is an identity terminator given
-        // parser is true, then run change state given parser, "hostname",
-        // and 1.
-        parser.change_state(State::HOSTNAME, 1);
-      }
-      break;
-    }
-    case State::PASSWORD: {
-      // If the result of running is an identity terminator given parser is
-      // true, then run change state given parser, "hostname", and 1.
-      if (parser.is_an_identity_terminator()) {
-        parser.change_state(State::HOSTNAME, 1);
-      }
-      break;
-    }
-    case State::HOSTNAME: {
-      // If the result of running is an IPv6 open given parser is true, then
-      // increment parser’s hostname IPv6 bracket depth by 1.
-      if (parser.is_an_ipv6_open()) {
-        parser.hostname_ipv6_bracket_depth += 1;
-      } else if (parser.is_an_ipv6_close()) {
-        // Otherwise if the result of running is an IPv6 close given parser is
-        // true, then decrement parser’s hostname IPv6 bracket depth by 1.
-        parser.hostname_ipv6_bracket_depth -= 1;
-      } else if (parser.is_port_prefix() &&
-                 parser.hostname_ipv6_bracket_depth == 0) {
-        // Otherwise if the result of running is a port prefix given parser is
-        // true and parser’s hostname IPv6 bracket depth is zero, then run
-        // change state given parser, "port", and 1.
-        parser.change_state(State::PORT, 1);
-      } else if (parser.is_pathname_start()) {
-        // Otherwise if the result of running is a pathname start given parser
-        // is true, then run change state given parser, "pathname", and 0.
-        parser.change_state(State::PATHNAME, 0);
-      } else if (parser.is_search_prefix()) {
-        // Otherwise if the result of running is a search prefix given parser
-        // is true, then run change state given parser, "search", and 1.
-        parser.change_state(State::SEARCH, 1);
-      } else if (parser.is_hash_prefix()) {
-        // Otherwise if the result of running is a hash prefix given parser is
-        // true, then run change state given parser, "hash", and 1.
-        parser.change_state(State::HASH, 1);
-      }
-
-      break;
-    }
-    case State::PORT: {
-      // If the result of running is a pathname start given parser is true,
-      // then run change state given parser, "pathname", and 0.
-      if (parser.is_pathname_start()) {
-        parser.change_state(State::PATHNAME, 0);
-      } else if (parser.is_search_prefix()) {
-        // Otherwise if the result of running is a search prefix given parser
-        // is true, then run change state given parser, "search", and 1.
-        parser.change_state(State::SEARCH, 1);
-      } else if (parser.is_hash_prefix()) {
-        // Otherwise if the result of running is a hash prefix given parser is
-        // true, then run change state given parser, "hash", and 1.
-        parser.change_state(State::HASH, 1);
-      }
-      break;
-    }
-    case State::PATHNAME: {
-      // If the result of running is a search prefix given parser is true,
-      // then run change state given parser, "search", and 1.
-      if (parser.is_search_prefix()) {
-        parser.change_state(State::SEARCH, 1);
-      } else if (parser.is_hash_prefix()) {
-        // Otherwise if the result of running is a hash prefix given parser is
-        // true, then run change state given parser, "hash", and 1.
-        parser.change_state(State::HASH, 1);
-      }
-      break;
-    }
-    case State::SEARCH: {
-      // If the result of running is a hash prefix given parser is true, then
-      // run change state given parser, "hash", and 1.
-      if (parser.is_hash_prefix()) {
-        parser.change_state(State::HASH, 1);
-      }
-    }
-    case State::HASH: {
-      // Do nothing
-      break;
-    }
-    default: {
-      // Assert: This step is never reached.
-      unreachable();
-    }
-    }
-
-    // Increment parser’s token index by parser’s token increment.
-    parser.token_index += parser.token_increment;
-  }
-
-  // If parser’s result contains "hostname" and not "port", then set parser’s
-  // result["port"] to the empty string.
-  if (parser.result.hostname && !parser.result.port) {
-    parser.result.port = "";
-  }
-
-  // Return parser’s result.
-  return parser.result;
-}
-
-} // namespace ada::url_pattern_helpers
-
-#endif
-/* end file include/ada/url_pattern_helpers-inl.h */
-
-// Public API
-/* begin file include/ada/ada_version.h */
-/**
- * @file ada_version.h
- * @brief Definitions for Ada's version number.
- */
-#ifndef ADA_ADA_VERSION_H
-#define ADA_ADA_VERSION_H
-
-#define ADA_VERSION "3.0.0"
-
-namespace ada {
-
-enum {
-  ADA_VERSION_MAJOR = 3,
-  ADA_VERSION_MINOR = 0,
-  ADA_VERSION_REVISION = 0,
-};
-
-} // namespace ada
-
-#endif // ADA_ADA_VERSION_H
-/* end file include/ada/ada_version.h */
-/* begin file include/ada/implementation-inl.h */
-/**
- * @file implementation-inl.h
- */
-#ifndef ADA_IMPLEMENTATION_INL_H
-#define ADA_IMPLEMENTATION_INL_H
-
-#include <string_view>
-#include <variant>
-
-namespace ada {
-
-template <url_pattern_regex::regex_concept regex_provider>
-ada_warn_unused tl::expected<url_pattern<regex_provider>, errors>
-parse_url_pattern(std::variant<std::string_view, url_pattern_init> input,
-                  const std::string_view *base_url,
-                  const url_pattern_options *options) {
-  return parser::parse_url_pattern_impl<regex_provider>(std::move(input),
-                                                        base_url, options);
-}
-
-} // namespace ada
-
-#endif // ADA_IMPLEMENTATION_INL_H
-/* end file include/ada/implementation-inl.h */
-
-#endif // ADA_H
-/* end file include/ada.h */
diff --git a/packages/react-native-executorch/common/pfft/pfft.c b/packages/react-native-executorch/common/pfft/pfft.c
deleted file mode 100644
index c7eb096a1c..0000000000
--- a/packages/react-native-executorch/common/pfft/pfft.c
+++ /dev/null
@@ -1,2205 +0,0 @@
-/* Copyright (c) 2013  Julien Pommier ( pommier@modartt.com )
-
-   Based on original fortran 77 code from FFTPACKv4 from NETLIB
-   (http://www.netlib.org/fftpack), authored by Dr Paul Swarztrauber
-   of NCAR, in 1985.
-
-   As confirmed by the NCAR fftpack software curators, the following
-   FFTPACKv5 license applies to FFTPACKv4 sources. My changes are
-   released under the same terms.
-
-   FFTPACK license:
-
-   http://www.cisl.ucar.edu/css/software/fftpack5/ftpk.html
-
-   Copyright (c) 2004 the University Corporation for Atmospheric
-   Research ("UCAR"). All rights reserved. Developed by NCAR's
-   Computational and Information Systems Laboratory, UCAR,
-   www.cisl.ucar.edu.
-
-   Redistribution and use of the Software in source and binary forms,
-   with or without modification, is permitted provided that the
-   following conditions are met:
-
-   - Neither the names of NCAR's Computational and Information Systems
-   Laboratory, the University Corporation for Atmospheric Research,
-   nor the names of its sponsors or contributors may be used to
-   endorse or promote products derived from this Software without
-   specific prior written permission.
-
-   - Redistributions of source code must retain the above copyright
-   notices, this list of conditions, and the disclaimer below.
-
-   - Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions, and the disclaimer below in the
-   documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-   EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO THE WARRANTIES OF
-   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-   NONINFRINGEMENT. IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT
-   HOLDERS BE LIABLE FOR ANY CLAIM, INDIRECT, INCIDENTAL, SPECIAL,
-   EXEMPLARY, OR CONSEQUENTIAL DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-   SOFTWARE.
-
-
-   PFFFT : a Pretty Fast FFT.
-
-   This file is largerly based on the original FFTPACK implementation, modified
-   in order to take advantage of SIMD instructions of modern CPUs.
-*/
-
-/*
-  ChangeLog:
-  - 2011/10/02, version 1: This is the very first release of this file.
-*/
-
-#ifndef _USE_MATH_DEFINES
-#define _USE_MATH_DEFINES // ask gently MSVC to define M_PI, M_SQRT2 etc.
-#endif
-
-#include <assert.h>
-#include <math.h>
-#include <pfft/pfft.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-/* detect compiler flavour */
-#if defined(_MSC_VER)
-#define COMPILER_MSVC
-#elif defined(__GNUC__)
-#define COMPILER_GCC
-#endif
-
-#if defined(COMPILER_GCC)
-#define ALWAYS_INLINE(return_type)                                             \
-  inline return_type __attribute__((always_inline))
-#define NEVER_INLINE(return_type) return_type __attribute__((noinline))
-#define RESTRICT __restrict
-#define VLA_ARRAY_ON_STACK(type__, varname__, size__) type__ varname__[size__];
-#elif defined(COMPILER_MSVC)
-#define ALWAYS_INLINE(return_type) __forceinline return_type
-#define NEVER_INLINE(return_type) __declspec(noinline) return_type
-#define RESTRICT __restrict
-#define VLA_ARRAY_ON_STACK(type__, varname__, size__)                          \
-  type__ *varname__ = (type__ *)_alloca(size__ * sizeof(type__))
-#endif
-
-/*
-  vector support macros: the rest of the code is independant of
-  SSE/Altivec/NEON -- adding support for other platforms with 4-element
-  vectors should be limited to these macros
-*/
-
-// define PFFFT_SIMD_DISABLE if you want to use scalar code instead of simd code
-// #define PFFFT_SIMD_DISABLE
-
-/* select which SIMD intrinsics will be used */
-#if !defined(PFFFT_SIMD_DISABLE)
-#if (defined(__ppc__) || defined(__ppc64__) || defined(__powerpc__) ||         \
-     defined(__powerpc64__)) &&                                                \
-    (defined(__VEC__) || defined(__ALTIVEC__))
-#define PFFFT_SIMD_ALTIVEC
-#elif defined(__ARM_NEON) || defined(__aarch64__) || defined(__arm64) ||       \
-    defined(_M_ARM64) || defined(_M_ARM64EC) || defined(__wasm_simd128__)
-// we test _M_ARM64EC before _M_X64 because when _M_ARM64EC is defined, the
-// microsoft compiler also defines _M_X64
-#define PFFFT_SIMD_NEON
-#elif defined(__x86_64__) || defined(__SSE__) || defined(_M_X64) ||            \
-    (defined(_M_IX86_FP) && _M_IX86_FP >= 1)
-#define PFFFT_SIMD_SSE
-#endif
-#endif // PFFFT_SIMD_DISABLE
-
-/*
-  Altivec support macros
-*/
-#ifdef PFFFT_SIMD_ALTIVEC
-#include <altivec.h>
-typedef vector float v4sf;
-#define SIMD_SZ 4
-#define VZERO() ((vector float)vec_splat_u8(0))
-#define VMUL(a, b) vec_madd(a, b, VZERO())
-#define VADD(a, b) vec_add(a, b)
-#define VMADD(a, b, c) vec_madd(a, b, c)
-#define VSUB(a, b) vec_sub(a, b)
-inline v4sf ld_ps1(const float *p) {
-  v4sf v = vec_lde(0, p);
-  return vec_splat(vec_perm(v, v, vec_lvsl(0, p)), 0);
-}
-#define LD_PS1(p) ld_ps1(&p)
-#define INTERLEAVE2(in1, in2, out1, out2)                                      \
-  {                                                                            \
-    v4sf tmp__ = vec_mergeh(in1, in2);                                         \
-    out2 = vec_mergel(in1, in2);                                               \
-    out1 = tmp__;                                                              \
-  }
-#define UNINTERLEAVE2(in1, in2, out1, out2)                                    \
-  {                                                                            \
-    vector unsigned char vperm1 = (vector unsigned char){                      \
-        0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27};             \
-    vector unsigned char vperm2 = (vector unsigned char){                      \
-        4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31};           \
-    v4sf tmp__ = vec_perm(in1, in2, vperm1);                                   \
-    out2 = vec_perm(in1, in2, vperm2);                                         \
-    out1 = tmp__;                                                              \
-  }
-#define VTRANSPOSE4(x0, x1, x2, x3)                                            \
-  {                                                                            \
-    v4sf y0 = vec_mergeh(x0, x2);                                              \
-    v4sf y1 = vec_mergel(x0, x2);                                              \
-    v4sf y2 = vec_mergeh(x1, x3);                                              \
-    v4sf y3 = vec_mergel(x1, x3);                                              \
-    x0 = vec_mergeh(y0, y2);                                                   \
-    x1 = vec_mergel(y0, y2);                                                   \
-    x2 = vec_mergeh(y1, y3);                                                   \
-    x3 = vec_mergel(y1, y3);                                                   \
-  }
-#define VSWAPHL(a, b)                                                          \
-  vec_perm(a, b,                                                               \
-           (vector unsigned char){16, 17, 18, 19, 20, 21, 22, 23, 8, 9, 10,    \
-                                  11, 12, 13, 14, 15})
-#define VALIGNED(ptr) ((((size_t)(ptr)) & 0xF) == 0)
-
-/*
-  SSE1 support macros
-*/
-#elif defined(PFFFT_SIMD_SSE)
-
-#include <xmmintrin.h>
-typedef __m128 v4sf;
-#define SIMD_SZ                                                                \
-  4 // 4 floats by simd vector -- this is pretty much hardcoded in the
-    // preprocess/finalize functions anyway so you will have to work if you want
-    // to enable AVX with its 256-bit vectors.
-#define VZERO() _mm_setzero_ps()
-#define VMUL(a, b) _mm_mul_ps(a, b)
-#define VADD(a, b) _mm_add_ps(a, b)
-#define VMADD(a, b, c) _mm_add_ps(_mm_mul_ps(a, b), c)
-#define VSUB(a, b) _mm_sub_ps(a, b)
-#define LD_PS1(p) _mm_set1_ps(p)
-#define INTERLEAVE2(in1, in2, out1, out2)                                      \
-  {                                                                            \
-    v4sf tmp__ = _mm_unpacklo_ps(in1, in2);                                    \
-    out2 = _mm_unpackhi_ps(in1, in2);                                          \
-    out1 = tmp__;                                                              \
-  }
-#define UNINTERLEAVE2(in1, in2, out1, out2)                                    \
-  {                                                                            \
-    v4sf tmp__ = _mm_shuffle_ps(in1, in2, _MM_SHUFFLE(2, 0, 2, 0));            \
-    out2 = _mm_shuffle_ps(in1, in2, _MM_SHUFFLE(3, 1, 3, 1));                  \
-    out1 = tmp__;                                                              \
-  }
-#define VTRANSPOSE4(x0, x1, x2, x3) _MM_TRANSPOSE4_PS(x0, x1, x2, x3)
-#define VSWAPHL(a, b) _mm_shuffle_ps(b, a, _MM_SHUFFLE(3, 2, 1, 0))
-#define VALIGNED(ptr) ((((size_t)(ptr)) & 0xF) == 0)
-
-/*
-  ARM NEON support macros
-*/
-#elif defined(PFFFT_SIMD_NEON)
-#include <arm_neon.h>
-typedef float32x4_t v4sf;
-#define SIMD_SZ 4
-#define VZERO() vdupq_n_f32(0)
-#define VMUL(a, b) vmulq_f32(a, b)
-#define VADD(a, b) vaddq_f32(a, b)
-#define VMADD(a, b, c) vmlaq_f32(c, a, b)
-#define VSUB(a, b) vsubq_f32(a, b)
-#define LD_PS1(p) vld1q_dup_f32(&(p))
-#define INTERLEAVE2(in1, in2, out1, out2)                                      \
-  {                                                                            \
-    float32x4x2_t tmp__ = vzipq_f32(in1, in2);                                 \
-    out1 = tmp__.val[0];                                                       \
-    out2 = tmp__.val[1];                                                       \
-  }
-#define UNINTERLEAVE2(in1, in2, out1, out2)                                    \
-  {                                                                            \
-    float32x4x2_t tmp__ = vuzpq_f32(in1, in2);                                 \
-    out1 = tmp__.val[0];                                                       \
-    out2 = tmp__.val[1];                                                       \
-  }
-#define VTRANSPOSE4(x0, x1, x2, x3)                                            \
-  {                                                                            \
-    float32x4x2_t t0_ = vzipq_f32(x0, x2);                                     \
-    float32x4x2_t t1_ = vzipq_f32(x1, x3);                                     \
-    float32x4x2_t u0_ = vzipq_f32(t0_.val[0], t1_.val[0]);                     \
-    float32x4x2_t u1_ = vzipq_f32(t0_.val[1], t1_.val[1]);                     \
-    x0 = u0_.val[0];                                                           \
-    x1 = u0_.val[1];                                                           \
-    x2 = u1_.val[0];                                                           \
-    x3 = u1_.val[1];                                                           \
-  }
-// marginally faster version
-// #  define VTRANSPOSE4(x0,x1,x2,x3) { asm("vtrn.32 %q0, %q1;\n vtrn.32
-// %q2,%q3\n vswp %f0,%e2\n vswp %f1,%e3" : "+w"(x0), "+w"(x1), "+w"(x2),
-// "+w"(x3)::); }
-#define VSWAPHL(a, b) vcombine_f32(vget_low_f32(b), vget_high_f32(a))
-#define VALIGNED(ptr) ((((size_t)(ptr)) & 0x3) == 0)
-#else
-#if !defined(PFFFT_SIMD_DISABLE)
-#warning "building with simd disabled !\n";
-#define PFFFT_SIMD_DISABLE // fallback to scalar code
-#endif
-#endif
-
-// fallback mode for situations where SSE/Altivec are not available, use scalar
-// mode instead
-#ifdef PFFFT_SIMD_DISABLE
-typedef float v4sf;
-#define SIMD_SZ 1
-#define VZERO() 0.f
-#define VMUL(a, b) ((a) * (b))
-#define VADD(a, b) ((a) + (b))
-#define VMADD(a, b, c) ((a) * (b) + (c))
-#define VSUB(a, b) ((a) - (b))
-#define LD_PS1(p) (p)
-#define VALIGNED(ptr) ((((size_t)(ptr)) & 0x3) == 0)
-#endif
-
-// shortcuts for complex multiplcations
-#define VCPLXMUL(ar, ai, br, bi)                                               \
-  {                                                                            \
-    v4sf tmp;                                                                  \
-    tmp = VMUL(ar, bi);                                                        \
-    ar = VMUL(ar, br);                                                         \
-    ar = VSUB(ar, VMUL(ai, bi));                                               \
-    ai = VMUL(ai, br);                                                         \
-    ai = VADD(ai, tmp);                                                        \
-  }
-#define VCPLXMULCONJ(ar, ai, br, bi)                                           \
-  {                                                                            \
-    v4sf tmp;                                                                  \
-    tmp = VMUL(ar, bi);                                                        \
-    ar = VMUL(ar, br);                                                         \
-    ar = VADD(ar, VMUL(ai, bi));                                               \
-    ai = VMUL(ai, br);                                                         \
-    ai = VSUB(ai, tmp);                                                        \
-  }
-#ifndef SVMUL
-// multiply a scalar with a vector
-#define SVMUL(f, v) VMUL(LD_PS1(f), v)
-#endif
-
-#if !defined(PFFFT_SIMD_DISABLE)
-typedef union v4sf_union {
-  v4sf v;
-  float f[4];
-} v4sf_union;
-
-#include <string.h>
-
-#define assertv4(v, f0, f1, f2, f3)                                            \
-  assert(v.f[0] == (f0) && v.f[1] == (f1) && v.f[2] == (f2) && v.f[3] == (f3))
-
-/* detect bugs with the vector support macros */
-void validate_pffft_simd(void) {
-  float f[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
-  v4sf_union a0, a1, a2, a3, t, u;
-  memcpy(a0.f, f, 4 * sizeof(float));
-  memcpy(a1.f, f + 4, 4 * sizeof(float));
-  memcpy(a2.f, f + 8, 4 * sizeof(float));
-  memcpy(a3.f, f + 12, 4 * sizeof(float));
-
-  t = a0;
-  u = a1;
-  t.v = VZERO();
-  printf("VZERO=[%2g %2g %2g %2g]\n", t.f[0], t.f[1], t.f[2], t.f[3]);
-  assertv4(t, 0, 0, 0, 0);
-  t.v = VADD(a1.v, a2.v);
-  printf("VADD(4:7,8:11)=[%2g %2g %2g %2g]\n", t.f[0], t.f[1], t.f[2], t.f[3]);
-  assertv4(t, 12, 14, 16, 18);
-  t.v = VMUL(a1.v, a2.v);
-  printf("VMUL(4:7,8:11)=[%2g %2g %2g %2g]\n", t.f[0], t.f[1], t.f[2], t.f[3]);
-  assertv4(t, 32, 45, 60, 77);
-  t.v = VMADD(a1.v, a2.v, a0.v);
-  printf("VMADD(4:7,8:11,0:3)=[%2g %2g %2g %2g]\n", t.f[0], t.f[1], t.f[2],
-         t.f[3]);
-  assertv4(t, 32, 46, 62, 80);
-
-  INTERLEAVE2(a1.v, a2.v, t.v, u.v);
-  printf("INTERLEAVE2(4:7,8:11)=[%2g %2g %2g %2g] [%2g %2g %2g %2g]\n", t.f[0],
-         t.f[1], t.f[2], t.f[3], u.f[0], u.f[1], u.f[2], u.f[3]);
-  assertv4(t, 4, 8, 5, 9);
-  assertv4(u, 6, 10, 7, 11);
-  UNINTERLEAVE2(a1.v, a2.v, t.v, u.v);
-  printf("UNINTERLEAVE2(4:7,8:11)=[%2g %2g %2g %2g] [%2g %2g %2g %2g]\n",
-         t.f[0], t.f[1], t.f[2], t.f[3], u.f[0], u.f[1], u.f[2], u.f[3]);
-  assertv4(t, 4, 6, 8, 10);
-  assertv4(u, 5, 7, 9, 11);
-
-  t.v = LD_PS1(f[15]);
-  printf("LD_PS1(15)=[%2g %2g %2g %2g]\n", t.f[0], t.f[1], t.f[2], t.f[3]);
-  assertv4(t, 15, 15, 15, 15);
-  t.v = VSWAPHL(a1.v, a2.v);
-  printf("VSWAPHL(4:7,8:11)=[%2g %2g %2g %2g]\n", t.f[0], t.f[1], t.f[2],
-         t.f[3]);
-  assertv4(t, 8, 9, 6, 7);
-  VTRANSPOSE4(a0.v, a1.v, a2.v, a3.v);
-  printf("VTRANSPOSE4(0:3,4:7,8:11,12:15)=[%2g %2g %2g %2g] [%2g %2g %2g %2g] "
-         "[%2g %2g %2g %2g] [%2g %2g %2g %2g]\n",
-         a0.f[0], a0.f[1], a0.f[2], a0.f[3], a1.f[0], a1.f[1], a1.f[2], a1.f[3],
-         a2.f[0], a2.f[1], a2.f[2], a2.f[3], a3.f[0], a3.f[1], a3.f[2],
-         a3.f[3]);
-  assertv4(a0, 0, 4, 8, 12);
-  assertv4(a1, 1, 5, 9, 13);
-  assertv4(a2, 2, 6, 10, 14);
-  assertv4(a3, 3, 7, 11, 15);
-}
-#else
-void validate_pffft_simd() {
-} // allow test_pffft.c to call this function even when simd is not available..
-#endif //! PFFFT_SIMD_DISABLE
-
-/* SSE and co like 16-bytes aligned pointers */
-#define MALLOC_V4SF_ALIGNMENT                                                  \
-  64 // with a 64-byte alignment, we are even aligned on L2 cache lines...
-void *pffft_aligned_malloc(size_t nb_bytes) {
-  void *p, *p0 = malloc(nb_bytes + MALLOC_V4SF_ALIGNMENT);
-  if (!p0)
-    return (void *)0;
-  p = (void *)(((size_t)p0 + MALLOC_V4SF_ALIGNMENT) &
-               (~((size_t)(MALLOC_V4SF_ALIGNMENT - 1))));
-  *((void **)p - 1) = p0;
-  return p;
-}
-
-void pffft_aligned_free(void *p) {
-  if (p)
-    free(*((void **)p - 1));
-}
-
-int pffft_simd_size(void) { return SIMD_SZ; }
-
-/*
-  passf2 and passb2 has been merged here, fsign = -1 for passf2, +1 for passb2
-*/
-static NEVER_INLINE(void) passf2_ps(int ido, int l1, const v4sf *cc, v4sf *ch,
-                                    const float *wa1, float fsign) {
-  int k, i;
-  int l1ido = l1 * ido;
-  if (ido <= 2) {
-    for (k = 0; k < l1ido; k += ido, ch += ido, cc += 2 * ido) {
-      ch[0] = VADD(cc[0], cc[ido + 0]);
-      ch[l1ido] = VSUB(cc[0], cc[ido + 0]);
-      ch[1] = VADD(cc[1], cc[ido + 1]);
-      ch[l1ido + 1] = VSUB(cc[1], cc[ido + 1]);
-    }
-  } else {
-    for (k = 0; k < l1ido; k += ido, ch += ido, cc += 2 * ido) {
-      for (i = 0; i < ido - 1; i += 2) {
-        v4sf tr2 = VSUB(cc[i + 0], cc[i + ido + 0]);
-        v4sf ti2 = VSUB(cc[i + 1], cc[i + ido + 1]);
-        v4sf wr = LD_PS1(wa1[i]), wi = VMUL(LD_PS1(fsign), LD_PS1(wa1[i + 1]));
-        ch[i] = VADD(cc[i + 0], cc[i + ido + 0]);
-        ch[i + 1] = VADD(cc[i + 1], cc[i + ido + 1]);
-        VCPLXMUL(tr2, ti2, wr, wi);
-        ch[i + l1ido] = tr2;
-        ch[i + l1ido + 1] = ti2;
-      }
-    }
-  }
-}
-
-/*
-  passf3 and passb3 has been merged here, fsign = -1 for passf3, +1 for passb3
-*/
-static NEVER_INLINE(void)
-    passf3_ps(int ido, int l1, const v4sf *cc, v4sf *ch, const float *wa1,
-              const float *wa2, float fsign) {
-  static const float taur = -0.5f;
-  float taui = 0.866025403784439f * fsign;
-  int i, k;
-  v4sf tr2, ti2, cr2, ci2, cr3, ci3, dr2, di2, dr3, di3;
-  int l1ido = l1 * ido;
-  float wr1, wi1, wr2, wi2;
-  assert(ido > 2);
-  for (k = 0; k < l1ido; k += ido, cc += 3 * ido, ch += ido) {
-    for (i = 0; i < ido - 1; i += 2) {
-      tr2 = VADD(cc[i + ido], cc[i + 2 * ido]);
-      cr2 = VADD(cc[i], SVMUL(taur, tr2));
-      ch[i] = VADD(cc[i], tr2);
-      ti2 = VADD(cc[i + ido + 1], cc[i + 2 * ido + 1]);
-      ci2 = VADD(cc[i + 1], SVMUL(taur, ti2));
-      ch[i + 1] = VADD(cc[i + 1], ti2);
-      cr3 = SVMUL(taui, VSUB(cc[i + ido], cc[i + 2 * ido]));
-      ci3 = SVMUL(taui, VSUB(cc[i + ido + 1], cc[i + 2 * ido + 1]));
-      dr2 = VSUB(cr2, ci3);
-      dr3 = VADD(cr2, ci3);
-      di2 = VADD(ci2, cr3);
-      di3 = VSUB(ci2, cr3);
-      wr1 = wa1[i];
-      wi1 = fsign * wa1[i + 1];
-      wr2 = wa2[i];
-      wi2 = fsign * wa2[i + 1];
-      VCPLXMUL(dr2, di2, LD_PS1(wr1), LD_PS1(wi1));
-      ch[i + l1ido] = dr2;
-      ch[i + l1ido + 1] = di2;
-      VCPLXMUL(dr3, di3, LD_PS1(wr2), LD_PS1(wi2));
-      ch[i + 2 * l1ido] = dr3;
-      ch[i + 2 * l1ido + 1] = di3;
-    }
-  }
-} /* passf3 */
-
-static NEVER_INLINE(void)
-    passf4_ps(int ido, int l1, const v4sf *cc, v4sf *ch, const float *wa1,
-              const float *wa2, const float *wa3, float fsign) {
-  /* isign == -1 for forward transform and +1 for backward transform */
-
-  int i, k;
-  v4sf ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4;
-  int l1ido = l1 * ido;
-  if (ido == 2) {
-    for (k = 0; k < l1ido; k += ido, ch += ido, cc += 4 * ido) {
-      tr1 = VSUB(cc[0], cc[2 * ido + 0]);
-      tr2 = VADD(cc[0], cc[2 * ido + 0]);
-      ti1 = VSUB(cc[1], cc[2 * ido + 1]);
-      ti2 = VADD(cc[1], cc[2 * ido + 1]);
-      ti4 = VMUL(VSUB(cc[1 * ido + 0], cc[3 * ido + 0]), LD_PS1(fsign));
-      tr4 = VMUL(VSUB(cc[3 * ido + 1], cc[1 * ido + 1]), LD_PS1(fsign));
-      tr3 = VADD(cc[ido + 0], cc[3 * ido + 0]);
-      ti3 = VADD(cc[ido + 1], cc[3 * ido + 1]);
-
-      ch[0 * l1ido + 0] = VADD(tr2, tr3);
-      ch[0 * l1ido + 1] = VADD(ti2, ti3);
-      ch[1 * l1ido + 0] = VADD(tr1, tr4);
-      ch[1 * l1ido + 1] = VADD(ti1, ti4);
-      ch[2 * l1ido + 0] = VSUB(tr2, tr3);
-      ch[2 * l1ido + 1] = VSUB(ti2, ti3);
-      ch[3 * l1ido + 0] = VSUB(tr1, tr4);
-      ch[3 * l1ido + 1] = VSUB(ti1, ti4);
-    }
-  } else {
-    for (k = 0; k < l1ido; k += ido, ch += ido, cc += 4 * ido) {
-      for (i = 0; i < ido - 1; i += 2) {
-        float wr1, wi1, wr2, wi2, wr3, wi3;
-        tr1 = VSUB(cc[i + 0], cc[i + 2 * ido + 0]);
-        tr2 = VADD(cc[i + 0], cc[i + 2 * ido + 0]);
-        ti1 = VSUB(cc[i + 1], cc[i + 2 * ido + 1]);
-        ti2 = VADD(cc[i + 1], cc[i + 2 * ido + 1]);
-        tr4 =
-            VMUL(VSUB(cc[i + 3 * ido + 1], cc[i + 1 * ido + 1]), LD_PS1(fsign));
-        ti4 =
-            VMUL(VSUB(cc[i + 1 * ido + 0], cc[i + 3 * ido + 0]), LD_PS1(fsign));
-        tr3 = VADD(cc[i + ido + 0], cc[i + 3 * ido + 0]);
-        ti3 = VADD(cc[i + ido + 1], cc[i + 3 * ido + 1]);
-
-        ch[i] = VADD(tr2, tr3);
-        cr3 = VSUB(tr2, tr3);
-        ch[i + 1] = VADD(ti2, ti3);
-        ci3 = VSUB(ti2, ti3);
-
-        cr2 = VADD(tr1, tr4);
-        cr4 = VSUB(tr1, tr4);
-        ci2 = VADD(ti1, ti4);
-        ci4 = VSUB(ti1, ti4);
-        wr1 = wa1[i];
-        wi1 = fsign * wa1[i + 1];
-        VCPLXMUL(cr2, ci2, LD_PS1(wr1), LD_PS1(wi1));
-        wr2 = wa2[i];
-        wi2 = fsign * wa2[i + 1];
-        ch[i + l1ido] = cr2;
-        ch[i + l1ido + 1] = ci2;
-
-        VCPLXMUL(cr3, ci3, LD_PS1(wr2), LD_PS1(wi2));
-        wr3 = wa3[i];
-        wi3 = fsign * wa3[i + 1];
-        ch[i + 2 * l1ido] = cr3;
-        ch[i + 2 * l1ido + 1] = ci3;
-
-        VCPLXMUL(cr4, ci4, LD_PS1(wr3), LD_PS1(wi3));
-        ch[i + 3 * l1ido] = cr4;
-        ch[i + 3 * l1ido + 1] = ci4;
-      }
-    }
-  }
-} /* passf4 */
-
-/*
-  passf5 and passb5 has been merged here, fsign = -1 for passf5, +1 for passb5
-*/
-static NEVER_INLINE(void)
-    passf5_ps(int ido, int l1, const v4sf *cc, v4sf *ch, const float *wa1,
-              const float *wa2, const float *wa3, const float *wa4,
-              float fsign) {
-  static const float tr11 = .309016994374947f;
-  const float ti11 = .951056516295154f * fsign;
-  static const float tr12 = -.809016994374947f;
-  const float ti12 = .587785252292473f * fsign;
-
-  /* Local variables */
-  int i, k;
-  v4sf ci2, ci3, ci4, ci5, di3, di4, di5, di2, cr2, cr3, cr5, cr4, ti2, ti3,
-      ti4, ti5, dr3, dr4, dr5, dr2, tr2, tr3, tr4, tr5;
-
-  float wr1, wi1, wr2, wi2, wr3, wi3, wr4, wi4;
-
-#define cc_ref(a_1, a_2) cc[(a_2 - 1) * ido + a_1 + 1]
-#define ch_ref(a_1, a_3) ch[(a_3 - 1) * l1 * ido + a_1 + 1]
-
-  assert(ido > 2);
-  for (k = 0; k < l1; ++k, cc += 5 * ido, ch += ido) {
-    for (i = 0; i < ido - 1; i += 2) {
-      ti5 = VSUB(cc_ref(i, 2), cc_ref(i, 5));
-      ti2 = VADD(cc_ref(i, 2), cc_ref(i, 5));
-      ti4 = VSUB(cc_ref(i, 3), cc_ref(i, 4));
-      ti3 = VADD(cc_ref(i, 3), cc_ref(i, 4));
-      tr5 = VSUB(cc_ref(i - 1, 2), cc_ref(i - 1, 5));
-      tr2 = VADD(cc_ref(i - 1, 2), cc_ref(i - 1, 5));
-      tr4 = VSUB(cc_ref(i - 1, 3), cc_ref(i - 1, 4));
-      tr3 = VADD(cc_ref(i - 1, 3), cc_ref(i - 1, 4));
-      ch_ref(i - 1, 1) = VADD(cc_ref(i - 1, 1), VADD(tr2, tr3));
-      ch_ref(i, 1) = VADD(cc_ref(i, 1), VADD(ti2, ti3));
-      cr2 = VADD(cc_ref(i - 1, 1), VADD(SVMUL(tr11, tr2), SVMUL(tr12, tr3)));
-      ci2 = VADD(cc_ref(i, 1), VADD(SVMUL(tr11, ti2), SVMUL(tr12, ti3)));
-      cr3 = VADD(cc_ref(i - 1, 1), VADD(SVMUL(tr12, tr2), SVMUL(tr11, tr3)));
-      ci3 = VADD(cc_ref(i, 1), VADD(SVMUL(tr12, ti2), SVMUL(tr11, ti3)));
-      cr5 = VADD(SVMUL(ti11, tr5), SVMUL(ti12, tr4));
-      ci5 = VADD(SVMUL(ti11, ti5), SVMUL(ti12, ti4));
-      cr4 = VSUB(SVMUL(ti12, tr5), SVMUL(ti11, tr4));
-      ci4 = VSUB(SVMUL(ti12, ti5), SVMUL(ti11, ti4));
-      dr3 = VSUB(cr3, ci4);
-      dr4 = VADD(cr3, ci4);
-      di3 = VADD(ci3, cr4);
-      di4 = VSUB(ci3, cr4);
-      dr5 = VADD(cr2, ci5);
-      dr2 = VSUB(cr2, ci5);
-      di5 = VSUB(ci2, cr5);
-      di2 = VADD(ci2, cr5);
-      wr1 = wa1[i];
-      wi1 = fsign * wa1[i + 1];
-      wr2 = wa2[i];
-      wi2 = fsign * wa2[i + 1];
-      wr3 = wa3[i];
-      wi3 = fsign * wa3[i + 1];
-      wr4 = wa4[i];
-      wi4 = fsign * wa4[i + 1];
-      VCPLXMUL(dr2, di2, LD_PS1(wr1), LD_PS1(wi1));
-      ch_ref(i - 1, 2) = dr2;
-      ch_ref(i, 2) = di2;
-      VCPLXMUL(dr3, di3, LD_PS1(wr2), LD_PS1(wi2));
-      ch_ref(i - 1, 3) = dr3;
-      ch_ref(i, 3) = di3;
-      VCPLXMUL(dr4, di4, LD_PS1(wr3), LD_PS1(wi3));
-      ch_ref(i - 1, 4) = dr4;
-      ch_ref(i, 4) = di4;
-      VCPLXMUL(dr5, di5, LD_PS1(wr4), LD_PS1(wi4));
-      ch_ref(i - 1, 5) = dr5;
-      ch_ref(i, 5) = di5;
-    }
-  }
-#undef ch_ref
-#undef cc_ref
-}
-
-static NEVER_INLINE(void) radf2_ps(int ido, int l1, const v4sf *RESTRICT cc,
-                                   v4sf *RESTRICT ch, const float *wa1) {
-  static const float minus_one = -1.f;
-  int i, k, l1ido = l1 * ido;
-  for (k = 0; k < l1ido; k += ido) {
-    v4sf a = cc[k], b = cc[k + l1ido];
-    ch[2 * k] = VADD(a, b);
-    ch[2 * (k + ido) - 1] = VSUB(a, b);
-  }
-  if (ido < 2)
-    return;
-  if (ido != 2) {
-    for (k = 0; k < l1ido; k += ido) {
-      for (i = 2; i < ido; i += 2) {
-        v4sf tr2 = cc[i - 1 + k + l1ido], ti2 = cc[i + k + l1ido];
-        v4sf br = cc[i - 1 + k], bi = cc[i + k];
-        VCPLXMULCONJ(tr2, ti2, LD_PS1(wa1[i - 2]), LD_PS1(wa1[i - 1]));
-        ch[i + 2 * k] = VADD(bi, ti2);
-        ch[2 * (k + ido) - i] = VSUB(ti2, bi);
-        ch[i - 1 + 2 * k] = VADD(br, tr2);
-        ch[2 * (k + ido) - i - 1] = VSUB(br, tr2);
-      }
-    }
-    if (ido % 2 == 1)
-      return;
-  }
-  for (k = 0; k < l1ido; k += ido) {
-    ch[2 * k + ido] = SVMUL(minus_one, cc[ido - 1 + k + l1ido]);
-    ch[2 * k + ido - 1] = cc[k + ido - 1];
-  }
-} /* radf2 */
-
-static NEVER_INLINE(void)
-    radb2_ps(int ido, int l1, const v4sf *cc, v4sf *ch, const float *wa1) {
-  static const float minus_two = -2;
-  int i, k, l1ido = l1 * ido;
-  v4sf a, b, c, d, tr2, ti2;
-  for (k = 0; k < l1ido; k += ido) {
-    a = cc[2 * k];
-    b = cc[2 * (k + ido) - 1];
-    ch[k] = VADD(a, b);
-    ch[k + l1ido] = VSUB(a, b);
-  }
-  if (ido < 2)
-    return;
-  if (ido != 2) {
-    for (k = 0; k < l1ido; k += ido) {
-      for (i = 2; i < ido; i += 2) {
-        a = cc[i - 1 + 2 * k];
-        b = cc[2 * (k + ido) - i - 1];
-        c = cc[i + 0 + 2 * k];
-        d = cc[2 * (k + ido) - i + 0];
-        ch[i - 1 + k] = VADD(a, b);
-        tr2 = VSUB(a, b);
-        ch[i + 0 + k] = VSUB(c, d);
-        ti2 = VADD(c, d);
-        VCPLXMUL(tr2, ti2, LD_PS1(wa1[i - 2]), LD_PS1(wa1[i - 1]));
-        ch[i - 1 + k + l1ido] = tr2;
-        ch[i + 0 + k + l1ido] = ti2;
-      }
-    }
-    if (ido % 2 == 1)
-      return;
-  }
-  for (k = 0; k < l1ido; k += ido) {
-    a = cc[2 * k + ido - 1];
-    b = cc[2 * k + ido];
-    ch[k + ido - 1] = VADD(a, a);
-    ch[k + ido - 1 + l1ido] = SVMUL(minus_two, b);
-  }
-} /* radb2 */
-
-static void radf3_ps(int ido, int l1, const v4sf *RESTRICT cc,
-                     v4sf *RESTRICT ch, const float *wa1, const float *wa2) {
-  static const float taur = -0.5f;
-  static const float taui = 0.866025403784439f;
-  int i, k, ic;
-  v4sf ci2, di2, di3, cr2, dr2, dr3, ti2, ti3, tr2, tr3, wr1, wi1, wr2, wi2;
-  for (k = 0; k < l1; k++) {
-    cr2 = VADD(cc[(k + l1) * ido], cc[(k + 2 * l1) * ido]);
-    ch[3 * k * ido] = VADD(cc[k * ido], cr2);
-    ch[(3 * k + 2) * ido] =
-        SVMUL(taui, VSUB(cc[(k + l1 * 2) * ido], cc[(k + l1) * ido]));
-    ch[ido - 1 + (3 * k + 1) * ido] = VADD(cc[k * ido], SVMUL(taur, cr2));
-  }
-  if (ido == 1)
-    return;
-  for (k = 0; k < l1; k++) {
-    for (i = 2; i < ido; i += 2) {
-      ic = ido - i;
-      wr1 = LD_PS1(wa1[i - 2]);
-      wi1 = LD_PS1(wa1[i - 1]);
-      dr2 = cc[i - 1 + (k + l1) * ido];
-      di2 = cc[i + (k + l1) * ido];
-      VCPLXMULCONJ(dr2, di2, wr1, wi1);
-
-      wr2 = LD_PS1(wa2[i - 2]);
-      wi2 = LD_PS1(wa2[i - 1]);
-      dr3 = cc[i - 1 + (k + l1 * 2) * ido];
-      di3 = cc[i + (k + l1 * 2) * ido];
-      VCPLXMULCONJ(dr3, di3, wr2, wi2);
-
-      cr2 = VADD(dr2, dr3);
-      ci2 = VADD(di2, di3);
-      ch[i - 1 + 3 * k * ido] = VADD(cc[i - 1 + k * ido], cr2);
-      ch[i + 3 * k * ido] = VADD(cc[i + k * ido], ci2);
-      tr2 = VADD(cc[i - 1 + k * ido], SVMUL(taur, cr2));
-      ti2 = VADD(cc[i + k * ido], SVMUL(taur, ci2));
-      tr3 = SVMUL(taui, VSUB(di2, di3));
-      ti3 = SVMUL(taui, VSUB(dr3, dr2));
-      ch[i - 1 + (3 * k + 2) * ido] = VADD(tr2, tr3);
-      ch[ic - 1 + (3 * k + 1) * ido] = VSUB(tr2, tr3);
-      ch[i + (3 * k + 2) * ido] = VADD(ti2, ti3);
-      ch[ic + (3 * k + 1) * ido] = VSUB(ti3, ti2);
-    }
-  }
-} /* radf3 */
-
-static void radb3_ps(int ido, int l1, const v4sf *RESTRICT cc,
-                     v4sf *RESTRICT ch, const float *wa1, const float *wa2) {
-  static const float taur = -0.5f;
-  static const float taui = 0.866025403784439f;
-  static const float taui_2 = 0.866025403784439f * 2;
-  int i, k, ic;
-  v4sf ci2, ci3, di2, di3, cr2, cr3, dr2, dr3, ti2, tr2;
-  for (k = 0; k < l1; k++) {
-    tr2 = cc[ido - 1 + (3 * k + 1) * ido];
-    tr2 = VADD(tr2, tr2);
-    cr2 = VMADD(LD_PS1(taur), tr2, cc[3 * k * ido]);
-    ch[k * ido] = VADD(cc[3 * k * ido], tr2);
-    ci3 = SVMUL(taui_2, cc[(3 * k + 2) * ido]);
-    ch[(k + l1) * ido] = VSUB(cr2, ci3);
-    ch[(k + 2 * l1) * ido] = VADD(cr2, ci3);
-  }
-  if (ido == 1)
-    return;
-  for (k = 0; k < l1; k++) {
-    for (i = 2; i < ido; i += 2) {
-      ic = ido - i;
-      tr2 = VADD(cc[i - 1 + (3 * k + 2) * ido], cc[ic - 1 + (3 * k + 1) * ido]);
-      cr2 = VMADD(LD_PS1(taur), tr2, cc[i - 1 + 3 * k * ido]);
-      ch[i - 1 + k * ido] = VADD(cc[i - 1 + 3 * k * ido], tr2);
-      ti2 = VSUB(cc[i + (3 * k + 2) * ido], cc[ic + (3 * k + 1) * ido]);
-      ci2 = VMADD(LD_PS1(taur), ti2, cc[i + 3 * k * ido]);
-      ch[i + k * ido] = VADD(cc[i + 3 * k * ido], ti2);
-      cr3 = SVMUL(taui, VSUB(cc[i - 1 + (3 * k + 2) * ido],
-                             cc[ic - 1 + (3 * k + 1) * ido]));
-      ci3 = SVMUL(taui,
-                  VADD(cc[i + (3 * k + 2) * ido], cc[ic + (3 * k + 1) * ido]));
-      dr2 = VSUB(cr2, ci3);
-      dr3 = VADD(cr2, ci3);
-      di2 = VADD(ci2, cr3);
-      di3 = VSUB(ci2, cr3);
-      VCPLXMUL(dr2, di2, LD_PS1(wa1[i - 2]), LD_PS1(wa1[i - 1]));
-      ch[i - 1 + (k + l1) * ido] = dr2;
-      ch[i + (k + l1) * ido] = di2;
-      VCPLXMUL(dr3, di3, LD_PS1(wa2[i - 2]), LD_PS1(wa2[i - 1]));
-      ch[i - 1 + (k + 2 * l1) * ido] = dr3;
-      ch[i + (k + 2 * l1) * ido] = di3;
-    }
-  }
-} /* radb3 */
-
-static NEVER_INLINE(void)
-    radf4_ps(int ido, int l1, const v4sf *RESTRICT cc, v4sf *RESTRICT ch,
-             const float *RESTRICT wa1, const float *RESTRICT wa2,
-             const float *RESTRICT wa3) {
-  static const float minus_hsqt2 = (float)-0.7071067811865475;
-  int i, k, l1ido = l1 * ido;
-  {
-    const v4sf *RESTRICT cc_ = cc, *RESTRICT cc_end = cc + l1ido;
-    v4sf *RESTRICT ch_ = ch;
-    while (cc < cc_end) {
-      // this loop represents between 25% and 40% of total radf4_ps cost !
-      v4sf a0 = cc[0], a1 = cc[l1ido];
-      v4sf a2 = cc[2 * l1ido], a3 = cc[3 * l1ido];
-      v4sf tr1 = VADD(a1, a3);
-      v4sf tr2 = VADD(a0, a2);
-      ch[2 * ido - 1] = VSUB(a0, a2);
-      ch[2 * ido] = VSUB(a3, a1);
-      ch[0] = VADD(tr1, tr2);
-      ch[4 * ido - 1] = VSUB(tr2, tr1);
-      cc += ido;
-      ch += 4 * ido;
-    }
-    cc = cc_;
-    ch = ch_;
-  }
-  if (ido < 2)
-    return;
-  if (ido != 2) {
-    for (k = 0; k < l1ido; k += ido) {
-      const v4sf *RESTRICT pc = (v4sf *)(cc + 1 + k);
-      for (i = 2; i < ido; i += 2, pc += 2) {
-        int ic = ido - i;
-        v4sf wr, wi, cr2, ci2, cr3, ci3, cr4, ci4;
-        v4sf tr1, ti1, tr2, ti2, tr3, ti3, tr4, ti4;
-
-        cr2 = pc[1 * l1ido + 0];
-        ci2 = pc[1 * l1ido + 1];
-        wr = LD_PS1(wa1[i - 2]);
-        wi = LD_PS1(wa1[i - 1]);
-        VCPLXMULCONJ(cr2, ci2, wr, wi);
-
-        cr3 = pc[2 * l1ido + 0];
-        ci3 = pc[2 * l1ido + 1];
-        wr = LD_PS1(wa2[i - 2]);
-        wi = LD_PS1(wa2[i - 1]);
-        VCPLXMULCONJ(cr3, ci3, wr, wi);
-
-        cr4 = pc[3 * l1ido];
-        ci4 = pc[3 * l1ido + 1];
-        wr = LD_PS1(wa3[i - 2]);
-        wi = LD_PS1(wa3[i - 1]);
-        VCPLXMULCONJ(cr4, ci4, wr, wi);
-
-        /* at this point, on SSE, five of "cr2 cr3 cr4 ci2 ci3 ci4" should be
-         * loaded in registers */
-
-        tr1 = VADD(cr2, cr4);
-        tr4 = VSUB(cr4, cr2);
-        tr2 = VADD(pc[0], cr3);
-        tr3 = VSUB(pc[0], cr3);
-        ch[i - 1 + 4 * k] = VADD(tr1, tr2);
-        ch[ic - 1 + 4 * k + 3 * ido] =
-            VSUB(tr2, tr1); // at this point tr1 and tr2 can be disposed
-        ti1 = VADD(ci2, ci4);
-        ti4 = VSUB(ci2, ci4);
-        ch[i - 1 + 4 * k + 2 * ido] = VADD(ti4, tr3);
-        ch[ic - 1 + 4 * k + 1 * ido] = VSUB(tr3, ti4); // dispose tr3, ti4
-        ti2 = VADD(pc[1], ci3);
-        ti3 = VSUB(pc[1], ci3);
-        ch[i + 4 * k] = VADD(ti1, ti2);
-        ch[ic + 4 * k + 3 * ido] = VSUB(ti1, ti2);
-        ch[i + 4 * k + 2 * ido] = VADD(tr4, ti3);
-        ch[ic + 4 * k + 1 * ido] = VSUB(tr4, ti3);
-      }
-    }
-    if (ido % 2 == 1)
-      return;
-  }
-  for (k = 0; k < l1ido; k += ido) {
-    v4sf a = cc[ido - 1 + k + l1ido], b = cc[ido - 1 + k + 3 * l1ido];
-    v4sf c = cc[ido - 1 + k], d = cc[ido - 1 + k + 2 * l1ido];
-    v4sf ti1 = SVMUL(minus_hsqt2, VADD(a, b));
-    v4sf tr1 = SVMUL(minus_hsqt2, VSUB(b, a));
-    ch[ido - 1 + 4 * k] = VADD(tr1, c);
-    ch[ido - 1 + 4 * k + 2 * ido] = VSUB(c, tr1);
-    ch[4 * k + 1 * ido] = VSUB(ti1, d);
-    ch[4 * k + 3 * ido] = VADD(ti1, d);
-  }
-} /* radf4 */
-
-static NEVER_INLINE(void)
-    radb4_ps(int ido, int l1, const v4sf *RESTRICT cc, v4sf *RESTRICT ch,
-             const float *RESTRICT wa1, const float *RESTRICT wa2,
-             const float *RESTRICT wa3) {
-  static const float minus_sqrt2 = (float)-1.414213562373095;
-  static const float two = 2.f;
-  int i, k, l1ido = l1 * ido;
-  v4sf ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4;
-  {
-    const v4sf *RESTRICT cc_ = cc, *RESTRICT ch_end = ch + l1ido;
-    v4sf *ch_ = ch;
-    while (ch < ch_end) {
-      v4sf a = cc[0], b = cc[4 * ido - 1];
-      v4sf c = cc[2 * ido], d = cc[2 * ido - 1];
-      tr3 = SVMUL(two, d);
-      tr2 = VADD(a, b);
-      tr1 = VSUB(a, b);
-      tr4 = SVMUL(two, c);
-      ch[0 * l1ido] = VADD(tr2, tr3);
-      ch[2 * l1ido] = VSUB(tr2, tr3);
-      ch[1 * l1ido] = VSUB(tr1, tr4);
-      ch[3 * l1ido] = VADD(tr1, tr4);
-
-      cc += 4 * ido;
-      ch += ido;
-    }
-    cc = cc_;
-    ch = ch_;
-  }
-  if (ido < 2)
-    return;
-  if (ido != 2) {
-    for (k = 0; k < l1ido; k += ido) {
-      const v4sf *RESTRICT pc = (v4sf *)(cc - 1 + 4 * k);
-      v4sf *RESTRICT ph = (v4sf *)(ch + k + 1);
-      for (i = 2; i < ido; i += 2) {
-
-        tr1 = VSUB(pc[i], pc[4 * ido - i]);
-        tr2 = VADD(pc[i], pc[4 * ido - i]);
-        ti4 = VSUB(pc[2 * ido + i], pc[2 * ido - i]);
-        tr3 = VADD(pc[2 * ido + i], pc[2 * ido - i]);
-        ph[0] = VADD(tr2, tr3);
-        cr3 = VSUB(tr2, tr3);
-
-        ti3 = VSUB(pc[2 * ido + i + 1], pc[2 * ido - i + 1]);
-        tr4 = VADD(pc[2 * ido + i + 1], pc[2 * ido - i + 1]);
-        cr2 = VSUB(tr1, tr4);
-        cr4 = VADD(tr1, tr4);
-
-        ti1 = VADD(pc[i + 1], pc[4 * ido - i + 1]);
-        ti2 = VSUB(pc[i + 1], pc[4 * ido - i + 1]);
-
-        ph[1] = VADD(ti2, ti3);
-        ph += l1ido;
-        ci3 = VSUB(ti2, ti3);
-        ci2 = VADD(ti1, ti4);
-        ci4 = VSUB(ti1, ti4);
-        VCPLXMUL(cr2, ci2, LD_PS1(wa1[i - 2]), LD_PS1(wa1[i - 1]));
-        ph[0] = cr2;
-        ph[1] = ci2;
-        ph += l1ido;
-        VCPLXMUL(cr3, ci3, LD_PS1(wa2[i - 2]), LD_PS1(wa2[i - 1]));
-        ph[0] = cr3;
-        ph[1] = ci3;
-        ph += l1ido;
-        VCPLXMUL(cr4, ci4, LD_PS1(wa3[i - 2]), LD_PS1(wa3[i - 1]));
-        ph[0] = cr4;
-        ph[1] = ci4;
-        ph = ph - 3 * l1ido + 2;
-      }
-    }
-    if (ido % 2 == 1)
-      return;
-  }
-  for (k = 0; k < l1ido; k += ido) {
-    int i0 = 4 * k + ido;
-    v4sf c = cc[i0 - 1], d = cc[i0 + 2 * ido - 1];
-    v4sf a = cc[i0 + 0], b = cc[i0 + 2 * ido + 0];
-    tr1 = VSUB(c, d);
-    tr2 = VADD(c, d);
-    ti1 = VADD(b, a);
-    ti2 = VSUB(b, a);
-    ch[ido - 1 + k + 0 * l1ido] = VADD(tr2, tr2);
-    ch[ido - 1 + k + 1 * l1ido] = SVMUL(minus_sqrt2, VSUB(ti1, tr1));
-    ch[ido - 1 + k + 2 * l1ido] = VADD(ti2, ti2);
-    ch[ido - 1 + k + 3 * l1ido] = SVMUL(minus_sqrt2, VADD(ti1, tr1));
-  }
-} /* radb4 */
-
-static void radf5_ps(int ido, int l1, const v4sf *RESTRICT cc,
-                     v4sf *RESTRICT ch, const float *wa1, const float *wa2,
-                     const float *wa3, const float *wa4) {
-  static const float tr11 = .309016994374947f;
-  static const float ti11 = .951056516295154f;
-  static const float tr12 = -.809016994374947f;
-  static const float ti12 = .587785252292473f;
-
-  /* System generated locals */
-  int cc_offset, ch_offset;
-
-  /* Local variables */
-  int i, k, ic;
-  v4sf ci2, di2, ci4, ci5, di3, di4, di5, ci3, cr2, cr3, dr2, dr3, dr4, dr5,
-      cr5, cr4, ti2, ti3, ti5, ti4, tr2, tr3, tr4, tr5;
-  int idp2;
-
-#define cc_ref(a_1, a_2, a_3) cc[((a_3) * l1 + (a_2)) * ido + a_1]
-#define ch_ref(a_1, a_2, a_3) ch[((a_3) * 5 + (a_2)) * ido + a_1]
-
-  /* Parameter adjustments */
-  ch_offset = 1 + ido * 6;
-  ch -= ch_offset;
-  cc_offset = 1 + ido * (1 + l1);
-  cc -= cc_offset;
-
-  /* Function Body */
-  for (k = 1; k <= l1; ++k) {
-    cr2 = VADD(cc_ref(1, k, 5), cc_ref(1, k, 2));
-    ci5 = VSUB(cc_ref(1, k, 5), cc_ref(1, k, 2));
-    cr3 = VADD(cc_ref(1, k, 4), cc_ref(1, k, 3));
-    ci4 = VSUB(cc_ref(1, k, 4), cc_ref(1, k, 3));
-    ch_ref(1, 1, k) = VADD(cc_ref(1, k, 1), VADD(cr2, cr3));
-    ch_ref(ido, 2, k) =
-        VADD(cc_ref(1, k, 1), VADD(SVMUL(tr11, cr2), SVMUL(tr12, cr3)));
-    ch_ref(1, 3, k) = VADD(SVMUL(ti11, ci5), SVMUL(ti12, ci4));
-    ch_ref(ido, 4, k) =
-        VADD(cc_ref(1, k, 1), VADD(SVMUL(tr12, cr2), SVMUL(tr11, cr3)));
-    ch_ref(1, 5, k) = VSUB(SVMUL(ti12, ci5), SVMUL(ti11, ci4));
-    // printf("pffft: radf5, k=%d ch_ref=%f, ci4=%f\n", k, ch_ref(1, 5, k),
-    // ci4);
-  }
-  if (ido == 1) {
-    return;
-  }
-  idp2 = ido + 2;
-  for (k = 1; k <= l1; ++k) {
-    for (i = 3; i <= ido; i += 2) {
-      ic = idp2 - i;
-      dr2 = LD_PS1(wa1[i - 3]);
-      di2 = LD_PS1(wa1[i - 2]);
-      dr3 = LD_PS1(wa2[i - 3]);
-      di3 = LD_PS1(wa2[i - 2]);
-      dr4 = LD_PS1(wa3[i - 3]);
-      di4 = LD_PS1(wa3[i - 2]);
-      dr5 = LD_PS1(wa4[i - 3]);
-      di5 = LD_PS1(wa4[i - 2]);
-      VCPLXMULCONJ(dr2, di2, cc_ref(i - 1, k, 2), cc_ref(i, k, 2));
-      VCPLXMULCONJ(dr3, di3, cc_ref(i - 1, k, 3), cc_ref(i, k, 3));
-      VCPLXMULCONJ(dr4, di4, cc_ref(i - 1, k, 4), cc_ref(i, k, 4));
-      VCPLXMULCONJ(dr5, di5, cc_ref(i - 1, k, 5), cc_ref(i, k, 5));
-      cr2 = VADD(dr2, dr5);
-      ci5 = VSUB(dr5, dr2);
-      cr5 = VSUB(di2, di5);
-      ci2 = VADD(di2, di5);
-      cr3 = VADD(dr3, dr4);
-      ci4 = VSUB(dr4, dr3);
-      cr4 = VSUB(di3, di4);
-      ci3 = VADD(di3, di4);
-      ch_ref(i - 1, 1, k) = VADD(cc_ref(i - 1, k, 1), VADD(cr2, cr3));
-      ch_ref(i, 1, k) = VSUB(cc_ref(i, k, 1), VADD(ci2, ci3)); //
-      tr2 = VADD(cc_ref(i - 1, k, 1), VADD(SVMUL(tr11, cr2), SVMUL(tr12, cr3)));
-      ti2 = VSUB(cc_ref(i, k, 1), VADD(SVMUL(tr11, ci2), SVMUL(tr12, ci3))); //
-      tr3 = VADD(cc_ref(i - 1, k, 1), VADD(SVMUL(tr12, cr2), SVMUL(tr11, cr3)));
-      ti3 = VSUB(cc_ref(i, k, 1), VADD(SVMUL(tr12, ci2), SVMUL(tr11, ci3))); //
-      tr5 = VADD(SVMUL(ti11, cr5), SVMUL(ti12, cr4));
-      ti5 = VADD(SVMUL(ti11, ci5), SVMUL(ti12, ci4));
-      tr4 = VSUB(SVMUL(ti12, cr5), SVMUL(ti11, cr4));
-      ti4 = VSUB(SVMUL(ti12, ci5), SVMUL(ti11, ci4));
-      ch_ref(i - 1, 3, k) = VSUB(tr2, tr5);
-      ch_ref(ic - 1, 2, k) = VADD(tr2, tr5);
-      ch_ref(i, 3, k) = VADD(ti2, ti5);
-      ch_ref(ic, 2, k) = VSUB(ti5, ti2);
-      ch_ref(i - 1, 5, k) = VSUB(tr3, tr4);
-      ch_ref(ic - 1, 4, k) = VADD(tr3, tr4);
-      ch_ref(i, 5, k) = VADD(ti3, ti4);
-      ch_ref(ic, 4, k) = VSUB(ti4, ti3);
-    }
-  }
-#undef cc_ref
-#undef ch_ref
-} /* radf5 */
-
-static void radb5_ps(int ido, int l1, const v4sf *RESTRICT cc,
-                     v4sf *RESTRICT ch, const float *wa1, const float *wa2,
-                     const float *wa3, const float *wa4) {
-  static const float tr11 = .309016994374947f;
-  static const float ti11 = .951056516295154f;
-  static const float tr12 = -.809016994374947f;
-  static const float ti12 = .587785252292473f;
-
-  int cc_offset, ch_offset;
-
-  /* Local variables */
-  int i, k, ic;
-  v4sf ci2, ci3, ci4, ci5, di3, di4, di5, di2, cr2, cr3, cr5, cr4, ti2, ti3,
-      ti4, ti5, dr3, dr4, dr5, dr2, tr2, tr3, tr4, tr5;
-  int idp2;
-
-#define cc_ref(a_1, a_2, a_3) cc[((a_3) * 5 + (a_2)) * ido + a_1]
-#define ch_ref(a_1, a_2, a_3) ch[((a_3) * l1 + (a_2)) * ido + a_1]
-
-  /* Parameter adjustments */
-  ch_offset = 1 + ido * (1 + l1);
-  ch -= ch_offset;
-  cc_offset = 1 + ido * 6;
-  cc -= cc_offset;
-
-  /* Function Body */
-  for (k = 1; k <= l1; ++k) {
-    ti5 = VADD(cc_ref(1, 3, k), cc_ref(1, 3, k));
-    ti4 = VADD(cc_ref(1, 5, k), cc_ref(1, 5, k));
-    tr2 = VADD(cc_ref(ido, 2, k), cc_ref(ido, 2, k));
-    tr3 = VADD(cc_ref(ido, 4, k), cc_ref(ido, 4, k));
-    ch_ref(1, k, 1) = VADD(cc_ref(1, 1, k), VADD(tr2, tr3));
-    cr2 = VADD(cc_ref(1, 1, k), VADD(SVMUL(tr11, tr2), SVMUL(tr12, tr3)));
-    cr3 = VADD(cc_ref(1, 1, k), VADD(SVMUL(tr12, tr2), SVMUL(tr11, tr3)));
-    ci5 = VADD(SVMUL(ti11, ti5), SVMUL(ti12, ti4));
-    ci4 = VSUB(SVMUL(ti12, ti5), SVMUL(ti11, ti4));
-    ch_ref(1, k, 2) = VSUB(cr2, ci5);
-    ch_ref(1, k, 3) = VSUB(cr3, ci4);
-    ch_ref(1, k, 4) = VADD(cr3, ci4);
-    ch_ref(1, k, 5) = VADD(cr2, ci5);
-  }
-  if (ido == 1) {
-    return;
-  }
-  idp2 = ido + 2;
-  for (k = 1; k <= l1; ++k) {
-    for (i = 3; i <= ido; i += 2) {
-      ic = idp2 - i;
-      ti5 = VADD(cc_ref(i, 3, k), cc_ref(ic, 2, k));
-      ti2 = VSUB(cc_ref(i, 3, k), cc_ref(ic, 2, k));
-      ti4 = VADD(cc_ref(i, 5, k), cc_ref(ic, 4, k));
-      ti3 = VSUB(cc_ref(i, 5, k), cc_ref(ic, 4, k));
-      tr5 = VSUB(cc_ref(i - 1, 3, k), cc_ref(ic - 1, 2, k));
-      tr2 = VADD(cc_ref(i - 1, 3, k), cc_ref(ic - 1, 2, k));
-      tr4 = VSUB(cc_ref(i - 1, 5, k), cc_ref(ic - 1, 4, k));
-      tr3 = VADD(cc_ref(i - 1, 5, k), cc_ref(ic - 1, 4, k));
-      ch_ref(i - 1, k, 1) = VADD(cc_ref(i - 1, 1, k), VADD(tr2, tr3));
-      ch_ref(i, k, 1) = VADD(cc_ref(i, 1, k), VADD(ti2, ti3));
-      cr2 = VADD(cc_ref(i - 1, 1, k), VADD(SVMUL(tr11, tr2), SVMUL(tr12, tr3)));
-      ci2 = VADD(cc_ref(i, 1, k), VADD(SVMUL(tr11, ti2), SVMUL(tr12, ti3)));
-      cr3 = VADD(cc_ref(i - 1, 1, k), VADD(SVMUL(tr12, tr2), SVMUL(tr11, tr3)));
-      ci3 = VADD(cc_ref(i, 1, k), VADD(SVMUL(tr12, ti2), SVMUL(tr11, ti3)));
-      cr5 = VADD(SVMUL(ti11, tr5), SVMUL(ti12, tr4));
-      ci5 = VADD(SVMUL(ti11, ti5), SVMUL(ti12, ti4));
-      cr4 = VSUB(SVMUL(ti12, tr5), SVMUL(ti11, tr4));
-      ci4 = VSUB(SVMUL(ti12, ti5), SVMUL(ti11, ti4));
-      dr3 = VSUB(cr3, ci4);
-      dr4 = VADD(cr3, ci4);
-      di3 = VADD(ci3, cr4);
-      di4 = VSUB(ci3, cr4);
-      dr5 = VADD(cr2, ci5);
-      dr2 = VSUB(cr2, ci5);
-      di5 = VSUB(ci2, cr5);
-      di2 = VADD(ci2, cr5);
-      VCPLXMUL(dr2, di2, LD_PS1(wa1[i - 3]), LD_PS1(wa1[i - 2]));
-      VCPLXMUL(dr3, di3, LD_PS1(wa2[i - 3]), LD_PS1(wa2[i - 2]));
-      VCPLXMUL(dr4, di4, LD_PS1(wa3[i - 3]), LD_PS1(wa3[i - 2]));
-      VCPLXMUL(dr5, di5, LD_PS1(wa4[i - 3]), LD_PS1(wa4[i - 2]));
-
-      ch_ref(i - 1, k, 2) = dr2;
-      ch_ref(i, k, 2) = di2;
-      ch_ref(i - 1, k, 3) = dr3;
-      ch_ref(i, k, 3) = di3;
-      ch_ref(i - 1, k, 4) = dr4;
-      ch_ref(i, k, 4) = di4;
-      ch_ref(i - 1, k, 5) = dr5;
-      ch_ref(i, k, 5) = di5;
-    }
-  }
-#undef cc_ref
-#undef ch_ref
-} /* radb5 */
-
-static NEVER_INLINE(v4sf *)
-    rfftf1_ps(int n, const v4sf *input_readonly, v4sf *work1, v4sf *work2,
-              const float *wa, const int *ifac) {
-  v4sf *in = (v4sf *)input_readonly;
-  v4sf *out = (in == work2 ? work1 : work2);
-  int nf = ifac[1], k1;
-  int l2 = n;
-  int iw = n - 1;
-  assert(in != out && work1 != work2);
-  for (k1 = 1; k1 <= nf; ++k1) {
-    int kh = nf - k1;
-    int ip = ifac[kh + 2];
-    int l1 = l2 / ip;
-    int ido = n / l2;
-    iw -= (ip - 1) * ido;
-    switch (ip) {
-    case 5: {
-      int ix2 = iw + ido;
-      int ix3 = ix2 + ido;
-      int ix4 = ix3 + ido;
-      radf5_ps(ido, l1, in, out, &wa[iw], &wa[ix2], &wa[ix3], &wa[ix4]);
-    } break;
-    case 4: {
-      int ix2 = iw + ido;
-      int ix3 = ix2 + ido;
-      radf4_ps(ido, l1, in, out, &wa[iw], &wa[ix2], &wa[ix3]);
-    } break;
-    case 3: {
-      int ix2 = iw + ido;
-      radf3_ps(ido, l1, in, out, &wa[iw], &wa[ix2]);
-    } break;
-    case 2:
-      radf2_ps(ido, l1, in, out, &wa[iw]);
-      break;
-    default:
-      assert(0);
-      break;
-    }
-    l2 = l1;
-    if (out == work2) {
-      out = work1;
-      in = work2;
-    } else {
-      out = work2;
-      in = work1;
-    }
-  }
-  return in; /* this is in fact the output .. */
-} /* rfftf1 */
-
-static NEVER_INLINE(v4sf *)
-    rfftb1_ps(int n, const v4sf *input_readonly, v4sf *work1, v4sf *work2,
-              const float *wa, const int *ifac) {
-  v4sf *in = (v4sf *)input_readonly;
-  v4sf *out = (in == work2 ? work1 : work2);
-  int nf = ifac[1], k1;
-  int l1 = 1;
-  int iw = 0;
-  assert(in != out);
-  for (k1 = 1; k1 <= nf; k1++) {
-    int ip = ifac[k1 + 1];
-    int l2 = ip * l1;
-    int ido = n / l2;
-    switch (ip) {
-    case 5: {
-      int ix2 = iw + ido;
-      int ix3 = ix2 + ido;
-      int ix4 = ix3 + ido;
-      radb5_ps(ido, l1, in, out, &wa[iw], &wa[ix2], &wa[ix3], &wa[ix4]);
-    } break;
-    case 4: {
-      int ix2 = iw + ido;
-      int ix3 = ix2 + ido;
-      radb4_ps(ido, l1, in, out, &wa[iw], &wa[ix2], &wa[ix3]);
-    } break;
-    case 3: {
-      int ix2 = iw + ido;
-      radb3_ps(ido, l1, in, out, &wa[iw], &wa[ix2]);
-    } break;
-    case 2:
-      radb2_ps(ido, l1, in, out, &wa[iw]);
-      break;
-    default:
-      assert(0);
-      break;
-    }
-    l1 = l2;
-    iw += (ip - 1) * ido;
-
-    if (out == work2) {
-      out = work1;
-      in = work2;
-    } else {
-      out = work2;
-      in = work1;
-    }
-  }
-  return in; /* this is in fact the output .. */
-}
-
-#define IFAC_MAX_SIZE                                                          \
-  25 /* max number of integer factors for the decomposition, +2 */
-static int decompose(int n, int *ifac, const int *ntryh) {
-  int nl = n, nf = 0, i, j = 0;
-  for (j = 0; ntryh[j]; ++j) {
-    int ntry = ntryh[j];
-    while (nl != 1) {
-      int nq = nl / ntry;
-      int nr = nl - ntry * nq;
-      if (nr == 0) {
-        assert(2 + nf < IFAC_MAX_SIZE);
-        ifac[2 + nf++] = ntry;
-        nl = nq;
-        if (ntry == 2 && nf != 1) {
-          for (i = 2; i <= nf; ++i) {
-            int ib = nf - i + 2;
-            ifac[ib + 1] = ifac[ib];
-          }
-          ifac[2] = 2;
-        }
-      } else
-        break;
-    }
-  }
-  ifac[0] = n;
-  ifac[1] = nf;
-  return nf;
-}
-
-static void rffti1_ps(int n, float *wa, int *ifac) {
-  static const int ntryh[] = {4, 2, 3, 5, 0};
-  int k1, j, ii;
-
-  int nf = decompose(n, ifac, ntryh);
-  float argh = (2 * M_PI) / n;
-  int is = 0;
-  int nfm1 = nf - 1;
-  int l1 = 1;
-  for (k1 = 1; k1 <= nfm1; k1++) {
-    int ip = ifac[k1 + 1];
-    int ld = 0;
-    int l2 = l1 * ip;
-    int ido = n / l2;
-    int ipm = ip - 1;
-    for (j = 1; j <= ipm; ++j) {
-      float argld;
-      int i = is, fi = 0;
-      ld += l1;
-      argld = ld * argh;
-      for (ii = 3; ii <= ido; ii += 2) {
-        i += 2;
-        fi += 1;
-        wa[i - 2] = cos(fi * argld);
-        wa[i - 1] = sin(fi * argld);
-      }
-      is += ido;
-    }
-    l1 = l2;
-  }
-} /* rffti1 */
-
-void cffti1_ps(int n, float *wa, int *ifac) {
-  static const int ntryh[] = {5, 3, 4, 2, 0};
-  int k1, j, ii;
-
-  int nf = decompose(n, ifac, ntryh);
-  float argh = (2 * M_PI) / (float)n;
-  int i = 1;
-  int l1 = 1;
-  for (k1 = 1; k1 <= nf; k1++) {
-    int ip = ifac[k1 + 1];
-    int ld = 0;
-    int l2 = l1 * ip;
-    int ido = n / l2;
-    int idot = ido + ido + 2;
-    int ipm = ip - 1;
-    for (j = 1; j <= ipm; j++) {
-      float argld;
-      int i1 = i, fi = 0;
-      wa[i - 1] = 1;
-      wa[i] = 0;
-      ld += l1;
-      argld = ld * argh;
-      for (ii = 4; ii <= idot; ii += 2) {
-        i += 2;
-        fi += 1;
-        wa[i - 1] = cos(fi * argld);
-        wa[i] = sin(fi * argld);
-      }
-      if (ip > 5) {
-        wa[i1 - 1] = wa[i - 1];
-        wa[i1] = wa[i];
-      }
-    }
-    l1 = l2;
-  }
-} /* cffti1 */
-
-v4sf *cfftf1_ps(int n, const v4sf *input_readonly, v4sf *work1, v4sf *work2,
-                const float *wa, const int *ifac, int isign) {
-  v4sf *in = (v4sf *)input_readonly;
-  v4sf *out = (in == work2 ? work1 : work2);
-  int nf = ifac[1], k1;
-  int l1 = 1;
-  int iw = 0;
-  assert(in != out && work1 != work2);
-  for (k1 = 2; k1 <= nf + 1; k1++) {
-    int ip = ifac[k1];
-    int l2 = ip * l1;
-    int ido = n / l2;
-    int idot = ido + ido;
-    switch (ip) {
-    case 5: {
-      int ix2 = iw + idot;
-      int ix3 = ix2 + idot;
-      int ix4 = ix3 + idot;
-      passf5_ps(idot, l1, in, out, &wa[iw], &wa[ix2], &wa[ix3], &wa[ix4],
-                isign);
-    } break;
-    case 4: {
-      int ix2 = iw + idot;
-      int ix3 = ix2 + idot;
-      passf4_ps(idot, l1, in, out, &wa[iw], &wa[ix2], &wa[ix3], isign);
-    } break;
-    case 2: {
-      passf2_ps(idot, l1, in, out, &wa[iw], isign);
-    } break;
-    case 3: {
-      int ix2 = iw + idot;
-      passf3_ps(idot, l1, in, out, &wa[iw], &wa[ix2], isign);
-    } break;
-    default:
-      assert(0);
-    }
-    l1 = l2;
-    iw += (ip - 1) * idot;
-    if (out == work2) {
-      out = work1;
-      in = work2;
-    } else {
-      out = work2;
-      in = work1;
-    }
-  }
-
-  return in; /* this is in fact the output .. */
-}
-
-struct PFFFT_Setup {
-  int N;
-  int Ncvec; // nb of complex simd vectors (N/4 if PFFFT_COMPLEX, N/8 if
-             // PFFFT_REAL)
-  // hold the decomposition into small integers of N
-  int ifac[IFAC_MAX_SIZE]; // N , number of factors, factors (admitted values:
-                           // 2, 3, 4 ou 5)
-  pffft_transform_t transform;
-  v4sf *data;     // allocated room for twiddle coefs
-  float *e;       // points into 'data' , N/4*3 elements
-  float *twiddle; // points into 'data', N/4 elements
-};
-
-PFFFT_Setup *pffft_new_setup(int N, pffft_transform_t transform) {
-  // validate N for negative values or potential int overflow
-  if (N < 0) {
-    return 0;
-  }
-  if (N > (1 << 26)) {
-    // higher values of N will make you enter in the integer overflow world...
-    assert(0);
-    return 0;
-  }
-  PFFFT_Setup *s = (PFFFT_Setup *)malloc(sizeof(PFFFT_Setup));
-  int k, m;
-  /* unfortunately, the fft size must be a multiple of 16 for complex FFTs
-     and 32 for real FFTs -- a lot of stuff would need to be rewritten to
-     handle other cases (or maybe just switch to a scalar fft, I don't know..)
-   */
-  if (transform == PFFFT_REAL) {
-    assert((N % (2 * SIMD_SZ * SIMD_SZ)) == 0 && N > 0);
-  }
-  if (transform == PFFFT_COMPLEX) {
-    assert((N % (SIMD_SZ * SIMD_SZ)) == 0 && N > 0);
-  }
-  // assert((N % 32) == 0);
-  s->N = N;
-  s->transform = transform;
-  /* nb of complex simd vectors */
-  s->Ncvec = (transform == PFFFT_REAL ? N / 2 : N) / SIMD_SZ;
-  s->data = (v4sf *)pffft_aligned_malloc(2 * s->Ncvec * sizeof(v4sf));
-  s->e = (float *)s->data;
-  s->twiddle = (float *)(s->data + (2 * s->Ncvec * (SIMD_SZ - 1)) / SIMD_SZ);
-
-  for (k = 0; k < s->Ncvec; ++k) {
-    int i = k / SIMD_SZ;
-    int j = k % SIMD_SZ;
-    for (m = 0; m < SIMD_SZ - 1; ++m) {
-      float A = -2 * M_PI * (m + 1) * k / N;
-      s->e[(2 * (i * 3 + m) + 0) * SIMD_SZ + j] = cos(A);
-      s->e[(2 * (i * 3 + m) + 1) * SIMD_SZ + j] = sin(A);
-    }
-  }
-
-  if (transform == PFFFT_REAL) {
-    rffti1_ps(N / SIMD_SZ, s->twiddle, s->ifac);
-  } else {
-    cffti1_ps(N / SIMD_SZ, s->twiddle, s->ifac);
-  }
-
-  /* check that N is decomposable with allowed prime factors */
-  for (k = 0, m = 1; k < s->ifac[1]; ++k) {
-    m *= s->ifac[2 + k];
-  }
-  if (m != N / SIMD_SZ) {
-    pffft_destroy_setup(s);
-    s = 0;
-  }
-
-  return s;
-}
-
-void pffft_destroy_setup(PFFFT_Setup *s) {
-  pffft_aligned_free(s->data);
-  free(s);
-}
-
-#if !defined(PFFFT_SIMD_DISABLE)
-
-/* [0 0 1 2 3 4 5 6 7 8] -> [0 8 7 6 5 4 3 2 1] */
-static void reversed_copy(int N, const v4sf *in, int in_stride, v4sf *out) {
-  v4sf g0, g1;
-  int k;
-  INTERLEAVE2(in[0], in[1], g0, g1);
-  in += in_stride;
-
-  *--out = VSWAPHL(g0, g1); // [g0l, g0h], [g1l g1h] -> [g1l, g0h]
-  for (k = 1; k < N; ++k) {
-    v4sf h0, h1;
-    INTERLEAVE2(in[0], in[1], h0, h1);
-    in += in_stride;
-    *--out = VSWAPHL(g1, h0);
-    *--out = VSWAPHL(h0, h1);
-    g1 = h1;
-  }
-  *--out = VSWAPHL(g1, g0);
-}
-
-static void unreversed_copy(int N, const v4sf *in, v4sf *out, int out_stride) {
-  v4sf g0, g1, h0, h1;
-  int k;
-  g0 = g1 = in[0];
-  ++in;
-  for (k = 1; k < N; ++k) {
-    h0 = *in++;
-    h1 = *in++;
-    g1 = VSWAPHL(g1, h0);
-    h0 = VSWAPHL(h0, h1);
-    UNINTERLEAVE2(h0, g1, out[0], out[1]);
-    out += out_stride;
-    g1 = h1;
-  }
-  h0 = *in++;
-  h1 = g0;
-  g1 = VSWAPHL(g1, h0);
-  h0 = VSWAPHL(h0, h1);
-  UNINTERLEAVE2(h0, g1, out[0], out[1]);
-}
-
-void pffft_zreorder(PFFFT_Setup *setup, const float *in, float *out,
-                    pffft_direction_t direction) {
-  int k, N = setup->N, Ncvec = setup->Ncvec;
-  const v4sf *vin = (const v4sf *)in;
-  v4sf *vout = (v4sf *)out;
-  assert(in != out);
-  if (setup->transform == PFFFT_REAL) {
-    int k, dk = N / 32;
-    if (direction == PFFFT_FORWARD) {
-      for (k = 0; k < dk; ++k) {
-        INTERLEAVE2(vin[k * 8 + 0], vin[k * 8 + 1], vout[2 * (0 * dk + k) + 0],
-                    vout[2 * (0 * dk + k) + 1]);
-        INTERLEAVE2(vin[k * 8 + 4], vin[k * 8 + 5], vout[2 * (2 * dk + k) + 0],
-                    vout[2 * (2 * dk + k) + 1]);
-      }
-      reversed_copy(dk, vin + 2, 8, (v4sf *)(out + N / 2));
-      reversed_copy(dk, vin + 6, 8, (v4sf *)(out + N));
-    } else {
-      for (k = 0; k < dk; ++k) {
-        UNINTERLEAVE2(vin[2 * (0 * dk + k) + 0], vin[2 * (0 * dk + k) + 1],
-                      vout[k * 8 + 0], vout[k * 8 + 1]);
-        UNINTERLEAVE2(vin[2 * (2 * dk + k) + 0], vin[2 * (2 * dk + k) + 1],
-                      vout[k * 8 + 4], vout[k * 8 + 5]);
-      }
-      unreversed_copy(dk, (v4sf *)(in + N / 4), (v4sf *)(out + N - 6 * SIMD_SZ),
-                      -8);
-      unreversed_copy(dk, (v4sf *)(in + 3 * N / 4),
-                      (v4sf *)(out + N - 2 * SIMD_SZ), -8);
-    }
-  } else {
-    if (direction == PFFFT_FORWARD) {
-      for (k = 0; k < Ncvec; ++k) {
-        int kk = (k / 4) + (k % 4) * (Ncvec / 4);
-        INTERLEAVE2(vin[k * 2], vin[k * 2 + 1], vout[kk * 2], vout[kk * 2 + 1]);
-      }
-    } else {
-      for (k = 0; k < Ncvec; ++k) {
-        int kk = (k / 4) + (k % 4) * (Ncvec / 4);
-        UNINTERLEAVE2(vin[kk * 2], vin[kk * 2 + 1], vout[k * 2],
-                      vout[k * 2 + 1]);
-      }
-    }
-  }
-}
-
-void pffft_cplx_finalize(int Ncvec, const v4sf *in, v4sf *out, const v4sf *e) {
-  int k, dk = Ncvec / SIMD_SZ; // number of 4x4 matrix blocks
-  v4sf r0, i0, r1, i1, r2, i2, r3, i3;
-  v4sf sr0, dr0, sr1, dr1, si0, di0, si1, di1;
-  assert(in != out);
-  for (k = 0; k < dk; ++k) {
-    r0 = in[8 * k + 0];
-    i0 = in[8 * k + 1];
-    r1 = in[8 * k + 2];
-    i1 = in[8 * k + 3];
-    r2 = in[8 * k + 4];
-    i2 = in[8 * k + 5];
-    r3 = in[8 * k + 6];
-    i3 = in[8 * k + 7];
-    VTRANSPOSE4(r0, r1, r2, r3);
-    VTRANSPOSE4(i0, i1, i2, i3);
-    VCPLXMUL(r1, i1, e[k * 6 + 0], e[k * 6 + 1]);
-    VCPLXMUL(r2, i2, e[k * 6 + 2], e[k * 6 + 3]);
-    VCPLXMUL(r3, i3, e[k * 6 + 4], e[k * 6 + 5]);
-
-    sr0 = VADD(r0, r2);
-    dr0 = VSUB(r0, r2);
-    sr1 = VADD(r1, r3);
-    dr1 = VSUB(r1, r3);
-    si0 = VADD(i0, i2);
-    di0 = VSUB(i0, i2);
-    si1 = VADD(i1, i3);
-    di1 = VSUB(i1, i3);
-
-    /*
-      transformation for each column is:
-
-      [1   1   1   1   0   0   0   0]   [r0]
-      [1   0  -1   0   0  -1   0   1]   [r1]
-      [1  -1   1  -1   0   0   0   0]   [r2]
-      [1   0  -1   0   0   1   0  -1]   [r3]
-      [0   0   0   0   1   1   1   1] * [i0]
-      [0   1   0  -1   1   0  -1   0]   [i1]
-      [0   0   0   0   1  -1   1  -1]   [i2]
-      [0  -1   0   1   1   0  -1   0]   [i3]
-    */
-
-    r0 = VADD(sr0, sr1);
-    i0 = VADD(si0, si1);
-    r1 = VADD(dr0, di1);
-    i1 = VSUB(di0, dr1);
-    r2 = VSUB(sr0, sr1);
-    i2 = VSUB(si0, si1);
-    r3 = VSUB(dr0, di1);
-    i3 = VADD(di0, dr1);
-
-    *out++ = r0;
-    *out++ = i0;
-    *out++ = r1;
-    *out++ = i1;
-    *out++ = r2;
-    *out++ = i2;
-    *out++ = r3;
-    *out++ = i3;
-  }
-}
-
-void pffft_cplx_preprocess(int Ncvec, const v4sf *in, v4sf *out,
-                           const v4sf *e) {
-  int k, dk = Ncvec / SIMD_SZ; // number of 4x4 matrix blocks
-  v4sf r0, i0, r1, i1, r2, i2, r3, i3;
-  v4sf sr0, dr0, sr1, dr1, si0, di0, si1, di1;
-  assert(in != out);
-  for (k = 0; k < dk; ++k) {
-    r0 = in[8 * k + 0];
-    i0 = in[8 * k + 1];
-    r1 = in[8 * k + 2];
-    i1 = in[8 * k + 3];
-    r2 = in[8 * k + 4];
-    i2 = in[8 * k + 5];
-    r3 = in[8 * k + 6];
-    i3 = in[8 * k + 7];
-
-    sr0 = VADD(r0, r2);
-    dr0 = VSUB(r0, r2);
-    sr1 = VADD(r1, r3);
-    dr1 = VSUB(r1, r3);
-    si0 = VADD(i0, i2);
-    di0 = VSUB(i0, i2);
-    si1 = VADD(i1, i3);
-    di1 = VSUB(i1, i3);
-
-    r0 = VADD(sr0, sr1);
-    i0 = VADD(si0, si1);
-    r1 = VSUB(dr0, di1);
-    i1 = VADD(di0, dr1);
-    r2 = VSUB(sr0, sr1);
-    i2 = VSUB(si0, si1);
-    r3 = VADD(dr0, di1);
-    i3 = VSUB(di0, dr1);
-
-    VCPLXMULCONJ(r1, i1, e[k * 6 + 0], e[k * 6 + 1]);
-    VCPLXMULCONJ(r2, i2, e[k * 6 + 2], e[k * 6 + 3]);
-    VCPLXMULCONJ(r3, i3, e[k * 6 + 4], e[k * 6 + 5]);
-
-    VTRANSPOSE4(r0, r1, r2, r3);
-    VTRANSPOSE4(i0, i1, i2, i3);
-
-    *out++ = r0;
-    *out++ = i0;
-    *out++ = r1;
-    *out++ = i1;
-    *out++ = r2;
-    *out++ = i2;
-    *out++ = r3;
-    *out++ = i3;
-  }
-}
-
-static ALWAYS_INLINE(void)
-    pffft_real_finalize_4x4(const v4sf *in0, const v4sf *in1, const v4sf *in,
-                            const v4sf *e, v4sf *out) {
-  v4sf r0, i0, r1, i1, r2, i2, r3, i3;
-  v4sf sr0, dr0, sr1, dr1, si0, di0, si1, di1;
-  r0 = *in0;
-  i0 = *in1;
-  r1 = *in++;
-  i1 = *in++;
-  r2 = *in++;
-  i2 = *in++;
-  r3 = *in++;
-  i3 = *in++;
-  VTRANSPOSE4(r0, r1, r2, r3);
-  VTRANSPOSE4(i0, i1, i2, i3);
-
-  /*
-    transformation for each column is:
-
-    [1   1   1   1   0   0   0   0]   [r0]
-    [1   0  -1   0   0  -1   0   1]   [r1]
-    [1   0  -1   0   0   1   0  -1]   [r2]
-    [1  -1   1  -1   0   0   0   0]   [r3]
-    [0   0   0   0   1   1   1   1] * [i0]
-    [0  -1   0   1  -1   0   1   0]   [i1]
-    [0  -1   0   1   1   0  -1   0]   [i2]
-    [0   0   0   0  -1   1  -1   1]   [i3]
-  */
-
-  // cerr << "matrix initial, before e , REAL:\n 1: " << r0 << "\n 1: " << r1 <<
-  // "\n 1: " << r2 << "\n 1: " << r3 << "\n"; cerr << "matrix initial, before
-  // e, IMAG :\n 1: " << i0 << "\n 1: " << i1 << "\n 1: " << i2 << "\n 1: " <<
-  // i3 << "\n";
-
-  VCPLXMUL(r1, i1, e[0], e[1]);
-  VCPLXMUL(r2, i2, e[2], e[3]);
-  VCPLXMUL(r3, i3, e[4], e[5]);
-
-  // cerr << "matrix initial, real part:\n 1: " << r0 << "\n 1: " << r1 << "\n
-  // 1: " << r2 << "\n 1: " << r3 << "\n"; cerr << "matrix initial, imag part:\n
-  // 1: " << i0 << "\n 1: " << i1 << "\n 1: " << i2 << "\n 1: " << i3 << "\n";
-
-  sr0 = VADD(r0, r2);
-  dr0 = VSUB(r0, r2);
-  sr1 = VADD(r1, r3);
-  dr1 = VSUB(r3, r1);
-  si0 = VADD(i0, i2);
-  di0 = VSUB(i0, i2);
-  si1 = VADD(i1, i3);
-  di1 = VSUB(i3, i1);
-
-  r0 = VADD(sr0, sr1);
-  r3 = VSUB(sr0, sr1);
-  i0 = VADD(si0, si1);
-  i3 = VSUB(si1, si0);
-  r1 = VADD(dr0, di1);
-  r2 = VSUB(dr0, di1);
-  i1 = VSUB(dr1, di0);
-  i2 = VADD(dr1, di0);
-
-  *out++ = r0;
-  *out++ = i0;
-  *out++ = r1;
-  *out++ = i1;
-  *out++ = r2;
-  *out++ = i2;
-  *out++ = r3;
-  *out++ = i3;
-}
-
-static NEVER_INLINE(void)
-    pffft_real_finalize(int Ncvec, const v4sf *in, v4sf *out, const v4sf *e) {
-  int k, dk = Ncvec / SIMD_SZ; // number of 4x4 matrix blocks
-  /* fftpack order is f0r f1r f1i f2r f2i ... f(n-1)r f(n-1)i f(n)r */
-
-  v4sf_union cr, ci, *uout = (v4sf_union *)out;
-  v4sf save = in[7], zero = VZERO();
-  float xr0, xi0, xr1, xi1, xr2, xi2, xr3, xi3;
-  static const float s = (float)(M_SQRT2 / 2);
-
-  cr.v = in[0];
-  ci.v = in[Ncvec * 2 - 1];
-  assert(in != out);
-  pffft_real_finalize_4x4(&zero, &zero, in + 1, e, out);
-
-  /*
-    [cr0 cr1 cr2 cr3 ci0 ci1 ci2 ci3]
-
-    [Xr(1)]  ] [1   1   1   1   0   0   0   0]
-    [Xr(N/4) ] [0   0   0   0   1   s   0  -s]
-    [Xr(N/2) ] [1   0  -1   0   0   0   0   0]
-    [Xr(3N/4)] [0   0   0   0   1  -s   0   s]
-    [Xi(1)   ] [1  -1   1  -1   0   0   0   0]
-    [Xi(N/4) ] [0   0   0   0   0  -s  -1  -s]
-    [Xi(N/2) ] [0  -1   0   1   0   0   0   0]
-    [Xi(3N/4)] [0   0   0   0   0  -s   1  -s]
-  */
-
-  xr0 = (cr.f[0] + cr.f[2]) + (cr.f[1] + cr.f[3]);
-  uout[0].f[0] = xr0;
-  xi0 = (cr.f[0] + cr.f[2]) - (cr.f[1] + cr.f[3]);
-  uout[1].f[0] = xi0;
-  xr2 = (cr.f[0] - cr.f[2]);
-  uout[4].f[0] = xr2;
-  xi2 = (cr.f[3] - cr.f[1]);
-  uout[5].f[0] = xi2;
-  xr1 = ci.f[0] + s * (ci.f[1] - ci.f[3]);
-  uout[2].f[0] = xr1;
-  xi1 = -ci.f[2] - s * (ci.f[1] + ci.f[3]);
-  uout[3].f[0] = xi1;
-  xr3 = ci.f[0] - s * (ci.f[1] - ci.f[3]);
-  uout[6].f[0] = xr3;
-  xi3 = ci.f[2] - s * (ci.f[1] + ci.f[3]);
-  uout[7].f[0] = xi3;
-
-  for (k = 1; k < dk; ++k) {
-    v4sf save_next = in[8 * k + 7];
-    pffft_real_finalize_4x4(&save, &in[8 * k + 0], in + 8 * k + 1, e + k * 6,
-                            out + k * 8);
-    save = save_next;
-  }
-}
-
-static ALWAYS_INLINE(void)
-    pffft_real_preprocess_4x4(const v4sf *in, const v4sf *e, v4sf *out,
-                              int first) {
-  v4sf r0 = in[0], i0 = in[1], r1 = in[2], i1 = in[3], r2 = in[4], i2 = in[5],
-       r3 = in[6], i3 = in[7];
-  /*
-    transformation for each column is:
-
-    [1   1   1   1   0   0   0   0]   [r0]
-    [1   0   0  -1   0  -1  -1   0]   [r1]
-    [1  -1  -1   1   0   0   0   0]   [r2]
-    [1   0   0  -1   0   1   1   0]   [r3]
-    [0   0   0   0   1  -1   1  -1] * [i0]
-    [0  -1   1   0   1   0   0   1]   [i1]
-    [0   0   0   0   1   1  -1  -1]   [i2]
-    [0   1  -1   0   1   0   0   1]   [i3]
-  */
-
-  v4sf sr0 = VADD(r0, r3), dr0 = VSUB(r0, r3);
-  v4sf sr1 = VADD(r1, r2), dr1 = VSUB(r1, r2);
-  v4sf si0 = VADD(i0, i3), di0 = VSUB(i0, i3);
-  v4sf si1 = VADD(i1, i2), di1 = VSUB(i1, i2);
-
-  r0 = VADD(sr0, sr1);
-  r2 = VSUB(sr0, sr1);
-  r1 = VSUB(dr0, si1);
-  r3 = VADD(dr0, si1);
-  i0 = VSUB(di0, di1);
-  i2 = VADD(di0, di1);
-  i1 = VSUB(si0, dr1);
-  i3 = VADD(si0, dr1);
-
-  VCPLXMULCONJ(r1, i1, e[0], e[1]);
-  VCPLXMULCONJ(r2, i2, e[2], e[3]);
-  VCPLXMULCONJ(r3, i3, e[4], e[5]);
-
-  VTRANSPOSE4(r0, r1, r2, r3);
-  VTRANSPOSE4(i0, i1, i2, i3);
-
-  if (!first) {
-    *out++ = r0;
-    *out++ = i0;
-  }
-  *out++ = r1;
-  *out++ = i1;
-  *out++ = r2;
-  *out++ = i2;
-  *out++ = r3;
-  *out++ = i3;
-}
-
-static NEVER_INLINE(void)
-    pffft_real_preprocess(int Ncvec, const v4sf *in, v4sf *out, const v4sf *e) {
-  int k, dk = Ncvec / SIMD_SZ; // number of 4x4 matrix blocks
-  /* fftpack order is f0r f1r f1i f2r f2i ... f(n-1)r f(n-1)i f(n)r */
-
-  v4sf_union Xr, Xi, *uout = (v4sf_union *)out;
-  float cr0, ci0, cr1, ci1, cr2, ci2, cr3, ci3;
-  static const float s = (float)M_SQRT2;
-  assert(in != out);
-  for (k = 0; k < 4; ++k) {
-    Xr.f[k] = ((float *)in)[8 * k];
-    Xi.f[k] = ((float *)in)[8 * k + 4];
-  }
-
-  pffft_real_preprocess_4x4(in, e, out + 1, 1); // will write only 6 values
-
-  /*
-    [Xr0 Xr1 Xr2 Xr3 Xi0 Xi1 Xi2 Xi3]
-
-    [cr0] [1   0   2   0   1   0   0   0]
-    [cr1] [1   0   0   0  -1   0  -2   0]
-    [cr2] [1   0  -2   0   1   0   0   0]
-    [cr3] [1   0   0   0  -1   0   2   0]
-    [ci0] [0   2   0   2   0   0   0   0]
-    [ci1] [0   s   0  -s   0  -s   0  -s]
-    [ci2] [0   0   0   0   0  -2   0   2]
-    [ci3] [0  -s   0   s   0  -s   0  -s]
-  */
-  for (k = 1; k < dk; ++k) {
-    pffft_real_preprocess_4x4(in + 8 * k, e + k * 6, out - 1 + k * 8, 0);
-  }
-
-  cr0 = (Xr.f[0] + Xi.f[0]) + 2 * Xr.f[2];
-  uout[0].f[0] = cr0;
-  cr1 = (Xr.f[0] - Xi.f[0]) - 2 * Xi.f[2];
-  uout[0].f[1] = cr1;
-  cr2 = (Xr.f[0] + Xi.f[0]) - 2 * Xr.f[2];
-  uout[0].f[2] = cr2;
-  cr3 = (Xr.f[0] - Xi.f[0]) + 2 * Xi.f[2];
-  uout[0].f[3] = cr3;
-  ci0 = 2 * (Xr.f[1] + Xr.f[3]);
-  uout[2 * Ncvec - 1].f[0] = ci0;
-  ci1 = s * (Xr.f[1] - Xr.f[3]) - s * (Xi.f[1] + Xi.f[3]);
-  uout[2 * Ncvec - 1].f[1] = ci1;
-  ci2 = 2 * (Xi.f[3] - Xi.f[1]);
-  uout[2 * Ncvec - 1].f[2] = ci2;
-  ci3 = -s * (Xr.f[1] - Xr.f[3]) - s * (Xi.f[1] + Xi.f[3]);
-  uout[2 * Ncvec - 1].f[3] = ci3;
-}
-
-void pffft_transform_internal(PFFFT_Setup *setup, const float *finput,
-                              float *foutput, v4sf *scratch,
-                              pffft_direction_t direction, int ordered) {
-  int k, Ncvec = setup->Ncvec;
-  int nf_odd = (setup->ifac[1] & 1);
-
-  // temporary buffer is allocated on the stack if the scratch pointer is NULL
-  int stack_allocate = (scratch == 0 ? Ncvec * 2 : 1);
-  VLA_ARRAY_ON_STACK(v4sf, scratch_on_stack, stack_allocate);
-
-  const v4sf *vinput = (const v4sf *)finput;
-  v4sf *voutput = (v4sf *)foutput;
-  v4sf *buff[2] = {voutput, scratch ? scratch : scratch_on_stack};
-  int ib = (nf_odd ^ ordered ? 1 : 0);
-
-  assert(VALIGNED(finput) && VALIGNED(foutput));
-
-  // assert(finput != foutput);
-  if (direction == PFFFT_FORWARD) {
-    ib = !ib;
-    if (setup->transform == PFFFT_REAL) {
-      ib = (rfftf1_ps(Ncvec * 2, vinput, buff[ib], buff[!ib], setup->twiddle,
-                      &setup->ifac[0]) == buff[0]
-                ? 0
-                : 1);
-      pffft_real_finalize(Ncvec, buff[ib], buff[!ib], (v4sf *)setup->e);
-    } else {
-      v4sf *tmp = buff[ib];
-      for (k = 0; k < Ncvec; ++k) {
-        UNINTERLEAVE2(vinput[k * 2], vinput[k * 2 + 1], tmp[k * 2],
-                      tmp[k * 2 + 1]);
-      }
-      ib = (cfftf1_ps(Ncvec, buff[ib], buff[!ib], buff[ib], setup->twiddle,
-                      &setup->ifac[0], -1) == buff[0]
-                ? 0
-                : 1);
-      pffft_cplx_finalize(Ncvec, buff[ib], buff[!ib], (v4sf *)setup->e);
-    }
-    if (ordered) {
-      pffft_zreorder(setup, (float *)buff[!ib], (float *)buff[ib],
-                     PFFFT_FORWARD);
-    } else
-      ib = !ib;
-  } else {
-    if (vinput == buff[ib]) {
-      ib = !ib; // may happen when finput == foutput
-    }
-    if (ordered) {
-      pffft_zreorder(setup, (float *)vinput, (float *)buff[ib], PFFFT_BACKWARD);
-      vinput = buff[ib];
-      ib = !ib;
-    }
-    if (setup->transform == PFFFT_REAL) {
-      pffft_real_preprocess(Ncvec, vinput, buff[ib], (v4sf *)setup->e);
-      ib = (rfftb1_ps(Ncvec * 2, buff[ib], buff[0], buff[1], setup->twiddle,
-                      &setup->ifac[0]) == buff[0]
-                ? 0
-                : 1);
-    } else {
-      pffft_cplx_preprocess(Ncvec, vinput, buff[ib], (v4sf *)setup->e);
-      ib = (cfftf1_ps(Ncvec, buff[ib], buff[0], buff[1], setup->twiddle,
-                      &setup->ifac[0], +1) == buff[0]
-                ? 0
-                : 1);
-      for (k = 0; k < Ncvec; ++k) {
-        INTERLEAVE2(buff[ib][k * 2], buff[ib][k * 2 + 1], buff[ib][k * 2],
-                    buff[ib][k * 2 + 1]);
-      }
-    }
-  }
-
-  if (buff[ib] != voutput) {
-    /* extra copy required -- this situation should only happen when finput ==
-     * foutput */
-    assert(finput == foutput);
-    for (k = 0; k < Ncvec; ++k) {
-      v4sf a = buff[ib][2 * k], b = buff[ib][2 * k + 1];
-      voutput[2 * k] = a;
-      voutput[2 * k + 1] = b;
-    }
-    ib = !ib;
-  }
-  assert(buff[ib] == voutput);
-}
-
-void pffft_zconvolve_accumulate(PFFFT_Setup *s, const float *a, const float *b,
-                                float *ab, float scaling) {
-  int Ncvec = s->Ncvec;
-  const v4sf *RESTRICT va = (const v4sf *)a;
-  const v4sf *RESTRICT vb = (const v4sf *)b;
-  v4sf *RESTRICT vab = (v4sf *)ab;
-
-#ifdef __arm__
-  __builtin_prefetch(va);
-  __builtin_prefetch(vb);
-  __builtin_prefetch(vab);
-  __builtin_prefetch(va + 2);
-  __builtin_prefetch(vb + 2);
-  __builtin_prefetch(vab + 2);
-  __builtin_prefetch(va + 4);
-  __builtin_prefetch(vb + 4);
-  __builtin_prefetch(vab + 4);
-  __builtin_prefetch(va + 6);
-  __builtin_prefetch(vb + 6);
-  __builtin_prefetch(vab + 6);
-#ifndef __clang__
-#define ZCONVOLVE_USING_INLINE_NEON_ASM
-#endif
-#endif
-
-  float ar0, ai0, br0, bi0, abr0, abi0;
-#ifndef ZCONVOLVE_USING_INLINE_ASM
-  v4sf vscal = LD_PS1(scaling);
-  int i;
-#endif
-
-  assert(VALIGNED(a) && VALIGNED(b) && VALIGNED(ab));
-  ar0 = ((v4sf_union *)va)[0].f[0];
-  ai0 = ((v4sf_union *)va)[1].f[0];
-  br0 = ((v4sf_union *)vb)[0].f[0];
-  bi0 = ((v4sf_union *)vb)[1].f[0];
-  abr0 = ((v4sf_union *)vab)[0].f[0];
-  abi0 = ((v4sf_union *)vab)[1].f[0];
-
-#ifdef ZCONVOLVE_USING_INLINE_ASM // inline asm version, unfortunately
-                                  // miscompiled by clang 3.2, at least on
-                                  // ubuntu.. so this will be restricted to gcc
-  const float *a_ = a, *b_ = b;
-  float *ab_ = ab;
-  int N = Ncvec;
-  asm volatile("mov         r8, %2                  \n"
-               "vdup.f32    q15, %4                 \n"
-               "1:                                  \n"
-               "pld         [%0,#64]                \n"
-               "pld         [%1,#64]                \n"
-               "pld         [%2,#64]                \n"
-               "pld         [%0,#96]                \n"
-               "pld         [%1,#96]                \n"
-               "pld         [%2,#96]                \n"
-               "vld1.f32    {q0,q1},   [%0,:128]!         \n"
-               "vld1.f32    {q4,q5},   [%1,:128]!         \n"
-               "vld1.f32    {q2,q3},   [%0,:128]!         \n"
-               "vld1.f32    {q6,q7},   [%1,:128]!         \n"
-               "vld1.f32    {q8,q9},   [r8,:128]!          \n"
-
-               "vmul.f32    q10, q0, q4             \n"
-               "vmul.f32    q11, q0, q5             \n"
-               "vmul.f32    q12, q2, q6             \n"
-               "vmul.f32    q13, q2, q7             \n"
-               "vmls.f32    q10, q1, q5             \n"
-               "vmla.f32    q11, q1, q4             \n"
-               "vld1.f32    {q0,q1}, [r8,:128]!     \n"
-               "vmls.f32    q12, q3, q7             \n"
-               "vmla.f32    q13, q3, q6             \n"
-               "vmla.f32    q8, q10, q15            \n"
-               "vmla.f32    q9, q11, q15            \n"
-               "vmla.f32    q0, q12, q15            \n"
-               "vmla.f32    q1, q13, q15            \n"
-               "vst1.f32    {q8,q9},[%2,:128]!    \n"
-               "vst1.f32    {q0,q1},[%2,:128]!    \n"
-               "subs        %3, #2                  \n"
-               "bne         1b                      \n"
-               : "+r"(a_), "+r"(b_), "+r"(ab_), "+r"(N)
-               : "r"(scaling)
-               : "r8", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7", "q8",
-                 "q9", "q10", "q11", "q12", "q13", "q15", "memory");
-#else // default routine, works fine for non-arm cpus with current compilers
-  for (i = 0; i < Ncvec; i += 2) {
-    v4sf ar, ai, br, bi;
-    ar = va[2 * i + 0];
-    ai = va[2 * i + 1];
-    br = vb[2 * i + 0];
-    bi = vb[2 * i + 1];
-    VCPLXMUL(ar, ai, br, bi);
-    vab[2 * i + 0] = VMADD(ar, vscal, vab[2 * i + 0]);
-    vab[2 * i + 1] = VMADD(ai, vscal, vab[2 * i + 1]);
-    ar = va[2 * i + 2];
-    ai = va[2 * i + 3];
-    br = vb[2 * i + 2];
-    bi = vb[2 * i + 3];
-    VCPLXMUL(ar, ai, br, bi);
-    vab[2 * i + 2] = VMADD(ar, vscal, vab[2 * i + 2]);
-    vab[2 * i + 3] = VMADD(ai, vscal, vab[2 * i + 3]);
-  }
-#endif
-  if (s->transform == PFFFT_REAL) {
-    ((v4sf_union *)vab)[0].f[0] = abr0 + ar0 * br0 * scaling;
-    ((v4sf_union *)vab)[1].f[0] = abi0 + ai0 * bi0 * scaling;
-  }
-}
-
-#else // defined(PFFFT_SIMD_DISABLE)
-
-// standard routine using scalar floats, without SIMD stuff.
-
-#define pffft_zreorder_nosimd pffft_zreorder
-void pffft_zreorder_nosimd(PFFFT_Setup *setup, const float *in, float *out,
-                           pffft_direction_t direction) {
-  int k, N = setup->N;
-  if (setup->transform == PFFFT_COMPLEX) {
-    for (k = 0; k < 2 * N; ++k)
-      out[k] = in[k];
-    return;
-  } else if (direction == PFFFT_FORWARD) {
-    float x_N = in[N - 1];
-    for (k = N - 1; k > 1; --k)
-      out[k] = in[k - 1];
-    out[0] = in[0];
-    out[1] = x_N;
-  } else {
-    float x_N = in[1];
-    for (k = 1; k < N - 1; ++k)
-      out[k] = in[k + 1];
-    out[0] = in[0];
-    out[N - 1] = x_N;
-  }
-}
-
-#define pffft_transform_internal_nosimd pffft_transform_internal
-void pffft_transform_internal_nosimd(PFFFT_Setup *setup, const float *input,
-                                     float *output, float *scratch,
-                                     pffft_direction_t direction, int ordered) {
-  int Ncvec = setup->Ncvec;
-  int nf_odd = (setup->ifac[1] & 1);
-
-  // temporary buffer is allocated on the stack if the scratch pointer is NULL
-  int stack_allocate = (scratch == 0 ? Ncvec * 2 : 1);
-  VLA_ARRAY_ON_STACK(v4sf, scratch_on_stack, stack_allocate);
-  float *buff[2];
-  int ib;
-  if (scratch == 0)
-    scratch = scratch_on_stack;
-  buff[0] = output;
-  buff[1] = scratch;
-
-  if (setup->transform == PFFFT_COMPLEX)
-    ordered = 0; // it is always ordered.
-  ib = (nf_odd ^ ordered ? 1 : 0);
-
-  if (direction == PFFFT_FORWARD) {
-    if (setup->transform == PFFFT_REAL) {
-      ib = (rfftf1_ps(Ncvec * 2, input, buff[ib], buff[!ib], setup->twiddle,
-                      &setup->ifac[0]) == buff[0]
-                ? 0
-                : 1);
-    } else {
-      ib = (cfftf1_ps(Ncvec, input, buff[ib], buff[!ib], setup->twiddle,
-                      &setup->ifac[0], -1) == buff[0]
-                ? 0
-                : 1);
-    }
-    if (ordered) {
-      pffft_zreorder(setup, buff[ib], buff[!ib], PFFFT_FORWARD);
-      ib = !ib;
-    }
-  } else {
-    if (input == buff[ib]) {
-      ib = !ib; // may happen when finput == foutput
-    }
-    if (ordered) {
-      pffft_zreorder(setup, input, buff[!ib], PFFFT_BACKWARD);
-      input = buff[!ib];
-    }
-    if (setup->transform == PFFFT_REAL) {
-      ib = (rfftb1_ps(Ncvec * 2, input, buff[ib], buff[!ib], setup->twiddle,
-                      &setup->ifac[0]) == buff[0]
-                ? 0
-                : 1);
-    } else {
-      ib = (cfftf1_ps(Ncvec, input, buff[ib], buff[!ib], setup->twiddle,
-                      &setup->ifac[0], +1) == buff[0]
-                ? 0
-                : 1);
-    }
-  }
-  if (buff[ib] != output) {
-    int k;
-    // extra copy required -- this situation should happens only when finput ==
-    // foutput
-    assert(input == output);
-    for (k = 0; k < Ncvec; ++k) {
-      float a = buff[ib][2 * k], b = buff[ib][2 * k + 1];
-      output[2 * k] = a;
-      output[2 * k + 1] = b;
-    }
-    ib = !ib;
-  }
-  assert(buff[ib] == output);
-}
-
-#define pffft_zconvolve_accumulate_nosimd pffft_zconvolve_accumulate
-void pffft_zconvolve_accumulate_nosimd(PFFFT_Setup *s, const float *a,
-                                       const float *b, float *ab,
-                                       float scaling) {
-  int i, Ncvec = s->Ncvec;
-
-  if (s->transform == PFFFT_REAL) {
-    // take care of the fftpack ordering
-    ab[0] += a[0] * b[0] * scaling;
-    ab[2 * Ncvec - 1] += a[2 * Ncvec - 1] * b[2 * Ncvec - 1] * scaling;
-    ++ab;
-    ++a;
-    ++b;
-    --Ncvec;
-  }
-  for (i = 0; i < Ncvec; ++i) {
-    float ar, ai, br, bi;
-    ar = a[2 * i + 0];
-    ai = a[2 * i + 1];
-    br = b[2 * i + 0];
-    bi = b[2 * i + 1];
-    VCPLXMUL(ar, ai, br, bi);
-    ab[2 * i + 0] += ar * scaling;
-    ab[2 * i + 1] += ai * scaling;
-  }
-}
-
-#endif // defined(PFFFT_SIMD_DISABLE)
-
-void pffft_transform(PFFFT_Setup *setup, const float *input, float *output,
-                     float *work, pffft_direction_t direction) {
-  pffft_transform_internal(setup, input, output, (v4sf *)work, direction, 0);
-}
-
-void pffft_transform_ordered(PFFFT_Setup *setup, const float *input,
-                             float *output, float *work,
-                             pffft_direction_t direction) {
-  pffft_transform_internal(setup, input, output, (v4sf *)work, direction, 1);
-}
diff --git a/packages/react-native-executorch/common/pfft/pfft.h b/packages/react-native-executorch/common/pfft/pfft.h
deleted file mode 100644
index 392f65f589..0000000000
--- a/packages/react-native-executorch/common/pfft/pfft.h
+++ /dev/null
@@ -1,185 +0,0 @@
-/* Copyright (c) 2013  Julien Pommier ( pommier@modartt.com )
-
-   Based on original fortran 77 code from FFTPACKv4 from NETLIB,
-   authored by Dr Paul Swarztrauber of NCAR, in 1985.
-
-   As confirmed by the NCAR fftpack software curators, the following
-   FFTPACKv5 license applies to FFTPACKv4 sources. My changes are
-   released under the same terms.
-
-   FFTPACK license:
-
-   http://www.cisl.ucar.edu/css/software/fftpack5/ftpk.html
-
-   Copyright (c) 2004 the University Corporation for Atmospheric
-   Research ("UCAR"). All rights reserved. Developed by NCAR's
-   Computational and Information Systems Laboratory, UCAR,
-   www.cisl.ucar.edu.
-
-   Redistribution and use of the Software in source and binary forms,
-   with or without modification, is permitted provided that the
-   following conditions are met:
-
-   - Neither the names of NCAR's Computational and Information Systems
-   Laboratory, the University Corporation for Atmospheric Research,
-   nor the names of its sponsors or contributors may be used to
-   endorse or promote products derived from this Software without
-   specific prior written permission.
-
-   - Redistributions of source code must retain the above copyright
-   notices, this list of conditions, and the disclaimer below.
-
-   - Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions, and the disclaimer below in the
-   documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-   EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO THE WARRANTIES OF
-   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-   NONINFRINGEMENT. IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT
-   HOLDERS BE LIABLE FOR ANY CLAIM, INDIRECT, INCIDENTAL, SPECIAL,
-   EXEMPLARY, OR CONSEQUENTIAL DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-   SOFTWARE.
-*/
-
-/*
-  PFFFT : a Pretty Fast FFT.
-
-  This is basically an adaptation of the single precision fftpack
-  (v4) as found on netlib taking advantage of SIMD instruction found
-  on cpus such as intel x86 (SSE1), powerpc (Altivec), and arm (NEON).
-
-  For architectures where no SIMD instruction is available, the code
-  falls back to a scalar version.
-
-  Restrictions:
-
-  - 1D transforms only, with 32-bit single precision.
-
-  - supports only transforms for inputs of length N of the form
-  N=(2^a)*(3^b)*(5^c), a >= 5, b >=0, c >= 0 (32, 48, 64, 96, 128,
-  144, 160, etc are all acceptable lengths). Performance is best for
-  128<=N<=8192.
-
-  - all (float*) pointers in the functions below are expected to
-  have an "simd-compatible" alignment, that is 16 bytes on x86 and
-  powerpc CPUs.
-
-  You can allocate such buffers with the functions
-  pffft_aligned_malloc / pffft_aligned_free (or with stuff like
-  posix_memalign..)
-
-*/
-
-#pragma once
-
-#include <stddef.h> // for size_t
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
-   Opaque struct holding internal stuff (precomputed twiddle factors)
-   this struct can be shared by many threads as it contains only
-   read-only data.
-*/
-typedef struct PFFFT_Setup PFFFT_Setup;
-
-/** Direction of the transform */
-typedef enum { PFFFT_FORWARD, PFFFT_BACKWARD } pffft_direction_t;
-
-/** Type of transform */
-typedef enum { PFFFT_REAL, PFFFT_COMPLEX } pffft_transform_t;
-
-/**
-  Prepare for performing transforms of size N -- the returned
-  PFFFT_Setup structure is read-only so it can safely be shared by
-  multiple concurrent threads.
-
-  Will return NULL if N is not suitable (too large / no decomposable with simple
-  integer factors..)
-*/
-PFFFT_Setup *pffft_new_setup(int N, pffft_transform_t transform);
-void pffft_destroy_setup(PFFFT_Setup *);
-/**
-  Perform a Fourier transform , The z-domain data is stored in the
-  most efficient order for transforming it back, or using it for
-  convolution. If you need to have its content sorted in the
-  "usual" way, that is as an array of interleaved complex numbers,
-  either use pffft_transform_ordered , or call pffft_zreorder after
-  the forward fft, and before the backward fft.
-
-  Transforms are not scaled: PFFFT_BACKWARD(PFFFT_FORWARD(x)) = N*x.
-  Typically you will want to scale the backward transform by 1/N.
-
-  The 'work' pointer should point to an area of N (2*N for complex
-  fft) floats, properly aligned. If 'work' is NULL, then stack will
-  be used instead (this is probably the best strategy for small
-  FFTs, say for N < 16384).
-
-  input and output may alias.
-*/
-void pffft_transform(PFFFT_Setup *setup, const float *input, float *output,
-                     float *work, pffft_direction_t direction);
-
-/**
-  Similar to pffft_transform, but makes sure that the output is
-  ordered as expected (interleaved complex numbers).  This is
-  similar to calling pffft_transform and then pffft_zreorder.
-
-  input and output may alias.
-*/
-void pffft_transform_ordered(PFFFT_Setup *setup, const float *input,
-                             float *output, float *work,
-                             pffft_direction_t direction);
-
-/**
-  call pffft_zreorder(.., PFFFT_FORWARD) after pffft_transform(...,
-  PFFFT_FORWARD) if you want to have the frequency components in
-  the correct "canonical" order, as interleaved complex numbers.
-
-  (for real transforms, both 0-frequency and half frequency
-  components, which are real, are assembled in the first entry as
-  F(0)+i*F(n/2+1). Note that the original fftpack did place
-  F(n/2+1) at the end of the arrays).
-
-  input and output should not alias.
-*/
-void pffft_zreorder(PFFFT_Setup *setup, const float *input, float *output,
-                    pffft_direction_t direction);
-
-/**
-  Perform a multiplication of the frequency components of dft_a and
-  dft_b and accumulate them into dft_ab. The arrays should have
-  been obtained with pffft_transform(.., PFFFT_FORWARD) and should
-  *not* have been reordered with pffft_zreorder (otherwise just
-  perform the operation yourself as the dft coefs are stored as
-  interleaved complex numbers).
-
-  the operation performed is: dft_ab += (dft_a * fdt_b)*scaling
-
-  The dft_a, dft_b and dft_ab pointers may alias.
-*/
-void pffft_zconvolve_accumulate(PFFFT_Setup *setup, const float *dft_a,
-                                const float *dft_b, float *dft_ab,
-                                float scaling);
-
-/**
-  the float buffers must have the correct alignment (16-byte boundary
-  on intel and powerpc). This function may be used to obtain such
-  correctly aligned buffers.
-*/
-void *pffft_aligned_malloc(size_t nb_bytes);
-void pffft_aligned_free(void *);
-
-/** return 4 or 1 wether support SSE/Altivec instructions was enable when
- * building pffft.c */
-int pffft_simd_size(void);
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/packages/react-native-executorch/common/rnexecutorch/Error.h b/packages/react-native-executorch/common/rnexecutorch/Error.h
deleted file mode 100644
index edd69d4a07..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/Error.h
+++ /dev/null
@@ -1,75 +0,0 @@
-#pragma once
-
-#include <executorch/runtime/core/error.h>
-#include <source_location>
-#include <stdexcept>
-#include <string>
-#include <string_view>
-#include <variant>
-
-#include <rnexecutorch/ErrorCodes.h>
-
-namespace rnexecutorch {
-
-using ErrorVariant =
-    std::variant<RnExecutorchErrorCode, executorch::runtime::Error>;
-
-class RnExecutorchError : public std::runtime_error {
-public:
-  ErrorVariant errorCode;
-
-  RnExecutorchError(ErrorVariant code, const std::string &message)
-      : std::runtime_error(message), errorCode(code) {}
-
-  int32_t getNumericCode() const noexcept {
-    return std::visit(
-        [](auto &&arg) -> int32_t { return static_cast<int32_t>(arg); },
-        errorCode);
-  }
-
-  bool isRnExecutorchError() const noexcept {
-    return std::holds_alternative<RnExecutorchErrorCode>(errorCode);
-  }
-
-  bool isExecuTorchRuntimeError() const noexcept {
-    return std::holds_alternative<executorch::runtime::Error>(errorCode);
-  }
-};
-
-namespace detail {
-
-// npos + 1 wraps to 0, so the no-slash case returns the whole path.
-constexpr std::string_view basename(std::string_view path) noexcept {
-  return path.substr(path.find_last_of('/') + 1);
-}
-
-inline std::string locationPrefix(const std::source_location &loc) {
-  return "[" + std::string(basename(loc.file_name())) + "] ";
-}
-
-[[noreturn]] inline void
-throwNotLoaded(std::source_location loc = std::source_location::current()) {
-  throw RnExecutorchError(RnExecutorchErrorCode::ModuleNotLoaded,
-                          locationPrefix(loc) + "Model not loaded (in: " +
-                              loc.function_name() + ")");
-}
-
-template <typename Result>
-inline void checkOkOrThrowForwardError(
-    const Result &result,
-    std::source_location loc = std::source_location::current()) {
-  if (!result.ok()) {
-    throw RnExecutorchError(
-        result.error(), locationPrefix(loc) +
-                            "Forward pass failed (in: " + loc.function_name() +
-                            "). Ensure the model input is correct.");
-  }
-}
-
-} // namespace detail
-} // namespace rnexecutorch
-
-#define CHECK_OK_OR_THROW_FORWARD_ERROR(result)                                \
-  ::rnexecutorch::detail::checkOkOrThrowForwardError(result)
-
-#define THROW_NOT_LOADED_ERROR() ::rnexecutorch::detail::throwNotLoaded()
diff --git a/packages/react-native-executorch/common/rnexecutorch/ErrorCodes.h b/packages/react-native-executorch/common/rnexecutorch/ErrorCodes.h
deleted file mode 100644
index d79e10c56b..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/ErrorCodes.h
+++ /dev/null
@@ -1,129 +0,0 @@
-#pragma once
-
-// Auto-generated from scripts/errors.config.ts
-// DO NOT EDIT MANUALLY - Run 'yarn codegen:errors' to regenerate
-
-#include <cstdint>
-
-namespace rnexecutorch {
-
-enum class RnExecutorchErrorCode : int32_t {
-  /**
-   * An umbrella-error that is thrown usually when something unexpected happens, for example a 3rd-party library error.
-   */
-  UnknownError = 101,
-  /**
-   * Thrown when a user tries to run a model that is not yet downloaded or loaded into memory.
-   */
-  ModuleNotLoaded = 102,
-  /**
-   * An error ocurred when saving a file. This could be, for instance a result image from an image model.
-   */
-  FileWriteFailed = 103,
-  /**
-   * Thrown when a user tries to run a model that is currently processing. It is only allowed to run a single model prediction at a time.
-   */
-  ModelGenerating = 104,
-  /**
-   * Thrown when a language is passed to a multi-language model that is not supported. For example OCR or Speech To Text.
-   */
-  LanguageNotSupported = 105,
-  /**
-   * Thrown when config parameters passed to a model are invalid. For example, when LLM's topp is outside of range [0, 1].
-   */
-  InvalidConfig = 112,
-  /**
-   * Thrown when React Native ExecuTorch threadpool problem occurs.
-   */
-  ThreadPoolError = 113,
-  /**
-   * Thrown when a file read operation failed. This could be invalid image url passed to image models, or unsupported format.
-   */
-  FileReadFailed = 114,
-  /**
-   * Thrown when the size of model output is unexpected. If you're using your custom model with any of the pre-defined modules, please verify docs or source code for the expected model I/O contract.
-   */
-  InvalidModelOutput = 115,
-  /**
-   * Thrown when the dimensions of input tensors don't match the model's expected dimensions.
-   */
-  WrongDimensions = 116,
-  /**
-   * Thrown when the input passed to our APIs is invalid, for example when passing an empty message array to LLM's generate().
-   */
-  InvalidUserInput = 117,
-  /**
-   * Thrown when the number of downloaded files is unexpected, due to download interruptions.
-   */
-  DownloadInterrupted = 118,
-  /**
-   * Thrown when a feature or platform is not supported in the current environment.
-   */
-  PlatformNotSupported = 119,
-  /**
-   * Thrown when the type of model source passed by the user is invalid.
-   */
-  InvalidModelSource = 120,
-  /**
-   * Thrown when the number of passed inputs to the model is different than the model metadata specifies. If you're using your custom model with any of the pre-defined modules, please verify docs or source code for the expected model I/O contract.
-   */
-  UnexpectedNumInputs = 121,
-  /**
-   * Thrown when an error occurs with the tokenizer or tokenization process.
-   */
-  TokenizerError = 122,
-  /**
-   * Thrown when there's a configuration mismatch between multilingual and language settings in Speech-to-Text models.
-   */
-  MultilingualConfiguration = 160,
-  /**
-   * Thrown when streaming transcription is attempted but audio data chunk is missing.
-   */
-  MissingDataChunk = 161,
-  /**
-   * Thrown when trying to stop or insert data into a stream that hasn't been started.
-   */
-  StreamingNotStarted = 162,
-  /**
-   * Thrown when trying to start a new streaming session while another is already in progress.
-   */
-  StreamingInProgress = 163,
-  /**
-   * Thrown when a resource fails to download. This could be due to invalid URL, or for example a network problem.
-   */
-  ResourceFetcherDownloadFailed = 180,
-  /**
-   * Thrown when a user tries to trigger a download that's already in progress.
-   */
-  ResourceFetcherDownloadInProgress = 181,
-  /**
-   * Thrown when trying to pause a download that is already paused.
-   */
-  ResourceFetcherAlreadyPaused = 182,
-  /**
-   * Thrown when trying to resume a download that is already ongoing.
-   */
-  ResourceFetcherAlreadyOngoing = 183,
-  /**
-   * Thrown when trying to pause, resume, or cancel a download that is not active.
-   */
-  ResourceFetcherNotActive = 184,
-  /**
-   * Thrown when required URI information is missing for a download operation.
-   */
-  ResourceFetcherMissingUri = 185,
-  /**
-   * Thrown when trying to load resources without fetcher initialization.
-   */
-  ResourceFetcherAdapterNotInitialized = 186,
-  /**
-   * Thrown when the platform does not support the resource fetching feature, which is required for downloading models and other resources in React Native ExecuTorch.
-   */
-  ResourceFetcherPlatformNotSupported = 187,
-  /**
-   * Thrown when the Expo resource fetcher entry point is incompatible with the installed expo-file-system version. The default entry point requires the new Directory/File API (Expo SDK 56+); use the `/legacy` entry point on older SDKs.
-   */
-  ResourceFetcherFileSystemApiUnavailable = 188,
-};
-
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/Log.h b/packages/react-native-executorch/common/rnexecutorch/Log.h
deleted file mode 100644
index bb17a53ec9..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/Log.h
+++ /dev/null
@@ -1,496 +0,0 @@
-#pragma once
-#include <cstdint>
-#include <exception>
-#include <filesystem>
-#include <ios>
-#include <iostream>
-#include <iterator>
-#include <memory>
-#include <optional>
-#include <sstream>
-#include <string>
-#include <system_error>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include <variant>
-
-#ifdef __ANDROID__
-#include <android/log.h>
-#endif
-#ifdef __APPLE__
-#include <os/log.h>
-#endif
-
-namespace low_level_log_implementation {
-
-using namespace std::string_literals;
-
-namespace concepts {
-template <typename T>
-concept Iterable = requires(const T &t) {
-  { std::begin(t) } -> std::input_or_output_iterator;
-  { std::end(t) } -> std::input_or_output_iterator;
-};
-
-template <typename T>
-concept FrontAccessible = requires(T t) {
-  { t.front() };
-  requires !std::is_void_v<decltype(t.front())>;
-};
-
-template <typename T>
-concept TopAccessible = requires(T t) {
-  { t.top() };
-  requires !std::is_void_v<decltype(t.top())>;
-};
-
-template <typename T>
-concept HasPop = requires(T t) {
-  { t.pop() };
-};
-
-template <typename T>
-concept HasEmpty = requires(const T &t) {
-  { t.empty() } -> std::same_as<bool>;
-};
-
-// These two below are needed apart from TopAccessible and FrontAccessible
-// to guarantee that correct templated is matched
-template <typename T>
-concept ReadOnlySequencableFront = requires(const T &t) {
-  { t.front() } -> std::same_as<const typename T::value_type &>;
-} && HasEmpty<T> && !Iterable<T>;
-
-template <typename T>
-concept ReadOnlySequencableTop = requires(const T &t) {
-  { t.top() } -> std::same_as<const typename T::value_type &>;
-} && HasEmpty<T> && !Iterable<T>;
-
-template <typename T>
-concept ReadOnlySequencable =
-    ReadOnlySequencableFront<T> || ReadOnlySequencableTop<T>;
-
-template <typename T>
-concept MutableSequencable = ReadOnlySequencable<T> && HasPop<T>;
-
-template <typename T>
-concept Streamable = requires(std::ostream &os, const T &t) {
-  { os << t } -> std::convertible_to<std::ostream &>;
-};
-
-template <typename T>
-concept SmartPointer = requires(const T &a) {
-  *a;
-  { a ? true : false } -> std::convertible_to<bool>;
-} && !std::is_pointer_v<T>; // Ensure that it's not a raw pointer
-
-template <typename T>
-concept WeakPointer = requires(const T &a) {
-  {
-    a.lock()
-  } -> std::convertible_to<
-      std::shared_ptr<typename T::element_type>>; // Verifies if a.lock() can
-                                                  // convert to std::shared_ptr
-};
-
-template <typename T>
-concept Fallback =
-    !Iterable<T> && !Streamable<T> && !SmartPointer<T> && !WeakPointer<T> &&
-    !ReadOnlySequencable<T> && !MutableSequencable<T>;
-
-} // namespace concepts
-
-template <typename T>
-  requires concepts::Streamable<T> && (!concepts::SmartPointer<T>)
-void printElement(std::ostream &os, const T &value);
-
-template <typename T, typename U>
-void printElement(std::ostream &os, const std::pair<T, U> &p);
-
-template <std::size_t N>
-void printElement(std::ostream &os, const char (&array)[N]);
-
-template <typename T, std::size_t N>
-void printElement(std::ostream &os, T (&array)[N]);
-
-template <typename T>
-  requires concepts::Iterable<T> && (!concepts::Streamable<T>)
-void printElement(std::ostream &os, const T &container);
-
-template <typename T> void printSequencable(std::ostream &os, T &&container);
-
-template <typename T>
-  requires concepts::ReadOnlySequencable<T>
-void printElement(std::ostream &os, const T &container);
-
-template <typename T>
-  requires concepts::MutableSequencable<T>
-void printElement(std::ostream &os, T &&container);
-
-template <typename... Args>
-void printElement(std::ostream &os, const std::tuple<Args...> &tpl);
-
-template <concepts::SmartPointer SP>
-void printElement(std::ostream &os, const SP &ptr);
-
-template <concepts::WeakPointer WP>
-void printElement(std::ostream &os, const WP &ptr);
-
-template <typename T>
-void printElement(std::ostream &os, const std::optional<T> &opt);
-
-template <typename... Ts>
-void printElement(std::ostream &os, const std::variant<Ts...> &var);
-
-void printElement(std::ostream &os, const std::exception_ptr &exPtr);
-
-void printElement(std::ostream &os, const std::filesystem::path &path);
-
-void printElement(std::ostream &os,
-                  const std::filesystem::directory_iterator &dir_it);
-
-template <concepts::Fallback UnsupportedArg>
-void printElement(std::ostream &os, const UnsupportedArg &value);
-
-void printElement(std::ostream &os, const std::error_code &ec);
-
-template <typename T>
-  requires concepts::Streamable<T> && (!concepts::SmartPointer<T>)
-void printElement(std::ostream &os, const T &value) {
-  os << value;
-}
-
-template <typename T, typename U>
-void printElement(std::ostream &os, const std::pair<T, U> &p) {
-  os << "(";
-  printElement(os, p.first);
-  os << ", ";
-  printElement(os, p.second);
-  os << ")";
-}
-
-template <std::size_t N>
-void printElement(std::ostream &os, const char (&array)[N]) {
-  // Treats the input as a string up to length N, drop null termination
-  if (N > 1) {
-    os << std::string_view(array, N - 1);
-  }
-}
-
-// A special function for C-style arrays deducing size via template
-template <typename T, std::size_t N>
-void printElement(std::ostream &os, T (&array)[N]) {
-  os << "[";
-  for (std::size_t i = 0; i < N; ++i) {
-    if (i > 0) {
-      os << ", ";
-    }
-    printElement(os, array[i]);
-  }
-  os << "]";
-}
-
-template <typename T>
-  requires concepts::Iterable<T> && (!concepts::Streamable<T>)
-void printElement(std::ostream &os, const T &container) {
-  os << "[";
-  auto it = std::begin(container);
-  if (it != std::end(container)) {
-    printElement(os, *it++);
-    for (; it != std::end(container); ++it) {
-      os << ", ";
-      printElement(os, *it);
-    }
-  }
-  os << "]";
-}
-
-template <typename T> void printSequencable(std::ostream &os, T &&container) {
-  os << "[";
-  bool isFirst = true;
-
-  auto printElementLambda = [&isFirst, &os](auto &&element) {
-    if (!isFirst) {
-      os << ", ";
-    }
-    low_level_log_implementation::printElement(
-        os, std::forward<decltype(element)>(element));
-    isFirst = false;
-  };
-
-  while (!container.empty()) {
-    if constexpr (concepts::FrontAccessible<T>) {
-      printElementLambda(container.front());
-    } else if constexpr (concepts::TopAccessible<T>) {
-      printElementLambda(container.top());
-    }
-    container.pop();
-  }
-
-  os << "]";
-}
-
-template <typename T>
-  requires concepts::ReadOnlySequencable<T>
-void printElement(std::ostream &os, const T &container) {
-  T tempContainer = container; // Make a copy to preserve original container
-  printSequencable(
-      os, std::move(tempContainer)); // Use std::move since tempContainer won't
-                                     // be used again
-}
-
-template <typename T>
-  requires concepts::MutableSequencable<T>
-void printElement(std::ostream &os, T &&container) {
-  printSequencable(os, std::forward<T>(container));
-}
-
-template <typename... Args>
-void printElement(std::ostream &os, const std::tuple<Args...> &tpl) {
-  os << "<";
-  std::apply(
-      [&os](const auto &...args) {
-        // Counter to apply commas correctly
-        std::size_t count = 0;
-        std::size_t total = sizeof...(args);
-
-        (
-            [&] {
-              printElement(os, args);
-              if (++count < total) {
-                os << ", ";
-              }
-            }(),
-            ...);
-      },
-      tpl);
-  os << ">";
-}
-
-template <concepts::SmartPointer SP>
-void printElement(std::ostream &os, const SP &ptr) {
-  if (ptr) {
-    printElement(os, *ptr);
-  } else {
-    os << "nullptr";
-  }
-}
-
-template <concepts::WeakPointer WP>
-void printElement(std::ostream &os, const WP &ptr) {
-  auto sp = ptr.lock();
-  if (sp) {
-    printElement(os, *sp);
-  } else {
-    os << "expired";
-  }
-}
-
-template <typename T>
-void printElement(std::ostream &os, const std::optional<T> &opt) {
-  if (opt) {
-    os << "Optional(";
-    printElement(os, *opt);
-    os << ")";
-  } else {
-    os << "nullopt";
-  }
-}
-
-template <typename... Ts>
-void printElement(std::ostream &os, const std::variant<Ts...> &var) {
-  std::visit(
-      [&os](const auto &value) {
-        os << "Variant(";
-        printElement(os, value);
-        os << ")";
-      },
-      var);
-}
-
-inline void printElement(std::ostream &os, const std::error_code &ec) {
-  os << "ErrorCode(" << ec.value() << ", " << ec.category().name() << ")";
-}
-
-inline void printElement(std::ostream &os, const std::exception_ptr &exPtr) {
-  if (exPtr) {
-    try {
-      std::rethrow_exception(exPtr);
-    } catch (const std::exception &ex) {
-      os << "ExceptionPtr(\"" << ex.what() << "\")";
-    } catch (...) {
-      os << "ExceptionPtr(non-standard exception)";
-    }
-  } else {
-    os << "nullptr";
-  }
-}
-
-inline void printElement(std::ostream &os, const std::filesystem::path &path) {
-  os << "Path(" << path << ")";
-}
-
-inline void
-printElement(std::ostream &os,
-             const std::filesystem::directory_iterator &dirIterator) {
-  os << "Directory[";
-  bool first = true;
-  for (const auto &entry : dirIterator) {
-    if (!first) {
-      os << ", ";
-    }
-    os << entry.path().filename(); // Ensuring only filename is captured
-    first = false;
-  }
-  os << "]";
-}
-
-// Fallback
-template <concepts::Fallback UnsupportedArg>
-void printElement(std::ostream &os, const UnsupportedArg &value) {
-  const auto *typeName = typeid(UnsupportedArg).name();
-  throw std::runtime_error(
-      "Type "s + std::string(typeName) +
-      "neither supports << operator for std::ostream nor is supported "
-      "out-of-the-box in logging functionality."s);
-}
-
-} // namespace low_level_log_implementation
-
-namespace rnexecutorch {
-
-/**
- * @enum LogLevel
- * @brief Represents various levels of logging severity.
- *
- * This `enum class` is used to specify the severity of a log message. This
- * helps in filtering logs according to their importance and can be crucial for
- * debugging and monitoring applications.
- */
-enum class LOG_LEVEL : uint8_t {
-  Info,  /**< Informational messages that highlight the progress of the
-            application. */
-  Warn,  /**< Warning messages that a non-critical error occurred during
-            program execution */
-  Error, /**< Error events of considerable importance that will prevent normal
-            program execution. */
-  Debug  /**< Detailed information, typically of interest only when diagnosing
-            problems. */
-};
-
-namespace high_level_log_implementation {
-
-#ifdef __ANDROID__
-inline android_LogPriority androidLogLevel(LOG_LEVEL logLevel) {
-  switch (logLevel) {
-  case LOG_LEVEL::Info:
-    return ANDROID_LOG_INFO;
-  case LOG_LEVEL::Warn:
-    return ANDROID_LOG_WARN;
-  case LOG_LEVEL::Error:
-    return ANDROID_LOG_ERROR;
-  case LOG_LEVEL::Debug:
-    return ANDROID_LOG_DEBUG;
-  default:
-    return ANDROID_LOG_DEFAULT;
-  }
-}
-
-inline void handleAndroidLog(LOG_LEVEL logLevel, const char *buffer) {
-  __android_log_print(androidLogLevel(logLevel), "RnExecutorch", "%s", buffer);
-}
-#endif
-
-#ifdef __APPLE__
-inline void handleIosLog(LOG_LEVEL logLevel, const char *buffer) {
-  switch (logLevel) {
-  case LOG_LEVEL::Info:
-    os_log_info(OS_LOG_DEFAULT, "%{public}s", buffer);
-    return;
-  case LOG_LEVEL::Warn:
-    os_log(OS_LOG_DEFAULT, "%{public}s", buffer);
-    return;
-  case LOG_LEVEL::Error:
-    os_log_error(OS_LOG_DEFAULT, "%{public}s", buffer);
-    return;
-  case LOG_LEVEL::Debug:
-    os_log_debug(OS_LOG_DEFAULT, "%{public}s", buffer);
-    return;
-  }
-}
-#endif
-
-inline std::string getBuffer(const std::string &logMessage,
-                             std::size_t maxLogMessageSize) {
-  if (logMessage.size() > maxLogMessageSize) {
-    return logMessage.substr(0, maxLogMessageSize) + "...";
-  }
-  return logMessage;
-}
-
-inline std::ostringstream createConfiguredOutputStream() {
-  std::ostringstream oss;
-  oss << std::boolalpha;
-  return oss;
-}
-
-} // namespace high_level_log_implementation
-
-/**
- * @brief Logs given data on a console
- * @details
- * The function takes logging level and variety of data types:
- * - Every data type that implements `operator<<` for `std::ostream`
- * - All STL constainers available in C++20
- * - Static arrays
- * - Smart pointers, `std::variant`, and `std::optional`
- * - `std::tuple` and `std::pair`
- * - `std::error_code` and `std::exception_ptr`
- * - `std::filesystem::path` and `std::filesystem::directory_iterator`
- * - Every combination for mentioned above like `std::vector<std::set<int>>`
- *
- * You can manipulate size of the log message. By default it is set to 1024
- * characters. To change this, specify the template argument like so:
- * @code{.cpp}
- * log<2048>(LOG_LEVEL::Info, longMsg);
- * @endcode
- * @param logLevel logging level - one of `LOG_LEVEL` enum class value: `Info`,
- * `Error`, and `Debug`.
- * @tparam Args Data to be logged.
- * @tparam MaxLogSize Maximal size of log in characters.
- * @par Returns
- *    Nothing.
- */
-template <std::size_t MaxLogSize = 1024, typename... Args>
-void log(LOG_LEVEL logLevel, Args &&...args) {
-  auto oss = high_level_log_implementation::createConfiguredOutputStream();
-  auto space = [&oss](auto &&arg) {
-    low_level_log_implementation::printElement(
-        oss, std::forward<decltype(arg)>(arg));
-    oss << ' ';
-  };
-
-  (..., space(std::forward<Args>(args)));
-
-  // Remove the extra space after the last element
-  std::string output = oss.str();
-  if (!output.empty()) {
-    output.pop_back();
-  }
-
-  const auto buffer =
-      high_level_log_implementation::getBuffer(output, MaxLogSize);
-  const auto *cStyleBuffer = buffer.c_str();
-
-#ifdef __ANDROID__
-  high_level_log_implementation::handleAndroidLog(logLevel, cStyleBuffer);
-#elif defined(__APPLE__)
-  high_level_log_implementation::handleIosLog(logLevel, cStyleBuffer);
-#else
-  // Default log to cout if none of the above platforms
-  std::cout << cStyleBuffer << '\n';
-#endif
-}
-
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/RnExecutorchInstaller.cpp b/packages/react-native-executorch/common/rnexecutorch/RnExecutorchInstaller.cpp
deleted file mode 100644
index 53ee65a904..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/RnExecutorchInstaller.cpp
+++ /dev/null
@@ -1,143 +0,0 @@
-#include "RnExecutorchInstaller.h"
-
-#include <rnexecutorch/TokenizerModule.h>
-#include <rnexecutorch/host_objects/JsiConversions.h>
-#include <rnexecutorch/models/classification/Classification.h>
-#include <rnexecutorch/models/embeddings/image/ImageEmbeddings.h>
-#include <rnexecutorch/models/embeddings/text/TextEmbeddings.h>
-#include <rnexecutorch/models/instance_segmentation/BaseInstanceSegmentation.h>
-#include <rnexecutorch/models/llm/LLM.h>
-#include <rnexecutorch/models/object_detection/ObjectDetection.h>
-#include <rnexecutorch/models/ocr/OCR.h>
-#include <rnexecutorch/models/pose_estimation/PoseEstimation.h>
-#include <rnexecutorch/models/privacy_filter/PrivacyFilter.h>
-#include <rnexecutorch/models/semantic_segmentation/BaseSemanticSegmentation.h>
-#include <rnexecutorch/models/speech_to_text/SpeechToText.h>
-#include <rnexecutorch/models/style_transfer/StyleTransfer.h>
-#include <rnexecutorch/models/text_to_image/TextToImage.h>
-#include <rnexecutorch/models/text_to_speech/TextToSpeech.h>
-#include <rnexecutorch/models/vertical_ocr/VerticalOCR.h>
-#include <rnexecutorch/models/voice_activity_detection/VoiceActivityDetection.h>
-#include <rnexecutorch/threads/GlobalThreadPool.h>
-#include <rnexecutorch/threads/utils/ThreadUtils.h>
-
-#if defined(__ANDROID__) && defined(__aarch64__)
-#include <executorch/extension/threadpool/cpuinfo_utils.h>
-#include <executorch/extension/threadpool/threadpool.h>
-#include <rnexecutorch/Log.h>
-#endif
-
-namespace rnexecutorch {
-
-// This function fetches data from a url address. It is implemented in
-// Kotlin/ObjectiveC++ and then bound to this variable. It's done to not handle
-// SSL intricacies manually, as it is done automagically in ObjC++/Kotlin.
-FetchUrlFunc_t fetchUrlFunc;
-
-void RnExecutorchInstaller::injectJSIBindings(
-    jsi::Runtime *jsiRuntime, std::shared_ptr<react::CallInvoker> jsCallInvoker,
-    FetchUrlFunc_t fetchDataFromUrl, bool isEmulator) {
-  fetchUrlFunc = fetchDataFromUrl;
-
-  jsiRuntime->global().setProperty(*jsiRuntime, "__rne_isEmulator",
-                                   jsi::Value(isEmulator));
-
-  jsiRuntime->global().setProperty(
-      *jsiRuntime, "loadStyleTransfer",
-      RnExecutorchInstaller::loadModel<models::style_transfer::StyleTransfer>(
-          jsiRuntime, jsCallInvoker, "loadStyleTransfer"));
-
-  jsiRuntime->global().setProperty(
-      *jsiRuntime, "loadSemanticSegmentation",
-      RnExecutorchInstaller::loadModel<
-          models::semantic_segmentation::BaseSemanticSegmentation>(
-          jsiRuntime, jsCallInvoker, "loadSemanticSegmentation"));
-
-  jsiRuntime->global().setProperty(
-      *jsiRuntime, "loadInstanceSegmentation",
-      RnExecutorchInstaller::loadModel<
-          models::instance_segmentation::BaseInstanceSegmentation>(
-          jsiRuntime, jsCallInvoker, "loadInstanceSegmentation"));
-
-  jsiRuntime->global().setProperty(
-      *jsiRuntime, "loadTextToImage",
-      RnExecutorchInstaller::loadModel<models::text_to_image::TextToImage>(
-          jsiRuntime, jsCallInvoker, "loadTextToImage"));
-
-  jsiRuntime->global().setProperty(
-      *jsiRuntime, "loadClassification",
-      RnExecutorchInstaller::loadModel<models::classification::Classification>(
-          jsiRuntime, jsCallInvoker, "loadClassification"));
-
-  jsiRuntime->global().setProperty(
-      *jsiRuntime, "loadObjectDetection",
-      RnExecutorchInstaller::loadModel<
-          models::object_detection::ObjectDetection>(jsiRuntime, jsCallInvoker,
-                                                     "loadObjectDetection"));
-
-  jsiRuntime->global().setProperty(
-      *jsiRuntime, "loadPoseEstimation",
-      RnExecutorchInstaller::loadModel<models::pose_estimation::PoseEstimation>(
-          jsiRuntime, jsCallInvoker, "loadPoseEstimation"));
-
-  jsiRuntime->global().setProperty(
-      *jsiRuntime, "loadExecutorchModule",
-      RnExecutorchInstaller::loadModel<models::BaseModel>(
-          jsiRuntime, jsCallInvoker, "loadExecutorchModule"));
-
-  jsiRuntime->global().setProperty(
-      *jsiRuntime, "loadTokenizerModule",
-      RnExecutorchInstaller::loadModel<TokenizerModule>(
-          jsiRuntime, jsCallInvoker, "loadTokenizerModule"));
-
-  jsiRuntime->global().setProperty(
-      *jsiRuntime, "loadImageEmbeddings",
-      RnExecutorchInstaller::loadModel<models::embeddings::ImageEmbeddings>(
-          jsiRuntime, jsCallInvoker, "loadImageEmbeddings"));
-
-  jsiRuntime->global().setProperty(
-      *jsiRuntime, "loadTextEmbeddings",
-      RnExecutorchInstaller::loadModel<models::embeddings::TextEmbeddings>(
-          jsiRuntime, jsCallInvoker, "loadTextEmbeddings"));
-
-  jsiRuntime->global().setProperty(
-      *jsiRuntime, "loadLLM",
-      RnExecutorchInstaller::loadModel<models::llm::LLM>(
-          jsiRuntime, jsCallInvoker, "loadLLM"));
-
-  jsiRuntime->global().setProperty(
-      *jsiRuntime, "loadPrivacyFilter",
-      RnExecutorchInstaller::loadModel<models::privacy_filter::PrivacyFilter>(
-          jsiRuntime, jsCallInvoker, "loadPrivacyFilter"));
-
-  jsiRuntime->global().setProperty(
-      *jsiRuntime, "loadOCR",
-      RnExecutorchInstaller::loadModel<models::ocr::OCR>(
-          jsiRuntime, jsCallInvoker, "loadOCR"));
-
-  jsiRuntime->global().setProperty(
-      *jsiRuntime, "loadVerticalOCR",
-      RnExecutorchInstaller::loadModel<models::ocr::VerticalOCR>(
-          jsiRuntime, jsCallInvoker, "loadVerticalOCR"));
-
-  jsiRuntime->global().setProperty(
-      *jsiRuntime, "loadSpeechToText",
-      RnExecutorchInstaller::loadModel<models::speech_to_text::SpeechToText>(
-          jsiRuntime, jsCallInvoker, "loadSpeechToText"));
-
-  jsiRuntime->global().setProperty(
-      *jsiRuntime, "loadTextToSpeechKokoro",
-      RnExecutorchInstaller::loadModel<models::text_to_speech::kokoro::Kokoro>(
-          jsiRuntime, jsCallInvoker, "loadTextToSpeechKokoro"));
-
-  jsiRuntime->global().setProperty(
-      *jsiRuntime, "loadVAD",
-      RnExecutorchInstaller::loadModel<
-          models::voice_activity_detection::VoiceActivityDetection>(
-          jsiRuntime, jsCallInvoker, "loadVAD"));
-
-  threads::utils::unsafeSetupThreadPool();
-  threads::GlobalThreadPool::initialize();
-}
-
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/RnExecutorchInstaller.h b/packages/react-native-executorch/common/rnexecutorch/RnExecutorchInstaller.h
deleted file mode 100644
index 887a8ac0ea..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/RnExecutorchInstaller.h
+++ /dev/null
@@ -1,116 +0,0 @@
-#include <memory>
-#include <string>
-
-#include <ReactCommon/CallInvoker.h>
-#include <jsi/jsi.h>
-
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/host_objects/JsiConversions.h>
-#include <rnexecutorch/host_objects/ModelHostObject.h>
-#include <rnexecutorch/jsi/Promise.h>
-#include <rnexecutorch/metaprogramming/ConstructorHelpers.h>
-#include <rnexecutorch/metaprogramming/FunctionHelpers.h>
-#include <rnexecutorch/metaprogramming/TypeConcepts.h>
-#include <rnexecutorch/threads/GlobalThreadPool.h>
-
-namespace rnexecutorch {
-
-using FetchUrlFunc_t = std::function<std::vector<std::byte>(std::string)>;
-extern FetchUrlFunc_t fetchUrlFunc;
-using namespace facebook;
-
-class RnExecutorchInstaller {
-public:
-  static void
-  injectJSIBindings(jsi::Runtime *jsiRuntime,
-                    std::shared_ptr<react::CallInvoker> jsCallInvoker,
-                    FetchUrlFunc_t fetchDataFromUrl, bool isEmulator);
-
-private:
-  template <typename ModelT>
-    requires meta::ValidConstructorTraits<ModelT> &&
-             meta::CallInvokerLastInConstructor<ModelT> &&
-             meta::ProvidesMemoryLowerBound<ModelT>
-  static jsi::Function
-  loadModel(jsi::Runtime *jsiRuntime,
-            std::shared_ptr<react::CallInvoker> jsCallInvoker,
-            const std::string &loadFunctionName) {
-    return jsi::Function::createFromHostFunction(
-        *jsiRuntime, jsi::PropNameID::forAscii(*jsiRuntime, loadFunctionName),
-        0,
-        [jsCallInvoker](jsi::Runtime &runtime, const jsi::Value &thisValue,
-                        const jsi::Value *args, size_t count) -> jsi::Value {
-          constexpr std::size_t expectedCount = std::tuple_size_v<
-              typename meta::ConstructorTraits<ModelT>::arg_types>;
-          // count doesn't account for the JSCallInvoker
-          if (count != expectedCount - 1) {
-            char errorMessage[100];
-            std::snprintf(
-                errorMessage, sizeof(errorMessage),
-                "Argument count mismatch, was expecting: %zu but got: %zu",
-                expectedCount, count);
-            throw jsi::JSError(runtime, errorMessage);
-          }
-
-          // Parse JSI arguments on the JS thread (required for jsi::Value
-          // access), then dispatch the heavy model construction to a background
-          // thread and return a Promise.
-          auto constructorArgs =
-              meta::createConstructorArgsWithCallInvoker<ModelT>(args, runtime,
-                                                                 jsCallInvoker);
-
-          return Promise::createPromise(
-              runtime, jsCallInvoker,
-              [jsCallInvoker, constructorArgs = std::move(constructorArgs)](
-                  std::shared_ptr<Promise> promise) {
-                threads::GlobalThreadPool::detach([jsCallInvoker, promise,
-                                                   constructorArgs = std::move(
-                                                       constructorArgs)]() {
-                  try {
-                    auto modelImplementationPtr = std::apply(
-                        [](auto &&...unpackedArgs) {
-                          return std::make_shared<ModelT>(
-                              std::forward<decltype(unpackedArgs)>(
-                                  unpackedArgs)...);
-                        },
-                        std::move(constructorArgs));
-
-                    auto modelHostObject =
-                        std::make_shared<ModelHostObject<ModelT>>(
-                            modelImplementationPtr, jsCallInvoker);
-
-                    auto memoryLowerBound =
-                        modelImplementationPtr->getMemoryLowerBound();
-
-                    jsCallInvoker->invokeAsync([promise, modelHostObject,
-                                                memoryLowerBound](
-                                                   jsi::Runtime &rt) {
-                      auto jsiObject = jsi::Object::createFromHostObject(
-                          rt, modelHostObject);
-                      jsiObject.setExternalMemoryPressure(rt, memoryLowerBound);
-                      promise->resolve(std::move(jsiObject));
-                    });
-                  } catch (const rnexecutorch::RnExecutorchError &e) {
-                    auto code = e.getNumericCode();
-                    auto msg = std::string(e.what());
-                    jsCallInvoker->invokeAsync(
-                        [promise, code, msg](jsi::Runtime &rt) {
-                          promise->reject(
-                              makeRnExecutorchErrorValue(rt, code, msg));
-                        });
-                  } catch (const std::exception &e) {
-                    jsCallInvoker->invokeAsync(
-                        [promise, msg = std::string(e.what())]() {
-                          promise->reject(msg);
-                        });
-                  } catch (...) {
-                    jsCallInvoker->invokeAsync([promise]() {
-                      promise->reject(std::string("Unknown error"));
-                    });
-                  }
-                });
-              });
-        });
-  }
-};
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/TokenizerModule.cpp b/packages/react-native-executorch/common/rnexecutorch/TokenizerModule.cpp
deleted file mode 100644
index 76e0fb90c7..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/TokenizerModule.cpp
+++ /dev/null
@@ -1,106 +0,0 @@
-#include "TokenizerModule.h"
-#include "Error.h"
-#include "ErrorCodes.h"
-#include <cstdint>
-#include <executorch/extension/module/module.h>
-#include <filesystem>
-#include <pytorch/tokenizers/error.h>
-#include <runner/constants.h>
-
-namespace rnexecutorch {
-using namespace facebook;
-using namespace executorch::extension::llm;
-
-TokenizerModule::TokenizerModule(
-    std::string source, std::shared_ptr<react::CallInvoker> callInvoker)
-    : tokenizer(std::make_unique<tokenizers::HFTokenizer>()) {
-
-  auto status = tokenizer->load(source);
-
-  if (status != tokenizers::Error::Ok) {
-    throw RnExecutorchError(
-        RnExecutorchErrorCode::TokenizerError,
-        "Unexpected issue occurred while loading tokenizer");
-  };
-  std::filesystem::path modelPath{source};
-  memorySizeLowerBound = std::filesystem::file_size(modelPath);
-}
-
-std::vector<uint64_t> TokenizerModule::encode(std::string s) const {
-  if (!tokenizer) {
-    THROW_NOT_LOADED_ERROR();
-  }
-
-  // If the used tokenizer.json has defined post_processor field,
-  // setting any of bos or eos arguments to value other than provided constant
-  // ( which is 0) will result in running the post_processor with
-  // 'add_special_token' flag
-  auto encodeResult =
-      tokenizer->encode(s, numOfAddedBoSTokens, numOfAddedEoSTokens);
-  if (!encodeResult.ok()) {
-    throw RnExecutorchError(
-        RnExecutorchErrorCode::TokenizerError,
-        "Unexpected issue occurred while encoding: " +
-            std::to_string(static_cast<int32_t>(encodeResult.error())));
-  }
-  return encodeResult.get();
-}
-
-std::string TokenizerModule::decode(std::vector<uint64_t> vec,
-                                    bool skipSpecialTokens) const {
-  if (!tokenizer) {
-    THROW_NOT_LOADED_ERROR();
-  }
-
-  auto decodeResult = tokenizer->decode(vec, skipSpecialTokens);
-  if (!decodeResult.ok()) {
-    throw RnExecutorchError(
-        RnExecutorchErrorCode::TokenizerError,
-        "Unexpected issue occurred while decoding: " +
-            std::to_string(static_cast<int32_t>(decodeResult.error())));
-  }
-
-  return decodeResult.get();
-}
-
-size_t TokenizerModule::getVocabSize() const {
-  if (!tokenizer) {
-    THROW_NOT_LOADED_ERROR();
-  }
-  return static_cast<size_t>(tokenizer->vocab_size());
-}
-
-std::string TokenizerModule::idToToken(uint64_t tokenId) const {
-  if (!tokenizer) {
-    THROW_NOT_LOADED_ERROR();
-  }
-  auto result = tokenizer->id_to_piece(tokenId);
-  if (!result.ok()) {
-    throw RnExecutorchError(
-        RnExecutorchErrorCode::TokenizerError,
-        "Unexpected issue occurred while converting id to token: " +
-            std::to_string(static_cast<int32_t>(result.error())));
-  }
-  return result.get();
-}
-
-uint64_t TokenizerModule::tokenToId(std::string token) const {
-  if (!tokenizer) {
-    THROW_NOT_LOADED_ERROR();
-  }
-
-  auto result = tokenizer->piece_to_id(token);
-  if (!result.ok()) {
-    throw RnExecutorchError(
-        RnExecutorchErrorCode::TokenizerError,
-        "Unexpected issue occurred while converting token to id: " +
-            std::to_string(static_cast<int32_t>(result.error())));
-  }
-  return result.get();
-}
-
-std::size_t TokenizerModule::getMemoryLowerBound() const noexcept {
-  return memorySizeLowerBound;
-}
-
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/TokenizerModule.h b/packages/react-native-executorch/common/rnexecutorch/TokenizerModule.h
deleted file mode 100644
index 3c90b25557..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/TokenizerModule.h
+++ /dev/null
@@ -1,33 +0,0 @@
-#pragma once
-
-#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
-#include <ReactCommon/CallInvoker.h>
-#include <pytorch/tokenizers/hf_tokenizer.h>
-#include <string>
-namespace rnexecutorch {
-using namespace facebook;
-
-class TokenizerModule {
-public:
-  explicit TokenizerModule(std::string source,
-                           std::shared_ptr<react::CallInvoker> callInvoker);
-  [[nodiscard("Registered non-void function")]] std::vector<uint64_t>
-  encode(std::string s) const;
-  [[nodiscard("Registered non-void function")]] std::string
-  decode(std::vector<uint64_t> vec, bool skipSpecialTokens) const;
-  [[nodiscard("Registered non-void function")]] std::string
-  idToToken(uint64_t tokenId) const;
-  [[nodiscard("Registered non-void function")]] uint64_t
-  tokenToId(std::string token) const;
-  [[nodiscard("Registered non-void function")]] std::size_t
-  getVocabSize() const;
-  std::size_t getMemoryLowerBound() const noexcept;
-
-private:
-  std::unique_ptr<tokenizers::HFTokenizer> tokenizer;
-  std::size_t memorySizeLowerBound{0};
-};
-
-REGISTER_CONSTRUCTOR(TokenizerModule, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/data_processing/FFT.cpp b/packages/react-native-executorch/common/rnexecutorch/data_processing/FFT.cpp
deleted file mode 100644
index 4884938294..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/data_processing/FFT.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include <rnexecutorch/data_processing/FFT.h>
-
-namespace rnexecutorch::dsp {
-
-FFT::FFT(int size) : size_(size) {
-  pffftSetup_ = pffft_new_setup(size_, PFFFT_REAL);
-  work_ = static_cast<float *>(pffft_aligned_malloc(size_ * sizeof(float)));
-}
-
-FFT::~FFT() {
-  pffft_destroy_setup(pffftSetup_);
-  pffft_aligned_free(work_);
-}
-
-void FFT::doFFT(float *in, std::vector<std::complex<float>> &out) {
-  pffft_transform_ordered(pffftSetup_, in,
-                          reinterpret_cast<float *>(out.data()), work_,
-                          PFFFT_FORWARD);
-}
-
-} // namespace rnexecutorch::dsp
diff --git a/packages/react-native-executorch/common/rnexecutorch/data_processing/FFT.h b/packages/react-native-executorch/common/rnexecutorch/data_processing/FFT.h
deleted file mode 100644
index 5f3569e94f..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/data_processing/FFT.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#pragma once
-extern "C" {
-#include <pfft/pfft.h>
-}
-#include <complex>
-#include <vector>
-
-namespace rnexecutorch::dsp {
-
-class FFT final {
-public:
-  explicit FFT(int size);
-  ~FFT();
-  void doFFT(float *in, std::vector<std::complex<float>> &out);
-
-private:
-  int size_;
-
-  PFFFT_Setup *pffftSetup_;
-  float *work_;
-};
-
-} // namespace rnexecutorch::dsp
diff --git a/packages/react-native-executorch/common/rnexecutorch/data_processing/FileUtils.h b/packages/react-native-executorch/common/rnexecutorch/data_processing/FileUtils.h
deleted file mode 100644
index 9154a6c8e2..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/data_processing/FileUtils.h
+++ /dev/null
@@ -1,33 +0,0 @@
-#pragma once
-
-#include <chrono>
-#include <filesystem>
-#include <fstream>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-#include <string>
-
-namespace rnexecutorch::file_utils {
-
-inline std::string getTimeID() {
-  return std::to_string(std::chrono::duration_cast<std::chrono::milliseconds>(
-                            std::chrono::system_clock::now().time_since_epoch())
-                            .count());
-}
-
-inline std::string loadBytesFromFile(const std::string &path) {
-  std::ifstream fs(path, std::ios::in | std::ios::binary);
-  if (fs.fail()) {
-    throw RnExecutorchError(RnExecutorchErrorCode::FileReadFailed,
-                            "Failed to open tokenizer file!");
-  }
-  std::string data;
-  fs.seekg(0, std::ios::end);
-  auto size = static_cast<size_t>(fs.tellg());
-  fs.seekg(0, std::ios::beg);
-  data.resize(size);
-  fs.read(data.data(), size);
-  return data;
-}
-
-} // namespace rnexecutorch::file_utils
diff --git a/packages/react-native-executorch/common/rnexecutorch/data_processing/ImageProcessing.cpp b/packages/react-native-executorch/common/rnexecutorch/data_processing/ImageProcessing.cpp
deleted file mode 100644
index 3e73a3d8a4..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/data_processing/ImageProcessing.cpp
+++ /dev/null
@@ -1,261 +0,0 @@
-#include "ImageProcessing.h"
-
-#include <filesystem>
-
-#include <ada/ada.h>
-
-#include <rnexecutorch/RnExecutorchInstaller.h>
-#include <rnexecutorch/data_processing/FileUtils.h>
-#include <rnexecutorch/data_processing/base64.h>
-
-namespace rnexecutorch {
-// This is defined in RnExecutorchInstaller.cpp. This function fetches data
-// from a url address. It is implemented in Kotlin/ObjectiveC++ and then bound
-// to this variable. It's done to not handle SSL intricacies manually, as it is
-// done automagically in ObjC++/Kotlin.
-extern FetchUrlFunc_t fetchUrlFunc;
-namespace image_processing {
-std::vector<float> colorMatToVector(const cv::Mat &mat) {
-  return colorMatToVector(mat, cv::Scalar(0.0, 0.0, 0.0),
-                          cv::Scalar(1.0, 1.0, 1.0));
-}
-
-std::vector<float> colorMatToVector(const cv::Mat &mat, cv::Scalar mean,
-                                    cv::Scalar variance) {
-  int pixelCount = mat.cols * mat.rows;
-  std::vector<float> v(pixelCount * 3);
-
-  for (int i = 0; i < pixelCount; i++) {
-    int row = i / mat.cols;
-    int col = i % mat.cols;
-    cv::Vec3b pixel = mat.at<cv::Vec3b>(row, col);
-    v[0 * pixelCount + i] =
-        (pixel[0] - mean[0] * 255.0) / (variance[0] * 255.0);
-    v[1 * pixelCount + i] =
-        (pixel[1] - mean[1] * 255.0) / (variance[1] * 255.0);
-    v[2 * pixelCount + i] =
-        (pixel[2] - mean[2] * 255.0) / (variance[2] * 255.0);
-  }
-
-  return v;
-}
-
-cv::Mat bufferToColorMat(const std::span<const float> &buffer,
-                         cv::Size matSize) {
-  cv::Mat mat(matSize, CV_8UC3);
-
-  int pixelCount = matSize.width * matSize.height;
-  for (int i = 0; i < pixelCount; i++) {
-    int row = i / matSize.width;
-    int col = i % matSize.width;
-
-    float r = buffer[0 * pixelCount + i];
-    float g = buffer[1 * pixelCount + i];
-    float b = buffer[2 * pixelCount + i];
-
-    cv::Vec3b color(static_cast<uchar>(b * 255), static_cast<uchar>(g * 255),
-                    static_cast<uchar>(r * 255));
-    mat.at<cv::Vec3b>(row, col) = color;
-  }
-
-  return mat;
-}
-
-std::string saveToTempFile(const cv::Mat &image) {
-  std::string filename = "rn_executorch_" + file_utils::getTimeID() + ".png";
-
-  std::filesystem::path tempDir = std::filesystem::temp_directory_path();
-  std::filesystem::path filePath = tempDir / filename;
-
-  if (!cv::imwrite(filePath.string(), image)) {
-    throw RnExecutorchError(RnExecutorchErrorCode::FileWriteFailed,
-                            "Failed to save the image: " + filePath.string());
-  }
-
-  return "file://" + filePath.string();
-}
-
-cv::Mat readImage(const std::string &imageURI) {
-  cv::Mat image;
-
-  if (imageURI.starts_with("data")) {
-    // base64
-    std::stringstream uriStream(imageURI);
-    std::string stringData;
-    std::size_t segmentIndex{0};
-    while (std::getline(uriStream, stringData, ',')) {
-      ++segmentIndex;
-    }
-    if (segmentIndex != 2) {
-      throw RnExecutorchError(RnExecutorchErrorCode::FileReadFailed,
-                              "Read image error: invalid base64 URI");
-    }
-    auto data = base64_decode(stringData);
-    cv::Mat encodedData(1, data.size(), CV_8UC1, (void *)data.data());
-    image = cv::imdecode(encodedData, cv::IMREAD_COLOR);
-  } else if (imageURI.starts_with("file")) {
-    // local file
-    auto url = ada::parse(imageURI);
-    image = cv::imread(std::string{url->get_pathname()}, cv::IMREAD_COLOR);
-  } else if (imageURI.starts_with("http")) {
-    // remote file
-    std::vector<std::byte> imageData = fetchUrlFunc(imageURI);
-    image = cv::imdecode(
-        cv::Mat(1, imageData.size(), CV_8UC1, (void *)imageData.data()),
-        cv::IMREAD_COLOR);
-  } else {
-    // fallback to raw base64 content
-    auto data = base64_decode(imageURI);
-    cv::Mat encodedData(1, data.size(), CV_8UC1, (void *)data.data());
-    image = cv::imdecode(encodedData, cv::IMREAD_COLOR);
-  }
-
-  if (image.empty()) {
-    throw RnExecutorchError(RnExecutorchErrorCode::FileReadFailed,
-                            "Read image error: invalid argument");
-  }
-
-  return image;
-}
-
-TensorPtr getTensorFromMatrix(const std::vector<int32_t> &tensorDims,
-                              const cv::Mat &matrix) {
-  return executorch::extension::make_tensor_ptr(tensorDims,
-                                                colorMatToVector(matrix));
-}
-
-TensorPtr getTensorFromMatrix(const std::vector<int32_t> &tensorDims,
-                              const cv::Mat &matrix, cv::Scalar mean,
-                              cv::Scalar variance) {
-  return executorch::extension::make_tensor_ptr(
-      tensorDims, colorMatToVector(matrix, mean, variance));
-}
-
-TensorPtr getTensorFromMatrixGray(const std::vector<int32_t> &tensorDims,
-                                  const cv::Mat &matrix) {
-  return executorch::extension::make_tensor_ptr(tensorDims,
-                                                grayMatToVector(matrix));
-}
-
-std::vector<float> grayMatToVector(const cv::Mat &mat) {
-  CV_Assert(mat.type() == CV_32F);
-  if (mat.isContinuous()) {
-    return {mat.ptr<float>(), mat.ptr<float>() + mat.total()};
-  }
-
-  std::vector<float> v;
-  v.reserve(mat.total());
-  for (int i = 0; i < mat.rows; ++i) {
-    v.insert(v.end(), mat.ptr<float>(i), mat.ptr<float>(i) + mat.cols);
-  }
-  return v;
-}
-
-cv::Mat getMatrixFromTensor(cv::Size size, const Tensor &tensor) {
-  auto resultData = static_cast<const float *>(tensor.const_data_ptr());
-  return bufferToColorMat(std::span<const float>(resultData, tensor.numel()),
-                          size);
-}
-
-cv::Mat resizePadded(const cv::Mat inputImage, cv::Size targetSize) {
-  cv::Size inputSize = inputImage.size();
-  const float heightRatio =
-      static_cast<float>(targetSize.height) / inputSize.height;
-  const float widthRatio =
-      static_cast<float>(targetSize.width) / inputSize.width;
-  const float resizeRatio = std::min(heightRatio, widthRatio);
-  const int newWidth = inputSize.width * resizeRatio;
-  const int newHeight = inputSize.height * resizeRatio;
-  cv::Mat resizedImg;
-  cv::resize(inputImage, resizedImg, cv::Size(newWidth, newHeight), 0, 0,
-             cv::INTER_AREA);
-  constexpr int minCornerPatchSize = 1;
-  constexpr int cornerPatchFractionSize = 30;
-  int cornerPatchSize =
-      std::min(inputSize.height, inputSize.width) / cornerPatchFractionSize;
-  cornerPatchSize = std::max(minCornerPatchSize, cornerPatchSize);
-
-  const std::array<cv::Mat, 4> corners = {
-      inputImage(cv::Rect(0, 0, cornerPatchSize, cornerPatchSize)),
-      inputImage(cv::Rect(inputSize.width - cornerPatchSize, 0, cornerPatchSize,
-                          cornerPatchSize)),
-      inputImage(cv::Rect(0, inputSize.height - cornerPatchSize,
-                          cornerPatchSize, cornerPatchSize)),
-      inputImage(cv::Rect(inputSize.width - cornerPatchSize,
-                          inputSize.height - cornerPatchSize, cornerPatchSize,
-                          cornerPatchSize))};
-
-  // We choose the color of the padding based on a mean of colors in the corners
-  // of an image.
-  cv::Scalar backgroundScalar = cv::mean(corners[0]);
-#pragma unroll
-  for (size_t i = 1; i < corners.size(); i++) {
-    backgroundScalar += cv::mean(corners[i]);
-  }
-  backgroundScalar /= static_cast<double>(corners.size());
-
-  constexpr size_t numChannels = 3;
-#pragma unroll
-  for (size_t i = 0; i < numChannels; ++i) {
-    backgroundScalar[i] = cvFloor(backgroundScalar[i]);
-  }
-
-  const int deltaW = targetSize.width - newWidth;
-  const int deltaH = targetSize.height - newHeight;
-  const int top = deltaH / 2;
-  const int bottom = deltaH - top;
-  const int left = deltaW / 2;
-  const int right = deltaW - left;
-
-  cv::Mat centeredImg;
-  cv::copyMakeBorder(resizedImg, centeredImg, top, bottom, left, right,
-                     cv::BORDER_CONSTANT, backgroundScalar);
-
-  return centeredImg;
-}
-
-std::pair<TensorPtr, cv::Size>
-readImageToTensor(const std::string &path,
-                  const std::vector<int32_t> &tensorDims,
-                  bool maintainAspectRatio, std::optional<cv::Scalar> normMean,
-                  std::optional<cv::Scalar> normStd) {
-  cv::Mat input = image_processing::readImage(path);
-  cv::Size imageSize = input.size();
-
-  if (tensorDims.size() < 2) {
-    char errorMessage[100];
-    std::snprintf(errorMessage, sizeof(errorMessage),
-                  "Unexpected tensor size, expected at least 2 dimensions "
-                  "but got: %zu.",
-                  tensorDims.size());
-    throw RnExecutorchError(RnExecutorchErrorCode::UnexpectedNumInputs,
-                            errorMessage);
-  }
-  cv::Size tensorSize = cv::Size(tensorDims[tensorDims.size() - 1],
-                                 tensorDims[tensorDims.size() - 2]);
-
-  if (maintainAspectRatio) {
-    input = resizePadded(input, tensorSize);
-  } else {
-    cv::resize(input, input, tensorSize);
-  }
-
-  cv::cvtColor(input, input, cv::COLOR_BGR2RGB);
-
-  if (normMean.has_value() && normStd.has_value()) {
-    return {image_processing::getTensorFromMatrix(
-                tensorDims, input, normMean.value(), normStd.value()),
-            imageSize};
-  }
-  return {image_processing::getTensorFromMatrix(tensorDims, input), imageSize};
-}
-
-cv::Mat applySigmoid(const cv::Mat &logits) {
-  cv::Mat probMat;
-  cv::exp(-logits, probMat);
-  probMat = 255.0f / (1.0f + probMat);
-  probMat.convertTo(probMat, CV_8UC1);
-  return probMat;
-}
-} // namespace image_processing
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/data_processing/ImageProcessing.h b/packages/react-native-executorch/common/rnexecutorch/data_processing/ImageProcessing.h
deleted file mode 100644
index 8b371f87e3..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/data_processing/ImageProcessing.h
+++ /dev/null
@@ -1,63 +0,0 @@
-#pragma once
-
-#include <executorch/extension/tensor/tensor.h>
-#include <executorch/extension/tensor/tensor_ptr.h>
-#include <opencv2/opencv.hpp>
-#include <optional>
-#include <span>
-#include <string>
-#include <vector>
-
-namespace rnexecutorch::image_processing {
-using executorch::aten::Tensor;
-using executorch::extension::TensorPtr;
-
-/// @brief Convert a OpenCV matrix to channel-first vector representation
-std::vector<float> colorMatToVector(const cv::Mat &mat, cv::Scalar mean,
-                                    cv::Scalar variance);
-/// @brief Convert a OpenCV matrix to channel-first vector representation
-std::vector<float> colorMatToVector(const cv::Mat &mat);
-/// @brief Convert a channel-first representation of an RGB image to OpenCV
-/// matrix
-cv::Mat bufferToColorMat(const std::span<const float> &buffer,
-                         cv::Size matSize);
-std::string saveToTempFile(const cv::Mat &image);
-/// @brief Read image in a BGR format to a cv::Mat
-cv::Mat readImage(const std::string &imageURI);
-TensorPtr getTensorFromMatrix(const std::vector<int32_t> &tensorDims,
-                              const cv::Mat &mat);
-TensorPtr getTensorFromMatrix(const std::vector<int32_t> &tensorDims,
-                              const cv::Mat &matrix, cv::Scalar mean,
-                              cv::Scalar variance);
-cv::Mat getMatrixFromTensor(cv::Size size, const Tensor &tensor);
-TensorPtr getTensorFromMatrixGray(const std::vector<int32_t> &tensorDims,
-                                  const cv::Mat &matrix);
-std::vector<float> grayMatToVector(const cv::Mat &mat);
-/**
- * @brief Resizes an image to fit within target dimensions while preserving
- * aspect ratio, adding padding if needed. Padding color is derived from the
- * image's corner pixels for seamless blending.
- */
-cv::Mat resizePadded(const cv::Mat inputImage, cv::Size targetSize);
-/// @brief Read image, resize it and copy it to an ET tensor to store it.
-/// @param path Path to the image to be resized. Could be base64, local file or
-/// remote URL
-/// @param tensorDims The dimensions of the result tensor. The two last
-/// dimensions are taken as the image resolution.
-/// @param maintainAspectRatio If set to true the image will be resized to
-/// maintain the original aspect ratio. The rest of the tensor will be filled
-/// padding.
-/// @return Returns a tensor pointer and the original size of the image.
-std::pair<TensorPtr, cv::Size>
-readImageToTensor(const std::string &path,
-                  const std::vector<int32_t> &tensorDims,
-                  bool maintainAspectRatio = false,
-                  std::optional<cv::Scalar> normMean = std::nullopt,
-                  std::optional<cv::Scalar> normStd = std::nullopt);
-/**
- * @brief Applies sigmoid activation to logits and converts to uint8 binary mask
- * @param logits Input matrix containing raw logits (pre-sigmoid)
- * @return 8-bit unsigned integer matrix with values scaled to [0, 255]
- */
-cv::Mat applySigmoid(const cv::Mat &logits);
-} // namespace rnexecutorch::image_processing
diff --git a/packages/react-native-executorch/common/rnexecutorch/data_processing/Numerical.cpp b/packages/react-native-executorch/common/rnexecutorch/data_processing/Numerical.cpp
deleted file mode 100644
index 4b19cc99ba..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/data_processing/Numerical.cpp
+++ /dev/null
@@ -1,115 +0,0 @@
-#include "Numerical.h"
-
-#include <algorithm>
-#include <cmath>
-#include <limits>
-#include <numeric>
-#include <sstream>
-#include <string>
-
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-
-namespace rnexecutorch::numerical {
-
-void softmax(std::span<float> input) {
-  if (input.empty()) {
-    return;
-  }
-
-  const auto maxElement = *std::ranges::max_element(input);
-
-  for (auto &value : input) {
-    value = std::exp(value - maxElement);
-  }
-
-  const auto sum = std::reduce(input.begin(), input.end());
-
-  // sum is at least 1 since exp(max - max) == exp(0) == 1
-  for (auto &value : input) {
-    value /= sum;
-  }
-}
-
-void softmaxWithTemperature(std::span<float> input, float temperature) {
-  if (input.empty()) {
-    return;
-  }
-
-  if (temperature <= 0.0F) {
-    throw RnExecutorchError(
-        RnExecutorchErrorCode::InvalidConfig,
-        "Temperature must be greater than 0 for softmax with temperature!");
-  }
-
-  const auto maxElement = *std::ranges::max_element(input);
-
-  for (auto &value : input) {
-    value = std::exp((value - maxElement) / temperature);
-  }
-
-  const auto sum = std::reduce(input.begin(), input.end());
-
-  // sum is at least 1 since exp(max - max) == exp(0) == 1
-  for (auto &value : input) {
-    value /= sum;
-  }
-}
-
-void normalize(std::span<float> input) {
-  const auto sumOfSquares =
-      std::inner_product(input.begin(), input.end(), input.begin(), 0.0F);
-
-  constexpr auto kEpsilon = 1.0e-15F;
-
-  const auto norm = std::sqrt(sumOfSquares) + kEpsilon;
-
-  for (auto &value : input) {
-    value /= norm;
-  }
-}
-
-std::vector<float> meanPooling(std::span<const float> modelOutput,
-                               std::span<const int64_t> attnMask) {
-  if (attnMask.empty() || modelOutput.size() % attnMask.size() != 0) {
-    std::stringstream ss;
-    ss << "Invalid dimensions for mean pooling, expected model output size to "
-          "be divisible "
-       << "by the size of attention mask but got size: " << modelOutput.size()
-       << " for model output and size: " << attnMask.size()
-       << " for attention mask";
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidConfig, ss.str());
-  }
-
-  auto attnMaskLength = attnMask.size();
-  auto embeddingDim = modelOutput.size() / attnMaskLength;
-
-  auto maskSum = std::reduce(attnMask.begin(), attnMask.end());
-  std::vector<float> result(embeddingDim, 0.0F);
-  if (maskSum == 0LL) {
-    return result;
-  }
-
-  for (std::size_t i = 0; i < attnMaskLength; ++i) {
-    if (attnMask[i] != 0LL) {
-      for (std::size_t j = 0; j < embeddingDim; ++j) {
-        result[j] += modelOutput[i * embeddingDim + j];
-      }
-    }
-  }
-
-  for (auto &value : result) {
-    value /= static_cast<float>(maskSum);
-  }
-
-  return result;
-}
-
-template <typename T> bool isClose(T a, T b, T atol) {
-  return std::abs(a - b) <= atol;
-}
-
-template bool isClose<float>(float, float, float);
-template bool isClose<double>(double, double, double);
-
-} // namespace rnexecutorch::numerical
diff --git a/packages/react-native-executorch/common/rnexecutorch/data_processing/Numerical.h b/packages/react-native-executorch/common/rnexecutorch/data_processing/Numerical.h
deleted file mode 100644
index 3a292cfbbf..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/data_processing/Numerical.h
+++ /dev/null
@@ -1,77 +0,0 @@
-#pragma once
-
-#include <span>
-#include <vector>
-
-/**
- * @namespace rnexecutorch::numerical
- * @brief Namespace for numerical operations and transformations.
- */
-namespace rnexecutorch::numerical {
-
-/**
- * @brief Applies the softmax function in-place to a sequence of numbers.
- *
- * @param input A mutable span of floating-point numbers. After the function
- * returns, `input` contains the softmax probabilities.
- */
-void softmax(std::span<float> input);
-
-/**
- * @brief Applies the softmax function with temperature scaling in-place to a
- * sequence of numbers.
- *
- * The temperature parameter controls the "sharpness" of the resulting
- * probability distribution. A temperature of 1.0 means no scaling, while lower
- * values make the distribution sharper (more peaked), and higher values make it
- * softer (more uniform).
- *
- * @param input A mutable span of floating-point numbers. After the function
- * returns, `input` contains the softmax probabilities.
- * @param temperature A positive float value used to scale the logits before
- * applying softmax. Must be greater than 0.
- */
-void softmaxWithTemperature(std::span<float> input, float temperature);
-
-/**
- * @brief Normalizes the elements of the given float span in-place using the
- * L2 norm method.
- *
- * This function scales the input vector such that its L2 norm (Euclidean norm)
- * becomes 1. If the norm is zero, the result is a zero vector with the same
- * size as the input.
- *
- * @param input A mutable span of floating-point values representing the data to
- * be normalized.
- */
-void normalize(std::span<float> input);
-
-/**
- * @brief Computes mean pooling across the modelOutput adjusted by an attention
- * mask.
- *
- * This function aggregates the `modelOutput` span by sections defined by
- * `attnMask`, computing the mean of sections influenced by the mask. The result
- * is a vector where each element is the mean of a segment from the original
- * data.
- *
- * @param modelOutput A span of floating-point numbers representing the model
- * output.
- * @param attnMask A span of integers where each integer is a weight
- * corresponding to the elements in `modelOutput`.
- * @return A std::vector<float> containing the computed mean values of segments.
- */
-std::vector<float> meanPooling(std::span<const float> modelOutput,
-                               std::span<const int64_t> attnMask);
-
-/**
- * @brief Checks if two floating-point numbers are considered equal.
- */
-template <typename T>
-bool isClose(T a, T b,
-             T atol = std::numeric_limits<T>::epsilon() * static_cast<T>(10));
-
-extern template bool isClose<float>(float, float, float);
-extern template bool isClose<double>(double, double, double);
-
-} // namespace rnexecutorch::numerical
diff --git a/packages/react-native-executorch/common/rnexecutorch/data_processing/Sequential.h b/packages/react-native-executorch/common/rnexecutorch/data_processing/Sequential.h
deleted file mode 100644
index a872352f68..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/data_processing/Sequential.h
+++ /dev/null
@@ -1,53 +0,0 @@
-#pragma once
-
-#include <algorithm>
-#include <concepts>
-#include <numeric>
-#include <span>
-#include <vector>
-
-/**
- * @namespace rnexecutorch::sequential
- * @brief Namespace for non-modifying sequential operations
- */
-namespace rnexecutorch::sequential {
-
-/**
- * @brief Repeats each element of a one-dimensional data vector according to the
- * specified repetition counts.
- *
- * This function operates on one-dimensional input data and a corresponding
- * vector of repetition counts. For each i-th element in `data`, the function
- * appends it to the output vector `repetitions[i]` times. For example, given
- * `data = [0, 1, 2]` and `repetitions = [2, 1, 2]`, the result will be `[0, 0,
- * 1, 2, 2]`.
- *
- * @param data A span of input elements to be repeated.
- * @param repetitions A span of integral values specifying how many times to
- * repeat each corresponding element in `data`.
- * @return A std::vector<T> containing the repeated elements in order.
- */
-template <typename T, std::integral IType>
-std::vector<T> repeatInterleave(std::span<const T> data,
-                                std::span<const IType> repetitions) {
-  if (data.size() != repetitions.size()) {
-    throw std::invalid_argument(
-        "repeatInterleave(): repetitions vector must be the same size as data,"
-        " expected " +
-        std::to_string(data.size()) + " but got " +
-        std::to_string(repetitions.size()));
-  }
-
-  IType totalReps = std::reduce(repetitions.begin(), repetitions.end());
-  std::vector<T> result(totalReps);
-
-  IType filled = 0;
-  for (size_t i = 0; i < data.size(); i++) {
-    std::fill_n(result.begin() + filled, repetitions[i], data[i]);
-    filled += repetitions[i];
-  }
-
-  return result;
-}
-
-} // namespace rnexecutorch::sequential
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/data_processing/base64.cpp b/packages/react-native-executorch/common/rnexecutorch/data_processing/base64.cpp
deleted file mode 100644
index a79bee9b8f..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/data_processing/base64.cpp
+++ /dev/null
@@ -1,110 +0,0 @@
-#include "base64.h"
-#include <iostream>
-
-static const std::string base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                                        "abcdefghijklmnopqrstuvwxyz"
-                                        "0123456789+/";
-
-static inline bool is_base64(BYTE c) {
-  return (isalnum(c) || (c == '+') || (c == '/'));
-}
-
-std::string base64_encode(BYTE const *buf, unsigned int bufLen) {
-  std::string ret;
-  int i = 0;
-  int j = 0;
-  BYTE char_array_3[3];
-  BYTE char_array_4[4];
-
-  while (bufLen--) {
-    char_array_3[i++] = *(buf++);
-    if (i == 3) {
-      char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
-      char_array_4[1] =
-          ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
-      char_array_4[2] =
-          ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
-      char_array_4[3] = char_array_3[2] & 0x3f;
-
-      for (i = 0; (i < 4); i++) {
-        ret += base64_chars[char_array_4[i]];
-      }
-      i = 0;
-    }
-  }
-
-  if (i) {
-    for (j = i; j < 3; j++) {
-      char_array_3[j] = '\0';
-    }
-
-    char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
-    char_array_4[1] =
-        ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
-    char_array_4[2] =
-        ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
-    char_array_4[3] = char_array_3[2] & 0x3f;
-
-    for (j = 0; (j < i + 1); j++) {
-      ret += base64_chars[char_array_4[j]];
-    }
-
-    while ((i++ < 3)) {
-      ret += '=';
-    }
-  }
-
-  return ret;
-}
-
-std::vector<BYTE> base64_decode(std::string const &encoded_string) {
-  int in_len = encoded_string.size();
-  int i = 0;
-  int j = 0;
-  int in_ = 0;
-  BYTE char_array_4[4], char_array_3[3];
-  std::vector<BYTE> ret;
-
-  while (in_len-- && (encoded_string[in_] != '=') &&
-         is_base64(encoded_string[in_])) {
-    char_array_4[i++] = encoded_string[in_];
-    in_++;
-    if (i == 4) {
-      for (i = 0; i < 4; i++) {
-        char_array_4[i] = base64_chars.find(char_array_4[i]);
-      }
-
-      char_array_3[0] =
-          (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
-      char_array_3[1] =
-          ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
-      char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
-
-      for (i = 0; (i < 3); i++) {
-        ret.push_back(char_array_3[i]);
-      }
-      i = 0;
-    }
-  }
-
-  if (i) {
-    for (j = i; j < 4; j++) {
-      char_array_4[j] = 0;
-    }
-
-    for (j = 0; j < 4; j++) {
-      char_array_4[j] = base64_chars.find(char_array_4[j]);
-    }
-
-    char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
-    char_array_3[1] =
-        ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
-    char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
-
-    for (j = 0; (j < i - 1); j++) {
-      ret.push_back(char_array_3[j]);
-    }
-  }
-
-  return ret;
-}
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/data_processing/base64.h b/packages/react-native-executorch/common/rnexecutorch/data_processing/base64.h
deleted file mode 100644
index 5ebaaa84f9..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/data_processing/base64.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
-   base64.cpp and base64.h
-
-   base64 encoding and decoding with C++.
-   More information at
-     https://renenyffenegger.ch/notes/development/Base64/Encoding-and-decoding-base-64-with-cpp
-
-   Version: 2.rc.09 (release candidate)
-
-   Copyright (C) 2004-2017, 2020-2022 René Nyffenegger
-
-   This source code is provided 'as-is', without any express or implied
-   warranty. In no event will the author be held liable for any damages
-   arising from the use of this software.
-
-   Permission is granted to anyone to use this software for any purpose,
-   including commercial applications, and to alter it and redistribute it
-   freely, subject to the following restrictions:
-
-   1. The origin of this source code must not be misrepresented; you must not
-      claim that you wrote the original source code. If you use this source code
-      in a product, an acknowledgment in the product documentation would be
-      appreciated but is not required.
-
-   2. Altered source versions must be plainly marked as such, and must not be
-      misrepresented as being the original source code.
-
-   3. This notice may not be removed or altered from any source distribution.
-
-   René Nyffenegger rene.nyffenegger@adp-gmbh.ch
-
-*/
-
-// Modified version by LihO at https://stackoverflow.com/a/13935718/7470700
-
-#ifndef _BASE64_H_
-#define _BASE64_H_
-
-#include <string>
-#include <vector>
-typedef unsigned char BYTE;
-
-std::string base64_encode(BYTE const *buf, unsigned int bufLen);
-std::vector<BYTE> base64_decode(std::string const &);
-
-#endif
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/data_processing/dsp.cpp b/packages/react-native-executorch/common/rnexecutorch/data_processing/dsp.cpp
deleted file mode 100644
index 38282883f3..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/data_processing/dsp.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include <cmath>
-#include <cstddef>
-#include <numbers>
-#include <vector>
-
-#include <rnexecutorch/data_processing/FFT.h>
-#include <rnexecutorch/data_processing/dsp.h>
-
-namespace rnexecutorch::dsp {
-
-using std::numbers::pi_v;
-
-//https://www.mathworks.com/help/signal/ref/hann.html
-std::vector<float> hannWindow(size_t size) {
-  std::vector<float> window(size); 
-  for (size_t i = 0; i < size; i++) { 
-    window[i] = 0.5f * (1.0f - std::cosf(2.0f * pi_v<float> * static_cast<float>(i) / static_cast<float>(size)));
-  } 
-  return window; 
-} 
-
-} // namespace rnexecutorch::dsp
diff --git a/packages/react-native-executorch/common/rnexecutorch/data_processing/dsp.h b/packages/react-native-executorch/common/rnexecutorch/data_processing/dsp.h
deleted file mode 100644
index 7eaa26d831..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/data_processing/dsp.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-#include <span>
-#include <vector>
-
-namespace rnexecutorch::dsp {
-
-std::vector<float> hannWindow(size_t size);
-std::vector<float> stftFromWaveform(std::span<const float> waveform,
-                                    size_t fftWindowSize, size_t hopSize);
-
-} // namespace rnexecutorch::dsp
diff --git a/packages/react-native-executorch/common/rnexecutorch/data_processing/gzip.cpp b/packages/react-native-executorch/common/rnexecutorch/data_processing/gzip.cpp
deleted file mode 100644
index aeda796d0b..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/data_processing/gzip.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-#include <vector>
-#include <zlib.h>
-
-#include "gzip.h"
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-
-namespace rnexecutorch::gzip {
-
-namespace {
-constexpr int32_t kGzipWrapper = 16;     // gzip header/trailer
-constexpr int32_t kMemLevel = 8;         // memory level
-constexpr size_t kChunkSize = 16 * 1024; // 16 KiB stream buffer
-} // namespace
-
-size_t deflateSize(const std::string &input) {
-  z_stream strm{};
-  if (::deflateInit2(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
-                     MAX_WBITS + kGzipWrapper, kMemLevel,
-                     Z_DEFAULT_STRATEGY) != Z_OK) {
-    throw RnExecutorchError(RnExecutorchErrorCode::UnknownError,
-                            "deflateInit2 failed");
-  }
-
-  size_t outSize = 0;
-
-  strm.next_in = reinterpret_cast<z_const Bytef *>(
-      const_cast<z_const char *>(input.data()));
-  strm.avail_in = static_cast<uInt>(input.size());
-
-  std::vector<unsigned char> buf(kChunkSize);
-  int ret;
-  do {
-    strm.next_out = buf.data();
-    strm.avail_out = static_cast<uInt>(buf.size());
-
-    ret = ::deflate(&strm, strm.avail_in ? Z_NO_FLUSH : Z_FINISH);
-    if (ret == Z_STREAM_ERROR) {
-      ::deflateEnd(&strm);
-      throw RnExecutorchError(RnExecutorchErrorCode::UnknownError,
-                              "deflate stream error");
-    }
-
-    outSize += buf.size() - strm.avail_out;
-  } while (ret != Z_STREAM_END);
-
-  ::deflateEnd(&strm);
-  return outSize;
-}
-
-} // namespace rnexecutorch::gzip
diff --git a/packages/react-native-executorch/common/rnexecutorch/data_processing/gzip.h b/packages/react-native-executorch/common/rnexecutorch/data_processing/gzip.h
deleted file mode 100644
index 73890e1f94..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/data_processing/gzip.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#pragma once
-
-namespace rnexecutorch::gzip {
-
-size_t deflateSize(const std::string &input);
-
-} // namespace rnexecutorch::gzip
diff --git a/packages/react-native-executorch/common/rnexecutorch/host_objects/JSTensorViewIn.h b/packages/react-native-executorch/common/rnexecutorch/host_objects/JSTensorViewIn.h
deleted file mode 100644
index 1eb288ee30..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/host_objects/JSTensorViewIn.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#pragma once
-
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <vector>
-
-namespace rnexecutorch {
-
-using executorch::aten::ScalarType;
-
-struct JSTensorViewIn {
-  void *dataPtr;
-  std::vector<int32_t> sizes;
-  ScalarType scalarType;
-};
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/host_objects/JSTensorViewOut.h b/packages/react-native-executorch/common/rnexecutorch/host_objects/JSTensorViewOut.h
deleted file mode 100644
index 5d2f885021..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/host_objects/JSTensorViewOut.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#pragma once
-
-#include <executorch/runtime/core/portable_type/scalar_type.h>
-#include <memory>
-#include <rnexecutorch/jsi/OwningArrayBuffer.h>
-#include <vector>
-
-namespace rnexecutorch {
-
-using executorch::runtime::etensor::ScalarType;
-
-struct JSTensorViewOut {
-  std::shared_ptr<OwningArrayBuffer> dataPtr;
-  std::vector<int32_t> sizes;
-  ScalarType scalarType;
-
-  JSTensorViewOut(std::vector<int32_t> sizes, ScalarType scalarType,
-                  std::shared_ptr<OwningArrayBuffer> dataPtr)
-      : dataPtr(std::move(dataPtr)), sizes(std::move(sizes)),
-        scalarType(scalarType) {}
-};
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/host_objects/JsiConversions.h b/packages/react-native-executorch/common/rnexecutorch/host_objects/JsiConversions.h
deleted file mode 100644
index e4209b2f79..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/host_objects/JsiConversions.h
+++ /dev/null
@@ -1,745 +0,0 @@
-#pragma once
-
-#include <codecvt>
-#include <cstdint>
-#include <set>
-#include <span>
-#include <string>
-#include <type_traits>
-#include <unordered_map>
-#include <variant>
-#include <vector>
-
-#include <executorch/runtime/core/exec_aten/util/scalar_type_util.h>
-#include <jsi/jsi.h>
-#include <rnexecutorch/host_objects/JSTensorViewIn.h>
-#include <rnexecutorch/host_objects/JSTensorViewOut.h>
-#include <rnexecutorch/jsi/OwningArrayBuffer.h>
-
-#include <rnexecutorch/metaprogramming/TypeConcepts.h>
-#include <rnexecutorch/models/instance_segmentation/Types.h>
-#include <rnexecutorch/models/llm/Types.h>
-#include <rnexecutorch/models/object_detection/Constants.h>
-#include <rnexecutorch/models/object_detection/Types.h>
-#include <rnexecutorch/models/ocr/Types.h>
-#include <rnexecutorch/models/pose_estimation/Types.h>
-#include <rnexecutorch/models/privacy_filter/Types.h>
-#include <rnexecutorch/models/semantic_segmentation/Types.h>
-#include <rnexecutorch/models/speech_to_text/common/types/Segment.h>
-#include <rnexecutorch/models/speech_to_text/common/types/TranscriptionResult.h>
-#include <rnexecutorch/models/style_transfer/Types.h>
-#include <rnexecutorch/models/voice_activity_detection/Types.h>
-#include <rnexecutorch/utils/computer_vision/Types.h>
-
-using namespace rnexecutorch::models::speech_to_text;
-
-namespace rnexecutorch::jsi_conversion {
-
-using namespace facebook;
-
-// Conversion from jsi to C++ types --------------------------------------------
-
-template <typename T> T getValue(const jsi::Value &val, jsi::Runtime &runtime);
-
-template <typename T>
-  requires meta::IsNumeric<T>
-inline T getValue(const jsi::Value &val, jsi::Runtime &runtime) {
-  return static_cast<T>(val.asNumber());
-}
-
-template <>
-inline bool getValue<bool>(const jsi::Value &val, jsi::Runtime &runtime) {
-  return val.asBool();
-}
-
-template <>
-inline std::string getValue<std::string>(const jsi::Value &val,
-                                         jsi::Runtime &runtime) {
-  return val.getString(runtime).utf8(runtime);
-}
-
-template <>
-inline std::u32string getValue<std::u32string>(const jsi::Value &val,
-                                               jsi::Runtime &runtime) {
-  std::string utf8 = getValue<std::string>(val, runtime);
-  std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> conv;
-
-  return conv.from_bytes(utf8);
-}
-
-template <>
-inline std::shared_ptr<jsi::Function>
-getValue<std::shared_ptr<jsi::Function>>(const jsi::Value &val,
-                                         jsi::Runtime &runtime) {
-  return std::make_shared<jsi::Function>(
-      val.asObject(runtime).asFunction(runtime));
-}
-
-template <>
-inline JSTensorViewIn getValue<JSTensorViewIn>(const jsi::Value &val,
-                                               jsi::Runtime &runtime) {
-  jsi::Object obj = val.asObject(runtime);
-  JSTensorViewIn tensorView;
-
-  int scalarTypeInt = obj.getProperty(runtime, "scalarType").asNumber();
-  tensorView.scalarType = static_cast<ScalarType>(scalarTypeInt);
-
-  jsi::Value shapeValue = obj.getProperty(runtime, "sizes");
-  jsi::Array shapeArray = shapeValue.asObject(runtime).asArray(runtime);
-  size_t numShapeDims = shapeArray.size(runtime);
-  tensorView.sizes.reserve(numShapeDims);
-
-  for (size_t i = 0; i < numShapeDims; ++i) {
-    int32_t dim =
-        getValue<int32_t>(shapeArray.getValueAtIndex(runtime, i), runtime);
-    tensorView.sizes.push_back(dim);
-  }
-
-  // On JS side, TensorPtr objects hold a 'data' property which should be either
-  // an ArrayBuffer or TypedArray
-  jsi::Value dataValue = obj.getProperty(runtime, "dataPtr");
-  jsi::Object dataObj = dataValue.asObject(runtime);
-
-  // Check if it's an ArrayBuffer or TypedArray
-  if (dataObj.isArrayBuffer(runtime)) {
-    jsi::ArrayBuffer arrayBuffer = dataObj.getArrayBuffer(runtime);
-    tensorView.dataPtr = arrayBuffer.data(runtime);
-  } else {
-    // Handle typed arrays (Float32Array, Int32Array, etc.)
-    const bool isValidTypedArray = dataObj.hasProperty(runtime, "buffer") &&
-                                   dataObj.hasProperty(runtime, "byteOffset") &&
-                                   dataObj.hasProperty(runtime, "byteLength") &&
-                                   dataObj.hasProperty(runtime, "length");
-    if (!isValidTypedArray) {
-      throw jsi::JSError(runtime, "Data must be an ArrayBuffer or TypedArray");
-    }
-    jsi::Value bufferValue = dataObj.getProperty(runtime, "buffer");
-    if (!bufferValue.isObject() ||
-        !bufferValue.asObject(runtime).isArrayBuffer(runtime)) {
-      throw jsi::JSError(runtime,
-                         "TypedArray buffer property must be an ArrayBuffer");
-    }
-
-    jsi::ArrayBuffer arrayBuffer =
-        bufferValue.asObject(runtime).getArrayBuffer(runtime);
-    size_t byteOffset =
-        getValue<int>(dataObj.getProperty(runtime, "byteOffset"), runtime);
-
-    tensorView.dataPtr =
-        static_cast<uint8_t *>(arrayBuffer.data(runtime)) + byteOffset;
-  }
-  return tensorView;
-}
-
-// C++ set from JS array. Set with heterogenerous look-up (adding std::less<>
-// enables querying with std::string_view).
-template <>
-inline std::set<std::string, std::less<>>
-getValue<std::set<std::string, std::less<>>>(const jsi::Value &val,
-                                             jsi::Runtime &runtime) {
-
-  jsi::Array array = val.asObject(runtime).asArray(runtime);
-  size_t length = array.size(runtime);
-  std::set<std::string, std::less<>> result;
-
-  for (size_t i = 0; i < length; ++i) {
-    jsi::Value element = array.getValueAtIndex(runtime, i);
-    result.insert(getValue<std::string>(element, runtime));
-  }
-  return result;
-}
-
-// Helper function to convert typed arrays to std::span
-template <typename T>
-inline std::span<T> getTypedArrayAsSpan(const jsi::Value &val,
-                                        jsi::Runtime &runtime) {
-  jsi::Object obj = val.asObject(runtime);
-
-  const bool isValidTypedArray = obj.hasProperty(runtime, "buffer") &&
-                                 obj.hasProperty(runtime, "byteOffset") &&
-                                 obj.hasProperty(runtime, "byteLength") &&
-                                 obj.hasProperty(runtime, "length");
-  if (!isValidTypedArray) {
-    throw jsi::JSError(runtime, "Value must be a TypedArray");
-  }
-
-  // Get the underlying ArrayBuffer
-  jsi::Value bufferValue = obj.getProperty(runtime, "buffer");
-  if (!bufferValue.isObject() ||
-      !bufferValue.asObject(runtime).isArrayBuffer(runtime)) {
-    throw jsi::JSError(runtime,
-                       "TypedArray buffer property must be an ArrayBuffer");
-  }
-
-  jsi::ArrayBuffer arrayBuffer =
-      bufferValue.asObject(runtime).getArrayBuffer(runtime);
-  size_t byteOffset =
-      getValue<size_t>(obj.getProperty(runtime, "byteOffset"), runtime);
-  size_t length = getValue<size_t>(obj.getProperty(runtime, "length"), runtime);
-
-  T *dataPtr = reinterpret_cast<T *>(
-      static_cast<uint8_t *>(arrayBuffer.data(runtime)) + byteOffset);
-
-  return {dataPtr, length};
-}
-
-template <typename T>
-inline std::vector<T> getArrayAsVector(const jsi::Value &val,
-                                       jsi::Runtime &runtime) {
-  jsi::Array array = val.asObject(runtime).asArray(runtime);
-  const size_t length = array.size(runtime);
-  std::vector<T> result;
-  result.reserve(length);
-
-  for (size_t i = 0; i < length; ++i) {
-    const jsi::Value element = array.getValueAtIndex(runtime, i);
-    result.push_back(getValue<T>(element, runtime));
-  }
-  return result;
-}
-
-// Template specializations for std::vector<T> types
-template <>
-inline std::vector<JSTensorViewIn>
-getValue<std::vector<JSTensorViewIn>>(const jsi::Value &val,
-                                      jsi::Runtime &runtime) {
-  return getArrayAsVector<JSTensorViewIn>(val, runtime);
-}
-
-template <>
-inline std::vector<std::string>
-getValue<std::vector<std::string>>(const jsi::Value &val,
-                                   jsi::Runtime &runtime) {
-  return getArrayAsVector<std::string>(val, runtime);
-}
-
-template <>
-inline std::vector<int32_t>
-getValue<std::vector<int32_t>>(const jsi::Value &val, jsi::Runtime &runtime) {
-  return getArrayAsVector<int32_t>(val, runtime);
-}
-
-template <>
-inline std::vector<float> getValue<std::vector<float>>(const jsi::Value &val,
-                                                       jsi::Runtime &runtime) {
-  return getArrayAsVector<float>(val, runtime);
-}
-
-template <>
-inline std::vector<std::vector<float>>
-getValue<std::vector<std::vector<float>>>(const jsi::Value &val,
-                                          jsi::Runtime &runtime) {
-  jsi::Array array = val.asObject(runtime).asArray(runtime);
-  const size_t length = array.size(runtime);
-  std::vector<std::vector<float>> result;
-  result.reserve(length);
-  for (size_t i = 0; i < length; ++i) {
-    jsi::Value element = array.getValueAtIndex(runtime, i);
-    auto span = getTypedArrayAsSpan<float>(element, runtime);
-    result.emplace_back(span.begin(), span.end());
-  }
-  return result;
-}
-
-template <>
-inline std::vector<int64_t>
-getValue<std::vector<int64_t>>(const jsi::Value &val, jsi::Runtime &runtime) {
-  return getArrayAsVector<int64_t>(val, runtime);
-}
-
-template <>
-inline std::vector<uint64_t>
-getValue<std::vector<uint64_t>>(const jsi::Value &val, jsi::Runtime &runtime) {
-  return getArrayAsVector<uint64_t>(val, runtime);
-}
-
-// Template specializations for std::span<T> types
-template <>
-inline std::span<float> getValue<std::span<float>>(const jsi::Value &val,
-                                                   jsi::Runtime &runtime) {
-  return getTypedArrayAsSpan<float>(val, runtime);
-}
-
-template <>
-inline std::span<const float>
-getValue<std::span<const float>>(const jsi::Value &val, jsi::Runtime &runtime) {
-  return getTypedArrayAsSpan<float>(val, runtime);
-}
-
-template <>
-inline std::span<double> getValue<std::span<double>>(const jsi::Value &val,
-                                                     jsi::Runtime &runtime) {
-  return getTypedArrayAsSpan<double>(val, runtime);
-}
-
-template <>
-inline std::span<int32_t> getValue<std::span<int32_t>>(const jsi::Value &val,
-                                                       jsi::Runtime &runtime) {
-  return getTypedArrayAsSpan<int32_t>(val, runtime);
-}
-
-template <>
-inline std::span<uint32_t>
-getValue<std::span<uint32_t>>(const jsi::Value &val, jsi::Runtime &runtime) {
-  return getTypedArrayAsSpan<uint32_t>(val, runtime);
-}
-
-template <>
-inline std::span<int16_t> getValue<std::span<int16_t>>(const jsi::Value &val,
-                                                       jsi::Runtime &runtime) {
-  return getTypedArrayAsSpan<int16_t>(val, runtime);
-}
-
-template <>
-inline std::span<uint16_t>
-getValue<std::span<uint16_t>>(const jsi::Value &val, jsi::Runtime &runtime) {
-  return getTypedArrayAsSpan<uint16_t>(val, runtime);
-}
-
-template <>
-inline std::span<int8_t> getValue<std::span<int8_t>>(const jsi::Value &val,
-                                                     jsi::Runtime &runtime) {
-  return getTypedArrayAsSpan<int8_t>(val, runtime);
-}
-
-template <>
-inline std::span<uint8_t> getValue<std::span<uint8_t>>(const jsi::Value &val,
-                                                       jsi::Runtime &runtime) {
-  return getTypedArrayAsSpan<uint8_t>(val, runtime);
-}
-
-template <>
-inline std::span<int64_t> getValue<std::span<int64_t>>(const jsi::Value &val,
-                                                       jsi::Runtime &runtime) {
-  return getTypedArrayAsSpan<int64_t>(val, runtime);
-}
-
-template <>
-inline std::span<uint64_t>
-getValue<std::span<uint64_t>>(const jsi::Value &val, jsi::Runtime &runtime) {
-  return getTypedArrayAsSpan<uint64_t>(val, runtime);
-}
-
-template <>
-inline models::llm::MultimodalInputs
-getValue<models::llm::MultimodalInputs>(const jsi::Value &val,
-                                        jsi::Runtime &runtime) {
-  models::llm::MultimodalInputs multimodalInputs;
-  jsi::Object obj = val.asObject(runtime);
-
-  jsi::Value v = obj.getProperty(runtime, "imageToken");
-  if (!v.isUndefined() && !v.isNull()) {
-    auto &images = multimodalInputs.images.emplace();
-    images.token = getValue<std::string>(v, runtime);
-    v = obj.getProperty(runtime, "imagePaths");
-    images.paths = getValue<std::vector<std::string>>(v, runtime);
-  }
-  v = obj.getProperty(runtime, "audioToken");
-  if (!v.isUndefined() && !v.isNull()) {
-    auto &audios = multimodalInputs.audios.emplace();
-    audios.token = getValue<std::string>(v, runtime);
-    v = obj.getProperty(runtime, "audioWaveforms");
-    audios.waveforms = getValue<std::vector<std::vector<float>>>(v, runtime);
-  }
-
-  return multimodalInputs;
-}
-
-// Conversion from C++ types to jsi --------------------------------------------
-
-// Implementation functions might return any type, but in a promise we can only
-// return jsi::Value or jsi::Object. For each type being returned
-// we add a function here.
-
-inline jsi::Value getJsiValue(std::shared_ptr<jsi::Object> valuePtr,
-                              jsi::Runtime &runtime) {
-  return std::move(*valuePtr);
-}
-
-inline jsi::Value getJsiValue(const std::vector<int32_t> &vec,
-                              jsi::Runtime &runtime) {
-  jsi::Array array(runtime, vec.size());
-  for (size_t i = 0; i < vec.size(); i++) {
-    array.setValueAtIndex(runtime, i, jsi::Value(static_cast<int>(vec[i])));
-  }
-  return {runtime, array};
-}
-
-inline jsi::Value getJsiValue(const std::vector<uint64_t> &vec,
-                              jsi::Runtime &runtime) {
-  jsi::Array array(runtime, vec.size());
-  for (size_t i = 0; i < vec.size(); i++) {
-    array.setValueAtIndex(runtime, i, jsi::Value(static_cast<double>(vec[i])));
-  }
-  return {runtime, array};
-}
-
-inline jsi::Value getJsiValue(const std::vector<float> &vec,
-                              jsi::Runtime &runtime) {
-  jsi::Array array(runtime, vec.size());
-  for (size_t i = 0; i < vec.size(); i++) {
-    array.setValueAtIndex(runtime, i, jsi::Value(vec[i]));
-  }
-  return {runtime, array};
-}
-
-inline jsi::Value getJsiValue(const std::vector<std::string> &vec,
-                              jsi::Runtime &runtime) {
-  jsi::Array array(runtime, vec.size());
-  for (size_t i = 0; i < vec.size(); i++) {
-    array.setValueAtIndex(runtime, i,
-                          jsi::String::createFromUtf8(runtime, vec[i]));
-  }
-  return {runtime, array};
-}
-
-inline jsi::Value getJsiValue(const std::vector<char> &vec,
-                              jsi::Runtime &runtime) {
-  jsi::Array array(runtime, vec.size());
-  for (size_t i = 0; i < vec.size(); i++) {
-    array.setValueAtIndex(runtime, i, jsi::Value(vec[i]));
-  }
-  return {runtime, array};
-}
-
-inline jsi::Value getJsiValue(const std::vector<int64_t> &vec,
-                              jsi::Runtime &runtime) {
-  jsi::Array array(runtime, vec.size());
-  for (size_t i = 0; i < vec.size(); i++) {
-    array.setValueAtIndex(runtime, i, jsi::Value(static_cast<double>(vec[i])));
-  }
-  return {runtime, array};
-}
-
-inline jsi::Value getJsiValue(
-    const rnexecutorch::models::pose_estimation::PersonKeypoints &keypoints,
-    jsi::Runtime &runtime) {
-  jsi::Array array(runtime, keypoints.size());
-  for (size_t i = 0; i < keypoints.size(); ++i) {
-    jsi::Object point(runtime);
-    point.setProperty(runtime, "x", keypoints[i].x);
-    point.setProperty(runtime, "y", keypoints[i].y);
-    array.setValueAtIndex(runtime, i, point);
-  }
-  return array;
-}
-
-// Pose estimation: all detected people (vector of person keypoints)
-inline jsi::Value getJsiValue(
-    const rnexecutorch::models::pose_estimation::PoseDetections &detections,
-    jsi::Runtime &runtime) {
-  jsi::Array array(runtime, detections.size());
-  for (size_t i = 0; i < detections.size(); ++i) {
-    array.setValueAtIndex(runtime, i, getJsiValue(detections[i], runtime));
-  }
-  return array;
-}
-
-// Conditional as on android, size_t and uint64_t reduce to the same type,
-// introducing ambiguity
-template <typename T,
-          typename = std::enable_if_t<std::is_same_v<T, size_t> &&
-                                      !std::is_same_v<size_t, uint64_t>>>
-inline jsi::Value getJsiValue(T val, jsi::Runtime &runtime) {
-  return jsi::Value(static_cast<double>(val));
-}
-
-inline jsi::Value getJsiValue(uint64_t val, jsi::Runtime &runtime) {
-  jsi::BigInt bigInt = jsi::BigInt::fromUint64(runtime, val);
-  return {runtime, bigInt};
-}
-
-inline jsi::Value getJsiValue(int val, jsi::Runtime &runtime) {
-  return {runtime, val};
-}
-
-inline jsi::Value getJsiValue(bool val, jsi::Runtime &runtime) {
-  return jsi::Value(val);
-}
-
-inline jsi::Value getJsiValue(const std::shared_ptr<OwningArrayBuffer> &buf,
-                              jsi::Runtime &runtime) {
-  jsi::ArrayBuffer arrayBuffer(runtime, buf);
-  return {runtime, arrayBuffer};
-}
-
-inline jsi::Value
-getJsiValue(const std::vector<std::shared_ptr<OwningArrayBuffer>> &vec,
-            jsi::Runtime &runtime) {
-  jsi::Array array(runtime, vec.size());
-  for (size_t i = 0; i < vec.size(); i++) {
-    jsi::ArrayBuffer arrayBuffer(runtime, vec[i]);
-    array.setValueAtIndex(runtime, i, jsi::Value(runtime, arrayBuffer));
-  }
-  return {runtime, array};
-}
-
-inline jsi::Value getJsiValue(const std::vector<JSTensorViewOut> &vec,
-                              jsi::Runtime &runtime) {
-  jsi::Array array(runtime, vec.size());
-  for (size_t i = 0; i < vec.size(); i++) {
-    jsi::Object tensorObj(runtime);
-
-    tensorObj.setProperty(runtime, "sizes", getJsiValue(vec[i].sizes, runtime));
-
-    tensorObj.setProperty(runtime, "scalarType",
-                          jsi::Value(static_cast<int>(vec[i].scalarType)));
-
-    jsi::ArrayBuffer arrayBuffer(runtime, vec[i].dataPtr);
-    tensorObj.setProperty(runtime, "dataPtr", arrayBuffer);
-
-    array.setValueAtIndex(runtime, i, tensorObj);
-  }
-  return {runtime, array};
-}
-
-inline jsi::Value getJsiValue(const std::string &str, jsi::Runtime &runtime) {
-  return jsi::String::createFromUtf8(runtime, str);
-}
-
-inline jsi::Value
-getJsiValue(const std::unordered_map<std::string_view, float> &map,
-            jsi::Runtime &runtime) {
-  jsi::Object mapObj{runtime};
-  for (auto &[k, v] : map) {
-    // The string_view keys must be null-terminated!
-    mapObj.setProperty(runtime, k.data(), v);
-  }
-  return mapObj;
-}
-
-inline jsi::Value getJsiValue(const utils::computer_vision::BBox &bbox,
-                              jsi::Runtime &runtime) {
-  jsi::Object obj(runtime);
-  obj.setProperty(runtime, "x1", bbox.p1.x);
-  obj.setProperty(runtime, "y1", bbox.p1.y);
-  obj.setProperty(runtime, "x2", bbox.p2.x);
-  obj.setProperty(runtime, "y2", bbox.p2.y);
-  return obj;
-}
-
-inline jsi::Value getJsiValue(
-    const std::vector<models::object_detection::types::Detection> &detections,
-    jsi::Runtime &runtime) {
-  jsi::Array array(runtime, detections.size());
-  for (std::size_t i = 0; i < detections.size(); ++i) {
-    jsi::Object detection(runtime);
-    detection.setProperty(runtime, "bbox",
-                          getJsiValue(detections[i].bbox, runtime));
-    detection.setProperty(
-        runtime, "label",
-        jsi::String::createFromUtf8(runtime, detections[i].label));
-    detection.setProperty(runtime, "score", detections[i].score);
-    array.setValueAtIndex(runtime, i, detection);
-  }
-  return array;
-}
-
-inline jsi::Value
-getJsiValue(const std::vector<models::instance_segmentation::types::Instance>
-                &instances,
-            jsi::Runtime &runtime) {
-  jsi::Array array(runtime, instances.size());
-  for (std::size_t i = 0; i < instances.size(); ++i) {
-    jsi::Object instance(runtime);
-
-    instance.setProperty(runtime, "bbox",
-                         getJsiValue(instances[i].bbox, runtime));
-
-    // Mask as Uint8Array - reuse existing OwningArrayBuffer
-    jsi::ArrayBuffer arrayBuffer(runtime, instances[i].mask);
-    auto uint8ArrayCtor =
-        runtime.global().getPropertyAsFunction(runtime, "Uint8Array");
-    auto uint8Array = uint8ArrayCtor.callAsConstructor(runtime, arrayBuffer)
-                          .getObject(runtime);
-    instance.setProperty(runtime, "mask", uint8Array);
-
-    instance.setProperty(runtime, "maskWidth", instances[i].maskWidth);
-    instance.setProperty(runtime, "maskHeight", instances[i].maskHeight);
-
-    instance.setProperty(runtime, "classIndex", instances[i].classIndex);
-
-    instance.setProperty(runtime, "score", instances[i].score);
-
-    array.setValueAtIndex(runtime, i, instance);
-  }
-  return array;
-}
-
-inline jsi::Value
-getJsiValue(const std::vector<models::ocr::types::OCRDetection> &detections,
-            jsi::Runtime &runtime) {
-  auto jsiDetections = jsi::Array(runtime, detections.size());
-  for (size_t i = 0; i < detections.size(); ++i) {
-    const auto &detection = detections[i];
-
-    auto jsiDetectionObject = jsi::Object(runtime);
-
-    jsiDetectionObject.setProperty(runtime, "bbox",
-                                   getJsiValue(detection.bbox, runtime));
-    jsiDetectionObject.setProperty(
-        runtime, "text", jsi::String::createFromUtf8(runtime, detection.text));
-    jsiDetectionObject.setProperty(runtime, "score", detection.score);
-
-    jsiDetections.setValueAtIndex(runtime, i, jsiDetectionObject);
-  }
-
-  return jsiDetections;
-}
-
-inline jsi::Value
-getJsiValue(const std::vector<models::voice_activity_detection::types::Segment>
-                &speechSegments,
-            jsi::Runtime &runtime) {
-  auto jsiSegments = jsi::Array(runtime, speechSegments.size());
-  for (size_t i = 0; i < speechSegments.size(); i++) {
-    const auto &[start, end] = speechSegments[i];
-    auto jsiSegmentObject = jsi::Object(runtime);
-    jsiSegmentObject.setProperty(runtime, "start", static_cast<int>(start));
-    jsiSegmentObject.setProperty(runtime, "end", static_cast<int>(end));
-    jsiSegments.setValueAtIndex(runtime, i, jsiSegmentObject);
-  }
-  return jsiSegments;
-}
-
-inline jsi::Value getJsiValue(
-    const std::vector<models::privacy_filter::types::PiiEntity> &entities,
-    jsi::Runtime &runtime) {
-  auto jsiEntities = jsi::Array(runtime, entities.size());
-  for (size_t i = 0; i < entities.size(); i++) {
-    const auto &e = entities[i];
-    auto obj = jsi::Object(runtime);
-    obj.setProperty(runtime, "label",
-                    jsi::String::createFromUtf8(runtime, e.label));
-    obj.setProperty(runtime, "text",
-                    jsi::String::createFromUtf8(runtime, e.text));
-    obj.setProperty(runtime, "startToken", e.startToken);
-    obj.setProperty(runtime, "endToken", e.endToken);
-    jsiEntities.setValueAtIndex(runtime, i, obj);
-  }
-  return jsiEntities;
-}
-
-inline jsi::Value getJsiValue(const Segment &seg, jsi::Runtime &runtime) {
-  jsi::Object obj(runtime);
-  obj.setProperty(runtime, "start", seg.start);
-  obj.setProperty(runtime, "end", seg.end);
-
-  std::string segText;
-  for (const auto &w : seg.words)
-    segText += w.content;
-  obj.setProperty(runtime, "text",
-                  jsi::String::createFromUtf8(runtime, segText));
-
-  obj.setProperty(runtime, "avgLogprob", seg.avgLogprob);
-  obj.setProperty(runtime, "compressionRatio", seg.compressionRatio);
-  obj.setProperty(runtime, "temperature", seg.temperature);
-
-  jsi::Array wordsArray(runtime, seg.words.size());
-  for (size_t i = 0; i < seg.words.size(); ++i) {
-    jsi::Object wordObj(runtime);
-    wordObj.setProperty(
-        runtime, "word",
-        jsi::String::createFromUtf8(runtime, seg.words[i].content));
-    wordObj.setProperty(runtime, "start",
-                        static_cast<double>(seg.words[i].start));
-    wordObj.setProperty(runtime, "end", static_cast<double>(seg.words[i].end));
-
-    wordsArray.setValueAtIndex(runtime, i, wordObj);
-  }
-  obj.setProperty(runtime, "words", wordsArray);
-
-  jsi::Array tokensArray(runtime, seg.tokens.size());
-  for (size_t i = 0; i < seg.tokens.size(); ++i) {
-    tokensArray.setValueAtIndex(runtime, i, static_cast<double>(seg.tokens[i]));
-  }
-  obj.setProperty(runtime, "tokens", tokensArray);
-
-  return obj;
-}
-
-inline jsi::Value getJsiValue(const TranscriptionResult &result,
-                              jsi::Runtime &runtime) {
-  jsi::Object obj(runtime);
-  obj.setProperty(runtime, "text",
-                  jsi::String::createFromUtf8(runtime, result.text));
-
-  if (!result.segments.empty() || !result.language.empty()) {
-    obj.setProperty(runtime, "task",
-                    jsi::String::createFromUtf8(runtime, result.task));
-    if (!result.language.empty()) {
-      obj.setProperty(runtime, "language",
-                      jsi::String::createFromUtf8(runtime, result.language));
-    }
-    obj.setProperty(runtime, "duration", result.duration);
-
-    jsi::Array segmentsArray(runtime, result.segments.size());
-    for (size_t i = 0; i < result.segments.size(); ++i) {
-      segmentsArray.setValueAtIndex(runtime, i,
-                                    getJsiValue(result.segments[i], runtime));
-    }
-    obj.setProperty(runtime, "segments", segmentsArray);
-  }
-
-  return obj;
-}
-inline jsi::Value
-getJsiValue(const models::style_transfer::PixelDataResult &result,
-            jsi::Runtime &runtime) {
-  jsi::Object obj(runtime);
-
-  auto arrayBuffer = jsi::ArrayBuffer(runtime, result.dataPtr);
-  auto uint8ArrayCtor =
-      runtime.global().getPropertyAsFunction(runtime, "Uint8Array");
-  auto uint8Array =
-      uint8ArrayCtor.callAsConstructor(runtime, arrayBuffer).getObject(runtime);
-  obj.setProperty(runtime, "dataPtr", uint8Array);
-
-  auto sizesArray = jsi::Array(runtime, 3);
-  sizesArray.setValueAtIndex(runtime, 0, jsi::Value(result.height));
-  sizesArray.setValueAtIndex(runtime, 1, jsi::Value(result.width));
-  sizesArray.setValueAtIndex(runtime, 2, jsi::Value(result.channels));
-  obj.setProperty(runtime, "sizes", sizesArray);
-
-  obj.setProperty(runtime, "scalarType",
-                  jsi::Value(static_cast<int32_t>(ScalarType::Byte)));
-
-  return obj;
-}
-
-inline jsi::Value getJsiValue(
-    const rnexecutorch::models::semantic_segmentation::SegmentationResult
-        &result,
-    jsi::Runtime &runtime) {
-  jsi::Object dict(runtime);
-
-  auto argmaxArrayBuffer = jsi::ArrayBuffer(runtime, result.argmax);
-  auto int32ArrayCtor =
-      runtime.global().getPropertyAsFunction(runtime, "Int32Array");
-  auto int32Array = int32ArrayCtor.callAsConstructor(runtime, argmaxArrayBuffer)
-                        .getObject(runtime);
-  dict.setProperty(runtime, "ARGMAX", int32Array);
-
-  for (auto &[classLabel, owningBuffer] : *result.classBuffers) {
-    auto classArrayBuffer = jsi::ArrayBuffer(runtime, owningBuffer);
-    auto float32ArrayCtor =
-        runtime.global().getPropertyAsFunction(runtime, "Float32Array");
-    auto float32Array =
-        float32ArrayCtor.callAsConstructor(runtime, classArrayBuffer)
-            .getObject(runtime);
-    dict.setProperty(runtime, jsi::String::createFromAscii(runtime, classLabel),
-                     float32Array);
-  }
-
-  return dict;
-}
-
-inline jsi::Value
-getJsiValue(const models::style_transfer::StyleTransferResult &result,
-            jsi::Runtime &runtime) {
-  return std::visit(
-      [&runtime](const auto &value) { return getJsiValue(value, runtime); },
-      result);
-}
-
-} // namespace rnexecutorch::jsi_conversion
diff --git a/packages/react-native-executorch/common/rnexecutorch/host_objects/ModelHostObject.h b/packages/react-native-executorch/common/rnexecutorch/host_objects/ModelHostObject.h
deleted file mode 100644
index cb631e5fba..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/host_objects/ModelHostObject.h
+++ /dev/null
@@ -1,466 +0,0 @@
-#pragma once
-
-#include <ReactCommon/CallInvoker.h>
-#include <jsi/jsi.h>
-#include <sstream>
-#include <string>
-#include <tuple>
-#include <type_traits>
-
-#include <memory.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/TokenizerModule.h>
-#include <rnexecutorch/host_objects/JSTensorViewOut.h>
-#include <rnexecutorch/host_objects/JsiConversions.h>
-#include <rnexecutorch/jsi/JsiHostObject.h>
-#include <rnexecutorch/jsi/Promise.h>
-#include <rnexecutorch/metaprogramming/FunctionHelpers.h>
-#include <rnexecutorch/metaprogramming/TypeConcepts.h>
-#include <rnexecutorch/models/BaseModel.h>
-#include <rnexecutorch/models/VisionModel.h>
-#include <rnexecutorch/models/llm/LLM.h>
-#include <rnexecutorch/models/ocr/OCR.h>
-#include <rnexecutorch/models/speech_to_text/SpeechToText.h>
-#include <rnexecutorch/models/text_to_image/TextToImage.h>
-#include <rnexecutorch/models/text_to_speech/TextToSpeech.h>
-#include <rnexecutorch/models/vertical_ocr/VerticalOCR.h>
-#include <rnexecutorch/models/voice_activity_detection/VoiceActivityDetection.h>
-#include <rnexecutorch/threads/GlobalThreadPool.h>
-
-namespace rnexecutorch {
-
-inline jsi::Value makeRnExecutorchErrorValue(jsi::Runtime &runtime,
-                                             int32_t code,
-                                             const std::string &message) {
-  auto errorObj =
-      runtime.global()
-          .getPropertyAsFunction(runtime, "Error")
-          .callAsConstructor(runtime,
-                             jsi::String::createFromUtf8(runtime, message))
-          .asObject(runtime);
-  errorObj.setProperty(runtime, "code", code);
-  return jsi::Value(std::move(errorObj));
-}
-
-template <typename Model> class ModelHostObject : public JsiHostObject {
-public:
-  explicit ModelHostObject(const std::shared_ptr<Model> &model,
-                           std::shared_ptr<react::CallInvoker> callInvoker)
-      : model(model), callInvoker(callInvoker) {
-    if constexpr (meta::DerivedFromOrSameAs<Model, models::BaseModel>) {
-      addFunctions(
-          JSI_EXPORT_FUNCTION(ModelHostObject<Model>, unload, "unload"));
-
-      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
-                                       promiseHostFunction<&Model::forwardJS>,
-                                       "forward"));
-
-      addFunctions(JSI_EXPORT_FUNCTION(
-          ModelHostObject<Model>, promiseHostFunction<&Model::getInputShape>,
-          "getInputShape"));
-    }
-
-    // LLM::generate and LLM::generateMultimodal registered explicitly below
-    if constexpr (meta::HasGenerate<Model> &&
-                  !meta::SameAs<Model, models::llm::LLM>) {
-      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
-                                       promiseHostFunction<&Model::generate>,
-                                       "generate"));
-    }
-
-    if constexpr (meta::HasEncode<Model>) {
-      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
-                                       promiseHostFunction<&Model::encode>,
-                                       "encode"));
-    }
-
-    if constexpr (meta::HasDecode<Model>) {
-      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
-                                       promiseHostFunction<&Model::decode>,
-                                       "decode"));
-    }
-
-    if constexpr (meta::SameAs<Model, models::speech_to_text::SpeechToText>) {
-      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
-                                       synchronousHostFunction<&Model::unload>,
-                                       "unload"));
-
-      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
-                                       promiseHostFunction<&Model::transcribe>,
-                                       "transcribe"));
-
-      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
-                                       promiseHostFunction<&Model::stream>,
-                                       "stream"));
-
-      addFunctions(JSI_EXPORT_FUNCTION(
-          ModelHostObject<Model>, synchronousHostFunction<&Model::streamInsert>,
-          "streamInsert"));
-
-      addFunctions(JSI_EXPORT_FUNCTION(
-          ModelHostObject<Model>, synchronousHostFunction<&Model::streamStop>,
-          "streamStop"));
-    }
-
-    if constexpr (meta::SameAs<Model, models::voice_activity_detection::
-                                          VoiceActivityDetection>) {
-      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
-                                       promiseHostFunction<&Model::stream>,
-                                       "stream"));
-
-      addFunctions(JSI_EXPORT_FUNCTION(
-          ModelHostObject<Model>, synchronousHostFunction<&Model::streamInsert>,
-          "streamInsert"));
-
-      addFunctions(JSI_EXPORT_FUNCTION(
-          ModelHostObject<Model>, synchronousHostFunction<&Model::streamStop>,
-          "streamStop"));
-    }
-
-    if constexpr (meta::SameAs<Model, TokenizerModule>) {
-      addFunctions(JSI_EXPORT_FUNCTION(
-          ModelHostObject<Model>, promiseHostFunction<&Model::getVocabSize>,
-          "getVocabSize"));
-      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
-                                       promiseHostFunction<&Model::idToToken>,
-                                       "idToToken"));
-      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
-                                       promiseHostFunction<&Model::tokenToId>,
-                                       "tokenToId"));
-    }
-
-    if constexpr (meta::SameAs<Model, models::llm::LLM>) {
-      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
-                                       promiseHostFunction<&Model::generate>,
-                                       "generate"));
-
-      addFunctions(JSI_EXPORT_FUNCTION(
-          ModelHostObject<Model>, synchronousHostFunction<&Model::interrupt>,
-          "interrupt"));
-
-      addFunctions(JSI_EXPORT_FUNCTION(
-          ModelHostObject<Model>,
-          synchronousHostFunction<&Model::getGeneratedTokenCount>,
-          "getGeneratedTokenCount"));
-
-      addFunctions(JSI_EXPORT_FUNCTION(
-          ModelHostObject<Model>,
-          synchronousHostFunction<&Model::getPromptTokenCount>,
-          "getPromptTokenCount"));
-
-      addFunctions(JSI_EXPORT_FUNCTION(
-          ModelHostObject<Model>,
-          synchronousHostFunction<&Model::countTextTokens>, "countTextTokens"));
-
-      addFunctions(
-          JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
-                              synchronousHostFunction<&Model::setCountInterval>,
-                              "setCountInterval"));
-
-      addFunctions(JSI_EXPORT_FUNCTION(
-          ModelHostObject<Model>,
-          synchronousHostFunction<&Model::setTimeInterval>, "setTimeInterval"));
-
-      addFunctions(JSI_EXPORT_FUNCTION(
-          ModelHostObject<Model>,
-          synchronousHostFunction<&Model::setTemperature>, "setTemperature"));
-
-      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
-                                       synchronousHostFunction<&Model::setTopp>,
-                                       "setTopp"));
-
-      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
-                                       synchronousHostFunction<&Model::setMinP>,
-                                       "setMinP"));
-
-      addFunctions(JSI_EXPORT_FUNCTION(
-          ModelHostObject<Model>,
-          synchronousHostFunction<&Model::setRepetitionPenalty>,
-          "setRepetitionPenalty"));
-
-      addFunctions(JSI_EXPORT_FUNCTION(
-          ModelHostObject<Model>,
-          synchronousHostFunction<&Model::getMaxContextLength>,
-          "getMaxContextLength"));
-
-      addFunctions(
-          JSI_EXPORT_FUNCTION(ModelHostObject<Model>, unload, "unload"));
-
-      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
-                                       synchronousHostFunction<&Model::reset>,
-                                       "reset"));
-
-      addFunctions(
-          JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
-                              promiseHostFunction<&Model::generateMultimodal>,
-                              "generateMultimodal"));
-
-      addFunctions(JSI_EXPORT_FUNCTION(
-          ModelHostObject<Model>,
-          synchronousHostFunction<&Model::getVisualTokenCount>,
-          "getVisualTokenCount"));
-    }
-
-    if constexpr (meta::SameAs<Model, models::text_to_image::TextToImage>) {
-      addFunctions(
-          JSI_EXPORT_FUNCTION(ModelHostObject<Model>, unload, "unload"));
-      addFunctions(JSI_EXPORT_FUNCTION(
-          ModelHostObject<Model>, synchronousHostFunction<&Model::interrupt>,
-          "interrupt"));
-    }
-
-    if constexpr (meta::SameAs<Model, models::ocr::OCR>) {
-      addFunctions(
-          JSI_EXPORT_FUNCTION(ModelHostObject<Model>, unload, "unload"));
-    }
-
-    if constexpr (meta::SameAs<Model, models::ocr::VerticalOCR>) {
-      addFunctions(
-          JSI_EXPORT_FUNCTION(ModelHostObject<Model>, unload, "unload"));
-    }
-
-    if constexpr (meta::SameAs<Model, models::text_to_speech::kokoro::Kokoro>) {
-      addFunctions(
-          JSI_EXPORT_FUNCTION(ModelHostObject<Model>, unload, "unload"));
-      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
-                                       promiseHostFunction<&Model::stream>,
-                                       "stream"));
-      addFunctions(JSI_EXPORT_FUNCTION(
-          ModelHostObject<Model>, synchronousHostFunction<&Model::streamStop>,
-          "streamStop"));
-      addFunctions(JSI_EXPORT_FUNCTION(
-          ModelHostObject<Model>, synchronousHostFunction<&Model::streamInsert>,
-          "streamInsert"));
-      addFunctions(JSI_EXPORT_FUNCTION(
-          ModelHostObject<Model>, synchronousHostFunction<&Model::streamFlush>,
-          "streamFlush"));
-    }
-
-    if constexpr (meta::HasGenerateFromString<Model>) {
-      addFunctions(
-          JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
-                              promiseHostFunction<&Model::generateFromString>,
-                              "generateFromString"));
-    }
-
-    if constexpr (meta::HasGenerateFromFrame<Model>) {
-      addFunctions(JSI_EXPORT_FUNCTION(
-          ModelHostObject<Model>, visionHostFunction<&Model::generateFromFrame>,
-          "generateFromFrame"));
-    }
-
-    if constexpr (meta::HasGenerateFromPixels<Model>) {
-      addFunctions(
-          JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
-                              promiseHostFunction<&Model::generateFromPixels>,
-                              "generateFromPixels"));
-    }
-  }
-
-  // A generic host function that runs synchronously, works analogously to the
-  // generic promise host function.
-  template <auto FnPtr> JSI_HOST_FUNCTION(synchronousHostFunction) {
-    constexpr std::size_t functionArgCount = meta::getArgumentCount(FnPtr);
-    if (functionArgCount != count) {
-      std::stringstream ss;
-      ss << "Argument count mismatch, was expecting: " << functionArgCount
-         << " but got: " << count;
-      const auto errorMessage = ss.str();
-      throw jsi::JSError(runtime, errorMessage);
-    }
-
-    try {
-      auto argsConverted = meta::createArgsTupleFromJsi(FnPtr, args, runtime);
-
-      if constexpr (std::is_void_v<decltype(std::apply(
-                        std::bind_front(FnPtr, model), argsConverted))>) {
-        // For void functions, just call the function and return undefined
-        std::apply(std::bind_front(FnPtr, model), std::move(argsConverted));
-        return jsi::Value::undefined();
-      } else {
-        // For non-void functions, capture the result and convert it
-        auto result =
-            std::apply(std::bind_front(FnPtr, model), std::move(argsConverted));
-        return jsi_conversion::getJsiValue(std::move(result), runtime);
-      }
-    } catch (const RnExecutorchError &e) {
-      throw jsi::JSError(runtime, makeRnExecutorchErrorValue(
-                                      runtime, e.getNumericCode(), e.what()));
-    } catch (const std::exception &e) {
-      throw jsi::JSError(runtime, e.what());
-    } catch (...) {
-      throw jsi::JSError(runtime, "Unknown error in synchronous function");
-    }
-  }
-
-  /**
-   * Unlike promiseHostFunction, this runs synchronously on the JS thread,
-   * which is required for VisionCamera worklet frame processors.
-   *
-   * The key challenge is argument mapping: the C++ function takes
-   * (Runtime, frameData, Rest...) but from the JS side, Runtime is injected
-   * automatically and frameData is JS args[0]. The remaining args (Rest...)
-   * map to JS args[1..N].
-   *
-   * This is achieved via TailSignature: it extracts the Rest... parameter pack
-   * from the function pointer type, creates a dummy free function with only
-   * those types, then uses createArgsTupleFromJsi on that dummy to convert
-   * args[1..N] — bypassing the manually-handled frameData at args[0].
-   *
-   * Argument mapping:
-   *   C++ params:  (Runtime&,  frameData,  Rest[0],   Rest[1], ...)
-   *   JS args:     (           args[0],    args[1],   args[2], ...)
-   *   JS arg count = C++ arity - 1  (Runtime is injected, not counted)
-   *
-   */
-  template <auto FnPtr> JSI_HOST_FUNCTION(visionHostFunction) {
-    constexpr std::size_t cppArgCount =
-        meta::FunctionTraits<decltype(FnPtr)>::arity;
-    constexpr std::size_t expectedJsArgs = cppArgCount - 1;
-
-    if (count != expectedJsArgs) {
-      throw jsi::JSError(runtime, "Argument count mismatch in vision function");
-    }
-
-    try {
-      auto dummyFuncPtr = &meta::TailSignature<decltype(FnPtr)>::dummy;
-      auto tailArgsTuple =
-          meta::createArgsTupleFromJsi(dummyFuncPtr, args + 1, runtime);
-
-      using ReturnType =
-          typename meta::FunctionTraits<decltype(FnPtr)>::return_type;
-
-      if constexpr (std::is_void_v<ReturnType>) {
-        std::apply(
-            [&](auto &&...tailArgs) {
-              (model.get()->*FnPtr)(
-                  runtime, args[0],
-                  std::forward<decltype(tailArgs)>(tailArgs)...);
-            },
-            std::move(tailArgsTuple));
-        return jsi::Value::undefined();
-      } else {
-        auto result = std::apply(
-            [&](auto &&...tailArgs) {
-              return (model.get()->*FnPtr)(
-                  runtime, args[0],
-                  std::forward<decltype(tailArgs)>(tailArgs)...);
-            },
-            std::move(tailArgsTuple));
-
-        return jsi_conversion::getJsiValue(std::move(result), runtime);
-      }
-    } catch (const RnExecutorchError &e) {
-      throw jsi::JSError(runtime, makeRnExecutorchErrorValue(
-                                      runtime, e.getNumericCode(), e.what()));
-    } catch (const std::exception &e) {
-      throw jsi::JSError(runtime, e.what());
-    } catch (...) {
-      throw jsi::JSError(runtime, "Unknown error in vision function");
-    }
-  }
-
-  // A generic host function that resolves a promise with a result of a
-  // function. JSI arguments are converted to the types provided in the function
-  // signature, and the return value is converted back to JSI before resolving.
-  template <auto FnPtr> JSI_HOST_FUNCTION(promiseHostFunction) {
-    auto promise = Promise::createPromise(
-        runtime, callInvoker,
-        [this, count, args, &runtime](std::shared_ptr<Promise> promise) {
-          constexpr std::size_t functionArgCount =
-              meta::getArgumentCount(FnPtr);
-          if (functionArgCount != count) {
-            std::stringstream ss;
-            ss << "Argument count mismatch, was expecting: " << functionArgCount
-               << " but got: " << count;
-            const auto errorMessage = ss.str();
-            promise->reject(errorMessage);
-            return;
-          }
-
-          try {
-            auto argsConverted =
-                meta::createArgsTupleFromJsi(FnPtr, args, runtime);
-
-            // We need to dispatch a thread if we want the function to be
-            // asynchronous. In this thread all accesses to jsi::Runtime need to
-            // be done via the callInvoker.
-            threads::GlobalThreadPool::detach(
-                [model = this->model, callInvoker = this->callInvoker, promise,
-                 argsConverted = std::move(argsConverted)]() {
-                  try {
-                    if constexpr (std::is_void_v<decltype(std::apply(
-                                      std::bind_front(FnPtr, model),
-                                      argsConverted))>) {
-                      // For void functions, just call the function and resolve
-                      // with undefined
-                      std::apply(std::bind_front(FnPtr, model),
-                                 std::move(argsConverted));
-                      callInvoker->invokeAsync(
-                          [promise](jsi::Runtime &runtime) {
-                            promise->resolve(jsi::Value::undefined());
-                          });
-                    } else {
-                      // For non-void functions, capture the result and convert
-                      // it
-                      auto result = std::apply(std::bind_front(FnPtr, model),
-                                               std::move(argsConverted));
-                      // The result is copied. It should either be quickly
-                      // copiable, or passed with a shared_ptr.
-                      callInvoker->invokeAsync(
-                          [promise, result](jsi::Runtime &runtime) {
-                            promise->resolve(jsi_conversion::getJsiValue(
-                                std::move(result), runtime));
-                          });
-                    }
-                  } catch (const RnExecutorchError &e) {
-                    auto code = e.getNumericCode();
-                    auto msg = std::string(e.what());
-                    callInvoker->invokeAsync(
-                        [code, msg, promise](jsi::Runtime &runtime) {
-                          promise->reject(
-                              makeRnExecutorchErrorValue(runtime, code, msg));
-                        });
-                    return;
-                  } catch (const std::exception &e) {
-                    callInvoker->invokeAsync([e = std::move(e), promise]() {
-                      promise->reject(std::string(e.what()));
-                    });
-                    return;
-                  } catch (...) {
-                    callInvoker->invokeAsync([promise]() {
-                      promise->reject(std::string("Unknown error"));
-                    });
-                    return;
-                  }
-                });
-          } catch (...) {
-            promise->reject(std::string(
-                "Couldn't parse JS arguments in a native function"));
-          }
-        });
-
-    return promise;
-  }
-
-  JSI_HOST_FUNCTION(unload) {
-    try {
-      model->unload();
-      thisValue.asObject(runtime).setExternalMemoryPressure(runtime, 0);
-    } catch (const RnExecutorchError &e) {
-      throw jsi::JSError(runtime, makeRnExecutorchErrorValue(
-                                      runtime, e.getNumericCode(), e.what()));
-    } catch (const std::exception &e) {
-      throw jsi::JSError(runtime, e.what());
-    } catch (...) {
-      throw jsi::JSError(runtime, "Unknown error while unloading a model");
-    }
-    return jsi::Value::undefined();
-  }
-
-private:
-  std::shared_ptr<Model> model;
-  std::shared_ptr<react::CallInvoker> callInvoker;
-};
-
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/jsi/JsiHostObject.cpp b/packages/react-native-executorch/common/rnexecutorch/jsi/JsiHostObject.cpp
deleted file mode 100644
index d07434325c..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/jsi/JsiHostObject.cpp
+++ /dev/null
@@ -1,108 +0,0 @@
-#include "JsiHostObject.h"
-
-//  set this value to 1 in order to debug the construction/destruction
-#define JSI_DEBUG_ALLOCATIONS 1
-
-namespace rnexecutorch {
-
-#if JSI_DEBUG_ALLOCATIONS
-int objCounter = 0;
-std::vector<JsiHostObject *> objects;
-#endif
-
-JsiHostObject::JsiHostObject() {
-  getters_ = std::make_unique<std::unordered_map<
-      std::string, jsi::Value (JsiHostObject::*)(jsi::Runtime &)>>();
-  functions_ = std::make_unique<
-      std::unordered_map<std::string, jsi::Value (JsiHostObject::*)(
-                                          jsi::Runtime &, const jsi::Value &,
-                                          const jsi::Value *, size_t)>>();
-  setters_ = std::make_unique<std::unordered_map<
-      std::string,
-      void (JsiHostObject::*)(jsi::Runtime &, const jsi::Value &)>>();
-
-#if JSI_DEBUG_ALLOCATIONS
-  objects.push_back(this);
-  objCounter++;
-#endif
-}
-
-JsiHostObject::~JsiHostObject() {
-#if JSI_DEBUG_ALLOCATIONS
-  for (size_t i = 0; i < objects.size(); ++i) {
-    if (objects.at(i) == this) {
-      objects.erase(objects.begin() + i);
-      break;
-    }
-  }
-  objCounter--;
-#endif
-}
-
-std::vector<jsi::PropNameID> JsiHostObject::getPropertyNames(jsi::Runtime &rt) {
-  std::vector<jsi::PropNameID> propertyNames;
-  propertyNames.reserve(getters_->size() + functions_->size() +
-                        setters_->size());
-
-  for (const auto &it : *getters_) {
-    propertyNames.push_back(jsi::PropNameID::forUtf8(rt, it.first));
-  }
-
-  for (const auto &it : *functions_) {
-    propertyNames.push_back(jsi::PropNameID::forAscii(rt, it.first));
-  }
-
-  for (const auto &it : *setters_) {
-    propertyNames.push_back(jsi::PropNameID::forAscii(rt, it.first));
-  }
-
-  return propertyNames;
-}
-
-jsi::Value JsiHostObject::get(jsi::Runtime &runtime,
-                              const jsi::PropNameID &name) {
-  auto nameAsString = name.utf8(runtime);
-  auto &hostFunctionCache = hostFunctionCache_.get(runtime);
-
-  auto cachedFunction = hostFunctionCache.find(nameAsString);
-  if (cachedFunction != hostFunctionCache.end()) {
-    return cachedFunction->second.asFunction(runtime);
-  }
-
-  auto getter = getters_->find(nameAsString);
-  if (getter != getters_->end()) {
-    auto dispatcher = std::bind(getter->second, this, std::placeholders::_1);
-
-    return dispatcher(runtime);
-  }
-
-  auto function = functions_->find(nameAsString);
-  if (function == functions_->end()) {
-    return jsi::Value::undefined();
-  }
-
-  auto dispatcher =
-      std::bind(function->second, reinterpret_cast<JsiHostObject *>(this),
-                std::placeholders::_1, std::placeholders::_2,
-                std::placeholders::_3, std::placeholders::_4);
-
-  return hostFunctionCache
-      .emplace(nameAsString, jsi::Function::createFromHostFunction(
-                                 runtime, name, 0, dispatcher))
-      .first->second.asFunction(runtime);
-}
-
-void JsiHostObject::set(jsi::Runtime &runtime, const jsi::PropNameID &name,
-                        const jsi::Value &value) {
-  auto nameAsString = name.utf8(runtime);
-
-  auto setter = setters_->find(nameAsString);
-
-  if (setter != setters_->end()) {
-    auto dispatcher = std::bind(setter->second, this, std::placeholders::_1,
-                                std::placeholders::_2);
-
-    return dispatcher(runtime, value);
-  }
-}
-} // namespace rnexecutorch
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/jsi/JsiHostObject.h b/packages/react-native-executorch/common/rnexecutorch/jsi/JsiHostObject.h
deleted file mode 100644
index 8b78f3f885..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/jsi/JsiHostObject.h
+++ /dev/null
@@ -1,87 +0,0 @@
-#pragma once
-// Adapted from https://github.com/software-mansion/react-native-audio-api
-
-#include <rnexecutorch/jsi/RuntimeAwareCache.h>
-
-#include <jsi/jsi.h>
-#include <map>
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-#define JSI_HOST_FUNCTION(NAME)                                                \
-  jsi::Value NAME(jsi::Runtime &runtime, const jsi::Value &thisValue,          \
-                  const jsi::Value *args, size_t count)
-
-#define JSI_EXPORT_FUNCTION(CLASS, FUNCTION, NAME)                             \
-  std::make_pair(                                                              \
-      NAME,                                                                    \
-      static_cast<jsi::Value (JsiHostObject::*)(                               \
-          jsi::Runtime &, const jsi::Value &, const jsi::Value *, size_t)>(    \
-          &CLASS::FUNCTION))
-
-#define JSI_PROPERTY_GETTER(name) jsi::Value name(jsi::Runtime &runtime)
-
-#define JSI_EXPORT_PROPERTY_GETTER(CLASS, FUNCTION)                            \
-  std::make_pair(std::string(#FUNCTION),                                       \
-                 static_cast<jsi::Value (JsiHostObject::*)(jsi::Runtime &)>(   \
-                     &CLASS::FUNCTION))
-
-#define JSI_PROPERTY_SETTER(name)                                              \
-  void name(jsi::Runtime &runtime, const jsi::Value &value)
-
-#define JSI_EXPORT_PROPERTY_SETTER(CLASS, FUNCTION)                            \
-  std::make_pair(std::string(#FUNCTION),                                       \
-                 static_cast<void (JsiHostObject::*)(                          \
-                     jsi::Runtime &, const jsi::Value &)>(&CLASS::FUNCTION))
-
-namespace rnexecutorch {
-
-using namespace facebook;
-
-class JsiHostObject : public jsi::HostObject {
-public:
-  JsiHostObject();
-  ~JsiHostObject() override;
-
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
-
-  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
-
-  void set(jsi::Runtime &runtime, const jsi::PropNameID &name,
-           const jsi::Value &value) override;
-
-  template <typename... Args> void addGetters(Args... args) {
-    (getters_->insert(args), ...);
-  }
-
-  template <typename... Args> void addSetters(Args... args) {
-    (setters_->insert(args), ...);
-  }
-
-  template <typename... Args> void addFunctions(Args... args) {
-    (functions_->insert(args), ...);
-  }
-
-protected:
-  std::unique_ptr<std::unordered_map<std::string, jsi::Value (JsiHostObject::*)(
-                                                      jsi::Runtime &)>>
-      getters_;
-
-  std::unique_ptr<
-      std::unordered_map<std::string, jsi::Value (JsiHostObject::*)(
-                                          jsi::Runtime &, const jsi::Value &,
-                                          const jsi::Value *, size_t)>>
-      functions_;
-
-  std::unique_ptr<std::unordered_map<
-      std::string, void (JsiHostObject::*)(jsi::Runtime &, const jsi::Value &)>>
-      setters_;
-
-private:
-  RuntimeAwareCache<std::map<std::string, jsi::Function>> hostFunctionCache_;
-};
-
-} // namespace rnexecutorch
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/jsi/OwningArrayBuffer.h b/packages/react-native-executorch/common/rnexecutorch/jsi/OwningArrayBuffer.h
deleted file mode 100644
index a76fb02707..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/jsi/OwningArrayBuffer.h
+++ /dev/null
@@ -1,57 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-#include <vector>
-
-namespace rnexecutorch {
-
-using namespace facebook;
-
-/**
- * JSI offers the MutableBuffer as an interface for accessing native memory
- * directly from JS. A class inheriting from the MutableBuffer could be used to
- * access memory which is owned by C++ or memory which should be freed once JS
- * is done with it. OwningArrayBuffer is an example of the latter, memory is
- * allocated on creation and freed on deletion. JS holds a pointer to all
- * MutableBuffers via a shared_ptr, so the destructor will be called only when
- * no reference to it is kept. For a handy JS access to the data, MutableBuffers
- * can be inspected via a data view, such as Float32Array. See
- * ImageSegmentation.cpp for an example usage.
- */
-class OwningArrayBuffer : public jsi::MutableBuffer {
-public:
-  /**
-   * @param size Size of the buffer in bytes.
-   */
-  OwningArrayBuffer(size_t size) : size_(size) {
-    data_ = new uint8_t[size_];
-  }
-  /**
-   * @param data Pointer to the source data.
-   * @param size Size of the data in bytes.
-   */
-  OwningArrayBuffer(const auto &data, size_t size) : size_(size) {
-    data_ = new uint8_t[size_];
-    std::memcpy(data_, data, size_);
-  }
-  template <typename T>
-  OwningArrayBuffer(const std::vector<T> &vec) : size_(vec.size() * sizeof(T)) {
-    data_ = new uint8_t[size_];
-    std::memcpy(data_, vec.data(), size_);
-  }
-  ~OwningArrayBuffer() override { delete[] data_; }
-
-  OwningArrayBuffer(const OwningArrayBuffer &) = delete;
-  OwningArrayBuffer(OwningArrayBuffer &&) = delete;
-  OwningArrayBuffer &operator=(const OwningArrayBuffer &) = delete;
-  OwningArrayBuffer &operator=(OwningArrayBuffer &&) = delete;
-
-  [[nodiscard]] size_t size() const override { return size_; }
-  uint8_t *data() override { return data_; }
-
-private:
-  uint8_t *data_;
-  const size_t size_;
-};
-
-} // namespace rnexecutorch
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/jsi/Promise.cpp b/packages/react-native-executorch/common/rnexecutorch/jsi/Promise.cpp
deleted file mode 100644
index 510890e344..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/jsi/Promise.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-#include "Promise.h"
-
-namespace rnexecutorch {
-
-Promise::Promise(jsi::Runtime &runtime,
-                 std::shared_ptr<react::CallInvoker> callInvoker,
-                 jsi::Value resolver, jsi::Value rejecter)
-    : runtime(runtime), callInvoker(callInvoker),
-      _resolver(std::move(resolver)), _rejecter(std::move(rejecter)) {}
-
-void Promise::resolve(jsi::Value &&result) {
-  _resolver.asObject(runtime).asFunction(runtime).call(runtime, result);
-}
-
-void Promise::reject(jsi::Value &&error) {
-  _rejecter.asObject(runtime).asFunction(runtime).call(runtime, error);
-}
-
-void Promise::reject(std::string message) {
-  jsi::JSError error(runtime, message);
-  _rejecter.asObject(runtime).asFunction(runtime).call(runtime, error.value());
-}
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/jsi/Promise.h b/packages/react-native-executorch/common/rnexecutorch/jsi/Promise.h
deleted file mode 100644
index b278daa918..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/jsi/Promise.h
+++ /dev/null
@@ -1,70 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-
-#include <ReactCommon/CallInvoker.h>
-#include <jsi/jsi.h>
-
-namespace rnexecutorch {
-
-using namespace facebook;
-
-class Promise;
-
-template <typename T>
-concept PromiseRunFn =
-    std::invocable<T, std::shared_ptr<Promise>> &&
-    std::same_as<std::invoke_result_t<T, std::shared_ptr<Promise>>, void>;
-
-class Promise {
-public:
-  Promise(jsi::Runtime &runtime,
-          std::shared_ptr<react::CallInvoker> callInvoker, jsi::Value resolver,
-          jsi::Value rejecter);
-
-  Promise(const Promise &) = delete;
-  Promise &operator=(const Promise &) = delete;
-
-  void resolve(jsi::Value &&result);
-  void reject(jsi::Value &&result);
-  void reject(std::string error);
-
-  /**
-    Creates a new promise and runs the supplied "run" function that takes this
-    promise. We use a template for the function type to not use std::function
-    and be able to bind a lambda.
-  */
-  template <PromiseRunFn Fn>
-  static jsi::Value
-  createPromise(jsi::Runtime &runtime,
-                std::shared_ptr<react::CallInvoker> callInvoker, Fn &&run) {
-    // Get Promise ctor from global
-    auto promiseCtor =
-        runtime.global().getPropertyAsFunction(runtime, "Promise");
-
-    auto promiseCallback = jsi::Function::createFromHostFunction(
-        runtime, jsi::PropNameID::forUtf8(runtime, "PromiseCallback"), 2,
-        [run = std::move(run),
-         callInvoker](jsi::Runtime &runtime, const jsi::Value &thisValue,
-                      const jsi::Value *arguments, size_t count) -> jsi::Value {
-          // Call function
-          auto promise = std::make_shared<Promise>(
-              runtime, callInvoker, arguments[0].asObject(runtime),
-              arguments[1].asObject(runtime));
-          run(promise);
-
-          return jsi::Value::undefined();
-        });
-
-    return promiseCtor.callAsConstructor(runtime, promiseCallback);
-  }
-
-private:
-  jsi::Runtime &runtime;
-  std::shared_ptr<react::CallInvoker> callInvoker;
-  jsi::Value _resolver;
-  jsi::Value _rejecter;
-};
-
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/jsi/RuntimeAwareCache.h b/packages/react-native-executorch/common/rnexecutorch/jsi/RuntimeAwareCache.h
deleted file mode 100644
index dc7c8d0ff5..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/jsi/RuntimeAwareCache.h
+++ /dev/null
@@ -1,58 +0,0 @@
-#pragma once
-// Adapted from https://github.com/software-mansion/react-native-audio-api
-
-// Header in jsi/ need to be added like this. See comment in JsiHostObject.h.
-#include <rnexecutorch/jsi/RuntimeLifecycleMonitor.h>
-
-#include <jsi/jsi.h>
-#include <memory>
-#include <unordered_map>
-#include <utility>
-
-namespace rnexecutorch {
-
-using namespace facebook;
-
-/**
- * Provides a way to keep data specific to a jsi::Runtime instance that gets
- * cleaned up when that runtime is destroyed. This is necessary because JSI does
- * not allow for its associated objects to be retained past the runtime
- * lifetime. If an object (e.g. jsi::Values or jsi::Function instances) is kept
- * after the runtime is torn down, its destructor (once it is destroyed
- * eventually) will result in a crash (JSI objects keep a pointer to memory
- * managed by the runtime, accessing that portion of the memory after runtime is
- * deleted is the root cause of that crash).
- */
-template <typename T>
-class RuntimeAwareCache : public RuntimeLifecycleListener {
-public:
-  void onRuntimeDestroyed(jsi::Runtime *rt) override {
-    // A runtime has been destroyed, so destroy the related cache.
-    runtimeCaches_.erase(rt);
-  }
-
-  ~RuntimeAwareCache() override {
-    for (auto &cache : runtimeCaches_) {
-      // remove all `onRuntimeDestroyed` listeners.
-      RuntimeLifecycleMonitor::removeListener(*cache.first, this);
-    }
-  }
-
-  T &get(jsi::Runtime &rt) {
-    if (runtimeCaches_.count(&rt) == 0) {
-      // This is the first time this Runtime has been accessed.
-      // We set up a `onRuntimeDestroyed` listener for it and
-      // initialize the cache map.
-      RuntimeLifecycleMonitor::addListener(rt, this);
-
-      T cache;
-      runtimeCaches_.emplace(&rt, std::move(cache));
-    }
-    return runtimeCaches_.at(&rt);
-  }
-
-private:
-  std::unordered_map<jsi::Runtime *, T> runtimeCaches_;
-};
-
-} // namespace rnexecutorch
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/jsi/RuntimeLifecycleMonitor.cpp b/packages/react-native-executorch/common/rnexecutorch/jsi/RuntimeLifecycleMonitor.cpp
deleted file mode 100644
index a0d5465caf..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/jsi/RuntimeLifecycleMonitor.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "RuntimeLifecycleMonitor.h"
-
-namespace rnexecutorch {
-
-static std::unordered_map<jsi::Runtime *,
-                          std::unordered_set<RuntimeLifecycleListener *>>
-    listeners;
-
-struct RuntimeLifecycleMonitorObject : public jsi::HostObject {
-  jsi::Runtime *rt_;
-  explicit RuntimeLifecycleMonitorObject(jsi::Runtime *rt) : rt_(rt) {}
-  ~RuntimeLifecycleMonitorObject() override {
-    auto listenersSet = listeners.find(rt_);
-    if (listenersSet != listeners.end()) {
-      for (auto listener : listenersSet->second) {
-        listener->onRuntimeDestroyed(rt_);
-      }
-      listeners.erase(listenersSet);
-    }
-  }
-};
-
-void RuntimeLifecycleMonitor::addListener(jsi::Runtime &rt,
-                                          RuntimeLifecycleListener *listener) {
-  auto listenersSet = listeners.find(&rt);
-  if (listenersSet == listeners.end()) {
-    // We install a global host object in the provided runtime, this way we can
-    // use that host object destructor to get notified when the runtime is being
-    // terminated. We use a unique name for the object as it gets saved with the
-    // runtime's global object.
-    rt.global().setProperty(
-        rt, "__rnaudioapi_runtime_lifecycle_monitor",
-        jsi::Object::createFromHostObject(
-            rt, std::make_shared<RuntimeLifecycleMonitorObject>(&rt)));
-    std::unordered_set<RuntimeLifecycleListener *> newSet;
-    newSet.insert(listener);
-    listeners.emplace(&rt, std::move(newSet));
-  } else {
-    listenersSet->second.insert(listener);
-  }
-}
-
-void RuntimeLifecycleMonitor::removeListener(
-    jsi::Runtime &rt, RuntimeLifecycleListener *listener) {
-  auto listenersSet = listeners.find(&rt);
-  if (listenersSet == listeners.end()) {
-    // nothing to do here
-  } else {
-    listenersSet->second.erase(listener);
-  }
-}
-
-} // namespace rnexecutorch
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/jsi/RuntimeLifecycleMonitor.h b/packages/react-native-executorch/common/rnexecutorch/jsi/RuntimeLifecycleMonitor.h
deleted file mode 100644
index 7d0e88bbb6..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/jsi/RuntimeLifecycleMonitor.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#pragma once
-// Adapted from https://github.com/software-mansion/react-native-audio-api
-
-#include <jsi/jsi.h>
-#include <memory>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-
-namespace rnexecutorch {
-
-using namespace facebook;
-
-/**
- * Listener interface that allows for getting notified when a jsi::Runtime
- * instance is destroyed.
- */
-struct RuntimeLifecycleListener {
-  virtual ~RuntimeLifecycleListener() = default;
-  virtual void onRuntimeDestroyed(jsi::Runtime *) = 0;
-};
-
-/**
- * This class provides an API via static methods for registering and
- * unregistering runtime lifecycle listeners. The listeners can be used to
- * cleanup any data that references a given jsi::Runtime instance before it gets
- * destroyed.
- */
-struct RuntimeLifecycleMonitor {
-  static void addListener(jsi::Runtime &rt, RuntimeLifecycleListener *listener);
-  static void removeListener(jsi::Runtime &rt,
-                             RuntimeLifecycleListener *listener);
-};
-
-} // namespace rnexecutorch
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/metaprogramming/ConstructorHelpers.h b/packages/react-native-executorch/common/rnexecutorch/metaprogramming/ConstructorHelpers.h
deleted file mode 100644
index c3cdda6768..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/metaprogramming/ConstructorHelpers.h
+++ /dev/null
@@ -1,133 +0,0 @@
-#pragma once
-
-#include <concepts>
-#include <jsi/jsi.h>
-#include <memory>
-#include <rnexecutorch/host_objects/JsiConversions.h>
-#include <tuple>
-#include <type_traits>
-
-namespace facebook::react {
-class CallInvoker;
-}
-
-namespace rnexecutorch {
-namespace meta {
-
-using namespace facebook;
-
-/**
- * To be able to generically invoke constructors, we need to know what types
- * are the arguments that need to be passed to it. To do this, we specialize the
- * ConstructorTraits struct template for each class which constructor we want to
- * use. See REGISTER_CONSTRUCTOR macro for a easy way to do this.
- *
- * Note: a downside for this method is that we can specialize ConstructorTraits
- * only for a single constructor signature per class.
- */
-
-template <typename T> struct ConstructorTraits;
-
-template <typename T>
-concept HasConstructorTraits =
-    requires { typename ConstructorTraits<T>::arg_types; };
-
-template <typename T, typename Tuple> struct is_constructible_from_tuple;
-
-template <typename T, typename... Args>
-struct is_constructible_from_tuple<T, std::tuple<Args...>>
-    : std::is_constructible<T, Args...> {};
-
-template <typename T, typename Tuple>
-concept ConstructibleFromTuple = is_constructible_from_tuple<T, Tuple>::value;
-
-template <typename NotTuple>
-struct last_element_is_call_invoker : std::false_type {};
-
-template <typename... Args>
-struct last_element_is_call_invoker<std::tuple<Args...>> {
-private:
-  template <typename Last> static constexpr bool check() {
-    return std::is_same_v<Last, std::shared_ptr<facebook::react::CallInvoker>>;
-  }
-
-  template <typename First, typename Second, typename... Rest>
-  static constexpr bool check_last() {
-    return check_last<Second, Rest...>();
-  }
-
-  template <typename Last> static constexpr bool check_last() {
-    return check<Last>();
-  }
-
-public:
-  static constexpr bool value = sizeof...(Args) > 0 && check_last<Args...>();
-};
-
-// HasConstructorTraits<T> could be removed as typename
-// ConstructorTraits<T>::arg_types would still resolve the concept to false if
-// it wouldn't be defined, but we keep it for readability
-template <typename T>
-concept ValidConstructorTraits =
-    HasConstructorTraits<T> &&
-    ConstructibleFromTuple<T, typename ConstructorTraits<T>::arg_types>;
-
-template <typename T>
-concept CallInvokerLastInConstructor =
-    HasConstructorTraits<T> &&
-    last_element_is_call_invoker<
-        typename ConstructorTraits<T>::arg_types>::value;
-
-template <typename... Types, std::size_t... I>
-std::tuple<Types...> fillConstructorTupleFromArgs(
-    std::index_sequence<I...>, const jsi::Value *args, jsi::Runtime &runtime,
-    std::shared_ptr<react::CallInvoker> jsCallInvoker) {
-  constexpr std::size_t lastIndex = sizeof...(Types) - 1;
-  return std::make_tuple([&]() {
-    if constexpr (I == lastIndex) {
-      return jsCallInvoker;
-    } else {
-      return jsi_conversion::getValue<Types>(args[I], runtime);
-    }
-  }()...);
-}
-
-/// @brief A method that creates a tuple of arguments based on types specified
-/// in a ConstructorTraits specialization. The class has to have CallInvoker as
-/// the last argument in the constructor.
-/// @tparam T The class for which we want to construct the tuple
-/// @param args JSI args passed from JS that will be converted according to
-/// getValue<T> from JsiConversions
-/// @param runtime JS runtime reference
-/// @param jsCallInvoker CallInvoker that will be passed to the constructed
-/// object. This is the only argument that is not created from jsi::Value.
-/// @return A tuple which can then be used to instantiate the class T.
-template <typename T>
-  requires ValidConstructorTraits<T> && CallInvokerLastInConstructor<T>
-auto createConstructorArgsWithCallInvoker(
-    const jsi::Value *args, jsi::Runtime &runtime,
-    std::shared_ptr<react::CallInvoker> jsCallInvoker) {
-  return std::apply(
-      [&](auto... typeWrappers) {
-        return fillConstructorTupleFromArgs<decltype(typeWrappers)...>(
-            std::index_sequence_for<decltype(typeWrappers)...>{}, args, runtime,
-            jsCallInvoker);
-      },
-      typename ConstructorTraits<T>::arg_types{});
-}
-
-} // namespace meta
-
-/**
- * @brief A helper macro to create ConstructorTraits for a class. The variadic
- * pack
- * ("...") should list the types of the constructor arguments.
- * @note The Class must be fully declared or forward-declared before this macro
- * is invoked
- */
-#define REGISTER_CONSTRUCTOR(Class, ...)                                       \
-  template <> struct meta::ConstructorTraits<Class> {                          \
-    using arg_types = std::tuple<__VA_ARGS__>;                                 \
-  }
-
-} // namespace rnexecutorch
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/metaprogramming/ContainerHelpers.h b/packages/react-native-executorch/common/rnexecutorch/metaprogramming/ContainerHelpers.h
deleted file mode 100644
index 941ddedbb2..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/metaprogramming/ContainerHelpers.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#pragma once
-
-#include <cstddef>
-#include <filesystem>
-#include <stdexcept>
-#include <string>
-
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/Log.h>
-
-/**
- * @brief A helper macro to check if a container has the expected size.
- * Prints an error message with the container's name, file, and line number if
- * the size does not match, and throws a std::runtime_error.
- *
- * @param container The container whose size will be checked (must have a
- * .size() method).
- * @param expected The expected size of the container.
- * @note The macro prints the variable name, file, and line for easier
- * debugging.
- */
-#define CHECK_SIZE(container, expected)                                        \
-  if ((container).size() != (expected)) {                                      \
-    rnexecutorch::log(rnexecutorch::LOG_LEVEL::Error,                          \
-                      "Unexpected size for " #container " at ",                \
-                      std::filesystem::path(__FILE__).filename().string(),     \
-                      ":", __LINE__, ": expected ", (expected), " but got ",   \
-                      (container).size());                                     \
-    throw rnexecutorch::RnExecutorchError(                                     \
-        rnexecutorch::RnExecutorchErrorCode::WrongDimensions,                  \
-        "Invalid shape of " #container);                                       \
-  }
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/metaprogramming/FunctionHelpers.h b/packages/react-native-executorch/common/rnexecutorch/metaprogramming/FunctionHelpers.h
deleted file mode 100644
index fde81e046d..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/metaprogramming/FunctionHelpers.h
+++ /dev/null
@@ -1,100 +0,0 @@
-#pragma once
-
-#include <cstddef>
-#include <jsi/jsi.h>
-#include <tuple>
-#include <type_traits>
-
-#include <rnexecutorch/host_objects/JsiConversions.h>
-
-namespace rnexecutorch::meta {
-using namespace facebook;
-
-template <typename Model, typename R, typename... Types>
-constexpr std::size_t getArgumentCount(R (Model::*f)(Types...)) {
-  return sizeof...(Types);
-}
-
-template <typename Model, typename R, typename... Types>
-constexpr std::size_t getArgumentCount(R (Model::*f)(Types...) const) {
-  return sizeof...(Types);
-}
-
-template <typename... Types, std::size_t... I>
-std::tuple<Types...> fillTupleFromArgs(std::index_sequence<I...>,
-                                       const jsi::Value *args,
-                                       jsi::Runtime &runtime) {
-  return std::tuple<Types...>{
-      jsi_conversion::getValue<Types>(args[I], runtime)...};
-}
-
-/**
- * createArgsTupleFromJsi creates a tuple that can be used as a collection of
- * arguments for method supplied with a pointer. The types in the tuple are
- * inferred from the method pointer.
- */
-
-template <typename Model, typename R, typename... Types>
-std::tuple<Types...> createArgsTupleFromJsi(R (Model::*f)(Types...),
-                                            const jsi::Value *args,
-                                            jsi::Runtime &runtime) {
-  return fillTupleFromArgs<Types...>(std::index_sequence_for<Types...>{}, args,
-                                     runtime);
-}
-
-template <typename Model, typename R, typename... Types>
-std::tuple<Types...> createArgsTupleFromJsi(R (Model::*f)(Types...) const,
-                                            const jsi::Value *args,
-                                            jsi::Runtime &runtime) {
-  return fillTupleFromArgs<Types...>(std::index_sequence_for<Types...>{}, args,
-                                     runtime);
-}
-
-// Free function overload used by visionHostFunction: accepts a dummy free
-// function pointer whose parameter types (Rest...) are extracted by
-// TailSignature and converted from JSI args.
-template <typename... Types>
-std::tuple<Types...> createArgsTupleFromJsi(void (*f)(Types...),
-                                            const jsi::Value *args,
-                                            jsi::Runtime &runtime) {
-  return fillTupleFromArgs<Types...>(std::index_sequence_for<Types...>{}, args,
-                                     runtime);
-}
-
-// Extracts arity, return type, and argument types from a member function
-// pointer at compile time. Used by visionHostFunction to determine the expected
-// JS argument count and invoke the correct return path.
-template <typename T> struct FunctionTraits;
-
-template <typename R, typename C, typename... Args>
-struct FunctionTraits<R (C::*)(Args...)> {
-  static constexpr std::size_t arity = sizeof...(Args);
-  using return_type = R;
-  using args_tuple = std::tuple<Args...>;
-};
-
-template <typename R, typename C, typename... Args>
-struct FunctionTraits<R (C::*)(Args...) const> {
-  static constexpr std::size_t arity = sizeof...(Args);
-  using return_type = R;
-  using args_tuple = std::tuple<Args...>;
-};
-
-// Strips the first two parameters (Runtime& and jsi::Value&) from a member
-// function pointer and exposes the remaining types as a dummy free function.
-// Used by visionHostFunction to parse only the tail JS args via
-// createArgsTupleFromJsi, while frameData at args[0] is passed manually.
-template <typename T> struct TailSignature;
-
-template <typename R, typename C, typename Arg1, typename Arg2,
-          typename... Rest>
-struct TailSignature<R (C::*)(Arg1, Arg2, Rest...)> {
-  static void dummy(Rest...) {}
-};
-
-template <typename R, typename C, typename Arg1, typename Arg2,
-          typename... Rest>
-struct TailSignature<R (C::*)(Arg1, Arg2, Rest...) const> {
-  static void dummy(Rest...) {}
-};
-} // namespace rnexecutorch::meta
diff --git a/packages/react-native-executorch/common/rnexecutorch/metaprogramming/TypeConcepts.h b/packages/react-native-executorch/common/rnexecutorch/metaprogramming/TypeConcepts.h
deleted file mode 100644
index 2d7612f250..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/metaprogramming/TypeConcepts.h
+++ /dev/null
@@ -1,52 +0,0 @@
-#pragma once
-
-#include <concepts>
-#include <type_traits>
-
-namespace rnexecutorch::meta {
-
-template <typename T, typename Base>
-concept DerivedFromOrSameAs = std::is_base_of_v<Base, T>;
-
-template <typename T, typename Base>
-concept SameAs = std::is_same_v<Base, T>;
-
-template <typename T>
-concept HasGenerate = requires(T t) {
-  { &T::generate };
-};
-
-template <typename T>
-concept HasGenerateFromString = requires(T t) {
-  { &T::generateFromString };
-};
-
-template <typename T>
-concept HasGenerateFromPixels = requires(T t) {
-  { &T::generateFromPixels };
-};
-
-template <typename T>
-concept HasGenerateFromFrame = requires(T t) {
-  { &T::generateFromFrame };
-};
-
-template <typename T>
-concept HasEncode = requires(T t) {
-  { &T::encode };
-};
-
-template <typename T>
-concept HasDecode = requires(T t) {
-  { &T::decode };
-};
-
-template <typename T>
-concept IsNumeric = std::is_arithmetic_v<T>;
-
-template <typename T>
-concept ProvidesMemoryLowerBound = requires(T t) {
-  { &T::getMemoryLowerBound };
-};
-
-} // namespace rnexecutorch::meta
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/BaseModel.cpp b/packages/react-native-executorch/common/rnexecutorch/models/BaseModel.cpp
deleted file mode 100644
index 735b257f51..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/BaseModel.cpp
+++ /dev/null
@@ -1,179 +0,0 @@
-#include "BaseModel.h"
-
-#include <executorch/extension/tensor/tensor.h>
-#include <filesystem>
-#include <rnexecutorch/Error.h>
-
-namespace rnexecutorch::models {
-
-using namespace facebook;
-using namespace executorch::extension;
-using ::executorch::extension::module::Module;
-using ::executorch::runtime::Error;
-
-BaseModel::BaseModel(const std::string &modelSource,
-                     std::shared_ptr<react::CallInvoker> callInvoker,
-                     Module::LoadMode loadMode)
-    : callInvoker(callInvoker),
-      module_(std::make_unique<Module>(modelSource, loadMode)) {
-  Error loadError = module_->load();
-  if (loadError != Error::Ok) {
-    throw RnExecutorchError(loadError, "Failed to load model");
-  }
-  // We use the size of the model .pte file as the lower bound for the memory
-  // occupied by the ET module. This is not the whole size however, the module
-  // also allocates planned memory (for ET execution) and backend-specific
-  // memory (e.g. what XNNPACK operates on).
-  std::filesystem::path modelPath{modelSource};
-  memorySizeLowerBound = std::filesystem::file_size(modelPath);
-}
-
-std::vector<int32_t> BaseModel::getInputShape(std::string method_name,
-                                              int32_t index) const {
-  if (!module_) {
-    THROW_NOT_LOADED_ERROR();
-  }
-
-  auto method_meta = module_->method_meta(method_name);
-  if (!method_meta.ok()) {
-    throw RnExecutorchError(method_meta.error(),
-                            "Failed to get metadata for method '" +
-                                method_name + "'");
-  }
-
-  auto input_meta = method_meta->input_tensor_meta(index);
-  if (!input_meta.ok()) {
-    throw RnExecutorchError(
-        input_meta.error(),
-        "Failed to get metadata for input tensor at index " +
-            std::to_string(index) + " in method '" + method_name + "'");
-  }
-
-  auto sizes = input_meta->sizes();
-  std::vector<int32_t> input_shape(sizes.begin(), sizes.end());
-  return input_shape;
-}
-
-std::vector<std::vector<int32_t>>
-BaseModel::getAllInputShapes(std::string methodName) const {
-  if (!module_) {
-    THROW_NOT_LOADED_ERROR();
-  }
-
-  auto method_meta = module_->method_meta(methodName);
-  if (!method_meta.ok()) {
-    throw RnExecutorchError(method_meta.error(),
-                            "Failed to get metadata for method '" + methodName +
-                                "'");
-  }
-  std::vector<std::vector<int32_t>> output;
-  std::size_t numInputs = method_meta->num_inputs();
-  output.reserve(numInputs);
-  for (std::size_t input = 0; input < numInputs; ++input) {
-    auto input_meta = method_meta->input_tensor_meta(input);
-    if (!input_meta.ok()) {
-      throw RnExecutorchError(
-          input_meta.error(),
-          "Failed to get metadata for input tensor at index " +
-              std::to_string(input) + " in method '" + methodName + "'");
-    }
-    auto shape = input_meta->sizes();
-    output.emplace_back(std::vector<int32_t>(shape.begin(), shape.end()));
-  }
-  return output;
-}
-
-/// @brief This method is a forward wrapper that is created solely to be exposed
-/// to JS. It is not meant to be used within C++. If you want to call forward
-/// from C++ on a BaseModel, please use BaseModel::forward.
-std::vector<JSTensorViewOut>
-BaseModel::forwardJS(std::vector<JSTensorViewIn> tensorViewVec) const {
-  if (!module_) {
-    THROW_NOT_LOADED_ERROR();
-  }
-  std::vector<executorch::runtime::EValue> evalues;
-  evalues.reserve(tensorViewVec.size());
-  // Because EValue doesn't hold to the dynamic data and metadata from
-  // TensorPtr, we need to make sure that the TensorPtr for each EValue is valid
-  // as long as that EValue is in use. Therefore we create a vec solely for
-  // keeping references to the TensorPtr
-  std::vector<TensorPtr> tensorPtrs;
-  tensorPtrs.reserve(evalues.size());
-
-  for (size_t i = 0; i < tensorViewVec.size(); i++) {
-    const auto &currTensorView = tensorViewVec[i];
-    auto tensorPtr =
-        make_tensor_ptr(currTensorView.sizes, currTensorView.dataPtr,
-                        currTensorView.scalarType);
-    tensorPtrs.emplace_back(tensorPtr);
-    evalues.emplace_back(*tensorPtr); // Dereference TensorPtr to get Tensor,
-                                      // which implicitly converts to EValue
-  }
-
-  auto result = module_->forward(evalues);
-  CHECK_OK_OR_THROW_FORWARD_ERROR(result);
-
-  auto &outputs = result.get();
-  std::vector<JSTensorViewOut> output;
-  output.reserve(outputs.size());
-
-  // Convert ET outputs to a vector of JSTensorViewOut which are later
-  // converted to JSI types via JsiConversions.h
-  for (size_t i = 0; i < outputs.size(); i++) {
-    auto &outputTensor = outputs[i].toTensor();
-    std::vector<int32_t> sizes = getTensorShape(outputTensor);
-    size_t bufferSize = outputTensor.numel() * outputTensor.element_size();
-    auto buffer = std::make_shared<OwningArrayBuffer>(
-        outputTensor.const_data_ptr(), bufferSize);
-    auto jsTensor = JSTensorViewOut(sizes, outputTensor.scalar_type(), buffer);
-    output.emplace_back(jsTensor);
-  }
-  return output;
-}
-
-Result<executorch::runtime::MethodMeta>
-BaseModel::getMethodMeta(const std::string &methodName) const {
-  if (!module_) {
-    THROW_NOT_LOADED_ERROR();
-  }
-  return module_->method_meta(methodName);
-}
-
-Result<std::vector<EValue>>
-BaseModel::forward(const EValue &input_evalue) const {
-  if (!module_) {
-    THROW_NOT_LOADED_ERROR();
-  }
-  return module_->forward(input_evalue);
-}
-
-Result<std::vector<EValue>>
-BaseModel::forward(const std::vector<EValue> &input_evalues) const {
-  if (!module_) {
-    THROW_NOT_LOADED_ERROR();
-  }
-  return module_->forward(input_evalues);
-}
-
-Result<std::vector<EValue>>
-BaseModel::execute(const std::string &methodName,
-                   const std::vector<EValue> &input_value) const {
-  if (!module_) {
-    THROW_NOT_LOADED_ERROR();
-  }
-  return module_->execute(methodName, input_value);
-}
-
-std::size_t BaseModel::getMemoryLowerBound() const noexcept {
-  return memorySizeLowerBound;
-}
-
-void BaseModel::unload() noexcept { module_.reset(nullptr); }
-
-std::vector<int32_t>
-BaseModel::getTensorShape(const executorch::aten::Tensor &tensor) const {
-  auto sizes = tensor.sizes();
-  return std::vector<int32_t>(sizes.begin(), sizes.end());
-}
-
-} // namespace rnexecutorch::models
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/BaseModel.h b/packages/react-native-executorch/common/rnexecutorch/models/BaseModel.h
deleted file mode 100644
index 6d44976b90..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/BaseModel.h
+++ /dev/null
@@ -1,64 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-
-#include <ReactCommon/CallInvoker.h>
-#include <executorch/extension/module/module.h>
-#include <jsi/jsi.h>
-#include <rnexecutorch/host_objects/JSTensorViewIn.h>
-#include <rnexecutorch/host_objects/JSTensorViewOut.h>
-#include <rnexecutorch/metaprogramming/ConstructorHelpers.h>
-
-namespace rnexecutorch {
-namespace models {
-using namespace facebook;
-using executorch::extension::module::Module;
-using executorch::runtime::EValue;
-using executorch::runtime::Result;
-
-class BaseModel {
-public:
-  virtual ~BaseModel() = default;
-  BaseModel(BaseModel &&) = default;
-  BaseModel &operator=(BaseModel &&) = default;
-  BaseModel(
-      const std::string &modelSource,
-      std::shared_ptr<react::CallInvoker> callInvoker,
-      Module::LoadMode loadMode = Module::LoadMode::MmapUseMlockIgnoreErrors);
-  std::size_t getMemoryLowerBound() const noexcept;
-  void unload() noexcept;
-  [[nodiscard("Registered non-void function")]] std::vector<int32_t>
-  getInputShape(std::string method_name, int32_t index) const;
-  std::vector<std::vector<int32_t>>
-  getAllInputShapes(std::string methodName = "forward") const;
-  [[nodiscard("Registered non-void function")]] std::vector<JSTensorViewOut>
-  forwardJS(std::vector<JSTensorViewIn> tensorViewVec) const;
-  Result<std::vector<EValue>> forward(const EValue &input_value) const;
-  Result<std::vector<EValue>>
-  forward(const std::vector<EValue> &input_value) const;
-  Result<std::vector<EValue>>
-  execute(const std::string &methodName,
-          const std::vector<EValue> &input_value) const;
-  Result<executorch::runtime::MethodMeta>
-  getMethodMeta(const std::string &methodName) const;
-
-protected:
-  // If possible, models should not use the JS runtime to keep JSI internals
-  // away from logic, however, sometimes this would incur too big of a penalty
-  // (unnecessary copies instead of working on JS memory). In this case
-  // CallInvoker can be used to get jsi::Runtime, and use it in a safe manner.
-  std::shared_ptr<react::CallInvoker> callInvoker;
-  std::unique_ptr<Module> module_;
-
-  std::size_t memorySizeLowerBound{0};
-
-private:
-  std::vector<int32_t>
-  getTensorShape(const executorch::aten::Tensor &tensor) const;
-};
-} // namespace models
-
-REGISTER_CONSTRUCTOR(models::BaseModel, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/VisionModel.cpp b/packages/react-native-executorch/common/rnexecutorch/models/VisionModel.cpp
deleted file mode 100644
index cc9c862b32..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/VisionModel.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#include "VisionModel.h"
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-#include <rnexecutorch/utils/FrameProcessor.h>
-#include <rnexecutorch/utils/FrameTransform.h>
-
-namespace rnexecutorch::models {
-
-using namespace facebook;
-
-VisionModel::VisionModel(const std::string &modelSource,
-                         std::shared_ptr<react::CallInvoker> callInvoker)
-    : BaseModel(modelSource, callInvoker) {}
-
-void VisionModel::unload() noexcept {
-  std::scoped_lock lock(inference_mutex_);
-  BaseModel::unload();
-}
-
-cv::Size VisionModel::modelInputSize() const {
-  if (modelInputShape_.size() < 2) {
-    return {0, 0};
-  }
-  return cv::Size(modelInputShape_[modelInputShape_.size() - 1],
-                  modelInputShape_[modelInputShape_.size() - 2]);
-}
-
-cv::Mat VisionModel::extractFromFrame(jsi::Runtime &runtime,
-                                      const jsi::Value &frameData) const {
-  cv::Mat frame = ::rnexecutorch::utils::frameToMat(runtime, frameData);
-  cv::Mat rgb;
-#ifdef __APPLE__
-  cv::cvtColor(frame, rgb, cv::COLOR_BGRA2RGB);
-#else
-  cv::cvtColor(frame, rgb, cv::COLOR_RGBA2RGB);
-#endif
-  return rgb;
-}
-
-cv::Mat VisionModel::preprocess(const cv::Mat &image) const {
-  const cv::Size targetSize = modelInputSize();
-  if (image.size() == targetSize) {
-    return image;
-  }
-  cv::Mat resized;
-  cv::resize(image, resized, targetSize);
-  return resized;
-}
-
-cv::Mat VisionModel::extractFromPixels(const JSTensorViewIn &tensorView) const {
-  return ::rnexecutorch::utils::pixelsToMat(tensorView);
-}
-
-} // namespace rnexecutorch::models
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/VisionModel.h b/packages/react-native-executorch/common/rnexecutorch/models/VisionModel.h
deleted file mode 100644
index cf003948af..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/VisionModel.h
+++ /dev/null
@@ -1,156 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-#include <mutex>
-#include <opencv2/opencv.hpp>
-#include <rnexecutorch/metaprogramming/ConstructorHelpers.h>
-#include <rnexecutorch/models/BaseModel.h>
-#include <rnexecutorch/utils/FrameTransform.h>
-
-namespace rnexecutorch {
-namespace models {
-
-/**
- * @brief Base class for computer vision models that support real-time camera
- * input
- *
- * VisionModel extends BaseModel with thread-safe inference and automatic frame
- * extraction from VisionCamera. This class is designed for models that need to
- * process camera frames in real-time (e.g., at 30fps).
- *
- * Thread Safety:
- * - All inference operations are protected by a mutex via scoped_lock
- *
- * Usage:
- * Subclasses should:
- * 1. Inherit from VisionModel instead of BaseModel
- * 2. Optionally override preprocess() for model-specific preprocessing
- * 3. Implement runInference() which acquires the lock internally
- *
- * Example:
- * @code
- * class Classification : public VisionModel {
- * public:
- *   std::unordered_map<std::string_view, float>
- *   generateFromFrame(jsi::Runtime& runtime, const jsi::Value& frameValue) {
- *     auto frameObject = frameValue.asObject(runtime);
- *     cv::Mat frame = extractFromFrame(runtime, frameObject);
- *     return runInference(frame);
- *   }
- * };
- * @endcode
- */
-class VisionModel : public BaseModel {
-public:
-  VisionModel(const std::string &modelSource,
-              std::shared_ptr<react::CallInvoker> callInvoker);
-
-  virtual ~VisionModel() = default;
-
-  /**
-   * @brief Thread-safe unload that waits for any in-flight inference to
-   * complete
-   *
-   * Overrides BaseModel::unload() to acquire inference_mutex_ before
-   * resetting the module. This prevents a crash where BaseModel::unload()
-   * destroys module_ while generateFromFrame() is still executing on the
-   * VisionCamera worklet thread.
-   */
-  void unload() noexcept;
-
-protected:
-  /// Cached input tensor shape (getAllInputShapes()[0]).
-  /// Set once by each subclass constructor to avoid per-frame metadata lookups.
-  std::vector<int32_t> modelInputShape_;
-
-  /**
-   * @brief Mutex to ensure thread-safe inference
-   *
-   * This mutex protects against race conditions when:
-   * - generateFromFrame() is called from VisionCamera worklet thread (30fps)
-   * - generate() is called from JavaScript thread simultaneously
-   *
-   * Usage guidelines:
-   * - Use std::scoped_lock for blocking operations (JS API can wait)
-   * - Use try_lock() for non-blocking operations (camera should skip frames)
-   *
-   * @note Marked mutable to allow locking in const methods if needed
-   */
-  mutable std::mutex inference_mutex_;
-
-  /**
-   * @brief Resize an RGB image to the model's expected input size
-   *
-   * Resizes to modelInputSize() if needed. Subclasses may override for
-   * model-specific preprocessing (e.g., normalisation).
-   *
-   * @param image Input image in RGB format
-   * @return cv::Mat resized to modelInputSize(), in RGB format
-   *
-   * @note Called from runInference() under the inference mutex
-   */
-  virtual cv::Mat preprocess(const cv::Mat &image) const;
-
-  /**
-   * @brief Get the spatial dimensions of the model input.
-   *
-   * By default, returns the last two dimensions of modelInputShape_.
-   * Subclasses may override this for models with dynamic or multiple input
-   * sizes.
-   */
-  virtual cv::Size modelInputSize() const;
-  /**
-   * @brief Extract an RGB cv::Mat from a VisionCamera frame
-   *
-   * Calls frameToMat() then converts the raw 4-channel frame
-   * (BGRA on iOS, RGBA on Android) to RGB.
-   *
-   * @param runtime JSI runtime
-   * @param frameData JSI value containing frame data from VisionCamera
-   * @return cv::Mat in RGB format (3 channels)
-   *
-   * @note Does NOT acquire the inference mutex — caller is responsible
-   */
-  cv::Mat extractFromFrame(jsi::Runtime &runtime,
-                           const jsi::Value &frameData) const;
-
-  /**
-   * @brief Extract cv::Mat from raw pixel data (TensorPtr) sent from
-   * JavaScript
-   *
-   * This method enables users to run inference on raw pixel data without file
-   * I/O. Useful for processing images already in memory (e.g., from canvas,
-   * image library).
-   *
-   * @param tensorView JSTensorViewIn containing:
-   *                   - dataPtr: Pointer to raw pixel values (RGB format)
-   *                   - sizes: [height, width, channels] - must be 3D
-   *                   - scalarType: Must be ScalarType::Byte (Uint8Array)
-   *
-   * @return cv::Mat containing the pixel data
-   *
-   * @throws RnExecutorchError if tensorView format is invalid
-   *
-   * @note The returned cv::Mat owns a copy of the data
-   * @note Expected pixel format: RGB (3 channels), row-major order
-   * @note Typical usage from JS:
-   * @code
-   *   const pixels = new Uint8Array([...]);  // Raw RGB pixel data
-   *   const result = model.generateFromPixels({
-   *     dataPtr: pixels,
-   *     sizes: [480, 640, 3],
-   *     scalarType: ScalarType.BYTE
-   *   }, 0.5);
-   * @endcode
-   */
-  cv::Mat extractFromPixels(const JSTensorViewIn &tensorView) const;
-};
-
-} // namespace models
-// Register VisionModel constructor traits
-// Even though VisionModel is abstract, the metaprogramming system needs to know
-// its constructor signature for derived classes
-REGISTER_CONSTRUCTOR(models::VisionModel, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/classification/Classification.cpp b/packages/react-native-executorch/common/rnexecutorch/models/classification/Classification.cpp
deleted file mode 100644
index d31f78607f..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/classification/Classification.cpp
+++ /dev/null
@@ -1,118 +0,0 @@
-#include "Classification.h"
-
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-#include <rnexecutorch/Log.h>
-
-#include <rnexecutorch/data_processing/ImageProcessing.h>
-#include <rnexecutorch/data_processing/Numerical.h>
-
-namespace rnexecutorch::models::classification {
-
-Classification::Classification(const std::string &modelSource,
-                               std::vector<float> normMean,
-                               std::vector<float> normStd,
-                               std::vector<std::string> labelNames,
-                               std::shared_ptr<react::CallInvoker> callInvoker)
-    : VisionModel(modelSource, callInvoker),
-      labelNames_(std::move(labelNames)) {
-  if (normMean.size() == 3) {
-    normMean_ = cv::Scalar(normMean[0], normMean[1], normMean[2]);
-  } else if (!normMean.empty()) {
-    log(LOG_LEVEL::Warn,
-        "normMean must have 3 elements — ignoring provided value.");
-  }
-  if (normStd.size() == 3) {
-    normStd_ = cv::Scalar(normStd[0], normStd[1], normStd[2]);
-  } else if (!normStd.empty()) {
-    log(LOG_LEVEL::Warn,
-        "normStd must have 3 elements — ignoring provided value.");
-  }
-
-  auto inputShapes = getAllInputShapes();
-  if (inputShapes.size() == 0) {
-    throw RnExecutorchError(RnExecutorchErrorCode::UnexpectedNumInputs,
-                            "Model seems to not take any input tensors.");
-  }
-  modelInputShape_ = inputShapes[0];
-  if (modelInputShape_.size() < 2) {
-    char errorMessage[100];
-    std::snprintf(errorMessage, sizeof(errorMessage),
-                  "Unexpected model input size, expected at least 2 dimensions "
-                  "but got: %zu.",
-                  modelInputShape_.size());
-    throw RnExecutorchError(RnExecutorchErrorCode::WrongDimensions,
-                            errorMessage);
-  }
-}
-
-std::unordered_map<std::string_view, float>
-Classification::runInference(cv::Mat image) {
-  std::scoped_lock lock(inference_mutex_);
-
-  cv::Mat preprocessed = preprocess(image);
-
-  auto inputTensor =
-      (normMean_ && normStd_)
-          ? image_processing::getTensorFromMatrix(
-                modelInputShape_, preprocessed, *normMean_, *normStd_)
-          : image_processing::getTensorFromMatrix(modelInputShape_,
-                                                  preprocessed);
-
-  auto forwardResult = BaseModel::forward(inputTensor);
-  CHECK_OK_OR_THROW_FORWARD_ERROR(forwardResult);
-  return postprocess(forwardResult->at(0).toTensor());
-}
-
-std::unordered_map<std::string_view, float>
-Classification::generateFromString(std::string imageSource) {
-  cv::Mat imageBGR = image_processing::readImage(imageSource);
-
-  cv::Mat imageRGB;
-  cv::cvtColor(imageBGR, imageRGB, cv::COLOR_BGR2RGB);
-
-  return runInference(imageRGB);
-}
-
-std::unordered_map<std::string_view, float>
-Classification::generateFromFrame(jsi::Runtime &runtime,
-                                  const jsi::Value &frameData) {
-  cv::Mat frame = extractFromFrame(runtime, frameData);
-  return runInference(frame);
-}
-
-std::unordered_map<std::string_view, float>
-Classification::generateFromPixels(JSTensorViewIn pixelData) {
-  cv::Mat image = extractFromPixels(pixelData);
-
-  return runInference(image);
-}
-
-std::unordered_map<std::string_view, float>
-Classification::postprocess(const Tensor &tensor) {
-  std::span<const float> resultData(
-      static_cast<const float *>(tensor.const_data_ptr()), tensor.numel());
-  std::vector<float> resultVec(resultData.begin(), resultData.end());
-
-  if (resultVec.size() != labelNames_.size()) {
-    char errorMessage[100];
-    std::snprintf(
-        errorMessage, sizeof(errorMessage),
-        "Unexpected classification output size, was expecting: %zu classes "
-        "but got: %zu classes",
-        labelNames_.size(), resultVec.size());
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidModelOutput,
-                            errorMessage);
-  }
-
-  numerical::softmax(resultVec);
-
-  std::unordered_map<std::string_view, float> probs;
-  for (std::size_t cl = 0; cl < resultVec.size(); ++cl) {
-    probs[labelNames_[cl]] = resultVec[cl];
-  }
-
-  return probs;
-}
-
-} // namespace rnexecutorch::models::classification
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/classification/Classification.h b/packages/react-native-executorch/common/rnexecutorch/models/classification/Classification.h
deleted file mode 100644
index 2ea0e17bbb..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/classification/Classification.h
+++ /dev/null
@@ -1,52 +0,0 @@
-#pragma once
-
-#include <optional>
-#include <unordered_map>
-
-#include <executorch/extension/tensor/tensor_ptr.h>
-#include <jsi/jsi.h>
-#include <opencv2/opencv.hpp>
-
-#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
-#include <rnexecutorch/models/VisionModel.h>
-
-namespace rnexecutorch {
-namespace models::classification {
-using executorch::aten::Tensor;
-using executorch::extension::TensorPtr;
-
-class Classification : public VisionModel {
-public:
-  Classification(const std::string &modelSource, std::vector<float> normMean,
-                 std::vector<float> normStd,
-                 std::vector<std::string> labelNames,
-                 std::shared_ptr<react::CallInvoker> callInvoker);
-
-  [[nodiscard("Registered non-void function")]] std::unordered_map<
-      std::string_view, float>
-  generateFromString(std::string imageSource);
-
-  [[nodiscard("Registered non-void function")]] std::unordered_map<
-      std::string_view, float>
-  generateFromFrame(jsi::Runtime &runtime, const jsi::Value &frameData);
-
-  [[nodiscard("Registered non-void function")]] std::unordered_map<
-      std::string_view, float>
-  generateFromPixels(JSTensorViewIn pixelData);
-
-private:
-  std::unordered_map<std::string_view, float> runInference(cv::Mat image);
-
-  std::unordered_map<std::string_view, float> postprocess(const Tensor &tensor);
-
-  std::vector<std::string> labelNames_;
-  std::optional<cv::Scalar> normMean_;
-  std::optional<cv::Scalar> normStd_;
-};
-} // namespace models::classification
-
-REGISTER_CONSTRUCTOR(models::classification::Classification, std::string,
-                     std::vector<float>, std::vector<float>,
-                     std::vector<std::string>,
-                     std::shared_ptr<react::CallInvoker>);
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/embeddings/BaseEmbeddings.cpp b/packages/react-native-executorch/common/rnexecutorch/models/embeddings/BaseEmbeddings.cpp
deleted file mode 100644
index bf291136c1..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/embeddings/BaseEmbeddings.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "BaseEmbeddings.h"
-
-#include <span>
-
-namespace rnexecutorch::models::embeddings {
-
-BaseEmbeddings::BaseEmbeddings(const std::string &modelSource,
-                               std::shared_ptr<react::CallInvoker> callInvoker)
-    : BaseModel(modelSource, callInvoker) {}
-
-std::shared_ptr<OwningArrayBuffer>
-BaseEmbeddings::postprocess(const Result<std::vector<EValue>> &forwardResult) {
-  auto forwardResultTensor = forwardResult->at(0).toTensor();
-  auto buffer = std::make_shared<OwningArrayBuffer>(
-      forwardResultTensor.const_data_ptr(), forwardResultTensor.nbytes());
-  return buffer;
-}
-
-} // namespace rnexecutorch::models::embeddings
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/embeddings/BaseEmbeddings.h b/packages/react-native-executorch/common/rnexecutorch/models/embeddings/BaseEmbeddings.h
deleted file mode 100644
index 216d6bf8ce..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/embeddings/BaseEmbeddings.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#pragma once
-
-#include <rnexecutorch/models/BaseModel.h>
-
-namespace rnexecutorch::models::embeddings {
-
-class BaseEmbeddings : public BaseModel {
-public:
-  BaseEmbeddings(const std::string &modelSource,
-                 std::shared_ptr<react::CallInvoker> callInvoker);
-
-protected:
-  std::shared_ptr<OwningArrayBuffer>
-  postprocess(const Result<std::vector<EValue>> &forwardResult);
-};
-
-}; // namespace rnexecutorch::models::embeddings
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/embeddings/image/ImageEmbeddings.cpp b/packages/react-native-executorch/common/rnexecutorch/models/embeddings/image/ImageEmbeddings.cpp
deleted file mode 100644
index 03937334cc..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/embeddings/image/ImageEmbeddings.cpp
+++ /dev/null
@@ -1,72 +0,0 @@
-#include "ImageEmbeddings.h"
-#include <executorch/extension/tensor/tensor.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-#include <rnexecutorch/data_processing/ImageProcessing.h>
-
-namespace rnexecutorch::models::embeddings {
-
-ImageEmbeddings::ImageEmbeddings(
-    const std::string &modelSource,
-    std::shared_ptr<react::CallInvoker> callInvoker)
-    : VisionModel(modelSource, callInvoker) {
-  auto inputTensors = getAllInputShapes();
-  if (inputTensors.size() == 0) {
-    throw RnExecutorchError(RnExecutorchErrorCode::UnexpectedNumInputs,
-                            "Model seems to not take any input tensors.");
-  }
-  modelInputShape_ = inputTensors[0];
-  if (modelInputShape_.size() < 2) {
-    char errorMessage[100];
-    std::snprintf(errorMessage, sizeof(errorMessage),
-                  "Unexpected model input size, expected at least 2 dimensions "
-                  "but got: %zu.",
-                  modelInputShape_.size());
-    throw RnExecutorchError(RnExecutorchErrorCode::WrongDimensions,
-                            errorMessage);
-  }
-}
-
-std::shared_ptr<OwningArrayBuffer>
-ImageEmbeddings::runInference(cv::Mat image) {
-  std::scoped_lock lock(inference_mutex_);
-
-  cv::Mat preprocessed = preprocess(image);
-
-  auto inputTensor =
-      image_processing::getTensorFromMatrix(modelInputShape_, preprocessed);
-
-  auto forwardResult = BaseModel::forward(inputTensor);
-
-  CHECK_OK_OR_THROW_FORWARD_ERROR(forwardResult);
-
-  auto forwardResultTensor = forwardResult->at(0).toTensor();
-  return std::make_shared<OwningArrayBuffer>(
-      forwardResultTensor.const_data_ptr(), forwardResultTensor.nbytes());
-}
-
-std::shared_ptr<OwningArrayBuffer>
-ImageEmbeddings::generateFromString(std::string imageSource) {
-  cv::Mat imageBGR = image_processing::readImage(imageSource);
-
-  cv::Mat imageRGB;
-  cv::cvtColor(imageBGR, imageRGB, cv::COLOR_BGR2RGB);
-
-  return runInference(imageRGB);
-}
-
-std::shared_ptr<OwningArrayBuffer>
-ImageEmbeddings::generateFromFrame(jsi::Runtime &runtime,
-                                   const jsi::Value &frameData) {
-  cv::Mat frame = extractFromFrame(runtime, frameData);
-  return runInference(frame);
-}
-
-std::shared_ptr<OwningArrayBuffer>
-ImageEmbeddings::generateFromPixels(JSTensorViewIn pixelData) {
-  cv::Mat image = extractFromPixels(pixelData);
-
-  return runInference(image);
-}
-
-} // namespace rnexecutorch::models::embeddings
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/embeddings/image/ImageEmbeddings.h b/packages/react-native-executorch/common/rnexecutorch/models/embeddings/image/ImageEmbeddings.h
deleted file mode 100644
index 3a20301724..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/embeddings/image/ImageEmbeddings.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-
-#include <executorch/extension/tensor/tensor_ptr.h>
-#include <executorch/runtime/core/evalue.h>
-#include <jsi/jsi.h>
-#include <opencv2/opencv.hpp>
-
-#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
-#include <rnexecutorch/jsi/OwningArrayBuffer.h>
-#include <rnexecutorch/models/VisionModel.h>
-
-namespace rnexecutorch {
-namespace models::embeddings {
-using executorch::extension::TensorPtr;
-using executorch::runtime::EValue;
-
-class ImageEmbeddings final : public VisionModel {
-public:
-  ImageEmbeddings(const std::string &modelSource,
-                  std::shared_ptr<react::CallInvoker> callInvoker);
-
-  [[nodiscard(
-      "Registered non-void function")]] std::shared_ptr<OwningArrayBuffer>
-  generateFromString(std::string imageSource);
-
-  [[nodiscard(
-      "Registered non-void function")]] std::shared_ptr<OwningArrayBuffer>
-  generateFromFrame(jsi::Runtime &runtime, const jsi::Value &frameData);
-
-  [[nodiscard(
-      "Registered non-void function")]] std::shared_ptr<OwningArrayBuffer>
-  generateFromPixels(JSTensorViewIn pixelData);
-
-private:
-  std::shared_ptr<OwningArrayBuffer> runInference(cv::Mat image);
-};
-} // namespace models::embeddings
-
-REGISTER_CONSTRUCTOR(models::embeddings::ImageEmbeddings, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/embeddings/text/TextEmbeddings.cpp b/packages/react-native-executorch/common/rnexecutorch/models/embeddings/text/TextEmbeddings.cpp
deleted file mode 100644
index ba2c3243b2..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/embeddings/text/TextEmbeddings.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-#include "TextEmbeddings.h"
-#include <executorch/extension/tensor/tensor_ptr_maker.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-#include <rnexecutorch/data_processing/Numerical.h>
-
-namespace rnexecutorch::models::embeddings {
-
-using namespace executorch::extension;
-
-TextEmbeddings::TextEmbeddings(const std::string &modelSource,
-                               const std::string &tokenizerSource,
-                               std::shared_ptr<react::CallInvoker> callInvoker)
-    : BaseEmbeddings(modelSource, callInvoker),
-      tokenizer(
-          std::make_unique<TokenizerModule>(tokenizerSource, callInvoker)) {}
-
-TokenIdsWithAttentionMask TextEmbeddings::preprocess(const std::string &input) {
-  auto inputIds = tokenizer->encode(input);
-  // Tokenizers-cpp return tokens as int32, but text embedding models require
-  // int64 as input
-  std::vector<int64_t> inputIds64;
-  inputIds64.reserve(inputIds.size());
-  for (const auto &tok : inputIds) {
-    inputIds64.push_back(static_cast<int64_t>(tok));
-  }
-
-  std::vector<int64_t> attentionMask;
-  attentionMask.reserve(inputIds.size());
-  for (const auto &tok : inputIds64) {
-    // Distinguishing between real tokens and padding, 0 is for paddings, while
-    // any other tokens are relevant
-    attentionMask.push_back(tok != 0);
-  }
-  return {.inputIds = inputIds64, .attentionMask = attentionMask};
-}
-
-void TextEmbeddings::unload() noexcept {
-  std::scoped_lock lock(inference_mutex_);
-  BaseModel::unload();
-}
-
-std::shared_ptr<OwningArrayBuffer>
-TextEmbeddings::generate(const std::string input) {
-  std::scoped_lock lock(inference_mutex_);
-  auto preprocessed = preprocess(input);
-
-  std::vector<int32_t> tokenIdsShape = {
-      1, static_cast<int32_t>(preprocessed.inputIds.size())};
-  std::vector<int32_t> attnMaskShape = {
-      1, static_cast<int32_t>(preprocessed.attentionMask.size())};
-
-  auto tokenIds = make_tensor_ptr(tokenIdsShape, preprocessed.inputIds.data(),
-                                  ScalarType::Long);
-  auto attnMask = make_tensor_ptr(
-      attnMaskShape, preprocessed.attentionMask.data(), ScalarType::Long);
-
-  auto forwardResult = BaseModel::forward({tokenIds, attnMask});
-  CHECK_OK_OR_THROW_FORWARD_ERROR(forwardResult);
-
-  return BaseEmbeddings::postprocess(forwardResult);
-}
-
-} // namespace rnexecutorch::models::embeddings
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/embeddings/text/TextEmbeddings.h b/packages/react-native-executorch/common/rnexecutorch/models/embeddings/text/TextEmbeddings.h
deleted file mode 100644
index 93d0988c04..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/embeddings/text/TextEmbeddings.h
+++ /dev/null
@@ -1,36 +0,0 @@
-#pragma once
-
-#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
-#include <mutex>
-#include <rnexecutorch/TokenizerModule.h>
-#include <rnexecutorch/models/embeddings/BaseEmbeddings.h>
-
-namespace rnexecutorch {
-namespace models::embeddings {
-
-struct TokenIdsWithAttentionMask {
-  std::vector<int64_t> inputIds;
-  std::vector<int64_t> attentionMask;
-};
-
-class TextEmbeddings final : public BaseEmbeddings {
-public:
-  TextEmbeddings(const std::string &modelSource,
-                 const std::string &tokenizerSource,
-                 std::shared_ptr<react::CallInvoker> callInvoker);
-  [[nodiscard(
-      "Registered non-void function")]] std::shared_ptr<OwningArrayBuffer>
-  generate(const std::string input);
-  void unload() noexcept;
-
-private:
-  mutable std::mutex inference_mutex_;
-  std::vector<std::vector<int32_t>> inputShapes;
-  TokenIdsWithAttentionMask preprocess(const std::string &input);
-  std::unique_ptr<TokenizerModule> tokenizer;
-};
-} // namespace models::embeddings
-
-REGISTER_CONSTRUCTOR(models::embeddings::TextEmbeddings, std::string,
-                     std::string, std::shared_ptr<react::CallInvoker>);
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/instance_segmentation/BaseInstanceSegmentation.cpp b/packages/react-native-executorch/common/rnexecutorch/models/instance_segmentation/BaseInstanceSegmentation.cpp
deleted file mode 100644
index 24ef7a8e22..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/instance_segmentation/BaseInstanceSegmentation.cpp
+++ /dev/null
@@ -1,376 +0,0 @@
-#include "BaseInstanceSegmentation.h"
-
-#include <cmath>
-#include <cstdint>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-#include <rnexecutorch/Log.h>
-#include <rnexecutorch/data_processing/ImageProcessing.h>
-#include <rnexecutorch/utils/FrameProcessor.h>
-#include <rnexecutorch/utils/FrameTransform.h>
-#include <rnexecutorch/utils/computer_vision/Processing.h>
-
-namespace rnexecutorch::models::instance_segmentation {
-
-BaseInstanceSegmentation::BaseInstanceSegmentation(
-    const std::string &modelSource, std::vector<float> normMean,
-    std::vector<float> normStd, bool applyNMS,
-    std::shared_ptr<react::CallInvoker> callInvoker)
-    : VisionModel(modelSource, callInvoker), applyNMS_(applyNMS) {
-
-  if (normMean.size() == 3) {
-    normMean_ = cv::Scalar(normMean[0], normMean[1], normMean[2]);
-  } else if (!normMean.empty()) {
-    log(LOG_LEVEL::Warn,
-        "normMean must have 3 elements — ignoring provided value.");
-  }
-  if (normStd.size() == 3) {
-    normStd_ = cv::Scalar(normStd[0], normStd[1], normStd[2]);
-  } else if (!normStd.empty()) {
-    log(LOG_LEVEL::Warn,
-        "normStd must have 3 elements — ignoring provided value.");
-  }
-}
-
-cv::Size BaseInstanceSegmentation::modelInputSize() const {
-  if (currentlyLoadedMethod_.empty()) {
-    return VisionModel::modelInputSize();
-  }
-  auto inputShapes = getAllInputShapes(currentlyLoadedMethod_);
-  if (inputShapes.empty() || inputShapes[0].size() < 2) {
-    return VisionModel::modelInputSize();
-  }
-  const auto &shape = inputShapes[0];
-  return {shape[shape.size() - 2], shape[shape.size() - 1]};
-}
-
-TensorPtr BaseInstanceSegmentation::buildInputTensor(const cv::Mat &image) {
-  cv::Mat preprocessed = preprocess(image);
-  return (normMean_.has_value() && normStd_.has_value())
-             ? image_processing::getTensorFromMatrix(
-                   modelInputShape_, preprocessed, normMean_.value(),
-                   normStd_.value())
-             : image_processing::getTensorFromMatrix(modelInputShape_,
-                                                     preprocessed);
-}
-
-std::vector<types::Instance> BaseInstanceSegmentation::runInference(
-    const cv::Mat &image, double confidenceThreshold, double iouThreshold,
-    int32_t maxInstances, const std::vector<int32_t> &classIndices,
-    bool returnMaskAtOriginalResolution, const std::string &methodName) {
-
-  std::scoped_lock lock(inference_mutex_);
-
-  ensureMethodLoaded(methodName);
-
-  auto inputShapes = getAllInputShapes(methodName);
-  if (inputShapes.empty() || inputShapes[0].empty()) {
-    throw RnExecutorchError(RnExecutorchErrorCode::UnexpectedNumInputs,
-                            "Method '" + methodName +
-                                "' has invalid input tensor shape.");
-  }
-
-  modelInputShape_ = inputShapes[0];
-  const auto &shape = modelInputShape_;
-  cv::Size modelInputSize(shape[shape.size() - 2], shape[shape.size() - 1]);
-  cv::Size originalSize(image.cols, image.rows);
-
-  validateThresholds(confidenceThreshold, iouThreshold);
-
-  auto forwardResult =
-      BaseModel::execute(methodName, {buildInputTensor(image)});
-  CHECK_OK_OR_THROW_FORWARD_ERROR(forwardResult);
-
-  validateOutputTensors(forwardResult.get());
-
-  auto instances = collectInstances(
-      forwardResult.get(), originalSize, modelInputSize, confidenceThreshold,
-      classIndices, returnMaskAtOriginalResolution);
-  return finalizeInstances(std::move(instances), iouThreshold, maxInstances);
-}
-
-std::vector<types::Instance> BaseInstanceSegmentation::generateFromString(
-    std::string imageSource, double confidenceThreshold, double iouThreshold,
-    int32_t maxInstances, std::vector<int32_t> classIndices,
-    bool returnMaskAtOriginalResolution, std::string methodName) {
-
-  cv::Mat imageBGR = image_processing::readImage(imageSource);
-  cv::Mat imageRGB;
-  cv::cvtColor(imageBGR, imageRGB, cv::COLOR_BGR2RGB);
-
-  return runInference(imageRGB, confidenceThreshold, iouThreshold, maxInstances,
-                      classIndices, returnMaskAtOriginalResolution, methodName);
-}
-
-std::vector<types::Instance> BaseInstanceSegmentation::generateFromFrame(
-    jsi::Runtime &runtime, const jsi::Value &frameData,
-    double confidenceThreshold, double iouThreshold, int32_t maxInstances,
-    std::vector<int32_t> classIndices, bool returnMaskAtOriginalResolution,
-    std::string methodName) {
-
-  auto orient = ::rnexecutorch::utils::readFrameOrientation(runtime, frameData);
-  cv::Mat frame = extractFromFrame(runtime, frameData);
-  cv::Mat rotated = utils::rotateFrameForModel(frame, orient);
-  auto instances =
-      runInference(rotated, confidenceThreshold, iouThreshold, maxInstances,
-                   classIndices, returnMaskAtOriginalResolution, methodName);
-  for (auto &inst : instances) {
-    utils::inverseRotateBbox(inst.bbox, orient, rotated.size());
-    // Inverse-rotate the mask to match the screen orientation
-    cv::Mat maskMat(inst.maskHeight, inst.maskWidth, CV_8UC1,
-                    inst.mask->data());
-    cv::Mat invMask = utils::inverseRotateMat(maskMat, orient);
-    inst.mask = std::make_shared<OwningArrayBuffer>(
-        invMask.data, static_cast<size_t>(invMask.total()));
-    inst.maskWidth = invMask.cols;
-    inst.maskHeight = invMask.rows;
-  }
-  return instances;
-}
-
-std::vector<types::Instance> BaseInstanceSegmentation::generateFromPixels(
-    JSTensorViewIn tensorView, double confidenceThreshold, double iouThreshold,
-    int32_t maxInstances, std::vector<int32_t> classIndices,
-    bool returnMaskAtOriginalResolution, std::string methodName) {
-
-  cv::Mat image = extractFromPixels(tensorView);
-  return runInference(image, confidenceThreshold, iouThreshold, maxInstances,
-                      classIndices, returnMaskAtOriginalResolution, methodName);
-}
-
-std::tuple<utils::computer_vision::BBox, float, int32_t>
-BaseInstanceSegmentation::extractDetectionData(const float *bboxData,
-                                               const float *scoresData,
-                                               int32_t index) {
-  utils::computer_vision::BBox bbox{
-      bboxData[index * 4], bboxData[index * 4 + 1], bboxData[index * 4 + 2],
-      bboxData[index * 4 + 3]};
-  float score = scoresData[index * 2];
-  int32_t label = static_cast<int32_t>(scoresData[index * 2 + 1]);
-
-  return {bbox, score, label};
-}
-
-cv::Rect BaseInstanceSegmentation::computeMaskCropRect(
-    const utils::computer_vision::BBox &bboxModel, cv::Size modelInputSize,
-    cv::Size maskSize) {
-
-  float mx1F = bboxModel.p1.x * maskSize.width / modelInputSize.width;
-  float my1F = bboxModel.p1.y * maskSize.height / modelInputSize.height;
-  float mx2F = bboxModel.p2.x * maskSize.width / modelInputSize.width;
-  float my2F = bboxModel.p2.y * maskSize.height / modelInputSize.height;
-
-  int32_t mx1 = std::max(0, static_cast<int32_t>(std::floor(mx1F)));
-  int32_t my1 = std::max(0, static_cast<int32_t>(std::floor(my1F)));
-  int32_t mx2 = std::min(maskSize.width, static_cast<int32_t>(std::ceil(mx2F)));
-  int32_t my2 =
-      std::min(maskSize.height, static_cast<int32_t>(std::ceil(my2F)));
-
-  return {mx1, my1, mx2 - mx1, my2 - my1};
-}
-
-cv::Rect BaseInstanceSegmentation::addPaddingToRect(const cv::Rect &rect,
-                                                    cv::Size maskSize) {
-  int32_t x1 = std::max(0, rect.x - 1);
-  int32_t y1 = std::max(0, rect.y - 1);
-  int32_t x2 = std::min(maskSize.width, rect.x + rect.width + 1);
-  int32_t y2 = std::min(maskSize.height, rect.y + rect.height + 1);
-
-  return {x1, y1, x2 - x1, y2 - y1};
-}
-
-cv::Mat BaseInstanceSegmentation::warpToOriginalResolution(
-    const cv::Mat &probMat, const cv::Rect &maskRect, cv::Size originalSize,
-    cv::Size maskSize, const utils::computer_vision::BBox &bboxOriginal) {
-
-  float scaleX = static_cast<float>(originalSize.width) / maskSize.width;
-  float scaleY = static_cast<float>(originalSize.height) / maskSize.height;
-
-  cv::Mat M = (cv::Mat_<float>(2, 3) << scaleX, 0,
-               (maskRect.x * scaleX - bboxOriginal.p1.x), 0, scaleY,
-               (maskRect.y * scaleY - bboxOriginal.p1.y));
-
-  cv::Size bboxSize(static_cast<int32_t>(std::round(bboxOriginal.width())),
-                    static_cast<int32_t>(std::round(bboxOriginal.height())));
-
-  cv::Mat warped;
-  cv::warpAffine(probMat, warped, M, bboxSize, cv::INTER_LINEAR);
-  return warped;
-}
-
-cv::Mat BaseInstanceSegmentation::thresholdToBinary(const cv::Mat &probMat) {
-  cv::Mat binary;
-  cv::threshold(probMat, binary, 127, 1, cv::THRESH_BINARY);
-  return binary;
-}
-
-cv::Mat BaseInstanceSegmentation::processMaskFromLogits(
-    const cv::Mat &logitsMat, const utils::computer_vision::BBox &bboxModel,
-    const utils::computer_vision::BBox &bboxOriginal, cv::Size modelInputSize,
-    cv::Size originalSize, bool warpToOriginal) {
-
-  cv::Size maskSize = logitsMat.size();
-  cv::Rect cropRect = computeMaskCropRect(bboxModel, modelInputSize, maskSize);
-
-  if (warpToOriginal) {
-    cropRect = addPaddingToRect(cropRect, maskSize);
-  }
-
-  cv::Mat cropped = logitsMat(cropRect);
-  cv::Mat probMat = image_processing::applySigmoid(cropped);
-
-  if (warpToOriginal) {
-    probMat = warpToOriginalResolution(probMat, cropRect, originalSize,
-                                       maskSize, bboxOriginal);
-  }
-  return thresholdToBinary(probMat);
-}
-
-void BaseInstanceSegmentation::validateThresholds(double confidenceThreshold,
-                                                  double iouThreshold) const {
-  if (confidenceThreshold < 0 || confidenceThreshold > 1) {
-    throw RnExecutorchError(
-        RnExecutorchErrorCode::InvalidConfig,
-        "Confidence threshold must be greater or equal to 0 "
-        "and less than or equal to 1.");
-  }
-
-  if (iouThreshold < 0 || iouThreshold > 1) {
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidConfig,
-                            "IoU threshold must be greater or equal to 0 "
-                            "and less than or equal to 1.");
-  }
-}
-
-void BaseInstanceSegmentation::validateOutputTensors(
-    const std::vector<EValue> &tensors) const {
-  if (tensors.size() != 3) {
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidModelOutput,
-                            "Expected 3 output tensors ([1,N,4] + [1,N,2] + "
-                            "[1,N,H,W]), got " +
-                                std::to_string(tensors.size()));
-  }
-}
-
-std::set<int32_t> BaseInstanceSegmentation::prepareAllowedClasses(
-    const std::vector<int32_t> &classIndices) const {
-  std::set<int32_t> allowedClasses;
-  if (!classIndices.empty()) {
-    allowedClasses.insert(classIndices.begin(), classIndices.end());
-  }
-  return allowedClasses;
-}
-
-void BaseInstanceSegmentation::ensureMethodLoaded(
-    const std::string &methodName) {
-  if (methodName.empty()) {
-    throw RnExecutorchError(
-        RnExecutorchErrorCode::InvalidConfig,
-        "Method name cannot be empty. Use 'forward' for single-method models "
-        "or 'forward_{inputSize}' for multi-method models.");
-  }
-
-  if (currentlyLoadedMethod_ == methodName) {
-    return;
-  }
-
-  if (!module_) {
-    throw RnExecutorchError(RnExecutorchErrorCode::ModuleNotLoaded,
-                            "Model not loaded. Cannot load method '" +
-                                methodName + "'.");
-  }
-
-  if (!currentlyLoadedMethod_.empty()) {
-    module_->unload_method(currentlyLoadedMethod_);
-  }
-
-  auto loadResult = module_->load_method(methodName);
-  if (loadResult != executorch::runtime::Error::Ok) {
-    throw RnExecutorchError(
-        loadResult, "Failed to load method '" + methodName +
-                        "'. Ensure the method exists in the exported model.");
-  }
-
-  currentlyLoadedMethod_ = methodName;
-}
-
-std::vector<types::Instance> BaseInstanceSegmentation::finalizeInstances(
-    std::vector<types::Instance> instances, double iouThreshold,
-    int32_t maxInstances) const {
-
-  if (applyNMS_) {
-    instances =
-        utils::computer_vision::nonMaxSuppression(instances, iouThreshold);
-  }
-
-  if (std::cmp_greater(instances.size(), maxInstances)) {
-    instances.resize(maxInstances);
-  }
-
-  return instances;
-}
-
-std::vector<types::Instance> BaseInstanceSegmentation::collectInstances(
-    const std::vector<EValue> &tensors, cv::Size originalSize,
-    cv::Size modelInputSize, double confidenceThreshold,
-    const std::vector<int32_t> &classIndices,
-    bool returnMaskAtOriginalResolution) {
-
-  float widthRatio =
-      static_cast<float>(originalSize.width) / modelInputSize.width;
-  float heightRatio =
-      static_cast<float>(originalSize.height) / modelInputSize.height;
-  auto allowedClasses = prepareAllowedClasses(classIndices);
-
-  // CONTRACT
-  auto bboxTensor = tensors[0].toTensor();   // [1, N, 4]
-  auto scoresTensor = tensors[1].toTensor(); // [1, N, 2]
-  auto maskTensor = tensors[2].toTensor();   // [1, N, H, W]
-
-  int32_t numInstances = bboxTensor.size(1);
-  int32_t maskH = maskTensor.size(2);
-  int32_t maskW = maskTensor.size(3);
-
-  const float *bboxData = bboxTensor.const_data_ptr<float>();
-  const float *scoresData = scoresTensor.const_data_ptr<float>();
-  const float *maskData = maskTensor.const_data_ptr<float>();
-
-  auto isValidDetection =
-      [&allowedClasses, &confidenceThreshold](float score, int32_t labelIdx) {
-        return score >= confidenceThreshold &&
-               (allowedClasses.empty() || allowedClasses.count(labelIdx) != 0);
-      };
-
-  std::vector<types::Instance> instances;
-
-  for (int32_t i = 0; i < numInstances; ++i) {
-    auto [bboxModel, score, labelIdx] =
-        extractDetectionData(bboxData, scoresData, i);
-
-    if (!isValidDetection(score, labelIdx)) {
-      continue;
-    }
-
-    utils::computer_vision::BBox bboxOriginal =
-        bboxModel.scale(widthRatio, heightRatio);
-    if (!bboxOriginal.isValid()) {
-      continue;
-    }
-
-    cv::Mat logitsMat(maskH, maskW, CV_32FC1,
-                      const_cast<float *>(maskData + (i * maskH * maskW)));
-
-    cv::Mat binaryMask = processMaskFromLogits(
-        logitsMat, bboxModel, bboxOriginal, modelInputSize, originalSize,
-        returnMaskAtOriginalResolution);
-
-    instances.emplace_back(bboxOriginal,
-                           std::make_shared<OwningArrayBuffer>(
-                               binaryMask.data, binaryMask.total()),
-                           binaryMask.cols, binaryMask.rows, labelIdx, score);
-  }
-
-  return instances;
-}
-
-} // namespace rnexecutorch::models::instance_segmentation
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/instance_segmentation/BaseInstanceSegmentation.h b/packages/react-native-executorch/common/rnexecutorch/models/instance_segmentation/BaseInstanceSegmentation.h
deleted file mode 100644
index 341d0f2235..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/instance_segmentation/BaseInstanceSegmentation.h
+++ /dev/null
@@ -1,109 +0,0 @@
-#pragma once
-
-#include <executorch/extension/tensor/tensor_ptr.h>
-#include <executorch/runtime/core/evalue.h>
-#include <opencv2/opencv.hpp>
-#include <optional>
-#include <set>
-
-#include "Types.h"
-#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
-#include <rnexecutorch/models/VisionModel.h>
-#include <rnexecutorch/utils/computer_vision/Types.h>
-
-namespace rnexecutorch {
-namespace models::instance_segmentation {
-using executorch::extension::TensorPtr;
-using executorch::runtime::EValue;
-
-class BaseInstanceSegmentation : public VisionModel {
-public:
-  BaseInstanceSegmentation(const std::string &modelSource,
-                           std::vector<float> normMean,
-                           std::vector<float> normStd, bool applyNMS,
-                           std::shared_ptr<react::CallInvoker> callInvoker);
-
-  [[nodiscard("Registered non-void function")]] std::vector<types::Instance>
-  generateFromString(std::string imageSource, double confidenceThreshold,
-                     double iouThreshold, int32_t maxInstances,
-                     std::vector<int32_t> classIndices,
-                     bool returnMaskAtOriginalResolution,
-                     std::string methodName);
-
-  [[nodiscard("Registered non-void function")]] std::vector<types::Instance>
-  generateFromFrame(jsi::Runtime &runtime, const jsi::Value &frameData,
-                    double confidenceThreshold, double iouThreshold,
-                    int32_t maxInstances, std::vector<int32_t> classIndices,
-                    bool returnMaskAtOriginalResolution,
-                    std::string methodName);
-
-  [[nodiscard("Registered non-void function")]] std::vector<types::Instance>
-  generateFromPixels(JSTensorViewIn tensorView, double confidenceThreshold,
-                     double iouThreshold, int32_t maxInstances,
-                     std::vector<int32_t> classIndices,
-                     bool returnMaskAtOriginalResolution,
-                     std::string methodName);
-
-protected:
-  cv::Size modelInputSize() const override;
-
-private:
-  std::vector<types::Instance> runInference(
-      const cv::Mat &image, double confidenceThreshold, double iouThreshold,
-      int32_t maxInstances, const std::vector<int32_t> &classIndices,
-      bool returnMaskAtOriginalResolution, const std::string &methodName);
-
-  TensorPtr buildInputTensor(const cv::Mat &image);
-
-  std::vector<types::Instance>
-  collectInstances(const std::vector<EValue> &tensors, cv::Size originalSize,
-                   cv::Size modelInputSize, double confidenceThreshold,
-                   const std::vector<int32_t> &classIndices,
-                   bool returnMaskAtOriginalResolution);
-
-  void validateThresholds(double confidenceThreshold,
-                          double iouThreshold) const;
-  void validateOutputTensors(const std::vector<EValue> &tensors) const;
-
-  std::set<int32_t>
-  prepareAllowedClasses(const std::vector<int32_t> &classIndices) const;
-
-  // Model loading and input helpers
-  void ensureMethodLoaded(const std::string &methodName);
-
-  std::tuple<utils::computer_vision::BBox, float, int32_t>
-  extractDetectionData(const float *bboxData, const float *scoresData,
-                       int32_t index);
-
-  cv::Rect computeMaskCropRect(const utils::computer_vision::BBox &bboxModel,
-                               cv::Size modelInputSize, cv::Size maskSize);
-
-  cv::Rect addPaddingToRect(const cv::Rect &rect, cv::Size maskSize);
-
-  cv::Mat
-  warpToOriginalResolution(const cv::Mat &probMat, const cv::Rect &maskRect,
-                           cv::Size originalSize, cv::Size maskSize,
-                           const utils::computer_vision::BBox &bboxOriginal);
-
-  cv::Mat thresholdToBinary(const cv::Mat &probMat);
-
-  std::vector<types::Instance>
-  finalizeInstances(std::vector<types::Instance> instances, double iouThreshold,
-                    int32_t maxInstances) const;
-
-  cv::Mat processMaskFromLogits(
-      const cv::Mat &logitsMat, const utils::computer_vision::BBox &bboxModel,
-      const utils::computer_vision::BBox &bboxOriginal, cv::Size modelInputSize,
-      cv::Size originalSize, bool warpToOriginal);
-
-  std::optional<cv::Scalar> normMean_;
-  std::optional<cv::Scalar> normStd_;
-  bool applyNMS_;
-  std::string currentlyLoadedMethod_;
-};
-} // namespace models::instance_segmentation
-
-REGISTER_CONSTRUCTOR(models::instance_segmentation::BaseInstanceSegmentation,
-                     std::string, std::vector<float>, std::vector<float>, bool,
-                     std::shared_ptr<react::CallInvoker>);
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/instance_segmentation/Types.h b/packages/react-native-executorch/common/rnexecutorch/models/instance_segmentation/Types.h
deleted file mode 100644
index 9006688ce1..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/instance_segmentation/Types.h
+++ /dev/null
@@ -1,33 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <memory>
-#include <rnexecutorch/jsi/OwningArrayBuffer.h>
-#include <rnexecutorch/utils/computer_vision/Types.h>
-
-namespace rnexecutorch::models::instance_segmentation::types {
-
-/**
- * Represents a single detected instance in instance segmentation output.
- *
- * Contains bounding box coordinates, binary segmentation mask, class label,
- * and confidence score.
- */
-struct Instance {
-
-  Instance() = default;
-  Instance(utils::computer_vision::BBox bbox,
-           std::shared_ptr<OwningArrayBuffer> mask, int32_t maskWidth,
-           int32_t maskHeight, int32_t classIndex, float score)
-      : bbox(bbox), mask(std::move(mask)), maskWidth(maskWidth),
-        maskHeight(maskHeight), classIndex(classIndex), score(score) {}
-
-  utils::computer_vision::BBox bbox;
-  std::shared_ptr<OwningArrayBuffer> mask;
-  int32_t maskWidth;
-  int32_t maskHeight;
-  int32_t classIndex;
-  float score;
-};
-
-} // namespace rnexecutorch::models::instance_segmentation::types
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/llm/LLM.cpp b/packages/react-native-executorch/common/rnexecutorch/models/llm/LLM.cpp
deleted file mode 100644
index 924bba9f99..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/llm/LLM.cpp
+++ /dev/null
@@ -1,304 +0,0 @@
-#include "LLM.h"
-#include "rnexecutorch/models/llm/Types.h"
-
-#include <executorch/extension/tensor/tensor.h>
-#include <filesystem>
-#include <map>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/threads/GlobalThreadPool.h>
-#include <runner/encoders/audio_encoder.h>
-#include <runner/encoders/vision_encoder.h>
-#include <runner/multimodal_runner.h>
-#include <runner/text_runner.h>
-
-namespace rnexecutorch::models::llm {
-namespace llm = ::executorch::extension::llm;
-namespace fs = std::filesystem;
-using namespace facebook;
-using executorch::extension::module::Module;
-using executorch::runtime::Error;
-
-LLM::LLM(const std::string &modelSource, const std::string &tokenizerSource,
-         std::vector<std::string> capabilities,
-         std::shared_ptr<react::CallInvoker> callInvoker)
-    : BaseModel(modelSource, callInvoker, Module::LoadMode::Mmap) {
-  if (capabilities.empty()) {
-    runner_ =
-        std::make_unique<llm::TextRunner>(std::move(module_), tokenizerSource);
-  } else {
-    std::map<llm::MultimodalType, std::unique_ptr<llm::IEncoder>> encoders;
-    for (const auto &cap : capabilities) {
-      if (cap == "vision") {
-        encoders[llm::MultimodalType::Image] =
-            std::make_unique<llm::VisionEncoder>(*module_);
-      } else if (cap == "audio") {
-        encoders[llm::MultimodalType::Audio] =
-            std::make_unique<llm::AudioEncoder>(*module_);
-      }
-    }
-    runner_ = std::make_unique<llm::MultimodalRunner>(
-        std::move(module_), tokenizerSource, std::move(encoders));
-  }
-
-  auto loadResult = runner_->load();
-  if (loadResult != Error::Ok) {
-    throw RnExecutorchError(loadResult, "Failed to load LLM runner");
-  }
-
-  // I am purposefully not adding file size of the model here. The reason is
-  // that Hermes would crash the app if we try to alloc too much memory here.
-  // Also, given we're using mmap, the true memory consumption of a model is not
-  // really equal to the size of the model. The size of the tokenizer file is a
-  // hint to the GC that this object might be worth getting rid of.
-  memorySizeLowerBound = fs::file_size(fs::path(tokenizerSource));
-}
-
-std::string LLM::generate(std::string input,
-                          std::shared_ptr<jsi::Function> callback) {
-  if (!runner_ || !runner_->is_loaded()) {
-    throw RnExecutorchError(RnExecutorchErrorCode::ModuleNotLoaded,
-                            "Runner is not loaded");
-  }
-  std::string output;
-  auto nativeCallback = [this, callback, &output](const std::string &token) {
-    output += token;
-    if (callback && callInvoker) {
-      callInvoker->invokeAsync([callback, token](jsi::Runtime &runtime) {
-        callback->call(runtime, jsi::String::createFromUtf8(runtime, token));
-      });
-    }
-  };
-
-  auto config = llm::GenerationConfig{.echo = false, .warming = false};
-  auto error = runner_->generate(input, config, nativeCallback, {});
-  if (error != Error::Ok) {
-    throw RnExecutorchError(error, "Failed to generate text");
-  }
-  return output;
-}
-
-std::string LLM::generateMultimodal(std::string prompt,
-                                    std::shared_ptr<jsi::Function> callback,
-                                    MultimodalInputs mutlimodalInputs) {
-  if (!runner_ || !runner_->is_loaded()) {
-    throw RnExecutorchError(RnExecutorchErrorCode::ModuleNotLoaded,
-                            "Runner is not loaded");
-  }
-  if (!runner_->is_multimodal()) {
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidUserInput,
-                            "This model does not support multimodal input.");
-  }
-  if (!mutlimodalInputs.images.has_value() &&
-      !mutlimodalInputs.audios.has_value()) {
-    throw RnExecutorchError(
-        RnExecutorchErrorCode::InvalidUserInput,
-        "At least one of imageToken/audioToken must be non-empty");
-  }
-
-  // Scan the prompt once, splitting at the earliest placeholder at each step
-  // so that image/audio placeholders can be freely interleaved in the prompt.
-  std::vector<llm::MultimodalInput> inputs;
-  size_t imageIdx = 0, audioIdx = 0, pos = 0;
-  while (pos < prompt.size()) {
-    size_t imgAt = mutlimodalInputs.images.has_value()
-                       ? prompt.find(mutlimodalInputs.images.value().token, pos)
-                       : std::string::npos;
-    size_t audAt = mutlimodalInputs.audios.has_value()
-                       ? prompt.find(mutlimodalInputs.audios.value().token, pos)
-                       : std::string::npos;
-    if (imgAt == std::string::npos && audAt == std::string::npos) {
-      inputs.push_back(llm::make_text_input(prompt.substr(pos)));
-      break;
-    }
-    const bool imageFirst = imgAt != std::string::npos &&
-                            (audAt == std::string::npos || imgAt < audAt);
-    size_t at = imageFirst ? imgAt : audAt;
-    if (at > pos) {
-      inputs.push_back(llm::make_text_input(prompt.substr(pos, at - pos)));
-    }
-    if (imageFirst) {
-      auto &images = mutlimodalInputs.images.value();
-      if (imageIdx >= images.paths.size()) {
-        throw RnExecutorchError(RnExecutorchErrorCode::InvalidUserInput,
-                                "More '" + images.token +
-                                    "' placeholders than image paths");
-      }
-      inputs.push_back(llm::make_image_input(images.paths[imageIdx++]));
-      pos = at + images.token.size();
-    } else {
-      auto &audios = mutlimodalInputs.audios.value();
-      if (audioIdx >= audios.waveforms.size()) {
-        throw RnExecutorchError(RnExecutorchErrorCode::InvalidUserInput,
-                                "More '" + audios.token +
-                                    "' placeholders than audio waveforms");
-      }
-      inputs.push_back(
-          llm::make_audio_input(std::move(audios.waveforms[audioIdx++])));
-      pos = at + audios.token.size();
-    }
-  }
-  if ((mutlimodalInputs.images.has_value() &&
-       imageIdx < mutlimodalInputs.images.value().paths.size()) ||
-      (mutlimodalInputs.audios.has_value() &&
-       audioIdx < mutlimodalInputs.audios.value().waveforms.size())) {
-    throw RnExecutorchError(
-        RnExecutorchErrorCode::InvalidUserInput,
-        "More image/audio paths provided than placeholders in prompt");
-  }
-  if (inputs.empty()) {
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidUserInput,
-                            "No inputs to generate from");
-  }
-
-  std::string output;
-  auto nativeCallback = [this, callback, &output](const std::string &token) {
-    output += token;
-    if (callback && callInvoker) {
-      callInvoker->invokeAsync([callback, token](jsi::Runtime &runtime) {
-        callback->call(runtime, jsi::String::createFromUtf8(runtime, token));
-      });
-    }
-  };
-
-  auto error = runner_->generate(inputs, nativeCallback);
-  if (error != Error::Ok) {
-    throw RnExecutorchError(error, "Failed to generate multimodal response");
-  }
-  return output;
-}
-
-void LLM::interrupt() {
-  if (!runner_ || !runner_->is_loaded()) {
-    throw RnExecutorchError(RnExecutorchErrorCode::ModuleNotLoaded,
-                            "Can't interrupt a model that's not loaded");
-  }
-  runner_->stop();
-}
-
-void LLM::reset() {
-  if (!runner_ || !runner_->is_loaded()) {
-    throw RnExecutorchError(RnExecutorchErrorCode::ModuleNotLoaded,
-                            "Can't reset a model that's not loaded");
-  }
-  runner_->reset();
-}
-
-int32_t LLM::getGeneratedTokenCount() const noexcept {
-  if (!runner_ || !runner_->is_loaded())
-    return 0;
-  return runner_->stats_.num_generated_tokens;
-}
-
-int32_t LLM::getPromptTokenCount() const noexcept {
-  if (!runner_ || !runner_->is_loaded())
-    return 0;
-  return static_cast<int32_t>(runner_->stats_.num_prompt_tokens);
-}
-
-int32_t LLM::getVisualTokenCount() const {
-  if (!runner_ || !runner_->is_loaded()) {
-    return 0;
-  }
-  return static_cast<int32_t>(runner_->get_visual_token_count());
-}
-
-int32_t LLM::countTextTokens(std::string text) const {
-  if (!runner_ || !runner_->is_loaded()) {
-    throw RnExecutorchError(
-        RnExecutorchErrorCode::ModuleNotLoaded,
-        "Can't count tokens from a model that's not loaded");
-  }
-  return runner_->count_text_tokens(text);
-}
-
-size_t LLM::getMemoryLowerBound() const noexcept {
-  return memorySizeLowerBound;
-}
-
-void LLM::setCountInterval(size_t countInterval) {
-  if (!runner_ || !runner_->is_loaded()) {
-    throw RnExecutorchError(RnExecutorchErrorCode::ModuleNotLoaded,
-                            "Can't configure a model that's not loaded");
-  }
-  if (countInterval == 0) {
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidConfig,
-                            "Count interval must be greater than 0");
-  }
-  runner_->set_count_interval(countInterval);
-}
-
-void LLM::setTimeInterval(size_t timeInterval) {
-  if (!runner_ || !runner_->is_loaded()) {
-    throw RnExecutorchError(RnExecutorchErrorCode::ModuleNotLoaded,
-                            "Can't configure a model that's not loaded");
-  }
-  if (timeInterval == 0) {
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidConfig,
-                            "Time interval must be greater than 0");
-  }
-  runner_->set_time_interval(timeInterval);
-}
-
-void LLM::setTemperature(float temperature) {
-  if (!runner_ || !runner_->is_loaded()) {
-    throw RnExecutorchError(RnExecutorchErrorCode::ModuleNotLoaded,
-                            "Can't configure a model that's not loaded");
-  }
-  if (temperature < 0.0f) {
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidConfig,
-                            "Temperature must be non-negative");
-  }
-  runner_->set_temperature(temperature);
-}
-
-void LLM::setTopp(float topp) {
-  if (!runner_ || !runner_->is_loaded()) {
-    throw RnExecutorchError(RnExecutorchErrorCode::ModuleNotLoaded,
-                            "Can't configure a model that's not loaded");
-  }
-  if (topp < 0.0f || topp > 1.0f) {
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidConfig,
-                            "Top-p must be between 0.0 and 1.0");
-  }
-  runner_->set_topp(topp);
-}
-
-void LLM::setMinP(float minP) {
-  if (!runner_ || !runner_->is_loaded()) {
-    throw RnExecutorchError(RnExecutorchErrorCode::ModuleNotLoaded,
-                            "Can't configure a model that's not loaded");
-  }
-  if (minP < 0.0f || minP > 1.0f) {
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidConfig,
-                            "Min-p must be between 0.0 and 1.0");
-  }
-  runner_->set_min_p(minP);
-}
-
-void LLM::setRepetitionPenalty(float repetitionPenalty) {
-  if (!runner_ || !runner_->is_loaded()) {
-    throw RnExecutorchError(RnExecutorchErrorCode::ModuleNotLoaded,
-                            "Can't configure a model that's not loaded");
-  }
-  if (repetitionPenalty < 0.0f) {
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidConfig,
-                            "Repetition penalty must be non-negative");
-  }
-  runner_->set_repetition_penalty(repetitionPenalty);
-}
-
-int32_t LLM::getMaxContextLength() const {
-  if (!runner_ || !runner_->is_loaded()) {
-    throw RnExecutorchError(
-        RnExecutorchErrorCode::ModuleNotLoaded,
-        "Can't get context length from a model that's not loaded");
-  }
-  return runner_->get_max_context_length();
-}
-
-void LLM::unload() noexcept {
-  runner_.reset(nullptr);
-  BaseModel::unload();
-}
-
-} // namespace rnexecutorch::models::llm
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/llm/LLM.h b/packages/react-native-executorch/common/rnexecutorch/models/llm/LLM.h
deleted file mode 100644
index 4b7087351b..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/llm/LLM.h
+++ /dev/null
@@ -1,55 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include <ReactCommon/CallInvoker.h>
-#include <jsi/jsi.h>
-#include <rnexecutorch/models/BaseModel.h>
-#include <rnexecutorch/models/llm/Types.h>
-#include <runner/base_llm_runner.h>
-
-namespace rnexecutorch {
-namespace models::llm {
-using namespace facebook;
-
-class LLM : public BaseModel {
-public:
-  explicit LLM(const std::string &modelSource,
-               const std::string &tokenizerSource,
-               std::vector<std::string> capabilities,
-               std::shared_ptr<react::CallInvoker> callInvoker);
-
-  std::string generate(std::string prompt,
-                       std::shared_ptr<jsi::Function> callback);
-
-  std::string generateMultimodal(std::string prompt,
-                                 std::shared_ptr<jsi::Function> callback,
-                                 MultimodalInputs mutlimodalInputs = {});
-
-  void interrupt();
-  void reset();
-  void unload() noexcept;
-  int32_t getGeneratedTokenCount() const noexcept;
-  int32_t getPromptTokenCount() const noexcept;
-  int32_t countTextTokens(std::string text) const;
-  int32_t getVisualTokenCount() const;
-  size_t getMemoryLowerBound() const noexcept;
-  void setCountInterval(size_t countInterval);
-  void setTemperature(float temperature);
-  void setTopp(float topp);
-  void setMinP(float minP);
-  void setRepetitionPenalty(float repetitionPenalty);
-  void setTimeInterval(size_t timeInterval);
-  int32_t getMaxContextLength() const;
-
-private:
-  std::unique_ptr<::executorch::extension::llm::BaseLLMRunner> runner_;
-};
-} // namespace models::llm
-
-REGISTER_CONSTRUCTOR(models::llm::LLM, std::string, std::string,
-                     std::vector<std::string>,
-                     std::shared_ptr<react::CallInvoker>);
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/llm/Types.h b/packages/react-native-executorch/common/rnexecutorch/models/llm/Types.h
deleted file mode 100644
index 921d4fa8f4..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/llm/Types.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#pragma once
-
-#include <optional>
-#include <string>
-#include <vector>
-
-namespace rnexecutorch::models::llm {
-struct ImageInputs {
-  std::vector<std::string> paths;
-  std::string token;
-};
-
-struct AudioInputs {
-  std::vector<std::vector<float>> waveforms;
-  std::string token;
-};
-
-struct MultimodalInputs {
-  std::optional<ImageInputs> images;
-  std::optional<AudioInputs> audios;
-};
-
-} // namespace rnexecutorch::models::llm
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/object_detection/Constants.h b/packages/react-native-executorch/common/rnexecutorch/models/object_detection/Constants.h
deleted file mode 100644
index 95d58d596d..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/object_detection/Constants.h
+++ /dev/null
@@ -1,5 +0,0 @@
-#pragma once
-
-namespace rnexecutorch::models::object_detection::constants {
-inline constexpr float IOU_THRESHOLD = 0.55f;
-} // namespace rnexecutorch::models::object_detection::constants
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/object_detection/ObjectDetection.cpp b/packages/react-native-executorch/common/rnexecutorch/models/object_detection/ObjectDetection.cpp
deleted file mode 100644
index 24c4e1083a..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/object_detection/ObjectDetection.cpp
+++ /dev/null
@@ -1,231 +0,0 @@
-#include "ObjectDetection.h"
-#include "Constants.h"
-
-#include <set>
-
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-#include <rnexecutorch/Log.h>
-#include <rnexecutorch/data_processing/ImageProcessing.h>
-#include <rnexecutorch/host_objects/JsiConversions.h>
-#include <rnexecutorch/utils/FrameProcessor.h>
-#include <rnexecutorch/utils/FrameTransform.h>
-#include <rnexecutorch/utils/computer_vision/Processing.h>
-
-namespace rnexecutorch::models::object_detection {
-
-ObjectDetection::ObjectDetection(
-    const std::string &modelSource, std::vector<float> normMean,
-    std::vector<float> normStd, std::vector<std::string> labelNames,
-    std::shared_ptr<react::CallInvoker> callInvoker)
-    : VisionModel(modelSource, callInvoker),
-      labelNames_(std::move(labelNames)) {
-  if (normMean.size() == 3) {
-    normMean_ = cv::Scalar(normMean[0], normMean[1], normMean[2]);
-  } else if (!normMean.empty()) {
-    log(LOG_LEVEL::Warn,
-        "normMean must have 3 elements — ignoring provided value.");
-  }
-  if (normStd.size() == 3) {
-    normStd_ = cv::Scalar(normStd[0], normStd[1], normStd[2]);
-  } else if (!normStd.empty()) {
-    log(LOG_LEVEL::Warn,
-        "normStd must have 3 elements — ignoring provided value.");
-  }
-}
-
-cv::Size ObjectDetection::modelInputSize() const {
-  if (currentlyLoadedMethod_.empty()) {
-    return VisionModel::modelInputSize();
-  }
-  auto inputShapes = getAllInputShapes(currentlyLoadedMethod_);
-  if (inputShapes.empty() || inputShapes[0].size() < 2) {
-    throw RnExecutorchError(RnExecutorchErrorCode::UnexpectedNumInputs,
-                            "Could not determine input shape for method: " +
-                                currentlyLoadedMethod_);
-  }
-  const auto &shape = inputShapes[0];
-  return {static_cast<int32_t>(shape[shape.size() - 2]),
-          static_cast<int32_t>(shape[shape.size() - 1])};
-}
-
-void ObjectDetection::ensureMethodLoaded(const std::string &methodName) {
-  if (methodName.empty()) {
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidUserInput,
-                            "methodName cannot be empty");
-  }
-  if (currentlyLoadedMethod_ == methodName) {
-    return;
-  }
-  if (!module_) {
-    throw RnExecutorchError(RnExecutorchErrorCode::ModuleNotLoaded,
-                            "Model module is not loaded");
-  }
-  if (!currentlyLoadedMethod_.empty()) {
-    module_->unload_method(currentlyLoadedMethod_);
-  }
-  auto loadResult = module_->load_method(methodName);
-  if (loadResult != executorch::runtime::Error::Ok) {
-    throw RnExecutorchError(
-        loadResult, "Failed to load method '" + methodName +
-                        "'. Ensure the method exists in the exported model.");
-  }
-  currentlyLoadedMethod_ = methodName;
-}
-
-std::set<int32_t> ObjectDetection::prepareAllowedClasses(
-    const std::vector<int32_t> &classIndices) const {
-  std::set<int32_t> allowedClasses;
-  if (!classIndices.empty()) {
-    allowedClasses.insert(classIndices.begin(), classIndices.end());
-  }
-  return allowedClasses;
-}
-
-std::vector<types::Detection>
-ObjectDetection::postprocess(const std::vector<EValue> &tensors,
-                             cv::Size originalSize, double detectionThreshold,
-                             double iouThreshold,
-                             const std::vector<int32_t> &classIndices) {
-  const cv::Size inputSize = modelInputSize();
-  float widthRatio = static_cast<float>(originalSize.width) / inputSize.width;
-  float heightRatio =
-      static_cast<float>(originalSize.height) / inputSize.height;
-
-  // Prepare allowed classes set for filtering
-  auto allowedClasses = prepareAllowedClasses(classIndices);
-
-  std::vector<types::Detection> detections;
-  auto bboxTensor = tensors.at(0).toTensor();
-  std::span<const float> bboxes(
-      static_cast<const float *>(bboxTensor.const_data_ptr()),
-      bboxTensor.numel());
-
-  auto scoreTensor = tensors.at(1).toTensor();
-  std::span<const float> scores(
-      static_cast<const float *>(scoreTensor.const_data_ptr()),
-      scoreTensor.numel());
-
-  auto labelTensor = tensors.at(2).toTensor();
-  std::span<const float> labels(
-      static_cast<const float *>(labelTensor.const_data_ptr()),
-      labelTensor.numel());
-
-  for (std::size_t i = 0; i < scores.size(); ++i) {
-    if (scores[i] < detectionThreshold) {
-      continue;
-    }
-
-    auto labelIdx = static_cast<int32_t>(labels[i]);
-
-    // Filter by class if classesOfInterest is specified
-    if (!allowedClasses.empty() &&
-        allowedClasses.find(labelIdx) == allowedClasses.end()) {
-      continue;
-    }
-
-    float x1 = bboxes[i * 4] * widthRatio;
-    float y1 = bboxes[i * 4 + 1] * heightRatio;
-    float x2 = bboxes[i * 4 + 2] * widthRatio;
-    float y2 = bboxes[i * 4 + 3] * heightRatio;
-
-    if (std::cmp_greater_equal(labelIdx, labelNames_.size())) {
-      throw RnExecutorchError(
-          RnExecutorchErrorCode::InvalidConfig,
-          "Model output class index " + std::to_string(labelIdx) +
-              " exceeds labelNames size " + std::to_string(labelNames_.size()) +
-              ". Ensure the labelMap covers all model output classes.");
-    }
-    detections.emplace_back(utils::computer_vision::BBox{x1, y1, x2, y2},
-                            labelNames_[labelIdx], labelIdx, scores[i]);
-  }
-
-  return utils::computer_vision::nonMaxSuppression(detections, iouThreshold);
-}
-
-std::vector<types::Detection> ObjectDetection::runInference(
-    cv::Mat image, double detectionThreshold, double iouThreshold,
-    const std::vector<int32_t> &classIndices, const std::string &methodName) {
-  if (detectionThreshold < 0.0 || detectionThreshold > 1.0) {
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidUserInput,
-                            "detectionThreshold must be in range [0, 1]");
-  }
-  if (iouThreshold < 0.0 || iouThreshold > 1.0) {
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidUserInput,
-                            "iouThreshold must be in range [0, 1]");
-  }
-
-  std::scoped_lock lock(inference_mutex_);
-
-  // Ensure the correct method is loaded
-  ensureMethodLoaded(methodName);
-
-  cv::Size originalSize = image.size();
-
-  // Query input shapes for the currently loaded method
-  auto inputShapes = getAllInputShapes(methodName);
-  if (inputShapes.empty() || inputShapes[0].size() < 2) {
-    throw RnExecutorchError(RnExecutorchErrorCode::UnexpectedNumInputs,
-                            "Could not determine input shape for method: " +
-                                methodName);
-  }
-  modelInputShape_ = inputShapes[0];
-
-  cv::Mat preprocessed = preprocess(image);
-
-  auto inputTensor =
-      (normMean_ && normStd_)
-          ? image_processing::getTensorFromMatrix(
-                modelInputShape_, preprocessed, *normMean_, *normStd_)
-          : image_processing::getTensorFromMatrix(modelInputShape_,
-                                                  preprocessed);
-
-  auto executeResult = execute(methodName, {inputTensor});
-  if (!executeResult.ok()) {
-    throw RnExecutorchError(executeResult.error(),
-                            "The model's " + methodName +
-                                " method did not succeed. "
-                                "Ensure the model input is correct.");
-  }
-
-  return postprocess(executeResult.get(), originalSize, detectionThreshold,
-                     iouThreshold, classIndices);
-}
-
-std::vector<types::Detection> ObjectDetection::generateFromString(
-    std::string imageSource, double detectionThreshold, double iouThreshold,
-    std::vector<int32_t> classIndices, std::string methodName) {
-  cv::Mat imageBGR = image_processing::readImage(imageSource);
-
-  cv::Mat imageRGB;
-  cv::cvtColor(imageBGR, imageRGB, cv::COLOR_BGR2RGB);
-
-  return runInference(imageRGB, detectionThreshold, iouThreshold, classIndices,
-                      methodName);
-}
-
-std::vector<types::Detection> ObjectDetection::generateFromFrame(
-    jsi::Runtime &runtime, const jsi::Value &frameData,
-    double detectionThreshold, double iouThreshold,
-    std::vector<int32_t> classIndices, std::string methodName) {
-  auto orient = ::rnexecutorch::utils::readFrameOrientation(runtime, frameData);
-  cv::Mat frame = extractFromFrame(runtime, frameData);
-  cv::Mat rotated = ::rnexecutorch::utils::rotateFrameForModel(frame, orient);
-  auto detections = runInference(rotated, detectionThreshold, iouThreshold,
-                                 classIndices, methodName);
-
-  for (auto &det : detections) {
-    ::rnexecutorch::utils::inverseRotateBbox(det.bbox, orient, rotated.size());
-  }
-  return detections;
-}
-
-std::vector<types::Detection> ObjectDetection::generateFromPixels(
-    JSTensorViewIn pixelData, double detectionThreshold, double iouThreshold,
-    std::vector<int32_t> classIndices, std::string methodName) {
-  cv::Mat image = extractFromPixels(pixelData);
-
-  return runInference(image, detectionThreshold, iouThreshold, classIndices,
-                      methodName);
-}
-} // namespace rnexecutorch::models::object_detection
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/object_detection/ObjectDetection.h b/packages/react-native-executorch/common/rnexecutorch/models/object_detection/ObjectDetection.h
deleted file mode 100644
index 6e3c01356e..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/object_detection/ObjectDetection.h
+++ /dev/null
@@ -1,165 +0,0 @@
-#pragma once
-
-#include <executorch/extension/tensor/tensor_ptr.h>
-#include <executorch/runtime/core/evalue.h>
-#include <opencv2/opencv.hpp>
-#include <optional>
-
-#include "Types.h"
-#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
-#include <rnexecutorch/models/VisionModel.h>
-
-namespace rnexecutorch {
-namespace models::object_detection {
-using executorch::extension::TensorPtr;
-using executorch::runtime::EValue;
-
-/**
- * @brief Object detection model that detects and localises objects in images.
- *
- * Wraps an ExecuTorch model and exposes a single @ref generate call that
- * preprocesses an input image, runs the forward pass, and returns a filtered,
- * non-max-suppressed list of @ref types::Detection results.
- */
-class ObjectDetection : public VisionModel {
-public:
-  /**
-   * @brief Constructs an ObjectDetection model and loads it from disk.
-   *
-   * @param modelSource  Path to the `.pte` model file.
-   * @param normMean     Per-channel mean values used for input normalisation
-   *                     (must be exactly 3 elements, or empty to skip).
-   * @param normStd      Per-channel standard-deviation values used for input
-   *                     normalisation (must be exactly 3 elements, or empty to
-   *                     skip).
-   * @param labelNames   Ordered list of class label strings. Index @c i must
-   *                     correspond to class index @c i produced by the model.
-   *                     This is a runtime value passed from JS side,
-   *                     dependant the model. The user can pass his own, custom
-   *                     labels.
-   * @param callInvoker  JSI call invoker used to marshal results back to JS.
-   *
-   * @throws RnExecutorchError if the model cannot be loaded or its input shape
-   *         is incompatible.
-   */
-  ObjectDetection(const std::string &modelSource, std::vector<float> normMean,
-                  std::vector<float> normStd,
-                  std::vector<std::string> labelNames,
-                  std::shared_ptr<react::CallInvoker> callInvoker);
-
-  /**
-   * @brief Runs object detection on a single image.
-   *
-   * Preprocesses the image, executes the model's forward pass, and returns
-   * all detections whose confidence score meets @p detectionThreshold after
-   * non-maximum suppression.
-   *
-   * @param imageSource        URI or file path of the input image.
-   * @param detectionThreshold Minimum confidence score in (0, 1] for a
-   *                           detection to be included in the output.
-   * @param iouThreshold       IoU threshold for non-maximum suppression.
-   * @param classIndices       Optional list of class indices to filter results.
-   *                           Only detections matching these classes will be
-   *                           returned. Pass empty vector to include all
-   * classes.
-   * @param methodName         Name of the method to execute (e.g., "forward",
-   *                           "forward_384", "forward_512", "forward_640").
-   *
-   * @return A vector of @ref types::Detection objects with bounding boxes,
-   *         label strings (resolved via the label names passed to the
-   *         constructor), and confidence scores.
-   *
-   * @throws RnExecutorchError if the image cannot be read or the forward pass
-   *         fails.
-   */
-  [[nodiscard("Registered non-void function")]] std::vector<types::Detection>
-  generateFromString(std::string imageSource, double detectionThreshold,
-                     double iouThreshold, std::vector<int32_t> classIndices,
-                     std::string methodName);
-  [[nodiscard("Registered non-void function")]] std::vector<types::Detection>
-  generateFromFrame(jsi::Runtime &runtime, const jsi::Value &frameData,
-                    double detectionThreshold, double iouThreshold,
-                    std::vector<int32_t> classIndices, std::string methodName);
-  [[nodiscard("Registered non-void function")]] std::vector<types::Detection>
-  generateFromPixels(JSTensorViewIn pixelData, double detectionThreshold,
-                     double iouThreshold, std::vector<int32_t> classIndices,
-                     std::string methodName);
-
-protected:
-  /**
-   * @brief Returns the model input size based on the currently loaded method.
-   *
-   * Overrides VisionModel::modelInputSize() to support multi-method models
-   * where each method may have different input dimensions.
-   *
-   * @return The expected input size for the currently loaded method.
-   */
-  cv::Size modelInputSize() const override;
-
-  std::vector<types::Detection>
-  runInference(cv::Mat image, double detectionThreshold, double iouThreshold,
-               const std::vector<int32_t> &classIndices,
-               const std::string &methodName);
-
-private:
-  /**
-   * @brief Decodes raw model output tensors into a list of detections.
-   *
-   * @param tensors            Raw EValue outputs from the forward pass
-   *                           (bboxes at index 0, scores at index 1,
-   *                           labels at index 2).
-   * @param originalSize       Original image dimensions used to scale
-   *                           bounding boxes back to input coordinates.
-   * @param detectionThreshold Confidence threshold below which detections
-   *                           are discarded.
-   * @param iouThreshold       IoU threshold for non-maximum suppression.
-   * @param classIndices       Optional list of class indices to filter results.
-   *
-   * @return Non-max-suppressed detections above the threshold.
-   *
-   * @throws RnExecutorchError if the model outputs a class index that exceeds
-   *         the size of @ref labelNames_.
-   */
-  std::vector<types::Detection>
-  postprocess(const std::vector<EValue> &tensors, cv::Size originalSize,
-              double detectionThreshold, double iouThreshold,
-              const std::vector<int32_t> &classIndices);
-
-  /**
-   * @brief Ensures the specified method is loaded, unloading any previous
-   * method if necessary.
-   *
-   * @param methodName Name of the method to load (e.g., "forward",
-   * "forward_384").
-   * @throws RnExecutorchError if the method cannot be loaded.
-   */
-  void ensureMethodLoaded(const std::string &methodName);
-
-  /**
-   * @brief Prepares a set of allowed class indices for filtering detections.
-   *
-   * @param classIndices Vector of class indices to allow.
-   * @return A set containing the allowed class indices.
-   */
-  std::set<int32_t>
-  prepareAllowedClasses(const std::vector<int32_t> &classIndices) const;
-
-  /// Optional per-channel mean for input normalisation (set in constructor).
-  std::optional<cv::Scalar> normMean_;
-
-  /// Optional per-channel standard deviation for input normalisation.
-  std::optional<cv::Scalar> normStd_;
-
-  /// Ordered label strings mapping class indices to human-readable names.
-  std::vector<std::string> labelNames_;
-
-  /// Name of the currently loaded method (for multi-method models).
-  std::string currentlyLoadedMethod_;
-};
-} // namespace models::object_detection
-
-REGISTER_CONSTRUCTOR(models::object_detection::ObjectDetection, std::string,
-                     std::vector<float>, std::vector<float>,
-                     std::vector<std::string>,
-                     std::shared_ptr<react::CallInvoker>);
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/object_detection/Types.h b/packages/react-native-executorch/common/rnexecutorch/models/object_detection/Types.h
deleted file mode 100644
index 1652516e89..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/object_detection/Types.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <rnexecutorch/utils/computer_vision/Types.h>
-#include <string>
-
-namespace rnexecutorch::models::object_detection::types {
-struct Detection {
-
-  Detection() = default;
-  Detection(utils::computer_vision::BBox bbox, std::string label,
-            int32_t classIndex, float score)
-      : bbox(bbox), label(std::move(label)), classIndex(classIndex),
-        score(score) {}
-
-  utils::computer_vision::BBox bbox;
-  std::string label;
-  int32_t classIndex;
-  float score;
-};
-
-} // namespace rnexecutorch::models::object_detection::types
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/ocr/CTCLabelConverter.cpp b/packages/react-native-executorch/common/rnexecutorch/models/ocr/CTCLabelConverter.cpp
deleted file mode 100644
index 6a1913ae7d..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/ocr/CTCLabelConverter.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-#include "CTCLabelConverter.h"
-#include <algorithm>
-#include <optional>
-#include <rnexecutorch/Error.h>
-
-namespace rnexecutorch::models::ocr {
-CTCLabelConverter::CTCLabelConverter(const std::string &characters)
-    : ignoreIdx(0),
-      character({"[blank]"}) // blank character is ignored character (index 0).
-{
-  if (characters.empty()) {
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidConfig,
-                            "Character set cannot be empty");
-  }
-  for (size_t i = 0; i < characters.length();) {
-    size_t char_len = 0;
-    unsigned char first_byte = characters[i];
-
-    if ((first_byte & 0x80) == 0) { // 0xxxxxxx -> 1-byte character
-      char_len = 1;
-    } else if ((first_byte & 0xE0) == 0xC0) { // 110xxxxx -> 2-byte character
-      char_len = 2;
-    } else if ((first_byte & 0xF0) == 0xE0) { // 1110xxxx -> 3-byte character
-      char_len = 3;
-    } else if ((first_byte & 0xF8) == 0xF0) { // 11110xxx -> 4-byte character
-      char_len = 4;
-    } else {
-      // Invalid UTF-8 start byte, treat as a single byte character to avoid
-      // infinite loop
-      char_len = 1;
-    }
-
-    // Ensure we don't read past the end of the string
-    if (i + char_len <= characters.length()) {
-      character.push_back(characters.substr(i, char_len));
-    }
-    i += char_len;
-  }
-}
-
-std::vector<std::string>
-CTCLabelConverter::decodeGreedy(const std::vector<int32_t> &textIndex,
-                                size_t length) {
-  /*
-   The current strategy used for decoding is greedy approach
-   which iterates through the list of indices and process
-   each index using following steps:
-    1. Ignore if idx == 0
-    2. Ignore if idx is the same as last idx
-    3. decode idx -> char and append it to returned text.
-
-   Note that ignoring repeated indices, does not mean decoding
-   won't handle repeated letters in a word, since in most cases
-   actual chars are already seperated by blank tokens.
-  */
-  std::vector<std::string> texts;
-  size_t index = 0;
-
-  while (index < textIndex.size()) {
-    size_t segmentLength = std::min(length, textIndex.size() - index);
-
-    std::vector<int32_t> subArray(textIndex.begin() + index,
-                                  textIndex.begin() + index + segmentLength);
-
-    std::string text;
-
-    if (!subArray.empty()) {
-      std::optional<int32_t> lastChar;
-      for (int32_t currentChar : subArray) {
-        bool isRepeated =
-            lastChar.has_value() && lastChar.value() == currentChar;
-        bool isIgnored = currentChar == ignoreIdx;
-        lastChar = currentChar;
-
-        if (currentChar >= 0 &&
-            currentChar < static_cast<int32_t>(character.size()) &&
-            !isRepeated && !isIgnored) {
-          text += character[currentChar];
-        }
-      }
-    }
-
-    texts.push_back(std::move(text));
-    index += segmentLength;
-
-    if (segmentLength < length) {
-      break;
-    }
-  }
-
-  return texts;
-}
-} // namespace rnexecutorch::models::ocr
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/ocr/CTCLabelConverter.h b/packages/react-native-executorch/common/rnexecutorch/models/ocr/CTCLabelConverter.h
deleted file mode 100644
index 2b34847e50..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/ocr/CTCLabelConverter.h
+++ /dev/null
@@ -1,29 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-
-namespace rnexecutorch::models::ocr {
-/*
- CTC (Connectionist Temporal Classification) Label Converter
- is used for decoding the returned list of indices by Recognizer into
- actual characters.
- For each Recognizer there is an 1:1 correspondence between
- an index and a character. CTC Label Converter operates on this
- mapping. Symbol corresponding to the first index is a [blank]
- character, meaning "no character to decode here".
- The decoder ignores [blank] char.
-*/
-
-class CTCLabelConverter final {
-public:
-  explicit CTCLabelConverter(const std::string &characters);
-
-  std::vector<std::string> decodeGreedy(const std::vector<int32_t> &textIndex,
-                                        size_t length);
-
-private:
-  int32_t ignoreIdx;
-  std::vector<std::string> character;
-};
-} // namespace rnexecutorch::models::ocr
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/ocr/Constants.h b/packages/react-native-executorch/common/rnexecutorch/models/ocr/Constants.h
deleted file mode 100644
index 9b96f17615..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/ocr/Constants.h
+++ /dev/null
@@ -1,51 +0,0 @@
-#pragma once
-
-#include <array>
-#include <cstdint>
-#include <opencv2/opencv.hpp>
-#include <vector>
-
-namespace rnexecutorch::models::ocr::constants {
-
-inline constexpr float kTextThreshold = 0.4;
-inline constexpr float kTextThresholdVertical = 0.3;
-inline constexpr float kLinkThreshold = 0.4;
-inline constexpr float kLowTextThreshold = 0.7;
-inline constexpr float kCenterThreshold = 0.5;
-inline constexpr float kDistanceThreshold = 2.0;
-inline constexpr float kHeightThreshold = 2.0;
-inline constexpr float kSingleCharacterCenterThreshold = 0.3;
-inline constexpr float kLowConfidenceThreshold = 0.3;
-inline constexpr float kAdjustContrast = 0.2;
-inline constexpr int32_t kMinSideThreshold = 15;
-inline constexpr int32_t kMaxSideThreshold = 30;
-inline constexpr int32_t kRecognizerHeight = 64;
-inline constexpr int32_t kLargeRecognizerWidth = 512;
-inline constexpr int32_t kMediumRecognizerWidth = 256;
-inline constexpr int32_t kSmallRecognizerWidth = 128;
-inline constexpr int32_t kSmallVerticalRecognizerWidth = 64;
-inline constexpr int32_t kMaxWidth =
-    kLargeRecognizerWidth + (kLargeRecognizerWidth * 0.15);
-inline constexpr int32_t kSingleCharacterMinSize = 70;
-inline constexpr int32_t kRecognizerImageSize = 1280;
-inline constexpr int32_t kVerticalLineThreshold = 20;
-inline constexpr int32_t kSmallDetectorWidth = 320;
-inline constexpr int32_t kMediumDetectorWidth = 800;
-inline constexpr int32_t kLargeDetectorWidth = 1280;
-inline constexpr std::array<int32_t, 3> kDetectorInputWidths = {
-    kSmallDetectorWidth, kMediumDetectorWidth, kLargeDetectorWidth};
-inline constexpr std::array<int32_t, 4> kRecognizerInputWidths = {
-    kSmallVerticalRecognizerWidth, kSmallRecognizerWidth,
-    kMediumRecognizerWidth, kLargeRecognizerWidth};
-
-/*
- Mean and variance values for image normalization were used in EASYOCR pipeline
- (see
- https://github.com/JaidedAI/EasyOCR/blob/c4f3cd7225efd4f85451bd8b4a7646ae9a092420/easyocr/imgproc.py#L20)
- but they originate from ImageNet dataset and they are widely use in
- ComputerVision preprocessing.
-*/
-inline const cv::Scalar kNormalizationMean(0.485, 0.456, 0.406);
-inline const cv::Scalar kNormalizationVariance(0.229, 0.224, 0.225);
-
-} // namespace rnexecutorch::models::ocr::constants
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/ocr/Detector.cpp b/packages/react-native-executorch/common/rnexecutorch/models/ocr/Detector.cpp
deleted file mode 100644
index b5111d3f16..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/ocr/Detector.cpp
+++ /dev/null
@@ -1,122 +0,0 @@
-#include "Detector.h"
-#include "Constants.h"
-#include <cstdint>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/data_processing/ImageProcessing.h>
-#include <rnexecutorch/models/ocr/Constants.h>
-#include <rnexecutorch/models/ocr/utils/DetectorUtils.h>
-#include <string>
-
-namespace rnexecutorch::models::ocr {
-Detector::Detector(const std::string &modelSource,
-                   std::shared_ptr<react::CallInvoker> callInvoker)
-    : BaseModel(modelSource, callInvoker) {
-
-  for (auto input_size : constants::kDetectorInputWidths) {
-    std::string methodName = "forward_" + std::to_string(input_size);
-    auto inputShapes = getAllInputShapes(methodName);
-    if (inputShapes[0].size() < 2) {
-      std::string errorMessage =
-          "Unexpected detector model input size for method: " + methodName +
-          "expected at least 2 dimensions but got: ." +
-          std::to_string(inputShapes[0].size());
-      throw RnExecutorchError(RnExecutorchErrorCode::UnexpectedNumInputs,
-                              errorMessage);
-    }
-  }
-}
-
-std::vector<types::DetectorBBox> Detector::generate(const cv::Mat &inputImage,
-                                                    int32_t inputWidth) {
-  /*
-   Detector as an input accepts tensor with a shape of [1, 3, H, H].
-   where H is a constant for model. In our supported model it is currently
-   either H=800 or H=1280.
-   Due to big influence of resize to quality of recognition the image preserves
-   original aspect ratio and the missing parts are filled with padding.
-   */
-
-  utils::validateInputWidth(inputWidth, constants::kDetectorInputWidths,
-                            "Detector");
-
-  std::string methodName = "forward_" + std::to_string(inputWidth);
-  auto inputShapes = getAllInputShapes(methodName);
-
-  cv::Size modelInputSize = calculateModelImageSize(inputWidth);
-
-  cv::Mat resizedInputImage =
-      image_processing::resizePadded(inputImage, modelInputSize);
-  TensorPtr inputTensor = image_processing::getTensorFromMatrix(
-      inputShapes[0], resizedInputImage, constants::kNormalizationMean,
-      constants::kNormalizationVariance);
-  auto forwardResult = BaseModel::execute(methodName, {inputTensor});
-
-  CHECK_OK_OR_THROW_FORWARD_ERROR(forwardResult);
-
-  return postprocess(forwardResult->at(0).toTensor(), modelInputSize);
-}
-
-cv::Size Detector::calculateModelImageSize(int32_t methodInputWidth) {
-
-  utils::validateInputWidth(methodInputWidth, constants::kDetectorInputWidths,
-                            "Detector");
-  std::string methodName = "forward_" + std::to_string(methodInputWidth);
-
-  auto inputShapes = getAllInputShapes(methodName);
-  std::vector<int32_t> modelInputShape = inputShapes[0];
-  cv::Size modelInputSize =
-      cv::Size(modelInputShape[modelInputShape.size() - 1],
-               modelInputShape[modelInputShape.size() - 2]);
-  return modelInputSize;
-}
-
-std::vector<types::DetectorBBox>
-Detector::postprocess(const Tensor &tensor, const cv::Size &modelInputSize) {
-  /*
-   The output of the model consists of two matrices (heat maps):
-   1. ScoreText(Score map) - The probability of a region containing character.
-   2. ScoreAffinity(Affinity map) - affinity between characters, used to to
-   group each character into a single instance (sequence) Both matrices are
-   H/2xW/2 (400x400 or 640x640).
-   */
-  std::span<const float> tensorData(tensor.const_data_ptr<float>(),
-                                    tensor.numel());
-  /*
-   The output of the model is a matrix half the size of the input image
-   containing two channels representing the heatmaps.
-   */
-  auto [scoreTextMat, scoreAffinityMat] = utils::interleavedArrayToMats(
-      tensorData,
-      cv::Size(modelInputSize.width / 2, modelInputSize.height / 2));
-
-  /*
-   Heatmaps are then converted into list of bounding boxes.
-  */
-  std::vector<types::DetectorBBox> bBoxesList = utils::getDetBoxesFromTextMap(
-      scoreTextMat, scoreAffinityMat, constants::kTextThreshold,
-      constants::kLinkThreshold, constants::kLowTextThreshold);
-
-  /*
-   Bounding boxes are at first corresponding to the 400x400 size or 640x640.
-   RecognitionHandler in the later part of processing works on images of size
-   1280x1280. To match this difference we has to scale  by the proper factor
-   (3.2 or 2.0).
-  */
-  const float restoreRatio = utils::calculateRestoreRatio(
-      scoreTextMat.rows, constants::kRecognizerImageSize);
-  utils::restoreBboxRatio(bBoxesList, restoreRatio);
-  /*
-   Since every bounding box is processed separately by Recognition models, we'd
-   like to reduce the number of boxes. Also, grouping nearby boxes means we
-   process many words / full line at once. It is not only faster but also easier
-   for Recognizer models than recognition of single characters.
-  */
-  bBoxesList = utils::groupTextBoxes(
-      bBoxesList, constants::kCenterThreshold, constants::kDistanceThreshold,
-      constants::kHeightThreshold, constants::kMinSideThreshold,
-      constants::kMaxSideThreshold, constants::kMaxWidth);
-
-  return bBoxesList;
-}
-
-} // namespace rnexecutorch::models::ocr
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/ocr/Detector.h b/packages/react-native-executorch/common/rnexecutorch/models/ocr/Detector.h
deleted file mode 100644
index dc17aa0742..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/ocr/Detector.h
+++ /dev/null
@@ -1,37 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <executorch/extension/tensor/tensor_ptr.h>
-#include <opencv2/opencv.hpp>
-#include <rnexecutorch/models/BaseModel.h>
-#include <rnexecutorch/models/ocr/Types.h>
-
-namespace rnexecutorch::models::ocr {
-/*
- Detector is a model responsible for recognizing the areas where text is
- located. It returns the list of bounding boxes. The model used as detector is
- based on CRAFT (Character Region Awareness for Text Detection) paper.
- https://arxiv.org/pdf/1904.01941
-*/
-
-using executorch::aten::Tensor;
-using executorch::extension::TensorPtr;
-
-class Detector : public BaseModel {
-public:
-  explicit Detector(const std::string &modelSource,
-                    std::shared_ptr<react::CallInvoker> callInvoker);
-  [[nodiscard("Registered non-void function")]] 
-  virtual std::vector<types::DetectorBBox> 
-  generate(const cv::Mat &inputImage, int32_t inputWidth);
-
-  cv::Size calculateModelImageSize(int32_t methodInputWidth);
-
-protected:
-  TensorPtr runInference(const cv::Mat &inputImage, int32_t inputWidth,
-                         const std::string &detectorName);
-
-  std::vector<types::DetectorBBox> postprocess(const Tensor &tensor,
-                                               const cv::Size &modelInputSize);
-};
-} // namespace rnexecutorch::models::ocr
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/ocr/OCR.cpp b/packages/react-native-executorch/common/rnexecutorch/models/ocr/OCR.cpp
deleted file mode 100644
index d3e6964a05..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/ocr/OCR.cpp
+++ /dev/null
@@ -1,99 +0,0 @@
-#include "OCR.h"
-#include "Constants.h"
-#include <algorithm>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-#include <rnexecutorch/data_processing/ImageProcessing.h>
-#include <rnexecutorch/models/ocr/Constants.h>
-#include <rnexecutorch/utils/FrameProcessor.h>
-#include <rnexecutorch/utils/FrameTransform.h>
-
-namespace rnexecutorch::models::ocr {
-OCR::OCR(const std::string &detectorSource, const std::string &recognizerSource,
-         const std::string &symbols,
-         std::shared_ptr<react::CallInvoker> callInvoker)
-    : detector(detectorSource, callInvoker),
-      recognitionHandler(recognizerSource, symbols, callInvoker) {}
-
-std::vector<types::OCRDetection> OCR::runInference(cv::Mat image) {
-  std::scoped_lock lock(inference_mutex_);
-
-  /*
-   1. Detection process returns the list of bounding boxes containing areas
-   with text. They are corresponding to the image of size 1280x1280, which
-   is a size later used by Recognition Handler.
-  */
-  std::vector<types::DetectorBBox> bboxesList =
-      detector.generate(image, constants::kMediumDetectorWidth);
-  cv::cvtColor(image, image, cv::COLOR_BGR2GRAY);
-
-  /*
-   Recognition Handler is responsible for deciding which Recognition model to
-   use for each box. It returns the list of tuples; each consisting of:
-    - recognized text
-    - coordinates of bounding box corresponding to the original image size
-    - confidence score
-  */
-  std::vector<types::OCRDetection> result =
-      recognitionHandler.recognize(bboxesList, image,
-                                   cv::Size(constants::kRecognizerImageSize,
-                                            constants::kRecognizerImageSize));
-
-  return result;
-}
-
-std::vector<types::OCRDetection> OCR::generateFromString(std::string input) {
-  cv::Mat image = image_processing::readImage(input);
-  if (image.empty()) {
-    throw RnExecutorchError(RnExecutorchErrorCode::FileReadFailed,
-                            "Failed to load image from path: " + input);
-  }
-  return runInference(image);
-}
-
-std::vector<types::OCRDetection>
-OCR::generateFromFrame(jsi::Runtime &runtime, const jsi::Value &frameData) {
-  auto orient = ::rnexecutorch::utils::readFrameOrientation(runtime, frameData);
-  cv::Mat frame = ::rnexecutorch::utils::frameToMat(runtime, frameData);
-  cv::Mat bgr;
-#ifdef __APPLE__
-  cv::cvtColor(frame, bgr, cv::COLOR_BGRA2BGR);
-#elif defined(__ANDROID__)
-  cv::cvtColor(frame, bgr, cv::COLOR_RGBA2BGR);
-#else
-  throw RnExecutorchError(
-      RnExecutorchErrorCode::PlatformNotSupported,
-      "generateFromFrame is not supported on this platform");
-#endif
-  cv::Mat rotated = ::rnexecutorch::utils::rotateFrameForModel(bgr, orient);
-  auto detections = runInference(rotated);
-  for (auto &det : detections) {
-    std::array<types::Point, 2> corners = {det.bbox.p1, det.bbox.p2};
-    ::rnexecutorch::utils::inverseRotatePoints(corners, orient, rotated.size());
-    det.bbox = {{std::min(corners[0].x, corners[1].x),
-                 std::min(corners[0].y, corners[1].y)},
-                {std::max(corners[0].x, corners[1].x),
-                 std::max(corners[0].y, corners[1].y)}};
-  }
-  return detections;
-}
-
-std::vector<types::OCRDetection>
-OCR::generateFromPixels(JSTensorViewIn pixelData) {
-  cv::Mat image;
-  cv::cvtColor(::rnexecutorch::utils::pixelsToMat(pixelData), image,
-               cv::COLOR_RGB2BGR);
-  return runInference(image);
-}
-
-std::size_t OCR::getMemoryLowerBound() const noexcept {
-  return detector.getMemoryLowerBound() +
-         recognitionHandler.getMemoryLowerBound();
-}
-
-void OCR::unload() noexcept {
-  std::scoped_lock lock(inference_mutex_);
-  detector.unload();
-  recognitionHandler.unload();
-}
-} // namespace rnexecutorch::models::ocr
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/ocr/OCR.h b/packages/react-native-executorch/common/rnexecutorch/models/ocr/OCR.h
deleted file mode 100644
index 719cb957c4..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/ocr/OCR.h
+++ /dev/null
@@ -1,52 +0,0 @@
-#pragma once
-
-#include <mutex>
-#include <string>
-#include <vector>
-
-#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
-#include <rnexecutorch/host_objects/JSTensorViewIn.h>
-#include <rnexecutorch/models/ocr/Detector.h>
-#include <rnexecutorch/models/ocr/RecognitionHandler.h>
-#include <rnexecutorch/models/ocr/Types.h>
-
-namespace rnexecutorch {
-namespace models::ocr {
-/*
- The OCR consists of two phases:
- 1. Detection - detecting text regions in the image, the result of this phase
- is a list of bounding boxes.
- 2. Recognition - recognizing the text in the bounding boxes, the result is a
- list of strings and corresponding boxes & confidence scores.
-
- Recognition uses one model with three methods, each method is resposible for
- recognizing text of different sizes (e.g. large - 512x64, medium - 256x64,
- small - 128x64).
-*/
-
-class OCR final {
-public:
-  explicit OCR(const std::string &detectorSource,
-               const std::string &recognizerSource, const std::string &symbols,
-               std::shared_ptr<react::CallInvoker> callInvoker);
-  [[nodiscard("Registered non-void function")]] std::vector<types::OCRDetection>
-  generateFromString(std::string input);
-  [[nodiscard("Registered non-void function")]] std::vector<types::OCRDetection>
-  generateFromFrame(jsi::Runtime &runtime, const jsi::Value &frameData);
-  [[nodiscard("Registered non-void function")]] std::vector<types::OCRDetection>
-  generateFromPixels(JSTensorViewIn pixelData);
-  std::size_t getMemoryLowerBound() const noexcept;
-  void unload() noexcept;
-
-private:
-  std::vector<types::OCRDetection> runInference(cv::Mat image);
-
-  Detector detector;
-  RecognitionHandler recognitionHandler;
-  mutable std::mutex inference_mutex_;
-};
-} // namespace models::ocr
-
-REGISTER_CONSTRUCTOR(models::ocr::OCR, std::string, std::string, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/ocr/RecognitionHandler.cpp b/packages/react-native-executorch/common/rnexecutorch/models/ocr/RecognitionHandler.cpp
deleted file mode 100644
index e70e46ab9c..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/ocr/RecognitionHandler.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-#include "RecognitionHandler.h"
-#include <rnexecutorch/data_processing/ImageProcessing.h>
-#include <rnexecutorch/models/ocr/Constants.h>
-#include <rnexecutorch/models/ocr/utils/RecognitionHandlerUtils.h>
-
-namespace rnexecutorch::models::ocr {
-RecognitionHandler::RecognitionHandler(
-    const std::string &recognizerSource, const std::string &symbols,
-    std::shared_ptr<react::CallInvoker> callInvoker)
-    : converter(symbols), recognizer(recognizerSource, callInvoker) {
-  memorySizeLowerBound = recognizer.getMemoryLowerBound();
-}
-
-std::pair<std::vector<int32_t>, float>
-RecognitionHandler::runModel(cv::Mat image) {
-
-  // Note that the height of an  image is always equal to 64.
-  int32_t desiredWidth = utils::getDesiredWidth(image, false);
-  return recognizer.generate(image, desiredWidth);
-}
-
-void RecognitionHandler::processBBox(std::vector<types::OCRDetection> &boxList,
-                                     types::DetectorBBox &box, cv::Mat &imgGray,
-                                     types::PaddingInfo ratioAndPadding) {
-
-  /*
-    Resize the cropped image to have height = 64 (height accepted by
-    Recognizer).
-  */
-  auto croppedImage =
-      utils::cropImage(box, imgGray, constants::kRecognizerHeight);
-
-  if (croppedImage.empty()) {
-    return;
-  }
-
-  /*
-    Cropped image is resized into the closest of on of three:
-    128x64, 256x64, 512x64.
-  */
-  croppedImage =
-      utils::normalizeForRecognizer(croppedImage, constants::kRecognizerHeight,
-                                    constants::kAdjustContrast, false);
-
-  auto [predictionIndices, confidenceScore] = this->runModel(croppedImage);
-  if (confidenceScore < constants::kLowConfidenceThreshold) {
-    cv::rotate(croppedImage, croppedImage, cv::ROTATE_180);
-    auto [rotatedPredictionIndices, rotatedConfidenceScore] =
-        runModel(croppedImage);
-    if (rotatedConfidenceScore > confidenceScore) {
-      confidenceScore = rotatedConfidenceScore;
-      predictionIndices = rotatedPredictionIndices;
-    }
-  }
-  /*
-    Since the boxes were corresponding to the image resized to 1280x1280,
-    we want to return the boxes shifted and rescaled to match the original
-    image dimensions. Compute the axis-aligned bounding box (AABB) from the
-    four rotated corners and store only the top-left and bottom-right points.
-  */
-  const float ratio = ratioAndPadding.resizeRatio;
-  const float padLeft = static_cast<float>(ratioAndPadding.left);
-  const float padTop = static_cast<float>(ratioAndPadding.top);
-  types::BBox transformedBbox{
-      {(box.bbox.p1.x - padLeft) * ratio, (box.bbox.p1.y - padTop) * ratio},
-      {(box.bbox.p2.x - padLeft) * ratio, (box.bbox.p2.y - padTop) * ratio}};
-  boxList.emplace_back(
-      transformedBbox,
-      converter.decodeGreedy(predictionIndices, predictionIndices.size())[0],
-      confidenceScore);
-}
-
-std::vector<types::OCRDetection>
-RecognitionHandler::recognize(std::vector<types::DetectorBBox> bboxesList,
-                              cv::Mat &imgGray, cv::Size desiredSize) {
-  /*
-   Recognition Handler accepts bboxesList corresponding to size
-   1280x1280, which is desiredSize.
-  */
-  types::PaddingInfo ratioAndPadding =
-      utils::calculateResizeRatioAndPaddings(imgGray.size(), desiredSize);
-  imgGray = image_processing::resizePadded(imgGray, desiredSize);
-
-  std::vector<types::OCRDetection> result = {};
-  for (auto &box : bboxesList) {
-    processBBox(result, box, imgGray, ratioAndPadding);
-  }
-  return result;
-}
-
-std::size_t RecognitionHandler::getMemoryLowerBound() const noexcept {
-  return memorySizeLowerBound;
-}
-
-void RecognitionHandler::unload() noexcept { recognizer.unload(); }
-} // namespace rnexecutorch::models::ocr
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/ocr/RecognitionHandler.h b/packages/react-native-executorch/common/rnexecutorch/models/ocr/RecognitionHandler.h
deleted file mode 100644
index abdfe5ba97..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/ocr/RecognitionHandler.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#pragma once
-
-#include <opencv2/opencv.hpp>
-#include <rnexecutorch/models/ocr/CTCLabelConverter.h>
-#include <rnexecutorch/models/ocr/Recognizer.h>
-#include <rnexecutorch/models/ocr/Types.h>
-#include <string>
-#include <vector>
-
-namespace rnexecutorch::models::ocr {
-/*
- Recogntion Handler is responsible for:
- 1. Preparing the image to be processed by Recognition Model.
- 2. Deciding which Recogntion Model is used for each detected bounding box.
- 3. Returning the list of tuples (box, text, confidence) to the OCR class.
-*/
-
-class RecognitionHandler final {
-public:
-  explicit RecognitionHandler(const std::string &recognizer,
-                              const std::string &symbols,
-                              std::shared_ptr<react::CallInvoker> callInvoker);
-  std::vector<types::OCRDetection>
-  recognize(std::vector<types::DetectorBBox> bboxesList, cv::Mat &imgGray,
-            cv::Size desiredSize);
-  void unload() noexcept;
-  std::size_t getMemoryLowerBound() const noexcept;
-
-private:
-  std::pair<std::vector<int32_t>, float> runModel(cv::Mat image);
-  void processBBox(std::vector<types::OCRDetection> &boxList,
-                   types::DetectorBBox &box, cv::Mat &imgGray,
-                   types::PaddingInfo ratioAndPadding);
-  std::size_t memorySizeLowerBound{0};
-  CTCLabelConverter converter;
-  Recognizer recognizer;
-};
-} // namespace rnexecutorch::models::ocr
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/ocr/Recognizer.cpp b/packages/react-native-executorch/common/rnexecutorch/models/ocr/Recognizer.cpp
deleted file mode 100644
index b87bcb1a9e..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/ocr/Recognizer.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-#include "Recognizer.h"
-#include "Constants.h"
-#include <numeric>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/data_processing/ImageProcessing.h>
-#include <rnexecutorch/data_processing/Numerical.h>
-#include <rnexecutorch/models/ocr/Constants.h>
-#include <rnexecutorch/models/ocr/Types.h>
-#include <rnexecutorch/models/ocr/utils/DetectorUtils.h>
-#include <rnexecutorch/models/ocr/utils/RecognizerUtils.h>
-#include <string>
-
-namespace rnexecutorch::models::ocr {
-Recognizer::Recognizer(const std::string &modelSource,
-                       std::shared_ptr<react::CallInvoker> callInvoker)
-    : BaseModel(modelSource, callInvoker) {}
-
-std::pair<std::vector<int32_t>, float>
-Recognizer::generate(const cv::Mat &grayImage, int32_t inputWidth) {
-  /*
-   In our pipeline we use three types of Recognizer, each designated to
-   handle different image sizes:
-   - Small Recognizer - 128 x 64
-   - Medium Recognizer - 256 x 64
-   - Large Recognizer - 512 x 64
-   The `generate` function as an argument accepts an image in grayscale
-   already resized to the expected size.
-  */
-  utils::validateInputWidth(inputWidth, constants::kRecognizerInputWidths,
-                            "Recognizer");
-
-  std::string method_name = "forward_" + std::to_string(inputWidth);
-  auto shapes = getAllInputShapes(method_name);
-  if (shapes.empty()) {
-    throw RnExecutorchError(RnExecutorchErrorCode::UnexpectedNumInputs,
-                            "OCR method takes no inputs: " + method_name);
-  }
-  std::vector<int32_t> tensorDims = shapes[0];
-  TensorPtr inputTensor =
-      image_processing::getTensorFromMatrixGray(tensorDims, grayImage);
-  auto forwardResult = BaseModel::execute(method_name, {inputTensor});
-  CHECK_OK_OR_THROW_FORWARD_ERROR(forwardResult);
-
-  return postprocess(forwardResult->at(0).toTensor());
-}
-
-std::pair<std::vector<int32_t>, float>
-Recognizer::postprocess(const Tensor &tensor) const {
-  /*
-   Raw model returns a tensor with dimensions [ 1 x seqLen x alphabetSize ]
-  where:
-
-    - seqLen is the length of predicted sequence. It is constant for the model.
-   For our models it is:
-     - 31 for Small Recognizer
-     - 63 for Medium Recognizer
-     - 127 for Large Recognizer
-    Remember that usually many tokens of predicted sequences are blank, meaning
-   the predicted text is not of const size.
-
-    - alphabetSize is the length of considered alphabet. It is constant for the
-   model. Usually depends on language, e.g. for our models for english it is 97,
-   for polish it is 357 etc.
-
-  Each value of returned tensor corresponds to character logits.
-  */
-  const int32_t alphabetSize = tensor.size(2);
-  const int32_t numRows = tensor.numel() / alphabetSize;
-
-  cv::Mat resultMat(numRows, alphabetSize, CV_32F,
-                    tensor.mutable_data_ptr<float>());
-
-  auto probabilities = utils::softmax(resultMat);
-  auto [maxVal, maxIndices] = utils::findMaxValuesIndices(probabilities);
-  float confidence = utils::confidenceScore(maxVal, maxIndices);
-  return {maxIndices, confidence};
-}
-} // namespace rnexecutorch::models::ocr
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/ocr/Recognizer.h b/packages/react-native-executorch/common/rnexecutorch/models/ocr/Recognizer.h
deleted file mode 100644
index 9a8129eb63..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/ocr/Recognizer.h
+++ /dev/null
@@ -1,36 +0,0 @@
-#pragma once
-
-#include <executorch/extension/tensor/tensor_ptr.h>
-#include <opencv2/opencv.hpp>
-#include <rnexecutorch/models/BaseModel.h>
-#include <string>
-#include <utility>
-#include <vector>
-
-namespace rnexecutorch::models::ocr {
-/*
- Recognizer is a model responsible for interpreting detected text regions
- into characters/words.
-
- The model used as Recognizer is based on CRNN paper.
- https://arxiv.org/pdf/1507.05717
-
- It returns the list of predicted indices and a confidence value.
-*/
-
-using executorch::aten::Tensor;
-using executorch::extension::TensorPtr;
-
-class Recognizer final : public BaseModel {
-public:
-  explicit Recognizer(const std::string &modelSource,
-                      std::shared_ptr<react::CallInvoker> callInvoker);
-  [[nodiscard("Registered non-void function")]] 
-  std::pair<std::vector<int32_t>, float> generate(const cv::Mat &grayImage,
-                                                  int32_t inputWidth);
-
-private:
-  std::pair<std::vector<int32_t>, float>
-  postprocess(const Tensor &tensor) const;
-};
-} // namespace rnexecutorch::models::ocr
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/ocr/Types.h b/packages/react-native-executorch/common/rnexecutorch/models/ocr/Types.h
deleted file mode 100644
index 8e711d382c..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/ocr/Types.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#pragma once
-
-#include <rnexecutorch/utils/computer_vision/Types.h>
-#include <string>
-#include <vector>
-
-namespace rnexecutorch::models::ocr::types {
-using namespace rnexecutorch::utils::computer_vision;
-
-struct ValuesAndIndices {
-  std::vector<float> values;
-  std::vector<int32_t> indices;
-};
-
-struct DetectorBBox {
-  BBox bbox;
-  float angle;
-};
-
-struct PaddingInfo {
-  float resizeRatio;
-  int32_t top;
-  int32_t left;
-};
-
-struct OCRDetection {
-  BBox bbox;
-  std::string text;
-  float score;
-};
-
-} // namespace rnexecutorch::models::ocr::types
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/ocr/utils/DetectorUtils.cpp b/packages/react-native-executorch/common/rnexecutorch/models/ocr/utils/DetectorUtils.cpp
deleted file mode 100644
index d1d4d1b5a0..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/ocr/utils/DetectorUtils.cpp
+++ /dev/null
@@ -1,661 +0,0 @@
-#include "DetectorUtils.h"
-#include <algorithm>
-#include <limits>
-#include <numeric>
-#include <rnexecutorch/data_processing/Numerical.h>
-#include <rnexecutorch/models/ocr/Constants.h>
-#include <rnexecutorch/models/ocr/Types.h>
-#include <unordered_set>
-
-namespace rnexecutorch::models::ocr::utils {
-static std::array<types::Point, 4> bboxToCorners(const types::BBox &bbox) {
-  return {bbox.p1, {bbox.p2.x, bbox.p1.y}, bbox.p2, {bbox.p1.x, bbox.p2.y}};
-}
-
-std::pair<cv::Mat, cv::Mat> interleavedArrayToMats(std::span<const float> data,
-                                                   cv::Size size) {
-  cv::Mat mat1 = cv::Mat(size, CV_32F);
-  cv::Mat mat2 = cv::Mat(size, CV_32F);
-
-  for (std::size_t i = 0; i < data.size(); i++) {
-    const float value = data[i];
-    const int32_t x = (i / 2) % size.width;
-    const int32_t y = (i / 2) / size.width;
-
-    if (i % 2 == 0) {
-      mat1.at<float>(y, x) = value;
-    } else {
-      mat2.at<float>(y, x) = value;
-    }
-  }
-  return {mat1, mat2};
-}
-
-// Create a segmentation map for the current component.
-// Background is 0, (black), foreground is 255 (white)
-cv::Mat createSegmentMap(const cv::Mat &mask, cv::Size mapSize,
-                         const int32_t segmentColor = 255) {
-  cv::Mat segMap = cv::Mat::zeros(mapSize, CV_8U);
-  segMap.setTo(segmentColor, mask);
-  return segMap;
-}
-
-void morphologicalOperations(
-    const cv::Mat &segMap, const cv::Mat &stats, int32_t i, int32_t area,
-    int32_t imgW, int32_t imgH,
-    int32_t iterations = 1, // iterations number of times dilation is  applied.
-    cv::Size anchor =
-        cv::Point(-1, -1) // anchor position of the anchor within the element;
-                          // default means that the anchor is at the center.
-) {
-  const int32_t x = stats.at<int32_t>(i, cv::CC_STAT_LEFT);
-  const int32_t y = stats.at<int32_t>(i, cv::CC_STAT_TOP);
-  const int32_t w = stats.at<int32_t>(i, cv::CC_STAT_WIDTH);
-  const int32_t h = stats.at<int32_t>(i, cv::CC_STAT_HEIGHT);
-
-  // Dynamically calculate dilation radius to expand the bounding box slightly
-  constexpr int32_t evenMultiplyCoeff = 2; // ensure that dilationRadius is even
-  const int32_t dilationRadius = static_cast<int32_t>(
-      std::sqrt(static_cast<double>(area) / std::max(w, h)) *
-      evenMultiplyCoeff);
-  const int32_t sx = std::max(x - dilationRadius, 0);
-  const int32_t ex = std::min(x + w + dilationRadius, imgW);
-  const int32_t sy = std::max(y - dilationRadius, 0);
-  const int32_t ey = std::min(y + h + dilationRadius, imgH);
-
-  // Define a region of interest (ROI) and dilate it
-  cv::Rect roi(sx, sy, ex - sx, ey - sy);
-  // Morphological kernels require minimum size of 1x1 (no-op) plus dilation
-  // radius
-  const int32_t morphologicalKernelSize =
-      1 + dilationRadius; // Ensures valid odd-sized kernel,
-                          // notice the fact that dilationRadius is always even.
-  cv::Mat kernel = cv::getStructuringElement(
-      cv::MORPH_RECT,
-      cv::Size(morphologicalKernelSize, morphologicalKernelSize));
-  cv::Mat roiSegMap = segMap(roi);
-  cv::dilate(roiSegMap, roiSegMap, kernel, anchor, iterations);
-}
-
-types::DetectorBBox
-extractMinAreaBBoxFromContour(const std::vector<cv::Point> contour) {
-  cv::RotatedRect minRect = cv::minAreaRect(contour);
-
-  std::array<cv::Point2f, 4> vertices;
-  minRect.points(vertices.data());
-
-  float minX =
-      std::min({vertices[0].x, vertices[1].x, vertices[2].x, vertices[3].x});
-  float minY =
-      std::min({vertices[0].y, vertices[1].y, vertices[2].y, vertices[3].y});
-  float maxX =
-      std::max({vertices[0].x, vertices[1].x, vertices[2].x, vertices[3].x});
-  float maxY =
-      std::max({vertices[0].y, vertices[1].y, vertices[2].y, vertices[3].y});
-  types::BBox bbox = {{minX, minY}, {maxX, maxY}};
-  return {.bbox = bbox, .angle = minRect.angle};
-}
-
-void getBoxFromContour(cv::Mat &segMap,
-                       std::vector<types::DetectorBBox> &detectedBoxes) {
-  std::vector<std::vector<cv::Point>> contours;
-  cv::findContours(segMap, contours, cv::RETR_EXTERNAL,
-                   cv::CHAIN_APPROX_SIMPLE);
-  if (!contours.empty()) {
-    detectedBoxes.emplace_back(extractMinAreaBBoxFromContour(contours[0]));
-  }
-}
-
-// Function for processing single component. It is shared between the
-// VerticalOCR and standard OCR. param isVertical specifies which OCR uses it.
-// param lowTextThreshold is used only by standard OCR.
-void processComponent(const cv::Mat &textMap, const cv::Mat &labels,
-                      const cv::Mat &stats, int32_t i, int32_t imgW,
-                      int32_t imgH,
-                      std::vector<types::DetectorBBox> &detectedBoxes,
-                      bool isVertical, int32_t minimalAreaThreshold,
-                      int32_t dilationIter, float lowTextThreshold = 0.0) {
-  const int32_t area = stats.at<int32_t>(i, cv::CC_STAT_AREA);
-  // Skip small components as they are likely to be just noise
-  if (area < minimalAreaThreshold) {
-    return;
-  }
-
-  cv::Mat mask = (labels == i);
-
-  if (!isVertical) {
-    // Skip components with low values, as they are likely to be just noise
-    double maxVal;
-    cv::minMaxLoc(textMap, nullptr, &maxVal, nullptr, nullptr, mask);
-    if (maxVal < lowTextThreshold) {
-      return;
-    }
-  }
-
-  cv::Mat segMap = createSegmentMap(mask, textMap.size());
-
-  // Perform morphological operations on  the segment map.
-  // mostly includes the dilation of the region of interest
-  // to esnure the box captures the whole area
-  morphologicalOperations(segMap, stats, i, area, imgW, imgH, dilationIter);
-
-  // Find the minimum area rotated rectangle around the contour
-  // and add it to the box list.
-  getBoxFromContour(segMap, detectedBoxes);
-}
-
-std::vector<types::DetectorBBox>
-getDetBoxesFromTextMap(cv::Mat &textMap, cv::Mat &affinityMap,
-                       float textThreshold, float linkThreshold,
-                       float lowTextThreshold) {
-  // Ensure input mats are of the correct type for processing
-  CV_Assert(textMap.type() == CV_32F && affinityMap.type() == CV_32F);
-
-  const int32_t imgH = textMap.rows;
-  const int32_t imgW = textMap.cols;
-  cv::Mat textScore;
-  cv::Mat affinityScore;
-
-  // 1. Based on maps and threshold values create binary masks
-  constexpr double maxValBinaryMask = 1.0;
-  cv::threshold(textMap, textScore, textThreshold, maxValBinaryMask,
-                cv::THRESH_BINARY);
-  cv::threshold(affinityMap, affinityScore, linkThreshold, maxValBinaryMask,
-                cv::THRESH_BINARY);
-
-  // 2. Merge two maps into one using logical OR
-  cv::Mat textScoreComb = textScore + affinityScore;
-  constexpr double threshVal = 0.0;
-  cv::threshold(textScoreComb, textScoreComb, threshVal, maxValBinaryMask,
-                cv::THRESH_BINARY);
-  cv::Mat binaryMat;
-  textScoreComb.convertTo(binaryMat, CV_8UC1);
-
-  // 3. Find connected components to identify each box
-  cv::Mat labels, stats, centroids;
-  constexpr int32_t connectivityType = 4;
-  const int32_t nLabels = cv::connectedComponentsWithStats(
-      binaryMat, labels, stats, centroids, connectivityType);
-
-  std::vector<types::DetectorBBox> detectedBoxes;
-  detectedBoxes.reserve(nLabels); // Pre-allocate memory
-
-  // number of dilation iterations performed in some
-  // morphological operations on a component later on.
-  constexpr int32_t dilationIter = 1;
-  // minimal accepted area of component
-  constexpr int32_t minimalAreaThreshold = 10;
-
-  // 4. Process each component; omit component 0 as it is background
-  for (int32_t i = 1; i < nLabels; i++) {
-    processComponent(textMap, labels, stats, i, imgW, imgH, detectedBoxes,
-                     false, minimalAreaThreshold, dilationIter,
-                     lowTextThreshold);
-  }
-
-  return detectedBoxes;
-}
-
-std::vector<types::DetectorBBox>
-getDetBoxesFromTextMapVertical(cv::Mat &textMap, cv::Mat &affinityMap,
-                               float textThreshold, float linkThreshold,
-                               bool independentCharacters) {
-  // Ensure input mats are of the correct type for processing
-  CV_Assert(textMap.type() == CV_32F && affinityMap.type() == CV_32F);
-
-  const int32_t imgH = textMap.rows;
-  const int32_t imgW = textMap.cols;
-  cv::Mat textScore;
-  cv::Mat affinityScore;
-
-  // 1. Threshold text and affinity maps to create binary masks
-  constexpr double maxValBinaryMask = 1.0;
-  cv::threshold(textMap, textScore, textThreshold, maxValBinaryMask,
-                cv::THRESH_BINARY);
-  cv::threshold(affinityMap, affinityScore, linkThreshold, maxValBinaryMask,
-                cv::THRESH_BINARY);
-
-  // Prepare values for morphological operations
-  const auto kSize = cv::Size(3, 3); // size of the structuring element
-  cv::Mat kernel = cv::getStructuringElement(cv::MORPH_RECT, kSize);
-
-  // iterations number of times erosion is applied.
-  constexpr int32_t erosionIterations = 1;
-
-  // iterations number of times dilation is applied.
-  int32_t dilationIterations;
-  const auto anchor =
-      cv::Point(-1, -1); // anchor position of the anchor within the element;
-                         // default value (-1, -1)
-                         // means that the anchor is at the element center
-
-  // 2. Combine maps based on whether we are detecting words or single
-  // characters
-  // For single characters, subtract affinity to separate adjacent chars,
-  // otherwise add affinity to link characters together
-  cv::Mat textScoreComb = independentCharacters ? textScore - affinityScore
-                                                : textScore + affinityScore;
-  // Clamp values to be >= 0
-  cv::threshold(textScoreComb, textScoreComb, 0.0, 1.0, cv::THRESH_TOZERO);
-  // Clamp values to be <= 1
-  cv::threshold(textScoreComb, textScoreComb, 1.0, 1.0, cv::THRESH_TRUNC);
-
-  // Perform morphological operations to refine character regions
-  if (independentCharacters) {
-    dilationIterations = 4;
-    cv::erode(textScoreComb, textScoreComb, kernel, anchor, erosionIterations);
-  } else {
-    dilationIterations = 2;
-  }
-  cv::dilate(textScoreComb, textScoreComb, kernel, anchor, dilationIterations);
-
-  // 3. Find connected components to identify each character/word
-  cv::Mat binaryMat;
-  textScoreComb.convertTo(binaryMat, CV_8UC1);
-
-  cv::Mat labels, stats, centroids;
-  constexpr int32_t connectivityType = 4;
-  const int32_t nLabels = cv::connectedComponentsWithStats(
-      binaryMat, labels, stats, centroids, connectivityType);
-
-  std::vector<types::DetectorBBox> detectedBoxes;
-  detectedBoxes.reserve(nLabels);
-
-  // number of dilation iterations performed in some
-  // morphological operations on a component later on.
-  constexpr int32_t dilationIter = 2;
-  // minimal accepted area of component
-  constexpr int32_t minimalAreaThreshold = 20;
-
-  // 4. Process each component; omit component 0 as it is background
-  for (int32_t i = 1; i < nLabels; ++i) {
-    const int32_t width = stats.at<int32_t>(i, cv::CC_STAT_WIDTH);
-    const int32_t height = stats.at<int32_t>(i, cv::CC_STAT_HEIGHT);
-    // For vertical text (not single chars), height should be greater than width
-    if (!independentCharacters && height < width) {
-      continue;
-    }
-    processComponent(textMap, labels, stats, i, imgW, imgH, detectedBoxes, true,
-                     minimalAreaThreshold, dilationIter);
-  }
-
-  return detectedBoxes;
-}
-
-float calculateRestoreRatio(int32_t currentSize, int32_t desiredSize) {
-  return desiredSize / static_cast<float>(currentSize);
-}
-
-void restoreBboxRatio(std::vector<types::DetectorBBox> &boxes,
-                      float restoreRatio) {
-  for (auto &box : boxes) {
-    box.bbox = box.bbox.scale(restoreRatio, restoreRatio);
-  }
-}
-
-float distanceFromPoint(const types::Point &p1, const types::Point &p2) {
-  const float xDist = p2.x - p1.x;
-  const float yDist = p2.y - p1.y;
-  return std::hypot(xDist, yDist);
-}
-
-float normalizeAngle(float angle) {
-  return (angle > 45.0f) ? (angle - 90.0f) : angle;
-}
-
-types::Point midpointBetweenPoint(const types::Point &p1,
-                                  const types::Point &p2) {
-  return {.x = std::midpoint(p1.x, p2.x), .y = std::midpoint(p1.y, p2.y)};
-}
-
-types::Point centerOfBox(const types::BBox &box) {
-  return midpointBetweenPoint(box.p1, box.p2);
-}
-
-float minSideLength(const types::BBox &bbox) {
-  return std::min(bbox.width(), bbox.height());
-}
-
-float maxSideLength(const types::BBox &bbox) {
-  return std::max(bbox.width(), bbox.height());
-}
-
-/**
- * This method calculates the distances between each sequential pair of points
- * in a presumed quadrilateral, identifies the two shortest sides, and fits a
- * linear model to the midpoints of these sides. It also evaluates whether the
- * resulting line should be considered vertical based on a predefined threshold
- * for the x-coordinate differences.
- *
- * If the line is vertical it is fitted as a function of x = my + c, otherwise
- * as y = mx + c.
- *
- * @return A tuple with 2 floats and a bool, where:
- *   - the first float represents the slope (m) of the line.
- *   - the second float represents the line's intercept (c) with y-axis.
- *   - a bool indicating whether the line is
- * considered vertical.
- */
-std::tuple<float, float, bool> fitLineToShortestSides(const types::BBox &bbox) {
-  const std::array<types::Point, 4> points = bboxToCorners(bbox);
-  std::array<std::pair<float, float>, 4> sides;
-  std::array<types::Point, 4> midpoints;
-#pragma unroll
-  for (std::size_t i = 0; i < midpoints.size(); i++) {
-    const auto p1 = points[i];
-    const auto p2 = points[(i + 1) % midpoints.size()];
-
-    const float sideLength = distanceFromPoint(p1, p2);
-    sides[i] = std::make_pair(sideLength, i);
-    midpoints[i] = midpointBetweenPoint(p1, p2);
-  }
-
-  // Sort the sides by length ascending
-  std::ranges::sort(sides);
-
-  const types::Point midpoint1 = midpoints[sides[0].second];
-  const types::Point midpoint2 = midpoints[sides[1].second];
-  const float dx = std::fabs(midpoint2.x - midpoint1.x);
-
-  float m, c;
-  bool isVertical;
-
-  std::array<cv::Point2f, 2> cvMidPoints = {
-      cv::Point2f(midpoint1.x, midpoint1.y),
-      cv::Point2f(midpoint2.x, midpoint2.y)};
-  cv::Vec4f line;
-  // parameteres for fitLine calculation:
-  constexpr int32_t numericalParameter =
-      0; // important only for some types of distances, O means an optimal value
-         // is chosen
-  constexpr double accuracy =
-      0.01; // sufficient accuracy. Value proposed by OPENCV
-
-  isVertical = dx < constants::kVerticalLineThreshold;
-  if (isVertical) {
-    for (auto &pt : cvMidPoints) {
-      std::swap(pt.x, pt.y);
-    }
-  }
-  cv::fitLine(cvMidPoints, line, cv::DIST_L2, numericalParameter, accuracy,
-              accuracy);
-  m = line[1] / line[0];
-  c = line[3] - m * line[2];
-  return {m, c, isVertical};
-}
-
-types::BBox rotateBox(const types::BBox &bbox, float angle) {
-  const types::Point center = centerOfBox(bbox);
-  const float radians = angle * M_PI / 180.0f;
-
-  float minX = std::numeric_limits<float>::max();
-  float minY = std::numeric_limits<float>::max();
-  float maxX = std::numeric_limits<float>::lowest();
-  float maxY = std::numeric_limits<float>::lowest();
-
-  for (const auto &p : bboxToCorners(bbox)) {
-    const float tx = p.x - center.x;
-    const float ty = p.y - center.y;
-    const float rx = tx * std::cos(radians) - ty * std::sin(radians) + center.x;
-    const float ry = tx * std::sin(radians) + ty * std::cos(radians) + center.y;
-    minX = std::min(minX, rx);
-    minY = std::min(minY, ry);
-    maxX = std::max(maxX, rx);
-    maxY = std::max(maxY, ry);
-  }
-
-  return {{minX, minY}, {maxX, maxY}};
-}
-
-float calculateMinimalDistanceBetweenBox(const types::BBox &box1,
-                                         const types::BBox &box2) {
-  float minDistance = std::numeric_limits<float>::max();
-  for (const auto &c1 : bboxToCorners(box1)) {
-    for (const auto &c2 : bboxToCorners(box2)) {
-      minDistance = std::min(minDistance, distanceFromPoint(c1, c2));
-    }
-  }
-  return minDistance;
-}
-
-/**
- * Orders a set of 4 points in a clockwise direction starting with the top-left
- * point.
- *
- * Process:
- * 1. It iterates through each Point.
- * 2. For each point, it calculates the sum (x + y) and difference (y - x) of
- * the coordinates.
- * 3. Points are classified into:
- *    - Top-left: Minimum sum.
- *    - Bottom-right: Maximum sum.
- *    - Top-right: Minimum difference.
- *    - Bottom-left: Maximum difference.
- * 4. The points are ordered starting from the top-left in a clockwise manner:
- * top-left, top-right, bottom-right, bottom-left.
- */
-types::BBox orderPointsClockwise(const types::BBox &bbox) {
-  return {{std::min(bbox.p1.x, bbox.p2.x), std::min(bbox.p1.y, bbox.p2.y)},
-          {std::max(bbox.p1.x, bbox.p2.x), std::max(bbox.p1.y, bbox.p2.y)}};
-}
-
-types::BBox mergeRotatedBoxes(const types::BBox &box1,
-                              const types::BBox &box2) {
-  return {{std::min(box1.p1.x, box2.p1.x), std::min(box1.p1.y, box2.p1.y)},
-          {std::max(box1.p2.x, box2.p2.x), std::max(box1.p2.y, box2.p2.y)}};
-}
-
-/**
- * This method assesses each box from a provided vector, checks its center
- * against the center of a "current box", and evaluates its alignment with a
- * specified line equation. The function specifically searches for the box whose
- * center is closest to the current box that has not been ignored, and fits
- * within a defined distance from the line.
- *
- * @param boxes A vector of DetectorBBoxes
- * @param ignoredIdxs A set of indices of boxes to ignore in the evaluation.
- * @param currentBox Array of points encapsulating representing the current box
- * to compare against.
- * @param isVertical A boolean indicating if the line to compare distance to is
- * vertical.
- * @param m The slope (gradient) of the line against which the box's alignment
- * is checked.
- * @param c The y-intercept of the line equation y = mx + c.
- * @param centerThreshold A multiplier to determine the threshold for the
- * distance between the box's center and the line.
- *
- * @return A an optional pair containing:
- *         - the index of the found box in the original vector.
- *         - the length of the shortest side of the found box.
- * If no suitable box is found the optional is null.
- */
-std::optional<std::pair<std::size_t, float>>
-findClosestBox(const std::vector<types::DetectorBBox> &boxes,
-               const std::unordered_set<std::size_t> &ignoredIdxs,
-               const types::BBox &currentBox, bool isVertical, float m, float c,
-               float centerThreshold) {
-  float smallestDistance = std::numeric_limits<float>::max();
-  ssize_t idx = -1;
-  float boxHeight = 0.0f;
-  const types::Point centerOfCurrentBox = centerOfBox(currentBox);
-
-  for (std::size_t i = 0; i < boxes.size(); i++) {
-    if (ignoredIdxs.contains(i)) {
-      continue;
-    }
-    const types::BBox &bbox = boxes[i].bbox;
-    const types::Point centerOfProcessedBox = centerOfBox(bbox);
-    const float distanceBetweenCenters =
-        distanceFromPoint(centerOfCurrentBox, centerOfProcessedBox);
-
-    if (distanceBetweenCenters >= smallestDistance) {
-      continue;
-    }
-
-    boxHeight = minSideLength(bbox);
-
-    const float lineDistance =
-        isVertical ? std::fabs(centerOfProcessedBox.x -
-                               (m * centerOfProcessedBox.y + c))
-                   : std::fabs(centerOfProcessedBox.y -
-                               (m * centerOfProcessedBox.x + c));
-
-    if (lineDistance < boxHeight * centerThreshold) {
-      idx = i;
-      smallestDistance = distanceBetweenCenters;
-    }
-  }
-
-  return idx != -1 ? std::optional(std::make_pair(idx, boxHeight))
-                   : std::nullopt;
-}
-
-/**
- * Filters out boxes that are smaller than the specified thresholds.
- * A box is kept only if:
- *   - Its shorter side is **greater than** `minSideThreshold`, **and**
- *   - Its longer side is **greater than** `maxSideThreshold`.
- * Otherwise, the box is excluded from the result.
- */
-std::vector<types::DetectorBBox>
-removeSmallBoxesFromArray(const std::vector<types::DetectorBBox> &boxes,
-                          float minSideThreshold, float maxSideThreshold) {
-  std::vector<types::DetectorBBox> filteredBoxes;
-
-  for (const auto &box : boxes) {
-    const float maxSide = maxSideLength(box.bbox);
-    const float minSide = minSideLength(box.bbox);
-    if (minSide > minSideThreshold && maxSide > maxSideThreshold) {
-      filteredBoxes.push_back(box);
-    }
-  }
-
-  return filteredBoxes;
-}
-
-static float minimumYFromBox(const types::BBox &bbox) { return bbox.p1.y; }
-static float minimumXFromBox(const types::BBox &bbox) { return bbox.p1.x; }
-
-std::vector<types::DetectorBBox>
-groupTextBoxes(std::vector<types::DetectorBBox> &boxes, float centerThreshold,
-               float distanceThreshold, float heightThreshold,
-               int32_t minSideThreshold, int32_t maxSideThreshold,
-               int32_t maxWidth) {
-  // Sort boxes descending by maximum side length
-  std::ranges::sort(boxes, [](const types::DetectorBBox &lhs,
-                              const types::DetectorBBox &rhs) {
-    return maxSideLength(lhs.bbox) > maxSideLength(rhs.bbox);
-  });
-
-  std::vector<types::DetectorBBox> mergedVec;
-  float lineAngle;
-  std::unordered_set<std::size_t> ignoredIdxs;
-  while (!boxes.empty()) {
-    auto currentBox = boxes[0];
-    float normalizedAngle = normalizeAngle(currentBox.angle);
-    boxes.erase(boxes.begin());
-    ignoredIdxs.clear();
-
-    while (true) {
-      // Find all aligned boxes and merge them until max_size is reached or no
-      // more boxes can be merged
-      auto [slope, intercept, isVertical] =
-          fitLineToShortestSides(currentBox.bbox);
-
-      lineAngle = std::atan(slope) * 180.0f / M_PI;
-      if (isVertical) {
-        lineAngle = -90.0f;
-      }
-      auto closestBoxInfo =
-          findClosestBox(boxes, ignoredIdxs, currentBox.bbox, isVertical, slope,
-                         intercept, centerThreshold);
-      if (!closestBoxInfo.has_value()) {
-        break;
-      }
-      const auto [candidateIdx, candidateHeight] = closestBoxInfo.value();
-      types::DetectorBBox candidateBox = boxes[candidateIdx];
-
-      if ((numerical::isClose(candidateBox.angle, 90.0f) && !isVertical) ||
-          (numerical::isClose(candidateBox.angle, 0.0f) && isVertical)) {
-        candidateBox.bbox = rotateBox(candidateBox.bbox, normalizedAngle);
-      }
-
-      const float minDistance = calculateMinimalDistanceBetweenBox(
-          candidateBox.bbox, currentBox.bbox);
-      const float mergedHeight = minSideLength(currentBox.bbox);
-      if (minDistance < distanceThreshold * candidateHeight &&
-          std::fabs(mergedHeight - candidateHeight) <
-              candidateHeight * heightThreshold) {
-        currentBox.bbox = mergeRotatedBoxes(currentBox.bbox, candidateBox.bbox);
-        boxes.erase(boxes.begin() + candidateIdx);
-        ignoredIdxs.clear();
-        if (maxSideLength(currentBox.bbox) > maxWidth) {
-          break;
-        }
-      } else {
-        ignoredIdxs.insert(candidateIdx);
-      }
-    }
-    mergedVec.emplace_back(currentBox.bbox, lineAngle);
-  }
-
-  // Remove small boxes and sort by vertical
-  mergedVec =
-      removeSmallBoxesFromArray(mergedVec, minSideThreshold, maxSideThreshold);
-
-  std::ranges::sort(mergedVec, [](const auto &obj1, const auto &obj2) {
-    return minimumYFromBox(obj1.bbox) < minimumYFromBox(obj2.bbox);
-  });
-
-  // Group boxes whose top-Y differs by less than half the mean text height into
-  // a row, then sort within each row left-to-right by top-X. Without this,
-  // ties on minY fall back to the earlier descending-size sort, which reads as
-  // "by probability" rather than reading order.
-  float yThresh = 0.0f;
-  if (!mergedVec.empty()) {
-    float totalHeight = 0.0f;
-    for (const auto &box : mergedVec) {
-      totalHeight += minSideLength(box.bbox);
-    }
-    yThresh = (totalHeight / static_cast<float>(mergedVec.size())) * 0.5f;
-  }
-  for (auto rowBegin = mergedVec.begin(); rowBegin != mergedVec.end();) {
-    const float rowY = minimumYFromBox(rowBegin->bbox);
-    auto rowEnd =
-        std::find_if(rowBegin, mergedVec.end(), [rowY, yThresh](const auto &b) {
-          return minimumYFromBox(b.bbox) - rowY > yThresh;
-        });
-    std::sort(rowBegin, rowEnd, [](const auto &a, const auto &b) {
-      return minimumXFromBox(a.bbox) < minimumXFromBox(b.bbox);
-    });
-    rowBegin = rowEnd;
-  }
-
-  std::vector<types::DetectorBBox> orderedSortedBoxes;
-  orderedSortedBoxes.reserve(mergedVec.size());
-  for (types::DetectorBBox bbox : mergedVec) {
-    bbox.bbox = orderPointsClockwise(bbox.bbox);
-    orderedSortedBoxes.push_back(std::move(bbox));
-  }
-
-  return orderedSortedBoxes;
-}
-
-void validateInputWidth(int32_t inputWidth, std::span<const int32_t> constants,
-                        std::string modelName) {
-  auto it = std::ranges::find(constants, inputWidth);
-
-  if (it == constants.end()) {
-    std::string allowed;
-    for (size_t i = 0; i < constants.size(); ++i) {
-      allowed +=
-          std::to_string(constants[i]) + (i < constants.size() - 1 ? ", " : "");
-    }
-
-    throw std::runtime_error("Unexpected input width for " + modelName +
-                             "! Expected [" + allowed + "] but got " +
-                             std::to_string(inputWidth) + ".");
-  }
-}
-
-} // namespace rnexecutorch::models::ocr::utils
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/ocr/utils/DetectorUtils.h b/packages/react-native-executorch/common/rnexecutorch/models/ocr/utils/DetectorUtils.h
deleted file mode 100644
index 0b742a4ce1..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/ocr/utils/DetectorUtils.h
+++ /dev/null
@@ -1,96 +0,0 @@
-#pragma once
-
-#include <opencv2/opencv.hpp>
-#include <rnexecutorch/models/ocr/Types.h>
-#include <span>
-
-namespace rnexecutorch::models::ocr::utils {
-std::pair<cv::Mat, cv::Mat> interleavedArrayToMats(std::span<const float> data,
-                                                   cv::Size size);
-/**
- * This method applies a series of image processing operations to identify
- * likely areas of text in the textMap and return the bounding boxes for single
- * words.
- *
- * @param textMap A cv::Mat representing a heat map of the characters of text
- * being present in an image.
- * @param affinityMap A cv::Mat representing a heat map of the affinity between
- * characters.
- * @param textThreshold A float representing the threshold for the text map.
- * @param linkThreshold A float representing the threshold for the affinity
- * map.
- * @param lowTextThreshold A float representing the low text.
- *
- * @return A vector containing DetectorBBox bounding boxes. Each DetectorBBox
- * includes:
- *  - "bbox": an array of Point values representing the vertices of the
- * detected text box.
- *  - "angle": a float representing the rotation angle of the box.
- */
-std::vector<types::DetectorBBox> getDetBoxesFromTextMap(cv::Mat &textMap,
-                                                        cv::Mat &affinityMap,
-                                                        float textThreshold,
-                                                        float linkThreshold,
-                                                        float lowTextThreshold);
-std::vector<types::DetectorBBox>
-getDetBoxesFromTextMapVertical(cv::Mat &textMap, cv::Mat &affinityMap,
-                               float textThreshold, float linkThreshold,
-                               bool independentCharacters);
-
-float calculateRestoreRatio(int32_t currentSize, int32_t desiredSize);
-
-void restoreBboxRatio(std::vector<types::DetectorBBox> &boxes,
-                      float restoreRatio);
-/**
- * This method processes a vector of DetectorBBox bounding boxes, each
- * containing details about individual text boxes, and attempts to group and
- * merge these boxes based on specified criteria including proximity, alignment,
- * and size thresholds. It prioritizes merging of boxes that are aligned closely
- * in angle, are near each other, and whose sizes are compatible based on the
- * given thresholds.
- *
- * @param boxes A vector of DetectorBBoxes where each bounding box
- * represents a text box.
- * @param centerThreshold A float representing the threshold for considering
- * the distance between center and fitted line.
- * @param distanceThreshold A float that defines the maximum allowed distance
- * between boxes for them to be considered for merging.
- * @param heightThreshold A float representing the maximum allowed difference
- * in height between boxes for merging.
- * @param minSideThreshold An int that defines the minimum dimension threshold
- * to filter out small boxes after grouping.
- * @param maxSideThreshold An int that specifies the maximum dimension threshold
- * for filtering boxes post-grouping.
- * @param maxWidth An int that represents the maximum width allowable for a
- * merged box.
- *
- * @return A vector of DetectorBBoxes representing the merged boxes.
- *
- * Processing Steps:
- * 1. Sort initial boxes based on their maximum side length.
- * 2. Sequentially merge boxes considering alignment, proximity, and size
- * compatibility.
- * 3. Post-processing to remove any boxes that are too small.
- * 4. Sort the final array of boxes by their vertical positions.
- */
-std::vector<types::DetectorBBox>
-groupTextBoxes(std::vector<types::DetectorBBox> &boxes, float centerThreshold,
-               float distanceThreshold, float heightThreshold,
-               int32_t minSideThreshold, int32_t maxSideThreshold,
-               int32_t maxWidth);
-
-/**
- * Validates if the provided image width is supported by the model.
- * * This method checks the input width against the passed allowed
- * widths in constants vector. If the width is not found, it
- * constructs a descriptive error message listing all valid options.
- *
- * @param inputWidth The width of the input image to be validated.
- * @param constants Vector of available input sizes.
- * @param modelName String with modelNames used for generating error message
- * @throws std::runtime_error If inputWidth is not present in the allowed
- * detector input widths array.
- */
-void validateInputWidth(int32_t inputWidth, std::span<const int32_t> constants,
-                        std::string modelName);
-} // namespace rnexecutorch::models::ocr::utils
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/ocr/utils/RecognitionHandlerUtils.cpp b/packages/react-native-executorch/common/rnexecutorch/models/ocr/utils/RecognitionHandlerUtils.cpp
deleted file mode 100644
index 0e50f1c038..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/ocr/utils/RecognitionHandlerUtils.cpp
+++ /dev/null
@@ -1,159 +0,0 @@
-#include "RecognitionHandlerUtils.h"
-#include <algorithm>
-#include <rnexecutorch/data_processing/ImageProcessing.h>
-#include <rnexecutorch/models/ocr/Constants.h>
-
-namespace rnexecutorch::models::ocr::utils {
-types::PaddingInfo calculateResizeRatioAndPaddings(cv::Size size,
-                                                   cv::Size desiredSize) {
-  const auto newRatioH = static_cast<float>(desiredSize.height) / size.height;
-  const auto newRatioW = static_cast<float>(desiredSize.width) / size.width;
-  auto resizeRatio = std::min(newRatioH, newRatioW);
-
-  const auto newHeight = static_cast<int32_t>(size.height * resizeRatio);
-  const auto newWidth = static_cast<int32_t>(size.width * resizeRatio);
-
-  const int32_t deltaH = desiredSize.height - newHeight;
-  const int32_t deltaW = desiredSize.width - newWidth;
-
-  const int32_t top = deltaH / 2;
-  const int32_t left = deltaW / 2;
-
-  const auto heightRatio = static_cast<float>(size.height) / desiredSize.height;
-  const auto widthRatio = static_cast<float>(size.width) / desiredSize.width;
-
-  resizeRatio = std::max(heightRatio, widthRatio);
-  return {resizeRatio, top, left};
-}
-
-void computeRatioAndResize(cv::Mat &img, cv::Size size, int32_t modelHeight) {
-  auto ratio =
-      static_cast<double>(size.width) / static_cast<double>(size.height);
-  cv::Size resizedSize;
-  if (ratio < 1.0) {
-    resizedSize =
-        cv::Size(modelHeight, static_cast<int32_t>(modelHeight / ratio));
-  } else {
-    resizedSize =
-        cv::Size(static_cast<int32_t>(modelHeight * ratio), modelHeight);
-  }
-  cv::resize(img, img, resizedSize, 0.0, 0.0, cv::INTER_LANCZOS4);
-}
-
-cv::Mat cropImage(types::DetectorBBox box, cv::Mat &image,
-                  int32_t modelHeight) {
-  const std::array<cv::Point2f, 4> points = {{
-      {box.bbox.p1.x, box.bbox.p1.y},
-      {box.bbox.p2.x, box.bbox.p1.y},
-      {box.bbox.p2.x, box.bbox.p2.y},
-      {box.bbox.p1.x, box.bbox.p2.y},
-  }};
-
-  cv::RotatedRect rotatedRect = cv::minAreaRect(points);
-  cv::Point2f rectPoints[4];
-  rotatedRect.points(rectPoints);
-
-  // Rotate the image
-  cv::Point2f imageCenter(image.cols / 2.0f, image.rows / 2.0f);
-  cv::Mat rotationMatrix = cv::getRotationMatrix2D(imageCenter, box.angle, 1.0);
-  cv::Mat rotatedImage;
-  cv::warpAffine(image, rotatedImage, rotationMatrix, image.size(),
-                 cv::INTER_LINEAR);
-
-  constexpr int32_t rows = 4;
-  constexpr int32_t cols = 2;
-  cv::Mat rectMat(rows, cols, CV_32FC2);
-#pragma unroll
-  for (int32_t i = 0; i < rows; ++i) {
-    rectMat.at<cv::Vec2f>(i, 0) = cv::Vec2f(rectPoints[i].x, rectPoints[i].y);
-  }
-  cv::transform(rectMat, rectMat, rotationMatrix);
-
-  constexpr size_t transformedPointsSize = 4;
-  std::vector<cv::Point2f> transformedPoints(transformedPointsSize);
-#pragma unroll
-  for (std::size_t i = 0; i < transformedPointsSize; ++i) {
-    cv::Vec2f point = rectMat.at<cv::Vec2f>(i, 0);
-    transformedPoints[i] = cv::Point2f(point[0], point[1]);
-  }
-
-  cv::Rect boundingBox = cv::boundingRect(transformedPoints);
-
-  cv::Rect validRegion(0, 0, rotatedImage.cols, rotatedImage.rows);
-
-  boundingBox = boundingBox & validRegion; // OpenCV's built-in intersection
-
-  if (boundingBox.empty()) {
-    return {};
-  }
-
-  cv::Mat croppedImage = rotatedImage(boundingBox).clone();
-
-  computeRatioAndResize(croppedImage,
-                        cv::Size(boundingBox.width, boundingBox.height),
-                        modelHeight);
-
-  return croppedImage;
-}
-
-void adjustContrastGrey(cv::Mat &img, double target) {
-  constexpr double minValue = 0.0;
-  constexpr double maxValue = 255.0;
-
-  // calculate the brightest and the darkest point from the img
-  double highDouble;
-  double lowDouble;
-  cv::minMaxLoc(img, &lowDouble, &highDouble);
-  const auto low = static_cast<int32_t>(lowDouble);
-  const auto high = static_cast<int32_t>(highDouble);
-
-  double contrast = (highDouble - lowDouble) / maxValue;
-  if (contrast < target) {
-    constexpr double maxStretchIntensity = 200.0;
-    constexpr int32_t minRangeClamp = 10;
-    // Defines how much the contrast will actually stretch.
-    // Formula obtained empirically.
-    double ratio = maxStretchIntensity / std::max(minRangeClamp, high - low);
-    cv::Mat tempImg;
-    img.convertTo(tempImg, CV_32F);
-    constexpr int32_t histogramShift = 25;
-
-    tempImg -= (low - histogramShift);
-    tempImg *= ratio;
-
-    cv::threshold(tempImg, tempImg, maxValue, maxValue, cv::THRESH_TRUNC);
-    cv::threshold(tempImg, tempImg, minValue, maxValue, cv::THRESH_TOZERO);
-
-    tempImg.convertTo(img, CV_8U);
-  }
-}
-
-int32_t getDesiredWidth(const cv::Mat &img, bool isVertical) {
-
-  if (img.cols >= constants::kLargeRecognizerWidth) {
-    return constants::kLargeRecognizerWidth;
-  }
-  if (img.cols >= constants::kMediumRecognizerWidth) {
-    return constants::kMediumRecognizerWidth;
-  }
-  return isVertical ? constants::kSmallVerticalRecognizerWidth
-                    : constants::kSmallRecognizerWidth;
-}
-
-cv::Mat normalizeForRecognizer(const cv::Mat &image, int32_t modelHeight,
-                               double adjustContrast, bool isVertical) {
-  auto img = image.clone();
-  if (adjustContrast > 0.0) {
-    adjustContrastGrey(img, adjustContrast);
-  }
-
-  int32_t desiredWidth = getDesiredWidth(image, isVertical);
-
-  img =
-      image_processing::resizePadded(img, cv::Size(desiredWidth, modelHeight));
-  img.convertTo(img, CV_32F, 1.0f / 255.0f);
-  img -= 0.5f;
-  img *= 2.0f;
-  return img;
-}
-} // namespace rnexecutorch::models::ocr::utils
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/ocr/utils/RecognitionHandlerUtils.h b/packages/react-native-executorch/common/rnexecutorch/models/ocr/utils/RecognitionHandlerUtils.h
deleted file mode 100644
index e2dea2f7f9..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/ocr/utils/RecognitionHandlerUtils.h
+++ /dev/null
@@ -1,90 +0,0 @@
-#pragma once
-
-#include <opencv2/opencv.hpp>
-#include <rnexecutorch/models/ocr/Types.h>
-
-namespace rnexecutorch::models::ocr::utils {
-/**
- * @brief Calculates the resize ratio and padding offsets needed to fit an image
- *  into a target size while maintaining aspect ratio.
- * @param size Original dimensions of the image.
- * @param desiredSize Target size.
- * @return Struct containing the scaling factor and top/left padding amounts for
- * centering the image.
- */
-types::PaddingInfo calculateResizeRatioAndPaddings(cv::Size size,
-                                                   cv::Size desiredSize);
-/**
- * @brief Resizes an image proportionally to match a target height while
- * maintaining aspect ratio.
- * @param img Input/output image to resize.
- * @param size Original dimensions of the image.
- * @param modelHeight Target height for the output image.
- */
-void computeRatioAndResize(cv::Mat &img, cv::Size size, int32_t modelHeight);
-/**
- * @brief Crops and aligns a rotated bounding box region from an image, then
- * resizes it to target height.
- *
- * Handles rotated boxes by:
- * 1. Calculating minimum area rectangle around detected points
- * 2. Rotating the entire image to align the box horizontally
- * 3. Transforming the box coordinates to match the rotated image
- * 4. Cropping the aligned region
- *
- * Resizing:
- * - Maintains original aspect ratio while scaling to specified modelHeight
- * - Uses high-quality interpolation for both rotation and resizing
- *
- * @param box Detected bounding box with rotation angle and corner points
- * @param image Source image to crop from
- * @param modelHeight Target height for output (width scales proportionally)
- * @return Cropped, aligned and resized image region (empty if invalid box)
- */
-cv::Mat cropImage(types::DetectorBBox box, cv::Mat &image, int32_t modelHeight);
-void adjustContrastGrey(cv::Mat &img, double target);
-
-/**
- * @brief Determines the optimal width for an image based on its aspect ratio
- * and orientation, to fit the requirements of the recognition model.
- *
- * This function calculates a `desiredWidth` that, when combined with a fixed
- * `modelHeight` (from `normalizeForRecognizer`), maintains the image's aspect
- * ratio and prepares it for input into the recognizer model. It considers
- * whether the text in the image is `isVertical`, which might influence the
- * chosen width for better recognition performance.
- *
- * @param img The input image matrix.
- * @param isVertical A boolean indicating if the text in the image is oriented
- * vertically.
- * @return The calculated desired width for the image.
- */
-int32_t getDesiredWidth(const cv::Mat &img, bool isVertical);
-
-/**
- * @brief Prepares an image for recognition models by standardizing size,
- * contrast, and pixel values.
- *
- * Performs the following processing pipeline:
- * 1. Adjusts contrast (if coefficient > 0)
- * 2. Resizes to target height while:
- *    - Preserving aspect ratio (using padding if needed)
- *    - Selecting width to match one of the Recognizer accepted
- *      widths; (Large,Medium or Small RecognizerWidth)
- * 3. Normalizes pixel values to [-1, 1] range (from [0,255] input)
- *
- * @param image Input image to process (any size, will be cloned)
- * @param modelHeight Target output height in pixels
- * @param adjustContrast Contrast adjustment coefficient (0.0 = no adjustment)
- * @param isVertical Whether the image is in portrait orientation (affects width
- * selection)
- *
- * @return Processed image with:
- *   - Standardized dimensions (selected width × modelHeight)
- *   - Adjusted contrast (if requested)
- *   - Normalized float32 values in [-1, 1] range
- */
-cv::Mat normalizeForRecognizer(const cv::Mat &image, int32_t modelHeight,
-                               double adjustContrast = 0.0,
-                               bool isVertical = false);
-} // namespace rnexecutorch::models::ocr::utils
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/ocr/utils/RecognizerUtils.cpp b/packages/react-native-executorch/common/rnexecutorch/models/ocr/utils/RecognizerUtils.cpp
deleted file mode 100644
index e959739ab1..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/ocr/utils/RecognizerUtils.cpp
+++ /dev/null
@@ -1,222 +0,0 @@
-#include "RecognizerUtils.h"
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-#include <rnexecutorch/utils/computer_vision/Types.h>
-
-namespace rnexecutorch::models::ocr::utils {
-using namespace rnexecutorch::utils::computer_vision;
-
-cv::Mat softmax(const cv::Mat &inputs) {
-  cv::Mat maxVal;
-  cv::reduce(inputs, maxVal, 1, cv::REDUCE_MAX, CV_32F);
-  cv::Mat expInputs;
-  cv::Mat repeated = inputs - cv::repeat(maxVal, 1, inputs.cols);
-  repeated.convertTo(repeated, CV_32F);
-#ifdef TEST_BUILD
-  // Manually compute exp to avoid SIMD issues in test environment
-  expInputs = cv::Mat(repeated.size(), CV_32F);
-  for (int i = 0; i < repeated.rows; i++) {
-    for (int j = 0; j < repeated.cols; j++) {
-      expInputs.at<float>(i, j) = std::exp(repeated.at<float>(i, j));
-    }
-  }
-#else
-  cv::exp(repeated, expInputs);
-#endif
-  cv::Mat sumExp;
-  cv::reduce(expInputs, sumExp, 1, cv::REDUCE_SUM, CV_32F);
-  cv::Mat softmaxOutput = expInputs / cv::repeat(sumExp, 1, inputs.cols);
-
-  return softmaxOutput;
-}
-
-std::vector<float> sumProbabilityRows(const cv::Mat &matrix) {
-  std::vector<float> sums;
-  sums.reserve(matrix.rows);
-  for (int32_t i = 0; i < matrix.rows; ++i) {
-    sums.push_back(cv::sum(matrix.row(i))[0]);
-  }
-  return sums;
-}
-
-void divideMatrixByRows(cv::Mat &matrix, const std::vector<float> &rowSums) {
-  for (int32_t i = 0; i < matrix.rows; ++i) {
-    matrix.row(i) /= rowSums[i];
-  }
-}
-
-types::ValuesAndIndices findMaxValuesIndices(const cv::Mat &mat) {
-  CV_Assert(mat.type() == CV_32F);
-  types::ValuesAndIndices result{};
-  result.values.reserve(mat.rows);
-  result.indices.reserve(mat.rows);
-
-  for (int32_t i = 0; i < mat.rows; ++i) {
-    double maxVal;
-    cv::Point maxLoc;
-    cv::minMaxLoc(mat.row(i), nullptr, &maxVal, nullptr, &maxLoc);
-    result.values.push_back(static_cast<float>(maxVal));
-    result.indices.push_back(maxLoc.x);
-  }
-
-  return result;
-}
-
-float confidenceScore(const std::vector<float> &values,
-                      const std::vector<int32_t> &indices) {
-  float product = 1.0f;
-  int32_t count = 0;
-
-  for (size_t i = 0; i < indices.size(); ++i) {
-    if (indices[i] != 0) {
-      product *= values[i];
-      count++;
-    }
-  }
-
-  if (count == 0) {
-    return 0.0f;
-  }
-
-  const float n = static_cast<float>(count);
-  const float exponent = 2.0f / std::sqrt(n);
-  return std::pow(product, exponent);
-}
-
-cv::Rect extractBoundingBox(const BBox &bbox) {
-  return cv::Rect(static_cast<int>(bbox.p1.x), static_cast<int>(bbox.p1.y),
-                  static_cast<int>(bbox.width()),
-                  static_cast<int>(bbox.height()));
-}
-
-cv::Mat characterBitMask(const cv::Mat &img) {
-  // 1. Determine if character is darker/lighter than background.
-  cv::Mat histogram;
-  int32_t histSize = 256;
-  float range[] = {0.0f, 256.0f};
-  const float *histRange = {range};
-  bool uniform = true;
-  bool accumulate = false;
-
-  cv::calcHist(&img, 1, 0, cv::Mat(), histogram, 1, &histSize, &histRange,
-               uniform, accumulate);
-
-  // Compare sum of darker (left half) vs brighter (right half) pixels.
-  const int32_t midPoint = histSize / 2;
-  double sumLeft = 0.0;
-  double sumRight = 0.0;
-  for (int32_t i = 0; i < midPoint; i++) {
-    sumLeft += histogram.at<float>(i);
-  }
-  for (int32_t i = midPoint; i < histSize; i++) {
-    sumRight += histogram.at<float>(i);
-  }
-  const int32_t thresholdType =
-      (sumLeft < sumRight) ? cv::THRESH_BINARY_INV : cv::THRESH_BINARY;
-
-  // 2. Binarize using Otsu's method (auto threshold).
-  cv::Mat thresh;
-  cv::threshold(img, thresh, 0, 255, thresholdType + cv::THRESH_OTSU);
-
-  // 3. Find the largest connected component near the center.
-  cv::Mat labels, stats, centroids;
-  const int32_t numLabels = cv::connectedComponentsWithStats(
-      thresh, labels, stats, centroids, 8, CV_32S);
-
-  const int32_t height = thresh.rows;
-  const int32_t width = thresh.cols;
-  const int32_t minX = constants::kSingleCharacterCenterThreshold * width;
-  const int32_t maxX = (1 - constants::kSingleCharacterCenterThreshold) * width;
-  const int32_t minY = constants::kSingleCharacterCenterThreshold * height;
-  const int32_t maxY =
-      (1 - constants::kSingleCharacterCenterThreshold) * height;
-
-  int32_t selectedComponent = -1;
-  int32_t maxArea = -1;
-  for (int32_t i = 1; i < numLabels; i++) { // Skip background (label 0)
-    const int32_t area = stats.at<int32_t>(i, cv::CC_STAT_AREA);
-    const double cx = centroids.at<double>(i, 0);
-    const double cy = centroids.at<double>(i, 1);
-
-    if ((minX < cx && cx < maxX && minY < cy &&
-         cy < maxY &&                                  // check if centered
-         area > constants::kSingleCharacterMinSize) && // check if large enough
-        area > maxArea) {
-      selectedComponent = i;
-      maxArea = area;
-    }
-  }
-  // 4. Extract the character and invert to white-on-black.
-  cv::Mat resultImage;
-  cv::Mat mask;
-  if (selectedComponent != -1) {
-    mask = (labels == selectedComponent);
-    img.copyTo(resultImage, mask);
-  } else {
-    resultImage = cv::Mat::zeros(img.size(), img.type());
-  }
-
-  cv::bitwise_not(resultImage, resultImage);
-
-  return resultImage;
-}
-
-cv::Mat cropImageWithBoundingBox(const cv::Mat &img, const BBox &bbox,
-                                 const BBox &originalBbox,
-                                 const types::PaddingInfo &paddings,
-                                 const types::PaddingInfo &originalPaddings) {
-  if (!originalBbox.isValid()) {
-    throw RnExecutorchError(RnExecutorchErrorCode::UnknownError,
-                            "Original bounding box cannot be empty.");
-  }
-  const types::Point topLeft = originalBbox.p1;
-
-  const std::array<Point, 4> bboxCorners = {
-      bbox.p1, {bbox.p2.x, bbox.p1.y}, bbox.p2, {bbox.p1.x, bbox.p2.y}};
-  std::vector<cv::Point2f> points;
-  points.reserve(4);
-
-  for (const auto &point : bboxCorners) {
-    types::Point transformedPoint = point;
-
-    transformedPoint.x -= paddings.left;
-    transformedPoint.y -= paddings.top;
-
-    transformedPoint.x *= paddings.resizeRatio;
-    transformedPoint.y *= paddings.resizeRatio;
-
-    transformedPoint.x += topLeft.x;
-    transformedPoint.y += topLeft.y;
-
-    transformedPoint.x -= originalPaddings.left;
-    transformedPoint.y -= originalPaddings.top;
-
-    transformedPoint.x *= originalPaddings.resizeRatio;
-    transformedPoint.y *= originalPaddings.resizeRatio;
-
-    points.emplace_back(transformedPoint.x, transformedPoint.y);
-  }
-
-  cv::Rect rect = cv::boundingRect(points);
-  rect &= cv::Rect(0, 0, img.cols, img.rows);
-  if (rect.empty()) {
-    return {};
-  }
-  auto croppedImage = img(rect).clone();
-  return croppedImage;
-}
-
-cv::Mat prepareForRecognition(const cv::Mat &originalImage, const BBox &bbox,
-                              const BBox &originalBbox,
-                              const types::PaddingInfo &paddings,
-                              const types::PaddingInfo &originalPaddings) {
-  auto croppedChar = cropImageWithBoundingBox(originalImage, bbox, originalBbox,
-                                              paddings, originalPaddings);
-  cv::cvtColor(croppedChar, croppedChar, cv::COLOR_BGR2GRAY);
-  cv::resize(croppedChar, croppedChar,
-             cv::Size(constants::kSmallVerticalRecognizerWidth,
-                      constants::kRecognizerHeight),
-             0, 0, cv::INTER_AREA);
-  return croppedChar;
-}
-} // namespace rnexecutorch::models::ocr::utils
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/ocr/utils/RecognizerUtils.h b/packages/react-native-executorch/common/rnexecutorch/models/ocr/utils/RecognizerUtils.h
deleted file mode 100644
index d693193386..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/ocr/utils/RecognizerUtils.h
+++ /dev/null
@@ -1,67 +0,0 @@
-#pragma once
-
-#include <opencv2/opencv.hpp>
-#include <rnexecutorch/models/ocr/Constants.h>
-#include <rnexecutorch/models/ocr/Types.h>
-#include <vector>
-
-namespace rnexecutorch::models::ocr::utils {
-/**
- * @brief Computes per row softmax funcion.
- * Formula: softmax(x_i) = exp(x_i - max(x)) / sum(exp(x_j - max(x))) for each
- * row.
- */
-cv::Mat softmax(const cv::Mat &inputs);
-
-/**
- * @brief For each row of matrix computes {maxValue, index} pair. Returns a list
- * of maxValues and a list of corresponding indices.
- */
-types::ValuesAndIndices findMaxValuesIndices(const cv::Mat &mat);
-std::vector<float> sumProbabilityRows(const cv::Mat &matrix);
-void divideMatrixByRows(cv::Mat &matrix, const std::vector<float> &rowSums);
-cv::Rect extractBoundingBox(const types::BBox &bbox);
-
-/**
- * @brief Computes confidence score for given values and indices vectors.
- * Omits blank tokens.
- * Formula: pow(\prod_{i=1}^{n}(p_i), 2/sqrt(n)), where n is a number of
- * non-blank tokens, and p_i is the probability of i-th non-blank token.
- * @details Formula derived from line 14 of
- * https://github.com/JaidedAI/EasyOCR/blob/c4f3cd7225efd4f85451bd8b4a7646ae9a092420/easyocr/recognition.py#L14
- * @details 'Some say that it's a code, sent to us from god'
- */
-float confidenceScore(const std::vector<float> &values,
-                      const std::vector<int32_t> &indices);
-
-cv::Mat characterBitMask(const cv::Mat &img);
-
-/**
- * @brief Perform cropping of an image to a single character detector box.
- * This function utilizes info about external bounding box and padding combined
- * with internal bounding box and padding.
- * It does so to preserve the best possible image quality.
- */
-cv::Mat cropImageWithBoundingBox(const cv::Mat &img, const types::BBox &bbox,
-                                 const types::BBox &originalBbox,
-                                 const types::PaddingInfo &paddings,
-                                 const types::PaddingInfo &originalPaddings);
-
-/**
- * @brief Perform cropping, resizing and convert to grayscale to prepare image
- * for Recognizer.
- *
- * Prepare for Recognition by following steps:
- * 1. Crop image to the character bounding box,
- * 2. Convert Image to gray.
- * 3. Resize it to [kSmallVerticalRecognizerWidth x kRecognizerHeight] (64 x
- * 64).
- *
- * @details it utilizes cropImageWithBoundingBox to perform specific cropping.
- */
-cv::Mat prepareForRecognition(const cv::Mat &originalImage,
-                              const types::BBox &bbox,
-                              const types::BBox &originalBbox,
-                              const types::PaddingInfo &paddings,
-                              const types::PaddingInfo &originalPaddings);
-} // namespace rnexecutorch::models::ocr::utils
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/pose_estimation/PoseEstimation.cpp b/packages/react-native-executorch/common/rnexecutorch/models/pose_estimation/PoseEstimation.cpp
deleted file mode 100644
index 03147cd468..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/pose_estimation/PoseEstimation.cpp
+++ /dev/null
@@ -1,180 +0,0 @@
-#include "PoseEstimation.h"
-#include "ReactCommon/CallInvoker.h"
-#include <cmath>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-#include <rnexecutorch/Log.h>
-#include <rnexecutorch/data_processing/ImageProcessing.h>
-#include <rnexecutorch/models/VisionModel.h>
-#include <rnexecutorch/utils/FrameProcessor.h>
-#include <rnexecutorch/utils/FrameTransform.h>
-
-namespace rnexecutorch::models::pose_estimation {
-
-PoseEstimation::PoseEstimation(const std::string &modelSource,
-                               std::vector<float> normMean,
-                               std::vector<float> normStd,
-                               std::shared_ptr<react::CallInvoker> callInvoker)
-    : VisionModel(modelSource, callInvoker) {
-  if (normMean.size() == 3) {
-    normMean_ = cv::Scalar(normMean[0], normMean[1], normMean[2]);
-  } else if (!normMean.empty()) {
-    log(LOG_LEVEL::Warn,
-        "normMean must have 3 elements — ignoring provided value.");
-  }
-  if (normStd.size() == 3) {
-    normStd_ = cv::Scalar(normStd[0], normStd[1], normStd[2]);
-  } else if (!normStd.empty()) {
-    log(LOG_LEVEL::Warn,
-        "normStd must have 3 elements — ignoring provided value.");
-  }
-}
-
-PoseDetections PoseEstimation::postprocess(const std::vector<EValue> &tensors,
-                                           cv::Size originalSize,
-                                           double detectionThreshold,
-                                           double keypointThreshold) {
-  // Output tensors (batch dim squeezed):
-  //   0: boxes     (Q, 4)    - xyxy bbox in model input pixel space
-  //   1: scores    (Q,)      - person confidence [0, 1]
-  //   2: keypoints (Q, K, 3) - per-detection keypoints (x, y, visibility)
-
-  if (tensors.size() < 3) {
-    // TODO: maybe create a ContractNotMet error or something like this, this
-    // would also need to be applied for other models
-    return {};
-  }
-
-  auto scoresTensor = tensors[1].toTensor();
-  auto keypointsTensor = tensors[2].toTensor();
-
-  const int32_t numKeypoints = static_cast<int32_t>(keypointsTensor.size(1));
-
-  const float *scores = scoresTensor.const_data_ptr<float>();
-  const float *kpData = keypointsTensor.const_data_ptr<float>();
-
-  auto numDetections = scoresTensor.size(0);
-
-  const auto &shape = modelInputShape_;
-  cv::Size modelInputSize(static_cast<int32_t>(shape[shape.size() - 1]),
-                          static_cast<int32_t>(shape[shape.size() - 2]));
-
-  float scaleX = static_cast<float>(originalSize.width) / modelInputSize.width;
-  float scaleY =
-      static_cast<float>(originalSize.height) / modelInputSize.height;
-
-  PoseDetections allDetections;
-
-  for (size_t i = 0; i < numDetections; ++i) {
-    if (scores[i] < detectionThreshold) {
-      continue;
-    }
-
-    PersonKeypoints keypoints;
-    keypoints.reserve(numKeypoints);
-
-    const float *detectionKps = kpData + i * numKeypoints * 3;
-
-    for (size_t k = 0; k < numKeypoints; ++k) {
-      float visibility = detectionKps[k * 3 + 2];
-      if (visibility < keypointThreshold) {
-        keypoints.emplace_back(-1, -1);
-        continue;
-      }
-      float x = detectionKps[k * 3];
-      float y = detectionKps[k * 3 + 1];
-
-      int32_t scaledX = static_cast<int32_t>(std::round(x * scaleX));
-      int32_t scaledY = static_cast<int32_t>(std::round(y * scaleY));
-
-      keypoints.emplace_back(scaledX, scaledY);
-    }
-
-    allDetections.push_back(std::move(keypoints));
-  }
-
-  return allDetections;
-}
-
-PoseDetections PoseEstimation::runInference(cv::Mat image,
-                                            double detectionThreshold,
-                                            double keypointThreshold,
-                                            const std::string &methodName) {
-
-  log(LOG_LEVEL::Debug, "Running inference with model name: " + methodName);
-
-  if (detectionThreshold < 0.0 || detectionThreshold > 1.0) {
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidUserInput,
-                            "detectionThreshold must be in range [0, 1]");
-  }
-  if (keypointThreshold < 0.0 || keypointThreshold > 1.0) {
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidUserInput,
-                            "keypointThreshold must be in range [0, 1]");
-  }
-
-  std::scoped_lock lock(inference_mutex_);
-  cv::Size originalSize = image.size();
-  auto inputShapes = getAllInputShapes(methodName);
-  if (inputShapes.empty() || inputShapes[0].size() < 2) {
-    throw RnExecutorchError(RnExecutorchErrorCode::UnexpectedNumInputs,
-                            "Could not determine input shape for method: " +
-                                methodName);
-  }
-  modelInputShape_ = inputShapes[0];
-  cv::Mat resizedToModelInput = preprocess(image);
-
-  auto inputTensor =
-      (normMean_ && normStd_)
-          ? image_processing::getTensorFromMatrix(
-                modelInputShape_, resizedToModelInput, *normMean_, *normStd_)
-          : image_processing::getTensorFromMatrix(modelInputShape_,
-                                                  resizedToModelInput);
-
-  auto executeResult = execute(methodName, {inputTensor});
-  if (!executeResult.ok()) {
-    throw RnExecutorchError(executeResult.error(),
-                            "The model's " + methodName +
-                                " method did not succeed. "
-                                "Ensure the model input is correct.");
-  }
-
-  return postprocess(executeResult.get(), originalSize, detectionThreshold,
-                     keypointThreshold);
-}
-
-PoseDetections PoseEstimation::generateFromString(std::string imageSource,
-                                                  double detectionThreshold,
-                                                  double keypointThreshold,
-                                                  std::string methodName) {
-  cv::Mat imageBGR = image_processing::readImage(imageSource);
-  cv::Mat imageRGB;
-  cv::cvtColor(imageBGR, imageRGB, cv::COLOR_BGR2RGB);
-  return runInference(std::move(imageRGB), detectionThreshold,
-                      keypointThreshold, methodName);
-}
-
-PoseDetections PoseEstimation::generateFromFrame(jsi::Runtime &runtime,
-                                                 const jsi::Value &frameData,
-                                                 double detectionThreshold,
-                                                 double keypointThreshold,
-                                                 std::string methodName) {
-  auto orient = ::rnexecutorch::utils::readFrameOrientation(runtime, frameData);
-  cv::Mat frame = extractFromFrame(runtime, frameData);
-  cv::Mat rotated = ::rnexecutorch::utils::rotateFrameForModel(frame, orient);
-  auto detections =
-      runInference(rotated, detectionThreshold, keypointThreshold, methodName);
-  for (auto &person : detections) {
-    ::rnexecutorch::utils::inverseRotatePoints(person, orient, rotated.size());
-  }
-  return detections;
-}
-
-PoseDetections PoseEstimation::generateFromPixels(JSTensorViewIn pixelData,
-                                                  double detectionThreshold,
-                                                  double keypointThreshold,
-                                                  std::string methodName) {
-  cv::Mat image = extractFromPixels(pixelData);
-  return runInference(image, detectionThreshold, keypointThreshold, methodName);
-}
-
-} // namespace rnexecutorch::models::pose_estimation
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/pose_estimation/PoseEstimation.h b/packages/react-native-executorch/common/rnexecutorch/models/pose_estimation/PoseEstimation.h
deleted file mode 100644
index 983519b34b..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/pose_estimation/PoseEstimation.h
+++ /dev/null
@@ -1,49 +0,0 @@
-#pragma once
-
-#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
-#include "rnexecutorch/models/VisionModel.h"
-#include "rnexecutorch/models/pose_estimation/Types.h"
-#include <executorch/runtime/core/evalue.h>
-#include <optional>
-
-namespace rnexecutorch {
-namespace models::pose_estimation {
-
-class PoseEstimation : public VisionModel {
-public:
-  PoseEstimation(const std::string &modelSource, std::vector<float> normMean,
-                 std::vector<float> normStd,
-                 std::shared_ptr<react::CallInvoker> callInvoker);
-
-  [[nodiscard("Registered non-void function")]] PoseDetections
-  generateFromString(std::string imageSource, double detectionThreshold,
-                     double keypointThreshold, std::string methodName);
-  [[nodiscard("Registered non-void function")]] PoseDetections
-  generateFromFrame(jsi::Runtime &runtime, const jsi::Value &frameData,
-                    double detectionThreshold, double keypointThreshold,
-                    std::string methodName);
-  [[nodiscard("Registered non-void function")]] PoseDetections
-  generateFromPixels(JSTensorViewIn pixelData, double detectionThreshold,
-                     double keypointThreshold, std::string methodName);
-
-private:
-  std::optional<cv::Scalar> normMean_;
-  std::optional<cv::Scalar> normStd_;
-
-  [[nodiscard("Registered non-void function")]]
-  PoseDetections runInference(cv::Mat image, double detectionThreshold,
-                              double keypointThreshold,
-                              const std::string &modelName);
-
-  [[nodiscard("Registered non-void function")]]
-  PoseDetections postprocess(const std::vector<EValue> &evl,
-                             cv::Size originalSize, double detectionThreshold,
-                             double keypointThreshold);
-};
-
-} // namespace models::pose_estimation
-
-REGISTER_CONSTRUCTOR(models::pose_estimation::PoseEstimation, std::string,
-                     std::vector<float>, std::vector<float>,
-                     std::shared_ptr<react::CallInvoker>);
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/pose_estimation/Types.h b/packages/react-native-executorch/common/rnexecutorch/models/pose_estimation/Types.h
deleted file mode 100644
index 6a7cdc2e88..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/pose_estimation/Types.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#pragma once
-
-#include <rnexecutorch/utils/computer_vision/Types.h>
-#include <vector>
-
-namespace rnexecutorch::models::pose_estimation {
-
-// N keypoints for one person, depending on the model in question
-using PersonKeypoints = std::vector<utils::computer_vision::Point>;
-
-// N people for each image
-using PoseDetections = std::vector<PersonKeypoints>;
-
-} // namespace rnexecutorch::models::pose_estimation
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/privacy_filter/PrivacyFilter.cpp b/packages/react-native-executorch/common/rnexecutorch/models/privacy_filter/PrivacyFilter.cpp
deleted file mode 100644
index d05312e47c..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/privacy_filter/PrivacyFilter.cpp
+++ /dev/null
@@ -1,212 +0,0 @@
-#include "PrivacyFilter.h"
-
-#include <algorithm>
-#include <cstdint>
-#include <ranges>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include <executorch/extension/tensor/tensor_ptr_maker.h>
-
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-
-namespace rnexecutorch::models::privacy_filter {
-
-using executorch::aten::ScalarType;
-using executorch::extension::make_tensor_ptr;
-using executorch::extension::TensorPtr;
-using executorch::runtime::EValue;
-
-namespace {
-
-// o200k tokenizer: <|endoftext|> (id 199999) doubles as pad and eos.
-constexpr int64_t kPadTokenId = 199999;
-
-} // namespace
-
-PrivacyFilter::PrivacyFilter(const std::string &modelSource,
-                             const std::string &tokenizerSource,
-                             std::vector<std::string> labelNames,
-                             std::vector<float> viterbiBiases,
-                             std::shared_ptr<react::CallInvoker> callInvoker)
-    : BaseModel(modelSource, callInvoker),
-      tokenizer_(
-          std::make_unique<TokenizerModule>(tokenizerSource, callInvoker)),
-      labelNames_(std::move(labelNames)), seqLen_(0) {
-  if (labelNames_.empty() || labelNames_[0] != "O") {
-    throw RnExecutorchError(
-        RnExecutorchErrorCode::UnknownError,
-        "PrivacyFilter requires a non-empty labelNames vector "
-        "(must include 'O' at index 0).");
-  }
-  if (!viterbiBiases.empty() && viterbiBiases.size() != 6) {
-    throw RnExecutorchError(RnExecutorchErrorCode::UnknownError,
-                            "PrivacyFilter viterbiBiases must be empty or "
-                            "contain exactly 6 floats.");
-  }
-  if (viterbiBiases.size() == 6) {
-    biases_.backgroundStay = viterbiBiases[0];
-    biases_.backgroundToStart = viterbiBiases[1];
-    biases_.endToBackground = viterbiBiases[2];
-    biases_.endToStart = viterbiBiases[3];
-    biases_.insideToContinue = viterbiBiases[4];
-    biases_.insideToEnd = viterbiBiases[5];
-  }
-  auto inputShapes = getAllInputShapes();
-  if (inputShapes.empty() || inputShapes[0].size() < 2 ||
-      inputShapes[0][1] < 2) {
-    throw RnExecutorchError(RnExecutorchErrorCode::WrongDimensions,
-                            "PrivacyFilter: expected forward input shape "
-                            "[1, seq_len] with seq_len >= 2.");
-  }
-  seqLen_ = inputShapes[0][1];
-  grammar_ = viterbi::buildGrammar(labelNames_, biases_);
-}
-
-std::string PrivacyFilter::labelEntityType(int32_t labelId) const {
-  if (labelId <= 0 || std::cmp_greater_equal(labelId, labelNames_.size())) {
-    return "";
-  }
-  const auto &name = labelNames_[static_cast<size_t>(labelId)];
-  const auto dashPos = name.find('-');
-  if (dashPos == std::string::npos) {
-    return "";
-  }
-  return name.substr(dashPos + 1);
-}
-
-void PrivacyFilter::unload() noexcept {
-  std::scoped_lock lock(inference_mutex_);
-  BaseModel::unload();
-}
-
-void PrivacyFilter::runWindow(std::vector<int64_t> &paddedInputIds,
-                              std::vector<int64_t> &paddedAttentionMask,
-                              int32_t absStart, int32_t validLen,
-                              int32_t writeFromOffset, int32_t writeToOffset,
-                              std::vector<int32_t> &outLabels) {
-  if (validLen <= 0) {
-    return;
-  }
-
-  std::vector<int32_t> idsShape = {1, seqLen_};
-  auto inputIdsTensor =
-      make_tensor_ptr(idsShape, paddedInputIds.data(), ScalarType::Long);
-  auto attentionMaskTensor =
-      make_tensor_ptr(idsShape, paddedAttentionMask.data(), ScalarType::Long);
-
-  auto forwardResult =
-      BaseModel::forward({*inputIdsTensor, *attentionMaskTensor});
-  CHECK_OK_OR_THROW_FORWARD_ERROR(forwardResult);
-  auto &out = forwardResult.get();
-  if (out.empty()) {
-    throw RnExecutorchError(RnExecutorchErrorCode::UnknownError,
-                            "PrivacyFilter: forward returned no outputs");
-  }
-
-  const auto &logitsTensor = out[0].toTensor();
-  const float *logits = logitsTensor.const_data_ptr<float>();
-
-  auto path = viterbi::decode(logits, validLen, grammar_);
-
-  const int32_t end = std::min(writeToOffset, validLen);
-  std::copy(path.begin() + writeFromOffset, path.begin() + end,
-            outLabels.begin() + absStart + writeFromOffset);
-}
-
-std::vector<types::PiiEntity> PrivacyFilter::generate(std::string text) {
-  std::scoped_lock lock(inference_mutex_);
-
-  if (!module_) {
-    throw RnExecutorchError(RnExecutorchErrorCode::ModuleNotLoaded,
-                            "PrivacyFilter is not loaded");
-  }
-
-  auto rawIds = tokenizer_->encode(text);
-  const int32_t totalTokens = static_cast<int32_t>(rawIds.size());
-
-  std::vector<int32_t> predictedLabels(static_cast<size_t>(totalTokens), 0);
-
-  const int32_t stride = seqLen_ / 2;
-  const int32_t edgeMargin = seqLen_ / 4;
-  for (int32_t windowStart = 0; windowStart < totalTokens;
-       windowStart += stride) {
-    const int32_t validLen = std::min(seqLen_, totalTokens - windowStart);
-
-    std::vector<int64_t> paddedInputIds(static_cast<size_t>(seqLen_),
-                                        kPadTokenId);
-    std::vector<int64_t> paddedAttentionMask(static_cast<size_t>(seqLen_), 0);
-    for (int32_t i = 0; i < validLen; ++i) {
-      paddedInputIds[static_cast<size_t>(i)] =
-          static_cast<int64_t>(rawIds[static_cast<size_t>(windowStart + i)]);
-      paddedAttentionMask[static_cast<size_t>(i)] = 1;
-    }
-
-    const bool isFirst = windowStart == 0;
-    const bool isLast = windowStart + seqLen_ >= totalTokens;
-    int32_t writeFrom = isFirst ? 0 : edgeMargin;
-    int32_t writeTo = isLast ? validLen : seqLen_ - edgeMargin;
-
-    runWindow(paddedInputIds, paddedAttentionMask, windowStart, validLen,
-              writeFrom, writeTo, predictedLabels);
-
-    if (isLast) {
-      break;
-    }
-  }
-
-  struct Span {
-    int32_t start;
-    int32_t end; // exclusive
-    std::string entity;
-  };
-  std::vector<Span> spans;
-  int32_t i = 0;
-  while (i < totalTokens) {
-    const auto entity =
-        labelEntityType(predictedLabels[static_cast<size_t>(i)]);
-    if (entity.empty()) {
-      ++i;
-      continue;
-    }
-    int32_t j = i + 1;
-    while (j < totalTokens &&
-           labelEntityType(predictedLabels[static_cast<size_t>(j)]) == entity) {
-      ++j;
-    }
-    spans.emplace_back(i, j, entity);
-    i = j;
-  }
-
-  std::vector<types::PiiEntity> entities;
-  entities.reserve(spans.size());
-  for (const auto &span : spans) {
-    std::vector<uint64_t> slice;
-    slice.reserve(static_cast<size_t>(span.end - span.start));
-    for (int32_t k = span.start; k < span.end; ++k) {
-      slice.emplace_back(rawIds[static_cast<size_t>(k)]);
-    }
-    std::string decoded;
-    try {
-      decoded = tokenizer_->decode(slice, /*skipSpecialTokens=*/true);
-    } catch (...) {
-    }
-    constexpr auto notSpace = [](unsigned char c) { return !std::isspace(c); };
-    auto left = std::ranges::find_if(decoded, notSpace);
-    auto right =
-        std::ranges::find_if(decoded.rbegin(), decoded.rend(), notSpace).base();
-    if (left < right) {
-      decoded.assign(left, right);
-    } else {
-      decoded.clear();
-    }
-
-    entities.emplace_back(span.entity, std::move(decoded), span.start,
-                          span.end);
-  }
-  return entities;
-}
-
-} // namespace rnexecutorch::models::privacy_filter
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/privacy_filter/PrivacyFilter.h b/packages/react-native-executorch/common/rnexecutorch/models/privacy_filter/PrivacyFilter.h
deleted file mode 100644
index 880a9709f1..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/privacy_filter/PrivacyFilter.h
+++ /dev/null
@@ -1,54 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <mutex>
-#include <string>
-#include <vector>
-
-#include <ReactCommon/CallInvoker.h>
-
-#include <rnexecutorch/TokenizerModule.h>
-#include <rnexecutorch/metaprogramming/ConstructorHelpers.h>
-#include <rnexecutorch/models/BaseModel.h>
-#include <rnexecutorch/models/privacy_filter/Types.h>
-#include <rnexecutorch/models/privacy_filter/Viterbi.h>
-
-namespace rnexecutorch {
-namespace models::privacy_filter {
-using namespace facebook;
-
-class PrivacyFilter final : public BaseModel {
-public:
-  PrivacyFilter(const std::string &modelSource,
-                const std::string &tokenizerSource,
-                std::vector<std::string> labelNames,
-                std::vector<float> viterbiBiases,
-                std::shared_ptr<react::CallInvoker> callInvoker);
-
-  [[nodiscard("Registered non-void function")]] std::vector<types::PiiEntity>
-  generate(std::string text);
-
-  void unload() noexcept;
-
-private:
-  void runWindow(std::vector<int64_t> &paddedInputIds,
-                 std::vector<int64_t> &paddedAttentionMask, int32_t absStart,
-                 int32_t validLen, int32_t writeFromOffset,
-                 int32_t writeToOffset, std::vector<int32_t> &outLabels);
-
-  std::string labelEntityType(int32_t labelId) const;
-
-  mutable std::mutex inference_mutex_;
-  std::unique_ptr<TokenizerModule> tokenizer_;
-  std::vector<std::string> labelNames_;
-  viterbi::Biases biases_;
-  viterbi::Grammar grammar_;
-  int32_t seqLen_;
-};
-
-} // namespace models::privacy_filter
-
-REGISTER_CONSTRUCTOR(models::privacy_filter::PrivacyFilter, std::string,
-                     std::string, std::vector<std::string>, std::vector<float>,
-                     std::shared_ptr<react::CallInvoker>);
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/privacy_filter/Types.h b/packages/react-native-executorch/common/rnexecutorch/models/privacy_filter/Types.h
deleted file mode 100644
index 84a3a5d711..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/privacy_filter/Types.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <string>
-
-namespace rnexecutorch::models::privacy_filter::types {
-
-struct PiiEntity {
-  std::string label;
-  std::string text;
-  int32_t startToken;
-  int32_t endToken;
-};
-
-} // namespace rnexecutorch::models::privacy_filter::types
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/privacy_filter/Viterbi.cpp b/packages/react-native-executorch/common/rnexecutorch/models/privacy_filter/Viterbi.cpp
deleted file mode 100644
index 214ddbbea6..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/privacy_filter/Viterbi.cpp
+++ /dev/null
@@ -1,153 +0,0 @@
-#include "Viterbi.h"
-
-#include <algorithm>
-#include <iterator>
-#include <ranges>
-
-namespace rnexecutorch::models::privacy_filter::viterbi {
-
-namespace {
-
-constexpr float kNegInf = -1e30f;
-
-struct LabelRole {
-  char prefix; // 'O', 'B', 'I', 'E', 'S'
-  std::string entity;
-};
-
-LabelRole classifyLabel(const std::string &name) {
-  if (name == "O" || name.empty()) {
-    return {'O', ""};
-  }
-  if (name.size() < 2 || name[1] != '-') {
-    return {'O', ""};
-  }
-  return {name[0], name.substr(2)};
-}
-
-bool isValidTransition(const LabelRole &prev, const LabelRole &nxt) {
-  // BIOES grammar:
-  //   O / E-X / S-X -> O | B-* | S-*
-  //   B-X / I-X     -> I-X | E-X  (same entity type)
-  if (prev.prefix == 'O' || prev.prefix == 'E' || prev.prefix == 'S') {
-    return nxt.prefix == 'O' || nxt.prefix == 'B' || nxt.prefix == 'S';
-  }
-  if (prev.prefix == 'B' || prev.prefix == 'I') {
-    return (nxt.prefix == 'I' || nxt.prefix == 'E') &&
-           nxt.entity == prev.entity;
-  }
-  return false;
-}
-
-float biasFor(const LabelRole &prev, const LabelRole &nxt, const Biases &b) {
-  if (prev.prefix == 'O' && nxt.prefix == 'O') {
-    return b.backgroundStay;
-  }
-  if (prev.prefix == 'O' && (nxt.prefix == 'B' || nxt.prefix == 'S')) {
-    return b.backgroundToStart;
-  }
-  if ((prev.prefix == 'E' || prev.prefix == 'S') && nxt.prefix == 'O') {
-    return b.endToBackground;
-  }
-  if ((prev.prefix == 'E' || prev.prefix == 'S') &&
-      (nxt.prefix == 'B' || nxt.prefix == 'S')) {
-    return b.endToStart;
-  }
-  if ((prev.prefix == 'B' || prev.prefix == 'I') && nxt.prefix == 'I') {
-    return b.insideToContinue;
-  }
-  if ((prev.prefix == 'B' || prev.prefix == 'I') && nxt.prefix == 'E') {
-    return b.insideToEnd;
-  }
-  return 0.0f;
-}
-
-} // namespace
-
-Grammar buildGrammar(const std::vector<std::string> &labelNames,
-                     const Biases &biases) {
-  const size_t N = labelNames.size();
-  std::vector<LabelRole> roles;
-  roles.reserve(N);
-  for (const auto &name : labelNames) {
-    roles.emplace_back(classifyLabel(name));
-  }
-
-  Grammar grammar;
-  grammar.numLabels = N;
-  // transitionScore[i*N+j]: bias for valid transitions, -inf for invalid.
-  // Fused float lets the inner loop avoid a validity branch.
-  grammar.transitionScore.assign(N * N, kNegInf);
-  for (size_t i = 0; i < N; ++i) {
-    for (size_t j = 0; j < N; ++j) {
-      if (isValidTransition(roles[i], roles[j])) {
-        grammar.transitionScore[i * N + j] =
-            biasFor(roles[i], roles[j], biases);
-      }
-    }
-  }
-
-  grammar.validStart.assign(N, false);
-  for (size_t i = 0; i < N; ++i) {
-    grammar.validStart[i] = (roles[i].prefix == 'O' || roles[i].prefix == 'B' ||
-                             roles[i].prefix == 'S');
-  }
-  return grammar;
-}
-
-std::vector<int32_t> decode(const float *logits, int32_t validLen,
-                            const Grammar &grammar) {
-  if (validLen <= 0) {
-    return {};
-  }
-
-  const size_t N = grammar.numLabels;
-  std::vector<float> dp(N, kNegInf);
-  std::vector<float> dpNext(N, kNegInf);
-  // Allocate bp as [validLen, N] for indexing convenience; row 0 is unused
-  // (traceback starts at t = 1 and consults bp[t * N + j]).
-  std::vector<int32_t> bp(static_cast<size_t>(validLen) * N, 0);
-
-  {
-    const float *row0 = logits;
-    for (size_t j = 0; j < N; ++j) {
-      dp[j] = grammar.validStart[j] ? row0[j] : kNegInf;
-    }
-  }
-
-  for (int32_t t = 1; t < validLen; ++t) {
-    const float *rowT = logits + static_cast<size_t>(t) * N;
-    for (size_t j = 0; j < N; ++j) {
-      float best = kNegInf;
-      int32_t bestPrev = 0;
-      for (size_t i = 0; i < N; ++i) {
-        const float trans = grammar.transitionScore[i * N + j];
-        if (trans <= kNegInf / 2.0f) {
-          continue;
-        }
-        const float cand = dp[i] + trans;
-        if (cand > best) {
-          best = cand;
-          bestPrev = static_cast<int32_t>(i);
-        }
-      }
-      dpNext[j] = best == kNegInf ? kNegInf : best + rowT[j];
-      bp[static_cast<size_t>(t) * N + j] = bestPrev;
-    }
-    std::swap(dp, dpNext);
-  }
-
-  auto it = std::ranges::max_element(dp);
-  size_t bestEnd = std::distance(dp.begin(), it);
-
-  std::vector<int32_t> path(static_cast<size_t>(validLen), 0);
-  path[static_cast<size_t>(validLen) - 1] = static_cast<int32_t>(bestEnd);
-  for (int32_t t = validLen - 1; t > 0; --t) {
-    path[static_cast<size_t>(t) - 1] =
-        bp[static_cast<size_t>(t) * N +
-           static_cast<size_t>(path[static_cast<size_t>(t)])];
-  }
-  return path;
-}
-
-} // namespace rnexecutorch::models::privacy_filter::viterbi
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/privacy_filter/Viterbi.h b/packages/react-native-executorch/common/rnexecutorch/models/privacy_filter/Viterbi.h
deleted file mode 100644
index ec0912c7fb..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/privacy_filter/Viterbi.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <string>
-#include <vector>
-
-namespace rnexecutorch::models::privacy_filter::viterbi {
-
-// Six Viterbi transition biases matching the openai/privacy-filter
-// viterbi_calibration.json schema. Each value is added to the decoder score
-// for the corresponding BIOES transition. Positive = encourage, negative =
-// discourage. Defaults are zero (neutral, validity-only Viterbi).
-// JSI callers pass a 6-element vector; indices match the field order below.
-struct Biases {
-  float backgroundStay = 0.0f;    // [0] O      -> O
-  float backgroundToStart = 0.0f; // [1] O      -> B-* / S-*
-  float endToBackground = 0.0f;   // [2] E-/S-* -> O
-  float endToStart = 0.0f;        // [3] E-/S-* -> B-* / S-*
-  float insideToContinue = 0.0f;  // [4] B-/I-X -> I-X
-  float insideToEnd = 0.0f;       // [5] B-/I-X -> E-X
-};
-
-// Pre-computed BIOES grammar tables.
-//   transitionScore[i*N + j] = bias for valid transitions, -inf for invalid.
-//   validStart[i] = true iff label i is a legal first-token label (O, B-*,
-//   S-*).
-struct Grammar {
-  std::vector<float> transitionScore;
-  std::vector<bool> validStart;
-  size_t numLabels = 0;
-};
-
-Grammar buildGrammar(const std::vector<std::string> &labelNames,
-                     const Biases &biases);
-
-// Run constrained Viterbi over [validLen, numLabels] logits and return the
-// best BIOES-grammar-valid label-id sequence (length validLen).
-std::vector<int32_t> decode(const float *logits, int32_t validLen,
-                            const Grammar &grammar);
-
-} // namespace rnexecutorch::models::privacy_filter::viterbi
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/semantic_segmentation/BaseSemanticSegmentation.cpp b/packages/react-native-executorch/common/rnexecutorch/models/semantic_segmentation/BaseSemanticSegmentation.cpp
deleted file mode 100644
index ed88434533..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/semantic_segmentation/BaseSemanticSegmentation.cpp
+++ /dev/null
@@ -1,246 +0,0 @@
-#include "BaseSemanticSegmentation.h"
-#include "jsi/jsi.h"
-
-#include <executorch/extension/tensor/tensor.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/Log.h>
-#include <rnexecutorch/data_processing/ImageProcessing.h>
-#include <rnexecutorch/models/BaseModel.h>
-#include <rnexecutorch/utils/FrameProcessor.h>
-#include <rnexecutorch/utils/FrameTransform.h>
-
-namespace rnexecutorch::models::semantic_segmentation {
-
-BaseSemanticSegmentation::BaseSemanticSegmentation(
-    const std::string &modelSource, std::vector<float> normMean,
-    std::vector<float> normStd, std::vector<std::string> allClasses,
-    std::shared_ptr<react::CallInvoker> callInvoker)
-    : VisionModel(modelSource, callInvoker),
-      allClasses_(std::move(allClasses)) {
-  initModelImageSize();
-  if (normMean.size() == 3) {
-    normMean_ = cv::Scalar(normMean[0], normMean[1], normMean[2]);
-  } else if (!normMean.empty()) {
-    log(LOG_LEVEL::Warn,
-        "normMean must have 3 elements — ignoring provided value.");
-  }
-  if (normStd.size() == 3) {
-    normStd_ = cv::Scalar(normStd[0], normStd[1], normStd[2]);
-  } else if (!normStd.empty()) {
-    log(LOG_LEVEL::Warn,
-        "normStd must have 3 elements — ignoring provided value.");
-  }
-}
-
-void BaseSemanticSegmentation::initModelImageSize() {
-  auto inputShapes = getAllInputShapes();
-  if (inputShapes.empty()) {
-    throw RnExecutorchError(RnExecutorchErrorCode::UnexpectedNumInputs,
-                            "Model seems to not take any input tensors.");
-  }
-  modelInputShape_ = inputShapes[0];
-  if (modelInputShape_.size() < 2) {
-    throw RnExecutorchError(RnExecutorchErrorCode::WrongDimensions,
-                            "Unexpected model input size, expected at least 2 "
-                            "dimensions but got: " +
-                                std::to_string(modelInputShape_.size()) + ".");
-  }
-  numModelPixels = modelInputSize().area();
-}
-
-semantic_segmentation::SegmentationResult
-BaseSemanticSegmentation::runInference(
-    cv::Mat image, cv::Size originalSize,
-    std::set<std::string, std::less<>> &classesOfInterest, bool resize) {
-  std::scoped_lock lock(inference_mutex_);
-
-  cv::Mat preprocessed = VisionModel::preprocess(image);
-  auto inputTensor =
-      (normMean_ && normStd_)
-          ? image_processing::getTensorFromMatrix(
-                modelInputShape_, preprocessed, *normMean_, *normStd_)
-          : image_processing::getTensorFromMatrix(modelInputShape_,
-                                                  preprocessed);
-
-  auto forwardResult = BaseModel::forward(inputTensor);
-  CHECK_OK_OR_THROW_FORWARD_ERROR(forwardResult);
-
-  return computeResult(forwardResult->at(0).toTensor(), originalSize,
-                       allClasses_, classesOfInterest, resize);
-}
-
-semantic_segmentation::SegmentationResult
-BaseSemanticSegmentation::generateFromString(
-    std::string imageSource,
-    std::set<std::string, std::less<>> classesOfInterest, bool resize) {
-  cv::Mat imageBGR = image_processing::readImage(imageSource);
-  cv::Size originalSize = imageBGR.size();
-  cv::Mat imageRGB;
-  cv::cvtColor(imageBGR, imageRGB, cv::COLOR_BGR2RGB);
-
-  return runInference(imageRGB, originalSize, classesOfInterest, resize);
-}
-
-semantic_segmentation::SegmentationResult
-BaseSemanticSegmentation::generateFromPixels(
-    JSTensorViewIn pixelData,
-    std::set<std::string, std::less<>> classesOfInterest, bool resize) {
-  cv::Mat image = extractFromPixels(pixelData);
-  return runInference(image, image.size(), classesOfInterest, resize);
-}
-
-semantic_segmentation::SegmentationResult
-BaseSemanticSegmentation::generateFromFrame(
-    jsi::Runtime &runtime, const jsi::Value &frameData,
-    std::set<std::string, std::less<>> classesOfInterest, bool resize) {
-  auto orient = ::rnexecutorch::utils::readFrameOrientation(runtime, frameData);
-  cv::Mat frame = extractFromFrame(runtime, frameData);
-  cv::Mat rotated = utils::rotateFrameForModel(frame, orient);
-  // Always run inference without resize — rotate first, then resize.
-  auto result = runInference(rotated, rotated.size(), classesOfInterest, false);
-
-  const cv::Size outputSize = modelInputSize();
-  // JS reads maskW=frame.height, maskH=frame.width (sensor-native swap).
-  const cv::Size frameSize = frame.size();
-
-  auto inverseAndResize = [&orient, &frameSize, &outputSize,
-                           resize](std::shared_ptr<OwningArrayBuffer> &buf,
-                                   int32_t cvType, int32_t interpFlag) {
-    cv::Mat m(outputSize, cvType, buf->data());
-    cv::Mat inv = utils::inverseRotateMat(m, orient);
-    if (resize && inv.size() != frameSize) {
-      cv::resize(inv, inv, frameSize, 0, 0, interpFlag);
-    }
-    buf = std::make_shared<OwningArrayBuffer>(
-        inv.data, static_cast<size_t>(inv.total() * inv.elemSize()));
-  };
-
-  if (outputSize.area() > 0) {
-    if (result.argmax) {
-      inverseAndResize(result.argmax, CV_32SC1, cv::INTER_NEAREST);
-    }
-    if (result.classBuffers) {
-      for (auto &[label, buf] : *result.classBuffers) {
-        inverseAndResize(buf, CV_32FC1, cv::INTER_LINEAR);
-      }
-    }
-  }
-
-  return result;
-}
-
-semantic_segmentation::SegmentationResult
-BaseSemanticSegmentation::computeResult(
-    const Tensor &tensor, cv::Size originalSize,
-    std::vector<std::string> &allClasses,
-    std::set<std::string, std::less<>> &classesOfInterest, bool resize) {
-
-  const auto *dataPtr = tensor.const_data_ptr<float>();
-  auto resultData = std::span(dataPtr, tensor.numel());
-
-  // Read output dimensions directly from tensor shape
-  std::size_t numChannels =
-      (tensor.dim() >= 3) ? tensor.size(tensor.dim() - 3) : 1;
-  std::size_t outputH = tensor.size(tensor.dim() - 2);
-  std::size_t outputW = tensor.size(tensor.dim() - 1);
-  std::size_t outputPixels = outputH * outputW;
-  cv::Size outputSize(outputW, outputH);
-
-  // Copy class data directly into OwningArrayBuffers (single copy from span)
-  std::vector<std::shared_ptr<OwningArrayBuffer>> resultClasses;
-  resultClasses.reserve(numChannels);
-
-  if (numChannels == 1) {
-    // Binary segmentation (e.g. selfie segmentation)
-    auto fg = std::make_shared<OwningArrayBuffer>(resultData.data(),
-                                                  outputPixels * sizeof(float));
-    auto bg = std::make_shared<OwningArrayBuffer>(outputPixels * sizeof(float));
-    auto *fgPtr = reinterpret_cast<float *>(fg->data());
-    auto *bgPtr = reinterpret_cast<float *>(bg->data());
-    for (std::size_t pixel = 0; pixel < outputPixels; ++pixel) {
-      bgPtr[pixel] = 1.0f - fgPtr[pixel];
-    }
-    resultClasses.push_back(fg);
-    resultClasses.push_back(bg);
-  } else {
-    // Multi-class segmentation (e.g. DeepLab, RF-DETR)
-    for (std::size_t cl = 0; cl < numChannels; ++cl) {
-      resultClasses.push_back(std::make_shared<OwningArrayBuffer>(
-          resultData.data() + cl * outputPixels, outputPixels * sizeof(float)));
-    }
-  }
-
-  // Softmax + argmax in class-major order
-  auto argmax =
-      std::make_shared<OwningArrayBuffer>(outputPixels * sizeof(int32_t));
-  auto *argmaxPtr = reinterpret_cast<int32_t *>(argmax->data());
-
-  if (numChannels == 1) {
-    auto *fgPtr = reinterpret_cast<float *>(resultClasses[0]->data());
-    for (std::size_t pixel = 0; pixel < outputPixels; ++pixel) {
-      argmaxPtr[pixel] = (fgPtr[pixel] > 0.5f) ? 0 : 1;
-    }
-  } else {
-    std::vector<float> maxLogits(outputPixels,
-                                 -std::numeric_limits<float>::infinity());
-    std::vector<float> sumExp(outputPixels, 0.0f);
-
-    // Pass 1: find per-pixel max and argmax
-    for (std::size_t cl = 0; cl < numChannels; ++cl) {
-      auto *clPtr = reinterpret_cast<float *>(resultClasses[cl]->data());
-      for (std::size_t pixel = 0; pixel < outputPixels; ++pixel) {
-        if (clPtr[pixel] > maxLogits[pixel]) {
-          maxLogits[pixel] = clPtr[pixel];
-          argmaxPtr[pixel] = static_cast<int32_t>(cl);
-        }
-      }
-    }
-
-    // Pass 2: subtract max, exp, accumulate sum
-    for (std::size_t cl = 0; cl < numChannels; ++cl) {
-      auto *clPtr = reinterpret_cast<float *>(resultClasses[cl]->data());
-      for (std::size_t pixel = 0; pixel < outputPixels; ++pixel) {
-        clPtr[pixel] = std::exp(clPtr[pixel] - maxLogits[pixel]);
-        sumExp[pixel] += clPtr[pixel];
-      }
-    }
-
-    // Pass 3: normalize by sum
-    for (std::size_t cl = 0; cl < numChannels; ++cl) {
-      auto *clPtr = reinterpret_cast<float *>(resultClasses[cl]->data());
-      for (std::size_t pixel = 0; pixel < outputPixels; ++pixel) {
-        clPtr[pixel] /= sumExp[pixel];
-      }
-    }
-  }
-
-  auto buffersToReturn = std::make_shared<
-      std::unordered_map<std::string, std::shared_ptr<OwningArrayBuffer>>>();
-  bool returnAllClasses = classesOfInterest.empty();
-  for (std::size_t cl = 0; cl < resultClasses.size(); ++cl) {
-    if (cl < allClasses.size() &&
-        (returnAllClasses || classesOfInterest.contains(allClasses[cl]))) {
-      (*buffersToReturn)[allClasses[cl]] = resultClasses[cl];
-    }
-  }
-
-  // Resize selected classes and argmax
-  if (resize) {
-    cv::Mat argmaxMat(outputSize, CV_32SC1, argmax->data());
-    cv::resize(argmaxMat, argmaxMat, originalSize, 0, 0,
-               cv::InterpolationFlags::INTER_NEAREST);
-    argmax = std::make_shared<OwningArrayBuffer>(
-        argmaxMat.data, originalSize.area() * sizeof(int32_t));
-
-    for (auto &[label, arrayBuffer] : *buffersToReturn) {
-      cv::Mat classMat(outputSize, CV_32FC1, arrayBuffer->data());
-      cv::resize(classMat, classMat, originalSize);
-      arrayBuffer = std::make_shared<OwningArrayBuffer>(
-          classMat.data, originalSize.area() * sizeof(float));
-    }
-  }
-
-  return semantic_segmentation::SegmentationResult{argmax, buffersToReturn};
-}
-
-} // namespace rnexecutorch::models::semantic_segmentation
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/semantic_segmentation/BaseSemanticSegmentation.h b/packages/react-native-executorch/common/rnexecutorch/models/semantic_segmentation/BaseSemanticSegmentation.h
deleted file mode 100644
index a30ae375bf..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/semantic_segmentation/BaseSemanticSegmentation.h
+++ /dev/null
@@ -1,68 +0,0 @@
-#pragma once
-
-#include <opencv2/opencv.hpp>
-#include <optional>
-#include <set>
-
-#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
-#include <rnexecutorch/models/VisionModel.h>
-#include <rnexecutorch/models/semantic_segmentation/Types.h>
-
-namespace rnexecutorch {
-namespace models::semantic_segmentation {
-using namespace facebook;
-
-using executorch::aten::Tensor;
-
-class BaseSemanticSegmentation : public VisionModel {
-public:
-  BaseSemanticSegmentation(const std::string &modelSource,
-                           std::vector<float> normMean,
-                           std::vector<float> normStd,
-                           std::vector<std::string> allClasses,
-                           std::shared_ptr<react::CallInvoker> callInvoker);
-
-  [[nodiscard("Registered non-void function")]]
-  semantic_segmentation::SegmentationResult
-  generateFromString(std::string imageSource,
-                     std::set<std::string, std::less<>> classesOfInterest,
-                     bool resize);
-
-  [[nodiscard("Registered non-void function")]]
-  semantic_segmentation::SegmentationResult
-  generateFromPixels(JSTensorViewIn pixelData,
-                     std::set<std::string, std::less<>> classesOfInterest,
-                     bool resize);
-
-  [[nodiscard("Registered non-void function")]]
-  semantic_segmentation::SegmentationResult
-  generateFromFrame(jsi::Runtime &runtime, const jsi::Value &frameData,
-                    std::set<std::string, std::less<>> classesOfInterest,
-                    bool resize);
-
-protected:
-  virtual semantic_segmentation::SegmentationResult
-  computeResult(const Tensor &tensor, cv::Size originalSize,
-                std::vector<std::string> &allClasses,
-                std::set<std::string, std::less<>> &classesOfInterest,
-                bool resize);
-  std::size_t numModelPixels;
-  std::optional<cv::Scalar> normMean_;
-  std::optional<cv::Scalar> normStd_;
-  std::vector<std::string> allClasses_;
-
-private:
-  void initModelImageSize();
-
-  semantic_segmentation::SegmentationResult
-  runInference(cv::Mat image, cv::Size originalSize,
-               std::set<std::string, std::less<>> &classesOfInterest,
-               bool resize);
-};
-} // namespace models::semantic_segmentation
-
-REGISTER_CONSTRUCTOR(models::semantic_segmentation::BaseSemanticSegmentation,
-                     std::string, std::vector<float>, std::vector<float>,
-                     std::vector<std::string>,
-                     std::shared_ptr<react::CallInvoker>);
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/semantic_segmentation/Types.h b/packages/react-native-executorch/common/rnexecutorch/models/semantic_segmentation/Types.h
deleted file mode 100644
index b305b96a70..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/semantic_segmentation/Types.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <rnexecutorch/jsi/OwningArrayBuffer.h>
-#include <string>
-#include <unordered_map>
-
-namespace rnexecutorch::models::semantic_segmentation {
-
-struct SegmentationResult {
-  std::shared_ptr<OwningArrayBuffer> argmax;
-  std::shared_ptr<
-      std::unordered_map<std::string, std::shared_ptr<OwningArrayBuffer>>>
-      classBuffers;
-};
-
-} // namespace rnexecutorch::models::semantic_segmentation
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/SpeechToText.cpp b/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/SpeechToText.cpp
deleted file mode 100644
index f3ec9f755f..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/SpeechToText.cpp
+++ /dev/null
@@ -1,216 +0,0 @@
-#include <thread>
-
-#include "SpeechToText.h"
-#include "common/types/TranscriptionResult.h"
-#include "whisper/ASR.h"
-#include "whisper/OnlineASR.h"
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-
-namespace rnexecutorch::models::speech_to_text {
-
-SpeechToText::SpeechToText(const std::string &modelName,
-                           const std::string &modelSource,
-                           const std::string &tokenizerSource,
-                           const std::string &vadSource,
-                           std::shared_ptr<react::CallInvoker> callInvoker)
-    : callInvoker_(std::move(callInvoker)) {
-  // Switch between the ASR implementations based on model name
-  if (modelName == "whisper") {
-    if (!vadSource.empty()) {
-      vad_ = std::make_unique<VoiceActivityDetection>(vadSource, callInvoker_);
-    }
-
-    transcriber_ = std::make_unique<whisper::ASR>(modelSource, tokenizerSource,
-                                                  callInvoker_);
-    streamer_ = std::make_unique<whisper::stream::OnlineASR>(
-        static_cast<const whisper::ASR *>(transcriber_.get()),
-        static_cast<const VoiceActivityDetection *>(vad_.get()));
-  } else {
-    throw rnexecutorch::RnExecutorchError(
-        rnexecutorch::RnExecutorchErrorCode::InvalidConfig,
-        "[SpeechToText]: Invalid model name: " + modelName);
-  }
-}
-
-SpeechToText::SpeechToText(SpeechToText &&other) noexcept
-    : callInvoker_(std::move(other.callInvoker_)),
-      transcriber_(std::move(other.transcriber_)),
-      streamer_(std::move(other.streamer_)),
-      isStreaming_(other.isStreaming_.load()),
-      readyToProcess_(other.readyToProcess_.load()) {}
-
-void SpeechToText::unload() noexcept { transcriber_->unload(); }
-
-std::shared_ptr<OwningArrayBuffer>
-SpeechToText::encode(std::span<float> waveform) const {
-  executorch::aten::Tensor encoderOutputTensor = transcriber_->encode(waveform);
-
-  return std::make_shared<OwningArrayBuffer>(
-      encoderOutputTensor.const_data_ptr<float>(),
-      sizeof(float) * encoderOutputTensor.numel());
-}
-
-std::shared_ptr<OwningArrayBuffer>
-SpeechToText::decode(std::span<uint64_t> tokens,
-                     std::span<float> encoderOutput) const {
-  executorch::aten::Tensor decoderOutputTensor =
-      transcriber_->decode(tokens, encoderOutput);
-
-  return std::make_shared<OwningArrayBuffer>(
-      decoderOutputTensor.const_data_ptr<float>(),
-      sizeof(float) * decoderOutputTensor.numel());
-}
-
-TranscriptionResult SpeechToText::transcribe(std::span<float> waveform,
-                                             std::string languageOption,
-                                             bool verbose) const {
-  DecodingOptions options(languageOption, verbose);
-  std::vector<Segment> segments = transcriber_->transcribe(waveform, options);
-
-  std::string fullText;
-  for (const auto &segment : segments) {
-    for (const auto &word : segment.words)
-      fullText += word.content;
-  }
-
-  TranscriptionResult result;
-  result.text = fullText;
-  result.task = "transcribe";
-
-  if (verbose) {
-    result.language = languageOption.empty() ? "english" : languageOption;
-    result.duration = static_cast<double>(waveform.size()) / 16000.0;
-    result.segments = std::move(segments);
-  }
-
-  return result;
-}
-
-size_t SpeechToText::getMemoryLowerBound() const noexcept {
-  return transcriber_->getMemoryLowerBound();
-}
-
-namespace {
-TranscriptionResult wordsToResult(const std::vector<Word> &words,
-                                  const std::string &language, bool verbose) {
-  TranscriptionResult res;
-  res.language = language;
-  res.task = "stream";
-
-  std::string fullText;
-  for (const auto &w : words) {
-    fullText += w.content;
-  }
-  res.text = fullText;
-
-  if (verbose && !words.empty()) {
-    Segment seg;
-    seg.start = words.front().start;
-    seg.end = words.back().end;
-    seg.words = words;
-    seg.avgLogprob = std::nanf("0");
-    seg.compressionRatio = std::nanf("0");
-    seg.temperature = std::nanf("0");
-
-    res.segments.push_back(std::move(seg));
-  }
-
-  return res;
-}
-} // namespace
-
-void SpeechToText::stream(std::shared_ptr<jsi::Function> callback,
-                          std::string languageOption, bool verbose,
-                          uint32_t timeout, bool useVAD,
-                          uint32_t vadDetectionMargin) {
-  if (isStreaming_) {
-    throw RnExecutorchError(RnExecutorchErrorCode::StreamingInProgress,
-                            "Streaming is already in progress!");
-  }
-
-  // VAD must be initialized for this option to work.
-  if (useVAD && !vad_) {
-    throw RnExecutorchError(RnExecutorchErrorCode::ModuleNotLoaded,
-                            "Attempting to use VAD but it's not initialized!");
-  }
-
-  auto nativeCallback =
-      [this, callback](const TranscriptionResult &committed,
-                       const TranscriptionResult &nonCommitted, bool isDone) {
-        // This moves execution to the JS thread
-        callInvoker_->invokeAsync(
-            [callback, committed, nonCommitted, isDone](jsi::Runtime &rt) {
-              jsi::Value jsiCommitted =
-                  rnexecutorch::jsi_conversion::getJsiValue(committed, rt);
-              jsi::Value jsiNonCommitted =
-                  rnexecutorch::jsi_conversion::getJsiValue(nonCommitted, rt);
-
-              callback->call(rt, std::move(jsiCommitted),
-                             std::move(jsiNonCommitted), jsi::Value(isDone));
-            });
-      };
-
-  isStreaming_ = true;
-  StreamingOptions options(languageOption, verbose, useVAD, vadDetectionMargin);
-
-  while (isStreaming_) {
-    if (readyToProcess_ && streamer_->isReady()) {
-      ProcessResult res = streamer_->process(options);
-
-      // This is not only about optimization, but also about ensuring
-      // correctness when VAD is used. Otherwise we run into the vanishing text
-      // issue.
-      if (!res.committed.empty() || !res.nonCommitted.empty()) {
-        TranscriptionResult committedRes =
-            wordsToResult(res.committed, languageOption, verbose);
-        TranscriptionResult nonCommittedRes =
-            wordsToResult(res.nonCommitted, languageOption, verbose);
-
-        nativeCallback(committedRes, nonCommittedRes, false);
-      }
-
-      readyToProcess_ = false;
-    }
-
-    // Add a minimal pause between transcriptions.
-    // The reasoning is very simple: with the current liberal threshold values,
-    // running transcriptions too rapidly (before the audio buffer is filled
-    // with significant amount of new data) can cause streamer to commit wrong
-    // phrases. We wait on a condition_variable so streamStop() can break the
-    // pause immediately — inserts intentionally do not wake us, to preserve
-    // the throttle.
-    std::unique_lock<std::mutex> lock(streamCvMutex_);
-    streamCv_.wait_for(lock, std::chrono::milliseconds(timeout),
-                       [this] { return !isStreaming_.load(); });
-  }
-
-  // Do not use VAD on final processing to flush and commit everything properly.
-  StreamingOptions finishOptions = options;
-  finishOptions.useVAD = false;
-
-  std::vector<Word> finalWords = streamer_->finish(finishOptions);
-  TranscriptionResult finalRes =
-      wordsToResult(finalWords, languageOption, verbose);
-
-  nativeCallback(finalRes, {}, true);
-  resetStreamState();
-}
-
-void SpeechToText::streamStop() {
-  isStreaming_ = false;
-  streamCv_.notify_all();
-}
-
-void SpeechToText::streamInsert(std::span<float> waveform) {
-  streamer_->insertAudioChunk(waveform);
-  readyToProcess_ = true;
-}
-
-void SpeechToText::resetStreamState() {
-  isStreaming_ = false;
-  readyToProcess_ = false;
-  streamer_->reset();
-}
-
-} // namespace rnexecutorch::models::speech_to_text
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/SpeechToText.h b/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/SpeechToText.h
deleted file mode 100644
index 9c084dcf6e..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/SpeechToText.h
+++ /dev/null
@@ -1,79 +0,0 @@
-#pragma once
-
-#include <atomic>
-#include <condition_variable>
-#include <mutex>
-#include <span>
-#include <string>
-#include <vector>
-
-#include "common/schema/ASR.h"
-#include "common/schema/OnlineASR.h"
-#include "common/types/TranscriptionResult.h"
-#include <rnexecutorch/models/voice_activity_detection/VoiceActivityDetection.h>
-
-namespace rnexecutorch {
-
-namespace models::speech_to_text {
-
-using voice_activity_detection::VoiceActivityDetection;
-
-class SpeechToText {
-public:
-  SpeechToText(const std::string &modelName, const std::string &modelSource,
-               const std::string &tokenizerSource, const std::string &vadSource,
-               std::shared_ptr<react::CallInvoker> callInvoker);
-
-  // Required because of std::atomic usage
-  SpeechToText(SpeechToText &&other) noexcept;
-
-  void unload() noexcept;
-  [[nodiscard(
-      "Registered non-void function")]] std::shared_ptr<OwningArrayBuffer>
-  encode(std::span<float> waveform) const;
-  [[nodiscard(
-      "Registered non-void function")]] std::shared_ptr<OwningArrayBuffer>
-  decode(std::span<uint64_t> tokens, std::span<float> encoderOutput) const;
-  [[nodiscard("Registered non-void function")]]
-  TranscriptionResult transcribe(std::span<float> waveform,
-                                 std::string languageOption,
-                                 bool verbose) const;
-
-  size_t getMemoryLowerBound() const noexcept;
-
-  // Stream
-  void stream(std::shared_ptr<jsi::Function> callback,
-              std::string languageOption, bool verbose,
-              uint32_t timeout, bool useVAD, uint32_t vadDetectionMargin);
-  void streamStop();
-  void streamInsert(std::span<float> waveform);
-
-private:
-  void resetStreamState();
-
-  std::shared_ptr<react::CallInvoker> callInvoker_;
-
-  // ASR-like module (both static transcription & streaming)
-  std::unique_ptr<schema::ASR> transcriber_ = nullptr;
-
-  // Online ASR-like module (streaming only)
-  std::unique_ptr<schema::OnlineASR> streamer_ = nullptr;
-  std::atomic<bool> isStreaming_ = false;
-  std::atomic<bool> readyToProcess_ = false;
-
-  // Lets streamStop() wake the streaming loop immediately instead of
-  // waiting for the next throttling interval to expire.
-  std::mutex streamCvMutex_;
-  std::condition_variable streamCv_;
-
-  // VAD submodule
-  std::unique_ptr<VoiceActivityDetection> vad_ = nullptr;
-};
-
-} // namespace models::speech_to_text
-
-REGISTER_CONSTRUCTOR(models::speech_to_text::SpeechToText, std::string,
-                     std::string, std::string, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/schema/ASR.h b/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/schema/ASR.h
deleted file mode 100644
index 61ca8b6871..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/schema/ASR.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-
-#include <cinttypes>
-#include <span>
-#include <vector>
-
-#include "../types/Options.h"
-#include "../types/Segment.h"
-#include <rnexecutorch/models/BaseModel.h>
-
-namespace rnexecutorch::models::speech_to_text::schema {
-
-/**
- * @brief Abstract base class for Automatic Speech Recognition (ASR) models.
- *
- * Provides a unified interface for speech-to-text models like Whisper, allowing
- * for transcription of raw audio waveforms into text segments, as well as
- * access to lower-level model components like encoding and decoding.
- */
-class ASR {
-public:
-  virtual ~ASR() = default;
-
-  virtual std::vector<Segment>
-  transcribe(std::span<const float> waveform,
-             const DecodingOptions &options) const = 0;
-
-  virtual executorch::aten::Tensor
-  encode(std::span<const float> waveform) const = 0;
-
-  virtual executorch::aten::Tensor decode(std::span<uint64_t> tokens,
-                                          std::span<const float> encoderOutput,
-                                          uint64_t startPos = 0) const = 0;
-
-  // Standard ExecuTorch model methods for compatibility with the rest of the
-  // API.
-  virtual void unload() noexcept = 0;
-  virtual std::size_t getMemoryLowerBound() const noexcept = 0;
-};
-
-} // namespace rnexecutorch::models::speech_to_text::schema
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/schema/OnlineASR.h b/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/schema/OnlineASR.h
deleted file mode 100644
index b2ba2bb62b..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/schema/OnlineASR.h
+++ /dev/null
@@ -1,44 +0,0 @@
-#pragma once
-
-#include <span>
-#include <vector>
-
-#include "../types/Options.h"
-#include "../types/ProcessResult.h"
-#include "../types/Word.h"
-
-namespace rnexecutorch::models::speech_to_text::schema {
-
-/**
- * @brief Abstract base class for Online (streaming) Automatic Speech
- * Recognition.
- *
- * Provides an interface for processing audio in chunks, allowing for real-time
- * transcription results. Implementations of this interface typically maintain
- * an internal audio buffer and a hypothesis buffer for incremental decoding.
- *
- * Requires 5 main methods to be implemented:
- * - insertAudioChunk(): for expanding the collected audio (typically adding to
- * a buffer)
- * - ready(): returns a boolean flag indicating whether the module is ready to
- * process the next iteration
- * - process(): for processing a next chunk of audio (next iterartion)
- * - finish(): called to finish the live transcription mode
- * - reset(): resets the streaming state
- */
-class OnlineASR {
-public:
-  virtual ~OnlineASR() = default;
-
-  virtual void insertAudioChunk(std::span<const float> audio) = 0;
-
-  virtual bool isReady() const = 0;
-
-  virtual ProcessResult process(const StreamingOptions &options) = 0;
-
-  virtual std::vector<Word> finish(const StreamingOptions &options) = 0;
-
-  virtual void reset() = 0;
-};
-
-} // namespace rnexecutorch::models::speech_to_text::schema
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/types/GenerationResult.h b/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/types/GenerationResult.h
deleted file mode 100644
index 1b6c54805a..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/types/GenerationResult.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#pragma once
-
-#include "Token.h"
-#include <cinttypes>
-#include <vector>
-
-namespace rnexecutorch::models::speech_to_text {
-
-/**
- * An intermediate result of speech-to-text processing, before merging
- * into words.
- *
- * @property tokens Decoded tokens
- * @property scores Probabilities for each corresponding token obtained
- *                  by applying softmax on decoder's output (logits).
- */
-struct GenerationResult {
-  std::vector<Token> tokens;
-  std::vector<float> scores;
-};
-
-} // namespace rnexecutorch::models::speech_to_text
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/types/Options.h b/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/types/Options.h
deleted file mode 100644
index 760106d3f9..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/types/Options.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#pragma once
-
-#include <optional>
-#include <string>
-
-namespace rnexecutorch::models::speech_to_text {
-
-struct DecodingOptions {
-  DecodingOptions(const std::string &language, bool verbose = false)
-      : language(language.empty() ? std::nullopt : std::optional(language)),
-        verbose(verbose) {}
-
-  std::optional<std::string> language;
-  bool verbose;
-};
-
-struct StreamingOptions : public DecodingOptions {
-  StreamingOptions(const std::string &language, bool verbose = false,
-                   bool useVAD = false, uint32_t vadDetectionMargin = 500)
-      : DecodingOptions(language, verbose), useVAD(useVAD),
-        vadDetectionMargin(vadDetectionMargin) {}
-
-  bool useVAD;
-  uint32_t vadDetectionMargin;
-};
-
-} // namespace rnexecutorch::models::speech_to_text
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/types/ProcessResult.h b/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/types/ProcessResult.h
deleted file mode 100644
index 16476f71cc..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/types/ProcessResult.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#pragma once
-
-#include "Word.h"
-#include <string>
-#include <vector>
-
-namespace rnexecutorch::models::speech_to_text {
-
-/**
- * Represents the result of a speech-to-text processing step.
- *
- * @property committed Words that have been finalized and are not expected to
- * change. In streaming mode specifically, it means words obtained in two
- * consecutive transcriptions.
- * @property nonCommitted Words that are provisional and may change as more
- * input is processed.
- */
-struct ProcessResult {
-  std::vector<Word> committed;
-  std::vector<Word> nonCommitted;
-};
-
-} // namespace rnexecutorch::models::speech_to_text
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/types/Segment.h b/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/types/Segment.h
deleted file mode 100644
index 878589dce2..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/types/Segment.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#pragma once
-
-#include "Token.h"
-#include "Word.h"
-#include <cinttypes>
-#include <vector>
-
-namespace rnexecutorch::models::speech_to_text {
-
-struct Segment {
-  std::vector<Word> words;
-  std::vector<Token> tokens; // Raw token IDs
-  float start;
-  float end;
-  float avgLogprob;
-  float temperature;
-  float compressionRatio;
-};
-
-} // namespace rnexecutorch::models::speech_to_text
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/types/Token.h b/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/types/Token.h
deleted file mode 100644
index 17c4a40914..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/types/Token.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#pragma once
-
-#include <cinttypes>
-
-namespace rnexecutorch::models::speech_to_text {
-
-using Token = uint64_t;
-
-} // namespace rnexecutorch::models::speech_to_text
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/types/TranscriptionResult.h b/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/types/TranscriptionResult.h
deleted file mode 100644
index 994cdb15eb..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/types/TranscriptionResult.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-#include "Segment.h"
-#include <string>
-#include <vector>
-
-namespace rnexecutorch::models::speech_to_text {
-
-struct TranscriptionResult {
-  std::string text;
-  std::string task;
-  std::string language;
-  double duration = 0.0;
-  std::vector<Segment> segments; // Populated only if verbose=true
-};
-
-} // namespace rnexecutorch::models::speech_to_text
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/types/Word.h b/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/types/Word.h
deleted file mode 100644
index fcf7759b24..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/common/types/Word.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#pragma once
-
-#include <string>
-
-namespace rnexecutorch::models::speech_to_text {
-
-/**
- * Different representation of a token,
- * with timestamps calculated.
- */
-struct Word {
-  std::string content;
-  float start;
-  float end;
-};
-
-} // namespace rnexecutorch::models::speech_to_text
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/whisper/ASR.cpp b/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/whisper/ASR.cpp
deleted file mode 100644
index a9f2b152b4..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/whisper/ASR.cpp
+++ /dev/null
@@ -1,479 +0,0 @@
-#include "ASR.h"
-#include "Constants.h"
-#include "Params.h"
-#include <executorch/extension/tensor/tensor_ptr.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/data_processing/Numerical.h>
-#include <rnexecutorch/data_processing/gzip.h>
-
-#include <algorithm>
-#include <array>
-#include <numeric>
-#include <random>
-#include <ranges>
-
-namespace rnexecutorch::models::speech_to_text::whisper {
-
-using executorch::runtime::etensor::ScalarType;
-
-ASR::ASR(const std::string &modelSource, const std::string &tokenizerSource,
-         std::shared_ptr<facebook::react::CallInvoker> callInvoker)
-    : BaseModel(modelSource, std::move(callInvoker)), schema::ASR(),
-      tokenizer_(std::make_unique<TokenizerModule>(tokenizerSource,
-                                                   this->callInvoker)),
-      startOfTranscriptionToken_(
-          tokenizer_->tokenToId(constants::tokens::kStartOfTranscript)),
-      endOfTranscriptionToken_(
-          tokenizer_->tokenToId(constants::tokens::kEndOfTranscript)),
-      timestampBeginToken_(
-          tokenizer_->tokenToId(constants::tokens::kBeginTimestamp)) {}
-
-/**
- * Whisper inference - full transcription
- */
-std::vector<Segment> ASR::transcribe(std::span<const float> waveform,
-                                     const DecodingOptions &options) const {
-  // Use floats to prevent downcasting and timestamp mismatches
-  float seek = 0.f;
-  std::vector<Segment> results;
-
-  const float waveformSize = static_cast<float>(waveform.size());
-  const float waveformSkipBoundary =
-      static_cast<float>((constants::kChunkSize - params::kChunkBreakBuffer) *
-                         constants::kSamplingRate);
-
-  // We loop through the input audio waveform and process it in 30s chunks.
-  // This is determined by Whisper models strict 30s audio length requirement.
-  while (seek * constants::kSamplingRate < waveformSize) {
-    // Calculate chunk bounds and extract the chunk.
-    float start = seek * constants::kSamplingRate;
-    const auto end =
-        std::min<float>(static_cast<float>((seek + constants::kChunkSize) *
-                                           constants::kSamplingRate),
-                        waveformSize);
-    auto chunk = waveform.subspan(start, end - start);
-
-    if (std::cmp_less(chunk.size(), constants::kMinChunkSamples)) {
-      break;
-    }
-
-    // Enter the processing logic.
-    std::vector<Segment> segments = this->generate(chunk, options);
-
-    if (segments.empty()) {
-      seek += constants::kChunkSize;
-      continue;
-    }
-
-    for (auto &seg : segments) {
-      for (auto &w : seg.words) {
-        w.start += seek;
-        w.end += seek;
-      }
-
-      seg.start += seek;
-      seg.end += seek;
-    }
-
-    while (!segments.empty() && segments.back().words.empty()) {
-      segments.pop_back();
-    }
-
-    if (!segments.empty() && !segments.back().words.empty()) {
-      // This prevents additional segments to appear, unless the audio length is
-      // very close to the max chunk size, that is there could be some words
-      // spoken near the breakpoint.
-      seek = waveformSize < waveformSkipBoundary
-                 ? seek + constants::kChunkSize
-                 : segments.back().words.back().end;
-    }
-    results.insert(results.end(), std::make_move_iterator(segments.begin()),
-                   std::make_move_iterator(segments.end()));
-  }
-
-  return results;
-}
-
-/**
- * Whisper inference - encoding phase
- *
- * The input is a standard audio waveform, altough it is implicitly converted
- * to a log mel format inside the encoder call.
- */
-executorch::aten::Tensor ASR::encode(std::span<const float> waveform) const {
-  auto inputShape = {static_cast<int32_t>(waveform.size())};
-
-  const auto modelInputTensor = executorch::extension::make_tensor_ptr(
-      std::move(inputShape), const_cast<float *>(waveform.data()),
-      ScalarType::Float);
-
-  const auto encoderResult = this->execute("encode", {modelInputTensor});
-
-  if (!encoderResult.ok()) {
-    throw RnExecutorchError(encoderResult.error(),
-                            "[Whisper] The 'encode' method did not succeed. "
-                            "Ensure the model input is correct.");
-  }
-
-  return encoderResult.get().at(0).toTensor();
-}
-
-/**
- * Whisper inference - decoding phase
- *
- * An autoregressive decoder, called with increasing amount of input tokens.
- */
-executorch::aten::Tensor ASR::decode(std::span<uint64_t> tokens,
-                                     std::span<const float> encoderOutput,
-                                     uint64_t startPos) const {
-  std::vector<int32_t> tokenShape = {1, static_cast<int32_t>(tokens.size())};
-  std::vector<int32_t> positionShape = {static_cast<int32_t>(tokens.size())};
-
-  auto tokenTensor = executorch::extension::make_tensor_ptr(
-      tokenShape, tokens.data(), ScalarType::Long);
-
-  // Populate cache position vector
-  std::vector<uint64_t> cachePositions(tokens.size());
-  std::iota(cachePositions.begin(), cachePositions.end(), startPos);
-  auto positionTensor = executorch::extension::make_tensor_ptr(
-      positionShape, cachePositions.data(), ScalarType::Long);
-
-  const auto encoderOutputSize = static_cast<int32_t>(encoderOutput.size());
-  std::vector<int32_t> encShape = {
-      1, static_cast<int32_t>(constants::kNumFrames),
-      encoderOutputSize / static_cast<int32_t>(constants::kNumFrames)};
-  auto encoderTensor = executorch::extension::make_tensor_ptr(
-      std::move(encShape), const_cast<float *>(encoderOutput.data()),
-      ScalarType::Float);
-
-  const auto decoderResult =
-      this->execute("decode", {tokenTensor, positionTensor, encoderTensor});
-
-  if (!decoderResult.ok()) {
-    throw RnExecutorchError(decoderResult.error(),
-                            "[Whisper] The 'decode' method did not succeed. "
-                            "Ensure the model inputs are correct.");
-  }
-
-  return decoderResult.get().at(0).toTensor();
-}
-
-void ASR::unload() noexcept { BaseModel::unload(); }
-
-std::size_t ASR::getMemoryLowerBound() const noexcept {
-  return BaseModel::getMemoryLowerBound();
-}
-
-/**
- * Helper functions - creating initial token IDs sequence
- */
-std::vector<uint64_t>
-ASR::createInitialSequence(const DecodingOptions &options) const {
-  std::vector<uint64_t> seq;
-  seq.push_back(startOfTranscriptionToken_);
-
-  if (options.language.has_value()) {
-    uint64_t langToken =
-        tokenizer_->tokenToId("<|" + options.language.value() + "|>");
-    uint64_t taskToken = tokenizer_->tokenToId("<|transcribe|>");
-    seq.push_back(langToken);
-    seq.push_back(taskToken);
-  }
-
-  seq.push_back(timestampBeginToken_);
-
-  return seq;
-}
-
-/**
- * Helper functions - generation wrapper, with fallback
- */
-std::vector<Segment> ASR::generate(std::span<const float> waveform,
-                                   const DecodingOptions &options) const {
-  // A fixed pool of available temperatures
-  constexpr std::array<float, 6> temperatures = {0.0f, 0.2f, 0.4f,
-                                                 0.6f, 0.8f, 1.0f};
-
-  // Calculate audio features just once to save time.
-  executorch::aten::Tensor encoderFeaturesTensor = this->encode(waveform);
-  const float *encoderFeaturesData =
-      encoderFeaturesTensor.const_data_ptr<float>();
-  std::span<const float> encoderFeatures(
-      encoderFeaturesData, encoderFeaturesData + encoderFeaturesTensor.numel());
-
-  std::vector<uint64_t> bestTokens;
-  float bestAvgLogProb = -std::numeric_limits<float>::infinity();
-  float bestCompressionRatio = 0.0f;
-  float bestTemperature = 0.0f;
-
-  for (auto t : temperatures) {
-    auto [tokens, scores] =
-        this->generate(waveform, options, t, {encoderFeatures});
-
-    const float cumLogProb = std::transform_reduce(
-        scores.begin(), scores.end(), 0.0f, std::plus<>(),
-        [](float s) { return std::log(std::max(s, 1e-9f)); });
-
-    // Match whisper.cpp: divide by the number of summed log-probs.
-    const float avgLogProb =
-        cumLogProb / static_cast<float>(std::max<size_t>(1, scores.size()));
-    const std::string text = tokenizer_->decode(tokens, true);
-    const float compressionRatio = this->calculateCompressionRatio(text);
-
-    if (avgLogProb >= -1.0f && compressionRatio < 2.4f) {
-      bestTokens = std::move(tokens);
-      bestAvgLogProb = avgLogProb;
-      bestCompressionRatio = compressionRatio;
-      bestTemperature = t;
-      break;
-    }
-
-    if (t == temperatures.back() && bestTokens.empty()) {
-      bestTokens = std::move(tokens);
-      bestAvgLogProb = avgLogProb;
-      bestCompressionRatio = compressionRatio;
-      bestTemperature = t;
-    }
-  }
-
-  return this->calculateWordLevelTimestamps(bestTokens, waveform,
-                                            bestAvgLogProb, bestTemperature,
-                                            bestCompressionRatio);
-}
-
-/**
- * Helper functions - generation wrapper, single-temperature inference
- */
-GenerationResult
-ASR::generate(std::span<const float> waveform, const DecodingOptions &options,
-              float temperature,
-              std::optional<std::span<const float>> encoderOutput) const {
-  std::span<const float> encoderFeatures;
-  if (encoderOutput.has_value()) {
-    encoderFeatures = encoderOutput.value();
-  } else {
-    executorch::aten::Tensor encoderFeaturesTensor = this->encode(waveform);
-    const float *encoderFeaturesData =
-        encoderFeaturesTensor.const_data_ptr<float>();
-    encoderFeatures =
-        std::span(encoderFeaturesData,
-                  encoderFeaturesData + encoderFeaturesTensor.numel());
-  }
-
-  std::vector<uint64_t> sequenceIds = this->createInitialSequence(options);
-  std::vector<uint64_t> cachedTokens = sequenceIds;
-  const size_t initialSequenceLenght = sequenceIds.size();
-  std::vector<float> scores;
-
-  uint64_t startPos = 0;
-
-  // Prefill: feed each initial token individually so decode() always sees 1
-  // token.
-  executorch::aten::Tensor logitsTensor{nullptr};
-  for (size_t i = 0; i < sequenceIds.size(); i++, startPos++) {
-    std::span<uint64_t> single(sequenceIds.data() + i, 1);
-    logitsTensor = this->decode(single, encoderFeatures, startPos);
-  }
-
-  // Seed once per generate() call rather than per sampled token.
-  std::mt19937 gen(std::random_device{}());
-
-  // Autoregressive decoding: always 1 token at a time
-  while (std::cmp_less(startPos, constants::kMaxDecodeLength)) {
-    const size_t logitsInnerDim = logitsTensor.size(1);
-    const size_t logitsDictSize = logitsTensor.size(2);
-    const float *logitsData = logitsTensor.const_data_ptr<float>() +
-                              (logitsInnerDim - 1) * logitsDictSize;
-    // Needs to be float* without const for compatibility with utility functions
-    std::span<float> logits(const_cast<float *>(logitsData),
-                            const_cast<float *>(logitsData) +
-                                logitsTensor.numel() / logitsInnerDim);
-
-    // intentionally comparing float to float
-    // temperatures are predefined, so this is safe
-    if (temperature == 0.0f) {
-      numerical::softmax(logits);
-    } else {
-      numerical::softmaxWithTemperature(logits, temperature);
-    }
-
-    auto probs = logits;
-
-    uint64_t nextId;
-    float nextProb;
-
-    // intentionally comparing float to float
-    // temperatures are predefined, so this is safe
-    if (temperature == 0.0f) {
-      auto maxIt = std::ranges::max_element(probs);
-      nextId = static_cast<uint64_t>(std::distance(probs.begin(), maxIt));
-      nextProb = *maxIt;
-    } else {
-      std::discrete_distribution<> dist(probs.begin(), probs.end());
-      nextId = dist(gen);
-      nextProb = probs[nextId];
-    }
-
-    cachedTokens.push_back(nextId);
-    scores.push_back(nextProb);
-
-    if (nextId == endOfTranscriptionToken_) {
-      break;
-    }
-
-    std::span<uint64_t> single(&cachedTokens.back(), 1);
-    logitsTensor = this->decode(single, encoderFeatures, startPos);
-    ++startPos;
-  }
-
-  return {.tokens = std::vector<uint64_t>(cachedTokens.cbegin() +
-                                              initialSequenceLenght,
-                                          cachedTokens.cend()),
-          .scores = scores};
-}
-
-std::vector<Segment>
-ASR::calculateWordLevelTimestamps(std::span<const uint64_t> generatedTokens,
-                                  const std::span<const float> waveform,
-                                  float avgLogProb, float temperature,
-                                  float compressionRatio) const {
-  const size_t generatedTokensSize = generatedTokens.size();
-  if (generatedTokensSize < 2 ||
-      generatedTokens[generatedTokensSize - 1] != endOfTranscriptionToken_ ||
-      generatedTokens[generatedTokensSize - 2] < timestampBeginToken_) {
-    return {};
-  }
-  std::vector<Segment> segments;
-  std::vector<uint64_t> tokens;
-  uint64_t prevTimestamp = timestampBeginToken_;
-
-  for (size_t i = 0; i < generatedTokensSize; i++) {
-    if (generatedTokens[i] < timestampBeginToken_) {
-      tokens.push_back(generatedTokens[i]);
-    }
-    if (i > 0 && generatedTokens[i - 1] >= timestampBeginToken_ &&
-        generatedTokens[i] >= timestampBeginToken_) {
-      const uint64_t start = prevTimestamp;
-      const uint64_t end = generatedTokens[i - 1];
-      auto words = this->estimateWordLevelTimestampsLinear(tokens, start, end);
-      if (words.size()) {
-        Segment seg;
-        seg.words = std::move(words);
-        seg.tokens = tokens;
-        seg.avgLogprob = avgLogProb;
-        seg.temperature = temperature;
-        seg.compressionRatio = compressionRatio;
-
-        if (!seg.words.empty()) {
-          seg.start = seg.words.front().start;
-          seg.end = seg.words.back().end;
-        } else {
-          seg.start = 0.0;
-          seg.end = 0.0;
-        }
-
-        segments.push_back(std::move(seg));
-      }
-      tokens.clear();
-      prevTimestamp = generatedTokens[i];
-    }
-  }
-
-  const uint64_t start = prevTimestamp;
-  const uint64_t end = generatedTokens[generatedTokensSize - 2];
-  auto words = this->estimateWordLevelTimestampsLinear(tokens, start, end);
-
-  if (!words.empty()) {
-    Segment seg;
-    seg.words = std::move(words);
-    seg.tokens = tokens;
-    seg.avgLogprob = avgLogProb;
-    seg.temperature = temperature;
-    seg.compressionRatio = compressionRatio;
-
-    seg.start = seg.words.front().start;
-    seg.end = seg.words.back().end;
-
-    segments.push_back(std::move(seg));
-  }
-
-  float scalingFactor =
-      static_cast<float>(waveform.size()) /
-      (constants::kSamplingRate * (end - timestampBeginToken_) *
-       constants::kTimePrecision);
-  if (scalingFactor < 1.0f) {
-    for (auto &seg : segments) {
-      for (auto &w : seg.words) {
-        w.start *= scalingFactor;
-        w.end *= scalingFactor;
-      }
-    }
-  }
-
-  return segments;
-}
-
-std::vector<Word>
-ASR::estimateWordLevelTimestampsLinear(std::span<const uint64_t> tokens,
-                                       uint64_t start, uint64_t end) const {
-  const std::vector<uint64_t> tokensVec(tokens.begin(), tokens.end());
-  const std::string segmentText = tokenizer_->decode(tokensVec, true);
-
-  std::istringstream iss(segmentText);
-  std::vector<std::string> wordsStr;
-  std::string word;
-  while (iss >> word) {
-    // Detect special tokens such as [BLANK_AUDIO] by searching for square
-    // bracket.
-    if (word.find('[') == std::string::npos &&
-        word.find(']') == std::string::npos) {
-      wordsStr.emplace_back(" ");
-      wordsStr.back().append(word);
-    }
-  }
-
-  size_t numChars = 0;
-  for (const auto &w : wordsStr) {
-    numChars += w.size();
-  }
-  const float duration = (end - start) * constants::kTimePrecision;
-  const float timePerChar = duration / std::max<float>(1, numChars);
-  const float startOffset =
-      (start - timestampBeginToken_) * constants::kTimePrecision;
-
-  std::vector<Word> wordObjs;
-  wordObjs.reserve(wordsStr.size());
-  int32_t prevCharCount = 0;
-  for (auto &w : wordsStr) {
-    const auto wSize = static_cast<int32_t>(w.size());
-    const float wStart = startOffset + prevCharCount * timePerChar;
-    const float wEnd = wStart + timePerChar * wSize;
-    prevCharCount += wSize;
-
-    // Detect and extract trailing punctuations.
-    std::string puncts = "";
-    while (!w.empty() && constants::kPunctations.contains(w.back())) {
-      puncts += w.back();
-      w.pop_back();
-    }
-    std::ranges::reverse(puncts);
-
-    // Add the core word.
-    wordObjs.emplace_back(std::move(w), wStart, wEnd);
-
-    // If punctuation was present, add it as a separate "word" with an
-    // instantaneous timestamp at the end of the original word.
-    if (!puncts.empty()) {
-      wordObjs.emplace_back(std::move(puncts), wEnd, wEnd);
-    }
-  }
-
-  return wordObjs;
-}
-
-float ASR::calculateCompressionRatio(const std::string &text) const {
-  size_t compressedSize = gzip::deflateSize(text);
-  return static_cast<float>(text.size()) / static_cast<float>(compressedSize);
-}
-
-} // namespace rnexecutorch::models::speech_to_text::whisper
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/whisper/ASR.h b/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/whisper/ASR.h
deleted file mode 100644
index 475774f2e8..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/whisper/ASR.h
+++ /dev/null
@@ -1,169 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <optional>
-#include <span>
-#include <string>
-#include <vector>
-
-#include "../common/schema/ASR.h"
-#include "../common/types/GenerationResult.h"
-#include "../common/types/Token.h"
-#include <executorch/extension/tensor/tensor.h>
-#include <rnexecutorch/TokenizerModule.h>
-#include <rnexecutorch/models/BaseModel.h>
-
-namespace rnexecutorch::models::speech_to_text::whisper {
-
-using executorch::aten::Tensor;
-
-/**
- * Automatic Speech Recognition (ASR) class for Whisper-based models.
- * This class handles both encoding and decoding steps for Whisper family
- * models, loading a single model with named entry points for "encode" and
- * "decode".
- */
-class ASR : public models::BaseModel, public schema::ASR {
-public:
-  ASR(const std::string &modelSource, const std::string &tokenizerSource,
-      std::shared_ptr<facebook::react::CallInvoker> callInvoker);
-
-  /**
-   * @brief The main Whisper transcription API point.
-   *        Wrapps the entire transciption process into a single method.
-   *
-   * @param waveform Input audio waveform sampled at 16kHz, similarly to
-   * encode's input.
-   * @param options Control variables for decoding process.
-   */
-  std::vector<Segment> virtual transcribe(
-      std::span<const float> waveform,
-      const DecodingOptions &options) const override;
-
-  /**
-   * Encodes the input audio waveform into mel spectrogram embeddings.
-   *
-   * @param waveform  Input audio waveform sampled at 16kHz.
-   * @return          Float tensor containing encoder's output features.
-   *                  The output tensor shape: [1, 1500, 384] for Whisper
-   * models.
-   */
-  executorch::aten::Tensor
-  encode(std::span<const float> waveform) const override;
-
-  /**
-   * Decodes a sequence of tokens into logits given the encoded audio features.
-   *
-   * @param tokens        A span of token IDs from previous iteration
-   *                      (see autoregressive nature of Whisper decoding).
-   * @param encoderOutput A span of floats containing the precomputed encoder
-   * embeddings.
-   * @param startPos      The starting position in the sequence (used for KV
-   * caching).
-   * @return              A tensor representing the output logits for the next
-   * token.
-   */
-  executorch::aten::Tensor decode(std::span<Token> tokens,
-                                  std::span<const float> encoderOutput,
-                                  uint64_t startPos = 0) const override;
-
-  // Standard ExecuTorch model methods for compatibility with the rest of the
-  // API.
-  void unload() noexcept override;
-  std::size_t getMemoryLowerBound() const noexcept override;
-
-private:
-  /**
-   * A helper factory for creating initial token sequences.
-   *
-   * The initial sequence consists of special tokens, such as
-   * language mark token or timestamp token. It's always a part
-   * of decoder's input.
-   *
-   * @param options Determine a specific properties of the initial sequence,
-   * 								such as whether
-   * to add a language mark token or not.
-   */
-  std::vector<uint64_t>
-  createInitialSequence(const DecodingOptions &options) const;
-
-  /**
-   * Generation wrapper - wrapps encoding & decoding with
-   * temperature fallback mechanism.
-   * It could, in theory, run up to 5 inferences for increasing
-   * temperature values.
-   *
-   * @param waveform Input audio waveform sampled at 16kHz, similarly to
-   * encode's input.
-   * @param options Control variables for decoding process.
-   */
-  std::vector<Segment> generate(std::span<const float> waveform,
-                                const DecodingOptions &options) const;
-
-  /**
-   * Generation wrapper - wrapps encoding & decoding for a single,
-   * specific temperature value.
-   * Results in a single inference.
-   * Allows to skip the encoding phase if encoder results are already provided.
-   *
-   * @param waveform Input audio waveform sampled at 16kHz, similarly to
-   * encode's input.
-   * @param options Control variables for decoding process.
-   * @param temperature Controls the scale of randomization during the logits
-   * resolving process.
-   * @param encoderOutput An optional parameter. If provided, the encoding phase
-   * is skipped and the provided value is used instead.
-   */
-  GenerationResult generate(
-      std::span<const float> waveform, const DecodingOptions &options,
-      float temperature,
-      std::optional<std::span<const float>> encoderOutput = std::nullopt) const;
-
-  /**
-   * Calculates word-level timestamps for a sequence of generated tokens.
-   *
-   * This method parses the generated tokens, splits them into segments based on
-   * timestamp tokens, and applies a linear estimation for individual words.
-   * It also adjusts timestamps based on the actual waveform length.
-   *
-   * @param generatedTokens The sequence of tokens produced by the model.
-   * @param waveform        The original audio signal used for scaling.
-   * @param avgLogProb      Average log probability of the generated sequence.
-   * @param temperature     Temperature used during generation.
-   * @param compressionRatio Text compression ratio for the generated sequence.
-   * @return                A vector of transcribed segments with word-level
-   * timing.
-   */
-  std::vector<Segment>
-  calculateWordLevelTimestamps(std::span<const uint64_t> generatedTokens,
-                               const std::span<const float> waveform,
-                               float avgLogProb, float temperature,
-                               float compressionRatio) const;
-
-  /**
-   * Estimates word-level timestamps linearly within a token sequence.
-   *
-   * Decodes the tokens into words and distributes the time interval [start,
-   * end] across words based on their character count.
-   *
-   * @param tokens The slice of tokens representing a single segment.
-   * @param start  The timestamp token ID marking the beginning of the segment.
-   * @param end    The timestamp token ID marking the end of the segment.
-   * @return       A vector of Word objects with estimated start and end times.
-   */
-  std::vector<Word>
-  estimateWordLevelTimestampsLinear(std::span<const uint64_t> tokens,
-                                    uint64_t start, uint64_t end) const;
-
-  float calculateCompressionRatio(const std::string &text) const;
-
-  // Submodules - a tokenizer module for decoding process.
-  std::unique_ptr<TokenizerModule> tokenizer_;
-
-  // Tokenization helper definitions
-  Token startOfTranscriptionToken_;
-  Token endOfTranscriptionToken_;
-  Token timestampBeginToken_;
-};
-
-} // namespace rnexecutorch::models::speech_to_text::whisper
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/whisper/Constants.h b/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/whisper/Constants.h
deleted file mode 100644
index 62a9f968f7..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/whisper/Constants.h
+++ /dev/null
@@ -1,45 +0,0 @@
-#pragma once
-
-#include <cinttypes>
-#include <string>
-#include <unordered_set>
-
-namespace rnexecutorch::models::speech_to_text::whisper::constants {
-
-// Maximum duration of each audio chunk to process (in seconds)
-// It is intentionally set to 29 since otherwise only the last chunk would be
-// correctly transcribe due to the model's positional encoding limit
-inline constexpr size_t kChunkSize = 29;
-
-// Sampling rate expected by Whisper and the model's audio pipeline (16 kHz)
-inline constexpr size_t kSamplingRate = 16000;
-inline constexpr size_t kSamplesPerMilisecond = kSamplingRate / 1000;
-
-inline constexpr size_t kMaxSamples = kChunkSize * kSamplingRate;
-
-// The maximum number of tokens the decoder can generate per chunk
-inline constexpr size_t kMaxDecodeLength = 128;
-
-// Minimum allowed chunk length before processing (in audio samples)
-inline constexpr size_t kMinChunkSamples = 1 * kSamplingRate;
-
-// Number of mel frames output by the encoder (derived from input spectrogram)
-inline constexpr size_t kNumFrames = 1500;
-
-// Time precision used by Whisper timestamps: each token spans 0.02 seconds
-inline constexpr float kTimePrecision = 0.02f;
-
-// Special characters serving as pause / end of sentence
-inline const std::unordered_set<char> kPunctations = {',', '.', '?',
-                                                      '!', ':', ';'};
-inline const std::unordered_set<char> kEosPunctations = {'.', '?', '!', ';'};
-
-// Special token constants
-namespace tokens {
-inline const std::string kStartOfTranscript = "<|startoftranscript|>";
-inline const std::string kEndOfTranscript = "<|endoftext|>";
-inline const std::string kBeginTimestamp = "<|0.00|>";
-inline const std::string kBlankAudio = "[BLANK_AUDIO]";
-} // namespace tokens
-
-} // namespace rnexecutorch::models::speech_to_text::whisper::constants
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/whisper/OnlineASR.cpp b/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/whisper/OnlineASR.cpp
deleted file mode 100644
index 963567d8b5..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/whisper/OnlineASR.cpp
+++ /dev/null
@@ -1,307 +0,0 @@
-#include "OnlineASR.h"
-#include "Constants.h"
-#include "Params.h"
-#include "Utils.h"
-
-#include <algorithm>
-#include <iterator>
-#include <ranges>
-#include <utility>
-
-namespace rnexecutorch::models::speech_to_text::whisper::stream {
-
-OnlineASR::OnlineASR(const ASR *asr, const VoiceActivityDetection *vad)
-    : asr_(asr), vad_(vad) {
-  audioBuffer_.reserve((constants::kChunkSize + 1) * constants::kSamplingRate);
-}
-
-bool OnlineASR::isReady() const {
-  std::scoped_lock lock(streamingMutex);
-
-  return audioBuffer_.size() >= constants::kMinChunkSamples;
-}
-
-void OnlineASR::insertAudioChunk(std::span<const float> audio) {
-  std::scoped_lock lock(streamingMutex);
-
-  audioBuffer_.insert(audioBuffer_.end(), audio.begin(), audio.end());
-
-  // Automatic buffer cleanup.
-  //
-  // This prevents the audio buffer from growing indefinitely during continuous
-  // streaming. It is particularly useful when VAD (Voice Activity Detection)
-  // is used and elements are inserted but not processed for a long time.
-  // It should not pass the condition in a normal streaming, that is when
-  // process() method is called regularly within reasonable steps of time.
-  if (audioBuffer_.size() > constants::kMaxSamples) {
-    // Note that results are not actually committed now, but saved for
-    // a later call of process(). Append rather than assign so that two
-    // back-to-back buffer-cap hits (e.g. while VAD is muted) don't drop the
-    // first batch.
-    auto pending = commitAndClean(memory_.transcript);
-    std::ranges::move(pending, std::back_inserter(memory_.toCommit));
-  }
-}
-
-ProcessResult OnlineASR::process(const StreamingOptions &options) {
-  constexpr size_t kStreamSafeBufferMaxSamples = static_cast<size_t>(
-      params::kStreamSafeBufferDuration * constants::kSamplingRate);
-  constexpr size_t kSafetyMarginSamples = static_cast<size_t>(
-      params::kStreamSafetyThreshold * constants::kSamplingRate);
-
-  std::vector<float> audioCopy;
-
-  // Copy the audio buffer to avoid keeping the lock during the entire
-  // transcription process.
-  {
-    std::scoped_lock lock(streamingMutex);
-    audioCopy = audioBuffer_;
-  }
-
-  std::span<const float> input;
-
-  // Allowing VAD changes logic significantly - we no longer commit and clean
-  // at max samples reached moments, but rather at the end of speech moments.
-  if (options.useVAD && vad_) {
-    auto speechSegments = vad_->generate(audioCopy, options.vadDetectionMargin *
-                                                        params::kVadGapFactor);
-
-    if (speechSegments.empty()) {
-      // Extra cleanup to speed-up future processing by removing silence.
-      if (audioCopy.size() > params::kVadDeadSamplesRemovalSamples) {
-        std::scoped_lock lock(streamingMutex);
-        size_t cut = std::min(params::kVadDeadSamplesRemovalSamples -
-                                  kSafetyMarginSamples,
-                              audioBuffer_.size());
-        audioBuffer_.erase(audioBuffer_.begin(), audioBuffer_.begin() + cut);
-      }
-
-      return {};
-    }
-
-    const auto &lastSegment = speechSegments.back();
-    size_t marginSamples =
-        options.vadDetectionMargin * constants::kSamplesPerMilisecond;
-
-    if (audioCopy.size() - lastSegment.end <= marginSamples) {
-      // Speech is ongoing. Keep last 1s context and trim around current
-      // segment.
-      size_t startWithMargin =
-          std::max(lastSegment.start, constants::kSamplingRate) -
-          constants::kSamplingRate;
-      input = std::span(audioCopy.begin() + startWithMargin,
-                        audioCopy.begin() + lastSegment.end);
-    } else {
-      // Speech ended beyond margin. Commit existing transcript and clear
-      // buffer.
-      std::scoped_lock lock(streamingMutex);
-      std::vector<Word> committed = std::move(memory_.transcript);
-      memory_.transcript.clear();
-      memory_.eos.clear();
-
-      audioBuffer_.erase(audioBuffer_.begin(),
-                         audioBuffer_.begin() +
-                             std::min(lastSegment.end, audioBuffer_.size()));
-      return {.committed = std::move(committed), .nonCommitted = {}};
-    }
-  } else {
-    input = std::span(audioCopy.begin(),
-                      audioCopy.begin() +
-                          std::min(constants::kMaxSamples, audioCopy.size()));
-  }
-
-  std::vector<Segment> transcriptions = asr_->transcribe(input, options);
-
-  // Flatten segments into a single word sequence.
-  // This is our 'nonCommitted' part for now.
-  std::vector<Word> words;
-  for (auto &segment : transcriptions) {
-    std::ranges::move(segment.words, std::back_inserter(words));
-  }
-
-  // Aquire lock for the rest of the method (extensive usage of audioBuffer_).
-  std::scoped_lock lock(streamingMutex);
-
-  // Step 1: examine all previously saved EOS points.
-  // The idea is to remove entries which have changed or no longer exist
-  // due to model correcting it's output.
-  for (auto it = memory_.eos.begin(); it != memory_.eos.end(); it++) {
-    if (it->position >= words.size() || !utils::isEos(words[it->position]) ||
-        (it->position > 0 &&
-         it->preceeding != words[it->position - 1].content)) {
-      memory_.eos.erase(it, memory_.eos.end());
-      break;
-    }
-  }
-
-  // Step 2: check if the newest EOS character from transcript should be
-  // saved to eos_ vector.
-  auto lastEosIt = std::find_if(words.rbegin(), words.rend(), utils::isEos);
-  if (lastEosIt != words.rend()) {
-    size_t lastEosIndex = std::distance(words.begin(), lastEosIt.base()) - 1;
-
-    // Because of step 1, we know that if the last EOS exist in eos_,
-    // then it must be the last entry.
-    if (memory_.eos.empty() || memory_.eos.back().position != lastEosIndex) {
-      std::string preceeding =
-          lastEosIndex > 0 ? words[lastEosIndex - 1].content : "";
-      memory_.eos.emplace_back(lastEosIndex, preceeding, lastEosIt->end);
-    }
-  }
-
-  std::vector<Word> committed;
-
-  // Step 3: collect all the words which could possible get committed
-  // in-between iterations.
-  if (!memory_.toCommit.empty()) {
-    committed.insert(committed.end(),
-                     std::make_move_iterator(memory_.toCommit.begin()),
-                     std::make_move_iterator(memory_.toCommit.end()));
-    memory_.toCommit.clear();
-  }
-
-  // Step 4: clear the buffer if it is getting too large.
-  // The idea is to use the saved EOS entries and try to cut the buffer
-  // in a 'good' spot - where it will remove a significant audio chunk, yet
-  // won't affect most recent, unfinished speech samples.
-  size_t bufferSize = audioBuffer_.size();
-  if (bufferSize > kStreamSafeBufferMaxSamples) {
-    auto newCommitted = commitAndClean(words);
-
-    committed.insert(committed.end(),
-                     std::make_move_iterator(newCommitted.begin()),
-                     std::make_move_iterator(newCommitted.end()));
-  }
-
-  // Save the uncommitted part to streamer's memory,
-  // cause it might be necessary when committing inside streamInsert().
-  memory_.transcript = words;
-
-  // Note that uncommitted part represented by recent transcription (words)
-  // is already shrinked if something has been committed during the cleanup
-  // phase.
-  return {.committed = std::move(committed), .nonCommitted = std::move(words)};
-}
-
-std::vector<Word> OnlineASR::finish(const StreamingOptions &options) {
-  ProcessResult result = process(options);
-
-  // Last-tick committed delta + whatever never made it past the commit
-  // threshold.
-  std::vector<Word> residual{std::move(result.committed)};
-  residual.insert(residual.end(),
-                  std::make_move_iterator(result.nonCommitted.begin()),
-                  std::make_move_iterator(result.nonCommitted.end()));
-
-  reset();
-
-  return residual;
-}
-
-void OnlineASR::reset() {
-  std::scoped_lock lock(streamingMutex);
-
-  audioBuffer_.clear();
-
-  // Reset memory.
-  memory_.transcript.clear();
-  memory_.eos.clear();
-  memory_.toCommit.clear();
-}
-
-std::vector<Word> OnlineASR::commitAndClean(std::vector<Word> &transcript) {
-  constexpr float kMidpointAnchorTime = params::kStreamMaxDuration / 2.0F;
-  constexpr size_t kMidpointAnchorSamples =
-      static_cast<size_t>(kMidpointAnchorTime * constants::kSamplingRate);
-  constexpr size_t kSafetyMarginSamples = static_cast<size_t>(
-      params::kStreamSafetyThreshold * constants::kSamplingRate);
-  constexpr float kMaxSafeEosTime =
-      params::kStreamSafeBufferDuration - params::kStreamSafetyThreshold;
-  constexpr float kMinDurationToCalculateDensity = 0.1F;
-
-  const size_t bufferSize = audioBuffer_.size();
-
-  std::vector<Word> committed;
-
-  // If we don't have any EOS entries, then we most likely have not
-  // recorded any speech. In this case we can safely cut the maximum amount of
-  // audio data.
-  if (memory_.eos.empty()) {
-    size_t cut = bufferSize - kSafetyMarginSamples;
-
-    audioBuffer_.erase(audioBuffer_.begin(), audioBuffer_.begin() + cut);
-  }
-
-  // If we have exactly one (most recent) EOS entry in the eos_, then
-  // we need to be more careful.
-  // Normally we want to keep at least one sentence in, but if the sentence
-  // covers a significant amount of buffer, we have no choice.
-  else if (memory_.eos.size() == 1) {
-    const float eosTimestamp = memory_.eos[0].tmstpend;
-
-    const float upperHalfDuration =
-        std::max(0.0F, eosTimestamp - kMidpointAnchorTime);
-    const float wordsPerSecond =
-        upperHalfDuration > kMinDurationToCalculateDensity
-            ? static_cast<float>(transcript.size()) / upperHalfDuration
-            : 0.0F;
-
-    // The EOS sits early enough that cutting up to the safety margin won't
-    // touch the ongoing (post-EOS) speech.
-    const bool eosSafe = eosTimestamp < kMaxSafeEosTime;
-
-    if (!eosSafe && wordsPerSecond < params::kWordsPerSecondLow) {
-      // EOS lies past the midpoint, but a low word density implies the spoken
-      // audio is concentrated in the upper half. Drop the lower half and
-      // shift the EOS accordingly.
-      audioBuffer_.erase(audioBuffer_.begin(),
-                         audioBuffer_.begin() + kMidpointAnchorSamples);
-      memory_.eos[0].tmstpend -= kMidpointAnchorTime;
-    } else {
-      // Cut everything up to and including the sentence — either by the
-      // safety margin (when EOS is early) or (more aggresively) right at the
-      // EOS boundary — and commit its words.
-      const size_t cut =
-          eosSafe
-              ? bufferSize - kSafetyMarginSamples
-              : static_cast<size_t>(eosTimestamp * constants::kSamplingRate);
-
-      audioBuffer_.erase(audioBuffer_.begin(), audioBuffer_.begin() + cut);
-
-      committed.insert(committed.end(),
-                       std::make_move_iterator(transcript.begin()),
-                       std::make_move_iterator(transcript.end()));
-
-      transcript.clear();
-      memory_.eos.clear();
-    }
-  }
-
-  // In case of 2 or more sentences, we generally want to keep the last one
-  // intact. This would provide a bit of stability to the algorithm.
-  else {
-    const auto &secondTolastEntry = memory_.eos[memory_.eos.size() - 2];
-
-    const size_t cut = static_cast<size_t>(secondTolastEntry.tmstpend *
-                                           constants::kSamplingRate);
-    const size_t lastCommittedPos = secondTolastEntry.position;
-
-    audioBuffer_.erase(audioBuffer_.begin(), audioBuffer_.begin() + cut);
-
-    committed.insert(
-        committed.end(), std::make_move_iterator(transcript.begin()),
-        std::make_move_iterator(transcript.begin() + lastCommittedPos + 1));
-    transcript.erase(transcript.begin(),
-                     transcript.begin() + lastCommittedPos + 1);
-
-    // Retain only the most recent EOS entry, shifting both its timestamp
-    // and its position to match the new (truncated) transcript origin.
-    memory_.eos.erase(memory_.eos.begin(), memory_.eos.end() - 1);
-    memory_.eos[0].tmstpend -= secondTolastEntry.tmstpend;
-    memory_.eos[0].position -= lastCommittedPos + 1;
-  }
-
-  return committed;
-}
-
-} // namespace rnexecutorch::models::speech_to_text::whisper::stream
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/whisper/OnlineASR.h b/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/whisper/OnlineASR.h
deleted file mode 100644
index f13fa9ccff..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/whisper/OnlineASR.h
+++ /dev/null
@@ -1,92 +0,0 @@
-#pragma once
-
-#include <mutex>
-#include <optional>
-#include <span>
-#include <vector>
-
-#include "../common/schema/OnlineASR.h"
-#include "../common/types/ProcessResult.h"
-#include "../common/types/Word.h"
-#include "ASR.h"
-#include <rnexecutorch/models/voice_activity_detection/VoiceActivityDetection.h>
-
-namespace rnexecutorch::models::speech_to_text::whisper::stream {
-
-using voice_activity_detection::VoiceActivityDetection;
-
-/**
- * Online Automatic Speech Recognition (OnlineASR) for Whisper.
- * It manages continuous processing of audio stream by maintaining a local
- * audio buffer and using ASR to transcribe it in increments.
- */
-class OnlineASR : public schema::OnlineASR {
-public:
-  OnlineASR(const ASR *asr, const VoiceActivityDetection *vad);
-
-  /**
-   * Checks if the buffer contains enough audio for the next processing step.
-   * @return True if ready, false otherwise.
-   */
-  bool isReady() const override;
-
-  /**
-   * Appends audio samples to the internal buffer.
-   * @param audio Span containing the audio data.
-   */
-  void insertAudioChunk(std::span<const float> audio) override;
-
-  /**
-   * Processes the current buffered audio and returns transcription results.
-   * @param options Decoding options for the transcription.
-   * @return Transcription result containing committed and volatile tokens.
-   */
-  ProcessResult process(const StreamingOptions &options) override;
-
-  /**
-   * Finalizes the current stream and returns all words.
-   * @return Vector of detected words.
-   */
-  std::vector<Word> finish(const StreamingOptions &options) override;
-
-  /**
-   * Resets the internal state and clears buffers.
-   */
-  void reset() override;
-
-private:
-  // Cleans up the buffer and returns committed words based on given transcript.
-  std::vector<Word> commitAndClean(std::vector<Word> &transcript);
-
-  // ASR module connection for transcribing the audio
-  const ASR *asr_;
-
-  // VAD module connection for selecting processing (optional)
-  const VoiceActivityDetection *vad_;
-
-  // Audio buffer (input) - accumulates obtained audio samples.
-  std::vector<float> audioBuffer_ = {};
-  mutable std::mutex streamingMutex; // Covers both buffer & memory
-
-  // Streaming memory.
-  // In general, helps to navigate continous streaming state and improve buffer
-  // handling algorithms.
-  struct Memory {
-    // State management helper.
-    struct EOSEntry {
-      size_t position; // An absolute position (index) in the transcription
-                       // (word sequence).
-      std::string preceeding; // A preceeding word in the transcription
-      float tmstpend;         // Ending timestamp of the sentence.
-    };
-
-    std::vector<Word>
-        transcript; // The most recent transcription result (uncommitted only!).
-    std::vector<EOSEntry>
-        eos; // End of sentence points from the most recent transcription.
-    std::vector<Word> toCommit; // Words to be committed in the next iteration
-                                // (next process() call).
-  } memory_;
-};
-
-} // namespace rnexecutorch::models::speech_to_text::whisper::stream
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/whisper/Params.h b/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/whisper/Params.h
deleted file mode 100644
index f6c6e491b0..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/whisper/Params.h
+++ /dev/null
@@ -1,82 +0,0 @@
-#pragma once
-
-#include "Constants.h"
-
-#include <cinttypes>
-#include <cstdlib>
-
-/**
- * Hyperparameters
- *
- * Those are adjustable values, which when changed, affect the behavior
- * of the underlying model and/or algorithms.
- */
-namespace rnexecutorch::models::speech_to_text::whisper::params {
-
-/**
- * Maximum duration of audio that the streaming buffer keeps before forcing
- * a cleanup. Aligned with Whisper's maximum supported input length.
- */
-constexpr inline float kStreamMaxDuration =
-    static_cast<float>(constants::kChunkSize);
-
-/**
- * The minimum amount of recent audio always kept in the buffer when a blind
- * cut is performed. Acts as the lower bound on what survives a cleanup.
- */
-constexpr inline float kStreamSafetyThreshold = 3.F; // [s]
-
-/**
- * Forced-cleanup threshold. Once the buffer grows past this duration we run
- * the EOS-anchored cleanup routine.
- */
-constexpr inline float kStreamSafeBufferDuration =
-    kStreamMaxDuration - kStreamSafetyThreshold; // [s]
-/**
- * An estimate of the number of words spoken per second.
- * Used for estimating transcription progress and buffer management heuristics.
- */
-constexpr inline float kWordsPerSecondEstimation = 2.25F;
-
-/**
- * Upper bound for words per second estimate in fast speech.
- */
-constexpr inline float kWordsPerSecondHigh = 4.F;
-
-/**
- * Lower bound for words per second estimate in slow speech.
- */
-constexpr inline float kWordsPerSecondLow = 1.5F;
-
-/**
- * Determines the range of buffer left when skipping an audio chunk
- * of size lower than maximum allowed chunk size.
- *
- * If the audio length does not exceed [kChunkSize * kSamplingRate] - [buffer],
- * then instead of moving to the last returned timestamp, we jump across the
- * entire 30 seconds chunk. This resolves the issue of multiple redundant
- * segments being produced by the transcription algorithm.
- */
-constexpr inline int32_t kChunkBreakBuffer = 2; // [s]
-
-/**
- * Multiplier applied to `vadDetectionMargin` when computing the merge gap
- * passed to `VoiceActivityDetection::generate`. The merge window is widened
- * slightly so brief intra-utterance silences (just over the detection margin)
- * still fold into a single speech segment.
- */
-constexpr inline float kVadGapFactor = 1.2F;
-
-constexpr inline size_t kVadDeadSamplesRemovalSamples =
-    9 * constants::kSamplingRate; // 9s of audio samples
-
-// `OnlineASR::process` computes the silence-trim cut as
-// `kVadDeadSamplesRemovalSamples - kSafetyMarginSamples` over `size_t`. If the
-// two ever invert, that subtraction wraps and the subsequent erase reads past
-// the buffer. Catch the regression at compile time.
-static_assert(kVadDeadSamplesRemovalSamples >
-                  static_cast<size_t>(kStreamSafetyThreshold *
-                                      constants::kSamplingRate),
-              "kVadDeadSamplesRemovalSamples must exceed the safety margin");
-
-} // namespace rnexecutorch::models::speech_to_text::whisper::params
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/whisper/Utils.h b/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/whisper/Utils.h
deleted file mode 100644
index ae461c27cf..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/whisper/Utils.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#pragma once
-
-#include "../common/types/Word.h"
-#include "Constants.h"
-#include <algorithm>
-#include <cmath>
-#include <span>
-#include <string>
-
-namespace rnexecutorch::models::speech_to_text::whisper::utils {
-
-/**
- * Checks if the given word represents an End-of-Sentence (EOS) punctuation.
- *
- * @param word The word to check.
- */
-inline bool isEos(const Word &word) {
-  return word.content.size() == 1 &&
-         constants::kEosPunctations.contains(word.content[0]);
-}
-
-} // namespace rnexecutorch::models::speech_to_text::whisper::utils
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/style_transfer/StyleTransfer.cpp b/packages/react-native-executorch/common/rnexecutorch/models/style_transfer/StyleTransfer.cpp
deleted file mode 100644
index 184d2db10d..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/style_transfer/StyleTransfer.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-#include "StyleTransfer.h"
-
-#include <rnexecutorch/data_processing/ImageProcessing.h>
-#include <rnexecutorch/utils/FrameProcessor.h>
-#include <rnexecutorch/utils/FrameTransform.h>
-
-#include <executorch/extension/tensor/tensor.h>
-#include <opencv2/opencv.hpp>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-
-namespace rnexecutorch::models::style_transfer {
-using namespace facebook;
-using executorch::extension::TensorPtr;
-
-StyleTransfer::StyleTransfer(const std::string &modelSource,
-                             std::shared_ptr<react::CallInvoker> callInvoker)
-    : VisionModel(modelSource, callInvoker) {
-  auto inputShapes = getAllInputShapes();
-  if (inputShapes.size() == 0) {
-    throw RnExecutorchError(RnExecutorchErrorCode::UnexpectedNumInputs,
-                            "Model seems to not take any input tensors");
-  }
-  modelInputShape_ = inputShapes[0];
-  if (modelInputShape_.size() < 2) {
-    char errorMessage[100];
-    std::snprintf(errorMessage, sizeof(errorMessage),
-                  "Unexpected model input size, expected at least 2 dimensions "
-                  "but got: %zu.",
-                  modelInputShape_.size());
-    throw RnExecutorchError(RnExecutorchErrorCode::UnexpectedNumInputs,
-                            errorMessage);
-  }
-}
-
-cv::Mat StyleTransfer::runInference(cv::Mat image, cv::Size outputSize) {
-  std::scoped_lock lock(inference_mutex_);
-
-  cv::Mat preprocessed = preprocess(image);
-
-  auto inputTensor =
-      image_processing::getTensorFromMatrix(modelInputShape_, preprocessed);
-
-  auto forwardResult = BaseModel::forward(inputTensor);
-  CHECK_OK_OR_THROW_FORWARD_ERROR(forwardResult);
-
-  cv::Mat mat = image_processing::getMatrixFromTensor(
-      modelInputSize(), forwardResult->at(0).toTensor());
-  if (mat.size() != outputSize) {
-    cv::resize(mat, mat, outputSize);
-  }
-  return mat;
-}
-
-PixelDataResult toPixelDataResult(const cv::Mat &bgrMat) {
-  cv::Size size = bgrMat.size();
-  // Convert BGR -> RGBA so JS can pass the buffer directly to Skia
-  cv::Mat rgba;
-  cv::cvtColor(bgrMat, rgba, cv::COLOR_BGR2RGBA);
-  std::size_t dataSize = static_cast<std::size_t>(size.width) * size.height * 4;
-  auto pixelBuffer = std::make_shared<OwningArrayBuffer>(rgba.data, dataSize);
-  return PixelDataResult{pixelBuffer, size.width, size.height, rgba.channels()};
-}
-
-StyleTransferResult StyleTransfer::generateFromString(std::string imageSource,
-                                                      bool saveToFile) {
-  cv::Mat imageBGR = image_processing::readImage(imageSource);
-  cv::Size originalSize = imageBGR.size();
-
-  cv::Mat imageRGB;
-  cv::cvtColor(imageBGR, imageRGB, cv::COLOR_BGR2RGB);
-
-  cv::Mat result = runInference(imageRGB, originalSize);
-  if (saveToFile) {
-    return image_processing::saveToTempFile(result);
-  }
-  return toPixelDataResult(result);
-}
-
-PixelDataResult StyleTransfer::generateFromFrame(jsi::Runtime &runtime,
-                                                 const jsi::Value &frameData) {
-  auto orient = ::rnexecutorch::utils::readFrameOrientation(runtime, frameData);
-  cv::Mat frame = extractFromFrame(runtime, frameData);
-  cv::Mat rotated = utils::rotateFrameForModel(frame, orient);
-  cv::Mat output = runInference(rotated, modelInputSize());
-  cv::Mat oriented = utils::inverseRotateMat(output, orient);
-  return toPixelDataResult(oriented);
-}
-
-StyleTransferResult StyleTransfer::generateFromPixels(JSTensorViewIn pixelData,
-                                                      bool saveToFile) {
-  cv::Mat image = extractFromPixels(pixelData);
-
-  cv::Mat result = runInference(image, image.size());
-  if (saveToFile) {
-    return image_processing::saveToTempFile(result);
-  }
-  return toPixelDataResult(result);
-}
-
-} // namespace rnexecutorch::models::style_transfer
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/style_transfer/StyleTransfer.h b/packages/react-native-executorch/common/rnexecutorch/models/style_transfer/StyleTransfer.h
deleted file mode 100644
index c15095bf5b..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/style_transfer/StyleTransfer.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-
-#include <string>
-#include <utility>
-
-#include <executorch/extension/module/module.h>
-#include <executorch/extension/tensor/tensor_ptr.h>
-#include <jsi/jsi.h>
-#include <opencv2/opencv.hpp>
-
-#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
-#include <rnexecutorch/jsi/OwningArrayBuffer.h>
-#include <rnexecutorch/models/VisionModel.h>
-#include <rnexecutorch/models/style_transfer/Types.h>
-
-namespace rnexecutorch {
-namespace models::style_transfer {
-using namespace facebook;
-
-class StyleTransfer : public VisionModel {
-public:
-  StyleTransfer(const std::string &modelSource,
-                std::shared_ptr<react::CallInvoker> callInvoker);
-
-  [[nodiscard("Registered non-void function")]] StyleTransferResult
-  generateFromString(std::string imageSource, bool saveToFile);
-
-  [[nodiscard("Registered non-void function")]] PixelDataResult
-  generateFromFrame(jsi::Runtime &runtime, const jsi::Value &frameData);
-
-  [[nodiscard("Registered non-void function")]] StyleTransferResult
-  generateFromPixels(JSTensorViewIn pixelData, bool saveToFile);
-
-private:
-  cv::Mat runInference(cv::Mat image, cv::Size outputSize);
-};
-} // namespace models::style_transfer
-
-REGISTER_CONSTRUCTOR(models::style_transfer::StyleTransfer, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/style_transfer/Types.h b/packages/react-native-executorch/common/rnexecutorch/models/style_transfer/Types.h
deleted file mode 100644
index 27df4ec6c6..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/style_transfer/Types.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <rnexecutorch/jsi/OwningArrayBuffer.h>
-#include <string>
-#include <variant>
-
-namespace rnexecutorch::models::style_transfer {
-
-struct PixelDataResult {
-  std::shared_ptr<OwningArrayBuffer> dataPtr;
-  int width;
-  int height;
-  int channels;
-};
-
-using StyleTransferResult = std::variant<PixelDataResult, std::string>;
-
-} // namespace rnexecutorch::models::style_transfer
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/Constants.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/Constants.h
deleted file mode 100644
index c6af48e82e..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/Constants.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#pragma once
-
-#include <string_view>
-
-namespace rnexecutorch::models::text_to_image::constants {
-
-inline constexpr std::string_view kBosToken = "<|startoftext|>";
-
-} // namespace rnexecutorch::models::text_to_image::constants
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/Decoder.cpp b/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/Decoder.cpp
deleted file mode 100644
index e3e37521ee..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/Decoder.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "Decoder.h"
-
-#include <cmath>
-
-#include <executorch/extension/tensor/tensor_ptr_maker.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-
-namespace rnexecutorch::models::text_to_image {
-
-using namespace executorch::extension;
-
-Decoder::Decoder(const std::string &modelSource,
-                 std::shared_ptr<react::CallInvoker> callInvoker)
-    : BaseModel(modelSource, callInvoker) {}
-
-std::vector<float> Decoder::generate(std::vector<float> &input) const {
-  std::vector<int32_t> inputShape = {1, numChannels, latentImageSize,
-                                     latentImageSize};
-  auto inputTensor =
-      make_tensor_ptr(inputShape, input.data(), ScalarType::Float);
-
-  auto forwardResult = BaseModel::forward(inputTensor);
-  if (!forwardResult.ok()) {
-    throw RnExecutorchError(
-        forwardResult.error(),
-        "Function forward in decoder failed with error code: ");
-  }
-
-  auto forwardResultTensor = forwardResult->at(0).toTensor();
-  const auto *dataPtr = forwardResultTensor.const_data_ptr<float>();
-  return {dataPtr, dataPtr + forwardResultTensor.numel()};
-}
-} // namespace rnexecutorch::models::text_to_image
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/Decoder.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/Decoder.h
deleted file mode 100644
index c0b35c102a..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/Decoder.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include <ReactCommon/CallInvoker.h>
-
-#include <rnexecutorch/models/BaseModel.h>
-
-namespace rnexecutorch::models::text_to_image {
-
-class Decoder final : public BaseModel {
-public:
-  explicit Decoder(const std::string &modelSource,
-                   std::shared_ptr<react::CallInvoker> callInvoker);
-  std::vector<float> generate(std::vector<float> &input) const;
-
-  int32_t latentImageSize;
-
-private:
-  static constexpr int32_t numChannels = 4;
-};
-} // namespace rnexecutorch::models::text_to_image
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/Encoder.cpp b/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/Encoder.cpp
deleted file mode 100644
index 68a9a9fef4..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/Encoder.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#include "Encoder.h"
-
-#include <cmath>
-#include <random>
-#include <span>
-
-#include <rnexecutorch/models/text_to_image/Constants.h>
-
-namespace rnexecutorch::models::text_to_image {
-
-Encoder::Encoder(const std::string &tokenizerSource,
-                 const std::string &encoderSource,
-                 std::shared_ptr<react::CallInvoker> callInvoker)
-    : callInvoker(callInvoker),
-      encoder(std::make_unique<embeddings::TextEmbeddings>(
-          encoderSource, tokenizerSource, callInvoker)) {}
-
-std::vector<float> Encoder::generate(std::string input) {
-  std::shared_ptr<OwningArrayBuffer> embeddingsText = encoder->generate(input);
-  std::shared_ptr<OwningArrayBuffer> embeddingsUncond =
-      encoder->generate(std::string(constants::kBosToken));
-
-  assert(embeddingsText->size() == embeddingsUncond->size());
-  size_t embeddingsSize = embeddingsText->size() / sizeof(float);
-  auto *embeddingsTextPtr = reinterpret_cast<float *>(embeddingsText->data());
-  auto *embeddingsUncondPtr =
-      reinterpret_cast<float *>(embeddingsUncond->data());
-
-  std::vector<float> embeddingsConcat;
-  embeddingsConcat.reserve(embeddingsSize * 2);
-  embeddingsConcat.insert(embeddingsConcat.end(), embeddingsUncondPtr,
-                          embeddingsUncondPtr + embeddingsSize);
-  embeddingsConcat.insert(embeddingsConcat.end(), embeddingsTextPtr,
-                          embeddingsTextPtr + embeddingsSize);
-  return embeddingsConcat;
-}
-
-size_t Encoder::getMemoryLowerBound() const noexcept {
-  return encoder->getMemoryLowerBound();
-}
-
-void Encoder::unload() noexcept { encoder->unload(); }
-
-} // namespace rnexecutorch::models::text_to_image
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/Encoder.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/Encoder.h
deleted file mode 100644
index b444f30ab9..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/Encoder.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include <ReactCommon/CallInvoker.h>
-#include <jsi/jsi.h>
-
-#include <rnexecutorch/jsi/OwningArrayBuffer.h>
-
-#include <rnexecutorch/models/embeddings/text/TextEmbeddings.h>
-
-namespace rnexecutorch {
-namespace models::text_to_image {
-using namespace facebook;
-
-class Encoder final {
-public:
-  explicit Encoder(const std::string &tokenizerSource,
-                   const std::string &encoderSource,
-                   std::shared_ptr<react::CallInvoker> callInvoker);
-  std::vector<float> generate(std::string input);
-  size_t getMemoryLowerBound() const noexcept;
-  void unload() noexcept;
-
-private:
-  std::shared_ptr<react::CallInvoker> callInvoker;
-  std::unique_ptr<embeddings::TextEmbeddings> encoder;
-};
-} // namespace models::text_to_image
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/Scheduler.cpp b/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/Scheduler.cpp
deleted file mode 100644
index 61640f7f64..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/Scheduler.cpp
+++ /dev/null
@@ -1,155 +0,0 @@
-// The implementation of the PNDMScheduler class from the diffusers library
-// https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_pndm.py
-
-#include "Scheduler.h"
-
-#include <algorithm>
-#include <cmath>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-
-namespace rnexecutorch::models::text_to_image {
-using namespace facebook;
-
-Scheduler::Scheduler(float betaStart, float betaEnd, int32_t numTrainTimesteps,
-                     int32_t stepsOffset,
-                     std::shared_ptr<react::CallInvoker> callInvoker)
-    : numTrainTimesteps(numTrainTimesteps), stepsOffset(stepsOffset) {
-  const float start = std::sqrt(betaStart);
-  const float end = std::sqrt(betaEnd);
-  const float step = (end - start) / (numTrainTimesteps - 1);
-
-  float runningProduct = 1.0f;
-  alphas.reserve(numTrainTimesteps);
-  // alphasCumprod[t] — fraction of the signal remaining after t steps
-  alphasCumprod.reserve(numTrainTimesteps);
-  // betas[t] — amount of noise injected at timestep t
-  betas.reserve(numTrainTimesteps);
-  for (int32_t i = 0; i < numTrainTimesteps; ++i) {
-    const float value = start + step * i;
-    const float beta = value * value;
-    betas.push_back(beta);
-
-    const float alpha = 1.0f - beta;
-    alphas.push_back(alpha);
-
-    runningProduct *= alpha;
-    alphasCumprod.push_back(runningProduct);
-  }
-
-  // finalAlphaCumprod — signal at the first training step (highest
-  // signal-to-noise ratio) used as reference at the end of diffusion process
-  if (!alphasCumprod.empty()) {
-    finalAlphaCumprod = alphasCumprod[0];
-  }
-}
-
-void Scheduler::setTimesteps(size_t numInferenceSteps) {
-  this->numInferenceSteps = numInferenceSteps;
-  ets.clear();
-
-  if (numInferenceSteps < 2) {
-    timesteps = {1};
-    return;
-  }
-
-  timesteps.clear();
-  timesteps.reserve(numInferenceSteps + 1);
-
-  float numStepsRatio =
-      static_cast<float>(numTrainTimesteps) / numInferenceSteps;
-  for (size_t i = 0; i < numInferenceSteps; i++) {
-    const auto timestep =
-        static_cast<int32_t>(std::round(i * numStepsRatio)) + stepsOffset;
-    timesteps.push_back(timestep);
-  }
-  // Duplicate the timestep to provide enough points for the solver
-  timesteps.insert(timesteps.end() - 1, timesteps[numInferenceSteps - 2]);
-  std::ranges::reverse(timesteps);
-}
-
-std::vector<float> Scheduler::step(const std::vector<float> &sample,
-                                   const std::vector<float> &noise,
-                                   int32_t timestep) {
-  if (numInferenceSteps == 0) {
-    throw RnExecutorchError(
-        RnExecutorchErrorCode::InvalidConfig,
-        "Number of inference steps is not set. Call `set_timesteps` first.");
-  }
-
-  size_t noiseSize = noise.size();
-  std::vector<float> etsOutput(noiseSize);
-  float numStepsRatio =
-      static_cast<float>(numTrainTimesteps) / numInferenceSteps;
-  float timestepPrev = timestep - numStepsRatio;
-
-  if (ets.empty()) {
-    ets.push_back(noise);
-    etsOutput = noise;
-    tempFirstSample = sample;
-    return getPrevSample(sample, etsOutput, timestep, timestepPrev);
-  }
-
-  // Use the previous sample as the estimate requires at least 2 points
-  if (ets.size() == 1 && !tempFirstSample.empty()) {
-    for (size_t i = 0; i < noiseSize; i++) {
-      etsOutput[i] = (noise[i] + ets[0][i]) / 2;
-    }
-    auto prevSample = getPrevSample(std::move(tempFirstSample), etsOutput,
-                                    timestep + numStepsRatio, timestep);
-    tempFirstSample.clear();
-    return prevSample;
-  }
-
-  // Coefficients come from the linear multistep method
-  // https://en.wikipedia.org/wiki/Linear_multistep_method
-  ets.push_back(noise);
-
-  if (ets.size() == 2) {
-    for (size_t i = 0; i < noiseSize; i++) {
-      etsOutput[i] = (ets[1][i] * 3 - ets[0][i]) / 2;
-    }
-  } else if (ets.size() == 3) {
-    for (size_t i = 0; i < noiseSize; i++) {
-      etsOutput[i] = ((ets[2][i] * 23 - ets[1][i] * 16) + ets[0][i] * 5) / 12;
-    }
-  } else {
-    ets.assign(ets.end() - 4, ets.end());
-    for (size_t i = 0; i < noiseSize; i++) {
-      etsOutput[i] =
-          (ets[3][i] * 55 - ets[2][i] * 59 + ets[1][i] * 37 - ets[0][i] * 9) /
-          24;
-    }
-  }
-  return getPrevSample(sample, etsOutput, timestep, timestepPrev);
-}
-
-std::vector<float> Scheduler::getPrevSample(const std::vector<float> &sample,
-                                            const std::vector<float> &noise,
-                                            int32_t timestep,
-                                            int32_t timestepPrev) const {
-  const float alpha = alphasCumprod[timestep];
-  const float alphaPrev =
-      timestepPrev >= 0 ? alphasCumprod[timestepPrev] : finalAlphaCumprod;
-  const float beta = 1 - alpha;
-  const float betaPrev = 1 - alphaPrev;
-
-  size_t noiseSize = noise.size();
-  const float noiseCoeff =
-      (alphaPrev - alpha) /
-      (alpha * std::sqrt(betaPrev) + std::sqrt(alpha * beta * alphaPrev));
-  const float sampleCoeff = std::sqrt(alphaPrev / alpha);
-
-  std::vector<float> samplePrev;
-  samplePrev.reserve(noiseSize);
-  for (size_t i = 0; i < noiseSize; i++) {
-    const float noiseTerm =
-        (noise[i] * std::sqrt(alpha) + sample[i] * std::sqrt(beta)) *
-        noiseCoeff;
-    samplePrev.push_back(sample[i] * sampleCoeff - noiseTerm);
-  }
-
-  return samplePrev;
-}
-
-} // namespace rnexecutorch::models::text_to_image
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/Scheduler.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/Scheduler.h
deleted file mode 100644
index 66fe422c3b..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/Scheduler.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <vector>
-
-#include <ReactCommon/CallInvoker.h>
-
-namespace rnexecutorch::models::text_to_image {
-
-using namespace facebook;
-
-class Scheduler final {
-public:
-  explicit Scheduler(float betaStart, float betaEnd, int32_t numTrainTimesteps,
-                     int32_t stepsOfset,
-                     std::shared_ptr<react::CallInvoker> callInvoker);
-  void setTimesteps(size_t numInferenceSteps);
-  std::vector<float> step(const std::vector<float> &sample,
-                          const std::vector<float> &noise, int32_t timestep);
-
-  std::vector<int32_t> timesteps;
-
-private:
-  int32_t numTrainTimesteps;
-  int32_t stepsOffset;
-
-  std::vector<float> betas;
-  std::vector<float> alphas;
-  std::vector<float> alphasCumprod;
-  std::vector<float> tempFirstSample;
-  std::vector<std::vector<float>> ets;
-  float finalAlphaCumprod{1.0f};
-
-  size_t numInferenceSteps{0};
-
-  std::vector<float> getPrevSample(const std::vector<float> &sample,
-                                   const std::vector<float> &noise,
-                                   int32_t timestep,
-                                   int32_t prevTimestep) const;
-};
-} // namespace rnexecutorch::models::text_to_image
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/TextToImage.cpp b/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/TextToImage.cpp
deleted file mode 100644
index d96f76c8ec..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/TextToImage.cpp
+++ /dev/null
@@ -1,150 +0,0 @@
-#include "TextToImage.h"
-
-#include <cmath>
-#include <random>
-#include <span>
-
-#include <executorch/extension/tensor/tensor.h>
-#include <opencv2/opencv.hpp>
-
-#include <rnexecutorch/Log.h>
-#include <rnexecutorch/data_processing/ImageProcessing.h>
-#include <rnexecutorch/models/text_to_image/Constants.h>
-
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-
-namespace rnexecutorch::models::text_to_image {
-
-using namespace executorch::extension;
-
-TextToImage::TextToImage(const std::string &tokenizerSource,
-                         const std::string &encoderSource,
-                         const std::string &unetSource,
-                         const std::string &decoderSource,
-                         float schedulerBetaStart, float schedulerBetaEnd,
-                         int32_t schedulerNumTrainTimesteps,
-                         int32_t schedulerStepsOffset,
-                         std::shared_ptr<react::CallInvoker> callInvoker)
-    : callInvoker(callInvoker),
-      scheduler(std::make_unique<Scheduler>(
-          schedulerBetaStart, schedulerBetaEnd, schedulerNumTrainTimesteps,
-          schedulerStepsOffset, callInvoker)),
-      encoder(std::make_unique<Encoder>(tokenizerSource, encoderSource,
-                                        callInvoker)),
-      unet(std::make_unique<UNet>(unetSource, callInvoker)),
-      decoder(std::make_unique<Decoder>(decoderSource, callInvoker)) {}
-
-void TextToImage::setImageSize(int32_t imageSize) {
-  if (imageSize % 32 != 0) {
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidConfig,
-                            "Image size must be a multiple of 32.");
-  }
-  this->imageSize = imageSize;
-  constexpr int32_t latentDownsample = 8;
-  latentImageSize = std::floor(imageSize / latentDownsample);
-  unet->latentImageSize = latentImageSize;
-  decoder->latentImageSize = latentImageSize;
-}
-
-void TextToImage::setSeed(int32_t &seed) {
-  // Seed argument is provided
-  if (seed >= 0) {
-    return;
-  }
-  std::random_device rd;
-  seed = rd();
-}
-
-std::string TextToImage::generate(std::string input, int32_t imageSize,
-                                  size_t numInferenceSteps, int32_t seed,
-                                  std::shared_ptr<jsi::Function> callback) {
-  std::scoped_lock lock(inference_mutex_);
-  setImageSize(imageSize);
-  setSeed(seed);
-
-  std::vector<float> embeddings = encoder->generate(input);
-  std::vector<int32_t> embeddingsShape = {2, 77, 768};
-  auto embeddingsTensor =
-      make_tensor_ptr(embeddingsShape, embeddings.data(), ScalarType::Float);
-
-  int32_t latentsSize = numChannels * latentImageSize * latentImageSize;
-  std::vector<float> latents(latentsSize);
-  std::mt19937 gen(seed);
-  std::normal_distribution<float> dist(0.0, 1.0);
-  for (auto &val : latents) {
-    val = dist(gen);
-  }
-
-  scheduler->setTimesteps(numInferenceSteps);
-  std::vector<int32_t> timesteps = scheduler->timesteps;
-
-  auto nativeCallback = [this, callback](size_t stepIdx) {
-    this->callInvoker->invokeAsync([callback, stepIdx](jsi::Runtime &runtime) {
-      callback->call(runtime, jsi::Value(static_cast<int32_t>(stepIdx)));
-    });
-  };
-  for (size_t t = 0; t < numInferenceSteps + 1 && !interrupted; t++) {
-    log(LOG_LEVEL::Debug, "Step:", t, "/", numInferenceSteps);
-
-    std::vector<float> noisePred =
-        unet->generate(latents, timesteps[t], embeddingsTensor);
-
-    size_t noiseSize = noisePred.size() / 2;
-    std::span<const float> noisePredSpan{noisePred};
-    std::span<const float> noiseUncond = noisePredSpan.subspan(0, noiseSize);
-    std::span<const float> noiseText =
-        noisePredSpan.subspan(noiseSize, noiseSize);
-    std::vector<float> noise(noiseSize);
-    for (size_t i = 0; i < noiseSize; i++) {
-      noise[i] =
-          noiseUncond[i] * (1 - guidanceScale) + noiseText[i] * guidanceScale;
-    }
-    latents = scheduler->step(latents, noise, timesteps[t]);
-
-    nativeCallback(t);
-  }
-  if (interrupted) {
-    interrupted = false;
-    return "";
-  }
-
-  for (auto &val : latents) {
-    val /= latentsScale;
-  }
-
-  std::vector<float> output = decoder->generate(latents);
-  return postprocess(output);
-}
-
-std::string TextToImage::postprocess(const std::vector<float> &output) const {
-  // Decoder output is HWC float RGB (values already in [0..255]). cv::imwrite
-  // expects a BGR matrix, so pack the channels in BGR order here.
-  cv::Mat bgr(imageSize, imageSize, CV_8UC3);
-  for (int32_t y = 0; y < imageSize; ++y) {
-    auto *row = bgr.ptr<cv::Vec3b>(y);
-    for (int32_t x = 0; x < imageSize; ++x) {
-      const int32_t idx = (y * imageSize + x) * 3;
-      row[x] = cv::Vec3b(static_cast<uint8_t>(output[idx + 2]),
-                         static_cast<uint8_t>(output[idx + 1]),
-                         static_cast<uint8_t>(output[idx + 0]));
-    }
-  }
-  return image_processing::saveToTempFile(bgr);
-}
-
-void TextToImage::interrupt() noexcept { interrupted = true; }
-
-size_t TextToImage::getMemoryLowerBound() const noexcept {
-  return encoder->getMemoryLowerBound() + unet->getMemoryLowerBound() +
-         decoder->getMemoryLowerBound();
-}
-
-void TextToImage::unload() noexcept {
-  std::scoped_lock lock(inference_mutex_);
-  encoder->unload();
-  unet->unload();
-  decoder->unload();
-}
-
-} // namespace rnexecutorch::models::text_to_image
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/TextToImage.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/TextToImage.h
deleted file mode 100644
index 5eaae65f08..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/TextToImage.h
+++ /dev/null
@@ -1,64 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <mutex>
-#include <string>
-#include <vector>
-
-#include <ReactCommon/CallInvoker.h>
-#include <jsi/jsi.h>
-
-#include <rnexecutorch/metaprogramming/ConstructorHelpers.h>
-
-#include <rnexecutorch/models/text_to_image/Decoder.h>
-#include <rnexecutorch/models/text_to_image/Encoder.h>
-#include <rnexecutorch/models/text_to_image/Scheduler.h>
-#include <rnexecutorch/models/text_to_image/UNet.h>
-
-namespace rnexecutorch {
-namespace models::text_to_image {
-using namespace facebook;
-
-class TextToImage final {
-public:
-  explicit TextToImage(const std::string &tokenizerSource,
-                       const std::string &encoderSource,
-                       const std::string &unetSource,
-                       const std::string &decoderSource,
-                       float schedulerBetaStart, float schedulerBetaEnd,
-                       int32_t schedulerNumTrainTimesteps,
-                       int32_t schedulerStepsOffset,
-                       std::shared_ptr<react::CallInvoker> callInvoker);
-  std::string generate(std::string input, int32_t imageSize,
-                       size_t numInferenceSteps, int32_t seed,
-                       std::shared_ptr<jsi::Function> callback);
-  void interrupt() noexcept;
-  size_t getMemoryLowerBound() const noexcept;
-  void unload() noexcept;
-
-private:
-  void setImageSize(int32_t imageSize);
-  void setSeed(int32_t &seed);
-  std::string postprocess(const std::vector<float> &output) const;
-
-  size_t memorySizeLowerBound;
-  int32_t imageSize;
-  int32_t latentImageSize;
-  static constexpr int32_t numChannels = 4;
-  static constexpr float guidanceScale = 7.5f;
-  static constexpr float latentsScale = 0.18215f;
-  bool interrupted = false;
-  mutable std::mutex inference_mutex_;
-
-  std::shared_ptr<react::CallInvoker> callInvoker;
-  std::unique_ptr<Scheduler> scheduler;
-  std::unique_ptr<Encoder> encoder;
-  std::unique_ptr<UNet> unet;
-  std::unique_ptr<Decoder> decoder;
-};
-} // namespace models::text_to_image
-
-REGISTER_CONSTRUCTOR(models::text_to_image::TextToImage, std::string,
-                     std::string, std::string, std::string, float, float,
-                     int32_t, int32_t, std::shared_ptr<react::CallInvoker>);
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/UNet.cpp b/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/UNet.cpp
deleted file mode 100644
index d2d58badb8..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/UNet.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "UNet.h"
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-
-namespace rnexecutorch::models::text_to_image {
-
-using namespace executorch::extension;
-
-UNet::UNet(const std::string &modelSource,
-           std::shared_ptr<react::CallInvoker> callInvoker)
-    : BaseModel(modelSource, callInvoker) {}
-
-std::vector<float> UNet::generate(std::vector<float> &latents, int32_t timestep,
-                                  TensorPtr &embeddingsTensor) const {
-  std::vector<float> latentsConcat;
-  latentsConcat.reserve(2 * latentImageSize);
-  latentsConcat.insert(latentsConcat.end(), latents.begin(), latents.end());
-  latentsConcat.insert(latentsConcat.end(), latents.begin(), latents.end());
-
-  std::vector<int32_t> latentsShape = {2, numChannels, latentImageSize,
-                                       latentImageSize};
-
-  auto timestepTensor =
-      make_tensor_ptr<int64_t>({static_cast<int64_t>(timestep)});
-  auto latentsTensor =
-      make_tensor_ptr(latentsShape, latentsConcat.data(), ScalarType::Float);
-
-  auto forwardResult =
-      BaseModel::forward({latentsTensor, timestepTensor, embeddingsTensor});
-  CHECK_OK_OR_THROW_FORWARD_ERROR(forwardResult);
-
-  auto forwardResultTensor = forwardResult->at(0).toTensor();
-  const auto *dataPtr = forwardResultTensor.const_data_ptr<float>();
-  return {dataPtr, dataPtr + forwardResultTensor.numel()};
-}
-} // namespace rnexecutorch::models::text_to_image
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/UNet.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/UNet.h
deleted file mode 100644
index 0c6dd057c6..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_image/UNet.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include <executorch/extension/tensor/tensor.h>
-
-#include <ReactCommon/CallInvoker.h>
-#include <rnexecutorch/models/BaseModel.h>
-
-namespace rnexecutorch::models::text_to_image {
-
-using namespace executorch::extension;
-
-class UNet final : public BaseModel {
-public:
-  explicit UNet(const std::string &modelSource,
-                std::shared_ptr<react::CallInvoker> callInvoker);
-  std::vector<float> generate(std::vector<float> &latents, int32_t timestep,
-                              TensorPtr &embeddingsTensor) const;
-
-  int32_t latentImageSize;
-
-private:
-  static constexpr int32_t numChannels = 4;
-};
-} // namespace rnexecutorch::models::text_to_image
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/TextToSpeech.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/TextToSpeech.h
deleted file mode 100644
index 2fb17c95f5..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/TextToSpeech.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#pragma once
-
-#include "kokoro/Kokoro.h"
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Constants.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Constants.h
deleted file mode 100644
index 21f0e11501..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Constants.h
+++ /dev/null
@@ -1,88 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-
-#include "Types.h"
-
-namespace rnexecutorch::models::text_to_speech::kokoro::constants {
-
-// Model input size limits
-inline constexpr size_t kMinInputTokens =
-    8; // Models do not accept less amount of tokens (including padding)
-inline constexpr size_t kMaxInputTokens =
-    128; // Models do not accept more tokens (including padding)
-inline constexpr size_t kMinDurationTicks =
-    16; // Corresponds to DurationPredictor output and one of Synthesizer's
-        // input shapes
-inline constexpr size_t kMaxDurationTicks =
-    296; // Corresponds to DurationPredictor output and one of Synthesizer's
-         // input shapes
-inline constexpr float kMinValidSpeed = 0.1F;
-inline constexpr float kMaxValidSpeed = 3.0F;
-
-// Model input sizes - voice reference vector
-inline constexpr int32_t kVoiceRefSize =
-    256; // Always a fixed size, regardless of number of input tokens
-inline constexpr int32_t kVoiceRefHalfSize = kVoiceRefSize / 2;
-
-// Duration mappings
-// This corresponds to a number of elements in resulting audio vector per each
-// duration point.
-inline constexpr int32_t kTicksPerDuration = 600;
-inline constexpr int32_t kSamplingRate =
-    24000; // Corresponds to Kokoro's model audio frequency
-inline constexpr int32_t kSamplesPerMilisecond = kSamplingRate / 1000;
-
-// Special text characters
-inline const std::unordered_set<char32_t> kEndOfSentenceCharacters = {
-    U'.', U'?', U'!', U';',
-    U'…', // Ellipsis
-    U'|', // ASCII Pipe (often used as Hindi Purna Viram)
-    U'।', // Hindi Purna Viram (U+0964)
-    U'॥', // Hindi Deergh Viram (U+0965)
-    U'¿', // Spanish Inverted Question Mark (U+00BF)
-    U'¡', // Spanish Inverted Exclamation Mark (U+00A1)
-};
-
-inline const std::unordered_set<char32_t> kPauseCharacters = {
-    U',', U':', U'-',
-    U'—', // Em Dash (U+2014)
-    U'«', // Left Guillemet (U+00AB)
-    U'»', // Right Guillemet (U+00BB)
-};
-
-// Phoneme to token mappings
-inline constexpr int32_t kVocabSize = 178;
-inline const std::unordered_map<char32_t, Token> kVocab = {
-    {U';', 1},       {U':', 2},   {U',', 3},   {U'.', 4},   {U'!', 5},
-    {U'?', 6},       {U'—', 9},   {U'…', 10},  {U'"', 11},  {U'(', 12},
-    {U')', 13},      {U'“', 14},  {U'”', 15},  {U' ', 16},  {U'\u0303', 17},
-    {U'ʣ', 18},      {U'ʥ', 19},  {U'ʦ', 20},  {U'ʨ', 21},  {U'ᵝ', 22},
-    {U'\uAB67', 23}, {U'A', 24},  {U'I', 25},  {U'O', 31},  {U'Q', 33},
-    {U'S', 35},      {U'T', 36},  {U'W', 39},  {U'Y', 41},  {U'ᵊ', 42},
-    {U'a', 43},      {U'b', 44},  {U'c', 45},  {U'd', 46},  {U'e', 47},
-    {U'f', 48},      {U'h', 50},  {U'i', 51},  {U'j', 52},  {U'k', 53},
-    {U'l', 54},      {U'm', 55},  {U'n', 56},  {U'o', 57},  {U'p', 58},
-    {U'q', 59},      {U'r', 60},  {U's', 61},  {U't', 62},  {U'u', 63},
-    {U'v', 64},      {U'w', 65},  {U'x', 66},  {U'y', 67},  {U'z', 68},
-    {U'ɑ', 69},      {U'ɐ', 70},  {U'ɒ', 71},  {U'æ', 72},  {U'β', 75},
-    {U'ɔ', 76},      {U'ɕ', 77},  {U'ç', 78},  {U'ɖ', 80},  {U'ð', 81},
-    {U'ʤ', 82},      {U'ə', 83},  {U'ɚ', 85},  {U'ɛ', 86},  {U'ɜ', 87},
-    {U'ɟ', 90},      {U'ɡ', 92},  {U'ɥ', 99},  {U'ɨ', 101}, {U'ɪ', 102},
-    {U'ʝ', 103},     {U'ɯ', 110}, {U'ɰ', 111}, {U'ŋ', 112}, {U'ɳ', 113},
-    {U'ɲ', 114},     {U'ɴ', 115}, {U'ø', 116}, {U'ɸ', 118}, {U'θ', 119},
-    {U'œ', 120},     {U'ɹ', 123}, {U'ɾ', 125}, {U'ɻ', 126}, {U'ʁ', 128},
-    {U'ɽ', 129},     {U'ʂ', 130}, {U'ʃ', 131}, {U'ʈ', 132}, {U'ʧ', 133},
-    {U'ʊ', 135},     {U'ʋ', 136}, {U'ʌ', 138}, {U'ɣ', 139}, {U'ɤ', 140},
-    {U'χ', 142},     {U'ʎ', 143}, {U'ʒ', 147}, {U'ʔ', 148}, {U'ˈ', 156},
-    {U'ˌ', 157},     {U'ː', 158}, {U'ʰ', 162}, {U'ʲ', 164}, {U'↓', 169},
-    {U'→', 171},     {U'↗', 172}, {U'↘', 173}, {U'ᵻ', 177}};
-
-// Special tokens
-inline constexpr Token kInvalidToken = -1;
-inline constexpr Token kPadToken = 0;
-
-} // namespace rnexecutorch::models::text_to_speech::kokoro::constants
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/DurationPredictor.cpp b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/DurationPredictor.cpp
deleted file mode 100644
index a3d27574bc..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/DurationPredictor.cpp
+++ /dev/null
@@ -1,216 +0,0 @@
-#include "DurationPredictor.h"
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/data_processing/Sequential.h>
-#include <rnexecutorch/metaprogramming/ContainerHelpers.h>
-
-#include <algorithm>
-#include <cmath>
-#include <numeric>
-#include <queue>
-#include <ranges>
-
-namespace rnexecutorch::models::text_to_speech::kokoro {
-
-using ::executorch::aten::ScalarType;
-using ::executorch::extension::make_tensor_ptr;
-using ::executorch::extension::TensorPtr;
-
-DurationPredictor::DurationPredictor(
-    const std::string &modelSource, const Context &modelContext,
-    std::shared_ptr<react::CallInvoker> callInvoker)
-    : BaseModel(modelSource, callInvoker), context_(modelContext) {
-  auto availableMethods = module_->method_names();
-  if (!availableMethods.ok()) {
-    throw RnExecutorchError(
-        RnExecutorchErrorCode::UnknownError,
-        "[Kokoro::DurationPredictor] Unable to read model's methods");
-  }
-
-  // Recognize available forward methods
-  const auto &names = *availableMethods;
-  for (const auto &name : names) {
-    // Check if method starts with "forward"
-    if (name.rfind("forward", 0) == 0) {
-      const auto inputTensors = getAllInputShapes(name);
-
-      // Perform checks to validate model's compatibility with native code
-      CHECK_SIZE(inputTensors, 4);
-      CHECK_SIZE(inputTensors[0], 2);
-
-      // Obtain the maximum number of tokens supported by the method
-      size_t inputSize = inputTensors[0][1];
-
-      forwardMethods_.emplace_back(name, inputSize);
-    }
-  }
-
-  // Sort the forward methods by input size
-  std::stable_sort(
-      forwardMethods_.begin(), forwardMethods_.end(),
-      [](const auto &a, const auto &b) { return a.second < b.second; });
-}
-
-std::tuple<Tensor, std::vector<int64_t>, int32_t, std::vector<Timestamp>>
-DurationPredictor::generate(std::span<Token> tokens, std::span<bool> textMask,
-                            std::span<float> ref_hs, float speed) {
-  size_t inputSize = tokens.size();
-
-  // Perform input shape checks
-  // Since every bit in text mask corresponds to exactly one of the tokens, both
-  // vectors should be the same length
-  CHECK_SIZE(textMask, inputSize);
-  CHECK_SIZE(ref_hs, constants::kVoiceRefHalfSize);
-
-  // Select appropriate forward method
-  auto it =
-      std::ranges::find_if(forwardMethods_, [inputSize](const auto &entry) {
-        return entry.second >= inputSize;
-      });
-  if (it == forwardMethods_.end()) {
-    throw RnExecutorchError(
-        RnExecutorchErrorCode::WrongDimensions,
-        "[Kokoro::DurationPredictor] No appropriate forward method to"
-        "handle input of size " +
-            std::to_string(inputSize));
-  }
-  auto selectedMethod = it->first;
-
-  // Convert input data to ExecuTorch tensors
-  auto tokensTensor = make_tensor_ptr({1, static_cast<int32_t>(tokens.size())},
-                                      tokens.data(), ScalarType::Long);
-
-  auto textMaskTensor =
-      make_tensor_ptr({1, static_cast<int32_t>(textMask.size())},
-                      textMask.data(), ScalarType::Bool);
-
-  auto voiceRefTensor = make_tensor_ptr({1, constants::kVoiceRefHalfSize},
-                                        ref_hs.data(), ScalarType::Float);
-
-  auto speedTensor = make_tensor_ptr({1}, &speed, ScalarType::Float);
-
-  // Execute the appropriate "forward_xyz" method, based on given method name
-  auto results = execute(selectedMethod, {tokensTensor, textMaskTensor,
-                                          voiceRefTensor, speedTensor});
-
-  CHECK_OK_OR_THROW_FORWARD_ERROR(results);
-
-  // Unpack the result
-  auto predDurTensor = results->at(0).toTensor();
-  auto predDurPtr = predDurTensor.const_data_ptr<int64_t>();
-  auto dTensor = results->at(1).toTensor();
-
-  // Scale output durations if it exceedes the limits
-  size_t totalDur = std::reduce(predDurPtr, predDurPtr + inputSize);
-  size_t clampedDur = std::clamp(totalDur, constants::kMinDurationTicks,
-                                 context_.inputDurationLimit);
-  if (totalDur != clampedDur) {
-    scaleDurations(predDurTensor, inputSize, clampedDur);
-  }
-
-  // Create indices tensor by repetitions according to durations vector
-  std::vector<int64_t> idxs(inputSize);
-  std::iota(idxs.begin(), idxs.end(), 0LL);
-  std::vector<int64_t> indices = rnexecutorch::sequential::repeatInterleave(
-      std::span<const int64_t>(idxs),
-      std::span<const int64_t>(predDurPtr, inputSize));
-
-  // Calculate the effective duration
-  // Note that we lower effective duration even further, to remove
-  // some of the side-effects at the end of the audio.
-  int32_t originalLength =
-      std::distance(tokens.begin(),
-                    std::find(tokens.begin() + 1, tokens.end(), 0)) +
-      1;
-  int32_t effDuration = std::distance(
-      indices.begin(),
-      std::lower_bound(indices.begin(), indices.end(), originalLength));
-
-  // Calculate timestamps - based on predicted durations.
-  std::vector<Timestamp> timestamps =
-      calculateTimestamps(predDurPtr, inputSize);
-
-  /**
-   * Returns:
-   *   - d: tensor containing the predicted durations for each token.
-   *   - indices: vector of repeated token indices according to durations.
-   *   - effDuration: an effective duration after post-processing.
-   */
-  return std::make_tuple(std::move(dTensor), std::move(indices),
-                         std::move(effDuration), std::move(timestamps));
-}
-
-size_t DurationPredictor::getTokensLimit() const {
-  return forwardMethods_.empty() ? 0 : forwardMethods_.back().second;
-}
-
-std::vector<Timestamp>
-DurationPredictor::calculateTimestamps(const int64_t *predDurPtr,
-                                       size_t inputSize) const {
-  std::vector<Timestamp> timestamps;
-  timestamps.reserve(inputSize);
-
-  size_t accDur = 0;
-  for (size_t i = 0; i < inputSize; i++) {
-    int64_t dur = predDurPtr[i] *
-                  constants::kTicksPerDuration; // Convert to audio samples
-    timestamps.emplace_back(accDur, accDur + dur);
-    accDur += dur;
-  }
-
-  return timestamps;
-}
-
-void DurationPredictor::scaleDurations(Tensor &durations, size_t nTokens,
-                                       int32_t targetDuration) const {
-  // We expect durations tensor to be a Long tensor of a shape [1, n_tokens]
-  if (durations.dtype() != ScalarType::Long &&
-      durations.dtype() != ScalarType::Int) {
-    throw RnExecutorchError(
-        RnExecutorchErrorCode::InvalidModelOutput,
-        "[Kokoro::DurationPredictor] Attempted to scale a non-integer tensor");
-  }
-
-  auto shape = durations.sizes();
-  if (shape.size() != 1) {
-    throw RnExecutorchError(
-        RnExecutorchErrorCode::InvalidModelOutput,
-        "[Kokoro::DurationPredictor] Attempted to scale an ill-shaped tensor");
-  }
-
-  int64_t *durationsPtr = durations.mutable_data_ptr<int64_t>();
-  int64_t totalDur = std::reduce(durationsPtr, durationsPtr + nTokens);
-
-  float scaleFactor = static_cast<float>(targetDuration) / totalDur;
-  bool shrinking = scaleFactor < 1.F;
-
-  // We need to scale partial durations (integers) corresponding to each token
-  // in a way that they all sum up to target duration, while keeping the balance
-  // between the values.
-  std::priority_queue<std::pair<float, uint32_t>>
-      remainders; // Sorted by the first value
-  int64_t scaledSum = 0;
-  for (uint32_t i = 0; i < nTokens; i++) {
-    float scaled = scaleFactor * durationsPtr[i];
-    float remainder =
-        shrinking ? std::ceil(scaled) - scaled : scaled - std::floor(scaled);
-
-    durationsPtr[i] = static_cast<int64_t>(shrinking ? std::ceil(scaled)
-                                                     : std::floor(scaled));
-    scaledSum += durationsPtr[i];
-
-    // Keeps the entries sorted by the remainders
-    remainders.emplace(remainder, i);
-  }
-
-  // The initial processing scales durations to at least (targetDuration -
-  // nTokens) - the next part is to round the remaining values sorted by their
-  // remainders size.
-  int32_t diff = std::abs(targetDuration - scaledSum);
-  for (uint32_t i = 0; i < diff; i++) {
-    auto [remainder, idx] = remainders.top();
-    durationsPtr[idx] += shrinking ? -1 : 1;
-    remainders.pop();
-  }
-}
-
-} // namespace rnexecutorch::models::text_to_speech::kokoro
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/DurationPredictor.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/DurationPredictor.h
deleted file mode 100644
index 2ace0b9b25..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/DurationPredictor.h
+++ /dev/null
@@ -1,78 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <span>
-#include <string>
-#include <tuple>
-#include <vector>
-
-#include <executorch/extension/tensor/tensor.h>
-
-#include "Constants.h"
-#include "Types.h"
-#include <rnexecutorch/models/BaseModel.h>
-
-namespace rnexecutorch::models::text_to_speech::kokoro {
-
-using executorch::aten::Tensor;
-
-class DurationPredictor : public BaseModel {
-public:
-  explicit DurationPredictor(const std::string &modelSource,
-                             const Context &modelContext,
-                             std::shared_ptr<react::CallInvoker> callInvoker);
-
-  /**
-   * Generates approximated durations and corresponding indices for the input
-   * tokens.
-   *
-   * @param tokens      The input token sequence.
-   * @param textMask    A boolean mask indicating which tokens are valid.
-   * @param ref_hs      Reference speaker embedding (upper segment of the voice
-   * vector).
-   * @param speed       Speed factor for synthesis (default: 1.0).
-   * @return            Tuple containing:
-   *                    d - Tensor: predicted durations for each token,
-   *                    indices  - std::vector<int64_t>: repeated token indices,
-   *                    effDuration  - int32_t: effective duration after
-   *                                            post-processing.
-   *                    timestamps - timestamp marks for each token (phoneme)
-   */
-  std::tuple<Tensor, std::vector<int64_t>, int32_t, std::vector<Timestamp>>
-  generate(std::span<Token> tokens, std::span<bool> textMask,
-           std::span<float> ref_hs, float speed = 1.F);
-
-  // Returns maximum supported amount of input tokens.
-  size_t getTokensLimit() const;
-
-private:
-  // Helper function - calculating timestamps based on predicted durations
-  std::vector<Timestamp> calculateTimestamps(const int64_t *predDurPtr,
-                                             size_t inputSize) const;
-
-  // Helper function - duration scalling
-  // Performs integer scaling on the durations tensor to ensure the sum of
-  // durations matches the given target duration
-  void scaleDurations(
-      Tensor &durations, size_t nTokens,
-      int32_t targetDuration) const; // Helper function - calculating effective
-                                     // duration based on duration tensor
-
-  // Since we apply padding to the input, the effective duration is
-  // usually a little bit lower than the max duration defined by static input
-  // size.
-  int32_t calculateEffectiveDuration(const Tensor &d,
-                                     const std::vector<int64_t> &indices) const;
-
-  // Available forward methods
-  // In order to speed-up the calculations, we allow DurationPredictor to
-  // have multiple forward_xyz methods, where syz stands for maximum supported
-  // amount of input tokens.
-  std::vector<std::pair<std::string, size_t>> forwardMethods_;
-
-  // Shared model context
-  // A const reference to singleton in Kokoro.
-  const Context &context_;
-};
-
-} // namespace rnexecutorch::models::text_to_speech::kokoro
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Kokoro.cpp b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Kokoro.cpp
deleted file mode 100644
index aa8486c276..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Kokoro.cpp
+++ /dev/null
@@ -1,443 +0,0 @@
-#include "Kokoro.h"
-#include "Params.h"
-#include "Utils.h"
-
-#include <algorithm>
-#include <fstream>
-#include <phonemis/utils/strings.h>
-#include <phonemis/utils/unicode.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/data_processing/Sequential.h>
-#include <thread>
-
-namespace rnexecutorch::models::text_to_speech::kokoro {
-
-Kokoro::Kokoro(const std::string &lang, const std::string &taggerDataSource,
-               const std::string &lexiconSource,
-               const std::string &neuralModelSource,
-               const std::string &durationPredictorSource,
-               const std::string &synthesizerSource,
-               const std::string &voiceSource,
-               std::shared_ptr<react::CallInvoker> callInvoker)
-    : callInvoker_(std::move(callInvoker)),
-      phonemizer_(phonemis::Config{
-          .lang = lang,
-          .tagger = taggerDataSource.empty()
-                        ? std::optional<phonemis::tagger::Config>{}
-                        : std::make_optional(phonemis::tagger::Config{
-                              .data_filepath = taggerDataSource}),
-          .phonemizer =
-              phonemis::phonemizer::Config{
-                  .lang = lang,
-                  .lexicon_filepath = lexiconSource.empty()
-                                          ? std::nullopt
-                                          : std::make_optional(lexiconSource),
-                  .nn_model_filepath =
-                      neuralModelSource.empty()
-                          ? std::nullopt
-                          : std::make_optional(neuralModelSource)}}),
-      durationPredictor_(durationPredictorSource, context_, callInvoker_),
-      synthesizer_(synthesizerSource, context_, callInvoker_) {
-  // Populate the voice array by reading given file
-  loadVoice(voiceSource);
-
-  // Read model limits & check compatibility
-  if (durationPredictor_.getTokensLimit() != synthesizer_.getTokensLimit()) {
-    throw RnExecutorchError(
-        RnExecutorchErrorCode::WrongDimensions,
-        "[Kokoro] incompatible DurationPredictor & Synthesizer models");
-  }
-
-  context_.inputTokensLimit = durationPredictor_.getTokensLimit();
-  context_.inputDurationLimit = synthesizer_.getDurationLimit();
-}
-
-void Kokoro::loadVoice(const std::string &voiceSource) {
-  constexpr size_t cols = static_cast<size_t>(constants::kVoiceRefSize);
-  constexpr size_t bytesPerRow = cols * sizeof(float);
-
-  std::ifstream in(voiceSource, std::ios::binary);
-  if (!in) {
-    throw RnExecutorchError(RnExecutorchErrorCode::FileReadFailed,
-                            "[Kokoro::loadVoice]: cannot open file: " +
-                                voiceSource);
-  }
-
-  // Determine number of rows from file size
-  in.seekg(0, std::ios::end);
-  const auto fileSize = static_cast<size_t>(in.tellg());
-  in.seekg(0, std::ios::beg);
-
-  if (fileSize < bytesPerRow) {
-    throw RnExecutorchError(
-        RnExecutorchErrorCode::FileReadFailed,
-        "[Kokoro::loadVoice]: file too small: need at least " +
-            std::to_string(bytesPerRow) + " bytes for one row, got " +
-            std::to_string(fileSize));
-  }
-
-  const size_t rows = fileSize / bytesPerRow;
-  const auto readBytes = static_cast<std::streamsize>(rows * bytesPerRow);
-
-  // Resize voice vector to hold all rows from the file
-  voice_.resize(rows);
-
-  if (!in.read(reinterpret_cast<char *>(voice_.data()->data()), readBytes)) {
-    throw RnExecutorchError(
-        RnExecutorchErrorCode::FileReadFailed,
-        "[Kokoro::loadVoice]: failed to read voice weights");
-  }
-}
-
-std::vector<float> Kokoro::generate(std::u32string input, float speed,
-                                    bool phonemize) {
-  if (input.size() > params::kMaxTextSize) {
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidUserInput,
-                            "Kokoro: maximum input text size exceeded");
-  }
-
-  if (speed < constants::kMinValidSpeed) {
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidUserInput,
-                            "Kokoro: speed value too low (min " +
-                                std::to_string(constants::kMinValidSpeed) +
-                                ")");
-  }
-
-  if (speed > constants::kMaxValidSpeed) {
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidUserInput,
-                            "Kokoro: speed value too high (max " +
-                                std::to_string(constants::kMaxValidSpeed) +
-                                ")");
-  }
-
-  if (input.empty()) {
-    return {};
-  }
-
-  // G2P (Grapheme to Phoneme) conversion
-  auto phonemes = phonemize ? phonemizer_(input) : input;
-
-  // Divide the phonemes string into substrings, minimizing the amount of
-  // breaks.
-  auto partition = partitioner_.partition(phonemes, context_.inputTokensLimit,
-                                          Partitioner::Mode::MIN_BREAKS);
-
-  std::vector<float> audio = {};
-  for (const auto &[offset, length] : partition.segments) {
-    auto subsentence = partition.content.substr(offset, length);
-
-    // Generate an audio vector with the Kokoro model
-    auto audioPart = synthesize(subsentence, speed);
-
-    // Calculate a pause between the sentences
-    char32_t lastPhoneme = subsentence.back();
-    size_t pauseMs = params::kPauseValues.contains(lastPhoneme)
-                         ? params::kPauseValues.at(lastPhoneme)
-                         : params::kDefaultPause;
-
-    // Add audio part and silence pause to the main audio vector
-    audio.insert(audio.end(), std::make_move_iterator(audioPart.begin()),
-                 std::make_move_iterator(audioPart.end()));
-    audio.resize(audio.size() + pauseMs * constants::kSamplesPerMilisecond,
-                 0.F);
-  }
-
-  return audio;
-}
-
-void Kokoro::stream(std::shared_ptr<jsi::Function> callback, float speed,
-                    bool phonemize, bool stopOnEmptyBuffer) {
-  if (speed < constants::kMinValidSpeed) {
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidUserInput,
-                            "Kokoro: speed value too low (min " +
-                                std::to_string(constants::kMinValidSpeed) +
-                                ")");
-  }
-
-  if (speed > constants::kMaxValidSpeed) {
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidUserInput,
-                            "Kokoro: speed value too high (max " +
-                                std::to_string(constants::kMaxValidSpeed) +
-                                ")");
-  }
-
-  // Create a callback
-  auto nativeCallback = [this, callback](const std::vector<float> &audioVec) {
-    if (this->isStreaming_) {
-      this->callInvoker_->invokeAsync(
-          [callback, audioVec = std::move(audioVec)](jsi::Runtime &rt) {
-            callback->call(
-                rt, rnexecutorch::jsi_conversion::getJsiValue(audioVec, rt));
-          });
-    }
-  };
-
-  isStreaming_ = true;
-  stopOnEmptyBuffer_ = stopOnEmptyBuffer;
-  flushPending_ = false;
-
-  // The outer streaming loop is responsible for handling the input buffer.
-  // The extracted text is then passed to the inner loop, which performs a
-  // standard streaming on a fixed amount of input text.
-  while (isStreaming_) {
-    std::u32string input;
-
-    // Extract the code relying on input buffer for a separate mutex lock
-    // section.
-    {
-      // Trim to remove trailing whitespace characters
-      inputTextBuffer_ =
-          phonemis::utils::strings::strip<std::u32string, char32_t>(
-              inputTextBuffer_);
-
-      std::scoped_lock<std::mutex> lock(inputTextBufferMutex_);
-      if (inputTextBuffer_.empty() && stopOnEmptyBuffer_) {
-        break;
-      }
-
-      // Try to find the most recent available end of sentence character.
-      size_t searchLimit =
-          std::min(inputTextBuffer_.size(), params::kMaxTextSize);
-      auto eosIt = std::find_first_of(
-          inputTextBuffer_.rbegin() + (inputTextBuffer_.size() - searchLimit),
-          inputTextBuffer_.rend(), constants::kEndOfSentenceCharacters.begin(),
-          constants::kEndOfSentenceCharacters.end());
-      size_t chunkSize = (eosIt != inputTextBuffer_.rend())
-                             ? std::distance(eosIt, inputTextBuffer_.rend())
-                             : 0;
-
-      // Default behavior: hold back partial content until an EOS arrives, so
-      // we don't synthesize mid-sentence (relevant for LLM token streaming).
-      // When the caller signals via `streamFlush()` / `streamStop(false)`
-      // that they want the tail drained, take the entire searchable window
-      // instead. The flush flag stays set until the buffer empties, so a
-      // multi-chunk drain progresses across iterations.
-      if (chunkSize == 0 && flushPending_.load()) {
-        chunkSize = searchLimit;
-      }
-      if (chunkSize > 0) {
-        input = inputTextBuffer_.substr(0, chunkSize);
-        inputTextBuffer_.erase(0, chunkSize);
-        if (inputTextBuffer_.empty()) {
-          flushPending_ = false;
-        }
-      }
-    }
-
-    if (!input.empty()) {
-      // Now we proceed with a standard streaming logic for fixed-size input.
-      // Start with preprocessing the input once.
-      std::u32string buffer = phonemizer_.preprocess(input);
-
-      // A variable to keep the information about phonemized (but not
-      // synthesized) tokens from the previous iteration.
-      size_t phonemizedTokens = 0;
-
-      while (!buffer.empty() && isStreaming_) {
-        // Since we do not phonemize the entire input before partitioning, there
-        // is a possibility that some segment might exceed the token limit after
-        // phonemization. This is being handled later.
-        auto partition = partitioner_.partition(
-            buffer, context_.inputTokensLimit, Partitioner::Mode::MIN_LATENCY);
-
-        for (size_t i = 0; i < partition.segments.size(); i++) {
-          if (!isStreaming_) {
-            break;
-          }
-
-          const auto &[offset, length] = partition.segments[i];
-          const auto subsentence = partition.content.substr(0, length);
-
-          std::u32string phonemes;
-
-          if (phonemize) {
-            size_t unchangedLength = std::min(length, phonemizedTokens);
-            // Include trailing space if it was already phonemized
-            if (unchangedLength < length &&
-                subsentence[unchangedLength] == U' ' &&
-                phonemizedTokens > unchangedLength) {
-              unchangedLength++;
-            }
-
-            // We phonemize on the fly - meaning there is no time waste
-            // phonemizing the entire input if we only need one segment at the
-            // time.`
-            phonemes = subsentence.substr(0, unchangedLength);
-            if (unchangedLength < length) {
-              // Phonemize without preprocessing (since we already did that).
-              phonemes +=
-                  phonemizer_(subsentence.substr(unchangedLength), false);
-            }
-          } else {
-            // Simple case - no phonemization, no risk of exceeding the token
-            // limit.
-            phonemes = subsentence;
-          }
-
-          if (phonemes.size() <= context_.inputTokensLimit - 2) {
-            // Determine the silent padding duration
-            bool endsWithSpace = (subsentence.back() == U' ');
-            bool prevEndsWithSpace =
-                (offset > 0 && partition.content[offset - 1] == U' ');
-            size_t paddingMs = endsWithSpace || prevEndsWithSpace ? 15 : 50;
-
-            // Generate and push audio
-            auto audioPart = synthesize(phonemes, speed, paddingMs);
-
-            size_t pauseMs = params::kPauseValues.contains(phonemes.back())
-                                 ? params::kPauseValues.at(phonemes.back())
-                                 : params::kDefaultPause;
-
-            audioPart.resize(audioPart.size() +
-                                 pauseMs * constants::kSamplesPerMilisecond,
-                             0.F);
-
-            nativeCallback(std::move(audioPart));
-
-            // Remove processed segment from buffer.
-            // Since we process it from left to right, we expect the segment to
-            // be at the beginning of the buffer.
-            buffer.erase(0, length);
-            phonemizedTokens = std::max(phonemizedTokens, length) - length;
-          } else {
-            // Length exceeds limit. Replace the sentence in buffer with its
-            // phonemization.
-            if (phonemize) {
-              buffer.replace(0, length, phonemes);
-            }
-            phonemizedTokens = phonemes.size();
-
-            break;
-          }
-        }
-      }
-    }
-
-    // A little bit of pause to not overload the thread.
-    if (isStreaming_) {
-      std::this_thread::sleep_for(
-          std::chrono::milliseconds(params::kStreamPause));
-    }
-  }
-
-  {
-    std::scoped_lock<std::mutex> lock(inputTextBufferMutex_);
-    inputTextBuffer_.clear();
-    isStreaming_ = false;
-    flushPending_ = false;
-  }
-}
-
-std::vector<float> Kokoro::synthesize(std::u32string_view phonemes, float speed,
-                                      size_t paddingMs) {
-  if (phonemes.empty()) {
-    return {};
-  }
-
-  // Remove leading whitespace if exists.
-  if (phonemes.front() == U' ') {
-    phonemes = phonemes.substr(1);
-  }
-
-  // 1. Prepare input tokens.
-  // Clamp input to avoid exceeding model limits (2 tokens reserved for pre/post
-  // padding).
-  const size_t noTokens =
-      std::clamp(phonemes.size() + 2, constants::kMinInputTokens,
-                 context_.inputTokensLimit);
-  auto tokens = utils::tokenize(phonemes, {noTokens});
-
-  // 2. Initialize text mask.
-  // Exclude all paddings except the first and last ones.
-  // We use uint8_t instead of bool to avoid boolean span issues.
-  std::vector<uint8_t> textMask(noTokens, false);
-  std::fill(textMask.begin(),
-            textMask.begin() + std::min(phonemes.size() + 2, noTokens), true);
-
-  // 3. Select the appropriate voice vector.
-  // Each number of input tokens corresponds to a different voice embedding
-  // vector.
-  const size_t voiceID =
-      std::min({phonemes.size() - 1, noTokens - 1, voice_.size() - 1});
-  auto &voice = voice_[voiceID];
-
-  // 4. Inference Phase 1: DurationPredictor (submodule).
-  auto [d, indices, effectiveDuration, timestamps] =
-      durationPredictor_.generate(
-          std::span(tokens),
-          std::span(reinterpret_cast<bool *>(textMask.data()), textMask.size()),
-          std::span(voice).last(constants::kVoiceRefHalfSize), speed);
-
-  // 5. Inference Phase 2: Synthesizer.
-  // Note that we reduce the size of the duration tensor to match the number of
-  // tokens.
-  auto decoding = synthesizer_.generate(
-      std::span(tokens),
-      std::span(reinterpret_cast<bool *>(textMask.data()), textMask.size()),
-      std::span(indices),
-      std::span<float>(d.mutable_data_ptr<float>(),
-                       noTokens * d.sizes().back()),
-      std::span(voice));
-
-  // 6. Post-processing: Finalize audio.
-  auto audioTensor = decoding->at(0).toTensor();
-
-  if (audioTensor.numel() == 0) {
-    return {};
-  }
-
-  const int32_t audioLength = constants::kTicksPerDuration * effectiveDuration;
-
-  auto audio =
-      std::span<const float>(audioTensor.const_data_ptr<float>(), audioLength);
-
-  // To counter any potential trailing voice artifacts (which can occur due to
-  // slight mismatch of .pte model results) we cut it according to the predicted
-  // duration ticks.
-  if (noTokens > 2) {
-    // We want to skip both the last PAD token, as well as any potential EOS
-    // token just before it.
-    auto lastTokenTimestamp =
-        !phonemis::utils::unicode::isalpha(phonemes.back())
-            ? timestamps[noTokens - 3].end
-            : timestamps[noTokens - 2].end;
-
-    audio = audio.subspan(0, std::min(lastTokenTimestamp, audio.size()));
-  }
-
-  // Now additional stripping of a (hopefully) pure silence.
-  audio =
-      utils::stripAudio(audio, paddingMs * constants::kSamplesPerMilisecond);
-
-  return {audio.begin(), audio.end()};
-}
-
-void Kokoro::streamInsert(std::u32string chunk) noexcept {
-  std::scoped_lock<std::mutex> lock(inputTextBufferMutex_);
-  inputTextBuffer_.append(chunk);
-}
-
-void Kokoro::streamFlush() noexcept { flushPending_ = true; }
-
-void Kokoro::streamStop(bool instant) noexcept {
-  if (instant) {
-    isStreaming_ = false;
-  } else {
-    // Ensure trailing un-terminated content is drained before the loop exits.
-    flushPending_ = true;
-    stopOnEmptyBuffer_ = true;
-  }
-}
-
-std::size_t Kokoro::getMemoryLowerBound() const noexcept {
-  return durationPredictor_.getMemoryLowerBound() +
-         synthesizer_.getMemoryLowerBound() + sizeof(voice_) +
-         sizeof(phonemizer_);
-}
-
-void Kokoro::unload() noexcept {
-  durationPredictor_.unload();
-  synthesizer_.unload();
-}
-
-} // namespace rnexecutorch::models::text_to_speech::kokoro
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Kokoro.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Kokoro.h
deleted file mode 100644
index ef9fa432b6..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Kokoro.h
+++ /dev/null
@@ -1,129 +0,0 @@
-#pragma once
-
-#include <array>
-#include <atomic>
-#include <memory>
-#include <optional>
-#include <string>
-#include <vector>
-
-#include "DurationPredictor.h"
-#include "Partitioner.h"
-#include "Synthesizer.h"
-#include "Types.h"
-#include <phonemis/base/pipeline.h>
-#include <rnexecutorch/metaprogramming/ConstructorHelpers.h>
-
-namespace rnexecutorch {
-namespace models::text_to_speech::kokoro {
-
-class Kokoro {
-public:
-  Kokoro(const std::string &lang, const std::string &taggerDataSource,
-         const std::string &lexiconSource, const std::string &neuralModelSource,
-         const std::string &durationPredictorSource,
-         const std::string &synthesizerSource, const std::string &voiceSource,
-         std::shared_ptr<react::CallInvoker> callInvoker);
-
-  /**
-   * Generates complete audio for the provided text.
-   *
-   * @param text The input to be synthesized - either a raw text or IPA
-   * phonemes.
-   * @param speed Playback speed multiplier (default: 1.0).
-   * @param phonemize Optional, if set to false disables the phonemization and
-   * operates on raw input.
-   * @return A vector of PCM float samples representing the synthesized speech.
-   */
-  std::vector<float> generate(std::u32string input, float speed = 1.F,
-                              bool phonemize = true);
-
-  /**
-   * Starts an asynchronous streaming process that processes text in chunks.
-   * The internal buffer can be expanded during streaming using `streamInsert`.
-   *
-   * @param callback A JSI function called with each generated audio chunk
-   * (std::vector<float>).
-   * @param speed Playback speed multiplier.
-   * @param phonemize Optional, if set to false disables the phonemization and
-   * operates on raw input.
-   * @param stopOnEmptyBuffer If true, streaming terminates automatically when
-   * the buffer is exhausted.
-   */
-  void stream(std::shared_ptr<jsi::Function> callback, float speed = 1.F,
-              bool phonemize = true, bool stopOnEmptyBuffer = false);
-
-  /**
-   * Appends new input data (either text or phonemes) to the buffer.
-   *
-   * @param chunk A text/phonemes chunk to be added to the streaming buffer.
-   */
-  void streamInsert(std::u32string chunk) noexcept;
-
-  /**
-   * Requests the streaming loop to partition and synthesize whatever is
-   * currently buffered, even if no end-of-sentence character is present.
-   *
-   * Use after the last `streamInsert` of an utterance when you want trailing
-   * un-terminated content to play out without stopping the stream. LLM-style
-   * callers feeding partial tokens typically should not call this — the
-   * model's punctuation drives natural EOS partitioning.
-   */
-  void streamFlush() noexcept;
-
-  /**
-   * Signals the streaming process to stop.
-   *
-   * @param instant If true, stops immediately, discarding remaining buffered
-   * text. If false, drains the current buffer (force-flushing any trailing
-   * un-terminated content) before stopping — equivalent to `streamFlush()`
-   * followed by an automatic stop once the buffer empties.
-   */
-  void streamStop(bool instant) noexcept;
-
-  std::size_t getMemoryLowerBound() const noexcept;
-  void unload() noexcept;
-
-private:
-  // --- Initialization & Core Inference ---
-  void loadVoice(const std::string &voiceSource);
-  std::vector<float> synthesize(std::u32string_view phonemes, float speed,
-                                size_t paddingMs = 50);
-
-  // --- External Dependencies ---
-  std::shared_ptr<react::CallInvoker> callInvoker_;
-
-  // --- Model context ---
-  Context context_;
-
-  // --- Model Components ---
-  // Arranged in order of appearance in the generation pipeline
-  phonemis::Pipeline phonemizer_;
-  Partitioner partitioner_;
-  DurationPredictor durationPredictor_;
-  Synthesizer synthesizer_;
-
-  // --- Data Buffers ---
-  // Voice embeddings: Each row is a style vector for a given input token count
-  std::vector<std::array<float, constants::kVoiceRefSize>> voice_;
-  // Streaming buffer
-  std::u32string inputTextBuffer_;
-  mutable std::mutex inputTextBufferMutex_;
-
-  // --- Streaming control State ---
-  std::atomic<bool> isStreaming_{false};
-  std::atomic<bool> stopOnEmptyBuffer_{true};
-  // Set by `streamFlush()` or `streamStop(false)`. While true, the stream
-  // loop force-extracts the entire searchable window even when no EOS is
-  // present. Cleared once the buffer drains so subsequent inserts go back to
-  // EOS-aligned chunking.
-  std::atomic<bool> flushPending_{false};
-};
-} // namespace models::text_to_speech::kokoro
-
-REGISTER_CONSTRUCTOR(models::text_to_speech::kokoro::Kokoro, std::string,
-                     std::string, std::string, std::string, std::string,
-                     std::string, std::string,
-                     std::shared_ptr<react::CallInvoker>);
-
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Params.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Params.h
deleted file mode 100644
index 5f61287f02..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Params.h
+++ /dev/null
@@ -1,102 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <unordered_map>
-
-/**
- * Hyperparameters
- *
- * Those are adjustable values, which when changed, affect the behavior
- * of the underlying models and/or algorithms.
- */
-namespace rnexecutorch::models::text_to_speech::kokoro::params {
-
-/**
- * Causes an exception to be thrown on input texts longer
- * (in terms of number of characters) than this value.
- *
- * Note that the partitioning algorithm theoreticaly allows for
- * any input length to be processed, so using this parameter is optional.
- */
-inline constexpr size_t kMaxTextSize = 2048;
-
-/**
- * A size of pause (in miliseconds) applied after each streaming iteration.
- */
-inline constexpr int32_t kStreamPause = 200;
-
-/**
- * A set of punctation - pause values. Determines how much pause (silence) is
- * being added at the end of each calculated audio vector. This is primarly used
- * when the input text is partitioned for subsentences, to make the pause
- * between subsentences feel natural. Pause values are measured in miliseconds
- * (ms).
- */
-inline const std::unordered_map<char32_t, int32_t> kPauseValues = {
-    {U'.', 375}, {U'?', 500}, {U'!', 250}, {U';', 400}, {U'…', 600}, // Ellipsis
-    {U',', 130}, {U':', 250}, {U'-', 200}, {U'—', 250}, // Em Dash (slightly
-                                                        // longer than hyphen)
-    {U'|', 375}, // ASCII Pipe (treated as full stop)
-    {U'।', 375}, // Hindi Purna Viram
-    {U'॥', 500}, // Hindi Deergh Viram (typically longer than Purna Viram)
-    {U'¿', 50},  // Spanish Inverted Question Mark (short preparatory pause)
-    {U'¡', 50},  // Spanish Inverted Exclamation Mark (short preparatory pause)
-    {U'«', 50},  // Guillemet open (short pause)
-    {U'»', 100}, // Guillemet close (short pause)
-}; // [ms]
-
-/**
- * A default pause applied after a sentence finished with a character other
- * than the ones defined in kPauseValues.
- */
-inline constexpr int32_t kDefaultPause = 0; // [ms]
-
-// Audio cropping related hyperparameters
-namespace cropping {
-/**
- * The audio cropping algorithm is a moving average variant.
- * This value controls the number of steps in moving average.
- */
-inline constexpr uint32_t kAudioCroppingSteps = 10;
-
-/**
- * Determines silent audio fragments in audio cropping algorithm.
- * The audio fragment is considered as a silence, if the moving average with K
- * steps does not exceed this threshold.
- */
-inline constexpr float kAudioSilenceThreshold = 0.005F;
-} // namespace cropping
-
-// Partitioning related hyperparameters
-namespace partitioning {
-/**
- * Used in latency-focused partitioning variant. Decides on
- * how much more are big latencies in the beginning phase of
- * an input text penalized.
- */
-inline constexpr int64_t kTokenDiscountFactor = 1;
-
-/**
- * Used in latency-focused partitioning variant. Decides on
- * how quickly latency penalties (linearly interpolated) evaporate
- * with each processed token.
- * For example, using kTokenDiscountRange = 128 means that after reaching
- * 128 tokens, the latency is completely omited and not penalized.
- */
-inline constexpr int64_t kTokenDiscountRange = 128;
-
-/**
- * A set of weights used by partition algorithm to penalize dividing sentences
- * on different breakpoints.
- */
-inline constexpr uint64_t kEosMinBreaksCost = 1;
-inline constexpr uint64_t kPauseMinBreaksCost = 3;
-inline constexpr uint64_t kWhiteMinBreaksCost = 1000;
-
-inline constexpr uint64_t kEosMinLatencyCost = 5;
-inline constexpr uint64_t kPauseMinLatencyCost = 18;
-inline constexpr uint64_t kWhiteMinLatencyCost = 1000;
-
-} // namespace partitioning
-
-} // namespace rnexecutorch::models::text_to_speech::kokoro::params
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Partitioner.cpp b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Partitioner.cpp
deleted file mode 100644
index d994d98d74..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Partitioner.cpp
+++ /dev/null
@@ -1,133 +0,0 @@
-#include "Partitioner.h"
-#include "Constants.h"
-#include "Params.h"
-
-#include <algorithm>
-#include <deque>
-#include <limits>
-#include <ranges>
-
-namespace rnexecutorch::models::text_to_speech::kokoro {
-
-using namespace params::partitioning;
-
-// Custom infinity definition
-constexpr Partitioner::Cost INF = 1e7;
-
-Partitioner::Partition Partitioner::partition(std::u32string_view input,
-                                              size_t limit, Mode mode) const {
-  if (mode == Mode::MIN_BREAKS) {
-    auto minBreakCostFn = [limit](Cost acc, size_t beg, int64_t prevBp,
-                                  int64_t bp, size_t end,
-                                  Separator sep) -> Cost {
-      if (end - bp > limit) {
-        return INF;
-      }
-
-      Cost sepPenalty = sep == Separator::EOS     ? kEosMinBreaksCost
-                        : sep == Separator::PAUSE ? kPauseMinBreaksCost
-                        : sep == Separator::WHITE ? kWhiteMinBreaksCost
-                                                  : 0;
-
-      return acc + sepPenalty + static_cast<Cost>(end - bp);
-    };
-
-    return partition(input, limit, minBreakCostFn);
-  }
-
-  if (mode == Mode::MIN_LATENCY) {
-    auto minLatencyCostFn = [limit](Cost acc, size_t beg, int64_t prevBp,
-                                    int64_t bp, size_t end,
-                                    Separator sep) -> Cost {
-      if (end - bp > limit) {
-        return INF;
-      }
-
-      Cost sepPenalty = sep == Separator::EOS     ? kEosMinLatencyCost
-                        : sep == Separator::PAUSE ? kPauseMinLatencyCost
-                        : sep == Separator::WHITE ? kWhiteMinLatencyCost
-                                                  : 0;
-
-      int64_t rightmostRangeLength = end - bp;
-      int64_t prevRangeLength = bp - prevBp;
-
-      int64_t latency = std::max(static_cast<int64_t>(0),
-                                 rightmostRangeLength - prevRangeLength);
-      int64_t discount =
-          kTokenDiscountFactor *
-          std::max(static_cast<int64_t>(0), kTokenDiscountRange - bp - 1);
-
-      return acc + static_cast<Cost>(latency * discount / kTokenDiscountRange) +
-             sepPenalty;
-    };
-
-    return partition(input, limit, minLatencyCostFn);
-  }
-
-  return {input, {}};
-}
-
-Partitioner::Partition Partitioner::partition(std::u32string_view input,
-                                              size_t limit,
-                                              CostFn costFn) const {
-  if (input.empty()) {
-    return {input, {}};
-  }
-
-  size_t n = input.size();
-  std::vector<std::pair<Cost, int64_t>> dp(n, {INF, -1});
-
-  std::deque<size_t> eosPoints, pausePoints, whitePoints;
-
-  for (size_t i = 0; i < n; ++i) {
-    auto &[bestCost, prevBpIdx] = dp[i];
-
-    bestCost = costFn(0, 0, -1, -1, i + 1, Separator::NO_SEP);
-
-    for (auto *q : {&eosPoints, &pausePoints, &whitePoints}) {
-      while (!q->empty() && q->front() + limit < i) {
-        q->pop_front();
-      }
-
-      Separator sep = q == &eosPoints     ? Separator::EOS
-                      : q == &pausePoints ? Separator::PAUSE
-                                          : Separator::WHITE;
-      for (size_t breakIdx : (*q)) {
-        auto cost = costFn(dp[breakIdx].first, 0, dp[breakIdx].second, breakIdx,
-                           i, sep);
-        if (cost < bestCost && breakIdx > 0) {
-          bestCost = cost;
-          prevBpIdx = breakIdx;
-        }
-      }
-    }
-
-    char32_t c = input[i];
-    if (constants::kEndOfSentenceCharacters.contains(c)) {
-      eosPoints.push_back(i);
-    } else if (constants::kPauseCharacters.contains(c)) {
-      pausePoints.push_back(i);
-    } else if (c < 256 && std::isspace(static_cast<char>(c))) {
-      whitePoints.push_back(i);
-    }
-  }
-
-  std::vector<std::pair<size_t, size_t>> segments;
-  int64_t currBp = dp.back().second;
-  size_t lastIdx = n;
-
-  while (currBp != -1) {
-    size_t start = static_cast<size_t>(currBp + 1);
-    segments.emplace_back(start, lastIdx - start);
-    lastIdx = currBp + 1;
-    currBp = dp[currBp].second;
-  }
-  // Add the first segment
-  segments.emplace_back(0, lastIdx);
-
-  std::ranges::reverse(segments);
-
-  return {input, std::move(segments)};
-}
-
-} // namespace rnexecutorch::models::text_to_speech::kokoro
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Partitioner.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Partitioner.h
deleted file mode 100644
index 93f2b97c84..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Partitioner.h
+++ /dev/null
@@ -1,88 +0,0 @@
-#pragma once
-
-#include "Types.h"
-
-#include <cstdint>
-#include <functional>
-#include <optional>
-#include <string>
-#include <vector>
-
-namespace rnexecutorch::models::text_to_speech::kokoro {
-
-class Partitioner {
-public:
-  /**
-   * Partitioning strategy.
-   * Affects the cost function choice, which changes the way input text is
-   * divided.
-   */
-  enum class Mode {
-    MIN_BREAKS = 0, // Minimizes number of substrings (best quality)
-    MIN_LATENCY =
-        1, // Minimizes the processing latency (best speed - streaming mode)
-  };
-
-  /**
-   * Represents the logical separator types.
-   */
-  enum class Separator {
-    EOS = 1, // End of sentence marker (e.g., '.', '!', '?').
-    PAUSE,   // Mid-sentence pause (e.g., ',', ';', ':').
-    WHITE,   // Whitespace or other weak separators.
-
-    NO_SEP // No separation
-  };
-
-  /**
-   * Represents a heuristic evaluation of given partition.
-   * The lower it is, the better partition is.
-   */
-  using Cost = uint64_t;
-
-  /**
-   * A cost function type to evaluate given partition.
-   *
-   * @param acc Total cost accumulated from previous segments.
-   * @param beg Start index of the current range.
-   * @param prevBp Previous breakpoint index - useful for calculating some
-   * formulas.
-   * @param bp Breakpoint index (the split point, and the last character of the
-   * left-most subrange). -1 if there are no bps.
-   * @param end End index of the current range (inclusive).
-   * @param sep The type of the breakpoint.
-   */
-  using CostFn = std::function<Cost(Cost acc, size_t beg, int64_t prevBp,
-                                    int64_t bp, size_t end, Separator sep)>;
-
-  /**
-   * Holds the result of text partitioning.
-   * The content is stored as logical views to avoid copying. Segments
-   * defines ranges of the content views for smaller segments.
-   */
-  struct Partition {
-    std::u32string_view content;
-    std::vector<std::pair<size_t, size_t>>
-        segments; // Pairs of {offset, length} for each segment.
-  };
-
-  /**
-   * Partitions the input text into segments according to the specified
-   * strategy.
-   *
-   * @param input The source text to be partitioned.
-   * @param limit The maximum available size of a single segment.
-   * @param mode The partitioning strategy to use (defaults to MIN_LATENCY).
-   * @return A Partition object containing the original content view and
-   * breakpoints.
-   */
-  Partition partition(std::u32string_view input, size_t limit,
-                      Mode mode = Mode::MIN_LATENCY) const;
-
-private:
-  // Internal partition implementation that uses a specific cost function.
-  Partition partition(std::u32string_view input, size_t limit,
-                      CostFn costFn) const;
-};
-
-} // namespace rnexecutorch::models::text_to_speech::kokoro
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Synthesizer.cpp b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Synthesizer.cpp
deleted file mode 100644
index 9029759caf..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Synthesizer.cpp
+++ /dev/null
@@ -1,113 +0,0 @@
-#include "Synthesizer.h"
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/Log.h>
-#include <rnexecutorch/metaprogramming/ContainerHelpers.h>
-
-#include <algorithm>
-#include <ranges>
-#include <utility>
-
-namespace rnexecutorch::models::text_to_speech::kokoro {
-
-using ::executorch::aten::ScalarType;
-using ::executorch::extension::make_tensor_ptr;
-using ::executorch::extension::TensorPtr;
-
-Synthesizer::Synthesizer(const std::string &modelSource,
-                         const Context &modelContext,
-                         std::shared_ptr<react::CallInvoker> callInvoker)
-    : BaseModel(modelSource, callInvoker), context_(modelContext) {
-  // Discover all forward methods (forward, forward_8, forward_32, etc.)
-  auto availableMethods = module_->method_names();
-  if (availableMethods.ok()) {
-    const auto &names = *availableMethods;
-    for (const auto &name : names) {
-      if (name.rfind("forward", 0) == 0) {
-        const auto inputTensors = getAllInputShapes(name);
-        CHECK_SIZE(inputTensors, 5);
-        CHECK_SIZE(inputTensors[0], 2);
-        CHECK_SIZE(inputTensors[1], 2);
-        CHECK_SIZE(inputTensors[2], 1);
-        size_t inputSize = inputTensors[0][1];
-        forwardMethods_.emplace_back(name, inputSize);
-      }
-    }
-    std::ranges::stable_sort(forwardMethods_, [](const auto &a, const auto &b) {
-      return a.second < b.second;
-    });
-  }
-
-  // Fallback: if no methods discovered, validate "forward" directly
-  if (forwardMethods_.empty()) {
-    const auto inputTensors = getAllInputShapes("forward");
-    CHECK_SIZE(inputTensors, 5);
-    CHECK_SIZE(inputTensors[0], 2);
-    CHECK_SIZE(inputTensors[1], 2);
-    CHECK_SIZE(inputTensors[2], 1);
-    forwardMethods_.emplace_back("forward", inputTensors[0][1]);
-  }
-}
-
-Result<std::vector<EValue>> Synthesizer::generate(std::span<Token> tokens,
-                                                  std::span<bool> textMask,
-                                                  std::span<int64_t> indices,
-                                                  std::span<float> dur,
-                                                  std::span<float> ref_s) {
-  // Perform input shape checks
-  // Both F0 and N vectors should be twice as long as duration
-  CHECK_SIZE(tokens, textMask.size());
-  CHECK_SIZE(ref_s, constants::kVoiceRefSize);
-
-  int32_t noTokens = tokens.size();
-  int32_t duration = indices.size();
-
-  // Convert input data to ExecuTorch tensors
-  auto tokensTensor = make_tensor_ptr({1, static_cast<int32_t>(tokens.size())},
-                                      tokens.data(), ScalarType::Long);
-  auto textMaskTensor =
-      make_tensor_ptr({1, static_cast<int32_t>(textMask.size())},
-                      textMask.data(), ScalarType::Bool);
-  auto indicesTensor =
-      make_tensor_ptr({duration}, indices.data(), ScalarType::Long);
-  auto durTensor =
-      make_tensor_ptr({1, noTokens, 640}, dur.data(), ScalarType::Float);
-  auto voiceRefTensor = make_tensor_ptr({1, constants::kVoiceRefSize},
-                                        ref_s.data(), ScalarType::Float);
-
-  // Select appropriate forward method based on token count
-  auto it =
-      std::ranges::find_if(forwardMethods_, [noTokens](const auto &entry) {
-        return std::cmp_greater_equal(entry.second, noTokens);
-      });
-  std::string selectedMethod =
-      (it != forwardMethods_.end()) ? it->first : forwardMethods_.back().first;
-
-  // Execute the selected forward method
-  auto results =
-      execute(selectedMethod, {tokensTensor, textMaskTensor, indicesTensor,
-                               durTensor, voiceRefTensor});
-
-  if (!results.ok()) {
-    throw RnExecutorchError(
-        RnExecutorchErrorCode::InvalidModelOutput,
-        "[Kokoro::Synthesizer] Failed to execute method " + selectedMethod +
-            ", error: " +
-            std::to_string(static_cast<uint32_t>(results.error())));
-  }
-
-  // Returns a single [audio] vector, which contains the
-  // resulting audio data in PCM (Pulse-Code Modulation) format.
-  return results;
-}
-
-size_t Synthesizer::getTokensLimit() const {
-  return forwardMethods_.empty() ? 0 : forwardMethods_.back().second;
-}
-
-size_t Synthesizer::getDurationLimit() const {
-  if (forwardMethods_.empty())
-    return 0;
-  return getInputShape(forwardMethods_.back().first, 2)[0];
-}
-
-} // namespace rnexecutorch::models::text_to_speech::kokoro
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Synthesizer.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Synthesizer.h
deleted file mode 100644
index c3a21957db..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Synthesizer.h
+++ /dev/null
@@ -1,61 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <span>
-#include <string>
-#include <vector>
-
-#include <executorch/extension/tensor/tensor.h>
-
-#include "Constants.h"
-#include "Types.h"
-#include <rnexecutorch/models/BaseModel.h>
-
-namespace rnexecutorch::models::text_to_speech::kokoro {
-
-/**
- * A module for synthesizing audio from scratch.
- *
- * As it stands for now, this module is designed to utilize only
- * dynamic input shape versions of exported Kokoro model.
- */
-class Synthesizer : public BaseModel {
-public:
-  explicit Synthesizer(const std::string &modelSource,
-                       const Context &modelContext,
-                       std::shared_ptr<react::CallInvoker> callInvoker);
-
-  /**
-   * Generates an audio vector in PCM (Pulse-Code Modulation) format for
-   * given input tokens and voice. Requires additional duration data obtained
-   * from DurarionPredictor.
-   *
-   * @param tokens tokenized input text (see utils::tokenize())
-   * @param textMask a boolean mask, marking real input with 1 and padded values
-   * with 0
-   * @param indices token indices array with shape (1 x d),
-   *                where d corresponds to calculated duration, obtained from
-   * DurationPredictor module
-   * @param dur duration values, obtained from DurationPredictor module
-   * @param ref_s a full voice array for given duration
-   */
-  Result<std::vector<EValue>> generate(std::span<Token> tokens,
-                                       std::span<bool> textMask,
-                                       std::span<int64_t> indices,
-                                       std::span<float> dur,
-                                       std::span<float> ref_s);
-
-  // Model limits getters
-  size_t getTokensLimit() const;
-  size_t getDurationLimit() const;
-
-private:
-  // Forward methods discovered at construction (e.g. forward_8, forward_64,
-  // forward_128)
-  std::vector<std::pair<std::string, size_t>> forwardMethods_;
-  // Shared model context
-  // A const reference to singleton in Kokoro.
-  const Context &context_;
-};
-
-} // namespace rnexecutorch::models::text_to_speech::kokoro
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Types.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Types.h
deleted file mode 100644
index 8a99dc09c8..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Types.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#pragma once
-
-#include <cstddef>
-#include <cstdint>
-
-namespace rnexecutorch::models::text_to_speech::kokoro {
-
-// Type definitions - model input tokens
-using Token = int64_t;
-
-/**
- * Type definition - model shared context
- *
- * Defines values shared between Kokoro submodules.
- */
-struct Context {
-  size_t inputTokensLimit = 0;
-  size_t inputDurationLimit = 0;
-};
-
-/**
- * Type definition - token timestamp.
- *
- * Values correspond to the amount of waveform samples.
- */
-struct Timestamp {
-  size_t begin = 0;
-  size_t end = 0;
-};
-
-} // namespace rnexecutorch::models::text_to_speech::kokoro
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Utils.cpp b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Utils.cpp
deleted file mode 100644
index f1bf7f8d4d..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Utils.cpp
+++ /dev/null
@@ -1,107 +0,0 @@
-#include "Utils.h"
-#include "Constants.h"
-#include "Params.h"
-#include <rnexecutorch/Error.h>
-
-#include <algorithm>
-#include <cmath>
-
-namespace rnexecutorch::models::text_to_speech::kokoro::utils {
-
-using namespace params::cropping;
-
-namespace {
-
-float normalize(float sample) {
-  return std::max(0.0F, std::abs(sample) - kAudioSilenceThreshold);
-}
-
-template <bool reverse> size_t findAudioBound(std::span<const float> audio) {
-  if (audio.empty()) {
-    return 0;
-  }
-
-  const size_t length = audio.size();
-  float windowSum = 0.0F;
-  size_t processedCount = 0;
-  size_t currentIndex = reverse ? length - 1 : 0;
-
-  while (processedCount < length) {
-    processedCount++;
-    windowSum += normalize(audio[currentIndex]);
-
-    // Maintain the sliding window sum
-    if (processedCount > kAudioCroppingSteps) {
-      const size_t oldIndex = reverse ? currentIndex + kAudioCroppingSteps
-                                      : currentIndex - kAudioCroppingSteps;
-      windowSum -= normalize(audio[oldIndex]);
-    }
-
-    // Check if moving average exceeds threshold
-    if (processedCount >= kAudioCroppingSteps &&
-        (windowSum / kAudioCroppingSteps) >= kAudioSilenceThreshold) {
-      return currentIndex;
-    }
-
-    currentIndex += reverse ? -1 : 1;
-  }
-
-  return reverse ? 0 : length - 1;
-}
-
-} // namespace
-
-std::span<const float> stripAudio(std::span<const float> audio, size_t margin) {
-  if (audio.empty()) {
-    return {};
-  }
-
-  size_t lbound = findAudioBound<false>(audio);
-  size_t rbound = findAudioBound<true>(audio);
-
-  // Apply margins
-  lbound = (lbound > margin) ? lbound - margin : 0;
-  rbound = std::min(rbound + margin, audio.size() - 1);
-
-  const size_t strippedLength = (rbound >= lbound) ? (rbound - lbound + 1) : 0;
-  return audio.subspan(lbound, strippedLength);
-}
-
-std::vector<Token> tokenize(std::u32string_view phonemes,
-                            std::optional<size_t> expectedSize) {
-  if (expectedSize.has_value() && expectedSize.value() < 2) {
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidUserInput,
-                            "[Kokoro::Utils] Expected tokens must be >= 2");
-  }
-
-  // 1. Determine lengths (2 tokens reserved for start/end padding)
-  const size_t totalLength = expectedSize.value_or(phonemes.size() + 2);
-  const size_t maxPhonemes = totalLength - 2;
-  const size_t effectivePhonemeCount = std::min(maxPhonemes, phonemes.size());
-
-  // 2. Initialize with pad tokens
-  std::vector<Token> tokens(totalLength, constants::kPadToken);
-
-  // 3. Map phonemes to vocabulary tokens
-  // Starting from index 1 to leave index 0 as start-padding
-  std::transform(phonemes.begin(), phonemes.begin() + effectivePhonemeCount,
-                 tokens.begin() + 1, [](char32_t p) -> Token {
-                   return constants::kVocab.contains(p)
-                              ? constants::kVocab.at(p)
-                              : constants::kInvalidToken;
-                 });
-
-  // 4. Remove invalid tokens while preserving order (bubbling them to the end
-  // of the content segment)
-  auto validEnd = std::stable_partition(
-      tokens.begin() + 1, tokens.begin() + effectivePhonemeCount + 1,
-      [](Token t) { return t != constants::kInvalidToken; });
-
-  // 5. Fill any gaps created by partitioning or sizing with pad tokens
-  std::fill(validEnd, tokens.begin() + effectivePhonemeCount + 1,
-            constants::kPadToken);
-
-  return tokens;
-}
-
-} // namespace rnexecutorch::models::text_to_speech::kokoro::utils
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Utils.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Utils.h
deleted file mode 100644
index c6996a3f40..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Utils.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#pragma once
-
-#include "Types.h"
-#include <optional>
-#include <span>
-#include <string>
-#include <vector>
-
-namespace rnexecutorch::models::text_to_speech::kokoro::utils {
-
-/**
- * Strips silence from audio edges using a sliding window.
- * @param audio The input audio samples.
- * @param margin Number of silence samples to preserve at each edge.
- */
-std::span<const float> stripAudio(std::span<const float> audio,
-                                  size_t margin = 0);
-
-/**
- * Maps phonemes to vocabulary tokens with start/end padding.
- * @param phonemes UTF-32 phoneme sequence.
- * @param expectedSize If set, pads the output to this exact length.
- */
-std::vector<Token> tokenize(std::u32string_view phonemes,
-                            std::optional<size_t> expectedSize = std::nullopt);
-
-} // namespace rnexecutorch::models::text_to_speech::kokoro::utils
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/vertical_ocr/VerticalDetector.cpp b/packages/react-native-executorch/common/rnexecutorch/models/vertical_ocr/VerticalDetector.cpp
deleted file mode 100644
index 10fe8bfc35..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/vertical_ocr/VerticalDetector.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-#include "VerticalDetector.h"
-
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/data_processing/ImageProcessing.h>
-#include <rnexecutorch/models/ocr/Constants.h>
-#include <rnexecutorch/models/ocr/utils/DetectorUtils.h>
-
-#include <executorch/extension/tensor/tensor_ptr.h>
-#include <string>
-
-namespace rnexecutorch::models::ocr {
-VerticalDetector::VerticalDetector(
-    const std::string &modelSource,
-    std::shared_ptr<react::CallInvoker> callInvoker)
-    : Detector(modelSource, callInvoker) {};
-
-std::vector<types::DetectorBBox>
-VerticalDetector::generate(const cv::Mat &inputImage, int32_t inputWidth) {
-
-  bool detectSingleCharacters =
-      !(inputWidth >= constants::kMediumDetectorWidth);
-
-  utils::validateInputWidth(inputWidth, constants::kDetectorInputWidths,
-                            "VerticalDetector");
-
-  std::string methodName = "forward_" + std::to_string(inputWidth);
-  auto inputShapes = getAllInputShapes(methodName);
-
-  cv::Size modelInputSize = calculateModelImageSize(inputWidth);
-
-  cv::Mat resizedInputImage =
-      image_processing::resizePadded(inputImage, modelInputSize);
-  TensorPtr inputTensor = image_processing::getTensorFromMatrix(
-      inputShapes[0], resizedInputImage, constants::kNormalizationMean,
-      constants::kNormalizationVariance);
-  auto forwardResult = BaseModel::execute(methodName, {inputTensor});
-
-  CHECK_OK_OR_THROW_FORWARD_ERROR(forwardResult);
-  return postprocess(forwardResult->at(0).toTensor(),
-                     calculateModelImageSize(inputWidth),
-                     detectSingleCharacters);
-}
-
-std::vector<types::DetectorBBox>
-VerticalDetector::postprocess(const Tensor &tensor,
-                              const cv::Size &modelInputSize,
-                              bool detectSingleCharacters) const {
-  /*
-   The output of the model consists of two matrices (heat maps):
-   1. ScoreText(Score map) - The probability of a region containing character.
-   2. ScoreAffinity(Affinity map) - affinity between characters, used to to
-   group each character into a single instance (sequence) Both matrices are
-   H/2xW/2.
-
-   The result of this step is a list of bounding boxes that contain text.
-   */
-  std::span<const float> tensorData(tensor.const_data_ptr<float>(),
-                                    tensor.numel());
-  /*
-   The output of the model is a matrix half the size of the input image
-   containing two channels representing the heatmaps.
-   */
-  auto [scoreTextMat, scoreAffinityMat] = utils::interleavedArrayToMats(
-      tensorData,
-      cv::Size(modelInputSize.width / 2, modelInputSize.height / 2));
-  float txtThreshold = detectSingleCharacters
-                           ? constants::kTextThreshold
-                           : constants::kTextThresholdVertical;
-  std::vector<types::DetectorBBox> bBoxesList =
-      utils::getDetBoxesFromTextMapVertical(
-          scoreTextMat, scoreAffinityMat, txtThreshold,
-          constants::kLinkThreshold, detectSingleCharacters);
-  const float restoreRatio = utils::calculateRestoreRatio(
-      scoreTextMat.rows, constants::kRecognizerImageSize);
-  utils::restoreBboxRatio(bBoxesList, restoreRatio);
-
-  // if this is Narrow Detector, do not group boxes.
-  if (!detectSingleCharacters) {
-    bBoxesList = utils::groupTextBoxes(
-        bBoxesList, constants::kCenterThreshold, constants::kDistanceThreshold,
-        constants::kHeightThreshold, constants::kMinSideThreshold,
-        constants::kMaxSideThreshold, constants::kMaxWidth);
-  }
-
-  return bBoxesList;
-}
-
-} // namespace rnexecutorch::models::ocr
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/vertical_ocr/VerticalDetector.h b/packages/react-native-executorch/common/rnexecutorch/models/vertical_ocr/VerticalDetector.h
deleted file mode 100644
index 34b79ce33a..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/vertical_ocr/VerticalDetector.h
+++ /dev/null
@@ -1,50 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <executorch/extension/tensor/tensor_ptr.h>
-#include <opencv2/opencv.hpp>
-#include <rnexecutorch/models/BaseModel.h>
-#include <rnexecutorch/models/ocr/Detector.h>
-#include <rnexecutorch/models/ocr/Types.h>
-
-namespace rnexecutorch::models::ocr {
-
-/*
- Vertical Detector is an sligtly modified Detector tuned for detecting Vertical
- text. For more details about standard detector, refer to the file
- ocr/Detector.cpp.
-
-  In Vertical OCR pipeline we make use of Detector two times:
-
-  1. Large Detector through forward_1280 method -- The differences between
- Detector used in standard OCR and Large Detector used in Vertical OCR is: a) To
- obtain detected boxes from heeat maps it utilizes
- `getDetBoxesFromTextMapVertical()` function rather than
- 'getDetBoxesFromTextMap()`. Other than that, refer to the standard OCR
- Detector.
-
-  2. Narrow Detector through forward_320 method -- it is designed to detect a
- single characters bounding boxes. `getDetBoxesFromTextMapVertical()` function
- acts differently for Narrow Detector and different textThreshold Value is
- passed. Additionally, the grouping of detected boxes is completely omited.
-
-  Vertical Detector pipeline differentiate the Large Detector and Narrow
- Detector based on `detectSingleCharacters` flag passed to the constructor.
-*/
-
-using executorch::aten::Tensor;
-using executorch::extension::TensorPtr;
-
-class VerticalDetector final : public Detector {
-public:
-  explicit VerticalDetector(const std::string &modelSource,
-                            std::shared_ptr<react::CallInvoker> callInvoker);
-  std::vector<types::DetectorBBox> generate(const cv::Mat &inputImage,
-                                            int32_t inputWidth) override;
-
-private:
-  std::vector<types::DetectorBBox>
-  postprocess(const Tensor &tensor, const cv::Size &modelInputSize,
-              bool detectSingleCharacters) const;
-};
-} // namespace rnexecutorch::models::ocr
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/vertical_ocr/VerticalOCR.cpp b/packages/react-native-executorch/common/rnexecutorch/models/vertical_ocr/VerticalOCR.cpp
deleted file mode 100644
index c0a531ecd3..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/vertical_ocr/VerticalOCR.cpp
+++ /dev/null
@@ -1,226 +0,0 @@
-#include "VerticalOCR.h"
-#include <algorithm>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-#include <rnexecutorch/data_processing/ImageProcessing.h>
-#include <rnexecutorch/data_processing/Numerical.h>
-#include <rnexecutorch/models/ocr/Constants.h>
-#include <rnexecutorch/models/ocr/Types.h>
-#include <rnexecutorch/utils/FrameProcessor.h>
-#include <rnexecutorch/utils/FrameTransform.h>
-#include <tuple>
-
-namespace rnexecutorch::models::ocr {
-VerticalOCR::VerticalOCR(const std::string &detectorSource,
-                         const std::string &recognizerSource,
-                         std::string symbols, bool independentChars,
-                         std::shared_ptr<react::CallInvoker> invoker)
-    : detector(detectorSource, invoker), recognizer(recognizerSource, invoker),
-      converter(symbols), independentCharacters(independentChars),
-      callInvoker(invoker) {}
-
-std::vector<types::OCRDetection> VerticalOCR::runInference(cv::Mat image) {
-  std::scoped_lock lock(inference_mutex_);
-
-  // 1. Large Detector
-  std::vector<types::DetectorBBox> largeBoxes =
-      detector.generate(image, constants::kLargeDetectorWidth);
-
-  cv::Size largeDetectorSize =
-      detector.calculateModelImageSize(constants::kLargeDetectorWidth);
-  cv::Mat resizedImage =
-      image_processing::resizePadded(image, largeDetectorSize);
-  types::PaddingInfo imagePaddings =
-      utils::calculateResizeRatioAndPaddings(image.size(), largeDetectorSize);
-
-  std::vector<types::OCRDetection> predictions;
-  predictions.reserve(largeBoxes.size());
-
-  for (auto &box : largeBoxes) {
-    predictions.push_back(
-        _processSingleTextBox(box, image, resizedImage, imagePaddings));
-  }
-
-  return predictions;
-}
-
-std::vector<types::OCRDetection>
-VerticalOCR::generateFromString(std::string input) {
-  cv::Mat image = image_processing::readImage(input);
-  if (image.empty()) {
-    throw RnExecutorchError(RnExecutorchErrorCode::FileReadFailed,
-                            "Failed to load image from path: " + input);
-  }
-  return runInference(image);
-}
-
-std::vector<types::OCRDetection>
-VerticalOCR::generateFromFrame(jsi::Runtime &runtime,
-                               const jsi::Value &frameData) {
-  auto orient = ::rnexecutorch::utils::readFrameOrientation(runtime, frameData);
-  cv::Mat frame = ::rnexecutorch::utils::frameToMat(runtime, frameData);
-  cv::Mat bgr;
-#ifdef __APPLE__
-  cv::cvtColor(frame, bgr, cv::COLOR_BGRA2BGR);
-#elif defined(__ANDROID__)
-  cv::cvtColor(frame, bgr, cv::COLOR_RGBA2BGR);
-#else
-  throw RnExecutorchError(
-      RnExecutorchErrorCode::PlatformNotSupported,
-      "generateFromFrame is not supported on this platform");
-#endif
-  cv::Mat rotated = ::rnexecutorch::utils::rotateFrameForModel(bgr, orient);
-  auto detections = runInference(rotated);
-  for (auto &det : detections) {
-    std::array<types::Point, 2> corners = {det.bbox.p1, det.bbox.p2};
-    ::rnexecutorch::utils::inverseRotatePoints(corners, orient, rotated.size());
-    det.bbox = {{std::min(corners[0].x, corners[1].x),
-                 std::min(corners[0].y, corners[1].y)},
-                {std::max(corners[0].x, corners[1].x),
-                 std::max(corners[0].y, corners[1].y)}};
-  }
-  return detections;
-}
-
-std::vector<types::OCRDetection>
-VerticalOCR::generateFromPixels(JSTensorViewIn pixelData) {
-  cv::Mat image;
-  cv::cvtColor(::rnexecutorch::utils::pixelsToMat(pixelData), image,
-               cv::COLOR_RGB2BGR);
-  return runInference(image);
-}
-
-std::size_t VerticalOCR::getMemoryLowerBound() const noexcept {
-  return detector.getMemoryLowerBound() + recognizer.getMemoryLowerBound();
-}
-
-// Strategy 1: Recognize each character individually
-std::pair<std::string, float> VerticalOCR::_handleIndependentCharacters(
-    const types::DetectorBBox &box, const cv::Mat &originalImage,
-    const std::vector<types::DetectorBBox> &characterBoxes,
-    const types::PaddingInfo &paddingsBox,
-    const types::PaddingInfo &imagePaddings) {
-  std::string text;
-  float confidenceScore = 0.0f;
-  float totalScore = 0.0f;
-  for (const auto &characterBox : characterBoxes) {
-
-    /*
-     Prepare for Recognition by following steps:
-     1. Crop image to the character bounding box,
-     2. Convert Image to gray.
-     3. Resize it to [VerticalSmallRecognizerWidth x RecognizerHeight] (64 x
-     64),
-    */
-    auto croppedChar = utils::prepareForRecognition(
-        originalImage, characterBox.bbox, box.bbox, paddingsBox, imagePaddings);
-
-    /*
-     To make Recognition simpler, we convert cropped character image
-     to a bit mask with white character and black background.
-    */
-    croppedChar = utils::characterBitMask(croppedChar);
-    croppedChar = utils::normalizeForRecognizer(
-        croppedChar, constants::kRecognizerHeight, 0.0, true);
-
-    const auto &[predIndex, score] =
-        recognizer.generate(croppedChar, constants::kRecognizerHeight);
-    if (!predIndex.empty()) {
-      text += converter.decodeGreedy(predIndex, predIndex.size())[0];
-    }
-    totalScore += score;
-  }
-  confidenceScore = totalScore / characterBoxes.size();
-  return {text, confidenceScore};
-}
-
-// Strategy 2: Concatenate characters and recognize as a single line
-std::pair<std::string, float> VerticalOCR::_handleJointCharacters(
-    const types::DetectorBBox &box, const cv::Mat &originalImage,
-    const std::vector<types::DetectorBBox> &characterBoxes,
-    const types::PaddingInfo &paddingsBox,
-    const types::PaddingInfo &imagePaddings) {
-  std::string text;
-  std::vector<cv::Mat> croppedCharacters;
-  croppedCharacters.reserve(characterBoxes.size());
-  for (const auto &characterBox : characterBoxes) {
-    /*
-     Prepare for Recognition by following steps:
-     1. Crop image to the character bounding box,
-     2. Convert Image to gray.
-     3. Resize it to [kSmallVerticalRecognizerWidth x kRecognizerHeight] (64 x
-     64). The same height is required for horizontal concatenation of single
-     characters into one image.
-    */
-    auto croppedChar = utils::prepareForRecognition(
-        originalImage, characterBox.bbox, box.bbox, paddingsBox, imagePaddings);
-    croppedCharacters.push_back(croppedChar);
-  }
-
-  cv::Mat mergedCharacters;
-  cv::hconcat(croppedCharacters, mergedCharacters);
-  mergedCharacters = image_processing::resizePadded(
-      mergedCharacters,
-      cv::Size(constants::kLargeRecognizerWidth, constants::kRecognizerHeight));
-  mergedCharacters = utils::normalizeForRecognizer(
-      mergedCharacters, constants::kRecognizerHeight, 0.0, false);
-
-  const auto &[predIndex, confidenceScore] =
-      recognizer.generate(mergedCharacters, constants::kLargeRecognizerWidth);
-  if (!predIndex.empty()) {
-    text = converter.decodeGreedy(predIndex, predIndex.size())[0];
-  }
-  return {text, confidenceScore};
-}
-
-types::OCRDetection VerticalOCR::_processSingleTextBox(
-    types::DetectorBBox &box, const cv::Mat &originalImage,
-    const cv::Mat &resizedLargeImage, const types::PaddingInfo &imagePaddings) {
-  cv::Rect boundingBox = utils::extractBoundingBox(box.bbox);
-
-  // Crop the image for detection of single characters.
-  cv::Rect safeRect =
-      boundingBox & cv::Rect(0, 0, resizedLargeImage.cols,
-                             resizedLargeImage.rows); // ensure valid box
-  cv::Mat croppedLargeBox = resizedLargeImage(safeRect);
-
-  // 2. Narrow Detector - detects single characters
-  std::vector<types::DetectorBBox> characterBoxes =
-      detector.generate(croppedLargeBox, constants::kSmallDetectorWidth);
-
-  std::string text;
-  float confidenceScore = 0.0;
-  if (!characterBoxes.empty()) {
-    // Prepare information useful for proper boxes shifting and image cropping.
-    const int32_t boxWidth = static_cast<int32_t>(box.bbox.width());
-    const int32_t boxHeight = static_cast<int32_t>(box.bbox.height());
-    cv::Size narrowRecognizerSize =
-        detector.calculateModelImageSize(constants::kSmallDetectorWidth);
-    types::PaddingInfo paddingsBox = utils::calculateResizeRatioAndPaddings(
-        cv::Size(boxWidth, boxHeight), narrowRecognizerSize);
-
-    // 3. Recognition - decide between Strategy 1 and Strategy 2.
-    std::tie(text, confidenceScore) =
-        independentCharacters
-            ? _handleIndependentCharacters(box, originalImage, characterBoxes,
-                                           paddingsBox, imagePaddings)
-            : _handleJointCharacters(box, originalImage, characterBoxes,
-                                     paddingsBox, imagePaddings);
-  }
-  // Modify the returned boxes to match the original image size.
-  const float ratio = imagePaddings.resizeRatio;
-  const float padLeft = static_cast<float>(imagePaddings.left);
-  const float padTop = static_cast<float>(imagePaddings.top);
-  types::BBox transformedBbox{
-      {(box.bbox.p1.x - padLeft) * ratio, (box.bbox.p1.y - padTop) * ratio},
-      {(box.bbox.p2.x - padLeft) * ratio, (box.bbox.p2.y - padTop) * ratio}};
-
-  return {transformedBbox, text, confidenceScore};
-}
-
-void VerticalOCR::unload() noexcept {
-  std::scoped_lock lock(inference_mutex_);
-  detector.unload();
-  recognizer.unload();
-}
-} // namespace rnexecutorch::models::ocr
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/vertical_ocr/VerticalOCR.h b/packages/react-native-executorch/common/rnexecutorch/models/vertical_ocr/VerticalOCR.h
deleted file mode 100644
index 4016e28138..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/vertical_ocr/VerticalOCR.h
+++ /dev/null
@@ -1,92 +0,0 @@
-#pragma once
-
-#include <executorch/extension/tensor/tensor_ptr.h>
-#include <mutex>
-#include <opencv2/opencv.hpp>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
-#include <rnexecutorch/host_objects/JSTensorViewIn.h>
-#include <rnexecutorch/models/BaseModel.h>
-#include <rnexecutorch/models/ocr/CTCLabelConverter.h>
-#include <rnexecutorch/models/ocr/Recognizer.h>
-#include <rnexecutorch/models/ocr/utils/DetectorUtils.h>
-#include <rnexecutorch/models/ocr/utils/RecognitionHandlerUtils.h>
-#include <rnexecutorch/models/ocr/utils/RecognizerUtils.h>
-#include <rnexecutorch/models/vertical_ocr/VerticalDetector.h>
-
-namespace rnexecutorch {
-namespace models::ocr {
-
-/*
-  Vertical OCR is OCR designed to handle vertical texts.
-  Vertical OCR pipeline consists of:
-  1. Detector using forward_1280 method-- detects regions where text is located.
-     Almost identical to the Detector in standard OCR.
-     The result of this phase is a list of bounding boxes.
-  Each detected box is then processed individually through the following steps:
-    2. Detector using forward_320 method -- designed for detecting where single
-  characters are located. There are two different strategies used for vertical
-  recognition: Strategy 1 "Independent Characters": Treating each character
-  region found  by Narrow Detector as compeletely independent.
-        3. Each character is forwarded to Recognizer with input size 64 x 64.
-      Strategy 2 "Joint Characters":
-        The bounding boxes found by Narrow Detector are
-        horizontally merged to create one wide image.
-        3. One wide image is forwarded to  Recognzer with input width of 512
-  x 64. Vertical OCR differentiate between those two strategies based on
-    `independentChars` flag passed to the constructor.
-*/
-
-using executorch::aten::Tensor;
-using executorch::extension::TensorPtr;
-
-class VerticalOCR final {
-public:
-  explicit VerticalOCR(const std::string &detectorSource,
-                       const std::string &recognizerSource, std::string symbols,
-                       bool indpendentCharacters,
-                       std::shared_ptr<react::CallInvoker> callInvoker);
-  [[nodiscard("Registered non-void function")]] std::vector<types::OCRDetection>
-  generateFromString(std::string input);
-  [[nodiscard("Registered non-void function")]] std::vector<types::OCRDetection>
-  generateFromFrame(jsi::Runtime &runtime, const jsi::Value &frameData);
-  [[nodiscard("Registered non-void function")]] std::vector<types::OCRDetection>
-  generateFromPixels(JSTensorViewIn pixelData);
-  std::size_t getMemoryLowerBound() const noexcept;
-  void unload() noexcept;
-
-private:
-  std::vector<types::OCRDetection> runInference(cv::Mat image);
-
-  std::pair<std::string, float> _handleIndependentCharacters(
-      const types::DetectorBBox &box, const cv::Mat &originalImage,
-      const std::vector<types::DetectorBBox> &characterBoxes,
-      const types::PaddingInfo &paddingsBox,
-      const types::PaddingInfo &imagePaddings);
-
-  std::pair<std::string, float>
-  _handleJointCharacters(const types::DetectorBBox &box,
-                         const cv::Mat &originalImage,
-                         const std::vector<types::DetectorBBox> &characterBoxes,
-                         const types::PaddingInfo &paddingsBox,
-                         const types::PaddingInfo &imagePaddings);
-  types::OCRDetection
-  _processSingleTextBox(types::DetectorBBox &box, const cv::Mat &originalImage,
-                        const cv::Mat &resizedLargeImage,
-                        const types::PaddingInfo &imagePaddings);
-
-  VerticalDetector detector;
-  Recognizer recognizer;
-  CTCLabelConverter converter;
-  bool independentCharacters;
-  std::shared_ptr<react::CallInvoker> callInvoker;
-  mutable std::mutex inference_mutex_;
-};
-} // namespace models::ocr
-
-REGISTER_CONSTRUCTOR(models::ocr::VerticalOCR, std::string, std::string,
-                     std::string, bool, std::shared_ptr<react::CallInvoker>);
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/voice_activity_detection/Constants.h b/packages/react-native-executorch/common/rnexecutorch/models/voice_activity_detection/Constants.h
deleted file mode 100644
index a46947572f..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/voice_activity_detection/Constants.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#pragma once
-
-#include <bit>
-#include <cstddef>
-#include <cstdint>
-namespace rnexecutorch::models::voice_activity_detection::constants {
-
-inline constexpr uint32_t kSampleRate = 16000;
-inline constexpr uint32_t kSamplesPerMs = kSampleRate / 1000;
-inline constexpr auto kMsToSeconds = 0.001f;
-inline constexpr uint32_t kWindowSizeMs = 25;
-inline constexpr uint32_t kHopLengthMs = 10;
-inline constexpr auto kWindowSize =
-    static_cast<uint32_t>(kMsToSeconds * kWindowSizeMs * kSampleRate); // 400
-inline constexpr auto kHopLength =
-    static_cast<uint32_t>(kMsToSeconds * kHopLengthMs * kSampleRate); // 160
-inline constexpr auto kPreemphasisCoeff = 0.97f;
-inline constexpr auto kLeftPadding = (kWindowSize - 1) / 2;
-inline constexpr auto kRightPadding = kWindowSize / 2;
-inline constexpr auto kPaddedWindowSize = std::bit_ceil(kWindowSize); // 512
-inline constexpr size_t kModelInputMin = 100;
-inline constexpr size_t kModelInputMax = 1000;
-inline constexpr auto kSpeechThreshold = 0.6f;
-inline constexpr size_t kMinSpeechDurationMs = 250;
-inline constexpr size_t kMinSilenceDurationMs = 100;
-inline constexpr size_t kSpeechPadMs = 30;
-inline constexpr size_t kStreamBufferMaxSize = 10 * kSampleRate; // 10s
-inline constexpr size_t kStreamBufferMinReserve =
-    1 * kSampleRate; // 1s of audio
-
-} // namespace rnexecutorch::models::voice_activity_detection::constants
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/voice_activity_detection/Types.h b/packages/react-native-executorch/common/rnexecutorch/models/voice_activity_detection/Types.h
deleted file mode 100644
index 51794d6bf5..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/voice_activity_detection/Types.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-#include <cstddef>
-
-namespace rnexecutorch::models::voice_activity_detection::types {
-
-struct Segment {
-  size_t start;
-  size_t end;
-};
-
-} // namespace rnexecutorch::models::voice_activity_detection::types
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/voice_activity_detection/Utils.cpp b/packages/react-native-executorch/common/rnexecutorch/models/voice_activity_detection/Utils.cpp
deleted file mode 100644
index ff26372896..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/voice_activity_detection/Utils.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#include "Utils.h"
-#include "Types.h"
-
-#include <algorithm>
-
-namespace rnexecutorch::models::voice_activity_detection::utils {
-size_t getNonSpeechClassProbabilites(const executorch::aten::Tensor &tensor,
-                                     size_t numClass, size_t size,
-                                     std::vector<float> &resultVector,
-                                     size_t startIdx) {
-  const auto *rawData = tensor.const_data_ptr<float>();
-  for (size_t i = 0; i < size; i++) {
-    resultVector[startIdx + i] = rawData[numClass * i];
-  }
-  return startIdx + size;
-}
-
-std::vector<types::Segment>
-mergeSegments(const std::vector<types::Segment> &segments, size_t maxMergeGap) {
-  if (segments.empty()) {
-    return segments;
-  }
-
-  std::vector<types::Segment> mergedSegments;
-  mergedSegments.push_back(segments[0]);
-
-  for (size_t i = 1; i < segments.size(); ++i) {
-    auto &lastMerged = mergedSegments.back();
-    const auto &current = segments[i];
-
-    if (current.start < lastMerged.end ||
-        current.start - lastMerged.end <= maxMergeGap) {
-      lastMerged.end = std::max(lastMerged.end, current.end);
-    } else {
-      mergedSegments.push_back(current);
-    }
-  }
-
-  return mergedSegments;
-}
-
-} // namespace rnexecutorch::models::voice_activity_detection::utils
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/voice_activity_detection/Utils.h b/packages/react-native-executorch/common/rnexecutorch/models/voice_activity_detection/Utils.h
deleted file mode 100644
index 3ec8212448..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/voice_activity_detection/Utils.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#pragma once
-
-#include "Types.h"
-#include <cstddef>
-#include <executorch/extension/tensor/tensor.h>
-#include <vector>
-
-namespace rnexecutorch::models::voice_activity_detection::utils {
-size_t getNonSpeechClassProbabilites(const executorch::aten::Tensor &tensor,
-                                     size_t numClass, size_t size,
-                                     std::vector<float> &resultVector,
-                                     size_t startIdx);
-
-/**
- * Merges adjacent speech segments which are separated by a gap smaller than or
- * equal to the specified maximum merge gap.
- *
- * @param segments A collection of speech segments to be merged.
- * @param maxMergeGap The maximum allowed distance between two segments (in
- * samples) to qualify them for a merge.
- * @return A new collection containing the merged speech segments.
- */
-std::vector<types::Segment>
-mergeSegments(const std::vector<types::Segment> &segments, size_t maxMergeGap);
-
-} // namespace rnexecutorch::models::voice_activity_detection::utils
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/voice_activity_detection/VoiceActivityDetection.cpp b/packages/react-native-executorch/common/rnexecutorch/models/voice_activity_detection/VoiceActivityDetection.cpp
deleted file mode 100644
index 77c3a16cc8..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/voice_activity_detection/VoiceActivityDetection.cpp
+++ /dev/null
@@ -1,253 +0,0 @@
-#include "VoiceActivityDetection.h"
-#include "rnexecutorch/data_processing/dsp.h"
-#include "rnexecutorch/models/voice_activity_detection/Utils.h"
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-
-#include <algorithm>
-#include <array>
-#include <functional>
-#include <numeric>
-#include <thread>
-#include <vector>
-
-namespace rnexecutorch::models::voice_activity_detection {
-
-namespace ranges = std::ranges;
-using namespace constants;
-using executorch::aten::Tensor;
-using executorch::extension::TensorPtr;
-
-VoiceActivityDetection::VoiceActivityDetection(
-    const std::string &modelSource,
-    std::shared_ptr<react::CallInvoker> callInvoker)
-    : BaseModel(modelSource, callInvoker), callInvoker_(callInvoker) {
-  // Important - preallocate memory for the buffer to avoid any reallocations.
-  audioBuffer_.reserve(2 * constants::kStreamBufferMaxSize);
-}
-
-std::vector<types::Segment>
-VoiceActivityDetection::generate(std::span<float> waveform,
-                                 uint32_t mergeGap) const {
-  // Guard against small buffers to prevent underflow in preprocess
-  if (waveform.size() < kWindowSize) {
-    return {};
-  }
-
-  auto windowedInput = preprocess(waveform);
-  auto [chunksNumber, remainder] = std::div(
-      static_cast<int>(windowedInput.size()), static_cast<int>(kModelInputMax));
-  std::vector<float> scores(windowedInput.size());
-  auto lastChunkSize = remainder;
-  if (remainder < kModelInputMin) {
-    auto paddingSize = kModelInputMin - remainder;
-    lastChunkSize = kModelInputMin;
-    windowedInput.insert(windowedInput.end(), paddingSize,
-                         std::array<float, kPaddedWindowSize>{});
-  }
-  TensorPtr inputTensor;
-  size_t startIdx = 0;
-
-  for (size_t i = 0; i < chunksNumber; i++) {
-    std::span<std::array<float, kPaddedWindowSize>> chunk(
-        windowedInput.data() + kModelInputMax * i, kModelInputMax);
-    inputTensor = executorch::extension::from_blob(
-        chunk.data(), {kModelInputMax, kPaddedWindowSize},
-        executorch::aten::ScalarType::Float);
-    auto forwardResult = BaseModel::forward(inputTensor);
-    CHECK_OK_OR_THROW_FORWARD_ERROR(forwardResult);
-    auto tensor = forwardResult->at(0).toTensor();
-    startIdx = utils::getNonSpeechClassProbabilites(
-        tensor, tensor.size(2), tensor.size(1), scores, startIdx);
-  }
-
-  std::span<std::array<float, kPaddedWindowSize>> lastChunk(
-      windowedInput.data() + kModelInputMax * chunksNumber, lastChunkSize);
-  inputTensor = executorch::extension::from_blob(
-      lastChunk.data(), {lastChunkSize, kPaddedWindowSize},
-      executorch::aten::ScalarType::Float);
-  auto forwardResult = BaseModel::forward(inputTensor);
-  CHECK_OK_OR_THROW_FORWARD_ERROR(forwardResult);
-  auto tensor = forwardResult->at(0).toTensor();
-  startIdx = utils::getNonSpeechClassProbabilites(tensor, tensor.size(2),
-                                                  remainder, scores, startIdx);
-  return postprocess(scores, kSpeechThreshold, mergeGap);
-}
-
-void VoiceActivityDetection::stream(std::shared_ptr<jsi::Function> callback,
-                                    uint32_t timeout,
-                                    uint32_t detectionMargin) {
-  bool expected = false;
-  if (!isStreaming_.compare_exchange_strong(expected, true)) {
-    throw RnExecutorchError(RnExecutorchErrorCode::StreamingInProgress,
-                            "Streaming is already in progress!");
-  }
-
-  // RAII guard
-  struct StreamingGuard {
-    VoiceActivityDetection *self;
-    ~StreamingGuard() {
-      self->isStreaming_ = false;
-      std::scoped_lock lock(self->audioBufferMutex_);
-      self->audioBuffer_.clear();
-    }
-  } guard{this};
-
-  // Build a native callback which simply sends a boolean signal,
-  // where true corresponds to detected ongoing speech, and false corresponds to
-  // silence.
-  auto nativeCallback = [this, callback](bool speaking) {
-    callInvoker_->invokeAsync([callback, speaking](jsi::Runtime &rt) {
-      callback->call(rt, jsi::Value(speaking));
-    });
-  };
-
-  while (isStreaming_) {
-    // Make sure that audio buffer does not exceed it's max size
-    // BEFORE infering the model, such that potentially save 1 unnecessary
-    // iteration.
-    {
-      std::scoped_lock lock(audioBufferMutex_);
-      if (audioBuffer_.size() > constants::kStreamBufferMaxSize) {
-        // Keep the most recent audio samples in.
-        size_t cut = audioBuffer_.size() - constants::kStreamBufferMinReserve;
-        audioBuffer_.erase(audioBuffer_.begin(), audioBuffer_.begin() + cut);
-      }
-    }
-
-    std::vector<float> snapshot;
-    {
-      // Copy under lock so a concurrent streamInsert that grows audioBuffer_
-      // past its reserved capacity (causing a reallocation) can't invalidate
-      // the data we hand to generate().
-      std::scoped_lock lock(audioBufferMutex_);
-      snapshot.assign(audioBuffer_.begin(), audioBuffer_.end());
-    }
-
-    std::vector<types::Segment> detection = generate(snapshot);
-
-    bool speaking = false;
-
-    // Get the last detected speech segment (if any exists) and
-    // check if it is recent enough to consider the speech as ongoing.
-    if (!detection.empty()) {
-      auto lastSegment = detection.back();
-      auto speechEnd = lastSegment.end;
-
-      std::scoped_lock lock(audioBufferMutex_);
-      uint32_t diffMs =
-          (audioBuffer_.size() - speechEnd) / constants::kSamplesPerMs; // [ms]
-
-      speaking = diffMs <= detectionMargin;
-    }
-
-    // Send result to the JS side.
-    nativeCallback(speaking);
-
-    std::unique_lock<std::mutex> lock(streamCvMutex_);
-    streamCv_.wait_for(lock, std::chrono::milliseconds(timeout),
-                       [this] { return !isStreaming_.load(); });
-  }
-}
-
-void VoiceActivityDetection::streamStop() {
-  isStreaming_ = false;
-  streamCv_.notify_all();
-}
-
-void VoiceActivityDetection::streamInsert(std::span<const float> audio) {
-  std::scoped_lock lock(audioBufferMutex_);
-  audioBuffer_.insert(audioBuffer_.end(), audio.begin(), audio.end());
-}
-
-std::vector<std::array<float, kPaddedWindowSize>>
-VoiceActivityDetection::preprocess(std::span<float> waveform) const {
-  auto kHammingWindowArray = dsp::hannWindow(kWindowSize);
-
-  const size_t numFrames = (waveform.size() - kWindowSize) / kHopLength;
-
-  std::vector<std::array<float, kPaddedWindowSize>> frameBuffer(
-      numFrames, std::array<float, kPaddedWindowSize>{});
-
-  constexpr size_t totalPadding = kPaddedWindowSize - kWindowSize;
-  constexpr size_t leftPadding = totalPadding / 2;
-  for (size_t i = 0; i < numFrames; i++) {
-
-    auto windowView = waveform.subspan(i * kHopLength, kWindowSize);
-    ranges::copy(windowView, frameBuffer[i].begin() + leftPadding);
-    auto frameView =
-        std::span{frameBuffer[i].data() + leftPadding, kWindowSize};
-    const float sum = std::reduce(frameView.begin(), frameView.end(), 0.0f);
-    const float mean = sum / kWindowSize;
-    ranges::transform(frameView, frameView.begin(),
-                      [mean](float value) { return value - mean; });
-
-    // apply pre-emphasis filter
-    for (auto j = frameView.size() - 1; j > 0; --j) {
-      frameView[j] -= kPreemphasisCoeff * frameView[j - 1];
-    }
-    // apply hamming window to reduce spectral leakage
-    ranges::transform(frameView, kHammingWindowArray, frameView.begin(),
-                      std::multiplies{});
-  }
-  return frameBuffer;
-}
-
-std::vector<types::Segment>
-VoiceActivityDetection::postprocess(const std::vector<float> &scores,
-                                    float threshold, uint32_t mergeGap) const {
-  bool triggered = false;
-  std::vector<types::Segment> speechSegments{};
-  ssize_t startSegment = -1;
-  ssize_t endSegment = -1;
-  ssize_t potentialStart = -1;
-  ssize_t potentialEnd = -1;
-  float score;
-  for (size_t i = 0; i < scores.size(); i++) {
-    score = 1 - scores[i];
-    if (!triggered) {
-      if (score >= threshold) {
-        if (potentialStart == -1) {
-          potentialStart = i;
-        } else if (i - potentialStart >= kMinSpeechDurationMs / kHopLengthMs) {
-          triggered = true;
-          startSegment = potentialStart;
-          potentialStart = -1;
-        }
-      } else { // score < threshold
-        potentialStart = -1;
-      }
-    } else { // triggered
-      if (score < threshold) {
-        if (potentialEnd == -1) {
-          potentialEnd = i;
-        } else if (i - potentialEnd >= kMinSilenceDurationMs / kHopLengthMs) {
-          triggered = false;
-          endSegment = potentialEnd;
-          speechSegments.emplace_back(startSegment, endSegment);
-          potentialEnd = -1;
-        }
-      } else {
-        potentialEnd = -1;
-      }
-    }
-  }
-  if (triggered) {
-    endSegment = scores.size();
-    speechSegments.emplace_back(startSegment, endSegment);
-  }
-
-  constexpr size_t kSpeechPadHops = kSpeechPadMs / kHopLengthMs;
-  for (auto &[start, end] : speechSegments) {
-    // std::max(start-kSpeechPadHops, 0) might be underflow that is why we use ?
-    // operator.
-    start = (start > kSpeechPadHops ? start - kSpeechPadHops : 0) * kHopLength;
-    end = std::min(end + kSpeechPadHops, scores.size()) * kHopLength;
-  }
-
-  // Merge tightly placed segments according to the max allowed gap parameter.
-  size_t maxMergeGap = mergeGap * constants::kSamplesPerMs;
-  return utils::mergeSegments(speechSegments, maxMergeGap);
-}
-
-} // namespace rnexecutorch::models::voice_activity_detection
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/voice_activity_detection/VoiceActivityDetection.h b/packages/react-native-executorch/common/rnexecutorch/models/voice_activity_detection/VoiceActivityDetection.h
deleted file mode 100644
index d9d72adbba..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/voice_activity_detection/VoiceActivityDetection.h
+++ /dev/null
@@ -1,76 +0,0 @@
-#pragma once
-
-#include <condition_variable>
-#include <cstddef>
-#include <executorch/extension/module/module.h>
-#include <executorch/extension/tensor/tensor.h>
-#include <executorch/extension/tensor/tensor_ptr.h>
-#include <executorch/runtime/core/evalue.h>
-#include <mutex>
-#include <span>
-
-#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
-#include "rnexecutorch/models/BaseModel.h"
-#include "rnexecutorch/models/voice_activity_detection/Constants.h"
-#include "rnexecutorch/models/voice_activity_detection/Types.h"
-
-namespace rnexecutorch {
-namespace models::voice_activity_detection {
-
-using executorch::extension::TensorPtr;
-using executorch::runtime::EValue;
-
-class VoiceActivityDetection : public BaseModel {
-public:
-  VoiceActivityDetection(const std::string &modelSource,
-                         std::shared_ptr<react::CallInvoker> callInvoker);
-
-  [[nodiscard("Registered non-void function")]] std::vector<types::Segment>
-  generate(std::span<float> waveform, uint32_t mergeGap = 0) const;
-
-  /**
-   * Initializes the streaming procedure, which performs
-   * a continuous detection on live expanding audio buffer.
-   *
-   * @param callback JS side callback to pass the results with.
-   * @param timeout Specifies (in miliseconds) how much does streamer wait
-   * between model inferences.
-   * @param detectionMargin Specifies (in miliseconds) how far the last detected
-   * speech segment can be to still be considered as ongoing speech.
-   */
-  void stream(std::shared_ptr<jsi::Function> callback, uint32_t timeout,
-              uint32_t detectionMargin);
-
-  /**
-   * When called, stops the streaming procedure.
-   */
-  void streamStop();
-
-  /**
-   * Adds a new audio chunk to the streaming buffer.
-   */
-  void streamInsert(std::span<const float> audio);
-
-private:
-  std::vector<std::array<float, constants::kPaddedWindowSize>>
-  preprocess(std::span<float> waveform) const;
-  std::vector<types::Segment> postprocess(const std::vector<float> &scores,
-                                          float threshold,
-                                          uint32_t mergeGap) const;
-
-  std::shared_ptr<react::CallInvoker> callInvoker_;
-
-  // Streaming buffer
-  std::vector<float> audioBuffer_ = {};
-  mutable std::mutex audioBufferMutex_;
-  // Streaming state
-  std::atomic<bool> isStreaming_ = false;
-  std::condition_variable streamCv_;
-  std::mutex streamCvMutex_;
-};
-
-} // namespace models::voice_activity_detection
-
-REGISTER_CONSTRUCTOR(models::voice_activity_detection::VoiceActivityDetection,
-                     std::string, std::shared_ptr<react::CallInvoker>);
-} // namespace rnexecutorch
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/CMakeLists.txt b/packages/react-native-executorch/common/rnexecutorch/tests/CMakeLists.txt
deleted file mode 100644
index 5f9d7287a5..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/CMakeLists.txt
+++ /dev/null
@@ -1,380 +0,0 @@
-if(NOT ANDROID_ABI)
-    message(FATAL_ERROR "Tests can be only built for Android simulator")
-endif()
-
-cmake_minimum_required(VERSION 3.13)
-project(RNExecutorchTests)
-
-set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
-
-# tests/                         <- CMAKE_SOURCE_DIR (this file's location)
-# rnexecutorch/                  <- RNEXECUTORCH_DIR (parent of tests)
-# common/                        <- COMMON_DIR
-# react-native-executorch/       <- PACKAGE_ROOT
-# <monorepo-root>/               <- MONOREPO_ROOT
-# <monorepo-root>/third-party/   <- THIRD_PARTY_DIR
-set(RNEXECUTORCH_DIR "${CMAKE_SOURCE_DIR}/..")
-set(COMMON_DIR "${RNEXECUTORCH_DIR}/..")
-set(PACKAGE_ROOT "${COMMON_DIR}/..")
-set(MONOREPO_ROOT "${PACKAGE_ROOT}/../..")
-set(THIRD_PARTY_DIR "${MONOREPO_ROOT}/third-party")
-set(REACT_NATIVE_DIR "${MONOREPO_ROOT}/node_modules/react-native")
-set(ANDROID_THIRD_PARTY "${PACKAGE_ROOT}/third-party/android/libs/")
-set(TOKENIZERS_DIR "${PACKAGE_ROOT}/third-party/include/executorch/extension/llm/tokenizers/include")
-
-# Add Gtest as a subdirectory
-add_subdirectory(${THIRD_PARTY_DIR}/googletest ${PROJECT_BINARY_DIR}/googletest)
-
-# ExecuTorch Prebuilt binaries
-add_library(executorch_prebuilt SHARED IMPORTED)
-set_target_properties(executorch_prebuilt PROPERTIES
-    IMPORTED_LOCATION "${ANDROID_THIRD_PARTY}/executorch/${ANDROID_ABI}/libexecutorch.so"
-)
-
-# pthreadpool and cpuinfo (needed for OpenMP/OpenCV)
-if(ANDROID_ABI STREQUAL "arm64-v8a")
-  add_library(pthreadpool SHARED IMPORTED)
-  set_target_properties(pthreadpool PROPERTIES
-      IMPORTED_LOCATION "${ANDROID_THIRD_PARTY}/pthreadpool/${ANDROID_ABI}/libpthreadpool.so"
-  )
-
-  add_library(cpuinfo SHARED IMPORTED)
-  set_target_properties(cpuinfo PROPERTIES
-      IMPORTED_LOCATION "${ANDROID_THIRD_PARTY}/cpuinfo/${ANDROID_ABI}/libcpuinfo.so"
-  )
-
-  set(EXECUTORCH_LIBS pthreadpool cpuinfo)
-else()
-  set(EXECUTORCH_LIBS "")
-endif()
-
-# OpenCV (Interface Library)
-set(OPENCV_LIBS_DIR "${ANDROID_THIRD_PARTY}/opencv/${ANDROID_ABI}")
-set(OPENCV_THIRD_PARTY_DIR "${ANDROID_THIRD_PARTY}/opencv-third-party/${ANDROID_ABI}")
-
-if(ANDROID_ABI STREQUAL "arm64-v8a")
-  set(OPENCV_THIRD_PARTY_LIBS
-    "${OPENCV_THIRD_PARTY_DIR}/libkleidicv_hal.a"
-    "${OPENCV_THIRD_PARTY_DIR}/libkleidicv_thread.a"
-    "${OPENCV_THIRD_PARTY_DIR}/libkleidicv.a"
-  )
-elseif(ANDROID_ABI STREQUAL "x86_64")
-  set(OPENCV_THIRD_PARTY_LIBS "")
-endif()
-
-
-add_library(opencv_deps INTERFACE)
-target_link_libraries(opencv_deps INTERFACE
-    ${OPENCV_LIBS_DIR}/libopencv_core.a
-    ${OPENCV_LIBS_DIR}/libopencv_features2d.a
-    ${OPENCV_LIBS_DIR}/libopencv_highgui.a
-    ${OPENCV_LIBS_DIR}/libopencv_imgproc.a
-    ${OPENCV_LIBS_DIR}/libopencv_photo.a
-    ${OPENCV_LIBS_DIR}/libopencv_video.a
-    ${OPENCV_THIRD_PARTY_LIBS}
-    ${EXECUTORCH_LIBS}
-    z
-    dl
-    m
-    log
-)
-target_link_options(opencv_deps INTERFACE -fopenmp -static-openmp)
-
-add_library(tokenizers_deps INTERFACE)
-target_include_directories(tokenizers_deps INTERFACE "${TOKENIZERS_DIR}")
-
-# Phonemis (built from source — mirrors android/src/main/cpp/CMakeLists.txt)
-set(PHONEMIS_DIR "${PACKAGE_ROOT}/third-party/common/phonemis")
-add_subdirectory(${PHONEMIS_DIR} ${PROJECT_BINARY_DIR}/phonemis)
-target_compile_definitions(phonemis PRIVATE ET_ON)
-target_include_directories(phonemis PRIVATE "${PACKAGE_ROOT}/third-party/include")
-
-# Source Definitions
-set(CORE_SOURCES
-    ${RNEXECUTORCH_DIR}/models/BaseModel.cpp
-    ${RNEXECUTORCH_DIR}/data_processing/Numerical.cpp
-    ${CMAKE_SOURCE_DIR}/integration/stubs/jsi_stubs.cpp
-)
-
-set(IMAGE_UTILS_SOURCES
-    ${RNEXECUTORCH_DIR}/data_processing/ImageProcessing.cpp
-    ${RNEXECUTORCH_DIR}/data_processing/base64.cpp
-    ${COMMON_DIR}/ada/ada.cpp
-)
-
-set(TOKENIZER_SOURCES ${RNEXECUTORCH_DIR}/TokenizerModule.cpp)
-set(DSP_SOURCES ${RNEXECUTORCH_DIR}/data_processing/dsp.cpp)
-
-# Core Library
-add_library(rntests_core STATIC ${CORE_SOURCES})
-
-target_include_directories(rntests_core PUBLIC
-    ${RNEXECUTORCH_DIR}/data_processing
-    ${TOKENIZERS_DIR}
-    ${RNEXECUTORCH_DIR}
-    ${COMMON_DIR}
-    ${PACKAGE_ROOT}/third-party/include
-    ${PACKAGE_ROOT}/third-party/include/cpuinfo
-    ${PACKAGE_ROOT}/third-party/include/pthreadpool
-    ${PHONEMIS_DIR}/src
-    ${REACT_NATIVE_DIR}/ReactCommon
-    ${REACT_NATIVE_DIR}/ReactCommon/jsi
-    ${REACT_NATIVE_DIR}/ReactCommon/callinvoker
-    ${COMMON_DIR}/ada
-)
-
-target_link_libraries(rntests_core PUBLIC
-    executorch_prebuilt
-    gtest
-    log
-)
-
-enable_testing()
-function(add_rn_test TEST_TARGET TEST_FILENAME)
-    cmake_parse_arguments(ARG "" "" "SOURCES;LIBS" ${ARGN})
-    # Create executable using the explicit filename provided
-    add_executable(${TEST_TARGET} ${TEST_FILENAME} ${ARG_SOURCES})
-
-    target_compile_definitions(${TEST_TARGET} PRIVATE TEST_BUILD)
-    target_link_libraries(${TEST_TARGET} PRIVATE rntests_core gtest_main ${ARG_LIBS})
-    target_link_options(${TEST_TARGET} PRIVATE "LINKER:-z,max-page-size=16384")
-
-    add_test(NAME ${TEST_TARGET} COMMAND ${TEST_TARGET})
-endfunction()
-
-add_rn_test(NumericalTests unit/NumericalTest.cpp)
-add_rn_test(RunnerTests unit/RunnerTest.cpp
-    SOURCES
-        ${COMMON_DIR}/runner/base_llm_runner.cpp
-        ${COMMON_DIR}/runner/sampler.cpp
-        ${COMMON_DIR}/runner/arange_util.cpp
-        integration/stubs/jsi_stubs.cpp
-    LIBS tokenizers_deps
-)
-add_rn_test(SamplerTests unit/SamplerTest.cpp
-    SOURCES
-        ${COMMON_DIR}/runner/sampler.cpp
-        ${COMMON_DIR}/runner/arange_util.cpp
-    LIBS
-)
-add_rn_test(LogTests unit/LogTest.cpp)
-add_rn_test(FileUtilsTest unit/FileUtilsTest.cpp)
-add_rn_test(ImageProcessingTest unit/ImageProcessingTest.cpp
-    SOURCES
-        ${IMAGE_UTILS_SOURCES}
-    LIBS opencv_deps
-)
-
-add_rn_test(FrameProcessorTests unit/FrameProcessorTest.cpp
-    SOURCES
-        ${RNEXECUTORCH_DIR}/utils/FrameProcessor.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameExtractor.cpp
-        ${IMAGE_UTILS_SOURCES}
-    LIBS opencv_deps android
-)
-
-add_rn_test(FrameTransformTests unit/FrameTransformTest.cpp
-    SOURCES
-        ${RNEXECUTORCH_DIR}/utils/FrameTransform.cpp
-    LIBS opencv_deps
-)
-
-add_rn_test(BaseModelTests integration/BaseModelTest.cpp)
-
-add_rn_test(VisionModelTests integration/VisionModelTest.cpp
-    SOURCES
-        ${RNEXECUTORCH_DIR}/models/VisionModel.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameProcessor.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameExtractor.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameTransform.cpp
-        ${IMAGE_UTILS_SOURCES}
-    LIBS opencv_deps android
-)
-
-add_rn_test(ClassificationTests integration/ClassificationTest.cpp
-    SOURCES
-        ${RNEXECUTORCH_DIR}/models/classification/Classification.cpp
-        ${RNEXECUTORCH_DIR}/models/VisionModel.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameProcessor.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameExtractor.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameTransform.cpp
-        ${IMAGE_UTILS_SOURCES}
-    LIBS opencv_deps android
-)
-
-add_rn_test(ObjectDetectionTests integration/ObjectDetectionTest.cpp
-    SOURCES
-        ${RNEXECUTORCH_DIR}/models/object_detection/ObjectDetection.cpp
-        ${RNEXECUTORCH_DIR}/models/VisionModel.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameProcessor.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameExtractor.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameTransform.cpp
-        ${RNEXECUTORCH_DIR}/utils/computer_vision/Processing.cpp
-        ${IMAGE_UTILS_SOURCES}
-    LIBS opencv_deps android
-)
-
-add_rn_test(ImageEmbeddingsTests integration/ImageEmbeddingsTest.cpp
-    SOURCES
-        ${RNEXECUTORCH_DIR}/models/embeddings/image/ImageEmbeddings.cpp
-        ${RNEXECUTORCH_DIR}/models/embeddings/BaseEmbeddings.cpp
-        ${RNEXECUTORCH_DIR}/models/VisionModel.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameProcessor.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameExtractor.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameTransform.cpp
-        ${IMAGE_UTILS_SOURCES}
-    LIBS opencv_deps android
-)
-
-add_rn_test(TextEmbeddingsTests integration/TextEmbeddingsTest.cpp
-    SOURCES
-        ${RNEXECUTORCH_DIR}/models/embeddings/text/TextEmbeddings.cpp
-        ${RNEXECUTORCH_DIR}/models/embeddings/BaseEmbeddings.cpp
-        ${TOKENIZER_SOURCES}
-    LIBS tokenizers_deps
-)
-
-add_rn_test(StyleTransferTests integration/StyleTransferTest.cpp
-    SOURCES
-        ${RNEXECUTORCH_DIR}/models/style_transfer/StyleTransfer.cpp
-        ${RNEXECUTORCH_DIR}/models/VisionModel.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameProcessor.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameExtractor.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameTransform.cpp
-        ${IMAGE_UTILS_SOURCES}
-    LIBS opencv_deps android
-)
-
-add_rn_test(VADTests integration/VoiceActivityDetectionTest.cpp
-    SOURCES
-        ${RNEXECUTORCH_DIR}/models/voice_activity_detection/VoiceActivityDetection.cpp
-        ${RNEXECUTORCH_DIR}/models/voice_activity_detection/Utils.cpp
-        ${DSP_SOURCES}
-)
-
-add_rn_test(TokenizerModuleTests integration/TokenizerModuleTest.cpp
-    SOURCES ${TOKENIZER_SOURCES}
-    LIBS tokenizers_deps
-)
-
-add_rn_test(SpeechToTextTests integration/SpeechToTextTest.cpp
-    SOURCES
-        ${RNEXECUTORCH_DIR}/models/speech_to_text/SpeechToText.cpp
-        ${RNEXECUTORCH_DIR}/models/speech_to_text/whisper/ASR.cpp
-        ${RNEXECUTORCH_DIR}/models/speech_to_text/whisper/OnlineASR.cpp
-        ${RNEXECUTORCH_DIR}/models/voice_activity_detection/VoiceActivityDetection.cpp
-        ${RNEXECUTORCH_DIR}/models/voice_activity_detection/Utils.cpp
-        ${RNEXECUTORCH_DIR}/data_processing/gzip.cpp
-        ${TOKENIZER_SOURCES}
-        ${DSP_SOURCES}
-    LIBS tokenizers_deps z
-)
-
-add_rn_test(TextToSpeechTests integration/TextToSpeechTest.cpp
-    SOURCES
-        ${RNEXECUTORCH_DIR}/models/text_to_speech/kokoro/Kokoro.cpp
-        ${RNEXECUTORCH_DIR}/models/text_to_speech/kokoro/DurationPredictor.cpp
-        ${RNEXECUTORCH_DIR}/models/text_to_speech/kokoro/Synthesizer.cpp
-        ${RNEXECUTORCH_DIR}/models/text_to_speech/kokoro/Partitioner.cpp
-        ${RNEXECUTORCH_DIR}/models/text_to_speech/kokoro/Utils.cpp
-    LIBS phonemis
-)
-
-add_rn_test(LLMTests integration/LLMTest.cpp
-    SOURCES
-        ${RNEXECUTORCH_DIR}/models/llm/LLM.cpp
-        ${COMMON_DIR}/runner/base_llm_runner.cpp
-        ${COMMON_DIR}/runner/text_runner.cpp
-        ${COMMON_DIR}/runner/multimodal_runner.cpp
-        ${COMMON_DIR}/runner/multimodal_prefiller.cpp
-        ${COMMON_DIR}/runner/text_prefiller.cpp
-        ${COMMON_DIR}/runner/text_decoder_runner.cpp
-        ${COMMON_DIR}/runner/sampler.cpp
-        ${COMMON_DIR}/runner/arange_util.cpp
-        ${COMMON_DIR}/runner/encoders/vision_encoder.cpp
-        ${COMMON_DIR}/runner/encoders/audio_encoder.cpp
-        ${IMAGE_UTILS_SOURCES}
-    LIBS tokenizers_deps opencv_deps
-)
-
-add_rn_test(TextToImageTests integration/TextToImageTest.cpp
-    SOURCES
-        ${RNEXECUTORCH_DIR}/models/text_to_image/TextToImage.cpp
-        ${RNEXECUTORCH_DIR}/models/text_to_image/Encoder.cpp
-        ${RNEXECUTORCH_DIR}/models/text_to_image/UNet.cpp
-        ${RNEXECUTORCH_DIR}/models/text_to_image/Decoder.cpp
-        ${RNEXECUTORCH_DIR}/models/text_to_image/Scheduler.cpp
-        ${RNEXECUTORCH_DIR}/models/embeddings/text/TextEmbeddings.cpp
-        ${RNEXECUTORCH_DIR}/models/embeddings/BaseEmbeddings.cpp
-        ${TOKENIZER_SOURCES}
-    LIBS tokenizers_deps
-)
-
-add_rn_test(SemanticSegmentationTests integration/SemanticSegmentationTest.cpp
-    SOURCES
-        ${RNEXECUTORCH_DIR}/models/semantic_segmentation/BaseSemanticSegmentation.cpp
-        ${RNEXECUTORCH_DIR}/models/VisionModel.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameProcessor.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameExtractor.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameTransform.cpp
-        ${IMAGE_UTILS_SOURCES}
-    LIBS opencv_deps android
-)
-
-add_rn_test(InstanceSegmentationTests integration/InstanceSegmentationTest.cpp
-    SOURCES
-        ${RNEXECUTORCH_DIR}/models/instance_segmentation/BaseInstanceSegmentation.cpp
-        ${RNEXECUTORCH_DIR}/models/VisionModel.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameProcessor.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameExtractor.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameTransform.cpp
-        ${RNEXECUTORCH_DIR}/utils/computer_vision/Processing.cpp
-        ${IMAGE_UTILS_SOURCES}
-    LIBS opencv_deps android
-)
-
-add_rn_test(PoseEstimationTests integration/PoseEstimationTest.cpp
-    SOURCES
-        ${RNEXECUTORCH_DIR}/models/pose_estimation/PoseEstimation.cpp
-        ${RNEXECUTORCH_DIR}/models/VisionModel.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameProcessor.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameExtractor.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameTransform.cpp
-        ${IMAGE_UTILS_SOURCES}
-    LIBS opencv_deps android
-)
-
-add_rn_test(OCRTests integration/OCRTest.cpp
-    SOURCES
-        ${RNEXECUTORCH_DIR}/models/ocr/OCR.cpp
-        ${RNEXECUTORCH_DIR}/models/ocr/CTCLabelConverter.cpp
-        ${RNEXECUTORCH_DIR}/models/ocr/Detector.cpp
-        ${RNEXECUTORCH_DIR}/models/ocr/RecognitionHandler.cpp
-        ${RNEXECUTORCH_DIR}/models/ocr/Recognizer.cpp
-        ${RNEXECUTORCH_DIR}/models/ocr/utils/DetectorUtils.cpp
-        ${RNEXECUTORCH_DIR}/models/ocr/utils/RecognitionHandlerUtils.cpp
-        ${RNEXECUTORCH_DIR}/models/ocr/utils/RecognizerUtils.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameProcessor.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameExtractor.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameTransform.cpp
-        ${IMAGE_UTILS_SOURCES}
-    LIBS opencv_deps android
-)
-
-add_rn_test(VerticalOCRTests integration/VerticalOCRTest.cpp
-    SOURCES
-        ${RNEXECUTORCH_DIR}/models/vertical_ocr/VerticalOCR.cpp
-        ${RNEXECUTORCH_DIR}/models/vertical_ocr/VerticalDetector.cpp
-        ${RNEXECUTORCH_DIR}/models/ocr/Detector.cpp
-        ${RNEXECUTORCH_DIR}/models/ocr/CTCLabelConverter.cpp
-        ${RNEXECUTORCH_DIR}/models/ocr/Recognizer.cpp
-        ${RNEXECUTORCH_DIR}/models/ocr/utils/DetectorUtils.cpp
-        ${RNEXECUTORCH_DIR}/models/ocr/utils/RecognitionHandlerUtils.cpp
-        ${RNEXECUTORCH_DIR}/models/ocr/utils/RecognizerUtils.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameProcessor.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameExtractor.cpp
-        ${RNEXECUTORCH_DIR}/utils/FrameTransform.cpp
-        ${IMAGE_UTILS_SOURCES}
-    LIBS opencv_deps android
-)
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/README.md b/packages/react-native-executorch/common/rnexecutorch/tests/README.md
deleted file mode 100644
index 8a28b40032..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/README.md
+++ /dev/null
@@ -1,76 +0,0 @@
-## Native Test
-This guide provide information on how functions are tested, how to install all needed dependencies and how to run tests.
-
-### Used Tools
-To test the native code we use [`googletest`](https://github.com/google/googletest). It's a flexible tool for creating unit tests.
-
-### Installation
-The googletest is already in repo in `react-native-executorch/third-party/googletest`. Firstly, you need to fetch googletest locally, run from root directory of project:
-* `git submodule update --init --recursive third-party/googletest`
-
-### Running tests
-
-#### Prerequisites
-
-- **Android NDK**: The `ANDROID_NDK` environment variable must be set
-- **wget**: Must be in your PATH
-- **Android emulator**: Must be running before executing tests
-- **Device requirements**:
-  - 16GB disk storage (minimum)
-  - 8GB RAM (minimum)
-
-#### First-time setup
-
-Before running tests, you need to build an app to generate required native libraries (`libfbjni.so` and `libc++_shared.so`). The test script automatically searches for these in the monorepo.
-
-If the script reports missing libraries, build any example app:
-```bash
-cd apps/computer-vision/android
-./gradlew assembleDebug
-# or
-./gradlew assembleRelease
-```
-
-#### Running the tests
-
-Navigate to the tests directory:
-```bash
-cd packages/react-native-executorch/common/rnexecutorch/tests
-```
-
-Run the test script:
-```bash
-bash ./run_tests.sh
-```
-
-This script:
-- Downloads all needed models
-- Pushes executables, models, assets, and shared libraries via ADB to the running emulator
-- Runs the pre-compiled test executables
-
-#### Available flags
-
-* `--refresh-models` - Forcefully downloads all the models. By default, models are not downloaded unless they are missing from the specified directory.
-* `--skip-build` - Skips the cmake build step.
-
-### How to add a new test
-To add new test you need to:
-* Add a new .cpp file to either integration/ or unit/, depending on the type of the test.
-* In `CMakeLists.txt`, add all executables and link all the needed libraries against the executable, for example you can use the `add_rn_test`, which is a helper function that links core libs. Example:
-    ```cmake
-    # unit
-    add_rn_test(BaseModelTests integration/BaseModelTest.cpp)
-
-    # integration
-    add_rn_test(ClassificationTests integration/ClassificationTest.cpp
-        SOURCES
-            ${RNEXECUTORCH_DIR}/models/classification/Classification.cpp
-            ${IMAGE_UTILS_SOURCES}
-        LIBS opencv_deps
-    )
-    ```
-* In `run_tests.sh`:
-  * Add the test executable name to `TEST_EXECUTABLES`.
-  * Add any models/files the test downloads at runtime to `MODELS` (filename + URL), **and** register every downloaded file the test loads in the `models_for_test()` case statement. The runner pushes only the files listed there from `$MODELS_DIR` to the device for that test, runs it, and removes them afterwards — anything missing won't be on the device when the test runs. Tests with no model dependencies don't need an entry.
-  * Repo-bundled fixtures (small images, audio, etc.) go in `TEST_ASSETS` instead. Those are pushed once up front and stay on the device; do not list them in `models_for_test()`.
-
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/BaseModelTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/integration/BaseModelTest.cpp
deleted file mode 100644
index 4889537389..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/integration/BaseModelTest.cpp
+++ /dev/null
@@ -1,208 +0,0 @@
-#include "BaseModelTests.h"
-#include <executorch/extension/tensor/tensor.h>
-#include <gtest/gtest.h>
-#include <limits>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/models/BaseModel.h>
-#include <vector>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models;
-using namespace executorch::extension;
-using namespace model_tests;
-using executorch::runtime::EValue;
-
-constexpr auto kValidStyleTransferModelPath =
-    "style_transfer_candy_xnnpack_fp32.pte";
-
-// ============================================================================
-// Common tests via typed test suite
-// ============================================================================
-namespace model_tests {
-
-template <> struct ModelTraits<BaseModel> {
-  using ModelType = BaseModel;
-
-  static ModelType createValid() {
-    return ModelType(kValidStyleTransferModelPath, nullptr);
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.pte", nullptr);
-  }
-
-  static void callGenerate(ModelType &model) {
-    std::vector<int32_t> shape = {1, 3, 640, 640};
-    size_t numElements = 1 * 3 * 640 * 640;
-    std::vector<float> inputData(numElements, 0.5f);
-    auto tensorPtr = make_tensor_ptr(shape, inputData.data());
-    EValue input(*tensorPtr);
-    (void)model.forward(input);
-  }
-};
-} // namespace model_tests
-
-using BaseModelTypes = ::testing::Types<BaseModel>;
-INSTANTIATE_TYPED_TEST_SUITE_P(BaseModel, CommonModelTest, BaseModelTypes);
-
-// ============================================================================
-// BaseModel-specific tests (methods not in all models)
-// ============================================================================
-
-TEST(BaseModelGetInputShapeTests, ValidMethodCorrectShape) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  auto forwardShape = model.getInputShape("forward", 0);
-  std::vector<int32_t> expectedShape = {1, 3, 640, 640};
-  EXPECT_EQ(forwardShape, expectedShape);
-}
-
-TEST(BaseModelGetInputShapeTests, InvalidMethodThrows) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  EXPECT_THROW((void)model.getInputShape("this_method_does_not_exist", 0),
-               RnExecutorchError);
-}
-
-TEST(BaseModelGetInputShapeTests, ValidMethodInvalidIndexThrows) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  EXPECT_THROW(
-      (void)model.getInputShape("forward", std::numeric_limits<int32_t>::min()),
-      RnExecutorchError);
-}
-
-TEST(BaseModelGetAllInputShapesTests, ValidMethodReturnsShapes) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  auto allShapes = model.getAllInputShapes("forward");
-  EXPECT_FALSE(allShapes.empty());
-  std::vector<int32_t> expectedFirstShape = {1, 3, 640, 640};
-  EXPECT_EQ(allShapes[0], expectedFirstShape);
-}
-
-TEST(BaseModelGetAllInputShapesTests, InvalidMethodThrows) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  EXPECT_THROW(model.getAllInputShapes("non_existent_method"),
-               RnExecutorchError);
-}
-
-TEST(BaseModelGetMethodMetaTests, ValidMethodReturnsOk) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  auto result = model.getMethodMeta("forward");
-  EXPECT_TRUE(result.ok());
-}
-
-TEST(BaseModelGetMethodMetaTests, InvalidMethodReturnsError) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  auto result = model.getMethodMeta("non_existent_method");
-  EXPECT_FALSE(result.ok());
-}
-
-TEST(BaseModelForwardTests, ForwardWithValidInputReturnsOk) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  std::vector<int32_t> shape = {1, 3, 640, 640};
-  size_t numElements = 1 * 3 * 640 * 640;
-  std::vector<float> inputData(numElements, 0.5f);
-  auto tensorPtr = make_tensor_ptr(shape, inputData.data());
-  EValue input(*tensorPtr);
-
-  auto result = model.forward(input);
-  EXPECT_TRUE(result.ok());
-}
-
-TEST(BaseModelForwardTests, ForwardWithVectorInputReturnsOk) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  std::vector<int32_t> shape = {1, 3, 640, 640};
-  size_t numElements = 1 * 3 * 640 * 640;
-  std::vector<float> inputData(numElements, 0.5f);
-  auto tensorPtr = make_tensor_ptr(shape, inputData.data());
-  std::vector<EValue> inputs;
-  inputs.emplace_back(*tensorPtr);
-
-  auto result = model.forward(inputs);
-  EXPECT_TRUE(result.ok());
-}
-
-TEST(BaseModelForwardTests, ForwardReturnsCorrectOutputShape) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  std::vector<int32_t> shape = {1, 3, 640, 640};
-  size_t numElements = 1 * 3 * 640 * 640;
-  std::vector<float> inputData(numElements, 0.5f);
-  auto tensorPtr = make_tensor_ptr(shape, inputData.data());
-  EValue input(*tensorPtr);
-
-  auto result = model.forward(input);
-  ASSERT_TRUE(result.ok());
-  ASSERT_FALSE(result->empty());
-
-  auto &outputTensor = result->at(0).toTensor();
-  auto outputSizes = outputTensor.sizes();
-  EXPECT_EQ(outputSizes.size(), 4);
-  EXPECT_EQ(outputSizes[0], 1);
-  EXPECT_EQ(outputSizes[1], 3);
-  EXPECT_EQ(outputSizes[2], 640);
-  EXPECT_EQ(outputSizes[3], 640);
-}
-
-TEST(BaseModelForwardTests, ForwardAfterUnloadThrows) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  model.unload();
-
-  std::vector<int32_t> shape = {1, 3, 640, 640};
-  size_t numElements = 1 * 3 * 640 * 640;
-  std::vector<float> inputData(numElements, 0.5f);
-  auto tensorPtr = make_tensor_ptr(shape, inputData.data());
-  EValue input(*tensorPtr);
-
-  EXPECT_THROW(model.forward(input), RnExecutorchError);
-}
-
-TEST(BaseModelForwardJSTests, ForwardJSWithValidInputReturnsOutput) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  std::vector<int32_t> shape = {1, 3, 640, 640};
-  size_t numElements = 1 * 3 * 640 * 640;
-  std::vector<float> inputData(numElements, 0.5f);
-
-  JSTensorViewIn tensorView;
-  tensorView.dataPtr = inputData.data();
-  tensorView.sizes = shape;
-  tensorView.scalarType = executorch::aten::ScalarType::Float;
-
-  std::vector<JSTensorViewIn> inputs = {tensorView};
-  auto outputs = model.forwardJS(inputs);
-
-  EXPECT_FALSE(outputs.empty());
-}
-
-TEST(BaseModelForwardJSTests, ForwardJSReturnsCorrectOutputShape) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  std::vector<int32_t> shape = {1, 3, 640, 640};
-  size_t numElements = 1 * 3 * 640 * 640;
-  std::vector<float> inputData(numElements, 0.5f);
-
-  JSTensorViewIn tensorView;
-  tensorView.dataPtr = inputData.data();
-  tensorView.sizes = shape;
-  tensorView.scalarType = executorch::aten::ScalarType::Float;
-
-  std::vector<JSTensorViewIn> inputs = {tensorView};
-  auto outputs = model.forwardJS(inputs);
-
-  ASSERT_EQ(outputs.size(), 1);
-  std::vector<int32_t> expectedShape = {1, 3, 640, 640};
-  EXPECT_EQ(outputs[0].sizes, expectedShape);
-}
-
-TEST(BaseModelForwardJSTests, ForwardJSAfterUnloadThrows) {
-  BaseModel model(kValidStyleTransferModelPath, nullptr);
-  model.unload();
-
-  std::vector<int32_t> shape = {1, 3, 640, 640};
-  size_t numElements = 1 * 3 * 640 * 640;
-  std::vector<float> inputData(numElements, 0.5f);
-
-  JSTensorViewIn tensorView;
-  tensorView.dataPtr = inputData.data();
-  tensorView.sizes = shape;
-  tensorView.scalarType = executorch::aten::ScalarType::Float;
-
-  std::vector<JSTensorViewIn> inputs = {tensorView};
-  EXPECT_THROW((void)model.forwardJS(inputs), RnExecutorchError);
-}
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/BaseModelTests.h b/packages/react-native-executorch/common/rnexecutorch/tests/integration/BaseModelTests.h
deleted file mode 100644
index af00a2164d..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/integration/BaseModelTests.h
+++ /dev/null
@@ -1,123 +0,0 @@
-#pragma once
-
-#include "gtest/gtest.h"
-#include <rnexecutorch/Error.h>
-
-namespace facebook::react {
-class CallInvoker;
-}
-
-namespace rnexecutorch {
-std::shared_ptr<facebook::react::CallInvoker> createMockCallInvoker();
-}
-
-namespace model_tests {
-
-inline auto getMockInvoker() { return rnexecutorch::createMockCallInvoker(); }
-
-/// Helper macro to access Traits in typed tests
-#define SETUP_TRAITS() using Traits = typename TestFixture::Traits
-
-/// Trait struct that each model must specialize
-/// This defines how to construct and test each model type
-template <typename T> struct ModelTraits;
-
-/// Example of what a specialization looks like:
-///
-/// template<>
-/// struct ModelTraits<Classification> {
-///   using ModelType = Classification;
-///
-///   // Create valid model instance
-///   static ModelType createValid() {
-///     return ModelType("valid_model.pte", nullptr);
-///   }
-///
-///   // Create invalid model instance (should throw in constructor)
-///   static ModelType createInvalid() {
-///     return ModelType("nonexistent.pte", nullptr);
-///   }
-///
-///   // Call the model's generate/forward function with valid input
-///   // Used to test that generate throws after unload
-///  static void callGenerate(ModelType& model) {
-///     (void)model.generate("valid_input.jpg");
-///   }
-/// };
-// Typed test fixture for common model tests
-template <typename T> class CommonModelTest : public ::testing::Test {
-protected:
-  using Traits = ModelTraits<T>;
-  using ModelType = typename Traits::ModelType;
-};
-
-// Define the test suite
-TYPED_TEST_SUITE_P(CommonModelTest);
-
-// Constructor tests
-TYPED_TEST_P(CommonModelTest, InvalidPathThrows) {
-  SETUP_TRAITS();
-  EXPECT_THROW(Traits::createInvalid(), rnexecutorch::RnExecutorchError);
-}
-
-TYPED_TEST_P(CommonModelTest, ValidPathDoesntThrow) {
-  SETUP_TRAITS();
-  EXPECT_NO_THROW(Traits::createValid());
-}
-
-// Memory tests
-TYPED_TEST_P(CommonModelTest, GetMemoryLowerBoundValue) {
-  SETUP_TRAITS();
-  auto model = Traits::createValid();
-  EXPECT_GT(model.getMemoryLowerBound(), 0u);
-}
-
-TYPED_TEST_P(CommonModelTest, GetMemoryLowerBoundConsistent) {
-  SETUP_TRAITS();
-  auto model = Traits::createValid();
-  auto bound1 = model.getMemoryLowerBound();
-  auto bound2 = model.getMemoryLowerBound();
-  EXPECT_EQ(bound1, bound2);
-}
-
-// Unload tests
-TYPED_TEST_P(CommonModelTest, UnloadDoesntThrow) {
-  SETUP_TRAITS();
-  auto model = Traits::createValid();
-  EXPECT_NO_THROW(model.unload());
-}
-
-TYPED_TEST_P(CommonModelTest, MultipleUnloadsSafe) {
-  SETUP_TRAITS();
-  auto model = Traits::createValid();
-  EXPECT_NO_THROW(model.unload());
-  EXPECT_NO_THROW(model.unload());
-  EXPECT_NO_THROW(model.unload());
-}
-
-TYPED_TEST_P(CommonModelTest, GenerateAfterUnloadThrows) {
-  SETUP_TRAITS();
-  auto model = Traits::createValid();
-  model.unload();
-  EXPECT_THROW(Traits::callGenerate(model), rnexecutorch::RnExecutorchError);
-}
-
-TYPED_TEST_P(CommonModelTest, MultipleGeneratesWork) {
-  SETUP_TRAITS();
-  auto model = Traits::createValid();
-  EXPECT_NO_THROW(Traits::callGenerate(model));
-  EXPECT_NO_THROW(Traits::callGenerate(model));
-  EXPECT_NO_THROW(Traits::callGenerate(model));
-}
-
-// Register all tests in the suite
-
-// TODO: Investigate why TextToImage fails on MultipleGeneratesWork in the
-// emulator environment
-REGISTER_TYPED_TEST_SUITE_P(CommonModelTest, InvalidPathThrows,
-                            ValidPathDoesntThrow, GetMemoryLowerBoundValue,
-                            GetMemoryLowerBoundConsistent, UnloadDoesntThrow,
-                            MultipleUnloadsSafe, GenerateAfterUnloadThrows,
-                            MultipleGeneratesWork);
-
-} // namespace model_tests
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/ClassificationTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/integration/ClassificationTest.cpp
deleted file mode 100644
index 6991c2fe06..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/integration/ClassificationTest.cpp
+++ /dev/null
@@ -1,164 +0,0 @@
-#include "BaseModelTests.h"
-#include "VisionModelTests.h"
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/host_objects/JSTensorViewIn.h>
-#include <rnexecutorch/models/classification/Classification.h>
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::classification;
-using namespace model_tests;
-
-constexpr auto kValidClassificationModelPath = "efficientnet_v2_s_xnnpack.pte";
-constexpr auto kValidTestImagePath =
-    "file:///data/local/tmp/rnexecutorch_tests/test_image.jpg";
-constexpr size_t kImagenet1kNumClasses = 1000;
-
-static std::vector<float> kImagenetNormMean = {0.485f, 0.456f, 0.406f};
-static std::vector<float> kImagenetNormStd = {0.229f, 0.224f, 0.225f};
-
-static std::vector<std::string> getImagenetLabelNames() {
-  std::vector<std::string> names;
-  names.reserve(kImagenet1kNumClasses);
-  for (size_t i = 0; i < kImagenet1kNumClasses; ++i) {
-    names.emplace_back("class_" + std::to_string(i));
-  }
-  return names;
-}
-
-// ============================================================================
-// Common tests via typed test suite
-// ============================================================================
-namespace model_tests {
-template <> struct ModelTraits<Classification> {
-  using ModelType = Classification;
-
-  static ModelType createValid() {
-    return ModelType(kValidClassificationModelPath, kImagenetNormMean,
-                     kImagenetNormStd, getImagenetLabelNames(), nullptr);
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.pte", {}, {}, {}, nullptr);
-  }
-
-  static void callGenerate(ModelType &model) {
-    (void)model.generateFromString(kValidTestImagePath);
-  }
-};
-} // namespace model_tests
-
-using ClassificationTypes = ::testing::Types<Classification>;
-INSTANTIATE_TYPED_TEST_SUITE_P(Classification, CommonModelTest,
-                               ClassificationTypes);
-INSTANTIATE_TYPED_TEST_SUITE_P(Classification, VisionModelTest,
-                               ClassificationTypes);
-
-// ============================================================================
-// Model-specific tests
-// ============================================================================
-TEST(ClassificationGenerateTests, InvalidImagePathThrows) {
-  Classification model(kValidClassificationModelPath, kImagenetNormMean,
-                       kImagenetNormStd, getImagenetLabelNames(), nullptr);
-  EXPECT_THROW((void)model.generateFromString("nonexistent_image.jpg"),
-               RnExecutorchError);
-}
-
-TEST(ClassificationGenerateTests, EmptyImagePathThrows) {
-  Classification model(kValidClassificationModelPath, kImagenetNormMean,
-                       kImagenetNormStd, getImagenetLabelNames(), nullptr);
-  EXPECT_THROW((void)model.generateFromString(""), RnExecutorchError);
-}
-
-TEST(ClassificationGenerateTests, MalformedURIThrows) {
-  Classification model(kValidClassificationModelPath, kImagenetNormMean,
-                       kImagenetNormStd, getImagenetLabelNames(), nullptr);
-  EXPECT_THROW((void)model.generateFromString("not_a_valid_uri://bad"),
-               RnExecutorchError);
-}
-
-TEST(ClassificationGenerateTests, ValidImageReturnsResults) {
-  Classification model(kValidClassificationModelPath, kImagenetNormMean,
-                       kImagenetNormStd, getImagenetLabelNames(), nullptr);
-  auto results = model.generateFromString(kValidTestImagePath);
-  EXPECT_FALSE(results.empty());
-}
-
-TEST(ClassificationGenerateTests, ResultsHaveCorrectSize) {
-  Classification model(kValidClassificationModelPath, kImagenetNormMean,
-                       kImagenetNormStd, getImagenetLabelNames(), nullptr);
-  auto results = model.generateFromString(kValidTestImagePath);
-  auto expectedNumClasses = kImagenet1kNumClasses;
-  EXPECT_EQ(results.size(), expectedNumClasses);
-}
-
-TEST(ClassificationGenerateTests, ResultsContainValidProbabilities) {
-  Classification model(kValidClassificationModelPath, kImagenetNormMean,
-                       kImagenetNormStd, getImagenetLabelNames(), nullptr);
-  auto results = model.generateFromString(kValidTestImagePath);
-
-  float sum = 0.0f;
-  for (const auto &[label, prob] : results) {
-    EXPECT_GE(prob, 0.0f);
-    EXPECT_LE(prob, 1.0f);
-    sum += prob;
-  }
-  EXPECT_NEAR(sum, 1.0f, 0.01f);
-}
-
-TEST(ClassificationGenerateTests, TopPredictionHasReasonableConfidence) {
-  Classification model(kValidClassificationModelPath, kImagenetNormMean,
-                       kImagenetNormStd, getImagenetLabelNames(), nullptr);
-  auto results = model.generateFromString(kValidTestImagePath);
-
-  float maxProb = 0.0f;
-  for (const auto &[label, prob] : results) {
-    if (prob > maxProb) {
-      maxProb = prob;
-    }
-  }
-  EXPECT_GT(maxProb, 0.0f);
-}
-
-TEST(ClassificationGenerateTests, WrongLabelCountThrows) {
-  Classification model(kValidClassificationModelPath, kImagenetNormMean,
-                       kImagenetNormStd, {"A", "B", "C"}, nullptr);
-  EXPECT_THROW((void)model.generateFromString(kValidTestImagePath),
-               RnExecutorchError);
-}
-
-TEST(ClassificationInheritedTests, GetInputShapeWorks) {
-  Classification model(kValidClassificationModelPath, kImagenetNormMean,
-                       kImagenetNormStd, getImagenetLabelNames(), nullptr);
-  auto shape = model.getInputShape("forward", 0);
-  EXPECT_EQ(shape.size(), 4);
-  EXPECT_EQ(shape[0], 1);
-  EXPECT_EQ(shape[1], 3);
-}
-
-TEST(ClassificationInheritedTests, GetAllInputShapesWorks) {
-  Classification model(kValidClassificationModelPath, kImagenetNormMean,
-                       kImagenetNormStd, getImagenetLabelNames(), nullptr);
-  auto shapes = model.getAllInputShapes("forward");
-  EXPECT_FALSE(shapes.empty());
-}
-
-TEST(ClassificationInheritedTests, GetMethodMetaWorks) {
-  Classification model(kValidClassificationModelPath, kImagenetNormMean,
-                       kImagenetNormStd, getImagenetLabelNames(), nullptr);
-  auto result = model.getMethodMeta("forward");
-  EXPECT_TRUE(result.ok());
-}
-
-// ============================================================================
-// generateFromPixels smoke test
-// ============================================================================
-TEST(ClassificationPixelTests, ValidPixelsReturnsResults) {
-  Classification model(kValidClassificationModelPath, kImagenetNormMean,
-                       kImagenetNormStd, getImagenetLabelNames(), nullptr);
-  std::vector<uint8_t> buf(64 * 64 * 3, 128);
-  JSTensorViewIn view{
-      buf.data(), {64, 64, 3}, executorch::aten::ScalarType::Byte};
-  auto results = model.generateFromPixels(view);
-  EXPECT_FALSE(results.empty());
-}
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/ImageEmbeddingsTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/integration/ImageEmbeddingsTest.cpp
deleted file mode 100644
index 4982206614..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/integration/ImageEmbeddingsTest.cpp
+++ /dev/null
@@ -1,142 +0,0 @@
-#include "BaseModelTests.h"
-#include "VisionModelTests.h"
-#include <cmath>
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/host_objects/JSTensorViewIn.h>
-#include <rnexecutorch/models/embeddings/image/ImageEmbeddings.h>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::embeddings;
-using namespace model_tests;
-
-constexpr auto kValidImageEmbeddingsModelPath =
-    "clip-vit-base-patch32-vision_xnnpack.pte";
-constexpr auto kValidTestImagePath =
-    "file:///data/local/tmp/rnexecutorch_tests/test_image.jpg";
-
-// ============================================================================
-// Common tests via typed test suite
-// ============================================================================
-namespace model_tests {
-template <> struct ModelTraits<ImageEmbeddings> {
-  using ModelType = ImageEmbeddings;
-
-  static ModelType createValid() {
-    return ModelType(kValidImageEmbeddingsModelPath, nullptr);
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.pte", nullptr);
-  }
-
-  static void callGenerate(ModelType &model) {
-    (void)model.generateFromString(kValidTestImagePath);
-  }
-};
-} // namespace model_tests
-
-using ImageEmbeddingsTypes = ::testing::Types<ImageEmbeddings>;
-INSTANTIATE_TYPED_TEST_SUITE_P(ImageEmbeddings, CommonModelTest,
-                               ImageEmbeddingsTypes);
-INSTANTIATE_TYPED_TEST_SUITE_P(ImageEmbeddings, VisionModelTest,
-                               ImageEmbeddingsTypes);
-
-// ============================================================================
-// Model-specific tests
-// ============================================================================
-TEST(ImageEmbeddingsGenerateTests, InvalidImagePathThrows) {
-  ImageEmbeddings model(kValidImageEmbeddingsModelPath, nullptr);
-  EXPECT_THROW((void)model.generateFromString("nonexistent_image.jpg"),
-               RnExecutorchError);
-}
-
-TEST(ImageEmbeddingsGenerateTests, EmptyImagePathThrows) {
-  ImageEmbeddings model(kValidImageEmbeddingsModelPath, nullptr);
-  EXPECT_THROW((void)model.generateFromString(""), RnExecutorchError);
-}
-
-TEST(ImageEmbeddingsGenerateTests, MalformedURIThrows) {
-  ImageEmbeddings model(kValidImageEmbeddingsModelPath, nullptr);
-  EXPECT_THROW((void)model.generateFromString("not_a_valid_uri://bad"),
-               RnExecutorchError);
-}
-
-TEST(ImageEmbeddingsGenerateTests, ValidImageReturnsResults) {
-  ImageEmbeddings model(kValidImageEmbeddingsModelPath, nullptr);
-  auto result = model.generateFromString(kValidTestImagePath);
-  EXPECT_NE(result, nullptr);
-  EXPECT_GT(result->size(), 0u);
-}
-
-TEST(ImageEmbeddingsGenerateTests, ResultsHaveCorrectSize) {
-  ImageEmbeddings model(kValidImageEmbeddingsModelPath, nullptr);
-  auto result = model.generateFromString(kValidTestImagePath);
-  size_t numFloats = result->size() / sizeof(float);
-  constexpr size_t kClipEmbeddingDimensions = 512;
-  EXPECT_EQ(numFloats, kClipEmbeddingDimensions);
-}
-
-TEST(ImageEmbeddingsGenerateTests, ResultsAreNormalized) {
-  // TODO: Investigate the source of the issue;
-  GTEST_SKIP() << "Expected to fail in emulator environments";
-  ImageEmbeddings model(kValidImageEmbeddingsModelPath, nullptr);
-  auto result = model.generateFromString(kValidTestImagePath);
-
-  const float *data = reinterpret_cast<const float *>(result->data());
-  size_t numFloats = result->size() / sizeof(float);
-
-  float sumOfSquares = 0.0f;
-  for (size_t i = 0; i < numFloats; ++i) {
-    sumOfSquares += data[i] * data[i];
-  }
-  float norm = std::sqrt(sumOfSquares);
-  EXPECT_NEAR(norm, 1.0f, 0.01f);
-}
-
-TEST(ImageEmbeddingsGenerateTests, ResultsContainValidValues) {
-  ImageEmbeddings model(kValidImageEmbeddingsModelPath, nullptr);
-  auto result = model.generateFromString(kValidTestImagePath);
-
-  const float *data = reinterpret_cast<const float *>(result->data());
-  size_t numFloats = result->size() / sizeof(float);
-
-  for (size_t i = 0; i < numFloats; ++i) {
-    EXPECT_FALSE(std::isnan(data[i]));
-    EXPECT_FALSE(std::isinf(data[i]));
-  }
-}
-
-TEST(ImageEmbeddingsInheritedTests, GetInputShapeWorks) {
-  ImageEmbeddings model(kValidImageEmbeddingsModelPath, nullptr);
-  auto shape = model.getInputShape("forward", 0);
-  EXPECT_EQ(shape.size(), 4);
-  EXPECT_EQ(shape[0], 1);
-  EXPECT_EQ(shape[1], 3);
-}
-
-TEST(ImageEmbeddingsInheritedTests, GetAllInputShapesWorks) {
-  ImageEmbeddings model(kValidImageEmbeddingsModelPath, nullptr);
-  auto shapes = model.getAllInputShapes("forward");
-  EXPECT_FALSE(shapes.empty());
-}
-
-TEST(ImageEmbeddingsInheritedTests, GetMethodMetaWorks) {
-  ImageEmbeddings model(kValidImageEmbeddingsModelPath, nullptr);
-  auto result = model.getMethodMeta("forward");
-  EXPECT_TRUE(result.ok());
-}
-
-// ============================================================================
-// generateFromPixels smoke test
-// ============================================================================
-TEST(ImageEmbeddingsPixelTests, ValidPixelsReturnsEmbedding) {
-  ImageEmbeddings model(kValidImageEmbeddingsModelPath, nullptr);
-  std::vector<uint8_t> buf(64 * 64 * 3, 128);
-  JSTensorViewIn view{
-      buf.data(), {64, 64, 3}, executorch::aten::ScalarType::Byte};
-  auto result = model.generateFromPixels(view);
-  EXPECT_NE(result, nullptr);
-  EXPECT_GT(result->size(), 0u);
-}
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/InstanceSegmentationTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/integration/InstanceSegmentationTest.cpp
deleted file mode 100644
index ff003eb62d..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/integration/InstanceSegmentationTest.cpp
+++ /dev/null
@@ -1,338 +0,0 @@
-#include "BaseModelTests.h"
-#include "VisionModelTests.h"
-#include <executorch/extension/tensor/tensor.h>
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/host_objects/JSTensorViewIn.h>
-#include <rnexecutorch/models/instance_segmentation/BaseInstanceSegmentation.h>
-#include <rnexecutorch/models/instance_segmentation/Types.h>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::instance_segmentation;
-using namespace model_tests;
-
-constexpr auto kValidInstanceSegModelPath = "yolo26n-seg.pte";
-constexpr auto kValidTestImagePath =
-    "file:///data/local/tmp/rnexecutorch_tests/segmentation_image.jpg";
-constexpr auto kMethodName = "forward_384";
-
-// ============================================================================
-// Common tests via typed test suite
-// ============================================================================
-namespace model_tests {
-template <> struct ModelTraits<BaseInstanceSegmentation> {
-  using ModelType = BaseInstanceSegmentation;
-
-  static ModelType createValid() {
-    return ModelType(kValidInstanceSegModelPath, {}, {}, true, nullptr);
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.pte", {}, {}, true, nullptr);
-  }
-
-  static void callGenerate(ModelType &model) {
-    (void)model.generateFromString(kValidTestImagePath, 0.5, 0.5, 100, {}, true,
-                                   kMethodName);
-  }
-};
-} // namespace model_tests
-
-using InstanceSegmentationTypes = ::testing::Types<BaseInstanceSegmentation>;
-INSTANTIATE_TYPED_TEST_SUITE_P(InstanceSegmentation, CommonModelTest,
-                               InstanceSegmentationTypes);
-INSTANTIATE_TYPED_TEST_SUITE_P(InstanceSegmentation, VisionModelTest,
-                               InstanceSegmentationTypes);
-
-// ============================================================================
-// Model-specific tests
-// ============================================================================
-TEST(InstanceSegGenerateTests, InvalidImagePathThrows) {
-  BaseInstanceSegmentation model(kValidInstanceSegModelPath, {}, {}, true,
-                                 nullptr);
-  EXPECT_THROW((void)model.generateFromString("nonexistent_image.jpg", 0.5, 0.5,
-                                              100, {}, true, kMethodName),
-               RnExecutorchError);
-}
-
-TEST(InstanceSegGenerateTests, EmptyImagePathThrows) {
-  BaseInstanceSegmentation model(kValidInstanceSegModelPath, {}, {}, true,
-                                 nullptr);
-  EXPECT_THROW(
-      (void)model.generateFromString("", 0.5, 0.5, 100, {}, true, kMethodName),
-      RnExecutorchError);
-}
-
-TEST(InstanceSegGenerateTests, EmptyMethodNameThrows) {
-  BaseInstanceSegmentation model(kValidInstanceSegModelPath, {}, {}, true,
-                                 nullptr);
-  EXPECT_THROW((void)model.generateFromString(kValidTestImagePath, 0.5, 0.5,
-                                              100, {}, true, ""),
-               RnExecutorchError);
-}
-
-TEST(InstanceSegGenerateTests, NegativeConfidenceThrows) {
-  BaseInstanceSegmentation model(kValidInstanceSegModelPath, {}, {}, true,
-                                 nullptr);
-  EXPECT_THROW((void)model.generateFromString(kValidTestImagePath, -0.1, 0.5,
-                                              100, {}, true, kMethodName),
-               RnExecutorchError);
-}
-
-TEST(InstanceSegGenerateTests, ConfidenceAboveOneThrows) {
-  BaseInstanceSegmentation model(kValidInstanceSegModelPath, {}, {}, true,
-                                 nullptr);
-  EXPECT_THROW((void)model.generateFromString(kValidTestImagePath, 1.1, 0.5,
-                                              100, {}, true, kMethodName),
-               RnExecutorchError);
-}
-
-TEST(InstanceSegGenerateTests, NegativeIouThresholdThrows) {
-  BaseInstanceSegmentation model(kValidInstanceSegModelPath, {}, {}, true,
-                                 nullptr);
-  EXPECT_THROW((void)model.generateFromString(kValidTestImagePath, 0.5, -0.1,
-                                              100, {}, true, kMethodName),
-               RnExecutorchError);
-}
-
-TEST(InstanceSegGenerateTests, IouThresholdAboveOneThrows) {
-  BaseInstanceSegmentation model(kValidInstanceSegModelPath, {}, {}, true,
-                                 nullptr);
-  EXPECT_THROW((void)model.generateFromString(kValidTestImagePath, 0.5, 1.1,
-                                              100, {}, true, kMethodName),
-               RnExecutorchError);
-}
-
-TEST(InstanceSegGenerateTests, ValidImageReturnsResults) {
-  BaseInstanceSegmentation model(kValidInstanceSegModelPath, {}, {}, true,
-                                 nullptr);
-  auto results = model.generateFromString(kValidTestImagePath, 0.3, 0.5, 100,
-                                          {}, true, kMethodName);
-  EXPECT_FALSE(results.empty());
-}
-
-TEST(InstanceSegGenerateTests, HighThresholdReturnsFewerResults) {
-  BaseInstanceSegmentation model(kValidInstanceSegModelPath, {}, {}, true,
-                                 nullptr);
-  auto lowResults = model.generateFromString(kValidTestImagePath, 0.1, 0.5, 100,
-                                             {}, true, kMethodName);
-  auto highResults = model.generateFromString(kValidTestImagePath, 0.9, 0.5,
-                                              100, {}, true, kMethodName);
-  EXPECT_GE(lowResults.size(), highResults.size());
-}
-
-TEST(InstanceSegGenerateTests, MaxInstancesLimitsResults) {
-  BaseInstanceSegmentation model(kValidInstanceSegModelPath, {}, {}, true,
-                                 nullptr);
-  auto results = model.generateFromString(kValidTestImagePath, 0.1, 0.5, 2, {},
-                                          true, kMethodName);
-  EXPECT_LE(results.size(), 2u);
-}
-
-// ============================================================================
-// Result validation tests
-// ============================================================================
-TEST(InstanceSegResultTests, InstancesHaveValidBoundingBoxes) {
-  BaseInstanceSegmentation model(kValidInstanceSegModelPath, {}, {}, true,
-                                 nullptr);
-  auto results = model.generateFromString(kValidTestImagePath, 0.3, 0.5, 100,
-                                          {}, true, kMethodName);
-
-  for (const auto &inst : results) {
-    EXPECT_LE(inst.bbox.p1.x, inst.bbox.p2.x);
-    EXPECT_LE(inst.bbox.p1.y, inst.bbox.p2.y);
-    EXPECT_GE(inst.bbox.p1.x, 0.0f);
-    EXPECT_GE(inst.bbox.p1.y, 0.0f);
-  }
-}
-
-TEST(InstanceSegResultTests, InstancesHaveValidScores) {
-  BaseInstanceSegmentation model(kValidInstanceSegModelPath, {}, {}, true,
-                                 nullptr);
-  auto results = model.generateFromString(kValidTestImagePath, 0.3, 0.5, 100,
-                                          {}, true, kMethodName);
-
-  for (const auto &inst : results) {
-    EXPECT_GE(inst.score, 0.0f);
-    EXPECT_LE(inst.score, 1.0f);
-  }
-}
-
-TEST(InstanceSegResultTests, InstancesHaveValidMasks) {
-  BaseInstanceSegmentation model(kValidInstanceSegModelPath, {}, {}, true,
-                                 nullptr);
-  auto results = model.generateFromString(kValidTestImagePath, 0.3, 0.5, 100,
-                                          {}, true, kMethodName);
-
-  for (const auto &inst : results) {
-    EXPECT_GT(inst.maskWidth, 0);
-    EXPECT_GT(inst.maskHeight, 0);
-    EXPECT_EQ(inst.mask->size(),
-              static_cast<size_t>(inst.maskWidth) * inst.maskHeight);
-
-    for (size_t i = 0; i < inst.mask->size(); ++i) {
-      uint8_t val = inst.mask->data()[i];
-      EXPECT_TRUE(val == 0 || val == 1);
-    }
-  }
-}
-
-TEST(InstanceSegResultTests, InstancesHaveValidClassIndices) {
-  BaseInstanceSegmentation model(kValidInstanceSegModelPath, {}, {}, true,
-                                 nullptr);
-  auto results = model.generateFromString(kValidTestImagePath, 0.3, 0.5, 100,
-                                          {}, true, kMethodName);
-
-  for (const auto &inst : results) {
-    EXPECT_GE(inst.classIndex, 0);
-    EXPECT_LT(inst.classIndex, 80); // COCO YOLO has 80 classes
-  }
-}
-
-// ============================================================================
-// Class filtering tests
-// ============================================================================
-TEST(InstanceSegFilterTests, ClassFilterReturnsOnlyMatchingClasses) {
-  BaseInstanceSegmentation model(kValidInstanceSegModelPath, {}, {}, true,
-                                 nullptr);
-  // Filter to class index 0 (PERSON in CocoLabelYolo)
-  std::vector<int32_t> classIndices = {0};
-  auto results = model.generateFromString(kValidTestImagePath, 0.3, 0.5, 100,
-                                          classIndices, true, kMethodName);
-
-  for (const auto &inst : results) {
-    EXPECT_EQ(inst.classIndex, 0);
-  }
-}
-
-TEST(InstanceSegFilterTests, EmptyFilterReturnsAllClasses) {
-  BaseInstanceSegmentation model(kValidInstanceSegModelPath, {}, {}, true,
-                                 nullptr);
-  auto allResults = model.generateFromString(kValidTestImagePath, 0.3, 0.5, 100,
-                                             {}, true, kMethodName);
-  EXPECT_FALSE(allResults.empty());
-
-  auto noResults = model.generateFromString(kValidTestImagePath, 0.3, 0.5, 100,
-                                            {50}, true, kMethodName);
-  EXPECT_TRUE(noResults.empty());
-}
-
-// ============================================================================
-// Mask resolution tests
-// ============================================================================
-TEST(InstanceSegMaskTests, LowResMaskIsSmallerThanOriginal) {
-  BaseInstanceSegmentation model(kValidInstanceSegModelPath, {}, {}, true,
-                                 nullptr);
-  auto hiRes = model.generateFromString(kValidTestImagePath, 0.3, 0.5, 100, {},
-                                        true, kMethodName);
-  auto loRes = model.generateFromString(kValidTestImagePath, 0.3, 0.5, 100, {},
-                                        false, kMethodName);
-
-  if (!hiRes.empty() && !loRes.empty()) {
-    EXPECT_LE(loRes[0].mask->size(), hiRes[0].mask->size());
-  }
-}
-
-// ============================================================================
-// NMS tests
-// ============================================================================
-TEST(InstanceSegNMSTests, NMSEnabledReturnsFewerOrEqualResults) {
-  BaseInstanceSegmentation modelWithNMS(kValidInstanceSegModelPath, {}, {},
-                                        true, nullptr);
-  BaseInstanceSegmentation modelWithoutNMS(kValidInstanceSegModelPath, {}, {},
-                                           false, nullptr);
-
-  auto nmsResults = modelWithNMS.generateFromString(
-      kValidTestImagePath, 0.3, 0.5, 100, {}, true, kMethodName);
-  auto noNmsResults = modelWithoutNMS.generateFromString(
-      kValidTestImagePath, 0.3, 0.5, 100, {}, true, kMethodName);
-
-  EXPECT_LE(nmsResults.size(), noNmsResults.size());
-}
-
-// ============================================================================
-// generateFromPixels tests
-// ============================================================================
-TEST(InstanceSegPixelTests, ValidPixelDataReturnsResults) {
-  BaseInstanceSegmentation model(kValidInstanceSegModelPath, {}, {}, true,
-                                 nullptr);
-  constexpr int32_t width = 4, height = 4, channels = 3;
-  std::vector<uint8_t> pixelData(width * height * channels, 128);
-  JSTensorViewIn tensorView{pixelData.data(),
-                            {height, width, channels},
-                            executorch::aten::ScalarType::Byte};
-  auto results = model.generateFromPixels(tensorView, 0.3, 0.5, 100, {}, true,
-                                          kMethodName);
-  EXPECT_GE(results.size(), 0u);
-}
-
-TEST(InstanceSegPixelTests, NegativeConfidenceThrows) {
-  BaseInstanceSegmentation model(kValidInstanceSegModelPath, {}, {}, true,
-                                 nullptr);
-  constexpr int32_t width = 4, height = 4, channels = 3;
-  std::vector<uint8_t> pixelData(width * height * channels, 128);
-  JSTensorViewIn tensorView{pixelData.data(),
-                            {height, width, channels},
-                            executorch::aten::ScalarType::Byte};
-  EXPECT_THROW((void)model.generateFromPixels(tensorView, -0.1, 0.5, 100, {},
-                                              true, kMethodName),
-               RnExecutorchError);
-}
-
-TEST(InstanceSegPixelTests, ConfidenceAboveOneThrows) {
-  BaseInstanceSegmentation model(kValidInstanceSegModelPath, {}, {}, true,
-                                 nullptr);
-  constexpr int32_t width = 4, height = 4, channels = 3;
-  std::vector<uint8_t> pixelData(width * height * channels, 128);
-  JSTensorViewIn tensorView{pixelData.data(),
-                            {height, width, channels},
-                            executorch::aten::ScalarType::Byte};
-  EXPECT_THROW((void)model.generateFromPixels(tensorView, 1.1, 0.5, 100, {},
-                                              true, kMethodName),
-               RnExecutorchError);
-}
-
-// ============================================================================
-// Inherited method tests
-// ============================================================================
-TEST(InstanceSegInheritedTests, GetInputShapeWorks) {
-  BaseInstanceSegmentation model(kValidInstanceSegModelPath, {}, {}, true,
-                                 nullptr);
-  auto shape = model.getInputShape(kMethodName, 0);
-  EXPECT_EQ(shape.size(), 4);
-  EXPECT_EQ(shape[0], 1);
-  EXPECT_EQ(shape[1], 3);
-}
-
-TEST(InstanceSegInheritedTests, GetAllInputShapesWorks) {
-  BaseInstanceSegmentation model(kValidInstanceSegModelPath, {}, {}, true,
-                                 nullptr);
-  auto shapes = model.getAllInputShapes(kMethodName);
-  EXPECT_FALSE(shapes.empty());
-}
-
-TEST(InstanceSegInheritedTests, GetMethodMetaWorks) {
-  BaseInstanceSegmentation model(kValidInstanceSegModelPath, {}, {}, true,
-                                 nullptr);
-  auto result = model.getMethodMeta(kMethodName);
-  EXPECT_TRUE(result.ok());
-}
-
-// ============================================================================
-// Normalisation tests
-// ============================================================================
-TEST(InstanceSegNormTests, ValidNormParamsDoesntThrow) {
-  const std::vector<float> mean = {0.485f, 0.456f, 0.406f};
-  const std::vector<float> std = {0.229f, 0.224f, 0.225f};
-  EXPECT_NO_THROW(BaseInstanceSegmentation(kValidInstanceSegModelPath, mean,
-                                           std, true, nullptr));
-}
-
-TEST(InstanceSegNormTests, ValidNormParamsGenerateSucceeds) {
-  const std::vector<float> mean = {0.485f, 0.456f, 0.406f};
-  const std::vector<float> std = {0.229f, 0.224f, 0.225f};
-  BaseInstanceSegmentation model(kValidInstanceSegModelPath, mean, std, true,
-                                 nullptr);
-  EXPECT_NO_THROW((void)model.generateFromString(kValidTestImagePath, 0.5, 0.5,
-                                                 100, {}, true, kMethodName));
-}
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/LLMTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/integration/LLMTest.cpp
deleted file mode 100644
index 4b34f4248e..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/integration/LLMTest.cpp
+++ /dev/null
@@ -1,415 +0,0 @@
-#include "BaseModelTests.h"
-#include "utils/TestUtils.h"
-#include <gtest/gtest.h>
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include <ReactCommon/CallInvoker.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/models/llm/LLM.h>
-#include <runner/encoders/audio_encoder.h>
-#include <runner/encoders/vision_encoder.h>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::llm;
-using namespace model_tests;
-
-constexpr auto kValidModelPath = "smolLm2_135M_8da4w.pte";
-constexpr auto kValidTokenizerPath = "smollm_tokenizer.json";
-constexpr auto kSystemPrompt = "You are a helpful assistant. Assist the user "
-                               "to the best of your abilities.";
-
-// Forward declaration from jsi_stubs.cpp
-namespace rnexecutorch {
-std::shared_ptr<facebook::react::CallInvoker> createMockCallInvoker();
-}
-
-// Helper to format prompt in ChatML format for SmolLM2
-std::string formatChatML(const std::string &systemPrompt,
-                         const std::string &userMessage) {
-  return "<|im_start|>system\n" + systemPrompt + "<|im_end|>\n" +
-         "<|im_start|>user\n" + userMessage + "<|im_end|>\n" +
-         "<|im_start|>assistant\n";
-}
-
-// Helper to format a single-turn prompt in Gemma's chat template.
-std::string formatGemma(const std::string &userMessage) {
-  return "<start_of_turn>user\n" + userMessage + "<end_of_turn>\n" +
-         "<start_of_turn>model\n";
-}
-
-// ============================================================================
-// Common tests via typed test suite
-// ============================================================================
-namespace model_tests {
-template <> struct ModelTraits<LLM> {
-  using ModelType = LLM;
-
-  static ModelType createValid() {
-    return ModelType(kValidModelPath, kValidTokenizerPath, {},
-                     rnexecutorch::createMockCallInvoker());
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.pte", kValidTokenizerPath, {},
-                     rnexecutorch::createMockCallInvoker());
-  }
-
-  static void callGenerate(ModelType &model) {
-    std::string prompt = formatChatML(kSystemPrompt, "Hello");
-    (void)model.generate(prompt, nullptr);
-  }
-};
-} // namespace model_tests
-
-using LLMTypes = ::testing::Types<LLM>;
-INSTANTIATE_TYPED_TEST_SUITE_P(LLM, CommonModelTest, LLMTypes);
-
-// ============================================================================
-// LLM-specific fixture tests
-// ============================================================================
-class LLMTest : public ::testing::Test {
-protected:
-  std::shared_ptr<facebook::react::CallInvoker> mockInvoker_;
-
-  void SetUp() override { mockInvoker_ = createMockCallInvoker(); }
-};
-
-TEST(LLMCtorTests, InvalidTokenizerPathThrows) {
-  EXPECT_THROW(LLM(kValidModelPath, "nonexistent_tokenizer.json", {},
-                   createMockCallInvoker()),
-               RnExecutorchError);
-}
-
-TEST(LLMCtorTests, WrongCapabilitiesThrowsClearError) {
-  EXPECT_THROW(LLM(kValidModelPath, kValidTokenizerPath, {"vision"},
-                   createMockCallInvoker()),
-               rnexecutorch::RnExecutorchError);
-}
-
-TEST_F(LLMTest, GetGeneratedTokenCountInitiallyZero) {
-  LLM model(kValidModelPath, kValidTokenizerPath, {}, mockInvoker_);
-  EXPECT_EQ(model.getGeneratedTokenCount(), 0);
-}
-
-TEST_F(LLMTest, SetTemperature) {
-  LLM model(kValidModelPath, kValidTokenizerPath, {}, mockInvoker_);
-  // Should not throw for valid values
-  EXPECT_NO_THROW(model.setTemperature(0.5f));
-  EXPECT_NO_THROW(model.setTemperature(1.0f));
-  EXPECT_NO_THROW(model.setTemperature(0.0f));
-}
-
-TEST_F(LLMTest, SetTemperatureNegativeThrows) {
-  LLM model(kValidModelPath, kValidTokenizerPath, {}, mockInvoker_);
-  EXPECT_THROW(model.setTemperature(-0.1f), RnExecutorchError);
-}
-
-TEST_F(LLMTest, SetTopp) {
-  LLM model(kValidModelPath, kValidTokenizerPath, {}, mockInvoker_);
-  EXPECT_NO_THROW(model.setTopp(0.9f));
-  EXPECT_NO_THROW(model.setTopp(0.5f));
-  EXPECT_NO_THROW(model.setTopp(1.0f));
-}
-
-TEST_F(LLMTest, SetToppInvalidThrows) {
-  LLM model(kValidModelPath, kValidTokenizerPath, {}, mockInvoker_);
-  EXPECT_THROW(model.setTopp(-0.1f), RnExecutorchError);
-  EXPECT_THROW(model.setTopp(1.1f), RnExecutorchError);
-}
-
-TEST_F(LLMTest, SetMinP) {
-  LLM model(kValidModelPath, kValidTokenizerPath, {}, mockInvoker_);
-  EXPECT_NO_THROW(model.setMinP(0.0f));
-  EXPECT_NO_THROW(model.setMinP(0.15f));
-  EXPECT_NO_THROW(model.setMinP(1.0f));
-}
-
-TEST_F(LLMTest, SetMinPInvalidThrows) {
-  LLM model(kValidModelPath, kValidTokenizerPath, {}, mockInvoker_);
-  EXPECT_THROW(model.setMinP(-0.1f), RnExecutorchError);
-  EXPECT_THROW(model.setMinP(1.1f), RnExecutorchError);
-}
-
-TEST_F(LLMTest, SetRepetitionPenalty) {
-  LLM model(kValidModelPath, kValidTokenizerPath, {}, mockInvoker_);
-  EXPECT_NO_THROW(model.setRepetitionPenalty(1.0f));
-  EXPECT_NO_THROW(model.setRepetitionPenalty(1.05f));
-  EXPECT_NO_THROW(model.setRepetitionPenalty(2.0f));
-}
-
-TEST_F(LLMTest, SetRepetitionPenaltyInvalidThrows) {
-  LLM model(kValidModelPath, kValidTokenizerPath, {}, mockInvoker_);
-  EXPECT_THROW(model.setRepetitionPenalty(-0.1f), RnExecutorchError);
-}
-
-TEST_F(LLMTest, SetCountInterval) {
-  LLM model(kValidModelPath, kValidTokenizerPath, {}, mockInvoker_);
-  EXPECT_NO_THROW(model.setCountInterval(5));
-  EXPECT_NO_THROW(model.setCountInterval(10));
-}
-
-TEST_F(LLMTest, SetTimeInterval) {
-  LLM model(kValidModelPath, kValidTokenizerPath, {}, mockInvoker_);
-  EXPECT_NO_THROW(model.setTimeInterval(100));
-  EXPECT_NO_THROW(model.setTimeInterval(500));
-}
-
-TEST_F(LLMTest, InterruptThrowsWhenUnloaded) {
-  LLM model(kValidModelPath, kValidTokenizerPath, {}, mockInvoker_);
-  model.unload();
-  EXPECT_THROW(model.interrupt(), RnExecutorchError);
-}
-
-TEST_F(LLMTest, SettersThrowWhenUnloaded) {
-  LLM model(kValidModelPath, kValidTokenizerPath, {}, mockInvoker_);
-  model.unload();
-  // All setters should throw when model is unloaded
-  EXPECT_THROW(model.setTemperature(0.5f), RnExecutorchError);
-  EXPECT_THROW(model.setTopp(0.9f), RnExecutorchError);
-  EXPECT_THROW(model.setCountInterval(5), RnExecutorchError);
-  EXPECT_THROW(model.setTimeInterval(100), RnExecutorchError);
-}
-
-TEST_F(LLMTest, GenerateProducesValidOutput) {
-  LLM model(kValidModelPath, kValidTokenizerPath, {}, mockInvoker_);
-  model.setTemperature(0.0f);
-  std::string prompt =
-      formatChatML(kSystemPrompt, "Repeat exactly this: `naszponcilem testy`");
-  std::string output = model.generate(prompt, nullptr);
-  EXPECT_EQ(output, "`naszponcilem testy`<|im_end|>");
-}
-
-TEST_F(LLMTest, GenerateUpdatesTokenCount) {
-  LLM model(kValidModelPath, kValidTokenizerPath, {}, mockInvoker_);
-  EXPECT_EQ(model.getGeneratedTokenCount(), 0);
-  std::string prompt =
-      formatChatML(kSystemPrompt, "Repeat exactly this: 'naszponcilem testy'");
-  model.generate(prompt, nullptr);
-  EXPECT_GT(model.getGeneratedTokenCount(), 0);
-}
-
-TEST_F(LLMTest, EmptyPromptThrows) {
-  LLM model(kValidModelPath, kValidTokenizerPath, {}, mockInvoker_);
-  EXPECT_THROW((void)model.generate("", nullptr), RnExecutorchError);
-}
-
-TEST_F(LLMTest, CountTextTokensPositive) {
-  LLM model(kValidModelPath, kValidTokenizerPath, {}, mockInvoker_);
-  EXPECT_GT(model.countTextTokens("hello world"), 0);
-}
-
-TEST_F(LLMTest, CountTextTokensEmptyString) {
-  LLM model(kValidModelPath, kValidTokenizerPath, {}, mockInvoker_);
-  EXPECT_GE(model.countTextTokens(""), 0);
-}
-
-TEST_F(LLMTest, GetMaxContextLengthPositive) {
-  LLM model(kValidModelPath, kValidTokenizerPath, {}, mockInvoker_);
-  EXPECT_GT(model.getMaxContextLength(), 0);
-}
-
-TEST_F(LLMTest, ResetZerosGeneratedTokenCount) {
-  LLM model(kValidModelPath, kValidTokenizerPath, {}, mockInvoker_);
-  model.generate(formatChatML(kSystemPrompt, "Hi"), nullptr);
-  EXPECT_GT(model.getGeneratedTokenCount(), 0);
-  model.reset();
-  EXPECT_EQ(model.getGeneratedTokenCount(), 0);
-}
-
-TEST_F(LLMTest, PromptTokenCountNonZeroAfterGenerate) {
-  LLM model(kValidModelPath, kValidTokenizerPath, {}, mockInvoker_);
-  model.generate(formatChatML(kSystemPrompt, "Hi"), nullptr);
-  EXPECT_GT(model.getPromptTokenCount(), 0);
-}
-
-TEST(VisionEncoderTest, LoadFailsWithClearErrorWhenMethodMissing) {
-  // smolLm2_135M_8da4w.pte has no vision_encoder method
-  auto module = std::make_unique<::executorch::extension::Module>(
-      "smolLm2_135M_8da4w.pte",
-      ::executorch::extension::Module::LoadMode::File);
-
-  auto encoder =
-      std::make_unique<executorch::extension::llm::VisionEncoder>(*module);
-
-  EXPECT_THROW(encoder->load(), rnexecutorch::RnExecutorchError);
-}
-
-TEST(AudioEncoderTest, LoadFailsWithClearErrorWhenMethodMissing) {
-  // smolLm2_135M_8da4w.pte has no audio_encoder method
-  auto module = std::make_unique<::executorch::extension::Module>(
-      "smolLm2_135M_8da4w.pte",
-      ::executorch::extension::Module::LoadMode::File);
-
-  auto encoder =
-      std::make_unique<executorch::extension::llm::AudioEncoder>(*module);
-
-  EXPECT_THROW(encoder->load(), rnexecutorch::RnExecutorchError);
-}
-
-// ============================================================================
-// VLM-specific tests
-// ============================================================================
-constexpr auto kVlmModelPath = "lfm2_5_vl_quantized_xnnpack_v2.pte";
-constexpr auto kVlmTokenizerPath = "lfm2_vl_tokenizer.json";
-constexpr auto kVlmImageToken = "<image>";
-constexpr auto kTestImagePath =
-    "file:///data/local/tmp/rnexecutorch_tests/test_image.jpg";
-
-TEST_F(LLMTest, TextModelIsNotMultimodal) {
-  LLM model(kValidModelPath, kValidTokenizerPath, {}, mockInvoker_);
-  EXPECT_EQ(model.getVisualTokenCount(), 0);
-}
-
-TEST_F(LLMTest, GenerateMultimodalOnTextModelThrows) {
-  LLM model(kValidModelPath, kValidTokenizerPath, {}, mockInvoker_);
-  // A text-only runner reports is_multimodal() == false, so any multimodal
-  // call must be rejected before the inputs are even inspected.
-  MultimodalInputs inputs{.images =
-                              ImageInputs{.paths = {}, .token = "<image>"}};
-  EXPECT_THROW(model.generateMultimodal("hello", nullptr, std::move(inputs)),
-               RnExecutorchError);
-}
-
-// Fixture that loads the VLM model once for all VLM tests
-class VLMTest : public ::testing::Test {
-protected:
-  static void SetUpTestSuite() {
-    invoker_ = createMockCallInvoker();
-    model_ =
-        std::make_unique<LLM>(kVlmModelPath, kVlmTokenizerPath,
-                              std::vector<std::string>{"vision"}, invoker_);
-  }
-
-  static void TearDownTestSuite() {
-    model_.reset();
-    invoker_.reset();
-  }
-
-  static std::shared_ptr<facebook::react::CallInvoker> invoker_;
-  static std::unique_ptr<LLM> model_;
-};
-
-std::shared_ptr<facebook::react::CallInvoker> VLMTest::invoker_;
-std::unique_ptr<LLM> VLMTest::model_;
-
-TEST_F(VLMTest, GenerateMultimodalEmptyImageTokenThrows) {
-  MultimodalInputs inputs{
-      .images = ImageInputs{.paths = {kTestImagePath}, .token = ""}};
-  EXPECT_THROW(model_->generateMultimodal("hello", nullptr, std::move(inputs)),
-               RnExecutorchError);
-}
-
-TEST_F(VLMTest, GenerateMultimodalMorePlaceholdersThanImagePaths) {
-  std::string prompt = std::string(kVlmImageToken) + " and " + kVlmImageToken;
-  MultimodalInputs inputs{.images = ImageInputs{.paths = {kTestImagePath},
-                                                .token = kVlmImageToken}};
-  EXPECT_THROW(model_->generateMultimodal(prompt, nullptr, std::move(inputs)),
-               RnExecutorchError);
-}
-
-TEST_F(VLMTest, GenerateMultimodalMoreImagePathsThanPlaceholders) {
-  std::string prompt = std::string(kVlmImageToken) + " describe";
-  MultimodalInputs inputs{
-      .images = ImageInputs{.paths = {kTestImagePath, kTestImagePath},
-                            .token = kVlmImageToken}};
-  EXPECT_THROW(model_->generateMultimodal(prompt, nullptr, std::move(inputs)),
-               RnExecutorchError);
-}
-
-// ============================================================================
-// Audio (Gemma 4) multimodal tests
-// ============================================================================
-constexpr auto kGemmaModelPath = "gemma4_e2b_mm_xnnpack.pte";
-constexpr auto kGemmaTokenizerPath = "gemma_tokenizer.json";
-constexpr auto kGemmaAudioToken = "<audio_soft_token>";
-constexpr auto kTestAudioPath = "test_audio_float.raw";
-
-// Fixture that loads the audio-capable Gemma model once for all audio tests.
-class GemmaAudioTest : public ::testing::Test {
-protected:
-  static void SetUpTestSuite() {
-    invoker_ = createMockCallInvoker();
-    model_ = std::make_unique<LLM>(kGemmaModelPath, kGemmaTokenizerPath,
-                                   std::vector<std::string>{"vision", "audio"},
-                                   invoker_);
-  }
-
-  static void TearDownTestSuite() {
-    model_.reset();
-    invoker_.reset();
-  }
-
-  static std::vector<float> loadAudio(size_t maxSamples = 32000) {
-    auto wav = test_utils::loadAudioFromFile(kTestAudioPath);
-    if (wav.size() > maxSamples) {
-      wav.resize(maxSamples);
-    }
-    return wav;
-  }
-
-  static std::shared_ptr<facebook::react::CallInvoker> invoker_;
-  static std::unique_ptr<LLM> model_;
-};
-
-std::shared_ptr<facebook::react::CallInvoker> GemmaAudioTest::invoker_;
-std::unique_ptr<LLM> GemmaAudioTest::model_;
-
-TEST_F(GemmaAudioTest, GenerateMultimodalNoInputsThrows) {
-  EXPECT_THROW(model_->generateMultimodal("hello", nullptr, {}),
-               RnExecutorchError);
-}
-
-TEST_F(GemmaAudioTest, GenerateMultimodalEmptyAudioTokenThrows) {
-  MultimodalInputs inputs{
-      .audios = AudioInputs{.waveforms = {loadAudio()}, .token = ""}};
-  EXPECT_THROW(model_->generateMultimodal("hello", nullptr, std::move(inputs)),
-               RnExecutorchError);
-}
-
-TEST_F(GemmaAudioTest, GenerateMultimodalMorePlaceholdersThanWaveformsThrows) {
-  std::string prompt =
-      std::string(kGemmaAudioToken) + " and " + kGemmaAudioToken;
-  MultimodalInputs inputs{.audios = AudioInputs{.waveforms = {loadAudio()},
-                                                .token = kGemmaAudioToken}};
-  EXPECT_THROW(model_->generateMultimodal(prompt, nullptr, std::move(inputs)),
-               RnExecutorchError);
-}
-
-TEST_F(GemmaAudioTest, GenerateMultimodalMoreWaveformsThanPlaceholdersThrows) {
-  std::string prompt = std::string(kGemmaAudioToken) + " describe";
-  MultimodalInputs inputs{
-      .audios = AudioInputs{.waveforms = {loadAudio(), loadAudio()},
-                            .token = kGemmaAudioToken}};
-  EXPECT_THROW(model_->generateMultimodal(prompt, nullptr, std::move(inputs)),
-               RnExecutorchError);
-}
-
-TEST_F(GemmaAudioTest, GenerateMultimodalAudioProducesOutput) {
-  std::vector<float> wav = loadAudio();
-  ASSERT_FALSE(wav.empty())
-      << "test_audio_float.raw missing on device - check run_tests.sh assets";
-
-  std::string prompt =
-      formatGemma(std::string(kGemmaAudioToken) + " Transcribe the audio.");
-  MultimodalInputs inputs{.audios = AudioInputs{.waveforms = {std::move(wav)},
-                                                .token = kGemmaAudioToken}};
-  std::string output =
-      model_->generateMultimodal(prompt, nullptr, std::move(inputs));
-
-  EXPECT_FALSE(output.empty());
-  EXPECT_GT(model_->getGeneratedTokenCount(), 0);
-}
-
-TEST_F(GemmaAudioTest, GenerateMultimodalInterleavedTextAndAudio) {
-  std::string prompt = formatGemma("Listen: " + std::string(kGemmaAudioToken) +
-                                   " then summarise it.");
-  MultimodalInputs inputs{.audios = AudioInputs{.waveforms = {loadAudio()},
-                                                .token = kGemmaAudioToken}};
-  std::string output =
-      model_->generateMultimodal(prompt, nullptr, std::move(inputs));
-
-  EXPECT_FALSE(output.empty());
-}
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/OCRTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/integration/OCRTest.cpp
deleted file mode 100644
index a97e4c2121..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/integration/OCRTest.cpp
+++ /dev/null
@@ -1,141 +0,0 @@
-#include "BaseModelTests.h"
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/host_objects/JSTensorViewIn.h>
-#include <rnexecutorch/models/ocr/OCR.h>
-#include <string>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::ocr;
-using namespace model_tests;
-
-namespace rnexecutorch {
-std::shared_ptr<facebook::react::CallInvoker> createMockCallInvoker();
-}
-
-constexpr auto kValidDetectorPath = "xnnpack_craft_quantized.pte";
-constexpr auto kValidRecognizerPath = "xnnpack_crnn_english.pte";
-constexpr auto kValidTestImagePath =
-    "file:///data/local/tmp/rnexecutorch_tests/we_are_software_mansion.jpg";
-
-// English alphabet symbols (must match alphabets.english from symbols.ts)
-const std::string ENGLISH_SYMBOLS =
-    "0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ "
-    "\xE2\x82\xAC" // Euro sign (€)
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-
-// ============================================================================
-// Common tests via typed test suite
-// ============================================================================
-namespace model_tests {
-template <> struct ModelTraits<OCR> {
-  using ModelType = OCR;
-
-  static ModelType createValid() {
-    return ModelType(kValidDetectorPath, kValidRecognizerPath, ENGLISH_SYMBOLS,
-                     rnexecutorch::createMockCallInvoker());
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.pte", kValidRecognizerPath, ENGLISH_SYMBOLS,
-                     rnexecutorch::createMockCallInvoker());
-  }
-
-  static void callGenerate(ModelType &model) {
-    (void)model.generateFromString(kValidTestImagePath);
-  }
-};
-} // namespace model_tests
-
-using OCRTypes = ::testing::Types<OCR>;
-INSTANTIATE_TYPED_TEST_SUITE_P(OCR, CommonModelTest, OCRTypes);
-
-// ============================================================================
-// Model-specific tests
-// ============================================================================
-TEST(OCRCtorTests, InvalidRecognizerPathThrows) {
-  EXPECT_THROW(OCR(kValidDetectorPath, "nonexistent.pte", ENGLISH_SYMBOLS,
-                   createMockCallInvoker()),
-               RnExecutorchError);
-}
-
-TEST(OCRCtorTests, EmptySymbolsThrows) {
-  EXPECT_THROW(OCR(kValidDetectorPath, kValidRecognizerPath, "",
-                   createMockCallInvoker()),
-               RnExecutorchError);
-}
-
-TEST(OCRGenerateTests, InvalidImagePathThrows) {
-  OCR model(kValidDetectorPath, kValidRecognizerPath, ENGLISH_SYMBOLS,
-            createMockCallInvoker());
-  EXPECT_THROW((void)model.generateFromString("nonexistent_image.jpg"),
-               RnExecutorchError);
-}
-
-TEST(OCRGenerateTests, EmptyImagePathThrows) {
-  OCR model(kValidDetectorPath, kValidRecognizerPath, ENGLISH_SYMBOLS,
-            createMockCallInvoker());
-  EXPECT_THROW((void)model.generateFromString(""), RnExecutorchError);
-}
-
-TEST(OCRGenerateTests, MalformedURIThrows) {
-  OCR model(kValidDetectorPath, kValidRecognizerPath, ENGLISH_SYMBOLS,
-            createMockCallInvoker());
-  EXPECT_THROW((void)model.generateFromString("not_a_valid_uri://bad"),
-               RnExecutorchError);
-}
-
-TEST(OCRGenerateTests, ValidImageReturnsResults) {
-  OCR model(kValidDetectorPath, kValidRecognizerPath, ENGLISH_SYMBOLS,
-            createMockCallInvoker());
-  auto results = model.generateFromString(kValidTestImagePath);
-  // May or may not have detections depending on image content
-  EXPECT_GE(results.size(), 0u);
-}
-
-TEST(OCRGenerateTests, DetectionsHaveValidBoundingBoxes) {
-  OCR model(kValidDetectorPath, kValidRecognizerPath, ENGLISH_SYMBOLS,
-            createMockCallInvoker());
-  auto results = model.generateFromString(kValidTestImagePath);
-
-  for (const auto &detection : results) {
-    EXPECT_GE(detection.bbox.p1.x, 0.0f);
-    EXPECT_GE(detection.bbox.p1.y, 0.0f);
-    EXPECT_GE(detection.bbox.p2.x, detection.bbox.p1.x);
-    EXPECT_GE(detection.bbox.p2.y, detection.bbox.p1.y);
-  }
-}
-
-TEST(OCRGenerateTests, DetectionsHaveValidScores) {
-  OCR model(kValidDetectorPath, kValidRecognizerPath, ENGLISH_SYMBOLS,
-            createMockCallInvoker());
-  auto results = model.generateFromString(kValidTestImagePath);
-
-  for (const auto &detection : results) {
-    EXPECT_GE(detection.score, 0.0f);
-    EXPECT_LE(detection.score, 1.0f);
-  }
-}
-
-TEST(OCRGenerateTests, DetectionsHaveNonEmptyText) {
-  OCR model(kValidDetectorPath, kValidRecognizerPath, ENGLISH_SYMBOLS,
-            createMockCallInvoker());
-  auto results = model.generateFromString(kValidTestImagePath);
-  for (const auto &detection : results) {
-    EXPECT_FALSE(detection.text.empty());
-  }
-}
-
-// ============================================================================
-// generateFromPixels smoke test
-// ============================================================================
-TEST(OCRPixelTests, ValidPixelsReturnsResults) {
-  OCR model(kValidDetectorPath, kValidRecognizerPath, ENGLISH_SYMBOLS,
-            createMockCallInvoker());
-  std::vector<uint8_t> buf(64 * 64 * 3, 128);
-  JSTensorViewIn view{
-      buf.data(), {64, 64, 3}, executorch::aten::ScalarType::Byte};
-  auto results = model.generateFromPixels(view);
-  EXPECT_GE(results.size(), 0u);
-}
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/ObjectDetectionTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/integration/ObjectDetectionTest.cpp
deleted file mode 100644
index 5c5bb6e736..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/integration/ObjectDetectionTest.cpp
+++ /dev/null
@@ -1,320 +0,0 @@
-#include "BaseModelTests.h"
-#include "VisionModelTests.h"
-#include <executorch/extension/tensor/tensor.h>
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/host_objects/JSTensorViewIn.h>
-#include <rnexecutorch/models/object_detection/Constants.h>
-#include <rnexecutorch/models/object_detection/ObjectDetection.h>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::object_detection;
-using namespace model_tests;
-
-constexpr auto kValidObjectDetectionModelPath =
-    "ssdlite320-mobilenetv3-large.pte";
-constexpr auto kValidTestImagePath =
-    "file:///data/local/tmp/rnexecutorch_tests/test_image.jpg";
-
-// clang-format off
-const std::vector<std::string> kCocoLabels = {
-  "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train",
-  "truck", "boat", "traffic light", "fire hydrant", "stop sign",
-  "parking meter", "bench", "bird", "cat", "dog", "horse", "sheep", "cow",
-  "elephant", "bear", "zebra", "giraffe", "backpack", "umbrella", "handbag",
-  "tie", "suitcase", "frisbee", "skis", "snowboard", "sports ball", "kite",
-  "baseball bat", "baseball glove", "skateboard", "surfboard", "tennis racket",
-  "bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana",
-  "apple", "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza",
-  "donut", "cake", "chair", "couch", "potted plant", "bed", "dining table",
-  "toilet", "tv", "laptop", "mouse", "remote", "keyboard", "cell phone",
-  "microwave", "oven", "toaster", "sink", "refrigerator", "book", "clock",
-  "vase", "scissors", "teddy bear", "hair drier", "toothbrush"
-};
-// clang-format on
-
-// ============================================================================
-// Common tests via typed test suite
-// ============================================================================
-namespace model_tests {
-template <> struct ModelTraits<ObjectDetection> {
-  using ModelType = ObjectDetection;
-
-  static ModelType createValid() {
-    return ModelType(kValidObjectDetectionModelPath, {}, {}, kCocoLabels,
-                     nullptr);
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.pte", {}, {}, {}, nullptr);
-  }
-
-  static void callGenerate(ModelType &model) {
-    (void)model.generateFromString(kValidTestImagePath, 0.5, 0.55, {},
-                                   "forward");
-  }
-};
-} // namespace model_tests
-
-using ObjectDetectionTypes = ::testing::Types<ObjectDetection>;
-INSTANTIATE_TYPED_TEST_SUITE_P(ObjectDetection, CommonModelTest,
-                               ObjectDetectionTypes);
-INSTANTIATE_TYPED_TEST_SUITE_P(ObjectDetection, VisionModelTest,
-                               ObjectDetectionTypes);
-
-// ============================================================================
-// Model-specific tests
-// ============================================================================
-TEST(ObjectDetectionGenerateTests, InvalidImagePathThrows) {
-  ObjectDetection model(kValidObjectDetectionModelPath, {}, {}, kCocoLabels,
-                        nullptr);
-  EXPECT_THROW((void)model.generateFromString("nonexistent_image.jpg", 0.5,
-                                              0.55, {}, "forward"),
-               RnExecutorchError);
-}
-
-TEST(ObjectDetectionGenerateTests, EmptyImagePathThrows) {
-  ObjectDetection model(kValidObjectDetectionModelPath, {}, {}, kCocoLabels,
-                        nullptr);
-  EXPECT_THROW((void)model.generateFromString("", 0.5, 0.55, {}, "forward"),
-               RnExecutorchError);
-}
-
-TEST(ObjectDetectionGenerateTests, MalformedURIThrows) {
-  ObjectDetection model(kValidObjectDetectionModelPath, {}, {}, kCocoLabels,
-                        nullptr);
-  EXPECT_THROW((void)model.generateFromString("not_a_valid_uri://bad", 0.5,
-                                              0.55, {}, "forward"),
-               RnExecutorchError);
-}
-
-TEST(ObjectDetectionGenerateTests, NegativeThresholdThrows) {
-  ObjectDetection model(kValidObjectDetectionModelPath, {}, {}, kCocoLabels,
-                        nullptr);
-  EXPECT_THROW((void)model.generateFromString(kValidTestImagePath, -0.1, 0.55,
-                                              {}, "forward"),
-               RnExecutorchError);
-}
-
-TEST(ObjectDetectionGenerateTests, ThresholdAboveOneThrows) {
-  ObjectDetection model(kValidObjectDetectionModelPath, {}, {}, kCocoLabels,
-                        nullptr);
-  EXPECT_THROW((void)model.generateFromString(kValidTestImagePath, 1.1, 0.55,
-                                              {}, "forward"),
-               RnExecutorchError);
-}
-
-TEST(ObjectDetectionGenerateTests, ValidImageReturnsResults) {
-  ObjectDetection model(kValidObjectDetectionModelPath, {}, {}, kCocoLabels,
-                        nullptr);
-  auto results =
-      model.generateFromString(kValidTestImagePath, 0.3, 0.55, {}, "forward");
-  EXPECT_GE(results.size(), 0u);
-}
-
-TEST(ObjectDetectionGenerateTests, HighThresholdReturnsFewerResults) {
-  ObjectDetection model(kValidObjectDetectionModelPath, {}, {}, kCocoLabels,
-                        nullptr);
-  auto lowThresholdResults =
-      model.generateFromString(kValidTestImagePath, 0.1, 0.55, {}, "forward");
-  auto highThresholdResults =
-      model.generateFromString(kValidTestImagePath, 0.9, 0.55, {}, "forward");
-  EXPECT_GE(lowThresholdResults.size(), highThresholdResults.size());
-}
-
-TEST(ObjectDetectionGenerateTests, DetectionsHaveValidBoundingBoxes) {
-  ObjectDetection model(kValidObjectDetectionModelPath, {}, {}, kCocoLabels,
-                        nullptr);
-  auto results =
-      model.generateFromString(kValidTestImagePath, 0.3, 0.55, {}, "forward");
-
-  for (const auto &detection : results) {
-    EXPECT_LE(detection.bbox.p1.x, detection.bbox.p2.x);
-    EXPECT_LE(detection.bbox.p1.y, detection.bbox.p2.y);
-    EXPECT_GE(detection.bbox.p1.x, 0.0f);
-    EXPECT_GE(detection.bbox.p1.y, 0.0f);
-  }
-}
-
-TEST(ObjectDetectionGenerateTests, DetectionsHaveValidScores) {
-  ObjectDetection model(kValidObjectDetectionModelPath, {}, {}, kCocoLabels,
-                        nullptr);
-  auto results =
-      model.generateFromString(kValidTestImagePath, 0.3, 0.55, {}, "forward");
-
-  for (const auto &detection : results) {
-    EXPECT_GE(detection.score, 0.0f);
-    EXPECT_LE(detection.score, 1.0f);
-  }
-}
-
-TEST(ObjectDetectionGenerateTests, DetectionsHaveValidLabels) {
-  ObjectDetection model(kValidObjectDetectionModelPath, {}, {}, kCocoLabels,
-                        nullptr);
-  auto results =
-      model.generateFromString(kValidTestImagePath, 0.3, 0.55, {}, "forward");
-
-  for (const auto &detection : results) {
-    const auto &label = detection.label;
-    EXPECT_FALSE(label.empty());
-    EXPECT_NE(std::find(kCocoLabels.begin(), kCocoLabels.end(), label),
-              kCocoLabels.end());
-  }
-}
-
-// ============================================================================
-// generateFromPixels tests
-// ============================================================================
-TEST(ObjectDetectionPixelTests, ValidPixelDataReturnsResults) {
-  ObjectDetection model(kValidObjectDetectionModelPath, {}, {}, kCocoLabels,
-                        nullptr);
-  constexpr int32_t width = 4, height = 4, channels = 3;
-  std::vector<uint8_t> pixelData(width * height * channels, 128);
-  JSTensorViewIn tensorView{pixelData.data(),
-                            {height, width, channels},
-                            executorch::aten::ScalarType::Byte};
-  auto results = model.generateFromPixels(tensorView, 0.3, 0.55, {}, "forward");
-  EXPECT_GE(results.size(), 0u);
-}
-
-TEST(ObjectDetectionPixelTests, NegativeThresholdThrows) {
-  ObjectDetection model(kValidObjectDetectionModelPath, {}, {}, kCocoLabels,
-                        nullptr);
-  constexpr int32_t width = 4, height = 4, channels = 3;
-  std::vector<uint8_t> pixelData(width * height * channels, 128);
-  JSTensorViewIn tensorView{pixelData.data(),
-                            {height, width, channels},
-                            executorch::aten::ScalarType::Byte};
-  EXPECT_THROW(
-      (void)model.generateFromPixels(tensorView, -0.1, 0.55, {}, "forward"),
-      RnExecutorchError);
-}
-
-TEST(ObjectDetectionPixelTests, ThresholdAboveOneThrows) {
-  ObjectDetection model(kValidObjectDetectionModelPath, {}, {}, kCocoLabels,
-                        nullptr);
-  constexpr int32_t width = 4, height = 4, channels = 3;
-  std::vector<uint8_t> pixelData(width * height * channels, 128);
-  JSTensorViewIn tensorView{pixelData.data(),
-                            {height, width, channels},
-                            executorch::aten::ScalarType::Byte};
-  EXPECT_THROW(
-      (void)model.generateFromPixels(tensorView, 1.1, 0.55, {}, "forward"),
-      RnExecutorchError);
-}
-
-TEST(ObjectDetectionInheritedTests, GetInputShapeWorks) {
-  ObjectDetection model(kValidObjectDetectionModelPath, {}, {}, kCocoLabels,
-                        nullptr);
-  auto shape = model.getInputShape("forward", 0);
-  // v0.9.0 ssdlite is exported without a leading batch dim, so the signature
-  // is (C, H, W) rather than the (1, C, H, W) used by sibling vision models.
-  EXPECT_EQ(shape.size(), 3);
-  EXPECT_EQ(shape[0], 3);
-  EXPECT_EQ(shape[1], 320);
-}
-
-TEST(ObjectDetectionInheritedTests, GetAllInputShapesWorks) {
-  ObjectDetection model(kValidObjectDetectionModelPath, {}, {}, kCocoLabels,
-                        nullptr);
-  auto shapes = model.getAllInputShapes("forward");
-  EXPECT_FALSE(shapes.empty());
-}
-
-TEST(ObjectDetectionInheritedTests, GetMethodMetaWorks) {
-  ObjectDetection model(kValidObjectDetectionModelPath, {}, {}, kCocoLabels,
-                        nullptr);
-  auto result = model.getMethodMeta("forward");
-  EXPECT_TRUE(result.ok());
-}
-
-// ============================================================================
-// Normalisation tests
-// ============================================================================
-TEST(ObjectDetectionNormTests, ValidNormParamsDoesntThrow) {
-  const std::vector<float> mean = {0.485f, 0.456f, 0.406f};
-  const std::vector<float> std = {0.229f, 0.224f, 0.225f};
-  EXPECT_NO_THROW(
-      ObjectDetection(kValidObjectDetectionModelPath, mean, std, {}, nullptr));
-}
-
-TEST(ObjectDetectionNormTests, InvalidNormMeanSizeDoesntThrow) {
-  EXPECT_NO_THROW(ObjectDetection(kValidObjectDetectionModelPath, {0.5f},
-                                  {0.229f, 0.224f, 0.225f}, {}, nullptr));
-}
-
-TEST(ObjectDetectionNormTests, InvalidNormStdSizeDoesntThrow) {
-  EXPECT_NO_THROW(ObjectDetection(kValidObjectDetectionModelPath,
-                                  {0.485f, 0.456f, 0.406f}, {0.5f}, {},
-                                  nullptr));
-}
-
-TEST(ObjectDetectionNormTests, ValidNormParamsGenerateSucceeds) {
-  const std::vector<float> mean = {0.485f, 0.456f, 0.406f};
-  const std::vector<float> std = {0.229f, 0.224f, 0.225f};
-  ObjectDetection model(kValidObjectDetectionModelPath, mean, std, kCocoLabels,
-                        nullptr);
-  EXPECT_NO_THROW((void)model.generateFromString(kValidTestImagePath, 0.5, 0.55,
-                                                 {}, "forward"));
-}
-
-// ============================================================================
-// Method name tests
-// ============================================================================
-TEST(ObjectDetectionMethodTests, InvalidMethodNameThrows) {
-  ObjectDetection model(kValidObjectDetectionModelPath, {}, {}, kCocoLabels,
-                        nullptr);
-  EXPECT_THROW((void)model.generateFromString(kValidTestImagePath, 0.5, 0.55,
-                                              {}, "forward_999"),
-               RnExecutorchError);
-}
-
-TEST(ObjectDetectionMethodTests, EmptyMethodNameThrows) {
-  ObjectDetection model(kValidObjectDetectionModelPath, {}, {}, kCocoLabels,
-                        nullptr);
-  EXPECT_THROW(
-      (void)model.generateFromString(kValidTestImagePath, 0.5, 0.55, {}, ""),
-      RnExecutorchError);
-}
-
-// ============================================================================
-// Class indices filtering tests
-// ============================================================================
-TEST(ObjectDetectionClassFilterTests,
-     FilteredResultsOnlyContainRequestedClasses) {
-  ObjectDetection model(kValidObjectDetectionModelPath, {}, {}, kCocoLabels,
-                        nullptr);
-  // Only request "person" class (index 0 in COCO)
-  auto results =
-      model.generateFromString(kValidTestImagePath, 0.3, 0.55, {0}, "forward");
-  for (const auto &det : results) {
-    EXPECT_EQ(det.label, "person");
-  }
-}
-
-TEST(ObjectDetectionClassFilterTests,
-     EmptyClassIndicesReturnsMoreOrEqualResults) {
-  ObjectDetection model(kValidObjectDetectionModelPath, {}, {}, kCocoLabels,
-                        nullptr);
-  auto allClasses =
-      model.generateFromString(kValidTestImagePath, 0.3, 0.55, {}, "forward");
-  // person (0) only
-  auto filtered =
-      model.generateFromString(kValidTestImagePath, 0.3, 0.55, {0}, "forward");
-  EXPECT_GE(allClasses.size(), filtered.size());
-}
-
-// ============================================================================
-// IoU threshold tests
-// ============================================================================
-TEST(ObjectDetectionIouTests, HigherIouThresholdReturnsSameOrMoreResults) {
-  ObjectDetection model(kValidObjectDetectionModelPath, {}, {}, kCocoLabels,
-                        nullptr);
-  // High IoU threshold = less aggressive NMS = more boxes survive
-  auto highIou =
-      model.generateFromString(kValidTestImagePath, 0.3, 0.9, {}, "forward");
-  // Low IoU threshold = more aggressive NMS = fewer boxes survive
-  auto lowIou =
-      model.generateFromString(kValidTestImagePath, 0.3, 0.1, {}, "forward");
-  EXPECT_GE(highIou.size(), lowIou.size());
-}
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/PoseEstimationTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/integration/PoseEstimationTest.cpp
deleted file mode 100644
index 81f7100512..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/integration/PoseEstimationTest.cpp
+++ /dev/null
@@ -1,253 +0,0 @@
-#include "BaseModelTests.h"
-#include "VisionModelTests.h"
-#include <executorch/extension/tensor/tensor.h>
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/host_objects/JSTensorViewIn.h>
-#include <rnexecutorch/models/pose_estimation/PoseEstimation.h>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::pose_estimation;
-using namespace model_tests;
-
-constexpr auto kValidPoseModelPath = "yolo26n-pose.pte";
-constexpr auto kValidTestImagePath =
-    "file:///data/local/tmp/rnexecutorch_tests/we_are_software_mansion.jpg";
-constexpr auto kMethodName = "forward_384";
-
-// ============================================================================
-// Common tests via typed test suite
-// ============================================================================
-namespace model_tests {
-template <> struct ModelTraits<PoseEstimation> {
-  using ModelType = PoseEstimation;
-
-  static ModelType createValid() {
-    return ModelType(kValidPoseModelPath, {}, {}, nullptr);
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.pte", {}, {}, nullptr);
-  }
-
-  static void callGenerate(ModelType &model) {
-    (void)model.generateFromString(kValidTestImagePath, 0.5, 0.5, kMethodName);
-  }
-};
-} // namespace model_tests
-
-using PoseEstimationTypes = ::testing::Types<PoseEstimation>;
-INSTANTIATE_TYPED_TEST_SUITE_P(PoseEstimation, CommonModelTest,
-                               PoseEstimationTypes);
-INSTANTIATE_TYPED_TEST_SUITE_P(PoseEstimation, VisionModelTest,
-                               PoseEstimationTypes);
-
-// ============================================================================
-// generateFromString — input path validity
-// ============================================================================
-TEST(PoseEstimationGenerateTests, InvalidImagePathThrows) {
-  PoseEstimation model(kValidPoseModelPath, {}, {}, nullptr);
-  EXPECT_THROW((void)model.generateFromString("nonexistent_image.jpg", 0.5, 0.5,
-                                              kMethodName),
-               RnExecutorchError);
-}
-
-TEST(PoseEstimationGenerateTests, EmptyImagePathThrows) {
-  PoseEstimation model(kValidPoseModelPath, {}, {}, nullptr);
-  EXPECT_THROW((void)model.generateFromString("", 0.5, 0.5, kMethodName),
-               RnExecutorchError);
-}
-
-TEST(PoseEstimationGenerateTests, MalformedURIThrows) {
-  PoseEstimation model(kValidPoseModelPath, {}, {}, nullptr);
-  EXPECT_THROW((void)model.generateFromString("not_a_valid_uri://bad", 0.5, 0.5,
-                                              kMethodName),
-               RnExecutorchError);
-}
-
-// ============================================================================
-// generateFromString — threshold range
-// ============================================================================
-TEST(PoseEstimationGenerateTests, NegativeDetectionThresholdThrows) {
-  PoseEstimation model(kValidPoseModelPath, {}, {}, nullptr);
-  EXPECT_THROW((void)model.generateFromString(kValidTestImagePath, -0.1, 0.5,
-                                              kMethodName),
-               RnExecutorchError);
-}
-
-TEST(PoseEstimationGenerateTests, DetectionThresholdAboveOneThrows) {
-  PoseEstimation model(kValidPoseModelPath, {}, {}, nullptr);
-  EXPECT_THROW((void)model.generateFromString(kValidTestImagePath, 1.1, 0.5,
-                                              kMethodName),
-               RnExecutorchError);
-}
-
-TEST(PoseEstimationGenerateTests, NegativeKeypointThresholdThrows) {
-  PoseEstimation model(kValidPoseModelPath, {}, {}, nullptr);
-  EXPECT_THROW((void)model.generateFromString(kValidTestImagePath, 0.5, -0.1,
-                                              kMethodName),
-               RnExecutorchError);
-}
-
-TEST(PoseEstimationGenerateTests, KeypointThresholdAboveOneThrows) {
-  PoseEstimation model(kValidPoseModelPath, {}, {}, nullptr);
-  EXPECT_THROW((void)model.generateFromString(kValidTestImagePath, 0.5, 1.1,
-                                              kMethodName),
-               RnExecutorchError);
-}
-
-// ============================================================================
-// generateFromString — happy path & output shape
-// ============================================================================
-TEST(PoseEstimationGenerateTests, ValidImageReturnsResults) {
-  PoseEstimation model(kValidPoseModelPath, {}, {}, nullptr);
-  auto results =
-      model.generateFromString(kValidTestImagePath, 0.3, 0.5, kMethodName);
-  EXPECT_GE(results.size(), 0u);
-}
-
-TEST(PoseEstimationGenerateTests, HighThresholdReturnsFewerResults) {
-  PoseEstimation model(kValidPoseModelPath, {}, {}, nullptr);
-  auto lowThresholdResults =
-      model.generateFromString(kValidTestImagePath, 0.1, 0.5, kMethodName);
-  auto highThresholdResults =
-      model.generateFromString(kValidTestImagePath, 0.95, 0.5, kMethodName);
-  EXPECT_GE(lowThresholdResults.size(), highThresholdResults.size());
-}
-
-TEST(PoseEstimationGenerateTests, AllDetectionsHaveSameKeypointCount) {
-  PoseEstimation model(kValidPoseModelPath, {}, {}, nullptr);
-  auto results =
-      model.generateFromString(kValidTestImagePath, 0.1, 0.5, kMethodName);
-  if (results.size() < 2) {
-    GTEST_SKIP() << "Need at least 2 detections to compare keypoint counts";
-  }
-  const size_t firstSize = results.front().size();
-  EXPECT_GT(firstSize, 0u);
-  for (const auto &person : results) {
-    EXPECT_EQ(person.size(), firstSize);
-  }
-}
-
-TEST(PoseEstimationGenerateTests, KeypointsHaveValidStructure) {
-  PoseEstimation model(kValidPoseModelPath, {}, {}, nullptr);
-  auto results =
-      model.generateFromString(kValidTestImagePath, 0.3, 0.5, kMethodName);
-  // Each detection must contain a non-zero number of keypoints, and each
-  // keypoint must be aggregate-initializable as { x, y } floats (compile-time).
-  for (const auto &person : results) {
-    EXPECT_GT(person.size(), 0u);
-    for (const auto &kp : person) {
-      // No range constraint here — out-of-bounds coords are valid model
-      // output for low-visibility keypoints; consumers filter on visibility.
-      static_assert(std::is_same_v<decltype(kp.x), float>);
-      static_assert(std::is_same_v<decltype(kp.y), float>);
-      (void)kp;
-    }
-  }
-}
-
-// ============================================================================
-// generateFromPixels
-// ============================================================================
-TEST(PoseEstimationPixelTests, ValidPixelDataReturnsResults) {
-  PoseEstimation model(kValidPoseModelPath, {}, {}, nullptr);
-  constexpr int32_t width = 4, height = 4, channels = 3;
-  std::vector<uint8_t> pixelData(width * height * channels, 128);
-  JSTensorViewIn tensorView{pixelData.data(),
-                            {height, width, channels},
-                            executorch::aten::ScalarType::Byte};
-  auto results = model.generateFromPixels(tensorView, 0.3, 0.5, kMethodName);
-  EXPECT_GE(results.size(), 0u);
-}
-
-TEST(PoseEstimationPixelTests, NegativeThresholdThrows) {
-  PoseEstimation model(kValidPoseModelPath, {}, {}, nullptr);
-  constexpr int32_t width = 4, height = 4, channels = 3;
-  std::vector<uint8_t> pixelData(width * height * channels, 128);
-  JSTensorViewIn tensorView{pixelData.data(),
-                            {height, width, channels},
-                            executorch::aten::ScalarType::Byte};
-  EXPECT_THROW(
-      (void)model.generateFromPixels(tensorView, -0.1, 0.5, kMethodName),
-      RnExecutorchError);
-}
-
-TEST(PoseEstimationPixelTests, ThresholdAboveOneThrows) {
-  PoseEstimation model(kValidPoseModelPath, {}, {}, nullptr);
-  constexpr int32_t width = 4, height = 4, channels = 3;
-  std::vector<uint8_t> pixelData(width * height * channels, 128);
-  JSTensorViewIn tensorView{pixelData.data(),
-                            {height, width, channels},
-                            executorch::aten::ScalarType::Byte};
-  EXPECT_THROW(
-      (void)model.generateFromPixels(tensorView, 1.1, 0.5, kMethodName),
-      RnExecutorchError);
-}
-
-// ============================================================================
-// Method name
-// ============================================================================
-TEST(PoseEstimationMethodTests, InvalidMethodNameThrows) {
-  PoseEstimation model(kValidPoseModelPath, {}, {}, nullptr);
-  EXPECT_THROW((void)model.generateFromString(kValidTestImagePath, 0.5, 0.5,
-                                              "forward_999"),
-               RnExecutorchError);
-}
-
-TEST(PoseEstimationMethodTests, EmptyMethodNameThrows) {
-  PoseEstimation model(kValidPoseModelPath, {}, {}, nullptr);
-  EXPECT_THROW(
-      (void)model.generateFromString(kValidTestImagePath, 0.5, 0.5, ""),
-      RnExecutorchError);
-}
-
-// ============================================================================
-// Normalisation params (constructor logs but does not throw)
-// ============================================================================
-TEST(PoseEstimationNormTests, ValidNormParamsDoesntThrow) {
-  const std::vector<float> mean = {0.485f, 0.456f, 0.406f};
-  const std::vector<float> std = {0.229f, 0.224f, 0.225f};
-  EXPECT_NO_THROW(PoseEstimation(kValidPoseModelPath, mean, std, nullptr));
-}
-
-TEST(PoseEstimationNormTests, InvalidNormMeanSizeDoesntThrow) {
-  EXPECT_NO_THROW(PoseEstimation(kValidPoseModelPath, {0.5f},
-                                 {0.229f, 0.224f, 0.225f}, nullptr));
-}
-
-TEST(PoseEstimationNormTests, InvalidNormStdSizeDoesntThrow) {
-  EXPECT_NO_THROW(PoseEstimation(kValidPoseModelPath, {0.485f, 0.456f, 0.406f},
-                                 {0.5f}, nullptr));
-}
-
-TEST(PoseEstimationNormTests, ValidNormParamsGenerateSucceeds) {
-  const std::vector<float> mean = {0.485f, 0.456f, 0.406f};
-  const std::vector<float> std = {0.229f, 0.224f, 0.225f};
-  PoseEstimation model(kValidPoseModelPath, mean, std, nullptr);
-  EXPECT_NO_THROW((void)model.generateFromString(kValidTestImagePath, 0.5, 0.5,
-                                                 kMethodName));
-}
-
-// ============================================================================
-// Inherited VisionModel methods
-// ============================================================================
-TEST(PoseEstimationInheritedTests, GetInputShapeWorks) {
-  PoseEstimation model(kValidPoseModelPath, {}, {}, nullptr);
-  auto shape = model.getInputShape(kMethodName, 0);
-  EXPECT_EQ(shape.size(), 4);
-  EXPECT_EQ(shape[0], 1);
-  EXPECT_EQ(shape[1], 3);
-}
-
-TEST(PoseEstimationInheritedTests, GetAllInputShapesWorks) {
-  PoseEstimation model(kValidPoseModelPath, {}, {}, nullptr);
-  auto shapes = model.getAllInputShapes(kMethodName);
-  EXPECT_FALSE(shapes.empty());
-}
-
-TEST(PoseEstimationInheritedTests, GetMethodMetaWorks) {
-  PoseEstimation model(kValidPoseModelPath, {}, {}, nullptr);
-  auto result = model.getMethodMeta(kMethodName);
-  EXPECT_TRUE(result.ok());
-}
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/SemanticSegmentationTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/integration/SemanticSegmentationTest.cpp
deleted file mode 100644
index 09c5d42f67..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/integration/SemanticSegmentationTest.cpp
+++ /dev/null
@@ -1,291 +0,0 @@
-#include <algorithm>
-#include <executorch/extension/tensor/tensor.h>
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/host_objects/JSTensorViewIn.h>
-#include <rnexecutorch/models/semantic_segmentation/BaseSemanticSegmentation.h>
-#include <string>
-#include <vector>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::semantic_segmentation;
-using executorch::extension::make_tensor_ptr;
-using executorch::extension::TensorPtr;
-using executorch::runtime::EValue;
-
-constexpr auto kValidSemanticSegmentationModelPath =
-    "deeplabV3_xnnpack_fp32.pte";
-constexpr auto kValidTestImagePath =
-    "file:///data/local/tmp/rnexecutorch_tests/test_image.jpg";
-
-// DeepLab V3 class labels (Pascal VOC)
-static const std::vector<std::string> kDeeplabV3Labels = {
-    "BACKGROUND", "AEROPLANE",   "BICYCLE", "BIRD",  "BOAT",
-    "BOTTLE",     "BUS",         "CAR",     "CAT",   "CHAIR",
-    "COW",        "DININGTABLE", "DOG",     "HORSE", "MOTORBIKE",
-    "PERSON",     "POTTEDPLANT", "SHEEP",   "SOFA",  "TRAIN",
-    "TVMONITOR"};
-
-// ImageNet normalization constants
-static const std::vector<float> kImageNetMean = {0.485f, 0.456f, 0.406f};
-static const std::vector<float> kImageNetStd = {0.229f, 0.224f, 0.225f};
-
-static JSTensorViewIn makeRgbView(std::vector<uint8_t> &buf, int32_t h,
-                                  int32_t w) {
-  buf.assign(static_cast<size_t>(h * w * 3), 128);
-  return JSTensorViewIn{
-      buf.data(), {h, w, 3}, executorch::aten::ScalarType::Byte};
-}
-
-// Test fixture for tests that need dummy input data
-class SemanticSegmentationForwardTest : public ::testing::Test {
-protected:
-  void SetUp() override {
-    model = std::make_unique<BaseSemanticSegmentation>(
-        kValidSemanticSegmentationModelPath, kImageNetMean, kImageNetStd,
-        kDeeplabV3Labels, nullptr);
-    auto shapes = model->getAllInputShapes("forward");
-    ASSERT_FALSE(shapes.empty());
-    shape = shapes[0];
-
-    size_t numElements = 1;
-    for (auto dim : shape) {
-      numElements *= dim;
-    }
-    dummyData = std::vector<float>(numElements, 0.5f);
-
-    sizes = std::vector<int32_t>(shape.begin(), shape.end());
-    inputTensor =
-        make_tensor_ptr(sizes, dummyData.data(), exec_aten::ScalarType::Float);
-  }
-
-  std::unique_ptr<BaseSemanticSegmentation> model;
-  std::vector<int32_t> shape;
-  std::vector<float> dummyData;
-  std::vector<int32_t> sizes;
-  TensorPtr inputTensor;
-};
-
-TEST(SemanticSegmentationCtorTests, InvalidPathThrows) {
-  EXPECT_THROW(BaseSemanticSegmentation("this_file_does_not_exist.pte",
-                                        kImageNetMean, kImageNetStd,
-                                        kDeeplabV3Labels, nullptr),
-               RnExecutorchError);
-}
-
-TEST(SemanticSegmentationCtorTests, ValidPathDoesntThrow) {
-  EXPECT_NO_THROW(BaseSemanticSegmentation(kValidSemanticSegmentationModelPath,
-                                           kImageNetMean, kImageNetStd,
-                                           kDeeplabV3Labels, nullptr));
-}
-
-TEST_F(SemanticSegmentationForwardTest, ForwardWithValidTensorSucceeds) {
-  auto result = model->forward(EValue(inputTensor));
-  EXPECT_TRUE(result.ok());
-}
-
-TEST_F(SemanticSegmentationForwardTest, ForwardOutputHasCorrectDimensions) {
-  auto result = model->forward(EValue(inputTensor));
-  ASSERT_TRUE(result.ok());
-
-  auto &outputs = result.get();
-  ASSERT_FALSE(outputs.empty());
-
-  auto outputTensor = outputs[0].toTensor();
-  EXPECT_EQ(outputTensor.dim(), 4); // NCHW format
-}
-
-TEST_F(SemanticSegmentationForwardTest, ForwardOutputHas21Classes) {
-  auto result = model->forward(EValue(inputTensor));
-  ASSERT_TRUE(result.ok());
-
-  auto &outputs = result.get();
-  ASSERT_FALSE(outputs.empty());
-
-  auto outputTensor = outputs[0].toTensor();
-  EXPECT_EQ(outputTensor.size(1), 21); // DeepLabV3 has 21 classes
-}
-
-TEST_F(SemanticSegmentationForwardTest, MultipleForwardsWork) {
-  auto result1 = model->forward(EValue(inputTensor));
-  EXPECT_TRUE(result1.ok());
-
-  auto result2 = model->forward(EValue(inputTensor));
-  EXPECT_TRUE(result2.ok());
-}
-
-TEST_F(SemanticSegmentationForwardTest, ForwardAfterUnloadThrows) {
-  model->unload();
-  EXPECT_THROW((void)model->forward(EValue(inputTensor)), RnExecutorchError);
-}
-
-// ============================================================================
-// generateFromString tests
-// ============================================================================
-TEST(SemanticSegmentationGenerateTests, InvalidImagePathThrows) {
-  BaseSemanticSegmentation model(kValidSemanticSegmentationModelPath,
-                                 kImageNetMean, kImageNetStd, kDeeplabV3Labels,
-                                 nullptr);
-  EXPECT_THROW(
-      (void)model.generateFromString("nonexistent_image.jpg", {}, true),
-      RnExecutorchError);
-}
-
-TEST(SemanticSegmentationGenerateTests, EmptyImagePathThrows) {
-  BaseSemanticSegmentation model(kValidSemanticSegmentationModelPath,
-                                 kImageNetMean, kImageNetStd, kDeeplabV3Labels,
-                                 nullptr);
-  EXPECT_THROW((void)model.generateFromString("", {}, true), RnExecutorchError);
-}
-
-TEST(SemanticSegmentationGenerateTests, MalformedURIThrows) {
-  BaseSemanticSegmentation model(kValidSemanticSegmentationModelPath,
-                                 kImageNetMean, kImageNetStd, kDeeplabV3Labels,
-                                 nullptr);
-  EXPECT_THROW(
-      (void)model.generateFromString("not_a_valid_uri://bad", {}, true),
-      RnExecutorchError);
-}
-
-TEST(SemanticSegmentationGenerateTests, ValidImageNoFilterReturnsResult) {
-  BaseSemanticSegmentation model(kValidSemanticSegmentationModelPath,
-                                 kImageNetMean, kImageNetStd, kDeeplabV3Labels,
-                                 nullptr);
-  auto result = model.generateFromString(kValidTestImagePath, {}, true);
-  EXPECT_NE(result.argmax, nullptr);
-  EXPECT_NE(result.classBuffers, nullptr);
-}
-
-TEST(SemanticSegmentationGenerateTests, ValidImageReturnsAllClasses) {
-  BaseSemanticSegmentation model(kValidSemanticSegmentationModelPath,
-                                 kImageNetMean, kImageNetStd, kDeeplabV3Labels,
-                                 nullptr);
-  auto result = model.generateFromString(kValidTestImagePath, {}, true);
-  ASSERT_NE(result.classBuffers, nullptr);
-  EXPECT_EQ(result.classBuffers->size(), 21u);
-}
-
-TEST(SemanticSegmentationGenerateTests, ClassFilterLimitsClassBuffers) {
-  BaseSemanticSegmentation model(kValidSemanticSegmentationModelPath,
-                                 kImageNetMean, kImageNetStd, kDeeplabV3Labels,
-                                 nullptr);
-  std::set<std::string, std::less<>> filter = {"PERSON", "CAT"};
-  auto result = model.generateFromString(kValidTestImagePath, filter, true);
-  ASSERT_NE(result.classBuffers, nullptr);
-  // Only the requested classes should appear in classBuffers
-  for (const auto &[label, _] : *result.classBuffers) {
-    EXPECT_TRUE(filter.count(label) > 0);
-  }
-}
-
-TEST(SemanticSegmentationGenerateTests, ResizeFalseReturnsResult) {
-  BaseSemanticSegmentation model(kValidSemanticSegmentationModelPath,
-                                 kImageNetMean, kImageNetStd, kDeeplabV3Labels,
-                                 nullptr);
-  auto result = model.generateFromString(kValidTestImagePath, {}, false);
-  EXPECT_NE(result.argmax, nullptr);
-}
-
-// ============================================================================
-// generateFromPixels tests
-// ============================================================================
-TEST(SemanticSegmentationPixelTests, ValidPixelsNoFilterReturnsResult) {
-  BaseSemanticSegmentation model(kValidSemanticSegmentationModelPath,
-                                 kImageNetMean, kImageNetStd, kDeeplabV3Labels,
-                                 nullptr);
-  std::vector<uint8_t> buf;
-  auto view = makeRgbView(buf, 64, 64);
-  auto result = model.generateFromPixels(view, {}, true);
-  EXPECT_NE(result.argmax, nullptr);
-  EXPECT_NE(result.classBuffers, nullptr);
-}
-
-TEST(SemanticSegmentationPixelTests, ValidPixelsReturnsAllClasses) {
-  BaseSemanticSegmentation model(kValidSemanticSegmentationModelPath,
-                                 kImageNetMean, kImageNetStd, kDeeplabV3Labels,
-                                 nullptr);
-  std::vector<uint8_t> buf;
-  auto view = makeRgbView(buf, 64, 64);
-  auto result = model.generateFromPixels(view, {}, true);
-  ASSERT_NE(result.classBuffers, nullptr);
-  EXPECT_EQ(result.classBuffers->size(), 21u);
-}
-
-TEST(SemanticSegmentationPixelTests, ClassFilterLimitsClassBuffers) {
-  BaseSemanticSegmentation model(kValidSemanticSegmentationModelPath,
-                                 kImageNetMean, kImageNetStd, kDeeplabV3Labels,
-                                 nullptr);
-  std::vector<uint8_t> buf;
-  auto view = makeRgbView(buf, 64, 64);
-  std::set<std::string, std::less<>> filter = {"PERSON"};
-  auto result = model.generateFromPixels(view, filter, true);
-  ASSERT_NE(result.classBuffers, nullptr);
-  for (const auto &[label, _] : *result.classBuffers) {
-    EXPECT_EQ(label, "PERSON");
-  }
-}
-
-// ============================================================================
-// Inherited BaseModel tests
-// ============================================================================
-TEST(SemanticSegmentationInheritedTests, GetInputShapeWorks) {
-  BaseSemanticSegmentation model(kValidSemanticSegmentationModelPath,
-                                 kImageNetMean, kImageNetStd, kDeeplabV3Labels,
-                                 nullptr);
-  auto shape = model.getInputShape("forward", 0);
-  EXPECT_EQ(shape.size(), 4);
-  EXPECT_EQ(shape[0], 1); // Batch size
-  EXPECT_EQ(shape[1], 3); // RGB channels
-}
-
-TEST(SemanticSegmentationInheritedTests, GetAllInputShapesWorks) {
-  BaseSemanticSegmentation model(kValidSemanticSegmentationModelPath,
-                                 kImageNetMean, kImageNetStd, kDeeplabV3Labels,
-                                 nullptr);
-  auto shapes = model.getAllInputShapes("forward");
-  EXPECT_FALSE(shapes.empty());
-}
-
-TEST(SemanticSegmentationInheritedTests, GetMethodMetaWorks) {
-  BaseSemanticSegmentation model(kValidSemanticSegmentationModelPath,
-                                 kImageNetMean, kImageNetStd, kDeeplabV3Labels,
-                                 nullptr);
-  auto result = model.getMethodMeta("forward");
-  EXPECT_TRUE(result.ok());
-}
-
-TEST(SemanticSegmentationInheritedTests, GetMemoryLowerBoundReturnsPositive) {
-  BaseSemanticSegmentation model(kValidSemanticSegmentationModelPath,
-                                 kImageNetMean, kImageNetStd, kDeeplabV3Labels,
-                                 nullptr);
-  EXPECT_GT(model.getMemoryLowerBound(), 0u);
-}
-
-TEST(SemanticSegmentationInheritedTests, InputShapeIsSquare) {
-  BaseSemanticSegmentation model(kValidSemanticSegmentationModelPath,
-                                 kImageNetMean, kImageNetStd, kDeeplabV3Labels,
-                                 nullptr);
-  auto shape = model.getInputShape("forward", 0);
-  EXPECT_EQ(shape[2], shape[3]); // Height == Width for DeepLabV3
-}
-
-// ============================================================================
-// Constants tests
-// ============================================================================
-TEST(SemanticSegmentationConstantsTests, ClassLabelsHas21Entries) {
-  EXPECT_EQ(kDeeplabV3Labels.size(), 21u);
-}
-
-TEST(SemanticSegmentationConstantsTests, ClassLabelsContainExpectedClasses) {
-  const auto &labels = kDeeplabV3Labels;
-
-  auto contains = [&labels](const std::string &target) {
-    return std::ranges::find(labels, target) != labels.end();
-  };
-
-  EXPECT_TRUE(contains("BACKGROUND"));
-  EXPECT_TRUE(contains("PERSON"));
-  EXPECT_TRUE(contains("CAT"));
-  EXPECT_TRUE(contains("DOG"));
-}
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/SpeechToTextTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/integration/SpeechToTextTest.cpp
deleted file mode 100644
index cc326d8bc0..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/integration/SpeechToTextTest.cpp
+++ /dev/null
@@ -1,171 +0,0 @@
-#include "BaseModelTests.h"
-#include "utils/TestUtils.h"
-#include <chrono>
-#include <gtest/gtest.h>
-#include <jsi/jsi.h>
-#include <memory>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/models/speech_to_text/SpeechToText.h>
-#include <thread>
-
-namespace rnexecutorch {
-std::shared_ptr<facebook::react::CallInvoker> createMockCallInvoker();
-}
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::speech_to_text;
-using namespace test_utils;
-using namespace model_tests;
-
-constexpr auto kValidModelPath = "whisper_tiny_en_xnnpack.pte";
-constexpr auto kValidTokenizerPath = "whisper_tokenizer.json";
-constexpr auto kValidVadModelPath = "fsmn-vad_xnnpack.pte";
-
-// ============================================================================
-// Common tests via typed test suite
-// ============================================================================
-namespace model_tests {
-template <> struct ModelTraits<SpeechToText> {
-  using ModelType = SpeechToText;
-
-  static ModelType createValid() {
-    return ModelType("whisper", kValidModelPath, kValidTokenizerPath,
-                     /*vadSource=*/"", nullptr);
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("whisper", "nonexistent.pte", kValidTokenizerPath,
-                     /*vadSource=*/"", nullptr);
-  }
-
-  static void callGenerate(ModelType &model) {
-    auto audio = test_utils::loadAudioFromFile("test_audio_float.raw");
-    (void)model.transcribe(audio, "en", false);
-  }
-};
-} // namespace model_tests
-
-using SpeechToTextTypes = ::testing::Types<SpeechToText>;
-INSTANTIATE_TYPED_TEST_SUITE_P(SpeechToText, CommonModelTest,
-                               SpeechToTextTypes);
-
-// ============================================================================
-// Model-specific tests
-// ============================================================================
-TEST(S2TCtorTests, InvalidModelNameThrows) {
-  EXPECT_THROW(SpeechToText("invalid_model", kValidModelPath,
-                            kValidTokenizerPath, /*vadSource=*/"", nullptr),
-               RnExecutorchError);
-}
-
-TEST(S2TCtorTests, InvalidModelPathThrows) {
-  EXPECT_THROW(SpeechToText("whisper", "nonexistent.pte", kValidTokenizerPath,
-                            /*vadSource=*/"", nullptr),
-               RnExecutorchError);
-}
-
-TEST(S2TCtorTests, InvalidTokenizerPathThrows) {
-  EXPECT_THROW(SpeechToText("whisper", kValidModelPath, "nonexistent.json",
-                            /*vadSource=*/"", nullptr),
-               rnexecutorch::RnExecutorchError);
-}
-
-TEST(S2TEncodeTests, EncodeReturnsNonNull) {
-  SpeechToText model("whisper", kValidModelPath, kValidTokenizerPath,
-                     /*vadSource=*/"", nullptr);
-  auto audio = loadAudioFromFile("test_audio_float.raw");
-  ASSERT_FALSE(audio.empty());
-  auto result = model.encode(audio);
-  EXPECT_NE(result, nullptr);
-  EXPECT_GT(result->size(), 0u);
-}
-
-TEST(S2TTranscribeTests, TranscribeReturnsValidChars) {
-  GTEST_SKIP() << "TODO: known failure on this branch; needs investigation.";
-  SpeechToText model("whisper", kValidModelPath, kValidTokenizerPath,
-                     /*vadSource=*/"", nullptr);
-  auto audio = loadAudioFromFile("test_audio_float.raw");
-  ASSERT_FALSE(audio.empty());
-  auto result = model.transcribe(audio, "en", true);
-  ASSERT_EQ(result.language, "en");
-  EXPECT_GE(result.duration, 20.0f);
-  ASSERT_EQ(result.task, "transcribe");
-  ASSERT_FALSE(result.segments.empty());
-  ASSERT_FALSE(result.text.empty());
-  for (char c : result.text) {
-    EXPECT_GE(static_cast<unsigned char>(c), 0);
-    EXPECT_LE(static_cast<unsigned char>(c), 127);
-  }
-}
-
-TEST(S2TTranscribeTests, EmptyResultOnSilence) {
-  SpeechToText model("whisper", kValidModelPath, kValidTokenizerPath,
-                     /*vadSource=*/"", nullptr);
-  auto audio = generateSilence(16000 * 5);
-  auto result = model.transcribe(audio, "en", false);
-  EXPECT_TRUE(result.text.empty());
-}
-
-TEST(S2TTranscribeTests, InvalidLanguageThrows) {
-  SpeechToText model("whisper", kValidModelPath, kValidTokenizerPath,
-                     /*vadSource=*/"", nullptr);
-  auto audio = loadAudioFromFile("test_audio_float.raw");
-  ASSERT_FALSE(audio.empty());
-  EXPECT_THROW((void)model.transcribe(audio, "invalid_language_code", false),
-               RnExecutorchError);
-}
-
-// ============================================================================
-// VAD integration tests (vadSource provided => internal VAD module loaded)
-// ============================================================================
-TEST(S2TVadCtorTests, ValidVadSourceConstructs) {
-  EXPECT_NO_THROW(SpeechToText("whisper", kValidModelPath, kValidTokenizerPath,
-                               kValidVadModelPath, createMockCallInvoker()));
-}
-
-TEST(S2TVadCtorTests, InvalidVadSourceThrows) {
-  EXPECT_THROW(SpeechToText("whisper", kValidModelPath, kValidTokenizerPath,
-                            "nonexistent_vad.pte", createMockCallInvoker()),
-               RnExecutorchError);
-}
-
-TEST(S2TVadTranscribeTests, TranscribeStillWorksWithVadLoaded) {
-  // The vadSource only affects streaming. The one-shot transcribe() path
-  // must remain unchanged when a VAD is attached.
-  SpeechToText model("whisper", kValidModelPath, kValidTokenizerPath,
-                     kValidVadModelPath, createMockCallInvoker());
-  auto silence = generateSilence(16000 * 5);
-  auto result = model.transcribe(silence, "en", false);
-  EXPECT_TRUE(result.text.empty());
-}
-
-TEST(S2TVadStreamTests, UseVadWithoutVadInitializedThrows) {
-  // Guard added by the PR: stream() with useVAD=true on a model that was
-  // built with an empty vadSource should fail loudly.
-  SpeechToText model("whisper", kValidModelPath, kValidTokenizerPath,
-                     /*vadSource=*/"", createMockCallInvoker());
-  EXPECT_THROW(model.stream(std::shared_ptr<jsi::Function>(), /*language=*/"en",
-                            /*verbose=*/false, /*timeout=*/100,
-                            /*useVAD=*/true, /*vadDetectionMargin=*/500),
-               RnExecutorchError);
-}
-
-TEST(S2TVadStreamTests, StreamWithVadOnSilenceCompletesCleanly) {
-  // Drives the OnlineASR::process VAD branch with audio that contains no
-  // speech segments. Exercises the "speechSegments.empty()" cleanup path
-  // added by the PR.
-  SpeechToText model("whisper", kValidModelPath, kValidTokenizerPath,
-                     kValidVadModelPath, createMockCallInvoker());
-  std::thread streamer([&model] {
-    model.stream(std::shared_ptr<jsi::Function>(), /*language=*/"en",
-                 /*verbose=*/false, /*timeout=*/100, /*useVAD=*/true,
-                 /*vadDetectionMargin=*/500);
-  });
-
-  auto silence = generateSilence(16000 * 2); // 2s of silence
-  model.streamInsert(silence);
-  std::this_thread::sleep_for(std::chrono::milliseconds(400));
-
-  model.streamStop();
-  streamer.join();
-}
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/StyleTransferTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/integration/StyleTransferTest.cpp
deleted file mode 100644
index a4511cad11..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/integration/StyleTransferTest.cpp
+++ /dev/null
@@ -1,187 +0,0 @@
-#include "BaseModelTests.h"
-#include "VisionModelTests.h"
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/host_objects/JSTensorViewIn.h>
-#include <rnexecutorch/models/style_transfer/StyleTransfer.h>
-#include <variant>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::style_transfer;
-using namespace model_tests;
-
-constexpr auto kValidStyleTransferModelPath =
-    "style_transfer_candy_xnnpack_fp32.pte";
-constexpr auto kValidTestImagePath =
-    "file:///data/local/tmp/rnexecutorch_tests/test_image.jpg";
-
-static JSTensorViewIn makeRgbView(std::vector<uint8_t> &buf, int32_t h,
-                                  int32_t w) {
-  buf.assign(static_cast<size_t>(h * w * 3), 128);
-  return JSTensorViewIn{
-      buf.data(), {h, w, 3}, executorch::aten::ScalarType::Byte};
-}
-
-// ============================================================================
-// Common tests via typed test suite
-// ============================================================================
-namespace model_tests {
-template <> struct ModelTraits<StyleTransfer> {
-  using ModelType = StyleTransfer;
-
-  static ModelType createValid() {
-    return ModelType(kValidStyleTransferModelPath, nullptr);
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.pte", nullptr);
-  }
-
-  static void callGenerate(ModelType &model) {
-    (void)model.generateFromString(kValidTestImagePath, false);
-  }
-};
-} // namespace model_tests
-
-using StyleTransferTypes = ::testing::Types<StyleTransfer>;
-INSTANTIATE_TYPED_TEST_SUITE_P(StyleTransfer, CommonModelTest,
-                               StyleTransferTypes);
-INSTANTIATE_TYPED_TEST_SUITE_P(StyleTransfer, VisionModelTest,
-                               StyleTransferTypes);
-
-// ============================================================================
-// generateFromString tests
-// ============================================================================
-TEST(StyleTransferGenerateTests, InvalidImagePathThrows) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  EXPECT_THROW((void)model.generateFromString("nonexistent_image.jpg", false),
-               RnExecutorchError);
-}
-
-TEST(StyleTransferGenerateTests, EmptyImagePathThrows) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  EXPECT_THROW((void)model.generateFromString("", false), RnExecutorchError);
-}
-
-TEST(StyleTransferGenerateTests, MalformedURIThrows) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  EXPECT_THROW((void)model.generateFromString("not_a_valid_uri://bad", false),
-               RnExecutorchError);
-}
-
-TEST(StyleTransferGenerateTests, ValidImageReturnsFilePath) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  auto result = model.generateFromString(kValidTestImagePath, false);
-  ASSERT_TRUE(std::holds_alternative<PixelDataResult>(result));
-  auto &pr = std::get<PixelDataResult>(result);
-  EXPECT_NE(pr.dataPtr, nullptr);
-  EXPECT_GT(pr.width, 0);
-  EXPECT_GT(pr.height, 0);
-}
-
-// ============================================================================
-// generateFromString saveToFile tests
-// ============================================================================
-TEST(StyleTransferSaveToFileTests, SaveToFileFalseReturnsValidPixelData) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  auto result = model.generateFromString(kValidTestImagePath, false);
-  ASSERT_TRUE(std::holds_alternative<PixelDataResult>(result));
-  EXPECT_NE(std::get<PixelDataResult>(result).dataPtr, nullptr);
-}
-
-TEST(StyleTransferSaveToFileTests, SaveToFileFalseHasPositiveDimensions) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  auto result = model.generateFromString(kValidTestImagePath, false);
-  ASSERT_TRUE(std::holds_alternative<PixelDataResult>(result));
-  auto &pr = std::get<PixelDataResult>(result);
-  EXPECT_GT(pr.width, 0);
-  EXPECT_GT(pr.height, 0);
-}
-
-TEST(StyleTransferSaveToFileTests, SaveToFileTrueReturnsStringVariant) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  auto result = model.generateFromString(kValidTestImagePath, true);
-  EXPECT_TRUE(std::holds_alternative<std::string>(result));
-}
-
-TEST(StyleTransferSaveToFileTests, SaveToFileTrueStringIsNonEmpty) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  auto result = model.generateFromString(kValidTestImagePath, true);
-  ASSERT_TRUE(std::holds_alternative<std::string>(result));
-  EXPECT_FALSE(std::get<std::string>(result).empty());
-}
-
-TEST(StyleTransferSaveToFileTests, SaveToFileTrueStringHasFileScheme) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  auto result = model.generateFromString(kValidTestImagePath, true);
-  ASSERT_TRUE(std::holds_alternative<std::string>(result));
-  EXPECT_TRUE(std::get<std::string>(result).starts_with("file://"));
-}
-
-// ============================================================================
-// generateFromPixels tests
-// ============================================================================
-TEST(StyleTransferPixelTests, ValidPixelsSaveToFileFalseReturnsPixelData) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  std::vector<uint8_t> buf;
-  auto view = makeRgbView(buf, 64, 64);
-  auto result = model.generateFromPixels(view, false);
-  ASSERT_TRUE(std::holds_alternative<PixelDataResult>(result));
-  EXPECT_NE(std::get<PixelDataResult>(result).dataPtr, nullptr);
-}
-
-TEST(StyleTransferPixelTests, ValidPixelsSaveToFileFalseHasPositiveDimensions) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  std::vector<uint8_t> buf;
-  auto view = makeRgbView(buf, 64, 64);
-  auto result = model.generateFromPixels(view, false);
-  ASSERT_TRUE(std::holds_alternative<PixelDataResult>(result));
-  auto &pr = std::get<PixelDataResult>(result);
-  EXPECT_GT(pr.width, 0);
-  EXPECT_GT(pr.height, 0);
-}
-
-TEST(StyleTransferPixelTests,
-     ValidPixelsSaveToFileTrueReturnsFileSchemeString) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  std::vector<uint8_t> buf;
-  auto view = makeRgbView(buf, 64, 64);
-  auto result = model.generateFromPixels(view, true);
-  ASSERT_TRUE(std::holds_alternative<std::string>(result));
-  EXPECT_TRUE(std::get<std::string>(result).starts_with("file://"));
-}
-
-TEST(StyleTransferPixelTests, OutputDimensionsMatchInputSize) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  std::vector<uint8_t> buf;
-  auto view = makeRgbView(buf, 64, 64);
-  auto result = model.generateFromPixels(view, false);
-  ASSERT_TRUE(std::holds_alternative<PixelDataResult>(result));
-  auto &pr = std::get<PixelDataResult>(result);
-  EXPECT_EQ(pr.width, 64);
-  EXPECT_EQ(pr.height, 64);
-}
-
-// ============================================================================
-// Inherited BaseModel tests
-// ============================================================================
-TEST(StyleTransferInheritedTests, GetInputShapeWorks) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  auto shape = model.getInputShape("forward", 0);
-  EXPECT_EQ(shape.size(), 4);
-  EXPECT_EQ(shape[0], 1);
-  EXPECT_EQ(shape[1], 3);
-}
-
-TEST(StyleTransferInheritedTests, GetAllInputShapesWorks) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  auto shapes = model.getAllInputShapes("forward");
-  EXPECT_FALSE(shapes.empty());
-}
-
-TEST(StyleTransferInheritedTests, GetMethodMetaWorks) {
-  StyleTransfer model(kValidStyleTransferModelPath, nullptr);
-  auto result = model.getMethodMeta("forward");
-  EXPECT_TRUE(result.ok());
-}
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/TextEmbeddingsTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/integration/TextEmbeddingsTest.cpp
deleted file mode 100644
index ff1abd4c30..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/integration/TextEmbeddingsTest.cpp
+++ /dev/null
@@ -1,164 +0,0 @@
-#include "BaseModelTests.h"
-#include <cmath>
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/models/embeddings/text/TextEmbeddings.h>
-#include <string>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::embeddings;
-using namespace model_tests;
-
-constexpr auto kValidTextEmbeddingsModelPath = "all-MiniLM-L6-v2_xnnpack.pte";
-constexpr auto kValidTextEmbeddingsTokenizerPath = "tokenizer.json";
-constexpr size_t kMiniLmEmbeddingDimensions = 384;
-
-// ============================================================================
-// Common tests via typed test suite
-// ============================================================================
-namespace model_tests {
-template <> struct ModelTraits<TextEmbeddings> {
-  using ModelType = TextEmbeddings;
-
-  static ModelType createValid() {
-    return ModelType(kValidTextEmbeddingsModelPath,
-                     kValidTextEmbeddingsTokenizerPath, nullptr);
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.pte", kValidTextEmbeddingsTokenizerPath,
-                     nullptr);
-  }
-
-  static void callGenerate(ModelType &model) {
-    (void)model.generate("Hello, world!");
-  }
-};
-} // namespace model_tests
-
-using TextEmbeddingsTypes = ::testing::Types<TextEmbeddings>;
-INSTANTIATE_TYPED_TEST_SUITE_P(TextEmbeddings, CommonModelTest,
-                               TextEmbeddingsTypes);
-
-// ============================================================================
-// Model-specific tests
-// ============================================================================
-TEST(TextEmbeddingsCtorTests, InvalidTokenizerPathThrows) {
-  EXPECT_THROW(TextEmbeddings(kValidTextEmbeddingsModelPath,
-                              "this_tokenizer_does_not_exist.json", nullptr),
-               std::exception);
-}
-
-TEST(TextEmbeddingsGenerateTests, EmptyStringReturnsResults) {
-  TextEmbeddings model(kValidTextEmbeddingsModelPath,
-                       kValidTextEmbeddingsTokenizerPath, nullptr);
-  auto result = model.generate("");
-  EXPECT_NE(result, nullptr);
-  EXPECT_GT(result->size(), 0u);
-}
-
-TEST(TextEmbeddingsGenerateTests, ValidTextReturnsResults) {
-  TextEmbeddings model(kValidTextEmbeddingsModelPath,
-                       kValidTextEmbeddingsTokenizerPath, nullptr);
-  auto result = model.generate("Hello, world!");
-  EXPECT_NE(result, nullptr);
-  EXPECT_GT(result->size(), 0u);
-}
-
-TEST(TextEmbeddingsGenerateTests, ResultsHaveCorrectSize) {
-  TextEmbeddings model(kValidTextEmbeddingsModelPath,
-                       kValidTextEmbeddingsTokenizerPath, nullptr);
-  auto result = model.generate("This is a test sentence.");
-  size_t numFloats = result->size() / sizeof(float);
-  EXPECT_EQ(numFloats, kMiniLmEmbeddingDimensions);
-}
-
-TEST(TextEmbeddingsGenerateTests, ResultsAreNormalized) {
-  TextEmbeddings model(kValidTextEmbeddingsModelPath,
-                       kValidTextEmbeddingsTokenizerPath, nullptr);
-  auto result = model.generate("The quick brown fox jumps over the lazy dog.");
-
-  const float *data = reinterpret_cast<const float *>(result->data());
-  size_t numFloats = result->size() / sizeof(float);
-
-  float sumOfSquares = 0.0f;
-  for (size_t i = 0; i < numFloats; ++i) {
-    sumOfSquares += data[i] * data[i];
-  }
-  float norm = std::sqrt(sumOfSquares);
-  EXPECT_NEAR(norm, 1.0f, 0.01f);
-}
-
-TEST(TextEmbeddingsGenerateTests, ResultsContainValidValues) {
-  TextEmbeddings model(kValidTextEmbeddingsModelPath,
-                       kValidTextEmbeddingsTokenizerPath, nullptr);
-  auto result = model.generate("Testing valid values.");
-
-  const float *data = reinterpret_cast<const float *>(result->data());
-  size_t numFloats = result->size() / sizeof(float);
-
-  for (size_t i = 0; i < numFloats; ++i) {
-    EXPECT_FALSE(std::isnan(data[i]));
-    EXPECT_FALSE(std::isinf(data[i]));
-  }
-}
-
-TEST(TextEmbeddingsGenerateTests, DifferentTextProducesDifferentEmbeddings) {
-  TextEmbeddings model(kValidTextEmbeddingsModelPath,
-                       kValidTextEmbeddingsTokenizerPath, nullptr);
-
-  auto result1 = model.generate("Hello, world!");
-  auto result2 = model.generate("Goodbye, moon!");
-
-  const float *data1 = reinterpret_cast<const float *>(result1->data());
-  const float *data2 = reinterpret_cast<const float *>(result2->data());
-  size_t numFloats = result1->size() / sizeof(float);
-
-  bool allEqual = true;
-  for (size_t i = 0; i < numFloats; ++i) {
-    if (std::abs(data1[i] - data2[i]) > 1e-6f) {
-      allEqual = false;
-      break;
-    }
-  }
-  EXPECT_FALSE(allEqual);
-}
-
-TEST(TextEmbeddingsGenerateTests, SimilarTextProducesSimilarEmbeddings) {
-  TextEmbeddings model(kValidTextEmbeddingsModelPath,
-                       kValidTextEmbeddingsTokenizerPath, nullptr);
-
-  auto result1 = model.generate("I love programming");
-  auto result2 = model.generate("I enjoy coding");
-
-  const float *data1 = reinterpret_cast<const float *>(result1->data());
-  const float *data2 = reinterpret_cast<const float *>(result2->data());
-  size_t numFloats = result1->size() / sizeof(float);
-
-  float dotProduct = 0.0f;
-  for (size_t i = 0; i < numFloats; ++i) {
-    dotProduct += data1[i] * data2[i];
-  }
-  EXPECT_GT(dotProduct, 0.5f);
-}
-
-TEST(TextEmbeddingsInheritedTests, GetInputShapeWorks) {
-  TextEmbeddings model(kValidTextEmbeddingsModelPath,
-                       kValidTextEmbeddingsTokenizerPath, nullptr);
-  auto shape = model.getInputShape("forward", 0);
-  EXPECT_GE(shape.size(), 2u);
-}
-
-TEST(TextEmbeddingsInheritedTests, GetAllInputShapesWorks) {
-  TextEmbeddings model(kValidTextEmbeddingsModelPath,
-                       kValidTextEmbeddingsTokenizerPath, nullptr);
-  auto shapes = model.getAllInputShapes("forward");
-  EXPECT_FALSE(shapes.empty());
-}
-
-TEST(TextEmbeddingsInheritedTests, GetMethodMetaWorks) {
-  TextEmbeddings model(kValidTextEmbeddingsModelPath,
-                       kValidTextEmbeddingsTokenizerPath, nullptr);
-  auto result = model.getMethodMeta("forward");
-  EXPECT_TRUE(result.ok());
-}
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/TextToImageTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/integration/TextToImageTest.cpp
deleted file mode 100644
index 7ecae1f392..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/integration/TextToImageTest.cpp
+++ /dev/null
@@ -1,153 +0,0 @@
-#include "BaseModelTests.h"
-#include <gtest/gtest.h>
-#include <opencv2/opencv.hpp>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/models/text_to_image/TextToImage.h>
-#include <string>
-#include <string_view>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::text_to_image;
-using namespace model_tests;
-
-namespace rnexecutorch {
-std::shared_ptr<facebook::react::CallInvoker> createMockCallInvoker();
-}
-
-constexpr auto kValidTokenizerPath = "t2i_tokenizer.json";
-constexpr auto kValidEncoderPath = "t2i_encoder.pte";
-constexpr auto kValidUnetPath = "t2i_unet.pte";
-constexpr auto kValidDecoderPath = "t2i_decoder.pte";
-
-constexpr float kSchedulerBetaStart = 0.00085f;
-constexpr float kSchedulerBetaEnd = 0.012f;
-constexpr int32_t kSchedulerNumTrainTimesteps = 1000;
-constexpr int32_t kSchedulerStepsOffset = 1;
-
-// ============================================================================
-// Common tests via typed test suite
-// ============================================================================
-namespace model_tests {
-template <> struct ModelTraits<TextToImage> {
-  using ModelType = TextToImage;
-
-  static ModelType createValid() {
-    return ModelType(kValidTokenizerPath, kValidEncoderPath, kValidUnetPath,
-                     kValidDecoderPath, kSchedulerBetaStart, kSchedulerBetaEnd,
-                     kSchedulerNumTrainTimesteps, kSchedulerStepsOffset,
-                     rnexecutorch::createMockCallInvoker());
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.json", kValidEncoderPath, kValidUnetPath,
-                     kValidDecoderPath, kSchedulerBetaStart, kSchedulerBetaEnd,
-                     kSchedulerNumTrainTimesteps, kSchedulerStepsOffset,
-                     rnexecutorch::createMockCallInvoker());
-  }
-
-  static void callGenerate(ModelType &model) {
-    (void)model.generate("a cat", 128, 1, 42, nullptr);
-  }
-};
-} // namespace model_tests
-
-// TODO: Investigate why TextToImage fails on MultipleGeneratesWork in the
-// emulator environment
-using TextToImageTypes = ::testing::Types<TextToImage>;
-INSTANTIATE_TYPED_TEST_SUITE_P(TextToImage, CommonModelTest, TextToImageTypes);
-
-// ============================================================================
-// Model-specific tests
-// ============================================================================
-TEST(TextToImageCtorTests, InvalidEncoderPathThrows) {
-  EXPECT_THROW(TextToImage(kValidTokenizerPath, "nonexistent.pte",
-                           kValidUnetPath, kValidDecoderPath,
-                           kSchedulerBetaStart, kSchedulerBetaEnd,
-                           kSchedulerNumTrainTimesteps, kSchedulerStepsOffset,
-                           createMockCallInvoker()),
-               RnExecutorchError);
-}
-
-TEST(TextToImageCtorTests, InvalidUnetPathThrows) {
-  EXPECT_THROW(TextToImage(kValidTokenizerPath, kValidEncoderPath,
-                           "nonexistent.pte", kValidDecoderPath,
-                           kSchedulerBetaStart, kSchedulerBetaEnd,
-                           kSchedulerNumTrainTimesteps, kSchedulerStepsOffset,
-                           createMockCallInvoker()),
-               RnExecutorchError);
-}
-
-TEST(TextToImageCtorTests, InvalidDecoderPathThrows) {
-  EXPECT_THROW(TextToImage(kValidTokenizerPath, kValidEncoderPath,
-                           kValidUnetPath, "nonexistent.pte",
-                           kSchedulerBetaStart, kSchedulerBetaEnd,
-                           kSchedulerNumTrainTimesteps, kSchedulerStepsOffset,
-                           createMockCallInvoker()),
-               RnExecutorchError);
-}
-
-TEST(TextToImageGenerateTests, InvalidImageSizeThrows) {
-  TextToImage model(kValidTokenizerPath, kValidEncoderPath, kValidUnetPath,
-                    kValidDecoderPath, kSchedulerBetaStart, kSchedulerBetaEnd,
-                    kSchedulerNumTrainTimesteps, kSchedulerStepsOffset,
-                    createMockCallInvoker());
-  EXPECT_THROW((void)model.generate("a cat", 100, 1, 42, nullptr),
-               RnExecutorchError);
-}
-
-TEST(TextToImageGenerateTests, EmptyPromptThrows) {
-  TextToImage model(kValidTokenizerPath, kValidEncoderPath, kValidUnetPath,
-                    kValidDecoderPath, kSchedulerBetaStart, kSchedulerBetaEnd,
-                    kSchedulerNumTrainTimesteps, kSchedulerStepsOffset,
-                    createMockCallInvoker());
-  EXPECT_THROW((void)model.generate("", 128, 1, 42, nullptr),
-               RnExecutorchError);
-}
-
-TEST(TextToImageGenerateTests, ZeroStepsThrows) {
-  TextToImage model(kValidTokenizerPath, kValidEncoderPath, kValidUnetPath,
-                    kValidDecoderPath, kSchedulerBetaStart, kSchedulerBetaEnd,
-                    kSchedulerNumTrainTimesteps, kSchedulerStepsOffset,
-                    createMockCallInvoker());
-  EXPECT_THROW((void)model.generate("a cat", 128, 0, 42, nullptr),
-               RnExecutorchError);
-}
-
-TEST(TextToImageGenerateTests, GenerateReturnsFileUri) {
-  // TODO: Investigate source of the issue
-  GTEST_SKIP() << "Skipping TextToImage generation test in emulator "
-                  "environment due to UNet forward call throwing error no. 1";
-  TextToImage model(kValidTokenizerPath, kValidEncoderPath, kValidUnetPath,
-                    kValidDecoderPath, kSchedulerBetaStart, kSchedulerBetaEnd,
-                    kSchedulerNumTrainTimesteps, kSchedulerStepsOffset,
-                    createMockCallInvoker());
-  auto result = model.generate("a cat", 128, 1, 42, nullptr);
-  EXPECT_FALSE(result.empty());
-  EXPECT_TRUE(result.starts_with("file://"));
-}
-
-TEST(TextToImageGenerateTests, SameSeedProducesSameResult) {
-  // TODO: Investigate source of the issue
-  GTEST_SKIP() << "Skipping TextToImage generation test in emulator "
-                  "environment due to UNet forward call throwing error no. 1";
-  TextToImage model(kValidTokenizerPath, kValidEncoderPath, kValidUnetPath,
-                    kValidDecoderPath, kSchedulerBetaStart, kSchedulerBetaEnd,
-                    kSchedulerNumTrainTimesteps, kSchedulerStepsOffset,
-                    createMockCallInvoker());
-  auto path1 = model.generate("a cat", 128, 1, 42, nullptr);
-  auto path2 = model.generate("a cat", 128, 1, 42, nullptr);
-  ASSERT_FALSE(path1.empty());
-  ASSERT_FALSE(path2.empty());
-
-  const std::string kScheme = "file://";
-  auto stripScheme = [&kScheme](const std::string &uri) {
-    return uri.starts_with(kScheme) ? uri.substr(kScheme.size()) : uri;
-  };
-  cv::Mat img1 = cv::imread(stripScheme(path1), cv::IMREAD_UNCHANGED);
-  cv::Mat img2 = cv::imread(stripScheme(path2), cv::IMREAD_UNCHANGED);
-  ASSERT_FALSE(img1.empty());
-  ASSERT_FALSE(img2.empty());
-  ASSERT_EQ(img1.size(), img2.size());
-  ASSERT_EQ(img1.type(), img2.type());
-  EXPECT_EQ(cv::countNonZero(img1 != img2), 0);
-}
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/TextToSpeechTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/integration/TextToSpeechTest.cpp
deleted file mode 100644
index bb1a201ebc..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/integration/TextToSpeechTest.cpp
+++ /dev/null
@@ -1,129 +0,0 @@
-#include "BaseModelTests.h"
-#include "utils/TestUtils.h"
-#include <algorithm>
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/models/text_to_speech/kokoro/Kokoro.h>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::text_to_speech::kokoro;
-
-// Kokoro doesn't use the CommonModelTest suite, so suppress the warning
-namespace model_tests {
-GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(CommonModelTest);
-}
-
-constexpr auto kValidLang = "en-us";
-constexpr auto kValidTaggerPath = "kokoro_en_tagger.json";
-constexpr auto kValidLexiconPath = "kokoro_us_lexicon.json";
-constexpr auto kValidPhonemizerPath = "kokoro_us_phonemizer.pte";
-constexpr auto kValidDurationPath = "kokoro_duration_predictor.pte";
-constexpr auto kValidSynthesizerPath = "kokoro_synthesizer.pte";
-constexpr auto kValidVoicePath = "kokoro_af_heart.bin";
-
-namespace {
-bool isAudioValid(const std::vector<float> &audio) {
-  if (audio.empty()) {
-    return false;
-  }
-  // Check for non-silence (amplitude greater than an arbitrary small noise
-  // threshold)
-  return std::ranges::any_of(
-      audio, [](float sample) { return std::abs(sample) > 1e-4f; });
-}
-
-bool isAudioSimilar(const std::vector<float> &audio1,
-                    const std::vector<float> &audio2, float tolerance = 0.1f) {
-  if (audio1.empty() || audio2.empty()) {
-    return false;
-  }
-
-  double sumSqDiff = 0.0;
-  size_t steps = std::max(audio1.size(), audio2.size());
-
-  for (size_t i = 0; i < steps; ++i) {
-    size_t idx1 =
-        static_cast<size_t>((static_cast<float>(i) / steps) * audio1.size());
-    size_t idx2 =
-        static_cast<size_t>((static_cast<float>(i) / steps) * audio2.size());
-
-    float diff = audio1[idx1] - audio2[idx2];
-    sumSqDiff += diff * diff;
-  }
-
-  double rmse = std::sqrt(sumSqDiff / steps);
-  if (rmse >= tolerance) {
-    std::cerr << "Audio structural RMSE difference: " << rmse
-              << " (tolerance: " << tolerance << ")" << std::endl;
-    return false;
-  }
-  return true;
-}
-
-class KokoroTest : public ::testing::Test {
-protected:
-  void SetUp() override {
-    try {
-      model_ = std::make_unique<Kokoro>(
-          kValidLang, kValidTaggerPath, kValidLexiconPath, kValidPhonemizerPath,
-          kValidDurationPath, kValidSynthesizerPath, kValidVoicePath, nullptr);
-    } catch (...) {
-      model_ = nullptr;
-    }
-  }
-
-  std::unique_ptr<Kokoro> model_;
-};
-} // namespace
-
-TEST(TTSCtorTests, InvalidVoicePathThrows) {
-  EXPECT_THROW(Kokoro(kValidLang, kValidTaggerPath, kValidLexiconPath,
-                      kValidPhonemizerPath, kValidDurationPath,
-                      kValidSynthesizerPath, "nonexistent_voice.bin", nullptr),
-               RnExecutorchError);
-}
-
-TEST_F(KokoroTest, MaxTextSizeExceededThrows) {
-  if (!model_) {
-    GTEST_SKIP() << "Model assets not available, skipping test.";
-  }
-  std::u32string hugeText(10000, U'A'); // beyond params::kMaxTextSize
-  EXPECT_THROW(model_->generate(hugeText, 1.0f), RnExecutorchError);
-}
-
-TEST_F(KokoroTest, EmptyStringReturnsEmptyVector) {
-  if (!model_) {
-    GTEST_SKIP() << "Model assets not available, skipping test.";
-  }
-  auto result = model_->generate(U"", 1.0f);
-  EXPECT_TRUE(result.empty());
-}
-
-TEST_F(KokoroTest, GenerateReturnsValidAudio) {
-  if (!model_) {
-    GTEST_SKIP() << "Model assets not available, skipping test.";
-  }
-  auto result = model_->generate(U"Hello world! How are you doing?", 1.0f);
-  auto reference = test_utils::loadAudioFromFile("test_speech.raw");
-
-  ASSERT_FALSE(reference.empty())
-      << "Reference audio 'test_speech.raw' not found.";
-
-  // Compare against an audio waveform obtained from the original
-  // Kokoro model (PyTorch)
-  EXPECT_TRUE(isAudioSimilar(result, reference));
-}
-
-TEST_F(KokoroTest, GenerateSpeedAdjustsAudioLength) {
-  if (!model_) {
-    GTEST_SKIP() << "Model assets not available, skipping test.";
-  }
-  std::u32string text = U"This is a sentence to test the speed modifications.";
-  auto resultNormal = model_->generate(text, 1.0f);
-  auto resultFast = model_->generate(text, 1.5f);
-
-  EXPECT_TRUE(isAudioValid(resultNormal));
-  EXPECT_TRUE(isAudioValid(resultFast));
-  // Fast speech should result in a noticeably shorter output waveform
-  EXPECT_LT(resultFast.size(), resultNormal.size());
-}
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/TokenizerModuleTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/integration/TokenizerModuleTest.cpp
deleted file mode 100644
index 393ce78d39..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/integration/TokenizerModuleTest.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/TokenizerModule.h>
-
-using namespace rnexecutorch;
-
-constexpr auto kValidTokenizerPath = "tokenizer.json";
-
-TEST(TokenizerCtorTests, InvalidPathThrows) {
-  EXPECT_THROW(TokenizerModule("nonexistent_tokenizer.json", nullptr),
-               RnExecutorchError);
-}
-
-TEST(TokenizerCtorTests, ValidPathDoesntThrow) {
-  EXPECT_NO_THROW(TokenizerModule(kValidTokenizerPath, nullptr));
-}
-
-TEST(TokenizerMemoryTests, MemoryLowerBoundIsPositive) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  EXPECT_GT(tokenizer.getMemoryLowerBound(), 0u);
-}
-
-TEST(TokenizerEncodeTests, EmptyStringReturnsEmptyString) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  auto tokens = tokenizer.encode("");
-  EXPECT_TRUE(tokens.empty());
-}
-
-TEST(TokenizerEncodeTests, SimpleTextReturnsTokens) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  auto tokens = tokenizer.encode("Hello world");
-  EXPECT_GT(tokens.size(), 0u);
-}
-
-TEST(TokenizerEncodeTests, SameTextReturnsSameTokens) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  auto tokens1 = tokenizer.encode("test");
-  auto tokens2 = tokenizer.encode("test");
-  EXPECT_EQ(tokens1, tokens2);
-}
-
-TEST(TokenizerEncodeTests, DifferentTextReturnsDifferentTokens) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  auto tokens1 = tokenizer.encode("hello");
-  auto tokens2 = tokenizer.encode("goodbye");
-  EXPECT_NE(tokens1, tokens2);
-}
-
-TEST(TokenizerEncodeTests, SpecialCharactersWork) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  auto tokens = tokenizer.encode("!@#$%^&*()");
-  EXPECT_GT(tokens.size(), 0u);
-}
-
-TEST(TokenizerEncodeTests, VeryLongTextWorks) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  std::string longText(10000, 'a');
-  EXPECT_NO_THROW((void)tokenizer.encode(longText));
-}
-
-TEST(TokenizerDecodeTests, DecodeEncodedTextReturnsOriginal) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  std::string original = "szponcik";
-  auto tokens = tokenizer.encode(original);
-  auto decoded = tokenizer.decode(tokens, true);
-  EXPECT_EQ(decoded, original);
-}
-
-TEST(TokenizerDecodeTests, DecodeEmptyVectorReturnsEmpty) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  auto decoded = tokenizer.decode({}, true);
-  EXPECT_TRUE(decoded.empty());
-}
-
-TEST(TokenizerIdToTokenTests, ValidIdReturnsToken) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  auto token = tokenizer.idToToken(0);
-  EXPECT_FALSE(token.empty());
-}
-
-TEST(TokenizerTokenToIdTests, RoundTripWorks) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  auto token = tokenizer.idToToken(100);
-  auto id = tokenizer.tokenToId(token);
-  EXPECT_EQ(id, 100);
-}
-
-TEST(TokenizerVocabTests, VocabSizeIsPositive) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  EXPECT_GT(tokenizer.getVocabSize(), 0u);
-}
-
-TEST(TokenizerVocabTests, VocabSizeIsReasonable) {
-  TokenizerModule tokenizer(kValidTokenizerPath, nullptr);
-  auto vocabSize = tokenizer.getVocabSize();
-  EXPECT_GT(vocabSize, 1000u);
-  EXPECT_LT(vocabSize, 1000000u);
-}
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/VerticalOCRTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/integration/VerticalOCRTest.cpp
deleted file mode 100644
index c92abc0f15..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/integration/VerticalOCRTest.cpp
+++ /dev/null
@@ -1,254 +0,0 @@
-#include "BaseModelTests.h"
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/host_objects/JSTensorViewIn.h>
-#include <rnexecutorch/models/vertical_ocr/VerticalOCR.h>
-#include <string>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::ocr;
-using namespace model_tests;
-
-namespace rnexecutorch {
-std::shared_ptr<facebook::react::CallInvoker> createMockCallInvoker();
-}
-
-constexpr auto kValidVerticalDetectorPath = "xnnpack_craft_quantized.pte";
-constexpr auto kValidVerticalRecognizerPath = "xnnpack_crnn_english.pte";
-constexpr auto kValidVerticalTestImagePath =
-    "file:///data/local/tmp/rnexecutorch_tests/we_are_software_mansion.jpg";
-
-// English alphabet symbols (must match alphabets.english from symbols.ts)
-const std::string ENGLISH_SYMBOLS =
-    "0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ "
-    "\xE2\x82\xAC" // Euro sign (€)
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-
-// ============================================================================
-// Common tests via typed test suite
-// ============================================================================
-namespace model_tests {
-template <> struct ModelTraits<VerticalOCR> {
-  using ModelType = VerticalOCR;
-
-  static ModelType createValid() {
-    return ModelType(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                     ENGLISH_SYMBOLS, false,
-                     rnexecutorch::createMockCallInvoker());
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.pte", kValidVerticalRecognizerPath,
-                     ENGLISH_SYMBOLS, false,
-                     rnexecutorch::createMockCallInvoker());
-  }
-
-  static void callGenerate(ModelType &model) {
-    (void)model.generateFromString(kValidVerticalTestImagePath);
-  }
-};
-} // namespace model_tests
-
-using VerticalOCRTypes = ::testing::Types<VerticalOCR>;
-INSTANTIATE_TYPED_TEST_SUITE_P(VerticalOCR, CommonModelTest, VerticalOCRTypes);
-
-// ============================================================================
-// VerticalOCR-specific tests
-// ============================================================================
-
-// Constructor tests
-TEST(VerticalOCRCtorTests, InvalidRecognizerPathThrows) {
-  EXPECT_THROW(VerticalOCR(kValidVerticalDetectorPath, "nonexistent.pte",
-                           ENGLISH_SYMBOLS, false, createMockCallInvoker()),
-               RnExecutorchError);
-}
-
-TEST(VerticalOCRCtorTests, EmptySymbolsThrows) {
-  EXPECT_THROW(VerticalOCR(kValidVerticalDetectorPath,
-                           kValidVerticalRecognizerPath, "", false,
-                           createMockCallInvoker()),
-               RnExecutorchError);
-}
-
-TEST(VerticalOCRCtorTests, IndependentCharsTrueDoesntThrow) {
-  EXPECT_NO_THROW(VerticalOCR(kValidVerticalDetectorPath,
-                              kValidVerticalRecognizerPath, ENGLISH_SYMBOLS,
-                              true, createMockCallInvoker()));
-}
-
-TEST(VerticalOCRCtorTests, IndependentCharsFalseDoesntThrow) {
-  EXPECT_NO_THROW(VerticalOCR(kValidVerticalDetectorPath,
-                              kValidVerticalRecognizerPath, ENGLISH_SYMBOLS,
-                              false, createMockCallInvoker()));
-}
-
-// Generate tests - Independent Characters strategy
-TEST(VerticalOCRGenerateTests, IndependentCharsInvalidImageThrows) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, true, createMockCallInvoker());
-  EXPECT_THROW((void)model.generateFromString("nonexistent_image.jpg"),
-               RnExecutorchError);
-}
-
-TEST(VerticalOCRGenerateTests, IndependentCharsEmptyImagePathThrows) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, true, createMockCallInvoker());
-  EXPECT_THROW((void)model.generateFromString(""), RnExecutorchError);
-}
-
-TEST(VerticalOCRGenerateTests, IndependentCharsMalformedURIThrows) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, true, createMockCallInvoker());
-  EXPECT_THROW((void)model.generateFromString("not_a_valid_uri://bad"),
-               RnExecutorchError);
-}
-
-TEST(VerticalOCRGenerateTests, IndependentCharsValidImageReturnsResults) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, true, createMockCallInvoker());
-  auto results = model.generateFromString(kValidVerticalTestImagePath);
-  EXPECT_GE(results.size(), 0u);
-}
-
-TEST(VerticalOCRGenerateTests, IndependentCharsDetectionsHaveValidBBoxes) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, true, createMockCallInvoker());
-  auto results = model.generateFromString(kValidVerticalTestImagePath);
-
-  for (const auto &detection : results) {
-    EXPECT_GE(detection.bbox.p1.x, 0.0f);
-    EXPECT_GE(detection.bbox.p1.y, 0.0f);
-    EXPECT_GE(detection.bbox.p2.x, detection.bbox.p1.x);
-    EXPECT_GE(detection.bbox.p2.y, detection.bbox.p1.y);
-  }
-}
-
-TEST(VerticalOCRGenerateTests, IndependentCharsDetectionsHaveValidScores) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, true, createMockCallInvoker());
-  auto results = model.generateFromString(kValidVerticalTestImagePath);
-
-  for (const auto &detection : results) {
-    EXPECT_GE(detection.score, 0.0f);
-    EXPECT_LE(detection.score, 1.0f);
-  }
-}
-
-TEST(VerticalOCRGenerateTests, IndependentCharsDetectionsHaveNonEmptyText) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, true, createMockCallInvoker());
-  auto results = model.generateFromString(kValidVerticalTestImagePath);
-
-  for (const auto &detection : results) {
-    EXPECT_FALSE(detection.text.empty());
-  }
-}
-
-// Generate tests - Joint Characters strategy
-TEST(VerticalOCRGenerateTests, JointCharsInvalidImageThrows) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, false, createMockCallInvoker());
-  EXPECT_THROW((void)model.generateFromString("nonexistent_image.jpg"),
-               RnExecutorchError);
-}
-
-TEST(VerticalOCRGenerateTests, JointCharsEmptyImagePathThrows) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, false, createMockCallInvoker());
-  EXPECT_THROW((void)model.generateFromString(""), RnExecutorchError);
-}
-
-TEST(VerticalOCRGenerateTests, JointCharsMalformedURIThrows) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, false, createMockCallInvoker());
-  EXPECT_THROW((void)model.generateFromString("not_a_valid_uri://bad"),
-               RnExecutorchError);
-}
-
-TEST(VerticalOCRGenerateTests, JointCharsValidImageReturnsResults) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, false, createMockCallInvoker());
-  auto results = model.generateFromString(kValidVerticalTestImagePath);
-  EXPECT_GE(results.size(), 0u);
-}
-
-TEST(VerticalOCRGenerateTests, JointCharsDetectionsHaveValidBBoxes) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, false, createMockCallInvoker());
-  auto results = model.generateFromString(kValidVerticalTestImagePath);
-
-  for (const auto &detection : results) {
-    EXPECT_GE(detection.bbox.p1.x, 0.0f);
-    EXPECT_GE(detection.bbox.p1.y, 0.0f);
-    EXPECT_GE(detection.bbox.p2.x, detection.bbox.p1.x);
-    EXPECT_GE(detection.bbox.p2.y, detection.bbox.p1.y);
-  }
-}
-
-TEST(VerticalOCRGenerateTests, JointCharsDetectionsHaveValidScores) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, false, createMockCallInvoker());
-  auto results = model.generateFromString(kValidVerticalTestImagePath);
-
-  for (const auto &detection : results) {
-    EXPECT_GE(detection.score, 0.0f);
-    EXPECT_LE(detection.score, 1.0f);
-  }
-}
-
-TEST(VerticalOCRGenerateTests, JointCharsDetectionsHaveNonEmptyText) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, false, createMockCallInvoker());
-  auto results = model.generateFromString(kValidVerticalTestImagePath);
-
-  for (const auto &detection : results) {
-    EXPECT_FALSE(detection.text.empty());
-  }
-}
-
-// Strategy comparison tests
-TEST(VerticalOCRStrategyTests, BothStrategiesRunSuccessfully) {
-  VerticalOCR independentModel(kValidVerticalDetectorPath,
-                               kValidVerticalRecognizerPath, ENGLISH_SYMBOLS,
-                               true, createMockCallInvoker());
-  VerticalOCR jointModel(kValidVerticalDetectorPath,
-                         kValidVerticalRecognizerPath, ENGLISH_SYMBOLS, false,
-                         createMockCallInvoker());
-
-  EXPECT_NO_THROW(
-      (void)independentModel.generateFromString(kValidVerticalTestImagePath));
-  EXPECT_NO_THROW(
-      (void)jointModel.generateFromString(kValidVerticalTestImagePath));
-}
-
-TEST(VerticalOCRStrategyTests, BothStrategiesReturnValidResults) {
-  VerticalOCR independentModel(kValidVerticalDetectorPath,
-                               kValidVerticalRecognizerPath, ENGLISH_SYMBOLS,
-                               true, createMockCallInvoker());
-  VerticalOCR jointModel(kValidVerticalDetectorPath,
-                         kValidVerticalRecognizerPath, ENGLISH_SYMBOLS, false,
-                         createMockCallInvoker());
-
-  auto independentResults =
-      independentModel.generateFromString(kValidVerticalTestImagePath);
-  auto jointResults =
-      jointModel.generateFromString(kValidVerticalTestImagePath);
-
-  // Both should return some results (or none if no text detected)
-  EXPECT_GE(independentResults.size(), 0u);
-  EXPECT_GE(jointResults.size(), 0u);
-}
-
-// ============================================================================
-// generateFromPixels smoke test
-// ============================================================================
-TEST(VerticalOCRPixelTests, ValidPixelsReturnsResults) {
-  VerticalOCR model(kValidVerticalDetectorPath, kValidVerticalRecognizerPath,
-                    ENGLISH_SYMBOLS, false, createMockCallInvoker());
-  std::vector<uint8_t> buf(64 * 64 * 3, 128);
-  JSTensorViewIn view{
-      buf.data(), {64, 64, 3}, executorch::aten::ScalarType::Byte};
-  auto results = model.generateFromPixels(view);
-  EXPECT_GE(results.size(), 0u);
-}
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/VisionModelTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/integration/VisionModelTest.cpp
deleted file mode 100644
index 6736454d6f..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/integration/VisionModelTest.cpp
+++ /dev/null
@@ -1,121 +0,0 @@
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <gtest/gtest.h>
-#include <memory>
-#include <opencv2/opencv.hpp>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/host_objects/JSTensorViewIn.h>
-#include <rnexecutorch/models/VisionModel.h>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models;
-using executorch::aten::ScalarType;
-
-// ============================================================================
-// TestableVisionModel — exposes protected methods for testing
-// ============================================================================
-class TestableVisionModel : public VisionModel {
-public:
-  explicit TestableVisionModel(const std::string &path)
-      : VisionModel(path, nullptr) {}
-
-  cv::Mat preprocessPublic(const cv::Mat &img) const { return preprocess(img); }
-
-  cv::Mat extractFromPixelsPublic(const JSTensorViewIn &v) const {
-    return extractFromPixels(v);
-  }
-
-  void setInputShape(std::vector<int32_t> shape) {
-    modelInputShape_ = std::move(shape);
-  }
-};
-
-// Reuse the style_transfer .pte as a vehicle — we never call forward().
-constexpr auto kModelPath = "style_transfer_candy_xnnpack_fp32.pte";
-
-// ============================================================================
-// preprocess() tests
-// ============================================================================
-class VisionModelPreprocessTest : public ::testing::Test {
-protected:
-  void SetUp() override {
-    model = std::make_unique<TestableVisionModel>(kModelPath);
-  }
-  std::unique_ptr<TestableVisionModel> model;
-};
-
-TEST_F(VisionModelPreprocessTest, CorrectSizeImageReturnedAsIs) {
-  model->setInputShape({1, 3, 64, 64});
-  cv::Mat img(64, 64, CV_8UC3, cv::Scalar(100, 150, 200));
-  auto result = model->preprocessPublic(img);
-  EXPECT_EQ(result.size(), cv::Size(64, 64));
-}
-
-TEST_F(VisionModelPreprocessTest, CorrectSizeDataUnchanged) {
-  model->setInputShape({1, 3, 8, 8});
-  cv::Mat img(8, 8, CV_8UC3, cv::Scalar(255, 0, 0));
-  auto result = model->preprocessPublic(img);
-  auto pixel = result.at<cv::Vec3b>(0, 0);
-  EXPECT_EQ(pixel[0], 255);
-  EXPECT_EQ(pixel[1], 0);
-  EXPECT_EQ(pixel[2], 0);
-}
-
-TEST_F(VisionModelPreprocessTest, LargerImageIsResizedDown) {
-  model->setInputShape({1, 3, 32, 32});
-  cv::Mat img(128, 128, CV_8UC3, cv::Scalar(0));
-  auto result = model->preprocessPublic(img);
-  EXPECT_EQ(result.size(), cv::Size(32, 32));
-}
-
-TEST_F(VisionModelPreprocessTest, SmallerImageIsResizedUp) {
-  model->setInputShape({1, 3, 128, 128});
-  cv::Mat img(32, 32, CV_8UC3, cv::Scalar(0));
-  auto result = model->preprocessPublic(img);
-  EXPECT_EQ(result.size(), cv::Size(128, 128));
-}
-
-TEST_F(VisionModelPreprocessTest, NonSquareTargetSize) {
-  model->setInputShape({1, 3, 48, 96});
-  cv::Mat img(200, 100, CV_8UC3, cv::Scalar(0));
-  auto result = model->preprocessPublic(img);
-  EXPECT_EQ(result.rows, 48);
-  EXPECT_EQ(result.cols, 96);
-}
-
-// ============================================================================
-// extractFromPixels() tests
-// ============================================================================
-class VisionModelExtractFromPixelsTest : public ::testing::Test {
-protected:
-  void SetUp() override {
-    model = std::make_unique<TestableVisionModel>(kModelPath);
-  }
-  std::unique_ptr<TestableVisionModel> model;
-};
-
-TEST_F(VisionModelExtractFromPixelsTest, ValidInputReturnsCorrectDimensions) {
-  std::vector<uint8_t> buf(64 * 64 * 3, 128);
-  JSTensorViewIn view{buf.data(), {64, 64, 3}, ScalarType::Byte};
-  auto mat = model->extractFromPixelsPublic(view);
-  EXPECT_EQ(mat.rows, 64);
-  EXPECT_EQ(mat.cols, 64);
-  EXPECT_EQ(mat.channels(), 3);
-}
-
-TEST_F(VisionModelExtractFromPixelsTest, TwoDimensionalSizesThrows) {
-  std::vector<uint8_t> buf(16, 0);
-  JSTensorViewIn view{buf.data(), {4, 4}, ScalarType::Byte};
-  EXPECT_THROW(model->extractFromPixelsPublic(view), RnExecutorchError);
-}
-
-TEST_F(VisionModelExtractFromPixelsTest, WrongChannelsThrows) {
-  std::vector<uint8_t> buf(64, 0);
-  JSTensorViewIn view{buf.data(), {4, 4, 4}, ScalarType::Byte};
-  EXPECT_THROW(model->extractFromPixelsPublic(view), RnExecutorchError);
-}
-
-TEST_F(VisionModelExtractFromPixelsTest, WrongScalarTypeThrows) {
-  std::vector<uint8_t> buf(48, 0);
-  JSTensorViewIn view{buf.data(), {4, 4, 3}, ScalarType::Float};
-  EXPECT_THROW(model->extractFromPixelsPublic(view), RnExecutorchError);
-}
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/VisionModelTests.h b/packages/react-native-executorch/common/rnexecutorch/tests/integration/VisionModelTests.h
deleted file mode 100644
index 04e407787d..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/integration/VisionModelTests.h
+++ /dev/null
@@ -1,61 +0,0 @@
-#pragma once
-
-#include "BaseModelTests.h"
-#include <atomic>
-#include <gtest/gtest.h>
-#include <rnexecutorch/Error.h>
-#include <thread>
-
-namespace model_tests {
-
-template <typename T> class VisionModelTest : public ::testing::Test {
-protected:
-  using Traits = ModelTraits<T>;
-  using ModelType = typename Traits::ModelType;
-};
-
-TYPED_TEST_SUITE_P(VisionModelTest);
-
-TYPED_TEST_P(VisionModelTest, TwoConcurrentGeneratesDoNotCrash) {
-  SETUP_TRAITS();
-  auto model = Traits::createValid();
-  std::atomic<int32_t> successCount{0};
-  std::atomic<int32_t> exceptionCount{0};
-
-  auto task = [&]() {
-    try {
-      Traits::callGenerate(model);
-      successCount++;
-    } catch (const rnexecutorch::RnExecutorchError &) {
-      exceptionCount++;
-    }
-  };
-
-  std::thread a(task);
-  std::thread b(task);
-  a.join();
-  b.join();
-
-  EXPECT_EQ(successCount + exceptionCount, 2);
-}
-
-TYPED_TEST_P(VisionModelTest, GenerateAndUnloadConcurrentlyDoesNotCrash) {
-  SETUP_TRAITS();
-  auto model = Traits::createValid();
-
-  std::thread a([&]() {
-    try {
-      Traits::callGenerate(model);
-    } catch (const rnexecutorch::RnExecutorchError &) {
-    }
-  });
-  std::thread b([&]() { model.unload(); });
-
-  a.join();
-  b.join();
-}
-
-REGISTER_TYPED_TEST_SUITE_P(VisionModelTest, TwoConcurrentGeneratesDoNotCrash,
-                            GenerateAndUnloadConcurrentlyDoesNotCrash);
-
-} // namespace model_tests
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/VoiceActivityDetectionTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/integration/VoiceActivityDetectionTest.cpp
deleted file mode 100644
index e60b375f1d..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/integration/VoiceActivityDetectionTest.cpp
+++ /dev/null
@@ -1,253 +0,0 @@
-#include "BaseModelTests.h"
-#include "utils/TestUtils.h"
-#include <chrono>
-#include <gtest/gtest.h>
-#include <jsi/jsi.h>
-#include <memory>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/models/voice_activity_detection/Utils.h>
-#include <rnexecutorch/models/voice_activity_detection/VoiceActivityDetection.h>
-#include <thread>
-
-namespace rnexecutorch {
-std::shared_ptr<facebook::react::CallInvoker> createMockCallInvoker();
-}
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::models::voice_activity_detection;
-using namespace test_utils;
-using namespace model_tests;
-
-namespace vad_utils = rnexecutorch::models::voice_activity_detection::utils;
-
-constexpr auto kValidVadModelPath = "fsmn-vad_xnnpack.pte";
-
-// ============================================================================
-// Common tests via typed test suite
-// ============================================================================
-namespace model_tests {
-template <> struct ModelTraits<VoiceActivityDetection> {
-  using ModelType = VoiceActivityDetection;
-
-  static ModelType createValid() {
-    return ModelType(kValidVadModelPath, nullptr);
-  }
-
-  static ModelType createInvalid() {
-    return ModelType("nonexistent.pte", nullptr);
-  }
-
-  static void callGenerate(ModelType &model) {
-    auto audio = loadAudioFromFile("test_audio_float.raw");
-    (void)model.generate(audio);
-  }
-};
-} // namespace model_tests
-
-using VADTypes = ::testing::Types<VoiceActivityDetection>;
-INSTANTIATE_TYPED_TEST_SUITE_P(VAD, CommonModelTest, VADTypes);
-
-// ============================================================================
-// Model-specific tests
-// ============================================================================
-TEST(VADGenerateTests, SilenceReturnsNoSegments) {
-  VoiceActivityDetection model(kValidVadModelPath, nullptr);
-  auto silence = generateSilence(16000 * 5);
-  auto segments = model.generate(silence);
-  EXPECT_TRUE(segments.empty());
-}
-
-TEST(VADGenerateTests, SegmentsHaveValidBounds) {
-  VoiceActivityDetection model(kValidVadModelPath, nullptr);
-  auto audio = loadAudioFromFile("test_audio_float.raw");
-  ASSERT_FALSE(audio.empty());
-  auto segments = model.generate(audio);
-
-  for (const auto &segment : segments) {
-    EXPECT_LE(segment.start, segment.end);
-    EXPECT_LE(segment.end, audio.size());
-  }
-}
-
-TEST(VADGenerateTests, SegmentsAreNonOverlapping) {
-  VoiceActivityDetection model(kValidVadModelPath, nullptr);
-  auto audio = loadAudioFromFile("test_audio_float.raw");
-  ASSERT_FALSE(audio.empty());
-  auto segments = model.generate(audio);
-  for (size_t i = 1; i < segments.size(); ++i) {
-    EXPECT_LE(segments[i - 1].end, segments[i].start);
-  }
-}
-
-TEST(VADGenerateTests, LongAudioSegmentBoundsValid) {
-  VoiceActivityDetection model(kValidVadModelPath, nullptr);
-  auto audio = loadAudioFromFile("test_audio_float.raw");
-  ASSERT_FALSE(audio.empty());
-  auto segments = model.generate(audio);
-
-  for (const auto &segment : segments) {
-    EXPECT_LE(segment.start, segment.end);
-    EXPECT_LE(segment.end, audio.size());
-  }
-}
-
-TEST(VADInheritedTests, GetInputShapeWorks) {
-  VoiceActivityDetection model(kValidVadModelPath, nullptr);
-  auto shape = model.getInputShape("forward", 0);
-  EXPECT_GE(shape.size(), 2u);
-}
-
-TEST(VADInheritedTests, GetAllInputShapesWorks) {
-  VoiceActivityDetection model(kValidVadModelPath, nullptr);
-  auto shapes = model.getAllInputShapes("forward");
-  EXPECT_FALSE(shapes.empty());
-}
-
-TEST(VADInheritedTests, GetMethodMetaWorks) {
-  VoiceActivityDetection model(kValidVadModelPath, nullptr);
-  auto result = model.getMethodMeta("forward");
-  EXPECT_TRUE(result.ok());
-}
-
-// ============================================================================
-// utils::mergeSegments unit tests (no model load needed)
-// ============================================================================
-TEST(VADMergeSegmentsTests, EmptyInputReturnsEmpty) {
-  std::vector<types::Segment> empty;
-  EXPECT_TRUE(vad_utils::mergeSegments(empty, /*maxMergeGap=*/100).empty());
-}
-
-TEST(VADMergeSegmentsTests, SingleSegmentReturnedUnchanged) {
-  std::vector<types::Segment> input = {{100, 500}};
-  auto merged = vad_utils::mergeSegments(input, /*maxMergeGap=*/100);
-  ASSERT_EQ(merged.size(), 1u);
-  EXPECT_EQ(merged[0].start, 100u);
-  EXPECT_EQ(merged[0].end, 500u);
-}
-
-TEST(VADMergeSegmentsTests, DistantSegmentsStaySeparate) {
-  // Gap between segments (1000 - 500 = 500) is larger than maxMergeGap (100).
-  std::vector<types::Segment> input = {{0, 500}, {1000, 1500}};
-  auto merged = vad_utils::mergeSegments(input, /*maxMergeGap=*/100);
-  ASSERT_EQ(merged.size(), 2u);
-  EXPECT_EQ(merged[0].end, 500u);
-  EXPECT_EQ(merged[1].start, 1000u);
-}
-
-TEST(VADMergeSegmentsTests, CloseSegmentsAreMerged) {
-  // Gap (510 - 500 = 10) is within maxMergeGap (100).
-  std::vector<types::Segment> input = {{0, 500}, {510, 1000}};
-  auto merged = vad_utils::mergeSegments(input, /*maxMergeGap=*/100);
-  ASSERT_EQ(merged.size(), 1u);
-  EXPECT_EQ(merged[0].start, 0u);
-  EXPECT_EQ(merged[0].end, 1000u);
-}
-
-TEST(VADMergeSegmentsTests, AdjacentSegmentsAreMerged) {
-  // Gap of 0 is <= maxMergeGap (0).
-  std::vector<types::Segment> input = {{0, 500}, {500, 1000}};
-  auto merged = vad_utils::mergeSegments(input, /*maxMergeGap=*/0);
-  ASSERT_EQ(merged.size(), 1u);
-  EXPECT_EQ(merged[0].start, 0u);
-  EXPECT_EQ(merged[0].end, 1000u);
-}
-
-TEST(VADMergeSegmentsTests, OverlappingShorterInnerDoesNotShrink) {
-  // Second segment overlaps inside the first. Merged result must not shrink.
-  std::vector<types::Segment> input = {{0, 1000}, {200, 500}};
-  auto merged = vad_utils::mergeSegments(input, /*maxMergeGap=*/0);
-  ASSERT_EQ(merged.size(), 1u);
-  EXPECT_EQ(merged[0].start, 0u);
-  EXPECT_EQ(merged[0].end, 1000u);
-}
-
-TEST(VADMergeSegmentsTests, MixedSequenceMergesOnlyAdjacentClose) {
-  // First two are close enough to merge; third is far.
-  std::vector<types::Segment> input = {{0, 500}, {520, 800}, {2000, 2500}};
-  auto merged = vad_utils::mergeSegments(input, /*maxMergeGap=*/100);
-  ASSERT_EQ(merged.size(), 2u);
-  EXPECT_EQ(merged[0].start, 0u);
-  EXPECT_EQ(merged[0].end, 800u);
-  EXPECT_EQ(merged[1].start, 2000u);
-  EXPECT_EQ(merged[1].end, 2500u);
-}
-
-// ============================================================================
-// Streaming lifecycle tests
-//
-// VAD::stream() blocks on its own loop until streamStop() flips the flag, so
-// every test below drives it from a background thread and joins after stop.
-// The native callback round-trips through the CallInvoker — using the no-op
-// MockCallInvoker means callbacks are dropped but the streaming loop itself
-// still runs normally.
-// ============================================================================
-TEST(VADStreamTests, StreamStopExitsLoop) {
-  VoiceActivityDetection model(kValidVadModelPath, createMockCallInvoker());
-  std::thread streamer([&model] {
-    model.stream(std::shared_ptr<jsi::Function>(), /*timeout=*/50,
-                 /*detectionMargin=*/100);
-  });
-
-  // Let the loop spin a few iterations before stopping.
-  std::this_thread::sleep_for(std::chrono::milliseconds(200));
-  const auto stopRequestedAt = std::chrono::steady_clock::now();
-  model.streamStop();
-  streamer.join();
-  const auto elapsedToStop = std::chrono::steady_clock::now() - stopRequestedAt;
-
-  // streamStop() should wake the wait_for() and return quickly (well below
-  // the timeout window — give a generous safety margin).
-  EXPECT_LT(elapsedToStop, std::chrono::milliseconds(500));
-}
-
-TEST(VADStreamTests, StreamInsertWhileStreamingDoesNotCrash) {
-  VoiceActivityDetection model(kValidVadModelPath, createMockCallInvoker());
-  std::thread streamer([&model] {
-    model.stream(std::shared_ptr<jsi::Function>(), /*timeout=*/50,
-                 /*detectionMargin=*/100);
-  });
-
-  auto silence = generateSilence(16000); // 1s
-  auto audio = loadAudioFromFile("test_audio_float.raw");
-  ASSERT_FALSE(audio.empty());
-
-  model.streamInsert(silence);
-  std::this_thread::sleep_for(std::chrono::milliseconds(150));
-  model.streamInsert(audio);
-  std::this_thread::sleep_for(std::chrono::milliseconds(300));
-
-  model.streamStop();
-  streamer.join();
-}
-
-TEST(VADStreamTests, ConcurrentStreamCallThrows) {
-  VoiceActivityDetection model(kValidVadModelPath, createMockCallInvoker());
-  std::thread streamer([&model] {
-    model.stream(std::shared_ptr<jsi::Function>(), /*timeout=*/50,
-                 /*detectionMargin=*/100);
-  });
-
-  // Give the first call time to flip isStreaming_ to true.
-  std::this_thread::sleep_for(std::chrono::milliseconds(100));
-
-  EXPECT_THROW(model.stream(std::shared_ptr<jsi::Function>(), /*timeout=*/50,
-                            /*detectionMargin=*/100),
-               RnExecutorchError);
-
-  model.streamStop();
-  streamer.join();
-}
-
-TEST(VADStreamTests, StreamCanBeRestartedAfterStop) {
-  VoiceActivityDetection model(kValidVadModelPath, createMockCallInvoker());
-
-  for (int iter = 0; iter < 2; ++iter) {
-    std::thread streamer([&model] {
-      model.stream(std::shared_ptr<jsi::Function>(), /*timeout=*/50,
-                   /*detectionMargin=*/100);
-    });
-    std::this_thread::sleep_for(std::chrono::milliseconds(150));
-    model.streamStop();
-    streamer.join();
-  }
-}
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/assets/test_audio_float.raw b/packages/react-native-executorch/common/rnexecutorch/tests/integration/assets/test_audio_float.raw
deleted file mode 100644
index 177c7b8914..0000000000
Binary files a/packages/react-native-executorch/common/rnexecutorch/tests/integration/assets/test_audio_float.raw and /dev/null differ
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/assets/test_speech.raw b/packages/react-native-executorch/common/rnexecutorch/tests/integration/assets/test_speech.raw
deleted file mode 100644
index 2cf55af04f..0000000000
Binary files a/packages/react-native-executorch/common/rnexecutorch/tests/integration/assets/test_speech.raw and /dev/null differ
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/assets/we_are_software_mansion.jpg b/packages/react-native-executorch/common/rnexecutorch/tests/integration/assets/we_are_software_mansion.jpg
deleted file mode 100644
index 521416d008..0000000000
Binary files a/packages/react-native-executorch/common/rnexecutorch/tests/integration/assets/we_are_software_mansion.jpg and /dev/null differ
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/libs/libfbjni.so b/packages/react-native-executorch/common/rnexecutorch/tests/integration/libs/libfbjni.so
deleted file mode 100644
index aadd325f60..0000000000
Binary files a/packages/react-native-executorch/common/rnexecutorch/tests/integration/libs/libfbjni.so and /dev/null differ
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/stubs/StubRunner.h b/packages/react-native-executorch/common/rnexecutorch/tests/integration/stubs/StubRunner.h
deleted file mode 100644
index 023d6cf080..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/integration/stubs/StubRunner.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#pragma once
-
-#include <runner/base_llm_runner.h>
-
-// Minimal concrete subclass of BaseLLMRunner — only used in tests to verify
-// base class behavior without a full runner implementation.
-class StubRunner : public ::executorch::extension::llm::BaseLLMRunner {
-public:
-  using BaseLLMRunner::BaseLLMRunner;
-  bool is_loaded() const override { return loaded_; }
-  ::executorch::runtime::Error load_subcomponents() override {
-    loaded_ = true;
-    return ::executorch::runtime::Error::Ok;
-  }
-  ::executorch::runtime::Error generate_internal(
-      const std::vector<::executorch::extension::llm::MultimodalInput> &,
-      std::function<void(const std::string &)>) override {
-    return ::executorch::runtime::Error::Ok;
-  }
-  void stop_impl() override {}
-
-  int32_t resolve_max(int32_t prompt, int32_t seq_len, int32_t ctx_len,
-                      int32_t max_new = -1) const {
-    return resolve_max_new_tokens(prompt, seq_len, ctx_len, max_new);
-  }
-
-  bool loaded_ = false;
-};
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/stubs/jsi_stubs.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/integration/stubs/jsi_stubs.cpp
deleted file mode 100644
index 897a2778e8..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/integration/stubs/jsi_stubs.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-// Stub implementations for JSI and other symbols to satisfy the linker
-// These are never actually called in tests
-
-#include <ReactCommon/CallInvoker.h>
-#include <cstddef>
-#include <functional>
-#include <jsi/jsi.h>
-#include <string>
-#include <vector>
-
-namespace facebook::jsi {
-
-// MutableBuffer destructor - needed by OwningArrayBuffer
-MutableBuffer::~MutableBuffer() {}
-Value::~Value() {}
-Value::Value(Value &&other) noexcept {}
-
-// Needed to link ObjectDetectionTests: generateFromFrame and FrameProcessor
-// pull in these JSI symbols, but they are never called in tests.
-Object Value::asObject(Runtime &) const & { __builtin_unreachable(); }
-BigInt Value::asBigInt(Runtime &) const & { __builtin_unreachable(); }
-
-uint64_t BigInt::asUint64(Runtime &) const { return 0; }
-
-} // namespace facebook::jsi
-
-namespace facebook::react {
-
-// Needed by LLM test
-class MockCallInvoker : public CallInvoker {
-public:
-  void invokeAsync(CallFunc &&func) noexcept override {}
-
-  void invokeSync(CallFunc &&func) override {}
-};
-
-} // namespace facebook::react
-
-namespace rnexecutorch {
-
-// Stub for fetchUrlFunc - used by ImageProcessing for remote URLs
-// Tests only use local files, so this is never called
-using FetchUrlFunc_t = std::function<std::vector<std::byte>(std::string)>;
-FetchUrlFunc_t fetchUrlFunc = [](std::string) -> std::vector<std::byte> {
-  return {};
-};
-
-// Global mock call invoker for tests
-std::shared_ptr<facebook::react::CallInvoker> createMockCallInvoker() {
-  return std::make_shared<facebook::react::MockCallInvoker>();
-}
-
-} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/integration/utils/TestUtils.h b/packages/react-native-executorch/common/rnexecutorch/tests/integration/utils/TestUtils.h
deleted file mode 100644
index 1e02408156..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/integration/utils/TestUtils.h
+++ /dev/null
@@ -1,36 +0,0 @@
-#pragma once
-
-#include <fstream>
-#include <string>
-#include <vector>
-
-namespace test_utils {
-
-inline void trimFilePrefix(std::string &filepath) {
-  constexpr std::string_view prefix = "file://";
-  if (filepath.starts_with(prefix)) {
-    filepath.erase(0, prefix.size());
-  }
-}
-
-inline std::vector<float> loadAudioFromFile(const std::string &filepath) {
-  std::ifstream file(filepath, std::ios::binary | std::ios::ate);
-  if (!file.is_open()) {
-    return {};
-  }
-
-  std::streamsize size = file.tellg();
-  file.seekg(0, std::ios::beg);
-
-  size_t numSamples = size / sizeof(float);
-  std::vector<float> buffer(numSamples);
-
-  file.read(reinterpret_cast<char *>(buffer.data()), size);
-  return buffer;
-}
-
-inline std::vector<float> generateSilence(size_t numSamples) {
-  return std::vector<float>(numSamples, 0.0f);
-}
-
-} // namespace test_utils
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/run_tests.sh b/packages/react-native-executorch/common/rnexecutorch/tests/run_tests.sh
deleted file mode 100755
index fda1cce6d6..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/run_tests.sh
+++ /dev/null
@@ -1,404 +0,0 @@
-#!/bin/bash
-set -e
-
-# ============================================================================
-# Constants
-# ============================================================================
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PACKAGE_ROOT="$SCRIPT_DIR/../../.."
-ANDROID_ABI="arm64-v8a"
-ANDROID_LIBS_DIR="$PACKAGE_ROOT/third-party/android/libs"
-DEVICE_TEST_DIR="/data/local/tmp/rnexecutorch_tests"
-MODELS_DIR="$SCRIPT_DIR/integration/assets/models"
-
-# Keep in sync with `LIB_VERSION` in src/constants/versions.ts so the runner
-# pulls the same artifacts that the JS API ships at runtime.
-LIB_VERSION="0.9.0"
-HF_VERSION_TAG="resolve/v${LIB_VERSION}"
-
-# ============================================================================
-# Test executables
-# ============================================================================
-TEST_EXECUTABLES=(
-  "NumericalTests"
-  "RunnerTests"
-  "SamplerTests"
-  "LogTests"
-  "FileUtilsTest"
-  "ImageProcessingTest"
-  "FrameTransformTests"
-  "BaseModelTests"
-  "ClassificationTests"
-  "ObjectDetectionTests"
-  "ImageEmbeddingsTests"
-  "TextEmbeddingsTests"
-  "StyleTransferTests"
-  "VADTests"
-  "TokenizerModuleTests"
-  "SpeechToTextTests"
-  "TextToSpeechTests"
-  "LLMTests"
-  "TextToImageTests"
-  "InstanceSegmentationTests"
-  "PoseEstimationTests"
-  "SemanticSegmentationTests"
-  "OCRTests"
-  "VerticalOCRTests"
-)
-
-# ============================================================================
-# Test assets
-# ============================================================================
-TEST_ASSETS=(
-  "integration/assets/test_audio_float.raw"
-  "integration/assets/test_speech.raw"
-  "integration/assets/we_are_software_mansion.jpg"
-)
-
-# ============================================================================
-# Models to download (format: "filename|url")
-# ============================================================================
-MODELS=(
-  "style_transfer_candy_xnnpack_fp32.pte|https://huggingface.co/software-mansion/react-native-executorch-style-transfer-candy/${HF_VERSION_TAG}/xnnpack/style_transfer_candy_xnnpack_fp32.pte"
-  "efficientnet_v2_s_xnnpack.pte|https://huggingface.co/software-mansion/react-native-executorch-efficientnet-v2-s/${HF_VERSION_TAG}/xnnpack/efficientnet_v2_s_xnnpack_fp32.pte"
-  "ssdlite320-mobilenetv3-large.pte|https://huggingface.co/software-mansion/react-native-executorch-ssdlite320-mobilenet-v3-large/${HF_VERSION_TAG}/xnnpack/ssdlite320_mobilenet_v3_large_xnnpack_fp32.pte"
-  "test_image.jpg|https://upload.wikimedia.org/wikipedia/commons/f/f8/Cat_in_tree03.jpg"
-  "clip-vit-base-patch32-vision_xnnpack.pte|https://huggingface.co/software-mansion/react-native-executorch-clip-vit-base-patch32/${HF_VERSION_TAG}/xnnpack/clip_vit_base_patch32_image_xnnpack_fp32.pte"
-  "all-MiniLM-L6-v2_xnnpack.pte|https://huggingface.co/software-mansion/react-native-executorch-all-MiniLM-L6-v2/${HF_VERSION_TAG}/xnnpack/all_minilm_l6_v2_xnnpack_fp32.pte"
-  "tokenizer.json|https://huggingface.co/software-mansion/react-native-executorch-all-MiniLM-L6-v2/${HF_VERSION_TAG}/tokenizer.json"
-  "fsmn-vad_xnnpack.pte|https://huggingface.co/software-mansion/react-native-executorch-fsmn-vad/${HF_VERSION_TAG}/xnnpack/fsmn_vad_xnnpack_fp32.pte"
-  "whisper_tiny_en_xnnpack.pte|https://huggingface.co/software-mansion/react-native-executorch-whisper-tiny.en/${HF_VERSION_TAG}/xnnpack/whisper_tiny_en_xnnpack_fp32.pte"
-  "whisper_tokenizer.json|https://huggingface.co/software-mansion/react-native-executorch-whisper-tiny.en/${HF_VERSION_TAG}/tokenizer.json"
-  "kokoro_duration_predictor.pte|https://huggingface.co/software-mansion/react-native-executorch-kokoro/${HF_VERSION_TAG}/xnnpack/standard/duration_predictor_std.pte"
-  "kokoro_synthesizer.pte|https://huggingface.co/software-mansion/react-native-executorch-kokoro/${HF_VERSION_TAG}/xnnpack/standard/synthesizer_std.pte"
-  "kokoro_af_heart.bin|https://huggingface.co/software-mansion/react-native-executorch-kokoro/${HF_VERSION_TAG}/voices/af_heart.bin"
-  "kokoro_us_lexicon.json|https://huggingface.co/software-mansion/react-native-executorch-kokoro/${HF_VERSION_TAG}/phonemizer/en-us/lexicon.json"
-  "kokoro_en_tagger.json|https://huggingface.co/software-mansion/react-native-executorch-kokoro/${HF_VERSION_TAG}/phonemizer/en-us/tags.json"
-  "kokoro_us_phonemizer.pte|https://huggingface.co/software-mansion/react-native-executorch-kokoro/${HF_VERSION_TAG}/phonemizer/en-us/phonemizer_en_us.pte"
-  "smolLm2_135M_8da4w.pte|https://huggingface.co/software-mansion/react-native-executorch-smolLm-2/${HF_VERSION_TAG}/135m/xnnpack/smollm2_135m_xnnpack_8da4w.pte"
-  "smollm_tokenizer.json|https://huggingface.co/software-mansion/react-native-executorch-smolLm-2/${HF_VERSION_TAG}/tokenizer.json"
-  "deeplabV3_xnnpack_fp32.pte|https://huggingface.co/software-mansion/react-native-executorch-deeplab-v3/${HF_VERSION_TAG}/xnnpack/deeplab_v3_resnet50_xnnpack_fp32.pte"
-  "xnnpack_crnn_english.pte|https://huggingface.co/software-mansion/react-native-executorch-recognizer-crnn.en/${HF_VERSION_TAG}/english/xnnpack/crnn_english_xnnpack_fp32.pte"
-  "xnnpack_craft_quantized.pte|https://huggingface.co/software-mansion/react-native-executorch-detector-craft/${HF_VERSION_TAG}/xnnpack/craft_xnnpack_int8.pte"
-  "t2i_tokenizer.json|https://huggingface.co/software-mansion/react-native-executorch-bk-sdm-tiny/${HF_VERSION_TAG}/tokenizer/tokenizer.json"
-  "t2i_encoder.pte|https://huggingface.co/software-mansion/react-native-executorch-bk-sdm-tiny/${HF_VERSION_TAG}/xnnpack/bk_sdm_tiny_text_encoder_xnnpack_fp32.pte"
-  "t2i_unet.pte|https://huggingface.co/software-mansion/react-native-executorch-bk-sdm-tiny/${HF_VERSION_TAG}/xnnpack/bk_sdm_tiny_unet_256_xnnpack_fp32.pte"
-  "t2i_decoder.pte|https://huggingface.co/software-mansion/react-native-executorch-bk-sdm-tiny/${HF_VERSION_TAG}/xnnpack/bk_sdm_tiny_vae_256_xnnpack_fp32.pte"
-  "lfm2_5_vl_quantized_xnnpack_v2.pte|https://huggingface.co/software-mansion/react-native-executorch-lfm-2.5/${HF_VERSION_TAG}/vl_1_6b/xnnpack/lfm_2_5_vl_1_6b_xnnpack_8da4w.pte"
-  "lfm2_vl_tokenizer.json|https://huggingface.co/software-mansion/react-native-executorch-lfm-2.5/${HF_VERSION_TAG}/vl_1_6b/tokenizer.json"
-  "lfm2_vl_tokenizer_config.json|https://huggingface.co/software-mansion/react-native-executorch-lfm-2.5/${HF_VERSION_TAG}/vl_1_6b/tokenizer_config.json"
-  "gemma4_e2b_mm_xnnpack.pte|https://huggingface.co/software-mansion/react-native-executorch-gemma-4-multimodal/${HF_VERSION_TAG}/e2b/xnnpack/gemma_4_e2b_xnnpack_8da4w.pte"
-  "gemma_tokenizer.json|https://huggingface.co/software-mansion/react-native-executorch-gemma-4/${HF_VERSION_TAG}/e2b/tokenizer.json"
-  "yolo26n-seg.pte|https://huggingface.co/software-mansion/react-native-executorch-yolo26-seg/${HF_VERSION_TAG}/n/xnnpack/yolo26_seg_n_xnnpack_fp32.pte"
-  "segmentation_image.jpg|https://upload.wikimedia.org/wikipedia/commons/thumb/8/85/Collage_audi.jpg/1280px-Collage_audi.jpg"
-  "yolo26n-pose.pte|https://huggingface.co/software-mansion/react-native-executorch-yolo26-pose/${HF_VERSION_TAG}/xnnpack/yolo26_pose_n_xnnpack_fp32.pte"
-)
-
-# ============================================================================
-# Libraries to push
-# ============================================================================
-REQUIRED_LIBS=(
-  "$ANDROID_LIBS_DIR/executorch/$ANDROID_ABI/libexecutorch.so:libexecutorch_jni.so"
-  "$ANDROID_LIBS_DIR/pthreadpool/$ANDROID_ABI/libpthreadpool.so:libpthreadpool.so"
-  "$ANDROID_LIBS_DIR/cpuinfo/$ANDROID_ABI/libcpuinfo.so:libcpuinfo.so"
-)
-
-# Dynamically find libfbjni.so from CMake builds (exclude node_modules for speed)
-# Get libc++_shared.so directly from NDK
-MONOREPO_ROOT="$PACKAGE_ROOT/../../.."
-
-LIBFBJNI_PATH="$SCRIPT_DIR/integration/libs/libfbjni.so"
-
-if [ -z "$LIBFBJNI_PATH" ]; then
-  echo "Error: libfbjni.so not found."
-  echo "Please build an app first: cd apps/computer-vision/android && ./gradlew assembleRelease"
-  exit 1
-fi
-
-# Get libc++_shared.so from NDK based on host platform
-if [[ "$OSTYPE" == "darwin"* ]]; then
-  NDK_HOST="darwin-x86_64"
-else
-  NDK_HOST="linux-x86_64"
-fi
-
-LIBCPP_PATH="$ANDROID_NDK/toolchains/llvm/prebuilt/$NDK_HOST/sysroot/usr/lib/aarch64-linux-android/libc++_shared.so"
-
-if [ ! -f "$LIBCPP_PATH" ]; then
-  echo "Error: libc++_shared.so not found at: $LIBCPP_PATH"
-  exit 1
-fi
-
-GRADLE_LIBS=(
-  "$LIBFBJNI_PATH:libfbjni.so"
-  "$LIBCPP_PATH:libc++_shared.so"
-)
-
-# ============================================================================
-# Flags
-# ============================================================================
-REFRESH_MODELS=false
-SKIP_BUILD=false
-
-# ============================================================================
-# Functions
-# ============================================================================
-
-print_usage() {
-  cat <<EOF
-Usage: $0 [OPTIONS]
-
-Options:
-  --refresh-models   Force re-download of all models
-  --skip-build       Skip the CMake build step
-  --help             Show this help message
-
-EOF
-}
-
-log() {
-  echo "[$(date +'%H:%M:%S')] $*"
-}
-
-error() {
-  echo "[ERROR] $*" >&2
-}
-
-download_if_needed() {
-  local url="$1"
-  local output="$2"
-  local filepath="$MODELS_DIR/$output"
-
-  if [ "$REFRESH_MODELS" = true ] || [ ! -f "$filepath" ]; then
-    log "Downloading $output..."
-    wget -q -O "$filepath" "$url"
-  else
-    log "$output already exists, skipping"
-  fi
-}
-
-push_file() {
-  local src="$1"
-  local dest="$2"
-
-  if [ -f "$src" ]; then
-    adb push "$src" "$dest" >/dev/null
-  else
-    error "File not found: $src"
-  fi
-}
-
-run_test() {
-  local test_exe="$1"
-
-  if adb shell "[ -f $DEVICE_TEST_DIR/$test_exe ]"; then
-    log "Running $test_exe"
-    if ! adb shell "cd $DEVICE_TEST_DIR && LD_LIBRARY_PATH=. ./$test_exe --gtest_color=yes"; then
-      return 1
-    fi
-  fi
-  return 0
-}
-
-# Returns a space-separated list of model/asset filenames (in $MODELS_DIR) that
-# the given test executable loads at runtime. Tests not listed here have no
-# model dependencies. Adding a new test? Add its filenames below.
-models_for_test() {
-  case "$1" in
-  BaseModelTests) echo "style_transfer_candy_xnnpack_fp32.pte" ;;
-  ClassificationTests) echo "efficientnet_v2_s_xnnpack.pte test_image.jpg" ;;
-  ObjectDetectionTests) echo "ssdlite320-mobilenetv3-large.pte test_image.jpg" ;;
-  ImageEmbeddingsTests) echo "clip-vit-base-patch32-vision_xnnpack.pte test_image.jpg" ;;
-  TextEmbeddingsTests) echo "all-MiniLM-L6-v2_xnnpack.pte tokenizer.json" ;;
-  StyleTransferTests) echo "style_transfer_candy_xnnpack_fp32.pte test_image.jpg" ;;
-  VADTests) echo "fsmn-vad_xnnpack.pte" ;;
-  TokenizerModuleTests) echo "tokenizer.json" ;;
-  SpeechToTextTests) echo "whisper_tiny_en_xnnpack.pte whisper_tokenizer.json fsmn-vad_xnnpack.pte" ;;
-  TextToSpeechTests) echo "kokoro_duration_predictor.pte kokoro_synthesizer.pte kokoro_af_heart.bin kokoro_us_lexicon.json kokoro_en_tagger.json kokoro_us_phonemizer.pte" ;;
-  LLMTests) echo "smolLm2_135M_8da4w.pte smollm_tokenizer.json lfm2_5_vl_quantized_xnnpack_v2.pte lfm2_vl_tokenizer.json lfm2_vl_tokenizer_config.json test_image.jpg gemma4_e2b_mm_xnnpack.pte gemma_tokenizer.json" ;;
-  TextToImageTests) echo "t2i_tokenizer.json t2i_encoder.pte t2i_unet.pte t2i_decoder.pte" ;;
-  InstanceSegmentationTests) echo "yolo26n-seg.pte segmentation_image.jpg" ;;
-  PoseEstimationTests) echo "yolo26n-pose.pte" ;;
-  SemanticSegmentationTests) echo "deeplabV3_xnnpack_fp32.pte test_image.jpg" ;;
-  OCRTests | VerticalOCRTests) echo "xnnpack_craft_quantized.pte xnnpack_crnn_english.pte" ;;
-  *) echo "" ;;
-  esac
-}
-
-push_test_models() {
-  local models="$1"
-  for filename in $models; do
-    push_file "$MODELS_DIR/$filename" "$DEVICE_TEST_DIR/"
-  done
-}
-
-cleanup_test_models() {
-  local models="$1"
-  for filename in $models; do
-    adb shell "rm -f $DEVICE_TEST_DIR/$filename" >/dev/null 2>&1 || true
-  done
-}
-
-# ============================================================================
-# Parse arguments
-# ============================================================================
-for arg in "$@"; do
-  case $arg in
-  --refresh-models)
-    REFRESH_MODELS=true
-    shift
-    ;;
-  --skip-build)
-    SKIP_BUILD=true
-    shift
-    ;;
-  --help)
-    print_usage
-    exit 0
-    ;;
-  *)
-    error "Unknown option: $arg"
-    print_usage
-    exit 1
-    ;;
-  esac
-done
-
-# ============================================================================
-# Validate environment
-# ============================================================================
-if ! adb shell ":"; then
-  error "ADB shell couldn't run successfully"
-  exit 1
-fi
-
-if [ -z "$ANDROID_NDK" ]; then
-  error "ANDROID_NDK is not set"
-  exit 1
-fi
-
-log "ANDROID_NDK = $ANDROID_NDK"
-
-# ============================================================================
-# Build tests
-# ============================================================================
-if [ "$SKIP_BUILD" = false ]; then
-  log "Building tests..."
-  rm -rf build
-  mkdir build
-  cd build
-
-  cmake .. \
-    -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK/build/cmake/android.toolchain.cmake \
-    -DANDROID_ABI=$ANDROID_ABI \
-    -DANDROID_PLATFORM=android-34 \
-    -DANDROID_STL=c++_shared
-
-  make
-else
-  if ! [ -d build ]; then
-    error "Build was skipped and the build directory doesn't exist"
-    exit 1
-  fi
-  log "Skipping build..."
-  cd build
-fi
-
-# ============================================================================
-# Prepare device
-# ============================================================================
-log "Creating device test directory..."
-adb shell "mkdir -p $DEVICE_TEST_DIR"
-
-# ============================================================================
-# Push test executables
-# ============================================================================
-log "Pushing test executables to device..."
-for test_exe in "${TEST_EXECUTABLES[@]}"; do
-  if [ -f "$test_exe" ]; then
-    push_file "$test_exe" "$DEVICE_TEST_DIR/"
-    adb shell "chmod +x $DEVICE_TEST_DIR/$test_exe"
-  fi
-done
-
-# ============================================================================
-# Push test assets
-# ============================================================================
-log "Pushing test assets to device..."
-for asset in "${TEST_ASSETS[@]}"; do
-  push_file "../$asset" "$DEVICE_TEST_DIR/"
-done
-
-# ============================================================================
-# Download models
-# ============================================================================
-log "Downloading models (use --refresh-models to force re-download)..."
-mkdir -p "$MODELS_DIR"
-
-for entry in "${MODELS[@]}"; do
-  IFS='|' read -r filename url <<<"$entry"
-  download_if_needed "$url" "$filename"
-done
-
-# Models are pushed per-test in the run loop below to keep peak device disk
-# usage low (the full set is ~6GB, far more than `/data/local/tmp` on a typical
-# emulator). See `models_for_test` for the test → models mapping.
-
-# ============================================================================
-# Push libraries
-# ============================================================================
-log "Pushing shared libraries to device..."
-
-for lib_entry in "${REQUIRED_LIBS[@]}"; do
-  IFS=':' read -r src dest <<<"$lib_entry"
-  if [ -f "$src" ]; then
-    push_file "$src" "$DEVICE_TEST_DIR/$dest"
-  fi
-done
-
-for lib_entry in "${GRADLE_LIBS[@]}"; do
-  IFS=':' read -r src dest <<<"$lib_entry"
-  if [ -f "$src" ]; then
-    push_file "$src" "$DEVICE_TEST_DIR/"
-  else
-    error "Library not found: $src"
-  fi
-done
-
-# ============================================================================
-# Run tests
-# ============================================================================
-log "Running tests on device..."
-FAILED=0
-for test_exe in "${TEST_EXECUTABLES[@]}"; do
-  models=$(models_for_test "$test_exe")
-
-  if [ -n "$models" ]; then
-    log "Pushing models for $test_exe..."
-    push_test_models "$models"
-  fi
-
-  if ! run_test "$test_exe"; then
-    FAILED=1
-  fi
-
-  if [ -n "$models" ]; then
-    cleanup_test_models "$models"
-  fi
-done
-
-# ============================================================================
-# Cleanup
-# ============================================================================
-log "Cleaning up device..."
-adb shell "rm -rf $DEVICE_TEST_DIR"
-
-cd ..
-
-if [ $FAILED -eq 0 ]; then
-  log "All tests passed!"
-else
-  error "Some tests failed"
-fi
-
-exit $FAILED
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/unit/FileUtilsTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/unit/FileUtilsTest.cpp
deleted file mode 100644
index ed9d802361..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/unit/FileUtilsTest.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include "../data_processing/FileUtils.h"
-#include <fstream>
-#include <gtest/gtest.h>
-#include <iostream>
-
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-
-namespace rnexecutorch::file_utils {
-class FileIOTest : public ::testing::Test {
-protected:
-  std::string tempFileName = "temp_test_file.txt";
-
-  void SetUp() override {
-    std::ofstream out(tempFileName, std::ios::binary);
-    out << "Hello, world";
-    out.close();
-  }
-
-  void TearDown() override { std::remove(tempFileName.c_str()); }
-};
-
-TEST_F(FileIOTest, LoadBytesFromFileSuccessfully) {
-  std::string data = loadBytesFromFile(tempFileName);
-  EXPECT_EQ(data, "Hello, world");
-}
-
-TEST_F(FileIOTest, LoadBytesFromFileFailOnNonExistentFile) {
-  EXPECT_THROW(
-      { loadBytesFromFile("non_existent_file.txt"); }, RnExecutorchError);
-}
-} // namespace rnexecutorch::file_utils
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/unit/FrameProcessorTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/unit/FrameProcessorTest.cpp
deleted file mode 100644
index cfea1eb2a4..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/unit/FrameProcessorTest.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <gtest/gtest.h>
-#include <opencv2/opencv.hpp>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/host_objects/JSTensorViewIn.h>
-#include <rnexecutorch/utils/FrameProcessor.h>
-
-using namespace rnexecutorch;
-using namespace rnexecutorch::utils;
-using executorch::aten::ScalarType;
-
-static JSTensorViewIn makeValidView(std::vector<uint8_t> &buf, int32_t h,
-                                    int32_t w) {
-  buf.assign(static_cast<size_t>(h * w * 3), 128);
-  return JSTensorViewIn{buf.data(), {h, w, 3}, ScalarType::Byte};
-}
-
-// ============================================================================
-// Valid input
-// ============================================================================
-TEST(PixelsToMatValidInput, ProducesCorrectDimensions) {
-  std::vector<uint8_t> buf;
-  auto view = makeValidView(buf, 48, 64);
-  auto mat = pixelsToMat(view);
-  EXPECT_EQ(mat.rows, 48);
-  EXPECT_EQ(mat.cols, 64);
-}
-
-TEST(PixelsToMatValidInput, MatTypeIsCV_8UC3) {
-  std::vector<uint8_t> buf;
-  auto view = makeValidView(buf, 4, 4);
-  auto mat = pixelsToMat(view);
-  EXPECT_EQ(mat.channels(), 3);
-  EXPECT_EQ(mat.type(), CV_8UC3);
-}
-
-TEST(PixelsToMatValidInput, MatWrapsOriginalData) {
-  std::vector<uint8_t> buf;
-  auto view = makeValidView(buf, 4, 4);
-  auto mat = pixelsToMat(view);
-  EXPECT_EQ(mat.data, buf.data());
-}
-
-// ============================================================================
-// Invalid sizes dimensionality
-// ============================================================================
-TEST(PixelsToMatInvalidSizes, TwoDimensionalThrows) {
-  std::vector<uint8_t> buf(16, 0);
-  JSTensorViewIn view{buf.data(), {4, 4}, ScalarType::Byte};
-  EXPECT_THROW(pixelsToMat(view), RnExecutorchError);
-}
-
-TEST(PixelsToMatInvalidSizes, FourDimensionalThrows) {
-  std::vector<uint8_t> buf(48, 0);
-  JSTensorViewIn view{buf.data(), {1, 4, 4, 3}, ScalarType::Byte};
-  EXPECT_THROW(pixelsToMat(view), RnExecutorchError);
-}
-
-TEST(PixelsToMatInvalidSizes, EmptySizesThrows) {
-  std::vector<uint8_t> buf(4, 0);
-  JSTensorViewIn view{buf.data(), {}, ScalarType::Byte};
-  EXPECT_THROW(pixelsToMat(view), RnExecutorchError);
-}
-
-// ============================================================================
-// Invalid channel count
-// ============================================================================
-TEST(PixelsToMatInvalidChannels, OneChannelThrows) {
-  std::vector<uint8_t> buf(16, 0);
-  JSTensorViewIn view{buf.data(), {4, 4, 1}, ScalarType::Byte};
-  EXPECT_THROW(pixelsToMat(view), RnExecutorchError);
-}
-
-TEST(PixelsToMatInvalidChannels, FourChannelsThrows) {
-  std::vector<uint8_t> buf(64, 0);
-  JSTensorViewIn view{buf.data(), {4, 4, 4}, ScalarType::Byte};
-  EXPECT_THROW(pixelsToMat(view), RnExecutorchError);
-}
-
-// ============================================================================
-// Invalid scalar type
-// ============================================================================
-TEST(PixelsToMatInvalidScalarType, FloatScalarTypeThrows) {
-  std::vector<uint8_t> buf(48, 0);
-  JSTensorViewIn view{buf.data(), {4, 4, 3}, ScalarType::Float};
-  EXPECT_THROW(pixelsToMat(view), RnExecutorchError);
-}
-
-TEST(PixelsToMatInvalidScalarType, IntScalarTypeThrows) {
-  std::vector<uint8_t> buf(48, 0);
-  JSTensorViewIn view{buf.data(), {4, 4, 3}, ScalarType::Int};
-  EXPECT_THROW(pixelsToMat(view), RnExecutorchError);
-}
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/unit/FrameTransformTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/unit/FrameTransformTest.cpp
deleted file mode 100644
index f9df940be2..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/unit/FrameTransformTest.cpp
+++ /dev/null
@@ -1,373 +0,0 @@
-#include <gtest/gtest.h>
-#include <opencv2/opencv.hpp>
-#include <rnexecutorch/utils/FrameTransform.h>
-#include <rnexecutorch/utils/computer_vision/Types.h>
-
-using namespace rnexecutorch::utils;
-using rnexecutorch::utils::computer_vision::BBox;
-
-static FrameOrientation makeOrient(const std::string &o, bool mirrored) {
-  return {orientationFromString(o), mirrored};
-}
-
-// ============================================================================
-// rotateFrameForModel — rotates sensor-native frame so model sees upright
-// image.
-//
-//   "up"    (landscape-left)       → no rotation
-//   "left"  (portrait upright)     → CW
-//   "right" (portrait upside-down) → CCW
-//   "down"  (landscape-right)      → 180°
-// ============================================================================
-
-// "up" → no rotation. 480×640 stays 480×640.
-TEST(RotateFrameForModel, Up_NoRotation) {
-  cv::Mat input(480, 640, CV_8UC3, cv::Scalar(1, 2, 3));
-  cv::Mat result = rotateFrameForModel(input, makeOrient("up", false));
-  EXPECT_EQ(result.rows, 480);
-  EXPECT_EQ(result.cols, 640);
-}
-
-// "up" → no rotation. Verify pixel values preserved.
-TEST(RotateFrameForModel, Up_PixelsPreserved) {
-  cv::Mat input(1, 2, CV_8UC3);
-  input.at<cv::Vec3b>(0, 0) = {255, 0, 0};
-  input.at<cv::Vec3b>(0, 1) = {0, 0, 255};
-  cv::Mat result = rotateFrameForModel(input, makeOrient("up", false));
-  EXPECT_EQ(result.at<cv::Vec3b>(0, 0), (cv::Vec3b{255, 0, 0}));
-  EXPECT_EQ(result.at<cv::Vec3b>(0, 1), (cv::Vec3b{0, 0, 255}));
-}
-
-// "left" → CW. 480×640 becomes 640×480.
-TEST(RotateFrameForModel, Left_CW) {
-  cv::Mat input(480, 640, CV_8UC3, cv::Scalar(1, 2, 3));
-  cv::Mat result = rotateFrameForModel(input, makeOrient("left", false));
-  EXPECT_EQ(result.rows, 640);
-  EXPECT_EQ(result.cols, 480);
-}
-
-// "left" → CW pixel check. 1×2 [R, B] → 2×1 [R; B].
-// CW takes bottom-of-left-col to top: (0,0)→(0,0), (0,1)→(1,0).
-TEST(RotateFrameForModel, Left_CW_Pixels) {
-  cv::Mat input(1, 2, CV_8UC3);
-  input.at<cv::Vec3b>(0, 0) = {255, 0, 0}; // R left
-  input.at<cv::Vec3b>(0, 1) = {0, 0, 255}; // B right
-  cv::Mat result = rotateFrameForModel(input, makeOrient("left", false));
-  EXPECT_EQ(result.rows, 2);
-  EXPECT_EQ(result.cols, 1);
-  EXPECT_EQ(result.at<cv::Vec3b>(0, 0), (cv::Vec3b{255, 0, 0})); // R
-  EXPECT_EQ(result.at<cv::Vec3b>(1, 0), (cv::Vec3b{0, 0, 255})); // B
-}
-
-// "right" → CCW. 480×640 becomes 640×480.
-TEST(RotateFrameForModel, Right_CCW) {
-  cv::Mat input(480, 640, CV_8UC3, cv::Scalar(1, 2, 3));
-  cv::Mat result = rotateFrameForModel(input, makeOrient("right", false));
-  EXPECT_EQ(result.rows, 640);
-  EXPECT_EQ(result.cols, 480);
-}
-
-// "right" → pixel check. 1×2 [R, B] → 2×1.
-// iOS rotates CCW: (0,1)→(0,0), (0,0)→(1,0), so result is [B; R].
-// Android rotates CW (front-cam upright portrait): result is [R; B].
-TEST(RotateFrameForModel, Right_CCW_Pixels) {
-  cv::Mat input(1, 2, CV_8UC3);
-  input.at<cv::Vec3b>(0, 0) = {255, 0, 0}; // R left
-  input.at<cv::Vec3b>(0, 1) = {0, 0, 255}; // B right
-  cv::Mat result = rotateFrameForModel(input, makeOrient("right", false));
-  EXPECT_EQ(result.rows, 2);
-  EXPECT_EQ(result.cols, 1);
-#if defined(__APPLE__)
-  EXPECT_EQ(result.at<cv::Vec3b>(0, 0), (cv::Vec3b{0, 0, 255})); // B
-  EXPECT_EQ(result.at<cv::Vec3b>(1, 0), (cv::Vec3b{255, 0, 0})); // R
-#else
-  EXPECT_EQ(result.at<cv::Vec3b>(0, 0), (cv::Vec3b{255, 0, 0})); // R
-  EXPECT_EQ(result.at<cv::Vec3b>(1, 0), (cv::Vec3b{0, 0, 255})); // B
-#endif
-}
-
-// "down" → 180°. 480×640 stays 480×640.
-TEST(RotateFrameForModel, Down_180) {
-  cv::Mat input(480, 640, CV_8UC3, cv::Scalar(1, 2, 3));
-  cv::Mat result = rotateFrameForModel(input, makeOrient("down", false));
-  EXPECT_EQ(result.rows, 480);
-  EXPECT_EQ(result.cols, 640);
-}
-
-// "down" → 180° pixel check. 1×2 [R, B] → 1×2 [B, R].
-TEST(RotateFrameForModel, Down_180_Pixels) {
-  cv::Mat input(1, 2, CV_8UC3);
-  input.at<cv::Vec3b>(0, 0) = {255, 0, 0};
-  input.at<cv::Vec3b>(0, 1) = {0, 0, 255};
-  cv::Mat result = rotateFrameForModel(input, makeOrient("down", false));
-  EXPECT_EQ(result.at<cv::Vec3b>(0, 0), (cv::Vec3b{0, 0, 255})); // B
-  EXPECT_EQ(result.at<cv::Vec3b>(0, 1), (cv::Vec3b{255, 0, 0})); // R
-}
-
-// isMirrored + "up" → flip only. 1×2 [R, B] → 1×2 [B, R].
-TEST(RotateFrameForModel, Mirrored_Up_FlipOnly) {
-  cv::Mat input(1, 2, CV_8UC3);
-  input.at<cv::Vec3b>(0, 0) = {255, 0, 0};
-  input.at<cv::Vec3b>(0, 1) = {0, 0, 255};
-  cv::Mat result = rotateFrameForModel(input, makeOrient("up", true));
-  EXPECT_EQ(result.rows, 1);
-  EXPECT_EQ(result.cols, 2);
-  EXPECT_EQ(result.at<cv::Vec3b>(0, 0), (cv::Vec3b{0, 0, 255})); // B
-  EXPECT_EQ(result.at<cv::Vec3b>(0, 1), (cv::Vec3b{255, 0, 0})); // R
-}
-
-// isMirrored + "left" → flip then CW.
-// 1×2 [R, B] → flip → [B, R] → CW → 2×1 [B; R].
-TEST(RotateFrameForModel, Mirrored_Left_FlipThenCW) {
-  cv::Mat input(1, 2, CV_8UC3);
-  input.at<cv::Vec3b>(0, 0) = {255, 0, 0};
-  input.at<cv::Vec3b>(0, 1) = {0, 0, 255};
-  cv::Mat result = rotateFrameForModel(input, makeOrient("left", true));
-  EXPECT_EQ(result.rows, 2);
-  EXPECT_EQ(result.cols, 1);
-  EXPECT_EQ(result.at<cv::Vec3b>(0, 0), (cv::Vec3b{0, 0, 255})); // B
-  EXPECT_EQ(result.at<cv::Vec3b>(1, 0), (cv::Vec3b{255, 0, 0})); // R
-}
-
-// Does not modify input.
-TEST(RotateFrameForModel, DoesNotModifyInput) {
-  cv::Mat input(1, 2, CV_8UC3);
-  input.at<cv::Vec3b>(0, 0) = {255, 0, 0};
-  input.at<cv::Vec3b>(0, 1) = {0, 0, 255};
-  cv::Mat inputCopy = input.clone();
-  rotateFrameForModel(input, makeOrient("left", true));
-  EXPECT_EQ(input.at<cv::Vec3b>(0, 0), inputCopy.at<cv::Vec3b>(0, 0));
-  EXPECT_EQ(input.at<cv::Vec3b>(0, 1), inputCopy.at<cv::Vec3b>(0, 1));
-}
-
-// ============================================================================
-// inverseRotateMat — inverse of rotateFrameForModel for matrices.
-//
-//   "up"    → CW   (undo no-op: landscape→portrait for screen)
-//   "left"  → no-op (already in screen space after CW model rotation)
-//   "right" → 180°  (undo CCW)
-//   "down"  → CCW   (undo 180°)
-// ============================================================================
-
-// "left" → no-op. Same dims.
-TEST(InverseRotateMat, Left_NoOp) {
-  cv::Mat input(640, 480, CV_8UC3, cv::Scalar(1, 2, 3));
-  cv::Mat result = inverseRotateMat(input, makeOrient("left", false));
-  EXPECT_EQ(result.rows, 640);
-  EXPECT_EQ(result.cols, 480);
-}
-
-// "up" → CW. 480×640 becomes 640×480.
-TEST(InverseRotateMat, Up_CW) {
-  cv::Mat input(480, 640, CV_8UC3, cv::Scalar(1, 2, 3));
-  cv::Mat result = inverseRotateMat(input, makeOrient("up", false));
-  EXPECT_EQ(result.rows, 640);
-  EXPECT_EQ(result.cols, 480);
-}
-
-// "right" → 180°. Same dims.
-TEST(InverseRotateMat, Right_180) {
-  cv::Mat input(640, 480, CV_8UC3, cv::Scalar(1, 2, 3));
-  cv::Mat result = inverseRotateMat(input, makeOrient("right", false));
-  EXPECT_EQ(result.rows, 640);
-  EXPECT_EQ(result.cols, 480);
-}
-
-// "down" → CCW. 480×640 becomes 640×480.
-TEST(InverseRotateMat, Down_CCW) {
-  cv::Mat input(480, 640, CV_8UC3, cv::Scalar(1, 2, 3));
-  cv::Mat result = inverseRotateMat(input, makeOrient("down", false));
-  EXPECT_EQ(result.rows, 640);
-  EXPECT_EQ(result.cols, 480);
-}
-
-// Round-trip: rotateFrameForModel then inverseRotateMat restores pixel content.
-// Use "left" (CW then no-op for inverse on Android).
-TEST(InverseRotateMat, RoundTrip_Left) {
-  cv::Mat input(2, 3, CV_8UC3);
-  input.at<cv::Vec3b>(0, 0) = {10, 20, 30};
-  input.at<cv::Vec3b>(0, 1) = {40, 50, 60};
-  input.at<cv::Vec3b>(0, 2) = {70, 80, 90};
-  input.at<cv::Vec3b>(1, 0) = {100, 110, 120};
-  input.at<cv::Vec3b>(1, 1) = {130, 140, 150};
-  input.at<cv::Vec3b>(1, 2) = {160, 170, 180};
-
-  cv::Mat rotated = rotateFrameForModel(input, makeOrient("left", false));
-  // "left" → CW: 2×3 → 3×2
-  EXPECT_EQ(rotated.rows, 3);
-  EXPECT_EQ(rotated.cols, 2);
-
-  cv::Mat restored = inverseRotateMat(rotated, makeOrient("left", false));
-  // "left" inverse → no-op on Android, so restored is still 3×2.
-  // The inverse undoes the model rotation to get back to sensor-native layout
-  // which for "left" means the CW was the model rotation, and inverse is no-op
-  // because the model output is already in screen orientation.
-  // On Android: left inverse = no-op, so result stays as rotated.
-  EXPECT_EQ(restored.rows, 3);
-  EXPECT_EQ(restored.cols, 2);
-}
-
-// Does not modify input.
-TEST(InverseRotateMat, DoesNotModifyInput) {
-  cv::Mat input(1, 2, CV_8UC3);
-  input.at<cv::Vec3b>(0, 0) = {255, 0, 0};
-  input.at<cv::Vec3b>(0, 1) = {0, 0, 255};
-  cv::Mat inputCopy = input.clone();
-  inverseRotateMat(input, makeOrient("up", false));
-  EXPECT_EQ(input.at<cv::Vec3b>(0, 0), inputCopy.at<cv::Vec3b>(0, 0));
-  EXPECT_EQ(input.at<cv::Vec3b>(0, 1), inputCopy.at<cv::Vec3b>(0, 1));
-}
-
-// ============================================================================
-// inverseRotateBbox — inverse of rotateFrameForModel for axis-aligned bboxes.
-//
-// rW/rH = rotated frame dimensions (after rotateFrameForModel).
-// On Android (no __APPLE__), isMirrored is ignored.
-//
-// Formulas (same as inverseRotatePoints per-corner, but preserves x1<=x2,
-// y1<=y2):
-//   "up"    → CW:  nx1=h-y2, ny1=x1, nx2=h-y1, ny2=x2
-//   "right" → 180°: nx1=w-x2, ny1=h-y2, nx2=w-x1, ny2=h-y1
-//   "down"  → CCW: nx1=y1, ny1=w-x2, nx2=y2, ny2=w-x1
-//   "left"  → no-op
-// ============================================================================
-
-// "left" → no-op. Box unchanged.
-TEST(InverseRotateBbox, Left_NoOp) {
-  BBox bbox{10, 20, 100, 200};
-  inverseRotateBbox(bbox, makeOrient("left", false), {640, 480});
-  EXPECT_FLOAT_EQ(bbox.p1.x, 10);
-  EXPECT_FLOAT_EQ(bbox.p1.y, 20);
-  EXPECT_FLOAT_EQ(bbox.p2.x, 100);
-  EXPECT_FLOAT_EQ(bbox.p2.y, 200);
-}
-
-// "up" → CW. rW=640, rH=480. Box (10,20)-(100,200):
-//   nx1=480-200=280, ny1=10, nx2=480-20=460, ny2=100
-TEST(InverseRotateBbox, Up_CW) {
-  BBox bbox{10, 20, 100, 200};
-  inverseRotateBbox(bbox, makeOrient("up", false), {640, 480});
-  EXPECT_FLOAT_EQ(bbox.p1.x, 280);
-  EXPECT_FLOAT_EQ(bbox.p1.y, 10);
-  EXPECT_FLOAT_EQ(bbox.p2.x, 460);
-  EXPECT_FLOAT_EQ(bbox.p2.y, 100);
-}
-
-// "right" → iOS does 180° inverse (rW=480, rH=640; (10,20)-(100,200) →
-// (380,440)-(470,620)). Android intentionally no-ops because
-// rotateFrameForModel already rotated CW (front-cam upright portrait).
-TEST(InverseRotateBbox, Right_180) {
-  BBox bbox{10, 20, 100, 200};
-  inverseRotateBbox(bbox, makeOrient("right", false), {480, 640});
-#if defined(__APPLE__)
-  EXPECT_FLOAT_EQ(bbox.p1.x, 380);
-  EXPECT_FLOAT_EQ(bbox.p1.y, 440);
-  EXPECT_FLOAT_EQ(bbox.p2.x, 470);
-  EXPECT_FLOAT_EQ(bbox.p2.y, 620);
-#else
-  EXPECT_FLOAT_EQ(bbox.p1.x, 10);
-  EXPECT_FLOAT_EQ(bbox.p1.y, 20);
-  EXPECT_FLOAT_EQ(bbox.p2.x, 100);
-  EXPECT_FLOAT_EQ(bbox.p2.y, 200);
-#endif
-}
-
-// "down" → CCW. rW=640, rH=480. Box (10,20)-(100,200):
-//   nx1=20, ny1=640-100=540, nx2=200, ny2=640-10=630
-TEST(InverseRotateBbox, Down_CCW) {
-  BBox bbox{10, 20, 100, 200};
-  inverseRotateBbox(bbox, makeOrient("down", false), {640, 480});
-  EXPECT_FLOAT_EQ(bbox.p1.x, 20);
-  EXPECT_FLOAT_EQ(bbox.p1.y, 540);
-  EXPECT_FLOAT_EQ(bbox.p2.x, 200);
-  EXPECT_FLOAT_EQ(bbox.p2.y, 630);
-}
-
-// Guarantees x1<=x2 and y1<=y2 after transform.
-TEST(InverseRotateBbox, OutputOrdered) {
-  BBox bbox{50, 50, 150, 250};
-  inverseRotateBbox(bbox, makeOrient("up", false), {640, 480});
-  EXPECT_LE(bbox.p1.x, bbox.p2.x);
-  EXPECT_LE(bbox.p1.y, bbox.p2.y);
-}
-
-// ============================================================================
-// inverseRotatePoints — inverse of rotateFrameForModel for 4-point bboxes.
-//
-// Same formulas as inverseRotateBbox but applied per-point (no reordering).
-// On Android (no __APPLE__), isMirrored is ignored.
-// ============================================================================
-
-struct Pt {
-  float x;
-  float y;
-};
-
-// "left" → no-op. Points unchanged.
-TEST(InverseRotatePoints, Left_NoOp) {
-  std::array<Pt, 4> pts = {{{10, 20}, {30, 40}, {50, 60}, {70, 80}}};
-  inverseRotatePoints(pts, makeOrient("left", false), {640, 480});
-  EXPECT_FLOAT_EQ(pts[0].x, 10);
-  EXPECT_FLOAT_EQ(pts[0].y, 20);
-  EXPECT_FLOAT_EQ(pts[1].x, 30);
-  EXPECT_FLOAT_EQ(pts[1].y, 40);
-  EXPECT_FLOAT_EQ(pts[2].x, 50);
-  EXPECT_FLOAT_EQ(pts[2].y, 60);
-  EXPECT_FLOAT_EQ(pts[3].x, 70);
-  EXPECT_FLOAT_EQ(pts[3].y, 80);
-}
-
-// "up" → CW per point. rW=640, rH=480. pt(10,20): nx=480-20=460, ny=10.
-TEST(InverseRotatePoints, Up_CW) {
-  std::array<Pt, 4> pts = {{{10, 20}, {30, 40}, {50, 60}, {70, 80}}};
-  inverseRotatePoints(pts, makeOrient("up", false), {640, 480});
-  EXPECT_FLOAT_EQ(pts[0].x, 460);
-  EXPECT_FLOAT_EQ(pts[0].y, 10);
-  EXPECT_FLOAT_EQ(pts[1].x, 440);
-  EXPECT_FLOAT_EQ(pts[1].y, 30);
-  EXPECT_FLOAT_EQ(pts[2].x, 420);
-  EXPECT_FLOAT_EQ(pts[2].y, 50);
-  EXPECT_FLOAT_EQ(pts[3].x, 400);
-  EXPECT_FLOAT_EQ(pts[3].y, 70);
-}
-
-// "right" → iOS does 180° per point (rW=480, rH=640; (10,20)→(470,620)).
-// Android intentionally no-ops because rotateFrameForModel already rotated
-// CW (front-cam upright portrait).
-TEST(InverseRotatePoints, Right_180) {
-  std::array<Pt, 4> pts = {{{10, 20}, {30, 40}, {50, 60}, {70, 80}}};
-  inverseRotatePoints(pts, makeOrient("right", false), {480, 640});
-#if defined(__APPLE__)
-  EXPECT_FLOAT_EQ(pts[0].x, 470);
-  EXPECT_FLOAT_EQ(pts[0].y, 620);
-  EXPECT_FLOAT_EQ(pts[1].x, 450);
-  EXPECT_FLOAT_EQ(pts[1].y, 600);
-  EXPECT_FLOAT_EQ(pts[2].x, 430);
-  EXPECT_FLOAT_EQ(pts[2].y, 580);
-  EXPECT_FLOAT_EQ(pts[3].x, 410);
-  EXPECT_FLOAT_EQ(pts[3].y, 560);
-#else
-  EXPECT_FLOAT_EQ(pts[0].x, 10);
-  EXPECT_FLOAT_EQ(pts[0].y, 20);
-  EXPECT_FLOAT_EQ(pts[1].x, 30);
-  EXPECT_FLOAT_EQ(pts[1].y, 40);
-  EXPECT_FLOAT_EQ(pts[2].x, 50);
-  EXPECT_FLOAT_EQ(pts[2].y, 60);
-  EXPECT_FLOAT_EQ(pts[3].x, 70);
-  EXPECT_FLOAT_EQ(pts[3].y, 80);
-#endif
-}
-
-// "down" → CCW per point. rW=640, rH=480. pt(10,20): nx=20, ny=640-10=630.
-TEST(InverseRotatePoints, Down_CCW) {
-  std::array<Pt, 4> pts = {{{10, 20}, {30, 40}, {50, 60}, {70, 80}}};
-  inverseRotatePoints(pts, makeOrient("down", false), {640, 480});
-  EXPECT_FLOAT_EQ(pts[0].x, 20);
-  EXPECT_FLOAT_EQ(pts[0].y, 630);
-  EXPECT_FLOAT_EQ(pts[1].x, 40);
-  EXPECT_FLOAT_EQ(pts[1].y, 610);
-  EXPECT_FLOAT_EQ(pts[2].x, 60);
-  EXPECT_FLOAT_EQ(pts[2].y, 590);
-  EXPECT_FLOAT_EQ(pts[3].x, 80);
-  EXPECT_FLOAT_EQ(pts[3].y, 570);
-}
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/unit/ImageProcessingTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/unit/ImageProcessingTest.cpp
deleted file mode 100644
index d8a5a2a7fe..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/unit/ImageProcessingTest.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-#include "../data_processing/ImageProcessing.h"
-#include <gtest/gtest.h>
-#include <opencv2/opencv.hpp>
-#include <string>
-
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-
-const std::string RAW_BASE64_JPEG =
-    "/9j/4AAQSkZJRgABAQEASABIAAD/2wBDAP////////////////////////////////////////"
-    "//////////////////////////////////////////////2wBDAf//////////////////////"
-    "////////////////////////////////////////////////////////////////"
-    "wAARCAABAAEDASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAj/"
-    "xAAUEAEAAAAAAAAAAAAAAAAAAAAA/8QAFAEBAQAAAAAAAAAAAAAAAAAAAAH/"
-    "xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIRAxEAPwC/gAf/2Q==";
-
-namespace rnexecutorch::image_processing {
-TEST(ReadImageTest, WorksWithWholeUriBase64) {
-  std::string dataUri = "data:image/jpeg;base64," + RAW_BASE64_JPEG;
-
-  cv::Mat image;
-  ASSERT_NO_THROW({ image = readImage(dataUri); });
-
-  EXPECT_FALSE(image.empty());
-  EXPECT_EQ(image.rows, 1);
-  EXPECT_EQ(image.cols, 1);
-}
-
-TEST(ReadImageTest, WorksWithRawBase64Content) {
-  cv::Mat image;
-  ASSERT_NO_THROW({ image = readImage(RAW_BASE64_JPEG); });
-
-  EXPECT_FALSE(image.empty());
-  EXPECT_EQ(image.rows, 1);
-  EXPECT_EQ(image.cols, 1);
-}
-
-TEST(ReadImageTest, FailsForInvalidBase64UriFormat) {
-  std::string invalidUri =
-      "data:image/jpeg;base64,extra,comma," + RAW_BASE64_JPEG;
-
-  EXPECT_THROW({ readImage(invalidUri); }, RnExecutorchError);
-
-  try {
-    readImage(invalidUri);
-  } catch (const RnExecutorchError &e) {
-    EXPECT_EQ(e.getNumericCode(),
-              static_cast<int32_t>(RnExecutorchErrorCode::FileReadFailed));
-  }
-}
-
-TEST(ReadImageTest, FailsForInvalidBase64Data) {
-  std::string badDataUri = "data:image/jpeg;base64,NOT_A_VALID_IMAGE_DATA";
-
-  EXPECT_THROW({ readImage(badDataUri); }, RnExecutorchError);
-
-  try {
-    readImage(badDataUri);
-  } catch (const RnExecutorchError &e) {
-    EXPECT_STREQ(e.what(), "Read image error: invalid argument");
-  }
-}
-} // namespace rnexecutorch::image_processing
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/unit/LogTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/unit/LogTest.cpp
deleted file mode 100644
index 1fb2f3fdf6..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/unit/LogTest.cpp
+++ /dev/null
@@ -1,529 +0,0 @@
-#include "../Log.h"
-#include <gtest/gtest.h>
-
-#include <array>
-#include <cmath>
-#include <complex>
-#include <deque>
-#include <forward_list>
-#include <fstream>
-#include <list>
-#include <map>
-#include <queue>
-#include <regex>
-#include <set>
-#include <stack>
-#include <stdexcept>
-#include <string_view>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-namespace low_level_log_implementation {
-
-class TestValue : public ::testing::Test {
-protected:
-  TestValue() { oss << std::boolalpha; }
-
-  template <typename T>
-  void testValueViaComparison(const T &value,
-                              const std::string &expectedOutput) {
-    printElement(oss, value);
-    EXPECT_EQ(oss.str(), expectedOutput);
-    clearOutputStream(oss);
-  }
-
-  template <typename T>
-  void testValueViaRegex(const T &value, const std::string &expectedPattern) {
-    printElement(oss, value);
-    const std::regex pattern(expectedPattern);
-    EXPECT_TRUE(std::regex_search(oss.str(), pattern))
-        << "Expected pattern not found: " << expectedPattern;
-    clearOutputStream(oss);
-  }
-
-  void setOutputStreamPresicion(int precision) noexcept {
-    oss << std::fixed << std::setprecision(precision);
-  }
-
-private:
-  std::ostringstream oss;
-  void clearOutputStream(std::ostringstream &os) noexcept {
-    oss.str("");
-    oss.clear();
-  }
-};
-
-class DirectStreamableElementsPrintTest : public TestValue {};
-
-class ContainerPrintTest : public TestValue {};
-
-class NestedContainerPrintTest : public TestValue {};
-
-class EgdeCasesPrintTest : public TestValue {};
-
-class SmartPointerPrintTest : public TestValue {};
-
-class OptionalPrintTest : public TestValue {};
-
-class VariantPrintTest : public TestValue {};
-
-class ErrorHandlingPrintTest : public TestValue {};
-
-class FileSystemPrintTest : public TestValue {};
-
-class UnsupportedLoggingTest : public ::testing::Test {};
-
-class Point final {
-public:
-  explicit constexpr Point(int x, int y) noexcept : x(x), y(y) {}
-
-  // Overloading the << operator to make Point directly streamable
-  friend std::ostream &operator<<(std::ostream &os, const Point &pt) noexcept {
-    os << "Point(" << pt.x << ", " << pt.y << ")";
-    return os;
-  }
-
-private:
-  int x, y;
-};
-
-TEST_F(DirectStreamableElementsPrintTest, HandlesIntegers) {
-  testValueViaComparison(123, "123");
-}
-
-TEST_F(DirectStreamableElementsPrintTest, HandlesStrings) {
-  testValueViaComparison(std::string("Hello World"), "Hello World");
-}
-
-TEST_F(DirectStreamableElementsPrintTest, HandlesStringViews) {
-  testValueViaComparison(std::string_view("Hello World"), "Hello World");
-}
-
-TEST_F(DirectStreamableElementsPrintTest, HandlesDoubles) {
-  constexpr double roughlyPi = 3.14159;
-  testValueViaComparison(roughlyPi, "3.14159");
-}
-
-TEST_F(DirectStreamableElementsPrintTest, HandlesBooleans) {
-  testValueViaComparison(true, "true");
-  testValueViaComparison(false, "false");
-}
-
-TEST_F(DirectStreamableElementsPrintTest, HandlesChar) {
-  testValueViaComparison('a', "a");
-}
-
-TEST_F(DirectStreamableElementsPrintTest, HandlesCharPointer) {
-  const char *word = "Hello World";
-  testValueViaComparison(word, "Hello World");
-}
-
-TEST_F(DirectStreamableElementsPrintTest, HandlesComplexNumbers) {
-  using namespace std::complex_literals;
-  constexpr int presision = 1;
-  setOutputStreamPresicion(presision);
-  const std::complex<double> complexNumber = std::pow(1i, 2);
-  testValueViaComparison(complexNumber, "(-1.0,0.0)");
-}
-
-TEST_F(DirectStreamableElementsPrintTest, HandlesPoint) {
-  constexpr Point point(3, 4);
-  testValueViaComparison(point, "Point(3, 4)");
-}
-
-// log handles operator<<(&ostream) for std::pair
-TEST_F(DirectStreamableElementsPrintTest, HandlesStdPair) {
-  std::pair<int, std::string> pairOfIntAndString = {42, "Hello"};
-  testValueViaComparison(pairOfIntAndString, "(42, Hello)");
-
-  // Testing edge cases with pairs
-  const std::pair<std::string, std::string> emptyPair = {"", ""};
-  testValueViaComparison(emptyPair, "(, )");
-}
-
-TEST_F(DirectStreamableElementsPrintTest, handlesStaticArrayOfChars) {
-  constexpr char staticCharArray[] = "prompt tokens:";
-  testValueViaComparison(staticCharArray, "prompt tokens:");
-}
-
-// log handles operator<<(&ostream) for std::tuple
-TEST_F(DirectStreamableElementsPrintTest, HandlesStdTuple) {
-  const std::tuple<int, std::string, double> tupleOfDifferentTypes = {
-      42, "Tuple", 3.14};
-  testValueViaComparison(tupleOfDifferentTypes, "<42, Tuple, 3.14>");
-
-  // All empty or zero-initialized elements of tuple
-  const std::tuple<std::string, int, float> zeroInitializedTuple = {"", 0,
-                                                                    0.0f};
-  testValueViaComparison(zeroInitializedTuple, "<, 0, 0>");
-
-  // Nested tuple
-  const std::tuple<int, std::pair<std::string, bool>, float> nestedTuple = {
-      1, {"nested", true}, 2.5};
-  testValueViaComparison(nestedTuple, "<1, (nested, true), 2.5>");
-}
-
-TEST_F(ContainerPrintTest, VectorIntTest) {
-  const std::vector<int> vectorOfInts = {1, 2, 3, 4};
-  testValueViaComparison(vectorOfInts, "[1, 2, 3, 4]");
-}
-
-TEST_F(ContainerPrintTest, ListDoubleTest) {
-  const std::list<double> listOfDoubles = {1.1, 2.2, 3.3};
-  testValueViaComparison(listOfDoubles, "[1.1, 2.2, 3.3]");
-}
-
-TEST_F(ContainerPrintTest, DequeStringTest) {
-  const std::deque<std::string> dequeOfStrings = {"hello", "world"};
-  testValueViaComparison(dequeOfStrings, "[hello, world]");
-}
-
-TEST_F(ContainerPrintTest, SetTest) {
-  const std::set<std::string> setOfStrings = {"apple", "banana", "cherry"};
-  testValueViaComparison(setOfStrings,
-                         "[apple, banana, cherry]"); // Note: Sets are sorted
-}
-
-TEST_F(ContainerPrintTest, MapTest) {
-  const std::map<std::string, int> mapStringToInt = {{"one", 1}, {"two", 2}};
-  testValueViaComparison(mapStringToInt, "[(one, 1), (two, 2)]");
-}
-
-TEST_F(ContainerPrintTest, HandlesUnorderedSet) {
-  const std::unordered_set<int> unorderedSetOfInts = {4, 3, 2, 1};
-  // Pattern expects to find each element at least once in any order
-  testValueViaRegex(unorderedSetOfInts, R"(.*1.*2.*3.*4.*)");
-}
-
-TEST_F(ContainerPrintTest, HandlesUnorderedMultimap) {
-  const std::unordered_multimap<std::string, int> unorderedMultimapStringToInt =
-      {{"one", 1}, {"one", 2}, {"two", 2}};
-  std::string pattern = R"(\[\s*)";
-  // construct regex by adding each permutation
-  pattern += R"((?:\(one, 1\),\s*\(one, 2\),\s*\(two, 2\)|)";
-  pattern += R"(\(one, 1\),\s*\(two, 2\),\s*\(one, 2\)|)";
-  pattern += R"(\(one, 2\),\s*\(one, 1\),\s*\(two, 2\)|)";
-  pattern += R"(\(one, 2\),\s*\(two, 2\),\s*\(one, 1\)|)";
-  pattern += R"(\(two, 2\),\s*\(one, 1\),\s*\(one, 2\)|)";
-  pattern += R"(\(two, 2\),\s*\(one, 2\),\s*\(one, 1\))\s*\])";
-
-  testValueViaRegex(unorderedMultimapStringToInt, pattern);
-}
-
-TEST_F(ContainerPrintTest, StackTest) {
-  std::stack<int> stackOfInts;
-  stackOfInts.push(1);
-  stackOfInts.push(2);
-  stackOfInts.push(3);
-  testValueViaComparison(stackOfInts, "[3, 2, 1]"); // LIFO order
-}
-
-TEST_F(ContainerPrintTest, QueueTest) {
-  std::queue<int> queueOfInts;
-  queueOfInts.push(1);
-  queueOfInts.push(2);
-  queueOfInts.push(3);
-  testValueViaComparison(queueOfInts, "[1, 2, 3]"); // FIFO order
-}
-
-TEST_F(ContainerPrintTest, PriorityQueueTest) {
-  std::priority_queue<int> priorityQueueOfInts;
-  priorityQueueOfInts.push(3);
-  priorityQueueOfInts.push(1);
-  priorityQueueOfInts.push(2);
-  testValueViaComparison(priorityQueueOfInts,
-                         "[3, 2, 1]"); // Output based on internal max-heap
-}
-
-TEST_F(ContainerPrintTest, HandlesArray) {
-  constexpr std::array<int, 3> arrayOfInts = {1, 2, 3};
-  testValueViaComparison(arrayOfInts, "[1, 2, 3]");
-}
-
-TEST_F(ContainerPrintTest, HandlesForwardList) {
-  const std::forward_list<int> forwardListOfInts = {1, 2, 3};
-  testValueViaComparison(forwardListOfInts, "[1, 2, 3]");
-}
-
-TEST_F(ContainerPrintTest, HandlesMultiset) {
-  const std::multiset<int> multisetOfInts = {3, 2, 1, 2};
-  testValueViaComparison(multisetOfInts,
-                         "[1, 2, 2, 3]"); // Multiset elements are sorted
-}
-
-TEST_F(ContainerPrintTest, HandlesMultimap) {
-  const std::multimap<std::string, int> multimapStringToInt = {
-      {"one", 1}, {"one", 2}, {"two", 2}};
-  testValueViaComparison(multimapStringToInt, "[(one, 1), (one, 2), (two, 2)]");
-}
-
-TEST_F(ContainerPrintTest, HandlesSpan) {
-  std::vector<int> vectorOfInts = {1, 2, 3, 4};
-  const std::span<int> spanOnVector(
-      vectorOfInts.begin(), vectorOfInts.end()); // Create a span from a vector
-  testValueViaComparison(spanOnVector, "[1, 2, 3, 4]");
-}
-
-TEST_F(ContainerPrintTest, HandlesStaticArray) {
-  constexpr int staticArray[] = {1, 2, 3, 4, 5};
-  testValueViaComparison(staticArray, "[1, 2, 3, 4, 5]");
-}
-
-TEST_F(NestedContainerPrintTest, HandlesListOfQueuesOfPoints) {
-  std::list<std::queue<Point>> listOfQueues = {std::queue<Point>()};
-  listOfQueues.front().push(Point(1, 1));
-  listOfQueues.front().push(Point(2, 2));
-  listOfQueues.front().push(Point(3, 3));
-  testValueViaComparison(listOfQueues,
-                         "[[Point(1, 1), Point(2, 2), Point(3, 3)]]");
-}
-
-TEST_F(NestedContainerPrintTest, HandlesNestedVectors) {
-  const std::vector<std::vector<int>> nestedVector = {{1, 2}, {3, 4, 5}};
-  testValueViaComparison(nestedVector, "[[1, 2], [3, 4, 5]]");
-}
-
-TEST_F(NestedContainerPrintTest, HandlesMapOfVectorOfPoints) {
-  const std::map<std::string, std::vector<Point>> mapOfVectors = {
-      {"first", {Point(1, 2)}}, {"second", {Point(3, 4), Point(5, 6)}}};
-  testValueViaComparison(
-      mapOfVectors,
-      "[(first, [Point(1, 2)]), (second, [Point(3, 4), Point(5, 6)])]");
-}
-
-TEST_F(NestedContainerPrintTest, HandlesVectorOfMaps) {
-  const std::vector<std::map<std::string, int>> vectorOfMaps = {
-      {{"one", 1}, {"two", 2}}, {{"three", 3}, {"four", 4}}};
-  // word "three" is lexicographically smaller than "four"
-  testValueViaComparison(vectorOfMaps,
-                         "[[(one, 1), (two, 2)], [(four, 4), (three, 3)]]");
-}
-
-TEST_F(NestedContainerPrintTest, HandlesComplexNestedStructures) {
-  const std::vector<std::map<std::string, std::list<std::set<int>>>>
-      complexNested = {{{"first", {{1, 2}, {3}}}, {"second", {{4}}}}};
-  testValueViaComparison(complexNested,
-                         "[[(first, [[1, 2], [3]]), (second, [[4]])]]");
-}
-
-TEST_F(EgdeCasesPrintTest, HandleEmptyContainer) {
-  const std::vector<int> emptyVector{};
-  testValueViaComparison(emptyVector, "[]");
-}
-
-TEST_F(SmartPointerPrintTest, HandlesSharedPtr) {
-  const auto sharedPointer = std::make_shared<int>(10);
-  testValueViaComparison(sharedPointer, "10");
-}
-
-TEST_F(SmartPointerPrintTest, HandlesWeakPtr) {
-  auto sharedPointer = std::make_shared<int>(20);
-  std::weak_ptr<int> weakPointer = sharedPointer;
-  testValueViaComparison(weakPointer, "20");
-
-  sharedPointer.reset(); // Reset shared_ptr to make the weak_ptr expire
-  testValueViaComparison(weakPointer,
-                         "expired"); // Test after the weak pointer has expired
-}
-
-TEST_F(SmartPointerPrintTest, HandlesUniquePtr) {
-  const auto uniquePointer = std::make_unique<int>(30);
-  testValueViaComparison(uniquePointer, "30");
-}
-
-TEST_F(OptionalPrintTest, HandlesOptional) {
-  std::optional<int> optionalInt{40};
-  testValueViaComparison(optionalInt, "Optional(40)");
-  optionalInt.reset();
-  testValueViaComparison(optionalInt, "nullopt");
-}
-
-TEST_F(VariantPrintTest, HandlesVariant) {
-  std::variant<int, std::string> variantIntOrString = 10;
-  testValueViaComparison(variantIntOrString, "Variant(10)");
-  variantIntOrString = "Hello";
-  testValueViaComparison(variantIntOrString, "Variant(Hello)");
-}
-
-TEST_F(ErrorHandlingPrintTest, HandlesErrorCode) {
-  const auto errorCodeValue =
-      std::make_error_code(std::errc::function_not_supported).value();
-  const std::error_code errorCode =
-      make_error_code(std::errc::function_not_supported);
-  testValueViaComparison(
-      errorCode, "ErrorCode(" + std::to_string(errorCodeValue) + ", generic)");
-}
-
-TEST_F(ErrorHandlingPrintTest, HandlesExceptionPtr) {
-  try {
-    throw std::runtime_error("test error");
-  } catch (...) {
-    const std::exception_ptr exceptionPointer = std::current_exception();
-    testValueViaComparison(exceptionPointer, "ExceptionPtr(\"test error\")");
-  }
-}
-
-TEST_F(FileSystemPrintTest, HandlesPath) {
-  const std::filesystem::path filePath = "/path/to/some/file.txt";
-  testValueViaComparison(filePath, "Path(\"/path/to/some/file.txt\")");
-}
-
-TEST_F(FileSystemPrintTest, HandlesDirectoryIterator) {
-  // Setup a temporary directory and files within
-  std::filesystem::path directory =
-      std::filesystem::temp_directory_path() / "test_dir";
-  std::filesystem::create_directory(directory);
-
-  std::ofstream(directory / "file1.txt");
-  std::ofstream(directory / "file2.txt");
-
-  std::filesystem::directory_iterator begin(directory);
-
-  testValueViaRegex(
-      begin,
-      R"(Directory\["file1.txt", "file2.txt"\]|Directory\["file2.txt", "file1.txt"\])");
-
-  // Cleanup
-  std::filesystem::remove_all(directory);
-}
-
-TEST_F(UnsupportedLoggingTest, TestLoggingUnsupportedType) {
-  std::ostringstream oss;
-  class UnsupportedClass {};
-  const auto x = UnsupportedClass();
-
-  ASSERT_THROW({ printElement(oss, x); }, std::runtime_error);
-}
-
-} // namespace low_level_log_implementation
-
-namespace rnexecutorch {
-
-namespace high_level_log_implementation {
-
-class BufferTest : public ::testing::Test {
-protected:
-  // Helper to validate the final output
-  void validateBuffer(const std::string &result, const std::string &expected,
-                      std::size_t expectedSize) {
-    EXPECT_EQ(result, expected);
-    EXPECT_EQ(result.size(), expectedSize);
-    if (result.size() > expected.size()) {
-      EXPECT_EQ(result.substr(expected.size()), "...");
-    }
-  }
-};
-
-TEST_F(BufferTest, MessageShorterThanLimit) {
-  constexpr std::size_t smallLogLimit = 20;
-  const std::string message = "Short message";
-  auto result = getBuffer(message, smallLogLimit);
-  validateBuffer(result, message, message.size());
-}
-
-TEST_F(BufferTest, MessageExactlyAtLimit) {
-  // Creating a string with 1024 'a' characters
-  constexpr std::size_t defaultLogLimit = 1024;
-  const std::string message(defaultLogLimit, 'a');
-  auto result = getBuffer(message, defaultLogLimit);
-  validateBuffer(result, message, message.size());
-}
-
-TEST_F(BufferTest, MessageLongerThanLimit) {
-  constexpr std::size_t defaultLogLimit = 1024;
-  constexpr std::size_t sizeAboveLimit = 1050;
-  // Creating a string longer than the limit
-  const std::string message(sizeAboveLimit, 'a');
-  const auto expected = std::string(defaultLogLimit, 'a') + "...";
-  const auto result = getBuffer(message, defaultLogLimit);
-  validateBuffer(result, expected, expected.size());
-}
-
-} // namespace high_level_log_implementation
-
-class LoggingTest : public ::testing::Test {
-protected:
-  template <typename T>
-  void testLoggingDoesNotChangeContainer(const T &original) {
-    const auto copy = original; // Make a copy of the container
-    log(LOG_LEVEL::Info, original);
-    ASSERT_TRUE(check_if_same_content(original, copy))
-        << "Logging modified the content of the container.";
-  }
-
-private:
-  // == op for smart pointers compare addresses, check content maunally
-  template <typename T>
-  bool check_if_same_content(const std::shared_ptr<T> &a,
-                             const std::shared_ptr<T> &b) const noexcept {
-    if (!a || !b) {
-      return a == b;
-    }
-    return *a == *b;
-  }
-
-  template <typename T>
-  bool check_if_same_content(const T &original, const T &after) const noexcept {
-    // Requires that T has an equality operator (operator==)
-    return original == after;
-  }
-};
-
-TEST_F(LoggingTest, LoggingDoesNotChangeSharedPtr) {
-  const auto original = std::make_shared<int>(42);
-  testLoggingDoesNotChangeContainer(original);
-}
-
-TEST_F(LoggingTest, LoggingDoesNotChangeQueue) {
-  std::queue<int> original;
-  original.push(1);
-  original.push(2);
-  original.push(3);
-  testLoggingDoesNotChangeContainer(original);
-}
-
-TEST_F(LoggingTest, LoggingDoesNotChangeVector) {
-  const std::vector<int> original = {1, 2, 3, 4, 5};
-  testLoggingDoesNotChangeContainer(original);
-}
-
-TEST(LogFunctionTest, LoggingBasic) {
-  EXPECT_NO_THROW(log(LOG_LEVEL::Debug, "Test123"));
-}
-
-TEST(LogFunctionTest, LoggingWithNonDefaultLogSize) {
-  constexpr std::size_t sizeBiggerThanDefault = 2048;
-  const auto testString = std::string(sizeBiggerThanDefault, 'a');
-  EXPECT_NO_THROW(log<sizeBiggerThanDefault>(LOG_LEVEL::Info, testString));
-}
-
-TEST(LogFunctionTest, LoggingMoreThanOneElement) {
-  constexpr auto testStringLiteral = "Test123";
-  const auto testVector = std::vector<int>{1, 2, 3, 4};
-  const auto testPair = std::pair<int, double>(1, 2.0);
-  EXPECT_NO_THROW(
-      log(LOG_LEVEL::Debug, testStringLiteral, testVector, testPair));
-}
-
-TEST(MovingSequencable, MovingSequencableTest) {
-  std::priority_queue<int> q;
-  q.push(1);
-  q.push(2);
-  q.push(3);
-
-  log(LOG_LEVEL::Debug, q);
-  ASSERT_EQ(q.size(), 3);
-  const auto &cq = q;
-  log(LOG_LEVEL::Debug, cq);
-  ASSERT_EQ(cq.size(), 3);
-  log(LOG_LEVEL::Debug, std::move(q));
-  ASSERT_EQ(q.size(), 0);
-}
-
-} // namespace rnexecutorch
-
-int main(int argc, char **argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/unit/NumericalTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/unit/NumericalTest.cpp
deleted file mode 100644
index fa7f8cfddb..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/unit/NumericalTest.cpp
+++ /dev/null
@@ -1,107 +0,0 @@
-#include "../data_processing/Numerical.h"
-#include <gtest/gtest.h>
-#include <limits>
-#include <rnexecutorch/Error.h>
-#include <span>
-#include <vector>
-
-namespace rnexecutorch::numerical {
-
-// Helper function to check if two float vectors are approximately equal
-void expect_vectors_eq(const std::vector<float> &vector1,
-                       const std::vector<float> &vector2,
-                       float atol = 1.0e-6F) {
-  ASSERT_EQ(vector1.size(), vector2.size());
-  for (size_t i = 0; i < vector1.size(); i++) {
-    EXPECT_NEAR(vector1[i], vector2[i], atol);
-  }
-}
-
-TEST(SoftmaxTests, SoftmaxBasic) {
-  std::vector<float> input = {1.0F, 2.0F, 3.0F};
-  softmax(input);
-  const std::vector<float> expected = {0.09003057F, 0.24472847F, 0.66524095F};
-  expect_vectors_eq(input, expected);
-}
-
-TEST(SoftmaxTests, SoftmaxWithBigValues) {
-  std::vector<float> input = {100000.0F, 100000.0F, 100000.0F};
-  softmax(input);
-  const std::vector<float> expected = {0.3333333F, 0.3333333F, 0.3333333F};
-  expect_vectors_eq(input, expected);
-}
-
-TEST(SoftmaxTests, SoftmaxOfEmptyVector) {
-  std::vector<float> emptyVector{};
-  EXPECT_NO_THROW(softmax(emptyVector));
-}
-
-TEST(NormalizeTests, NormalizeBasic) {
-  std::vector<float> input = {1.0F, 2.0F, 3.0F};
-  normalize(input);
-  const auto normOfInput = std::sqrtf(14.0F);
-  const std::vector<float> expected = {1.0F / normOfInput, 2.0F / normOfInput,
-                                       3.0F / normOfInput};
-  expect_vectors_eq(input, expected);
-}
-
-TEST(NormalizeTests, NormalizationOfExtremelySmallValues) {
-  constexpr auto epsilon = std::numeric_limits<float>::epsilon();
-  std::vector<float> input(3, epsilon);
-  const auto normOfInput = std::sqrtf(3.0F);
-  const std::vector<float> expected(3, 1.0F / normOfInput);
-  normalize(input);
-  expect_vectors_eq(input, expected);
-}
-
-TEST(NormalizeTests, NormalizationOfZeroVector) {
-  std::vector<float> zeroVector(3, 0.0F);
-  EXPECT_NO_THROW(normalize(zeroVector));
-}
-
-TEST(NormalizeTests, NormalizationOfEmptyVector) {
-  std::vector<float> emptyVector{};
-  EXPECT_NO_THROW(normalize(emptyVector));
-}
-
-TEST(MeanPoolingTests, MeanPoolingBasic) {
-  const std::vector<float> modelOutputVec = {1.0F, 2.0F, 3.0F,
-                                             4.0F, 5.0F, 6.0F};
-  const std::vector<int64_t> attnMaskVec = {1, 1, 0};
-
-  std::span<const float> modelOutput(modelOutputVec);
-  std::span<const int64_t> attnMask(attnMaskVec);
-
-  const auto result = meanPooling(modelOutput, attnMask);
-  const std::vector<float> expected = {2.0F, 3.0F};
-  expect_vectors_eq(result, expected);
-}
-
-TEST(MeanPoolingTests, MeanPoolingWithZeroAttentionMask) {
-  const std::vector<float> modelOutputVec = {1.0F, 2.0F, 3.0F,
-                                             4.0F, 5.0F, 6.0F};
-  const std::vector<int64_t> attnMaskVec = {0, 0, 0};
-
-  std::span<const float> modelOutput(modelOutputVec);
-  std::span<const int64_t> attnMask(attnMaskVec);
-
-  const auto result = meanPooling(modelOutput, attnMask);
-  const std::vector<float> expected = {0.0F, 0.0F};
-  expect_vectors_eq(result, expected);
-}
-
-TEST(MeanPoolingTests, InvalidDimensionSize) {
-  const std::vector<float> modelOutput = {1.0F, 2.0F, 3.0F, 4.0F};
-  const std::vector<int64_t> attnMask = {1, 1, 1};
-
-  EXPECT_THROW({ meanPooling(modelOutput, attnMask); }, RnExecutorchError);
-}
-
-TEST(MeanPoolingTests, EmptyAttentionMask) {
-  const std::vector<float> modelOutput = {1.0F, 2.0F, 3.0F, 4.0F};
-  const std::vector<int64_t> attnMask = {};
-
-  EXPECT_THROW({ meanPooling(modelOutput, attnMask); }, RnExecutorchError);
-}
-
-} // namespace rnexecutorch::numerical
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/unit/RunnerTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/unit/RunnerTest.cpp
deleted file mode 100644
index 77d0d4ae8d..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/unit/RunnerTest.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-#include "../integration/stubs/StubRunner.h"
-#include <gtest/gtest.h>
-#include <runner/irunner.h>
-#include <runner/multimodal_input.h>
-
-using namespace executorch::extension::llm;
-
-// ============================================================================
-// resolve_max_new_tokens tests
-// ============================================================================
-
-class ResolveMaxNewTokensTest : public ::testing::Test {
-protected:
-  StubRunner runner{nullptr, "dummy"};
-};
-
-TEST_F(ResolveMaxNewTokensTest, BothMinusOne_UsesContextMinusPrompt) {
-  EXPECT_EQ(runner.resolve_max(10, -1, 128, -1), 118);
-}
-
-TEST_F(ResolveMaxNewTokensTest, OnlySeqLenMinusOne_CapsAtMaxNew) {
-  EXPECT_EQ(runner.resolve_max(10, -1, 128, 50), 50);
-  EXPECT_EQ(runner.resolve_max(10, -1, 128, 200), 118);
-}
-
-TEST_F(ResolveMaxNewTokensTest, OnlyMaxNewMinusOne_CapsAtSeqLen) {
-  EXPECT_EQ(runner.resolve_max(10, 64, 128, -1), 54);
-  EXPECT_EQ(runner.resolve_max(10, 200, 128, -1), 118);
-}
-
-TEST_F(ResolveMaxNewTokensTest, NeitherMinusOne_TakesSmallest) {
-  EXPECT_EQ(runner.resolve_max(10, 64, 128, 30), 30);
-  EXPECT_EQ(runner.resolve_max(10, 64, 128, 100), 54);
-}
-
-TEST_F(ResolveMaxNewTokensTest, ClampedToZeroWhenPromptExceedsContext) {
-  EXPECT_EQ(runner.resolve_max(200, -1, 128, -1), 0);
-  EXPECT_EQ(runner.resolve_max(200, 64, 128, -1), 0);
-}
-
-// ============================================================================
-// MultimodalInput edge cases
-// ============================================================================
-
-TEST(MultimodalInputTest, GetTextOnImageThrows) {
-  auto input = make_image_input("/some/path.jpg");
-  EXPECT_THROW(input.get_text(), std::bad_variant_access);
-}
-
-TEST(MultimodalInputTest, GetImagePathOnTextThrows) {
-  MultimodalInput input(std::string("hello"));
-  EXPECT_THROW(input.get_image_path(), std::bad_variant_access);
-}
-
-TEST(MultimodalInputTest, EmptyStringIsStillText) {
-  MultimodalInput input(std::string(""));
-  EXPECT_TRUE(input.is_text());
-  EXPECT_EQ(input.get_text(), "");
-}
-
-// ============================================================================
-// BaseLLMRunner via StubRunner
-// ============================================================================
-
-TEST(BaseLLMRunnerTest, SetTemperatureUpdatesConfig) {
-  StubRunner runner(nullptr, "dummy");
-  runner.set_temperature(0.42f);
-  EXPECT_FLOAT_EQ(runner.config_.temperature, 0.42f);
-}
-
-TEST(BaseLLMRunnerTest, SetToppUpdatesConfig) {
-  StubRunner runner(nullptr, "dummy");
-  runner.set_topp(0.7f);
-  EXPECT_FLOAT_EQ(runner.config_.topp, 0.7f);
-}
-
-TEST(BaseLLMRunnerTest, ResetZerosPosAndStats) {
-  StubRunner runner(nullptr, "dummy");
-  runner.pos_ = 99;
-  runner.stats_.num_generated_tokens = 5;
-  runner.reset();
-  EXPECT_EQ(runner.pos_, 0);
-  EXPECT_EQ(runner.stats_.num_generated_tokens, 0);
-}
-
-TEST(BaseLLMRunnerTest, GenerateEmptyStringReturnsError) {
-  StubRunner runner(nullptr, "dummy");
-  auto err = runner.generate("", {}, {}, {});
-  EXPECT_NE(err, ::executorch::runtime::Error::Ok);
-}
-
-TEST(BaseLLMRunnerTest, SetMinPUpdatesConfig) {
-  StubRunner runner(nullptr, "dummy");
-  runner.set_min_p(0.15f);
-  EXPECT_FLOAT_EQ(runner.config_.min_p, 0.15f);
-}
-
-TEST(BaseLLMRunnerTest, SetRepetitionPenaltyUpdatesConfig) {
-  StubRunner runner(nullptr, "dummy");
-  runner.set_repetition_penalty(1.05f);
-  EXPECT_FLOAT_EQ(runner.config_.repetition_penalty, 1.05f);
-}
diff --git a/packages/react-native-executorch/common/rnexecutorch/tests/unit/SamplerTest.cpp b/packages/react-native-executorch/common/rnexecutorch/tests/unit/SamplerTest.cpp
deleted file mode 100644
index bf7a1d02d6..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/tests/unit/SamplerTest.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#include <gtest/gtest.h>
-#include <runner/irunner.h>
-#include <runner/sampler.h>
-#include <vector>
-
-using namespace executorch::extension::llm;
-
-// Helper: run sampler N times, count how often each index is picked.
-template <typename T>
-std::vector<int> sampleMany(Sampler &s, std::vector<T> logits,
-                            const std::vector<uint64_t> &recent, int n) {
-  std::vector<int> counts(logits.size(), 0);
-  for (int i = 0; i < n; ++i) {
-    std::vector<T> copy = logits;
-    counts[s.sample(copy.data(), recent)]++;
-  }
-  return counts;
-}
-
-// 1. Repetition penalty on positive logit: token 0 should be sampled less.
-TEST(SamplerTest, RepetitionPenaltyReducesPositiveLogit) {
-  Sampler s(2, {.temperature = 1.0f, .topp = 1.0f, .repetition_penalty = 1.3f});
-  std::vector<float> logits = {1.0f, 1.0f};
-  std::vector<uint64_t> recent = {0};
-  auto counts = sampleMany(s, logits, recent, 2000);
-  EXPECT_LT(counts[0], 1200);
-}
-
-// 2. Repetition penalty on negative logit: multiplying a negative logit by the
-// penalty makes it more negative, so the penalised token is sampled strictly
-// less often than without the penalty. Compare against an unpenalised baseline
-// rather than a fixed threshold: with penalty 1.5 the penalised logit is
-// -1.0 * 1.5 = -1.5, giving P(token 1) = e^-1.5 / (1 + e^-1.5) ≈ 0.18 (~365 of
-// 2000) versus the baseline e^-1 / (1 + e^-1) ≈ 0.27 (~538). A static "< 200"
-// bound would be mathematically unreachable at this penalty.
-TEST(SamplerTest, RepetitionPenaltyMultipliesNegativeLogit) {
-  Sampler baseline(
-      2, {.temperature = 1.0f, .topp = 1.0f, .repetition_penalty = 1.0f});
-  Sampler penalised(
-      2, {.temperature = 1.0f, .topp = 1.0f, .repetition_penalty = 1.5f});
-  std::vector<float> logits_b = {0.0f, -1.0f};
-  std::vector<float> logits_p = {0.0f, -1.0f};
-  std::vector<uint64_t> recent = {1};
-  auto cb = sampleMany(baseline, logits_b, recent, 2000);
-  auto cp = sampleMany(penalised, logits_p, recent, 2000);
-  EXPECT_LT(cp[1], cb[1]);
-}
-
-// 3. No recent tokens — penalty has no effect.
-TEST(SamplerTest, RepetitionPenaltyNoRecentTokensHasNoEffect) {
-  Sampler baseline(
-      2, {.temperature = 1.0f, .topp = 1.0f, .repetition_penalty = 1.0f});
-  Sampler penalised(
-      2, {.temperature = 1.0f, .topp = 1.0f, .repetition_penalty = 2.0f});
-  std::vector<float> logits_b = {1.0f, 1.0f};
-  std::vector<float> logits_p = {1.0f, 1.0f};
-  std::vector<uint64_t> recent = {};
-  auto cb = sampleMany(baseline, logits_b, recent, 2000);
-  auto cp = sampleMany(penalised, logits_p, recent, 2000);
-  EXPECT_NEAR(cb[0], cp[0], 300);
-}
-
-// 4. Min-p truncation: token with very low probability is excluded.
-TEST(SamplerTest, MinPFiltersTailTokens) {
-  Sampler s(3, {.temperature = 1.0f, .topp = 1.0f, .min_p = 0.1f});
-  std::vector<float> logits = {5.0f, -5.0f, -5.0f};
-  std::vector<uint64_t> recent = {};
-  auto counts = sampleMany(s, logits, recent, 1000);
-  EXPECT_EQ(counts[1], 0);
-  EXPECT_EQ(counts[2], 0);
-  EXPECT_EQ(counts[0], 1000);
-}
-
-// 5. Min-p = 0 disables filtering.
-TEST(SamplerTest, MinPZeroDisablesFiltering) {
-  Sampler s(3, {.temperature = 0.0f, .topp = 1.0f});
-  std::vector<float> logits = {1.0f, -1000.0f, -1000.0f};
-  std::vector<uint64_t> recent = {};
-  EXPECT_EQ(s.sample(logits.data(), recent), 0);
-}
-
-// 6. Min-p + top-p stacked.
-TEST(SamplerTest, MinPAndToppStack) {
-  Sampler s(4, {.temperature = 1.0f, .topp = 0.5f, .min_p = 0.2f});
-  std::vector<float> logits = {5.0f, 2.0f, -2.0f, -5.0f};
-  std::vector<uint64_t> recent = {};
-  auto counts = sampleMany(s, logits, recent, 2000);
-  EXPECT_EQ(counts[2], 0);
-  EXPECT_EQ(counts[3], 0);
-}
diff --git a/packages/react-native-executorch/common/rnexecutorch/threads/GlobalThreadPool.h b/packages/react-native-executorch/common/rnexecutorch/threads/GlobalThreadPool.h
deleted file mode 100644
index 50025eeeb7..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/threads/GlobalThreadPool.h
+++ /dev/null
@@ -1,84 +0,0 @@
-// GlobalThreadPool.h
-#pragma once
-
-#include <executorch/extension/threadpool/cpuinfo_utils.h>
-#include <memory>
-#include <mutex>
-#include <opencv2/opencv.hpp>
-#include <optional>
-#include <rnexecutorch/Log.h>
-#include <rnexecutorch/threads/HighPerformanceThreadPool.h>
-
-namespace rnexecutorch::threads {
-
-class GlobalThreadPool {
-public:
-  GlobalThreadPool() = delete;
-  GlobalThreadPool(const GlobalThreadPool &) = delete;
-  GlobalThreadPool &operator=(const GlobalThreadPool &) = delete;
-  GlobalThreadPool(GlobalThreadPool &&) = delete;
-  GlobalThreadPool &operator=(GlobalThreadPool &&) = delete;
-
-  static HighPerformanceThreadPool &get() {
-    if (!instance) {
-      initialize();
-    }
-    return *instance;
-  }
-
-  static void initialize(std::optional<uint32_t> numThreads = std::nullopt,
-                         ThreadConfig config = {}) {
-    std::call_once(initFlag, [&numThreads, config]() {
-      if (!numThreads) {
-        numThreads =
-            ::executorch::extension::cpuinfo::get_num_performant_cores();
-      }
-
-      numThreads = std::max(numThreads.value(), 2u);
-      log(rnexecutorch::LOG_LEVEL::Info, "Initializing global thread pool with",
-          numThreads, "threads");
-      instance = std::make_unique<HighPerformanceThreadPool>(numThreads.value(),
-                                                             config);
-      // Disable OpenCV's internal threading to prevent it from overriding our
-      // thread pool configuration, which would cause degraded performance
-      cv::setNumThreads(0);
-    });
-  }
-
-  // Convenience methods that mirror std::thread interface
-  template <typename Func, typename... Args>
-  static auto async(Func &&func, Args &&...args) {
-    return get().submit(std::forward<Func>(func), std::forward<Args>(args)...);
-  }
-
-  template <typename Func, typename... Args>
-  static auto async_high_priority(Func &&func, Args &&...args) {
-    return get().submitWithPriority(Priority::HIGH, std::forward<Func>(func),
-                                    std::forward<Args>(args)...);
-  }
-
-  // Fire and forget (like std::thread{}.detach())
-  template <typename Func, typename... Args>
-  static void detach(Func &&func, Args &&...args) {
-    get().submitDetached(std::forward<Func>(func), std::forward<Args>(args)...);
-  }
-
-  // Execute and wait (like std::thread{}.join())
-  template <typename Func, typename... Args>
-  static auto execute(Func &&func, Args &&...args) {
-    return get().execute(std::forward<Func>(func), std::forward<Args>(args)...);
-  }
-
-  static void shutdown() {
-    if (instance) {
-      instance->shutdown();
-      instance.reset();
-    }
-  }
-
-private:
-  inline static std::unique_ptr<HighPerformanceThreadPool> instance;
-  inline static std::once_flag initFlag;
-};
-
-} // namespace rnexecutorch::threads
diff --git a/packages/react-native-executorch/common/rnexecutorch/threads/HighPerformanceThreadPool.h b/packages/react-native-executorch/common/rnexecutorch/threads/HighPerformanceThreadPool.h
deleted file mode 100644
index 67610ec958..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/threads/HighPerformanceThreadPool.h
+++ /dev/null
@@ -1,366 +0,0 @@
-// HighPerformanceThreadPool.h
-#pragma once
-
-#include <algorithm>
-#include <atomic>
-#include <chrono>
-#include <condition_variable>
-#include <fstream>
-#include <functional>
-#include <future>
-#include <memory>
-#include <mutex>
-#include <pthread.h>
-#include <queue>
-#include <sched.h>
-#include <sys/resource.h>
-#include <thread>
-#include <unistd.h>
-#include <vector>
-
-#include <executorch/extension/threadpool/cpuinfo_utils.h>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-#include <rnexecutorch/Log.h>
-
-#ifdef __APPLE__
-#include <sys/syscall.h>
-#endif
-
-#ifdef __ANDROID__
-#include <sys/types.h>
-#endif
-
-namespace rnexecutorch::threads {
-
-enum class Priority { LOW, NORMAL, HIGH, REALTIME };
-
-struct ThreadConfig {
-  bool pinToPerformanceCores{true};
-  std::string namePrefix{"RN_ET_Worker"};
-};
-
-class HighPerformanceThreadPool {
-public:
-  explicit HighPerformanceThreadPool(size_t numThreads = 1,
-                                     ThreadConfig cfg = ThreadConfig())
-      : config(std::move(cfg)) {
-
-#ifdef __ANDROID__
-    detectCPUTopology();
-    numThreads = std::max(std::min(numThreads, performanceCores.size()), 2lu);
-#endif
-
-    for (size_t i = 0; i < numThreads; i++) {
-      workers.emplace_back(&HighPerformanceThreadPool::workerThread, this, i);
-    }
-
-    log(LOG_LEVEL::Debug, "Thread pool initialized with", numThreads,
-        "workers.");
-  }
-
-  ~HighPerformanceThreadPool() { shutdown(); }
-
-  // Submit a task and get a future for the result
-  template <typename Func, typename... Args>
-  auto submit(Func &&func, Args &&...args)
-      -> std::future<decltype(func(args...))> {
-    return submitWithPriority(Priority::NORMAL, std::forward<Func>(func),
-                              std::forward<Args>(args)...);
-  }
-
-  // Submit a task with specific priority
-  template <typename Func, typename... Args>
-  auto submitWithPriority(Priority priority, Func &&func, Args &&...args)
-      -> std::future<decltype(func(args...))> {
-
-    using ReturnType = decltype(func(args...));
-
-    // Create a packaged task
-    auto boundFunc =
-        std::bind(std::forward<Func>(func), std::forward<Args>(args)...);
-    auto task = std::make_unique<Task<decltype(boundFunc), ReturnType>>(
-        std::move(boundFunc));
-    auto future = task->getFuture();
-
-    // Add to queue
-    {
-      std::scoped_lock lock(queueMutex);
-
-      if (!running) {
-        throw RnExecutorchError(RnExecutorchErrorCode::ThreadPoolError,
-                                "Thread pool is shutting down");
-      }
-
-      WorkItem item(std::move(task), priority,
-                    std::chrono::steady_clock::now());
-
-      taskQueue.push(std::move(item));
-    }
-
-    condition.notify_one();
-    return future;
-  }
-
-  // Execute a task and wait for result
-  template <typename Func, typename... Args>
-  auto execute(Func &&func, Args &&...args) -> decltype(func(args...)) {
-    auto future = submit(std::forward<Func>(func), std::forward<Args>(args)...);
-    return future.get();
-  }
-
-  // Fire and forget task
-  template <typename Func, typename... Args>
-  void submitDetached(Func &&func, Args &&...args) {
-    submit(std::forward<Func>(func), std::forward<Args>(args)...);
-    // Future is destroyed, task still runs
-  }
-
-  void shutdown() {
-    if (!running.exchange(false)) {
-      return;
-    }
-
-    condition.notify_all();
-
-    for (auto &worker : workers) {
-      if (worker.joinable()) {
-        worker.join();
-      }
-    }
-  }
-
-private:
-  // Task wrapper that can hold any callable
-  class ITask {
-  public:
-    virtual ~ITask() = default;
-    virtual void execute() = 0;
-  };
-
-  template <typename Func, typename Result> class Task : public ITask {
-  public:
-    Task(Func &&f) : func(std::forward<Func>(f)) {}
-
-    void execute() override {
-      try {
-        if constexpr (std::is_void_v<Result>) {
-          func();
-          promise.set_value();
-        } else {
-          promise.set_value(func());
-        }
-      } catch (...) {
-        promise.set_exception(std::current_exception());
-      }
-    }
-
-    std::future<Result> getFuture() { return promise.get_future(); }
-
-  private:
-    Func func;
-    std::promise<Result> promise;
-  };
-
-  class WorkItem {
-  public:
-    WorkItem() = default;
-    WorkItem(std::unique_ptr<ITask> task, Priority priority,
-             std::chrono::steady_clock::time_point enqueueTime)
-        : task(std::move(task)), priority(priority), enqueueTime(enqueueTime) {}
-
-    std::unique_ptr<ITask> task;
-
-    bool operator<(const WorkItem &other) const {
-      return priority != other.priority ? priority < other.priority
-                                        : enqueueTime > other.enqueueTime;
-    }
-
-  private:
-    Priority priority;
-    std::chrono::steady_clock::time_point enqueueTime;
-  };
-
-  // Thread pool state
-  std::vector<std::thread> workers;
-  std::priority_queue<WorkItem> taskQueue;
-  std::mutex queueMutex;
-  std::condition_variable condition;
-  std::atomic<bool> running{true};
-  std::atomic<size_t> activeWorkers{0};
-  std::atomic<size_t> totalTasksProcessed{0};
-
-#ifdef __ANDROID__
-  // Performance cores
-  std::vector<int32_t> performanceCores;
-  std::vector<int32_t> efficiencyCores;
-#endif
-
-  // Configuration
-  ThreadConfig config;
-
-  void detectCPUTopology() {
-#ifdef __ANDROID__
-    struct CoreInfo {
-      int32_t id;
-      int64_t maxFreq;
-    };
-
-    std::vector<CoreInfo> cores;
-    const auto numOfCores = std::thread::hardware_concurrency();
-
-    for (int32_t i = 0; std::cmp_less(i, numOfCores); ++i) {
-      std::string path = "/sys/devices/system/cpu/cpu" + std::to_string(i) +
-                         "/cpufreq/cpuinfo_max_freq";
-      std::ifstream file(path);
-      if (!file.good()) {
-        break;
-      }
-
-      CoreInfo info;
-      info.id = i;
-      file >> info.maxFreq;
-      cores.push_back(info);
-    }
-
-    if (cores.empty()) {
-      log(LOG_LEVEL::Debug, "Could not detect CPU topology");
-      return;
-    }
-
-    // Sort by frequency
-    std::ranges::sort(cores, [](const CoreInfo &a, const CoreInfo &b) {
-      return a.maxFreq > b.maxFreq;
-    });
-
-    // Classify cores
-    const auto numOfPerfCores =
-        ::executorch::extension::cpuinfo::get_num_performant_cores();
-
-    constexpr float kKiloToGigaRatio = 1e6;
-    for (int32_t i = 0; i < cores.size(); ++i) {
-      if (i < numOfPerfCores) {
-        performanceCores.push_back(cores[i].id);
-        log(LOG_LEVEL::Debug, "Performance core:", cores[i].id, "(",
-            cores[i].maxFreq / kKiloToGigaRatio, "GHz)");
-      } else {
-        efficiencyCores.push_back(cores[i].id);
-        log(LOG_LEVEL::Debug, "Efficiency core:", cores[i].id, "(",
-            cores[i].maxFreq / kKiloToGigaRatio, "GHz)");
-      }
-    }
-#endif
-  }
-
-#ifdef __ANDROID__
-  inline uint64_t getCurrentThreadId() { return gettid(); }
-#endif
-
-  inline void setCurrentThreadName(const std::string &name) {
-#ifdef __ANDROID__
-    pthread_setname_np(pthread_self(), name.c_str());
-#elif defined(__APPLE__)
-    pthread_setname_np(name.c_str());
-#endif
-  }
-
-  void configureThread(uint32_t workerIndex) {
-    std::string threadName = config.namePrefix + std::to_string(workerIndex);
-    setCurrentThreadName(threadName.c_str());
-
-#ifdef __ANDROID__
-    if (config.pinToPerformanceCores && !performanceCores.empty()) {
-      setCPUAffinity();
-    }
-#endif
-
-    setThreadPriority();
-
-    log(LOG_LEVEL::Debug, "Worker", workerIndex,
-        "configured:", threadName.c_str());
-  }
-
-  void setCPUAffinity() {
-    // AFAIK it is not possible on iOS
-#ifdef __ANDROID__
-    if (performanceCores.empty()) {
-      log(LOG_LEVEL::Error, "No cores specified for affinity setting");
-      return;
-    }
-
-    cpu_set_t cpuset;
-    CPU_ZERO(&cpuset);
-
-    for (int32_t core : performanceCores) {
-      CPU_SET(core, &cpuset);
-    }
-
-    pid_t tid = getCurrentThreadId();
-    log(LOG_LEVEL::Debug, "Thread id", tid);
-    if (sched_setaffinity(tid, sizeof(cpuset), &cpuset) == 0) {
-      log(LOG_LEVEL::Debug, "Thread pinned to cores:", performanceCores);
-    } else {
-      log(LOG_LEVEL::Debug, "Failed to set CPU affinity (error:", errno,
-          "). Continuing without affinity.");
-    }
-#endif
-  }
-
-  void setThreadPriority() {
-    // pthread_setschedparam doesn't work on android because permissions reasons
-    // and in general does not provide visible improvements on iOS
-
-    // Set nice value as fallback or additional priority boost
-    constexpr int nice_value = 0;
-    if (setpriority(PRIO_PROCESS, 0, nice_value) != 0) {
-      log(LOG_LEVEL::Debug, "Failed to set nice value");
-    } else {
-      log(LOG_LEVEL::Debug, "Set nice value", nice_value);
-    }
-  }
-
-  void processTask(const WorkItem &item) {
-    activeWorkers++;
-
-    try {
-      item.task->execute();
-    } catch (const std::exception &e) {
-      log(LOG_LEVEL::Error, "Task failed:", e.what());
-      activeWorkers--;
-      throw;
-    }
-
-    activeWorkers--;
-    totalTasksProcessed++;
-  }
-
-  void workerThread(int workerIndex) {
-    configureThread(workerIndex);
-
-    while (running) {
-      WorkItem item;
-
-      {
-        std::unique_lock<std::mutex> lock(queueMutex);
-        condition.wait(lock, [this] { return !taskQueue.empty() || !running; });
-
-        if (!running && taskQueue.empty()) {
-          break;
-        }
-
-        if (!taskQueue.empty()) {
-          item = std::move(const_cast<WorkItem &>(taskQueue.top()));
-          taskQueue.pop();
-        } else {
-          continue;
-        }
-      }
-
-      processTask(item);
-    }
-
-    log(LOG_LEVEL::Debug, "Worker", workerIndex, "shutting down");
-  }
-};
-
-} // namespace rnexecutorch::threads
diff --git a/packages/react-native-executorch/common/rnexecutorch/threads/utils/ThreadUtils.h b/packages/react-native-executorch/common/rnexecutorch/threads/utils/ThreadUtils.h
deleted file mode 100644
index 664480d387..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/threads/utils/ThreadUtils.h
+++ /dev/null
@@ -1,29 +0,0 @@
-#pragma once
-
-#include <executorch/extension/threadpool/cpuinfo_utils.h>
-#include <executorch/extension/threadpool/threadpool.h>
-#include <rnexecutorch/Log.h>
-
-namespace rnexecutorch::threads::utils {
-
-void unsafeSetupThreadPool(uint32_t num_of_cores = 0) {
-  auto num_of_perf_cores =
-      ::executorch::extension::cpuinfo::get_num_performant_cores();
-  log(LOG_LEVEL::Info, "Detected ", num_of_perf_cores, " performant cores");
-  // setting num_of_cores to floor(num_of_perf_cores / 2) + 1) because
-  // depending on cpu arch as when possible we want to leave at least 2
-  // performant cores for other tasks (setting more actually results in drop
-  // of performance). For older devices (i.e. samsung s22) resolves to 3
-  // cores, and for newer ones (like OnePlus 12) resolves to 4, which when
-  // benchmarked gives highest throughput. For iPhones they usually have 2
-  // performance cores
-  auto _num_of_cores = num_of_cores
-                           ? num_of_cores
-                           : static_cast<uint32_t>(num_of_perf_cores / 2) + 1;
-  const auto threadpool = ::executorch::extension::threadpool::get_threadpool();
-  threadpool->_unsafe_reset_threadpool(_num_of_cores);
-  log(LOG_LEVEL::Info, "Configuring xnnpack for",
-      threadpool->get_thread_count(), "threads");
-}
-
-} // namespace rnexecutorch::threads::utils
diff --git a/packages/react-native-executorch/common/rnexecutorch/utils/FrameExtractor.cpp b/packages/react-native-executorch/common/rnexecutorch/utils/FrameExtractor.cpp
deleted file mode 100644
index d14c522184..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/utils/FrameExtractor.cpp
+++ /dev/null
@@ -1,112 +0,0 @@
-#include "FrameExtractor.h"
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-#include <rnexecutorch/Log.h>
-
-#ifdef __APPLE__
-#import <CoreVideo/CoreVideo.h>
-#endif
-
-#if defined(__ANDROID__) && __ANDROID_API__ >= 26
-#include <android/hardware_buffer.h>
-#endif
-
-namespace rnexecutorch::utils {
-
-namespace {
-
-#ifdef __APPLE__
-cv::Mat extractFromCVPixelBuffer(void *pixelBuffer) {
-  CVPixelBufferRef buffer = static_cast<CVPixelBufferRef>(pixelBuffer);
-
-  size_t width = CVPixelBufferGetWidth(buffer);
-  size_t height = CVPixelBufferGetHeight(buffer);
-  size_t bytesPerRow = CVPixelBufferGetBytesPerRow(buffer);
-  OSType pixelFormat = CVPixelBufferGetPixelFormatType(buffer);
-
-  CVPixelBufferLockBaseAddress(buffer, kCVPixelBufferLock_ReadOnly);
-  void *baseAddress = CVPixelBufferGetBaseAddress(buffer);
-
-  cv::Mat mat;
-
-  if (pixelFormat == kCVPixelFormatType_32BGRA) {
-    mat = cv::Mat(static_cast<int>(height), static_cast<int>(width), CV_8UC4,
-                  baseAddress, bytesPerRow);
-  } else if (pixelFormat == kCVPixelFormatType_32RGBA) {
-    mat = cv::Mat(static_cast<int>(height), static_cast<int>(width), CV_8UC4,
-                  baseAddress, bytesPerRow);
-  } else if (pixelFormat == kCVPixelFormatType_24RGB) {
-    mat = cv::Mat(static_cast<int>(height), static_cast<int>(width), CV_8UC3,
-                  baseAddress, bytesPerRow);
-  } else {
-    CVPixelBufferUnlockBaseAddress(buffer, kCVPixelBufferLock_ReadOnly);
-    char errorMessage[100];
-    std::snprintf(errorMessage, sizeof(errorMessage),
-                  "Unsupported CVPixelBuffer format: %u", pixelFormat);
-    throw RnExecutorchError(RnExecutorchErrorCode::PlatformNotSupported,
-                            errorMessage);
-  }
-
-  CVPixelBufferUnlockBaseAddress(buffer, kCVPixelBufferLock_ReadOnly);
-
-  return mat;
-}
-#endif
-
-#ifdef __ANDROID__
-cv::Mat extractFromAHardwareBuffer(void *hardwareBuffer) {
-#if __ANDROID_API__ >= 26
-  AHardwareBuffer *buffer = static_cast<AHardwareBuffer *>(hardwareBuffer);
-
-  AHardwareBuffer_Desc desc;
-  AHardwareBuffer_describe(buffer, &desc);
-
-  void *data = nullptr;
-  int lockResult = AHardwareBuffer_lock(
-      buffer, AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN, -1, nullptr, &data);
-
-  if (lockResult != 0) {
-    throw RnExecutorchError(RnExecutorchErrorCode::UnknownError,
-                            "Failed to lock AHardwareBuffer");
-  }
-
-  cv::Mat mat;
-
-  if (desc.format == AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM) {
-    mat = cv::Mat(desc.height, desc.width, CV_8UC4, data, desc.stride * 4);
-  } else if (desc.format == AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM) {
-    mat = cv::Mat(desc.height, desc.width, CV_8UC4, data, desc.stride * 4);
-  } else if (desc.format == AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM) {
-    mat = cv::Mat(desc.height, desc.width, CV_8UC3, data, desc.stride * 3);
-  } else {
-    AHardwareBuffer_unlock(buffer, nullptr);
-    char errorMessage[100];
-    std::snprintf(errorMessage, sizeof(errorMessage),
-                  "Unsupported AHardwareBuffer format: %u", desc.format);
-    throw RnExecutorchError(RnExecutorchErrorCode::PlatformNotSupported,
-                            errorMessage);
-  }
-
-  AHardwareBuffer_unlock(buffer, nullptr);
-  return mat;
-#else
-  throw RnExecutorchError(RnExecutorchErrorCode::PlatformNotSupported,
-                          "AHardwareBuffer requires Android API 26+");
-#endif // __ANDROID_API__ >= 26
-}
-#endif
-
-} // namespace
-
-cv::Mat extractFromNativeBuffer(uint64_t bufferPtr) {
-#ifdef __APPLE__
-  return extractFromCVPixelBuffer(reinterpret_cast<void *>(bufferPtr));
-#elif defined(__ANDROID__)
-  return extractFromAHardwareBuffer(reinterpret_cast<void *>(bufferPtr));
-#else
-  throw RnExecutorchError(RnExecutorchErrorCode::PlatformNotSupported,
-                          "NativeBuffer not supported on this platform");
-#endif
-}
-
-} // namespace rnexecutorch::utils
diff --git a/packages/react-native-executorch/common/rnexecutorch/utils/FrameExtractor.h b/packages/react-native-executorch/common/rnexecutorch/utils/FrameExtractor.h
deleted file mode 100644
index f5d7c2094d..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/utils/FrameExtractor.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <opencv2/opencv.hpp>
-
-namespace rnexecutorch::utils {
-
-/**
- * @brief Extract cv::Mat from a native platform buffer pointer (zero-copy)
- *
- * Dispatches to the platform-specific implementation:
- * - iOS: CVPixelBufferRef
- * - Android: AHardwareBuffer
- *
- * @param bufferPtr Platform-specific buffer pointer (uint64_t)
- * @return cv::Mat wrapping the buffer data (zero-copy)
- *
- * @throws RnExecutorchError if the platform is unsupported or extraction fails
- *
- * @note The returned cv::Mat does not own the data.
- *       Caller must ensure the buffer remains valid during use.
- */
-cv::Mat extractFromNativeBuffer(uint64_t bufferPtr);
-
-} // namespace rnexecutorch::utils
diff --git a/packages/react-native-executorch/common/rnexecutorch/utils/FrameProcessor.cpp b/packages/react-native-executorch/common/rnexecutorch/utils/FrameProcessor.cpp
deleted file mode 100644
index 48be09801e..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/utils/FrameProcessor.cpp
+++ /dev/null
@@ -1,91 +0,0 @@
-#include "FrameProcessor.h"
-#include "FrameExtractor.h"
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/ErrorCodes.h>
-
-namespace rnexecutorch::utils {
-
-namespace {
-
-bool hasNativeBuffer(jsi::Runtime &runtime, const jsi::Object &frameData) {
-  return frameData.hasProperty(runtime, "nativeBuffer");
-}
-
-} // namespace
-
-cv::Mat extractFrame(jsi::Runtime &runtime, const jsi::Object &frameData) {
-  if (!hasNativeBuffer(runtime, frameData)) {
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidUserInput,
-                            "FrameProcessor: No nativeBuffer found in frame");
-  }
-
-  auto nativeBufferValue = frameData.getProperty(runtime, "nativeBuffer");
-  uint64_t bufferPtr = static_cast<uint64_t>(
-      nativeBufferValue.asBigInt(runtime).asUint64(runtime));
-
-  return extractFromNativeBuffer(bufferPtr);
-}
-
-cv::Mat frameToMat(jsi::Runtime &runtime, const jsi::Value &frameData) {
-  auto frameObj = frameData.asObject(runtime);
-  return extractFrame(runtime, frameObj);
-}
-
-FrameOrientation readFrameOrientation(jsi::Runtime &runtime,
-                                      const jsi::Value &frameData) {
-  auto obj = frameData.asObject(runtime);
-
-  std::string orientStr = "up";
-  if (obj.hasProperty(runtime, "orientation")) {
-    auto val = obj.getProperty(runtime, "orientation");
-    if (val.isString()) {
-      orientStr = val.getString(runtime).utf8(runtime);
-    }
-  }
-
-  bool isMirrored = false;
-  if (obj.hasProperty(runtime, "isMirrored")) {
-    auto val = obj.getProperty(runtime, "isMirrored");
-    if (val.isBool()) {
-      isMirrored = val.getBool();
-    }
-  }
-
-  return {orientationFromString(orientStr), isMirrored};
-}
-
-cv::Mat pixelsToMat(const JSTensorViewIn &pixelData) {
-  if (pixelData.sizes.size() != 3) {
-    char errorMessage[100];
-    std::snprintf(errorMessage, sizeof(errorMessage),
-                  "Invalid pixel data: sizes must have 3 elements "
-                  "[height, width, channels], got %zu",
-                  pixelData.sizes.size());
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidUserInput,
-                            errorMessage);
-  }
-
-  int32_t height = pixelData.sizes[0];
-  int32_t width = pixelData.sizes[1];
-  int32_t channels = pixelData.sizes[2];
-
-  if (channels != 3) {
-    char errorMessage[100];
-    std::snprintf(errorMessage, sizeof(errorMessage),
-                  "Invalid pixel data: expected 3 channels (RGB), got %d",
-                  channels);
-    throw RnExecutorchError(RnExecutorchErrorCode::InvalidUserInput,
-                            errorMessage);
-  }
-
-  if (pixelData.scalarType != executorch::aten::ScalarType::Byte) {
-    throw RnExecutorchError(
-        RnExecutorchErrorCode::InvalidUserInput,
-        "Invalid pixel data: scalarType must be BYTE (Uint8Array)");
-  }
-
-  auto *dataPtr = static_cast<uint8_t *>(pixelData.dataPtr);
-  return cv::Mat(height, width, CV_8UC3, dataPtr);
-}
-
-} // namespace rnexecutorch::utils
diff --git a/packages/react-native-executorch/common/rnexecutorch/utils/FrameProcessor.h b/packages/react-native-executorch/common/rnexecutorch/utils/FrameProcessor.h
deleted file mode 100644
index b44f040d41..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/utils/FrameProcessor.h
+++ /dev/null
@@ -1,52 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-#include <opencv2/opencv.hpp>
-#include <rnexecutorch/host_objects/JSTensorViewIn.h>
-#include <rnexecutorch/utils/FrameTransform.h>
-
-namespace rnexecutorch::utils {
-
-using namespace facebook;
-
-/**
- * @brief Extract cv::Mat from VisionCamera frame data via nativeBuffer
- *
- * Returns an RGB mat (as delivered by the native buffer).
- *
- * @throws RnExecutorchError if nativeBuffer is not present or extraction fails
- * @note The returned cv::Mat does not own the data.
- */
-cv::Mat extractFrame(jsi::Runtime &runtime, const jsi::Object &frameData);
-
-/**
- * @brief Extract a raw RGB cv::Mat from a VisionCamera frameData JSI object.
- *
- * Does not apply any orientation correction — use FrameTransform utilities
- * on the model output to convert coordinates/buffers to screen space.
- * Callers are responsible for any further colour space conversion.
- */
-cv::Mat frameToMat(jsi::Runtime &runtime, const jsi::Value &frameData);
-
-/**
- * @brief Read orientation metadata from a VisionCamera frameData JSI object.
- *
- * Reads orientation and isMirrored from the frameData object.
- * Falls back to "up"/false if fields are absent (e.g. when
- * enablePhysicalBufferRotation is used — transform will be a no-op).
- */
-FrameOrientation readFrameOrientation(jsi::Runtime &runtime,
-                                      const jsi::Value &frameData);
-
-/**
- * @brief Validate a JSTensorViewIn and wrap its data in a RGB cv::Mat.
- *
- * Validates sizes (must be [H, W, 3]), scalar type (Byte), and returns a
- * cv::Mat that wraps the raw pixel buffer without copying.
- * Callers are responsible for any further colour space conversion.
- *
- * @throws RnExecutorchError on invalid input
- */
-cv::Mat pixelsToMat(const JSTensorViewIn &pixelData);
-
-} // namespace rnexecutorch::utils
diff --git a/packages/react-native-executorch/common/rnexecutorch/utils/FrameTransform.cpp b/packages/react-native-executorch/common/rnexecutorch/utils/FrameTransform.cpp
deleted file mode 100644
index e9cf1e9d73..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/utils/FrameTransform.cpp
+++ /dev/null
@@ -1,129 +0,0 @@
-#include "FrameTransform.h"
-
-namespace rnexecutorch::utils {
-
-cv::Mat rotateFrameForModel(const cv::Mat &mat,
-                            const FrameOrientation &orient) {
-  if (!orient.isMirrored && orient.orientation == Orientation::Up) {
-    return mat;
-  }
-
-  cv::Mat result;
-
-  if (orient.isMirrored) {
-    cv::flip(mat, result, 1);
-  } else {
-    result = mat;
-  }
-
-  switch (orient.orientation) {
-  case Orientation::Left:
-    cv::rotate(result, result, cv::ROTATE_90_CLOCKWISE);
-    break;
-  case Orientation::Right:
-#if defined(__APPLE__)
-    cv::rotate(result, result, cv::ROTATE_90_COUNTERCLOCKWISE);
-#else
-    // Android front-cam in upright portrait reports orient=Right with
-    // isMirrored=true; the sensor mount needs CW (same as back-cam Left)
-    // to land upright for the model after the horizontal flip above.
-    cv::rotate(result, result, cv::ROTATE_90_CLOCKWISE);
-#endif
-    break;
-  case Orientation::Down:
-    cv::rotate(result, result, cv::ROTATE_180);
-    break;
-  case Orientation::Up:
-    break;
-  }
-
-  return result;
-}
-
-void inverseRotateBbox(computer_vision::BBox &bbox,
-                       const FrameOrientation &orient, cv::Size rotatedSize) {
-  const float w = static_cast<float>(rotatedSize.width);
-  const float h = static_cast<float>(rotatedSize.height);
-
-  switch (orient.orientation) {
-  case Orientation::Up: {
-    // landscape-left → portrait: nx = h - y, ny = x
-    float nx1 = h - bbox.p2.y, ny1 = bbox.p1.x;
-    float nx2 = h - bbox.p1.y, ny2 = bbox.p2.x;
-    bbox.p1 = {nx1, ny1};
-    bbox.p2 = {nx2, ny2};
-    break;
-  }
-  case Orientation::Right: {
-#if defined(__APPLE__)
-    // iOS upside-down portrait → portrait: nx = w - x, ny = h - y
-    float nx1 = w - bbox.p2.x, ny1 = h - bbox.p2.y;
-    float nx2 = w - bbox.p1.x, ny2 = h - bbox.p1.y;
-    bbox.p1 = {nx1, ny1};
-    bbox.p2 = {nx2, ny2};
-#endif
-    // Android front-cam upright portrait: rotated frame already in screen
-    // space, no inverse needed.
-    break;
-  }
-  case Orientation::Down: {
-    // landscape-right → portrait: nx = y, ny = w - x
-    float nx1 = bbox.p1.y, ny1 = w - bbox.p2.x;
-    float nx2 = bbox.p2.y, ny2 = w - bbox.p1.x;
-    bbox.p1 = {nx1, ny1};
-    bbox.p2 = {nx2, ny2};
-    break;
-  }
-  case Orientation::Left:
-    // no-op (coords already in screen space)
-    break;
-  }
-
-#if defined(__APPLE__)
-  if (orient.isMirrored) {
-    // After CW/CCW rotation (Up/Down) screen dims are swapped: rH × rW.
-    // After no-op/180° (Left/Right) screen dims are unchanged: rW × rH.
-    bool swapped = (orient.orientation == Orientation::Up ||
-                    orient.orientation == Orientation::Down);
-    float sw = swapped ? h : w;
-    float sh = swapped ? w : h;
-    float nx1 = sw - bbox.p2.x, ny1 = sh - bbox.p2.y;
-    float nx2 = sw - bbox.p1.x, ny2 = sh - bbox.p1.y;
-    bbox.p1 = {nx1, ny1};
-    bbox.p2 = {nx2, ny2};
-  }
-#endif
-}
-
-cv::Mat inverseRotateMat(const cv::Mat &mat, const FrameOrientation &orient) {
-  cv::Mat result;
-  switch (orient.orientation) {
-  case Orientation::Up:
-    cv::rotate(mat, result, cv::ROTATE_90_CLOCKWISE);
-    break;
-  case Orientation::Right:
-#if defined(__APPLE__)
-    cv::rotate(mat, result, cv::ROTATE_180);
-#else
-    // Android front-cam upright portrait: mask already in screen space.
-    result = mat;
-#endif
-    break;
-  case Orientation::Down:
-    cv::rotate(mat, result, cv::ROTATE_90_COUNTERCLOCKWISE);
-    break;
-  case Orientation::Left:
-    // no-op (mask already in screen space)
-    result = mat;
-    break;
-  }
-
-#if defined(__APPLE__)
-  if (orient.isMirrored) {
-    cv::rotate(result, result, cv::ROTATE_180);
-  }
-#endif
-  return result;
-}
-
-} // namespace rnexecutorch::utils
diff --git a/packages/react-native-executorch/common/rnexecutorch/utils/FrameTransform.h b/packages/react-native-executorch/common/rnexecutorch/utils/FrameTransform.h
deleted file mode 100644
index 8f9ca46cc2..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/utils/FrameTransform.h
+++ /dev/null
@@ -1,135 +0,0 @@
-#pragma once
-
-#include <opencv2/opencv.hpp>
-#include <rnexecutorch/utils/computer_vision/Types.h>
-#include <string>
-#include <type_traits>
-
-namespace rnexecutorch::utils {
-
-enum class Orientation { Up, Down, Left, Right };
-
-inline Orientation orientationFromString(const std::string &s) {
-  if (s == "down") {
-    return Orientation::Down;
-  }
-  if (s == "left") {
-    return Orientation::Left;
-  }
-  if (s == "right") {
-    return Orientation::Right;
-  }
-  return Orientation::Up;
-}
-
-struct FrameOrientation {
-  Orientation orientation;
-  bool isMirrored;
-};
-
-/**
- * @brief Rotate/flip a cv::Mat so the model sees an upright image.
- *
- * Applies the correct rotation per orientation so the output matches how a
- * human would see the scene, regardless of device orientation:
- *   "up"    (landscape-left)       → no rotation
- *   "down"  (landscape-right)      → 180°
- *   "left"  (portrait upright)     → CW
- *   "right" (portrait upside-down) → CCW
- * Also applies isMirrored flip.
- * Does not modify or clone the input — cv::rotate/cv::flip allocate
- * internally when needed. Returns the input mat unchanged when no
- * transform is needed (Up, not mirrored).
- */
-cv::Mat rotateFrameForModel(const cv::Mat &mat, const FrameOrientation &orient);
-
-/**
- * @brief Map bbox coords from rotated-frame space back to screen space.
- *
- * Inverse of rotateFrameForModel for coordinates.
- * rotatedSize is the rotated frame size (rotated.size()).
- */
-void inverseRotateBbox(computer_vision::BBox &bbox,
-                       const FrameOrientation &orient, cv::Size rotatedSize);
-
-/**
- * @brief Rotate a cv::Mat from rotated-frame space back to screen space.
- *
- * Inverse of rotateFrameForModel for matrices.
- * Does not modify or clone the input.
- */
-cv::Mat inverseRotateMat(const cv::Mat &mat, const FrameOrientation &orient);
-
-/**
- * @brief A 2D point with mutable arithmetic `x` and `y` members.
- *
- * Satisfied by e.g. `cv::Point2f`, `cv::Point`, and any user-defined struct
- * shaped `{ T x; T y; }` where `T` is arithmetic.
- */
-template <typename P>
-concept Point2D = requires(P &p) {
-  requires std::is_arithmetic_v<std::remove_reference_t<decltype(p.x)>>;
-  requires std::is_arithmetic_v<std::remove_reference_t<decltype(p.y)>>;
-};
-
-/**
- * @brief Map a sequence of points from rotated-frame space back to screen
- * space. Inverse of rotateFrameForModel for a collection of points.
- *
- * Works on any iterable whose elements satisfy {@link Point2D}
- * (e.g. `std::array<P, 4>`, `std::vector<P>`).
- * rotatedSize is the rotated frame size (rotated.size()).
- */
-template <typename Points>
-  requires Point2D<typename Points::value_type>
-void inverseRotatePoints(Points &points, const FrameOrientation &orient,
-                         cv::Size rotatedSize) {
-  const float w = static_cast<float>(rotatedSize.width);
-  const float h = static_cast<float>(rotatedSize.height);
-
-  using Coord = decltype(std::declval<Points>().begin()->x);
-
-  for (auto &p : points) {
-    float x = static_cast<float>(p.x);
-    float y = static_cast<float>(p.y);
-
-    switch (orient.orientation) {
-    case Orientation::Up:
-      // landscape-left → portrait: nx = h-y, ny = x
-      p.x = static_cast<Coord>(h - y);
-      p.y = static_cast<Coord>(x);
-      break;
-    case Orientation::Right:
-#if defined(__APPLE__)
-      // iOS upside-down portrait → portrait: nx = w-x, ny = h-y
-      p.x = static_cast<Coord>(w - x);
-      p.y = static_cast<Coord>(h - y);
-#endif
-      // Android front-cam upright portrait: rotated frame already in
-      // screen space (mirror-selfie portrait), no inverse needed.
-      break;
-    case Orientation::Down:
-      // landscape-right → portrait: nx = y, ny = w-x
-      p.x = static_cast<Coord>(y);
-      p.y = static_cast<Coord>(w - x);
-      break;
-    case Orientation::Left:
-      break;
-    }
-  }
-
-#if defined(__APPLE__)
-  if (orient.isMirrored) {
-    bool swapped = (orient.orientation == Orientation::Up ||
-                    orient.orientation == Orientation::Down);
-    float sw = swapped ? h : w;
-    float sh = swapped ? w : h;
-    for (auto &p : points) {
-      p.x = static_cast<Coord>(sw - static_cast<float>(p.x));
-      p.y = static_cast<Coord>(sh - static_cast<float>(p.y));
-    }
-  }
-#endif
-}
-
-} // namespace rnexecutorch::utils
diff --git a/packages/react-native-executorch/common/rnexecutorch/utils/computer_vision/Processing.cpp b/packages/react-native-executorch/common/rnexecutorch/utils/computer_vision/Processing.cpp
deleted file mode 100644
index 8ced125ecf..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/utils/computer_vision/Processing.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "Processing.h"
-#include <algorithm>
-
-namespace rnexecutorch::utils::computer_vision {
-
-float computeIoU(const BBox &a, const BBox &b) {
-  float x1 = std::max(a.p1.x, b.p1.x);
-  float y1 = std::max(a.p1.y, b.p1.y);
-  float x2 = std::min(a.p2.x, b.p2.x);
-  float y2 = std::min(a.p2.y, b.p2.y);
-
-  float intersectionArea = std::max(0.0f, x2 - x1) * std::max(0.0f, y2 - y1);
-  float areaA = a.area();
-  float areaB = b.area();
-  float unionArea = areaA + areaB - intersectionArea;
-
-  return (unionArea > 0.0f) ? (intersectionArea / unionArea) : 0.0f;
-}
-
-} // namespace rnexecutorch::utils::computer_vision
diff --git a/packages/react-native-executorch/common/rnexecutorch/utils/computer_vision/Processing.h b/packages/react-native-executorch/common/rnexecutorch/utils/computer_vision/Processing.h
deleted file mode 100644
index 3bd3022d4a..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/utils/computer_vision/Processing.h
+++ /dev/null
@@ -1,51 +0,0 @@
-#pragma once
-
-#include "Types.h"
-#include <algorithm>
-#include <vector>
-
-namespace rnexecutorch::utils::computer_vision {
-
-float computeIoU(const BBox &a, const BBox &b);
-
-template <HasBBoxAndScore T>
-std::vector<T> nonMaxSuppression(std::vector<T> items, double iouThreshold) {
-  if (items.empty()) {
-    return {};
-  }
-
-  std::ranges::sort(items,
-                    [](const T &a, const T &b) { return a.score > b.score; });
-
-  std::vector<T> result;
-  std::vector<bool> suppressed(items.size(), false);
-
-  for (size_t i = 0; i < items.size(); ++i) {
-    if (suppressed[i]) {
-      continue;
-    }
-
-    result.push_back(items[i]);
-
-    for (size_t j = i + 1; j < items.size(); ++j) {
-      if (suppressed[j]) {
-        continue;
-      }
-
-      if constexpr (requires(T t) { t.classIndex; }) {
-        if (items[i].classIndex != items[j].classIndex) {
-          continue;
-        }
-      }
-
-      float iou = computeIoU(items[i].bbox, items[j].bbox);
-      if (iou > iouThreshold) {
-        suppressed[j] = true;
-      }
-    }
-  }
-
-  return result;
-}
-
-} // namespace rnexecutorch::utils::computer_vision
diff --git a/packages/react-native-executorch/common/rnexecutorch/utils/computer_vision/Types.h b/packages/react-native-executorch/common/rnexecutorch/utils/computer_vision/Types.h
deleted file mode 100644
index 7698d9807f..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/utils/computer_vision/Types.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#pragma once
-
-#include <concepts>
-
-namespace rnexecutorch::utils::computer_vision {
-
-struct Point {
-  float x;
-  float y;
-};
-
-struct BBox {
-  float width() const { return p2.x - p1.x; }
-  float height() const { return p2.y - p1.y; }
-  float area() const { return width() * height(); }
-
-  bool isValid() const {
-    return p2.x > p1.x && p2.y > p1.y && p1.x >= 0.0f && p1.y >= 0.0f;
-  }
-
-  BBox scale(float widthRatio, float heightRatio) const {
-    return {{p1.x * widthRatio, p1.y * heightRatio},
-            {p2.x * widthRatio, p2.y * heightRatio}};
-  }
-
-  Point p1, p2;
-};
-
-template <typename T>
-concept HasBBoxAndScore = requires(T t) {
-  { t.bbox } -> std::convertible_to<BBox>;
-  { t.score } -> std::convertible_to<float>;
-};
-
-} // namespace rnexecutorch::utils::computer_vision
diff --git a/packages/react-native-executorch/common/runner/arange_util.cpp b/packages/react-native-executorch/common/runner/arange_util.cpp
deleted file mode 100644
index 4aa340966c..0000000000
--- a/packages/react-native-executorch/common/runner/arange_util.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#include "arange_util.h"
-
-namespace torch::executor::native {
-#define ET_ARANGE_IMPL(ctx, start, numel, step, out, op_name)                  \
-  ET_SWITCH_REALHBF16_TYPES(out.scalar_type(), ctx, op_name, CTYPE, [&]() {    \
-    auto out_data = out.mutable_data_ptr<CTYPE>();                             \
-    for (executorch::aten::SizesType i = 0; i < numel; ++i) {                  \
-      out_data[i] = static_cast<CTYPE>(start + i * step);                      \
-    }                                                                          \
-  })
-
-executorch::aten::SizesType compute_arange_out_size(double start, double end,
-                                                    double step) {
-  executorch::aten::SizesType numel =
-      static_cast<executorch::aten::SizesType>(std::ceil((end - start) / step));
-
-  ET_CHECK_MSG(numel >= 0,
-               "numel should be non-negative, but got (%" PRId64
-               "). start (%f), end (%f), step (%f)",
-               static_cast<int64_t>(numel), start, end, step);
-  return numel;
-}
-
-void arange_out_impl(KernelRuntimeContext &ctx, double start, double end,
-                     double step, Tensor &out) {
-  (void)ctx;
-  executorch::aten::SizesType numel = compute_arange_out_size(start, end, step);
-  ET_ARANGE_IMPL(ctx, start, numel, step, out, "arange.start_out");
-}
-
-void arange_out_impl(KernelRuntimeContext &ctx, double end, Tensor &out) {
-  (void)ctx;
-  ET_ARANGE_IMPL(ctx, 0.0, end, 1.0, out, "arange.out");
-}
-
-} // namespace torch::executor::native
diff --git a/packages/react-native-executorch/common/runner/arange_util.h b/packages/react-native-executorch/common/runner/arange_util.h
deleted file mode 100644
index 773b32204e..0000000000
--- a/packages/react-native-executorch/common/runner/arange_util.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include "kernel_includes.h"
-
-namespace torch::executor::native {
-
-executorch::aten::SizesType compute_arange_out_size(double start, double end,
-                                                    double step);
-
-inline executorch::aten::SizesType compute_arange_out_size(double end) {
-  return compute_arange_out_size(0.0, end, 1.0);
-}
-
-void arange_out_impl(KernelRuntimeContext &ctx, double start, double end,
-                     double step, Tensor &out);
-
-void arange_out_impl(KernelRuntimeContext &ctx, double end, Tensor &out);
-
-inline void arange_out_impl(double start, double end, double step,
-                            Tensor &out) {
-  KernelRuntimeContext ctx;
-  arange_out_impl(ctx, start, end, step, out);
-}
-
-inline void arange_out_impl(double end, Tensor &out) {
-  KernelRuntimeContext ctx;
-  arange_out_impl(ctx, 0.0, end, 1.0, out);
-}
-} // namespace torch::executor::native
diff --git a/packages/react-native-executorch/common/runner/base_llm_runner.cpp b/packages/react-native-executorch/common/runner/base_llm_runner.cpp
deleted file mode 100644
index 7229d64f20..0000000000
--- a/packages/react-native-executorch/common/runner/base_llm_runner.cpp
+++ /dev/null
@@ -1,185 +0,0 @@
-// common/runner/base_llm_runner.cpp
-#include "base_llm_runner.h"
-#include "constants.h"
-#include <cstdint>
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/Log.h>
-
-namespace executorch::extension::llm {
-
-using ::executorch::extension::Module;
-using ::executorch::runtime::Error;
-
-BaseLLMRunner::BaseLLMRunner(std::unique_ptr<Module> module,
-                             const std::string &tokenizer_path,
-                             const GenerationConfig &config)
-    : config_(config), module_(std::move(module)),
-      tokenizer_path_(tokenizer_path),
-      tokenizer_(std::make_unique<tokenizers::HFTokenizer>()),
-      metadata_({
-          {kEnableDynamicShape, false},
-          {kMaxSeqLen, 128},
-          {kMaxContextLen, 128},
-          {kUseKVCache, true},
-      }) {}
-
-Error BaseLLMRunner::load() {
-  if (is_loaded()) {
-    return Error::Ok;
-  }
-
-  auto status = tokenizer_->load(tokenizer_path_);
-  if (status != tokenizers::Error::Ok) {
-    throw rnexecutorch::RnExecutorchError(
-        rnexecutorch::RnExecutorchErrorCode::TokenizerError,
-        "Unexpected issue occurred while loading tokenizer (error code: " +
-            std::to_string(static_cast<int32_t>(status)) + ")");
-  }
-
-  const auto method_names =
-      ET_UNWRAP(module_->method_names(), "Failed reading method names");
-
-  metadata_[kVocabSize] = tokenizer_->vocab_size();
-  for (auto &[method_name, value] : metadata_) {
-    if (method_names.count(method_name)) {
-      value = ET_UNWRAP(module_->get(method_name))
-                  .toScalar()
-                  .to<decltype(metadata_)::mapped_type>();
-    }
-  }
-
-  if (config_.max_seq_len < 0)
-    config_.max_seq_len = static_cast<int32_t>(metadata_.at(kMaxSeqLen));
-  if (config_.max_context_length < 0) {
-    config_.max_context_length =
-        method_names.count(kMaxContextLen)
-            ? static_cast<int32_t>(metadata_.at(kMaxContextLen))
-            : static_cast<int32_t>(metadata_.at(kMaxSeqLen));
-  }
-  config_.enable_dynamic_shape =
-      static_cast<bool>(metadata_.at(kEnableDynamicShape));
-  if (config_.max_new_tokens < 0) {
-    // For dynamic-shape PTEs, max_seq_len is the per-call decoder chunk
-    // size, not the generation budget — use max_context_length instead.
-    const int32_t seq_cap = config_.enable_dynamic_shape
-                                ? config_.max_context_length
-                                : config_.max_seq_len;
-    config_.max_new_tokens = std::min(seq_cap, config_.max_context_length);
-  }
-  config_.enable_kv_cache = static_cast<bool>(metadata_.at(kUseKVCache));
-
-  eos_ids_ = std::make_unique<std::unordered_set<uint64_t>>();
-  if (method_names.count(kEosIds)) {
-    for (const auto &eos_id : ET_UNWRAP(module_->execute(kEosIds))) {
-      eos_ids_->emplace(static_cast<uint64_t>(eos_id.toScalar().to<int64_t>()));
-    }
-  }
-  if (eos_ids_->empty()) {
-    throw rnexecutorch::RnExecutorchError(
-        rnexecutorch::RnExecutorchErrorCode::InvalidModelOutput,
-        "Model did not provide any EOS token IDs via 'get_eos_ids'. "
-        "The .pte file may be misconfigured.");
-  }
-
-  io_manager_ = std::make_unique<IOManager>(*module_);
-
-  return load_subcomponents();
-}
-
-Error BaseLLMRunner::generate(
-    const std::string &prompt, const GenerationConfig &generation_config,
-    std::function<void(const std::string &)> token_callback,
-    std::function<void(const Stats &)> stats_callback) {
-
-  ET_CHECK_OR_RETURN_ERROR(!prompt.empty(), InvalidArgument,
-                           "Prompt cannot be null");
-
-  std::vector<MultimodalInput> inputs = {make_text_input(prompt)};
-  auto err = generate_internal(inputs, token_callback);
-
-  if (stats_callback) {
-    stats_callback(stats_);
-  }
-
-  return err;
-}
-
-Error BaseLLMRunner::generate(
-    const std::vector<MultimodalInput> &inputs,
-    std::function<void(const std::string &)> token_callback,
-    std::function<void(const Stats &)> stats_callback) {
-
-  auto err = generate_internal(inputs, token_callback);
-
-  if (stats_callback) {
-    stats_callback(stats_);
-  }
-
-  return err;
-}
-
-void BaseLLMRunner::stop() { stop_impl(); }
-
-void BaseLLMRunner::reset() {
-  stats_.reset();
-  pos_ = 0;
-}
-
-int32_t BaseLLMRunner::count_text_tokens(const std::string &text) const {
-  auto encodeResult =
-      tokenizer_->encode(text, numOfAddedBoSTokens, numOfAddedEoSTokens);
-  if (!encodeResult.ok()) {
-    throw rnexecutorch::RnExecutorchError(
-        rnexecutorch::RnExecutorchErrorCode::TokenizerError,
-        "Encoding failed during token count check.");
-  }
-  return static_cast<int32_t>(encodeResult.get().size());
-}
-
-int32_t BaseLLMRunner::get_max_context_length() const {
-  if (!is_loaded())
-    return static_cast<int32_t>(metadata_.at(kMaxContextLen));
-  return config_.max_context_length;
-}
-
-void BaseLLMRunner::set_temperature(float temperature) noexcept {
-  config_.temperature = temperature;
-}
-
-void BaseLLMRunner::set_topp(float topp) noexcept { config_.topp = topp; }
-
-void BaseLLMRunner::set_min_p(float min_p) noexcept { config_.min_p = min_p; }
-
-void BaseLLMRunner::set_repetition_penalty(float repetition_penalty) noexcept {
-  config_.repetition_penalty = repetition_penalty;
-}
-
-void BaseLLMRunner::set_topk(int32_t topk) noexcept { config_.topk = topk; }
-
-void BaseLLMRunner::set_count_interval(size_t count_interval) {
-  config_.output_token_batch_size = count_interval;
-}
-
-void BaseLLMRunner::set_time_interval(size_t time_interval) {
-  config_.batch_time_interval_ms = time_interval;
-}
-
-int32_t BaseLLMRunner::resolve_max_new_tokens(int32_t num_prompt_tokens,
-                                              int32_t max_seq_len,
-                                              int32_t max_context_len,
-                                              int32_t max_new_tokens) const {
-  int32_t result;
-  if (max_seq_len == -1 && max_new_tokens == -1)
-    result = max_context_len - num_prompt_tokens;
-  else if (max_seq_len == -1)
-    result = std::min(max_new_tokens, max_context_len - num_prompt_tokens);
-  else if (max_new_tokens == -1)
-    result = std::min(max_seq_len, max_context_len) - num_prompt_tokens;
-  else
-    result =
-        std::min(std::min(max_seq_len, max_context_len) - num_prompt_tokens,
-                 max_new_tokens);
-  return std::max(0, result);
-}
-
-} // namespace executorch::extension::llm
diff --git a/packages/react-native-executorch/common/runner/base_llm_runner.h b/packages/react-native-executorch/common/runner/base_llm_runner.h
deleted file mode 100644
index 82de49bea3..0000000000
--- a/packages/react-native-executorch/common/runner/base_llm_runner.h
+++ /dev/null
@@ -1,90 +0,0 @@
-// common/runner/base_llm_runner.h
-#pragma once
-
-#include "io_manager.h"
-#include "irunner.h"
-#include "multimodal_input.h"
-#include "stats.h"
-#include <cstdint>
-#include <executorch/extension/module/module.h>
-#include <functional>
-#include <memory>
-#include <pytorch/tokenizers/hf_tokenizer.h>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-namespace executorch::extension::llm {
-class BaseLLMRunner {
-public:
-  explicit BaseLLMRunner(
-      std::unique_ptr<::executorch::extension::Module> module,
-      const std::string &tokenizer_path,
-      const GenerationConfig &config = {.temperature = 0.8F, .topp = 0.9F});
-
-  virtual ~BaseLLMRunner() = default;
-
-  virtual bool is_loaded() const = 0;
-
-  virtual ::executorch::runtime::Error load();
-
-  ::executorch::runtime::Error
-  generate(const std::string &prompt,
-           const GenerationConfig &generation_config = {},
-           std::function<void(const std::string &)> token_callback = {},
-           std::function<void(const Stats &)> stats_callback = {});
-
-  ::executorch::runtime::Error
-  generate(const std::vector<MultimodalInput> &inputs,
-           std::function<void(const std::string &)> token_callback = {},
-           std::function<void(const Stats &)> stats_callback = {});
-
-  virtual ::executorch::runtime::Error generate_internal(
-      const std::vector<MultimodalInput> &inputs,
-      std::function<void(const std::string &)> token_callback) = 0;
-
-  void stop();
-  void reset();
-  int32_t count_text_tokens(const std::string &text) const;
-  int32_t get_max_context_length() const;
-  virtual bool is_multimodal() const { return false; }
-  virtual int32_t get_visual_token_count() const { return 0; }
-
-  void set_temperature(float temperature) noexcept;
-  void set_topp(float topp) noexcept;
-  void set_min_p(float min_p) noexcept;
-  void set_repetition_penalty(float repetition_penalty) noexcept;
-  void set_topk(int32_t topk) noexcept;
-  void set_count_interval(size_t count_interval);
-  void set_time_interval(size_t time_interval);
-
-  Stats stats_;
-
-  // Public for test access
-  GenerationConfig config_;
-  int64_t pos_{0};
-
-protected:
-  virtual ::executorch::runtime::Error load_subcomponents() = 0;
-  virtual void stop_impl() = 0;
-  // Sampling values and token-batching intervals live entirely in `config_`.
-  // The TextDecoderRunner / TextTokenGenerator shared by both TextRunner and
-  // MultimodalRunner are constructed with a const reference to `config_`
-  // and read those fields on every iteration, so writes via the public
-  // set_* methods on BaseLLMRunner take effect immediately with no virtual
-  // dispatch needed.
-
-  int32_t resolve_max_new_tokens(int32_t num_prompt_tokens, int32_t max_seq_len,
-                                 int32_t max_context_len,
-                                 int32_t max_new_tokens = -1) const;
-
-  std::unique_ptr<::executorch::extension::Module> module_;
-  std::string tokenizer_path_;
-  std::unique_ptr<tokenizers::HFTokenizer> tokenizer_;
-  std::unordered_map<std::string, int64_t> metadata_;
-  std::unique_ptr<IOManager> io_manager_;
-  std::unique_ptr<std::unordered_set<uint64_t>> eos_ids_;
-};
-
-} // namespace executorch::extension::llm
diff --git a/packages/react-native-executorch/common/runner/constants.h b/packages/react-native-executorch/common/runner/constants.h
deleted file mode 100644
index 368371688a..0000000000
--- a/packages/react-native-executorch/common/runner/constants.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-#pragma once
-// constants for LLM runtime
-namespace executorch::extension::llm {
-
-// Runtime metadata key constants
-inline constexpr auto kEnableDynamicShape = "enable_dynamic_shape";
-inline constexpr auto kBosId = "get_bos_id";
-inline constexpr auto kEosIds = "get_eos_ids";
-inline constexpr auto kMaxSeqLen = "get_max_seq_len";
-inline constexpr auto kMaxContextLen = "get_max_context_len";
-inline constexpr auto kVocabSize = "get_vocab_size";
-inline constexpr auto kUseKVCache = "use_kv_cache";
-
-// Multimodal method name conventions
-inline constexpr auto kVisionEncoderMethod = "vision_encoder";
-inline constexpr auto kAudioEncoderMethod = "audio_encoder";
-inline constexpr auto kTokenEmbeddingMethod = "token_embedding";
-inline constexpr auto kTextModelMethod = "text_decoder";
-inline constexpr auto numOfAddedBoSTokens = 0;
-inline constexpr auto numOfAddedEoSTokens = 0;
-
-// Gemma4
-// PLE models only: token id that marks image placeholder slots in input_ids.
-// token_embedding run on this id produces the per-layer PLE signal for image
-// positions; the inputs_embeds output for those positions is discarded (the
-// vision encoder output replaces it).
-inline constexpr auto kImagePlaceholderId = "image_placeholder_id";
-// True iff the model exposes a per-layer-embedding (PLE) signal alongside
-// inputs_embeds (Gemma4-style). When true, `token_embedding.execute()`
-// returns the tuple (inputs_embeds, ple_tok) and the runner must thread
-// ple_tok into text_decoder; when false (or absent), token_embedding returns
-// inputs_embeds alone. Text-only PTEs that ship a single `forward` method
-// omit this key entirely — it is meaningful only for multimodal PTEs that
-// expose a separate `token_embedding` method.
-inline constexpr auto kHasPLE = "has_ple";
-
-} // namespace executorch::extension::llm
diff --git a/packages/react-native-executorch/common/runner/encoders/audio_encoder.cpp b/packages/react-native-executorch/common/runner/encoders/audio_encoder.cpp
deleted file mode 100644
index 36227dc966..0000000000
--- a/packages/react-native-executorch/common/runner/encoders/audio_encoder.cpp
+++ /dev/null
@@ -1,111 +0,0 @@
-// common/runner/encoders/audio_encoder.cpp
-#include "audio_encoder.h"
-
-#include <rnexecutorch/Error.h>
-#include <runner/constants.h>
-
-#include <executorch/extension/tensor/tensor.h>
-
-#include <cmath>
-#include <cstdint>
-#include <cstring>
-#include <string>
-#include <vector>
-
-namespace executorch::extension::llm {
-
-using ::executorch::aten::SizesType;
-using ::executorch::runtime::Error;
-using ::executorch::runtime::EValue;
-using ::executorch::runtime::Result;
-
-namespace {
-constexpr int32_t kSamplingRate = 16e3;
-constexpr int32_t kMaxLengthSeconds = 30;
-constexpr int32_t kSamplesPerBlock = 7680;
-constexpr int64_t kAudioBlockKMin = 1;
-constexpr int64_t kAudioBlockKMax =
-    kSamplingRate * kMaxLengthSeconds / kSamplesPerBlock;
-} // namespace
-
-AudioEncoder::AudioEncoder(::executorch::extension::Module &module)
-    : module_(&module) {}
-
-Error AudioEncoder::load() {
-  if (is_loaded()) {
-    return Error::Ok;
-  }
-  auto method_names_result = module_->method_names();
-  if (!method_names_result.ok()) {
-    return method_names_result.error();
-  }
-  if (method_names_result->count(kAudioEncoderMethod) == 0) {
-    throw rnexecutorch::RnExecutorchError(
-        rnexecutorch::RnExecutorchErrorCode::InvalidConfig,
-        "Model does not support audio: 'audio_encoder' method not found. "
-        "Check that the .pte file matches the declared capabilities.");
-  }
-  return module_->load_method(kAudioEncoderMethod);
-}
-
-bool AudioEncoder::is_loaded() const noexcept {
-  return module_->is_method_loaded(kAudioEncoderMethod);
-}
-
-int32_t AudioEncoder::encoderTokenCount() const noexcept {
-  return last_token_count_;
-}
-
-Result<EValue> AudioEncoder::encode(const MultimodalInput &input) {
-  if (!is_loaded()) {
-    return Error::InvalidState;
-  }
-  if (!input.is_audio()) {
-    return Error::InvalidArgument;
-  }
-
-  const auto &wav = input.get_audio();
-  ET_CHECK_OR_RETURN_ERROR(!wav.samples.empty(), InvalidArgument,
-                           "AudioEncoder: empty waveform");
-
-  const int64_t n_valid = static_cast<int64_t>(wav.samples.size());
-  const int64_t k_blocks = (n_valid + kSamplesPerBlock - 1) / kSamplesPerBlock;
-  ET_CHECK_OR_RETURN_ERROR(
-      k_blocks >= kAudioBlockKMin && k_blocks <= kAudioBlockKMax,
-      InvalidArgument,
-      "AudioEncoder: waveform of %lld samples needs k_blocks=%lld.",
-      static_cast<long long>(n_valid), static_cast<long long>(k_blocks));
-  const int64_t n_padded = k_blocks * kSamplesPerBlock;
-
-  // Own the padded waveform for the lifetime of this call; from_blob below
-  // borrows without copying. The current export takes
-  //   forward(waveform[1, 7680*k] fp32, num_blocks: int64 scalar)
-  // — input 1 is a rank-0 Long telling the encoder how many of the K_MAX
-  // blocks contain real PCM. Passing a 2-d mask here trips "Attempted to
-  // change tensor rank: old=0, new=2".
-  padded_wav_.assign(static_cast<size_t>(n_padded), 0.0f);
-  std::memcpy(padded_wav_.data(), wav.samples.data(),
-              static_cast<size_t>(n_valid) * sizeof(float));
-
-  valid_samples_scalar_ = n_valid;
-
-  auto wav_tensor = ::executorch::extension::from_blob(
-      padded_wav_.data(), {1, static_cast<SizesType>(n_padded)},
-      ::executorch::aten::ScalarType::Float);
-
-  auto num_blocks_tensor = ::executorch::extension::from_blob(
-      &valid_samples_scalar_, {}, ::executorch::aten::ScalarType::Long);
-
-  std::vector<EValue> args = {EValue(*wav_tensor), EValue(*num_blocks_tensor)};
-  auto exec_result = ET_UNWRAP(module_->execute(kAudioEncoderMethod, args));
-  ET_CHECK_OR_RETURN_ERROR(!exec_result.empty(), InvalidState,
-                           "audio_encoder returned no outputs");
-  auto audio_tensor = exec_result[0].toTensor();
-  ET_CHECK_OR_RETURN_ERROR(audio_tensor.dim() == 3, InvalidState,
-                           "audio_encoder output rank=%zd, expected 3",
-                           audio_tensor.dim());
-  last_token_count_ = static_cast<int32_t>(audio_tensor.size(1));
-  return exec_result[0];
-}
-
-} // namespace executorch::extension::llm
diff --git a/packages/react-native-executorch/common/runner/encoders/audio_encoder.h b/packages/react-native-executorch/common/runner/encoders/audio_encoder.h
deleted file mode 100644
index 9723e4fbd7..0000000000
--- a/packages/react-native-executorch/common/runner/encoders/audio_encoder.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// common/runner/encoders/audio_encoder.h
-#pragma once
-
-#include "iencoder.h"
-#include <executorch/extension/module/module.h>
-#include <executorch/runtime/core/evalue.h>
-#include <runner/multimodal_input.h>
-
-#include <cstdint>
-#include <vector>
-
-namespace executorch::extension::llm {
-
-// Runs the Gemma4 `audio_encoder` PTE method.
-//
-// Contract mirrors SpeechToText (Whisper): JS hands in fp32 mono 16 kHz PCM
-// via `MultimodalInput::get_audio()`; the PTE owns the log-mel frontend so
-// this class just wraps the samples in a `[1, N_samples]` Float tensor and
-// executes. Resampling and WAV/MP3 decoding are the caller's responsibility
-// (e.g. react-native-audio-api).
-class AudioEncoder : public IEncoder {
-public:
-  explicit AudioEncoder(::executorch::extension::Module &module);
-
-  ::executorch::runtime::Error load() override;
-  bool is_loaded() const noexcept override;
-  ::executorch::runtime::Result<::executorch::runtime::EValue>
-  encode(const MultimodalInput &input) override;
-  // Number of audio embedding tokens produced per encode() call. 0 until first
-  // encode, since Gemma4's audio_encoder has a dynamic T dim.
-  int32_t encoderTokenCount() const noexcept override;
-
-private:
-  ::executorch::extension::Module *module_;
-  int32_t last_token_count_ = 0;
-  std::vector<float> padded_wav_;
-  int64_t valid_samples_scalar_ = 0;
-};
-
-} // namespace executorch::extension::llm
diff --git a/packages/react-native-executorch/common/runner/encoders/iencoder.h b/packages/react-native-executorch/common/runner/encoders/iencoder.h
deleted file mode 100644
index ae9bb203c4..0000000000
--- a/packages/react-native-executorch/common/runner/encoders/iencoder.h
+++ /dev/null
@@ -1,25 +0,0 @@
-// common/runner/encoders/iencoder.h
-#pragma once
-
-#include <executorch/runtime/core/error.h>
-#include <executorch/runtime/core/evalue.h>
-#include <executorch/runtime/core/result.h>
-#include <runner/multimodal_input.h>
-
-namespace executorch::extension::llm {
-
-class IEncoder {
-public:
-  virtual ~IEncoder() = default;
-  virtual ::executorch::runtime::Error load() = 0;
-  virtual bool is_loaded() const noexcept = 0;
-
-  virtual ::executorch::runtime::Result<::executorch::runtime::EValue>
-  encode(const MultimodalInput &input) = 0;
-
-  // Returns the number of tokens produced per encoded input (e.g. visual
-  // tokens per image). Returns 0 if not loaded or unknown.
-  virtual int32_t encoderTokenCount() const { return 0; }
-};
-
-} // namespace executorch::extension::llm
diff --git a/packages/react-native-executorch/common/runner/encoders/vision_encoder.cpp b/packages/react-native-executorch/common/runner/encoders/vision_encoder.cpp
deleted file mode 100644
index 09fb459661..0000000000
--- a/packages/react-native-executorch/common/runner/encoders/vision_encoder.cpp
+++ /dev/null
@@ -1,145 +0,0 @@
-// common/runner/encoders/vision_encoder.cpp
-#include "vision_encoder.h"
-
-#include <rnexecutorch/Error.h>
-#include <rnexecutorch/data_processing/ImageProcessing.h>
-#include <runner/constants.h>
-
-#include <executorch/extension/tensor/tensor.h>
-#include <opencv2/opencv.hpp>
-
-namespace executorch::extension::llm {
-
-using ::executorch::runtime::Error;
-using ::executorch::runtime::EValue;
-using ::executorch::runtime::Result;
-
-VisionEncoder::VisionEncoder(::executorch::extension::Module &module)
-    : module_(&module) {}
-
-Error VisionEncoder::load() {
-  if (is_loaded()) {
-    return Error::Ok;
-  }
-  auto method_names_result = module_->method_names();
-  if (!method_names_result.ok()) {
-    return method_names_result.error();
-  }
-
-  if (method_names_result->count(kVisionEncoderMethod) == 0) {
-    throw rnexecutorch::RnExecutorchError(
-        rnexecutorch::RnExecutorchErrorCode::InvalidConfig,
-        "Model does not support vision: 'vision_encoder' method not found. "
-        "Check that the .pte file matches the declared capabilities.");
-  }
-  return module_->load_method(kVisionEncoderMethod);
-}
-
-bool VisionEncoder::is_loaded() const noexcept {
-  return module_->is_method_loaded(kVisionEncoderMethod);
-}
-
-int32_t VisionEncoder::encoderTokenCount() const {
-  if (!is_loaded()) {
-    return 0;
-  }
-  auto meta_result = module_->method_meta(kVisionEncoderMethod);
-  if (!meta_result.ok()) {
-    return 0;
-  }
-  auto output_meta = meta_result->output_tensor_meta(0);
-  if (!output_meta.ok()) {
-    return 0;
-  }
-  // Output shape is [1, num_visual_tokens, embed_dim]
-  auto sizes = output_meta->sizes();
-  if (sizes.size() < 2) {
-    return 0;
-  }
-  return static_cast<int32_t>(sizes[1]);
-}
-
-Result<VisionEncoder::ImageShape> VisionEncoder::getInputShape() const {
-  auto method_meta = ET_UNWRAP(module_->method_meta(kVisionEncoderMethod));
-  auto input_meta = ET_UNWRAP(method_meta.input_tensor_meta(0));
-  auto dims = input_meta.sizes();
-  const bool with_batch = dims.size() == 4;
-  const int32_t offset = with_batch ? 1 : 0;
-  return ImageShape{
-      .channels = static_cast<int32_t>(dims[offset]),
-      .height = static_cast<int32_t>(dims[offset + 1]),
-      .width = static_cast<int32_t>(dims[offset + 2]),
-      .with_batch = with_batch,
-  };
-}
-
-std::vector<float>
-VisionEncoder::preprocessImage(const std::string &path,
-                               const ImageShape &targetShape) const {
-  // The bundled vision-encoder PTEs (e.g. LFM2.5-VL) bake rescale + normalize
-  // into the exported graph, so we hand raw 0-255 float pixel values to the
-  // module. Adding rescale / normalize here would double-apply the transform
-  // and destroy the input distribution. We reuse `resizePadded` for the
-  // aspect-ratio-preserving letterbox (it picks the pad colour from the
-  // source image corners, which blends better than a flat gray), then
-  // convert BGR->RGB and repack the raw pixels into CHW float.
-  cv::Mat src = rnexecutorch::image_processing::readImage(path);
-  cv::Mat canvas = rnexecutorch::image_processing::resizePadded(
-      src, cv::Size(targetShape.width, targetShape.height));
-  cv::cvtColor(canvas, canvas, cv::COLOR_BGR2RGB);
-
-  const int32_t pixelCount = targetShape.height * targetShape.width;
-  std::vector<float> chw(targetShape.channels * pixelCount);
-  for (int32_t i = 0; i < pixelCount; ++i) {
-    cv::Vec3b px =
-        canvas.at<cv::Vec3b>(i / targetShape.width, i % targetShape.width);
-    for (int32_t c = 0; c < targetShape.channels; ++c) {
-      chw[c * pixelCount + i] = static_cast<float>(px[c]);
-    }
-  }
-  return chw;
-}
-
-Result<EValue> VisionEncoder::encode(const MultimodalInput &input) {
-  if (!is_loaded()) {
-    return Error::InvalidState;
-  }
-  if (!input.is_image()) {
-    return Error::InvalidArgument;
-  }
-
-  const std::string &path = input.get_image_path();
-
-  auto it = embedding_cache_.find(path);
-  if (it != embedding_cache_.end()) {
-    return EValue(*it->second.tensor);
-  }
-
-  auto shape = ET_UNWRAP(getInputShape());
-  auto chw = preprocessImage(path, shape);
-
-  std::vector<::executorch::aten::SizesType> sizes = {
-      shape.channels, shape.height, shape.width};
-  if (shape.with_batch) {
-    sizes.insert(sizes.begin(), 1);
-  }
-
-  auto image_tensor = ::executorch::extension::from_blob(
-      chw.data(), sizes, ::executorch::aten::ScalarType::Float);
-
-  auto result = ET_UNWRAP(module_->execute(kVisionEncoderMethod, image_tensor));
-  auto out_tensor = result[0].toTensor();
-
-  CachedEmbedding cached;
-  cached.bytes.resize(out_tensor.nbytes());
-  std::memcpy(cached.bytes.data(), out_tensor.const_data_ptr(),
-              out_tensor.nbytes());
-  cached.sizes.assign(out_tensor.sizes().begin(), out_tensor.sizes().end());
-  cached.dtype = out_tensor.scalar_type();
-  auto [entry, inserted] = embedding_cache_.emplace(path, std::move(cached));
-  entry->second.tensor = ::executorch::extension::from_blob(
-      entry->second.bytes.data(), entry->second.sizes, entry->second.dtype);
-  return EValue(*entry->second.tensor);
-}
-
-} // namespace executorch::extension::llm
diff --git a/packages/react-native-executorch/common/runner/encoders/vision_encoder.h b/packages/react-native-executorch/common/runner/encoders/vision_encoder.h
deleted file mode 100644
index 54d43bb869..0000000000
--- a/packages/react-native-executorch/common/runner/encoders/vision_encoder.h
+++ /dev/null
@@ -1,51 +0,0 @@
-// common/runner/encoders/vision_encoder.h
-#pragma once
-
-#include "iencoder.h"
-#include <cstdint>
-#include <executorch/extension/module/module.h>
-#include <executorch/extension/tensor/tensor.h>
-#include <executorch/runtime/core/evalue.h>
-#include <runner/multimodal_input.h>
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-namespace executorch::extension::llm {
-
-class VisionEncoder : public IEncoder {
-public:
-  explicit VisionEncoder(::executorch::extension::Module &module);
-
-  ::executorch::runtime::Error load() override;
-  bool is_loaded() const noexcept override;
-  ::executorch::runtime::Result<::executorch::runtime::EValue>
-  encode(const MultimodalInput &input) override;
-  int32_t encoderTokenCount() const override;
-
-private:
-  struct ImageShape {
-    int32_t channels, height, width;
-    bool with_batch;
-  };
-
-  // The method's output EValue aliases the runtime's reusable output buffer,
-  // which the NEXT vision_encoder.execute() overwrites — caching it directly
-  // silently turns earlier images into the most recently encoded one. Cache
-  // an owned byte snapshot instead and hand out a tensor over those bytes.
-  struct CachedEmbedding {
-    std::vector<uint8_t> bytes;
-    std::vector<::executorch::aten::SizesType> sizes;
-    ::executorch::aten::ScalarType dtype;
-    ::executorch::extension::TensorPtr tensor;
-  };
-
-  ::executorch::runtime::Result<ImageShape> getInputShape() const;
-  std::vector<float> preprocessImage(const std::string &path,
-                                     const ImageShape &targetShape) const;
-
-  ::executorch::extension::Module *module_;
-  std::unordered_map<std::string, CachedEmbedding> embedding_cache_;
-};
-
-} // namespace executorch::extension::llm
diff --git a/packages/react-native-executorch/common/runner/io_manager.h b/packages/react-native-executorch/common/runner/io_manager.h
deleted file mode 100644
index af176b47d4..0000000000
--- a/packages/react-native-executorch/common/runner/io_manager.h
+++ /dev/null
@@ -1,240 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <executorch/extension/module/module.h>
-#include <executorch/extension/tensor/tensor.h>
-
-namespace executorch {
-namespace extension {
-namespace llm {
-
-/**
- * @brief Base class for managing input/output operations for LLM inference.
- *
- * IOManager provides an interface for handling the input preparation and
- * output processing for both prefill and decode phases of LLM inference.
- * Derived classes must implement the virtual methods to provide specific IO
- * management functionality.
- */
-class IOManager {
-public:
-  /**
-   * @brief Construct an IOManager bound to a Module.
-   *
-   * @param module The Module used for querying method metadata and execution.
-   */
-  explicit IOManager(ET_MODULE_NAMESPACE::Module &module) : module_(module) {}
-
-  /**
-   * @brief Virtual destructor to allow proper cleanup in derived classes.
-   */
-  virtual ~IOManager() = default;
-
-  /**
-   * @brief Load the IO manager with method metadata for prefill and
-   * decode operations.
-   *
-   * @param prefill_method The prefill method to initialize with.
-   * @param decode_method The decode method to initialize with.
-   */
-  ET_NODISCARD virtual runtime::Error load(const std::string &prefill_method,
-                                           const std::string &decode_method) {
-    (void)prefill_method;
-    (void)decode_method;
-    return runtime::Error::Ok;
-  }
-
-  /**
-   * @brief Load the IO manager using the default method names.
-   *
-   * Uses "forward" for both prefill and decode.
-   *
-   * @return Error code.
-   */
-  ET_NODISCARD runtime::Error load() { return load("forward", "forward"); }
-
-  /**
-   * @brief Reset the IO manager state.
-   *
-   * @param prefill_method The prefill method to reset with.
-   * @param decode_method The decode method to reset with.
-   */
-  ET_NODISCARD virtual runtime::Error reset(const std::string &prefill_method,
-                                            const std::string &decode_method) {
-    (void)prefill_method;
-    (void)decode_method;
-    return runtime::Error::Ok;
-  }
-
-  /**
-   * @brief Reset the IO manager state using the default method names.
-   *
-   * Uses "forward" for both prefill and decode.
-   *
-   * @return Error code.
-   */
-  ET_NODISCARD runtime::Error reset() { return reset("forward", "forward"); }
-
-  /**
-   * @brief Prepare inputs for the prefill phase of LLM inference.
-   *
-   * @param input The input tensor containing token IDs.
-   * @param start_pos The tensor containing the starting position of the current
-   * input within the context.
-   * @param prefill_method The prefill method to prepare inputs for.
-   * @return std::vector<runtime::EValue> Vector of prepared inputs
-   * for the prefill method.
-   */
-  virtual runtime::Result<std::vector<runtime::EValue>>
-  prepare_prefill(const TensorPtr &input, const TensorPtr &start_pos,
-                  const std::string &prefill_method) {
-    auto method_meta = module_.method_meta(prefill_method);
-    if (!method_meta.ok()) {
-      return method_meta.error();
-    }
-    if (method_meta->num_inputs() != 2) {
-      ET_LOG(Error,
-             "Expected 2 inputs for prefill method, got %zu. Likely the model "
-             "takes the caches or mask as an argument which this IOManager "
-             "does not support.",
-             method_meta->num_inputs());
-      return runtime::Error::InvalidState;
-    }
-    // Cpu IO Manager supports dynamic shapes for prefill, so no work to be done
-    // here.
-    return std::vector<runtime::EValue>{input, start_pos};
-  }
-
-  /**
-   * @brief Prepare inputs for the prefill phase using the default method name.
-   *
-   * Uses "forward" as the prefill method.
-   *
-   * @param input The input tensor containing token IDs.
-   * @param start_pos The tensor containing the starting position.
-   * @return Vector of prepared inputs for the prefill method.
-   */
-  runtime::Result<std::vector<runtime::EValue>>
-  prepare_prefill(const TensorPtr &input, const TensorPtr &start_pos) {
-    return prepare_prefill(input, start_pos, "forward");
-  }
-
-  /**
-   * @brief Prepare inputs for the decode phase of LLM inference.
-   *
-   * @param input The input tensor containing token IDs.
-   * @param start_pos The tensor containing the starting position of the current
-   * input within the context.
-   * @param decode_method The decode method to prepare inputs for.
-   * @return std::vector<runtime::EValue> Vector of prepared inputs
-   * for the decode method.
-   */
-  virtual runtime::Result<std::vector<runtime::EValue>>
-  prepare_decode(const TensorPtr &input, const TensorPtr &start_pos,
-                 const std::string &decode_method) {
-    auto method_meta = module_.method_meta(decode_method);
-    if (!method_meta.ok()) {
-      return method_meta.error();
-    }
-    if (method_meta->num_inputs() != 2) {
-      ET_LOG(Error,
-             "Expected 2 inputs for decode method, got %zu. Likely the model "
-             "takes the caches or mask as an argument which this IOManager "
-             "does not support.",
-             method_meta->num_inputs());
-      return runtime::Error::InvalidState;
-    }
-    // Cpu IO Manager supports dynamic shapes for prefill, so no work to be done
-    // here.
-    return std::vector<runtime::EValue>{input, start_pos};
-  }
-
-  /**
-   * @brief Prepare inputs for the decode phase using the default method name.
-   *
-   * Uses "forward" as the decode method.
-   *
-   * @param input The input tensor containing token IDs.
-   * @param start_pos The tensor containing the starting position.
-   * @return Vector of prepared inputs for the decode method.
-   */
-  runtime::Result<std::vector<runtime::EValue>>
-  prepare_decode(const TensorPtr &input, const TensorPtr &start_pos) {
-    return prepare_decode(input, start_pos, "forward");
-  }
-
-  /**
-   * @brief Process and update internal state with outputs from the prefill
-   * phase.
-   *
-   * @param prefill_method The prefill method to update with outputs.
-   * @param model_outputs Vector of outputs from the prefill method execution.
-   */
-  ET_NODISCARD virtual runtime::Error
-  update_prefill(const std::vector<runtime::EValue> &model_outputs,
-                 const std::string &prefill_method) {
-    (void)model_outputs;
-    (void)prefill_method;
-    // No post inference work to do.
-    return runtime::Error::Ok;
-  }
-
-  /**
-   * @brief Process outputs from the prefill phase using the default method.
-   *
-   * Uses "forward" as the prefill method.
-   *
-   * @param model_outputs Vector of outputs from the prefill execution.
-   * @return Error code.
-   */
-  ET_NODISCARD runtime::Error
-  update_prefill(const std::vector<runtime::EValue> &model_outputs) {
-    return update_prefill(model_outputs, "forward");
-  }
-
-  /**
-   * @brief Process and update internal state with outputs from the decode
-   * phase.
-   *
-   * @param decode_method The decode method to update with outputs.
-   * @param model_outputs Vector of outputs from the decode method execution.
-   */
-  ET_NODISCARD virtual runtime::Error
-  update_decode(const std::vector<runtime::EValue> &model_outputs,
-                const std::string &decode_method) {
-    (void)model_outputs;
-    (void)decode_method;
-    // No post inference work to do.
-    return runtime::Error::Ok;
-  }
-
-  /**
-   * @brief Process outputs from the decode phase using the default method.
-   *
-   * Uses "forward" as the decode method.
-   *
-   * @param model_outputs Vector of outputs from the decode execution.
-   * @return Error code.
-   */
-  ET_NODISCARD runtime::Error
-  update_decode(const std::vector<runtime::EValue> &model_outputs) {
-    return update_decode(model_outputs, "forward");
-  }
-
-private:
-  /**
-   * @brief Reference to the Module used for method metadata and execution.
-   */
-  ET_MODULE_NAMESPACE::Module &module_;
-};
-
-} // namespace llm
-} // namespace extension
-} // namespace executorch
diff --git a/packages/react-native-executorch/common/runner/irunner.h b/packages/react-native-executorch/common/runner/irunner.h
deleted file mode 100644
index 4e5b14444a..0000000000
--- a/packages/react-native-executorch/common/runner/irunner.h
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// Interface for text generation runners.
-
-#pragma once
-
-#include "stats.h"
-
-#include <cstdint>
-#include <functional>
-#include <memory>
-#include <string>
-
-#include <executorch/runtime/core/error.h>
-
-namespace executorch {
-namespace extension {
-namespace llm {
-
-// Configuration struct for generation parameters
-struct GenerationConfig {
-  // Whether to echo the input prompt in the output
-  bool echo = false;
-
-  // Whether this is a warmup run (affects perf benchmarking)
-  bool warming = false;
-
-  // Maximum number of new tokens to generate
-  // If the max_context_len metadata that's serialized in the .pte file exists,
-  // then the number of prompt tokens + max_new_tokens won't exceed
-  // max_context_len. If this field is -1, it means we will rely on
-  // max_context_len metadata and seq_len value.
-  int32_t max_new_tokens = -1;
-
-  // Maximum number of total tokens
-  // If the .pte file contains the max_context_len metadata, it will override
-  // this value if it's smaller. If this field is -1, we will use the
-  // max_context_len metadata directly.
-  int32_t max_seq_len = -1;
-
-  // Maximum context length
-  // If the .pte file contains the max_context_len metadata, it will override
-  // this value if it's smaller. If this field is -1, we will use the
-  // max_context_len metadata directly.
-  int32_t max_context_length = -1;
-
-  // Temperature for sampling (higher = more random)
-  float temperature = -1.F;
-
-  // Top-p (nucleus sampling) – limits next token selection to the smallest set
-  // whose cumulative probability exceeds topp. Range: 0.0 to 1.0. Lower values
-  // = more deterministic, higher = more diverse generations.
-  float topp = -1.F;
-
-  // Minimum probability threshold: tokens with prob < min_p * max_prob are
-  // excluded. 0.0 disables min_p filtering.
-  float min_p = 0.0f;
-
-  // Multiplicative penalty applied to logits of recently generated tokens.
-  // Values > 1.0 discourage repetition. 1.0 disables the penalty.
-  float repetition_penalty = 1.0f;
-
-  // Token-batching parameters for the streaming token callback. The
-  // generator flushes a batch when either `output_token_batch_size` tokens
-  // have accumulated or `batch_time_interval_ms` milliseconds have elapsed
-  // since the last flush, whichever comes first.
-  size_t output_token_batch_size = 10;
-  size_t batch_time_interval_ms = 120;
-
-  // Top-k sampling – keep only the k highest-logit tokens before softmax.
-  // 0 (default) disables top-k filtering. Stacks with topp: temperature ->
-  // top-k -> top-p -> softmax -> multinomial.
-  int32_t topk = 0;
-
-  // Enable dynamic input shapes (if implemented) or not
-  // Impacts the prefill phase and causes TextPrefiller to pass all the tokens
-  // at once if set to true.
-  bool enable_dynamic_shape = true;
-
-  // Use KV_CACHE implementation (if implemented) or not
-  bool enable_kv_cache = true;
-
-  // Number of eos and bos to add to the prompt
-  int32_t num_bos = 0;
-  int32_t num_eos = 0;
-};
-
-// Base interface for LLM runners
-class IRunner {
-public:
-  virtual ~IRunner() = default;
-
-  /**
-   * Check if the runner is loaded and ready for inference.
-   *
-   * @return true if the runner is loaded, false otherwise
-   */
-  virtual bool is_loaded() const = 0;
-
-  /**
-   * Load the model and prepare for inference.
-   *
-   * @return Error::Ok if successful, an error otherwise
-   */
-  virtual runtime::Error load() = 0;
-
-  /**
-   * Generate text based on the provided prompt and generation config.
-   *
-   * @param prompt The input prompt to generate from
-   * @param config Generation configuration parameters
-   * @param token_callback Callback function called for each generated token
-   * @param stats_callback Callback function for generation statistics
-   * @return Error::Ok if successful, an error otherwise
-   */
-  virtual runtime::Error
-  generate(const std::string &prompt, const GenerationConfig &config,
-           std::function<void(const std::string &)> token_callback,
-           std::function<void(const Stats &)> stats_callback) = 0;
-
-  /**
-   * Stop the generation process.
-   */
-  virtual void stop() = 0;
-
-  /**
-   * Force remove prefilled tokens and reset KV cache start position
-   *
-   * This method removes the prefilled tokens from the KV cache and resets the
-   * start position to 0.
-   */
-  virtual void reset() = 0;
-};
-
-} // namespace llm
-} // namespace extension
-} // namespace executorch
diff --git a/packages/react-native-executorch/common/runner/kernel_includes.h b/packages/react-native-executorch/common/runner/kernel_includes.h
deleted file mode 100644
index bafaf80e72..0000000000
--- a/packages/react-native-executorch/common/runner/kernel_includes.h
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @file
- *
- * Common includes used by all kernel implementations.
- */
-
-#pragma once
-
-// This list should be very conservative since most kernel .cpp files will
-// include these and depend on their transitive deps. Only add a header if
-// 99% of kernels would have included it anyway.
-#include <executorch/runtime/core/exec_aten/exec_aten.h> // IWYU pragma: export
-#include <executorch/runtime/core/exec_aten/util/scalar_type_util.h> // IWYU pragma: export
-#include <executorch/runtime/core/exec_aten/util/tensor_util.h> // IWYU pragma: export
-#include <executorch/runtime/kernel/kernel_runtime_context.h> // IWYU pragma: export
diff --git a/packages/react-native-executorch/common/runner/multimodal_decoder_runner.h b/packages/react-native-executorch/common/runner/multimodal_decoder_runner.h
deleted file mode 100644
index 8d83c1fa64..0000000000
--- a/packages/react-native-executorch/common/runner/multimodal_decoder_runner.h
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// Ported from executorch/extension/llm/runner/multimodal_decoder_runner.h
-
-#pragma once
-
-#include "constants.h"
-#include "text_decoder_runner.h"
-
-namespace executorch::extension::llm {
-// Supports two PTE contracts, selected per-call from the kHasPLE metadata
-// key (mirrors how kEnableDynamicShape etc. are read — queried on demand,
-// not cached in a member). Callers that need it multiple times in a hot
-// path should snapshot into a local.
-//
-//  * Legacy (has_ple == false):
-//      token_embedding(ids) -> inputs_embeds
-//      text_decoder(inputs_embeds, input_pos)
-//
-//  * Gemma-style PLE (has_ple == true):
-//      token_embedding(ids) -> (inputs_embeds, ple_tok)
-//      text_decoder(inputs_embeds, ple_tok, input_pos)
-//    ple_tok carries Gemma4's per-layer PLE signal keyed on input_ids. It's
-//    computed once in token_embedding and threaded through every decoder call
-//    so PLE fires at every position (including multimodal placeholder slots).
-class MultimodalDecoderRunner : public TextDecoderRunner {
-public:
-  explicit MultimodalDecoderRunner(Module &module, IOManager *io_manager,
-                                   const GenerationConfig &config)
-      : TextDecoderRunner(module, io_manager, config) {}
-
-  bool has_ple() const {
-    auto r = module_->get(kHasPLE);
-    if (r.error() != ::executorch::runtime::Error::Ok) {
-      return false;
-    }
-    return r->toScalar().to<bool>();
-  }
-
-  inline ::executorch::runtime::Result<::executorch::aten::Tensor>
-  step(TensorPtr &tokens, int64_t start_pos) override {
-    auto embed_result = module_->execute(kTokenEmbeddingMethod, tokens);
-    if (!embed_result.ok()) {
-      return embed_result.error();
-    }
-    auto &embed_outputs = *embed_result;
-    if (has_ple()) {
-      ET_CHECK_MSG(embed_outputs.size() == 2,
-                   "Expected 2 outputs (inputs_embeds, ple_tok) from "
-                   "token_embedding, got %zu",
-                   embed_outputs.size());
-      return decode(embed_outputs[0], embed_outputs[1], start_pos);
-    }
-    return decode(embed_outputs[0], start_pos);
-  }
-
-  inline ::executorch::runtime::Result<::executorch::aten::Tensor>
-  decode(const ::executorch::runtime::EValue &embeddings, int64_t start_pos) {
-    auto start_pos_tensor = ::executorch::extension::from_blob(
-        &start_pos, {1}, ::executorch::aten::ScalarType::Long);
-    auto outputs_result =
-        module_->execute(kTextModelMethod, {embeddings, start_pos_tensor});
-    if (!outputs_result.ok()) {
-      return outputs_result.error();
-    }
-    auto &outputs = *outputs_result;
-    ET_CHECK_MSG(outputs.size() == 1,
-                 "Expected 1 output from text_decoder, got %zu",
-                 outputs.size());
-    ET_CHECK_MSG(outputs[0].isTensor(), "text_decoder output is not a tensor");
-    return outputs[0].toTensor();
-  }
-
-  inline ::executorch::runtime::Result<::executorch::aten::Tensor>
-  decode(const ::executorch::runtime::EValue &embeddings,
-         const ::executorch::runtime::EValue &ple_tok, int64_t start_pos) {
-    auto start_pos_tensor = ::executorch::extension::from_blob(
-        &start_pos, {1}, ::executorch::aten::ScalarType::Long);
-    auto outputs_result = module_->execute(
-        kTextModelMethod, {embeddings, ple_tok, start_pos_tensor});
-    if (!outputs_result.ok()) {
-      return outputs_result.error();
-    }
-    auto &outputs = *outputs_result;
-    ET_CHECK_MSG(outputs.size() == 1,
-                 "Expected 1 output from text_decoder, got %zu",
-                 outputs.size());
-    ET_CHECK_MSG(outputs[0].isTensor(), "text_decoder output is not a tensor");
-    return outputs[0].toTensor();
-  }
-
-  inline ::executorch::runtime::Error load() override {
-    if (is_method_loaded()) {
-      return ::executorch::runtime::Error::Ok;
-    }
-    ET_CHECK_OK_OR_RETURN_ERROR(module_->load_method(kTokenEmbeddingMethod));
-    ET_CHECK_OK_OR_RETURN_ERROR(module_->load_method(kTextModelMethod));
-    return ::executorch::runtime::Error::Ok;
-  }
-
-  inline bool is_method_loaded() override {
-    return module_->is_method_loaded(kTokenEmbeddingMethod) &&
-           module_->is_method_loaded(kTextModelMethod);
-  }
-};
-
-} // namespace executorch::extension::llm
diff --git a/packages/react-native-executorch/common/runner/multimodal_input.h b/packages/react-native-executorch/common/runner/multimodal_input.h
deleted file mode 100644
index b49da0561f..0000000000
--- a/packages/react-native-executorch/common/runner/multimodal_input.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// Ported from executorch/extension/llm/runner/multimodal_input.h
-// Audio support stripped — only text and image are used by LFM2-VL.
-
-#pragma once
-
-#include <string>
-#include <variant>
-#include <vector>
-
-namespace executorch::extension::llm {
-struct ImagePath {
-  std::string path;
-};
-
-struct AudioWaveform {
-  std::vector<float> samples;
-};
-
-class MultimodalInput {
-public:
-  explicit MultimodalInput(std::string text) : data_(std::move(text)) {}
-  explicit MultimodalInput(std::vector<uint64_t> tokens)
-      : data_(std::move(tokens)) {}
-  explicit MultimodalInput(ImagePath image_path)
-      : data_(std::move(image_path)) {}
-  explicit MultimodalInput(AudioWaveform audio) : data_(std::move(audio)) {}
-
-  MultimodalInput(const MultimodalInput &) = default;
-  MultimodalInput &operator=(const MultimodalInput &) = default;
-  MultimodalInput(MultimodalInput &&) noexcept = default;
-  MultimodalInput &operator=(MultimodalInput &&) noexcept = default;
-
-  bool is_text() const noexcept {
-    return std::holds_alternative<std::string>(data_);
-  }
-  bool is_tokens() const noexcept {
-    return std::holds_alternative<std::vector<uint64_t>>(data_);
-  }
-  bool is_image() const noexcept {
-    return std::holds_alternative<ImagePath>(data_);
-  }
-  bool is_audio() const noexcept {
-    return std::holds_alternative<AudioWaveform>(data_);
-  }
-
-  const std::string &get_text() const & { return std::get<std::string>(data_); }
-  const std::vector<uint64_t> &get_tokens() const & {
-    return std::get<std::vector<uint64_t>>(data_);
-  }
-  const std::string &get_image_path() const & {
-    return std::get<ImagePath>(data_).path;
-  }
-  const AudioWaveform &get_audio() const & {
-    return std::get<AudioWaveform>(data_);
-  }
-
-private:
-  std::variant<std::string, std::vector<uint64_t>, ImagePath, AudioWaveform>
-      data_;
-};
-
-inline MultimodalInput make_text_input(const std::string &text) noexcept {
-  return MultimodalInput(text);
-}
-inline MultimodalInput make_text_input(std::string &&text) noexcept {
-  return MultimodalInput(std::move(text));
-}
-inline MultimodalInput make_image_input(std::string path) noexcept {
-  return MultimodalInput(ImagePath{std::move(path)});
-}
-inline MultimodalInput make_audio_input(std::vector<float> samples) noexcept {
-  return MultimodalInput(AudioWaveform{std::move(samples)});
-}
-
-} // namespace executorch::extension::llm
diff --git a/packages/react-native-executorch/common/runner/multimodal_prefiller.cpp b/packages/react-native-executorch/common/runner/multimodal_prefiller.cpp
deleted file mode 100644
index 8b04dc39bf..0000000000
--- a/packages/react-native-executorch/common/runner/multimodal_prefiller.cpp
+++ /dev/null
@@ -1,459 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// Ported from executorch/extension/llm/runner/multimodal_prefiller.cpp
-// with our token-embedding padding fix and LFM2-VL adaptations.
-
-#include "multimodal_prefiller.h"
-#include "constants.h"
-#include "util.h"
-#include <algorithm>
-#include <cstring>
-#include <rnexecutorch/Log.h>
-#include <string>
-
-namespace executorch::extension::llm {
-
-using ::executorch::aten::SizesType;
-using ::executorch::runtime::Error;
-using ::executorch::runtime::EValue;
-using ::executorch::runtime::Result;
-
-MultimodalPrefiller::MultimodalPrefiller(
-    Module &module, MultimodalDecoderRunner &decoder_runner,
-    tokenizers::HFTokenizer &tokenizer,
-    std::unordered_map<std::string, int64_t> metadata, IEncoder *image_encoder,
-    IEncoder *audio_encoder)
-    : module_(&module), decoder_runner_(&decoder_runner),
-      tokenizer_(&tokenizer), metadata_(metadata),
-      image_encoder_(image_encoder), audio_encoder_(audio_encoder) {}
-
-int64_t MultimodalPrefiller::get_max_seq_len() const {
-  auto r = module_->get(kMaxSeqLen);
-  if (r.error() != ::executorch::runtime::Error::Ok) {
-    return metadata_.at(kMaxSeqLen);
-  }
-  return r->toScalar().to<int64_t>();
-}
-
-int64_t MultimodalPrefiller::get_max_context_len() const {
-  auto r = module_->get(kMaxContextLen);
-  if (r.error() != ::executorch::runtime::Error::Ok) {
-    return metadata_.at(kMaxContextLen) || get_max_seq_len();
-  }
-  return r->toScalar().to<int64_t>();
-}
-
-bool MultimodalPrefiller::get_enable_dynamic_shape() const {
-  auto r = module_->get(kEnableDynamicShape);
-  if (r.error() != ::executorch::runtime::Error::Ok) {
-    return metadata_.at(kEnableDynamicShape);
-  }
-  return r->toScalar().to<bool>();
-}
-
-[[nodiscard]] auto MultimodalPrefiller::processMultimodalInput(
-    const MultimodalInput &input, std::vector<int64_t> &ids,
-    std::vector<Types::ImageSlot> &image_slots,
-    std::vector<Types::AudioSlot> &audio_slots) {
-  if (input.is_image()) {
-    ET_CHECK_OR_RETURN_ERROR(image_encoder_ != nullptr, InvalidState,
-                             "No image encoder registered");
-    const int32_t num_visual = image_encoder_->encoderTokenCount();
-    ET_CHECK_OR_RETURN_ERROR(num_visual > 0, InvalidState,
-                             "Image encoder reports 0 visual tokens");
-    image_slots.push_back(Types::ImageSlot{&input,
-                                           static_cast<int64_t>(ids.size()),
-                                           static_cast<int64_t>(num_visual)});
-    ids.insert(ids.end(), static_cast<size_t>(num_visual), 0);
-  } else if (input.is_audio()) {
-    ET_CHECK_OR_RETURN_ERROR(audio_encoder_ != nullptr, InvalidState,
-                             "No audio encoder registered");
-    auto enc = audio_encoder_->encode(input);
-    ET_CHECK_OK_OR_RETURN_ERROR(enc.error(), "Audio encoding failed");
-    // Snapshot the encoder output NOW — see AudioSlot comment above for
-    // why the returned EValue's tensor metadata can't survive past the
-    // next module_->execute(). num_audio and audio_hidden are read from
-    // the tensor directly rather than from encoderTokenCount() so they
-    // are guaranteed to reflect THIS encode call.
-    auto audio_tensor = enc->toTensor();
-    ET_CHECK_OR_RETURN_ERROR(audio_tensor.dim() == 3, InvalidState,
-                             "audio_encoder output rank=%zd, expected 3",
-                             audio_tensor.dim());
-    const int64_t num_audio = static_cast<int64_t>(audio_tensor.size(1));
-    const int64_t audio_hidden = static_cast<int64_t>(audio_tensor.size(2));
-    ET_CHECK_OR_RETURN_ERROR(num_audio > 0, InvalidState,
-                             "Audio encoder produced 0 tokens");
-    std::vector<uint8_t> bytes(audio_tensor.nbytes());
-    std::memcpy(bytes.data(), audio_tensor.const_data_ptr(),
-                audio_tensor.nbytes());
-    audio_slots.push_back(Types::AudioSlot{
-        std::move(bytes), audio_tensor.scalar_type(),
-        static_cast<int64_t>(ids.size()), num_audio, audio_hidden});
-    ids.insert(ids.end(), static_cast<size_t>(num_audio), 0);
-  } else if (input.is_text()) {
-    auto encode_result = tokenizer_->encode(input.get_text());
-    if (!encode_result.ok()) {
-      ET_LOG(Error, "Tokenizer encode error %d",
-             static_cast<uint32_t>(encode_result.error()));
-      return Error::InvalidArgument;
-    }
-    std::vector<uint64_t> tokens = std::move(*encode_result);
-    for (auto t : tokens) {
-      ids.push_back(static_cast<int64_t>(t));
-    }
-  } else if (input.is_tokens()) {
-    std::vector<uint64_t> tokens = input.get_tokens();
-    for (auto t : tokens) {
-      ids.push_back(static_cast<int64_t>(t));
-    }
-  } else {
-    ET_LOG(Error, "Unsupported MultimodalInput type");
-    return Error::NotSupported;
-  }
-  return ::executorch::runtime::Error::Ok;
-}
-
-[[nodiscard]] auto MultimodalPrefiller::encodeAudio(
-    const Types::AudioSlot &slot, const auto hidden,
-    std::vector<uint8_t> &embeds_buf, const size_t embeds_elem_size,
-    const ::executorch::aten::ScalarType &embeds_dtype) {
-  ET_CHECK_OR_RETURN_ERROR(
-      slot.audio_hidden == static_cast<int64_t>(hidden), InvalidState,
-      "audio encoder hidden %lld != text_embed hidden %lld",
-      static_cast<long long>(slot.audio_hidden),
-      static_cast<long long>(hidden));
-
-  const auto audio_dtype = slot.dtype;
-  const size_t audio_elems =
-      static_cast<size_t>(slot.num_audio) * static_cast<size_t>(hidden);
-  const size_t audio_elem_size =
-      audio_elems > 0 ? slot.bytes.size() / audio_elems : 0;
-  ET_CHECK_OR_RETURN_ERROR(
-      audio_elem_size > 0 && audio_elem_size * audio_elems == slot.bytes.size(),
-      InvalidState,
-      "audio slot bytes %zu inconsistent with num_audio=%lld hidden=%lld",
-      slot.bytes.size(), static_cast<long long>(slot.num_audio),
-      static_cast<long long>(hidden));
-
-  uint8_t *dst = embeds_buf.data() + static_cast<size_t>(slot.slot_start) *
-                                         static_cast<size_t>(hidden) *
-                                         embeds_elem_size;
-
-  if (audio_dtype == embeds_dtype) {
-    std::memcpy(dst, slot.bytes.data(), audio_elems * embeds_elem_size);
-  } else if (audio_dtype == ::executorch::aten::ScalarType::Float &&
-             embeds_dtype == ::executorch::aten::ScalarType::Half) {
-    const float *src = reinterpret_cast<const float *>(slot.bytes.data());
-    auto *dst_h = reinterpret_cast<::executorch::aten::Half *>(dst);
-    for (size_t i = 0; i < audio_elems; ++i) {
-      dst_h[i] = ::executorch::aten::Half(src[i]);
-    }
-  } else if (audio_dtype == ::executorch::aten::ScalarType::Half &&
-             embeds_dtype == ::executorch::aten::ScalarType::Float) {
-    const auto *src =
-        reinterpret_cast<const ::executorch::aten::Half *>(slot.bytes.data());
-    auto *dst_f = reinterpret_cast<float *>(dst);
-    for (size_t i = 0; i < audio_elems; ++i) {
-      dst_f[i] = static_cast<float>(src[i]);
-    }
-  } else {
-    ET_CHECK_OR_RETURN_ERROR(
-        false, InvalidState,
-        "unsupported audio/text dtype pair: audio=%hhd text=%hhd",
-        static_cast<int8_t>(audio_dtype), static_cast<int8_t>(embeds_dtype));
-  }
-  return ::executorch::runtime::Error::Ok;
-}
-
-[[nodiscard]] auto MultimodalPrefiller::encodeImages(
-    const Types::ImageSlot &slot, const auto hidden,
-    std::vector<uint8_t> &embeds_buf, const size_t embeds_elem_size,
-    const ::executorch::aten::ScalarType &embeds_dtype) {
-  auto encode_result = image_encoder_->encode(*slot.input);
-  ET_CHECK_OK_OR_RETURN_ERROR(encode_result.error(), "Image encoding failed");
-  auto encoder_output = *encode_result;
-  auto vision_tensor = encoder_output.toTensor();
-
-  const auto vision_dtype = vision_tensor.scalar_type();
-  const size_t visual_elems =
-      static_cast<size_t>(slot.num_visual) * static_cast<size_t>(hidden);
-  uint8_t *dst = embeds_buf.data() + static_cast<size_t>(slot.slot_start) *
-                                         static_cast<size_t>(hidden) *
-                                         embeds_elem_size;
-  if (vision_dtype == embeds_dtype) {
-    const uint8_t *src =
-        static_cast<const uint8_t *>(vision_tensor.const_data_ptr());
-    std::memcpy(dst, src, visual_elems * embeds_elem_size);
-  } else if (vision_dtype == ::executorch::aten::ScalarType::Float &&
-             embeds_dtype == ::executorch::aten::ScalarType::Half) {
-    const float *src = vision_tensor.const_data_ptr<float>();
-    auto *dst_h = reinterpret_cast<::executorch::aten::Half *>(dst);
-    for (size_t i = 0; i < visual_elems; ++i) {
-      dst_h[i] = ::executorch::aten::Half(src[i]);
-    }
-  } else if (vision_dtype == ::executorch::aten::ScalarType::Half &&
-             embeds_dtype == ::executorch::aten::ScalarType::Float) {
-    const auto *src = vision_tensor.const_data_ptr<::executorch::aten::Half>();
-    auto *dst_f = reinterpret_cast<float *>(dst);
-    for (size_t i = 0; i < visual_elems; ++i) {
-      dst_f[i] = static_cast<float>(src[i]);
-    }
-  } else {
-    ET_CHECK_OR_RETURN_ERROR(
-        false, InvalidState,
-        "unsupported vision/text dtype pair: vision=%hhd text=%hhd",
-        static_cast<int8_t>(vision_dtype), static_cast<int8_t>(embeds_dtype));
-  }
-  return ::executorch::runtime::Error::Ok;
-}
-
-[[nodiscard]] auto
-MultimodalPrefiller::initializePLE(auto &embed_outputs, auto total_len,
-                                   Types::PLEEmbeddings &ple_embeddings) {
-  auto full_ple_tok = embed_outputs[1].toTensor();
-  ple_embeddings.num_layers = static_cast<SizesType>(full_ple_tok.size(2));
-  ple_embeddings.ple_dim = static_cast<SizesType>(full_ple_tok.size(3));
-  ple_embeddings.ple_tok_dtype = full_ple_tok.scalar_type();
-  const size_t total_numel = static_cast<size_t>(full_ple_tok.numel());
-  const size_t total_bytes = full_ple_tok.nbytes();
-  ET_CHECK_OR_RETURN_ERROR(total_numel > 0, InvalidState,
-                           "ple_tok has zero elements");
-  ple_embeddings.ple_elem_size = total_bytes / total_numel;
-  const size_t prefix_bytes = static_cast<size_t>(total_len) *
-                              static_cast<size_t>(ple_embeddings.num_layers) *
-                              static_cast<size_t>(ple_embeddings.ple_dim) *
-                              ple_embeddings.ple_elem_size;
-  ple_embeddings.ple_tok_buf.resize(prefix_bytes);
-  std::memcpy(ple_embeddings.ple_tok_buf.data(),
-              full_ple_tok.mutable_data_ptr(), prefix_bytes);
-  return ::executorch::runtime::Error::Ok;
-}
-
-[[nodiscard]] auto MultimodalPrefiller::prefillChunk(
-    std::vector<EValue> &last_outs, std::vector<uint8_t> &embeds_buf,
-    auto chunk_start, auto chunk_len, auto hidden, auto embeds_elem_size,
-    auto embeds_dtype, Types::PLEEmbeddings &ple_embeddings,
-    std::vector<int64_t> &cache_positions) {
-  uint8_t *embeds_chunk_ptr =
-      embeds_buf.data() + static_cast<size_t>(chunk_start) *
-                              static_cast<size_t>(hidden) * embeds_elem_size;
-  auto embeds_chunk = ::executorch::extension::from_blob(
-      embeds_chunk_ptr, {1, static_cast<SizesType>(chunk_len), hidden},
-      embeds_dtype);
-
-  TensorPtr ple_chunk;
-  if (decoder_runner_->has_ple()) {
-    uint8_t *ple_chunk_ptr =
-        ple_embeddings.ple_tok_buf.data() +
-        static_cast<size_t>(chunk_start) *
-            static_cast<size_t>(ple_embeddings.num_layers) *
-            static_cast<size_t>(ple_embeddings.ple_dim) *
-            ple_embeddings.ple_elem_size;
-    ple_chunk = ::executorch::extension::from_blob(
-        ple_chunk_ptr,
-        {1, static_cast<SizesType>(chunk_len), ple_embeddings.num_layers,
-         ple_embeddings.ple_dim},
-        ple_embeddings.ple_tok_dtype);
-  }
-
-  auto pos_chunk = ::executorch::extension::from_blob(
-      cache_positions.data() + chunk_start, {static_cast<SizesType>(chunk_len)},
-      ::executorch::aten::ScalarType::Long);
-
-  auto res = decoder_runner_->has_ple()
-                 ? module_->execute(kTextModelMethod,
-                                    {EValue(*embeds_chunk), EValue(*ple_chunk),
-                                     EValue(*pos_chunk)})
-                 : module_->execute(kTextModelMethod, {EValue(*embeds_chunk),
-                                                       EValue(*pos_chunk)});
-  ET_CHECK_OK_OR_RETURN_ERROR(res.error());
-  last_outs = std::move(*res);
-  return ::executorch::runtime::Error::Ok;
-}
-
-Result<uint64_t>
-MultimodalPrefiller::prefill(const std::vector<MultimodalInput> &inputs,
-                             int64_t &start_pos) {
-  const bool has_ple = decoder_runner_->has_ple();
-
-  ET_CHECK_OR_RETURN_ERROR(!inputs.empty(), InvalidArgument,
-                           "prefill: empty input list");
-
-  // ------------------------------------------------------------
-  //   * get_max_seq_len     — text_decoder S cap. Max prefill chunk length
-  //   (<=get_max_conetxt_len)
-  //   * get_max_context_len — total KV budget. Caps max context length for
-  //   multi-turn conversation.
-  // ------------------------------------------------------------
-  int64_t max_seq_len = get_max_seq_len();
-  int64_t max_context_len = get_max_context_len();
-  bool enable_dynamic_shape = get_enable_dynamic_shape();
-  const int64_t prefill_total_cap =
-      enable_dynamic_shape ? max_context_len : max_seq_len;
-  const int64_t decoder_chunk_size = max_seq_len;
-
-  std::vector<int64_t> ids;
-  ids.reserve(static_cast<size_t>(prefill_total_cap));
-  std::vector<Types::ImageSlot> image_slots;
-  std::vector<Types::AudioSlot> audio_slots;
-
-  for (const auto &input : inputs) {
-    auto res = processMultimodalInput(input, ids, image_slots, audio_slots);
-    if (res != ::executorch::runtime::Error::Ok) {
-      return res;
-    }
-  }
-
-  const int64_t total_len = static_cast<int64_t>(ids.size());
-  ET_CHECK_OR_RETURN_ERROR(total_len > 0, InvalidArgument,
-                           "prefill produced zero tokens");
-
-  ET_CHECK_OR_RETURN_ERROR(total_len <= prefill_total_cap, InvalidArgument,
-                           "Prefill length %lld exceeds %s (%lld)",
-                           static_cast<long long>(total_len),
-                           enable_dynamic_shape ? "get_max_context_len"
-                                                : "get_max_seq_len",
-                           static_cast<long long>(prefill_total_cap));
-  if (!enable_dynamic_shape) {
-    ids.resize(static_cast<size_t>(max_seq_len), 0);
-  }
-
-  // ------------------------------------------------------------
-  // Single token_embedding call over the fused id buffer.
-  // ------------------------------------------------------------
-  const int64_t tok_buf_len = static_cast<int64_t>(ids.size());
-  auto token_tensor = ::executorch::extension::from_blob(
-      ids.data(), {1, static_cast<SizesType>(tok_buf_len)},
-      ::executorch::aten::ScalarType::Long);
-
-  auto embed_result = module_->execute(kTokenEmbeddingMethod, token_tensor);
-  ET_CHECK_OK_OR_RETURN_ERROR(embed_result.error());
-  auto &embed_outputs = *embed_result;
-
-  auto full_embed = embed_outputs[0].toTensor();
-  const auto hidden = static_cast<SizesType>(full_embed.size(2));
-
-  // Own the embeds for the live prefix — subsequent vision_encoder.execute
-  // calls may reuse the token_embedding output buffer in the runtime.
-  const ::executorch::aten::ScalarType embeds_dtype = full_embed.scalar_type();
-  const size_t embeds_total_numel = static_cast<size_t>(full_embed.numel());
-  ET_CHECK_OR_RETURN_ERROR(embeds_total_numel > 0, InvalidState,
-                           "token_embedding returned zero elements");
-  const size_t embeds_elem_size = full_embed.nbytes() / embeds_total_numel;
-  const size_t embeds_prefix_bytes = static_cast<size_t>(total_len) *
-                                     static_cast<size_t>(hidden) *
-                                     embeds_elem_size;
-  std::vector<uint8_t> embeds_buf(embeds_prefix_bytes);
-  std::memcpy(embeds_buf.data(), full_embed.mutable_data_ptr(),
-              embeds_prefix_bytes);
-
-  // ------------------------------------------------------------
-  // Pass 2: encode images and splice their outputs into embeds_buf.
-  // ------------------------------------------------------------
-  for (const auto &slot : image_slots) {
-    auto res =
-        encodeImages(slot, hidden, embeds_buf, embeds_elem_size, embeds_dtype);
-    if (res != ::executorch::runtime::Error::Ok) {
-      return res;
-    }
-  }
-
-  // ------------------------------------------------------------
-  // Pass 2b: splice encoded audio tokens into embeds_buf. Reads from the
-  // byte snapshot taken at encode time so post-encode execute() calls can't
-  // invalidate slot state. Same dtype-conversion matrix as vision.
-  // ------------------------------------------------------------
-  for (auto &slot : audio_slots) {
-    auto res =
-        encodeAudio(slot, hidden, embeds_buf, embeds_elem_size, embeds_dtype);
-    if (res != ::executorch::runtime::Error::Ok) {
-      return res;
-    }
-  }
-
-  Types::PLEEmbeddings ple_embeddings;
-  if (has_ple) {
-    auto res = initializePLE(embed_outputs, total_len, ple_embeddings);
-    if (res != ::executorch::runtime::Error::Ok) {
-      return res;
-    }
-  }
-
-  std::vector<EValue> last_outs;
-  const int64_t chunk_cap =
-      decoder_chunk_size > 0 ? decoder_chunk_size : total_len;
-  std::vector<int64_t> cache_positions(static_cast<size_t>(total_len));
-  for (int64_t i = 0; i < total_len; ++i) {
-    cache_positions[static_cast<size_t>(i)] = start_pos + i;
-  }
-  const int64_t num_chunks = (total_len + chunk_cap - 1) / chunk_cap;
-  for (int64_t ci = 0; ci < num_chunks; ++ci) {
-    const int64_t chunk_start = ci * chunk_cap;
-    const int64_t chunk_end = std::min(chunk_start + chunk_cap, total_len);
-    const int64_t chunk_len = chunk_end - chunk_start;
-    auto res = prefillChunk(last_outs, embeds_buf, chunk_start, chunk_len,
-                            hidden, embeds_elem_size, embeds_dtype,
-                            ple_embeddings, cache_positions);
-    if (res != ::executorch::runtime::Error::Ok) {
-      return res;
-    }
-  }
-
-  ET_CHECK_OR_RETURN_ERROR(!last_outs.empty(), InvalidState,
-                           "text_decoder returned no outputs during prefill");
-
-  auto logits = last_outs[0].toTensor();
-  start_pos += total_len;
-
-  return static_cast<uint64_t>(decoder_runner_->logits_to_token(logits));
-}
-
-Error MultimodalPrefiller::load() {
-  if (is_method_loaded()) {
-    return Error::Ok;
-  }
-  ET_CHECK_OK_OR_RETURN_ERROR(module_->load_method(kTokenEmbeddingMethod));
-  ET_CHECK_OK_OR_RETURN_ERROR(module_->load_method(kTextModelMethod));
-
-  auto method_names_result = module_->method_names();
-  ET_CHECK_OK_OR_RETURN_ERROR(method_names_result.error(),
-                              "Failed to get method names");
-  const auto &methods = *method_names_result;
-
-  if (methods.find(kVisionEncoderMethod) != methods.end()) {
-    ET_CHECK_OK_OR_RETURN_ERROR(module_->load_method(kVisionEncoderMethod));
-  }
-  if (methods.find(kAudioEncoderMethod) != methods.end()) {
-    ET_CHECK_OK_OR_RETURN_ERROR(module_->load_method(kAudioEncoderMethod));
-  }
-  return Error::Ok;
-}
-
-bool MultimodalPrefiller::is_method_loaded() {
-  auto methods_res = module_->method_names();
-  if (methods_res.error() != Error::Ok) {
-    return false;
-  }
-  if (!module_->is_method_loaded(kTokenEmbeddingMethod) ||
-      !module_->is_method_loaded(kTextModelMethod)) {
-    return false;
-  }
-  const auto &methods = *methods_res;
-  if (methods.find(kVisionEncoderMethod) != methods.end() &&
-      !module_->is_method_loaded(kVisionEncoderMethod)) {
-    return false;
-  }
-  if (methods.find(kAudioEncoderMethod) != methods.end() &&
-      !module_->is_method_loaded(kAudioEncoderMethod)) {
-    return false;
-  }
-  return true;
-}
-
-} // namespace executorch::extension::llm
diff --git a/packages/react-native-executorch/common/runner/multimodal_prefiller.h b/packages/react-native-executorch/common/runner/multimodal_prefiller.h
deleted file mode 100644
index 05037d88c8..0000000000
--- a/packages/react-native-executorch/common/runner/multimodal_prefiller.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// Ported from executorch/extension/llm/runner/multimodal_prefiller.h
-
-#pragma once
-
-#include "multimodal_decoder_runner.h"
-#include "multimodal_input.h"
-#include <executorch/extension/module/module.h>
-#include <pytorch/tokenizers/hf_tokenizer.h>
-#include <runner/encoders/iencoder.h>
-
-namespace executorch::extension::llm {
-
-namespace Types {
-struct ImageSlot {
-  const MultimodalInput *input; // non-owning, valid for duration of call
-  int64_t slot_start;
-  int64_t num_visual;
-};
-
-struct AudioSlot {
-  std::vector<uint8_t> bytes;
-  ::executorch::aten::ScalarType dtype;
-  int64_t slot_start;
-  int64_t num_audio;
-  int64_t audio_hidden;
-};
-
-struct PLEEmbeddings {
-  std::vector<uint8_t> ple_tok_buf;
-  aten::SizesType num_layers = 0;
-  aten::SizesType ple_dim = 0;
-  size_t ple_elem_size = 0;
-  ::executorch::aten::ScalarType ple_tok_dtype =
-      ::executorch::aten::ScalarType::Half;
-};
-} // namespace Types
-
-class MultimodalPrefiller {
-public:
-  explicit MultimodalPrefiller(
-      Module &module, MultimodalDecoderRunner &decoder_runner,
-      tokenizers::HFTokenizer &tokenizer,
-      std::unordered_map<std::string, int64_t> metadata,
-      IEncoder *image_encoder = nullptr, IEncoder *audio_encoder = nullptr);
-
-  // Prefill one input segment. Updates start_pos in-place.
-  // Returns the first predicted token after this segment.
-  ::executorch::runtime::Result<uint64_t>
-  prefill(const std::vector<MultimodalInput> &inputs, int64_t &start_pos);
-
-  auto processMultimodalInput(const MultimodalInput &input,
-                              std::vector<int64_t> &ids,
-                              std::vector<Types::ImageSlot> &image_slots,
-                              std::vector<Types::AudioSlot> &audio_slots);
-  ::executorch::runtime::Error load();
-  bool is_method_loaded();
-  int64_t get_max_seq_len() const;
-  int64_t get_max_context_len() const;
-  bool get_enable_dynamic_shape() const;
-
-private:
-  auto encodeImages(const Types::ImageSlot &slot, const auto hidden,
-                    std::vector<uint8_t> &embeds_buf,
-                    const size_t embeds_elem_size,
-                    const ::executorch::aten::ScalarType &embeds_dtype);
-  auto encodeAudio(const Types::AudioSlot &slot, const auto hidden,
-                   std::vector<uint8_t> &embeds_buf,
-                   const size_t embeds_elem_size,
-                   const ::executorch::aten::ScalarType &embeds_dtype);
-  auto prefillChunk(std::vector<::executorch::runtime::EValue> &last_outs,
-                    std::vector<uint8_t> &embeds_buf, auto chunk_start,
-                    auto chunk_len, auto hidden, auto embeds_elem_size,
-                    auto embeds_dtype, Types::PLEEmbeddings &ple_embeddings,
-                    std::vector<int64_t> &cache_positions);
-  auto initializePLE(auto &embed_outputs, auto total_len,
-                     Types::PLEEmbeddings &ple_embeddings);
-
-  Module *module_;
-  MultimodalDecoderRunner *decoder_runner_;
-  tokenizers::HFTokenizer *tokenizer_;
-  std::unordered_map<std::string, int64_t> metadata_;
-  IEncoder *image_encoder_;
-  IEncoder *audio_encoder_;
-};
-
-} // namespace executorch::extension::llm
diff --git a/packages/react-native-executorch/common/runner/multimodal_runner.cpp b/packages/react-native-executorch/common/runner/multimodal_runner.cpp
deleted file mode 100644
index 084a7ef191..0000000000
--- a/packages/react-native-executorch/common/runner/multimodal_runner.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-// common/runner/multimodal_runner.cpp
-#include "multimodal_runner.h"
-#include "constants.h"
-#include "util.h"
-#include <rnexecutorch/Error.h>
-
-namespace executorch::extension::llm {
-
-using ::executorch::extension::Module;
-using ::executorch::runtime::Error;
-
-MultimodalRunner::MultimodalRunner(
-    std::unique_ptr<Module> module, const std::string &tokenizer_path,
-    std::map<MultimodalType, std::unique_ptr<IEncoder>> encoders,
-    const GenerationConfig &config)
-    : BaseLLMRunner(std::move(module), tokenizer_path, config),
-      encoders_(std::move(encoders)) {}
-
-int32_t MultimodalRunner::get_visual_token_count() const {
-  auto it = encoders_.find(MultimodalType::Image);
-  if (it == encoders_.end()) {
-    return 0;
-  }
-  return it->second->encoderTokenCount();
-}
-
-bool MultimodalRunner::is_loaded() const {
-  if (!mm_prefiller_ || !mm_token_generator_) {
-    return false;
-  }
-  if (!mm_prefiller_->is_method_loaded() || !mm_token_generator_->is_loaded()) {
-    return false;
-  }
-  for (const auto &[type, encoder] : encoders_) {
-    if (!encoder->is_loaded()) {
-      return false;
-    }
-  }
-  return true;
-}
-
-Error MultimodalRunner::load_subcomponents() {
-  for (auto &[type, encoder] : encoders_) {
-    ET_CHECK_OK_OR_RETURN_ERROR(encoder->load());
-  }
-
-  Stats *stats_ptr = &stats_;
-
-  mm_decoder_runner_ = std::make_unique<MultimodalDecoderRunner>(
-      *module_, io_manager_.get(), config_);
-  IEncoder *image_encoder = nullptr;
-  auto enc_it = encoders_.find(MultimodalType::Image);
-  if (enc_it != encoders_.end()) {
-    image_encoder = enc_it->second.get();
-  }
-  IEncoder *audio_encoder = nullptr;
-  auto aud_it = encoders_.find(MultimodalType::Audio);
-  if (aud_it != encoders_.end()) {
-    audio_encoder = aud_it->second.get();
-  }
-  mm_prefiller_ = std::make_unique<MultimodalPrefiller>(
-      *module_, *mm_decoder_runner_, *tokenizer_, metadata_, image_encoder,
-      audio_encoder);
-  mm_token_generator_ = std::make_unique<TextTokenGenerator>(
-      tokenizer_.get(), mm_decoder_runner_.get(), /*use_kv_cache=*/true,
-      std::move(eos_ids_), stats_ptr, config_);
-
-  ET_CHECK_OK_OR_RETURN_ERROR(mm_prefiller_->load());
-  ET_CHECK_OK_OR_RETURN_ERROR(mm_token_generator_->load());
-
-  return Error::Ok;
-}
-
-Error MultimodalRunner::generate_internal(
-    const std::vector<MultimodalInput> &inputs,
-    std::function<void(const std::string &)> token_callback) {
-
-  if (inputs.empty()) {
-    return Error::InvalidArgument;
-  }
-  if (!is_loaded()) {
-    ET_CHECK_OK_OR_RETURN_ERROR(load());
-  }
-
-  stats_.inference_start_ms = time_in_ms();
-  auto prefill_result = mm_prefiller_->prefill(inputs, pos_);
-  if (!prefill_result.ok())
-    return prefill_result.error();
-  uint64_t prefill_next_token = prefill_result.get();
-
-  stats_.first_token_ms = time_in_ms();
-  stats_.prompt_eval_end_ms = time_in_ms();
-  stats_.num_prompt_tokens = pos_;
-
-  // For dynamic-shape PTEs (Gemma4 iter*), get_max_seq_len is the per-call
-  // decoder chunk size (e.g. 128) and the true generation budget lives in
-  // get_max_context_len. Mirrors text_runner.cpp:95-97.
-  const int32_t seq_cap = config_.enable_dynamic_shape
-                              ? config_.max_context_length
-                              : config_.max_seq_len;
-  int32_t resolved_max_new = resolve_max_new_tokens(
-      static_cast<int32_t>(pos_), seq_cap, config_.max_context_length,
-      config_.max_new_tokens);
-
-  std::vector<uint64_t> seed_tokens = {prefill_next_token};
-  auto wrapped_callback = [&](const std::string &piece) {
-    safe_printf(piece.c_str());
-    fflush(stdout);
-    if (token_callback)
-      token_callback(piece);
-  };
-
-  auto generate_result = mm_token_generator_->generate(
-      seed_tokens, pos_,
-      static_cast<uint64_t>(std::max(0, resolved_max_new - 1)),
-      wrapped_callback);
-
-  if (!generate_result.ok())
-    return generate_result.error();
-
-  int64_t num_generated = generate_result.get();
-  pos_ += num_generated;
-  stats_.inference_end_ms = time_in_ms();
-  stats_.num_generated_tokens = num_generated;
-
-  return Error::Ok;
-}
-
-void MultimodalRunner::stop_impl() {
-  if (mm_token_generator_) {
-    mm_token_generator_->stop();
-  }
-}
-
-} // namespace executorch::extension::llm
diff --git a/packages/react-native-executorch/common/runner/multimodal_runner.h b/packages/react-native-executorch/common/runner/multimodal_runner.h
deleted file mode 100644
index c6180c54f0..0000000000
--- a/packages/react-native-executorch/common/runner/multimodal_runner.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-
-#include "base_llm_runner.h"
-#include "encoders/iencoder.h"
-#include "multimodal_decoder_runner.h"
-#include "multimodal_input.h"
-#include "multimodal_prefiller.h"
-#include "text_token_generator.h"
-#include <map>
-
-namespace executorch::extension::llm {
-
-enum class MultimodalType { Image, Audio };
-
-class MultimodalRunner : public BaseLLMRunner {
-public:
-  explicit MultimodalRunner(
-      std::unique_ptr<Module> module, const std::string &tokenizer_path,
-      std::map<MultimodalType, std::unique_ptr<IEncoder>> encoders,
-      const GenerationConfig &config = {.temperature = 0.8F, .topp = 0.9F});
-
-  bool is_loaded() const override;
-  bool is_multimodal() const override { return true; }
-  int32_t get_visual_token_count() const override;
-
-  ::executorch::runtime::Error generate_internal(
-      const std::vector<MultimodalInput> &inputs,
-      std::function<void(const std::string &)> token_callback) override;
-
-protected:
-  ::executorch::runtime::Error load_subcomponents() override;
-  void stop_impl() override;
-
-private:
-  std::map<MultimodalType, std::unique_ptr<IEncoder>> encoders_;
-  std::unique_ptr<MultimodalDecoderRunner> mm_decoder_runner_;
-  std::unique_ptr<MultimodalPrefiller> mm_prefiller_;
-  std::unique_ptr<TextTokenGenerator> mm_token_generator_;
-};
-
-} // namespace executorch::extension::llm
diff --git a/packages/react-native-executorch/common/runner/sampler.cpp b/packages/react-native-executorch/common/runner/sampler.cpp
deleted file mode 100644
index 8215c49be5..0000000000
--- a/packages/react-native-executorch/common/runner/sampler.cpp
+++ /dev/null
@@ -1,307 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// This is a modified version of https://github.com/karpathy/llama2.c.git
-// @lint-ignore-every LICENSELINT
-/**
- * MIT License
- *
- * Copyright (c) 2023 Andrej
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include "sampler.h"
-#include <algorithm>
-#include <ctime>
-#include <limits>
-#include <ranges>
-#include <span>
-#include <type_traits>
-#include <vector>
-
-namespace executorch {
-namespace extension {
-namespace llm {
-
-// sampler stuff
-template <typename T> int32_t Sampler::sample_argmax(T *probabilities) {
-  // return the index that has the highest probability
-  int max_i = 0;
-  T max_p = probabilities[0];
-  for (size_t i = 1; i < vocab_size_; i++) {
-    if (probabilities[i] > max_p) {
-      max_i = i;
-      max_p = probabilities[i];
-    }
-  }
-  return max_i;
-}
-
-template <typename T>
-int32_t Sampler::sample_mult(T *probabilities, float coin) {
-  // sample index from probabilities (they must sum to 1!)
-  // coin is a random number in [0, 1), usually from random_f32()
-  T cdf = 0.0;
-  for (size_t i = 0; i < vocab_size_; i++) {
-    cdf += probabilities[i];
-    if (coin < cdf) {
-      return i;
-    }
-  }
-  return vocab_size_ - 1; // in case of rounding errors
-}
-
-template <typename T>
-int32_t Sampler::sample_topp(T *probabilities, float coin) {
-  // top-p sampling (or "nucleus sampling") samples from the smallest set of
-  // tokens that exceed probability topp. This way we never sample tokens that
-  // have very low probabilities and are less likely to go "off the rails".
-  // coin is a random number in [0, 1), usually from random_f32()
-  int n = vocab_size_;
-  int n0 = 0;
-  // quicksort indices in descending order of probabilities
-  // values smaller than (1 - topp) / (n - 1) cannot be part of the result
-  // so for efficiency we crop these out as candidates before sorting
-  std::unique_ptr<ProbIndex<T>[]> probindex =
-      std::make_unique<ProbIndex<T>[]>(vocab_size_);
-
-  const float cutoff = (1.0f - topp_) / (n - 1);
-  for (size_t i = 0; i < n; i++) {
-    if (probabilities[i] >= cutoff) {
-      probindex[n0].index = i;
-      probindex[n0].prob = probabilities[i];
-      n0++;
-    }
-  }
-
-  std::sort(probindex.get(), probindex.get() + n0,
-            [](const ProbIndex<T> &a, const ProbIndex<T> &b) {
-              return a.prob > b.prob;
-            });
-
-  // truncate the list where cumulative probability exceeds topp
-  T cumulative_prob = 0;
-  int last_idx = n0 - 1;
-  for (size_t i = 0; i < n0; i++) {
-    cumulative_prob += probindex[i].prob;
-    if (static_cast<float>(cumulative_prob) > topp_) {
-      last_idx = i;
-      break;
-    }
-  }
-
-  // sample from the truncated list
-  float r = coin * static_cast<float>(cumulative_prob);
-  T cdf = 0;
-  for (size_t i = 0; i <= last_idx; i++) {
-    cdf += probindex[i].prob;
-    if (r < static_cast<float>(cdf)) {
-      return probindex[i].index;
-    }
-  }
-  return probindex[last_idx].index;
-}
-
-// Mask logits outside the top-k by rank to -inf. Ties at the k-th boundary
-// are kept (matches HuggingFace TopKLogitsWarper).
-template <typename T> void Sampler::mask_topk(T *logits) {
-  if (topk_ <= 0 || topk_ >= vocab_size_) {
-    return;
-  }
-  // Partial-select the (topk_-th largest) threshold using nth_element on a
-  // copy of logits; O(n) average.
-  std::vector<T> scratch(logits, logits + vocab_size_);
-  std::nth_element(scratch.begin(), scratch.begin() + (topk_ - 1),
-                   scratch.end(), std::greater<T>());
-  const T threshold = scratch[topk_ - 1];
-  constexpr T neg_inf = std::numeric_limits<T>::lowest();
-  for (size_t i = 0; i < vocab_size_; i++) {
-    if (logits[i] < threshold) {
-      logits[i] = neg_inf;
-    }
-  }
-}
-
-// Mask logits outside the top-p nucleus to -inf. Approximates the exact
-// sort-based nucleus with a histogram over (logit - max): two O(n) passes, no
-// sort. Binning in logit (not probability) space keeps uniform resolution for
-// peaked and flat distributions alike. kRange=40 spans exp() down to ~4e-18.
-template <typename T> void Sampler::mask_topp(T *logits) {
-  if (topp_ <= 0.0f || topp_ >= 1.0f) {
-    return;
-  }
-  constexpr int32_t kBins = 2048;
-  // Compute in a type at least as wide as T so converting logits never loses
-  // precision: double stays double, everything else (float and the narrow
-  // half/bf16/uint16 logit types) widens to float. Accumulating in T directly
-  // would be unsafe for bf16, whose mantissa saturates when summing exp()
-  // over the full vocab.
-  using acc_t = std::conditional_t<std::is_same_v<T, double>, double, float>;
-  constexpr acc_t kRange = 40;
-
-  std::span<const T> logit_span{logits, static_cast<size_t>(vocab_size_)};
-  const acc_t max_val =
-      static_cast<acc_t>(*std::ranges::max_element(logit_span));
-
-  std::vector<acc_t> bin_mass(kBins, acc_t(0));
-  acc_t total = 0;
-  for (size_t i = 0; i < vocab_size_; i++) {
-    acc_t d = static_cast<acc_t>(logits[i]) - max_val;
-    acc_t e = std::exp(d);
-    total += e;
-    int32_t bin = static_cast<int32_t>((d + kRange) / kRange * kBins);
-    bin = std::clamp(bin, 0, kBins - 1);
-    bin_mass[bin] += e;
-  }
-  if (total <= acc_t(0)) {
-    return;
-  }
-
-  // Highest bin downward until the kept mass reaches topp. The crossing bin is
-  // kept (HuggingFace "keep the token that crosses" convention).
-  const acc_t target = static_cast<acc_t>(topp_) * total;
-  acc_t acc = 0;
-  int32_t keep_bin = 0;
-  for (int32_t bin = kBins - 1; bin >= 0; --bin) {
-    acc += bin_mass[bin];
-    if (acc >= target) {
-      keep_bin = bin;
-      break;
-    }
-  }
-  const acc_t d_threshold =
-      static_cast<acc_t>(keep_bin) / kBins * kRange - kRange;
-
-  constexpr T neg_inf = std::numeric_limits<T>::lowest();
-  for (size_t i = 0; i < vocab_size_; i++) {
-    if (static_cast<acc_t>(logits[i]) - max_val < d_threshold) {
-      logits[i] = neg_inf;
-    }
-  }
-}
-
-Sampler::Sampler(int32_t vocab_size, GenerationConfig config,
-                 unsigned long long rng_seed)
-    : vocab_size_(vocab_size),
-      inv_temperature_(
-          (config.temperature != 0.0f) ? (1.0f / config.temperature) : 0.0f),
-      topp_(config.topp), min_p_(config.min_p),
-      repetition_penalty_(config.repetition_penalty), topk_(config.topk),
-      rng_state_(rng_seed) {}
-
-Sampler::Sampler(int32_t vocab_size, GenerationConfig config)
-    : Sampler(vocab_size, config, std::time(nullptr)) {}
-
-template <typename T> static void softmax(T *x, int size) {
-  // Runs after top-k/top-p masking, which sets rejected logits to lowest().
-  // Skip exp() on those: it underflows to 0 anyway and is slow on device.
-  constexpr T kMasked = std::numeric_limits<T>::lowest();
-  T max_val = x[0];
-  for (size_t i = 1; i < size; i++) {
-    if (x[i] > max_val) {
-      max_val = x[i];
-    }
-  }
-  T sum = 0;
-  for (size_t i = 0; i < size; i++) {
-    if (x[i] == kMasked) {
-      x[i] = T(0);
-      continue;
-    }
-    x[i] = expf(x[i] - max_val);
-    sum += x[i];
-  }
-  for (size_t i = 0; i < size; i++) {
-    if (x[i] != T(0)) {
-      x[i] /= sum;
-    }
-  }
-}
-
-static unsigned int random_u32(unsigned long long *state) {
-  // xorshift rng: https://en.wikipedia.org/wiki/Xorshift#xorshift.2A
-  *state ^= *state >> 12;
-  *state ^= *state << 25;
-  *state ^= *state >> 27;
-  return (*state * 0x2545F4914F6CDD1Dull) >> 32;
-}
-
-static float random_f32(unsigned long long *state) { // random float32 in [0,1)
-  return (random_u32(state) >> 8) / 16777216.0f;
-}
-
-template <typename T>
-int32_t Sampler::sample(T *logits, const std::vector<uint64_t> &recent_tokens) {
-  // sample the token given the logits and some hyperparameters
-  int next;
-  if (inv_temperature_ == 0.0f) {
-    // greedy argmax sampling: take the token with the highest probability
-    next = sample_argmax(logits);
-  } else {
-    // 1. apply repetition penalty to raw logits (pre-softmax)
-    apply_repetition_penalty(logits, vocab_size_, recent_tokens);
-    // 2. apply the temperature to the logits
-    apply_temperature(logits, vocab_size_);
-    // 3. mask out logits outside top-k by rank (pre-softmax, becomes 0 mass)
-    mask_topk(logits);
-    // 4. mask out logits outside top-p by rank (pre-softmax)
-    mask_topp(logits);
-    // 5. apply softmax to the logits to get the probabilities for next token
-    softmax(logits, vocab_size_);
-    // 6. apply min_p truncation
-    apply_min_p(logits, vocab_size_);
-    // flip a (float) coin (this is our source of entropy for sampling)
-    float coin = random_f32(&rng_state_);
-    // 7. we sample from this distribution to get the next token
-    next = sample_mult(logits, coin);
-  }
-  return next;
-}
-
-template <typename T> int32_t Sampler::sample(T *logits) {
-  return sample(logits, {});
-}
-
-template int32_t Sampler::sample<float>(float *logits);
-template int32_t Sampler::sample<uint16_t>(uint16_t *logits);
-template int32_t
-Sampler::sample<executorch::aten::Half>(executorch::aten::Half *logits);
-template int32_t
-Sampler::sample<executorch::aten::BFloat16>(executorch::aten::BFloat16 *logits);
-
-template int32_t Sampler::sample<float>(float *logits,
-                                        const std::vector<uint64_t> &);
-template int32_t Sampler::sample<uint16_t>(uint16_t *logits,
-                                           const std::vector<uint64_t> &);
-template int32_t
-Sampler::sample<executorch::aten::Half>(executorch::aten::Half *logits,
-                                        const std::vector<uint64_t> &);
-template int32_t
-Sampler::sample<executorch::aten::BFloat16>(executorch::aten::BFloat16 *logits,
-                                            const std::vector<uint64_t> &);
-
-} // namespace llm
-} // namespace extension
-} // namespace executorch
diff --git a/packages/react-native-executorch/common/runner/sampler.h b/packages/react-native-executorch/common/runner/sampler.h
deleted file mode 100644
index 6af1a5a487..0000000000
--- a/packages/react-native-executorch/common/runner/sampler.h
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include "runner/irunner.h"
-#include <algorithm>
-#include <cctype>
-#include <cmath>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <memory>
-#include <utility>
-#include <vector>
-#ifdef USE_ATEN_LIB
-#include <torch/torch.h>
-#endif
-
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <executorch/runtime/platform/compiler.h>
-
-namespace executorch {
-namespace extension {
-namespace llm {
-// A simple llama2 sampler.
-struct GenerationConfig;
-
-inline constexpr auto kTopp = 0.9f;
-
-template <typename T> struct ProbIndex {
-  T prob;
-  int32_t index;
-}; // struct used when sorting probabilities during top-p sampling
-
-class Sampler {
-public:
-  // topk <= 0 disables top-k filtering. topp <= 0 || topp >= 1 disables top-p.
-  // Pipeline when temperature != 0: temperature -> top-k mask -> top-p mask
-  // -> softmax -> multinomial. Note: topk == 1 with temperature != 0 collapses
-  // to greedy; pass topk = 0 to keep full-vocab temperature sampling.
-  Sampler(int32_t vocab_size, GenerationConfig config,
-          unsigned long long rng_seed);
-  Sampler(int32_t vocab_size, GenerationConfig config);
-
-  template <typename T> int32_t sample(T *logits);
-
-  template <typename T>
-  int32_t sample(T *logits, const std::vector<uint64_t> &recent_tokens);
-
-private:
-  template <typename T> int32_t sample_topp(T *probabilities, float coin);
-  template <typename T> int32_t sample_mult(T *probabilities, float coin);
-  template <typename T> int32_t sample_argmax(T *probabilities);
-  // In-place logit warpers: set excluded indices to -inf.
-  template <typename T> void mask_topk(T *logits);
-  template <typename T> void mask_topp(T *logits);
-
-  template <typename T>
-  inline void apply_temperature(T *logits, int32_t vocab_size) {
-    for (std::size_t i = 0; std::cmp_less(i, vocab_size); ++i) {
-      logits[i] =
-          static_cast<T>(static_cast<float>(logits[i]) * inv_temperature_);
-    }
-  }
-
-  template <typename T>
-  inline void
-  apply_repetition_penalty(T *logits, int32_t vocab_size,
-                           const std::vector<uint64_t> &recent_tokens) {
-    if (repetition_penalty_ == 1.0f || recent_tokens.empty())
-      return;
-    for (uint64_t id : recent_tokens) {
-      if (!std::cmp_less(id, vocab_size)) {
-        continue;
-      }
-      T &val = logits[id];
-      if (val > T(0)) {
-        val = static_cast<T>(static_cast<float>(val) / repetition_penalty_);
-      } else {
-        val = static_cast<T>(static_cast<float>(val) * repetition_penalty_);
-      }
-    }
-  }
-
-  template <typename T>
-  inline void apply_min_p(T *probabilities, int32_t vocab_size) {
-    if (min_p_ <= 0.0f) {
-      return;
-    }
-    T max_prob = *std::max_element(probabilities, probabilities + vocab_size);
-    T threshold = static_cast<T>(min_p_ * static_cast<float>(max_prob));
-    T sum = T(0);
-    for (std::size_t i = 0; std::cmp_less(i, vocab_size); ++i) {
-      if (probabilities[i] < threshold) {
-        probabilities[i] = T(0);
-      } else {
-        sum += probabilities[i];
-      }
-    }
-    if (sum > T(0)) {
-      for (std::size_t i = 0; std::cmp_less(i, vocab_size); ++i) {
-        probabilities[i] /= sum;
-      }
-    }
-  }
-
-private:
-  int32_t vocab_size_;
-  // reciprocal of temperature, or 0 if temperature == 0.
-  float inv_temperature_;
-  float topp_;
-  float min_p_;
-  float repetition_penalty_;
-  int32_t topk_;
-  unsigned long long rng_state_;
-};
-
-} // namespace llm
-} // namespace extension
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::extension::llm::ProbIndex;
-using ::executorch::extension::llm::Sampler;
-} // namespace executor
-} // namespace torch
-
-namespace executorch::llm {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch::extension::llm` namespaces.
-using ::executorch::extension::llm::kTopp;
-} // namespace executorch::llm
diff --git a/packages/react-native-executorch/common/runner/stats.h b/packages/react-native-executorch/common/runner/stats.h
deleted file mode 100644
index b94834475d..0000000000
--- a/packages/react-native-executorch/common/runner/stats.h
+++ /dev/null
@@ -1,218 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// Runner stats for LLM
-#pragma once
-#include "util.h"
-#include <cinttypes>
-#include <executorch/runtime/platform/log.h>
-#include <limits>
-#include <sstream>
-#include <string>
-
-namespace executorch {
-namespace extension {
-namespace llm {
-
-struct Stats {
-  // Scaling factor for timestamps - in this case, we use ms.
-  const long SCALING_FACTOR_UNITS_PER_SECOND = 1000;
-  // Time stamps for the different stages of the execution
-  // model_load_start_ms: Start of model loading.
-  long model_load_start_ms;
-  // model_load_end_ms: End of model loading.
-  long model_load_end_ms;
-  // inference_start_ms: Immediately after the model is loaded (or we check
-  // for model load), measure the inference time.
-  // NOTE: It's actually the tokenizer encode + model execution time.
-  long inference_start_ms;
-  // End of the tokenizer encode time.
-  long token_encode_end_ms;
-  // Start of the model execution (forward function) time.
-  long model_execution_start_ms;
-  // End of the model execution (forward function) time.
-  long model_execution_end_ms;
-  // prompt_eval_end_ms: Prompt array allocation and tokenization. Ends right
-  // before the inference loop starts
-  long prompt_eval_end_ms;
-  // first_token: Timestamp when the first generated token is emitted
-  long first_token_ms;
-  // inference_end_ms: End of inference/generation.
-  long inference_end_ms;
-  // Keep a running total of the time spent in sampling.
-  long aggregate_sampling_time_ms = 0;
-  // Token count from prompt
-  int64_t num_prompt_tokens;
-  // Token count from generated (total - prompt)
-  int64_t num_generated_tokens;
-  // GPU memory stats (optional; may be zero if not available)
-  // GPU memory stats (optional). Use sentinel UINT64_MAX / -1.0 to indicate
-  // "not available".
-  uint64_t gpu_total_bytes = std::numeric_limits<uint64_t>::max();
-  uint64_t gpu_free_before_load_bytes = std::numeric_limits<uint64_t>::max();
-  uint64_t gpu_free_after_load_bytes = std::numeric_limits<uint64_t>::max();
-  uint64_t gpu_free_after_generate_bytes = std::numeric_limits<uint64_t>::max();
-  double gpu_peak_usage_mb = -1.0;
-  inline void on_sampling_begin() {
-    aggregate_sampling_timer_start_timestamp = time_in_ms();
-  }
-  inline void on_sampling_end() {
-    aggregate_sampling_time_ms +=
-        time_in_ms() - aggregate_sampling_timer_start_timestamp;
-    aggregate_sampling_timer_start_timestamp = 0;
-  }
-
-  void reset(bool all_stats = false) {
-    // Not resetting model_load_start_ms and model_load_end_ms because reset is
-    // typically called after warmup and before running the actual run.
-    // However, we don't load the model again during the actual run after
-    // warmup. So, we don't want to reset these timestamps unless we are
-    // resetting everything.
-    if (all_stats) {
-      model_load_start_ms = 0;
-      model_load_end_ms = 0;
-    }
-    inference_start_ms = 0;
-    prompt_eval_end_ms = 0;
-    first_token_ms = 0;
-    inference_end_ms = 0;
-    aggregate_sampling_time_ms = 0;
-    num_prompt_tokens = 0;
-    num_generated_tokens = 0;
-    gpu_total_bytes = std::numeric_limits<uint64_t>::max();
-    gpu_free_before_load_bytes = std::numeric_limits<uint64_t>::max();
-    gpu_free_after_load_bytes = std::numeric_limits<uint64_t>::max();
-    gpu_free_after_generate_bytes = std::numeric_limits<uint64_t>::max();
-    gpu_peak_usage_mb = -1.0;
-    aggregate_sampling_timer_start_timestamp = 0;
-  }
-
-private:
-  long aggregate_sampling_timer_start_timestamp = 0;
-};
-
-inline std::string stats_to_json_string(const Stats &stats) {
-  std::stringstream ss;
-  ss << "{\"prompt_tokens\":" << stats.num_prompt_tokens << ","
-     << "\"generated_tokens\":" << stats.num_generated_tokens << ","
-     << "\"model_load_start_ms\":" << stats.model_load_start_ms << ","
-     << "\"model_load_end_ms\":" << stats.model_load_end_ms << ","
-     << "\"inference_start_ms\":" << stats.inference_start_ms << ","
-     << "\"inference_end_ms\":" << stats.inference_end_ms << ","
-     << "\"prompt_eval_end_ms\":" << stats.prompt_eval_end_ms << ","
-     << "\"first_token_ms\":" << stats.first_token_ms << ","
-     << "\"aggregate_sampling_time_ms\":" << stats.aggregate_sampling_time_ms
-     << ",";
-  // Only include GPU fields in the JSON if gpu_total_bytes is valid (not
-  // equal to sentinel -1)
-  if (stats.gpu_total_bytes != static_cast<uint64_t>(-1)) {
-    ss << "\"gpu_total_bytes\":" << stats.gpu_total_bytes;
-    if (stats.gpu_free_before_load_bytes != static_cast<uint64_t>(-1)) {
-      ss << ",\"gpu_free_before_load_bytes\":"
-         << stats.gpu_free_before_load_bytes;
-    }
-    if (stats.gpu_free_after_load_bytes != static_cast<uint64_t>(-1)) {
-      ss << ",\"gpu_free_after_load_bytes\":"
-         << stats.gpu_free_after_load_bytes;
-    }
-    if (stats.gpu_free_after_generate_bytes != static_cast<uint64_t>(-1)) {
-      ss << ",\"gpu_free_after_generate_bytes\":"
-         << stats.gpu_free_after_generate_bytes;
-    }
-    if (stats.gpu_peak_usage_mb >= 0.0) {
-      ss << ",\"gpu_peak_usage_mb\":" << stats.gpu_peak_usage_mb;
-    }
-    ss << ",";
-  }
-  ss << "\"SCALING_FACTOR_UNITS_PER_SECOND\":"
-     << stats.SCALING_FACTOR_UNITS_PER_SECOND << "}";
-  return ss.str();
-}
-
-inline void print_report(const Stats &stats) {
-  printf("PyTorchObserver %s\n", stats_to_json_string(stats).c_str());
-
-  ET_LOG(Info, "\tPrompt Tokens: %" PRIu64 "    Generated Tokens: %" PRIu64,
-         stats.num_prompt_tokens, stats.num_generated_tokens);
-
-  ET_LOG(Info, "\tModel Load Time:\t\t%f (seconds)",
-         ((double)(stats.model_load_end_ms - stats.model_load_start_ms) /
-          stats.SCALING_FACTOR_UNITS_PER_SECOND));
-  double inference_time_ms =
-      (double)(stats.inference_end_ms - stats.inference_start_ms);
-  ET_LOG(
-      Info,
-      "\tTotal inference time:\t\t%f (seconds)\t\t Rate: \t%f (tokens/second)",
-      inference_time_ms / stats.SCALING_FACTOR_UNITS_PER_SECOND,
-
-      (stats.num_generated_tokens) /
-          (double)(stats.inference_end_ms - stats.inference_start_ms) *
-          stats.SCALING_FACTOR_UNITS_PER_SECOND);
-  double prompt_eval_time =
-      (double)(stats.prompt_eval_end_ms - stats.inference_start_ms);
-  ET_LOG(Info,
-         "\t\tPrompt evaluation:\t%f (seconds)\t\t Rate: \t%f (tokens/second)",
-         prompt_eval_time / stats.SCALING_FACTOR_UNITS_PER_SECOND,
-         (stats.num_prompt_tokens) / prompt_eval_time *
-             stats.SCALING_FACTOR_UNITS_PER_SECOND);
-
-  double eval_time =
-      (double)(stats.inference_end_ms - stats.prompt_eval_end_ms);
-  ET_LOG(Info,
-         "\t\tGenerated %" PRIu64
-         " tokens:\t%f (seconds)\t\t Rate: \t%f (tokens/second)",
-         stats.num_generated_tokens,
-         eval_time / stats.SCALING_FACTOR_UNITS_PER_SECOND,
-         stats.num_generated_tokens / eval_time *
-             stats.SCALING_FACTOR_UNITS_PER_SECOND);
-
-  // Time to first token is measured from the start of inference, excluding
-  // model load time.
-  ET_LOG(Info, "\tTime to first generated token:\t%f (seconds)",
-         ((double)(stats.first_token_ms - stats.inference_start_ms) /
-          stats.SCALING_FACTOR_UNITS_PER_SECOND));
-
-  ET_LOG(Info, "\tSampling time over %" PRIu64 " tokens:\t%f (seconds)",
-         stats.num_prompt_tokens + stats.num_generated_tokens,
-         (double)stats.aggregate_sampling_time_ms /
-             stats.SCALING_FACTOR_UNITS_PER_SECOND);
-
-  // GPU memory reporting (only meaningful if GPU fields were populated)
-  if (stats.gpu_total_bytes != static_cast<uint64_t>(-1)) {
-    ET_LOG(Info, "\tGPU total memory: %.2f MB",
-           stats.gpu_total_bytes / 1024.0 / 1024.0);
-    if (stats.gpu_free_before_load_bytes != static_cast<uint64_t>(-1)) {
-      ET_LOG(Info, "\tGPU free before load: %.2f MB",
-             stats.gpu_free_before_load_bytes / 1024.0 / 1024.0);
-    }
-    if (stats.gpu_free_after_load_bytes != static_cast<uint64_t>(-1)) {
-      ET_LOG(Info, "\tGPU free after load: %.2f MB",
-             stats.gpu_free_after_load_bytes / 1024.0 / 1024.0);
-    }
-    if (stats.gpu_free_after_generate_bytes != static_cast<uint64_t>(-1)) {
-      ET_LOG(Info, "\tGPU free after generate: %.2f MB",
-             stats.gpu_free_after_generate_bytes / 1024.0 / 1024.0);
-    }
-    if (stats.gpu_peak_usage_mb >= 0.0) {
-      ET_LOG(Info, "\tGPU peak usage: %.2f MB", stats.gpu_peak_usage_mb);
-    }
-  }
-}
-
-} // namespace llm
-} // namespace extension
-} // namespace executorch
-
-namespace executorch {
-namespace llm {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::extension::llm::print_report;
-using ::executorch::extension::llm::Stats;
-} // namespace llm
-} // namespace executorch
diff --git a/packages/react-native-executorch/common/runner/text_decoder_runner.cpp b/packages/react-native-executorch/common/runner/text_decoder_runner.cpp
deleted file mode 100644
index 77770e3418..0000000000
--- a/packages/react-native-executorch/common/runner/text_decoder_runner.cpp
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// Given inputs, run a text decoder and return logits.
-
-#include "text_decoder_runner.h"
-#include "arange_util.h"
-#include "irunner.h"
-#include "stats.h"
-
-#include <ctime>
-
-namespace executorch {
-namespace extension {
-namespace llm {
-
-// NOTE: we observed ~2x loading performance increase on iPhone 15
-// and a ~5% improvement on Galaxy S22 by switching to
-// FileDataLoader instead of MmapDataLoader + UseMlockIgnoreErrors.
-TextDecoderRunner::TextDecoderRunner(Module &module, IOManager *io_manager,
-                                     const GenerationConfig &config)
-    : module_(&module), io_manager_(io_manager), config_(config) {}
-
-// This function is functional, meaning it shouldn't modify any state of the
-// input. It should be safe to call multiple times with the same inputs. The
-// outer loop (call site) is responsible for managing state.
-::executorch::runtime::Result<executorch::aten::Tensor>
-TextDecoderRunner::step(TensorPtr &tokens, int64_t start_pos) {
-  auto method_meta_result = module_->method_meta("forward");
-  if (!method_meta_result.ok()) {
-    return method_meta_result.error();
-  }
-  auto method_meta = std::move(*method_meta_result);
-  // If only 1 input, we are not using kv cache
-  bool use_kv_cache = method_meta.num_inputs() > 1;
-
-  std::vector<int64_t> cache_positions;
-
-  if (use_kv_cache) {
-    auto start_pos_tensor_result = populate_start_pos_or_cache_position(
-        module_, start_pos, cache_positions, tokens->numel(), "forward");
-    if (!start_pos_tensor_result.ok()) {
-      return start_pos_tensor_result.error();
-    }
-    auto start_pos_tensor = std::move(*start_pos_tensor_result);
-
-    std::vector<runtime::EValue> inputs;
-    auto inputs_res = io_manager_->prepare_decode(tokens, start_pos_tensor);
-    ET_CHECK_OK_OR_RETURN_ERROR(inputs_res.error());
-    inputs = inputs_res.get();
-    auto outputs_res = module_->forward(inputs);
-    ET_CHECK_OK_OR_RETURN_ERROR(outputs_res.error());
-
-    auto update_err = io_manager_->update_decode(outputs_res.get());
-    ET_CHECK_OK_OR_RETURN_ERROR(update_err);
-
-    ET_CHECK_MSG(outputs_res.get().size() == 1,
-                 "More then one output returned from executing LLM.");
-    ET_CHECK_MSG(outputs_res.get()[0].isTensor(),
-                 "Non Tensor Output returned from executing LLM");
-
-    // Return the logits tensor
-    return outputs_res.get()[0].toTensor();
-  } else {           // no kv cache
-    (void)start_pos; // unused
-
-    auto outputs_res = module_->forward(tokens);
-    ET_CHECK_OK_OR_RETURN_ERROR(outputs_res.error());
-    ET_CHECK_MSG(outputs_res.get().size() == 1,
-                 "More then one output returned from executing LLM.");
-    ET_CHECK_MSG(outputs_res.get()[0].isTensor(),
-                 "Non Tensor Output returned from executing LLM");
-
-    // Return the logits tensor
-    return outputs_res.get()[0].toTensor();
-  }
-}
-
-int32_t TextDecoderRunner::logits_to_token(
-    const executorch::aten::Tensor &logits_tensor,
-    const std::vector<uint64_t> &recent_tokens) {
-  int32_t result = 0;
-
-  struct {
-    [[noreturn]] void fail(torch::executor::Error) {
-      ET_CHECK_MSG(false, "Unsupported dtype in logits_to_token");
-    }
-  } ctx;
-
-  ET_SWITCH_FOUR_TYPES(
-      Float, Half, BFloat16, UInt16, logits_tensor.scalar_type(), ctx,
-      "logits_to_token", CTYPE, [&]() {
-        auto *logits = logits_tensor.mutable_data_ptr<CTYPE>();
-        ssize_t vocab_size = logits_tensor.size(logits_tensor.dim() - 1);
-        if (logits_tensor.dim() == 3) {
-          auto num_tokens = logits_tensor.size(1);
-          logits += (num_tokens - 1) * vocab_size;
-        }
-        Sampler sampler(vocab_size, config_);
-        result = sampler.sample(logits, recent_tokens);
-      });
-  return result;
-}
-
-} // namespace llm
-} // namespace extension
-} // namespace executorch
diff --git a/packages/react-native-executorch/common/runner/text_decoder_runner.h b/packages/react-native-executorch/common/runner/text_decoder_runner.h
deleted file mode 100644
index d3aa229cd0..0000000000
--- a/packages/react-native-executorch/common/runner/text_decoder_runner.h
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// Given inputs, run a text decoder in LLM and return the output.
-
-#pragma once
-
-#include "constants.h"
-#include "io_manager.h"
-#include "sampler.h"
-
-namespace executorch {
-namespace extension {
-namespace llm {
-
-// Forward declaration to avoid the include chain
-// irunner.h -> stats.h -> util.h -> text_prefiller.h -> text_decoder_runner.h
-// which would re-enter this header before TextDecoderRunner is defined.
-struct GenerationConfig;
-
-class TextDecoderRunner {
-public:
-  explicit TextDecoderRunner(Module &module, IOManager *io_manager,
-                             const GenerationConfig &config);
-
-  virtual ~TextDecoderRunner() = default;
-
-  /**
-   * Run LLM text decoder with inputs to generate next token.
-   * @param input The input to the LLM Module.
-   * @param start_pos The starting position in KV cache of the input in the LLM
-   * Module.
-   * @return The output of the LLM Module. This will be a tensor of logits.
-   */
-  virtual ::executorch::runtime::Result<executorch::aten::Tensor>
-  step(TensorPtr &input, int64_t start_pos);
-
-  /**
-   * Load the Module for text decode purpose. Loads the dynamic-shape `forward`
-   * method used for both prefill and decode.
-   */
-  virtual ::executorch::runtime::Error load() {
-    return module_->load_method("forward");
-  }
-
-  /**
-   * Check if the required methods in the Module is loaded.
-   * @return True if the Module is loaded, false otherwise.
-   */
-  virtual bool is_method_loaded() {
-    return module_->is_method_loaded("forward");
-  }
-
-  inline void stop() { should_stop_ = true; }
-
-  /**
-   * Sample the next token from the logits tensor using the sampling
-   * parameters in `config_`. `recent_tokens` is the prompt-plus-generated
-   * window used by the repetition penalty. Defined out-of-line in the cpp
-   * so this header doesn't need a complete `GenerationConfig` type.
-   */
-  int32_t logits_to_token(const executorch::aten::Tensor &logits_tensor,
-                          const std::vector<uint64_t> &recent_tokens = {});
-
-protected:
-  // Non-owning. The runner (BaseLLMRunner) owns the Module and outlives this.
-  Module *module_;
-  IOManager *io_manager_;
-  bool should_stop_{false};
-  const GenerationConfig &config_;
-};
-
-} // namespace llm
-} // namespace extension
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::extension::llm::TextDecoderRunner;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/common/runner/text_prefiller.cpp b/packages/react-native-executorch/common/runner/text_prefiller.cpp
deleted file mode 100644
index 370ca5c7f4..0000000000
--- a/packages/react-native-executorch/common/runner/text_prefiller.cpp
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// Given a text prompt, encode it using tokenizer and prefill the KV cache of a
-// LLM.
-
-#include "text_prefiller.h"
-#include <algorithm>
-
-namespace executorch {
-namespace extension {
-namespace llm {
-
-TextPrefiller::TextPrefiller(TextDecoderRunner *text_decoder_runner,
-                             bool use_kv_cache, bool enable_parallel_prefill,
-                             int64_t max_seq_len, int32_t prefill_chunk_size)
-    : text_decoder_runner_(text_decoder_runner), use_kv_cache_(use_kv_cache),
-      enable_parallel_prefill_(enable_parallel_prefill),
-      max_seq_len_(max_seq_len > 0 ? max_seq_len : 128),
-      prefill_chunk_size_(prefill_chunk_size) {}
-
-::executorch::runtime::Result<uint64_t>
-TextPrefiller::prefill(std::vector<uint64_t> &prompt_tokens,
-                       int64_t &start_pos) {
-  ET_CHECK_MSG(!prompt_tokens.empty(), "Prompt cannot be null");
-  if (!text_decoder_runner_->is_method_loaded()) {
-    ET_CHECK_OK_OR_RETURN_ERROR(text_decoder_runner_->load());
-  }
-
-  int32_t num_prompt_tokens = prompt_tokens.size();
-  int32_t chunk_size =
-      prefill_chunk_size_ > 0 ? prefill_chunk_size_ : max_seq_len_;
-
-  if (num_prompt_tokens > chunk_size) {
-    uint64_t cur_token = 0;
-    int num_tokens_to_process = 0;
-
-    while (num_tokens_to_process < num_prompt_tokens) {
-      auto num_tokens_to_prefill_with =
-          std::min<int>(num_prompt_tokens - num_tokens_to_process, chunk_size);
-
-      std::vector<uint64_t> prompt_tokens_to_process(
-          num_tokens_to_prefill_with);
-      std::copy(prompt_tokens.begin() + num_tokens_to_process,
-                prompt_tokens.begin() + num_tokens_to_process +
-                    num_tokens_to_prefill_with,
-                prompt_tokens_to_process.begin());
-
-      // Process this chunk
-      auto chunk_result = prefill_chunk(prompt_tokens_to_process, start_pos);
-      ET_CHECK_OK_OR_RETURN_ERROR(chunk_result.error());
-      cur_token = chunk_result.get();
-
-      num_tokens_to_process += num_tokens_to_prefill_with;
-    }
-
-    return cur_token;
-  } else {
-    // If prompt tokens don't exceed max_seq_len_, process them directly
-    return prefill_chunk(prompt_tokens, start_pos);
-  }
-}
-
-::executorch::runtime::Result<uint64_t>
-TextPrefiller::prefill_chunk(std::vector<uint64_t> &prompt_tokens,
-                             int64_t &start_pos) {
-  // enable_parallel_prefill_ maybe set even when not using kv cache
-  // When kv cache is not used, start pos is ignored
-  int32_t num_prompt_tokens = prompt_tokens.size();
-
-  // store the token
-  uint64_t cur_token;
-  if (enable_parallel_prefill_ || !use_kv_cache_) {
-    auto tokens = from_blob(prompt_tokens.data(), {1, num_prompt_tokens},
-                            executorch::aten::ScalarType::Long);
-
-    auto outputs_res = text_decoder_runner_->step(tokens, start_pos);
-
-    ET_CHECK_OK_OR_RETURN_ERROR(outputs_res.error());
-    ET_LOG(Info, "Prefill token result numel(): %zu",
-           outputs_res.get().numel());
-
-    start_pos += num_prompt_tokens;
-    cur_token = text_decoder_runner_->logits_to_token(outputs_res.get());
-  } else {           // sequential prefill
-    int64_t pos = 0; // position in the sequence
-    // NOLINTNEXTLINE(facebook-hte-ParameterUncheckedArrayBounds)
-    cur_token = prompt_tokens[0];
-
-    // initialize tensor wrappers
-    auto tokens =
-        from_blob(&cur_token, {1, 1}, executorch::aten::ScalarType::Long);
-
-    // run the first token and get back logits tensor. Assuming the first token
-    // is bos so don't callback.
-    auto logits_result = text_decoder_runner_->step(tokens, start_pos);
-    if (!logits_result.ok()) {
-      return logits_result.error();
-    }
-    auto logits_tensor = std::move(*logits_result);
-
-    pos += 1; // start the loop from index 1
-    start_pos += 1;
-
-    while (pos < num_prompt_tokens) {
-      // Run the model
-      // NOLINTNEXTLINE(facebook-hte-ParameterUncheckedArrayBounds)
-      cur_token = prompt_tokens[pos];
-
-      logits_tensor = ET_UNWRAP(text_decoder_runner_->step(tokens, start_pos));
-
-      pos++;
-      start_pos++;
-    }
-
-    cur_token = text_decoder_runner_->logits_to_token(logits_tensor);
-  }
-  return cur_token;
-}
-
-} // namespace llm
-} // namespace extension
-} // namespace executorch
diff --git a/packages/react-native-executorch/common/runner/text_prefiller.h b/packages/react-native-executorch/common/runner/text_prefiller.h
deleted file mode 100644
index b8cdb1b98c..0000000000
--- a/packages/react-native-executorch/common/runner/text_prefiller.h
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// Given a text prompt, encode it using tokenizer and prefill the KV cache of a
-// LLM.
-
-#pragma once
-
-#include "text_decoder_runner.h"
-
-namespace executorch {
-namespace extension {
-namespace llm {
-
-class TextPrefiller {
-public:
-  // prefill_chunk_size: when > 0, the prompt is always processed in steps of
-  // this size (see prefill()). Set to the model's forward sequence-length cap
-  // for the MLX backend (its forward is exported with a sliding-window bound
-  // and one-shot prefill spikes Metal memory). Other backends (XNNPACK/CoreML)
-  // pass 0 → original one-shot behavior.
-  TextPrefiller(TextDecoderRunner *text_decoder_runner, bool use_kv_cache,
-                bool enable_parallel_prefill, int64_t max_seq_len = 128,
-                int32_t prefill_chunk_size = 0);
-
-  virtual ~TextPrefiller() = default;
-  /**
-   * Prefill an LLM Module with the given text input.
-   * @param prompt_tokens The text prompt tokens to the LLM Module. Encoded by
-   * tokenizer.
-   * @param start_pos The starting position in KV cache of the input in the LLM
-   * Module.
-   * @return The next token of the LLM Module after prefill.
-   */
-  virtual ::executorch::runtime::Result<uint64_t>
-  prefill(std::vector<uint64_t> &prompt_tokens, int64_t &start_pos);
-
-  /**
-   * Helper method to prefill a chunk of tokens.
-   * @param prompt_tokens The chunk of text prompt tokens to process.
-   * @param start_pos The starting position in KV cache of the input in the LLM
-   * Module.
-   * @return The next token of the LLM Module after prefilling this chunk.
-   */
-  virtual ::executorch::runtime::Result<uint64_t>
-  prefill_chunk(std::vector<uint64_t> &prompt_tokens, int64_t &start_pos);
-
-  /**
-   * Load the necessary resources for the TextPrefiller.
-   * This method should be called before using the prefill methods.
-   */
-  ::executorch::runtime::Error load() { return text_decoder_runner_->load(); }
-
-  /**
-   * Check if the TextPrefiller has been successfully loaded.
-   * @return True if the resources are loaded, false otherwise.
-   */
-  bool inline is_loaded() const {
-    // Implementation to check if resources are loaded
-    return text_decoder_runner_->is_method_loaded();
-  }
-
-private:
-  /**
-   * Note: TextPrefiller does not own the TextDecoderRunner instance.
-   * The responsibility of managing the lifecycle of TextDecoderRunner
-   * lies with the outer class or entity (likely Runner) that creates
-   * and passes the TextDecoderRunner instance to TextPrefiller.
-   */
-  TextDecoderRunner *text_decoder_runner_;
-  bool use_kv_cache_;
-  bool enable_parallel_prefill_;
-  int64_t max_seq_len_;
-  int32_t prefill_chunk_size_;
-};
-
-} // namespace llm
-} // namespace extension
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::extension::llm::TextPrefiller;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/common/runner/text_runner.cpp b/packages/react-native-executorch/common/runner/text_runner.cpp
deleted file mode 100644
index bbcc0d8981..0000000000
--- a/packages/react-native-executorch/common/runner/text_runner.cpp
+++ /dev/null
@@ -1,156 +0,0 @@
-// common/runner/text_runner.cpp
-#include "text_runner.h"
-#include "constants.h"
-#include "util.h"
-#include <cstdint>
-#include <rnexecutorch/Error.h>
-
-namespace executorch::extension::llm {
-
-using ::executorch::extension::Module;
-using ::executorch::runtime::Error;
-
-TextRunner::TextRunner(std::unique_ptr<Module> module,
-                       const std::string &tokenizer_path,
-                       const GenerationConfig &config)
-    : BaseLLMRunner(std::move(module), tokenizer_path, config) {}
-
-bool TextRunner::is_loaded() const {
-  return module_ && module_->is_loaded() && tokenizer_ &&
-         tokenizer_->is_loaded() && text_decoder_runner_ && text_prefiller_ &&
-         text_token_generator_;
-}
-
-Error TextRunner::load_subcomponents() {
-  ET_CHECK_OK_OR_RETURN_ERROR(module_->load_method("forward"));
-
-  Stats *stats_ptr = &stats_;
-
-  text_decoder_runner_ =
-      std::make_unique<TextDecoderRunner>(*module_, io_manager_.get(), config_);
-
-  int32_t prefill_chunk_size = 0;
-  auto fwd_meta = module_->method_meta("forward");
-  if (fwd_meta.ok() && fwd_meta->uses_backend("MLXBackend")) {
-    auto input_meta = fwd_meta->input_tensor_meta(0);
-    if (input_meta.ok()) {
-      auto sizes = input_meta->sizes();
-      if (sizes.size() >= 2 && sizes[sizes.size() - 1] > 0) {
-        prefill_chunk_size = sizes[sizes.size() - 1];
-      }
-    }
-  }
-
-  text_prefiller_ = std::make_unique<TextPrefiller>(
-      text_decoder_runner_.get(), config_.enable_kv_cache,
-      config_.enable_dynamic_shape, config_.max_seq_len, prefill_chunk_size);
-  text_token_generator_ = std::make_unique<TextTokenGenerator>(
-      tokenizer_.get(), text_decoder_runner_.get(), config_.enable_kv_cache,
-      std::move(eos_ids_), stats_ptr, config_);
-
-  return Error::Ok;
-}
-
-Error TextRunner::generate_internal(
-    const std::vector<MultimodalInput> &inputs,
-    std::function<void(const std::string &)> token_callback) {
-
-  if (inputs.empty()) {
-    return Error::InvalidArgument;
-  }
-
-  const std::string &prompt = inputs[0].get_text();
-  ET_CHECK_MSG(!prompt.empty(), "Prompt cannot be null");
-
-  if (!is_loaded()) {
-    stats_.model_load_start_ms = time_in_ms();
-    ET_CHECK_OK_OR_RETURN_ERROR(load());
-    stats_.model_load_end_ms = time_in_ms();
-  }
-
-  std::function<void(const std::string &)> wrapped_callback =
-      [token_callback](const std::string &piece) {
-        safe_printf(piece.c_str());
-        fflush(stdout);
-        if (token_callback)
-          token_callback(piece);
-      };
-
-  stats_.inference_start_ms = time_in_ms();
-
-  // Multi-turn: JS re-renders the full chat history each call, so reset KV
-  // position to 0 and re-prefill from scratch.
-  pos_ = 0;
-
-  int64_t context_len_left =
-      static_cast<int64_t>(config_.max_context_length) - pos_;
-
-  auto encodeResult =
-      tokenizer_->encode(prompt, numOfAddedBoSTokens, numOfAddedEoSTokens);
-  if (!encodeResult.ok()) {
-    throw rnexecutorch::RnExecutorchError(
-        rnexecutorch::RnExecutorchErrorCode::TokenizerError,
-        "Unexpected issue occurred while encoding: " +
-            std::to_string(static_cast<int32_t>(encodeResult.error())));
-  }
-  std::vector<uint64_t> prompt_tokens = encodeResult.get();
-  int num_prompt_tokens = prompt_tokens.size();
-
-  // For dynamic-shape PTEs (e.g. Gemma4 MLX/Vulkan), get_max_seq_len is the
-  // per-call decoder chunk size (e.g. the sliding window) and the real
-  // generation budget lives in get_max_context_len. Static-shape PTEs set both
-  // equal, so this collapses to the old behavior. Without this the budget is
-  // computed from the small chunk size, so max_new_tokens can resolve to ~0 and
-  // generation ends immediately after prefill.
-  const int32_t seq_cap = config_.enable_dynamic_shape
-                              ? config_.max_context_length
-                              : config_.max_seq_len;
-
-  ET_CHECK_OR_RETURN_ERROR(num_prompt_tokens >= 1, InvalidArgument,
-                           "Expected at least 1 prompt token");
-  ET_CHECK_OR_RETURN_ERROR(num_prompt_tokens < seq_cap, InvalidArgument,
-                           "num_prompt_tokens %d >= seq cap %" PRId32,
-                           num_prompt_tokens, seq_cap);
-
-  int32_t max_new_tokens = resolve_max_new_tokens(
-      num_prompt_tokens, seq_cap, static_cast<int32_t>(context_len_left),
-      config_.max_new_tokens);
-
-  ET_CHECK_OR_RETURN_ERROR(max_new_tokens > 0, InvalidArgument,
-                           "Max new tokens %d is <= 0", max_new_tokens);
-
-  if (config_.echo)
-    wrapped_callback(prompt);
-
-  auto prefill_res = text_prefiller_->prefill(prompt_tokens, pos_);
-  stats_.first_token_ms = time_in_ms();
-  stats_.prompt_eval_end_ms = time_in_ms();
-  ET_CHECK_OK_OR_RETURN_ERROR(prefill_res.error());
-
-  uint64_t cur_token = prefill_res.get();
-  auto decodeResult = tokenizer_->decode({cur_token});
-  if (!decodeResult.ok()) {
-    throw rnexecutorch::RnExecutorchError(
-        rnexecutorch::RnExecutorchErrorCode::TokenizerError,
-        "Unexpected issue occurred while decoding: " +
-            std::to_string(static_cast<int32_t>(decodeResult.error())));
-  }
-
-  prompt_tokens.push_back(cur_token);
-  int64_t num_generated = ET_UNWRAP(text_token_generator_->generate(
-      prompt_tokens, pos_, max_new_tokens - 1, wrapped_callback));
-
-  pos_ += num_generated;
-  stats_.inference_end_ms = time_in_ms();
-  stats_.num_prompt_tokens = num_prompt_tokens;
-  stats_.num_generated_tokens = num_generated;
-
-  return Error::Ok;
-}
-
-void TextRunner::stop_impl() {
-  if (text_token_generator_)
-    text_token_generator_->stop();
-}
-
-} // namespace executorch::extension::llm
diff --git a/packages/react-native-executorch/common/runner/text_runner.h b/packages/react-native-executorch/common/runner/text_runner.h
deleted file mode 100644
index 096d3498d7..0000000000
--- a/packages/react-native-executorch/common/runner/text_runner.h
+++ /dev/null
@@ -1,34 +0,0 @@
-// common/runner/text_runner.h
-#pragma once
-
-#include "base_llm_runner.h"
-#include "text_decoder_runner.h"
-#include "text_prefiller.h"
-#include "text_token_generator.h"
-
-namespace executorch::extension::llm {
-
-class TextRunner : public BaseLLMRunner {
-public:
-  explicit TextRunner(std::unique_ptr<::executorch::extension::Module> module,
-                      const std::string &tokenizer_path,
-                      const GenerationConfig &config = {.temperature = 0.8F,
-                                                        .topp = 0.9F});
-
-  bool is_loaded() const override;
-
-  ::executorch::runtime::Error generate_internal(
-      const std::vector<MultimodalInput> &inputs,
-      std::function<void(const std::string &)> token_callback) override;
-
-protected:
-  ::executorch::runtime::Error load_subcomponents() override;
-  void stop_impl() override;
-
-private:
-  std::unique_ptr<TextDecoderRunner> text_decoder_runner_;
-  std::unique_ptr<TextPrefiller> text_prefiller_;
-  std::unique_ptr<TextTokenGenerator> text_token_generator_;
-};
-
-} // namespace executorch::extension::llm
diff --git a/packages/react-native-executorch/common/runner/text_token_generator.h b/packages/react-native-executorch/common/runner/text_token_generator.h
deleted file mode 100644
index 13f53bd2e4..0000000000
--- a/packages/react-native-executorch/common/runner/text_token_generator.h
+++ /dev/null
@@ -1,220 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// Generate tokens in a loop.
-#pragma once
-
-#include "irunner.h"
-#include "stats.h"
-#include "text_decoder_runner.h"
-#include "util.h"
-#include <executorch/extension/tensor/tensor.h>
-#include <pytorch/tokenizers/hf_tokenizer.h>
-#include <rnexecutorch/Error.h>
-
-namespace executorch {
-namespace extension {
-namespace llm {
-
-class TextTokenGenerator {
-public:
-  // Holds a const reference to the owning runner's GenerationConfig and
-  // reads `output_token_batch_size` / `batch_time_interval_ms` from it on
-  // every iteration of the generation loop, so external updates take effect
-  // mid-stream without any sync setter on this class.
-  TextTokenGenerator(tokenizers::HFTokenizer *tokenizer,
-                     TextDecoderRunner *text_decoder_runner, bool use_kv_cache,
-                     std::unique_ptr<std::unordered_set<uint64_t>> &&eos_ids,
-                     Stats *stats, const GenerationConfig &config)
-      : tokenizer_(tokenizer), text_decoder_runner_(text_decoder_runner),
-        eos_ids_(std::move(eos_ids)), use_kv_cache_(use_kv_cache),
-        timestamp_(std::chrono::high_resolution_clock::now()), stats_(stats),
-        config_(config) {}
-
-  virtual ~TextTokenGenerator() = default;
-
-  /**
-   * Token generation loop.
-   * @param tokens The first token generated by prefill, if using kv cache. Else
-   * the prompt tokens + the first token generated by prefill.
-   * @param start_pos The start position of the new tokens, based on how many
-   * prompt tokens is prefilled.
-   * @param max_new_tokens Maximum number of new tokens to generate.
-   * @param temperature controls the randomness of predictions by scaling the
-   * logits before applying softmax. A higher temperature results in more
-   * random predictions, while a lower temperature results in more deterministic
-   * predictions.
-   * @param token_callback what to do after a token is generated.
-   * @return how many tokens are generated.
-   */
-  inline ::executorch::runtime::Result<int64_t> generate(
-      std::vector<uint64_t> tokens, int64_t start_pos, uint64_t max_new_tokens,
-      const std::function<void(const std::string &)> &token_callback = {}) {
-    ET_CHECK_MSG(!tokens.empty(),
-                 "Token generation loop shouldn't take empty tokens");
-    int64_t pos = start_pos; // position in the sequence
-
-    std::vector<uint64_t> token_data; // allocate space for the tokens
-    std::vector<executorch::aten::SizesType> token_shape;
-
-    // Token after prefill
-    uint64_t cur_token = tokens.back();
-    [[maybe_unused]] uint64_t prev_token;
-
-    // cache to keep tokens if they were decoded into illegal character
-    std::vector<uint64_t> token_cache;
-    // add first token after prefill to cache here
-    token_cache.push_back(static_cast<uint64_t>(cur_token));
-
-    if (use_kv_cache_) {
-      // hard code these to size 1 as kv cache is locked to static size right
-      // now.
-      token_data = {cur_token};
-      token_shape = {1, 1};
-    } else {
-      token_data = tokens;
-      token_shape = {1, static_cast<int>(tokens.size())};
-    }
-
-    // initialize tensor wrappers
-    auto tokens_managed = from_blob(token_data.data(), token_shape,
-                                    executorch::aten::ScalarType::Long);
-
-    std::vector<uint64_t> generated_tokens(tokens.begin(), tokens.end());
-    should_stop_ = false;
-    timestamp_ = std::chrono::high_resolution_clock::now();
-
-    // Generate our tokens
-    while (pos < start_pos + max_new_tokens) {
-      // Run the model
-      auto logits_res = text_decoder_runner_->step(tokens_managed, pos);
-
-      ET_CHECK_OK_OR_RETURN_ERROR(logits_res.error());
-      executorch::aten::Tensor &logits_tensor = logits_res.get();
-
-      prev_token = cur_token;
-
-      stats_->on_sampling_begin();
-      cur_token = text_decoder_runner_->logits_to_token(logits_tensor,
-                                                        generated_tokens);
-      stats_->on_sampling_end();
-
-      pos++;
-      generated_tokens.push_back(cur_token);
-
-      if (use_kv_cache_) {
-        // update the token tensor. token_data will not be empty.
-        // NOLINTNEXTLINE(facebook-hte-LocalUncheckedArrayBounds)
-        token_data[0] = cur_token;
-      } else {
-        // push it to the back
-        token_data.push_back(cur_token);
-        ET_CHECK_OK_OR_RETURN_ERROR(resize_tensor_ptr(
-            tokens_managed, {1, static_cast<int>(token_data.size())}));
-      }
-
-      token_cache.push_back(static_cast<uint64_t>(cur_token));
-
-      // print the token as string, decode it with the Tokenizer object
-      // We pass false, as we want don't want to skip special tokens e.g.
-      // <think>
-
-      auto decodeResult =
-          tokenizer_->decode(token_cache, false); // NOTE: difference
-      if (!decodeResult.ok()) {
-        throw rnexecutorch::RnExecutorchError(
-            rnexecutorch::RnExecutorchErrorCode::TokenizerError,
-            "Unexpected issue occured while decoding: " +
-                std::to_string(static_cast<int32_t>(decodeResult.error())));
-      }
-      std::string cache_decoded = decodeResult.get();
-      const auto timeIntervalElapsed =
-          std::chrono::duration_cast<std::chrono::milliseconds>(
-              std::chrono::high_resolution_clock::now() - timestamp_)
-              .count() > static_cast<int64_t>(config_.batch_time_interval_ms);
-      const auto countIntervalElapsed =
-          token_cache.size() > config_.output_token_batch_size;
-      const auto eos_reached = eos_ids_->contains(cur_token);
-
-      if (!cache_decoded.ends_with("�") &&
-          (countIntervalElapsed || timeIntervalElapsed || should_stop_ || eos_reached)) {
-        token_callback(cache_decoded);
-        token_cache.clear();
-        timestamp_ = std::chrono::high_resolution_clock::now();
-      }
-
-      if (should_stop_) {
-        break;
-      }
-      // data-dependent terminating condition: we have n_eos_ number of EOS
-      if (eos_ids_->find(cur_token) != eos_ids_->end()) {
-        printf("\n");
-        ET_LOG(Info, "\nReached to the end of generation");
-        break;
-      }
-    }
-    return pos - start_pos;
-  }
-
-  /**
-   * Stop the generation loop.
-   */
-  inline void stop() { should_stop_ = true; }
-
-  /**
-   * Load the necessary resources for TextTokenGenerator.
-   * This method should be called before using the generate() method.
-   */
-  ::executorch::runtime::Error load() { return text_decoder_runner_->load(); }
-
-  /**
-   * Check if the TextTokenGenerator has been successfully loaded.
-   * @return True if the resources are loaded, false otherwise.
-   */
-  bool inline is_loaded() const {
-    // Implementation to check if resources are loaded
-    // return tokenizer_->is_loaded() &&
-    // text_decoder_runner_->is_method_loaded();
-    return text_decoder_runner_->is_method_loaded();
-  }
-
-private:
-  /**
-   * Note: TextTokenGenerator does not own the tokenizer_ and
-   * text_decoder_runner_. The lifecycle of these objects should be managed
-   * externally, likely in the Runner. This class assumes that the provided
-   * pointers remain valid for the duration of its use.
-   */
-  tokenizers::HFTokenizer *tokenizer_;
-  TextDecoderRunner *text_decoder_runner_;
-  std::unique_ptr<std::unordered_set<uint64_t>> eos_ids_;
-  bool use_kv_cache_;
-
-  // state machine
-  bool should_stop_ = false;
-  std::chrono::high_resolution_clock::time_point timestamp_;
-
-  // stats
-  Stats *stats_;
-
-  // Reference to the owning runner's GenerationConfig. Token-batching
-  // intervals are read fresh on every iteration.
-  const GenerationConfig &config_;
-};
-
-} // namespace llm
-} // namespace extension
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::extension::llm::TextTokenGenerator;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/common/runner/util.h b/packages/react-native-executorch/common/runner/util.h
deleted file mode 100644
index b1e707034b..0000000000
--- a/packages/react-native-executorch/common/runner/util.h
+++ /dev/null
@@ -1,187 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-#include "constants.h"
-#include <cctype>
-#include <executorch/extension/module/module.h>
-#include <executorch/extension/tensor/tensor.h>
-#include <executorch/runtime/platform/compiler.h>
-#include <stdio.h>
-#include <time.h>
-#include <vector>
-#if defined(__linux__) || defined(__ANDROID__) || defined(__unix__)
-#include <sys/resource.h>
-#endif
-
-#define ET_UNWRAP_TOKENIZER(result__)                                          \
-  ({                                                                           \
-    auto tk_result__ = (result__);                                             \
-    if (!tk_result__.ok()) {                                                   \
-      ET_LOG(Error, "Tokenizers error code %d",                                \
-             static_cast<uint32_t>(tk_result__.error()));                      \
-      return ::executorch::runtime::Error::InvalidArgument;                    \
-    }                                                                          \
-    std::move(*tk_result__);                                                   \
-  })
-
-#define ET_CHECK_TK_OK_OR_RETURN_ERROR(result__, ...)                          \
-  ({                                                                           \
-    auto tk_result__ = (result__);                                             \
-    if (tk_result__ != ::tokenizers::Error::Ok) {                              \
-      ET_LOG(Error, "Tokenizer error: %d",                                     \
-             static_cast<uint32_t>(tk_result__));                              \
-      ET_CHECK_OK_OR_RETURN_ERROR(                                             \
-          ::executorch::runtime::Error::InvalidArgument, ##__VA_ARGS__);       \
-    }                                                                          \
-  })
-
-namespace executorch {
-namespace extension {
-namespace llm {
-
-void inline safe_printf(const char *piece) {
-  // piece might be a raw byte token, and we only want to print printable chars
-  // or whitespace because some of the other bytes can be various control codes,
-  // backspace, etc.
-  if (piece == nullptr) {
-    return;
-  }
-  if (piece[0] == '\0') {
-    return;
-  }
-  if (piece[1] == '\0') {
-    unsigned char byte_val = piece[0];
-    if (!(isprint(byte_val) || isspace(byte_val))) {
-      return; // bad byte, don't print it
-    }
-  }
-  printf("%s", piece);
-}
-
-// ----------------------------------------------------------------------------
-// utilities: time
-
-long inline time_in_ms() {
-  // return time in milliseconds, for benchmarking the model speed
-  struct timespec time;
-  // The `timespec_get` function is for windows time access. Some AOSP OS does
-  // not have timespec_get support.
-#if defined(__ANDROID_API__)
-  clock_gettime(CLOCK_REALTIME, &time);
-#else
-  timespec_get(&time, TIME_UTC);
-#endif
-  return time.tv_sec * 1000 + time.tv_nsec / 1000000;
-}
-
-// ----------------------------------------------------------------------------
-// utilities: memory usage
-
-// Returns the current RSS in bytes. Returns 0 if not supported.
-// RSS: Resident Set Size, the amount of memory currently in the RAM for this
-// process. These values are approximate, and are only used for logging
-// purposes.
-size_t inline get_rss_bytes() {
-#if defined(__linux__) || defined(__ANDROID__) || defined(__unix__)
-  struct rusage r_usage;
-  if (getrusage(RUSAGE_SELF, &r_usage) == 0) {
-    return r_usage.ru_maxrss * 1024;
-  }
-#endif // __linux__ || __ANDROID__ || __unix__
-  // Unsupported platform like Windows, or getrusage() failed.
-  // __APPLE__ and __MACH__ are not supported because r_usage.ru_maxrss does not
-  // consistently return kbytes on macOS. On older versions of macOS, it
-  // returns bytes, but on newer versions it returns kbytes. Need to figure out
-  // when this changed.
-  return 0;
-}
-
-// Returns the cache position tensor, which can be either a single start_pos
-// (when the method_name [`text_decoder` or `forward`] expects a tensor with
-// size 1 because model will populate the cache position tensor underneath), or
-// a populated tensor for cache position, for the given start_pos and seq_len.
-inline runtime::Result<TensorPtr>
-populate_start_pos_or_cache_position(Module *module, int64_t &start_pos,
-                                     std::vector<int64_t> &cache_positions_vec,
-                                     int seq_len,
-                                     const char *method_name = "forward") {
-  // Get expected shape of cache position tensor, which should be the second
-  // argument
-  auto method_meta_result = module->method_meta(method_name);
-  if (!method_meta_result.ok()) {
-    return method_meta_result.error();
-  }
-  auto method_meta = std::move(*method_meta_result);
-  auto second_input_info_result = method_meta.input_tensor_meta(1);
-  if (!second_input_info_result.ok()) {
-    return second_input_info_result.error();
-  }
-  auto second_input_info = std::move(*second_input_info_result);
-  auto second_input_sizes = second_input_info.sizes();
-  auto numel = second_input_sizes[0];
-
-  TensorPtr start_pos_tensor;
-  if (numel > 1) {
-    // `cache_position` goes from start_pos to start_pos +
-    // encoder_output.size(1). e.g. if start_pos = 2 and encoder_output.size(1)
-    // = 5, cache_position_tensor should be [2, 3, 4, 5, 6].
-    cache_positions_vec.resize(seq_len);
-    for (int64_t i = 0; i < seq_len; ++i) {
-      cache_positions_vec[i] = start_pos + i;
-    }
-    return ::executorch::extension::from_blob(
-        cache_positions_vec.data(), {static_cast<int>(seq_len)},
-        executorch::aten::ScalarType::Long);
-  } else {
-    // Cache position is size 1.
-    return ::executorch::extension::from_blob(
-        &start_pos, {1}, executorch::aten::ScalarType::Long);
-  }
-}
-
-/**
- * Helper function to convert a float tensor to bfloat16.
- * Creates a new tensor with bfloat16 dtype and copies/converts the data.
- */
-inline ::executorch::runtime::Result<::executorch::extension::TensorPtr>
-convert_to_bfloat16(const ::executorch::extension::TensorPtr &src_tensor) {
-  ET_CHECK_OR_RETURN_ERROR(
-      src_tensor->scalar_type() == ::executorch::aten::ScalarType::Float,
-      InvalidArgument,
-      "BFloat16 conversion only supported from Float source data");
-
-  const auto num_elements = static_cast<size_t>(src_tensor->numel());
-  const float *float_data = src_tensor->const_data_ptr<float>();
-
-  auto bf16_tensor = ::executorch::extension::empty_like(
-      src_tensor, ::executorch::aten::ScalarType::BFloat16);
-  auto *bf16_data =
-      bf16_tensor->mutable_data_ptr<::executorch::aten::BFloat16>();
-  for (size_t i = 0; i < num_elements; ++i) {
-    bf16_data[i] = ::executorch::aten::BFloat16(float_data[i]);
-  }
-
-  return bf16_tensor;
-}
-
-} // namespace llm
-} // namespace extension
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-namespace util {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::extension::llm::get_rss_bytes;
-using ::executorch::extension::llm::safe_printf;
-using ::executorch::extension::llm::time_in_ms;
-} // namespace util
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/cpp/RnExecutorch.cpp b/packages/react-native-executorch/cpp/RnExecutorch.cpp
new file mode 100644
index 0000000000..dbcd4e41c9
--- /dev/null
+++ b/packages/react-native-executorch/cpp/RnExecutorch.cpp
@@ -0,0 +1,15 @@
+#include "RnExecutorch.h"
+
+#include "core/install.h"
+
+using namespace facebook;
+
+namespace rnexecutorch {
+void install(jsi::Runtime &jsiRuntime) {
+    jsi::Object module = jsi::Object(jsiRuntime);
+
+    rnexecutorch::core::install(jsiRuntime, module);
+
+    jsiRuntime.global().setProperty(jsiRuntime, "__rnexecutorch_jsi__", std::move(module));
+}
+} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/cpp/RnExecutorch.h b/packages/react-native-executorch/cpp/RnExecutorch.h
new file mode 100644
index 0000000000..fb10d6bf6c
--- /dev/null
+++ b/packages/react-native-executorch/cpp/RnExecutorch.h
@@ -0,0 +1,7 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+namespace rnexecutorch {
+void install(facebook::jsi::Runtime &jsiRuntime);
+} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/cpp/core/dtype.cpp b/packages/react-native-executorch/cpp/core/dtype.cpp
new file mode 100644
index 0000000000..4acc4fdd26
--- /dev/null
+++ b/packages/react-native-executorch/cpp/core/dtype.cpp
@@ -0,0 +1,62 @@
+#include "dtype.h"
+#include <stdexcept>
+
+namespace rnexecutorch::core::types {
+DType parseDType(const std::string &s) {
+    if (s == "uint8")
+        return DType::uint8;
+    if (s == "int32")
+        return DType::int32;
+    if (s == "float32")
+        return DType::float32;
+    throw std::invalid_argument("Unsupported dtype: '" + s +
+                                "'. Expected 'uint8', 'int32', or 'float32'");
+}
+
+std::string toString(DType dtype) {
+    switch (dtype) {
+    case DType::uint8:
+        return "uint8";
+    case DType::int32:
+        return "int32";
+    case DType::float32:
+        return "float32";
+    }
+}
+
+executorch::aten::ScalarType toScalarType(DType dtype) {
+    switch (dtype) {
+    case DType::uint8:
+        return executorch::aten::ScalarType::Byte;
+    case DType::int32:
+        return executorch::aten::ScalarType::Int;
+    case DType::float32:
+        return executorch::aten::ScalarType::Float;
+    }
+}
+
+DType fromScalarType(executorch::aten::ScalarType st) {
+    switch (st) {
+    case executorch::aten::ScalarType::Byte:
+        return DType::uint8;
+    case executorch::aten::ScalarType::Int:
+        return DType::int32;
+    case executorch::aten::ScalarType::Float:
+        return DType::float32;
+    default:
+        throw std::invalid_argument("Unsupported ScalarType");
+    }
+}
+
+size_t elementSize(DType dtype) {
+    switch (dtype) {
+    case DType::uint8:
+        return 1;
+    case DType::int32:
+        return 4;
+    case DType::float32:
+        return 4;
+    }
+}
+
+} // namespace rnexecutorch::core::types
diff --git a/packages/react-native-executorch/cpp/core/dtype.h b/packages/react-native-executorch/cpp/core/dtype.h
new file mode 100644
index 0000000000..fcc395a566
--- /dev/null
+++ b/packages/react-native-executorch/cpp/core/dtype.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <cstdint>
+#include <executorch/runtime/core/exec_aten/exec_aten.h>
+#include <string>
+
+namespace rnexecutorch::core::types {
+enum DType { uint8,
+             int32,
+             float32 };
+
+DType parseDType(const std::string &s);
+std::string toString(DType dtype);
+
+executorch::aten::ScalarType toScalarType(DType dtype);
+DType fromScalarType(executorch::aten::ScalarType st);
+
+size_t elementSize(DType dtype);
+
+} // namespace rnexecutorch::core::types
diff --git a/packages/react-native-executorch/cpp/core/install.cpp b/packages/react-native-executorch/cpp/core/install.cpp
new file mode 100644
index 0000000000..1a2d3b1ab4
--- /dev/null
+++ b/packages/react-native-executorch/cpp/core/install.cpp
@@ -0,0 +1,12 @@
+#include "install.h"
+#include "model.h"
+#include "tensor.h"
+#include "utils.h"
+
+namespace rnexecutorch::core {
+void install(facebook::jsi::Runtime &rt, facebook::jsi::Object &module) {
+    utils::install_getExecuTorchRegisteredBackends(rt, module);
+    model::install_loadModel(rt, module);
+    tensor::install_createTensor(rt, module);
+}
+} // namespace rnexecutorch::core
diff --git a/packages/react-native-executorch/cpp/core/install.h b/packages/react-native-executorch/cpp/core/install.h
new file mode 100644
index 0000000000..9e17949adb
--- /dev/null
+++ b/packages/react-native-executorch/cpp/core/install.h
@@ -0,0 +1,7 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+namespace rnexecutorch::core {
+void install(facebook::jsi::Runtime &rt, facebook::jsi::Object &module);
+} // namespace rnexecutorch::core
diff --git a/packages/react-native-executorch/cpp/core/model.cpp b/packages/react-native-executorch/cpp/core/model.cpp
new file mode 100644
index 0000000000..b52b69752b
--- /dev/null
+++ b/packages/react-native-executorch/cpp/core/model.cpp
@@ -0,0 +1,529 @@
+#include "model.h"
+#include "dtype.h"
+#include "tensor.h"
+
+#include <chrono>
+#include <unordered_set>
+
+#include <executorch/runtime/backend/interface.h>
+#include <executorch/runtime/core/error.h>
+#include <executorch/runtime/core/tag.h>
+
+namespace rnexecutorch::core::model {
+namespace jsi = facebook::jsi;
+using TensorHostObject = rnexecutorch::core::tensor::TensorHostObject;
+
+ModelHostObject::ModelHostObject(const std::string &modelPath)
+    : modelPath_(modelPath), etModule_(std::make_unique<executorch::extension::Module>(modelPath)) {
+}
+
+jsi::Value ModelHostObject::get(jsi::Runtime &rt, const jsi::PropNameID &name) {
+    auto nameStr = name.utf8(rt);
+
+    if (nameStr == "path") {
+        return jsi::String::createFromUtf8(rt, modelPath_);
+    }
+
+    if (nameStr == "getMethodNames") {
+        auto self = shared_from_this();
+        auto fnBody = [self](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+                             size_t count) -> jsi::Value {
+            if (count != 0) {
+                throw jsi::JSError(rt, "getMethodNames: Usage: getMethodNames()");
+            }
+
+            std::unique_lock<std::mutex> lock(self->mutex_, std::try_to_lock);
+            if (!lock.owns_lock()) {
+                throw jsi::JSError(rt, "getMethodNames: Model is currently in use");
+            }
+
+            if (!self->etModule_) {
+                throw jsi::JSError(rt, "getMethodNames: Model has been disposed");
+            }
+
+            auto methodNames = self->etModule_->method_names();
+            if (!methodNames.ok()) {
+                std::string errorMsg = executorch::runtime::to_string(methodNames.error());
+                throw jsi::JSError(rt, "getMethodNames: Failed to get method names: " + errorMsg);
+            }
+
+            auto jsArray = jsi::Array(rt, methodNames->size());
+            size_t index = 0;
+            for (const auto &methodName : methodNames.get()) {
+                jsArray.setValueAtIndex(rt, index, jsi::String::createFromUtf8(rt, methodName));
+                ++index;
+            }
+
+            return jsArray;
+        };
+        return jsi::Function::createFromHostFunction(
+            rt, jsi::PropNameID::forAscii(rt, "getMethodNames"), 0, fnBody);
+    }
+
+    if (nameStr == "getMethodMeta") {
+        auto self = shared_from_this();
+        auto fnBody = [self](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+                             size_t count) -> jsi::Value {
+            if (count != 1) {
+                throw jsi::JSError(rt, "getMethodMeta: Usage: getMethodMeta(methodName)");
+            }
+
+            if (!args[0].isString()) {
+                throw jsi::JSError(rt, "getMethodMeta: Expected arg0 to be a string");
+            }
+
+            std::unique_lock<std::mutex> lock(self->mutex_, std::try_to_lock);
+            if (!lock.owns_lock()) {
+                throw jsi::JSError(rt, "getMethodMeta: Model is currently in use");
+            }
+
+            if (!self->etModule_) {
+                throw jsi::JSError(rt, "getMethodMeta: Model has been disposed");
+            }
+
+            auto methodName = args[0].asString(rt).utf8(rt);
+            auto methodMeta = self->etModule_->method_meta(methodName);
+            if (!methodMeta.ok()) {
+                std::string errorMsg = executorch::runtime::to_string(methodMeta.error());
+                throw jsi::JSError(rt, "getMethodMeta: Failed to get method meta: " + errorMsg);
+            }
+
+            auto inputTagsArray = jsi::Array(rt, methodMeta->num_inputs());
+            for (size_t i = 0; i < methodMeta->num_inputs(); ++i) {
+                auto tag = methodMeta->input_tag(i);
+                if (!tag.ok()) {
+                    std::string errorMsg = executorch::runtime::to_string(tag.error());
+                    throw jsi::JSError(rt, "getMethodMeta: Failed to get input tag for input " +
+                                               std::to_string(i) + ": " + errorMsg);
+                }
+                inputTagsArray.setValueAtIndex(
+                    rt, i, jsi::String::createFromUtf8(rt, executorch::runtime::tag_to_string(tag.get())));
+            }
+
+            auto outputTagsArray = jsi::Array(rt, methodMeta->num_outputs());
+            for (size_t i = 0; i < methodMeta->num_outputs(); ++i) {
+                auto tag = methodMeta->output_tag(i);
+                if (!tag.ok()) {
+                    std::string errorMsg = executorch::runtime::to_string(tag.error());
+                    throw jsi::JSError(rt, "getMethodMeta: Failed to get output tag for output " +
+                                               std::to_string(i) + ": " + errorMsg);
+                }
+                outputTagsArray.setValueAtIndex(
+                    rt, i, jsi::String::createFromUtf8(rt, executorch::runtime::tag_to_string(tag.get())));
+            }
+
+            auto usesBackendMap = jsi::Object(rt);
+            for (size_t i = 0; i < methodMeta->num_backends(); ++i) {
+                auto backendName = methodMeta->get_backend_name(i);
+                if (!backendName.ok()) {
+                    std::string errorMsg = executorch::runtime::to_string(backendName.error());
+                    throw jsi::JSError(rt, "getMethodMeta: Failed to get backend name for backend " +
+                                               std::to_string(i) + ": " + errorMsg);
+                }
+                usesBackendMap.setProperty(rt, backendName.get(),
+                                           methodMeta->uses_backend(backendName.get()));
+            }
+
+            auto tensorMetaToJS = [](jsi::Runtime &rt,
+                                     const executorch::runtime::TensorInfo &tensorMeta) -> jsi::Object {
+                auto jsTensorMeta = jsi::Object(rt);
+                jsTensorMeta.setProperty(rt, "name",
+                                         jsi::String::createFromUtf8(rt, std::string(tensorMeta.name())));
+                jsTensorMeta.setProperty(rt, "ndim", static_cast<double>(tensorMeta.sizes().size()));
+                jsTensorMeta.setProperty(rt, "nbytes", static_cast<double>(tensorMeta.nbytes()));
+
+                try {
+                    std::string dtypeStr = rnexecutorch::core::types::toString(
+                        rnexecutorch::core::types::fromScalarType(tensorMeta.scalar_type()));
+                    jsTensorMeta.setProperty(rt, "dtype", jsi::String::createFromUtf8(rt, dtypeStr));
+                } catch (const std::exception &) {
+                    jsTensorMeta.setProperty(rt, "dtype", jsi::String::createFromUtf8(rt, "not supported"));
+                }
+
+                auto jsShapeArray = jsi::Array(rt, tensorMeta.sizes().size());
+                for (size_t i = 0; i < tensorMeta.sizes().size(); ++i) {
+                    jsShapeArray.setValueAtIndex(rt, i, static_cast<double>(tensorMeta.sizes()[i]));
+                }
+                jsTensorMeta.setProperty(rt, "shape", jsShapeArray);
+
+                return jsTensorMeta;
+            };
+
+            auto inputTensorMetaArray = jsi::Array(rt, methodMeta->num_inputs());
+            for (size_t i = 0; i < methodMeta->num_inputs(); ++i) {
+                auto tensorMeta = methodMeta->input_tensor_meta(i);
+                if (!tensorMeta.ok()) {
+                    std::string errorMsg = executorch::runtime::to_string(tensorMeta.error());
+                    throw jsi::JSError(rt, "getMethodMeta: Failed to get tensor meta for input " +
+                                               std::to_string(i) + ": " + errorMsg);
+                }
+                inputTensorMetaArray.setValueAtIndex(rt, i, tensorMetaToJS(rt, tensorMeta.get()));
+            }
+
+            auto outputTensorMetaArray = jsi::Array(rt, methodMeta->num_outputs());
+            for (size_t i = 0; i < methodMeta->num_outputs(); ++i) {
+                auto tensorMeta = methodMeta->output_tensor_meta(i);
+                if (!tensorMeta.ok()) {
+                    std::string errorMsg = executorch::runtime::to_string(tensorMeta.error());
+                    throw jsi::JSError(rt, "getMethodMeta: Failed to get tensor meta for output " +
+                                               std::to_string(i) + ": " + errorMsg);
+                }
+                outputTensorMetaArray.setValueAtIndex(rt, i, tensorMetaToJS(rt, tensorMeta.get()));
+            }
+
+            auto jsMeta = jsi::Object(rt);
+
+            jsMeta.setProperty(rt, "name", jsi::String::createFromUtf8(rt, methodMeta->name()));
+            jsMeta.setProperty(rt, "numInputs", static_cast<double>(methodMeta->num_inputs()));
+            jsMeta.setProperty(rt, "numOutputs", static_cast<double>(methodMeta->num_outputs()));
+            jsMeta.setProperty(rt, "inputTags", inputTagsArray);
+            jsMeta.setProperty(rt, "outputTags", outputTagsArray);
+            jsMeta.setProperty(rt, "usesBackend", usesBackendMap);
+            jsMeta.setProperty(rt, "inputTensorMeta", inputTensorMetaArray);
+            jsMeta.setProperty(rt, "outputTensorMeta", outputTensorMetaArray);
+
+            return jsMeta;
+        };
+        return jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "getMethodMeta"),
+                                                     1, fnBody);
+    }
+
+    if (nameStr == "execute") {
+        auto self = shared_from_this();
+        auto fnBody = [self](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+                             size_t count) -> jsi::Value {
+            if (count != 3) {
+                throw jsi::JSError(rt, "execute: Usage: execute(methodName, inputs, outputTensors)");
+            }
+
+            if (!args[0].isString()) {
+                throw jsi::JSError(rt, "execute: Expected arg0 to be a string");
+            }
+
+            if (!args[1].isObject() || !args[1].asObject(rt).isArray(rt)) {
+                throw jsi::JSError(rt, "execute: Expected arg1 to be an array");
+            }
+
+            if (!args[2].isObject() || !args[2].asObject(rt).isArray(rt)) {
+                throw jsi::JSError(rt, "execute: Expected arg2 to be an array");
+            }
+
+            std::unique_lock<std::mutex> lock(self->mutex_, std::try_to_lock);
+            if (!lock.owns_lock()) {
+                throw jsi::JSError(rt, "execute: Model is currently in use");
+            }
+
+            if (!self->etModule_) {
+                throw jsi::JSError(rt, "execute: Model has been disposed");
+            }
+
+            auto methodName = args[0].asString(rt).utf8(rt);
+            auto methodMeta = self->etModule_->method_meta(methodName);
+            auto inputsArray = args[1].asObject(rt).asArray(rt);
+
+            if (!methodMeta.ok()) {
+                std::string errorMsg = executorch::runtime::to_string(methodMeta.error());
+                throw jsi::JSError(rt, "execute: Failed to get method meta for '" + methodName +
+                                           "': " + errorMsg);
+            }
+
+            if (inputsArray.size(rt) != methodMeta->num_inputs()) {
+                std::string errorMsg = "execute: Incorrect size for inputs: got " +
+                                       std::to_string(inputsArray.size(rt)) + ", expected " +
+                                       std::to_string(methodMeta->num_inputs());
+                throw jsi::JSError(rt, errorMsg);
+            }
+
+            auto validateTensor =
+                [](jsi::Runtime &rt, const TensorHostObject *tensorHostObject,
+                   const executorch::runtime::Result<executorch::runtime::TensorInfo> &tensorMeta,
+                   const std::string &identifier) {
+                    if (tensorMeta->scalar_type() != tensorHostObject->tensor_->dtype()) {
+                        throw jsi::JSError(rt, "execute: Tensor dtype mismatch for " + identifier);
+                    }
+
+                    if (tensorMeta->sizes().size() != tensorHostObject->shape_.size()) {
+                        throw jsi::JSError(rt, "execute: Tensor rank mismatch for " + identifier +
+                                                   ": expected rank " +
+                                                   std::to_string(tensorMeta->sizes().size()) + " but got " +
+                                                   std::to_string(tensorHostObject->shape_.size()));
+                    }
+
+                    auto ndim = tensorHostObject->tensor_->sizes().size();
+                    for (size_t j = 0; j < ndim; ++j) {
+                        if (tensorMeta->sizes()[j] != tensorHostObject->shape_[j]) {
+                            throw jsi::JSError(rt, "execute: Tensor shape mismatch for " + identifier +
+                                                       ": expected dimension " + std::to_string(j) + " to be " +
+                                                       std::to_string(tensorMeta->sizes()[j]) + " but got " +
+                                                       std::to_string(tensorHostObject->shape_[j]));
+                        }
+                    }
+                };
+
+            auto inputs = std::vector<executorch::runtime::EValue>(methodMeta->num_inputs());
+            std::vector<std::unique_lock<std::shared_mutex>> tensorLocks;
+            std::unordered_set<TensorHostObject *> lockedTensors;
+
+            for (size_t i = 0; i < methodMeta->num_inputs(); ++i) {
+                auto tag = methodMeta->input_tag(i);
+                auto val = inputsArray.getValueAtIndex(rt, i);
+
+                if (!tag.ok()) {
+                    std::string errorMsg = executorch::runtime::to_string(tag.error());
+                    throw jsi::JSError(rt, "execute: Failed to get input tag for inputs[" +
+                                               std::to_string(i) + "]: " + errorMsg);
+                }
+
+                switch (tag.get()) {
+                case executorch::runtime::Tag::None: {
+                    if (!val.isNull()) {
+                        throw jsi::JSError(rt,
+                                           "execute: Expected inputs[" + std::to_string(i) + "] to be null");
+                    }
+                    inputs[i] = executorch::runtime::EValue();
+                    break;
+                }
+                case executorch::runtime::Tag::Tensor: {
+                    if (!val.isObject() || !val.asObject(rt).isHostObject<TensorHostObject>(rt)) {
+                        throw jsi::JSError(rt, "execute: Expected inputs[" + std::to_string(i) +
+                                                   "] to be a TensorHostObject");
+                    }
+
+                    auto tensorHostObject = val.asObject(rt).getHostObject<TensorHostObject>(rt);
+                    if (!tensorHostObject->data_) {
+                        throw jsi::JSError(rt, "execute: inputs[" + std::to_string(i) + "] has been disposed");
+                    }
+
+                    if (!lockedTensors.insert(tensorHostObject.get()).second) {
+                        throw jsi::JSError(
+                            rt,
+                            "execute: Tensor aliasing detected. The same tensor was passed multiple times.");
+                    }
+
+                    tensorLocks.emplace_back(tensorHostObject->mutex_, std::try_to_lock);
+                    if (!tensorLocks.back().owns_lock()) {
+                        throw jsi::JSError(rt,
+                                           "execute: inputs[" + std::to_string(i) + "] is currently in use");
+                    }
+
+                    auto tensorMeta = methodMeta->input_tensor_meta(i);
+
+                    if (!tensorMeta.ok()) {
+                        std::string errorMsg = executorch::runtime::to_string(tensorMeta.error());
+                        throw jsi::JSError(rt, "execute: Failed to get tensor meta for inputs[" +
+                                                   std::to_string(i) + "]: " + errorMsg);
+                    }
+
+                    validateTensor(rt, tensorHostObject.get(), tensorMeta,
+                                   "inputs[" + std::to_string(i) + "]");
+
+                    inputs[i] = tensorHostObject->tensor_;
+                    break;
+                }
+                case executorch::runtime::Tag::Double: {
+                    if (!val.isNumber()) {
+                        throw jsi::JSError(rt, "execute: Expected inputs[" + std::to_string(i) +
+                                                   "] to be a number");
+                    }
+                    inputs[i] = executorch::runtime::EValue(val.asNumber());
+                    break;
+                }
+                case executorch::runtime::Tag::Int: {
+                    if (!val.isNumber()) {
+                        throw jsi::JSError(rt, "execute: Expected inputs[" + std::to_string(i) +
+                                                   "] to be a number");
+                    }
+                    inputs[i] = executorch::runtime::EValue(static_cast<int64_t>(val.asNumber()));
+                    break;
+                }
+                case executorch::runtime::Tag::Bool: {
+                    if (!val.isBool()) {
+                        throw jsi::JSError(rt, "execute: Expected inputs[" + std::to_string(i) +
+                                                   "] to be a boolean");
+                    }
+                    inputs[i] = executorch::runtime::EValue(val.asBool());
+                    break;
+                }
+                default: {
+                    throw jsi::JSError(rt, "execute: Unsupported input type for inputs[" + std::to_string(i) +
+                                               "]");
+                }
+                }
+            }
+
+            auto startTime = std::chrono::high_resolution_clock::now();
+            auto result = self->etModule_->execute(methodName, inputs);
+            auto finishTime = std::chrono::high_resolution_clock::now();
+
+#ifdef EXECUTORCH_ENABLE_EXECUTION_PROFILING
+            auto durationMs =
+                std::chrono::duration_cast<std::chrono::milliseconds>(finishTime - startTime).count();
+            auto consoleObj = rt.global().getProperty(rt, "console").asObject(rt);
+            auto logFn = consoleObj.getProperty(rt, "log").asObject(rt).asFunction(rt);
+            auto info =
+                "Execution of method '" + methodName + "' took " + std::to_string(durationMs) + " ms";
+            logFn.callWithThis(rt, consoleObj, {jsi::String::createFromUtf8(rt, info)});
+#endif
+
+            if (!result.ok()) {
+                std::string errorMsg = executorch::runtime::to_string(result.error());
+                throw jsi::JSError(
+                    rt, "execute: Method '" + methodName + "' execution failed: " + errorMsg +
+                            ". This may be due to missing required backends - use getMethodMeta()" +
+                            " to check required backends and getExecuTorchRegisteredBackends()" +
+                            " to check which backends are registered in the runtime.");
+            }
+
+            auto outputTensorsArray = args[2].asObject(rt).asArray(rt);
+            auto jsOutputArray = jsi::Array(rt, result->size());
+
+            size_t index = 0;
+            size_t tensorOutputIdx = 0;
+
+            for (const auto &output : result.get()) {
+                switch (output.tag) {
+                case executorch::runtime::Tag::None: {
+                    jsOutputArray.setValueAtIndex(rt, index, jsi::Value::null());
+                    break;
+                }
+                case executorch::runtime::Tag::Tensor: {
+                    if (tensorOutputIdx >= outputTensorsArray.size(rt)) {
+                        throw jsi::JSError(rt,
+                                           "execute: Not enough tensor output placeholders in outputTensors");
+                    }
+
+                    auto val = outputTensorsArray.getValueAtIndex(rt, tensorOutputIdx);
+                    if (!val.isObject() || !val.asObject(rt).isHostObject<TensorHostObject>(rt)) {
+                        throw jsi::JSError(rt, "execute: Expected outputTensors[" +
+                                                   std::to_string(tensorOutputIdx) +
+                                                   "] to be a TensorHostObject");
+                    }
+
+                    auto tensorHostObject = val.asObject(rt).getHostObject<TensorHostObject>(rt);
+                    if (!tensorHostObject->data_) {
+                        throw jsi::JSError(rt, "execute: outputTensors[" + std::to_string(tensorOutputIdx) +
+                                                   "] has been disposed");
+                    }
+
+                    if (!lockedTensors.insert(tensorHostObject.get()).second) {
+                        throw jsi::JSError(
+                            rt,
+                            "execute: Tensor aliasing detected. The same tensor was passed multiple times.");
+                    }
+
+                    tensorLocks.emplace_back(tensorHostObject->mutex_, std::try_to_lock);
+                    if (!tensorLocks.back().owns_lock()) {
+                        throw jsi::JSError(rt, "execute: outputTensors[" + std::to_string(tensorOutputIdx) +
+                                                   "] is currently in use");
+                    }
+
+                    auto tensorMeta = methodMeta->output_tensor_meta(index);
+
+                    if (!tensorMeta.ok()) {
+                        std::string errorMsg = executorch::runtime::to_string(tensorMeta.error());
+                        throw jsi::JSError(rt, "execute: Failed to get tensor meta for output at index " +
+                                                   std::to_string(index) + ": " + errorMsg);
+                    }
+
+                    validateTensor(rt, tensorHostObject.get(), tensorMeta,
+                                   "outputTensors[" + std::to_string(tensorOutputIdx) + "]");
+
+                    std::memcpy(tensorHostObject->data_.get(), output.toTensor().const_data_ptr(),
+                                output.toTensor().nbytes());
+
+                    jsOutputArray.setValueAtIndex(rt, index,
+                                                  jsi::Object::createFromHostObject(rt, tensorHostObject));
+                    ++tensorOutputIdx;
+
+                    break;
+                }
+                case executorch::runtime::Tag::Double: {
+                    jsOutputArray.setValueAtIndex(rt, index, output.toDouble());
+                    break;
+                }
+                case executorch::runtime::Tag::Int: {
+                    jsOutputArray.setValueAtIndex(rt, index, static_cast<double>(output.toInt()));
+                    break;
+                }
+                case executorch::runtime::Tag::Bool: {
+                    jsOutputArray.setValueAtIndex(rt, index, output.toBool());
+                    break;
+                }
+                default: {
+                    throw jsi::JSError(rt, "execute: Unsupported return type");
+                }
+                }
+
+                ++index;
+            }
+
+            return jsOutputArray;
+        };
+        return jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "execute"), 3,
+                                                     fnBody);
+    }
+
+    if (nameStr == "dispose") {
+        auto self = shared_from_this();
+        auto fnBody = [self](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+                             size_t count) -> jsi::Value {
+            if (count != 0) {
+                throw jsi::JSError(rt, "dispose: Usage: dispose()");
+            }
+
+            std::unique_lock<std::mutex> lock(self->mutex_);
+
+            if (!self->etModule_) {
+                throw jsi::JSError(rt, "dispose: Model has already been disposed");
+            }
+
+            self->etModule_.reset();
+
+            return jsi::Value::undefined();
+        };
+        return jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "dispose"), 0,
+                                                     fnBody);
+    }
+
+    return jsi::Value::undefined();
+}
+
+std::vector<facebook::jsi::PropNameID> ModelHostObject::getPropertyNames(jsi::Runtime &rt) {
+    std::vector<facebook::jsi::PropNameID> properties;
+    properties.push_back(jsi::PropNameID::forAscii(rt, "path"));
+    properties.push_back(jsi::PropNameID::forAscii(rt, "getMethodNames"));
+    properties.push_back(jsi::PropNameID::forAscii(rt, "getMethodMeta"));
+    properties.push_back(jsi::PropNameID::forAscii(rt, "execute"));
+    properties.push_back(jsi::PropNameID::forAscii(rt, "dispose"));
+    return properties;
+}
+
+void install_loadModel(jsi::Runtime &rt, jsi::Object &module) {
+    auto name = "loadModel";
+    auto fnBody = [](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+                     size_t count) -> jsi::Value {
+        if (count != 1) {
+            throw jsi::JSError(rt, "loadModel: Usage: loadModel(arg0)");
+        }
+
+        if (!args[0].isString()) {
+            throw jsi::JSError(rt, "loadModel: Expected arg0 to be a string");
+        }
+
+        auto modelPath = args[0].asString(rt).utf8(rt);
+        auto modelInstance = std::make_shared<ModelHostObject>(modelPath);
+
+        auto error = modelInstance->etModule_->load();
+        if (!modelInstance->etModule_->is_loaded()) {
+            std::string errorMsg = executorch::runtime::to_string(error);
+            throw jsi::JSError(rt, "loadModel: Failed to load model: " + errorMsg);
+        }
+
+        return jsi::Object::createFromHostObject(rt, modelInstance);
+    };
+    auto fn =
+        jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, name), 1, fnBody);
+
+    module.setProperty(rt, name, fn);
+}
+} // namespace rnexecutorch::core::model
diff --git a/packages/react-native-executorch/cpp/core/model.h b/packages/react-native-executorch/cpp/core/model.h
new file mode 100644
index 0000000000..a30da90bb8
--- /dev/null
+++ b/packages/react-native-executorch/cpp/core/model.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <memory>
+#include <mutex>
+#include <string>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+#include <executorch/extension/module/module.h>
+
+namespace rnexecutorch::core::model {
+class ModelHostObject : public facebook::jsi::HostObject,
+                        public std::enable_shared_from_this<ModelHostObject> {
+public:
+    std::string modelPath_;
+    std::unique_ptr<executorch::extension::Module> etModule_;
+    std::mutex mutex_;
+
+    ModelHostObject(const std::string &modelPath);
+
+    facebook::jsi::Value get(facebook::jsi::Runtime &rt,
+                             const facebook::jsi::PropNameID &name) override;
+    std::vector<facebook::jsi::PropNameID> getPropertyNames(facebook::jsi::Runtime &rt) override;
+};
+
+void install_loadModel(facebook::jsi::Runtime &rt, facebook::jsi::Object &module);
+} // namespace rnexecutorch::core::model
diff --git a/packages/react-native-executorch/cpp/core/tensor.cpp b/packages/react-native-executorch/cpp/core/tensor.cpp
new file mode 100644
index 0000000000..971a9e61af
--- /dev/null
+++ b/packages/react-native-executorch/cpp/core/tensor.cpp
@@ -0,0 +1,356 @@
+#include "tensor.h"
+#include <cstring>
+#include <numeric>
+
+namespace rnexecutorch::core::tensor {
+namespace jsi = facebook::jsi;
+
+TensorHostObject::TensorHostObject(const std::vector<std::int32_t> &shape,
+                                   rnexecutorch::core::types::DType dtype) {
+    const auto elemSize = rnexecutorch::core::types::elementSize(dtype);
+
+    dtype_ = dtype;
+    shape_ = shape;
+    numel_ = std::accumulate(shape.begin(), shape.end(), size_t(1), std::multiplies<size_t>());
+
+    size_ = numel_ * elemSize;
+    data_ = std::make_unique<std::uint8_t[]>(size_);
+    tensor_ = executorch::extension::from_blob(data_.get(), shape_,
+                                               rnexecutorch::core::types::toScalarType(dtype));
+}
+
+jsi::Value TensorHostObject::get(jsi::Runtime &rt, const jsi::PropNameID &name) {
+    auto nameStr = name.utf8(rt);
+
+    if (nameStr == "shape") {
+        auto jsArray = jsi::Array(rt, shape_.size());
+        for (size_t i = 0; i < shape_.size(); ++i) {
+            jsArray.setValueAtIndex(rt, i, static_cast<double>(shape_[i]));
+        }
+        return jsArray;
+    }
+
+    if (nameStr == "dtype") {
+        return jsi::String::createFromUtf8(rt, rnexecutorch::core::types::toString(dtype_));
+    }
+
+    if (nameStr == "numel") {
+        return jsi::Value(static_cast<double>(numel_));
+    }
+
+    if (nameStr == "copyTo") {
+        auto self = shared_from_this();
+        auto fnBody = [self](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+                             size_t count) -> jsi::Value {
+            if (count != 1) {
+                throw jsi::JSError(rt, "copyTo: Usage: copyTo(dst)");
+            }
+
+            if (!args[0].isObject() || !args[0].asObject(rt).isHostObject<TensorHostObject>(rt)) {
+                throw jsi::JSError(rt, "copyTo: Expected dst to be a Tensor");
+            }
+
+            auto dst = args[0].asObject(rt).getHostObject<TensorHostObject>(rt);
+
+            if (self.get() == dst.get()) {
+                throw jsi::JSError(rt, "copyTo: In-place operations (src == dst) are not supported.");
+            }
+
+            std::shared_lock<std::shared_mutex> src_lock(self->mutex_, std::try_to_lock);
+            if (!src_lock.owns_lock()) {
+                throw jsi::JSError(rt, "copyTo: src tensor is currently in use");
+            }
+
+            std::unique_lock<std::shared_mutex> dst_lock(dst->mutex_, std::try_to_lock);
+            if (!dst_lock.owns_lock()) {
+                throw jsi::JSError(rt, "copyTo: dst tensor is currently in use");
+            }
+
+            if (!self->data_) {
+                throw jsi::JSError(rt, "copyTo: src tensor has been disposed");
+            }
+
+            if (!dst->data_) {
+                throw jsi::JSError(rt, "copyTo: dst tensor has been disposed");
+            }
+
+            if (self->size_ != dst->size_) {
+                throw jsi::JSError(rt, "copyTo: size mismatch between src and dst tensors");
+            }
+
+            std::memcpy(dst->data_.get(), self->data_.get(), self->size_);
+
+            return jsi::Value(rt, args[0].asObject(rt));
+        };
+        return jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "copyTo"), 1,
+                                                     fnBody);
+    }
+
+    if (nameStr == "setData") {
+        auto self = shared_from_this();
+        auto fnBody = [self](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+                             size_t count) -> jsi::Value {
+            if (count != 1) {
+                throw jsi::JSError(rt, "setData: Usage: setData(array)");
+            }
+
+            if (!args[0].isObject()) {
+                throw jsi::JSError(rt, "setData: Expected array to be an object (TypedArray)");
+            }
+
+            jsi::Object dataObj = args[0].asObject(rt);
+            if (!dataObj.hasProperty(rt, "buffer")) {
+                throw jsi::JSError(rt, "setData: Expected a TypedArray with a 'buffer' property");
+            }
+
+            jsi::ArrayBuffer buffer = dataObj.getProperty(rt, "buffer").asObject(rt).getArrayBuffer(rt);
+            size_t byteOffset = 0;
+            size_t byteLength = buffer.size(rt);
+
+            if (dataObj.hasProperty(rt, "byteOffset")) {
+                auto byteOffsetValue = dataObj.getProperty(rt, "byteOffset");
+                if (!byteOffsetValue.isNumber()) {
+                    throw jsi::JSError(rt, "setData: Expected 'byteOffset' to be a number");
+                }
+                byteOffset = static_cast<size_t>(byteOffsetValue.asNumber());
+            }
+
+            if (dataObj.hasProperty(rt, "byteLength")) {
+                auto byteLengthValue = dataObj.getProperty(rt, "byteLength");
+                if (!byteLengthValue.isNumber()) {
+                    throw jsi::JSError(rt, "setData: Expected 'byteLength' to be a number");
+                }
+                byteLength = static_cast<size_t>(byteLengthValue.asNumber());
+            }
+
+            std::unique_lock<std::shared_mutex> lock(self->mutex_, std::try_to_lock);
+            if (!lock.owns_lock()) {
+                throw jsi::JSError(rt, "setData: Tensor is currently in use and cannot be written to");
+            }
+
+            if (!self->data_) {
+                throw jsi::JSError(rt, "setData: Tensor has been disposed");
+            }
+
+            if (byteLength != self->size_) {
+                std::string errorMsg = "setData: Data size mismatch: TypedArray is " +
+                                       std::to_string(byteLength) + " bytes, but Tensor requires " +
+                                       std::to_string(self->size_) + " bytes.";
+                throw jsi::JSError(rt, errorMsg);
+            }
+
+            std::memcpy(self->data_.get(), buffer.data(rt) + byteOffset, byteLength);
+
+            return jsi::Value(rt, thisVal.asObject(rt));
+        };
+        return jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "setData"), 1,
+                                                     fnBody);
+    }
+
+    if (nameStr == "getData") {
+        auto self = shared_from_this();
+        auto fnBody = [self](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+                             size_t count) -> jsi::Value {
+            if (count != 1) {
+                throw jsi::JSError(rt, "getData: Usage: getData(array)");
+            }
+
+            if (!args[0].isObject()) {
+                throw jsi::JSError(rt, "getData: Expected array to be an object (TypedArray)");
+            }
+
+            jsi::Object dataObj = args[0].asObject(rt);
+            if (!dataObj.hasProperty(rt, "buffer")) {
+                throw jsi::JSError(rt, "getData: Expected a TypedArray with a 'buffer' property");
+            }
+
+            jsi::ArrayBuffer buffer = dataObj.getProperty(rt, "buffer").asObject(rt).getArrayBuffer(rt);
+            size_t byteOffset = 0;
+            size_t byteLength = buffer.size(rt);
+
+            if (dataObj.hasProperty(rt, "byteOffset")) {
+                auto byteOffsetValue = dataObj.getProperty(rt, "byteOffset");
+                if (!byteOffsetValue.isNumber()) {
+                    throw jsi::JSError(rt, "getData: Expected 'byteOffset' to be a number");
+                }
+                byteOffset = static_cast<size_t>(byteOffsetValue.asNumber());
+            }
+
+            if (dataObj.hasProperty(rt, "byteLength")) {
+                auto byteLengthValue = dataObj.getProperty(rt, "byteLength");
+                if (!byteLengthValue.isNumber()) {
+                    throw jsi::JSError(rt, "getData: Expected 'byteLength' to be a number");
+                }
+                byteLength = static_cast<size_t>(byteLengthValue.asNumber());
+            }
+
+            std::shared_lock<std::shared_mutex> lock(self->mutex_, std::try_to_lock);
+            if (!lock.owns_lock()) {
+                throw jsi::JSError(rt, "getData: Tensor is currently in use and cannot be read");
+            }
+
+            if (!self->data_) {
+                throw jsi::JSError(rt, "getData: Tensor has been disposed");
+            }
+
+            if (byteLength != self->size_) {
+                std::string errorMsg = "getData: Data size mismatch: TypedArray is " +
+                                       std::to_string(byteLength) + " bytes, but Tensor requires " +
+                                       std::to_string(self->size_) + " bytes.";
+                throw jsi::JSError(rt, errorMsg);
+            }
+
+            std::memcpy(buffer.data(rt) + byteOffset, self->data_.get(), byteLength);
+
+            return jsi::Value(rt, args[0].asObject(rt));
+        };
+        return jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "getData"), 1,
+                                                     fnBody);
+    }
+
+    if (nameStr == "through") {
+        auto self = shared_from_this();
+        auto fnBody = [self](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+                             size_t count) -> jsi::Value {
+            if (count < 1) {
+                throw jsi::JSError(rt, "through: Usage: through(fn, ...args)");
+            }
+
+            if (!args[0].isObject() || !args[0].asObject(rt).isFunction(rt)) {
+                throw jsi::JSError(rt, "through: First argument must be a function");
+            }
+
+            auto fn = args[0].asObject(rt).asFunction(rt);
+
+            std::vector<jsi::Value> fnArgs;
+            fnArgs.reserve(count);
+            fnArgs.push_back(jsi::Value(rt, thisVal));
+            for (size_t i = 1; i < count; ++i) {
+                fnArgs.push_back(jsi::Value(rt, args[i]));
+            }
+
+            return fn.call(rt, static_cast<const jsi::Value *>(fnArgs.data()), fnArgs.size());
+        };
+
+        return jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "through"), 1,
+                                                     fnBody);
+    }
+
+    if (nameStr == "throughIf") {
+        auto self = shared_from_this();
+        auto fnBody = [self](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+                             size_t count) -> jsi::Value {
+            if (count < 2) {
+                throw jsi::JSError(rt, "throughIf: Usage: throughIf(pred, fn, ...args)");
+            }
+
+            bool pred = args[0].asBool();
+            if (!pred) {
+                return jsi::Value(rt, thisVal);
+            }
+
+            if (!args[1].isObject() || !args[1].asObject(rt).isFunction(rt)) {
+                throw jsi::JSError(rt, "throughIf: Second argument must be a function");
+            }
+
+            auto fn = args[1].asObject(rt).asFunction(rt);
+
+            std::vector<jsi::Value> fnArgs;
+            fnArgs.reserve(count - 1);
+            fnArgs.push_back(jsi::Value(rt, thisVal));
+            for (size_t i = 2; i < count; ++i) {
+                fnArgs.push_back(jsi::Value(rt, args[i]));
+            }
+
+            return fn.call(rt, static_cast<const jsi::Value *>(fnArgs.data()), fnArgs.size());
+        };
+
+        return jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "throughIf"), 2,
+                                                     fnBody);
+    }
+
+    if (nameStr == "dispose") {
+        auto self = shared_from_this();
+        auto fnBody = [self](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+                             size_t count) -> jsi::Value {
+            if (count != 0) {
+                throw jsi::JSError(rt, "dispose: Usage: dispose()");
+            }
+
+            std::unique_lock<std::shared_mutex> lock(self->mutex_);
+
+            if (!self->data_) {
+                throw jsi::JSError(rt, "dispose: Tensor has already been disposed");
+            }
+
+            self->tensor_.reset();
+            self->data_.reset();
+
+            return jsi::Value::undefined();
+        };
+        return jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "dispose"), 0,
+                                                     fnBody);
+    }
+
+    return jsi::Value::undefined();
+}
+
+std::vector<facebook::jsi::PropNameID> TensorHostObject::getPropertyNames(jsi::Runtime &rt) {
+    std::vector<facebook::jsi::PropNameID> properties;
+    properties.push_back(jsi::PropNameID::forAscii(rt, "shape"));
+    properties.push_back(jsi::PropNameID::forAscii(rt, "dtype"));
+    properties.push_back(jsi::PropNameID::forAscii(rt, "numel"));
+    properties.push_back(jsi::PropNameID::forAscii(rt, "copyTo"));
+    properties.push_back(jsi::PropNameID::forAscii(rt, "setData"));
+    properties.push_back(jsi::PropNameID::forAscii(rt, "getData"));
+    properties.push_back(jsi::PropNameID::forAscii(rt, "through"));
+    properties.push_back(jsi::PropNameID::forAscii(rt, "throughIf"));
+    properties.push_back(jsi::PropNameID::forAscii(rt, "dispose"));
+    return properties;
+}
+
+void install_createTensor(jsi::Runtime &rt, jsi::Object &module) {
+    auto name = "createTensor";
+    auto fnBody = [](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+                     size_t count) -> jsi::Value {
+        if (count != 2) {
+            throw jsi::JSError(rt, "createTensor: Usage: createTensor(shape, dtype)");
+        }
+
+        if (!args[0].isObject() || !args[0].asObject(rt).isArray(rt)) {
+            throw jsi::JSError(rt, "createTensor: Expected shape as an array of integers");
+        }
+
+        if (!args[1].isString()) {
+            throw jsi::JSError(rt, "createTensor: Expected dtype as a string");
+        }
+
+        auto shapeArray = args[0].asObject(rt).asArray(rt);
+        std::vector<std::int32_t> shape;
+        for (size_t i = 0; i < shapeArray.length(rt); ++i) {
+            auto dimValue = shapeArray.getValueAtIndex(rt, i);
+            if (!dimValue.isNumber()) {
+                throw jsi::JSError(rt, "createTensor: Shape array must contain only numbers");
+            }
+
+            if (dimValue.asNumber() <= 0) {
+                throw jsi::JSError(rt, "createTensor: Shape dimensions must be positive integers");
+            }
+
+            shape.push_back(static_cast<std::int32_t>(dimValue.asNumber()));
+        }
+
+        try {
+            const auto dtype = rnexecutorch::core::types::parseDType(args[1].asString(rt).utf8(rt));
+            auto tensorHostObject = std::make_shared<TensorHostObject>(shape, dtype);
+            return jsi::Object::createFromHostObject(rt, tensorHostObject);
+        } catch (const std::exception &e) {
+            throw jsi::JSError(rt, "createTensor: Error creating tensor: " + std::string(e.what()));
+        }
+    };
+    auto fn =
+        jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, name), 2, fnBody);
+
+    module.setProperty(rt, name, fn);
+}
+} // namespace rnexecutorch::core::tensor
diff --git a/packages/react-native-executorch/cpp/core/tensor.h b/packages/react-native-executorch/cpp/core/tensor.h
new file mode 100644
index 0000000000..4555b3a583
--- /dev/null
+++ b/packages/react-native-executorch/cpp/core/tensor.h
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <mutex>
+#include <shared_mutex>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+#include <executorch/extension/tensor/tensor.h>
+#include <executorch/runtime/core/exec_aten/exec_aten.h>
+
+#include "dtype.h"
+
+namespace rnexecutorch::core::tensor {
+class TensorHostObject : public facebook::jsi::HostObject,
+                         public std::enable_shared_from_this<TensorHostObject> {
+public:
+    rnexecutorch::core::types::DType dtype_;
+    std::vector<std::int32_t> shape_;
+    size_t numel_;
+
+    size_t size_;
+    std::unique_ptr<std::uint8_t[]> data_;
+    executorch::extension::TensorPtr tensor_;
+
+    std::shared_mutex mutex_;
+
+    TensorHostObject(const std::vector<std::int32_t> &shape, rnexecutorch::core::types::DType dtype);
+
+    facebook::jsi::Value get(facebook::jsi::Runtime &rt,
+                             const facebook::jsi::PropNameID &name) override;
+    std::vector<facebook::jsi::PropNameID> getPropertyNames(facebook::jsi::Runtime &rt) override;
+};
+
+void install_createTensor(facebook::jsi::Runtime &rt, facebook::jsi::Object &module);
+} // namespace rnexecutorch::core::tensor
diff --git a/packages/react-native-executorch/cpp/core/utils.cpp b/packages/react-native-executorch/cpp/core/utils.cpp
new file mode 100644
index 0000000000..193cd422ee
--- /dev/null
+++ b/packages/react-native-executorch/cpp/core/utils.cpp
@@ -0,0 +1,36 @@
+#include "utils.h"
+
+#include <string>
+
+#include <executorch/runtime/backend/interface.h>
+#include <executorch/runtime/core/error.h>
+
+namespace rnexecutorch::core::utils {
+namespace jsi = facebook::jsi;
+
+void install_getExecuTorchRegisteredBackends(jsi::Runtime &rt, jsi::Object &module) {
+    auto name = "getExecuTorchRegisteredBackends";
+    auto fnBody = [](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+                     size_t count) -> jsi::Value {
+        if (count != 0) {
+            throw jsi::JSError(rt, "Usage: getExecuTorchRegisteredBackends()");
+        }
+
+        auto registeredCount = executorch::runtime::get_num_registered_backends();
+        auto jsArray = jsi::Array(rt, registeredCount);
+        for (size_t i = 0; i < registeredCount; ++i) {
+            auto backendName = executorch::runtime::get_backend_name(i);
+            if (!backendName.ok()) {
+                std::string errorMsg = executorch::runtime::to_string(backendName.error());
+                throw jsi::JSError(rt, "Failed to get backend name: " + errorMsg);
+            }
+            jsArray.setValueAtIndex(rt, i, jsi::String::createFromUtf8(rt, backendName.get()));
+        }
+        return jsArray;
+    };
+    auto fn =
+        jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, name), 0, fnBody);
+
+    module.setProperty(rt, name, fn);
+}
+} // namespace rnexecutorch::core::utils
diff --git a/packages/react-native-executorch/cpp/core/utils.h b/packages/react-native-executorch/cpp/core/utils.h
new file mode 100644
index 0000000000..cf2988c86b
--- /dev/null
+++ b/packages/react-native-executorch/cpp/core/utils.h
@@ -0,0 +1,8 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+namespace rnexecutorch::core::utils {
+void install_getExecuTorchRegisteredBackends(facebook::jsi::Runtime &rt,
+                                             facebook::jsi::Object &module);
+} // namespace rnexecutorch::core::utils
diff --git a/packages/react-native-executorch/ios/RnExecutorch.h b/packages/react-native-executorch/ios/RnExecutorch.h
new file mode 100644
index 0000000000..99f17f58a7
--- /dev/null
+++ b/packages/react-native-executorch/ios/RnExecutorch.h
@@ -0,0 +1,5 @@
+#import <RnExecutorchSpec/RnExecutorchSpec.h>
+
+@interface RnExecutorch : NSObject <NativeRnExecutorchSpec>
+
+@end
diff --git a/packages/react-native-executorch/ios/RnExecutorch.mm b/packages/react-native-executorch/ios/RnExecutorch.mm
new file mode 100644
index 0000000000..50c29f2ebd
--- /dev/null
+++ b/packages/react-native-executorch/ios/RnExecutorch.mm
@@ -0,0 +1,31 @@
+#import "RnExecutorch.h"
+#import "../cpp/RnExecutorch.h"
+#import <React/RCTBridge+Private.h>
+#import <jsi/jsi.h>
+
+@implementation RnExecutorch
+RCT_EXPORT_MODULE()
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+    return std::make_shared<facebook::react::NativeRnExecutorchSpecJSI>(params);
+}
+
+RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(NSNumber *, install) {
+    RCTBridge *bridge = [RCTBridge currentBridge];
+    RCTCxxBridge *cxxBridge = (RCTCxxBridge *)bridge;
+
+    if (cxxBridge == nil)
+        return @NO;
+
+    facebook::jsi::Runtime *jsiRuntime = (facebook::jsi::Runtime *)cxxBridge.runtime;
+
+    if (jsiRuntime == nil)
+        return @NO;
+
+    rnexecutorch::install(*jsiRuntime);
+
+    return @YES;
+}
+
+@end
diff --git a/packages/react-native-executorch/ios/RnExecutorch.xcodeproj/project.pbxproj b/packages/react-native-executorch/ios/RnExecutorch.xcodeproj/project.pbxproj
deleted file mode 100644
index 89935c29b8..0000000000
--- a/packages/react-native-executorch/ios/RnExecutorch.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,389 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 77;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		8C9A9BD02DB0CE800027DD32 /* ImageSegmentation.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8C9A9BCA2DB0CE800027DD32 /* ImageSegmentation.cpp */; };
-		8C9A9BD12DB0CE800027DD32 /* RuntimeLifecycleMonitor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8C9A9BC72DB0CE800027DD32 /* RuntimeLifecycleMonitor.cpp */; };
-		8C9A9BD22DB0CE800027DD32 /* JsiHostObject.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8C9A9BC22DB0CE800027DD32 /* JsiHostObject.cpp */; };
-		8C9A9BD32DB0CE800027DD32 /* JsiPromise.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8C9A9BC42DB0CE800027DD32 /* JsiPromise.cpp */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXCopyFilesBuildPhase section */
-		550986872CEF541900FECBB8 /* CopyFiles */ = {
-			isa = PBXCopyFilesBuildPhase;
-			buildActionMask = 2147483647;
-			dstPath = "include/$(PRODUCT_NAME)";
-			dstSubfolderSpec = 16;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXCopyFilesBuildPhase section */
-
-/* Begin PBXFileReference section */
-		550986892CEF541900FECBB8 /* libRnExecutorch.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libRnExecutorch.a; sourceTree = BUILT_PRODUCTS_DIR; };
-		55D6EA8B2D0987D2009BA408 /* ExecutorchLib.xcframework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcframework; path = ExecutorchLib.xcframework; sourceTree = "<group>"; };
-		8C9A9BBF2DB0CE800027DD32 /* ModelHostObject.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ModelHostObject.h; sourceTree = "<group>"; };
-		8C9A9BC12DB0CE800027DD32 /* JsiHostObject.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = JsiHostObject.h; sourceTree = "<group>"; };
-		8C9A9BC22DB0CE800027DD32 /* JsiHostObject.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = JsiHostObject.cpp; sourceTree = "<group>"; };
-		8C9A9BC32DB0CE800027DD32 /* JsiPromise.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = JsiPromise.h; sourceTree = "<group>"; };
-		8C9A9BC42DB0CE800027DD32 /* JsiPromise.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = JsiPromise.cpp; sourceTree = "<group>"; };
-		8C9A9BC52DB0CE800027DD32 /* RuntimeAwareCache.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RuntimeAwareCache.h; sourceTree = "<group>"; };
-		8C9A9BC62DB0CE800027DD32 /* RuntimeLifecycleMonitor.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RuntimeLifecycleMonitor.h; sourceTree = "<group>"; };
-		8C9A9BC72DB0CE800027DD32 /* RuntimeLifecycleMonitor.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RuntimeLifecycleMonitor.cpp; sourceTree = "<group>"; };
-		8C9A9BC92DB0CE800027DD32 /* ImageSegmentation.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ImageSegmentation.h; sourceTree = "<group>"; };
-		8C9A9BCA2DB0CE800027DD32 /* ImageSegmentation.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = ImageSegmentation.cpp; sourceTree = "<group>"; };
-		8C9A9BCC2DB0CE800027DD32 /* Log.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = Log.h; sourceTree = "<group>"; };
-		8C9A9BCD2DB0CE800027DD32 /* RnExecutorchInstaller.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RnExecutorchInstaller.h; sourceTree = "<group>"; };
-/* End PBXFileReference section */
-
-/* Begin PBXFileSystemSynchronizedRootGroup section */
-		5509868B2CEF541900FECBB8 /* RnExecutorch */ = {
-			isa = PBXFileSystemSynchronizedRootGroup;
-			path = RnExecutorch;
-			sourceTree = "<group>";
-		};
-/* End PBXFileSystemSynchronizedRootGroup section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		550986862CEF541900FECBB8 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		550986802CEF541900FECBB8 = {
-			isa = PBXGroup;
-			children = (
-				8C9A9BCF2DB0CE800027DD32 /* common */,
-				5509868B2CEF541900FECBB8 /* RnExecutorch */,
-				55D6EA8A2D0987D2009BA408 /* Frameworks */,
-				5509868A2CEF541900FECBB8 /* Products */,
-			);
-			sourceTree = "<group>";
-		};
-		5509868A2CEF541900FECBB8 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				550986892CEF541900FECBB8 /* libRnExecutorch.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		55D6EA8A2D0987D2009BA408 /* Frameworks */ = {
-			isa = PBXGroup;
-			children = (
-				55D6EA8B2D0987D2009BA408 /* ExecutorchLib.xcframework */,
-			);
-			name = Frameworks;
-			sourceTree = "<group>";
-		};
-		8C9A9BC02DB0CE800027DD32 /* host_objects */ = {
-			isa = PBXGroup;
-			children = (
-				8C9A9BBF2DB0CE800027DD32 /* ModelHostObject.h */,
-			);
-			path = host_objects;
-			sourceTree = "<group>";
-		};
-		8C9A9BC82DB0CE800027DD32 /* jsi */ = {
-			isa = PBXGroup;
-			children = (
-				8C9A9BC12DB0CE800027DD32 /* JsiHostObject.h */,
-				8C9A9BC22DB0CE800027DD32 /* JsiHostObject.cpp */,
-				8C9A9BC32DB0CE800027DD32 /* JsiPromise.h */,
-				8C9A9BC42DB0CE800027DD32 /* JsiPromise.cpp */,
-				8C9A9BC52DB0CE800027DD32 /* RuntimeAwareCache.h */,
-				8C9A9BC62DB0CE800027DD32 /* RuntimeLifecycleMonitor.h */,
-				8C9A9BC72DB0CE800027DD32 /* RuntimeLifecycleMonitor.cpp */,
-			);
-			path = jsi;
-			sourceTree = "<group>";
-		};
-		8C9A9BCB2DB0CE800027DD32 /* modules */ = {
-			isa = PBXGroup;
-			children = (
-				8C9A9BC92DB0CE800027DD32 /* ImageSegmentation.h */,
-				8C9A9BCA2DB0CE800027DD32 /* ImageSegmentation.cpp */,
-			);
-			path = modules;
-			sourceTree = "<group>";
-		};
-		8C9A9BCE2DB0CE800027DD32 /* rnexecutorch */ = {
-			isa = PBXGroup;
-			children = (
-				8C9A9BC02DB0CE800027DD32 /* host_objects */,
-				8C9A9BC82DB0CE800027DD32 /* jsi */,
-				8C9A9BCB2DB0CE800027DD32 /* modules */,
-				8C9A9BCC2DB0CE800027DD32 /* Log.h */,
-				8C9A9BCD2DB0CE800027DD32 /* RnExecutorchInstaller.h */,
-			);
-			path = rnexecutorch;
-			sourceTree = "<group>";
-		};
-		8C9A9BCF2DB0CE800027DD32 /* common */ = {
-			isa = PBXGroup;
-			children = (
-				8C9A9BCE2DB0CE800027DD32 /* rnexecutorch */,
-			);
-			name = common;
-			path = ../common;
-			sourceTree = SOURCE_ROOT;
-		};
-/* End PBXGroup section */
-
-/* Begin PBXNativeTarget section */
-		550986882CEF541900FECBB8 /* RnExecutorch */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 550986932CEF541900FECBB8 /* Build configuration list for PBXNativeTarget "RnExecutorch" */;
-			buildPhases = (
-				550986852CEF541900FECBB8 /* Sources */,
-				550986862CEF541900FECBB8 /* Frameworks */,
-				550986872CEF541900FECBB8 /* CopyFiles */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			fileSystemSynchronizedGroups = (
-				5509868B2CEF541900FECBB8 /* RnExecutorch */,
-			);
-			name = RnExecutorch;
-			productName = RnExecutorch;
-			productReference = 550986892CEF541900FECBB8 /* libRnExecutorch.a */;
-			productType = "com.apple.product-type.library.static";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		550986812CEF541900FECBB8 /* Project object */ = {
-			isa = PBXProject;
-			attributes = {
-				BuildIndependentTargetsInParallel = 1;
-				LastUpgradeCheck = 1610;
-				TargetAttributes = {
-					550986882CEF541900FECBB8 = {
-						CreatedOnToolsVersion = 16.1;
-						LastSwiftMigration = 1610;
-					};
-				};
-			};
-			buildConfigurationList = 550986842CEF541900FECBB8 /* Build configuration list for PBXProject "RnExecutorch" */;
-			developmentRegion = en;
-			hasScannedForEncodings = 0;
-			knownRegions = (
-				en,
-				Base,
-			);
-			mainGroup = 550986802CEF541900FECBB8;
-			minimizedProjectReferenceProxies = 1;
-			preferredProjectObjectVersion = 77;
-			productRefGroup = 5509868A2CEF541900FECBB8 /* Products */;
-			projectDirPath = "";
-			projectRoot = "";
-			targets = (
-				550986882CEF541900FECBB8 /* RnExecutorch */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXSourcesBuildPhase section */
-		550986852CEF541900FECBB8 /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				8C9A9BD02DB0CE800027DD32 /* ImageSegmentation.cpp in Sources */,
-				8C9A9BD12DB0CE800027DD32 /* RuntimeLifecycleMonitor.cpp in Sources */,
-				8C9A9BD22DB0CE800027DD32 /* JsiHostObject.cpp in Sources */,
-				8C9A9BD32DB0CE800027DD32 /* JsiPromise.cpp in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin XCBuildConfiguration section */
-		550986912CEF541900FECBB8 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
-				CLANG_ANALYZER_NONNULL = YES;
-				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
-				CLANG_CXX_LANGUAGE_STANDARD = "gnu++20";
-				CLANG_ENABLE_MODULES = YES;
-				CLANG_ENABLE_OBJC_ARC = YES;
-				CLANG_ENABLE_OBJC_WEAK = YES;
-				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
-				CLANG_WARN_BOOL_CONVERSION = YES;
-				CLANG_WARN_COMMA = YES;
-				CLANG_WARN_CONSTANT_CONVERSION = YES;
-				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
-				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
-				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
-				CLANG_WARN_EMPTY_BODY = YES;
-				CLANG_WARN_ENUM_CONVERSION = YES;
-				CLANG_WARN_INFINITE_RECURSION = YES;
-				CLANG_WARN_INT_CONVERSION = YES;
-				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
-				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
-				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
-				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
-				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
-				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
-				CLANG_WARN_STRICT_PROTOTYPES = YES;
-				CLANG_WARN_SUSPICIOUS_MOVE = YES;
-				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
-				CLANG_WARN_UNREACHABLE_CODE = YES;
-				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
-				COPY_PHASE_STRIP = NO;
-				DEBUG_INFORMATION_FORMAT = dwarf;
-				ENABLE_STRICT_OBJC_MSGSEND = YES;
-				ENABLE_TESTABILITY = YES;
-				ENABLE_USER_SCRIPT_SANDBOXING = YES;
-				GCC_C_LANGUAGE_STANDARD = gnu17;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_NO_COMMON_BLOCKS = YES;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					"DEBUG=1",
-					"$(inherited)",
-				);
-				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
-				GCC_WARN_UNDECLARED_SELECTOR = YES;
-				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
-				GCC_WARN_UNUSED_FUNCTION = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				IPHONEOS_DEPLOYMENT_TARGET = 17.0;
-				LOCALIZATION_PREFERS_STRING_CATALOGS = YES;
-				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
-				MTL_FAST_MATH = YES;
-				ONLY_ACTIVE_ARCH = YES;
-				SDKROOT = iphoneos;
-			};
-			name = Debug;
-		};
-		550986922CEF541900FECBB8 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
-				CLANG_ANALYZER_NONNULL = YES;
-				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
-				CLANG_CXX_LANGUAGE_STANDARD = "gnu++20";
-				CLANG_ENABLE_MODULES = YES;
-				CLANG_ENABLE_OBJC_ARC = YES;
-				CLANG_ENABLE_OBJC_WEAK = YES;
-				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
-				CLANG_WARN_BOOL_CONVERSION = YES;
-				CLANG_WARN_COMMA = YES;
-				CLANG_WARN_CONSTANT_CONVERSION = YES;
-				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
-				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
-				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
-				CLANG_WARN_EMPTY_BODY = YES;
-				CLANG_WARN_ENUM_CONVERSION = YES;
-				CLANG_WARN_INFINITE_RECURSION = YES;
-				CLANG_WARN_INT_CONVERSION = YES;
-				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
-				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
-				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
-				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
-				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
-				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
-				CLANG_WARN_STRICT_PROTOTYPES = YES;
-				CLANG_WARN_SUSPICIOUS_MOVE = YES;
-				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
-				CLANG_WARN_UNREACHABLE_CODE = YES;
-				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
-				COPY_PHASE_STRIP = NO;
-				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
-				ENABLE_NS_ASSERTIONS = NO;
-				ENABLE_STRICT_OBJC_MSGSEND = YES;
-				ENABLE_USER_SCRIPT_SANDBOXING = YES;
-				GCC_C_LANGUAGE_STANDARD = gnu17;
-				GCC_NO_COMMON_BLOCKS = YES;
-				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
-				GCC_WARN_UNDECLARED_SELECTOR = YES;
-				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
-				GCC_WARN_UNUSED_FUNCTION = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				IPHONEOS_DEPLOYMENT_TARGET = 17.0;
-				LOCALIZATION_PREFERS_STRING_CATALOGS = YES;
-				MTL_ENABLE_DEBUG_INFO = NO;
-				MTL_FAST_MATH = YES;
-				SDKROOT = iphoneos;
-				VALIDATE_PRODUCT = YES;
-			};
-			name = Release;
-		};
-		550986942CEF541900FECBB8 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				CLANG_ENABLE_MODULES = YES;
-				CODE_SIGN_STYLE = Automatic;
-				OTHER_LDFLAGS = "-ObjC";
-				PRODUCT_NAME = "$(TARGET_NAME)";
-				SKIP_INSTALL = YES;
-				SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
-				SUPPORTS_MACCATALYST = NO;
-				SUPPORTS_MAC_DESIGNED_FOR_IPHONE_IPAD = NO;
-				SUPPORTS_XR_DESIGNED_FOR_IPHONE_IPAD = NO;
-				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
-				SWIFT_VERSION = 6.0;
-				TARGETED_DEVICE_FAMILY = "1,2";
-			};
-			name = Debug;
-		};
-		550986952CEF541900FECBB8 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				CLANG_ENABLE_MODULES = YES;
-				CODE_SIGN_STYLE = Automatic;
-				OTHER_LDFLAGS = "-ObjC";
-				PRODUCT_NAME = "$(TARGET_NAME)";
-				SKIP_INSTALL = YES;
-				SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
-				SUPPORTS_MACCATALYST = NO;
-				SUPPORTS_MAC_DESIGNED_FOR_IPHONE_IPAD = NO;
-				SUPPORTS_XR_DESIGNED_FOR_IPHONE_IPAD = NO;
-				SWIFT_VERSION = 6.0;
-				TARGETED_DEVICE_FAMILY = "1,2";
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		550986842CEF541900FECBB8 /* Build configuration list for PBXProject "RnExecutorch" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				550986912CEF541900FECBB8 /* Debug */,
-				550986922CEF541900FECBB8 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		550986932CEF541900FECBB8 /* Build configuration list for PBXNativeTarget "RnExecutorch" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				550986942CEF541900FECBB8 /* Debug */,
-				550986952CEF541900FECBB8 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 550986812CEF541900FECBB8 /* Project object */;
-}
diff --git a/packages/react-native-executorch/ios/RnExecutorch/ETInstaller.h b/packages/react-native-executorch/ios/RnExecutorch/ETInstaller.h
deleted file mode 100644
index d01236e994..0000000000
--- a/packages/react-native-executorch/ios/RnExecutorch/ETInstaller.h
+++ /dev/null
@@ -1,8 +0,0 @@
-#import <React/RCTCallInvokerModule.h>
-#import <React/RCTEventEmitter.h>
-#import <RnExecutorchSpec/RnExecutorchSpec.h>
-
-@interface ETInstaller
-    : RCTEventEmitter <NativeETInstallerSpec, RCTCallInvokerModule>
-
-@end
diff --git a/packages/react-native-executorch/ios/RnExecutorch/ETInstaller.mm b/packages/react-native-executorch/ios/RnExecutorch/ETInstaller.mm
deleted file mode 100644
index 2a8bc519ba..0000000000
--- a/packages/react-native-executorch/ios/RnExecutorch/ETInstaller.mm
+++ /dev/null
@@ -1,58 +0,0 @@
-#import "ETInstaller.h"
-
-#import <React/RCTBridge+Private.h>
-
-#import <React/RCTCallInvoker.h>
-#import <ReactCommon/RCTTurboModule.h>
-#import <TargetConditionals.h>
-#include <rnexecutorch/RnExecutorchInstaller.h>
-#include <stdexcept>
-
-using namespace facebook::react;
-
-@interface RCTBridge (JSIRuntime)
-- (void *)runtime;
-@end
-
-@implementation ETInstaller
-
-@synthesize callInvoker = _callInvoker;
-
-RCT_EXPORT_MODULE(ETInstaller);
-
-RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) {
-  auto jsiRuntime =
-      reinterpret_cast<facebook::jsi::Runtime *>(self.bridge.runtime);
-  auto jsCallInvoker = _callInvoker.callInvoker;
-
-  assert(jsiRuntime != nullptr);
-
-  auto fetchUrl = [](std::string url) {
-    @try {
-      NSString *nsUrlStr =
-          [NSString stringWithCString:url.c_str()
-                             encoding:[NSString defaultCStringEncoding]];
-      NSURL *nsUrl = [NSURL URLWithString:nsUrlStr];
-      NSData *data = [NSData dataWithContentsOfURL:nsUrl];
-      const std::byte *bytePtr =
-          reinterpret_cast<const std::byte *>(data.bytes);
-      int bufferLength = [data length];
-      return std::vector<std::byte>(bytePtr, bytePtr + bufferLength);
-    } @catch (NSException *exception) {
-      throw std::runtime_error("Error fetching data from a url");
-    }
-  };
-  bool isEmulator = TARGET_OS_SIMULATOR;
-  rnexecutorch::RnExecutorchInstaller::injectJSIBindings(
-      jsiRuntime, jsCallInvoker, fetchUrl, isEmulator);
-
-  NSLog(@"Successfully installed JSI bindings for react-native-executorch!");
-  return @true;
-}
-
-- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
-    (const facebook::react::ObjCTurboModule::InitParams &)params {
-  return std::make_shared<facebook::react::NativeETInstallerSpecJSI>(params);
-}
-
-@end
diff --git a/packages/react-native-executorch/package.json b/packages/react-native-executorch/package.json
index 4d6493fdfa..cac6b74a5e 100644
--- a/packages/react-native-executorch/package.json
+++ b/packages/react-native-executorch/package.json
@@ -1,43 +1,39 @@
 {
   "name": "react-native-executorch",
-  "version": "0.10.0",
+  "version": "0.0.0",
   "description": "An easy way to run AI models in React Native with ExecuTorch",
-  "source": "./src/index.ts",
   "main": "./lib/module/index.js",
   "module": "./lib/module/index.js",
-  "types": "./lib/typescript/index.d.ts",
-  "react-native": "src/index",
+  "types": "./lib/typescript/src/index.d.ts",
+  "source": "./src/index.ts",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./lib/typescript/src/index.d.ts",
+      "default": "./lib/module/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "files": [
     "src",
     "lib",
     "android",
     "ios",
     "cpp",
-    "common",
-    "!common/rnexecutorch/tests",
-    "*.podspec",
-    "third-party/include",
     "third-party",
-    "!third-party/ios/ExecutorchLib",
-    "!third-party/ios/libs/executorch",
-    "!ios/*.xcodeproj",
-    "!ios/build",
+    "*.podspec",
     "!android/build",
-    "!android/gradle",
-    "!android/gradlew",
-    "!android/gradlew.bat",
-    "!android/local.properties",
+    "!ios/build",
     "!**/__tests__",
     "!**/__fixtures__",
     "!**/__mocks__",
     "!**/.*"
   ],
   "scripts": {
-    "example": "yarn workspace react-native-executorch-example",
+    "clean": "del-cli lib",
+    "prepare": "bob build",
     "typecheck": "tsc --noEmit",
     "lint": "eslint \"**/*.{js,ts,tsx}\"",
-    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
-    "prepare": "bob build",
     "prepack": "cp ../../README.md ./README.md",
     "postpack": "rm ./README.md"
   },
@@ -64,7 +60,7 @@
     "url": "git+https://github.com/software-mansion/react-native-executorch.git",
     "directory": "packages/react-native-executorch"
   },
-  "author": "Norbert Klockiewicz <norbert.klockiewicz@swmansion.com> (https://github.com/NorbertKlockiewicz)",
+  "author": "Software Mansion <hello@swmansion.com> (https://github.com/software-mansion)",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/software-mansion/react-native-executorch/issues"
@@ -75,39 +71,33 @@
   },
   "peerDependencies": {
     "react": "*",
-    "react-native": "*"
+    "react-native": "*",
+    "react-native-worklets": "*"
   },
   "devDependencies": {
-    "@react-native-community/cli": "latest",
-    "@types/jest": "^30.0.0",
-    "@types/react": "~19.2.0",
-    "jest": "^30.2.0",
-    "metro-react-native-babel-preset": "^0.77.0",
-    "react": "19.2.3",
-    "react-native": "0.85.3",
-    "react-native-builder-bob": "^0.40.12",
+    "@react-native/babel-preset": "0.83.6",
+    "@types/react": "^19.1.12",
+    "del-cli": "^6.0.0",
+    "react": "19.2.0",
+    "react-native": "0.83.6",
+    "react-native-builder-bob": "^0.40.18",
+    "react-native-worklets": "0.9.1",
     "typescript": "~5.9.2"
   },
-  "workspaces": [
-    "example"
-  ],
-  "packageManager": "yarn@4.1.1",
-  "babel": {
-    "presets": [
-      "module:metro-react-native-babel-preset"
-    ]
-  },
   "react-native-builder-bob": {
     "source": "src",
     "output": "lib",
     "targets": [
       [
-        "module"
+        "module",
+        {
+          "esm": true
+        }
       ],
       [
         "typescript",
         {
-          "project": "tsconfig.json"
+          "project": "tsconfig.build.json"
         }
       ]
     ]
@@ -115,16 +105,15 @@
   "codegenConfig": {
     "name": "RnExecutorchSpec",
     "type": "modules",
-    "jsSrcsDir": "./src/native",
+    "jsSrcsDir": "src",
     "android": {
       "javaPackageName": "com.swmansion.rnexecutorch"
     }
   },
-  "dependencies": {
-    "@huggingface/jinja": "^0.5.0",
-    "jsonrepair": "^3.12.0",
-    "jsonschema": "^1.5.0",
-    "react-native-device-info": "^15.0.2",
-    "zod": "^4.3.6"
+  "create-react-native-library": {
+    "type": "turbo-module",
+    "languages": "kotlin-objc",
+    "tools": [],
+    "version": "0.57.2"
   }
 }
diff --git a/packages/react-native-executorch/react-native-executorch.podspec b/packages/react-native-executorch/react-native-executorch.podspec
index daf0da27c7..a6e25a9fc0 100644
--- a/packages/react-native-executorch/react-native-executorch.podspec
+++ b/packages/react-native-executorch/react-native-executorch.podspec
@@ -10,81 +10,33 @@ Pod::Spec.new do |s|
   s.license      = package["license"]
   s.authors      = package["author"]
 
-  s.platforms    = { :ios => '17.0' }
+  s.platforms    = { :ios => min_ios_version_supported }
   s.source       = { :git => "https://github.com/software-mansion/react-native-executorch.git", :tag => "#{s.version}" }
 
+  s.source_files = "ios/**/*.{h,m,mm,swift,cpp}", "cpp/**/*.{hpp,cpp,c,h}"
+  s.private_header_files = "ios/**/*.h"
 
-  pthreadpool_binaries_path = File.expand_path('$(PODS_TARGET_SRCROOT)/third-party/ios/libs/pthreadpool', __dir__)
-  cpuinfo_binaries_path = File.expand_path('$(PODS_TARGET_SRCROOT)/third-party/ios/libs/cpuinfo', __dir__)
+  s.ios.vendored_frameworks = "third-party/ios/Frameworks/ExecutorchLib.xcframework"
+  s.frameworks = "CoreML", "Metal", "MetalPerformanceShaders", "Accelerate"
+  s.library = "sqlite3"
 
-  s.user_target_xcconfig = {
-    "HEADER_SEARCH_PATHS" =>
-      '"$(PODS_TARGET_SRCROOT)/third-party/include" '+
-      '"$(PODS_TARGET_SRCROOT)/third-party/include/cpuinfo" '+
-      '"$(PODS_TARGET_SRCROOT)/third-party/include/pthreadpool"',
-
-    "OTHER_LDFLAGS[sdk=iphoneos*]" => [
-      '$(inherited)',
-      "\"#{pthreadpool_binaries_path}/physical-arm64-release/libpthreadpool.a\"",
-      "\"#{cpuinfo_binaries_path}/libcpuinfo.a\"",
+  s.pod_target_xcconfig = {
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
 
+    "GCC_PREPROCESSOR_DEFINITIONS" => [
+      "$(inherited)",
+      "C10_USING_CUSTOM_GENERATED_MACROS=1",
+      "EXECUTORCH_ENABLE_EXECUTION_PROFILING=1",
     ].join(' '),
 
-    "OTHER_LDFLAGS[sdk=iphonesimulator*]" => [
-      '$(inherited)',
-      "\"#{pthreadpool_binaries_path}/simulator-arm64-debug/libpthreadpool.a\"",
-      "\"#{cpuinfo_binaries_path}/libcpuinfo.a\"",
+    "HEADER_SEARCH_PATHS" => [
+      "\"$(PODS_TARGET_SRCROOT)/cpp\"",
+      "\"$(PODS_TARGET_SRCROOT)/third-party/include\"",
     ].join(' '),
-
-    'EXCLUDED_ARCHS[sdk=iphonesimulator*]' => 'x86_64',
+    
+    "WARNING_CFLAGS" => "-Wno-documentation"
   }
 
-  s.pod_target_xcconfig = {
-    "USE_HEADERMAP" => "YES",
-    "HEADER_SEARCH_PATHS" =>
-      '"$(PODS_TARGET_SRCROOT)/ios" '+
-      '"$(PODS_TARGET_SRCROOT)/third-party/include/executorch/extension/llm/tokenizers/include" '+
-      '"$(PODS_TARGET_SRCROOT)/third-party/include" '+
-      '"$(PODS_TARGET_SRCROOT)/third-party/include/cpuinfo" '+
-      '"$(PODS_TARGET_SRCROOT)/third-party/include/pthreadpool" '+
-      '"$(PODS_TARGET_SRCROOT)/common" ' +
-      '"$(PODS_TARGET_SRCROOT)/third-party/common/phonemis/src" ',
-    "GCC_PREPROCESSOR_DEFINITIONS" => '$(inherited) ET_ON=1',
-    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
-    'EXCLUDED_ARCHS[sdk=iphonesimulator*]' => 'x86_64',
-  }
-
-  s.source_files = [
-    "ios/**/*.{m,mm,h}",
-    "common/**/*.{cpp,c,h,hpp}",
-    "third-party/common/phonemis/src/**/*.{cpp,hpp,h}",
-  ]
-
-  s.libraries = "z"
-  s.ios.vendored_frameworks = "third-party/ios/ExecutorchLib.xcframework"
-
-  # NOTE: mlx.metallib (the MLX GPU kernels) is bundled INSIDE
-  # ExecutorchLib.framework, colocated with the binary that contains the MLX
-  # code. MLX's runtime loader resolves the metallib relative to that binary
-  # (via dladdr), so it must live next to it in the framework — not at the app
-  # bundle root.
-  # Exclude file with tests to not introduce gtest dependency.
-  # Do not include the headers from common/rnexecutorch/jsi/ as source files.
-  # Xcode/Cocoapods leaks them to other pods that an app also depends on, so if
-  # another pod includes a header with the same name without a path by
-  # #include "Header.h" we get a conflict. Here, headers in jsi/ collide with
-  # react-native-skia. The headers are preserved by preserve_paths and
-  # then made available by HEADER_SEARCH_PATHS.
-  s.exclude_files = [
-    "common/rnexecutorch/tests/**/*",
-    "common/rnexecutorch/jsi/*.{h,hpp}",
-    "third-party/common/phonemis/src/phonemis/main.cpp" # Exclude the phonemis runner
-  ]
-  s.header_mappings_dir = "common/rnexecutorch"
-  s.header_dir = "rnexecutorch"
-  s.preserve_paths = "common/rnexecutorch/jsi/*.{h,hpp}"
-
-  s.dependency "opencv-rne", "~> 4.11.0"
-
   install_modules_dependencies(s)
 end
+
diff --git a/packages/react-native-executorch/scripts/create-package.sh b/packages/react-native-executorch/scripts/create-package.sh
deleted file mode 100755
index 709af11d20..0000000000
--- a/packages/react-native-executorch/scripts/create-package.sh
+++ /dev/null
@@ -1,49 +0,0 @@
-#!/bin/bash
-
-# Phonemis is a git submodule whose sources the podspec compiles directly
-# (see third-party/common/phonemis/src in react-native-executorch.podspec).
-# Init it explicitly so the files are present in the packed tarball.
-# Run from repo root so the submodule path resolves regardless of cwd.
-git -C "$(git rev-parse --show-toplevel)" submodule update --init --recursive \
-  packages/react-native-executorch/third-party/common/phonemis
-
-# Trim phonemis to what consumers need at build time. Done here (not via
-# package.json "files") because the submodule's own .gitignore has
-# `!scripts/build*` which npm-packlist honors and re-includes those files
-# despite our exclusion rules. Restore on exit so the working tree stays clean.
-PHONEMIS_DIR="third-party/common/phonemis"
-restore_phonemis() {
-  git -C "$PHONEMIS_DIR" checkout -- data test scripts requirements.txt 2>/dev/null || true
-}
-trap restore_phonemis EXIT
-rm -rf "$PHONEMIS_DIR/data" "$PHONEMIS_DIR/test" "$PHONEMIS_DIR/scripts"
-rm -f "$PHONEMIS_DIR/requirements.txt"
-
-yarn install --immutable
-
-if [ $# -ge 1 ] && [ "$1" = "generate_nightly_version" ]; then
-  VERSION=$(jq -r '.version' package.json)
-  IFS='.' read -r MAJOR MINOR PATCH <<<"$VERSION"
-  GIT_COMMIT=$(git rev-parse HEAD)
-  DATE=$(date +%Y%m%d)
-  NIGHTLY_UNIQUE_NAME="${GIT_COMMIT:0:7}-$DATE"
-  if [[ "$OSTYPE" == "darwin"* ]]; then
-    sed -i '' "3s/.*/  \"version\": \"$MAJOR.$MINOR.$PATCH-nightly-$NIGHTLY_UNIQUE_NAME\",/" package.json
-  else
-    sed -i "3s/.*/  \"version\": \"$MAJOR.$MINOR.$PATCH-nightly-$NIGHTLY_UNIQUE_NAME\",/" package.json
-  fi
-fi
-
-yarn bob build
-
-npm pack
-
-if [ $# -ge 1 ] && [ "$1" = "generate_nightly_version" ]; then
-  if [[ "$OSTYPE" == "darwin"* ]]; then
-    sed -i '' "3s/.*/  \"version\": \"$MAJOR.$MINOR.$PATCH\",/" package.json
-  else
-    sed -i "3s/.*/  \"version\": \"$MAJOR.$MINOR.$PATCH\",/" package.json
-  fi
-fi
-
-echo "Done!"
diff --git a/packages/react-native-executorch/src/common/Logger.ts b/packages/react-native-executorch/src/common/Logger.ts
deleted file mode 100644
index 7e05f52a23..0000000000
--- a/packages/react-native-executorch/src/common/Logger.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-/**
- * High level wrapper that prefixes `console.<command>` with [React Native ExecuTorch] tag.
- */
-/* eslint-disable no-console */
-export class Logger {
-  private static readonly PREFIX = '[React Native ExecuTorch]';
-
-  static log(...data: any[]) {
-    console.log(Logger.PREFIX, ...data);
-  }
-
-  static debug(...data: any[]) {
-    console.debug(Logger.PREFIX, ...data);
-  }
-
-  static info(...data: any[]) {
-    console.info(Logger.PREFIX, ...data);
-  }
-
-  static warn(...data: any[]) {
-    console.warn(Logger.PREFIX, ...data);
-  }
-
-  static error(...data: any[]) {
-    console.error(Logger.PREFIX, ...data);
-  }
-}
diff --git a/packages/react-native-executorch/src/constants/classification.ts b/packages/react-native-executorch/src/constants/classification.ts
deleted file mode 100644
index ffd33fe894..0000000000
--- a/packages/react-native-executorch/src/constants/classification.ts
+++ /dev/null
@@ -1,1007 +0,0 @@
-/**
- * ImageNet-1K class labels used for image classification.
- * Contains 1000 classes from the ImageNet Large Scale Visual Recognition Challenge.
- * @category Types
- */
-export enum Imagenet1kLabel {
-  TENCH = 0,
-  GOLDFISH = 1,
-  GREAT_WHITE_SHARK = 2,
-  TIGER_SHARK = 3,
-  HAMMERHEAD = 4,
-  ELECTRIC_RAY = 5,
-  STINGRAY = 6,
-  COCK = 7,
-  HEN = 8,
-  OSTRICH = 9,
-  BRAMBLING = 10,
-  GOLDFINCH = 11,
-  HOUSE_FINCH = 12,
-  JUNCO = 13,
-  INDIGO_BUNTING = 14,
-  ROBIN = 15,
-  BULBUL = 16,
-  JAY = 17,
-  MAGPIE = 18,
-  CHICKADEE = 19,
-  WATER_OUZEL = 20,
-  KITE = 21,
-  BALD_EAGLE = 22,
-  VULTURE = 23,
-  GREAT_GREY_OWL = 24,
-  EUROPEAN_FIRE_SALAMANDER = 25,
-  COMMON_NEWT = 26,
-  EFT = 27,
-  SPOTTED_SALAMANDER = 28,
-  AXOLOTL = 29,
-  BULLFROG = 30,
-  TREE_FROG = 31,
-  TAILED_FROG = 32,
-  LOGGERHEAD = 33,
-  LEATHERBACK_TURTLE = 34,
-  MUD_TURTLE = 35,
-  TERRAPIN = 36,
-  BOX_TURTLE = 37,
-  BANDED_GECKO = 38,
-  COMMON_IGUANA = 39,
-  AMERICAN_CHAMELEON = 40,
-  WHIPTAIL = 41,
-  AGAMA = 42,
-  FRILLED_LIZARD = 43,
-  ALLIGATOR_LIZARD = 44,
-  GILA_MONSTER = 45,
-  GREEN_LIZARD = 46,
-  AFRICAN_CHAMELEON = 47,
-  KOMODO_DRAGON = 48,
-  AFRICAN_CROCODILE = 49,
-  AMERICAN_ALLIGATOR = 50,
-  TRICERATOPS = 51,
-  THUNDER_SNAKE = 52,
-  RINGNECK_SNAKE = 53,
-  HOGNOSE_SNAKE = 54,
-  GREEN_SNAKE = 55,
-  KING_SNAKE = 56,
-  GARTER_SNAKE = 57,
-  WATER_SNAKE = 58,
-  VINE_SNAKE = 59,
-  NIGHT_SNAKE = 60,
-  BOA_CONSTRICTOR = 61,
-  ROCK_PYTHON = 62,
-  INDIAN_COBRA = 63,
-  GREEN_MAMBA = 64,
-  SEA_SNAKE = 65,
-  HORNED_VIPER = 66,
-  DIAMONDBACK = 67,
-  SIDEWINDER = 68,
-  TRILOBITE = 69,
-  HARVESTMAN = 70,
-  SCORPION = 71,
-  BLACK_AND_GOLD_GARDEN_SPIDER = 72,
-  BARN_SPIDER = 73,
-  GARDEN_SPIDER = 74,
-  BLACK_WIDOW = 75,
-  TARANTULA = 76,
-  WOLF_SPIDER = 77,
-  TICK = 78,
-  CENTIPEDE = 79,
-  BLACK_GROUSE = 80,
-  PTARMIGAN = 81,
-  RUFFED_GROUSE = 82,
-  PRAIRIE_CHICKEN = 83,
-  PEACOCK = 84,
-  QUAIL = 85,
-  PARTRIDGE = 86,
-  AFRICAN_GREY = 87,
-  MACAW = 88,
-  SULPHUR_CRESTED_COCKATOO = 89,
-  LORIKEET = 90,
-  COUCAL = 91,
-  BEE_EATER = 92,
-  HORNBILL = 93,
-  HUMMINGBIRD = 94,
-  JACAMAR = 95,
-  TOUCAN = 96,
-  DRAKE = 97,
-  RED_BREASTED_MERGANSER = 98,
-  GOOSE = 99,
-  BLACK_SWAN = 100,
-  TUSKER = 101,
-  ECHIDNA = 102,
-  PLATYPUS = 103,
-  WALLABY = 104,
-  KOALA = 105,
-  WOMBAT = 106,
-  JELLYFISH = 107,
-  SEA_ANEMONE = 108,
-  BRAIN_CORAL = 109,
-  FLATWORM = 110,
-  NEMATODE = 111,
-  CONCH = 112,
-  SNAIL = 113,
-  SLUG = 114,
-  SEA_SLUG = 115,
-  CHITON = 116,
-  CHAMBERED_NAUTILUS = 117,
-  DUNGENESS_CRAB = 118,
-  ROCK_CRAB = 119,
-  FIDDLER_CRAB = 120,
-  KING_CRAB = 121,
-  AMERICAN_LOBSTER = 122,
-  SPINY_LOBSTER = 123,
-  CRAYFISH = 124,
-  HERMIT_CRAB = 125,
-  ISOPOD = 126,
-  WHITE_STORK = 127,
-  BLACK_STORK = 128,
-  SPOONBILL = 129,
-  FLAMINGO = 130,
-  LITTLE_BLUE_HERON = 131,
-  AMERICAN_EGRET = 132,
-  BITTERN = 133,
-  CRANE_BIRD = 134,
-  LIMPKIN = 135,
-  EUROPEAN_GALLINULE = 136,
-  AMERICAN_COOT = 137,
-  BUSTARD = 138,
-  RUDDY_TURNSTONE = 139,
-  RED_BACKED_SANDPIPER = 140,
-  REDSHANK = 141,
-  DOWITCHER = 142,
-  OYSTERCATCHER = 143,
-  PELICAN = 144,
-  KING_PENGUIN = 145,
-  ALBATROSS = 146,
-  GREY_WHALE = 147,
-  KILLER_WHALE = 148,
-  DUGONG = 149,
-  SEA_LION = 150,
-  CHIHUAHUA = 151,
-  JAPANESE_SPANIEL = 152,
-  MALTESE_DOG = 153,
-  PEKINESE = 154,
-  SHIH_TZU = 155,
-  BLENHEIM_SPANIEL = 156,
-  PAPILLON = 157,
-  TOY_TERRIER = 158,
-  RHODESIAN_RIDGEBACK = 159,
-  AFGHAN_HOUND = 160,
-  BASSET = 161,
-  BEAGLE = 162,
-  BLOODHOUND = 163,
-  BLUETICK = 164,
-  BLACK_AND_TAN_COONHOUND = 165,
-  WALKER_HOUND = 166,
-  ENGLISH_FOXHOUND = 167,
-  REDBONE = 168,
-  BORZOI = 169,
-  IRISH_WOLFHOUND = 170,
-  ITALIAN_GREYHOUND = 171,
-  WHIPPET = 172,
-  IBIZAN_HOUND = 173,
-  NORWEGIAN_ELKHOUND = 174,
-  OTTERHOUND = 175,
-  SALUKI = 176,
-  SCOTTISH_DEERHOUND = 177,
-  WEIMARANER = 178,
-  STAFFORDSHIRE_BULLTERRIER = 179,
-  AMERICAN_STAFFORDSHIRE_TERRIER = 180,
-  BEDLINGTON_TERRIER = 181,
-  BORDER_TERRIER = 182,
-  KERRY_BLUE_TERRIER = 183,
-  IRISH_TERRIER = 184,
-  NORFOLK_TERRIER = 185,
-  NORWICH_TERRIER = 186,
-  YORKSHIRE_TERRIER = 187,
-  WIRE_HAIRED_FOX_TERRIER = 188,
-  LAKELAND_TERRIER = 189,
-  SEALYHAM_TERRIER = 190,
-  AIREDALE = 191,
-  CAIRN = 192,
-  AUSTRALIAN_TERRIER = 193,
-  DANDIE_DINMONT = 194,
-  BOSTON_BULL = 195,
-  MINIATURE_SCHNAUZER = 196,
-  GIANT_SCHNAUZER = 197,
-  STANDARD_SCHNAUZER = 198,
-  SCOTCH_TERRIER = 199,
-  TIBETAN_TERRIER = 200,
-  SILKY_TERRIER = 201,
-  SOFT_COATED_WHEATEN_TERRIER = 202,
-  WEST_HIGHLAND_WHITE_TERRIER = 203,
-  LHASA = 204,
-  FLAT_COATED_RETRIEVER = 205,
-  CURLY_COATED_RETRIEVER = 206,
-  GOLDEN_RETRIEVER = 207,
-  LABRADOR_RETRIEVER = 208,
-  CHESAPEAKE_BAY_RETRIEVER = 209,
-  GERMAN_SHORT_HAIRED_POINTER = 210,
-  VIZSLA = 211,
-  ENGLISH_SETTER = 212,
-  IRISH_SETTER = 213,
-  GORDON_SETTER = 214,
-  BRITTANY_SPANIEL = 215,
-  CLUMBER = 216,
-  ENGLISH_SPRINGER = 217,
-  WELSH_SPRINGER_SPANIEL = 218,
-  COCKER_SPANIEL = 219,
-  SUSSEX_SPANIEL = 220,
-  IRISH_WATER_SPANIEL = 221,
-  KUVASZ = 222,
-  SCHIPPERKE = 223,
-  GROENENDAEL = 224,
-  MALINOIS = 225,
-  BRIARD = 226,
-  KELPIE = 227,
-  KOMONDOR = 228,
-  OLD_ENGLISH_SHEEPDOG = 229,
-  SHETLAND_SHEEPDOG = 230,
-  COLLIE = 231,
-  BORDER_COLLIE = 232,
-  BOUVIER_DES_FLANDRES = 233,
-  ROTTWEILER = 234,
-  GERMAN_SHEPHERD = 235,
-  DOBERMAN = 236,
-  MINIATURE_PINSCHER = 237,
-  GREATER_SWISS_MOUNTAIN_DOG = 238,
-  BERNESE_MOUNTAIN_DOG = 239,
-  APPENZELLER = 240,
-  ENTLEBUCHER = 241,
-  BOXER = 242,
-  BULL_MASTIFF = 243,
-  TIBETAN_MASTIFF = 244,
-  FRENCH_BULLDOG = 245,
-  GREAT_DANE = 246,
-  SAINT_BERNARD = 247,
-  ESKIMO_DOG = 248,
-  MALAMUTE = 249,
-  SIBERIAN_HUSKY = 250,
-  DALMATIAN = 251,
-  AFFENPINSCHER = 252,
-  BASENJI = 253,
-  PUG = 254,
-  LEONBERG = 255,
-  NEWFOUNDLAND = 256,
-  GREAT_PYRENEES = 257,
-  SAMOYED = 258,
-  POMERANIAN = 259,
-  CHOW = 260,
-  KEESHOND = 261,
-  BRABANCON_GRIFFON = 262,
-  PEMBROKE = 263,
-  CARDIGAN = 264,
-  TOY_POODLE = 265,
-  MINIATURE_POODLE = 266,
-  STANDARD_POODLE = 267,
-  MEXICAN_HAIRLESS = 268,
-  TIMBER_WOLF = 269,
-  WHITE_WOLF = 270,
-  RED_WOLF = 271,
-  COYOTE = 272,
-  DINGO = 273,
-  DHOLE = 274,
-  AFRICAN_HUNTING_DOG = 275,
-  HYENA = 276,
-  RED_FOX = 277,
-  KIT_FOX = 278,
-  ARCTIC_FOX = 279,
-  GREY_FOX = 280,
-  TABBY = 281,
-  TIGER_CAT = 282,
-  PERSIAN_CAT = 283,
-  SIAMESE_CAT = 284,
-  EGYPTIAN_CAT = 285,
-  COUGAR = 286,
-  LYNX = 287,
-  LEOPARD = 288,
-  SNOW_LEOPARD = 289,
-  JAGUAR = 290,
-  LION = 291,
-  TIGER = 292,
-  CHEETAH = 293,
-  BROWN_BEAR = 294,
-  AMERICAN_BLACK_BEAR = 295,
-  ICE_BEAR = 296,
-  SLOTH_BEAR = 297,
-  MONGOOSE = 298,
-  MEERKAT = 299,
-  TIGER_BEETLE = 300,
-  LADYBUG = 301,
-  GROUND_BEETLE = 302,
-  LONG_HORNED_BEETLE = 303,
-  LEAF_BEETLE = 304,
-  DUNG_BEETLE = 305,
-  RHINOCEROS_BEETLE = 306,
-  WEEVIL = 307,
-  FLY = 308,
-  BEE = 309,
-  ANT = 310,
-  GRASSHOPPER = 311,
-  CRICKET = 312,
-  WALKING_STICK = 313,
-  COCKROACH = 314,
-  MANTIS = 315,
-  CICADA = 316,
-  LEAFHOPPER = 317,
-  LACEWING = 318,
-  DRAGONFLY = 319,
-  DAMSELFLY = 320,
-  ADMIRAL = 321,
-  RINGLET = 322,
-  MONARCH = 323,
-  CABBAGE_BUTTERFLY = 324,
-  SULPHUR_BUTTERFLY = 325,
-  LYCAENID = 326,
-  STARFISH = 327,
-  SEA_URCHIN = 328,
-  SEA_CUCUMBER = 329,
-  WOOD_RABBIT = 330,
-  HARE = 331,
-  ANGORA = 332,
-  HAMSTER = 333,
-  PORCUPINE = 334,
-  FOX_SQUIRREL = 335,
-  MARMOT = 336,
-  BEAVER = 337,
-  GUINEA_PIG = 338,
-  SORREL = 339,
-  ZEBRA = 340,
-  HOG = 341,
-  WILD_BOAR = 342,
-  WARTHOG = 343,
-  HIPPOPOTAMUS = 344,
-  OX = 345,
-  WATER_BUFFALO = 346,
-  BISON = 347,
-  RAM = 348,
-  BIGHORN = 349,
-  IBEX = 350,
-  HARTEBEEST = 351,
-  IMPALA = 352,
-  GAZELLE = 353,
-  ARABIAN_CAMEL = 354,
-  LLAMA = 355,
-  WEASEL = 356,
-  MINK = 357,
-  POLECAT = 358,
-  BLACK_FOOTED_FERRET = 359,
-  OTTER = 360,
-  SKUNK = 361,
-  BADGER = 362,
-  ARMADILLO = 363,
-  THREE_TOED_SLOTH = 364,
-  ORANGUTAN = 365,
-  GORILLA = 366,
-  CHIMPANZEE = 367,
-  GIBBON = 368,
-  SIAMANG = 369,
-  GUENON = 370,
-  PATAS = 371,
-  BABOON = 372,
-  MACAQUE = 373,
-  LANGUR = 374,
-  COLOBUS = 375,
-  PROBOSCIS_MONKEY = 376,
-  MARMOSET = 377,
-  CAPUCHIN = 378,
-  HOWLER_MONKEY = 379,
-  TITI = 380,
-  SPIDER_MONKEY = 381,
-  SQUIRREL_MONKEY = 382,
-  MADAGASCAR_CAT = 383,
-  INDRI = 384,
-  INDIAN_ELEPHANT = 385,
-  AFRICAN_ELEPHANT = 386,
-  LESSER_PANDA = 387,
-  GIANT_PANDA = 388,
-  BARRACOUTA = 389,
-  EEL = 390,
-  COHO = 391,
-  ROCK_BEAUTY = 392,
-  ANEMONE_FISH = 393,
-  STURGEON = 394,
-  GAR = 395,
-  LIONFISH = 396,
-  PUFFER = 397,
-  ABACUS = 398,
-  ABAYA = 399,
-  ACADEMIC_GOWN = 400,
-  ACCORDION = 401,
-  ACOUSTIC_GUITAR = 402,
-  AIRCRAFT_CARRIER = 403,
-  AIRLINER = 404,
-  AIRSHIP = 405,
-  ALTAR = 406,
-  AMBULANCE = 407,
-  AMPHIBIAN = 408,
-  ANALOG_CLOCK = 409,
-  APIARY = 410,
-  APRON = 411,
-  ASHCAN = 412,
-  ASSAULT_RIFLE = 413,
-  BACKPACK = 414,
-  BAKERY = 415,
-  BALANCE_BEAM = 416,
-  BALLOON = 417,
-  BALLPOINT = 418,
-  BAND_AID = 419,
-  BANJO = 420,
-  BANNISTER = 421,
-  BARBELL = 422,
-  BARBER_CHAIR = 423,
-  BARBERSHOP = 424,
-  BARN = 425,
-  BAROMETER = 426,
-  BARREL = 427,
-  BARROW = 428,
-  BASEBALL = 429,
-  BASKETBALL = 430,
-  BASSINET = 431,
-  BASSOON = 432,
-  BATHING_CAP = 433,
-  BATH_TOWEL = 434,
-  BATHTUB = 435,
-  BEACH_WAGON = 436,
-  BEACON = 437,
-  BEAKER = 438,
-  BEARSKIN = 439,
-  BEER_BOTTLE = 440,
-  BEER_GLASS = 441,
-  BELL_COTE = 442,
-  BIB = 443,
-  BICYCLE_BUILT_FOR_TWO = 444,
-  BIKINI = 445,
-  BINDER = 446,
-  BINOCULARS = 447,
-  BIRDHOUSE = 448,
-  BOATHOUSE = 449,
-  BOBSLED = 450,
-  BOLO_TIE = 451,
-  BONNET = 452,
-  BOOKCASE = 453,
-  BOOKSHOP = 454,
-  BOTTLECAP = 455,
-  BOW = 456,
-  BOW_TIE = 457,
-  BRASS = 458,
-  BRASSIERE = 459,
-  BREAKWATER = 460,
-  BREASTPLATE = 461,
-  BROOM = 462,
-  BUCKET = 463,
-  BUCKLE = 464,
-  BULLETPROOF_VEST = 465,
-  BULLET_TRAIN = 466,
-  BUTCHER_SHOP = 467,
-  CAB = 468,
-  CALDRON = 469,
-  CANDLE = 470,
-  CANNON = 471,
-  CANOE = 472,
-  CAN_OPENER = 473,
-  CARDIGAN_474 = 474,
-  CAR_MIRROR = 475,
-  CAROUSEL = 476,
-  CARPENTERS_KIT = 477,
-  CARTON = 478,
-  CAR_WHEEL = 479,
-  CASH_MACHINE = 480,
-  CASSETTE = 481,
-  CASSETTE_PLAYER = 482,
-  CASTLE = 483,
-  CATAMARAN = 484,
-  CD_PLAYER = 485,
-  CELLO = 486,
-  CELLULAR_TELEPHONE = 487,
-  CHAIN = 488,
-  CHAINLINK_FENCE = 489,
-  CHAIN_MAIL = 490,
-  CHAIN_SAW = 491,
-  CHEST = 492,
-  CHIFFONIER = 493,
-  CHIME = 494,
-  CHINA_CABINET = 495,
-  CHRISTMAS_STOCKING = 496,
-  CHURCH = 497,
-  CINEMA = 498,
-  CLEAVER = 499,
-  CLIFF_DWELLING = 500,
-  CLOAK = 501,
-  CLOG = 502,
-  COCKTAIL_SHAKER = 503,
-  COFFEE_MUG = 504,
-  COFFEEPOT = 505,
-  COIL = 506,
-  COMBINATION_LOCK = 507,
-  COMPUTER_KEYBOARD = 508,
-  CONFECTIONERY = 509,
-  CONTAINER_SHIP = 510,
-  CONVERTIBLE = 511,
-  CORKSCREW = 512,
-  CORNET = 513,
-  COWBOY_BOOT = 514,
-  COWBOY_HAT = 515,
-  CRADLE = 516,
-  CRANE_MACHINE = 517,
-  CRASH_HELMET = 518,
-  CRATE = 519,
-  CRIB = 520,
-  CROCK_POT = 521,
-  CROQUET_BALL = 522,
-  CRUTCH = 523,
-  CUIRASS = 524,
-  DAM = 525,
-  DESK = 526,
-  DESKTOP_COMPUTER = 527,
-  DIAL_TELEPHONE = 528,
-  DIAPER = 529,
-  DIGITAL_CLOCK = 530,
-  DIGITAL_WATCH = 531,
-  DINING_TABLE = 532,
-  DISHRAG = 533,
-  DISHWASHER = 534,
-  DISK_BRAKE = 535,
-  DOCK = 536,
-  DOGSLED = 537,
-  DOME = 538,
-  DOORMAT = 539,
-  DRILLING_PLATFORM = 540,
-  DRUM = 541,
-  DRUMSTICK = 542,
-  DUMBBELL = 543,
-  DUTCH_OVEN = 544,
-  ELECTRIC_FAN = 545,
-  ELECTRIC_GUITAR = 546,
-  ELECTRIC_LOCOMOTIVE = 547,
-  ENTERTAINMENT_CENTER = 548,
-  ENVELOPE = 549,
-  ESPRESSO_MAKER = 550,
-  FACE_POWDER = 551,
-  FEATHER_BOA = 552,
-  FILE = 553,
-  FIREBOAT = 554,
-  FIRE_ENGINE = 555,
-  FIRE_SCREEN = 556,
-  FLAGPOLE = 557,
-  FLUTE = 558,
-  FOLDING_CHAIR = 559,
-  FOOTBALL_HELMET = 560,
-  FORKLIFT = 561,
-  FOUNTAIN = 562,
-  FOUNTAIN_PEN = 563,
-  FOUR_POSTER = 564,
-  FREIGHT_CAR = 565,
-  FRENCH_HORN = 566,
-  FRYING_PAN = 567,
-  FUR_COAT = 568,
-  GARBAGE_TRUCK = 569,
-  GASMASK = 570,
-  GAS_PUMP = 571,
-  GOBLET = 572,
-  GO_KART = 573,
-  GOLF_BALL = 574,
-  GOLFCART = 575,
-  GONDOLA = 576,
-  GONG = 577,
-  GOWN = 578,
-  GRAND_PIANO = 579,
-  GREENHOUSE = 580,
-  GRILLE = 581,
-  GROCERY_STORE = 582,
-  GUILLOTINE = 583,
-  HAIR_SLIDE = 584,
-  HAIR_SPRAY = 585,
-  HALF_TRACK = 586,
-  HAMMER = 587,
-  HAMPER = 588,
-  HAND_BLOWER = 589,
-  HAND_HELD_COMPUTER = 590,
-  HANDKERCHIEF = 591,
-  HARD_DISC = 592,
-  HARMONICA = 593,
-  HARP = 594,
-  HARVESTER = 595,
-  HATCHET = 596,
-  HOLSTER = 597,
-  HOME_THEATER = 598,
-  HONEYCOMB = 599,
-  HOOK = 600,
-  HOOPSKIRT = 601,
-  HORIZONTAL_BAR = 602,
-  HORSE_CART = 603,
-  HOURGLASS = 604,
-  IPOD = 605,
-  IRON = 606,
-  JACK_O_LANTERN = 607,
-  JEAN = 608,
-  JEEP = 609,
-  JERSEY = 610,
-  JIGSAW_PUZZLE = 611,
-  JINRIKISHA = 612,
-  JOYSTICK = 613,
-  KIMONO = 614,
-  KNEE_PAD = 615,
-  KNOT = 616,
-  LAB_COAT = 617,
-  LADLE = 618,
-  LAMPSHADE = 619,
-  LAPTOP = 620,
-  LAWN_MOWER = 621,
-  LENS_CAP = 622,
-  LETTER_OPENER = 623,
-  LIBRARY = 624,
-  LIFEBOAT = 625,
-  LIGHTER = 626,
-  LIMOUSINE = 627,
-  LINER = 628,
-  LIPSTICK = 629,
-  LOAFER = 630,
-  LOTION = 631,
-  LOUDSPEAKER = 632,
-  LOUPE = 633,
-  LUMBERMILL = 634,
-  MAGNETIC_COMPASS = 635,
-  MAILBAG = 636,
-  MAILBOX = 637,
-  MAILLOT = 638,
-  MAILLOT_639 = 639,
-  MANHOLE_COVER = 640,
-  MARACA = 641,
-  MARIMBA = 642,
-  MASK = 643,
-  MATCHSTICK = 644,
-  MAYPOLE = 645,
-  MAZE = 646,
-  MEASURING_CUP = 647,
-  MEDICINE_CHEST = 648,
-  MEGALITH = 649,
-  MICROPHONE = 650,
-  MICROWAVE = 651,
-  MILITARY_UNIFORM = 652,
-  MILK_CAN = 653,
-  MINIBUS = 654,
-  MINISKIRT = 655,
-  MINIVAN = 656,
-  MISSILE = 657,
-  MITTEN = 658,
-  MIXING_BOWL = 659,
-  MOBILE_HOME = 660,
-  MODEL_T = 661,
-  MODEM = 662,
-  MONASTERY = 663,
-  MONITOR = 664,
-  MOPED = 665,
-  MORTAR = 666,
-  MORTARBOARD = 667,
-  MOSQUE = 668,
-  MOSQUITO_NET = 669,
-  MOTOR_SCOOTER = 670,
-  MOUNTAIN_BIKE = 671,
-  MOUNTAIN_TENT = 672,
-  MOUSE = 673,
-  MOUSETRAP = 674,
-  MOVING_VAN = 675,
-  MUZZLE = 676,
-  NAIL = 677,
-  NECK_BRACE = 678,
-  NECKLACE = 679,
-  NIPPLE = 680,
-  NOTEBOOK = 681,
-  OBELISK = 682,
-  OBOE = 683,
-  OCARINA = 684,
-  ODOMETER = 685,
-  OIL_FILTER = 686,
-  ORGAN = 687,
-  OSCILLOSCOPE = 688,
-  OVERSKIRT = 689,
-  OXCART = 690,
-  OXYGEN_MASK = 691,
-  PACKET = 692,
-  PADDLE = 693,
-  PADDLEWHEEL = 694,
-  PADLOCK = 695,
-  PAINTBRUSH = 696,
-  PAJAMA = 697,
-  PALACE = 698,
-  PANPIPE = 699,
-  PAPER_TOWEL = 700,
-  PARACHUTE = 701,
-  PARALLEL_BARS = 702,
-  PARK_BENCH = 703,
-  PARKING_METER = 704,
-  PASSENGER_CAR = 705,
-  PATIO = 706,
-  PAY_PHONE = 707,
-  PEDESTAL = 708,
-  PENCIL_BOX = 709,
-  PENCIL_SHARPENER = 710,
-  PERFUME = 711,
-  PETRI_DISH = 712,
-  PHOTOCOPIER = 713,
-  PICK = 714,
-  PICKELHAUBE = 715,
-  PICKET_FENCE = 716,
-  PICKUP = 717,
-  PIER = 718,
-  PIGGY_BANK = 719,
-  PILL_BOTTLE = 720,
-  PILLOW = 721,
-  PING_PONG_BALL = 722,
-  PINWHEEL = 723,
-  PIRATE = 724,
-  PITCHER = 725,
-  PLANE = 726,
-  PLANETARIUM = 727,
-  PLASTIC_BAG = 728,
-  PLATE_RACK = 729,
-  PLOW = 730,
-  PLUNGER = 731,
-  POLAROID_CAMERA = 732,
-  POLE = 733,
-  POLICE_VAN = 734,
-  PONCHO = 735,
-  POOL_TABLE = 736,
-  POP_BOTTLE = 737,
-  POT = 738,
-  POTTERS_WHEEL = 739,
-  POWER_DRILL = 740,
-  PRAYER_RUG = 741,
-  PRINTER = 742,
-  PRISON = 743,
-  PROJECTILE = 744,
-  PROJECTOR = 745,
-  PUCK = 746,
-  PUNCHING_BAG = 747,
-  PURSE = 748,
-  QUILL = 749,
-  QUILT = 750,
-  RACER = 751,
-  RACKET = 752,
-  RADIATOR = 753,
-  RADIO = 754,
-  RADIO_TELESCOPE = 755,
-  RAIN_BARREL = 756,
-  RECREATIONAL_VEHICLE = 757,
-  REEL = 758,
-  REFLEX_CAMERA = 759,
-  REFRIGERATOR = 760,
-  REMOTE_CONTROL = 761,
-  RESTAURANT = 762,
-  REVOLVER = 763,
-  RIFLE = 764,
-  ROCKING_CHAIR = 765,
-  ROTISSERIE = 766,
-  RUBBER_ERASER = 767,
-  RUGBY_BALL = 768,
-  RULE = 769,
-  RUNNING_SHOE = 770,
-  SAFE = 771,
-  SAFETY_PIN = 772,
-  SALTSHAKER = 773,
-  SANDAL = 774,
-  SARONG = 775,
-  SAX = 776,
-  SCABBARD = 777,
-  SCALE = 778,
-  SCHOOL_BUS = 779,
-  SCHOONER = 780,
-  SCOREBOARD = 781,
-  SCREEN = 782,
-  SCREW = 783,
-  SCREWDRIVER = 784,
-  SEAT_BELT = 785,
-  SEWING_MACHINE = 786,
-  SHIELD = 787,
-  SHOE_SHOP = 788,
-  SHOJI = 789,
-  SHOPPING_BASKET = 790,
-  SHOPPING_CART = 791,
-  SHOVEL = 792,
-  SHOWER_CAP = 793,
-  SHOWER_CURTAIN = 794,
-  SKI = 795,
-  SKI_MASK = 796,
-  SLEEPING_BAG = 797,
-  SLIDE_RULE = 798,
-  SLIDING_DOOR = 799,
-  SLOT = 800,
-  SNORKEL = 801,
-  SNOWMOBILE = 802,
-  SNOWPLOW = 803,
-  SOAP_DISPENSER = 804,
-  SOCCER_BALL = 805,
-  SOCK = 806,
-  SOLAR_DISH = 807,
-  SOMBRERO = 808,
-  SOUP_BOWL = 809,
-  SPACE_BAR = 810,
-  SPACE_HEATER = 811,
-  SPACE_SHUTTLE = 812,
-  SPATULA = 813,
-  SPEEDBOAT = 814,
-  SPIDER_WEB = 815,
-  SPINDLE = 816,
-  SPORTS_CAR = 817,
-  SPOTLIGHT = 818,
-  STAGE = 819,
-  STEAM_LOCOMOTIVE = 820,
-  STEEL_ARCH_BRIDGE = 821,
-  STEEL_DRUM = 822,
-  STETHOSCOPE = 823,
-  STOLE = 824,
-  STONE_WALL = 825,
-  STOPWATCH = 826,
-  STOVE = 827,
-  STRAINER = 828,
-  STREETCAR = 829,
-  STRETCHER = 830,
-  STUDIO_COUCH = 831,
-  STUPA = 832,
-  SUBMARINE = 833,
-  SUIT = 834,
-  SUNDIAL = 835,
-  SUNGLASS = 836,
-  SUNGLASSES = 837,
-  SUNSCREEN = 838,
-  SUSPENSION_BRIDGE = 839,
-  SWAB = 840,
-  SWEATSHIRT = 841,
-  SWIMMING_TRUNKS = 842,
-  SWING = 843,
-  SWITCH = 844,
-  SYRINGE = 845,
-  TABLE_LAMP = 846,
-  TANK = 847,
-  TAPE_PLAYER = 848,
-  TEAPOT = 849,
-  TEDDY = 850,
-  TELEVISION = 851,
-  TENNIS_BALL = 852,
-  THATCH = 853,
-  THEATER_CURTAIN = 854,
-  THIMBLE = 855,
-  THRESHER = 856,
-  THRONE = 857,
-  TILE_ROOF = 858,
-  TOASTER = 859,
-  TOBACCO_SHOP = 860,
-  TOILET_SEAT = 861,
-  TORCH = 862,
-  TOTEM_POLE = 863,
-  TOW_TRUCK = 864,
-  TOYSHOP = 865,
-  TRACTOR = 866,
-  TRAILER_TRUCK = 867,
-  TRAY = 868,
-  TRENCH_COAT = 869,
-  TRICYCLE = 870,
-  TRIMARAN = 871,
-  TRIPOD = 872,
-  TRIUMPHAL_ARCH = 873,
-  TROLLEYBUS = 874,
-  TROMBONE = 875,
-  TUB = 876,
-  TURNSTILE = 877,
-  TYPEWRITER_KEYBOARD = 878,
-  UMBRELLA = 879,
-  UNICYCLE = 880,
-  UPRIGHT = 881,
-  VACUUM = 882,
-  VASE = 883,
-  VAULT = 884,
-  VELVET = 885,
-  VENDING_MACHINE = 886,
-  VESTMENT = 887,
-  VIADUCT = 888,
-  VIOLIN = 889,
-  VOLLEYBALL = 890,
-  WAFFLE_IRON = 891,
-  WALL_CLOCK = 892,
-  WALLET = 893,
-  WARDROBE = 894,
-  WARPLANE = 895,
-  WASHBASIN = 896,
-  WASHER = 897,
-  WATER_BOTTLE = 898,
-  WATER_JUG = 899,
-  WATER_TOWER = 900,
-  WHISKEY_JUG = 901,
-  WHISTLE = 902,
-  WIG = 903,
-  WINDOW_SCREEN = 904,
-  WINDOW_SHADE = 905,
-  WINDSOR_TIE = 906,
-  WINE_BOTTLE = 907,
-  WING = 908,
-  WOK = 909,
-  WOODEN_SPOON = 910,
-  WOOL = 911,
-  WORM_FENCE = 912,
-  WRECK = 913,
-  YAWL = 914,
-  YURT = 915,
-  WEB_SITE = 916,
-  COMIC_BOOK = 917,
-  CROSSWORD_PUZZLE = 918,
-  STREET_SIGN = 919,
-  TRAFFIC_LIGHT = 920,
-  BOOK_JACKET = 921,
-  MENU = 922,
-  PLATE = 923,
-  GUACAMOLE = 924,
-  CONSOMME = 925,
-  HOT_POT = 926,
-  TRIFLE = 927,
-  ICE_CREAM = 928,
-  ICE_LOLLY = 929,
-  FRENCH_LOAF = 930,
-  BAGEL = 931,
-  PRETZEL = 932,
-  CHEESEBURGER = 933,
-  HOTDOG = 934,
-  MASHED_POTATO = 935,
-  HEAD_CABBAGE = 936,
-  BROCCOLI = 937,
-  CAULIFLOWER = 938,
-  ZUCCHINI = 939,
-  SPAGHETTI_SQUASH = 940,
-  ACORN_SQUASH = 941,
-  BUTTERNUT_SQUASH = 942,
-  CUCUMBER = 943,
-  ARTICHOKE = 944,
-  BELL_PEPPER = 945,
-  CARDOON = 946,
-  MUSHROOM = 947,
-  GRANNY_SMITH = 948,
-  STRAWBERRY = 949,
-  ORANGE = 950,
-  LEMON = 951,
-  FIG = 952,
-  PINEAPPLE = 953,
-  BANANA = 954,
-  JACKFRUIT = 955,
-  CUSTARD_APPLE = 956,
-  POMEGRANATE = 957,
-  HAY = 958,
-  CARBONARA = 959,
-  CHOCOLATE_SAUCE = 960,
-  DOUGH = 961,
-  MEAT_LOAF = 962,
-  PIZZA = 963,
-  POTPIE = 964,
-  BURRITO = 965,
-  RED_WINE = 966,
-  ESPRESSO = 967,
-  CUP = 968,
-  EGGNOG = 969,
-  ALP = 970,
-  BUBBLE = 971,
-  CLIFF = 972,
-  CORAL_REEF = 973,
-  GEYSER = 974,
-  LAKESIDE = 975,
-  PROMONTORY = 976,
-  SANDBAR = 977,
-  SEASHORE = 978,
-  VALLEY = 979,
-  VOLCANO = 980,
-  BALLPLAYER = 981,
-  GROOM = 982,
-  SCUBA_DIVER = 983,
-  RAPESEED = 984,
-  DAISY = 985,
-  YELLOW_LADYS_SLIPPER = 986,
-  CORN = 987,
-  ACORN = 988,
-  HIP = 989,
-  BUCKEYE = 990,
-  CORAL_FUNGUS = 991,
-  AGARIC = 992,
-  GYROMITRA = 993,
-  STINKHORN = 994,
-  EARTHSTAR = 995,
-  HEN_OF_THE_WOODS = 996,
-  BOLETE = 997,
-  EAR = 998,
-  TOILET_TISSUE = 999,
-}
diff --git a/packages/react-native-executorch/src/constants/commonVision.ts b/packages/react-native-executorch/src/constants/commonVision.ts
deleted file mode 100644
index 6221d5701e..0000000000
--- a/packages/react-native-executorch/src/constants/commonVision.ts
+++ /dev/null
@@ -1,213 +0,0 @@
-import { Triple } from '../types/common';
-
-export const IMAGENET1K_MEAN: Triple<number> = [0.485, 0.456, 0.406];
-export const IMAGENET1K_STD: Triple<number> = [0.229, 0.224, 0.225];
-
-/**
- * COCO dataset class labels used by **RF-DETR** and **SSDLite** object detection models.
- *
- * This enum is **1-indexed** and contains **91 classes**, matching the original COCO
- * dataset category IDs. For **YOLO** models (object detection or instance segmentation),
- * use {@link CocoLabelYolo} instead — a 0-indexed, 80-class variant.
- * @see {@link CocoLabelYolo} for the YOLO-specific variant
- * @category Types
- */
-export enum CocoLabel {
-  PERSON = 1,
-  BICYCLE = 2,
-  CAR = 3,
-  MOTORCYCLE = 4,
-  AIRPLANE = 5,
-  BUS = 6,
-  TRAIN = 7,
-  TRUCK = 8,
-  BOAT = 9,
-  TRAFFIC_LIGHT = 10,
-  FIRE_HYDRANT = 11,
-  STREET_SIGN = 12,
-  STOP_SIGN = 13,
-  PARKING = 14,
-  BENCH = 15,
-  BIRD = 16,
-  CAT = 17,
-  DOG = 18,
-  HORSE = 19,
-  SHEEP = 20,
-  COW = 21,
-  ELEPHANT = 22,
-  BEAR = 23,
-  ZEBRA = 24,
-  GIRAFFE = 25,
-  HAT = 26,
-  BACKPACK = 27,
-  UMBRELLA = 28,
-  SHOE = 29,
-  EYE = 30,
-  HANDBAG = 31,
-  TIE = 32,
-  SUITCASE = 33,
-  FRISBEE = 34,
-  SKIS = 35,
-  SNOWBOARD = 36,
-  SPORTS = 37,
-  KITE = 38,
-  BASEBALL = 39,
-  SKATEBOARD = 41,
-  SURFBOARD = 42,
-  TENNIS_RACKET = 43,
-  BOTTLE = 44,
-  PLATE = 45,
-  WINE_GLASS = 46,
-  CUP = 47,
-  FORK = 48,
-  KNIFE = 49,
-  SPOON = 50,
-  BOWL = 51,
-  BANANA = 52,
-  APPLE = 53,
-  SANDWICH = 54,
-  ORANGE = 55,
-  BROCCOLI = 56,
-  CARROT = 57,
-  HOT_DOG = 58,
-  PIZZA = 59,
-  DONUT = 60,
-  CAKE = 61,
-  CHAIR = 62,
-  COUCH = 63,
-  POTTED_PLANT = 64,
-  BED = 65,
-  MIRROR = 66,
-  DINING_TABLE = 67,
-  WINDOW = 68,
-  DESK = 69,
-  TOILET = 70,
-  DOOR = 71,
-  TV = 72,
-  LAPTOP = 73,
-  MOUSE = 74,
-  REMOTE = 75,
-  KEYBOARD = 76,
-  CELL_PHONE = 77,
-  MICROWAVE = 78,
-  OVEN = 79,
-  TOASTER = 80,
-  SINK = 81,
-  REFRIGERATOR = 82,
-  BLENDER = 83,
-  BOOK = 84,
-  CLOCK = 85,
-  VASE = 86,
-  SCISSORS = 87,
-  TEDDY_BEAR = 88,
-  HAIR_DRIER = 89,
-  TOOTHBRUSH = 90,
-  HAIR_BRUSH = 91,
-}
-
-/**
- * COCO dataset class labels used by **YOLO** models for instance segmentation and object detection.
- *
- * This enum is **0-indexed** (values start at 0) and contains exactly **80 classes** —
- * the standard COCO detection subset without gaps. This differs from {@link CocoLabel},
- * which is 1-indexed with 91 classes and includes extra categories not present in the
- * YOLO label set.
- *
- * Use this enum when working with YOLO models (e.g. `yolo26n-seg`).
- * For RF-DETR or SSDLite models, use {@link CocoLabel}.
- * @see {@link CocoLabel} for the RF-DETR / SSDLite variant
- * @category Types
- */
-export enum CocoLabelYolo {
-  PERSON = 0,
-  BICYCLE = 1,
-  CAR = 2,
-  MOTORCYCLE = 3,
-  AIRPLANE = 4,
-  BUS = 5,
-  TRAIN = 6,
-  TRUCK = 7,
-  BOAT = 8,
-  TRAFFIC_LIGHT = 9,
-  FIRE_HYDRANT = 10,
-  STOP_SIGN = 11,
-  PARKING_METER = 12,
-  BENCH = 13,
-  BIRD = 14,
-  CAT = 15,
-  DOG = 16,
-  HORSE = 17,
-  SHEEP = 18,
-  COW = 19,
-  ELEPHANT = 20,
-  BEAR = 21,
-  ZEBRA = 22,
-  GIRAFFE = 23,
-  BACKPACK = 24,
-  UMBRELLA = 25,
-  HANDBAG = 26,
-  TIE = 27,
-  SUITCASE = 28,
-  FRISBEE = 29,
-  SKIS = 30,
-  SNOWBOARD = 31,
-  SPORTS_BALL = 32,
-  KITE = 33,
-  BASEBALL_BAT = 34,
-  BASEBALL_GLOVE = 35,
-  SKATEBOARD = 36,
-  SURFBOARD = 37,
-  TENNIS_RACKET = 38,
-  BOTTLE = 39,
-  WINE_GLASS = 40,
-  CUP = 41,
-  FORK = 42,
-  KNIFE = 43,
-  SPOON = 44,
-  BOWL = 45,
-  BANANA = 46,
-  APPLE = 47,
-  SANDWICH = 48,
-  ORANGE = 49,
-  BROCCOLI = 50,
-  CARROT = 51,
-  HOT_DOG = 52,
-  PIZZA = 53,
-  DONUT = 54,
-  CAKE = 55,
-  CHAIR = 56,
-  COUCH = 57,
-  POTTED_PLANT = 58,
-  BED = 59,
-  DINING_TABLE = 60,
-  TOILET = 61,
-  TV = 62,
-  LAPTOP = 63,
-  MOUSE = 64,
-  REMOTE = 65,
-  KEYBOARD = 66,
-  CELL_PHONE = 67,
-  MICROWAVE = 68,
-  OVEN = 69,
-  TOASTER = 70,
-  SINK = 71,
-  REFRIGERATOR = 72,
-  BOOK = 73,
-  CLOCK = 74,
-  VASE = 75,
-  SCISSORS = 76,
-  TEDDY_BEAR = 77,
-  HAIR_DRIER = 78,
-  TOOTHBRUSH = 79,
-}
-
-/**
- * Class label for FastSAM models.
- *
- * FastSAM is class-agnostic and produces a single "object" class for every
- * detected region. Use this enum when working with `fastsam-s` or `fastsam-x`.
- * @category Types
- */
-export enum FastSAMLabel {
-  OBJECT = 0,
-}
diff --git a/packages/react-native-executorch/src/constants/llmDefaults.ts b/packages/react-native-executorch/src/constants/llmDefaults.ts
deleted file mode 100644
index 77a60fe311..0000000000
--- a/packages/react-native-executorch/src/constants/llmDefaults.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import { ChatConfig, Message } from '../types/llm';
-import { SlidingWindowContextStrategy } from '../utils/llms/context_strategy';
-
-/**
- * Default system prompt used to guide the behavior of Large Language Models (LLMs).
- * @category Utilities - LLM
- */
-export const DEFAULT_SYSTEM_PROMPT =
-  "You are a knowledgeable, efficient, and direct AI assistant. Provide concise answers, focusing on the key information needed. Offer suggestions tactfully when appropriate to improve outcomes. Engage in productive collaboration with the user. Don't return too much text. If provided with audio samples treat it with at most importance";
-
-/**
- * Generates a default structured output prompt based on the provided JSON schema.
- * @category Utilities - LLM
- * @param structuredOutputSchema - A string representing the JSON schema for the desired output format.
- * @returns A prompt string instructing the model to format its output according to the given schema.
- */
-export const DEFAULT_STRUCTURED_OUTPUT_PROMPT = (
-  structuredOutputSchema: string
-) => `The output should be formatted as a JSON instance that conforms to the JSON schema below.
-
-As an example, for the schema {"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
-the object {"foo": ["bar", "baz"]} is a well-formatted instance of the schema. The object {"properties": {"foo": ["bar", "baz"]}} is not well-formatted.
-
-Here is the output schema:
-${structuredOutputSchema}
-`;
-
-/**
- * Default message history for Large Language Models (LLMs).
- * @category Utilities - LLM
- */
-export const DEFAULT_MESSAGE_HISTORY: Message[] = [];
-
-/**
- * Default context buffer tokens (number of tokens to keep for the model response) for Large Language Models (LLMs).
- * @category Utilities - LLM
- */
-export const DEFAULT_CONTEXT_BUFFER_TOKENS = 512;
-
-/**
- * Default chat configuration for Large Language Models (LLMs).
- * @category Utilities - LLM
- */
-export const DEFAULT_CHAT_CONFIG: ChatConfig = {
-  systemPrompt: DEFAULT_SYSTEM_PROMPT,
-  initialMessageHistory: DEFAULT_MESSAGE_HISTORY,
-  contextStrategy: new SlidingWindowContextStrategy(
-    DEFAULT_CONTEXT_BUFFER_TOKENS
-  ),
-};
diff --git a/packages/react-native-executorch/src/constants/modelRegistry.ts b/packages/react-native-executorch/src/constants/modelRegistry.ts
deleted file mode 100644
index ed44fa3a68..0000000000
--- a/packages/react-native-executorch/src/constants/modelRegistry.ts
+++ /dev/null
@@ -1,735 +0,0 @@
-import { Platform } from 'react-native';
-import { isEmulatorSync } from 'react-native-device-info';
-import * as M from './modelUrls';
-import * as OCR from './ocr/models';
-import { symbols } from './ocr/symbols';
-import {
-  KOKORO_AMERICAN_ENGLISH_FEMALE_HEART,
-  KOKORO_AMERICAN_ENGLISH_FEMALE_RIVER,
-  KOKORO_AMERICAN_ENGLISH_FEMALE_SARAH,
-  KOKORO_AMERICAN_ENGLISH_MALE_ADAM,
-  KOKORO_AMERICAN_ENGLISH_MALE_MICHAEL,
-  KOKORO_AMERICAN_ENGLISH_MALE_SANTA,
-  KOKORO_BRITISH_ENGLISH_FEMALE_EMMA,
-  KOKORO_BRITISH_ENGLISH_MALE_DANIEL,
-  KOKORO_FRENCH_FEMALE_SIWIS,
-  KOKORO_SPANISH_FEMALE_DORA,
-  KOKORO_SPANISH_MALE_ALEX,
-  KOKORO_ITALIAN_FEMALE_SARA,
-  KOKORO_ITALIAN_MALE_NICOLA,
-  KOKORO_PORTUGUESE_FEMALE_DORA,
-  KOKORO_PORTUGUESE_MALE_SANTA,
-  KOKORO_HINDI_FEMALE_ALPHA,
-  KOKORO_HINDI_MALE_OMEGA,
-  KOKORO_HINDI_MALE_PSI,
-  KOKORO_POLISH_MALE_MATEUSZ,
-  KOKORO_GERMAN_FEMALE_ANNA,
-} from './tts/voices';
-import { TextToSpeechModelConfig } from '../types/tts';
-import { RnExecutorchError } from '../errors/errorUtils';
-import { RnExecutorchErrorCode } from '../errors/ErrorCodes';
-
-/**
- * Backend options accepted by `models` accessors.
- *
- * The set of backends a particular model can be loaded with is encoded in
- * its accessor's call signature — e.g. `models.llm.llama3_2_3b` only accepts
- * `'xnnpack'`, while `models.object_detection.rf_detr_nano` accepts
- * `'xnnpack' | 'coreml'`. Passing a backend a model doesn't ship is a
- * compile-time error.
- * @category Utils
- */
-export type Backend = 'xnnpack' | 'coreml' | 'vulkan' | 'qnn' | 'mlx';
-
-/**
- * Options for a `models` accessor call.
- * @typeParam B - Subset of {@link Backend} that the accessor actually supports.
- * @category Utils
- */
-export type ModelOpts<B extends Backend = Backend> = {
-  /** Pick the non-quantized variant when `false`. Defaults to the quantized variant when one is published. */
-  quant?: boolean;
-  /** Explicit backend; defaults to the platform-preferred backend for the model. */
-  backend?: B;
-};
-
-// Accessors are functions; calling with no opts returns the platform default.
-type Accessor<C extends { modelName: string }, B extends Backend = Backend> = (
-  opts?: ModelOpts<B>
-) => C;
-
-type BackendCell = {
-  base?: { modelName: string };
-  quant?: { modelName: string };
-};
-type AnyVariantMap = Partial<Record<Backend, BackendCell>>;
-type PlatformDefaults<B extends Backend> = {
-  ios?: B;
-  android?: B;
-  /** Fallback when no platform-specific default is set. */
-  default?: B;
-};
-
-type CellConfig<T> = T extends { base?: infer D; quant?: infer Q }
-  ? NonNullable<D> | NonNullable<Q>
-  : never;
-type ConfigOf<V> = Extract<
-  { [K in keyof V]: CellConfig<V[K]> }[keyof V],
-  { modelName: string }
->;
-type BackendsOf<V> = Extract<keyof V, Backend>;
-
-const PLATFORM_PREFERENCE: Partial<Record<typeof Platform.OS, Backend[]>> = {
-  ios: ['coreml', 'mlx', 'xnnpack'],
-  android: ['vulkan', 'qnn', 'xnnpack'],
-};
-
-function applySimulatorPolicy(
-  backend: Backend,
-  variants: AnyVariantMap,
-  explicit: boolean
-): Backend {
-  if (backend !== 'mlx' || Platform.OS !== 'ios' || !isEmulatorSync()) {
-    return backend;
-  }
-  if (!explicit && variants.xnnpack) return 'xnnpack';
-  throw new RnExecutorchError(
-    RnExecutorchErrorCode.InvalidConfig,
-    'The MLX backend requires a physical iOS device and cannot run on the ' +
-      'simulator.' +
-      (variants.xnnpack
-        ? " Pass `{ backend: 'xnnpack' }` (or omit `backend`) to run on the " +
-          'simulator.'
-        : ' This model ships no simulator-compatible backend.')
-  );
-}
-
-function selectBackend(
-  variants: AnyVariantMap,
-  platformDefaults: PlatformDefaults<Backend> | undefined,
-  requested: Backend | undefined
-): Backend {
-  if (requested) return requested;
-  if (platformDefaults) {
-    if (Platform.OS === 'ios' && platformDefaults.ios)
-      return platformDefaults.ios;
-    if (Platform.OS === 'android' && platformDefaults.android)
-      return platformDefaults.android;
-    if (platformDefaults.default) return platformDefaults.default;
-  }
-  // Implicit platform default: walk the platform's preference order (iOS:
-  // coreml → mlx → xnnpack, Android: vulkan → qnn → xnnpack) and take the
-  // first backend the model ships. Models can override via `platformDefaults`.
-  const preference = PLATFORM_PREFERENCE[Platform.OS] ?? [];
-  for (const b of preference) {
-    if (variants[b]) return b;
-  }
-  // No backend the model ships can run on this platform.
-  throw new RnExecutorchError(
-    RnExecutorchErrorCode.InvalidConfig,
-    `This model ships no backend compatible with ${Platform.OS}.`
-  );
-}
-
-function resolveBackend(
-  variants: AnyVariantMap,
-  platformDefaults: PlatformDefaults<Backend> | undefined,
-  requested: Backend | undefined
-): Backend {
-  const explicit = requested !== undefined;
-  const backend = selectBackend(variants, platformDefaults, requested);
-  return applySimulatorPolicy(backend, variants, explicit);
-}
-
-function resolveCell(cell: BackendCell, quant: boolean): { modelName: string } {
-  // Fall back to the other slot when the requested precision is missing,
-  // so single-precision backends still work either way.
-  const primary = quant ? cell.quant : cell.base;
-  const fallback = quant ? cell.base : cell.quant;
-  const result = primary ?? fallback;
-  if (!result) {
-    throw new RnExecutorchError(
-      RnExecutorchErrorCode.Internal,
-      'Model variant cell has no config.'
-    );
-  }
-  return result;
-}
-
-function resolveVariant(
-  variants: AnyVariantMap,
-  platformDefaults: PlatformDefaults<Backend> | undefined,
-  opts: ModelOpts
-): { modelName: string } {
-  const backend = resolveBackend(variants, platformDefaults, opts.backend);
-  const cell = variants[backend];
-  if (!cell) {
-    throw new RnExecutorchError(
-      RnExecutorchErrorCode.InvalidConfig,
-      `Backend '${backend}' is not available for this model.`
-    );
-  }
-  return resolveCell(cell, opts.quant !== false);
-}
-
-// Build an Accessor from a per-backend variant map and an optional
-// platform-default policy. The resulting accessor's `backend` parameter is
-// typed to exactly the keys present in `variants`.
-function variant<const V extends AnyVariantMap>(
-  variants: V,
-  platformDefaults?: PlatformDefaults<BackendsOf<V>>
-): Accessor<ConfigOf<V>, BackendsOf<V>> {
-  type C = ConfigOf<V>;
-  type B = BackendsOf<V>;
-  return (opts: ModelOpts<B> = {}) =>
-    resolveVariant(variants, platformDefaults, opts) as C;
-}
-
-// Single-config accessor (xnnpack-only, no quantized variant).
-function base<C extends { modelName: string }>(c: C) {
-  return variant({ xnnpack: { base: c } });
-}
-
-// xnnpack-only accessor with a `base` / `quant` pair.
-function pair<D extends { modelName: string }, Q extends { modelName: string }>(
-  baseC: D,
-  quantC: Q
-) {
-  return variant({ xnnpack: { base: baseC, quant: quantC } });
-}
-
-// TTS presets bundle model + voice + phonemizer in a single config; they
-// don't share the `{ modelName: string }` shape of the rest of the registry,
-// and have no quant/backend axis. Expose them as a plain `() => Config`
-// accessor so the call style stays consistent (`models.text_to_speech.en_us.heart()`).
-function tts<C extends TextToSpeechModelConfig>(c: C): () => C {
-  return () => c;
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Per-backend variant maps for models that ship more than one backend.
-// ─────────────────────────────────────────────────────────────────────────────
-
-const GEMMA4_E2B_VARIANTS = {
-  mlx: {
-    base: {
-      modelName: 'gemma4-e2b' as const,
-      modelSource: M.GEMMA4_E2B_MLX_MODEL,
-      tokenizerSource: M.GEMMA4_E2B_TOKENIZER,
-      tokenizerConfigSource: M.GEMMA4_E2B_TOKENIZER_CONFIG,
-    },
-  },
-  xnnpack: {
-    base: {
-      modelName: 'gemma4-e2b' as const,
-      modelSource: M.GEMMA4_E2B_XNNPACK_MODEL,
-      tokenizerSource: M.GEMMA4_E2B_TOKENIZER,
-      tokenizerConfigSource: M.GEMMA4_E2B_TOKENIZER_CONFIG,
-    },
-  },
-  vulkan: {
-    base: {
-      modelName: 'gemma4-e2b' as const,
-      modelSource: M.GEMMA4_E2B_VULKAN_MODEL,
-      tokenizerSource: M.GEMMA4_E2B_TOKENIZER,
-      tokenizerConfigSource: M.GEMMA4_E2B_TOKENIZER_CONFIG,
-    },
-  },
-};
-
-const GEMMA4_E2B_MM_CONFIG = {
-  modelName: 'gemma4-e2b-multimodal' as const,
-  tokenizerSource: M.GEMMA4_E2B_TOKENIZER,
-  tokenizerConfigSource: M.GEMMA4_E2B_TOKENIZER_CONFIG,
-  capabilities: ['vision', 'audio'] as const,
-  audioConfig: {
-    samplesPerBlock: 7680,
-    tokensPerBlock: 12,
-  },
-};
-
-const GEMMA4_E2B_MM_VARIANTS = {
-  mlx: {
-    base: { ...GEMMA4_E2B_MM_CONFIG, modelSource: M.GEMMA4_E2B_MLX_MM },
-  },
-  vulkan: {
-    base: { ...GEMMA4_E2B_MM_CONFIG, modelSource: M.GEMMA4_E2B_VULKAN_MM },
-  },
-  xnnpack: {
-    base: { ...GEMMA4_E2B_MM_CONFIG, modelSource: M.GEMMA4_E2B_XNNPACK_MM },
-  },
-};
-
-const EFFICIENTNET_V2_S_VARIANTS = {
-  xnnpack: {
-    base: {
-      modelName: 'efficientnet-v2-s' as const,
-      modelSource: M.EFFICIENTNET_V2_S_XNNPACK_FP32_MODEL,
-    },
-    quant: {
-      modelName: 'efficientnet-v2-s-quantized' as const,
-      modelSource: M.EFFICIENTNET_V2_S_XNNPACK_INT8_MODEL,
-    },
-  },
-  coreml: {
-    base: {
-      modelName: 'efficientnet-v2-s' as const,
-      modelSource: M.EFFICIENTNET_V2_S_COREML_FP32_MODEL,
-    },
-    quant: {
-      modelName: 'efficientnet-v2-s-quantized' as const,
-      modelSource: M.EFFICIENTNET_V2_S_COREML_FP16_MODEL,
-    },
-  },
-};
-
-const SSDLITE_320_MOBILENET_V3_LARGE_VARIANTS = {
-  xnnpack: {
-    base: {
-      modelName: 'ssdlite-320-mobilenet-v3-large' as const,
-      modelSource: M.SSDLITE_320_MOBILENET_V3_LARGE_XNNPACK_FP32_MODEL,
-    },
-  },
-  coreml: {
-    base: {
-      modelName: 'ssdlite-320-mobilenet-v3-large' as const,
-      modelSource: M.SSDLITE_320_MOBILENET_V3_LARGE_COREML_FP16_MODEL,
-    },
-  },
-};
-
-const RF_DETR_NANO_VARIANTS = {
-  xnnpack: {
-    base: {
-      modelName: 'rf-detr-nano' as const,
-      modelSource: M.RF_DETR_NANO_XNNPACK_FP32_MODEL,
-    },
-  },
-  coreml: {
-    base: {
-      modelName: 'rf-detr-nano' as const,
-      modelSource: M.RF_DETR_NANO_COREML_INT8_MODEL,
-    },
-  },
-};
-
-const RF_DETR_NANO_SEG_VARIANTS = {
-  xnnpack: {
-    base: {
-      modelName: 'rfdetr-nano-seg' as const,
-      modelSource: M.RF_DETR_NANO_SEG_XNNPACK_FP32_MODEL,
-    },
-  },
-  coreml: {
-    base: {
-      modelName: 'rfdetr-nano-seg' as const,
-      modelSource: M.RF_DETR_NANO_SEG_COREML_INT8_MODEL,
-    },
-  },
-};
-
-const FASTSAM_S_VARIANTS = {
-  xnnpack: {
-    base: {
-      modelName: 'fastsam-s' as const,
-      modelSource: M.FASTSAM_S_XNNPACK_FP32_MODEL,
-    },
-  },
-  coreml: {
-    base: {
-      modelName: 'fastsam-s' as const,
-      modelSource: M.FASTSAM_S_COREML_FP16_MODEL,
-    },
-  },
-};
-
-const FASTSAM_X_VARIANTS = {
-  xnnpack: {
-    base: {
-      modelName: 'fastsam-x' as const,
-      modelSource: M.FASTSAM_X_XNNPACK_FP32_MODEL,
-    },
-  },
-  coreml: {
-    base: {
-      modelName: 'fastsam-x' as const,
-      modelSource: M.FASTSAM_X_COREML_FP16_MODEL,
-    },
-  },
-};
-
-function styleTransferVariants<
-  const Display extends string,
-  const Slug extends string,
->(display: Display, slug: Slug) {
-  const urls = M.styleTransferUrls(display, slug);
-  return {
-    xnnpack: {
-      base: {
-        modelName: `style-transfer-${display}`,
-        modelSource: urls.xnnpackBase,
-      } as {
-        modelName: `style-transfer-${Display}`;
-        modelSource: string;
-      },
-      quant: {
-        modelName: `style-transfer-${display}-quantized`,
-        modelSource: urls.xnnpackQuant,
-      } as {
-        modelName: `style-transfer-${Display}-quantized`;
-        modelSource: string;
-      },
-    },
-    coreml: {
-      base: {
-        modelName: `style-transfer-${display}`,
-        modelSource: urls.coremlBase,
-      } as {
-        modelName: `style-transfer-${Display}`;
-        modelSource: string;
-      },
-      quant: {
-        modelName: `style-transfer-${display}-quantized`,
-        modelSource: urls.coremlQuant,
-      } as {
-        modelName: `style-transfer-${Display}-quantized`;
-        modelSource: string;
-      },
-    },
-  };
-}
-
-const STYLE_TRANSFER_CANDY_VARIANTS = styleTransferVariants('candy', 'candy');
-const STYLE_TRANSFER_MOSAIC_VARIANTS = styleTransferVariants(
-  'mosaic',
-  'mosaic'
-);
-const STYLE_TRANSFER_RAIN_PRINCESS_VARIANTS = styleTransferVariants(
-  'rain-princess',
-  'rain_princess'
-);
-const STYLE_TRANSFER_UDNIE_VARIANTS = styleTransferVariants('udnie', 'udnie');
-
-function whisperVariants<const N extends string, const IsML extends boolean>(
-  modelName: N,
-  isMultilingual: IsML,
-  xnnpackUrl: string,
-  coremlUrl: string,
-  tokenizerUrl: string
-) {
-  return {
-    xnnpack: {
-      base: {
-        modelName,
-        isMultilingual,
-        modelSource: xnnpackUrl,
-        tokenizerSource: tokenizerUrl,
-      } as {
-        modelName: N;
-        isMultilingual: IsML;
-        modelSource: string;
-        tokenizerSource: string;
-      },
-    },
-    coreml: {
-      base: {
-        modelName,
-        isMultilingual,
-        modelSource: coremlUrl,
-        tokenizerSource: tokenizerUrl,
-      } as {
-        modelName: N;
-        isMultilingual: IsML;
-        modelSource: string;
-        tokenizerSource: string;
-      },
-    },
-  };
-}
-
-const WHISPER_TINY_EN_VARIANTS = whisperVariants(
-  'whisper-tiny-en',
-  false,
-  M.WHISPER_TINY_EN_MODEL_XNNPACK,
-  M.WHISPER_TINY_EN_MODEL_COREML,
-  M.WHISPER_TINY_EN_TOKENIZER
-);
-const WHISPER_BASE_EN_VARIANTS = whisperVariants(
-  'whisper-base-en',
-  false,
-  M.WHISPER_BASE_EN_MODEL_XNNPACK,
-  M.WHISPER_BASE_EN_MODEL_COREML,
-  M.WHISPER_BASE_EN_TOKENIZER
-);
-const WHISPER_SMALL_EN_VARIANTS = whisperVariants(
-  'whisper-small-en',
-  false,
-  M.WHISPER_SMALL_EN_MODEL_XNNPACK,
-  M.WHISPER_SMALL_EN_MODEL_COREML,
-  M.WHISPER_SMALL_EN_TOKENIZER
-);
-const WHISPER_TINY_VARIANTS = whisperVariants(
-  'whisper-tiny',
-  true,
-  M.WHISPER_TINY_MODEL_XNNPACK,
-  M.WHISPER_TINY_MODEL_COREML,
-  M.WHISPER_TINY_TOKENIZER
-);
-const WHISPER_BASE_VARIANTS = whisperVariants(
-  'whisper-base',
-  true,
-  M.WHISPER_BASE_MODEL_XNNPACK,
-  M.WHISPER_BASE_MODEL_COREML,
-  M.WHISPER_BASE_TOKENIZER
-);
-const WHISPER_SMALL_VARIANTS = whisperVariants(
-  'whisper-small',
-  true,
-  M.WHISPER_SMALL_MODEL_XNNPACK,
-  M.WHISPER_SMALL_MODEL_COREML,
-  M.WHISPER_SMALL_TOKENIZER
-);
-
-// ─────────────────────────────────────────────────────────────────────────────
-// OCR — language-parameterized accessor.
-//
-// The OCR pipeline ships one CRAFT detector + per-alphabet CRNN recognizers,
-// already paired up in `OCR_<LANGUAGE>` objects keyed by ISO language token
-// (the `.language` field on each export). Build a runtime map from those
-// exports so the user only needs to pass `{ language: 'en' }`.
-// ─────────────────────────────────────────────────────────────────────────────
-
-type OcrConfig = typeof OCR.OCR_ABAZA;
-type SupportedLanguage = keyof typeof symbols;
-
-const OCR_BY_LANGUAGE: Partial<Record<SupportedLanguage, OcrConfig>> = (() => {
-  const map: Partial<Record<SupportedLanguage, OcrConfig>> = {};
-  for (const value of Object.values(OCR) as OcrConfig[]) {
-    if (value && typeof value === 'object' && 'language' in value) {
-      map[value.language as SupportedLanguage] = value;
-    }
-  }
-  return map;
-})();
-
-function craft({ language }: { language: SupportedLanguage }): OcrConfig {
-  const cfg = OCR_BY_LANGUAGE[language];
-  if (!cfg) {
-    throw new RnExecutorchError(
-      RnExecutorchErrorCode.LanguageNotSupported,
-      `OCR is not published for language '${language}'. ` +
-        `Supported: ${Object.keys(OCR_BY_LANGUAGE).sort().join(', ')}`
-    );
-  }
-  return cfg;
-}
-
-/**
- * Typed model registry grouped by capability. Each entry is a function-only
- * accessor: call it (optionally with `{ quant, backend }`) to get the resolved
- * config. The `backend` parameter is typed to exactly the backends a given
- * model ships with — asking for a backend a model doesn't publish is a
- * compile-time error.
- * @example
- * ```ts
- * import { models } from 'react-native-executorch';
- *
- * // Platform default (CoreML on iOS, XNNPACK on Android for multi-backend models).
- * useObjectDetection({ model: models.object_detection.rf_detr_nano() });
- *
- * // Explicit backend.
- * useObjectDetection({
- *   model: models.object_detection.rf_detr_nano({ backend: 'xnnpack' }),
- * });
- *
- * // Non-quantized variant.
- * useLLM({ model: models.llm.llama3_2_3b({ quant: false }) });
- *
- * // OCR — language-parameterized.
- * useOcr({ model: models.ocr({ language: 'en' }) });
- * ```
- * @category Utils
- */
-export const models = {
-  llm: {
-    llama3_2_1b: pair(M.LLAMA3_2_1B, M.LLAMA3_2_1B_SPINQUANT),
-    llama3_2_3b: pair(M.LLAMA3_2_3B, M.LLAMA3_2_3B_SPINQUANT),
-    qwen3_0_6b: pair(M.QWEN3_0_6B, M.QWEN3_0_6B_QUANTIZED),
-    qwen3_1_7b: pair(M.QWEN3_1_7B, M.QWEN3_1_7B_QUANTIZED),
-    qwen3_4b: pair(M.QWEN3_4B, M.QWEN3_4B_QUANTIZED),
-    qwen3_5_0_8b: base(M.QWEN3_5_0_8B_QUANTIZED),
-    qwen3_5_2b: base(M.QWEN3_5_2B_QUANTIZED),
-    qwen2_5_0_5b: pair(M.QWEN2_5_0_5B, M.QWEN2_5_0_5B_QUANTIZED),
-    qwen2_5_1_5b: pair(M.QWEN2_5_1_5B, M.QWEN2_5_1_5B_QUANTIZED),
-    qwen2_5_3b: pair(M.QWEN2_5_3B, M.QWEN2_5_3B_QUANTIZED),
-    hammer2_1_0_5b: pair(M.HAMMER2_1_0_5B, M.HAMMER2_1_0_5B_QUANTIZED),
-    hammer2_1_1_5b: pair(M.HAMMER2_1_1_5B, M.HAMMER2_1_1_5B_QUANTIZED),
-    hammer2_1_3b: pair(M.HAMMER2_1_3B, M.HAMMER2_1_3B_QUANTIZED),
-    smollm2_1_135m: pair(M.SMOLLM2_1_135M, M.SMOLLM2_1_135M_QUANTIZED),
-    smollm2_1_360m: pair(M.SMOLLM2_1_360M, M.SMOLLM2_1_360M_QUANTIZED),
-    smollm2_1_1_7b: pair(M.SMOLLM2_1_1_7B, M.SMOLLM2_1_1_7B_QUANTIZED),
-    phi_4_mini_4b: pair(M.PHI_4_MINI_4B, M.PHI_4_MINI_4B_QUANTIZED),
-    lfm2_5_350m: pair(M.LFM2_5_350M, M.LFM2_5_350M_QUANTIZED),
-    lfm2_5_1_2b_instruct: pair(
-      M.LFM2_5_1_2B_INSTRUCT,
-      M.LFM2_5_1_2B_INSTRUCT_QUANTIZED
-    ),
-    bielik_v3_0_1_5b: pair(M.BIELIK_V3_0_1_5B, M.BIELIK_V3_0_1_5B_QUANTIZED),
-    gemma4_e2b: variant(GEMMA4_E2B_VARIANTS, {
-      ios: 'mlx',
-      android: 'vulkan',
-    }),
-    // Multimodal LLMs — same hook/module as plain LLMs, listed here so users
-    // pick a model by capability ("LLM") rather than by modality.
-    lfm2_5_vl_1_6b: base(M.LFM2_5_VL_1_6B_QUANTIZED),
-    lfm2_5_vl_450m: base(M.LFM2_5_VL_450M_QUANTIZED),
-    gemma4_e2b_multimodal: variant(GEMMA4_E2B_MM_VARIANTS, {
-      ios: 'mlx',
-      android: 'vulkan',
-    }),
-  },
-  classification: {
-    efficientnet_v2_s: variant(EFFICIENTNET_V2_S_VARIANTS),
-  },
-  privacy_filter: {
-    openai: base(M.PRIVACY_FILTER_OPENAI),
-    nemotron: base(M.PRIVACY_FILTER_NEMOTRON),
-  },
-  object_detection: {
-    ssdlite_320_mobilenet_v3_large: variant(
-      SSDLITE_320_MOBILENET_V3_LARGE_VARIANTS
-    ),
-    rf_detr_nano: variant(RF_DETR_NANO_VARIANTS),
-    yolo26n: base(M.YOLO26N),
-    yolo26s: base(M.YOLO26S),
-    yolo26m: base(M.YOLO26M),
-    yolo26l: base(M.YOLO26L),
-    yolo26x: base(M.YOLO26X),
-  },
-  pose_estimation: {
-    yolo26n: base(M.YOLO26N_POSE),
-  },
-  semantic_segmentation: {
-    deeplab_v3_resnet50: pair(
-      M.DEEPLAB_V3_RESNET50,
-      M.DEEPLAB_V3_RESNET50_QUANTIZED
-    ),
-    deeplab_v3_resnet101: pair(
-      M.DEEPLAB_V3_RESNET101,
-      M.DEEPLAB_V3_RESNET101_QUANTIZED
-    ),
-    deeplab_v3_mobilenet_v3_large: pair(
-      M.DEEPLAB_V3_MOBILENET_V3_LARGE,
-      M.DEEPLAB_V3_MOBILENET_V3_LARGE_QUANTIZED
-    ),
-    lraspp_mobilenet_v3_large: pair(
-      M.LRASPP_MOBILENET_V3_LARGE,
-      M.LRASPP_MOBILENET_V3_LARGE_QUANTIZED
-    ),
-    fcn_resnet50: pair(M.FCN_RESNET50, M.FCN_RESNET50_QUANTIZED),
-    fcn_resnet101: pair(M.FCN_RESNET101, M.FCN_RESNET101_QUANTIZED),
-    selfie_segmentation: base(M.SELFIE_SEGMENTATION),
-  },
-  instance_segmentation: {
-    yolo26n: base(M.YOLO26N_SEG),
-    yolo26s: base(M.YOLO26S_SEG),
-    yolo26m: base(M.YOLO26M_SEG),
-    yolo26l: base(M.YOLO26L_SEG),
-    yolo26x: base(M.YOLO26X_SEG),
-    rf_detr_nano: variant(RF_DETR_NANO_SEG_VARIANTS),
-    fastsam_s: variant(FASTSAM_S_VARIANTS),
-    fastsam_x: variant(FASTSAM_X_VARIANTS),
-  },
-  style_transfer: {
-    candy: variant(STYLE_TRANSFER_CANDY_VARIANTS),
-    mosaic: variant(STYLE_TRANSFER_MOSAIC_VARIANTS),
-    rain_princess: variant(STYLE_TRANSFER_RAIN_PRINCESS_VARIANTS),
-    udnie: variant(STYLE_TRANSFER_UDNIE_VARIANTS),
-  },
-  speech_to_text: {
-    whisper_tiny_en: variant(WHISPER_TINY_EN_VARIANTS),
-    whisper_base_en: variant(WHISPER_BASE_EN_VARIANTS),
-    whisper_small_en: variant(WHISPER_SMALL_EN_VARIANTS),
-    whisper_tiny: variant(WHISPER_TINY_VARIANTS),
-    whisper_base: variant(WHISPER_BASE_VARIANTS),
-    whisper_small: variant(WHISPER_SMALL_VARIANTS),
-  },
-  // Kokoro presets bundle model + voice + phonemizer per language. They go
-  // through `useTextToSpeech` directly — pick one and pass it as the `model`.
-  // Nested under the model family (`kokoro`) so a future TTS family can be
-  // added without breaking call sites.
-  text_to_speech: {
-    kokoro: {
-      en_us: {
-        heart: tts(KOKORO_AMERICAN_ENGLISH_FEMALE_HEART),
-        river: tts(KOKORO_AMERICAN_ENGLISH_FEMALE_RIVER),
-        sarah: tts(KOKORO_AMERICAN_ENGLISH_FEMALE_SARAH),
-        adam: tts(KOKORO_AMERICAN_ENGLISH_MALE_ADAM),
-        michael: tts(KOKORO_AMERICAN_ENGLISH_MALE_MICHAEL),
-        santa: tts(KOKORO_AMERICAN_ENGLISH_MALE_SANTA),
-      },
-      en_gb: {
-        emma: tts(KOKORO_BRITISH_ENGLISH_FEMALE_EMMA),
-        daniel: tts(KOKORO_BRITISH_ENGLISH_MALE_DANIEL),
-      },
-      fr: {
-        siwis: tts(KOKORO_FRENCH_FEMALE_SIWIS),
-      },
-      es: {
-        dora: tts(KOKORO_SPANISH_FEMALE_DORA),
-        alex: tts(KOKORO_SPANISH_MALE_ALEX),
-      },
-      it: {
-        sara: tts(KOKORO_ITALIAN_FEMALE_SARA),
-        nicola: tts(KOKORO_ITALIAN_MALE_NICOLA),
-      },
-      pt: {
-        dora: tts(KOKORO_PORTUGUESE_FEMALE_DORA),
-        santa: tts(KOKORO_PORTUGUESE_MALE_SANTA),
-      },
-      hi: {
-        alpha: tts(KOKORO_HINDI_FEMALE_ALPHA),
-        omega: tts(KOKORO_HINDI_MALE_OMEGA),
-        psi: tts(KOKORO_HINDI_MALE_PSI),
-      },
-      pl: {
-        mateusz: tts(KOKORO_POLISH_MALE_MATEUSZ),
-      },
-      de: {
-        anna: tts(KOKORO_GERMAN_FEMALE_ANNA),
-      },
-    },
-  },
-  text_embedding: {
-    all_minilm_l6_v2: base(M.ALL_MINILM_L6_V2),
-    all_mpnet_base_v2: base(M.ALL_MPNET_BASE_V2),
-    multi_qa_minilm_l6_cos_v1: base(M.MULTI_QA_MINILM_L6_COS_V1),
-    multi_qa_mpnet_base_dot_v1: base(M.MULTI_QA_MPNET_BASE_DOT_V1),
-    distiluse_base_multilingual_cased_v2: base({
-      modelName: 'distiluse-base-multilingual-cased-v2-8da4w' as const,
-      modelSource: M.DISTILUSE_BASE_MULTILINGUAL_CASED_V2_8DA4W_MODEL,
-      tokenizerSource: M.DISTILUSE_BASE_MULTILINGUAL_CASED_V2_TOKENIZER,
-    }),
-    paraphrase_multilingual_minilm_l12_v2: base(
-      M.PARAPHRASE_MULTILINGUAL_MINILM_L12_V2_QUANTIZED
-    ),
-    clip_vit_base_patch32_text: base(M.CLIP_VIT_BASE_PATCH32_TEXT),
-  },
-  image_embedding: {
-    clip_vit_base_patch32_image: pair(
-      M.CLIP_VIT_BASE_PATCH32_IMAGE,
-      M.CLIP_VIT_BASE_PATCH32_IMAGE_QUANTIZED
-    ),
-  },
-  image_generation: {
-    bk_sdm_tiny_vpred_512: base(M.BK_SDM_TINY_VPRED_512),
-    bk_sdm_tiny_vpred_256: base(M.BK_SDM_TINY_VPRED_256),
-  },
-  vad: {
-    fsmn_vad: base(M.FSMN_VAD),
-  },
-  // Nested under the detector model (`craft`) so a future OCR pipeline
-  // (e.g. an end-to-end TrOCR) can land as a sibling without breaking
-  // existing call sites.
-  ocr: { craft },
-} as const;
diff --git a/packages/react-native-executorch/src/constants/modelUrls.ts b/packages/react-native-executorch/src/constants/modelUrls.ts
deleted file mode 100644
index 2520d84520..0000000000
--- a/packages/react-native-executorch/src/constants/modelUrls.ts
+++ /dev/null
@@ -1,1428 +0,0 @@
-import { Platform } from 'react-native';
-import { URL_PREFIX, PREVIOUS_VERSION_TAG, VERSION_TAG } from './versions';
-
-// LLMs
-
-// LLAMA 3.2
-const LLAMA3_2_3B_MODEL = `${URL_PREFIX}-llama-3.2/${PREVIOUS_VERSION_TAG}/3b/xnnpack/llama_3_2_3b_xnnpack_bf16.pte`;
-// Pinned to v0.8.0 — the last HF tag where the QLoRA files live; SpinQuant
-// supersedes them in later releases.
-const LLAMA3_2_3B_QLORA_MODEL = `${URL_PREFIX}-llama-3.2/resolve/v0.8.0/llama-3.2-3B/QLoRA/llama3_2-3B_qat_lora.pte`;
-const LLAMA3_2_3B_SPINQUANT_MODEL = `${URL_PREFIX}-llama-3.2/${PREVIOUS_VERSION_TAG}/3b/xnnpack/llama_3_2_3b_xnnpack_spinquant.pte`;
-const LLAMA3_2_1B_MODEL = `${URL_PREFIX}-llama-3.2/${PREVIOUS_VERSION_TAG}/1b/xnnpack/llama_3_2_1b_xnnpack_bf16.pte`;
-// Pinned to v0.8.0 — see note above on LLAMA3_2_3B_QLORA_MODEL.
-const LLAMA3_2_1B_QLORA_MODEL = `${URL_PREFIX}-llama-3.2/resolve/v0.8.0/llama-3.2-1B/QLoRA/llama3_2_qat_lora.pte`;
-const LLAMA3_2_1B_SPINQUANT_MODEL = `${URL_PREFIX}-llama-3.2/${PREVIOUS_VERSION_TAG}/1b/xnnpack/llama_3_2_1b_xnnpack_spinquant.pte`;
-const LLAMA3_2_TOKENIZER = `${URL_PREFIX}-llama-3.2/${PREVIOUS_VERSION_TAG}/tokenizer.json`;
-const LLAMA3_2_TOKENIZER_CONFIG = `${URL_PREFIX}-llama-3.2/${PREVIOUS_VERSION_TAG}/tokenizer_config.json`;
-
-/**
- * @category Models - LLM
- */
-export const LLAMA3_2_3B = {
-  modelName: 'llama-3.2-3b',
-  modelSource: LLAMA3_2_3B_MODEL,
-  tokenizerSource: LLAMA3_2_TOKENIZER,
-  tokenizerConfigSource: LLAMA3_2_TOKENIZER_CONFIG,
-} as const;
-
-/**
- * @deprecated Use `LLAMA3_2_3B_SPINQUANT` instead — SpinQuant is the
- * canonical quantized Llama 3.2 3B variant going forward. This alias
- * still resolves the v0.8.0 file for back-compat and will be removed in
- * a future major release.
- * @category Models - LLM
- */
-export const LLAMA3_2_3B_QLORA = {
-  modelName: 'llama-3.2-3b-qlora',
-  modelSource: LLAMA3_2_3B_QLORA_MODEL,
-  tokenizerSource: LLAMA3_2_TOKENIZER,
-  tokenizerConfigSource: LLAMA3_2_TOKENIZER_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const LLAMA3_2_3B_SPINQUANT = {
-  modelName: 'llama-3.2-3b-spinquant',
-  modelSource: LLAMA3_2_3B_SPINQUANT_MODEL,
-  tokenizerSource: LLAMA3_2_TOKENIZER,
-  tokenizerConfigSource: LLAMA3_2_TOKENIZER_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const LLAMA3_2_1B = {
-  modelName: 'llama-3.2-1b',
-  modelSource: LLAMA3_2_1B_MODEL,
-  tokenizerSource: LLAMA3_2_TOKENIZER,
-  tokenizerConfigSource: LLAMA3_2_TOKENIZER_CONFIG,
-} as const;
-
-/**
- * @deprecated Use `LLAMA3_2_1B_SPINQUANT` instead — SpinQuant is the
- * canonical quantized Llama 3.2 1B variant going forward. This alias
- * still resolves the v0.8.0 file for back-compat and will be removed in
- * a future major release.
- * @category Models - LLM
- */
-export const LLAMA3_2_1B_QLORA = {
-  modelName: 'llama-3.2-1b-qlora',
-  modelSource: LLAMA3_2_1B_QLORA_MODEL,
-  tokenizerSource: LLAMA3_2_TOKENIZER,
-  tokenizerConfigSource: LLAMA3_2_TOKENIZER_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const LLAMA3_2_1B_SPINQUANT = {
-  modelName: 'llama-3.2-1b-spinquant',
-  modelSource: LLAMA3_2_1B_SPINQUANT_MODEL,
-  tokenizerSource: LLAMA3_2_TOKENIZER,
-  tokenizerConfigSource: LLAMA3_2_TOKENIZER_CONFIG,
-} as const;
-
-// QWEN 3
-const QWEN3_0_6B_MODEL = `${URL_PREFIX}-qwen-3/${PREVIOUS_VERSION_TAG}/0_6b/xnnpack/qwen_3_0_6b_xnnpack_bf16.pte`;
-const QWEN3_0_6B_QUANTIZED_MODEL = `${URL_PREFIX}-qwen-3/${PREVIOUS_VERSION_TAG}/0_6b/xnnpack/qwen_3_0_6b_xnnpack_8da4w.pte`;
-const QWEN3_1_7B_MODEL = `${URL_PREFIX}-qwen-3/${PREVIOUS_VERSION_TAG}/1_7b/xnnpack/qwen_3_1_7b_xnnpack_bf16.pte`;
-const QWEN3_1_7B_QUANTIZED_MODEL = `${URL_PREFIX}-qwen-3/${PREVIOUS_VERSION_TAG}/1_7b/xnnpack/qwen_3_1_7b_xnnpack_8da4w.pte`;
-const QWEN3_4B_MODEL = `${URL_PREFIX}-qwen-3/${PREVIOUS_VERSION_TAG}/4b/xnnpack/qwen_3_4b_xnnpack_bf16.pte`;
-const QWEN3_4B_QUANTIZED_MODEL = `${URL_PREFIX}-qwen-3/${PREVIOUS_VERSION_TAG}/4b/xnnpack/qwen_3_4b_xnnpack_8da4w.pte`;
-const QWEN3_TOKENIZER = `${URL_PREFIX}-qwen-3/${PREVIOUS_VERSION_TAG}/tokenizer.json`;
-const QWEN3_TOKENIZER_CONFIG = `${URL_PREFIX}-qwen-3/${PREVIOUS_VERSION_TAG}/tokenizer_config.json`;
-
-// Qwen3's published generation_config.json recommends temperature=0.6 and
-// top_p=0.95. We propagate those to every Qwen3 preset so model quality is
-// reasonable out of the box; users can override via `configure()`.
-const QWEN3_GENERATION_CONFIG = {
-  temperature: 0.6,
-  topP: 0.95,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const QWEN3_0_6B = {
-  modelName: 'qwen3-0.6b',
-  modelSource: QWEN3_0_6B_MODEL,
-  tokenizerSource: QWEN3_TOKENIZER,
-  tokenizerConfigSource: QWEN3_TOKENIZER_CONFIG,
-  generationConfig: QWEN3_GENERATION_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const QWEN3_0_6B_QUANTIZED = {
-  modelName: 'qwen3-0.6b-quantized',
-  modelSource: QWEN3_0_6B_QUANTIZED_MODEL,
-  tokenizerSource: QWEN3_TOKENIZER,
-  tokenizerConfigSource: QWEN3_TOKENIZER_CONFIG,
-  generationConfig: QWEN3_GENERATION_CONFIG,
-} as const;
-
-// GEMMA 4 — separate HF repo; tokenizer files live at the e2b root and are
-// shared by all backend variants.
-const GEMMA4_E2B_PREFIX = `${URL_PREFIX}-gemma-4/${PREVIOUS_VERSION_TAG}/e2b`;
-export const GEMMA4_E2B_MLX_MODEL = `${GEMMA4_E2B_PREFIX}/mlx/gemma4_e2b_mlx_int4.pte`;
-export const GEMMA4_E2B_XNNPACK_MODEL = `${GEMMA4_E2B_PREFIX}/xnnpack/gemma_4_e2b_xnnpack_8da4w.pte`;
-export const GEMMA4_E2B_VULKAN_MODEL = `${GEMMA4_E2B_PREFIX}/vulkan/gemma_4_e2b_vulkan_8da4w.pte`;
-export const GEMMA4_E2B_TOKENIZER = `${GEMMA4_E2B_PREFIX}/tokenizer.json`;
-export const GEMMA4_E2B_TOKENIZER_CONFIG = `${GEMMA4_E2B_PREFIX}/tokenizer_config.json`;
-
-export const GEMMA4_E2B_MLX_MM = `${URL_PREFIX}-gemma-4-multimodal/${PREVIOUS_VERSION_TAG}/e2b/mlx/gemma4_e2b_mlx_int4.pte`;
-export const GEMMA4_E2B_VULKAN_MM = `${URL_PREFIX}-gemma-4-multimodal/${PREVIOUS_VERSION_TAG}/e2b/vulkan/gemma_4_e2b_vulkan_8da4w.pte`;
-export const GEMMA4_E2B_XNNPACK_MM = `${URL_PREFIX}-gemma-4-multimodal/${PREVIOUS_VERSION_TAG}/e2b/xnnpack/gemma_4_e2b_xnnpack_8da4w.pte`;
-
-/**
- * @category Models - LLM
- */
-export const QWEN3_1_7B = {
-  modelName: 'qwen3-1.7b',
-  modelSource: QWEN3_1_7B_MODEL,
-  tokenizerSource: QWEN3_TOKENIZER,
-  tokenizerConfigSource: QWEN3_TOKENIZER_CONFIG,
-  generationConfig: QWEN3_GENERATION_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const QWEN3_1_7B_QUANTIZED = {
-  modelName: 'qwen3-1.7b-quantized',
-  modelSource: QWEN3_1_7B_QUANTIZED_MODEL,
-  tokenizerSource: QWEN3_TOKENIZER,
-  tokenizerConfigSource: QWEN3_TOKENIZER_CONFIG,
-  generationConfig: QWEN3_GENERATION_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const QWEN3_4B = {
-  modelName: 'qwen3-4b',
-  modelSource: QWEN3_4B_MODEL,
-  tokenizerSource: QWEN3_TOKENIZER,
-  tokenizerConfigSource: QWEN3_TOKENIZER_CONFIG,
-  generationConfig: QWEN3_GENERATION_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const QWEN3_4B_QUANTIZED = {
-  modelName: 'qwen3-4b-quantized',
-  modelSource: QWEN3_4B_QUANTIZED_MODEL,
-  tokenizerSource: QWEN3_TOKENIZER,
-  tokenizerConfigSource: QWEN3_TOKENIZER_CONFIG,
-  generationConfig: QWEN3_GENERATION_CONFIG,
-} as const;
-
-// HAMMER 2.1
-const HAMMER2_1_0_5B_MODEL = `${URL_PREFIX}-hammer-2.1/${PREVIOUS_VERSION_TAG}/0_5b/xnnpack/hammer_2_1_0_5b_xnnpack_bf16.pte`;
-const HAMMER2_1_0_5B_QUANTIZED_MODEL = `${URL_PREFIX}-hammer-2.1/${PREVIOUS_VERSION_TAG}/0_5b/xnnpack/hammer_2_1_0_5b_xnnpack_8da4w.pte`;
-const HAMMER2_1_1_5B_MODEL = `${URL_PREFIX}-hammer-2.1/${PREVIOUS_VERSION_TAG}/1_5b/xnnpack/hammer_2_1_1_5b_xnnpack_bf16.pte`;
-const HAMMER2_1_1_5B_QUANTIZED_MODEL = `${URL_PREFIX}-hammer-2.1/${PREVIOUS_VERSION_TAG}/1_5b/xnnpack/hammer_2_1_1_5b_xnnpack_8da4w.pte`;
-const HAMMER2_1_3B_MODEL = `${URL_PREFIX}-hammer-2.1/${PREVIOUS_VERSION_TAG}/3b/xnnpack/hammer_2_1_3b_xnnpack_bf16.pte`;
-const HAMMER2_1_3B_QUANTIZED_MODEL = `${URL_PREFIX}-hammer-2.1/${PREVIOUS_VERSION_TAG}/3b/xnnpack/hammer_2_1_3b_xnnpack_8da4w.pte`;
-const HAMMER2_1_TOKENIZER = `${URL_PREFIX}-hammer-2.1/${PREVIOUS_VERSION_TAG}/tokenizer.json`;
-const HAMMER2_1_TOKENIZER_CONFIG = `${URL_PREFIX}-hammer-2.1/${PREVIOUS_VERSION_TAG}/tokenizer_config.json`;
-
-/**
- * @category Models - LLM
- */
-export const HAMMER2_1_0_5B = {
-  modelName: 'hammer2.1-0.5b',
-  modelSource: HAMMER2_1_0_5B_MODEL,
-  tokenizerSource: HAMMER2_1_TOKENIZER,
-  tokenizerConfigSource: HAMMER2_1_TOKENIZER_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const HAMMER2_1_0_5B_QUANTIZED = {
-  modelName: 'hammer2.1-0.5b-quantized',
-  modelSource: HAMMER2_1_0_5B_QUANTIZED_MODEL,
-  tokenizerSource: HAMMER2_1_TOKENIZER,
-  tokenizerConfigSource: HAMMER2_1_TOKENIZER_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const HAMMER2_1_1_5B = {
-  modelName: 'hammer2.1-1.5b',
-  modelSource: HAMMER2_1_1_5B_MODEL,
-  tokenizerSource: HAMMER2_1_TOKENIZER,
-  tokenizerConfigSource: HAMMER2_1_TOKENIZER_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const HAMMER2_1_1_5B_QUANTIZED = {
-  modelName: 'hammer2.1-1.5b-quantized',
-  modelSource: HAMMER2_1_1_5B_QUANTIZED_MODEL,
-  tokenizerSource: HAMMER2_1_TOKENIZER,
-  tokenizerConfigSource: HAMMER2_1_TOKENIZER_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const HAMMER2_1_3B = {
-  modelName: 'hammer2.1-3b',
-  modelSource: HAMMER2_1_3B_MODEL,
-  tokenizerSource: HAMMER2_1_TOKENIZER,
-  tokenizerConfigSource: HAMMER2_1_TOKENIZER_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const HAMMER2_1_3B_QUANTIZED = {
-  modelName: 'hammer2.1-3b-quantized',
-  modelSource: HAMMER2_1_3B_QUANTIZED_MODEL,
-  tokenizerSource: HAMMER2_1_TOKENIZER,
-  tokenizerConfigSource: HAMMER2_1_TOKENIZER_CONFIG,
-} as const;
-
-// SMOLLM2
-const SMOLLM2_1_135M_MODEL = `${URL_PREFIX}-smolLm-2/${PREVIOUS_VERSION_TAG}/135m/xnnpack/smollm2_135m_xnnpack_bf16.pte`;
-const SMOLLM2_1_135M_QUANTIZED_MODEL = `${URL_PREFIX}-smolLm-2/${PREVIOUS_VERSION_TAG}/135m/xnnpack/smollm2_135m_xnnpack_8da4w.pte`;
-const SMOLLM2_1_360M_MODEL = `${URL_PREFIX}-smolLm-2/${PREVIOUS_VERSION_TAG}/360m/xnnpack/smollm2_360m_xnnpack_bf16.pte`;
-const SMOLLM2_1_360M_QUANTIZED_MODEL = `${URL_PREFIX}-smolLm-2/${PREVIOUS_VERSION_TAG}/360m/xnnpack/smollm2_360m_xnnpack_8da4w.pte`;
-const SMOLLM2_1_1_7B_MODEL = `${URL_PREFIX}-smolLm-2/${PREVIOUS_VERSION_TAG}/1_7b/xnnpack/smollm2_1_7b_xnnpack_bf16.pte`;
-const SMOLLM2_1_1_7B_QUANTIZED_MODEL = `${URL_PREFIX}-smolLm-2/${PREVIOUS_VERSION_TAG}/1_7b/xnnpack/smollm2_1_7b_xnnpack_8da4w.pte`;
-const SMOLLM2_1_TOKENIZER = `${URL_PREFIX}-smolLm-2/${PREVIOUS_VERSION_TAG}/tokenizer.json`;
-const SMOLLM2_1_TOKENIZER_CONFIG = `${URL_PREFIX}-smolLm-2/${PREVIOUS_VERSION_TAG}/tokenizer_config.json`;
-
-/**
- * @category Models - LLM
- */
-export const SMOLLM2_1_135M = {
-  modelName: 'smollm2.1-135m',
-  modelSource: SMOLLM2_1_135M_MODEL,
-  tokenizerSource: SMOLLM2_1_TOKENIZER,
-  tokenizerConfigSource: SMOLLM2_1_TOKENIZER_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const SMOLLM2_1_135M_QUANTIZED = {
-  modelName: 'smollm2.1-135m-quantized',
-  modelSource: SMOLLM2_1_135M_QUANTIZED_MODEL,
-  tokenizerSource: SMOLLM2_1_TOKENIZER,
-  tokenizerConfigSource: SMOLLM2_1_TOKENIZER_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const SMOLLM2_1_360M = {
-  modelName: 'smollm2.1-360m',
-  modelSource: SMOLLM2_1_360M_MODEL,
-  tokenizerSource: SMOLLM2_1_TOKENIZER,
-  tokenizerConfigSource: SMOLLM2_1_TOKENIZER_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const SMOLLM2_1_360M_QUANTIZED = {
-  modelName: 'smollm2.1-360m-quantized',
-  modelSource: SMOLLM2_1_360M_QUANTIZED_MODEL,
-  tokenizerSource: SMOLLM2_1_TOKENIZER,
-  tokenizerConfigSource: SMOLLM2_1_TOKENIZER_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const SMOLLM2_1_1_7B = {
-  modelName: 'smollm2.1-1.7b',
-  modelSource: SMOLLM2_1_1_7B_MODEL,
-  tokenizerSource: SMOLLM2_1_TOKENIZER,
-  tokenizerConfigSource: SMOLLM2_1_TOKENIZER_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const SMOLLM2_1_1_7B_QUANTIZED = {
-  modelName: 'smollm2.1-1.7b-quantized',
-  modelSource: SMOLLM2_1_1_7B_QUANTIZED_MODEL,
-  tokenizerSource: SMOLLM2_1_TOKENIZER,
-  tokenizerConfigSource: SMOLLM2_1_TOKENIZER_CONFIG,
-} as const;
-
-// QWEN 2.5
-const QWEN2_5_0_5B_MODEL = `${URL_PREFIX}-qwen-2.5/${PREVIOUS_VERSION_TAG}/0_5b/xnnpack/qwen_2_5_0_5b_xnnpack_bf16.pte`;
-const QWEN2_5_0_5B_QUANTIZED_MODEL = `${URL_PREFIX}-qwen-2.5/${PREVIOUS_VERSION_TAG}/0_5b/xnnpack/qwen_2_5_0_5b_xnnpack_8da4w.pte`;
-const QWEN2_5_1_5B_MODEL = `${URL_PREFIX}-qwen-2.5/${PREVIOUS_VERSION_TAG}/1_5b/xnnpack/qwen_2_5_1_5b_xnnpack_bf16.pte`;
-const QWEN2_5_1_5B_QUANTIZED_MODEL = `${URL_PREFIX}-qwen-2.5/${PREVIOUS_VERSION_TAG}/1_5b/xnnpack/qwen_2_5_1_5b_xnnpack_8da4w.pte`;
-const QWEN2_5_3B_MODEL = `${URL_PREFIX}-qwen-2.5/${PREVIOUS_VERSION_TAG}/3b/xnnpack/qwen_2_5_3b_xnnpack_bf16.pte`;
-const QWEN2_5_3B_QUANTIZED_MODEL = `${URL_PREFIX}-qwen-2.5/${PREVIOUS_VERSION_TAG}/3b/xnnpack/qwen_2_5_3b_xnnpack_8da4w.pte`;
-const QWEN2_5_TOKENIZER = `${URL_PREFIX}-qwen-2.5/${PREVIOUS_VERSION_TAG}/tokenizer.json`;
-const QWEN2_5_TOKENIZER_CONFIG = `${URL_PREFIX}-qwen-2.5/${PREVIOUS_VERSION_TAG}/tokenizer_config.json`;
-
-/**
- * @category Models - LLM
- */
-export const QWEN2_5_0_5B = {
-  modelName: 'qwen2.5-0.5b',
-  modelSource: QWEN2_5_0_5B_MODEL,
-  tokenizerSource: QWEN2_5_TOKENIZER,
-  tokenizerConfigSource: QWEN2_5_TOKENIZER_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const QWEN2_5_0_5B_QUANTIZED = {
-  modelName: 'qwen2.5-0.5b-quantized',
-  modelSource: QWEN2_5_0_5B_QUANTIZED_MODEL,
-  tokenizerSource: QWEN2_5_TOKENIZER,
-  tokenizerConfigSource: QWEN2_5_TOKENIZER_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const QWEN2_5_1_5B = {
-  modelName: 'qwen2.5-1.5b',
-  modelSource: QWEN2_5_1_5B_MODEL,
-  tokenizerSource: QWEN2_5_TOKENIZER,
-  tokenizerConfigSource: QWEN2_5_TOKENIZER_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const QWEN2_5_1_5B_QUANTIZED = {
-  modelName: 'qwen2.5-1.5b-quantized',
-  modelSource: QWEN2_5_1_5B_QUANTIZED_MODEL,
-  tokenizerSource: QWEN2_5_TOKENIZER,
-  tokenizerConfigSource: QWEN2_5_TOKENIZER_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const QWEN2_5_3B = {
-  modelName: 'qwen2.5-3b',
-  modelSource: QWEN2_5_3B_MODEL,
-  tokenizerSource: QWEN2_5_TOKENIZER,
-  tokenizerConfigSource: QWEN2_5_TOKENIZER_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const QWEN2_5_3B_QUANTIZED = {
-  modelName: 'qwen2.5-3b-quantized',
-  modelSource: QWEN2_5_3B_QUANTIZED_MODEL,
-  tokenizerSource: QWEN2_5_TOKENIZER,
-  tokenizerConfigSource: QWEN2_5_TOKENIZER_CONFIG,
-} as const;
-
-// QWEN3.5-0.8B
-const QWEN3_5_0_8B_QUANTIZED_MODEL = `${URL_PREFIX}-qwen-3.5/${PREVIOUS_VERSION_TAG}/0_8b/xnnpack/qwen_3_5_0_8b_xnnpack_8da4w.pte`;
-const QWEN3_5_0_8B_TOKENIZER = `${URL_PREFIX}-qwen-3.5/${PREVIOUS_VERSION_TAG}/0_8b/tokenizer.json`;
-const QWEN3_5_0_8B_TOKENIZER_CONFIG = `${URL_PREFIX}-qwen-3.5/${PREVIOUS_VERSION_TAG}/0_8b/tokenizer_config.json`;
-
-/**
- * @category Models - LLM
- */
-export const QWEN3_5_0_8B_QUANTIZED = {
-  modelName: 'qwen3.5-0.8b-quantized',
-  modelSource: QWEN3_5_0_8B_QUANTIZED_MODEL,
-  tokenizerSource: QWEN3_5_0_8B_TOKENIZER,
-  tokenizerConfigSource: QWEN3_5_0_8B_TOKENIZER_CONFIG,
-} as const;
-
-// QWEN3.5-2B
-const QWEN3_5_2B_QUANTIZED_MODEL = `${URL_PREFIX}-qwen-3.5/${PREVIOUS_VERSION_TAG}/2b/xnnpack/qwen_3_5_2b_xnnpack_8da4w.pte`;
-const QWEN3_5_2B_TOKENIZER = `${URL_PREFIX}-qwen-3.5/${PREVIOUS_VERSION_TAG}/2b/tokenizer.json`;
-const QWEN3_5_2B_TOKENIZER_CONFIG = `${URL_PREFIX}-qwen-3.5/${PREVIOUS_VERSION_TAG}/2b/tokenizer_config.json`;
-
-/**
- * @category Models - LLM
- */
-export const QWEN3_5_2B_QUANTIZED = {
-  modelName: 'qwen3.5-2b-quantized',
-  modelSource: QWEN3_5_2B_QUANTIZED_MODEL,
-  tokenizerSource: QWEN3_5_2B_TOKENIZER,
-  tokenizerConfigSource: QWEN3_5_2B_TOKENIZER_CONFIG,
-} as const;
-
-// PHI 4
-const PHI_4_MINI_4B_MODEL = `${URL_PREFIX}-phi-4-mini/${PREVIOUS_VERSION_TAG}/xnnpack/phi_4_mini_xnnpack_bf16.pte`;
-const PHI_4_MINI_4B_QUANTIZED_MODEL = `${URL_PREFIX}-phi-4-mini/${PREVIOUS_VERSION_TAG}/xnnpack/phi_4_mini_xnnpack_8da4w.pte`;
-const PHI_4_MINI_TOKENIZER = `${URL_PREFIX}-phi-4-mini/${PREVIOUS_VERSION_TAG}/tokenizer.json`;
-const PHI_4_MINI_TOKENIZER_CONFIG = `${URL_PREFIX}-phi-4-mini/${PREVIOUS_VERSION_TAG}/tokenizer_config.json`;
-
-/**
- * @category Models - LLM
- */
-export const PHI_4_MINI_4B = {
-  modelName: 'phi-4-mini-4b',
-  modelSource: PHI_4_MINI_4B_MODEL,
-  tokenizerSource: PHI_4_MINI_TOKENIZER,
-  tokenizerConfigSource: PHI_4_MINI_TOKENIZER_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const PHI_4_MINI_4B_QUANTIZED = {
-  modelName: 'phi-4-mini-4b-quantized',
-  modelSource: PHI_4_MINI_4B_QUANTIZED_MODEL,
-  tokenizerSource: PHI_4_MINI_TOKENIZER,
-  tokenizerConfigSource: PHI_4_MINI_TOKENIZER_CONFIG,
-} as const;
-
-// LFM2.5-1.2B-Instruct
-const LFM2_5_1_2B_INSTRUCT_MODEL = `${URL_PREFIX}-lfm-2.5/${PREVIOUS_VERSION_TAG}/1_2b/xnnpack/lfm_2_5_1_2b_xnnpack_fp16.pte`;
-const LFM2_5_1_2B_INSTRUCT_QUANTIZED_MODEL = `${URL_PREFIX}-lfm-2.5/${PREVIOUS_VERSION_TAG}/1_2b/xnnpack/lfm_2_5_1_2b_xnnpack_8da4w.pte`;
-const LFM2_5_1_2B_TOKENIZER = `${URL_PREFIX}-lfm-2.5/${PREVIOUS_VERSION_TAG}/1_2b/tokenizer.json`;
-const LFM2_5_1_2B_TOKENIZER_CONFIG = `${URL_PREFIX}-lfm-2.5/${PREVIOUS_VERSION_TAG}/1_2b/tokenizer_config.json`;
-
-/**
- * @category Models - LLM
- */
-export const LFM2_5_1_2B_INSTRUCT = {
-  modelName: 'lfm2.5-1.2b-instruct',
-  modelSource: LFM2_5_1_2B_INSTRUCT_MODEL,
-  tokenizerSource: LFM2_5_1_2B_TOKENIZER,
-  tokenizerConfigSource: LFM2_5_1_2B_TOKENIZER_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const LFM2_5_1_2B_INSTRUCT_QUANTIZED = {
-  modelName: 'lfm2.5-1.2b-instruct-quantized',
-  modelSource: LFM2_5_1_2B_INSTRUCT_QUANTIZED_MODEL,
-  tokenizerSource: LFM2_5_1_2B_TOKENIZER,
-  tokenizerConfigSource: LFM2_5_1_2B_TOKENIZER_CONFIG,
-} as const;
-
-// LFM2.5-350M
-const LFM2_5_350M_MODEL = `${URL_PREFIX}-lfm-2.5/${PREVIOUS_VERSION_TAG}/350m/xnnpack/lfm_2_5_350m_xnnpack_fp16.pte`;
-const LFM2_5_350M_QUANTIZED_MODEL = `${URL_PREFIX}-lfm-2.5/${PREVIOUS_VERSION_TAG}/350m/xnnpack/lfm_2_5_350m_xnnpack_8da4w.pte`;
-const LFM2_5_350M_TOKENIZER = `${URL_PREFIX}-lfm-2.5/${PREVIOUS_VERSION_TAG}/350m/tokenizer.json`;
-const LFM2_5_350M_TOKENIZER_CONFIG = `${URL_PREFIX}-lfm-2.5/${PREVIOUS_VERSION_TAG}/350m/tokenizer_config.json`;
-
-/**
- * @category Models - LLM
- */
-export const LFM2_5_350M = {
-  modelName: 'lfm2.5-350m',
-  modelSource: LFM2_5_350M_MODEL,
-  tokenizerSource: LFM2_5_350M_TOKENIZER,
-  tokenizerConfigSource: LFM2_5_350M_TOKENIZER_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const LFM2_5_350M_QUANTIZED = {
-  modelName: 'lfm2.5-350m-quantized',
-  modelSource: LFM2_5_350M_QUANTIZED_MODEL,
-  tokenizerSource: LFM2_5_350M_TOKENIZER,
-  tokenizerConfigSource: LFM2_5_350M_TOKENIZER_CONFIG,
-} as const;
-
-// Bielik-v3.0
-const BIELIK_V3_0_1_5B_MODEL = `${URL_PREFIX}-bielik-v3.0/${PREVIOUS_VERSION_TAG}/xnnpack/bielik_v3_0_1_5b_xnnpack_fp16.pte`;
-const BIELIK_V3_0_1_5B_QUANTIZED_MODEL = `${URL_PREFIX}-bielik-v3.0/${PREVIOUS_VERSION_TAG}/xnnpack/bielik_v3_0_1_5b_xnnpack_8da4w.pte`;
-const BIELIK_V3_0_TOKENIZER = `${URL_PREFIX}-bielik-v3.0/${PREVIOUS_VERSION_TAG}/tokenizer.json`;
-const BIELIK_V3_0_TOKENIZER_CONFIG = `${URL_PREFIX}-bielik-v3.0/${PREVIOUS_VERSION_TAG}/tokenizer_config.json`;
-
-/**
- * @category Models - LLM
- */
-export const BIELIK_V3_0_1_5B = {
-  modelName: 'bielik-v3.0-1.5b',
-  modelSource: BIELIK_V3_0_1_5B_MODEL,
-  tokenizerSource: BIELIK_V3_0_TOKENIZER,
-  tokenizerConfigSource: BIELIK_V3_0_TOKENIZER_CONFIG,
-} as const;
-
-/**
- * @category Models - LLM
- */
-export const BIELIK_V3_0_1_5B_QUANTIZED = {
-  modelName: 'bielik-v3.0-1.5b-quantized',
-  modelSource: BIELIK_V3_0_1_5B_QUANTIZED_MODEL,
-  tokenizerSource: BIELIK_V3_0_TOKENIZER,
-  tokenizerConfigSource: BIELIK_V3_0_TOKENIZER_CONFIG,
-} as const;
-
-// LFM2.5-VL-1.6B
-const LFM2_VL_1_6B_QUANTIZED_MODEL = `${URL_PREFIX}-lfm-2.5/${PREVIOUS_VERSION_TAG}/vl_1_6b/xnnpack/lfm_2_5_vl_1_6b_xnnpack_8da4w.pte`;
-const LFM2_VL_1_6B_TOKENIZER = `${URL_PREFIX}-lfm-2.5/${PREVIOUS_VERSION_TAG}/vl_1_6b/tokenizer.json`;
-const LFM2_VL_1_6B_TOKENIZER_CONFIG = `${URL_PREFIX}-lfm-2.5/${PREVIOUS_VERSION_TAG}/vl_1_6b/tokenizer_config.json`;
-
-// LFM2.5-VL-450M
-const LFM2_VL_450M_QUANTIZED_MODEL = `${URL_PREFIX}-lfm-2.5/${PREVIOUS_VERSION_TAG}/vl_450m/xnnpack/lfm_2_5_vl_450m_xnnpack_8da4w.pte`;
-const LFM2_VL_450M_TOKENIZER = `${URL_PREFIX}-lfm-2.5/${PREVIOUS_VERSION_TAG}/vl_450m/tokenizer.json`;
-const LFM2_VL_450M_TOKENIZER_CONFIG = `${URL_PREFIX}-lfm-2.5/${PREVIOUS_VERSION_TAG}/vl_450m/tokenizer_config.json`;
-
-/**
- * @category Models - VLM
- */
-// LiquidAI's LFM2-VL model card recommends the following sampling settings.
-// Without them the model often produces generic / repetitive responses.
-const LFM2_5_VL_GENERATION_CONFIG = {
-  temperature: 0.1,
-  minP: 0.15,
-  repetitionPenalty: 1.05,
-} as const;
-
-/**
- * @category Models - VLM
- */
-export const LFM2_5_VL_1_6B_QUANTIZED = {
-  modelName: 'lfm2.5-vl-1.6b-quantized',
-  capabilities: ['vision'],
-  modelSource: LFM2_VL_1_6B_QUANTIZED_MODEL,
-  tokenizerSource: LFM2_VL_1_6B_TOKENIZER,
-  tokenizerConfigSource: LFM2_VL_1_6B_TOKENIZER_CONFIG,
-  generationConfig: LFM2_5_VL_GENERATION_CONFIG,
-} as const;
-
-/**
- * @category Models - VLM
- */
-export const LFM2_5_VL_450M_QUANTIZED = {
-  modelName: 'lfm2.5-vl-450m-quantized',
-  capabilities: ['vision'],
-  modelSource: LFM2_VL_450M_QUANTIZED_MODEL,
-  tokenizerSource: LFM2_VL_450M_TOKENIZER,
-  tokenizerConfigSource: LFM2_VL_450M_TOKENIZER_CONFIG,
-  generationConfig: LFM2_5_VL_GENERATION_CONFIG,
-} as const;
-
-/**
- * @deprecated Use `LFM2_5_VL_1_6B_QUANTIZED` instead — the model is from the
- * LFM2.5 family. This alias will be removed in a future major release.
- * @category Models - VLM
- */
-export const LFM2_VL_1_6B_QUANTIZED = LFM2_5_VL_1_6B_QUANTIZED;
-
-/**
- * @deprecated Use `LFM2_5_VL_450M_QUANTIZED` instead — the model is from the
- * LFM2.5 family. This alias will be removed in a future major release.
- * @category Models - VLM
- */
-export const LFM2_VL_450M_QUANTIZED = LFM2_5_VL_450M_QUANTIZED;
-
-// Classification
-export const EFFICIENTNET_V2_S_XNNPACK_FP32_MODEL = `${URL_PREFIX}-efficientnet-v2-s/${PREVIOUS_VERSION_TAG}/xnnpack/efficientnet_v2_s_xnnpack_fp32.pte`;
-export const EFFICIENTNET_V2_S_XNNPACK_INT8_MODEL = `${URL_PREFIX}-efficientnet-v2-s/${PREVIOUS_VERSION_TAG}/xnnpack/efficientnet_v2_s_xnnpack_int8.pte`;
-export const EFFICIENTNET_V2_S_COREML_FP32_MODEL = `${URL_PREFIX}-efficientnet-v2-s/${PREVIOUS_VERSION_TAG}/coreml/efficientnet_v2_s_coreml_fp32.pte`;
-export const EFFICIENTNET_V2_S_COREML_FP16_MODEL = `${URL_PREFIX}-efficientnet-v2-s/${PREVIOUS_VERSION_TAG}/coreml/efficientnet_v2_s_coreml_fp16.pte`;
-const EFFICIENTNET_V2_S_MODEL =
-  Platform.OS === `ios`
-    ? EFFICIENTNET_V2_S_COREML_FP32_MODEL
-    : EFFICIENTNET_V2_S_XNNPACK_FP32_MODEL;
-const EFFICIENTNET_V2_S_QUANTIZED_MODEL =
-  Platform.OS === `ios`
-    ? EFFICIENTNET_V2_S_COREML_FP16_MODEL
-    : EFFICIENTNET_V2_S_XNNPACK_INT8_MODEL;
-
-/**
- * @category Models - Classification
- */
-export const EFFICIENTNET_V2_S = {
-  modelName: 'efficientnet-v2-s',
-  modelSource: EFFICIENTNET_V2_S_MODEL,
-} as const;
-
-/**
- * @category Models - Classification
- */
-export const EFFICIENTNET_V2_S_QUANTIZED = {
-  modelName: 'efficientnet-v2-s-quantized',
-  modelSource: EFFICIENTNET_V2_S_QUANTIZED_MODEL,
-} as const;
-
-// Object detection
-export const SSDLITE_320_MOBILENET_V3_LARGE_XNNPACK_FP32_MODEL = `${URL_PREFIX}-ssdlite320-mobilenet-v3-large/${PREVIOUS_VERSION_TAG}/xnnpack/ssdlite320_mobilenet_v3_large_xnnpack_fp32.pte`;
-export const SSDLITE_320_MOBILENET_V3_LARGE_COREML_FP16_MODEL = `${URL_PREFIX}-ssdlite320-mobilenet-v3-large/${PREVIOUS_VERSION_TAG}/coreml/ssdlite320_mobilenet_v3_large_coreml_fp16.pte`;
-export const RF_DETR_NANO_XNNPACK_FP32_MODEL = `${URL_PREFIX}-rfdetr-nano-detector/${PREVIOUS_VERSION_TAG}/xnnpack/rfdetr_nano_xnnpack_fp32.pte`;
-export const RF_DETR_NANO_COREML_INT8_MODEL = `${URL_PREFIX}-rfdetr-nano-detector/${PREVIOUS_VERSION_TAG}/coreml/rfdetr_nano_coreml_int8.pte`;
-const SSDLITE_320_MOBILENET_V3_LARGE_MODEL =
-  Platform.OS === 'ios'
-    ? SSDLITE_320_MOBILENET_V3_LARGE_COREML_FP16_MODEL
-    : SSDLITE_320_MOBILENET_V3_LARGE_XNNPACK_FP32_MODEL;
-const RF_DETR_NANO_MODEL =
-  Platform.OS === 'ios'
-    ? RF_DETR_NANO_COREML_INT8_MODEL
-    : RF_DETR_NANO_XNNPACK_FP32_MODEL;
-
-/**
- * @category Models - Object Detection
- */
-export const SSDLITE_320_MOBILENET_V3_LARGE = {
-  modelName: 'ssdlite-320-mobilenet-v3-large',
-  modelSource: SSDLITE_320_MOBILENET_V3_LARGE_MODEL,
-} as const;
-
-/**
- * @category Models - Object Detection
- */
-export const RF_DETR_NANO = {
-  modelName: 'rf-detr-nano',
-  modelSource: RF_DETR_NANO_MODEL,
-} as const;
-
-// YOLO26 Object Detection
-const YOLO26N_DETECTION_MODEL = `${URL_PREFIX}-yolo26/${PREVIOUS_VERSION_TAG}/n/xnnpack/yolo26_n_xnnpack_fp32.pte`;
-const YOLO26S_DETECTION_MODEL = `${URL_PREFIX}-yolo26/${PREVIOUS_VERSION_TAG}/s/xnnpack/yolo26_s_xnnpack_fp32.pte`;
-const YOLO26M_DETECTION_MODEL = `${URL_PREFIX}-yolo26/${PREVIOUS_VERSION_TAG}/m/xnnpack/yolo26_m_xnnpack_fp32.pte`;
-const YOLO26L_DETECTION_MODEL = `${URL_PREFIX}-yolo26/${PREVIOUS_VERSION_TAG}/l/xnnpack/yolo26_l_xnnpack_fp32.pte`;
-const YOLO26X_DETECTION_MODEL = `${URL_PREFIX}-yolo26/${PREVIOUS_VERSION_TAG}/x/xnnpack/yolo26_x_xnnpack_fp32.pte`;
-
-/**
- * @category Models - Object Detection
- */
-export const YOLO26N = {
-  modelName: 'yolo26n',
-  modelSource: YOLO26N_DETECTION_MODEL,
-} as const;
-
-/**
- * @category Models - Object Detection
- */
-export const YOLO26S = {
-  modelName: 'yolo26s',
-  modelSource: YOLO26S_DETECTION_MODEL,
-} as const;
-
-/**
- * @category Models - Object Detection
- */
-export const YOLO26M = {
-  modelName: 'yolo26m',
-  modelSource: YOLO26M_DETECTION_MODEL,
-} as const;
-
-/**
- * @category Models - Object Detection
- */
-export const YOLO26L = {
-  modelName: 'yolo26l',
-  modelSource: YOLO26L_DETECTION_MODEL,
-} as const;
-
-/**
- * @category Models - Object Detection
- */
-export const YOLO26X = {
-  modelName: 'yolo26x',
-  modelSource: YOLO26X_DETECTION_MODEL,
-} as const;
-
-// YOLO26 Pose Estimation
-const YOLO26N_POSE_MODEL = `${URL_PREFIX}-yolo26-pose/${PREVIOUS_VERSION_TAG}/xnnpack/yolo26_pose_n_xnnpack_fp32.pte`;
-
-/**
- * @category Models - Pose Estimation
- */
-export const YOLO26N_POSE = {
-  modelName: 'yolo26n-pose',
-  modelSource: YOLO26N_POSE_MODEL,
-} as const;
-
-// Style transfer
-/**
- * Builds the four `(backend, precision)` URLs for a single style-transfer style.
- * @param display - HF repo suffix (e.g. `rain-princess`).
- * @param slug - .pte filename token (e.g. `rain_princess`). Differs from
- *   `display` for styles whose names contain spaces.
- * @returns Per-(backend, precision) URLs for the requested style.
- */
-export function styleTransferUrls<
-  const Display extends string,
-  const Slug extends string,
->(display: Display, slug: Slug) {
-  return {
-    xnnpackBase: `${URL_PREFIX}-style-transfer-${display}/${PREVIOUS_VERSION_TAG}/xnnpack/style_transfer_${slug}_xnnpack_fp32.pte`,
-    xnnpackQuant: `${URL_PREFIX}-style-transfer-${display}/${PREVIOUS_VERSION_TAG}/xnnpack/style_transfer_${slug}_xnnpack_int8.pte`,
-    coremlBase: `${URL_PREFIX}-style-transfer-${display}/${PREVIOUS_VERSION_TAG}/coreml/style_transfer_${slug}_coreml_fp32.pte`,
-    coremlQuant: `${URL_PREFIX}-style-transfer-${display}/${PREVIOUS_VERSION_TAG}/coreml/style_transfer_${slug}_coreml_fp16.pte`,
-  };
-}
-const STYLE_TRANSFER_CANDY_URLS = styleTransferUrls('candy', 'candy');
-const STYLE_TRANSFER_MOSAIC_URLS = styleTransferUrls('mosaic', 'mosaic');
-const STYLE_TRANSFER_RAIN_PRINCESS_URLS = styleTransferUrls(
-  'rain-princess',
-  'rain_princess'
-);
-const STYLE_TRANSFER_UDNIE_URLS = styleTransferUrls('udnie', 'udnie');
-const STYLE_TRANSFER_CANDY_MODEL =
-  Platform.OS === `ios`
-    ? STYLE_TRANSFER_CANDY_URLS.coremlBase
-    : STYLE_TRANSFER_CANDY_URLS.xnnpackBase;
-const STYLE_TRANSFER_CANDY_QUANTIZED_MODEL =
-  Platform.OS === `ios`
-    ? STYLE_TRANSFER_CANDY_URLS.coremlQuant
-    : STYLE_TRANSFER_CANDY_URLS.xnnpackQuant;
-const STYLE_TRANSFER_MOSAIC_MODEL =
-  Platform.OS === `ios`
-    ? STYLE_TRANSFER_MOSAIC_URLS.coremlBase
-    : STYLE_TRANSFER_MOSAIC_URLS.xnnpackBase;
-const STYLE_TRANSFER_MOSAIC_QUANTIZED_MODEL =
-  Platform.OS === `ios`
-    ? STYLE_TRANSFER_MOSAIC_URLS.coremlQuant
-    : STYLE_TRANSFER_MOSAIC_URLS.xnnpackQuant;
-const STYLE_TRANSFER_RAIN_PRINCESS_MODEL =
-  Platform.OS === `ios`
-    ? STYLE_TRANSFER_RAIN_PRINCESS_URLS.coremlBase
-    : STYLE_TRANSFER_RAIN_PRINCESS_URLS.xnnpackBase;
-const STYLE_TRANSFER_RAIN_PRINCESS_QUANTIZED_MODEL =
-  Platform.OS === `ios`
-    ? STYLE_TRANSFER_RAIN_PRINCESS_URLS.coremlQuant
-    : STYLE_TRANSFER_RAIN_PRINCESS_URLS.xnnpackQuant;
-const STYLE_TRANSFER_UDNIE_MODEL =
-  Platform.OS === `ios`
-    ? STYLE_TRANSFER_UDNIE_URLS.coremlBase
-    : STYLE_TRANSFER_UDNIE_URLS.xnnpackBase;
-const STYLE_TRANSFER_UDNIE_QUANTIZED_MODEL =
-  Platform.OS === `ios`
-    ? STYLE_TRANSFER_UDNIE_URLS.coremlQuant
-    : STYLE_TRANSFER_UDNIE_URLS.xnnpackQuant;
-
-/**
- * @category Models - Style Transfer
- */
-export const STYLE_TRANSFER_CANDY = {
-  modelName: 'style-transfer-candy',
-  modelSource: STYLE_TRANSFER_CANDY_MODEL,
-} as const;
-
-/**
- * @category Models - Style Transfer
- */
-export const STYLE_TRANSFER_CANDY_QUANTIZED = {
-  modelName: 'style-transfer-candy-quantized',
-  modelSource: STYLE_TRANSFER_CANDY_QUANTIZED_MODEL,
-} as const;
-
-/**
- * @category Models - Style Transfer
- */
-export const STYLE_TRANSFER_MOSAIC = {
-  modelName: 'style-transfer-mosaic',
-  modelSource: STYLE_TRANSFER_MOSAIC_MODEL,
-} as const;
-
-/**
- * @category Models - Style Transfer
- */
-export const STYLE_TRANSFER_MOSAIC_QUANTIZED = {
-  modelName: 'style-transfer-mosaic-quantized',
-  modelSource: STYLE_TRANSFER_MOSAIC_QUANTIZED_MODEL,
-} as const;
-
-/**
- * @category Models - Style Transfer
- */
-export const STYLE_TRANSFER_RAIN_PRINCESS = {
-  modelName: 'style-transfer-rain-princess',
-  modelSource: STYLE_TRANSFER_RAIN_PRINCESS_MODEL,
-} as const;
-
-/**
- * @category Models - Style Transfer
- */
-export const STYLE_TRANSFER_RAIN_PRINCESS_QUANTIZED = {
-  modelName: 'style-transfer-rain-princess-quantized',
-  modelSource: STYLE_TRANSFER_RAIN_PRINCESS_QUANTIZED_MODEL,
-} as const;
-
-/**
- * @category Models - Style Transfer
- */
-export const STYLE_TRANSFER_UDNIE = {
-  modelName: 'style-transfer-udnie',
-  modelSource: STYLE_TRANSFER_UDNIE_MODEL,
-} as const;
-
-/**
- * @category Models - Style Transfer
- */
-export const STYLE_TRANSFER_UDNIE_QUANTIZED = {
-  modelName: 'style-transfer-udnie-quantized',
-  modelSource: STYLE_TRANSFER_UDNIE_QUANTIZED_MODEL,
-} as const;
-
-// S2T
-export const WHISPER_TINY_EN_TOKENIZER = `${URL_PREFIX}-whisper-tiny.en/${VERSION_TAG}/tokenizer.json`;
-export const WHISPER_TINY_EN_MODEL_XNNPACK = `${URL_PREFIX}-whisper-tiny.en/${VERSION_TAG}/xnnpack/whisper_tiny_en_xnnpack_fp32.pte`;
-export const WHISPER_TINY_EN_MODEL_COREML = `${URL_PREFIX}-whisper-tiny.en/${VERSION_TAG}/coreml/whisper_tiny_en_coreml_fp16.pte`;
-
-export const WHISPER_BASE_EN_TOKENIZER = `${URL_PREFIX}-whisper-base.en/${VERSION_TAG}/tokenizer.json`;
-export const WHISPER_BASE_EN_MODEL_XNNPACK = `${URL_PREFIX}-whisper-base.en/${VERSION_TAG}/xnnpack/whisper_base_en_xnnpack_fp32.pte`;
-export const WHISPER_BASE_EN_MODEL_COREML = `${URL_PREFIX}-whisper-base.en/${VERSION_TAG}/coreml/whisper_base_en_coreml_fp16.pte`;
-
-export const WHISPER_SMALL_EN_TOKENIZER = `${URL_PREFIX}-whisper-small.en/${VERSION_TAG}/tokenizer.json`;
-export const WHISPER_SMALL_EN_MODEL_XNNPACK = `${URL_PREFIX}-whisper-small.en/${VERSION_TAG}/xnnpack/whisper_small_en_xnnpack_fp32.pte`;
-export const WHISPER_SMALL_EN_MODEL_COREML = `${URL_PREFIX}-whisper-small.en/${VERSION_TAG}/coreml/whisper_small_en_coreml_fp16.pte`;
-
-export const WHISPER_TINY_TOKENIZER = `${URL_PREFIX}-whisper-tiny/${VERSION_TAG}/tokenizer.json`;
-export const WHISPER_TINY_MODEL_XNNPACK = `${URL_PREFIX}-whisper-tiny/${VERSION_TAG}/xnnpack/whisper_tiny_xnnpack_fp32.pte`;
-export const WHISPER_TINY_MODEL_COREML = `${URL_PREFIX}-whisper-tiny/${VERSION_TAG}/coreml/whisper_tiny_coreml_fp16.pte`;
-
-export const WHISPER_BASE_TOKENIZER = `${URL_PREFIX}-whisper-base/${VERSION_TAG}/tokenizer.json`;
-export const WHISPER_BASE_MODEL_XNNPACK = `${URL_PREFIX}-whisper-base/${VERSION_TAG}/xnnpack/whisper_base_xnnpack_fp32.pte`;
-export const WHISPER_BASE_MODEL_COREML = `${URL_PREFIX}-whisper-base/${VERSION_TAG}/coreml/whisper_base_coreml_fp16.pte`;
-
-export const WHISPER_SMALL_TOKENIZER = `${URL_PREFIX}-whisper-small/${VERSION_TAG}/tokenizer.json`;
-export const WHISPER_SMALL_MODEL_XNNPACK = `${URL_PREFIX}-whisper-small/${VERSION_TAG}/xnnpack/whisper_small_xnnpack_fp32.pte`;
-export const WHISPER_SMALL_MODEL_COREML = `${URL_PREFIX}-whisper-small/${VERSION_TAG}/coreml/whisper_small_coreml_fp16.pte`;
-
-/**
- * @category Models - Speech To Text
- */
-export const WHISPER_TINY_EN = {
-  modelName: 'whisper-tiny-en',
-  isMultilingual: false,
-  modelSource:
-    Platform.OS === 'ios'
-      ? WHISPER_TINY_EN_MODEL_COREML
-      : WHISPER_TINY_EN_MODEL_XNNPACK,
-  tokenizerSource: WHISPER_TINY_EN_TOKENIZER,
-} as const;
-
-/**
- * @category Models - Speech To Text
- */
-export const WHISPER_BASE_EN = {
-  modelName: 'whisper-base-en',
-  isMultilingual: false,
-  modelSource:
-    Platform.OS === 'ios'
-      ? WHISPER_BASE_EN_MODEL_COREML
-      : WHISPER_BASE_EN_MODEL_XNNPACK,
-  tokenizerSource: WHISPER_BASE_EN_TOKENIZER,
-} as const;
-
-/**
- * @category Models - Speech To Text
- */
-export const WHISPER_SMALL_EN = {
-  modelName: 'whisper-small-en',
-  isMultilingual: false,
-  modelSource:
-    Platform.OS === 'ios'
-      ? WHISPER_SMALL_EN_MODEL_COREML
-      : WHISPER_SMALL_EN_MODEL_XNNPACK,
-  tokenizerSource: WHISPER_SMALL_EN_TOKENIZER,
-} as const;
-
-/**
- * @category Models - Speech To Text
- */
-export const WHISPER_TINY = {
-  modelName: 'whisper-tiny',
-  isMultilingual: true,
-  modelSource:
-    Platform.OS === 'ios'
-      ? WHISPER_TINY_MODEL_COREML
-      : WHISPER_TINY_MODEL_XNNPACK,
-  tokenizerSource: WHISPER_TINY_TOKENIZER,
-} as const;
-
-/**
- * @category Models - Speech To Text
- */
-export const WHISPER_BASE = {
-  modelName: 'whisper-base',
-  isMultilingual: true,
-  modelSource:
-    Platform.OS === 'ios'
-      ? WHISPER_BASE_MODEL_COREML
-      : WHISPER_BASE_MODEL_XNNPACK,
-  tokenizerSource: WHISPER_BASE_TOKENIZER,
-} as const;
-
-/**
- * @category Models - Speech To Text
- */
-export const WHISPER_SMALL = {
-  modelName: 'whisper-small',
-  isMultilingual: true,
-  modelSource:
-    Platform.OS === 'ios'
-      ? WHISPER_SMALL_MODEL_COREML
-      : WHISPER_SMALL_MODEL_XNNPACK,
-  tokenizerSource: WHISPER_SMALL_TOKENIZER,
-} as const;
-
-// Semantic Segmentation
-const DEEPLAB_V3_RESNET50_MODEL = `${URL_PREFIX}-deeplab-v3/${PREVIOUS_VERSION_TAG}/xnnpack/deeplab_v3_resnet50_xnnpack_fp32.pte`;
-const DEEPLAB_V3_RESNET101_MODEL = `${URL_PREFIX}-deeplab-v3/${PREVIOUS_VERSION_TAG}/xnnpack/deeplab_v3_resnet101_xnnpack_fp32.pte`;
-const DEEPLAB_V3_MOBILENET_V3_LARGE_MODEL = `${URL_PREFIX}-deeplab-v3/${PREVIOUS_VERSION_TAG}/xnnpack/deeplab_v3_mobilenet_v3_large_xnnpack_fp32.pte`;
-const LRASPP_MOBILENET_V3_LARGE_MODEL = `${URL_PREFIX}-lraspp/${PREVIOUS_VERSION_TAG}/xnnpack/lraspp_mobilenet_v3_large_xnnpack_fp32.pte`;
-const FCN_RESNET50_MODEL = `${URL_PREFIX}-fcn/${PREVIOUS_VERSION_TAG}/xnnpack/fcn_resnet50_xnnpack_fp32.pte`;
-const FCN_RESNET101_MODEL = `${URL_PREFIX}-fcn/${PREVIOUS_VERSION_TAG}/xnnpack/fcn_resnet101_xnnpack_fp32.pte`;
-const DEEPLAB_V3_RESNET50_QUANTIZED_MODEL = `${URL_PREFIX}-deeplab-v3/${PREVIOUS_VERSION_TAG}/xnnpack/deeplab_v3_resnet50_xnnpack_int8.pte`;
-const DEEPLAB_V3_RESNET101_QUANTIZED_MODEL = `${URL_PREFIX}-deeplab-v3/${PREVIOUS_VERSION_TAG}/xnnpack/deeplab_v3_resnet101_xnnpack_int8.pte`;
-const DEEPLAB_V3_MOBILENET_V3_LARGE_QUANTIZED_MODEL = `${URL_PREFIX}-deeplab-v3/${PREVIOUS_VERSION_TAG}/xnnpack/deeplab_v3_mobilenet_v3_large_xnnpack_int8.pte`;
-const LRASPP_MOBILENET_V3_LARGE_QUANTIZED_MODEL = `${URL_PREFIX}-lraspp/${PREVIOUS_VERSION_TAG}/xnnpack/lraspp_mobilenet_v3_large_xnnpack_int8.pte`;
-const FCN_RESNET50_QUANTIZED_MODEL = `${URL_PREFIX}-fcn/${PREVIOUS_VERSION_TAG}/xnnpack/fcn_resnet50_xnnpack_int8.pte`;
-const FCN_RESNET101_QUANTIZED_MODEL = `${URL_PREFIX}-fcn/${PREVIOUS_VERSION_TAG}/xnnpack/fcn_resnet101_xnnpack_int8.pte`;
-
-/**
- * @category Models - Semantic Segmentation
- */
-export const DEEPLAB_V3_RESNET50 = {
-  modelName: 'deeplab-v3-resnet50',
-  modelSource: DEEPLAB_V3_RESNET50_MODEL,
-} as const;
-
-/**
- * @category Models - Semantic Segmentation
- */
-export const DEEPLAB_V3_RESNET101 = {
-  modelName: 'deeplab-v3-resnet101',
-  modelSource: DEEPLAB_V3_RESNET101_MODEL,
-} as const;
-
-/**
- * @category Models - Semantic Segmentation
- */
-export const DEEPLAB_V3_MOBILENET_V3_LARGE = {
-  modelName: 'deeplab-v3-mobilenet-v3-large',
-  modelSource: DEEPLAB_V3_MOBILENET_V3_LARGE_MODEL,
-} as const;
-
-/**
- * @category Models - Semantic Segmentation
- */
-export const LRASPP_MOBILENET_V3_LARGE = {
-  modelName: 'lraspp-mobilenet-v3-large',
-  modelSource: LRASPP_MOBILENET_V3_LARGE_MODEL,
-} as const;
-
-/**
- * @category Models - Semantic Segmentation
- */
-export const FCN_RESNET50 = {
-  modelName: 'fcn-resnet50',
-  modelSource: FCN_RESNET50_MODEL,
-} as const;
-
-/**
- * @category Models - Semantic Segmentation
- */
-export const FCN_RESNET101 = {
-  modelName: 'fcn-resnet101',
-  modelSource: FCN_RESNET101_MODEL,
-} as const;
-
-/**
- * @category Models - Semantic Segmentation
- */
-export const DEEPLAB_V3_RESNET50_QUANTIZED = {
-  modelName: 'deeplab-v3-resnet50-quantized',
-  modelSource: DEEPLAB_V3_RESNET50_QUANTIZED_MODEL,
-} as const;
-
-/**
- * @category Models - Semantic Segmentation
- */
-export const DEEPLAB_V3_RESNET101_QUANTIZED = {
-  modelName: 'deeplab-v3-resnet101-quantized',
-  modelSource: DEEPLAB_V3_RESNET101_QUANTIZED_MODEL,
-} as const;
-
-/**
- * @category Models - Semantic Segmentation
- */
-export const DEEPLAB_V3_MOBILENET_V3_LARGE_QUANTIZED = {
-  modelName: 'deeplab-v3-mobilenet-v3-large-quantized',
-  modelSource: DEEPLAB_V3_MOBILENET_V3_LARGE_QUANTIZED_MODEL,
-} as const;
-
-/**
- * @category Models - Semantic Segmentation
- */
-export const LRASPP_MOBILENET_V3_LARGE_QUANTIZED = {
-  modelName: 'lraspp-mobilenet-v3-large-quantized',
-  modelSource: LRASPP_MOBILENET_V3_LARGE_QUANTIZED_MODEL,
-} as const;
-
-/**
- * @category Models - Semantic Segmentation
- */
-export const FCN_RESNET50_QUANTIZED = {
-  modelName: 'fcn-resnet50-quantized',
-  modelSource: FCN_RESNET50_QUANTIZED_MODEL,
-} as const;
-
-/**
- * @category Models - Semantic Segmentation
- */
-export const FCN_RESNET101_QUANTIZED = {
-  modelName: 'fcn-resnet101-quantized',
-  modelSource: FCN_RESNET101_QUANTIZED_MODEL,
-} as const;
-
-const SELFIE_SEGMENTATION_MODEL = `${URL_PREFIX}-selfie-segmentation/${PREVIOUS_VERSION_TAG}/xnnpack/selfie_segmentation_xnnpack_fp32.pte`;
-
-/**
- * @category Models - Semantic Segmentation
- */
-export const SELFIE_SEGMENTATION = {
-  modelName: 'selfie-segmentation',
-  modelSource: SELFIE_SEGMENTATION_MODEL,
-} as const;
-
-// FastSAM Instance Segmentation
-export const FASTSAM_S_XNNPACK_FP32_MODEL = `${URL_PREFIX}-fast-sam/${PREVIOUS_VERSION_TAG}/s/xnnpack/fast_sam_s_xnnpack_fp32.pte`;
-export const FASTSAM_S_COREML_FP16_MODEL = `${URL_PREFIX}-fast-sam/${PREVIOUS_VERSION_TAG}/s/coreml/fast_sam_s_coreml_fp16.pte`;
-export const FASTSAM_X_XNNPACK_FP32_MODEL = `${URL_PREFIX}-fast-sam/${PREVIOUS_VERSION_TAG}/x/xnnpack/fast_sam_x_xnnpack_fp32.pte`;
-export const FASTSAM_X_COREML_FP16_MODEL = `${URL_PREFIX}-fast-sam/${PREVIOUS_VERSION_TAG}/x/coreml/fast_sam_x_coreml_fp16.pte`;
-const FASTSAM_S_SEG_MODEL =
-  Platform.OS === 'ios'
-    ? FASTSAM_S_COREML_FP16_MODEL
-    : FASTSAM_S_XNNPACK_FP32_MODEL;
-const FASTSAM_X_SEG_MODEL =
-  Platform.OS === 'ios'
-    ? FASTSAM_X_COREML_FP16_MODEL
-    : FASTSAM_X_XNNPACK_FP32_MODEL;
-
-/**
- * @category Models - Instance Segmentation
- */
-export const FASTSAM_S = {
-  modelName: 'fastsam-s',
-  modelSource: FASTSAM_S_SEG_MODEL,
-} as const;
-
-/**
- * @category Models - Instance Segmentation
- */
-export const FASTSAM_X = {
-  modelName: 'fastsam-x',
-  modelSource: FASTSAM_X_SEG_MODEL,
-} as const;
-
-/**
- * @category Models - Instance Segmentation
- */
-const YOLO26N_SEG_MODEL = `${URL_PREFIX}-yolo26-seg/${PREVIOUS_VERSION_TAG}/n/xnnpack/yolo26_seg_n_xnnpack_fp32.pte`;
-const YOLO26S_SEG_MODEL = `${URL_PREFIX}-yolo26-seg/${PREVIOUS_VERSION_TAG}/s/xnnpack/yolo26_seg_s_xnnpack_fp32.pte`;
-const YOLO26M_SEG_MODEL = `${URL_PREFIX}-yolo26-seg/${PREVIOUS_VERSION_TAG}/m/xnnpack/yolo26_seg_m_xnnpack_fp32.pte`;
-const YOLO26L_SEG_MODEL = `${URL_PREFIX}-yolo26-seg/${PREVIOUS_VERSION_TAG}/l/xnnpack/yolo26_seg_l_xnnpack_fp32.pte`;
-const YOLO26X_SEG_MODEL = `${URL_PREFIX}-yolo26-seg/${PREVIOUS_VERSION_TAG}/x/xnnpack/yolo26_seg_x_xnnpack_fp32.pte`;
-export const RF_DETR_NANO_SEG_XNNPACK_FP32_MODEL = `${URL_PREFIX}-rfdetr-nano-segmentation/${PREVIOUS_VERSION_TAG}/xnnpack/rfdetr_nano_xnnpack_fp32.pte`;
-export const RF_DETR_NANO_SEG_COREML_INT8_MODEL = `${URL_PREFIX}-rfdetr-nano-segmentation/${PREVIOUS_VERSION_TAG}/coreml/rfdetr_nano_coreml_int8.pte`;
-const RF_DETR_NANO_SEG_MODEL =
-  Platform.OS === 'ios'
-    ? RF_DETR_NANO_SEG_COREML_INT8_MODEL
-    : RF_DETR_NANO_SEG_XNNPACK_FP32_MODEL;
-/**
- * @category Models - Instance Segmentation
- */
-export const YOLO26N_SEG = {
-  modelName: 'yolo26n-seg',
-  modelSource: YOLO26N_SEG_MODEL,
-} as const;
-
-/**
- * @category Models - Instance Segmentation
- */
-export const YOLO26S_SEG = {
-  modelName: 'yolo26s-seg',
-  modelSource: YOLO26S_SEG_MODEL,
-} as const;
-
-/**
- * @category Models - Instance Segmentation
- */
-export const YOLO26M_SEG = {
-  modelName: 'yolo26m-seg',
-  modelSource: YOLO26M_SEG_MODEL,
-} as const;
-
-/**
- * @category Models - Instance Segmentation
- */
-export const YOLO26L_SEG = {
-  modelName: 'yolo26l-seg',
-  modelSource: YOLO26L_SEG_MODEL,
-} as const;
-
-/**
- * @category Models - Instance Segmentation
- */
-export const YOLO26X_SEG = {
-  modelName: 'yolo26x-seg',
-  modelSource: YOLO26X_SEG_MODEL,
-} as const;
-
-/**
- * @category Models - Instance Segmentation
- */
-export const RF_DETR_NANO_SEG = {
-  modelName: 'rfdetr-nano-seg',
-  modelSource: RF_DETR_NANO_SEG_MODEL,
-} as const;
-
-// Image Embeddings
-const CLIP_VIT_BASE_PATCH32_IMAGE_MODEL = `${URL_PREFIX}-clip-vit-base-patch32/${PREVIOUS_VERSION_TAG}/xnnpack/clip_vit_base_patch32_image_xnnpack_fp32.pte`;
-const CLIP_VIT_BASE_PATCH32_IMAGE_QUANTIZED_MODEL = `${URL_PREFIX}-clip-vit-base-patch32/${PREVIOUS_VERSION_TAG}/xnnpack/clip_vit_base_patch32_image_xnnpack_int8.pte`;
-
-/**
- * @category Models - Image Embeddings
- */
-export const CLIP_VIT_BASE_PATCH32_IMAGE = {
-  modelName: 'clip-vit-base-patch32-image',
-  modelSource: CLIP_VIT_BASE_PATCH32_IMAGE_MODEL,
-} as const;
-
-/**
- * @category Models - Image Embeddings
- */
-export const CLIP_VIT_BASE_PATCH32_IMAGE_QUANTIZED = {
-  modelName: 'clip-vit-base-patch32-image-quantized',
-  modelSource: CLIP_VIT_BASE_PATCH32_IMAGE_QUANTIZED_MODEL,
-} as const;
-
-// Text Embeddings
-const ALL_MINILM_L6_V2_MODEL = `${URL_PREFIX}-all-MiniLM-L6-v2/${PREVIOUS_VERSION_TAG}/xnnpack/all_minilm_l6_v2_xnnpack_fp32.pte`;
-const ALL_MINILM_L6_V2_TOKENIZER = `${URL_PREFIX}-all-MiniLM-L6-v2/${PREVIOUS_VERSION_TAG}/tokenizer.json`;
-const ALL_MPNET_BASE_V2_MODEL = `${URL_PREFIX}-all-mpnet-base-v2/${PREVIOUS_VERSION_TAG}/xnnpack/all_mpnet_base_v2_xnnpack_fp32.pte`;
-const ALL_MPNET_BASE_V2_TOKENIZER = `${URL_PREFIX}-all-mpnet-base-v2/${PREVIOUS_VERSION_TAG}/tokenizer.json`;
-const MULTI_QA_MINILM_L6_COS_V1_MODEL = `${URL_PREFIX}-multi-qa-MiniLM-L6-cos-v1/${PREVIOUS_VERSION_TAG}/xnnpack/multi_qa_minilm_l6_cos_v1_xnnpack_fp32.pte`;
-const MULTI_QA_MINILM_L6_COS_V1_TOKENIZER = `${URL_PREFIX}-multi-qa-MiniLM-L6-cos-v1/${PREVIOUS_VERSION_TAG}/tokenizer.json`;
-const MULTI_QA_MPNET_BASE_DOT_V1_MODEL = `${URL_PREFIX}-multi-qa-mpnet-base-dot-v1/${PREVIOUS_VERSION_TAG}/xnnpack/multi_qa_mpnet_base_dot_v1_xnnpack_fp32.pte`;
-const MULTI_QA_MPNET_BASE_DOT_V1_TOKENIZER = `${URL_PREFIX}-multi-qa-mpnet-base-dot-v1/${PREVIOUS_VERSION_TAG}/tokenizer.json`;
-export const DISTILUSE_BASE_MULTILINGUAL_CASED_V2_8DA4W_MODEL = `${URL_PREFIX}-distiluse-base-multilingual-cased-v2/${PREVIOUS_VERSION_TAG}/xnnpack/distiluse_base_multilingual_cased_v2_xnnpack_8da4w.pte`;
-export const DISTILUSE_BASE_MULTILINGUAL_CASED_V2_TOKENIZER = `${URL_PREFIX}-distiluse-base-multilingual-cased-v2/${PREVIOUS_VERSION_TAG}/tokenizer.json`;
-const PARAPHRASE_MULTILINGUAL_MINILM_L12_V2_QUANTIZED_MODEL = `${URL_PREFIX}-paraphrase-multilingual-MiniLM-L12-v2/${PREVIOUS_VERSION_TAG}/xnnpack/paraphrase_multilingual_minilm_l12_v2_xnnpack_8da4w.pte`;
-const PARAPHRASE_MULTILINGUAL_MINILM_L12_V2_TOKENIZER = `${URL_PREFIX}-paraphrase-multilingual-MiniLM-L12-v2/${PREVIOUS_VERSION_TAG}/tokenizer.json`;
-const CLIP_VIT_BASE_PATCH32_TEXT_MODEL = `${URL_PREFIX}-clip-vit-base-patch32/${PREVIOUS_VERSION_TAG}/xnnpack/clip_vit_base_patch32_text_xnnpack_fp32.pte`;
-const CLIP_VIT_BASE_PATCH32_TEXT_TOKENIZER = `${URL_PREFIX}-clip-vit-base-patch32/${PREVIOUS_VERSION_TAG}/tokenizer.json`;
-
-/**
- * @category Models - Text Embeddings
- */
-export const ALL_MINILM_L6_V2 = {
-  modelName: 'all-minilm-l6-v2',
-  modelSource: ALL_MINILM_L6_V2_MODEL,
-  tokenizerSource: ALL_MINILM_L6_V2_TOKENIZER,
-} as const;
-
-/**
- * @category Models - Text Embeddings
- */
-export const ALL_MPNET_BASE_V2 = {
-  modelName: 'all-mpnet-base-v2',
-  modelSource: ALL_MPNET_BASE_V2_MODEL,
-  tokenizerSource: ALL_MPNET_BASE_V2_TOKENIZER,
-} as const;
-
-/**
- * @category Models - Text Embeddings
- */
-export const MULTI_QA_MINILM_L6_COS_V1 = {
-  modelName: 'multi-qa-minilm-l6-cos-v1',
-  modelSource: MULTI_QA_MINILM_L6_COS_V1_MODEL,
-  tokenizerSource: MULTI_QA_MINILM_L6_COS_V1_TOKENIZER,
-} as const;
-
-/**
- * @category Models - Text Embeddings
- */
-export const MULTI_QA_MPNET_BASE_DOT_V1 = {
-  modelName: 'multi-qa-mpnet-base-dot-v1',
-  modelSource: MULTI_QA_MPNET_BASE_DOT_V1_MODEL,
-  tokenizerSource: MULTI_QA_MPNET_BASE_DOT_V1_TOKENIZER,
-} as const;
-
-/**
- * @category Models - Text Embeddings
- * @deprecated Use `models.text_embedding.distiluse_base_multilingual_cased_v2()`.
- */
-export const DISTILUSE_BASE_MULTILINGUAL_CASED_V2_8DA4W = {
-  modelName: 'distiluse-base-multilingual-cased-v2-8da4w',
-  modelSource: DISTILUSE_BASE_MULTILINGUAL_CASED_V2_8DA4W_MODEL,
-  tokenizerSource: DISTILUSE_BASE_MULTILINGUAL_CASED_V2_TOKENIZER,
-} as const;
-
-/**
- * @category Models - Text Embeddings
- */
-export const PARAPHRASE_MULTILINGUAL_MINILM_L12_V2_QUANTIZED = {
-  modelName: 'paraphrase-multilingual-minilm-l12-v2-quantized',
-  modelSource: PARAPHRASE_MULTILINGUAL_MINILM_L12_V2_QUANTIZED_MODEL,
-  tokenizerSource: PARAPHRASE_MULTILINGUAL_MINILM_L12_V2_TOKENIZER,
-} as const;
-
-/**
- * @category Models - Text Embeddings
- */
-export const CLIP_VIT_BASE_PATCH32_TEXT = {
-  modelName: 'clip-vit-base-patch32-text',
-  modelSource: CLIP_VIT_BASE_PATCH32_TEXT_MODEL,
-  tokenizerSource: CLIP_VIT_BASE_PATCH32_TEXT_TOKENIZER,
-} as const;
-
-// Privacy Filter (PII detection)
-//
-// Both supported variants share the same architecture (8-layer MoE,
-// 128-token banded attention) and tokenizer (o200k, pad/eos id 199999).
-// They differ only in the BIOES label space; the runner expects the
-// matching `labelNames` array to be passed at load time.
-
-/**
- * openai/privacy-filter — base PII detector with 8 entity types
- * (account_number, private_address, private_date, private_email,
- * private_person, private_phone, private_url, secret).
- * @category Models - Privacy Filter
- */
-export const PRIVACY_FILTER_OPENAI = {
-  modelName: 'privacy-filter-openai',
-  modelSource: `${URL_PREFIX}-privacy-filter-openai/${PREVIOUS_VERSION_TAG}/xnnpack/privacy_filter_openai_xnnpack_8da4w.pte`,
-  tokenizerSource: `${URL_PREFIX}-privacy-filter-openai/${PREVIOUS_VERSION_TAG}/tokenizer.json`,
-} as const;
-
-/**
- * OpenMed/privacy-filter-nemotron — extended PII detector with 55 entity
- * types (adds medical, financial, identity, technical, demographic, etc.).
- * Same base architecture as the OpenAI model, larger label space.
- * @category Models - Privacy Filter
- */
-export const PRIVACY_FILTER_NEMOTRON = {
-  modelName: 'privacy-filter-nemotron',
-  modelSource: `${URL_PREFIX}-privacy-filter-nemotron/${PREVIOUS_VERSION_TAG}/xnnpack/privacy_filter_nemotron_xnnpack_8da4w.pte`,
-  tokenizerSource: `${URL_PREFIX}-privacy-filter-nemotron/${PREVIOUS_VERSION_TAG}/tokenizer.json`,
-} as const;
-
-// Image generation
-
-/**
- * @category Models - Image Generation
- */
-export const BK_SDM_TINY_VPRED_512 = {
-  modelName: 'bk-sdm-tiny-vpred-512',
-  schedulerSource: `${URL_PREFIX}-bk-sdm-tiny/${PREVIOUS_VERSION_TAG}/scheduler/scheduler_config.json`,
-  tokenizerSource: `${URL_PREFIX}-bk-sdm-tiny/${PREVIOUS_VERSION_TAG}/tokenizer/tokenizer.json`,
-  encoderSource: `${URL_PREFIX}-bk-sdm-tiny/${PREVIOUS_VERSION_TAG}/xnnpack/bk_sdm_tiny_text_encoder_xnnpack_fp32.pte`,
-  unetSource: `${URL_PREFIX}-bk-sdm-tiny/${PREVIOUS_VERSION_TAG}/xnnpack/bk_sdm_tiny_unet_xnnpack_fp32.pte`,
-  decoderSource: `${URL_PREFIX}-bk-sdm-tiny/${PREVIOUS_VERSION_TAG}/xnnpack/bk_sdm_tiny_vae_xnnpack_fp32.pte`,
-} as const;
-
-/**
- * @category Models - Image Generation
- */
-export const BK_SDM_TINY_VPRED_256 = {
-  modelName: 'bk-sdm-tiny-vpred-256',
-  schedulerSource: `${URL_PREFIX}-bk-sdm-tiny/${PREVIOUS_VERSION_TAG}/scheduler/scheduler_config.json`,
-  tokenizerSource: `${URL_PREFIX}-bk-sdm-tiny/${PREVIOUS_VERSION_TAG}/tokenizer/tokenizer.json`,
-  encoderSource: `${URL_PREFIX}-bk-sdm-tiny/${PREVIOUS_VERSION_TAG}/xnnpack/bk_sdm_tiny_text_encoder_xnnpack_fp32.pte`,
-  unetSource: `${URL_PREFIX}-bk-sdm-tiny/${PREVIOUS_VERSION_TAG}/xnnpack/bk_sdm_tiny_unet_256_xnnpack_fp32.pte`,
-  decoderSource: `${URL_PREFIX}-bk-sdm-tiny/${PREVIOUS_VERSION_TAG}/xnnpack/bk_sdm_tiny_vae_256_xnnpack_fp32.pte`,
-} as const;
-
-// Voice Activity Detection
-const FSMN_VAD_MODEL = `${URL_PREFIX}-fsmn-vad/${PREVIOUS_VERSION_TAG}/xnnpack/fsmn_vad_xnnpack_fp32.pte`;
-
-/**
- * @category Models - Voice Activity Detection
- */
-export const FSMN_VAD = {
-  modelName: 'fsmn-vad',
-  modelSource: FSMN_VAD_MODEL,
-} as const;
-
-// Internal — populates the urlToModelName lookup below. Not exported: the
-// typed grouping lives in `./modelRegistry` as `models`.
-const _ALL_MODELS = [
-  LLAMA3_2_3B,
-  LLAMA3_2_3B_QLORA,
-  LLAMA3_2_3B_SPINQUANT,
-  LLAMA3_2_1B,
-  LLAMA3_2_1B_QLORA,
-  LLAMA3_2_1B_SPINQUANT,
-  QWEN3_0_6B,
-  QWEN3_0_6B_QUANTIZED,
-  QWEN3_1_7B,
-  QWEN3_1_7B_QUANTIZED,
-  QWEN3_4B,
-  QWEN3_4B_QUANTIZED,
-  QWEN3_5_0_8B_QUANTIZED,
-  QWEN3_5_2B_QUANTIZED,
-  HAMMER2_1_0_5B,
-  HAMMER2_1_0_5B_QUANTIZED,
-  HAMMER2_1_1_5B,
-  HAMMER2_1_1_5B_QUANTIZED,
-  HAMMER2_1_3B,
-  HAMMER2_1_3B_QUANTIZED,
-  SMOLLM2_1_135M,
-  SMOLLM2_1_135M_QUANTIZED,
-  SMOLLM2_1_360M,
-  SMOLLM2_1_360M_QUANTIZED,
-  SMOLLM2_1_1_7B,
-  SMOLLM2_1_1_7B_QUANTIZED,
-  QWEN2_5_0_5B,
-  QWEN2_5_0_5B_QUANTIZED,
-  QWEN2_5_1_5B,
-  QWEN2_5_1_5B_QUANTIZED,
-  QWEN2_5_3B,
-  QWEN2_5_3B_QUANTIZED,
-  PHI_4_MINI_4B,
-  PHI_4_MINI_4B_QUANTIZED,
-  LFM2_5_350M,
-  LFM2_5_350M_QUANTIZED,
-  LFM2_5_1_2B_INSTRUCT,
-  LFM2_5_1_2B_INSTRUCT_QUANTIZED,
-  LFM2_5_VL_1_6B_QUANTIZED,
-  LFM2_5_VL_450M_QUANTIZED,
-  BIELIK_V3_0_1_5B,
-  BIELIK_V3_0_1_5B_QUANTIZED,
-  EFFICIENTNET_V2_S,
-  EFFICIENTNET_V2_S_QUANTIZED,
-  SSDLITE_320_MOBILENET_V3_LARGE,
-  RF_DETR_NANO,
-  STYLE_TRANSFER_CANDY,
-  STYLE_TRANSFER_CANDY_QUANTIZED,
-  STYLE_TRANSFER_MOSAIC,
-  STYLE_TRANSFER_MOSAIC_QUANTIZED,
-  STYLE_TRANSFER_RAIN_PRINCESS,
-  STYLE_TRANSFER_RAIN_PRINCESS_QUANTIZED,
-  STYLE_TRANSFER_UDNIE,
-  STYLE_TRANSFER_UDNIE_QUANTIZED,
-  WHISPER_TINY_EN,
-  WHISPER_BASE_EN,
-  WHISPER_SMALL_EN,
-  WHISPER_TINY,
-  WHISPER_BASE,
-  WHISPER_SMALL,
-  DEEPLAB_V3_RESNET50,
-  DEEPLAB_V3_RESNET101,
-  DEEPLAB_V3_MOBILENET_V3_LARGE,
-  LRASPP_MOBILENET_V3_LARGE,
-  FCN_RESNET50,
-  FCN_RESNET101,
-  DEEPLAB_V3_RESNET50_QUANTIZED,
-  DEEPLAB_V3_RESNET101_QUANTIZED,
-  DEEPLAB_V3_MOBILENET_V3_LARGE_QUANTIZED,
-  LRASPP_MOBILENET_V3_LARGE_QUANTIZED,
-  FCN_RESNET50_QUANTIZED,
-  FCN_RESNET101_QUANTIZED,
-  SELFIE_SEGMENTATION,
-  YOLO26N_SEG,
-  YOLO26S_SEG,
-  YOLO26M_SEG,
-  YOLO26L_SEG,
-  YOLO26X_SEG,
-  RF_DETR_NANO_SEG,
-  FASTSAM_S,
-  FASTSAM_X,
-  CLIP_VIT_BASE_PATCH32_IMAGE,
-  CLIP_VIT_BASE_PATCH32_IMAGE_QUANTIZED,
-  ALL_MINILM_L6_V2,
-  ALL_MPNET_BASE_V2,
-  MULTI_QA_MINILM_L6_COS_V1,
-  MULTI_QA_MPNET_BASE_DOT_V1,
-  DISTILUSE_BASE_MULTILINGUAL_CASED_V2_8DA4W,
-  PARAPHRASE_MULTILINGUAL_MINILM_L12_V2_QUANTIZED,
-  CLIP_VIT_BASE_PATCH32_TEXT,
-  BK_SDM_TINY_VPRED_512,
-  BK_SDM_TINY_VPRED_256,
-  FSMN_VAD,
-  PRIVACY_FILTER_OPENAI,
-  PRIVACY_FILTER_NEMOTRON,
-];
-
-const urlToModelName = new Map<string, string>();
-for (const config of _ALL_MODELS) {
-  const modelName = config.modelName;
-  for (const [key, value] of Object.entries(config)) {
-    if (key !== 'modelName' && typeof value === 'string') {
-      urlToModelName.set(value, modelName);
-    }
-  }
-}
-
-/**
- * Looks up the model name for a given source URL.
- * @param url - The source URL to look up.
- * @returns The model name if found, otherwise undefined.
- */
-export function getModelNameForUrl(url: string): string | undefined {
-  return urlToModelName.get(url);
-}
diff --git a/packages/react-native-executorch/src/constants/ocr/models.ts b/packages/react-native-executorch/src/constants/ocr/models.ts
deleted file mode 100644
index eff21afbfd..0000000000
--- a/packages/react-native-executorch/src/constants/ocr/models.ts
+++ /dev/null
@@ -1,353 +0,0 @@
-import { alphabets, symbols } from './symbols';
-
-import { URL_PREFIX, PREVIOUS_VERSION_TAG } from '../versions';
-
-const DETECTOR_CRAFT_MODEL = `${URL_PREFIX}-detector-craft/${PREVIOUS_VERSION_TAG}/xnnpack/craft_xnnpack_int8.pte`;
-
-const createHFRecognizerDownloadUrl = (alphabet: keyof typeof alphabets) =>
-  `${URL_PREFIX}-recognizer-crnn.en/${PREVIOUS_VERSION_TAG}/${alphabet}/xnnpack/crnn_${alphabet}_xnnpack_fp32.pte`;
-
-const RECOGNIZER_ENGLISH_CRNN = createHFRecognizerDownloadUrl('english');
-const RECOGNIZER_LATIN_CRNN = createHFRecognizerDownloadUrl('latin');
-const RECOGNIZER_JAPANESE_CRNN = createHFRecognizerDownloadUrl('japanese');
-const RECOGNIZER_KANNADA_CRNN = createHFRecognizerDownloadUrl('kannada');
-const RECOGNIZER_KOREAN_CRNN = createHFRecognizerDownloadUrl('korean');
-const RECOGNIZER_TELUGU_CRNN = createHFRecognizerDownloadUrl('telugu');
-const RECOGNIZER_ZH_SIM_CRNN = createHFRecognizerDownloadUrl('zh_sim');
-const RECOGNIZER_CYRILLIC_CRNN = createHFRecognizerDownloadUrl('cyrillic');
-
-const createOCRObject = (
-  recognizerSource: string,
-  language: keyof typeof symbols
-) => {
-  return {
-    modelName: `ocr-${language}` as const,
-    detectorSource: DETECTOR_CRAFT_MODEL,
-    recognizerSource,
-    language,
-  };
-};
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_ABAZA = createOCRObject(RECOGNIZER_CYRILLIC_CRNN, 'abq');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_ADYGHE = createOCRObject(RECOGNIZER_CYRILLIC_CRNN, 'ady');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_AFRIKAANS = createOCRObject(RECOGNIZER_LATIN_CRNN, 'af');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_AVAR = createOCRObject(RECOGNIZER_CYRILLIC_CRNN, 'ava');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_AZERBAIJANI = createOCRObject(RECOGNIZER_LATIN_CRNN, 'az');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_BELARUSIAN = createOCRObject(RECOGNIZER_CYRILLIC_CRNN, 'be');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_BULGARIAN = createOCRObject(RECOGNIZER_CYRILLIC_CRNN, 'bg');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_BOSNIAN = createOCRObject(RECOGNIZER_LATIN_CRNN, 'bs');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_SIMPLIFIED_CHINESE = createOCRObject(
-  RECOGNIZER_ZH_SIM_CRNN,
-  'chSim'
-);
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_CHECHEN = createOCRObject(RECOGNIZER_CYRILLIC_CRNN, 'che');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_CZECH = createOCRObject(RECOGNIZER_LATIN_CRNN, 'cs');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_WELSH = createOCRObject(RECOGNIZER_LATIN_CRNN, 'cy');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_DANISH = createOCRObject(RECOGNIZER_LATIN_CRNN, 'da');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_DARGWA = createOCRObject(RECOGNIZER_CYRILLIC_CRNN, 'dar');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_GERMAN = createOCRObject(RECOGNIZER_LATIN_CRNN, 'de');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_ENGLISH = createOCRObject(RECOGNIZER_ENGLISH_CRNN, 'en');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_SPANISH = createOCRObject(RECOGNIZER_LATIN_CRNN, 'es');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_ESTONIAN = createOCRObject(RECOGNIZER_LATIN_CRNN, 'et');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_FRENCH = createOCRObject(RECOGNIZER_LATIN_CRNN, 'fr');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_IRISH = createOCRObject(RECOGNIZER_LATIN_CRNN, 'ga');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_CROATIAN = createOCRObject(RECOGNIZER_LATIN_CRNN, 'hr');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_HUNGARIAN = createOCRObject(RECOGNIZER_LATIN_CRNN, 'hu');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_INDONESIAN = createOCRObject(RECOGNIZER_LATIN_CRNN, 'id');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_INGUSH = createOCRObject(RECOGNIZER_CYRILLIC_CRNN, 'inh');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_ICELANDIC = createOCRObject(RECOGNIZER_LATIN_CRNN, 'ic');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_ITALIAN = createOCRObject(RECOGNIZER_LATIN_CRNN, 'it');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_JAPANESE = createOCRObject(RECOGNIZER_JAPANESE_CRNN, 'ja');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_KARBADIAN = createOCRObject(RECOGNIZER_CYRILLIC_CRNN, 'kbd');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_KANNADA = createOCRObject(RECOGNIZER_KANNADA_CRNN, 'kn');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_KOREAN = createOCRObject(RECOGNIZER_KOREAN_CRNN, 'ko');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_KURDISH = createOCRObject(RECOGNIZER_LATIN_CRNN, 'ku');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_LATIN = createOCRObject(RECOGNIZER_LATIN_CRNN, 'la');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_LAK = createOCRObject(RECOGNIZER_CYRILLIC_CRNN, 'lbe');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_LEZGHIAN = createOCRObject(RECOGNIZER_CYRILLIC_CRNN, 'lez');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_LITHUANIAN = createOCRObject(RECOGNIZER_LATIN_CRNN, 'lt');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_LATVIAN = createOCRObject(RECOGNIZER_LATIN_CRNN, 'lv');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_MAORI = createOCRObject(RECOGNIZER_LATIN_CRNN, 'mi');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_MONGOLIAN = createOCRObject(RECOGNIZER_CYRILLIC_CRNN, 'mn');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_MALAY = createOCRObject(RECOGNIZER_LATIN_CRNN, 'ms');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_MALTESE = createOCRObject(RECOGNIZER_LATIN_CRNN, 'mt');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_DUTCH = createOCRObject(RECOGNIZER_LATIN_CRNN, 'nl');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_NORWEGIAN = createOCRObject(RECOGNIZER_LATIN_CRNN, 'no');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_OCCITAN = createOCRObject(RECOGNIZER_LATIN_CRNN, 'oc');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_PALI = createOCRObject(RECOGNIZER_LATIN_CRNN, 'pi');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_POLISH = createOCRObject(RECOGNIZER_LATIN_CRNN, 'pl');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_PORTUGUESE = createOCRObject(RECOGNIZER_LATIN_CRNN, 'pt');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_ROMANIAN = createOCRObject(RECOGNIZER_LATIN_CRNN, 'ro');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_RUSSIAN = createOCRObject(RECOGNIZER_CYRILLIC_CRNN, 'ru');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_SERBIAN_CYRILLIC = createOCRObject(
-  RECOGNIZER_CYRILLIC_CRNN,
-  'rsCyrillic'
-);
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_SERBIAN_LATIN = createOCRObject(
-  RECOGNIZER_LATIN_CRNN,
-  'rsLatin'
-);
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_SLOVAK = createOCRObject(RECOGNIZER_LATIN_CRNN, 'sk');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_SLOVENIAN = createOCRObject(RECOGNIZER_LATIN_CRNN, 'sl');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_ALBANIAN = createOCRObject(RECOGNIZER_LATIN_CRNN, 'sq');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_SWEDISH = createOCRObject(RECOGNIZER_LATIN_CRNN, 'sv');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_SWAHILI = createOCRObject(RECOGNIZER_LATIN_CRNN, 'sw');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_TABASSARAN = createOCRObject(RECOGNIZER_CYRILLIC_CRNN, 'tab');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_TELUGU = createOCRObject(RECOGNIZER_TELUGU_CRNN, 'te');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_TAJIK = createOCRObject(RECOGNIZER_CYRILLIC_CRNN, 'tjk');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_TAGALOG = createOCRObject(RECOGNIZER_LATIN_CRNN, 'tl');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_TURKISH = createOCRObject(RECOGNIZER_LATIN_CRNN, 'tr');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_UKRAINIAN = createOCRObject(RECOGNIZER_CYRILLIC_CRNN, 'uk');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_UZBEK = createOCRObject(RECOGNIZER_LATIN_CRNN, 'uz');
-
-/**
- * @category OCR Supported Alphabets
- */
-export const OCR_VIETNAMESE = createOCRObject(RECOGNIZER_LATIN_CRNN, 'vi');
diff --git a/packages/react-native-executorch/src/constants/ocr/symbols.ts b/packages/react-native-executorch/src/constants/ocr/symbols.ts
deleted file mode 100644
index 0947b2e8b7..0000000000
--- a/packages/react-native-executorch/src/constants/ocr/symbols.ts
+++ /dev/null
@@ -1,151 +0,0 @@
-/* eslint-disable @cspell/spellchecker */
-export const alphabets = {
-  cyrillic:
-    '0123456789!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ €₽ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдеёжзийклмнопрстуфхцчшщъыьэюяЂђЃѓЄєІіЇїЈјЉљЊњЋћЌќЎўЏџҐґҒғҚқҮүҲҳҶҷӀӏӢӣӨөӮӯ',
-  english:
-    '0123456789!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ €ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
-  latin:
-    ' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~ªÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿĀāĂ㥹ĆćČčĎďĐđĒēĖėĘęĚěĞğĨĩĪīĮįİıĶķĹĺĻļĽľŁłŃńŅņŇňŒœŔŕŘřŚśŞşŠšŤťŨũŪūŮůŲųŸŹźŻżŽžƏƠơƯưȘșȚțə̇ḌḍḶḷṀṁṂṃṄṅṆṇṬṭẠạẢảẤấẦầẨẩẪẫẬậẮắẰằẲẳẴẵẶặẸẹẺẻẼẽẾếỀềỂểỄễỆệỈỉỊịỌọỎỏỐốỒồỔổỖỗỘộỚớỜờỞởỠỡỢợỤụỦủỨứỪừỬửỮữỰựỲỳỴỵỶỷỸỹ€',
-  japanese:
-    ' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~‥…※♪、。々〈〉《》「」『』【】〔〕あぃいうぇえおかがきぎくぐけげこごさざしじすずせぜそぞただちぢっつづてでとどなにぬねのはばぱひびぴふぶぷへべぺほぼぽまみむめもゃやゅゆょよらりるれろわをんァアィイゥウェエォオカガキギクグケゲコゴサザシジスズセゼソゾタダチヂッツヅテデトドナニヌネノハバパヒビピフブプヘベペホボポマミムメモャヤュユョヨラリルレロワヱヲンヴヶ・ー一丁七万丈三上下不与丑世丘丙丞両並中串丸丹主乃久之乗乙九也乱乳乾亀了予争事二互五井亘亜亡交亥亨享京亭亮人仁今介仏仕他付仙代令以仮仰仲件任企伊伍伎伏休会伝伯伴伶伸似伽位低住佐佑体何余作佳使例侍侑供依価便係俊俗保信俣修俵倉個倍倒倖候借値倫倭倶偉偏健側偵偽傍傑備債傷働像僧儀優允元兄充先光克免兎児党入全八公六共兵其具典兼内円再写冠冨冬冴冶冷凍凡処凪出刀刃分切刈刑列初判別利制刷券刺刻則削前剛剣剤剥副割創劇力功加助労効勅勇勉動勘務勝勢勤勧勲包化北匠匡区医十千升午半卒卓協南単博占卯印危即卵卸厚原厨厳去参又叉及友双反収取受叡口古句只叫召可台史右叶号司各合吉同名后吏吐向君吟否吸吹吾呂呉告呑周味呼命和咲哀品哉員哲唄唐唯唱商問啓善喜喬喰営嗣嘉噌器四回因団囲図固国國園土圧在圭地坂均坊坐坪垂型垢垣埋城埜域執基埼堀堂堅堤堰報場堺塔塗塚塩塵境墓増墨墳壁壇壊士壬壮声壱売壷変夏夕外多夜夢大天太夫央失夷奇奈奉奏契奥奨女奴好如妃妙妹妻姉始姓委姥姫姿威娘婆婚婦嫌嬉子孔字存孝孟季孤学孫宅宇守安完宏宗官宙定宜宝実客宣室宥宮宰害家容宿寂寄寅密富寒寛寝察寧審寸寺対寿封専射将尊尋導小少尚尭就尺尻尼尽尾尿局居屈屋展属層屯山岐岡岩岬岱岳岸峠峡峨峯峰島峻崇崎崩嵐嵩嵯嶋嶺巌川州巡巣工左巧巨差己巳巴巻巾市布帆希帝師席帯帰帳常帽幅幌幕幡幣干平年幸幹幽幾庁広庄床序底店府度座庫庭庵康庸廃廉廣延建廻弁式弐弓引弘弟弥弦弱張強弾当形彦彩彪彫彬彰影役彼往征径待律後徒従得御復微徳徹心必忌忍志応忠快念怒怜思急性恋恐恒恩恭息恵悌悟悠患悦悪悲情惇惑惟惣想意愚愛感慈態慎慣慧慶憂憲憶懐懸戎成我戒戦戯戸戻房所扇手才打払扶承技投抗折抜抱押担拓拝拡拳拾持指挙振捕捨捷掃排掘掛採探接推掻提揖揚換揮援揺損摂摘摩摺撃撫播撮操擦擬支改攻放政故敏救敗教敢散敦敬数整敵敷文斉斎斐斑斗料斜斤断斯新方於施旅旋族旗日旦旧旨早旬旭旺昂昆昇昌明易星映春昭是昼時晃晋晩普景晴晶智暁暖暗暢暦暮暴曇曙曜曲曳更書曹曽曾替最月有朋服朔朗望朝期木未末本札朱朴杉李杏材村杖杜束条来杭東杵松板析枕林枚果枝枯架柄柊柏柑染柔柚柱柳柴査柿栃栄栖栗校株核根格桂桃案桐桑桜桝桧桶梁梅梓梢梨梯械梶棄棒棚棟森椋植椎検椿楊楓楠楢業楯極楼楽榊榎榛構槌様槙槻樋標模権横樫樹樺樽橋橘機檀櫛欠次欣欧欲欽歌歓止正此武歩歯歳歴死殊残殖段殺殻殿毅母毎毒比毛氏民気水氷永汀汁求汐汗汚江池汰汲決沈沓沖沙沢河油治沼泉泊法波泣泥注泰洋洗洞津洪洲活派流浄浅浜浦浩浪浮浴海消涌涙液涼淀淑淡深淳淵混添清済渉渋渓渕渚減渡渥温測港湊湖湧湯湾湿満源準溜溝溶滅滋滑滝漁漆漏演漢漬潔潜潟潤潮潰澄澤激濃濱瀧瀬灘火灯灰災炉炎炭点為烈烏無焦然焼煙照煮熊熟熱燃燈燕燦燭爆爪父爽爾片版牛牟牧物特犬犯状狂狐狗狩独狭狼猛猪猫献猿獄獅獣玄率玉王玖玲珍珠現球理琉琢琳琴瑚瑛瑞瑠瑳璃環瓜瓦瓶甘甚生産用甫田由甲申男町画界畑畔留畜畝畠略番異畳疾病症痛療発登白百的皆皇皮皿盆益盗盛盟監盤目盲直相省眉看県眞真眠眼着督睦瞬瞳矢知矩短石砂研砲破硫硬碑碧碩確磁磐磨磯礁示礼社祇祈祉祐祖祝神祢祥票祭禁禄禅禎福禰秀私秋科秘秦秩称移稀程税稔稗稚種稲穂積穏穴究空突窓窪立竜章童竪端競竹笑笛笠符第笹筆等筋筑筒答策箇箕算管箱箸節範築篠篤篭簡簾籍米粉粒粕粗粟粥精糖糞糠糸系紀約紅紋納純紗紘紙級素紡索紫細紳紹紺終組経結絡絢給統絵絶絹継続綜維綱網綾綿緋総緑緒線締編緩練縁縄縦縫縮績繁織繰罪置羅羊美群義羽翁習翔翠翼耀老考者耐耕耳耶聖聞聡聴職肇肉肌肝股肥肩育肺背胞胡胤胸能脂脇脈脚脱脳腐腕腫腰腸腹膜膳臣臥臨自臭至致臼興舌舎舘舛舜舞舟航般船艦良色艶芋芙芝芥芦花芳芸芹芽苅苑苔苗若苦苫英茂茄茅茉茜茨茶草荒荘荷荻莉菅菊菌菓菖菜華菱萌萩萱落葉葛葦葵蒔蒲蒸蒼蓋蓑蓬蓮蔦蔭蔵蕗薄薩薫薬薮藁藍藤藻蘇蘭虎虚虫虹虻蚊蛇蛍蛭蜂蜜蝦蝶融螺蟹蟻血衆行術街衛衝衡衣表袋袖被裁裂装裏裕補裟裸製複西要覆覇見規視覚覧親観角解触言計訓託記訪設許訳訴診証評詞詠試詩詰話誉誌認誓誘語誠誤説読課調談請諏論諭諸謙講謝謹識警議譲護讃谷豆豊豚象豪貝貞負財貢貧貨販貫責貯貴買貸費賀賃資賞賢質赤赦走起超越足跡路跳踏身車軌軍軒軟転軸軽載輔輝輪輸辛辞辰農辺辻込迎近返迦迫述迷追退送逃逆透途通速造逢連週進逸遅遊運過道達違遠遣遥適選遺遼避邑那邦邪郁郎郡部郭郵郷都配酒酔酢酸醍醐采釈里重野量金釘釜針釣鈴鉄鉛鉢鉱鉾銀銃銅銘銭鋭鋼錦録鍋鍛鍬鍵鎌鎖鎮鏡鐘鑑長門閉開閑間関閣闇闘阪防阿陀附降限院陣除陰陳陵陶陸険陽隅隆隈隊階随隔際障隠隣隼雀雁雄雅集雑雛離難雨雪雲零雷電震霊霜霞霧露青靖静非面革鞍鞠韓音響頂頃項順須預頓領頭頼題額顔顕願類風飛食飯飲飼飽飾餅養館首香馨馬駄駅駆駐駒駿騎験骨高髪鬼魁魂魅魔魚鮎鮫鮮鯉鯨鳥鳩鳳鳴鴨鴻鵜鶏鶴鷲鷹鷺鹿麓麗麦麻麿黄黒黙鼓鼠鼻齢龍＊',
-  zh_sim:
-    ' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~。〈〉《》「」『』一丁七万丈三上下不与丐丑专且丕世丘丙业丛东丝丞丢两严丧个丫中丰串临丸丹为主丽举乃久么义之乌乍乎乏乐乒乓乔乖乘乙乜九乞也习乡书乩买乱乳乾了予争事二亍于亏云互亓五井亘亚些亟亡亢交亥亦产亨亩享京亭亮亲亳亵人亿什仁仂仃仄仅仆仇仉今介仍从仑仓仔仕他仗付仙仞仟仡代令以仨仪仫们仰仲仳仵件价任份仿企伉伊伍伎伏伐休众优伙会伛伞伟传伢伤伦伧伪伫伯估伴伶伸伺似伽佃但位低住佐佑体何佗佘余佚佛作佝佞佟你佣佤佥佩佬佯佰佳佴佶佻佼佾使侃侄侈侉例侍侏侑侔侗供依侠侣侥侦侧侨侩侪侬侮侯侵便促俄俅俊俎俏俐俑俗俘俚俜保俞俟信俣俦俨俩俪俭修俯俱俳俸俺俾倌倍倏倒倔倘候倚倜借倡倥倦倨倩倪倬倭债值倾偃假偈偌偎偏偕做停健偬偶偷偻偾偿傀傅傈傍傣傥傧储傩催傲傻像僖僚僦僧僬僭僮僳僵僻儆儇儋儒儡儿兀允元兄充兆先光克免兑兔兕兖党兜兢入全八公六兮兰共关兴兵其具典兹养兼兽冀冁内冈冉册再冒冕冗写军农冠冢冤冥冬冯冰冱冲决况冶冷冻冼冽净凄准凇凉凋凌减凑凛凝几凡凤凫凭凯凰凳凶凸凹出击凼函凿刀刁刃分切刈刊刍刎刑划刖列刘则刚创初删判刨利别刭刮到刳制刷券刹刺刻刽刿剀剁剂剃削剌前剐剑剔剖剜剞剡剥剧剩剪副割剽剿劁劂劈劐劓力劝办功加务劢劣动助努劫劬劭励劲劳劾势勃勇勉勋勐勒勖勘募勤勰勺勾勿匀包匆匈匍匏匐匕化北匙匝匠匡匣匦匪匮匹区医匾匿十千卅升午卉半华协卑卒卓单卖南博卜卞卟占卡卢卣卤卦卧卫卮卯印危即却卵卷卸卺卿厂厄厅历厉压厌厍厕厘厚厝原厢厣厥厦厨厩厮去县叁参又叉及友双反发叔取受变叙叛叟叠口古句另叨叩只叫召叭叮可台叱史右叵叶号司叹叻叼叽吁吃各吆合吉吊同名后吏吐向吒吓吕吗君吝吞吟吠吡吣否吧吨吩含听吭吮启吱吲吴吵吸吹吻吼吾呀呃呆呈告呋呐呓呔呕呖呗员呙呛呜呢呤呦周呱呲味呵呶呷呸呻呼命咀咂咄咆咋和咎咏咐咒咔咕咖咙咚咛咝咣咤咦咧咨咩咪咫咬咭咯咱咳咴咸咻咽咿哀品哂哄哆哇哈哉哌响哎哏哐哑哓哔哕哗哙哚哝哞哟哥哦哧哨哩哪哭哮哲哳哺哼哽哿唁唆唇唉唏唐唑唔唛唠唢唣唤唧唪唬售唯唱唳唷唼唾唿啁啃啄商啉啊啐啕啖啜啡啤啥啦啧啪啬啭啮啵啶啷啸啻啼啾喀喁喂喃善喇喈喉喊喋喏喑喔喘喙喜喝喟喧喱喳喵喷喹喻喽喾嗄嗅嗉嗌嗍嗑嗒嗓嗔嗖嗜嗝嗟嗡嗣嗤嗥嗦嗨嗪嗫嗬嗯嗲嗳嗵嗷嗽嗾嘀嘁嘈嘉嘌嘎嘏嘘嘛嘞嘟嘣嘤嘧嘬嘭嘱嘲嘴嘶嘹嘻嘿噌噍噎噔噗噙噜噢噤器噩噪噫噬噱噶噻噼嚅嚆嚎嚏嚓嚣嚯嚷嚼囊囔囚四囝回囟因囡团囤囫园困囱围囵囹固国图囿圃圄圆圈圉圊圜土圣在圩圪圬圭圮圯地圳圹场圻圾址坂均坊坌坍坎坏坐坑块坚坛坜坝坞坟坠坡坤坦坨坩坪坫坭坯坳坷坻坼垂垃垄垅垆型垌垒垓垛垠垡垢垣垤垦垧垩垫垭垮垲垸埂埃埋城埏埒埔埕埘埙埚埝域埠埤埭埯埴埸培基埽堂堆堇堋堍堑堕堙堞堠堡堤堪堰堵塄塌塍塑塔塘塞塥填塬塾墀墁境墅墉墒墓墙增墟墨墩墼壁壅壑壕壤士壬壮声壳壶壹处备复夏夔夕外夙多夜够夤夥大天太夫夭央夯失头夷夸夹夺夼奁奂奄奇奈奉奋奎奏契奔奕奖套奘奚奠奢奥女奴奶奸她好妁如妃妄妆妇妈妊妍妒妓妖妗妙妞妣妤妥妨妩妪妫妮妯妲妹妻妾姆姊始姐姑姒姓委姗姘姚姜姝姣姥姨姬姹姻姿威娃娄娅娆娇娈娉娌娑娓娘娜娟娠娣娥娩娱娲娴娶娼婀婆婉婊婕婚婢婧婪婴婵婶婷婺婿媒媚媛媪媲媳媵媸媾嫁嫂嫉嫌嫒嫔嫖嫘嫜嫠嫡嫣嫦嫩嫫嫱嬉嬖嬗嬴嬷孀子孑孓孔孕字存孙孚孛孜孝孟孢季孤孥学孩孪孬孰孱孳孵孺孽宁它宄宅宇守安宋完宏宓宕宗官宙定宛宜宝实宠审客宣室宥宦宪宫宰害宴宵家宸容宽宾宿寂寄寅密寇富寐寒寓寝寞察寡寤寥寨寮寰寸对寺寻导寿封射将尉尊小少尔尕尖尘尚尜尝尤尥尧尬就尴尸尹尺尻尼尽尾尿局屁层居屈屉届屋屎屏屐屑展屙属屠屡屣履屦屯山屹屺屿岁岂岈岌岍岐岑岔岖岗岘岙岚岛岢岣岩岫岬岭岱岳岵岷岸岿峁峄峋峒峙峡峤峥峦峨峪峭峰峻崂崃崆崇崎崔崖崛崞崤崦崧崩崭崮崴崽嵇嵊嵋嵌嵘嵛嵝嵩嵫嵬嵯嵴嶂嶙嶝嶷巅巍川州巡巢工左巧巨巩巫差巯己已巳巴巷巽巾币市布帅帆师希帏帐帑帔帕帖帘帙帚帛帜帝带帧席帮帱帷常帻帼帽幂幄幅幌幔幕幛幞幡幢干平年并幸幺幻幼幽广庀庄庆庇床庋序庐庑库应底庖店庙庚府庞废庠庥度座庭庳庵庶康庸庹庾廉廊廒廓廖廛廨廪延廷建廿开弁异弃弄弈弊弋式弑弓引弗弘弛弟张弥弦弧弩弭弯弱弹强弼彀归当录彖彗彘彝形彤彦彩彪彬彭彰影彳彷役彻彼往征徂径待徇很徉徊律後徐徒徕得徘徙徜御徨循徭微徵德徼徽心必忆忉忌忍忏忐忑忒忖志忘忙忝忠忡忤忧忪快忭忮忱念忸忻忽忾忿怀态怂怃怄怅怆怊怍怎怏怒怔怕怖怙怛怜思怠怡急怦性怨怩怪怫怯怵总怼怿恁恂恃恋恍恐恒恕恙恚恝恢恣恤恧恨恩恪恫恬恭息恰恳恶恸恹恺恻恼恽恿悃悄悉悌悍悒悔悖悚悛悝悟悠患悦您悫悬悭悯悱悲悴悸悻悼情惆惊惋惑惕惘惚惜惝惟惠惦惧惨惩惫惬惭惮惯惰想惴惶惹惺愀愁愆愈愉愍愎意愕愚感愠愣愤愦愧愫愿慈慊慌慎慑慕慝慢慧慨慰慵慷憋憎憔憝憧憨憩憬憷憾懂懈懊懋懑懒懦懵懿戆戈戊戋戌戍戎戏成我戒戕或戗战戚戛戟戡戢戥截戬戮戳戴户戽戾房所扁扃扇扈扉手扌才扎扑扒打扔托扛扣扦执扩扪扫扬扭扮扯扰扳扶批扼找承技抄抉把抑抒抓投抖抗折抚抛抟抠抡抢护报抨披抬抱抵抹抻押抽抿拂拄担拆拇拈拉拊拌拍拎拐拒拓拔拖拗拘拙拚招拜拟拢拣拥拦拧拨择括拭拮拯拱拳拴拶拷拼拽拾拿持挂指挈按挎挑挖挚挛挝挞挟挠挡挢挣挤挥挨挪挫振挲挹挺挽捂捃捅捆捉捋捌捍捎捏捐捕捞损捡换捣捧捩捭据捱捶捷捺捻掀掂掇授掉掊掌掎掏掐排掖掘掠探掣接控推掩措掬掭掮掰掳掴掷掸掺掼掾揄揆揉揍揎描提插揖揞揠握揣揩揪揭援揶揸揽揿搀搁搂搅搋搌搏搐搓搔搛搜搞搠搡搦搪搬搭搴携搽摁摄摅摆摇摈摊摒摔摘摞摧摩摭摸摹摺撂撄撅撇撑撒撕撖撙撞撤撩撬播撮撰撵撷撸撺撼擀擂擅操擎擐擒擘擞擢擤擦攀攉攒攘攥攫攮支收攸改攻放政故效敉敌敏救敕敖教敛敝敞敢散敦敫敬数敲整敷文斋斌斐斑斓斗料斛斜斟斡斤斥斧斩斫断斯新方於施旁旃旄旅旆旋旌旎族旒旖旗无既日旦旧旨早旬旭旮旯旰旱时旷旺昀昂昃昆昊昌明昏易昔昕昙昝星映春昧昨昭是昱昴昵昶昼显晁晃晋晌晏晒晓晔晕晖晗晚晟晡晤晦晨普景晰晴晶晷智晾暂暄暇暌暑暖暗暝暧暨暮暴暹暾曙曛曜曝曦曩曰曲曳更曷曹曼曾替最月有朊朋服朐朔朕朗望朝期朦木未末本札术朱朴朵机朽杀杂权杆杈杉杌李杏材村杓杖杜杞束杠条来杨杪杭杯杰杲杳杵杷杼松板极构枇枉枋析枕林枘枚果枝枞枢枣枥枧枨枪枫枭枯枰枳枵架枷枸柁柃柄柏某柑柒染柔柘柙柚柜柝柞柠柢查柩柬柯柰柱柳柴柽柿栀栅标栈栉栊栋栌栎栏树栓栖栗栝校栩株栲栳样核根格栽栾桀桁桂桃桄桅框案桉桊桌桎桐桑桓桔桕桠桡桢档桤桥桦桧桨桩桫桴桶桷梁梃梅梆梏梓梗梢梦梧梨梭梯械梳梵检棂棉棋棍棒棕棘棚棠棣森棰棱棵棹棺棼椁椅椋植椎椐椒椟椠椤椭椰椴椹椽椿楂楔楗楚楝楞楠楣楦楫楮楷楸楹楼榀概榄榆榇榈榉榍榔榕榛榜榧榨榫榭榱榴榷榻槁槊槌槎槐槔槛槟槠槭槲槽槿樊樗樘樟模樨横樯樱樵樽樾橄橇橐橘橙橛橡橥橱橹橼檀檄檎檐檑檗檠檩檫檬欠次欢欣欤欧欲欷欺款歃歆歇歉歌歙止正此步武歧歪歹死歼殁殂殃殄殆殇殉殊残殍殒殓殖殚殛殡殪殳殴段殷殿毁毂毅毋母每毒毓比毕毖毗毙毛毡毪毫毯毳毵毹毽氅氆氇氍氏氐民氓气氕氖氘氙氚氛氟氡氢氤氦氧氨氩氪氮氯氰氲水永氽汀汁求汆汇汉汊汐汔汕汗汛汜汝汞江池污汤汨汩汪汰汲汴汶汹汽汾沁沂沃沅沆沈沉沌沏沐沓沔沙沛沟没沣沤沥沦沧沩沪沫沭沮沱河沸油治沼沽沾沿泄泅泉泊泌泐泓泔法泖泗泛泞泠泡波泣泥注泪泫泮泯泰泱泳泵泷泸泺泻泼泽泾洁洄洇洋洌洎洒洗洙洚洛洞津洧洪洫洮洱洲洳洵洹活洼洽派流浃浅浆浇浈浊测浍济浏浑浒浓浔浙浚浜浞浠浣浦浩浪浮浯浴海浸浼涂涅消涉涌涎涑涓涔涕涛涝涞涟涠涡涣涤润涧涨涩涪涫涮涯液涵涸涿淀淄淅淆淇淋淌淑淖淘淙淝淞淠淡淤淦淫淬淮深淳混淹添淼清渊渌渍渎渐渑渔渖渗渚渝渠渡渣渤渥温渫渭港渲渴游渺湃湄湍湎湔湖湘湛湟湫湮湾湿溃溅溆溉溏源溘溜溟溢溥溧溪溯溱溲溴溶溷溺溻溽滁滂滇滋滏滑滓滔滕滗滚滞滟滠满滢滤滥滦滨滩滴滹漂漆漉漏漓演漕漠漤漩漪漫漭漯漱漳漶漾潆潇潋潍潘潜潞潢潦潭潮潲潴潸潺潼澄澈澉澌澍澎澜澡澧澳澶澹激濂濉濑濒濞濠濡濮濯瀑瀚瀛瀣瀵瀹灌灏灞火灭灯灰灵灶灸灼灾灿炀炅炉炊炎炒炔炕炖炙炜炝炫炬炭炮炯炱炳炷炸点炻炼炽烀烁烂烃烈烊烘烙烛烟烤烦烧烨烩烫烬热烯烷烹烽焉焊焐焓焕焖焘焙焚焦焯焰焱然煅煊煌煎煜煞煤煦照煨煮煲煳煸煺煽熄熊熏熔熘熙熟熠熨熬熵熹燃燎燔燕燠燥燧燮燹爆爝爨爪爬爰爱爵父爷爸爹爻爽爿片版牌牍牒牖牙牛牝牟牡牢牦牧物牮牯牲牵特牺牾犀犁犄犊犋犍犏犒犟犬犯犰犴状犷犸犹狁狂狃狄狈狍狎狐狒狗狙狞狠狡狨狩独狭狮狯狰狱狲狳狴狷狸狺狻狼猁猃猊猎猕猖猗猛猜猝猞猡猢猥猩猪猫猬献猱猴猷猸猹猾猿獍獐獒獗獠獬獭獯獾玄率玉王玎玑玖玛玢玩玫玮环现玲玳玷玺玻珀珂珈珉珊珍珏珐珑珙珞珠珥珧珩班珲球琅理琉琏琐琚琛琢琥琦琨琪琬琮琰琳琴琵琶琼瑁瑕瑗瑙瑚瑛瑜瑞瑟瑭瑰瑶瑾璀璁璃璇璋璎璐璜璞璧璨璩瓒瓜瓞瓠瓢瓣瓤瓦瓮瓯瓴瓶瓷瓿甄甏甑甓甘甙甚甜生甥用甩甫甬甭田由甲申电男甸町画甾畀畅畈畋界畎畏畔留畚畛畜略畦番畲畴畸畹畿疃疆疋疏疑疔疖疗疙疚疝疟疠疡疣疤疥疫疬疮疯疰疱疲疳疴疵疸疹疼疽疾痂痃痄病症痈痉痊痍痒痔痕痘痛痞痢痣痤痦痧痨痪痫痰痱痴痹痼痿瘀瘁瘃瘅瘊瘌瘐瘗瘘瘙瘛瘟瘠瘢瘤瘥瘦瘩瘪瘫瘭瘰瘳瘴瘵瘸瘼瘾瘿癀癃癌癍癔癖癜癞癣癫癯癸登白百皂的皆皇皈皋皎皑皓皖皙皤皮皱皲皴皿盂盅盆盈益盍盎盏盐监盒盔盖盗盘盛盟盥目盯盱盲直相盹盼盾省眄眇眈眉看眍眙眚真眠眢眦眨眩眭眯眵眶眷眸眺眼着睁睃睇睐睑睚睛睡睢督睥睦睨睫睬睹睽睾睿瞀瞄瞅瞌瞍瞎瞑瞒瞟瞠瞢瞥瞧瞩瞪瞬瞰瞳瞵瞻瞽瞿矍矗矛矜矢矣知矧矩矫矬短矮石矶矸矽矾矿砀码砂砉砌砍砑砒研砖砗砘砚砜砝砟砣砥砧砭砰破砷砸砹砺砻砼砾础硅硇硌硎硐硒硕硖硗硝硪硫硬硭确硷硼碇碉碌碍碎碑碓碗碘碚碛碜碟碡碣碥碧碰碱碲碳碴碹碾磁磅磉磊磋磐磔磕磙磨磬磲磴磷磺礁礅礓礞礤礴示礻礼社祀祁祆祈祉祓祖祗祚祛祜祝神祟祠祢祥祧票祭祯祷祸祺禀禁禄禅禊福禚禧禳禹禺离禽禾秀私秃秆秉秋种科秒秕秘租秣秤秦秧秩秫秭积称秸移秽稀稂稆程稍税稔稗稚稞稠稣稳稷稻稼稽稿穆穑穗穰穴究穷穸穹空穿窀突窃窄窈窍窑窒窕窖窗窘窜窝窟窠窥窦窨窬窭窳窿立竖站竞竟章竣童竦竭端竹竺竽竿笃笄笆笈笊笋笏笑笔笕笙笛笞笠笤笥符笨笪笫第笮笱笳笸笺笼笾筅筇等筋筌筏筐筑筒答策筘筚筛筝筠筢筮筱筲筵筷筹筻签简箅箍箐箔箕算箜管箢箦箧箨箩箪箫箬箭箱箴箸篁篆篇篌篑篓篙篚篝篡篥篦篪篮篱篷篼篾簇簋簌簏簖簟簦簧簪簸簿籀籁籍米籴类籼籽粉粑粒粕粗粘粜粝粞粟粤粥粪粮粱粲粳粹粼粽精糁糅糇糈糊糌糍糕糖糗糙糜糟糠糨糯系紊素索紧紫累絮絷綦綮縻繁繇纂纛纠纡红纣纤纥约级纨纩纪纫纬纭纯纰纱纲纳纵纶纷纸纹纺纽纾线绀绁绂练组绅细织终绉绊绋绌绍绎经绐绑绒结绔绕绗绘给绚绛络绝绞统绠绡绢绣绥绦继绨绩绪绫续绮绯绰绲绳维绵绶绷绸绺绻综绽绾绿缀缁缂缃缄缅缆缇缈缉缌缎缏缑缒缓缔缕编缗缘缙缚缛缜缝缟缠缡缢缣缤缥缦缧缨缩缪缫缬缭缮缯缰缱缲缳缴缵缶缸缺罂罄罅罐网罔罕罗罘罚罟罡罢罨罩罪置罱署罴罹罾羁羊羌美羔羚羝羞羟羡群羧羯羰羲羸羹羼羽羿翁翅翊翌翎翔翕翘翟翠翡翥翦翩翮翰翱翳翻翼耀老考耄者耆耋而耍耐耒耔耕耖耗耘耙耜耠耢耥耦耧耨耩耪耱耳耵耶耷耸耻耽耿聂聃聆聊聋职聍聒联聘聚聩聪聱聿肃肄肆肇肉肋肌肓肖肘肚肛肝肟肠股肢肤肥肩肪肫肭肮肯肱育肴肷肺肼肽肾肿胀胁胂胃胄胆背胍胎胖胗胙胚胛胜胝胞胡胤胥胧胨胩胪胫胬胭胯胰胱胲胳胴胶胸胺胼能脂脆脉脊脍脎脏脐脑脒脓脔脖脘脚脞脬脯脱脲脶脸脾腆腈腊腋腌腐腑腓腔腕腙腚腠腥腧腩腭腮腰腱腴腹腺腻腼腽腾腿膀膂膈膊膏膑膘膛膜膝膦膨膪膳膺膻臀臁臂臃臆臊臌臣臧自臬臭至致臻臼臾舀舁舂舄舅舆舌舍舐舒舔舛舜舞舟舡舢舣舨航舫般舰舱舳舴舵舶舷舸船舻舾艄艇艋艘艚艟艨艮良艰色艳艴艺艽艾艿节芄芈芊芋芍芎芏芑芒芗芘芙芜芝芟芡芥芦芨芩芪芫芬芭芮芯芰花芳芴芷芸芹芽芾苁苄苇苈苊苋苌苍苎苏苑苒苓苔苕苗苘苛苜苞苟苠苡苣苤若苦苫苯英苴苷苹苻茁茂范茄茅茆茈茉茌茎茏茑茔茕茗茚茛茜茧茨茫茬茭茯茱茳茴茵茶茸茹茼荀荃荆荇草荏荐荑荒荔荚荛荜荞荟荠荡荣荤荥荦荧荨荩荪荫荬荭药荷荸荻荼荽莅莆莉莎莒莓莘莛莜莞莠莨莩莪莫莰莱莲莳莴莶获莸莹莺莼莽菀菁菅菇菊菌菏菔菖菘菜菝菟菠菡菥菩菪菰菱菲菹菽萁萃萄萋萌萍萎萏萑萘萜萝萤营萦萧萨萱萸萼落葆葑著葚葛葜葡董葩葫葬葭葱葳葵葶葸葺蒂蒇蒈蒉蒋蒌蒎蒗蒙蒜蒡蒯蒲蒴蒸蒹蒺蒽蒿蓁蓄蓉蓊蓍蓐蓑蓓蓖蓝蓟蓠蓣蓥蓦蓬蓰蓼蓿蔌蔑蔓蔗蔚蔟蔡蔫蔬蔷蔸蔹蔺蔻蔼蔽蕃蕈蕉蕊蕖蕙蕞蕤蕨蕲蕴蕹蕺蕻蕾薄薅薇薏薛薜薤薨薪薮薯薰薷薹藁藉藏藐藓藕藜藤藩藻藿蘅蘑蘖蘧蘩蘸蘼虎虏虐虑虔虚虞虢虫虬虮虱虹虺虻虼虽虾虿蚀蚁蚂蚊蚋蚌蚍蚓蚕蚜蚝蚣蚤蚧蚨蚩蚬蚯蚰蚱蚴蚶蚺蛀蛄蛆蛇蛉蛊蛋蛎蛏蛐蛑蛔蛘蛙蛛蛞蛟蛤蛩蛭蛮蛰蛱蛲蛳蛴蛸蛹蛾蜀蜂蜃蜇蜈蜉蜊蜍蜒蜓蜕蜗蜘蜚蜜蜞蜡蜢蜣蜥蜩蜮蜱蜴蜷蜻蜾蜿蝇蝈蝉蝌蝎蝓蝗蝙蝠蝣蝤蝥蝮蝰蝴蝶蝻蝼蝽蝾螂螃螅螈螋融螗螟螨螫螬螭螯螳螵螺螽蟀蟆蟊蟋蟑蟒蟛蟠蟥蟪蟮蟹蟾蠃蠊蠓蠕蠖蠡蠢蠲蠹蠼血衄衅行衍衔街衙衡衢衣补表衩衫衬衮衰衲衷衽衾衿袁袂袄袅袈袋袍袒袖袜袢袤被袭袱袼裁裂装裆裉裎裒裔裕裘裙裟裢裣裤裥裨裰裱裳裴裸裹裼裾褂褊褐褒褓褙褚褛褡褥褪褫褰褴褶襁襄襞襟襦襻西要覃覆见观规觅视觇览觉觊觋觌觎觏觐觑角觖觚觜觞解觥触觫觯觳言訇訾詈詹誉誊誓謇警譬计订讣认讥讦讧讨让讪讫训议讯记讲讳讴讵讶讷许讹论讼讽设访诀证诂诃评诅识诈诉诊诋诌词诎诏译诒诓诔试诖诗诘诙诚诛诜话诞诟诠诡询诣诤该详诧诨诩诫诬语诮误诰诱诲诳说诵请诸诹诺读诼诽课诿谀谁谂调谄谅谆谇谈谊谋谌谍谎谏谐谑谒谓谔谕谖谗谙谚谛谜谝谟谠谡谢谣谤谥谦谧谨谩谪谫谬谭谮谯谰谱谲谳谴谵谶谷豁豆豇豉豌豕豚象豢豪豫豳豸豹豺貂貅貉貊貌貔貘贝贞负贡财责贤败账货质贩贪贫贬购贮贯贰贱贲贳贴贵贶贷贸费贺贻贼贽贾贿赀赁赂赃资赅赆赇赈赉赊赋赌赍赎赏赐赓赔赖赘赙赚赛赜赝赞赠赡赢赣赤赦赧赫赭走赳赴赵赶起趁趄超越趋趑趔趟趣趱足趴趵趸趺趼趾趿跃跄跆跋跌跎跏跑跖跗跚跛距跞跟跣跤跨跪跬路跳践跷跸跹跺跻跽踅踉踊踌踏踔踝踞踟踢踣踩踪踬踮踯踱踵踹踺踽蹀蹁蹂蹄蹇蹈蹉蹊蹋蹑蹒蹙蹦蹩蹬蹭蹯蹰蹲蹴蹶蹼蹿躁躅躇躏躐躔躜躞身躬躯躲躺车轧轨轩轫转轭轮软轰轱轲轳轴轵轶轷轸轺轻轼载轾轿辁辂较辄辅辆辇辈辉辊辋辍辎辏辐辑输辔辕辖辗辘辙辚辛辜辞辟辣辨辩辫辰辱边辽达迁迂迄迅过迈迎运近迓返迕还这进远违连迟迢迤迥迦迨迩迪迫迭迮述迷迸迹追退送适逃逄逅逆选逊逋逍透逐逑递途逖逗通逛逝逞速造逡逢逦逭逮逯逵逶逸逻逼逾遁遂遄遇遍遏遐遑遒道遗遘遛遢遣遥遨遭遮遴遵遽避邀邂邃邈邋邑邓邕邗邙邛邝邡邢那邦邪邬邮邯邰邱邳邴邵邶邸邹邺邻邾郁郄郅郇郊郎郏郐郑郓郗郛郜郝郡郢郦郧部郫郭郯郴郸都郾鄂鄄鄙鄞鄢鄣鄯鄱鄹酃酆酉酊酋酌配酎酏酐酒酗酚酝酞酡酢酣酤酥酩酪酬酮酯酰酱酲酴酵酶酷酸酹酽酾酿醅醇醉醋醌醍醐醑醒醚醛醢醪醭醮醯醴醵醺采釉释里重野量金釜鉴銎銮鋈錾鍪鎏鏊鏖鐾鑫钆钇针钉钊钋钌钍钎钏钐钒钓钔钕钗钙钚钛钜钝钞钟钠钡钢钣钤钥钦钧钨钩钪钫钬钭钮钯钰钱钲钳钴钵钷钹钺钻钼钽钾钿铀铁铂铃铄铅铆铈铉铊铋铌铍铎铐铑铒铕铗铘铙铛铜铝铞铟铠铡铢铣铤铥铧铨铩铪铫铬铭铮铯铰铱铲铳铴铵银铷铸铹铺铼铽链铿销锁锂锃锄锅锆锇锈锉锊锋锌锎锏锐锑锒锓锔锕锖锗锘错锚锛锝锞锟锡锢锣锤锥锦锨锩锪锫锬锭键锯锰锱锲锴锵锶锷锸锹锺锻锾锿镀镁镂镄镅镆镇镉镊镌镍镎镏镐镑镒镓镔镖镗镘镛镜镝镞镡镢镣镤镥镦镧镨镩镪镫镬镭镯镰镱镲镳镶长门闩闪闫闭问闯闰闱闲闳间闵闶闷闸闹闺闻闼闽闾阀阁阂阃阄阅阆阈阉阊阋阌阍阎阏阐阑阒阔阕阖阗阙阚阜队阡阢阪阮阱防阳阴阵阶阻阼阽阿陀陂附际陆陇陈陉陋陌降限陔陕陛陟陡院除陧陨险陪陬陲陴陵陶陷隅隆隈隋隍随隐隔隗隘隙障隧隰隳隶隼隽难雀雁雄雅集雇雉雌雍雎雏雒雕雠雨雩雪雯雳零雷雹雾需霁霄霆震霈霉霍霎霏霓霖霜霞霪霭霰露霸霹霾青靓靖静靛非靠靡面靥革靳靴靶靼鞅鞋鞍鞑鞒鞘鞠鞣鞫鞭鞯鞲鞴韦韧韩韪韫韬韭音韵韶页顶顷顸项顺须顼顽顾顿颀颁颂颃预颅领颇颈颉颊颌颍颏颐频颓颔颖颗题颚颛颜额颞颟颠颡颢颤颥颦颧风飑飒飓飕飘飙飚飞食飧飨餍餐餮饔饕饥饧饨饩饪饫饬饭饮饯饰饱饲饴饵饶饷饺饼饽饿馀馁馄馅馆馇馈馊馋馍馏馐馑馒馓馔馕首馗馘香馥馨马驭驮驯驰驱驳驴驵驶驷驸驹驺驻驼驽驾驿骀骁骂骄骅骆骇骈骊骋验骏骐骑骒骓骖骗骘骚骛骜骝骞骟骠骡骢骣骤骥骧骨骰骶骷骸骺骼髀髁髂髅髋髌髑髓高髡髦髫髭髯髹髻鬃鬈鬏鬓鬟鬣鬯鬲鬻鬼魁魂魃魄魅魇魈魉魍魏魑魔鱼鱿鲁鲂鲅鲆鲇鲈鲋鲍鲎鲐鲑鲔鲚鲛鲜鲞鲟鲠鲡鲢鲣鲤鲥鲦鲧鲨鲩鲫鲭鲮鲰鲱鲲鲳鲴鲵鲷鲸鲺鲻鲼鲽鳃鳄鳅鳆鳇鳊鳌鳍鳎鳏鳐鳓鳔鳕鳖鳗鳘鳙鳜鳝鳞鳟鳢鸟鸠鸡鸢鸣鸥鸦鸨鸩鸪鸫鸬鸭鸯鸱鸲鸳鸵鸶鸷鸸鸹鸺鸽鸾鸿鹁鹂鹃鹄鹅鹆鹇鹈鹉鹊鹋鹌鹎鹏鹑鹕鹗鹘鹚鹛鹜鹞鹣鹤鹦鹧鹨鹩鹪鹫鹬鹭鹰鹱鹳鹿麂麇麈麋麒麓麝麟麦麸麻麽麾黄黉黍黎黏黑黔默黛黜黝黟黠黢黥黧黩黯黹黻黼黾鼋鼍鼎鼐鼓鼗鼙鼠鼢鼬鼯鼷鼹鼻鼾齐齑齿龀龃龄龅龆龇龈龉龊龋龌龙龚龛龟龠',
-  korean:
-    ' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~가각간갇갈감갑값강갖같갚갛개객걀거걱건걷걸검겁것겉게겨격겪견결겹경곁계고곡곤곧골곰곱곳공과관광괜괴굉교구국군굳굴굵굶굽궁권귀규균그극근글긁금급긋긍기긴길김깅깊까깎깐깔깜깝깥깨꺼꺾껍껏껑께껴꼬꼭꼴꼼꼽꽂꽃꽉꽤꾸꿀꿈뀌끄끈끊끌끓끔끗끝끼낌나낙낚난날낡남납낫낭낮낯낱낳내냄냉냐냥너넉널넓넘넣네넥넷녀녁년념녕노녹논놀놈농높놓놔뇌뇨누눈눕뉘뉴늄느늑는늘늙능늦늬니닐님다닥닦단닫달닭닮담답닷당닿대댁댐더덕던덜덤덥덧덩덮데델도독돈돌돕동돼되된두둑둘둠둡둥뒤뒷드득든듣들듬듭듯등디딩딪따딱딴딸땀땅때땜떠떡떤떨떻떼또똑뚜뚫뚱뛰뜨뜩뜯뜰뜻띄라락란람랍랑랗래랜램랫략량러럭런럴럼럽럿렁렇레렉렌려력련렬렵령례로록론롬롭롯료루룩룹룻뤄류륙률륭르른름릇릎리릭린림립릿마막만많말맑맘맙맛망맞맡맣매맥맨맵맺머먹먼멀멈멋멍멎메멘멩며면멸명몇모목몰몸몹못몽묘무묵묶문묻물뭄뭇뭐뭣므미민믿밀밉밌및밑바박밖반받발밝밟밤밥방밭배백뱀뱃뱉버번벌범법벗베벤벼벽변별볍병볕보복볶본볼봄봇봉뵈뵙부북분불붉붐붓붕붙뷰브블비빌빗빚빛빠빨빵빼뺨뻐뻔뻗뼈뽑뿌뿐쁘쁨사삭산살삶삼상새색샌생서석섞선설섬섭섯성세센셈셋션소속손솔솜솟송솥쇄쇠쇼수숙순술숨숫숲쉬쉽슈스슨슬슴습슷승시식신싣실싫심십싱싶싸싹쌀쌍쌓써썩썰썹쎄쏘쏟쑤쓰쓸씀씌씨씩씬씹씻아악안앉않알앓암압앗앙앞애액야약얇양얗얘어억언얹얻얼엄업없엇엉엌엎에엔엘여역연열엷염엽엿영옆예옛오옥온올옮옳옷와완왕왜왠외왼요욕용우욱운울움웃웅워원월웨웬위윗유육율으윽은을음응의이익인일읽잃임입잇있잊잎자작잔잖잘잠잡장잦재쟁저적전절젊점접젓정젖제젠젯져조족존졸좀좁종좋좌죄주죽준줄줌줍중쥐즈즉즌즐즘증지직진질짐집짓징짙짚짜짝짧째쨌쩌쩍쩐쪽쫓쭈쭉찌찍찢차착찬찮찰참창찾채책챔챙처척천철첫청체쳐초촉촌총촬최추축춘출춤춥춧충취츠측츰층치칙친칠침칭카칸칼캐캠커컨컬컴컵컷켓켜코콜콤콩쾌쿠퀴크큰클큼키킬타탁탄탈탑탓탕태택탤터턱털텅테텍텔템토톤톱통퇴투툼퉁튀튜트특튼튿틀틈티틱팀팅파팎판팔패팩팬퍼퍽페펴편펼평폐포폭표푸푹풀품풍퓨프플픔피픽필핏핑하학한할함합항해핵핸햄햇행향허헌험헤헬혀현혈협형혜호혹혼홀홍화확환활황회획횟효후훈훌훔훨휘휴흉흐흑흔흘흙흡흥흩희흰히힘',
-  telugu:
-    '0123456789!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZఁంఃఅఆఇఈఉఊఋఌఎఏఐఒఓఔకఖగఘఙచఛజఝఞటఠడఢణతథదధనపఫబభమయరఱలళవశషసహాిీుూృౄెేైొోౌ్ౠౡౢౣ',
-  kannada:
-    '0123456789!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZಂಃಅಆಇಈಉಊಋಎಏಐಒಓಔಕಖಗಘಙಚಛಜಝಞಟಠಡಢಣತಥದಧನಪಫಬಭಮಯರಲಳವಶಷಸಹಾಿೀುೂೃೆೇೈೊೋೌ್೦೧೨೩೪೫೬೭೮೯',
-};
-
-/**
- * Mapping of language codes to their corresponding symbol sets.
- */
-export const symbols = {
-  // Abaza
-  abq: alphabets.cyrillic,
-  // Adyghe
-  ady: alphabets.cyrillic,
-  // Africans
-  af: alphabets.latin,
-  // Avar
-  ava: alphabets.cyrillic,
-  // Azerbaijani
-  az: alphabets.latin,
-  // Belarusian
-  be: alphabets.cyrillic,
-  // Bulgarian
-  bg: alphabets.cyrillic,
-  // Bosnian
-  bs: alphabets.latin,
-  // Simplified Chinese
-  chSim: alphabets.zh_sim,
-  // Chechen
-  che: alphabets.cyrillic,
-  // Czech
-  cs: alphabets.latin,
-  // Welsh
-  cy: alphabets.latin,
-  // Danish
-  da: alphabets.latin,
-  // Dargwa
-  dar: alphabets.cyrillic,
-  // German
-  de: alphabets.latin,
-  // English
-  en: alphabets.english,
-  // Spanish
-  es: alphabets.latin,
-  // Estonian
-  et: alphabets.latin,
-  // French
-  fr: alphabets.latin,
-  // Irish
-  ga: alphabets.latin,
-  // Croatian
-  hr: alphabets.latin,
-  // Hungarian
-  hu: alphabets.latin,
-  // Indonesian
-  id: alphabets.latin,
-  // Ingush
-  inh: alphabets.cyrillic,
-  // Icelandic
-  ic: alphabets.latin,
-  // Italian
-  it: alphabets.latin,
-  // Japanese
-  ja: alphabets.japanese,
-  // Karbadian
-  kbd: alphabets.cyrillic,
-  // Kannada
-  kn: alphabets.kannada,
-  // Korean
-  ko: alphabets.korean,
-  // Kurdish
-  ku: alphabets.latin,
-  // Latin
-  la: alphabets.latin,
-  // Lak
-  lbe: alphabets.cyrillic,
-  // Lezghian
-  lez: alphabets.cyrillic,
-  // Lithuanian
-  lt: alphabets.latin,
-  // Latvian
-  lv: alphabets.latin,
-  // Maori
-  mi: alphabets.latin,
-  // Mongolian
-  mn: alphabets.cyrillic,
-  // Malay
-  ms: alphabets.latin,
-  // Maltese
-  mt: alphabets.latin,
-  // Dutch
-  nl: alphabets.latin,
-  // Norwegian
-  no: alphabets.latin,
-  // Occitan
-  oc: alphabets.latin,
-  // Pali
-  pi: alphabets.latin,
-  // Polish
-  pl: alphabets.latin,
-  // Portuguese
-  pt: alphabets.latin,
-  // Romanian
-  ro: alphabets.latin,
-  // Russian
-  ru: alphabets.cyrillic,
-  // Serbian (cyrillic)
-  rsCyrillic: alphabets.cyrillic,
-  // Serbian (latin)
-  rsLatin: alphabets.latin,
-  // Slovak
-  sk: alphabets.latin,
-  // Slovenian
-  sl: alphabets.latin,
-  // Albanian
-  sq: alphabets.latin,
-  // Swedish
-  sv: alphabets.latin,
-  // Swahili
-  sw: alphabets.latin,
-  // Tabassaran
-  tab: alphabets.cyrillic,
-  // Telugu
-  te: alphabets.telugu,
-  // Tajik
-  tjk: alphabets.cyrillic,
-  // Tagalog
-  tl: alphabets.latin,
-  // Turkish
-  tr: alphabets.latin,
-  // Ukrainian
-  uk: alphabets.cyrillic,
-  // Uzbek
-  uz: alphabets.latin,
-  // Vietnamese
-  vi: alphabets.latin,
-};
diff --git a/packages/react-native-executorch/src/constants/poseEstimation.ts b/packages/react-native-executorch/src/constants/poseEstimation.ts
deleted file mode 100644
index 6d3929e8ef..0000000000
--- a/packages/react-native-executorch/src/constants/poseEstimation.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-/**
- * Standard COCO keypoint enum (17 keypoints).
- * Use for type-safe keypoint access: `keypoints[CocoKeypoint.NOSE]`
- * @category Types
- */
-export enum CocoKeypoint {
-  NOSE = 0,
-  LEFT_EYE = 1,
-  RIGHT_EYE = 2,
-  LEFT_EAR = 3,
-  RIGHT_EAR = 4,
-  LEFT_SHOULDER = 5,
-  RIGHT_SHOULDER = 6,
-  LEFT_ELBOW = 7,
-  RIGHT_ELBOW = 8,
-  LEFT_WRIST = 9,
-  RIGHT_WRIST = 10,
-  LEFT_HIP = 11,
-  RIGHT_HIP = 12,
-  LEFT_KNEE = 13,
-  RIGHT_KNEE = 14,
-  LEFT_ANKLE = 15,
-  RIGHT_ANKLE = 16,
-}
diff --git a/packages/react-native-executorch/src/constants/privacyFilterLabels.ts b/packages/react-native-executorch/src/constants/privacyFilterLabels.ts
deleted file mode 100644
index 345889afdc..0000000000
--- a/packages/react-native-executorch/src/constants/privacyFilterLabels.ts
+++ /dev/null
@@ -1,288 +0,0 @@
-import { PrivacyFilterModelName } from '../types/privacyFilter';
-
-// BIOES tag scheme: 1 outside ("O") + 4 prefix variants × N entity types.
-// These arrays must match the model's id2label mapping exactly — the runner
-// uses index = label id, and labels[0] must be "O".
-
-/**
- * Label space for the openai/privacy-filter base model (8 entity types,
- * 33 labels).
- */
-export const PRIVACY_FILTER_OPENAI_LABELS = [
-  'O',
-  'B-account_number',
-  'I-account_number',
-  'E-account_number',
-  'S-account_number',
-  'B-private_address',
-  'I-private_address',
-  'E-private_address',
-  'S-private_address',
-  'B-private_date',
-  'I-private_date',
-  'E-private_date',
-  'S-private_date',
-  'B-private_email',
-  'I-private_email',
-  'E-private_email',
-  'S-private_email',
-  'B-private_person',
-  'I-private_person',
-  'E-private_person',
-  'S-private_person',
-  'B-private_phone',
-  'I-private_phone',
-  'E-private_phone',
-  'S-private_phone',
-  'B-private_url',
-  'I-private_url',
-  'E-private_url',
-  'S-private_url',
-  'B-secret',
-  'I-secret',
-  'E-secret',
-  'S-secret',
-] as const;
-
-/**
- * Label space for the OpenMed/privacy-filter-nemotron model (55 entity
- * types, 221 labels). Source:
- * https://huggingface.co/OpenMed/privacy-filter-nemotron/blob/main/config.json
- */
-export const PRIVACY_FILTER_NEMOTRON_LABELS = [
-  'O',
-  'B-account_number',
-  'I-account_number',
-  'E-account_number',
-  'S-account_number',
-  'B-age',
-  'I-age',
-  'E-age',
-  'S-age',
-  'B-api_key',
-  'I-api_key',
-  'E-api_key',
-  'S-api_key',
-  'B-bank_routing_number',
-  'I-bank_routing_number',
-  'E-bank_routing_number',
-  'S-bank_routing_number',
-  'B-biometric_identifier',
-  'I-biometric_identifier',
-  'E-biometric_identifier',
-  'S-biometric_identifier',
-  'B-blood_type',
-  'I-blood_type',
-  'E-blood_type',
-  'S-blood_type',
-  'B-certificate_license_number',
-  'I-certificate_license_number',
-  'E-certificate_license_number',
-  'S-certificate_license_number',
-  'B-city',
-  'I-city',
-  'E-city',
-  'S-city',
-  'B-company_name',
-  'I-company_name',
-  'E-company_name',
-  'S-company_name',
-  'B-coordinate',
-  'I-coordinate',
-  'E-coordinate',
-  'S-coordinate',
-  'B-country',
-  'I-country',
-  'E-country',
-  'S-country',
-  'B-county',
-  'I-county',
-  'E-county',
-  'S-county',
-  'B-credit_debit_card',
-  'I-credit_debit_card',
-  'E-credit_debit_card',
-  'S-credit_debit_card',
-  'B-customer_id',
-  'I-customer_id',
-  'E-customer_id',
-  'S-customer_id',
-  'B-cvv',
-  'I-cvv',
-  'E-cvv',
-  'S-cvv',
-  'B-date',
-  'I-date',
-  'E-date',
-  'S-date',
-  'B-date_of_birth',
-  'I-date_of_birth',
-  'E-date_of_birth',
-  'S-date_of_birth',
-  'B-date_time',
-  'I-date_time',
-  'E-date_time',
-  'S-date_time',
-  'B-device_identifier',
-  'I-device_identifier',
-  'E-device_identifier',
-  'S-device_identifier',
-  'B-education_level',
-  'I-education_level',
-  'E-education_level',
-  'S-education_level',
-  'B-email',
-  'I-email',
-  'E-email',
-  'S-email',
-  'B-employee_id',
-  'I-employee_id',
-  'E-employee_id',
-  'S-employee_id',
-  'B-employment_status',
-  'I-employment_status',
-  'E-employment_status',
-  'S-employment_status',
-  'B-fax_number',
-  'I-fax_number',
-  'E-fax_number',
-  'S-fax_number',
-  'B-first_name',
-  'I-first_name',
-  'E-first_name',
-  'S-first_name',
-  'B-gender',
-  'I-gender',
-  'E-gender',
-  'S-gender',
-  'B-health_plan_beneficiary_number',
-  'I-health_plan_beneficiary_number',
-  'E-health_plan_beneficiary_number',
-  'S-health_plan_beneficiary_number',
-  'B-http_cookie',
-  'I-http_cookie',
-  'E-http_cookie',
-  'S-http_cookie',
-  'B-ipv4',
-  'I-ipv4',
-  'E-ipv4',
-  'S-ipv4',
-  'B-ipv6',
-  'I-ipv6',
-  'E-ipv6',
-  'S-ipv6',
-  'B-language',
-  'I-language',
-  'E-language',
-  'S-language',
-  'B-last_name',
-  'I-last_name',
-  'E-last_name',
-  'S-last_name',
-  'B-license_plate',
-  'I-license_plate',
-  'E-license_plate',
-  'S-license_plate',
-  'B-mac_address',
-  'I-mac_address',
-  'E-mac_address',
-  'S-mac_address',
-  'B-medical_record_number',
-  'I-medical_record_number',
-  'E-medical_record_number',
-  'S-medical_record_number',
-  'B-national_id',
-  'I-national_id',
-  'E-national_id',
-  'S-national_id',
-  'B-occupation',
-  'I-occupation',
-  'E-occupation',
-  'S-occupation',
-  'B-password',
-  'I-password',
-  'E-password',
-  'S-password',
-  'B-phone_number',
-  'I-phone_number',
-  'E-phone_number',
-  'S-phone_number',
-  'B-pin',
-  'I-pin',
-  'E-pin',
-  'S-pin',
-  'B-political_view',
-  'I-political_view',
-  'E-political_view',
-  'S-political_view',
-  'B-postcode',
-  'I-postcode',
-  'E-postcode',
-  'S-postcode',
-  'B-race_ethnicity',
-  'I-race_ethnicity',
-  'E-race_ethnicity',
-  'S-race_ethnicity',
-  'B-religious_belief',
-  'I-religious_belief',
-  'E-religious_belief',
-  'S-religious_belief',
-  'B-sexuality',
-  'I-sexuality',
-  'E-sexuality',
-  'S-sexuality',
-  'B-ssn',
-  'I-ssn',
-  'E-ssn',
-  'S-ssn',
-  'B-state',
-  'I-state',
-  'E-state',
-  'S-state',
-  'B-street_address',
-  'I-street_address',
-  'E-street_address',
-  'S-street_address',
-  'B-swift_bic',
-  'I-swift_bic',
-  'E-swift_bic',
-  'S-swift_bic',
-  'B-tax_id',
-  'I-tax_id',
-  'E-tax_id',
-  'S-tax_id',
-  'B-time',
-  'I-time',
-  'E-time',
-  'S-time',
-  'B-unique_id',
-  'I-unique_id',
-  'E-unique_id',
-  'S-unique_id',
-  'B-url',
-  'I-url',
-  'E-url',
-  'S-url',
-  'B-user_name',
-  'I-user_name',
-  'E-user_name',
-  'S-user_name',
-  'B-vehicle_identifier',
-  'I-vehicle_identifier',
-  'E-vehicle_identifier',
-  'S-vehicle_identifier',
-] as const;
-
-/**
- * Per-model label list lookup for built-in privacy filter presets. The
- * runner resolves the label space from `modelName`; custom fine-tunes
- * bypass this map and pass their own list through
- * `PrivacyFilterModule.fromCustomModel`.
- */
-export const PRIVACY_FILTER_LABELS: Record<
-  PrivacyFilterModelName,
-  readonly string[]
-> = {
-  'privacy-filter-openai': PRIVACY_FILTER_OPENAI_LABELS,
-  'privacy-filter-nemotron': PRIVACY_FILTER_NEMOTRON_LABELS,
-};
diff --git a/packages/react-native-executorch/src/constants/resourceFetcher.ts b/packages/react-native-executorch/src/constants/resourceFetcher.ts
deleted file mode 100644
index 2ddf36fd11..0000000000
--- a/packages/react-native-executorch/src/constants/resourceFetcher.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-export { LIB_VERSION } from './versions';
-
-export const DOWNLOAD_EVENT_ENDPOINT =
-  'https://ai.swmansion.com/telemetry/downloads/api/downloads';
diff --git a/packages/react-native-executorch/src/constants/tts/models.ts b/packages/react-native-executorch/src/constants/tts/models.ts
deleted file mode 100644
index b21595e851..0000000000
--- a/packages/react-native-executorch/src/constants/tts/models.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import { URL_PREFIX, PREVIOUS_VERSION_TAG } from '../versions';
-
-// Text to speech (tts) - Kokoro model(s)
-const KOKORO_MODEL_ROOT = `${URL_PREFIX}-kokoro/${PREVIOUS_VERSION_TAG}/xnnpack`;
-const KOKORO_STANDARD_MODEL_ROOT = `${KOKORO_MODEL_ROOT}/standard`;
-const KOKORO_POLISH_MODEL_ROOT = `${KOKORO_MODEL_ROOT}/polish`;
-const KOKORO_GERMAN_MODEL_ROOT = `${KOKORO_MODEL_ROOT}/german`;
-
-/**
- * A standard Kokoro instance which processes the text in batches of maximum 128 tokens.
- * Works well with built-in languages: english, spanish, french, italian, portuguese and hindi.
- * @category Models - Text to Speech
- */
-export const KOKORO_STANDARD = {
-  modelName: 'kokoro' as const,
-  durationPredictorSource: `${KOKORO_STANDARD_MODEL_ROOT}/duration_predictor_std.pte`,
-  synthesizerSource: `${KOKORO_STANDARD_MODEL_ROOT}/synthesizer_std.pte`,
-};
-
-/**
- * A fine-tuned Kokoro instance for Polish.
- * @category Models - Text to Speech
- */
-export const KOKORO_POLISH = {
-  modelName: 'kokoro' as const,
-  durationPredictorSource: `${KOKORO_POLISH_MODEL_ROOT}/duration_predictor_pl.pte`,
-  synthesizerSource: `${KOKORO_POLISH_MODEL_ROOT}/synthesizer_pl.pte`,
-};
-
-/**
- * A fine-tuned Kokoro instance for German.
- * @category Models - Text to Speech
- */
-export const KOKORO_GERMAN = {
-  modelName: 'kokoro' as const,
-  durationPredictorSource: `${KOKORO_GERMAN_MODEL_ROOT}/duration_predictor_de.pte`,
-  synthesizerSource: `${KOKORO_GERMAN_MODEL_ROOT}/synthesizer_de.pte`,
-};
diff --git a/packages/react-native-executorch/src/constants/tts/voices.ts b/packages/react-native-executorch/src/constants/tts/voices.ts
deleted file mode 100644
index 4bf9c4f80d..0000000000
--- a/packages/react-native-executorch/src/constants/tts/voices.ts
+++ /dev/null
@@ -1,302 +0,0 @@
-import { TextToSpeechModelConfig } from '../../types/tts';
-import { PREVIOUS_VERSION_TAG, URL_PREFIX } from '../versions';
-import { KOKORO_STANDARD, KOKORO_POLISH, KOKORO_GERMAN } from './models';
-
-// Common prefixes - voices & phonemization data
-const KOKORO_VOICE_PREFIX = `${URL_PREFIX}-kokoro/${PREVIOUS_VERSION_TAG}/voices`;
-const KOKORO_PHONEMIZER_PREFIX = `${URL_PREFIX}-kokoro/${PREVIOUS_VERSION_TAG}/phonemizer`;
-
-const KOKORO_PHONEMIZER_EN_US_PREFIX = `${KOKORO_PHONEMIZER_PREFIX}/en-us`;
-const KOKORO_PHONEMIZER_EN_US_TAGGER = `${KOKORO_PHONEMIZER_EN_US_PREFIX}/tags.json`;
-const KOKORO_PHONEMIZER_EN_US_LEXICON = `${KOKORO_PHONEMIZER_EN_US_PREFIX}/lexicon.json`;
-const KOKORO_PHONEMIZER_EN_US_MODEL = `${KOKORO_PHONEMIZER_EN_US_PREFIX}/phonemizer_en_us.pte`;
-
-const KOKORO_PHONEMIZER_EN_GB_PREFIX = `${KOKORO_PHONEMIZER_PREFIX}/en-gb`;
-const KOKORO_PHONEMIZER_EN_GB_TAGGER = `${KOKORO_PHONEMIZER_EN_GB_PREFIX}/tags.json`;
-const KOKORO_PHONEMIZER_EN_GB_LEXICON = `${KOKORO_PHONEMIZER_EN_GB_PREFIX}/lexicon.json`;
-const KOKORO_PHONEMIZER_EN_GB_MODEL = `${KOKORO_PHONEMIZER_EN_GB_PREFIX}/phonemizer_en_gb.pte`;
-
-// French
-const KOKORO_PHONEMIZER_FR_PREFIX = `${KOKORO_PHONEMIZER_PREFIX}/fr`;
-const KOKORO_PHONEMIZER_FR_MODEL = `${KOKORO_PHONEMIZER_FR_PREFIX}/phonemizer_fr.pte`;
-
-// Spanish
-const KOKORO_PHONEMIZER_ES_PREFIX = `${KOKORO_PHONEMIZER_PREFIX}/es`;
-const KOKORO_PHONEMIZER_ES_MODEL = `${KOKORO_PHONEMIZER_ES_PREFIX}/phonemizer_es.pte`;
-
-// Italian
-const KOKORO_PHONEMIZER_IT_PREFIX = `${KOKORO_PHONEMIZER_PREFIX}/it`;
-const KOKORO_PHONEMIZER_IT_MODEL = `${KOKORO_PHONEMIZER_IT_PREFIX}/phonemizer_it.pte`;
-
-// Portuguese
-const KOKORO_PHONEMIZER_PT_PREFIX = `${KOKORO_PHONEMIZER_PREFIX}/pt`;
-const KOKORO_PHONEMIZER_PT_MODEL = `${KOKORO_PHONEMIZER_PT_PREFIX}/phonemizer_pt.pte`;
-
-// Hindi
-const KOKORO_PHONEMIZER_HI_PREFIX = `${KOKORO_PHONEMIZER_PREFIX}/hi`;
-const KOKORO_PHONEMIZER_HI_MODEL = `${KOKORO_PHONEMIZER_HI_PREFIX}/phonemizer_hi.pte`;
-
-// German
-const KOKORO_PHONEMIZER_DE_PREFIX = `${KOKORO_PHONEMIZER_PREFIX}/de`;
-const KOKORO_PHONEMIZER_DE_MODEL = `${KOKORO_PHONEMIZER_DE_PREFIX}/phonemizer_de.pte`;
-
-// Polish
-const KOKORO_PHONEMIZER_PL_PREFIX = `${KOKORO_PHONEMIZER_PREFIX}/pl`;
-const KOKORO_PHONEMIZER_PL_MODEL = `${KOKORO_PHONEMIZER_PL_PREFIX}/phonemizer_pl.pte`;
-
-// Kokoro voices
-/**
- * @category TTS Supported Voices
- */
-export const KOKORO_AMERICAN_ENGLISH_FEMALE_HEART = {
-  model: KOKORO_STANDARD,
-  voiceSource: `${KOKORO_VOICE_PREFIX}/af_heart.bin`,
-  phonemizerConfig: {
-    lang: 'en-us' as const,
-    taggerSource: KOKORO_PHONEMIZER_EN_US_TAGGER,
-    lexiconSource: KOKORO_PHONEMIZER_EN_US_LEXICON,
-    neuralModelSource: KOKORO_PHONEMIZER_EN_US_MODEL,
-  },
-} as TextToSpeechModelConfig;
-
-/**
- * @category TTS Supported Voices
- */
-export const KOKORO_AMERICAN_ENGLISH_FEMALE_RIVER = {
-  model: KOKORO_STANDARD,
-  voiceSource: `${KOKORO_VOICE_PREFIX}/af_river.bin`,
-  phonemizerConfig: {
-    lang: 'en-us' as const,
-    taggerSource: KOKORO_PHONEMIZER_EN_US_TAGGER,
-    lexiconSource: KOKORO_PHONEMIZER_EN_US_LEXICON,
-    neuralModelSource: KOKORO_PHONEMIZER_EN_US_MODEL,
-  },
-} as TextToSpeechModelConfig;
-
-/**
- * @category TTS Supported Voices
- */
-export const KOKORO_AMERICAN_ENGLISH_FEMALE_SARAH = {
-  model: KOKORO_STANDARD,
-  voiceSource: `${KOKORO_VOICE_PREFIX}/af_sarah.bin`,
-  phonemizerConfig: {
-    lang: 'en-us' as const,
-    taggerSource: KOKORO_PHONEMIZER_EN_US_TAGGER,
-    lexiconSource: KOKORO_PHONEMIZER_EN_US_LEXICON,
-    neuralModelSource: KOKORO_PHONEMIZER_EN_US_MODEL,
-  },
-} as TextToSpeechModelConfig;
-
-/**
- * @category TTS Supported Voices
- */
-export const KOKORO_AMERICAN_ENGLISH_MALE_ADAM = {
-  model: KOKORO_STANDARD,
-  voiceSource: `${KOKORO_VOICE_PREFIX}/am_adam.bin`,
-  phonemizerConfig: {
-    lang: 'en-us' as const,
-    taggerSource: KOKORO_PHONEMIZER_EN_US_TAGGER,
-    lexiconSource: KOKORO_PHONEMIZER_EN_US_LEXICON,
-    neuralModelSource: KOKORO_PHONEMIZER_EN_US_MODEL,
-  },
-} as TextToSpeechModelConfig;
-
-/**
- * @category TTS Supported Voices
- */
-export const KOKORO_AMERICAN_ENGLISH_MALE_MICHAEL = {
-  model: KOKORO_STANDARD,
-  voiceSource: `${KOKORO_VOICE_PREFIX}/am_michael.bin`,
-  phonemizerConfig: {
-    lang: 'en-us' as const,
-    taggerSource: KOKORO_PHONEMIZER_EN_US_TAGGER,
-    lexiconSource: KOKORO_PHONEMIZER_EN_US_LEXICON,
-    neuralModelSource: KOKORO_PHONEMIZER_EN_US_MODEL,
-  },
-} as TextToSpeechModelConfig;
-
-/**
- * @category TTS Supported Voices
- */
-export const KOKORO_AMERICAN_ENGLISH_MALE_SANTA = {
-  model: KOKORO_STANDARD,
-  voiceSource: `${KOKORO_VOICE_PREFIX}/am_santa.bin`,
-  phonemizerConfig: {
-    lang: 'en-us' as const,
-    taggerSource: KOKORO_PHONEMIZER_EN_US_TAGGER,
-    lexiconSource: KOKORO_PHONEMIZER_EN_US_LEXICON,
-    neuralModelSource: KOKORO_PHONEMIZER_EN_US_MODEL,
-  },
-} as TextToSpeechModelConfig;
-
-/**
- * @category TTS Supported Voices
- */
-export const KOKORO_BRITISH_ENGLISH_FEMALE_EMMA = {
-  model: KOKORO_STANDARD,
-  voiceSource: `${KOKORO_VOICE_PREFIX}/bf_emma.bin`,
-  phonemizerConfig: {
-    lang: 'en-gb' as const,
-    taggerSource: KOKORO_PHONEMIZER_EN_GB_TAGGER,
-    lexiconSource: KOKORO_PHONEMIZER_EN_GB_LEXICON,
-    neuralModelSource: KOKORO_PHONEMIZER_EN_GB_MODEL,
-  },
-} as TextToSpeechModelConfig;
-
-/**
- * @category TTS Supported Voices
- */
-export const KOKORO_BRITISH_ENGLISH_MALE_DANIEL = {
-  model: KOKORO_STANDARD,
-  voiceSource: `${KOKORO_VOICE_PREFIX}/bm_daniel.bin`,
-  phonemizerConfig: {
-    lang: 'en-gb' as const,
-    taggerSource: KOKORO_PHONEMIZER_EN_GB_TAGGER,
-    lexiconSource: KOKORO_PHONEMIZER_EN_GB_LEXICON,
-    neuralModelSource: KOKORO_PHONEMIZER_EN_GB_MODEL,
-  },
-} as TextToSpeechModelConfig;
-
-/**
- * @category TTS Supported Voices
- */
-export const KOKORO_FRENCH_FEMALE_SIWIS = {
-  model: KOKORO_STANDARD,
-  voiceSource: `${KOKORO_VOICE_PREFIX}/ff_siwis.bin`,
-  phonemizerConfig: {
-    lang: 'fr' as const,
-    neuralModelSource: KOKORO_PHONEMIZER_FR_MODEL,
-  },
-} as TextToSpeechModelConfig;
-
-/**
- * @category TTS Supported Voices
- */
-export const KOKORO_SPANISH_FEMALE_DORA = {
-  model: KOKORO_STANDARD,
-  voiceSource: `${KOKORO_VOICE_PREFIX}/ef_dora.bin`,
-  phonemizerConfig: {
-    lang: 'es' as const,
-    neuralModelSource: KOKORO_PHONEMIZER_ES_MODEL,
-  },
-} as TextToSpeechModelConfig;
-
-/**
- * @category TTS Supported Voices
- */
-export const KOKORO_SPANISH_MALE_ALEX = {
-  model: KOKORO_STANDARD,
-  voiceSource: `${KOKORO_VOICE_PREFIX}/em_alex.bin`,
-  phonemizerConfig: {
-    lang: 'es' as const,
-    neuralModelSource: KOKORO_PHONEMIZER_ES_MODEL,
-  },
-} as TextToSpeechModelConfig;
-
-/**
- * @category TTS Supported Voices
- */
-export const KOKORO_ITALIAN_FEMALE_SARA = {
-  model: KOKORO_STANDARD,
-  voiceSource: `${KOKORO_VOICE_PREFIX}/if_sara.bin`,
-  phonemizerConfig: {
-    lang: 'it' as const,
-    neuralModelSource: KOKORO_PHONEMIZER_IT_MODEL,
-  },
-} as TextToSpeechModelConfig;
-
-/**
- * @category TTS Supported Voices
- */
-export const KOKORO_ITALIAN_MALE_NICOLA = {
-  model: KOKORO_STANDARD,
-  voiceSource: `${KOKORO_VOICE_PREFIX}/im_nicola.bin`,
-  phonemizerConfig: {
-    lang: 'it' as const,
-    neuralModelSource: KOKORO_PHONEMIZER_IT_MODEL,
-  },
-} as TextToSpeechModelConfig;
-
-/**
- * @category TTS Supported Voices
- */
-export const KOKORO_PORTUGUESE_FEMALE_DORA = {
-  model: KOKORO_STANDARD,
-  voiceSource: `${KOKORO_VOICE_PREFIX}/pf_dora.bin`,
-  phonemizerConfig: {
-    lang: 'pt' as const,
-    neuralModelSource: KOKORO_PHONEMIZER_PT_MODEL,
-  },
-} as TextToSpeechModelConfig;
-
-/**
- * @category TTS Supported Voices
- */
-export const KOKORO_PORTUGUESE_MALE_SANTA = {
-  model: KOKORO_STANDARD,
-  voiceSource: `${KOKORO_VOICE_PREFIX}/pm_santa.bin`,
-  phonemizerConfig: {
-    lang: 'pt' as const,
-    neuralModelSource: KOKORO_PHONEMIZER_PT_MODEL,
-  },
-} as TextToSpeechModelConfig;
-
-/**
- * @category TTS Supported Voices
- */
-export const KOKORO_HINDI_FEMALE_ALPHA = {
-  model: KOKORO_STANDARD,
-  voiceSource: `${KOKORO_VOICE_PREFIX}/hf_alpha.bin`,
-  phonemizerConfig: {
-    lang: 'hi' as const,
-    neuralModelSource: KOKORO_PHONEMIZER_HI_MODEL,
-  },
-} as TextToSpeechModelConfig;
-
-/**
- * @category TTS Supported Voices
- */
-export const KOKORO_HINDI_MALE_OMEGA = {
-  model: KOKORO_STANDARD,
-  voiceSource: `${KOKORO_VOICE_PREFIX}/hm_omega.bin`,
-  phonemizerConfig: {
-    lang: 'hi' as const,
-    neuralModelSource: KOKORO_PHONEMIZER_HI_MODEL,
-  },
-} as TextToSpeechModelConfig;
-
-/**
- * @category TTS Supported Voices
- */
-export const KOKORO_HINDI_MALE_PSI = {
-  model: KOKORO_STANDARD,
-  voiceSource: `${KOKORO_VOICE_PREFIX}/hm_psi.bin`,
-  phonemizerConfig: {
-    lang: 'hi' as const,
-    neuralModelSource: KOKORO_PHONEMIZER_HI_MODEL,
-  },
-} as TextToSpeechModelConfig;
-
-/**
- * @category TTS Supported Voices
- */
-export const KOKORO_POLISH_MALE_MATEUSZ = {
-  model: KOKORO_POLISH,
-  voiceSource: `${KOKORO_VOICE_PREFIX}/pm_mateusz.bin`,
-  phonemizerConfig: {
-    lang: 'pl' as const,
-    neuralModelSource: KOKORO_PHONEMIZER_PL_MODEL,
-  },
-} as TextToSpeechModelConfig;
-
-/**
- * @category TTS Supported Voices
- */
-export const KOKORO_GERMAN_FEMALE_ANNA = {
-  model: KOKORO_GERMAN,
-  voiceSource: `${KOKORO_VOICE_PREFIX}/df_anna.bin`,
-  phonemizerConfig: {
-    lang: 'de' as const,
-    neuralModelSource: KOKORO_PHONEMIZER_DE_MODEL,
-  },
-} as TextToSpeechModelConfig;
diff --git a/packages/react-native-executorch/src/constants/versions.ts b/packages/react-native-executorch/src/constants/versions.ts
deleted file mode 100644
index 1674a69d10..0000000000
--- a/packages/react-native-executorch/src/constants/versions.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-const PREVIOUS_LIB_VERSION = '0.9.0';
-export const LIB_VERSION = '0.10.0';
-
-export const URL_PREFIX =
-  'https://huggingface.co/software-mansion/react-native-executorch';
-// Latest stable release. Use for back-compat references that should follow
-// the last published version rather than the in-development VERSION_TAG.
-export const PREVIOUS_VERSION_TAG = `resolve/v${PREVIOUS_LIB_VERSION}`;
-// In-development version; resolves to whatever LIB_VERSION on main currently
-// targets. Models served under this tag may not be published yet.
-export const VERSION_TAG = `resolve/v${LIB_VERSION}`;
diff --git a/packages/react-native-executorch/src/controllers/BaseOCRController.ts b/packages/react-native-executorch/src/controllers/BaseOCRController.ts
deleted file mode 100644
index 5bc13b6545..0000000000
--- a/packages/react-native-executorch/src/controllers/BaseOCRController.ts
+++ /dev/null
@@ -1,162 +0,0 @@
-import { Logger } from '../common/Logger';
-import { symbols } from '../constants/ocr/symbols';
-import { RnExecutorchErrorCode } from '../errors/ErrorCodes';
-import { RnExecutorchError, parseUnknownError } from '../errors/errorUtils';
-import { isPixelData } from '../modules/computer_vision/VisionModule';
-import { Frame, PixelData, ResourceSource } from '../types/common';
-import { OCRLanguage, OCRDetection } from '../types/ocr';
-import { ResourceFetcher } from '../utils/ResourceFetcher';
-
-export abstract class BaseOCRController {
-  protected nativeModule: any;
-  public isReady: boolean = false;
-  public isGenerating: boolean = false;
-  public error: RnExecutorchError | null = null;
-  protected isReadyCallback: (isReady: boolean) => void;
-  protected isGeneratingCallback: (isGenerating: boolean) => void;
-  protected errorCallback: (error: RnExecutorchError) => void;
-
-  constructor({
-    isReadyCallback = (_isReady: boolean) => {},
-    isGeneratingCallback = (_isGenerating: boolean) => {},
-    errorCallback = (_error: RnExecutorchError) => {},
-  } = {}) {
-    this.isReadyCallback = isReadyCallback;
-    this.isGeneratingCallback = isGeneratingCallback;
-    this.errorCallback = errorCallback;
-  }
-
-  protected abstract loadNativeModule(
-    detectorPath: string,
-    recognizerPath: string,
-    language: OCRLanguage,
-    extraParams?: any
-  ): Promise<any>;
-
-  protected internalLoad = async (
-    detectorSource: ResourceSource,
-    recognizerSource: ResourceSource,
-    language: OCRLanguage,
-    onDownloadProgressCallback?: (downloadProgress: number) => void,
-    extraParams?: any
-  ) => {
-    try {
-      if (!detectorSource || !recognizerSource) return;
-
-      if (!symbols[language]) {
-        throw new RnExecutorchError(
-          RnExecutorchErrorCode.LanguageNotSupported,
-          'The provided language for OCR is not supported. Please try using other language.'
-        );
-      }
-
-      this.isReady = false;
-      this.isReadyCallback(false);
-
-      const paths = await ResourceFetcher.fetch(
-        onDownloadProgressCallback,
-        detectorSource,
-        recognizerSource
-      );
-      if (paths === null || paths.length < 2) {
-        throw new RnExecutorchError(RnExecutorchErrorCode.DownloadInterrupted);
-      }
-      this.nativeModule = await this.loadNativeModule(
-        paths[0]!,
-        paths[1]!,
-        language,
-        extraParams
-      );
-      this.isReady = true;
-      this.isReadyCallback(this.isReady);
-    } catch (e) {
-      if (
-        e &&
-        typeof e === 'object' &&
-        'code' in e &&
-        e.code === RnExecutorchErrorCode.ResourceFetcherAdapterNotInitialized
-      ) {
-        Logger.error('Load failed:', e);
-      } else if (this.errorCallback) {
-        this.errorCallback(parseUnknownError(e));
-      } else {
-        throw parseUnknownError(e);
-      }
-    }
-  };
-
-  get runOnFrame():
-    | ((frame: Frame, isFrontCamera: boolean) => OCRDetection[])
-    | null {
-    if (!this.isReady) {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.ModuleNotLoaded,
-        'The model is currently not loaded. Please load the model before calling runOnFrame().'
-      );
-    }
-
-    const nativeGenerateFromFrame = this.nativeModule.generateFromFrame;
-
-    return (frame: Frame, isFrontCamera: boolean): OCRDetection[] => {
-      'worklet';
-
-      let nativeBuffer: { pointer: bigint; release(): void } | null = null;
-      try {
-        nativeBuffer = frame.getNativeBuffer();
-        const frameData = {
-          nativeBuffer: nativeBuffer.pointer,
-          orientation: frame.orientation,
-          isMirrored: isFrontCamera,
-        };
-        return nativeGenerateFromFrame(frameData);
-      } finally {
-        if (nativeBuffer?.release) {
-          nativeBuffer.release();
-        }
-      }
-    };
-  }
-
-  public forward = async (
-    input: string | PixelData
-  ): Promise<OCRDetection[]> => {
-    if (!this.isReady) {
-      throw new RnExecutorchError(RnExecutorchErrorCode.ModuleNotLoaded);
-    }
-    if (this.isGenerating) {
-      throw new RnExecutorchError(RnExecutorchErrorCode.ModelGenerating);
-    }
-
-    try {
-      this.isGenerating = true;
-      this.isGeneratingCallback(this.isGenerating);
-
-      if (typeof input === 'string') {
-        return await this.nativeModule.generateFromString(input);
-      } else if (isPixelData(input)) {
-        return await this.nativeModule.generateFromPixels(input);
-      } else {
-        throw new RnExecutorchError(
-          RnExecutorchErrorCode.InvalidArgument,
-          'Invalid input: expected string path or PixelData object. For VisionCamera frames, use runOnFrame instead.'
-        );
-      }
-    } catch (e) {
-      throw parseUnknownError(e);
-    } finally {
-      this.isGenerating = false;
-      this.isGeneratingCallback(this.isGenerating);
-    }
-  };
-
-  public delete() {
-    if (this.isGenerating) {
-      throw new RnExecutorchError(RnExecutorchErrorCode.ModelGenerating);
-    }
-    if (this.nativeModule) {
-      this.nativeModule.unload();
-    }
-    this.isReadyCallback(false);
-    this.isGeneratingCallback(false);
-  }
-}
diff --git a/packages/react-native-executorch/src/controllers/LLMController.ts b/packages/react-native-executorch/src/controllers/LLMController.ts
deleted file mode 100644
index 4385ca909b..0000000000
--- a/packages/react-native-executorch/src/controllers/LLMController.ts
+++ /dev/null
@@ -1,557 +0,0 @@
-import { ResourceFetcher } from '../utils/ResourceFetcher';
-import { Template } from '@huggingface/jinja';
-import { DEFAULT_CHAT_CONFIG } from '../constants/llmDefaults';
-import {
-  AudioConfig,
-  ChatConfig,
-  GenerationConfig,
-  LLMModel,
-  LLMTool,
-  Message,
-  SPECIAL_TOKENS,
-  ToolsConfig,
-} from '../types/llm';
-import { parseToolCall } from '../utils/llm';
-import { Logger } from '../common/Logger';
-import { RnExecutorchError, parseUnknownError } from '../errors/errorUtils';
-import { RnExecutorchErrorCode } from '../errors/ErrorCodes';
-
-export class LLMController {
-  private nativeModule: any;
-  private chatConfig: ChatConfig = DEFAULT_CHAT_CONFIG;
-  private toolsConfig: ToolsConfig | undefined;
-  private tokenizerConfig: any;
-  private onToken?: (token: string) => void;
-  private _isReady = false;
-  private _isGenerating = false;
-  private _messageHistory: Message[] = [];
-  // User callbacks
-  private tokenCallback: (token: string) => void;
-  private messageHistoryCallback: (messageHistory: Message[]) => void;
-  private isReadyCallback: (isReady: boolean) => void;
-  private isGeneratingCallback: (isGenerating: boolean) => void;
-  private audioConfig: AudioConfig | undefined;
-
-  constructor({
-    tokenCallback,
-    messageHistoryCallback,
-    isReadyCallback,
-    isGeneratingCallback,
-  }: {
-    tokenCallback?: (token: string) => void;
-    messageHistoryCallback?: (messageHistory: Message[]) => void;
-    isReadyCallback?: (isReady: boolean) => void;
-    isGeneratingCallback?: (isGenerating: boolean) => void;
-  }) {
-    this.tokenCallback = (token) => {
-      tokenCallback?.(token);
-    };
-    this.messageHistoryCallback = (messageHistory) => {
-      this._messageHistory = messageHistory;
-      messageHistoryCallback?.(messageHistory);
-    };
-    this.isReadyCallback = (isReady) => {
-      this._isReady = isReady;
-      isReadyCallback?.(isReady);
-    };
-    this.isGeneratingCallback = (isGenerating) => {
-      this._isGenerating = isGenerating;
-      isGeneratingCallback?.(isGenerating);
-    };
-  }
-
-  public get isReady() {
-    return this._isReady;
-  }
-
-  public get isGenerating() {
-    return this._isGenerating;
-  }
-
-  public get messageHistory() {
-    return this._messageHistory;
-  }
-
-  public async load({
-    model,
-    onDownloadProgressCallback,
-  }: {
-    model: LLMModel;
-    onDownloadProgressCallback?: (downloadProgress: number) => void;
-  }) {
-    // reset inner state when loading new model
-    this.messageHistoryCallback(this.chatConfig.initialMessageHistory);
-    this.isGeneratingCallback(false);
-    this.isReadyCallback(false);
-
-    try {
-      const tokenizersPromise = ResourceFetcher.fetch(
-        undefined,
-        model.tokenizerSource,
-        model.tokenizerConfigSource
-      );
-
-      const modelPromise = ResourceFetcher.fetch(
-        onDownloadProgressCallback,
-        model.modelSource
-      );
-
-      const [tokenizersResults, modelResult] = await Promise.all([
-        tokenizersPromise,
-        modelPromise,
-      ]);
-
-      const tokenizerPath = tokenizersResults?.[0];
-      const tokenizerConfigPath = tokenizersResults?.[1];
-      const modelPath = modelResult?.[0];
-
-      if (!tokenizerPath || !tokenizerConfigPath || !modelPath) {
-        throw new RnExecutorchError(RnExecutorchErrorCode.DownloadInterrupted);
-      }
-
-      this.tokenizerConfig = JSON.parse(
-        await ResourceFetcher.fs.readAsString(tokenizerConfigPath!)
-      );
-
-      if (this.nativeModule) {
-        this.nativeModule.unload();
-      }
-
-      this.audioConfig = model.audioConfig;
-
-      this.nativeModule = await global.loadLLM(
-        modelPath,
-        tokenizerPath,
-        model.capabilities ?? []
-      );
-      if (model.generationConfig) {
-        // Apply model-specific recommended sampling defaults before flipping
-        // isReady so callers that react to it see the right config on first
-        // send. User-provided `configure()` calls still override these.
-        this.applyGenerationConfig(model.generationConfig);
-      }
-      this.isReadyCallback(true);
-      this.onToken = (data: string) => {
-        if (!data) {
-          return;
-        }
-
-        const filtered = this.filterSpecialTokens(data);
-
-        if (filtered.length === 0) {
-          return;
-        }
-        this.tokenCallback(filtered);
-      };
-    } catch (e) {
-      Logger.error('Load failed:', e);
-      this.isReadyCallback(false);
-      throw parseUnknownError(e);
-    }
-  }
-
-  public setTokenCallback(tokenCallback: (token: string) => void) {
-    this.tokenCallback = tokenCallback;
-  }
-
-  public configure({
-    chatConfig,
-    toolsConfig,
-    generationConfig,
-  }: {
-    chatConfig?: Partial<ChatConfig>;
-    toolsConfig?: ToolsConfig;
-    generationConfig?: GenerationConfig;
-  }) {
-    this.chatConfig = { ...DEFAULT_CHAT_CONFIG, ...chatConfig };
-    this.toolsConfig = toolsConfig;
-
-    if (generationConfig) {
-      this.applyGenerationConfig(generationConfig);
-    }
-
-    // reset inner state when loading new configuration
-    this.messageHistoryCallback(this.chatConfig.initialMessageHistory);
-    this.isGeneratingCallback(false);
-  }
-
-  private applyGenerationConfig(generationConfig: GenerationConfig) {
-    if (generationConfig.outputTokenBatchSize) {
-      this.nativeModule.setCountInterval(generationConfig.outputTokenBatchSize);
-    }
-    if (generationConfig.batchTimeInterval) {
-      this.nativeModule.setTimeInterval(generationConfig.batchTimeInterval);
-    }
-    if (generationConfig.temperature !== undefined) {
-      this.nativeModule.setTemperature(generationConfig.temperature);
-    }
-    // `topp` is the legacy spelling kept for backwards compatibility — `topP`
-    // wins when both are set so callers migrating to the new name don't get
-    // surprised by stale values. Reading the deprecated alias is intentional.
-    const topP = generationConfig.topP ?? generationConfig.topp;
-    if (topP !== undefined) {
-      if (topP < 0 || topP > 1) {
-        throw new RnExecutorchError(
-          RnExecutorchErrorCode.InvalidConfig,
-          'Top P has to be in range [0, 1]'
-        );
-      }
-      this.nativeModule.setTopp(topP);
-    }
-    if (generationConfig.minP !== undefined) {
-      if (generationConfig.minP < 0 || generationConfig.minP > 1) {
-        throw new RnExecutorchError(
-          RnExecutorchErrorCode.InvalidConfig,
-          'Min P has to be in range [0, 1]'
-        );
-      }
-      this.nativeModule.setMinP(generationConfig.minP);
-    }
-    if (generationConfig.repetitionPenalty !== undefined) {
-      if (generationConfig.repetitionPenalty < 0) {
-        throw new RnExecutorchError(
-          RnExecutorchErrorCode.InvalidConfig,
-          'Repetition penalty must be non-negative'
-        );
-      }
-      this.nativeModule.setRepetitionPenalty(
-        generationConfig.repetitionPenalty
-      );
-    }
-  }
-
-  private getImageToken(): string {
-    const token = this.tokenizerConfig.image_token;
-    if (!token) {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.InvalidConfig,
-        "Tokenizer config is missing 'image_token'. Vision models require tokenizerConfigSource with an 'image_token' field."
-      );
-    }
-    return token;
-  }
-
-  private getAudioToken(): string {
-    const token = this.tokenizerConfig.audio_token;
-    if (!token) {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.InvalidConfig,
-        "Tokenizer config is missing 'audio_token'. Audio-capable models require tokenizerConfigSource with an 'audio_token' field."
-      );
-    }
-    return token;
-  }
-
-  private filterSpecialTokens(text: string): string {
-    let filtered = text;
-    if (
-      SPECIAL_TOKENS.EOS_TOKEN in this.tokenizerConfig &&
-      this.tokenizerConfig.eos_token
-    ) {
-      filtered = filtered.replaceAll(this.tokenizerConfig.eos_token, '');
-    }
-    if (
-      SPECIAL_TOKENS.EOT_TOKEN in this.tokenizerConfig &&
-      this.tokenizerConfig.eot_token
-    ) {
-      filtered = filtered.replaceAll(this.tokenizerConfig.eot_token, '');
-    }
-    if (
-      SPECIAL_TOKENS.PAD_TOKEN in this.tokenizerConfig &&
-      this.tokenizerConfig.pad_token
-    ) {
-      filtered = filtered.replaceAll(this.tokenizerConfig.pad_token, '');
-    }
-    return filtered;
-  }
-
-  public delete() {
-    if (this._isGenerating) {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.ModelGenerating,
-        'You cannot delete the model now. You need to interrupt it first.'
-      );
-    }
-
-    this.onToken = () => {};
-    if (this.nativeModule) {
-      this.nativeModule.unload();
-    }
-    this.isReadyCallback(false);
-    this.isGeneratingCallback(false);
-  }
-
-  public async forward(
-    input: string,
-    imagePaths?: string[],
-    audioWaveforms?: Float32Array[]
-  ): Promise<string> {
-    if (!this._isReady) {
-      throw new RnExecutorchError(RnExecutorchErrorCode.ModuleNotLoaded);
-    }
-    if (this._isGenerating) {
-      throw new RnExecutorchError(RnExecutorchErrorCode.ModelGenerating);
-    }
-    const hasImages = !!imagePaths && imagePaths.length > 0;
-    const hasAudio = !!audioWaveforms && audioWaveforms.length > 0;
-    try {
-      this.isGeneratingCallback(true);
-      this.nativeModule.reset();
-      let response: string;
-      if (hasImages || hasAudio) {
-        response = await this.nativeModule.generateMultimodal(
-          input,
-          this.onToken,
-          {
-            imagePaths: hasImages ? imagePaths!.map(normalizeImagePath) : null,
-            imageToken: hasImages ? this.getImageToken() : null,
-            audioWaveforms: hasAudio ? audioWaveforms! : null,
-            audioToken: hasAudio ? this.getAudioToken() : null,
-          }
-        );
-      } else {
-        response = await this.nativeModule.generate(input, this.onToken);
-      }
-      return this.filterSpecialTokens(response);
-    } catch (e) {
-      throw parseUnknownError(e);
-    } finally {
-      this.isGeneratingCallback(false);
-    }
-  }
-
-  public interrupt() {
-    if (!this.nativeModule) {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.ModuleNotLoaded,
-        "Cannot interrupt a model that's not loaded."
-      );
-    }
-    this.nativeModule.interrupt();
-  }
-
-  public getGeneratedTokenCount(): number {
-    if (!this.nativeModule) {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.ModuleNotLoaded,
-        "Cannot get token count for a model that's not loaded."
-      );
-    }
-    return this.nativeModule.getGeneratedTokenCount();
-  }
-
-  public getPromptTokenCount(): number {
-    if (!this.nativeModule) {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.ModuleNotLoaded,
-        "Cannot get prompt token count for a model that's not loaded."
-      );
-    }
-    return this.nativeModule.getPromptTokenCount();
-  }
-
-  public getTotalTokenCount(): number {
-    return this.getGeneratedTokenCount() + this.getPromptTokenCount();
-  }
-
-  public async generate(
-    messages: Message[],
-    tools?: LLMTool[]
-  ): Promise<string> {
-    if (!this._isReady) {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.ModuleNotLoaded,
-        'The model is currently not loaded. Please load the model before calling generate().'
-      );
-    }
-    if (messages.length === 0) {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.InvalidUserInput,
-        'Messages array is empty!'
-      );
-    }
-    if (messages[0] && messages[0].role !== 'system') {
-      Logger.warn(
-        `You are not providing system prompt. You can pass it in the first message using { role: 'system', content: YOUR_PROMPT }. Otherwise prompt from your model's chat template will be used.`
-      );
-    }
-
-    const imagePaths = messages
-      .filter((m) => m.mediaPath)
-      .map((m) => m.mediaPath!);
-    const audioWaveforms = messages
-      .filter((m) => m.audioWaveform)
-      .map((m) => m.audioWaveform!);
-    const renderedChat: string = this.applyChatTemplate(
-      messages,
-      this.tokenizerConfig,
-      tools,
-      { tools_in_user_message: false, add_generation_prompt: true }
-    );
-
-    return await this.forward(
-      renderedChat,
-      imagePaths.length > 0 ? imagePaths : undefined,
-      audioWaveforms.length > 0 ? audioWaveforms : undefined
-    );
-  }
-
-  public async sendMessage(
-    message: string,
-    media?: { imagePath?: string; audioBuffer?: Float32Array }
-  ): Promise<string> {
-    const mediaPath = media?.imagePath;
-    const audioBuffer = media?.audioBuffer;
-    const newMessage: Message = {
-      content: message,
-      role: 'user',
-      ...(mediaPath ? { mediaPath } : {}),
-      ...(audioBuffer ? { audioWaveform: audioBuffer } : {}),
-    };
-    const updatedHistory = [...this._messageHistory, newMessage];
-    this.messageHistoryCallback(updatedHistory);
-
-    const visualTokenCount = this.nativeModule.getVisualTokenCount();
-    const countTokensCallback = (messages: Message[]) => {
-      const rendered = this.applyChatTemplate(
-        messages,
-        this.tokenizerConfig,
-        this.toolsConfig?.tools,
-        { tools_in_user_message: false, add_generation_prompt: true }
-      );
-      const textTokens = this.nativeModule.countTextTokens(rendered);
-      const imageCount = messages.filter((m) => m.mediaPath).length;
-      // Audio soft-token expansion: audio_encoder pads samples to
-      // multiples of this.audioConfig.samplesPerBlock (7680 @ 16 kHz) and emits
-      // this.audioConfig.tokensPerBlock (~12) soft tokens per padded block. The
-      // rendered template only contributes 1 token for the audio placeholder,
-      // so add (expansion - 1) per audio message to match prefill consumption.
-      const audioTokenExpansion = messages.reduce((acc, m) => {
-        if (!m.audioWaveform) return acc;
-        const kBlocks = Math.max(
-          1,
-          Math.ceil(m.audioWaveform.length / this.audioConfig!.samplesPerBlock)
-        );
-        return acc + (this.audioConfig!.tokensPerBlock * kBlocks - 1);
-      }, 0);
-      return (
-        textTokens + imageCount * (visualTokenCount - 1) + audioTokenExpansion
-      );
-    };
-    const maxContextLength = this.nativeModule.getMaxContextLength();
-    const messageHistoryWithPrompt =
-      this.chatConfig.contextStrategy.buildContext(
-        this.chatConfig.systemPrompt,
-        updatedHistory,
-        maxContextLength,
-        countTokensCallback
-      );
-
-    const response = await this.generate(
-      messageHistoryWithPrompt,
-      this.toolsConfig?.tools
-    );
-
-    if (!this.toolsConfig || this.toolsConfig.displayToolCalls) {
-      this.messageHistoryCallback([
-        ...this._messageHistory,
-        { content: response, role: 'assistant' },
-      ]);
-    }
-
-    if (this.toolsConfig) {
-      try {
-        const toolCalls = parseToolCall(response);
-        for (const toolCall of toolCalls) {
-          const toolResponse =
-            await this.toolsConfig.executeToolCallback(toolCall);
-          if (toolResponse != null) {
-            this.messageHistoryCallback([
-              ...this._messageHistory,
-              { content: toolResponse, role: 'assistant' },
-            ]);
-          }
-        }
-      } catch (e) {
-        throw parseUnknownError(e);
-      }
-    }
-
-    return response;
-  }
-
-  public deleteMessage(index: number) {
-    // we delete referenced message and all messages after it
-    // so the model responses that used them are deleted as well
-    const newMessageHistory = this._messageHistory.slice(0, index);
-
-    this.messageHistoryCallback(newMessageHistory);
-  }
-
-  private applyChatTemplate(
-    messages: Message[],
-    tokenizerConfig: any,
-    tools?: LLMTool[],
-    templateFlags?: Object
-  ): string {
-    if (!tokenizerConfig.chat_template) {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.TokenizerError,
-        "Tokenizer config doesn't include chat_template"
-      );
-    }
-    const template = new Template(tokenizerConfig.chat_template);
-
-    const specialTokens = Object.fromEntries(
-      Object.values(SPECIAL_TOKENS)
-        .filter((key) => key in tokenizerConfig)
-        .map((key) => [key, tokenizerConfig[key]])
-    );
-
-    const result = template.render({
-      messages: messagesForChatTemplate(messages),
-      tools,
-      ...templateFlags,
-      ...specialTokens,
-    });
-    return result;
-  }
-}
-
-/**
- * The native multimodal pipeline expects image paths to be `file://` URIs.
- * `ResourceFetcher.fetch` and most platform file APIs return raw filesystem
- * paths without that prefix, so callers routinely pass either form. Accept
- * both and normalize to the prefixed form here.
- * @param path - Local image path, either with or without the `file://` prefix.
- * @returns The same path with a `file://` prefix.
- */
-function normalizeImagePath(path: string): string {
-  return path.startsWith('file://') ? path : `file://${path}`;
-}
-
-/**
- * Multimodal chat templates expect message content for image-bearing turns
- * to be an array of content parts with an `image` part as a placeholder.
- * Callers of `LLMController.generate` and `LLMController.sendMessage` pass
- * messages with a plain string `content` plus an optional `mediaPath`; this
- * helper rewrites them into the structured form that the template engine
- * understands.
- * @param messages - Messages to prepare for the chat template engine.
- * @returns Messages with image-bearing turns rewritten to structured content.
- */
-function messagesForChatTemplate(messages: Message[]): any[] {
-  return messages.map((m) => {
-    if (typeof m.content !== 'string') return m;
-    const hasImage = !!m.mediaPath;
-    const hasAudio = !!m.audioWaveform;
-    if (!hasImage && !hasAudio) return m;
-    const parts: any[] = [];
-    if (hasImage) parts.push({ type: 'image' });
-    if (hasAudio) parts.push({ type: 'audio' });
-    parts.push({ type: 'text', text: m.content });
-    // Drop the Float32Array on the clone only — passing it into the Jinja
-    // template engine slows render past 3s. Don't mutate m;
-    return { ...m, content: parts, audioWaveform: undefined };
-  });
-}
diff --git a/packages/react-native-executorch/src/controllers/OCRController.ts b/packages/react-native-executorch/src/controllers/OCRController.ts
deleted file mode 100644
index 19cfd9230c..0000000000
--- a/packages/react-native-executorch/src/controllers/OCRController.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { symbols } from '../constants/ocr/symbols';
-import { ResourceSource } from '../types/common';
-import { OCRLanguage } from '../types/ocr';
-import { BaseOCRController } from './BaseOCRController';
-
-export class OCRController extends BaseOCRController {
-  protected async loadNativeModule(
-    detectorPath: string,
-    recognizerPath: string,
-    language: OCRLanguage
-  ): Promise<any> {
-    return await global.loadOCR(
-      detectorPath,
-      recognizerPath,
-      symbols[language]
-    );
-  }
-
-  public load = async (
-    detectorSource: ResourceSource,
-    recognizerSource: ResourceSource,
-    language: OCRLanguage,
-    onDownloadProgressCallback?: (downloadProgress: number) => void
-  ) => {
-    await this.internalLoad(
-      detectorSource,
-      recognizerSource,
-      language,
-      onDownloadProgressCallback
-    );
-  };
-}
diff --git a/packages/react-native-executorch/src/controllers/VerticalOCRController.ts b/packages/react-native-executorch/src/controllers/VerticalOCRController.ts
deleted file mode 100644
index b94e2ff6c8..0000000000
--- a/packages/react-native-executorch/src/controllers/VerticalOCRController.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import { symbols } from '../constants/ocr/symbols';
-import { ResourceSource } from '../types/common';
-import { OCRLanguage } from '../types/ocr';
-import { BaseOCRController } from './BaseOCRController';
-
-export class VerticalOCRController extends BaseOCRController {
-  protected async loadNativeModule(
-    detectorPath: string,
-    recognizerPath: string,
-    language: OCRLanguage,
-    independentCharacters?: boolean
-  ): Promise<any> {
-    return await global.loadVerticalOCR(
-      detectorPath,
-      recognizerPath,
-      symbols[language],
-      independentCharacters
-    );
-  }
-
-  public load = async (
-    detectorSource: ResourceSource,
-    recognizerSource: ResourceSource,
-    language: OCRLanguage,
-    independentCharacters: boolean,
-    onDownloadProgressCallback: (downloadProgress: number) => void
-  ) => {
-    await this.internalLoad(
-      detectorSource,
-      recognizerSource,
-      language,
-      onDownloadProgressCallback,
-      independentCharacters
-    );
-  };
-}
diff --git a/packages/react-native-executorch/src/core/model.ts b/packages/react-native-executorch/src/core/model.ts
new file mode 100644
index 0000000000..d0ff2f3a24
--- /dev/null
+++ b/packages/react-native-executorch/src/core/model.ts
@@ -0,0 +1,60 @@
+import { rnexecutorchJsi } from '../native/bridge';
+import type { DType, Tensor } from './tensor';
+
+declare const modelBrand: unique symbol;
+
+export type ModelInput = Tensor | number | boolean | null;
+export type ModelOutput = Tensor | number | boolean | null;
+export type TensorMeta = {
+  name: string;
+  ndim: number;
+  nbytes: number;
+  dtype: DType;
+  shape: number[];
+};
+
+export type ExecuTorchTag =
+  | 'None'
+  | 'Tensor'
+  | 'Int'
+  | 'Double'
+  | 'Bool'
+  | 'String'
+  | 'ListBool'
+  | 'ListDouble'
+  | 'ListInt'
+  | 'ListTensor';
+
+export type ModelMethodMeta = {
+  name: string;
+  numInputs: number;
+  numOutputs: number;
+  inputTags: ExecuTorchTag[];
+  outputTags: ExecuTorchTag[];
+  usesBackend: Record<string, boolean>;
+  inputTensorMeta: TensorMeta[];
+  outputTensorMeta: TensorMeta[];
+};
+
+export interface Model {
+  readonly path: string;
+  getMethodNames(): string[];
+  getMethodMeta(methodName: string): ModelMethodMeta;
+  execute(
+    methodName: string,
+    inputs: ModelInput[],
+    outputTensors: Tensor[]
+  ): ModelOutput[];
+  dispose(): void;
+
+  /**
+   * Prevents plain JS objects from being cast as Models.
+   * @internal
+   */
+  readonly [modelBrand]: never;
+}
+
+export function loadModel(modelPath: string): Model {
+  'worklet';
+  return rnexecutorchJsi.loadModel(modelPath) as Model;
+}
diff --git a/packages/react-native-executorch/src/core/modelSchema.ts b/packages/react-native-executorch/src/core/modelSchema.ts
new file mode 100644
index 0000000000..7f6e6d924b
--- /dev/null
+++ b/packages/react-native-executorch/src/core/modelSchema.ts
@@ -0,0 +1,145 @@
+import { type DType } from './tensor';
+import {
+  type Model,
+  type ExecuTorchTag,
+  type ModelMethodMeta,
+  type TensorMeta,
+} from './model';
+
+export type SymbolicShape = readonly (number | string)[];
+export type TensorConstraint = {
+  readonly dtype?: DType;
+  readonly shapes?: readonly SymbolicShape[];
+};
+
+export function SymbolicTensor(
+  dtype?: DType,
+  ...shapes: readonly SymbolicShape[]
+): TensorConstraint {
+  return { dtype, shapes };
+}
+
+const primitiveTagMap = {
+  number: ['Int', 'Double'] as ExecuTorchTag[],
+  boolean: ['Bool'] as ExecuTorchTag[],
+  null: ['None'] as ExecuTorchTag[],
+} as const;
+
+export type ValueConstraint = keyof typeof primitiveTagMap | TensorConstraint;
+
+export function matchShape(
+  actual: number[],
+  ...expected: readonly SymbolicShape[]
+): boolean {
+  return expected.some((shape) => {
+    if (actual.length !== shape.length) return false;
+    const symbolMap = new Map<string, number>();
+    return shape.every((dim, i) => {
+      const act = actual[i]!;
+      if (typeof dim === 'number') return act === dim;
+      if (symbolMap.has(dim)) return symbolMap.get(dim) === act;
+      symbolMap.set(dim, act);
+      return true;
+    });
+  });
+}
+
+// TODO: Implement cross-tensor symbol validation (e.g. enforcing that 'N' or
+// 'H' has the same value across different input/output tensors). Note that a
+// proper implementation will require backtracking/solving when multiple tensors
+// have multiple alternative shapes. For now, we just check that each tensor
+// individually matches at least one of its expected shapes, without enforcing
+// consistency of symbolic dimensions across tensors, only within each tensor.
+function validateTags(
+  side: 'input' | 'output',
+  expected: readonly ValueConstraint[],
+  actualTags: ExecuTorchTag[],
+  tensorMetas: TensorMeta[]
+) {
+  const numTensors = expected.filter((t) => typeof t === 'object').length;
+  if (tensorMetas.length !== numTensors)
+    throw new Error(
+      `${side} tensor count mismatch: expected ${numTensors}, got ${tensorMetas.length}`
+    );
+
+  let tIdx = 0;
+  expected.forEach((exp, i) => {
+    const act = actualTags[i]!;
+    if (typeof exp === 'string') {
+      if (!primitiveTagMap[exp].includes(act)) {
+        throw new Error(
+          `${side}[${i}]: expected primitive '${exp}', got '${act}'`
+        );
+      }
+    } else {
+      if (act !== 'Tensor') {
+        throw new Error(
+          `${side}[${i}]: expected Tensor, got primitive '${act}'`
+        );
+      }
+      const tMeta = tensorMetas[tIdx++]!;
+      if (exp.dtype && tMeta.dtype !== exp.dtype) {
+        throw new Error(
+          `${side}[${i}]: dtype mismatch: expected '${exp.dtype}', got '${tMeta.dtype}'`
+        );
+      }
+      if (exp.shapes?.length && !matchShape(tMeta.shape, ...exp.shapes)) {
+        const expectedShapesStr = exp.shapes
+          .map((s) => `[${s.join(',')}]`)
+          .join('|');
+        throw new Error(
+          `${side}[${i}]: shape mismatch: expected shape matching ${expectedShapesStr}, got [${tMeta.shape.join(',')}]`
+        );
+      }
+    }
+  });
+}
+
+export function validateModelSchema(
+  model: Model,
+  methodName: string,
+  expectedInputs: readonly ValueConstraint[],
+  expectedOutputs: readonly ValueConstraint[]
+): ModelMethodMeta {
+  if (!model.getMethodNames().includes(methodName))
+    throw new Error(`signature validation: '${methodName}' method not found`);
+
+  const meta = model.getMethodMeta(methodName);
+
+  const formatError = (errorMsg: string) => {
+    return (
+      `signature validation failed for '${methodName}': ${errorMsg}\n` +
+      `  Expected: ${JSON.stringify(expectedInputs)} -> ${JSON.stringify(expectedOutputs)}\n` +
+      `  Actual:   [${meta.inputTags.join(', ')}] -> [${meta.outputTags.join(', ')}] (metas: ${JSON.stringify(meta.inputTensorMeta)} -> ${JSON.stringify(meta.outputTensorMeta)})`
+    );
+  };
+
+  if (meta.inputTags.length !== expectedInputs.length) {
+    throw new Error(
+      formatError(
+        `input count mismatch: expected ${expectedInputs.length}, got ${meta.inputTags.length}`
+      )
+    );
+  }
+  if (meta.outputTags.length !== expectedOutputs.length) {
+    throw new Error(
+      formatError(
+        `output count mismatch: expected ${expectedOutputs.length}, got ${meta.outputTags.length}`
+      )
+    );
+  }
+
+  try {
+    validateTags('input', expectedInputs, meta.inputTags, meta.inputTensorMeta);
+    validateTags(
+      'output',
+      expectedOutputs,
+      meta.outputTags,
+      meta.outputTensorMeta
+    );
+  } catch (e: any) {
+    throw new Error(formatError(e.message));
+  }
+
+  return meta;
+}
diff --git a/packages/react-native-executorch/src/core/runtime.ts b/packages/react-native-executorch/src/core/runtime.ts
new file mode 100644
index 0000000000..1bbd9a9872
--- /dev/null
+++ b/packages/react-native-executorch/src/core/runtime.ts
@@ -0,0 +1,32 @@
+import {
+  createWorkletRuntime,
+  runOnRuntimeAsync,
+  type WorkletRuntime,
+} from 'react-native-worklets';
+
+export const defaultWorkletRuntime = createWorkletRuntime({
+  name: 'ExecuTorchDefaultRuntime',
+});
+
+export function wrapAsync<Args extends any[], R>(
+  fn: (...args: Args) => R,
+  runtime: WorkletRuntime = defaultWorkletRuntime
+) {
+  return async (...args: Args): Promise<R> => {
+    const result = await runOnRuntimeAsync(
+      runtime,
+      (argsArray) => {
+        'worklet';
+        try {
+          return { ok: true, value: fn(...argsArray) };
+        } catch (e: any) {
+          return { ok: false, error: e?.message ?? String(e) };
+        }
+      },
+      args
+    );
+
+    if (!result.ok) throw new Error(result.error);
+    return result.value!;
+  };
+}
diff --git a/packages/react-native-executorch/src/core/tensor.ts b/packages/react-native-executorch/src/core/tensor.ts
new file mode 100644
index 0000000000..303affc048
--- /dev/null
+++ b/packages/react-native-executorch/src/core/tensor.ts
@@ -0,0 +1,42 @@
+import { rnexecutorchJsi } from '../native/bridge';
+
+declare const tensorBrand: unique symbol;
+
+export type DType = 'float32' | 'uint8' | 'int32';
+export type Tensor = {
+  readonly dtype: DType;
+  readonly shape: readonly number[];
+  readonly numel: number;
+
+  copyTo(dst: Tensor): Tensor;
+  dispose(): void;
+  setData(src: Float32Array | Uint8Array | Int32Array): Tensor;
+  getData<T extends Float32Array | Uint8Array | Int32Array>(dst: T): T;
+  through<R, Args extends any[]>(
+    fn: (t: Tensor, ...args: Args) => R,
+    ...args: Args
+  ): R;
+  throughIf<Args extends any[]>(
+    pred: boolean,
+    fn: (t: Tensor, ...args: Args) => Tensor,
+    ...args: Args
+  ): Tensor;
+
+  /**
+   * Prevents plain JS objects from being cast as Tensors. Tensors should only
+   * be created via the `tensor` function exported from this module.
+   * @internal
+   */
+  readonly [tensorBrand]: never;
+};
+
+export function tensor(
+  dtype: DType,
+  shape: number[],
+  src?: Float32Array | Uint8Array | Int32Array
+): Tensor {
+  'worklet';
+  const t: Tensor = rnexecutorchJsi.createTensor(shape, dtype);
+  if (src) t.setData(src);
+  return t;
+}
diff --git a/packages/react-native-executorch/src/errors/ErrorCodes.ts b/packages/react-native-executorch/src/errors/ErrorCodes.ts
deleted file mode 100644
index f0b4f96de4..0000000000
--- a/packages/react-native-executorch/src/errors/ErrorCodes.ts
+++ /dev/null
@@ -1,197 +0,0 @@
-// Auto-generated from scripts/errors.config.ts
-// DO NOT EDIT MANUALLY - Run 'yarn codegen:errors' to regenerate
-
-export enum RnExecutorchErrorCode {
-  /**
-   * An umbrella-error that is thrown usually when something unexpected happens, for example a 3rd-party library error.
-   */
-  UnknownError = 101,
-  /**
-   * Thrown when a user tries to run a model that is not yet downloaded or loaded into memory.
-   */
-  ModuleNotLoaded = 102,
-  /**
-   * An error ocurred when saving a file. This could be, for instance a result image from an image model.
-   */
-  FileWriteFailed = 103,
-  /**
-   * Thrown when a user tries to run a model that is currently processing. It is only allowed to run a single model prediction at a time.
-   */
-  ModelGenerating = 104,
-  /**
-   * Thrown when a language is passed to a multi-language model that is not supported. For example OCR or Speech To Text.
-   */
-  LanguageNotSupported = 105,
-  /**
-   * Thrown when config parameters passed to a model are invalid. For example, when LLM's topp is outside of range [0, 1].
-   */
-  InvalidConfig = 112,
-  /**
-   * Thrown when React Native ExecuTorch threadpool problem occurs.
-   */
-  ThreadPoolError = 113,
-  /**
-   * Thrown when a file read operation failed. This could be invalid image url passed to image models, or unsupported format.
-   */
-  FileReadFailed = 114,
-  /**
-   * Thrown when the size of model output is unexpected. If you're using your custom model with any of the pre-defined modules, please verify docs or source code for the expected model I/O contract.
-   */
-  InvalidModelOutput = 115,
-  /**
-   * Thrown when the dimensions of input tensors don't match the model's expected dimensions.
-   */
-  WrongDimensions = 116,
-  /**
-   * Thrown when the input passed to our APIs is invalid, for example when passing an empty message array to LLM's generate().
-   */
-  InvalidUserInput = 117,
-  /**
-   * Thrown when the number of downloaded files is unexpected, due to download interruptions.
-   */
-  DownloadInterrupted = 118,
-  /**
-   * Thrown when a feature or platform is not supported in the current environment.
-   */
-  PlatformNotSupported = 119,
-  /**
-   * Thrown when the type of model source passed by the user is invalid.
-   */
-  InvalidModelSource = 120,
-  /**
-   * Thrown when the number of passed inputs to the model is different than the model metadata specifies. If you're using your custom model with any of the pre-defined modules, please verify docs or source code for the expected model I/O contract.
-   */
-  UnexpectedNumInputs = 121,
-  /**
-   * Thrown when an error occurs with the tokenizer or tokenization process.
-   */
-  TokenizerError = 122,
-  /**
-   * Thrown when there's a configuration mismatch between multilingual and language settings in Speech-to-Text models.
-   */
-  MultilingualConfiguration = 160,
-  /**
-   * Thrown when streaming transcription is attempted but audio data chunk is missing.
-   */
-  MissingDataChunk = 161,
-  /**
-   * Thrown when trying to stop or insert data into a stream that hasn't been started.
-   */
-  StreamingNotStarted = 162,
-  /**
-   * Thrown when trying to start a new streaming session while another is already in progress.
-   */
-  StreamingInProgress = 163,
-  /**
-   * Thrown when a resource fails to download. This could be due to invalid URL, or for example a network problem.
-   */
-  ResourceFetcherDownloadFailed = 180,
-  /**
-   * Thrown when a user tries to trigger a download that's already in progress.
-   */
-  ResourceFetcherDownloadInProgress = 181,
-  /**
-   * Thrown when trying to pause a download that is already paused.
-   */
-  ResourceFetcherAlreadyPaused = 182,
-  /**
-   * Thrown when trying to resume a download that is already ongoing.
-   */
-  ResourceFetcherAlreadyOngoing = 183,
-  /**
-   * Thrown when trying to pause, resume, or cancel a download that is not active.
-   */
-  ResourceFetcherNotActive = 184,
-  /**
-   * Thrown when required URI information is missing for a download operation.
-   */
-  ResourceFetcherMissingUri = 185,
-  /**
-   * Thrown when trying to load resources without fetcher initialization.
-   */
-  ResourceFetcherAdapterNotInitialized = 186,
-  /**
-   * Thrown when the platform does not support the resource fetching feature, which is required for downloading models and other resources in React Native ExecuTorch.
-   */
-  ResourceFetcherPlatformNotSupported = 187,
-  /**
-   * Thrown when the Expo resource fetcher entry point is incompatible with the installed expo-file-system version. The default entry point requires the new Directory/File API (Expo SDK 56+); use the `/legacy` entry point on older SDKs.
-   */
-  ResourceFetcherFileSystemApiUnavailable = 188,
-  /**
-   * Status indicating a successful operation.
-   */
-  Ok = 0,
-  /**
-   * An internal error occurred.
-   */
-  Internal = 1,
-  /**
-   * Status indicating the executor is in an invalid state for a targeted operation.
-   */
-  InvalidState = 2,
-  /**
-   * Status indicating there are no more steps of execution to run
-   */
-  EndOfMethod = 3,
-  /**
-   * Status indicating a resource has already been loaded.
-   */
-  AlreadyLoaded = 4,
-  /**
-   * Operation is not supported in the current context.
-   */
-  NotSupported = 16,
-  /**
-   * Operation is not yet implemented.
-   */
-  NotImplemented = 17,
-  /**
-   * User provided an invalid argument.
-   */
-  InvalidArgument = 18,
-  /**
-   * Object is an invalid type for the operation.
-   */
-  InvalidType = 19,
-  /**
-   * Operator(s) missing in the operator registry.
-   */
-  OperatorMissing = 20,
-  /**
-   * Requested resource could not be found.
-   */
-  NotFound = 32,
-  /**
-   * Could not allocate the requested memory.
-   */
-  MemoryAllocationFailed = 33,
-  /**
-   * Could not access a resource.
-   */
-  AccessFailed = 34,
-  /**
-   * Error caused by the contents of a program.
-   */
-  InvalidProgram = 35,
-  /**
-   * Error caused by the contents of external data.
-   */
-  InvalidExternalData = 36,
-  /**
-   * Does not have enough resources to perform the requested operation.
-   */
-  OutOfResources = 37,
-  /**
-   * Init stage: Backend receives an incompatible delegate version.
-   */
-  DelegateInvalidCompatibility = 48,
-  /**
-   * Init stage: Backend fails to allocate memory.
-   */
-  DelegateMemoryAllocationFailed = 49,
-  /**
-   * Execute stage: The handle is invalid.
-   */
-  DelegateInvalidHandle = 50,
-}
diff --git a/packages/react-native-executorch/src/errors/errorUtils.ts b/packages/react-native-executorch/src/errors/errorUtils.ts
deleted file mode 100644
index 2768ab706b..0000000000
--- a/packages/react-native-executorch/src/errors/errorUtils.ts
+++ /dev/null
@@ -1,83 +0,0 @@
-import { RnExecutorchErrorCode } from './ErrorCodes';
-
-/**
- * Default user-facing message for error codes that are thrown verbatim from
- * multiple call sites. When a code is listed here, the `message` argument to
- * {@link RnExecutorchError} can be omitted.
- */
-const DefaultErrorMessages: { [code: number]: string } = {
-  [RnExecutorchErrorCode.DownloadInterrupted]:
-    'The download has been interrupted. As a result, not every file was downloaded. Please retry the download.',
-  [RnExecutorchErrorCode.ModelGenerating]:
-    'The model is currently generating. Please wait until previous model run is complete.',
-  [RnExecutorchErrorCode.ModuleNotLoaded]:
-    'The model is currently not loaded. Please load the model before calling forward().',
-};
-
-/**
- * Custom error class for React Native ExecuTorch errors.
- */
-export class RnExecutorchError extends Error {
-  /**
-   * The error code representing the type of error.
-   *
-   * Typed as `RnExecutorchErrorCode | number` because codes are defined in
-   * `scripts/errors.config.ts` and generated into both the C++ and the TS
-   * sources. If those generated files drift, a code emitted on one side may
-   * not exist in the enum on the other and flows through as a raw number.
-   * Consumers switching on `code` should always include a `default` branch.
-   */
-  public code: RnExecutorchErrorCode | number;
-
-  /**
-   * The original cause of the error, if any.
-   */
-  public cause?: unknown;
-
-  constructor(
-    code: RnExecutorchErrorCode | number,
-    message?: string,
-    cause?: unknown
-  ) {
-    const resolved =
-      message ??
-      DefaultErrorMessages[code] ??
-      `RnExecutorch error: ${RnExecutorchErrorCode[code] ?? `code ${code}`}`;
-    super(resolved);
-    this.code = code;
-    this.message = resolved;
-    this.cause = cause;
-  }
-}
-
-function isRnExecutorchErrorLike(
-  e: unknown
-): e is { code: number; message: string } {
-  const candidate = e as Record<string, unknown>;
-
-  return (
-    typeof e === 'object' &&
-    e !== null &&
-    typeof candidate.code === 'number' &&
-    typeof candidate.message === 'string'
-  );
-}
-
-export function parseUnknownError(e: unknown): RnExecutorchError {
-  if (e instanceof RnExecutorchError) {
-    return e;
-  }
-  if (isRnExecutorchErrorLike(e)) {
-    return new RnExecutorchError(e.code, e.message);
-  }
-
-  if (e instanceof Error) {
-    return new RnExecutorchError(RnExecutorchErrorCode.Internal, e.message, e);
-  }
-
-  if (typeof e === 'string') {
-    return new RnExecutorchError(RnExecutorchErrorCode.Internal, e);
-  }
-
-  return new RnExecutorchError(RnExecutorchErrorCode.Internal, String(e));
-}
diff --git a/packages/react-native-executorch/src/hooks/computer_vision/useClassification.ts b/packages/react-native-executorch/src/hooks/computer_vision/useClassification.ts
deleted file mode 100644
index abb649d413..0000000000
--- a/packages/react-native-executorch/src/hooks/computer_vision/useClassification.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-import {
-  ClassificationModule,
-  ClassificationLabels,
-} from '../../modules/computer_vision/ClassificationModule';
-import {
-  ClassificationModelSources,
-  ClassificationProps,
-  ClassificationType,
-} from '../../types/classification';
-import { PixelData } from '../../types/common';
-import { useModuleFactory } from '../useModuleFactory';
-
-/**
- * React hook for managing a Classification model instance.
- * @typeParam C - A {@link ClassificationModelSources} config specifying which built-in model to load.
- * @category Hooks
- * @param props - Configuration object containing `model` source and optional `preventLoad` flag.
- * @returns Ready to use Classification model.
- */
-export const useClassification = <C extends ClassificationModelSources>({
-  model,
-  preventLoad = false,
-}: ClassificationProps<C>): ClassificationType<
-  ClassificationLabels<C['modelName']>
-> => {
-  const {
-    error,
-    isReady,
-    isGenerating,
-    downloadProgress,
-    runForward,
-    runOnFrame,
-  } = useModuleFactory({
-    factory: (config, onProgress) =>
-      ClassificationModule.fromModelName(config, onProgress),
-    config: model,
-    deps: [model.modelName, model.modelSource],
-    preventLoad,
-  });
-
-  const forward = (input: string | PixelData) =>
-    runForward((inst) => inst.forward(input));
-
-  return {
-    error,
-    isReady,
-    isGenerating,
-    downloadProgress,
-    forward,
-    runOnFrame,
-  };
-};
diff --git a/packages/react-native-executorch/src/hooks/computer_vision/useImageEmbeddings.ts b/packages/react-native-executorch/src/hooks/computer_vision/useImageEmbeddings.ts
deleted file mode 100644
index 84c2a5cbbc..0000000000
--- a/packages/react-native-executorch/src/hooks/computer_vision/useImageEmbeddings.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-import { ImageEmbeddingsModule } from '../../modules/computer_vision/ImageEmbeddingsModule';
-import {
-  ImageEmbeddingsProps,
-  ImageEmbeddingsType,
-} from '../../types/imageEmbeddings';
-import { PixelData } from '../../types/common';
-import { useModuleFactory } from '../useModuleFactory';
-
-/**
- * React hook for managing an Image Embeddings model instance.
- * @category Hooks
- * @param ImageEmbeddingsProps - Configuration object containing `model` source and optional `preventLoad` flag.
- * @returns Ready to use Image Embeddings model.
- */
-export const useImageEmbeddings = ({
-  model,
-  preventLoad = false,
-}: ImageEmbeddingsProps): ImageEmbeddingsType => {
-  const {
-    error,
-    isReady,
-    isGenerating,
-    downloadProgress,
-    runForward,
-    runOnFrame,
-  } = useModuleFactory({
-    factory: (config, onProgress) =>
-      ImageEmbeddingsModule.fromModelName(config, onProgress),
-    config: model,
-    deps: [model.modelName, model.modelSource],
-    preventLoad,
-  });
-
-  const forward = (imageSource: string | PixelData) =>
-    runForward((inst) => inst.forward(imageSource));
-
-  return {
-    error,
-    isReady,
-    isGenerating,
-    downloadProgress,
-    forward,
-    runOnFrame,
-  };
-};
diff --git a/packages/react-native-executorch/src/hooks/computer_vision/useInstanceSegmentation.ts b/packages/react-native-executorch/src/hooks/computer_vision/useInstanceSegmentation.ts
deleted file mode 100644
index ab63912fae..0000000000
--- a/packages/react-native-executorch/src/hooks/computer_vision/useInstanceSegmentation.ts
+++ /dev/null
@@ -1,78 +0,0 @@
-import {
-  InstanceSegmentationModule,
-  InstanceSegmentationLabels,
-} from '../../modules/computer_vision/InstanceSegmentationModule';
-import {
-  InstanceSegmentationProps,
-  InstanceSegmentationType,
-  InstanceSegmentationModelSources,
-} from '../../types/instanceSegmentation';
-import { useModuleFactory } from '../useModuleFactory';
-
-/**
- * React hook for managing an Instance Segmentation model instance.
- * @typeParam C - A {@link InstanceSegmentationModelSources} config specifying which model to load.
- * @param props - Configuration object containing `model` config and optional `preventLoad` flag.
- * @returns An object with model state (`error`, `isReady`, `isGenerating`, `downloadProgress`), a typed `forward` function, `getAvailableInputSizes` helper, and a `runOnFrame` worklet for VisionCamera integration.
- * @example
- * ```tsx
- * const { isReady, isGenerating, forward, error, downloadProgress, getAvailableInputSizes, runOnFrame } =
- *   useInstanceSegmentation({
- *     model: {
- *       modelName: 'yolo26n-seg',
- *       modelSource: 'https://huggingface.co/.../yolo26n-seg.pte',
- *     },
- *   });
- *
- * if (!isReady) {
- *   return <Text>Loading: {(downloadProgress * 100).toFixed(0)}%</Text>;
- * }
- *
- * const results = await forward('path/to/image.jpg', {
- *   confidenceThreshold: 0.5,
- *   inputSize: 640,
- * });
- * ```
- * @category Hooks
- */
-export const useInstanceSegmentation = <
-  C extends InstanceSegmentationModelSources,
->({
-  model,
-  preventLoad = false,
-}: InstanceSegmentationProps<C>): InstanceSegmentationType<
-  InstanceSegmentationLabels<C['modelName']>
-> => {
-  const {
-    error,
-    isReady,
-    isGenerating,
-    downloadProgress,
-    runForward,
-    instance,
-    runOnFrame,
-  } = useModuleFactory({
-    factory: (config, onProgress) =>
-      InstanceSegmentationModule.fromModelName(config, onProgress),
-    config: model,
-    deps: [model.modelName, model.modelSource],
-    preventLoad,
-  });
-
-  const forward: InstanceSegmentationType<
-    InstanceSegmentationLabels<C['modelName']>
-  >['forward'] = (imageSource, options) =>
-    runForward((inst) => inst.forward(imageSource, options));
-
-  const getAvailableInputSizes = () => instance?.getAvailableInputSizes();
-
-  return {
-    error,
-    isReady,
-    isGenerating,
-    downloadProgress,
-    forward,
-    getAvailableInputSizes,
-    runOnFrame,
-  };
-};
diff --git a/packages/react-native-executorch/src/hooks/computer_vision/useOCR.ts b/packages/react-native-executorch/src/hooks/computer_vision/useOCR.ts
deleted file mode 100644
index 516c08b49f..0000000000
--- a/packages/react-native-executorch/src/hooks/computer_vision/useOCR.ts
+++ /dev/null
@@ -1,78 +0,0 @@
-import { useCallback, useEffect, useState } from 'react';
-import { Frame, PixelData } from '../../types/common';
-import { OCRController } from '../../controllers/OCRController';
-import { RnExecutorchError } from '../../errors/errorUtils';
-import { OCRDetection, OCRProps, OCRType } from '../../types/ocr';
-
-/**
- * React hook for managing an OCR instance.
- * @category Hooks
- * @param OCRProps - Configuration object containing `model` sources and optional `preventLoad` flag.
- * @returns Ready to use OCR model.
- */
-export const useOCR = ({ model, preventLoad = false }: OCRProps): OCRType => {
-  const [isReady, setIsReady] = useState(false);
-  const [isGenerating, setIsGenerating] = useState(false);
-  const [downloadProgress, setDownloadProgress] = useState(0);
-  const [error, setError] = useState<RnExecutorchError | null>(null);
-  const [runOnFrame, setRunOnFrame] = useState<
-    ((frame: Frame, isFrontCamera: boolean) => OCRDetection[]) | null
-  >(null);
-
-  const [controller] = useState(
-    () =>
-      new OCRController({
-        isReadyCallback: setIsReady,
-        isGeneratingCallback: setIsGenerating,
-        errorCallback: setError,
-      })
-  );
-
-  useEffect(() => {
-    setDownloadProgress(0);
-    setError(null);
-
-    if (preventLoad) return;
-
-    controller
-      .load(
-        model.detectorSource,
-        model.recognizerSource,
-        model.language,
-        setDownloadProgress
-      )
-      .then(() => {
-        const worklet = controller.runOnFrame;
-        if (worklet) setRunOnFrame(() => worklet);
-      });
-
-    return () => {
-      setRunOnFrame(null);
-      if (controller.isReady) {
-        controller.delete();
-      }
-    };
-  }, [
-    controller,
-    model.modelName,
-    model.detectorSource,
-    model.recognizerSource,
-    model.language,
-    preventLoad,
-  ]);
-
-  const forward = useCallback(
-    (imageSource: string | PixelData): Promise<OCRDetection[]> =>
-      controller.forward(imageSource),
-    [controller]
-  );
-
-  return {
-    error,
-    isReady,
-    isGenerating,
-    forward,
-    downloadProgress,
-    runOnFrame,
-  };
-};
diff --git a/packages/react-native-executorch/src/hooks/computer_vision/useObjectDetection.ts b/packages/react-native-executorch/src/hooks/computer_vision/useObjectDetection.ts
deleted file mode 100644
index cc5d69e42a..0000000000
--- a/packages/react-native-executorch/src/hooks/computer_vision/useObjectDetection.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-import {
-  ObjectDetectionModule,
-  ObjectDetectionLabels,
-} from '../../modules/computer_vision/ObjectDetectionModule';
-import {
-  ObjectDetectionModelSources,
-  ObjectDetectionProps,
-  ObjectDetectionType,
-  ObjectDetectionOptions,
-} from '../../types/objectDetection';
-import { PixelData } from '../../types/common';
-import { useModuleFactory } from '../useModuleFactory';
-
-/**
- * React hook for managing an Object Detection model instance.
- * @typeParam C - A {@link ObjectDetectionModelSources} config specifying which built-in model to load.
- * @category Hooks
- * @param props - Configuration object containing `model` config and optional `preventLoad` flag.
- * @returns An object with model state (`error`, `isReady`, `isGenerating`, `downloadProgress`) and typed `forward` and `runOnFrame` functions.
- */
-export const useObjectDetection = <C extends ObjectDetectionModelSources>({
-  model,
-  preventLoad = false,
-}: ObjectDetectionProps<C>): ObjectDetectionType<
-  ObjectDetectionLabels<C['modelName']>
-> => {
-  const {
-    error,
-    isReady,
-    isGenerating,
-    downloadProgress,
-    runForward,
-    runOnFrame,
-    instance,
-  } = useModuleFactory({
-    factory: (config, onProgress) =>
-      ObjectDetectionModule.fromModelName(config, onProgress),
-    config: model,
-    deps: [model.modelName, model.modelSource],
-    preventLoad,
-  });
-
-  const forward = (
-    input: string | PixelData,
-    options?: ObjectDetectionOptions<ObjectDetectionLabels<C['modelName']>>
-  ) => runForward((inst) => inst.forward(input, options));
-
-  const getAvailableInputSizes = () =>
-    instance?.getAvailableInputSizes() ?? undefined;
-
-  return {
-    error,
-    isReady,
-    isGenerating,
-    downloadProgress,
-    forward,
-    runOnFrame,
-    getAvailableInputSizes,
-  };
-};
diff --git a/packages/react-native-executorch/src/hooks/computer_vision/usePoseEstimation.ts b/packages/react-native-executorch/src/hooks/computer_vision/usePoseEstimation.ts
deleted file mode 100644
index 2eda27deaa..0000000000
--- a/packages/react-native-executorch/src/hooks/computer_vision/usePoseEstimation.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-import {
-  PoseEstimationModule,
-  PoseEstimationKeypoints,
-} from '../../modules/computer_vision/PoseEstimationModule';
-import {
-  PoseEstimationModelSources,
-  PoseEstimationProps,
-  PoseEstimationType,
-  PoseEstimationOptions,
-} from '../../types/poseEstimation';
-import { PixelData } from '../../types/common';
-import { useModuleFactory } from '../useModuleFactory';
-
-/**
- * React hook for managing a Pose Estimation model instance.
- * @typeParam C - A {@link PoseEstimationModelSources} config specifying which built-in model to load.
- * @category Hooks
- * @param props - Configuration object containing `model` config and optional `preventLoad` flag.
- * @returns An object with model state (`error`, `isReady`, `isGenerating`, `downloadProgress`) and typed `forward` and `runOnFrame` functions.
- */
-export const usePoseEstimation = <C extends PoseEstimationModelSources>({
-  model,
-  preventLoad = false,
-}: PoseEstimationProps<C>): PoseEstimationType<
-  PoseEstimationKeypoints<C['modelName']>
-> => {
-  const {
-    error,
-    isReady,
-    isGenerating,
-    downloadProgress,
-    runForward,
-    runOnFrame,
-    instance,
-  } = useModuleFactory({
-    factory: (config, onProgress) =>
-      PoseEstimationModule.fromModelName(config, onProgress),
-    config: model,
-    deps: [model.modelName, model.modelSource],
-    preventLoad,
-  });
-
-  const forward = (
-    input: string | PixelData,
-    options?: PoseEstimationOptions
-  ) => runForward((inst) => inst.forward(input, options));
-
-  const getAvailableInputSizes = () =>
-    instance?.getAvailableInputSizes() ?? undefined;
-
-  return {
-    error,
-    isReady,
-    isGenerating,
-    downloadProgress,
-    forward,
-    runOnFrame,
-    getAvailableInputSizes,
-  };
-};
diff --git a/packages/react-native-executorch/src/hooks/computer_vision/useSemanticSegmentation.ts b/packages/react-native-executorch/src/hooks/computer_vision/useSemanticSegmentation.ts
deleted file mode 100644
index 6b9309f7ff..0000000000
--- a/packages/react-native-executorch/src/hooks/computer_vision/useSemanticSegmentation.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-import { PixelData } from '../..';
-import {
-  SemanticSegmentationModule,
-  SegmentationLabels,
-} from '../../modules/computer_vision/SemanticSegmentationModule';
-import {
-  SemanticSegmentationProps,
-  SemanticSegmentationType,
-  ModelNameOf,
-  SemanticSegmentationModelSources,
-} from '../../types/semanticSegmentation';
-import { useModuleFactory } from '../useModuleFactory';
-
-/**
- * React hook for managing a Semantic Segmentation model instance.
- * @typeParam C - A {@link SemanticSegmentationModelSources} config specifying which built-in model to load.
- * @param props - Configuration object containing `model` config and optional `preventLoad` flag.
- * @returns An object with model state (`error`, `isReady`, `isGenerating`, `downloadProgress`) and a typed `forward` function.
- * @example
- * ```ts
- * const { isReady, forward } = useSemanticSegmentation({
- *   model: { modelName: 'deeplab-v3-resnet50', modelSource: DEEPLAB_V3_RESNET50 },
- * });
- * ```
- * @category Hooks
- */
-export const useSemanticSegmentation = <
-  C extends SemanticSegmentationModelSources,
->({
-  model,
-  preventLoad = false,
-}: SemanticSegmentationProps<C>): SemanticSegmentationType<
-  SegmentationLabels<ModelNameOf<C>>
-> => {
-  const {
-    error,
-    isReady,
-    isGenerating,
-    downloadProgress,
-    runForward,
-    runOnFrame,
-  } = useModuleFactory({
-    factory: (config, onProgress) =>
-      SemanticSegmentationModule.fromModelName(config, onProgress),
-    config: model,
-    deps: [model.modelName, model.modelSource],
-    preventLoad,
-  });
-
-  const forward = <K extends keyof SegmentationLabels<ModelNameOf<C>>>(
-    imageSource: string | PixelData,
-    classesOfInterest: K[] = [],
-    resizeToInput: boolean = true
-  ) =>
-    runForward((inst) =>
-      inst.forward(imageSource, classesOfInterest, resizeToInput)
-    );
-
-  return {
-    error,
-    isReady,
-    isGenerating,
-    downloadProgress,
-    forward,
-    runOnFrame,
-  };
-};
diff --git a/packages/react-native-executorch/src/hooks/computer_vision/useStyleTransfer.ts b/packages/react-native-executorch/src/hooks/computer_vision/useStyleTransfer.ts
deleted file mode 100644
index 35eac71fd2..0000000000
--- a/packages/react-native-executorch/src/hooks/computer_vision/useStyleTransfer.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-import { StyleTransferModule } from '../../modules/computer_vision/StyleTransferModule';
-import { PixelData } from '../../types/common';
-import {
-  StyleTransferProps,
-  StyleTransferType,
-} from '../../types/styleTransfer';
-import { useModuleFactory } from '../useModuleFactory';
-
-/**
- * React hook for managing a Style Transfer model instance.
- * @category Hooks
- * @param StyleTransferProps - Configuration object containing `model` source and optional `preventLoad` flag.
- * @returns Ready to use Style Transfer model.
- */
-export const useStyleTransfer = ({
-  model,
-  preventLoad = false,
-}: StyleTransferProps): StyleTransferType => {
-  const {
-    error,
-    isReady,
-    isGenerating,
-    downloadProgress,
-    runForward,
-    runOnFrame,
-  } = useModuleFactory({
-    factory: (config, onProgress) =>
-      StyleTransferModule.fromModelName(config, onProgress),
-    config: model,
-    deps: [model.modelName, model.modelSource],
-    preventLoad,
-  });
-
-  const forward = <O extends 'pixelData' | 'url' = 'pixelData'>(
-    imageSource: string | PixelData,
-    outputType?: O
-  ) => runForward((inst) => inst.forward(imageSource, outputType));
-
-  return {
-    error,
-    isReady,
-    isGenerating,
-    downloadProgress,
-    forward,
-    runOnFrame,
-  } as StyleTransferType;
-};
diff --git a/packages/react-native-executorch/src/hooks/computer_vision/useTextToImage.ts b/packages/react-native-executorch/src/hooks/computer_vision/useTextToImage.ts
deleted file mode 100644
index f5ca97fd53..0000000000
--- a/packages/react-native-executorch/src/hooks/computer_vision/useTextToImage.ts
+++ /dev/null
@@ -1,112 +0,0 @@
-import { useCallback, useEffect, useState } from 'react';
-import { RnExecutorchError, parseUnknownError } from '../../errors/errorUtils';
-import { RnExecutorchErrorCode } from '../../errors/ErrorCodes';
-import { TextToImageModule } from '../../modules/computer_vision/TextToImageModule';
-import { TextToImageProps, TextToImageType } from '../../types/tti';
-
-/**
- * React hook for managing a Text to Image instance.
- * @category Hooks
- * @param TextToImageProps - Configuration object containing `model` source, `inferenceCallback`, and optional `preventLoad` flag.
- * @returns Ready to use Text to Image model.
- */
-export const useTextToImage = ({
-  model,
-  inferenceCallback,
-  preventLoad = false,
-}: TextToImageProps): TextToImageType => {
-  const [isReady, setIsReady] = useState(false);
-  const [isGenerating, setIsGenerating] = useState(false);
-  const [downloadProgress, setDownloadProgress] = useState(0);
-  const [error, setError] = useState<RnExecutorchError | null>(null);
-  const [moduleInstance, setModuleInstance] =
-    useState<TextToImageModule | null>(null);
-
-  useEffect(() => {
-    if (preventLoad) return;
-
-    let active = true;
-    setDownloadProgress(0);
-    setError(null);
-    setIsReady(false);
-
-    TextToImageModule.fromModelName(
-      {
-        modelName: model.modelName,
-        tokenizerSource: model.tokenizerSource,
-        schedulerSource: model.schedulerSource,
-        encoderSource: model.encoderSource,
-        unetSource: model.unetSource,
-        decoderSource: model.decoderSource,
-        inferenceCallback,
-      },
-      (p) => {
-        if (active) setDownloadProgress(p);
-      }
-    )
-      .then((mod) => {
-        if (!active) {
-          mod.delete();
-          return;
-        }
-        setModuleInstance((prev) => {
-          prev?.delete();
-          return mod;
-        });
-        setIsReady(true);
-      })
-      .catch((err) => {
-        if (active) setError(parseUnknownError(err));
-      });
-
-    return () => {
-      active = false;
-      setModuleInstance((prev) => {
-        prev?.delete();
-        return null;
-      });
-    };
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [
-    model.modelName,
-    model.tokenizerSource,
-    model.schedulerSource,
-    model.encoderSource,
-    model.unetSource,
-    model.decoderSource,
-    preventLoad,
-  ]);
-
-  const generate = async (
-    input: string,
-    imageSize?: number,
-    numSteps?: number,
-    seed?: number
-  ): Promise<string> => {
-    if (!isReady || !moduleInstance)
-      throw new RnExecutorchError(RnExecutorchErrorCode.ModuleNotLoaded);
-    if (isGenerating)
-      throw new RnExecutorchError(RnExecutorchErrorCode.ModelGenerating);
-    try {
-      setIsGenerating(true);
-      return await moduleInstance.forward(input, imageSize, numSteps, seed);
-    } finally {
-      setIsGenerating(false);
-    }
-  };
-
-  const interrupt = useCallback(() => {
-    if (isGenerating && moduleInstance) {
-      moduleInstance.interrupt();
-    }
-  }, [moduleInstance, isGenerating]);
-
-  return {
-    isReady,
-    isGenerating,
-    downloadProgress,
-    error,
-    generate,
-    interrupt,
-  };
-};
diff --git a/packages/react-native-executorch/src/hooks/computer_vision/useVerticalOCR.ts b/packages/react-native-executorch/src/hooks/computer_vision/useVerticalOCR.ts
deleted file mode 100644
index df7e99add5..0000000000
--- a/packages/react-native-executorch/src/hooks/computer_vision/useVerticalOCR.ts
+++ /dev/null
@@ -1,85 +0,0 @@
-import { useCallback, useEffect, useState } from 'react';
-import { Frame, PixelData } from '../../types/common';
-import { VerticalOCRController } from '../../controllers/VerticalOCRController';
-import { RnExecutorchError } from '../../errors/errorUtils';
-import { OCRDetection, OCRType, VerticalOCRProps } from '../../types/ocr';
-
-/**
- * React hook for managing a Vertical OCR instance.
- * @category Hooks
- * @param VerticalOCRProps - Configuration object containing `model` sources, optional `independentCharacters` and `preventLoad` flag.
- * @returns Ready to use Vertical OCR model.
- */
-export const useVerticalOCR = ({
-  model,
-  independentCharacters = false,
-  preventLoad = false,
-}: VerticalOCRProps): OCRType => {
-  const [isReady, setIsReady] = useState(false);
-  const [isGenerating, setIsGenerating] = useState(false);
-  const [downloadProgress, setDownloadProgress] = useState(0);
-  const [error, setError] = useState<RnExecutorchError | null>(null);
-
-  const [runOnFrame, setRunOnFrame] = useState<
-    ((frame: Frame, isFrontCamera: boolean) => OCRDetection[]) | null
-  >(null);
-
-  const [controller] = useState(
-    () =>
-      new VerticalOCRController({
-        isReadyCallback: setIsReady,
-        isGeneratingCallback: setIsGenerating,
-        errorCallback: setError,
-      })
-  );
-
-  useEffect(() => {
-    setDownloadProgress(0);
-    setError(null);
-
-    if (preventLoad) return;
-
-    controller
-      .load(
-        model.detectorSource,
-        model.recognizerSource,
-        model.language,
-        independentCharacters,
-        setDownloadProgress
-      )
-      .then(() => {
-        const worklet = controller.runOnFrame;
-        if (worklet) setRunOnFrame(() => worklet);
-      });
-
-    return () => {
-      setRunOnFrame(null);
-      if (controller.isReady) {
-        controller.delete();
-      }
-    };
-  }, [
-    controller,
-    model.modelName,
-    model.detectorSource,
-    model.recognizerSource,
-    model.language,
-    independentCharacters,
-    preventLoad,
-  ]);
-
-  const forward = useCallback(
-    (imageSource: string | PixelData): Promise<OCRDetection[]> =>
-      controller.forward(imageSource),
-    [controller]
-  );
-
-  return {
-    error,
-    isReady,
-    isGenerating,
-    forward,
-    downloadProgress,
-    runOnFrame,
-  };
-};
diff --git a/packages/react-native-executorch/src/hooks/general/useExecutorchModule.ts b/packages/react-native-executorch/src/hooks/general/useExecutorchModule.ts
deleted file mode 100644
index f41524fc4d..0000000000
--- a/packages/react-native-executorch/src/hooks/general/useExecutorchModule.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import { ExecutorchModule } from '../../modules/general/ExecutorchModule';
-import {
-  ExecutorchModuleProps,
-  ExecutorchModuleType,
-} from '../../types/executorchModule';
-import { useModule } from '../useModule';
-
-/**
- * React hook for managing an arbitrary Executorch module instance.
- * @category Hooks
- * @param executorchModuleProps - Configuration object containing `modelSource` and optional `preventLoad` flag.
- * @returns Ready to use Executorch module.
- */
-export const useExecutorchModule = ({
-  modelSource,
-  preventLoad = false,
-}: ExecutorchModuleProps): ExecutorchModuleType =>
-  useModule({
-    module: ExecutorchModule,
-    model: modelSource,
-    preventLoad,
-  });
diff --git a/packages/react-native-executorch/src/hooks/natural_language_processing/useLLM.ts b/packages/react-native-executorch/src/hooks/natural_language_processing/useLLM.ts
deleted file mode 100644
index a8daef8d91..0000000000
--- a/packages/react-native-executorch/src/hooks/natural_language_processing/useLLM.ts
+++ /dev/null
@@ -1,157 +0,0 @@
-import { useCallback, useEffect, useState } from 'react';
-import {
-  LLMCapability,
-  LLMConfig,
-  LLMProps,
-  LLMTool,
-  LLMType,
-  LLMTypeMultimodal,
-  Message,
-} from '../../types/llm';
-import { LLMController } from '../../controllers/LLMController';
-import { RnExecutorchError, parseUnknownError } from '../../errors/errorUtils';
-
-/**
- * React hook for managing a Large Language Model (LLM) instance.
- * @category Hooks
- * @param props - Object containing model, tokenizer, and tokenizer config sources.
- * @returns An object implementing the `LLMTypeMultimodal` interface when `model.capabilities` is provided, otherwise `LLMType`.
- */
-export function useLLM<C extends readonly LLMCapability[]>(
-  props: LLMProps & { model: { capabilities: C } }
-): LLMTypeMultimodal<C>;
-export function useLLM(props: LLMProps): LLMType;
-export function useLLM({
-  model,
-  preventLoad = false,
-}: LLMProps): LLMType | LLMTypeMultimodal {
-  const [token, setToken] = useState<string>('');
-  const [response, setResponse] = useState<string>('');
-  const [messageHistory, setMessageHistory] = useState<Message[]>([]);
-  const [isReady, setIsReady] = useState(false);
-  const [isGenerating, setIsGenerating] = useState(false);
-  const [downloadProgress, setDownloadProgress] = useState(0);
-  const [error, setError] = useState<null | RnExecutorchError>(null);
-  const capabilitiesKey = model.capabilities?.join(',') ?? '';
-
-  const tokenCallback = useCallback((newToken: string) => {
-    setToken(newToken);
-    setResponse((prevResponse) => prevResponse + newToken);
-  }, []);
-
-  const [controllerInstance] = useState(
-    () =>
-      new LLMController({
-        tokenCallback: tokenCallback,
-        messageHistoryCallback: setMessageHistory,
-        isReadyCallback: setIsReady,
-        isGeneratingCallback: setIsGenerating,
-      })
-  );
-
-  useEffect(() => {
-    setDownloadProgress(0);
-    setError(null);
-
-    if (preventLoad) return;
-
-    (async () => {
-      try {
-        await controllerInstance.load({
-          model: model,
-          onDownloadProgressCallback: setDownloadProgress,
-        });
-      } catch (e) {
-        setError(parseUnknownError(e));
-      }
-    })();
-
-    return () => {
-      if (controllerInstance.isReady) {
-        controllerInstance.delete();
-      }
-    };
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [
-    controllerInstance,
-    model.modelName,
-    model.modelSource,
-    model.tokenizerSource,
-    model.tokenizerConfigSource,
-    capabilitiesKey, // intentional: serialized string to avoid array reference re-runs
-    preventLoad,
-  ]);
-
-  // memoization of returned functions
-  const configure = useCallback(
-    ({ chatConfig, toolsConfig, generationConfig }: LLMConfig) =>
-      controllerInstance.configure({
-        chatConfig,
-        toolsConfig,
-        generationConfig,
-      }),
-    [controllerInstance]
-  );
-
-  const generate = useCallback(
-    (messages: Message[], tools?: LLMTool[]) => {
-      setResponse('');
-      return controllerInstance.generate(messages, tools);
-    },
-    [controllerInstance]
-  );
-
-  const sendMessage = useCallback(
-    (
-      message: string,
-      media?: { imagePath?: string; audioBuffer?: Float32Array }
-    ) => {
-      setResponse('');
-      return controllerInstance.sendMessage(message, media);
-    },
-    [controllerInstance]
-  );
-
-  const deleteMessage = useCallback(
-    (index: number) => controllerInstance.deleteMessage(index),
-    [controllerInstance]
-  );
-
-  const interrupt = useCallback(
-    () => controllerInstance.interrupt(),
-    [controllerInstance]
-  );
-
-  const getGeneratedTokenCount = useCallback(
-    () => controllerInstance.getGeneratedTokenCount(),
-    [controllerInstance]
-  );
-
-  const getPromptTokenCount = useCallback(
-    () => controllerInstance.getPromptTokenCount(),
-    [controllerInstance]
-  );
-
-  const getTotalTokenCount = useCallback(
-    () => controllerInstance.getTotalTokenCount(),
-    [controllerInstance]
-  );
-
-  return {
-    messageHistory,
-    response,
-    token,
-    isReady,
-    isGenerating,
-    downloadProgress,
-    error,
-    getGeneratedTokenCount: getGeneratedTokenCount,
-    getPromptTokenCount: getPromptTokenCount,
-    getTotalTokenCount: getTotalTokenCount,
-    configure: configure,
-    generate: generate,
-    sendMessage: sendMessage,
-    deleteMessage: deleteMessage,
-    interrupt: interrupt,
-  };
-}
diff --git a/packages/react-native-executorch/src/hooks/natural_language_processing/usePrivacyFilter.ts b/packages/react-native-executorch/src/hooks/natural_language_processing/usePrivacyFilter.ts
deleted file mode 100644
index aebb76b21d..0000000000
--- a/packages/react-native-executorch/src/hooks/natural_language_processing/usePrivacyFilter.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { PrivacyFilterModule } from '../../modules/natural_language_processing/PrivacyFilterModule';
-import { useModuleFactory } from '../useModuleFactory';
-import {
-  PiiEntity,
-  PrivacyFilterProps,
-  PrivacyFilterType,
-} from '../../types/privacyFilter';
-
-/**
- * React hook for managing a Privacy Filter model instance.
- * @category Hooks
- * @param PrivacyFilterProps - Configuration object containing the model sources and an optional `preventLoad` flag.
- * @returns Ready to use Privacy Filter model.
- */
-export const usePrivacyFilter = ({
-  model,
-  preventLoad = false,
-}: PrivacyFilterProps): PrivacyFilterType => {
-  const { error, isReady, isGenerating, downloadProgress, runForward } =
-    useModuleFactory({
-      factory: (config, onProgress) =>
-        PrivacyFilterModule.fromModelName(config, onProgress),
-      config: model,
-      deps: [model.modelName, model.modelSource, model.tokenizerSource],
-      preventLoad,
-    });
-
-  const generate = (text: string): Promise<PiiEntity[]> =>
-    runForward((inst) => inst.generate(text));
-
-  return { error, isReady, isGenerating, downloadProgress, generate };
-};
diff --git a/packages/react-native-executorch/src/hooks/natural_language_processing/useSpeechToText.ts b/packages/react-native-executorch/src/hooks/natural_language_processing/useSpeechToText.ts
deleted file mode 100644
index 0fd0480d3e..0000000000
--- a/packages/react-native-executorch/src/hooks/natural_language_processing/useSpeechToText.ts
+++ /dev/null
@@ -1,191 +0,0 @@
-import { useEffect, useCallback, useState } from 'react';
-import { SpeechToTextModule } from '../../modules/natural_language_processing/SpeechToTextModule';
-import {
-  DecodingOptions,
-  SpeechToTextType,
-  SpeechToTextProps,
-  TranscriptionResult,
-  StreamingOptions,
-} from '../../types/stt';
-import { RnExecutorchErrorCode } from '../../errors/ErrorCodes';
-import { RnExecutorchError, parseUnknownError } from '../../errors/errorUtils';
-
-/**
- * React hook for managing a Speech to Text (STT) instance.
- * @category Hooks
- * @param speechToTextProps - Configuration object containing `model` source and optional `preventLoad` flag.
- * @returns Ready to use Speech to Text model.
- */
-export const useSpeechToText = ({
-  model,
-  vad,
-  preventLoad = false,
-}: SpeechToTextProps): SpeechToTextType => {
-  const [error, setError] = useState<null | RnExecutorchError>(null);
-  const [isReady, setIsReady] = useState(false);
-  const [isGenerating, setIsGenerating] = useState(false);
-  const [downloadProgress, setDownloadProgress] = useState(0);
-  const [moduleInstance, setModuleInstance] =
-    useState<SpeechToTextModule | null>(null);
-
-  useEffect(() => {
-    if (preventLoad) return;
-
-    let active = true;
-    setDownloadProgress(0);
-    setError(null);
-    setIsReady(false);
-
-    SpeechToTextModule.fromModelName(
-      {
-        modelName: model.modelName,
-        isMultilingual: model.isMultilingual,
-        modelSource: model.modelSource,
-        tokenizerSource: model.tokenizerSource,
-      },
-      vad,
-      (p) => {
-        if (active) setDownloadProgress(p);
-      }
-    )
-      .then((mod) => {
-        if (!active) {
-          mod.delete();
-          return;
-        }
-        setModuleInstance((prev) => {
-          prev?.delete();
-          return mod;
-        });
-        setIsReady(true);
-      })
-      .catch((err) => {
-        if (active) setError(parseUnknownError(err));
-      });
-
-    return () => {
-      active = false;
-      setModuleInstance((prev) => {
-        prev?.delete();
-        return null;
-      });
-    };
-  }, [
-    model.modelName,
-    model.isMultilingual,
-    model.modelSource,
-    model.tokenizerSource,
-    vad,
-    preventLoad,
-  ]);
-
-  const transcribe = useCallback(
-    async (
-      waveform: Float32Array,
-      options: DecodingOptions = {}
-    ): Promise<TranscriptionResult> => {
-      if (!isReady || !moduleInstance) {
-        throw new RnExecutorchError(
-          RnExecutorchErrorCode.ModuleNotLoaded,
-          'The model is currently not loaded. Please load the model before calling this function.'
-        );
-      }
-      if (isGenerating) {
-        throw new RnExecutorchError(RnExecutorchErrorCode.ModelGenerating);
-      }
-
-      setIsGenerating(true);
-      try {
-        return await moduleInstance.transcribe(waveform, options);
-      } finally {
-        setIsGenerating(false);
-      }
-    },
-    [isReady, isGenerating, moduleInstance]
-  );
-
-  const stream = useCallback(
-    async function* (options: StreamingOptions = {}): AsyncGenerator<
-      {
-        committed: TranscriptionResult;
-        nonCommitted: TranscriptionResult;
-      },
-      void,
-      unknown
-    > {
-      if (!isReady || !moduleInstance) {
-        throw new RnExecutorchError(
-          RnExecutorchErrorCode.ModuleNotLoaded,
-          'The model is currently not loaded. Please load the model before calling this function.'
-        );
-      }
-      if (isGenerating) {
-        throw new RnExecutorchError(RnExecutorchErrorCode.ModelGenerating);
-      }
-
-      setIsGenerating(true);
-      try {
-        const generator = moduleInstance.stream(options);
-        for await (const result of generator) {
-          yield result;
-        }
-      } finally {
-        setIsGenerating(false);
-      }
-    },
-    [isReady, isGenerating, moduleInstance]
-  );
-
-  const streamInsert = useCallback(
-    (waveform: Float32Array) => {
-      if (!isReady || !moduleInstance) return;
-      moduleInstance.streamInsert(waveform);
-    },
-    [isReady, moduleInstance]
-  );
-
-  const streamStop = useCallback(() => {
-    if (!isReady || !moduleInstance) return;
-    moduleInstance.streamStop();
-  }, [isReady, moduleInstance]);
-
-  const encode = useCallback(
-    (waveform: Float32Array): Promise<Float32Array> => {
-      if (!moduleInstance)
-        throw new RnExecutorchError(
-          RnExecutorchErrorCode.ModuleNotLoaded,
-          'The model is currently not loaded. Please load the model before calling this function.'
-        );
-      return moduleInstance.encode(waveform);
-    },
-    [moduleInstance]
-  );
-
-  const decode = useCallback(
-    (
-      tokens: Int32Array,
-      encoderOutput: Float32Array
-    ): Promise<Float32Array> => {
-      if (!moduleInstance)
-        throw new RnExecutorchError(
-          RnExecutorchErrorCode.ModuleNotLoaded,
-          'The model is currently not loaded. Please load the model before calling this function.'
-        );
-      return moduleInstance.decode(tokens, encoderOutput);
-    },
-    [moduleInstance]
-  );
-
-  return {
-    error,
-    isReady,
-    isGenerating,
-    downloadProgress,
-    transcribe,
-    stream,
-    streamInsert,
-    streamStop,
-    encode,
-    decode,
-  };
-};
diff --git a/packages/react-native-executorch/src/hooks/natural_language_processing/useTextEmbeddings.ts b/packages/react-native-executorch/src/hooks/natural_language_processing/useTextEmbeddings.ts
deleted file mode 100644
index 31ee179925..0000000000
--- a/packages/react-native-executorch/src/hooks/natural_language_processing/useTextEmbeddings.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-import { TextEmbeddingsModule } from '../../modules/natural_language_processing/TextEmbeddingsModule';
-import { useModuleFactory } from '../useModuleFactory';
-import {
-  TextEmbeddingsType,
-  TextEmbeddingsProps,
-} from '../../types/textEmbeddings';
-
-/**
- * React hook for managing a Text Embeddings model instance.
- * @category Hooks
- * @param TextEmbeddingsProps - Configuration object containing `model` source and optional `preventLoad` flag.
- * @returns Ready to use Text Embeddings model.
- */
-export const useTextEmbeddings = ({
-  model,
-  preventLoad = false,
-}: TextEmbeddingsProps): TextEmbeddingsType => {
-  const { error, isReady, isGenerating, downloadProgress, runForward } =
-    useModuleFactory({
-      factory: (config, onProgress) =>
-        TextEmbeddingsModule.fromModelName(config, onProgress),
-      config: model,
-      deps: [model.modelName, model.modelSource, model.tokenizerSource],
-      preventLoad,
-    });
-
-  const forward = (input: string) => runForward((inst) => inst.forward(input));
-
-  return { error, isReady, isGenerating, downloadProgress, forward };
-};
diff --git a/packages/react-native-executorch/src/hooks/natural_language_processing/useTextToSpeech.ts b/packages/react-native-executorch/src/hooks/natural_language_processing/useTextToSpeech.ts
deleted file mode 100644
index 21576eb0f3..0000000000
--- a/packages/react-native-executorch/src/hooks/natural_language_processing/useTextToSpeech.ts
+++ /dev/null
@@ -1,170 +0,0 @@
-import { useCallback, useEffect, useState } from 'react';
-import { TextToSpeechModule } from '../../modules/natural_language_processing/TextToSpeechModule';
-import {
-  TextToSpeechInput,
-  TextToSpeechModelConfig,
-  TextToSpeechStreamingInput,
-  TextToSpeechType,
-} from '../../types/tts';
-import { RnExecutorchErrorCode } from '../../errors/ErrorCodes';
-import { RnExecutorchError, parseUnknownError } from '../../errors/errorUtils';
-
-/**
- * React hook for managing Text to Speech instance.
- * @category Hooks
- * @param model - Configuration object containing model config.
- * @param options - Additional options for the hook.
- * @param options.preventLoad - If true, prevents the model from loading automatically on initialization.
- * @returns Ready to use Text to Speech model.
- */
-export const useTextToSpeech = (
-  model: TextToSpeechModelConfig,
-  { preventLoad = false }: { preventLoad?: boolean } = {}
-): TextToSpeechType => {
-  const [error, setError] = useState<RnExecutorchError | null>(null);
-  const [isReady, setIsReady] = useState(false);
-  const [isGenerating, setIsGenerating] = useState(false);
-  const [downloadProgress, setDownloadProgress] = useState(0);
-
-  const [moduleInstance, setModuleInstance] =
-    useState<TextToSpeechModule | null>(null);
-
-  useEffect(() => {
-    if (preventLoad) return;
-
-    let active = true;
-    setDownloadProgress(0);
-    setError(null);
-    setIsReady(false);
-
-    TextToSpeechModule.fromModelName(model, setDownloadProgress)
-      .then((mod) => {
-        if (!active) {
-          mod.delete();
-          return;
-        }
-        setModuleInstance((prev) => {
-          prev?.delete();
-          return mod;
-        });
-        setIsReady(true);
-      })
-      .catch((err) => {
-        if (active) setError(parseUnknownError(err));
-      });
-
-    return () => {
-      active = false;
-      setModuleInstance((prev) => {
-        prev?.streamStop(true);
-        prev?.delete();
-        return null;
-      });
-    };
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [
-    model.model.modelName,
-    model.model.durationPredictorSource,
-    model.model.synthesizerSource,
-    model.voiceSource,
-    model.phonemizerConfig,
-    preventLoad,
-  ]);
-
-  const guardReady = useCallback(
-    (methodName: string): TextToSpeechModule => {
-      if (!isReady || !moduleInstance)
-        throw new RnExecutorchError(
-          RnExecutorchErrorCode.ModuleNotLoaded,
-          `The model is currently not loaded. Please load the model before calling ${methodName}().`
-        );
-      if (isGenerating)
-        throw new RnExecutorchError(RnExecutorchErrorCode.ModelGenerating);
-      return moduleInstance;
-    },
-    [isReady, isGenerating, moduleInstance]
-  );
-
-  const forward = async (input: TextToSpeechInput) => {
-    const instance = guardReady('forward');
-    try {
-      setIsGenerating(true);
-      return await instance.forward(
-        input.text ?? '',
-        input.speed ?? 1.0,
-        input.phonemize ?? true
-      );
-    } finally {
-      setIsGenerating(false);
-    }
-  };
-
-  const stream = useCallback(
-    async (input: TextToSpeechStreamingInput) => {
-      const instance = guardReady('stream');
-      setIsGenerating(true);
-      try {
-        if (input.text) {
-          instance.streamInsert(
-            input.text +
-              ('.?!;'.includes(input.text.trim().slice(-1)) ? '' : '.')
-          );
-        }
-
-        await input.onBegin?.();
-        for await (const audio of instance.stream({
-          speed: input.speed ?? 1.0,
-          phonemize: input.phonemize ?? true,
-          stopAutomatically: input.stopAutomatically ?? true,
-        })) {
-          if (input.onNext) {
-            await input.onNext(audio);
-          }
-        }
-      } catch (e) {
-        instance.streamStop(true);
-        throw e;
-      } finally {
-        await input.onEnd?.();
-        setIsGenerating(false);
-      }
-    },
-    [guardReady]
-  );
-
-  const streamInsert = useCallback(
-    (text: string) => {
-      if (moduleInstance) {
-        moduleInstance.streamInsert(text);
-      }
-    },
-    [moduleInstance]
-  );
-
-  const streamFlush = useCallback(() => {
-    if (moduleInstance) {
-      moduleInstance.streamFlush();
-    }
-  }, [moduleInstance]);
-
-  const streamStop = useCallback(
-    (instant: boolean = true) => {
-      if (moduleInstance) {
-        moduleInstance.streamStop(instant);
-      }
-    },
-    [moduleInstance]
-  );
-
-  return {
-    error,
-    isReady,
-    isGenerating,
-    forward,
-    stream,
-    streamInsert,
-    streamFlush,
-    streamStop,
-    downloadProgress,
-  };
-};
diff --git a/packages/react-native-executorch/src/hooks/natural_language_processing/useTokenizer.ts b/packages/react-native-executorch/src/hooks/natural_language_processing/useTokenizer.ts
deleted file mode 100644
index d1ca99c1a4..0000000000
--- a/packages/react-native-executorch/src/hooks/natural_language_processing/useTokenizer.ts
+++ /dev/null
@@ -1,70 +0,0 @@
-import { useEffect, useState } from 'react';
-import { TokenizerModule } from '../../modules/natural_language_processing/TokenizerModule';
-import { RnExecutorchErrorCode } from '../../errors/ErrorCodes';
-import { RnExecutorchError, parseUnknownError } from '../../errors/errorUtils';
-import { TokenizerProps, TokenizerType } from '../../types/tokenizer';
-
-/**
- * React hook for managing a Tokenizer instance.
- * @category Hooks
- * @param tokenizerProps - Configuration object containing `tokenizer` source and optional `preventLoad` flag.
- * @returns Ready to use Tokenizer model.
- */
-export const useTokenizer = ({
-  tokenizer,
-  preventLoad = false,
-}: TokenizerProps): TokenizerType => {
-  const [error, setError] = useState<null | RnExecutorchError>(null);
-  const [isReady, setIsReady] = useState(false);
-  const [isGenerating, setIsGenerating] = useState(false);
-  const [downloadProgress, setDownloadProgress] = useState(0);
-  const [tokenizerInstance] = useState(() => new TokenizerModule());
-
-  useEffect(() => {
-    if (preventLoad) return;
-    (async () => {
-      setDownloadProgress(0);
-      setError(null);
-      try {
-        setIsReady(false);
-        await tokenizerInstance.load(
-          { tokenizerSource: tokenizer.tokenizerSource },
-          setDownloadProgress
-        );
-        setIsReady(true);
-      } catch (err) {
-        setError(parseUnknownError(err));
-      }
-    })();
-  }, [tokenizerInstance, tokenizer.tokenizerSource, preventLoad]);
-
-  const stateWrapper = <T extends (...args: any[]) => Promise<any>>(fn: T) => {
-    return (...args: Parameters<T>): Promise<Awaited<ReturnType<T>>> => {
-      if (!isReady)
-        throw new RnExecutorchError(
-          RnExecutorchErrorCode.ModuleNotLoaded,
-          'The model is currently not loaded. Please load the model before calling this function.'
-        );
-      if (isGenerating)
-        throw new RnExecutorchError(RnExecutorchErrorCode.ModelGenerating);
-      try {
-        setIsGenerating(true);
-        return fn.apply(tokenizerInstance, args);
-      } finally {
-        setIsGenerating(false);
-      }
-    };
-  };
-
-  return {
-    error,
-    isReady,
-    isGenerating,
-    downloadProgress,
-    decode: stateWrapper(TokenizerModule.prototype.decode),
-    encode: stateWrapper(TokenizerModule.prototype.encode),
-    getVocabSize: stateWrapper(TokenizerModule.prototype.getVocabSize),
-    idToToken: stateWrapper(TokenizerModule.prototype.idToToken),
-    tokenToId: stateWrapper(TokenizerModule.prototype.tokenToId),
-  };
-};
diff --git a/packages/react-native-executorch/src/hooks/natural_language_processing/useVAD.ts b/packages/react-native-executorch/src/hooks/natural_language_processing/useVAD.ts
deleted file mode 100644
index 72bcaae7e1..0000000000
--- a/packages/react-native-executorch/src/hooks/natural_language_processing/useVAD.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import { VADModule } from '../../modules/natural_language_processing/VADModule';
-import { VADType, VADProps, VADStreamingInput } from '../../types/vad';
-import { useModuleFactory } from '../useModuleFactory';
-
-/**
- * React hook for managing a VAD model instance.
- * @category Hooks
- * @param VADProps - Configuration object containing `model` source and optional `preventLoad` flag.
- * @returns Ready to use VAD model.
- */
-export const useVAD = ({ model, preventLoad = false }: VADProps): VADType => {
-  const {
-    error,
-    isReady,
-    isGenerating,
-    downloadProgress,
-    runForward,
-    runSideChannel,
-  } = useModuleFactory({
-    factory: (config, onProgress) =>
-      VADModule.fromModelName(config, onProgress),
-    config: model,
-    deps: [model.modelName, model.modelSource],
-    preventLoad,
-  });
-
-  const forward = (waveform: Float32Array) =>
-    runForward((inst) => inst.forward(waveform));
-
-  const stream = (input: VADStreamingInput) =>
-    runForward((inst) => inst.stream(input));
-
-  const streamInsert = (waveform: Float32Array) =>
-    runSideChannel((inst) => inst.streamInsert(waveform));
-
-  const streamStop = () => runSideChannel((inst) => inst.streamStop());
-
-  return {
-    error,
-    isReady,
-    isGenerating,
-    downloadProgress,
-    forward,
-    stream,
-    streamInsert,
-    streamStop,
-  };
-};
diff --git a/packages/react-native-executorch/src/hooks/useModule.ts b/packages/react-native-executorch/src/hooks/useModule.ts
deleted file mode 100644
index c26c93c361..0000000000
--- a/packages/react-native-executorch/src/hooks/useModule.ts
+++ /dev/null
@@ -1,148 +0,0 @@
-import { useEffect, useState } from 'react';
-import { RnExecutorchErrorCode } from '../errors/ErrorCodes';
-import { RnExecutorchError, parseUnknownError } from '../errors/errorUtils';
-
-type RunOnFrame<M> = M extends { runOnFrame: infer R } ? R : never;
-
-interface Module {
-  load: (...args: any[]) => Promise<void>;
-  forward: (...args: any[]) => Promise<any>;
-  delete: () => void;
-}
-
-interface ModuleConstructor<M extends Module> {
-  new (): M;
-}
-
-export const useModule = <
-  M extends Module,
-  LoadArgs extends Parameters<M['load']>,
-  ForwardArgs extends Parameters<M['forward']>,
-  ForwardReturn extends Awaited<ReturnType<M['forward']>>,
->({
-  module,
-  model,
-  preventLoad = false,
-}: {
-  module: ModuleConstructor<M>;
-  model: LoadArgs[0];
-  preventLoad?: boolean;
-}) => {
-  const [error, setError] = useState<null | RnExecutorchError>(null);
-  const [isReady, setIsReady] = useState(false);
-  const [isGenerating, setIsGenerating] = useState(false);
-  const [downloadProgress, setDownloadProgress] = useState(0);
-  const [moduleInstance] = useState(() => new module());
-  const [runOnFrame, setRunOnFrame] = useState<RunOnFrame<M> | null>(null);
-
-  useEffect(() => {
-    if (preventLoad) return;
-
-    let isMounted = true;
-
-    (async () => {
-      setDownloadProgress(0);
-      setError(null);
-      try {
-        setIsReady(false);
-        await moduleInstance.load(model, (progress: number) => {
-          if (isMounted) setDownloadProgress(progress);
-        });
-        if (isMounted) setIsReady(true);
-
-        // VisionCamera worklets run on a separate JS thread and can only capture
-        // serializable values (plain functions, primitives). The module instance
-        // is a class object and is not serializable, so accessing runOnFrame
-        // directly inside a worklet would fail at runtime.
-        //
-        // By extracting the method and storing it in React state, it becomes a
-        // standalone function reference that the worklet thread can capture and
-        // call safely.
-        //
-        // Note: setState(fn) triggers React's updater form — it calls fn(prevState)
-        // and stores the return value, not fn itself. Since runOnFrame is a function,
-        // we wrap it: setState(() => worklet) so React stores the worklet as the
-        // state value rather than invoking it.
-        if ('runOnFrame' in moduleInstance) {
-          const worklet = moduleInstance.runOnFrame as RunOnFrame<M>;
-          if (worklet) {
-            setRunOnFrame(() => worklet);
-          }
-        }
-      } catch (err) {
-        if (isMounted) setError(parseUnknownError(err));
-      }
-    })();
-
-    return () => {
-      isMounted = false;
-      setIsReady(false);
-      setRunOnFrame(null);
-      moduleInstance.delete();
-    };
-
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [moduleInstance, ...Object.values(model), preventLoad]);
-
-  const forward = async (...input: ForwardArgs): Promise<ForwardReturn> => {
-    if (!isReady)
-      throw new RnExecutorchError(RnExecutorchErrorCode.ModuleNotLoaded);
-    if (isGenerating)
-      throw new RnExecutorchError(RnExecutorchErrorCode.ModelGenerating);
-    try {
-      setIsGenerating(true);
-      return await moduleInstance.forward(...input);
-    } finally {
-      setIsGenerating(false);
-    }
-  };
-
-  return {
-    /**
-     * Contains the error message if the model failed to load.
-     */
-    error,
-
-    /**
-     * Indicates whether the model is ready.
-     */
-    isReady,
-
-    /**
-     * Indicates whether the model is currently generating a response.
-     */
-    isGenerating,
-
-    /**
-     * Represents the download progress as a value between 0 and 1, indicating the extent of the model file retrieval.
-     */
-    downloadProgress,
-    forward,
-
-    /**
-     * Synchronous worklet function for real-time VisionCamera frame processing.
-     * Automatically handles native buffer extraction and cleanup.
-     *
-     * Only available for Computer Vision modules that support real-time frame processing
-     * (e.g., ObjectDetection, Classification, ImageSegmentation).
-     * Returns `null` if the module doesn't implement frame processing.
-     *
-     * **Use this for VisionCamera frame processing in worklets.**
-     * For async processing, use `forward()` instead.
-     * @example
-     * ```typescript
-     * const { runOnFrame } = useObjectDetection({ model: MODEL });
-     *
-     * const frameOutput = useFrameOutput({
-     *   onFrame(frame) {
-     *     'worklet';
-     *     if (!runOnFrame) return;
-     *     const detections = runOnFrame(frame, 0.5);
-     *     frame.dispose();
-     *   }
-     * });
-     * ```
-     */
-    runOnFrame,
-  };
-};
diff --git a/packages/react-native-executorch/src/hooks/useModuleFactory.ts b/packages/react-native-executorch/src/hooks/useModuleFactory.ts
deleted file mode 100644
index 82f8c7a49e..0000000000
--- a/packages/react-native-executorch/src/hooks/useModuleFactory.ts
+++ /dev/null
@@ -1,120 +0,0 @@
-import { useState, useEffect, useMemo } from 'react';
-import { RnExecutorchErrorCode } from '../errors/ErrorCodes';
-import { RnExecutorchError, parseUnknownError } from '../errors/errorUtils';
-
-type Deletable = { delete: () => void };
-
-type RunOnFrame<M> = M extends { runOnFrame: infer R } ? R : never;
-
-/**
- * Shared hook for modules that are instantiated via an async static factory
- * (i.e. `SomeModule.fromModelName(config, onProgress)`).
- *
- * Handles model loading, download progress, error state, and enforces the
- * not-loaded / already-generating guards so individual hooks only need to
- * define their typed `forward` wrapper.
- * @param props - Options object containing the factory function, config, deps array, and optional preventLoad flag.
- * @returns An object with error, isReady, isGenerating, downloadProgress, runForward, runSideChannel, instance, and runOnFrame.
- * @internal
- */
-export function useModuleFactory<M extends Deletable, Config>({
-  factory,
-  config,
-  deps,
-  preventLoad = false,
-}: {
-  factory: (
-    config: Config,
-    onProgress: (progress: number) => void
-  ) => Promise<M>;
-  config: Config;
-  deps: ReadonlyArray<unknown>;
-  preventLoad?: boolean;
-}) {
-  const [error, setError] = useState<RnExecutorchError | null>(null);
-  const [isReady, setIsReady] = useState(false);
-  const [isGenerating, setIsGenerating] = useState(false);
-  const [downloadProgress, setDownloadProgress] = useState(0);
-  const [instance, setInstance] = useState<M | null>(null);
-
-  useEffect(() => {
-    if (preventLoad) return;
-
-    let active = true;
-    setDownloadProgress(0);
-    setError(null);
-    setIsReady(false);
-
-    factory(config, (p) => {
-      if (active) setDownloadProgress(p);
-    })
-      .then((mod) => {
-        if (!active) {
-          mod.delete();
-          return;
-        }
-        setInstance((prev) => {
-          prev?.delete();
-          return mod;
-        });
-        setIsReady(true);
-      })
-      .catch((err) => {
-        if (active) setError(parseUnknownError(err));
-      });
-
-    return () => {
-      active = false;
-      setInstance((prev) => {
-        prev?.delete();
-        return null;
-      });
-    };
-
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [...deps, preventLoad]);
-
-  const runForward = async <R>(fn: (instance: M) => Promise<R>): Promise<R> => {
-    if (!isReady || !instance) {
-      throw new RnExecutorchError(RnExecutorchErrorCode.ModuleNotLoaded);
-    }
-    if (isGenerating) {
-      throw new RnExecutorchError(RnExecutorchErrorCode.ModelGenerating);
-    }
-    try {
-      setIsGenerating(true);
-      return await fn(instance);
-    } finally {
-      setIsGenerating(false);
-    }
-  };
-
-  // Non-gating call path for streaming modules: only checks `isReady`, never
-  // `isGenerating`. Lets side-channel methods (e.g. `streamInsert` buffer push,
-  // `streamStop` interrupt signal) run while `stream`/`forward` is in flight.
-  const runSideChannel = <R>(fn: (instance: M) => R): R => {
-    if (!isReady || !instance) {
-      throw new RnExecutorchError(RnExecutorchErrorCode.ModuleNotLoaded);
-    }
-    return fn(instance);
-  };
-
-  const runOnFrame = useMemo(
-    () =>
-      instance && 'runOnFrame' in instance
-        ? (instance.runOnFrame as RunOnFrame<M> | null)
-        : null,
-    [instance]
-  );
-
-  return {
-    error,
-    isReady,
-    isGenerating,
-    downloadProgress,
-    runForward,
-    runSideChannel,
-    instance,
-    runOnFrame,
-  };
-}
diff --git a/packages/react-native-executorch/src/index.ts b/packages/react-native-executorch/src/index.ts
index 1f190d41f5..e47ee5cec8 100644
--- a/packages/react-native-executorch/src/index.ts
+++ b/packages/react-native-executorch/src/index.ts
@@ -1,251 +1,30 @@
-import { ETInstallerNativeModule } from './native/RnExecutorchModules';
-import {
-  ResourceFetcher,
-  ResourceFetcherAdapter,
-} from './utils/ResourceFetcher';
-import { Triple } from './types/common';
-import { LLMCapability } from './types/llm';
-/**
- * Configuration that goes to the `initExecutorch`.
- * You can pass either bare React Native or Expo configuration.
- * @category Utilities - General
- */
-export interface ExecutorchConfig {
-  resourceFetcher: ResourceFetcherAdapter;
-}
-
-/**
- * Function that setups the provided resource fetcher.
- * @category Utilities - General
- * @param config - Configuration that you want to use in resource fetching.
- */
-export function initExecutorch(config: ExecutorchConfig) {
-  ResourceFetcher.setAdapter(config.resourceFetcher);
-}
-
-/**
- * Function that cleans current setup of fetching resources.
- * @category Utilities - General
- */
-export function cleanupExecutorch() {
-  ResourceFetcher.resetAdapter();
-}
-
-// eslint-disable no-var
-declare global {
-  var loadStyleTransfer: (source: string) => Promise<any>;
-  var loadSemanticSegmentation: (
-    source: string,
-    normMean: Triple<number> | [],
-    normStd: Triple<number> | [],
-    allClasses: string[]
-  ) => Promise<any>;
-  var loadInstanceSegmentation: (
-    source: string,
-    normMean: Triple<number> | [],
-    normStd: Triple<number> | [],
-    applyNMS: boolean
-  ) => Promise<any>;
-  var loadClassification: (
-    source: string,
-    normMean: Triple<number> | [],
-    normStd: Triple<number> | [],
-    labelNames: string[]
-  ) => Promise<any>;
-  var loadObjectDetection: (
-    source: string,
-    normMean: Triple<number> | [],
-    normStd: Triple<number> | [],
-    labelNames: string[]
-  ) => Promise<any>;
-  var loadPoseEstimation: (
-    source: string,
-    normMean: Triple<number> | [],
-    normStd: Triple<number> | []
-  ) => Promise<any>;
-  var loadExecutorchModule: (source: string) => Promise<any>;
-  var loadTokenizerModule: (source: string) => Promise<any>;
-  var loadImageEmbeddings: (source: string) => Promise<any>;
-  var loadVAD: (source: string) => Promise<any>;
-  var loadTextEmbeddings: (
-    modelSource: string,
-    tokenizerSource: string
-  ) => Promise<any>;
-  var loadLLM: (
-    modelSource: string,
-    tokenizerSource: string,
-    capabilities: readonly LLMCapability[]
-  ) => Promise<any>;
-  var loadPrivacyFilter: (
-    modelSource: string,
-    tokenizerSource: string,
-    labelNames: readonly string[],
-    viterbiBiases: readonly number[]
-  ) => Promise<any>;
-  var loadTextToImage: (
-    tokenizerSource: string,
-    encoderSource: string,
-    unetSource: string,
-    decoderSource: string,
-    schedulerBetaStart: number,
-    schedulerBetaEnd: number,
-    schedulerNumTrainTimesteps: number,
-    schedulerStepsOffset: number
-  ) => Promise<any>;
-  var loadSpeechToText: (
-    modelName: string,
-    modelSource: string,
-    tokenizerSource: string,
-    vadSource: string
-  ) => Promise<any>;
-  var loadTextToSpeechKokoro: (
-    lang: string,
-    taggerData: string,
-    lexiconData: string,
-    neuralPhonemizerData: string,
-    durationPredictorSource: string,
-    synthesizerSource: string,
-    voice: string
-  ) => Promise<any>;
-  var loadOCR: (
-    detectorSource: string,
-    recognizer: string,
-    symbols: string
-  ) => Promise<any>;
-  var loadVerticalOCR: (
-    detectorSource: string,
-    recognizer: string,
-    symbols: string,
-    independentCharacters?: boolean
-  ) => Promise<any>;
-  // eslint-disable-next-line camelcase
-  var __rne_isEmulator: boolean;
-}
-// eslint-disable no-var
-
-if (
-  global.loadStyleTransfer == null ||
-  global.loadSemanticSegmentation == null ||
-  global.loadInstanceSegmentation == null ||
-  global.loadTextToImage == null ||
-  global.loadExecutorchModule == null ||
-  global.loadClassification == null ||
-  global.loadObjectDetection == null ||
-  global.loadPoseEstimation == null ||
-  global.loadTokenizerModule == null ||
-  global.loadTextEmbeddings == null ||
-  global.loadImageEmbeddings == null ||
-  global.loadVAD == null ||
-  global.loadLLM == null ||
-  global.loadPrivacyFilter == null ||
-  global.loadSpeechToText == null ||
-  global.loadTextToSpeechKokoro == null ||
-  global.loadOCR == null ||
-  global.loadVerticalOCR == null ||
-  global.__rne_isEmulator == null
-) {
-  if (!ETInstallerNativeModule) {
-    throw new Error(
-      `Failed to install react-native-executorch: The native module could not be found.`
-    );
-  }
-  // install() returns false when the native library is intentionally unavailable
-  // (e.g. ETInstallerUnavailable on unsupported ABIs). In that case, JSI
-  // bindings are not injected and globals remain unset.
-  ETInstallerNativeModule.install();
-}
-
-/**
- * Whether the native ExecuTorch runtime is available on this device.
- * Returns `false` when native libraries cannot be loaded (e.g. 32-bit Android
- * devices where only arm64-v8a binaries are shipped).
- * @category Utilities - General
- */
-export const isAvailable = typeof global.loadExecutorchModule === 'function';
-
-// hooks
-export * from './hooks/computer_vision/useClassification';
-export * from './hooks/computer_vision/useObjectDetection';
-export * from './hooks/computer_vision/useStyleTransfer';
-export * from './hooks/computer_vision/useSemanticSegmentation';
-export * from './hooks/computer_vision/useInstanceSegmentation';
-export * from './hooks/computer_vision/useOCR';
-export * from './hooks/computer_vision/useVerticalOCR';
-export * from './hooks/computer_vision/useImageEmbeddings';
-export * from './hooks/computer_vision/useTextToImage';
-export * from './hooks/computer_vision/usePoseEstimation';
-
-export * from './hooks/natural_language_processing/useLLM';
-export * from './hooks/natural_language_processing/useSpeechToText';
-export * from './hooks/natural_language_processing/useTextToSpeech';
-export * from './hooks/natural_language_processing/usePrivacyFilter';
-export * from './hooks/natural_language_processing/useTextEmbeddings';
-export * from './hooks/natural_language_processing/useTokenizer';
-export * from './hooks/natural_language_processing/useVAD';
-
-export * from './hooks/general/useExecutorchModule';
-
-// modules
-export * from './modules/computer_vision/ClassificationModule';
-export * from './modules/computer_vision/ObjectDetectionModule';
-export * from './modules/computer_vision/StyleTransferModule';
-export * from './modules/computer_vision/SemanticSegmentationModule';
-export * from './modules/computer_vision/InstanceSegmentationModule';
-export * from './modules/computer_vision/OCRModule';
-export * from './modules/computer_vision/VerticalOCRModule';
-export * from './modules/computer_vision/ImageEmbeddingsModule';
-export * from './modules/computer_vision/TextToImageModule';
-export * from './modules/computer_vision/PoseEstimationModule';
-
-export * from './modules/natural_language_processing/LLMModule';
-export * from './modules/natural_language_processing/SpeechToTextModule';
-export * from './modules/natural_language_processing/TextToSpeechModule';
-export * from './modules/natural_language_processing/PrivacyFilterModule';
-export * from './modules/natural_language_processing/TextEmbeddingsModule';
-export * from './modules/natural_language_processing/TokenizerModule';
-export * from './modules/natural_language_processing/VADModule';
-
-export * from './modules/general/ExecutorchModule';
-
-// utils
-export * from './utils/ResourceFetcher';
-export * from './utils/ResourceFetcherUtils';
-export * from './utils/BaseResourceFetcherClass';
-export * from './utils/llm';
-export * from './common/Logger';
-export * from './utils/llms/context_strategy';
-export * from './utils/segmentAnythingPrompts';
-
-// types
-export * from './types/objectDetection';
-export * from './types/ocr';
-export * from './types/semanticSegmentation';
-export * from './types/instanceSegmentation';
-export * from './types/llm';
-export * from './types/vad';
-export * from './types/common';
-export * from './types/stt';
-export * from './types/textEmbeddings';
-export * from './types/privacyFilter';
-export * from './types/tts';
-export * from './types/tokenizer';
-export * from './types/executorchModule';
-export * from './types/classification';
-export * from './types/imageEmbeddings';
-export * from './types/styleTransfer';
-export * from './types/tti';
-export * from './types/poseEstimation';
-
-// constants
-export * from './constants/commonVision';
-export * from './constants/classification';
-export * from './constants/modelUrls';
-export * from './constants/modelRegistry';
-export * from './constants/ocr/models';
-export * from './constants/tts/models';
-export * from './constants/tts/voices';
-export * from './constants/llmDefaults';
-export * from './constants/poseEstimation';
-
-export { RnExecutorchError } from './errors/errorUtils';
-export { RnExecutorchErrorCode } from './errors/ErrorCodes';
+// Core primitives — for library builders
+
+export { tensor } from './core/tensor';
+export type { DType, Tensor } from './core/tensor';
+
+export { loadModel } from './core/model';
+export type {
+  Model,
+  ModelInput,
+  ModelOutput,
+  TensorMeta,
+  ModelMethodMeta,
+  ExecuTorchTag,
+} from './core/model';
+
+export {
+  validateModelSchema,
+  SymbolicTensor,
+  matchShape,
+} from './core/modelSchema';
+export type {
+  ValueConstraint,
+  TensorConstraint,
+  SymbolicShape,
+} from './core/modelSchema';
+
+export { defaultWorkletRuntime, wrapAsync } from './core/runtime';
+
+// Utils
+export * from './utils';
diff --git a/packages/react-native-executorch/src/modules/BaseModule.ts b/packages/react-native-executorch/src/modules/BaseModule.ts
deleted file mode 100644
index 7545734f74..0000000000
--- a/packages/react-native-executorch/src/modules/BaseModule.ts
+++ /dev/null
@@ -1,86 +0,0 @@
-import { Frame } from '../types/common';
-import { TensorPtr } from '../types/common';
-
-/**
- * Base class for all React Native Executorch modules.
- *
- * Provides core functionality for loading models, running inference,
- * and managing native resources.
- * @category Base Classes
- */
-export abstract class BaseModule {
-  /**
-   * Native module instance (JSI Host Object)
-   * @internal
-   */
-  nativeModule: any = null;
-
-  /**
-   * Process a camera frame directly for real-time inference.
-   *
-   * This method is bound to a native JSI function after calling `load()`,
-   * making it worklet-compatible and safe to call from VisionCamera's
-   * frame processor thread.
-   *
-   * **Performance characteristics:**
-   * - **Zero-copy path**: When using `frame.getNativeBuffer()` from VisionCamera v5,
-   *   frame data is accessed directly without copying (fastest, recommended).
-   * - **Copy path**: When using `frame.toArrayBuffer()`, pixel data is copied
-   *   from native to JS, then accessed from native code (slower, fallback).
-   *
-   * **Usage with VisionCamera:**
-   * ```typescript
-   * const frameOutput = useFrameOutput({
-   *   pixelFormat: 'rgb',
-   *   onFrame(frame) {
-   *     'worklet';
-   *     // Zero-copy approach (recommended)
-   *     const nativeBuffer = frame.getNativeBuffer();
-   *     const result = model.generateFromFrame(
-   *       { nativeBuffer: nativeBuffer.pointer, width: frame.width, height: frame.height },
-   *       ...args
-   *     );
-   *     nativeBuffer.release();
-   *     frame.dispose();
-   *   }
-   * });
-   * ```
-   * @param frameData Frame data object with either nativeBuffer (zero-copy) or data (ArrayBuffer)
-   * @param args Additional model-specific arguments (e.g., threshold, options)
-   * @returns Model-specific output (e.g., detections, classifications, embeddings)
-   * @see {@link Frame} for frame data format details
-   */
-  public generateFromFrame!: (frameData: Frame, ...args: any[]) => any;
-
-  /**
-   * Runs the model's forward method with the given input tensors.
-   * It returns the output tensors that mimic the structure of output from ExecuTorch.
-   * @param inputTensor - Array of input tensors.
-   * @returns Array of output tensors.
-   * @internal
-   */
-  protected async forwardET(inputTensor: TensorPtr[]): Promise<TensorPtr[]> {
-    return await this.nativeModule.forward(inputTensor);
-  }
-
-  /**
-   * Gets the input shape for a given method and index.
-   * @param methodName method name
-   * @param index index of the argument which shape is requested
-   * @returns The input shape as an array of numbers.
-   */
-  async getInputShape(methodName: string, index: number): Promise<number[]> {
-    return this.nativeModule.getInputShape(methodName, index);
-  }
-
-  /**
-   * Unloads the model from memory and releases native resources.
-   *
-   * Always call this method when you're done with a model to prevent memory leaks.
-   */
-  delete() {
-    if (this.nativeModule !== null) {
-      this.nativeModule.unload();
-    }
-  }
-}
diff --git a/packages/react-native-executorch/src/modules/computer_vision/ClassificationModule.ts b/packages/react-native-executorch/src/modules/computer_vision/ClassificationModule.ts
deleted file mode 100644
index 3c030edfc6..0000000000
--- a/packages/react-native-executorch/src/modules/computer_vision/ClassificationModule.ts
+++ /dev/null
@@ -1,139 +0,0 @@
-import { LabelEnum, PixelData, ResourceSource } from '../../types/common';
-import {
-  ClassificationConfig,
-  ClassificationModelName,
-  ClassificationModelSources,
-} from '../../types/classification';
-import { Imagenet1kLabel } from '../../constants/classification';
-import {
-  fetchModelPath,
-  ResolveLabels as ResolveLabelsFor,
-  VisionLabeledModule,
-} from './VisionLabeledModule';
-import { buildLabelArray } from '../../utils/labelUtils';
-
-const ModelConfigs = {
-  'efficientnet-v2-s': {
-    labelMap: Imagenet1kLabel,
-  },
-  'efficientnet-v2-s-quantized': {
-    labelMap: Imagenet1kLabel,
-  },
-} as const satisfies Record<
-  ClassificationModelName,
-  ClassificationConfig<LabelEnum>
->;
-
-type ModelConfigsType = typeof ModelConfigs;
-
-/**
- * Resolves the {@link LabelEnum} for a given built-in classification model name.
- * @typeParam M - A built-in model name from {@link ClassificationModelName}.
- * @category Types
- */
-export type ClassificationLabels<M extends ClassificationModelName> =
-  ResolveLabelsFor<M, ModelConfigsType>;
-
-type ModelNameOf<C extends ClassificationModelSources> = C['modelName'];
-
-/** @internal */
-type ResolveLabels<T extends ClassificationModelName | LabelEnum> =
-  ResolveLabelsFor<T, ModelConfigsType>;
-
-/**
- * Generic classification module with type-safe label maps.
- * @typeParam T - Either a built-in model name (e.g. `'efficientnet-v2-s'`)
- *   or a custom {@link LabelEnum} label map.
- * @category Typescript API
- */
-export class ClassificationModule<
-  T extends ClassificationModelName | LabelEnum,
-> extends VisionLabeledModule<
-  Record<keyof ResolveLabels<T>, number>,
-  ResolveLabels<T>
-> {
-  private constructor(labelMap: ResolveLabels<T>, nativeModule: unknown) {
-    super(labelMap, nativeModule);
-  }
-
-  /**
-   * Creates a classification instance for a built-in model.
-   * @param namedSources - A {@link ClassificationModelSources} object specifying which model to load and where to fetch it from.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @returns A Promise resolving to a `ClassificationModule` instance typed to the chosen model's label map.
-   */
-  static async fromModelName<C extends ClassificationModelSources>(
-    namedSources: C,
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<ClassificationModule<ModelNameOf<C>>> {
-    const { modelSource } = namedSources;
-    const { labelMap, preprocessorConfig } = ModelConfigs[
-      namedSources.modelName
-    ] as ClassificationConfig<LabelEnum>;
-    const normMean = preprocessorConfig?.normMean ?? [];
-    const normStd = preprocessorConfig?.normStd ?? [];
-    const allLabelNames = buildLabelArray(labelMap);
-    const modelPath = await fetchModelPath(modelSource, onDownloadProgress);
-    const nativeModule = await global.loadClassification(
-      modelPath,
-      normMean,
-      normStd,
-      allLabelNames
-    );
-    return new ClassificationModule<ModelNameOf<C>>(
-      labelMap as ResolveLabels<ModelNameOf<C>>,
-      nativeModule
-    );
-  }
-
-  /**
-   * Creates a classification instance with a user-provided model binary and label map.
-   * Use this when working with a custom-exported model that is not one of the built-in presets.
-   *
-   * ## Required model contract
-   *
-   * The `.pte` model binary must expose a single `forward` method with the following interface:
-   *
-   * **Input:** one `float32` tensor of shape `[1, 3, H, W]` — a single RGB image, values in
-   * `[0, 1]` after optional per-channel normalization `(pixel − mean) / std`.
-   * H and W are read from the model's declared input shape at load time.
-   *
-   * **Output:** one `float32` tensor of shape `[1, C]` containing raw logits — one value per class,
-   * in the same order as the entries in your `labelMap`. Softmax is applied by the native runtime.
-   * @param modelSource - A fetchable resource pointing to the model binary.
-   * @param config - A {@link ClassificationConfig} object with the label map and optional preprocessing parameters.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @returns A Promise resolving to a `ClassificationModule` instance typed to the provided label map.
-   */
-  static async fromCustomModel<L extends LabelEnum>(
-    modelSource: ResourceSource,
-    config: ClassificationConfig<L>,
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<ClassificationModule<L>> {
-    const normMean = config.preprocessorConfig?.normMean ?? [];
-    const normStd = config.preprocessorConfig?.normStd ?? [];
-    const allLabelNames = buildLabelArray(config.labelMap);
-    const modelPath = await fetchModelPath(modelSource, onDownloadProgress);
-    const nativeModule = await global.loadClassification(
-      modelPath,
-      normMean,
-      normStd,
-      allLabelNames
-    );
-    return new ClassificationModule<L>(
-      config.labelMap as ResolveLabels<L>,
-      nativeModule
-    );
-  }
-
-  /**
-   * Executes the model's forward pass to classify the provided image.
-   * @param input - A string image source (file path, URI, or Base64) or a {@link PixelData} object.
-   * @returns A Promise resolving to an object mapping label keys to confidence scores.
-   */
-  override async forward(
-    input: string | PixelData
-  ): Promise<Record<keyof ResolveLabels<T>, number>> {
-    return super.forward(input);
-  }
-}
diff --git a/packages/react-native-executorch/src/modules/computer_vision/ImageEmbeddingsModule.ts b/packages/react-native-executorch/src/modules/computer_vision/ImageEmbeddingsModule.ts
deleted file mode 100644
index acc8d80d04..0000000000
--- a/packages/react-native-executorch/src/modules/computer_vision/ImageEmbeddingsModule.ts
+++ /dev/null
@@ -1,72 +0,0 @@
-import { ResourceFetcher } from '../../utils/ResourceFetcher';
-import { ImageEmbeddingsModelName } from '../../types/imageEmbeddings';
-import { ResourceSource, PixelData } from '../../types/common';
-import { RnExecutorchErrorCode } from '../../errors/ErrorCodes';
-import { parseUnknownError, RnExecutorchError } from '../../errors/errorUtils';
-import { Logger } from '../../common/Logger';
-import { VisionModule } from './VisionModule';
-
-/**
- * Module for generating image embeddings from input images.
- * @category Typescript API
- */
-export class ImageEmbeddingsModule extends VisionModule<Float32Array> {
-  private constructor(nativeModule: unknown) {
-    super();
-    this.nativeModule = nativeModule;
-  }
-  /**
-   * Creates an image embeddings instance for a built-in model.
-   * @param namedSources - An object specifying which built-in model to load and where to fetch it from.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @returns A Promise resolving to an `ImageEmbeddingsModule` instance.
-   */
-  static async fromModelName(
-    namedSources: {
-      modelName: ImageEmbeddingsModelName;
-      modelSource: ResourceSource;
-    },
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<ImageEmbeddingsModule> {
-    try {
-      const paths = await ResourceFetcher.fetch(
-        onDownloadProgress,
-        namedSources.modelSource
-      );
-
-      if (!paths?.[0]) {
-        throw new RnExecutorchError(RnExecutorchErrorCode.DownloadInterrupted);
-      }
-
-      return new ImageEmbeddingsModule(
-        await global.loadImageEmbeddings(paths[0])
-      );
-    } catch (error) {
-      Logger.error('Load failed:', error);
-      throw parseUnknownError(error);
-    }
-  }
-
-  /**
-   * Creates an image embeddings instance with a user-provided model binary.
-   * Use this when working with a custom-exported model that is not one of the built-in presets.
-   * @remarks The native model contract for this method is not formally defined and may change
-   * between releases. Refer to the native source code for the current expected tensor interface.
-   * @param modelSource - A fetchable resource pointing to the model binary.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @returns A Promise resolving to an `ImageEmbeddingsModule` instance.
-   */
-  static fromCustomModel(
-    modelSource: ResourceSource,
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<ImageEmbeddingsModule> {
-    return ImageEmbeddingsModule.fromModelName(
-      { modelName: 'custom' as ImageEmbeddingsModelName, modelSource },
-      onDownloadProgress
-    );
-  }
-
-  async forward(input: string | PixelData): Promise<Float32Array> {
-    return new Float32Array((await super.forward(input)) as any);
-  }
-}
diff --git a/packages/react-native-executorch/src/modules/computer_vision/InstanceSegmentationModule.ts b/packages/react-native-executorch/src/modules/computer_vision/InstanceSegmentationModule.ts
deleted file mode 100644
index e7e96f2deb..0000000000
--- a/packages/react-native-executorch/src/modules/computer_vision/InstanceSegmentationModule.ts
+++ /dev/null
@@ -1,483 +0,0 @@
-import {
-  ResourceSource,
-  LabelEnum,
-  PixelData,
-  Frame,
-} from '../../types/common';
-import {
-  InstanceSegmentationModelSources,
-  InstanceSegmentationConfig,
-  InstanceSegmentationModelName,
-  InstanceModelNameOf,
-  NativeSegmentedInstance,
-  SegmentedInstance,
-  InstanceSegmentationOptions,
-} from '../../types/instanceSegmentation';
-import { RnExecutorchErrorCode } from '../../errors/ErrorCodes';
-import { RnExecutorchError } from '../../errors/errorUtils';
-import {
-  fetchModelPath,
-  ResolveLabels as ResolveLabelsFor,
-  VisionLabeledModule,
-} from './VisionLabeledModule';
-import {
-  CocoLabel,
-  CocoLabelYolo,
-  FastSAMLabel,
-  IMAGENET1K_MEAN,
-  IMAGENET1K_STD,
-} from '../../constants/commonVision';
-
-const YOLO_SEG_CONFIG = {
-  preprocessorConfig: undefined,
-  labelMap: CocoLabelYolo,
-  availableInputSizes: [384, 512, 640] as const,
-  defaultInputSize: 384,
-  defaultConfidenceThreshold: 0.5,
-  defaultIouThreshold: 0.5,
-  postprocessorConfig: {
-    applyNMS: false,
-  },
-} satisfies InstanceSegmentationConfig<typeof CocoLabelYolo>;
-
-const FASTSAM_CONFIG = {
-  preprocessorConfig: undefined,
-  labelMap: FastSAMLabel,
-  availableInputSizes: undefined,
-  defaultInputSize: undefined,
-  defaultConfidenceThreshold: 0.5,
-  defaultIouThreshold: 0.9,
-  postprocessorConfig: {
-    applyNMS: true,
-  },
-} satisfies InstanceSegmentationConfig<typeof FastSAMLabel>;
-
-const RF_DETR_NANO_SEG_CONFIG = {
-  preprocessorConfig: { normMean: IMAGENET1K_MEAN, normStd: IMAGENET1K_STD },
-  labelMap: CocoLabel,
-  availableInputSizes: undefined,
-  defaultInputSize: undefined, //RFDetr exposes only one method named forward
-  defaultConfidenceThreshold: 0.5,
-  defaultIouThreshold: 0.5,
-  postprocessorConfig: {
-    applyNMS: true,
-  },
-} satisfies InstanceSegmentationConfig<typeof CocoLabel>;
-
-/**
- * Builds a reverse map from 0-based model class index to label key name, and
- * computes the minimum enum value (offset) so TS enum values can be converted
- * to 0-based model indices.
- * @param labelMap - The label enum to build the index map from.
- * @returns An object containing `indexToLabel` map and `minValue` offset.
- */
-function buildClassIndexMap(labelMap: LabelEnum): {
-  indexToLabel: Map<number, string>;
-  minValue: number;
-} {
-  const entries: [string, number][] = [];
-  for (const [name, value] of Object.entries(labelMap)) {
-    if (typeof value === 'number') entries.push([name, value]);
-  }
-  const minValue = Math.min(...entries.map(([, v]) => v));
-  const indexToLabel = new Map<number, string>();
-  for (const [name, value] of entries) {
-    indexToLabel.set(value - minValue, name);
-  }
-  return { indexToLabel, minValue };
-}
-
-const ModelConfigs = {
-  'yolo26n-seg': YOLO_SEG_CONFIG,
-  'yolo26s-seg': YOLO_SEG_CONFIG,
-  'yolo26m-seg': YOLO_SEG_CONFIG,
-  'yolo26l-seg': YOLO_SEG_CONFIG,
-  'yolo26x-seg': YOLO_SEG_CONFIG,
-  'rfdetr-nano-seg': RF_DETR_NANO_SEG_CONFIG,
-  'fastsam-s': FASTSAM_CONFIG,
-  'fastsam-x': FASTSAM_CONFIG,
-} as const satisfies Record<
-  InstanceSegmentationModelName,
-  | InstanceSegmentationConfig<typeof CocoLabel>
-  | InstanceSegmentationConfig<typeof CocoLabelYolo>
-  | InstanceSegmentationConfig<typeof FastSAMLabel>
->;
-
-/** @internal */
-type ModelConfigsType = typeof ModelConfigs;
-
-/**
- * Resolves the label map type for a given built-in model name.
- * @typeParam M - A built-in model name from {@link InstanceSegmentationModelName}.
- * @category Types
- */
-export type InstanceSegmentationLabels<
-  M extends InstanceSegmentationModelName,
-> = ResolveLabels<M>;
-
-/**
- * Resolves the label type: if `T` is a {@link InstanceSegmentationModelName}, looks up its labels
- * from the built-in config; otherwise uses `T` directly as a {@link LabelEnum}.
- * @internal
- */
-type ResolveLabels<T extends InstanceSegmentationModelName | LabelEnum> =
-  ResolveLabelsFor<T, ModelConfigsType>;
-
-/**
- * Generic instance segmentation module with type-safe label maps.
- * Use a model name (e.g. `'yolo26n-seg'`) as the generic parameter for pre-configured models,
- * or a custom label enum for custom configs.
- *
- * Supported models (download from HuggingFace):
- * - `yolo26n-seg`, `yolo26s-seg`, `yolo26m-seg`, `yolo26l-seg`, `yolo26x-seg` - YOLO models with COCO labels (80 classes)
- * - `rfdetr-nano-seg` - RF-DETR Nano model with COCO labels (80 classes)
- * @typeParam T - Either a pre-configured model name from {@link InstanceSegmentationModelName}
- *   or a custom label map conforming to {@link LabelEnum}.
- * @category Typescript API
- * @example
- * ```ts
- * const segmentation = await InstanceSegmentationModule.fromModelName({
- *   modelName: 'yolo26n-seg',
- *   modelSource: 'https://huggingface.co/.../yolo26n-seg.pte',
- * });
- *
- * const results = await segmentation.forward('path/to/image.jpg', {
- *   confidenceThreshold: 0.5,
- *   iouThreshold: 0.45,
- *   maxInstances: 20,
- *   inputSize: 640,
- * });
- * ```
- */
-export class InstanceSegmentationModule<
-  T extends InstanceSegmentationModelName | LabelEnum,
-> extends VisionLabeledModule<
-  SegmentedInstance<ResolveLabels<T>>[],
-  ResolveLabels<T>
-> {
-  private modelConfig: InstanceSegmentationConfig<LabelEnum>;
-  private classIndexToLabel: Map<number, string>;
-  private labelEnumOffset: number;
-
-  private constructor(
-    labelMap: ResolveLabels<T>,
-    modelConfig: InstanceSegmentationConfig<LabelEnum>,
-    nativeModule: unknown,
-    classIndexToLabel: Map<number, string>,
-    labelEnumOffset: number
-  ) {
-    super(labelMap, nativeModule);
-    this.modelConfig = modelConfig;
-    this.classIndexToLabel = classIndexToLabel;
-    this.labelEnumOffset = labelEnumOffset;
-  }
-
-  /**
-   * Creates an instance segmentation module for a pre-configured model.
-   * The config object is discriminated by `modelName` — each model can require different fields.
-   * @param config - A {@link InstanceSegmentationModelSources} object specifying which model to load and where to fetch it from.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @returns A Promise resolving to an `InstanceSegmentationModule` instance typed to the chosen model's label map.
-   * @example
-   * ```ts
-   * const segmentation = await InstanceSegmentationModule.fromModelName({
-   *   modelName: 'yolo26n-seg',
-   *   modelSource: 'https://huggingface.co/.../yolo26n-seg.pte',
-   * });
-   * ```
-   */
-  static async fromModelName<C extends InstanceSegmentationModelSources>(
-    config: C,
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<InstanceSegmentationModule<InstanceModelNameOf<C>>> {
-    const { modelName, modelSource } = config;
-    const modelConfig = ModelConfigs[modelName as keyof typeof ModelConfigs];
-
-    const path = await fetchModelPath(modelSource, onDownloadProgress);
-
-    if (typeof global.loadInstanceSegmentation !== 'function') {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.ModuleNotLoaded,
-        `global.loadInstanceSegmentation is not available`
-      );
-    }
-
-    const { indexToLabel, minValue } = buildClassIndexMap(modelConfig.labelMap);
-
-    const nativeModule = await global.loadInstanceSegmentation(
-      path,
-      modelConfig.preprocessorConfig?.normMean || [],
-      modelConfig.preprocessorConfig?.normStd || [],
-      modelConfig.postprocessorConfig?.applyNMS ?? true
-    );
-
-    return new InstanceSegmentationModule<InstanceModelNameOf<C>>(
-      modelConfig.labelMap as ResolveLabels<InstanceModelNameOf<C>>,
-      modelConfig,
-      nativeModule,
-      indexToLabel,
-      minValue
-    );
-  }
-
-  /**
-   * Creates an instance segmentation module with a user-provided label map and custom config.
-   * Use this when working with a custom-exported segmentation model that is not one of the pre-configured models.
-   * @param modelSource - A fetchable resource pointing to the model binary.
-   * @param config - A {@link InstanceSegmentationConfig} object with the label map and optional preprocessing parameters.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @returns A Promise resolving to an `InstanceSegmentationModule` instance typed to the provided label map.
-   * @example
-   * ```ts
-   * const MyLabels = { PERSON: 0, CAR: 1 } as const;
-   * const segmentation = await InstanceSegmentationModule.fromCustomModel(
-   *   'https://huggingface.co/.../custom_model.pte',
-   *   {
-   *     labelMap: MyLabels,
-   *     availableInputSizes: [640],
-   *     defaultInputSize: 640,
-   *     defaultConfidenceThreshold: 0.5,
-   *     defaultIouThreshold: 0.45,
-   *     postprocessorConfig: { applyNMS: true },
-   *   },
-   * );
-   * ```
-   */
-  static async fromCustomModel<L extends LabelEnum>(
-    modelSource: ResourceSource,
-    config: InstanceSegmentationConfig<L>,
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<InstanceSegmentationModule<L>> {
-    const path = await fetchModelPath(modelSource, onDownloadProgress);
-
-    if (typeof global.loadInstanceSegmentation !== 'function') {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.ModuleNotLoaded,
-        `global.loadInstanceSegmentation is not available`
-      );
-    }
-
-    const { indexToLabel, minValue } = buildClassIndexMap(config.labelMap);
-
-    const nativeModule = await global.loadInstanceSegmentation(
-      path,
-      config.preprocessorConfig?.normMean || [],
-      config.preprocessorConfig?.normStd || [],
-      config.postprocessorConfig?.applyNMS ?? true
-    );
-
-    return new InstanceSegmentationModule<L>(
-      config.labelMap as ResolveLabels<L>,
-      config,
-      nativeModule,
-      indexToLabel,
-      minValue
-    );
-  }
-
-  /**
-   * Returns the available input sizes for this model, or undefined if the model accepts any size.
-   * @returns An array of available input sizes, or undefined if not constrained.
-   * @example
-   * ```ts
-   * const sizes = segmentation.getAvailableInputSizes();
-   * console.log(sizes); // [384, 512, 640] for YOLO models, or undefined for RF-DETR
-   * ```
-   */
-  getAvailableInputSizes(): readonly number[] | undefined {
-    return this.modelConfig.availableInputSizes;
-  }
-
-  /**
-   * Override runOnFrame to add label mapping for VisionCamera integration.
-   * The parent's runOnFrame returns raw native results with class indices;
-   * this override maps them to label strings and provides an options-based API.
-   * @returns A worklet function for VisionCamera frame processing.
-   * @throws {RnExecutorchError} If the underlying native worklet is unavailable (should not occur on a loaded module).
-   */
-  override get runOnFrame(): (
-    frame: Frame,
-    isFrontCamera: boolean,
-    options?: InstanceSegmentationOptions<ResolveLabels<T>>
-  ) => SegmentedInstance<ResolveLabels<T>>[] {
-    const baseRunOnFrame = super.runOnFrame;
-    if (!baseRunOnFrame) {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.ModuleNotLoaded,
-        'Model is not loaded. Ensure the model has been loaded before using runOnFrame.'
-      );
-    }
-
-    // Convert Map to plain object for worklet serialization
-    const labelLookup: Record<number, string> = {};
-    this.classIndexToLabel.forEach((label, index) => {
-      labelLookup[index] = label;
-    });
-    // Create reverse map (label → enum value) for classesOfInterest lookup
-    const labelMap: Record<string, number> = {};
-    for (const [name, value] of Object.entries(this.labelMap)) {
-      if (typeof value === 'number') {
-        labelMap[name] = value;
-      }
-    }
-    const labelEnumOffset = this.labelEnumOffset;
-    const defaultConfidenceThreshold =
-      this.modelConfig.defaultConfidenceThreshold ?? 0.5;
-    const defaultIouThreshold = this.modelConfig.defaultIouThreshold ?? 0.5;
-    const defaultInputSize = this.modelConfig.defaultInputSize;
-
-    return (
-      frame: Frame,
-      isFrontCamera: boolean,
-      options?: InstanceSegmentationOptions<ResolveLabels<T>>
-    ): SegmentedInstance<ResolveLabels<T>>[] => {
-      'worklet';
-
-      const confidenceThreshold =
-        options?.confidenceThreshold ?? defaultConfidenceThreshold;
-      const iouThreshold = options?.iouThreshold ?? defaultIouThreshold;
-      const maxInstances = options?.maxInstances ?? 100;
-      const returnMaskAtOriginalResolution =
-        options?.returnMaskAtOriginalResolution ?? true;
-      const inputSize = options?.inputSize ?? defaultInputSize;
-      const methodName =
-        inputSize !== undefined ? `forward_${inputSize}` : 'forward';
-
-      const classIndices = options?.classesOfInterest
-        ? options.classesOfInterest.map((label) => {
-            const labelStr = String(label);
-            const enumValue = labelMap[labelStr];
-            // Don't normalize - send raw enum values to match model output
-            return typeof enumValue === 'number' ? enumValue : -1;
-          })
-        : [];
-
-      const nativeResults = baseRunOnFrame(
-        frame,
-        isFrontCamera,
-        confidenceThreshold,
-        iouThreshold,
-        maxInstances,
-        classIndices,
-        returnMaskAtOriginalResolution,
-        methodName
-      );
-      return nativeResults.map((inst: any) => ({
-        bbox: inst.bbox,
-        mask: inst.mask,
-        maskWidth: inst.maskWidth,
-        maskHeight: inst.maskHeight,
-        label: (labelLookup[inst.classIndex - labelEnumOffset] ??
-          String(inst.classIndex)) as keyof ResolveLabels<T>,
-        score: inst.score,
-      }));
-    };
-  }
-
-  /**
-   * Executes the model's forward pass to perform instance segmentation on the provided image.
-   *
-   * Supports two input types:
-   * 1. **String path/URI**: File path, URL, or Base64-encoded string
-   * 2. **PixelData**: Raw pixel data from image libraries (e.g., NitroImage)
-   * @param input - Image source (string path or PixelData object)
-   * @param options - Optional configuration for the segmentation process. Includes `confidenceThreshold`, `iouThreshold`, `maxInstances`, `classesOfInterest`, `returnMaskAtOriginalResolution`, and `inputSize`.
-   * @returns A Promise resolving to an array of {@link SegmentedInstance} objects with `bbox`, `mask`, `maskWidth`, `maskHeight`, `label`, `score`.
-   * @throws {RnExecutorchError} If the model is not loaded or if an invalid `inputSize` is provided.
-   * @example
-   * ```ts
-   * const results = await segmentation.forward('path/to/image.jpg', {
-   *   confidenceThreshold: 0.6,
-   *   iouThreshold: 0.5,
-   *   maxInstances: 10,
-   *   inputSize: 640,
-   *   classesOfInterest: ['PERSON', 'CAR'],
-   *   returnMaskAtOriginalResolution: true,
-   * });
-   *
-   * results.forEach((inst) => {
-   *   console.log(`${inst.label}: ${(inst.score * 100).toFixed(1)}%`);
-   * });
-   * ```
-   */
-  async forward(
-    input: string | PixelData,
-    options?: InstanceSegmentationOptions<ResolveLabels<T>>
-  ): Promise<SegmentedInstance<ResolveLabels<T>>[]> {
-    if (this.nativeModule == null) {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.ModuleNotLoaded,
-        'The model is currently not loaded.'
-      );
-    }
-
-    const confidenceThreshold =
-      options?.confidenceThreshold ??
-      this.modelConfig.defaultConfidenceThreshold ??
-      0.5;
-    const iouThreshold =
-      options?.iouThreshold ?? this.modelConfig.defaultIouThreshold ?? 0.5;
-    const maxInstances = options?.maxInstances ?? 100;
-    const returnMaskAtOriginalResolution =
-      options?.returnMaskAtOriginalResolution ?? true;
-
-    const inputSize = options?.inputSize ?? this.modelConfig.defaultInputSize;
-
-    if (
-      this.modelConfig.availableInputSizes &&
-      inputSize !== undefined &&
-      !this.modelConfig.availableInputSizes.includes(
-        inputSize as (typeof this.modelConfig.availableInputSizes)[number]
-      )
-    ) {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.InvalidArgument,
-        `Invalid inputSize: ${inputSize}. Available sizes: ${this.modelConfig.availableInputSizes.join(', ')}`
-      );
-    }
-
-    const methodName =
-      inputSize !== undefined ? `forward_${inputSize}` : 'forward';
-
-    const classIndices = options?.classesOfInterest
-      ? options.classesOfInterest.map((label) => {
-          const labelStr = String(label);
-          const enumValue = this.labelMap[labelStr as keyof ResolveLabels<T>];
-          // Don't normalize - send raw enum values to match model output
-          return typeof enumValue === 'number' ? enumValue : -1;
-        })
-      : [];
-
-    const nativeResult: NativeSegmentedInstance[] =
-      typeof input === 'string'
-        ? await this.nativeModule.generateFromString(
-            input,
-            confidenceThreshold,
-            iouThreshold,
-            maxInstances,
-            classIndices,
-            returnMaskAtOriginalResolution,
-            methodName
-          )
-        : await this.nativeModule.generateFromPixels(
-            input,
-            confidenceThreshold,
-            iouThreshold,
-            maxInstances,
-            classIndices,
-            returnMaskAtOriginalResolution,
-            methodName
-          );
-
-    return nativeResult.map((inst) => ({
-      bbox: inst.bbox,
-      mask: inst.mask,
-      maskWidth: inst.maskWidth,
-      maskHeight: inst.maskHeight,
-      label: (this.classIndexToLabel.get(
-        inst.classIndex - this.labelEnumOffset
-      ) ?? String(inst.classIndex)) as keyof ResolveLabels<T>,
-      score: inst.score,
-    }));
-  }
-}
diff --git a/packages/react-native-executorch/src/modules/computer_vision/OCRModule.ts b/packages/react-native-executorch/src/modules/computer_vision/OCRModule.ts
deleted file mode 100644
index 69faca6980..0000000000
--- a/packages/react-native-executorch/src/modules/computer_vision/OCRModule.ts
+++ /dev/null
@@ -1,98 +0,0 @@
-import { OCRController } from '../../controllers/OCRController';
-import { ResourceSource } from '../../types/common';
-import { OCRDetection, OCRLanguage, OCRModelName } from '../../types/ocr';
-import { Logger } from '../../common/Logger';
-import { parseUnknownError } from '../../errors/errorUtils';
-
-/**
- * Module for Optical Character Recognition (OCR) tasks.
- * @category Typescript API
- */
-export class OCRModule {
-  private controller: OCRController;
-
-  private constructor(controller: OCRController) {
-    this.controller = controller;
-  }
-
-  /**
-   * Creates an OCR instance for a built-in model.
-   * @param namedSources - An object specifying the model name, detector source, recognizer source, and language.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @returns A Promise resolving to an `OCRModule` instance.
-   * @example
-   * ```ts
-   * import { OCRModule, OCR_ENGLISH } from 'react-native-executorch';
-   * const ocr = await OCRModule.fromModelName(OCR_ENGLISH);
-   * ```
-   */
-  static async fromModelName(
-    namedSources: {
-      modelName: OCRModelName;
-      detectorSource: ResourceSource;
-      recognizerSource: ResourceSource;
-      language: OCRLanguage;
-    },
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<OCRModule> {
-    try {
-      const controller = new OCRController();
-      await controller.load(
-        namedSources.detectorSource,
-        namedSources.recognizerSource,
-        namedSources.language,
-        onDownloadProgress
-      );
-      return new OCRModule(controller);
-    } catch (error) {
-      Logger.error('Load failed:', error);
-      throw parseUnknownError(error);
-    }
-  }
-
-  /**
-   * Creates an OCR instance with a user-provided model binary.
-   * Use this when working with a custom-exported OCR model.
-   * Internally uses `'custom'` as the model name for telemetry.
-   * @remarks The native model contract for this method is not formally defined and may change
-   * between releases. Refer to the native source code for the current expected tensor interface.
-   * @param detectorSource - A fetchable resource pointing to the text detector model binary.
-   * @param recognizerSource - A fetchable resource pointing to the text recognizer model binary.
-   * @param language - The language for the OCR model.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @returns A Promise resolving to an `OCRModule` instance.
-   */
-  static fromCustomModel(
-    detectorSource: ResourceSource,
-    recognizerSource: ResourceSource,
-    language: OCRLanguage,
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<OCRModule> {
-    return OCRModule.fromModelName(
-      {
-        modelName: `ocr-${language}` as OCRModelName,
-        detectorSource,
-        recognizerSource,
-        language,
-      },
-      onDownloadProgress
-    );
-  }
-
-  /**
-   * Executes the model's forward pass, where `imageSource` can be a fetchable resource or a Base64-encoded string.
-   * @param imageSource - The image source to be processed.
-   * @returns The OCR result as a `OCRDetection[]`.
-   */
-  async forward(imageSource: string): Promise<OCRDetection[]> {
-    return await this.controller.forward(imageSource);
-  }
-
-  /**
-   * Release the memory held by the module. Calling `forward` afterwards is invalid.
-   * Note that you cannot delete model while it's generating.
-   */
-  delete() {
-    this.controller.delete();
-  }
-}
diff --git a/packages/react-native-executorch/src/modules/computer_vision/ObjectDetectionModule.ts b/packages/react-native-executorch/src/modules/computer_vision/ObjectDetectionModule.ts
deleted file mode 100644
index 7274209df6..0000000000
--- a/packages/react-native-executorch/src/modules/computer_vision/ObjectDetectionModule.ts
+++ /dev/null
@@ -1,353 +0,0 @@
-import {
-  Frame,
-  LabelEnum,
-  PixelData,
-  ResourceSource,
-} from '../../types/common';
-import {
-  Detection,
-  ObjectDetectionConfig,
-  ObjectDetectionModelName,
-  ObjectDetectionModelSources,
-  ObjectDetectionOptions,
-} from '../../types/objectDetection';
-import { RnExecutorchErrorCode } from '../../errors/ErrorCodes';
-import { RnExecutorchError } from '../../errors/errorUtils';
-import { buildLabelArray } from '../../utils/labelUtils';
-import {
-  CocoLabel,
-  CocoLabelYolo,
-  IMAGENET1K_MEAN,
-  IMAGENET1K_STD,
-} from '../../constants/commonVision';
-import {
-  fetchModelPath,
-  ResolveLabels as ResolveLabelsFor,
-  VisionLabeledModule,
-} from './VisionLabeledModule';
-
-const YOLO_DETECTION_CONFIG = {
-  labelMap: CocoLabelYolo,
-  preprocessorConfig: undefined,
-  availableInputSizes: [384, 512, 640] as const,
-  defaultInputSize: 384,
-  defaultDetectionThreshold: 0.5,
-  defaultIouThreshold: 0.5,
-} satisfies ObjectDetectionConfig<typeof CocoLabelYolo>;
-
-const ModelConfigs = {
-  'ssdlite-320-mobilenet-v3-large': {
-    labelMap: CocoLabel,
-    preprocessorConfig: undefined,
-    availableInputSizes: undefined,
-    defaultInputSize: undefined,
-    defaultDetectionThreshold: 0.7,
-    defaultIouThreshold: 0.55,
-  },
-  'rf-detr-nano': {
-    labelMap: CocoLabel,
-    preprocessorConfig: { normMean: IMAGENET1K_MEAN, normStd: IMAGENET1K_STD },
-    availableInputSizes: undefined,
-    defaultInputSize: undefined,
-    defaultDetectionThreshold: 0.7,
-    defaultIouThreshold: 0.55,
-  },
-  'yolo26n': YOLO_DETECTION_CONFIG,
-  'yolo26s': YOLO_DETECTION_CONFIG,
-  'yolo26m': YOLO_DETECTION_CONFIG,
-  'yolo26l': YOLO_DETECTION_CONFIG,
-  'yolo26x': YOLO_DETECTION_CONFIG,
-} as const satisfies Record<
-  ObjectDetectionModelName,
-  ObjectDetectionConfig<LabelEnum>
->;
-
-type ModelConfigsType = typeof ModelConfigs;
-
-/**
- * Resolves the {@link LabelEnum} for a given built-in object detection model name.
- * @typeParam M - A built-in model name from {@link ObjectDetectionModelName}.
- * @category Types
- */
-export type ObjectDetectionLabels<M extends ObjectDetectionModelName> =
-  ResolveLabelsFor<M, ModelConfigsType>;
-
-type ModelNameOf<C extends ObjectDetectionModelSources> = C['modelName'];
-
-/** @internal */
-type ResolveLabels<T extends ObjectDetectionModelName | LabelEnum> =
-  ResolveLabelsFor<T, ModelConfigsType>;
-
-/**
- * Generic object detection module with type-safe label maps.
- * @typeParam T - Either a built-in model name (e.g. `'ssdlite-320-mobilenet-v3-large'`)
- *   or a custom {@link LabelEnum} label map.
- * @category Typescript API
- */
-export class ObjectDetectionModule<
-  T extends ObjectDetectionModelName | LabelEnum,
-> extends VisionLabeledModule<Detection<ResolveLabels<T>>[], ResolveLabels<T>> {
-  private modelConfig: ObjectDetectionConfig<LabelEnum>;
-
-  private constructor(
-    labelMap: ResolveLabels<T>,
-    modelConfig: ObjectDetectionConfig<LabelEnum>,
-    nativeModule: unknown
-  ) {
-    super(labelMap, nativeModule);
-    this.modelConfig = modelConfig;
-  }
-
-  /**
-   * Creates an object detection instance for a built-in model.
-   * @param namedSources - A {@link ObjectDetectionModelSources} object specifying which model to load and where to fetch it from.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @returns A Promise resolving to an `ObjectDetectionModule` instance typed to the chosen model's label map.
-   */
-  static async fromModelName<C extends ObjectDetectionModelSources>(
-    namedSources: C,
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<ObjectDetectionModule<ModelNameOf<C>>> {
-    const { modelSource } = namedSources;
-    const modelConfig = ModelConfigs[
-      namedSources.modelName
-    ] as ObjectDetectionConfig<LabelEnum>;
-    const { labelMap, preprocessorConfig } = modelConfig;
-    const normMean = preprocessorConfig?.normMean ?? [];
-    const normStd = preprocessorConfig?.normStd ?? [];
-    const allLabelNames = buildLabelArray(labelMap);
-    const modelPath = await fetchModelPath(modelSource, onDownloadProgress);
-    const nativeModule = await global.loadObjectDetection(
-      modelPath,
-      normMean,
-      normStd,
-      allLabelNames
-    );
-    return new ObjectDetectionModule<ModelNameOf<C>>(
-      labelMap as ResolveLabels<ModelNameOf<C>>,
-      modelConfig,
-      nativeModule
-    );
-  }
-
-  /**
-   * Returns the available input sizes for this model, or undefined if the model accepts any size.
-   * @returns An array of available input sizes, or undefined if not constrained.
-   * @example
-   * ```typescript
-   * const sizes = model.getAvailableInputSizes(); // [384, 512, 640] for YOLO models, or undefined for RF-DETR
-   * ```
-   */
-  getAvailableInputSizes(): readonly number[] | undefined {
-    return this.modelConfig.availableInputSizes;
-  }
-
-  /**
-   * Override runOnFrame to provide an options-based API for VisionCamera integration.
-   * @returns A worklet function for frame processing.
-   * @throws {RnExecutorchError} If the underlying native worklet is unavailable (should not occur on a loaded module).
-   */
-  override get runOnFrame(): (
-    frame: Frame,
-    isFrontCamera: boolean,
-    options?: ObjectDetectionOptions<ResolveLabels<T>>
-  ) => Detection<ResolveLabels<T>>[] {
-    const baseRunOnFrame = super.runOnFrame;
-    if (!baseRunOnFrame) {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.ModuleNotLoaded,
-        'Model is not loaded. Ensure the model has been loaded before using runOnFrame.'
-      );
-    }
-
-    // Create reverse map (label → enum value) for classesOfInterest lookup
-    const labelMap: Record<string, number> = {};
-    for (const [name, value] of Object.entries(this.labelMap)) {
-      if (typeof value === 'number') {
-        labelMap[name] = value;
-      }
-    }
-
-    const defaultDetectionThreshold =
-      this.modelConfig.defaultDetectionThreshold ?? 0.7;
-    const defaultIouThreshold = this.modelConfig.defaultIouThreshold ?? 0.55;
-    const defaultInputSize = this.modelConfig.defaultInputSize;
-    const availableInputSizes = this.modelConfig.availableInputSizes;
-
-    return (
-      frame: any,
-      isFrontCamera: boolean,
-      options?: ObjectDetectionOptions<ResolveLabels<T>>
-    ): Detection<ResolveLabels<T>>[] => {
-      'worklet';
-
-      const detectionThreshold =
-        options?.detectionThreshold ?? defaultDetectionThreshold;
-      const iouThreshold = options?.iouThreshold ?? defaultIouThreshold;
-      const inputSize = options?.inputSize ?? defaultInputSize;
-
-      if (
-        availableInputSizes &&
-        inputSize !== undefined &&
-        !availableInputSizes.includes(
-          inputSize as (typeof availableInputSizes)[number]
-        )
-      ) {
-        throw new Error(
-          `Invalid inputSize: ${inputSize}. Available sizes: ${availableInputSizes.join(', ')}`
-        );
-      }
-
-      const methodName =
-        inputSize !== undefined ? `forward_${inputSize}` : 'forward';
-
-      const classIndices = options?.classesOfInterest
-        ? options.classesOfInterest.map((label) => {
-            const labelStr = String(label);
-            const enumValue = labelMap[labelStr];
-            return typeof enumValue === 'number' ? enumValue : -1;
-          })
-        : [];
-
-      return baseRunOnFrame(
-        frame,
-        isFrontCamera,
-        detectionThreshold,
-        iouThreshold,
-        classIndices,
-        methodName
-      );
-    };
-  }
-
-  /**
-   * Executes the model's forward pass to detect objects within the provided image.
-   *
-   * Supports two input types:
-   * 1. **String path/URI**: File path, URL, or Base64-encoded string
-   * 2. **PixelData**: Raw pixel data from image libraries (e.g., NitroImage)
-   * @param input - A string image source (file path, URI, or Base64) or a {@link PixelData} object.
-   * @param options - Optional configuration for detection inference. Includes `detectionThreshold`, `inputSize`, and `classesOfInterest`.
-   * @returns A Promise resolving to an array of {@link Detection} objects.
-   * @throws {RnExecutorchError} If the model is not loaded or if an invalid `inputSize` is provided.
-   * @example
-   * ```typescript
-   * const detections = await model.forward('path/to/image.jpg', {
-   *   detectionThreshold: 0.7,
-   *   inputSize: 640,  // For YOLO models
-   *   classesOfInterest: ['PERSON', 'CAR'],
-   * });
-   * ```
-   */
-  override async forward(
-    input: string | PixelData,
-    options?: ObjectDetectionOptions<ResolveLabels<T>>
-  ): Promise<Detection<ResolveLabels<T>>[]> {
-    if (this.nativeModule == null) {
-      throw new RnExecutorchError(RnExecutorchErrorCode.ModuleNotLoaded);
-    }
-
-    // Extract parameters with defaults from config
-    const detectionThreshold =
-      options?.detectionThreshold ??
-      this.modelConfig.defaultDetectionThreshold ??
-      0.7;
-    const iouThreshold =
-      options?.iouThreshold ?? this.modelConfig.defaultIouThreshold ?? 0.55;
-    const inputSize = options?.inputSize ?? this.modelConfig.defaultInputSize;
-
-    // Validate inputSize against availableInputSizes
-    if (
-      this.modelConfig.availableInputSizes &&
-      inputSize !== undefined &&
-      !this.modelConfig.availableInputSizes.includes(
-        inputSize as (typeof this.modelConfig.availableInputSizes)[number]
-      )
-    ) {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.InvalidArgument,
-        `Invalid inputSize: ${inputSize}. Available sizes: ${this.modelConfig.availableInputSizes.join(', ')}`
-      );
-    }
-
-    // Construct method name: forward_384, forward_512, forward_640, or forward
-    const methodName =
-      inputSize !== undefined ? `forward_${inputSize}` : 'forward';
-
-    // Convert classesOfInterest to indices
-    const classIndices = options?.classesOfInterest
-      ? options.classesOfInterest.map((label) => {
-          const labelStr = String(label);
-          const enumValue = this.labelMap[labelStr as keyof ResolveLabels<T>];
-          return typeof enumValue === 'number' ? enumValue : -1;
-        })
-      : [];
-
-    // Call native with all parameters
-    return typeof input === 'string'
-      ? await this.nativeModule.generateFromString(
-          input,
-          detectionThreshold,
-          iouThreshold,
-          classIndices,
-          methodName
-        )
-      : await this.nativeModule.generateFromPixels(
-          input,
-          detectionThreshold,
-          iouThreshold,
-          classIndices,
-          methodName
-        );
-  }
-
-  /**
-   * Creates an object detection instance with a user-provided model binary and label map.
-   * Use this when working with a custom-exported model that is not one of the built-in presets.
-   * Internally uses `'custom'` as the model name for telemetry unless overridden.
-   *
-   * ## Required model contract
-   *
-   * The `.pte` model binary must expose a single `forward` method with the following interface:
-   *
-   * **Input:** one `float32` tensor of shape `[1, 3, H, W]` — a single RGB image, values in
-   * `[0, 1]` after optional per-channel normalization `(pixel − mean) / std`.
-   * H and W are read from the model's declared input shape at load time.
-   *
-   * **Outputs:** exactly three `float32` tensors, in this order:
-   * 1. Bounding boxes — flat `[4·N]` array of `(x1, y1, x2, y2)` coordinates in model-input
-   *    pixel space, repeated for N detections.
-   * 2. Confidence scores — flat `[N]` array of values in `[0, 1]`.
-   * 3. Class indices — flat `[N]` array of `float32`-encoded integer class indices
-   *    (0-based, matching the order of entries in your `labelMap`).
-   *
-   * Preprocessing (resize → normalize) and postprocessing (coordinate rescaling, threshold
-   * filtering, NMS) are handled by the native runtime — your model only needs to produce
-   * the raw detections above.
-   * @param modelSource - A fetchable resource pointing to the model binary.
-   * @param config - A {@link ObjectDetectionConfig} object with the label map and optional preprocessing parameters.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @returns A Promise resolving to an `ObjectDetectionModule` instance typed to the provided label map.
-   */
-  static async fromCustomModel<L extends LabelEnum>(
-    modelSource: ResourceSource,
-    config: ObjectDetectionConfig<L>,
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<ObjectDetectionModule<L>> {
-    const normMean = config.preprocessorConfig?.normMean ?? [];
-    const normStd = config.preprocessorConfig?.normStd ?? [];
-    const allLabelNames = buildLabelArray(config.labelMap);
-    const modelPath = await fetchModelPath(modelSource, onDownloadProgress);
-    const nativeModule = await global.loadObjectDetection(
-      modelPath,
-      normMean,
-      normStd,
-      allLabelNames
-    );
-    return new ObjectDetectionModule<L>(
-      config.labelMap as ResolveLabels<L>,
-      config,
-      nativeModule
-    );
-  }
-}
diff --git a/packages/react-native-executorch/src/modules/computer_vision/PoseEstimationModule.ts b/packages/react-native-executorch/src/modules/computer_vision/PoseEstimationModule.ts
deleted file mode 100644
index ff2b68b1fd..0000000000
--- a/packages/react-native-executorch/src/modules/computer_vision/PoseEstimationModule.ts
+++ /dev/null
@@ -1,328 +0,0 @@
-import {
-  Frame,
-  LabelEnum,
-  PixelData,
-  ResourceSource,
-} from '../../types/common';
-import {
-  Keypoint,
-  PersonKeypoints,
-  PoseDetections,
-  PoseEstimationOptions,
-  PoseEstimationModelSources,
-  PoseEstimationModelName,
-  PoseEstimationConfig,
-} from '../../types/poseEstimation';
-import { RnExecutorchErrorCode } from '../../errors/ErrorCodes';
-import { RnExecutorchError } from '../../errors/errorUtils';
-import { VisionModule } from './VisionModule';
-import { fetchModelPath } from './VisionLabeledModule';
-import { CocoKeypoint } from '../../constants/poseEstimation';
-import { ResolveConfigOrType } from '../../types/computerVision';
-
-const YOLO_POSE_CONFIG = {
-  keypointMap: CocoKeypoint,
-  preprocessorConfig: undefined,
-  availableInputSizes: [384, 512, 640] as const,
-  defaultInputSize: 384,
-  defaultDetectionThreshold: 0.5,
-  defaultKeypointThreshold: 0.5,
-} satisfies PoseEstimationConfig<typeof CocoKeypoint>;
-
-const ModelConfigs = {
-  'yolo26n-pose': YOLO_POSE_CONFIG,
-} as const satisfies Record<
-  PoseEstimationModelName,
-  PoseEstimationConfig<LabelEnum>
->;
-
-type ModelConfigsType = typeof ModelConfigs;
-
-/**
- * Resolves the {@link LabelEnum} for a given built-in pose estimation model name.
- * @typeParam M - A built-in model name from {@link PoseEstimationModelName}.
- * @category Types
- */
-export type PoseEstimationKeypoints<M extends PoseEstimationModelName> =
-  (typeof ModelConfigs)[M]['keypointMap'];
-
-type ModelNameOf<C extends PoseEstimationModelSources> = C['modelName'];
-
-/** @internal */
-type ResolveKeypoints<T extends PoseEstimationModelName | LabelEnum> =
-  ResolveConfigOrType<T, ModelConfigsType, 'keypointMap'>;
-
-function mapPersonKeypoints<K extends LabelEnum>(
-  raw: Keypoint[][],
-  entries: [string, number][],
-  maxIndex: number
-): PersonKeypoints<K>[] {
-  'worklet';
-  if (raw.length > 0 && raw[0]!.length <= maxIndex) {
-    throw new Error(
-      `Keypoint map references index ${maxIndex} but model returned ${raw[0]!.length} keypoints per person — keypointMap is incompatible with this model.`
-    );
-  }
-  const out: PersonKeypoints<K>[] = [];
-  for (const person of raw) {
-    const named: Record<string, Keypoint> = {};
-    for (const [name, idx] of entries) named[name] = person[idx]!;
-    out.push(named as PersonKeypoints<K>);
-  }
-  return out;
-}
-
-/**
- * Pose estimation module for detecting human body keypoints.
- * @typeParam T - Either a built-in model name (e.g. `'yolo26n-pose'`)
- *   or a custom {@link LabelEnum} keypoint map.
- * @category Typescript API
- */
-export class PoseEstimationModule<
-  T extends PoseEstimationModelName | LabelEnum,
-> extends VisionModule<PoseDetections<ResolveKeypoints<T>>> {
-  private readonly keypointMap: ResolveKeypoints<T>;
-  private readonly modelConfig: PoseEstimationConfig<LabelEnum>;
-  // Numeric TS enums double-list
-  // their keys at runtime (value → name); we keep only the (name, index) pairs
-  private readonly keypointEntries: [string, number][];
-  private readonly maxKeypointIndex: number;
-
-  private constructor(
-    keypointMap: ResolveKeypoints<T>,
-    modelConfig: PoseEstimationConfig<LabelEnum>,
-    nativeModule: unknown
-  ) {
-    super();
-    this.keypointMap = keypointMap;
-    this.modelConfig = modelConfig;
-    this.nativeModule = nativeModule;
-    this.keypointEntries = [];
-    for (const [name, value] of Object.entries(keypointMap)) {
-      if (typeof value === 'number') this.keypointEntries.push([name, value]);
-    }
-    this.maxKeypointIndex = Math.max(...this.keypointEntries.map(([, v]) => v));
-  }
-
-  /**
-   * Creates a pose estimation instance for a built-in model.
-   * @param namedSources - A {@link PoseEstimationModelSources} object specifying which model to load.
-   * @param onDownloadProgress - Optional callback to monitor download progress (0-1).
-   * @returns A Promise resolving to a `PoseEstimationModule` instance typed to the model's keypoint map.
-   */
-  static async fromModelName<C extends PoseEstimationModelSources>(
-    namedSources: C,
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<PoseEstimationModule<ModelNameOf<C>>> {
-    const { modelSource } = namedSources;
-    const modelConfig = ModelConfigs[
-      namedSources.modelName
-    ] as PoseEstimationConfig<LabelEnum>;
-    const { keypointMap, preprocessorConfig } = modelConfig;
-    const normMean = preprocessorConfig?.normMean ?? [];
-    const normStd = preprocessorConfig?.normStd ?? [];
-
-    const modelPath = await fetchModelPath(modelSource, onDownloadProgress);
-    const nativeModule = await global.loadPoseEstimation(
-      modelPath,
-      normMean,
-      normStd
-    );
-
-    return new PoseEstimationModule<ModelNameOf<C>>(
-      keypointMap as ResolveKeypoints<ModelNameOf<C>>,
-      modelConfig,
-      nativeModule
-    );
-  }
-
-  /**
-   * Creates a pose estimation instance with a user-provided model binary and keypoint map.
-   * Use this when working with a custom-exported model that is not one of the built-in presets.
-   * @param modelSource - A fetchable resource pointing to the model binary.
-   * @param config - A {@link PoseEstimationConfig} object with the keypoint map and optional preprocessing parameters.
-   * @param onDownloadProgress - Optional callback to monitor download progress (0-1).
-   * @returns A Promise resolving to a `PoseEstimationModule` instance typed to the provided keypoint map.
-   */
-  static async fromCustomModel<K extends LabelEnum>(
-    modelSource: ResourceSource,
-    config: PoseEstimationConfig<K>,
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<PoseEstimationModule<K>> {
-    const { keypointMap, preprocessorConfig } = config;
-    const normMean = preprocessorConfig?.normMean ?? [];
-    const normStd = preprocessorConfig?.normStd ?? [];
-
-    const modelPath = await fetchModelPath(modelSource, onDownloadProgress);
-    const nativeModule = await global.loadPoseEstimation(
-      modelPath,
-      normMean,
-      normStd
-    );
-
-    return new PoseEstimationModule<K>(
-      keypointMap as ResolveKeypoints<K>,
-      config,
-      nativeModule
-    );
-  }
-
-  /**
-   * Get the keypoint map for this model.
-   * @returns Map of keypoint names to indices, e.g. `{ NOSE: 0, LEFT_EYE: 1, ... }`.
-   */
-  getKeypointMap(): ResolveKeypoints<T> {
-    return this.keypointMap;
-  }
-
-  /**
-   * Returns the available input sizes for this model, or undefined if the model accepts any size.
-   * @returns a readonly number[] specifying what input sizes the model supports.
-   */
-  getAvailableInputSizes(): readonly number[] | undefined {
-    return this.modelConfig.availableInputSizes;
-  }
-
-  /**
-   * Override runOnFrame to provide an options-based API for VisionCamera integration.
-   * @returns A worklet function for frame processing.
-   */
-  override get runOnFrame(): (
-    frame: Frame,
-    isFrontCamera: boolean,
-    options?: PoseEstimationOptions
-  ) => PoseDetections<ResolveKeypoints<T>> {
-    if (!this.nativeModule) {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.ModuleNotLoaded,
-        'Model is not loaded. Ensure the model has been loaded before using runOnFrame.'
-      );
-    }
-
-    const nativeGenerateFromFrame = this.nativeModule.generateFromFrame;
-    const defaultDetectionThreshold =
-      this.modelConfig.defaultDetectionThreshold ?? 0.5;
-    const defaultKeypointThreshold =
-      this.modelConfig.defaultKeypointThreshold ?? 0.5;
-    const defaultInputSize = this.modelConfig.defaultInputSize;
-    const availableInputSizes = this.modelConfig.availableInputSizes;
-    const keypointEntries = this.keypointEntries;
-    const maxKeypointIndex = this.maxKeypointIndex;
-    return (
-      frame: Frame,
-      isFrontCamera: boolean,
-      options?: PoseEstimationOptions
-    ): PoseDetections<ResolveKeypoints<T>> => {
-      'worklet';
-
-      const detectionThreshold =
-        options?.detectionThreshold ?? defaultDetectionThreshold;
-      const keypointThreshold =
-        options?.keypointThreshold ?? defaultKeypointThreshold;
-      const inputSize = options?.inputSize ?? defaultInputSize;
-
-      // Validate inputSize
-      if (
-        availableInputSizes &&
-        inputSize !== undefined &&
-        !availableInputSizes.includes(inputSize)
-      ) {
-        throw new Error(
-          `Invalid inputSize: ${inputSize}. Available sizes: ${availableInputSizes.join(', ')}`
-        );
-      }
-
-      const methodName =
-        inputSize !== undefined ? `forward_${inputSize}` : 'forward';
-
-      let nativeBuffer: { pointer: bigint; release(): void } | null = null;
-      try {
-        nativeBuffer = frame.getNativeBuffer();
-        const frameData = {
-          nativeBuffer: nativeBuffer.pointer,
-          orientation: frame.orientation,
-          isMirrored: isFrontCamera,
-        };
-        const raw: Keypoint[][] = nativeGenerateFromFrame(
-          frameData,
-          detectionThreshold,
-          keypointThreshold,
-          methodName
-        );
-        return mapPersonKeypoints<ResolveKeypoints<T>>(
-          raw,
-          keypointEntries,
-          maxKeypointIndex
-        );
-      } finally {
-        if (nativeBuffer?.release) {
-          nativeBuffer.release();
-        }
-      }
-    };
-  }
-
-  /**
-   * Run pose estimation on an image.
-   * @param input - Image path/URI or PixelData
-   * @param options - Detection options including inputSize for multi-method models
-   * @returns Array of detected people, each with keypoints accessible via the keypoint enum
-   */
-  override async forward(
-    input: string | PixelData,
-    options?: PoseEstimationOptions
-  ): Promise<PoseDetections<ResolveKeypoints<T>>> {
-    if (this.nativeModule == null) {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.ModuleNotLoaded,
-        'Model not loaded. Please load the model before calling forward().'
-      );
-    }
-
-    const detectionThreshold =
-      options?.detectionThreshold ??
-      this.modelConfig.defaultDetectionThreshold ??
-      0.5;
-    const keypointThreshold =
-      options?.keypointThreshold ??
-      this.modelConfig.defaultKeypointThreshold ??
-      0.5;
-    const inputSize = options?.inputSize ?? this.modelConfig.defaultInputSize;
-
-    // Validate inputSize against availableInputSizes
-    if (
-      this.modelConfig.availableInputSizes &&
-      inputSize !== undefined &&
-      !this.modelConfig.availableInputSizes.includes(inputSize)
-    ) {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.InvalidArgument,
-        `Invalid inputSize: ${inputSize}. Available sizes: ${this.modelConfig.availableInputSizes.join(', ')}`
-      );
-    }
-
-    const methodName =
-      inputSize !== undefined ? `forward_${inputSize}` : 'forward';
-
-    const raw: Keypoint[][] =
-      typeof input === 'string'
-        ? await this.nativeModule.generateFromString(
-            input,
-            detectionThreshold,
-            keypointThreshold,
-            methodName
-          )
-        : await this.nativeModule.generateFromPixels(
-            input,
-            detectionThreshold,
-            keypointThreshold,
-            methodName
-          );
-
-    return mapPersonKeypoints<ResolveKeypoints<T>>(
-      raw,
-      this.keypointEntries,
-      this.maxKeypointIndex
-    );
-  }
-}
diff --git a/packages/react-native-executorch/src/modules/computer_vision/SemanticSegmentationModule.ts b/packages/react-native-executorch/src/modules/computer_vision/SemanticSegmentationModule.ts
deleted file mode 100644
index 2cd2ceadd9..0000000000
--- a/packages/react-native-executorch/src/modules/computer_vision/SemanticSegmentationModule.ts
+++ /dev/null
@@ -1,199 +0,0 @@
-import { ResourceSource, LabelEnum, PixelData } from '../../types/common';
-import {
-  DeeplabLabel,
-  ModelNameOf,
-  SemanticSegmentationModelSources,
-  SemanticSegmentationConfig,
-  SemanticSegmentationModelName,
-  SelfieSegmentationLabel,
-} from '../../types/semanticSegmentation';
-import { IMAGENET1K_MEAN, IMAGENET1K_STD } from '../../constants/commonVision';
-import {
-  fetchModelPath,
-  ResolveLabels as ResolveLabelsFor,
-  VisionLabeledModule,
-} from './VisionLabeledModule';
-
-const PascalVocSegmentationConfig = {
-  labelMap: DeeplabLabel,
-  preprocessorConfig: {
-    normMean: IMAGENET1K_MEAN,
-    normStd: IMAGENET1K_STD,
-  },
-};
-const ModelConfigs = {
-  'deeplab-v3-resnet50': PascalVocSegmentationConfig,
-  'deeplab-v3-resnet101': PascalVocSegmentationConfig,
-  'deeplab-v3-mobilenet-v3-large': PascalVocSegmentationConfig,
-  'lraspp-mobilenet-v3-large': PascalVocSegmentationConfig,
-  'fcn-resnet50': PascalVocSegmentationConfig,
-  'fcn-resnet101': PascalVocSegmentationConfig,
-  'deeplab-v3-resnet50-quantized': PascalVocSegmentationConfig,
-  'deeplab-v3-resnet101-quantized': PascalVocSegmentationConfig,
-  'deeplab-v3-mobilenet-v3-large-quantized': PascalVocSegmentationConfig,
-  'lraspp-mobilenet-v3-large-quantized': PascalVocSegmentationConfig,
-  'fcn-resnet50-quantized': PascalVocSegmentationConfig,
-  'fcn-resnet101-quantized': PascalVocSegmentationConfig,
-  'selfie-segmentation': {
-    labelMap: SelfieSegmentationLabel,
-    preprocessorConfig: undefined,
-  },
-} as const satisfies Record<
-  SemanticSegmentationModelName,
-  SemanticSegmentationConfig<LabelEnum>
->;
-
-/** @internal */
-type ModelConfigsType = typeof ModelConfigs;
-
-/**
- * Resolves the {@link LabelEnum} for a given built-in model name.
- * @typeParam M - A built-in model name from {@link SemanticSegmentationModelName}.
- * @category Types
- */
-export type SegmentationLabels<M extends SemanticSegmentationModelName> =
-  ModelConfigsType[M]['labelMap'];
-
-/** @internal */
-type ResolveLabels<T extends SemanticSegmentationModelName | LabelEnum> =
-  ResolveLabelsFor<T, ModelConfigsType>;
-
-/**
- * Generic semantic segmentation module with type-safe label maps.
- * Use a model name (e.g. `'deeplab-v3-resnet50'`) as the generic parameter for built-in models,
- * or a custom label enum for custom configs.
- * @typeParam T - Either a built-in model name (`'deeplab-v3-resnet50'`,
- *   `'deeplab-v3-resnet50-quantized'`, `'deeplab-v3-resnet101'`,
- *   `'deeplab-v3-resnet101-quantized'`, `'deeplab-v3-mobilenet-v3-large'`,
- *   `'deeplab-v3-mobilenet-v3-large-quantized'`, `'lraspp-mobilenet-v3-large'`,
- *   `'lraspp-mobilenet-v3-large-quantized'`, `'fcn-resnet50'`,
- *   `'fcn-resnet50-quantized'`, `'fcn-resnet101'`, `'fcn-resnet101-quantized'`,
- *   `'selfie-segmentation'`) or a custom {@link LabelEnum} label map.
- * @category Typescript API
- */
-export class SemanticSegmentationModule<
-  T extends SemanticSegmentationModelName | LabelEnum,
-> extends VisionLabeledModule<
-  Record<'ARGMAX', Int32Array> & Record<keyof ResolveLabels<T>, Float32Array>,
-  ResolveLabels<T>
-> {
-  private constructor(labelMap: ResolveLabels<T>, nativeModule: unknown) {
-    super(labelMap, nativeModule);
-  }
-
-  /**
-   * Creates a segmentation instance for a built-in model.
-   * The config object is discriminated by `modelName` — each model can require different fields.
-   * @param namedSources - A {@link SemanticSegmentationModelSources} object specifying which model to load and where to fetch it from.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @returns A Promise resolving to a `SemanticSegmentationModule` instance typed to the chosen model's label map.
-   * @example
-   * ```ts
-   * const segmentation = await SemanticSegmentationModule.fromModelName(DEEPLAB_V3_RESNET50);
-   * ```
-   */
-
-  static async fromModelName<C extends SemanticSegmentationModelSources>(
-    namedSources: C,
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<SemanticSegmentationModule<ModelNameOf<C>>> {
-    const { modelName, modelSource } = namedSources;
-    const { labelMap } = ModelConfigs[modelName];
-    const { preprocessorConfig } = ModelConfigs[
-      modelName
-    ] as SemanticSegmentationConfig<LabelEnum>;
-    const normMean = preprocessorConfig?.normMean ?? [];
-    const normStd = preprocessorConfig?.normStd ?? [];
-    const allClassNames = Object.keys(labelMap).filter((k) => isNaN(Number(k)));
-    const modelPath = await fetchModelPath(modelSource, onDownloadProgress);
-    const nativeModule = await global.loadSemanticSegmentation(
-      modelPath,
-      normMean,
-      normStd,
-      allClassNames
-    );
-    return new SemanticSegmentationModule<ModelNameOf<C>>(
-      labelMap as ResolveLabels<ModelNameOf<C>>,
-      nativeModule
-    );
-  }
-
-  /**
-   * Creates a segmentation instance with a user-provided model binary and label map.
-   * Use this when working with a custom-exported segmentation model that is not one of the built-in models.
-   * Internally uses `'custom'` as the model name for telemetry unless overridden.
-   *
-   * ## Required model contract
-   *
-   * The `.pte` model binary must expose a single `forward` method with the following interface:
-   *
-   * **Input:** one `float32` tensor of shape `[1, 3, H, W]` — a single RGB image, values in
-   * `[0, 1]` after optional per-channel normalization `(pixel − mean) / std`.
-   * H and W are read from the model's declared input shape at load time.
-   *
-   * **Output:** one `float32` tensor of shape `[1, C, H_out, W_out]` (NCHW) containing raw
-   * logits — one channel per class, in the same order as the entries in your `labelMap`.
-   * For binary segmentation a single-channel output is also supported: channel 0 is treated
-   * as the foreground probability and a synthetic background channel is added automatically.
-   *
-   * Preprocessing (resize → normalize) and postprocessing (softmax, argmax, resize back to
-   * original dimensions) are handled by the native runtime.
-   * @param modelSource - A fetchable resource pointing to the model binary.
-   * @param config - A {@link SemanticSegmentationConfig} object with the label map and optional preprocessing parameters.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @returns A Promise resolving to a `SemanticSegmentationModule` instance typed to the provided label map.
-   * @example
-   * ```ts
-   * const MyLabels = { BACKGROUND: 0, FOREGROUND: 1 } as const;
-   * const segmentation = await SemanticSegmentationModule.fromCustomModel(
-   *   'https://example.com/custom_model.pte',
-   *   { labelMap: MyLabels },
-   * );
-   * ```
-   */
-  static async fromCustomModel<L extends LabelEnum>(
-    modelSource: ResourceSource,
-    config: SemanticSegmentationConfig<L>,
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<SemanticSegmentationModule<L>> {
-    const normMean = config.preprocessorConfig?.normMean ?? [];
-    const normStd = config.preprocessorConfig?.normStd ?? [];
-    const allClassNames = Object.keys(config.labelMap).filter((k) =>
-      isNaN(Number(k))
-    );
-    const modelPath = await fetchModelPath(modelSource, onDownloadProgress);
-    const nativeModule = await global.loadSemanticSegmentation(
-      modelPath,
-      normMean,
-      normStd,
-      allClassNames
-    );
-    return new SemanticSegmentationModule<L>(
-      config.labelMap as ResolveLabels<L>,
-      nativeModule
-    );
-  }
-
-  /**
-   * Executes the model's forward pass to perform semantic segmentation on the provided image.
-   *
-   * Supports two input types:
-   * 1. **String path/URI**: File path, URL, or Base64-encoded string
-   * 2. **PixelData**: Raw pixel data from image libraries (e.g., NitroImage)
-   *
-   * **Note**: For VisionCamera frame processing, use `runOnFrame` instead.
-   * @param input - Image source (string or PixelData object)
-   * @param classesOfInterest - An optional list of label keys indicating which per-class probability masks to include in the output. `ARGMAX` is always returned regardless.
-   * @param resizeToInput - Whether to resize the output masks to the original input image dimensions. If `false`, returns the raw model output dimensions. Defaults to `true`.
-   * @returns A Promise resolving to an object with an `'ARGMAX'` key mapped to an `Int32Array` of per-pixel class indices, and each requested class label mapped to a `Float32Array` of per-pixel probabilities.
-   * @throws {RnExecutorchError} If the model is not loaded.
-   */
-  override async forward<K extends keyof ResolveLabels<T>>(
-    input: string | PixelData,
-    classesOfInterest: K[] = [],
-    resizeToInput: boolean = true
-  ): Promise<Record<'ARGMAX', Int32Array> & Record<K, Float32Array>> {
-    const classesOfInterestNames = classesOfInterest.map(String);
-    return super.forward(input, classesOfInterestNames, resizeToInput);
-  }
-}
diff --git a/packages/react-native-executorch/src/modules/computer_vision/StyleTransferModule.ts b/packages/react-native-executorch/src/modules/computer_vision/StyleTransferModule.ts
deleted file mode 100644
index 388df968bc..0000000000
--- a/packages/react-native-executorch/src/modules/computer_vision/StyleTransferModule.ts
+++ /dev/null
@@ -1,85 +0,0 @@
-import { ResourceFetcher } from '../../utils/ResourceFetcher';
-import { StyleTransferModelName } from '../../types/styleTransfer';
-import { ResourceSource, PixelData } from '../../types/common';
-import { parseUnknownError, RnExecutorchError } from '../../errors/errorUtils';
-import { RnExecutorchErrorCode } from '../../errors/ErrorCodes';
-import { Logger } from '../../common/Logger';
-import { VisionModule } from './VisionModule';
-
-/**
- * Module for style transfer tasks.
- * @category Typescript API
- */
-export class StyleTransferModule extends VisionModule<PixelData | string> {
-  private constructor(nativeModule: unknown) {
-    super();
-    this.nativeModule = nativeModule;
-  }
-  /**
-   * Creates a style transfer instance for a built-in model.
-   * @param namedSources - An object specifying which built-in model to load and where to fetch it from.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @returns A Promise resolving to a `StyleTransferModule` instance.
-   */
-  static async fromModelName(
-    namedSources: {
-      modelName: StyleTransferModelName;
-      modelSource: ResourceSource;
-    },
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<StyleTransferModule> {
-    try {
-      const paths = await ResourceFetcher.fetch(
-        onDownloadProgress,
-        namedSources.modelSource
-      );
-
-      if (!paths?.[0]) {
-        throw new RnExecutorchError(RnExecutorchErrorCode.DownloadInterrupted);
-      }
-
-      return new StyleTransferModule(await global.loadStyleTransfer(paths[0]));
-    } catch (error) {
-      Logger.error('Load failed:', error);
-      throw parseUnknownError(error);
-    }
-  }
-
-  /**
-   * Creates a style transfer instance with a user-provided model binary.
-   * Use this when working with a custom-exported model that is not one of the built-in presets.
-   * @remarks The native model contract for this method is not formally defined and may change
-   * between releases. Refer to the native source code for the current expected tensor interface.
-   * @param modelSource - A fetchable resource pointing to the model binary.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @returns A Promise resolving to a `StyleTransferModule` instance.
-   */
-  static fromCustomModel(
-    modelSource: ResourceSource,
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<StyleTransferModule> {
-    return StyleTransferModule.fromModelName(
-      { modelName: 'custom' as StyleTransferModelName, modelSource },
-      onDownloadProgress
-    );
-  }
-
-  /**
-   * Executes style transfer on the provided image.
-   * @param input - Image source (string path/URI or `PixelData` from a frame library).
-   * @param outputType - Controls the output format. Defaults to `'pixelData'`, which
-   *   returns raw RGBA pixels suitable for direct rendering. Pass `'url'` to
-   *   have the stylized image saved to a temporary PNG on the device and
-   *   receive a `file://` URI string instead.
-   * @returns A Promise resolving to either a `PixelData` object or a `file://` URI string,
-   *   depending on `outputType`.
-   */
-  async forward<O extends 'pixelData' | 'url' = 'pixelData'>(
-    input: string | PixelData,
-    outputType?: O
-  ): Promise<O extends 'url' ? string : PixelData> {
-    return super.forward(input, outputType === 'url') as Promise<
-      O extends 'url' ? string : PixelData
-    >;
-  }
-}
diff --git a/packages/react-native-executorch/src/modules/computer_vision/TextToImageModule.ts b/packages/react-native-executorch/src/modules/computer_vision/TextToImageModule.ts
deleted file mode 100644
index 18ac17eb47..0000000000
--- a/packages/react-native-executorch/src/modules/computer_vision/TextToImageModule.ts
+++ /dev/null
@@ -1,178 +0,0 @@
-import { ResourceFetcher } from '../../utils/ResourceFetcher';
-import { ResourceSource } from '../../types/common';
-import { TextToImageModelName } from '../../types/tti';
-import { BaseModule } from '../BaseModule';
-
-import { RnExecutorchErrorCode } from '../../errors/ErrorCodes';
-import { parseUnknownError, RnExecutorchError } from '../../errors/errorUtils';
-import { Logger } from '../../common/Logger';
-
-/**
- * Module for text-to-image generation tasks.
- * @category Typescript API
- */
-export class TextToImageModule extends BaseModule {
-  private inferenceCallback: (stepIdx: number) => void;
-
-  private constructor(
-    nativeModule: unknown,
-    inferenceCallback?: (stepIdx: number) => void
-  ) {
-    super();
-    this.nativeModule = nativeModule;
-    this.inferenceCallback = (stepIdx: number) => {
-      inferenceCallback?.(stepIdx);
-    };
-  }
-
-  /**
-   * Creates a Text to Image instance for a built-in model.
-   * @param namedSources - An object specifying the model name, pipeline sources, and optional inference callback.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @returns A Promise resolving to a `TextToImageModule` instance.
-   * @example
-   * ```ts
-   * import { TextToImageModule, BK_SDM_TINY_VPRED_512 } from 'react-native-executorch';
-   * const tti = await TextToImageModule.fromModelName(BK_SDM_TINY_VPRED_512);
-   * ```
-   */
-  static async fromModelName(
-    namedSources: {
-      modelName: TextToImageModelName;
-      tokenizerSource: ResourceSource;
-      schedulerSource: ResourceSource;
-      encoderSource: ResourceSource;
-      unetSource: ResourceSource;
-      decoderSource: ResourceSource;
-      inferenceCallback?: (stepIdx: number) => void;
-    },
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<TextToImageModule> {
-    try {
-      const nativeModule = await TextToImageModule.load(
-        namedSources,
-        onDownloadProgress
-      );
-      return new TextToImageModule(
-        nativeModule,
-        namedSources.inferenceCallback
-      );
-    } catch (error) {
-      Logger.error('Load failed:', error);
-      throw parseUnknownError(error);
-    }
-  }
-
-  /**
-   * Creates a Text to Image instance with user-provided model binaries.
-   * Use this when working with a custom-exported diffusion pipeline.
-   * Internally uses `'custom'` as the model name for telemetry.
-   * @remarks The native model contract for this method is not formally defined and may change
-   * between releases. Refer to the native source code for the current expected tensor interface.
-   * @param sources - An object containing the pipeline source paths.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @param inferenceCallback - Optional callback triggered after each diffusion step.
-   * @returns A Promise resolving to a `TextToImageModule` instance.
-   */
-  static fromCustomModel(
-    sources: {
-      tokenizerSource: ResourceSource;
-      schedulerSource: ResourceSource;
-      encoderSource: ResourceSource;
-      unetSource: ResourceSource;
-      decoderSource: ResourceSource;
-    },
-    onDownloadProgress: (progress: number) => void = () => {},
-    inferenceCallback?: (stepIdx: number) => void
-  ): Promise<TextToImageModule> {
-    return TextToImageModule.fromModelName(
-      {
-        modelName: 'custom' as TextToImageModelName,
-        ...sources,
-        inferenceCallback,
-      },
-      onDownloadProgress
-    );
-  }
-
-  private static async load(
-    model: {
-      tokenizerSource: ResourceSource;
-      schedulerSource: ResourceSource;
-      encoderSource: ResourceSource;
-      unetSource: ResourceSource;
-      decoderSource: ResourceSource;
-    },
-    onDownloadProgressCallback: (progress: number) => void
-  ): Promise<unknown> {
-    const results = await ResourceFetcher.fetch(
-      onDownloadProgressCallback,
-      model.tokenizerSource,
-      model.schedulerSource,
-      model.encoderSource,
-      model.unetSource,
-      model.decoderSource
-    );
-    if (!results || results.length !== 5) {
-      throw new RnExecutorchError(RnExecutorchErrorCode.DownloadInterrupted);
-    }
-    const [tokenizerPath, schedulerPath, encoderPath, unetPath, decoderPath] =
-      results;
-
-    if (
-      !tokenizerPath ||
-      !schedulerPath ||
-      !encoderPath ||
-      !unetPath ||
-      !decoderPath
-    ) {
-      throw new RnExecutorchError(RnExecutorchErrorCode.DownloadInterrupted);
-    }
-
-    const schedulerJson = await ResourceFetcher.fs.readAsString(schedulerPath);
-    const schedulerConfig = JSON.parse(schedulerJson);
-
-    return global.loadTextToImage(
-      tokenizerPath,
-      encoderPath,
-      unetPath,
-      decoderPath,
-      schedulerConfig.beta_start,
-      schedulerConfig.beta_end,
-      schedulerConfig.num_train_timesteps,
-      schedulerConfig.steps_offset
-    );
-  }
-
-  /**
-   * Runs the model to generate an image described by `input`, and conditioned by `seed`, performing `numSteps` inference steps.
-   * The resulting image, with dimensions `imageSize`×`imageSize` pixels, is saved as a PNG on the device and returned as a `file://` URI.
-   * If generation is interrupted before completion, an empty string is returned.
-   * @param input - The text prompt to generate the image from.
-   * @param imageSize - The desired width and height of the output image in pixels.
-   * @param numSteps - The number of inference steps to perform.
-   * @param seed - An optional seed for random number generation to ensure reproducibility.
-   * @returns A `file://` URI pointing to the generated PNG, or an empty string if generation was interrupted.
-   */
-  async forward(
-    input: string,
-    imageSize: number = 512,
-    numSteps: number = 5,
-    seed?: number
-  ): Promise<string> {
-    return await this.nativeModule.generate(
-      input,
-      imageSize,
-      numSteps,
-      seed ? seed : -1,
-      this.inferenceCallback
-    );
-  }
-
-  /**
-   * Interrupts model generation. The model is stopped in the nearest step.
-   */
-  public interrupt(): void {
-    this.nativeModule.interrupt();
-  }
-}
diff --git a/packages/react-native-executorch/src/modules/computer_vision/VerticalOCRModule.ts b/packages/react-native-executorch/src/modules/computer_vision/VerticalOCRModule.ts
deleted file mode 100644
index f9a818d4dc..0000000000
--- a/packages/react-native-executorch/src/modules/computer_vision/VerticalOCRModule.ts
+++ /dev/null
@@ -1,103 +0,0 @@
-import { Logger } from '../../common/Logger';
-import { VerticalOCRController } from '../../controllers/VerticalOCRController';
-import { parseUnknownError } from '../../errors/errorUtils';
-import { ResourceSource } from '../../types/common';
-import { OCRDetection, OCRLanguage, OCRModelName } from '../../types/ocr';
-
-/**
- * Module for Vertical Optical Character Recognition (Vertical OCR) tasks.
- * @category Typescript API
- */
-export class VerticalOCRModule {
-  private controller: VerticalOCRController;
-
-  private constructor(controller: VerticalOCRController) {
-    this.controller = controller;
-  }
-
-  /**
-   * Creates a Vertical OCR instance for a built-in model.
-   * @param namedSources - An object specifying the model name, detector source, recognizer source, language, and optional independent characters flag.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @returns A Promise resolving to a `VerticalOCRModule` instance.
-   * @example
-   * ```ts
-   * import { VerticalOCRModule, OCR_JAPANESE } from 'react-native-executorch';
-   * const ocr = await VerticalOCRModule.fromModelName({ ...OCR_JAPANESE, independentCharacters: true });
-   * ```
-   */
-  static async fromModelName(
-    namedSources: {
-      modelName: OCRModelName;
-      detectorSource: ResourceSource;
-      recognizerSource: ResourceSource;
-      language: OCRLanguage;
-      independentCharacters?: boolean;
-    },
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<VerticalOCRModule> {
-    try {
-      const controller = new VerticalOCRController();
-      await controller.load(
-        namedSources.detectorSource,
-        namedSources.recognizerSource,
-        namedSources.language,
-        namedSources.independentCharacters ?? false,
-        onDownloadProgress
-      );
-      return new VerticalOCRModule(controller);
-    } catch (error) {
-      Logger.error('Load failed:', error);
-      throw parseUnknownError(error);
-    }
-  }
-
-  /**
-   * Creates a Vertical OCR instance with a user-provided model binary.
-   * Use this when working with a custom-exported Vertical OCR model.
-   * Internally uses `'custom'` as the model name for telemetry.
-   * @remarks The native model contract for this method is not formally defined and may change
-   * between releases. Refer to the native source code for the current expected tensor interface.
-   * @param detectorSource - A fetchable resource pointing to the text detector model binary.
-   * @param recognizerSource - A fetchable resource pointing to the text recognizer model binary.
-   * @param language - The language for the OCR model.
-   * @param independentCharacters - Whether to treat characters independently during recognition.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @returns A Promise resolving to a `VerticalOCRModule` instance.
-   */
-  static fromCustomModel(
-    detectorSource: ResourceSource,
-    recognizerSource: ResourceSource,
-    language: OCRLanguage,
-    independentCharacters: boolean = false,
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<VerticalOCRModule> {
-    return VerticalOCRModule.fromModelName(
-      {
-        modelName: `ocr-${language}` as OCRModelName,
-        detectorSource,
-        recognizerSource,
-        language,
-        independentCharacters,
-      },
-      onDownloadProgress
-    );
-  }
-
-  /**
-   * Executes the model's forward pass, where `imageSource` can be a fetchable resource or a Base64-encoded string.
-   * @param imageSource - The image source to be processed.
-   * @returns The OCR result as a `OCRDetection[]`.
-   */
-  async forward(imageSource: string): Promise<OCRDetection[]> {
-    return await this.controller.forward(imageSource);
-  }
-
-  /**
-   * Release the memory held by the module. Calling `forward` afterwards is invalid.
-   * Note that you cannot delete model while it's generating.
-   */
-  delete() {
-    this.controller.delete();
-  }
-}
diff --git a/packages/react-native-executorch/src/modules/computer_vision/VisionLabeledModule.ts b/packages/react-native-executorch/src/modules/computer_vision/VisionLabeledModule.ts
deleted file mode 100644
index 19adaa9ab4..0000000000
--- a/packages/react-native-executorch/src/modules/computer_vision/VisionLabeledModule.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-import { LabelEnum, ResourceSource } from '../../types/common';
-import { ResourceFetcher } from '../../utils/ResourceFetcher';
-import { RnExecutorchErrorCode } from '../../errors/ErrorCodes';
-import { RnExecutorchError } from '../../errors/errorUtils';
-import { VisionModule } from './VisionModule';
-
-export { ResolveLabels } from '../../types/computerVision';
-
-/**
- * Fetches a model binary and returns its local path, throwing if the download
- * was interrupted (paused or cancelled).
- * @param source - The resource source to fetch the model binary from.
- * @param onDownloadProgress - Callback invoked with download progress (0–1).
- * @returns A promise resolving to the local file path of the downloaded model.
- * @internal
- */
-export async function fetchModelPath(
-  source: ResourceSource,
-  onDownloadProgress: (progress: number) => void
-): Promise<string> {
-  const paths = await ResourceFetcher.fetch(onDownloadProgress, source);
-  if (!paths?.[0]) {
-    throw new RnExecutorchError(
-      RnExecutorchErrorCode.DownloadInterrupted,
-      'The download has been interrupted. Please retry.'
-    );
-  }
-  return paths[0];
-}
-
-/**
- * Base class for computer vision modules that carry a type-safe label map
- * and support the full VisionModule API (string/PixelData forward + runOnFrame).
- * @typeParam TOutput - The model's output type.
- * @typeParam LabelMap - The resolved {@link LabelEnum} for the model's output classes.
- * @internal
- */
-export abstract class VisionLabeledModule<
-  TOutput = unknown,
-  LabelMap extends LabelEnum = LabelEnum,
-> extends VisionModule<TOutput> {
-  protected readonly labelMap: LabelMap;
-
-  protected constructor(labelMap: LabelMap, nativeModule: unknown) {
-    super();
-    this.labelMap = labelMap;
-    this.nativeModule = nativeModule;
-  }
-}
diff --git a/packages/react-native-executorch/src/modules/computer_vision/VisionModule.ts b/packages/react-native-executorch/src/modules/computer_vision/VisionModule.ts
deleted file mode 100644
index 84e3784623..0000000000
--- a/packages/react-native-executorch/src/modules/computer_vision/VisionModule.ts
+++ /dev/null
@@ -1,147 +0,0 @@
-import { BaseModule } from '../BaseModule';
-import { RnExecutorchErrorCode } from '../../errors/ErrorCodes';
-import { RnExecutorchError } from '../../errors/errorUtils';
-import { Frame, PixelData, ScalarType } from '../../types/common';
-
-export function isPixelData(input: unknown): input is PixelData {
-  return (
-    typeof input === 'object' &&
-    input !== null &&
-    'dataPtr' in input &&
-    input.dataPtr instanceof Uint8Array &&
-    'sizes' in input &&
-    Array.isArray(input.sizes) &&
-    input.sizes.length === 3 &&
-    'scalarType' in input &&
-    input.scalarType === ScalarType.BYTE
-  );
-}
-
-/**
- * Base class for computer vision models that support multiple input types.
- *
- * VisionModule extends BaseModule with:
- * - Unified `forward()` API accepting string paths or raw pixel data
- * - `runOnFrame` getter for real-time VisionCamera frame processing
- * - Shared frame processor creation logic
- *
- * Subclasses implement model-specific loading logic and may override `forward` for typed signatures.
- * @category Typescript API
- */
-export abstract class VisionModule<TOutput> extends BaseModule {
-  /**
-   * Synchronous worklet function for real-time VisionCamera frame processing.
-   *
-   * Only available after the model is loaded.
-   *
-   * **Use this for VisionCamera frame processing in worklets.**
-   * For async processing, use `forward()` instead.
-   * @example
-   * ```typescript
-   * const model = new ClassificationModule();
-   * await model.load({ modelSource: MODEL });
-   *
-   * // Use the functional form of setState to store the worklet — passing it
-   * // directly would cause React to invoke it immediately as an updater fn.
-   * const [runOnFrame, setRunOnFrame] = useState(null);
-   * setRunOnFrame(() => model.runOnFrame);
-   *
-   * const frameOutput = useFrameOutput({
-   *   onFrame(frame) {
-   *     'worklet';
-   *     if (!runOnFrame) return;
-   *     const result = runOnFrame(frame, isFrontCamera);
-   *     frame.dispose();
-   *   }
-   * });
-   * ```
-   * @returns A worklet function for frame processing.
-   * @throws {RnExecutorchError} If the model is not loaded.
-   */
-  get runOnFrame(): (frame: Frame, ...args: any[]) => TOutput {
-    if (!this.nativeModule) {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.ModuleNotLoaded,
-        'The model is currently not loaded. Please load the model before calling runOnFrame().'
-      );
-    }
-
-    // Extract pure JSI function reference (runs on JS thread)
-    const nativeGenerateFromFrame = this.nativeModule.generateFromFrame;
-
-    // Return worklet that captures ONLY the JSI function
-    return (frame: Frame, isFrontCamera: boolean, ...args: any[]): TOutput => {
-      'worklet';
-
-      let nativeBuffer: { pointer: bigint; release(): void } | null = null;
-      try {
-        nativeBuffer = frame.getNativeBuffer();
-        /**
-        Currently isMirrored is never set to true in VisionCamera.
-        That's why we need to use our own property to determine if we need
-        to mirror the results
-         */
-        const frameData = {
-          nativeBuffer: nativeBuffer.pointer,
-          orientation: frame.orientation,
-          isMirrored: isFrontCamera,
-        };
-        return nativeGenerateFromFrame(frameData, ...args);
-      } finally {
-        if (nativeBuffer?.release) {
-          nativeBuffer.release();
-        }
-      }
-    };
-  }
-
-  /**
-   * Executes the model's forward pass with automatic input type detection.
-   *
-   * Supports two input types:
-   * 1. **String path/URI**: File path, URL, or Base64-encoded string
-   * 2. **PixelData**: Raw pixel data from image libraries (e.g., NitroImage)
-   *
-   * **Note**: For VisionCamera frame processing, use `runOnFrame` instead.
-   * This method is async and cannot be called in worklet context.
-   * @param input - Image source (string path or PixelData object)
-   * @param args - Additional model-specific arguments
-   * @returns A Promise that resolves to the model output.
-   * @example
-   * ```typescript
-   * // String path (async)
-   * const result1 = await model.forward('file:///path/to/image.jpg');
-   *
-   * // Pixel data (async)
-   * const result2 = await model.forward({
-   *   dataPtr: new Uint8Array(pixelBuffer),
-   *   sizes: [480, 640, 3],
-   *   scalarType: ScalarType.BYTE
-   * });
-   *
-   * // For VisionCamera frames, use runOnFrame in worklet:
-   * const frameOutput = useFrameOutput({
-   *   onFrame(frame) {
-   *     'worklet';
-   *     if (!model.runOnFrame) return;
-   *     const result = model.runOnFrame(frame);
-   *   }
-   * });
-   * ```
-   */
-  async forward(input: string | PixelData, ...args: any[]): Promise<TOutput> {
-    if (this.nativeModule == null)
-      throw new RnExecutorchError(RnExecutorchErrorCode.ModuleNotLoaded);
-    // Type detection and routing
-    if (typeof input === 'string') {
-      return await this.nativeModule.generateFromString(input, ...args);
-    } else if (isPixelData(input)) {
-      return await this.nativeModule.generateFromPixels(input, ...args);
-    } else {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.InvalidArgument,
-        'Invalid input: expected string path or PixelData object. For VisionCamera frames, use runOnFrame instead.'
-      );
-    }
-  }
-}
diff --git a/packages/react-native-executorch/src/modules/general/ExecutorchModule.ts b/packages/react-native-executorch/src/modules/general/ExecutorchModule.ts
deleted file mode 100644
index ed98b92698..0000000000
--- a/packages/react-native-executorch/src/modules/general/ExecutorchModule.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import { TensorPtr } from '../../types/common';
-import { BaseModule } from '../BaseModule';
-import { ResourceSource } from '../../types/common';
-import { ResourceFetcher } from '../../utils/ResourceFetcher';
-import { RnExecutorchErrorCode } from '../../errors/ErrorCodes';
-import { parseUnknownError, RnExecutorchError } from '../../errors/errorUtils';
-import { Logger } from '../../common/Logger';
-
-/**
- * General module for executing custom Executorch models.
- * @category Typescript API
- */
-export class ExecutorchModule extends BaseModule {
-  /**
-   * Loads the model, where `modelSource` is a string, number, or object that specifies the location of the model binary.
-   * Optionally accepts a download progress callback.
-   * @param modelSource - Source of the model to be loaded.
-   * @param onDownloadProgressCallback - Optional callback to monitor download progress.
-   */
-  async load(
-    modelSource: ResourceSource,
-    onDownloadProgressCallback: (progress: number) => void = () => {}
-  ): Promise<void> {
-    try {
-      const paths = await ResourceFetcher.fetch(
-        onDownloadProgressCallback,
-        modelSource
-      );
-      if (!paths?.[0]) {
-        throw new RnExecutorchError(RnExecutorchErrorCode.DownloadInterrupted);
-      }
-      this.nativeModule = await global.loadExecutorchModule(paths[0]);
-    } catch (error) {
-      Logger.error('Load failed:', error);
-      throw parseUnknownError(error);
-    }
-  }
-
-  /**
-   * Executes the model's forward pass, where input is an array of `TensorPtr` objects.
-   * If the inference is successful, an array of tensor pointers is returned.
-   * @param inputTensor - Array of input tensor pointers.
-   * @returns An array of output tensor pointers.
-   */
-  async forward(inputTensor: TensorPtr[]): Promise<TensorPtr[]> {
-    return await this.forwardET(inputTensor);
-  }
-}
diff --git a/packages/react-native-executorch/src/modules/natural_language_processing/LLMModule.ts b/packages/react-native-executorch/src/modules/natural_language_processing/LLMModule.ts
deleted file mode 100644
index be6ecb229b..0000000000
--- a/packages/react-native-executorch/src/modules/natural_language_processing/LLMModule.ts
+++ /dev/null
@@ -1,238 +0,0 @@
-import { LLMController } from '../../controllers/LLMController';
-import { Logger } from '../../common/Logger';
-import { parseUnknownError } from '../../errors/errorUtils';
-import { ResourceSource } from '../../types/common';
-import {
-  AudioConfig,
-  LLMCapability,
-  LLMConfig,
-  LLMModelName,
-  LLMTool,
-  Message,
-} from '../../types/llm';
-
-/**
- * Module for managing a Large Language Model (LLM) instance.
- * @category Typescript API
- */
-export class LLMModule {
-  private controller: LLMController;
-
-  private constructor({
-    tokenCallback,
-    messageHistoryCallback,
-  }: {
-    tokenCallback?: (token: string) => void;
-    messageHistoryCallback?: (messageHistory: Message[]) => void;
-  } = {}) {
-    this.controller = new LLMController({
-      tokenCallback,
-      messageHistoryCallback,
-    });
-  }
-
-  /**
-   * Creates an LLM instance for a built-in model.
-   * @param namedSources - An object specifying the model name, model source, tokenizer source,
-   *   tokenizer config source, and optional capabilities.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @param tokenCallback - Optional callback invoked on every generated token.
-   * @param messageHistoryCallback - Optional callback invoked when the model finishes a response, with the full message history.
-   * @returns A Promise resolving to an `LLMModule` instance.
-   * @example
-   * ```ts
-   * import { LLMModule, LLAMA3_2_3B } from 'react-native-executorch';
-   * const llm = await LLMModule.fromModelName(LLAMA3_2_3B);
-   * ```
-   */
-  static async fromModelName(
-    namedSources: {
-      modelName: LLMModelName;
-      modelSource: ResourceSource;
-      tokenizerSource: ResourceSource;
-      tokenizerConfigSource: ResourceSource;
-      capabilities?: readonly LLMCapability[];
-      audioConfig?: AudioConfig;
-    },
-    onDownloadProgress: (progress: number) => void = () => {},
-    tokenCallback?: (token: string) => void,
-    messageHistoryCallback?: (messageHistory: Message[]) => void
-  ): Promise<LLMModule> {
-    const instance = new LLMModule({ tokenCallback, messageHistoryCallback });
-    try {
-      await instance.controller.load({
-        model: {
-          modelName: namedSources.modelName,
-          modelSource: namedSources.modelSource,
-          tokenizerSource: namedSources.tokenizerSource,
-          tokenizerConfigSource: namedSources.tokenizerConfigSource,
-          capabilities: namedSources.capabilities,
-          audioConfig: namedSources.audioConfig,
-        },
-        onDownloadProgressCallback: onDownloadProgress,
-      });
-      return instance;
-    } catch (error) {
-      Logger.error('Load failed:', error);
-      throw parseUnknownError(error);
-    }
-  }
-
-  /**
-   * Creates an LLM instance with a user-provided model binary.
-   * Use this when working with a custom-exported LLM.
-   * Internally uses `'custom'` as the model name for telemetry.
-   *
-   * ## Required model contract
-   *
-   * The `.pte` model binary must be exported following the
-   * [ExecuTorch LLM export process](https://docs.pytorch.org/executorch/1.1/llm/export-llm.html).
-   * The native runner expects the standard ExecuTorch text-generation interface — KV-cache
-   * management, prefill/decode phases, and logit sampling are all handled by the runtime.
-   * @param modelSource - A fetchable resource pointing to the model binary.
-   * @param tokenizerSource - A fetchable resource pointing to the tokenizer JSON file.
-   * @param tokenizerConfigSource - A fetchable resource pointing to the tokenizer config JSON file.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @param tokenCallback - Optional callback invoked on every generated token.
-   * @param messageHistoryCallback - Optional callback invoked when the model finishes a response, with the full message history.
-   * @returns A Promise resolving to an `LLMModule` instance.
-   */
-  static fromCustomModel(
-    modelSource: ResourceSource,
-    tokenizerSource: ResourceSource,
-    tokenizerConfigSource: ResourceSource,
-    onDownloadProgress: (progress: number) => void = () => {},
-    tokenCallback?: (token: string) => void,
-    messageHistoryCallback?: (messageHistory: Message[]) => void
-  ): Promise<LLMModule> {
-    return LLMModule.fromModelName(
-      {
-        modelName: 'custom' as LLMModelName,
-        modelSource,
-        tokenizerSource,
-        tokenizerConfigSource,
-      },
-      onDownloadProgress,
-      tokenCallback,
-      messageHistoryCallback
-    );
-  }
-
-  /**
-   * Sets new token callback invoked on every token batch.
-   * @param tokenCallback - Callback function to handle new tokens.
-   */
-  setTokenCallback({
-    tokenCallback,
-  }: {
-    tokenCallback: (token: string) => void;
-  }) {
-    this.controller.setTokenCallback(tokenCallback);
-  }
-
-  /**
-   * Configures chat and tool calling and generation settings.
-   * See [Configuring the model](https://docs.swmansion.com/react-native-executorch/docs/hooks/natural-language-processing/useLLM#configuring-the-model) for details.
-   * @param config - Configuration object containing `chatConfig`, `toolsConfig`, and `generationConfig`.
-   */
-  configure(config: LLMConfig) {
-    this.controller.configure(config);
-  }
-
-  /**
-   * Runs model inference with raw input string.
-   * You need to provide entire conversation and prompt (in correct format and with special tokens!) in input string to this method.
-   * It doesn't manage conversation context. It is intended for users that need access to the model itself without any wrapper.
-   * If you want a simple chat with model the consider using `sendMessage`
-   * @param input - Raw input string containing the prompt and conversation history.
-   * @param imagePaths - Optional array of local image paths for multimodal inference. Each entry may be either `file:///absolute/path` or `/absolute/path` — the controller normalizes the path before passing it to native code.
-   * @param audioWaveforms - Optional array of 16kHz waveforms of audio recordings for multimodal inference.
-   * @returns The generated response as a string.
-   */
-  async forward(
-    input: string,
-    imagePaths?: string[],
-    audioWaveforms?: Float32Array[]
-  ): Promise<string> {
-    return await this.controller.forward(input, imagePaths, audioWaveforms);
-  }
-
-  /**
-   * Runs model to complete chat passed in `messages` argument. It doesn't manage conversation context.
-   * For multimodal models, set `mediaPath` on user messages to include images.
-   * @param messages - Array of messages representing the chat history. User messages may include a `mediaPath` field with a local image path.
-   * @param tools - Optional array of tools that can be used during generation.
-   * @returns The generated response as a string.
-   */
-  async generate(messages: Message[], tools?: LLMTool[]): Promise<string> {
-    return await this.controller.generate(messages, tools);
-  }
-
-  /**
-   * Method to add user message to conversation.
-   * After model responds it will call `messageHistoryCallback()` containing both user message and model response.
-   * It also returns them.
-   * @param message - The message string to send.
-   * @param media - Optional media object containing a local image path or 16kHz waveform of an audio recording for multimodal models.
-   * @returns - Updated message history including the new user message and model response.
-   */
-  async sendMessage(
-    message: string,
-    media?: { imagePath?: string; audioBuffer?: Float32Array }
-  ): Promise<Message[]> {
-    await this.controller.sendMessage(message, media);
-    return this.controller.messageHistory;
-  }
-
-  /**
-   * Deletes all messages starting with message on `index` position.
-   * After deletion it will call `messageHistoryCallback()` containing new history.
-   * It also returns it.
-   * @param index - The index of the message to delete from history.
-   * @returns - Updated message history after deletion.
-   */
-  deleteMessage(index: number): Message[] {
-    this.controller.deleteMessage(index);
-    return this.controller.messageHistory;
-  }
-
-  /**
-   * Interrupts model generation. It may return one more token after interrupt.
-   */
-  interrupt() {
-    this.controller.interrupt();
-  }
-
-  /**
-   * Returns the number of tokens generated in the last response.
-   * @returns The count of generated tokens.
-   */
-  getGeneratedTokenCount(): number {
-    return this.controller.getGeneratedTokenCount();
-  }
-
-  /**
-   * Returns the number of prompt tokens in the last message.
-   * @returns The count of prompt token.
-   */
-  getPromptTokensCount() {
-    return this.controller.getPromptTokenCount();
-  }
-
-  /**
-   * Returns the number of total tokens from the previous generation. This is a sum of prompt tokens and generated tokens.
-   * @returns The count of prompt and generated tokens.
-   */
-  getTotalTokensCount() {
-    return this.controller.getTotalTokenCount();
-  }
-
-  /**
-   * Method to delete the model from memory.
-   * Note you cannot delete model while it's generating.
-   * You need to interrupt it first and make sure model stopped generation.
-   */
-  delete() {
-    this.controller.delete();
-  }
-}
diff --git a/packages/react-native-executorch/src/modules/natural_language_processing/PrivacyFilterModule.ts b/packages/react-native-executorch/src/modules/natural_language_processing/PrivacyFilterModule.ts
deleted file mode 100644
index 9b010f4c14..0000000000
--- a/packages/react-native-executorch/src/modules/natural_language_processing/PrivacyFilterModule.ts
+++ /dev/null
@@ -1,137 +0,0 @@
-import { ResourceSource } from '../../types/common';
-import {
-  PiiEntity,
-  PrivacyFilterModelSources,
-  ViterbiBiases,
-} from '../../types/privacyFilter';
-import { PRIVACY_FILTER_LABELS } from '../../constants/privacyFilterLabels';
-import { ResourceFetcher } from '../../utils/ResourceFetcher';
-import { BaseModule } from '../BaseModule';
-import { RnExecutorchErrorCode } from '../../errors/ErrorCodes';
-import { parseUnknownError, RnExecutorchError } from '../../errors/errorUtils';
-import { Logger } from '../../common/Logger';
-
-/**
- * Pack the optional ViterbiBiases struct into a 6-element array in the
- * fixed order the native side expects. Missing fields default to 0.
- * @param biases - Caller-supplied biases (any subset of the 6 fields).
- * @returns A 6-element number[] in the canonical bias order.
- */
-function packViterbiBiases(biases?: ViterbiBiases): number[] {
-  return [
-    biases?.backgroundStay ?? 0,
-    biases?.backgroundToStart ?? 0,
-    biases?.endToBackground ?? 0,
-    biases?.endToStart ?? 0,
-    biases?.insideToContinue ?? 0,
-    biases?.insideToEnd ?? 0,
-  ];
-}
-
-/**
- * Module for running token-level PII detection over text. Supports any
- * privacy-filter-style model with a `forward(input_ids, attention_mask)`
- * graph and a BIOES label space (the runner reads `labelNames` to map
- * predicted indices back to entity types).
- * @category Typescript API
- */
-export class PrivacyFilterModule extends BaseModule {
-  private constructor(nativeModule: unknown) {
-    super();
-    this.nativeModule = nativeModule;
-  }
-
-  /**
-   * Creates a Privacy Filter instance for a built-in preset. Pass one of
-   * the `PRIVACY_FILTER_*` constants from `react-native-executorch/constants`
-   * (or the matching `models.privacy_filter.*` accessor); the runner
-   * resolves the BIOES label list from `modelName`. For custom fine-tunes
-   * with a non-standard label space, use {@link fromCustomModel} instead.
-   * @param namedSources - Built-in model + tokenizer resource locations.
-   * @param onDownloadProgress - Optional 0..1 download progress callback.
-   * @returns A Promise resolving to a `PrivacyFilterModule` instance.
-   */
-  static fromModelName(
-    namedSources: PrivacyFilterModelSources,
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<PrivacyFilterModule> {
-    return PrivacyFilterModule.load(
-      namedSources.modelSource,
-      namedSources.tokenizerSource,
-      PRIVACY_FILTER_LABELS[namedSources.modelName],
-      undefined,
-      onDownloadProgress
-    );
-  }
-
-  /**
-   * Creates a Privacy Filter instance with a user-provided model binary and tokenizer.
-   * Use this when working with a custom-exported model that is not one of the built-in presets.
-   * @remarks The `labelNames` array must match the model's head dimension and id2label mapping exactly.
-   * @param modelSource - A fetchable resource pointing to the .pte file.
-   * @param tokenizerSource - A fetchable resource pointing to the tokenizer.json.
-   * @param labelNames - BIOES label list; index 0 must be "O".
-   * @param options - Optional Viterbi biases and download progress callback.
-   * @returns A Promise resolving to a `PrivacyFilterModule` instance.
-   */
-  static fromCustomModel(
-    modelSource: ResourceSource,
-    tokenizerSource: ResourceSource,
-    labelNames: readonly string[],
-    options: {
-      viterbiBiases?: ViterbiBiases;
-      onDownloadProgress?: (progress: number) => void;
-    } = {}
-  ): Promise<PrivacyFilterModule> {
-    return PrivacyFilterModule.load(
-      modelSource,
-      tokenizerSource,
-      labelNames,
-      options.viterbiBiases,
-      options.onDownloadProgress ?? (() => {})
-    );
-  }
-
-  private static async load(
-    modelSource: ResourceSource,
-    tokenizerSource: ResourceSource,
-    labelNames: readonly string[],
-    viterbiBiases: ViterbiBiases | undefined,
-    onDownloadProgress: (progress: number) => void
-  ): Promise<PrivacyFilterModule> {
-    try {
-      const [modelResult, tokenizerResult] = await Promise.all([
-        ResourceFetcher.fetch(onDownloadProgress, modelSource),
-        ResourceFetcher.fetch(undefined, tokenizerSource),
-      ]);
-      const modelPath = modelResult?.[0];
-      const tokenizerPath = tokenizerResult?.[0];
-      if (!modelPath || !tokenizerPath) {
-        throw new RnExecutorchError(RnExecutorchErrorCode.DownloadInterrupted);
-      }
-      const labels = Array.from(labelNames);
-      const biases = packViterbiBiases(viterbiBiases);
-      return new PrivacyFilterModule(
-        await global.loadPrivacyFilter(modelPath, tokenizerPath, labels, biases)
-      );
-    } catch (error) {
-      Logger.error('Load failed:', error);
-      throw parseUnknownError(error);
-    }
-  }
-
-  /**
-   * Executes the model's forward pass to detect PII entity spans within the provided text.
-   * @param text - The input text to scan for PII.
-   * @returns A Promise resolving to an array of detected {@link PiiEntity} spans.
-   */
-  async generate(text: string): Promise<PiiEntity[]> {
-    if (this.nativeModule == null) {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.ModuleNotLoaded,
-        'The model is currently not loaded. Please load the model before calling generate().'
-      );
-    }
-    return (await this.nativeModule.generate(text)) as PiiEntity[];
-  }
-}
diff --git a/packages/react-native-executorch/src/modules/natural_language_processing/SpeechToTextModule.ts b/packages/react-native-executorch/src/modules/natural_language_processing/SpeechToTextModule.ts
deleted file mode 100644
index f7ffe52f1c..0000000000
--- a/packages/react-native-executorch/src/modules/natural_language_processing/SpeechToTextModule.ts
+++ /dev/null
@@ -1,295 +0,0 @@
-import {
-  DecodingOptions,
-  SpeechToTextModelConfig,
-  SpeechToTextModelName,
-  StreamingOptions,
-  TranscriptionResult,
-} from '../../types/stt';
-import { VADConfig } from '../../types/vad';
-import { ResourceFetcher } from '../../utils/ResourceFetcher';
-import { ResourceSource } from '../../types/common';
-import { RnExecutorchErrorCode } from '../../errors/ErrorCodes';
-import { RnExecutorchError, parseUnknownError } from '../../errors/errorUtils';
-import { Logger } from '../../common/Logger';
-
-/**
- * Module for Speech to Text (STT) functionalities.
- * @category Typescript API
- */
-export class SpeechToTextModule {
-  private nativeModule: any;
-  private modelConfig: SpeechToTextModelConfig;
-
-  private constructor(
-    nativeModule: unknown,
-    modelConfig: SpeechToTextModelConfig
-  ) {
-    this.nativeModule = nativeModule;
-    this.modelConfig = modelConfig;
-  }
-
-  /**
-   * Creates a Speech to Text instance for a built-in model.
-   * @param namedSources - Configuration object containing model name, sources, and multilingual flag.
-   * @param vad - Optional configuration for Voice Activity Detection (VAD).
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @returns A Promise resolving to a `SpeechToTextModule` instance.
-   * @example
-   * ```ts
-   * import { SpeechToTextModule, WHISPER_TINY_EN } from 'react-native-executorch';
-   * const stt = await SpeechToTextModule.fromModelName(WHISPER_TINY_EN);
-   * ```
-   */
-  static async fromModelName(
-    namedSources: SpeechToTextModelConfig,
-    vad?: VADConfig,
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<SpeechToTextModule> {
-    try {
-      const nativeModule = await SpeechToTextModule.loadWhisper(
-        namedSources,
-        vad,
-        onDownloadProgress
-      );
-      return new SpeechToTextModule(nativeModule, namedSources);
-    } catch (error) {
-      Logger.error('Load failed:', error);
-      throw parseUnknownError(error);
-    }
-  }
-
-  /**
-   * Creates a Speech to Text instance with user-provided model binaries.
-   * Use this when working with a custom-exported STT model.
-   * Internally uses `'custom'` as the model name for telemetry.
-   * @remarks The native model contract for this method is not formally defined and may change
-   * between releases. Currently only the Whisper architecture is supported by the native runner.
-   * Refer to the native source code for the current expected interface.
-   * @param modelSource - A fetchable resource pointing to the model binary.
-   * @param tokenizerSource - A fetchable resource pointing to the tokenizer file.
-   * @param isMultilingual - Whether the model supports multiple languages.
-   * @param vad - Optional VAD configuration.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @returns A Promise resolving to a `SpeechToTextModule` instance.
-   */
-  static fromCustomModel(
-    modelSource: ResourceSource,
-    tokenizerSource: ResourceSource,
-    isMultilingual: boolean,
-    vad?: VADConfig,
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<SpeechToTextModule> {
-    return SpeechToTextModule.fromModelName(
-      {
-        modelName: 'custom' as SpeechToTextModelName,
-        modelSource,
-        tokenizerSource,
-        isMultilingual,
-      },
-      vad,
-      onDownloadProgress
-    );
-  }
-
-  private static async loadWhisper(
-    model: SpeechToTextModelConfig,
-    vad: VADConfig | undefined,
-    onDownloadProgressCallback: (progress: number) => void
-  ): Promise<unknown> {
-    const tokenizerLoadPromise = ResourceFetcher.fetch(
-      undefined,
-      model.tokenizerSource
-    );
-    const modelPromise = ResourceFetcher.fetch(
-      onDownloadProgressCallback,
-      model.modelSource
-    );
-    const vadPromise = vad
-      ? ResourceFetcher.fetch(undefined, vad.modelSource)
-      : Promise.resolve(undefined);
-
-    const [tokenizerSources, modelSources, vadSources] = await Promise.all([
-      tokenizerLoadPromise,
-      modelPromise,
-      vadPromise,
-    ]);
-    if (!modelSources?.[0] || !tokenizerSources?.[0]) {
-      throw new RnExecutorchError(RnExecutorchErrorCode.DownloadInterrupted);
-    }
-    // Currently only Whisper architecture is supported
-    return await global.loadSpeechToText(
-      'whisper',
-      modelSources[0],
-      tokenizerSources[0],
-      vadSources?.[0] || ''
-    );
-  }
-
-  /**
-   * Unloads the model from memory.
-   */
-  public delete(): void {
-    this.nativeModule?.unload();
-  }
-
-  /**
-   * Runs the encoding part of the model on the provided waveform.
-   * Returns the encoded waveform as a Float32Array.
-   * @param waveform - The input audio waveform.
-   * @returns The encoded output.
-   */
-  public async encode(waveform: Float32Array): Promise<Float32Array> {
-    const buffer = await this.nativeModule.encode(waveform);
-    return new Float32Array(buffer);
-  }
-
-  /**
-   * Runs the decoder of the model.
-   * @param tokens - The input tokens.
-   * @param encoderOutput - The encoder output.
-   * @returns Decoded output.
-   */
-  public async decode(
-    tokens: Int32Array,
-    encoderOutput: Float32Array
-  ): Promise<Float32Array> {
-    const buffer = await this.nativeModule.decode(tokens, encoderOutput);
-    return new Float32Array(buffer);
-  }
-
-  /**
-   * Starts a transcription process for a given input array (16kHz waveform).
-   * For multilingual models, specify the language in `options`.
-   * Returns the transcription as a string. Passing `number[]` is deprecated.
-   * @param waveform - The Float32Array audio data.
-   * @param options - Decoding options including language.
-   * @returns The transcription string.
-   */
-  public async transcribe(
-    waveform: Float32Array,
-    options: DecodingOptions = {}
-  ): Promise<TranscriptionResult> {
-    this.validateOptions(options);
-    return await this.nativeModule.transcribe(
-      waveform,
-      options.language || '',
-      !!options.verbose
-    );
-  }
-
-  /**
-   * Starts a streaming transcription session.
-   * Yields objects with `committed` and `nonCommitted` transcriptions.
-   * Committed transcription contains the part of the transcription that is finalized and will not change.
-   * Useful for displaying stable results during streaming.
-   * Non-committed transcription contains the part of the transcription that is still being processed and may change.
-   * Useful for displaying live, partial results during streaming.
-   * Use with `streamInsert` and `streamStop` to control the stream.
-   * @param options - Decoding options including language.
-   * @yields An object containing `committed` and `nonCommitted` transcription results.
-   * @returns An async generator yielding transcription updates.
-   */
-  public async *stream(options: StreamingOptions = {}): AsyncGenerator<{
-    committed: TranscriptionResult;
-    nonCommitted: TranscriptionResult;
-  }> {
-    this.validateOptions(options);
-
-    const verbose = !!options.verbose;
-    const language = options.language || '';
-    const timeout = options.timeout || 100;
-    const useVAD = options.useVAD ?? false;
-    const vadDetectionMargin = options.vadDetectionMargin ?? 500;
-
-    const queue: {
-      committed: TranscriptionResult;
-      nonCommitted: TranscriptionResult;
-    }[] = [];
-
-    let waiter: (() => void) | null = null;
-    let finished = false;
-    let error: unknown;
-
-    const wake = () => {
-      waiter?.();
-      waiter = null;
-    };
-
-    (async () => {
-      try {
-        await this.nativeModule.stream(
-          (
-            committed: TranscriptionResult,
-            nonCommitted: TranscriptionResult,
-            isDone: boolean
-          ) => {
-            queue.push({
-              committed,
-              nonCommitted,
-            });
-
-            if (isDone) {
-              finished = true;
-            }
-            wake();
-          },
-          language,
-          verbose,
-          timeout,
-          useVAD,
-          vadDetectionMargin
-        );
-
-        finished = true;
-        wake();
-      } catch (e) {
-        error = e;
-        finished = true;
-        wake();
-      }
-    })();
-
-    while (true) {
-      if (queue.length > 0) {
-        yield queue.shift()!;
-        if (finished && queue.length === 0) {
-          return;
-        }
-        continue;
-      }
-      if (error) throw parseUnknownError(error);
-      if (finished) return;
-      await new Promise<void>((r) => (waiter = r));
-    }
-  }
-
-  /**
-   * Inserts a new audio chunk into the streaming transcription session.
-   * @param waveform - The audio chunk to insert.
-   */
-  public streamInsert(waveform: Float32Array): void {
-    this.nativeModule.streamInsert(waveform);
-  }
-
-  /**
-   * Stops the current streaming transcription session.
-   */
-  public streamStop(): void {
-    this.nativeModule.streamStop();
-  }
-
-  private validateOptions(options: DecodingOptions) {
-    if (!this.modelConfig.isMultilingual && options.language) {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.MultilingualConfiguration,
-        'Model is not multilingual, cannot set language'
-      );
-    }
-    if (this.modelConfig.isMultilingual && !options.language) {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.MultilingualConfiguration,
-        'Model is multilingual, provide a language'
-      );
-    }
-  }
-}
diff --git a/packages/react-native-executorch/src/modules/natural_language_processing/TextEmbeddingsModule.ts b/packages/react-native-executorch/src/modules/natural_language_processing/TextEmbeddingsModule.ts
deleted file mode 100644
index 27b0e59ceb..0000000000
--- a/packages/react-native-executorch/src/modules/natural_language_processing/TextEmbeddingsModule.ts
+++ /dev/null
@@ -1,87 +0,0 @@
-import { ResourceSource } from '../../types/common';
-import { TextEmbeddingsModelName } from '../../types/textEmbeddings';
-import { ResourceFetcher } from '../../utils/ResourceFetcher';
-import { BaseModule } from '../BaseModule';
-import { RnExecutorchErrorCode } from '../../errors/ErrorCodes';
-import { parseUnknownError, RnExecutorchError } from '../../errors/errorUtils';
-import { Logger } from '../../common/Logger';
-
-/**
- * Module for generating text embeddings from input text.
- * @category Typescript API
- */
-export class TextEmbeddingsModule extends BaseModule {
-  private constructor(nativeModule: unknown) {
-    super();
-    this.nativeModule = nativeModule;
-  }
-
-  /**
-   * Creates a text embeddings instance for a built-in model.
-   * @param namedSources - An object specifying which built-in model to load and where to fetch it from.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @returns A Promise resolving to a `TextEmbeddingsModule` instance.
-   */
-  static async fromModelName(
-    namedSources: {
-      modelName: TextEmbeddingsModelName;
-      modelSource: ResourceSource;
-      tokenizerSource: ResourceSource;
-    },
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<TextEmbeddingsModule> {
-    try {
-      const [modelResult, tokenizerResult] = await Promise.all([
-        ResourceFetcher.fetch(onDownloadProgress, namedSources.modelSource),
-        ResourceFetcher.fetch(undefined, namedSources.tokenizerSource),
-      ]);
-      const modelPath = modelResult?.[0];
-      const tokenizerPath = tokenizerResult?.[0];
-      if (!modelPath || !tokenizerPath) {
-        throw new RnExecutorchError(RnExecutorchErrorCode.DownloadInterrupted);
-      }
-      return new TextEmbeddingsModule(
-        await global.loadTextEmbeddings(modelPath, tokenizerPath)
-      );
-    } catch (error) {
-      Logger.error('Load failed:', error);
-      throw parseUnknownError(error);
-    }
-  }
-
-  /**
-   * Creates a text embeddings instance with a user-provided model binary and tokenizer.
-   * Use this when working with a custom-exported model that is not one of the built-in presets.
-   * @remarks The native model contract for this method is not formally defined and may change
-   * between releases. Refer to the native source code for the current expected tensor interface.
-   * @param modelSource - A fetchable resource pointing to the model binary.
-   * @param tokenizerSource - A fetchable resource pointing to the tokenizer file.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @returns A Promise resolving to a `TextEmbeddingsModule` instance.
-   */
-  static fromCustomModel(
-    modelSource: ResourceSource,
-    tokenizerSource: ResourceSource,
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<TextEmbeddingsModule> {
-    return TextEmbeddingsModule.fromModelName(
-      {
-        modelName: 'custom' as TextEmbeddingsModelName,
-        modelSource,
-        tokenizerSource,
-      },
-      onDownloadProgress
-    );
-  }
-
-  /**
-   * Executes the model's forward pass to generate an embedding for the provided text.
-   * @param input - The text string to embed.
-   * @returns A Promise resolving to a `Float32Array` containing the embedding vector.
-   */
-  async forward(input: string): Promise<Float32Array> {
-    if (this.nativeModule == null)
-      throw new RnExecutorchError(RnExecutorchErrorCode.ModuleNotLoaded);
-    return new Float32Array(await this.nativeModule.generate(input));
-  }
-}
diff --git a/packages/react-native-executorch/src/modules/natural_language_processing/TextToSpeechModule.ts b/packages/react-native-executorch/src/modules/natural_language_processing/TextToSpeechModule.ts
deleted file mode 100644
index df1aaa01c8..0000000000
--- a/packages/react-native-executorch/src/modules/natural_language_processing/TextToSpeechModule.ts
+++ /dev/null
@@ -1,228 +0,0 @@
-import { RnExecutorchErrorCode } from '../../errors/ErrorCodes';
-import { parseUnknownError, RnExecutorchError } from '../../errors/errorUtils';
-import { ResourceFetcher } from '../../utils/ResourceFetcher';
-import { ResourceSource } from '../../types/common';
-import {
-  TextToSpeechModelConfig,
-  TextToSpeechModelSources,
-  TextToSpeechStreamingInput,
-} from '../../types/tts';
-import { Logger } from '../../common/Logger';
-
-/**
- * Module for Text to Speech (TTS) functionalities.
- * @category Typescript API
- */
-export class TextToSpeechModule {
-  private nativeModule: any;
-  private isStreaming: boolean = false;
-
-  private constructor(nativeModule: unknown) {
-    this.nativeModule = nativeModule;
-  }
-
-  /**
-   * Creates a Text to Speech instance.
-   * @param config - Configuration object containing model and voice sources.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @returns A Promise resolving to a `TextToSpeechModule` instance.
-   */
-  static async fromModelName(
-    config: TextToSpeechModelConfig,
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<TextToSpeechModule> {
-    try {
-      const nativeModule = await TextToSpeechModule.loadKokoro(
-        config,
-        onDownloadProgress
-      );
-      return new TextToSpeechModule(nativeModule);
-    } catch (error) {
-      Logger.error('Load failed:', error);
-      throw parseUnknownError(error);
-    }
-  }
-
-  private static async loadKokoro(
-    config: TextToSpeechModelConfig,
-    onDownloadProgressCallback: (progress: number) => void
-  ): Promise<unknown> {
-    const { model, voiceSource, phonemizerConfig } = config;
-    const kokoroModel = model as Extract<
-      TextToSpeechModelSources,
-      { modelName: 'kokoro' }
-    >;
-
-    const sources: ResourceSource[] = [
-      kokoroModel.durationPredictorSource,
-      kokoroModel.synthesizerSource,
-      voiceSource,
-    ];
-
-    // Since each of these args is optional, we need to handle the sources array in a dynamic way.
-    const taggerIdx = phonemizerConfig.taggerSource
-      ? sources.push(phonemizerConfig.taggerSource) - 1
-      : -1;
-    const lexiconIdx = phonemizerConfig.lexiconSource
-      ? sources.push(phonemizerConfig.lexiconSource) - 1
-      : -1;
-    const neuralModelIdx = phonemizerConfig.neuralModelSource
-      ? sources.push(phonemizerConfig.neuralModelSource) - 1
-      : -1;
-
-    const paths = await ResourceFetcher.fetch(
-      onDownloadProgressCallback,
-      ...sources
-    );
-
-    // Required fields
-    const [duration, synth, voice] = paths;
-    if (!duration || !synth || !voice) {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.DownloadInterrupted,
-        'Kokoro: missing required model paths.'
-      );
-    }
-
-    // Optional fields
-    const tagger = paths[taggerIdx] ?? '';
-    const lexicon = paths[lexiconIdx] ?? '';
-    const neural = paths[neuralModelIdx] ?? '';
-
-    return await global.loadTextToSpeechKokoro(
-      phonemizerConfig.lang,
-      tagger,
-      lexicon,
-      neural,
-      duration,
-      synth,
-      voice
-    );
-  }
-
-  private ensureLoaded(methodName: string): void {
-    if (this.nativeModule == null)
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.ModuleNotLoaded,
-        `The model is currently not loaded. Please load the model before calling ${methodName}().`
-      );
-  }
-
-  /**
-   * Synthesizes the provided input (text or IPA phonemes) into speech.
-   * @param input - The input text or phonemes to be synthesized.
-   * @param speed - Playback speed multiplier (default: 1.0).
-   * @param phonemize - If true (default), treats input as text and converts it to phonemes.
-   *                    If false, input is treated as phonemes.
-   * @returns A promise resolving to the full audio waveform as a `Float32Array`.
-   */
-  public async forward(
-    input: string,
-    speed: number = 1.0,
-    phonemize: boolean = true
-  ): Promise<Float32Array> {
-    this.ensureLoaded('forward');
-    return await this.nativeModule.generate(input, speed, phonemize);
-  }
-
-  /**
-   * Starts a streaming synthesis session. Yields audio chunks as they are generated.
-   * @param input - Input object containing optional speed, phonemize flag and stopAutomatically flag.
-   * @yields An audio chunk generated during synthesis.
-   * @returns An async generator yielding Float32Array audio chunks.
-   */
-  public async *stream({
-    speed = 1.0,
-    phonemize = true,
-    stopAutomatically = true,
-  }: TextToSpeechStreamingInput): AsyncGenerator<Float32Array> {
-    const queue: Float32Array[] = [];
-
-    let waiter: (() => void) | null = null;
-    let error: RnExecutorchError | undefined;
-    let nativeStreamFinished = false;
-
-    this.isStreaming = true;
-
-    const wake = () => {
-      waiter?.();
-      waiter = null;
-    };
-
-    (async () => {
-      try {
-        await this.nativeModule.stream(
-          (audio: number[]) => {
-            queue.push(new Float32Array(audio));
-            wake();
-          },
-          speed,
-          phonemize,
-          stopAutomatically
-        );
-        nativeStreamFinished = true;
-        wake();
-      } catch (e) {
-        error = parseUnknownError(e);
-        nativeStreamFinished = true;
-        wake();
-      }
-    })();
-
-    while (this.isStreaming) {
-      if (queue.length > 0) {
-        yield queue.shift()!;
-        if (nativeStreamFinished && queue.length === 0) {
-          return;
-        }
-        continue;
-      }
-      if (error) throw error;
-      if (nativeStreamFinished && queue.length === 0) return;
-      await new Promise<void>((r) => (waiter = r));
-    }
-  }
-
-  /**
-   * Inserts new content (text or IPA phonemes) into the buffer to be processed
-   * in streaming mode. Trailing un-terminated content sits in the buffer
-   * until {@link TextToSpeechModule.streamFlush} or `streamStop(false)`
-   * releases it.
-   * @param input - The text or phoneme fragment to append to the streaming buffer.
-   */
-  public streamInsert(input: string): void {
-    this.nativeModule.streamInsert(input);
-  }
-
-  /**
-   * Force-partitions whatever is currently buffered, even without an
-   * end-of-sentence character. Call after the final `streamInsert` of an
-   * utterance to play out the trailing tail without ending the stream.
-   */
-  public streamFlush(): void {
-    this.nativeModule.streamFlush();
-  }
-
-  /**
-   * Stops the streaming process if there is any ongoing.
-   * @param instant - If true, stops the streaming as soon as possible. Otherwise
-   *                  drains the current buffer (force-flushing any trailing
-   *                  un-terminated content) before stopping.
-   */
-  public streamStop(instant: boolean = true): void {
-    this.nativeModule.streamStop(instant);
-
-    if (instant) {
-      this.isStreaming = false;
-    }
-  }
-
-  /**
-   * Unloads the model from memory.
-   */
-  delete() {
-    if (this.nativeModule !== null) {
-      this.nativeModule.unload();
-    }
-  }
-}
diff --git a/packages/react-native-executorch/src/modules/natural_language_processing/TokenizerModule.ts b/packages/react-native-executorch/src/modules/natural_language_processing/TokenizerModule.ts
deleted file mode 100644
index aec377b91e..0000000000
--- a/packages/react-native-executorch/src/modules/natural_language_processing/TokenizerModule.ts
+++ /dev/null
@@ -1,93 +0,0 @@
-import { ResourceSource } from '../../types/common';
-import { ResourceFetcher } from '../../utils/ResourceFetcher';
-import { parseUnknownError, RnExecutorchError } from '../../errors/errorUtils';
-import { RnExecutorchErrorCode } from '../../errors/ErrorCodes';
-import { Logger } from '../../common/Logger';
-
-/**
- * Module for Tokenizer functionalities.
- * @category Typescript API
- */
-export class TokenizerModule {
-  /**
-   * Native module instance
-   */
-  nativeModule: any;
-
-  /**
-   * Loads the tokenizer from the specified source.
-   * `tokenizerSource` is a string that points to the location of the tokenizer JSON file.
-   * @param tokenizer - Object containing `tokenizerSource`.
-   * @param onDownloadProgressCallback - Optional callback to monitor download progress.
-   */
-  async load(
-    tokenizer: { tokenizerSource: ResourceSource },
-    onDownloadProgressCallback: (progress: number) => void = () => {}
-  ): Promise<void> {
-    try {
-      const paths = await ResourceFetcher.fetch(
-        onDownloadProgressCallback,
-        tokenizer.tokenizerSource
-      );
-      const path = paths?.[0];
-      if (!path) {
-        throw new RnExecutorchError(RnExecutorchErrorCode.DownloadInterrupted);
-      }
-      this.nativeModule = await global.loadTokenizerModule(path);
-    } catch (error) {
-      Logger.error('Load failed:', error);
-      throw parseUnknownError(error);
-    }
-  }
-
-  /**
-   * Converts a string into an array of token IDs.
-   * @param input - The input string to be tokenized.
-   * @returns An array of token IDs.
-   */
-  async encode(input: string): Promise<number[]> {
-    return await this.nativeModule.encode(input);
-  }
-
-  /**
-   * Converts an array of token IDs into a string.
-   * @param tokens - Array of token IDs to be decoded.
-   * @param skipSpecialTokens - Whether to skip special tokens during decoding (default: true).
-   * @returns The decoded string.
-   */
-  async decode(
-    tokens: number[],
-    skipSpecialTokens: boolean = true
-  ): Promise<string> {
-    if (tokens.length === 0) {
-      return '';
-    }
-    return await this.nativeModule.decode(tokens, skipSpecialTokens);
-  }
-
-  /**
-   * Returns the size of the tokenizer's vocabulary.
-   * @returns The vocabulary size.
-   */
-  async getVocabSize(): Promise<number> {
-    return await this.nativeModule.getVocabSize();
-  }
-
-  /**
-   * Returns the token associated to the ID.
-   * @param tokenId - ID of the token.
-   * @returns The token string associated to ID.
-   */
-  async idToToken(tokenId: number): Promise<string> {
-    return this.nativeModule.idToToken(tokenId);
-  }
-
-  /**
-   * Returns the ID associated to the token.
-   * @param token - The token string.
-   * @returns The ID associated to the token.
-   */
-  async tokenToId(token: string): Promise<number> {
-    return await this.nativeModule.tokenToId(token);
-  }
-}
diff --git a/packages/react-native-executorch/src/modules/natural_language_processing/VADModule.ts b/packages/react-native-executorch/src/modules/natural_language_processing/VADModule.ts
deleted file mode 100644
index eb74a582c0..0000000000
--- a/packages/react-native-executorch/src/modules/natural_language_processing/VADModule.ts
+++ /dev/null
@@ -1,156 +0,0 @@
-import { ResourceFetcher } from '../../utils/ResourceFetcher';
-import { ResourceSource } from '../../types/common';
-import { Segment, VADModelName, VADStreamingInput } from '../../types/vad';
-import { BaseModule } from '../BaseModule';
-import { RnExecutorchErrorCode } from '../../errors/ErrorCodes';
-import { parseUnknownError, RnExecutorchError } from '../../errors/errorUtils';
-import { Logger } from '../../common/Logger';
-
-/**
- * Module for Voice Activity Detection (VAD) functionalities.
- * @category Typescript API
- */
-export class VADModule extends BaseModule {
-  private isStreaming: boolean = false;
-
-  private constructor(nativeModule: unknown) {
-    super();
-    this.nativeModule = nativeModule;
-  }
-
-  /**
-   * Creates a VAD instance for a built-in model.
-   * @param namedSources - An object specifying which built-in model to load and where to fetch it from.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @returns A Promise resolving to a `VADModule` instance.
-   */
-  static async fromModelName(
-    namedSources: { modelName: VADModelName; modelSource: ResourceSource },
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<VADModule> {
-    try {
-      const paths = await ResourceFetcher.fetch(
-        onDownloadProgress,
-        namedSources.modelSource
-      );
-      if (!paths?.[0]) {
-        throw new RnExecutorchError(RnExecutorchErrorCode.DownloadInterrupted);
-      }
-      return new VADModule(await global.loadVAD(paths[0]));
-    } catch (error) {
-      Logger.error('Load failed:', error);
-      throw parseUnknownError(error);
-    }
-  }
-
-  /**
-   * Creates a VAD instance with a user-provided model binary.
-   * Use this when working with a custom-exported model that is not one of the built-in presets.
-   * @remarks The native model contract for this method is not formally defined and may change
-   * between releases. Refer to the native source code for the current expected tensor interface.
-   * @param modelSource - A fetchable resource pointing to the model binary.
-   * @param onDownloadProgress - Optional callback to monitor download progress, receiving a value between 0 and 1.
-   * @returns A Promise resolving to a `VADModule` instance.
-   */
-  static fromCustomModel(
-    modelSource: ResourceSource,
-    onDownloadProgress: (progress: number) => void = () => {}
-  ): Promise<VADModule> {
-    return VADModule.fromModelName(
-      { modelName: 'custom' as VADModelName, modelSource },
-      onDownloadProgress
-    );
-  }
-
-  /**
-   * Executes the model's forward pass to detect speech segments within the provided audio.
-   * @param waveform - A `Float32Array` representing a mono audio signal sampled at 16kHz.
-   * @returns A Promise resolving to an array of {@link Segment} objects.
-   */
-  async forward(waveform: Float32Array): Promise<Segment[]> {
-    if (this.nativeModule == null)
-      throw new RnExecutorchError(RnExecutorchErrorCode.ModuleNotLoaded);
-    return await this.nativeModule.generate(waveform);
-  }
-
-  /**
-   * Starts a streaming VAD session.
-   * @param input - Configuration for streaming, including callbacks for speech begin/end and optional parameters.
-   * @returns A promise that resolves when the streaming session stops.
-   */
-  public async stream({
-    onSpeechBegin,
-    onSpeechEnd,
-    options,
-  }: VADStreamingInput): Promise<void> {
-    if (this.nativeModule == null)
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.ModuleNotLoaded,
-        'The model is currently not loaded. Please load the model before calling stream().'
-      );
-
-    const timeout = options?.timeout ?? 100;
-    const detectionMargin = options?.detectionMargin ?? 100;
-
-    let isSpeaking = false;
-    let error: unknown;
-    let finished = false;
-
-    let waiter: (() => void) | null = null;
-    const wake = () => {
-      waiter?.();
-      waiter = null;
-    };
-
-    this.isStreaming = true;
-
-    (async () => {
-      try {
-        await this.nativeModule.stream(
-          async (speaking: boolean) => {
-            if (speaking && !isSpeaking) {
-              isSpeaking = true;
-              await onSpeechBegin?.();
-            } else if (!speaking && isSpeaking) {
-              isSpeaking = false;
-              await onSpeechEnd?.();
-            }
-          },
-          timeout,
-          detectionMargin
-        );
-      } catch (e) {
-        error = e;
-      } finally {
-        this.isStreaming = false;
-        finished = true;
-        wake();
-      }
-    })();
-
-    while (this.isStreaming && !finished) {
-      if (error) throw parseUnknownError(error);
-      await new Promise<void>((r) => (waiter = r));
-    }
-  }
-
-  /**
-   * Inserts a new audio chunk into the streaming VAD session.
-   * @param waveform - The audio chunk to insert.
-   */
-  public streamInsert(waveform: Float32Array): void {
-    if (this.nativeModule == null)
-      throw new RnExecutorchError(RnExecutorchErrorCode.ModuleNotLoaded);
-    this.nativeModule.streamInsert(waveform);
-  }
-
-  /**
-   * Stops the current streaming VAD session.
-   */
-  public streamStop(): void {
-    if (this.nativeModule == null)
-      throw new RnExecutorchError(RnExecutorchErrorCode.ModuleNotLoaded);
-    this.nativeModule.streamStop();
-    this.isStreaming = false;
-  }
-}
diff --git a/packages/react-native-executorch/src/native/NativeETInstaller.ts b/packages/react-native-executorch/src/native/NativeETInstaller.ts
deleted file mode 100644
index a163524d78..0000000000
--- a/packages/react-native-executorch/src/native/NativeETInstaller.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-import type { TurboModule } from 'react-native';
-import { TurboModuleRegistry } from 'react-native';
-
-export interface Spec extends TurboModule {
-  install(): boolean;
-}
-
-export default TurboModuleRegistry.get<Spec>('ETInstaller');
diff --git a/packages/react-native-executorch/src/native/NativeRnExecutorch.ts b/packages/react-native-executorch/src/native/NativeRnExecutorch.ts
new file mode 100644
index 0000000000..85c98f24c6
--- /dev/null
+++ b/packages/react-native-executorch/src/native/NativeRnExecutorch.ts
@@ -0,0 +1,7 @@
+import { TurboModuleRegistry, type TurboModule } from 'react-native';
+
+export interface Spec extends TurboModule {
+  install(): boolean;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('RnExecutorch');
diff --git a/packages/react-native-executorch/src/native/RnExecutorchModules.ts b/packages/react-native-executorch/src/native/RnExecutorchModules.ts
deleted file mode 100644
index 3cf4a10bbb..0000000000
--- a/packages/react-native-executorch/src/native/RnExecutorchModules.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { Platform } from 'react-native';
-import { Spec as ETInstallerInterface } from './NativeETInstaller';
-
-const LINKING_ERROR =
-  `The package 'react-native-executorch' doesn't seem to be linked. Make sure: \n\n` +
-  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
-  '- You rebuilt the app after installing the package\n' +
-  '- You are not using Expo Go\n';
-
-function returnSpecOrThrowLinkingError(spec: any) {
-  return spec
-    ? spec
-    : new Proxy(
-        {},
-        {
-          get() {
-            throw new Error(LINKING_ERROR);
-          },
-        }
-      );
-}
-
-const ETInstallerNativeModule: ETInstallerInterface =
-  returnSpecOrThrowLinkingError(require('./NativeETInstaller').default);
-
-export { ETInstallerNativeModule };
diff --git a/packages/react-native-executorch/src/native/bridge.ts b/packages/react-native-executorch/src/native/bridge.ts
new file mode 100644
index 0000000000..cd3cc54816
--- /dev/null
+++ b/packages/react-native-executorch/src/native/bridge.ts
@@ -0,0 +1,14 @@
+const globalObj = globalThis as any;
+
+if (!globalObj.__rnexecutorch_jsi__) {
+  const NativeRnExecutorch = require('./NativeRnExecutorch').default;
+  if (NativeRnExecutorch) NativeRnExecutorch.install();
+}
+
+export const rnexecutorchJsi = globalObj.__rnexecutorch_jsi__;
+
+if (!rnexecutorchJsi) {
+  throw new Error(
+    "JSI global object '__rnexecutorch_jsi__' is not registered."
+  );
+}
diff --git a/packages/react-native-executorch/src/types/classification.ts b/packages/react-native-executorch/src/types/classification.ts
deleted file mode 100644
index f4eba97ad8..0000000000
--- a/packages/react-native-executorch/src/types/classification.ts
+++ /dev/null
@@ -1,100 +0,0 @@
-import { RnExecutorchError } from '../errors/errorUtils';
-import { LabelEnum, Triple, ResourceSource, PixelData, Frame } from './common';
-import { Imagenet1kLabel } from '../constants/classification';
-export { Imagenet1kLabel };
-
-/**
- * Configuration for a custom classification model.
- * @typeParam T - The {@link LabelEnum} type for the model.
- * @property labelMap - The enum-like object mapping class names to indices.
- * @property preprocessorConfig - Optional preprocessing parameters.
- * @property preprocessorConfig.normMean - Per-channel mean values for input normalization.
- * @property preprocessorConfig.normStd - Per-channel standard deviation values for input normalization.
- * @category Types
- */
-export type ClassificationConfig<T extends LabelEnum> = {
-  labelMap: T;
-  preprocessorConfig?: { normMean?: Triple<number>; normStd?: Triple<number> };
-};
-
-/**
- * Per-model config for {@link ClassificationModule.fromModelName}.
- * Each model name maps to its required fields.
- * @category Types
- */
-export type ClassificationModelSources =
-  | { modelName: 'efficientnet-v2-s'; modelSource: ResourceSource }
-  | { modelName: 'efficientnet-v2-s-quantized'; modelSource: ResourceSource };
-
-/**
- * Union of all built-in classification model names.
- * @category Types
- */
-export type ClassificationModelName = ClassificationModelSources['modelName'];
-
-/**
- * Props for the `useClassification` hook.
- * @typeParam C - A {@link ClassificationModelSources} config specifying which built-in model to load.
- * @property model - The model config containing `modelName` and `modelSource`.
- * @property {boolean} [preventLoad] - Boolean that can prevent automatic model loading (and downloading the data if you load it for the first time) after running the hook.
- * @category Types
- */
-export interface ClassificationProps<C extends ClassificationModelSources> {
-  model: C;
-  preventLoad?: boolean;
-}
-
-/**
- * Return type for the `useClassification` hook.
- * Manages the state and operations for Computer Vision image classification.
- * @typeParam L - The {@link LabelEnum} representing the model's class labels.
- * @category Types
- */
-export interface ClassificationType<L extends LabelEnum> {
-  /**
-   * Contains the error object if the model failed to load, download, or encountered a runtime error during classification.
-   */
-  error: RnExecutorchError | null;
-
-  /**
-   * Indicates whether the classification model is loaded and ready to process images.
-   */
-  isReady: boolean;
-
-  /**
-   * Indicates whether the model is currently processing an image.
-   */
-  isGenerating: boolean;
-
-  /**
-   * Represents the download progress of the model binary as a value between 0 and 1.
-   */
-  downloadProgress: number;
-
-  /**
-   * Executes the model's forward pass to classify the provided image.
-   *
-   * Supports two input types:
-   * 1. **String path/URI**: File path, URL, or Base64-encoded string
-   * 2. **PixelData**: Raw pixel data from image libraries (e.g., NitroImage)
-   *
-   * **Note**: For VisionCamera frame processing, use `runOnFrame` instead.
-   * @param input - Image source (string or PixelData object)
-   * @returns A Promise that resolves to the classification result mapping label keys to confidence scores.
-   * @throws {RnExecutorchError} If the model is not loaded or is currently processing another image.
-   */
-  forward: (input: string | PixelData) => Promise<Record<keyof L, number>>;
-
-  /**
-   * Synchronous worklet function for real-time VisionCamera frame processing.
-   * Automatically handles native buffer extraction and cleanup.
-   *
-   * **Use this for VisionCamera frame processing in worklets.**
-   * For async processing, use `forward()` instead.
-   *
-   * Available after model is loaded (`isReady: true`).
-   * @param frame - VisionCamera Frame object
-   * @returns Object mapping class labels to confidence scores.
-   */
-  runOnFrame: ((frame: Frame) => Record<keyof L, number>) | null;
-}
diff --git a/packages/react-native-executorch/src/types/common.ts b/packages/react-native-executorch/src/types/common.ts
deleted file mode 100644
index e8afa8ff4d..0000000000
--- a/packages/react-native-executorch/src/types/common.ts
+++ /dev/null
@@ -1,201 +0,0 @@
-/**
- * Common types used across the React Native Executorch package.
- */
-
-/**
- * Represents a source of a resource, which can be a string (e.g., URL or file path), a number (e.g., resource ID), or an object (e.g., binary data).
- * @category Types
- */
-export type ResourceSource = string | number | object;
-
-/**
- * Enum representing the scalar types of tensors.
- * @category Types
- */
-export enum ScalarType {
-  /**
-   * Byte type (8-bit unsigned integer).
-   */
-  BYTE = 0,
-  /**
-   * Character type (8-bit signed integer).
-   */
-  CHAR = 1,
-  /**
-   * Short integer type (16-bit signed integer).
-   */
-  SHORT = 2,
-  /**
-   * Integer type (32-bit signed integer).
-   */
-  INT = 3,
-  /**
-   * Long integer type (64-bit signed integer).
-   */
-  LONG = 4,
-  /**
-   * Half-precision floating point type (16-bit).
-   */
-  HALF = 5,
-  /**
-   * Single-precision floating point type (32-bit).
-   */
-  FLOAT = 6,
-  /**
-   * Double-precision floating point type (64-bit).
-   */
-  DOUBLE = 7,
-  /**
-   * Boolean type.
-   */
-  BOOL = 11,
-  /**
-   * Quantized 8-bit signed integer type.
-   */
-  QINT8 = 12,
-  /**
-   * Quantized 8-bit unsigned integer type.
-   */
-  QUINT8 = 13,
-  /**
-   * Quantized 32-bit signed integer type.
-   */
-  QINT32 = 14,
-  /**
-   * Packed Quantized Unsigned 4-bit Integers type (2 number in 1 byte).
-   */
-  QUINT4X2 = 16,
-  /**
-   * Packed Quantized Unsigned 2-bit Integer type (4 numbers in 1 byte).
-   */
-  QUINT2X4 = 17,
-  /**
-   * Raw Bits type.
-   */
-  BITS16 = 22,
-  /**
-   * Quantized 8-bit floating point type: Sign bit, 5 Exponent bits, 2 Mantissa bits.
-   */
-  FLOAT8E5M2 = 23,
-  /**
-   * Quantized 8-bit floating point type: Sign bit, 4 Exponent bits, 3 Mantissa bits.
-   */
-  FLOAT8E4M3FN = 24,
-  /**
-   * Quantized 8-bit floating point type with No Unsigned Zero (NUZ): Sign bit, 5 Exponent bits, 2 Mantissa bits.
-   */
-  FLOAT8E5M2FNUZ = 25,
-  /**
-   * Quantized 8-bit floating point type with No Unsigned Zero (NUZ): Sign bit, 4 Exponent bits, 3 Mantissa bits.
-   */
-  FLOAT8E4M3FNUZ = 26,
-  /**
-   * Unsigned 16-bit integer type.
-   */
-  UINT16 = 27,
-  /**
-   * Unsigned 32-bit integer type.
-   */
-  UINT32 = 28,
-  /**
-   * Unsigned 64-bit integer type.
-   */
-  UINT64 = 29,
-}
-
-/**
- * Represents the data buffer of a tensor, which can be one of several typed array formats.
- * @category Types
- */
-export type TensorBuffer =
-  | ArrayBuffer
-  | Float32Array
-  | Float64Array
-  | Int8Array
-  | Int16Array
-  | Int32Array
-  | Uint8Array
-  | Uint16Array
-  | Uint32Array
-  | BigInt64Array
-  | BigUint64Array;
-
-/**
- * Represents a pointer to a tensor, including its data buffer, size dimensions, and scalar type.
- * @category Types
- * @property {TensorBuffer} dataPtr - The data buffer of the tensor.
- * @property {number[]} sizes - An array representing the size of each dimension of the tensor.
- * @property {ScalarType} scalarType - The scalar type of the tensor, as defined in the `ScalarType` enum.
- */
-export interface TensorPtr {
-  dataPtr: TensorBuffer;
-  sizes: number[];
-  scalarType: ScalarType;
-}
-
-/**
- * A readonly record mapping string keys to numeric or string values.
- * Used to represent enum-like label maps for models.
- * @category Types
- */
-export type LabelEnum = Readonly<Record<string, number | string>>;
-
-/**
- * A readonly triple of values, typically used for per-channel normalization parameters.
- * @category Types
- */
-export type Triple<T> = readonly [T, T, T];
-/**
- * Represents raw pixel data in RGB format for vision models.
- *
- * This type extends TensorPtr with constraints specific to image data:
- * - dataPtr must be Uint8Array (8-bit unsigned integers)
- * - scalarType is always BYTE (ScalarType.BYTE)
- * - sizes represents [height, width, channels] where channels must be 3 (RGB)
- * @category Types
- * @example
- * ```typescript
- * const pixelData: PixelData = {
- *   dataPtr: new Uint8Array(width * height * 3), // RGB pixel data
- *   sizes: [height, width, 3], // [height, width, channels]
- *   scalarType: ScalarType.BYTE
- * };
- * ```
- */
-export interface PixelData extends Pick<TensorPtr, 'sizes'> {
-  /**
-   * RGB pixel data as Uint8Array.
-   * Expected format: RGB (3 channels), not RGBA or BGRA.
-   * Size must equal: width * height * 3
-   */
-  dataPtr: Uint8Array;
-
-  /**
-   * Dimensions of the pixel data: [height, width, channels].
-   * - sizes[0]: height (number of rows)
-   * - sizes[1]: width (number of columns)
-   * - sizes[2]: channels (must be 3 for RGB)
-   */
-  sizes: [number, number, 3];
-
-  /**
-   * Scalar type is always BYTE for pixel data.
-   */
-  scalarType: ScalarType.BYTE;
-}
-
-/**
- * Frame data for vision model processing.
- */
-export interface Frame {
-  /**
-   * Pointer to native platform buffer (zero-copy, best performance).
-   * - On iOS: CVPixelBufferRef pointer
-   * - On Android: AHardwareBuffer* pointer
-   *
-   * Obtain from Vision Camera v5: `frame.getNativeBuffer().pointer`
-   */
-  getNativeBuffer(): { pointer: bigint; release(): void };
-  orientation: string;
-  isMirrored: boolean;
-}
diff --git a/packages/react-native-executorch/src/types/computerVision.ts b/packages/react-native-executorch/src/types/computerVision.ts
deleted file mode 100644
index da15999100..0000000000
--- a/packages/react-native-executorch/src/types/computerVision.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import { LabelEnum } from './common';
-
-/*
- * Automatically resolves the type to either Configs[NameOrType][OutputKey], if the NameOrType
- * is a key of Configs. Otherwise, returns NameOrType.
- * @internal
- */
-export type ResolveConfigOrType<
-  NameOrType,
-  Configs extends Record<string, Record<OutputKey, unknown>>,
-  OutputKey extends string = 'output',
-> = NameOrType extends keyof Configs
-  ? Configs[NameOrType][OutputKey]
-  : NameOrType;
-
-/**
- * Given a model configs record (mapping model names to `{ labelMap }`) and a
- * type `T` (either a model name key or a raw {@link LabelEnum}), resolves to
- * the label map for that model or `T` itself.
- * @internal
- */
-export type ResolveLabels<
-  NameOrLabels,
-  Configs extends Record<string, { labelMap: LabelEnum }>,
-> = ResolveConfigOrType<NameOrLabels, Configs, 'labelMap'>;
diff --git a/packages/react-native-executorch/src/types/executorchModule.ts b/packages/react-native-executorch/src/types/executorchModule.ts
deleted file mode 100644
index e058d13eb7..0000000000
--- a/packages/react-native-executorch/src/types/executorchModule.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import { ResourceSource, TensorPtr } from '../types/common';
-import { RnExecutorchError } from '../errors/errorUtils';
-
-/**
- * Props for the `useExecutorchModule` hook.
- * @category Types
- * @property {ResourceSource} modelSource - The source of the ExecuTorch model binary.
- * @property {boolean} [preventLoad] - Boolean that can prevent automatic model loading (and downloading the data if you load it for the first time) after running the hook.
- */
-export interface ExecutorchModuleProps {
-  modelSource: ResourceSource;
-  preventLoad?: boolean;
-}
-
-/**
- * Return type for the `useExecutorchModule` hook.
- * Manages the state and core execution methods for a general ExecuTorch model.
- * @category Types
- */
-export interface ExecutorchModuleType {
-  /**
-   * Contains the error object if the model failed to load, download, or encountered a runtime error.
-   */
-  error: RnExecutorchError | null;
-
-  /**
-   * Indicates whether the ExecuTorch model binary has successfully loaded into memory and is ready for inference.
-   */
-  isReady: boolean;
-
-  /**
-   * Indicates whether the model is currently processing a forward pass.
-   */
-  isGenerating: boolean;
-
-  /**
-   * Represents the download progress of the model binary as a value between 0 and 1.
-   */
-  downloadProgress: number;
-
-  /**
-   * Executes the model's forward pass with the provided input tensors.
-   * @param inputTensor - An array of `TensorPtr` objects representing the input tensors required by the model.
-   * @returns A Promise that resolves to an array of output `TensorPtr` objects resulting from the model's inference.
-   * @throws {RnExecutorchError} If the model is not loaded or is currently processing another request.
-   */
-  forward: (inputTensor: TensorPtr[]) => Promise<TensorPtr[]>;
-}
diff --git a/packages/react-native-executorch/src/types/genericImageSegmentation.ts b/packages/react-native-executorch/src/types/genericImageSegmentation.ts
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/packages/react-native-executorch/src/types/imageEmbeddings.ts b/packages/react-native-executorch/src/types/imageEmbeddings.ts
deleted file mode 100644
index 1ecea1ffd2..0000000000
--- a/packages/react-native-executorch/src/types/imageEmbeddings.ts
+++ /dev/null
@@ -1,77 +0,0 @@
-import { RnExecutorchError } from '../errors/errorUtils';
-import { ResourceSource, PixelData, Frame } from './common';
-
-/**
- * Union of all built-in image embeddings model names.
- * @category Types
- */
-export type ImageEmbeddingsModelName =
-  | 'clip-vit-base-patch32-image'
-  | 'clip-vit-base-patch32-image-quantized';
-
-/**
- * Props for the `useImageEmbeddings` hook.
- * @category Types
- * @property {object} model - An object containing the model configuration.
- * @property {ImageEmbeddingsModelName} model.modelName - Unique name identifying the model.
- * @property {ResourceSource} model.modelSource - The source of the image embeddings model binary.
- * @property {boolean} [preventLoad] - Boolean that can prevent automatic model loading (and downloading the data if you load it for the first time) after running the hook.
- */
-export interface ImageEmbeddingsProps {
-  model: { modelName: ImageEmbeddingsModelName; modelSource: ResourceSource };
-  preventLoad?: boolean;
-}
-
-/**
- * Return type for the `useImageEmbeddings` hook.
- * Manages the state and operations for generating image embeddings (feature vectors) used in Computer Vision tasks.
- * @category Types
- */
-export interface ImageEmbeddingsType {
-  /**
-   * Contains the error object if the model failed to load, download, or encountered a runtime error during embedding generation.
-   */
-  error: RnExecutorchError | null;
-
-  /**
-   * Indicates whether the image embeddings model is loaded and ready to process images.
-   */
-  isReady: boolean;
-
-  /**
-   * Indicates whether the model is currently generating embeddings for an image.
-   */
-  isGenerating: boolean;
-
-  /**
-   * Represents the download progress of the model binary as a value between 0 and 1.
-   */
-  downloadProgress: number;
-
-  /**
-   * Executes the model's forward pass to generate embeddings (a feature vector) for the provided image.
-   *
-   * Supports two input types:
-   * 1. **String path/URI**: File path, URL, or Base64-encoded string
-   * 2. **PixelData**: Raw pixel data from image libraries (e.g., NitroImage)
-   *
-   * **Note**: For VisionCamera frame processing, use `runOnFrame` instead.
-   * @param input - Image source (string or {@link PixelData} object)
-   * @returns A Promise that resolves to a `Float32Array` containing the generated embedding vector.
-   * @throws {RnExecutorchError} If the model is not loaded or is currently processing another image.
-   */
-  forward: (input: string | PixelData) => Promise<Float32Array>;
-
-  /**
-   * Synchronous worklet function for real-time VisionCamera frame processing.
-   * Automatically handles native buffer extraction and cleanup.
-   *
-   * **Use this for VisionCamera frame processing in worklets.**
-   * For async processing, use `forward()` instead.
-   *
-   * Available after model is loaded (`isReady: true`).
-   * @param frame - VisionCamera Frame object
-   * @returns Float32Array containing the embedding vector for the frame.
-   */
-  runOnFrame: ((frame: Frame) => Float32Array) | null;
-}
diff --git a/packages/react-native-executorch/src/types/instanceSegmentation.ts b/packages/react-native-executorch/src/types/instanceSegmentation.ts
deleted file mode 100644
index ff7f4ae314..0000000000
--- a/packages/react-native-executorch/src/types/instanceSegmentation.ts
+++ /dev/null
@@ -1,216 +0,0 @@
-import { RnExecutorchError } from '../errors/errorUtils';
-import { LabelEnum, ResourceSource, Triple, Frame, PixelData } from './common';
-import { Bbox } from './objectDetection';
-
-/**
- * Raw instance returned from the native C++ side, carrying a numeric
- * `classIndex` instead of a resolved label string.
- * @internal
- */
-export interface NativeSegmentedInstance {
-  bbox: Bbox;
-  mask: Uint8Array;
-  maskWidth: number;
-  maskHeight: number;
-  classIndex: number;
-  score: number;
-}
-
-/**
- * Represents a single detected instance in instance segmentation output.
- * @typeParam L - The label map type for the model, must conform to {@link LabelEnum}.
- * @category Types
- * @property {Bbox} bbox - The bounding box of the instance.
- * @property {Uint8Array} mask - Binary mask (0 or 1) representing the instance.
- * @property {number} maskWidth - Width of the mask array.
- * @property {number} maskHeight - Height of the mask array.
- * @property {keyof L} label - The class label of the instance.
- * @property {number} score - Confidence score [0, 1].
- */
-export interface SegmentedInstance<L extends LabelEnum> {
-  bbox: Bbox;
-  mask: Uint8Array;
-  maskWidth: number;
-  maskHeight: number;
-  label: keyof L;
-  score: number;
-}
-
-/**
- * Options for instance segmentation forward pass.
- * @typeParam L - The label map type for the model, must conform to {@link LabelEnum}.
- * @category Types
- */
-export interface InstanceSegmentationOptions<L extends LabelEnum> {
-  /**
-   * Minimum confidence threshold for including instances.
-   * Defaults to model's defaultConfidenceThreshold (typically 0.5).
-   */
-  confidenceThreshold?: number;
-  /**
-   * IoU threshold for non-maximum suppression.
-   * Defaults to model's defaultIouThreshold (typically 0.5).
-   */
-  iouThreshold?: number;
-  /**
-   * Maximum number of instances to return. Default: 100
-   */
-  maxInstances?: number;
-  /**
-   * Filter to include only specific classes.
-   */
-  classesOfInterest?: (keyof L)[];
-  /**
-   * Whether to return masks at original image resolution. Default: true
-   */
-  returnMaskAtOriginalResolution?: boolean;
-  /**
-   * Input size for the model (e.g., 384, 512, 640).
-   * Must be one of the model's availableInputSizes.
-   * Defaults to model's defaultInputSize.
-   */
-  inputSize?: number;
-}
-
-/**
- * Configuration for an instance segmentation model.
- * @typeParam T - The label map type for the model, must conform to {@link LabelEnum}.
- * @category Types
- * @remarks
- * The `availableInputSizes` and `defaultInputSize` fields are mutually inclusive:
- * - **Either both must be provided** (for models with multiple input sizes), or
- * - **Both must be omitted** (for models with a single input size).
- *
- * This discriminated union ensures type safety and prevents partial configuration.
- */
-export type InstanceSegmentationConfig<T extends LabelEnum> = {
-  labelMap: T;
-  preprocessorConfig?: {
-    normMean?: Triple<number>;
-    normStd?: Triple<number>;
-  };
-  postprocessorConfig?: { applyNMS?: boolean };
-  defaultConfidenceThreshold?: number;
-  defaultIouThreshold?: number;
-} & (
-  | {
-      availableInputSizes: readonly number[];
-      defaultInputSize: number;
-    }
-  | {
-      availableInputSizes?: undefined;
-      defaultInputSize?: undefined;
-    }
-);
-
-/**
- * Per-model config for {@link InstanceSegmentationModule.fromModelName}.
- * Each model name maps to its required fields.
- * @category Types
- */
-export type InstanceSegmentationModelSources =
-  | { modelName: 'yolo26n-seg'; modelSource: ResourceSource }
-  | { modelName: 'yolo26s-seg'; modelSource: ResourceSource }
-  | { modelName: 'yolo26m-seg'; modelSource: ResourceSource }
-  | { modelName: 'yolo26l-seg'; modelSource: ResourceSource }
-  | { modelName: 'yolo26x-seg'; modelSource: ResourceSource }
-  | { modelName: 'rfdetr-nano-seg'; modelSource: ResourceSource }
-  | { modelName: 'fastsam-s'; modelSource: ResourceSource }
-  | { modelName: 'fastsam-x'; modelSource: ResourceSource };
-
-/**
- * Union of all built-in instance segmentation model names.
- * @category Types
- */
-export type InstanceSegmentationModelName =
-  InstanceSegmentationModelSources['modelName'];
-
-/**
- * Extracts the instance segmentation model name from a {@link InstanceSegmentationModelSources} config object.
- * @category Types
- */
-export type InstanceModelNameOf<C extends InstanceSegmentationModelSources> =
-  C['modelName'];
-
-/**
- * Props for the `useInstanceSegmentation` hook.
- * @typeParam C - A {@link InstanceSegmentationModelSources} config specifying which built-in model to load.
- * @property model - The model config containing `modelName` and `modelSource`.
- * @property {boolean} [preventLoad] - Boolean that can prevent automatic model loading (and downloading the data if you load it for the first time) after running the hook.
- * @category Types
- */
-export interface InstanceSegmentationProps<
-  C extends InstanceSegmentationModelSources,
-> {
-  model: C;
-  preventLoad?: boolean;
-}
-
-/**
- * Return type for the `useInstanceSegmentation` hook.
- * Manages the state and operations for instance segmentation models.
- * @typeParam L - The label map type for the model, must conform to {@link LabelEnum}.
- * @category Types
- */
-export interface InstanceSegmentationType<L extends LabelEnum> {
-  /**
-   * Contains the error object if the model failed to load, download, or encountered a runtime error during segmentation.
-   */
-  error: RnExecutorchError | null;
-
-  /**
-   * Indicates whether the instance segmentation model is loaded and ready to process images.
-   */
-  isReady: boolean;
-
-  /**
-   * Indicates whether the model is currently processing an image.
-   */
-  isGenerating: boolean;
-
-  /**
-   * Represents the download progress of the model binary as a value between 0 and 1.
-   */
-  downloadProgress: number;
-
-  /**
-   * Executes the model's forward pass to perform instance segmentation on the provided image.
-   * @param imageSource - A string (e.g., a file path, URI ) or PixelData representing the image source to be processed.
-   * @param options - Optional configuration for the segmentation process.
-   * @returns A Promise resolving to an array of {@link SegmentedInstance} objects.
-   * @throws {RnExecutorchError} If the model is not loaded or is currently processing another image.
-   */
-  forward: (
-    imageSource: string | PixelData,
-    options?: InstanceSegmentationOptions<L>
-  ) => Promise<SegmentedInstance<L>[]>;
-
-  /**
-   * Returns the available input sizes for this model, or undefined if the model accepts single forward input size.
-   * @returns An array of available input sizes, or undefined if not constrained.
-   */
-  getAvailableInputSizes: () => readonly number[] | undefined;
-
-  /**
-   * Synchronous worklet function for real-time VisionCamera frame processing.
-   * Automatically handles native buffer extraction and cleanup.
-   *
-   * **Use this for VisionCamera frame processing in worklets.**
-   * For async processing, use `forward()` instead.
-   *
-   * `null` until the model is ready (`isReady: true`). The property itself is
-   * `null` when the model has not loaded yet — the function always returns an
-   * array (never `null`) once called.
-   * @param frame - VisionCamera Frame object
-   * @param isFrontCamera - Whether the front camera is active (for mirroring correction).
-   * @param options - Optional configuration for the segmentation process.
-   * @returns Array of SegmentedInstance objects representing detected items in the frame.
-   */
-  runOnFrame:
-    | ((
-        frame: Frame,
-        isFrontCamera: boolean,
-        options?: InstanceSegmentationOptions<L>
-      ) => SegmentedInstance<L>[])
-    | null;
-}
diff --git a/packages/react-native-executorch/src/types/llm.ts b/packages/react-native-executorch/src/types/llm.ts
deleted file mode 100644
index 1d8da7bd70..0000000000
--- a/packages/react-native-executorch/src/types/llm.ts
+++ /dev/null
@@ -1,424 +0,0 @@
-import { RnExecutorchError } from '../errors/errorUtils';
-import { ResourceSource } from './common';
-
-/**
- * Capabilities a multimodal LLM can have.
- * @category Types
- */
-export type LLMCapability = 'vision' | 'audio';
-
-/**
- * Derives the media argument shape for `sendMessage` from a capabilities tuple.
- * @category Types
- */
-export type MediaArg<C extends readonly LLMCapability[]> =
-  ('vision' extends C[number] ? { imagePath?: string } : object) &
-    ('audio' extends C[number] ? { audioBuffer?: Float32Array } : object);
-
-/**
- * Union of all built-in LLM model names.
- * @category Types
- */
-export type LLMModelName =
-  | 'gemma4-e2b'
-  | 'gemma4-e2b-multimodal'
-  | 'llama-3.2-3b'
-  | 'llama-3.2-3b-qlora'
-  | 'llama-3.2-3b-spinquant'
-  | 'llama-3.2-1b'
-  | 'llama-3.2-1b-qlora'
-  | 'llama-3.2-1b-spinquant'
-  | 'qwen3-0.6b'
-  | 'qwen3-0.6b-quantized'
-  | 'qwen3-1.7b'
-  | 'qwen3-1.7b-quantized'
-  | 'qwen3-4b'
-  | 'qwen3-4b-quantized'
-  | 'hammer2.1-0.5b'
-  | 'hammer2.1-0.5b-quantized'
-  | 'hammer2.1-1.5b'
-  | 'hammer2.1-1.5b-quantized'
-  | 'hammer2.1-3b'
-  | 'hammer2.1-3b-quantized'
-  | 'smollm2.1-135m'
-  | 'smollm2.1-135m-quantized'
-  | 'smollm2.1-360m'
-  | 'smollm2.1-360m-quantized'
-  | 'smollm2.1-1.7b'
-  | 'smollm2.1-1.7b-quantized'
-  | 'qwen2.5-0.5b'
-  | 'qwen2.5-0.5b-quantized'
-  | 'qwen2.5-1.5b'
-  | 'qwen2.5-1.5b-quantized'
-  | 'qwen2.5-3b'
-  | 'qwen2.5-3b-quantized'
-  | 'phi-4-mini-4b'
-  | 'phi-4-mini-4b-quantized'
-  | 'lfm2.5-350m'
-  | 'lfm2.5-350m-quantized'
-  | 'lfm2.5-1.2b-instruct'
-  | 'lfm2.5-1.2b-instruct-quantized'
-  | 'lfm2.5-vl-1.6b-quantized'
-  | 'lfm2.5-vl-450m-quantized'
-  | 'qwen3.5-0.8b-quantized'
-  | 'qwen3.5-2b-quantized'
-  | 'bielik-v3.0-1.5b'
-  | 'bielik-v3.0-1.5b-quantized';
-
-/**
- * Audio soft-token expansion constants for audio_encoder.
- * @category Types
- */
-export interface AudioConfig {
-  samplesPerBlock: number;
-  tokensPerBlock: number;
-}
-
-/**
- * Properties defining LLMModel.
- * @category Types
- */
-export interface LLMModel {
-  /**
-   * The built-in model name (e.g. `'llama-3.2-3b'`). Used for telemetry and hook reload triggers.
-   * Pass one of the pre-built LLM constants (e.g. `LLAMA3_2_3B`) to populate all required fields.
-   */
-  modelName: LLMModelName;
-  /**
-   * `ResourceSource` that specifies the location of the model binary.
-   */
-  modelSource: ResourceSource;
-  /**
-   * `ResourceSource` pointing to the JSON file which contains the tokenizer.
-   */
-  tokenizerSource: ResourceSource;
-  /**
-   * `ResourceSource` pointing to the JSON file which contains the tokenizer config.
-   */
-  tokenizerConfigSource: ResourceSource;
-  /**
-   * Optional list of modality capabilities the model supports.
-   * Determines the type of the `media` argument in `sendMessage`.
-   * Example: `['vision']` enables `sendMessage(text, { imagePath })`.
-   */
-  capabilities?: readonly LLMCapability[];
-  /**
-   * Recommended default generation settings, typically copied from the
-   * upstream `generation_config.json` or the model card. Applied automatically
-   * after the native module loads and before any user `configure()` call,
-   * so callers only need to override the values they want to change.
-   */
-  generationConfig?: GenerationConfig;
-  /**
-   * Defines config for audio input modality for multimodal LLMs.
-   * `capabilities` must include 'audio'.
-   */
-  audioConfig?: AudioConfig;
-}
-
-/**
- * Properties for initializing and configuring a Large Language Model (LLM) instance.
- * @category Types
- */
-export interface LLMProps {
-  model: LLMModel;
-  /**
-   * Boolean that can prevent automatic model loading (and downloading the data if you load it for the first time) after running the hook.
-   */
-  preventLoad?: boolean;
-}
-
-/**
- * Base return type for `useLLM`. Contains all fields except `sendMessage`.
- * @category Types
- */
-export interface LLMTypeBase {
-  /**
-   * History containing all messages in conversation. This field is updated after model responds to sendMessage.
-   */
-  messageHistory: Message[];
-
-  /**
-   * State of the generated response. This field is updated with each token generated by the model.
-   */
-  response: string;
-
-  /**
-   * The most recently generated token.
-   */
-  token: string;
-
-  /**
-   * Indicates whether the model is ready.
-   */
-  isReady: boolean;
-
-  /**
-   * Indicates whether the model is currently generating a response.
-   */
-  isGenerating: boolean;
-
-  /**
-   * Represents the download progress as a value between 0 and 1, indicating the extent of the model file retrieval.
-   */
-  downloadProgress: number;
-
-  /**
-   * Contains the error message if the model failed to load.
-   */
-  error: RnExecutorchError | null;
-
-  /**
-   * Configures chat and tool calling.
-   * See [Configuring the model](https://docs.swmansion.com/react-native-executorch/docs/hooks/natural-language-processing/useLLM#configuring-the-model) for details.
-   * @param {LLMConfig} configuration - Configuration object containing `chatConfig`, `toolsConfig`, and `generationConfig`.
-   */
-  configure: ({ chatConfig, toolsConfig, generationConfig }: LLMConfig) => void;
-
-  /**
-   * Returns the number of tokens generated so far in the current generation.
-   * @returns The count of generated tokens.
-   */
-  getGeneratedTokenCount: () => number;
-  /**
-   * Runs model to complete chat passed in `messages` argument. It doesn't manage conversation context.
-   * For multimodal models, set `mediaPath` on user messages to include images.
-   * @param messages - Array of messages representing the chat history. User messages may include a `mediaPath` field with a local image path.
-   * @param tools - Optional array of tools that can be used during generation.
-   * @returns The generated tokens as `string`.
-   */
-  generate: (messages: Message[], tools?: LLMTool[]) => Promise<string>;
-  /**
-   * Returns the number of total tokens from the previous generation. This is a sum of prompt tokens and generated tokens.
-   * @returns The count of prompt and generated tokens.
-   */
-  getTotalTokenCount: () => number;
-  /**
-   * Returns the number of prompt tokens in the last message.
-   * @returns The count of prompt token.
-   */
-  getPromptTokenCount: () => number;
-
-  /**
-   * Deletes all messages starting with message on `index` position. After deletion `messageHistory` will be updated.
-   * @param index - The index of the message to delete from history.
-   */
-  deleteMessage: (index: number) => void;
-
-  /**
-   * Function to interrupt the current inference.
-   */
-  interrupt: () => void;
-}
-
-/**
- * Return type for `useLLM` when `model.capabilities` is provided.
- * `sendMessage` accepts a typed `media` object based on declared capabilities.
- * @category Types
- */
-export interface LLMTypeMultimodal<
-  C extends readonly LLMCapability[] = readonly LLMCapability[],
-> extends LLMTypeBase {
-  /**
-   * Function to add user message to conversation.
-   * Pass a `media` object whose shape is determined by the declared capabilities.
-   * After model responds, `messageHistory` will be updated.
-   * @param message - The message string to send.
-   * @param media - Optional media object (e.g. `{ imagePath }` for vision.
-   * @returns The model's response as a `string`.
-   */
-  sendMessage: (message: string, media?: MediaArg<C>) => Promise<string>;
-}
-
-/**
- * Return type for `useLLM` when `model.capabilities` is absent or does not include `'vision'`.
- * `sendMessage` accepts only text.
- * @category Types
- */
-export interface LLMType extends LLMTypeBase {
-  /**
-   * Function to add user message to conversation.
-   * After model responds, `messageHistory` will be updated.
-   * @param message - The message string to send.
-   * @returns The model's response as a `string`.
-   */
-  sendMessage: (message: string) => Promise<string>;
-}
-
-/**
- * Configuration object for initializing and customizing a Large Language Model (LLM) instance.
- * @category Types
- */
-export interface LLMConfig {
-  /**
-   * Object configuring chat management, contains following properties:
-   *
-   * `systemPrompt` - Often used to tell the model what is its purpose, for example - "Be a helpful translator".
-   *
-   * `initialMessageHistory` - An array of `Message` objects that represent the conversation history. This can be used to provide initial context to the model.
-   *
-   * `contextStrategy` - Defines a strategy for managing the conversation context window and message history
-   */
-  chatConfig?: Partial<ChatConfig>;
-
-  /**
-   * Object configuring options for enabling and managing tool use. **It will only have effect if your model's chat template support it**. Contains following properties:
-   *
-   * `tools` - List of objects defining tools.
-   *
-   * `executeToolCallback` - Function that accepts `ToolCall`, executes tool and returns the string to model.
-   *
-   * `displayToolCalls` - If set to true, JSON tool calls will be displayed in chat. If false, only answers will be displayed.
-   */
-  toolsConfig?: ToolsConfig;
-
-  /**
-   * Object configuring generation settings.
-   *
-   * `outputTokenBatchSize` - Soft upper limit on the number of tokens in each token batch (in certain cases there can be more tokens in given batch, i.e. when the batch would end with special emoji join character).
-   *
-   * `batchTimeInterval` - Upper limit on the time interval between consecutive token batches.
-   *
-   * `temperature` - Scales output logits by the inverse of temperature. Controls the randomness / creativity of text generation.
-   *
-   * `topp` - Only samples from the smallest set of tokens whose cumulative probability exceeds topp.
-   *
-   * `minP` - Minimum probability threshold: tokens with prob < minP * max_prob are excluded. 0 disables filtering.
-   *
-   * `repetitionPenalty` - Multiplicative penalty applied to logits of recently generated tokens. Values > 1 discourage repetition. 1 disables the penalty.
-   */
-  generationConfig?: GenerationConfig;
-}
-
-/**
- * Roles that a message sender can have.
- * @category Types
- */
-export type MessageRole = 'user' | 'assistant' | 'system';
-
-/**
- * Represents a message in the conversation.
- * @category Types
- * @property {MessageRole} role - Role of the message sender of type `MessageRole`.
- * @property {string} content - Content of the message.
- */
-export interface Message {
-  role: MessageRole;
-  content: string;
-  /**
-   * Optional local file path to media (image, audio, etc.).
-   * Only valid on `user` messages.
-   * Either `file:///absolute/path` or `/absolute/path` is accepted; the
-   * controller normalizes the path before passing it to native code.
-   */
-  mediaPath?: string;
-  /**
-   * Optional fp32 mono 16 kHz PCM buffer. Only valid on `user` messages for
-   * models with the `'audio'` capability. The controller forwards it to the
-   * native `generateMultimodal` path.
-   */
-  audioWaveform?: Float32Array;
-}
-
-/**
- * Represents a tool call made by the model.
- * @category Types
- * @property {string} toolName - The name of the tool being called.
- * @property {object} arguments - The arguments passed to the tool.
- */
-export interface ToolCall {
-  toolName: string;
-  arguments: Object;
-}
-
-/**
- * Represents a tool that can be used by the model.
- * Usually tool is represented with dictionary (Object), but fields depend on the model.
- * Unfortunately there's no one standard so it's hard to type it better.
- * @category Types
- */
-export type LLMTool = Object;
-
-/**
- * Object configuring chat management.
- * @category Types
- * @property {Message[]} initialMessageHistory - An array of `Message` objects that represent the conversation history. This can be used to provide initial context to the model.
- * @property {string} systemPrompt - Often used to tell the model what is its purpose, for example - "Be a helpful translator".
- * @property {ContextStrategy} contextStrategy - Defines a strategy for managing the conversation context window and message history.
- */
-export interface ChatConfig {
-  initialMessageHistory: Message[];
-  systemPrompt: string;
-  contextStrategy: ContextStrategy;
-}
-
-/**
- * Object configuring options for enabling and managing tool use. **It will only have effect if your model's chat template support it**.
- * @category Types
- * @property {LLMTool[]} tools - List of objects defining tools.
- * @property {(call: ToolCall) => Promise<string | null>} executeToolCallback - Function that accepts `ToolCall`, executes tool and returns the string to model.
- * @property {boolean} [displayToolCalls] - If set to true, JSON tool calls will be displayed in chat. If false, only answers will be displayed.
- */
-export interface ToolsConfig {
-  tools: LLMTool[];
-  executeToolCallback: (call: ToolCall) => Promise<string | null>;
-  displayToolCalls?: boolean;
-}
-
-/**
- * Object configuring generation settings.
- * @category Types
- * @property {number} [temperature] - Scales output logits by the inverse of temperature. Controls the randomness / creativity of text generation.
- * @property {number} [topP] - Only samples from the smallest set of tokens whose cumulative probability exceeds topP.
- * @property {number} [topp] - **Deprecated.** Use `topP` instead.
- * @property {number} [minP] - Minimum probability threshold: tokens with prob < minP * max_prob are excluded. 0 disables filtering.
- * @property {number} [repetitionPenalty] - Multiplicative penalty applied to logits of recently generated tokens. Values > 1 discourage repetition. 1 disables the penalty.
- * @property {number} [outputTokenBatchSize] - Soft upper limit on the number of tokens in each token batch (in certain cases there can be more tokens in given batch, i.e. when the batch would end with special emoji join character).
- * @property {number} [batchTimeInterval] - Upper limit on the time interval between consecutive token batches.
- */
-export interface GenerationConfig {
-  temperature?: number;
-  topP?: number;
-  /** @deprecated Use `topP` instead. */
-  topp?: number;
-  minP?: number;
-  repetitionPenalty?: number;
-  outputTokenBatchSize?: number;
-  batchTimeInterval?: number;
-}
-
-/**
- * Defines a strategy for managing the conversation context window and message history.
- * @category Types
- */
-export interface ContextStrategy {
-  /**
-   * Constructs the final array of messages to be sent to the model for the current inference step.
-   * @param systemPrompt - The top-level instructions or persona assigned to the model.
-   * @param history - The complete conversation history up to the current point.
-   * @param maxContextLength - The maximum number of tokens that the model can keep in the context.
-   * @param getTokenCount - A callback function provided by the LLM controller that calculates the exact number of tokens a specific array of messages will consume once formatted.
-   * @returns The optimized array of messages, ready to be processed by the model.
-   */
-  buildContext(
-    systemPrompt: string,
-    history: Message[],
-    maxContextLength: number,
-    getTokenCount: (messages: Message[]) => number
-  ): Message[];
-}
-
-/**
- * Special tokens used in Large Language Models (LLMs).
- * @category Types
- */
-export const SPECIAL_TOKENS = {
-  BOS_TOKEN: 'bos_token',
-  EOS_TOKEN: 'eos_token',
-  EOT_TOKEN: 'eot_token',
-  UNK_TOKEN: 'unk_token',
-  SEP_TOKEN: 'sep_token',
-  PAD_TOKEN: 'pad_token',
-  CLS_TOKEN: 'cls_token',
-  MASK_TOKEN: 'mask_token',
-};
diff --git a/packages/react-native-executorch/src/types/objectDetection.ts b/packages/react-native-executorch/src/types/objectDetection.ts
deleted file mode 100644
index 271676c439..0000000000
--- a/packages/react-native-executorch/src/types/objectDetection.ts
+++ /dev/null
@@ -1,196 +0,0 @@
-import { RnExecutorchError } from '../errors/errorUtils';
-import { LabelEnum, Triple, ResourceSource, PixelData, Frame } from './common';
-import { CocoLabel } from '../constants/commonVision';
-export { CocoLabel };
-
-/**
- * Represents a bounding box for a detected object in an image.
- * @category Types
- * @property {number} x1 - The x-coordinate of the top-left corner of the bounding box.
- * @property {number} y1 - The y-coordinate of the top-left corner of the bounding box.
- * @property {number} x2 - The x-coordinate of the bottom-right corner of the bounding box.
- * @property {number} y2 - The y-coordinate of the bottom-right corner of the bounding box.
- */
-export interface Bbox {
-  x1: number;
-  x2: number;
-  y1: number;
-  y2: number;
-}
-
-/**
- * Represents a detected object within an image, including its bounding box, label, and confidence score.
- * @category Types
- * @typeParam L - The label enum type for the detected object. Defaults to {@link CocoLabel}.
- * @property {Bbox} bbox - The bounding box of the detected object, defined by its top-left (x1, y1) and bottom-right (x2, y2) coordinates.
- * @property {keyof L} label - The class label of the detected object.
- * @property {number} score - The confidence score of the detection, typically ranging from 0 to 1.
- */
-export interface Detection<L extends LabelEnum = typeof CocoLabel> {
-  bbox: Bbox;
-  label: keyof L;
-  score: number;
-}
-
-/**
- * Options for configuring object detection inference.
- * @category Types
- * @typeParam L - The label enum type for filtering classes of interest.
- * @property {number} [detectionThreshold] - Minimum confidence score for detections (0-1). Defaults to model-specific value.
- * @property {number} [iouThreshold] - IoU threshold for non-maximum suppression (0-1). Defaults to model-specific value.
- * @property {number} [inputSize] - Input size for multi-method models (e.g., 384, 512, 640 for YOLO). Required for YOLO models if not using default.
- * @property {(keyof L)[]} [classesOfInterest] - Optional array of class labels to filter detections. Only detections matching these classes will be returned.
- */
-export interface ObjectDetectionOptions<L extends LabelEnum> {
-  detectionThreshold?: number;
-  iouThreshold?: number;
-  inputSize?: number;
-  classesOfInterest?: (keyof L)[];
-}
-
-/**
- * Per-model config for {@link ObjectDetectionModule.fromModelName}.
- * Each model name maps to its required fields.
- * @category Types
- */
-export type ObjectDetectionModelSources =
-  | { modelName: 'ssdlite-320-mobilenet-v3-large'; modelSource: ResourceSource }
-  | { modelName: 'rf-detr-nano'; modelSource: ResourceSource }
-  | { modelName: 'yolo26n'; modelSource: ResourceSource }
-  | { modelName: 'yolo26s'; modelSource: ResourceSource }
-  | { modelName: 'yolo26m'; modelSource: ResourceSource }
-  | { modelName: 'yolo26l'; modelSource: ResourceSource }
-  | { modelName: 'yolo26x'; modelSource: ResourceSource };
-
-/**
- * Union of all built-in object detection model names.
- * @category Types
- */
-export type ObjectDetectionModelName = ObjectDetectionModelSources['modelName'];
-
-/**
- * Configuration for a custom object detection model.
- * @category Types
- * @typeParam T - The label enum type for the model.
- * @property {T} labelMap - The label mapping for the model.
- * @property {object} [preprocessorConfig] - Optional preprocessing configuration with normalization parameters.
- * @property {number} [defaultDetectionThreshold] - Default detection confidence threshold (0-1).
- * @property {number} [defaultIouThreshold] - Default IoU threshold for non-maximum suppression (0-1).
- * @property {readonly number[]} [availableInputSizes] - For multi-method models, the available input sizes (e.g., [384, 512, 640]).
- * @property {number} [defaultInputSize] - For multi-method models, the default input size to use.
- */
-export type ObjectDetectionConfig<T extends LabelEnum> = {
-  labelMap: T;
-  preprocessorConfig?: { normMean?: Triple<number>; normStd?: Triple<number> };
-  defaultDetectionThreshold?: number;
-  defaultIouThreshold?: number;
-} & (
-  | {
-      availableInputSizes: readonly number[];
-      defaultInputSize: number;
-    }
-  | {
-      availableInputSizes?: undefined;
-      defaultInputSize?: undefined;
-    }
-);
-
-/**
- * Props for the `useObjectDetection` hook.
- * @typeParam C - A {@link ObjectDetectionModelSources} config specifying which built-in model to load.
- * @category Types
- * @property model - The model config containing `modelName` and `modelSource`.
- * @property {boolean} [preventLoad] - Boolean that can prevent automatic model loading (and downloading the data if you load it for the first time) after running the hook.
- */
-export interface ObjectDetectionProps<C extends ObjectDetectionModelSources> {
-  model: C;
-  preventLoad?: boolean;
-}
-
-/**
- * Return type for the `useObjectDetection` hook.
- * Manages the state and operations for Computer Vision object detection tasks.
- * @typeParam L - The {@link LabelEnum} representing the model's class labels.
- * @category Types
- */
-export interface ObjectDetectionType<L extends LabelEnum> {
-  /**
-   * Contains the error object if the model failed to load, download, or encountered a runtime error during detection.
-   */
-  error: RnExecutorchError | null;
-
-  /**
-   * Indicates whether the object detection model is loaded and ready to process images.
-   */
-  isReady: boolean;
-
-  /**
-   * Indicates whether the model is currently processing an image.
-   */
-  isGenerating: boolean;
-
-  /**
-   * Represents the download progress of the model binary as a value between 0 and 1.
-   */
-  downloadProgress: number;
-
-  /**
-   * Executes the model's forward pass with automatic input type detection.
-   * @param input - Image source (string path/URI or PixelData object)
-   * @param options - Optional configuration for detection inference
-   * @returns A Promise that resolves to an array of `Detection` objects.
-   * @throws {RnExecutorchError} If the model is not loaded or is currently processing another image.
-   * @example
-   * ```typescript
-   * // String path with options
-   * const detections1 = await model.forward('file:///path/to/image.jpg', {
-   *   detectionThreshold: 0.7,
-   *   inputSize: 640,  // For YOLO models
-   *   classesOfInterest: ['PERSON', 'CAR']
-   * });
-   *
-   * // Pixel data
-   * const detections2 = await model.forward({
-   *   dataPtr: new Uint8Array(rgbPixels),
-   *   sizes: [480, 640, 3],
-   *   scalarType: ScalarType.BYTE
-   * }, { detectionThreshold: 0.5 });
-   * ```
-   */
-  forward: (
-    input: string | PixelData,
-    options?: ObjectDetectionOptions<L>
-  ) => Promise<Detection<L>[]>;
-
-  /**
-   * Returns the available input sizes for multi-method models (e.g., YOLO).
-   * Returns undefined for single-method models (e.g., RF-DETR, SSDLite).
-   * @returns Array of available input sizes or undefined
-   * @example
-   * ```typescript
-   * const sizes = model.getAvailableInputSizes(); // [384, 512, 640] for YOLO models
-   * ```
-   */
-  getAvailableInputSizes: () => readonly number[] | undefined;
-
-  /**
-   * Synchronous worklet function for real-time VisionCamera frame processing.
-   * Automatically handles native buffer extraction and cleanup.
-   *
-   * **Use this for VisionCamera frame processing in worklets.**
-   * For async processing, use `forward()` instead.
-   *
-   * Available after model is loaded (`isReady: true`).
-   * @param frame - VisionCamera Frame object
-   * @param isFrontCamera - Whether the front camera is active, used for mirroring corrections.
-   * @param options - Optional configuration for detection inference
-   * @returns Array of Detection objects representing detected items in the frame.
-   */
-  runOnFrame:
-    | ((
-        frame: Frame,
-        isFrontCamera: boolean,
-        options?: ObjectDetectionOptions<L>
-      ) => Detection<L>[])
-    | null;
-}
diff --git a/packages/react-native-executorch/src/types/ocr.ts b/packages/react-native-executorch/src/types/ocr.ts
deleted file mode 100644
index 38879e6c9d..0000000000
--- a/packages/react-native-executorch/src/types/ocr.ts
+++ /dev/null
@@ -1,139 +0,0 @@
-import { symbols } from '../constants/ocr/symbols';
-import { RnExecutorchError } from '../errors/errorUtils';
-import { Frame, PixelData, ResourceSource } from './common';
-import { Bbox } from './objectDetection';
-
-/**
- * OCRDetection represents a single detected text instance in an image,
- * including its bounding box, recognized text, and confidence score.
- * @category Types
- * @property {Bbox} bbox - The axis-aligned bounding box around the detected text, with `x1`/`y1` as the top-left corner and `x2`/`y2` as the bottom-right corner.
- * @property {string} text - The recognized text within the bounding box.
- * @property {number} score - The confidence score of the OCR detection, ranging from 0 to 1.
- */
-export interface OCRDetection {
-  bbox: Bbox;
-  text: string;
-  score: number;
-}
-
-/**
- * Configuration properties for the `useOCR` hook.
- * @category Types
- */
-export interface OCRProps {
-  /**
-   * Object containing the necessary model sources and configuration for the OCR pipeline.
-   */
-  model: {
-    /**
-     * The built-in model name, e.g. `'ocr-en'`. Used for telemetry and hook reload triggers.
-     * Pass one of the pre-built OCR constants (e.g. `OCR_ENGLISH`) to populate all required fields.
-     */
-    modelName: OCRModelName;
-
-    /**
-     * `ResourceSource` that specifies the location of the text detector model binary.
-     */
-    detectorSource: ResourceSource;
-
-    /**
-     * `ResourceSource` that specifies the location of the text recognizer model binary.
-     */
-    recognizerSource: ResourceSource;
-
-    /**
-     * The language configuration enum for the OCR model (e.g., English, Polish, etc.).
-     */
-    language: OCRLanguage;
-  };
-
-  /**
-   * Boolean that can prevent automatic model loading (and downloading the data if loaded for the first time) after running the hook.
-   * Defaults to `false`.
-   */
-  preventLoad?: boolean;
-}
-
-/**
- * Configuration properties for the `useVerticalOCR` hook.
- * @category Types
- */
-export interface VerticalOCRProps extends OCRProps {
-  /**
-   * Boolean indicating whether to treat each character independently during recognition.
-   * Defaults to `false`.
-   */
-  independentCharacters?: boolean;
-}
-
-/**
- * Return type for the `useOCR` hook.
- * Manages the state and operations for Optical Character Recognition (OCR).
- * @category Types
- */
-export interface OCRType {
-  /**
-   * Contains the error object if the models failed to load, download, or encountered a runtime error during recognition.
-   */
-  error: RnExecutorchError | null;
-
-  /**
-   * Indicates whether both detector and recognizer models are loaded and ready to process images.
-   */
-  isReady: boolean;
-
-  /**
-   * Indicates whether the model is currently processing an image.
-   */
-  isGenerating: boolean;
-
-  /**
-   * Represents the total download progress of the model binaries as a value between 0 and 1.
-   */
-  downloadProgress: number;
-
-  /**
-   * Executes the OCR pipeline (detection and recognition) on the provided image.
-   *
-   * Supports two input types:
-   * 1. **String path/URI**: File path, URL, or Base64-encoded string
-   * 2. **PixelData**: Raw pixel data from image libraries (e.g., NitroImage)
-   *
-   * **Note**: For VisionCamera frame processing, use `runOnFrame` instead.
-   * @param input - Image source (string or PixelData object)
-   * @returns A Promise that resolves to the OCR results (recognized text and bounding boxes).
-   * @throws {RnExecutorchError} If the models are not loaded or are currently processing another image.
-   */
-  forward: (input: string | PixelData) => Promise<OCRDetection[]>;
-
-  /**
-   * Synchronous worklet function for VisionCamera frame processing.
-   * Automatically handles native buffer extraction and cleanup.
-   *
-   * **Use this for VisionCamera frame processing in worklets.**
-   * For async processing, use `forward()` instead.
-   *
-   * **Note**: OCR is a two-stage pipeline (detection + recognition) and may not
-   * achieve real-time frame rates. Frames may be dropped if inference is still running.
-   *
-   * Available after model is loaded (`isReady: true`).
-   * @param frame - VisionCamera Frame object
-   * @param isFrontCamera - Whether the front camera is active, used for mirroring corrections.
-   * @returns Array of OCRDetection results for the frame.
-   */
-  runOnFrame: ((frame: Frame, isFrontCamera: boolean) => OCRDetection[]) | null;
-}
-
-/**
- * Enumeration of supported OCR languages based on available symbol sets.
- * @category Types
- */
-export type OCRLanguage = keyof typeof symbols;
-
-/**
- * Union of all built-in OCR model names.
- * Each name is derived from the language code, e.g. `'ocr-en'`, `'ocr-ja'`.
- * @category Types
- */
-export type OCRModelName = `ocr-${OCRLanguage}`;
diff --git a/packages/react-native-executorch/src/types/poseEstimation.ts b/packages/react-native-executorch/src/types/poseEstimation.ts
deleted file mode 100644
index 03afc592c3..0000000000
--- a/packages/react-native-executorch/src/types/poseEstimation.ts
+++ /dev/null
@@ -1,159 +0,0 @@
-import { Frame, LabelEnum, PixelData, ResourceSource } from './common';
-import { CocoKeypoint } from '../constants/poseEstimation';
-import { RnExecutorchError } from '../errors/errorUtils';
-
-export { CocoKeypoint };
-
-/**
- * A single keypoint with x, y coordinates
- * @category Types
- */
-export interface Keypoint {
-  x: number;
-  y: number;
-}
-
-/**
- * Keypoints for a single detected person, keyed by name from the keypoint map.
- * @typeParam K - The {@link LabelEnum} for this model.
- * @category Types
- * @example
- * ```ts
- * person.NOSE; // { x, y }
- * ```
- */
-export type PersonKeypoints<K extends LabelEnum = typeof CocoKeypoint> = {
-  readonly [Name in keyof K]: Keypoint;
-};
-
-/**
- * Pose estimation result containing all detected people.
- * @category Types
- */
-export type PoseDetections<K extends LabelEnum = typeof CocoKeypoint> =
-  PersonKeypoints<K>[];
-
-/**
- * Configuration for pose estimation model behavior.
- * @category Types
- * @typeParam K - The keypoint enum type for this model.
- */
-export type PoseEstimationConfig<K extends LabelEnum> = {
-  keypointMap: K;
-  preprocessorConfig?: {
-    normMean?: readonly [number, number, number];
-    normStd?: readonly [number, number, number];
-  };
-  defaultDetectionThreshold?: number;
-  defaultKeypointThreshold?: number;
-} & (
-  | {
-      availableInputSizes: readonly number[];
-      defaultInputSize: number;
-    }
-  | {
-      availableInputSizes?: undefined;
-      defaultInputSize?: undefined;
-    }
-);
-
-/**
- * Per-model config for {@link PoseEstimationModule.fromModelName}.
- * Each model name maps to its required fields.
- * @category Types
- */
-export type PoseEstimationModelSources = {
-  modelName: 'yolo26n-pose';
-  modelSource: ResourceSource;
-};
-
-/**
- * Union of all built-in pose estimation model names.
- * @category Types
- */
-export type PoseEstimationModelName = PoseEstimationModelSources['modelName'];
-
-/**
- * Props for usePoseEstimation hook.
- * @typeParam C - A {@link PoseEstimationModelSources} config specifying which built-in model to load.
- * @category Types
- */
-export interface PoseEstimationProps<C extends PoseEstimationModelSources> {
-  model: C;
-  preventLoad?: boolean;
-}
-
-/**
- * Options for pose estimation inference
- * @category Types
- */
-export interface PoseEstimationOptions {
-  detectionThreshold?: number;
-  /**
-   * Per-keypoint visibility threshold (0-1). Keypoints whose visibility
-   * score is below this are emitted as (-1, -1) so consumers can skip them.
-   * Defaults to the model config's `defaultKeypointThreshold` (typically 0.5).
-   */
-  keypointThreshold?: number;
-  /**
-   * Input size for multi-method models.
-   * For YOLO models, valid values are typically 384, 512, or 640.
-   * Maps to forward_384, forward_512, forward_640 methods.
-   */
-  inputSize?: number;
-}
-
-/**
- * Return type of usePoseEstimation hook.
- * @typeParam K - The {@link LabelEnum} representing the model's keypoint schema.
- * @category Types
- */
-export interface PoseEstimationType<K extends LabelEnum> {
-  /**
-   * Contains the error object if the model failed to load or encountered a runtime error.
-   */
-  error: RnExecutorchError | null;
-
-  /**
-   * Indicates whether the model is loaded and ready to process images.
-   */
-  isReady: boolean;
-
-  /**
-   * Indicates whether the model is currently processing an image.
-   */
-  isGenerating: boolean;
-
-  /**
-   * Represents the download progress of the model binary as a value between 0 and 1.
-   */
-  downloadProgress: number;
-
-  /**
-   * Run pose estimation on an image.
-   * @param input - Image path/URI or PixelData
-   * @param options - Detection options
-   * @returns Array of detected people, each with keypoints accessible via the keypoint enum
-   */
-  forward: (
-    input: string | PixelData,
-    options?: PoseEstimationOptions
-  ) => Promise<PoseDetections<K>>;
-
-  /**
-   * Returns the available input sizes for multi-method models.
-   * Returns undefined for single-method models.
-   */
-  getAvailableInputSizes: () => readonly number[] | undefined;
-
-  /**
-   * Synchronous worklet function for real-time VisionCamera frame processing.
-   */
-  runOnFrame:
-    | ((
-        frame: Frame,
-        isFrontCamera: boolean,
-        options?: PoseEstimationOptions
-      ) => PoseDetections<K>)
-    | null;
-}
diff --git a/packages/react-native-executorch/src/types/privacyFilter.ts b/packages/react-native-executorch/src/types/privacyFilter.ts
deleted file mode 100644
index 3e604af5f3..0000000000
--- a/packages/react-native-executorch/src/types/privacyFilter.ts
+++ /dev/null
@@ -1,95 +0,0 @@
-import { RnExecutorchError } from '../errors/errorUtils';
-import { ResourceSource } from './common';
-
-/**
- * Six Viterbi transition biases that match the operating-point schema
- * from the openai/privacy-filter `viterbi_calibration.json`. Each value
- * is added to the decoder score whenever the corresponding BIOES
- * transition is taken.
- *
- * Positive values *encourage* the transition; negative values discourage
- * it. Defaults are zero (neutral validity-only Viterbi).
- * @category Types
- */
-export interface ViterbiBiases {
-  /** O -> O (background persistence). Higher = stay in background more, fewer false positives. */
-  backgroundStay?: number;
-  /** O -> B-* / S-* (span entry). Lower (negative) = enter spans more eagerly, higher recall. */
-  backgroundToStart?: number;
-  /** E-/S-* -> O (span closure to background). */
-  endToBackground?: number;
-  /** E-/S-* -> B-* / S-* (back-to-back spans). */
-  endToStart?: number;
-  /** B-/I-X -> I-X (span continuation). Higher = longer spans. */
-  insideToContinue?: number;
-  /** B-/I-X -> E-X (span closure). Higher = shorter spans. */
-  insideToEnd?: number;
-}
-
-/**
- * Per-model config for {@link PrivacyFilterModule.fromModelName}. Each
- * built-in `modelName` resolves to its baked-in label list and default
- * Viterbi biases; custom fine-tunes go through
- * {@link PrivacyFilterModule.fromCustomModel} instead.
- * @category Types
- */
-export type PrivacyFilterModelSources =
-  | {
-      modelName: 'privacy-filter-openai';
-      modelSource: ResourceSource;
-      tokenizerSource: ResourceSource;
-    }
-  | {
-      modelName: 'privacy-filter-nemotron';
-      modelSource: ResourceSource;
-      tokenizerSource: ResourceSource;
-    };
-
-/**
- * Union of all built-in privacy filter model names.
- * @category Types
- */
-export type PrivacyFilterModelName = PrivacyFilterModelSources['modelName'];
-
-/**
- * A single detected PII entity span.
- * @category Types
- */
-export interface PiiEntity {
-  /** Entity type, e.g. `private_person`, `private_email`, `secret`. */
-  label: string;
-  /** Decoded text of the span (whitespace trimmed). */
-  text: string;
-  /** Inclusive start token index in the original (unpadded) tokenization. */
-  startToken: number;
-  /** Exclusive end token index. */
-  endToken: number;
-}
-
-/**
- * Props for the usePrivacyFilter hook.
- * @category Types
- */
-export interface PrivacyFilterProps {
-  model: PrivacyFilterModelSources;
-  preventLoad?: boolean;
-}
-
-/**
- * React hook state and methods for a Privacy Filter model.
- * @category Types
- */
-export interface PrivacyFilterType {
-  error: null | RnExecutorchError;
-  isReady: boolean;
-  isGenerating: boolean;
-  downloadProgress: number;
-  /**
-   * Run PII detection over the given text. Long inputs are processed in
-   * sliding windows with 50% overlap; no truncation. The window size is
-   * determined by the model's exported `forward` input shape.
-   * @param text Input text.
-   * @returns A promise resolving to detected entity spans.
-   */
-  generate(text: string): Promise<PiiEntity[]>;
-}
diff --git a/packages/react-native-executorch/src/types/semanticSegmentation.ts b/packages/react-native-executorch/src/types/semanticSegmentation.ts
deleted file mode 100644
index 8f13a65eb7..0000000000
--- a/packages/react-native-executorch/src/types/semanticSegmentation.ts
+++ /dev/null
@@ -1,180 +0,0 @@
-import { RnExecutorchError } from '../errors/errorUtils';
-import { LabelEnum, Triple, ResourceSource, PixelData, Frame } from './common';
-
-/**
- * Configuration for a custom semantic segmentation model.
- * @typeParam T - The {@link LabelEnum} type for the model.
- * @property labelMap - The enum-like object mapping class names to indices.
- * @property preprocessorConfig - Optional preprocessing parameters.
- * @property preprocessorConfig.normMean - Per-channel mean values for input normalization.
- * @property preprocessorConfig.normStd - Per-channel standard deviation values for input normalization.
- * @category Types
- */
-export type SemanticSegmentationConfig<T extends LabelEnum> = {
-  labelMap: T;
-  preprocessorConfig?: { normMean?: Triple<number>; normStd?: Triple<number> };
-};
-
-/**
- * Per-model config for {@link SemanticSegmentationModule.fromModelName}.
- * Each model name maps to its required fields.
- * Add new union members here when a model needs extra sources or options.
- * @category Types
- */
-export type SemanticSegmentationModelSources =
-  | { modelName: 'deeplab-v3-resnet50'; modelSource: ResourceSource }
-  | { modelName: 'deeplab-v3-resnet101'; modelSource: ResourceSource }
-  | { modelName: 'deeplab-v3-mobilenet-v3-large'; modelSource: ResourceSource }
-  | { modelName: 'lraspp-mobilenet-v3-large'; modelSource: ResourceSource }
-  | { modelName: 'fcn-resnet50'; modelSource: ResourceSource }
-  | { modelName: 'fcn-resnet101'; modelSource: ResourceSource }
-  | { modelName: 'deeplab-v3-resnet50-quantized'; modelSource: ResourceSource }
-  | { modelName: 'deeplab-v3-resnet101-quantized'; modelSource: ResourceSource }
-  | {
-      modelName: 'deeplab-v3-mobilenet-v3-large-quantized';
-      modelSource: ResourceSource;
-    }
-  | {
-      modelName: 'lraspp-mobilenet-v3-large-quantized';
-      modelSource: ResourceSource;
-    }
-  | { modelName: 'fcn-resnet50-quantized'; modelSource: ResourceSource }
-  | { modelName: 'fcn-resnet101-quantized'; modelSource: ResourceSource }
-  | { modelName: 'selfie-segmentation'; modelSource: ResourceSource };
-
-/**
- * Union of all built-in semantic segmentation model names
- * (e.g. `'deeplab-v3-resnet50'`, `'selfie-segmentation'`).
- * @category Types
- */
-export type SemanticSegmentationModelName =
-  SemanticSegmentationModelSources['modelName'];
-
-/**
- * Extracts the model name from a {@link SemanticSegmentationModelSources} config object.
- * @category Types
- */
-export type ModelNameOf<C extends SemanticSegmentationModelSources> =
-  C['modelName'];
-
-/**
- * Labels used in the DeepLab semantic segmentation model.
- * @category Types
- */
-export enum DeeplabLabel {
-  BACKGROUND,
-  AEROPLANE,
-  BICYCLE,
-  BIRD,
-  BOAT,
-  BOTTLE,
-  BUS,
-  CAR,
-  CAT,
-  CHAIR,
-  COW,
-  DININGTABLE,
-  DOG,
-  HORSE,
-  MOTORBIKE,
-  PERSON,
-  POTTEDPLANT,
-  SHEEP,
-  SOFA,
-  TRAIN,
-  TVMONITOR,
-}
-
-/**
- * Labels used in the selfie semantic segmentation model.
- * @category Types
- */
-export enum SelfieSegmentationLabel {
-  SELFIE,
-  BACKGROUND,
-}
-
-/**
- * Props for the `useSemanticSegmentation` hook.
- * @typeParam C - A {@link SemanticSegmentationModelSources} config specifying which built-in model to load.
- * @property model - The model config containing `modelName` and `modelSource`.
- * @property {boolean} [preventLoad] - Boolean that can prevent automatic model loading (and downloading the data if you load it for the first time) after running the hook.
- * @category Types
- */
-export interface SemanticSegmentationProps<
-  C extends SemanticSegmentationModelSources,
-> {
-  model: C;
-  preventLoad?: boolean;
-}
-
-/**
- * Return type for the `useSemanticSegmentation` hook.
- * Manages the state and operations for semantic segmentation models.
- * @typeParam L - The {@link LabelEnum} representing the model's class labels.
- * @category Types
- */
-export interface SemanticSegmentationType<L extends LabelEnum> {
-  /**
-   * Contains the error object if the model failed to load, download, or encountered a runtime error during segmentation.
-   */
-  error: RnExecutorchError | null;
-
-  /**
-   * Indicates whether the segmentation model is loaded and ready to process images.
-   */
-  isReady: boolean;
-
-  /**
-   * Indicates whether the model is currently processing an image.
-   */
-  isGenerating: boolean;
-
-  /**
-   * Represents the download progress of the model binary as a value between 0 and 1.
-   */
-  downloadProgress: number;
-
-  /**
-   * Executes the model's forward pass to perform semantic segmentation on the provided image.
-   *
-   * Supports two input types:
-   * 1. **String path/URI**: File path, URL, or Base64-encoded string
-   * 2. **PixelData**: Raw pixel data from image libraries (e.g., NitroImage)
-   *
-   * **Note**: For VisionCamera frame processing, use `runOnFrame` instead.
-   * @param input - Image source (string or PixelData object)
-   * @param classesOfInterest - An optional array of label keys indicating which per-class probability masks to include in the output. `ARGMAX` is always returned regardless.
-   * @param resizeToInput - Whether to resize the output masks to the original input image dimensions. If `false`, returns the raw model output dimensions. Defaults to `true`.
-   * @returns A Promise resolving to an object with an `'ARGMAX'` `Int32Array` of per-pixel class indices, and each requested class label mapped to a `Float32Array` of per-pixel probabilities.
-   * @throws {RnExecutorchError} If the model is not loaded or is currently processing another image.
-   */
-  forward: <K extends keyof L>(
-    input: string | PixelData,
-    classesOfInterest?: K[],
-    resizeToInput?: boolean
-  ) => Promise<Record<'ARGMAX', Int32Array> & Record<K, Float32Array>>;
-
-  /**
-   * Synchronous worklet function for real-time VisionCamera frame processing.
-   * Automatically handles native buffer extraction and cleanup.
-   *
-   * **Use this for VisionCamera frame processing in worklets.**
-   * For async processing, use `forward()` instead.
-   *
-   * Available after model is loaded (`isReady: true`).
-   * @param frame - VisionCamera Frame object
-   * @param isFrontCamera - Whether the front camera is active, used for mirroring corrections.
-   * @param classesOfInterest - Labels for which to return per-class probability masks.
-   * @param resizeToInput - Whether to resize masks to original frame dimensions. Defaults to `true`.
-   * @returns Object with `ARGMAX` Int32Array and per-class Float32Array masks.
-   */
-  runOnFrame:
-    | ((
-        frame: Frame,
-        isFrontCamera: boolean,
-        classesOfInterest?: string[],
-        resizeToInput?: boolean
-      ) => Record<'ARGMAX', Int32Array> & Record<string, Float32Array>)
-    | null;
-}
diff --git a/packages/react-native-executorch/src/types/stt.ts b/packages/react-native-executorch/src/types/stt.ts
deleted file mode 100644
index 7669f6c044..0000000000
--- a/packages/react-native-executorch/src/types/stt.ts
+++ /dev/null
@@ -1,310 +0,0 @@
-import { ResourceSource } from './common';
-import { VADConfig } from './vad';
-import { RnExecutorchError } from '../errors/errorUtils';
-
-/**
- * Named Speech to Text model variants.
- * @category Types
- */
-export type SpeechToTextModelName =
-  | 'whisper-tiny-en'
-  | 'whisper-base-en'
-  | 'whisper-small-en'
-  | 'whisper-tiny'
-  | 'whisper-base'
-  | 'whisper-small';
-
-/**
- * Configuration for Speech to Text model.
- * @category Types
- */
-export interface SpeechToTextProps {
-  /**
-   * Configuration object containing model sources.
-   */
-  model: SpeechToTextModelConfig; // | ...
-  /**
-   * An optional VAD model to be utilized to enhance speech-to-text streaming capabilities.
-   */
-  vad?: VADConfig;
-  /**
-   * Boolean that can prevent automatic model loading (and downloading the data if you load it for the first time) after running the hook.
-   */
-  preventLoad?: boolean;
-}
-
-/**
- * React hook for managing Speech to Text (STT) instance.
- * @category Types
- */
-export interface SpeechToTextType {
-  /**
-   * Contains the error message if the model failed to load.
-   */
-  error: null | RnExecutorchError;
-
-  /**
-   * Indicates whether the model has successfully loaded and is ready for inference.
-   */
-  isReady: boolean;
-
-  /**
-   * Indicates whether the model is currently processing an inference.
-   */
-  isGenerating: boolean;
-
-  /**
-   * Tracks the progress of the model download process.
-   */
-  downloadProgress: number;
-
-  /**
-   * Runs the encoding part of the model on the provided waveform.
-   * @param waveform - The input audio waveform array.
-   * @returns A promise resolving to the encoded data.
-   */
-  encode(waveform: Float32Array): Promise<Float32Array>;
-
-  /**
-   * Runs the decoder of the model.
-   * @param tokens - The encoded audio data.
-   * @param encoderOutput - The output from the encoder.
-   * @returns A promise resolving to the decoded text.
-   */
-  decode(
-    tokens: Int32Array,
-    encoderOutput: Float32Array
-  ): Promise<Float32Array>;
-
-  /**
-   * Starts a transcription process for a given input array, which should be a waveform at 16kHz.
-   * @param waveform - The input audio waveform.
-   * @param options - Decoding options, check API reference for more details.
-   * @returns Resolves a promise with the output transcription. Result of transcription is
-   * object of type `TranscriptionResult`.
-   */
-  transcribe(
-    waveform: Float32Array,
-    options?: DecodingOptions | undefined
-  ): Promise<TranscriptionResult>;
-
-  /**
-   * Starts a streaming transcription process.
-   * Use in combination with `streamInsert` to feed audio chunks and `streamStop` to end the stream.
-   * Updates `committedTranscription` and `nonCommittedTranscription` as transcription progresses.
-   * @param options - Decoding options including language.
-   * @returns Asynchronous generator that returns `committed` and `nonCommitted` transcription.
-   * Both `committed` and `nonCommitted` are of type `TranscriptionResult`
-   */
-  stream(options?: StreamingOptions | undefined): AsyncGenerator<
-    {
-      committed: TranscriptionResult;
-      nonCommitted: TranscriptionResult;
-    },
-    void,
-    unknown
-  >;
-
-  /**
-   * Inserts a chunk of audio data (sampled at 16kHz) into the ongoing streaming transcription.
-   * @param waveform - The audio chunk to insert.
-   */
-  streamInsert(waveform: Float32Array): void;
-
-  /**
-   * Stops the ongoing streaming transcription process.
-   */
-  streamStop(): void;
-}
-
-/**
- * Languages supported by whisper (not whisper.en)
- * @category Types
- */
-export type SpeechToTextLanguage =
-  | 'af'
-  | 'sq'
-  | 'ar'
-  | 'hy'
-  | 'az'
-  | 'eu'
-  | 'be'
-  | 'bn'
-  | 'bs'
-  | 'bg'
-  | 'my'
-  | 'ca'
-  | 'zh'
-  | 'hr'
-  | 'cs'
-  | 'da'
-  | 'nl'
-  | 'et'
-  | 'en'
-  | 'fi'
-  | 'fr'
-  | 'gl'
-  | 'ka'
-  | 'de'
-  | 'el'
-  | 'gu'
-  | 'ht'
-  | 'he'
-  | 'hi'
-  | 'hu'
-  | 'is'
-  | 'id'
-  | 'it'
-  | 'ja'
-  | 'kn'
-  | 'kk'
-  | 'km'
-  | 'ko'
-  | 'lo'
-  | 'lv'
-  | 'lt'
-  | 'mk'
-  | 'mg'
-  | 'ms'
-  | 'ml'
-  | 'mt'
-  | 'mr'
-  | 'ne'
-  | 'no'
-  | 'fa'
-  | 'pl'
-  | 'pt'
-  | 'pa'
-  | 'ro'
-  | 'ru'
-  | 'sr'
-  | 'si'
-  | 'sk'
-  | 'sl'
-  | 'es'
-  | 'su'
-  | 'sw'
-  | 'sv'
-  | 'tl'
-  | 'tg'
-  | 'ta'
-  | 'te'
-  | 'th'
-  | 'tr'
-  | 'uk'
-  | 'ur'
-  | 'uz'
-  | 'vi'
-  | 'cy'
-  | 'yi';
-
-/**
- * Options for decoding speech to text.
- * @category Types
- * @property {SpeechToTextLanguage} [language] - Optional language code to guide the transcription.
- * @property {boolean} [verbose] - Optional flag. If set, transcription result is presented with timestamps
- * and with additional parameters. For more details please refer to `TranscriptionResult`.
- */
-export interface DecodingOptions {
-  language?: SpeechToTextLanguage;
-  verbose?: boolean;
-}
-
-/**
- * Configuration options for the speech-to-text streaming process.
- * @category Types
- * @property {number} [timeout] - Specifies (in milliseconds) how much does streamer wait between model inferences.
- * @property {boolean} [useVAD] - When set to true, utilizes the inner VAD submodule (if initialized) and
- *                                transcription process runs only when speech is being detected.
- * @property {number} [vadDetectionMargin] - Specifies (in milliseconds) how far the last detected speech segment can be to still be considered
- *                                           as ongoing speech. Works only with useVAD set to true.
- */
-export interface StreamingOptions extends DecodingOptions {
-  timeout?: number;
-  useVAD?: boolean;
-  vadDetectionMargin?: number;
-}
-
-/**
- * Structure that represent single token with timestamp information.
- * @category Types
- * @property {string} [word] - Token as a string value.
- * @property {number} [start] - Timestamp of the beginning of the token in audio (in seconds).
- * @property {number} [end] - Timestamp of the end of the token in audio (in seconds).
- */
-export interface Word {
-  word: string;
-  start: number;
-  end: number;
-}
-
-/**
- * Structure that represent single Segment of transcription.
- * @category Types
- * @property {number} [start] - Timestamp of the beginning of the segment in audio (in seconds).
- * @property {number} [end] - Timestamp of the end of the segment in audio (in seconds).
- * @property {string} [text] - Full text of the given segment as a string.
- * @property {Word[]} [words] - If `verbose` set to `true` in `DecodingOptions`, it returns word-level timestamping
- * as an array of `Word`.
- * @property {number[]} [tokens] - Raw tokens represented as table of integers.
- * @property {number} [temperature] - Temperature for which given segment was computed.
- * @property {number} [avgLogprob] - Average log probability calculated across all tokens in a segment.
- * @property {number} [compressionRatio] - Compression ration achieved on a given segment.
- */
-export interface TranscriptionSegment {
-  start: number;
-  end: number;
-  text: string;
-  words?: Word[];
-  tokens: number[];
-  temperature: number;
-  avgLogprob: number;
-  compressionRatio: number;
-}
-
-/**
- * Structure that represent result of transcription for a one function call (either `transcribe` or `stream`).
- * @category Types
- * @property {'transcribe' | 'stream'} [task] - String indicating task, either 'transcribe' or 'stream'.
- * @property {string} [language] - Language chosen for transcription.
- * @property {number} [duration] - Duration in seconds of a given transcription.
- * @property {string} [text] - The whole text of a transcription as a `string`.
- * @property {TranscriptionSegment[]} [segments] - If `verbose` set to `true` in `DecodingOptions`, it contains array of
- * `TranscriptionSegment` with details split into separate transcription segments.
- */
-export interface TranscriptionResult {
-  task?: 'transcribe' | 'stream';
-  language: string;
-  duration: number;
-  text: string;
-  segments?: TranscriptionSegment[]; // Present if verbose=true
-}
-
-/**
- * Configuration for Speech to Text model.
- * @category Types
- */
-export interface SpeechToTextModelConfig {
-  /**
-   * The built-in model name (e.g. `'whisper-tiny-en'`). Used for telemetry and hook reload triggers.
-   * Pass one of the pre-built STT constants (e.g. `WHISPER_TINY_EN`) to populate all required fields.
-   */
-  modelName: SpeechToTextModelName;
-
-  /**
-   * A boolean flag indicating whether the model supports multiple languages.
-   */
-  isMultilingual: boolean;
-
-  /**
-   * A string that specifies the location of a `.pte` file for the model.
-   *
-   * We expect the model to have 2 bundled methods: 'decode' and 'encode'.
-   */
-  modelSource: ResourceSource;
-
-  /**
-   * A string that specifies the location to the tokenizer for the model.
-   */
-  tokenizerSource: ResourceSource;
-}
diff --git a/packages/react-native-executorch/src/types/styleTransfer.ts b/packages/react-native-executorch/src/types/styleTransfer.ts
deleted file mode 100644
index ca08366f34..0000000000
--- a/packages/react-native-executorch/src/types/styleTransfer.ts
+++ /dev/null
@@ -1,88 +0,0 @@
-import { RnExecutorchError } from '../errors/errorUtils';
-import { ResourceSource, PixelData, Frame } from './common';
-
-/**
- * Union of all built-in style transfer model names.
- * @category Types
- */
-export type StyleTransferModelName =
-  | 'style-transfer-candy'
-  | 'style-transfer-candy-quantized'
-  | 'style-transfer-mosaic'
-  | 'style-transfer-mosaic-quantized'
-  | 'style-transfer-rain-princess'
-  | 'style-transfer-rain-princess-quantized'
-  | 'style-transfer-udnie'
-  | 'style-transfer-udnie-quantized';
-
-/**
- * Configuration properties for the `useStyleTransfer` hook.
- * @category Types
- * @property {object} model - Object containing the model configuration.
- * @property {StyleTransferModelName} model.modelName - Unique name identifying the model.
- * @property {ResourceSource} model.modelSource - `ResourceSource` that specifies the location of the style transfer model binary.
- * @property {boolean} [preventLoad] - Boolean that can prevent automatic model loading (and downloading the data if loaded for the first time) after running the hook.
- */
-export interface StyleTransferProps {
-  model: { modelName: StyleTransferModelName; modelSource: ResourceSource };
-  preventLoad?: boolean;
-}
-
-/**
- * Return type for the `useStyleTransfer` hook.
- * Manages the state and operations for applying artistic style transfer to images.
- * @category Types
- */
-export interface StyleTransferType {
-  /**
-   * Contains the error object if the model failed to load, download, or encountered a runtime error during style transfer.
-   */
-  error: RnExecutorchError | null;
-
-  /**
-   * Indicates whether the style transfer model is loaded and ready to process images.
-   */
-  isReady: boolean;
-
-  /**
-   * Indicates whether the model is currently processing an image.
-   */
-  isGenerating: boolean;
-
-  /**
-   * Represents the download progress of the model binary as a value between 0 and 1.
-   */
-  downloadProgress: number;
-
-  /**
-   * Executes the model's forward pass to apply the specific artistic style to the provided image.
-   *
-   * Supports two input types:
-   * 1. **String path/URI**: File path, URL, or Base64-encoded string
-   * 2. **PixelData**: Raw pixel data from image libraries (e.g., NitroImage)
-   *
-   * **Note**: For VisionCamera frame processing, use `runOnFrame` instead.
-   * @param input - Image source (string or PixelData object)
-   * @param outputType - Output format: `'pixelData'` (default) returns raw RGBA pixel data; `'url'` saves the result to a temp file and returns its `file://` path.
-   * @returns A Promise resolving to `PixelData` when `outputType` is `'pixelData'` (default), or a `file://` URL string when `outputType` is `'url'`.
-   * @throws {RnExecutorchError} If the model is not loaded or is currently processing another image.
-   */
-  forward<O extends 'pixelData' | 'url' = 'pixelData'>(
-    input: string | PixelData,
-    outputType?: O
-  ): Promise<O extends 'url' ? string : PixelData>;
-
-  /**
-   * Synchronous worklet function for real-time VisionCamera frame processing.
-   * Automatically handles native buffer extraction and cleanup.
-   *
-   * **Use this for VisionCamera frame processing in worklets.**
-   * For async processing, use `forward()` instead.
-   *
-   * Available after model is loaded (`isReady: true`).
-   * @param frame - VisionCamera Frame object
-   * @param isFrontCamera - Whether the front camera is active, used for mirroring corrections.
-   * @returns PixelData containing the stylized frame as raw RGB pixel data.
-   */
-  runOnFrame: ((frame: Frame, isFrontCamera: boolean) => PixelData) | null;
-}
diff --git a/packages/react-native-executorch/src/types/textEmbeddings.ts b/packages/react-native-executorch/src/types/textEmbeddings.ts
deleted file mode 100644
index d9cd120e26..0000000000
--- a/packages/react-native-executorch/src/types/textEmbeddings.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-import { RnExecutorchError } from '../errors/errorUtils';
-import { ResourceSource } from '../types/common';
-
-/**
- * Union of all built-in text embeddings model names.
- * @category Types
- */
-export type TextEmbeddingsModelName =
-  | 'all-minilm-l6-v2'
-  | 'all-mpnet-base-v2'
-  | 'multi-qa-minilm-l6-cos-v1'
-  | 'multi-qa-mpnet-base-dot-v1'
-  | 'distiluse-base-multilingual-cased-v2-8da4w'
-  | 'paraphrase-multilingual-minilm-l12-v2-quantized'
-  | 'clip-vit-base-patch32-text';
-
-/**
- * Props for the useTextEmbeddings hook.
- * @category Types
- * @property {object} model - An object containing the model configuration.
- * @property {TextEmbeddingsModelName} model.modelName - Unique name identifying the model.
- * @property {ResourceSource} model.modelSource - The source of the text embeddings model binary.
- * @property {ResourceSource} model.tokenizerSource - The source of the tokenizer JSON file.
- * @property {boolean} [preventLoad] - Boolean that can prevent automatic model loading (and downloading the data if you load it for the first time) after running the hook.
- */
-export interface TextEmbeddingsProps {
-  model: {
-    /**
-     * The unique name of the text embeddings model.
-     */
-    modelName: TextEmbeddingsModelName;
-    /**
-     * The source of the text embeddings model binary.
-     */
-    modelSource: ResourceSource;
-    /**
-     * The source of the tokenizer JSON file.
-     */
-    tokenizerSource: ResourceSource;
-  };
-  preventLoad?: boolean;
-}
-
-/**
- * React hook state and methods for managing a Text Embeddings model instance.
- * @category Types
- */
-export interface TextEmbeddingsType {
-  /**
-   * Contains the error message if the model failed to load or during inference.
-   */
-  error: null | RnExecutorchError;
-
-  /**
-   * Indicates whether the embeddings model has successfully loaded and is ready for inference.
-   */
-  isReady: boolean;
-
-  /**
-   * Indicates whether the model is currently generating embeddings.
-   */
-  isGenerating: boolean;
-
-  /**
-   * Tracks the progress of the model download process (value between 0 and 1).
-   */
-  downloadProgress: number;
-
-  /**
-   * Runs the text embeddings model on the provided input string.
-   * @param input - The text string to embed.
-   * @returns A promise resolving to a Float32Array containing the vector embeddings.
-   * @throws {RnExecutorchError} If the model is not loaded or is currently processing another request.
-   */
-  forward(input: string): Promise<Float32Array>;
-}
diff --git a/packages/react-native-executorch/src/types/tokenizer.ts b/packages/react-native-executorch/src/types/tokenizer.ts
deleted file mode 100644
index dba7d61e77..0000000000
--- a/packages/react-native-executorch/src/types/tokenizer.ts
+++ /dev/null
@@ -1,84 +0,0 @@
-import { RnExecutorchError } from '../errors/errorUtils';
-import { ResourceSource } from './common';
-
-/**
- * Parameters for initializing and configuring a Tokenizer instance.
- * @category Types
- */
-export interface TokenizerProps {
-  /**
-   * Object containing:
-   *
-   * `tokenizerSource` - A `ResourceSource` that specifies the location of the tokenizer.
-   */
-  tokenizer: { tokenizerSource: ResourceSource };
-
-  /**
-   * Boolean that can prevent automatic model loading (and downloading the data if you load it for the first time) after running the hook.
-   */
-  preventLoad?: boolean;
-}
-
-/**
- * React hook state and methods for managing a Tokenizer instance.
- * @category Types
- */
-export interface TokenizerType {
-  /**
-   * Contains the error message if the tokenizer failed to load or during processing.
-   */
-  error: null | RnExecutorchError;
-
-  /**
-   * Indicates whether the tokenizer has successfully loaded and is ready for use.
-   */
-  isReady: boolean;
-
-  /**
-   * Indicates whether the tokenizer is currently processing data.
-   */
-  isGenerating: boolean;
-
-  /**
-   * Tracks the progress of the tokenizer download process (value between 0 and 1).
-   */
-  downloadProgress: number;
-
-  /**
-   * Converts an array of token IDs into a string.
-   * @param tokens - An array or `number[]` of token IDs to decode.
-   * @param skipSpecialTokens - Optional boolean to indicate whether special tokens should be skipped during decoding.
-   * @returns A promise resolving to the decoded text string.
-   */
-  decode(
-    tokens: number[],
-    skipSpecialTokens: boolean | undefined
-  ): Promise<string>;
-
-  /**
-   * Converts a string into an array of token IDs.
-   * @param text - The input text string to tokenize.
-   * @returns A promise resolving to an array `number[]` containing the encoded token IDs.
-   */
-  encode(text: string): Promise<number[]>;
-
-  /**
-   * Returns the size of the tokenizer's vocabulary.
-   * @returns A promise resolving to the vocabulary size.
-   */
-  getVocabSize(): Promise<number>;
-
-  /**
-   * Returns the token associated to the ID.
-   * @param id - The numeric token ID.
-   * @returns A promise resolving to the token string representation.
-   */
-  idToToken(id: number): Promise<string>;
-
-  /**
-   * Returns the ID associated to the token.
-   * @param token - The token string.
-   * @returns A promise resolving to the token ID.
-   */
-  tokenToId(token: string): Promise<number>;
-}
diff --git a/packages/react-native-executorch/src/types/tti.ts b/packages/react-native-executorch/src/types/tti.ts
deleted file mode 100644
index 91f0f2dc55..0000000000
--- a/packages/react-native-executorch/src/types/tti.ts
+++ /dev/null
@@ -1,98 +0,0 @@
-import { RnExecutorchError } from '../errors/errorUtils';
-import { ResourceSource } from '../types/common';
-
-/**
- * Union of all built-in Text-to-Image model names.
- * @category Types
- */
-export type TextToImageModelName =
-  | 'bk-sdm-tiny-vpred-512'
-  | 'bk-sdm-tiny-vpred-256';
-
-/**
- * Configuration properties for the `useTextToImage` hook.
- * @category Types
- */
-export interface TextToImageProps {
-  /**
-   * Object containing the required model sources for the diffusion pipeline.
-   */
-  model: {
-    /**
-     * The built-in model name (e.g. `'bk-sdm-tiny-vpred-512'`). Used for telemetry and hook reload triggers.
-     * Pass one of the pre-built TTI constants (e.g. `BK_SDM_TINY_VPRED_512`) to populate all required fields.
-     */
-    modelName: TextToImageModelName;
-    /** Source for the text tokenizer binary/config. */
-    tokenizerSource: ResourceSource;
-    /** Source for the diffusion scheduler binary/config. */
-    schedulerSource: ResourceSource;
-    /** Source for the text encoder model binary. */
-    encoderSource: ResourceSource;
-    /** Source for the UNet (noise predictor) model binary. */
-    unetSource: ResourceSource;
-    /** Source for the VAE decoder model binary, used to decode the final image. */
-    decoderSource: ResourceSource;
-  };
-
-  /**
-   * Optional callback function that is triggered after each diffusion inference step.
-   * Useful for updating a progress bar during image generation.
-   * @param stepIdx - The index of the current inference step.
-   */
-  inferenceCallback?: (stepIdx: number) => void;
-
-  /**
-   * Boolean that can prevent automatic model loading (and downloading the data if loaded for the first time) after running the hook.
-   * Defaults to `false`.
-   */
-  preventLoad?: boolean;
-}
-
-/**
- * Return type for the `useTextToImage` hook.
- * Manages the state and operations for generating images from text prompts using a diffusion model pipeline.
- * @category Types
- */
-export interface TextToImageType {
-  /**
-   * Contains the error object if any of the pipeline models failed to load, download, or encountered a runtime error.
-   */
-  error: RnExecutorchError | null;
-
-  /**
-   * Indicates whether the entire diffusion pipeline is loaded into memory and ready for generation.
-   */
-  isReady: boolean;
-
-  /**
-   * Indicates whether the model is currently generating an image.
-   */
-  isGenerating: boolean;
-
-  /**
-   * Represents the total download progress of all the model binaries combined, as a value between 0 and 1.
-   */
-  downloadProgress: number;
-
-  /**
-   * Runs the diffusion pipeline to generate an image from the provided text prompt.
-   * @param input - The text prompt describing the desired image.
-   * @param [imageSize] - Optional. The target width and height of the generated image (e.g., 512 for 512x512). Defaults to the model's standard size if omitted.
-   * @param [numSteps] - Optional. The number of denoising steps for the diffusion process. More steps generally yield higher quality at the cost of generation time.
-   * @param [seed] - Optional. A random seed for reproducible generation. Should be a positive integer.
-   * @returns A Promise that resolves to a `file://` URI pointing to the generated PNG on the device, or an empty string if generation was interrupted.
-   * @throws {RnExecutorchError} If the model is not loaded or is currently generating another image.
-   */
-  generate: (
-    input: string,
-    imageSize?: number,
-    numSteps?: number,
-    seed?: number
-  ) => Promise<string>;
-
-  /**
-   * Interrupts the currently active image generation process at the next available inference step.
-   */
-  interrupt: () => void;
-}
diff --git a/packages/react-native-executorch/src/types/tts.ts b/packages/react-native-executorch/src/types/tts.ts
deleted file mode 100644
index 811d7d27c2..0000000000
--- a/packages/react-native-executorch/src/types/tts.ts
+++ /dev/null
@@ -1,201 +0,0 @@
-import { ResourceSource } from './common';
-import { RnExecutorchError } from '../errors/errorUtils';
-
-/**
- * Per-model config for {@link TextToSpeechModule.fromModelName}.
- * Each model name maps to its required fields.
- * @category Types
- */
-export type TextToSpeechModelSources = {
-  modelName: 'kokoro';
-  durationPredictorSource: ResourceSource;
-  synthesizerSource: ResourceSource;
-};
-
-/**
- * Union of all built-in Text to Speech model names.
- * @category Types
- */
-export type TextToSpeechModelName = TextToSpeechModelSources['modelName'];
-
-/**
- * List all the languages available in TTS models (as lang shorthands)
- * @category Types
- */
-export type TextToSpeechLanguage =
-  | 'en-us' // American English
-  | 'en-gb' // British English
-  | 'fr' // French
-  | 'es' // Spanish
-  | 'it' // Italian
-  | 'pt' // Portuguese
-  | 'de' // German
-  | 'pl' // Polish
-  | 'hi'; // Hindi
-
-/**
- * Configuration for the Phonemizer used in Text-to-Speech models.
- * Phonemization is the process of converting text into phonetic representations.
- * @category Types
- */
-export interface TextToSpeechPhonemizerConfig {
-  /**
-   * The language code for phonemization (e.g., 'en-us').
-   */
-  lang: TextToSpeechLanguage;
-
-  /**
-   * Optional resource for the part-of-speech tagger.
-   * Utilized by more challenging languages, such as english.
-   */
-  taggerSource?: ResourceSource;
-
-  /**
-   * Optional resource for the pronunciation lexicon.
-   * If provided, it wil be a primary phonemization mechanism.
-   */
-  lexiconSource?: ResourceSource;
-
-  /**
-   * Optional neural model resource for Grapheme-to-Phoneme conversion.
-   * Serves as a fallback for lexicon or a primary phonemization mechanism if lexicon
-   * is not defined.
-   */
-  neuralModelSource?: ResourceSource;
-}
-
-/**
- * Configuration for a specific model and voice in a Text-to-Speech module.
- * @category Types
- * @property {TextToSpeechModelSources} model - The model sources and identifiers.
- * @property {ResourceSource} voiceSource - The resource containing the voice-specific tensor stored in a binary format.
- * @property {TextToSpeechPhonemizerConfig} phonemizerConfig - The phonemizer configuration to be used with this voice.
- */
-export interface TextToSpeechModelConfig {
-  model: TextToSpeechModelSources;
-  voiceSource: ResourceSource;
-  phonemizerConfig: TextToSpeechPhonemizerConfig;
-}
-
-/**
- * Text to Speech module input definition
- * @category Types
- * @property {string} text - a text to be spoken
- * @property {number} [speed] - optional speed argument - the higher it is, the faster the speech becomes
- * @property {boolean} [phonemize] - if true (default), the input is treated as text and converted to phonemes.
- *                                   If false, the input should already be in IPA phonemes.
- */
-export interface TextToSpeechInput {
-  text?: string;
-  speed?: number;
-  phonemize?: boolean;
-}
-
-/**
- * Return type for the `useTextToSpeech` hook.
- * Manages the state and operations for Text-to-Speech generation.
- * @category Types
- */
-export interface TextToSpeechType {
-  /**
-   * Contains the error object if the model failed to load or encountered an error during inference.
-   */
-  error: RnExecutorchError | null;
-
-  /**
-   * Indicates whether the Text-to-Speech model is loaded and ready to accept inputs.
-   */
-  isReady: boolean;
-
-  /**
-   * Indicates whether the model is currently generating audio.
-   */
-  isGenerating: boolean;
-
-  /**
-   * Represents the download progress of the model and voice assets as a value between 0 and 1.
-   */
-  downloadProgress: number;
-
-  /**
-   * Runs the model to convert the provided text into speech audio in a single pass.
-   * @param input - The `TextToSpeechInput` object containing the `text` to synthesize and optional `speed`.
-   * @returns A Promise that resolves with the generated audio data (typically a `Float32Array`).
-   * @throws {RnExecutorchError} If the model is not loaded or is currently generating.
-   */
-  forward: (input: TextToSpeechInput) => Promise<Float32Array>;
-
-  /**
-   * Streams the generated audio data incrementally.
-   * This is optimal for real-time playback, allowing audio to start playing before the full text is synthesized.
-   * @param input - The `TextToSpeechStreamingInput` object containing `text`, optional `speed`, and lifecycle callbacks (`onBegin`, `onNext`, `onEnd`).
-   * @returns A Promise that resolves when the streaming process is complete.
-   * @throws {RnExecutorchError} If the model is not loaded or is currently generating.
-   */
-  stream: (input: TextToSpeechStreamingInput) => Promise<void>;
-
-  /**
-   * Inserts a new text chunk into the buffer to be processed in streaming mode.
-   *
-   * Chunks accumulate until an end-of-sentence character (`.?!;…`) appears in
-   * the buffer, at which point they're partitioned and synthesized. If the
-   * caller stops feeding before an EOS arrives, the trailing tail will sit in
-   * the buffer until `streamFlush()` or `streamStop(false)` is called.
-   * @param textChunk - Text (or IPA phonemes) to append to the streaming buffer.
-   */
-  streamInsert: (textChunk: string) => void;
-
-  /**
-   * Requests the streaming session to partition and synthesize whatever is
-   * currently buffered, even if no end-of-sentence character is present.
-   *
-   * Call after the final `streamInsert` of an utterance when you want
-   * trailing un-terminated content to play out without ending the stream.
-   * LLM-style callers feeding partial tokens typically should not call this —
-   * model punctuation drives natural EOS partitioning, and the residual tail
-   * is drained by `streamStop(false)` when generation completes.
-   */
-  streamFlush: () => void;
-
-  /**
-   * Interrupts and stops the currently active audio generation stream.
-   * @param instant If true, stops the streaming as soon as possible. Otherwise
-   *                drains the current buffer (force-flushing any trailing
-   *                un-terminated content) before stopping — equivalent to
-   *                calling {@link TextToSpeechType.streamFlush} followed by an
-   *                automatic stop once the buffer empties, so this call
-   *                always returns.
-   */
-  streamStop: (instant?: boolean) => void;
-}
-
-/**
- * Shared streaming lifecycle callbacks for TTS streaming modes.
- * @category Types
- * @property {() => void | Promise<void>} [onBegin] - Called when streaming begins
- * @property {(audio: Float32Array) => void | Promise<void>} [onNext] - Called after each audio chunk gets calculated.
- * @property {() => void | Promise<void>} [onEnd] - Called when streaming ends
- */
-export interface TextToSpeechStreamingCallbacks {
-  onBegin?: () => void | Promise<void>;
-  onNext?: (audio: Float32Array) => void | Promise<void>;
-  onEnd?: () => void | Promise<void>;
-}
-
-/**
- * Text to Speech streaming input definition
- *
- * Streaming mode in T2S is synchronized by passing specific callbacks
- * executed at given moments of the streaming.
- * Actions such as playing the audio should happen within the onNext callback.
- * Callbacks can be both synchronous or asynchronous.
- *
- * Enables an incrementally expanded input, in other words adding
- * new text chunks with streamInsert() as the streaming is running.
- * @category Types
- * @property {boolean} [stopAutomatically] - If true, streaming will stop automatically when the buffer is empty.
- */
-export interface TextToSpeechStreamingInput
-  extends TextToSpeechInput, TextToSpeechStreamingCallbacks {
-  stopAutomatically?: boolean;
-}
diff --git a/packages/react-native-executorch/src/types/vad.ts b/packages/react-native-executorch/src/types/vad.ts
deleted file mode 100644
index a266a775da..0000000000
--- a/packages/react-native-executorch/src/types/vad.ts
+++ /dev/null
@@ -1,119 +0,0 @@
-import { ResourceSource } from '../types/common';
-import { RnExecutorchError } from '../errors/errorUtils';
-
-/**
- * Union of all built-in VAD model names.
- * @category Types
- */
-export type VADModelName = 'fsmn-vad';
-
-/**
- * Configuration for the VAD model.
- * @category Types
- * @property {VADModelName} modelName - Unique name identifying the model.
- * @property {ResourceSource} modelSource - The source of the VAD model binary.
- */
-export interface VADConfig {
-  modelName: VADModelName;
-  modelSource: ResourceSource;
-}
-
-/**
- * Props for the useVAD hook.
- * @category Types
- * @property {object} model - An object containing the model configuration.
- * @property {VADModelName} model.modelName - Unique name identifying the model.
- * @property {ResourceSource} model.modelSource - The source of the VAD model binary.
- * @property {boolean} [preventLoad] - Boolean that can prevent automatic model loading (and downloading the data if you load it for the first time) after running the hook.
- */
-export interface VADProps {
-  model: VADConfig;
-  preventLoad?: boolean;
-}
-
-/**
- * Represents a detected audio segment with start and end timestamps.
- * @category Types
- * @property {number} start - Start time of the segment in seconds.
- * @property {number} end - End time of the segment in seconds.
- */
-export interface Segment {
-  start: number;
-  end: number;
-}
-
-/**
- * Configuration options for the VAD streaming process.
- * @category Types
- * @property {number} [timeout] - Specifies (in milliseconds) how much does streamer wait between model inferences.
- * @property {number} [detectionMargin] - Specifies (in milliseconds) how far the last detected speech segment can be to still be considered as ongoing speech.
- */
-export interface VADStreamingOptions {
-  timeout?: number;
-  detectionMargin?: number;
-}
-
-/**
- * Input configuration for the VAD streaming hook.
- * @category Types
- * @property {() => void | Promise<void>} [onSpeechBegin] - Callback function triggered when speech is detected.
- * @property {() => void | Promise<void>} [onSpeechEnd] - Callback function triggered when speech end (silence is detected).
- * @property {VADStreamingOptions} [options] - Optional configuration for the streaming process.
- */
-export interface VADStreamingInput {
-  onSpeechBegin?: () => void | Promise<void>;
-  onSpeechEnd?: () => void | Promise<void>;
-  options?: VADStreamingOptions;
-}
-
-/**
- * React hook state and methods for managing a Voice Activity Detection (VAD) model instance.
- * @category Types
- */
-export interface VADType {
-  /**
-   * Contains the error message if the VAD model failed to load or during processing.
-   */
-  error: null | RnExecutorchError;
-
-  /**
-   * Indicates whether the VAD model has successfully loaded and is ready for inference.
-   */
-  isReady: boolean;
-
-  /**
-   * Indicates whether the model is currently processing an inference.
-   */
-  isGenerating: boolean;
-
-  /**
-   * Represents the download progress as a value between 0 and 1.
-   */
-  downloadProgress: number;
-
-  /**
-   * Runs the Voice Activity Detection model on the provided audio waveform.
-   * @param waveform - The input audio waveform array.
-   * @returns A promise resolving to an array of detected audio segments (e.g., timestamps for speech).
-   * @throws {RnExecutorchError} If the model is not loaded or is currently processing another request.
-   */
-  forward(waveform: Float32Array): Promise<Segment[]>;
-
-  /**
-   * Starts a streaming Voice Activity Detection session.
-   * @param input - Configuration for streaming, including callbacks for speech begin/end and optional parameters.
-   * @returns A promise that resolves when the streaming session stops.
-   */
-  stream(input: VADStreamingInput): Promise<void>;
-
-  /**
-   * Inserts an audio chunk into the streaming VAD session.
-   * @param waveform - The audio data to add to the buffer.
-   */
-  streamInsert(waveform: Float32Array): void;
-
-  /**
-   * Stops the current streaming VAD session.
-   */
-  streamStop(): void;
-}
diff --git a/packages/react-native-executorch/src/utils.ts b/packages/react-native-executorch/src/utils.ts
new file mode 100644
index 0000000000..e954b70cf8
--- /dev/null
+++ b/packages/react-native-executorch/src/utils.ts
@@ -0,0 +1,5 @@
+import { rnexecutorchJsi } from './native/bridge';
+
+export function getRegisteredBackends(): string[] {
+  return rnexecutorchJsi.getExecuTorchRegisteredBackends();
+}
diff --git a/packages/react-native-executorch/src/utils/BaseResourceFetcherClass.ts b/packages/react-native-executorch/src/utils/BaseResourceFetcherClass.ts
deleted file mode 100644
index ac9174b4e9..0000000000
--- a/packages/react-native-executorch/src/utils/BaseResourceFetcherClass.ts
+++ /dev/null
@@ -1,230 +0,0 @@
-import { ResourceSource } from '../types/common';
-import { ResourceFetcherAdapter } from './ResourceFetcher';
-import { ResourceFetcherUtils, SourceType } from './ResourceFetcherUtils';
-import { RnExecutorchError } from '../errors/errorUtils';
-import { RnExecutorchErrorCode } from '../errors/ErrorCodes';
-
-interface FileSizeInfo {
-  source: ResourceSource;
-  type: SourceType;
-  length: number;
-  previousFilesTotalLength: number;
-}
-
-interface FilesSizesResult {
-  results: FileSizeInfo[];
-  totalLength: number;
-}
-
-/**
- * Abstract base class for resource fetcher implementations.
- *
- * Contains the shared fetch loop, source dispatching, and pause/resume/cancel
- * plumbing. Concrete subclasses (expo, bare) implement the platform-specific
- * file system operations and download mechanics.
- * @typeParam TDownload - The platform-specific active download descriptor type.
- */
-export abstract class BaseResourceFetcherClass<
-  TDownload,
-> implements ResourceFetcherAdapter {
-  /**
-   * Map of currently active (downloading or paused) remote downloads.
-   * Keyed by the original source value the user passed in so that
-   * `pauseFetching`/`cancelFetching` can look up the entry using that same value.
-   * Entries are added when a download starts and removed when it completes,
-   * is canceled, or errors.
-   */
-  protected abstract downloads: Map<ResourceSource, TDownload>;
-
-  /**
-   * Fire HEAD requests for all remote sources to collect their file sizes.
-   * Used by `fetch()` to calculate unified 0→1 progress across all downloads.
-   * Non-remote sources (objects, local files, assets) should be included in
-   * the results with `length: 0`.
-   */
-  protected abstract getFilesSizes(
-    sources: ResourceSource[]
-  ): Promise<FilesSizesResult>;
-
-  /**
-   * Serialize `source` as JSON, write it to `RNEDirectory`, and return the
-   * local path. Should be idempotent — if the file already exists, return its
-   * path without rewriting.
-   */
-  protected abstract handleObject(source: object): Promise<string>;
-
-  /**
-   * Strip the `file://` prefix from a local file URI and return the bare path.
-   * No I/O required — this is a pure string transformation.
-   */
-  protected abstract handleLocalFile(source: string): string;
-
-  /**
-   * Handle a bundled asset (a `require()` number).
-   * - **Dev mode** (Metro serves the asset over HTTP): resolve the URI and
-   *   delegate to `handleRemote`.
-   * - **Release mode** (asset is bundled locally): copy it to `RNEDirectory`
-   *   and return the local path.
-   * Must be idempotent — if the destination file already exists, skip the copy.
-   */
-  protected abstract handleAsset(
-    source: number,
-    progressCallback: (progress: number) => void
-  ): Promise<string>;
-
-  /**
-   * Download a remote file to `RNEDirectory` and return the local path.
-   * Must be idempotent — if the file is already present, return its path
-   * without re-downloading.
-   *
-   * `uri` and `source` are separate parameters because for asset dev-mode
-   * sources, `source` is the `require()` number the user holds (used as the
-   * `downloads` map key for pause/cancel), while `uri` is the resolved HTTP
-   * URL needed for the actual network request. For plain remote strings they
-   * are the same value.
-   *
-   * Returns `null` if the download was interrupted by `cancel()`.
-   * @remarks
-   * The returned Promise must be resolvable from outside this function —
-   * `cancel()` and `resume()` need to unblock the `fetch()` loop by calling
-   * `resolve`/`reject` stored on the `downloads` map entry. See handlers.ts
-   * for the leaked-resolver pattern used to achieve this.
-   */
-  protected abstract handleRemote(
-    uri: string,
-    source: ResourceSource,
-    progressCallback: (progress: number) => void
-  ): Promise<{ path: string; wasDownloaded: boolean }>;
-
-  /**
-   * Pause the active download for `source`. Should throw
-   * `ResourceFetcherAlreadyPaused` if already paused, and
-   * `ResourceFetcherPlatformNotSupported` if the platform does not support
-   * pausing (e.g. Android in the bare implementation).
-   */
-  protected abstract pause(source: ResourceSource): Promise<void>;
-
-  /**
-   * Resume a paused download for `source`. The result must flow back through
-   * the original `fetch()` promise — call `resolve(path)` on the `downloads`
-   * map entry rather than creating a new Promise. Should throw
-   * `ResourceFetcherAlreadyOngoing` if the download is not paused, and
-   * `ResourceFetcherPlatformNotSupported` if the platform does not support
-   * resuming.
-   */
-  protected abstract resume(source: ResourceSource): Promise<void>;
-
-  /**
-   * Cancel an active or paused download for `source`. Must:
-   * 1. Abort the in-progress network request.
-   * 2. Clean up any partial files from the cache directory.
-   * 3. Delete the entry from `downloads`.
-   * 4. Call `reject(new RnExecutorchError(DownloadInterrupted, ...))` on the entry to unblock the `fetch()` loop.
-   */
-  protected abstract cancel(source: ResourceSource): Promise<void>;
-
-  /**
-   * Read a local file and return its contents as a UTF-8 string.
-   * Used internally to read config files (e.g. tokenizer JSON).
-   */
-  abstract readAsString(path: string): Promise<string>;
-
-  /**
-   * List all files previously downloaded into `RNEDirectory`.
-   * Returns absolute file paths (no `file://` prefix).
-   */
-  abstract listDownloadedFiles(): Promise<string[]>;
-
-  /**
-   * Delete the local files corresponding to the given sources from
-   * `RNEDirectory`. Should be a no-op for sources whose file does not exist.
-   */
-  abstract deleteResources(...sources: ResourceSource[]): Promise<void>;
-
-  /**
-   * Fire HEAD requests for the given remote URLs and return their combined
-   * size in bytes. Non-remote sources should contribute 0 bytes.
-   */
-  abstract getFilesTotalSize(...sources: ResourceSource[]): Promise<number>;
-
-  async fetch(
-    callback: (downloadProgress: number) => void = () => {},
-    ...sources: ResourceSource[]
-  ): Promise<{ paths: string[]; wasDownloaded: boolean[] }> {
-    if (sources.length === 0) {
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.InvalidUserInput,
-        'Empty list given as an argument to Resource Fetcher'
-      );
-    }
-
-    const { results: info, totalLength } = await this.getFilesSizes(sources);
-    // Key by source so we can look up progress info without relying on index
-    // alignment (getFilesSizes skips sources whose HEAD request fails).
-    const infoMap = new Map(info.map((entry) => [entry.source, entry]));
-    const paths: string[] = [];
-    const wasDownloaded: boolean[] = [];
-
-    for (const source of sources) {
-      const fileInfo = infoMap.get(source);
-      const progressCallback =
-        fileInfo?.type === SourceType.REMOTE_FILE
-          ? ResourceFetcherUtils.calculateDownloadProgress(
-              totalLength,
-              fileInfo.previousFilesTotalLength,
-              fileInfo.length,
-              callback
-            )
-          : () => {};
-
-      const result = await this.fetchOne(source, progressCallback);
-      paths.push(result.path);
-      wasDownloaded.push(result.wasDownloaded);
-    }
-
-    return { paths, wasDownloaded };
-  }
-
-  private async fetchOne(
-    source: ResourceSource,
-    progressCallback: (progress: number) => void
-  ): Promise<{ path: string; wasDownloaded: boolean }> {
-    if (typeof source === 'object')
-      return { path: await this.handleObject(source), wasDownloaded: false };
-    if (typeof source === 'number')
-      return {
-        path: await this.handleAsset(source, progressCallback),
-        wasDownloaded: false,
-      };
-    if (source.startsWith('file://'))
-      return { path: this.handleLocalFile(source), wasDownloaded: false };
-    return this.handleRemote(source, source, progressCallback);
-  }
-
-  async listDownloadedModels(): Promise<string[]> {
-    const files = await this.listDownloadedFiles();
-    return files.filter((f) => f.endsWith('.pte'));
-  }
-
-  async pauseFetching(...sources: ResourceSource[]): Promise<void> {
-    await this.pause(this.findActive(sources));
-  }
-
-  async resumeFetching(...sources: ResourceSource[]): Promise<void> {
-    await this.resume(this.findActive(sources));
-  }
-
-  async cancelFetching(...sources: ResourceSource[]): Promise<void> {
-    await this.cancel(this.findActive(sources));
-  }
-
-  protected findActive(sources: ResourceSource[]): ResourceSource {
-    for (const source of sources) {
-      if (this.downloads.has(source)) return source;
-    }
-    throw new RnExecutorchError(
-      RnExecutorchErrorCode.ResourceFetcherNotActive,
-      'None of given sources are currently during downloading process.'
-    );
-  }
-}
diff --git a/packages/react-native-executorch/src/utils/ResourceFetcher.ts b/packages/react-native-executorch/src/utils/ResourceFetcher.ts
deleted file mode 100644
index 7b31f65584..0000000000
--- a/packages/react-native-executorch/src/utils/ResourceFetcher.ts
+++ /dev/null
@@ -1,145 +0,0 @@
-import { ResourceSource } from '../types/common';
-import { RnExecutorchError } from '../errors/errorUtils';
-import { RnExecutorchErrorCode } from '../errors/ErrorCodes';
-import { ResourceFetcherUtils } from './ResourceFetcherUtils';
-import { Logger } from '../common/Logger';
-import { getModelNameForUrl } from '../constants/modelUrls';
-
-/**
- * Adapter interface for resource fetching operations.
- * **Required Methods:**
- * - `fetch`: Download resources to local storage (used by all modules)
- * - `readAsString`: Read file contents as string (used for config files)
- * @category Utilities - General
- * @remarks
- * This interface is intentionally minimal. Custom fetchers only need to implement
- * these two methods for the library to function correctly.
- */
-export interface ResourceFetcherAdapter {
-  /**
-   * Fetches resources (remote URLs, local files or embedded assets), downloads or stores them locally for use by React Native ExecuTorch.
-   * @param callback - Optional callback to track progress of all downloads, reported between 0 and 1.
-   * @param sources - Multiple resources that can be strings, asset references, or objects.
-   * @returns If the fetch was successful, it returns a promise which resolves to an array of local file paths for the downloaded/stored resources (without file:// prefix).
-   * If the fetch was interrupted, it returns a promise which resolves to `null`.
-   * @remarks
-   * **REQUIRED**: Used by all library modules for downloading models and resources.
-   */
-  fetch(
-    callback: (downloadProgress: number) => void,
-    ...sources: ResourceSource[]
-  ): Promise<{ paths: string[]; wasDownloaded: boolean[] }>;
-
-  /**
-   * Read file contents as a string.
-   * @param path - Absolute file path
-   * @returns File contents as string
-   * @remarks
-   * **REQUIRED**: Used internally for reading configuration files (e.g., tokenizer configs).
-   */
-  readAsString(path: string): Promise<string>;
-}
-
-/**
- * Static entry point that delegates resource operations to the configured
- * `ResourceFetcherAdapter` (registered via `initExecutorch({ resourceFetcher })`).
- *
- * For storage-management utilities — deleting downloaded models, listing
- * downloaded files, getting their total size, and pausing/resuming/cancelling
- * downloads — use the adapter implementation directly. See `ExpoResourceFetcher`
- * (in `react-native-executorch-expo-resource-fetcher`) or `BareResourceFetcher`
- * (in `react-native-executorch-bare-resource-fetcher`).
- * @category Utilities - General
- */
-export class ResourceFetcher {
-  private static adapter: ResourceFetcherAdapter | null = null;
-
-  /**
-   * Sets a custom resource fetcher adapter for resource operations.
-   * @param adapter - The adapter instance to use for fetching resources.
-   * @remarks
-   * **INTERNAL**: Used by platform-specific init functions (expo/bare) to inject their fetcher implementation.
-   */
-  static setAdapter(adapter: ResourceFetcherAdapter) {
-    this.adapter = adapter;
-  }
-
-  /**
-   * Resets the resource fetcher adapter to null.
-   * @remarks
-   * **INTERNAL**: Used primarily for testing purposes to clear the adapter state.
-   */
-  static resetAdapter() {
-    this.adapter = null;
-  }
-
-  /**
-   * Gets the current resource fetcher adapter instance.
-   * @returns The configured ResourceFetcherAdapter instance.
-   * @throws {RnExecutorchError} If no adapter has been set via {@link setAdapter}.
-   * @remarks
-   * **INTERNAL**: Used internally by all resource fetching operations.
-   */
-  static getAdapter(): ResourceFetcherAdapter {
-    if (!this.adapter) {
-      const errorMessage =
-        'ResourceFetcher adapter is not initialized. Please call initExecutorch({ resourceFetcher: ... }) with a valid adapter, e.g., from react-native-executorch-expo-resource-fetcher or react-native-executorch-bare-resource-fetcher. For more details please refer to: https://docs.swmansion.com/react-native-executorch/docs/next/fundamentals/loading-models';
-      // for sanity :)
-      Logger.error(errorMessage);
-      throw new RnExecutorchError(
-        RnExecutorchErrorCode.ResourceFetcherAdapterNotInitialized,
-        errorMessage
-      );
-    }
-    return this.adapter;
-  }
-
-  /**
-   * Fetches resources (remote URLs, local files or embedded assets), downloads or stores them locally for use by React Native ExecuTorch.
-   * @param callback - Optional callback to track progress of all downloads, reported between 0 and 1.
-   * @param sources - Multiple resources that can be strings, asset references, or objects.
-   * @returns If the fetch was successful, it returns a promise which resolves to an array of local file paths for the downloaded/stored resources (without file:// prefix).
-   * If the fetch was interrupted, it returns a promise which resolves to `null`.
-   */
-  static async fetch(
-    callback: (downloadProgress: number) => void = () => {},
-    ...sources: ResourceSource[]
-  ): Promise<string[]> {
-    const { paths, wasDownloaded } = await this.getAdapter().fetch(
-      callback,
-      ...sources
-    );
-    const triggeredModels = new Set<string>();
-    for (let i = 0; i < sources.length; i++) {
-      if (typeof sources[i] === 'string' && wasDownloaded[i]) {
-        const source = sources[i] as string;
-        const modelName = getModelNameForUrl(source);
-        if (modelName && !triggeredModels.has(modelName)) {
-          triggeredModels.add(modelName);
-          ResourceFetcherUtils.triggerDownloadEvent(source);
-          ResourceFetcherUtils.triggerHuggingFaceDownloadCounter(source);
-        }
-      }
-    }
-    return paths;
-  }
-
-  /**
-   * Filesystem utilities for reading downloaded resources.
-   * @remarks
-   * Provides access to filesystem operations through the configured adapter.
-   * Currently supports reading file contents as strings for configuration files.
-   */
-  static fs = {
-    /**
-     * Reads the contents of a file as a string.
-     * @param path - Absolute file path to read.
-     * @returns A promise that resolves to the file contents as a string.
-     * @remarks
-     * **REQUIRED**: Used internally for reading configuration files (e.g., tokenizer configs).
-     */
-    readAsString: async (path: string) => {
-      return this.getAdapter().readAsString(path);
-    },
-  };
-}
diff --git a/packages/react-native-executorch/src/utils/ResourceFetcherUtils.ts b/packages/react-native-executorch/src/utils/ResourceFetcherUtils.ts
deleted file mode 100644
index 46f4b34e2d..0000000000
--- a/packages/react-native-executorch/src/utils/ResourceFetcherUtils.ts
+++ /dev/null
@@ -1,216 +0,0 @@
-import { getModelNameForUrl } from '../constants/modelUrls';
-import {
-  DOWNLOAD_EVENT_ENDPOINT,
-  LIB_VERSION,
-} from '../constants/resourceFetcher';
-/**
- * Http status codes
- * @category Types
- */
-export enum HTTP_CODE {
-  /**
-    Everything is ok.
-   */
-  OK = 200,
-
-  /**
-    Server has fulfilled a client request for a specific part of a resource, instead of sending the entire file.
-   */
-  PARTIAL_CONTENT = 206,
-}
-
-/**
- * Download status of the file.
- * @category Types
- */
-export enum DownloadStatus {
-  /**
-   * Download is still in progress.
-   */
-  ONGOING,
-
-  /**
-   * Download is paused.
-   */
-  PAUSED,
-}
-
-/**
- * Types of sources that can be downloaded
- * @category Types
- */
-export enum SourceType {
-  /**
-   * Represents a raw object or data structure.
-   */
-  OBJECT,
-
-  /**
-   * Represents a file stored locally on the filesystem.
-   */
-  LOCAL_FILE,
-
-  /**
-   * Represents a file bundled with the application in release mode.
-   */
-  RELEASE_MODE_FILE,
-
-  /**
-   * Represents a file served via the metro bundler during development.
-   */
-  DEV_MODE_FILE,
-
-  /**
-   * Represents a file located at a remote URL.
-   */
-  REMOTE_FILE,
-}
-
-/**
- * Utility functions for fetching and managing resources.
- * @category Utilities - General
- */
-export namespace ResourceFetcherUtils {
-  /**
-   * Removes the 'file://' prefix from a URI if it exists.
-   * @param uri - The URI to process.
-   * @returns The URI without the 'file://' prefix.
-   */
-  export function removeFilePrefix(uri: string) {
-    return uri.startsWith('file://') ? uri.slice(7) : uri;
-  }
-
-  /**
-   * Generates a hash from a string representation of an object.
-   * @param jsonString - The stringified JSON object to hash.
-   * @returns The resulting hash as a string.
-   */
-  export function hashObject(jsonString: string) {
-    let hash = 0;
-    for (let i = 0; i < jsonString.length; i++) {
-      // eslint-disable-next-line no-bitwise
-      hash = (hash << 5) - hash + jsonString.charCodeAt(i);
-      // eslint-disable-next-line no-bitwise
-      hash |= 0;
-    }
-    // eslint-disable-next-line no-bitwise
-    return (hash >>> 0).toString();
-  }
-
-  /**
-   * Creates a progress callback that scales the current file's progress
-   * relative to the total size of all files being downloaded.
-   * @param totalLength - The total size of all files in the download batch.
-   * @param previousFilesTotalLength - The sum of sizes of files already downloaded.
-   * @param currentFileLength - The size of the file currently being downloaded.
-   * @param setProgress - The main callback to update the global progress.
-   * @returns A function that accepts the progress (0-1) of the current file.
-   */
-  export function calculateDownloadProgress(
-    totalLength: number,
-    previousFilesTotalLength: number,
-    currentFileLength: number,
-    setProgress: (downloadProgress: number) => void
-  ) {
-    return (progress: number) => {
-      if (
-        progress === 1 &&
-        previousFilesTotalLength === totalLength - currentFileLength
-      ) {
-        setProgress(1);
-        return;
-      }
-
-      // Avoid division by zero
-      if (totalLength === 0) {
-        setProgress(0);
-        return;
-      }
-
-      const baseProgress = previousFilesTotalLength / totalLength;
-      const scaledProgress = progress * (currentFileLength / totalLength);
-      const updatedProgress = baseProgress + scaledProgress;
-      setProgress(updatedProgress);
-    };
-  }
-
-  /**
-   * Increments the Hugging Face download counter if the URI points to a Software Mansion Hugging Face repo.
-   * More information: https://huggingface.co/docs/hub/models-download-stats
-   * @param uri - The URI of the file being downloaded.
-   */
-  export async function triggerHuggingFaceDownloadCounter(uri: string) {
-    const url = new URL(uri);
-    if (isUrlHfRepo(url)) {
-      const baseUrl = `${url.protocol}//${url.host}${url.pathname.split('resolve')[0]}`;
-      fetch(`${baseUrl}resolve/main/config.json`, { method: 'HEAD' });
-    }
-  }
-
-  /**
-   * Checks whether the given URL conforms to the huggingface.co/software-mansion schema.
-   * @param url - the URL to the remote file
-   * @returns Boolean specifying whether the given URL conforms to our HF repo schema
-   */
-  export function isUrlHfRepo(url: URL): boolean {
-    return (
-      url.host === 'huggingface.co' &&
-      url.pathname.startsWith('/software-mansion')
-    );
-  }
-
-  function getCountryCode(): string {
-    try {
-      const locale = Intl.DateTimeFormat().resolvedOptions().locale;
-      const regionTag = locale.split('-').pop();
-      if (regionTag && regionTag.length === 2) {
-        return regionTag.toUpperCase();
-      }
-    } catch {}
-    return 'UNKNOWN';
-  }
-
-  export function isEmulator(): boolean {
-    return global.__rne_isEmulator;
-  }
-
-  function getModelNameFromUri(uri: string): string {
-    const knownName = getModelNameForUrl(uri);
-    if (knownName) {
-      return knownName;
-    }
-    const pathname = new URL(uri).pathname;
-    const filename = pathname.split('/').pop() ?? uri;
-    return filename.replace(/\.[^.]+$/, '');
-  }
-
-  /**
-   * Sends a download event to the analytics endpoint.
-   * @param uri - The URI of the downloaded resource.
-   */
-  export function triggerDownloadEvent(uri: string) {
-    try {
-      fetch(DOWNLOAD_EVENT_ENDPOINT, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          modelName: getModelNameFromUri(uri),
-          countryCode: getCountryCode(),
-          isEmulator: isEmulator(),
-          libVersion: LIB_VERSION,
-        }),
-      });
-    } catch (e) {}
-  }
-
-  /**
-   * Generates a safe filename from a URI by removing the protocol and replacing special characters.
-   * @param uri - The source URI.
-   * @returns A sanitized filename string.
-   */
-  export function getFilenameFromUri(uri: string) {
-    let cleanUri = uri.replace(/^https?:\/\//, '');
-    cleanUri = cleanUri.split('#')?.[0] ?? cleanUri;
-    return cleanUri.replace(/[^a-zA-Z0-9._-]/g, '_');
-  }
-}
diff --git a/packages/react-native-executorch/src/utils/commonVision.ts b/packages/react-native-executorch/src/utils/commonVision.ts
deleted file mode 100644
index 7cd9b2a44b..0000000000
--- a/packages/react-native-executorch/src/utils/commonVision.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import { Bbox } from '../types/objectDetection';
-
-/**
- * Calculates the area of a bounding box.
- * @param bbox - Bounding box to calculate area for.
- * @returns Area of the bounding box.
- */
-export function bboxArea(bbox: Bbox): number {
-  return Math.max(bbox.x2 - bbox.x1, 0) * Math.max(bbox.y2 - bbox.y1, 0);
-}
diff --git a/packages/react-native-executorch/src/utils/labelUtils.ts b/packages/react-native-executorch/src/utils/labelUtils.ts
deleted file mode 100644
index 914c8e91d3..0000000000
--- a/packages/react-native-executorch/src/utils/labelUtils.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-export function buildLabelArray(
-  labelMap: Record<string, number | string>
-): string[] {
-  const labels: string[] = [];
-  for (const [name, value] of Object.entries(labelMap)) {
-    if (typeof value === 'number') labels[value] = name;
-  }
-  for (let i = 0; i < labels.length; i++) {
-    if (labels[i] == null) labels[i] = '';
-  }
-  return labels;
-}
diff --git a/packages/react-native-executorch/src/utils/llm.ts b/packages/react-native-executorch/src/utils/llm.ts
deleted file mode 100644
index 62b509bff4..0000000000
--- a/packages/react-native-executorch/src/utils/llm.ts
+++ /dev/null
@@ -1,127 +0,0 @@
-import { LLMTool, ToolCall } from '../types/llm';
-import * as z from 'zod/v4';
-import { Schema, Validator } from 'jsonschema';
-import { jsonrepair } from 'jsonrepair';
-import { DEFAULT_STRUCTURED_OUTPUT_PROMPT } from '../constants/llmDefaults';
-import * as zCore from 'zod/v4/core';
-import { RnExecutorchError } from '../errors/errorUtils';
-import { RnExecutorchErrorCode } from '../errors/ErrorCodes';
-
-/**
- * Parses tool calls from a given message string.
- * @category Utilities - LLM
- * @param message - The message string containing tool calls in JSON format.
- * @returns An array of `ToolCall` objects extracted from the message. Returns
- *   an empty array if the model did not emit a `[...]` block (i.e. chose not
- *   to call any tool).
- * @throws {RnExecutorchError} `InvalidModelOutput` when a `[...]` block is
- *   present but cannot be parsed as JSON — distinct from the model
- *   legitimately deciding not to invoke a tool.
- */
-export const parseToolCall: (message: string) => ToolCall[] = (
-  message: string
-) => {
-  const unparsedToolCalls = message.match('\\[(.|\\s)*\\]');
-  if (!unparsedToolCalls) {
-    return [];
-  }
-
-  let parsedMessage: LLMTool[];
-  try {
-    parsedMessage = JSON.parse(unparsedToolCalls[0]);
-  } catch (e) {
-    throw new RnExecutorchError(
-      RnExecutorchErrorCode.InvalidModelOutput,
-      `Failed to parse tool call JSON from model output: ${unparsedToolCalls[0]}`,
-      e
-    );
-  }
-
-  const results: ToolCall[] = [];
-  for (const tool of parsedMessage) {
-    if (
-      'name' in tool &&
-      typeof tool.name === 'string' &&
-      'arguments' in tool &&
-      tool.arguments !== null &&
-      typeof tool.arguments === 'object'
-    ) {
-      results.push({
-        toolName: tool.name,
-        arguments: tool.arguments,
-      });
-    }
-  }
-
-  return results;
-};
-
-const filterObjectKeys = (obj: object, keysToRemove: string[]) => {
-  const entries = Object.entries(obj);
-  const filteredEntries = entries.filter(
-    ([key, _]) => !keysToRemove.includes(key)
-  );
-  return Object.fromEntries(filteredEntries);
-};
-
-/**
- * Generates a structured output prompt based on the provided schema.
- * @category Utilities - LLM
- * @param responseSchema - The schema (Zod or JSON Schema) defining the desired output format.
- * @returns A prompt string instructing the model to format its output according to the given schema.
- */
-export const getStructuredOutputPrompt = <T extends zCore.$ZodType>(
-  responseSchema: T | Schema
-) => {
-  const schemaObject: Schema | zCore.JSONSchema.JSONSchema =
-    responseSchema instanceof zCore.$ZodType
-      ? filterObjectKeys(z.toJSONSchema(responseSchema), [
-          '$schema',
-          'additionalProperties',
-        ])
-      : responseSchema;
-
-  const schemaString = JSON.stringify(schemaObject);
-
-  return DEFAULT_STRUCTURED_OUTPUT_PROMPT(schemaString);
-};
-
-const extractBetweenBrackets = (text: string): string => {
-  const startIndex = text.search(/[\\{\\[]/); // First occurrence of either { or [
-
-  const openingBracket = text[startIndex];
-  const closingBracket = openingBracket === '{' ? '}' : ']';
-
-  if (!openingBracket) throw Error("Couldn't find JSON in text");
-
-  return text.slice(
-    text.indexOf(openingBracket),
-    text.lastIndexOf(closingBracket) + 1
-  );
-};
-
-/**
- * Fixes and validates structured output from LLMs against a provided schema.
- * @category Utilities - LLM
- * @param output - The raw output string from the LLM.
- * @param responseSchema - The schema (Zod or JSON Schema) to validate the output against.
- * @returns The validated and parsed output.
- */
-export const fixAndValidateStructuredOutput = <T extends zCore.$ZodType>(
-  output: string,
-  responseSchema: T | Schema
-): zCore.output<T> => {
-  const extractedOutput = extractBetweenBrackets(output);
-  const repairedOutput = jsonrepair(extractedOutput);
-  const outputJSON = JSON.parse(repairedOutput);
-
-  if (responseSchema instanceof zCore.$ZodType) {
-    return z.parse(responseSchema, outputJSON) as zCore.output<T>;
-  } else {
-    const validator = new Validator();
-    validator.validate(outputJSON, responseSchema, {
-      throwAll: true,
-    });
-    return outputJSON;
-  }
-};
diff --git a/packages/react-native-executorch/src/utils/llms/context_strategy/MessageCountContextStrategy.ts b/packages/react-native-executorch/src/utils/llms/context_strategy/MessageCountContextStrategy.ts
deleted file mode 100644
index c967561377..0000000000
--- a/packages/react-native-executorch/src/utils/llms/context_strategy/MessageCountContextStrategy.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import { ContextStrategy, Message } from '../../../types/llm';
-
-/**
- * A simple context strategy that retains a fixed number of the most recent messages.
- * This strategy trims the conversation history based purely on the message count.
- * @category Utils
- */
-export class MessageCountContextStrategy implements ContextStrategy {
-  /**
-   * Initializes the MessageCountContextStrategy.
-   * @param windowLength - The maximum number of recent messages to retain in the context. Defaults to 5.
-   */
-  constructor(private readonly windowLength: number = 5) {}
-
-  /**
-   * Builds the context by slicing the history to retain only the most recent `windowLength` messages.
-   * @param systemPrompt - The top-level instructions for the model.
-   * @param history - The complete conversation history.
-   * @param _maxContextLength - Unused in this strategy.
-   * @param _getTokenCount - Unused in this strategy.
-   * @returns The truncated message history with the system prompt at the beginning.
-   */
-  buildContext(
-    systemPrompt: string,
-    history: Message[],
-    _maxContextLength: number,
-    _getTokenCount: (messages: Message[]) => number
-  ): Message[] {
-    return [
-      { content: systemPrompt, role: 'system' as const },
-      ...history.slice(-this.windowLength),
-    ];
-  }
-}
diff --git a/packages/react-native-executorch/src/utils/llms/context_strategy/NoopContextStrategy.ts b/packages/react-native-executorch/src/utils/llms/context_strategy/NoopContextStrategy.ts
deleted file mode 100644
index a9dee23f93..0000000000
--- a/packages/react-native-executorch/src/utils/llms/context_strategy/NoopContextStrategy.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { ContextStrategy, Message } from '../../../types/llm';
-
-/**
- * A context strategy that performs no filtering or trimming of the message history.
- * This strategy is ideal when the developer wants to manually manage the conversation
- * context.
- * @category Utils
- */
-export class NoopContextStrategy implements ContextStrategy {
-  /**
-   * Builds the context by prepending the system prompt to the entire unfiltered history.
-   * @param systemPrompt - The top-level instructions for the model.
-   * @param history - The complete conversation history.
-   * @param _maxContextLength - Unused in this strategy.
-   * @param _getTokenCount - Unused in this strategy.
-   * @returns The unedited message history with the system prompt at the beginning.
-   */
-  buildContext(
-    systemPrompt: string,
-    history: Message[],
-    _maxContextLength: number,
-    _getTokenCount: (messages: Message[]) => number
-  ): Message[] {
-    return [{ content: systemPrompt, role: 'system' as const }, ...history];
-  }
-}
diff --git a/packages/react-native-executorch/src/utils/llms/context_strategy/SlidingWindowContextStrategy.ts b/packages/react-native-executorch/src/utils/llms/context_strategy/SlidingWindowContextStrategy.ts
deleted file mode 100644
index fcbe1c295b..0000000000
--- a/packages/react-native-executorch/src/utils/llms/context_strategy/SlidingWindowContextStrategy.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import { ContextStrategy, Message } from '../../../types/llm';
-
-/**
- * An advanced, token-aware context strategy that dynamically trims the message history
- * to ensure it fits within the model's physical context limits.
- * This strategy calculates the exact token count of the formatted prompt. If the prompt
- * exceeds the allowed token budget (`maxContextLength` - `bufferTokens`), it recursively
- * removes the oldest messages.
- * @category Utils
- */
-export class SlidingWindowContextStrategy implements ContextStrategy {
-  /**
-   * Initializes the SlidingWindowContextStrategy.
-   * @param bufferTokens - The number of tokens to keep free for the model's generated response (e.g., 1000).
-   * @param allowOrphanedAssistantMessages - Whether to allow orphaned assistant messages when trimming the history.
-   * If false, the strategy will ensure that an assistant message is not left without its preceding user message.
-   */
-  constructor(
-    private bufferTokens: number,
-    private allowOrphanedAssistantMessages: boolean = false
-  ) {}
-
-  /**
-   * Builds the context by recursively evicting the oldest messages until the total
-   * token count is safely within the defined budget.
-   * @param systemPrompt - The top-level instructions for the model.
-   * @param history - The complete conversation history.
-   * @param maxContextLength - Unused in this strategy, as the strategy relies on token count rather than message count.
-   * @param getTokenCount - Callback to calculate the exact token count of the rendered template.
-   * @returns The optimized message history guaranteed to fit the token budget.
-   */
-  buildContext(
-    systemPrompt: string,
-    history: Message[],
-    maxContextLength: number,
-    getTokenCount: (messages: Message[]) => number
-  ): Message[] {
-    let localHistory = [...history];
-    const tokenBudget = maxContextLength - this.bufferTokens;
-
-    while (localHistory.length > 1) {
-      const candidateContext: Message[] = [
-        { content: systemPrompt, role: 'system' as const },
-        ...localHistory,
-      ];
-
-      if (getTokenCount(candidateContext) <= tokenBudget) {
-        return candidateContext;
-      }
-
-      localHistory.shift();
-
-      if (!this.allowOrphanedAssistantMessages) {
-        // Prevent leaving an orphaned "assistant" response
-        if (localHistory.length > 0 && localHistory[0]?.role === 'assistant') {
-          localHistory.shift();
-        }
-      }
-    }
-
-    return [
-      { content: systemPrompt, role: 'system' as const },
-      ...localHistory,
-    ];
-  }
-}
diff --git a/packages/react-native-executorch/src/utils/llms/context_strategy/index.ts b/packages/react-native-executorch/src/utils/llms/context_strategy/index.ts
deleted file mode 100644
index 2188d9b936..0000000000
--- a/packages/react-native-executorch/src/utils/llms/context_strategy/index.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-export { MessageCountContextStrategy } from './MessageCountContextStrategy';
-export { SlidingWindowContextStrategy } from './SlidingWindowContextStrategy';
-export { NoopContextStrategy } from './NoopContextStrategy';
diff --git a/packages/react-native-executorch/src/utils/segmentAnythingPrompts.ts b/packages/react-native-executorch/src/utils/segmentAnythingPrompts.ts
deleted file mode 100644
index db854705c7..0000000000
--- a/packages/react-native-executorch/src/utils/segmentAnythingPrompts.ts
+++ /dev/null
@@ -1,157 +0,0 @@
-import { LabelEnum } from '../types/common';
-import { Bbox } from '../types/objectDetection';
-import { SegmentedInstance } from '../types/instanceSegmentation';
-import { bboxArea } from './commonVision';
-
-/**
- * Selects the best matching instance for a given point prompt.
- *
- * Finds all instances whose mask covers the point (x, y), then returns the one
- * with the smallest bounding box area (ties broken by highest confidence).
- * @param instances - Array of segmented instances returned by `forward()`.
- * @param x - X coordinate in original image space.
- * @param y - Y coordinate in original image space.
- * @returns The best matching instance, or `null` if no mask covers the point.
- */
-export function selectByPoint<L extends LabelEnum>(
-  instances: SegmentedInstance<L>[],
-  x: number,
-  y: number
-): SegmentedInstance<L> | null {
-  const px = Math.round(x);
-  const py = Math.round(y);
-
-  const matches = instances.filter((inst) => {
-    const mx = px - Math.round(inst.bbox.x1);
-    const my = py - Math.round(inst.bbox.y1);
-    if (mx < 0 || my < 0 || mx >= inst.maskWidth || my >= inst.maskHeight) {
-      return false;
-    }
-    return inst.mask[my * inst.maskWidth + mx] === 1;
-  });
-
-  if (matches.length === 0) return null;
-
-  return matches.reduce((best, inst) => {
-    const boxArea = bboxArea(inst.bbox);
-    const bestBoxArea = bboxArea(best.bbox);
-    if (boxArea !== bestBoxArea) return boxArea < bestBoxArea ? inst : best;
-
-    return inst.score > best.score ? inst : best;
-  });
-}
-
-/**
- * Selects the best matching instance for a given box prompt.
- *
- * Finds all instances that overlap with the prompt box, then returns the one
- * with the highest IoU with that box (ties broken by highest confidence).
- * @param instances - Array of segmented instances returned by `forward()`.
- * @param box - The prompt bounding box in image coordinates.
- * @returns The best matching instance, or `null` if no instance overlaps.
- */
-export function selectByBox<L extends LabelEnum>(
-  instances: SegmentedInstance<L>[],
-  box: Bbox
-): SegmentedInstance<L> | null {
-  const { x1: px1, y1: py1, x2: px2, y2: py2 } = box;
-  const promptArea = bboxArea(box);
-
-  type Match = {
-    iou: number;
-    score: number;
-    inst: SegmentedInstance<L>;
-  };
-  let best: Match | null = null;
-
-  for (const inst of instances) {
-    const { x1, y1, x2, y2 } = inst.bbox;
-    const interX1 = Math.max(px1, x1);
-    const interY1 = Math.max(py1, y1);
-    const interX2 = Math.min(px2, x2);
-    const interY2 = Math.min(py2, y2);
-    const interArea =
-      Math.max(interX2 - interX1, 0) * Math.max(interY2 - interY1, 0);
-    if (interArea <= 0) continue;
-
-    const detArea = bboxArea(inst.bbox);
-    const iou = interArea / (promptArea + detArea - interArea + 1e-7);
-
-    if (
-      best === null ||
-      iou > best.iou ||
-      (iou === best.iou && inst.score > best.score)
-    ) {
-      best = { iou, score: inst.score, inst };
-    }
-  }
-
-  return best?.inst ?? null;
-}
-
-/**
- * Selects the best matching instance(s) for a text prompt.
- *
- * Returns the instance(s) whose image embedding has the highest cosine similarity
- * with the text embedding. The caller is responsible for producing the
- * embeddings (e.g. with CLIP) and passing them in the same order as
- * `instances`.
- * @param instances - Array of segmented instances returned by `forward()`.
- * @param instanceEmbeddings - Image embedding for each instance, in the same order as `instances`.
- * @param textEmbedding - Embedding of the text prompt.
- * @param topk - Number of top matches to return (defaults to 1).
- * @returns The best matching instance (or null) if topk is 1, otherwise an array of the topk matching instances.
- */
-export function selectByText<L extends LabelEnum>(
-  instances: SegmentedInstance<L>[],
-  instanceEmbeddings: Float32Array[],
-  textEmbedding: Float32Array,
-  topk?: 1
-): SegmentedInstance<L> | null;
-export function selectByText<L extends LabelEnum>(
-  instances: SegmentedInstance<L>[],
-  instanceEmbeddings: Float32Array[],
-  textEmbedding: Float32Array,
-  topk: number
-): SegmentedInstance<L>[];
-export function selectByText<L extends LabelEnum>(
-  instances: SegmentedInstance<L>[],
-  instanceEmbeddings: Float32Array[],
-  textEmbedding: Float32Array,
-  topk = 1
-): SegmentedInstance<L> | null | SegmentedInstance<L>[] {
-  if (instances.length === 0) return topk === 1 ? null : [];
-  if (instances.length !== instanceEmbeddings.length) {
-    throw new Error(
-      `selectByText: instances (${instances.length}) ` +
-        `and instanceEmbeddings (${instanceEmbeddings.length}) ` +
-        `must have the same length`
-    );
-  }
-
-  const scores = instanceEmbeddings.map((emb) => {
-    let dot = 0;
-    for (let j = 0; j < emb.length; j++) {
-      dot += emb[j]! * textEmbedding[j]!;
-    }
-    return dot;
-  });
-
-  if (topk === 1) {
-    let bestIdx = 0;
-    let bestScore = -Infinity;
-    for (let i = 0; i < scores.length; i++) {
-      if (scores[i]! > bestScore) {
-        bestScore = scores[i]!;
-        bestIdx = i;
-      }
-    }
-    return instances[bestIdx]!;
-  }
-
-  return instances
-    .map((instance, index) => ({ instance, score: scores[index]! }))
-    .sort((a, b) => b.score - a.score)
-    .slice(0, topk)
-    .map((item) => item.instance);
-}
diff --git a/packages/react-native-executorch/third-party/.gitignore b/packages/react-native-executorch/third-party/.gitignore
new file mode 100644
index 0000000000..75e91bee9c
--- /dev/null
+++ b/packages/react-native-executorch/third-party/.gitignore
@@ -0,0 +1,7 @@
+# Native ExecuTorch artifacts (headers, .so/.jar libs, xcframeworks) are
+# provisioned locally and NOT committed, until split builds land (see README.md).
+# Ignore everything here except this file, the README, and the common/ submodules.
+/*
+!/.gitignore
+!/README.md
+!/common/
diff --git a/packages/react-native-executorch/third-party/README.md b/packages/react-native-executorch/third-party/README.md
new file mode 100644
index 0000000000..2713110e48
--- /dev/null
+++ b/packages/react-native-executorch/third-party/README.md
@@ -0,0 +1,17 @@
+# third-party
+
+Native ExecuTorch binaries and headers are **not** committed to this branch.
+
+The core package's `android/CMakeLists.txt` and `react-native-executorch.podspec`
+expect ExecuTorch artifacts under this directory:
+
+- `include/` — ExecuTorch + c10 + torch headers
+- `android/jniLibs/<abi>/libexecutorch.so`, `android/libs/executorch.jar`
+- `ios/Frameworks/ExecutorchLib.xcframework`
+
+These must be provisioned before an on-device native build. Wiring this into the
+repo's on-demand artifact mechanism is tracked as a follow-up (see #1208). CI does
+not require them — it builds and type-checks the TypeScript only.
+
+The `common/phonemis` git submodule is retained for later use (TTS phonemizer);
+run `git submodule update --init` to fetch it.
diff --git a/packages/react-native-executorch/third-party/android/libs/cpuinfo/arm64-v8a/libcpuinfo.so b/packages/react-native-executorch/third-party/android/libs/cpuinfo/arm64-v8a/libcpuinfo.so
deleted file mode 100755
index c97092dbce..0000000000
Binary files a/packages/react-native-executorch/third-party/android/libs/cpuinfo/arm64-v8a/libcpuinfo.so and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/android/libs/executorch/arm64-v8a/libexecutorch.so b/packages/react-native-executorch/third-party/android/libs/executorch/arm64-v8a/libexecutorch.so
deleted file mode 100644
index 36cb0919c2..0000000000
Binary files a/packages/react-native-executorch/third-party/android/libs/executorch/arm64-v8a/libexecutorch.so and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/android/libs/executorch/x86_64/libexecutorch.so b/packages/react-native-executorch/third-party/android/libs/executorch/x86_64/libexecutorch.so
deleted file mode 100644
index 7d39ee85a3..0000000000
Binary files a/packages/react-native-executorch/third-party/android/libs/executorch/x86_64/libexecutorch.so and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/android/libs/opencv-third-party/arm64-v8a/libkleidicv.a b/packages/react-native-executorch/third-party/android/libs/opencv-third-party/arm64-v8a/libkleidicv.a
deleted file mode 100644
index aafb96d52a..0000000000
Binary files a/packages/react-native-executorch/third-party/android/libs/opencv-third-party/arm64-v8a/libkleidicv.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/android/libs/opencv-third-party/arm64-v8a/libkleidicv_hal.a b/packages/react-native-executorch/third-party/android/libs/opencv-third-party/arm64-v8a/libkleidicv_hal.a
deleted file mode 100644
index 2586c51da7..0000000000
Binary files a/packages/react-native-executorch/third-party/android/libs/opencv-third-party/arm64-v8a/libkleidicv_hal.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/android/libs/opencv-third-party/arm64-v8a/libkleidicv_thread.a b/packages/react-native-executorch/third-party/android/libs/opencv-third-party/arm64-v8a/libkleidicv_thread.a
deleted file mode 100644
index 21b46fd532..0000000000
Binary files a/packages/react-native-executorch/third-party/android/libs/opencv-third-party/arm64-v8a/libkleidicv_thread.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/android/libs/opencv/arm64-v8a/libopencv_core.a b/packages/react-native-executorch/third-party/android/libs/opencv/arm64-v8a/libopencv_core.a
deleted file mode 100644
index dfa6cac97b..0000000000
Binary files a/packages/react-native-executorch/third-party/android/libs/opencv/arm64-v8a/libopencv_core.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/android/libs/opencv/arm64-v8a/libopencv_features2d.a b/packages/react-native-executorch/third-party/android/libs/opencv/arm64-v8a/libopencv_features2d.a
deleted file mode 100644
index 2d9285ff48..0000000000
Binary files a/packages/react-native-executorch/third-party/android/libs/opencv/arm64-v8a/libopencv_features2d.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/android/libs/opencv/arm64-v8a/libopencv_highgui.a b/packages/react-native-executorch/third-party/android/libs/opencv/arm64-v8a/libopencv_highgui.a
deleted file mode 100644
index f5935c0a49..0000000000
Binary files a/packages/react-native-executorch/third-party/android/libs/opencv/arm64-v8a/libopencv_highgui.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/android/libs/opencv/arm64-v8a/libopencv_imgproc.a b/packages/react-native-executorch/third-party/android/libs/opencv/arm64-v8a/libopencv_imgproc.a
deleted file mode 100644
index 1230670d37..0000000000
Binary files a/packages/react-native-executorch/third-party/android/libs/opencv/arm64-v8a/libopencv_imgproc.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/android/libs/opencv/arm64-v8a/libopencv_photo.a b/packages/react-native-executorch/third-party/android/libs/opencv/arm64-v8a/libopencv_photo.a
deleted file mode 100644
index 6fd7b5725c..0000000000
Binary files a/packages/react-native-executorch/third-party/android/libs/opencv/arm64-v8a/libopencv_photo.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/android/libs/opencv/arm64-v8a/libopencv_video.a b/packages/react-native-executorch/third-party/android/libs/opencv/arm64-v8a/libopencv_video.a
deleted file mode 100644
index 94afa14b0c..0000000000
Binary files a/packages/react-native-executorch/third-party/android/libs/opencv/arm64-v8a/libopencv_video.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/android/libs/opencv/x86_64/libopencv_core.a b/packages/react-native-executorch/third-party/android/libs/opencv/x86_64/libopencv_core.a
deleted file mode 100644
index 11dbb38c99..0000000000
Binary files a/packages/react-native-executorch/third-party/android/libs/opencv/x86_64/libopencv_core.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/android/libs/opencv/x86_64/libopencv_features2d.a b/packages/react-native-executorch/third-party/android/libs/opencv/x86_64/libopencv_features2d.a
deleted file mode 100644
index 7dda0f00f4..0000000000
Binary files a/packages/react-native-executorch/third-party/android/libs/opencv/x86_64/libopencv_features2d.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/android/libs/opencv/x86_64/libopencv_highgui.a b/packages/react-native-executorch/third-party/android/libs/opencv/x86_64/libopencv_highgui.a
deleted file mode 100644
index 074a6fbd7f..0000000000
Binary files a/packages/react-native-executorch/third-party/android/libs/opencv/x86_64/libopencv_highgui.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/android/libs/opencv/x86_64/libopencv_imgproc.a b/packages/react-native-executorch/third-party/android/libs/opencv/x86_64/libopencv_imgproc.a
deleted file mode 100644
index af4e846586..0000000000
Binary files a/packages/react-native-executorch/third-party/android/libs/opencv/x86_64/libopencv_imgproc.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/android/libs/opencv/x86_64/libopencv_photo.a b/packages/react-native-executorch/third-party/android/libs/opencv/x86_64/libopencv_photo.a
deleted file mode 100644
index d1cd183451..0000000000
Binary files a/packages/react-native-executorch/third-party/android/libs/opencv/x86_64/libopencv_photo.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/android/libs/opencv/x86_64/libopencv_video.a b/packages/react-native-executorch/third-party/android/libs/opencv/x86_64/libopencv_video.a
deleted file mode 100644
index 6d76f3b5b5..0000000000
Binary files a/packages/react-native-executorch/third-party/android/libs/opencv/x86_64/libopencv_video.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/android/libs/pthreadpool/arm64-v8a/libpthreadpool.so b/packages/react-native-executorch/third-party/android/libs/pthreadpool/arm64-v8a/libpthreadpool.so
deleted file mode 100755
index 5b144aaa8c..0000000000
Binary files a/packages/react-native-executorch/third-party/android/libs/pthreadpool/arm64-v8a/libpthreadpool.so and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/include/absl/base/attributes.h b/packages/react-native-executorch/third-party/include/absl/base/attributes.h
deleted file mode 100644
index db9949ae24..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/attributes.h
+++ /dev/null
@@ -1,998 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// This header file defines macros for declaring attributes for functions,
-// types, and variables.
-//
-// These macros are used within Abseil and allow the compiler to optimize, where
-// applicable, certain function calls.
-//
-// Most macros here are exposing GCC or Clang features, and are stubbed out for
-// other compilers.
-//
-// GCC attributes documentation:
-//   https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Function-Attributes.html
-//   https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Variable-Attributes.html
-//   https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Type-Attributes.html
-//
-// Most attributes in this file are already supported by GCC 4.7. However, some
-// of them are not supported in older version of Clang. Thus, we check
-// `__has_attribute()` first. If the check fails, we check if we are on GCC and
-// assume the attribute exists on GCC (which is verified on GCC 4.7).
-
-// SKIP_ABSL_INLINE_NAMESPACE_CHECK
-
-#ifndef ABSL_BASE_ATTRIBUTES_H_
-#define ABSL_BASE_ATTRIBUTES_H_
-
-#include "absl/base/config.h"
-
-// ABSL_HAVE_ATTRIBUTE
-//
-// A function-like feature checking macro that is a wrapper around
-// `__has_attribute`, which is defined by GCC 5+ and Clang and evaluates to a
-// nonzero constant integer if the attribute is supported or 0 if not.
-//
-// It evaluates to zero if `__has_attribute` is not defined by the compiler.
-//
-// GCC: https://gcc.gnu.org/gcc-5/changes.html
-// Clang: https://clang.llvm.org/docs/LanguageExtensions.html
-#ifdef __has_attribute
-#define ABSL_HAVE_ATTRIBUTE(x) __has_attribute(x)
-#else
-#define ABSL_HAVE_ATTRIBUTE(x) 0
-#endif
-
-// ABSL_HAVE_CPP_ATTRIBUTE
-//
-// A function-like feature checking macro that accepts C++11 style attributes.
-// It's a wrapper around `__has_cpp_attribute`, defined by ISO C++ SD-6
-// (https://en.cppreference.com/w/cpp/experimental/feature_test). If we don't
-// find `__has_cpp_attribute`, will evaluate to 0.
-#if defined(__cplusplus) && defined(__has_cpp_attribute)
-// NOTE: requiring __cplusplus above should not be necessary, but
-// works around https://bugs.llvm.org/show_bug.cgi?id=23435.
-#define ABSL_HAVE_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
-#else
-#define ABSL_HAVE_CPP_ATTRIBUTE(x) 0
-#endif
-
-// -----------------------------------------------------------------------------
-// Function Attributes
-// -----------------------------------------------------------------------------
-//
-// GCC: https://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
-// Clang: https://clang.llvm.org/docs/AttributeReference.html
-
-// ABSL_PRINTF_ATTRIBUTE
-// ABSL_SCANF_ATTRIBUTE
-//
-// Tells the compiler to perform `printf` format string checking if the
-// compiler supports it; see the 'format' attribute in
-// <https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Function-Attributes.html>.
-//
-// Note: As the GCC manual states, "[s]ince non-static C++ methods
-// have an implicit 'this' argument, the arguments of such methods
-// should be counted from two, not one."
-#if ABSL_HAVE_ATTRIBUTE(format) || (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_PRINTF_ATTRIBUTE(string_index, first_to_check)                    \
-  __attribute__((__format__(__printf__, string_index, first_to_check)))
-#define ABSL_SCANF_ATTRIBUTE(string_index, first_to_check)                     \
-  __attribute__((__format__(__scanf__, string_index, first_to_check)))
-#else
-#define ABSL_PRINTF_ATTRIBUTE(string_index, first_to_check)
-#define ABSL_SCANF_ATTRIBUTE(string_index, first_to_check)
-#endif
-
-// ABSL_ATTRIBUTE_ALWAYS_INLINE
-// ABSL_ATTRIBUTE_NOINLINE
-//
-// Forces functions to either inline or not inline. Introduced in gcc 3.1.
-#if ABSL_HAVE_ATTRIBUTE(always_inline) ||                                      \
-    (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_ATTRIBUTE_ALWAYS_INLINE __attribute__((always_inline))
-#define ABSL_HAVE_ATTRIBUTE_ALWAYS_INLINE 1
-#else
-#define ABSL_ATTRIBUTE_ALWAYS_INLINE
-#endif
-
-#if ABSL_HAVE_ATTRIBUTE(noinline) || (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_ATTRIBUTE_NOINLINE __attribute__((noinline))
-#define ABSL_HAVE_ATTRIBUTE_NOINLINE 1
-#else
-#define ABSL_ATTRIBUTE_NOINLINE
-#endif
-
-// ABSL_ATTRIBUTE_NO_TAIL_CALL
-//
-// Prevents the compiler from optimizing away stack frames for functions which
-// end in a call to another function.
-#if ABSL_HAVE_ATTRIBUTE(disable_tail_calls)
-#define ABSL_HAVE_ATTRIBUTE_NO_TAIL_CALL 1
-#define ABSL_ATTRIBUTE_NO_TAIL_CALL __attribute__((disable_tail_calls))
-#elif defined(__GNUC__) && !defined(__clang__) && !defined(__e2k__)
-#define ABSL_HAVE_ATTRIBUTE_NO_TAIL_CALL 1
-#define ABSL_ATTRIBUTE_NO_TAIL_CALL                                            \
-  __attribute__((optimize("no-optimize-sibling-calls")))
-#else
-#define ABSL_ATTRIBUTE_NO_TAIL_CALL
-#define ABSL_HAVE_ATTRIBUTE_NO_TAIL_CALL 0
-#endif
-
-// ABSL_ATTRIBUTE_WEAK
-//
-// Tags a function as weak for the purposes of compilation and linking.
-// Weak attributes did not work properly in LLVM's Windows backend before
-// 9.0.0, so disable them there. See https://bugs.llvm.org/show_bug.cgi?id=37598
-// for further information. Weak attributes do not work across DLL boundary.
-// The MinGW compiler doesn't complain about the weak attribute until the link
-// step, presumably because Windows doesn't use ELF binaries.
-#if (ABSL_HAVE_ATTRIBUTE(weak) ||                                              \
-     (defined(__GNUC__) && !defined(__clang__))) &&                            \
-    (!defined(_WIN32) ||                                                       \
-     (defined(__clang__) && __clang_major__ >= 9 &&                            \
-      !defined(ABSL_BUILD_DLL) && !defined(ABSL_CONSUME_DLL))) &&              \
-    !defined(__MINGW32__)
-#undef ABSL_ATTRIBUTE_WEAK
-#define ABSL_ATTRIBUTE_WEAK __attribute__((weak))
-#define ABSL_HAVE_ATTRIBUTE_WEAK 1
-#else
-#define ABSL_ATTRIBUTE_WEAK
-#define ABSL_HAVE_ATTRIBUTE_WEAK 0
-#endif
-
-// ABSL_ATTRIBUTE_NONNULL
-//
-// Tells the compiler either (a) that a particular function parameter
-// should be a non-null pointer, or (b) that all pointer arguments should
-// be non-null.
-//
-// Note: As the GCC manual states, "[s]ince non-static C++ methods
-// have an implicit 'this' argument, the arguments of such methods
-// should be counted from two, not one."
-//
-// Args are indexed starting at 1.
-//
-// For non-static class member functions, the implicit `this` argument
-// is arg 1, and the first explicit argument is arg 2. For static class member
-// functions, there is no implicit `this`, and the first explicit argument is
-// arg 1.
-//
-// Example:
-//
-//   /* arg_a cannot be null, but arg_b can */
-//   void Function(void* arg_a, void* arg_b) ABSL_ATTRIBUTE_NONNULL(1);
-//
-//   class C {
-//     /* arg_a cannot be null, but arg_b can */
-//     void Method(void* arg_a, void* arg_b) ABSL_ATTRIBUTE_NONNULL(2);
-//
-//     /* arg_a cannot be null, but arg_b can */
-//     static void StaticMethod(void* arg_a, void* arg_b)
-//     ABSL_ATTRIBUTE_NONNULL(1);
-//   };
-//
-// If no arguments are provided, then all pointer arguments should be non-null.
-//
-//  /* No pointer arguments may be null. */
-//  void Function(void* arg_a, void* arg_b, int arg_c) ABSL_ATTRIBUTE_NONNULL();
-//
-// NOTE: The GCC nonnull attribute actually accepts a list of arguments, but
-// ABSL_ATTRIBUTE_NONNULL does not.
-#if ABSL_HAVE_ATTRIBUTE(nonnull) || (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_ATTRIBUTE_NONNULL(arg_index) __attribute__((nonnull(arg_index)))
-#else
-#define ABSL_ATTRIBUTE_NONNULL(...)
-#endif
-
-// ABSL_ATTRIBUTE_NORETURN
-//
-// Tells the compiler that a given function never returns.
-//
-// Deprecated: Prefer the `[[noreturn]]` attribute standardized by C++11 over
-// this macro.
-#if ABSL_HAVE_ATTRIBUTE(noreturn) || (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_ATTRIBUTE_NORETURN __attribute__((noreturn))
-#elif defined(_MSC_VER)
-#define ABSL_ATTRIBUTE_NORETURN __declspec(noreturn)
-#else
-#define ABSL_ATTRIBUTE_NORETURN
-#endif
-
-// ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS
-//
-// Tells the AddressSanitizer (or other memory testing tools) to ignore a given
-// function. Useful for cases when a function reads random locations on stack,
-// calls _exit from a cloned subprocess, deliberately accesses buffer
-// out of bounds or does other scary things with memory.
-// NOTE: GCC supports AddressSanitizer(asan) since 4.8.
-// https://gcc.gnu.org/gcc-4.8/changes.html
-#if defined(ABSL_HAVE_ADDRESS_SANITIZER) &&                                    \
-    ABSL_HAVE_ATTRIBUTE(no_sanitize_address)
-#define ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS __attribute__((no_sanitize_address))
-#elif defined(ABSL_HAVE_ADDRESS_SANITIZER) && defined(_MSC_VER) &&             \
-    _MSC_VER >= 1928
-// https://docs.microsoft.com/en-us/cpp/cpp/no-sanitize-address
-#define ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS __declspec(no_sanitize_address)
-#elif defined(ABSL_HAVE_HWADDRESS_SANITIZER) && ABSL_HAVE_ATTRIBUTE(no_sanitize)
-// HWAddressSanitizer is a sanitizer similar to AddressSanitizer, which uses CPU
-// features to detect similar bugs with less CPU and memory overhead.
-// NOTE: GCC supports HWAddressSanitizer(hwasan) since 11.
-// https://gcc.gnu.org/gcc-11/changes.html
-#define ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS                                     \
-  __attribute__((no_sanitize("hwaddress")))
-#else
-#define ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS
-#endif
-
-// ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY
-//
-// Tells the MemorySanitizer to relax the handling of a given function. All "Use
-// of uninitialized value" warnings from such functions will be suppressed, and
-// all values loaded from memory will be considered fully initialized.  This
-// attribute is similar to the ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS attribute
-// above, but deals with initialized-ness rather than addressability issues.
-// NOTE: MemorySanitizer(msan) is supported by Clang but not GCC.
-#if ABSL_HAVE_ATTRIBUTE(no_sanitize_memory)
-#define ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY __attribute__((no_sanitize_memory))
-#else
-#define ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY
-#endif
-
-// ABSL_ATTRIBUTE_NO_SANITIZE_THREAD
-//
-// Tells the ThreadSanitizer to not instrument a given function.
-// NOTE: GCC supports ThreadSanitizer(tsan) since 4.8.
-// https://gcc.gnu.org/gcc-4.8/changes.html
-#if ABSL_HAVE_ATTRIBUTE(no_sanitize_thread)
-#define ABSL_ATTRIBUTE_NO_SANITIZE_THREAD __attribute__((no_sanitize_thread))
-#else
-#define ABSL_ATTRIBUTE_NO_SANITIZE_THREAD
-#endif
-
-// ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED
-//
-// Tells the UndefinedSanitizer to ignore a given function. Useful for cases
-// where certain behavior (eg. division by zero) is being used intentionally.
-// NOTE: GCC supports UndefinedBehaviorSanitizer(ubsan) since 4.9.
-// https://gcc.gnu.org/gcc-4.9/changes.html
-#if ABSL_HAVE_ATTRIBUTE(no_sanitize_undefined)
-#define ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED                                   \
-  __attribute__((no_sanitize_undefined))
-#elif ABSL_HAVE_ATTRIBUTE(no_sanitize)
-#define ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED                                   \
-  __attribute__((no_sanitize("undefined")))
-#else
-#define ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED
-#endif
-
-// ABSL_ATTRIBUTE_NO_SANITIZE_CFI
-//
-// Tells the ControlFlowIntegrity sanitizer to not instrument a given function.
-// See https://clang.llvm.org/docs/ControlFlowIntegrity.html for details.
-#if ABSL_HAVE_ATTRIBUTE(no_sanitize) && defined(__llvm__)
-#define ABSL_ATTRIBUTE_NO_SANITIZE_CFI __attribute__((no_sanitize("cfi")))
-#else
-#define ABSL_ATTRIBUTE_NO_SANITIZE_CFI
-#endif
-
-// ABSL_ATTRIBUTE_NO_SANITIZE_SAFESTACK
-//
-// Tells the SafeStack to not instrument a given function.
-// See https://clang.llvm.org/docs/SafeStack.html for details.
-#if ABSL_HAVE_ATTRIBUTE(no_sanitize)
-#define ABSL_ATTRIBUTE_NO_SANITIZE_SAFESTACK                                   \
-  __attribute__((no_sanitize("safe-stack")))
-#else
-#define ABSL_ATTRIBUTE_NO_SANITIZE_SAFESTACK
-#endif
-
-// ABSL_ATTRIBUTE_RETURNS_NONNULL
-//
-// Tells the compiler that a particular function never returns a null pointer.
-#if ABSL_HAVE_ATTRIBUTE(returns_nonnull)
-#define ABSL_ATTRIBUTE_RETURNS_NONNULL __attribute__((returns_nonnull))
-#else
-#define ABSL_ATTRIBUTE_RETURNS_NONNULL
-#endif
-
-// ABSL_HAVE_ATTRIBUTE_SECTION
-//
-// Indicates whether labeled sections are supported. Weak symbol support is
-// a prerequisite. Labeled sections are not supported on Darwin/iOS.
-#ifdef ABSL_HAVE_ATTRIBUTE_SECTION
-#error ABSL_HAVE_ATTRIBUTE_SECTION cannot be directly set
-#elif (ABSL_HAVE_ATTRIBUTE(section) ||                                         \
-       (defined(__GNUC__) && !defined(__clang__))) &&                          \
-    !defined(__APPLE__) && ABSL_HAVE_ATTRIBUTE_WEAK
-#define ABSL_HAVE_ATTRIBUTE_SECTION 1
-
-// ABSL_ATTRIBUTE_SECTION
-//
-// Tells the compiler/linker to put a given function into a section and define
-// `__start_ ## name` and `__stop_ ## name` symbols to bracket the section.
-// This functionality is supported by GNU linker.  Any function annotated with
-// `ABSL_ATTRIBUTE_SECTION` must not be inlined, or it will be placed into
-// whatever section its caller is placed into.
-//
-#ifndef ABSL_ATTRIBUTE_SECTION
-#define ABSL_ATTRIBUTE_SECTION(name)                                           \
-  __attribute__((section(#name))) __attribute__((noinline))
-#endif
-
-// ABSL_ATTRIBUTE_SECTION_VARIABLE
-//
-// Tells the compiler/linker to put a given variable into a section and define
-// `__start_ ## name` and `__stop_ ## name` symbols to bracket the section.
-// This functionality is supported by GNU linker.
-#ifndef ABSL_ATTRIBUTE_SECTION_VARIABLE
-#ifdef _AIX
-// __attribute__((section(#name))) on AIX is achieved by using the `.csect`
-// psudo op which includes an additional integer as part of its syntax indcating
-// alignment. If data fall under different alignments then you might get a
-// compilation error indicating a `Section type conflict`.
-#define ABSL_ATTRIBUTE_SECTION_VARIABLE(name)
-#else
-#define ABSL_ATTRIBUTE_SECTION_VARIABLE(name) __attribute__((section(#name)))
-#endif
-#endif
-
-// ABSL_DECLARE_ATTRIBUTE_SECTION_VARS
-//
-// A weak section declaration to be used as a global declaration
-// for ABSL_ATTRIBUTE_SECTION_START|STOP(name) to compile and link
-// even without functions with ABSL_ATTRIBUTE_SECTION(name).
-// ABSL_DEFINE_ATTRIBUTE_SECTION should be in the exactly one file; it's
-// a no-op on ELF but not on Mach-O.
-//
-#ifndef ABSL_DECLARE_ATTRIBUTE_SECTION_VARS
-#define ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(name)                              \
-  extern char __start_##name[] ABSL_ATTRIBUTE_WEAK;                            \
-  extern char __stop_##name[] ABSL_ATTRIBUTE_WEAK
-#endif
-#ifndef ABSL_DEFINE_ATTRIBUTE_SECTION_VARS
-#define ABSL_INIT_ATTRIBUTE_SECTION_VARS(name)
-#define ABSL_DEFINE_ATTRIBUTE_SECTION_VARS(name)
-#endif
-
-// ABSL_ATTRIBUTE_SECTION_START
-//
-// Returns `void*` pointers to start/end of a section of code with
-// functions having ABSL_ATTRIBUTE_SECTION(name).
-// Returns 0 if no such functions exist.
-// One must ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(name) for this to compile and
-// link.
-//
-#define ABSL_ATTRIBUTE_SECTION_START(name)                                     \
-  (reinterpret_cast<void *>(__start_##name))
-#define ABSL_ATTRIBUTE_SECTION_STOP(name)                                      \
-  (reinterpret_cast<void *>(__stop_##name))
-
-#else // !ABSL_HAVE_ATTRIBUTE_SECTION
-
-#define ABSL_HAVE_ATTRIBUTE_SECTION 0
-
-// provide dummy definitions
-#define ABSL_ATTRIBUTE_SECTION(name)
-#define ABSL_ATTRIBUTE_SECTION_VARIABLE(name)
-#define ABSL_INIT_ATTRIBUTE_SECTION_VARS(name)
-#define ABSL_DEFINE_ATTRIBUTE_SECTION_VARS(name)
-#define ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(name)
-#define ABSL_ATTRIBUTE_SECTION_START(name) (reinterpret_cast<void *>(0))
-#define ABSL_ATTRIBUTE_SECTION_STOP(name) (reinterpret_cast<void *>(0))
-
-#endif // ABSL_ATTRIBUTE_SECTION
-
-// ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
-//
-// Support for aligning the stack on 32-bit x86.
-#if ABSL_HAVE_ATTRIBUTE(force_align_arg_pointer) ||                            \
-    (defined(__GNUC__) && !defined(__clang__))
-#if defined(__i386__)
-#define ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC                                \
-  __attribute__((force_align_arg_pointer))
-#define ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)
-#elif defined(__x86_64__)
-#define ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (1)
-#define ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
-#else // !__i386__ && !__x86_64
-#define ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)
-#define ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
-#endif // __i386__
-#else
-#define ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
-#define ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)
-#endif
-
-// ABSL_MUST_USE_RESULT
-//
-// Tells the compiler to warn about unused results.
-//
-// For code or headers that are assured to only build with C++17 and up, prefer
-// just using the standard `[[nodiscard]]` directly over this macro.
-//
-// When annotating a function, it must appear as the first part of the
-// declaration or definition. The compiler will warn if the return value from
-// such a function is unused:
-//
-//   ABSL_MUST_USE_RESULT Sprocket* AllocateSprocket();
-//   AllocateSprocket();  // Triggers a warning.
-//
-// When annotating a class, it is equivalent to annotating every function which
-// returns an instance.
-//
-//   class ABSL_MUST_USE_RESULT Sprocket {};
-//   Sprocket();  // Triggers a warning.
-//
-//   Sprocket MakeSprocket();
-//   MakeSprocket();  // Triggers a warning.
-//
-// Note that references and pointers are not instances:
-//
-//   Sprocket* SprocketPointer();
-//   SprocketPointer();  // Does *not* trigger a warning.
-//
-// ABSL_MUST_USE_RESULT allows using cast-to-void to suppress the unused result
-// warning. For that, warn_unused_result is used only for clang but not for gcc.
-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66425
-//
-// Note: past advice was to place the macro after the argument list.
-//
-// TODO(b/176172494): Use ABSL_HAVE_CPP_ATTRIBUTE(nodiscard) when all code is
-// compliant with the stricter [[nodiscard]].
-#if defined(__clang__) && ABSL_HAVE_ATTRIBUTE(warn_unused_result)
-#define ABSL_MUST_USE_RESULT __attribute__((warn_unused_result))
-#else
-#define ABSL_MUST_USE_RESULT
-#endif
-
-// ABSL_ATTRIBUTE_HOT, ABSL_ATTRIBUTE_COLD
-//
-// Tells GCC that a function is hot or cold. GCC can use this information to
-// improve static analysis, i.e. a conditional branch to a cold function
-// is likely to be not-taken.
-// This annotation is used for function declarations.
-//
-// Example:
-//
-//   int foo() ABSL_ATTRIBUTE_HOT;
-#if ABSL_HAVE_ATTRIBUTE(hot) || (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_ATTRIBUTE_HOT __attribute__((hot))
-#else
-#define ABSL_ATTRIBUTE_HOT
-#endif
-
-#if ABSL_HAVE_ATTRIBUTE(cold) || (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_ATTRIBUTE_COLD __attribute__((cold))
-#else
-#define ABSL_ATTRIBUTE_COLD
-#endif
-
-// ABSL_XRAY_ALWAYS_INSTRUMENT, ABSL_XRAY_NEVER_INSTRUMENT, ABSL_XRAY_LOG_ARGS
-//
-// We define the ABSL_XRAY_ALWAYS_INSTRUMENT and ABSL_XRAY_NEVER_INSTRUMENT
-// macro used as an attribute to mark functions that must always or never be
-// instrumented by XRay. Currently, this is only supported in Clang/LLVM.
-//
-// For reference on the LLVM XRay instrumentation, see
-// http://llvm.org/docs/XRay.html.
-//
-// A function with the XRAY_ALWAYS_INSTRUMENT macro attribute in its declaration
-// will always get the XRay instrumentation sleds. These sleds may introduce
-// some binary size and runtime overhead and must be used sparingly.
-//
-// These attributes only take effect when the following conditions are met:
-//
-//   * The file/target is built in at least C++11 mode, with a Clang compiler
-//     that supports XRay attributes.
-//   * The file/target is built with the -fxray-instrument flag set for the
-//     Clang/LLVM compiler.
-//   * The function is defined in the translation unit (the compiler honors the
-//     attribute in either the definition or the declaration, and must match).
-//
-// There are cases when, even when building with XRay instrumentation, users
-// might want to control specifically which functions are instrumented for a
-// particular build using special-case lists provided to the compiler. These
-// special case lists are provided to Clang via the
-// -fxray-always-instrument=... and -fxray-never-instrument=... flags. The
-// attributes in source take precedence over these special-case lists.
-//
-// To disable the XRay attributes at build-time, users may define
-// ABSL_NO_XRAY_ATTRIBUTES. Do NOT define ABSL_NO_XRAY_ATTRIBUTES on specific
-// packages/targets, as this may lead to conflicting definitions of functions at
-// link-time.
-//
-// XRay isn't currently supported on Android:
-// https://github.com/android/ndk/issues/368
-#if ABSL_HAVE_CPP_ATTRIBUTE(clang::xray_always_instrument) &&                  \
-    !defined(ABSL_NO_XRAY_ATTRIBUTES) && !defined(__ANDROID__)
-#define ABSL_XRAY_ALWAYS_INSTRUMENT [[clang::xray_always_instrument]]
-#define ABSL_XRAY_NEVER_INSTRUMENT [[clang::xray_never_instrument]]
-#if ABSL_HAVE_CPP_ATTRIBUTE(clang::xray_log_args)
-#define ABSL_XRAY_LOG_ARGS(N)                                                  \
-  [[clang::xray_always_instrument, clang::xray_log_args(N)]]
-#else
-#define ABSL_XRAY_LOG_ARGS(N) [[clang::xray_always_instrument]]
-#endif
-#else
-#define ABSL_XRAY_ALWAYS_INSTRUMENT
-#define ABSL_XRAY_NEVER_INSTRUMENT
-#define ABSL_XRAY_LOG_ARGS(N)
-#endif
-
-// ABSL_ATTRIBUTE_REINITIALIZES
-//
-// Indicates that a member function reinitializes the entire object to a known
-// state, independent of the previous state of the object.
-//
-// The clang-tidy check bugprone-use-after-move allows member functions marked
-// with this attribute to be called on objects that have been moved from;
-// without the attribute, this would result in a use-after-move warning.
-#if ABSL_HAVE_CPP_ATTRIBUTE(clang::reinitializes)
-#define ABSL_ATTRIBUTE_REINITIALIZES [[clang::reinitializes]]
-#else
-#define ABSL_ATTRIBUTE_REINITIALIZES
-#endif
-
-// -----------------------------------------------------------------------------
-// Variable Attributes
-// -----------------------------------------------------------------------------
-
-// ABSL_ATTRIBUTE_UNUSED
-//
-// Prevents the compiler from complaining about variables that appear unused.
-//
-// For code or headers that are assured to only build with C++17 and up, prefer
-// just using the standard '[[maybe_unused]]' directly over this macro.
-//
-// Due to differences in positioning requirements between the old, compiler
-// specific __attribute__ syntax and the now standard [[maybe_unused]], this
-// macro does not attempt to take advantage of '[[maybe_unused]]'.
-#if ABSL_HAVE_ATTRIBUTE(unused) || (defined(__GNUC__) && !defined(__clang__))
-#undef ABSL_ATTRIBUTE_UNUSED
-#define ABSL_ATTRIBUTE_UNUSED __attribute__((__unused__))
-#else
-#define ABSL_ATTRIBUTE_UNUSED
-#endif
-
-// ABSL_ATTRIBUTE_INITIAL_EXEC
-//
-// Tells the compiler to use "initial-exec" mode for a thread-local variable.
-// See http://people.redhat.com/drepper/tls.pdf for the gory details.
-#if ABSL_HAVE_ATTRIBUTE(tls_model) || (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_ATTRIBUTE_INITIAL_EXEC __attribute__((tls_model("initial-exec")))
-#else
-#define ABSL_ATTRIBUTE_INITIAL_EXEC
-#endif
-
-// ABSL_ATTRIBUTE_PACKED
-//
-// Instructs the compiler not to use natural alignment for a tagged data
-// structure, but instead to reduce its alignment to 1.
-//
-// Therefore, DO NOT APPLY THIS ATTRIBUTE TO STRUCTS CONTAINING ATOMICS. Doing
-// so can cause atomic variables to be mis-aligned and silently violate
-// atomicity on x86.
-//
-// This attribute can either be applied to members of a structure or to a
-// structure in its entirety. Applying this attribute (judiciously) to a
-// structure in its entirety to optimize the memory footprint of very
-// commonly-used structs is fine. Do not apply this attribute to a structure in
-// its entirety if the purpose is to control the offsets of the members in the
-// structure. Instead, apply this attribute only to structure members that need
-// it.
-//
-// When applying ABSL_ATTRIBUTE_PACKED only to specific structure members the
-// natural alignment of structure members not annotated is preserved. Aligned
-// member accesses are faster than non-aligned member accesses even if the
-// targeted microprocessor supports non-aligned accesses.
-#if ABSL_HAVE_ATTRIBUTE(packed) || (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_ATTRIBUTE_PACKED __attribute__((__packed__))
-#else
-#define ABSL_ATTRIBUTE_PACKED
-#endif
-
-// ABSL_ATTRIBUTE_FUNC_ALIGN
-//
-// Tells the compiler to align the function start at least to certain
-// alignment boundary
-#if ABSL_HAVE_ATTRIBUTE(aligned) || (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_ATTRIBUTE_FUNC_ALIGN(bytes) __attribute__((aligned(bytes)))
-#else
-#define ABSL_ATTRIBUTE_FUNC_ALIGN(bytes)
-#endif
-
-// ABSL_FALLTHROUGH_INTENDED
-//
-// Annotates implicit fall-through between switch labels, allowing a case to
-// indicate intentional fallthrough and turn off warnings about any lack of a
-// `break` statement. The ABSL_FALLTHROUGH_INTENDED macro should be followed by
-// a semicolon and can be used in most places where `break` can, provided that
-// no statements exist between it and the next switch label.
-//
-// Example:
-//
-//  switch (x) {
-//    case 40:
-//    case 41:
-//      if (truth_is_out_there) {
-//        ++x;
-//        ABSL_FALLTHROUGH_INTENDED;  // Use instead of/along with annotations
-//                                    // in comments
-//      } else {
-//        return x;
-//      }
-//    case 42:
-//      ...
-//
-// Notes: When supported, GCC and Clang can issue a warning on switch labels
-// with unannotated fallthrough using the warning `-Wimplicit-fallthrough`. See
-// clang documentation on language extensions for details:
-// https://clang.llvm.org/docs/AttributeReference.html#fallthrough-clang-fallthrough
-//
-// When used with unsupported compilers, the ABSL_FALLTHROUGH_INTENDED macro has
-// no effect on diagnostics. In any case this macro has no effect on runtime
-// behavior and performance of code.
-
-#ifdef ABSL_FALLTHROUGH_INTENDED
-#error "ABSL_FALLTHROUGH_INTENDED should not be defined."
-#elif ABSL_HAVE_CPP_ATTRIBUTE(fallthrough)
-#define ABSL_FALLTHROUGH_INTENDED [[fallthrough]]
-#elif ABSL_HAVE_CPP_ATTRIBUTE(clang::fallthrough)
-#define ABSL_FALLTHROUGH_INTENDED [[clang::fallthrough]]
-#elif ABSL_HAVE_CPP_ATTRIBUTE(gnu::fallthrough)
-#define ABSL_FALLTHROUGH_INTENDED [[gnu::fallthrough]]
-#else
-#define ABSL_FALLTHROUGH_INTENDED                                              \
-  do {                                                                         \
-  } while (0)
-#endif
-
-// ABSL_DEPRECATED()
-//
-// Marks a deprecated class, struct, enum, function, method and variable
-// declarations. The macro argument is used as a custom diagnostic message (e.g.
-// suggestion of a better alternative).
-//
-// For code or headers that are assured to only build with C++14 and up, prefer
-// just using the standard `[[deprecated("message")]]` directly over this macro.
-//
-// Examples:
-//
-//   class ABSL_DEPRECATED("Use Bar instead") Foo {...};
-//
-//   ABSL_DEPRECATED("Use Baz() instead") void Bar() {...}
-//
-//   template <typename T>
-//   ABSL_DEPRECATED("Use DoThat() instead")
-//   void DoThis();
-//
-//   enum FooEnum {
-//     kBar ABSL_DEPRECATED("Use kBaz instead"),
-//   };
-//
-// Every usage of a deprecated entity will trigger a warning when compiled with
-// GCC/Clang's `-Wdeprecated-declarations` option. Google's production toolchain
-// turns this warning off by default, instead relying on clang-tidy to report
-// new uses of deprecated code.
-#if ABSL_HAVE_ATTRIBUTE(deprecated)
-#define ABSL_DEPRECATED(message) __attribute__((deprecated(message)))
-#else
-#define ABSL_DEPRECATED(message)
-#endif
-
-// When deprecating Abseil code, it is sometimes necessary to turn off the
-// warning within Abseil, until the deprecated code is actually removed. The
-// deprecated code can be surrounded with these directives to achieve that
-// result.
-//
-// class ABSL_DEPRECATED("Use Bar instead") Foo;
-//
-// ABSL_INTERNAL_DISABLE_DEPRECATED_DECLARATION_WARNING
-// Baz ComputeBazFromFoo(Foo f);
-// ABSL_INTERNAL_RESTORE_DEPRECATED_DECLARATION_WARNING
-#if defined(__GNUC__) || defined(__clang__)
-// Clang also supports these GCC pragmas.
-#define ABSL_INTERNAL_DISABLE_DEPRECATED_DECLARATION_WARNING                   \
-  _Pragma("GCC diagnostic push")                                               \
-      _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
-#define ABSL_INTERNAL_RESTORE_DEPRECATED_DECLARATION_WARNING                   \
-  _Pragma("GCC diagnostic pop")
-#elif defined(_MSC_VER)
-#define ABSL_INTERNAL_DISABLE_DEPRECATED_DECLARATION_WARNING                   \
-  _Pragma("warning(push)") _Pragma("warning(disable: 4996)")
-#define ABSL_INTERNAL_RESTORE_DEPRECATED_DECLARATION_WARNING                   \
-  _Pragma("warning(pop)")
-#else
-#define ABSL_INTERNAL_DISABLE_DEPRECATED_DECLARATION_WARNING
-#define ABSL_INTERNAL_RESTORE_DEPRECATED_DECLARATION_WARNING
-#endif // defined(__GNUC__) || defined(__clang__)
-
-// ABSL_CONST_INIT
-//
-// A variable declaration annotated with the `ABSL_CONST_INIT` attribute will
-// not compile (on supported platforms) unless the variable has a constant
-// initializer. This is useful for variables with static and thread storage
-// duration, because it guarantees that they will not suffer from the so-called
-// "static init order fiasco".
-//
-// This attribute must be placed on the initializing declaration of the
-// variable. Some compilers will give a -Wmissing-constinit warning when this
-// attribute is placed on some other declaration but missing from the
-// initializing declaration.
-//
-// In some cases (notably with thread_local variables), `ABSL_CONST_INIT` can
-// also be used in a non-initializing declaration to tell the compiler that a
-// variable is already initialized, reducing overhead that would otherwise be
-// incurred by a hidden guard variable. Thus annotating all declarations with
-// this attribute is recommended to potentially enhance optimization.
-//
-// Example:
-//
-//   class MyClass {
-//    public:
-//     ABSL_CONST_INIT static MyType my_var;
-//   };
-//
-//   ABSL_CONST_INIT MyType MyClass::my_var = MakeMyType(...);
-//
-// For code or headers that are assured to only build with C++20 and up, prefer
-// just using the standard `constinit` keyword directly over this macro.
-//
-// Note that this attribute is redundant if the variable is declared constexpr.
-#if defined(__cpp_constinit) && __cpp_constinit >= 201907L
-#define ABSL_CONST_INIT constinit
-#elif ABSL_HAVE_CPP_ATTRIBUTE(clang::require_constant_initialization)
-#define ABSL_CONST_INIT [[clang::require_constant_initialization]]
-#else
-#define ABSL_CONST_INIT
-#endif
-
-// ABSL_ATTRIBUTE_PURE_FUNCTION
-//
-// ABSL_ATTRIBUTE_PURE_FUNCTION is used to annotate declarations of "pure"
-// functions. A function is pure if its return value is only a function of its
-// arguments. The pure attribute prohibits a function from modifying the state
-// of the program that is observable by means other than inspecting the
-// function's return value. Declaring such functions with the pure attribute
-// allows the compiler to avoid emitting some calls in repeated invocations of
-// the function with the same argument values.
-//
-// Example:
-//
-//  ABSL_ATTRIBUTE_PURE_FUNCTION std::string FormatTime(Time t);
-#if ABSL_HAVE_CPP_ATTRIBUTE(gnu::pure)
-#define ABSL_ATTRIBUTE_PURE_FUNCTION [[gnu::pure]]
-#elif ABSL_HAVE_ATTRIBUTE(pure)
-#define ABSL_ATTRIBUTE_PURE_FUNCTION __attribute__((pure))
-#else
-// If the attribute isn't defined, we'll fallback to ABSL_MUST_USE_RESULT since
-// pure functions are useless if its return is ignored.
-#define ABSL_ATTRIBUTE_PURE_FUNCTION ABSL_MUST_USE_RESULT
-#endif
-
-// ABSL_ATTRIBUTE_CONST_FUNCTION
-//
-// ABSL_ATTRIBUTE_CONST_FUNCTION is used to annotate declarations of "const"
-// functions. A const function is similar to a pure function, with one
-// exception: Pure functions may return value that depend on a non-volatile
-// object that isn't provided as a function argument, while the const function
-// is guaranteed to return the same result given the same arguments.
-//
-// Example:
-//
-//  ABSL_ATTRIBUTE_CONST_FUNCTION int64_t ToInt64Milliseconds(Duration d);
-#if defined(_MSC_VER) && !defined(__clang__)
-// Put the MSVC case first since MSVC seems to parse const as a C++ keyword.
-#define ABSL_ATTRIBUTE_CONST_FUNCTION ABSL_ATTRIBUTE_PURE_FUNCTION
-#elif ABSL_HAVE_CPP_ATTRIBUTE(gnu::const)
-#define ABSL_ATTRIBUTE_CONST_FUNCTION [[gnu::const]]
-#elif ABSL_HAVE_ATTRIBUTE(const)
-#define ABSL_ATTRIBUTE_CONST_FUNCTION __attribute__((const))
-#else
-// Since const functions are more restrictive pure function, we'll fallback to a
-// pure function if the const attribute is not handled.
-#define ABSL_ATTRIBUTE_CONST_FUNCTION ABSL_ATTRIBUTE_PURE_FUNCTION
-#endif
-
-// ABSL_ATTRIBUTE_LIFETIME_BOUND indicates that a resource owned by a function
-// parameter or implicit object parameter is retained by the return value of the
-// annotated function (or, for a parameter of a constructor, in the value of the
-// constructed object). This attribute causes warnings to be produced if a
-// temporary object does not live long enough.
-//
-// When applied to a reference parameter, the referenced object is assumed to be
-// retained by the return value of the function. When applied to a non-reference
-// parameter (for example, a pointer or a class type), all temporaries
-// referenced by the parameter are assumed to be retained by the return value of
-// the function.
-//
-// See also the upstream documentation:
-// https://clang.llvm.org/docs/AttributeReference.html#lifetimebound
-// https://learn.microsoft.com/en-us/cpp/code-quality/c26816?view=msvc-170
-#if ABSL_HAVE_CPP_ATTRIBUTE(clang::lifetimebound)
-#define ABSL_ATTRIBUTE_LIFETIME_BOUND [[clang::lifetimebound]]
-#elif ABSL_HAVE_CPP_ATTRIBUTE(msvc::lifetimebound)
-#define ABSL_ATTRIBUTE_LIFETIME_BOUND [[msvc::lifetimebound]]
-#elif ABSL_HAVE_ATTRIBUTE(lifetimebound)
-#define ABSL_ATTRIBUTE_LIFETIME_BOUND __attribute__((lifetimebound))
-#else
-#define ABSL_ATTRIBUTE_LIFETIME_BOUND
-#endif
-
-// ABSL_ATTRIBUTE_VIEW indicates that a type is solely a "view" of data that it
-// points to, similarly to a span, string_view, or other non-owning reference
-// type.
-// This enables diagnosing certain lifetime issues similar to those enabled by
-// ABSL_ATTRIBUTE_LIFETIME_BOUND, such as:
-//
-//   struct ABSL_ATTRIBUTE_VIEW StringView {
-//     template<class R>
-//     StringView(const R&);
-//   };
-//
-//   StringView f(std::string s) {
-//     return s;  // warning: address of stack memory returned
-//   }
-//
-// We disable this on Clang versions < 13 because of the following
-// false-positive:
-//
-//   absl::string_view f(absl::optional<absl::string_view> sv) { return *sv; }
-//
-// See the following links for details:
-// https://reviews.llvm.org/D64448
-// https://lists.llvm.org/pipermail/cfe-dev/2018-November/060355.html
-#if ABSL_HAVE_CPP_ATTRIBUTE(gsl::Pointer) &&                                   \
-    (!defined(__clang_major__) || __clang_major__ >= 13)
-#define ABSL_ATTRIBUTE_VIEW [[gsl::Pointer]]
-#else
-#define ABSL_ATTRIBUTE_VIEW
-#endif
-
-// ABSL_ATTRIBUTE_OWNER indicates that a type is a container, smart pointer, or
-// similar class that owns all the data that it points to.
-// This enables diagnosing certain lifetime issues similar to those enabled by
-// ABSL_ATTRIBUTE_LIFETIME_BOUND, such as:
-//
-//   struct ABSL_ATTRIBUTE_VIEW StringView {
-//     template<class R>
-//     StringView(const R&);
-//   };
-//
-//   struct ABSL_ATTRIBUTE_OWNER String {};
-//
-//   StringView f(String s) {
-//     return s;  // warning: address of stack memory returned
-//   }
-//
-// We disable this on Clang versions < 13 because of the following
-// false-positive:
-//
-//   absl::string_view f(absl::optional<absl::string_view> sv) { return *sv; }
-//
-// See the following links for details:
-// https://reviews.llvm.org/D64448
-// https://lists.llvm.org/pipermail/cfe-dev/2018-November/060355.html
-#if ABSL_HAVE_CPP_ATTRIBUTE(gsl::Owner) &&                                     \
-    (!defined(__clang_major__) || __clang_major__ >= 13)
-#define ABSL_ATTRIBUTE_OWNER [[gsl::Owner]]
-#else
-#define ABSL_ATTRIBUTE_OWNER
-#endif
-
-// ABSL_ATTRIBUTE_TRIVIAL_ABI
-// Indicates that a type is "trivially relocatable" -- meaning it can be
-// relocated without invoking the constructor/destructor, using a form of move
-// elision.
-//
-// From a memory safety point of view, putting aside destructor ordering, it's
-// safe to apply ABSL_ATTRIBUTE_TRIVIAL_ABI if an object's location
-// can change over the course of its lifetime: if a constructor can be run one
-// place, and then the object magically teleports to another place where some
-// methods are run, and then the object teleports to yet another place where it
-// is destroyed. This is notably not true for self-referential types, where the
-// move-constructor must keep the self-reference up to date. If the type changed
-// location without invoking the move constructor, it would have a dangling
-// self-reference.
-//
-// The use of this teleporting machinery means that the number of paired
-// move/destroy operations can change, and so it is a bad idea to apply this to
-// a type meant to count the number of moves.
-//
-// Warning: applying this can, rarely, break callers. Objects passed by value
-// will be destroyed at the end of the call, instead of the end of the
-// full-expression containing the call. In addition, it changes the ABI
-// of functions accepting this type by value (e.g. to pass in registers).
-//
-// See also the upstream documentation:
-// https://clang.llvm.org/docs/AttributeReference.html#trivial-abi
-//
-// b/321691395 - This is currently disabled in open-source builds since
-// compiler support differs. If system libraries compiled with GCC are mixed
-// with libraries compiled with Clang, types will have different ideas about
-// their ABI, leading to hard to debug crashes.
-#define ABSL_ATTRIBUTE_TRIVIAL_ABI
-
-// ABSL_ATTRIBUTE_NO_UNIQUE_ADDRESS
-//
-// Indicates a data member can be optimized to occupy no space (if it is empty)
-// and/or its tail padding can be used for other members.
-//
-// For code that is assured to only build with C++20 or later, prefer using
-// the standard attribute `[[no_unique_address]]` directly instead of this
-// macro.
-//
-// https://devblogs.microsoft.com/cppblog/msvc-cpp20-and-the-std-cpp20-switch/#c20-no_unique_address
-// Current versions of MSVC have disabled `[[no_unique_address]]` since it
-// breaks ABI compatibility, but offers `[[msvc::no_unique_address]]` for
-// situations when it can be assured that it is desired. Since Abseil does not
-// claim ABI compatibility in mixed builds, we can offer it unconditionally.
-#if defined(_MSC_VER) && _MSC_VER >= 1929
-#define ABSL_ATTRIBUTE_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]]
-#elif ABSL_HAVE_CPP_ATTRIBUTE(no_unique_address)
-#define ABSL_ATTRIBUTE_NO_UNIQUE_ADDRESS [[no_unique_address]]
-#else
-#define ABSL_ATTRIBUTE_NO_UNIQUE_ADDRESS
-#endif
-
-// ABSL_ATTRIBUTE_UNINITIALIZED
-//
-// GCC and Clang support a flag `-ftrivial-auto-var-init=<option>` (<option>
-// can be "zero" or "pattern") that can be used to initialize automatic stack
-// variables. Variables with this attribute will be left uninitialized,
-// overriding the compiler flag.
-//
-// See https://clang.llvm.org/docs/AttributeReference.html#uninitialized
-// and
-// https://gcc.gnu.org/onlinedocs/gcc/Common-Variable-Attributes.html#index-uninitialized-variable-attribute
-#if ABSL_HAVE_CPP_ATTRIBUTE(clang::uninitialized)
-#define ABSL_ATTRIBUTE_UNINITIALIZED [[clang::uninitialized]]
-#elif ABSL_HAVE_CPP_ATTRIBUTE(gnu::uninitialized)
-#define ABSL_ATTRIBUTE_UNINITIALIZED [[gnu::uninitialized]]
-#elif ABSL_HAVE_ATTRIBUTE(uninitialized)
-#define ABSL_ATTRIBUTE_UNINITIALIZED __attribute__((uninitialized))
-#else
-#define ABSL_ATTRIBUTE_UNINITIALIZED
-#endif
-
-// ABSL_ATTRIBUTE_WARN_UNUSED
-//
-// Compilers routinely warn about trivial variables that are unused.  For
-// non-trivial types, this warning is suppressed since the
-// constructor/destructor may be intentional and load-bearing, for example, with
-// a RAII scoped lock.
-//
-// For example:
-//
-// class ABSL_ATTRIBUTE_WARN_UNUSED MyType {
-//  public:
-//   MyType();
-//   ~MyType();
-// };
-//
-// void foo() {
-//   // Warns with ABSL_ATTRIBUTE_WARN_UNUSED attribute present.
-//   MyType unused;
-// }
-//
-// See https://clang.llvm.org/docs/AttributeReference.html#warn-unused and
-// https://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html#index-warn_005funused-type-attribute
-#if ABSL_HAVE_CPP_ATTRIBUTE(gnu::warn_unused)
-#define ABSL_ATTRIBUTE_WARN_UNUSED [[gnu::warn_unused]]
-#else
-#define ABSL_ATTRIBUTE_WARN_UNUSED
-#endif
-
-#endif // ABSL_BASE_ATTRIBUTES_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/call_once.h b/packages/react-native-executorch/third-party/include/absl/base/call_once.h
deleted file mode 100644
index b2ca265a0a..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/call_once.h
+++ /dev/null
@@ -1,223 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: call_once.h
-// -----------------------------------------------------------------------------
-//
-// This header file provides an Abseil version of `std::call_once` for invoking
-// a given function at most once, across all threads. This Abseil version is
-// faster than the C++11 version and incorporates the C++17 argument-passing
-// fix, so that (for example) non-const references may be passed to the invoked
-// function.
-
-#ifndef ABSL_BASE_CALL_ONCE_H_
-#define ABSL_BASE_CALL_ONCE_H_
-
-#include <algorithm>
-#include <atomic>
-#include <cstdint>
-#include <type_traits>
-#include <utility>
-
-#include "absl/base/internal/invoke.h"
-#include "absl/base/internal/low_level_scheduling.h"
-#include "absl/base/internal/raw_logging.h"
-#include "absl/base/internal/scheduling_mode.h"
-#include "absl/base/internal/spinlock_wait.h"
-#include "absl/base/macros.h"
-#include "absl/base/nullability.h"
-#include "absl/base/optimization.h"
-#include "absl/base/port.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-class once_flag;
-
-namespace base_internal {
-absl::Nonnull<std::atomic<uint32_t> *>
-ControlWord(absl::Nonnull<absl::once_flag *> flag);
-} // namespace base_internal
-
-// call_once()
-//
-// For all invocations using a given `once_flag`, invokes a given `fn` exactly
-// once across all threads. The first call to `call_once()` with a particular
-// `once_flag` argument (that does not throw an exception) will run the
-// specified function with the provided `args`; other calls with the same
-// `once_flag` argument will not run the function, but will wait
-// for the provided function to finish running (if it is still running).
-//
-// This mechanism provides a safe, simple, and fast mechanism for one-time
-// initialization in a multi-threaded process.
-//
-// Example:
-//
-// class MyInitClass {
-//  public:
-//  ...
-//  mutable absl::once_flag once_;
-//
-//  MyInitClass* init() const {
-//    absl::call_once(once_, &MyInitClass::Init, this);
-//    return ptr_;
-//  }
-//
-template <typename Callable, typename... Args>
-void call_once(absl::once_flag &flag, Callable &&fn, Args &&...args);
-
-// once_flag
-//
-// Objects of this type are used to distinguish calls to `call_once()` and
-// ensure the provided function is only invoked once across all threads. This
-// type is not copyable or movable. However, it has a `constexpr`
-// constructor, and is safe to use as a namespace-scoped global variable.
-class once_flag {
-public:
-  constexpr once_flag() : control_(0) {}
-  once_flag(const once_flag &) = delete;
-  once_flag &operator=(const once_flag &) = delete;
-
-private:
-  friend absl::Nonnull<std::atomic<uint32_t> *>
-  base_internal::ControlWord(absl::Nonnull<once_flag *> flag);
-  std::atomic<uint32_t> control_;
-};
-
-//------------------------------------------------------------------------------
-// End of public interfaces.
-// Implementation details follow.
-//------------------------------------------------------------------------------
-
-namespace base_internal {
-
-// Like call_once, but uses KERNEL_ONLY scheduling. Intended to be used to
-// initialize entities used by the scheduler implementation.
-template <typename Callable, typename... Args>
-void LowLevelCallOnce(absl::Nonnull<absl::once_flag *> flag, Callable &&fn,
-                      Args &&...args);
-
-// Disables scheduling while on stack when scheduling mode is non-cooperative.
-// No effect for cooperative scheduling modes.
-class SchedulingHelper {
-public:
-  explicit SchedulingHelper(base_internal::SchedulingMode mode) : mode_(mode) {
-    if (mode_ == base_internal::SCHEDULE_KERNEL_ONLY) {
-      guard_result_ = base_internal::SchedulingGuard::DisableRescheduling();
-    }
-  }
-
-  ~SchedulingHelper() {
-    if (mode_ == base_internal::SCHEDULE_KERNEL_ONLY) {
-      base_internal::SchedulingGuard::EnableRescheduling(guard_result_);
-    }
-  }
-
-private:
-  base_internal::SchedulingMode mode_;
-  bool guard_result_ = false;
-};
-
-// Bit patterns for call_once state machine values.  Internal implementation
-// detail, not for use by clients.
-//
-// The bit patterns are arbitrarily chosen from unlikely values, to aid in
-// debugging.  However, kOnceInit must be 0, so that a zero-initialized
-// once_flag will be valid for immediate use.
-enum {
-  kOnceInit = 0,
-  kOnceRunning = 0x65C2937B,
-  kOnceWaiter = 0x05A308D2,
-  // A very small constant is chosen for kOnceDone so that it fit in a single
-  // compare with immediate instruction for most common ISAs.  This is verified
-  // for x86, POWER and ARM.
-  kOnceDone = 221, // Random Number
-};
-
-template <typename Callable, typename... Args>
-ABSL_ATTRIBUTE_NOINLINE void
-CallOnceImpl(absl::Nonnull<std::atomic<uint32_t> *> control,
-             base_internal::SchedulingMode scheduling_mode, Callable &&fn,
-             Args &&...args) {
-#ifndef NDEBUG
-  {
-    uint32_t old_control = control->load(std::memory_order_relaxed);
-    if (old_control != kOnceInit && old_control != kOnceRunning &&
-        old_control != kOnceWaiter && old_control != kOnceDone) {
-      ABSL_RAW_LOG(FATAL, "Unexpected value for control word: 0x%lx",
-                   static_cast<unsigned long>(old_control)); // NOLINT
-    }
-  }
-#endif // NDEBUG
-  static const base_internal::SpinLockWaitTransition trans[] = {
-      {kOnceInit, kOnceRunning, true},
-      {kOnceRunning, kOnceWaiter, false},
-      {kOnceDone, kOnceDone, true}};
-
-  // Must do this before potentially modifying control word's state.
-  base_internal::SchedulingHelper maybe_disable_scheduling(scheduling_mode);
-  // Short circuit the simplest case to avoid procedure call overhead.
-  // The base_internal::SpinLockWait() call returns either kOnceInit or
-  // kOnceDone. If it returns kOnceDone, it must have loaded the control word
-  // with std::memory_order_acquire and seen a value of kOnceDone.
-  uint32_t old_control = kOnceInit;
-  if (control->compare_exchange_strong(old_control, kOnceRunning,
-                                       std::memory_order_relaxed) ||
-      base_internal::SpinLockWait(control, ABSL_ARRAYSIZE(trans), trans,
-                                  scheduling_mode) == kOnceInit) {
-    base_internal::invoke(std::forward<Callable>(fn),
-                          std::forward<Args>(args)...);
-    old_control =
-        control->exchange(base_internal::kOnceDone, std::memory_order_release);
-    if (old_control == base_internal::kOnceWaiter) {
-      base_internal::SpinLockWake(control, true);
-    }
-  } // else *control is already kOnceDone
-}
-
-inline absl::Nonnull<std::atomic<uint32_t> *>
-ControlWord(absl::Nonnull<once_flag *> flag) {
-  return &flag->control_;
-}
-
-template <typename Callable, typename... Args>
-void LowLevelCallOnce(absl::Nonnull<absl::once_flag *> flag, Callable &&fn,
-                      Args &&...args) {
-  std::atomic<uint32_t> *once = base_internal::ControlWord(flag);
-  uint32_t s = once->load(std::memory_order_acquire);
-  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
-    base_internal::CallOnceImpl(once, base_internal::SCHEDULE_KERNEL_ONLY,
-                                std::forward<Callable>(fn),
-                                std::forward<Args>(args)...);
-  }
-}
-
-} // namespace base_internal
-
-template <typename Callable, typename... Args>
-void call_once(absl::once_flag &flag, Callable &&fn, Args &&...args) {
-  std::atomic<uint32_t> *once = base_internal::ControlWord(&flag);
-  uint32_t s = once->load(std::memory_order_acquire);
-  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
-    base_internal::CallOnceImpl(
-        once, base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL,
-        std::forward<Callable>(fn), std::forward<Args>(args)...);
-  }
-}
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_CALL_ONCE_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/casts.h b/packages/react-native-executorch/third-party/include/absl/base/casts.h
deleted file mode 100644
index 461cb8d526..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/casts.h
+++ /dev/null
@@ -1,180 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: casts.h
-// -----------------------------------------------------------------------------
-//
-// This header file defines casting templates to fit use cases not covered by
-// the standard casts provided in the C++ standard. As with all cast operations,
-// use these with caution and only if alternatives do not exist.
-
-#ifndef ABSL_BASE_CASTS_H_
-#define ABSL_BASE_CASTS_H_
-
-#include <cstring>
-#include <memory>
-#include <type_traits>
-#include <utility>
-
-#if defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L
-#include <bit> // For std::bit_cast.
-#endif         // defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L
-
-#include "absl/base/internal/identity.h"
-#include "absl/base/macros.h"
-#include "absl/meta/type_traits.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// implicit_cast()
-//
-// Performs an implicit conversion between types following the language
-// rules for implicit conversion; if an implicit conversion is otherwise
-// allowed by the language in the given context, this function performs such an
-// implicit conversion.
-//
-// Example:
-//
-//   // If the context allows implicit conversion:
-//   From from;
-//   To to = from;
-//
-//   // Such code can be replaced by:
-//   implicit_cast<To>(from);
-//
-// An `implicit_cast()` may also be used to annotate numeric type conversions
-// that, although safe, may produce compiler warnings (such as `long` to `int`).
-// Additionally, an `implicit_cast()` is also useful within return statements to
-// indicate a specific implicit conversion is being undertaken.
-//
-// Example:
-//
-//   return implicit_cast<double>(size_in_bytes) / capacity_;
-//
-// Annotating code with `implicit_cast()` allows you to explicitly select
-// particular overloads and template instantiations, while providing a safer
-// cast than `reinterpret_cast()` or `static_cast()`.
-//
-// Additionally, an `implicit_cast()` can be used to allow upcasting within a
-// type hierarchy where incorrect use of `static_cast()` could accidentally
-// allow downcasting.
-//
-// Finally, an `implicit_cast()` can be used to perform implicit conversions
-// from unrelated types that otherwise couldn't be implicitly cast directly;
-// C++ will normally only implicitly cast "one step" in such conversions.
-//
-// That is, if C is a type which can be implicitly converted to B, with B being
-// a type that can be implicitly converted to A, an `implicit_cast()` can be
-// used to convert C to B (which the compiler can then implicitly convert to A
-// using language rules).
-//
-// Example:
-//
-//   // Assume an object C is convertible to B, which is implicitly convertible
-//   // to A
-//   A a = implicit_cast<B>(C);
-//
-// Such implicit cast chaining may be useful within template logic.
-template <typename To>
-constexpr To implicit_cast(typename absl::internal::type_identity_t<To> to) {
-  return to;
-}
-
-// bit_cast()
-//
-// Creates a value of the new type `Dest` whose representation is the same as
-// that of the argument, which is of (deduced) type `Source` (a "bitwise cast";
-// every bit in the value representation of the result is equal to the
-// corresponding bit in the object representation of the source). Source and
-// destination types must be of the same size, and both types must be trivially
-// copyable.
-//
-// As with most casts, use with caution. A `bit_cast()` might be needed when you
-// need to treat a value as the value of some other type, for example, to access
-// the individual bits of an object which are not normally accessible through
-// the object's type, such as for working with the binary representation of a
-// floating point value:
-//
-//   float f = 3.14159265358979;
-//   int i = bit_cast<int>(f);
-//   // i = 0x40490fdb
-//
-// Reinterpreting and accessing a value directly as a different type (as shown
-// below) usually results in undefined behavior.
-//
-// Example:
-//
-//   // WRONG
-//   float f = 3.14159265358979;
-//   int i = reinterpret_cast<int&>(f);    // Wrong
-//   int j = *reinterpret_cast<int*>(&f);  // Equally wrong
-//   int k = *bit_cast<int*>(&f);          // Equally wrong
-//
-// Reinterpret-casting results in undefined behavior according to the ISO C++
-// specification, section [basic.lval]. Roughly, this section says: if an object
-// in memory has one type, and a program accesses it with a different type, the
-// result is undefined behavior for most "different type".
-//
-// Using bit_cast on a pointer and then dereferencing it is no better than using
-// reinterpret_cast. You should only use bit_cast on the value itself.
-//
-// Such casting results in type punning: holding an object in memory of one type
-// and reading its bits back using a different type. A `bit_cast()` avoids this
-// issue by copying the object representation to a new value, which avoids
-// introducing this undefined behavior (since the original value is never
-// accessed in the wrong way).
-//
-// The requirements of `absl::bit_cast` are more strict than that of
-// `std::bit_cast` unless compiler support is available. Specifically, without
-// compiler support, this implementation also requires `Dest` to be
-// default-constructible. In C++20, `absl::bit_cast` is replaced by
-// `std::bit_cast`.
-#if defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L
-
-using std::bit_cast;
-
-#else // defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L
-
-template <
-    typename Dest, typename Source,
-    typename std::enable_if<sizeof(Dest) == sizeof(Source) &&
-                                std::is_trivially_copyable<Source>::value &&
-                                std::is_trivially_copyable<Dest>::value
-#if !ABSL_HAVE_BUILTIN(__builtin_bit_cast)
-                                && std::is_default_constructible<Dest>::value
-#endif // !ABSL_HAVE_BUILTIN(__builtin_bit_cast)
-                            ,
-                            int>::type = 0>
-#if ABSL_HAVE_BUILTIN(__builtin_bit_cast)
-inline constexpr Dest bit_cast(const Source &source) {
-  return __builtin_bit_cast(Dest, source);
-}
-#else  // ABSL_HAVE_BUILTIN(__builtin_bit_cast)
-inline Dest bit_cast(const Source &source) {
-  Dest dest;
-  memcpy(static_cast<void *>(std::addressof(dest)),
-         static_cast<const void *>(std::addressof(source)), sizeof(dest));
-  return dest;
-}
-#endif // ABSL_HAVE_BUILTIN(__builtin_bit_cast)
-
-#endif // defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_CASTS_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/config.h b/packages/react-native-executorch/third-party/include/absl/base/config.h
deleted file mode 100644
index d1bb2606d8..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/config.h
+++ /dev/null
@@ -1,984 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: config.h
-// -----------------------------------------------------------------------------
-//
-// This header file defines a set of macros for checking the presence of
-// important compiler and platform features. Such macros can be used to
-// produce portable code by parameterizing compilation based on the presence or
-// lack of a given feature.
-//
-// We define a "feature" as some interface we wish to program to: for example,
-// a library function or system call. A value of `1` indicates support for
-// that feature; any other value indicates the feature support is undefined.
-//
-// Example:
-//
-// Suppose a programmer wants to write a program that uses the 'mmap()' system
-// call. The Abseil macro for that feature (`ABSL_HAVE_MMAP`) allows you to
-// selectively include the `mmap.h` header and bracket code using that feature
-// in the macro:
-//
-//   #include "absl/base/config.h"
-//
-//   #ifdef ABSL_HAVE_MMAP
-//   #include "sys/mman.h"
-//   #endif  //ABSL_HAVE_MMAP
-//
-//   ...
-//   #ifdef ABSL_HAVE_MMAP
-//   void *ptr = mmap(...);
-//   ...
-//   #endif  // ABSL_HAVE_MMAP
-
-#ifndef ABSL_BASE_CONFIG_H_
-#define ABSL_BASE_CONFIG_H_
-
-// Included for the __GLIBC__ macro (or similar macros on other systems).
-#include <limits.h>
-
-#ifdef __cplusplus
-// Included for __GLIBCXX__, _LIBCPP_VERSION
-#include <cstddef>
-#endif // __cplusplus
-
-// ABSL_INTERNAL_CPLUSPLUS_LANG
-//
-// MSVC does not set the value of __cplusplus correctly, but instead uses
-// _MSVC_LANG as a stand-in.
-// https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros
-//
-// However, there are reports that MSVC even sets _MSVC_LANG incorrectly at
-// times, for example:
-// https://github.com/microsoft/vscode-cpptools/issues/1770
-// https://reviews.llvm.org/D70996
-//
-// For this reason, this symbol is considered INTERNAL and code outside of
-// Abseil must not use it.
-#if defined(_MSVC_LANG)
-#define ABSL_INTERNAL_CPLUSPLUS_LANG _MSVC_LANG
-#elif defined(__cplusplus)
-#define ABSL_INTERNAL_CPLUSPLUS_LANG __cplusplus
-#endif
-
-#if defined(ABSL_INTERNAL_CPLUSPLUS_LANG) &&                                   \
-    ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
-// Include library feature test macros.
-#include <version>
-#endif
-
-#if defined(__APPLE__)
-// Included for TARGET_OS_IPHONE, __IPHONE_OS_VERSION_MIN_REQUIRED,
-// __IPHONE_8_0.
-#include <Availability.h>
-#include <TargetConditionals.h>
-#endif
-
-#include "absl/base/options.h"
-#include "absl/base/policy_checks.h"
-
-// Abseil long-term support (LTS) releases will define
-// `ABSL_LTS_RELEASE_VERSION` to the integer representing the date string of the
-// LTS release version, and will define `ABSL_LTS_RELEASE_PATCH_LEVEL` to the
-// integer representing the patch-level for that release.
-//
-// For example, for LTS release version "20300401.2", this would give us
-// ABSL_LTS_RELEASE_VERSION == 20300401 && ABSL_LTS_RELEASE_PATCH_LEVEL == 2
-//
-// These symbols will not be defined in non-LTS code.
-//
-// Abseil recommends that clients live-at-head. Therefore, if you are using
-// these symbols to assert a minimum version requirement, we recommend you do it
-// as
-//
-// #if defined(ABSL_LTS_RELEASE_VERSION) && ABSL_LTS_RELEASE_VERSION < 20300401
-// #error Project foo requires Abseil LTS version >= 20300401
-// #endif
-//
-// The `defined(ABSL_LTS_RELEASE_VERSION)` part of the check excludes
-// live-at-head clients from the minimum version assertion.
-//
-// See https://abseil.io/about/releases for more information on Abseil release
-// management.
-//
-// LTS releases can be obtained from
-// https://github.com/abseil/abseil-cpp/releases.
-#undef ABSL_LTS_RELEASE_VERSION
-#undef ABSL_LTS_RELEASE_PATCH_LEVEL
-
-// Helper macro to convert a CPP variable to a string literal.
-#define ABSL_INTERNAL_DO_TOKEN_STR(x) #x
-#define ABSL_INTERNAL_TOKEN_STR(x) ABSL_INTERNAL_DO_TOKEN_STR(x)
-
-// -----------------------------------------------------------------------------
-// Abseil namespace annotations
-// -----------------------------------------------------------------------------
-
-// ABSL_NAMESPACE_BEGIN/ABSL_NAMESPACE_END
-//
-// An annotation placed at the beginning/end of each `namespace absl` scope.
-// This is used to inject an inline namespace.
-//
-// The proper way to write Abseil code in the `absl` namespace is:
-//
-// namespace absl {
-// ABSL_NAMESPACE_BEGIN
-//
-// void Foo();  // absl::Foo().
-//
-// ABSL_NAMESPACE_END
-// }  // namespace absl
-//
-// Users of Abseil should not use these macros, because users of Abseil should
-// not write `namespace absl {` in their own code for any reason.  (Abseil does
-// not support forward declarations of its own types, nor does it support
-// user-provided specialization of Abseil templates.  Code that violates these
-// rules may be broken without warning.)
-#if !defined(ABSL_OPTION_USE_INLINE_NAMESPACE) ||                              \
-    !defined(ABSL_OPTION_INLINE_NAMESPACE_NAME)
-#error options.h is misconfigured.
-#endif
-
-// Check that ABSL_OPTION_INLINE_NAMESPACE_NAME is neither "head" nor ""
-#if defined(__cplusplus) && ABSL_OPTION_USE_INLINE_NAMESPACE == 1
-
-#define ABSL_INTERNAL_INLINE_NAMESPACE_STR                                     \
-  ABSL_INTERNAL_TOKEN_STR(ABSL_OPTION_INLINE_NAMESPACE_NAME)
-
-static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != '\0',
-              "options.h misconfigured: ABSL_OPTION_INLINE_NAMESPACE_NAME must "
-              "not be empty.");
-static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
-                  ABSL_INTERNAL_INLINE_NAMESPACE_STR[1] != 'e' ||
-                  ABSL_INTERNAL_INLINE_NAMESPACE_STR[2] != 'a' ||
-                  ABSL_INTERNAL_INLINE_NAMESPACE_STR[3] != 'd' ||
-                  ABSL_INTERNAL_INLINE_NAMESPACE_STR[4] != '\0',
-              "options.h misconfigured: ABSL_OPTION_INLINE_NAMESPACE_NAME must "
-              "be changed to a new, unique identifier name.");
-
-#endif
-
-#if ABSL_OPTION_USE_INLINE_NAMESPACE == 0
-#define ABSL_NAMESPACE_BEGIN
-#define ABSL_NAMESPACE_END
-#define ABSL_INTERNAL_C_SYMBOL(x) x
-#elif ABSL_OPTION_USE_INLINE_NAMESPACE == 1
-#define ABSL_NAMESPACE_BEGIN                                                   \
-  inline namespace ABSL_OPTION_INLINE_NAMESPACE_NAME {
-#define ABSL_NAMESPACE_END }
-#define ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v) x##_##v
-#define ABSL_INTERNAL_C_SYMBOL_HELPER_1(x, v)                                  \
-  ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v)
-#define ABSL_INTERNAL_C_SYMBOL(x)                                              \
-  ABSL_INTERNAL_C_SYMBOL_HELPER_1(x, ABSL_OPTION_INLINE_NAMESPACE_NAME)
-#else
-#error options.h is misconfigured.
-#endif
-
-// -----------------------------------------------------------------------------
-// Compiler Feature Checks
-// -----------------------------------------------------------------------------
-
-// ABSL_HAVE_BUILTIN()
-//
-// Checks whether the compiler supports a Clang Feature Checking Macro, and if
-// so, checks whether it supports the provided builtin function "x" where x
-// is one of the functions noted in
-// https://clang.llvm.org/docs/LanguageExtensions.html
-//
-// Note: Use this macro to avoid an extra level of #ifdef __has_builtin check.
-// http://releases.llvm.org/3.3/tools/clang/docs/LanguageExtensions.html
-#ifdef __has_builtin
-#define ABSL_HAVE_BUILTIN(x) __has_builtin(x)
-#else
-#define ABSL_HAVE_BUILTIN(x) 0
-#endif
-
-#ifdef __has_feature
-#define ABSL_HAVE_FEATURE(f) __has_feature(f)
-#else
-#define ABSL_HAVE_FEATURE(f) 0
-#endif
-
-// Portable check for GCC minimum version:
-// https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html
-#if defined(__GNUC__) && defined(__GNUC_MINOR__)
-#define ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(x, y)                              \
-  (__GNUC__ > (x) || __GNUC__ == (x) && __GNUC_MINOR__ >= (y))
-#else
-#define ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(x, y) 0
-#endif
-
-#if defined(__clang__) && defined(__clang_major__) && defined(__clang_minor__)
-#define ABSL_INTERNAL_HAVE_MIN_CLANG_VERSION(x, y)                             \
-  (__clang_major__ > (x) || __clang_major__ == (x) && __clang_minor__ >= (y))
-#else
-#define ABSL_INTERNAL_HAVE_MIN_CLANG_VERSION(x, y) 0
-#endif
-
-// ABSL_HAVE_TLS is defined to 1 when __thread should be supported.
-// We assume __thread is supported on Linux when compiled with Clang or
-// compiled against libstdc++ with _GLIBCXX_HAVE_TLS defined.
-#ifdef ABSL_HAVE_TLS
-#error ABSL_HAVE_TLS cannot be directly set
-#elif (defined(__linux__)) && (defined(__clang__) || defined(_GLIBCXX_HAVE_TLS))
-#define ABSL_HAVE_TLS 1
-#endif
-
-// ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
-//
-// Checks whether `std::is_trivially_destructible<T>` is supported.
-#ifdef ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
-#error ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE cannot be directly set
-#define ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE 1
-#endif
-
-// ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
-//
-// Checks whether `std::is_trivially_default_constructible<T>` and
-// `std::is_trivially_copy_constructible<T>` are supported.
-#ifdef ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
-#error ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE cannot be directly set
-#else
-#define ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE 1
-#endif
-
-// ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
-//
-// Checks whether `std::is_trivially_copy_assignable<T>` is supported.
-#ifdef ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
-#error ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE cannot be directly set
-#else
-#define ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE 1
-#endif
-
-// ABSL_HAVE_STD_IS_TRIVIALLY_COPYABLE
-//
-// Checks whether `std::is_trivially_copyable<T>` is supported.
-#ifdef ABSL_HAVE_STD_IS_TRIVIALLY_COPYABLE
-#error ABSL_HAVE_STD_IS_TRIVIALLY_COPYABLE cannot be directly set
-#define ABSL_HAVE_STD_IS_TRIVIALLY_COPYABLE 1
-#endif
-
-// ABSL_HAVE_THREAD_LOCAL
-//
-// DEPRECATED - `thread_local` is available on all supported platforms.
-// Checks whether C++11's `thread_local` storage duration specifier is
-// supported.
-#ifdef ABSL_HAVE_THREAD_LOCAL
-#error ABSL_HAVE_THREAD_LOCAL cannot be directly set
-#else
-#define ABSL_HAVE_THREAD_LOCAL 1
-#endif
-
-// ABSL_HAVE_INTRINSIC_INT128
-//
-// Checks whether the __int128 compiler extension for a 128-bit integral type is
-// supported.
-//
-// Note: __SIZEOF_INT128__ is defined by Clang and GCC when __int128 is
-// supported, but we avoid using it in certain cases:
-// * On Clang:
-//   * Building using Clang for Windows, where the Clang runtime library has
-//     128-bit support only on LP64 architectures, but Windows is LLP64.
-// * On Nvidia's nvcc:
-//   * nvcc also defines __GNUC__ and __SIZEOF_INT128__, but not all versions
-//     actually support __int128.
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-#error ABSL_HAVE_INTRINSIC_INT128 cannot be directly set
-#elif defined(__SIZEOF_INT128__)
-#if (defined(__clang__) && !defined(_WIN32)) ||                                \
-    (defined(__CUDACC__) && __CUDACC_VER_MAJOR__ >= 9) ||                      \
-    (defined(__GNUC__) && !defined(__clang__) && !defined(__CUDACC__))
-#define ABSL_HAVE_INTRINSIC_INT128 1
-#elif defined(__CUDACC__)
-// __CUDACC_VER__ is a full version number before CUDA 9, and is defined to a
-// string explaining that it has been removed starting with CUDA 9. We use
-// nested #ifs because there is no short-circuiting in the preprocessor.
-// NOTE: `__CUDACC__` could be undefined while `__CUDACC_VER__` is defined.
-#if __CUDACC_VER__ >= 70000
-#define ABSL_HAVE_INTRINSIC_INT128 1
-#endif // __CUDACC_VER__ >= 70000
-#endif // defined(__CUDACC__)
-#endif // ABSL_HAVE_INTRINSIC_INT128
-
-// ABSL_HAVE_EXCEPTIONS
-//
-// Checks whether the compiler both supports and enables exceptions. Many
-// compilers support a "no exceptions" mode that disables exceptions.
-//
-// Generally, when ABSL_HAVE_EXCEPTIONS is not defined:
-//
-// * Code using `throw` and `try` may not compile.
-// * The `noexcept` specifier will still compile and behave as normal.
-// * The `noexcept` operator may still return `false`.
-//
-// For further details, consult the compiler's documentation.
-#ifdef ABSL_HAVE_EXCEPTIONS
-#error ABSL_HAVE_EXCEPTIONS cannot be directly set.
-#elif ABSL_INTERNAL_HAVE_MIN_CLANG_VERSION(3, 6)
-// Clang >= 3.6
-#if ABSL_HAVE_FEATURE(cxx_exceptions)
-#define ABSL_HAVE_EXCEPTIONS 1
-#endif // ABSL_HAVE_FEATURE(cxx_exceptions)
-#elif defined(__clang__)
-// Clang < 3.6
-// http://releases.llvm.org/3.6.0/tools/clang/docs/ReleaseNotes.html#the-exceptions-macro
-#if defined(__EXCEPTIONS) && ABSL_HAVE_FEATURE(cxx_exceptions)
-#define ABSL_HAVE_EXCEPTIONS 1
-#endif // defined(__EXCEPTIONS) && ABSL_HAVE_FEATURE(cxx_exceptions)
-// Handle remaining special cases and default to exceptions being supported.
-#elif !(defined(__GNUC__) && !defined(__cpp_exceptions)) &&                    \
-    !(defined(_MSC_VER) && !defined(_CPPUNWIND))
-#define ABSL_HAVE_EXCEPTIONS 1
-#endif
-
-// -----------------------------------------------------------------------------
-// Platform Feature Checks
-// -----------------------------------------------------------------------------
-
-// Currently supported operating systems and associated preprocessor
-// symbols:
-//
-//   Linux and Linux-derived           __linux__
-//   Android                           __ANDROID__ (implies __linux__)
-//   Linux (non-Android)               __linux__ && !__ANDROID__
-//   Darwin (macOS and iOS)            __APPLE__
-//   Akaros (http://akaros.org)        __ros__
-//   Windows                           _WIN32
-//   NaCL                              __native_client__
-//   AsmJS                             __asmjs__
-//   WebAssembly (Emscripten)          __EMSCRIPTEN__
-//   Fuchsia                           __Fuchsia__
-//
-// Note that since Android defines both __ANDROID__ and __linux__, one
-// may probe for either Linux or Android by simply testing for __linux__.
-
-// ABSL_HAVE_MMAP
-//
-// Checks whether the platform has an mmap(2) implementation as defined in
-// POSIX.1-2001.
-#ifdef ABSL_HAVE_MMAP
-#error ABSL_HAVE_MMAP cannot be directly set
-#elif defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) ||      \
-    defined(_AIX) || defined(__ros__) || defined(__native_client__) ||         \
-    defined(__asmjs__) || defined(__EMSCRIPTEN__) || defined(__Fuchsia__) ||   \
-    defined(__sun) || defined(__myriad2__) || defined(__HAIKU__) ||            \
-    defined(__OpenBSD__) || defined(__NetBSD__) || defined(__QNX__) ||         \
-    defined(__VXWORKS__) || defined(__hexagon__) || defined(__XTENSA__)
-#define ABSL_HAVE_MMAP 1
-#endif
-
-// ABSL_HAVE_PTHREAD_GETSCHEDPARAM
-//
-// Checks whether the platform implements the pthread_(get|set)schedparam(3)
-// functions as defined in POSIX.1-2001.
-#ifdef ABSL_HAVE_PTHREAD_GETSCHEDPARAM
-#error ABSL_HAVE_PTHREAD_GETSCHEDPARAM cannot be directly set
-#elif defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) ||      \
-    defined(_AIX) || defined(__ros__) || defined(__OpenBSD__) ||               \
-    defined(__NetBSD__) || defined(__VXWORKS__)
-#define ABSL_HAVE_PTHREAD_GETSCHEDPARAM 1
-#endif
-
-// ABSL_HAVE_SCHED_GETCPU
-//
-// Checks whether sched_getcpu is available.
-#ifdef ABSL_HAVE_SCHED_GETCPU
-#error ABSL_HAVE_SCHED_GETCPU cannot be directly set
-#elif defined(__linux__)
-#define ABSL_HAVE_SCHED_GETCPU 1
-#endif
-
-// ABSL_HAVE_SCHED_YIELD
-//
-// Checks whether the platform implements sched_yield(2) as defined in
-// POSIX.1-2001.
-#ifdef ABSL_HAVE_SCHED_YIELD
-#error ABSL_HAVE_SCHED_YIELD cannot be directly set
-#elif defined(__linux__) || defined(__ros__) || defined(__native_client__) ||  \
-    defined(__VXWORKS__)
-#define ABSL_HAVE_SCHED_YIELD 1
-#endif
-
-// ABSL_HAVE_SEMAPHORE_H
-//
-// Checks whether the platform supports the <semaphore.h> header and sem_init(3)
-// family of functions as standardized in POSIX.1-2001.
-//
-// Note: While Apple provides <semaphore.h> for both iOS and macOS, it is
-// explicitly deprecated and will cause build failures if enabled for those
-// platforms.  We side-step the issue by not defining it here for Apple
-// platforms.
-#ifdef ABSL_HAVE_SEMAPHORE_H
-#error ABSL_HAVE_SEMAPHORE_H cannot be directly set
-#elif defined(__linux__) || defined(__ros__) || defined(__VXWORKS__)
-#define ABSL_HAVE_SEMAPHORE_H 1
-#endif
-
-// ABSL_HAVE_ALARM
-//
-// Checks whether the platform supports the <signal.h> header and alarm(2)
-// function as standardized in POSIX.1-2001.
-#ifdef ABSL_HAVE_ALARM
-#error ABSL_HAVE_ALARM cannot be directly set
-#elif defined(__GOOGLE_GRTE_VERSION__)
-// feature tests for Google's GRTE
-#define ABSL_HAVE_ALARM 1
-#elif defined(__GLIBC__)
-// feature test for glibc
-#define ABSL_HAVE_ALARM 1
-#elif defined(_MSC_VER)
-// feature tests for Microsoft's library
-#elif defined(__MINGW32__)
-// mingw32 doesn't provide alarm(2):
-// https://osdn.net/projects/mingw/scm/git/mingw-org-wsl/blobs/5.2-trunk/mingwrt/include/unistd.h
-// mingw-w64 provides a no-op implementation:
-// https://sourceforge.net/p/mingw-w64/mingw-w64/ci/master/tree/mingw-w64-crt/misc/alarm.c
-#elif defined(__EMSCRIPTEN__)
-// emscripten doesn't support signals
-#elif defined(__wasi__)
-// WASI doesn't support signals
-#elif defined(__Fuchsia__)
-// Signals don't exist on fuchsia.
-#elif defined(__native_client__)
-// Signals don't exist on hexagon/QuRT
-#elif defined(__hexagon__)
-#else
-// other standard libraries
-#define ABSL_HAVE_ALARM 1
-#endif
-
-// ABSL_IS_LITTLE_ENDIAN
-// ABSL_IS_BIG_ENDIAN
-//
-// Checks the endianness of the platform.
-//
-// Notes: uses the built in endian macros provided by GCC (since 4.6) and
-// Clang (since 3.2); see
-// https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html.
-// Otherwise, if _WIN32, assume little endian. Otherwise, bail with an error.
-#if defined(ABSL_IS_BIG_ENDIAN)
-#error "ABSL_IS_BIG_ENDIAN cannot be directly set."
-#endif
-#if defined(ABSL_IS_LITTLE_ENDIAN)
-#error "ABSL_IS_LITTLE_ENDIAN cannot be directly set."
-#endif
-
-#if (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) &&            \
-     __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
-#define ABSL_IS_LITTLE_ENDIAN 1
-#elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) &&              \
-    __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-#define ABSL_IS_BIG_ENDIAN 1
-#elif defined(_WIN32)
-#define ABSL_IS_LITTLE_ENDIAN 1
-#else
-#error "absl endian detection needs to be set up for your compiler"
-#endif
-
-// macOS < 10.13 and iOS < 12 don't support <any>, <optional>, or <variant>
-// because the libc++ shared library shipped on the system doesn't have the
-// requisite exported symbols.  See
-// https://github.com/abseil/abseil-cpp/issues/207 and
-// https://developer.apple.com/documentation/xcode_release_notes/xcode_10_release_notes
-//
-// libc++ spells out the availability requirements in the file
-// llvm-project/libcxx/include/__config via the #define
-// _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS. The set of versions has been
-// modified a few times, via
-// https://github.com/llvm/llvm-project/commit/7fb40e1569dd66292b647f4501b85517e9247953
-// and
-// https://github.com/llvm/llvm-project/commit/0bc451e7e137c4ccadcd3377250874f641ca514a
-// The second has the actually correct versions, thus, is what we copy here.
-#if defined(__APPLE__) &&                                                      \
-    ((defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) &&                \
-      __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101300) ||               \
-     (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) &&               \
-      __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 120000) ||              \
-     (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) &&                \
-      __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 50000) ||                \
-     (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) &&                   \
-      __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 120000))
-#define ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE 1
-#else
-#define ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE 0
-#endif
-
-// ABSL_HAVE_STD_ANY
-//
-// Checks whether C++17 std::any is available.
-#ifdef ABSL_HAVE_STD_ANY
-#error "ABSL_HAVE_STD_ANY cannot be directly set."
-#elif defined(__cpp_lib_any) && __cpp_lib_any >= 201606L
-#define ABSL_HAVE_STD_ANY 1
-#elif defined(ABSL_INTERNAL_CPLUSPLUS_LANG) &&                                 \
-    ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L &&                                 \
-    !ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE
-#define ABSL_HAVE_STD_ANY 1
-#endif
-
-// ABSL_HAVE_STD_OPTIONAL
-//
-// Checks whether C++17 std::optional is available.
-#ifdef ABSL_HAVE_STD_OPTIONAL
-#error "ABSL_HAVE_STD_OPTIONAL cannot be directly set."
-#elif defined(__cpp_lib_optional) && __cpp_lib_optional >= 202106L
-#define ABSL_HAVE_STD_OPTIONAL 1
-#elif defined(ABSL_INTERNAL_CPLUSPLUS_LANG) &&                                 \
-    ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L &&                                 \
-    !ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE
-#define ABSL_HAVE_STD_OPTIONAL 1
-#endif
-
-// ABSL_HAVE_STD_VARIANT
-//
-// Checks whether C++17 std::variant is available.
-#ifdef ABSL_HAVE_STD_VARIANT
-#error "ABSL_HAVE_STD_VARIANT cannot be directly set."
-#elif defined(__cpp_lib_variant) && __cpp_lib_variant >= 201606L
-#define ABSL_HAVE_STD_VARIANT 1
-#elif defined(ABSL_INTERNAL_CPLUSPLUS_LANG) &&                                 \
-    ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L &&                                 \
-    !ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE
-#define ABSL_HAVE_STD_VARIANT 1
-#endif
-
-// ABSL_HAVE_STD_STRING_VIEW
-//
-// Checks whether C++17 std::string_view is available.
-#ifdef ABSL_HAVE_STD_STRING_VIEW
-#error "ABSL_HAVE_STD_STRING_VIEW cannot be directly set."
-#elif defined(__cpp_lib_string_view) && __cpp_lib_string_view >= 201606L
-#define ABSL_HAVE_STD_STRING_VIEW 1
-#elif defined(ABSL_INTERNAL_CPLUSPLUS_LANG) &&                                 \
-    ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
-#define ABSL_HAVE_STD_STRING_VIEW 1
-#endif
-
-// ABSL_HAVE_STD_ORDERING
-//
-// Checks whether C++20 std::{partial,weak,strong}_ordering are available.
-//
-// __cpp_lib_three_way_comparison is missing on libc++
-// (https://github.com/llvm/llvm-project/issues/73953) so treat it as defined
-// when building in C++20 mode.
-#ifdef ABSL_HAVE_STD_ORDERING
-#error "ABSL_HAVE_STD_ORDERING cannot be directly set."
-#elif (defined(__cpp_lib_three_way_comparison) &&                              \
-       __cpp_lib_three_way_comparison >= 201907L) ||                           \
-    (defined(ABSL_INTERNAL_CPLUSPLUS_LANG) &&                                  \
-     ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L)
-#define ABSL_HAVE_STD_ORDERING 1
-#endif
-
-// ABSL_USES_STD_ANY
-//
-// Indicates whether absl::any is an alias for std::any.
-#if !defined(ABSL_OPTION_USE_STD_ANY)
-#error options.h is misconfigured.
-#elif ABSL_OPTION_USE_STD_ANY == 0 ||                                          \
-    (ABSL_OPTION_USE_STD_ANY == 2 && !defined(ABSL_HAVE_STD_ANY))
-#undef ABSL_USES_STD_ANY
-#elif ABSL_OPTION_USE_STD_ANY == 1 ||                                          \
-    (ABSL_OPTION_USE_STD_ANY == 2 && defined(ABSL_HAVE_STD_ANY))
-#define ABSL_USES_STD_ANY 1
-#else
-#error options.h is misconfigured.
-#endif
-
-// ABSL_USES_STD_OPTIONAL
-//
-// Indicates whether absl::optional is an alias for std::optional.
-#if !defined(ABSL_OPTION_USE_STD_OPTIONAL)
-#error options.h is misconfigured.
-#elif ABSL_OPTION_USE_STD_OPTIONAL == 0 ||                                     \
-    (ABSL_OPTION_USE_STD_OPTIONAL == 2 && !defined(ABSL_HAVE_STD_OPTIONAL))
-#undef ABSL_USES_STD_OPTIONAL
-#elif ABSL_OPTION_USE_STD_OPTIONAL == 1 ||                                     \
-    (ABSL_OPTION_USE_STD_OPTIONAL == 2 && defined(ABSL_HAVE_STD_OPTIONAL))
-#define ABSL_USES_STD_OPTIONAL 1
-#else
-#error options.h is misconfigured.
-#endif
-
-// ABSL_USES_STD_VARIANT
-//
-// Indicates whether absl::variant is an alias for std::variant.
-#if !defined(ABSL_OPTION_USE_STD_VARIANT)
-#error options.h is misconfigured.
-#elif ABSL_OPTION_USE_STD_VARIANT == 0 ||                                      \
-    (ABSL_OPTION_USE_STD_VARIANT == 2 && !defined(ABSL_HAVE_STD_VARIANT))
-#undef ABSL_USES_STD_VARIANT
-#elif ABSL_OPTION_USE_STD_VARIANT == 1 ||                                      \
-    (ABSL_OPTION_USE_STD_VARIANT == 2 && defined(ABSL_HAVE_STD_VARIANT))
-#define ABSL_USES_STD_VARIANT 1
-#else
-#error options.h is misconfigured.
-#endif
-
-// ABSL_USES_STD_STRING_VIEW
-//
-// Indicates whether absl::string_view is an alias for std::string_view.
-#if !defined(ABSL_OPTION_USE_STD_STRING_VIEW)
-#error options.h is misconfigured.
-#elif ABSL_OPTION_USE_STD_STRING_VIEW == 0 ||                                  \
-    (ABSL_OPTION_USE_STD_STRING_VIEW == 2 &&                                   \
-     !defined(ABSL_HAVE_STD_STRING_VIEW))
-#undef ABSL_USES_STD_STRING_VIEW
-#elif ABSL_OPTION_USE_STD_STRING_VIEW == 1 ||                                  \
-    (ABSL_OPTION_USE_STD_STRING_VIEW == 2 &&                                   \
-     defined(ABSL_HAVE_STD_STRING_VIEW))
-#define ABSL_USES_STD_STRING_VIEW 1
-#else
-#error options.h is misconfigured.
-#endif
-
-// ABSL_USES_STD_ORDERING
-//
-// Indicates whether absl::{partial,weak,strong}_ordering are aliases for the
-// std:: ordering types.
-#if !defined(ABSL_OPTION_USE_STD_ORDERING)
-#error options.h is misconfigured.
-#elif ABSL_OPTION_USE_STD_ORDERING == 0 ||                                     \
-    (ABSL_OPTION_USE_STD_ORDERING == 2 && !defined(ABSL_HAVE_STD_ORDERING))
-#undef ABSL_USES_STD_ORDERING
-#elif ABSL_OPTION_USE_STD_ORDERING == 1 ||                                     \
-    (ABSL_OPTION_USE_STD_ORDERING == 2 && defined(ABSL_HAVE_STD_ORDERING))
-#define ABSL_USES_STD_ORDERING 1
-#else
-#error options.h is misconfigured.
-#endif
-
-// In debug mode, MSVC 2017's std::variant throws a EXCEPTION_ACCESS_VIOLATION
-// SEH exception from emplace for variant<SomeStruct> when constructing the
-// struct can throw. This defeats some of variant_test and
-// variant_exception_safety_test.
-#if defined(_MSC_VER) && _MSC_VER >= 1700 && defined(_DEBUG)
-#define ABSL_INTERNAL_MSVC_2017_DBG_MODE
-#endif
-
-// ABSL_INTERNAL_MANGLED_NS
-// ABSL_INTERNAL_MANGLED_BACKREFERENCE
-//
-// Internal macros for building up mangled names in our internal fork of CCTZ.
-// This implementation detail is only needed and provided for the MSVC build.
-//
-// These macros both expand to string literals.  ABSL_INTERNAL_MANGLED_NS is
-// the mangled spelling of the `absl` namespace, and
-// ABSL_INTERNAL_MANGLED_BACKREFERENCE is a back-reference integer representing
-// the proper count to skip past the CCTZ fork namespace names.  (This number
-// is one larger when there is an inline namespace name to skip.)
-#if defined(_MSC_VER)
-#if ABSL_OPTION_USE_INLINE_NAMESPACE == 0
-#define ABSL_INTERNAL_MANGLED_NS "absl"
-#define ABSL_INTERNAL_MANGLED_BACKREFERENCE "5"
-#else
-#define ABSL_INTERNAL_MANGLED_NS                                               \
-  ABSL_INTERNAL_TOKEN_STR(ABSL_OPTION_INLINE_NAMESPACE_NAME) "@absl"
-#define ABSL_INTERNAL_MANGLED_BACKREFERENCE "6"
-#endif
-#endif
-
-// ABSL_DLL
-//
-// When building Abseil as a DLL, this macro expands to `__declspec(dllexport)`
-// so we can annotate symbols appropriately as being exported. When used in
-// headers consuming a DLL, this macro expands to `__declspec(dllimport)` so
-// that consumers know the symbol is defined inside the DLL. In all other cases,
-// the macro expands to nothing.
-#if defined(_MSC_VER)
-#if defined(ABSL_BUILD_DLL)
-#define ABSL_DLL __declspec(dllexport)
-#elif defined(ABSL_CONSUME_DLL)
-#define ABSL_DLL __declspec(dllimport)
-#else
-#define ABSL_DLL
-#endif
-#else
-#define ABSL_DLL
-#endif // defined(_MSC_VER)
-
-#if defined(_MSC_VER)
-#if defined(ABSL_BUILD_TEST_DLL)
-#define ABSL_TEST_DLL __declspec(dllexport)
-#elif defined(ABSL_CONSUME_TEST_DLL)
-#define ABSL_TEST_DLL __declspec(dllimport)
-#else
-#define ABSL_TEST_DLL
-#endif
-#else
-#define ABSL_TEST_DLL
-#endif // defined(_MSC_VER)
-
-// ABSL_HAVE_MEMORY_SANITIZER
-//
-// MemorySanitizer (MSan) is a detector of uninitialized reads. It consists of
-// a compiler instrumentation module and a run-time library.
-#ifdef ABSL_HAVE_MEMORY_SANITIZER
-#error "ABSL_HAVE_MEMORY_SANITIZER cannot be directly set."
-#elif !defined(__native_client__) && ABSL_HAVE_FEATURE(memory_sanitizer)
-#define ABSL_HAVE_MEMORY_SANITIZER 1
-#endif
-
-// ABSL_HAVE_THREAD_SANITIZER
-//
-// ThreadSanitizer (TSan) is a fast data race detector.
-#ifdef ABSL_HAVE_THREAD_SANITIZER
-#error "ABSL_HAVE_THREAD_SANITIZER cannot be directly set."
-#elif defined(__SANITIZE_THREAD__)
-#define ABSL_HAVE_THREAD_SANITIZER 1
-#elif ABSL_HAVE_FEATURE(thread_sanitizer)
-#define ABSL_HAVE_THREAD_SANITIZER 1
-#endif
-
-// ABSL_HAVE_ADDRESS_SANITIZER
-//
-// AddressSanitizer (ASan) is a fast memory error detector.
-#ifdef ABSL_HAVE_ADDRESS_SANITIZER
-#error "ABSL_HAVE_ADDRESS_SANITIZER cannot be directly set."
-#elif defined(__SANITIZE_ADDRESS__)
-#define ABSL_HAVE_ADDRESS_SANITIZER 1
-#elif ABSL_HAVE_FEATURE(address_sanitizer)
-#define ABSL_HAVE_ADDRESS_SANITIZER 1
-#endif
-
-// ABSL_HAVE_HWADDRESS_SANITIZER
-//
-// Hardware-Assisted AddressSanitizer (or HWASAN) is even faster than asan
-// memory error detector which can use CPU features like ARM TBI, Intel LAM or
-// AMD UAI.
-#ifdef ABSL_HAVE_HWADDRESS_SANITIZER
-#error "ABSL_HAVE_HWADDRESS_SANITIZER cannot be directly set."
-#elif defined(__SANITIZE_HWADDRESS__)
-#define ABSL_HAVE_HWADDRESS_SANITIZER 1
-#elif ABSL_HAVE_FEATURE(hwaddress_sanitizer)
-#define ABSL_HAVE_HWADDRESS_SANITIZER 1
-#endif
-
-// ABSL_HAVE_DATAFLOW_SANITIZER
-//
-// Dataflow Sanitizer (or DFSAN) is a generalised dynamic data flow analysis.
-#ifdef ABSL_HAVE_DATAFLOW_SANITIZER
-#error "ABSL_HAVE_DATAFLOW_SANITIZER cannot be directly set."
-#elif defined(DATAFLOW_SANITIZER)
-// GCC provides no method for detecting the presence of the standalone
-// DataFlowSanitizer (-fsanitize=dataflow), so GCC users of -fsanitize=dataflow
-// should also use -DDATAFLOW_SANITIZER.
-#define ABSL_HAVE_DATAFLOW_SANITIZER 1
-#elif ABSL_HAVE_FEATURE(dataflow_sanitizer)
-#define ABSL_HAVE_DATAFLOW_SANITIZER 1
-#endif
-
-// ABSL_HAVE_LEAK_SANITIZER
-//
-// LeakSanitizer (or lsan) is a detector of memory leaks.
-// https://clang.llvm.org/docs/LeakSanitizer.html
-// https://github.com/google/sanitizers/wiki/AddressSanitizerLeakSanitizer
-//
-// The macro ABSL_HAVE_LEAK_SANITIZER can be used to detect at compile-time
-// whether the LeakSanitizer is potentially available. However, just because the
-// LeakSanitizer is available does not mean it is active. Use the
-// always-available run-time interface in //absl/debugging/leak_check.h for
-// interacting with LeakSanitizer.
-#ifdef ABSL_HAVE_LEAK_SANITIZER
-#error "ABSL_HAVE_LEAK_SANITIZER cannot be directly set."
-#elif defined(LEAK_SANITIZER)
-// GCC provides no method for detecting the presence of the standalone
-// LeakSanitizer (-fsanitize=leak), so GCC users of -fsanitize=leak should also
-// use -DLEAK_SANITIZER.
-#define ABSL_HAVE_LEAK_SANITIZER 1
-// Clang standalone LeakSanitizer (-fsanitize=leak)
-#elif ABSL_HAVE_FEATURE(leak_sanitizer)
-#define ABSL_HAVE_LEAK_SANITIZER 1
-#elif defined(ABSL_HAVE_ADDRESS_SANITIZER)
-// GCC or Clang using the LeakSanitizer integrated into AddressSanitizer.
-#define ABSL_HAVE_LEAK_SANITIZER 1
-#endif
-
-// ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION
-//
-// Class template argument deduction is a language feature added in C++17.
-#ifdef ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION
-#error "ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION cannot be directly set."
-#elif defined(__cpp_deduction_guides)
-#define ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION 1
-#endif
-
-// ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-//
-// Prior to C++17, static constexpr variables defined in classes required a
-// separate definition outside of the class body, for example:
-//
-// class Foo {
-//   static constexpr int kBar = 0;
-// };
-// constexpr int Foo::kBar;
-//
-// In C++17, these variables defined in classes are considered inline variables,
-// and the extra declaration is redundant. Since some compilers warn on the
-// extra declarations, ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL can be used
-// conditionally ignore them:
-//
-// #ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-// constexpr int Foo::kBar;
-// #endif
-#if defined(ABSL_INTERNAL_CPLUSPLUS_LANG) &&                                   \
-    ABSL_INTERNAL_CPLUSPLUS_LANG < 201703L
-#define ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL 1
-#endif
-
-// `ABSL_INTERNAL_HAS_RTTI` determines whether abseil is being compiled with
-// RTTI support.
-#ifdef ABSL_INTERNAL_HAS_RTTI
-#error ABSL_INTERNAL_HAS_RTTI cannot be directly set
-#elif ABSL_HAVE_FEATURE(cxx_rtti)
-#define ABSL_INTERNAL_HAS_RTTI 1
-#elif defined(__GNUC__) && defined(__GXX_RTTI)
-#define ABSL_INTERNAL_HAS_RTTI 1
-#elif defined(_MSC_VER) && defined(_CPPRTTI)
-#define ABSL_INTERNAL_HAS_RTTI 1
-#elif !defined(__GNUC__) && !defined(_MSC_VER)
-// Unknown compiler, default to RTTI
-#define ABSL_INTERNAL_HAS_RTTI 1
-#endif
-
-// `ABSL_INTERNAL_HAS_CXA_DEMANGLE` determines whether `abi::__cxa_demangle` is
-// available.
-#ifdef ABSL_INTERNAL_HAS_CXA_DEMANGLE
-#error ABSL_INTERNAL_HAS_CXA_DEMANGLE cannot be directly set
-#elif defined(OS_ANDROID) && (defined(__i386__) || defined(__x86_64__))
-#define ABSL_INTERNAL_HAS_CXA_DEMANGLE 0
-#elif defined(__GNUC__)
-#define ABSL_INTERNAL_HAS_CXA_DEMANGLE 1
-#elif defined(__clang__) && !defined(_MSC_VER)
-#define ABSL_INTERNAL_HAS_CXA_DEMANGLE 1
-#endif
-
-// ABSL_INTERNAL_HAVE_SSE is used for compile-time detection of SSE support.
-// See https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html for an overview of
-// which architectures support the various x86 instruction sets.
-#ifdef ABSL_INTERNAL_HAVE_SSE
-#error ABSL_INTERNAL_HAVE_SSE cannot be directly set
-#elif defined(__SSE__)
-#define ABSL_INTERNAL_HAVE_SSE 1
-#elif (defined(_M_X64) || (defined(_M_IX86_FP) && _M_IX86_FP >= 1)) &&         \
-    !defined(_M_ARM64EC)
-// MSVC only defines _M_IX86_FP for x86 32-bit code, and _M_IX86_FP >= 1
-// indicates that at least SSE was targeted with the /arch:SSE option.
-// All x86-64 processors support SSE, so support can be assumed.
-// https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros
-#define ABSL_INTERNAL_HAVE_SSE 1
-#endif
-
-// ABSL_INTERNAL_HAVE_SSE2 is used for compile-time detection of SSE2 support.
-// See https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html for an overview of
-// which architectures support the various x86 instruction sets.
-#ifdef ABSL_INTERNAL_HAVE_SSE2
-#error ABSL_INTERNAL_HAVE_SSE2 cannot be directly set
-#elif defined(__SSE2__)
-#define ABSL_INTERNAL_HAVE_SSE2 1
-#elif (defined(_M_X64) || (defined(_M_IX86_FP) && _M_IX86_FP >= 2)) &&         \
-    !defined(_M_ARM64EC)
-// MSVC only defines _M_IX86_FP for x86 32-bit code, and _M_IX86_FP >= 2
-// indicates that at least SSE2 was targeted with the /arch:SSE2 option.
-// All x86-64 processors support SSE2, so support can be assumed.
-// https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros
-#define ABSL_INTERNAL_HAVE_SSE2 1
-#endif
-
-// ABSL_INTERNAL_HAVE_SSSE3 is used for compile-time detection of SSSE3 support.
-// See https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html for an overview of
-// which architectures support the various x86 instruction sets.
-//
-// MSVC does not have a mode that targets SSSE3 at compile-time. To use SSSE3
-// with MSVC requires either assuming that the code will only every run on CPUs
-// that support SSSE3, otherwise __cpuid() can be used to detect support at
-// runtime and fallback to a non-SSSE3 implementation when SSSE3 is unsupported
-// by the CPU.
-#ifdef ABSL_INTERNAL_HAVE_SSSE3
-#error ABSL_INTERNAL_HAVE_SSSE3 cannot be directly set
-#elif defined(__SSSE3__)
-#define ABSL_INTERNAL_HAVE_SSSE3 1
-#endif
-
-// ABSL_INTERNAL_HAVE_ARM_NEON is used for compile-time detection of NEON (ARM
-// SIMD).
-//
-// If __CUDA_ARCH__ is defined, then we are compiling CUDA code in device mode.
-// In device mode, NEON intrinsics are not available, regardless of host
-// platform.
-// https://llvm.org/docs/CompileCudaWithLLVM.html#detecting-clang-vs-nvcc-from-code
-#ifdef ABSL_INTERNAL_HAVE_ARM_NEON
-#error ABSL_INTERNAL_HAVE_ARM_NEON cannot be directly set
-#elif defined(__ARM_NEON) && !(defined(__NVCC__) && defined(__CUDACC__))
-#define ABSL_INTERNAL_HAVE_ARM_NEON 1
-#endif
-
-// ABSL_HAVE_CONSTANT_EVALUATED is used for compile-time detection of
-// constant evaluation support through `absl::is_constant_evaluated`.
-#ifdef ABSL_HAVE_CONSTANT_EVALUATED
-#error ABSL_HAVE_CONSTANT_EVALUATED cannot be directly set
-#endif
-#ifdef __cpp_lib_is_constant_evaluated
-#define ABSL_HAVE_CONSTANT_EVALUATED 1
-#elif ABSL_HAVE_BUILTIN(__builtin_is_constant_evaluated)
-#define ABSL_HAVE_CONSTANT_EVALUATED 1
-#endif
-
-// ABSL_INTERNAL_CONSTEXPR_SINCE_CXXYY is used to conditionally define constexpr
-// for different C++ versions.
-//
-// These macros are an implementation detail and will be unconditionally removed
-// once the minimum supported C++ version catches up to a given version.
-//
-// For this reason, this symbol is considered INTERNAL and code outside of
-// Abseil must not use it.
-#if defined(ABSL_INTERNAL_CPLUSPLUS_LANG) &&                                   \
-    ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
-#define ABSL_INTERNAL_CONSTEXPR_SINCE_CXX17 constexpr
-#else
-#define ABSL_INTERNAL_CONSTEXPR_SINCE_CXX17
-#endif
-#if defined(ABSL_INTERNAL_CPLUSPLUS_LANG) &&                                   \
-    ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
-#define ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 constexpr
-#else
-#define ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
-#endif
-
-// ABSL_INTERNAL_EMSCRIPTEN_VERSION combines Emscripten's three version macros
-// into an integer that can be compared against.
-#ifdef ABSL_INTERNAL_EMSCRIPTEN_VERSION
-#error ABSL_INTERNAL_EMSCRIPTEN_VERSION cannot be directly set
-#endif
-#ifdef __EMSCRIPTEN__
-#include <emscripten/version.h>
-#ifdef __EMSCRIPTEN_major__
-#if __EMSCRIPTEN_minor__ >= 1000
-#error __EMSCRIPTEN_minor__ is too big to fit in ABSL_INTERNAL_EMSCRIPTEN_VERSION
-#endif
-#if __EMSCRIPTEN_tiny__ >= 1000
-#error __EMSCRIPTEN_tiny__ is too big to fit in ABSL_INTERNAL_EMSCRIPTEN_VERSION
-#endif
-#define ABSL_INTERNAL_EMSCRIPTEN_VERSION                                       \
-  ((__EMSCRIPTEN_major__) * 1000000 + (__EMSCRIPTEN_minor__) * 1000 +          \
-   (__EMSCRIPTEN_tiny__))
-#endif
-#endif
-
-#endif // ABSL_BASE_CONFIG_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/const_init.h b/packages/react-native-executorch/third-party/include/absl/base/const_init.h
deleted file mode 100644
index 96bef4dd37..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/const_init.h
+++ /dev/null
@@ -1,76 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// kConstInit
-// -----------------------------------------------------------------------------
-//
-// A constructor tag used to mark an object as safe for use as a global
-// variable, avoiding the usual lifetime issues that can affect globals.
-
-#ifndef ABSL_BASE_CONST_INIT_H_
-#define ABSL_BASE_CONST_INIT_H_
-
-#include "absl/base/config.h"
-
-// In general, objects with static storage duration (such as global variables)
-// can trigger tricky object lifetime situations.  Attempting to access them
-// from the constructors or destructors of other global objects can result in
-// undefined behavior, unless their constructors and destructors are designed
-// with this issue in mind.
-//
-// The normal way to deal with this issue in C++11 is to use constant
-// initialization and trivial destructors.
-//
-// Constant initialization is guaranteed to occur before any other code
-// executes.  Constructors that are declared 'constexpr' are eligible for
-// constant initialization.  You can annotate a variable declaration with the
-// ABSL_CONST_INIT macro to express this intent.  For compilers that support
-// it, this annotation will cause a compilation error for declarations that
-// aren't subject to constant initialization (perhaps because a runtime value
-// was passed as a constructor argument).
-//
-// On program shutdown, lifetime issues can be avoided on global objects by
-// ensuring that they contain  trivial destructors.  A class has a trivial
-// destructor unless it has a user-defined destructor, a virtual method or base
-// class, or a data member or base class with a non-trivial destructor of its
-// own.  Objects with static storage duration and a trivial destructor are not
-// cleaned up on program shutdown, and are thus safe to access from other code
-// running during shutdown.
-//
-// For a few core Abseil classes, we make a best effort to allow for safe global
-// instances, even though these classes have non-trivial destructors.  These
-// objects can be created with the absl::kConstInit tag.  For example:
-//   ABSL_CONST_INIT absl::Mutex global_mutex(absl::kConstInit);
-//
-// The line above declares a global variable of type absl::Mutex which can be
-// accessed at any point during startup or shutdown.  global_mutex's destructor
-// will still run, but will not invalidate the object.  Note that C++ specifies
-// that accessing an object after its destructor has run results in undefined
-// behavior, but this pattern works on the toolchains we support.
-//
-// The absl::kConstInit tag should only be used to define objects with static
-// or thread_local storage duration.
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-enum ConstInitType {
-  kConstInit,
-};
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_CONST_INIT_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/dynamic_annotations.h b/packages/react-native-executorch/third-party/include/absl/base/dynamic_annotations.h
deleted file mode 100644
index 5deb2f2ce4..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/dynamic_annotations.h
+++ /dev/null
@@ -1,476 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// This file defines dynamic annotations for use with dynamic analysis tool
-// such as valgrind, PIN, etc.
-//
-// Dynamic annotation is a source code annotation that affects the generated
-// code (that is, the annotation is not a comment). Each such annotation is
-// attached to a particular instruction and/or to a particular object (address)
-// in the program.
-//
-// The annotations that should be used by users are macros in all upper-case
-// (e.g., ABSL_ANNOTATE_THREAD_NAME).
-//
-// Actual implementation of these macros may differ depending on the dynamic
-// analysis tool being used.
-//
-// This file supports the following configurations:
-// - Dynamic Annotations enabled (with static thread-safety warnings disabled).
-//   In this case, macros expand to functions implemented by Thread Sanitizer,
-//   when building with TSan. When not provided an external implementation,
-//   dynamic_annotations.cc provides no-op implementations.
-//
-// - Static Clang thread-safety warnings enabled.
-//   When building with a Clang compiler that supports thread-safety warnings,
-//   a subset of annotations can be statically-checked at compile-time. We
-//   expand these macros to static-inline functions that can be analyzed for
-//   thread-safety, but afterwards elided when building the final binary.
-//
-// - All annotations are disabled.
-//   If neither Dynamic Annotations nor Clang thread-safety warnings are
-//   enabled, then all annotation-macros expand to empty.
-
-#ifndef ABSL_BASE_DYNAMIC_ANNOTATIONS_H_
-#define ABSL_BASE_DYNAMIC_ANNOTATIONS_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#ifdef __cplusplus
-#include "absl/base/macros.h"
-#endif
-
-#ifdef ABSL_HAVE_HWADDRESS_SANITIZER
-#include <sanitizer/hwasan_interface.h>
-#endif
-
-// TODO(rogeeff): Remove after the backward compatibility period.
-#include "absl/base/internal/dynamic_annotations.h" // IWYU pragma: export
-
-// -------------------------------------------------------------------------
-// Decide which features are enabled.
-
-#ifdef ABSL_HAVE_THREAD_SANITIZER
-
-#define ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED 1
-#define ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED 1
-#define ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED 1
-#define ABSL_INTERNAL_ANNOTALYSIS_ENABLED 0
-#define ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED 1
-
-#else
-
-#define ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED 0
-#define ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED 0
-#define ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED 0
-
-// Clang provides limited support for static thread-safety analysis through a
-// feature called Annotalysis. We configure macro-definitions according to
-// whether Annotalysis support is available. When running in opt-mode, GCC
-// will issue a warning, if these attributes are compiled. Only include them
-// when compiling using Clang.
-
-#if defined(__clang__)
-#define ABSL_INTERNAL_ANNOTALYSIS_ENABLED 1
-#if !defined(SWIG)
-#define ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED 1
-#endif
-#else
-#define ABSL_INTERNAL_ANNOTALYSIS_ENABLED 0
-#endif
-
-// Read/write annotations are enabled in Annotalysis mode; disabled otherwise.
-#define ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED                         \
-  ABSL_INTERNAL_ANNOTALYSIS_ENABLED
-
-#endif // ABSL_HAVE_THREAD_SANITIZER
-
-#ifdef __cplusplus
-#define ABSL_INTERNAL_BEGIN_EXTERN_C extern "C" {
-#define ABSL_INTERNAL_END_EXTERN_C } // extern "C"
-#define ABSL_INTERNAL_GLOBAL_SCOPED(F) ::F
-#define ABSL_INTERNAL_STATIC_INLINE inline
-#else
-#define ABSL_INTERNAL_BEGIN_EXTERN_C // empty
-#define ABSL_INTERNAL_END_EXTERN_C   // empty
-#define ABSL_INTERNAL_GLOBAL_SCOPED(F) F
-#define ABSL_INTERNAL_STATIC_INLINE static inline
-#endif
-
-// -------------------------------------------------------------------------
-// Define race annotations.
-
-#if ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED == 1
-// Some of the symbols used in this section (e.g. AnnotateBenignRaceSized) are
-// defined by the compiler-based sanitizer implementation, not by the Abseil
-// library. Therefore they do not use ABSL_INTERNAL_C_SYMBOL.
-
-// -------------------------------------------------------------
-// Annotations that suppress errors. It is usually better to express the
-// program's synchronization using the other annotations, but these can be used
-// when all else fails.
-
-// Report that we may have a benign race at `pointer`, with size
-// "sizeof(*(pointer))". `pointer` must be a non-void* pointer. Insert at the
-// point where `pointer` has been allocated, preferably close to the point
-// where the race happens. See also ABSL_ANNOTATE_BENIGN_RACE_STATIC.
-#define ABSL_ANNOTATE_BENIGN_RACE(pointer, description)                        \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized)                         \
-  (__FILE__, __LINE__, pointer, sizeof(*(pointer)), description)
-
-// Same as ABSL_ANNOTATE_BENIGN_RACE(`address`, `description`), but applies to
-// the memory range [`address`, `address`+`size`).
-#define ABSL_ANNOTATE_BENIGN_RACE_SIZED(address, size, description)            \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized)                         \
-  (__FILE__, __LINE__, address, size, description)
-
-// Enable (`enable`!=0) or disable (`enable`==0) race detection for all threads.
-// This annotation could be useful if you want to skip expensive race analysis
-// during some period of program execution, e.g. during initialization.
-#define ABSL_ANNOTATE_ENABLE_RACE_DETECTION(enable)                            \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateEnableRaceDetection)                     \
-  (__FILE__, __LINE__, enable)
-
-// -------------------------------------------------------------
-// Annotations useful for debugging.
-
-// Report the current thread `name` to a race detector.
-#define ABSL_ANNOTATE_THREAD_NAME(name)                                        \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateThreadName)(__FILE__, __LINE__, name)
-
-// -------------------------------------------------------------
-// Annotations useful when implementing locks. They are not normally needed by
-// modules that merely use locks. The `lock` argument is a pointer to the lock
-// object.
-
-// Report that a lock has been created at address `lock`.
-#define ABSL_ANNOTATE_RWLOCK_CREATE(lock)                                      \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreate)(__FILE__, __LINE__, lock)
-
-// Report that a linker initialized lock has been created at address `lock`.
-#ifdef ABSL_HAVE_THREAD_SANITIZER
-#define ABSL_ANNOTATE_RWLOCK_CREATE_STATIC(lock)                               \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreateStatic)                      \
-  (__FILE__, __LINE__, lock)
-#else
-#define ABSL_ANNOTATE_RWLOCK_CREATE_STATIC(lock)                               \
-  ABSL_ANNOTATE_RWLOCK_CREATE(lock)
-#endif
-
-// Report that the lock at address `lock` is about to be destroyed.
-#define ABSL_ANNOTATE_RWLOCK_DESTROY(lock)                                     \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockDestroy)(__FILE__, __LINE__, lock)
-
-// Report that the lock at address `lock` has been acquired.
-// `is_w`=1 for writer lock, `is_w`=0 for reader lock.
-#define ABSL_ANNOTATE_RWLOCK_ACQUIRED(lock, is_w)                              \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockAcquired)                          \
-  (__FILE__, __LINE__, lock, is_w)
-
-// Report that the lock at address `lock` is about to be released.
-// `is_w`=1 for writer lock, `is_w`=0 for reader lock.
-#define ABSL_ANNOTATE_RWLOCK_RELEASED(lock, is_w)                              \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockReleased)                          \
-  (__FILE__, __LINE__, lock, is_w)
-
-// Apply ABSL_ANNOTATE_BENIGN_RACE_SIZED to a static variable `static_var`.
-#define ABSL_ANNOTATE_BENIGN_RACE_STATIC(static_var, description)              \
-  namespace {                                                                  \
-  class static_var##_annotator {                                               \
-  public:                                                                      \
-    static_var##_annotator() {                                                 \
-      ABSL_ANNOTATE_BENIGN_RACE_SIZED(&static_var, sizeof(static_var),         \
-                                      #static_var ": " description);           \
-    }                                                                          \
-  };                                                                           \
-  static static_var##_annotator the##static_var##_annotator;                   \
-  } // namespace
-
-// Function prototypes of annotations provided by the compiler-based sanitizer
-// implementation.
-ABSL_INTERNAL_BEGIN_EXTERN_C
-void AnnotateRWLockCreate(const char *file, int line,
-                          const volatile void *lock);
-void AnnotateRWLockCreateStatic(const char *file, int line,
-                                const volatile void *lock);
-void AnnotateRWLockDestroy(const char *file, int line,
-                           const volatile void *lock);
-void AnnotateRWLockAcquired(const char *file, int line,
-                            const volatile void *lock, long is_w); // NOLINT
-void AnnotateRWLockReleased(const char *file, int line,
-                            const volatile void *lock, long is_w); // NOLINT
-void AnnotateBenignRace(const char *file, int line,
-                        const volatile void *address, const char *description);
-void AnnotateBenignRaceSized(const char *file, int line,
-                             const volatile void *address, size_t size,
-                             const char *description);
-void AnnotateThreadName(const char *file, int line, const char *name);
-void AnnotateEnableRaceDetection(const char *file, int line, int enable);
-ABSL_INTERNAL_END_EXTERN_C
-
-#else // ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED == 0
-
-#define ABSL_ANNOTATE_RWLOCK_CREATE(lock)                           // empty
-#define ABSL_ANNOTATE_RWLOCK_CREATE_STATIC(lock)                    // empty
-#define ABSL_ANNOTATE_RWLOCK_DESTROY(lock)                          // empty
-#define ABSL_ANNOTATE_RWLOCK_ACQUIRED(lock, is_w)                   // empty
-#define ABSL_ANNOTATE_RWLOCK_RELEASED(lock, is_w)                   // empty
-#define ABSL_ANNOTATE_BENIGN_RACE(address, description)             // empty
-#define ABSL_ANNOTATE_BENIGN_RACE_SIZED(address, size, description) // empty
-#define ABSL_ANNOTATE_THREAD_NAME(name)                             // empty
-#define ABSL_ANNOTATE_ENABLE_RACE_DETECTION(enable)                 // empty
-#define ABSL_ANNOTATE_BENIGN_RACE_STATIC(static_var, description)   // empty
-
-#endif // ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED
-
-// -------------------------------------------------------------------------
-// Define memory annotations.
-
-#ifdef ABSL_HAVE_MEMORY_SANITIZER
-
-#include <sanitizer/msan_interface.h>
-
-#define ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(address, size)                     \
-  __msan_unpoison(address, size)
-
-#define ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size)                   \
-  __msan_allocated_memory(address, size)
-
-#else // !defined(ABSL_HAVE_MEMORY_SANITIZER)
-
-#define ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(address, size)   // empty
-#define ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) // empty
-
-#endif // ABSL_HAVE_MEMORY_SANITIZER
-
-// -------------------------------------------------------------------------
-// Define IGNORE_READS_BEGIN/_END attributes.
-
-#if defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
-
-#define ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE                             \
-  __attribute((exclusive_lock_function("*")))
-#define ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE                               \
-  __attribute((unlock_function("*")))
-
-#else // !defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
-
-#define ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE // empty
-#define ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE   // empty
-
-#endif // defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
-
-// -------------------------------------------------------------------------
-// Define IGNORE_READS_BEGIN/_END annotations.
-
-#if ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED == 1
-// Some of the symbols used in this section (e.g. AnnotateIgnoreReadsBegin) are
-// defined by the compiler-based implementation, not by the Abseil
-// library. Therefore they do not use ABSL_INTERNAL_C_SYMBOL.
-
-// Request the analysis tool to ignore all reads in the current thread until
-// ABSL_ANNOTATE_IGNORE_READS_END is called. Useful to ignore intentional racey
-// reads, while still checking other reads and all writes.
-// See also ABSL_ANNOTATE_UNPROTECTED_READ.
-#define ABSL_ANNOTATE_IGNORE_READS_BEGIN()                                     \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsBegin)                        \
-  (__FILE__, __LINE__)
-
-// Stop ignoring reads.
-#define ABSL_ANNOTATE_IGNORE_READS_END()                                       \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsEnd)                          \
-  (__FILE__, __LINE__)
-
-// Function prototypes of annotations provided by the compiler-based sanitizer
-// implementation.
-ABSL_INTERNAL_BEGIN_EXTERN_C
-void AnnotateIgnoreReadsBegin(const char *file, int line)
-    ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE;
-void AnnotateIgnoreReadsEnd(const char *file,
-                            int line) ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE;
-ABSL_INTERNAL_END_EXTERN_C
-
-#elif defined(ABSL_INTERNAL_ANNOTALYSIS_ENABLED)
-
-// When Annotalysis is enabled without Dynamic Annotations, the use of
-// static-inline functions allows the annotations to be read at compile-time,
-// while still letting the compiler elide the functions from the final build.
-//
-// TODO(delesley) -- The exclusive lock here ignores writes as well, but
-// allows IGNORE_READS_AND_WRITES to work properly.
-
-#define ABSL_ANNOTATE_IGNORE_READS_BEGIN()                                     \
-  ABSL_INTERNAL_GLOBAL_SCOPED(                                                 \
-      ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsBegin))            \
-  ()
-
-#define ABSL_ANNOTATE_IGNORE_READS_END()                                       \
-  ABSL_INTERNAL_GLOBAL_SCOPED(                                                 \
-      ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsEnd))              \
-  ()
-
-ABSL_INTERNAL_STATIC_INLINE void
-ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsBegin)()
-    ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE {}
-
-ABSL_INTERNAL_STATIC_INLINE void
-ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsEnd)()
-    ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE {}
-
-#else
-
-#define ABSL_ANNOTATE_IGNORE_READS_BEGIN() // empty
-#define ABSL_ANNOTATE_IGNORE_READS_END()   // empty
-
-#endif
-
-// -------------------------------------------------------------------------
-// Define IGNORE_WRITES_BEGIN/_END annotations.
-
-#if ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED == 1
-
-// Similar to ABSL_ANNOTATE_IGNORE_READS_BEGIN, but ignore writes instead.
-#define ABSL_ANNOTATE_IGNORE_WRITES_BEGIN()                                    \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesBegin)(__FILE__, __LINE__)
-
-// Stop ignoring writes.
-#define ABSL_ANNOTATE_IGNORE_WRITES_END()                                      \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesEnd)(__FILE__, __LINE__)
-
-// Function prototypes of annotations provided by the compiler-based sanitizer
-// implementation.
-ABSL_INTERNAL_BEGIN_EXTERN_C
-void AnnotateIgnoreWritesBegin(const char *file, int line);
-void AnnotateIgnoreWritesEnd(const char *file, int line);
-ABSL_INTERNAL_END_EXTERN_C
-
-#else
-
-#define ABSL_ANNOTATE_IGNORE_WRITES_BEGIN() // empty
-#define ABSL_ANNOTATE_IGNORE_WRITES_END()   // empty
-
-#endif
-
-// -------------------------------------------------------------------------
-// Define the ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_* annotations using the more
-// primitive annotations defined above.
-//
-//     Instead of doing
-//        ABSL_ANNOTATE_IGNORE_READS_BEGIN();
-//        ... = x;
-//        ABSL_ANNOTATE_IGNORE_READS_END();
-//     one can use
-//        ... = ABSL_ANNOTATE_UNPROTECTED_READ(x);
-
-#if defined(ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED)
-
-// Start ignoring all memory accesses (both reads and writes).
-#define ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN()                          \
-  do {                                                                         \
-    ABSL_ANNOTATE_IGNORE_READS_BEGIN();                                        \
-    ABSL_ANNOTATE_IGNORE_WRITES_BEGIN();                                       \
-  } while (0)
-
-// Stop ignoring both reads and writes.
-#define ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END()                            \
-  do {                                                                         \
-    ABSL_ANNOTATE_IGNORE_WRITES_END();                                         \
-    ABSL_ANNOTATE_IGNORE_READS_END();                                          \
-  } while (0)
-
-#ifdef __cplusplus
-// ABSL_ANNOTATE_UNPROTECTED_READ is the preferred way to annotate racey reads.
-#define ABSL_ANNOTATE_UNPROTECTED_READ(x)                                      \
-  absl::base_internal::AnnotateUnprotectedRead(x)
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-template <typename T>
-inline T AnnotateUnprotectedRead(const volatile T &x) { // NOLINT
-  ABSL_ANNOTATE_IGNORE_READS_BEGIN();
-  T res = x;
-  ABSL_ANNOTATE_IGNORE_READS_END();
-  return res;
-}
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-#endif
-
-#else
-
-#define ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() // empty
-#define ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END()   // empty
-#define ABSL_ANNOTATE_UNPROTECTED_READ(x) (x)
-
-#endif
-
-// -------------------------------------------------------------------------
-// Address sanitizer annotations
-
-#ifdef ABSL_HAVE_ADDRESS_SANITIZER
-// Describe the current state of a contiguous container such as e.g.
-// std::vector or std::string. For more details see
-// sanitizer/common_interface_defs.h, which is provided by the compiler.
-#include <sanitizer/common_interface_defs.h>
-
-#define ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(beg, end, old_mid, new_mid)         \
-  __sanitizer_annotate_contiguous_container(beg, end, old_mid, new_mid)
-#define ABSL_ADDRESS_SANITIZER_REDZONE(name)                                   \
-  struct {                                                                     \
-    alignas(8) char x[8];                                                      \
-  } name
-
-#else
-
-#define ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(beg, end, old_mid, new_mid) // empty
-#define ABSL_ADDRESS_SANITIZER_REDZONE(name) static_assert(true, "")
-
-#endif // ABSL_HAVE_ADDRESS_SANITIZER
-
-// -------------------------------------------------------------------------
-// HWAddress sanitizer annotations
-
-#ifdef __cplusplus
-namespace absl {
-#ifdef ABSL_HAVE_HWADDRESS_SANITIZER
-// Under HWASAN changes the tag of the pointer.
-template <typename T> T *HwasanTagPointer(T *ptr, uintptr_t tag) {
-  return reinterpret_cast<T *>(__hwasan_tag_pointer(ptr, tag));
-}
-#else
-template <typename T> T *HwasanTagPointer(T *ptr, uintptr_t) { return ptr; }
-#endif
-} // namespace absl
-#endif
-
-// -------------------------------------------------------------------------
-// Undefine the macros intended only for this file.
-
-#undef ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED
-#undef ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED
-#undef ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED
-#undef ABSL_INTERNAL_ANNOTALYSIS_ENABLED
-#undef ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED
-#undef ABSL_INTERNAL_BEGIN_EXTERN_C
-#undef ABSL_INTERNAL_END_EXTERN_C
-#undef ABSL_INTERNAL_STATIC_INLINE
-
-#endif // ABSL_BASE_DYNAMIC_ANNOTATIONS_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/atomic_hook.h b/packages/react-native-executorch/third-party/include/absl/base/internal/atomic_hook.h
deleted file mode 100644
index e026d482c4..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/atomic_hook.h
+++ /dev/null
@@ -1,197 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_BASE_INTERNAL_ATOMIC_HOOK_H_
-#define ABSL_BASE_INTERNAL_ATOMIC_HOOK_H_
-
-#include <atomic>
-#include <cassert>
-#include <cstdint>
-#include <utility>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-
-#if defined(_MSC_VER) && !defined(__clang__)
-#define ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT 0
-#else
-#define ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT 1
-#endif
-
-#if defined(_MSC_VER)
-#define ABSL_HAVE_WORKING_ATOMIC_POINTER 0
-#else
-#define ABSL_HAVE_WORKING_ATOMIC_POINTER 1
-#endif
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-template <typename T> class AtomicHook;
-
-// To workaround AtomicHook not being constant-initializable on some platforms,
-// prefer to annotate instances with `ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES`
-// instead of `ABSL_CONST_INIT`.
-#if ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
-#define ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES ABSL_CONST_INIT
-#else
-#define ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
-#endif
-
-// `AtomicHook` is a helper class, templatized on a raw function pointer type,
-// for implementing Abseil customization hooks.  It is a callable object that
-// dispatches to the registered hook.  Objects of type `AtomicHook` must have
-// static or thread storage duration.
-//
-// A default constructed object performs a no-op (and returns a default
-// constructed object) if no hook has been registered.
-//
-// Hooks can be pre-registered via constant initialization, for example:
-//
-// ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES static AtomicHook<void(*)()>
-//     my_hook(DefaultAction);
-//
-// and then changed at runtime via a call to `Store()`.
-//
-// Reads and writes guarantee memory_order_acquire/memory_order_release
-// semantics.
-template <typename ReturnType, typename... Args>
-class AtomicHook<ReturnType (*)(Args...)> {
-public:
-  using FnPtr = ReturnType (*)(Args...);
-
-  // Constructs an object that by default performs a no-op (and
-  // returns a default constructed object) when no hook as been registered.
-  constexpr AtomicHook() : AtomicHook(DummyFunction) {}
-
-  // Constructs an object that by default dispatches to/returns the
-  // pre-registered default_fn when no hook has been registered at runtime.
-#if ABSL_HAVE_WORKING_ATOMIC_POINTER && ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
-  explicit constexpr AtomicHook(FnPtr default_fn)
-      : hook_(default_fn), default_fn_(default_fn) {}
-#elif ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
-  explicit constexpr AtomicHook(FnPtr default_fn)
-      : hook_(kUninitialized), default_fn_(default_fn) {}
-#else
-  // As of January 2020, on all known versions of MSVC this constructor runs in
-  // the global constructor sequence.  If `Store()` is called by a dynamic
-  // initializer, we want to preserve the value, even if this constructor runs
-  // after the call to `Store()`.  If not, `hook_` will be
-  // zero-initialized by the linker and we have no need to set it.
-  // https://developercommunity.visualstudio.com/content/problem/336946/class-with-constexpr-constructor-not-using-static.html
-  explicit constexpr AtomicHook(FnPtr default_fn)
-      : /* hook_(deliberately omitted), */ default_fn_(default_fn) {
-    static_assert(kUninitialized == 0, "here we rely on zero-initialization");
-  }
-#endif
-
-  // Stores the provided function pointer as the value for this hook.
-  //
-  // This is intended to be called once.  Multiple calls are legal only if the
-  // same function pointer is provided for each call.  The store is implemented
-  // as a memory_order_release operation, and read accesses are implemented as
-  // memory_order_acquire.
-  void Store(FnPtr fn) {
-    bool success = DoStore(fn);
-    static_cast<void>(success);
-    assert(success);
-  }
-
-  // Invokes the registered callback.  If no callback has yet been registered, a
-  // default-constructed object of the appropriate type is returned instead.
-  template <typename... CallArgs>
-  ReturnType operator()(CallArgs &&...args) const {
-    return DoLoad()(std::forward<CallArgs>(args)...);
-  }
-
-  // Returns the registered callback, or nullptr if none has been registered.
-  // Useful if client code needs to conditionalize behavior based on whether a
-  // callback was registered.
-  //
-  // Note that atomic_hook.Load()() and atomic_hook() have different semantics:
-  // operator()() will perform a no-op if no callback was registered, while
-  // Load()() will dereference a null function pointer.  Prefer operator()() to
-  // Load()() unless you must conditionalize behavior on whether a hook was
-  // registered.
-  FnPtr Load() const {
-    FnPtr ptr = DoLoad();
-    return (ptr == DummyFunction) ? nullptr : ptr;
-  }
-
-private:
-  static ReturnType DummyFunction(Args...) { return ReturnType(); }
-
-  // Current versions of MSVC (as of September 2017) have a broken
-  // implementation of std::atomic<T*>:  Its constructor attempts to do the
-  // equivalent of a reinterpret_cast in a constexpr context, which is not
-  // allowed.
-  //
-  // This causes an issue when building with LLVM under Windows.  To avoid this,
-  // we use a less-efficient, intptr_t-based implementation on Windows.
-#if ABSL_HAVE_WORKING_ATOMIC_POINTER
-  // Return the stored value, or DummyFunction if no value has been stored.
-  FnPtr DoLoad() const { return hook_.load(std::memory_order_acquire); }
-
-  // Store the given value.  Returns false if a different value was already
-  // stored to this object.
-  bool DoStore(FnPtr fn) {
-    assert(fn);
-    FnPtr expected = default_fn_;
-    const bool store_succeeded = hook_.compare_exchange_strong(
-        expected, fn, std::memory_order_acq_rel, std::memory_order_acquire);
-    const bool same_value_already_stored = (expected == fn);
-    return store_succeeded || same_value_already_stored;
-  }
-
-  std::atomic<FnPtr> hook_;
-#else // !ABSL_HAVE_WORKING_ATOMIC_POINTER
-  // Use a sentinel value unlikely to be the address of an actual function.
-  static constexpr intptr_t kUninitialized = 0;
-
-  static_assert(sizeof(intptr_t) >= sizeof(FnPtr),
-                "intptr_t can't contain a function pointer");
-
-  FnPtr DoLoad() const {
-    const intptr_t value = hook_.load(std::memory_order_acquire);
-    if (value == kUninitialized) {
-      return default_fn_;
-    }
-    return reinterpret_cast<FnPtr>(value);
-  }
-
-  bool DoStore(FnPtr fn) {
-    assert(fn);
-    const auto value = reinterpret_cast<intptr_t>(fn);
-    intptr_t expected = kUninitialized;
-    const bool store_succeeded = hook_.compare_exchange_strong(
-        expected, value, std::memory_order_acq_rel, std::memory_order_acquire);
-    const bool same_value_already_stored = (expected == value);
-    return store_succeeded || same_value_already_stored;
-  }
-
-  std::atomic<intptr_t> hook_;
-#endif
-
-  const FnPtr default_fn_;
-};
-
-#undef ABSL_HAVE_WORKING_ATOMIC_POINTER
-#undef ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_INTERNAL_ATOMIC_HOOK_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/atomic_hook_test_helper.h b/packages/react-native-executorch/third-party/include/absl/base/internal/atomic_hook_test_helper.h
deleted file mode 100644
index f5ff0fea32..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/atomic_hook_test_helper.h
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_BASE_INTERNAL_ATOMIC_HOOK_TEST_HELPER_H_
-#define ABSL_BASE_INTERNAL_ATOMIC_HOOK_TEST_HELPER_H_
-
-#include "absl/base/internal/atomic_hook.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace atomic_hook_internal {
-
-using VoidF = void (*)();
-extern absl::base_internal::AtomicHook<VoidF> func;
-extern int default_func_calls;
-void DefaultFunc();
-void RegisterFunc(VoidF func);
-
-} // namespace atomic_hook_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_INTERNAL_ATOMIC_HOOK_TEST_HELPER_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/cycleclock.h b/packages/react-native-executorch/third-party/include/absl/base/internal/cycleclock.h
deleted file mode 100644
index a6ca008c41..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/cycleclock.h
+++ /dev/null
@@ -1,144 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-// -----------------------------------------------------------------------------
-// File: cycleclock.h
-// -----------------------------------------------------------------------------
-//
-// This header file defines a `CycleClock`, which yields the value and frequency
-// of a cycle counter that increments at a rate that is approximately constant.
-//
-// NOTE:
-//
-// The cycle counter frequency is not necessarily related to the core clock
-// frequency and should not be treated as such. That is, `CycleClock` cycles are
-// not necessarily "CPU cycles" and code should not rely on that behavior, even
-// if experimentally observed.
-//
-// An arbitrary offset may have been added to the counter at power on.
-//
-// On some platforms, the rate and offset of the counter may differ
-// slightly when read from different CPUs of a multiprocessor. Usually,
-// we try to ensure that the operating system adjusts values periodically
-// so that values agree approximately.   If you need stronger guarantees,
-// consider using alternate interfaces.
-//
-// The CPU is not required to maintain the ordering of a cycle counter read
-// with respect to surrounding instructions.
-
-#ifndef ABSL_BASE_INTERNAL_CYCLECLOCK_H_
-#define ABSL_BASE_INTERNAL_CYCLECLOCK_H_
-
-#include <atomic>
-#include <cstdint>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/base/internal/cycleclock_config.h"
-#include "absl/base/internal/unscaledcycleclock.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-using CycleClockSourceFunc = int64_t (*)();
-
-// -----------------------------------------------------------------------------
-// CycleClock
-// -----------------------------------------------------------------------------
-class CycleClock {
-public:
-  // CycleClock::Now()
-  //
-  // Returns the value of a cycle counter that counts at a rate that is
-  // approximately constant.
-  static int64_t Now();
-
-  // CycleClock::Frequency()
-  //
-  // Returns the amount by which `CycleClock::Now()` increases per second. Note
-  // that this value may not necessarily match the core CPU clock frequency.
-  static double Frequency();
-
-private:
-#if ABSL_USE_UNSCALED_CYCLECLOCK
-  static CycleClockSourceFunc LoadCycleClockSource();
-
-  static constexpr int32_t kShift = kCycleClockShift;
-  static constexpr double kFrequencyScale = kCycleClockFrequencyScale;
-
-  ABSL_CONST_INIT static std::atomic<CycleClockSourceFunc> cycle_clock_source_;
-#endif //  ABSL_USE_UNSCALED_CYCLECLOC
-
-  CycleClock() = delete; // no instances
-  CycleClock(const CycleClock &) = delete;
-  CycleClock &operator=(const CycleClock &) = delete;
-
-  friend class CycleClockSource;
-};
-
-class CycleClockSource {
-private:
-  // CycleClockSource::Register()
-  //
-  // Register a function that provides an alternate source for the unscaled CPU
-  // cycle count value. The source function must be async signal safe, must not
-  // call CycleClock::Now(), and must have a frequency that matches that of the
-  // unscaled clock used by CycleClock. A nullptr value resets CycleClock to use
-  // the default source.
-  static void Register(CycleClockSourceFunc source);
-};
-
-#if ABSL_USE_UNSCALED_CYCLECLOCK
-
-inline CycleClockSourceFunc CycleClock::LoadCycleClockSource() {
-#if !defined(__x86_64__)
-  // Optimize for the common case (no callback) by first doing a relaxed load;
-  // this is significantly faster on non-x86 platforms.
-  if (cycle_clock_source_.load(std::memory_order_relaxed) == nullptr) {
-    return nullptr;
-  }
-#endif // !defined(__x86_64__)
-
-  // This corresponds to the store(std::memory_order_release) in
-  // CycleClockSource::Register, and makes sure that any updates made prior to
-  // registering the callback are visible to this thread before the callback
-  // is invoked.
-  return cycle_clock_source_.load(std::memory_order_acquire);
-}
-
-// Accessing globals in inlined code in Window DLLs is problematic.
-#ifndef _WIN32
-inline int64_t CycleClock::Now() {
-  auto fn = LoadCycleClockSource();
-  if (fn == nullptr) {
-    return base_internal::UnscaledCycleClock::Now() >> kShift;
-  }
-  return fn() >> kShift;
-}
-#endif
-
-inline double CycleClock::Frequency() {
-  return kFrequencyScale * base_internal::UnscaledCycleClock::Frequency();
-}
-
-#endif // ABSL_USE_UNSCALED_CYCLECLOCK
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_INTERNAL_CYCLECLOCK_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/cycleclock_config.h b/packages/react-native-executorch/third-party/include/absl/base/internal/cycleclock_config.h
deleted file mode 100644
index 3e15b97129..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/cycleclock_config.h
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright 2022 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_BASE_INTERNAL_CYCLECLOCK_CONFIG_H_
-#define ABSL_BASE_INTERNAL_CYCLECLOCK_CONFIG_H_
-
-#include <cstdint>
-
-#include "absl/base/config.h"
-#include "absl/base/internal/inline_variable.h"
-#include "absl/base/internal/unscaledcycleclock_config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-#if ABSL_USE_UNSCALED_CYCLECLOCK
-#ifdef NDEBUG
-#ifdef ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY
-// Not debug mode and the UnscaledCycleClock frequency is the CPU
-// frequency.  Scale the CycleClock to prevent overflow if someone
-// tries to represent the time as cycles since the Unix epoch.
-ABSL_INTERNAL_INLINE_CONSTEXPR(int32_t, kCycleClockShift, 1);
-#else
-// Not debug mode and the UnscaledCycleClock isn't operating at the
-// raw CPU frequency. There is no need to do any scaling, so don't
-// needlessly sacrifice precision.
-ABSL_INTERNAL_INLINE_CONSTEXPR(int32_t, kCycleClockShift, 0);
-#endif
-#else  // NDEBUG
-// In debug mode use a different shift to discourage depending on a
-// particular shift value.
-ABSL_INTERNAL_INLINE_CONSTEXPR(int32_t, kCycleClockShift, 2);
-#endif // NDEBUG
-
-ABSL_INTERNAL_INLINE_CONSTEXPR(double, kCycleClockFrequencyScale,
-                               1.0 / (1 << kCycleClockShift));
-#endif //  ABSL_USE_UNSCALED_CYCLECLOC
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_INTERNAL_CYCLECLOCK_CONFIG_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/direct_mmap.h b/packages/react-native-executorch/third-party/include/absl/base/internal/direct_mmap.h
deleted file mode 100644
index d657f11b53..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/direct_mmap.h
+++ /dev/null
@@ -1,170 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Functions for directly invoking mmap() via syscall, avoiding the case where
-// mmap() has been locally overridden.
-
-#ifndef ABSL_BASE_INTERNAL_DIRECT_MMAP_H_
-#define ABSL_BASE_INTERNAL_DIRECT_MMAP_H_
-
-#include "absl/base/config.h"
-
-#ifdef ABSL_HAVE_MMAP
-
-#include <sys/mman.h>
-
-#ifdef __linux__
-
-#include <sys/types.h>
-#ifdef __BIONIC__
-#include <sys/syscall.h>
-#else
-#include <syscall.h>
-#endif
-
-#include <cerrno>
-#include <cstdarg>
-#include <cstdint>
-#include <linux/unistd.h>
-#include <unistd.h>
-
-#ifdef __mips__
-// Include definitions of the ABI currently in use.
-#if defined(__BIONIC__) || !defined(__GLIBC__)
-// Android doesn't have sgidefs.h, but does have asm/sgidefs.h, which has the
-// definitions we need.
-#include <asm/sgidefs.h>
-#else
-#include <sgidefs.h>
-#endif // __BIONIC__ || !__GLIBC__
-#endif // __mips__
-
-// SYS_mmap and SYS_munmap are not defined in Android.
-#ifdef __BIONIC__
-extern "C" void *__mmap2(void *, size_t, int, int, int, size_t);
-#if defined(__NR_mmap) && !defined(SYS_mmap)
-#define SYS_mmap __NR_mmap
-#endif
-#ifndef SYS_munmap
-#define SYS_munmap __NR_munmap
-#endif
-#endif // __BIONIC__
-
-#if defined(__NR_mmap2) && !defined(SYS_mmap2)
-#define SYS_mmap2 __NR_mmap2
-#endif
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-// Platform specific logic extracted from
-// https://chromium.googlesource.com/linux-syscall-support/+/master/linux_syscall_support.h
-inline void *DirectMmap(void *start, size_t length, int prot, int flags, int fd,
-                        off_t offset) noexcept {
-#if defined(__i386__) || defined(__ARM_ARCH_3__) || defined(__ARM_EABI__) ||   \
-    defined(__m68k__) || defined(__sh__) ||                                    \
-    (defined(__hppa__) && !defined(__LP64__)) ||                               \
-    (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) ||                     \
-    (defined(__PPC__) && !defined(__PPC64__)) ||                               \
-    (defined(__riscv) && __riscv_xlen == 32) ||                                \
-    (defined(__s390__) && !defined(__s390x__)) ||                              \
-    (defined(__sparc__) && !defined(__arch64__))
-  // On these architectures, implement mmap with mmap2.
-  static int pagesize = 0;
-  if (pagesize == 0) {
-#if defined(__wasm__) || defined(__asmjs__)
-    pagesize = getpagesize();
-#else
-    pagesize = sysconf(_SC_PAGESIZE);
-#endif
-  }
-  if (offset < 0 || offset % pagesize != 0) {
-    errno = EINVAL;
-    return MAP_FAILED;
-  }
-#ifdef __BIONIC__
-  // SYS_mmap2 has problems on Android API level <= 16.
-  // Workaround by invoking __mmap2() instead.
-  return __mmap2(start, length, prot, flags, fd,
-                 static_cast<size_t>(offset / pagesize));
-#else
-  return reinterpret_cast<void *>(
-      syscall(SYS_mmap2, start, length, prot, flags, fd,
-              static_cast<unsigned long>(offset / pagesize))); // NOLINT
-#endif
-#elif defined(__s390x__)
-  // On s390x, mmap() arguments are passed in memory.
-  unsigned long buf[6] = {reinterpret_cast<unsigned long>(start), // NOLINT
-                          static_cast<unsigned long>(length),     // NOLINT
-                          static_cast<unsigned long>(prot),       // NOLINT
-                          static_cast<unsigned long>(flags),      // NOLINT
-                          static_cast<unsigned long>(fd),         // NOLINT
-                          static_cast<unsigned long>(offset)};    // NOLINT
-  return reinterpret_cast<void *>(syscall(SYS_mmap, buf));
-#elif defined(__x86_64__)
-// The x32 ABI has 32 bit longs, but the syscall interface is 64 bit.
-// We need to explicitly cast to an unsigned 64 bit type to avoid implicit
-// sign extension.  We can't cast pointers directly because those are
-// 32 bits, and gcc will dump ugly warnings about casting from a pointer
-// to an integer of a different size. We also need to make sure __off64_t
-// isn't truncated to 32-bits under x32.
-#define MMAP_SYSCALL_ARG(x) ((uint64_t)(uintptr_t)(x))
-  return reinterpret_cast<void *>(
-      syscall(SYS_mmap, MMAP_SYSCALL_ARG(start), MMAP_SYSCALL_ARG(length),
-              MMAP_SYSCALL_ARG(prot), MMAP_SYSCALL_ARG(flags),
-              MMAP_SYSCALL_ARG(fd), static_cast<uint64_t>(offset)));
-#undef MMAP_SYSCALL_ARG
-#else // Remaining 64-bit aritectures.
-  static_assert(sizeof(unsigned long) == 8, "Platform is not 64-bit");
-  return reinterpret_cast<void *>(
-      syscall(SYS_mmap, start, length, prot, flags, fd, offset));
-#endif
-}
-
-inline int DirectMunmap(void *start, size_t length) {
-  return static_cast<int>(syscall(SYS_munmap, start, length));
-}
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#else // !__linux__
-
-// For non-linux platforms where we have mmap, just dispatch directly to the
-// actual mmap()/munmap() methods.
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-inline void *DirectMmap(void *start, size_t length, int prot, int flags, int fd,
-                        off_t offset) {
-  return mmap(start, length, prot, flags, fd, offset);
-}
-
-inline int DirectMunmap(void *start, size_t length) {
-  return munmap(start, length);
-}
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // __linux__
-
-#endif // ABSL_HAVE_MMAP
-
-#endif // ABSL_BASE_INTERNAL_DIRECT_MMAP_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/dynamic_annotations.h b/packages/react-native-executorch/third-party/include/absl/base/internal/dynamic_annotations.h
deleted file mode 100644
index 4366fc7ef0..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/dynamic_annotations.h
+++ /dev/null
@@ -1,398 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// This file defines dynamic annotations for use with dynamic analysis tool
-// such as valgrind, PIN, etc.
-//
-// Dynamic annotation is a source code annotation that affects the generated
-// code (that is, the annotation is not a comment). Each such annotation is
-// attached to a particular instruction and/or to a particular object (address)
-// in the program.
-//
-// The annotations that should be used by users are macros in all upper-case
-// (e.g., ANNOTATE_THREAD_NAME).
-//
-// Actual implementation of these macros may differ depending on the dynamic
-// analysis tool being used.
-//
-// This file supports the following configurations:
-// - Dynamic Annotations enabled (with static thread-safety warnings disabled).
-//   In this case, macros expand to functions implemented by Thread Sanitizer,
-//   when building with TSan. When not provided an external implementation,
-//   dynamic_annotations.cc provides no-op implementations.
-//
-// - Static Clang thread-safety warnings enabled.
-//   When building with a Clang compiler that supports thread-safety warnings,
-//   a subset of annotations can be statically-checked at compile-time. We
-//   expand these macros to static-inline functions that can be analyzed for
-//   thread-safety, but afterwards elided when building the final binary.
-//
-// - All annotations are disabled.
-//   If neither Dynamic Annotations nor Clang thread-safety warnings are
-//   enabled, then all annotation-macros expand to empty.
-
-#ifndef ABSL_BASE_INTERNAL_DYNAMIC_ANNOTATIONS_H_
-#define ABSL_BASE_INTERNAL_DYNAMIC_ANNOTATIONS_H_
-
-#include <stddef.h>
-
-#include "absl/base/config.h"
-
-// -------------------------------------------------------------------------
-// Decide which features are enabled
-
-#ifndef DYNAMIC_ANNOTATIONS_ENABLED
-#define DYNAMIC_ANNOTATIONS_ENABLED 0
-#endif
-
-#if defined(__clang__) && !defined(SWIG)
-#define ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED 1
-#endif
-
-#if DYNAMIC_ANNOTATIONS_ENABLED != 0
-
-#define ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED 1
-#define ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED 1
-#define ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED 1
-#define ABSL_INTERNAL_ANNOTALYSIS_ENABLED 0
-#define ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED 1
-
-#else
-
-#define ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED 0
-#define ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED 0
-#define ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED 0
-
-// Clang provides limited support for static thread-safety analysis through a
-// feature called Annotalysis. We configure macro-definitions according to
-// whether Annotalysis support is available. When running in opt-mode, GCC
-// will issue a warning, if these attributes are compiled. Only include them
-// when compiling using Clang.
-
-// ANNOTALYSIS_ENABLED == 1 when IGNORE_READ_ATTRIBUTE_ENABLED == 1
-#define ABSL_INTERNAL_ANNOTALYSIS_ENABLED                                      \
-  defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
-// Read/write annotations are enabled in Annotalysis mode; disabled otherwise.
-#define ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED                         \
-  ABSL_INTERNAL_ANNOTALYSIS_ENABLED
-#endif
-
-// Memory annotations are also made available to LLVM's Memory Sanitizer
-#if defined(ABSL_HAVE_MEMORY_SANITIZER) && !defined(__native_client__)
-#define ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED 1
-#endif
-
-#ifndef ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED
-#define ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED 0
-#endif
-
-#ifdef __cplusplus
-#define ABSL_INTERNAL_BEGIN_EXTERN_C extern "C" {
-#define ABSL_INTERNAL_END_EXTERN_C } // extern "C"
-#define ABSL_INTERNAL_GLOBAL_SCOPED(F) ::F
-#define ABSL_INTERNAL_STATIC_INLINE inline
-#else
-#define ABSL_INTERNAL_BEGIN_EXTERN_C // empty
-#define ABSL_INTERNAL_END_EXTERN_C   // empty
-#define ABSL_INTERNAL_GLOBAL_SCOPED(F) F
-#define ABSL_INTERNAL_STATIC_INLINE static inline
-#endif
-
-// -------------------------------------------------------------------------
-// Define race annotations.
-
-#if ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED == 1
-
-// -------------------------------------------------------------
-// Annotations that suppress errors. It is usually better to express the
-// program's synchronization using the other annotations, but these can be used
-// when all else fails.
-
-// Report that we may have a benign race at `pointer`, with size
-// "sizeof(*(pointer))". `pointer` must be a non-void* pointer. Insert at the
-// point where `pointer` has been allocated, preferably close to the point
-// where the race happens. See also ANNOTATE_BENIGN_RACE_STATIC.
-#define ANNOTATE_BENIGN_RACE(pointer, description)                             \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized)                         \
-  (__FILE__, __LINE__, pointer, sizeof(*(pointer)), description)
-
-// Same as ANNOTATE_BENIGN_RACE(`address`, `description`), but applies to
-// the memory range [`address`, `address`+`size`).
-#define ANNOTATE_BENIGN_RACE_SIZED(address, size, description)                 \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized)                         \
-  (__FILE__, __LINE__, address, size, description)
-
-// Enable (`enable`!=0) or disable (`enable`==0) race detection for all threads.
-// This annotation could be useful if you want to skip expensive race analysis
-// during some period of program execution, e.g. during initialization.
-#define ANNOTATE_ENABLE_RACE_DETECTION(enable)                                 \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateEnableRaceDetection)                     \
-  (__FILE__, __LINE__, enable)
-
-// -------------------------------------------------------------
-// Annotations useful for debugging.
-
-// Report the current thread `name` to a race detector.
-#define ANNOTATE_THREAD_NAME(name)                                             \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateThreadName)(__FILE__, __LINE__, name)
-
-// -------------------------------------------------------------
-// Annotations useful when implementing locks. They are not normally needed by
-// modules that merely use locks. The `lock` argument is a pointer to the lock
-// object.
-
-// Report that a lock has been created at address `lock`.
-#define ANNOTATE_RWLOCK_CREATE(lock)                                           \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreate)(__FILE__, __LINE__, lock)
-
-// Report that a linker initialized lock has been created at address `lock`.
-#ifdef ABSL_HAVE_THREAD_SANITIZER
-#define ANNOTATE_RWLOCK_CREATE_STATIC(lock)                                    \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreateStatic)                      \
-  (__FILE__, __LINE__, lock)
-#else
-#define ANNOTATE_RWLOCK_CREATE_STATIC(lock) ANNOTATE_RWLOCK_CREATE(lock)
-#endif
-
-// Report that the lock at address `lock` is about to be destroyed.
-#define ANNOTATE_RWLOCK_DESTROY(lock)                                          \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockDestroy)(__FILE__, __LINE__, lock)
-
-// Report that the lock at address `lock` has been acquired.
-// `is_w`=1 for writer lock, `is_w`=0 for reader lock.
-#define ANNOTATE_RWLOCK_ACQUIRED(lock, is_w)                                   \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockAcquired)                          \
-  (__FILE__, __LINE__, lock, is_w)
-
-// Report that the lock at address `lock` is about to be released.
-// `is_w`=1 for writer lock, `is_w`=0 for reader lock.
-#define ANNOTATE_RWLOCK_RELEASED(lock, is_w)                                   \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockReleased)                          \
-  (__FILE__, __LINE__, lock, is_w)
-
-// Apply ANNOTATE_BENIGN_RACE_SIZED to a static variable `static_var`.
-#define ANNOTATE_BENIGN_RACE_STATIC(static_var, description)                   \
-  namespace {                                                                  \
-  class static_var##_annotator {                                               \
-  public:                                                                      \
-    static_var##_annotator() {                                                 \
-      ANNOTATE_BENIGN_RACE_SIZED(&static_var, sizeof(static_var),              \
-                                 #static_var ": " description);                \
-    }                                                                          \
-  };                                                                           \
-  static static_var##_annotator the##static_var##_annotator;                   \
-  } // namespace
-
-#else // ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED == 0
-
-#define ANNOTATE_RWLOCK_CREATE(lock)                           // empty
-#define ANNOTATE_RWLOCK_CREATE_STATIC(lock)                    // empty
-#define ANNOTATE_RWLOCK_DESTROY(lock)                          // empty
-#define ANNOTATE_RWLOCK_ACQUIRED(lock, is_w)                   // empty
-#define ANNOTATE_RWLOCK_RELEASED(lock, is_w)                   // empty
-#define ANNOTATE_BENIGN_RACE(address, description)             // empty
-#define ANNOTATE_BENIGN_RACE_SIZED(address, size, description) // empty
-#define ANNOTATE_THREAD_NAME(name)                             // empty
-#define ANNOTATE_ENABLE_RACE_DETECTION(enable)                 // empty
-#define ANNOTATE_BENIGN_RACE_STATIC(static_var, description)   // empty
-
-#endif // ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED
-
-// -------------------------------------------------------------------------
-// Define memory annotations.
-
-#if ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED == 1
-
-#include <sanitizer/msan_interface.h>
-
-#define ANNOTATE_MEMORY_IS_INITIALIZED(address, size)                          \
-  __msan_unpoison(address, size)
-
-#define ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size)                        \
-  __msan_allocated_memory(address, size)
-
-#else // ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED == 0
-
-#if DYNAMIC_ANNOTATIONS_ENABLED == 1
-#define ANNOTATE_MEMORY_IS_INITIALIZED(address, size)                          \
-  do {                                                                         \
-    (void)(address);                                                           \
-    (void)(size);                                                              \
-  } while (0)
-#define ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size)                        \
-  do {                                                                         \
-    (void)(address);                                                           \
-    (void)(size);                                                              \
-  } while (0)
-#else
-#define ANNOTATE_MEMORY_IS_INITIALIZED(address, size)   // empty
-#define ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) // empty
-#endif
-
-#endif // ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED
-
-// -------------------------------------------------------------------------
-// Define IGNORE_READS_BEGIN/_END attributes.
-
-#if defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
-
-#define ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE                             \
-  __attribute((exclusive_lock_function("*")))
-#define ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE                               \
-  __attribute((unlock_function("*")))
-
-#else // !defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
-
-#define ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE // empty
-#define ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE   // empty
-
-#endif // defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
-
-// -------------------------------------------------------------------------
-// Define IGNORE_READS_BEGIN/_END annotations.
-
-#if ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED == 1
-
-// Request the analysis tool to ignore all reads in the current thread until
-// ANNOTATE_IGNORE_READS_END is called. Useful to ignore intentional racey
-// reads, while still checking other reads and all writes.
-// See also ANNOTATE_UNPROTECTED_READ.
-#define ANNOTATE_IGNORE_READS_BEGIN()                                          \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsBegin)(__FILE__, __LINE__)
-
-// Stop ignoring reads.
-#define ANNOTATE_IGNORE_READS_END()                                            \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsEnd)(__FILE__, __LINE__)
-
-#elif defined(ABSL_INTERNAL_ANNOTALYSIS_ENABLED)
-
-// When Annotalysis is enabled without Dynamic Annotations, the use of
-// static-inline functions allows the annotations to be read at compile-time,
-// while still letting the compiler elide the functions from the final build.
-//
-// TODO(delesley) -- The exclusive lock here ignores writes as well, but
-// allows IGNORE_READS_AND_WRITES to work properly.
-
-#define ANNOTATE_IGNORE_READS_BEGIN()                                          \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AbslInternalAnnotateIgnoreReadsBegin)()
-
-#define ANNOTATE_IGNORE_READS_END()                                            \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AbslInternalAnnotateIgnoreReadsEnd)()
-
-#else
-
-#define ANNOTATE_IGNORE_READS_BEGIN() // empty
-#define ANNOTATE_IGNORE_READS_END()   // empty
-
-#endif
-
-// -------------------------------------------------------------------------
-// Define IGNORE_WRITES_BEGIN/_END annotations.
-
-#if ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED == 1
-
-// Similar to ANNOTATE_IGNORE_READS_BEGIN, but ignore writes instead.
-#define ANNOTATE_IGNORE_WRITES_BEGIN()                                         \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesBegin)(__FILE__, __LINE__)
-
-// Stop ignoring writes.
-#define ANNOTATE_IGNORE_WRITES_END()                                           \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesEnd)(__FILE__, __LINE__)
-
-#else
-
-#define ANNOTATE_IGNORE_WRITES_BEGIN() // empty
-#define ANNOTATE_IGNORE_WRITES_END()   // empty
-
-#endif
-
-// -------------------------------------------------------------------------
-// Define the ANNOTATE_IGNORE_READS_AND_WRITES_* annotations using the more
-// primitive annotations defined above.
-//
-//     Instead of doing
-//        ANNOTATE_IGNORE_READS_BEGIN();
-//        ... = x;
-//        ANNOTATE_IGNORE_READS_END();
-//     one can use
-//        ... = ANNOTATE_UNPROTECTED_READ(x);
-
-#if defined(ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED)
-
-// Start ignoring all memory accesses (both reads and writes).
-#define ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN()                               \
-  do {                                                                         \
-    ANNOTATE_IGNORE_READS_BEGIN();                                             \
-    ANNOTATE_IGNORE_WRITES_BEGIN();                                            \
-  } while (0)
-
-// Stop ignoring both reads and writes.
-#define ANNOTATE_IGNORE_READS_AND_WRITES_END()                                 \
-  do {                                                                         \
-    ANNOTATE_IGNORE_WRITES_END();                                              \
-    ANNOTATE_IGNORE_READS_END();                                               \
-  } while (0)
-
-#ifdef __cplusplus
-// ANNOTATE_UNPROTECTED_READ is the preferred way to annotate racey reads.
-#define ANNOTATE_UNPROTECTED_READ(x)                                           \
-  absl::base_internal::AnnotateUnprotectedRead(x)
-
-#endif
-
-#else
-
-#define ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() // empty
-#define ANNOTATE_IGNORE_READS_AND_WRITES_END()   // empty
-#define ANNOTATE_UNPROTECTED_READ(x) (x)
-
-#endif
-
-// -------------------------------------------------------------------------
-// Address sanitizer annotations
-
-#ifdef ABSL_HAVE_ADDRESS_SANITIZER
-// Describe the current state of a contiguous container such as e.g.
-// std::vector or std::string. For more details see
-// sanitizer/common_interface_defs.h, which is provided by the compiler.
-#include <sanitizer/common_interface_defs.h>
-
-#define ANNOTATE_CONTIGUOUS_CONTAINER(beg, end, old_mid, new_mid)              \
-  __sanitizer_annotate_contiguous_container(beg, end, old_mid, new_mid)
-#define ADDRESS_SANITIZER_REDZONE(name)                                        \
-  struct {                                                                     \
-    char x[8] __attribute__((aligned(8)));                                     \
-  } name
-
-#else
-
-#define ANNOTATE_CONTIGUOUS_CONTAINER(beg, end, old_mid, new_mid)
-#define ADDRESS_SANITIZER_REDZONE(name) static_assert(true, "")
-
-#endif // ABSL_HAVE_ADDRESS_SANITIZER
-
-// -------------------------------------------------------------------------
-// Undefine the macros intended only for this file.
-
-#undef ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED
-#undef ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED
-#undef ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED
-#undef ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED
-#undef ABSL_INTERNAL_ANNOTALYSIS_ENABLED
-#undef ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED
-#undef ABSL_INTERNAL_BEGIN_EXTERN_C
-#undef ABSL_INTERNAL_END_EXTERN_C
-#undef ABSL_INTERNAL_STATIC_INLINE
-
-#endif // ABSL_BASE_INTERNAL_DYNAMIC_ANNOTATIONS_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/endian.h b/packages/react-native-executorch/third-party/include/absl/base/internal/endian.h
deleted file mode 100644
index 4b630e76ee..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/endian.h
+++ /dev/null
@@ -1,282 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef ABSL_BASE_INTERNAL_ENDIAN_H_
-#define ABSL_BASE_INTERNAL_ENDIAN_H_
-
-#include <cstdint>
-#include <cstdlib>
-
-#include "absl/base/casts.h"
-#include "absl/base/config.h"
-#include "absl/base/internal/unaligned_access.h"
-#include "absl/base/nullability.h"
-#include "absl/base/port.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-inline uint64_t gbswap_64(uint64_t host_int) {
-#if ABSL_HAVE_BUILTIN(__builtin_bswap64) || defined(__GNUC__)
-  return __builtin_bswap64(host_int);
-#elif defined(_MSC_VER)
-  return _byteswap_uint64(host_int);
-#else
-  return (((host_int & uint64_t{0xFF}) << 56) |
-          ((host_int & uint64_t{0xFF00}) << 40) |
-          ((host_int & uint64_t{0xFF0000}) << 24) |
-          ((host_int & uint64_t{0xFF000000}) << 8) |
-          ((host_int & uint64_t{0xFF00000000}) >> 8) |
-          ((host_int & uint64_t{0xFF0000000000}) >> 24) |
-          ((host_int & uint64_t{0xFF000000000000}) >> 40) |
-          ((host_int & uint64_t{0xFF00000000000000}) >> 56));
-#endif
-}
-
-inline uint32_t gbswap_32(uint32_t host_int) {
-#if ABSL_HAVE_BUILTIN(__builtin_bswap32) || defined(__GNUC__)
-  return __builtin_bswap32(host_int);
-#elif defined(_MSC_VER)
-  return _byteswap_ulong(host_int);
-#else
-  return (((host_int & uint32_t{0xFF}) << 24) |
-          ((host_int & uint32_t{0xFF00}) << 8) |
-          ((host_int & uint32_t{0xFF0000}) >> 8) |
-          ((host_int & uint32_t{0xFF000000}) >> 24));
-#endif
-}
-
-inline uint16_t gbswap_16(uint16_t host_int) {
-#if ABSL_HAVE_BUILTIN(__builtin_bswap16) || defined(__GNUC__)
-  return __builtin_bswap16(host_int);
-#elif defined(_MSC_VER)
-  return _byteswap_ushort(host_int);
-#else
-  return (((host_int & uint16_t{0xFF}) << 8) |
-          ((host_int & uint16_t{0xFF00}) >> 8));
-#endif
-}
-
-#ifdef ABSL_IS_LITTLE_ENDIAN
-
-// Portable definitions for htonl (host-to-network) and friends on little-endian
-// architectures.
-inline uint16_t ghtons(uint16_t x) { return gbswap_16(x); }
-inline uint32_t ghtonl(uint32_t x) { return gbswap_32(x); }
-inline uint64_t ghtonll(uint64_t x) { return gbswap_64(x); }
-
-#elif defined ABSL_IS_BIG_ENDIAN
-
-// Portable definitions for htonl (host-to-network) etc on big-endian
-// architectures. These definitions are simpler since the host byte order is the
-// same as network byte order.
-inline uint16_t ghtons(uint16_t x) { return x; }
-inline uint32_t ghtonl(uint32_t x) { return x; }
-inline uint64_t ghtonll(uint64_t x) { return x; }
-
-#else
-#error "Unsupported byte order: Either ABSL_IS_BIG_ENDIAN or " \
-       "ABSL_IS_LITTLE_ENDIAN must be defined"
-#endif // byte order
-
-inline uint16_t gntohs(uint16_t x) { return ghtons(x); }
-inline uint32_t gntohl(uint32_t x) { return ghtonl(x); }
-inline uint64_t gntohll(uint64_t x) { return ghtonll(x); }
-
-// Utilities to convert numbers between the current hosts's native byte
-// order and little-endian byte order
-//
-// Load/Store methods are alignment safe
-namespace little_endian {
-// Conversion functions.
-#ifdef ABSL_IS_LITTLE_ENDIAN
-
-inline uint16_t FromHost16(uint16_t x) { return x; }
-inline uint16_t ToHost16(uint16_t x) { return x; }
-
-inline uint32_t FromHost32(uint32_t x) { return x; }
-inline uint32_t ToHost32(uint32_t x) { return x; }
-
-inline uint64_t FromHost64(uint64_t x) { return x; }
-inline uint64_t ToHost64(uint64_t x) { return x; }
-
-inline constexpr bool IsLittleEndian() { return true; }
-
-#elif defined ABSL_IS_BIG_ENDIAN
-
-inline uint16_t FromHost16(uint16_t x) { return gbswap_16(x); }
-inline uint16_t ToHost16(uint16_t x) { return gbswap_16(x); }
-
-inline uint32_t FromHost32(uint32_t x) { return gbswap_32(x); }
-inline uint32_t ToHost32(uint32_t x) { return gbswap_32(x); }
-
-inline uint64_t FromHost64(uint64_t x) { return gbswap_64(x); }
-inline uint64_t ToHost64(uint64_t x) { return gbswap_64(x); }
-
-inline constexpr bool IsLittleEndian() { return false; }
-
-#endif /* ENDIAN */
-
-inline uint8_t FromHost(uint8_t x) { return x; }
-inline uint16_t FromHost(uint16_t x) { return FromHost16(x); }
-inline uint32_t FromHost(uint32_t x) { return FromHost32(x); }
-inline uint64_t FromHost(uint64_t x) { return FromHost64(x); }
-inline uint8_t ToHost(uint8_t x) { return x; }
-inline uint16_t ToHost(uint16_t x) { return ToHost16(x); }
-inline uint32_t ToHost(uint32_t x) { return ToHost32(x); }
-inline uint64_t ToHost(uint64_t x) { return ToHost64(x); }
-
-inline int8_t FromHost(int8_t x) { return x; }
-inline int16_t FromHost(int16_t x) {
-  return bit_cast<int16_t>(FromHost16(bit_cast<uint16_t>(x)));
-}
-inline int32_t FromHost(int32_t x) {
-  return bit_cast<int32_t>(FromHost32(bit_cast<uint32_t>(x)));
-}
-inline int64_t FromHost(int64_t x) {
-  return bit_cast<int64_t>(FromHost64(bit_cast<uint64_t>(x)));
-}
-inline int8_t ToHost(int8_t x) { return x; }
-inline int16_t ToHost(int16_t x) {
-  return bit_cast<int16_t>(ToHost16(bit_cast<uint16_t>(x)));
-}
-inline int32_t ToHost(int32_t x) {
-  return bit_cast<int32_t>(ToHost32(bit_cast<uint32_t>(x)));
-}
-inline int64_t ToHost(int64_t x) {
-  return bit_cast<int64_t>(ToHost64(bit_cast<uint64_t>(x)));
-}
-
-// Functions to do unaligned loads and stores in little-endian order.
-inline uint16_t Load16(absl::Nonnull<const void *> p) {
-  return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));
-}
-
-inline void Store16(absl::Nonnull<void *> p, uint16_t v) {
-  ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
-}
-
-inline uint32_t Load32(absl::Nonnull<const void *> p) {
-  return ToHost32(ABSL_INTERNAL_UNALIGNED_LOAD32(p));
-}
-
-inline void Store32(absl::Nonnull<void *> p, uint32_t v) {
-  ABSL_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
-}
-
-inline uint64_t Load64(absl::Nonnull<const void *> p) {
-  return ToHost64(ABSL_INTERNAL_UNALIGNED_LOAD64(p));
-}
-
-inline void Store64(absl::Nonnull<void *> p, uint64_t v) {
-  ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
-}
-
-} // namespace little_endian
-
-// Utilities to convert numbers between the current hosts's native byte
-// order and big-endian byte order (same as network byte order)
-//
-// Load/Store methods are alignment safe
-namespace big_endian {
-#ifdef ABSL_IS_LITTLE_ENDIAN
-
-inline uint16_t FromHost16(uint16_t x) { return gbswap_16(x); }
-inline uint16_t ToHost16(uint16_t x) { return gbswap_16(x); }
-
-inline uint32_t FromHost32(uint32_t x) { return gbswap_32(x); }
-inline uint32_t ToHost32(uint32_t x) { return gbswap_32(x); }
-
-inline uint64_t FromHost64(uint64_t x) { return gbswap_64(x); }
-inline uint64_t ToHost64(uint64_t x) { return gbswap_64(x); }
-
-inline constexpr bool IsLittleEndian() { return true; }
-
-#elif defined ABSL_IS_BIG_ENDIAN
-
-inline uint16_t FromHost16(uint16_t x) { return x; }
-inline uint16_t ToHost16(uint16_t x) { return x; }
-
-inline uint32_t FromHost32(uint32_t x) { return x; }
-inline uint32_t ToHost32(uint32_t x) { return x; }
-
-inline uint64_t FromHost64(uint64_t x) { return x; }
-inline uint64_t ToHost64(uint64_t x) { return x; }
-
-inline constexpr bool IsLittleEndian() { return false; }
-
-#endif /* ENDIAN */
-
-inline uint8_t FromHost(uint8_t x) { return x; }
-inline uint16_t FromHost(uint16_t x) { return FromHost16(x); }
-inline uint32_t FromHost(uint32_t x) { return FromHost32(x); }
-inline uint64_t FromHost(uint64_t x) { return FromHost64(x); }
-inline uint8_t ToHost(uint8_t x) { return x; }
-inline uint16_t ToHost(uint16_t x) { return ToHost16(x); }
-inline uint32_t ToHost(uint32_t x) { return ToHost32(x); }
-inline uint64_t ToHost(uint64_t x) { return ToHost64(x); }
-
-inline int8_t FromHost(int8_t x) { return x; }
-inline int16_t FromHost(int16_t x) {
-  return bit_cast<int16_t>(FromHost16(bit_cast<uint16_t>(x)));
-}
-inline int32_t FromHost(int32_t x) {
-  return bit_cast<int32_t>(FromHost32(bit_cast<uint32_t>(x)));
-}
-inline int64_t FromHost(int64_t x) {
-  return bit_cast<int64_t>(FromHost64(bit_cast<uint64_t>(x)));
-}
-inline int8_t ToHost(int8_t x) { return x; }
-inline int16_t ToHost(int16_t x) {
-  return bit_cast<int16_t>(ToHost16(bit_cast<uint16_t>(x)));
-}
-inline int32_t ToHost(int32_t x) {
-  return bit_cast<int32_t>(ToHost32(bit_cast<uint32_t>(x)));
-}
-inline int64_t ToHost(int64_t x) {
-  return bit_cast<int64_t>(ToHost64(bit_cast<uint64_t>(x)));
-}
-
-// Functions to do unaligned loads and stores in big-endian order.
-inline uint16_t Load16(absl::Nonnull<const void *> p) {
-  return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));
-}
-
-inline void Store16(absl::Nonnull<void *> p, uint16_t v) {
-  ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
-}
-
-inline uint32_t Load32(absl::Nonnull<const void *> p) {
-  return ToHost32(ABSL_INTERNAL_UNALIGNED_LOAD32(p));
-}
-
-inline void Store32(absl::Nonnull<void *> p, uint32_t v) {
-  ABSL_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
-}
-
-inline uint64_t Load64(absl::Nonnull<const void *> p) {
-  return ToHost64(ABSL_INTERNAL_UNALIGNED_LOAD64(p));
-}
-
-inline void Store64(absl::Nonnull<void *> p, uint64_t v) {
-  ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
-}
-
-} // namespace big_endian
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_INTERNAL_ENDIAN_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/errno_saver.h b/packages/react-native-executorch/third-party/include/absl/base/internal/errno_saver.h
deleted file mode 100644
index 6adacc5237..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/errno_saver.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_BASE_INTERNAL_ERRNO_SAVER_H_
-#define ABSL_BASE_INTERNAL_ERRNO_SAVER_H_
-
-#include <cerrno>
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-// `ErrnoSaver` captures the value of `errno` upon construction and restores it
-// upon deletion.  It is used in low-level code and must be super fast.  Do not
-// add instrumentation, even in debug modes.
-class ErrnoSaver {
-public:
-  ErrnoSaver() : saved_errno_(errno) {}
-  ~ErrnoSaver() { errno = saved_errno_; }
-  int operator()() const { return saved_errno_; }
-
-private:
-  const int saved_errno_;
-};
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_INTERNAL_ERRNO_SAVER_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/exception_safety_testing.h b/packages/react-native-executorch/third-party/include/absl/base/internal/exception_safety_testing.h
deleted file mode 100644
index ff15dd3a4a..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/exception_safety_testing.h
+++ /dev/null
@@ -1,1108 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Utilities for testing exception-safety
-
-#ifndef ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_
-#define ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_
-
-#include "absl/base/config.h"
-
-#ifdef ABSL_HAVE_EXCEPTIONS
-
-#include <cstddef>
-#include <cstdint>
-#include <functional>
-#include <initializer_list>
-#include <iosfwd>
-#include <string>
-#include <tuple>
-#include <unordered_map>
-
-#include "absl/base/internal/pretty_function.h"
-#include "absl/memory/memory.h"
-#include "absl/meta/type_traits.h"
-#include "absl/strings/string_view.h"
-#include "absl/strings/substitute.h"
-#include "absl/utility/utility.h"
-#include "gtest/gtest.h"
-
-namespace testing {
-
-enum class TypeSpec;
-enum class AllocSpec;
-
-constexpr TypeSpec operator|(TypeSpec a, TypeSpec b) {
-  using T = absl::underlying_type_t<TypeSpec>;
-  return static_cast<TypeSpec>(static_cast<T>(a) | static_cast<T>(b));
-}
-
-constexpr TypeSpec operator&(TypeSpec a, TypeSpec b) {
-  using T = absl::underlying_type_t<TypeSpec>;
-  return static_cast<TypeSpec>(static_cast<T>(a) & static_cast<T>(b));
-}
-
-constexpr AllocSpec operator|(AllocSpec a, AllocSpec b) {
-  using T = absl::underlying_type_t<AllocSpec>;
-  return static_cast<AllocSpec>(static_cast<T>(a) | static_cast<T>(b));
-}
-
-constexpr AllocSpec operator&(AllocSpec a, AllocSpec b) {
-  using T = absl::underlying_type_t<AllocSpec>;
-  return static_cast<AllocSpec>(static_cast<T>(a) & static_cast<T>(b));
-}
-
-namespace exceptions_internal {
-
-std::string GetSpecString(TypeSpec);
-std::string GetSpecString(AllocSpec);
-
-struct NoThrowTag {};
-struct StrongGuaranteeTagType {};
-
-// A simple exception class.  We throw this so that test code can catch
-// exceptions specifically thrown by ThrowingValue.
-class TestException {
-public:
-  explicit TestException(absl::string_view msg) : msg_(msg) {}
-  virtual ~TestException() {}
-  virtual const char *what() const noexcept { return msg_.c_str(); }
-
-private:
-  std::string msg_;
-};
-
-// TestBadAllocException exists because allocation functions must throw an
-// exception which can be caught by a handler of std::bad_alloc.  We use a child
-// class of std::bad_alloc so we can customise the error message, and also
-// derive from TestException so we don't accidentally end up catching an actual
-// bad_alloc exception in TestExceptionSafety.
-class TestBadAllocException : public std::bad_alloc, public TestException {
-public:
-  explicit TestBadAllocException(absl::string_view msg) : TestException(msg) {}
-  using TestException::what;
-};
-
-extern int countdown;
-
-// Allows the countdown variable to be set manually (defaulting to the initial
-// value of 0)
-inline void SetCountdown(int i = 0) { countdown = i; }
-// Sets the countdown to the terminal value -1
-inline void UnsetCountdown() { SetCountdown(-1); }
-
-void MaybeThrow(absl::string_view msg, bool throw_bad_alloc = false);
-
-testing::AssertionResult FailureMessage(const TestException &e,
-                                        int countdown) noexcept;
-
-struct TrackedAddress {
-  bool is_alive;
-  std::string description;
-};
-
-// Inspects the constructions and destructions of anything inheriting from
-// TrackedObject. This allows us to safely "leak" TrackedObjects, as
-// ConstructorTracker will destroy everything left over in its destructor.
-class ConstructorTracker {
-public:
-  explicit ConstructorTracker(int count) : countdown_(count) {
-    assert(current_tracker_instance_ == nullptr);
-    current_tracker_instance_ = this;
-  }
-
-  ~ConstructorTracker() {
-    assert(current_tracker_instance_ == this);
-    current_tracker_instance_ = nullptr;
-
-    for (auto &it : address_map_) {
-      void *address = it.first;
-      TrackedAddress &tracked_address = it.second;
-      if (tracked_address.is_alive) {
-        ADD_FAILURE() << ErrorMessage(address, tracked_address.description,
-                                      countdown_, "Object was not destroyed.");
-      }
-    }
-  }
-
-  static void ObjectConstructed(void *address, std::string description) {
-    if (!CurrentlyTracking())
-      return;
-
-    TrackedAddress &tracked_address =
-        current_tracker_instance_->address_map_[address];
-    if (tracked_address.is_alive) {
-      ADD_FAILURE() << ErrorMessage(
-          address, tracked_address.description,
-          current_tracker_instance_->countdown_,
-          "Object was re-constructed. Current object was constructed by " +
-              description);
-    }
-    tracked_address = {true, std::move(description)};
-  }
-
-  static void ObjectDestructed(void *address) {
-    if (!CurrentlyTracking())
-      return;
-
-    auto it = current_tracker_instance_->address_map_.find(address);
-    // Not tracked. Ignore.
-    if (it == current_tracker_instance_->address_map_.end())
-      return;
-
-    TrackedAddress &tracked_address = it->second;
-    if (!tracked_address.is_alive) {
-      ADD_FAILURE() << ErrorMessage(address, tracked_address.description,
-                                    current_tracker_instance_->countdown_,
-                                    "Object was re-destroyed.");
-    }
-    tracked_address.is_alive = false;
-  }
-
-private:
-  static bool CurrentlyTracking() {
-    return current_tracker_instance_ != nullptr;
-  }
-
-  static std::string ErrorMessage(void *address,
-                                  const std::string &address_description,
-                                  int countdown,
-                                  const std::string &error_description) {
-    return absl::Substitute("With coundtown at $0:\n"
-                            "  $1\n"
-                            "  Object originally constructed by $2\n"
-                            "  Object address: $3\n",
-                            countdown, error_description, address_description,
-                            address);
-  }
-
-  std::unordered_map<void *, TrackedAddress> address_map_;
-  int countdown_;
-
-  static ConstructorTracker *current_tracker_instance_;
-};
-
-class TrackedObject {
-public:
-  TrackedObject(const TrackedObject &) = delete;
-  TrackedObject(TrackedObject &&) = delete;
-
-protected:
-  explicit TrackedObject(std::string description) {
-    ConstructorTracker::ObjectConstructed(this, std::move(description));
-  }
-
-  ~TrackedObject() noexcept { ConstructorTracker::ObjectDestructed(this); }
-};
-} // namespace exceptions_internal
-
-extern exceptions_internal::NoThrowTag nothrow_ctor;
-
-extern exceptions_internal::StrongGuaranteeTagType strong_guarantee;
-
-// A test class which is convertible to bool.  The conversion can be
-// instrumented to throw at a controlled time.
-class ThrowingBool {
-public:
-  ThrowingBool(bool b) noexcept : b_(b) {} // NOLINT(runtime/explicit)
-  operator bool() const {                  // NOLINT
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return b_;
-  }
-
-private:
-  bool b_;
-};
-
-/*
- * Configuration enum for the ThrowingValue type that defines behavior for the
- * lifetime of the instance. Use testing::nothrow_ctor to prevent the integer
- * constructor from throwing.
- *
- * kEverythingThrows: Every operation can throw an exception
- * kNoThrowCopy: Copy construction and copy assignment will not throw
- * kNoThrowMove: Move construction and move assignment will not throw
- * kNoThrowNew: Overloaded operators new and new[] will not throw
- */
-enum class TypeSpec {
-  kEverythingThrows = 0,
-  kNoThrowCopy = 1,
-  kNoThrowMove = 1 << 1,
-  kNoThrowNew = 1 << 2,
-};
-
-/*
- * A testing class instrumented to throw an exception at a controlled time.
- *
- * ThrowingValue implements a slightly relaxed version of the Regular concept --
- * that is it's a value type with the expected semantics.  It also implements
- * arithmetic operations.  It doesn't implement member and pointer operators
- * like operator-> or operator[].
- *
- * ThrowingValue can be instrumented to have certain operations be noexcept by
- * using compile-time bitfield template arguments.  That is, to make an
- * ThrowingValue which has noexcept move construction/assignment and noexcept
- * copy construction/assignment, use the following:
- *   ThrowingValue<testing::kNoThrowMove | testing::kNoThrowCopy> my_thrwr{val};
- */
-template <TypeSpec Spec = TypeSpec::kEverythingThrows>
-class ThrowingValue : private exceptions_internal::TrackedObject {
-  static constexpr bool IsSpecified(TypeSpec spec) {
-    return static_cast<bool>(Spec & spec);
-  }
-
-  static constexpr int kDefaultValue = 0;
-  static constexpr int kBadValue = 938550620;
-
-public:
-  ThrowingValue() : TrackedObject(GetInstanceString(kDefaultValue)) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ = kDefaultValue;
-  }
-
-  ThrowingValue(const ThrowingValue &other) noexcept(
-      IsSpecified(TypeSpec::kNoThrowCopy))
-      : TrackedObject(GetInstanceString(other.dummy_)) {
-    if (!IsSpecified(TypeSpec::kNoThrowCopy)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    }
-    dummy_ = other.dummy_;
-  }
-
-  ThrowingValue(ThrowingValue &&other) noexcept(
-      IsSpecified(TypeSpec::kNoThrowMove))
-      : TrackedObject(GetInstanceString(other.dummy_)) {
-    if (!IsSpecified(TypeSpec::kNoThrowMove)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    }
-    dummy_ = other.dummy_;
-  }
-
-  explicit ThrowingValue(int i) : TrackedObject(GetInstanceString(i)) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ = i;
-  }
-
-  ThrowingValue(int i, exceptions_internal::NoThrowTag) noexcept
-      : TrackedObject(GetInstanceString(i)), dummy_(i) {}
-
-  // absl expects nothrow destructors
-  ~ThrowingValue() noexcept = default;
-
-  ThrowingValue &operator=(const ThrowingValue &other) noexcept(
-      IsSpecified(TypeSpec::kNoThrowCopy)) {
-    dummy_ = kBadValue;
-    if (!IsSpecified(TypeSpec::kNoThrowCopy)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    }
-    dummy_ = other.dummy_;
-    return *this;
-  }
-
-  ThrowingValue &operator=(ThrowingValue &&other) noexcept(
-      IsSpecified(TypeSpec::kNoThrowMove)) {
-    dummy_ = kBadValue;
-    if (!IsSpecified(TypeSpec::kNoThrowMove)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    }
-    dummy_ = other.dummy_;
-    return *this;
-  }
-
-  // Arithmetic Operators
-  ThrowingValue operator+(const ThrowingValue &other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(dummy_ + other.dummy_, nothrow_ctor);
-  }
-
-  ThrowingValue operator+() const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(dummy_, nothrow_ctor);
-  }
-
-  ThrowingValue operator-(const ThrowingValue &other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(dummy_ - other.dummy_, nothrow_ctor);
-  }
-
-  ThrowingValue operator-() const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(-dummy_, nothrow_ctor);
-  }
-
-  ThrowingValue &operator++() {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    ++dummy_;
-    return *this;
-  }
-
-  ThrowingValue operator++(int) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    auto out = ThrowingValue(dummy_, nothrow_ctor);
-    ++dummy_;
-    return out;
-  }
-
-  ThrowingValue &operator--() {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    --dummy_;
-    return *this;
-  }
-
-  ThrowingValue operator--(int) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    auto out = ThrowingValue(dummy_, nothrow_ctor);
-    --dummy_;
-    return out;
-  }
-
-  ThrowingValue operator*(const ThrowingValue &other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(dummy_ * other.dummy_, nothrow_ctor);
-  }
-
-  ThrowingValue operator/(const ThrowingValue &other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(dummy_ / other.dummy_, nothrow_ctor);
-  }
-
-  ThrowingValue operator%(const ThrowingValue &other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(dummy_ % other.dummy_, nothrow_ctor);
-  }
-
-  ThrowingValue operator<<(int shift) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(dummy_ << shift, nothrow_ctor);
-  }
-
-  ThrowingValue operator>>(int shift) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(dummy_ >> shift, nothrow_ctor);
-  }
-
-  // Comparison Operators
-  // NOTE: We use `ThrowingBool` instead of `bool` because most STL
-  // types/containers requires T to be convertible to bool.
-  friend ThrowingBool operator==(const ThrowingValue &a,
-                                 const ThrowingValue &b) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return a.dummy_ == b.dummy_;
-  }
-  friend ThrowingBool operator!=(const ThrowingValue &a,
-                                 const ThrowingValue &b) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return a.dummy_ != b.dummy_;
-  }
-  friend ThrowingBool operator<(const ThrowingValue &a,
-                                const ThrowingValue &b) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return a.dummy_ < b.dummy_;
-  }
-  friend ThrowingBool operator<=(const ThrowingValue &a,
-                                 const ThrowingValue &b) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return a.dummy_ <= b.dummy_;
-  }
-  friend ThrowingBool operator>(const ThrowingValue &a,
-                                const ThrowingValue &b) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return a.dummy_ > b.dummy_;
-  }
-  friend ThrowingBool operator>=(const ThrowingValue &a,
-                                 const ThrowingValue &b) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return a.dummy_ >= b.dummy_;
-  }
-
-  // Logical Operators
-  ThrowingBool operator!() const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return !dummy_;
-  }
-
-  ThrowingBool operator&&(const ThrowingValue &other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return dummy_ && other.dummy_;
-  }
-
-  ThrowingBool operator||(const ThrowingValue &other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return dummy_ || other.dummy_;
-  }
-
-  // Bitwise Logical Operators
-  ThrowingValue operator~() const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(~dummy_, nothrow_ctor);
-  }
-
-  ThrowingValue operator&(const ThrowingValue &other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(dummy_ & other.dummy_, nothrow_ctor);
-  }
-
-  ThrowingValue operator|(const ThrowingValue &other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(dummy_ | other.dummy_, nothrow_ctor);
-  }
-
-  ThrowingValue operator^(const ThrowingValue &other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(dummy_ ^ other.dummy_, nothrow_ctor);
-  }
-
-  // Compound Assignment operators
-  ThrowingValue &operator+=(const ThrowingValue &other) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ += other.dummy_;
-    return *this;
-  }
-
-  ThrowingValue &operator-=(const ThrowingValue &other) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ -= other.dummy_;
-    return *this;
-  }
-
-  ThrowingValue &operator*=(const ThrowingValue &other) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ *= other.dummy_;
-    return *this;
-  }
-
-  ThrowingValue &operator/=(const ThrowingValue &other) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ /= other.dummy_;
-    return *this;
-  }
-
-  ThrowingValue &operator%=(const ThrowingValue &other) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ %= other.dummy_;
-    return *this;
-  }
-
-  ThrowingValue &operator&=(const ThrowingValue &other) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ &= other.dummy_;
-    return *this;
-  }
-
-  ThrowingValue &operator|=(const ThrowingValue &other) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ |= other.dummy_;
-    return *this;
-  }
-
-  ThrowingValue &operator^=(const ThrowingValue &other) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ ^= other.dummy_;
-    return *this;
-  }
-
-  ThrowingValue &operator<<=(int shift) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ <<= shift;
-    return *this;
-  }
-
-  ThrowingValue &operator>>=(int shift) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ >>= shift;
-    return *this;
-  }
-
-  // Pointer operators
-  void operator&() const = delete; // NOLINT(runtime/operator)
-
-  // Stream operators
-  friend std::ostream &operator<<(std::ostream &os, const ThrowingValue &tv) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return os << GetInstanceString(tv.dummy_);
-  }
-
-  friend std::istream &operator>>(std::istream &is, const ThrowingValue &) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return is;
-  }
-
-  // Memory management operators
-  static void *
-  operator new(size_t s) noexcept(IsSpecified(TypeSpec::kNoThrowNew)) {
-    if (!IsSpecified(TypeSpec::kNoThrowNew)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
-    }
-    return ::operator new(s);
-  }
-
-  static void *
-  operator new[](size_t s) noexcept(IsSpecified(TypeSpec::kNoThrowNew)) {
-    if (!IsSpecified(TypeSpec::kNoThrowNew)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
-    }
-    return ::operator new[](s);
-  }
-
-  template <typename... Args>
-  static void *
-  operator new(size_t s,
-               Args &&...args) noexcept(IsSpecified(TypeSpec::kNoThrowNew)) {
-    if (!IsSpecified(TypeSpec::kNoThrowNew)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
-    }
-    return ::operator new(s, std::forward<Args>(args)...);
-  }
-
-  template <typename... Args>
-  static void *
-  operator new[](size_t s,
-                 Args &&...args) noexcept(IsSpecified(TypeSpec::kNoThrowNew)) {
-    if (!IsSpecified(TypeSpec::kNoThrowNew)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
-    }
-    return ::operator new[](s, std::forward<Args>(args)...);
-  }
-
-  // Abseil doesn't support throwing overloaded operator delete.  These are
-  // provided so a throwing operator-new can clean up after itself.
-  void operator delete(void *p) noexcept { ::operator delete(p); }
-
-  template <typename... Args>
-  void operator delete(void *p, Args &&...args) noexcept {
-    ::operator delete(p, std::forward<Args>(args)...);
-  }
-
-  void operator delete[](void *p) noexcept { return ::operator delete[](p); }
-
-  template <typename... Args>
-  void operator delete[](void *p, Args &&...args) noexcept {
-    return ::operator delete[](p, std::forward<Args>(args)...);
-  }
-
-  // Non-standard access to the actual contained value.  No need for this to
-  // throw.
-  int &Get() noexcept { return dummy_; }
-  const int &Get() const noexcept { return dummy_; }
-
-private:
-  static std::string GetInstanceString(int dummy) {
-    return absl::StrCat("ThrowingValue<",
-                        exceptions_internal::GetSpecString(Spec), ">(", dummy,
-                        ")");
-  }
-
-  int dummy_;
-};
-// While not having to do with exceptions, explicitly delete comma operator, to
-// make sure we don't use it on user-supplied types.
-template <TypeSpec Spec, typename T>
-void operator,(const ThrowingValue<Spec> &, T &&) = delete;
-template <TypeSpec Spec, typename T>
-void operator,(T &&, const ThrowingValue<Spec> &) = delete;
-
-/*
- * Configuration enum for the ThrowingAllocator type that defines behavior for
- * the lifetime of the instance.
- *
- * kEverythingThrows: Calls to the member functions may throw
- * kNoThrowAllocate: Calls to the member functions will not throw
- */
-enum class AllocSpec {
-  kEverythingThrows = 0,
-  kNoThrowAllocate = 1,
-};
-
-/*
- * An allocator type which is instrumented to throw at a controlled time, or not
- * to throw, using AllocSpec. The supported settings are the default of every
- * function which is allowed to throw in a conforming allocator possibly
- * throwing, or nothing throws, in line with the ABSL_ALLOCATOR_THROWS
- * configuration macro.
- */
-template <typename T, AllocSpec Spec = AllocSpec::kEverythingThrows>
-class ThrowingAllocator : private exceptions_internal::TrackedObject {
-  static constexpr bool IsSpecified(AllocSpec spec) {
-    return static_cast<bool>(Spec & spec);
-  }
-
-public:
-  using pointer = T *;
-  using const_pointer = const T *;
-  using reference = T &;
-  using const_reference = const T &;
-  using void_pointer = void *;
-  using const_void_pointer = const void *;
-  using value_type = T;
-  using size_type = size_t;
-  using difference_type = ptrdiff_t;
-
-  using is_nothrow =
-      std::integral_constant<bool, Spec == AllocSpec::kNoThrowAllocate>;
-  using propagate_on_container_copy_assignment = std::true_type;
-  using propagate_on_container_move_assignment = std::true_type;
-  using propagate_on_container_swap = std::true_type;
-  using is_always_equal = std::false_type;
-
-  ThrowingAllocator() : TrackedObject(GetInstanceString(next_id_)) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ = std::make_shared<const int>(next_id_++);
-  }
-
-  template <typename U>
-  ThrowingAllocator(const ThrowingAllocator<U, Spec> &other) noexcept // NOLINT
-      : TrackedObject(GetInstanceString(*other.State())),
-        dummy_(other.State()) {}
-
-  // According to C++11 standard [17.6.3.5], Table 28, the move/copy ctors of
-  // allocator shall not exit via an exception, thus they are marked noexcept.
-  ThrowingAllocator(const ThrowingAllocator &other) noexcept
-      : TrackedObject(GetInstanceString(*other.State())),
-        dummy_(other.State()) {}
-
-  template <typename U>
-  ThrowingAllocator(ThrowingAllocator<U, Spec> &&other) noexcept // NOLINT
-      : TrackedObject(GetInstanceString(*other.State())),
-        dummy_(std::move(other.State())) {}
-
-  ThrowingAllocator(ThrowingAllocator &&other) noexcept
-      : TrackedObject(GetInstanceString(*other.State())),
-        dummy_(std::move(other.State())) {}
-
-  ~ThrowingAllocator() noexcept = default;
-
-  ThrowingAllocator &operator=(const ThrowingAllocator &other) noexcept {
-    dummy_ = other.State();
-    return *this;
-  }
-
-  template <typename U>
-  ThrowingAllocator &
-  operator=(const ThrowingAllocator<U, Spec> &other) noexcept {
-    dummy_ = other.State();
-    return *this;
-  }
-
-  template <typename U>
-  ThrowingAllocator &operator=(ThrowingAllocator<U, Spec> &&other) noexcept {
-    dummy_ = std::move(other.State());
-    return *this;
-  }
-
-  template <typename U> struct rebind {
-    using other = ThrowingAllocator<U, Spec>;
-  };
-
-  pointer
-  allocate(size_type n) noexcept(IsSpecified(AllocSpec::kNoThrowAllocate)) {
-    ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
-    return static_cast<pointer>(::operator new(n * sizeof(T)));
-  }
-
-  pointer allocate(size_type n, const_void_pointer) noexcept(
-      IsSpecified(AllocSpec::kNoThrowAllocate)) {
-    return allocate(n);
-  }
-
-  void deallocate(pointer ptr, size_type) noexcept {
-    ReadState();
-    ::operator delete(static_cast<void *>(ptr));
-  }
-
-  template <typename U, typename... Args>
-  void
-  construct(U *ptr,
-            Args &&...args) noexcept(IsSpecified(AllocSpec::kNoThrowAllocate)) {
-    ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
-    ::new (static_cast<void *>(ptr)) U(std::forward<Args>(args)...);
-  }
-
-  template <typename U> void destroy(U *p) noexcept {
-    ReadState();
-    p->~U();
-  }
-
-  size_type max_size() const noexcept {
-    return (std::numeric_limits<difference_type>::max)() / sizeof(value_type);
-  }
-
-  ThrowingAllocator select_on_container_copy_construction() noexcept(
-      IsSpecified(AllocSpec::kNoThrowAllocate)) {
-    ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
-    return *this;
-  }
-
-  template <typename U>
-  bool operator==(const ThrowingAllocator<U, Spec> &other) const noexcept {
-    return dummy_ == other.dummy_;
-  }
-
-  template <typename U>
-  bool operator!=(const ThrowingAllocator<U, Spec> &other) const noexcept {
-    return dummy_ != other.dummy_;
-  }
-
-  template <typename, AllocSpec> friend class ThrowingAllocator;
-
-private:
-  static std::string GetInstanceString(int dummy) {
-    return absl::StrCat("ThrowingAllocator<",
-                        exceptions_internal::GetSpecString(Spec), ">(", dummy,
-                        ")");
-  }
-
-  const std::shared_ptr<const int> &State() const { return dummy_; }
-  std::shared_ptr<const int> &State() { return dummy_; }
-
-  void ReadState() {
-    // we know that this will never be true, but the compiler doesn't, so this
-    // should safely force a read of the value.
-    if (*dummy_ < 0)
-      std::abort();
-  }
-
-  void ReadStateAndMaybeThrow(absl::string_view msg) const {
-    if (!IsSpecified(AllocSpec::kNoThrowAllocate)) {
-      exceptions_internal::MaybeThrow(
-          absl::Substitute("Allocator id $0 threw from $1", *dummy_, msg));
-    }
-  }
-
-  static int next_id_;
-  std::shared_ptr<const int> dummy_;
-};
-
-template <typename T, AllocSpec Spec>
-int ThrowingAllocator<T, Spec>::next_id_ = 0;
-
-// Tests for resource leaks by attempting to construct a T using args repeatedly
-// until successful, using the countdown method.  Side effects can then be
-// tested for resource leaks.
-template <typename T, typename... Args> void TestThrowingCtor(Args &&...args) {
-  struct Cleanup {
-    ~Cleanup() { exceptions_internal::UnsetCountdown(); }
-  } c;
-  for (int count = 0;; ++count) {
-    exceptions_internal::ConstructorTracker ct(count);
-    exceptions_internal::SetCountdown(count);
-    try {
-      T temp(std::forward<Args>(args)...);
-      static_cast<void>(temp);
-      break;
-    } catch (const exceptions_internal::TestException &) {
-    }
-  }
-}
-
-// Tests the nothrow guarantee of the provided nullary operation. If the an
-// exception is thrown, the result will be AssertionFailure(). Otherwise, it
-// will be AssertionSuccess().
-template <typename Operation>
-testing::AssertionResult TestNothrowOp(const Operation &operation) {
-  struct Cleanup {
-    Cleanup() { exceptions_internal::SetCountdown(); }
-    ~Cleanup() { exceptions_internal::UnsetCountdown(); }
-  } c;
-  try {
-    operation();
-    return testing::AssertionSuccess();
-  } catch (const exceptions_internal::TestException &) {
-    return testing::AssertionFailure()
-           << "TestException thrown during call to operation() when nothrow "
-              "guarantee was expected.";
-  } catch (...) {
-    return testing::AssertionFailure()
-           << "Unknown exception thrown during call to operation() when "
-              "nothrow guarantee was expected.";
-  }
-}
-
-namespace exceptions_internal {
-
-// Dummy struct for ExceptionSafetyTestBuilder<> partial state.
-struct UninitializedT {};
-
-template <typename T> class DefaultFactory {
-public:
-  explicit DefaultFactory(const T &t) : t_(t) {}
-  std::unique_ptr<T> operator()() const { return absl::make_unique<T>(t_); }
-
-private:
-  T t_;
-};
-
-template <size_t LazyContractsCount, typename LazyFactory,
-          typename LazyOperation>
-using EnableIfTestable = typename absl::enable_if_t<
-    LazyContractsCount != 0 &&
-    !std::is_same<LazyFactory, UninitializedT>::value &&
-    !std::is_same<LazyOperation, UninitializedT>::value>;
-
-template <typename Factory = UninitializedT,
-          typename Operation = UninitializedT, typename... Contracts>
-class ExceptionSafetyTestBuilder;
-
-} // namespace exceptions_internal
-
-/*
- * Constructs an empty ExceptionSafetyTestBuilder. All
- * ExceptionSafetyTestBuilder objects are immutable and all With[thing] mutation
- * methods return new instances of ExceptionSafetyTestBuilder.
- *
- * In order to test a T for exception safety, a factory for that T, a testable
- * operation, and at least one contract callback returning an assertion
- * result must be applied using the respective methods.
- */
-exceptions_internal::ExceptionSafetyTestBuilder<> MakeExceptionSafetyTester();
-
-namespace exceptions_internal {
-template <typename T> struct IsUniquePtr : std::false_type {};
-
-template <typename T, typename D>
-struct IsUniquePtr<std::unique_ptr<T, D>> : std::true_type {};
-
-template <typename Factory> struct FactoryPtrTypeHelper {
-  using type = decltype(std::declval<const Factory &>()());
-
-  static_assert(IsUniquePtr<type>::value, "Factories must return a unique_ptr");
-};
-
-template <typename Factory>
-using FactoryPtrType = typename FactoryPtrTypeHelper<Factory>::type;
-
-template <typename Factory>
-using FactoryElementType = typename FactoryPtrType<Factory>::element_type;
-
-template <typename T> class ExceptionSafetyTest {
-  using Factory = std::function<std::unique_ptr<T>()>;
-  using Operation = std::function<void(T *)>;
-  using Contract = std::function<AssertionResult(T *)>;
-
-public:
-  template <typename... Contracts>
-  explicit ExceptionSafetyTest(const Factory &f, const Operation &op,
-                               const Contracts &...contracts)
-      : factory_(f), operation_(op), contracts_{WrapContract(contracts)...} {}
-
-  AssertionResult Test() const {
-    for (int count = 0;; ++count) {
-      exceptions_internal::ConstructorTracker ct(count);
-
-      for (const auto &contract : contracts_) {
-        auto t_ptr = factory_();
-        try {
-          SetCountdown(count);
-          operation_(t_ptr.get());
-          // Unset for the case that the operation throws no exceptions, which
-          // would leave the countdown set and break the *next* exception safety
-          // test after this one.
-          UnsetCountdown();
-          return AssertionSuccess();
-        } catch (const exceptions_internal::TestException &e) {
-          if (!contract(t_ptr.get())) {
-            return AssertionFailure() << e.what() << " failed contract check";
-          }
-        }
-      }
-    }
-  }
-
-private:
-  template <typename ContractFn>
-  Contract WrapContract(const ContractFn &contract) {
-    return [contract](T *t_ptr) { return AssertionResult(contract(t_ptr)); };
-  }
-
-  Contract WrapContract(StrongGuaranteeTagType) {
-    return [this](T *t_ptr) { return AssertionResult(*factory_() == *t_ptr); };
-  }
-
-  Factory factory_;
-  Operation operation_;
-  std::vector<Contract> contracts_;
-};
-
-/*
- * Builds a tester object that tests if performing a operation on a T follows
- * exception safety guarantees. Verification is done via contract assertion
- * callbacks applied to T instances post-throw.
- *
- * Template parameters for ExceptionSafetyTestBuilder:
- *
- * - Factory: The factory object (passed in via tester.WithFactory(...) or
- *   tester.WithInitialValue(...)) must be invocable with the signature
- *   `std::unique_ptr<T> operator()() const` where T is the type being tested.
- *   It is used for reliably creating identical T instances to test on.
- *
- * - Operation: The operation object (passed in via tester.WithOperation(...)
- *   or tester.Test(...)) must be invocable with the signature
- *   `void operator()(T*) const` where T is the type being tested. It is used
- *   for performing steps on a T instance that may throw and that need to be
- *   checked for exception safety. Each call to the operation will receive a
- *   fresh T instance so it's free to modify and destroy the T instances as it
- *   pleases.
- *
- * - Contracts...: The contract assertion callback objects (passed in via
- *   tester.WithContracts(...)) must be invocable with the signature
- *   `testing::AssertionResult operator()(T*) const` where T is the type being
- *   tested. Contract assertion callbacks are provided T instances post-throw.
- *   They must return testing::AssertionSuccess when the type contracts of the
- *   provided T instance hold. If the type contracts of the T instance do not
- *   hold, they must return testing::AssertionFailure. Execution order of
- *   Contracts... is unspecified. They will each individually get a fresh T
- *   instance so they are free to modify and destroy the T instances as they
- *   please.
- */
-template <typename Factory, typename Operation, typename... Contracts>
-class ExceptionSafetyTestBuilder {
-public:
-  /*
-   * Returns a new ExceptionSafetyTestBuilder with an included T factory based
-   * on the provided T instance. The existing factory will not be included in
-   * the newly created tester instance. The created factory returns a new T
-   * instance by copy-constructing the provided const T& t.
-   *
-   * Preconditions for tester.WithInitialValue(const T& t):
-   *
-   * - The const T& t object must be copy-constructible where T is the type
-   *   being tested. For non-copy-constructible objects, use the method
-   *   tester.WithFactory(...).
-   */
-  template <typename T>
-  ExceptionSafetyTestBuilder<DefaultFactory<T>, Operation, Contracts...>
-  WithInitialValue(const T &t) const {
-    return WithFactory(DefaultFactory<T>(t));
-  }
-
-  /*
-   * Returns a new ExceptionSafetyTestBuilder with the provided T factory
-   * included. The existing factory will not be included in the newly-created
-   * tester instance. This method is intended for use with types lacking a copy
-   * constructor. Types that can be copy-constructed should instead use the
-   * method tester.WithInitialValue(...).
-   */
-  template <typename NewFactory>
-  ExceptionSafetyTestBuilder<absl::decay_t<NewFactory>, Operation, Contracts...>
-  WithFactory(const NewFactory &new_factory) const {
-    return {new_factory, operation_, contracts_};
-  }
-
-  /*
-   * Returns a new ExceptionSafetyTestBuilder with the provided testable
-   * operation included. The existing operation will not be included in the
-   * newly created tester.
-   */
-  template <typename NewOperation>
-  ExceptionSafetyTestBuilder<Factory, absl::decay_t<NewOperation>, Contracts...>
-  WithOperation(const NewOperation &new_operation) const {
-    return {factory_, new_operation, contracts_};
-  }
-
-  /*
-   * Returns a new ExceptionSafetyTestBuilder with the provided MoreContracts...
-   * combined with the Contracts... that were already included in the instance
-   * on which the method was called. Contracts... cannot be removed or replaced
-   * once added to an ExceptionSafetyTestBuilder instance. A fresh object must
-   * be created in order to get an empty Contracts... list.
-   *
-   * In addition to passing in custom contract assertion callbacks, this method
-   * accepts `testing::strong_guarantee` as an argument which checks T instances
-   * post-throw against freshly created T instances via operator== to verify
-   * that any state changes made during the execution of the operation were
-   * properly rolled back.
-   */
-  template <typename... MoreContracts>
-  ExceptionSafetyTestBuilder<Factory, Operation, Contracts...,
-                             absl::decay_t<MoreContracts>...>
-  WithContracts(const MoreContracts &...more_contracts) const {
-    return {
-        factory_, operation_,
-        std::tuple_cat(contracts_, std::tuple<absl::decay_t<MoreContracts>...>(
-                                       more_contracts...))};
-  }
-
-  /*
-   * Returns a testing::AssertionResult that is the reduced result of the
-   * exception safety algorithm. The algorithm short circuits and returns
-   * AssertionFailure after the first contract callback returns an
-   * AssertionFailure. Otherwise, if all contract callbacks return an
-   * AssertionSuccess, the reduced result is AssertionSuccess.
-   *
-   * The passed-in testable operation will not be saved in a new tester instance
-   * nor will it modify/replace the existing tester instance. This is useful
-   * when each operation being tested is unique and does not need to be reused.
-   *
-   * Preconditions for tester.Test(const NewOperation& new_operation):
-   *
-   * - May only be called after at least one contract assertion callback and a
-   *   factory or initial value have been provided.
-   */
-  template <
-      typename NewOperation,
-      typename = EnableIfTestable<sizeof...(Contracts), Factory, NewOperation>>
-  testing::AssertionResult Test(const NewOperation &new_operation) const {
-    return TestImpl(new_operation, absl::index_sequence_for<Contracts...>());
-  }
-
-  /*
-   * Returns a testing::AssertionResult that is the reduced result of the
-   * exception safety algorithm. The algorithm short circuits and returns
-   * AssertionFailure after the first contract callback returns an
-   * AssertionFailure. Otherwise, if all contract callbacks return an
-   * AssertionSuccess, the reduced result is AssertionSuccess.
-   *
-   * Preconditions for tester.Test():
-   *
-   * - May only be called after at least one contract assertion callback, a
-   *   factory or initial value and a testable operation have been provided.
-   */
-  template <
-      typename LazyOperation = Operation,
-      typename = EnableIfTestable<sizeof...(Contracts), Factory, LazyOperation>>
-  testing::AssertionResult Test() const {
-    return Test(operation_);
-  }
-
-private:
-  template <typename, typename, typename...>
-  friend class ExceptionSafetyTestBuilder;
-
-  friend ExceptionSafetyTestBuilder<> testing::MakeExceptionSafetyTester();
-
-  ExceptionSafetyTestBuilder() {}
-
-  ExceptionSafetyTestBuilder(const Factory &f, const Operation &o,
-                             const std::tuple<Contracts...> &i)
-      : factory_(f), operation_(o), contracts_(i) {}
-
-  template <typename SelectedOperation, size_t... Indices>
-  testing::AssertionResult TestImpl(SelectedOperation selected_operation,
-                                    absl::index_sequence<Indices...>) const {
-    return ExceptionSafetyTest<FactoryElementType<Factory>>(
-               factory_, selected_operation, std::get<Indices>(contracts_)...)
-        .Test();
-  }
-
-  Factory factory_;
-  Operation operation_;
-  std::tuple<Contracts...> contracts_;
-};
-
-} // namespace exceptions_internal
-
-} // namespace testing
-
-#endif // ABSL_HAVE_EXCEPTIONS
-
-#endif // ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/exception_testing.h b/packages/react-native-executorch/third-party/include/absl/base/internal/exception_testing.h
deleted file mode 100644
index 3bf940d8ad..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/exception_testing.h
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Testing utilities for ABSL types which throw exceptions.
-
-#ifndef ABSL_BASE_INTERNAL_EXCEPTION_TESTING_H_
-#define ABSL_BASE_INTERNAL_EXCEPTION_TESTING_H_
-
-#include "absl/base/config.h"
-#include "gtest/gtest.h"
-
-// ABSL_BASE_INTERNAL_EXPECT_FAIL tests either for a specified thrown exception
-// if exceptions are enabled, or for death with a specified text in the error
-// message
-#ifdef ABSL_HAVE_EXCEPTIONS
-
-#define ABSL_BASE_INTERNAL_EXPECT_FAIL(expr, exception_t, text)                \
-  EXPECT_THROW(expr, exception_t)
-
-#elif defined(__ANDROID__)
-// Android asserts do not log anywhere that gtest can currently inspect.
-// So we expect exit, but cannot match the message.
-#define ABSL_BASE_INTERNAL_EXPECT_FAIL(expr, exception_t, text)                \
-  EXPECT_DEATH(expr, ".*")
-#else
-#define ABSL_BASE_INTERNAL_EXPECT_FAIL(expr, exception_t, text)                \
-  EXPECT_DEATH_IF_SUPPORTED(expr, text)
-
-#endif
-
-#endif // ABSL_BASE_INTERNAL_EXCEPTION_TESTING_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/fast_type_id.h b/packages/react-native-executorch/third-party/include/absl/base/internal/fast_type_id.h
deleted file mode 100644
index b233bd0050..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/fast_type_id.h
+++ /dev/null
@@ -1,47 +0,0 @@
-//
-// Copyright 2020 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef ABSL_BASE_INTERNAL_FAST_TYPE_ID_H_
-#define ABSL_BASE_INTERNAL_FAST_TYPE_ID_H_
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-template <typename Type> struct FastTypeTag {
-  constexpr static char dummy_var = 0;
-};
-
-#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-template <typename Type> constexpr char FastTypeTag<Type>::dummy_var;
-#endif
-
-// FastTypeId<Type>() evaluates at compile/link-time to a unique pointer for the
-// passed-in type. These are meant to be good match for keys into maps or
-// straight up comparisons.
-using FastTypeIdType = const void *;
-
-template <typename Type> constexpr inline FastTypeIdType FastTypeId() {
-  return &FastTypeTag<Type>::dummy_var;
-}
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_INTERNAL_FAST_TYPE_ID_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/hide_ptr.h b/packages/react-native-executorch/third-party/include/absl/base/internal/hide_ptr.h
deleted file mode 100644
index 400fb388ba..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/hide_ptr.h
+++ /dev/null
@@ -1,49 +0,0 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_BASE_INTERNAL_HIDE_PTR_H_
-#define ABSL_BASE_INTERNAL_HIDE_PTR_H_
-
-#include <cstdint>
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-// Arbitrary value with high bits set. Xor'ing with it is unlikely
-// to map one valid pointer to another valid pointer.
-constexpr uintptr_t HideMask() {
-  return (uintptr_t{0xF03A5F7BU} << (sizeof(uintptr_t) - 4) * 8) | 0xF03A5F7BU;
-}
-
-// Hide a pointer from the leak checker. For internal use only.
-// Differs from absl::IgnoreLeak(ptr) in that absl::IgnoreLeak(ptr) causes ptr
-// and all objects reachable from ptr to be ignored by the leak checker.
-template <class T> inline uintptr_t HidePtr(T *ptr) {
-  return reinterpret_cast<uintptr_t>(ptr) ^ HideMask();
-}
-
-// Return a pointer that has been hidden from the leak checker.
-// For internal use only.
-template <class T> inline T *UnhidePtr(uintptr_t hidden) {
-  return reinterpret_cast<T *>(hidden ^ HideMask());
-}
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_INTERNAL_HIDE_PTR_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/identity.h b/packages/react-native-executorch/third-party/include/absl/base/internal/identity.h
deleted file mode 100644
index 475c58c32b..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/identity.h
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef ABSL_BASE_INTERNAL_IDENTITY_H_
-#define ABSL_BASE_INTERNAL_IDENTITY_H_
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace internal {
-
-// This is a back-fill of C++20's `std::type_identity`.
-template <typename T> struct type_identity {
-  typedef T type;
-};
-
-// This is a back-fill of C++20's `std::type_identity_t`.
-template <typename T> using type_identity_t = typename type_identity<T>::type;
-
-} // namespace internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_INTERNAL_IDENTITY_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/inline_variable.h b/packages/react-native-executorch/third-party/include/absl/base/internal/inline_variable.h
deleted file mode 100644
index ef28d10271..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/inline_variable.h
+++ /dev/null
@@ -1,108 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_BASE_INTERNAL_INLINE_VARIABLE_H_
-#define ABSL_BASE_INTERNAL_INLINE_VARIABLE_H_
-
-#include <type_traits>
-
-#include "absl/base/internal/identity.h"
-
-// File:
-//   This file define a macro that allows the creation of or emulation of C++17
-//   inline variables based on whether or not the feature is supported.
-
-////////////////////////////////////////////////////////////////////////////////
-// Macro: ABSL_INTERNAL_INLINE_CONSTEXPR(type, name, init)
-//
-// Description:
-//   Expands to the equivalent of an inline constexpr instance of the specified
-//   `type` and `name`, initialized to the value `init`. If the compiler being
-//   used is detected as supporting actual inline variables as a language
-//   feature, then the macro expands to an actual inline variable definition.
-//
-// Requires:
-//   `type` is a type that is usable in an extern variable declaration.
-//
-// Requires: `name` is a valid identifier
-//
-// Requires:
-//   `init` is an expression that can be used in the following definition:
-//     constexpr type name = init;
-//
-// Usage:
-//
-//   // Equivalent to: `inline constexpr size_t variant_npos = -1;`
-//   ABSL_INTERNAL_INLINE_CONSTEXPR(size_t, variant_npos, -1);
-//
-// Differences in implementation:
-//   For a direct, language-level inline variable, decltype(name) will be the
-//   type that was specified along with const qualification, whereas for
-//   emulated inline variables, decltype(name) may be different (in practice
-//   it will likely be a reference type).
-////////////////////////////////////////////////////////////////////////////////
-
-#ifdef __cpp_inline_variables
-
-// Clang's -Wmissing-variable-declarations option erroneously warned that
-// inline constexpr objects need to be pre-declared. This has now been fixed,
-// but we will need to support this workaround for people building with older
-// versions of clang.
-//
-// Bug: https://bugs.llvm.org/show_bug.cgi?id=35862
-//
-// Note:
-//   type_identity_t is used here so that the const and name are in the
-//   appropriate place for pointer types, reference types, function pointer
-//   types, etc..
-#if defined(__clang__)
-#define ABSL_INTERNAL_EXTERN_DECL(type, name)                                  \
-  extern const ::absl::internal::type_identity_t<type> name;
-#else // Otherwise, just define the macro to do nothing.
-#define ABSL_INTERNAL_EXTERN_DECL(type, name)
-#endif // defined(__clang__)
-
-// See above comment at top of file for details.
-#define ABSL_INTERNAL_INLINE_CONSTEXPR(type, name, init)                       \
-  ABSL_INTERNAL_EXTERN_DECL(type, name)                                        \
-  inline constexpr ::absl::internal::type_identity_t<type> name = init
-
-#else
-
-// See above comment at top of file for details.
-//
-// Note:
-//   type_identity_t is used here so that the const and name are in the
-//   appropriate place for pointer types, reference types, function pointer
-//   types, etc..
-#define ABSL_INTERNAL_INLINE_CONSTEXPR(var_type, name, init)                   \
-  template <class /*AbslInternalDummy*/ = void>                                \
-  struct AbslInternalInlineVariableHolder##name {                              \
-    static constexpr ::absl::internal::type_identity_t<var_type> kInstance =   \
-        init;                                                                  \
-  };                                                                           \
-                                                                               \
-  template <class AbslInternalDummy>                                           \
-  constexpr ::absl::internal::type_identity_t<var_type>                        \
-      AbslInternalInlineVariableHolder##name<AbslInternalDummy>::kInstance;    \
-                                                                               \
-  static constexpr const ::absl::internal::type_identity_t<var_type>           \
-      &name = /* NOLINT */                                                     \
-      AbslInternalInlineVariableHolder##name<>::kInstance;                     \
-  static_assert(sizeof(void (*)(decltype(name))) != 0,                         \
-                "Silence unused variable warnings.")
-
-#endif // __cpp_inline_variables
-
-#endif // ABSL_BASE_INTERNAL_INLINE_VARIABLE_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/inline_variable_testing.h b/packages/react-native-executorch/third-party/include/absl/base/internal/inline_variable_testing.h
deleted file mode 100644
index d0a7809a5d..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/inline_variable_testing.h
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_BASE_INTERNAL_INLINE_VARIABLE_TESTING_H_
-#define ABSL_BASE_INTERNAL_INLINE_VARIABLE_TESTING_H_
-
-#include "absl/base/internal/inline_variable.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace inline_variable_testing_internal {
-
-struct Foo {
-  int value = 5;
-};
-
-ABSL_INTERNAL_INLINE_CONSTEXPR(Foo, inline_variable_foo, {});
-ABSL_INTERNAL_INLINE_CONSTEXPR(Foo, other_inline_variable_foo, {});
-
-ABSL_INTERNAL_INLINE_CONSTEXPR(int, inline_variable_int, 5);
-ABSL_INTERNAL_INLINE_CONSTEXPR(int, other_inline_variable_int, 5);
-
-ABSL_INTERNAL_INLINE_CONSTEXPR(void (*)(), inline_variable_fun_ptr, nullptr);
-
-const Foo &get_foo_a();
-const Foo &get_foo_b();
-
-const int &get_int_a();
-const int &get_int_b();
-
-} // namespace inline_variable_testing_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_INTERNAL_INLINE_VARIABLE_TESTING_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/invoke.h b/packages/react-native-executorch/third-party/include/absl/base/internal/invoke.h
deleted file mode 100644
index 3b59425a91..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/invoke.h
+++ /dev/null
@@ -1,235 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// absl::base_internal::invoke(f, args...) is an implementation of
-// INVOKE(f, args...) from section [func.require] of the C++ standard.
-// When compiled as C++17 and later versions, it is implemented as an alias of
-// std::invoke.
-//
-// [func.require]
-// Define INVOKE (f, t1, t2, ..., tN) as follows:
-// 1. (t1.*f)(t2, ..., tN) when f is a pointer to a member function of a class T
-//    and t1 is an object of type T or a reference to an object of type T or a
-//    reference to an object of a type derived from T;
-// 2. ((*t1).*f)(t2, ..., tN) when f is a pointer to a member function of a
-//    class T and t1 is not one of the types described in the previous item;
-// 3. t1.*f when N == 1 and f is a pointer to member data of a class T and t1 is
-//    an object of type T or a reference to an object of type T or a reference
-//    to an object of a type derived from T;
-// 4. (*t1).*f when N == 1 and f is a pointer to member data of a class T and t1
-//    is not one of the types described in the previous item;
-// 5. f(t1, t2, ..., tN) in all other cases.
-//
-// The implementation is SFINAE-friendly: substitution failure within invoke()
-// isn't an error.
-
-#ifndef ABSL_BASE_INTERNAL_INVOKE_H_
-#define ABSL_BASE_INTERNAL_INVOKE_H_
-
-#include "absl/base/config.h"
-
-#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
-
-#include <functional>
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-using std::invoke;
-using std::invoke_result_t;
-using std::is_invocable_r;
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#else // ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
-
-#include <algorithm>
-#include <type_traits>
-#include <utility>
-
-#include "absl/meta/type_traits.h"
-
-// The following code is internal implementation detail.  See the comment at the
-// top of this file for the API documentation.
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-// The five classes below each implement one of the clauses from the definition
-// of INVOKE. The inner class template Accept<F, Args...> checks whether the
-// clause is applicable; static function template Invoke(f, args...) does the
-// invocation.
-//
-// By separating the clause selection logic from invocation we make sure that
-// Invoke() does exactly what the standard says.
-
-template <typename Derived> struct StrippedAccept {
-  template <typename... Args>
-  struct Accept : Derived::template AcceptImpl<typename std::remove_cv<
-                      typename std::remove_reference<Args>::type>::type...> {};
-};
-
-// (t1.*f)(t2, ..., tN) when f is a pointer to a member function of a class T
-// and t1 is an object of type T or a reference to an object of type T or a
-// reference to an object of a type derived from T.
-struct MemFunAndRef : StrippedAccept<MemFunAndRef> {
-  template <typename... Args> struct AcceptImpl : std::false_type {};
-
-  template <typename MemFunType, typename C, typename Obj, typename... Args>
-  struct AcceptImpl<MemFunType C::*, Obj, Args...>
-      : std::integral_constant<bool, std::is_base_of<C, Obj>::value &&
-                                         absl::is_function<MemFunType>::value> {
-  };
-
-  template <typename MemFun, typename Obj, typename... Args>
-  static decltype((std::declval<Obj>().*
-                   std::declval<MemFun>())(std::declval<Args>()...))
-  Invoke(MemFun &&mem_fun, Obj &&obj, Args &&...args) {
-// Ignore bogus GCC warnings on this line.
-// See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=101436 for similar example.
-#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(11, 0)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Warray-bounds"
-#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif
-    return (std::forward<Obj>(obj).*
-            std::forward<MemFun>(mem_fun))(std::forward<Args>(args)...);
-#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(11, 0)
-#pragma GCC diagnostic pop
-#endif
-  }
-};
-
-// ((*t1).*f)(t2, ..., tN) when f is a pointer to a member function of a
-// class T and t1 is not one of the types described in the previous item.
-struct MemFunAndPtr : StrippedAccept<MemFunAndPtr> {
-  template <typename... Args> struct AcceptImpl : std::false_type {};
-
-  template <typename MemFunType, typename C, typename Ptr, typename... Args>
-  struct AcceptImpl<MemFunType C::*, Ptr, Args...>
-      : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value &&
-                                         absl::is_function<MemFunType>::value> {
-  };
-
-  template <typename MemFun, typename Ptr, typename... Args>
-  static decltype(((*std::declval<Ptr>()).*
-                   std::declval<MemFun>())(std::declval<Args>()...))
-  Invoke(MemFun &&mem_fun, Ptr &&ptr, Args &&...args) {
-    return ((*std::forward<Ptr>(ptr)).*
-            std::forward<MemFun>(mem_fun))(std::forward<Args>(args)...);
-  }
-};
-
-// t1.*f when N == 1 and f is a pointer to member data of a class T and t1 is
-// an object of type T or a reference to an object of type T or a reference
-// to an object of a type derived from T.
-struct DataMemAndRef : StrippedAccept<DataMemAndRef> {
-  template <typename... Args> struct AcceptImpl : std::false_type {};
-
-  template <typename R, typename C, typename Obj>
-  struct AcceptImpl<R C::*, Obj>
-      : std::integral_constant<bool, std::is_base_of<C, Obj>::value &&
-                                         !absl::is_function<R>::value> {};
-
-  template <typename DataMem, typename Ref>
-  static decltype(std::declval<Ref>().*std::declval<DataMem>())
-  Invoke(DataMem &&data_mem, Ref &&ref) {
-    return std::forward<Ref>(ref).*std::forward<DataMem>(data_mem);
-  }
-};
-
-// (*t1).*f when N == 1 and f is a pointer to member data of a class T and t1
-// is not one of the types described in the previous item.
-struct DataMemAndPtr : StrippedAccept<DataMemAndPtr> {
-  template <typename... Args> struct AcceptImpl : std::false_type {};
-
-  template <typename R, typename C, typename Ptr>
-  struct AcceptImpl<R C::*, Ptr>
-      : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value &&
-                                         !absl::is_function<R>::value> {};
-
-  template <typename DataMem, typename Ptr>
-  static decltype((*std::declval<Ptr>()).*std::declval<DataMem>())
-  Invoke(DataMem &&data_mem, Ptr &&ptr) {
-    return (*std::forward<Ptr>(ptr)).*std::forward<DataMem>(data_mem);
-  }
-};
-
-// f(t1, t2, ..., tN) in all other cases.
-struct Callable {
-  // Callable doesn't have Accept because it's the last clause that gets picked
-  // when none of the previous clauses are applicable.
-  template <typename F, typename... Args>
-  static decltype(std::declval<F>()(std::declval<Args>()...))
-  Invoke(F &&f, Args &&...args) {
-    return std::forward<F>(f)(std::forward<Args>(args)...);
-  }
-};
-
-// Resolves to the first matching clause.
-template <typename... Args> struct Invoker {
-  typedef typename std::conditional<
-      MemFunAndRef::Accept<Args...>::value, MemFunAndRef,
-      typename std::conditional<
-          MemFunAndPtr::Accept<Args...>::value, MemFunAndPtr,
-          typename std::conditional<
-              DataMemAndRef::Accept<Args...>::value, DataMemAndRef,
-              typename std::conditional<DataMemAndPtr::Accept<Args...>::value,
-                                        DataMemAndPtr, Callable>::type>::type>::
-          type>::type type;
-};
-
-// The result type of Invoke<F, Args...>.
-template <typename F, typename... Args>
-using invoke_result_t = decltype(Invoker<F, Args...>::type::Invoke(
-    std::declval<F>(), std::declval<Args>()...));
-
-// Invoke(f, args...) is an implementation of INVOKE(f, args...) from section
-// [func.require] of the C++ standard.
-template <typename F, typename... Args>
-invoke_result_t<F, Args...> invoke(F &&f, Args &&...args) {
-  return Invoker<F, Args...>::type::Invoke(std::forward<F>(f),
-                                           std::forward<Args>(args)...);
-}
-
-template <typename AlwaysVoid, typename, typename, typename...>
-struct IsInvocableRImpl : std::false_type {};
-
-template <typename R, typename F, typename... Args>
-struct IsInvocableRImpl<
-    absl::void_t<absl::base_internal::invoke_result_t<F, Args...>>, R, F,
-    Args...>
-    : std::integral_constant<
-          bool,
-          std::is_convertible<absl::base_internal::invoke_result_t<F, Args...>,
-                              R>::value ||
-              std::is_void<R>::value> {};
-
-// Type trait whose member `value` is true if invoking `F` with `Args` is valid,
-// and either the return type is convertible to `R`, or `R` is void.
-// C++11-compatible version of `std::is_invocable_r`.
-template <typename R, typename F, typename... Args>
-using is_invocable_r = IsInvocableRImpl<void, R, F, Args...>;
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
-
-#endif // ABSL_BASE_INTERNAL_INVOKE_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/low_level_alloc.h b/packages/react-native-executorch/third-party/include/absl/base/internal/low_level_alloc.h
deleted file mode 100644
index 484ea67fb0..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/low_level_alloc.h
+++ /dev/null
@@ -1,127 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef ABSL_BASE_INTERNAL_LOW_LEVEL_ALLOC_H_
-#define ABSL_BASE_INTERNAL_LOW_LEVEL_ALLOC_H_
-
-// A simple thread-safe memory allocator that does not depend on
-// mutexes or thread-specific data.  It is intended to be used
-// sparingly, and only when malloc() would introduce an unwanted
-// dependency, such as inside the heap-checker, or the Mutex
-// implementation.
-
-// IWYU pragma: private, include "base/low_level_alloc.h"
-
-#include <sys/types.h>
-
-#include <cstdint>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-
-// LowLevelAlloc requires that the platform support low-level
-// allocation of virtual memory. Platforms lacking this cannot use
-// LowLevelAlloc.
-#ifdef ABSL_LOW_LEVEL_ALLOC_MISSING
-#error ABSL_LOW_LEVEL_ALLOC_MISSING cannot be directly set
-#elif !defined(ABSL_HAVE_MMAP) && !defined(_WIN32)
-#define ABSL_LOW_LEVEL_ALLOC_MISSING 1
-#endif
-
-// Using LowLevelAlloc with kAsyncSignalSafe isn't supported on Windows or
-// asm.js / WebAssembly.
-// See https://kripken.github.io/emscripten-site/docs/porting/pthreads.html
-// for more information.
-#ifdef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
-#error ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING cannot be directly set
-#elif defined(_WIN32) || defined(__asmjs__) || defined(__wasm__) ||            \
-    defined(__hexagon__)
-#define ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING 1
-#endif
-
-#include <cstddef>
-
-#include "absl/base/port.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-class LowLevelAlloc {
-public:
-  struct Arena; // an arena from which memory may be allocated
-
-  // Returns a pointer to a block of at least "request" bytes
-  // that have been newly allocated from the specific arena.
-  // for Alloc() call the DefaultArena() is used.
-  // Returns 0 if passed request==0.
-  // Does not return 0 under other circumstances; it crashes if memory
-  // is not available.
-  static void *Alloc(size_t request) ABSL_ATTRIBUTE_SECTION(malloc_hook);
-  static void *AllocWithArena(size_t request, Arena *arena)
-      ABSL_ATTRIBUTE_SECTION(malloc_hook);
-
-  // Deallocates a region of memory that was previously allocated with
-  // Alloc().   Does nothing if passed 0.   "s" must be either 0,
-  // or must have been returned from a call to Alloc() and not yet passed to
-  // Free() since that call to Alloc().  The space is returned to the arena
-  // from which it was allocated.
-  static void Free(void *s) ABSL_ATTRIBUTE_SECTION(malloc_hook);
-
-  // ABSL_ATTRIBUTE_SECTION(malloc_hook) for Alloc* and Free
-  // are to put all callers of MallocHook::Invoke* in this module
-  // into special section,
-  // so that MallocHook::GetCallerStackTrace can function accurately.
-
-  // Create a new arena.
-  // The root metadata for the new arena is allocated in the
-  // meta_data_arena; the DefaultArena() can be passed for meta_data_arena.
-  // These values may be ored into flags:
-  enum {
-    // Report calls to Alloc() and Free() via the MallocHook interface.
-    // Set in the DefaultArena.
-    kCallMallocHook = 0x0001,
-
-#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
-    // Make calls to Alloc(), Free() be async-signal-safe. Not set in
-    // DefaultArena(). Not supported on all platforms.
-    kAsyncSignalSafe = 0x0002,
-#endif
-  };
-  // Construct a new arena.  The allocation of the underlying metadata honors
-  // the provided flags.  For example, the call NewArena(kAsyncSignalSafe)
-  // is itself async-signal-safe, as well as generatating an arena that provides
-  // async-signal-safe Alloc/Free.
-  static Arena *NewArena(uint32_t flags);
-
-  // Destroys an arena allocated by NewArena and returns true,
-  // provided no allocated blocks remain in the arena.
-  // If allocated blocks remain in the arena, does nothing and
-  // returns false.
-  // It is illegal to attempt to destroy the DefaultArena().
-  static bool DeleteArena(Arena *arena);
-
-  // The default arena that always exists.
-  static Arena *DefaultArena();
-
-private:
-  LowLevelAlloc(); // no instances
-};
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_INTERNAL_LOW_LEVEL_ALLOC_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/low_level_scheduling.h b/packages/react-native-executorch/third-party/include/absl/base/internal/low_level_scheduling.h
deleted file mode 100644
index d574fb54ff..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/low_level_scheduling.h
+++ /dev/null
@@ -1,130 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Core interfaces and definitions used by by low-level interfaces such as
-// SpinLock.
-
-#ifndef ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
-#define ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
-
-#include "absl/base/internal/raw_logging.h"
-#include "absl/base/internal/scheduling_mode.h"
-#include "absl/base/macros.h"
-
-// The following two declarations exist so SchedulingGuard may friend them with
-// the appropriate language linkage.  These callbacks allow libc internals, such
-// as function level statics, to schedule cooperatively when locking.
-extern "C" bool __google_disable_rescheduling(void);
-extern "C" void __google_enable_rescheduling(bool disable_result);
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-class CondVar;
-class Mutex;
-
-namespace synchronization_internal {
-int MutexDelay(int32_t c, int mode);
-} // namespace synchronization_internal
-
-namespace base_internal {
-
-class SchedulingHelper; // To allow use of SchedulingGuard.
-class SpinLock;         // To allow use of SchedulingGuard.
-
-// SchedulingGuard
-// Provides guard semantics that may be used to disable cooperative rescheduling
-// of the calling thread within specific program blocks.  This is used to
-// protect resources (e.g. low-level SpinLocks or Domain code) that cooperative
-// scheduling depends on.
-//
-// Domain implementations capable of rescheduling in reaction to involuntary
-// kernel thread actions (e.g blocking due to a pagefault or syscall) must
-// guarantee that an annotated thread is not allowed to (cooperatively)
-// reschedule until the annotated region is complete.
-//
-// It is an error to attempt to use a cooperatively scheduled resource (e.g.
-// Mutex) within a rescheduling-disabled region.
-//
-// All methods are async-signal safe.
-class SchedulingGuard {
-public:
-  // Returns true iff the calling thread may be cooperatively rescheduled.
-  static bool ReschedulingIsAllowed();
-  SchedulingGuard(const SchedulingGuard &) = delete;
-  SchedulingGuard &operator=(const SchedulingGuard &) = delete;
-
-private:
-  // Disable cooperative rescheduling of the calling thread.  It may still
-  // initiate scheduling operations (e.g. wake-ups), however, it may not itself
-  // reschedule.  Nestable.  The returned result is opaque, clients should not
-  // attempt to interpret it.
-  // REQUIRES: Result must be passed to a pairing EnableScheduling().
-  static bool DisableRescheduling();
-
-  // Marks the end of a rescheduling disabled region, previously started by
-  // DisableRescheduling().
-  // REQUIRES: Pairs with innermost call (and result) of DisableRescheduling().
-  static void EnableRescheduling(bool disable_result);
-
-  // A scoped helper for {Disable, Enable}Rescheduling().
-  // REQUIRES: destructor must run in same thread as constructor.
-  struct ScopedDisable {
-    ScopedDisable() { disabled = SchedulingGuard::DisableRescheduling(); }
-    ~ScopedDisable() { SchedulingGuard::EnableRescheduling(disabled); }
-
-    bool disabled;
-  };
-
-  // A scoped helper to enable rescheduling temporarily.
-  // REQUIRES: destructor must run in same thread as constructor.
-  class ScopedEnable {
-  public:
-    ScopedEnable();
-    ~ScopedEnable();
-
-  private:
-    int scheduling_disabled_depth_;
-  };
-
-  // Access to SchedulingGuard is explicitly permitted.
-  friend class absl::CondVar;
-  friend class absl::Mutex;
-  friend class SchedulingHelper;
-  friend class SpinLock;
-  friend int absl::synchronization_internal::MutexDelay(int32_t c, int mode);
-};
-
-//------------------------------------------------------------------------------
-// End of public interfaces.
-//------------------------------------------------------------------------------
-
-inline bool SchedulingGuard::ReschedulingIsAllowed() { return false; }
-
-inline bool SchedulingGuard::DisableRescheduling() { return false; }
-
-inline void SchedulingGuard::EnableRescheduling(bool /* disable_result */) {
-  return;
-}
-
-inline SchedulingGuard::ScopedEnable::ScopedEnable()
-    : scheduling_disabled_depth_(0) {}
-inline SchedulingGuard::ScopedEnable::~ScopedEnable() {
-  ABSL_RAW_CHECK(scheduling_disabled_depth_ == 0, "disable unused warning");
-}
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/nullability_impl.h b/packages/react-native-executorch/third-party/include/absl/base/internal/nullability_impl.h
deleted file mode 100644
index b1f7591db6..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/nullability_impl.h
+++ /dev/null
@@ -1,69 +0,0 @@
-// Copyright 2023 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_BASE_INTERNAL_NULLABILITY_IMPL_H_
-#define ABSL_BASE_INTERNAL_NULLABILITY_IMPL_H_
-
-#include <memory>
-#include <type_traits>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/meta/type_traits.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace nullability_internal {
-
-template <typename T>
-using NullableImpl
-#if ABSL_HAVE_CPP_ATTRIBUTE(clang::annotate)
-    [[clang::annotate("Nullable")]]
-#endif
-// Don't add the _Nullable attribute in Objective-C compiles. Many Objective-C
-// projects enable the `-Wnullable-to-nonnull-conversion warning`, which is
-// liable to produce false positives.
-#if ABSL_HAVE_FEATURE(nullability_on_classes) && !defined(__OBJC__)
-    = T _Nullable;
-#else
-    = T;
-#endif
-
-template <typename T>
-using NonnullImpl
-#if ABSL_HAVE_CPP_ATTRIBUTE(clang::annotate)
-    [[clang::annotate("Nonnull")]]
-#endif
-#if ABSL_HAVE_FEATURE(nullability_on_classes) && !defined(__OBJC__)
-    = T _Nonnull;
-#else
-    = T;
-#endif
-
-template <typename T>
-using NullabilityUnknownImpl
-#if ABSL_HAVE_CPP_ATTRIBUTE(clang::annotate)
-    [[clang::annotate("Nullability_Unspecified")]]
-#endif
-#if ABSL_HAVE_FEATURE(nullability_on_classes) && !defined(__OBJC__)
-    = T _Null_unspecified;
-#else
-    = T;
-#endif
-
-} // namespace nullability_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_INTERNAL_NULLABILITY_IMPL_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/per_thread_tls.h b/packages/react-native-executorch/third-party/include/absl/base/internal/per_thread_tls.h
deleted file mode 100644
index 0dfb94354c..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/per_thread_tls.h
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_BASE_INTERNAL_PER_THREAD_TLS_H_
-#define ABSL_BASE_INTERNAL_PER_THREAD_TLS_H_
-
-// This header defines two macros:
-//
-// If the platform supports thread-local storage:
-//
-// * ABSL_PER_THREAD_TLS_KEYWORD is the C keyword needed to declare a
-//   thread-local variable
-// * ABSL_PER_THREAD_TLS is 1
-//
-// Otherwise:
-//
-// * ABSL_PER_THREAD_TLS_KEYWORD is empty
-// * ABSL_PER_THREAD_TLS is 0
-//
-// Microsoft C supports thread-local storage.
-// GCC supports it if the appropriate version of glibc is available,
-// which the programmer can indicate by defining ABSL_HAVE_TLS
-
-#include "absl/base/port.h" // For ABSL_HAVE_TLS
-
-#if defined(ABSL_PER_THREAD_TLS)
-#error ABSL_PER_THREAD_TLS cannot be directly set
-#elif defined(ABSL_PER_THREAD_TLS_KEYWORD)
-#error ABSL_PER_THREAD_TLS_KEYWORD cannot be directly set
-#elif defined(ABSL_HAVE_TLS)
-#define ABSL_PER_THREAD_TLS_KEYWORD __thread
-#define ABSL_PER_THREAD_TLS 1
-#elif defined(_MSC_VER)
-#define ABSL_PER_THREAD_TLS_KEYWORD __declspec(thread)
-#define ABSL_PER_THREAD_TLS 1
-#else
-#define ABSL_PER_THREAD_TLS_KEYWORD
-#define ABSL_PER_THREAD_TLS 0
-#endif
-
-#endif // ABSL_BASE_INTERNAL_PER_THREAD_TLS_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/poison.h b/packages/react-native-executorch/third-party/include/absl/base/internal/poison.h
deleted file mode 100644
index 6241cd3f5a..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/poison.h
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright 2024 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_BASE_INTERNAL_POISON_H_
-#define ABSL_BASE_INTERNAL_POISON_H_
-
-#include <cstdint>
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-inline void *GetBadPointerInternal() {
-  // A likely bad pointer. Pointers are required to have high bits that are all
-  // zero or all one for certain 64-bit CPUs. This pointer value will hopefully
-  // cause a crash on dereference and also be clearly recognizable as invalid.
-  constexpr uint64_t kBadPtr = 0xBAD0BAD0BAD0BAD0;
-  auto ret = reinterpret_cast<void *>(static_cast<uintptr_t>(kBadPtr));
-#ifndef _MSC_VER // MSVC doesn't support inline asm with `volatile`.
-  // Try to prevent the compiler from optimizing out the undefined behavior.
-  asm volatile("" : : "r"(ret) :); // NOLINT
-#endif
-  return ret;
-}
-
-void *InitializePoisonedPointerInternal();
-
-inline void *get_poisoned_pointer() {
-#if defined(NDEBUG) && !defined(ABSL_HAVE_ADDRESS_SANITIZER) &&                \
-    !defined(ABSL_HAVE_MEMORY_SANITIZER)
-  // In optimized non-sanitized builds, avoid the function-local static because
-  // of the codegen and runtime cost.
-  return GetBadPointerInternal();
-#else
-  // Non-optimized builds may use more robust implementation. Note that we can't
-  // use a static global because Chromium doesn't allow non-constinit globals.
-  static void *ptr = InitializePoisonedPointerInternal();
-  return ptr;
-#endif
-}
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_INTERNAL_POISON_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/pretty_function.h b/packages/react-native-executorch/third-party/include/absl/base/internal/pretty_function.h
deleted file mode 100644
index 639cca1412..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/pretty_function.h
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_BASE_INTERNAL_PRETTY_FUNCTION_H_
-#define ABSL_BASE_INTERNAL_PRETTY_FUNCTION_H_
-
-// ABSL_PRETTY_FUNCTION
-//
-// In C++11, __func__ gives the undecorated name of the current function.  That
-// is, "main", not "int main()".  Various compilers give extra macros to get the
-// decorated function name, including return type and arguments, to
-// differentiate between overload sets.  ABSL_PRETTY_FUNCTION is a portable
-// version of these macros which forwards to the correct macro on each compiler.
-#if defined(_MSC_VER)
-#define ABSL_PRETTY_FUNCTION __FUNCSIG__
-#elif defined(__GNUC__)
-#define ABSL_PRETTY_FUNCTION __PRETTY_FUNCTION__
-#else
-#error "Unsupported compiler"
-#endif
-
-#endif // ABSL_BASE_INTERNAL_PRETTY_FUNCTION_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/raw_logging.h b/packages/react-native-executorch/third-party/include/absl/base/internal/raw_logging.h
deleted file mode 100644
index 8abe8e0d43..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/raw_logging.h
+++ /dev/null
@@ -1,219 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Thread-safe logging routines that do not allocate any memory or
-// acquire any locks, and can therefore be used by low-level memory
-// allocation, synchronization, and signal-handling code.
-
-#ifndef ABSL_BASE_INTERNAL_RAW_LOGGING_H_
-#define ABSL_BASE_INTERNAL_RAW_LOGGING_H_
-
-#include <string>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/base/internal/atomic_hook.h"
-#include "absl/base/log_severity.h"
-#include "absl/base/macros.h"
-#include "absl/base/optimization.h"
-#include "absl/base/port.h"
-
-// This is similar to LOG(severity) << format..., but
-// * it is to be used ONLY by low-level modules that can't use normal LOG()
-// * it is designed to be a low-level logger that does not allocate any
-//   memory and does not need any locks, hence:
-// * it logs straight and ONLY to STDERR w/o buffering
-// * it uses an explicit printf-format and arguments list
-// * it will silently chop off really long message strings
-// Usage example:
-//   ABSL_RAW_LOG(ERROR, "Failed foo with %i: %s", status, error);
-// This will print an almost standard log line like this to stderr only:
-//   E0821 211317 file.cc:123] RAW: Failed foo with 22: bad_file
-
-#define ABSL_RAW_LOG(severity, ...)                                            \
-  do {                                                                         \
-    constexpr const char *absl_raw_log_internal_basename =                     \
-        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
-    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
-                                     absl_raw_log_internal_basename, __LINE__, \
-                                     __VA_ARGS__);                             \
-    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
-  } while (0)
-
-// Similar to CHECK(condition) << message, but for low-level modules:
-// we use only ABSL_RAW_LOG that does not allocate memory.
-// We do not want to provide args list here to encourage this usage:
-//   if (!cond)  ABSL_RAW_LOG(FATAL, "foo ...", hard_to_compute_args);
-// so that the args are not computed when not needed.
-#define ABSL_RAW_CHECK(condition, message)                                     \
-  do {                                                                         \
-    if (ABSL_PREDICT_FALSE(!(condition))) {                                    \
-      ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message);         \
-    }                                                                          \
-  } while (0)
-
-// ABSL_INTERNAL_LOG and ABSL_INTERNAL_CHECK work like the RAW variants above,
-// except that if the richer log library is linked into the binary, we dispatch
-// to that instead.  This is potentially useful for internal logging and
-// assertions, where we are using RAW_LOG neither for its async-signal-safety
-// nor for its non-allocating nature, but rather because raw logging has very
-// few other dependencies.
-//
-// The API is a subset of the above: each macro only takes two arguments.  Use
-// StrCat if you need to build a richer message.
-#define ABSL_INTERNAL_LOG(severity, message)                                   \
-  do {                                                                         \
-    constexpr const char *absl_raw_log_internal_filename = __FILE__;           \
-    ::absl::raw_log_internal::internal_log_function(                           \
-        ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename,      \
-        __LINE__, message);                                                    \
-    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
-  } while (0)
-
-#define ABSL_INTERNAL_CHECK(condition, message)                                \
-  do {                                                                         \
-    if (ABSL_PREDICT_FALSE(!(condition))) {                                    \
-      std::string death_message = "Check " #condition " failed: ";             \
-      death_message += std::string(message);                                   \
-      ABSL_INTERNAL_LOG(FATAL, death_message);                                 \
-    }                                                                          \
-  } while (0)
-
-#ifndef NDEBUG
-
-#define ABSL_RAW_DLOG(severity, ...) ABSL_RAW_LOG(severity, __VA_ARGS__)
-#define ABSL_RAW_DCHECK(condition, message) ABSL_RAW_CHECK(condition, message)
-
-#else // NDEBUG
-
-#define ABSL_RAW_DLOG(severity, ...)                                           \
-  while (false)                                                                \
-  ABSL_RAW_LOG(severity, __VA_ARGS__)
-#define ABSL_RAW_DCHECK(condition, message)                                    \
-  while (false)                                                                \
-  ABSL_RAW_CHECK(condition, message)
-
-#endif // NDEBUG
-
-#define ABSL_RAW_LOG_INTERNAL_INFO ::absl::LogSeverity::kInfo
-#define ABSL_RAW_LOG_INTERNAL_WARNING ::absl::LogSeverity::kWarning
-#define ABSL_RAW_LOG_INTERNAL_ERROR ::absl::LogSeverity::kError
-#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
-#define ABSL_RAW_LOG_INTERNAL_DFATAL ::absl::kLogDebugFatal
-#define ABSL_RAW_LOG_INTERNAL_LEVEL(severity)                                  \
-  ::absl::NormalizeLogSeverity(severity)
-
-#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_INFO
-#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_WARNING
-#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_ERROR
-#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
-#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_DFATAL
-#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_LEVEL(severity)
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace raw_log_internal {
-
-// Helper function to implement ABSL_RAW_LOG
-// Logs format... at "severity" level, reporting it
-// as called from file:line.
-// This does not allocate memory or acquire locks.
-void RawLog(absl::LogSeverity severity, const char *file, int line,
-            const char *format, ...) ABSL_PRINTF_ATTRIBUTE(4, 5);
-
-// Writes the provided buffer directly to stderr, in a signal-safe, low-level
-// manner.  Preserves errno.
-void AsyncSignalSafeWriteError(const char *s, size_t len);
-
-// compile-time function to get the "base" filename, that is, the part of
-// a filename after the last "/" or "\" path separator.  The search starts at
-// the end of the string; the second parameter is the length of the string.
-constexpr const char *Basename(const char *fname, int offset) {
-  return offset == 0 || fname[offset - 1] == '/' || fname[offset - 1] == '\\'
-             ? fname + offset
-             : Basename(fname, offset - 1);
-}
-
-// For testing only.
-// Returns true if raw logging is fully supported. When it is not
-// fully supported, no messages will be emitted, but a log at FATAL
-// severity will cause an abort.
-//
-// TODO(gfalcon): Come up with a better name for this method.
-bool RawLoggingFullySupported();
-
-// Function type for a raw_log customization hook for suppressing messages
-// by severity, and for writing custom prefixes on non-suppressed messages.
-//
-// The installed hook is called for every raw log invocation.  The message will
-// be logged to stderr only if the hook returns true.  FATAL errors will cause
-// the process to abort, even if writing to stderr is suppressed.  The hook is
-// also provided with an output buffer, where it can write a custom log message
-// prefix.
-//
-// The raw_log system does not allocate memory or grab locks.  User-provided
-// hooks must avoid these operations, and must not throw exceptions.
-//
-// 'severity' is the severity level of the message being written.
-// 'file' and 'line' are the file and line number where the ABSL_RAW_LOG macro
-// was located.
-// 'buf' and 'buf_size' are pointers to the buffer and buffer size.  If the
-// hook writes a prefix, it must increment *buf and decrement *buf_size
-// accordingly.
-using LogFilterAndPrefixHook = bool (*)(absl::LogSeverity severity,
-                                        const char *file, int line, char **buf,
-                                        int *buf_size);
-
-// Function type for a raw_log customization hook called to abort a process
-// when a FATAL message is logged.  If the provided AbortHook() returns, the
-// logging system will call abort().
-//
-// 'file' and 'line' are the file and line number where the ABSL_RAW_LOG macro
-// was located.
-// The NUL-terminated logged message lives in the buffer between 'buf_start'
-// and 'buf_end'.  'prefix_end' points to the first non-prefix character of the
-// buffer (as written by the LogFilterAndPrefixHook.)
-//
-// The lifetime of the filename and message buffers will not end while the
-// process remains alive.
-using AbortHook = void (*)(const char *file, int line, const char *buf_start,
-                           const char *prefix_end, const char *buf_end);
-
-// Internal logging function for ABSL_INTERNAL_LOG to dispatch to.
-//
-// TODO(gfalcon): When string_view no longer depends on base, change this
-// interface to take its message as a string_view instead.
-using InternalLogFunction = void (*)(absl::LogSeverity severity,
-                                     const char *file, int line,
-                                     const std::string &message);
-
-ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
-    ABSL_DLL extern base_internal::AtomicHook<InternalLogFunction>
-        internal_log_function;
-
-// Registers hooks of the above types.  Only a single hook of each type may be
-// registered.  It is an error to call these functions multiple times with
-// different input arguments.
-//
-// These functions are safe to call at any point during initialization; they do
-// not block or malloc, and are async-signal safe.
-void RegisterLogFilterAndPrefixHook(LogFilterAndPrefixHook func);
-void RegisterAbortHook(AbortHook func);
-void RegisterInternalLogFunction(InternalLogFunction func);
-
-} // namespace raw_log_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_INTERNAL_RAW_LOGGING_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/scheduling_mode.h b/packages/react-native-executorch/third-party/include/absl/base/internal/scheduling_mode.h
deleted file mode 100644
index a74367758d..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/scheduling_mode.h
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Core interfaces and definitions used by by low-level interfaces such as
-// SpinLock.
-
-#ifndef ABSL_BASE_INTERNAL_SCHEDULING_MODE_H_
-#define ABSL_BASE_INTERNAL_SCHEDULING_MODE_H_
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-// Used to describe how a thread may be scheduled.  Typically associated with
-// the declaration of a resource supporting synchronized access.
-//
-// SCHEDULE_COOPERATIVE_AND_KERNEL:
-// Specifies that when waiting, a cooperative thread (e.g. a Fiber) may
-// reschedule (using base::scheduling semantics); allowing other cooperative
-// threads to proceed.
-//
-// SCHEDULE_KERNEL_ONLY: (Also described as "non-cooperative")
-// Specifies that no cooperative scheduling semantics may be used, even if the
-// current thread is itself cooperatively scheduled.  This means that
-// cooperative threads will NOT allow other cooperative threads to execute in
-// their place while waiting for a resource of this type.  Host operating system
-// semantics (e.g. a futex) may still be used.
-//
-// When optional, clients should strongly prefer SCHEDULE_COOPERATIVE_AND_KERNEL
-// by default.  SCHEDULE_KERNEL_ONLY should only be used for resources on which
-// base::scheduling (e.g. the implementation of a Scheduler) may depend.
-//
-// NOTE: Cooperative resources may not be nested below non-cooperative ones.
-// This means that it is invalid to to acquire a SCHEDULE_COOPERATIVE_AND_KERNEL
-// resource if a SCHEDULE_KERNEL_ONLY resource is already held.
-enum SchedulingMode {
-  SCHEDULE_KERNEL_ONLY = 0,        // Allow scheduling only the host OS.
-  SCHEDULE_COOPERATIVE_AND_KERNEL, // Also allow cooperative scheduling.
-};
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_INTERNAL_SCHEDULING_MODE_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/scoped_set_env.h b/packages/react-native-executorch/third-party/include/absl/base/internal/scoped_set_env.h
deleted file mode 100644
index 1cf52c41a8..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/scoped_set_env.h
+++ /dev/null
@@ -1,45 +0,0 @@
-//
-// Copyright 2019 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef ABSL_BASE_INTERNAL_SCOPED_SET_ENV_H_
-#define ABSL_BASE_INTERNAL_SCOPED_SET_ENV_H_
-
-#include <string>
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-class ScopedSetEnv {
-public:
-  ScopedSetEnv(const char *var_name, const char *new_value);
-  ~ScopedSetEnv();
-
-private:
-  std::string var_name_;
-  std::string old_value_;
-
-  // True if the environment variable was initially not set.
-  bool was_unset_;
-};
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_INTERNAL_SCOPED_SET_ENV_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/spinlock.h b/packages/react-native-executorch/third-party/include/absl/base/internal/spinlock.h
deleted file mode 100644
index d3885177f9..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/spinlock.h
+++ /dev/null
@@ -1,275 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-//  Most users requiring mutual exclusion should use Mutex.
-//  SpinLock is provided for use in two situations:
-//   - for use by Abseil internal code that Mutex itself depends on
-//   - for async signal safety (see below)
-
-// SpinLock with a base_internal::SchedulingMode::SCHEDULE_KERNEL_ONLY is async
-// signal safe. If a spinlock is used within a signal handler, all code that
-// acquires the lock must ensure that the signal cannot arrive while they are
-// holding the lock. Typically, this is done by blocking the signal.
-//
-// Threads waiting on a SpinLock may be woken in an arbitrary order.
-
-#ifndef ABSL_BASE_INTERNAL_SPINLOCK_H_
-#define ABSL_BASE_INTERNAL_SPINLOCK_H_
-
-#include <atomic>
-#include <cstdint>
-
-#include "absl/base/attributes.h"
-#include "absl/base/const_init.h"
-#include "absl/base/dynamic_annotations.h"
-#include "absl/base/internal/low_level_scheduling.h"
-#include "absl/base/internal/raw_logging.h"
-#include "absl/base/internal/scheduling_mode.h"
-#include "absl/base/internal/tsan_mutex_interface.h"
-#include "absl/base/thread_annotations.h"
-
-namespace tcmalloc {
-namespace tcmalloc_internal {
-
-class AllocationGuardSpinLockHolder;
-
-} // namespace tcmalloc_internal
-} // namespace tcmalloc
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-class ABSL_LOCKABLE ABSL_ATTRIBUTE_WARN_UNUSED SpinLock {
-public:
-  SpinLock() : lockword_(kSpinLockCooperative) {
-    ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
-  }
-
-  // Constructors that allow non-cooperative spinlocks to be created for use
-  // inside thread schedulers.  Normal clients should not use these.
-  explicit SpinLock(base_internal::SchedulingMode mode);
-
-  // Constructor for global SpinLock instances.  See absl/base/const_init.h.
-  constexpr SpinLock(absl::ConstInitType, base_internal::SchedulingMode mode)
-      : lockword_(IsCooperative(mode) ? kSpinLockCooperative : 0) {}
-
-  // For global SpinLock instances prefer trivial destructor when possible.
-  // Default but non-trivial destructor in some build configurations causes an
-  // extra static initializer.
-#ifdef ABSL_INTERNAL_HAVE_TSAN_INTERFACE
-  ~SpinLock() { ABSL_TSAN_MUTEX_DESTROY(this, __tsan_mutex_not_static); }
-#else
-  ~SpinLock() = default;
-#endif
-
-  // Acquire this SpinLock.
-  inline void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() {
-    ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
-    if (!TryLockImpl()) {
-      SlowLock();
-    }
-    ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
-  }
-
-  // Try to acquire this SpinLock without blocking and return true if the
-  // acquisition was successful.  If the lock was not acquired, false is
-  // returned.  If this SpinLock is free at the time of the call, TryLock
-  // will return true with high probability.
-  ABSL_MUST_USE_RESULT inline bool TryLock()
-      ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true) {
-    ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_try_lock);
-    bool res = TryLockImpl();
-    ABSL_TSAN_MUTEX_POST_LOCK(
-        this, __tsan_mutex_try_lock | (res ? 0 : __tsan_mutex_try_lock_failed),
-        0);
-    return res;
-  }
-
-  // Release this SpinLock, which must be held by the calling thread.
-  inline void Unlock() ABSL_UNLOCK_FUNCTION() {
-    ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
-    uint32_t lock_value = lockword_.load(std::memory_order_relaxed);
-    lock_value = lockword_.exchange(lock_value & kSpinLockCooperative,
-                                    std::memory_order_release);
-
-    if ((lock_value & kSpinLockDisabledScheduling) != 0) {
-      base_internal::SchedulingGuard::EnableRescheduling(true);
-    }
-    if ((lock_value & kWaitTimeMask) != 0) {
-      // Collect contentionz profile info, and speed the wakeup of any waiter.
-      // The wait_cycles value indicates how long this thread spent waiting
-      // for the lock.
-      SlowUnlock(lock_value);
-    }
-    ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
-  }
-
-  // Determine if the lock is held.  When the lock is held by the invoking
-  // thread, true will always be returned. Intended to be used as
-  // CHECK(lock.IsHeld()).
-  ABSL_MUST_USE_RESULT inline bool IsHeld() const {
-    return (lockword_.load(std::memory_order_relaxed) & kSpinLockHeld) != 0;
-  }
-
-  // Return immediately if this thread holds the SpinLock exclusively.
-  // Otherwise, report an error by crashing with a diagnostic.
-  inline void AssertHeld() const ABSL_ASSERT_EXCLUSIVE_LOCK() {
-    if (!IsHeld()) {
-      ABSL_RAW_LOG(FATAL, "thread should hold the lock on SpinLock");
-    }
-  }
-
-protected:
-  // These should not be exported except for testing.
-
-  // Store number of cycles between wait_start_time and wait_end_time in a
-  // lock value.
-  static uint32_t EncodeWaitCycles(int64_t wait_start_time,
-                                   int64_t wait_end_time);
-
-  // Extract number of wait cycles in a lock value.
-  static int64_t DecodeWaitCycles(uint32_t lock_value);
-
-  // Provide access to protected method above.  Use for testing only.
-  friend struct SpinLockTest;
-  friend class tcmalloc::tcmalloc_internal::AllocationGuardSpinLockHolder;
-
-private:
-  // lockword_ is used to store the following:
-  //
-  // bit[0] encodes whether a lock is being held.
-  // bit[1] encodes whether a lock uses cooperative scheduling.
-  // bit[2] encodes whether the current lock holder disabled scheduling when
-  //        acquiring the lock. Only set when kSpinLockHeld is also set.
-  // bit[3:31] encodes time a lock spent on waiting as a 29-bit unsigned int.
-  //        This is set by the lock holder to indicate how long it waited on
-  //        the lock before eventually acquiring it. The number of cycles is
-  //        encoded as a 29-bit unsigned int, or in the case that the current
-  //        holder did not wait but another waiter is queued, the LSB
-  //        (kSpinLockSleeper) is set. The implementation does not explicitly
-  //        track the number of queued waiters beyond this. It must always be
-  //        assumed that waiters may exist if the current holder was required to
-  //        queue.
-  //
-  // Invariant: if the lock is not held, the value is either 0 or
-  // kSpinLockCooperative.
-  static constexpr uint32_t kSpinLockHeld = 1;
-  static constexpr uint32_t kSpinLockCooperative = 2;
-  static constexpr uint32_t kSpinLockDisabledScheduling = 4;
-  static constexpr uint32_t kSpinLockSleeper = 8;
-  // Includes kSpinLockSleeper.
-  static constexpr uint32_t kWaitTimeMask =
-      ~(kSpinLockHeld | kSpinLockCooperative | kSpinLockDisabledScheduling);
-
-  // Returns true if the provided scheduling mode is cooperative.
-  static constexpr bool
-  IsCooperative(base_internal::SchedulingMode scheduling_mode) {
-    return scheduling_mode == base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL;
-  }
-
-  bool IsCooperative() const {
-    return lockword_.load(std::memory_order_relaxed) & kSpinLockCooperative;
-  }
-
-  uint32_t TryLockInternal(uint32_t lock_value, uint32_t wait_cycles);
-  void SlowLock() ABSL_ATTRIBUTE_COLD;
-  void SlowUnlock(uint32_t lock_value) ABSL_ATTRIBUTE_COLD;
-  uint32_t SpinLoop();
-
-  inline bool TryLockImpl() {
-    uint32_t lock_value = lockword_.load(std::memory_order_relaxed);
-    return (TryLockInternal(lock_value, 0) & kSpinLockHeld) == 0;
-  }
-
-  std::atomic<uint32_t> lockword_;
-
-  SpinLock(const SpinLock &) = delete;
-  SpinLock &operator=(const SpinLock &) = delete;
-};
-
-// Corresponding locker object that arranges to acquire a spinlock for
-// the duration of a C++ scope.
-//
-// TODO(b/176172494): Use only [[nodiscard]] when baseline is raised.
-// TODO(b/6695610): Remove forward declaration when #ifdef is no longer needed.
-#if ABSL_HAVE_CPP_ATTRIBUTE(nodiscard)
-class [[nodiscard]] SpinLockHolder;
-#else
-class ABSL_MUST_USE_RESULT ABSL_ATTRIBUTE_TRIVIAL_ABI SpinLockHolder;
-#endif
-
-class ABSL_SCOPED_LOCKABLE SpinLockHolder {
-public:
-  inline explicit SpinLockHolder(SpinLock *l) ABSL_EXCLUSIVE_LOCK_FUNCTION(l)
-      : lock_(l) {
-    l->Lock();
-  }
-  inline ~SpinLockHolder() ABSL_UNLOCK_FUNCTION() { lock_->Unlock(); }
-
-  SpinLockHolder(const SpinLockHolder &) = delete;
-  SpinLockHolder &operator=(const SpinLockHolder &) = delete;
-
-private:
-  SpinLock *lock_;
-};
-
-// Register a hook for profiling support.
-//
-// The function pointer registered here will be called whenever a spinlock is
-// contended.  The callback is given an opaque handle to the contended spinlock
-// and the number of wait cycles.  This is thread-safe, but only a single
-// profiler can be registered.  It is an error to call this function multiple
-// times with different arguments.
-void RegisterSpinLockProfiler(void (*fn)(const void *lock,
-                                         int64_t wait_cycles));
-
-//------------------------------------------------------------------------------
-// Public interface ends here.
-//------------------------------------------------------------------------------
-
-// If (result & kSpinLockHeld) == 0, then *this was successfully locked.
-// Otherwise, returns last observed value for lockword_.
-inline uint32_t SpinLock::TryLockInternal(uint32_t lock_value,
-                                          uint32_t wait_cycles) {
-  if ((lock_value & kSpinLockHeld) != 0) {
-    return lock_value;
-  }
-
-  uint32_t sched_disabled_bit = 0;
-  if ((lock_value & kSpinLockCooperative) == 0) {
-    // For non-cooperative locks we must make sure we mark ourselves as
-    // non-reschedulable before we attempt to CompareAndSwap.
-    if (base_internal::SchedulingGuard::DisableRescheduling()) {
-      sched_disabled_bit = kSpinLockDisabledScheduling;
-    }
-  }
-
-  if (!lockword_.compare_exchange_strong(
-          lock_value,
-          kSpinLockHeld | lock_value | wait_cycles | sched_disabled_bit,
-          std::memory_order_acquire, std::memory_order_relaxed)) {
-    base_internal::SchedulingGuard::EnableRescheduling(sched_disabled_bit != 0);
-  }
-
-  return lock_value;
-}
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_INTERNAL_SPINLOCK_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/spinlock_akaros.inc b/packages/react-native-executorch/third-party/include/absl/base/internal/spinlock_akaros.inc
deleted file mode 100644
index 7b0cada4f1..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/spinlock_akaros.inc
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// This file is an Akaros-specific part of spinlock_wait.cc
-
-#include <atomic>
-
-#include "absl/base/internal/scheduling_mode.h"
-
-extern "C" {
-
-ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
-    std::atomic<uint32_t>* /* lock_word */, uint32_t /* value */,
-    int /* loop */, absl::base_internal::SchedulingMode /* mode */) {
-  // In Akaros, one must take care not to call anything that could cause a
-  // malloc(), a blocking system call, or a uthread_yield() while holding a
-  // spinlock. Our callers assume will not call into libraries or other
-  // arbitrary code.
-}
-
-ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(
-    std::atomic<uint32_t>* /* lock_word */, bool /* all */) {}
-
-}  // extern "C"
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/spinlock_linux.inc b/packages/react-native-executorch/third-party/include/absl/base/internal/spinlock_linux.inc
deleted file mode 100644
index fe8ba674f5..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/spinlock_linux.inc
+++ /dev/null
@@ -1,71 +0,0 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// This file is a Linux-specific part of spinlock_wait.cc
-
-#include <linux/futex.h>
-#include <sys/syscall.h>
-#include <unistd.h>
-
-#include <atomic>
-#include <climits>
-#include <cstdint>
-#include <ctime>
-
-#include "absl/base/attributes.h"
-#include "absl/base/internal/errno_saver.h"
-
-// The SpinLock lockword is `std::atomic<uint32_t>`. Here we assert that
-// `std::atomic<uint32_t>` is bitwise equivalent of the `int` expected
-// by SYS_futex. We also assume that reads/writes done to the lockword
-// by SYS_futex have rational semantics with regard to the
-// std::atomic<> API. C++ provides no guarantees of these assumptions,
-// but they are believed to hold in practice.
-static_assert(sizeof(std::atomic<uint32_t>) == sizeof(int),
-              "SpinLock lockword has the wrong size for a futex");
-
-// Some Android headers are missing these definitions even though they
-// support these futex operations.
-#ifdef __BIONIC__
-#ifndef SYS_futex
-#define SYS_futex __NR_futex
-#endif
-#ifndef FUTEX_PRIVATE_FLAG
-#define FUTEX_PRIVATE_FLAG 128
-#endif
-#endif
-
-#if defined(__NR_futex_time64) && !defined(SYS_futex_time64)
-#define SYS_futex_time64 __NR_futex_time64
-#endif
-
-#if defined(SYS_futex_time64) && !defined(SYS_futex)
-#define SYS_futex SYS_futex_time64
-#endif
-
-extern "C" {
-
-ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
-    std::atomic<uint32_t> *w, uint32_t value, int,
-    absl::base_internal::SchedulingMode) {
-  absl::base_internal::ErrnoSaver errno_saver;
-  syscall(SYS_futex, w, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, value, nullptr);
-}
-
-ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(
-    std::atomic<uint32_t> *w, bool all) {
-  syscall(SYS_futex, w, FUTEX_WAKE | FUTEX_PRIVATE_FLAG, all ? INT_MAX : 1, 0);
-}
-
-}  // extern "C"
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/spinlock_posix.inc b/packages/react-native-executorch/third-party/include/absl/base/internal/spinlock_posix.inc
deleted file mode 100644
index 4f6f887d99..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/spinlock_posix.inc
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// This file is a Posix-specific part of spinlock_wait.cc
-
-#include <sched.h>
-
-#include <atomic>
-#include <ctime>
-
-#include "absl/base/internal/errno_saver.h"
-#include "absl/base/internal/scheduling_mode.h"
-#include "absl/base/port.h"
-
-extern "C" {
-
-ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
-    std::atomic<uint32_t>* /* lock_word */, uint32_t /* value */, int loop,
-    absl::base_internal::SchedulingMode /* mode */) {
-  absl::base_internal::ErrnoSaver errno_saver;
-  if (loop == 0) {
-  } else if (loop == 1) {
-    sched_yield();
-  } else {
-    struct timespec tm;
-    tm.tv_sec = 0;
-    tm.tv_nsec = absl::base_internal::SpinLockSuggestedDelayNS(loop);
-    nanosleep(&tm, nullptr);
-  }
-}
-
-ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(
-    std::atomic<uint32_t>* /* lock_word */, bool /* all */) {}
-
-}  // extern "C"
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/spinlock_wait.h b/packages/react-native-executorch/third-party/include/absl/base/internal/spinlock_wait.h
deleted file mode 100644
index c55f345447..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/spinlock_wait.h
+++ /dev/null
@@ -1,95 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_BASE_INTERNAL_SPINLOCK_WAIT_H_
-#define ABSL_BASE_INTERNAL_SPINLOCK_WAIT_H_
-
-// Operations to make atomic transitions on a word, and to allow
-// waiting for those transitions to become possible.
-
-#include <atomic>
-#include <stdint.h>
-
-#include "absl/base/internal/scheduling_mode.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-// SpinLockWait() waits until it can perform one of several transitions from
-// "from" to "to".  It returns when it performs a transition where done==true.
-struct SpinLockWaitTransition {
-  uint32_t from;
-  uint32_t to;
-  bool done;
-};
-
-// Wait until *w can transition from trans[i].from to trans[i].to for some i
-// satisfying 0<=i<n && trans[i].done, atomically make the transition,
-// then return the old value of *w.   Make any other atomic transitions
-// where !trans[i].done, but continue waiting.
-//
-// Wakeups for threads blocked on SpinLockWait do not respect priorities.
-uint32_t SpinLockWait(std::atomic<uint32_t> *w, int n,
-                      const SpinLockWaitTransition trans[],
-                      SchedulingMode scheduling_mode);
-
-// If possible, wake some thread that has called SpinLockDelay(w, ...). If `all`
-// is true, wake all such threads. On some systems, this may be a no-op; on
-// those systems, threads calling SpinLockDelay() will always wake eventually
-// even if SpinLockWake() is never called.
-void SpinLockWake(std::atomic<uint32_t> *w, bool all);
-
-// Wait for an appropriate spin delay on iteration "loop" of a
-// spin loop on location *w, whose previously observed value was "value".
-// SpinLockDelay() may do nothing, may yield the CPU, may sleep a clock tick,
-// or may wait for a call to SpinLockWake(w).
-void SpinLockDelay(std::atomic<uint32_t> *w, uint32_t value, int loop,
-                   base_internal::SchedulingMode scheduling_mode);
-
-// Helper used by AbslInternalSpinLockDelay.
-// Returns a suggested delay in nanoseconds for iteration number "loop".
-int SpinLockSuggestedDelayNS(int loop);
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-// In some build configurations we pass --detect-odr-violations to the
-// gold linker.  This causes it to flag weak symbol overrides as ODR
-// violations.  Because ODR only applies to C++ and not C,
-// --detect-odr-violations ignores symbols not mangled with C++ names.
-// By changing our extension points to be extern "C", we dodge this
-// check.
-extern "C" {
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(std::atomic<uint32_t> *w,
-                                                      bool all);
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
-    std::atomic<uint32_t> *w, uint32_t value, int loop,
-    absl::base_internal::SchedulingMode scheduling_mode);
-}
-
-inline void absl::base_internal::SpinLockWake(std::atomic<uint32_t> *w,
-                                              bool all) {
-  ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(w, all);
-}
-
-inline void absl::base_internal::SpinLockDelay(
-    std::atomic<uint32_t> *w, uint32_t value, int loop,
-    absl::base_internal::SchedulingMode scheduling_mode) {
-  ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)
-  (w, value, loop, scheduling_mode);
-}
-
-#endif // ABSL_BASE_INTERNAL_SPINLOCK_WAIT_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/spinlock_win32.inc b/packages/react-native-executorch/third-party/include/absl/base/internal/spinlock_win32.inc
deleted file mode 100644
index 934c2016fb..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/spinlock_win32.inc
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// This file is a Win32-specific part of spinlock_wait.cc
-
-#include <windows.h>
-#include <atomic>
-#include "absl/base/internal/scheduling_mode.h"
-
-extern "C" {
-
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
-    std::atomic<uint32_t>* /* lock_word */, uint32_t /* value */, int loop,
-    absl::base_internal::SchedulingMode /* mode */) {
-  if (loop == 0) {
-  } else if (loop == 1) {
-    Sleep(0);
-  } else {
-    // SpinLockSuggestedDelayNS() always returns a positive integer, so this
-    // static_cast is safe.
-    Sleep(static_cast<DWORD>(
-        absl::base_internal::SpinLockSuggestedDelayNS(loop) / 1000000));
-  }
-}
-
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(
-    std::atomic<uint32_t>* /* lock_word */, bool /* all */) {}
-
-}  // extern "C"
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/strerror.h b/packages/react-native-executorch/third-party/include/absl/base/internal/strerror.h
deleted file mode 100644
index 693a985870..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/strerror.h
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright 2020 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_BASE_INTERNAL_STRERROR_H_
-#define ABSL_BASE_INTERNAL_STRERROR_H_
-
-#include <string>
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-// A portable and thread-safe alternative to C89's `strerror`.
-//
-// The C89 specification of `strerror` is not suitable for use in a
-// multi-threaded application as the returned string may be changed by calls to
-// `strerror` from another thread.  The many non-stdlib alternatives differ
-// enough in their names, availability, and semantics to justify this wrapper
-// around them.  `errno` will not be modified by a call to `absl::StrError`.
-std::string StrError(int errnum);
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_INTERNAL_STRERROR_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/sysinfo.h b/packages/react-native-executorch/third-party/include/absl/base/internal/sysinfo.h
deleted file mode 100644
index 3a20dee524..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/sysinfo.h
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// This file includes routines to find out characteristics
-// of the machine a program is running on.  It is undoubtedly
-// system-dependent.
-
-// Functions listed here that accept a pid_t as an argument act on the
-// current process if the pid_t argument is 0
-// All functions here are thread-hostile due to file caching unless
-// commented otherwise.
-
-#ifndef ABSL_BASE_INTERNAL_SYSINFO_H_
-#define ABSL_BASE_INTERNAL_SYSINFO_H_
-
-#ifndef _WIN32
-#include <sys/types.h>
-#endif
-
-#include <cstdint>
-
-#include "absl/base/config.h"
-#include "absl/base/port.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-// Nominal core processor cycles per second of each processor.   This is _not_
-// necessarily the frequency of the CycleClock counter (see cycleclock.h)
-// Thread-safe.
-double NominalCPUFrequency();
-
-// Number of logical processors (hyperthreads) in system. Thread-safe.
-int NumCPUs();
-
-// Return the thread id of the current thread, as told by the system.
-// No two currently-live threads implemented by the OS shall have the same ID.
-// Thread ids of exited threads may be reused.   Multiple user-level threads
-// may have the same thread ID if multiplexed on the same OS thread.
-//
-// On Linux, you may send a signal to the resulting ID with kill().  However,
-// it is recommended for portability that you use pthread_kill() instead.
-#ifdef _WIN32
-// On Windows, process id and thread id are of the same type according to the
-// return types of GetProcessId() and GetThreadId() are both DWORD, an unsigned
-// 32-bit type.
-using pid_t = uint32_t;
-#endif
-pid_t GetTID();
-
-// Like GetTID(), but caches the result in thread-local storage in order
-// to avoid unnecessary system calls. Note that there are some cases where
-// one must call through to GetTID directly, which is why this exists as a
-// separate function. For example, GetCachedTID() is not safe to call in
-// an asynchronous signal-handling context nor right after a call to fork().
-pid_t GetCachedTID();
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_INTERNAL_SYSINFO_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/thread_identity.h b/packages/react-native-executorch/third-party/include/absl/base/internal/thread_identity.h
deleted file mode 100644
index 8018c79e1f..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/thread_identity.h
+++ /dev/null
@@ -1,273 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Each active thread has an ThreadIdentity that may represent the thread in
-// various level interfaces.  ThreadIdentity objects are never deallocated.
-// When a thread terminates, its ThreadIdentity object may be reused for a
-// thread created later.
-
-#ifndef ABSL_BASE_INTERNAL_THREAD_IDENTITY_H_
-#define ABSL_BASE_INTERNAL_THREAD_IDENTITY_H_
-
-#ifndef _WIN32
-#include <pthread.h>
-// Defines __GOOGLE_GRTE_VERSION__ (via glibc-specific features.h) when
-// supported.
-#include <unistd.h>
-#endif
-
-#include <atomic>
-#include <cstdint>
-
-#include "absl/base/config.h"
-#include "absl/base/internal/per_thread_tls.h"
-#include "absl/base/optimization.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-struct SynchLocksHeld;
-struct SynchWaitParams;
-
-namespace base_internal {
-
-class SpinLock;
-struct ThreadIdentity;
-
-// Used by the implementation of absl::Mutex and absl::CondVar.
-struct PerThreadSynch {
-  // The internal representation of absl::Mutex and absl::CondVar rely
-  // on the alignment of PerThreadSynch. Both store the address of the
-  // PerThreadSynch in the high-order bits of their internal state,
-  // which means the low kLowZeroBits of the address of PerThreadSynch
-  // must be zero.
-  static constexpr int kLowZeroBits = 8;
-  static constexpr int kAlignment = 1 << kLowZeroBits;
-
-  // Returns the associated ThreadIdentity.
-  // This can be implemented as a cast because we guarantee
-  // PerThreadSynch is the first element of ThreadIdentity.
-  ThreadIdentity *thread_identity() {
-    return reinterpret_cast<ThreadIdentity *>(this);
-  }
-
-  PerThreadSynch *next; // Circular waiter queue; initialized to 0.
-  PerThreadSynch *skip; // If non-zero, all entries in Mutex queue
-                        // up to and including "skip" have same
-                        // condition as this, and will be woken later
-  bool may_skip;        // if false while on mutex queue, a mutex unlocker
-                        // is using this PerThreadSynch as a terminator.  Its
-                        // skip field must not be filled in because the loop
-                        // might then skip over the terminator.
-  bool wake;            // This thread is to be woken from a Mutex.
-  // If "x" is on a waiter list for a mutex, "x->cond_waiter" is true iff the
-  // waiter is waiting on the mutex as part of a CV Wait or Mutex Await.
-  //
-  // The value of "x->cond_waiter" is meaningless if "x" is not on a
-  // Mutex waiter list.
-  bool cond_waiter;
-  bool maybe_unlocking;       // Valid at head of Mutex waiter queue;
-                              // true if UnlockSlow could be searching
-                              // for a waiter to wake.  Used for an optimization
-                              // in Enqueue().  true is always a valid value.
-                              // Can be reset to false when the unlocker or any
-                              // writer releases the lock, or a reader fully
-                              // releases the lock.  It may not be set to false
-                              // by a reader that decrements the count to
-                              // non-zero. protected by mutex spinlock
-  bool suppress_fatal_errors; // If true, try to proceed even in the face
-                              // of broken invariants.  This is used within
-                              // fatal signal handlers to improve the
-                              // chances of debug logging information being
-                              // output successfully.
-  int priority;               // Priority of thread (updated every so often).
-
-  // State values:
-  //   kAvailable: This PerThreadSynch is available.
-  //   kQueued: This PerThreadSynch is unavailable, it's currently queued on a
-  //            Mutex or CondVar waistlist.
-  //
-  // Transitions from kQueued to kAvailable require a release
-  // barrier. This is needed as a waiter may use "state" to
-  // independently observe that it's no longer queued.
-  //
-  // Transitions from kAvailable to kQueued require no barrier, they
-  // are externally ordered by the Mutex.
-  enum State { kAvailable, kQueued };
-  std::atomic<State> state;
-
-  // The wait parameters of the current wait.  waitp is null if the
-  // thread is not waiting. Transitions from null to non-null must
-  // occur before the enqueue commit point (state = kQueued in
-  // Enqueue() and CondVarEnqueue()). Transitions from non-null to
-  // null must occur after the wait is finished (state = kAvailable in
-  // Mutex::Block() and CondVar::WaitCommon()). This field may be
-  // changed only by the thread that describes this PerThreadSynch.  A
-  // special case is Fer(), which calls Enqueue() on another thread,
-  // but with an identical SynchWaitParams pointer, thus leaving the
-  // pointer unchanged.
-  SynchWaitParams *waitp;
-
-  intptr_t readers; // Number of readers in mutex.
-
-  // When priority will next be read (cycles).
-  int64_t next_priority_read_cycles;
-
-  // Locks held; used during deadlock detection.
-  // Allocated in Synch_GetAllLocks() and freed in ReclaimThreadIdentity().
-  SynchLocksHeld *all_locks;
-};
-
-// The instances of this class are allocated in NewThreadIdentity() with an
-// alignment of PerThreadSynch::kAlignment and never destroyed. Initialization
-// should happen in OneTimeInitThreadIdentity().
-//
-// Instances may be reused by new threads - fields should be reset in
-// ResetThreadIdentityBetweenReuse().
-//
-// NOTE: The layout of fields in this structure is critical, please do not
-//       add, remove, or modify the field placements without fully auditing the
-//       layout.
-struct ThreadIdentity {
-  // Must be the first member.  The Mutex implementation requires that
-  // the PerThreadSynch object associated with each thread is
-  // PerThreadSynch::kAlignment aligned.  We provide this alignment on
-  // ThreadIdentity itself.
-  PerThreadSynch per_thread_synch;
-
-  // Private: Reserved for absl::synchronization_internal::Waiter.
-  struct WaiterState {
-    alignas(void *) char data[256];
-  } waiter_state;
-
-  // Used by PerThreadSem::{Get,Set}ThreadBlockedCounter().
-  std::atomic<int> *blocked_count_ptr;
-
-  // The following variables are mostly read/written just by the
-  // thread itself.  The only exception is that these are read by
-  // a ticker thread as a hint.
-  std::atomic<int> ticker;     // Tick counter, incremented once per second.
-  std::atomic<int> wait_start; // Ticker value when thread started waiting.
-  std::atomic<bool> is_idle;   // Has thread become idle yet?
-
-  ThreadIdentity *next;
-};
-
-// Returns the ThreadIdentity object representing the calling thread; guaranteed
-// to be unique for its lifetime.  The returned object will remain valid for the
-// program's lifetime; although it may be re-assigned to a subsequent thread.
-// If one does not exist, return nullptr instead.
-//
-// Does not malloc(*), and is async-signal safe.
-// [*] Technically pthread_setspecific() does malloc on first use; however this
-// is handled internally within tcmalloc's initialization already. Note that
-// darwin does *not* use tcmalloc, so this can catch you if using MallocHooks
-// on Apple platforms. Whatever function is calling your MallocHooks will need
-// to watch for recursion on Apple platforms.
-//
-// New ThreadIdentity objects can be constructed and associated with a thread
-// by calling GetOrCreateCurrentThreadIdentity() in per-thread-sem.h.
-ThreadIdentity *CurrentThreadIdentityIfPresent();
-
-using ThreadIdentityReclaimerFunction = void (*)(void *);
-
-// Sets the current thread identity to the given value.  'reclaimer' is a
-// pointer to the global function for cleaning up instances on thread
-// destruction.
-void SetCurrentThreadIdentity(ThreadIdentity *identity,
-                              ThreadIdentityReclaimerFunction reclaimer);
-
-// Removes the currently associated ThreadIdentity from the running thread.
-// This must be called from inside the ThreadIdentityReclaimerFunction, and only
-// from that function.
-void ClearCurrentThreadIdentity();
-
-// May be chosen at compile time via: -DABSL_FORCE_THREAD_IDENTITY_MODE=<mode
-// index>
-#ifdef ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
-#error ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC cannot be directly set
-#else
-#define ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC 0
-#endif
-
-#ifdef ABSL_THREAD_IDENTITY_MODE_USE_TLS
-#error ABSL_THREAD_IDENTITY_MODE_USE_TLS cannot be directly set
-#else
-#define ABSL_THREAD_IDENTITY_MODE_USE_TLS 1
-#endif
-
-#ifdef ABSL_THREAD_IDENTITY_MODE_USE_CPP11
-#error ABSL_THREAD_IDENTITY_MODE_USE_CPP11 cannot be directly set
-#else
-#define ABSL_THREAD_IDENTITY_MODE_USE_CPP11 2
-#endif
-
-#ifdef ABSL_THREAD_IDENTITY_MODE
-#error ABSL_THREAD_IDENTITY_MODE cannot be directly set
-#elif defined(ABSL_FORCE_THREAD_IDENTITY_MODE)
-#define ABSL_THREAD_IDENTITY_MODE ABSL_FORCE_THREAD_IDENTITY_MODE
-#elif defined(_WIN32) && !defined(__MINGW32__)
-#define ABSL_THREAD_IDENTITY_MODE ABSL_THREAD_IDENTITY_MODE_USE_CPP11
-#elif defined(__APPLE__) && defined(ABSL_HAVE_THREAD_LOCAL)
-#define ABSL_THREAD_IDENTITY_MODE ABSL_THREAD_IDENTITY_MODE_USE_CPP11
-#elif ABSL_PER_THREAD_TLS && defined(__GOOGLE_GRTE_VERSION__) &&               \
-    (__GOOGLE_GRTE_VERSION__ >= 20140228L)
-// Support for async-safe TLS was specifically added in GRTEv4.  It's not
-// present in the upstream eglibc.
-// Note:  Current default for production systems.
-#define ABSL_THREAD_IDENTITY_MODE ABSL_THREAD_IDENTITY_MODE_USE_TLS
-#else
-#define ABSL_THREAD_IDENTITY_MODE                                              \
-  ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
-#endif
-
-#if ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_TLS ||          \
-    ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_CPP11
-
-#if ABSL_PER_THREAD_TLS
-ABSL_CONST_INIT extern ABSL_PER_THREAD_TLS_KEYWORD ThreadIdentity
-    *thread_identity_ptr;
-#elif defined(ABSL_HAVE_THREAD_LOCAL)
-ABSL_CONST_INIT extern thread_local ThreadIdentity *thread_identity_ptr;
-#else
-#error Thread-local storage not detected on this platform
-#endif
-
-// thread_local variables cannot be in headers exposed by DLLs or in certain
-// build configurations on Apple platforms. However, it is important for
-// performance reasons in general that `CurrentThreadIdentityIfPresent` be
-// inlined. In the other cases we opt to have the function not be inlined. Note
-// that `CurrentThreadIdentityIfPresent` is declared above so we can exclude
-// this entire inline definition.
-#if !defined(__APPLE__) && !defined(ABSL_BUILD_DLL) &&                         \
-    !defined(ABSL_CONSUME_DLL)
-#define ABSL_INTERNAL_INLINE_CURRENT_THREAD_IDENTITY_IF_PRESENT 1
-#endif
-
-#ifdef ABSL_INTERNAL_INLINE_CURRENT_THREAD_IDENTITY_IF_PRESENT
-inline ThreadIdentity *CurrentThreadIdentityIfPresent() {
-  return thread_identity_ptr;
-}
-#endif
-
-#elif ABSL_THREAD_IDENTITY_MODE !=                                             \
-    ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
-#error Unknown ABSL_THREAD_IDENTITY_MODE
-#endif
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_INTERNAL_THREAD_IDENTITY_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/throw_delegate.h b/packages/react-native-executorch/third-party/include/absl/base/internal/throw_delegate.h
deleted file mode 100644
index 589212acf4..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/throw_delegate.h
+++ /dev/null
@@ -1,75 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef ABSL_BASE_INTERNAL_THROW_DELEGATE_H_
-#define ABSL_BASE_INTERNAL_THROW_DELEGATE_H_
-
-#include <string>
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-// Helper functions that allow throwing exceptions consistently from anywhere.
-// The main use case is for header-based libraries (eg templates), as they will
-// be built by many different targets with their own compiler options.
-// In particular, this will allow a safe way to throw exceptions even if the
-// caller is compiled with -fno-exceptions.  This is intended for implementing
-// things like map<>::at(), which the standard documents as throwing an
-// exception on error.
-//
-// Using other techniques like #if tricks could lead to ODR violations.
-//
-// You shouldn't use it unless you're writing code that you know will be built
-// both with and without exceptions and you need to conform to an interface
-// that uses exceptions.
-
-[[noreturn]] void ThrowStdLogicError(const std::string &what_arg);
-[[noreturn]] void ThrowStdLogicError(const char *what_arg);
-[[noreturn]] void ThrowStdInvalidArgument(const std::string &what_arg);
-[[noreturn]] void ThrowStdInvalidArgument(const char *what_arg);
-[[noreturn]] void ThrowStdDomainError(const std::string &what_arg);
-[[noreturn]] void ThrowStdDomainError(const char *what_arg);
-[[noreturn]] void ThrowStdLengthError(const std::string &what_arg);
-[[noreturn]] void ThrowStdLengthError(const char *what_arg);
-[[noreturn]] void ThrowStdOutOfRange(const std::string &what_arg);
-[[noreturn]] void ThrowStdOutOfRange(const char *what_arg);
-[[noreturn]] void ThrowStdRuntimeError(const std::string &what_arg);
-[[noreturn]] void ThrowStdRuntimeError(const char *what_arg);
-[[noreturn]] void ThrowStdRangeError(const std::string &what_arg);
-[[noreturn]] void ThrowStdRangeError(const char *what_arg);
-[[noreturn]] void ThrowStdOverflowError(const std::string &what_arg);
-[[noreturn]] void ThrowStdOverflowError(const char *what_arg);
-[[noreturn]] void ThrowStdUnderflowError(const std::string &what_arg);
-[[noreturn]] void ThrowStdUnderflowError(const char *what_arg);
-
-[[noreturn]] void ThrowStdBadFunctionCall();
-[[noreturn]] void ThrowStdBadAlloc();
-
-// ThrowStdBadArrayNewLength() cannot be consistently supported because
-// std::bad_array_new_length is missing in libstdc++ until 4.9.0.
-// https://gcc.gnu.org/onlinedocs/gcc-4.8.3/libstdc++/api/a01379_source.html
-// https://gcc.gnu.org/onlinedocs/gcc-4.9.0/libstdc++/api/a01327_source.html
-// libcxx (as of 3.2) and msvc (as of 2015) both have it.
-// [[noreturn]] void ThrowStdBadArrayNewLength();
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_INTERNAL_THROW_DELEGATE_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/tracing.h b/packages/react-native-executorch/third-party/include/absl/base/internal/tracing.h
deleted file mode 100644
index a99baefdab..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/tracing.h
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright 2024 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_BASE_INTERNAL_TRACING_H_
-#define ABSL_BASE_INTERNAL_TRACING_H_
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-// Well known Abseil object types that have causality.
-enum class ObjectKind { kUnknown, kBlockingCounter, kNotification };
-
-// `TraceWait` and `TraceContinue` record the start and end of a potentially
-// blocking wait operation on `object`. `object` typically represents a higher
-// level synchronization object such as `absl::Notification`.
-void TraceWait(const void *object, ObjectKind kind);
-void TraceContinue(const void *object, ObjectKind kind);
-
-// `TraceSignal` records a signal on `object`.
-void TraceSignal(const void *object, ObjectKind kind);
-
-// `TraceObserved` records the non-blocking observation of a signaled object.
-void TraceObserved(const void *object, ObjectKind kind);
-
-// ---------------------------------------------------------------------------
-// Weak implementation detail:
-//
-// We define the weak API as extern "C": in some build configurations we pass
-// `--detect-odr-violations` to the gold linker. This causes it to flag weak
-// symbol overrides as ODR violations. Because ODR only applies to C++ and not
-// C, `--detect-odr-violations` ignores symbols not mangled with C++ names.
-// By changing our extension points to be extern "C", we dodge this check.
-// ---------------------------------------------------------------------------
-extern "C" {
-
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalTraceWait)(const void *object,
-                                                   ObjectKind kind);
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalTraceContinue)(const void *object,
-                                                       ObjectKind kind);
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalTraceSignal)(const void *object,
-                                                     ObjectKind kind);
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalTraceObserved)(const void *object,
-                                                       ObjectKind kind);
-
-} // extern "C"
-
-inline void TraceWait(const void *object, ObjectKind kind) {
-  ABSL_INTERNAL_C_SYMBOL(AbslInternalTraceWait)(object, kind);
-}
-
-inline void TraceContinue(const void *object, ObjectKind kind) {
-  ABSL_INTERNAL_C_SYMBOL(AbslInternalTraceContinue)(object, kind);
-}
-
-inline void TraceSignal(const void *object, ObjectKind kind) {
-  ABSL_INTERNAL_C_SYMBOL(AbslInternalTraceSignal)(object, kind);
-}
-
-inline void TraceObserved(const void *object, ObjectKind kind) {
-  ABSL_INTERNAL_C_SYMBOL(AbslInternalTraceObserved)(object, kind);
-}
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_INTERNAL_TRACING_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/tsan_mutex_interface.h b/packages/react-native-executorch/third-party/include/absl/base/internal/tsan_mutex_interface.h
deleted file mode 100644
index 957c082789..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/tsan_mutex_interface.h
+++ /dev/null
@@ -1,68 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// This file is intended solely for spinlock.h.
-// It provides ThreadSanitizer annotations for custom mutexes.
-// See <sanitizer/tsan_interface.h> for meaning of these annotations.
-
-#ifndef ABSL_BASE_INTERNAL_TSAN_MUTEX_INTERFACE_H_
-#define ABSL_BASE_INTERNAL_TSAN_MUTEX_INTERFACE_H_
-
-#include "absl/base/config.h"
-
-// ABSL_INTERNAL_HAVE_TSAN_INTERFACE
-// Macro intended only for internal use.
-//
-// Checks whether LLVM Thread Sanitizer interfaces are available.
-// First made available in LLVM 5.0 (Sep 2017).
-#ifdef ABSL_INTERNAL_HAVE_TSAN_INTERFACE
-#error "ABSL_INTERNAL_HAVE_TSAN_INTERFACE cannot be directly set."
-#endif
-
-#if defined(ABSL_HAVE_THREAD_SANITIZER) && defined(__has_include)
-#if __has_include(<sanitizer/tsan_interface.h>)
-#define ABSL_INTERNAL_HAVE_TSAN_INTERFACE 1
-#endif
-#endif
-
-#ifdef ABSL_INTERNAL_HAVE_TSAN_INTERFACE
-#include <sanitizer/tsan_interface.h>
-
-#define ABSL_TSAN_MUTEX_CREATE __tsan_mutex_create
-#define ABSL_TSAN_MUTEX_DESTROY __tsan_mutex_destroy
-#define ABSL_TSAN_MUTEX_PRE_LOCK __tsan_mutex_pre_lock
-#define ABSL_TSAN_MUTEX_POST_LOCK __tsan_mutex_post_lock
-#define ABSL_TSAN_MUTEX_PRE_UNLOCK __tsan_mutex_pre_unlock
-#define ABSL_TSAN_MUTEX_POST_UNLOCK __tsan_mutex_post_unlock
-#define ABSL_TSAN_MUTEX_PRE_SIGNAL __tsan_mutex_pre_signal
-#define ABSL_TSAN_MUTEX_POST_SIGNAL __tsan_mutex_post_signal
-#define ABSL_TSAN_MUTEX_PRE_DIVERT __tsan_mutex_pre_divert
-#define ABSL_TSAN_MUTEX_POST_DIVERT __tsan_mutex_post_divert
-
-#else
-
-#define ABSL_TSAN_MUTEX_CREATE(...)
-#define ABSL_TSAN_MUTEX_DESTROY(...)
-#define ABSL_TSAN_MUTEX_PRE_LOCK(...)
-#define ABSL_TSAN_MUTEX_POST_LOCK(...)
-#define ABSL_TSAN_MUTEX_PRE_UNLOCK(...)
-#define ABSL_TSAN_MUTEX_POST_UNLOCK(...)
-#define ABSL_TSAN_MUTEX_PRE_SIGNAL(...)
-#define ABSL_TSAN_MUTEX_POST_SIGNAL(...)
-#define ABSL_TSAN_MUTEX_PRE_DIVERT(...)
-#define ABSL_TSAN_MUTEX_POST_DIVERT(...)
-
-#endif
-
-#endif // ABSL_BASE_INTERNAL_TSAN_MUTEX_INTERFACE_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/unaligned_access.h b/packages/react-native-executorch/third-party/include/absl/base/internal/unaligned_access.h
deleted file mode 100644
index 597cce3c7e..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/unaligned_access.h
+++ /dev/null
@@ -1,89 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef ABSL_BASE_INTERNAL_UNALIGNED_ACCESS_H_
-#define ABSL_BASE_INTERNAL_UNALIGNED_ACCESS_H_
-
-#include <string.h>
-
-#include <cstdint>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/base/nullability.h"
-
-// unaligned APIs
-
-// Portable handling of unaligned loads, stores, and copies.
-
-// The unaligned API is C++ only.  The declarations use C++ features
-// (namespaces, inline) which are absent or incompatible in C.
-#if defined(__cplusplus)
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-inline uint16_t UnalignedLoad16(absl::Nonnull<const void *> p) {
-  uint16_t t;
-  memcpy(&t, p, sizeof t);
-  return t;
-}
-
-inline uint32_t UnalignedLoad32(absl::Nonnull<const void *> p) {
-  uint32_t t;
-  memcpy(&t, p, sizeof t);
-  return t;
-}
-
-inline uint64_t UnalignedLoad64(absl::Nonnull<const void *> p) {
-  uint64_t t;
-  memcpy(&t, p, sizeof t);
-  return t;
-}
-
-inline void UnalignedStore16(absl::Nonnull<void *> p, uint16_t v) {
-  memcpy(p, &v, sizeof v);
-}
-
-inline void UnalignedStore32(absl::Nonnull<void *> p, uint32_t v) {
-  memcpy(p, &v, sizeof v);
-}
-
-inline void UnalignedStore64(absl::Nonnull<void *> p, uint64_t v) {
-  memcpy(p, &v, sizeof v);
-}
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#define ABSL_INTERNAL_UNALIGNED_LOAD16(_p)                                     \
-  (absl::base_internal::UnalignedLoad16(_p))
-#define ABSL_INTERNAL_UNALIGNED_LOAD32(_p)                                     \
-  (absl::base_internal::UnalignedLoad32(_p))
-#define ABSL_INTERNAL_UNALIGNED_LOAD64(_p)                                     \
-  (absl::base_internal::UnalignedLoad64(_p))
-
-#define ABSL_INTERNAL_UNALIGNED_STORE16(_p, _val)                              \
-  (absl::base_internal::UnalignedStore16(_p, _val))
-#define ABSL_INTERNAL_UNALIGNED_STORE32(_p, _val)                              \
-  (absl::base_internal::UnalignedStore32(_p, _val))
-#define ABSL_INTERNAL_UNALIGNED_STORE64(_p, _val)                              \
-  (absl::base_internal::UnalignedStore64(_p, _val))
-
-#endif // defined(__cplusplus), end of unaligned API
-
-#endif // ABSL_BASE_INTERNAL_UNALIGNED_ACCESS_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/unscaledcycleclock.h b/packages/react-native-executorch/third-party/include/absl/base/internal/unscaledcycleclock.h
deleted file mode 100644
index 2cbda0903d..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/unscaledcycleclock.h
+++ /dev/null
@@ -1,96 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// UnscaledCycleClock
-//    An UnscaledCycleClock yields the value and frequency of a cycle counter
-//    that increments at a rate that is approximately constant.
-//    This class is for internal use only, you should consider using CycleClock
-//    instead.
-//
-// Notes:
-// The cycle counter frequency is not necessarily the core clock frequency.
-// That is, CycleCounter cycles are not necessarily "CPU cycles".
-//
-// An arbitrary offset may have been added to the counter at power on.
-//
-// On some platforms, the rate and offset of the counter may differ
-// slightly when read from different CPUs of a multiprocessor.  Usually,
-// we try to ensure that the operating system adjusts values periodically
-// so that values agree approximately.   If you need stronger guarantees,
-// consider using alternate interfaces.
-//
-// The CPU is not required to maintain the ordering of a cycle counter read
-// with respect to surrounding instructions.
-
-#ifndef ABSL_BASE_INTERNAL_UNSCALEDCYCLECLOCK_H_
-#define ABSL_BASE_INTERNAL_UNSCALEDCYCLECLOCK_H_
-
-#include <cstdint>
-
-#if defined(__APPLE__)
-#include <TargetConditionals.h>
-#endif
-
-#include "absl/base/config.h"
-#include "absl/base/internal/unscaledcycleclock_config.h"
-
-#if ABSL_USE_UNSCALED_CYCLECLOCK
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace time_internal {
-class UnscaledCycleClockWrapperForGetCurrentTime;
-} // namespace time_internal
-
-namespace base_internal {
-class CycleClock;
-class UnscaledCycleClockWrapperForInitializeFrequency;
-
-class UnscaledCycleClock {
-private:
-  UnscaledCycleClock() = delete;
-
-  // Return the value of a cycle counter that counts at a rate that is
-  // approximately constant.
-  static int64_t Now();
-
-  // Return the how much UnscaledCycleClock::Now() increases per second.
-  // This is not necessarily the core CPU clock frequency.
-  // It may be the nominal value report by the kernel, rather than a measured
-  // value.
-  static double Frequency();
-
-  // Allowed users
-  friend class base_internal::CycleClock;
-  friend class time_internal::UnscaledCycleClockWrapperForGetCurrentTime;
-  friend class base_internal::UnscaledCycleClockWrapperForInitializeFrequency;
-};
-
-#if defined(__x86_64__)
-
-inline int64_t UnscaledCycleClock::Now() {
-  uint64_t low, high;
-  __asm__ volatile("rdtsc" : "=a"(low), "=d"(high));
-  return static_cast<int64_t>((high << 32) | low);
-}
-
-#endif
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_USE_UNSCALED_CYCLECLOCK
-
-#endif // ABSL_BASE_INTERNAL_UNSCALEDCYCLECLOCK_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/internal/unscaledcycleclock_config.h b/packages/react-native-executorch/third-party/include/absl/base/internal/unscaledcycleclock_config.h
deleted file mode 100644
index 9a65178cd2..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/internal/unscaledcycleclock_config.h
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright 2022 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_BASE_INTERNAL_UNSCALEDCYCLECLOCK_CONFIG_H_
-#define ABSL_BASE_INTERNAL_UNSCALEDCYCLECLOCK_CONFIG_H_
-
-#if defined(__APPLE__)
-#include <TargetConditionals.h>
-#endif
-
-// The following platforms have an implementation of a hardware counter.
-#if defined(__i386__) || defined(__x86_64__) || defined(__aarch64__) ||        \
-    defined(__powerpc__) || defined(__ppc__) || defined(_M_IX86) ||            \
-    (defined(_M_X64) && !defined(_M_ARM64EC))
-#define ABSL_HAVE_UNSCALED_CYCLECLOCK_IMPLEMENTATION 1
-#else
-#define ABSL_HAVE_UNSCALED_CYCLECLOCK_IMPLEMENTATION 0
-#endif
-
-// The following platforms often disable access to the hardware
-// counter (through a sandbox) even if the underlying hardware has a
-// usable counter. The CycleTimer interface also requires a *scaled*
-// CycleClock that runs at atleast 1 MHz. We've found some Android
-// ARM64 devices where this is not the case, so we disable it by
-// default on Android ARM64.
-#if defined(__native_client__) || (defined(__APPLE__)) ||                      \
-    (defined(__ANDROID__) && defined(__aarch64__))
-#define ABSL_USE_UNSCALED_CYCLECLOCK_DEFAULT 0
-#else
-#define ABSL_USE_UNSCALED_CYCLECLOCK_DEFAULT 1
-#endif
-
-// UnscaledCycleClock is an optional internal feature.
-// Use "#if ABSL_USE_UNSCALED_CYCLECLOCK" to test for its presence.
-// Can be overridden at compile-time via -DABSL_USE_UNSCALED_CYCLECLOCK=0|1
-#if !defined(ABSL_USE_UNSCALED_CYCLECLOCK)
-#define ABSL_USE_UNSCALED_CYCLECLOCK                                           \
-  (ABSL_HAVE_UNSCALED_CYCLECLOCK_IMPLEMENTATION &&                             \
-   ABSL_USE_UNSCALED_CYCLECLOCK_DEFAULT)
-#endif
-
-#if ABSL_USE_UNSCALED_CYCLECLOCK
-// This macro can be used to test if UnscaledCycleClock::Frequency()
-// is NominalCPUFrequency() on a particular platform.
-#if (defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) ||           \
-     defined(_M_X64))
-#define ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY
-#endif
-#endif
-
-#endif // ABSL_BASE_INTERNAL_UNSCALEDCYCLECLOCK_CONFIG_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/log_severity.h b/packages/react-native-executorch/third-party/include/absl/base/log_severity.h
deleted file mode 100644
index 18699ce9fb..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/log_severity.h
+++ /dev/null
@@ -1,191 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_BASE_LOG_SEVERITY_H_
-#define ABSL_BASE_LOG_SEVERITY_H_
-
-#include <array>
-#include <ostream>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// absl::LogSeverity
-//
-// Four severity levels are defined. Logging APIs should terminate the program
-// when a message is logged at severity `kFatal`; the other levels have no
-// special semantics.
-//
-// Values other than the four defined levels (e.g. produced by `static_cast`)
-// are valid, but their semantics when passed to a function, macro, or flag
-// depend on the function, macro, or flag. The usual behavior is to normalize
-// such values to a defined severity level, however in some cases values other
-// than the defined levels are useful for comparison.
-//
-// Example:
-//
-//   // Effectively disables all logging:
-//   SetMinLogLevel(static_cast<absl::LogSeverity>(100));
-//
-// Abseil flags may be defined with type `LogSeverity`. Dependency layering
-// constraints require that the `AbslParseFlag()` overload be declared and
-// defined in the flags library itself rather than here. The `AbslUnparseFlag()`
-// overload is defined there as well for consistency.
-//
-// absl::LogSeverity Flag String Representation
-//
-// An `absl::LogSeverity` has a string representation used for parsing
-// command-line flags based on the enumerator name (e.g. `kFatal`) or
-// its unprefixed name (without the `k`) in any case-insensitive form. (E.g.
-// "FATAL", "fatal" or "Fatal" are all valid.) Unparsing such flags produces an
-// unprefixed string representation in all caps (e.g. "FATAL") or an integer.
-//
-// Additionally, the parser accepts arbitrary integers (as if the type were
-// `int`).
-//
-// Examples:
-//
-//   --my_log_level=kInfo
-//   --my_log_level=INFO
-//   --my_log_level=info
-//   --my_log_level=0
-//
-// `DFATAL` and `kLogDebugFatal` are similarly accepted.
-//
-// Unparsing a flag produces the same result as `absl::LogSeverityName()` for
-// the standard levels and a base-ten integer otherwise.
-enum class LogSeverity : int {
-  kInfo = 0,
-  kWarning = 1,
-  kError = 2,
-  kFatal = 3,
-};
-
-// LogSeverities()
-//
-// Returns an iterable of all standard `absl::LogSeverity` values, ordered from
-// least to most severe.
-constexpr std::array<absl::LogSeverity, 4> LogSeverities() {
-  return {{absl::LogSeverity::kInfo, absl::LogSeverity::kWarning,
-           absl::LogSeverity::kError, absl::LogSeverity::kFatal}};
-}
-
-// `absl::kLogDebugFatal` equals `absl::LogSeverity::kFatal` in debug builds
-// (i.e. when `NDEBUG` is not defined) and `absl::LogSeverity::kError`
-// otherwise.  Avoid ODR-using this variable as it has internal linkage and thus
-// distinct storage in different TUs.
-#ifdef NDEBUG
-static constexpr absl::LogSeverity kLogDebugFatal = absl::LogSeverity::kError;
-#else
-static constexpr absl::LogSeverity kLogDebugFatal = absl::LogSeverity::kFatal;
-#endif
-
-// LogSeverityName()
-//
-// Returns the all-caps string representation (e.g. "INFO") of the specified
-// severity level if it is one of the standard levels and "UNKNOWN" otherwise.
-constexpr const char *LogSeverityName(absl::LogSeverity s) {
-  switch (s) {
-  case absl::LogSeverity::kInfo:
-    return "INFO";
-  case absl::LogSeverity::kWarning:
-    return "WARNING";
-  case absl::LogSeverity::kError:
-    return "ERROR";
-  case absl::LogSeverity::kFatal:
-    return "FATAL";
-  }
-  return "UNKNOWN";
-}
-
-// NormalizeLogSeverity()
-//
-// Values less than `kInfo` normalize to `kInfo`; values greater than `kFatal`
-// normalize to `kError` (**NOT** `kFatal`).
-constexpr absl::LogSeverity NormalizeLogSeverity(absl::LogSeverity s) {
-  absl::LogSeverity n = s;
-  if (n < absl::LogSeverity::kInfo)
-    n = absl::LogSeverity::kInfo;
-  if (n > absl::LogSeverity::kFatal)
-    n = absl::LogSeverity::kError;
-  return n;
-}
-constexpr absl::LogSeverity NormalizeLogSeverity(int s) {
-  return absl::NormalizeLogSeverity(static_cast<absl::LogSeverity>(s));
-}
-
-// operator<<
-//
-// The exact representation of a streamed `absl::LogSeverity` is deliberately
-// unspecified; do not rely on it.
-std::ostream &operator<<(std::ostream &os, absl::LogSeverity s);
-
-// Enums representing a lower bound for LogSeverity. APIs that only operate on
-// messages of at least a certain level (for example, `SetMinLogLevel()`) use
-// this type to specify that level. absl::LogSeverityAtLeast::kInfinity is
-// a level above all threshold levels and therefore no log message will
-// ever meet this threshold.
-enum class LogSeverityAtLeast : int {
-  kInfo = static_cast<int>(absl::LogSeverity::kInfo),
-  kWarning = static_cast<int>(absl::LogSeverity::kWarning),
-  kError = static_cast<int>(absl::LogSeverity::kError),
-  kFatal = static_cast<int>(absl::LogSeverity::kFatal),
-  kInfinity = 1000,
-};
-
-std::ostream &operator<<(std::ostream &os, absl::LogSeverityAtLeast s);
-
-// Enums representing an upper bound for LogSeverity. APIs that only operate on
-// messages of at most a certain level (for example, buffer all messages at or
-// below a certain level) use this type to specify that level.
-// absl::LogSeverityAtMost::kNegativeInfinity is a level below all threshold
-// levels and therefore will exclude all log messages.
-enum class LogSeverityAtMost : int {
-  kNegativeInfinity = -1000,
-  kInfo = static_cast<int>(absl::LogSeverity::kInfo),
-  kWarning = static_cast<int>(absl::LogSeverity::kWarning),
-  kError = static_cast<int>(absl::LogSeverity::kError),
-  kFatal = static_cast<int>(absl::LogSeverity::kFatal),
-};
-
-std::ostream &operator<<(std::ostream &os, absl::LogSeverityAtMost s);
-
-#define COMPOP(op1, op2, T)                                                    \
-  constexpr bool operator op1(absl::T lhs, absl::LogSeverity rhs) {            \
-    return static_cast<absl::LogSeverity>(lhs) op1 rhs;                        \
-  }                                                                            \
-  constexpr bool operator op2(absl::LogSeverity lhs, absl::T rhs) {            \
-    return lhs op2 static_cast<absl::LogSeverity>(rhs);                        \
-  }
-
-// Comparisons between `LogSeverity` and `LogSeverityAtLeast`/
-// `LogSeverityAtMost` are only supported in one direction.
-// Valid checks are:
-//   LogSeverity >= LogSeverityAtLeast
-//   LogSeverity < LogSeverityAtLeast
-//   LogSeverity <= LogSeverityAtMost
-//   LogSeverity > LogSeverityAtMost
-COMPOP(>, <, LogSeverityAtLeast)
-COMPOP(<=, >=, LogSeverityAtLeast)
-COMPOP(<, >, LogSeverityAtMost)
-COMPOP(>=, <=, LogSeverityAtMost)
-#undef COMPOP
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_LOG_SEVERITY_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/macros.h b/packages/react-native-executorch/third-party/include/absl/base/macros.h
deleted file mode 100644
index 3b815b4d8b..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/macros.h
+++ /dev/null
@@ -1,225 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: macros.h
-// -----------------------------------------------------------------------------
-//
-// This header file defines the set of language macros used within Abseil code.
-// For the set of macros used to determine supported compilers and platforms,
-// see absl/base/config.h instead.
-//
-// This code is compiled directly on many platforms, including client
-// platforms like Windows, Mac, and embedded systems.  Before making
-// any changes here, make sure that you're not breaking any platforms.
-
-#ifndef ABSL_BASE_MACROS_H_
-#define ABSL_BASE_MACROS_H_
-
-#include <cassert>
-#include <cstddef>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/base/optimization.h"
-#include "absl/base/options.h"
-#include "absl/base/port.h"
-
-// ABSL_ARRAYSIZE()
-//
-// Returns the number of elements in an array as a compile-time constant, which
-// can be used in defining new arrays. If you use this macro on a pointer by
-// mistake, you will get a compile-time error.
-#define ABSL_ARRAYSIZE(array)                                                  \
-  (sizeof(::absl::macros_internal::ArraySizeHelper(array)))
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace macros_internal {
-// Note: this internal template function declaration is used by ABSL_ARRAYSIZE.
-// The function doesn't need a definition, as we only use its type.
-template <typename T, size_t N>
-auto ArraySizeHelper(const T (&array)[N]) -> char (&)[N];
-} // namespace macros_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-// ABSL_BAD_CALL_IF()
-//
-// Used on a function overload to trap bad calls: any call that matches the
-// overload will cause a compile-time error. This macro uses a clang-specific
-// "enable_if" attribute, as described at
-// https://clang.llvm.org/docs/AttributeReference.html#enable-if
-//
-// Overloads which use this macro should be bracketed by
-// `#ifdef ABSL_BAD_CALL_IF`.
-//
-// Example:
-//
-//   int isdigit(int c);
-//   #ifdef ABSL_BAD_CALL_IF
-//   int isdigit(int c)
-//     ABSL_BAD_CALL_IF(c <= -1 || c > 255,
-//                       "'c' must have the value of an unsigned char or EOF");
-//   #endif // ABSL_BAD_CALL_IF
-#if ABSL_HAVE_ATTRIBUTE(enable_if)
-#define ABSL_BAD_CALL_IF(expr, msg)                                            \
-  __attribute__((enable_if(expr, "Bad call trap"), unavailable(msg)))
-#endif
-
-// ABSL_ASSERT()
-//
-// In C++11, `assert` can't be used portably within constexpr functions.
-// `assert` also generates spurious unused-symbol warnings.
-// ABSL_ASSERT functions as a runtime assert but works in C++11 constexpr
-// functions, and maintains references to symbols.  Example:
-//
-// constexpr double Divide(double a, double b) {
-//   return ABSL_ASSERT(b != 0), a / b;
-// }
-//
-// This macro is inspired by
-// https://akrzemi1.wordpress.com/2017/05/18/asserts-in-constexpr-functions/
-#if defined(NDEBUG)
-#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
-// We use `decltype` here to avoid generating unnecessary code that the
-// optimizer then has to optimize away.
-// This not only improves compilation performance by reducing codegen bloat
-// and optimization work, but also guarantees fast run-time performance without
-// having to rely on the optimizer.
-#define ABSL_ASSERT(expr) (decltype((expr) ? void() : void())())
-#else
-// Pre-C++20, lambdas can't be inside unevaluated operands, so we're forced to
-// rely on the optimizer.
-#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
-#endif
-#else
-#define ABSL_ASSERT(expr)                                                      \
-  (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0)                            \
-                             : [] { assert(false && #expr); }()) // NOLINT
-#endif
-
-// `ABSL_INTERNAL_HARDENING_ABORT()` controls how `ABSL_HARDENING_ASSERT()`
-// aborts the program in release mode (when NDEBUG is defined). The
-// implementation should abort the program as quickly as possible and ideally it
-// should not be possible to ignore the abort request.
-#define ABSL_INTERNAL_HARDENING_ABORT()                                        \
-  do {                                                                         \
-    ABSL_INTERNAL_IMMEDIATE_ABORT_IMPL();                                      \
-    ABSL_INTERNAL_UNREACHABLE_IMPL();                                          \
-  } while (false)
-
-// ABSL_HARDENING_ASSERT()
-//
-// `ABSL_HARDENING_ASSERT()` is like `ABSL_ASSERT()`, but used to implement
-// runtime assertions that should be enabled in hardened builds even when
-// `NDEBUG` is defined.
-//
-// When `NDEBUG` is not defined, `ABSL_HARDENING_ASSERT()` is identical to
-// `ABSL_ASSERT()`.
-//
-// See `ABSL_OPTION_HARDENED` in `absl/base/options.h` for more information on
-// hardened mode.
-#if (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG)
-#define ABSL_HARDENING_ASSERT(expr)                                            \
-  (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0)                            \
-                             : [] { ABSL_INTERNAL_HARDENING_ABORT(); }())
-#else
-#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
-#endif
-
-// ABSL_HARDENING_ASSERT_SLOW()
-//
-// `ABSL_HARDENING_ASSERT()` is like `ABSL_HARDENING_ASSERT()`,
-//  but specifically for assertions whose predicates are too slow
-//  to be enabled in many applications.
-//
-// When `NDEBUG` is not defined, `ABSL_HARDENING_ASSERT_SLOW()` is identical to
-// `ABSL_ASSERT()`.
-//
-// See `ABSL_OPTION_HARDENED` in `absl/base/options.h` for more information on
-// hardened mode.
-#if ABSL_OPTION_HARDENED == 1 && defined(NDEBUG)
-#define ABSL_HARDENING_ASSERT_SLOW(expr)                                       \
-  (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0)                            \
-                             : [] { ABSL_INTERNAL_HARDENING_ABORT(); }())
-#else
-#define ABSL_HARDENING_ASSERT_SLOW(expr) ABSL_ASSERT(expr)
-#endif
-
-#ifdef ABSL_HAVE_EXCEPTIONS
-#define ABSL_INTERNAL_TRY try
-#define ABSL_INTERNAL_CATCH_ANY catch (...)
-#define ABSL_INTERNAL_RETHROW                                                  \
-  do {                                                                         \
-    throw;                                                                     \
-  } while (false)
-#else // ABSL_HAVE_EXCEPTIONS
-#define ABSL_INTERNAL_TRY if (true)
-#define ABSL_INTERNAL_CATCH_ANY else if (false)
-#define ABSL_INTERNAL_RETHROW                                                  \
-  do {                                                                         \
-  } while (false)
-#endif // ABSL_HAVE_EXCEPTIONS
-
-// ABSL_DEPRECATE_AND_INLINE()
-//
-// Marks a function or type alias as deprecated and tags it to be picked up for
-// automated refactoring by go/cpp-inliner. It can added to inline function
-// definitions or type aliases. It should only be used within a header file. It
-// differs from `ABSL_DEPRECATED` in the following ways:
-//
-// 1. New uses of the function or type will be discouraged via Tricorder
-//    warnings.
-// 2. If enabled via `METADATA`, automated changes will be sent out inlining the
-//    functions's body or replacing the type where it is used.
-//
-// For example:
-//
-// ABSL_DEPRECATE_AND_INLINE() inline int OldFunc(int x) {
-//   return NewFunc(x, 0);
-// }
-//
-// will mark `OldFunc` as deprecated, and the go/cpp-inliner service will
-// replace calls to `OldFunc(x)` with calls to `NewFunc(x, 0)`. Once all calls
-// to `OldFunc` have been replaced, `OldFunc` can be deleted.
-//
-// See go/cpp-inliner for more information.
-//
-// Note: go/cpp-inliner is Google-internal service for automated refactoring.
-// While open-source users do not have access to this service, the macro is
-// provided for compatibility, and so that users receive deprecation warnings.
-#if ABSL_HAVE_CPP_ATTRIBUTE(deprecated) &&                                     \
-    ABSL_HAVE_CPP_ATTRIBUTE(clang::annotate)
-#define ABSL_DEPRECATE_AND_INLINE() [[deprecated, clang::annotate("inline-me")]]
-#elif ABSL_HAVE_CPP_ATTRIBUTE(deprecated)
-#define ABSL_DEPRECATE_AND_INLINE() [[deprecated]]
-#else
-#define ABSL_DEPRECATE_AND_INLINE()
-#endif
-
-// Requires the compiler to prove that the size of the given object is at least
-// the expected amount.
-#if ABSL_HAVE_ATTRIBUTE(diagnose_if) && ABSL_HAVE_BUILTIN(__builtin_object_size)
-#define ABSL_INTERNAL_NEED_MIN_SIZE(Obj, N)                                    \
-  __attribute__((diagnose_if(__builtin_object_size(Obj, 0) < N,                \
-                             "object size provably too small "                 \
-                             "(this would corrupt memory)",                    \
-                             "error")))
-#else
-#define ABSL_INTERNAL_NEED_MIN_SIZE(Obj, N)
-#endif
-
-#endif // ABSL_BASE_MACROS_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/no_destructor.h b/packages/react-native-executorch/third-party/include/absl/base/no_destructor.h
deleted file mode 100644
index 9242d10bd2..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/no_destructor.h
+++ /dev/null
@@ -1,208 +0,0 @@
-// Copyright 2023 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: no_destructor.h
-// -----------------------------------------------------------------------------
-//
-// This header file defines the absl::NoDestructor<T> wrapper for defining a
-// static type that does not need to be destructed upon program exit. Instead,
-// such an object survives during program exit (and can be safely accessed at
-// any time).
-//
-// absl::NoDestructor<T> is useful when when a variable has static storage
-// duration but its type has a non-trivial destructor. Global constructors are
-// not recommended because of the C++'s static initialization order fiasco (See
-// https://en.cppreference.com/w/cpp/language/siof). Global destructors are not
-// allowed due to similar concerns about destruction ordering. Using
-// absl::NoDestructor<T> as a function-local static prevents both of these
-// issues.
-//
-// See below for complete details.
-
-#ifndef ABSL_BASE_NO_DESTRUCTOR_H_
-#define ABSL_BASE_NO_DESTRUCTOR_H_
-
-#include <new>
-#include <type_traits>
-#include <utility>
-
-#include "absl/base/config.h"
-#include "absl/base/nullability.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// absl::NoDestructor<T>
-//
-// NoDestructor<T> is a wrapper around an object of type T that behaves as an
-// object of type T but never calls T's destructor. NoDestructor<T> makes it
-// safer and/or more efficient to use such objects in static storage contexts,
-// ideally as function scope static variables.
-//
-// An instance of absl::NoDestructor<T> has similar type semantics to an
-// instance of T:
-//
-// * Constructs in the same manner as an object of type T through perfect
-//   forwarding.
-// * Provides pointer/reference semantic access to the object of type T via
-//   `->`, `*`, and `get()`.
-//   (Note that `const NoDestructor<T>` works like a pointer to const `T`.)
-//
-// Additionally, NoDestructor<T> provides the following benefits:
-//
-// * Never calls T's destructor for the object
-// * If the object is a function-local static variable, the type can be
-//   lazily constructed.
-//
-// An object of type NoDestructor<T> is "trivially destructible" in the notion
-// that its destructor is never run.
-//
-// Usage as Function Scope Static Variables
-//
-// Function static objects will be lazily initialized within static storage:
-//
-//    // Function scope.
-//    const std::string& MyString() {
-//      static const absl::NoDestructor<std::string> x("foo");
-//      return *x;
-//    }
-//
-// For function static variables, NoDestructor avoids heap allocation and can be
-// inlined in static storage, resulting in exactly-once, thread-safe
-// construction of an object, and very fast access thereafter (the cost is a few
-// extra cycles).
-//
-// Using NoDestructor<T> in this manner is generally better than other patterns
-// which require pointer chasing:
-//
-//   // Prefer using absl::NoDestructor<T> instead for the static variable.
-//   const std::string& MyString() {
-//     static const std::string* x = new std::string("foo");
-//     return *x;
-//   }
-//
-// Usage as Global Static Variables
-//
-// NoDestructor<T> allows declaration of a global object of type T that has a
-// non-trivial destructor since its destructor is never run. However, such
-// objects still need to worry about initialization order, so such use is not
-// recommended, strongly discouraged by the Google C++ Style Guide, and outright
-// banned in Chromium.
-// See
-// https://google.github.io/styleguide/cppguide.html#Static_and_Global_Variables
-//
-//    // Global or namespace scope.
-//    absl::NoDestructor<MyRegistry> reg{"foo", "bar", 8008};
-//
-// Note that if your object already has a trivial destructor, you don't need to
-// use NoDestructor<T>.
-//
-template <typename T> class NoDestructor {
-public:
-  // Forwards arguments to the T's constructor: calls T(args...).
-  template <typename... Ts,
-            // Disable this overload when it might collide with copy/move.
-            typename std::enable_if<!std::is_same<void(std::decay_t<Ts> &...),
-                                                  void(NoDestructor &)>::value,
-                                    int>::type = 0>
-  explicit constexpr NoDestructor(Ts &&...args)
-      : impl_(std::forward<Ts>(args)...) {}
-
-  // Forwards copy and move construction for T. Enables usage like this:
-  //   static NoDestructor<std::array<string, 3>> x{{{"1", "2", "3"}}};
-  //   static NoDestructor<std::vector<int>> x{{1, 2, 3}};
-  explicit constexpr NoDestructor(const T &x) : impl_(x) {}
-  explicit constexpr NoDestructor(T &&x) : impl_(std::move(x)) {}
-
-  // No copying.
-  NoDestructor(const NoDestructor &) = delete;
-  NoDestructor &operator=(const NoDestructor &) = delete;
-
-  // Pretend to be a smart pointer to T with deep constness.
-  // Never returns a null pointer.
-  T &operator*() { return *get(); }
-  absl::Nonnull<T *> operator->() { return get(); }
-  absl::Nonnull<T *> get() { return impl_.get(); }
-  const T &operator*() const { return *get(); }
-  absl::Nonnull<const T *> operator->() const { return get(); }
-  absl::Nonnull<const T *> get() const { return impl_.get(); }
-
-private:
-  class DirectImpl {
-  public:
-    template <typename... Args>
-    explicit constexpr DirectImpl(Args &&...args)
-        : value_(std::forward<Args>(args)...) {}
-    absl::Nonnull<const T *> get() const { return &value_; }
-    absl::Nonnull<T *> get() { return &value_; }
-
-  private:
-    T value_;
-  };
-
-  class PlacementImpl {
-  public:
-    template <typename... Args> explicit PlacementImpl(Args &&...args) {
-      new (&space_) T(std::forward<Args>(args)...);
-    }
-    absl::Nonnull<const T *> get() const {
-      return Launder(reinterpret_cast<const T *>(&space_));
-    }
-    absl::Nonnull<T *> get() { return Launder(reinterpret_cast<T *>(&space_)); }
-
-  private:
-    template <typename P>
-    static absl::Nonnull<P *> Launder(absl::Nonnull<P *> p) {
-#if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606L
-      return std::launder(p);
-#elif ABSL_HAVE_BUILTIN(__builtin_launder)
-      return __builtin_launder(p);
-#else
-      // When `std::launder` or equivalent are not available, we rely on
-      // undefined behavior, which works as intended on Abseil's officially
-      // supported platforms as of Q3 2023.
-#if defined(__GNUC__) && !defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstrict-aliasing"
-#endif
-      return p;
-#if defined(__GNUC__) && !defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-#endif
-    }
-
-    alignas(T) unsigned char space_[sizeof(T)];
-  };
-
-  // If the object is trivially destructible we use a member directly to avoid
-  // potential once-init runtime initialization. It somewhat defeats the
-  // purpose of NoDestructor in this case, but this makes the class more
-  // friendly to generic code.
-  std::conditional_t<std::is_trivially_destructible<T>::value, DirectImpl,
-                     PlacementImpl>
-      impl_;
-};
-
-#ifdef ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION
-// Provide 'Class Template Argument Deduction': the type of NoDestructor's T
-// will be the same type as the argument passed to NoDestructor's constructor.
-template <typename T> NoDestructor(T) -> NoDestructor<T>;
-#endif // ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_NO_DESTRUCTOR_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/nullability.h b/packages/react-native-executorch/third-party/include/absl/base/nullability.h
deleted file mode 100644
index 205be3414c..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/nullability.h
+++ /dev/null
@@ -1,282 +0,0 @@
-// Copyright 2023 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: nullability.h
-// -----------------------------------------------------------------------------
-//
-// This header file defines a set of "templated annotations" for designating the
-// expected nullability of pointers. These annotations allow you to designate
-// pointers in one of three classification states:
-//
-//  * "Non-null" (for pointers annotated `Nonnull<T>`), indicating that it is
-//    invalid for the given pointer to ever be null.
-//  * "Nullable" (for pointers annotated `Nullable<T>`), indicating that it is
-//    valid for the given pointer to be null.
-//  * "Unknown" (for pointers annotated `NullabilityUnknown<T>`), indicating
-//    that the given pointer has not been yet classified as either nullable or
-//    non-null. This is the default state of unannotated pointers.
-//
-// NOTE: unannotated pointers implicitly bear the annotation
-// `NullabilityUnknown<T>`; you should rarely, if ever, see this annotation used
-// in the codebase explicitly.
-//
-// -----------------------------------------------------------------------------
-// Nullability and Contracts
-// -----------------------------------------------------------------------------
-//
-// These nullability annotations allow you to more clearly specify contracts on
-// software components by narrowing the *preconditions*, *postconditions*, and
-// *invariants* of pointer state(s) in any given interface. It then depends on
-// context who is responsible for fulfilling the annotation's requirements.
-//
-// For example, a function may receive a pointer argument. Designating that
-// pointer argument as "non-null" tightens the precondition of the contract of
-// that function. It is then the responsibility of anyone calling such a
-// function to ensure that the passed pointer is not null.
-//
-// Similarly, a function may have a pointer as a return value. Designating that
-// return value as "non-null" tightens the postcondition of the contract of that
-// function. In this case, however, it is the responsibility of the function
-// itself to ensure that the returned pointer is not null.
-//
-// Clearly defining these contracts allows providers (and consumers) of such
-// pointers to have more confidence in their null state. If a function declares
-// a return value as "non-null", for example, the caller should not need to
-// check whether the returned value is `nullptr`; it can simply assume the
-// pointer is valid.
-//
-// Of course most interfaces already have expectations on the nullability state
-// of pointers, and these expectations are, in effect, a contract; often,
-// however, those contracts are either poorly or partially specified, assumed,
-// or misunderstood. These nullability annotations are designed to allow you to
-// formalize those contracts within the codebase.
-//
-// -----------------------------------------------------------------------------
-// Using Nullability Annotations
-// -----------------------------------------------------------------------------
-//
-// It is important to note that these annotations are not distinct strong
-// *types*. They are alias templates defined to be equal to the underlying
-// pointer type. A pointer annotated `Nonnull<T*>`, for example, is simply a
-// pointer of type `T*`. Each annotation acts as a form of documentation about
-// the contract for the given pointer. Each annotation requires providers or
-// consumers of these pointers across API boundaries to take appropriate steps
-// when setting or using these pointers:
-//
-// * "Non-null" pointers should never be null. It is the responsibility of the
-//   provider of this pointer to ensure that the pointer may never be set to
-//   null. Consumers of such pointers can treat such pointers as non-null.
-// * "Nullable" pointers may or may not be null. Consumers of such pointers
-//   should precede any usage of that pointer (e.g. a dereference operation)
-//   with a a `nullptr` check.
-// * "Unknown" pointers may be either "non-null" or "nullable" but have not been
-//   definitively determined to be in either classification state. Providers of
-//   such pointers across API boundaries should determine --  over time -- to
-//   annotate the pointer in either of the above two states. Consumers of such
-//   pointers across an API boundary should continue to treat such pointers as
-//   they currently do.
-//
-// Example:
-//
-// // PaySalary() requires the passed pointer to an `Employee` to be non-null.
-// void PaySalary(absl::Nonnull<Employee *> e) {
-//   pay(e->salary);  // OK to dereference
-// }
-//
-// // CompleteTransaction() guarantees the returned pointer to an `Account` to
-// // be non-null.
-// absl::Nonnull<Account *> balance CompleteTransaction(double fee) {
-// ...
-// }
-//
-// // Note that specifying a nullability annotation does not prevent someone
-// // from violating the contract:
-//
-// Nullable<Employee *> find(Map& employees, std::string_view name);
-//
-// void g(Map& employees) {
-//   Employee *e = find(employees, "Pat");
-//   // `e` can now be null.
-//   PaySalary(e); // Violates contract, but compiles!
-// }
-//
-// Nullability annotations, in other words, are useful for defining and
-// narrowing contracts; *enforcement* of those contracts depends on use and any
-// additional (static or dynamic analysis) tooling.
-//
-// NOTE: The "unknown" annotation state indicates that a pointer's contract has
-// not yet been positively identified. The unknown state therefore acts as a
-// form of documentation of your technical debt, and a codebase that adopts
-// nullability annotations should aspire to annotate every pointer as either
-// "non-null" or "nullable".
-//
-// -----------------------------------------------------------------------------
-// Applicability of Nullability Annotations
-// -----------------------------------------------------------------------------
-//
-// By default, nullability annotations are applicable to raw and smart
-// pointers. User-defined types can indicate compatibility with nullability
-// annotations by adding the ABSL_NULLABILITY_COMPATIBLE attribute.
-//
-// // Example:
-// struct ABSL_NULLABILITY_COMPATIBLE MyPtr {
-//   ...
-// };
-//
-// Note: Compilers that don't support the `nullability_on_classes` feature will
-// allow nullability annotations to be applied to any type, not just ones
-// marked with `ABSL_NULLABILITY_COMPATIBLE`.
-//
-// DISCLAIMER:
-// ===========================================================================
-// These nullability annotations are primarily a human readable signal about the
-// intended contract of the pointer. They are not *types* and do not currently
-// provide any correctness guarantees. For example, a pointer annotated as
-// `Nonnull<T*>` is *not guaranteed* to be non-null, and the compiler won't
-// alert or prevent assignment of a `Nullable<T*>` to a `Nonnull<T*>`.
-// ===========================================================================
-#ifndef ABSL_BASE_NULLABILITY_H_
-#define ABSL_BASE_NULLABILITY_H_
-
-#include "absl/base/config.h"
-#include "absl/base/internal/nullability_impl.h"
-
-// ABSL_POINTERS_DEFAULT_NONNULL
-//
-// This macro specifies that all unannotated pointer types within the given
-// file are designated as nonnull (instead of the default "unknown"). This macro
-// exists as a standalone statement and applies default nonnull behavior to all
-// subsequent pointers; as a result, place this macro as the first non-comment,
-// non-`#include` line in a file.
-//
-// Example:
-//
-//     #include "absl/base/nullability.h"
-//
-//     ABSL_POINTERS_DEFAULT_NONNULL
-//
-//     void FillMessage(Message *m);                  // implicitly non-null
-//     absl::Nullable<T*> GetNullablePtr();           // explicitly nullable
-//     absl::NullabilityUnknown<T*> GetUnknownPtr();  // explicitly unknown
-//
-// The macro can be safely used in header files -- it will not affect any files
-// that include it.
-//
-// In files with the macro, plain `T*` syntax means `absl::Nonnull<T*>`, and the
-// exceptions (`Nullable` and `NullabilityUnknown`) must be marked
-// explicitly. The same holds, correspondingly, for smart pointer types.
-//
-// For comparison, without the macro, all unannotated pointers would default to
-// unknown, and otherwise require explicit annotations to change this behavior:
-//
-//     #include "absl/base/nullability.h"
-//
-//     void FillMessage(absl::Nonnull<Message*> m);  // explicitly non-null
-//     absl::Nullable<T*> GetNullablePtr();          // explicitly nullable
-//     T* GetUnknownPtr();                           // implicitly unknown
-//
-// No-op except for being a human readable signal.
-#define ABSL_POINTERS_DEFAULT_NONNULL
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// absl::Nonnull (default with `ABSL_POINTERS_DEFAULT_NONNULL`)
-//
-// The indicated pointer is never null. It is the responsibility of the provider
-// of this pointer across an API boundary to ensure that the pointer is never
-// set to null. Consumers of this pointer across an API boundary may safely
-// dereference the pointer.
-//
-// Example:
-//
-// // `employee` is designated as not null.
-// void PaySalary(absl::Nonnull<Employee *> employee) {
-//   pay(*employee);  // OK to dereference
-// }
-template <typename T> using Nonnull = nullability_internal::NonnullImpl<T>;
-
-// absl::Nullable
-//
-// The indicated pointer may, by design, be either null or non-null. Consumers
-// of this pointer across an API boundary should perform a `nullptr` check
-// before performing any operation using the pointer.
-//
-// Example:
-//
-// // `employee` may  be null.
-// void PaySalary(absl::Nullable<Employee *> employee) {
-//   if (employee != nullptr) {
-//     Pay(*employee);  // OK to dereference
-//   }
-// }
-template <typename T> using Nullable = nullability_internal::NullableImpl<T>;
-
-// absl::NullabilityUnknown (default without `ABSL_POINTERS_DEFAULT_NONNULL`)
-//
-// The indicated pointer has not yet been determined to be definitively
-// "non-null" or "nullable." Providers of such pointers across API boundaries
-// should, over time, annotate such pointers as either "non-null" or "nullable."
-// Consumers of these pointers across an API boundary should treat such pointers
-// with the same caution they treat currently unannotated pointers. Most
-// existing code will have "unknown"  pointers, which should eventually be
-// migrated into one of the above two nullability states: `Nonnull<T>` or
-//  `Nullable<T>`.
-//
-// NOTE: For files that do not specify `ABSL_POINTERS_DEFAULT_NONNULL`,
-// because this annotation is the global default state, unannotated pointers are
-// are assumed to have "unknown" semantics. This assumption is designed to
-// minimize churn and reduce clutter within the codebase.
-//
-// Example:
-//
-// // `employee`s nullability state is unknown.
-// void PaySalary(absl::NullabilityUnknown<Employee *> employee) {
-//   Pay(*employee); // Potentially dangerous. API provider should investigate.
-// }
-//
-// Note that a pointer without an annotation, by default, is assumed to have the
-// annotation `NullabilityUnknown`.
-//
-// // `employee`s nullability state is unknown.
-// void PaySalary(Employee* employee) {
-//   Pay(*employee); // Potentially dangerous. API provider should investigate.
-// }
-template <typename T>
-using NullabilityUnknown = nullability_internal::NullabilityUnknownImpl<T>;
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-// ABSL_NULLABILITY_COMPATIBLE
-//
-// Indicates that a class is compatible with nullability annotations.
-//
-// For example:
-//
-// struct ABSL_NULLABILITY_COMPATIBLE MyPtr {
-//   ...
-// };
-//
-// Note: Compilers that don't support the `nullability_on_classes` feature will
-// allow nullability annotations to be applied to any type, not just ones marked
-// with `ABSL_NULLABILITY_COMPATIBLE`.
-#if ABSL_HAVE_FEATURE(nullability_on_classes)
-#define ABSL_NULLABILITY_COMPATIBLE _Nullable
-#else
-#define ABSL_NULLABILITY_COMPATIBLE
-#endif
-
-#endif // ABSL_BASE_NULLABILITY_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/optimization.h b/packages/react-native-executorch/third-party/include/absl/base/optimization.h
deleted file mode 100644
index fe295ae50d..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/optimization.h
+++ /dev/null
@@ -1,324 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: optimization.h
-// -----------------------------------------------------------------------------
-//
-// This header file defines portable macros for performance optimization.
-//
-// This header is included in both C++ code and legacy C code and thus must
-// remain compatible with both C and C++. C compatibility will be removed if
-// the legacy code is removed or converted to C++. Do not include this header in
-// new code that requires C compatibility or assume C compatibility will remain
-// indefinitely.
-
-#ifndef ABSL_BASE_OPTIMIZATION_H_
-#define ABSL_BASE_OPTIMIZATION_H_
-
-#include <assert.h>
-
-#ifdef __cplusplus
-// Included for std::unreachable()
-#include <utility>
-#endif // __cplusplus
-
-#include "absl/base/config.h"
-#include "absl/base/options.h"
-
-// ABSL_BLOCK_TAIL_CALL_OPTIMIZATION
-//
-// Instructs the compiler to avoid optimizing tail-call recursion. This macro is
-// useful when you wish to preserve the existing function order within a stack
-// trace for logging, debugging, or profiling purposes.
-//
-// Example:
-//
-//   int f() {
-//     int result = g();
-//     ABSL_BLOCK_TAIL_CALL_OPTIMIZATION();
-//     return result;
-//   }
-#if defined(__pnacl__)
-#define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION()                                    \
-  if (volatile int x = 0) {                                                    \
-    (void)x;                                                                   \
-  }
-#elif defined(__clang__)
-// Clang will not tail call given inline volatile assembly.
-#define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() __asm__ __volatile__("")
-#elif defined(__GNUC__)
-// GCC will not tail call given inline volatile assembly.
-#define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() __asm__ __volatile__("")
-#elif defined(_MSC_VER)
-#include <intrin.h>
-// The __nop() intrinsic blocks the optimisation.
-#define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() __nop()
-#else
-#define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION()                                    \
-  if (volatile int x = 0) {                                                    \
-    (void)x;                                                                   \
-  }
-#endif
-
-// ABSL_CACHELINE_SIZE
-//
-// Explicitly defines the size of the L1 cache for purposes of alignment.
-// Setting the cacheline size allows you to specify that certain objects be
-// aligned on a cacheline boundary with `ABSL_CACHELINE_ALIGNED` declarations.
-// (See below.)
-//
-// NOTE: this macro should be replaced with the following C++17 features, when
-// those are generally available:
-//
-//   * `std::hardware_constructive_interference_size`
-//   * `std::hardware_destructive_interference_size`
-//
-// See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0154r1.html
-// for more information.
-#if defined(__GNUC__)
-// Cache line alignment
-#if defined(__i386__) || defined(__x86_64__)
-#define ABSL_CACHELINE_SIZE 64
-#elif defined(__powerpc64__)
-#define ABSL_CACHELINE_SIZE 128
-#elif defined(__aarch64__)
-// We would need to read special register ctr_el0 to find out L1 dcache size.
-// This value is a good estimate based on a real aarch64 machine.
-#define ABSL_CACHELINE_SIZE 64
-#elif defined(__arm__)
-// Cache line sizes for ARM: These values are not strictly correct since
-// cache line sizes depend on implementations, not architectures.  There
-// are even implementations with cache line sizes configurable at boot
-// time.
-#if defined(__ARM_ARCH_5T__)
-#define ABSL_CACHELINE_SIZE 32
-#elif defined(__ARM_ARCH_7A__)
-#define ABSL_CACHELINE_SIZE 64
-#endif
-#endif
-#endif
-
-#ifndef ABSL_CACHELINE_SIZE
-// A reasonable default guess.  Note that overestimates tend to waste more
-// space, while underestimates tend to waste more time.
-#define ABSL_CACHELINE_SIZE 64
-#endif
-
-// ABSL_CACHELINE_ALIGNED
-//
-// Indicates that the declared object be cache aligned using
-// `ABSL_CACHELINE_SIZE` (see above). Cacheline aligning objects allows you to
-// load a set of related objects in the L1 cache for performance improvements.
-// Cacheline aligning objects properly allows constructive memory sharing and
-// prevents destructive (or "false") memory sharing.
-//
-// NOTE: callers should replace uses of this macro with `alignas()` using
-// `std::hardware_constructive_interference_size` and/or
-// `std::hardware_destructive_interference_size` when C++17 becomes available to
-// them.
-//
-// See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0154r1.html
-// for more information.
-//
-// On some compilers, `ABSL_CACHELINE_ALIGNED` expands to an `__attribute__`
-// or `__declspec` attribute. For compilers where this is not known to work,
-// the macro expands to nothing.
-//
-// No further guarantees are made here. The result of applying the macro
-// to variables and types is always implementation-defined.
-//
-// WARNING: It is easy to use this attribute incorrectly, even to the point
-// of causing bugs that are difficult to diagnose, crash, etc. It does not
-// of itself guarantee that objects are aligned to a cache line.
-//
-// NOTE: Some compilers are picky about the locations of annotations such as
-// this attribute, so prefer to put it at the beginning of your declaration.
-// For example,
-//
-//   ABSL_CACHELINE_ALIGNED static Foo* foo = ...
-//
-//   class ABSL_CACHELINE_ALIGNED Bar { ...
-//
-// Recommendations:
-//
-// 1) Consult compiler documentation; this comment is not kept in sync as
-//    toolchains evolve.
-// 2) Verify your use has the intended effect. This often requires inspecting
-//    the generated machine code.
-// 3) Prefer applying this attribute to individual variables. Avoid
-//    applying it to types. This tends to localize the effect.
-#if defined(__clang__) || defined(__GNUC__)
-#define ABSL_CACHELINE_ALIGNED __attribute__((aligned(ABSL_CACHELINE_SIZE)))
-#elif defined(_MSC_VER)
-#define ABSL_CACHELINE_ALIGNED __declspec(align(ABSL_CACHELINE_SIZE))
-#else
-#define ABSL_CACHELINE_ALIGNED
-#endif
-
-// ABSL_PREDICT_TRUE, ABSL_PREDICT_FALSE
-//
-// Enables the compiler to prioritize compilation using static analysis for
-// likely paths within a boolean branch.
-//
-// Example:
-//
-//   if (ABSL_PREDICT_TRUE(expression)) {
-//     return result;                        // Faster if more likely
-//   } else {
-//     return 0;
-//   }
-//
-// Compilers can use the information that a certain branch is not likely to be
-// taken (for instance, a CHECK failure) to optimize for the common case in
-// the absence of better information (ie. compiling gcc with `-fprofile-arcs`).
-//
-// Recommendation: Modern CPUs dynamically predict branch execution paths,
-// typically with accuracy greater than 97%. As a result, annotating every
-// branch in a codebase is likely counterproductive; however, annotating
-// specific branches that are both hot and consistently mispredicted is likely
-// to yield performance improvements.
-#if ABSL_HAVE_BUILTIN(__builtin_expect) ||                                     \
-    (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
-#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
-#else
-#define ABSL_PREDICT_FALSE(x) (x)
-#define ABSL_PREDICT_TRUE(x) (x)
-#endif
-
-// `ABSL_INTERNAL_IMMEDIATE_ABORT_IMPL()` aborts the program in the fastest
-// possible way, with no attempt at logging. One use is to implement hardening
-// aborts with ABSL_OPTION_HARDENED.  Since this is an internal symbol, it
-// should not be used directly outside of Abseil.
-#if ABSL_HAVE_BUILTIN(__builtin_trap) ||                                       \
-    (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_INTERNAL_IMMEDIATE_ABORT_IMPL() __builtin_trap()
-#else
-#define ABSL_INTERNAL_IMMEDIATE_ABORT_IMPL() abort()
-#endif
-
-// `ABSL_INTERNAL_UNREACHABLE_IMPL()` is the platform specific directive to
-// indicate that a statement is unreachable, and to allow the compiler to
-// optimize accordingly. Clients should use `ABSL_UNREACHABLE()`, which is
-// defined below.
-#if defined(__cpp_lib_unreachable) && __cpp_lib_unreachable >= 202202L
-#define ABSL_INTERNAL_UNREACHABLE_IMPL() std::unreachable()
-#elif defined(__GNUC__) || ABSL_HAVE_BUILTIN(__builtin_unreachable)
-#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
-#elif ABSL_HAVE_BUILTIN(__builtin_assume)
-#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_assume(false)
-#elif defined(_MSC_VER)
-#define ABSL_INTERNAL_UNREACHABLE_IMPL() __assume(false)
-#else
-#define ABSL_INTERNAL_UNREACHABLE_IMPL()
-#endif
-
-// `ABSL_UNREACHABLE()` is an unreachable statement.  A program which reaches
-// one has undefined behavior, and the compiler may optimize accordingly.
-#if ABSL_OPTION_HARDENED == 1 && defined(NDEBUG)
-// Abort in hardened mode to avoid dangerous undefined behavior.
-#define ABSL_UNREACHABLE()                                                     \
-  do {                                                                         \
-    ABSL_INTERNAL_IMMEDIATE_ABORT_IMPL();                                      \
-    ABSL_INTERNAL_UNREACHABLE_IMPL();                                          \
-  } while (false)
-#else
-// The assert only fires in debug mode to aid in debugging.
-// When NDEBUG is defined, reaching ABSL_UNREACHABLE() is undefined behavior.
-#define ABSL_UNREACHABLE()                                                     \
-  do {                                                                         \
-    /* NOLINTNEXTLINE: misc-static-assert */                                   \
-    assert(false && "ABSL_UNREACHABLE reached");                               \
-    ABSL_INTERNAL_UNREACHABLE_IMPL();                                          \
-  } while (false)
-#endif
-
-// ABSL_ASSUME(cond)
-//
-// Informs the compiler that a condition is always true and that it can assume
-// it to be true for optimization purposes.
-//
-// WARNING: If the condition is false, the program can produce undefined and
-// potentially dangerous behavior.
-//
-// In !NDEBUG mode, the condition is checked with an assert().
-//
-// NOTE: The expression must not have side effects, as it may only be evaluated
-// in some compilation modes and not others. Some compilers may issue a warning
-// if the compiler cannot prove the expression has no side effects. For example,
-// the expression should not use a function call since the compiler cannot prove
-// that a function call does not have side effects.
-//
-// Example:
-//
-//   int x = ...;
-//   ABSL_ASSUME(x >= 0);
-//   // The compiler can optimize the division to a simple right shift using the
-//   // assumption specified above.
-//   int y = x / 16;
-//
-#if !defined(NDEBUG)
-#define ABSL_ASSUME(cond) assert(cond)
-#elif ABSL_HAVE_BUILTIN(__builtin_assume)
-#define ABSL_ASSUME(cond) __builtin_assume(cond)
-#elif defined(_MSC_VER)
-#define ABSL_ASSUME(cond) __assume(cond)
-#elif defined(__cpp_lib_unreachable) && __cpp_lib_unreachable >= 202202L
-#define ABSL_ASSUME(cond)                                                      \
-  do {                                                                         \
-    if (!(cond))                                                               \
-      std::unreachable();                                                      \
-  } while (false)
-#elif defined(__GNUC__) || ABSL_HAVE_BUILTIN(__builtin_unreachable)
-#define ABSL_ASSUME(cond)                                                      \
-  do {                                                                         \
-    if (!(cond))                                                               \
-      __builtin_unreachable();                                                 \
-  } while (false)
-#else
-#define ABSL_ASSUME(cond)                                                      \
-  do {                                                                         \
-    static_cast<void>(false && (cond));                                        \
-  } while (false)
-#endif
-
-// ABSL_INTERNAL_UNIQUE_SMALL_NAME(cond)
-// This macro forces small unique name on a static file level symbols like
-// static local variables or static functions. This is intended to be used in
-// macro definitions to optimize the cost of generated code. Do NOT use it on
-// symbols exported from translation unit since it may cause a link time
-// conflict.
-//
-// Example:
-//
-// #define MY_MACRO(txt)
-// namespace {
-//  char VeryVeryLongVarName[] ABSL_INTERNAL_UNIQUE_SMALL_NAME() = txt;
-//  const char* VeryVeryLongFuncName() ABSL_INTERNAL_UNIQUE_SMALL_NAME();
-//  const char* VeryVeryLongFuncName() { return txt; }
-// }
-//
-
-#if defined(__GNUC__)
-#define ABSL_INTERNAL_UNIQUE_SMALL_NAME2(x) #x
-#define ABSL_INTERNAL_UNIQUE_SMALL_NAME1(x) ABSL_INTERNAL_UNIQUE_SMALL_NAME2(x)
-#define ABSL_INTERNAL_UNIQUE_SMALL_NAME()                                      \
-  asm(ABSL_INTERNAL_UNIQUE_SMALL_NAME1(.absl.__COUNTER__))
-#else
-#define ABSL_INTERNAL_UNIQUE_SMALL_NAME()
-#endif
-
-#endif // ABSL_BASE_OPTIMIZATION_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/options.h b/packages/react-native-executorch/third-party/include/absl/base/options.h
deleted file mode 100644
index 8b2549d011..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/options.h
+++ /dev/null
@@ -1,259 +0,0 @@
-// Copyright 2019 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: options.h
-// -----------------------------------------------------------------------------
-//
-// This file contains Abseil configuration options for setting specific
-// implementations instead of letting Abseil determine which implementation to
-// use at compile-time. Setting these options may be useful for package or build
-// managers who wish to guarantee ABI stability within binary builds (which are
-// otherwise difficult to enforce).
-//
-// *** IMPORTANT NOTICE FOR PACKAGE MANAGERS:  It is important that
-// maintainers of package managers who wish to package Abseil read and
-// understand this file! ***
-//
-// Abseil contains a number of possible configuration endpoints, based on
-// parameters such as the detected platform, language version, or command-line
-// flags used to invoke the underlying binary. As is the case with all
-// libraries, binaries which contain Abseil code must ensure that separate
-// packages use the same compiled copy of Abseil to avoid a diamond dependency
-// problem, which can occur if two packages built with different Abseil
-// configuration settings are linked together. Diamond dependency problems in
-// C++ may manifest as violations to the One Definition Rule (ODR) (resulting in
-// linker errors), or undefined behavior (resulting in crashes).
-//
-// Diamond dependency problems can be avoided if all packages utilize the same
-// exact version of Abseil. Building from source code with the same compilation
-// parameters is the easiest way to avoid such dependency problems. However, for
-// package managers who cannot control such compilation parameters, we are
-// providing the file to allow you to inject ABI (Application Binary Interface)
-// stability across builds. Settings options in this file will neither change
-// API nor ABI, providing a stable copy of Abseil between packages.
-//
-// Care must be taken to keep options within these configurations isolated
-// from any other dynamic settings, such as command-line flags which could alter
-// these options. This file is provided specifically to help build and package
-// managers provide a stable copy of Abseil within their libraries and binaries;
-// other developers should not have need to alter the contents of this file.
-//
-// -----------------------------------------------------------------------------
-// Usage
-// -----------------------------------------------------------------------------
-//
-// For any particular package release, set the appropriate definitions within
-// this file to whatever value makes the most sense for your package(s). Note
-// that, by default, most of these options, at the moment, affect the
-// implementation of types; future options may affect other implementation
-// details.
-//
-// NOTE: the defaults within this file all assume that Abseil can select the
-// proper Abseil implementation at compile-time, which will not be sufficient
-// to guarantee ABI stability to package managers.
-
-#ifndef ABSL_BASE_OPTIONS_H_
-#define ABSL_BASE_OPTIONS_H_
-
-// -----------------------------------------------------------------------------
-// Type Compatibility Options
-// -----------------------------------------------------------------------------
-//
-// ABSL_OPTION_USE_STD_ANY
-//
-// This option controls whether absl::any is implemented as an alias to
-// std::any, or as an independent implementation.
-//
-// A value of 0 means to use Abseil's implementation.  This requires only C++11
-// support, and is expected to work on every toolchain we support.
-//
-// A value of 1 means to use an alias to std::any.  This requires that all code
-// using Abseil is built in C++17 mode or later.
-//
-// A value of 2 means to detect the C++ version being used to compile Abseil,
-// and use an alias only if a working std::any is available.  This option is
-// useful when you are building your entire program, including all of its
-// dependencies, from source.  It should not be used otherwise -- for example,
-// if you are distributing Abseil in a binary package manager -- since in
-// mode 2, absl::any will name a different type, with a different mangled name
-// and binary layout, depending on the compiler flags passed by the end user.
-// For more info, see https://abseil.io/about/design/dropin-types.
-//
-// User code should not inspect this macro.  To check in the preprocessor if
-// absl::any is a typedef of std::any, use the feature macro ABSL_USES_STD_ANY.
-
-#define ABSL_OPTION_USE_STD_ANY 1
-
-// ABSL_OPTION_USE_STD_OPTIONAL
-//
-// This option controls whether absl::optional is implemented as an alias to
-// std::optional, or as an independent implementation.
-//
-// A value of 0 means to use Abseil's implementation.  This requires only C++11
-// support, and is expected to work on every toolchain we support.
-//
-// A value of 1 means to use an alias to std::optional.  This requires that all
-// code using Abseil is built in C++17 mode or later.
-//
-// A value of 2 means to detect the C++ version being used to compile Abseil,
-// and use an alias only if a working std::optional is available.  This option
-// is useful when you are building your program from source.  It should not be
-// used otherwise -- for example, if you are distributing Abseil in a binary
-// package manager -- since in mode 2, absl::optional will name a different
-// type, with a different mangled name and binary layout, depending on the
-// compiler flags passed by the end user.  For more info, see
-// https://abseil.io/about/design/dropin-types.
-
-// User code should not inspect this macro.  To check in the preprocessor if
-// absl::optional is a typedef of std::optional, use the feature macro
-// ABSL_USES_STD_OPTIONAL.
-
-#define ABSL_OPTION_USE_STD_OPTIONAL 1
-
-// ABSL_OPTION_USE_STD_STRING_VIEW
-//
-// This option controls whether absl::string_view is implemented as an alias to
-// std::string_view, or as an independent implementation.
-//
-// A value of 0 means to use Abseil's implementation.  This requires only C++11
-// support, and is expected to work on every toolchain we support.
-//
-// A value of 1 means to use an alias to std::string_view.  This requires that
-// all code using Abseil is built in C++17 mode or later.
-//
-// A value of 2 means to detect the C++ version being used to compile Abseil,
-// and use an alias only if a working std::string_view is available.  This
-// option is useful when you are building your program from source.  It should
-// not be used otherwise -- for example, if you are distributing Abseil in a
-// binary package manager -- since in mode 2, absl::string_view will name a
-// different type, with a different mangled name and binary layout, depending on
-// the compiler flags passed by the end user.  For more info, see
-// https://abseil.io/about/design/dropin-types.
-//
-// User code should not inspect this macro.  To check in the preprocessor if
-// absl::string_view is a typedef of std::string_view, use the feature macro
-// ABSL_USES_STD_STRING_VIEW.
-
-#define ABSL_OPTION_USE_STD_STRING_VIEW 1
-
-// ABSL_OPTION_USE_STD_VARIANT
-//
-// This option controls whether absl::variant is implemented as an alias to
-// std::variant, or as an independent implementation.
-//
-// A value of 0 means to use Abseil's implementation.  This requires only C++11
-// support, and is expected to work on every toolchain we support.
-//
-// A value of 1 means to use an alias to std::variant.  This requires that all
-// code using Abseil is built in C++17 mode or later.
-//
-// A value of 2 means to detect the C++ version being used to compile Abseil,
-// and use an alias only if a working std::variant is available.  This option
-// is useful when you are building your program from source.  It should not be
-// used otherwise -- for example, if you are distributing Abseil in a binary
-// package manager -- since in mode 2, absl::variant will name a different
-// type, with a different mangled name and binary layout, depending on the
-// compiler flags passed by the end user.  For more info, see
-// https://abseil.io/about/design/dropin-types.
-//
-// User code should not inspect this macro.  To check in the preprocessor if
-// absl::variant is a typedef of std::variant, use the feature macro
-// ABSL_USES_STD_VARIANT.
-
-#define ABSL_OPTION_USE_STD_VARIANT 1
-
-// ABSL_OPTION_USE_STD_ORDERING
-//
-// This option controls whether absl::{partial,weak,strong}_ordering are
-// implemented as aliases to the std:: ordering types, or as an independent
-// implementation.
-//
-// A value of 0 means to use Abseil's implementation.  This requires only C++11
-// support, and is expected to work on every toolchain we support.
-//
-// A value of 1 means to use aliases.  This requires that all code using Abseil
-// is built in C++20 mode or later.
-//
-// A value of 2 means to detect the C++ version being used to compile Abseil,
-// and use an alias only if working std:: ordering types are available.  This
-// option is useful when you are building your program from source.  It should
-// not be used otherwise -- for example, if you are distributing Abseil in a
-// binary package manager -- since in mode 2, they will name different types,
-// with different mangled names and binary layout, depending on the compiler
-// flags passed by the end user.  For more info, see
-// https://abseil.io/about/design/dropin-types.
-//
-// User code should not inspect this macro.  To check in the preprocessor if
-// the ordering types are aliases of std:: ordering types, use the feature macro
-// ABSL_USES_STD_ORDERING.
-
-#define ABSL_OPTION_USE_STD_ORDERING 0
-
-// ABSL_OPTION_USE_INLINE_NAMESPACE
-// ABSL_OPTION_INLINE_NAMESPACE_NAME
-//
-// These options controls whether all entities in the absl namespace are
-// contained within an inner inline namespace.  This does not affect the
-// user-visible API of Abseil, but it changes the mangled names of all symbols.
-//
-// This can be useful as a version tag if you are distributing Abseil in
-// precompiled form.  This will prevent a binary library build of Abseil with
-// one inline namespace being used with headers configured with a different
-// inline namespace name.  Binary packagers are reminded that Abseil does not
-// guarantee any ABI stability in Abseil, so any update of Abseil or
-// configuration change in such a binary package should be combined with a
-// new, unique value for the inline namespace name.
-//
-// A value of 0 means not to use inline namespaces.
-//
-// A value of 1 means to use an inline namespace with the given name inside
-// namespace absl.  If this is set, ABSL_OPTION_INLINE_NAMESPACE_NAME must also
-// be changed to a new, unique identifier name.  In particular "head" is not
-// allowed.
-
-#define ABSL_OPTION_USE_INLINE_NAMESPACE 0
-#define ABSL_OPTION_INLINE_NAMESPACE_NAME head
-
-// ABSL_OPTION_HARDENED
-//
-// This option enables a "hardened" build in release mode (in this context,
-// release mode is defined as a build where the `NDEBUG` macro is defined).
-//
-// A value of 0 means that "hardened" mode is not enabled.
-//
-// A value of 1 means that "hardened" mode is enabled with all checks.
-//
-// A value of 2 means that "hardened" mode is partially enabled, with
-// only a subset of checks chosen to minimize performance impact.
-//
-// Hardened builds have additional security checks enabled when `NDEBUG` is
-// defined. Defining `NDEBUG` is normally used to turn `assert()` macro into a
-// no-op, as well as disabling other bespoke program consistency checks. By
-// defining ABSL_OPTION_HARDENED to 1, a select set of checks remain enabled in
-// release mode. These checks guard against programming errors that may lead to
-// security vulnerabilities. In release mode, when one of these programming
-// errors is encountered, the program will immediately abort, possibly without
-// any attempt at logging.
-//
-// The checks enabled by this option are not free; they do incur runtime cost.
-//
-// The checks enabled by this option are always active when `NDEBUG` is not
-// defined, even in the case when ABSL_OPTION_HARDENED is defined to 0. The
-// checks enabled by this option may abort the program in a different way and
-// log additional information when `NDEBUG` is not defined.
-
-#define ABSL_OPTION_HARDENED 0
-
-#endif // ABSL_BASE_OPTIONS_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/policy_checks.h b/packages/react-native-executorch/third-party/include/absl/base/policy_checks.h
deleted file mode 100644
index 73811f555e..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/policy_checks.h
+++ /dev/null
@@ -1,115 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: policy_checks.h
-// -----------------------------------------------------------------------------
-//
-// This header enforces a minimum set of policies at build time, such as the
-// supported compiler and library versions. Unsupported configurations are
-// reported with `#error`. This enforcement is best effort, so successfully
-// compiling this header does not guarantee a supported configuration.
-
-// SKIP_ABSL_INLINE_NAMESPACE_CHECK
-
-#ifndef ABSL_BASE_POLICY_CHECKS_H_
-#define ABSL_BASE_POLICY_CHECKS_H_
-
-// Included for the __GLIBC_PREREQ macro used below.
-#include <limits.h>
-
-// Included for the _STLPORT_VERSION macro used below.
-#if defined(__cplusplus)
-#include <cstddef>
-#endif
-
-// -----------------------------------------------------------------------------
-// Operating System Check
-// -----------------------------------------------------------------------------
-
-#if defined(__CYGWIN__)
-#error "Cygwin is not supported."
-#endif
-
-// -----------------------------------------------------------------------------
-// Toolchain Check
-// -----------------------------------------------------------------------------
-
-// We support Visual Studio 2019 (MSVC++ 16.0) and later.
-// This minimum will go up.
-#if defined(_MSC_VER) && _MSC_VER < 1920 && !defined(__clang__)
-#error "This package requires Visual Studio 2019 (MSVC++ 16.0) or higher."
-#endif
-
-// We support GCC 7 and later.
-// This minimum will go up.
-#if defined(__GNUC__) && !defined(__clang__)
-#if __GNUC__ < 7
-#error "This package requires GCC 7 or higher."
-#endif
-#endif
-
-// We support Apple Xcode clang 4.2.1 (version 421.11.65) and later.
-// This corresponds to Apple Xcode version 4.5.
-// This minimum will go up.
-#if defined(__apple_build_version__) && __apple_build_version__ < 4211165
-#error "This package requires __apple_build_version__ of 4211165 or higher."
-#endif
-
-// -----------------------------------------------------------------------------
-// C++ Version Check
-// -----------------------------------------------------------------------------
-
-// Enforce C++14 as the minimum.
-#if defined(_MSVC_LANG)
-#if _MSVC_LANG < 201402L
-#error "C++ versions less than C++14 are not supported."
-#endif // _MSVC_LANG < 201402L
-#elif defined(__cplusplus)
-#if __cplusplus < 201402L
-#error "C++ versions less than C++14 are not supported."
-#endif // __cplusplus < 201402L
-#endif
-
-// -----------------------------------------------------------------------------
-// Standard Library Check
-// -----------------------------------------------------------------------------
-
-#if defined(_STLPORT_VERSION)
-#error "STLPort is not supported."
-#endif
-
-// -----------------------------------------------------------------------------
-// `char` Size Check
-// -----------------------------------------------------------------------------
-
-// Abseil currently assumes CHAR_BIT == 8. If you would like to use Abseil on a
-// platform where this is not the case, please provide us with the details about
-// your platform so we can consider relaxing this requirement.
-#if CHAR_BIT != 8
-#error "Abseil assumes CHAR_BIT == 8."
-#endif
-
-// -----------------------------------------------------------------------------
-// `int` Size Check
-// -----------------------------------------------------------------------------
-
-// Abseil currently assumes that an int is 4 bytes. If you would like to use
-// Abseil on a platform where this is not the case, please provide us with the
-// details about your platform so we can consider relaxing this requirement.
-#if INT_MAX < 2147483647
-#error "Abseil assumes that int is at least 4 bytes. "
-#endif
-
-#endif // ABSL_BASE_POLICY_CHECKS_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/port.h b/packages/react-native-executorch/third-party/include/absl/base/port.h
deleted file mode 100644
index 7a6ad115a6..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/port.h
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// This files is a forwarding header for other headers containing various
-// portability macros and functions.
-
-#ifndef ABSL_BASE_PORT_H_
-#define ABSL_BASE_PORT_H_
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/base/optimization.h"
-
-#endif // ABSL_BASE_PORT_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/prefetch.h b/packages/react-native-executorch/third-party/include/absl/base/prefetch.h
deleted file mode 100644
index 4e50178c12..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/prefetch.h
+++ /dev/null
@@ -1,209 +0,0 @@
-// Copyright 2023 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: prefetch.h
-// -----------------------------------------------------------------------------
-//
-// This header file defines prefetch functions to prefetch memory contents
-// into the first level cache (L1) for the current CPU. The prefetch logic
-// offered in this header is limited to prefetching first level cachelines
-// only, and is aimed at relatively 'simple' prefetching logic.
-//
-#ifndef ABSL_BASE_PREFETCH_H_
-#define ABSL_BASE_PREFETCH_H_
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-
-#if defined(ABSL_INTERNAL_HAVE_SSE)
-#include <xmmintrin.h>
-#endif
-
-#if defined(_MSC_VER)
-#include <intrin.h>
-#if defined(ABSL_INTERNAL_HAVE_SSE)
-#pragma intrinsic(_mm_prefetch)
-#endif
-#endif
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// Moves data into the L1 cache before it is read, or "prefetches" it.
-//
-// The value of `addr` is the address of the memory to prefetch. If
-// the target and compiler support it, data prefetch instructions are
-// generated. If the prefetch is done some time before the memory is
-// read, it may be in the cache by the time the read occurs.
-//
-// This method prefetches data with the highest degree of temporal locality;
-// data is prefetched where possible into all levels of the cache.
-//
-// Incorrect or gratuitous use of this function can degrade performance.
-// Use this function only when representative benchmarks show an improvement.
-//
-// Example:
-//
-//  // Computes incremental checksum for `data`.
-//  int ComputeChecksum(int sum, absl::string_view data);
-//
-//  // Computes cumulative checksum for all values in `data`
-//  int ComputeChecksum(absl::Span<const std::string> data) {
-//    int sum = 0;
-//    auto it = data.begin();
-//    auto pit = data.begin();
-//    auto end = data.end();
-//    for (int dist = 8; dist > 0 && pit != data.end(); --dist, ++pit) {
-//      absl::PrefetchToLocalCache(pit->data());
-//    }
-//    for (; pit != end; ++pit, ++it) {
-//      sum = ComputeChecksum(sum, *it);
-//      absl::PrefetchToLocalCache(pit->data());
-//    }
-//    for (; it != end; ++it) {
-//      sum = ComputeChecksum(sum, *it);
-//    }
-//    return sum;
-//  }
-//
-void PrefetchToLocalCache(const void *addr);
-
-// Moves data into the L1 cache before it is read, or "prefetches" it.
-//
-// This function is identical to `PrefetchToLocalCache()` except that it has
-// non-temporal locality: the fetched data should not be left in any of the
-// cache tiers. This is useful for cases where the data is used only once /
-// short term, for example, invoking a destructor on an object.
-//
-// Incorrect or gratuitous use of this function can degrade performance.
-// Use this function only when representative benchmarks show an improvement.
-//
-// Example:
-//
-//  template <typename Iterator>
-//  void DestroyPointers(Iterator begin, Iterator end) {
-//    size_t distance = std::min(8U, bars.size());
-//
-//    int dist = 8;
-//    auto prefetch_it = begin;
-//    while (prefetch_it != end && --dist;) {
-//      absl::PrefetchToLocalCacheNta(*prefetch_it++);
-//    }
-//    while (prefetch_it != end) {
-//      delete *begin++;
-//      absl::PrefetchToLocalCacheNta(*prefetch_it++);
-//    }
-//    while (begin != end) {
-//      delete *begin++;
-//    }
-//  }
-//
-void PrefetchToLocalCacheNta(const void *addr);
-
-// Moves data into the L1 cache with the intent to modify it.
-//
-// This function is similar to `PrefetchToLocalCache()` except that it
-// prefetches cachelines with an 'intent to modify' This typically includes
-// invalidating cache entries for this address in all other cache tiers, and an
-// exclusive access intent.
-//
-// Incorrect or gratuitous use of this function can degrade performance. As this
-// function can invalidate cached cachelines on other caches and computer cores,
-// incorrect usage of this function can have an even greater negative impact
-// than incorrect regular prefetches.
-// Use this function only when representative benchmarks show an improvement.
-//
-// Example:
-//
-//  void* Arena::Allocate(size_t size) {
-//    void* ptr = AllocateBlock(size);
-//    absl::PrefetchToLocalCacheForWrite(ptr);
-//    return ptr;
-//  }
-//
-void PrefetchToLocalCacheForWrite(const void *addr);
-
-#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
-
-#define ABSL_HAVE_PREFETCH 1
-
-// See __builtin_prefetch:
-// https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html.
-//
-ABSL_ATTRIBUTE_ALWAYS_INLINE inline void
-PrefetchToLocalCache(const void *addr) {
-  __builtin_prefetch(addr, 0, 3);
-}
-
-ABSL_ATTRIBUTE_ALWAYS_INLINE inline void
-PrefetchToLocalCacheNta(const void *addr) {
-  __builtin_prefetch(addr, 0, 0);
-}
-
-ABSL_ATTRIBUTE_ALWAYS_INLINE inline void
-PrefetchToLocalCacheForWrite(const void *addr) {
-  // [x86] gcc/clang don't generate PREFETCHW for __builtin_prefetch(.., 1)
-  // unless -march=broadwell or newer; this is not generally the default, so we
-  // manually emit prefetchw. PREFETCHW is recognized as a no-op on older Intel
-  // processors and has been present on AMD processors since the K6-2.
-#if defined(__x86_64__) && !defined(__PRFCHW__)
-  asm("prefetchw %0" : : "m"(*reinterpret_cast<const char *>(addr)));
-#else
-  __builtin_prefetch(addr, 1, 3);
-#endif
-}
-
-#elif defined(ABSL_INTERNAL_HAVE_SSE)
-
-#define ABSL_HAVE_PREFETCH 1
-
-ABSL_ATTRIBUTE_ALWAYS_INLINE inline void
-PrefetchToLocalCache(const void *addr) {
-  _mm_prefetch(reinterpret_cast<const char *>(addr), _MM_HINT_T0);
-}
-
-ABSL_ATTRIBUTE_ALWAYS_INLINE inline void
-PrefetchToLocalCacheNta(const void *addr) {
-  _mm_prefetch(reinterpret_cast<const char *>(addr), _MM_HINT_NTA);
-}
-
-ABSL_ATTRIBUTE_ALWAYS_INLINE inline void
-PrefetchToLocalCacheForWrite(const void *addr) {
-#if defined(_MM_HINT_ET0)
-  _mm_prefetch(reinterpret_cast<const char *>(addr), _MM_HINT_ET0);
-#elif !defined(_MSC_VER) && defined(__x86_64__)
-  // _MM_HINT_ET0 is not universally supported. As we commented further
-  // up, PREFETCHW is recognized as a no-op on older Intel processors
-  // and has been present on AMD processors since the K6-2. We have this
-  // disabled for MSVC compilers as this miscompiles on older MSVC compilers.
-  asm("prefetchw %0" : : "m"(*reinterpret_cast<const char *>(addr)));
-#endif
-}
-
-#else
-
-ABSL_ATTRIBUTE_ALWAYS_INLINE inline void
-PrefetchToLocalCache(const void *addr) {}
-ABSL_ATTRIBUTE_ALWAYS_INLINE inline void
-PrefetchToLocalCacheNta(const void *addr) {}
-ABSL_ATTRIBUTE_ALWAYS_INLINE inline void
-PrefetchToLocalCacheForWrite(const void *addr) {}
-
-#endif
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_PREFETCH_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/base/thread_annotations.h b/packages/react-native-executorch/third-party/include/absl/base/thread_annotations.h
deleted file mode 100644
index a673844197..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/base/thread_annotations.h
+++ /dev/null
@@ -1,333 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: thread_annotations.h
-// -----------------------------------------------------------------------------
-//
-// This header file contains macro definitions for thread safety annotations
-// that allow developers to document the locking policies of multi-threaded
-// code. The annotations can also help program analysis tools to identify
-// potential thread safety issues.
-//
-// These annotations are implemented using compiler attributes. Using the macros
-// defined here instead of raw attributes allow for portability and future
-// compatibility.
-//
-// When referring to mutexes in the arguments of the attributes, you should
-// use variable names or more complex expressions (e.g. my_object->mutex_)
-// that evaluate to a concrete mutex object whenever possible. If the mutex
-// you want to refer to is not in scope, you may use a member pointer
-// (e.g. &MyClass::mutex_) to refer to a mutex in some (unknown) object.
-
-#ifndef ABSL_BASE_THREAD_ANNOTATIONS_H_
-#define ABSL_BASE_THREAD_ANNOTATIONS_H_
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-
-// ABSL_GUARDED_BY()
-//
-// Documents if a shared field or global variable needs to be protected by a
-// mutex. ABSL_GUARDED_BY() allows the user to specify a particular mutex that
-// should be held when accessing the annotated variable.
-//
-// Although this annotation (and ABSL_PT_GUARDED_BY, below) cannot be applied to
-// local variables, a local variable and its associated mutex can often be
-// combined into a small class or struct, thereby allowing the annotation.
-//
-// Example:
-//
-//   class Foo {
-//     Mutex mu_;
-//     int p1_ ABSL_GUARDED_BY(mu_);
-//     ...
-//   };
-#if ABSL_HAVE_ATTRIBUTE(guarded_by)
-#define ABSL_GUARDED_BY(x) __attribute__((guarded_by(x)))
-#else
-#define ABSL_GUARDED_BY(x)
-#endif
-
-// ABSL_PT_GUARDED_BY()
-//
-// Documents if the memory location pointed to by a pointer should be guarded
-// by a mutex when dereferencing the pointer.
-//
-// Example:
-//   class Foo {
-//     Mutex mu_;
-//     int *p1_ ABSL_PT_GUARDED_BY(mu_);
-//     ...
-//   };
-//
-// Note that a pointer variable to a shared memory location could itself be a
-// shared variable.
-//
-// Example:
-//
-//   // `q_`, guarded by `mu1_`, points to a shared memory location that is
-//   // guarded by `mu2_`:
-//   int *q_ ABSL_GUARDED_BY(mu1_) ABSL_PT_GUARDED_BY(mu2_);
-#if ABSL_HAVE_ATTRIBUTE(pt_guarded_by)
-#define ABSL_PT_GUARDED_BY(x) __attribute__((pt_guarded_by(x)))
-#else
-#define ABSL_PT_GUARDED_BY(x)
-#endif
-
-// ABSL_ACQUIRED_AFTER() / ABSL_ACQUIRED_BEFORE()
-//
-// Documents the acquisition order between locks that can be held
-// simultaneously by a thread. For any two locks that need to be annotated
-// to establish an acquisition order, only one of them needs the annotation.
-// (i.e. You don't have to annotate both locks with both ABSL_ACQUIRED_AFTER
-// and ABSL_ACQUIRED_BEFORE.)
-//
-// As with ABSL_GUARDED_BY, this is only applicable to mutexes that are shared
-// fields or global variables.
-//
-// Example:
-//
-//   Mutex m1_;
-//   Mutex m2_ ABSL_ACQUIRED_AFTER(m1_);
-#if ABSL_HAVE_ATTRIBUTE(acquired_after)
-#define ABSL_ACQUIRED_AFTER(...) __attribute__((acquired_after(__VA_ARGS__)))
-#else
-#define ABSL_ACQUIRED_AFTER(...)
-#endif
-
-#if ABSL_HAVE_ATTRIBUTE(acquired_before)
-#define ABSL_ACQUIRED_BEFORE(...) __attribute__((acquired_before(__VA_ARGS__)))
-#else
-#define ABSL_ACQUIRED_BEFORE(...)
-#endif
-
-// ABSL_EXCLUSIVE_LOCKS_REQUIRED() / ABSL_SHARED_LOCKS_REQUIRED()
-//
-// Documents a function that expects a mutex to be held prior to entry.
-// The mutex is expected to be held both on entry to, and exit from, the
-// function.
-//
-// An exclusive lock allows read-write access to the guarded data member(s), and
-// only one thread can acquire a lock exclusively at any one time. A shared lock
-// allows read-only access, and any number of threads can acquire a shared lock
-// concurrently.
-//
-// Generally, non-const methods should be annotated with
-// ABSL_EXCLUSIVE_LOCKS_REQUIRED, while const methods should be annotated with
-// ABSL_SHARED_LOCKS_REQUIRED.
-//
-// Example:
-//
-//   Mutex mu1, mu2;
-//   int a ABSL_GUARDED_BY(mu1);
-//   int b ABSL_GUARDED_BY(mu2);
-//
-//   void foo() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu1, mu2) { ... }
-//   void bar() const ABSL_SHARED_LOCKS_REQUIRED(mu1, mu2) { ... }
-#if ABSL_HAVE_ATTRIBUTE(exclusive_locks_required)
-#define ABSL_EXCLUSIVE_LOCKS_REQUIRED(...)                                     \
-  __attribute__((exclusive_locks_required(__VA_ARGS__)))
-#else
-#define ABSL_EXCLUSIVE_LOCKS_REQUIRED(...)
-#endif
-
-#if ABSL_HAVE_ATTRIBUTE(shared_locks_required)
-#define ABSL_SHARED_LOCKS_REQUIRED(...)                                        \
-  __attribute__((shared_locks_required(__VA_ARGS__)))
-#else
-#define ABSL_SHARED_LOCKS_REQUIRED(...)
-#endif
-
-// ABSL_LOCKS_EXCLUDED()
-//
-// Documents the locks that cannot be held by callers of this function, as they
-// might be acquired by this function (Abseil's `Mutex` locks are
-// non-reentrant).
-#if ABSL_HAVE_ATTRIBUTE(locks_excluded)
-#define ABSL_LOCKS_EXCLUDED(...) __attribute__((locks_excluded(__VA_ARGS__)))
-#else
-#define ABSL_LOCKS_EXCLUDED(...)
-#endif
-
-// ABSL_LOCK_RETURNED()
-//
-// Documents a function that returns a mutex without acquiring it.  For example,
-// a public getter method that returns a pointer to a private mutex should
-// be annotated with ABSL_LOCK_RETURNED.
-#if ABSL_HAVE_ATTRIBUTE(lock_returned)
-#define ABSL_LOCK_RETURNED(x) __attribute__((lock_returned(x)))
-#else
-#define ABSL_LOCK_RETURNED(x)
-#endif
-
-// ABSL_LOCKABLE
-//
-// Documents if a class/type is a lockable type (such as the `Mutex` class).
-#if ABSL_HAVE_ATTRIBUTE(lockable)
-#define ABSL_LOCKABLE __attribute__((lockable))
-#else
-#define ABSL_LOCKABLE
-#endif
-
-// ABSL_SCOPED_LOCKABLE
-//
-// Documents if a class does RAII locking (such as the `MutexLock` class).
-// The constructor should use `LOCK_FUNCTION()` to specify the mutex that is
-// acquired, and the destructor should use `UNLOCK_FUNCTION()` with no
-// arguments; the analysis will assume that the destructor unlocks whatever the
-// constructor locked.
-#if ABSL_HAVE_ATTRIBUTE(scoped_lockable)
-#define ABSL_SCOPED_LOCKABLE __attribute__((scoped_lockable))
-#else
-#define ABSL_SCOPED_LOCKABLE
-#endif
-
-// ABSL_EXCLUSIVE_LOCK_FUNCTION()
-//
-// Documents functions that acquire a lock in the body of a function, and do
-// not release it.
-#if ABSL_HAVE_ATTRIBUTE(exclusive_lock_function)
-#define ABSL_EXCLUSIVE_LOCK_FUNCTION(...)                                      \
-  __attribute__((exclusive_lock_function(__VA_ARGS__)))
-#else
-#define ABSL_EXCLUSIVE_LOCK_FUNCTION(...)
-#endif
-
-// ABSL_SHARED_LOCK_FUNCTION()
-//
-// Documents functions that acquire a shared (reader) lock in the body of a
-// function, and do not release it.
-#if ABSL_HAVE_ATTRIBUTE(shared_lock_function)
-#define ABSL_SHARED_LOCK_FUNCTION(...)                                         \
-  __attribute__((shared_lock_function(__VA_ARGS__)))
-#else
-#define ABSL_SHARED_LOCK_FUNCTION(...)
-#endif
-
-// ABSL_UNLOCK_FUNCTION()
-//
-// Documents functions that expect a lock to be held on entry to the function,
-// and release it in the body of the function.
-#if ABSL_HAVE_ATTRIBUTE(unlock_function)
-#define ABSL_UNLOCK_FUNCTION(...) __attribute__((unlock_function(__VA_ARGS__)))
-#else
-#define ABSL_UNLOCK_FUNCTION(...)
-#endif
-
-// ABSL_EXCLUSIVE_TRYLOCK_FUNCTION() / ABSL_SHARED_TRYLOCK_FUNCTION()
-//
-// Documents functions that try to acquire a lock, and return success or failure
-// (or a non-boolean value that can be interpreted as a boolean).
-// The first argument should be `true` for functions that return `true` on
-// success, or `false` for functions that return `false` on success. The second
-// argument specifies the mutex that is locked on success. If unspecified, this
-// mutex is assumed to be `this`.
-#if ABSL_HAVE_ATTRIBUTE(exclusive_trylock_function)
-#define ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(...)                                   \
-  __attribute__((exclusive_trylock_function(__VA_ARGS__)))
-#else
-#define ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(...)
-#endif
-
-#if ABSL_HAVE_ATTRIBUTE(shared_trylock_function)
-#define ABSL_SHARED_TRYLOCK_FUNCTION(...)                                      \
-  __attribute__((shared_trylock_function(__VA_ARGS__)))
-#else
-#define ABSL_SHARED_TRYLOCK_FUNCTION(...)
-#endif
-
-// ABSL_ASSERT_EXCLUSIVE_LOCK() / ABSL_ASSERT_SHARED_LOCK()
-//
-// Documents functions that dynamically check to see if a lock is held, and fail
-// if it is not held.
-#if ABSL_HAVE_ATTRIBUTE(assert_exclusive_lock)
-#define ABSL_ASSERT_EXCLUSIVE_LOCK(...)                                        \
-  __attribute__((assert_exclusive_lock(__VA_ARGS__)))
-#else
-#define ABSL_ASSERT_EXCLUSIVE_LOCK(...)
-#endif
-
-#if ABSL_HAVE_ATTRIBUTE(assert_shared_lock)
-#define ABSL_ASSERT_SHARED_LOCK(...)                                           \
-  __attribute__((assert_shared_lock(__VA_ARGS__)))
-#else
-#define ABSL_ASSERT_SHARED_LOCK(...)
-#endif
-
-// ABSL_NO_THREAD_SAFETY_ANALYSIS
-//
-// Turns off thread safety checking within the body of a particular function.
-// This annotation is used to mark functions that are known to be correct, but
-// the locking behavior is more complicated than the analyzer can handle.
-#if ABSL_HAVE_ATTRIBUTE(no_thread_safety_analysis)
-#define ABSL_NO_THREAD_SAFETY_ANALYSIS                                         \
-  __attribute__((no_thread_safety_analysis))
-#else
-#define ABSL_NO_THREAD_SAFETY_ANALYSIS
-#endif
-
-//------------------------------------------------------------------------------
-// Tool-Supplied Annotations
-//------------------------------------------------------------------------------
-
-// ABSL_TS_UNCHECKED should be placed around lock expressions that are not valid
-// C++ syntax, but which are present for documentation purposes.  These
-// annotations will be ignored by the analysis.
-#define ABSL_TS_UNCHECKED(x) ""
-
-// ABSL_TS_FIXME is used to mark lock expressions that are not valid C++ syntax.
-// It is used by automated tools to mark and disable invalid expressions.
-// The annotation should either be fixed, or changed to ABSL_TS_UNCHECKED.
-#define ABSL_TS_FIXME(x) ""
-
-// Like ABSL_NO_THREAD_SAFETY_ANALYSIS, this turns off checking within the body
-// of a particular function.  However, this attribute is used to mark functions
-// that are incorrect and need to be fixed.  It is used by automated tools to
-// avoid breaking the build when the analysis is updated.
-// Code owners are expected to eventually fix the routine.
-#define ABSL_NO_THREAD_SAFETY_ANALYSIS_FIXME ABSL_NO_THREAD_SAFETY_ANALYSIS
-
-// Similar to ABSL_NO_THREAD_SAFETY_ANALYSIS_FIXME, this macro marks a
-// ABSL_GUARDED_BY annotation that needs to be fixed, because it is producing
-// thread safety warning. It disables the ABSL_GUARDED_BY.
-#define ABSL_GUARDED_BY_FIXME(x)
-
-// Disables warnings for a single read operation.  This can be used to avoid
-// warnings when it is known that the read is not actually involved in a race,
-// but the compiler cannot confirm that.
-#define ABSL_TS_UNCHECKED_READ(x) absl::base_internal::ts_unchecked_read(x)
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-// Takes a reference to a guarded data member, and returns an unguarded
-// reference.
-// Do not use this function directly, use ABSL_TS_UNCHECKED_READ instead.
-template <typename T>
-inline const T &ts_unchecked_read(const T &v) ABSL_NO_THREAD_SAFETY_ANALYSIS {
-  return v;
-}
-
-template <typename T>
-inline T &ts_unchecked_read(T &v) ABSL_NO_THREAD_SAFETY_ANALYSIS {
-  return v;
-}
-
-} // namespace base_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_BASE_THREAD_ANNOTATIONS_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/meta/type_traits.h b/packages/react-native-executorch/third-party/include/absl/meta/type_traits.h
deleted file mode 100644
index e523718b8d..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/meta/type_traits.h
+++ /dev/null
@@ -1,636 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// type_traits.h
-// -----------------------------------------------------------------------------
-//
-// This file contains C++11-compatible versions of standard <type_traits> API
-// functions for determining the characteristics of types. Such traits can
-// support type inference, classification, and transformation, as well as
-// make it easier to write templates based on generic type behavior.
-//
-// See https://en.cppreference.com/w/cpp/header/type_traits
-//
-// WARNING: use of many of the constructs in this header will count as "complex
-// template metaprogramming", so before proceeding, please carefully consider
-// https://google.github.io/styleguide/cppguide.html#Template_metaprogramming
-//
-// WARNING: using template metaprogramming to detect or depend on API
-// features is brittle and not guaranteed. Neither the standard library nor
-// Abseil provides any guarantee that APIs are stable in the face of template
-// metaprogramming. Use with caution.
-#ifndef ABSL_META_TYPE_TRAITS_H_
-#define ABSL_META_TYPE_TRAITS_H_
-
-#include <cstddef>
-#include <functional>
-#include <string>
-#include <type_traits>
-#include <vector>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-
-#ifdef __cpp_lib_span
-#include <span> // NOLINT(build/c++20)
-#endif
-
-#ifdef ABSL_HAVE_STD_STRING_VIEW
-#include <string_view>
-#endif
-
-// Defines the default alignment. `__STDCPP_DEFAULT_NEW_ALIGNMENT__` is a C++17
-// feature.
-#if defined(__STDCPP_DEFAULT_NEW_ALIGNMENT__)
-#define ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT __STDCPP_DEFAULT_NEW_ALIGNMENT__
-#else // defined(__STDCPP_DEFAULT_NEW_ALIGNMENT__)
-#define ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT alignof(std::max_align_t)
-#endif // defined(__STDCPP_DEFAULT_NEW_ALIGNMENT__)
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-namespace type_traits_internal {
-
-template <typename... Ts> struct VoidTImpl {
-  using type = void;
-};
-
-////////////////////////////////
-// Library Fundamentals V2 TS //
-////////////////////////////////
-
-// NOTE: The `is_detected` family of templates here differ from the library
-// fundamentals specification in that for library fundamentals, `Op<Args...>` is
-// evaluated as soon as the type `is_detected<Op, Args...>` undergoes
-// substitution, regardless of whether or not the `::value` is accessed. That
-// is inconsistent with all other standard traits and prevents lazy evaluation
-// in larger contexts (such as if the `is_detected` check is a trailing argument
-// of a `conjunction`. This implementation opts to instead be lazy in the same
-// way that the standard traits are (this "defect" of the detection idiom
-// specifications has been reported).
-
-template <class Enabler, template <class...> class Op, class... Args>
-struct is_detected_impl {
-  using type = std::false_type;
-};
-
-template <template <class...> class Op, class... Args>
-struct is_detected_impl<typename VoidTImpl<Op<Args...>>::type, Op, Args...> {
-  using type = std::true_type;
-};
-
-template <template <class...> class Op, class... Args>
-struct is_detected : is_detected_impl<void, Op, Args...>::type {};
-
-template <class Enabler, class To, template <class...> class Op, class... Args>
-struct is_detected_convertible_impl {
-  using type = std::false_type;
-};
-
-template <class To, template <class...> class Op, class... Args>
-struct is_detected_convertible_impl<
-    typename std::enable_if<std::is_convertible<Op<Args...>, To>::value>::type,
-    To, Op, Args...> {
-  using type = std::true_type;
-};
-
-template <class To, template <class...> class Op, class... Args>
-struct is_detected_convertible
-    : is_detected_convertible_impl<void, To, Op, Args...>::type {};
-
-} // namespace type_traits_internal
-
-// void_t()
-//
-// Ignores the type of any its arguments and returns `void`. In general, this
-// metafunction allows you to create a general case that maps to `void` while
-// allowing specializations that map to specific types.
-//
-// This metafunction is designed to be a drop-in replacement for the C++17
-// `std::void_t` metafunction.
-//
-// NOTE: `absl::void_t` does not use the standard-specified implementation so
-// that it can remain compatible with gcc < 5.1. This can introduce slightly
-// different behavior, such as when ordering partial specializations.
-template <typename... Ts>
-using void_t = typename type_traits_internal::VoidTImpl<Ts...>::type;
-
-// conjunction
-//
-// Performs a compile-time logical AND operation on the passed types (which
-// must have  `::value` members convertible to `bool`. Short-circuits if it
-// encounters any `false` members (and does not compare the `::value` members
-// of any remaining arguments).
-//
-// This metafunction is designed to be a drop-in replacement for the C++17
-// `std::conjunction` metafunction.
-template <typename... Ts> struct conjunction : std::true_type {};
-
-template <typename T, typename... Ts>
-struct conjunction<T, Ts...>
-    : std::conditional<T::value, conjunction<Ts...>, T>::type {};
-
-template <typename T> struct conjunction<T> : T {};
-
-// disjunction
-//
-// Performs a compile-time logical OR operation on the passed types (which
-// must have  `::value` members convertible to `bool`. Short-circuits if it
-// encounters any `true` members (and does not compare the `::value` members
-// of any remaining arguments).
-//
-// This metafunction is designed to be a drop-in replacement for the C++17
-// `std::disjunction` metafunction.
-template <typename... Ts> struct disjunction : std::false_type {};
-
-template <typename T, typename... Ts>
-struct disjunction<T, Ts...>
-    : std::conditional<T::value, T, disjunction<Ts...>>::type {};
-
-template <typename T> struct disjunction<T> : T {};
-
-// negation
-//
-// Performs a compile-time logical NOT operation on the passed type (which
-// must have  `::value` members convertible to `bool`.
-//
-// This metafunction is designed to be a drop-in replacement for the C++17
-// `std::negation` metafunction.
-template <typename T>
-struct negation : std::integral_constant<bool, !T::value> {};
-
-// is_function()
-//
-// Determines whether the passed type `T` is a function type.
-//
-// This metafunction is designed to be a drop-in replacement for the C++11
-// `std::is_function()` metafunction for platforms that have incomplete C++11
-// support (such as libstdc++ 4.x).
-//
-// This metafunction works because appending `const` to a type does nothing to
-// function types and reference types (and forms a const-qualified type
-// otherwise).
-template <typename T>
-struct is_function
-    : std::integral_constant<
-          bool, !(std::is_reference<T>::value ||
-                  std::is_const<typename std::add_const<T>::type>::value)> {};
-
-// is_copy_assignable()
-// is_move_assignable()
-// is_trivially_destructible()
-// is_trivially_default_constructible()
-// is_trivially_move_constructible()
-// is_trivially_copy_constructible()
-// is_trivially_move_assignable()
-// is_trivially_copy_assignable()
-//
-// Historical note: Abseil once provided implementations of these type traits
-// for platforms that lacked full support. New code should prefer to use the
-// std variants.
-//
-// See the documentation for the STL <type_traits> header for more information:
-// https://en.cppreference.com/w/cpp/header/type_traits
-using std::is_copy_assignable;
-using std::is_move_assignable;
-using std::is_trivially_copy_assignable;
-using std::is_trivially_copy_constructible;
-using std::is_trivially_default_constructible;
-using std::is_trivially_destructible;
-using std::is_trivially_move_assignable;
-using std::is_trivially_move_constructible;
-
-#if defined(__cpp_lib_remove_cvref) && __cpp_lib_remove_cvref >= 201711L
-template <typename T> using remove_cvref = std::remove_cvref<T>;
-
-template <typename T>
-using remove_cvref_t = typename std::remove_cvref<T>::type;
-#else
-// remove_cvref()
-//
-// C++11 compatible implementation of std::remove_cvref which was added in
-// C++20.
-template <typename T> struct remove_cvref {
-  using type =
-      typename std::remove_cv<typename std::remove_reference<T>::type>::type;
-};
-
-template <typename T> using remove_cvref_t = typename remove_cvref<T>::type;
-#endif
-
-// -----------------------------------------------------------------------------
-// C++14 "_t" trait aliases
-// -----------------------------------------------------------------------------
-
-template <typename T> using remove_cv_t = typename std::remove_cv<T>::type;
-
-template <typename T>
-using remove_const_t = typename std::remove_const<T>::type;
-
-template <typename T>
-using remove_volatile_t = typename std::remove_volatile<T>::type;
-
-template <typename T> using add_cv_t = typename std::add_cv<T>::type;
-
-template <typename T> using add_const_t = typename std::add_const<T>::type;
-
-template <typename T>
-using add_volatile_t = typename std::add_volatile<T>::type;
-
-template <typename T>
-using remove_reference_t = typename std::remove_reference<T>::type;
-
-template <typename T>
-using add_lvalue_reference_t = typename std::add_lvalue_reference<T>::type;
-
-template <typename T>
-using add_rvalue_reference_t = typename std::add_rvalue_reference<T>::type;
-
-template <typename T>
-using remove_pointer_t = typename std::remove_pointer<T>::type;
-
-template <typename T> using add_pointer_t = typename std::add_pointer<T>::type;
-
-template <typename T> using make_signed_t = typename std::make_signed<T>::type;
-
-template <typename T>
-using make_unsigned_t = typename std::make_unsigned<T>::type;
-
-template <typename T>
-using remove_extent_t = typename std::remove_extent<T>::type;
-
-template <typename T>
-using remove_all_extents_t = typename std::remove_all_extents<T>::type;
-
-template <typename T> using decay_t = typename std::decay<T>::type;
-
-template <bool B, typename T = void>
-using enable_if_t = typename std::enable_if<B, T>::type;
-
-template <bool B, typename T, typename F>
-using conditional_t = typename std::conditional<B, T, F>::type;
-
-template <typename... T>
-using common_type_t = typename std::common_type<T...>::type;
-
-template <typename T>
-using underlying_type_t = typename std::underlying_type<T>::type;
-
-namespace type_traits_internal {
-
-#if (defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703L) ||  \
-    (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
-// std::result_of is deprecated (C++17) or removed (C++20)
-template <typename> struct result_of;
-template <typename F, typename... Args>
-struct result_of<F(Args...)> : std::invoke_result<F, Args...> {};
-#else
-template <typename F> using result_of = std::result_of<F>;
-#endif
-
-} // namespace type_traits_internal
-
-template <typename F>
-using result_of_t = typename type_traits_internal::result_of<F>::type;
-
-namespace type_traits_internal {
-// In MSVC we can't probe std::hash or stdext::hash because it triggers a
-// static_assert instead of failing substitution. Libc++ prior to 4.0
-// also used a static_assert.
-//
-#if defined(_MSC_VER) || (defined(_LIBCPP_VERSION) &&                          \
-                          _LIBCPP_VERSION < 4000 && _LIBCPP_STD_VER > 11)
-#define ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ 0
-#else
-#define ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ 1
-#endif
-
-#if !ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
-template <typename Key, typename = size_t>
-struct IsHashable : std::true_type {};
-#else  // ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
-template <typename Key, typename = void> struct IsHashable : std::false_type {};
-
-template <typename Key>
-struct IsHashable<
-    Key,
-    absl::enable_if_t<std::is_convertible<
-        decltype(std::declval<std::hash<Key> &>()(std::declval<Key const &>())),
-        std::size_t>::value>> : std::true_type {};
-#endif // !ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
-
-struct AssertHashEnabledHelper {
-private:
-  static void Sink(...) {}
-  struct NAT {};
-
-  template <class Key>
-  static auto GetReturnType(int)
-      -> decltype(std::declval<std::hash<Key>>()(std::declval<Key const &>()));
-  template <class Key> static NAT GetReturnType(...);
-
-  template <class Key> static std::nullptr_t DoIt() {
-    static_assert(IsHashable<Key>::value,
-                  "std::hash<Key> does not provide a call operator");
-    static_assert(
-        std::is_default_constructible<std::hash<Key>>::value,
-        "std::hash<Key> must be default constructible when it is enabled");
-    static_assert(
-        std::is_copy_constructible<std::hash<Key>>::value,
-        "std::hash<Key> must be copy constructible when it is enabled");
-    static_assert(absl::is_copy_assignable<std::hash<Key>>::value,
-                  "std::hash<Key> must be copy assignable when it is enabled");
-    // is_destructible is unchecked as it's implied by each of the
-    // is_constructible checks.
-    using ReturnType = decltype(GetReturnType<Key>(0));
-    static_assert(std::is_same<ReturnType, NAT>::value ||
-                      std::is_same<ReturnType, size_t>::value,
-                  "std::hash<Key> must return size_t");
-    return nullptr;
-  }
-
-  template <class... Ts> friend void AssertHashEnabled();
-};
-
-template <class... Ts> inline void AssertHashEnabled() {
-  using Helper = AssertHashEnabledHelper;
-  Helper::Sink(Helper::DoIt<Ts>()...);
-}
-
-} // namespace type_traits_internal
-
-// An internal namespace that is required to implement the C++17 swap traits.
-// It is not further nested in type_traits_internal to avoid long symbol names.
-namespace swap_internal {
-
-// Necessary for the traits.
-using std::swap;
-
-// This declaration prevents global `swap` and `absl::swap` overloads from being
-// considered unless ADL picks them up.
-void swap();
-
-template <class T>
-using IsSwappableImpl =
-    decltype(swap(std::declval<T &>(), std::declval<T &>()));
-
-// NOTE: This dance with the default template parameter is for MSVC.
-template <class T,
-          class IsNoexcept = std::integral_constant<
-              bool, noexcept(swap(std::declval<T &>(), std::declval<T &>()))>>
-using IsNothrowSwappableImpl = typename std::enable_if<IsNoexcept::value>::type;
-
-// IsSwappable
-//
-// Determines whether the standard swap idiom is a valid expression for
-// arguments of type `T`.
-template <class T>
-struct IsSwappable
-    : absl::type_traits_internal::is_detected<IsSwappableImpl, T> {};
-
-// IsNothrowSwappable
-//
-// Determines whether the standard swap idiom is a valid expression for
-// arguments of type `T` and is noexcept.
-template <class T>
-struct IsNothrowSwappable
-    : absl::type_traits_internal::is_detected<IsNothrowSwappableImpl, T> {};
-
-// Swap()
-//
-// Performs the swap idiom from a namespace where valid candidates may only be
-// found in `std` or via ADL.
-template <class T, absl::enable_if_t<IsSwappable<T>::value, int> = 0>
-void Swap(T &lhs, T &rhs) noexcept(IsNothrowSwappable<T>::value) {
-  swap(lhs, rhs);
-}
-
-// StdSwapIsUnconstrained
-//
-// Some standard library implementations are broken in that they do not
-// constrain `std::swap`. This will effectively tell us if we are dealing with
-// one of those implementations.
-using StdSwapIsUnconstrained = IsSwappable<void()>;
-
-} // namespace swap_internal
-
-namespace type_traits_internal {
-
-// Make the swap-related traits/function accessible from this namespace.
-using swap_internal::IsNothrowSwappable;
-using swap_internal::IsSwappable;
-using swap_internal::StdSwapIsUnconstrained;
-using swap_internal::Swap;
-
-} // namespace type_traits_internal
-
-// absl::is_trivially_relocatable<T>
-//
-// Detects whether a type is known to be "trivially relocatable" -- meaning it
-// can be relocated from one place to another as if by memcpy/memmove.
-// This implies that its object representation doesn't depend on its address,
-// and also none of its special member functions do anything strange.
-//
-// This trait is conservative. If it's true then the type is definitely
-// trivially relocatable, but if it's false then the type may or may not be. For
-// example, std::vector<int> is trivially relocatable on every known STL
-// implementation, but absl::is_trivially_relocatable<std::vector<int>> remains
-// false.
-//
-// Example:
-//
-// if constexpr (absl::is_trivially_relocatable<T>::value) {
-//   memcpy(new_location, old_location, sizeof(T));
-// } else {
-//   new(new_location) T(std::move(*old_location));
-//   old_location->~T();
-// }
-//
-// Upstream documentation:
-//
-// https://clang.llvm.org/docs/LanguageExtensions.html#:~:text=__is_trivially_relocatable
-
-// If the compiler offers a builtin that tells us the answer, we can use that.
-// This covers all of the cases in the fallback below, plus types that opt in
-// using e.g. [[clang::trivial_abi]].
-//
-// Clang on Windows has the builtin, but it falsely claims types with a
-// user-provided destructor are trivial (http://b/275003464). So we opt out
-// there.
-//
-// TODO(b/275003464): remove the opt-out once the bug is fixed.
-//
-// Starting with Xcode 15, the Apple compiler will falsely say a type
-// with a user-provided move constructor is trivially relocatable
-// (b/324278148). We will opt out without a version check, due to
-// the fluidity of Apple versions.
-//
-// TODO(b/324278148): If all versions we use have the bug fixed, then
-// remove the condition.
-//
-// Clang on all platforms fails to detect that a type with a user-provided
-// move-assignment operator is not trivially relocatable. So in fact we
-// opt out of Clang altogether, for now.
-//
-// TODO(b/325479096): Remove the opt-out once Clang's behavior is fixed.
-//
-// According to https://github.com/abseil/abseil-cpp/issues/1479, this does not
-// work with NVCC either.
-#if ABSL_HAVE_BUILTIN(__is_trivially_relocatable) &&                           \
-    (defined(__cpp_impl_trivially_relocatable) ||                              \
-     (!defined(__clang__) && !defined(__APPLE__) && !defined(__NVCC__)))
-template <class T>
-struct is_trivially_relocatable
-    : std::integral_constant<bool, __is_trivially_relocatable(T)> {};
-#else
-// Otherwise we use a fallback that detects only those types we can feasibly
-// detect. Any type that is trivially copyable is by definition trivially
-// relocatable.
-template <class T>
-struct is_trivially_relocatable : std::is_trivially_copyable<T> {};
-#endif
-
-// absl::is_constant_evaluated()
-//
-// Detects whether the function call occurs within a constant-evaluated context.
-// Returns true if the evaluation of the call occurs within the evaluation of an
-// expression or conversion that is manifestly constant-evaluated; otherwise
-// returns false.
-//
-// This function is implemented in terms of `std::is_constant_evaluated` for
-// c++20 and up. For older c++ versions, the function is implemented in terms
-// of `__builtin_is_constant_evaluated` if available, otherwise the function
-// will fail to compile.
-//
-// Applications can inspect `ABSL_HAVE_CONSTANT_EVALUATED` at compile time
-// to check if this function is supported.
-//
-// Example:
-//
-// constexpr MyClass::MyClass(int param) {
-// #ifdef ABSL_HAVE_CONSTANT_EVALUATED
-//   if (!absl::is_constant_evaluated()) {
-//     ABSL_LOG(INFO) << "MyClass(" << param << ")";
-//   }
-// #endif  // ABSL_HAVE_CONSTANT_EVALUATED
-// }
-//
-// Upstream documentation:
-//
-// http://en.cppreference.com/w/cpp/types/is_constant_evaluated
-// http://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html#:~:text=__builtin_is_constant_evaluated
-//
-#if defined(ABSL_HAVE_CONSTANT_EVALUATED)
-constexpr bool is_constant_evaluated() noexcept {
-#ifdef __cpp_lib_is_constant_evaluated
-  return std::is_constant_evaluated();
-#elif ABSL_HAVE_BUILTIN(__builtin_is_constant_evaluated)
-  return __builtin_is_constant_evaluated();
-#endif
-}
-#endif // ABSL_HAVE_CONSTANT_EVALUATED
-
-namespace type_traits_internal {
-
-// Detects if a class's definition has declared itself to be an owner by
-// declaring
-//   using absl_internal_is_view = std::true_type;
-// as a member.
-// Types that don't want either must either omit this declaration entirely, or
-// (if e.g. inheriting from a base class) define the member to something that
-// isn't a Boolean trait class, such as `void`.
-// Do not specialize or use this directly. It's an implementation detail.
-template <typename T, typename = void> struct IsOwnerImpl : std::false_type {
-  static_assert(std::is_same<T, absl::remove_cvref_t<T>>::value,
-                "type must lack qualifiers");
-};
-
-template <typename T>
-struct IsOwnerImpl<
-    T,
-    std::enable_if_t<std::is_class<typename T::absl_internal_is_view>::value>>
-    : absl::negation<typename T::absl_internal_is_view> {};
-
-// A trait to determine whether a type is an owner.
-// Do *not* depend on the correctness of this trait for correct code behavior.
-// It is only a safety feature and its value may change in the future.
-// Do not specialize this; instead, define the member trait inside your type so
-// that it can be auto-detected, and to prevent ODR violations.
-// If it ever becomes possible to detect [[gsl::Owner]], we should leverage it:
-// https://wg21.link/p1179
-template <typename T> struct IsOwner : IsOwnerImpl<T> {};
-
-template <typename T, typename Traits, typename Alloc>
-struct IsOwner<std::basic_string<T, Traits, Alloc>> : std::true_type {};
-
-template <typename T, typename Alloc>
-struct IsOwner<std::vector<T, Alloc>> : std::true_type {};
-
-// Detects if a class's definition has declared itself to be a view by declaring
-//   using absl_internal_is_view = std::true_type;
-// as a member.
-// Do not specialize or use this directly.
-template <typename T, typename = void> struct IsViewImpl : std::false_type {
-  static_assert(std::is_same<T, absl::remove_cvref_t<T>>::value,
-                "type must lack qualifiers");
-};
-
-template <typename T>
-struct IsViewImpl<
-    T,
-    std::enable_if_t<std::is_class<typename T::absl_internal_is_view>::value>>
-    : T::absl_internal_is_view {};
-
-// A trait to determine whether a type is a view.
-// Do *not* depend on the correctness of this trait for correct code behavior.
-// It is only a safety feature, and its value may change in the future.
-// Do not specialize this trait. Instead, define the member
-//   using absl_internal_is_view = std::true_type;
-// in your class to allow its detection while preventing ODR violations.
-// If it ever becomes possible to detect [[gsl::Pointer]], we should leverage
-// it: https://wg21.link/p1179
-template <typename T>
-struct IsView : std::integral_constant<bool, std::is_pointer<T>::value ||
-                                                 IsViewImpl<T>::value> {};
-
-#ifdef ABSL_HAVE_STD_STRING_VIEW
-template <typename Char, typename Traits>
-struct IsView<std::basic_string_view<Char, Traits>> : std::true_type {};
-#endif
-
-#ifdef __cpp_lib_span
-template <typename T> struct IsView<std::span<T>> : std::true_type {};
-#endif
-
-// Determines whether the assignment of the given types is lifetime-bound.
-// Do *not* depend on the correctness of this trait for correct code behavior.
-// It is only a safety feature and its value may change in the future.
-// If it ever becomes possible to detect [[clang::lifetimebound]] directly,
-// we should change the implementation to leverage that.
-// Until then, we consider an assignment from an "owner" (such as std::string)
-// to a "view" (such as std::string_view) to be a lifetime-bound assignment.
-template <typename T, typename U>
-using IsLifetimeBoundAssignment =
-    std::integral_constant<bool, IsView<absl::remove_cvref_t<T>>::value &&
-                                     IsOwner<absl::remove_cvref_t<U>>::value>;
-
-} // namespace type_traits_internal
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_META_TYPE_TRAITS_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/ascii.h b/packages/react-native-executorch/third-party/include/absl/strings/ascii.h
deleted file mode 100644
index 7295b44f42..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/ascii.h
+++ /dev/null
@@ -1,284 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: ascii.h
-// -----------------------------------------------------------------------------
-//
-// This package contains functions operating on characters and strings
-// restricted to standard ASCII. These include character classification
-// functions analogous to those found in the ANSI C Standard Library <ctype.h>
-// header file.
-//
-// C++ implementations provide <ctype.h> functionality based on their
-// C environment locale. In general, reliance on such a locale is not ideal, as
-// the locale standard is problematic (and may not return invariant information
-// for the same character set, for example). These `ascii_*()` functions are
-// hard-wired for standard ASCII, much faster, and guaranteed to behave
-// consistently.  They will never be overloaded, nor will their function
-// signature change.
-//
-// `ascii_isalnum()`, `ascii_isalpha()`, `ascii_isascii()`, `ascii_isblank()`,
-// `ascii_iscntrl()`, `ascii_isdigit()`, `ascii_isgraph()`, `ascii_islower()`,
-// `ascii_isprint()`, `ascii_ispunct()`, `ascii_isspace()`, `ascii_isupper()`,
-// `ascii_isxdigit()`
-//   Analogous to the <ctype.h> functions with similar names, these
-//   functions take an unsigned char and return a bool, based on whether the
-//   character matches the condition specified.
-//
-//   If the input character has a numerical value greater than 127, these
-//   functions return `false`.
-//
-// `ascii_tolower()`, `ascii_toupper()`
-//   Analogous to the <ctype.h> functions with similar names, these functions
-//   take an unsigned char and return a char.
-//
-//   If the input character is not an ASCII {lower,upper}-case letter (including
-//   numerical values greater than 127) then the functions return the same value
-//   as the input character.
-
-#ifndef ABSL_STRINGS_ASCII_H_
-#define ABSL_STRINGS_ASCII_H_
-
-#include <algorithm>
-#include <cstddef>
-#include <string>
-#include <utility>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/base/nullability.h"
-#include "absl/strings/internal/resize_uninitialized.h"
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace ascii_internal {
-
-// Declaration for an array of bitfields holding character information.
-ABSL_DLL extern const unsigned char kPropertyBits[256];
-
-// Declaration for the array of characters to upper-case characters.
-ABSL_DLL extern const char kToUpper[256];
-
-// Declaration for the array of characters to lower-case characters.
-ABSL_DLL extern const char kToLower[256];
-
-void AsciiStrToLower(absl::Nonnull<char *> dst,
-                     absl::Nullable<const char *> src, size_t n);
-
-void AsciiStrToUpper(absl::Nonnull<char *> dst,
-                     absl::Nullable<const char *> src, size_t n);
-
-} // namespace ascii_internal
-
-// ascii_isalpha()
-//
-// Determines whether the given character is an alphabetic character.
-inline bool ascii_isalpha(unsigned char c) {
-  return (ascii_internal::kPropertyBits[c] & 0x01) != 0;
-}
-
-// ascii_isalnum()
-//
-// Determines whether the given character is an alphanumeric character.
-inline bool ascii_isalnum(unsigned char c) {
-  return (ascii_internal::kPropertyBits[c] & 0x04) != 0;
-}
-
-// ascii_isspace()
-//
-// Determines whether the given character is a whitespace character (space,
-// tab, vertical tab, formfeed, linefeed, or carriage return).
-inline bool ascii_isspace(unsigned char c) {
-  return (ascii_internal::kPropertyBits[c] & 0x08) != 0;
-}
-
-// ascii_ispunct()
-//
-// Determines whether the given character is a punctuation character.
-inline bool ascii_ispunct(unsigned char c) {
-  return (ascii_internal::kPropertyBits[c] & 0x10) != 0;
-}
-
-// ascii_isblank()
-//
-// Determines whether the given character is a blank character (tab or space).
-inline bool ascii_isblank(unsigned char c) {
-  return (ascii_internal::kPropertyBits[c] & 0x20) != 0;
-}
-
-// ascii_iscntrl()
-//
-// Determines whether the given character is a control character.
-inline bool ascii_iscntrl(unsigned char c) {
-  return (ascii_internal::kPropertyBits[c] & 0x40) != 0;
-}
-
-// ascii_isxdigit()
-//
-// Determines whether the given character can be represented as a hexadecimal
-// digit character (i.e. {0-9} or {A-F}).
-inline bool ascii_isxdigit(unsigned char c) {
-  return (ascii_internal::kPropertyBits[c] & 0x80) != 0;
-}
-
-// ascii_isdigit()
-//
-// Determines whether the given character can be represented as a decimal
-// digit character (i.e. {0-9}).
-inline constexpr bool ascii_isdigit(unsigned char c) {
-  return c >= '0' && c <= '9';
-}
-
-// ascii_isprint()
-//
-// Determines whether the given character is printable, including spaces.
-inline constexpr bool ascii_isprint(unsigned char c) {
-  return c >= 32 && c < 127;
-}
-
-// ascii_isgraph()
-//
-// Determines whether the given character has a graphical representation.
-inline constexpr bool ascii_isgraph(unsigned char c) {
-  return c > 32 && c < 127;
-}
-
-// ascii_isupper()
-//
-// Determines whether the given character is uppercase.
-inline constexpr bool ascii_isupper(unsigned char c) {
-  return c >= 'A' && c <= 'Z';
-}
-
-// ascii_islower()
-//
-// Determines whether the given character is lowercase.
-inline constexpr bool ascii_islower(unsigned char c) {
-  return c >= 'a' && c <= 'z';
-}
-
-// ascii_isascii()
-//
-// Determines whether the given character is ASCII.
-inline constexpr bool ascii_isascii(unsigned char c) { return c < 128; }
-
-// ascii_tolower()
-//
-// Returns an ASCII character, converting to lowercase if uppercase is
-// passed. Note that character values > 127 are simply returned.
-inline char ascii_tolower(unsigned char c) {
-  return ascii_internal::kToLower[c];
-}
-
-// Converts the characters in `s` to lowercase, changing the contents of `s`.
-void AsciiStrToLower(absl::Nonnull<std::string *> s);
-
-// Creates a lowercase string from a given absl::string_view.
-ABSL_MUST_USE_RESULT inline std::string AsciiStrToLower(absl::string_view s) {
-  std::string result;
-  strings_internal::STLStringResizeUninitialized(&result, s.size());
-  ascii_internal::AsciiStrToLower(&result[0], s.data(), s.size());
-  return result;
-}
-
-// Creates a lowercase string from a given std::string&&.
-//
-// (Template is used to lower priority of this overload.)
-template <int &...DoNotSpecify>
-ABSL_MUST_USE_RESULT inline std::string AsciiStrToLower(std::string &&s) {
-  std::string result = std::move(s);
-  absl::AsciiStrToLower(&result);
-  return result;
-}
-
-// ascii_toupper()
-//
-// Returns the ASCII character, converting to upper-case if lower-case is
-// passed. Note that characters values > 127 are simply returned.
-inline char ascii_toupper(unsigned char c) {
-  return ascii_internal::kToUpper[c];
-}
-
-// Converts the characters in `s` to uppercase, changing the contents of `s`.
-void AsciiStrToUpper(absl::Nonnull<std::string *> s);
-
-// Creates an uppercase string from a given absl::string_view.
-ABSL_MUST_USE_RESULT inline std::string AsciiStrToUpper(absl::string_view s) {
-  std::string result;
-  strings_internal::STLStringResizeUninitialized(&result, s.size());
-  ascii_internal::AsciiStrToUpper(&result[0], s.data(), s.size());
-  return result;
-}
-
-// Creates an uppercase string from a given std::string&&.
-//
-// (Template is used to lower priority of this overload.)
-template <int &...DoNotSpecify>
-ABSL_MUST_USE_RESULT inline std::string AsciiStrToUpper(std::string &&s) {
-  std::string result = std::move(s);
-  absl::AsciiStrToUpper(&result);
-  return result;
-}
-
-// Returns absl::string_view with whitespace stripped from the beginning of the
-// given string_view.
-ABSL_MUST_USE_RESULT inline absl::string_view
-StripLeadingAsciiWhitespace(absl::string_view str) {
-  auto it = std::find_if_not(str.begin(), str.end(), absl::ascii_isspace);
-  return str.substr(static_cast<size_t>(it - str.begin()));
-}
-
-// Strips in place whitespace from the beginning of the given string.
-inline void StripLeadingAsciiWhitespace(absl::Nonnull<std::string *> str) {
-  auto it = std::find_if_not(str->begin(), str->end(), absl::ascii_isspace);
-  str->erase(str->begin(), it);
-}
-
-// Returns absl::string_view with whitespace stripped from the end of the given
-// string_view.
-ABSL_MUST_USE_RESULT inline absl::string_view
-StripTrailingAsciiWhitespace(absl::string_view str) {
-  auto it = std::find_if_not(str.rbegin(), str.rend(), absl::ascii_isspace);
-  return str.substr(0, static_cast<size_t>(str.rend() - it));
-}
-
-// Strips in place whitespace from the end of the given string
-inline void StripTrailingAsciiWhitespace(absl::Nonnull<std::string *> str) {
-  auto it = std::find_if_not(str->rbegin(), str->rend(), absl::ascii_isspace);
-  str->erase(static_cast<size_t>(str->rend() - it));
-}
-
-// Returns absl::string_view with whitespace stripped from both ends of the
-// given string_view.
-ABSL_MUST_USE_RESULT inline absl::string_view
-StripAsciiWhitespace(absl::string_view str) {
-  return StripTrailingAsciiWhitespace(StripLeadingAsciiWhitespace(str));
-}
-
-// Strips in place whitespace from both ends of the given string
-inline void StripAsciiWhitespace(absl::Nonnull<std::string *> str) {
-  StripTrailingAsciiWhitespace(str);
-  StripLeadingAsciiWhitespace(str);
-}
-
-// Removes leading, trailing, and consecutive internal whitespace.
-void RemoveExtraAsciiWhitespace(absl::Nonnull<std::string *> str);
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_ASCII_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/charconv.h b/packages/react-native-executorch/third-party/include/absl/strings/charconv.h
deleted file mode 100644
index 9b0f14f598..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/charconv.h
+++ /dev/null
@@ -1,123 +0,0 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_CHARCONV_H_
-#define ABSL_STRINGS_CHARCONV_H_
-
-#include <system_error> // NOLINT(build/c++11)
-
-#include "absl/base/config.h"
-#include "absl/base/nullability.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// Workalike compatibility version of std::chars_format from C++17.
-//
-// This is an bitfield enumerator which can be passed to absl::from_chars to
-// configure the string-to-float conversion.
-enum class chars_format {
-  scientific = 1,
-  fixed = 2,
-  hex = 4,
-  general = fixed | scientific,
-};
-
-// The return result of a string-to-number conversion.
-//
-// `ec` will be set to `invalid_argument` if a well-formed number was not found
-// at the start of the input range, `result_out_of_range` if a well-formed
-// number was found, but it was out of the representable range of the requested
-// type, or to std::errc() otherwise.
-//
-// If a well-formed number was found, `ptr` is set to one past the sequence of
-// characters that were successfully parsed.  If none was found, `ptr` is set
-// to the `first` argument to from_chars.
-struct from_chars_result {
-  absl::Nonnull<const char *> ptr;
-  std::errc ec;
-};
-
-// Workalike compatibility version of std::from_chars from C++17.  Currently
-// this only supports the `double` and `float` types.
-//
-// This interface incorporates the proposed resolutions for library issues
-// DR 3080 and DR 3081.  If these are adopted with different wording,
-// Abseil's behavior will change to match the standard.  (The behavior most
-// likely to change is for DR 3081, which says what `value` will be set to in
-// the case of overflow and underflow.  Code that wants to avoid possible
-// breaking changes in this area should not depend on `value` when the returned
-// from_chars_result indicates a range error.)
-//
-// Searches the range [first, last) for the longest matching pattern beginning
-// at `first` that represents a floating point number.  If one is found, store
-// the result in `value`.
-//
-// The matching pattern format is almost the same as that of strtod(), except
-// that (1) C locale is not respected, (2) an initial '+' character in the
-// input range will never be matched, and (3) leading whitespaces are not
-// ignored.
-//
-// If `fmt` is set, it must be one of the enumerator values of the chars_format.
-// (This is despite the fact that chars_format is a bitmask type.)  If set to
-// `scientific`, a matching number must contain an exponent.  If set to `fixed`,
-// then an exponent will never match.  (For example, the string "1e5" will be
-// parsed as "1".)  If set to `hex`, then a hexadecimal float is parsed in the
-// format that strtod() accepts, except that a "0x" prefix is NOT matched.
-// (In particular, in `hex` mode, the input "0xff" results in the largest
-// matching pattern "0".)
-absl::from_chars_result from_chars(absl::Nonnull<const char *> first,
-                                   absl::Nonnull<const char *> last,
-                                   double &value, // NOLINT
-                                   chars_format fmt = chars_format::general);
-
-absl::from_chars_result from_chars(absl::Nonnull<const char *> first,
-                                   absl::Nonnull<const char *> last,
-                                   float &value, // NOLINT
-                                   chars_format fmt = chars_format::general);
-
-// std::chars_format is specified as a bitmask type, which means the following
-// operations must be provided:
-inline constexpr chars_format operator&(chars_format lhs, chars_format rhs) {
-  return static_cast<chars_format>(static_cast<int>(lhs) &
-                                   static_cast<int>(rhs));
-}
-inline constexpr chars_format operator|(chars_format lhs, chars_format rhs) {
-  return static_cast<chars_format>(static_cast<int>(lhs) |
-                                   static_cast<int>(rhs));
-}
-inline constexpr chars_format operator^(chars_format lhs, chars_format rhs) {
-  return static_cast<chars_format>(static_cast<int>(lhs) ^
-                                   static_cast<int>(rhs));
-}
-inline constexpr chars_format operator~(chars_format arg) {
-  return static_cast<chars_format>(~static_cast<int>(arg));
-}
-inline chars_format &operator&=(chars_format &lhs, chars_format rhs) {
-  lhs = lhs & rhs;
-  return lhs;
-}
-inline chars_format &operator|=(chars_format &lhs, chars_format rhs) {
-  lhs = lhs | rhs;
-  return lhs;
-}
-inline chars_format &operator^=(chars_format &lhs, chars_format rhs) {
-  lhs = lhs ^ rhs;
-  return lhs;
-}
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_CHARCONV_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/charset.h b/packages/react-native-executorch/third-party/include/absl/strings/charset.h
deleted file mode 100644
index 6d882dafe4..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/charset.h
+++ /dev/null
@@ -1,164 +0,0 @@
-// Copyright 2022 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: charset.h
-// -----------------------------------------------------------------------------
-//
-// This file contains absl::CharSet, a fast, bit-vector set of 8-bit unsigned
-// characters.
-//
-// Instances can be initialized as constexpr constants. For example:
-//
-//   constexpr absl::CharSet kJustX = absl::CharSet::Char('x');
-//   constexpr absl::CharSet kMySymbols = absl::CharSet("$@!");
-//   constexpr absl::CharSet kLetters = absl::CharSet::Range('a', 'z');
-//
-// Multiple instances can be combined that still forms a constexpr expression.
-// For example:
-//
-//   constexpr absl::CharSet kLettersAndNumbers =
-//       absl::CharSet::Range('a', 'z') | absl::CharSet::Range('0', '9');
-//
-// Several pre-defined character classes are available that mirror the methods
-// from <cctype>. For example:
-//
-//   constexpr absl::CharSet kLettersAndWhitespace =
-//       absl::CharSet::AsciiAlphabet() | absl::CharSet::AsciiWhitespace();
-//
-// To check membership, use the .contains method, e.g.
-//
-//   absl::CharSet hex_letters("abcdef");
-//   hex_letters.contains('a');  // true
-//   hex_letters.contains('g');  // false
-
-#ifndef ABSL_STRINGS_CHARSET_H_
-#define ABSL_STRINGS_CHARSET_H_
-
-#include <cstdint>
-
-#include "absl/base/config.h"
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-class CharSet {
-public:
-  constexpr CharSet() : m_() {}
-
-  // Initializes with a given string_view.
-  constexpr explicit CharSet(absl::string_view str) : m_() {
-    for (char c : str) {
-      SetChar(static_cast<unsigned char>(c));
-    }
-  }
-
-  constexpr bool contains(char c) const {
-    return ((m_[static_cast<unsigned char>(c) / 64] >>
-             (static_cast<unsigned char>(c) % 64)) &
-            0x1) == 0x1;
-  }
-
-  constexpr bool empty() const {
-    for (uint64_t c : m_) {
-      if (c != 0)
-        return false;
-    }
-    return true;
-  }
-
-  // Containing only a single specified char.
-  static constexpr CharSet Char(char x) {
-    return CharSet(CharMaskForWord(x, 0), CharMaskForWord(x, 1),
-                   CharMaskForWord(x, 2), CharMaskForWord(x, 3));
-  }
-
-  // Containing all the chars in the closed interval [lo,hi].
-  static constexpr CharSet Range(char lo, char hi) {
-    return CharSet(RangeForWord(lo, hi, 0), RangeForWord(lo, hi, 1),
-                   RangeForWord(lo, hi, 2), RangeForWord(lo, hi, 3));
-  }
-
-  friend constexpr CharSet operator&(const CharSet &a, const CharSet &b) {
-    return CharSet(a.m_[0] & b.m_[0], a.m_[1] & b.m_[1], a.m_[2] & b.m_[2],
-                   a.m_[3] & b.m_[3]);
-  }
-
-  friend constexpr CharSet operator|(const CharSet &a, const CharSet &b) {
-    return CharSet(a.m_[0] | b.m_[0], a.m_[1] | b.m_[1], a.m_[2] | b.m_[2],
-                   a.m_[3] | b.m_[3]);
-  }
-
-  friend constexpr CharSet operator~(const CharSet &a) {
-    return CharSet(~a.m_[0], ~a.m_[1], ~a.m_[2], ~a.m_[3]);
-  }
-
-  // Mirrors the char-classifying predicates in <cctype>.
-  static constexpr CharSet AsciiUppercase() { return CharSet::Range('A', 'Z'); }
-  static constexpr CharSet AsciiLowercase() { return CharSet::Range('a', 'z'); }
-  static constexpr CharSet AsciiDigits() { return CharSet::Range('0', '9'); }
-  static constexpr CharSet AsciiAlphabet() {
-    return AsciiLowercase() | AsciiUppercase();
-  }
-  static constexpr CharSet AsciiAlphanumerics() {
-    return AsciiDigits() | AsciiAlphabet();
-  }
-  static constexpr CharSet AsciiHexDigits() {
-    return AsciiDigits() | CharSet::Range('A', 'F') | CharSet::Range('a', 'f');
-  }
-  static constexpr CharSet AsciiPrintable() {
-    return CharSet::Range(0x20, 0x7e);
-  }
-  static constexpr CharSet AsciiWhitespace() { return CharSet("\t\n\v\f\r "); }
-  static constexpr CharSet AsciiPunctuation() {
-    return AsciiPrintable() & ~AsciiWhitespace() & ~AsciiAlphanumerics();
-  }
-
-private:
-  constexpr CharSet(uint64_t b0, uint64_t b1, uint64_t b2, uint64_t b3)
-      : m_{b0, b1, b2, b3} {}
-
-  static constexpr uint64_t RangeForWord(char lo, char hi, uint64_t word) {
-    return OpenRangeFromZeroForWord(static_cast<unsigned char>(hi) + 1, word) &
-           ~OpenRangeFromZeroForWord(static_cast<unsigned char>(lo), word);
-  }
-
-  // All the chars in the specified word of the range [0, upper).
-  static constexpr uint64_t OpenRangeFromZeroForWord(uint64_t upper,
-                                                     uint64_t word) {
-    return (upper <= 64 * word) ? 0
-           : (upper >= 64 * (word + 1))
-               ? ~static_cast<uint64_t>(0)
-               : (~static_cast<uint64_t>(0) >> (64 - upper % 64));
-  }
-
-  static constexpr uint64_t CharMaskForWord(char x, uint64_t word) {
-    return (static_cast<unsigned char>(x) / 64 == word)
-               ? (static_cast<uint64_t>(1)
-                  << (static_cast<unsigned char>(x) % 64))
-               : 0;
-  }
-
-  constexpr void SetChar(unsigned char c) {
-    m_[c / 64] |= static_cast<uint64_t>(1) << (c % 64);
-  }
-
-  uint64_t m_[4];
-};
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_CHARSET_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/cord.h b/packages/react-native-executorch/third-party/include/absl/strings/cord.h
deleted file mode 100644
index a466ba7336..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/cord.h
+++ /dev/null
@@ -1,1766 +0,0 @@
-// Copyright 2020 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: cord.h
-// -----------------------------------------------------------------------------
-//
-// This file defines the `absl::Cord` data structure and operations on that data
-// structure. A Cord is a string-like sequence of characters optimized for
-// specific use cases. Unlike a `std::string`, which stores an array of
-// contiguous characters, Cord data is stored in a structure consisting of
-// separate, reference-counted "chunks."
-//
-// Because a Cord consists of these chunks, data can be added to or removed from
-// a Cord during its lifetime. Chunks may also be shared between Cords. Unlike a
-// `std::string`, a Cord can therefore accommodate data that changes over its
-// lifetime, though it's not quite "mutable"; it can change only in the
-// attachment, detachment, or rearrangement of chunks of its constituent data.
-//
-// A Cord provides some benefit over `std::string` under the following (albeit
-// narrow) circumstances:
-//
-//   * Cord data is designed to grow and shrink over a Cord's lifetime. Cord
-//     provides efficient insertions and deletions at the start and end of the
-//     character sequences, avoiding copies in those cases. Static data should
-//     generally be stored as strings.
-//   * External memory consisting of string-like data can be directly added to
-//     a Cord without requiring copies or allocations.
-//   * Cord data may be shared and copied cheaply. Cord provides a copy-on-write
-//     implementation and cheap sub-Cord operations. Copying a Cord is an O(1)
-//     operation.
-//
-// As a consequence to the above, Cord data is generally large. Small data
-// should generally use strings, as construction of a Cord requires some
-// overhead. Small Cords (<= 15 bytes) are represented inline, but most small
-// Cords are expected to grow over their lifetimes.
-//
-// Note that because a Cord is made up of separate chunked data, random access
-// to character data within a Cord is slower than within a `std::string`.
-//
-// Thread Safety
-//
-// Cord has the same thread-safety properties as many other types like
-// std::string, std::vector<>, int, etc -- it is thread-compatible. In
-// particular, if threads do not call non-const methods, then it is safe to call
-// const methods without synchronization. Copying a Cord produces a new instance
-// that can be used concurrently with the original in arbitrary ways.
-
-#ifndef ABSL_STRINGS_CORD_H_
-#define ABSL_STRINGS_CORD_H_
-
-#include <algorithm>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <iosfwd>
-#include <iterator>
-#include <string>
-#include <type_traits>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/base/internal/endian.h"
-#include "absl/base/internal/per_thread_tls.h"
-#include "absl/base/macros.h"
-#include "absl/base/nullability.h"
-#include "absl/base/optimization.h"
-#include "absl/base/port.h"
-#include "absl/container/inlined_vector.h"
-#include "absl/crc/internal/crc_cord_state.h"
-#include "absl/functional/function_ref.h"
-#include "absl/meta/type_traits.h"
-#include "absl/strings/cord_analysis.h"
-#include "absl/strings/cord_buffer.h"
-#include "absl/strings/internal/cord_data_edge.h"
-#include "absl/strings/internal/cord_internal.h"
-#include "absl/strings/internal/cord_rep_btree.h"
-#include "absl/strings/internal/cord_rep_btree_reader.h"
-#include "absl/strings/internal/cord_rep_crc.h"
-#include "absl/strings/internal/cordz_functions.h"
-#include "absl/strings/internal/cordz_info.h"
-#include "absl/strings/internal/cordz_statistics.h"
-#include "absl/strings/internal/cordz_update_scope.h"
-#include "absl/strings/internal/cordz_update_tracker.h"
-#include "absl/strings/internal/resize_uninitialized.h"
-#include "absl/strings/internal/string_constant.h"
-#include "absl/strings/string_view.h"
-#include "absl/types/compare.h"
-#include "absl/types/optional.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-class Cord;
-class CordTestPeer;
-template <typename Releaser>
-Cord MakeCordFromExternal(absl::string_view, Releaser &&);
-void CopyCordToString(const Cord &src, absl::Nonnull<std::string *> dst);
-void AppendCordToString(const Cord &src, absl::Nonnull<std::string *> dst);
-
-// Cord memory accounting modes
-enum class CordMemoryAccounting {
-  // Counts the *approximate* number of bytes held in full or in part by this
-  // Cord (which may not remain the same between invocations). Cords that share
-  // memory could each be "charged" independently for the same shared memory.
-  // See also comment on `kTotalMorePrecise` on internally shared memory.
-  kTotal,
-
-  // Counts the *approximate* number of bytes held in full or in part by this
-  // Cord for the distinct memory held by this cord. This option is similar
-  // to `kTotal`, except that if the cord has multiple references to the same
-  // memory, that memory is only counted once.
-  //
-  // For example:
-  //   absl::Cord cord;
-  //   cord.Append(some_other_cord);
-  //   cord.Append(some_other_cord);
-  //   // Counts `some_other_cord` twice:
-  //   cord.EstimatedMemoryUsage(kTotal);
-  //   // Counts `some_other_cord` once:
-  //   cord.EstimatedMemoryUsage(kTotalMorePrecise);
-  //
-  // The `kTotalMorePrecise` number is more expensive to compute as it requires
-  // deduplicating all memory references. Applications should prefer to use
-  // `kFairShare` or `kTotal` unless they really need a more precise estimate
-  // on "how much memory is potentially held / kept alive by this cord?"
-  kTotalMorePrecise,
-
-  // Counts the *approximate* number of bytes held in full or in part by this
-  // Cord weighted by the sharing ratio of that data. For example, if some data
-  // edge is shared by 4 different Cords, then each cord is attributed 1/4th of
-  // the total memory usage as a 'fair share' of the total memory usage.
-  kFairShare,
-};
-
-// Cord
-//
-// A Cord is a sequence of characters, designed to be more efficient than a
-// `std::string` in certain circumstances: namely, large string data that needs
-// to change over its lifetime or shared, especially when such data is shared
-// across API boundaries.
-//
-// A Cord stores its character data in a structure that allows efficient prepend
-// and append operations. This makes a Cord useful for large string data sent
-// over in a wire format that may need to be prepended or appended at some point
-// during the data exchange (e.g. HTTP, protocol buffers). For example, a
-// Cord is useful for storing an HTTP request, and prepending an HTTP header to
-// such a request.
-//
-// Cords should not be used for storing general string data, however. They
-// require overhead to construct and are slower than strings for random access.
-//
-// The Cord API provides the following common API operations:
-//
-// * Create or assign Cords out of existing string data, memory, or other Cords
-// * Append and prepend data to an existing Cord
-// * Create new Sub-Cords from existing Cord data
-// * Swap Cord data and compare Cord equality
-// * Write out Cord data by constructing a `std::string`
-//
-// Additionally, the API provides iterator utilities to iterate through Cord
-// data via chunks or character bytes.
-//
-class Cord {
-private:
-  template <typename T>
-  using EnableIfString =
-      absl::enable_if_t<std::is_same<T, std::string>::value, int>;
-
-public:
-  // Cord::Cord() Constructors.
-
-  // Creates an empty Cord.
-  constexpr Cord() noexcept;
-
-  // Creates a Cord from an existing Cord. Cord is copyable and efficiently
-  // movable. The moved-from state is valid but unspecified.
-  Cord(const Cord &src);
-  Cord(Cord &&src) noexcept;
-  Cord &operator=(const Cord &x);
-  Cord &operator=(Cord &&x) noexcept;
-
-  // Creates a Cord from a `src` string. This constructor is marked explicit to
-  // prevent implicit Cord constructions from arguments convertible to an
-  // `absl::string_view`.
-  explicit Cord(absl::string_view src);
-  Cord &operator=(absl::string_view src);
-
-  // Creates a Cord from a `std::string&&` rvalue. These constructors are
-  // templated to avoid ambiguities for types that are convertible to both
-  // `absl::string_view` and `std::string`, such as `const char*`.
-  template <typename T, EnableIfString<T> = 0> explicit Cord(T &&src);
-  template <typename T, EnableIfString<T> = 0> Cord &operator=(T &&src);
-
-  // Cord::~Cord()
-  //
-  // Destructs the Cord.
-  ~Cord() {
-    if (contents_.is_tree())
-      DestroyCordSlow();
-  }
-
-  // MakeCordFromExternal()
-  //
-  // Creates a Cord that takes ownership of external string memory. The
-  // contents of `data` are not copied to the Cord; instead, the external
-  // memory is added to the Cord and reference-counted. This data may not be
-  // changed for the life of the Cord, though it may be prepended or appended
-  // to.
-  //
-  // `MakeCordFromExternal()` takes a callable "releaser" that is invoked when
-  // the reference count for `data` reaches zero. As noted above, this data must
-  // remain live until the releaser is invoked. The callable releaser also must:
-  //
-  //   * be move constructible
-  //   * support `void operator()(absl::string_view) const` or `void operator()`
-  //
-  // Example:
-  //
-  // Cord MakeCord(BlockPool* pool) {
-  //   Block* block = pool->NewBlock();
-  //   FillBlock(block);
-  //   return absl::MakeCordFromExternal(
-  //       block->ToStringView(),
-  //       [pool, block](absl::string_view v) {
-  //         pool->FreeBlock(block, v);
-  //       });
-  // }
-  //
-  // WARNING: Because a Cord can be reference-counted, it's likely a bug if your
-  // releaser doesn't do anything. For example, consider the following:
-  //
-  // void Foo(const char* buffer, int len) {
-  //   auto c = absl::MakeCordFromExternal(absl::string_view(buffer, len),
-  //                                       [](absl::string_view) {});
-  //
-  //   // BUG: If Bar() copies its cord for any reason, including keeping a
-  //   // substring of it, the lifetime of buffer might be extended beyond
-  //   // when Foo() returns.
-  //   Bar(c);
-  // }
-  template <typename Releaser>
-  friend Cord MakeCordFromExternal(absl::string_view data, Releaser &&releaser);
-
-  // Cord::Clear()
-  //
-  // Releases the Cord data. Any nodes that share data with other Cords, if
-  // applicable, will have their reference counts reduced by 1.
-  ABSL_ATTRIBUTE_REINITIALIZES void Clear();
-
-  // Cord::Append()
-  //
-  // Appends data to the Cord, which may come from another Cord or other string
-  // data.
-  void Append(const Cord &src);
-  void Append(Cord &&src);
-  void Append(absl::string_view src);
-  template <typename T, EnableIfString<T> = 0> void Append(T &&src);
-
-  // Appends `buffer` to this cord, unless `buffer` has a zero length in which
-  // case this method has no effect on this cord instance.
-  // This method is guaranteed to consume `buffer`.
-  void Append(CordBuffer buffer);
-
-  // Returns a CordBuffer, re-using potential existing capacity in this cord.
-  //
-  // Cord instances may have additional unused capacity in the last (or first)
-  // nodes of the underlying tree to facilitate amortized growth. This method
-  // allows applications to explicitly use this spare capacity if available,
-  // or create a new CordBuffer instance otherwise.
-  // If this cord has a final non-shared node with at least `min_capacity`
-  // available, then this method will return that buffer including its data
-  // contents. I.e.; the returned buffer will have a non-zero length, and
-  // a capacity of at least `buffer.length + min_capacity`. Otherwise, this
-  // method will return `CordBuffer::CreateWithDefaultLimit(capacity)`.
-  //
-  // Below an example of using GetAppendBuffer. Notice that in this example we
-  // use `GetAppendBuffer()` only on the first iteration. As we know nothing
-  // about any initial extra capacity in `cord`, we may be able to use the extra
-  // capacity. But as we add new buffers with fully utilized contents after that
-  // we avoid calling `GetAppendBuffer()` on subsequent iterations: while this
-  // works fine, it results in an unnecessary inspection of cord contents:
-  //
-  //   void AppendRandomDataToCord(absl::Cord &cord, size_t n) {
-  //     bool first = true;
-  //     while (n > 0) {
-  //       CordBuffer buffer = first ? cord.GetAppendBuffer(n)
-  //                                 : CordBuffer::CreateWithDefaultLimit(n);
-  //       absl::Span<char> data = buffer.available_up_to(n);
-  //       FillRandomValues(data.data(), data.size());
-  //       buffer.IncreaseLengthBy(data.size());
-  //       cord.Append(std::move(buffer));
-  //       n -= data.size();
-  //       first = false;
-  //     }
-  //   }
-  CordBuffer GetAppendBuffer(size_t capacity, size_t min_capacity = 16);
-
-  // Returns a CordBuffer, re-using potential existing capacity in this cord.
-  //
-  // This function is identical to `GetAppendBuffer`, except that in the case
-  // where a new `CordBuffer` is allocated, it is allocated using the provided
-  // custom limit instead of the default limit. `GetAppendBuffer` will default
-  // to `CordBuffer::CreateWithDefaultLimit(capacity)` whereas this method
-  // will default to `CordBuffer::CreateWithCustomLimit(block_size, capacity)`.
-  // This method is equivalent to `GetAppendBuffer` if `block_size` is zero.
-  // See the documentation for `CreateWithCustomLimit` for more details on the
-  // restrictions and legal values for `block_size`.
-  CordBuffer GetCustomAppendBuffer(size_t block_size, size_t capacity,
-                                   size_t min_capacity = 16);
-
-  // Cord::Prepend()
-  //
-  // Prepends data to the Cord, which may come from another Cord or other string
-  // data.
-  void Prepend(const Cord &src);
-  void Prepend(absl::string_view src);
-  template <typename T, EnableIfString<T> = 0> void Prepend(T &&src);
-
-  // Prepends `buffer` to this cord, unless `buffer` has a zero length in which
-  // case this method has no effect on this cord instance.
-  // This method is guaranteed to consume `buffer`.
-  void Prepend(CordBuffer buffer);
-
-  // Cord::RemovePrefix()
-  //
-  // Removes the first `n` bytes of a Cord.
-  void RemovePrefix(size_t n);
-  void RemoveSuffix(size_t n);
-
-  // Cord::Subcord()
-  //
-  // Returns a new Cord representing the subrange [pos, pos + new_size) of
-  // *this. If pos >= size(), the result is empty(). If
-  // (pos + new_size) >= size(), the result is the subrange [pos, size()).
-  Cord Subcord(size_t pos, size_t new_size) const;
-
-  // Cord::swap()
-  //
-  // Swaps the contents of the Cord with `other`.
-  void swap(Cord &other) noexcept;
-
-  // swap()
-  //
-  // Swaps the contents of two Cords.
-  friend void swap(Cord &x, Cord &y) noexcept { x.swap(y); }
-
-  // Cord::size()
-  //
-  // Returns the size of the Cord.
-  size_t size() const;
-
-  // Cord::empty()
-  //
-  // Determines whether the given Cord is empty, returning `true` if so.
-  bool empty() const;
-
-  // Cord::EstimatedMemoryUsage()
-  //
-  // Returns the *approximate* number of bytes held by this cord.
-  // See CordMemoryAccounting for more information on the accounting method.
-  size_t EstimatedMemoryUsage(CordMemoryAccounting accounting_method =
-                                  CordMemoryAccounting::kTotal) const;
-
-  // Cord::Compare()
-  //
-  // Compares 'this' Cord with rhs. This function and its relatives treat Cords
-  // as sequences of unsigned bytes. The comparison is a straightforward
-  // lexicographic comparison. `Cord::Compare()` returns values as follows:
-  //
-  //   -1  'this' Cord is smaller
-  //    0  two Cords are equal
-  //    1  'this' Cord is larger
-  int Compare(absl::string_view rhs) const;
-  int Compare(const Cord &rhs) const;
-
-  // Cord::StartsWith()
-  //
-  // Determines whether the Cord starts with the passed string data `rhs`.
-  bool StartsWith(const Cord &rhs) const;
-  bool StartsWith(absl::string_view rhs) const;
-
-  // Cord::EndsWith()
-  //
-  // Determines whether the Cord ends with the passed string data `rhs`.
-  bool EndsWith(absl::string_view rhs) const;
-  bool EndsWith(const Cord &rhs) const;
-
-  // Cord::Contains()
-  //
-  // Determines whether the Cord contains the passed string data `rhs`.
-  bool Contains(absl::string_view rhs) const;
-  bool Contains(const Cord &rhs) const;
-
-  // Cord::operator std::string()
-  //
-  // Converts a Cord into a `std::string()`. This operator is marked explicit to
-  // prevent unintended Cord usage in functions that take a string.
-  explicit operator std::string() const;
-
-  // CopyCordToString()
-  //
-  // Copies the contents of a `src` Cord into a `*dst` string.
-  //
-  // This function optimizes the case of reusing the destination string since it
-  // can reuse previously allocated capacity. However, this function does not
-  // guarantee that pointers previously returned by `dst->data()` remain valid
-  // even if `*dst` had enough capacity to hold `src`. If `*dst` is a new
-  // object, prefer to simply use the conversion operator to `std::string`.
-  friend void CopyCordToString(const Cord &src,
-                               absl::Nonnull<std::string *> dst);
-
-  // AppendCordToString()
-  //
-  // Appends the contents of a `src` Cord to a `*dst` string.
-  //
-  // This function optimizes the case of appending to a non-empty destination
-  // string. If `*dst` already has capacity to store the contents of the cord,
-  // this function does not invalidate pointers previously returned by
-  // `dst->data()`. If `*dst` is a new object, prefer to simply use the
-  // conversion operator to `std::string`.
-  friend void AppendCordToString(const Cord &src,
-                                 absl::Nonnull<std::string *> dst);
-
-  class CharIterator;
-
-  //----------------------------------------------------------------------------
-  // Cord::ChunkIterator
-  //----------------------------------------------------------------------------
-  //
-  // A `Cord::ChunkIterator` allows iteration over the constituent chunks of its
-  // Cord. Such iteration allows you to perform non-const operations on the data
-  // of a Cord without modifying it.
-  //
-  // Generally, you do not instantiate a `Cord::ChunkIterator` directly;
-  // instead, you create one implicitly through use of the `Cord::Chunks()`
-  // member function.
-  //
-  // The `Cord::ChunkIterator` has the following properties:
-  //
-  //   * The iterator is invalidated after any non-const operation on the
-  //     Cord object over which it iterates.
-  //   * The `string_view` returned by dereferencing a valid, non-`end()`
-  //     iterator is guaranteed to be non-empty.
-  //   * Two `ChunkIterator` objects can be compared equal if and only if they
-  //     remain valid and iterate over the same Cord.
-  //   * The iterator in this case is a proxy iterator; the `string_view`
-  //     returned by the iterator does not live inside the Cord, and its
-  //     lifetime is limited to the lifetime of the iterator itself. To help
-  //     prevent lifetime issues, `ChunkIterator::reference` is not a true
-  //     reference type and is equivalent to `value_type`.
-  //   * The iterator keeps state that can grow for Cords that contain many
-  //     nodes and are imbalanced due to sharing. Prefer to pass this type by
-  //     const reference instead of by value.
-  class ChunkIterator {
-  public:
-    using iterator_category = std::input_iterator_tag;
-    using value_type = absl::string_view;
-    using difference_type = ptrdiff_t;
-    using pointer = absl::Nonnull<const value_type *>;
-    using reference = value_type;
-
-    ChunkIterator() = default;
-
-    ChunkIterator &operator++();
-    ChunkIterator operator++(int);
-    bool operator==(const ChunkIterator &other) const;
-    bool operator!=(const ChunkIterator &other) const;
-    reference operator*() const;
-    pointer operator->() const;
-
-    friend class Cord;
-    friend class CharIterator;
-
-  private:
-    using CordRep = absl::cord_internal::CordRep;
-    using CordRepBtree = absl::cord_internal::CordRepBtree;
-    using CordRepBtreeReader = absl::cord_internal::CordRepBtreeReader;
-
-    // Constructs a `begin()` iterator from `tree`.
-    explicit ChunkIterator(absl::Nonnull<cord_internal::CordRep *> tree);
-
-    // Constructs a `begin()` iterator from `cord`.
-    explicit ChunkIterator(absl::Nonnull<const Cord *> cord);
-
-    // Initializes this instance from a tree. Invoked by constructors.
-    void InitTree(absl::Nonnull<cord_internal::CordRep *> tree);
-
-    // Removes `n` bytes from `current_chunk_`. Expects `n` to be smaller than
-    // `current_chunk_.size()`.
-    void RemoveChunkPrefix(size_t n);
-    Cord AdvanceAndReadBytes(size_t n);
-    void AdvanceBytes(size_t n);
-
-    // Btree specific operator++
-    ChunkIterator &AdvanceBtree();
-    void AdvanceBytesBtree(size_t n);
-
-    // A view into bytes of the current `CordRep`. It may only be a view to a
-    // suffix of bytes if this is being used by `CharIterator`.
-    absl::string_view current_chunk_;
-    // The current leaf, or `nullptr` if the iterator points to short data.
-    // If the current chunk is a substring node, current_leaf_ points to the
-    // underlying flat or external node.
-    absl::Nullable<absl::cord_internal::CordRep *> current_leaf_ = nullptr;
-    // The number of bytes left in the `Cord` over which we are iterating.
-    size_t bytes_remaining_ = 0;
-
-    // Cord reader for cord btrees. Empty if not traversing a btree.
-    CordRepBtreeReader btree_reader_;
-  };
-
-  // Cord::chunk_begin()
-  //
-  // Returns an iterator to the first chunk of the `Cord`.
-  //
-  // Generally, prefer using `Cord::Chunks()` within a range-based for loop for
-  // iterating over the chunks of a Cord. This method may be useful for getting
-  // a `ChunkIterator` where range-based for-loops are not useful.
-  //
-  // Example:
-  //
-  //   absl::Cord::ChunkIterator FindAsChunk(const absl::Cord& c,
-  //                                         absl::string_view s) {
-  //     return std::find(c.chunk_begin(), c.chunk_end(), s);
-  //   }
-  ChunkIterator chunk_begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND;
-
-  // Cord::chunk_end()
-  //
-  // Returns an iterator one increment past the last chunk of the `Cord`.
-  //
-  // Generally, prefer using `Cord::Chunks()` within a range-based for loop for
-  // iterating over the chunks of a Cord. This method may be useful for getting
-  // a `ChunkIterator` where range-based for-loops may not be available.
-  ChunkIterator chunk_end() const ABSL_ATTRIBUTE_LIFETIME_BOUND;
-
-  //----------------------------------------------------------------------------
-  // Cord::ChunkRange
-  //----------------------------------------------------------------------------
-  //
-  // `ChunkRange` is a helper class for iterating over the chunks of the `Cord`,
-  // producing an iterator which can be used within a range-based for loop.
-  // Construction of a `ChunkRange` will return an iterator pointing to the
-  // first chunk of the Cord. Generally, do not construct a `ChunkRange`
-  // directly; instead, prefer to use the `Cord::Chunks()` method.
-  //
-  // Implementation note: `ChunkRange` is simply a convenience wrapper over
-  // `Cord::chunk_begin()` and `Cord::chunk_end()`.
-  class ChunkRange {
-  public:
-    // Fulfill minimum c++ container requirements [container.requirements]
-    // These (partial) container type definitions allow ChunkRange to be used
-    // in various utilities expecting a subset of [container.requirements].
-    // For example, the below enables using `::testing::ElementsAre(...)`
-    using value_type = absl::string_view;
-    using reference = value_type &;
-    using const_reference = const value_type &;
-    using iterator = ChunkIterator;
-    using const_iterator = ChunkIterator;
-
-    explicit ChunkRange(absl::Nonnull<const Cord *> cord) : cord_(cord) {}
-
-    ChunkIterator begin() const;
-    ChunkIterator end() const;
-
-  private:
-    absl::Nonnull<const Cord *> cord_;
-  };
-
-  // Cord::Chunks()
-  //
-  // Returns a `Cord::ChunkRange` for iterating over the chunks of a `Cord` with
-  // a range-based for-loop. For most iteration tasks on a Cord, use
-  // `Cord::Chunks()` to retrieve this iterator.
-  //
-  // Example:
-  //
-  //   void ProcessChunks(const Cord& cord) {
-  //     for (absl::string_view chunk : cord.Chunks()) { ... }
-  //   }
-  //
-  // Note that the ordinary caveats of temporary lifetime extension apply:
-  //
-  //   void Process() {
-  //     for (absl::string_view chunk : CordFactory().Chunks()) {
-  //       // The temporary Cord returned by CordFactory has been destroyed!
-  //     }
-  //   }
-  ChunkRange Chunks() const ABSL_ATTRIBUTE_LIFETIME_BOUND;
-
-  //----------------------------------------------------------------------------
-  // Cord::CharIterator
-  //----------------------------------------------------------------------------
-  //
-  // A `Cord::CharIterator` allows iteration over the constituent characters of
-  // a `Cord`.
-  //
-  // Generally, you do not instantiate a `Cord::CharIterator` directly; instead,
-  // you create one implicitly through use of the `Cord::Chars()` member
-  // function.
-  //
-  // A `Cord::CharIterator` has the following properties:
-  //
-  //   * The iterator is invalidated after any non-const operation on the
-  //     Cord object over which it iterates.
-  //   * Two `CharIterator` objects can be compared equal if and only if they
-  //     remain valid and iterate over the same Cord.
-  //   * The iterator keeps state that can grow for Cords that contain many
-  //     nodes and are imbalanced due to sharing. Prefer to pass this type by
-  //     const reference instead of by value.
-  //   * This type cannot act as a forward iterator because a `Cord` can reuse
-  //     sections of memory. This fact violates the requirement for forward
-  //     iterators to compare equal if dereferencing them returns the same
-  //     object.
-  class CharIterator {
-  public:
-    using iterator_category = std::input_iterator_tag;
-    using value_type = char;
-    using difference_type = ptrdiff_t;
-    using pointer = absl::Nonnull<const char *>;
-    using reference = const char &;
-
-    CharIterator() = default;
-
-    CharIterator &operator++();
-    CharIterator operator++(int);
-    bool operator==(const CharIterator &other) const;
-    bool operator!=(const CharIterator &other) const;
-    reference operator*() const;
-
-    friend Cord;
-
-  private:
-    explicit CharIterator(absl::Nonnull<const Cord *> cord)
-        : chunk_iterator_(cord) {}
-
-    ChunkIterator chunk_iterator_;
-  };
-
-  // Cord::AdvanceAndRead()
-  //
-  // Advances the `Cord::CharIterator` by `n_bytes` and returns the bytes
-  // advanced as a separate `Cord`. `n_bytes` must be less than or equal to the
-  // number of bytes within the Cord; otherwise, behavior is undefined. It is
-  // valid to pass `char_end()` and `0`.
-  static Cord AdvanceAndRead(absl::Nonnull<CharIterator *> it, size_t n_bytes);
-
-  // Cord::Advance()
-  //
-  // Advances the `Cord::CharIterator` by `n_bytes`. `n_bytes` must be less than
-  // or equal to the number of bytes remaining within the Cord; otherwise,
-  // behavior is undefined. It is valid to pass `char_end()` and `0`.
-  static void Advance(absl::Nonnull<CharIterator *> it, size_t n_bytes);
-
-  // Cord::ChunkRemaining()
-  //
-  // Returns the longest contiguous view starting at the iterator's position.
-  //
-  // `it` must be dereferenceable.
-  static absl::string_view ChunkRemaining(const CharIterator &it);
-
-  // Cord::char_begin()
-  //
-  // Returns an iterator to the first character of the `Cord`.
-  //
-  // Generally, prefer using `Cord::Chars()` within a range-based for loop for
-  // iterating over the chunks of a Cord. This method may be useful for getting
-  // a `CharIterator` where range-based for-loops may not be available.
-  CharIterator char_begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND;
-
-  // Cord::char_end()
-  //
-  // Returns an iterator to one past the last character of the `Cord`.
-  //
-  // Generally, prefer using `Cord::Chars()` within a range-based for loop for
-  // iterating over the chunks of a Cord. This method may be useful for getting
-  // a `CharIterator` where range-based for-loops are not useful.
-  CharIterator char_end() const ABSL_ATTRIBUTE_LIFETIME_BOUND;
-
-  // Cord::CharRange
-  //
-  // `CharRange` is a helper class for iterating over the characters of a
-  // producing an iterator which can be used within a range-based for loop.
-  // Construction of a `CharRange` will return an iterator pointing to the first
-  // character of the Cord. Generally, do not construct a `CharRange` directly;
-  // instead, prefer to use the `Cord::Chars()` method shown below.
-  //
-  // Implementation note: `CharRange` is simply a convenience wrapper over
-  // `Cord::char_begin()` and `Cord::char_end()`.
-  class CharRange {
-  public:
-    // Fulfill minimum c++ container requirements [container.requirements]
-    // These (partial) container type definitions allow CharRange to be used
-    // in various utilities expecting a subset of [container.requirements].
-    // For example, the below enables using `::testing::ElementsAre(...)`
-    using value_type = char;
-    using reference = value_type &;
-    using const_reference = const value_type &;
-    using iterator = CharIterator;
-    using const_iterator = CharIterator;
-
-    explicit CharRange(absl::Nonnull<const Cord *> cord) : cord_(cord) {}
-
-    CharIterator begin() const;
-    CharIterator end() const;
-
-  private:
-    absl::Nonnull<const Cord *> cord_;
-  };
-
-  // Cord::Chars()
-  //
-  // Returns a `Cord::CharRange` for iterating over the characters of a `Cord`
-  // with a range-based for-loop. For most character-based iteration tasks on a
-  // Cord, use `Cord::Chars()` to retrieve this iterator.
-  //
-  // Example:
-  //
-  //   void ProcessCord(const Cord& cord) {
-  //     for (char c : cord.Chars()) { ... }
-  //   }
-  //
-  // Note that the ordinary caveats of temporary lifetime extension apply:
-  //
-  //   void Process() {
-  //     for (char c : CordFactory().Chars()) {
-  //       // The temporary Cord returned by CordFactory has been destroyed!
-  //     }
-  //   }
-  CharRange Chars() const ABSL_ATTRIBUTE_LIFETIME_BOUND;
-
-  // Cord::operator[]
-  //
-  // Gets the "i"th character of the Cord and returns it, provided that
-  // 0 <= i < Cord.size().
-  //
-  // NOTE: This routine is reasonably efficient. It is roughly
-  // logarithmic based on the number of chunks that make up the cord. Still,
-  // if you need to iterate over the contents of a cord, you should
-  // use a CharIterator/ChunkIterator rather than call operator[] or Get()
-  // repeatedly in a loop.
-  char operator[](size_t i) const;
-
-  // Cord::TryFlat()
-  //
-  // If this cord's representation is a single flat array, returns a
-  // string_view referencing that array.  Otherwise returns nullopt.
-  absl::optional<absl::string_view>
-  TryFlat() const ABSL_ATTRIBUTE_LIFETIME_BOUND;
-
-  // Cord::Flatten()
-  //
-  // Flattens the cord into a single array and returns a view of the data.
-  //
-  // If the cord was already flat, the contents are not modified.
-  absl::string_view Flatten() ABSL_ATTRIBUTE_LIFETIME_BOUND;
-
-  // Cord::Find()
-  //
-  // Returns an iterator to the first occurrence of the substring `needle`.
-  //
-  // If the substring `needle` does not occur, `Cord::char_end()` is returned.
-  CharIterator Find(absl::string_view needle) const;
-  CharIterator Find(const absl::Cord &needle) const;
-
-  // Supports absl::Cord as a sink object for absl::Format().
-  friend void AbslFormatFlush(absl::Nonnull<absl::Cord *> cord,
-                              absl::string_view part) {
-    cord->Append(part);
-  }
-
-  // Support automatic stringification with absl::StrCat and absl::StrFormat.
-  template <typename Sink>
-  friend void AbslStringify(Sink &sink, const absl::Cord &cord) {
-    for (absl::string_view chunk : cord.Chunks()) {
-      sink.Append(chunk);
-    }
-  }
-
-  // Cord::SetExpectedChecksum()
-  //
-  // Stores a checksum value with this non-empty cord instance, for later
-  // retrieval.
-  //
-  // The expected checksum is a number stored out-of-band, alongside the data.
-  // It is preserved across copies and assignments, but any mutations to a cord
-  // will cause it to lose its expected checksum.
-  //
-  // The expected checksum is not part of a Cord's value, and does not affect
-  // operations such as equality or hashing.
-  //
-  // This field is intended to store a CRC32C checksum for later validation, to
-  // help support end-to-end checksum workflows.  However, the Cord API itself
-  // does no CRC validation, and assigns no meaning to this number.
-  //
-  // This call has no effect if this cord is empty.
-  void SetExpectedChecksum(uint32_t crc);
-
-  // Returns this cord's expected checksum, if it has one.  Otherwise, returns
-  // nullopt.
-  absl::optional<uint32_t> ExpectedChecksum() const;
-
-  template <typename H>
-  friend H AbslHashValue(H hash_state, const absl::Cord &c) {
-    absl::optional<absl::string_view> maybe_flat = c.TryFlat();
-    if (maybe_flat.has_value()) {
-      return H::combine(std::move(hash_state), *maybe_flat);
-    }
-    return c.HashFragmented(std::move(hash_state));
-  }
-
-  // Create a Cord with the contents of StringConstant<T>::value.
-  // No allocations will be done and no data will be copied.
-  // This is an INTERNAL API and subject to change or removal. This API can only
-  // be used by spelling absl::strings_internal::MakeStringConstant, which is
-  // also an internal API.
-  template <typename T>
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  constexpr Cord(strings_internal::StringConstant<T>);
-
-private:
-  using CordRep = absl::cord_internal::CordRep;
-  using CordRepFlat = absl::cord_internal::CordRepFlat;
-  using CordzInfo = cord_internal::CordzInfo;
-  using CordzUpdateScope = cord_internal::CordzUpdateScope;
-  using CordzUpdateTracker = cord_internal::CordzUpdateTracker;
-  using InlineData = cord_internal::InlineData;
-  using MethodIdentifier = CordzUpdateTracker::MethodIdentifier;
-
-  // Creates a cord instance with `method` representing the originating
-  // public API call causing the cord to be created.
-  explicit Cord(absl::string_view src, MethodIdentifier method);
-
-  friend class CordTestPeer;
-  friend bool operator==(const Cord &lhs, const Cord &rhs);
-  friend bool operator==(const Cord &lhs, absl::string_view rhs);
-
-#ifdef __cpp_impl_three_way_comparison
-
-  // Cords support comparison with other Cords and string_views via operator<
-  // and others; here we provide a wrapper for the C++20 three-way comparison
-  // <=> operator.
-
-  static inline std::strong_ordering
-  ConvertCompareResultToStrongOrdering(int c) {
-    if (c == 0) {
-      return std::strong_ordering::equal;
-    } else if (c < 0) {
-      return std::strong_ordering::less;
-    } else {
-      return std::strong_ordering::greater;
-    }
-  }
-
-  friend inline std::strong_ordering operator<=>(const Cord &x, const Cord &y) {
-    return ConvertCompareResultToStrongOrdering(x.Compare(y));
-  }
-
-  friend inline std::strong_ordering operator<=>(const Cord &lhs,
-                                                 absl::string_view rhs) {
-    return ConvertCompareResultToStrongOrdering(lhs.Compare(rhs));
-  }
-
-  friend inline std::strong_ordering operator<=>(absl::string_view lhs,
-                                                 const Cord &rhs) {
-    return ConvertCompareResultToStrongOrdering(-rhs.Compare(lhs));
-  }
-#endif
-
-  friend absl::Nullable<const CordzInfo *>
-  GetCordzInfoForTesting(const Cord &cord);
-
-  // Calls the provided function once for each cord chunk, in order.  Unlike
-  // Chunks(), this API will not allocate memory.
-  void ForEachChunk(absl::FunctionRef<void(absl::string_view)>) const;
-
-  // Allocates new contiguous storage for the contents of the cord. This is
-  // called by Flatten() when the cord was not already flat.
-  absl::string_view FlattenSlowPath();
-
-  // Actual cord contents are hidden inside the following simple
-  // class so that we can isolate the bulk of cord.cc from changes
-  // to the representation.
-  //
-  // InlineRep holds either a tree pointer, or an array of kMaxInline bytes.
-  class InlineRep {
-  public:
-    static constexpr unsigned char kMaxInline = cord_internal::kMaxInline;
-    static_assert(kMaxInline >= sizeof(absl::cord_internal::CordRep *), "");
-
-    constexpr InlineRep() : data_() {}
-    explicit InlineRep(InlineData::DefaultInitType init) : data_(init) {}
-    InlineRep(const InlineRep &src);
-    InlineRep(InlineRep &&src);
-    InlineRep &operator=(const InlineRep &src);
-    InlineRep &operator=(InlineRep &&src) noexcept;
-
-    explicit constexpr InlineRep(absl::string_view sv,
-                                 absl::Nullable<CordRep *> rep);
-
-    void Swap(absl::Nonnull<InlineRep *> rhs);
-    size_t size() const;
-    // Returns nullptr if holding pointer
-    absl::Nullable<const char *> data() const;
-    // Discards pointer, if any
-    void set_data(absl::Nonnull<const char *> data, size_t n);
-    absl::Nonnull<char *> set_data(size_t n); // Write data to the result
-    // Returns nullptr if holding bytes
-    absl::Nullable<absl::cord_internal::CordRep *> tree() const;
-    absl::Nonnull<absl::cord_internal::CordRep *> as_tree() const;
-    absl::Nonnull<const char *> as_chars() const;
-    // Returns non-null iff was holding a pointer
-    absl::Nullable<absl::cord_internal::CordRep *> clear();
-    // Converts to pointer if necessary.
-    void reduce_size(size_t n);   // REQUIRES: holding data
-    void remove_prefix(size_t n); // REQUIRES: holding data
-    void AppendArray(absl::string_view src, MethodIdentifier method);
-    absl::string_view FindFlatStartPiece() const;
-
-    // Creates a CordRepFlat instance from the current inlined data with `extra'
-    // bytes of desired additional capacity.
-    absl::Nonnull<CordRepFlat *> MakeFlatWithExtraCapacity(size_t extra);
-
-    // Sets the tree value for this instance. `rep` must not be null.
-    // Requires the current instance to hold a tree, and a lock to be held on
-    // any CordzInfo referenced by this instance. The latter is enforced through
-    // the CordzUpdateScope argument. If the current instance is sampled, then
-    // the CordzInfo instance is updated to reference the new `rep` value.
-    void SetTree(absl::Nonnull<CordRep *> rep, const CordzUpdateScope &scope);
-
-    // Identical to SetTree(), except that `rep` is allowed to be null, in
-    // which case the current instance is reset to an empty value.
-    void SetTreeOrEmpty(absl::Nullable<CordRep *> rep,
-                        const CordzUpdateScope &scope);
-
-    // Sets the tree value for this instance, and randomly samples this cord.
-    // This function disregards existing contents in `data_`, and should be
-    // called when a Cord is 'promoted' from an 'uninitialized' or 'inlined'
-    // value to a non-inlined (tree / ring) value.
-    void EmplaceTree(absl::Nonnull<CordRep *> rep, MethodIdentifier method);
-
-    // Identical to EmplaceTree, except that it copies the parent stack from
-    // the provided `parent` data if the parent is sampled.
-    void EmplaceTree(absl::Nonnull<CordRep *> rep, const InlineData &parent,
-                     MethodIdentifier method);
-
-    // Commits the change of a newly created, or updated `rep` root value into
-    // this cord. `old_rep` indicates the old (inlined or tree) value of the
-    // cord, and determines if the commit invokes SetTree() or EmplaceTree().
-    void CommitTree(absl::Nullable<const CordRep *> old_rep,
-                    absl::Nonnull<CordRep *> rep, const CordzUpdateScope &scope,
-                    MethodIdentifier method);
-
-    void AppendTreeToInlined(absl::Nonnull<CordRep *> tree,
-                             MethodIdentifier method);
-    void AppendTreeToTree(absl::Nonnull<CordRep *> tree,
-                          MethodIdentifier method);
-    void AppendTree(absl::Nonnull<CordRep *> tree, MethodIdentifier method);
-    void PrependTreeToInlined(absl::Nonnull<CordRep *> tree,
-                              MethodIdentifier method);
-    void PrependTreeToTree(absl::Nonnull<CordRep *> tree,
-                           MethodIdentifier method);
-    void PrependTree(absl::Nonnull<CordRep *> tree, MethodIdentifier method);
-
-    bool IsSame(const InlineRep &other) const { return data_ == other.data_; }
-
-    void CopyTo(absl::Nonnull<std::string *> dst) const {
-      // memcpy is much faster when operating on a known size. On most supported
-      // platforms, the small string optimization is large enough that resizing
-      // to 15 bytes does not cause a memory allocation.
-      absl::strings_internal::STLStringResizeUninitialized(dst, kMaxInline);
-      data_.copy_max_inline_to(&(*dst)[0]);
-      // erase is faster than resize because the logic for memory allocation is
-      // not needed.
-      dst->erase(inline_size());
-    }
-
-    // Copies the inline contents into `dst`. Assumes the cord is not empty.
-    void CopyToArray(absl::Nonnull<char *> dst) const;
-
-    bool is_tree() const { return data_.is_tree(); }
-
-    // Returns true if the Cord is being profiled by cordz.
-    bool is_profiled() const { return data_.is_tree() && data_.is_profiled(); }
-
-    // Returns the available inlined capacity, or 0 if is_tree() == true.
-    size_t remaining_inline_capacity() const {
-      return data_.is_tree() ? 0 : kMaxInline - data_.inline_size();
-    }
-
-    // Returns the profiled CordzInfo, or nullptr if not sampled.
-    absl::Nullable<absl::cord_internal::CordzInfo *> cordz_info() const {
-      return data_.cordz_info();
-    }
-
-    // Sets the profiled CordzInfo.
-    void set_cordz_info(absl::Nonnull<cord_internal::CordzInfo *> cordz_info) {
-      assert(cordz_info != nullptr);
-      data_.set_cordz_info(cordz_info);
-    }
-
-    // Resets the current cordz_info to null / empty.
-    void clear_cordz_info() { data_.clear_cordz_info(); }
-
-  private:
-    friend class Cord;
-
-    void AssignSlow(const InlineRep &src);
-    // Unrefs the tree and stops profiling.
-    void UnrefTree();
-
-    void ResetToEmpty() { data_ = {}; }
-
-    void set_inline_size(size_t size) { data_.set_inline_size(size); }
-    size_t inline_size() const { return data_.inline_size(); }
-
-    // Empty cords that carry a checksum have a CordRepCrc node with a null
-    // child node. The code can avoid lots of special cases where it would
-    // otherwise transition from tree to inline storage if we just remove the
-    // CordRepCrc node before mutations. Must never be called inside a
-    // CordzUpdateScope since it untracks the cordz info.
-    void MaybeRemoveEmptyCrcNode();
-
-    cord_internal::InlineData data_;
-  };
-  InlineRep contents_;
-
-  // Helper for GetFlat() and TryFlat().
-  static bool GetFlatAux(absl::Nonnull<absl::cord_internal::CordRep *> rep,
-                         absl::Nonnull<absl::string_view *> fragment);
-
-  // Helper for ForEachChunk().
-  static void
-  ForEachChunkAux(absl::Nonnull<absl::cord_internal::CordRep *> rep,
-                  absl::FunctionRef<void(absl::string_view)> callback);
-
-  // The destructor for non-empty Cords.
-  void DestroyCordSlow();
-
-  // Out-of-line implementation of slower parts of logic.
-  void CopyToArraySlowPath(absl::Nonnull<char *> dst) const;
-  int CompareSlowPath(absl::string_view rhs, size_t compared_size,
-                      size_t size_to_compare) const;
-  int CompareSlowPath(const Cord &rhs, size_t compared_size,
-                      size_t size_to_compare) const;
-  bool EqualsImpl(absl::string_view rhs, size_t size_to_compare) const;
-  bool EqualsImpl(const Cord &rhs, size_t size_to_compare) const;
-  int CompareImpl(const Cord &rhs) const;
-
-  template <typename ResultType, typename RHS>
-  friend ResultType GenericCompare(const Cord &lhs, const RHS &rhs,
-                                   size_t size_to_compare);
-  static absl::string_view GetFirstChunk(const Cord &c);
-  static absl::string_view GetFirstChunk(absl::string_view sv);
-
-  // Returns a new reference to contents_.tree(), or steals an existing
-  // reference if called on an rvalue.
-  absl::Nonnull<absl::cord_internal::CordRep *> TakeRep() const &;
-  absl::Nonnull<absl::cord_internal::CordRep *> TakeRep() &&;
-
-  // Helper for Append().
-  template <typename C> void AppendImpl(C &&src);
-
-  // Appends / Prepends `src` to this instance, using precise sizing.
-  // This method does explicitly not attempt to use any spare capacity
-  // in any pending last added private owned flat.
-  // Requires `src` to be <= kMaxFlatLength.
-  void AppendPrecise(absl::string_view src, MethodIdentifier method);
-  void PrependPrecise(absl::string_view src, MethodIdentifier method);
-
-  CordBuffer GetAppendBufferSlowPath(size_t block_size, size_t capacity,
-                                     size_t min_capacity);
-
-  // Prepends the provided data to this instance. `method` contains the public
-  // API method for this action which is tracked for Cordz sampling purposes.
-  void PrependArray(absl::string_view src, MethodIdentifier method);
-
-  // Assigns the value in 'src' to this instance, 'stealing' its contents.
-  // Requires src.length() > kMaxBytesToCopy.
-  Cord &AssignLargeString(std::string &&src);
-
-  // Helper for AbslHashValue().
-  template <typename H> H HashFragmented(H hash_state) const {
-    typename H::AbslInternalPiecewiseCombiner combiner;
-    ForEachChunk([&combiner, &hash_state](absl::string_view chunk) {
-      hash_state = combiner.add_buffer(std::move(hash_state), chunk.data(),
-                                       chunk.size());
-    });
-    return H::combine(combiner.finalize(std::move(hash_state)), size());
-  }
-
-  friend class CrcCord;
-  void SetCrcCordState(crc_internal::CrcCordState state);
-  absl::Nullable<const crc_internal::CrcCordState *>
-  MaybeGetCrcCordState() const;
-
-  CharIterator FindImpl(CharIterator it, absl::string_view needle) const;
-
-  void CopyToArrayImpl(absl::Nonnull<char *> dst) const;
-};
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// allow a Cord to be logged
-extern std::ostream &operator<<(std::ostream &out, const Cord &cord);
-
-// ------------------------------------------------------------------
-// Internal details follow.  Clients should ignore.
-
-namespace cord_internal {
-
-// Does non-template-specific `CordRepExternal` initialization.
-// Requires `data` to be non-empty.
-void InitializeCordRepExternal(absl::string_view data,
-                               absl::Nonnull<CordRepExternal *> rep);
-
-// Creates a new `CordRep` that owns `data` and `releaser` and returns a pointer
-// to it. Requires `data` to be non-empty.
-template <typename Releaser>
-// NOLINTNEXTLINE - suppress clang-tidy raw pointer return.
-absl::Nonnull<CordRep *> NewExternalRep(absl::string_view data,
-                                        Releaser &&releaser) {
-  assert(!data.empty());
-  using ReleaserType = absl::decay_t<Releaser>;
-  CordRepExternal *rep = new CordRepExternalImpl<ReleaserType>(
-      std::forward<Releaser>(releaser), 0);
-  InitializeCordRepExternal(data, rep);
-  return rep;
-}
-
-// Overload for function reference types that dispatches using a function
-// pointer because there are no `alignof()` or `sizeof()` a function reference.
-// NOLINTNEXTLINE - suppress clang-tidy raw pointer return.
-inline absl::Nonnull<CordRep *>
-NewExternalRep(absl::string_view data, void (&releaser)(absl::string_view)) {
-  return NewExternalRep(data, &releaser);
-}
-
-} // namespace cord_internal
-
-template <typename Releaser>
-Cord MakeCordFromExternal(absl::string_view data, Releaser &&releaser) {
-  Cord cord;
-  if (ABSL_PREDICT_TRUE(!data.empty())) {
-    cord.contents_.EmplaceTree(::absl::cord_internal::NewExternalRep(
-                                   data, std::forward<Releaser>(releaser)),
-                               Cord::MethodIdentifier::kMakeCordFromExternal);
-  } else {
-    using ReleaserType = absl::decay_t<Releaser>;
-    cord_internal::InvokeReleaser(
-        cord_internal::Rank1{}, ReleaserType(std::forward<Releaser>(releaser)),
-        data);
-  }
-  return cord;
-}
-
-constexpr Cord::InlineRep::InlineRep(absl::string_view sv,
-                                     absl::Nullable<CordRep *> rep)
-    : data_(sv, rep) {}
-
-inline Cord::InlineRep::InlineRep(const Cord::InlineRep &src)
-    : data_(InlineData::kDefaultInit) {
-  if (CordRep *tree = src.tree()) {
-    EmplaceTree(CordRep::Ref(tree), src.data_,
-                CordzUpdateTracker::kConstructorCord);
-  } else {
-    data_ = src.data_;
-  }
-}
-
-inline Cord::InlineRep::InlineRep(Cord::InlineRep &&src) : data_(src.data_) {
-  src.ResetToEmpty();
-}
-
-inline Cord::InlineRep &Cord::InlineRep::operator=(const Cord::InlineRep &src) {
-  if (this == &src) {
-    return *this;
-  }
-  if (!is_tree() && !src.is_tree()) {
-    data_ = src.data_;
-    return *this;
-  }
-  AssignSlow(src);
-  return *this;
-}
-
-inline Cord::InlineRep &
-Cord::InlineRep::operator=(Cord::InlineRep &&src) noexcept {
-  if (is_tree()) {
-    UnrefTree();
-  }
-  data_ = src.data_;
-  src.ResetToEmpty();
-  return *this;
-}
-
-inline void Cord::InlineRep::Swap(absl::Nonnull<Cord::InlineRep *> rhs) {
-  if (rhs == this) {
-    return;
-  }
-  using std::swap;
-  swap(data_, rhs->data_);
-}
-
-inline absl::Nullable<const char *> Cord::InlineRep::data() const {
-  return is_tree() ? nullptr : data_.as_chars();
-}
-
-inline absl::Nonnull<const char *> Cord::InlineRep::as_chars() const {
-  assert(!data_.is_tree());
-  return data_.as_chars();
-}
-
-inline absl::Nonnull<absl::cord_internal::CordRep *>
-Cord::InlineRep::as_tree() const {
-  assert(data_.is_tree());
-  return data_.as_tree();
-}
-
-inline absl::Nullable<absl::cord_internal::CordRep *>
-Cord::InlineRep::tree() const {
-  if (is_tree()) {
-    return as_tree();
-  } else {
-    return nullptr;
-  }
-}
-
-inline size_t Cord::InlineRep::size() const {
-  return is_tree() ? as_tree()->length : inline_size();
-}
-
-inline absl::Nonnull<cord_internal::CordRepFlat *>
-Cord::InlineRep::MakeFlatWithExtraCapacity(size_t extra) {
-  static_assert(cord_internal::kMinFlatLength >= sizeof(data_), "");
-  size_t len = data_.inline_size();
-  auto *result = CordRepFlat::New(len + extra);
-  result->length = len;
-  data_.copy_max_inline_to(result->Data());
-  return result;
-}
-
-inline void Cord::InlineRep::EmplaceTree(absl::Nonnull<CordRep *> rep,
-                                         MethodIdentifier method) {
-  assert(rep);
-  data_.make_tree(rep);
-  CordzInfo::MaybeTrackCord(data_, method);
-}
-
-inline void Cord::InlineRep::EmplaceTree(absl::Nonnull<CordRep *> rep,
-                                         const InlineData &parent,
-                                         MethodIdentifier method) {
-  data_.make_tree(rep);
-  CordzInfo::MaybeTrackCord(data_, parent, method);
-}
-
-inline void Cord::InlineRep::SetTree(absl::Nonnull<CordRep *> rep,
-                                     const CordzUpdateScope &scope) {
-  assert(rep);
-  assert(data_.is_tree());
-  data_.set_tree(rep);
-  scope.SetCordRep(rep);
-}
-
-inline void Cord::InlineRep::SetTreeOrEmpty(absl::Nullable<CordRep *> rep,
-                                            const CordzUpdateScope &scope) {
-  assert(data_.is_tree());
-  if (rep) {
-    data_.set_tree(rep);
-  } else {
-    data_ = {};
-  }
-  scope.SetCordRep(rep);
-}
-
-inline void Cord::InlineRep::CommitTree(absl::Nullable<const CordRep *> old_rep,
-                                        absl::Nonnull<CordRep *> rep,
-                                        const CordzUpdateScope &scope,
-                                        MethodIdentifier method) {
-  if (old_rep) {
-    SetTree(rep, scope);
-  } else {
-    EmplaceTree(rep, method);
-  }
-}
-
-inline absl::Nullable<absl::cord_internal::CordRep *> Cord::InlineRep::clear() {
-  if (is_tree()) {
-    CordzInfo::MaybeUntrackCord(cordz_info());
-  }
-  absl::cord_internal::CordRep *result = tree();
-  ResetToEmpty();
-  return result;
-}
-
-inline void Cord::InlineRep::CopyToArray(absl::Nonnull<char *> dst) const {
-  assert(!is_tree());
-  size_t n = inline_size();
-  assert(n != 0);
-  cord_internal::SmallMemmove(dst, data_.as_chars(), n);
-}
-
-inline void Cord::InlineRep::MaybeRemoveEmptyCrcNode() {
-  CordRep *rep = tree();
-  if (rep == nullptr || ABSL_PREDICT_TRUE(rep->length > 0)) {
-    return;
-  }
-  assert(rep->IsCrc());
-  assert(rep->crc()->child == nullptr);
-  CordzInfo::MaybeUntrackCord(cordz_info());
-  CordRep::Unref(rep);
-  ResetToEmpty();
-}
-
-constexpr inline Cord::Cord() noexcept {}
-
-inline Cord::Cord(absl::string_view src)
-    : Cord(src, CordzUpdateTracker::kConstructorString) {}
-
-template <typename T>
-constexpr Cord::Cord(strings_internal::StringConstant<T>)
-    : contents_(strings_internal::StringConstant<T>::value,
-                strings_internal::StringConstant<T>::value.size() <=
-                        cord_internal::kMaxInline
-                    ? nullptr
-                    : &cord_internal::ConstInitExternalStorage<
-                          strings_internal::StringConstant<T>>::value) {}
-
-inline Cord &Cord::operator=(const Cord &x) {
-  contents_ = x.contents_;
-  return *this;
-}
-
-template <typename T, Cord::EnableIfString<T>> Cord &Cord::operator=(T &&src) {
-  if (src.size() <= cord_internal::kMaxBytesToCopy) {
-    return operator=(absl::string_view(src));
-  } else {
-    return AssignLargeString(std::forward<T>(src));
-  }
-}
-
-inline Cord::Cord(const Cord &src) : contents_(src.contents_) {}
-
-inline Cord::Cord(Cord &&src) noexcept : contents_(std::move(src.contents_)) {}
-
-inline void Cord::swap(Cord &other) noexcept {
-  contents_.Swap(&other.contents_);
-}
-
-inline Cord &Cord::operator=(Cord &&x) noexcept {
-  contents_ = std::move(x.contents_);
-  return *this;
-}
-
-extern template Cord::Cord(std::string &&src);
-
-inline size_t Cord::size() const {
-  // Length is 1st field in str.rep_
-  return contents_.size();
-}
-
-inline bool Cord::empty() const { return size() == 0; }
-
-inline size_t
-Cord::EstimatedMemoryUsage(CordMemoryAccounting accounting_method) const {
-  size_t result = sizeof(Cord);
-  if (const absl::cord_internal::CordRep *rep = contents_.tree()) {
-    switch (accounting_method) {
-    case CordMemoryAccounting::kFairShare:
-      result += cord_internal::GetEstimatedFairShareMemoryUsage(rep);
-      break;
-    case CordMemoryAccounting::kTotalMorePrecise:
-      result += cord_internal::GetMorePreciseMemoryUsage(rep);
-      break;
-    case CordMemoryAccounting::kTotal:
-      result += cord_internal::GetEstimatedMemoryUsage(rep);
-      break;
-    }
-  }
-  return result;
-}
-
-inline absl::optional<absl::string_view>
-Cord::TryFlat() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
-  absl::cord_internal::CordRep *rep = contents_.tree();
-  if (rep == nullptr) {
-    return absl::string_view(contents_.data(), contents_.size());
-  }
-  absl::string_view fragment;
-  if (GetFlatAux(rep, &fragment)) {
-    return fragment;
-  }
-  return absl::nullopt;
-}
-
-inline absl::string_view Cord::Flatten() ABSL_ATTRIBUTE_LIFETIME_BOUND {
-  absl::cord_internal::CordRep *rep = contents_.tree();
-  if (rep == nullptr) {
-    return absl::string_view(contents_.data(), contents_.size());
-  } else {
-    absl::string_view already_flat_contents;
-    if (GetFlatAux(rep, &already_flat_contents)) {
-      return already_flat_contents;
-    }
-  }
-  return FlattenSlowPath();
-}
-
-inline void Cord::Append(absl::string_view src) {
-  contents_.AppendArray(src, CordzUpdateTracker::kAppendString);
-}
-
-inline void Cord::Prepend(absl::string_view src) {
-  PrependArray(src, CordzUpdateTracker::kPrependString);
-}
-
-inline void Cord::Append(CordBuffer buffer) {
-  if (ABSL_PREDICT_FALSE(buffer.length() == 0))
-    return;
-  contents_.MaybeRemoveEmptyCrcNode();
-  absl::string_view short_value;
-  if (CordRep *rep = buffer.ConsumeValue(short_value)) {
-    contents_.AppendTree(rep, CordzUpdateTracker::kAppendCordBuffer);
-  } else {
-    AppendPrecise(short_value, CordzUpdateTracker::kAppendCordBuffer);
-  }
-}
-
-inline void Cord::Prepend(CordBuffer buffer) {
-  if (ABSL_PREDICT_FALSE(buffer.length() == 0))
-    return;
-  contents_.MaybeRemoveEmptyCrcNode();
-  absl::string_view short_value;
-  if (CordRep *rep = buffer.ConsumeValue(short_value)) {
-    contents_.PrependTree(rep, CordzUpdateTracker::kPrependCordBuffer);
-  } else {
-    PrependPrecise(short_value, CordzUpdateTracker::kPrependCordBuffer);
-  }
-}
-
-inline CordBuffer Cord::GetAppendBuffer(size_t capacity, size_t min_capacity) {
-  if (empty())
-    return CordBuffer::CreateWithDefaultLimit(capacity);
-  return GetAppendBufferSlowPath(0, capacity, min_capacity);
-}
-
-inline CordBuffer Cord::GetCustomAppendBuffer(size_t block_size,
-                                              size_t capacity,
-                                              size_t min_capacity) {
-  if (empty()) {
-    return block_size ? CordBuffer::CreateWithCustomLimit(block_size, capacity)
-                      : CordBuffer::CreateWithDefaultLimit(capacity);
-  }
-  return GetAppendBufferSlowPath(block_size, capacity, min_capacity);
-}
-
-extern template void Cord::Append(std::string &&src);
-extern template void Cord::Prepend(std::string &&src);
-
-inline int Cord::Compare(const Cord &rhs) const {
-  if (!contents_.is_tree() && !rhs.contents_.is_tree()) {
-    return contents_.data_.Compare(rhs.contents_.data_);
-  }
-
-  return CompareImpl(rhs);
-}
-
-// Does 'this' cord start/end with rhs
-inline bool Cord::StartsWith(const Cord &rhs) const {
-  if (contents_.IsSame(rhs.contents_))
-    return true;
-  size_t rhs_size = rhs.size();
-  if (size() < rhs_size)
-    return false;
-  return EqualsImpl(rhs, rhs_size);
-}
-
-inline bool Cord::StartsWith(absl::string_view rhs) const {
-  size_t rhs_size = rhs.size();
-  if (size() < rhs_size)
-    return false;
-  return EqualsImpl(rhs, rhs_size);
-}
-
-inline void Cord::CopyToArrayImpl(absl::Nonnull<char *> dst) const {
-  if (!contents_.is_tree()) {
-    if (!empty())
-      contents_.CopyToArray(dst);
-  } else {
-    CopyToArraySlowPath(dst);
-  }
-}
-
-inline void
-Cord::ChunkIterator::InitTree(absl::Nonnull<cord_internal::CordRep *> tree) {
-  tree = cord_internal::SkipCrcNode(tree);
-  if (tree->tag == cord_internal::BTREE) {
-    current_chunk_ = btree_reader_.Init(tree->btree());
-  } else {
-    current_leaf_ = tree;
-    current_chunk_ = cord_internal::EdgeData(tree);
-  }
-}
-
-inline Cord::ChunkIterator::ChunkIterator(
-    absl::Nonnull<cord_internal::CordRep *> tree) {
-  bytes_remaining_ = tree->length;
-  InitTree(tree);
-}
-
-inline Cord::ChunkIterator::ChunkIterator(absl::Nonnull<const Cord *> cord) {
-  if (CordRep *tree = cord->contents_.tree()) {
-    bytes_remaining_ = tree->length;
-    if (ABSL_PREDICT_TRUE(bytes_remaining_ != 0)) {
-      InitTree(tree);
-    } else {
-      current_chunk_ = {};
-    }
-  } else {
-    bytes_remaining_ = cord->contents_.inline_size();
-    current_chunk_ = {cord->contents_.data(), bytes_remaining_};
-  }
-}
-
-inline Cord::ChunkIterator &Cord::ChunkIterator::AdvanceBtree() {
-  current_chunk_ = btree_reader_.Next();
-  return *this;
-}
-
-inline void Cord::ChunkIterator::AdvanceBytesBtree(size_t n) {
-  assert(n >= current_chunk_.size());
-  bytes_remaining_ -= n;
-  if (bytes_remaining_) {
-    if (n == current_chunk_.size()) {
-      current_chunk_ = btree_reader_.Next();
-    } else {
-      size_t offset = btree_reader_.length() - bytes_remaining_;
-      current_chunk_ = btree_reader_.Seek(offset);
-    }
-  } else {
-    current_chunk_ = {};
-  }
-}
-
-inline Cord::ChunkIterator &Cord::ChunkIterator::operator++() {
-  ABSL_HARDENING_ASSERT(bytes_remaining_ > 0 &&
-                        "Attempted to iterate past `end()`");
-  assert(bytes_remaining_ >= current_chunk_.size());
-  bytes_remaining_ -= current_chunk_.size();
-  if (bytes_remaining_ > 0) {
-    if (btree_reader_) {
-      return AdvanceBtree();
-    } else {
-      assert(!current_chunk_.empty()); // Called on invalid iterator.
-    }
-    current_chunk_ = {};
-  }
-  return *this;
-}
-
-inline Cord::ChunkIterator Cord::ChunkIterator::operator++(int) {
-  ChunkIterator tmp(*this);
-  operator++();
-  return tmp;
-}
-
-inline bool Cord::ChunkIterator::operator==(const ChunkIterator &other) const {
-  return bytes_remaining_ == other.bytes_remaining_;
-}
-
-inline bool Cord::ChunkIterator::operator!=(const ChunkIterator &other) const {
-  return !(*this == other);
-}
-
-inline Cord::ChunkIterator::reference Cord::ChunkIterator::operator*() const {
-  ABSL_HARDENING_ASSERT(bytes_remaining_ != 0);
-  return current_chunk_;
-}
-
-inline Cord::ChunkIterator::pointer Cord::ChunkIterator::operator->() const {
-  ABSL_HARDENING_ASSERT(bytes_remaining_ != 0);
-  return &current_chunk_;
-}
-
-inline void Cord::ChunkIterator::RemoveChunkPrefix(size_t n) {
-  assert(n < current_chunk_.size());
-  current_chunk_.remove_prefix(n);
-  bytes_remaining_ -= n;
-}
-
-inline void Cord::ChunkIterator::AdvanceBytes(size_t n) {
-  assert(bytes_remaining_ >= n);
-  if (ABSL_PREDICT_TRUE(n < current_chunk_.size())) {
-    RemoveChunkPrefix(n);
-  } else if (n != 0) {
-    if (btree_reader_) {
-      AdvanceBytesBtree(n);
-    } else {
-      bytes_remaining_ = 0;
-    }
-  }
-}
-
-inline Cord::ChunkIterator Cord::chunk_begin() const {
-  return ChunkIterator(this);
-}
-
-inline Cord::ChunkIterator Cord::chunk_end() const { return ChunkIterator(); }
-
-inline Cord::ChunkIterator Cord::ChunkRange::begin() const {
-  return cord_->chunk_begin();
-}
-
-inline Cord::ChunkIterator Cord::ChunkRange::end() const {
-  return cord_->chunk_end();
-}
-
-inline Cord::ChunkRange Cord::Chunks() const { return ChunkRange(this); }
-
-inline Cord::CharIterator &Cord::CharIterator::operator++() {
-  if (ABSL_PREDICT_TRUE(chunk_iterator_->size() > 1)) {
-    chunk_iterator_.RemoveChunkPrefix(1);
-  } else {
-    ++chunk_iterator_;
-  }
-  return *this;
-}
-
-inline Cord::CharIterator Cord::CharIterator::operator++(int) {
-  CharIterator tmp(*this);
-  operator++();
-  return tmp;
-}
-
-inline bool Cord::CharIterator::operator==(const CharIterator &other) const {
-  return chunk_iterator_ == other.chunk_iterator_;
-}
-
-inline bool Cord::CharIterator::operator!=(const CharIterator &other) const {
-  return !(*this == other);
-}
-
-inline Cord::CharIterator::reference Cord::CharIterator::operator*() const {
-  return *chunk_iterator_->data();
-}
-
-inline Cord Cord::AdvanceAndRead(absl::Nonnull<CharIterator *> it,
-                                 size_t n_bytes) {
-  assert(it != nullptr);
-  return it->chunk_iterator_.AdvanceAndReadBytes(n_bytes);
-}
-
-inline void Cord::Advance(absl::Nonnull<CharIterator *> it, size_t n_bytes) {
-  assert(it != nullptr);
-  it->chunk_iterator_.AdvanceBytes(n_bytes);
-}
-
-inline absl::string_view Cord::ChunkRemaining(const CharIterator &it) {
-  return *it.chunk_iterator_;
-}
-
-inline Cord::CharIterator Cord::char_begin() const {
-  return CharIterator(this);
-}
-
-inline Cord::CharIterator Cord::char_end() const { return CharIterator(); }
-
-inline Cord::CharIterator Cord::CharRange::begin() const {
-  return cord_->char_begin();
-}
-
-inline Cord::CharIterator Cord::CharRange::end() const {
-  return cord_->char_end();
-}
-
-inline Cord::CharRange Cord::Chars() const { return CharRange(this); }
-
-inline void
-Cord::ForEachChunk(absl::FunctionRef<void(absl::string_view)> callback) const {
-  absl::cord_internal::CordRep *rep = contents_.tree();
-  if (rep == nullptr) {
-    callback(absl::string_view(contents_.data(), contents_.size()));
-  } else {
-    ForEachChunkAux(rep, callback);
-  }
-}
-
-// Nonmember Cord-to-Cord relational operators.
-inline bool operator==(const Cord &lhs, const Cord &rhs) {
-  if (lhs.contents_.IsSame(rhs.contents_))
-    return true;
-  size_t rhs_size = rhs.size();
-  if (lhs.size() != rhs_size)
-    return false;
-  return lhs.EqualsImpl(rhs, rhs_size);
-}
-
-inline bool operator!=(const Cord &x, const Cord &y) { return !(x == y); }
-inline bool operator<(const Cord &x, const Cord &y) { return x.Compare(y) < 0; }
-inline bool operator>(const Cord &x, const Cord &y) { return x.Compare(y) > 0; }
-inline bool operator<=(const Cord &x, const Cord &y) {
-  return x.Compare(y) <= 0;
-}
-inline bool operator>=(const Cord &x, const Cord &y) {
-  return x.Compare(y) >= 0;
-}
-
-// Nonmember Cord-to-absl::string_view relational operators.
-//
-// Due to implicit conversions, these also enable comparisons of Cord with
-// std::string and const char*.
-inline bool operator==(const Cord &lhs, absl::string_view rhs) {
-  size_t lhs_size = lhs.size();
-  size_t rhs_size = rhs.size();
-  if (lhs_size != rhs_size)
-    return false;
-  return lhs.EqualsImpl(rhs, rhs_size);
-}
-
-inline bool operator==(absl::string_view x, const Cord &y) { return y == x; }
-inline bool operator!=(const Cord &x, absl::string_view y) { return !(x == y); }
-inline bool operator!=(absl::string_view x, const Cord &y) { return !(x == y); }
-inline bool operator<(const Cord &x, absl::string_view y) {
-  return x.Compare(y) < 0;
-}
-inline bool operator<(absl::string_view x, const Cord &y) {
-  return y.Compare(x) > 0;
-}
-inline bool operator>(const Cord &x, absl::string_view y) { return y < x; }
-inline bool operator>(absl::string_view x, const Cord &y) { return y < x; }
-inline bool operator<=(const Cord &x, absl::string_view y) { return !(y < x); }
-inline bool operator<=(absl::string_view x, const Cord &y) { return !(y < x); }
-inline bool operator>=(const Cord &x, absl::string_view y) { return !(x < y); }
-inline bool operator>=(absl::string_view x, const Cord &y) { return !(x < y); }
-
-// Some internals exposed to test code.
-namespace strings_internal {
-class CordTestAccess {
-public:
-  static size_t FlatOverhead();
-  static size_t MaxFlatLength();
-  static size_t SizeofCordRepExternal();
-  static size_t SizeofCordRepSubstring();
-  static size_t FlatTagToLength(uint8_t tag);
-  static uint8_t LengthToTag(size_t s);
-};
-} // namespace strings_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_CORD_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/cord_analysis.h b/packages/react-native-executorch/third-party/include/absl/strings/cord_analysis.h
deleted file mode 100644
index 456dc09c25..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/cord_analysis.h
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright 2021 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_CORD_ANALYSIS_H_
-#define ABSL_STRINGS_CORD_ANALYSIS_H_
-
-#include <cstddef>
-#include <cstdint>
-
-#include "absl/base/config.h"
-#include "absl/base/nullability.h"
-#include "absl/strings/internal/cord_internal.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// Returns the *approximate* number of bytes held in full or in part by this
-// Cord (which may not remain the same between invocations). Cords that share
-// memory could each be "charged" independently for the same shared memory.
-size_t GetEstimatedMemoryUsage(absl::Nonnull<const CordRep *> rep);
-
-// Returns the *approximate* number of bytes held in full or in part by this
-// Cord for the distinct memory held by this cord. This is similar to
-// `GetEstimatedMemoryUsage()`, except that if the cord has multiple references
-// to the same memory, that memory is only counted once.
-//
-// For example:
-//   absl::Cord cord;
-//   cord.append(some_other_cord);
-//   cord.append(some_other_cord);
-//    // Calls GetEstimatedMemoryUsage() and counts `other_cord` twice:
-//   cord.EstimatedMemoryUsage(kTotal);
-//    // Calls GetMorePreciseMemoryUsage() and counts `other_cord` once:
-//   cord.EstimatedMemoryUsage(kTotalMorePrecise);
-//
-// This is more expensive than `GetEstimatedMemoryUsage()` as it requires
-// deduplicating all memory references.
-size_t GetMorePreciseMemoryUsage(absl::Nonnull<const CordRep *> rep);
-
-// Returns the *approximate* number of bytes held in full or in part by this
-// CordRep weighted by the sharing ratio of that data. For example, if some data
-// edge is shared by 4 different Cords, then each cord is attribute 1/4th of
-// the total memory usage as a 'fair share' of the total memory usage.
-size_t GetEstimatedFairShareMemoryUsage(absl::Nonnull<const CordRep *> rep);
-
-} // namespace cord_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_CORD_ANALYSIS_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/cord_buffer.h b/packages/react-native-executorch/third-party/include/absl/strings/cord_buffer.h
deleted file mode 100644
index 6848a40f5d..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/cord_buffer.h
+++ /dev/null
@@ -1,574 +0,0 @@
-// Copyright 2021 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: cord_buffer.h
-// -----------------------------------------------------------------------------
-//
-// This file defines an `absl::CordBuffer` data structure to hold data for
-// eventual inclusion within an existing `Cord` data structure. Cord buffers are
-// useful for building large Cords that may require custom allocation of its
-// associated memory.
-//
-#ifndef ABSL_STRINGS_CORD_BUFFER_H_
-#define ABSL_STRINGS_CORD_BUFFER_H_
-
-#include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <memory>
-#include <utility>
-
-#include "absl/base/config.h"
-#include "absl/base/macros.h"
-#include "absl/numeric/bits.h"
-#include "absl/strings/internal/cord_internal.h"
-#include "absl/strings/internal/cord_rep_flat.h"
-#include "absl/types/span.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-class Cord;
-class CordBufferTestPeer;
-
-// CordBuffer
-//
-// CordBuffer manages memory buffers for purposes such as zero-copy APIs as well
-// as applications building cords with large data requiring granular control
-// over the allocation and size of cord data. For example, a function creating
-// a cord of random data could use a CordBuffer as follows:
-//
-//   absl::Cord CreateRandomCord(size_t length) {
-//     absl::Cord cord;
-//     while (length > 0) {
-//       CordBuffer buffer = CordBuffer::CreateWithDefaultLimit(length);
-//       absl::Span<char> data = buffer.available_up_to(length);
-//       FillRandomValues(data.data(), data.size());
-//       buffer.IncreaseLengthBy(data.size());
-//       cord.Append(std::move(buffer));
-//       length -= data.size();
-//     }
-//     return cord;
-//   }
-//
-// CordBuffer instances are by default limited to a capacity of `kDefaultLimit`
-// bytes. `kDefaultLimit` is currently just under 4KiB, but this default may
-// change in the future and/or for specific architectures. The default limit is
-// aimed to provide a good trade-off between performance and memory overhead.
-// Smaller buffers typically incur more compute cost while larger buffers are
-// more CPU efficient but create significant memory overhead because of such
-// allocations being less granular. Using larger buffers may also increase the
-// risk of memory fragmentation.
-//
-// Applications create a buffer using one of the `CreateWithDefaultLimit()` or
-// `CreateWithCustomLimit()` methods. The returned instance will have a non-zero
-// capacity and a zero length. Applications use the `data()` method to set the
-// contents of the managed memory, and once done filling the buffer, use the
-// `IncreaseLengthBy()` or 'SetLength()' method to specify the length of the
-// initialized data before adding the buffer to a Cord.
-//
-// The `CreateWithCustomLimit()` method is intended for applications needing
-// larger buffers than the default memory limit, allowing the allocation of up
-// to a capacity of `kCustomLimit` bytes minus some minimum internal overhead.
-// The usage of `CreateWithCustomLimit()` should be limited to only those use
-// cases where the distribution of the input is relatively well known, and/or
-// where the trade-off between the efficiency gains outweigh the risk of memory
-// fragmentation. See the documentation for `CreateWithCustomLimit()` for more
-// information on using larger custom limits.
-//
-// The capacity of a `CordBuffer` returned by one of the `Create` methods may
-// be larger than the requested capacity due to rounding, alignment and
-// granularity of the memory allocator. Applications should use the `capacity`
-// method to obtain the effective capacity of the returned instance as
-// demonstrated in the provided example above.
-//
-// CordBuffer is a move-only class. All references into the managed memory are
-// invalidated when an instance is moved into either another CordBuffer instance
-// or a Cord. Writing to a location obtained by a previous call to `data()`
-// after an instance was moved will lead to undefined behavior.
-//
-// A `moved from` CordBuffer instance will have a valid, but empty state.
-// CordBuffer is thread compatible.
-class CordBuffer {
-public:
-  // kDefaultLimit
-  //
-  // Default capacity limits of allocated CordBuffers.
-  // See the class comments for more information on allocation limits.
-  static constexpr size_t kDefaultLimit = cord_internal::kMaxFlatLength;
-
-  // kCustomLimit
-  //
-  // Maximum size for CreateWithCustomLimit() allocated buffers.
-  // Note that the effective capacity may be slightly less
-  // because of internal overhead of internal cord buffers.
-  static constexpr size_t kCustomLimit = 64U << 10;
-
-  // Constructors, Destructors and Assignment Operators
-
-  // Creates an empty CordBuffer.
-  CordBuffer() = default;
-
-  // Destroys this CordBuffer instance and, if not empty, releases any memory
-  // managed by this instance, invalidating previously returned references.
-  ~CordBuffer();
-
-  // CordBuffer is move-only
-  CordBuffer(CordBuffer &&rhs) noexcept;
-  CordBuffer &operator=(CordBuffer &&) noexcept;
-  CordBuffer(const CordBuffer &) = delete;
-  CordBuffer &operator=(const CordBuffer &) = delete;
-
-  // CordBuffer::MaximumPayload()
-  //
-  // Returns the guaranteed maximum payload for a CordBuffer returned by the
-  // `CreateWithDefaultLimit()` method. While small, each internal buffer inside
-  // a Cord incurs an overhead to manage the length, type and reference count
-  // for the buffer managed inside the cord tree. Applications can use this
-  // method to get approximate number of buffers required for a given byte
-  // size, etc.
-  //
-  // For example:
-  //   const size_t payload = absl::CordBuffer::MaximumPayload();
-  //   const size_t buffer_count = (total_size + payload - 1) / payload;
-  //   buffers.reserve(buffer_count);
-  static constexpr size_t MaximumPayload();
-
-  // Overload to the above `MaximumPayload()` except that it returns the
-  // maximum payload for a CordBuffer returned by the `CreateWithCustomLimit()`
-  // method given the provided `block_size`.
-  static constexpr size_t MaximumPayload(size_t block_size);
-
-  // CordBuffer::CreateWithDefaultLimit()
-  //
-  // Creates a CordBuffer instance of the desired `capacity`, capped at the
-  // default limit `kDefaultLimit`. The returned buffer has a guaranteed
-  // capacity of at least `min(kDefaultLimit, capacity)`. See the class comments
-  // for more information on buffer capacities and intended usage.
-  static CordBuffer CreateWithDefaultLimit(size_t capacity);
-
-  // CordBuffer::CreateWithCustomLimit()
-  //
-  // Creates a CordBuffer instance of the desired `capacity` rounded to an
-  // appropriate power of 2 size less than, or equal to `block_size`.
-  // Requires `block_size` to be a power of 2.
-  //
-  // If `capacity` is less than or equal to `kDefaultLimit`, then this method
-  // behaves identical to `CreateWithDefaultLimit`, which means that the caller
-  // is guaranteed to get a buffer of at least the requested capacity.
-  //
-  // If `capacity` is greater than or equal to `block_size`, then this method
-  // returns a buffer with an `allocated size` of `block_size` bytes. Otherwise,
-  // this methods returns a buffer with a suitable smaller power of 2 block size
-  // to satisfy the request. The actual size depends on a number of factors, and
-  // is typically (but not necessarily) the highest or second highest power of 2
-  // value less than or equal to `capacity`.
-  //
-  // The 'allocated size' includes a small amount of overhead required for
-  // internal state, which is currently 13 bytes on 64-bit platforms. For
-  // example: a buffer created with `block_size` and `capacity' set to 8KiB
-  // will have an allocated size of 8KiB, and an effective internal `capacity`
-  // of 8KiB - 13 = 8179 bytes.
-  //
-  // To demonstrate this in practice, let's assume we want to read data from
-  // somewhat larger files using approximately 64KiB buffers:
-  //
-  //   absl::Cord ReadFromFile(int fd, size_t n) {
-  //     absl::Cord cord;
-  //     while (n > 0) {
-  //       CordBuffer buffer = CordBuffer::CreateWithCustomLimit(64 << 10, n);
-  //       absl::Span<char> data = buffer.available_up_to(n);
-  //       ReadFileDataOrDie(fd, data.data(), data.size());
-  //       buffer.IncreaseLengthBy(data.size());
-  //       cord.Append(std::move(buffer));
-  //       n -= data.size();
-  //     }
-  //     return cord;
-  //   }
-  //
-  // If we'd use this function to read a file of 659KiB, we may get the
-  // following pattern of allocated cord buffer sizes:
-  //
-  //   CreateWithCustomLimit(64KiB, 674816) --> ~64KiB (65523)
-  //   CreateWithCustomLimit(64KiB, 674816) --> ~64KiB (65523)
-  //   ...
-  //   CreateWithCustomLimit(64KiB,  19586) --> ~16KiB (16371)
-  //   CreateWithCustomLimit(64KiB,   3215) -->   3215 (at least 3215)
-  //
-  // The reason the method returns a 16K buffer instead of a roughly 19K buffer
-  // is to reduce memory overhead and fragmentation risks. Using carefully
-  // chosen power of 2 values reduces the entropy of allocated memory sizes.
-  //
-  // Additionally, let's assume we'd use the above function on files that are
-  // generally smaller than 64K. If we'd use 'precise' sized buffers for such
-  // files, than we'd get a very wide distribution of allocated memory sizes
-  // rounded to 4K page sizes, and we'd end up with a lot of unused capacity.
-  //
-  // In general, application should only use custom sizes if the data they are
-  // consuming or storing is expected to be many times the chosen block size,
-  // and be based on objective data and performance metrics. For example, a
-  // compress function may work faster and consume less CPU when using larger
-  // buffers. Such an application should pick a size offering a reasonable
-  // trade-off between expected data size, compute savings with larger buffers,
-  // and the cost or fragmentation effect of larger buffers.
-  // Applications must pick a reasonable spot on that curve, and make sure their
-  // data meets their expectations in size distributions such as "mostly large".
-  static CordBuffer CreateWithCustomLimit(size_t block_size, size_t capacity);
-
-  // CordBuffer::available()
-  //
-  // Returns the span delineating the available capacity in this buffer
-  // which is defined as `{ data() + length(), capacity() - length() }`.
-  absl::Span<char> available();
-
-  // CordBuffer::available_up_to()
-  //
-  // Returns the span delineating the available capacity in this buffer limited
-  // to `size` bytes. This is equivalent to `available().subspan(0, size)`.
-  absl::Span<char> available_up_to(size_t size);
-
-  // CordBuffer::data()
-  //
-  // Returns a non-null reference to the data managed by this instance.
-  // Applications are allowed to write up to `capacity` bytes of instance data.
-  // CordBuffer data is uninitialized by default. Reading data from an instance
-  // that has not yet been initialized will lead to undefined behavior.
-  char *data();
-  const char *data() const;
-
-  // CordBuffer::length()
-  //
-  // Returns the length of this instance. The default length of a CordBuffer is
-  // 0, indicating an 'empty' CordBuffer. Applications must specify the length
-  // of the data in a CordBuffer before adding it to a Cord.
-  size_t length() const;
-
-  // CordBuffer::capacity()
-  //
-  // Returns the capacity of this instance. All instances have a non-zero
-  // capacity: default and `moved from` instances have a small internal buffer.
-  size_t capacity() const;
-
-  // CordBuffer::IncreaseLengthBy()
-  //
-  // Increases the length of this buffer by the specified 'n' bytes.
-  // Applications must make sure all data in this buffer up to the new length
-  // has been initialized before adding a CordBuffer to a Cord: failure to do so
-  // will lead to undefined behavior.  Requires `length() + n <= capacity()`.
-  // Typically, applications will use 'available_up_to()` to get a span of the
-  // desired capacity, and use `span.size()` to increase the length as in:
-  //   absl::Span<char> span = buffer.available_up_to(desired);
-  //   buffer.IncreaseLengthBy(span.size());
-  //   memcpy(span.data(), src, span.size());
-  //   etc...
-  void IncreaseLengthBy(size_t n);
-
-  // CordBuffer::SetLength()
-  //
-  // Sets the data length of this instance. Applications must make sure all data
-  // of the specified length has been initialized before adding a CordBuffer to
-  // a Cord: failure to do so will lead to undefined behavior.
-  // Setting the length to a small value or zero does not release any memory
-  // held by this CordBuffer instance. Requires `length <= capacity()`.
-  // Applications should preferably use the `IncreaseLengthBy()` method above
-  // in combination with the 'available()` or `available_up_to()` methods.
-  void SetLength(size_t length);
-
-private:
-  // Make sure we don't accidentally over promise.
-  static_assert(kCustomLimit <= cord_internal::kMaxLargeFlatSize, "");
-
-  // Assume the cost of an 'uprounded' allocation to CeilPow2(size) versus
-  // the cost of allocating at least 1 extra flat <= 4KB:
-  // - Flat overhead = 13 bytes
-  // - Btree amortized cost / node =~ 13 bytes
-  // - 64 byte granularity of tcmalloc at 4K =~ 32 byte average
-  // CPU cost and efficiency requires we should at least 'save' something by
-  // splitting, as a poor man's measure, we say the slop needs to be
-  // at least double the cost offset to make it worth splitting: ~128 bytes.
-  static constexpr size_t kMaxPageSlop = 128;
-
-  // Overhead for allocation a flat.
-  static constexpr size_t kOverhead = cord_internal::kFlatOverhead;
-
-  using CordRepFlat = cord_internal::CordRepFlat;
-
-  // `Rep` is the internal data representation of a CordBuffer. The internal
-  // representation has an internal small size optimization similar to
-  // std::string (SSO).
-  struct Rep {
-    // Inline SSO size of a CordBuffer
-    static constexpr size_t kInlineCapacity = sizeof(intptr_t) * 2 - 1;
-
-    // Creates a default instance with kInlineCapacity.
-    Rep() : short_rep{} {}
-
-    // Creates an instance managing an allocated non zero CordRep.
-    explicit Rep(cord_internal::CordRepFlat *rep) : long_rep{rep} {
-      assert(rep != nullptr);
-    }
-
-    // Returns true if this instance manages the SSO internal buffer.
-    bool is_short() const {
-      constexpr size_t offset = offsetof(Short, raw_size);
-      return (reinterpret_cast<const char *>(this)[offset] & 1) != 0;
-    }
-
-    // Returns the available area of the internal SSO data
-    absl::Span<char> short_available() {
-      const size_t length = short_length();
-      return absl::Span<char>(short_rep.data + length,
-                              kInlineCapacity - length);
-    }
-
-    // Returns the available area of the internal SSO data
-    absl::Span<char> long_available() const {
-      assert(!is_short());
-      const size_t length = long_rep.rep->length;
-      return absl::Span<char>(long_rep.rep->Data() + length,
-                              long_rep.rep->Capacity() - length);
-    }
-
-    // Returns the length of the internal SSO data.
-    size_t short_length() const {
-      assert(is_short());
-      return static_cast<size_t>(short_rep.raw_size >> 1);
-    }
-
-    // Sets the length of the internal SSO data.
-    // Disregards any previously set CordRep instance.
-    void set_short_length(size_t length) {
-      short_rep.raw_size = static_cast<char>((length << 1) + 1);
-    }
-
-    // Adds `n` to the current short length.
-    void add_short_length(size_t n) {
-      assert(is_short());
-      short_rep.raw_size += static_cast<char>(n << 1);
-    }
-
-    // Returns reference to the internal SSO data buffer.
-    char *data() {
-      assert(is_short());
-      return short_rep.data;
-    }
-    const char *data() const {
-      assert(is_short());
-      return short_rep.data;
-    }
-
-    // Returns a pointer the external CordRep managed by this instance.
-    cord_internal::CordRepFlat *rep() const {
-      assert(!is_short());
-      return long_rep.rep;
-    }
-
-    // The internal representation takes advantage of the fact that allocated
-    // memory is always on an even address, and uses the least significant bit
-    // of the first or last byte (depending on endianness) as the inline size
-    // indicator overlapping with the least significant byte of the CordRep*.
-#if defined(ABSL_IS_BIG_ENDIAN)
-    struct Long {
-      explicit Long(cord_internal::CordRepFlat *rep_arg) : rep(rep_arg) {}
-      void *padding;
-      cord_internal::CordRepFlat *rep;
-    };
-    struct Short {
-      char data[sizeof(Long) - 1];
-      char raw_size = 1;
-    };
-#else
-    struct Long {
-      explicit Long(cord_internal::CordRepFlat *rep_arg) : rep(rep_arg) {}
-      cord_internal::CordRepFlat *rep;
-      void *padding;
-    };
-    struct Short {
-      char raw_size = 1;
-      char data[sizeof(Long) - 1];
-    };
-#endif
-
-    union {
-      Long long_rep;
-      Short short_rep;
-    };
-  };
-
-  // Power2 functions
-  static bool IsPow2(size_t size) { return absl::has_single_bit(size); }
-  static size_t Log2Floor(size_t size) {
-    return static_cast<size_t>(absl::bit_width(size) - 1);
-  }
-  static size_t Log2Ceil(size_t size) {
-    return static_cast<size_t>(absl::bit_width(size - 1));
-  }
-
-  // Implementation of `CreateWithCustomLimit()`.
-  // This implementation allows for future memory allocation hints to
-  // be passed down into the CordRepFlat allocation function.
-  template <typename... AllocationHints>
-  static CordBuffer CreateWithCustomLimitImpl(size_t block_size,
-                                              size_t capacity,
-                                              AllocationHints... hints);
-
-  // Consumes the value contained in this instance and resets the instance.
-  // This method returns a non-null Cordrep* if the current instances manages a
-  // CordRep*, and resets the instance to an empty SSO instance. If the current
-  // instance is an SSO instance, then this method returns nullptr and sets
-  // `short_value` to the inlined data value. In either case, the current
-  // instance length is reset to zero.
-  // This method is intended to be used by Cord internal functions only.
-  cord_internal::CordRep *ConsumeValue(absl::string_view &short_value) {
-    cord_internal::CordRep *rep = nullptr;
-    if (rep_.is_short()) {
-      short_value = absl::string_view(rep_.data(), rep_.short_length());
-    } else {
-      rep = rep_.rep();
-    }
-    rep_.set_short_length(0);
-    return rep;
-  }
-
-  // Internal constructor.
-  explicit CordBuffer(cord_internal::CordRepFlat *rep) : rep_(rep) {
-    assert(rep != nullptr);
-  }
-
-  Rep rep_;
-
-  friend class Cord;
-  friend class CordBufferTestPeer;
-};
-
-inline constexpr size_t CordBuffer::MaximumPayload() {
-  return cord_internal::kMaxFlatLength;
-}
-
-inline constexpr size_t CordBuffer::MaximumPayload(size_t block_size) {
-  return (std::min)(kCustomLimit, block_size) - cord_internal::kFlatOverhead;
-}
-
-inline CordBuffer CordBuffer::CreateWithDefaultLimit(size_t capacity) {
-  if (capacity > Rep::kInlineCapacity) {
-    auto *rep = cord_internal::CordRepFlat::New(capacity);
-    rep->length = 0;
-    return CordBuffer(rep);
-  }
-  return CordBuffer();
-}
-
-template <typename... AllocationHints>
-inline CordBuffer
-CordBuffer::CreateWithCustomLimitImpl(size_t block_size, size_t capacity,
-                                      AllocationHints... hints) {
-  assert(IsPow2(block_size));
-  capacity = (std::min)(capacity, kCustomLimit);
-  block_size = (std::min)(block_size, kCustomLimit);
-  if (capacity + kOverhead >= block_size) {
-    capacity = block_size;
-  } else if (capacity <= kDefaultLimit) {
-    capacity = capacity + kOverhead;
-  } else if (!IsPow2(capacity)) {
-    // Check if rounded up to next power 2 is a good enough fit
-    // with limited waste making it an acceptable direct fit.
-    const size_t rounded_up = size_t{1} << Log2Ceil(capacity);
-    const size_t slop = rounded_up - capacity;
-    if (slop >= kOverhead && slop <= kMaxPageSlop + kOverhead) {
-      capacity = rounded_up;
-    } else {
-      // Round down to highest power of 2 <= capacity.
-      // Consider a more aggressive step down if that may reduce the
-      // risk of fragmentation where 'people are holding it wrong'.
-      const size_t rounded_down = size_t{1} << Log2Floor(capacity);
-      capacity = rounded_down;
-    }
-  }
-  const size_t length = capacity - kOverhead;
-  auto *rep = CordRepFlat::New(CordRepFlat::Large(), length, hints...);
-  rep->length = 0;
-  return CordBuffer(rep);
-}
-
-inline CordBuffer CordBuffer::CreateWithCustomLimit(size_t block_size,
-                                                    size_t capacity) {
-  return CreateWithCustomLimitImpl(block_size, capacity);
-}
-
-inline CordBuffer::~CordBuffer() {
-  if (!rep_.is_short()) {
-    cord_internal::CordRepFlat::Delete(rep_.rep());
-  }
-}
-
-inline CordBuffer::CordBuffer(CordBuffer &&rhs) noexcept : rep_(rhs.rep_) {
-  rhs.rep_.set_short_length(0);
-}
-
-inline CordBuffer &CordBuffer::operator=(CordBuffer &&rhs) noexcept {
-  if (!rep_.is_short())
-    cord_internal::CordRepFlat::Delete(rep_.rep());
-  rep_ = rhs.rep_;
-  rhs.rep_.set_short_length(0);
-  return *this;
-}
-
-inline absl::Span<char> CordBuffer::available() {
-  return rep_.is_short() ? rep_.short_available() : rep_.long_available();
-}
-
-inline absl::Span<char> CordBuffer::available_up_to(size_t size) {
-  return available().subspan(0, size);
-}
-
-inline char *CordBuffer::data() {
-  return rep_.is_short() ? rep_.data() : rep_.rep()->Data();
-}
-
-inline const char *CordBuffer::data() const {
-  return rep_.is_short() ? rep_.data() : rep_.rep()->Data();
-}
-
-inline size_t CordBuffer::capacity() const {
-  return rep_.is_short() ? Rep::kInlineCapacity : rep_.rep()->Capacity();
-}
-
-inline size_t CordBuffer::length() const {
-  return rep_.is_short() ? rep_.short_length() : rep_.rep()->length;
-}
-
-inline void CordBuffer::SetLength(size_t length) {
-  ABSL_HARDENING_ASSERT(length <= capacity());
-  if (rep_.is_short()) {
-    rep_.set_short_length(length);
-  } else {
-    rep_.rep()->length = length;
-  }
-}
-
-inline void CordBuffer::IncreaseLengthBy(size_t n) {
-  ABSL_HARDENING_ASSERT(n <= capacity() && length() + n <= capacity());
-  if (rep_.is_short()) {
-    rep_.add_short_length(n);
-  } else {
-    rep_.rep()->length += n;
-  }
-}
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_CORD_BUFFER_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/cord_test_helpers.h b/packages/react-native-executorch/third-party/include/absl/strings/cord_test_helpers.h
deleted file mode 100644
index 5dd8ed04db..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/cord_test_helpers.h
+++ /dev/null
@@ -1,121 +0,0 @@
-//
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef ABSL_STRINGS_CORD_TEST_HELPERS_H_
-#define ABSL_STRINGS_CORD_TEST_HELPERS_H_
-
-#include <cstdint>
-#include <iostream>
-#include <string>
-
-#include "absl/base/config.h"
-#include "absl/strings/cord.h"
-#include "absl/strings/internal/cord_internal.h"
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// Cord sizes relevant for testing
-enum class TestCordSize {
-  // An empty value
-  kEmpty = 0,
-
-  // An inlined string value
-  kInlined = cord_internal::kMaxInline / 2 + 1,
-
-  // 'Well known' SSO lengths (excluding terminating zero).
-  // libstdcxx has a maximum SSO of 15, libc++ has a maximum SSO of 22.
-  kStringSso1 = 15,
-  kStringSso2 = 22,
-
-  // A string value which is too large to fit in inlined data, but small enough
-  // such that Cord prefers copying the value if possible, i.e.: not stealing
-  // std::string inputs, or referencing existing CordReps on Append, etc.
-  kSmall = cord_internal::kMaxBytesToCopy / 2 + 1,
-
-  // A string value large enough that Cord prefers to reference or steal from
-  // existing inputs rather than copying contents of the input.
-  kMedium = cord_internal::kMaxFlatLength / 2 + 1,
-
-  // A string value large enough to cause it to be stored in multiple flats.
-  kLarge = cord_internal::kMaxFlatLength * 4
-};
-
-// To string helper
-inline absl::string_view ToString(TestCordSize size) {
-  switch (size) {
-  case TestCordSize::kEmpty:
-    return "Empty";
-  case TestCordSize::kInlined:
-    return "Inlined";
-  case TestCordSize::kSmall:
-    return "Small";
-  case TestCordSize::kStringSso1:
-    return "StringSso1";
-  case TestCordSize::kStringSso2:
-    return "StringSso2";
-  case TestCordSize::kMedium:
-    return "Medium";
-  case TestCordSize::kLarge:
-    return "Large";
-  }
-  return "???";
-}
-
-// Returns the length matching the specified size
-inline size_t Length(TestCordSize size) { return static_cast<size_t>(size); }
-
-// Stream output helper
-inline std::ostream &operator<<(std::ostream &stream, TestCordSize size) {
-  return stream << ToString(size);
-}
-
-// Creates a multi-segment Cord from an iterable container of strings.  The
-// resulting Cord is guaranteed to have one segment for every string in the
-// container.  This allows code to be unit tested with multi-segment Cord
-// inputs.
-//
-// Example:
-//
-//   absl::Cord c = absl::MakeFragmentedCord({"A ", "fragmented ", "Cord"});
-//   EXPECT_FALSE(c.GetFlat(&unused));
-//
-// The mechanism by which this Cord is created is an implementation detail.  Any
-// implementation that produces a multi-segment Cord may produce a flat Cord in
-// the future as new optimizations are added to the Cord class.
-// MakeFragmentedCord will, however, always be updated to return a multi-segment
-// Cord.
-template <typename Container> Cord MakeFragmentedCord(const Container &c) {
-  Cord result;
-  for (const auto &s : c) {
-    auto *external = new std::string(s);
-    Cord tmp = absl::MakeCordFromExternal(
-        *external, [external](absl::string_view) { delete external; });
-    tmp.Prepend(result);
-    result = tmp;
-  }
-  return result;
-}
-
-inline Cord MakeFragmentedCord(std::initializer_list<absl::string_view> list) {
-  return MakeFragmentedCord<std::initializer_list<absl::string_view>>(list);
-}
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_CORD_TEST_HELPERS_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/cordz_test_helpers.h b/packages/react-native-executorch/third-party/include/absl/strings/cordz_test_helpers.h
deleted file mode 100644
index 413de5b9b0..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/cordz_test_helpers.h
+++ /dev/null
@@ -1,154 +0,0 @@
-// Copyright 2021 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_CORDZ_TEST_HELPERS_H_
-#define ABSL_STRINGS_CORDZ_TEST_HELPERS_H_
-
-#include <utility>
-
-#include "absl/base/config.h"
-#include "absl/base/macros.h"
-#include "absl/base/nullability.h"
-#include "absl/strings/cord.h"
-#include "absl/strings/internal/cord_internal.h"
-#include "absl/strings/internal/cordz_info.h"
-#include "absl/strings/internal/cordz_sample_token.h"
-#include "absl/strings/internal/cordz_statistics.h"
-#include "absl/strings/internal/cordz_update_tracker.h"
-#include "absl/strings/str_cat.h"
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// Returns the CordzInfo for the cord, or nullptr if the cord is not sampled.
-inline absl::Nullable<const cord_internal::CordzInfo *>
-GetCordzInfoForTesting(const Cord &cord) {
-  if (!cord.contents_.is_tree())
-    return nullptr;
-  return cord.contents_.cordz_info();
-}
-
-// Returns true if the provided cordz_info is in the list of sampled cords.
-inline bool
-CordzInfoIsListed(absl::Nonnull<const cord_internal::CordzInfo *> cordz_info,
-                  cord_internal::CordzSampleToken token = {}) {
-  for (const cord_internal::CordzInfo &info : token) {
-    if (cordz_info == &info)
-      return true;
-  }
-  return false;
-}
-
-// Matcher on Cord that verifies all of:
-// - the cord is sampled
-// - the CordzInfo of the cord is listed / discoverable.
-// - the reported CordzStatistics match the cord's actual properties
-// - the cord has an (initial) UpdateTracker count of 1 for `method`
-MATCHER_P(HasValidCordzInfoOf, method, "CordzInfo matches cord") {
-  const cord_internal::CordzInfo *cord_info = GetCordzInfoForTesting(arg);
-  if (cord_info == nullptr) {
-    *result_listener << "cord is not sampled";
-    return false;
-  }
-  if (!CordzInfoIsListed(cord_info)) {
-    *result_listener << "cord is sampled, but not listed";
-    return false;
-  }
-  cord_internal::CordzStatistics stat = cord_info->GetCordzStatistics();
-  if (stat.size != arg.size()) {
-    *result_listener << "cordz size " << stat.size
-                     << " does not match cord size " << arg.size();
-    return false;
-  }
-  if (stat.update_tracker.Value(method) != 1) {
-    *result_listener << "Expected method count 1 for " << method << ", found "
-                     << stat.update_tracker.Value(method);
-    return false;
-  }
-  return true;
-}
-
-// Matcher on Cord that verifies that the cord is sampled and that the CordzInfo
-// update tracker has 'method' with a call count of 'n'
-MATCHER_P2(CordzMethodCountEq, method, n,
-           absl::StrCat("CordzInfo method count equals ", n)) {
-  const cord_internal::CordzInfo *cord_info = GetCordzInfoForTesting(arg);
-  if (cord_info == nullptr) {
-    *result_listener << "cord is not sampled";
-    return false;
-  }
-  cord_internal::CordzStatistics stat = cord_info->GetCordzStatistics();
-  if (stat.update_tracker.Value(method) != n) {
-    *result_listener << "Expected method count " << n << " for " << method
-                     << ", found " << stat.update_tracker.Value(method);
-    return false;
-  }
-  return true;
-}
-
-// Cordz will only update with a new rate once the previously scheduled event
-// has fired. When we disable Cordz, a long delay takes place where we won't
-// consider profiling new Cords. CordzSampleIntervalHelper will burn through
-// that interval and allow for testing that assumes that the average sampling
-// interval is a particular value.
-class CordzSamplingIntervalHelper {
-public:
-  explicit CordzSamplingIntervalHelper(int32_t interval)
-      : orig_mean_interval_(absl::cord_internal::get_cordz_mean_interval()) {
-    absl::cord_internal::set_cordz_mean_interval(interval);
-    absl::cord_internal::cordz_set_next_sample_for_testing(interval);
-  }
-
-  ~CordzSamplingIntervalHelper() {
-    absl::cord_internal::set_cordz_mean_interval(orig_mean_interval_);
-    absl::cord_internal::cordz_set_next_sample_for_testing(orig_mean_interval_);
-  }
-
-private:
-  int32_t orig_mean_interval_;
-};
-
-// Wrapper struct managing a small CordRep `rep`
-struct TestCordRep {
-  absl::Nonnull<cord_internal::CordRepFlat *> rep;
-
-  TestCordRep() {
-    rep = cord_internal::CordRepFlat::New(100);
-    rep->length = 100;
-    memset(rep->Data(), 1, 100);
-  }
-  ~TestCordRep() { cord_internal::CordRep::Unref(rep); }
-};
-
-// Wrapper struct managing a small CordRep `rep`, and
-// an InlineData `data` initialized with that CordRep.
-struct TestCordData {
-  TestCordRep rep;
-  cord_internal::InlineData data{rep.rep};
-};
-
-// Creates a Cord that is not sampled
-template <typename... Args> Cord UnsampledCord(Args... args) {
-  CordzSamplingIntervalHelper never(9999);
-  Cord cord(std::forward<Args>(args)...);
-  ABSL_ASSERT(GetCordzInfoForTesting(cord) == nullptr);
-  return cord;
-}
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_CORDZ_TEST_HELPERS_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/escaping.h b/packages/react-native-executorch/third-party/include/absl/strings/escaping.h
deleted file mode 100644
index 2c90eba6e3..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/escaping.h
+++ /dev/null
@@ -1,186 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: escaping.h
-// -----------------------------------------------------------------------------
-//
-// This header file contains string utilities involved in escaping and
-// unescaping strings in various ways.
-
-#ifndef ABSL_STRINGS_ESCAPING_H_
-#define ABSL_STRINGS_ESCAPING_H_
-
-#include <cstddef>
-#include <string>
-#include <vector>
-
-#include "absl/base/attributes.h"
-#include "absl/base/macros.h"
-#include "absl/base/nullability.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/str_join.h"
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// CUnescape()
-//
-// Unescapes a `source` string and copies it into `dest`, rewriting C-style
-// escape sequences (https://en.cppreference.com/w/cpp/language/escape) into
-// their proper code point equivalents, returning `true` if successful.
-//
-// The following unescape sequences can be handled:
-//
-//   * ASCII escape sequences ('\n','\r','\\', etc.) to their ASCII equivalents
-//   * Octal escape sequences ('\nnn') to byte nnn. The unescaped value must
-//     resolve to a single byte or an error will occur. E.g. values greater than
-//     0xff will produce an error.
-//   * Hexadecimal escape sequences ('\xnn') to byte nn. While an arbitrary
-//     number of following digits are allowed, the unescaped value must resolve
-//     to a single byte or an error will occur. E.g. '\x0045' is equivalent to
-//     '\x45', but '\x1234' will produce an error.
-//   * Unicode escape sequences ('\unnnn' for exactly four hex digits or
-//     '\Unnnnnnnn' for exactly eight hex digits, which will be encoded in
-//     UTF-8. (E.g., `\u2019` unescapes to the three bytes 0xE2, 0x80, and
-//     0x99).
-//
-// If any errors are encountered, this function returns `false`, leaving the
-// `dest` output parameter in an unspecified state, and stores the first
-// encountered error in `error`. To disable error reporting, set `error` to
-// `nullptr` or use the overload with no error reporting below.
-//
-// Example:
-//
-//   std::string s = "foo\\rbar\\nbaz\\t";
-//   std::string unescaped_s;
-//   if (!absl::CUnescape(s, &unescaped_s)) {
-//     ...
-//   }
-//   EXPECT_EQ(unescaped_s, "foo\rbar\nbaz\t");
-bool CUnescape(absl::string_view source, absl::Nonnull<std::string *> dest,
-               absl::Nullable<std::string *> error);
-
-// Overload of `CUnescape()` with no error reporting.
-inline bool CUnescape(absl::string_view source,
-                      absl::Nonnull<std::string *> dest) {
-  return CUnescape(source, dest, nullptr);
-}
-
-// CEscape()
-//
-// Escapes a 'src' string using C-style escapes sequences
-// (https://en.cppreference.com/w/cpp/language/escape), escaping other
-// non-printable/non-whitespace bytes as octal sequences (e.g. "\377").
-//
-// Example:
-//
-//   std::string s = "foo\rbar\tbaz\010\011\012\013\014\x0d\n";
-//   std::string escaped_s = absl::CEscape(s);
-//   EXPECT_EQ(escaped_s, "foo\\rbar\\tbaz\\010\\t\\n\\013\\014\\r\\n");
-std::string CEscape(absl::string_view src);
-
-// CHexEscape()
-//
-// Escapes a 'src' string using C-style escape sequences, escaping
-// other non-printable/non-whitespace bytes as hexadecimal sequences (e.g.
-// "\xFF").
-//
-// Example:
-//
-//   std::string s = "foo\rbar\tbaz\010\011\012\013\014\x0d\n";
-//   std::string escaped_s = absl::CHexEscape(s);
-//   EXPECT_EQ(escaped_s, "foo\\rbar\\tbaz\\x08\\t\\n\\x0b\\x0c\\r\\n");
-std::string CHexEscape(absl::string_view src);
-
-// Utf8SafeCEscape()
-//
-// Escapes a 'src' string using C-style escape sequences, escaping bytes as
-// octal sequences, and passing through UTF-8 characters without conversion.
-// I.e., when encountering any bytes with their high bit set, this function
-// will not escape those values, whether or not they are valid UTF-8.
-std::string Utf8SafeCEscape(absl::string_view src);
-
-// Utf8SafeCHexEscape()
-//
-// Escapes a 'src' string using C-style escape sequences, escaping bytes as
-// hexadecimal sequences, and passing through UTF-8 characters without
-// conversion.
-std::string Utf8SafeCHexEscape(absl::string_view src);
-
-// Base64Escape()
-//
-// Encodes a `src` string into a base64-encoded 'dest' string with padding
-// characters. This function conforms with RFC 4648 section 4 (base64) and RFC
-// 2045.
-void Base64Escape(absl::string_view src, absl::Nonnull<std::string *> dest);
-std::string Base64Escape(absl::string_view src);
-
-// WebSafeBase64Escape()
-//
-// Encodes a `src` string into a base64 string, like Base64Escape() does, but
-// outputs '-' instead of '+' and '_' instead of '/', and does not pad 'dest'.
-// This function conforms with RFC 4648 section 5 (base64url).
-void WebSafeBase64Escape(absl::string_view src,
-                         absl::Nonnull<std::string *> dest);
-std::string WebSafeBase64Escape(absl::string_view src);
-
-// Base64Unescape()
-//
-// Converts a `src` string encoded in Base64 (RFC 4648 section 4) to its binary
-// equivalent, writing it to a `dest` buffer, returning `true` on success. If
-// `src` contains invalid characters, `dest` is cleared and returns `false`.
-// If padding is included (note that `Base64Escape()` does produce it), it must
-// be correct. In the padding, '=' and '.' are treated identically.
-bool Base64Unescape(absl::string_view src, absl::Nonnull<std::string *> dest);
-
-// WebSafeBase64Unescape()
-//
-// Converts a `src` string encoded in "web safe" Base64 (RFC 4648 section 5) to
-// its binary equivalent, writing it to a `dest` buffer. If `src` contains
-// invalid characters, `dest` is cleared and returns `false`. If padding is
-// included (note that `WebSafeBase64Escape()` does not produce it), it must be
-// correct. In the padding, '=' and '.' are treated identically.
-bool WebSafeBase64Unescape(absl::string_view src,
-                           absl::Nonnull<std::string *> dest);
-
-// HexStringToBytes()
-//
-// Converts the hexadecimal encoded data in `hex` into raw bytes in the `bytes`
-// output string.  If `hex` does not consist of valid hexadecimal data, this
-// function returns false and leaves `bytes` in an unspecified state. Returns
-// true on success.
-ABSL_MUST_USE_RESULT bool HexStringToBytes(absl::string_view hex,
-                                           absl::Nonnull<std::string *> bytes);
-
-// HexStringToBytes()
-//
-// Converts an ASCII hex string into bytes, returning binary data of length
-// `from.size()/2`. The input must be valid hexadecimal data, otherwise the
-// return value is unspecified.
-ABSL_DEPRECATED("Use the HexStringToBytes() that returns a bool")
-std::string HexStringToBytes(absl::string_view from);
-
-// BytesToHexString()
-//
-// Converts binary data into an ASCII text string, returning a string of size
-// `2*from.size()`.
-std::string BytesToHexString(absl::string_view from);
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_ESCAPING_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/has_absl_stringify.h b/packages/react-native-executorch/third-party/include/absl/strings/has_absl_stringify.h
deleted file mode 100644
index 5f7526a550..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/has_absl_stringify.h
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright 2022 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_HAS_ABSL_STRINGIFY_H_
-#define ABSL_STRINGS_HAS_ABSL_STRINGIFY_H_
-
-#include <type_traits>
-#include <utility>
-
-#include "absl/base/config.h"
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-namespace strings_internal {
-
-// This is an empty class not intended to be used. It exists so that
-// `HasAbslStringify` can reference a universal class rather than needing to be
-// copied for each new sink.
-class UnimplementedSink {
-public:
-  void Append(size_t count, char ch);
-
-  void Append(string_view v);
-
-  // Support `absl::Format(&sink, format, args...)`.
-  friend void AbslFormatFlush(UnimplementedSink *sink, absl::string_view v);
-};
-
-} // namespace strings_internal
-
-// `HasAbslStringify<T>` detects if type `T` supports the `AbslStringify()`
-// customization point (see
-// https://abseil.io/docs/cpp/guides/format#abslstringify for the
-// documentation).
-//
-// Note that there are types that can be `StrCat`-ed that do not use the
-// `AbslStringify` customization point (for example, `int`).
-
-template <typename T, typename = void>
-struct HasAbslStringify : std::false_type {};
-
-template <typename T>
-struct HasAbslStringify<
-    T, std::enable_if_t<std::is_void<decltype(AbslStringify(
-           std::declval<strings_internal::UnimplementedSink &>(),
-           std::declval<const T &>()))>::value>> : std::true_type {};
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_HAS_ABSL_STRINGIFY_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/has_ostream_operator.h b/packages/react-native-executorch/third-party/include/absl/strings/has_ostream_operator.h
deleted file mode 100644
index cf58a76802..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/has_ostream_operator.h
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright 2023 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_HAS_OSTREAM_OPERATOR_H_
-#define ABSL_STRINGS_HAS_OSTREAM_OPERATOR_H_
-
-#include <ostream>
-#include <type_traits>
-#include <utility>
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// Detects if type `T` supports streaming to `std::ostream`s with `operator<<`.
-
-template <typename T, typename = void>
-struct HasOstreamOperator : std::false_type {};
-
-template <typename T>
-struct HasOstreamOperator<
-    T, std::enable_if_t<std::is_same<
-           std::ostream &, decltype(std::declval<std::ostream &>()
-                                    << std::declval<const T &>())>::value>>
-    : std::true_type {};
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_HAS_OSTREAM_OPERATOR_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/charconv_bigint.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/charconv_bigint.h
deleted file mode 100644
index 0389dbfce9..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/charconv_bigint.h
+++ /dev/null
@@ -1,430 +0,0 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_
-#define ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_
-
-#include <algorithm>
-#include <cstdint>
-#include <iostream>
-#include <string>
-
-#include "absl/base/config.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/internal/charconv_parse.h"
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-// The largest power that 5 that can be raised to, and still fit in a uint32_t.
-constexpr int kMaxSmallPowerOfFive = 13;
-// The largest power that 10 that can be raised to, and still fit in a uint32_t.
-constexpr int kMaxSmallPowerOfTen = 9;
-
-ABSL_DLL extern const uint32_t kFiveToNth[kMaxSmallPowerOfFive + 1];
-ABSL_DLL extern const uint32_t kTenToNth[kMaxSmallPowerOfTen + 1];
-
-// Large, fixed-width unsigned integer.
-//
-// Exact rounding for decimal-to-binary floating point conversion requires very
-// large integer math, but a design goal of absl::from_chars is to avoid
-// allocating memory.  The integer precision needed for decimal-to-binary
-// conversions is large but bounded, so a huge fixed-width integer class
-// suffices.
-//
-// This is an intentionally limited big integer class.  Only needed operations
-// are implemented.  All storage lives in an array data member, and all
-// arithmetic is done in-place, to avoid requiring separate storage for operand
-// and result.
-//
-// This is an internal class.  Some methods live in the .cc file, and are
-// instantiated only for the values of max_words we need.
-template <int max_words> class BigUnsigned {
-public:
-  static_assert(max_words == 4 || max_words == 84,
-                "unsupported max_words value");
-
-  BigUnsigned() : size_(0), words_{} {}
-  explicit constexpr BigUnsigned(uint64_t v)
-      : size_((v >> 32) ? 2
-              : v       ? 1
-                        : 0),
-        words_{static_cast<uint32_t>(v & 0xffffffffu),
-               static_cast<uint32_t>(v >> 32)} {}
-
-  // Constructs a BigUnsigned from the given string_view containing a decimal
-  // value.  If the input string is not a decimal integer, constructs a 0
-  // instead.
-  explicit BigUnsigned(absl::string_view sv) : size_(0), words_{} {
-    // Check for valid input, returning a 0 otherwise.  This is reasonable
-    // behavior only because this constructor is for unit tests.
-    if (std::find_if_not(sv.begin(), sv.end(), ascii_isdigit) != sv.end() ||
-        sv.empty()) {
-      return;
-    }
-    int exponent_adjust =
-        ReadDigits(sv.data(), sv.data() + sv.size(), Digits10() + 1);
-    if (exponent_adjust > 0) {
-      MultiplyByTenToTheNth(exponent_adjust);
-    }
-  }
-
-  // Loads the mantissa value of a previously-parsed float.
-  //
-  // Returns the associated decimal exponent.  The value of the parsed float is
-  // exactly *this * 10**exponent.
-  int ReadFloatMantissa(const ParsedFloat &fp, int significant_digits);
-
-  // Returns the number of decimal digits of precision this type provides.  All
-  // numbers with this many decimal digits or fewer are representable by this
-  // type.
-  //
-  // Analogous to std::numeric_limits<BigUnsigned>::digits10.
-  static constexpr int Digits10() {
-    // 9975007/1035508 is very slightly less than log10(2**32).
-    return static_cast<uint64_t>(max_words) * 9975007 / 1035508;
-  }
-
-  // Shifts left by the given number of bits.
-  void ShiftLeft(int count) {
-    if (count > 0) {
-      const int word_shift = count / 32;
-      if (word_shift >= max_words) {
-        SetToZero();
-        return;
-      }
-      size_ = (std::min)(size_ + word_shift, max_words);
-      count %= 32;
-      if (count == 0) {
-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=warray-bounds
-// shows a lot of bogus -Warray-bounds warnings under GCC.
-// This is not the only one in Abseil.
-#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(14, 0)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Warray-bounds"
-#endif
-        std::copy_backward(words_, words_ + size_ - word_shift, words_ + size_);
-#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(14, 0)
-#pragma GCC diagnostic pop
-#endif
-      } else {
-        for (int i = (std::min)(size_, max_words - 1); i > word_shift; --i) {
-          words_[i] = (words_[i - word_shift] << count) |
-                      (words_[i - word_shift - 1] >> (32 - count));
-        }
-        words_[word_shift] = words_[0] << count;
-        // Grow size_ if necessary.
-        if (size_ < max_words && words_[size_]) {
-          ++size_;
-        }
-      }
-      std::fill_n(words_, word_shift, 0u);
-    }
-  }
-
-  // Multiplies by v in-place.
-  void MultiplyBy(uint32_t v) {
-    if (size_ == 0 || v == 1) {
-      return;
-    }
-    if (v == 0) {
-      SetToZero();
-      return;
-    }
-    const uint64_t factor = v;
-    uint64_t window = 0;
-    for (int i = 0; i < size_; ++i) {
-      window += factor * words_[i];
-      words_[i] = window & 0xffffffff;
-      window >>= 32;
-    }
-    // If carry bits remain and there's space for them, grow size_.
-    if (window && size_ < max_words) {
-      words_[size_] = window & 0xffffffff;
-      ++size_;
-    }
-  }
-
-  void MultiplyBy(uint64_t v) {
-    uint32_t words[2];
-    words[0] = static_cast<uint32_t>(v);
-    words[1] = static_cast<uint32_t>(v >> 32);
-    if (words[1] == 0) {
-      MultiplyBy(words[0]);
-    } else {
-      MultiplyBy(2, words);
-    }
-  }
-
-  // Multiplies in place by 5 to the power of n.  n must be non-negative.
-  void MultiplyByFiveToTheNth(int n) {
-    while (n >= kMaxSmallPowerOfFive) {
-      MultiplyBy(kFiveToNth[kMaxSmallPowerOfFive]);
-      n -= kMaxSmallPowerOfFive;
-    }
-    if (n > 0) {
-      MultiplyBy(kFiveToNth[n]);
-    }
-  }
-
-  // Multiplies in place by 10 to the power of n.  n must be non-negative.
-  void MultiplyByTenToTheNth(int n) {
-    if (n > kMaxSmallPowerOfTen) {
-      // For large n, raise to a power of 5, then shift left by the same amount.
-      // (10**n == 5**n * 2**n.)  This requires fewer multiplications overall.
-      MultiplyByFiveToTheNth(n);
-      ShiftLeft(n);
-    } else if (n > 0) {
-      // We can do this more quickly for very small N by using a single
-      // multiplication.
-      MultiplyBy(kTenToNth[n]);
-    }
-  }
-
-  // Returns the value of 5**n, for non-negative n.  This implementation uses
-  // a lookup table, and is faster then seeding a BigUnsigned with 1 and calling
-  // MultiplyByFiveToTheNth().
-  static BigUnsigned FiveToTheNth(int n);
-
-  // Multiplies by another BigUnsigned, in-place.
-  template <int M> void MultiplyBy(const BigUnsigned<M> &other) {
-    MultiplyBy(other.size(), other.words());
-  }
-
-  void SetToZero() {
-    std::fill_n(words_, size_, 0u);
-    size_ = 0;
-  }
-
-  // Returns the value of the nth word of this BigUnsigned.  This is
-  // range-checked, and returns 0 on out-of-bounds accesses.
-  uint32_t GetWord(int index) const {
-    if (index < 0 || index >= size_) {
-      return 0;
-    }
-    return words_[index];
-  }
-
-  // Returns this integer as a decimal string.  This is not used in the decimal-
-  // to-binary conversion; it is intended to aid in testing.
-  std::string ToString() const;
-
-  int size() const { return size_; }
-  const uint32_t *words() const { return words_; }
-
-private:
-  // Reads the number between [begin, end), possibly containing a decimal point,
-  // into this BigUnsigned.
-  //
-  // Callers are required to ensure [begin, end) contains a valid number, with
-  // one or more decimal digits and at most one decimal point.  This routine
-  // will behave unpredictably if these preconditions are not met.
-  //
-  // Only the first `significant_digits` digits are read.  Digits beyond this
-  // limit are "sticky": If the final significant digit is 0 or 5, and if any
-  // dropped digit is nonzero, then that final significant digit is adjusted up
-  // to 1 or 6.  This adjustment allows for precise rounding.
-  //
-  // Returns `exponent_adjustment`, a power-of-ten exponent adjustment to
-  // account for the decimal point and for dropped significant digits.  After
-  // this function returns,
-  //   actual_value_of_parsed_string ~= *this * 10**exponent_adjustment.
-  int ReadDigits(const char *begin, const char *end, int significant_digits);
-
-  // Performs a step of big integer multiplication.  This computes the full
-  // (64-bit-wide) values that should be added at the given index (step), and
-  // adds to that location in-place.
-  //
-  // Because our math all occurs in place, we must multiply starting from the
-  // highest word working downward.  (This is a bit more expensive due to the
-  // extra carries involved.)
-  //
-  // This must be called in steps, for each word to be calculated, starting from
-  // the high end and working down to 0.  The first value of `step` should be
-  //   `std::min(original_size + other.size_ - 2, max_words - 1)`.
-  // The reason for this expression is that multiplying the i'th word from one
-  // multiplicand and the j'th word of another multiplicand creates a
-  // two-word-wide value to be stored at the (i+j)'th element.  The highest
-  // word indices we will access are `original_size - 1` from this object, and
-  // `other.size_ - 1` from our operand.  Therefore,
-  // `original_size + other.size_ - 2` is the first step we should calculate,
-  // but limited on an upper bound by max_words.
-
-  // Working from high-to-low ensures that we do not overwrite the portions of
-  // the initial value of *this which are still needed for later steps.
-  //
-  // Once called with step == 0, *this contains the result of the
-  // multiplication.
-  //
-  // `original_size` is the size_ of *this before the first call to
-  // MultiplyStep().  `other_words` and `other_size` are the contents of our
-  // operand.  `step` is the step to perform, as described above.
-  void MultiplyStep(int original_size, const uint32_t *other_words,
-                    int other_size, int step);
-
-  void MultiplyBy(int other_size, const uint32_t *other_words) {
-    const int original_size = size_;
-    const int first_step =
-        (std::min)(original_size + other_size - 2, max_words - 1);
-    for (int step = first_step; step >= 0; --step) {
-      MultiplyStep(original_size, other_words, other_size, step);
-    }
-  }
-
-  // Adds a 32-bit value to the index'th word, with carry.
-  void AddWithCarry(int index, uint32_t value) {
-    if (value) {
-      while (index < max_words && value > 0) {
-        words_[index] += value;
-        // carry if we overflowed in this word:
-        if (value > words_[index]) {
-          value = 1;
-          ++index;
-        } else {
-          value = 0;
-        }
-      }
-      size_ = (std::min)(max_words, (std::max)(index + 1, size_));
-    }
-  }
-
-  void AddWithCarry(int index, uint64_t value) {
-    if (value && index < max_words) {
-      uint32_t high = value >> 32;
-      uint32_t low = value & 0xffffffff;
-      words_[index] += low;
-      if (words_[index] < low) {
-        ++high;
-        if (high == 0) {
-          // Carry from the low word caused our high word to overflow.
-          // Short circuit here to do the right thing.
-          AddWithCarry(index + 2, static_cast<uint32_t>(1));
-          return;
-        }
-      }
-      if (high > 0) {
-        AddWithCarry(index + 1, high);
-      } else {
-        // Normally 32-bit AddWithCarry() sets size_, but since we don't call
-        // it when `high` is 0, do it ourselves here.
-        size_ = (std::min)(max_words, (std::max)(index + 1, size_));
-      }
-    }
-  }
-
-  // Divide this in place by a constant divisor.  Returns the remainder of the
-  // division.
-  template <uint32_t divisor> uint32_t DivMod() {
-    uint64_t accumulator = 0;
-    for (int i = size_ - 1; i >= 0; --i) {
-      accumulator <<= 32;
-      accumulator += words_[i];
-      // accumulator / divisor will never overflow an int32_t in this loop
-      words_[i] = static_cast<uint32_t>(accumulator / divisor);
-      accumulator = accumulator % divisor;
-    }
-    while (size_ > 0 && words_[size_ - 1] == 0) {
-      --size_;
-    }
-    return static_cast<uint32_t>(accumulator);
-  }
-
-  // The number of elements in words_ that may carry significant values.
-  // All elements beyond this point are 0.
-  //
-  // When size_ is 0, this BigUnsigned stores the value 0.
-  // When size_ is nonzero, is *not* guaranteed that words_[size_ - 1] is
-  // nonzero.  This can occur due to overflow truncation.
-  // In particular, x.size_ != y.size_ does *not* imply x != y.
-  int size_;
-  uint32_t words_[max_words];
-};
-
-// Compares two big integer instances.
-//
-// Returns -1 if lhs < rhs, 0 if lhs == rhs, and 1 if lhs > rhs.
-template <int N, int M>
-int Compare(const BigUnsigned<N> &lhs, const BigUnsigned<M> &rhs) {
-  int limit = (std::max)(lhs.size(), rhs.size());
-  for (int i = limit - 1; i >= 0; --i) {
-    const uint32_t lhs_word = lhs.GetWord(i);
-    const uint32_t rhs_word = rhs.GetWord(i);
-    if (lhs_word < rhs_word) {
-      return -1;
-    } else if (lhs_word > rhs_word) {
-      return 1;
-    }
-  }
-  return 0;
-}
-
-template <int N, int M>
-bool operator==(const BigUnsigned<N> &lhs, const BigUnsigned<M> &rhs) {
-  int limit = (std::max)(lhs.size(), rhs.size());
-  for (int i = 0; i < limit; ++i) {
-    if (lhs.GetWord(i) != rhs.GetWord(i)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-template <int N, int M>
-bool operator!=(const BigUnsigned<N> &lhs, const BigUnsigned<M> &rhs) {
-  return !(lhs == rhs);
-}
-
-template <int N, int M>
-bool operator<(const BigUnsigned<N> &lhs, const BigUnsigned<M> &rhs) {
-  return Compare(lhs, rhs) == -1;
-}
-
-template <int N, int M>
-bool operator>(const BigUnsigned<N> &lhs, const BigUnsigned<M> &rhs) {
-  return rhs < lhs;
-}
-template <int N, int M>
-bool operator<=(const BigUnsigned<N> &lhs, const BigUnsigned<M> &rhs) {
-  return !(rhs < lhs);
-}
-template <int N, int M>
-bool operator>=(const BigUnsigned<N> &lhs, const BigUnsigned<M> &rhs) {
-  return !(lhs < rhs);
-}
-
-// Output operator for BigUnsigned, for testing purposes only.
-template <int N>
-std::ostream &operator<<(std::ostream &os, const BigUnsigned<N> &num) {
-  return os << num.ToString();
-}
-
-// Explicit instantiation declarations for the sizes of BigUnsigned that we
-// are using.
-//
-// For now, the choices of 4 and 84 are arbitrary; 4 is a small value that is
-// still bigger than an int128, and 84 is a large value we will want to use
-// in the from_chars implementation.
-//
-// Comments justifying the use of 84 belong in the from_chars implementation,
-// and will be added in a follow-up CL.
-extern template class BigUnsigned<4>;
-extern template class BigUnsigned<84>;
-
-} // namespace strings_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/charconv_parse.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/charconv_parse.h
deleted file mode 100644
index 759899002a..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/charconv_parse.h
+++ /dev/null
@@ -1,99 +0,0 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
-#define ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
-
-#include <cstdint>
-
-#include "absl/base/config.h"
-#include "absl/strings/charconv.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-// Enum indicating whether a parsed float is a number or special value.
-enum class FloatType { kNumber, kInfinity, kNan };
-
-// The decomposed parts of a parsed `float` or `double`.
-struct ParsedFloat {
-  // Representation of the parsed mantissa, with the decimal point adjusted to
-  // make it an integer.
-  //
-  // During decimal scanning, this contains 19 significant digits worth of
-  // mantissa value.  If digits beyond this point are found, they
-  // are truncated, and if any of these dropped digits are nonzero, then
-  // `mantissa` is inexact, and the full mantissa is stored in [subrange_begin,
-  // subrange_end).
-  //
-  // During hexadecimal scanning, this contains 15 significant hex digits worth
-  // of mantissa value.  Digits beyond this point are sticky -- they are
-  // truncated, but if any dropped digits are nonzero, the low bit of mantissa
-  // will be set.  (This allows for precise rounding, and avoids the need
-  // to store the full mantissa in [subrange_begin, subrange_end).)
-  uint64_t mantissa = 0;
-
-  // Floating point expontent.  This reflects any decimal point adjustments and
-  // any truncated digits from the mantissa.  The absolute value of the parsed
-  // number is represented by mantissa * (base ** exponent), where base==10 for
-  // decimal floats, and base==2 for hexadecimal floats.
-  int exponent = 0;
-
-  // The literal exponent value scanned from the input, or 0 if none was
-  // present.  This does not reflect any adjustments applied to mantissa.
-  int literal_exponent = 0;
-
-  // The type of number scanned.
-  FloatType type = FloatType::kNumber;
-
-  // When non-null, [subrange_begin, subrange_end) marks a range of characters
-  // that require further processing.  The meaning is dependent on float type.
-  // If type == kNumber and this is set, this is a "wide input": the input
-  // mantissa contained more than 19 digits.  The range contains the full
-  // mantissa.  It plus `literal_exponent` need to be examined to find the best
-  // floating point match.
-  // If type == kNan and this is set, the range marks the contents of a
-  // matched parenthesized character region after the NaN.
-  const char *subrange_begin = nullptr;
-  const char *subrange_end = nullptr;
-
-  // One-past-the-end of the successfully parsed region, or nullptr if no
-  // matching pattern was found.
-  const char *end = nullptr;
-};
-
-// Read the floating point number in the provided range, and populate
-// ParsedFloat accordingly.
-//
-// format_flags is a bitmask value specifying what patterns this API will match.
-// `scientific` and `fixed`  are honored per std::from_chars rules
-// ([utility.from.chars], C++17): if exactly one of these bits is set, then an
-// exponent is required, or dislallowed, respectively.
-//
-// Template parameter `base` must be either 10 or 16.  For base 16, a "0x" is
-// *not* consumed.  The `hex` bit from format_flags is ignored by ParseFloat.
-template <int base>
-ParsedFloat ParseFloat(const char *begin, const char *end,
-                       absl::chars_format format_flags);
-
-extern template ParsedFloat ParseFloat<10>(const char *begin, const char *end,
-                                           absl::chars_format format_flags);
-extern template ParsedFloat ParseFloat<16>(const char *begin, const char *end,
-                                           absl::chars_format format_flags);
-
-} // namespace strings_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-#endif // ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_data_edge.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_data_edge.h
deleted file mode 100644
index ca6330bf8d..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_data_edge.h
+++ /dev/null
@@ -1,65 +0,0 @@
-// Copyright 2022 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_CORD_DATA_EDGE_H_
-#define ABSL_STRINGS_INTERNAL_CORD_DATA_EDGE_H_
-
-#include <cassert>
-#include <cstddef>
-
-#include "absl/base/config.h"
-#include "absl/strings/internal/cord_internal.h"
-#include "absl/strings/internal/cord_rep_flat.h"
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// Returns true if the provided rep is a FLAT, EXTERNAL or a SUBSTRING node
-// holding a FLAT or EXTERNAL child rep. Requires `rep != nullptr`.
-inline bool IsDataEdge(const CordRep *edge) {
-  assert(edge != nullptr);
-
-  // The fast path is that `edge` is an EXTERNAL or FLAT node, making the below
-  // if a single, well predicted branch. We then repeat the FLAT or EXTERNAL
-  // check in the slow path of the SUBSTRING check to optimize for the hot path.
-  if (edge->tag == EXTERNAL || edge->tag >= FLAT)
-    return true;
-  if (edge->tag == SUBSTRING)
-    edge = edge->substring()->child;
-  return edge->tag == EXTERNAL || edge->tag >= FLAT;
-}
-
-// Returns the `absl::string_view` data reference for the provided data edge.
-// Requires 'IsDataEdge(edge) == true`.
-inline absl::string_view EdgeData(const CordRep *edge) {
-  assert(IsDataEdge(edge));
-
-  size_t offset = 0;
-  const size_t length = edge->length;
-  if (edge->IsSubstring()) {
-    offset = edge->substring()->start;
-    edge = edge->substring()->child;
-  }
-  return edge->tag >= FLAT
-             ? absl::string_view{edge->flat()->Data() + offset, length}
-             : absl::string_view{edge->external()->base + offset, length};
-}
-
-} // namespace cord_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_CORD_DATA_EDGE_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_internal.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_internal.h
deleted file mode 100644
index 3fc02c5375..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_internal.h
+++ /dev/null
@@ -1,929 +0,0 @@
-// Copyright 2021 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_CORD_INTERNAL_H_
-#define ABSL_STRINGS_INTERNAL_CORD_INTERNAL_H_
-
-#include <atomic>
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <type_traits>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/base/internal/endian.h"
-#include "absl/base/internal/invoke.h"
-#include "absl/base/optimization.h"
-#include "absl/container/internal/compressed_tuple.h"
-#include "absl/container/internal/container_memory.h"
-#include "absl/meta/type_traits.h"
-#include "absl/strings/string_view.h"
-
-// We can only add poisoning if we can detect consteval executions.
-#if defined(ABSL_HAVE_CONSTANT_EVALUATED) &&                                   \
-    (defined(ABSL_HAVE_ADDRESS_SANITIZER) ||                                   \
-     defined(ABSL_HAVE_MEMORY_SANITIZER))
-#define ABSL_INTERNAL_CORD_HAVE_SANITIZER 1
-#endif
-
-#define ABSL_CORD_INTERNAL_NO_SANITIZE                                         \
-  ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// The overhead of a vtable is too much for Cord, so we roll our own subclasses
-// using only a single byte to differentiate classes from each other - the "tag"
-// byte.  Define the subclasses first so we can provide downcasting helper
-// functions in the base class.
-struct CordRep;
-struct CordRepConcat;
-struct CordRepExternal;
-struct CordRepFlat;
-struct CordRepSubstring;
-struct CordRepCrc;
-class CordRepBtree;
-
-class CordzInfo;
-
-// Default feature enable states for cord ring buffers
-enum CordFeatureDefaults { kCordShallowSubcordsDefault = false };
-
-extern std::atomic<bool> shallow_subcords_enabled;
-
-inline void enable_shallow_subcords(bool enable) {
-  shallow_subcords_enabled.store(enable, std::memory_order_relaxed);
-}
-
-enum Constants {
-  // The inlined size to use with absl::InlinedVector.
-  //
-  // Note: The InlinedVectors in this file (and in cord.h) do not need to use
-  // the same value for their inlined size. The fact that they do is historical.
-  // It may be desirable for each to use a different inlined size optimized for
-  // that InlinedVector's usage.
-  //
-  // TODO(jgm): Benchmark to see if there's a more optimal value than 47 for
-  // the inlined vector size (47 exists for backward compatibility).
-  kInlinedVectorSize = 47,
-
-  // Prefer copying blocks of at most this size, otherwise reference count.
-  kMaxBytesToCopy = 511
-};
-
-// Emits a fatal error "Unexpected node type: xyz" and aborts the program.
-[[noreturn]] void LogFatalNodeType(CordRep *rep);
-
-// Fast implementation of memmove for up to 15 bytes. This implementation is
-// safe for overlapping regions. If nullify_tail is true, the destination is
-// padded with '\0' up to 15 bytes.
-template <bool nullify_tail = false>
-inline void SmallMemmove(char *dst, const char *src, size_t n) {
-  if (n >= 8) {
-    assert(n <= 15);
-    uint64_t buf1;
-    uint64_t buf2;
-    memcpy(&buf1, src, 8);
-    memcpy(&buf2, src + n - 8, 8);
-    if (nullify_tail) {
-      memset(dst + 7, 0, 8);
-    }
-    // GCC 12 has a false-positive -Wstringop-overflow warning here.
-#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(12, 0)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#endif
-    memcpy(dst, &buf1, 8);
-    memcpy(dst + n - 8, &buf2, 8);
-#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(12, 0)
-#pragma GCC diagnostic pop
-#endif
-  } else if (n >= 4) {
-    uint32_t buf1;
-    uint32_t buf2;
-    memcpy(&buf1, src, 4);
-    memcpy(&buf2, src + n - 4, 4);
-    if (nullify_tail) {
-      memset(dst + 4, 0, 4);
-      memset(dst + 7, 0, 8);
-    }
-    memcpy(dst, &buf1, 4);
-    memcpy(dst + n - 4, &buf2, 4);
-  } else {
-    if (n != 0) {
-      dst[0] = src[0];
-      dst[n / 2] = src[n / 2];
-      dst[n - 1] = src[n - 1];
-    }
-    if (nullify_tail) {
-      memset(dst + 7, 0, 8);
-      memset(dst + n, 0, 8);
-    }
-  }
-}
-
-// Compact class for tracking the reference count and state flags for CordRep
-// instances.  Data is stored in an atomic int32_t for compactness and speed.
-class RefcountAndFlags {
-public:
-  constexpr RefcountAndFlags() : count_{kRefIncrement} {}
-  struct Immortal {};
-  explicit constexpr RefcountAndFlags(Immortal) : count_(kImmortalFlag) {}
-
-  // Increments the reference count. Imposes no memory ordering.
-  inline void Increment() {
-    count_.fetch_add(kRefIncrement, std::memory_order_relaxed);
-  }
-
-  // Asserts that the current refcount is greater than 0. If the refcount is
-  // greater than 1, decrements the reference count.
-  //
-  // Returns false if there are no references outstanding; true otherwise.
-  // Inserts barriers to ensure that state written before this method returns
-  // false will be visible to a thread that just observed this method returning
-  // false.  Always returns false when the immortal bit is set.
-  inline bool Decrement() {
-    int32_t refcount = count_.load(std::memory_order_acquire);
-    assert(refcount > 0 || refcount & kImmortalFlag);
-    return refcount != kRefIncrement &&
-           count_.fetch_sub(kRefIncrement, std::memory_order_acq_rel) !=
-               kRefIncrement;
-  }
-
-  // Same as Decrement but expect that refcount is greater than 1.
-  inline bool DecrementExpectHighRefcount() {
-    int32_t refcount =
-        count_.fetch_sub(kRefIncrement, std::memory_order_acq_rel);
-    assert(refcount > 0 || refcount & kImmortalFlag);
-    return refcount != kRefIncrement;
-  }
-
-  // Returns the current reference count using acquire semantics.
-  inline size_t Get() const {
-    return static_cast<size_t>(count_.load(std::memory_order_acquire) >>
-                               kNumFlags);
-  }
-
-  // Returns whether the atomic integer is 1.
-  // If the reference count is used in the conventional way, a
-  // reference count of 1 implies that the current thread owns the
-  // reference and no other thread shares it.
-  // This call performs the test for a reference count of one, and
-  // performs the memory barrier needed for the owning thread
-  // to act on the object, knowing that it has exclusive access to the
-  // object. Always returns false when the immortal bit is set.
-  inline bool IsOne() {
-    return count_.load(std::memory_order_acquire) == kRefIncrement;
-  }
-
-  bool IsImmortal() const {
-    return (count_.load(std::memory_order_relaxed) & kImmortalFlag) != 0;
-  }
-
-private:
-  // We reserve the bottom bit for flag.
-  // kImmortalBit indicates that this entity should never be collected; it is
-  // used for the StringConstant constructor to avoid collecting immutable
-  // constant cords.
-  enum Flags {
-    kNumFlags = 1,
-
-    kImmortalFlag = 0x1,
-    kRefIncrement = (1 << kNumFlags),
-  };
-
-  std::atomic<int32_t> count_;
-};
-
-// Various representations that we allow
-enum CordRepKind {
-  UNUSED_0 = 0,
-  SUBSTRING = 1,
-  CRC = 2,
-  BTREE = 3,
-  UNUSED_4 = 4,
-  EXTERNAL = 5,
-
-  // We have different tags for different sized flat arrays,
-  // starting with FLAT, and limited to MAX_FLAT_TAG. The below values map to an
-  // allocated range of 32 bytes to 256 KB. The current granularity is:
-  // - 8 byte granularity for flat sizes in [32 - 512]
-  // - 64 byte granularity for flat sizes in (512 - 8KiB]
-  // - 4KiB byte granularity for flat sizes in (8KiB, 256 KiB]
-  // If a new tag is needed in the future, then 'FLAT' and 'MAX_FLAT_TAG' should
-  // be adjusted as well as the Tag <---> Size mapping logic so that FLAT still
-  // represents the minimum flat allocation size. (32 bytes as of now).
-  FLAT = 6,
-  MAX_FLAT_TAG = 248
-};
-
-// There are various locations where we want to check if some rep is a 'plain'
-// data edge, i.e. an external or flat rep. By having FLAT == EXTERNAL + 1, we
-// can perform this check in a single branch as 'tag >= EXTERNAL'
-// Note that we can leave this optimization to the compiler. The compiler will
-// DTRT when it sees a condition like `tag == EXTERNAL || tag >= FLAT`.
-static_assert(FLAT == EXTERNAL + 1, "EXTERNAL and FLAT not consecutive");
-
-struct CordRep {
-  // Result from an `extract edge` operation. Contains the (possibly changed)
-  // tree node as well as the extracted edge, or {tree, nullptr} if no edge
-  // could be extracted.
-  // On success, the returned `tree` value is null if `extracted` was the only
-  // data edge inside the tree, a data edge if there were only two data edges in
-  // the tree, or the (possibly new / smaller) remaining tree with the extracted
-  // data edge removed.
-  struct ExtractResult {
-    CordRep *tree;
-    CordRep *extracted;
-  };
-
-  CordRep() = default;
-  constexpr CordRep(RefcountAndFlags::Immortal immortal, size_t l)
-      : length(l), refcount(immortal), tag(EXTERNAL), storage{} {}
-
-  // The following three fields have to be less than 32 bytes since
-  // that is the smallest supported flat node size. Some code optimizations rely
-  // on the specific layout of these fields. Notably: the non-trivial field
-  // `refcount` being preceded by `length`, and being tailed by POD data
-  // members only.
-  // LINT.IfChange
-  size_t length;
-  RefcountAndFlags refcount;
-  // If tag < FLAT, it represents CordRepKind and indicates the type of node.
-  // Otherwise, the node type is CordRepFlat and the tag is the encoded size.
-  uint8_t tag;
-
-  // `storage` provides two main purposes:
-  // - the starting point for FlatCordRep.Data() [flexible-array-member]
-  // - 3 bytes of additional storage for use by derived classes.
-  // The latter is used by CordrepConcat and CordRepBtree. CordRepConcat stores
-  // a 'depth' value in storage[0], and the (future) CordRepBtree class stores
-  // `height`, `begin` and `end` in the 3 entries. Otherwise we would need to
-  // allocate room for these in the derived class, as not all compilers reuse
-  // padding space from the base class (clang and gcc do, MSVC does not, etc)
-  uint8_t storage[3];
-  // LINT.ThenChange(cord_rep_btree.h:copy_raw)
-
-  // Returns true if this instance's tag matches the requested type.
-  constexpr bool IsSubstring() const { return tag == SUBSTRING; }
-  constexpr bool IsCrc() const { return tag == CRC; }
-  constexpr bool IsExternal() const { return tag == EXTERNAL; }
-  constexpr bool IsFlat() const { return tag >= FLAT; }
-  constexpr bool IsBtree() const { return tag == BTREE; }
-
-  inline CordRepSubstring *substring();
-  inline const CordRepSubstring *substring() const;
-  inline CordRepCrc *crc();
-  inline const CordRepCrc *crc() const;
-  inline CordRepExternal *external();
-  inline const CordRepExternal *external() const;
-  inline CordRepFlat *flat();
-  inline const CordRepFlat *flat() const;
-  inline CordRepBtree *btree();
-  inline const CordRepBtree *btree() const;
-
-  // --------------------------------------------------------------------
-  // Memory management
-
-  // Destroys the provided `rep`.
-  static void Destroy(CordRep *rep);
-
-  // Increments the reference count of `rep`.
-  // Requires `rep` to be a non-null pointer value.
-  static inline CordRep *Ref(CordRep *rep);
-
-  // Decrements the reference count of `rep`. Destroys rep if count reaches
-  // zero. Requires `rep` to be a non-null pointer value.
-  static inline void Unref(CordRep *rep);
-};
-
-struct CordRepSubstring : public CordRep {
-  size_t start; // Starting offset of substring in child
-  CordRep *child;
-
-  // Creates a substring on `child`, adopting a reference on `child`.
-  // Requires `child` to be either a flat or external node, and `pos` and `n` to
-  // form a non-empty partial sub range of `'child`, i.e.:
-  // `n > 0 && n < length && n + pos <= length`
-  static inline CordRepSubstring *Create(CordRep *child, size_t pos, size_t n);
-
-  // Creates a substring of `rep`. Does not adopt a reference on `rep`.
-  // Requires `IsDataEdge(rep) && n > 0 && pos + n <= rep->length`.
-  // If `n == rep->length` then this method returns `CordRep::Ref(rep)`
-  // If `rep` is a substring of a flat or external node, then this method will
-  // return a new substring of that flat or external node with `pos` adjusted
-  // with the original `start` position.
-  static inline CordRep *Substring(CordRep *rep, size_t pos, size_t n);
-};
-
-// Type for function pointer that will invoke the releaser function and also
-// delete the `CordRepExternalImpl` corresponding to the passed in
-// `CordRepExternal`.
-using ExternalReleaserInvoker = void (*)(CordRepExternal *);
-
-// External CordReps are allocated together with a type erased releaser. The
-// releaser is stored in the memory directly following the CordRepExternal.
-struct CordRepExternal : public CordRep {
-  CordRepExternal() = default;
-  explicit constexpr CordRepExternal(absl::string_view str)
-      : CordRep(RefcountAndFlags::Immortal{}, str.size()), base(str.data()),
-        releaser_invoker(nullptr) {}
-
-  const char *base;
-  // Pointer to function that knows how to call and destroy the releaser.
-  ExternalReleaserInvoker releaser_invoker;
-
-  // Deletes (releases) the external rep.
-  // Requires rep != nullptr and rep->IsExternal()
-  static void Delete(CordRep *rep);
-};
-
-// Use go/ranked-overloads for dispatching.
-struct Rank0 {};
-struct Rank1 : Rank0 {};
-
-template <typename Releaser, typename = ::absl::base_internal::invoke_result_t<
-                                 Releaser, absl::string_view>>
-void InvokeReleaser(Rank1, Releaser &&releaser, absl::string_view data) {
-  ::absl::base_internal::invoke(std::forward<Releaser>(releaser), data);
-}
-
-template <typename Releaser,
-          typename = ::absl::base_internal::invoke_result_t<Releaser>>
-void InvokeReleaser(Rank0, Releaser &&releaser, absl::string_view) {
-  ::absl::base_internal::invoke(std::forward<Releaser>(releaser));
-}
-
-// We use CompressedTuple so that we can benefit from EBCO.
-template <typename Releaser>
-struct CordRepExternalImpl
-    : public CordRepExternal,
-      public ::absl::container_internal::CompressedTuple<Releaser> {
-  // The extra int arg is so that we can avoid interfering with copy/move
-  // constructors while still benefitting from perfect forwarding.
-  template <typename T>
-  CordRepExternalImpl(T &&releaser, int)
-      : CordRepExternalImpl::CompressedTuple(std::forward<T>(releaser)) {
-    this->releaser_invoker = &Release;
-  }
-
-  ~CordRepExternalImpl() {
-    InvokeReleaser(Rank1{}, std::move(this->template get<0>()),
-                   absl::string_view(base, length));
-  }
-
-  static void Release(CordRepExternal *rep) {
-    delete static_cast<CordRepExternalImpl *>(rep);
-  }
-};
-
-inline CordRepSubstring *CordRepSubstring::Create(CordRep *child, size_t pos,
-                                                  size_t n) {
-  assert(child != nullptr);
-  assert(n > 0);
-  assert(n < child->length);
-  assert(pos < child->length);
-  assert(n <= child->length - pos);
-
-  // Move to strategical places inside the Cord logic and make this an assert.
-  if (ABSL_PREDICT_FALSE(!(child->IsExternal() || child->IsFlat()))) {
-    LogFatalNodeType(child);
-  }
-
-  CordRepSubstring *rep = new CordRepSubstring();
-  rep->length = n;
-  rep->tag = SUBSTRING;
-  rep->start = pos;
-  rep->child = child;
-  return rep;
-}
-
-inline CordRep *CordRepSubstring::Substring(CordRep *rep, size_t pos,
-                                            size_t n) {
-  assert(rep != nullptr);
-  assert(n != 0);
-  assert(pos < rep->length);
-  assert(n <= rep->length - pos);
-  if (n == rep->length)
-    return CordRep::Ref(rep);
-  if (rep->IsSubstring()) {
-    pos += rep->substring()->start;
-    rep = rep->substring()->child;
-  }
-  CordRepSubstring *substr = new CordRepSubstring();
-  substr->length = n;
-  substr->tag = SUBSTRING;
-  substr->start = pos;
-  substr->child = CordRep::Ref(rep);
-  return substr;
-}
-
-inline void CordRepExternal::Delete(CordRep *rep) {
-  assert(rep != nullptr && rep->IsExternal());
-  auto *rep_external = static_cast<CordRepExternal *>(rep);
-  assert(rep_external->releaser_invoker != nullptr);
-  rep_external->releaser_invoker(rep_external);
-}
-
-template <typename Str> struct ConstInitExternalStorage {
-  ABSL_CONST_INIT static CordRepExternal value;
-};
-
-template <typename Str>
-ABSL_CONST_INIT
-    CordRepExternal ConstInitExternalStorage<Str>::value(Str::value);
-
-enum {
-  kMaxInline = 15,
-};
-
-constexpr char GetOrNull(absl::string_view data, size_t pos) {
-  return pos < data.size() ? data[pos] : '\0';
-}
-
-// We store cordz_info as 64 bit pointer value in little endian format. This
-// guarantees that the least significant byte of cordz_info matches the first
-// byte of the inline data representation in `data`, which holds the inlined
-// size or the 'is_tree' bit.
-using cordz_info_t = int64_t;
-
-// Assert that the `cordz_info` pointer value perfectly overlaps the last half
-// of `data` and can hold a pointer value.
-static_assert(sizeof(cordz_info_t) * 2 == kMaxInline + 1, "");
-static_assert(sizeof(cordz_info_t) >= sizeof(intptr_t), "");
-
-// LittleEndianByte() creates a little endian representation of 'value', i.e.:
-// a little endian value where the first byte in the host's representation
-// holds 'value`, with all other bytes being 0.
-static constexpr cordz_info_t LittleEndianByte(unsigned char value) {
-#if defined(ABSL_IS_BIG_ENDIAN)
-  return static_cast<cordz_info_t>(value) << ((sizeof(cordz_info_t) - 1) * 8);
-#else
-  return value;
-#endif
-}
-
-class InlineData {
-public:
-  // DefaultInitType forces the use of the default initialization constructor.
-  enum DefaultInitType { kDefaultInit };
-
-  // kNullCordzInfo holds the little endian representation of intptr_t(1)
-  // This is the 'null' / initial value of 'cordz_info'. The null value
-  // is specifically big endian 1 as with 64-bit pointers, the last
-  // byte of cordz_info overlaps with the last byte holding the tag.
-  static constexpr cordz_info_t kNullCordzInfo = LittleEndianByte(1);
-
-  // kTagOffset contains the offset of the control byte / tag. This constant is
-  // intended mostly for debugging purposes: do not remove this constant as it
-  // is actively inspected and used by gdb pretty printing code.
-  static constexpr size_t kTagOffset = 0;
-
-  // Implement `~InlineData()` conditionally: we only need this destructor to
-  // unpoison poisoned instances under *SAN, and it will only compile correctly
-  // if the current compiler supports `absl::is_constant_evaluated()`.
-#ifdef ABSL_INTERNAL_CORD_HAVE_SANITIZER
-  ~InlineData() noexcept { unpoison(); }
-#endif
-
-  constexpr InlineData() noexcept { poison_this(); }
-
-  explicit InlineData(DefaultInitType) noexcept : rep_(kDefaultInit) {
-    poison_this();
-  }
-
-  explicit InlineData(CordRep *rep) noexcept : rep_(rep) {
-    ABSL_ASSERT(rep != nullptr);
-  }
-
-  // Explicit constexpr constructor to create a constexpr InlineData
-  // value. Creates an inlined SSO value if `rep` is null, otherwise
-  // creates a tree instance value.
-  constexpr InlineData(absl::string_view sv, CordRep *rep) noexcept
-      : rep_(rep ? Rep(rep) : Rep(sv)) {
-    poison();
-  }
-
-  constexpr InlineData(const InlineData &rhs) noexcept;
-  InlineData &operator=(const InlineData &rhs) noexcept;
-  friend void swap(InlineData &lhs, InlineData &rhs) noexcept;
-
-  friend bool operator==(const InlineData &lhs, const InlineData &rhs) {
-#ifdef ABSL_INTERNAL_CORD_HAVE_SANITIZER
-    const Rep l = lhs.rep_.SanitizerSafeCopy();
-    const Rep r = rhs.rep_.SanitizerSafeCopy();
-    return memcmp(&l, &r, sizeof(l)) == 0;
-#else
-    return memcmp(&lhs, &rhs, sizeof(lhs)) == 0;
-#endif
-  }
-  friend bool operator!=(const InlineData &lhs, const InlineData &rhs) {
-    return !operator==(lhs, rhs);
-  }
-
-  // Poisons the unused inlined SSO data if the current instance
-  // is inlined, else un-poisons the entire instance.
-  constexpr void poison();
-
-  // Un-poisons this instance.
-  constexpr void unpoison();
-
-  // Poisons the current instance. This is used on default initialization.
-  constexpr void poison_this();
-
-  // Returns true if the current instance is empty.
-  // The 'empty value' is an inlined data value of zero length.
-  bool is_empty() const { return rep_.tag() == 0; }
-
-  // Returns true if the current instance holds a tree value.
-  bool is_tree() const { return (rep_.tag() & 1) != 0; }
-
-  // Returns true if the current instance holds a cordz_info value.
-  // Requires the current instance to hold a tree value.
-  bool is_profiled() const {
-    assert(is_tree());
-    return rep_.cordz_info() != kNullCordzInfo;
-  }
-
-  // Returns true if either of the provided instances hold a cordz_info value.
-  // This method is more efficient than the equivalent `data1.is_profiled() ||
-  // data2.is_profiled()`. Requires both arguments to hold a tree.
-  static bool is_either_profiled(const InlineData &data1,
-                                 const InlineData &data2) {
-    assert(data1.is_tree() && data2.is_tree());
-    return (data1.rep_.cordz_info() | data2.rep_.cordz_info()) !=
-           kNullCordzInfo;
-  }
-
-  // Returns the cordz_info sampling instance for this instance, or nullptr
-  // if the current instance is not sampled and does not have CordzInfo data.
-  // Requires the current instance to hold a tree value.
-  CordzInfo *cordz_info() const {
-    assert(is_tree());
-    intptr_t info = static_cast<intptr_t>(absl::little_endian::ToHost64(
-        static_cast<uint64_t>(rep_.cordz_info())));
-    assert(info & 1);
-    return reinterpret_cast<CordzInfo *>(info - 1);
-  }
-
-  // Sets the current cordz_info sampling instance for this instance, or nullptr
-  // if the current instance is not sampled and does not have CordzInfo data.
-  // Requires the current instance to hold a tree value.
-  void set_cordz_info(CordzInfo *cordz_info) {
-    assert(is_tree());
-    uintptr_t info = reinterpret_cast<uintptr_t>(cordz_info) | 1;
-    rep_.set_cordz_info(
-        static_cast<cordz_info_t>(absl::little_endian::FromHost64(info)));
-  }
-
-  // Resets the current cordz_info to null / empty.
-  void clear_cordz_info() {
-    assert(is_tree());
-    rep_.set_cordz_info(kNullCordzInfo);
-  }
-
-  // Returns a read only pointer to the character data inside this instance.
-  // Requires the current instance to hold inline data.
-  const char *as_chars() const {
-    assert(!is_tree());
-    return rep_.as_chars();
-  }
-
-  // Returns a mutable pointer to the character data inside this instance.
-  // Should be used for 'write only' operations setting an inlined value.
-  // Applications can set the value of inlined data either before or after
-  // setting the inlined size, i.e., both of the below are valid:
-  //
-  //   // Set inlined data and inline size
-  //   memcpy(data_.as_chars(), data, size);
-  //   data_.set_inline_size(size);
-  //
-  //   // Set inlined size and inline data
-  //   data_.set_inline_size(size);
-  //   memcpy(data_.as_chars(), data, size);
-  //
-  // It's an error to read from the returned pointer without a preceding write
-  // if the current instance does not hold inline data, i.e.: is_tree() == true.
-  char *as_chars() { return rep_.as_chars(); }
-
-  // Returns the tree value of this value.
-  // Requires the current instance to hold a tree value.
-  CordRep *as_tree() const {
-    assert(is_tree());
-    return rep_.tree();
-  }
-
-  void set_inline_data(const char *data, size_t n) {
-    ABSL_ASSERT(n <= kMaxInline);
-    unpoison();
-    rep_.set_tag(static_cast<int8_t>(n << 1));
-    SmallMemmove<true>(rep_.as_chars(), data, n);
-    poison();
-  }
-
-  void copy_max_inline_to(char *dst) const {
-    assert(!is_tree());
-    memcpy(dst, rep_.SanitizerSafeCopy().as_chars(), kMaxInline);
-  }
-
-  // Initialize this instance to holding the tree value `rep`,
-  // initializing the cordz_info to null, i.e.: 'not profiled'.
-  void make_tree(CordRep *rep) {
-    unpoison();
-    rep_.make_tree(rep);
-  }
-
-  // Set the tree value of this instance to 'rep`.
-  // Requires the current instance to already hold a tree value.
-  // Does not affect the value of cordz_info.
-  void set_tree(CordRep *rep) {
-    assert(is_tree());
-    rep_.set_tree(rep);
-  }
-
-  // Returns the size of the inlined character data inside this instance.
-  // Requires the current instance to hold inline data.
-  size_t inline_size() const { return rep_.inline_size(); }
-
-  // Sets the size of the inlined character data inside this instance.
-  // Requires `size` to be <= kMaxInline.
-  // See the documentation on 'as_chars()' for more information and examples.
-  void set_inline_size(size_t size) {
-    unpoison();
-    rep_.set_inline_size(size);
-    poison();
-  }
-
-  // Compares 'this' inlined data  with rhs. The comparison is a straightforward
-  // lexicographic comparison. `Compare()` returns values as follows:
-  //
-  //   -1  'this' InlineData instance is smaller
-  //    0  the InlineData instances are equal
-  //    1  'this' InlineData instance larger
-  int Compare(const InlineData &rhs) const {
-    return Compare(rep_.SanitizerSafeCopy(), rhs.rep_.SanitizerSafeCopy());
-  }
-
-private:
-  struct Rep {
-    // See cordz_info_t for forced alignment and size of `cordz_info` details.
-    struct AsTree {
-      explicit constexpr AsTree(absl::cord_internal::CordRep *tree)
-          : rep(tree) {}
-      cordz_info_t cordz_info = kNullCordzInfo;
-      absl::cord_internal::CordRep *rep;
-    };
-
-    explicit Rep(DefaultInitType) {}
-    constexpr Rep() : data{0} {}
-    constexpr Rep(const Rep &) = default;
-    constexpr Rep &operator=(const Rep &) = default;
-
-    explicit constexpr Rep(CordRep *rep) : as_tree(rep) {}
-
-    explicit constexpr Rep(absl::string_view chars)
-        : data{static_cast<char>((chars.size() << 1)),
-               GetOrNull(chars, 0),
-               GetOrNull(chars, 1),
-               GetOrNull(chars, 2),
-               GetOrNull(chars, 3),
-               GetOrNull(chars, 4),
-               GetOrNull(chars, 5),
-               GetOrNull(chars, 6),
-               GetOrNull(chars, 7),
-               GetOrNull(chars, 8),
-               GetOrNull(chars, 9),
-               GetOrNull(chars, 10),
-               GetOrNull(chars, 11),
-               GetOrNull(chars, 12),
-               GetOrNull(chars, 13),
-               GetOrNull(chars, 14)} {}
-
-#ifdef ABSL_INTERNAL_CORD_HAVE_SANITIZER
-    // Break compiler optimization for cases when value is allocated on the
-    // stack. Compiler assumes that the the variable is fully accessible
-    // regardless of our poisoning.
-    // Missing report: https://github.com/llvm/llvm-project/issues/100640
-    const Rep *self() const {
-      const Rep *volatile ptr = this;
-      return ptr;
-    }
-    Rep *self() {
-      Rep *volatile ptr = this;
-      return ptr;
-    }
-#else
-    constexpr const Rep *self() const { return this; }
-    constexpr Rep *self() { return this; }
-#endif
-
-    // Disable sanitizer as we must always be able to read `tag`.
-    ABSL_CORD_INTERNAL_NO_SANITIZE
-    int8_t tag() const { return reinterpret_cast<const int8_t *>(this)[0]; }
-    void set_tag(int8_t rhs) { reinterpret_cast<int8_t *>(self())[0] = rhs; }
-
-    char *as_chars() { return self()->data + 1; }
-    const char *as_chars() const { return self()->data + 1; }
-
-    bool is_tree() const { return (self()->tag() & 1) != 0; }
-
-    size_t inline_size() const {
-      ABSL_ASSERT(!self()->is_tree());
-      return static_cast<size_t>(self()->tag()) >> 1;
-    }
-
-    void set_inline_size(size_t size) {
-      ABSL_ASSERT(size <= kMaxInline);
-      self()->set_tag(static_cast<int8_t>(size << 1));
-    }
-
-    CordRep *tree() const { return self()->as_tree.rep; }
-    void set_tree(CordRep *rhs) { self()->as_tree.rep = rhs; }
-
-    cordz_info_t cordz_info() const { return self()->as_tree.cordz_info; }
-    void set_cordz_info(cordz_info_t rhs) { self()->as_tree.cordz_info = rhs; }
-
-    void make_tree(CordRep *tree) {
-      self()->as_tree.rep = tree;
-      self()->as_tree.cordz_info = kNullCordzInfo;
-    }
-
-#ifdef ABSL_INTERNAL_CORD_HAVE_SANITIZER
-    constexpr Rep SanitizerSafeCopy() const {
-      if (!absl::is_constant_evaluated()) {
-        Rep res;
-        if (is_tree()) {
-          res = *this;
-        } else {
-          res.set_tag(tag());
-          memcpy(res.as_chars(), as_chars(), inline_size());
-        }
-        return res;
-      } else {
-        return *this;
-      }
-    }
-#else
-    constexpr const Rep &SanitizerSafeCopy() const { return *this; }
-#endif
-
-    // If the data has length <= kMaxInline, we store it in `data`, and
-    // store the size in the first char of `data` shifted left + 1.
-    // Else we store it in a tree and store a pointer to that tree in
-    // `as_tree.rep` with a tagged pointer to make `tag() & 1` non zero.
-    union {
-      char data[kMaxInline + 1];
-      AsTree as_tree;
-    };
-
-    // TODO(b/145829486): see swap(InlineData, InlineData) for more info.
-    inline void SwapValue(Rep rhs, Rep &refrhs) {
-      memcpy(&refrhs, this, sizeof(*this));
-      memcpy(this, &rhs, sizeof(*this));
-    }
-  };
-
-  // Private implementation of `Compare()`
-  static inline int Compare(const Rep &lhs, const Rep &rhs) {
-    uint64_t x, y;
-    memcpy(&x, lhs.as_chars(), sizeof(x));
-    memcpy(&y, rhs.as_chars(), sizeof(y));
-    if (x == y) {
-      memcpy(&x, lhs.as_chars() + 7, sizeof(x));
-      memcpy(&y, rhs.as_chars() + 7, sizeof(y));
-      if (x == y) {
-        if (lhs.inline_size() == rhs.inline_size())
-          return 0;
-        return lhs.inline_size() < rhs.inline_size() ? -1 : 1;
-      }
-    }
-    x = absl::big_endian::FromHost64(x);
-    y = absl::big_endian::FromHost64(y);
-    return x < y ? -1 : 1;
-  }
-
-  Rep rep_;
-};
-
-static_assert(sizeof(InlineData) == kMaxInline + 1, "");
-
-#ifdef ABSL_INTERNAL_CORD_HAVE_SANITIZER
-
-constexpr InlineData::InlineData(const InlineData &rhs) noexcept
-    : rep_(rhs.rep_.SanitizerSafeCopy()) {
-  poison();
-}
-
-inline InlineData &InlineData::operator=(const InlineData &rhs) noexcept {
-  unpoison();
-  rep_ = rhs.rep_.SanitizerSafeCopy();
-  poison();
-  return *this;
-}
-
-constexpr void InlineData::poison_this() {
-  if (!absl::is_constant_evaluated()) {
-    container_internal::SanitizerPoisonObject(this);
-  }
-}
-
-constexpr void InlineData::unpoison() {
-  if (!absl::is_constant_evaluated()) {
-    container_internal::SanitizerUnpoisonObject(this);
-  }
-}
-
-constexpr void InlineData::poison() {
-  if (!absl::is_constant_evaluated()) {
-    if (is_tree()) {
-      container_internal::SanitizerUnpoisonObject(this);
-    } else if (const size_t size = inline_size()) {
-      if (size < kMaxInline) {
-        const char *end = rep_.as_chars() + size;
-        container_internal::SanitizerPoisonMemoryRegion(end, kMaxInline - size);
-      }
-    } else {
-      container_internal::SanitizerPoisonObject(this);
-    }
-  }
-}
-
-#else // ABSL_INTERNAL_CORD_HAVE_SANITIZER
-
-constexpr InlineData::InlineData(const InlineData &) noexcept = default;
-inline InlineData &InlineData::operator=(const InlineData &) noexcept = default;
-
-constexpr void InlineData::poison_this() {}
-constexpr void InlineData::unpoison() {}
-constexpr void InlineData::poison() {}
-
-#endif // ABSL_INTERNAL_CORD_HAVE_SANITIZER
-
-inline CordRepSubstring *CordRep::substring() {
-  assert(IsSubstring());
-  return static_cast<CordRepSubstring *>(this);
-}
-
-inline const CordRepSubstring *CordRep::substring() const {
-  assert(IsSubstring());
-  return static_cast<const CordRepSubstring *>(this);
-}
-
-inline CordRepExternal *CordRep::external() {
-  assert(IsExternal());
-  return static_cast<CordRepExternal *>(this);
-}
-
-inline const CordRepExternal *CordRep::external() const {
-  assert(IsExternal());
-  return static_cast<const CordRepExternal *>(this);
-}
-
-inline CordRep *CordRep::Ref(CordRep *rep) {
-  // ABSL_ASSUME is a workaround for
-  // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105585
-  ABSL_ASSUME(rep != nullptr);
-  rep->refcount.Increment();
-  return rep;
-}
-
-inline void CordRep::Unref(CordRep *rep) {
-  assert(rep != nullptr);
-  // Expect refcount to be 0. Avoiding the cost of an atomic decrement should
-  // typically outweigh the cost of an extra branch checking for ref == 1.
-  if (ABSL_PREDICT_FALSE(!rep->refcount.DecrementExpectHighRefcount())) {
-    Destroy(rep);
-  }
-}
-
-inline void swap(InlineData &lhs, InlineData &rhs) noexcept {
-  lhs.unpoison();
-  rhs.unpoison();
-  // TODO(b/145829486): `std::swap(lhs.rep_, rhs.rep_)` results in bad codegen
-  // on clang, spilling the temporary swap value on the stack. Since `Rep` is
-  // trivial, we can make clang DTRT by calling a hand-rolled `SwapValue` where
-  // we pass `rhs` both by value (register allocated) and by reference. The IR
-  // then folds and inlines correctly into an optimized swap without spill.
-  lhs.rep_.SwapValue(rhs.rep_, rhs.rep_);
-  rhs.poison();
-  lhs.poison();
-}
-
-} // namespace cord_internal
-
-ABSL_NAMESPACE_END
-} // namespace absl
-#endif // ABSL_STRINGS_INTERNAL_CORD_INTERNAL_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_rep_btree.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_rep_btree.h
deleted file mode 100644
index 6962754fd1..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_rep_btree.h
+++ /dev/null
@@ -1,957 +0,0 @@
-// Copyright 2021 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_H_
-#define ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_H_
-
-#include <cassert>
-#include <cstdint>
-#include <iosfwd>
-
-#include "absl/base/config.h"
-#include "absl/base/internal/raw_logging.h"
-#include "absl/base/optimization.h"
-#include "absl/strings/internal/cord_data_edge.h"
-#include "absl/strings/internal/cord_internal.h"
-#include "absl/strings/internal/cord_rep_flat.h"
-#include "absl/strings/string_view.h"
-#include "absl/types/span.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// `SetCordBtreeExhaustiveValidation()` can be set to force exhaustive
-// validation in debug assertions, and code that calls `IsValid()`
-// explicitly. By default, assertions should be relatively cheap and
-// AssertValid() can easily lead to O(n^2) complexity as recursive / full tree
-// validation is O(n).
-void SetCordBtreeExhaustiveValidation(bool do_exaustive_validation);
-bool IsCordBtreeExhaustiveValidationEnabled();
-
-class CordRepBtreeNavigator;
-
-// CordRepBtree is as the name implies a btree implementation of a Cordrep tree.
-// Data is stored at the leaf level only, non leaf nodes contain down pointers
-// only. Allowed types of data edges are FLAT, EXTERNAL and SUBSTRINGs of FLAT
-// or EXTERNAL nodes. The implementation allows for data to be added to either
-// end of the tree only, it does not provide any 'insert' logic. This has the
-// benefit that we can expect good fill ratios: all nodes except the outer
-// 'legs' will have 100% fill ratios for trees built using Append/Prepend
-// methods. Merged trees will typically have a fill ratio well above 50% as in a
-// similar fashion, one side of the merged tree will typically have a 100% fill
-// ratio, and the 'open' end will average 50%. All operations are O(log(n)) or
-// better, and the tree never needs balancing.
-//
-// All methods accepting a CordRep* or CordRepBtree* adopt a reference on that
-// input unless explicitly stated otherwise. All functions returning a CordRep*
-// or CordRepBtree* instance transfer a reference back to the caller.
-// Simplified, callers both 'donate' and 'consume' a reference count on each
-// call, simplifying the API. An example of building a tree:
-//
-//   CordRepBtree* tree = CordRepBtree::Create(MakeFlat("Hello"));
-//   tree = CordRepBtree::Append(tree, MakeFlat("world"));
-//
-// In the above example, all inputs are consumed, making each call affecting
-// `tree` reference count neutral. The returned `tree` value can be different
-// from the input if the input is shared with other threads, or if the tree
-// grows in height, but callers typically never have to concern themselves with
-// that and trust that all methods DTRT at all times.
-class CordRepBtree : public CordRep {
-public:
-  // EdgeType identifies `front` and `back` enum values.
-  // Various implementations in CordRepBtree such as `Add` and `Edge` are
-  // generic and templated on operating on either of the boundary edges.
-  // For more information on the possible edges contained in a CordRepBtree
-  // instance see the documentation for `edges_`.
-  enum class EdgeType { kFront, kBack };
-
-  // Convenience constants into `EdgeType`
-  static constexpr EdgeType kFront = EdgeType::kFront;
-  static constexpr EdgeType kBack = EdgeType::kBack;
-
-  // Maximum number of edges: based on experiments and performance data, we can
-  // pick suitable values resulting in optimum cacheline aligned values. The
-  // preferred values are based on 64-bit systems where we aim to align this
-  // class onto 64 bytes, i.e.:  6 = 64 bytes, 14 = 128 bytes, etc.
-  // TODO(b/192061034): experiment with alternative sizes.
-  static constexpr size_t kMaxCapacity = 6;
-
-  // Reasonable maximum height of the btree. We can expect a fill ratio of at
-  // least 50%: trees are always expanded at the front or back. Concatenating
-  // trees will then typically fold at the top most node, where the lower nodes
-  // are at least at capacity on one side of joined inputs. At a lower fill
-  // rate of 4 edges per node, we have capacity for ~16 million leaf nodes.
-  // We will fail / abort if an application ever exceeds this height, which
-  // should be extremely rare (near impossible) and be an indication of an
-  // application error: we do not assume it reasonable for any application to
-  // operate correctly with such monster trees.
-  // Another compelling reason for the number `12` is that any contextual stack
-  // required for navigation or insertion requires 12 words and 12 bytes, which
-  // fits inside 2 cache lines with some room to spare, and is reasonable as a
-  // local stack variable compared to Cord's current near 400 bytes stack use.
-  // The maximum `height` value of a node is then `kMaxDepth - 1` as node height
-  // values start with a value of 0 for leaf nodes.
-  static constexpr size_t kMaxDepth = 12;
-  // See comments on height() for why this is an int and not a size_t.
-  static constexpr int kMaxHeight = static_cast<int>(kMaxDepth - 1);
-
-  // `Action` defines the action for unwinding changes done at the btree's leaf
-  // level that need to be propagated up to the parent node(s). Each operation
-  // on a node has an effect / action defined as follows:
-  // - kSelf
-  //   The operation (add / update, etc) was performed directly on the node as
-  //   the node is private to the current thread (i.e.: not shared directly or
-  //   indirectly through a refcount > 1). Changes can be propagated directly to
-  //   all parent nodes as all parent nodes are also then private to the current
-  //   thread.
-  // - kCopied
-  //   The operation (add / update, etc) was performed on a copy of the original
-  //   node, as the node is (potentially) directly or indirectly shared with
-  //   other threads. Changes need to be propagated into the parent nodes where
-  //   the old down pointer must be unreffed and replaced with this new copy.
-  //   Such changes to parent nodes may themselves require a copy if the parent
-  //   node is also shared. A kCopied action can propagate all the way to the
-  //   top node where we then must unref the `tree` input provided by the
-  //   caller, and return the new copy.
-  // - kPopped
-  //   The operation (typically add) could not be satisfied due to insufficient
-  //   capacity in the targeted node, and a new 'leg' was created that needs to
-  //   be added into the parent node. For example, adding a FLAT inside a leaf
-  //   node that is at capacity will create a new leaf node containing that
-  //   FLAT, that needs to be 'popped' up the btree. Such 'pop' actions can
-  //   cascade up the tree if parent nodes are also at capacity. A 'Popped'
-  //   action propagating all the way to the top of the tree will result in
-  //   the tree becoming one level higher than the current tree through a final
-  //   `CordRepBtree::New(tree, popped)` call, resulting in a new top node
-  //   referencing the old tree and the new (fully popped upwards) 'leg'.
-  enum Action { kSelf, kCopied, kPopped };
-
-  // Result of an operation on a node. See the `Action` enum for details.
-  struct OpResult {
-    CordRepBtree *tree;
-    Action action;
-  };
-
-  // Return value of the CopyPrefix and CopySuffix methods which can
-  // return a node or data edge at any height inside the tree.
-  // A height of 0 defines the lowest (leaf) node, a height of -1 identifies
-  // `edge` as being a plain data node: EXTERNAL / FLAT or SUBSTRING thereof.
-  struct CopyResult {
-    CordRep *edge;
-    int height;
-  };
-
-  // Logical position inside a node:
-  // - index: index of the edge.
-  // - n: size or offset value depending on context.
-  struct Position {
-    size_t index;
-    size_t n;
-  };
-
-  // Creates a btree from the given input. Adopts a ref of `rep`.
-  // If the input `rep` is itself a btree, i.e., `IsBtree()`, then this
-  // function immediately returns `rep->btree()`. If the input is a valid data
-  // edge (see IsDataEdge()), then a new leaf node is returned containing `rep`
-  // as the sole data edge. Else, the input is assumed to be a (legacy) concat
-  // tree, and the input is consumed and transformed into a btree().
-  static CordRepBtree *Create(CordRep *rep);
-
-  // Destroys the provided tree. Should only be called by cord internal API's,
-  // typically after a ref_count.Decrement() on the last reference count.
-  static void Destroy(CordRepBtree *tree);
-
-  // Destruction
-  static void Delete(CordRepBtree *tree) { delete tree; }
-
-  // Use CordRep::Unref() as we overload for absl::Span<CordRep* const>.
-  using CordRep::Unref;
-
-  // Unrefs all edges in `edges` which are assumed to be 'likely one'.
-  static void Unref(absl::Span<CordRep *const> edges);
-
-  // Appends / Prepends an existing CordRep instance to this tree.
-  // The below methods accept three types of input:
-  // 1) `rep` is a data node (See `IsDataNode` for valid data edges).
-  // `rep` is appended or prepended to this tree 'as is'.
-  // 2) `rep` is a BTREE.
-  // `rep` is merged into `tree` respecting the Append/Prepend order.
-  // 3) `rep` is some other (legacy) type.
-  // `rep` is converted in place and added to `tree`
-  // Requires `tree` and `rep` to be not null.
-  static CordRepBtree *Append(CordRepBtree *tree, CordRep *rep);
-  static CordRepBtree *Prepend(CordRepBtree *tree, CordRep *rep);
-
-  // Append/Prepend the data in `data` to this tree.
-  // The `extra` parameter defines how much extra capacity should be allocated
-  // for any additional FLAT being allocated. This is an optimization hint from
-  // the caller. For example, a caller may need to add 2 string_views of data
-  // "abc" and "defghi" which are not consecutive. The caller can in this case
-  // invoke `AddData(tree, "abc", 6)`, and any newly added flat is allocated
-  // where possible with at least 6 bytes of extra capacity beyond `length`.
-  // This helps avoiding data getting fragmented over multiple flats.
-  // There is no limit on the size of `data`. If `data` can not be stored inside
-  // a single flat, then the function will iteratively add flats until all data
-  // has been consumed and appended or prepended to the tree.
-  static CordRepBtree *Append(CordRepBtree *tree, string_view data,
-                              size_t extra = 0);
-  static CordRepBtree *Prepend(CordRepBtree *tree, string_view data,
-                               size_t extra = 0);
-
-  // Returns a new tree, containing `n` bytes of data from this instance
-  // starting at offset `offset`. Where possible, the returned tree shares
-  // (re-uses) data edges and nodes with this instance to minimize the
-  // combined memory footprint of both trees.
-  // Requires `offset + n <= length`. Returns `nullptr` if `n` is zero.
-  CordRep *SubTree(size_t offset, size_t n);
-
-  // Removes `n` trailing bytes from `tree`, and returns the resulting tree
-  // or data edge. Returns `tree` if n is zero, and nullptr if n == length.
-  // This function is logically identical to:
-  //   result = tree->SubTree(0, tree->length - n);
-  //   Unref(tree);
-  //   return result;
-  // However, the actual implementation will as much as possible perform 'in
-  // place' modifications on the tree on all nodes and edges that are mutable.
-  // For example, in a fully privately owned tree with the last edge being a
-  // flat of length 12, RemoveSuffix(1) will simply set the length of that data
-  // edge to 11, and reduce the length of all nodes on the edge path by 1.
-  static CordRep *RemoveSuffix(CordRepBtree *tree, size_t n);
-
-  // Returns the character at the given offset.
-  char GetCharacter(size_t offset) const;
-
-  // Returns true if this node holds a single data edge, and if so, sets
-  // `fragment` to reference the contained data. `fragment` is an optional
-  // output parameter and allowed to be null.
-  bool IsFlat(absl::string_view *fragment) const;
-
-  // Returns true if the data of `n` bytes starting at offset `offset`
-  // is contained in a single data edge, and if so, sets fragment to reference
-  // the contained data. `fragment` is an optional output parameter and allowed
-  // to be null.
-  bool IsFlat(size_t offset, size_t n, absl::string_view *fragment) const;
-
-  // Returns a span (mutable range of bytes) of up to `size` bytes into the
-  // last FLAT data edge inside this tree under the following conditions:
-  // - none of the nodes down into the FLAT node are shared.
-  // - the last data edge in this tree is a non-shared FLAT.
-  // - the referenced FLAT has additional capacity available.
-  // If all these conditions are met, a non-empty span is returned, and the
-  // length of the flat node and involved tree nodes have been increased by
-  // `span.length()`. The caller is responsible for immediately assigning values
-  // to all uninitialized data reference by the returned span.
-  // Requires `this->refcount.IsOne()`: this function forces the caller to do
-  // this fast path check on the top level node, as this is the most commonly
-  // shared node of a cord tree.
-  Span<char> GetAppendBuffer(size_t size);
-
-  // Extracts the right-most data edge from this tree iff:
-  // - the tree and all internal edges to the right-most node are not shared.
-  // - the right-most node is a FLAT node and not shared.
-  // - the right-most node has at least the desired extra capacity.
-  //
-  // Returns {tree, nullptr} if any of the above conditions are not met.
-  // This method effectively removes data from the tree. The intent of this
-  // method is to allow applications appending small string data to use
-  // pre-existing capacity, and add the modified rep back to the tree.
-  //
-  // Simplified such code would look similar to this:
-  //   void MyTreeBuilder::Append(string_view data) {
-  //     ExtractResult result = CordRepBtree::ExtractAppendBuffer(tree_, 1);
-  //     if (CordRep* rep = result.extracted) {
-  //       size_t available = rep->Capacity() - rep->length;
-  //       size_t n = std::min(data.size(), n);
-  //       memcpy(rep->Data(), data.data(), n);
-  //       rep->length += n;
-  //       data.remove_prefix(n);
-  //       if (!result.tree->IsBtree()) {
-  //         tree_ = CordRepBtree::Create(result.tree);
-  //       }
-  //       tree_ = CordRepBtree::Append(tree_, rep);
-  //     }
-  //     ...
-  //     // Remaining edge in `result.tree`.
-  //   }
-  static ExtractResult ExtractAppendBuffer(CordRepBtree *tree,
-                                           size_t extra_capacity = 1);
-
-  // Returns the `height` of the tree. The height of a tree is limited to
-  // kMaxHeight. `height` is implemented as an `int` as in some places we
-  // use negative (-1) values for 'data edges'.
-  int height() const { return static_cast<int>(storage[0]); }
-
-  // Properties: begin, back, end, front/back boundary indexes.
-  size_t begin() const { return static_cast<size_t>(storage[1]); }
-  size_t back() const { return static_cast<size_t>(storage[2]) - 1; }
-  size_t end() const { return static_cast<size_t>(storage[2]); }
-  size_t index(EdgeType edge) const {
-    return edge == kFront ? begin() : back();
-  }
-
-  // Properties: size and capacity.
-  // `capacity` contains the current capacity of this instance, where
-  // `kMaxCapacity` contains the maximum capacity of a btree node.
-  // For now, `capacity` and `kMaxCapacity` return the same value, but this may
-  // change in the future if we see benefit in dynamically sizing 'small' nodes
-  // to 'large' nodes for large data trees.
-  size_t size() const { return end() - begin(); }
-  size_t capacity() const { return kMaxCapacity; }
-
-  // Edge access
-  inline CordRep *Edge(size_t index) const;
-  inline CordRep *Edge(EdgeType edge_type) const;
-  inline absl::Span<CordRep *const> Edges() const;
-  inline absl::Span<CordRep *const> Edges(size_t begin, size_t end) const;
-
-  // Returns reference to the data edge at `index`.
-  // Requires this instance to be a leaf node, and `index` to be valid index.
-  inline absl::string_view Data(size_t index) const;
-
-  // Diagnostics: returns true if `tree` is valid and internally consistent.
-  // If `shallow` is false, then the provided top level node and all child nodes
-  // below it are recursively checked. If `shallow` is true, only the provided
-  // node in `tree` and the cumulative length, type and height of the direct
-  // child nodes of `tree` are checked. The value of `shallow` is ignored if the
-  // internal `cord_btree_exhaustive_validation` diagnostics variable is true,
-  // in which case the performed validations works as if `shallow` were false.
-  // This function is intended for debugging and testing purposes only.
-  static bool IsValid(const CordRepBtree *tree, bool shallow = false);
-
-  // Diagnostics: asserts that the provided tree is valid.
-  // `AssertValid()` performs a shallow validation by default. `shallow` can be
-  // set to false in which case an exhaustive validation is performed. This
-  // function is implemented in terms of calling `IsValid()` and asserting the
-  // return value to be true. See `IsValid()` for more information.
-  // This function is intended for debugging and testing purposes only.
-  static CordRepBtree *AssertValid(CordRepBtree *tree, bool shallow = true);
-  static const CordRepBtree *AssertValid(const CordRepBtree *tree,
-                                         bool shallow = true);
-
-  // Diagnostics: dump the contents of this tree to `stream`.
-  // This function is intended for debugging and testing purposes only.
-  static void Dump(const CordRep *rep, std::ostream &stream);
-  static void Dump(const CordRep *rep, absl::string_view label,
-                   std::ostream &stream);
-  static void Dump(const CordRep *rep, absl::string_view label,
-                   bool include_contents, std::ostream &stream);
-
-  // Adds the edge `edge` to this node if possible. `owned` indicates if the
-  // current node is potentially shared or not with other threads. Returns:
-  // - {kSelf, <this>}
-  //   The edge was directly added to this node.
-  // - {kCopied, <node>}
-  //   The edge was added to a copy of this node.
-  // - {kPopped, New(edge, height())}
-  //   A new leg with the edge was created as this node has no extra capacity.
-  template <EdgeType edge_type>
-  inline OpResult AddEdge(bool owned, CordRep *edge, size_t delta);
-
-  // Replaces the front or back edge with the provided new edge. Returns:
-  // - {kSelf, <this>}
-  //   The edge was directly set in this node. The old edge is unreffed.
-  // - {kCopied, <node>}
-  //   A copy of this node was created with the new edge value.
-  // In both cases, the function adopts a reference on `edge`.
-  template <EdgeType edge_type>
-  OpResult SetEdge(bool owned, CordRep *edge, size_t delta);
-
-  // Creates a new empty node at the specified height.
-  static CordRepBtree *New(int height = 0);
-
-  // Creates a new node containing `rep`, with the height being computed
-  // automatically based on the type of `rep`.
-  static CordRepBtree *New(CordRep *rep);
-
-  // Creates a new node containing both `front` and `back` at height
-  // `front.height() + 1`. Requires `back.height() == front.height()`.
-  static CordRepBtree *New(CordRepBtree *front, CordRepBtree *back);
-
-  // Creates a fully balanced tree from the provided tree by rebuilding a new
-  // tree from all data edges in the input. This function is automatically
-  // invoked internally when the tree exceeds the maximum height.
-  static CordRepBtree *Rebuild(CordRepBtree *tree);
-
-private:
-  CordRepBtree() = default;
-  ~CordRepBtree() = default;
-
-  // Initializes the main properties `tag`, `begin`, `end`, `height`.
-  inline void InitInstance(int height, size_t begin = 0, size_t end = 0);
-
-  // Direct property access begin / end
-  void set_begin(size_t begin) { storage[1] = static_cast<uint8_t>(begin); }
-  void set_end(size_t end) { storage[2] = static_cast<uint8_t>(end); }
-
-  // Decreases the value of `begin` by `n`, and returns the new value. Notice
-  // how this returns the new value unlike atomic::fetch_add which returns the
-  // old value. This is because this is used to prepend edges at 'begin - 1'.
-  size_t sub_fetch_begin(size_t n) {
-    storage[1] -= static_cast<uint8_t>(n);
-    return storage[1];
-  }
-
-  // Increases the value of `end` by `n`, and returns the previous value. This
-  // function is typically used to append edges at 'end'.
-  size_t fetch_add_end(size_t n) {
-    const uint8_t current = storage[2];
-    storage[2] = static_cast<uint8_t>(current + n);
-    return current;
-  }
-
-  // Returns the index of the last edge starting on, or before `offset`, with
-  // `n` containing the relative offset of `offset` inside that edge.
-  // Requires `offset` < length.
-  Position IndexOf(size_t offset) const;
-
-  // Returns the index of the last edge starting before `offset`, with `n`
-  // containing the relative offset of `offset` inside that edge.
-  // This function is useful to find the edges for some span of bytes ending at
-  // `offset` (i.e., `n` bytes). For example:
-  //
-  //   Position pos = IndexBefore(n)
-  //   edges = Edges(begin(), pos.index)     // All full edges (may be empty)
-  //   last = Sub(Edge(pos.index), 0, pos.n) // Last partial edge (may be empty)
-  //
-  // Requires 0 < `offset` <= length.
-  Position IndexBefore(size_t offset) const;
-
-  // Returns the index of the edge ending at (or on) length `length`, and the
-  // number of bytes inside that edge up to `length`. For example, if we have a
-  // Node with 2 edges, one of 10 and one of 20 long, then IndexOfLength(27)
-  // will return {1, 17}, and IndexOfLength(10) will return {0, 10}.
-  Position IndexOfLength(size_t n) const;
-
-  // Identical to the above function except starting from the position `front`.
-  // This function is equivalent to `IndexBefore(front.n + offset)`, with
-  // the difference that this function is optimized to start at `front.index`.
-  Position IndexBefore(Position front, size_t offset) const;
-
-  // Returns the index of the edge directly beyond the edge containing offset
-  // `offset`, with `n` containing the distance of that edge from `offset`.
-  // This function is useful for iteratively finding suffix nodes and remaining
-  // partial bytes in left-most suffix nodes as for example in CopySuffix.
-  // Requires `offset` < length.
-  Position IndexBeyond(size_t offset) const;
-
-  // Creates a new leaf node containing as much data as possible from `data`.
-  // The data is added either forwards or reversed depending on `edge_type`.
-  // Callers must check the length of the returned node to determine if all data
-  // was copied or not.
-  // See the `Append/Prepend` function for the meaning and purpose of `extra`.
-  template <EdgeType edge_type>
-  static CordRepBtree *NewLeaf(absl::string_view data, size_t extra);
-
-  // Creates a raw copy of this Btree node with the specified length, copying
-  // all properties, but without adding any references to existing edges.
-  CordRepBtree *CopyRaw(size_t new_length) const;
-
-  // Creates a full copy of this Btree node, adding a reference on all edges.
-  CordRepBtree *Copy() const;
-
-  // Creates a partial copy of this Btree node, copying all edges up to `end`,
-  // adding a reference on each copied edge, and sets the length of the newly
-  // created copy to `new_length`.
-  CordRepBtree *CopyBeginTo(size_t end, size_t new_length) const;
-
-  // Returns a tree containing the edges [tree->begin(), end) and length
-  // of `new_length`. This method consumes a reference on the provided
-  // tree, and logically performs the following operation:
-  //   result = tree->CopyBeginTo(end, new_length);
-  //   CordRep::Unref(tree);
-  //   return result;
-  static CordRepBtree *ConsumeBeginTo(CordRepBtree *tree, size_t end,
-                                      size_t new_length);
-
-  // Creates a partial copy of this Btree node, copying all edges starting at
-  // `begin`, adding a reference on each copied edge, and sets the length of
-  // the newly created copy to `new_length`.
-  CordRepBtree *CopyToEndFrom(size_t begin, size_t new_length) const;
-
-  // Extracts and returns the front edge from the provided tree.
-  // This method consumes a reference on the provided tree, and logically
-  // performs the following operation:
-  //   edge = CordRep::Ref(tree->Edge(kFront));
-  //   CordRep::Unref(tree);
-  //   return edge;
-  static CordRep *ExtractFront(CordRepBtree *tree);
-
-  // Returns a tree containing the result of appending `right` to `left`.
-  static CordRepBtree *MergeTrees(CordRepBtree *left, CordRepBtree *right);
-
-  // Fallback functions for `Create()`, `Append()` and `Prepend()` which
-  // deal with legacy / non conforming input, i.e.: CONCAT trees.
-  static CordRepBtree *CreateSlow(CordRep *rep);
-  static CordRepBtree *AppendSlow(CordRepBtree *, CordRep *rep);
-  static CordRepBtree *PrependSlow(CordRepBtree *, CordRep *rep);
-
-  // Recursively rebuilds `tree` into `stack`. If 'consume` is set to true, the
-  // function will consume a reference on `tree`. `stack` is a null terminated
-  // array containing the new tree's state, with the current leaf node at
-  // stack[0], and parent nodes above that, or null for 'top of tree'.
-  static void Rebuild(CordRepBtree **stack, CordRepBtree *tree, bool consume);
-
-  // Aligns existing edges to start at index 0, to allow for a new edge to be
-  // added to the back of the current edges.
-  inline void AlignBegin();
-
-  // Aligns existing edges to end at `capacity`, to allow for a new edge to be
-  // added in front of the current edges.
-  inline void AlignEnd();
-
-  // Adds the provided edge to this node.
-  // Requires this node to have capacity for the edge. Realigns / moves
-  // existing edges as needed to prepend or append the new edge.
-  template <EdgeType edge_type> inline void Add(CordRep *rep);
-
-  // Adds the provided edges to this node.
-  // Requires this node to have capacity for the edges. Realigns / moves
-  // existing edges as needed to prepend or append the new edges.
-  template <EdgeType edge_type> inline void Add(absl::Span<CordRep *const>);
-
-  // Adds data from `data` to this node until either all data has been consumed,
-  // or there is no more capacity for additional flat nodes inside this node.
-  // Requires the current node to be a leaf node, data to be non empty, and the
-  // current node to have capacity for at least one more data edge.
-  // Returns any remaining data from `data` that was not added, which is
-  // depending on the edge type (front / back) either the remaining prefix of
-  // suffix of the input.
-  // See the `Append/Prepend` function for the meaning and purpose of `extra`.
-  template <EdgeType edge_type>
-  absl::string_view AddData(absl::string_view data, size_t extra);
-
-  // Replace the front or back edge with the provided value.
-  // Adopts a reference on `edge` and unrefs the old edge.
-  template <EdgeType edge_type> inline void SetEdge(CordRep *edge);
-
-  // Returns a partial copy of the current tree containing the first `n` bytes
-  // of data. `CopyResult` contains both the resulting edge and its height. The
-  // resulting tree may be less high than the current tree, or even be a single
-  // matching data edge if `allow_folding` is set to true.
-  // For example, if `n == 1`, then the result will be the single data edge, and
-  // height will be set to -1 (one below the owning leaf node). If n == 0, this
-  // function returns null. Requires `n <= length`
-  CopyResult CopyPrefix(size_t n, bool allow_folding = true);
-
-  // Returns a partial copy of the current tree containing all data starting
-  // after `offset`. `CopyResult` contains both the resulting edge and its
-  // height. The resulting tree may be less high than the current tree, or even
-  // be a single matching data edge. For example, if `n == length - 1`, then the
-  // result will be a single data edge, and height will be set to -1 (one below
-  // the owning leaf node).
-  // Requires `offset < length`
-  CopyResult CopySuffix(size_t offset);
-
-  // Returns a OpResult value of {this, kSelf} or {Copy(), kCopied}
-  // depending on the value of `owned`.
-  inline OpResult ToOpResult(bool owned);
-
-  // Adds `rep` to the specified tree, returning the modified tree.
-  template <EdgeType edge_type>
-  static CordRepBtree *AddCordRep(CordRepBtree *tree, CordRep *rep);
-
-  // Adds `data` to the specified tree, returning the modified tree.
-  // See the `Append/Prepend` function for the meaning and purpose of `extra`.
-  template <EdgeType edge_type>
-  static CordRepBtree *AddData(CordRepBtree *tree, absl::string_view data,
-                               size_t extra = 0);
-
-  // Merges `src` into `dst` with `src` being added either before (kFront) or
-  // after (kBack) `dst`. Requires the height of `dst` to be greater than or
-  // equal to the height of `src`.
-  template <EdgeType edge_type>
-  static CordRepBtree *Merge(CordRepBtree *dst, CordRepBtree *src);
-
-  // Fallback version of GetAppendBuffer for large trees: GetAppendBuffer()
-  // implements an inlined version for trees of limited height (3 levels),
-  // GetAppendBufferSlow implements the logic for large trees.
-  Span<char> GetAppendBufferSlow(size_t size);
-
-  // `edges_` contains all edges starting from this instance.
-  // These are explicitly `child` edges only, a cord btree (or any cord tree in
-  // that respect) does not store `parent` pointers anywhere: multiple trees /
-  // parents can reference the same shared child edge. The type of these edges
-  // depends on the height of the node. `Leaf nodes` (height == 0) contain `data
-  // edges` (external or flat nodes, or sub-strings thereof). All other nodes
-  // (height > 0) contain pointers to BTREE nodes with a height of `height - 1`.
-  CordRep *edges_[kMaxCapacity];
-
-  friend class CordRepBtreeTestPeer;
-  friend class CordRepBtreeNavigator;
-};
-
-inline CordRepBtree *CordRep::btree() {
-  assert(IsBtree());
-  return static_cast<CordRepBtree *>(this);
-}
-
-inline const CordRepBtree *CordRep::btree() const {
-  assert(IsBtree());
-  return static_cast<const CordRepBtree *>(this);
-}
-
-inline void CordRepBtree::InitInstance(int height, size_t begin, size_t end) {
-  tag = BTREE;
-  storage[0] = static_cast<uint8_t>(height);
-  storage[1] = static_cast<uint8_t>(begin);
-  storage[2] = static_cast<uint8_t>(end);
-}
-
-inline CordRep *CordRepBtree::Edge(size_t index) const {
-  assert(index >= begin());
-  assert(index < end());
-  return edges_[index];
-}
-
-inline CordRep *CordRepBtree::Edge(EdgeType edge_type) const {
-  return edges_[edge_type == kFront ? begin() : back()];
-}
-
-inline absl::Span<CordRep *const> CordRepBtree::Edges() const {
-  return {edges_ + begin(), size()};
-}
-
-inline absl::Span<CordRep *const> CordRepBtree::Edges(size_t begin,
-                                                      size_t end) const {
-  assert(begin <= end);
-  assert(begin >= this->begin());
-  assert(end <= this->end());
-  return {edges_ + begin, static_cast<size_t>(end - begin)};
-}
-
-inline absl::string_view CordRepBtree::Data(size_t index) const {
-  assert(height() == 0);
-  return EdgeData(Edge(index));
-}
-
-inline CordRepBtree *CordRepBtree::New(int height) {
-  CordRepBtree *tree = new CordRepBtree;
-  tree->length = 0;
-  tree->InitInstance(height);
-  return tree;
-}
-
-inline CordRepBtree *CordRepBtree::New(CordRep *rep) {
-  CordRepBtree *tree = new CordRepBtree;
-  int height = rep->IsBtree() ? rep->btree()->height() + 1 : 0;
-  tree->length = rep->length;
-  tree->InitInstance(height, /*begin=*/0, /*end=*/1);
-  tree->edges_[0] = rep;
-  return tree;
-}
-
-inline CordRepBtree *CordRepBtree::New(CordRepBtree *front,
-                                       CordRepBtree *back) {
-  assert(front->height() == back->height());
-  CordRepBtree *tree = new CordRepBtree;
-  tree->length = front->length + back->length;
-  tree->InitInstance(front->height() + 1, /*begin=*/0, /*end=*/2);
-  tree->edges_[0] = front;
-  tree->edges_[1] = back;
-  return tree;
-}
-
-inline void CordRepBtree::Unref(absl::Span<CordRep *const> edges) {
-  for (CordRep *edge : edges) {
-    if (ABSL_PREDICT_FALSE(!edge->refcount.Decrement())) {
-      CordRep::Destroy(edge);
-    }
-  }
-}
-
-inline CordRepBtree *CordRepBtree::CopyRaw(size_t new_length) const {
-  CordRepBtree *tree = new CordRepBtree;
-
-  // `length` and `refcount` are the first members of `CordRepBtree`.
-  // We initialize `length` using the given length, have `refcount` be set to
-  // ref = 1 through its default constructor, and copy all data beyond
-  // 'refcount' which starts with `tag` using a single memcpy: all contents
-  // except `refcount` is trivially copyable, and the compiler does not
-  // efficiently coalesce member-wise copy of these members.
-  // See https://gcc.godbolt.org/z/qY8zsca6z
-  // LINT.IfChange(copy_raw)
-  tree->length = new_length;
-  uint8_t *dst = &tree->tag;
-  const uint8_t *src = &tag;
-  const ptrdiff_t offset = src - reinterpret_cast<const uint8_t *>(this);
-  memcpy(dst, src, sizeof(CordRepBtree) - static_cast<size_t>(offset));
-  return tree;
-  // LINT.ThenChange()
-}
-
-inline CordRepBtree *CordRepBtree::Copy() const {
-  CordRepBtree *tree = CopyRaw(length);
-  for (CordRep *rep : Edges())
-    CordRep::Ref(rep);
-  return tree;
-}
-
-inline CordRepBtree *CordRepBtree::CopyToEndFrom(size_t begin,
-                                                 size_t new_length) const {
-  assert(begin >= this->begin());
-  assert(begin <= this->end());
-  CordRepBtree *tree = CopyRaw(new_length);
-  tree->set_begin(begin);
-  for (CordRep *edge : tree->Edges())
-    CordRep::Ref(edge);
-  return tree;
-}
-
-inline CordRepBtree *CordRepBtree::CopyBeginTo(size_t end,
-                                               size_t new_length) const {
-  assert(end <= capacity());
-  assert(end >= this->begin());
-  CordRepBtree *tree = CopyRaw(new_length);
-  tree->set_end(end);
-  for (CordRep *edge : tree->Edges())
-    CordRep::Ref(edge);
-  return tree;
-}
-
-inline void CordRepBtree::AlignBegin() {
-  // The below code itself does not need to be fast as typically we have
-  // mono-directional append/prepend calls, and `begin` / `end` are typically
-  // adjusted no more than once. But we want to avoid potential register clobber
-  // effects, making the compiler emit register save/store/spills, and minimize
-  // the size of code.
-  const size_t delta = begin();
-  if (ABSL_PREDICT_FALSE(delta != 0)) {
-    const size_t new_end = end() - delta;
-    set_begin(0);
-    set_end(new_end);
-    // TODO(mvels): we can write this using 2 loads / 2 stores depending on
-    // total size for the kMaxCapacity = 6 case. I.e., we can branch (switch) on
-    // size, and then do overlapping load/store of up to 4 pointers (inlined as
-    // XMM, YMM or ZMM load/store) and up to 2 pointers (XMM / YMM), which is a)
-    // compact and b) not clobbering any registers.
-    ABSL_ASSUME(new_end <= kMaxCapacity);
-#ifdef __clang__
-#pragma unroll 1
-#endif
-    for (size_t i = 0; i < new_end; ++i) {
-      edges_[i] = edges_[i + delta];
-    }
-  }
-}
-
-inline void CordRepBtree::AlignEnd() {
-  // See comments in `AlignBegin` for motivation on the hand-rolled for loops.
-  const size_t delta = capacity() - end();
-  if (delta != 0) {
-    const size_t new_begin = begin() + delta;
-    const size_t new_end = end() + delta;
-    set_begin(new_begin);
-    set_end(new_end);
-    ABSL_ASSUME(new_end <= kMaxCapacity);
-#ifdef __clang__
-#pragma unroll 1
-#endif
-    for (size_t i = new_end - 1; i >= new_begin; --i) {
-      edges_[i] = edges_[i - delta];
-    }
-  }
-}
-
-template <> inline void CordRepBtree::Add<CordRepBtree::kBack>(CordRep *rep) {
-  AlignBegin();
-  edges_[fetch_add_end(1)] = rep;
-}
-
-template <>
-inline void
-CordRepBtree::Add<CordRepBtree::kBack>(absl::Span<CordRep *const> edges) {
-  AlignBegin();
-  size_t new_end = end();
-  for (CordRep *edge : edges)
-    edges_[new_end++] = edge;
-  set_end(new_end);
-}
-
-template <> inline void CordRepBtree::Add<CordRepBtree::kFront>(CordRep *rep) {
-  AlignEnd();
-  edges_[sub_fetch_begin(1)] = rep;
-}
-
-template <>
-inline void
-CordRepBtree::Add<CordRepBtree::kFront>(absl::Span<CordRep *const> edges) {
-  AlignEnd();
-  size_t new_begin = begin() - edges.size();
-  set_begin(new_begin);
-  for (CordRep *edge : edges)
-    edges_[new_begin++] = edge;
-}
-
-template <CordRepBtree::EdgeType edge_type>
-inline void CordRepBtree::SetEdge(CordRep *edge) {
-  const int idx = edge_type == kFront ? begin() : back();
-  CordRep::Unref(edges_[idx]);
-  edges_[idx] = edge;
-}
-
-inline CordRepBtree::OpResult CordRepBtree::ToOpResult(bool owned) {
-  return owned ? OpResult{this, kSelf} : OpResult{Copy(), kCopied};
-}
-
-inline CordRepBtree::Position CordRepBtree::IndexOf(size_t offset) const {
-  assert(offset < length);
-  size_t index = begin();
-  while (offset >= edges_[index]->length)
-    offset -= edges_[index++]->length;
-  return {index, offset};
-}
-
-inline CordRepBtree::Position CordRepBtree::IndexBefore(size_t offset) const {
-  assert(offset > 0);
-  assert(offset <= length);
-  size_t index = begin();
-  while (offset > edges_[index]->length)
-    offset -= edges_[index++]->length;
-  return {index, offset};
-}
-
-inline CordRepBtree::Position CordRepBtree::IndexBefore(Position front,
-                                                        size_t offset) const {
-  size_t index = front.index;
-  offset = offset + front.n;
-  while (offset > edges_[index]->length)
-    offset -= edges_[index++]->length;
-  return {index, offset};
-}
-
-inline CordRepBtree::Position CordRepBtree::IndexOfLength(size_t n) const {
-  assert(n <= length);
-  size_t index = back();
-  size_t strip = length - n;
-  while (strip >= edges_[index]->length)
-    strip -= edges_[index--]->length;
-  return {index, edges_[index]->length - strip};
-}
-
-inline CordRepBtree::Position
-CordRepBtree::IndexBeyond(const size_t offset) const {
-  // We need to find the edge which `starting offset` is beyond (>=)`offset`.
-  // For this we can't use the `offset -= length` logic of IndexOf. Instead, we
-  // track the offset of the `current edge` in `off`, which we increase as we
-  // iterate over the edges until we find the matching edge.
-  size_t off = 0;
-  size_t index = begin();
-  while (offset > off)
-    off += edges_[index++]->length;
-  return {index, off - offset};
-}
-
-inline CordRepBtree *CordRepBtree::Create(CordRep *rep) {
-  if (IsDataEdge(rep))
-    return New(rep);
-  return CreateSlow(rep);
-}
-
-inline Span<char> CordRepBtree::GetAppendBuffer(size_t size) {
-  assert(refcount.IsOne());
-  CordRepBtree *tree = this;
-  const int height = this->height();
-  CordRepBtree *n1 = tree;
-  CordRepBtree *n2 = tree;
-  CordRepBtree *n3 = tree;
-  switch (height) {
-  case 3:
-    tree = tree->Edge(kBack)->btree();
-    if (!tree->refcount.IsOne())
-      return {};
-    n2 = tree;
-    ABSL_FALLTHROUGH_INTENDED;
-  case 2:
-    tree = tree->Edge(kBack)->btree();
-    if (!tree->refcount.IsOne())
-      return {};
-    n1 = tree;
-    ABSL_FALLTHROUGH_INTENDED;
-  case 1:
-    tree = tree->Edge(kBack)->btree();
-    if (!tree->refcount.IsOne())
-      return {};
-    ABSL_FALLTHROUGH_INTENDED;
-  case 0:
-    CordRep *edge = tree->Edge(kBack);
-    if (!edge->refcount.IsOne())
-      return {};
-    if (edge->tag < FLAT)
-      return {};
-    size_t avail = edge->flat()->Capacity() - edge->length;
-    if (avail == 0)
-      return {};
-    size_t delta = (std::min)(size, avail);
-    Span<char> span = {edge->flat()->Data() + edge->length, delta};
-    edge->length += delta;
-    switch (height) {
-    case 3:
-      n3->length += delta;
-      ABSL_FALLTHROUGH_INTENDED;
-    case 2:
-      n2->length += delta;
-      ABSL_FALLTHROUGH_INTENDED;
-    case 1:
-      n1->length += delta;
-      ABSL_FALLTHROUGH_INTENDED;
-    case 0:
-      tree->length += delta;
-      return span;
-    }
-    break;
-  }
-  return GetAppendBufferSlow(size);
-}
-
-extern template CordRepBtree *
-CordRepBtree::AddCordRep<CordRepBtree::kBack>(CordRepBtree *tree, CordRep *rep);
-
-extern template CordRepBtree *
-CordRepBtree::AddCordRep<CordRepBtree::kFront>(CordRepBtree *tree,
-                                               CordRep *rep);
-
-inline CordRepBtree *CordRepBtree::Append(CordRepBtree *tree, CordRep *rep) {
-  if (ABSL_PREDICT_TRUE(IsDataEdge(rep))) {
-    return CordRepBtree::AddCordRep<kBack>(tree, rep);
-  }
-  return AppendSlow(tree, rep);
-}
-
-inline CordRepBtree *CordRepBtree::Prepend(CordRepBtree *tree, CordRep *rep) {
-  if (ABSL_PREDICT_TRUE(IsDataEdge(rep))) {
-    return CordRepBtree::AddCordRep<kFront>(tree, rep);
-  }
-  return PrependSlow(tree, rep);
-}
-
-#ifdef NDEBUG
-
-inline CordRepBtree *CordRepBtree::AssertValid(CordRepBtree *tree,
-                                               bool /* shallow */) {
-  return tree;
-}
-
-inline const CordRepBtree *CordRepBtree::AssertValid(const CordRepBtree *tree,
-                                                     bool /* shallow */) {
-  return tree;
-}
-
-#endif
-
-} // namespace cord_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_rep_btree_navigator.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_rep_btree_navigator.h
deleted file mode 100644
index 01c2288bec..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_rep_btree_navigator.h
+++ /dev/null
@@ -1,270 +0,0 @@
-// Copyright 2021 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_NAVIGATOR_H_
-#define ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_NAVIGATOR_H_
-
-#include <cassert>
-#include <iostream>
-
-#include "absl/strings/internal/cord_internal.h"
-#include "absl/strings/internal/cord_rep_btree.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// CordRepBtreeNavigator is a bi-directional navigator allowing callers to
-// navigate all the (leaf) data edges in a CordRepBtree instance.
-//
-// A CordRepBtreeNavigator instance is by default empty. Callers initialize a
-// navigator instance by calling one of `InitFirst()`, `InitLast()` or
-// `InitOffset()`, which establishes a current position. Callers can then
-// navigate using the `Next`, `Previous`, `Skip` and `Seek` methods.
-//
-// The navigator instance does not take or adopt a reference on the provided
-// `tree` on any of the initialization calls. Callers are responsible for
-// guaranteeing the lifecycle of the provided tree. A navigator instance can
-// be reset to the empty state by calling `Reset`.
-//
-// A navigator only keeps positional state on the 'current data edge', it does
-// explicitly not keep any 'offset' state. The class does accept and return
-// offsets in the `Read()`, `Skip()` and 'Seek()` methods as these would
-// otherwise put a big burden on callers. Callers are expected to maintain
-// (returned) offset info if they require such granular state.
-class CordRepBtreeNavigator {
-public:
-  // The logical position as returned by the Seek() and Skip() functions.
-  // Returns the current leaf edge for the desired seek or skip position and
-  // the offset of that position inside that edge.
-  struct Position {
-    CordRep *edge;
-    size_t offset;
-  };
-
-  // The read result as returned by the Read() function.
-  // `tree` contains the resulting tree which is identical to the result
-  // of calling CordRepBtree::SubTree(...) on the tree being navigated.
-  // `n` contains the number of bytes used from the last navigated to
-  // edge of the tree.
-  struct ReadResult {
-    CordRep *tree;
-    size_t n;
-  };
-
-  // Returns true if this instance is not empty.
-  explicit operator bool() const;
-
-  // Returns the tree for this instance or nullptr if empty.
-  CordRepBtree *btree() const;
-
-  // Returns the data edge of the current position.
-  // Requires this instance to not be empty.
-  CordRep *Current() const;
-
-  // Resets this navigator to `tree`, returning the first data edge in the tree.
-  CordRep *InitFirst(CordRepBtree *tree);
-
-  // Resets this navigator to `tree`, returning the last data edge in the tree.
-  CordRep *InitLast(CordRepBtree *tree);
-
-  // Resets this navigator to `tree` returning the data edge at position
-  // `offset` and the relative offset of `offset` into that data edge.
-  // Returns `Position.edge = nullptr` if the provided offset is greater
-  // than or equal to the length of the tree, in which case the state of
-  // the navigator instance remains unchanged.
-  Position InitOffset(CordRepBtree *tree, size_t offset);
-
-  // Navigates to the next data edge.
-  // Returns the next data edge or nullptr if there is no next data edge, in
-  // which case the current position remains unchanged.
-  CordRep *Next();
-
-  // Navigates to the previous data edge.
-  // Returns the previous data edge or nullptr if there is no previous data
-  // edge, in which case the current position remains unchanged.
-  CordRep *Previous();
-
-  // Navigates to the data edge at position `offset`. Returns the navigated to
-  // data edge in `Position.edge` and the relative offset of `offset` into that
-  // data edge in `Position.offset`. Returns `Position.edge = nullptr` if the
-  // provide offset is greater than or equal to the tree's length.
-  Position Seek(size_t offset);
-
-  // Reads `n` bytes of data starting at offset `edge_offset` of the current
-  // data edge, and returns the result in `ReadResult.tree`. `ReadResult.n`
-  // contains the 'bytes used` from the last / current data edge in the tree.
-  // This allows users that mix regular navigation (using string views) and
-  // 'read into cord' navigation to keep track of the current state, and which
-  // bytes have been consumed from a navigator.
-  // This function returns `ReadResult.tree = nullptr` if the requested length
-  // exceeds the length of the tree starting at the current data edge.
-  ReadResult Read(size_t edge_offset, size_t n);
-
-  // Skips `n` bytes forward from the current data edge, returning the navigated
-  // to data edge in `Position.edge` and `Position.offset` containing the offset
-  // inside that data edge. Note that the state of the navigator is left
-  // unchanged if `n` is smaller than the length of the current data edge.
-  Position Skip(size_t n);
-
-  // Resets this instance to the default / empty state.
-  void Reset();
-
-private:
-  // Slow path for Next() if Next() reached the end of a leaf node. Backtracks
-  // up the stack until it finds a node that has a 'next' position available,
-  // and then does a 'front dive' towards the next leaf node.
-  CordRep *NextUp();
-
-  // Slow path for Previous() if Previous() reached the beginning of a leaf
-  // node. Backtracks up the stack until it finds a node that has a 'previous'
-  // position available, and then does a 'back dive' towards the previous leaf
-  // node.
-  CordRep *PreviousUp();
-
-  // Generic implementation of InitFirst() and InitLast().
-  template <CordRepBtree::EdgeType edge_type> CordRep *Init(CordRepBtree *tree);
-
-  // `height_` contains the height of the current tree, or -1 if empty.
-  int height_ = -1;
-
-  // `index_` and `node_` contain the navigation state as the 'path' to the
-  // current data edge which is at `node_[0]->Edge(index_[0])`. The contents
-  // of these are undefined until the instance is initialized (`height_ >= 0`).
-  uint8_t index_[CordRepBtree::kMaxDepth];
-  CordRepBtree *node_[CordRepBtree::kMaxDepth];
-};
-
-// Returns true if this instance is not empty.
-inline CordRepBtreeNavigator::operator bool() const { return height_ >= 0; }
-
-inline CordRepBtree *CordRepBtreeNavigator::btree() const {
-  return height_ >= 0 ? node_[height_] : nullptr;
-}
-
-inline CordRep *CordRepBtreeNavigator::Current() const {
-  assert(height_ >= 0);
-  return node_[0]->Edge(index_[0]);
-}
-
-inline void CordRepBtreeNavigator::Reset() { height_ = -1; }
-
-inline CordRep *CordRepBtreeNavigator::InitFirst(CordRepBtree *tree) {
-  return Init<CordRepBtree::kFront>(tree);
-}
-
-inline CordRep *CordRepBtreeNavigator::InitLast(CordRepBtree *tree) {
-  return Init<CordRepBtree::kBack>(tree);
-}
-
-template <CordRepBtree::EdgeType edge_type>
-inline CordRep *CordRepBtreeNavigator::Init(CordRepBtree *tree) {
-  assert(tree != nullptr);
-  assert(tree->size() > 0);
-  assert(tree->height() <= CordRepBtree::kMaxHeight);
-  int height = height_ = tree->height();
-  size_t index = tree->index(edge_type);
-  node_[height] = tree;
-  index_[height] = static_cast<uint8_t>(index);
-  while (--height >= 0) {
-    tree = tree->Edge(index)->btree();
-    node_[height] = tree;
-    index = tree->index(edge_type);
-    index_[height] = static_cast<uint8_t>(index);
-  }
-  return node_[0]->Edge(index);
-}
-
-inline CordRepBtreeNavigator::Position
-CordRepBtreeNavigator::Seek(size_t offset) {
-  assert(btree() != nullptr);
-  int height = height_;
-  CordRepBtree *edge = node_[height];
-  if (ABSL_PREDICT_FALSE(offset >= edge->length))
-    return {nullptr, 0};
-  CordRepBtree::Position index = edge->IndexOf(offset);
-  index_[height] = static_cast<uint8_t>(index.index);
-  while (--height >= 0) {
-    edge = edge->Edge(index.index)->btree();
-    node_[height] = edge;
-    index = edge->IndexOf(index.n);
-    index_[height] = static_cast<uint8_t>(index.index);
-  }
-  return {edge->Edge(index.index), index.n};
-}
-
-inline CordRepBtreeNavigator::Position
-CordRepBtreeNavigator::InitOffset(CordRepBtree *tree, size_t offset) {
-  assert(tree != nullptr);
-  assert(tree->height() <= CordRepBtree::kMaxHeight);
-  if (ABSL_PREDICT_FALSE(offset >= tree->length))
-    return {nullptr, 0};
-  height_ = tree->height();
-  node_[height_] = tree;
-  return Seek(offset);
-}
-
-inline CordRep *CordRepBtreeNavigator::Next() {
-  CordRepBtree *edge = node_[0];
-  return index_[0] == edge->back() ? NextUp() : edge->Edge(++index_[0]);
-}
-
-inline CordRep *CordRepBtreeNavigator::Previous() {
-  CordRepBtree *edge = node_[0];
-  return index_[0] == edge->begin() ? PreviousUp() : edge->Edge(--index_[0]);
-}
-
-inline CordRep *CordRepBtreeNavigator::NextUp() {
-  assert(index_[0] == node_[0]->back());
-  CordRepBtree *edge;
-  size_t index;
-  int height = 0;
-  do {
-    if (++height > height_)
-      return nullptr;
-    edge = node_[height];
-    index = index_[height] + 1;
-  } while (index == edge->end());
-  index_[height] = static_cast<uint8_t>(index);
-  do {
-    node_[--height] = edge = edge->Edge(index)->btree();
-    index_[height] = static_cast<uint8_t>(index = edge->begin());
-  } while (height > 0);
-  return edge->Edge(index);
-}
-
-inline CordRep *CordRepBtreeNavigator::PreviousUp() {
-  assert(index_[0] == node_[0]->begin());
-  CordRepBtree *edge;
-  size_t index;
-  int height = 0;
-  do {
-    if (++height > height_)
-      return nullptr;
-    edge = node_[height];
-    index = index_[height];
-  } while (index == edge->begin());
-  index_[height] = static_cast<uint8_t>(--index);
-  do {
-    node_[--height] = edge = edge->Edge(index)->btree();
-    index_[height] = static_cast<uint8_t>(index = edge->back());
-  } while (height > 0);
-  return edge->Edge(index);
-}
-
-} // namespace cord_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_NAVIGATOR_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_rep_btree_reader.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_rep_btree_reader.h
deleted file mode 100644
index 1bbbdb4b5d..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_rep_btree_reader.h
+++ /dev/null
@@ -1,213 +0,0 @@
-// Copyright 2021 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_READER_H_
-#define ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_READER_H_
-
-#include <cassert>
-
-#include "absl/base/config.h"
-#include "absl/strings/internal/cord_data_edge.h"
-#include "absl/strings/internal/cord_internal.h"
-#include "absl/strings/internal/cord_rep_btree.h"
-#include "absl/strings/internal/cord_rep_btree_navigator.h"
-#include "absl/strings/internal/cord_rep_flat.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// CordRepBtreeReader implements logic to iterate over cord btrees.
-// References to the underlying data are returned as absl::string_view values.
-// The most typical use case is a forward only iteration over tree data.
-// The class also provides `Skip()`, `Seek()` and `Read()` methods similar to
-// CordRepBtreeNavigator that allow more advanced navigation.
-//
-// Example: iterate over all data inside a cord btree:
-//
-//   CordRepBtreeReader reader;
-//   for (string_view sv = reader.Init(tree); !sv.Empty(); sv = sv.Next()) {
-//     DoSomethingWithDataIn(sv);
-//   }
-//
-// All navigation methods always return the next 'chunk' of data. The class
-// assumes that all data is directly 'consumed' by the caller. For example:
-// invoking `Skip()` will skip the desired number of bytes, and directly
-// read and return the next chunk of data directly after the skipped bytes.
-//
-// Example: iterate over all data inside a btree skipping the first 100 bytes:
-//
-//   CordRepBtreeReader reader;
-//   absl::string_view sv = reader.Init(tree);
-//   if (sv.length() > 100) {
-//     sv.RemovePrefix(100);
-//   } else {
-//     sv = reader.Skip(100 - sv.length());
-//   }
-//   while (!sv.empty()) {
-//     DoSomethingWithDataIn(sv);
-//     absl::string_view sv = reader.Next();
-//   }
-//
-// It is important to notice that `remaining` is based on the end position of
-// the last data edge returned to the caller, not the cumulative data returned
-// to the caller which can be less in cases of skipping or seeking over data.
-//
-// For example, consider a cord btree with five data edges: "abc", "def", "ghi",
-// "jkl" and "mno":
-//
-//   absl::string_view sv;
-//   CordRepBtreeReader reader;
-//
-//   sv = reader.Init(tree); // sv = "abc", remaining = 12
-//   sv = reader.Skip(4);    // sv = "hi",  remaining = 6
-//   sv = reader.Skip(2);    // sv = "l",   remaining = 3
-//   sv = reader.Next();     // sv = "mno", remaining = 0
-//   sv = reader.Seek(1);    // sv = "bc", remaining = 12
-//
-class CordRepBtreeReader {
-public:
-  using ReadResult = CordRepBtreeNavigator::ReadResult;
-  using Position = CordRepBtreeNavigator::Position;
-
-  // Returns true if this instance is not empty.
-  explicit operator bool() const { return navigator_.btree() != nullptr; }
-
-  // Returns the tree referenced by this instance or nullptr if empty.
-  CordRepBtree *btree() const { return navigator_.btree(); }
-
-  // Returns the current data edge inside the referenced btree.
-  // Requires that the current instance is not empty.
-  CordRep *node() const { return navigator_.Current(); }
-
-  // Returns the length of the referenced tree.
-  // Requires that the current instance is not empty.
-  size_t length() const;
-
-  // Returns the number of remaining bytes available for iteration, which is the
-  // number of bytes directly following the end of the last chunk returned.
-  // This value will be zero if we iterated over the last edge in the bound
-  // tree, in which case any call to Next() or Skip() will return an empty
-  // string_view reflecting the EOF state.
-  // Note that a call to `Seek()` resets `remaining` to a value based on the
-  // end position of the chunk returned by that call.
-  size_t remaining() const { return remaining_; }
-
-  // Resets this instance to an empty value.
-  void Reset() { navigator_.Reset(); }
-
-  // Initializes this instance with `tree`. `tree` must not be null.
-  // Returns a reference to the first data edge of the provided tree.
-  absl::string_view Init(CordRepBtree *tree);
-
-  // Navigates to and returns the next data edge of the referenced tree.
-  // Returns an empty string_view if an attempt is made to read beyond the end
-  // of the tree, i.e.: if `remaining()` is zero indicating an EOF condition.
-  // Requires that the current instance is not empty.
-  absl::string_view Next();
-
-  // Skips the provided amount of bytes and returns a reference to the data
-  // directly following the skipped bytes.
-  absl::string_view Skip(size_t skip);
-
-  // Reads `n` bytes into `tree`.
-  // If `chunk_size` is zero, starts reading at the next data edge. If
-  // `chunk_size` is non zero, the read starts at the last `chunk_size` bytes of
-  // the last returned data edge. Effectively, this means that the read starts
-  // at offset `consumed() - chunk_size`.
-  // Requires that `chunk_size` is less than or equal to the length of the
-  // last returned data edge. The purpose of `chunk_size` is to simplify code
-  // partially consuming a returned chunk and wanting to include the remaining
-  // bytes in the Read call. For example, the below code will read 1000 bytes of
-  // data into a cord tree if the first chunk starts with "big:":
-  //
-  //   CordRepBtreeReader reader;
-  //   absl::string_view sv = reader.Init(tree);
-  //   if (absl::StartsWith(sv, "big:")) {
-  //     CordRepBtree tree;
-  //     sv = reader.Read(1000, sv.size() - 4 /* "big:" */, &tree);
-  //   }
-  //
-  // This method will return an empty string view if all remaining data was
-  // read. If `n` exceeded the amount of remaining data this function will
-  // return an empty string view and `tree` will be set to nullptr.
-  // In both cases, `consumed` will be set to `length`.
-  absl::string_view Read(size_t n, size_t chunk_size, CordRep *&tree);
-
-  // Navigates to the chunk at offset `offset`.
-  // Returns a reference into the navigated to chunk, adjusted for the relative
-  // position of `offset` into that chunk. For example, calling `Seek(13)` on a
-  // cord tree containing 2 chunks of 10 and 20 bytes respectively will return
-  // a string view into the second chunk starting at offset 3 with a size of 17.
-  // Returns an empty string view if `offset` is equal to or greater than the
-  // length of the referenced tree.
-  absl::string_view Seek(size_t offset);
-
-private:
-  size_t remaining_ = 0;
-  CordRepBtreeNavigator navigator_;
-};
-
-inline size_t CordRepBtreeReader::length() const {
-  assert(btree() != nullptr);
-  return btree()->length;
-}
-
-inline absl::string_view CordRepBtreeReader::Init(CordRepBtree *tree) {
-  assert(tree != nullptr);
-  const CordRep *edge = navigator_.InitFirst(tree);
-  remaining_ = tree->length - edge->length;
-  return EdgeData(edge);
-}
-
-inline absl::string_view CordRepBtreeReader::Next() {
-  if (remaining_ == 0)
-    return {};
-  const CordRep *edge = navigator_.Next();
-  assert(edge != nullptr);
-  remaining_ -= edge->length;
-  return EdgeData(edge);
-}
-
-inline absl::string_view CordRepBtreeReader::Skip(size_t skip) {
-  // As we are always positioned on the last 'consumed' edge, we
-  // need to skip the current edge as well as `skip`.
-  const size_t edge_length = navigator_.Current()->length;
-  CordRepBtreeNavigator::Position pos = navigator_.Skip(skip + edge_length);
-  if (ABSL_PREDICT_FALSE(pos.edge == nullptr)) {
-    remaining_ = 0;
-    return {};
-  }
-  // The combined length of all edges skipped before `pos.edge` is `skip -
-  // pos.offset`, all of which are 'consumed', as well as the current edge.
-  remaining_ -= skip - pos.offset + pos.edge->length;
-  return EdgeData(pos.edge).substr(pos.offset);
-}
-
-inline absl::string_view CordRepBtreeReader::Seek(size_t offset) {
-  const CordRepBtreeNavigator::Position pos = navigator_.Seek(offset);
-  if (ABSL_PREDICT_FALSE(pos.edge == nullptr)) {
-    remaining_ = 0;
-    return {};
-  }
-  absl::string_view chunk = EdgeData(pos.edge).substr(pos.offset);
-  remaining_ = length() - offset - chunk.length();
-  return chunk;
-}
-
-} // namespace cord_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_READER_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_rep_consume.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_rep_consume.h
deleted file mode 100644
index 5c73c41f28..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_rep_consume.h
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright 2021 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_CONSUME_H_
-#define ABSL_STRINGS_INTERNAL_CORD_REP_CONSUME_H_
-
-#include <functional>
-
-#include "absl/functional/function_ref.h"
-#include "absl/strings/internal/cord_internal.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// Consume() and ReverseConsume() consume CONCAT based trees and invoke the
-// provided functor with the contained nodes in the proper forward or reverse
-// order, which is used to convert CONCAT trees into other tree or cord data.
-// All CONCAT and SUBSTRING nodes are processed internally. The 'offset`
-// parameter of the functor is non-zero for any nodes below SUBSTRING nodes.
-// It's up to the caller to form these back into SUBSTRING nodes or otherwise
-// store offset / prefix information. These functions are intended to be used
-// only for migration / transitional code where due to factors such as ODR
-// violations, we can not 100% guarantee that all code respects 'new format'
-// settings and flags, so we need to be able to parse old data on the fly until
-// all old code is deprecated / no longer the default format.
-void Consume(CordRep *rep,
-             FunctionRef<void(CordRep *, size_t, size_t)> consume_fn);
-void ReverseConsume(CordRep *rep,
-                    FunctionRef<void(CordRep *, size_t, size_t)> consume_fn);
-
-} // namespace cord_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_CORD_REP_CONSUME_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_rep_crc.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_rep_crc.h
deleted file mode 100644
index 197068df9c..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_rep_crc.h
+++ /dev/null
@@ -1,103 +0,0 @@
-// Copyright 2021 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_CRC_H_
-#define ABSL_STRINGS_INTERNAL_CORD_REP_CRC_H_
-
-#include <cassert>
-#include <cstdint>
-
-#include "absl/base/config.h"
-#include "absl/base/optimization.h"
-#include "absl/crc/internal/crc_cord_state.h"
-#include "absl/strings/internal/cord_internal.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// CordRepCrc is a CordRep node intended only to appear at the top level of a
-// cord tree.  It associates an "expected CRC" with the contained data, to allow
-// for easy passage of checksum data in Cord data flows.
-//
-// From Cord's perspective, the crc value has no semantics; any validation of
-// the contained checksum is the user's responsibility.
-struct CordRepCrc : public CordRep {
-  CordRep *child;
-  absl::crc_internal::CrcCordState crc_cord_state;
-
-  // Consumes `child` and returns a CordRepCrc prefixed tree containing `child`.
-  // If the specified `child` is itself a CordRepCrc node, then this method
-  // either replaces the existing node, or directly updates the crc state in it
-  // depending on the node being shared or not, i.e.: refcount.IsOne().
-  // `child` must only be null if the Cord is empty. Never returns null.
-  static CordRepCrc *New(CordRep *child, crc_internal::CrcCordState state);
-
-  // Destroys (deletes) the provided node. `node` must not be null.
-  static void Destroy(CordRepCrc *node);
-};
-
-// Consumes `rep` and returns a CordRep* with any outer CordRepCrc wrapper
-// removed.  This is usually a no-op (returning `rep`), but this will remove and
-// unref an outer CordRepCrc node.
-inline CordRep *RemoveCrcNode(CordRep *rep) {
-  assert(rep != nullptr);
-  if (ABSL_PREDICT_FALSE(rep->IsCrc())) {
-    CordRep *child = rep->crc()->child;
-    if (rep->refcount.IsOne()) {
-      delete rep->crc();
-    } else {
-      CordRep::Ref(child);
-      CordRep::Unref(rep);
-    }
-    return child;
-  }
-  return rep;
-}
-
-// Returns `rep` if it is not a CordRepCrc node, or its child if it is.
-// Does not consume or create a reference on `rep` or the returned value.
-inline CordRep *SkipCrcNode(CordRep *rep) {
-  assert(rep != nullptr);
-  if (ABSL_PREDICT_FALSE(rep->IsCrc())) {
-    return rep->crc()->child;
-  } else {
-    return rep;
-  }
-}
-
-inline const CordRep *SkipCrcNode(const CordRep *rep) {
-  assert(rep != nullptr);
-  if (ABSL_PREDICT_FALSE(rep->IsCrc())) {
-    return rep->crc()->child;
-  } else {
-    return rep;
-  }
-}
-
-inline CordRepCrc *CordRep::crc() {
-  assert(IsCrc());
-  return static_cast<CordRepCrc *>(this);
-}
-
-inline const CordRepCrc *CordRep::crc() const {
-  assert(IsCrc());
-  return static_cast<const CordRepCrc *>(this);
-}
-
-} // namespace cord_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_CORD_REP_CRC_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_rep_flat.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_rep_flat.h
deleted file mode 100644
index acad5d4790..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_rep_flat.h
+++ /dev/null
@@ -1,193 +0,0 @@
-// Copyright 2020 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_FLAT_H_
-#define ABSL_STRINGS_INTERNAL_CORD_REP_FLAT_H_
-
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <memory>
-
-#include "absl/base/config.h"
-#include "absl/base/macros.h"
-#include "absl/strings/internal/cord_internal.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// Note: all constants below are never ODR used and internal to cord, we define
-// these as static constexpr to avoid 'in struct' definition and usage clutter.
-
-// Largest and smallest flat node lengths we are willing to allocate
-// Flat allocation size is stored in tag, which currently can encode sizes up
-// to 4K, encoded as multiple of either 8 or 32 bytes.
-// If we allow for larger sizes, we need to change this to 8/64, 16/128, etc.
-// kMinFlatSize is bounded by tag needing to be at least FLAT * 8 bytes, and
-// ideally a 'nice' size aligning with allocation and cacheline sizes like 32.
-// kMaxFlatSize is bounded by the size resulting in a computed tag no greater
-// than MAX_FLAT_TAG. MAX_FLAT_TAG provides for additional 'high' tag values.
-static constexpr size_t kFlatOverhead = offsetof(CordRep, storage);
-static constexpr size_t kMinFlatSize = 32;
-static constexpr size_t kMaxFlatSize = 4096;
-static constexpr size_t kMaxFlatLength = kMaxFlatSize - kFlatOverhead;
-static constexpr size_t kMinFlatLength = kMinFlatSize - kFlatOverhead;
-static constexpr size_t kMaxLargeFlatSize = 256 * 1024;
-static constexpr size_t kMaxLargeFlatLength = kMaxLargeFlatSize - kFlatOverhead;
-
-// kTagBase should make the Size <--> Tag computation resilient
-// against changes to the value of FLAT when we add a new tag..
-static constexpr uint8_t kTagBase = FLAT - 4;
-
-// Converts the provided rounded size to the corresponding tag
-constexpr uint8_t AllocatedSizeToTagUnchecked(size_t size) {
-  return static_cast<uint8_t>(size <= 512 ? kTagBase + size / 8
-                              : size <= 8192
-                                  ? kTagBase + 512 / 8 + size / 64 - 512 / 64
-                                  : kTagBase + 512 / 8 + ((8192 - 512) / 64) +
-                                        size / 4096 - 8192 / 4096);
-}
-
-// Converts the provided tag to the corresponding allocated size
-constexpr size_t TagToAllocatedSize(uint8_t tag) {
-  return (tag <= kTagBase + 512 / 8) ? tag * 8 - kTagBase * 8
-         : (tag <= kTagBase + (512 / 8) + ((8192 - 512) / 64))
-             ? 512 + tag * 64 - kTagBase * 64 - 512 / 8 * 64
-             : 8192 + tag * 4096 - kTagBase * 4096 -
-                   ((512 / 8) + ((8192 - 512) / 64)) * 4096;
-}
-
-static_assert(AllocatedSizeToTagUnchecked(kMinFlatSize) == FLAT, "");
-static_assert(AllocatedSizeToTagUnchecked(kMaxLargeFlatSize) == MAX_FLAT_TAG,
-              "");
-
-// RoundUp logically performs `((n + m - 1) / m) * m` to round up to the nearest
-// multiple of `m`, optimized for the invariant that `m` is a power of 2.
-constexpr size_t RoundUp(size_t n, size_t m) { return (n + m - 1) & (0 - m); }
-
-// Returns the size to the nearest equal or larger value that can be
-// expressed exactly as a tag value.
-inline size_t RoundUpForTag(size_t size) {
-  return RoundUp(size, (size <= 512) ? 8 : (size <= 8192 ? 64 : 4096));
-}
-
-// Converts the allocated size to a tag, rounding down if the size
-// does not exactly match a 'tag expressible' size value. The result is
-// undefined if the size exceeds the maximum size that can be encoded in
-// a tag, i.e., if size is larger than TagToAllocatedSize(<max tag>).
-inline uint8_t AllocatedSizeToTag(size_t size) {
-  const uint8_t tag = AllocatedSizeToTagUnchecked(size);
-  assert(tag <= MAX_FLAT_TAG);
-  return tag;
-}
-
-// Converts the provided tag to the corresponding available data length
-constexpr size_t TagToLength(uint8_t tag) {
-  return TagToAllocatedSize(tag) - kFlatOverhead;
-}
-
-// Enforce that kMaxFlatSize maps to a well-known exact tag value.
-static_assert(TagToAllocatedSize(MAX_FLAT_TAG) == kMaxLargeFlatSize,
-              "Bad tag logic");
-
-struct CordRepFlat : public CordRep {
-  // Tag for explicit 'large flat' allocation
-  struct Large {};
-
-  // Creates a new flat node.
-  template <size_t max_flat_size, typename... Args>
-  static CordRepFlat *NewImpl(size_t len, Args... args ABSL_ATTRIBUTE_UNUSED) {
-    if (len <= kMinFlatLength) {
-      len = kMinFlatLength;
-    } else if (len > max_flat_size - kFlatOverhead) {
-      len = max_flat_size - kFlatOverhead;
-    }
-
-    // Round size up so it matches a size we can exactly express in a tag.
-    const size_t size = RoundUpForTag(len + kFlatOverhead);
-    void *const raw_rep = ::operator new(size);
-// GCC 13 has a false-positive -Wstringop-overflow warning here.
-#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(13, 0)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstringop-overflow"
-#endif
-    CordRepFlat *rep = new (raw_rep) CordRepFlat();
-    rep->tag = AllocatedSizeToTag(size);
-#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(13, 0)
-#pragma GCC diagnostic pop
-#endif
-    return rep;
-  }
-
-  static CordRepFlat *New(size_t len) { return NewImpl<kMaxFlatSize>(len); }
-
-  static CordRepFlat *New(Large, size_t len) {
-    return NewImpl<kMaxLargeFlatSize>(len);
-  }
-
-  // Deletes a CordRepFlat instance created previously through a call to New().
-  // Flat CordReps are allocated and constructed with raw ::operator new and
-  // placement new, and must be destructed and deallocated accordingly.
-  static void Delete(CordRep *rep) {
-    assert(rep->tag >= FLAT && rep->tag <= MAX_FLAT_TAG);
-
-#if defined(__cpp_sized_deallocation)
-    size_t size = TagToAllocatedSize(rep->tag);
-    rep->~CordRep();
-    ::operator delete(rep, size);
-#else
-    rep->~CordRep();
-    ::operator delete(rep);
-#endif
-  }
-
-  // Create a CordRepFlat containing `data`, with an optional additional
-  // extra capacity of up to `extra` bytes. Requires that `data.size()`
-  // is less than kMaxFlatLength.
-  static CordRepFlat *Create(absl::string_view data, size_t extra = 0) {
-    assert(data.size() <= kMaxFlatLength);
-    CordRepFlat *flat = New(data.size() + (std::min)(extra, kMaxFlatLength));
-    memcpy(flat->Data(), data.data(), data.size());
-    flat->length = data.size();
-    return flat;
-  }
-
-  // Returns a pointer to the data inside this flat rep.
-  char *Data() { return reinterpret_cast<char *>(storage); }
-  const char *Data() const { return reinterpret_cast<const char *>(storage); }
-
-  // Returns the maximum capacity (payload size) of this instance.
-  size_t Capacity() const { return TagToLength(tag); }
-
-  // Returns the allocated size (payload + overhead) of this instance.
-  size_t AllocatedSize() const { return TagToAllocatedSize(tag); }
-};
-
-// Now that CordRepFlat is defined, we can define CordRep's helper casts:
-inline CordRepFlat *CordRep::flat() {
-  assert(tag >= FLAT && tag <= MAX_FLAT_TAG);
-  return reinterpret_cast<CordRepFlat *>(this);
-}
-
-inline const CordRepFlat *CordRep::flat() const {
-  assert(tag >= FLAT && tag <= MAX_FLAT_TAG);
-  return reinterpret_cast<const CordRepFlat *>(this);
-}
-
-} // namespace cord_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_CORD_REP_FLAT_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_rep_test_util.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_rep_test_util.h
deleted file mode 100644
index d4eb4bd7e6..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/cord_rep_test_util.h
+++ /dev/null
@@ -1,205 +0,0 @@
-// Copyright 2021 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_TEST_UTIL_H_
-#define ABSL_STRINGS_INTERNAL_CORD_REP_TEST_UTIL_H_
-
-#include <cassert>
-#include <memory>
-#include <random>
-#include <string>
-#include <vector>
-
-#include "absl/base/config.h"
-#include "absl/base/internal/raw_logging.h"
-#include "absl/strings/internal/cord_internal.h"
-#include "absl/strings/internal/cord_rep_btree.h"
-#include "absl/strings/internal/cord_rep_flat.h"
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cordrep_testing {
-
-inline cord_internal::CordRepSubstring *
-MakeSubstring(size_t start, size_t len, cord_internal::CordRep *rep) {
-  auto *sub = new cord_internal::CordRepSubstring;
-  sub->tag = cord_internal::SUBSTRING;
-  sub->start = start;
-  sub->length = len <= 0 ? rep->length - start + len : len;
-  sub->child = rep;
-  return sub;
-}
-
-inline cord_internal::CordRepFlat *MakeFlat(absl::string_view value) {
-  assert(value.length() <= cord_internal::kMaxFlatLength);
-  auto *flat = cord_internal::CordRepFlat::New(value.length());
-  flat->length = value.length();
-  memcpy(flat->Data(), value.data(), value.length());
-  return flat;
-}
-
-// Creates an external node for testing
-inline cord_internal::CordRepExternal *MakeExternal(absl::string_view s) {
-  struct Rep : public cord_internal::CordRepExternal {
-    std::string s;
-    explicit Rep(absl::string_view sv) : s(sv) {
-      this->tag = cord_internal::EXTERNAL;
-      this->base = s.data();
-      this->length = s.length();
-      this->releaser_invoker = [](cord_internal::CordRepExternal *self) {
-        delete static_cast<Rep *>(self);
-      };
-    }
-  };
-  return new Rep(s);
-}
-
-inline std::string CreateRandomString(size_t n) {
-  absl::string_view data = "abcdefghijklmnopqrstuvwxyz"
-                           "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                           "0123456789~!@#$%^&*()_+=-<>?:\"{}[]|";
-  std::minstd_rand rnd;
-  std::uniform_int_distribution<size_t> dist(0, data.size() - 1);
-  std::string s(n, ' ');
-  for (size_t i = 0; i < n; ++i) {
-    s[i] = data[dist(rnd)];
-  }
-  return s;
-}
-
-// Creates an array of flats from the provided string, chopping
-// the provided string up into flats of size `chunk_size` characters
-// resulting in roughly `data.size() / chunk_size` total flats.
-inline std::vector<cord_internal::CordRep *>
-CreateFlatsFromString(absl::string_view data, size_t chunk_size) {
-  assert(chunk_size > 0);
-  std::vector<cord_internal::CordRep *> flats;
-  for (absl::string_view s = data; !s.empty(); s.remove_prefix(chunk_size)) {
-    flats.push_back(MakeFlat(s.substr(0, chunk_size)));
-  }
-  return flats;
-}
-
-inline cord_internal::CordRepBtree *
-CordRepBtreeFromFlats(absl::Span<cord_internal::CordRep *const> flats) {
-  assert(!flats.empty());
-  auto *node = cord_internal::CordRepBtree::Create(flats[0]);
-  for (size_t i = 1; i < flats.size(); ++i) {
-    node = cord_internal::CordRepBtree::Append(node, flats[i]);
-  }
-  return node;
-}
-
-template <typename Fn>
-inline void CordVisitReps(cord_internal::CordRep *rep, Fn &&fn) {
-  fn(rep);
-  while (rep->tag == cord_internal::SUBSTRING) {
-    rep = rep->substring()->child;
-    fn(rep);
-  }
-  if (rep->tag == cord_internal::BTREE) {
-    for (cord_internal::CordRep *edge : rep->btree()->Edges()) {
-      CordVisitReps(edge, fn);
-    }
-  }
-}
-
-template <typename Predicate>
-inline std::vector<cord_internal::CordRep *>
-CordCollectRepsIf(Predicate &&predicate, cord_internal::CordRep *rep) {
-  std::vector<cord_internal::CordRep *> reps;
-  CordVisitReps(rep, [&reps, &predicate](cord_internal::CordRep *rep) {
-    if (predicate(rep))
-      reps.push_back(rep);
-  });
-  return reps;
-}
-
-inline std::vector<cord_internal::CordRep *>
-CordCollectReps(cord_internal::CordRep *rep) {
-  std::vector<cord_internal::CordRep *> reps;
-  auto fn = [&reps](cord_internal::CordRep *rep) { reps.push_back(rep); };
-  CordVisitReps(rep, fn);
-  return reps;
-}
-
-inline void CordToString(cord_internal::CordRep *rep, std::string &s) {
-  size_t offset = 0;
-  size_t length = rep->length;
-  while (rep->tag == cord_internal::SUBSTRING) {
-    offset += rep->substring()->start;
-    rep = rep->substring()->child;
-  }
-  if (rep->tag == cord_internal::BTREE) {
-    for (cord_internal::CordRep *edge : rep->btree()->Edges()) {
-      CordToString(edge, s);
-    }
-  } else if (rep->tag >= cord_internal::FLAT) {
-    s.append(rep->flat()->Data() + offset, length);
-  } else if (rep->tag == cord_internal::EXTERNAL) {
-    s.append(rep->external()->base + offset, length);
-  } else {
-    ABSL_RAW_LOG(FATAL, "Unsupported tag %d", rep->tag);
-  }
-}
-
-inline std::string CordToString(cord_internal::CordRep *rep) {
-  std::string s;
-  s.reserve(rep->length);
-  CordToString(rep, s);
-  return s;
-}
-
-// RAII Helper class to automatically unref reps on destruction.
-class AutoUnref {
-public:
-  ~AutoUnref() {
-    for (CordRep *rep : unrefs_)
-      CordRep::Unref(rep);
-  }
-
-  // Adds `rep` to the list of reps to be unreffed at destruction.
-  template <typename CordRepType> CordRepType *Add(CordRepType *rep) {
-    unrefs_.push_back(rep);
-    return rep;
-  }
-
-  // Increments the reference count of `rep` by one, and adds it to
-  // the list of reps to be unreffed at destruction.
-  template <typename CordRepType> CordRepType *Ref(CordRepType *rep) {
-    unrefs_.push_back(CordRep::Ref(rep));
-    return rep;
-  }
-
-  // Increments the reference count of `rep` by one if `condition` is true,
-  // and adds it to the list of reps to be unreffed at destruction.
-  template <typename CordRepType>
-  CordRepType *RefIf(bool condition, CordRepType *rep) {
-    if (condition)
-      unrefs_.push_back(CordRep::Ref(rep));
-    return rep;
-  }
-
-private:
-  using CordRep = absl::cord_internal::CordRep;
-
-  std::vector<CordRep *> unrefs_;
-};
-
-} // namespace cordrep_testing
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_CORD_REP_TEST_UTIL_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/cordz_functions.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/cordz_functions.h
deleted file mode 100644
index ba45d12917..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/cordz_functions.h
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright 2019 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_CORDZ_FUNCTIONS_H_
-#define ABSL_STRINGS_INTERNAL_CORDZ_FUNCTIONS_H_
-
-#include <stdint.h>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/base/optimization.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// Returns the current sample rate. This represents the average interval
-// between samples.
-int32_t get_cordz_mean_interval();
-
-// Sets the sample rate with the average interval between samples.
-void set_cordz_mean_interval(int32_t mean_interval);
-
-// Cordz is only enabled on Linux with thread_local support.
-#if defined(ABSL_INTERNAL_CORDZ_ENABLED)
-#error ABSL_INTERNAL_CORDZ_ENABLED cannot be set directly
-#elif defined(__linux__) && defined(ABSL_HAVE_THREAD_LOCAL)
-#define ABSL_INTERNAL_CORDZ_ENABLED 1
-#endif
-
-#ifdef ABSL_INTERNAL_CORDZ_ENABLED
-
-struct SamplingState {
-  int64_t next_sample;
-  int64_t sample_stride;
-};
-
-// cordz_next_sample is the number of events until the next sample event. If
-// the value is 1 or less, the code will check on the next event if cordz is
-// enabled, and if so, will sample the Cord. cordz is only enabled when we can
-// use thread locals.
-ABSL_CONST_INIT extern thread_local SamplingState cordz_next_sample;
-
-// Determines if the next sample should be profiled.
-// Returns:
-//   0: Do not sample
-//  >0: Sample with the stride of the last sampling period
-int64_t cordz_should_profile_slow(SamplingState &state);
-
-// Determines if the next sample should be profiled.
-// Returns:
-//   0: Do not sample
-//  >0: Sample with the stride of the last sampling period
-inline int64_t cordz_should_profile() {
-  if (ABSL_PREDICT_TRUE(cordz_next_sample.next_sample > 1)) {
-    cordz_next_sample.next_sample--;
-    return 0;
-  }
-  return cordz_should_profile_slow(cordz_next_sample);
-}
-
-// Sets the interval until the next sample (for testing only)
-void cordz_set_next_sample_for_testing(int64_t next_sample);
-
-#else // ABSL_INTERNAL_CORDZ_ENABLED
-
-inline int64_t cordz_should_profile() { return 0; }
-inline void cordz_set_next_sample_for_testing(int64_t) {}
-
-#endif // ABSL_INTERNAL_CORDZ_ENABLED
-
-} // namespace cord_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_CORDZ_FUNCTIONS_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/cordz_handle.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/cordz_handle.h
deleted file mode 100644
index e751d86dc0..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/cordz_handle.h
+++ /dev/null
@@ -1,98 +0,0 @@
-// Copyright 2019 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_CORDZ_HANDLE_H_
-#define ABSL_STRINGS_INTERNAL_CORDZ_HANDLE_H_
-
-#include <atomic>
-#include <vector>
-
-#include "absl/base/config.h"
-#include "absl/base/internal/raw_logging.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// This base class allows multiple types of object (CordzInfo and
-// CordzSampleToken) to exist simultaneously on the delete queue (pointed to by
-// global_dq_tail and traversed using dq_prev_ and dq_next_). The
-// delete queue guarantees that once a profiler creates a CordzSampleToken and
-// has gained visibility into a CordzInfo object, that CordzInfo object will not
-// be deleted prematurely. This allows the profiler to inspect all CordzInfo
-// objects that are alive without needing to hold a global lock.
-class ABSL_DLL CordzHandle {
-public:
-  CordzHandle() : CordzHandle(false) {}
-
-  bool is_snapshot() const { return is_snapshot_; }
-
-  // Returns true if this instance is safe to be deleted because it is either a
-  // snapshot, which is always safe to delete, or not included in the global
-  // delete queue and thus not included in any snapshot.
-  // Callers are responsible for making sure this instance can not be newly
-  // discovered by other threads. For example, CordzInfo instances first de-list
-  // themselves from the global CordzInfo list before determining if they are
-  // safe to be deleted directly.
-  // If SafeToDelete returns false, callers MUST use the Delete() method to
-  // safely queue CordzHandle instances for deletion.
-  bool SafeToDelete() const;
-
-  // Deletes the provided instance, or puts it on the delete queue to be deleted
-  // once there are no more sample tokens (snapshot) instances potentially
-  // referencing the instance. `handle` should not be null.
-  static void Delete(CordzHandle *handle);
-
-  // Returns the current entries in the delete queue in LIFO order.
-  static std::vector<const CordzHandle *> DiagnosticsGetDeleteQueue();
-
-  // Returns true if the provided handle is nullptr or guarded by this handle.
-  // Since the CordzSnapshot token is itself a CordzHandle, this method will
-  // allow tests to check if that token is keeping an arbitrary CordzHandle
-  // alive.
-  bool DiagnosticsHandleIsSafeToInspect(const CordzHandle *handle) const;
-
-  // Returns the current entries in the delete queue, in LIFO order, that are
-  // protected by this. CordzHandle objects are only placed on the delete queue
-  // after CordzHandle::Delete is called with them as an argument. Only
-  // CordzHandle objects that are not also CordzSnapshot objects will be
-  // included in the return vector. For each of the handles in the return
-  // vector, the earliest that their memory can be freed is when this
-  // CordzSnapshot object is deleted.
-  std::vector<const CordzHandle *> DiagnosticsGetSafeToInspectDeletedHandles();
-
-protected:
-  explicit CordzHandle(bool is_snapshot);
-  virtual ~CordzHandle();
-
-private:
-  const bool is_snapshot_;
-
-  // dq_prev_ and dq_next_ require the global queue mutex to be held.
-  // Unfortunately we can't use thread annotations such that the thread safety
-  // analysis understands that queue_ and global_queue_ are one and the same.
-  CordzHandle *dq_prev_ = nullptr;
-  CordzHandle *dq_next_ = nullptr;
-};
-
-class CordzSnapshot : public CordzHandle {
-public:
-  CordzSnapshot() : CordzHandle(true) {}
-};
-
-} // namespace cord_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_CORDZ_HANDLE_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/cordz_info.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/cordz_info.h
deleted file mode 100644
index 2e0c05bd7b..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/cordz_info.h
+++ /dev/null
@@ -1,304 +0,0 @@
-// Copyright 2019 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_CORDZ_INFO_H_
-#define ABSL_STRINGS_INTERNAL_CORDZ_INFO_H_
-
-#include <atomic>
-#include <cstdint>
-#include <functional>
-
-#include "absl/base/config.h"
-#include "absl/base/internal/raw_logging.h"
-#include "absl/base/internal/spinlock.h"
-#include "absl/base/thread_annotations.h"
-#include "absl/strings/internal/cord_internal.h"
-#include "absl/strings/internal/cordz_functions.h"
-#include "absl/strings/internal/cordz_handle.h"
-#include "absl/strings/internal/cordz_statistics.h"
-#include "absl/strings/internal/cordz_update_tracker.h"
-#include "absl/synchronization/mutex.h"
-#include "absl/types/span.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// CordzInfo tracks a profiled Cord. Each of these objects can be in two places.
-// If a Cord is alive, the CordzInfo will be in the global_cordz_infos map, and
-// can also be retrieved via the linked list starting with
-// global_cordz_infos_head and continued via the cordz_info_next() method. When
-// a Cord has reached the end of its lifespan, the CordzInfo object will be
-// migrated out of the global_cordz_infos list and the global_cordz_infos_map,
-// and will either be deleted or appended to the global_delete_queue. If it is
-// placed on the global_delete_queue, the CordzInfo object will be cleaned in
-// the destructor of a CordzSampleToken object.
-class ABSL_LOCKABLE CordzInfo : public CordzHandle {
-public:
-  using MethodIdentifier = CordzUpdateTracker::MethodIdentifier;
-
-  // TrackCord creates a CordzInfo instance which tracks important metrics of
-  // a sampled cord, and stores the created CordzInfo instance into `cord'. All
-  // CordzInfo instances are placed in a global list which is used to discover
-  // and snapshot all actively tracked cords. Callers are responsible for
-  // calling UntrackCord() before the tracked Cord instance is deleted, or to
-  // stop tracking the sampled Cord. Callers are also responsible for guarding
-  // changes to the 'tree' value of a Cord (InlineData.tree) through the Lock()
-  // and Unlock() calls. Any change resulting in a new tree value for the cord
-  // requires a call to SetCordRep() before the old tree has been unreffed
-  // and/or deleted. `method` identifies the Cord public API method initiating
-  // the cord to be sampled.
-  // Requires `cord` to hold a tree, and `cord.cordz_info()` to be null.
-  static void TrackCord(InlineData &cord, MethodIdentifier method,
-                        int64_t sampling_stride);
-
-  // Identical to TrackCord(), except that this function fills the
-  // `parent_stack` and `parent_method` properties of the returned CordzInfo
-  // instance from the provided `src` instance if `src` is sampled.
-  // This function should be used for sampling 'copy constructed' and 'copy
-  // assigned' cords. This function allows 'cord` to be already sampled, in
-  // which case the CordzInfo will be newly created from `src`.
-  static void TrackCord(InlineData &cord, const InlineData &src,
-                        MethodIdentifier method);
-
-  // Maybe sample the cord identified by 'cord' for method 'method'.
-  // Uses `cordz_should_profile` to randomly pick cords to be sampled, and if
-  // so, invokes `TrackCord` to start sampling `cord`.
-  static void MaybeTrackCord(InlineData &cord, MethodIdentifier method);
-
-  // Maybe sample the cord identified by 'cord' for method 'method'.
-  // `src` identifies a 'parent' cord which is assigned to `cord`, typically the
-  // input cord for a copy constructor, or an assign method such as `operator=`
-  // `cord` will be sampled if (and only if) `src` is sampled.
-  // If `cord` is currently being sampled and `src` is not being sampled, then
-  // this function will stop sampling the cord and reset the cord's cordz_info.
-  //
-  // Previously this function defined that `cord` will be sampled if either
-  // `src` is sampled, or if `cord` is randomly picked for sampling. However,
-  // this can cause issues, as there may be paths where some cord is assigned an
-  // indirect copy of it's own value. As such a 'string of copies' would then
-  // remain sampled (`src.is_profiled`), then assigning such a cord back to
-  // 'itself' creates a cycle where the cord will converge to 'always sampled`.
-  //
-  // For example:
-  //
-  //   Cord x;
-  //   for (...) {
-  //     // Copy ctor --> y.is_profiled := x.is_profiled | random(...)
-  //     Cord y = x;
-  //     ...
-  //     // Assign x = y --> x.is_profiled = y.is_profiled | random(...)
-  //     //              ==> x.is_profiled |= random(...)
-  //     //              ==> x converges to 'always profiled'
-  //     x = y;
-  //   }
-  static void MaybeTrackCord(InlineData &cord, const InlineData &src,
-                             MethodIdentifier method);
-
-  // Stops tracking changes for a sampled cord, and deletes the provided info.
-  // This function must be called before the sampled cord instance is deleted,
-  // and before the root cordrep of the sampled cord is unreffed.
-  // This function may extend the lifetime of the cordrep in cases where the
-  // CordInfo instance is being held by a concurrent collection thread.
-  void Untrack();
-
-  // Invokes UntrackCord() on `info` if `info` is not null.
-  static void MaybeUntrackCord(CordzInfo *info);
-
-  CordzInfo() = delete;
-  CordzInfo(const CordzInfo &) = delete;
-  CordzInfo &operator=(const CordzInfo &) = delete;
-
-  // Retrieves the oldest existing CordzInfo.
-  static CordzInfo *
-  Head(const CordzSnapshot &snapshot) ABSL_NO_THREAD_SAFETY_ANALYSIS;
-
-  // Retrieves the next oldest existing CordzInfo older than 'this' instance.
-  CordzInfo *
-  Next(const CordzSnapshot &snapshot) const ABSL_NO_THREAD_SAFETY_ANALYSIS;
-
-  // Locks this instance for the update identified by `method`.
-  // Increases the count for `method` in `update_tracker`.
-  void Lock(MethodIdentifier method) ABSL_EXCLUSIVE_LOCK_FUNCTION(mutex_);
-
-  // Unlocks this instance. If the contained `rep` has been set to null
-  // indicating the Cord has been cleared or is otherwise no longer sampled,
-  // then this method will delete this CordzInfo instance.
-  void Unlock() ABSL_UNLOCK_FUNCTION(mutex_);
-
-  // Asserts that this CordzInfo instance is locked.
-  void AssertHeld() ABSL_ASSERT_EXCLUSIVE_LOCK(mutex_);
-
-  // Updates the `rep` property of this instance. This methods is invoked by
-  // Cord logic each time the root node of a sampled Cord changes, and before
-  // the old root reference count is deleted. This guarantees that collection
-  // code can always safely take a reference on the tracked cord.
-  // Requires a lock to be held through the `Lock()` method.
-  // TODO(b/117940323): annotate with ABSL_EXCLUSIVE_LOCKS_REQUIRED once all
-  // Cord code is in a state where this can be proven true by the compiler.
-  void SetCordRep(CordRep *rep);
-
-  // Returns the current `rep` property of this instance with a reference
-  // added, or null if this instance represents a cord that has since been
-  // deleted or untracked.
-  CordRep *RefCordRep() const ABSL_LOCKS_EXCLUDED(mutex_);
-
-  // Returns the current value of `rep_` for testing purposes only.
-  CordRep *GetCordRepForTesting() const ABSL_NO_THREAD_SAFETY_ANALYSIS {
-    return rep_;
-  }
-
-  // Sets the current value of `rep_` for testing purposes only.
-  void SetCordRepForTesting(CordRep *rep) ABSL_NO_THREAD_SAFETY_ANALYSIS {
-    rep_ = rep;
-  }
-
-  // Returns the stack trace for where the cord was first sampled. Cords are
-  // potentially sampled when they promote from an inlined cord to a tree or
-  // ring representation, which is not necessarily the location where the cord
-  // was first created. Some cords are created as inlined cords, and only as
-  // data is added do they become a non-inlined cord. However, typically the
-  // location represents reasonably well where the cord is 'created'.
-  absl::Span<void *const> GetStack() const;
-
-  // Returns the stack trace for a sampled cord's 'parent stack trace'. This
-  // value may be set if the cord is sampled (promoted) after being created
-  // from, or being assigned the value of an existing (sampled) cord.
-  absl::Span<void *const> GetParentStack() const;
-
-  // Retrieves the CordzStatistics associated with this Cord. The statistics
-  // are only updated when a Cord goes through a mutation, such as an Append
-  // or RemovePrefix.
-  CordzStatistics GetCordzStatistics() const;
-
-  int64_t sampling_stride() const { return sampling_stride_; }
-
-private:
-  using SpinLock = absl::base_internal::SpinLock;
-  using SpinLockHolder = ::absl::base_internal::SpinLockHolder;
-
-  // Global cordz info list. CordzInfo stores a pointer to the global list
-  // instance to harden against ODR violations.
-  struct List {
-    constexpr explicit List(absl::ConstInitType)
-        : mutex(absl::kConstInit,
-                absl::base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL) {}
-
-    SpinLock mutex;
-    std::atomic<CordzInfo *> head ABSL_GUARDED_BY(mutex){nullptr};
-  };
-
-  static constexpr size_t kMaxStackDepth = 64;
-
-  explicit CordzInfo(CordRep *rep, const CordzInfo *src,
-                     MethodIdentifier method, int64_t weight);
-  ~CordzInfo() override;
-
-  // Sets `rep_` without holding a lock.
-  void UnsafeSetCordRep(CordRep *rep) ABSL_NO_THREAD_SAFETY_ANALYSIS;
-
-  void Track();
-
-  // Returns the parent method from `src`, which is either `parent_method_` or
-  // `method_` depending on `parent_method_` being kUnknown.
-  // Returns kUnknown if `src` is null.
-  static MethodIdentifier GetParentMethod(const CordzInfo *src);
-
-  // Fills the provided stack from `src`, copying either `parent_stack_` or
-  // `stack_` depending on `parent_stack_` being empty, returning the size of
-  // the parent stack.
-  // Returns 0 if `src` is null.
-  static size_t FillParentStack(const CordzInfo *src, void **stack);
-
-  void ODRCheck() const {
-#ifndef NDEBUG
-    ABSL_RAW_CHECK(list_ == &global_list_, "ODR violation in Cord");
-#endif
-  }
-
-  // Non-inlined implementation of `MaybeTrackCord`, which is executed if
-  // either `src` is sampled or `cord` is sampled, and either untracks or
-  // tracks `cord` as documented per `MaybeTrackCord`.
-  static void MaybeTrackCordImpl(InlineData &cord, const InlineData &src,
-                                 MethodIdentifier method);
-
-  ABSL_CONST_INIT static List global_list_;
-  List *const list_ = &global_list_;
-
-  // ci_prev_ and ci_next_ require the global list mutex to be held.
-  // Unfortunately we can't use thread annotations such that the thread safety
-  // analysis understands that list_ and global_list_ are one and the same.
-  std::atomic<CordzInfo *> ci_prev_{nullptr};
-  std::atomic<CordzInfo *> ci_next_{nullptr};
-
-  mutable absl::Mutex mutex_;
-  CordRep *rep_ ABSL_GUARDED_BY(mutex_);
-
-  void *stack_[kMaxStackDepth];
-  void *parent_stack_[kMaxStackDepth];
-  const size_t stack_depth_;
-  const size_t parent_stack_depth_;
-  const MethodIdentifier method_;
-  const MethodIdentifier parent_method_;
-  CordzUpdateTracker update_tracker_;
-  const absl::Time create_time_;
-  const int64_t sampling_stride_;
-};
-
-inline ABSL_ATTRIBUTE_ALWAYS_INLINE void
-CordzInfo::MaybeTrackCord(InlineData &cord, MethodIdentifier method) {
-  auto stride = cordz_should_profile();
-  if (ABSL_PREDICT_FALSE(stride > 0)) {
-    TrackCord(cord, method, stride);
-  }
-}
-
-inline ABSL_ATTRIBUTE_ALWAYS_INLINE void
-CordzInfo::MaybeTrackCord(InlineData &cord, const InlineData &src,
-                          MethodIdentifier method) {
-  if (ABSL_PREDICT_FALSE(InlineData::is_either_profiled(cord, src))) {
-    MaybeTrackCordImpl(cord, src, method);
-  }
-}
-
-inline ABSL_ATTRIBUTE_ALWAYS_INLINE void
-CordzInfo::MaybeUntrackCord(CordzInfo *info) {
-  if (ABSL_PREDICT_FALSE(info)) {
-    info->Untrack();
-  }
-}
-
-inline void CordzInfo::AssertHeld() ABSL_ASSERT_EXCLUSIVE_LOCK(mutex_) {
-#ifndef NDEBUG
-  mutex_.AssertHeld();
-#endif
-}
-
-inline void CordzInfo::SetCordRep(CordRep *rep) {
-  AssertHeld();
-  rep_ = rep;
-}
-
-inline void CordzInfo::UnsafeSetCordRep(CordRep *rep) { rep_ = rep; }
-
-inline CordRep *CordzInfo::RefCordRep() const ABSL_LOCKS_EXCLUDED(mutex_) {
-  MutexLock lock(&mutex_);
-  return rep_ ? CordRep::Ref(rep_) : nullptr;
-}
-
-} // namespace cord_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_CORDZ_INFO_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/cordz_sample_token.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/cordz_sample_token.h
deleted file mode 100644
index ba601a511b..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/cordz_sample_token.h
+++ /dev/null
@@ -1,97 +0,0 @@
-// Copyright 2019 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "absl/base/config.h"
-#include "absl/strings/internal/cordz_handle.h"
-#include "absl/strings/internal/cordz_info.h"
-
-#ifndef ABSL_STRINGS_INTERNAL_CORDZ_SAMPLE_TOKEN_H_
-#define ABSL_STRINGS_INTERNAL_CORDZ_SAMPLE_TOKEN_H_
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// The existence of a CordzSampleToken guarantees that a reader can traverse the
-// global_cordz_infos_head linked-list without needing to hold a mutex. When a
-// CordzSampleToken exists, all CordzInfo objects that would be destroyed are
-// instead appended to a deletion queue. When the CordzSampleToken is destroyed,
-// it will also clean up any of these CordzInfo objects.
-//
-// E.g., ST are CordzSampleToken objects and CH are CordzHandle objects.
-//   ST1 <- CH1 <- CH2 <- ST2 <- CH3 <- global_delete_queue_tail
-//
-// This list tracks that CH1 and CH2 were created after ST1, so the thread
-// holding ST1 might have a reference to CH1, CH2, ST2, and CH3. However, ST2
-// was created later, so the thread holding the ST2 token cannot have a
-// reference to ST1, CH1, or CH2. If ST1 is cleaned up first, that thread will
-// delete ST1, CH1, and CH2. If instead ST2 is cleaned up first, that thread
-// will only delete ST2.
-//
-// If ST1 is cleaned up first, the new list will be:
-//   ST2 <- CH3 <- global_delete_queue_tail
-//
-// If ST2 is cleaned up first, the new list will be:
-//   ST1 <- CH1 <- CH2 <- CH3 <- global_delete_queue_tail
-//
-// All new CordzHandle objects are appended to the list, so if a new thread
-// comes along before either ST1 or ST2 are cleaned up, the new list will be:
-//   ST1 <- CH1 <- CH2 <- ST2 <- CH3 <- ST3 <- global_delete_queue_tail
-//
-// A thread must hold the global_delete_queue_mu mutex whenever it's altering
-// this list.
-//
-// It is safe for thread that holds a CordzSampleToken to read
-// global_cordz_infos at any time since the objects it is able to retrieve will
-// not be deleted while the CordzSampleToken exists.
-class CordzSampleToken : public CordzSnapshot {
-public:
-  class Iterator {
-  public:
-    using iterator_category = std::input_iterator_tag;
-    using value_type = const CordzInfo &;
-    using difference_type = ptrdiff_t;
-    using pointer = const CordzInfo *;
-    using reference = value_type;
-
-    Iterator() = default;
-
-    Iterator &operator++();
-    Iterator operator++(int);
-    friend bool operator==(const Iterator &lhs, const Iterator &rhs);
-    friend bool operator!=(const Iterator &lhs, const Iterator &rhs);
-    reference operator*() const;
-    pointer operator->() const;
-
-  private:
-    friend class CordzSampleToken;
-    explicit Iterator(const CordzSampleToken *token);
-
-    const CordzSampleToken *token_ = nullptr;
-    pointer current_ = nullptr;
-  };
-
-  CordzSampleToken() = default;
-  CordzSampleToken(const CordzSampleToken &) = delete;
-  CordzSampleToken &operator=(const CordzSampleToken &) = delete;
-
-  Iterator begin() { return Iterator(this); }
-  Iterator end() { return Iterator(); }
-};
-
-} // namespace cord_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_CORDZ_SAMPLE_TOKEN_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/cordz_statistics.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/cordz_statistics.h
deleted file mode 100644
index b859fd629c..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/cordz_statistics.h
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright 2019 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_CORDZ_STATISTICS_H_
-#define ABSL_STRINGS_INTERNAL_CORDZ_STATISTICS_H_
-
-#include <cstdint>
-
-#include "absl/base/config.h"
-#include "absl/strings/internal/cordz_update_tracker.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// CordzStatistics captures some meta information about a Cord's shape.
-struct CordzStatistics {
-  using MethodIdentifier = CordzUpdateTracker::MethodIdentifier;
-
-  // Node counts information
-  struct NodeCounts {
-    size_t flat = 0;      // #flats
-    size_t flat_64 = 0;   // #flats up to 64 bytes
-    size_t flat_128 = 0;  // #flats up to 128 bytes
-    size_t flat_256 = 0;  // #flats up to 256 bytes
-    size_t flat_512 = 0;  // #flats up to 512 bytes
-    size_t flat_1k = 0;   // #flats up to 1K bytes
-    size_t external = 0;  // #external reps
-    size_t substring = 0; // #substring reps
-    size_t concat = 0;    // #concat reps
-    size_t ring = 0;      // #ring buffer reps
-    size_t btree = 0;     // #btree reps
-    size_t crc = 0;       // #crc reps
-  };
-
-  // The size of the cord in bytes. This matches the result of Cord::size().
-  size_t size = 0;
-
-  // The estimated memory used by the sampled cord. This value matches the
-  // value as reported by Cord::EstimatedMemoryUsage().
-  // A value of 0 implies the property has not been recorded.
-  size_t estimated_memory_usage = 0;
-
-  // The effective memory used by the sampled cord, inversely weighted by the
-  // effective indegree of each allocated node. This is a representation of the
-  // fair share of memory usage that should be attributed to the sampled cord.
-  // This value is more useful for cases where one or more nodes are referenced
-  // by multiple Cord instances, and for cases where a Cord includes the same
-  // node multiple times (either directly or indirectly).
-  // A value of 0 implies the property has not been recorded.
-  size_t estimated_fair_share_memory_usage = 0;
-
-  // The total number of nodes referenced by this cord.
-  // For ring buffer Cords, this includes the 'ring buffer' node.
-  // For btree Cords, this includes all 'CordRepBtree' tree nodes as well as all
-  // the substring, flat and external nodes referenced by the tree.
-  // A value of 0 implies the property has not been recorded.
-  size_t node_count = 0;
-
-  // Detailed node counts per type
-  NodeCounts node_counts;
-
-  // The cord method responsible for sampling the cord.
-  MethodIdentifier method = MethodIdentifier::kUnknown;
-
-  // The cord method responsible for sampling the parent cord if applicable.
-  MethodIdentifier parent_method = MethodIdentifier::kUnknown;
-
-  // Update tracker tracking invocation count per cord method.
-  CordzUpdateTracker update_tracker;
-};
-
-} // namespace cord_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_CORDZ_STATISTICS_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/cordz_update_scope.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/cordz_update_scope.h
deleted file mode 100644
index a2ce3058a8..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/cordz_update_scope.h
+++ /dev/null
@@ -1,71 +0,0 @@
-// Copyright 2021 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_SCOPE_H_
-#define ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_SCOPE_H_
-
-#include "absl/base/config.h"
-#include "absl/base/optimization.h"
-#include "absl/base/thread_annotations.h"
-#include "absl/strings/internal/cord_internal.h"
-#include "absl/strings/internal/cordz_info.h"
-#include "absl/strings/internal/cordz_update_tracker.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// CordzUpdateScope scopes an update to the provided CordzInfo.
-// The class invokes `info->Lock(method)` and `info->Unlock()` to guard
-// cordrep updates. This class does nothing if `info` is null.
-// See also the 'Lock`, `Unlock` and `SetCordRep` methods in `CordzInfo`.
-class ABSL_SCOPED_LOCKABLE CordzUpdateScope {
-public:
-  CordzUpdateScope(CordzInfo *info, CordzUpdateTracker::MethodIdentifier method)
-      ABSL_EXCLUSIVE_LOCK_FUNCTION(info)
-      : info_(info) {
-    if (ABSL_PREDICT_FALSE(info_)) {
-      info->Lock(method);
-    }
-  }
-
-  // CordzUpdateScope can not be copied or assigned to.
-  CordzUpdateScope(CordzUpdateScope &&rhs) = delete;
-  CordzUpdateScope(const CordzUpdateScope &) = delete;
-  CordzUpdateScope &operator=(CordzUpdateScope &&rhs) = delete;
-  CordzUpdateScope &operator=(const CordzUpdateScope &) = delete;
-
-  ~CordzUpdateScope() ABSL_UNLOCK_FUNCTION() {
-    if (ABSL_PREDICT_FALSE(info_)) {
-      info_->Unlock();
-    }
-  }
-
-  void SetCordRep(CordRep *rep) const {
-    if (ABSL_PREDICT_FALSE(info_)) {
-      info_->SetCordRep(rep);
-    }
-  }
-
-  CordzInfo *info() const { return info_; }
-
-private:
-  CordzInfo *info_;
-};
-
-} // namespace cord_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_SCOPE_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/cordz_update_tracker.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/cordz_update_tracker.h
deleted file mode 100644
index 21cdcedb0e..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/cordz_update_tracker.h
+++ /dev/null
@@ -1,123 +0,0 @@
-// Copyright 2021 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_TRACKER_H_
-#define ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_TRACKER_H_
-
-#include <atomic>
-#include <cstdint>
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// CordzUpdateTracker tracks counters for Cord update methods.
-//
-// The purpose of CordzUpdateTracker is to track the number of calls to methods
-// updating Cord data for sampled cords. The class internally uses 'lossy'
-// atomic operations: Cord is thread-compatible, so there is no need to
-// synchronize updates. However, Cordz collection threads may call 'Value()' at
-// any point, so the class needs to provide thread safe access.
-//
-// This class is thread-safe. But as per above comments, all non-const methods
-// should be used single-threaded only: updates are thread-safe but lossy.
-class CordzUpdateTracker {
-public:
-  // Tracked update methods.
-  enum MethodIdentifier {
-    kUnknown,
-    kAppendCord,
-    kAppendCordBuffer,
-    kAppendExternalMemory,
-    kAppendString,
-    kAssignCord,
-    kAssignString,
-    kClear,
-    kConstructorCord,
-    kConstructorString,
-    kCordReader,
-    kFlatten,
-    kGetAppendBuffer,
-    kGetAppendRegion,
-    kMakeCordFromExternal,
-    kMoveAppendCord,
-    kMoveAssignCord,
-    kMovePrependCord,
-    kPrependCord,
-    kPrependCordBuffer,
-    kPrependString,
-    kRemovePrefix,
-    kRemoveSuffix,
-    kSetExpectedChecksum,
-    kSubCord,
-
-    // kNumMethods defines the number of entries: must be the last entry.
-    kNumMethods,
-  };
-
-  // Constructs a new instance. All counters are zero-initialized.
-  constexpr CordzUpdateTracker() noexcept : values_{} {}
-
-  // Copy constructs a new instance.
-  CordzUpdateTracker(const CordzUpdateTracker &rhs) noexcept { *this = rhs; }
-
-  // Assigns the provided value to this instance.
-  CordzUpdateTracker &operator=(const CordzUpdateTracker &rhs) noexcept {
-    for (int i = 0; i < kNumMethods; ++i) {
-      values_[i].store(rhs.values_[i].load(std::memory_order_relaxed),
-                       std::memory_order_relaxed);
-    }
-    return *this;
-  }
-
-  // Returns the value for the specified method.
-  int64_t Value(MethodIdentifier method) const {
-    return values_[method].load(std::memory_order_relaxed);
-  }
-
-  // Increases the value for the specified method by `n`
-  void LossyAdd(MethodIdentifier method, int64_t n = 1) {
-    auto &value = values_[method];
-    value.store(value.load(std::memory_order_relaxed) + n,
-                std::memory_order_relaxed);
-  }
-
-  // Adds all the values from `src` to this instance
-  void LossyAdd(const CordzUpdateTracker &src) {
-    for (int i = 0; i < kNumMethods; ++i) {
-      MethodIdentifier method = static_cast<MethodIdentifier>(i);
-      if (int64_t value = src.Value(method)) {
-        LossyAdd(method, value);
-      }
-    }
-  }
-
-private:
-  // Until C++20 std::atomic is not constexpr default-constructible, so we need
-  // a wrapper for this class to be constexpr constructible.
-  class Counter : public std::atomic<int64_t> {
-  public:
-    constexpr Counter() noexcept : std::atomic<int64_t>(0) {}
-  };
-
-  Counter values_[kNumMethods];
-};
-
-} // namespace cord_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_TRACKER_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/damerau_levenshtein_distance.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/damerau_levenshtein_distance.h
deleted file mode 100644
index 53d6c5961a..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/damerau_levenshtein_distance.h
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright 2022 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_DAMERAU_LEVENSHTEIN_DISTANCE_H_
-#define ABSL_STRINGS_INTERNAL_DAMERAU_LEVENSHTEIN_DISTANCE_H_
-
-#include <cstdint>
-
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-// Calculate DamerauLevenshtein distance between two strings.
-// When the distance is larger than cutoff, the code just returns cutoff + 1.
-uint8_t CappedDamerauLevenshteinDistance(absl::string_view s1,
-                                         absl::string_view s2, uint8_t cutoff);
-
-} // namespace strings_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_DAMERAU_LEVENSHTEIN_DISTANCE_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/escaping.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/escaping.h
deleted file mode 100644
index 8f936ddb12..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/escaping.h
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2020 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_ESCAPING_H_
-#define ABSL_STRINGS_INTERNAL_ESCAPING_H_
-
-#include <cassert>
-
-#include "absl/strings/internal/resize_uninitialized.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-ABSL_CONST_INIT extern const char kBase64Chars[];
-ABSL_CONST_INIT extern const char kWebSafeBase64Chars[];
-
-// Calculates the length of a Base64 encoding (RFC 4648) of a string of length
-// `input_len`, with or without padding per `do_padding`. Note that 'web-safe'
-// encoding (section 5 of the RFC) does not change this length.
-size_t CalculateBase64EscapedLenInternal(size_t input_len, bool do_padding);
-
-// Base64-encodes `src` using the alphabet provided in `base64` (which
-// determines whether to do web-safe encoding or not) and writes the result to
-// `dest`. If `do_padding` is true, `dest` is padded with '=' chars until its
-// length is a multiple of 3. Returns the length of `dest`.
-size_t Base64EscapeInternal(const unsigned char *src, size_t szsrc, char *dest,
-                            size_t szdest, const char *base64, bool do_padding);
-template <typename String>
-void Base64EscapeInternal(const unsigned char *src, size_t szsrc, String *dest,
-                          bool do_padding, const char *base64_chars) {
-  const size_t calc_escaped_size =
-      CalculateBase64EscapedLenInternal(szsrc, do_padding);
-  STLStringResizeUninitialized(dest, calc_escaped_size);
-
-  const size_t escaped_len = Base64EscapeInternal(
-      src, szsrc, &(*dest)[0], dest->size(), base64_chars, do_padding);
-  assert(calc_escaped_size == escaped_len);
-  dest->erase(escaped_len);
-}
-
-} // namespace strings_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_ESCAPING_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/escaping_test_common.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/escaping_test_common.h
deleted file mode 100644
index 1c812f2a74..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/escaping_test_common.h
+++ /dev/null
@@ -1,135 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// This test contains common things needed by both escaping_test.cc and
-// escaping_benchmark.cc.
-
-#ifndef ABSL_STRINGS_INTERNAL_ESCAPING_TEST_COMMON_H_
-#define ABSL_STRINGS_INTERNAL_ESCAPING_TEST_COMMON_H_
-
-#include "absl/strings/string_view.h"
-#include <array>
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-struct base64_testcase {
-  absl::string_view plaintext;
-  absl::string_view cyphertext;
-};
-
-inline const std::array<base64_testcase, 5> &base64_strings() {
-  static const std::array<base64_testcase, 5> testcase{{
-      // Some google quotes
-      // Cyphertext created with "uuencode (GNU sharutils) 4.6.3"
-      // (Note that we're testing the websafe encoding, though, so if
-      // you add messages, be sure to run "tr -- '+/' '-_'" on the output)
-      {"I was always good at math and science, and I never realized "
-       "that was unusual or somehow undesirable. So one of the things "
-       "I care a lot about is helping to remove that stigma, "
-       "to show girls that you can be feminine, you can like the things "
-       "that girls like, but you can also be really good at technology. "
-       "You can be really good at building things."
-       " - Marissa Meyer, Newsweek, 2010-12-22"
-       "\n",
-
-       "SSB3YXMgYWx3YXlzIGdvb2QgYXQgbWF0aCBhbmQgc2NpZW5jZSwgYW5kIEkg"
-       "bmV2ZXIgcmVhbGl6ZWQgdGhhdCB3YXMgdW51c3VhbCBvciBzb21laG93IHVu"
-       "ZGVzaXJhYmxlLiBTbyBvbmUgb2YgdGhlIHRoaW5ncyBJIGNhcmUgYSBsb3Qg"
-       "YWJvdXQgaXMgaGVscGluZyB0byByZW1vdmUgdGhhdCBzdGlnbWEsIHRvIHNo"
-       "b3cgZ2lybHMgdGhhdCB5b3UgY2FuIGJlIGZlbWluaW5lLCB5b3UgY2FuIGxp"
-       "a2UgdGhlIHRoaW5ncyB0aGF0IGdpcmxzIGxpa2UsIGJ1dCB5b3UgY2FuIGFs"
-       "c28gYmUgcmVhbGx5IGdvb2QgYXQgdGVjaG5vbG9neS4gWW91IGNhbiBiZSBy"
-       "ZWFsbHkgZ29vZCBhdCBidWlsZGluZyB0aGluZ3MuIC0gTWFyaXNzYSBNZXll"
-       "ciwgTmV3c3dlZWssIDIwMTAtMTItMjIK"},
-
-      {"Typical first year for a new cluster: "
-       "~0.5 overheating "
-       "~1 PDU failure "
-       "~1 rack-move "
-       "~1 network rewiring "
-       "~20 rack failures "
-       "~5 racks go wonky "
-       "~8 network maintenances "
-       "~12 router reloads "
-       "~3 router failures "
-       "~dozens of minor 30-second blips for dns "
-       "~1000 individual machine failures "
-       "~thousands of hard drive failures "
-       "slow disks, bad memory, misconfigured machines, flaky machines, etc."
-       " - Jeff Dean, The Joys of Real Hardware"
-       "\n",
-
-       "VHlwaWNhbCBmaXJzdCB5ZWFyIGZvciBhIG5ldyBjbHVzdGVyOiB-MC41IG92"
-       "ZXJoZWF0aW5nIH4xIFBEVSBmYWlsdXJlIH4xIHJhY2stbW92ZSB-MSBuZXR3"
-       "b3JrIHJld2lyaW5nIH4yMCByYWNrIGZhaWx1cmVzIH41IHJhY2tzIGdvIHdv"
-       "bmt5IH44IG5ldHdvcmsgbWFpbnRlbmFuY2VzIH4xMiByb3V0ZXIgcmVsb2Fk"
-       "cyB-MyByb3V0ZXIgZmFpbHVyZXMgfmRvemVucyBvZiBtaW5vciAzMC1zZWNv"
-       "bmQgYmxpcHMgZm9yIGRucyB-MTAwMCBpbmRpdmlkdWFsIG1hY2hpbmUgZmFp"
-       "bHVyZXMgfnRob3VzYW5kcyBvZiBoYXJkIGRyaXZlIGZhaWx1cmVzIHNsb3cg"
-       "ZGlza3MsIGJhZCBtZW1vcnksIG1pc2NvbmZpZ3VyZWQgbWFjaGluZXMsIGZs"
-       "YWt5IG1hY2hpbmVzLCBldGMuIC0gSmVmZiBEZWFuLCBUaGUgSm95cyBvZiBS"
-       "ZWFsIEhhcmR3YXJlCg"},
-
-      {"I'm the head of the webspam team at Google.  "
-       "That means that if you type your name into Google and get porn back, "
-       "it's my fault. Unless you're a porn star, in which case porn is a "
-       "completely reasonable response."
-       " - Matt Cutts, Google Plus"
-       "\n",
-
-       "SSdtIHRoZSBoZWFkIG9mIHRoZSB3ZWJzcGFtIHRlYW0gYXQgR29vZ2xlLiAg"
-       "VGhhdCBtZWFucyB0aGF0IGlmIHlvdSB0eXBlIHlvdXIgbmFtZSBpbnRvIEdv"
-       "b2dsZSBhbmQgZ2V0IHBvcm4gYmFjaywgaXQncyBteSBmYXVsdC4gVW5sZXNz"
-       "IHlvdSdyZSBhIHBvcm4gc3RhciwgaW4gd2hpY2ggY2FzZSBwb3JuIGlzIGEg"
-       "Y29tcGxldGVseSByZWFzb25hYmxlIHJlc3BvbnNlLiAtIE1hdHQgQ3V0dHMs"
-       "IEdvb2dsZSBQbHVzCg"},
-
-      {"It will still be a long time before machines approach human "
-       "intelligence. "
-       "But luckily, machines don't actually have to be intelligent; "
-       "they just have to fake it. Access to a wealth of information, "
-       "combined with a rudimentary decision-making capacity, "
-       "can often be almost as useful. Of course, the results are better yet "
-       "when coupled with intelligence. A reference librarian with access to "
-       "a good search engine is a formidable tool."
-       " - Craig Silverstein, Siemens Pictures of the Future, Spring 2004"
-       "\n",
-
-       "SXQgd2lsbCBzdGlsbCBiZSBhIGxvbmcgdGltZSBiZWZvcmUgbWFjaGluZXMg"
-       "YXBwcm9hY2ggaHVtYW4gaW50ZWxsaWdlbmNlLiBCdXQgbHVja2lseSwgbWFj"
-       "aGluZXMgZG9uJ3QgYWN0dWFsbHkgaGF2ZSB0byBiZSBpbnRlbGxpZ2VudDsg"
-       "dGhleSBqdXN0IGhhdmUgdG8gZmFrZSBpdC4gQWNjZXNzIHRvIGEgd2VhbHRo"
-       "IG9mIGluZm9ybWF0aW9uLCBjb21iaW5lZCB3aXRoIGEgcnVkaW1lbnRhcnkg"
-       "ZGVjaXNpb24tbWFraW5nIGNhcGFjaXR5LCBjYW4gb2Z0ZW4gYmUgYWxtb3N0"
-       "IGFzIHVzZWZ1bC4gT2YgY291cnNlLCB0aGUgcmVzdWx0cyBhcmUgYmV0dGVy"
-       "IHlldCB3aGVuIGNvdXBsZWQgd2l0aCBpbnRlbGxpZ2VuY2UuIEEgcmVmZXJl"
-       "bmNlIGxpYnJhcmlhbiB3aXRoIGFjY2VzcyB0byBhIGdvb2Qgc2VhcmNoIGVu"
-       "Z2luZSBpcyBhIGZvcm1pZGFibGUgdG9vbC4gLSBDcmFpZyBTaWx2ZXJzdGVp"
-       "biwgU2llbWVucyBQaWN0dXJlcyBvZiB0aGUgRnV0dXJlLCBTcHJpbmcgMjAw"
-       "NAo"},
-
-      // Degenerate edge case
-      {"", ""},
-  }};
-
-  return testcase;
-}
-
-} // namespace strings_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_ESCAPING_TEST_COMMON_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/memutil.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/memutil.h
deleted file mode 100644
index 1a9c33a639..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/memutil.h
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef ABSL_STRINGS_INTERNAL_MEMUTIL_H_
-#define ABSL_STRINGS_INTERNAL_MEMUTIL_H_
-
-#include <cstddef>
-#include <cstring>
-
-#include "absl/base/port.h"     // disable some warnings on Windows
-#include "absl/strings/ascii.h" // for absl::ascii_tolower
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-// Performs a byte-by-byte comparison of `len` bytes of the strings `s1` and
-// `s2`, ignoring the case of the characters. It returns an integer less than,
-// equal to, or greater than zero if `s1` is found, respectively, to be less
-// than, to match, or be greater than `s2`.
-int memcasecmp(const char *s1, const char *s2, size_t len);
-
-} // namespace strings_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_MEMUTIL_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/numbers_test_common.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/numbers_test_common.h
deleted file mode 100644
index b4e24d1168..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/numbers_test_common.h
+++ /dev/null
@@ -1,184 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// This file contains common things needed by numbers_test.cc,
-// numbers_legacy_test.cc and numbers_benchmark.cc.
-
-#ifndef ABSL_STRINGS_INTERNAL_NUMBERS_TEST_COMMON_H_
-#define ABSL_STRINGS_INTERNAL_NUMBERS_TEST_COMMON_H_
-
-#include <array>
-#include <cstdint>
-#include <limits>
-#include <string>
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-template <typename IntType>
-inline bool Itoa(IntType value, int base, std::string *destination) {
-  destination->clear();
-  if (base <= 1 || base > 36) {
-    return false;
-  }
-
-  if (value == 0) {
-    destination->push_back('0');
-    return true;
-  }
-
-  bool negative = value < 0;
-  while (value != 0) {
-    const IntType next_value = value / base;
-    // Can't use std::abs here because of problems when IntType is unsigned.
-    int remainder =
-        static_cast<int>(value > next_value * base ? value - next_value * base
-                                                   : next_value * base - value);
-    char c = remainder < 10 ? '0' + remainder : 'A' + remainder - 10;
-    destination->insert(0, 1, c);
-    value = next_value;
-  }
-
-  if (negative) {
-    destination->insert(0, 1, '-');
-  }
-  return true;
-}
-
-struct uint32_test_case {
-  const char *str;
-  bool expect_ok;
-  int base; // base to pass to the conversion function
-  uint32_t expected;
-};
-
-inline const std::array<uint32_test_case, 27> &strtouint32_test_cases() {
-  static const std::array<uint32_test_case, 27> test_cases{{
-      {"0xffffffff", true, 16, (std::numeric_limits<uint32_t>::max)()},
-      {"0x34234324", true, 16, 0x34234324},
-      {"34234324", true, 16, 0x34234324},
-      {"0", true, 16, 0},
-      {" \t\n 0xffffffff", true, 16, (std::numeric_limits<uint32_t>::max)()},
-      {" \f\v 46", true, 10, 46}, // must accept weird whitespace
-      {" \t\n 72717222", true, 8, 072717222},
-      {" \t\n 072717222", true, 8, 072717222},
-      {" \t\n 072717228", false, 8, 07271722},
-      {"0", true, 0, 0},
-
-      // Base-10 version.
-      {"34234324", true, 0, 34234324},
-      {"4294967295", true, 0, (std::numeric_limits<uint32_t>::max)()},
-      {"34234324 \n\t", true, 10, 34234324},
-
-      // Unusual base
-      {"0", true, 3, 0},
-      {"2", true, 3, 2},
-      {"11", true, 3, 4},
-
-      // Invalid uints.
-      {"", false, 0, 0},
-      {"  ", false, 0, 0},
-      {"abc", false, 0, 0}, // would be valid hex, but prefix is missing
-      {"34234324a", false, 0, 34234324},
-      {"34234.3", false, 0, 34234},
-      {"-1", false, 0, 0},
-      {"   -123", false, 0, 0},
-      {" \t\n -123", false, 0, 0},
-
-      // Out of bounds.
-      {"4294967296", false, 0, (std::numeric_limits<uint32_t>::max)()},
-      {"0x100000000", false, 0, (std::numeric_limits<uint32_t>::max)()},
-      {nullptr, false, 0, 0},
-  }};
-  return test_cases;
-}
-
-struct uint64_test_case {
-  const char *str;
-  bool expect_ok;
-  int base;
-  uint64_t expected;
-};
-
-inline const std::array<uint64_test_case, 34> &strtouint64_test_cases() {
-  static const std::array<uint64_test_case, 34> test_cases{{
-      {"0x3423432448783446", true, 16, int64_t{0x3423432448783446}},
-      {"3423432448783446", true, 16, int64_t{0x3423432448783446}},
-
-      {"0", true, 16, 0},
-      {"000", true, 0, 0},
-      {"0", true, 0, 0},
-      {" \t\n 0xffffffffffffffff", true, 16,
-       (std::numeric_limits<uint64_t>::max)()},
-
-      {"012345670123456701234", true, 8, int64_t{012345670123456701234}},
-      {"12345670123456701234", true, 8, int64_t{012345670123456701234}},
-
-      {"12845670123456701234", false, 8, 0},
-
-      // Base-10 version.
-      {"34234324487834466", true, 0, int64_t{34234324487834466}},
-
-      {" \t\n 18446744073709551615", true, 0,
-       (std::numeric_limits<uint64_t>::max)()},
-
-      {"34234324487834466 \n\t ", true, 0, int64_t{34234324487834466}},
-
-      {" \f\v 46", true, 10, 46}, // must accept weird whitespace
-
-      // Unusual base
-      {"0", true, 3, 0},
-      {"2", true, 3, 2},
-      {"11", true, 3, 4},
-
-      {"0", true, 0, 0},
-
-      // Invalid uints.
-      {"", false, 0, 0},
-      {"  ", false, 0, 0},
-      {"abc", false, 0, 0},
-      {"34234324487834466a", false, 0, 0},
-      {"34234487834466.3", false, 0, 0},
-      {"-1", false, 0, 0},
-      {"   -123", false, 0, 0},
-      {" \t\n -123", false, 0, 0},
-
-      // Out of bounds.
-      {"18446744073709551616", false, 10, 0},
-      {"18446744073709551616", false, 0, 0},
-      {"0x10000000000000000", false, 16,
-       (std::numeric_limits<uint64_t>::max)()},
-      {"0X10000000000000000", false, 16,
-       (std::numeric_limits<uint64_t>::max)()}, // 0X versus 0x.
-      {"0x10000000000000000", false, 0, (std::numeric_limits<uint64_t>::max)()},
-      {"0X10000000000000000", false, 0,
-       (std::numeric_limits<uint64_t>::max)()}, // 0X versus 0x.
-
-      {"0x1234", true, 16, 0x1234},
-
-      // Base-10 string version.
-      {"1234", true, 0, 1234},
-      {nullptr, false, 0, 0},
-  }};
-  return test_cases;
-}
-
-} // namespace strings_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_NUMBERS_TEST_COMMON_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/ostringstream.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/ostringstream.h
deleted file mode 100644
index 95395da57f..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/ostringstream.h
+++ /dev/null
@@ -1,113 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_OSTRINGSTREAM_H_
-#define ABSL_STRINGS_INTERNAL_OSTRINGSTREAM_H_
-
-#include <cassert>
-#include <ios>
-#include <ostream>
-#include <streambuf>
-#include <string>
-#include <utility>
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-// The same as std::ostringstream but appends to a user-specified std::string,
-// and is faster. It is ~70% faster to create, ~50% faster to write to, and
-// completely free to extract the result std::string.
-//
-//   std::string s;
-//   OStringStream strm(&s);
-//   strm << 42 << ' ' << 3.14;  // appends to `s`
-//
-// The stream object doesn't have to be named. Starting from C++11 operator<<
-// works with rvalues of std::ostream.
-//
-//   std::string s;
-//   OStringStream(&s) << 42 << ' ' << 3.14;  // appends to `s`
-//
-// OStringStream is faster to create than std::ostringstream but it's still
-// relatively slow. Avoid creating multiple streams where a single stream will
-// do.
-//
-// Creates unnecessary instances of OStringStream: slow.
-//
-//   std::string s;
-//   OStringStream(&s) << 42;
-//   OStringStream(&s) << ' ';
-//   OStringStream(&s) << 3.14;
-//
-// Creates a single instance of OStringStream and reuses it: fast.
-//
-//   std::string s;
-//   OStringStream strm(&s);
-//   strm << 42;
-//   strm << ' ';
-//   strm << 3.14;
-//
-// Note: flush() has no effect. No reason to call it.
-class OStringStream final : public std::ostream {
-public:
-  // The argument can be null, in which case you'll need to call str(p) with a
-  // non-null argument before you can write to the stream.
-  //
-  // The destructor of OStringStream doesn't use the std::string. It's OK to
-  // destroy the std::string before the stream.
-  explicit OStringStream(std::string *str) : std::ostream(&buf_), buf_(str) {}
-  OStringStream(OStringStream &&that)
-      : std::ostream(std::move(static_cast<std::ostream &>(that))),
-        buf_(that.buf_) {
-    rdbuf(&buf_);
-  }
-  OStringStream &operator=(OStringStream &&that) {
-    std::ostream::operator=(std::move(static_cast<std::ostream &>(that)));
-    buf_ = that.buf_;
-    rdbuf(&buf_);
-    return *this;
-  }
-
-  std::string *str() { return buf_.str(); }
-  const std::string *str() const { return buf_.str(); }
-  void str(std::string *str) { buf_.str(str); }
-
-private:
-  class Streambuf final : public std::streambuf {
-  public:
-    explicit Streambuf(std::string *str) : str_(str) {}
-    Streambuf(const Streambuf &) = default;
-    Streambuf &operator=(const Streambuf &) = default;
-
-    std::string *str() { return str_; }
-    const std::string *str() const { return str_; }
-    void str(std::string *str) { str_ = str; }
-
-  protected:
-    int_type overflow(int c) override;
-    std::streamsize xsputn(const char *s, std::streamsize n) override;
-
-  private:
-    std::string *str_;
-  } buf_;
-};
-
-} // namespace strings_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_OSTRINGSTREAM_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/pow10_helper.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/pow10_helper.h
deleted file mode 100644
index d2997ec8e7..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/pow10_helper.h
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// This test helper library contains a table of powers of 10, to guarantee
-// precise values are computed across the full range of doubles. We can't rely
-// on the pow() function, because not all standard libraries ship a version
-// that is precise.
-#ifndef ABSL_STRINGS_INTERNAL_POW10_HELPER_H_
-#define ABSL_STRINGS_INTERNAL_POW10_HELPER_H_
-
-#include <vector>
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-// Computes the precise value of 10^exp. (I.e. the nearest representable
-// double to the exact value, rounding to nearest-even in the (single) case of
-// being exactly halfway between.)
-double Pow10(int exp);
-
-} // namespace strings_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_POW10_HELPER_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/resize_uninitialized.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/resize_uninitialized.h
deleted file mode 100644
index 39b7f896f2..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/resize_uninitialized.h
+++ /dev/null
@@ -1,117 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef ABSL_STRINGS_INTERNAL_RESIZE_UNINITIALIZED_H_
-#define ABSL_STRINGS_INTERNAL_RESIZE_UNINITIALIZED_H_
-
-#include <algorithm>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-#include "absl/base/port.h"
-#include "absl/meta/type_traits.h" //  for void_t
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-// In this type trait, we look for a __resize_default_init member function, and
-// we use it if available, otherwise, we use resize. We provide HasMember to
-// indicate whether __resize_default_init is present.
-template <typename string_type, typename = void>
-struct ResizeUninitializedTraits {
-  using HasMember = std::false_type;
-  static void Resize(string_type *s, size_t new_size) { s->resize(new_size); }
-};
-
-// __resize_default_init is provided by libc++ >= 8.0
-template <typename string_type>
-struct ResizeUninitializedTraits<
-    string_type, absl::void_t<decltype(std::declval<string_type &>()
-                                           .__resize_default_init(237))>> {
-  using HasMember = std::true_type;
-  static void Resize(string_type *s, size_t new_size) {
-    s->__resize_default_init(new_size);
-  }
-};
-
-// Returns true if the std::string implementation supports a resize where
-// the new characters added to the std::string are left untouched.
-//
-// (A better name might be "STLStringSupportsUninitializedResize", alluding to
-// the previous function.)
-template <typename string_type>
-inline constexpr bool STLStringSupportsNontrashingResize(string_type *) {
-  return ResizeUninitializedTraits<string_type>::HasMember::value;
-}
-
-// Like str->resize(new_size), except any new characters added to "*str" as a
-// result of resizing may be left uninitialized, rather than being filled with
-// '0' bytes. Typically used when code is then going to overwrite the backing
-// store of the std::string with known data.
-template <typename string_type, typename = void>
-inline void STLStringResizeUninitialized(string_type *s, size_t new_size) {
-  ResizeUninitializedTraits<string_type>::Resize(s, new_size);
-}
-
-// Used to ensure exponential growth so that the amortized complexity of
-// increasing the string size by a small amount is O(1), in contrast to
-// O(str->size()) in the case of precise growth.
-template <typename string_type>
-void STLStringReserveAmortized(string_type *s, size_t new_size) {
-  const size_t cap = s->capacity();
-  if (new_size > cap) {
-    // Make sure to always grow by at least a factor of 2x.
-    s->reserve((std::max)(new_size, 2 * cap));
-  }
-}
-
-// In this type trait, we look for an __append_default_init member function, and
-// we use it if available, otherwise, we use append.
-template <typename string_type, typename = void>
-struct AppendUninitializedTraits {
-  static void Append(string_type *s, size_t n) {
-    s->append(n, typename string_type::value_type());
-  }
-};
-
-template <typename string_type>
-struct AppendUninitializedTraits<
-    string_type, absl::void_t<decltype(std::declval<string_type &>()
-                                           .__append_default_init(237))>> {
-  static void Append(string_type *s, size_t n) { s->__append_default_init(n); }
-};
-
-// Like STLStringResizeUninitialized(str, new_size), except guaranteed to use
-// exponential growth so that the amortized complexity of increasing the string
-// size by a small amount is O(1), in contrast to O(str->size()) in the case of
-// precise growth.
-template <typename string_type>
-void STLStringResizeUninitializedAmortized(string_type *s, size_t new_size) {
-  const size_t size = s->size();
-  if (new_size > size) {
-    AppendUninitializedTraits<string_type>::Append(s, new_size - size);
-  } else {
-    s->erase(new_size);
-  }
-}
-
-} // namespace strings_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_RESIZE_UNINITIALIZED_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/stl_type_traits.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/stl_type_traits.h
deleted file mode 100644
index 7bcb777a4a..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/stl_type_traits.h
+++ /dev/null
@@ -1,239 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-// The file provides the IsStrictlyBaseOfAndConvertibleToSTLContainer type
-// trait metafunction to assist in working with the _GLIBCXX_DEBUG debug
-// wrappers of STL containers.
-//
-// DO NOT INCLUDE THIS FILE DIRECTLY. Use this file by including
-// absl/strings/str_split.h.
-//
-// IWYU pragma: private, include "absl/strings/str_split.h"
-
-#ifndef ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_
-#define ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_
-
-#include <array>
-#include <bitset>
-#include <deque>
-#include <forward_list>
-#include <list>
-#include <map>
-#include <set>
-#include <type_traits>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-#include "absl/meta/type_traits.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-template <typename C, template <typename...> class T>
-struct IsSpecializationImpl : std::false_type {};
-template <template <typename...> class T, typename... Args>
-struct IsSpecializationImpl<T<Args...>, T> : std::true_type {};
-template <typename C, template <typename...> class T>
-using IsSpecialization = IsSpecializationImpl<absl::decay_t<C>, T>;
-
-template <typename C> struct IsArrayImpl : std::false_type {};
-template <template <typename, size_t> class A, typename T, size_t N>
-struct IsArrayImpl<A<T, N>> : std::is_same<A<T, N>, std::array<T, N>> {};
-template <typename C> using IsArray = IsArrayImpl<absl::decay_t<C>>;
-
-template <typename C> struct IsBitsetImpl : std::false_type {};
-template <template <size_t> class B, size_t N>
-struct IsBitsetImpl<B<N>> : std::is_same<B<N>, std::bitset<N>> {};
-template <typename C> using IsBitset = IsBitsetImpl<absl::decay_t<C>>;
-
-template <typename C>
-struct IsSTLContainer
-    : absl::disjunction<
-          IsArray<C>, IsBitset<C>, IsSpecialization<C, std::deque>,
-          IsSpecialization<C, std::forward_list>,
-          IsSpecialization<C, std::list>, IsSpecialization<C, std::map>,
-          IsSpecialization<C, std::multimap>, IsSpecialization<C, std::set>,
-          IsSpecialization<C, std::multiset>,
-          IsSpecialization<C, std::unordered_map>,
-          IsSpecialization<C, std::unordered_multimap>,
-          IsSpecialization<C, std::unordered_set>,
-          IsSpecialization<C, std::unordered_multiset>,
-          IsSpecialization<C, std::vector>> {};
-
-template <typename C, template <typename...> class T, typename = void>
-struct IsBaseOfSpecializationImpl : std::false_type {};
-// IsBaseOfSpecializationImpl needs multiple partial specializations to SFINAE
-// on the existence of container dependent types and plug them into the STL
-// template.
-template <typename C, template <typename, typename> class T>
-struct IsBaseOfSpecializationImpl<
-    C, T, absl::void_t<typename C::value_type, typename C::allocator_type>>
-    : std::is_base_of<C,
-                      T<typename C::value_type, typename C::allocator_type>> {};
-template <typename C, template <typename, typename, typename> class T>
-struct IsBaseOfSpecializationImpl<
-    C, T,
-    absl::void_t<typename C::key_type, typename C::key_compare,
-                 typename C::allocator_type>>
-    : std::is_base_of<C, T<typename C::key_type, typename C::key_compare,
-                           typename C::allocator_type>> {};
-template <typename C, template <typename, typename, typename, typename> class T>
-struct IsBaseOfSpecializationImpl<
-    C, T,
-    absl::void_t<typename C::key_type, typename C::mapped_type,
-                 typename C::key_compare, typename C::allocator_type>>
-    : std::is_base_of<C,
-                      T<typename C::key_type, typename C::mapped_type,
-                        typename C::key_compare, typename C::allocator_type>> {
-};
-template <typename C, template <typename, typename, typename, typename> class T>
-struct IsBaseOfSpecializationImpl<
-    C, T,
-    absl::void_t<typename C::key_type, typename C::hasher,
-                 typename C::key_equal, typename C::allocator_type>>
-    : std::is_base_of<C, T<typename C::key_type, typename C::hasher,
-                           typename C::key_equal, typename C::allocator_type>> {
-};
-template <typename C,
-          template <typename, typename, typename, typename, typename> class T>
-struct IsBaseOfSpecializationImpl<
-    C, T,
-    absl::void_t<typename C::key_type, typename C::mapped_type,
-                 typename C::hasher, typename C::key_equal,
-                 typename C::allocator_type>>
-    : std::is_base_of<C, T<typename C::key_type, typename C::mapped_type,
-                           typename C::hasher, typename C::key_equal,
-                           typename C::allocator_type>> {};
-template <typename C, template <typename...> class T>
-using IsBaseOfSpecialization = IsBaseOfSpecializationImpl<absl::decay_t<C>, T>;
-
-template <typename C> struct IsBaseOfArrayImpl : std::false_type {};
-template <template <typename, size_t> class A, typename T, size_t N>
-struct IsBaseOfArrayImpl<A<T, N>> : std::is_base_of<A<T, N>, std::array<T, N>> {
-};
-template <typename C> using IsBaseOfArray = IsBaseOfArrayImpl<absl::decay_t<C>>;
-
-template <typename C> struct IsBaseOfBitsetImpl : std::false_type {};
-template <template <size_t> class B, size_t N>
-struct IsBaseOfBitsetImpl<B<N>> : std::is_base_of<B<N>, std::bitset<N>> {};
-template <typename C>
-using IsBaseOfBitset = IsBaseOfBitsetImpl<absl::decay_t<C>>;
-
-template <typename C>
-struct IsBaseOfSTLContainer
-    : absl::disjunction<IsBaseOfArray<C>, IsBaseOfBitset<C>,
-                        IsBaseOfSpecialization<C, std::deque>,
-                        IsBaseOfSpecialization<C, std::forward_list>,
-                        IsBaseOfSpecialization<C, std::list>,
-                        IsBaseOfSpecialization<C, std::map>,
-                        IsBaseOfSpecialization<C, std::multimap>,
-                        IsBaseOfSpecialization<C, std::set>,
-                        IsBaseOfSpecialization<C, std::multiset>,
-                        IsBaseOfSpecialization<C, std::unordered_map>,
-                        IsBaseOfSpecialization<C, std::unordered_multimap>,
-                        IsBaseOfSpecialization<C, std::unordered_set>,
-                        IsBaseOfSpecialization<C, std::unordered_multiset>,
-                        IsBaseOfSpecialization<C, std::vector>> {};
-
-template <typename C, template <typename...> class T, typename = void>
-struct IsConvertibleToSpecializationImpl : std::false_type {};
-// IsConvertibleToSpecializationImpl needs multiple partial specializations to
-// SFINAE on the existence of container dependent types and plug them into the
-// STL template.
-template <typename C, template <typename, typename> class T>
-struct IsConvertibleToSpecializationImpl<
-    C, T, absl::void_t<typename C::value_type, typename C::allocator_type>>
-    : std::is_convertible<
-          C, T<typename C::value_type, typename C::allocator_type>> {};
-template <typename C, template <typename, typename, typename> class T>
-struct IsConvertibleToSpecializationImpl<
-    C, T,
-    absl::void_t<typename C::key_type, typename C::key_compare,
-                 typename C::allocator_type>>
-    : std::is_convertible<C, T<typename C::key_type, typename C::key_compare,
-                               typename C::allocator_type>> {};
-template <typename C, template <typename, typename, typename, typename> class T>
-struct IsConvertibleToSpecializationImpl<
-    C, T,
-    absl::void_t<typename C::key_type, typename C::mapped_type,
-                 typename C::key_compare, typename C::allocator_type>>
-    : std::is_convertible<
-          C, T<typename C::key_type, typename C::mapped_type,
-               typename C::key_compare, typename C::allocator_type>> {};
-template <typename C, template <typename, typename, typename, typename> class T>
-struct IsConvertibleToSpecializationImpl<
-    C, T,
-    absl::void_t<typename C::key_type, typename C::hasher,
-                 typename C::key_equal, typename C::allocator_type>>
-    : std::is_convertible<
-          C, T<typename C::key_type, typename C::hasher, typename C::key_equal,
-               typename C::allocator_type>> {};
-template <typename C,
-          template <typename, typename, typename, typename, typename> class T>
-struct IsConvertibleToSpecializationImpl<
-    C, T,
-    absl::void_t<typename C::key_type, typename C::mapped_type,
-                 typename C::hasher, typename C::key_equal,
-                 typename C::allocator_type>>
-    : std::is_convertible<C, T<typename C::key_type, typename C::mapped_type,
-                               typename C::hasher, typename C::key_equal,
-                               typename C::allocator_type>> {};
-template <typename C, template <typename...> class T>
-using IsConvertibleToSpecialization =
-    IsConvertibleToSpecializationImpl<absl::decay_t<C>, T>;
-
-template <typename C> struct IsConvertibleToArrayImpl : std::false_type {};
-template <template <typename, size_t> class A, typename T, size_t N>
-struct IsConvertibleToArrayImpl<A<T, N>>
-    : std::is_convertible<A<T, N>, std::array<T, N>> {};
-template <typename C>
-using IsConvertibleToArray = IsConvertibleToArrayImpl<absl::decay_t<C>>;
-
-template <typename C> struct IsConvertibleToBitsetImpl : std::false_type {};
-template <template <size_t> class B, size_t N>
-struct IsConvertibleToBitsetImpl<B<N>>
-    : std::is_convertible<B<N>, std::bitset<N>> {};
-template <typename C>
-using IsConvertibleToBitset = IsConvertibleToBitsetImpl<absl::decay_t<C>>;
-
-template <typename C>
-struct IsConvertibleToSTLContainer
-    : absl::disjunction<
-          IsConvertibleToArray<C>, IsConvertibleToBitset<C>,
-          IsConvertibleToSpecialization<C, std::deque>,
-          IsConvertibleToSpecialization<C, std::forward_list>,
-          IsConvertibleToSpecialization<C, std::list>,
-          IsConvertibleToSpecialization<C, std::map>,
-          IsConvertibleToSpecialization<C, std::multimap>,
-          IsConvertibleToSpecialization<C, std::set>,
-          IsConvertibleToSpecialization<C, std::multiset>,
-          IsConvertibleToSpecialization<C, std::unordered_map>,
-          IsConvertibleToSpecialization<C, std::unordered_multimap>,
-          IsConvertibleToSpecialization<C, std::unordered_set>,
-          IsConvertibleToSpecialization<C, std::unordered_multiset>,
-          IsConvertibleToSpecialization<C, std::vector>> {};
-
-template <typename C>
-struct IsStrictlyBaseOfAndConvertibleToSTLContainer
-    : absl::conjunction<absl::negation<IsSTLContainer<C>>,
-                        IsBaseOfSTLContainer<C>,
-                        IsConvertibleToSTLContainer<C>> {};
-
-} // namespace strings_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-#endif // ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/str_format/arg.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/str_format/arg.h
deleted file mode 100644
index 36b94ba425..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/str_format/arg.h
+++ /dev/null
@@ -1,658 +0,0 @@
-// Copyright 2020 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_ARG_H_
-#define ABSL_STRINGS_INTERNAL_STR_FORMAT_ARG_H_
-
-#include <string.h>
-#include <wchar.h>
-
-#include <algorithm>
-#include <cstddef>
-#include <cstdint>
-#include <cstdio>
-#include <limits>
-#include <memory>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-#include "absl/base/config.h"
-#include "absl/base/optimization.h"
-#include "absl/meta/type_traits.h"
-#include "absl/numeric/int128.h"
-#include "absl/strings/has_absl_stringify.h"
-#include "absl/strings/internal/str_format/extension.h"
-#include "absl/strings/string_view.h"
-
-#if defined(ABSL_HAVE_STD_STRING_VIEW)
-#include <string_view>
-#endif
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-class Cord;
-class FormatCountCapture;
-class FormatSink;
-
-template <absl::FormatConversionCharSet C> struct FormatConvertResult;
-class FormatConversionSpec;
-
-namespace str_format_internal {
-
-template <FormatConversionCharSet C> struct ArgConvertResult {
-  bool value;
-};
-
-using IntegralConvertResult = ArgConvertResult<FormatConversionCharSetUnion(
-    FormatConversionCharSetInternal::c,
-    FormatConversionCharSetInternal::kNumeric,
-    FormatConversionCharSetInternal::kStar,
-    FormatConversionCharSetInternal::v)>;
-using FloatingConvertResult = ArgConvertResult<FormatConversionCharSetUnion(
-    FormatConversionCharSetInternal::kFloating,
-    FormatConversionCharSetInternal::v)>;
-using CharConvertResult = ArgConvertResult<FormatConversionCharSetUnion(
-    FormatConversionCharSetInternal::c,
-    FormatConversionCharSetInternal::kNumeric,
-    FormatConversionCharSetInternal::kStar)>;
-
-template <typename T, typename = void>
-struct HasUserDefinedConvert : std::false_type {};
-
-template <typename T>
-struct HasUserDefinedConvert<
-    T,
-    void_t<decltype(AbslFormatConvert(
-        std::declval<const T &>(), std::declval<const FormatConversionSpec &>(),
-        std::declval<FormatSink *>()))>> : std::true_type {};
-
-// These declarations prevent ADL lookup from continuing in absl namespaces,
-// we are deliberately using these as ADL hooks and want them to consider
-// non-absl namespaces only.
-void AbslFormatConvert();
-void AbslStringify();
-
-template <typename T>
-bool ConvertIntArg(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink);
-
-// Forward declarations of internal `ConvertIntArg` function template
-// instantiations are here to avoid including the template body in the headers
-// and instantiating it in large numbers of translation units. Explicit
-// instantiations can be found in "absl/strings/internal/str_format/arg.cc"
-extern template bool ConvertIntArg<char>(char v, FormatConversionSpecImpl conv,
-                                         FormatSinkImpl *sink);
-extern template bool ConvertIntArg<signed char>(signed char v,
-                                                FormatConversionSpecImpl conv,
-                                                FormatSinkImpl *sink);
-extern template bool ConvertIntArg<unsigned char>(unsigned char v,
-                                                  FormatConversionSpecImpl conv,
-                                                  FormatSinkImpl *sink);
-extern template bool ConvertIntArg<wchar_t>(wchar_t v,
-                                            FormatConversionSpecImpl conv,
-                                            FormatSinkImpl *sink);
-extern template bool ConvertIntArg<short>(short v, // NOLINT
-                                          FormatConversionSpecImpl conv,
-                                          FormatSinkImpl *sink);
-extern template bool ConvertIntArg<unsigned short>(  // NOLINT
-    unsigned short v, FormatConversionSpecImpl conv, // NOLINT
-    FormatSinkImpl *sink);
-extern template bool ConvertIntArg<int>(int v, FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink);
-extern template bool ConvertIntArg<unsigned int>(unsigned int v,
-                                                 FormatConversionSpecImpl conv,
-                                                 FormatSinkImpl *sink);
-extern template bool ConvertIntArg<long>(                          // NOLINT
-    long v, FormatConversionSpecImpl conv, FormatSinkImpl *sink);  // NOLINT
-extern template bool ConvertIntArg<unsigned long>(unsigned long v, // NOLINT
-                                                  FormatConversionSpecImpl conv,
-                                                  FormatSinkImpl *sink);
-extern template bool ConvertIntArg<long long>(long long v, // NOLINT
-                                              FormatConversionSpecImpl conv,
-                                              FormatSinkImpl *sink);
-extern template bool ConvertIntArg<unsigned long long>(  // NOLINT
-    unsigned long long v, FormatConversionSpecImpl conv, // NOLINT
-    FormatSinkImpl *sink);
-
-template <typename T>
-auto FormatConvertImpl(const T &v, FormatConversionSpecImpl conv,
-                       FormatSinkImpl *sink)
-    -> decltype(AbslFormatConvert(v,
-                                  std::declval<const FormatConversionSpec &>(),
-                                  std::declval<FormatSink *>())) {
-  using FormatConversionSpecT =
-      absl::enable_if_t<sizeof(const T &(*)()) != 0, FormatConversionSpec>;
-  using FormatSinkT =
-      absl::enable_if_t<sizeof(const T &(*)()) != 0, FormatSink>;
-  auto fcs = conv.Wrap<FormatConversionSpecT>();
-  auto fs = sink->Wrap<FormatSinkT>();
-  return AbslFormatConvert(v, fcs, &fs);
-}
-
-template <typename T>
-auto FormatConvertImpl(const T &v, FormatConversionSpecImpl conv,
-                       FormatSinkImpl *sink)
-    -> std::enable_if_t<std::is_enum<T>::value &&
-                            std::is_void<decltype(AbslStringify(
-                                std::declval<FormatSink &>(), v))>::value,
-                        IntegralConvertResult> {
-  if (conv.conversion_char() == FormatConversionCharInternal::v) {
-    using FormatSinkT =
-        absl::enable_if_t<sizeof(const T &(*)()) != 0, FormatSink>;
-    auto fs = sink->Wrap<FormatSinkT>();
-    AbslStringify(fs, v);
-    return {true};
-  } else {
-    return {ConvertIntArg(
-        static_cast<typename std::underlying_type<T>::type>(v), conv, sink)};
-  }
-}
-
-template <typename T>
-auto FormatConvertImpl(const T &v, FormatConversionSpecImpl,
-                       FormatSinkImpl *sink)
-    -> std::enable_if_t<!std::is_enum<T>::value &&
-                            !std::is_same<T, absl::Cord>::value &&
-                            std::is_void<decltype(AbslStringify(
-                                std::declval<FormatSink &>(), v))>::value,
-                        ArgConvertResult<FormatConversionCharSetInternal::v>> {
-  using FormatSinkT =
-      absl::enable_if_t<sizeof(const T &(*)()) != 0, FormatSink>;
-  auto fs = sink->Wrap<FormatSinkT>();
-  AbslStringify(fs, v);
-  return {true};
-}
-
-template <typename T> class StreamedWrapper;
-
-// If 'v' can be converted (in the printf sense) according to 'conv',
-// then convert it, appending to `sink` and return `true`.
-// Otherwise fail and return `false`.
-
-// AbslFormatConvert(v, conv, sink) is intended to be found by ADL on 'v'
-// as an extension mechanism. These FormatConvertImpl functions are the default
-// implementations.
-// The ADL search is augmented via the 'Sink*' parameter, which also
-// serves as a disambiguator to reject possible unintended 'AbslFormatConvert'
-// functions in the namespaces associated with 'v'.
-
-// Raw pointers.
-struct VoidPtr {
-  VoidPtr() = default;
-  template <typename T,
-            decltype(reinterpret_cast<uintptr_t>(std::declval<T *>())) = 0>
-  VoidPtr(T *ptr) // NOLINT
-      : value(ptr ? reinterpret_cast<uintptr_t>(ptr) : 0) {}
-  uintptr_t value;
-};
-
-template <FormatConversionCharSet C>
-constexpr FormatConversionCharSet ExtractCharSet(FormatConvertResult<C>) {
-  return C;
-}
-
-template <FormatConversionCharSet C>
-constexpr FormatConversionCharSet ExtractCharSet(ArgConvertResult<C>) {
-  return C;
-}
-
-ArgConvertResult<FormatConversionCharSetInternal::p>
-FormatConvertImpl(VoidPtr v, FormatConversionSpecImpl conv,
-                  FormatSinkImpl *sink);
-
-// Strings.
-using StringConvertResult = ArgConvertResult<FormatConversionCharSetUnion(
-    FormatConversionCharSetInternal::s, FormatConversionCharSetInternal::v)>;
-StringConvertResult FormatConvertImpl(const std::string &v,
-                                      FormatConversionSpecImpl conv,
-                                      FormatSinkImpl *sink);
-StringConvertResult FormatConvertImpl(const std::wstring &v,
-                                      FormatConversionSpecImpl conv,
-                                      FormatSinkImpl *sink);
-StringConvertResult FormatConvertImpl(string_view v,
-                                      FormatConversionSpecImpl conv,
-                                      FormatSinkImpl *sink);
-#if defined(ABSL_HAVE_STD_STRING_VIEW)
-StringConvertResult FormatConvertImpl(std::wstring_view v,
-                                      FormatConversionSpecImpl conv,
-                                      FormatSinkImpl *sink);
-#if !defined(ABSL_USES_STD_STRING_VIEW)
-inline StringConvertResult FormatConvertImpl(std::string_view v,
-                                             FormatConversionSpecImpl conv,
-                                             FormatSinkImpl *sink) {
-  return FormatConvertImpl(absl::string_view(v.data(), v.size()), conv, sink);
-}
-#endif // !ABSL_USES_STD_STRING_VIEW
-#endif // ABSL_HAVE_STD_STRING_VIEW
-
-using StringPtrConvertResult = ArgConvertResult<FormatConversionCharSetUnion(
-    FormatConversionCharSetInternal::s, FormatConversionCharSetInternal::p)>;
-StringPtrConvertResult FormatConvertImpl(const char *v,
-                                         FormatConversionSpecImpl conv,
-                                         FormatSinkImpl *sink);
-StringPtrConvertResult FormatConvertImpl(const wchar_t *v,
-                                         FormatConversionSpecImpl conv,
-                                         FormatSinkImpl *sink);
-// This overload is needed to disambiguate, since `nullptr` could match either
-// of the other overloads equally well.
-StringPtrConvertResult FormatConvertImpl(std::nullptr_t,
-                                         FormatConversionSpecImpl conv,
-                                         FormatSinkImpl *sink);
-
-template <class AbslCord, typename std::enable_if<std::is_same<
-                              AbslCord, absl::Cord>::value>::type * = nullptr>
-StringConvertResult FormatConvertImpl(const AbslCord &value,
-                                      FormatConversionSpecImpl conv,
-                                      FormatSinkImpl *sink) {
-  bool is_left = conv.has_left_flag();
-  size_t space_remaining = 0;
-
-  int width = conv.width();
-  if (width >= 0)
-    space_remaining = static_cast<size_t>(width);
-
-  size_t to_write = value.size();
-
-  int precision = conv.precision();
-  if (precision >= 0)
-    to_write = (std::min)(to_write, static_cast<size_t>(precision));
-
-  space_remaining = Excess(to_write, space_remaining);
-
-  if (space_remaining > 0 && !is_left)
-    sink->Append(space_remaining, ' ');
-
-  for (string_view piece : value.Chunks()) {
-    if (piece.size() > to_write) {
-      piece.remove_suffix(piece.size() - to_write);
-      to_write = 0;
-    } else {
-      to_write -= piece.size();
-    }
-    sink->Append(piece);
-    if (to_write == 0) {
-      break;
-    }
-  }
-
-  if (space_remaining > 0 && is_left)
-    sink->Append(space_remaining, ' ');
-  return {true};
-}
-
-bool ConvertBoolArg(bool v, FormatSinkImpl *sink);
-
-// Floats.
-FloatingConvertResult FormatConvertImpl(float v, FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink);
-FloatingConvertResult FormatConvertImpl(double v, FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink);
-FloatingConvertResult FormatConvertImpl(long double v,
-                                        FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink);
-
-// Chars.
-CharConvertResult FormatConvertImpl(char v, FormatConversionSpecImpl conv,
-                                    FormatSinkImpl *sink);
-CharConvertResult FormatConvertImpl(wchar_t v, FormatConversionSpecImpl conv,
-                                    FormatSinkImpl *sink);
-
-// Ints.
-IntegralConvertResult FormatConvertImpl(signed char v,
-                                        FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink);
-IntegralConvertResult FormatConvertImpl(unsigned char v,
-                                        FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink);
-IntegralConvertResult FormatConvertImpl(short v, // NOLINT
-                                        FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink);
-IntegralConvertResult FormatConvertImpl(unsigned short v, // NOLINT
-                                        FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink);
-IntegralConvertResult FormatConvertImpl(int v, FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink);
-IntegralConvertResult FormatConvertImpl(unsigned v,
-                                        FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink);
-IntegralConvertResult FormatConvertImpl(long v, // NOLINT
-                                        FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink);
-IntegralConvertResult FormatConvertImpl(unsigned long v, // NOLINT
-                                        FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink);
-IntegralConvertResult FormatConvertImpl(long long v, // NOLINT
-                                        FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink);
-IntegralConvertResult FormatConvertImpl(unsigned long long v, // NOLINT
-                                        FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink);
-IntegralConvertResult FormatConvertImpl(int128 v, FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink);
-IntegralConvertResult FormatConvertImpl(uint128 v,
-                                        FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink);
-
-// This function needs to be a template due to ambiguity regarding type
-// conversions.
-template <typename T, enable_if_t<std::is_same<T, bool>::value, int> = 0>
-IntegralConvertResult FormatConvertImpl(T v, FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink) {
-  if (conv.conversion_char() == FormatConversionCharInternal::v) {
-    return {ConvertBoolArg(v, sink)};
-  }
-
-  return FormatConvertImpl(static_cast<int>(v), conv, sink);
-}
-
-// We provide this function to help the checker, but it is never defined.
-// FormatArgImpl will use the underlying Convert functions instead.
-template <typename T>
-typename std::enable_if<std::is_enum<T>::value &&
-                            !HasUserDefinedConvert<T>::value &&
-                            !HasAbslStringify<T>::value,
-                        IntegralConvertResult>::type
-FormatConvertImpl(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink);
-
-template <typename T>
-StringConvertResult FormatConvertImpl(const StreamedWrapper<T> &v,
-                                      FormatConversionSpecImpl conv,
-                                      FormatSinkImpl *out) {
-  std::ostringstream oss;
-  oss << v.v_;
-  if (!oss)
-    return {false};
-  return str_format_internal::FormatConvertImpl(oss.str(), conv, out);
-}
-
-// Use templates and dependent types to delay evaluation of the function
-// until after FormatCountCapture is fully defined.
-struct FormatCountCaptureHelper {
-  template <class T = int>
-  static ArgConvertResult<FormatConversionCharSetInternal::n>
-  ConvertHelper(const FormatCountCapture &v, FormatConversionSpecImpl conv,
-                FormatSinkImpl *sink) {
-    const absl::enable_if_t<sizeof(T) != 0, FormatCountCapture> &v2 = v;
-
-    if (conv.conversion_char() !=
-        str_format_internal::FormatConversionCharInternal::n) {
-      return {false};
-    }
-    *v2.p_ = static_cast<int>(sink->size());
-    return {true};
-  }
-};
-
-template <class T = int>
-ArgConvertResult<FormatConversionCharSetInternal::n>
-FormatConvertImpl(const FormatCountCapture &v, FormatConversionSpecImpl conv,
-                  FormatSinkImpl *sink) {
-  return FormatCountCaptureHelper::ConvertHelper(v, conv, sink);
-}
-
-// Helper friend struct to hide implementation details from the public API of
-// FormatArgImpl.
-struct FormatArgImplFriend {
-  template <typename Arg> static bool ToInt(Arg arg, int *out) {
-    // A value initialized FormatConversionSpecImpl has a `none` conv, which
-    // tells the dispatcher to run the `int` conversion.
-    return arg.dispatcher_(arg.data_, {}, out);
-  }
-
-  template <typename Arg>
-  static bool Convert(Arg arg, FormatConversionSpecImpl conv,
-                      FormatSinkImpl *out) {
-    return arg.dispatcher_(arg.data_, conv, out);
-  }
-
-  template <typename Arg>
-  static typename Arg::Dispatcher GetVTablePtrForTest(Arg arg) {
-    return arg.dispatcher_;
-  }
-};
-
-template <typename Arg> constexpr FormatConversionCharSet ArgumentToConv() {
-  using ConvResult = decltype(str_format_internal::FormatConvertImpl(
-      std::declval<const Arg &>(),
-      std::declval<const FormatConversionSpecImpl &>(),
-      std::declval<FormatSinkImpl *>()));
-  return absl::str_format_internal::ExtractCharSet(ConvResult{});
-}
-
-// A type-erased handle to a format argument.
-class FormatArgImpl {
-private:
-  enum { kInlinedSpace = 8 };
-
-  using VoidPtr = str_format_internal::VoidPtr;
-
-  union Data {
-    const void *ptr;
-    const volatile void *volatile_ptr;
-    char buf[kInlinedSpace];
-  };
-
-  using Dispatcher = bool (*)(Data, FormatConversionSpecImpl, void *out);
-
-  template <typename T>
-  struct store_by_value
-      : std::integral_constant<bool, (sizeof(T) <= kInlinedSpace) &&
-                                         (std::is_integral<T>::value ||
-                                          std::is_floating_point<T>::value ||
-                                          std::is_pointer<T>::value ||
-                                          std::is_same<VoidPtr, T>::value)> {};
-
-  enum StoragePolicy { ByPointer, ByVolatilePointer, ByValue };
-  template <typename T>
-  struct storage_policy
-      : std::integral_constant<StoragePolicy,
-                               (std::is_volatile<T>::value
-                                    ? ByVolatilePointer
-                                    : (store_by_value<T>::value ? ByValue
-                                                                : ByPointer))> {
-  };
-
-  // To reduce the number of vtables we will decay values before hand.
-  // Anything with a user-defined Convert will get its own vtable.
-  // For everything else:
-  //   - Decay char* and char arrays into `const char*`
-  //   - Decay wchar_t* and wchar_t arrays into `const wchar_t*`
-  //   - Decay any other pointer to `const void*`
-  //   - Decay all enums to the integral promotion of their underlying type.
-  //   - Decay function pointers to void*.
-  template <typename T, typename = void> struct DecayType {
-    static constexpr bool kHasUserDefined =
-        str_format_internal::HasUserDefinedConvert<T>::value ||
-        HasAbslStringify<T>::value;
-    using type = typename std::conditional<
-        !kHasUserDefined && std::is_convertible<T, const char *>::value,
-        const char *,
-        typename std::conditional<
-            !kHasUserDefined && std::is_convertible<T, const wchar_t *>::value,
-            const wchar_t *,
-            typename std::conditional<
-                !kHasUserDefined && std::is_convertible<T, VoidPtr>::value,
-                VoidPtr, const T &>::type>::type>::type;
-  };
-  template <typename T>
-  struct DecayType<
-      T, typename std::enable_if<
-             !str_format_internal::HasUserDefinedConvert<T>::value &&
-             !HasAbslStringify<T>::value && std::is_enum<T>::value>::type> {
-    using type = decltype(+typename std::underlying_type<T>::type());
-  };
-
-public:
-  template <typename T> explicit FormatArgImpl(const T &value) {
-    using D = typename DecayType<T>::type;
-    static_assert(std::is_same<D, const T &>::value ||
-                      storage_policy<D>::value == ByValue,
-                  "Decayed types must be stored by value");
-    Init(static_cast<D>(value));
-  }
-
-private:
-  friend struct str_format_internal::FormatArgImplFriend;
-  template <typename T, StoragePolicy = storage_policy<T>::value>
-  struct Manager;
-
-  template <typename T> struct Manager<T, ByPointer> {
-    static Data SetValue(const T &value) {
-      Data data;
-      data.ptr = std::addressof(value);
-      return data;
-    }
-
-    static const T &Value(Data arg) { return *static_cast<const T *>(arg.ptr); }
-  };
-
-  template <typename T> struct Manager<T, ByVolatilePointer> {
-    static Data SetValue(const T &value) {
-      Data data;
-      data.volatile_ptr = &value;
-      return data;
-    }
-
-    static const T &Value(Data arg) {
-      return *static_cast<const T *>(arg.volatile_ptr);
-    }
-  };
-
-  template <typename T> struct Manager<T, ByValue> {
-    static Data SetValue(const T &value) {
-      Data data;
-      memcpy(data.buf, &value, sizeof(value));
-      return data;
-    }
-
-    static T Value(Data arg) {
-      T value;
-      memcpy(&value, arg.buf, sizeof(T));
-      return value;
-    }
-  };
-
-  template <typename T> void Init(const T &value) {
-    data_ = Manager<T>::SetValue(value);
-    dispatcher_ = &Dispatch<T>;
-  }
-
-  template <typename T> static int ToIntVal(const T &val) {
-    using CommonType = typename std::conditional<std::is_signed<T>::value,
-                                                 int64_t, uint64_t>::type;
-    if (static_cast<CommonType>(val) >
-        static_cast<CommonType>((std::numeric_limits<int>::max)())) {
-      return (std::numeric_limits<int>::max)();
-    } else if (std::is_signed<T>::value &&
-               static_cast<CommonType>(val) <
-                   static_cast<CommonType>((std::numeric_limits<int>::min)())) {
-      return (std::numeric_limits<int>::min)();
-    }
-    return static_cast<int>(val);
-  }
-
-  template <typename T>
-  static bool ToInt(Data arg, int *out, std::true_type /* is_integral */,
-                    std::false_type) {
-    *out = ToIntVal(Manager<T>::Value(arg));
-    return true;
-  }
-
-  template <typename T>
-  static bool ToInt(Data arg, int *out, std::false_type,
-                    std::true_type /* is_enum */) {
-    *out = ToIntVal(static_cast<typename std::underlying_type<T>::type>(
-        Manager<T>::Value(arg)));
-    return true;
-  }
-
-  template <typename T>
-  static bool ToInt(Data, int *, std::false_type, std::false_type) {
-    return false;
-  }
-
-  template <typename T>
-  static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void *out) {
-    // A `none` conv indicates that we want the `int` conversion.
-    if (ABSL_PREDICT_FALSE(spec.conversion_char() ==
-                           FormatConversionCharInternal::kNone)) {
-      return ToInt<T>(arg, static_cast<int *>(out), std::is_integral<T>(),
-                      std::is_enum<T>());
-    }
-    if (ABSL_PREDICT_FALSE(
-            !Contains(ArgumentToConv<T>(), spec.conversion_char()))) {
-      return false;
-    }
-    return str_format_internal::FormatConvertImpl(
-               Manager<T>::Value(arg), spec, static_cast<FormatSinkImpl *>(out))
-        .value;
-  }
-
-  Data data_;
-  Dispatcher dispatcher_;
-};
-
-#define ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(T, E)                       \
-  E template bool FormatArgImpl::Dispatch<T>(Data, FormatConversionSpecImpl,   \
-                                             void *)
-
-#define ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_NO_WSTRING_VIEW_(...)   \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(str_format_internal::VoidPtr,     \
-                                             __VA_ARGS__);                     \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(bool, __VA_ARGS__);               \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(char, __VA_ARGS__);               \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(signed char, __VA_ARGS__);        \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned char, __VA_ARGS__);      \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(short, __VA_ARGS__); /* NOLINT */ \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned short,      /* NOLINT */ \
-                                             __VA_ARGS__);                     \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(int, __VA_ARGS__);                \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned int, __VA_ARGS__);       \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long, __VA_ARGS__); /* NOLINT */  \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned long,      /* NOLINT */  \
-                                             __VA_ARGS__);                     \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long long, /* NOLINT */           \
-                                             __VA_ARGS__);                     \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned long long, /* NOLINT */  \
-                                             __VA_ARGS__);                     \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(int128, __VA_ARGS__);             \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(uint128, __VA_ARGS__);            \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(float, __VA_ARGS__);              \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(double, __VA_ARGS__);             \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long double, __VA_ARGS__);        \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(const char *, __VA_ARGS__);       \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(std::string, __VA_ARGS__);        \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(string_view, __VA_ARGS__);        \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(const wchar_t *, __VA_ARGS__);    \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(std::wstring, __VA_ARGS__)
-
-#if defined(ABSL_HAVE_STD_STRING_VIEW)
-#define ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(...)                   \
-  ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_NO_WSTRING_VIEW_(             \
-      __VA_ARGS__);                                                            \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(std::wstring_view, __VA_ARGS__)
-#else
-#define ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(...)                   \
-  ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_NO_WSTRING_VIEW_(__VA_ARGS__)
-#endif
-
-ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(extern);
-
-} // namespace str_format_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_STR_FORMAT_ARG_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/str_format/bind.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/str_format/bind.h
deleted file mode 100644
index e825d0c08d..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/str_format/bind.h
+++ /dev/null
@@ -1,234 +0,0 @@
-// Copyright 2020 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_BIND_H_
-#define ABSL_STRINGS_INTERNAL_STR_FORMAT_BIND_H_
-
-#include <cassert>
-#include <cstdio>
-#include <ostream>
-#include <string>
-
-#include "absl/base/config.h"
-#include "absl/container/inlined_vector.h"
-#include "absl/strings/internal/str_format/arg.h"
-#include "absl/strings/internal/str_format/checker.h"
-#include "absl/strings/internal/str_format/constexpr_parser.h"
-#include "absl/strings/internal/str_format/extension.h"
-#include "absl/strings/internal/str_format/parser.h"
-#include "absl/strings/string_view.h"
-#include "absl/types/span.h"
-#include "absl/utility/utility.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-class UntypedFormatSpec;
-
-namespace str_format_internal {
-
-class BoundConversion : public FormatConversionSpecImpl {
-public:
-  const FormatArgImpl *arg() const { return arg_; }
-  void set_arg(const FormatArgImpl *a) { arg_ = a; }
-
-private:
-  const FormatArgImpl *arg_;
-};
-
-// This is the type-erased class that the implementation uses.
-class UntypedFormatSpecImpl {
-public:
-  UntypedFormatSpecImpl() = delete;
-
-  explicit UntypedFormatSpecImpl(string_view s)
-      : data_(s.data()), size_(s.size()) {}
-  explicit UntypedFormatSpecImpl(
-      const str_format_internal::ParsedFormatBase *pc)
-      : data_(pc), size_(~size_t{}) {}
-
-  bool has_parsed_conversion() const { return size_ == ~size_t{}; }
-
-  string_view str() const {
-    assert(!has_parsed_conversion());
-    return string_view(static_cast<const char *>(data_), size_);
-  }
-  const str_format_internal::ParsedFormatBase *parsed_conversion() const {
-    assert(has_parsed_conversion());
-    return static_cast<const str_format_internal::ParsedFormatBase *>(data_);
-  }
-
-  template <typename T>
-  static const UntypedFormatSpecImpl &Extract(const T &s) {
-    return s.spec_;
-  }
-
-private:
-  const void *data_;
-  size_t size_;
-};
-
-template <typename T, FormatConversionCharSet...> struct MakeDependent {
-  using type = T;
-};
-
-// Implicitly convertible from `const char*`, `string_view`, and the
-// `ExtendedParsedFormat` type. This abstraction allows all format functions to
-// operate on any without providing too many overloads.
-template <FormatConversionCharSet... Args>
-class FormatSpecTemplate
-    : public MakeDependent<UntypedFormatSpec, Args...>::type {
-  using Base = typename MakeDependent<UntypedFormatSpec, Args...>::type;
-
-  template <bool res> struct ErrorMaker {
-    constexpr bool operator()(int) const { return res; }
-  };
-
-  template <int i, int j>
-  static constexpr bool CheckArity(ErrorMaker<true> SpecifierCount = {},
-                                   ErrorMaker<i == j> ParametersPassed = {}) {
-    static_assert(SpecifierCount(i) == ParametersPassed(j),
-                  "Number of arguments passed must match the number of "
-                  "conversion specifiers.");
-    return true;
-  }
-
-  template <FormatConversionCharSet specified, FormatConversionCharSet passed,
-            int arg>
-  static constexpr bool CheckMatch(
-      ErrorMaker<Contains(specified, passed)> MismatchedArgumentNumber = {}) {
-    static_assert(MismatchedArgumentNumber(arg),
-                  "Passed argument must match specified format.");
-    return true;
-  }
-
-  template <FormatConversionCharSet... C, size_t... I>
-  static bool CheckMatches(absl::index_sequence<I...>) {
-    bool res[] = {true, CheckMatch<Args, C, I + 1>()...};
-    (void)res;
-    return true;
-  }
-
-public:
-#ifdef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
-
-  // Honeypot overload for when the string is not constexpr.
-  // We use the 'unavailable' attribute to give a better compiler error than
-  // just 'method is deleted'.
-  FormatSpecTemplate(...) // NOLINT
-      __attribute__((unavailable("Format string is not constexpr.")));
-
-  // Honeypot overload for when the format is constexpr and invalid.
-  // We use the 'unavailable' attribute to give a better compiler error than
-  // just 'method is deleted'.
-  // To avoid checking the format twice, we just check that the format is
-  // constexpr. If it is valid, then the overload below will kick in.
-  // We add the template here to make this overload have lower priority.
-  template <typename = void>
-  FormatSpecTemplate(const char *s) // NOLINT
-      __attribute__((
-          enable_if(str_format_internal::EnsureConstexpr(s), "constexpr trap"),
-          unavailable(
-              "Format specified does not match the arguments passed.")));
-
-  template <typename T = void>
-  FormatSpecTemplate(string_view s) // NOLINT
-      __attribute__((enable_if(str_format_internal::EnsureConstexpr(s),
-                               "constexpr trap")))
-      : Base("to avoid noise in the compiler error") {
-    static_assert(sizeof(T *) == 0,
-                  "Format specified does not match the arguments passed.");
-  }
-
-  // Good format overload.
-  FormatSpecTemplate(const char *s) // NOLINT
-      __attribute__((enable_if(ValidFormatImpl<Args...>(s), "bad format trap")))
-      : Base(s) {}
-
-  FormatSpecTemplate(string_view s) // NOLINT
-      __attribute__((enable_if(ValidFormatImpl<Args...>(s), "bad format trap")))
-      : Base(s) {}
-
-#else // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
-
-  FormatSpecTemplate(const char *s) : Base(s) {} // NOLINT
-  FormatSpecTemplate(string_view s) : Base(s) {} // NOLINT
-
-#endif // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
-
-  template <FormatConversionCharSet... C>
-  FormatSpecTemplate(const ExtendedParsedFormat<C...> &pc) // NOLINT
-      : Base(&pc) {
-    CheckArity<sizeof...(C), sizeof...(Args)>();
-    CheckMatches<C...>(absl::make_index_sequence<sizeof...(C)>{});
-  }
-};
-
-class Streamable {
-public:
-  Streamable(const UntypedFormatSpecImpl &format,
-             absl::Span<const FormatArgImpl> args)
-      : format_(format), args_(args.begin(), args.end()) {}
-
-  std::ostream &Print(std::ostream &os) const;
-
-  friend std::ostream &operator<<(std::ostream &os, const Streamable &l) {
-    return l.Print(os);
-  }
-
-private:
-  const UntypedFormatSpecImpl &format_;
-  absl::InlinedVector<FormatArgImpl, 4> args_;
-};
-
-// for testing
-std::string Summarize(UntypedFormatSpecImpl format,
-                      absl::Span<const FormatArgImpl> args);
-bool BindWithPack(const UnboundConversion *props,
-                  absl::Span<const FormatArgImpl> pack, BoundConversion *bound);
-
-bool FormatUntyped(FormatRawSinkImpl raw_sink, UntypedFormatSpecImpl format,
-                   absl::Span<const FormatArgImpl> args);
-
-std::string &AppendPack(std::string *out, UntypedFormatSpecImpl format,
-                        absl::Span<const FormatArgImpl> args);
-
-std::string FormatPack(UntypedFormatSpecImpl format,
-                       absl::Span<const FormatArgImpl> args);
-
-int FprintF(std::FILE *output, UntypedFormatSpecImpl format,
-            absl::Span<const FormatArgImpl> args);
-int SnprintF(char *output, size_t size, UntypedFormatSpecImpl format,
-             absl::Span<const FormatArgImpl> args);
-
-// Returned by Streamed(v). Converts via '%s' to the std::string created
-// by std::ostream << v.
-template <typename T> class StreamedWrapper {
-public:
-  explicit StreamedWrapper(const T &v) : v_(v) {}
-
-private:
-  template <typename S>
-  friend ArgConvertResult<FormatConversionCharSetUnion(
-      FormatConversionCharSetInternal::s, FormatConversionCharSetInternal::v)>
-  FormatConvertImpl(const StreamedWrapper<S> &v, FormatConversionSpecImpl conv,
-                    FormatSinkImpl *out);
-  const T &v_;
-};
-
-} // namespace str_format_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_STR_FORMAT_BIND_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/str_format/checker.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/str_format/checker.h
deleted file mode 100644
index e2db3beb2d..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/str_format/checker.h
+++ /dev/null
@@ -1,105 +0,0 @@
-// Copyright 2020 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_CHECKER_H_
-#define ABSL_STRINGS_INTERNAL_STR_FORMAT_CHECKER_H_
-
-#include <algorithm>
-
-#include "absl/base/attributes.h"
-#include "absl/strings/internal/str_format/arg.h"
-#include "absl/strings/internal/str_format/constexpr_parser.h"
-#include "absl/strings/internal/str_format/extension.h"
-
-// Compile time check support for entry points.
-
-#ifndef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
-// We disable format checker under vscode intellisense compilation.
-// See https://github.com/microsoft/vscode-cpptools/issues/3683 for
-// more details.
-#if ABSL_HAVE_ATTRIBUTE(enable_if) && !defined(__native_client__) &&           \
-    !defined(__INTELLISENSE__)
-#define ABSL_INTERNAL_ENABLE_FORMAT_CHECKER 1
-#endif // ABSL_HAVE_ATTRIBUTE(enable_if) && !defined(__native_client__) &&
-       // !defined(__INTELLISENSE__)
-#endif // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace str_format_internal {
-
-#ifdef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
-
-template <FormatConversionCharSet... C>
-constexpr bool ValidFormatImpl(string_view format) {
-  int next_arg = 0;
-  const char *p = format.data();
-  const char *const end = p + format.size();
-  constexpr FormatConversionCharSet
-      kAllowedConvs[(std::max)(sizeof...(C), size_t{1})] = {C...};
-  bool used[(std::max)(sizeof...(C), size_t{1})]{};
-  constexpr int kNumArgs = sizeof...(C);
-  while (p != end) {
-    while (p != end && *p != '%')
-      ++p;
-    if (p == end) {
-      break;
-    }
-    if (p + 1 >= end)
-      return false;
-    if (p[1] == '%') {
-      // %%
-      p += 2;
-      continue;
-    }
-
-    UnboundConversion conv(absl::kConstInit);
-    p = ConsumeUnboundConversion(p + 1, end, &conv, &next_arg);
-    if (p == nullptr)
-      return false;
-    if (conv.arg_position <= 0 || conv.arg_position > kNumArgs) {
-      return false;
-    }
-    if (!Contains(kAllowedConvs[conv.arg_position - 1], conv.conv)) {
-      return false;
-    }
-    used[conv.arg_position - 1] = true;
-    for (auto extra : {conv.width, conv.precision}) {
-      if (extra.is_from_arg()) {
-        int pos = extra.get_from_arg();
-        if (pos <= 0 || pos > kNumArgs)
-          return false;
-        used[pos - 1] = true;
-        if (!Contains(kAllowedConvs[pos - 1], '*')) {
-          return false;
-        }
-      }
-    }
-  }
-  if (sizeof...(C) != 0) {
-    for (bool b : used) {
-      if (!b)
-        return false;
-    }
-  }
-  return true;
-}
-
-#endif // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
-
-} // namespace str_format_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_STR_FORMAT_CHECKER_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/str_format/constexpr_parser.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/str_format/constexpr_parser.h
deleted file mode 100644
index c6d88e0982..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/str_format/constexpr_parser.h
+++ /dev/null
@@ -1,373 +0,0 @@
-// Copyright 2022 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_CONSTEXPR_PARSER_H_
-#define ABSL_STRINGS_INTERNAL_STR_FORMAT_CONSTEXPR_PARSER_H_
-
-#include <cassert>
-#include <cstdint>
-#include <cstdio>
-#include <limits>
-
-#include "absl/base/config.h"
-#include "absl/base/const_init.h"
-#include "absl/base/optimization.h"
-#include "absl/strings/internal/str_format/extension.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace str_format_internal {
-
-// The analyzed properties of a single specified conversion.
-struct UnboundConversion {
-  // This is a user defined default constructor on purpose to skip the
-  // initialization of parts of the object that are not necessary.
-  UnboundConversion() {} // NOLINT
-
-  // This constructor is provided for the static checker. We don't want to do
-  // the unnecessary initialization in the normal case.
-  explicit constexpr UnboundConversion(absl::ConstInitType)
-      : arg_position{}, width{}, precision{} {}
-
-  class InputValue {
-  public:
-    constexpr void set_value(int value) {
-      assert(value >= 0);
-      value_ = value;
-    }
-    constexpr int value() const { return value_; }
-
-    // Marks the value as "from arg". aka the '*' format.
-    // Requires `value >= 1`.
-    // When set, is_from_arg() return true and get_from_arg() returns the
-    // original value.
-    // `value()`'s return value is unspecified in this state.
-    constexpr void set_from_arg(int value) {
-      assert(value > 0);
-      value_ = -value - 1;
-    }
-    constexpr bool is_from_arg() const { return value_ < -1; }
-    constexpr int get_from_arg() const {
-      assert(is_from_arg());
-      return -value_ - 1;
-    }
-
-  private:
-    int value_ = -1;
-  };
-
-  // No need to initialize. It will always be set in the parser.
-  int arg_position;
-
-  InputValue width;
-  InputValue precision;
-
-  Flags flags = Flags::kBasic;
-  LengthMod length_mod = LengthMod::none;
-  FormatConversionChar conv = FormatConversionCharInternal::kNone;
-};
-
-// Helper tag class for the table below.
-// It allows fast `char -> ConversionChar/LengthMod/Flags` checking and
-// conversions.
-class ConvTag {
-public:
-  constexpr ConvTag(FormatConversionChar conversion_char) // NOLINT
-      : tag_(static_cast<uint8_t>(conversion_char)) {}
-  constexpr ConvTag(LengthMod length_mod) // NOLINT
-      : tag_(0x80 | static_cast<uint8_t>(length_mod)) {}
-  constexpr ConvTag(Flags flags) // NOLINT
-      : tag_(0xc0 | static_cast<uint8_t>(flags)) {}
-  constexpr ConvTag() : tag_(0xFF) {}
-
-  constexpr bool is_conv() const { return (tag_ & 0x80) == 0; }
-  constexpr bool is_length() const { return (tag_ & 0xC0) == 0x80; }
-  constexpr bool is_flags() const { return (tag_ & 0xE0) == 0xC0; }
-
-  constexpr FormatConversionChar as_conv() const {
-    assert(is_conv());
-    assert(!is_length());
-    assert(!is_flags());
-    return static_cast<FormatConversionChar>(tag_);
-  }
-  constexpr LengthMod as_length() const {
-    assert(!is_conv());
-    assert(is_length());
-    assert(!is_flags());
-    return static_cast<LengthMod>(tag_ & 0x3F);
-  }
-  constexpr Flags as_flags() const {
-    assert(!is_conv());
-    assert(!is_length());
-    assert(is_flags());
-    return static_cast<Flags>(tag_ & 0x1F);
-  }
-
-private:
-  uint8_t tag_;
-};
-
-struct ConvTagHolder {
-  using CC = FormatConversionCharInternal;
-  using LM = LengthMod;
-
-  // Abbreviations to fit in the table below.
-  static constexpr auto kFSign = Flags::kSignCol;
-  static constexpr auto kFAlt = Flags::kAlt;
-  static constexpr auto kFPos = Flags::kShowPos;
-  static constexpr auto kFLeft = Flags::kLeft;
-  static constexpr auto kFZero = Flags::kZero;
-
-  static constexpr ConvTag value[256] = {
-      {},     {},    {},    {},    {},    {},     {},    {},    // 00-07
-      {},     {},    {},    {},    {},    {},     {},    {},    // 08-0f
-      {},     {},    {},    {},    {},    {},     {},    {},    // 10-17
-      {},     {},    {},    {},    {},    {},     {},    {},    // 18-1f
-      kFSign, {},    {},    kFAlt, {},    {},     {},    {},    //  !"#$%&'
-      {},     {},    {},    kFPos, {},    kFLeft, {},    {},    // ()*+,-./
-      kFZero, {},    {},    {},    {},    {},     {},    {},    // 01234567
-      {},     {},    {},    {},    {},    {},     {},    {},    // 89:;<=>?
-      {},     CC::A, {},    {},    {},    CC::E,  CC::F, CC::G, // @ABCDEFG
-      {},     {},    {},    {},    LM::L, {},     {},    {},    // HIJKLMNO
-      {},     {},    {},    {},    {},    {},     {},    {},    // PQRSTUVW
-      CC::X,  {},    {},    {},    {},    {},     {},    {},    // XYZ[\]^_
-      {},     CC::a, {},    CC::c, CC::d, CC::e,  CC::f, CC::g, // `abcdefg
-      LM::h,  CC::i, LM::j, {},    LM::l, {},     CC::n, CC::o, // hijklmno
-      CC::p,  LM::q, {},    CC::s, LM::t, CC::u,  CC::v, {},    // pqrstuvw
-      CC::x,  {},    LM::z, {},    {},    {},     {},    {},    // xyz{|}!
-      {},     {},    {},    {},    {},    {},     {},    {},    // 80-87
-      {},     {},    {},    {},    {},    {},     {},    {},    // 88-8f
-      {},     {},    {},    {},    {},    {},     {},    {},    // 90-97
-      {},     {},    {},    {},    {},    {},     {},    {},    // 98-9f
-      {},     {},    {},    {},    {},    {},     {},    {},    // a0-a7
-      {},     {},    {},    {},    {},    {},     {},    {},    // a8-af
-      {},     {},    {},    {},    {},    {},     {},    {},    // b0-b7
-      {},     {},    {},    {},    {},    {},     {},    {},    // b8-bf
-      {},     {},    {},    {},    {},    {},     {},    {},    // c0-c7
-      {},     {},    {},    {},    {},    {},     {},    {},    // c8-cf
-      {},     {},    {},    {},    {},    {},     {},    {},    // d0-d7
-      {},     {},    {},    {},    {},    {},     {},    {},    // d8-df
-      {},     {},    {},    {},    {},    {},     {},    {},    // e0-e7
-      {},     {},    {},    {},    {},    {},     {},    {},    // e8-ef
-      {},     {},    {},    {},    {},    {},     {},    {},    // f0-f7
-      {},     {},    {},    {},    {},    {},     {},    {},    // f8-ff
-  };
-};
-
-// Keep a single table for all the conversion chars and length modifiers.
-constexpr ConvTag GetTagForChar(char c) {
-  return ConvTagHolder::value[static_cast<unsigned char>(c)];
-}
-
-constexpr bool CheckFastPathSetting(const UnboundConversion &conv) {
-  bool width_precision_needed =
-      conv.width.value() >= 0 || conv.precision.value() >= 0;
-  if (width_precision_needed && conv.flags == Flags::kBasic) {
-#if defined(__clang__)
-    // Some compilers complain about this in constexpr even when not executed,
-    // so only enable the error dump in clang.
-    fprintf(stderr,
-            "basic=%d left=%d show_pos=%d sign_col=%d alt=%d zero=%d "
-            "width=%d precision=%d\n",
-            conv.flags == Flags::kBasic ? 1 : 0,
-            FlagsContains(conv.flags, Flags::kLeft) ? 1 : 0,
-            FlagsContains(conv.flags, Flags::kShowPos) ? 1 : 0,
-            FlagsContains(conv.flags, Flags::kSignCol) ? 1 : 0,
-            FlagsContains(conv.flags, Flags::kAlt) ? 1 : 0,
-            FlagsContains(conv.flags, Flags::kZero) ? 1 : 0, conv.width.value(),
-            conv.precision.value());
-#endif // defined(__clang__)
-    return false;
-  }
-  return true;
-}
-
-constexpr int ParseDigits(char &c, const char *&pos, const char *const end) {
-  int digits = c - '0';
-  // We do not want to overflow `digits` so we consume at most digits10
-  // digits. If there are more digits the parsing will fail later on when the
-  // digit doesn't match the expected characters.
-  int num_digits = std::numeric_limits<int>::digits10;
-  for (;;) {
-    if (ABSL_PREDICT_FALSE(pos == end))
-      break;
-    c = *pos++;
-    if ('0' > c || c > '9')
-      break;
-    --num_digits;
-    if (ABSL_PREDICT_FALSE(!num_digits))
-      break;
-    digits = 10 * digits + c - '0';
-  }
-  return digits;
-}
-
-template <bool is_positional>
-constexpr const char *ConsumeConversion(const char *pos, const char *const end,
-                                        UnboundConversion *conv,
-                                        int *next_arg) {
-  const char *const original_pos = pos;
-  char c = 0;
-  // Read the next char into `c` and update `pos`. Returns false if there are
-  // no more chars to read.
-#define ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR()                                 \
-  do {                                                                         \
-    if (ABSL_PREDICT_FALSE(pos == end))                                        \
-      return nullptr;                                                          \
-    c = *pos++;                                                                \
-  } while (0)
-
-  if (is_positional) {
-    ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-    if (ABSL_PREDICT_FALSE(c < '1' || c > '9'))
-      return nullptr;
-    conv->arg_position = ParseDigits(c, pos, end);
-    assert(conv->arg_position > 0);
-    if (ABSL_PREDICT_FALSE(c != '$'))
-      return nullptr;
-  }
-
-  ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-
-  // We should start with the basic flag on.
-  assert(conv->flags == Flags::kBasic);
-
-  // Any non alpha character makes this conversion not basic.
-  // This includes flags (-+ #0), width (1-9, *) or precision (.).
-  // All conversion characters and length modifiers are alpha characters.
-  if (c < 'A') {
-    while (c <= '0') {
-      auto tag = GetTagForChar(c);
-      if (tag.is_flags()) {
-        conv->flags = conv->flags | tag.as_flags();
-        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-      } else {
-        break;
-      }
-    }
-
-    if (c <= '9') {
-      if (c >= '0') {
-        int maybe_width = ParseDigits(c, pos, end);
-        if (!is_positional && c == '$') {
-          if (ABSL_PREDICT_FALSE(*next_arg != 0))
-            return nullptr;
-          // Positional conversion.
-          *next_arg = -1;
-          return ConsumeConversion<true>(original_pos, end, conv, next_arg);
-        }
-        conv->flags = conv->flags | Flags::kNonBasic;
-        conv->width.set_value(maybe_width);
-      } else if (c == '*') {
-        conv->flags = conv->flags | Flags::kNonBasic;
-        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-        if (is_positional) {
-          if (ABSL_PREDICT_FALSE(c < '1' || c > '9'))
-            return nullptr;
-          conv->width.set_from_arg(ParseDigits(c, pos, end));
-          if (ABSL_PREDICT_FALSE(c != '$'))
-            return nullptr;
-          ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-        } else {
-          conv->width.set_from_arg(++*next_arg);
-        }
-      }
-    }
-
-    if (c == '.') {
-      conv->flags = conv->flags | Flags::kNonBasic;
-      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-      if ('0' <= c && c <= '9') {
-        conv->precision.set_value(ParseDigits(c, pos, end));
-      } else if (c == '*') {
-        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-        if (is_positional) {
-          if (ABSL_PREDICT_FALSE(c < '1' || c > '9'))
-            return nullptr;
-          conv->precision.set_from_arg(ParseDigits(c, pos, end));
-          if (c != '$')
-            return nullptr;
-          ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-        } else {
-          conv->precision.set_from_arg(++*next_arg);
-        }
-      } else {
-        conv->precision.set_value(0);
-      }
-    }
-  }
-
-  auto tag = GetTagForChar(c);
-
-  if (ABSL_PREDICT_FALSE(c == 'v' && conv->flags != Flags::kBasic)) {
-    return nullptr;
-  }
-
-  if (ABSL_PREDICT_FALSE(!tag.is_conv())) {
-    if (ABSL_PREDICT_FALSE(!tag.is_length()))
-      return nullptr;
-
-    // It is a length modifier.
-    LengthMod length_mod = tag.as_length();
-    ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-    if (c == 'h' && length_mod == LengthMod::h) {
-      conv->length_mod = LengthMod::hh;
-      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-    } else if (c == 'l' && length_mod == LengthMod::l) {
-      conv->length_mod = LengthMod::ll;
-      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-    } else {
-      conv->length_mod = length_mod;
-    }
-    tag = GetTagForChar(c);
-
-    if (ABSL_PREDICT_FALSE(c == 'v'))
-      return nullptr;
-    if (ABSL_PREDICT_FALSE(!tag.is_conv()))
-      return nullptr;
-
-    // `wchar_t` args are marked non-basic so `Bind()` will copy the length mod.
-    if (conv->length_mod == LengthMod::l && c == 'c') {
-      conv->flags = conv->flags | Flags::kNonBasic;
-    }
-  }
-#undef ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR
-
-  assert(CheckFastPathSetting(*conv));
-  (void)(&CheckFastPathSetting);
-
-  conv->conv = tag.as_conv();
-  if (!is_positional)
-    conv->arg_position = ++*next_arg;
-  return pos;
-}
-
-// Consume conversion spec prefix (not including '%') of [p, end) if valid.
-// Examples of valid specs would be e.g.: "s", "d", "-12.6f".
-// If valid, it returns the first character following the conversion spec,
-// and the spec part is broken down and returned in 'conv'.
-// If invalid, returns nullptr.
-constexpr const char *ConsumeUnboundConversion(const char *p, const char *end,
-                                               UnboundConversion *conv,
-                                               int *next_arg) {
-  if (*next_arg < 0)
-    return ConsumeConversion<true>(p, end, conv, next_arg);
-  return ConsumeConversion<false>(p, end, conv, next_arg);
-}
-
-} // namespace str_format_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_STR_FORMAT_CONSTEXPR_PARSER_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/str_format/extension.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/str_format/extension.h
deleted file mode 100644
index 6b85d1b64c..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/str_format/extension.h
+++ /dev/null
@@ -1,449 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_EXTENSION_H_
-#define ABSL_STRINGS_INTERNAL_STR_FORMAT_EXTENSION_H_
-
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <ostream>
-#include <string>
-
-#include "absl/base/config.h"
-#include "absl/strings/internal/str_format/output.h"
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-enum class FormatConversionChar : uint8_t;
-enum class FormatConversionCharSet : uint64_t;
-enum class LengthMod : std::uint8_t { h, hh, l, ll, L, j, z, t, q, none };
-
-namespace str_format_internal {
-
-class FormatRawSinkImpl {
-public:
-  // Implicitly convert from any type that provides the hook function as
-  // described above.
-  template <typename T, decltype(str_format_internal::InvokeFlush(
-                            std::declval<T *>(), string_view())) * = nullptr>
-  FormatRawSinkImpl(T *raw) // NOLINT
-      : sink_(raw), write_(&FormatRawSinkImpl::Flush<T>) {}
-
-  void Write(string_view s) { write_(sink_, s); }
-
-  template <typename T> static FormatRawSinkImpl Extract(T s) {
-    return s.sink_;
-  }
-
-private:
-  template <typename T> static void Flush(void *r, string_view s) {
-    str_format_internal::InvokeFlush(static_cast<T *>(r), s);
-  }
-
-  void *sink_;
-  void (*write_)(void *, string_view);
-};
-
-// An abstraction to which conversions write their string data.
-class FormatSinkImpl {
-public:
-  explicit FormatSinkImpl(FormatRawSinkImpl raw) : raw_(raw) {}
-
-  ~FormatSinkImpl() { Flush(); }
-
-  void Flush() {
-    raw_.Write(string_view(buf_, static_cast<size_t>(pos_ - buf_)));
-    pos_ = buf_;
-  }
-
-  void Append(size_t n, char c) {
-    if (n == 0)
-      return;
-    size_ += n;
-    auto raw_append = [&](size_t count) {
-      memset(pos_, c, count);
-      pos_ += count;
-    };
-    while (n > Avail()) {
-      n -= Avail();
-      if (Avail() > 0) {
-        raw_append(Avail());
-      }
-      Flush();
-    }
-    raw_append(n);
-  }
-
-  void Append(string_view v) {
-    size_t n = v.size();
-    if (n == 0)
-      return;
-    size_ += n;
-    if (n >= Avail()) {
-      Flush();
-      raw_.Write(v);
-      return;
-    }
-    memcpy(pos_, v.data(), n);
-    pos_ += n;
-  }
-
-  size_t size() const { return size_; }
-
-  // Put 'v' to 'sink' with specified width, precision, and left flag.
-  bool PutPaddedString(string_view v, int width, int precision, bool left);
-
-  template <typename T> T Wrap() { return T(this); }
-
-  template <typename T> static FormatSinkImpl *Extract(T *s) {
-    return s->sink_;
-  }
-
-private:
-  size_t Avail() const {
-    return static_cast<size_t>(buf_ + sizeof(buf_) - pos_);
-  }
-
-  FormatRawSinkImpl raw_;
-  size_t size_ = 0;
-  char *pos_ = buf_;
-  char buf_[1024];
-};
-
-enum class Flags : uint8_t {
-  kBasic = 0,
-  kLeft = 1 << 0,
-  kShowPos = 1 << 1,
-  kSignCol = 1 << 2,
-  kAlt = 1 << 3,
-  kZero = 1 << 4,
-  // This is not a real flag. It just exists to turn off kBasic when no other
-  // flags are set. This is for when width/precision are specified, or a length
-  // modifier affects the behavior ("%lc").
-  kNonBasic = 1 << 5,
-};
-
-constexpr Flags operator|(Flags a, Flags b) {
-  return static_cast<Flags>(static_cast<uint8_t>(a) | static_cast<uint8_t>(b));
-}
-
-constexpr bool FlagsContains(Flags haystack, Flags needle) {
-  return (static_cast<uint8_t>(haystack) & static_cast<uint8_t>(needle)) ==
-         static_cast<uint8_t>(needle);
-}
-
-std::string FlagsToString(Flags v);
-
-inline std::ostream &operator<<(std::ostream &os, Flags v) {
-  return os << FlagsToString(v);
-}
-
-// clang-format off
-#define ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(X_VAL, X_SEP) \
-  /* text */ \
-  X_VAL(c) X_SEP X_VAL(s) X_SEP \
-  /* ints */ \
-  X_VAL(d) X_SEP X_VAL(i) X_SEP X_VAL(o) X_SEP \
-  X_VAL(u) X_SEP X_VAL(x) X_SEP X_VAL(X) X_SEP \
-  /* floats */ \
-  X_VAL(f) X_SEP X_VAL(F) X_SEP X_VAL(e) X_SEP X_VAL(E) X_SEP \
-  X_VAL(g) X_SEP X_VAL(G) X_SEP X_VAL(a) X_SEP X_VAL(A) X_SEP \
-  /* misc */ \
-  X_VAL(n) X_SEP X_VAL(p) X_SEP X_VAL(v)
-// clang-format on
-
-// This type should not be referenced, it exists only to provide labels
-// internally that match the values declared in FormatConversionChar in
-// str_format.h. This is meant to allow internal libraries to use the same
-// declared interface type as the public interface
-// (absl::StrFormatConversionChar) while keeping the definition in a public
-// header.
-// Internal libraries should use the form
-// `FormatConversionCharInternal::c`, `FormatConversionCharInternal::kNone` for
-// comparisons.  Use in switch statements is not recommended due to a bug in how
-// gcc 4.9 -Wswitch handles declared but undefined enums.
-struct FormatConversionCharInternal {
-  FormatConversionCharInternal() = delete;
-
-private:
-  // clang-format off
-  enum class Enum : uint8_t {
-    c, s,                    // text
-    d, i, o, u, x, X,        // int
-    f, F, e, E, g, G, a, A,  // float
-    n, p, v,                    // misc
-    kNone
-  };
-  // clang-format on
-public:
-#define ABSL_INTERNAL_X_VAL(id)                                                \
-  static constexpr FormatConversionChar id =                                   \
-      static_cast<FormatConversionChar>(Enum::id);
-  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL, )
-#undef ABSL_INTERNAL_X_VAL
-  static constexpr FormatConversionChar kNone =
-      static_cast<FormatConversionChar>(Enum::kNone);
-};
-// clang-format on
-
-inline FormatConversionChar FormatConversionCharFromChar(char c) {
-  switch (c) {
-#define ABSL_INTERNAL_X_VAL(id)                                                \
-  case #id[0]:                                                                 \
-    return FormatConversionCharInternal::id;
-    ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL, )
-#undef ABSL_INTERNAL_X_VAL
-  }
-  return FormatConversionCharInternal::kNone;
-}
-
-inline bool FormatConversionCharIsUpper(FormatConversionChar c) {
-  if (c == FormatConversionCharInternal::X ||
-      c == FormatConversionCharInternal::F ||
-      c == FormatConversionCharInternal::E ||
-      c == FormatConversionCharInternal::G ||
-      c == FormatConversionCharInternal::A) {
-    return true;
-  } else {
-    return false;
-  }
-}
-
-inline bool FormatConversionCharIsFloat(FormatConversionChar c) {
-  if (c == FormatConversionCharInternal::a ||
-      c == FormatConversionCharInternal::e ||
-      c == FormatConversionCharInternal::f ||
-      c == FormatConversionCharInternal::g ||
-      c == FormatConversionCharInternal::A ||
-      c == FormatConversionCharInternal::E ||
-      c == FormatConversionCharInternal::F ||
-      c == FormatConversionCharInternal::G) {
-    return true;
-  } else {
-    return false;
-  }
-}
-
-inline char FormatConversionCharToChar(FormatConversionChar c) {
-  if (c == FormatConversionCharInternal::kNone) {
-    return '\0';
-
-#define ABSL_INTERNAL_X_VAL(e)                                                 \
-  }                                                                            \
-  else if (c == FormatConversionCharInternal::e) {                             \
-    return #e[0];
-#define ABSL_INTERNAL_X_SEP
-    ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
-                                           ABSL_INTERNAL_X_SEP)
-  } else {
-    return '\0';
-  }
-
-#undef ABSL_INTERNAL_X_VAL
-#undef ABSL_INTERNAL_X_SEP
-}
-
-// The associated char.
-inline std::ostream &operator<<(std::ostream &os, FormatConversionChar v) {
-  char c = FormatConversionCharToChar(v);
-  if (!c)
-    c = '?';
-  return os << c;
-}
-
-struct FormatConversionSpecImplFriend;
-
-class FormatConversionSpecImpl {
-public:
-  // Width and precision are not specified, no flags are set.
-  bool is_basic() const { return flags_ == Flags::kBasic; }
-  bool has_left_flag() const { return FlagsContains(flags_, Flags::kLeft); }
-  bool has_show_pos_flag() const {
-    return FlagsContains(flags_, Flags::kShowPos);
-  }
-  bool has_sign_col_flag() const {
-    return FlagsContains(flags_, Flags::kSignCol);
-  }
-  bool has_alt_flag() const { return FlagsContains(flags_, Flags::kAlt); }
-  bool has_zero_flag() const { return FlagsContains(flags_, Flags::kZero); }
-
-  LengthMod length_mod() const { return length_mod_; }
-
-  FormatConversionChar conversion_char() const {
-    // Keep this field first in the struct . It generates better code when
-    // accessing it when ConversionSpec is passed by value in registers.
-    static_assert(offsetof(FormatConversionSpecImpl, conv_) == 0, "");
-    return conv_;
-  }
-
-  void set_conversion_char(FormatConversionChar c) { conv_ = c; }
-
-  // Returns the specified width. If width is unspecfied, it returns a negative
-  // value.
-  int width() const { return width_; }
-  // Returns the specified precision. If precision is unspecfied, it returns a
-  // negative value.
-  int precision() const { return precision_; }
-
-  template <typename T> T Wrap() { return T(*this); }
-
-private:
-  friend struct str_format_internal::FormatConversionSpecImplFriend;
-  FormatConversionChar conv_ = FormatConversionCharInternal::kNone;
-  Flags flags_;
-  LengthMod length_mod_ = LengthMod::none;
-  int width_;
-  int precision_;
-};
-
-struct FormatConversionSpecImplFriend final {
-  static void SetFlags(Flags f, FormatConversionSpecImpl *conv) {
-    conv->flags_ = f;
-  }
-  static void SetLengthMod(LengthMod l, FormatConversionSpecImpl *conv) {
-    conv->length_mod_ = l;
-  }
-  static void SetConversionChar(FormatConversionChar c,
-                                FormatConversionSpecImpl *conv) {
-    conv->conv_ = c;
-  }
-  static void SetWidth(int w, FormatConversionSpecImpl *conv) {
-    conv->width_ = w;
-  }
-  static void SetPrecision(int p, FormatConversionSpecImpl *conv) {
-    conv->precision_ = p;
-  }
-  static std::string FlagsToString(const FormatConversionSpecImpl &spec) {
-    return str_format_internal::FlagsToString(spec.flags_);
-  }
-};
-
-// Type safe OR operator.
-// We need this for two reasons:
-//  1. operator| on enums makes them decay to integers and the result is an
-//     integer. We need the result to stay as an enum.
-//  2. We use "enum class" which would not work even if we accepted the decay.
-constexpr FormatConversionCharSet
-FormatConversionCharSetUnion(FormatConversionCharSet a) {
-  return a;
-}
-
-template <typename... CharSet>
-constexpr FormatConversionCharSet
-FormatConversionCharSetUnion(FormatConversionCharSet a, CharSet... rest) {
-  return static_cast<FormatConversionCharSet>(
-      static_cast<uint64_t>(a) |
-      static_cast<uint64_t>(FormatConversionCharSetUnion(rest...)));
-}
-
-constexpr uint64_t FormatConversionCharToConvInt(FormatConversionChar c) {
-  return uint64_t{1} << (1 + static_cast<uint8_t>(c));
-}
-
-constexpr uint64_t FormatConversionCharToConvInt(char conv) {
-  return
-#define ABSL_INTERNAL_CHAR_SET_CASE(c)                                         \
-  conv == #c[0]                                                                \
-      ? FormatConversionCharToConvInt(FormatConversionCharInternal::c)         \
-      :
-      ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_CHAR_SET_CASE, )
-#undef ABSL_INTERNAL_CHAR_SET_CASE
-                  conv == '*'
-          ? 1
-          : 0;
-}
-
-constexpr FormatConversionCharSet FormatConversionCharToConvValue(char conv) {
-  return static_cast<FormatConversionCharSet>(
-      FormatConversionCharToConvInt(conv));
-}
-
-struct FormatConversionCharSetInternal {
-#define ABSL_INTERNAL_CHAR_SET_CASE(c)                                         \
-  static constexpr FormatConversionCharSet c =                                 \
-      FormatConversionCharToConvValue(#c[0]);
-  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_CHAR_SET_CASE, )
-#undef ABSL_INTERNAL_CHAR_SET_CASE
-
-  // Used for width/precision '*' specification.
-  static constexpr FormatConversionCharSet kStar =
-      FormatConversionCharToConvValue('*');
-
-  static constexpr FormatConversionCharSet kIntegral =
-      FormatConversionCharSetUnion(d, i, u, o, x, X);
-  static constexpr FormatConversionCharSet kFloating =
-      FormatConversionCharSetUnion(a, e, f, g, A, E, F, G);
-  static constexpr FormatConversionCharSet kNumeric =
-      FormatConversionCharSetUnion(kIntegral, kFloating);
-  static constexpr FormatConversionCharSet kPointer = p;
-};
-
-// Type safe OR operator.
-// We need this for two reasons:
-//  1. operator| on enums makes them decay to integers and the result is an
-//     integer. We need the result to stay as an enum.
-//  2. We use "enum class" which would not work even if we accepted the decay.
-constexpr FormatConversionCharSet operator|(FormatConversionCharSet a,
-                                            FormatConversionCharSet b) {
-  return FormatConversionCharSetUnion(a, b);
-}
-
-// Overloaded conversion functions to support absl::ParsedFormat.
-// Get a conversion with a single character in it.
-constexpr FormatConversionCharSet ToFormatConversionCharSet(char c) {
-  return static_cast<FormatConversionCharSet>(
-      FormatConversionCharToConvValue(c));
-}
-
-// Get a conversion with a single character in it.
-constexpr FormatConversionCharSet
-ToFormatConversionCharSet(FormatConversionCharSet c) {
-  return c;
-}
-
-template <typename T> void ToFormatConversionCharSet(T) = delete;
-
-// Checks whether `c` exists in `set`.
-constexpr bool Contains(FormatConversionCharSet set, char c) {
-  return (static_cast<uint64_t>(set) &
-          static_cast<uint64_t>(FormatConversionCharToConvValue(c))) != 0;
-}
-
-// Checks whether all the characters in `c` are contained in `set`
-constexpr bool Contains(FormatConversionCharSet set,
-                        FormatConversionCharSet c) {
-  return (static_cast<uint64_t>(set) & static_cast<uint64_t>(c)) ==
-         static_cast<uint64_t>(c);
-}
-
-// Checks whether all the characters in `c` are contained in `set`
-constexpr bool Contains(FormatConversionCharSet set, FormatConversionChar c) {
-  return (static_cast<uint64_t>(set) & FormatConversionCharToConvInt(c)) != 0;
-}
-
-// Return capacity - used, clipped to a minimum of 0.
-inline size_t Excess(size_t used, size_t capacity) {
-  return used < capacity ? capacity - used : 0;
-}
-
-} // namespace str_format_internal
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_STR_FORMAT_EXTENSION_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/str_format/float_conversion.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/str_format/float_conversion.h
deleted file mode 100644
index 246cb4bd3f..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/str_format/float_conversion.h
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright 2020 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_FLOAT_CONVERSION_H_
-#define ABSL_STRINGS_INTERNAL_STR_FORMAT_FLOAT_CONVERSION_H_
-
-#include "absl/strings/internal/str_format/extension.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace str_format_internal {
-
-bool ConvertFloatImpl(float v, const FormatConversionSpecImpl &conv,
-                      FormatSinkImpl *sink);
-
-bool ConvertFloatImpl(double v, const FormatConversionSpecImpl &conv,
-                      FormatSinkImpl *sink);
-
-bool ConvertFloatImpl(long double v, const FormatConversionSpecImpl &conv,
-                      FormatSinkImpl *sink);
-
-} // namespace str_format_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_STR_FORMAT_FLOAT_CONVERSION_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/str_format/output.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/str_format/output.h
deleted file mode 100644
index 63705ea9b0..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/str_format/output.h
+++ /dev/null
@@ -1,97 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Output extension hooks for the Format library.
-// `internal::InvokeFlush` calls the appropriate flush function for the
-// specified output argument.
-// `BufferRawSink` is a simple output sink for a char buffer. Used by SnprintF.
-// `FILERawSink` is a std::FILE* based sink. Used by PrintF and FprintF.
-
-#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_OUTPUT_H_
-#define ABSL_STRINGS_INTERNAL_STR_FORMAT_OUTPUT_H_
-
-#include <cstdio>
-#include <ios>
-#include <ostream>
-#include <string>
-
-#include "absl/base/port.h"
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace str_format_internal {
-
-// RawSink implementation that writes into a char* buffer.
-// It will not overflow the buffer, but will keep the total count of chars
-// that would have been written.
-class BufferRawSink {
-public:
-  BufferRawSink(char *buffer, size_t size) : buffer_(buffer), size_(size) {}
-
-  size_t total_written() const { return total_written_; }
-  void Write(string_view v);
-
-private:
-  char *buffer_;
-  size_t size_;
-  size_t total_written_ = 0;
-};
-
-// RawSink implementation that writes into a FILE*.
-// It keeps track of the total number of bytes written and any error encountered
-// during the writes.
-class FILERawSink {
-public:
-  explicit FILERawSink(std::FILE *output) : output_(output) {}
-
-  void Write(string_view v);
-
-  size_t count() const { return count_; }
-  int error() const { return error_; }
-
-private:
-  std::FILE *output_;
-  int error_ = 0;
-  size_t count_ = 0;
-};
-
-// Provide RawSink integration with common types from the STL.
-inline void AbslFormatFlush(std::string *out, string_view s) {
-  out->append(s.data(), s.size());
-}
-inline void AbslFormatFlush(std::ostream *out, string_view s) {
-  out->write(s.data(), static_cast<std::streamsize>(s.size()));
-}
-
-inline void AbslFormatFlush(FILERawSink *sink, string_view v) {
-  sink->Write(v);
-}
-
-inline void AbslFormatFlush(BufferRawSink *sink, string_view v) {
-  sink->Write(v);
-}
-
-// This is a SFINAE to get a better compiler error message when the type
-// is not supported.
-template <typename T>
-auto InvokeFlush(T *out, string_view s) -> decltype(AbslFormatFlush(out, s)) {
-  AbslFormatFlush(out, s);
-}
-
-} // namespace str_format_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_STR_FORMAT_OUTPUT_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/str_format/parser.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/str_format/parser.h
deleted file mode 100644
index 3d4cd0756d..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/str_format/parser.h
+++ /dev/null
@@ -1,275 +0,0 @@
-// Copyright 2020 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_PARSER_H_
-#define ABSL_STRINGS_INTERNAL_STR_FORMAT_PARSER_H_
-
-#include <stddef.h>
-#include <stdlib.h>
-
-#include <cassert>
-#include <cstring>
-#include <initializer_list>
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "absl/base/config.h"
-#include "absl/base/optimization.h"
-#include "absl/strings/internal/str_format/checker.h"
-#include "absl/strings/internal/str_format/constexpr_parser.h"
-#include "absl/strings/internal/str_format/extension.h"
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace str_format_internal {
-
-std::string LengthModToString(LengthMod v);
-
-const char *ConsumeUnboundConversionNoInline(const char *p, const char *end,
-                                             UnboundConversion *conv,
-                                             int *next_arg);
-
-// Parse the format string provided in 'src' and pass the identified items into
-// 'consumer'.
-// Text runs will be passed by calling
-//   Consumer::Append(string_view);
-// ConversionItems will be passed by calling
-//   Consumer::ConvertOne(UnboundConversion, string_view);
-// In the case of ConvertOne, the string_view that is passed is the
-// portion of the format string corresponding to the conversion, not including
-// the leading %. On success, it returns true. On failure, it stops and returns
-// false.
-template <typename Consumer>
-bool ParseFormatString(string_view src, Consumer consumer) {
-  int next_arg = 0;
-  const char *p = src.data();
-  const char *const end = p + src.size();
-  while (p != end) {
-    const char *percent =
-        static_cast<const char *>(memchr(p, '%', static_cast<size_t>(end - p)));
-    if (!percent) {
-      // We found the last substring.
-      return consumer.Append(string_view(p, static_cast<size_t>(end - p)));
-    }
-    // We found a percent, so push the text run then process the percent.
-    if (ABSL_PREDICT_FALSE(!consumer.Append(
-            string_view(p, static_cast<size_t>(percent - p))))) {
-      return false;
-    }
-    if (ABSL_PREDICT_FALSE(percent + 1 >= end))
-      return false;
-
-    auto tag = GetTagForChar(percent[1]);
-    if (tag.is_conv()) {
-      if (ABSL_PREDICT_FALSE(next_arg < 0)) {
-        // This indicates an error in the format string.
-        // The only way to get `next_arg < 0` here is to have a positional
-        // argument first which sets next_arg to -1 and then a non-positional
-        // argument.
-        return false;
-      }
-      p = percent + 2;
-
-      // Keep this case separate from the one below.
-      // ConvertOne is more efficient when the compiler can see that the `basic`
-      // flag is set.
-      UnboundConversion conv;
-      conv.conv = tag.as_conv();
-      conv.arg_position = ++next_arg;
-      if (ABSL_PREDICT_FALSE(
-              !consumer.ConvertOne(conv, string_view(percent + 1, 1)))) {
-        return false;
-      }
-    } else if (percent[1] != '%') {
-      UnboundConversion conv;
-      p = ConsumeUnboundConversionNoInline(percent + 1, end, &conv, &next_arg);
-      if (ABSL_PREDICT_FALSE(p == nullptr))
-        return false;
-      if (ABSL_PREDICT_FALSE(!consumer.ConvertOne(
-              conv, string_view(percent + 1,
-                                static_cast<size_t>(p - (percent + 1)))))) {
-        return false;
-      }
-    } else {
-      if (ABSL_PREDICT_FALSE(!consumer.Append("%")))
-        return false;
-      p = percent + 2;
-      continue;
-    }
-  }
-  return true;
-}
-
-// Always returns true, or fails to compile in a constexpr context if s does not
-// point to a constexpr char array.
-constexpr bool EnsureConstexpr(string_view s) {
-  return s.empty() || s[0] == s[0];
-}
-
-class ParsedFormatBase {
-public:
-  explicit ParsedFormatBase(
-      string_view format, bool allow_ignored,
-      std::initializer_list<FormatConversionCharSet> convs);
-
-  ParsedFormatBase(const ParsedFormatBase &other) { *this = other; }
-
-  ParsedFormatBase(ParsedFormatBase &&other) { *this = std::move(other); }
-
-  ParsedFormatBase &operator=(const ParsedFormatBase &other) {
-    if (this == &other)
-      return *this;
-    has_error_ = other.has_error_;
-    items_ = other.items_;
-    size_t text_size = items_.empty() ? 0 : items_.back().text_end;
-    data_.reset(new char[text_size]);
-    memcpy(data_.get(), other.data_.get(), text_size);
-    return *this;
-  }
-
-  ParsedFormatBase &operator=(ParsedFormatBase &&other) {
-    if (this == &other)
-      return *this;
-    has_error_ = other.has_error_;
-    data_ = std::move(other.data_);
-    items_ = std::move(other.items_);
-    // Reset the vector to make sure the invariants hold.
-    other.items_.clear();
-    return *this;
-  }
-
-  template <typename Consumer> bool ProcessFormat(Consumer consumer) const {
-    const char *const base = data_.get();
-    string_view text(base, 0);
-    for (const auto &item : items_) {
-      const char *const end = text.data() + text.size();
-      text =
-          string_view(end, static_cast<size_t>((base + item.text_end) - end));
-      if (item.is_conversion) {
-        if (!consumer.ConvertOne(item.conv, text))
-          return false;
-      } else {
-        if (!consumer.Append(text))
-          return false;
-      }
-    }
-    return !has_error_;
-  }
-
-  bool has_error() const { return has_error_; }
-
-private:
-  // Returns whether the conversions match and if !allow_ignored it verifies
-  // that all conversions are used by the format.
-  bool MatchesConversions(
-      bool allow_ignored,
-      std::initializer_list<FormatConversionCharSet> convs) const;
-
-  struct ParsedFormatConsumer;
-
-  struct ConversionItem {
-    bool is_conversion;
-    // Points to the past-the-end location of this element in the data_ array.
-    size_t text_end;
-    UnboundConversion conv;
-  };
-
-  bool has_error_;
-  std::unique_ptr<char[]> data_;
-  std::vector<ConversionItem> items_;
-};
-
-// A value type representing a preparsed format.  These can be created, copied
-// around, and reused to speed up formatting loops.
-// The user must specify through the template arguments the conversion
-// characters used in the format. This will be checked at compile time.
-//
-// This class uses Conv enum values to specify each argument.
-// This allows for more flexibility as you can specify multiple possible
-// conversion characters for each argument.
-// ParsedFormat<char...> is a simplified alias for when the user only
-// needs to specify a single conversion character for each argument.
-//
-// Example:
-//   // Extended format supports multiple characters per argument:
-//   using MyFormat = ExtendedParsedFormat<Conv::d | Conv::x>;
-//   MyFormat GetFormat(bool use_hex) {
-//     if (use_hex) return MyFormat("foo %x bar");
-//     return MyFormat("foo %d bar");
-//   }
-//   // 'format' can be used with any value that supports 'd' and 'x',
-//   // like `int`.
-//   auto format = GetFormat(use_hex);
-//   value = StringF(format, i);
-//
-// This class also supports runtime format checking with the ::New() and
-// ::NewAllowIgnored() factory functions.
-// This is the only API that allows the user to pass a runtime specified format
-// string. These factory functions will return NULL if the format does not match
-// the conversions requested by the user.
-template <FormatConversionCharSet... C>
-class ExtendedParsedFormat : public str_format_internal::ParsedFormatBase {
-public:
-  explicit ExtendedParsedFormat(string_view format)
-#ifdef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
-      __attribute__((
-          enable_if(str_format_internal::EnsureConstexpr(format),
-                    "Format string is not constexpr."),
-          enable_if(str_format_internal::ValidFormatImpl<C...>(format),
-                    "Format specified does not match the template arguments.")))
-#endif // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
-      : ExtendedParsedFormat(format, false) {
-  }
-
-  // ExtendedParsedFormat factory function.
-  // The user still has to specify the conversion characters, but they will not
-  // be checked at compile time. Instead, it will be checked at runtime.
-  // This delays the checking to runtime, but allows the user to pass
-  // dynamically sourced formats.
-  // It returns NULL if the format does not match the conversion characters.
-  // The user is responsible for checking the return value before using it.
-  //
-  // The 'New' variant will check that all the specified arguments are being
-  // consumed by the format and return NULL if any argument is being ignored.
-  // The 'NewAllowIgnored' variant will not verify this and will allow formats
-  // that ignore arguments.
-  static std::unique_ptr<ExtendedParsedFormat> New(string_view format) {
-    return New(format, false);
-  }
-  static std::unique_ptr<ExtendedParsedFormat>
-  NewAllowIgnored(string_view format) {
-    return New(format, true);
-  }
-
-private:
-  static std::unique_ptr<ExtendedParsedFormat> New(string_view format,
-                                                   bool allow_ignored) {
-    std::unique_ptr<ExtendedParsedFormat> conv(
-        new ExtendedParsedFormat(format, allow_ignored));
-    if (conv->has_error())
-      return nullptr;
-    return conv;
-  }
-
-  ExtendedParsedFormat(string_view s, bool allow_ignored)
-      : ParsedFormatBase(s, allow_ignored, {C...}) {}
-};
-} // namespace str_format_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_STR_FORMAT_PARSER_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/str_join_internal.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/str_join_internal.h
deleted file mode 100644
index 927e74b4bd..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/str_join_internal.h
+++ /dev/null
@@ -1,324 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-// This file declares INTERNAL parts of the Join API that are inlined/templated
-// or otherwise need to be available at compile time. The main abstractions
-// defined in this file are:
-//
-//   - A handful of default Formatters
-//   - JoinAlgorithm() overloads
-//   - JoinRange() overloads
-//   - JoinTuple()
-//
-// DO NOT INCLUDE THIS FILE DIRECTLY. Use this file by including
-// absl/strings/str_join.h
-//
-// IWYU pragma: private, include "absl/strings/str_join.h"
-
-#ifndef ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_
-#define ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_
-
-#include <cstdint>
-#include <cstring>
-#include <initializer_list>
-#include <iterator>
-#include <limits>
-#include <memory>
-#include <string>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
-#include "absl/base/config.h"
-#include "absl/base/internal/raw_logging.h"
-#include "absl/strings/internal/ostringstream.h"
-#include "absl/strings/internal/resize_uninitialized.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-//
-// Formatter objects
-//
-// The following are implementation classes for standard Formatter objects. The
-// factory functions that users will call to create and use these formatters are
-// defined and documented in strings/join.h.
-//
-
-// The default formatter. Converts alpha-numeric types to strings.
-struct AlphaNumFormatterImpl {
-  // This template is needed in order to support passing in a dereferenced
-  // vector<bool>::iterator
-  template <typename T> void operator()(std::string *out, const T &t) const {
-    StrAppend(out, AlphaNum(t));
-  }
-
-  void operator()(std::string *out, const AlphaNum &t) const {
-    StrAppend(out, t);
-  }
-};
-
-// A type that's used to overload the JoinAlgorithm() function (defined below)
-// for ranges that do not require additional formatting (e.g., a range of
-// strings).
-
-struct NoFormatter : public AlphaNumFormatterImpl {};
-
-// Formats types to strings using the << operator.
-class StreamFormatterImpl {
-public:
-  // The method isn't const because it mutates state. Making it const will
-  // render StreamFormatterImpl thread-hostile.
-  template <typename T> void operator()(std::string *out, const T &t) {
-    // The stream is created lazily to avoid paying the relatively high cost
-    // of its construction when joining an empty range.
-    if (strm_) {
-      strm_->clear(); // clear the bad, fail and eof bits in case they were set
-      strm_->str(out);
-    } else {
-      strm_.reset(new strings_internal::OStringStream(out));
-    }
-    *strm_ << t;
-  }
-
-private:
-  std::unique_ptr<strings_internal::OStringStream> strm_;
-};
-
-// Formats a std::pair<>. The 'first' member is formatted using f1_ and the
-// 'second' member is formatted using f2_. sep_ is the separator.
-template <typename F1, typename F2> class PairFormatterImpl {
-public:
-  PairFormatterImpl(F1 f1, absl::string_view sep, F2 f2)
-      : f1_(std::move(f1)), sep_(sep), f2_(std::move(f2)) {}
-
-  template <typename T> void operator()(std::string *out, const T &p) {
-    f1_(out, p.first);
-    out->append(sep_);
-    f2_(out, p.second);
-  }
-
-  template <typename T> void operator()(std::string *out, const T &p) const {
-    f1_(out, p.first);
-    out->append(sep_);
-    f2_(out, p.second);
-  }
-
-private:
-  F1 f1_;
-  std::string sep_;
-  F2 f2_;
-};
-
-// Wraps another formatter and dereferences the argument to operator() then
-// passes the dereferenced argument to the wrapped formatter. This can be
-// useful, for example, to join a std::vector<int*>.
-template <typename Formatter> class DereferenceFormatterImpl {
-public:
-  DereferenceFormatterImpl() : f_() {}
-  explicit DereferenceFormatterImpl(Formatter &&f)
-      : f_(std::forward<Formatter>(f)) {}
-
-  template <typename T> void operator()(std::string *out, const T &t) {
-    f_(out, *t);
-  }
-
-  template <typename T> void operator()(std::string *out, const T &t) const {
-    f_(out, *t);
-  }
-
-private:
-  Formatter f_;
-};
-
-// DefaultFormatter<T> is a traits class that selects a default Formatter to use
-// for the given type T. The ::Type member names the Formatter to use. This is
-// used by the strings::Join() functions that do NOT take a Formatter argument,
-// in which case a default Formatter must be chosen.
-//
-// AlphaNumFormatterImpl is the default in the base template, followed by
-// specializations for other types.
-template <typename ValueType> struct DefaultFormatter {
-  typedef AlphaNumFormatterImpl Type;
-};
-template <> struct DefaultFormatter<const char *> {
-  typedef AlphaNumFormatterImpl Type;
-};
-template <> struct DefaultFormatter<char *> {
-  typedef AlphaNumFormatterImpl Type;
-};
-template <> struct DefaultFormatter<std::string> {
-  typedef NoFormatter Type;
-};
-template <> struct DefaultFormatter<absl::string_view> {
-  typedef NoFormatter Type;
-};
-template <typename ValueType> struct DefaultFormatter<ValueType *> {
-  typedef DereferenceFormatterImpl<typename DefaultFormatter<ValueType>::Type>
-      Type;
-};
-
-template <typename ValueType>
-struct DefaultFormatter<std::unique_ptr<ValueType>>
-    : public DefaultFormatter<ValueType *> {};
-
-//
-// JoinAlgorithm() functions
-//
-
-// The main joining algorithm. This simply joins the elements in the given
-// iterator range, each separated by the given separator, into an output string,
-// and formats each element using the provided Formatter object.
-template <typename Iterator, typename Formatter>
-std::string JoinAlgorithm(Iterator start, Iterator end, absl::string_view s,
-                          Formatter &&f) {
-  std::string result;
-  absl::string_view sep("");
-  for (Iterator it = start; it != end; ++it) {
-    result.append(sep.data(), sep.size());
-    f(&result, *it);
-    sep = s;
-  }
-  return result;
-}
-
-// A joining algorithm that's optimized for a forward iterator range of
-// string-like objects that do not need any additional formatting. This is to
-// optimize the common case of joining, say, a std::vector<string> or a
-// std::vector<absl::string_view>.
-//
-// This is an overload of the previous JoinAlgorithm() function. Here the
-// Formatter argument is of type NoFormatter. Since NoFormatter is an internal
-// type, this overload is only invoked when strings::Join() is called with a
-// range of string-like objects (e.g., std::string, absl::string_view), and an
-// explicit Formatter argument was NOT specified.
-//
-// The optimization is that the needed space will be reserved in the output
-// string to avoid the need to resize while appending. To do this, the iterator
-// range will be traversed twice: once to calculate the total needed size, and
-// then again to copy the elements and delimiters to the output string.
-template <typename Iterator,
-          typename = typename std::enable_if<std::is_convertible<
-              typename std::iterator_traits<Iterator>::iterator_category,
-              std::forward_iterator_tag>::value>::type>
-std::string JoinAlgorithm(Iterator start, Iterator end, absl::string_view s,
-                          NoFormatter) {
-  std::string result;
-  if (start != end) {
-    // Sums size
-    auto &&start_value = *start;
-    // Use uint64_t to prevent size_t overflow. We assume it is not possible for
-    // in memory strings to overflow a uint64_t.
-    uint64_t result_size = start_value.size();
-    for (Iterator it = start; ++it != end;) {
-      result_size += s.size();
-      result_size += (*it).size();
-    }
-
-    if (result_size > 0) {
-      constexpr uint64_t kMaxSize =
-          uint64_t{(std::numeric_limits<size_t>::max)()};
-      ABSL_INTERNAL_CHECK(result_size <= kMaxSize, "size_t overflow");
-      STLStringResizeUninitialized(&result, static_cast<size_t>(result_size));
-
-      // Joins strings
-      char *result_buf = &*result.begin();
-
-      memcpy(result_buf, start_value.data(), start_value.size());
-      result_buf += start_value.size();
-      for (Iterator it = start; ++it != end;) {
-        memcpy(result_buf, s.data(), s.size());
-        result_buf += s.size();
-        auto &&value = *it;
-        memcpy(result_buf, value.data(), value.size());
-        result_buf += value.size();
-      }
-    }
-  }
-
-  return result;
-}
-
-// JoinTupleLoop implements a loop over the elements of a std::tuple, which
-// are heterogeneous. The primary template matches the tuple interior case. It
-// continues the iteration after appending a separator (for nonzero indices)
-// and formatting an element of the tuple. The specialization for the I=N case
-// matches the end-of-tuple, and terminates the iteration.
-template <size_t I, size_t N> struct JoinTupleLoop {
-  template <typename Tup, typename Formatter>
-  void operator()(std::string *out, const Tup &tup, absl::string_view sep,
-                  Formatter &&fmt) {
-    if (I > 0)
-      out->append(sep.data(), sep.size());
-    fmt(out, std::get<I>(tup));
-    JoinTupleLoop<I + 1, N>()(out, tup, sep, fmt);
-  }
-};
-template <size_t N> struct JoinTupleLoop<N, N> {
-  template <typename Tup, typename Formatter>
-  void operator()(std::string *, const Tup &, absl::string_view, Formatter &&) {
-  }
-};
-
-template <typename... T, typename Formatter>
-std::string JoinAlgorithm(const std::tuple<T...> &tup, absl::string_view sep,
-                          Formatter &&fmt) {
-  std::string result;
-  JoinTupleLoop<0, sizeof...(T)>()(&result, tup, sep, fmt);
-  return result;
-}
-
-template <typename Iterator>
-std::string JoinRange(Iterator first, Iterator last,
-                      absl::string_view separator) {
-  // No formatter was explicitly given, so a default must be chosen.
-  typedef typename std::iterator_traits<Iterator>::value_type ValueType;
-  typedef typename DefaultFormatter<ValueType>::Type Formatter;
-  return JoinAlgorithm(first, last, separator, Formatter());
-}
-
-template <typename Range, typename Formatter>
-std::string JoinRange(const Range &range, absl::string_view separator,
-                      Formatter &&fmt) {
-  using std::begin;
-  using std::end;
-  return JoinAlgorithm(begin(range), end(range), separator, fmt);
-}
-
-template <typename Range>
-std::string JoinRange(const Range &range, absl::string_view separator) {
-  using std::begin;
-  using std::end;
-  return JoinRange(begin(range), end(range), separator);
-}
-
-template <typename Tuple, std::size_t... I>
-std::string JoinTuple(const Tuple &value, absl::string_view separator,
-                      std::index_sequence<I...>) {
-  return JoinRange(
-      std::initializer_list<absl::string_view>{
-          static_cast<const AlphaNum &>(std::get<I>(value)).Piece()...},
-      separator);
-}
-
-} // namespace strings_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/str_split_internal.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/str_split_internal.h
deleted file mode 100644
index 956da23f0d..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/str_split_internal.h
+++ /dev/null
@@ -1,514 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-// This file declares INTERNAL parts of the Split API that are inline/templated
-// or otherwise need to be available at compile time. The main abstractions
-// defined in here are
-//
-//   - ConvertibleToStringView
-//   - SplitIterator<>
-//   - Splitter<>
-//
-// DO NOT INCLUDE THIS FILE DIRECTLY. Use this file by including
-// absl/strings/str_split.h.
-//
-// IWYU pragma: private, include "absl/strings/str_split.h"
-
-#ifndef ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_
-#define ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_
-
-#include <array>
-#include <cstddef>
-#include <initializer_list>
-#include <iterator>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-#include "absl/base/macros.h"
-#include "absl/base/port.h"
-#include "absl/meta/type_traits.h"
-#include "absl/strings/string_view.h"
-
-#ifdef _GLIBCXX_DEBUG
-#include "absl/strings/internal/stl_type_traits.h"
-#endif // _GLIBCXX_DEBUG
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-// This class is implicitly constructible from everything that absl::string_view
-// is implicitly constructible from, except for rvalue strings.  This means it
-// can be used as a function parameter in places where passing a temporary
-// string might cause memory lifetime issues.
-class ConvertibleToStringView {
-public:
-  ConvertibleToStringView(const char *s) // NOLINT(runtime/explicit)
-      : value_(s) {}
-  ConvertibleToStringView(char *s) : value_(s) {} // NOLINT(runtime/explicit)
-  ConvertibleToStringView(absl::string_view s)    // NOLINT(runtime/explicit)
-      : value_(s) {}
-  ConvertibleToStringView(const std::string &s) // NOLINT(runtime/explicit)
-      : value_(s) {}
-
-  // Disable conversion from rvalue strings.
-  ConvertibleToStringView(std::string &&s) = delete;
-  ConvertibleToStringView(const std::string &&s) = delete;
-
-  absl::string_view value() const { return value_; }
-
-private:
-  absl::string_view value_;
-};
-
-// An iterator that enumerates the parts of a string from a Splitter. The text
-// to be split, the Delimiter, and the Predicate are all taken from the given
-// Splitter object. Iterators may only be compared if they refer to the same
-// Splitter instance.
-//
-// This class is NOT part of the public splitting API.
-template <typename Splitter> class SplitIterator {
-public:
-  using iterator_category = std::input_iterator_tag;
-  using value_type = absl::string_view;
-  using difference_type = ptrdiff_t;
-  using pointer = const value_type *;
-  using reference = const value_type &;
-
-  enum State { kInitState, kLastState, kEndState };
-  SplitIterator(State state, const Splitter *splitter)
-      : pos_(0), state_(state), splitter_(splitter),
-        delimiter_(splitter->delimiter()), predicate_(splitter->predicate()) {
-    // Hack to maintain backward compatibility. This one block makes it so an
-    // empty absl::string_view whose .data() happens to be nullptr behaves
-    // *differently* from an otherwise empty absl::string_view whose .data() is
-    // not nullptr. This is an undesirable difference in general, but this
-    // behavior is maintained to avoid breaking existing code that happens to
-    // depend on this old behavior/bug. Perhaps it will be fixed one day. The
-    // difference in behavior is as follows:
-    //   Split(absl::string_view(""), '-');  // {""}
-    //   Split(absl::string_view(), '-');    // {}
-    if (splitter_->text().data() == nullptr) {
-      state_ = kEndState;
-      pos_ = splitter_->text().size();
-      return;
-    }
-
-    if (state_ == kEndState) {
-      pos_ = splitter_->text().size();
-    } else {
-      ++(*this);
-    }
-  }
-
-  bool at_end() const { return state_ == kEndState; }
-
-  reference operator*() const { return curr_; }
-  pointer operator->() const { return &curr_; }
-
-  SplitIterator &operator++() {
-    do {
-      if (state_ == kLastState) {
-        state_ = kEndState;
-        return *this;
-      }
-      const absl::string_view text = splitter_->text();
-      const absl::string_view d = delimiter_.Find(text, pos_);
-      if (d.data() == text.data() + text.size())
-        state_ = kLastState;
-      curr_ = text.substr(pos_,
-                          static_cast<size_t>(d.data() - (text.data() + pos_)));
-      pos_ += curr_.size() + d.size();
-    } while (!predicate_(curr_));
-    return *this;
-  }
-
-  SplitIterator operator++(int) {
-    SplitIterator old(*this);
-    ++(*this);
-    return old;
-  }
-
-  friend bool operator==(const SplitIterator &a, const SplitIterator &b) {
-    return a.state_ == b.state_ && a.pos_ == b.pos_;
-  }
-
-  friend bool operator!=(const SplitIterator &a, const SplitIterator &b) {
-    return !(a == b);
-  }
-
-private:
-  size_t pos_;
-  State state_;
-  absl::string_view curr_;
-  const Splitter *splitter_;
-  typename Splitter::DelimiterType delimiter_;
-  typename Splitter::PredicateType predicate_;
-};
-
-// HasMappedType<T>::value is true iff there exists a type T::mapped_type.
-template <typename T, typename = void>
-struct HasMappedType : std::false_type {};
-template <typename T>
-struct HasMappedType<T, absl::void_t<typename T::mapped_type>>
-    : std::true_type {};
-
-// HasValueType<T>::value is true iff there exists a type T::value_type.
-template <typename T, typename = void> struct HasValueType : std::false_type {};
-template <typename T>
-struct HasValueType<T, absl::void_t<typename T::value_type>> : std::true_type {
-};
-
-// HasConstIterator<T>::value is true iff there exists a type T::const_iterator.
-template <typename T, typename = void>
-struct HasConstIterator : std::false_type {};
-template <typename T>
-struct HasConstIterator<T, absl::void_t<typename T::const_iterator>>
-    : std::true_type {};
-
-// HasEmplace<T>::value is true iff there exists a method T::emplace().
-template <typename T, typename = void> struct HasEmplace : std::false_type {};
-template <typename T>
-struct HasEmplace<T, absl::void_t<decltype(std::declval<T>().emplace())>>
-    : std::true_type {};
-
-// IsInitializerList<T>::value is true iff T is an std::initializer_list. More
-// details below in Splitter<> where this is used.
-std::false_type IsInitializerListDispatch(...); // default: No
-template <typename T>
-std::true_type IsInitializerListDispatch(std::initializer_list<T> *);
-template <typename T>
-struct IsInitializerList
-    : decltype(IsInitializerListDispatch(static_cast<T *>(nullptr))){};
-
-// A SplitterIsConvertibleTo<C>::type alias exists iff the specified condition
-// is true for type 'C'.
-//
-// Restricts conversion to container-like types (by testing for the presence of
-// a const_iterator member type) and also to disable conversion to an
-// std::initializer_list (which also has a const_iterator). Otherwise, code
-// compiled in C++11 will get an error due to ambiguous conversion paths (in
-// C++11 std::vector<T>::operator= is overloaded to take either a std::vector<T>
-// or an std::initializer_list<T>).
-
-template <typename C, bool has_value_type, bool has_mapped_type>
-struct SplitterIsConvertibleToImpl : std::false_type {};
-
-template <typename C>
-struct SplitterIsConvertibleToImpl<C, true, false>
-    : std::is_constructible<typename C::value_type, absl::string_view> {};
-
-template <typename C>
-struct SplitterIsConvertibleToImpl<C, true, true>
-    : absl::conjunction<
-          std::is_constructible<typename C::key_type, absl::string_view>,
-          std::is_constructible<typename C::mapped_type, absl::string_view>> {};
-
-template <typename C>
-struct SplitterIsConvertibleTo
-    : SplitterIsConvertibleToImpl<
-          C,
-#ifdef _GLIBCXX_DEBUG
-          !IsStrictlyBaseOfAndConvertibleToSTLContainer<C>::value &&
-#endif // _GLIBCXX_DEBUG
-              !IsInitializerList<
-                  typename std::remove_reference<C>::type>::value &&
-              HasValueType<C>::value && HasConstIterator<C>::value,
-          HasMappedType<C>::value> {
-};
-
-template <typename StringType, typename Container, typename = void>
-struct ShouldUseLifetimeBound : std::false_type {};
-
-template <typename StringType, typename Container>
-struct ShouldUseLifetimeBound<
-    StringType, Container,
-    std::enable_if_t<
-        std::is_same<StringType, std::string>::value &&
-        std::is_same<typename Container::value_type, absl::string_view>::value>>
-    : std::true_type {};
-
-template <typename StringType, typename First, typename Second>
-using ShouldUseLifetimeBoundForPair = std::integral_constant<
-    bool, std::is_same<StringType, std::string>::value &&
-              (std::is_same<First, absl::string_view>::value ||
-               std::is_same<Second, absl::string_view>::value)>;
-
-template <typename StringType, typename ElementType, std::size_t Size>
-using ShouldUseLifetimeBoundForArray = std::integral_constant<
-    bool, std::is_same<StringType, std::string>::value &&
-              std::is_same<ElementType, absl::string_view>::value>;
-
-// This class implements the range that is returned by absl::StrSplit(). This
-// class has templated conversion operators that allow it to be implicitly
-// converted to a variety of types that the caller may have specified on the
-// left-hand side of an assignment.
-//
-// The main interface for interacting with this class is through its implicit
-// conversion operators. However, this class may also be used like a container
-// in that it has .begin() and .end() member functions. It may also be used
-// within a range-for loop.
-//
-// Output containers can be collections of any type that is constructible from
-// an absl::string_view.
-//
-// An Predicate functor may be supplied. This predicate will be used to filter
-// the split strings: only strings for which the predicate returns true will be
-// kept. A Predicate object is any unary functor that takes an absl::string_view
-// and returns bool.
-//
-// The StringType parameter can be either string_view or string, depending on
-// whether the Splitter refers to a string stored elsewhere, or if the string
-// resides inside the Splitter itself.
-template <typename Delimiter, typename Predicate, typename StringType>
-class Splitter {
-public:
-  using DelimiterType = Delimiter;
-  using PredicateType = Predicate;
-  using const_iterator = strings_internal::SplitIterator<Splitter>;
-  using value_type = typename std::iterator_traits<const_iterator>::value_type;
-
-  Splitter(StringType input_text, Delimiter d, Predicate p)
-      : text_(std::move(input_text)), delimiter_(std::move(d)),
-        predicate_(std::move(p)) {}
-
-  absl::string_view text() const { return text_; }
-  const Delimiter &delimiter() const { return delimiter_; }
-  const Predicate &predicate() const { return predicate_; }
-
-  // Range functions that iterate the split substrings as absl::string_view
-  // objects. These methods enable a Splitter to be used in a range-based for
-  // loop.
-  const_iterator begin() const { return {const_iterator::kInitState, this}; }
-  const_iterator end() const { return {const_iterator::kEndState, this}; }
-
-  // An implicit conversion operator that is restricted to only those containers
-  // that the splitter is convertible to.
-  template <
-      typename Container,
-      std::enable_if_t<ShouldUseLifetimeBound<StringType, Container>::value &&
-                           SplitterIsConvertibleTo<Container>::value,
-                       std::nullptr_t> = nullptr>
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  operator Container() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    return ConvertToContainer<Container, typename Container::value_type,
-                              HasMappedType<Container>::value>()(*this);
-  }
-
-  template <
-      typename Container,
-      std::enable_if_t<!ShouldUseLifetimeBound<StringType, Container>::value &&
-                           SplitterIsConvertibleTo<Container>::value,
-                       std::nullptr_t> = nullptr>
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  operator Container() const {
-    return ConvertToContainer<Container, typename Container::value_type,
-                              HasMappedType<Container>::value>()(*this);
-  }
-
-  // Returns a pair with its .first and .second members set to the first two
-  // strings returned by the begin() iterator. Either/both of .first and .second
-  // will be constructed with empty strings if the iterator doesn't have a
-  // corresponding value.
-  template <typename First, typename Second,
-            std::enable_if_t<
-                ShouldUseLifetimeBoundForPair<StringType, First, Second>::value,
-                std::nullptr_t> = nullptr>
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  operator std::pair<First, Second>() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    return ConvertToPair<First, Second>();
-  }
-
-  template <typename First, typename Second,
-            std::enable_if_t<!ShouldUseLifetimeBoundForPair<StringType, First,
-                                                            Second>::value,
-                             std::nullptr_t> = nullptr>
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  operator std::pair<First, Second>() const {
-    return ConvertToPair<First, Second>();
-  }
-
-  // Returns an array with its elements set to the first few strings returned by
-  // the begin() iterator.  If there is not a corresponding value the empty
-  // string is used.
-  template <typename ElementType, std::size_t Size,
-            std::enable_if_t<ShouldUseLifetimeBoundForArray<
-                                 StringType, ElementType, Size>::value,
-                             std::nullptr_t> = nullptr>
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  operator std::array<ElementType, Size>() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    return ConvertToArray<ElementType, Size>();
-  }
-
-  template <typename ElementType, std::size_t Size,
-            std::enable_if_t<!ShouldUseLifetimeBoundForArray<
-                                 StringType, ElementType, Size>::value,
-                             std::nullptr_t> = nullptr>
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  operator std::array<ElementType, Size>() const {
-    return ConvertToArray<ElementType, Size>();
-  }
-
-private:
-  template <typename ElementType, std::size_t Size>
-  std::array<ElementType, Size> ConvertToArray() const {
-    std::array<ElementType, Size> a;
-    auto it = begin();
-    for (std::size_t i = 0; i < Size && it != end(); ++i, ++it) {
-      a[i] = ElementType(*it);
-    }
-    return a;
-  }
-
-  template <typename First, typename Second>
-  std::pair<First, Second> ConvertToPair() const {
-    absl::string_view first, second;
-    auto it = begin();
-    if (it != end()) {
-      first = *it;
-      if (++it != end()) {
-        second = *it;
-      }
-    }
-    return {First(first), Second(second)};
-  }
-
-  // ConvertToContainer is a functor converting a Splitter to the requested
-  // Container of ValueType. It is specialized below to optimize splitting to
-  // certain combinations of Container and ValueType.
-  //
-  // This base template handles the generic case of storing the split results in
-  // the requested non-map-like container and converting the split substrings to
-  // the requested type.
-  template <typename Container, typename ValueType, bool is_map = false>
-  struct ConvertToContainer {
-    Container operator()(const Splitter &splitter) const {
-      Container c;
-      auto it = std::inserter(c, c.end());
-      for (const auto &sp : splitter) {
-        *it++ = ValueType(sp);
-      }
-      return c;
-    }
-  };
-
-  // Partial specialization for a std::vector<absl::string_view>.
-  //
-  // Optimized for the common case of splitting to a
-  // std::vector<absl::string_view>. In this case we first split the results to
-  // a small array of absl::string_view on the stack, to reduce reallocations.
-  template <typename A>
-  struct ConvertToContainer<std::vector<absl::string_view, A>,
-                            absl::string_view, false> {
-    std::vector<absl::string_view, A>
-    operator()(const Splitter &splitter) const {
-      struct raw_view {
-        const char *data;
-        size_t size;
-        operator absl::string_view() const { // NOLINT(runtime/explicit)
-          return {data, size};
-        }
-      };
-      std::vector<absl::string_view, A> v;
-      std::array<raw_view, 16> ar;
-      for (auto it = splitter.begin(); !it.at_end();) {
-        size_t index = 0;
-        do {
-          ar[index].data = it->data();
-          ar[index].size = it->size();
-          ++it;
-        } while (++index != ar.size() && !it.at_end());
-        // We static_cast index to a signed type to work around overzealous
-        // compiler warnings about signedness.
-        v.insert(v.end(), ar.begin(),
-                 ar.begin() + static_cast<ptrdiff_t>(index));
-      }
-      return v;
-    }
-  };
-
-  // Partial specialization for a std::vector<std::string>.
-  //
-  // Optimized for the common case of splitting to a std::vector<std::string>.
-  // In this case we first split the results to a std::vector<absl::string_view>
-  // so the returned std::vector<std::string> can have space reserved to avoid
-  // std::string moves.
-  template <typename A>
-  struct ConvertToContainer<std::vector<std::string, A>, std::string, false> {
-    std::vector<std::string, A> operator()(const Splitter &splitter) const {
-      const std::vector<absl::string_view> v = splitter;
-      return std::vector<std::string, A>(v.begin(), v.end());
-    }
-  };
-
-  // Partial specialization for containers of pairs (e.g., maps).
-  //
-  // The algorithm is to insert a new pair into the map for each even-numbered
-  // item, with the even-numbered item as the key with a default-constructed
-  // value. Each odd-numbered item will then be assigned to the last pair's
-  // value.
-  template <typename Container, typename First, typename Second>
-  struct ConvertToContainer<Container, std::pair<const First, Second>, true> {
-    using iterator = typename Container::iterator;
-
-    Container operator()(const Splitter &splitter) const {
-      Container m;
-      iterator it;
-      bool insert = true;
-      for (const absl::string_view sv : splitter) {
-        if (insert) {
-          it = InsertOrEmplace(&m, sv);
-        } else {
-          it->second = Second(sv);
-        }
-        insert = !insert;
-      }
-      return m;
-    }
-
-    // Inserts the key and an empty value into the map, returning an iterator to
-    // the inserted item. We use emplace() if available, otherwise insert().
-    template <typename M>
-    static absl::enable_if_t<HasEmplace<M>::value, iterator>
-    InsertOrEmplace(M *m, absl::string_view key) {
-      // Use piecewise_construct to support old versions of gcc in which pair
-      // constructor can't otherwise construct string from string_view.
-      return ToIter(m->emplace(std::piecewise_construct, std::make_tuple(key),
-                               std::tuple<>()));
-    }
-    template <typename M>
-    static absl::enable_if_t<!HasEmplace<M>::value, iterator>
-    InsertOrEmplace(M *m, absl::string_view key) {
-      return ToIter(m->insert(std::make_pair(First(key), Second(""))));
-    }
-
-    static iterator ToIter(std::pair<iterator, bool> pair) {
-      return pair.first;
-    }
-    static iterator ToIter(iterator iter) { return iter; }
-  };
-
-  StringType text_;
-  Delimiter delimiter_;
-  Predicate predicate_;
-};
-
-} // namespace strings_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/string_constant.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/string_constant.h
deleted file mode 100644
index 98f4492ec5..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/string_constant.h
+++ /dev/null
@@ -1,69 +0,0 @@
-// Copyright 2020 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_STRING_CONSTANT_H_
-#define ABSL_STRINGS_INTERNAL_STRING_CONSTANT_H_
-
-#include "absl/meta/type_traits.h"
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-// StringConstant<T> represents a compile time string constant.
-// It can be accessed via its `absl::string_view value` static member.
-// It is guaranteed that the `string_view` returned has constant `.data()`,
-// constant `.size()` and constant `value[i]` for all `0 <= i < .size()`
-//
-// The `T` is an opaque type. It is guaranteed that different string constants
-// will have different values of `T`. This allows users to associate the string
-// constant with other static state at compile time.
-//
-// Instances should be made using the `MakeStringConstant()` factory function
-// below.
-template <typename T> struct StringConstant {
-private:
-  static constexpr bool TryConstexprEval(absl::string_view view) {
-    return view.empty() || 2 * view[0] != 1;
-  }
-
-public:
-  static constexpr absl::string_view value = T{}();
-  constexpr absl::string_view operator()() const { return value; }
-
-  // Check to be sure `view` points to constant data.
-  // Otherwise, it can't be constant evaluated.
-  static_assert(TryConstexprEval(value),
-                "The input string_view must point to constant data.");
-};
-
-#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-template <typename T> constexpr absl::string_view StringConstant<T>::value;
-#endif
-
-// Factory function for `StringConstant` instances.
-// It supports callables that have a constexpr default constructor and a
-// constexpr operator().
-// It must return an `absl::string_view` or `const char*` pointing to constant
-// data. This is validated at compile time.
-template <typename T> constexpr StringConstant<T> MakeStringConstant(T) {
-  return {};
-}
-
-} // namespace strings_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_STRING_CONSTANT_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/stringify_sink.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/stringify_sink.h
deleted file mode 100644
index d7cfcac047..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/stringify_sink.h
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2022 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_STRINGIFY_SINK_H_
-#define ABSL_STRINGS_INTERNAL_STRINGIFY_SINK_H_
-
-#include <string>
-#include <type_traits>
-#include <utility>
-
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-namespace strings_internal {
-class StringifySink {
-public:
-  void Append(size_t count, char ch);
-
-  void Append(string_view v);
-
-  // Support `absl::Format(&sink, format, args...)`.
-  friend void AbslFormatFlush(StringifySink *sink, absl::string_view v) {
-    sink->Append(v);
-  }
-
-private:
-  template <typename T>
-  friend string_view ExtractStringification(StringifySink &sink, const T &v);
-
-  std::string buffer_;
-};
-
-template <typename T>
-string_view ExtractStringification(StringifySink &sink, const T &v) {
-  AbslStringify(sink, v);
-  return sink.buffer_;
-}
-
-} // namespace strings_internal
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_STRINGIFY_SINK_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/internal/utf8.h b/packages/react-native-executorch/third-party/include/absl/strings/internal/utf8.h
deleted file mode 100644
index b6bfe23b6f..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/internal/utf8.h
+++ /dev/null
@@ -1,50 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// UTF8 utilities, implemented to reduce dependencies.
-
-#ifndef ABSL_STRINGS_INTERNAL_UTF8_H_
-#define ABSL_STRINGS_INTERNAL_UTF8_H_
-
-#include <cstddef>
-#include <cstdint>
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-// For Unicode code points 0 through 0x10FFFF, EncodeUTF8Char writes
-// out the UTF-8 encoding into buffer, and returns the number of chars
-// it wrote.
-//
-// As described in https://tools.ietf.org/html/rfc3629#section-3 , the encodings
-// are:
-//    00 -     7F : 0xxxxxxx
-//    80 -    7FF : 110xxxxx 10xxxxxx
-//   800 -   FFFF : 1110xxxx 10xxxxxx 10xxxxxx
-// 10000 - 10FFFF : 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
-//
-// Values greater than 0x10FFFF are not supported and may or may not write
-// characters into buffer, however never will more than kMaxEncodedUTF8Size
-// bytes be written, regardless of the value of utf8_char.
-enum { kMaxEncodedUTF8Size = 4 };
-size_t EncodeUTF8Char(char *buffer, char32_t utf8_char);
-
-} // namespace strings_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_INTERNAL_UTF8_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/match.h b/packages/react-native-executorch/third-party/include/absl/strings/match.h
deleted file mode 100644
index 845d46f62a..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/match.h
+++ /dev/null
@@ -1,128 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: match.h
-// -----------------------------------------------------------------------------
-//
-// This file contains simple utilities for performing string matching checks.
-// All of these function parameters are specified as `absl::string_view`,
-// meaning that these functions can accept `std::string`, `absl::string_view` or
-// NUL-terminated C-style strings.
-//
-// Examples:
-//   std::string s = "foo";
-//   absl::string_view sv = "f";
-//   assert(absl::StrContains(s, sv));
-//
-// Note: The order of parameters in these functions is designed to mimic the
-// order an equivalent member function would exhibit;
-// e.g. `s.Contains(x)` ==> `absl::StrContains(s, x).
-#ifndef ABSL_STRINGS_MATCH_H_
-#define ABSL_STRINGS_MATCH_H_
-
-#include <cstring>
-
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// StrContains()
-//
-// Returns whether a given string `haystack` contains the substring `needle`.
-inline bool StrContains(absl::string_view haystack,
-                        absl::string_view needle) noexcept {
-  return haystack.find(needle, 0) != haystack.npos;
-}
-
-inline bool StrContains(absl::string_view haystack, char needle) noexcept {
-  return haystack.find(needle) != haystack.npos;
-}
-
-// StartsWith()
-//
-// Returns whether a given string `text` begins with `prefix`.
-inline constexpr bool StartsWith(absl::string_view text,
-                                 absl::string_view prefix) noexcept {
-  if (prefix.empty()) {
-    return true;
-  }
-  if (text.size() < prefix.size()) {
-    return false;
-  }
-  absl::string_view possible_match = text.substr(0, prefix.size());
-
-  return possible_match == prefix;
-}
-
-// EndsWith()
-//
-// Returns whether a given string `text` ends with `suffix`.
-inline constexpr bool EndsWith(absl::string_view text,
-                               absl::string_view suffix) noexcept {
-  if (suffix.empty()) {
-    return true;
-  }
-  if (text.size() < suffix.size()) {
-    return false;
-  }
-  absl::string_view possible_match = text.substr(text.size() - suffix.size());
-  return possible_match == suffix;
-}
-// StrContainsIgnoreCase()
-//
-// Returns whether a given ASCII string `haystack` contains the ASCII substring
-// `needle`, ignoring case in the comparison.
-bool StrContainsIgnoreCase(absl::string_view haystack,
-                           absl::string_view needle) noexcept;
-
-bool StrContainsIgnoreCase(absl::string_view haystack, char needle) noexcept;
-
-// EqualsIgnoreCase()
-//
-// Returns whether given ASCII strings `piece1` and `piece2` are equal, ignoring
-// case in the comparison.
-bool EqualsIgnoreCase(absl::string_view piece1,
-                      absl::string_view piece2) noexcept;
-
-// StartsWithIgnoreCase()
-//
-// Returns whether a given ASCII string `text` starts with `prefix`,
-// ignoring case in the comparison.
-bool StartsWithIgnoreCase(absl::string_view text,
-                          absl::string_view prefix) noexcept;
-
-// EndsWithIgnoreCase()
-//
-// Returns whether a given ASCII string `text` ends with `suffix`, ignoring
-// case in the comparison.
-bool EndsWithIgnoreCase(absl::string_view text,
-                        absl::string_view suffix) noexcept;
-
-// Yields the longest prefix in common between both input strings.
-// Pointer-wise, the returned result is a subset of input "a".
-absl::string_view FindLongestCommonPrefix(absl::string_view a,
-                                          absl::string_view b);
-
-// Yields the longest suffix in common between both input strings.
-// Pointer-wise, the returned result is a subset of input "a".
-absl::string_view FindLongestCommonSuffix(absl::string_view a,
-                                          absl::string_view b);
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_MATCH_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/numbers.h b/packages/react-native-executorch/third-party/include/absl/strings/numbers.h
deleted file mode 100644
index 9c4d42ee41..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/numbers.h
+++ /dev/null
@@ -1,317 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: numbers.h
-// -----------------------------------------------------------------------------
-//
-// This package contains functions for converting strings to numbers. For
-// converting numbers to strings, use `StrCat()` or `StrAppend()` in str_cat.h,
-// which automatically detect and convert most number values appropriately.
-
-#ifndef ABSL_STRINGS_NUMBERS_H_
-#define ABSL_STRINGS_NUMBERS_H_
-
-#ifdef __SSSE3__
-#include <tmmintrin.h>
-#endif
-
-#ifdef _MSC_VER
-#include <intrin.h>
-#endif
-
-#include <cstddef>
-#include <cstdlib>
-#include <cstring>
-#include <ctime>
-#include <limits>
-#include <string>
-#include <type_traits>
-
-#include "absl/base/config.h"
-#include "absl/base/internal/endian.h"
-#include "absl/base/macros.h"
-#include "absl/base/nullability.h"
-#include "absl/base/port.h"
-#include "absl/numeric/bits.h"
-#include "absl/numeric/int128.h"
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// SimpleAtoi()
-//
-// Converts the given string (optionally followed or preceded by ASCII
-// whitespace) into an integer value, returning `true` if successful. The string
-// must reflect a base-10 integer whose value falls within the range of the
-// integer type (optionally preceded by a `+` or `-`). If any errors are
-// encountered, this function returns `false`, leaving `out` in an unspecified
-// state.
-template <typename int_type>
-ABSL_MUST_USE_RESULT bool SimpleAtoi(absl::string_view str,
-                                     absl::Nonnull<int_type *> out);
-
-// SimpleAtof()
-//
-// Converts the given string (optionally followed or preceded by ASCII
-// whitespace) into a float, which may be rounded on overflow or underflow,
-// returning `true` if successful.
-// See https://en.cppreference.com/w/c/string/byte/strtof for details about the
-// allowed formats for `str`, except SimpleAtof() is locale-independent and will
-// always use the "C" locale. If any errors are encountered, this function
-// returns `false`, leaving `out` in an unspecified state.
-ABSL_MUST_USE_RESULT bool SimpleAtof(absl::string_view str,
-                                     absl::Nonnull<float *> out);
-
-// SimpleAtod()
-//
-// Converts the given string (optionally followed or preceded by ASCII
-// whitespace) into a double, which may be rounded on overflow or underflow,
-// returning `true` if successful.
-// See https://en.cppreference.com/w/c/string/byte/strtof for details about the
-// allowed formats for `str`, except SimpleAtod is locale-independent and will
-// always use the "C" locale. If any errors are encountered, this function
-// returns `false`, leaving `out` in an unspecified state.
-ABSL_MUST_USE_RESULT bool SimpleAtod(absl::string_view str,
-                                     absl::Nonnull<double *> out);
-
-// SimpleAtob()
-//
-// Converts the given string into a boolean, returning `true` if successful.
-// The following case-insensitive strings are interpreted as boolean `true`:
-// "true", "t", "yes", "y", "1". The following case-insensitive strings
-// are interpreted as boolean `false`: "false", "f", "no", "n", "0". If any
-// errors are encountered, this function returns `false`, leaving `out` in an
-// unspecified state.
-ABSL_MUST_USE_RESULT bool SimpleAtob(absl::string_view str,
-                                     absl::Nonnull<bool *> out);
-
-// SimpleHexAtoi()
-//
-// Converts a hexadecimal string (optionally followed or preceded by ASCII
-// whitespace) to an integer, returning `true` if successful. Only valid base-16
-// hexadecimal integers whose value falls within the range of the integer type
-// (optionally preceded by a `+` or `-`) can be converted. A valid hexadecimal
-// value may include both upper and lowercase character symbols, and may
-// optionally include a leading "0x" (or "0X") number prefix, which is ignored
-// by this function. If any errors are encountered, this function returns
-// `false`, leaving `out` in an unspecified state.
-template <typename int_type>
-ABSL_MUST_USE_RESULT bool SimpleHexAtoi(absl::string_view str,
-                                        absl::Nonnull<int_type *> out);
-
-// Overloads of SimpleHexAtoi() for 128 bit integers.
-ABSL_MUST_USE_RESULT inline bool
-SimpleHexAtoi(absl::string_view str, absl::Nonnull<absl::int128 *> out);
-ABSL_MUST_USE_RESULT inline bool
-SimpleHexAtoi(absl::string_view str, absl::Nonnull<absl::uint128 *> out);
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-// End of public API.  Implementation details follow.
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace numbers_internal {
-
-// Digit conversion.
-ABSL_DLL extern const char kHexChar[17]; // 0123456789abcdef
-ABSL_DLL extern const char
-    kHexTable[513]; // 000102030405060708090a0b0c0d0e0f1011...
-
-// Writes a two-character representation of 'i' to 'buf'. 'i' must be in the
-// range 0 <= i < 100, and buf must have space for two characters. Example:
-//   char buf[2];
-//   PutTwoDigits(42, buf);
-//   // buf[0] == '4'
-//   // buf[1] == '2'
-void PutTwoDigits(uint32_t i, absl::Nonnull<char *> buf);
-
-// safe_strto?() functions for implementing SimpleAtoi()
-
-bool safe_strto32_base(absl::string_view text, absl::Nonnull<int32_t *> value,
-                       int base);
-bool safe_strto64_base(absl::string_view text, absl::Nonnull<int64_t *> value,
-                       int base);
-bool safe_strto128_base(absl::string_view text,
-                        absl::Nonnull<absl::int128 *> value, int base);
-bool safe_strtou32_base(absl::string_view text, absl::Nonnull<uint32_t *> value,
-                        int base);
-bool safe_strtou64_base(absl::string_view text, absl::Nonnull<uint64_t *> value,
-                        int base);
-bool safe_strtou128_base(absl::string_view text,
-                         absl::Nonnull<absl::uint128 *> value, int base);
-
-static const int kFastToBufferSize = 32;
-static const int kSixDigitsToBufferSize = 16;
-
-// Helper function for fast formatting of floating-point values.
-// The result is the same as printf's "%g", a.k.a. "%.6g"; that is, six
-// significant digits are returned, trailing zeros are removed, and numbers
-// outside the range 0.0001-999999 are output using scientific notation
-// (1.23456e+06). This routine is heavily optimized.
-// Required buffer size is `kSixDigitsToBufferSize`.
-size_t SixDigitsToBuffer(double d, absl::Nonnull<char *> buffer);
-
-// WARNING: These functions may write more characters than necessary, because
-// they are intended for speed. All functions take an output buffer
-// as an argument and return a pointer to the last byte they wrote, which is the
-// terminating '\0'. At most `kFastToBufferSize` bytes are written.
-absl::Nonnull<char *> FastIntToBuffer(int32_t i, absl::Nonnull<char *> buffer)
-    ABSL_INTERNAL_NEED_MIN_SIZE(buffer, kFastToBufferSize);
-absl::Nonnull<char *> FastIntToBuffer(uint32_t n, absl::Nonnull<char *> out_str)
-    ABSL_INTERNAL_NEED_MIN_SIZE(out_str, kFastToBufferSize);
-absl::Nonnull<char *> FastIntToBuffer(int64_t i, absl::Nonnull<char *> buffer)
-    ABSL_INTERNAL_NEED_MIN_SIZE(buffer, kFastToBufferSize);
-absl::Nonnull<char *> FastIntToBuffer(uint64_t i, absl::Nonnull<char *> buffer)
-    ABSL_INTERNAL_NEED_MIN_SIZE(buffer, kFastToBufferSize);
-
-// For enums and integer types that are not an exact match for the types above,
-// use templates to call the appropriate one of the four overloads above.
-template <typename int_type>
-absl::Nonnull<char *> FastIntToBuffer(int_type i, absl::Nonnull<char *> buffer)
-    ABSL_INTERNAL_NEED_MIN_SIZE(buffer, kFastToBufferSize) {
-  static_assert(sizeof(i) <= 64 / 8,
-                "FastIntToBuffer works only with 64-bit-or-less integers.");
-  // TODO(jorg): This signed-ness check is used because it works correctly
-  // with enums, and it also serves to check that int_type is not a pointer.
-  // If one day something like std::is_signed<enum E> works, switch to it.
-  // These conditions are constexpr bools to suppress MSVC warning C4127.
-  constexpr bool kIsSigned = static_cast<int_type>(1) - 2 < 0;
-  constexpr bool kUse64Bit = sizeof(i) > 32 / 8;
-  if (kIsSigned) {
-    if (kUse64Bit) {
-      return FastIntToBuffer(static_cast<int64_t>(i), buffer);
-    } else {
-      return FastIntToBuffer(static_cast<int32_t>(i), buffer);
-    }
-  } else {
-    if (kUse64Bit) {
-      return FastIntToBuffer(static_cast<uint64_t>(i), buffer);
-    } else {
-      return FastIntToBuffer(static_cast<uint32_t>(i), buffer);
-    }
-  }
-}
-
-// Implementation of SimpleAtoi, generalized to support arbitrary base (used
-// with base different from 10 elsewhere in Abseil implementation).
-template <typename int_type>
-ABSL_MUST_USE_RESULT bool
-safe_strtoi_base(absl::string_view s, absl::Nonnull<int_type *> out, int base) {
-  static_assert(sizeof(*out) == 4 || sizeof(*out) == 8,
-                "SimpleAtoi works only with 32-bit or 64-bit integers.");
-  static_assert(!std::is_floating_point<int_type>::value,
-                "Use SimpleAtof or SimpleAtod instead.");
-  bool parsed;
-  // TODO(jorg): This signed-ness check is used because it works correctly
-  // with enums, and it also serves to check that int_type is not a pointer.
-  // If one day something like std::is_signed<enum E> works, switch to it.
-  // These conditions are constexpr bools to suppress MSVC warning C4127.
-  constexpr bool kIsSigned = static_cast<int_type>(1) - 2 < 0;
-  constexpr bool kUse64Bit = sizeof(*out) == 64 / 8;
-  if (kIsSigned) {
-    if (kUse64Bit) {
-      int64_t val;
-      parsed = numbers_internal::safe_strto64_base(s, &val, base);
-      *out = static_cast<int_type>(val);
-    } else {
-      int32_t val;
-      parsed = numbers_internal::safe_strto32_base(s, &val, base);
-      *out = static_cast<int_type>(val);
-    }
-  } else {
-    if (kUse64Bit) {
-      uint64_t val;
-      parsed = numbers_internal::safe_strtou64_base(s, &val, base);
-      *out = static_cast<int_type>(val);
-    } else {
-      uint32_t val;
-      parsed = numbers_internal::safe_strtou32_base(s, &val, base);
-      *out = static_cast<int_type>(val);
-    }
-  }
-  return parsed;
-}
-
-// FastHexToBufferZeroPad16()
-//
-// Outputs `val` into `out` as if by `snprintf(out, 17, "%016x", val)` but
-// without the terminating null character. Thus `out` must be of length >= 16.
-// Returns the number of non-pad digits of the output (it can never be zero
-// since 0 has one digit).
-inline size_t FastHexToBufferZeroPad16(uint64_t val,
-                                       absl::Nonnull<char *> out) {
-#ifdef ABSL_INTERNAL_HAVE_SSSE3
-  uint64_t be = absl::big_endian::FromHost64(val);
-  const auto kNibbleMask = _mm_set1_epi8(0xf);
-  const auto kHexDigits = _mm_setr_epi8('0', '1', '2', '3', '4', '5', '6', '7',
-                                        '8', '9', 'a', 'b', 'c', 'd', 'e', 'f');
-  auto v = _mm_loadl_epi64(reinterpret_cast<__m128i *>(&be)); // load lo dword
-  auto v4 = _mm_srli_epi64(v, 4);                             // shift 4 right
-  auto il = _mm_unpacklo_epi8(v4, v);              // interleave bytes
-  auto m = _mm_and_si128(il, kNibbleMask);         // mask out nibbles
-  auto hexchars = _mm_shuffle_epi8(kHexDigits, m); // hex chars
-  _mm_storeu_si128(reinterpret_cast<__m128i *>(out), hexchars);
-#else
-  for (int i = 0; i < 8; ++i) {
-    auto byte = (val >> (56 - 8 * i)) & 0xFF;
-    auto *hex = &absl::numbers_internal::kHexTable[byte * 2];
-    std::memcpy(out + 2 * i, hex, 2);
-  }
-#endif
-  // | 0x1 so that even 0 has 1 digit.
-  return 16 - static_cast<size_t>(countl_zero(val | 0x1) / 4);
-}
-
-} // namespace numbers_internal
-
-template <typename int_type>
-ABSL_MUST_USE_RESULT bool SimpleAtoi(absl::string_view str,
-                                     absl::Nonnull<int_type *> out) {
-  return numbers_internal::safe_strtoi_base(str, out, 10);
-}
-
-ABSL_MUST_USE_RESULT inline bool SimpleAtoi(absl::string_view str,
-                                            absl::Nonnull<absl::int128 *> out) {
-  return numbers_internal::safe_strto128_base(str, out, 10);
-}
-
-ABSL_MUST_USE_RESULT inline bool
-SimpleAtoi(absl::string_view str, absl::Nonnull<absl::uint128 *> out) {
-  return numbers_internal::safe_strtou128_base(str, out, 10);
-}
-
-template <typename int_type>
-ABSL_MUST_USE_RESULT bool SimpleHexAtoi(absl::string_view str,
-                                        absl::Nonnull<int_type *> out) {
-  return numbers_internal::safe_strtoi_base(str, out, 16);
-}
-
-ABSL_MUST_USE_RESULT inline bool
-SimpleHexAtoi(absl::string_view str, absl::Nonnull<absl::int128 *> out) {
-  return numbers_internal::safe_strto128_base(str, out, 16);
-}
-
-ABSL_MUST_USE_RESULT inline bool
-SimpleHexAtoi(absl::string_view str, absl::Nonnull<absl::uint128 *> out) {
-  return numbers_internal::safe_strtou128_base(str, out, 16);
-}
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_NUMBERS_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/str_cat.h b/packages/react-native-executorch/third-party/include/absl/strings/str_cat.h
deleted file mode 100644
index 9235de9a7d..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/str_cat.h
+++ /dev/null
@@ -1,611 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: str_cat.h
-// -----------------------------------------------------------------------------
-//
-// This package contains functions for efficiently concatenating and appending
-// strings: `StrCat()` and `StrAppend()`. Most of the work within these routines
-// is actually handled through use of a special AlphaNum type, which was
-// designed to be used as a parameter type that efficiently manages conversion
-// to strings and avoids copies in the above operations.
-//
-// Any routine accepting either a string or a number may accept `AlphaNum`.
-// The basic idea is that by accepting a `const AlphaNum &` as an argument
-// to your function, your callers will automagically convert bools, integers,
-// and floating point values to strings for you.
-//
-// NOTE: Use of `AlphaNum` outside of the //absl/strings package is unsupported
-// except for the specific case of function parameters of type `AlphaNum` or
-// `const AlphaNum &`. In particular, instantiating `AlphaNum` directly as a
-// stack variable is not supported.
-//
-// Conversion from 8-bit values is not accepted because, if it were, then an
-// attempt to pass ':' instead of ":" might result in a 58 ending up in your
-// result.
-//
-// Bools convert to "0" or "1". Pointers to types other than `char *` are not
-// valid inputs. No output is generated for null `char *` pointers.
-//
-// Floating point numbers are formatted with six-digit precision, which is
-// the default for "std::cout <<" or printf "%g" (the same as "%.6g").
-//
-// You can convert to hexadecimal output rather than decimal output using the
-// `Hex` type contained here. To do so, pass `Hex(my_int)` as a parameter to
-// `StrCat()` or `StrAppend()`. You may specify a minimum hex field width using
-// a `PadSpec` enum.
-//
-// User-defined types can be formatted with the `AbslStringify()` customization
-// point. The API relies on detecting an overload in the user-defined type's
-// namespace of a free (non-member) `AbslStringify()` function as a definition
-// (typically declared as a friend and implemented in-line.
-// with the following signature:
-//
-// class MyClass { ... };
-//
-// template <typename Sink>
-// void AbslStringify(Sink& sink, const MyClass& value);
-//
-// An `AbslStringify()` overload for a type should only be declared in the same
-// file and namespace as said type.
-//
-// Note that `AbslStringify()` also supports use with `absl::StrFormat()` and
-// `absl::Substitute()`.
-//
-// Example:
-//
-// struct Point {
-//   // To add formatting support to `Point`, we simply need to add a free
-//   // (non-member) function `AbslStringify()`. This method specifies how
-//   // Point should be printed when absl::StrCat() is called on it. You can add
-//   // such a free function using a friend declaration within the body of the
-//   // class. The sink parameter is a templated type to avoid requiring
-//   // dependencies.
-//   template <typename Sink> friend void AbslStringify(Sink&
-//   sink, const Point& p) {
-//     absl::Format(&sink, "(%v, %v)", p.x, p.y);
-//   }
-//
-//   int x;
-//   int y;
-// };
-// -----------------------------------------------------------------------------
-
-#ifndef ABSL_STRINGS_STR_CAT_H_
-#define ABSL_STRINGS_STR_CAT_H_
-
-#include <algorithm>
-#include <array>
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <initializer_list>
-#include <limits>
-#include <string>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-#include "absl/base/attributes.h"
-#include "absl/base/nullability.h"
-#include "absl/base/port.h"
-#include "absl/meta/type_traits.h"
-#include "absl/strings/has_absl_stringify.h"
-#include "absl/strings/internal/resize_uninitialized.h"
-#include "absl/strings/internal/stringify_sink.h"
-#include "absl/strings/numbers.h"
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-namespace strings_internal {
-// AlphaNumBuffer allows a way to pass a string to StrCat without having to do
-// memory allocation.  It is simply a pair of a fixed-size character array, and
-// a size.  Please don't use outside of absl, yet.
-template <size_t max_size> struct AlphaNumBuffer {
-  std::array<char, max_size> data;
-  size_t size;
-};
-
-} // namespace strings_internal
-
-// Enum that specifies the number of significant digits to return in a `Hex` or
-// `Dec` conversion and fill character to use. A `kZeroPad2` value, for example,
-// would produce hexadecimal strings such as "0a","0f" and a 'kSpacePad5' value
-// would produce hexadecimal strings such as "    a","    f".
-enum PadSpec : uint8_t {
-  kNoPad = 1,
-  kZeroPad2,
-  kZeroPad3,
-  kZeroPad4,
-  kZeroPad5,
-  kZeroPad6,
-  kZeroPad7,
-  kZeroPad8,
-  kZeroPad9,
-  kZeroPad10,
-  kZeroPad11,
-  kZeroPad12,
-  kZeroPad13,
-  kZeroPad14,
-  kZeroPad15,
-  kZeroPad16,
-  kZeroPad17,
-  kZeroPad18,
-  kZeroPad19,
-  kZeroPad20,
-
-  kSpacePad2 = kZeroPad2 + 64,
-  kSpacePad3,
-  kSpacePad4,
-  kSpacePad5,
-  kSpacePad6,
-  kSpacePad7,
-  kSpacePad8,
-  kSpacePad9,
-  kSpacePad10,
-  kSpacePad11,
-  kSpacePad12,
-  kSpacePad13,
-  kSpacePad14,
-  kSpacePad15,
-  kSpacePad16,
-  kSpacePad17,
-  kSpacePad18,
-  kSpacePad19,
-  kSpacePad20,
-};
-
-// -----------------------------------------------------------------------------
-// Hex
-// -----------------------------------------------------------------------------
-//
-// `Hex` stores a set of hexadecimal string conversion parameters for use
-// within `AlphaNum` string conversions.
-struct Hex {
-  uint64_t value;
-  uint8_t width;
-  char fill;
-
-  template <typename Int>
-  explicit Hex(
-      Int v, PadSpec spec = absl::kNoPad,
-      typename std::enable_if<sizeof(Int) == 1 &&
-                              !std::is_pointer<Int>::value>::type * = nullptr)
-      : Hex(spec, static_cast<uint8_t>(v)) {}
-  template <typename Int>
-  explicit Hex(
-      Int v, PadSpec spec = absl::kNoPad,
-      typename std::enable_if<sizeof(Int) == 2 &&
-                              !std::is_pointer<Int>::value>::type * = nullptr)
-      : Hex(spec, static_cast<uint16_t>(v)) {}
-  template <typename Int>
-  explicit Hex(
-      Int v, PadSpec spec = absl::kNoPad,
-      typename std::enable_if<sizeof(Int) == 4 &&
-                              !std::is_pointer<Int>::value>::type * = nullptr)
-      : Hex(spec, static_cast<uint32_t>(v)) {}
-  template <typename Int>
-  explicit Hex(
-      Int v, PadSpec spec = absl::kNoPad,
-      typename std::enable_if<sizeof(Int) == 8 &&
-                              !std::is_pointer<Int>::value>::type * = nullptr)
-      : Hex(spec, static_cast<uint64_t>(v)) {}
-  template <typename Pointee>
-  explicit Hex(absl::Nullable<Pointee *> v, PadSpec spec = absl::kNoPad)
-      : Hex(spec, reinterpret_cast<uintptr_t>(v)) {}
-
-  template <typename S> friend void AbslStringify(S &sink, Hex hex) {
-    static_assert(
-        numbers_internal::kFastToBufferSize >= 32,
-        "This function only works when output buffer >= 32 bytes long");
-    char buffer[numbers_internal::kFastToBufferSize];
-    char *const end = &buffer[numbers_internal::kFastToBufferSize];
-    auto real_width =
-        absl::numbers_internal::FastHexToBufferZeroPad16(hex.value, end - 16);
-    if (real_width >= hex.width) {
-      sink.Append(absl::string_view(end - real_width, real_width));
-    } else {
-      // Pad first 16 chars because FastHexToBufferZeroPad16 pads only to 16 and
-      // max pad width can be up to 20.
-      std::memset(end - 32, hex.fill, 16);
-      // Patch up everything else up to the real_width.
-      std::memset(end - real_width - 16, hex.fill, 16);
-      sink.Append(absl::string_view(end - hex.width, hex.width));
-    }
-  }
-
-private:
-  Hex(PadSpec spec, uint64_t v)
-      : value(v),
-        width(spec == absl::kNoPad       ? 1
-              : spec >= absl::kSpacePad2 ? spec - absl::kSpacePad2 + 2
-                                         : spec - absl::kZeroPad2 + 2),
-        fill(spec >= absl::kSpacePad2 ? ' ' : '0') {}
-};
-
-// -----------------------------------------------------------------------------
-// Dec
-// -----------------------------------------------------------------------------
-//
-// `Dec` stores a set of decimal string conversion parameters for use
-// within `AlphaNum` string conversions.  Dec is slower than the default
-// integer conversion, so use it only if you need padding.
-struct Dec {
-  uint64_t value;
-  uint8_t width;
-  char fill;
-  bool neg;
-
-  template <typename Int>
-  explicit Dec(Int v, PadSpec spec = absl::kNoPad,
-               typename std::enable_if<(sizeof(Int) <= 8)>::type * = nullptr)
-      : value(v >= 0 ? static_cast<uint64_t>(v)
-                     : uint64_t{0} - static_cast<uint64_t>(v)),
-        width(spec == absl::kNoPad       ? 1
-              : spec >= absl::kSpacePad2 ? spec - absl::kSpacePad2 + 2
-                                         : spec - absl::kZeroPad2 + 2),
-        fill(spec >= absl::kSpacePad2 ? ' ' : '0'), neg(v < 0) {}
-
-  template <typename S> friend void AbslStringify(S &sink, Dec dec) {
-    assert(dec.width <= numbers_internal::kFastToBufferSize);
-    char buffer[numbers_internal::kFastToBufferSize];
-    char *const end = &buffer[numbers_internal::kFastToBufferSize];
-    char *const minfill = end - dec.width;
-    char *writer = end;
-    uint64_t val = dec.value;
-    while (val > 9) {
-      *--writer = '0' + (val % 10);
-      val /= 10;
-    }
-    *--writer = '0' + static_cast<char>(val);
-    if (dec.neg)
-      *--writer = '-';
-
-    ptrdiff_t fillers = writer - minfill;
-    if (fillers > 0) {
-      // Tricky: if the fill character is ' ', then it's <fill><+/-><digits>
-      // But...: if the fill character is '0', then it's <+/-><fill><digits>
-      bool add_sign_again = false;
-      if (dec.neg && dec.fill == '0') { // If filling with '0',
-        ++writer;                       // ignore the sign we just added
-        add_sign_again = true;          // and re-add the sign later.
-      }
-      writer -= fillers;
-      std::fill_n(writer, fillers, dec.fill);
-      if (add_sign_again)
-        *--writer = '-';
-    }
-
-    sink.Append(absl::string_view(writer, static_cast<size_t>(end - writer)));
-  }
-};
-
-// -----------------------------------------------------------------------------
-// AlphaNum
-// -----------------------------------------------------------------------------
-//
-// The `AlphaNum` class acts as the main parameter type for `StrCat()` and
-// `StrAppend()`, providing efficient conversion of numeric, boolean, decimal,
-// and hexadecimal values (through the `Dec` and `Hex` types) into strings.
-// `AlphaNum` should only be used as a function parameter. Do not instantiate
-//  `AlphaNum` directly as a stack variable.
-
-class AlphaNum {
-public:
-  // No bool ctor -- bools convert to an integral type.
-  // A bool ctor would also convert incoming pointers (bletch).
-
-  // Prevent brace initialization
-  template <typename T>
-  AlphaNum(std::initializer_list<T>) = delete; // NOLINT(runtime/explicit)
-
-  AlphaNum(int x) // NOLINT(runtime/explicit)
-      : piece_(digits_, static_cast<size_t>(
-                            numbers_internal::FastIntToBuffer(x, digits_) -
-                            &digits_[0])) {}
-  AlphaNum(unsigned int x) // NOLINT(runtime/explicit)
-      : piece_(digits_, static_cast<size_t>(
-                            numbers_internal::FastIntToBuffer(x, digits_) -
-                            &digits_[0])) {}
-  AlphaNum(long x) // NOLINT(*)
-      : piece_(digits_, static_cast<size_t>(
-                            numbers_internal::FastIntToBuffer(x, digits_) -
-                            &digits_[0])) {}
-  AlphaNum(unsigned long x) // NOLINT(*)
-      : piece_(digits_, static_cast<size_t>(
-                            numbers_internal::FastIntToBuffer(x, digits_) -
-                            &digits_[0])) {}
-  AlphaNum(long long x) // NOLINT(*)
-      : piece_(digits_, static_cast<size_t>(
-                            numbers_internal::FastIntToBuffer(x, digits_) -
-                            &digits_[0])) {}
-  AlphaNum(unsigned long long x) // NOLINT(*)
-      : piece_(digits_, static_cast<size_t>(
-                            numbers_internal::FastIntToBuffer(x, digits_) -
-                            &digits_[0])) {}
-
-  AlphaNum(float f) // NOLINT(runtime/explicit)
-      : piece_(digits_, numbers_internal::SixDigitsToBuffer(f, digits_)) {}
-  AlphaNum(double f) // NOLINT(runtime/explicit)
-      : piece_(digits_, numbers_internal::SixDigitsToBuffer(f, digits_)) {}
-
-  template <size_t size>
-  AlphaNum( // NOLINT(runtime/explicit)
-      const strings_internal::AlphaNumBuffer<size> &buf
-          ABSL_ATTRIBUTE_LIFETIME_BOUND)
-      : piece_(&buf.data[0], buf.size) {}
-
-  AlphaNum(absl::Nullable<const char *> c_str // NOLINT(runtime/explicit)
-               ABSL_ATTRIBUTE_LIFETIME_BOUND)
-      : piece_(NullSafeStringView(c_str)) {}
-  AlphaNum(absl::string_view pc // NOLINT(runtime/explicit)
-               ABSL_ATTRIBUTE_LIFETIME_BOUND)
-      : piece_(pc) {}
-
-  template <typename T, typename = typename std::enable_if<
-                            HasAbslStringify<T>::value>::type>
-  AlphaNum( // NOLINT(runtime/explicit)
-      const T &v ABSL_ATTRIBUTE_LIFETIME_BOUND,
-      strings_internal::StringifySink &&sink ABSL_ATTRIBUTE_LIFETIME_BOUND = {})
-      : piece_(strings_internal::ExtractStringification(sink, v)) {}
-
-  template <typename Allocator>
-  AlphaNum( // NOLINT(runtime/explicit)
-      const std::basic_string<char, std::char_traits<char>, Allocator> &str
-          ABSL_ATTRIBUTE_LIFETIME_BOUND)
-      : piece_(str) {}
-
-  // Use string literals ":" instead of character literals ':'.
-  AlphaNum(char c) = delete; // NOLINT(runtime/explicit)
-
-  AlphaNum(const AlphaNum &) = delete;
-  AlphaNum &operator=(const AlphaNum &) = delete;
-
-  absl::string_view::size_type size() const { return piece_.size(); }
-  absl::Nullable<const char *> data() const { return piece_.data(); }
-  absl::string_view Piece() const { return piece_; }
-
-  // Match unscoped enums.  Use integral promotion so that a `char`-backed
-  // enum becomes a wider integral type AlphaNum will accept.
-  template <typename T,
-            typename = typename std::enable_if<
-                std::is_enum<T>{} && std::is_convertible<T, int>{} &&
-                !HasAbslStringify<T>::value>::type>
-  AlphaNum(T e) // NOLINT(runtime/explicit)
-      : AlphaNum(+e) {}
-
-  // This overload matches scoped enums.  We must explicitly cast to the
-  // underlying type, but use integral promotion for the same reason as above.
-  template <typename T,
-            typename std::enable_if<std::is_enum<T>{} &&
-                                        !std::is_convertible<T, int>{} &&
-                                        !HasAbslStringify<T>::value,
-                                    char *>::type = nullptr>
-  AlphaNum(T e) // NOLINT(runtime/explicit)
-      : AlphaNum(+static_cast<typename std::underlying_type<T>::type>(e)) {}
-
-  // vector<bool>::reference and const_reference require special help to
-  // convert to `AlphaNum` because it requires two user defined conversions.
-  template <typename T,
-            typename std::enable_if<
-                std::is_class<T>::value &&
-                (std::is_same<T, std::vector<bool>::reference>::value ||
-                 std::is_same<T, std::vector<bool>::const_reference>::value)>::
-                type * = nullptr>
-  AlphaNum(T e) : AlphaNum(static_cast<bool>(e)) {} // NOLINT(runtime/explicit)
-
-private:
-  absl::string_view piece_;
-  char digits_[numbers_internal::kFastToBufferSize];
-};
-
-// -----------------------------------------------------------------------------
-// StrCat()
-// -----------------------------------------------------------------------------
-//
-// Merges given strings or numbers, using no delimiter(s), returning the merged
-// result as a string.
-//
-// `StrCat()` is designed to be the fastest possible way to construct a string
-// out of a mix of raw C strings, string_views, strings, bool values,
-// and numeric values.
-//
-// Don't use `StrCat()` for user-visible strings. The localization process
-// works poorly on strings built up out of fragments.
-//
-// For clarity and performance, don't use `StrCat()` when appending to a
-// string. Use `StrAppend()` instead. In particular, avoid using any of these
-// (anti-)patterns:
-//
-//   str.append(StrCat(...))
-//   str += StrCat(...)
-//   str = StrCat(str, ...)
-//
-// The last case is the worst, with a potential to change a loop
-// from a linear time operation with O(1) dynamic allocations into a
-// quadratic time operation with O(n) dynamic allocations.
-//
-// See `StrAppend()` below for more information.
-
-namespace strings_internal {
-
-// Do not call directly - this is not part of the public API.
-std::string CatPieces(std::initializer_list<absl::string_view> pieces);
-void AppendPieces(absl::Nonnull<std::string *> dest,
-                  std::initializer_list<absl::string_view> pieces);
-
-template <typename Integer> std::string IntegerToString(Integer i) {
-  // Any integer (signed/unsigned) up to 64 bits can be formatted into a buffer
-  // with 22 bytes (including NULL at the end).
-  constexpr size_t kMaxDigits10 = 22;
-  std::string result;
-  strings_internal::STLStringResizeUninitialized(&result, kMaxDigits10);
-  char *start = &result[0];
-  // note: this can be optimized to not write last zero.
-  char *end = numbers_internal::FastIntToBuffer(i, start);
-  auto size = static_cast<size_t>(end - start);
-  assert((size < result.size()) &&
-         "StrCat(Integer) does not fit into kMaxDigits10");
-  result.erase(size);
-  return result;
-}
-template <typename Float> std::string FloatToString(Float f) {
-  std::string result;
-  strings_internal::STLStringResizeUninitialized(
-      &result, numbers_internal::kSixDigitsToBufferSize);
-  char *start = &result[0];
-  result.erase(numbers_internal::SixDigitsToBuffer(f, start));
-  return result;
-}
-
-// `SingleArgStrCat` overloads take built-in `int`, `long` and `long long` types
-// (signed / unsigned) to avoid ambiguity on the call side. If we used int32_t
-// and int64_t, then at least one of the three (`int` / `long` / `long long`)
-// would have been ambiguous when passed to `SingleArgStrCat`.
-inline std::string SingleArgStrCat(int x) { return IntegerToString(x); }
-inline std::string SingleArgStrCat(unsigned int x) {
-  return IntegerToString(x);
-}
-// NOLINTNEXTLINE
-inline std::string SingleArgStrCat(long x) { return IntegerToString(x); }
-// NOLINTNEXTLINE
-inline std::string SingleArgStrCat(unsigned long x) {
-  return IntegerToString(x);
-}
-// NOLINTNEXTLINE
-inline std::string SingleArgStrCat(long long x) { return IntegerToString(x); }
-// NOLINTNEXTLINE
-inline std::string SingleArgStrCat(unsigned long long x) {
-  return IntegerToString(x);
-}
-inline std::string SingleArgStrCat(float x) { return FloatToString(x); }
-inline std::string SingleArgStrCat(double x) { return FloatToString(x); }
-
-// As of September 2023, the SingleArgStrCat() optimization is only enabled for
-// libc++. The reasons for this are:
-// 1) The SSO size for libc++ is 23, while libstdc++ and MSSTL have an SSO size
-// of 15. Since IntegerToString unconditionally resizes the string to 22 bytes,
-// this causes both libstdc++ and MSSTL to allocate.
-// 2) strings_internal::STLStringResizeUninitialized() only has an
-// implementation that avoids initialization when using libc++. This isn't as
-// relevant as (1), and the cost should be benchmarked if (1) ever changes on
-// libstc++ or MSSTL.
-#ifdef _LIBCPP_VERSION
-#define ABSL_INTERNAL_STRCAT_ENABLE_FAST_CASE true
-#else
-#define ABSL_INTERNAL_STRCAT_ENABLE_FAST_CASE false
-#endif
-
-template <typename T, typename = std::enable_if_t<
-                          ABSL_INTERNAL_STRCAT_ENABLE_FAST_CASE &&
-                          std::is_arithmetic<T>{} && !std::is_same<T, char>{}>>
-using EnableIfFastCase = T;
-
-#undef ABSL_INTERNAL_STRCAT_ENABLE_FAST_CASE
-
-} // namespace strings_internal
-
-ABSL_MUST_USE_RESULT inline std::string StrCat() { return std::string(); }
-
-template <typename T>
-ABSL_MUST_USE_RESULT inline std::string
-StrCat(strings_internal::EnableIfFastCase<T> a) {
-  return strings_internal::SingleArgStrCat(a);
-}
-ABSL_MUST_USE_RESULT inline std::string StrCat(const AlphaNum &a) {
-  return std::string(a.data(), a.size());
-}
-
-ABSL_MUST_USE_RESULT std::string StrCat(const AlphaNum &a, const AlphaNum &b);
-ABSL_MUST_USE_RESULT std::string StrCat(const AlphaNum &a, const AlphaNum &b,
-                                        const AlphaNum &c);
-ABSL_MUST_USE_RESULT std::string StrCat(const AlphaNum &a, const AlphaNum &b,
-                                        const AlphaNum &c, const AlphaNum &d);
-
-// Support 5 or more arguments
-template <typename... AV>
-ABSL_MUST_USE_RESULT inline std::string
-StrCat(const AlphaNum &a, const AlphaNum &b, const AlphaNum &c,
-       const AlphaNum &d, const AlphaNum &e, const AV &...args) {
-  return strings_internal::CatPieces(
-      {a.Piece(), b.Piece(), c.Piece(), d.Piece(), e.Piece(),
-       static_cast<const AlphaNum &>(args).Piece()...});
-}
-
-// -----------------------------------------------------------------------------
-// StrAppend()
-// -----------------------------------------------------------------------------
-//
-// Appends a string or set of strings to an existing string, in a similar
-// fashion to `StrCat()`.
-//
-// WARNING: `StrAppend(&str, a, b, c, ...)` requires that none of the
-// a, b, c, parameters be a reference into str. For speed, `StrAppend()` does
-// not try to check each of its input arguments to be sure that they are not
-// a subset of the string being appended to. That is, while this will work:
-//
-//   std::string s = "foo";
-//   s += s;
-//
-// This output is undefined:
-//
-//   std::string s = "foo";
-//   StrAppend(&s, s);
-//
-// This output is undefined as well, since `absl::string_view` does not own its
-// data:
-//
-//   std::string s = "foobar";
-//   absl::string_view p = s;
-//   StrAppend(&s, p);
-
-inline void StrAppend(absl::Nonnull<std::string *>) {}
-void StrAppend(absl::Nonnull<std::string *> dest, const AlphaNum &a);
-void StrAppend(absl::Nonnull<std::string *> dest, const AlphaNum &a,
-               const AlphaNum &b);
-void StrAppend(absl::Nonnull<std::string *> dest, const AlphaNum &a,
-               const AlphaNum &b, const AlphaNum &c);
-void StrAppend(absl::Nonnull<std::string *> dest, const AlphaNum &a,
-               const AlphaNum &b, const AlphaNum &c, const AlphaNum &d);
-
-// Support 5 or more arguments
-template <typename... AV>
-inline void StrAppend(absl::Nonnull<std::string *> dest, const AlphaNum &a,
-                      const AlphaNum &b, const AlphaNum &c, const AlphaNum &d,
-                      const AlphaNum &e, const AV &...args) {
-  strings_internal::AppendPieces(
-      dest, {a.Piece(), b.Piece(), c.Piece(), d.Piece(), e.Piece(),
-             static_cast<const AlphaNum &>(args).Piece()...});
-}
-
-// Helper function for the future StrCat default floating-point format, %.6g
-// This is fast.
-inline strings_internal::AlphaNumBuffer<
-    numbers_internal::kSixDigitsToBufferSize>
-SixDigits(double d) {
-  strings_internal::AlphaNumBuffer<numbers_internal::kSixDigitsToBufferSize>
-      result;
-  result.size = numbers_internal::SixDigitsToBuffer(d, &result.data[0]);
-  return result;
-}
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_STR_CAT_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/str_format.h b/packages/react-native-executorch/third-party/include/absl/strings/str_format.h
deleted file mode 100644
index 3c2bacf69d..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/str_format.h
+++ /dev/null
@@ -1,886 +0,0 @@
-//
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: str_format.h
-// -----------------------------------------------------------------------------
-//
-// The `str_format` library is a typesafe replacement for the family of
-// `printf()` string formatting routines within the `<cstdio>` standard library
-// header. Like the `printf` family, `str_format` uses a "format string" to
-// perform argument substitutions based on types. See the `FormatSpec` section
-// below for format string documentation.
-//
-// Example:
-//
-//   std::string s = absl::StrFormat(
-//                      "%s %s You have $%d!", "Hello", name, dollars);
-//
-// The library consists of the following basic utilities:
-//
-//   * `absl::StrFormat()`, a type-safe replacement for `std::sprintf()`, to
-//     write a format string to a `string` value.
-//   * `absl::StrAppendFormat()` to append a format string to a `string`
-//   * `absl::StreamFormat()` to more efficiently write a format string to a
-//     stream, such as`std::cout`.
-//   * `absl::PrintF()`, `absl::FPrintF()` and `absl::SNPrintF()` as
-//     drop-in replacements for `std::printf()`, `std::fprintf()` and
-//     `std::snprintf()`.
-//
-//     Note: An `absl::SPrintF()` drop-in replacement is not supported as it
-//     is generally unsafe due to buffer overflows. Use `absl::StrFormat` which
-//     returns the string as output instead of expecting a pre-allocated buffer.
-//
-// Additionally, you can provide a format string (and its associated arguments)
-// using one of the following abstractions:
-//
-//   * A `FormatSpec` class template fully encapsulates a format string and its
-//     type arguments and is usually provided to `str_format` functions as a
-//     variadic argument of type `FormatSpec<Arg...>`. The `FormatSpec<Args...>`
-//     template is evaluated at compile-time, providing type safety.
-//   * A `ParsedFormat` instance, which encapsulates a specific, pre-compiled
-//     format string for a specific set of type(s), and which can be passed
-//     between API boundaries. (The `FormatSpec` type should not be used
-//     directly except as an argument type for wrapper functions.)
-//
-// The `str_format` library provides the ability to output its format strings to
-// arbitrary sink types:
-//
-//   * A generic `Format()` function to write outputs to arbitrary sink types,
-//     which must implement a `FormatRawSink` interface.
-//
-//   * A `FormatUntyped()` function that is similar to `Format()` except it is
-//     loosely typed. `FormatUntyped()` is not a template and does not perform
-//     any compile-time checking of the format string; instead, it returns a
-//     boolean from a runtime check.
-//
-// In addition, the `str_format` library provides extension points for
-// augmenting formatting to new types.  See "StrFormat Extensions" below.
-
-#ifndef ABSL_STRINGS_STR_FORMAT_H_
-#define ABSL_STRINGS_STR_FORMAT_H_
-
-#include <cstdint>
-#include <cstdio>
-#include <string>
-#include <type_traits>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/base/nullability.h"
-#include "absl/strings/internal/str_format/arg.h"       // IWYU pragma: export
-#include "absl/strings/internal/str_format/bind.h"      // IWYU pragma: export
-#include "absl/strings/internal/str_format/checker.h"   // IWYU pragma: export
-#include "absl/strings/internal/str_format/extension.h" // IWYU pragma: export
-#include "absl/strings/internal/str_format/parser.h"    // IWYU pragma: export
-#include "absl/strings/string_view.h"
-#include "absl/types/span.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// UntypedFormatSpec
-//
-// A type-erased class that can be used directly within untyped API entry
-// points. An `UntypedFormatSpec` is specifically used as an argument to
-// `FormatUntyped()`.
-//
-// Example:
-//
-//   absl::UntypedFormatSpec format("%d");
-//   std::string out;
-//   CHECK(absl::FormatUntyped(&out, format, {absl::FormatArg(1)}));
-class UntypedFormatSpec {
-public:
-  UntypedFormatSpec() = delete;
-  UntypedFormatSpec(const UntypedFormatSpec &) = delete;
-  UntypedFormatSpec &operator=(const UntypedFormatSpec &) = delete;
-
-  explicit UntypedFormatSpec(string_view s) : spec_(s) {}
-
-protected:
-  explicit UntypedFormatSpec(
-      absl::Nonnull<const str_format_internal::ParsedFormatBase *> pc)
-      : spec_(pc) {}
-
-private:
-  friend str_format_internal::UntypedFormatSpecImpl;
-  str_format_internal::UntypedFormatSpecImpl spec_;
-};
-
-// FormatStreamed()
-//
-// Takes a streamable argument and returns an object that can print it
-// with '%s'. Allows printing of types that have an `operator<<` but no
-// intrinsic type support within `StrFormat()` itself.
-//
-// Example:
-//
-//   absl::StrFormat("%s", absl::FormatStreamed(obj));
-template <typename T>
-str_format_internal::StreamedWrapper<T> FormatStreamed(const T &v) {
-  return str_format_internal::StreamedWrapper<T>(v);
-}
-
-// FormatCountCapture
-//
-// This class provides a way to safely wrap `StrFormat()` captures of `%n`
-// conversions, which denote the number of characters written by a formatting
-// operation to this point, into an integer value.
-//
-// This wrapper is designed to allow safe usage of `%n` within `StrFormat(); in
-// the `printf()` family of functions, `%n` is not safe to use, as the `int *`
-// buffer can be used to capture arbitrary data.
-//
-// Example:
-//
-//   int n = 0;
-//   std::string s = absl::StrFormat("%s%d%n", "hello", 123,
-//                       absl::FormatCountCapture(&n));
-//   EXPECT_EQ(8, n);
-class FormatCountCapture {
-public:
-  explicit FormatCountCapture(absl::Nonnull<int *> p) : p_(p) {}
-
-private:
-  // FormatCountCaptureHelper is used to define FormatConvertImpl() for this
-  // class.
-  friend struct str_format_internal::FormatCountCaptureHelper;
-  // Unused() is here because of the false positive from -Wunused-private-field
-  // p_ is used in the templated function of the friend FormatCountCaptureHelper
-  // class.
-  absl::Nonnull<int *> Unused() { return p_; }
-  absl::Nonnull<int *> p_;
-};
-
-// FormatSpec
-//
-// The `FormatSpec` type defines the makeup of a format string within the
-// `str_format` library. It is a variadic class template that is evaluated at
-// compile-time, according to the format string and arguments that are passed to
-// it.
-//
-// You should not need to manipulate this type directly. You should only name it
-// if you are writing wrapper functions which accept format arguments that will
-// be provided unmodified to functions in this library. Such a wrapper function
-// might be a class method that provides format arguments and/or internally uses
-// the result of formatting.
-//
-// For a `FormatSpec` to be valid at compile-time, it must be provided as
-// either:
-//
-// * A `constexpr` literal or `absl::string_view`, which is how it is most often
-//   used.
-// * A `ParsedFormat` instantiation, which ensures the format string is
-//   valid before use. (See below.)
-//
-// Example:
-//
-//   // Provided as a string literal.
-//   absl::StrFormat("Welcome to %s, Number %d!", "The Village", 6);
-//
-//   // Provided as a constexpr absl::string_view.
-//   constexpr absl::string_view formatString = "Welcome to %s, Number %d!";
-//   absl::StrFormat(formatString, "The Village", 6);
-//
-//   // Provided as a pre-compiled ParsedFormat object.
-//   // Note that this example is useful only for illustration purposes.
-//   absl::ParsedFormat<'s', 'd'> formatString("Welcome to %s, Number %d!");
-//   absl::StrFormat(formatString, "TheVillage", 6);
-//
-// A format string generally follows the POSIX syntax as used within the POSIX
-// `printf` specification. (Exceptions are noted below.)
-//
-// (See http://pubs.opengroup.org/onlinepubs/9699919799/functions/fprintf.html)
-//
-// In specific, the `FormatSpec` supports the following type specifiers:
-//   * `c` for characters
-//   * `s` for strings
-//   * `d` or `i` for integers
-//   * `o` for unsigned integer conversions into octal
-//   * `x` or `X` for unsigned integer conversions into hex
-//   * `u` for unsigned integers
-//   * `f` or `F` for floating point values into decimal notation
-//   * `e` or `E` for floating point values into exponential notation
-//   * `a` or `A` for floating point values into hex exponential notation
-//   * `g` or `G` for floating point values into decimal or exponential
-//     notation based on their precision
-//   * `p` for pointer address values
-//   * `n` for the special case of writing out the number of characters
-//     written to this point. The resulting value must be captured within an
-//     `absl::FormatCountCapture` type.
-//   * `v` for values using the default format for a deduced type. These deduced
-//     types include many of the primitive types denoted here as well as
-//     user-defined types containing the proper extensions. (See below for more
-//     information.)
-//
-// Implementation-defined behavior:
-//   * A null pointer provided to "%s" or "%p" is output as "(nil)".
-//   * A non-null pointer provided to "%p" is output in hex as if by %#x or
-//     %#lx.
-//
-// NOTE: `o`, `x\X` and `u` will convert signed values to their unsigned
-// counterpart before formatting.
-//
-// Examples:
-//     "%c", 'a'                -> "a"
-//     "%c", 32                 -> " "
-//     "%s", "C"                -> "C"
-//     "%s", std::string("C++") -> "C++"
-//     "%d", -10                -> "-10"
-//     "%o", 10                 -> "12"
-//     "%x", 16                 -> "10"
-//     "%f", 123456789          -> "123456789.000000"
-//     "%e", .01                -> "1.00000e-2"
-//     "%a", -3.0               -> "-0x1.8p+1"
-//     "%g", .01                -> "1e-2"
-//     "%p", (void*)&value      -> "0x7ffdeb6ad2a4"
-//
-//     int n = 0;
-//     std::string s = absl::StrFormat(
-//         "%s%d%n", "hello", 123, absl::FormatCountCapture(&n));
-//     EXPECT_EQ(8, n);
-//
-// NOTE: the `v` specifier (for "value") is a type specifier not present in the
-// POSIX specification. %v will format values according to their deduced type.
-// `v` uses `d` for signed integer values, `u` for unsigned integer values, `g`
-// for floating point values, and formats boolean values as "true"/"false"
-// (instead of 1 or 0 for booleans formatted using d). `const char*` is not
-// supported; please use `std::string` and `string_view`. `char` is also not
-// supported due to ambiguity of the type. This specifier does not support
-// modifiers.
-//
-// The `FormatSpec` intrinsically supports all of these fundamental C++ types:
-//
-// *   Characters: `char`, `signed char`, `unsigned char`, `wchar_t`
-// *   Integers: `int`, `short`, `unsigned short`, `unsigned`, `long`,
-//         `unsigned long`, `long long`, `unsigned long long`
-// *   Enums: printed as their underlying integral value
-// *   Floating-point: `float`, `double`, `long double`
-//
-// However, in the `str_format` library, a format conversion specifies a broader
-// C++ conceptual category instead of an exact type. For example, `%s` binds to
-// any string-like argument, so `std::string`, `std::wstring`,
-// `absl::string_view`, `const char*`, and `const wchar_t*` are all accepted.
-// Likewise, `%d` accepts any integer-like argument, etc.
-
-template <typename... Args>
-using FormatSpec = str_format_internal::FormatSpecTemplate<
-    str_format_internal::ArgumentToConv<Args>()...>;
-
-// ParsedFormat
-//
-// A `ParsedFormat` is a class template representing a preparsed `FormatSpec`,
-// with template arguments specifying the conversion characters used within the
-// format string. Such characters must be valid format type specifiers, and
-// these type specifiers are checked at compile-time.
-//
-// Instances of `ParsedFormat` can be created, copied, and reused to speed up
-// formatting loops. A `ParsedFormat` may either be constructed statically, or
-// dynamically through its `New()` factory function, which only constructs a
-// runtime object if the format is valid at that time.
-//
-// Example:
-//
-//   // Verified at compile time.
-//   absl::ParsedFormat<'s', 'd'> format_string("Welcome to %s, Number %d!");
-//   absl::StrFormat(format_string, "TheVillage", 6);
-//
-//   // Verified at runtime.
-//   auto format_runtime = absl::ParsedFormat<'d'>::New(format_string);
-//   if (format_runtime) {
-//     value = absl::StrFormat(*format_runtime, i);
-//   } else {
-//     ... error case ...
-//   }
-
-#if defined(__cpp_nontype_template_parameter_auto)
-// If C++17 is available, an 'extended' format is also allowed that can specify
-// multiple conversion characters per format argument, using a combination of
-// `absl::FormatConversionCharSet` enum values (logically a set union)
-//  via the `|` operator. (Single character-based arguments are still accepted,
-// but cannot be combined). Some common conversions also have predefined enum
-// values, such as `absl::FormatConversionCharSet::kIntegral`.
-//
-// Example:
-//   // Extended format supports multiple conversion characters per argument,
-//   // specified via a combination of `FormatConversionCharSet` enums.
-//   using MyFormat = absl::ParsedFormat<absl::FormatConversionCharSet::d |
-//                                       absl::FormatConversionCharSet::x>;
-//   MyFormat GetFormat(bool use_hex) {
-//     if (use_hex) return MyFormat("foo %x bar");
-//     return MyFormat("foo %d bar");
-//   }
-//   // `format` can be used with any value that supports 'd' and 'x',
-//   // like `int`.
-//   auto format = GetFormat(use_hex);
-//   value = StringF(format, i);
-template <auto... Conv>
-using ParsedFormat = absl::str_format_internal::ExtendedParsedFormat<
-    absl::str_format_internal::ToFormatConversionCharSet(Conv)...>;
-#else
-template <char... Conv>
-using ParsedFormat = str_format_internal::ExtendedParsedFormat<
-    absl::str_format_internal::ToFormatConversionCharSet(Conv)...>;
-#endif // defined(__cpp_nontype_template_parameter_auto)
-
-// StrFormat()
-//
-// Returns a `string` given a `printf()`-style format string and zero or more
-// additional arguments. Use it as you would `sprintf()`. `StrFormat()` is the
-// primary formatting function within the `str_format` library, and should be
-// used in most cases where you need type-safe conversion of types into
-// formatted strings.
-//
-// The format string generally consists of ordinary character data along with
-// one or more format conversion specifiers (denoted by the `%` character).
-// Ordinary character data is returned unchanged into the result string, while
-// each conversion specification performs a type substitution from
-// `StrFormat()`'s other arguments. See the comments for `FormatSpec` for full
-// information on the makeup of this format string.
-//
-// Example:
-//
-//   std::string s = absl::StrFormat(
-//       "Welcome to %s, Number %d!", "The Village", 6);
-//   EXPECT_EQ("Welcome to The Village, Number 6!", s);
-//
-// Returns an empty string in case of error.
-template <typename... Args>
-ABSL_MUST_USE_RESULT std::string StrFormat(const FormatSpec<Args...> &format,
-                                           const Args &...args) {
-  return str_format_internal::FormatPack(
-      str_format_internal::UntypedFormatSpecImpl::Extract(format),
-      {str_format_internal::FormatArgImpl(args)...});
-}
-
-// StrAppendFormat()
-//
-// Appends to a `dst` string given a format string, and zero or more additional
-// arguments, returning `*dst` as a convenience for chaining purposes. Appends
-// nothing in case of error (but possibly alters its capacity).
-//
-// Example:
-//
-//   std::string orig("For example PI is approximately ");
-//   std::cout << StrAppendFormat(&orig, "%12.6f", 3.14);
-template <typename... Args>
-std::string &StrAppendFormat(absl::Nonnull<std::string *> dst,
-                             const FormatSpec<Args...> &format,
-                             const Args &...args) {
-  return str_format_internal::AppendPack(
-      dst, str_format_internal::UntypedFormatSpecImpl::Extract(format),
-      {str_format_internal::FormatArgImpl(args)...});
-}
-
-// StreamFormat()
-//
-// Writes to an output stream given a format string and zero or more arguments,
-// generally in a manner that is more efficient than streaming the result of
-// `absl::StrFormat()`. The returned object must be streamed before the full
-// expression ends.
-//
-// Example:
-//
-//   std::cout << StreamFormat("%12.6f", 3.14);
-template <typename... Args>
-ABSL_MUST_USE_RESULT str_format_internal::Streamable
-StreamFormat(const FormatSpec<Args...> &format, const Args &...args) {
-  return str_format_internal::Streamable(
-      str_format_internal::UntypedFormatSpecImpl::Extract(format),
-      {str_format_internal::FormatArgImpl(args)...});
-}
-
-// PrintF()
-//
-// Writes to stdout given a format string and zero or more arguments. This
-// function is functionally equivalent to `std::printf()` (and type-safe);
-// prefer `absl::PrintF()` over `std::printf()`.
-//
-// Example:
-//
-//   std::string_view s = "Ulaanbaatar";
-//   absl::PrintF("The capital of Mongolia is %s", s);
-//
-//   Outputs: "The capital of Mongolia is Ulaanbaatar"
-//
-template <typename... Args>
-int PrintF(const FormatSpec<Args...> &format, const Args &...args) {
-  return str_format_internal::FprintF(
-      stdout, str_format_internal::UntypedFormatSpecImpl::Extract(format),
-      {str_format_internal::FormatArgImpl(args)...});
-}
-
-// FPrintF()
-//
-// Writes to a file given a format string and zero or more arguments. This
-// function is functionally equivalent to `std::fprintf()` (and type-safe);
-// prefer `absl::FPrintF()` over `std::fprintf()`.
-//
-// Example:
-//
-//   std::string_view s = "Ulaanbaatar";
-//   absl::FPrintF(stdout, "The capital of Mongolia is %s", s);
-//
-//   Outputs: "The capital of Mongolia is Ulaanbaatar"
-//
-template <typename... Args>
-int FPrintF(absl::Nonnull<std::FILE *> output,
-            const FormatSpec<Args...> &format, const Args &...args) {
-  return str_format_internal::FprintF(
-      output, str_format_internal::UntypedFormatSpecImpl::Extract(format),
-      {str_format_internal::FormatArgImpl(args)...});
-}
-
-// SNPrintF()
-//
-// Writes to a sized buffer given a format string and zero or more arguments.
-// This function is functionally equivalent to `std::snprintf()` (and
-// type-safe); prefer `absl::SNPrintF()` over `std::snprintf()`.
-//
-// In particular, a successful call to `absl::SNPrintF()` writes at most `size`
-// bytes of the formatted output to `output`, including a NUL-terminator, and
-// returns the number of bytes that would have been written if truncation did
-// not occur. In the event of an error, a negative value is returned and `errno`
-// is set.
-//
-// Example:
-//
-//   std::string_view s = "Ulaanbaatar";
-//   char output[128];
-//   absl::SNPrintF(output, sizeof(output),
-//                  "The capital of Mongolia is %s", s);
-//
-//   Post-condition: output == "The capital of Mongolia is Ulaanbaatar"
-//
-template <typename... Args>
-int SNPrintF(absl::Nonnull<char *> output, std::size_t size,
-             const FormatSpec<Args...> &format, const Args &...args) {
-  return str_format_internal::SnprintF(
-      output, size, str_format_internal::UntypedFormatSpecImpl::Extract(format),
-      {str_format_internal::FormatArgImpl(args)...});
-}
-
-// -----------------------------------------------------------------------------
-// Custom Output Formatting Functions
-// -----------------------------------------------------------------------------
-
-// FormatRawSink
-//
-// FormatRawSink is a type erased wrapper around arbitrary sink objects
-// specifically used as an argument to `Format()`.
-//
-// All the object has to do define an overload of `AbslFormatFlush()` for the
-// sink, usually by adding a ADL-based free function in the same namespace as
-// the sink:
-//
-//   void AbslFormatFlush(MySink* dest, absl::string_view part);
-//
-// where `dest` is the pointer passed to `absl::Format()`. The function should
-// append `part` to `dest`.
-//
-// FormatRawSink does not own the passed sink object. The passed object must
-// outlive the FormatRawSink.
-class FormatRawSink {
-public:
-  // Implicitly convert from any type that provides the hook function as
-  // described above.
-  template <typename T,
-            typename = typename std::enable_if<std::is_constructible<
-                str_format_internal::FormatRawSinkImpl, T *>::value>::type>
-  FormatRawSink(absl::Nonnull<T *> raw) // NOLINT
-      : sink_(raw) {}
-
-private:
-  friend str_format_internal::FormatRawSinkImpl;
-  str_format_internal::FormatRawSinkImpl sink_;
-};
-
-// Format()
-//
-// Writes a formatted string to an arbitrary sink object (implementing the
-// `absl::FormatRawSink` interface), using a format string and zero or more
-// additional arguments.
-//
-// By default, `std::string`, `std::ostream`, and `absl::Cord` are supported as
-// destination objects. If a `std::string` is used the formatted string is
-// appended to it.
-//
-// `absl::Format()` is a generic version of `absl::StrAppendFormat()`, for
-// custom sinks. The format string, like format strings for `StrFormat()`, is
-// checked at compile-time.
-//
-// On failure, this function returns `false` and the state of the sink is
-// unspecified.
-template <typename... Args>
-bool Format(FormatRawSink raw_sink, const FormatSpec<Args...> &format,
-            const Args &...args) {
-  return str_format_internal::FormatUntyped(
-      str_format_internal::FormatRawSinkImpl::Extract(raw_sink),
-      str_format_internal::UntypedFormatSpecImpl::Extract(format),
-      {str_format_internal::FormatArgImpl(args)...});
-}
-
-// FormatArg
-//
-// A type-erased handle to a format argument specifically used as an argument to
-// `FormatUntyped()`. You may construct `FormatArg` by passing
-// reference-to-const of any printable type. `FormatArg` is both copyable and
-// assignable. The source data must outlive the `FormatArg` instance. See
-// example below.
-//
-using FormatArg = str_format_internal::FormatArgImpl;
-
-// FormatUntyped()
-//
-// Writes a formatted string to an arbitrary sink object (implementing the
-// `absl::FormatRawSink` interface), using an `UntypedFormatSpec` and zero or
-// more additional arguments.
-//
-// This function acts as the most generic formatting function in the
-// `str_format` library. The caller provides a raw sink, an unchecked format
-// string, and (usually) a runtime specified list of arguments; no compile-time
-// checking of formatting is performed within this function. As a result, a
-// caller should check the return value to verify that no error occurred.
-// On failure, this function returns `false` and the state of the sink is
-// unspecified.
-//
-// The arguments are provided in an `absl::Span<const absl::FormatArg>`.
-// Each `absl::FormatArg` object binds to a single argument and keeps a
-// reference to it. The values used to create the `FormatArg` objects must
-// outlive this function call.
-//
-// Example:
-//
-//   std::optional<std::string> FormatDynamic(
-//       const std::string& in_format,
-//       const vector<std::string>& in_args) {
-//     std::string out;
-//     std::vector<absl::FormatArg> args;
-//     for (const auto& v : in_args) {
-//       // It is important that 'v' is a reference to the objects in in_args.
-//       // The values we pass to FormatArg must outlive the call to
-//       // FormatUntyped.
-//       args.emplace_back(v);
-//     }
-//     absl::UntypedFormatSpec format(in_format);
-//     if (!absl::FormatUntyped(&out, format, args)) {
-//       return std::nullopt;
-//     }
-//     return std::move(out);
-//   }
-//
-ABSL_MUST_USE_RESULT inline bool
-FormatUntyped(FormatRawSink raw_sink, const UntypedFormatSpec &format,
-              absl::Span<const FormatArg> args) {
-  return str_format_internal::FormatUntyped(
-      str_format_internal::FormatRawSinkImpl::Extract(raw_sink),
-      str_format_internal::UntypedFormatSpecImpl::Extract(format), args);
-}
-
-//------------------------------------------------------------------------------
-// StrFormat Extensions
-//------------------------------------------------------------------------------
-//
-// AbslStringify()
-//
-// A simpler customization API for formatting user-defined types using
-// absl::StrFormat(). The API relies on detecting an overload in the
-// user-defined type's namespace of a free (non-member) `AbslStringify()`
-// function as a friend definition with the following signature:
-//
-// template <typename Sink>
-// void AbslStringify(Sink& sink, const X& value);
-//
-// An `AbslStringify()` overload for a type should only be declared in the same
-// file and namespace as said type.
-//
-// Note that unlike with AbslFormatConvert(), AbslStringify() does not allow
-// customization of allowed conversion characters. AbslStringify() uses `%v` as
-// the underlying conversion specififer. Additionally, AbslStringify() supports
-// use with absl::StrCat while AbslFormatConvert() does not.
-//
-// Example:
-//
-// struct Point {
-//   // To add formatting support to `Point`, we simply need to add a free
-//   // (non-member) function `AbslStringify()`. This method prints in the
-//   // request format using the underlying `%v` specifier. You can add such a
-//   // free function using a friend declaration within the body of the class.
-//   // The sink parameter is a templated type to avoid requiring dependencies.
-//   template <typename Sink>
-//   friend void AbslStringify(Sink& sink, const Point& p) {
-//     absl::Format(&sink, "(%v, %v)", p.x, p.y);
-//   }
-//
-//   int x;
-//   int y;
-// };
-//
-// AbslFormatConvert()
-//
-// The StrFormat library provides a customization API for formatting
-// user-defined types using absl::StrFormat(). The API relies on detecting an
-// overload in the user-defined type's namespace of a free (non-member)
-// `AbslFormatConvert()` function, usually as a friend definition with the
-// following signature:
-//
-// absl::FormatConvertResult<...> AbslFormatConvert(
-//     const X& value,
-//     const absl::FormatConversionSpec& spec,
-//     absl::FormatSink *sink);
-//
-// An `AbslFormatConvert()` overload for a type should only be declared in the
-// same file and namespace as said type.
-//
-// The abstractions within this definition include:
-//
-// * An `absl::FormatConversionSpec` to specify the fields to pull from a
-//   user-defined type's format string
-// * An `absl::FormatSink` to hold the converted string data during the
-//   conversion process.
-// * An `absl::FormatConvertResult` to hold the status of the returned
-//   formatting operation
-//
-// The return type encodes all the conversion characters that your
-// AbslFormatConvert() routine accepts.  The return value should be {true}.
-// A return value of {false} will result in `StrFormat()` returning
-// an empty string.  This result will be propagated to the result of
-// `FormatUntyped`.
-//
-// Example:
-//
-// struct Point {
-//   // To add formatting support to `Point`, we simply need to add a free
-//   // (non-member) function `AbslFormatConvert()`.  This method interprets
-//   // `spec` to print in the request format. The allowed conversion characters
-//   // can be restricted via the type of the result, in this example
-//   // string and integral formatting are allowed (but not, for instance
-//   // floating point characters like "%f").  You can add such a free function
-//   // using a friend declaration within the body of the class:
-//   friend absl::FormatConvertResult<absl::FormatConversionCharSet::kString |
-//                                    absl::FormatConversionCharSet::kIntegral>
-//   AbslFormatConvert(const Point& p, const absl::FormatConversionSpec& spec,
-//                     absl::FormatSink* s) {
-//     if (spec.conversion_char() == absl::FormatConversionChar::s) {
-//       absl::Format(s, "x=%vy=%v", p.x, p.y);
-//     } else {
-//       absl::Format(s, "%v,%v", p.x, p.y);
-//     }
-//     return {true};
-//   }
-//
-//   int x;
-//   int y;
-// };
-
-// clang-format off
-
-// FormatConversionChar
-//
-// Specifies the formatting character provided in the format string
-// passed to `StrFormat()`.
-enum class FormatConversionChar : uint8_t {
-  c, s,                    // text
-  d, i, o, u, x, X,        // int
-  f, F, e, E, g, G, a, A,  // float
-  n, p, v                  // misc
-};
-// clang-format on
-
-// FormatConversionSpec
-//
-// Specifies modifications to the conversion of the format string, through use
-// of one or more format flags in the source format string.
-class FormatConversionSpec {
-public:
-  // FormatConversionSpec::is_basic()
-  //
-  // Indicates that width and precision are not specified, and no additional
-  // flags are set for this conversion character in the format string.
-  bool is_basic() const { return impl_.is_basic(); }
-
-  // FormatConversionSpec::has_left_flag()
-  //
-  // Indicates whether the result should be left justified for this conversion
-  // character in the format string. This flag is set through use of a '-'
-  // character in the format string. E.g. "%-s"
-  bool has_left_flag() const { return impl_.has_left_flag(); }
-
-  // FormatConversionSpec::has_show_pos_flag()
-  //
-  // Indicates whether a sign column is prepended to the result for this
-  // conversion character in the format string, even if the result is positive.
-  // This flag is set through use of a '+' character in the format string.
-  // E.g. "%+d"
-  bool has_show_pos_flag() const { return impl_.has_show_pos_flag(); }
-
-  // FormatConversionSpec::has_sign_col_flag()
-  //
-  // Indicates whether a mandatory sign column is added to the result for this
-  // conversion character. This flag is set through use of a space character
-  // (' ') in the format string. E.g. "% i"
-  bool has_sign_col_flag() const { return impl_.has_sign_col_flag(); }
-
-  // FormatConversionSpec::has_alt_flag()
-  //
-  // Indicates whether an "alternate" format is applied to the result for this
-  // conversion character. Alternative forms depend on the type of conversion
-  // character, and unallowed alternatives are undefined. This flag is set
-  // through use of a '#' character in the format string. E.g. "%#h"
-  bool has_alt_flag() const { return impl_.has_alt_flag(); }
-
-  // FormatConversionSpec::has_zero_flag()
-  //
-  // Indicates whether zeroes should be prepended to the result for this
-  // conversion character instead of spaces. This flag is set through use of the
-  // '0' character in the format string. E.g. "%0f"
-  bool has_zero_flag() const { return impl_.has_zero_flag(); }
-
-  // FormatConversionSpec::conversion_char()
-  //
-  // Returns the underlying conversion character.
-  FormatConversionChar conversion_char() const {
-    return impl_.conversion_char();
-  }
-
-  // FormatConversionSpec::width()
-  //
-  // Returns the specified width (indicated through use of a non-zero integer
-  // value or '*' character) of the conversion character. If width is
-  // unspecified, it returns a negative value.
-  int width() const { return impl_.width(); }
-
-  // FormatConversionSpec::precision()
-  //
-  // Returns the specified precision (through use of the '.' character followed
-  // by a non-zero integer value or '*' character) of the conversion character.
-  // If precision is unspecified, it returns a negative value.
-  int precision() const { return impl_.precision(); }
-
-private:
-  explicit FormatConversionSpec(
-      str_format_internal::FormatConversionSpecImpl impl)
-      : impl_(impl) {}
-
-  friend str_format_internal::FormatConversionSpecImpl;
-
-  absl::str_format_internal::FormatConversionSpecImpl impl_;
-};
-
-// Type safe OR operator for FormatConversionCharSet to allow accepting multiple
-// conversion chars in custom format converters.
-constexpr FormatConversionCharSet operator|(FormatConversionCharSet a,
-                                            FormatConversionCharSet b) {
-  return static_cast<FormatConversionCharSet>(static_cast<uint64_t>(a) |
-                                              static_cast<uint64_t>(b));
-}
-
-// FormatConversionCharSet
-//
-// Specifies the _accepted_ conversion types as a template parameter to
-// FormatConvertResult for custom implementations of `AbslFormatConvert`.
-// Note the helper predefined alias definitions (kIntegral, etc.) below.
-enum class FormatConversionCharSet : uint64_t {
-  // text
-  c = str_format_internal::FormatConversionCharToConvInt('c'),
-  s = str_format_internal::FormatConversionCharToConvInt('s'),
-  // integer
-  d = str_format_internal::FormatConversionCharToConvInt('d'),
-  i = str_format_internal::FormatConversionCharToConvInt('i'),
-  o = str_format_internal::FormatConversionCharToConvInt('o'),
-  u = str_format_internal::FormatConversionCharToConvInt('u'),
-  x = str_format_internal::FormatConversionCharToConvInt('x'),
-  X = str_format_internal::FormatConversionCharToConvInt('X'),
-  // Float
-  f = str_format_internal::FormatConversionCharToConvInt('f'),
-  F = str_format_internal::FormatConversionCharToConvInt('F'),
-  e = str_format_internal::FormatConversionCharToConvInt('e'),
-  E = str_format_internal::FormatConversionCharToConvInt('E'),
-  g = str_format_internal::FormatConversionCharToConvInt('g'),
-  G = str_format_internal::FormatConversionCharToConvInt('G'),
-  a = str_format_internal::FormatConversionCharToConvInt('a'),
-  A = str_format_internal::FormatConversionCharToConvInt('A'),
-  // misc
-  n = str_format_internal::FormatConversionCharToConvInt('n'),
-  p = str_format_internal::FormatConversionCharToConvInt('p'),
-  v = str_format_internal::FormatConversionCharToConvInt('v'),
-
-  // Used for width/precision '*' specification.
-  kStar = static_cast<uint64_t>(
-      absl::str_format_internal::FormatConversionCharSetInternal::kStar),
-  // Some predefined values:
-  kIntegral = d | i | u | o | x | X,
-  kFloating = a | e | f | g | A | E | F | G,
-  kNumeric = kIntegral | kFloating,
-  kString = s,
-  kPointer = p,
-};
-
-// FormatSink
-//
-// A format sink is a generic abstraction to which conversions may write their
-// formatted string data. `absl::FormatConvert()` uses this sink to write its
-// formatted string.
-//
-class FormatSink {
-public:
-  // FormatSink::Append()
-  //
-  // Appends `count` copies of `ch` to the format sink.
-  void Append(size_t count, char ch) { sink_->Append(count, ch); }
-
-  // Overload of FormatSink::Append() for appending the characters of a string
-  // view to a format sink.
-  void Append(string_view v) { sink_->Append(v); }
-
-  // FormatSink::PutPaddedString()
-  //
-  // Appends `precision` number of bytes of `v` to the format sink. If this is
-  // less than `width`, spaces will be appended first (if `left` is false), or
-  // after (if `left` is true) to ensure the total amount appended is
-  // at least `width`.
-  bool PutPaddedString(string_view v, int width, int precision, bool left) {
-    return sink_->PutPaddedString(v, width, precision, left);
-  }
-
-  // Support `absl::Format(&sink, format, args...)`.
-  friend void AbslFormatFlush(absl::Nonnull<FormatSink *> sink,
-                              absl::string_view v) {
-    sink->Append(v);
-  }
-
-private:
-  friend str_format_internal::FormatSinkImpl;
-  explicit FormatSink(absl::Nonnull<str_format_internal::FormatSinkImpl *> s)
-      : sink_(s) {}
-  absl::Nonnull<str_format_internal::FormatSinkImpl *> sink_;
-};
-
-// FormatConvertResult
-//
-// Indicates whether a call to AbslFormatConvert() was successful.
-// This return type informs the StrFormat extension framework (through
-// ADL but using the return type) of what conversion characters are supported.
-// It is strongly discouraged to return {false}, as this will result in an
-// empty string in StrFormat.
-template <FormatConversionCharSet C> struct FormatConvertResult {
-  bool value;
-};
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_STR_FORMAT_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/str_join.h b/packages/react-native-executorch/third-party/include/absl/strings/str_join.h
deleted file mode 100644
index b84aa509c0..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/str_join.h
+++ /dev/null
@@ -1,301 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: str_join.h
-// -----------------------------------------------------------------------------
-//
-// This header file contains functions for joining a range of elements and
-// returning the result as a std::string. StrJoin operations are specified by
-// passing a range, a separator string to use between the elements joined, and
-// an optional Formatter responsible for converting each argument in the range
-// to a string. If omitted, a default `AlphaNumFormatter()` is called on the
-// elements to be joined, using the same formatting that `absl::StrCat()` uses.
-// This package defines a number of default formatters, and you can define your
-// own implementations.
-//
-// Ranges are specified by passing a container with `std::begin()` and
-// `std::end()` iterators, container-specific `begin()` and `end()` iterators, a
-// brace-initialized `std::initializer_list`, or a `std::tuple` of heterogeneous
-// objects. The separator string is specified as an `absl::string_view`.
-//
-// Because the default formatter uses the `absl::AlphaNum` class,
-// `absl::StrJoin()`, like `absl::StrCat()`, will work out-of-the-box on
-// collections of strings, ints, floats, doubles, etc.
-//
-// Example:
-//
-//   std::vector<std::string> v = {"foo", "bar", "baz"};
-//   std::string s = absl::StrJoin(v, "-");
-//   EXPECT_EQ("foo-bar-baz", s);
-//
-// See comments on the `absl::StrJoin()` function for more examples.
-
-#ifndef ABSL_STRINGS_STR_JOIN_H_
-#define ABSL_STRINGS_STR_JOIN_H_
-
-#include <cstdio>
-#include <cstring>
-#include <initializer_list>
-#include <iterator>
-#include <string>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
-#include "absl/base/macros.h"
-#include "absl/strings/internal/str_join_internal.h"
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// -----------------------------------------------------------------------------
-// Concept: Formatter
-// -----------------------------------------------------------------------------
-//
-// A Formatter is a function object that is responsible for formatting its
-// argument as a string and appending it to a given output std::string.
-// Formatters may be implemented as function objects, lambdas, or normal
-// functions. You may provide your own Formatter to enable `absl::StrJoin()` to
-// work with arbitrary types.
-//
-// The following is an example of a custom Formatter that uses
-// `absl::FormatDuration` to join a list of `absl::Duration`s.
-//
-//   std::vector<absl::Duration> v = {absl::Seconds(1), absl::Milliseconds(10)};
-//   std::string s =
-//       absl::StrJoin(v, ", ", [](std::string* out, absl::Duration dur) {
-//         absl::StrAppend(out, absl::FormatDuration(dur));
-//       });
-//   EXPECT_EQ(s, "1s, 10ms");
-//
-// The following standard formatters are provided within this file:
-//
-// - `AlphaNumFormatter()` (the default)
-// - `StreamFormatter()`
-// - `PairFormatter()`
-// - `DereferenceFormatter()`
-
-// AlphaNumFormatter()
-//
-// Default formatter used if none is specified. Uses `absl::AlphaNum` to convert
-// numeric arguments to strings.
-inline strings_internal::AlphaNumFormatterImpl AlphaNumFormatter() {
-  return strings_internal::AlphaNumFormatterImpl();
-}
-
-// StreamFormatter()
-//
-// Formats its argument using the << operator.
-inline strings_internal::StreamFormatterImpl StreamFormatter() {
-  return strings_internal::StreamFormatterImpl();
-}
-
-// Function Template: PairFormatter(Formatter, absl::string_view, Formatter)
-//
-// Formats a `std::pair` by putting a given separator between the pair's
-// `.first` and `.second` members. This formatter allows you to specify
-// custom Formatters for both the first and second member of each pair.
-template <typename FirstFormatter, typename SecondFormatter>
-inline strings_internal::PairFormatterImpl<FirstFormatter, SecondFormatter>
-PairFormatter(FirstFormatter f1, absl::string_view sep, SecondFormatter f2) {
-  return strings_internal::PairFormatterImpl<FirstFormatter, SecondFormatter>(
-      std::move(f1), sep, std::move(f2));
-}
-
-// Function overload of PairFormatter() for using a default
-// `AlphaNumFormatter()` for each Formatter in the pair.
-inline strings_internal::PairFormatterImpl<
-    strings_internal::AlphaNumFormatterImpl,
-    strings_internal::AlphaNumFormatterImpl>
-PairFormatter(absl::string_view sep) {
-  return PairFormatter(AlphaNumFormatter(), sep, AlphaNumFormatter());
-}
-
-// Function Template: DereferenceFormatter(Formatter)
-//
-// Formats its argument by dereferencing it and then applying the given
-// formatter. This formatter is useful for formatting a container of
-// pointer-to-T. This pattern often shows up when joining repeated fields in
-// protocol buffers.
-template <typename Formatter>
-strings_internal::DereferenceFormatterImpl<Formatter>
-DereferenceFormatter(Formatter &&f) {
-  return strings_internal::DereferenceFormatterImpl<Formatter>(
-      std::forward<Formatter>(f));
-}
-
-// Function overload of `DereferenceFormatter()` for using a default
-// `AlphaNumFormatter()`.
-inline strings_internal::DereferenceFormatterImpl<
-    strings_internal::AlphaNumFormatterImpl>
-DereferenceFormatter() {
-  return strings_internal::DereferenceFormatterImpl<
-      strings_internal::AlphaNumFormatterImpl>(AlphaNumFormatter());
-}
-
-// -----------------------------------------------------------------------------
-// StrJoin()
-// -----------------------------------------------------------------------------
-//
-// Joins a range of elements and returns the result as a std::string.
-// `absl::StrJoin()` takes a range, a separator string to use between the
-// elements joined, and an optional Formatter responsible for converting each
-// argument in the range to a string.
-//
-// If omitted, the default `AlphaNumFormatter()` is called on the elements to be
-// joined.
-//
-// Example 1:
-//   // Joins a collection of strings. This pattern also works with a collection
-//   // of `absl::string_view` or even `const char*`.
-//   std::vector<std::string> v = {"foo", "bar", "baz"};
-//   std::string s = absl::StrJoin(v, "-");
-//   EXPECT_EQ(s, "foo-bar-baz");
-//
-// Example 2:
-//   // Joins the values in the given `std::initializer_list<>` specified using
-//   // brace initialization. This pattern also works with an initializer_list
-//   // of ints or `absl::string_view` -- any `AlphaNum`-compatible type.
-//   std::string s = absl::StrJoin({"foo", "bar", "baz"}, "-");
-//   EXPECT_EQs, "foo-bar-baz");
-//
-// Example 3:
-//   // Joins a collection of ints. This pattern also works with floats,
-//   // doubles, int64s -- any `StrCat()`-compatible type.
-//   std::vector<int> v = {1, 2, 3, -4};
-//   std::string s = absl::StrJoin(v, "-");
-//   EXPECT_EQ(s, "1-2-3--4");
-//
-// Example 4:
-//   // Joins a collection of pointer-to-int. By default, pointers are
-//   // dereferenced and the pointee is formatted using the default format for
-//   // that type; such dereferencing occurs for all levels of indirection, so
-//   // this pattern works just as well for `std::vector<int**>` as for
-//   // `std::vector<int*>`.
-//   int x = 1, y = 2, z = 3;
-//   std::vector<int*> v = {&x, &y, &z};
-//   std::string s = absl::StrJoin(v, "-");
-//   EXPECT_EQ(s, "1-2-3");
-//
-// Example 5:
-//   // Dereferencing of `std::unique_ptr<>` is also supported:
-//   std::vector<std::unique_ptr<int>> v
-//   v.emplace_back(new int(1));
-//   v.emplace_back(new int(2));
-//   v.emplace_back(new int(3));
-//   std::string s = absl::StrJoin(v, "-");
-//   EXPECT_EQ(s, "1-2-3");
-//
-// Example 6:
-//   // Joins a `std::map`, with each key-value pair separated by an equals
-//   // sign. This pattern would also work with, say, a
-//   // `std::vector<std::pair<>>`.
-//   std::map<std::string, int> m = {
-//       {"a", 1},
-//       {"b", 2},
-//       {"c", 3}};
-//   std::string s = absl::StrJoin(m, ",", absl::PairFormatter("="));
-//   EXPECT_EQ(s, "a=1,b=2,c=3");
-//
-// Example 7:
-//   // These examples show how `absl::StrJoin()` handles a few common edge
-//   // cases:
-//   std::vector<std::string> v_empty;
-//   EXPECT_EQ(absl::StrJoin(v_empty, "-"), "");
-//
-//   std::vector<std::string> v_one_item = {"foo"};
-//   EXPECT_EQ(absl::StrJoin(v_one_item, "-"), "foo");
-//
-//   std::vector<std::string> v_empty_string = {""};
-//   EXPECT_EQ(absl::StrJoin(v_empty_string, "-"), "");
-//
-//   std::vector<std::string> v_one_item_empty_string = {"a", ""};
-//   EXPECT_EQ(absl::StrJoin(v_one_item_empty_string, "-"), "a-");
-//
-//   std::vector<std::string> v_two_empty_string = {"", ""};
-//   EXPECT_EQ(absl::StrJoin(v_two_empty_string, "-"), "-");
-//
-// Example 8:
-//   // Joins a `std::tuple<T...>` of heterogeneous types, converting each to
-//   // a std::string using the `absl::AlphaNum` class.
-//   std::string s = absl::StrJoin(std::make_tuple(123, "abc", 0.456), "-");
-//   EXPECT_EQ(s, "123-abc-0.456");
-
-template <typename Iterator, typename Formatter>
-std::string StrJoin(Iterator start, Iterator end, absl::string_view sep,
-                    Formatter &&fmt) {
-  return strings_internal::JoinAlgorithm(start, end, sep, fmt);
-}
-
-template <typename Range, typename Formatter>
-std::string StrJoin(const Range &range, absl::string_view separator,
-                    Formatter &&fmt) {
-  return strings_internal::JoinRange(range, separator, fmt);
-}
-
-template <typename T, typename Formatter,
-          typename = typename std::enable_if<
-              !std::is_convertible<T, absl::string_view>::value>::type>
-std::string StrJoin(std::initializer_list<T> il, absl::string_view separator,
-                    Formatter &&fmt) {
-  return strings_internal::JoinRange(il, separator, fmt);
-}
-
-template <typename Formatter>
-inline std::string StrJoin(std::initializer_list<absl::string_view> il,
-                           absl::string_view separator, Formatter &&fmt) {
-  return strings_internal::JoinRange(il, separator, fmt);
-}
-
-template <typename... T, typename Formatter>
-std::string StrJoin(const std::tuple<T...> &value, absl::string_view separator,
-                    Formatter &&fmt) {
-  return strings_internal::JoinAlgorithm(value, separator, fmt);
-}
-
-template <typename Iterator>
-std::string StrJoin(Iterator start, Iterator end, absl::string_view separator) {
-  return strings_internal::JoinRange(start, end, separator);
-}
-
-template <typename Range>
-std::string StrJoin(const Range &range, absl::string_view separator) {
-  return strings_internal::JoinRange(range, separator);
-}
-
-template <typename T, typename = typename std::enable_if<!std::is_convertible<
-                          T, absl::string_view>::value>::type>
-std::string StrJoin(std::initializer_list<T> il, absl::string_view separator) {
-  return strings_internal::JoinRange(il, separator);
-}
-
-inline std::string StrJoin(std::initializer_list<absl::string_view> il,
-                           absl::string_view separator) {
-  return strings_internal::JoinRange(il, separator);
-}
-
-template <typename... T>
-std::string StrJoin(const std::tuple<T...> &value,
-                    absl::string_view separator) {
-  return strings_internal::JoinTuple(value, separator,
-                                     std::index_sequence_for<T...>{});
-}
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_STR_JOIN_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/str_replace.h b/packages/react-native-executorch/third-party/include/absl/strings/str_replace.h
deleted file mode 100644
index 42b4d29442..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/str_replace.h
+++ /dev/null
@@ -1,227 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: str_replace.h
-// -----------------------------------------------------------------------------
-//
-// This file defines `absl::StrReplaceAll()`, a general-purpose string
-// replacement function designed for large, arbitrary text substitutions,
-// especially on strings which you are receiving from some other system for
-// further processing (e.g. processing regular expressions, escaping HTML
-// entities, etc.). `StrReplaceAll` is designed to be efficient even when only
-// one substitution is being performed, or when substitution is rare.
-//
-// If the string being modified is known at compile-time, and the substitutions
-// vary, `absl::Substitute()` may be a better choice.
-//
-// Example:
-//
-// std::string html_escaped = absl::StrReplaceAll(user_input, {
-//                                                {"&", "&amp;"},
-//                                                {"<", "&lt;"},
-//                                                {">", "&gt;"},
-//                                                {"\"", "&quot;"},
-//                                                {"'", "&#39;"}});
-#ifndef ABSL_STRINGS_STR_REPLACE_H_
-#define ABSL_STRINGS_STR_REPLACE_H_
-
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "absl/base/attributes.h"
-#include "absl/base/nullability.h"
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// StrReplaceAll()
-//
-// Replaces character sequences within a given string with replacements provided
-// within an initializer list of key/value pairs. Candidate replacements are
-// considered in order as they occur within the string, with earlier matches
-// taking precedence, and longer matches taking precedence for candidates
-// starting at the same position in the string. Once a substitution is made, the
-// replaced text is not considered for any further substitutions.
-//
-// Example:
-//
-//   std::string s = absl::StrReplaceAll(
-//       "$who bought $count #Noun. Thanks $who!",
-//       {{"$count", absl::StrCat(5)},
-//        {"$who", "Bob"},
-//        {"#Noun", "Apples"}});
-//   EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s);
-ABSL_MUST_USE_RESULT std::string StrReplaceAll(
-    absl::string_view s,
-    std::initializer_list<std::pair<absl::string_view, absl::string_view>>
-        replacements);
-
-// Overload of `StrReplaceAll()` to accept a container of key/value replacement
-// pairs (typically either an associative map or a `std::vector` of `std::pair`
-// elements). A vector of pairs is generally more efficient.
-//
-// Examples:
-//
-//   std::map<const absl::string_view, const absl::string_view> replacements;
-//   replacements["$who"] = "Bob";
-//   replacements["$count"] = "5";
-//   replacements["#Noun"] = "Apples";
-//   std::string s = absl::StrReplaceAll(
-//       "$who bought $count #Noun. Thanks $who!",
-//       replacements);
-//   EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s);
-//
-//   // A std::vector of std::pair elements can be more efficient.
-//   std::vector<std::pair<const absl::string_view, std::string>> replacements;
-//   replacements.push_back({"&", "&amp;"});
-//   replacements.push_back({"<", "&lt;"});
-//   replacements.push_back({">", "&gt;"});
-//   std::string s = absl::StrReplaceAll("if (ptr < &foo)",
-//                                  replacements);
-//   EXPECT_EQ("if (ptr &lt; &amp;foo)", s);
-template <typename StrToStrMapping>
-std::string StrReplaceAll(absl::string_view s,
-                          const StrToStrMapping &replacements);
-
-// Overload of `StrReplaceAll()` to replace character sequences within a given
-// output string *in place* with replacements provided within an initializer
-// list of key/value pairs, returning the number of substitutions that occurred.
-//
-// Example:
-//
-//   std::string s = std::string("$who bought $count #Noun. Thanks $who!");
-//   int count;
-//   count = absl::StrReplaceAll({{"$count", absl::StrCat(5)},
-//                               {"$who", "Bob"},
-//                               {"#Noun", "Apples"}}, &s);
-//  EXPECT_EQ(count, 4);
-//  EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s);
-int StrReplaceAll(
-    std::initializer_list<std::pair<absl::string_view, absl::string_view>>
-        replacements,
-    absl::Nonnull<std::string *> target);
-
-// Overload of `StrReplaceAll()` to replace patterns within a given output
-// string *in place* with replacements provided within a container of key/value
-// pairs.
-//
-// Example:
-//
-//   std::string s = std::string("if (ptr < &foo)");
-//   int count = absl::StrReplaceAll({{"&", "&amp;"},
-//                                    {"<", "&lt;"},
-//                                    {">", "&gt;"}}, &s);
-//  EXPECT_EQ(count, 2);
-//  EXPECT_EQ("if (ptr &lt; &amp;foo)", s);
-template <typename StrToStrMapping>
-int StrReplaceAll(const StrToStrMapping &replacements,
-                  absl::Nonnull<std::string *> target);
-
-// Implementation details only, past this point.
-namespace strings_internal {
-
-struct ViableSubstitution {
-  absl::string_view old;
-  absl::string_view replacement;
-  size_t offset;
-
-  ViableSubstitution(absl::string_view old_str,
-                     absl::string_view replacement_str, size_t offset_val)
-      : old(old_str), replacement(replacement_str), offset(offset_val) {}
-
-  // One substitution occurs "before" another (takes priority) if either
-  // it has the lowest offset, or it has the same offset but a larger size.
-  bool OccursBefore(const ViableSubstitution &y) const {
-    if (offset != y.offset)
-      return offset < y.offset;
-    return old.size() > y.old.size();
-  }
-};
-
-// Build a vector of ViableSubstitutions based on the given list of
-// replacements. subs can be implemented as a priority_queue. However, it turns
-// out that most callers have small enough a list of substitutions that the
-// overhead of such a queue isn't worth it.
-template <typename StrToStrMapping>
-std::vector<ViableSubstitution>
-FindSubstitutions(absl::string_view s, const StrToStrMapping &replacements) {
-  std::vector<ViableSubstitution> subs;
-  subs.reserve(replacements.size());
-
-  for (const auto &rep : replacements) {
-    using std::get;
-    absl::string_view old(get<0>(rep));
-
-    size_t pos = s.find(old);
-    if (pos == s.npos)
-      continue;
-
-    // Ignore attempts to replace "". This condition is almost never true,
-    // but above condition is frequently true. That's why we test for this
-    // now and not before.
-    if (old.empty())
-      continue;
-
-    subs.emplace_back(old, get<1>(rep), pos);
-
-    // Insertion sort to ensure the last ViableSubstitution comes before
-    // all the others.
-    size_t index = subs.size();
-    while (--index && subs[index - 1].OccursBefore(subs[index])) {
-      std::swap(subs[index], subs[index - 1]);
-    }
-  }
-  return subs;
-}
-
-int ApplySubstitutions(
-    absl::string_view s,
-    absl::Nonnull<std::vector<ViableSubstitution> *> subs_ptr,
-    absl::Nonnull<std::string *> result_ptr);
-
-} // namespace strings_internal
-
-template <typename StrToStrMapping>
-std::string StrReplaceAll(absl::string_view s,
-                          const StrToStrMapping &replacements) {
-  auto subs = strings_internal::FindSubstitutions(s, replacements);
-  std::string result;
-  result.reserve(s.size());
-  strings_internal::ApplySubstitutions(s, &subs, &result);
-  return result;
-}
-
-template <typename StrToStrMapping>
-int StrReplaceAll(const StrToStrMapping &replacements,
-                  absl::Nonnull<std::string *> target) {
-  auto subs = strings_internal::FindSubstitutions(*target, replacements);
-  if (subs.empty())
-    return 0;
-
-  std::string result;
-  result.reserve(target->size());
-  int substitutions =
-      strings_internal::ApplySubstitutions(*target, &subs, &result);
-  target->swap(result);
-  return substitutions;
-}
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_STR_REPLACE_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/str_split.h b/packages/react-native-executorch/third-party/include/absl/strings/str_split.h
deleted file mode 100644
index 99e8210cde..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/str_split.h
+++ /dev/null
@@ -1,575 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: str_split.h
-// -----------------------------------------------------------------------------
-//
-// This file contains functions for splitting strings. It defines the main
-// `StrSplit()` function, several delimiters for determining the boundaries on
-// which to split the string, and predicates for filtering delimited results.
-// `StrSplit()` adapts the returned collection to the type specified by the
-// caller.
-//
-// Example:
-//
-//   // Splits the given string on commas. Returns the results in a
-//   // vector of strings.
-//   std::vector<std::string> v = absl::StrSplit("a,b,c", ',');
-//   // Can also use ","
-//   // v[0] == "a", v[1] == "b", v[2] == "c"
-//
-// See StrSplit() below for more information.
-#ifndef ABSL_STRINGS_STR_SPLIT_H_
-#define ABSL_STRINGS_STR_SPLIT_H_
-
-#include <algorithm>
-#include <cstddef>
-#include <map>
-#include <set>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "absl/base/internal/raw_logging.h"
-#include "absl/base/macros.h"
-#include "absl/strings/internal/str_split_internal.h"
-#include "absl/strings/string_view.h"
-#include "absl/strings/strip.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-//------------------------------------------------------------------------------
-// Delimiters
-//------------------------------------------------------------------------------
-//
-// `StrSplit()` uses delimiters to define the boundaries between elements in the
-// provided input. Several `Delimiter` types are defined below. If a string
-// (`const char*`, `std::string`, or `absl::string_view`) is passed in place of
-// an explicit `Delimiter` object, `StrSplit()` treats it the same way as if it
-// were passed a `ByString` delimiter.
-//
-// A `Delimiter` is an object with a `Find()` function that knows how to find
-// the first occurrence of itself in a given `absl::string_view`.
-//
-// The following `Delimiter` types are available for use within `StrSplit()`:
-//
-//   - `ByString` (default for string arguments)
-//   - `ByChar` (default for a char argument)
-//   - `ByAnyChar`
-//   - `ByLength`
-//   - `MaxSplits`
-//
-// A Delimiter's `Find()` member function will be passed an input `text` that is
-// to be split and a position (`pos`) to begin searching for the next delimiter
-// in `text`. The returned absl::string_view should refer to the next occurrence
-// (after `pos`) of the represented delimiter; this returned absl::string_view
-// represents the next location where the input `text` should be broken.
-//
-// The returned absl::string_view may be zero-length if the Delimiter does not
-// represent a part of the string (e.g., a fixed-length delimiter). If no
-// delimiter is found in the input `text`, a zero-length absl::string_view
-// referring to `text.end()` should be returned (e.g.,
-// `text.substr(text.size())`). It is important that the returned
-// absl::string_view always be within the bounds of the input `text` given as an
-// argument--it must not refer to a string that is physically located outside of
-// the given string.
-//
-// The following example is a simple Delimiter object that is created with a
-// single char and will look for that char in the text passed to the `Find()`
-// function:
-//
-//   struct SimpleDelimiter {
-//     const char c_;
-//     explicit SimpleDelimiter(char c) : c_(c) {}
-//     absl::string_view Find(absl::string_view text, size_t pos) {
-//       auto found = text.find(c_, pos);
-//       if (found == absl::string_view::npos)
-//         return text.substr(text.size());
-//
-//       return text.substr(found, 1);
-//     }
-//   };
-
-// ByString
-//
-// A sub-string delimiter. If `StrSplit()` is passed a string in place of a
-// `Delimiter` object, the string will be implicitly converted into a
-// `ByString` delimiter.
-//
-// Example:
-//
-//   // Because a string literal is converted to an `absl::ByString`,
-//   // the following two splits are equivalent.
-//
-//   std::vector<std::string> v1 = absl::StrSplit("a, b, c", ", ");
-//
-//   using absl::ByString;
-//   std::vector<std::string> v2 = absl::StrSplit("a, b, c",
-//                                                ByString(", "));
-//   // v[0] == "a", v[1] == "b", v[2] == "c"
-class ByString {
-public:
-  explicit ByString(absl::string_view sp);
-  absl::string_view Find(absl::string_view text, size_t pos) const;
-
-private:
-  const std::string delimiter_;
-};
-
-// ByAsciiWhitespace
-//
-// A sub-string delimiter that splits by ASCII whitespace
-// (space, tab, vertical tab, formfeed, linefeed, or carriage return).
-// Note: you probably want to use absl::SkipEmpty() as well!
-//
-// This class is equivalent to ByAnyChar with ASCII whitespace chars.
-//
-// Example:
-//
-//   std::vector<std::string> v = absl::StrSplit(
-//       "a b\tc\n  d  \n", absl::ByAsciiWhitespace(), absl::SkipEmpty());
-//   // v[0] == "a", v[1] == "b", v[2] == "c", v[3] == "d"
-class ByAsciiWhitespace {
-public:
-  absl::string_view Find(absl::string_view text, size_t pos) const;
-};
-
-// ByChar
-//
-// A single character delimiter. `ByChar` is functionally equivalent to a
-// 1-char string within a `ByString` delimiter, but slightly more efficient.
-//
-// Example:
-//
-//   // Because a char literal is converted to a absl::ByChar,
-//   // the following two splits are equivalent.
-//   std::vector<std::string> v1 = absl::StrSplit("a,b,c", ',');
-//   using absl::ByChar;
-//   std::vector<std::string> v2 = absl::StrSplit("a,b,c", ByChar(','));
-//   // v[0] == "a", v[1] == "b", v[2] == "c"
-//
-// `ByChar` is also the default delimiter if a single character is given
-// as the delimiter to `StrSplit()`. For example, the following calls are
-// equivalent:
-//
-//   std::vector<std::string> v = absl::StrSplit("a-b", '-');
-//
-//   using absl::ByChar;
-//   std::vector<std::string> v = absl::StrSplit("a-b", ByChar('-'));
-//
-class ByChar {
-public:
-  explicit ByChar(char c) : c_(c) {}
-  absl::string_view Find(absl::string_view text, size_t pos) const;
-
-private:
-  char c_;
-};
-
-// ByAnyChar
-//
-// A delimiter that will match any of the given byte-sized characters within
-// its provided string.
-//
-// Note: this delimiter works with single-byte string data, but does not work
-// with variable-width encodings, such as UTF-8.
-//
-// Example:
-//
-//   using absl::ByAnyChar;
-//   std::vector<std::string> v = absl::StrSplit("a,b=c", ByAnyChar(",="));
-//   // v[0] == "a", v[1] == "b", v[2] == "c"
-//
-// If `ByAnyChar` is given the empty string, it behaves exactly like
-// `ByString` and matches each individual character in the input string.
-//
-class ByAnyChar {
-public:
-  explicit ByAnyChar(absl::string_view sp);
-  absl::string_view Find(absl::string_view text, size_t pos) const;
-
-private:
-  const std::string delimiters_;
-};
-
-// ByLength
-//
-// A delimiter for splitting into equal-length strings. The length argument to
-// the constructor must be greater than 0.
-//
-// Note: this delimiter works with single-byte string data, but does not work
-// with variable-width encodings, such as UTF-8.
-//
-// Example:
-//
-//   using absl::ByLength;
-//   std::vector<std::string> v = absl::StrSplit("123456789", ByLength(3));
-
-//   // v[0] == "123", v[1] == "456", v[2] == "789"
-//
-// Note that the string does not have to be a multiple of the fixed split
-// length. In such a case, the last substring will be shorter.
-//
-//   using absl::ByLength;
-//   std::vector<std::string> v = absl::StrSplit("12345", ByLength(2));
-//
-//   // v[0] == "12", v[1] == "34", v[2] == "5"
-class ByLength {
-public:
-  explicit ByLength(ptrdiff_t length);
-  absl::string_view Find(absl::string_view text, size_t pos) const;
-
-private:
-  const ptrdiff_t length_;
-};
-
-namespace strings_internal {
-
-// A traits-like metafunction for selecting the default Delimiter object type
-// for a particular Delimiter type. The base case simply exposes type Delimiter
-// itself as the delimiter's Type. However, there are specializations for
-// string-like objects that map them to the ByString delimiter object.
-// This allows functions like absl::StrSplit() and absl::MaxSplits() to accept
-// string-like objects (e.g., ',') as delimiter arguments but they will be
-// treated as if a ByString delimiter was given.
-template <typename Delimiter> struct SelectDelimiter {
-  using type = Delimiter;
-};
-
-template <> struct SelectDelimiter<char> {
-  using type = ByChar;
-};
-template <> struct SelectDelimiter<char *> {
-  using type = ByString;
-};
-template <> struct SelectDelimiter<const char *> {
-  using type = ByString;
-};
-template <> struct SelectDelimiter<absl::string_view> {
-  using type = ByString;
-};
-template <> struct SelectDelimiter<std::string> {
-  using type = ByString;
-};
-
-// Wraps another delimiter and sets a max number of matches for that delimiter.
-template <typename Delimiter> class MaxSplitsImpl {
-public:
-  MaxSplitsImpl(Delimiter delimiter, int limit)
-      : delimiter_(delimiter), limit_(limit), count_(0) {}
-  absl::string_view Find(absl::string_view text, size_t pos) {
-    if (count_++ == limit_) {
-      return absl::string_view(text.data() + text.size(),
-                               0); // No more matches.
-    }
-    return delimiter_.Find(text, pos);
-  }
-
-private:
-  Delimiter delimiter_;
-  const int limit_;
-  int count_;
-};
-
-} // namespace strings_internal
-
-// MaxSplits()
-//
-// A delimiter that limits the number of matches which can occur to the passed
-// `limit`. The last element in the returned collection will contain all
-// remaining unsplit pieces, which may contain instances of the delimiter.
-// The collection will contain at most `limit` + 1 elements.
-// Example:
-//
-//   using absl::MaxSplits;
-//   std::vector<std::string> v = absl::StrSplit("a,b,c", MaxSplits(',', 1));
-//
-//   // v[0] == "a", v[1] == "b,c"
-template <typename Delimiter>
-inline strings_internal::MaxSplitsImpl<
-    typename strings_internal::SelectDelimiter<Delimiter>::type>
-MaxSplits(Delimiter delimiter, int limit) {
-  typedef
-      typename strings_internal::SelectDelimiter<Delimiter>::type DelimiterType;
-  return strings_internal::MaxSplitsImpl<DelimiterType>(
-      DelimiterType(delimiter), limit);
-}
-
-//------------------------------------------------------------------------------
-// Predicates
-//------------------------------------------------------------------------------
-//
-// Predicates filter the results of a `StrSplit()` by determining whether or not
-// a resultant element is included in the result set. A predicate may be passed
-// as an optional third argument to the `StrSplit()` function.
-//
-// Predicates are unary functions (or functors) that take a single
-// `absl::string_view` argument and return a bool indicating whether the
-// argument should be included (`true`) or excluded (`false`).
-//
-// Predicates are useful when filtering out empty substrings. By default, empty
-// substrings may be returned by `StrSplit()`, which is similar to the way split
-// functions work in other programming languages.
-
-// AllowEmpty()
-//
-// Always returns `true`, indicating that all strings--including empty
-// strings--should be included in the split output. This predicate is not
-// strictly needed because this is the default behavior of `StrSplit()`;
-// however, it might be useful at some call sites to make the intent explicit.
-//
-// Example:
-//
-//  std::vector<std::string> v = absl::StrSplit(" a , ,,b,", ',', AllowEmpty());
-//
-//  // v[0] == " a ", v[1] == " ", v[2] == "", v[3] = "b", v[4] == ""
-struct AllowEmpty {
-  bool operator()(absl::string_view) const { return true; }
-};
-
-// SkipEmpty()
-//
-// Returns `false` if the given `absl::string_view` is empty, indicating that
-// `StrSplit()` should omit the empty string.
-//
-// Example:
-//
-//   std::vector<std::string> v = absl::StrSplit(",a,,b,", ',', SkipEmpty());
-//
-//   // v[0] == "a", v[1] == "b"
-//
-// Note: `SkipEmpty()` does not consider a string containing only whitespace
-// to be empty. To skip such whitespace as well, use the `SkipWhitespace()`
-// predicate.
-struct SkipEmpty {
-  bool operator()(absl::string_view sp) const { return !sp.empty(); }
-};
-
-// SkipWhitespace()
-//
-// Returns `false` if the given `absl::string_view` is empty *or* contains only
-// whitespace, indicating that `StrSplit()` should omit the string.
-//
-// Example:
-//
-//   std::vector<std::string> v = absl::StrSplit(" a , ,,b,",
-//                                               ',', SkipWhitespace());
-//   // v[0] == " a ", v[1] == "b"
-//
-//   // SkipEmpty() would return whitespace elements
-//   std::vector<std::string> v = absl::StrSplit(" a , ,,b,", ',', SkipEmpty());
-//   // v[0] == " a ", v[1] == " ", v[2] == "b"
-struct SkipWhitespace {
-  bool operator()(absl::string_view sp) const {
-    sp = absl::StripAsciiWhitespace(sp);
-    return !sp.empty();
-  }
-};
-
-template <typename T>
-using EnableSplitIfString =
-    typename std::enable_if<std::is_same<T, std::string>::value ||
-                                std::is_same<T, const std::string>::value,
-                            int>::type;
-
-//------------------------------------------------------------------------------
-//                                  StrSplit()
-//------------------------------------------------------------------------------
-
-// StrSplit()
-//
-// Splits a given string based on the provided `Delimiter` object, returning the
-// elements within the type specified by the caller. Optionally, you may pass a
-// `Predicate` to `StrSplit()` indicating whether to include or exclude the
-// resulting element within the final result set. (See the overviews for
-// Delimiters and Predicates above.)
-//
-// Example:
-//
-//   std::vector<std::string> v = absl::StrSplit("a,b,c,d", ',');
-//   // v[0] == "a", v[1] == "b", v[2] == "c", v[3] == "d"
-//
-// You can also provide an explicit `Delimiter` object:
-//
-// Example:
-//
-//   using absl::ByAnyChar;
-//   std::vector<std::string> v = absl::StrSplit("a,b=c", ByAnyChar(",="));
-//   // v[0] == "a", v[1] == "b", v[2] == "c"
-//
-// See above for more information on delimiters.
-//
-// By default, empty strings are included in the result set. You can optionally
-// include a third `Predicate` argument to apply a test for whether the
-// resultant element should be included in the result set:
-//
-// Example:
-//
-//   std::vector<std::string> v = absl::StrSplit(" a , ,,b,",
-//                                               ',', SkipWhitespace());
-//   // v[0] == " a ", v[1] == "b"
-//
-// See above for more information on predicates.
-//
-//------------------------------------------------------------------------------
-// StrSplit() Return Types
-//------------------------------------------------------------------------------
-//
-// The `StrSplit()` function adapts the returned collection to the collection
-// specified by the caller (e.g. `std::vector` above). The returned collections
-// may contain `std::string`, `absl::string_view` (in which case the original
-// string being split must ensure that it outlives the collection), or any
-// object that can be explicitly created from an `absl::string_view`. This
-// behavior works for:
-//
-// 1) All standard STL containers including `std::vector`, `std::list`,
-//    `std::deque`, `std::set`,`std::multiset`, 'std::map`, and `std::multimap`.
-// 2) `std::pair` (which is not actually a container). See below.
-// 3) `std::array`, which is a container but has different behavior due to its
-//    fixed size. See below.
-//
-// Example:
-//
-//   // The results are returned as `absl::string_view` objects. Note that we
-//   // have to ensure that the input string outlives any results.
-//   std::vector<absl::string_view> v = absl::StrSplit("a,b,c", ',');
-//
-//   // Stores results in a std::set<std::string>, which also performs
-//   // de-duplication and orders the elements in ascending order.
-//   std::set<std::string> a = absl::StrSplit("b,a,c,a,b", ',');
-//   // a[0] == "a", a[1] == "b", a[2] == "c"
-//
-//   // `StrSplit()` can be used within a range-based for loop, in which case
-//   // each element will be of type `absl::string_view`.
-//   std::vector<std::string> v;
-//   for (const auto sv : absl::StrSplit("a,b,c", ',')) {
-//     if (sv != "b") v.emplace_back(sv);
-//   }
-//   // v[0] == "a", v[1] == "c"
-//
-//   // Stores results in a map. The map implementation assumes that the input
-//   // is provided as a series of key/value pairs. For example, the 0th element
-//   // resulting from the split will be stored as a key to the 1st element. If
-//   // an odd number of elements are resolved, the last element is paired with
-//   // a default-constructed value (e.g., empty string).
-//   std::map<std::string, std::string> m = absl::StrSplit("a,b,c", ',');
-//   // m["a"] == "b", m["c"] == ""     // last component value equals ""
-//
-// Splitting to `std::pair` is an interesting case because it can hold only two
-// elements and is not a collection type. When splitting to a `std::pair` the
-// first two split strings become the `std::pair` `.first` and `.second`
-// members, respectively. The remaining split substrings are discarded. If there
-// are less than two split substrings, the empty string is used for the
-// corresponding `std::pair` member.
-//
-// Example:
-//
-//   // Stores first two split strings as the members in a std::pair.
-//   std::pair<std::string, std::string> p = absl::StrSplit("a,b,c", ',');
-//   // p.first == "a", p.second == "b"       // "c" is omitted.
-//
-//
-// Splitting to `std::array` is similar to splitting to `std::pair`, but for
-// N elements instead of two; missing elements are filled with the empty string
-// and extra elements are discarded.
-//
-// Examples:
-//
-//   // Stores first two split strings as the elements in a std::array.
-//   std::array<std::string, 2> a = absl::StrSplit("a,b,c", ',');
-//   // a[0] == "a", a[1] == "b"   // "c" is omitted.
-//
-//   // The second element is empty.
-//   std::array<std::string, 2> a = absl::StrSplit("a,", ',');
-//   // a[0] == "a", a[1] == ""
-//
-// The `StrSplit()` function can be used multiple times to perform more
-// complicated splitting logic, such as intelligently parsing key-value pairs.
-//
-// Example:
-//
-//   // The input string "a=b=c,d=e,f=,g" becomes
-//   // { "a" => "b=c", "d" => "e", "f" => "", "g" => "" }
-//   std::map<std::string, std::string> m;
-//   for (absl::string_view sp : absl::StrSplit("a=b=c,d=e,f=,g", ',')) {
-//     m.insert(absl::StrSplit(sp, absl::MaxSplits('=', 1)));
-//   }
-//   EXPECT_EQ("b=c", m.find("a")->second);
-//   EXPECT_EQ("e", m.find("d")->second);
-//   EXPECT_EQ("", m.find("f")->second);
-//   EXPECT_EQ("", m.find("g")->second);
-//
-// WARNING: Due to a legacy bug that is maintained for backward compatibility,
-// splitting the following empty string_views produces different results:
-//
-//   absl::StrSplit(absl::string_view(""), '-');  // {""}
-//   absl::StrSplit(absl::string_view(), '-');    // {}, but should be {""}
-//
-// Try not to depend on this distinction because the bug may one day be fixed.
-template <typename Delimiter>
-strings_internal::Splitter<
-    typename strings_internal::SelectDelimiter<Delimiter>::type, AllowEmpty,
-    absl::string_view>
-StrSplit(strings_internal::ConvertibleToStringView text, Delimiter d) {
-  using DelimiterType =
-      typename strings_internal::SelectDelimiter<Delimiter>::type;
-  return strings_internal::Splitter<DelimiterType, AllowEmpty,
-                                    absl::string_view>(
-      text.value(), DelimiterType(d), AllowEmpty());
-}
-
-template <typename Delimiter, typename StringType,
-          EnableSplitIfString<StringType> = 0>
-strings_internal::Splitter<
-    typename strings_internal::SelectDelimiter<Delimiter>::type, AllowEmpty,
-    std::string>
-StrSplit(StringType &&text, Delimiter d) {
-  using DelimiterType =
-      typename strings_internal::SelectDelimiter<Delimiter>::type;
-  return strings_internal::Splitter<DelimiterType, AllowEmpty, std::string>(
-      std::move(text), DelimiterType(d), AllowEmpty());
-}
-
-template <typename Delimiter, typename Predicate>
-strings_internal::Splitter<
-    typename strings_internal::SelectDelimiter<Delimiter>::type, Predicate,
-    absl::string_view>
-StrSplit(strings_internal::ConvertibleToStringView text, Delimiter d,
-         Predicate p) {
-  using DelimiterType =
-      typename strings_internal::SelectDelimiter<Delimiter>::type;
-  return strings_internal::Splitter<DelimiterType, Predicate,
-                                    absl::string_view>(
-      text.value(), DelimiterType(std::move(d)), std::move(p));
-}
-
-template <typename Delimiter, typename Predicate, typename StringType,
-          EnableSplitIfString<StringType> = 0>
-strings_internal::Splitter<
-    typename strings_internal::SelectDelimiter<Delimiter>::type, Predicate,
-    std::string>
-StrSplit(StringType &&text, Delimiter d, Predicate p) {
-  using DelimiterType =
-      typename strings_internal::SelectDelimiter<Delimiter>::type;
-  return strings_internal::Splitter<DelimiterType, Predicate, std::string>(
-      std::move(text), DelimiterType(d), std::move(p));
-}
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_STR_SPLIT_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/string_view.h b/packages/react-native-executorch/third-party/include/absl/strings/string_view.h
deleted file mode 100644
index 5f21a35c72..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/string_view.h
+++ /dev/null
@@ -1,770 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: string_view.h
-// -----------------------------------------------------------------------------
-//
-// This file contains the definition of the `absl::string_view` class. A
-// `string_view` points to a contiguous span of characters, often part or all of
-// another `std::string`, double-quoted string literal, character array, or even
-// another `string_view`.
-//
-// This `absl::string_view` abstraction is designed to be a drop-in
-// replacement for the C++17 `std::string_view` abstraction.
-#ifndef ABSL_STRINGS_STRING_VIEW_H_
-#define ABSL_STRINGS_STRING_VIEW_H_
-
-#include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <cstring>
-#include <iosfwd>
-#include <iterator>
-#include <limits>
-#include <string>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/base/internal/throw_delegate.h"
-#include "absl/base/macros.h"
-#include "absl/base/nullability.h"
-#include "absl/base/optimization.h"
-#include "absl/base/port.h"
-
-#ifdef ABSL_USES_STD_STRING_VIEW
-
-#include <string_view> // IWYU pragma: export
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-using string_view = std::string_view;
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#else // ABSL_USES_STD_STRING_VIEW
-
-#if ABSL_HAVE_BUILTIN(__builtin_memcmp) ||                                     \
-    (defined(__GNUC__) && !defined(__clang__)) ||                              \
-    (defined(_MSC_VER) && _MSC_VER >= 1928)
-#define ABSL_INTERNAL_STRING_VIEW_MEMCMP __builtin_memcmp
-#else // ABSL_HAVE_BUILTIN(__builtin_memcmp)
-#define ABSL_INTERNAL_STRING_VIEW_MEMCMP memcmp
-#endif // ABSL_HAVE_BUILTIN(__builtin_memcmp)
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// absl::string_view
-//
-// A `string_view` provides a lightweight view into the string data provided by
-// a `std::string`, double-quoted string literal, character array, or even
-// another `string_view`. A `string_view` does *not* own the string to which it
-// points, and that data cannot be modified through the view.
-//
-// You can use `string_view` as a function or method parameter anywhere a
-// parameter can receive a double-quoted string literal, `const char*`,
-// `std::string`, or another `absl::string_view` argument with no need to copy
-// the string data. Systematic use of `string_view` within function arguments
-// reduces data copies and `strlen()` calls.
-//
-// Because of its small size, prefer passing `string_view` by value:
-//
-//   void MyFunction(absl::string_view arg);
-//
-// If circumstances require, you may also pass one by const reference:
-//
-//   void MyFunction(const absl::string_view& arg);  // not preferred
-//
-// Passing by value generates slightly smaller code for many architectures.
-//
-// In either case, the source data of the `string_view` must outlive the
-// `string_view` itself.
-//
-// A `string_view` is also suitable for local variables if you know that the
-// lifetime of the underlying object is longer than the lifetime of your
-// `string_view` variable. However, beware of binding a `string_view` to a
-// temporary value:
-//
-//   // BAD use of string_view: lifetime problem
-//   absl::string_view sv = obj.ReturnAString();
-//
-//   // GOOD use of string_view: str outlives sv
-//   std::string str = obj.ReturnAString();
-//   absl::string_view sv = str;
-//
-// Due to lifetime issues, a `string_view` is sometimes a poor choice for a
-// return value and usually a poor choice for a data member. If you do use a
-// `string_view` this way, it is your responsibility to ensure that the object
-// pointed to by the `string_view` outlives the `string_view`.
-//
-// A `string_view` may represent a whole string or just part of a string. For
-// example, when splitting a string, `std::vector<absl::string_view>` is a
-// natural data type for the output.
-//
-// For another example, a Cord is a non-contiguous, potentially very
-// long string-like object.  The Cord class has an interface that iteratively
-// provides string_view objects that point to the successive pieces of a Cord
-// object.
-//
-// When constructed from a source which is NUL-terminated, the `string_view`
-// itself will not include the NUL-terminator unless a specific size (including
-// the NUL) is passed to the constructor. As a result, common idioms that work
-// on NUL-terminated strings do not work on `string_view` objects. If you write
-// code that scans a `string_view`, you must check its length rather than test
-// for nul, for example. Note, however, that nuls may still be embedded within
-// a `string_view` explicitly.
-//
-// You may create a null `string_view` in two ways:
-//
-//   absl::string_view sv;
-//   absl::string_view sv(nullptr, 0);
-//
-// For the above, `sv.data() == nullptr`, `sv.length() == 0`, and
-// `sv.empty() == true`. Also, if you create a `string_view` with a non-null
-// pointer then `sv.data() != nullptr`. Thus, you can use `string_view()` to
-// signal an undefined value that is different from other `string_view` values
-// in a similar fashion to how `const char* p1 = nullptr;` is different from
-// `const char* p2 = "";`. However, in practice, it is not recommended to rely
-// on this behavior.
-//
-// Be careful not to confuse a null `string_view` with an empty one. A null
-// `string_view` is an empty `string_view`, but some empty `string_view`s are
-// not null. Prefer checking for emptiness over checking for null.
-//
-// There are many ways to create an empty string_view:
-//
-//   const char* nullcp = nullptr;
-//   // string_view.size() will return 0 in all cases.
-//   absl::string_view();
-//   absl::string_view(nullcp, 0);
-//   absl::string_view("");
-//   absl::string_view("", 0);
-//   absl::string_view("abcdef", 0);
-//   absl::string_view("abcdef" + 6, 0);
-//
-// All empty `string_view` objects whether null or not, are equal:
-//
-//   absl::string_view() == absl::string_view("", 0)
-//   absl::string_view(nullptr, 0) == absl::string_view("abcdef"+6, 0)
-class ABSL_ATTRIBUTE_VIEW string_view {
-public:
-  using traits_type = std::char_traits<char>;
-  using value_type = char;
-  using pointer = absl::Nullable<char *>;
-  using const_pointer = absl::Nullable<const char *>;
-  using reference = char &;
-  using const_reference = const char &;
-  using const_iterator = absl::Nullable<const char *>;
-  using iterator = const_iterator;
-  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-  using reverse_iterator = const_reverse_iterator;
-  using size_type = size_t;
-  using difference_type = std::ptrdiff_t;
-  using absl_internal_is_view = std::true_type;
-
-  static constexpr size_type npos = static_cast<size_type>(-1);
-
-  // Null `string_view` constructor
-  constexpr string_view() noexcept : ptr_(nullptr), length_(0) {}
-
-  // Implicit constructors
-
-  template <typename Allocator>
-  string_view( // NOLINT(runtime/explicit)
-      const std::basic_string<char, std::char_traits<char>, Allocator> &str
-          ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
-      // This is implemented in terms of `string_view(p, n)` so `str.size()`
-      // doesn't need to be reevaluated after `ptr_` is set.
-      // The length check is also skipped since it is unnecessary and causes
-      // code bloat.
-      : string_view(str.data(), str.size(), SkipCheckLengthTag{}) {}
-
-  // Implicit constructor of a `string_view` from NUL-terminated `str`. When
-  // accepting possibly null strings, use `absl::NullSafeStringView(str)`
-  // instead (see below).
-  // The length check is skipped since it is unnecessary and causes code bloat.
-  constexpr string_view( // NOLINT(runtime/explicit)
-      absl::Nonnull<const char *> str)
-      : ptr_(str), length_(str ? StrlenInternal(str) : 0) {}
-
-  // Implicit constructor of a `string_view` from a `const char*` and length.
-  constexpr string_view(absl::Nullable<const char *> data, size_type len)
-      : ptr_(data), length_(CheckLengthInternal(len)) {}
-
-  // NOTE: Harmlessly omitted to work around gdb bug.
-  //   constexpr string_view(const string_view&) noexcept = default;
-  //   string_view& operator=(const string_view&) noexcept = default;
-
-  // Iterators
-
-  // string_view::begin()
-  //
-  // Returns an iterator pointing to the first character at the beginning of the
-  // `string_view`, or `end()` if the `string_view` is empty.
-  constexpr const_iterator begin() const noexcept { return ptr_; }
-
-  // string_view::end()
-  //
-  // Returns an iterator pointing just beyond the last character at the end of
-  // the `string_view`. This iterator acts as a placeholder; attempting to
-  // access it results in undefined behavior.
-  constexpr const_iterator end() const noexcept { return ptr_ + length_; }
-
-  // string_view::cbegin()
-  //
-  // Returns a const iterator pointing to the first character at the beginning
-  // of the `string_view`, or `end()` if the `string_view` is empty.
-  constexpr const_iterator cbegin() const noexcept { return begin(); }
-
-  // string_view::cend()
-  //
-  // Returns a const iterator pointing just beyond the last character at the end
-  // of the `string_view`. This pointer acts as a placeholder; attempting to
-  // access its element results in undefined behavior.
-  constexpr const_iterator cend() const noexcept { return end(); }
-
-  // string_view::rbegin()
-  //
-  // Returns a reverse iterator pointing to the last character at the end of the
-  // `string_view`, or `rend()` if the `string_view` is empty.
-  const_reverse_iterator rbegin() const noexcept {
-    return const_reverse_iterator(end());
-  }
-
-  // string_view::rend()
-  //
-  // Returns a reverse iterator pointing just before the first character at the
-  // beginning of the `string_view`. This pointer acts as a placeholder;
-  // attempting to access its element results in undefined behavior.
-  const_reverse_iterator rend() const noexcept {
-    return const_reverse_iterator(begin());
-  }
-
-  // string_view::crbegin()
-  //
-  // Returns a const reverse iterator pointing to the last character at the end
-  // of the `string_view`, or `crend()` if the `string_view` is empty.
-  const_reverse_iterator crbegin() const noexcept { return rbegin(); }
-
-  // string_view::crend()
-  //
-  // Returns a const reverse iterator pointing just before the first character
-  // at the beginning of the `string_view`. This pointer acts as a placeholder;
-  // attempting to access its element results in undefined behavior.
-  const_reverse_iterator crend() const noexcept { return rend(); }
-
-  // Capacity Utilities
-
-  // string_view::size()
-  //
-  // Returns the number of characters in the `string_view`.
-  constexpr size_type size() const noexcept { return length_; }
-
-  // string_view::length()
-  //
-  // Returns the number of characters in the `string_view`. Alias for `size()`.
-  constexpr size_type length() const noexcept { return size(); }
-
-  // string_view::max_size()
-  //
-  // Returns the maximum number of characters the `string_view` can hold.
-  constexpr size_type max_size() const noexcept { return kMaxSize; }
-
-  // string_view::empty()
-  //
-  // Checks if the `string_view` is empty (refers to no characters).
-  constexpr bool empty() const noexcept { return length_ == 0; }
-
-  // string_view::operator[]
-  //
-  // Returns the ith element of the `string_view` using the array operator.
-  // Note that this operator does not perform any bounds checking.
-  constexpr const_reference operator[](size_type i) const {
-    return ABSL_HARDENING_ASSERT(i < size()), ptr_[i];
-  }
-
-  // string_view::at()
-  //
-  // Returns the ith element of the `string_view`. Bounds checking is performed,
-  // and an exception of type `std::out_of_range` will be thrown on invalid
-  // access.
-  constexpr const_reference at(size_type i) const {
-    if (ABSL_PREDICT_FALSE(i >= size())) {
-      base_internal::ThrowStdOutOfRange("absl::string_view::at");
-    }
-    return ptr_[i];
-  }
-
-  // string_view::front()
-  //
-  // Returns the first element of a `string_view`.
-  constexpr const_reference front() const {
-    return ABSL_HARDENING_ASSERT(!empty()), ptr_[0];
-  }
-
-  // string_view::back()
-  //
-  // Returns the last element of a `string_view`.
-  constexpr const_reference back() const {
-    return ABSL_HARDENING_ASSERT(!empty()), ptr_[size() - 1];
-  }
-
-  // string_view::data()
-  //
-  // Returns a pointer to the underlying character array (which is of course
-  // stored elsewhere). Note that `string_view::data()` may contain embedded nul
-  // characters, but the returned buffer may or may not be NUL-terminated;
-  // therefore, do not pass `data()` to a routine that expects a NUL-terminated
-  // string.
-  constexpr const_pointer data() const noexcept { return ptr_; }
-
-  // Modifiers
-
-  // string_view::remove_prefix()
-  //
-  // Removes the first `n` characters from the `string_view`. Note that the
-  // underlying string is not changed, only the view.
-  constexpr void remove_prefix(size_type n) {
-    ABSL_HARDENING_ASSERT(n <= length_);
-    ptr_ += n;
-    length_ -= n;
-  }
-
-  // string_view::remove_suffix()
-  //
-  // Removes the last `n` characters from the `string_view`. Note that the
-  // underlying string is not changed, only the view.
-  constexpr void remove_suffix(size_type n) {
-    ABSL_HARDENING_ASSERT(n <= length_);
-    length_ -= n;
-  }
-
-  // string_view::swap()
-  //
-  // Swaps this `string_view` with another `string_view`.
-  constexpr void swap(string_view &s) noexcept {
-    auto t = *this;
-    *this = s;
-    s = t;
-  }
-
-  // Explicit conversion operators
-
-  // Converts to `std::basic_string`.
-  template <typename A>
-  explicit operator std::basic_string<char, traits_type, A>() const {
-    if (!data())
-      return {};
-    return std::basic_string<char, traits_type, A>(data(), size());
-  }
-
-  // string_view::copy()
-  //
-  // Copies the contents of the `string_view` at offset `pos` and length `n`
-  // into `buf`.
-  size_type copy(char *buf, size_type n, size_type pos = 0) const {
-    if (ABSL_PREDICT_FALSE(pos > length_)) {
-      base_internal::ThrowStdOutOfRange("absl::string_view::copy");
-    }
-    size_type rlen = (std::min)(length_ - pos, n);
-    if (rlen > 0) {
-      const char *start = ptr_ + pos;
-      traits_type::copy(buf, start, rlen);
-    }
-    return rlen;
-  }
-
-  // string_view::substr()
-  //
-  // Returns a "substring" of the `string_view` (at offset `pos` and length
-  // `n`) as another string_view. This function throws `std::out_of_bounds` if
-  // `pos > size`.
-  // Use absl::ClippedSubstr if you need a truncating substr operation.
-  constexpr string_view substr(size_type pos = 0, size_type n = npos) const {
-    if (ABSL_PREDICT_FALSE(pos > length_)) {
-      base_internal::ThrowStdOutOfRange("absl::string_view::substr");
-    }
-    return string_view(ptr_ + pos, Min(n, length_ - pos));
-  }
-
-  // string_view::compare()
-  //
-  // Performs a lexicographical comparison between this `string_view` and
-  // another `string_view` `x`, returning a negative value if `*this` is less
-  // than `x`, 0 if `*this` is equal to `x`, and a positive value if `*this`
-  // is greater than `x`.
-  constexpr int compare(string_view x) const noexcept {
-    return CompareImpl(length_, x.length_,
-                       Min(length_, x.length_) == 0
-                           ? 0
-                           : ABSL_INTERNAL_STRING_VIEW_MEMCMP(
-                                 ptr_, x.ptr_, Min(length_, x.length_)));
-  }
-
-  // Overload of `string_view::compare()` for comparing a substring of the
-  // 'string_view` and another `absl::string_view`.
-  constexpr int compare(size_type pos1, size_type count1, string_view v) const {
-    return substr(pos1, count1).compare(v);
-  }
-
-  // Overload of `string_view::compare()` for comparing a substring of the
-  // `string_view` and a substring of another `absl::string_view`.
-  constexpr int compare(size_type pos1, size_type count1, string_view v,
-                        size_type pos2, size_type count2) const {
-    return substr(pos1, count1).compare(v.substr(pos2, count2));
-  }
-
-  // Overload of `string_view::compare()` for comparing a `string_view` and a
-  // a different C-style string `s`.
-  constexpr int compare(absl::Nonnull<const char *> s) const {
-    return compare(string_view(s));
-  }
-
-  // Overload of `string_view::compare()` for comparing a substring of the
-  // `string_view` and a different string C-style string `s`.
-  constexpr int compare(size_type pos1, size_type count1,
-                        absl::Nonnull<const char *> s) const {
-    return substr(pos1, count1).compare(string_view(s));
-  }
-
-  // Overload of `string_view::compare()` for comparing a substring of the
-  // `string_view` and a substring of a different C-style string `s`.
-  constexpr int compare(size_type pos1, size_type count1,
-                        absl::Nonnull<const char *> s, size_type count2) const {
-    return substr(pos1, count1).compare(string_view(s, count2));
-  }
-
-  // Find Utilities
-
-  // string_view::find()
-  //
-  // Finds the first occurrence of the substring `s` within the `string_view`,
-  // returning the position of the first character's match, or `npos` if no
-  // match was found.
-  size_type find(string_view s, size_type pos = 0) const noexcept;
-
-  // Overload of `string_view::find()` for finding the given character `c`
-  // within the `string_view`.
-  size_type find(char c, size_type pos = 0) const noexcept;
-
-  // Overload of `string_view::find()` for finding a substring of a different
-  // C-style string `s` within the `string_view`.
-  size_type find(absl::Nonnull<const char *> s, size_type pos,
-                 size_type count) const {
-    return find(string_view(s, count), pos);
-  }
-
-  // Overload of `string_view::find()` for finding a different C-style string
-  // `s` within the `string_view`.
-  size_type find(absl::Nonnull<const char *> s, size_type pos = 0) const {
-    return find(string_view(s), pos);
-  }
-
-  // string_view::rfind()
-  //
-  // Finds the last occurrence of a substring `s` within the `string_view`,
-  // returning the position of the first character's match, or `npos` if no
-  // match was found.
-  size_type rfind(string_view s, size_type pos = npos) const noexcept;
-
-  // Overload of `string_view::rfind()` for finding the last given character `c`
-  // within the `string_view`.
-  size_type rfind(char c, size_type pos = npos) const noexcept;
-
-  // Overload of `string_view::rfind()` for finding a substring of a different
-  // C-style string `s` within the `string_view`.
-  size_type rfind(absl::Nonnull<const char *> s, size_type pos,
-                  size_type count) const {
-    return rfind(string_view(s, count), pos);
-  }
-
-  // Overload of `string_view::rfind()` for finding a different C-style string
-  // `s` within the `string_view`.
-  size_type rfind(absl::Nonnull<const char *> s, size_type pos = npos) const {
-    return rfind(string_view(s), pos);
-  }
-
-  // string_view::find_first_of()
-  //
-  // Finds the first occurrence of any of the characters in `s` within the
-  // `string_view`, returning the start position of the match, or `npos` if no
-  // match was found.
-  size_type find_first_of(string_view s, size_type pos = 0) const noexcept;
-
-  // Overload of `string_view::find_first_of()` for finding a character `c`
-  // within the `string_view`.
-  size_type find_first_of(char c, size_type pos = 0) const noexcept {
-    return find(c, pos);
-  }
-
-  // Overload of `string_view::find_first_of()` for finding a substring of a
-  // different C-style string `s` within the `string_view`.
-  size_type find_first_of(absl::Nonnull<const char *> s, size_type pos,
-                          size_type count) const {
-    return find_first_of(string_view(s, count), pos);
-  }
-
-  // Overload of `string_view::find_first_of()` for finding a different C-style
-  // string `s` within the `string_view`.
-  size_type find_first_of(absl::Nonnull<const char *> s,
-                          size_type pos = 0) const {
-    return find_first_of(string_view(s), pos);
-  }
-
-  // string_view::find_last_of()
-  //
-  // Finds the last occurrence of any of the characters in `s` within the
-  // `string_view`, returning the start position of the match, or `npos` if no
-  // match was found.
-  size_type find_last_of(string_view s, size_type pos = npos) const noexcept;
-
-  // Overload of `string_view::find_last_of()` for finding a character `c`
-  // within the `string_view`.
-  size_type find_last_of(char c, size_type pos = npos) const noexcept {
-    return rfind(c, pos);
-  }
-
-  // Overload of `string_view::find_last_of()` for finding a substring of a
-  // different C-style string `s` within the `string_view`.
-  size_type find_last_of(absl::Nonnull<const char *> s, size_type pos,
-                         size_type count) const {
-    return find_last_of(string_view(s, count), pos);
-  }
-
-  // Overload of `string_view::find_last_of()` for finding a different C-style
-  // string `s` within the `string_view`.
-  size_type find_last_of(absl::Nonnull<const char *> s,
-                         size_type pos = npos) const {
-    return find_last_of(string_view(s), pos);
-  }
-
-  // string_view::find_first_not_of()
-  //
-  // Finds the first occurrence of any of the characters not in `s` within the
-  // `string_view`, returning the start position of the first non-match, or
-  // `npos` if no non-match was found.
-  size_type find_first_not_of(string_view s, size_type pos = 0) const noexcept;
-
-  // Overload of `string_view::find_first_not_of()` for finding a character
-  // that is not `c` within the `string_view`.
-  size_type find_first_not_of(char c, size_type pos = 0) const noexcept;
-
-  // Overload of `string_view::find_first_not_of()` for finding a substring of a
-  // different C-style string `s` within the `string_view`.
-  size_type find_first_not_of(absl::Nonnull<const char *> s, size_type pos,
-                              size_type count) const {
-    return find_first_not_of(string_view(s, count), pos);
-  }
-
-  // Overload of `string_view::find_first_not_of()` for finding a different
-  // C-style string `s` within the `string_view`.
-  size_type find_first_not_of(absl::Nonnull<const char *> s,
-                              size_type pos = 0) const {
-    return find_first_not_of(string_view(s), pos);
-  }
-
-  // string_view::find_last_not_of()
-  //
-  // Finds the last occurrence of any of the characters not in `s` within the
-  // `string_view`, returning the start position of the last non-match, or
-  // `npos` if no non-match was found.
-  size_type find_last_not_of(string_view s,
-                             size_type pos = npos) const noexcept;
-
-  // Overload of `string_view::find_last_not_of()` for finding a character
-  // that is not `c` within the `string_view`.
-  size_type find_last_not_of(char c, size_type pos = npos) const noexcept;
-
-  // Overload of `string_view::find_last_not_of()` for finding a substring of a
-  // different C-style string `s` within the `string_view`.
-  size_type find_last_not_of(absl::Nonnull<const char *> s, size_type pos,
-                             size_type count) const {
-    return find_last_not_of(string_view(s, count), pos);
-  }
-
-  // Overload of `string_view::find_last_not_of()` for finding a different
-  // C-style string `s` within the `string_view`.
-  size_type find_last_not_of(absl::Nonnull<const char *> s,
-                             size_type pos = npos) const {
-    return find_last_not_of(string_view(s), pos);
-  }
-
-#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
-  // string_view::starts_with()
-  //
-  // Returns true if the `string_view` starts with the prefix `s`.
-  //
-  // This method only exists when targeting at least C++20.
-  // If support for C++ prior to C++20 is required, use `absl::StartsWith()`
-  // from `//absl/strings/match.h` for compatibility.
-  constexpr bool starts_with(string_view s) const noexcept {
-    return s.empty() ||
-           (size() >= s.size() &&
-            ABSL_INTERNAL_STRING_VIEW_MEMCMP(data(), s.data(), s.size()) == 0);
-  }
-
-  // Overload of `string_view::starts_with()` that returns true if `c` is the
-  // first character of the `string_view`.
-  constexpr bool starts_with(char c) const noexcept {
-    return !empty() && front() == c;
-  }
-
-  // Overload of `string_view::starts_with()` that returns true if the
-  // `string_view` starts with the C-style prefix `s`.
-  constexpr bool starts_with(const char *s) const {
-    return starts_with(string_view(s));
-  }
-
-  // string_view::ends_with()
-  //
-  // Returns true if the `string_view` ends with the suffix `s`.
-  //
-  // This method only exists when targeting at least C++20.
-  // If support for C++ prior to C++20 is required, use `absl::EndsWith()`
-  // from `//absl/strings/match.h` for compatibility.
-  constexpr bool ends_with(string_view s) const noexcept {
-    return s.empty() || (size() >= s.size() && ABSL_INTERNAL_STRING_VIEW_MEMCMP(
-                                                   data() + (size() - s.size()),
-                                                   s.data(), s.size()) == 0);
-  }
-
-  // Overload of `string_view::ends_with()` that returns true if `c` is the
-  // last character of the `string_view`.
-  constexpr bool ends_with(char c) const noexcept {
-    return !empty() && back() == c;
-  }
-
-  // Overload of `string_view::ends_with()` that returns true if the
-  // `string_view` ends with the C-style suffix `s`.
-  constexpr bool ends_with(const char *s) const {
-    return ends_with(string_view(s));
-  }
-#endif // ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
-
-private:
-  // The constructor from std::string delegates to this constructor.
-  // See the comment on that constructor for the rationale.
-  struct SkipCheckLengthTag {};
-  string_view(absl::Nullable<const char *> data, size_type len,
-              SkipCheckLengthTag) noexcept
-      : ptr_(data), length_(len) {}
-
-  static constexpr size_type kMaxSize =
-      (std::numeric_limits<difference_type>::max)();
-
-  static constexpr size_type CheckLengthInternal(size_type len) {
-    return ABSL_HARDENING_ASSERT(len <= kMaxSize), len;
-  }
-
-  static constexpr size_type StrlenInternal(absl::Nonnull<const char *> str) {
-#if defined(_MSC_VER) && !defined(__clang__)
-    // MSVC 2017+ can evaluate this at compile-time.
-    const char *begin = str;
-    while (*str != '\0')
-      ++str;
-    return str - begin;
-#elif ABSL_HAVE_BUILTIN(__builtin_strlen) ||                                   \
-    (defined(__GNUC__) && !defined(__clang__))
-    // GCC has __builtin_strlen according to
-    // https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Other-Builtins.html, but
-    // ABSL_HAVE_BUILTIN doesn't detect that, so we use the extra checks above.
-    // __builtin_strlen is constexpr.
-    return __builtin_strlen(str);
-#else
-    return str ? strlen(str) : 0;
-#endif
-  }
-
-  static constexpr size_t Min(size_type length_a, size_type length_b) {
-    return length_a < length_b ? length_a : length_b;
-  }
-
-  static constexpr int CompareImpl(size_type length_a, size_type length_b,
-                                   int compare_result) {
-    return compare_result == 0 ? static_cast<int>(length_a > length_b) -
-                                     static_cast<int>(length_a < length_b)
-                               : (compare_result < 0 ? -1 : 1);
-  }
-
-  absl::Nullable<const char *> ptr_;
-  size_type length_;
-};
-
-// This large function is defined inline so that in a fairly common case where
-// one of the arguments is a literal, the compiler can elide a lot of the
-// following comparisons.
-constexpr bool operator==(string_view x, string_view y) noexcept {
-  return x.size() == y.size() &&
-         (x.empty() ||
-          ABSL_INTERNAL_STRING_VIEW_MEMCMP(x.data(), y.data(), x.size()) == 0);
-}
-
-constexpr bool operator!=(string_view x, string_view y) noexcept {
-  return !(x == y);
-}
-
-constexpr bool operator<(string_view x, string_view y) noexcept {
-  return x.compare(y) < 0;
-}
-
-constexpr bool operator>(string_view x, string_view y) noexcept {
-  return y < x;
-}
-
-constexpr bool operator<=(string_view x, string_view y) noexcept {
-  return !(y < x);
-}
-
-constexpr bool operator>=(string_view x, string_view y) noexcept {
-  return !(x < y);
-}
-
-// IO Insertion Operator
-std::ostream &operator<<(std::ostream &o, string_view piece);
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#undef ABSL_INTERNAL_STRING_VIEW_MEMCMP
-
-#endif // ABSL_USES_STD_STRING_VIEW
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// ClippedSubstr()
-//
-// Like `s.substr(pos, n)`, but clips `pos` to an upper bound of `s.size()`.
-// Provided because std::string_view::substr throws if `pos > size()`
-inline string_view ClippedSubstr(string_view s, size_t pos,
-                                 size_t n = string_view::npos) {
-  pos = (std::min)(pos, static_cast<size_t>(s.size()));
-  return s.substr(pos, n);
-}
-
-// NullSafeStringView()
-//
-// Creates an `absl::string_view` from a pointer `p` even if it's null-valued.
-// This function should be used where an `absl::string_view` can be created from
-// a possibly-null pointer.
-constexpr string_view NullSafeStringView(absl::Nullable<const char *> p) {
-  return p ? string_view(p) : string_view();
-}
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_STRING_VIEW_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/strip.h b/packages/react-native-executorch/third-party/include/absl/strings/strip.h
deleted file mode 100644
index 18c1df3a2c..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/strip.h
+++ /dev/null
@@ -1,100 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: strip.h
-// -----------------------------------------------------------------------------
-//
-// This file contains various functions for stripping substrings from a string.
-#ifndef ABSL_STRINGS_STRIP_H_
-#define ABSL_STRINGS_STRIP_H_
-
-#include <cstddef>
-#include <string>
-
-#include "absl/base/macros.h"
-#include "absl/base/nullability.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/match.h"
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// ConsumePrefix()
-//
-// Strips the `expected` prefix, if found, from the start of `str`.
-// If the operation succeeded, `true` is returned.  If not, `false`
-// is returned and `str` is not modified.
-//
-// Example:
-//
-//   absl::string_view input("abc");
-//   EXPECT_TRUE(absl::ConsumePrefix(&input, "a"));
-//   EXPECT_EQ(input, "bc");
-inline constexpr bool ConsumePrefix(absl::Nonnull<absl::string_view *> str,
-                                    absl::string_view expected) {
-  if (!absl::StartsWith(*str, expected))
-    return false;
-  str->remove_prefix(expected.size());
-  return true;
-}
-// ConsumeSuffix()
-//
-// Strips the `expected` suffix, if found, from the end of `str`.
-// If the operation succeeded, `true` is returned.  If not, `false`
-// is returned and `str` is not modified.
-//
-// Example:
-//
-//   absl::string_view input("abcdef");
-//   EXPECT_TRUE(absl::ConsumeSuffix(&input, "def"));
-//   EXPECT_EQ(input, "abc");
-inline constexpr bool ConsumeSuffix(absl::Nonnull<absl::string_view *> str,
-                                    absl::string_view expected) {
-  if (!absl::EndsWith(*str, expected))
-    return false;
-  str->remove_suffix(expected.size());
-  return true;
-}
-
-// StripPrefix()
-//
-// Returns a view into the input string `str` with the given `prefix` removed,
-// but leaving the original string intact. If the prefix does not match at the
-// start of the string, returns the original string instead.
-ABSL_MUST_USE_RESULT inline constexpr absl::string_view
-StripPrefix(absl::string_view str, absl::string_view prefix) {
-  if (absl::StartsWith(str, prefix))
-    str.remove_prefix(prefix.size());
-  return str;
-}
-
-// StripSuffix()
-//
-// Returns a view into the input string `str` with the given `suffix` removed,
-// but leaving the original string intact. If the suffix does not match at the
-// end of the string, returns the original string instead.
-ABSL_MUST_USE_RESULT inline constexpr absl::string_view
-StripSuffix(absl::string_view str, absl::string_view suffix) {
-  if (absl::EndsWith(str, suffix))
-    str.remove_suffix(suffix.size());
-  return str;
-}
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_STRIP_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/strings/substitute.h b/packages/react-native-executorch/third-party/include/absl/strings/substitute.h
deleted file mode 100644
index 3ea9e57600..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/strings/substitute.h
+++ /dev/null
@@ -1,760 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: substitute.h
-// -----------------------------------------------------------------------------
-//
-// This package contains functions for efficiently performing string
-// substitutions using a format string with positional notation:
-// `Substitute()` and `SubstituteAndAppend()`.
-//
-// Unlike printf-style format specifiers, `Substitute()` functions do not need
-// to specify the type of the substitution arguments. Supported arguments
-// following the format string, such as strings, string_views, ints,
-// floats, and bools, are automatically converted to strings during the
-// substitution process. (See below for a full list of supported types.)
-//
-// `Substitute()` does not allow you to specify *how* to format a value, beyond
-// the default conversion to string. For example, you cannot format an integer
-// in hex.
-//
-// The format string uses positional identifiers indicated by a dollar sign ($)
-// and single digit positional ids to indicate which substitution arguments to
-// use at that location within the format string.
-//
-// A '$$' sequence in the format string causes a literal '$' character to be
-// output.
-//
-// Example 1:
-//   std::string s = Substitute("$1 purchased $0 $2 for $$10. Thanks $1!",
-//                              5, "Bob", "Apples");
-//   EXPECT_EQ("Bob purchased 5 Apples for $10. Thanks Bob!", s);
-//
-// Example 2:
-//   std::string s = "Hi. ";
-//   SubstituteAndAppend(&s, "My name is $0 and I am $1 years old.", "Bob", 5);
-//   EXPECT_EQ("Hi. My name is Bob and I am 5 years old.", s);
-//
-// Supported types:
-//   * absl::string_view, std::string, const char* (null is equivalent to "")
-//   * int32_t, int64_t, uint32_t, uint64_t
-//   * float, double
-//   * bool (Printed as "true" or "false")
-//   * pointer types other than char* (Printed as "0x<lower case hex string>",
-//     except that null is printed as "NULL")
-//   * user-defined types via the `AbslStringify()` customization point. See the
-//     documentation for `absl::StrCat` for an explanation on how to use this.
-//
-// If an invalid format string is provided, Substitute returns an empty string
-// and SubstituteAndAppend does not change the provided output string.
-// A format string is invalid if it:
-//   * ends in an unescaped $ character,
-//     e.g. "Hello $", or
-//   * calls for a position argument which is not provided,
-//     e.g. Substitute("Hello $2", "world"), or
-//   * specifies a non-digit, non-$ character after an unescaped $ character,
-//     e.g. "Hello $f".
-// In debug mode, i.e. #ifndef NDEBUG, such errors terminate the program.
-
-#ifndef ABSL_STRINGS_SUBSTITUTE_H_
-#define ABSL_STRINGS_SUBSTITUTE_H_
-
-#include <cstring>
-#include <string>
-#include <type_traits>
-#include <vector>
-
-#include "absl/base/macros.h"
-#include "absl/base/nullability.h"
-#include "absl/base/port.h"
-#include "absl/strings/ascii.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/internal/stringify_sink.h"
-#include "absl/strings/numbers.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_split.h"
-#include "absl/strings/string_view.h"
-#include "absl/strings/strip.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace substitute_internal {
-
-// Arg
-//
-// This class provides an argument type for `absl::Substitute()` and
-// `absl::SubstituteAndAppend()`. `Arg` handles implicit conversion of various
-// types to a string. (`Arg` is very similar to the `AlphaNum` class in
-// `StrCat()`.)
-//
-// This class has implicit constructors.
-class Arg {
-public:
-  // Overloads for string-y things
-  //
-  // Explicitly overload `const char*` so the compiler doesn't cast to `bool`.
-  Arg(absl::Nullable<const char *> value) // NOLINT(google-explicit-constructor)
-      : piece_(absl::NullSafeStringView(value)) {}
-  template <typename Allocator>
-  Arg( // NOLINT
-      const std::basic_string<char, std::char_traits<char>, Allocator>
-          &value) noexcept
-      : piece_(value) {}
-  Arg(absl::string_view value) // NOLINT(google-explicit-constructor)
-      : piece_(value) {}
-
-  // Overloads for primitives
-  //
-  // No overloads are available for signed and unsigned char because if people
-  // are explicitly declaring their chars as signed or unsigned then they are
-  // probably using them as 8-bit integers and would probably prefer an integer
-  // representation. However, we can't really know, so we make the caller decide
-  // what to do.
-  Arg(char value) // NOLINT(google-explicit-constructor)
-      : piece_(scratch_, 1) {
-    scratch_[0] = value;
-  }
-  Arg(short value) // NOLINT(*)
-      : piece_(scratch_, static_cast<size_t>(numbers_internal::FastIntToBuffer(
-                                                 value, scratch_) -
-                                             scratch_)) {}
-  Arg(unsigned short value) // NOLINT(*)
-      : piece_(scratch_, static_cast<size_t>(numbers_internal::FastIntToBuffer(
-                                                 value, scratch_) -
-                                             scratch_)) {}
-  Arg(int value) // NOLINT(google-explicit-constructor)
-      : piece_(scratch_, static_cast<size_t>(numbers_internal::FastIntToBuffer(
-                                                 value, scratch_) -
-                                             scratch_)) {}
-  Arg(unsigned int value) // NOLINT(google-explicit-constructor)
-      : piece_(scratch_, static_cast<size_t>(numbers_internal::FastIntToBuffer(
-                                                 value, scratch_) -
-                                             scratch_)) {}
-  Arg(long value) // NOLINT(*)
-      : piece_(scratch_, static_cast<size_t>(numbers_internal::FastIntToBuffer(
-                                                 value, scratch_) -
-                                             scratch_)) {}
-  Arg(unsigned long value) // NOLINT(*)
-      : piece_(scratch_, static_cast<size_t>(numbers_internal::FastIntToBuffer(
-                                                 value, scratch_) -
-                                             scratch_)) {}
-  Arg(long long value) // NOLINT(*)
-      : piece_(scratch_, static_cast<size_t>(numbers_internal::FastIntToBuffer(
-                                                 value, scratch_) -
-                                             scratch_)) {}
-  Arg(unsigned long long value) // NOLINT(*)
-      : piece_(scratch_, static_cast<size_t>(numbers_internal::FastIntToBuffer(
-                                                 value, scratch_) -
-                                             scratch_)) {}
-  Arg(float value) // NOLINT(google-explicit-constructor)
-      : piece_(scratch_, numbers_internal::SixDigitsToBuffer(value, scratch_)) {
-  }
-  Arg(double value) // NOLINT(google-explicit-constructor)
-      : piece_(scratch_, numbers_internal::SixDigitsToBuffer(value, scratch_)) {
-  }
-  Arg(bool value) // NOLINT(google-explicit-constructor)
-      : piece_(value ? "true" : "false") {}
-
-  template <typename T, typename = typename std::enable_if<
-                            HasAbslStringify<T>::value>::type>
-  Arg( // NOLINT(google-explicit-constructor)
-      const T &v, strings_internal::StringifySink &&sink = {})
-      : piece_(strings_internal::ExtractStringification(sink, v)) {}
-
-  Arg(Hex hex); // NOLINT(google-explicit-constructor)
-  Arg(Dec dec); // NOLINT(google-explicit-constructor)
-
-  // vector<bool>::reference and const_reference require special help to convert
-  // to `Arg` because it requires two user defined conversions.
-  template <typename T,
-            absl::enable_if_t<
-                std::is_class<T>::value &&
-                (std::is_same<T, std::vector<bool>::reference>::value ||
-                 std::is_same<T, std::vector<bool>::const_reference>::value)>
-                * = nullptr>
-  Arg(T value) // NOLINT(google-explicit-constructor)
-      : Arg(static_cast<bool>(value)) {}
-
-  // `void*` values, with the exception of `char*`, are printed as
-  // "0x<hex value>". However, in the case of `nullptr`, "NULL" is printed.
-  Arg( // NOLINT(google-explicit-constructor)
-      absl::Nullable<const void *> value);
-
-  // Normal enums are already handled by the integer formatters.
-  // This overload matches only scoped enums.
-  template <typename T,
-            typename = typename std::enable_if<
-                std::is_enum<T>{} && !std::is_convertible<T, int>{} &&
-                !HasAbslStringify<T>::value>::type>
-  Arg(T value) // NOLINT(google-explicit-constructor)
-      : Arg(static_cast<typename std::underlying_type<T>::type>(value)) {}
-
-  Arg(const Arg &) = delete;
-  Arg &operator=(const Arg &) = delete;
-
-  absl::string_view piece() const { return piece_; }
-
-private:
-  absl::string_view piece_;
-  char scratch_[numbers_internal::kFastToBufferSize];
-};
-
-// Internal helper function. Don't call this from outside this implementation.
-// This interface may change without notice.
-void SubstituteAndAppendArray(
-    absl::Nonnull<std::string *> output, absl::string_view format,
-    absl::Nullable<const absl::string_view *> args_array, size_t num_args);
-
-#if defined(ABSL_BAD_CALL_IF)
-constexpr int CalculateOneBit(absl::Nonnull<const char *> format) {
-  // Returns:
-  // * 2^N for '$N' when N is in [0-9]
-  // * 0 for correct '$' escaping: '$$'.
-  // * -1 otherwise.
-  return (*format < '0' || *format > '9') ? (*format == '$' ? 0 : -1)
-                                          : (1 << (*format - '0'));
-}
-
-constexpr const char *SkipNumber(absl::Nonnull<const char *> format) {
-  return !*format ? format : (format + 1);
-}
-
-constexpr int PlaceholderBitmask(absl::Nonnull<const char *> format) {
-  return !*format         ? 0
-         : *format != '$' ? PlaceholderBitmask(format + 1)
-                          : (CalculateOneBit(format + 1) |
-                             PlaceholderBitmask(SkipNumber(format + 1)));
-}
-#endif // ABSL_BAD_CALL_IF
-
-} // namespace substitute_internal
-
-//
-// PUBLIC API
-//
-
-// SubstituteAndAppend()
-//
-// Substitutes variables into a given format string and appends to a given
-// output string. See file comments above for usage.
-//
-// The declarations of `SubstituteAndAppend()` below consist of overloads
-// for passing 0 to 10 arguments, respectively.
-//
-// NOTE: A zero-argument `SubstituteAndAppend()` may be used within variadic
-// templates to allow a variable number of arguments.
-//
-// Example:
-//  template <typename... Args>
-//  void VarMsg(std::string* boilerplate, absl::string_view format,
-//      const Args&... args) {
-//    absl::SubstituteAndAppend(boilerplate, format, args...);
-//  }
-//
-inline void SubstituteAndAppend(absl::Nonnull<std::string *> output,
-                                absl::string_view format) {
-  substitute_internal::SubstituteAndAppendArray(output, format, nullptr, 0);
-}
-
-inline void SubstituteAndAppend(absl::Nonnull<std::string *> output,
-                                absl::string_view format,
-                                const substitute_internal::Arg &a0) {
-  const absl::string_view args[] = {a0.piece()};
-  substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
-}
-
-inline void SubstituteAndAppend(absl::Nonnull<std::string *> output,
-                                absl::string_view format,
-                                const substitute_internal::Arg &a0,
-                                const substitute_internal::Arg &a1) {
-  const absl::string_view args[] = {a0.piece(), a1.piece()};
-  substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
-}
-
-inline void SubstituteAndAppend(absl::Nonnull<std::string *> output,
-                                absl::string_view format,
-                                const substitute_internal::Arg &a0,
-                                const substitute_internal::Arg &a1,
-                                const substitute_internal::Arg &a2) {
-  const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece()};
-  substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
-}
-
-inline void SubstituteAndAppend(absl::Nonnull<std::string *> output,
-                                absl::string_view format,
-                                const substitute_internal::Arg &a0,
-                                const substitute_internal::Arg &a1,
-                                const substitute_internal::Arg &a2,
-                                const substitute_internal::Arg &a3) {
-  const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
-                                    a3.piece()};
-  substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
-}
-
-inline void SubstituteAndAppend(absl::Nonnull<std::string *> output,
-                                absl::string_view format,
-                                const substitute_internal::Arg &a0,
-                                const substitute_internal::Arg &a1,
-                                const substitute_internal::Arg &a2,
-                                const substitute_internal::Arg &a3,
-                                const substitute_internal::Arg &a4) {
-  const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
-                                    a3.piece(), a4.piece()};
-  substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
-}
-
-inline void SubstituteAndAppend(
-    absl::Nonnull<std::string *> output, absl::string_view format,
-    const substitute_internal::Arg &a0, const substitute_internal::Arg &a1,
-    const substitute_internal::Arg &a2, const substitute_internal::Arg &a3,
-    const substitute_internal::Arg &a4, const substitute_internal::Arg &a5) {
-  const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
-                                    a3.piece(), a4.piece(), a5.piece()};
-  substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
-}
-
-inline void SubstituteAndAppend(
-    absl::Nonnull<std::string *> output, absl::string_view format,
-    const substitute_internal::Arg &a0, const substitute_internal::Arg &a1,
-    const substitute_internal::Arg &a2, const substitute_internal::Arg &a3,
-    const substitute_internal::Arg &a4, const substitute_internal::Arg &a5,
-    const substitute_internal::Arg &a6) {
-  const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
-                                    a3.piece(), a4.piece(), a5.piece(),
-                                    a6.piece()};
-  substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
-}
-
-inline void SubstituteAndAppend(
-    absl::Nonnull<std::string *> output, absl::string_view format,
-    const substitute_internal::Arg &a0, const substitute_internal::Arg &a1,
-    const substitute_internal::Arg &a2, const substitute_internal::Arg &a3,
-    const substitute_internal::Arg &a4, const substitute_internal::Arg &a5,
-    const substitute_internal::Arg &a6, const substitute_internal::Arg &a7) {
-  const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
-                                    a3.piece(), a4.piece(), a5.piece(),
-                                    a6.piece(), a7.piece()};
-  substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
-}
-
-inline void SubstituteAndAppend(
-    absl::Nonnull<std::string *> output, absl::string_view format,
-    const substitute_internal::Arg &a0, const substitute_internal::Arg &a1,
-    const substitute_internal::Arg &a2, const substitute_internal::Arg &a3,
-    const substitute_internal::Arg &a4, const substitute_internal::Arg &a5,
-    const substitute_internal::Arg &a6, const substitute_internal::Arg &a7,
-    const substitute_internal::Arg &a8) {
-  const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
-                                    a3.piece(), a4.piece(), a5.piece(),
-                                    a6.piece(), a7.piece(), a8.piece()};
-  substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
-}
-
-inline void SubstituteAndAppend(
-    absl::Nonnull<std::string *> output, absl::string_view format,
-    const substitute_internal::Arg &a0, const substitute_internal::Arg &a1,
-    const substitute_internal::Arg &a2, const substitute_internal::Arg &a3,
-    const substitute_internal::Arg &a4, const substitute_internal::Arg &a5,
-    const substitute_internal::Arg &a6, const substitute_internal::Arg &a7,
-    const substitute_internal::Arg &a8, const substitute_internal::Arg &a9) {
-  const absl::string_view args[] = {
-      a0.piece(), a1.piece(), a2.piece(), a3.piece(), a4.piece(),
-      a5.piece(), a6.piece(), a7.piece(), a8.piece(), a9.piece()};
-  substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
-}
-
-#if defined(ABSL_BAD_CALL_IF)
-// This body of functions catches cases where the number of placeholders
-// doesn't match the number of data arguments.
-void SubstituteAndAppend(absl::Nonnull<std::string *> output,
-                         absl::Nonnull<const char *> format)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 0,
-        "There were no substitution arguments "
-        "but this format string either has a $[0-9] in it or contains "
-        "an unescaped $ character (use $$ instead)");
-
-void SubstituteAndAppend(absl::Nonnull<std::string *> output,
-                         absl::Nonnull<const char *> format,
-                         const substitute_internal::Arg &a0)
-    ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 1,
-                     "There was 1 substitution argument given, but "
-                     "this format string is missing its $0, contains "
-                     "one of $1-$9, or contains an unescaped $ character (use "
-                     "$$ instead)");
-
-void SubstituteAndAppend(absl::Nonnull<std::string *> output,
-                         absl::Nonnull<const char *> format,
-                         const substitute_internal::Arg &a0,
-                         const substitute_internal::Arg &a1)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 3,
-        "There were 2 substitution arguments given, but this format string is "
-        "missing its $0/$1, contains one of $2-$9, or contains an "
-        "unescaped $ character (use $$ instead)");
-
-void SubstituteAndAppend(absl::Nonnull<std::string *> output,
-                         absl::Nonnull<const char *> format,
-                         const substitute_internal::Arg &a0,
-                         const substitute_internal::Arg &a1,
-                         const substitute_internal::Arg &a2)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 7,
-        "There were 3 substitution arguments given, but "
-        "this format string is missing its $0/$1/$2, contains one of "
-        "$3-$9, or contains an unescaped $ character (use $$ instead)");
-
-void SubstituteAndAppend(absl::Nonnull<std::string *> output,
-                         absl::Nonnull<const char *> format,
-                         const substitute_internal::Arg &a0,
-                         const substitute_internal::Arg &a1,
-                         const substitute_internal::Arg &a2,
-                         const substitute_internal::Arg &a3)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 15,
-        "There were 4 substitution arguments given, but "
-        "this format string is missing its $0-$3, contains one of "
-        "$4-$9, or contains an unescaped $ character (use $$ instead)");
-
-void SubstituteAndAppend(absl::Nonnull<std::string *> output,
-                         absl::Nonnull<const char *> format,
-                         const substitute_internal::Arg &a0,
-                         const substitute_internal::Arg &a1,
-                         const substitute_internal::Arg &a2,
-                         const substitute_internal::Arg &a3,
-                         const substitute_internal::Arg &a4)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 31,
-        "There were 5 substitution arguments given, but "
-        "this format string is missing its $0-$4, contains one of "
-        "$5-$9, or contains an unescaped $ character (use $$ instead)");
-
-void SubstituteAndAppend(
-    absl::Nonnull<std::string *> output, absl::Nonnull<const char *> format,
-    const substitute_internal::Arg &a0, const substitute_internal::Arg &a1,
-    const substitute_internal::Arg &a2, const substitute_internal::Arg &a3,
-    const substitute_internal::Arg &a4, const substitute_internal::Arg &a5)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 63,
-        "There were 6 substitution arguments given, but "
-        "this format string is missing its $0-$5, contains one of "
-        "$6-$9, or contains an unescaped $ character (use $$ instead)");
-
-void SubstituteAndAppend(
-    absl::Nonnull<std::string *> output, absl::Nonnull<const char *> format,
-    const substitute_internal::Arg &a0, const substitute_internal::Arg &a1,
-    const substitute_internal::Arg &a2, const substitute_internal::Arg &a3,
-    const substitute_internal::Arg &a4, const substitute_internal::Arg &a5,
-    const substitute_internal::Arg &a6)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 127,
-        "There were 7 substitution arguments given, but "
-        "this format string is missing its $0-$6, contains one of "
-        "$7-$9, or contains an unescaped $ character (use $$ instead)");
-
-void SubstituteAndAppend(
-    absl::Nonnull<std::string *> output, absl::Nonnull<const char *> format,
-    const substitute_internal::Arg &a0, const substitute_internal::Arg &a1,
-    const substitute_internal::Arg &a2, const substitute_internal::Arg &a3,
-    const substitute_internal::Arg &a4, const substitute_internal::Arg &a5,
-    const substitute_internal::Arg &a6, const substitute_internal::Arg &a7)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 255,
-        "There were 8 substitution arguments given, but "
-        "this format string is missing its $0-$7, contains one of "
-        "$8-$9, or contains an unescaped $ character (use $$ instead)");
-
-void SubstituteAndAppend(
-    absl::Nonnull<std::string *> output, absl::Nonnull<const char *> format,
-    const substitute_internal::Arg &a0, const substitute_internal::Arg &a1,
-    const substitute_internal::Arg &a2, const substitute_internal::Arg &a3,
-    const substitute_internal::Arg &a4, const substitute_internal::Arg &a5,
-    const substitute_internal::Arg &a6, const substitute_internal::Arg &a7,
-    const substitute_internal::Arg &a8)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 511,
-        "There were 9 substitution arguments given, but "
-        "this format string is missing its $0-$8, contains a $9, or "
-        "contains an unescaped $ character (use $$ instead)");
-
-void SubstituteAndAppend(
-    absl::Nonnull<std::string *> output, absl::Nonnull<const char *> format,
-    const substitute_internal::Arg &a0, const substitute_internal::Arg &a1,
-    const substitute_internal::Arg &a2, const substitute_internal::Arg &a3,
-    const substitute_internal::Arg &a4, const substitute_internal::Arg &a5,
-    const substitute_internal::Arg &a6, const substitute_internal::Arg &a7,
-    const substitute_internal::Arg &a8, const substitute_internal::Arg &a9)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 1023,
-        "There were 10 substitution arguments given, but this "
-        "format string either doesn't contain all of $0 through $9 or "
-        "contains an unescaped $ character (use $$ instead)");
-#endif // ABSL_BAD_CALL_IF
-
-// Substitute()
-//
-// Substitutes variables into a given format string. See file comments above
-// for usage.
-//
-// The declarations of `Substitute()` below consist of overloads for passing 0
-// to 10 arguments, respectively.
-//
-// NOTE: A zero-argument `Substitute()` may be used within variadic templates to
-// allow a variable number of arguments.
-//
-// Example:
-//  template <typename... Args>
-//  void VarMsg(absl::string_view format, const Args&... args) {
-//    std::string s = absl::Substitute(format, args...);
-
-ABSL_MUST_USE_RESULT inline std::string Substitute(absl::string_view format) {
-  std::string result;
-  SubstituteAndAppend(&result, format);
-  return result;
-}
-
-ABSL_MUST_USE_RESULT inline std::string
-Substitute(absl::string_view format, const substitute_internal::Arg &a0) {
-  std::string result;
-  SubstituteAndAppend(&result, format, a0);
-  return result;
-}
-
-ABSL_MUST_USE_RESULT inline std::string
-Substitute(absl::string_view format, const substitute_internal::Arg &a0,
-           const substitute_internal::Arg &a1) {
-  std::string result;
-  SubstituteAndAppend(&result, format, a0, a1);
-  return result;
-}
-
-ABSL_MUST_USE_RESULT inline std::string
-Substitute(absl::string_view format, const substitute_internal::Arg &a0,
-           const substitute_internal::Arg &a1,
-           const substitute_internal::Arg &a2) {
-  std::string result;
-  SubstituteAndAppend(&result, format, a0, a1, a2);
-  return result;
-}
-
-ABSL_MUST_USE_RESULT inline std::string
-Substitute(absl::string_view format, const substitute_internal::Arg &a0,
-           const substitute_internal::Arg &a1,
-           const substitute_internal::Arg &a2,
-           const substitute_internal::Arg &a3) {
-  std::string result;
-  SubstituteAndAppend(&result, format, a0, a1, a2, a3);
-  return result;
-}
-
-ABSL_MUST_USE_RESULT inline std::string Substitute(
-    absl::string_view format, const substitute_internal::Arg &a0,
-    const substitute_internal::Arg &a1, const substitute_internal::Arg &a2,
-    const substitute_internal::Arg &a3, const substitute_internal::Arg &a4) {
-  std::string result;
-  SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4);
-  return result;
-}
-
-ABSL_MUST_USE_RESULT inline std::string Substitute(
-    absl::string_view format, const substitute_internal::Arg &a0,
-    const substitute_internal::Arg &a1, const substitute_internal::Arg &a2,
-    const substitute_internal::Arg &a3, const substitute_internal::Arg &a4,
-    const substitute_internal::Arg &a5) {
-  std::string result;
-  SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5);
-  return result;
-}
-
-ABSL_MUST_USE_RESULT inline std::string Substitute(
-    absl::string_view format, const substitute_internal::Arg &a0,
-    const substitute_internal::Arg &a1, const substitute_internal::Arg &a2,
-    const substitute_internal::Arg &a3, const substitute_internal::Arg &a4,
-    const substitute_internal::Arg &a5, const substitute_internal::Arg &a6) {
-  std::string result;
-  SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6);
-  return result;
-}
-
-ABSL_MUST_USE_RESULT inline std::string Substitute(
-    absl::string_view format, const substitute_internal::Arg &a0,
-    const substitute_internal::Arg &a1, const substitute_internal::Arg &a2,
-    const substitute_internal::Arg &a3, const substitute_internal::Arg &a4,
-    const substitute_internal::Arg &a5, const substitute_internal::Arg &a6,
-    const substitute_internal::Arg &a7) {
-  std::string result;
-  SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6, a7);
-  return result;
-}
-
-ABSL_MUST_USE_RESULT inline std::string Substitute(
-    absl::string_view format, const substitute_internal::Arg &a0,
-    const substitute_internal::Arg &a1, const substitute_internal::Arg &a2,
-    const substitute_internal::Arg &a3, const substitute_internal::Arg &a4,
-    const substitute_internal::Arg &a5, const substitute_internal::Arg &a6,
-    const substitute_internal::Arg &a7, const substitute_internal::Arg &a8) {
-  std::string result;
-  SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6, a7, a8);
-  return result;
-}
-
-ABSL_MUST_USE_RESULT inline std::string Substitute(
-    absl::string_view format, const substitute_internal::Arg &a0,
-    const substitute_internal::Arg &a1, const substitute_internal::Arg &a2,
-    const substitute_internal::Arg &a3, const substitute_internal::Arg &a4,
-    const substitute_internal::Arg &a5, const substitute_internal::Arg &a6,
-    const substitute_internal::Arg &a7, const substitute_internal::Arg &a8,
-    const substitute_internal::Arg &a9) {
-  std::string result;
-  SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
-  return result;
-}
-
-#if defined(ABSL_BAD_CALL_IF)
-// This body of functions catches cases where the number of placeholders
-// doesn't match the number of data arguments.
-std::string Substitute(absl::Nonnull<const char *> format)
-    ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 0,
-                     "There were no substitution arguments "
-                     "but this format string either has a $[0-9] in it or "
-                     "contains an unescaped $ character (use $$ instead)");
-
-std::string Substitute(absl::Nonnull<const char *> format,
-                       const substitute_internal::Arg &a0)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 1,
-        "There was 1 substitution argument given, but "
-        "this format string is missing its $0, contains one of $1-$9, "
-        "or contains an unescaped $ character (use $$ instead)");
-
-std::string Substitute(absl::Nonnull<const char *> format,
-                       const substitute_internal::Arg &a0,
-                       const substitute_internal::Arg &a1)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 3,
-        "There were 2 substitution arguments given, but "
-        "this format string is missing its $0/$1, contains one of "
-        "$2-$9, or contains an unescaped $ character (use $$ instead)");
-
-std::string Substitute(absl::Nonnull<const char *> format,
-                       const substitute_internal::Arg &a0,
-                       const substitute_internal::Arg &a1,
-                       const substitute_internal::Arg &a2)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 7,
-        "There were 3 substitution arguments given, but "
-        "this format string is missing its $0/$1/$2, contains one of "
-        "$3-$9, or contains an unescaped $ character (use $$ instead)");
-
-std::string Substitute(absl::Nonnull<const char *> format,
-                       const substitute_internal::Arg &a0,
-                       const substitute_internal::Arg &a1,
-                       const substitute_internal::Arg &a2,
-                       const substitute_internal::Arg &a3)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 15,
-        "There were 4 substitution arguments given, but "
-        "this format string is missing its $0-$3, contains one of "
-        "$4-$9, or contains an unescaped $ character (use $$ instead)");
-
-std::string Substitute(absl::Nonnull<const char *> format,
-                       const substitute_internal::Arg &a0,
-                       const substitute_internal::Arg &a1,
-                       const substitute_internal::Arg &a2,
-                       const substitute_internal::Arg &a3,
-                       const substitute_internal::Arg &a4)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 31,
-        "There were 5 substitution arguments given, but "
-        "this format string is missing its $0-$4, contains one of "
-        "$5-$9, or contains an unescaped $ character (use $$ instead)");
-
-std::string Substitute(absl::Nonnull<const char *> format,
-                       const substitute_internal::Arg &a0,
-                       const substitute_internal::Arg &a1,
-                       const substitute_internal::Arg &a2,
-                       const substitute_internal::Arg &a3,
-                       const substitute_internal::Arg &a4,
-                       const substitute_internal::Arg &a5)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 63,
-        "There were 6 substitution arguments given, but "
-        "this format string is missing its $0-$5, contains one of "
-        "$6-$9, or contains an unescaped $ character (use $$ instead)");
-
-std::string Substitute(
-    absl::Nonnull<const char *> format, const substitute_internal::Arg &a0,
-    const substitute_internal::Arg &a1, const substitute_internal::Arg &a2,
-    const substitute_internal::Arg &a3, const substitute_internal::Arg &a4,
-    const substitute_internal::Arg &a5, const substitute_internal::Arg &a6)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 127,
-        "There were 7 substitution arguments given, but "
-        "this format string is missing its $0-$6, contains one of "
-        "$7-$9, or contains an unescaped $ character (use $$ instead)");
-
-std::string Substitute(
-    absl::Nonnull<const char *> format, const substitute_internal::Arg &a0,
-    const substitute_internal::Arg &a1, const substitute_internal::Arg &a2,
-    const substitute_internal::Arg &a3, const substitute_internal::Arg &a4,
-    const substitute_internal::Arg &a5, const substitute_internal::Arg &a6,
-    const substitute_internal::Arg &a7)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 255,
-        "There were 8 substitution arguments given, but "
-        "this format string is missing its $0-$7, contains one of "
-        "$8-$9, or contains an unescaped $ character (use $$ instead)");
-
-std::string Substitute(
-    absl::Nonnull<const char *> format, const substitute_internal::Arg &a0,
-    const substitute_internal::Arg &a1, const substitute_internal::Arg &a2,
-    const substitute_internal::Arg &a3, const substitute_internal::Arg &a4,
-    const substitute_internal::Arg &a5, const substitute_internal::Arg &a6,
-    const substitute_internal::Arg &a7, const substitute_internal::Arg &a8)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 511,
-        "There were 9 substitution arguments given, but "
-        "this format string is missing its $0-$8, contains a $9, or "
-        "contains an unescaped $ character (use $$ instead)");
-
-std::string Substitute(
-    absl::Nonnull<const char *> format, const substitute_internal::Arg &a0,
-    const substitute_internal::Arg &a1, const substitute_internal::Arg &a2,
-    const substitute_internal::Arg &a3, const substitute_internal::Arg &a4,
-    const substitute_internal::Arg &a5, const substitute_internal::Arg &a6,
-    const substitute_internal::Arg &a7, const substitute_internal::Arg &a8,
-    const substitute_internal::Arg &a9)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 1023,
-        "There were 10 substitution arguments given, but this "
-        "format string either doesn't contain all of $0 through $9 or "
-        "contains an unescaped $ character (use $$ instead)");
-#endif // ABSL_BAD_CALL_IF
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_STRINGS_SUBSTITUTE_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/types/any.h b/packages/react-native-executorch/third-party/include/absl/types/any.h
deleted file mode 100644
index 2685fb32ce..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/types/any.h
+++ /dev/null
@@ -1,504 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// any.h
-// -----------------------------------------------------------------------------
-//
-// This header file define the `absl::any` type for holding a type-safe value
-// of any type. The 'absl::any` type is useful for providing a way to hold
-// something that is, as yet, unspecified. Such unspecified types
-// traditionally are passed between API boundaries until they are later cast to
-// their "destination" types. To cast to such a destination type, use
-// `absl::any_cast()`. Note that when casting an `absl::any`, you must cast it
-// to an explicit type; implicit conversions will throw.
-//
-// Example:
-//
-//   auto a = absl::any(65);
-//   absl::any_cast<int>(a);         // 65
-//   absl::any_cast<char>(a);        // throws absl::bad_any_cast
-//   absl::any_cast<std::string>(a); // throws absl::bad_any_cast
-//
-// `absl::any` is a C++11 compatible version of the C++17 `std::any` abstraction
-// and is designed to be a drop-in replacement for code compliant with C++17.
-//
-// Traditionally, the behavior of casting to a temporary unspecified type has
-// been accomplished with the `void *` paradigm, where the pointer was to some
-// other unspecified type. `absl::any` provides an "owning" version of `void *`
-// that avoids issues of pointer management.
-//
-// Note: just as in the case of `void *`, use of `absl::any` (and its C++17
-// version `std::any`) is a code smell indicating that your API might not be
-// constructed correctly. We have seen that most uses of `any` are unwarranted,
-// and `absl::any`, like `std::any`, is difficult to use properly. Before using
-// this abstraction, make sure that you should not instead be rewriting your
-// code to be more specific.
-//
-// Abseil has also released an `absl::variant` type (a C++11 compatible version
-// of the C++17 `std::variant`), which is generally preferred for use over
-// `absl::any`.
-#ifndef ABSL_TYPES_ANY_H_
-#define ABSL_TYPES_ANY_H_
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/utility/utility.h"
-
-#ifdef ABSL_USES_STD_ANY
-
-#include <any> // IWYU pragma: export
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-using std::any;
-using std::any_cast;
-using std::bad_any_cast;
-using std::make_any;
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#else // ABSL_USES_STD_ANY
-
-#include <algorithm>
-#include <cstddef>
-#include <initializer_list>
-#include <memory>
-#include <stdexcept>
-#include <type_traits>
-#include <typeinfo>
-#include <utility>
-
-#include "absl/base/internal/fast_type_id.h"
-#include "absl/meta/type_traits.h"
-#include "absl/types/bad_any_cast.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-class any;
-
-// swap()
-//
-// Swaps two `absl::any` values. Equivalent to `x.swap(y) where `x` and `y` are
-// `absl::any` types.
-void swap(any &x, any &y) noexcept;
-
-// make_any()
-//
-// Constructs an `absl::any` of type `T` with the given arguments.
-template <typename T, typename... Args> any make_any(Args &&...args);
-
-// Overload of `absl::make_any()` for constructing an `absl::any` type from an
-// initializer list.
-template <typename T, typename U, typename... Args>
-any make_any(std::initializer_list<U> il, Args &&...args);
-
-// any_cast()
-//
-// Statically casts the value of a `const absl::any` type to the given type.
-// This function will throw `absl::bad_any_cast` if the stored value type of the
-// `absl::any` does not match the cast.
-//
-// `any_cast()` can also be used to get a reference to the internal storage iff
-// a reference type is passed as its `ValueType`:
-//
-// Example:
-//
-//   absl::any my_any = std::vector<int>();
-//   absl::any_cast<std::vector<int>&>(my_any).push_back(42);
-template <typename ValueType> ValueType any_cast(const any &operand);
-
-// Overload of `any_cast()` to statically cast the value of a non-const
-// `absl::any` type to the given type. This function will throw
-// `absl::bad_any_cast` if the stored value type of the `absl::any` does not
-// match the cast.
-template <typename ValueType>
-ValueType any_cast(any &operand); // NOLINT(runtime/references)
-
-// Overload of `any_cast()` to statically cast the rvalue of an `absl::any`
-// type. This function will throw `absl::bad_any_cast` if the stored value type
-// of the `absl::any` does not match the cast.
-template <typename ValueType> ValueType any_cast(any &&operand);
-
-// Overload of `any_cast()` to statically cast the value of a const pointer
-// `absl::any` type to the given pointer type, or `nullptr` if the stored value
-// type of the `absl::any` does not match the cast.
-template <typename ValueType>
-const ValueType *any_cast(const any *operand) noexcept;
-
-// Overload of `any_cast()` to statically cast the value of a pointer
-// `absl::any` type to the given pointer type, or `nullptr` if the stored value
-// type of the `absl::any` does not match the cast.
-template <typename ValueType> ValueType *any_cast(any *operand) noexcept;
-
-// -----------------------------------------------------------------------------
-// absl::any
-// -----------------------------------------------------------------------------
-//
-// An `absl::any` object provides the facility to either store an instance of a
-// type, known as the "contained object", or no value. An `absl::any` is used to
-// store values of types that are unknown at compile time. The `absl::any`
-// object, when containing a value, must contain a value type; storing a
-// reference type is neither desired nor supported.
-//
-// An `absl::any` can only store a type that is copy-constructible; move-only
-// types are not allowed within an `any` object.
-//
-// Example:
-//
-//   auto a = absl::any(65);                 // Literal, copyable
-//   auto b = absl::any(std::vector<int>()); // Default-initialized, copyable
-//   std::unique_ptr<Foo> my_foo;
-//   auto c = absl::any(std::move(my_foo));  // Error, not copy-constructible
-//
-// Note that `absl::any` makes use of decayed types (`absl::decay_t` in this
-// context) to remove const-volatile qualifiers (known as "cv qualifiers"),
-// decay functions to function pointers, etc. We essentially "decay" a given
-// type into its essential type.
-//
-// `absl::any` makes use of decayed types when determining the basic type `T` of
-// the value to store in the any's contained object. In the documentation below,
-// we explicitly denote this by using the phrase "a decayed type of `T`".
-//
-// Example:
-//
-//   const int a = 4;
-//   absl::any foo(a);  // Decay ensures we store an "int", not a "const int&".
-//
-//   void my_function() {}
-//   absl::any bar(my_function);  // Decay ensures we store a function pointer.
-//
-// `absl::any` is a C++11 compatible version of the C++17 `std::any` abstraction
-// and is designed to be a drop-in replacement for code compliant with C++17.
-class any {
-private:
-  template <typename T> struct IsInPlaceType;
-
-public:
-  // Constructors
-
-  // Constructs an empty `absl::any` object (`any::has_value()` will return
-  // `false`).
-  constexpr any() noexcept;
-
-  // Copy constructs an `absl::any` object with a "contained object" of the
-  // passed type of `other` (or an empty `absl::any` if `other.has_value()` is
-  // `false`.
-  any(const any &other)
-      : obj_(other.has_value() ? other.obj_->Clone()
-                               : std::unique_ptr<ObjInterface>()) {}
-
-  // Move constructs an `absl::any` object with a "contained object" of the
-  // passed type of `other` (or an empty `absl::any` if `other.has_value()` is
-  // `false`).
-  any(any &&other) noexcept = default;
-
-  // Constructs an `absl::any` object with a "contained object" of the decayed
-  // type of `T`, which is initialized via `std::forward<T>(value)`.
-  //
-  // This constructor will not participate in overload resolution if the
-  // decayed type of `T` is not copy-constructible.
-  template <
-      typename T, typename VT = absl::decay_t<T>,
-      absl::enable_if_t<!absl::disjunction<
-          std::is_same<any, VT>, IsInPlaceType<VT>,
-          absl::negation<std::is_copy_constructible<VT>>>::value> * = nullptr>
-  any(T &&value) : obj_(new Obj<VT>(in_place, std::forward<T>(value))) {}
-
-  // Constructs an `absl::any` object with a "contained object" of the decayed
-  // type of `T`, which is initialized via `std::forward<T>(value)`.
-  template <typename T, typename... Args, typename VT = absl::decay_t<T>,
-            absl::enable_if_t<absl::conjunction<
-                std::is_copy_constructible<VT>,
-                std::is_constructible<VT, Args...>>::value> * = nullptr>
-  explicit any(in_place_type_t<T> /*tag*/, Args &&...args)
-      : obj_(new Obj<VT>(in_place, std::forward<Args>(args)...)) {}
-
-  // Constructs an `absl::any` object with a "contained object" of the passed
-  // type `VT` as a decayed type of `T`. `VT` is initialized as if
-  // direct-non-list-initializing an object of type `VT` with the arguments
-  // `initializer_list, std::forward<Args>(args)...`.
-  template <typename T, typename U, typename... Args,
-            typename VT = absl::decay_t<T>,
-            absl::enable_if_t<absl::conjunction<
-                std::is_copy_constructible<VT>,
-                std::is_constructible<VT, std::initializer_list<U> &,
-                                      Args...>>::value> * = nullptr>
-  explicit any(in_place_type_t<T> /*tag*/, std::initializer_list<U> ilist,
-               Args &&...args)
-      : obj_(new Obj<VT>(in_place, ilist, std::forward<Args>(args)...)) {}
-
-  // Assignment operators
-
-  // Copy assigns an `absl::any` object with a "contained object" of the
-  // passed type.
-  any &operator=(const any &rhs) {
-    any(rhs).swap(*this);
-    return *this;
-  }
-
-  // Move assigns an `absl::any` object with a "contained object" of the
-  // passed type. `rhs` is left in a valid but otherwise unspecified state.
-  any &operator=(any &&rhs) noexcept {
-    any(std::move(rhs)).swap(*this);
-    return *this;
-  }
-
-  // Assigns an `absl::any` object with a "contained object" of the passed type.
-  template <typename T, typename VT = absl::decay_t<T>,
-            absl::enable_if_t<absl::conjunction<
-                absl::negation<std::is_same<VT, any>>,
-                std::is_copy_constructible<VT>>::value> * = nullptr>
-  any &operator=(T &&rhs) {
-    any tmp(in_place_type_t<VT>(), std::forward<T>(rhs));
-    tmp.swap(*this);
-    return *this;
-  }
-
-  // Modifiers
-
-  // any::emplace()
-  //
-  // Emplaces a value within an `absl::any` object by calling `any::reset()`,
-  // initializing the contained value as if direct-non-list-initializing an
-  // object of type `VT` with the arguments `std::forward<Args>(args)...`, and
-  // returning a reference to the new contained value.
-  //
-  // Note: If an exception is thrown during the call to `VT`'s constructor,
-  // `*this` does not contain a value, and any previously contained value has
-  // been destroyed.
-  template <
-      typename T, typename... Args, typename VT = absl::decay_t<T>,
-      absl::enable_if_t<std::is_copy_constructible<VT>::value &&
-                        std::is_constructible<VT, Args...>::value> * = nullptr>
-  VT &emplace(Args &&...args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    reset(); // NOTE: reset() is required here even in the world of exceptions.
-    Obj<VT> *const object_ptr =
-        new Obj<VT>(in_place, std::forward<Args>(args)...);
-    obj_ = std::unique_ptr<ObjInterface>(object_ptr);
-    return object_ptr->value;
-  }
-
-  // Overload of `any::emplace()` to emplace a value within an `absl::any`
-  // object by calling `any::reset()`, initializing the contained value as if
-  // direct-non-list-initializing an object of type `VT` with the arguments
-  // `initializer_list, std::forward<Args>(args)...`, and returning a reference
-  // to the new contained value.
-  //
-  // Note: If an exception is thrown during the call to `VT`'s constructor,
-  // `*this` does not contain a value, and any previously contained value has
-  // been destroyed. The function shall not participate in overload resolution
-  // unless `is_copy_constructible_v<VT>` is `true` and
-  // `is_constructible_v<VT, initializer_list<U>&, Args...>` is `true`.
-  template <
-      typename T, typename U, typename... Args, typename VT = absl::decay_t<T>,
-      absl::enable_if_t<std::is_copy_constructible<VT>::value &&
-                        std::is_constructible<VT, std::initializer_list<U> &,
-                                              Args...>::value> * = nullptr>
-  VT &emplace(std::initializer_list<U> ilist,
-              Args &&...args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    reset(); // NOTE: reset() is required here even in the world of exceptions.
-    Obj<VT> *const object_ptr =
-        new Obj<VT>(in_place, ilist, std::forward<Args>(args)...);
-    obj_ = std::unique_ptr<ObjInterface>(object_ptr);
-    return object_ptr->value;
-  }
-
-  // any::reset()
-  //
-  // Resets the state of the `absl::any` object, destroying the contained object
-  // if present.
-  void reset() noexcept { obj_ = nullptr; }
-
-  // any::swap()
-  //
-  // Swaps the passed value and the value of this `absl::any` object.
-  void swap(any &other) noexcept { obj_.swap(other.obj_); }
-
-  // Observers
-
-  // any::has_value()
-  //
-  // Returns `true` if the `any` object has a contained value, otherwise
-  // returns `false`.
-  bool has_value() const noexcept { return obj_ != nullptr; }
-
-#ifdef ABSL_INTERNAL_HAS_RTTI
-  // Returns: typeid(T) if *this has a contained object of type T, otherwise
-  // typeid(void).
-  const std::type_info &type() const noexcept {
-    if (has_value()) {
-      return obj_->Type();
-    }
-
-    return typeid(void);
-  }
-#endif // ABSL_INTERNAL_HAS_RTTI
-
-private:
-  // Tagged type-erased abstraction for holding a cloneable object.
-  class ObjInterface {
-  public:
-    virtual ~ObjInterface() = default;
-    virtual std::unique_ptr<ObjInterface> Clone() const = 0;
-    virtual const void *ObjTypeId() const noexcept = 0;
-#ifdef ABSL_INTERNAL_HAS_RTTI
-    virtual const std::type_info &Type() const noexcept = 0;
-#endif // ABSL_INTERNAL_HAS_RTTI
-  };
-
-  // Hold a value of some queryable type, with an ability to Clone it.
-  template <typename T> class Obj : public ObjInterface {
-  public:
-    template <typename... Args>
-    explicit Obj(in_place_t /*tag*/, Args &&...args)
-        : value(std::forward<Args>(args)...) {}
-
-    std::unique_ptr<ObjInterface> Clone() const final {
-      return std::unique_ptr<ObjInterface>(new Obj(in_place, value));
-    }
-
-    const void *ObjTypeId() const noexcept final { return IdForType<T>(); }
-
-#ifdef ABSL_INTERNAL_HAS_RTTI
-    const std::type_info &Type() const noexcept final { return typeid(T); }
-#endif // ABSL_INTERNAL_HAS_RTTI
-
-    T value;
-  };
-
-  std::unique_ptr<ObjInterface> CloneObj() const {
-    if (!obj_)
-      return nullptr;
-    return obj_->Clone();
-  }
-
-  template <typename T> constexpr static const void *IdForType() {
-    // Note: This type dance is to make the behavior consistent with typeid.
-    using NormalizedType =
-        typename std::remove_cv<typename std::remove_reference<T>::type>::type;
-
-    return base_internal::FastTypeId<NormalizedType>();
-  }
-
-  const void *GetObjTypeId() const {
-    return obj_ ? obj_->ObjTypeId() : base_internal::FastTypeId<void>();
-  }
-
-  // `absl::any` nonmember functions //
-
-  // Description at the declaration site (top of file).
-  template <typename ValueType> friend ValueType any_cast(const any &operand);
-
-  // Description at the declaration site (top of file).
-  template <typename ValueType>
-  friend ValueType any_cast(any &operand); // NOLINT(runtime/references)
-
-  // Description at the declaration site (top of file).
-  template <typename T> friend const T *any_cast(const any *operand) noexcept;
-
-  // Description at the declaration site (top of file).
-  template <typename T> friend T *any_cast(any *operand) noexcept;
-
-  std::unique_ptr<ObjInterface> obj_;
-};
-
-// -----------------------------------------------------------------------------
-// Implementation Details
-// -----------------------------------------------------------------------------
-
-constexpr any::any() noexcept = default;
-
-template <typename T> struct any::IsInPlaceType : std::false_type {};
-
-template <typename T>
-struct any::IsInPlaceType<in_place_type_t<T>> : std::true_type {};
-
-inline void swap(any &x, any &y) noexcept { x.swap(y); }
-
-// Description at the declaration site (top of file).
-template <typename T, typename... Args> any make_any(Args &&...args) {
-  return any(in_place_type_t<T>(), std::forward<Args>(args)...);
-}
-
-// Description at the declaration site (top of file).
-template <typename T, typename U, typename... Args>
-any make_any(std::initializer_list<U> il, Args &&...args) {
-  return any(in_place_type_t<T>(), il, std::forward<Args>(args)...);
-}
-
-// Description at the declaration site (top of file).
-template <typename ValueType> ValueType any_cast(const any &operand) {
-  using U = typename std::remove_cv<
-      typename std::remove_reference<ValueType>::type>::type;
-  static_assert(std::is_constructible<ValueType, const U &>::value,
-                "Invalid ValueType");
-  auto *const result = (any_cast<U>)(&operand);
-  if (result == nullptr) {
-    any_internal::ThrowBadAnyCast();
-  }
-  return static_cast<ValueType>(*result);
-}
-
-// Description at the declaration site (top of file).
-template <typename ValueType>
-ValueType any_cast(any &operand) { // NOLINT(runtime/references)
-  using U = typename std::remove_cv<
-      typename std::remove_reference<ValueType>::type>::type;
-  static_assert(std::is_constructible<ValueType, U &>::value,
-                "Invalid ValueType");
-  auto *result = (any_cast<U>)(&operand);
-  if (result == nullptr) {
-    any_internal::ThrowBadAnyCast();
-  }
-  return static_cast<ValueType>(*result);
-}
-
-// Description at the declaration site (top of file).
-template <typename ValueType> ValueType any_cast(any &&operand) {
-  using U = typename std::remove_cv<
-      typename std::remove_reference<ValueType>::type>::type;
-  static_assert(std::is_constructible<ValueType, U>::value,
-                "Invalid ValueType");
-  return static_cast<ValueType>(std::move((any_cast<U &>)(operand)));
-}
-
-// Description at the declaration site (top of file).
-template <typename T> const T *any_cast(const any *operand) noexcept {
-  using U =
-      typename std::remove_cv<typename std::remove_reference<T>::type>::type;
-  return operand && operand->GetObjTypeId() == any::IdForType<U>()
-             ? std::addressof(
-                   static_cast<const any::Obj<U> *>(operand->obj_.get())->value)
-             : nullptr;
-}
-
-// Description at the declaration site (top of file).
-template <typename T> T *any_cast(any *operand) noexcept {
-  using U =
-      typename std::remove_cv<typename std::remove_reference<T>::type>::type;
-  return operand && operand->GetObjTypeId() == any::IdForType<U>()
-             ? std::addressof(
-                   static_cast<any::Obj<U> *>(operand->obj_.get())->value)
-             : nullptr;
-}
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_USES_STD_ANY
-
-#endif // ABSL_TYPES_ANY_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/types/bad_any_cast.h b/packages/react-native-executorch/third-party/include/absl/types/bad_any_cast.h
deleted file mode 100644
index c48d946f50..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/types/bad_any_cast.h
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// bad_any_cast.h
-// -----------------------------------------------------------------------------
-//
-// This header file defines the `absl::bad_any_cast` type.
-
-#ifndef ABSL_TYPES_BAD_ANY_CAST_H_
-#define ABSL_TYPES_BAD_ANY_CAST_H_
-
-#include <typeinfo>
-
-#include "absl/base/config.h"
-
-#ifdef ABSL_USES_STD_ANY
-
-#include <any>
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-using std::bad_any_cast;
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#else // ABSL_USES_STD_ANY
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// -----------------------------------------------------------------------------
-// bad_any_cast
-// -----------------------------------------------------------------------------
-//
-// An `absl::bad_any_cast` type is an exception type that is thrown when
-// failing to successfully cast the return value of an `absl::any` object.
-//
-// Example:
-//
-//   auto a = absl::any(65);
-//   absl::any_cast<int>(a);         // 65
-//   try {
-//     absl::any_cast<char>(a);
-//   } catch(const absl::bad_any_cast& e) {
-//     std::cout << "Bad any cast: " << e.what() << '\n';
-//   }
-class bad_any_cast : public std::bad_cast {
-public:
-  ~bad_any_cast() override;
-  const char *what() const noexcept override;
-};
-
-namespace any_internal {
-
-[[noreturn]] void ThrowBadAnyCast();
-
-} // namespace any_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_USES_STD_ANY
-
-#endif // ABSL_TYPES_BAD_ANY_CAST_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/types/bad_optional_access.h b/packages/react-native-executorch/third-party/include/absl/types/bad_optional_access.h
deleted file mode 100644
index b3e5fb6bf9..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/types/bad_optional_access.h
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// bad_optional_access.h
-// -----------------------------------------------------------------------------
-//
-// This header file defines the `absl::bad_optional_access` type.
-
-#ifndef ABSL_TYPES_BAD_OPTIONAL_ACCESS_H_
-#define ABSL_TYPES_BAD_OPTIONAL_ACCESS_H_
-
-#include <stdexcept>
-
-#include "absl/base/config.h"
-
-#ifdef ABSL_USES_STD_OPTIONAL
-
-#include <optional>
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-using std::bad_optional_access;
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#else // ABSL_USES_STD_OPTIONAL
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// -----------------------------------------------------------------------------
-// bad_optional_access
-// -----------------------------------------------------------------------------
-//
-// An `absl::bad_optional_access` type is an exception type that is thrown when
-// attempting to access an `absl::optional` object that does not contain a
-// value.
-//
-// Example:
-//
-//   absl::optional<int> o;
-//
-//   try {
-//     int n = o.value();
-//   } catch(const absl::bad_optional_access& e) {
-//     std::cout << "Bad optional access: " << e.what() << '\n';
-//   }
-class bad_optional_access : public std::exception {
-public:
-  bad_optional_access() = default;
-  ~bad_optional_access() override;
-  const char *what() const noexcept override;
-};
-
-namespace optional_internal {
-
-// throw delegator
-[[noreturn]] ABSL_DLL void throw_bad_optional_access();
-
-} // namespace optional_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_USES_STD_OPTIONAL
-
-#endif // ABSL_TYPES_BAD_OPTIONAL_ACCESS_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/types/bad_variant_access.h b/packages/react-native-executorch/third-party/include/absl/types/bad_variant_access.h
deleted file mode 100644
index 762e46a92e..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/types/bad_variant_access.h
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// bad_variant_access.h
-// -----------------------------------------------------------------------------
-//
-// This header file defines the `absl::bad_variant_access` type.
-
-#ifndef ABSL_TYPES_BAD_VARIANT_ACCESS_H_
-#define ABSL_TYPES_BAD_VARIANT_ACCESS_H_
-
-#include <stdexcept>
-
-#include "absl/base/config.h"
-
-#ifdef ABSL_USES_STD_VARIANT
-
-#include <variant>
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-using std::bad_variant_access;
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#else // ABSL_USES_STD_VARIANT
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// -----------------------------------------------------------------------------
-// bad_variant_access
-// -----------------------------------------------------------------------------
-//
-// An `absl::bad_variant_access` type is an exception type that is thrown in
-// the following cases:
-//
-//   * Calling `absl::get(absl::variant) with an index or type that does not
-//     match the currently selected alternative type
-//   * Calling `absl::visit on an `absl::variant` that is in the
-//     `variant::valueless_by_exception` state.
-//
-// Example:
-//
-//   absl::variant<int, std::string> v;
-//   v = 1;
-//   try {
-//     absl::get<std::string>(v);
-//   } catch(const absl::bad_variant_access& e) {
-//     std::cout << "Bad variant access: " << e.what() << '\n';
-//   }
-class bad_variant_access : public std::exception {
-public:
-  bad_variant_access() noexcept = default;
-  ~bad_variant_access() override;
-  const char *what() const noexcept override;
-};
-
-namespace variant_internal {
-
-[[noreturn]] ABSL_DLL void ThrowBadVariantAccess();
-[[noreturn]] ABSL_DLL void Rethrow();
-
-} // namespace variant_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_USES_STD_VARIANT
-
-#endif // ABSL_TYPES_BAD_VARIANT_ACCESS_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/types/compare.h b/packages/react-native-executorch/third-party/include/absl/types/compare.h
deleted file mode 100644
index a6a5ed8ff8..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/types/compare.h
+++ /dev/null
@@ -1,502 +0,0 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// compare.h
-// -----------------------------------------------------------------------------
-//
-// This header file defines the `absl::partial_ordering`, `absl::weak_ordering`,
-// and `absl::strong_ordering` types for storing the results of three way
-// comparisons.
-//
-// Example:
-//   absl::weak_ordering compare(const std::string& a, const std::string& b);
-//
-// These are C++11 compatible versions of the C++20 corresponding types
-// (`std::partial_ordering`, etc.) and are designed to be drop-in replacements
-// for code compliant with C++20.
-
-#ifndef ABSL_TYPES_COMPARE_H_
-#define ABSL_TYPES_COMPARE_H_
-
-#include "absl/base/config.h"
-
-#ifdef ABSL_USES_STD_ORDERING
-
-#include <compare> // IWYU pragma: export
-#include <type_traits>
-
-#include "absl/meta/type_traits.h"
-
-#else
-
-#include <cstddef>
-#include <cstdint>
-#include <cstdlib>
-#include <type_traits>
-
-#include "absl/base/attributes.h"
-#include "absl/base/macros.h"
-#include "absl/meta/type_traits.h"
-
-#endif
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-#ifdef ABSL_USES_STD_ORDERING
-
-using std::partial_ordering;
-using std::strong_ordering;
-using std::weak_ordering;
-
-#else
-
-namespace compare_internal {
-
-using value_type = int8_t;
-
-class OnlyLiteralZero {
-public:
-#if ABSL_HAVE_ATTRIBUTE(enable_if)
-  // On clang, we can avoid triggering modernize-use-nullptr by only enabling
-  // this overload when the value is a compile time integer constant equal to 0.
-  //
-  // In c++20, this could be a static_assert in a consteval function.
-  constexpr OnlyLiteralZero(int n) // NOLINT
-      __attribute__((enable_if(n == 0, "Only literal `0` is allowed."))) {}
-#else // ABSL_HAVE_ATTRIBUTE(enable_if)
-  // Accept only literal zero since it can be implicitly converted to a pointer
-  // to member type. nullptr constants will be caught by the other constructor
-  // which accepts a nullptr_t.
-  //
-  // This constructor is not used for clang since it triggers
-  // modernize-use-nullptr.
-  constexpr OnlyLiteralZero(int OnlyLiteralZero::*) noexcept {} // NOLINT
-#endif
-
-  // Fails compilation when `nullptr` or integral type arguments other than
-  // `int` are passed. This constructor doesn't accept `int` because literal `0`
-  // has type `int`. Literal `0` arguments will be implicitly converted to
-  // `std::nullptr_t` and accepted by the above constructor, while other `int`
-  // arguments will fail to be converted and cause compilation failure.
-  template <typename T, typename = typename std::enable_if<
-                            std::is_same<T, std::nullptr_t>::value ||
-                            (std::is_integral<T>::value &&
-                             !std::is_same<T, int>::value)>::type>
-  OnlyLiteralZero(T) { // NOLINT
-    static_assert(sizeof(T) < 0, "Only literal `0` is allowed.");
-  }
-};
-
-enum class eq : value_type {
-  equal = 0,
-  equivalent = equal,
-  nonequal = 1,
-  nonequivalent = nonequal,
-};
-
-enum class ord : value_type { less = -1, greater = 1 };
-
-enum class ncmp : value_type { unordered = -127 };
-
-// Define macros to allow for creation or emulation of C++17 inline variables
-// based on whether the feature is supported. Note: we can't use
-// ABSL_INTERNAL_INLINE_CONSTEXPR here because the variables here are of
-// incomplete types so they need to be defined after the types are complete.
-#ifdef __cpp_inline_variables
-
-// A no-op expansion that can be followed by a semicolon at class level.
-#define ABSL_COMPARE_INLINE_BASECLASS_DECL(name) static_assert(true, "")
-
-#define ABSL_COMPARE_INLINE_SUBCLASS_DECL(type, name) static const type name
-
-#define ABSL_COMPARE_INLINE_INIT(type, name, init)                             \
-  inline constexpr type type::name(init)
-
-#else // __cpp_inline_variables
-
-#define ABSL_COMPARE_INLINE_BASECLASS_DECL(name)                               \
-  ABSL_CONST_INIT static const T name
-
-// A no-op expansion that can be followed by a semicolon at class level.
-#define ABSL_COMPARE_INLINE_SUBCLASS_DECL(type, name) static_assert(true, "")
-
-#define ABSL_COMPARE_INLINE_INIT(type, name, init)                             \
-  template <typename T> const T compare_internal::type##_base<T>::name(init)
-
-#endif // __cpp_inline_variables
-
-// These template base classes allow for defining the values of the constants
-// in the header file (for performance) without using inline variables (which
-// aren't available in C++11).
-template <typename T> struct partial_ordering_base {
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(less);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(greater);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(unordered);
-};
-
-template <typename T> struct weak_ordering_base {
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(less);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(greater);
-};
-
-template <typename T> struct strong_ordering_base {
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(less);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(equal);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(greater);
-};
-
-} // namespace compare_internal
-
-class partial_ordering
-    : public compare_internal::partial_ordering_base<partial_ordering> {
-  explicit constexpr partial_ordering(compare_internal::eq v) noexcept
-      : value_(static_cast<compare_internal::value_type>(v)) {}
-  explicit constexpr partial_ordering(compare_internal::ord v) noexcept
-      : value_(static_cast<compare_internal::value_type>(v)) {}
-  explicit constexpr partial_ordering(compare_internal::ncmp v) noexcept
-      : value_(static_cast<compare_internal::value_type>(v)) {}
-  friend struct compare_internal::partial_ordering_base<partial_ordering>;
-
-  constexpr bool is_ordered() const noexcept {
-    return value_ !=
-           compare_internal::value_type(compare_internal::ncmp::unordered);
-  }
-
-public:
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, less);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, equivalent);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, greater);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, unordered);
-
-  // Comparisons
-  friend constexpr bool operator==(partial_ordering v,
-                                   compare_internal::OnlyLiteralZero) noexcept {
-    return v.is_ordered() && v.value_ == 0;
-  }
-  friend constexpr bool operator!=(partial_ordering v,
-                                   compare_internal::OnlyLiteralZero) noexcept {
-    return !v.is_ordered() || v.value_ != 0;
-  }
-  friend constexpr bool operator<(partial_ordering v,
-                                  compare_internal::OnlyLiteralZero) noexcept {
-    return v.is_ordered() && v.value_ < 0;
-  }
-  friend constexpr bool operator<=(partial_ordering v,
-                                   compare_internal::OnlyLiteralZero) noexcept {
-    return v.is_ordered() && v.value_ <= 0;
-  }
-  friend constexpr bool operator>(partial_ordering v,
-                                  compare_internal::OnlyLiteralZero) noexcept {
-    return v.is_ordered() && v.value_ > 0;
-  }
-  friend constexpr bool operator>=(partial_ordering v,
-                                   compare_internal::OnlyLiteralZero) noexcept {
-    return v.is_ordered() && v.value_ >= 0;
-  }
-  friend constexpr bool operator==(compare_internal::OnlyLiteralZero,
-                                   partial_ordering v) noexcept {
-    return v.is_ordered() && 0 == v.value_;
-  }
-  friend constexpr bool operator!=(compare_internal::OnlyLiteralZero,
-                                   partial_ordering v) noexcept {
-    return !v.is_ordered() || 0 != v.value_;
-  }
-  friend constexpr bool operator<(compare_internal::OnlyLiteralZero,
-                                  partial_ordering v) noexcept {
-    return v.is_ordered() && 0 < v.value_;
-  }
-  friend constexpr bool operator<=(compare_internal::OnlyLiteralZero,
-                                   partial_ordering v) noexcept {
-    return v.is_ordered() && 0 <= v.value_;
-  }
-  friend constexpr bool operator>(compare_internal::OnlyLiteralZero,
-                                  partial_ordering v) noexcept {
-    return v.is_ordered() && 0 > v.value_;
-  }
-  friend constexpr bool operator>=(compare_internal::OnlyLiteralZero,
-                                   partial_ordering v) noexcept {
-    return v.is_ordered() && 0 >= v.value_;
-  }
-  friend constexpr bool operator==(partial_ordering v1,
-                                   partial_ordering v2) noexcept {
-    return v1.value_ == v2.value_;
-  }
-  friend constexpr bool operator!=(partial_ordering v1,
-                                   partial_ordering v2) noexcept {
-    return v1.value_ != v2.value_;
-  }
-
-private:
-  compare_internal::value_type value_;
-};
-ABSL_COMPARE_INLINE_INIT(partial_ordering, less, compare_internal::ord::less);
-ABSL_COMPARE_INLINE_INIT(partial_ordering, equivalent,
-                         compare_internal::eq::equivalent);
-ABSL_COMPARE_INLINE_INIT(partial_ordering, greater,
-                         compare_internal::ord::greater);
-ABSL_COMPARE_INLINE_INIT(partial_ordering, unordered,
-                         compare_internal::ncmp::unordered);
-
-class weak_ordering
-    : public compare_internal::weak_ordering_base<weak_ordering> {
-  explicit constexpr weak_ordering(compare_internal::eq v) noexcept
-      : value_(static_cast<compare_internal::value_type>(v)) {}
-  explicit constexpr weak_ordering(compare_internal::ord v) noexcept
-      : value_(static_cast<compare_internal::value_type>(v)) {}
-  friend struct compare_internal::weak_ordering_base<weak_ordering>;
-
-public:
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, less);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, equivalent);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, greater);
-
-  // Conversions
-  constexpr operator partial_ordering() const noexcept { // NOLINT
-    return value_ == 0 ? partial_ordering::equivalent
-                       : (value_ < 0 ? partial_ordering::less
-                                     : partial_ordering::greater);
-  }
-  // Comparisons
-  friend constexpr bool operator==(weak_ordering v,
-                                   compare_internal::OnlyLiteralZero) noexcept {
-    return v.value_ == 0;
-  }
-  friend constexpr bool operator!=(weak_ordering v,
-                                   compare_internal::OnlyLiteralZero) noexcept {
-    return v.value_ != 0;
-  }
-  friend constexpr bool operator<(weak_ordering v,
-                                  compare_internal::OnlyLiteralZero) noexcept {
-    return v.value_ < 0;
-  }
-  friend constexpr bool operator<=(weak_ordering v,
-                                   compare_internal::OnlyLiteralZero) noexcept {
-    return v.value_ <= 0;
-  }
-  friend constexpr bool operator>(weak_ordering v,
-                                  compare_internal::OnlyLiteralZero) noexcept {
-    return v.value_ > 0;
-  }
-  friend constexpr bool operator>=(weak_ordering v,
-                                   compare_internal::OnlyLiteralZero) noexcept {
-    return v.value_ >= 0;
-  }
-  friend constexpr bool operator==(compare_internal::OnlyLiteralZero,
-                                   weak_ordering v) noexcept {
-    return 0 == v.value_;
-  }
-  friend constexpr bool operator!=(compare_internal::OnlyLiteralZero,
-                                   weak_ordering v) noexcept {
-    return 0 != v.value_;
-  }
-  friend constexpr bool operator<(compare_internal::OnlyLiteralZero,
-                                  weak_ordering v) noexcept {
-    return 0 < v.value_;
-  }
-  friend constexpr bool operator<=(compare_internal::OnlyLiteralZero,
-                                   weak_ordering v) noexcept {
-    return 0 <= v.value_;
-  }
-  friend constexpr bool operator>(compare_internal::OnlyLiteralZero,
-                                  weak_ordering v) noexcept {
-    return 0 > v.value_;
-  }
-  friend constexpr bool operator>=(compare_internal::OnlyLiteralZero,
-                                   weak_ordering v) noexcept {
-    return 0 >= v.value_;
-  }
-  friend constexpr bool operator==(weak_ordering v1,
-                                   weak_ordering v2) noexcept {
-    return v1.value_ == v2.value_;
-  }
-  friend constexpr bool operator!=(weak_ordering v1,
-                                   weak_ordering v2) noexcept {
-    return v1.value_ != v2.value_;
-  }
-
-private:
-  compare_internal::value_type value_;
-};
-ABSL_COMPARE_INLINE_INIT(weak_ordering, less, compare_internal::ord::less);
-ABSL_COMPARE_INLINE_INIT(weak_ordering, equivalent,
-                         compare_internal::eq::equivalent);
-ABSL_COMPARE_INLINE_INIT(weak_ordering, greater,
-                         compare_internal::ord::greater);
-
-class strong_ordering
-    : public compare_internal::strong_ordering_base<strong_ordering> {
-  explicit constexpr strong_ordering(compare_internal::eq v) noexcept
-      : value_(static_cast<compare_internal::value_type>(v)) {}
-  explicit constexpr strong_ordering(compare_internal::ord v) noexcept
-      : value_(static_cast<compare_internal::value_type>(v)) {}
-  friend struct compare_internal::strong_ordering_base<strong_ordering>;
-
-public:
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, less);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, equal);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, equivalent);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, greater);
-
-  // Conversions
-  constexpr operator partial_ordering() const noexcept { // NOLINT
-    return value_ == 0 ? partial_ordering::equivalent
-                       : (value_ < 0 ? partial_ordering::less
-                                     : partial_ordering::greater);
-  }
-  constexpr operator weak_ordering() const noexcept { // NOLINT
-    return value_ == 0
-               ? weak_ordering::equivalent
-               : (value_ < 0 ? weak_ordering::less : weak_ordering::greater);
-  }
-  // Comparisons
-  friend constexpr bool operator==(strong_ordering v,
-                                   compare_internal::OnlyLiteralZero) noexcept {
-    return v.value_ == 0;
-  }
-  friend constexpr bool operator!=(strong_ordering v,
-                                   compare_internal::OnlyLiteralZero) noexcept {
-    return v.value_ != 0;
-  }
-  friend constexpr bool operator<(strong_ordering v,
-                                  compare_internal::OnlyLiteralZero) noexcept {
-    return v.value_ < 0;
-  }
-  friend constexpr bool operator<=(strong_ordering v,
-                                   compare_internal::OnlyLiteralZero) noexcept {
-    return v.value_ <= 0;
-  }
-  friend constexpr bool operator>(strong_ordering v,
-                                  compare_internal::OnlyLiteralZero) noexcept {
-    return v.value_ > 0;
-  }
-  friend constexpr bool operator>=(strong_ordering v,
-                                   compare_internal::OnlyLiteralZero) noexcept {
-    return v.value_ >= 0;
-  }
-  friend constexpr bool operator==(compare_internal::OnlyLiteralZero,
-                                   strong_ordering v) noexcept {
-    return 0 == v.value_;
-  }
-  friend constexpr bool operator!=(compare_internal::OnlyLiteralZero,
-                                   strong_ordering v) noexcept {
-    return 0 != v.value_;
-  }
-  friend constexpr bool operator<(compare_internal::OnlyLiteralZero,
-                                  strong_ordering v) noexcept {
-    return 0 < v.value_;
-  }
-  friend constexpr bool operator<=(compare_internal::OnlyLiteralZero,
-                                   strong_ordering v) noexcept {
-    return 0 <= v.value_;
-  }
-  friend constexpr bool operator>(compare_internal::OnlyLiteralZero,
-                                  strong_ordering v) noexcept {
-    return 0 > v.value_;
-  }
-  friend constexpr bool operator>=(compare_internal::OnlyLiteralZero,
-                                   strong_ordering v) noexcept {
-    return 0 >= v.value_;
-  }
-  friend constexpr bool operator==(strong_ordering v1,
-                                   strong_ordering v2) noexcept {
-    return v1.value_ == v2.value_;
-  }
-  friend constexpr bool operator!=(strong_ordering v1,
-                                   strong_ordering v2) noexcept {
-    return v1.value_ != v2.value_;
-  }
-
-private:
-  compare_internal::value_type value_;
-};
-ABSL_COMPARE_INLINE_INIT(strong_ordering, less, compare_internal::ord::less);
-ABSL_COMPARE_INLINE_INIT(strong_ordering, equal, compare_internal::eq::equal);
-ABSL_COMPARE_INLINE_INIT(strong_ordering, equivalent,
-                         compare_internal::eq::equivalent);
-ABSL_COMPARE_INLINE_INIT(strong_ordering, greater,
-                         compare_internal::ord::greater);
-
-#undef ABSL_COMPARE_INLINE_BASECLASS_DECL
-#undef ABSL_COMPARE_INLINE_SUBCLASS_DECL
-#undef ABSL_COMPARE_INLINE_INIT
-
-#endif // ABSL_USES_STD_ORDERING
-
-namespace compare_internal {
-// We also provide these comparator adapter functions for internal absl use.
-
-// Helper functions to do a boolean comparison of two keys given a boolean
-// or three-way comparator.
-// SFINAE prevents implicit conversions to bool (such as from int).
-template <typename BoolT,
-          absl::enable_if_t<std::is_same<bool, BoolT>::value, int> = 0>
-constexpr bool compare_result_as_less_than(const BoolT r) {
-  return r;
-}
-constexpr bool compare_result_as_less_than(const absl::weak_ordering r) {
-  return r < 0;
-}
-
-template <typename Compare, typename K, typename LK>
-constexpr bool do_less_than_comparison(const Compare &compare, const K &x,
-                                       const LK &y) {
-  return compare_result_as_less_than(compare(x, y));
-}
-
-// Helper functions to do a three-way comparison of two keys given a boolean or
-// three-way comparator.
-// SFINAE prevents implicit conversions to int (such as from bool).
-template <typename Int,
-          absl::enable_if_t<std::is_same<int, Int>::value, int> = 0>
-constexpr absl::weak_ordering compare_result_as_ordering(const Int c) {
-  return c < 0    ? absl::weak_ordering::less
-         : c == 0 ? absl::weak_ordering::equivalent
-                  : absl::weak_ordering::greater;
-}
-constexpr absl::weak_ordering
-compare_result_as_ordering(const absl::weak_ordering c) {
-  return c;
-}
-
-template <
-    typename Compare, typename K, typename LK,
-    absl::enable_if_t<!std::is_same<bool, absl::result_of_t<Compare(
-                                              const K &, const LK &)>>::value,
-                      int> = 0>
-constexpr absl::weak_ordering do_three_way_comparison(const Compare &compare,
-                                                      const K &x, const LK &y) {
-  return compare_result_as_ordering(compare(x, y));
-}
-template <
-    typename Compare, typename K, typename LK,
-    absl::enable_if_t<std::is_same<bool, absl::result_of_t<Compare(
-                                             const K &, const LK &)>>::value,
-                      int> = 0>
-constexpr absl::weak_ordering do_three_way_comparison(const Compare &compare,
-                                                      const K &x, const LK &y) {
-  return compare(x, y)   ? absl::weak_ordering::less
-         : compare(y, x) ? absl::weak_ordering::greater
-                         : absl::weak_ordering::equivalent;
-}
-
-} // namespace compare_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_TYPES_COMPARE_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/types/internal/optional.h b/packages/react-native-executorch/third-party/include/absl/types/internal/optional.h
deleted file mode 100644
index c2dc8a258b..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/types/internal/optional.h
+++ /dev/null
@@ -1,337 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-#ifndef ABSL_TYPES_INTERNAL_OPTIONAL_H_
-#define ABSL_TYPES_INTERNAL_OPTIONAL_H_
-
-#include <functional>
-#include <new>
-#include <type_traits>
-#include <utility>
-
-#include "absl/base/internal/inline_variable.h"
-#include "absl/memory/memory.h"
-#include "absl/meta/type_traits.h"
-#include "absl/utility/utility.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// Forward declaration
-template <typename T> class optional;
-
-namespace optional_internal {
-
-// This tag type is used as a constructor parameter type for `nullopt_t`.
-struct init_t {
-  explicit init_t() = default;
-};
-
-struct empty_struct {};
-
-// This class stores the data in optional<T>.
-// It is specialized based on whether T is trivially destructible.
-// This is the specialization for non trivially destructible type.
-template <typename T, bool unused = std::is_trivially_destructible<T>::value>
-class optional_data_dtor_base {
-  struct dummy_type {
-    static_assert(sizeof(T) % sizeof(empty_struct) == 0, "");
-    // Use an array to avoid GCC 6 placement-new warning.
-    empty_struct data[sizeof(T) / sizeof(empty_struct)];
-  };
-
-protected:
-  // Whether there is data or not.
-  bool engaged_;
-  // Data storage
-  union {
-    T data_;
-    dummy_type dummy_;
-  };
-
-  void destruct() noexcept {
-    if (engaged_) {
-      // `data_` must be initialized if `engaged_` is true.
-#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(12, 0)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif
-      data_.~T();
-#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(12, 0)
-#pragma GCC diagnostic pop
-#endif
-      engaged_ = false;
-    }
-  }
-
-  // dummy_ must be initialized for constexpr constructor.
-  constexpr optional_data_dtor_base() noexcept : engaged_(false), dummy_{{}} {}
-
-  template <typename... Args>
-  constexpr explicit optional_data_dtor_base(in_place_t, Args &&...args)
-      : engaged_(true), data_(std::forward<Args>(args)...) {}
-
-  ~optional_data_dtor_base() { destruct(); }
-};
-
-// Specialization for trivially destructible type.
-template <typename T> class optional_data_dtor_base<T, true> {
-  struct dummy_type {
-    static_assert(sizeof(T) % sizeof(empty_struct) == 0, "");
-    // Use array to avoid GCC 6 placement-new warning.
-    empty_struct data[sizeof(T) / sizeof(empty_struct)];
-  };
-
-protected:
-  // Whether there is data or not.
-  bool engaged_;
-  // Data storage
-  union {
-    T data_;
-    dummy_type dummy_;
-  };
-  void destruct() noexcept { engaged_ = false; }
-
-  // dummy_ must be initialized for constexpr constructor.
-  constexpr optional_data_dtor_base() noexcept : engaged_(false), dummy_{{}} {}
-
-  template <typename... Args>
-  constexpr explicit optional_data_dtor_base(in_place_t, Args &&...args)
-      : engaged_(true), data_(std::forward<Args>(args)...) {}
-};
-
-template <typename T>
-class optional_data_base : public optional_data_dtor_base<T> {
-protected:
-  using base = optional_data_dtor_base<T>;
-  using base::base;
-
-  template <typename... Args> void construct(Args &&...args) {
-    // Use dummy_'s address to work around casting cv-qualified T* to void*.
-    ::new (static_cast<void *>(&this->dummy_)) T(std::forward<Args>(args)...);
-    this->engaged_ = true;
-  }
-
-  template <typename U> void assign(U &&u) {
-    if (this->engaged_) {
-      this->data_ = std::forward<U>(u);
-    } else {
-      construct(std::forward<U>(u));
-    }
-  }
-};
-
-// TODO(absl-team): Add another class using
-// std::is_trivially_move_constructible trait when available to match
-// http://cplusplus.github.io/LWG/lwg-defects.html#2900, for types that
-// have trivial move but nontrivial copy.
-// Also, we should be checking is_trivially_copyable here, which is not
-// supported now, so we use is_trivially_* traits instead.
-template <typename T,
-          bool unused = absl::is_trivially_copy_constructible<T>::value &&
-                        absl::is_trivially_copy_assignable<
-                            typename std::remove_cv<T>::type>::value &&
-                        std::is_trivially_destructible<T>::value>
-class optional_data;
-
-// Trivially copyable types
-template <typename T>
-class optional_data<T, true> : public optional_data_base<T> {
-protected:
-  using optional_data_base<T>::optional_data_base;
-};
-
-template <typename T>
-class optional_data<T, false> : public optional_data_base<T> {
-protected:
-  using optional_data_base<T>::optional_data_base;
-
-  optional_data() = default;
-
-  optional_data(const optional_data &rhs) : optional_data_base<T>() {
-    if (rhs.engaged_) {
-      this->construct(rhs.data_);
-    }
-  }
-
-  optional_data(optional_data &&rhs) noexcept(
-      absl::default_allocator_is_nothrow::value ||
-      std::is_nothrow_move_constructible<T>::value)
-      : optional_data_base<T>() {
-    if (rhs.engaged_) {
-      this->construct(std::move(rhs.data_));
-    }
-  }
-
-  optional_data &operator=(const optional_data &rhs) {
-    if (rhs.engaged_) {
-      this->assign(rhs.data_);
-    } else {
-      this->destruct();
-    }
-    return *this;
-  }
-
-  optional_data &operator=(optional_data &&rhs) noexcept(
-      std::is_nothrow_move_assignable<T>::value &&
-      std::is_nothrow_move_constructible<T>::value) {
-    if (rhs.engaged_) {
-      this->assign(std::move(rhs.data_));
-    } else {
-      this->destruct();
-    }
-    return *this;
-  }
-};
-
-// Ordered by level of restriction, from low to high.
-// Copyable implies movable.
-enum class copy_traits { copyable = 0, movable = 1, non_movable = 2 };
-
-// Base class for enabling/disabling copy/move constructor.
-template <copy_traits> class optional_ctor_base;
-
-template <> class optional_ctor_base<copy_traits::copyable> {
-public:
-  constexpr optional_ctor_base() = default;
-  optional_ctor_base(const optional_ctor_base &) = default;
-  optional_ctor_base(optional_ctor_base &&) = default;
-  optional_ctor_base &operator=(const optional_ctor_base &) = default;
-  optional_ctor_base &operator=(optional_ctor_base &&) = default;
-};
-
-template <> class optional_ctor_base<copy_traits::movable> {
-public:
-  constexpr optional_ctor_base() = default;
-  optional_ctor_base(const optional_ctor_base &) = delete;
-  optional_ctor_base(optional_ctor_base &&) = default;
-  optional_ctor_base &operator=(const optional_ctor_base &) = default;
-  optional_ctor_base &operator=(optional_ctor_base &&) = default;
-};
-
-template <> class optional_ctor_base<copy_traits::non_movable> {
-public:
-  constexpr optional_ctor_base() = default;
-  optional_ctor_base(const optional_ctor_base &) = delete;
-  optional_ctor_base(optional_ctor_base &&) = delete;
-  optional_ctor_base &operator=(const optional_ctor_base &) = default;
-  optional_ctor_base &operator=(optional_ctor_base &&) = default;
-};
-
-// Base class for enabling/disabling copy/move assignment.
-template <copy_traits> class optional_assign_base;
-
-template <> class optional_assign_base<copy_traits::copyable> {
-public:
-  constexpr optional_assign_base() = default;
-  optional_assign_base(const optional_assign_base &) = default;
-  optional_assign_base(optional_assign_base &&) = default;
-  optional_assign_base &operator=(const optional_assign_base &) = default;
-  optional_assign_base &operator=(optional_assign_base &&) = default;
-};
-
-template <> class optional_assign_base<copy_traits::movable> {
-public:
-  constexpr optional_assign_base() = default;
-  optional_assign_base(const optional_assign_base &) = default;
-  optional_assign_base(optional_assign_base &&) = default;
-  optional_assign_base &operator=(const optional_assign_base &) = delete;
-  optional_assign_base &operator=(optional_assign_base &&) = default;
-};
-
-template <> class optional_assign_base<copy_traits::non_movable> {
-public:
-  constexpr optional_assign_base() = default;
-  optional_assign_base(const optional_assign_base &) = default;
-  optional_assign_base(optional_assign_base &&) = default;
-  optional_assign_base &operator=(const optional_assign_base &) = delete;
-  optional_assign_base &operator=(optional_assign_base &&) = delete;
-};
-
-template <typename T> struct ctor_copy_traits {
-  static constexpr copy_traits traits =
-      std::is_copy_constructible<T>::value   ? copy_traits::copyable
-      : std::is_move_constructible<T>::value ? copy_traits::movable
-                                             : copy_traits::non_movable;
-};
-
-template <typename T> struct assign_copy_traits {
-  static constexpr copy_traits traits =
-      absl::is_copy_assignable<T>::value && std::is_copy_constructible<T>::value
-          ? copy_traits::copyable
-      : absl::is_move_assignable<T>::value &&
-              std::is_move_constructible<T>::value
-          ? copy_traits::movable
-          : copy_traits::non_movable;
-};
-
-// Whether T is constructible or convertible from optional<U>.
-template <typename T, typename U>
-struct is_constructible_convertible_from_optional
-    : std::integral_constant<
-          bool, std::is_constructible<T, optional<U> &>::value ||
-                    std::is_constructible<T, optional<U> &&>::value ||
-                    std::is_constructible<T, const optional<U> &>::value ||
-                    std::is_constructible<T, const optional<U> &&>::value ||
-                    std::is_convertible<optional<U> &, T>::value ||
-                    std::is_convertible<optional<U> &&, T>::value ||
-                    std::is_convertible<const optional<U> &, T>::value ||
-                    std::is_convertible<const optional<U> &&, T>::value> {};
-
-// Whether T is constructible or convertible or assignable from optional<U>.
-template <typename T, typename U>
-struct is_constructible_convertible_assignable_from_optional
-    : std::integral_constant<
-          bool, is_constructible_convertible_from_optional<T, U>::value ||
-                    std::is_assignable<T &, optional<U> &>::value ||
-                    std::is_assignable<T &, optional<U> &&>::value ||
-                    std::is_assignable<T &, const optional<U> &>::value ||
-                    std::is_assignable<T &, const optional<U> &&>::value> {};
-
-// Helper function used by [optional.relops], [optional.comp_with_t],
-// for checking whether an expression is convertible to bool.
-bool convertible_to_bool(bool);
-
-// Base class for std::hash<absl::optional<T>>:
-// If std::hash<std::remove_const_t<T>> is enabled, it provides operator() to
-// compute the hash; Otherwise, it is disabled.
-// Reference N4659 23.14.15 [unord.hash].
-template <typename T, typename = size_t> struct optional_hash_base {
-  optional_hash_base() = delete;
-  optional_hash_base(const optional_hash_base &) = delete;
-  optional_hash_base(optional_hash_base &&) = delete;
-  optional_hash_base &operator=(const optional_hash_base &) = delete;
-  optional_hash_base &operator=(optional_hash_base &&) = delete;
-};
-
-template <typename T>
-struct optional_hash_base<T, decltype(std::hash<absl::remove_const_t<T>>()(
-                                 std::declval<absl::remove_const_t<T>>()))> {
-  using argument_type = absl::optional<T>;
-  using result_type = size_t;
-  size_t operator()(const absl::optional<T> &opt) const {
-    absl::type_traits_internal::AssertHashEnabled<absl::remove_const_t<T>>();
-    if (opt) {
-      return std::hash<absl::remove_const_t<T>>()(*opt);
-    } else {
-      return static_cast<size_t>(0x297814aaad196e6dULL);
-    }
-  }
-};
-
-} // namespace optional_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_TYPES_INTERNAL_OPTIONAL_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/types/internal/span.h b/packages/react-native-executorch/third-party/include/absl/types/internal/span.h
deleted file mode 100644
index b9b4a3655d..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/types/internal/span.h
+++ /dev/null
@@ -1,137 +0,0 @@
-//
-// Copyright 2019 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-#ifndef ABSL_TYPES_INTERNAL_SPAN_H_
-#define ABSL_TYPES_INTERNAL_SPAN_H_
-
-#include <algorithm>
-#include <cstddef>
-#include <string>
-#include <type_traits>
-
-#include "absl/algorithm/algorithm.h"
-#include "absl/base/config.h"
-#include "absl/base/internal/throw_delegate.h"
-#include "absl/meta/type_traits.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-template <typename T> class Span;
-
-namespace span_internal {
-// Wrappers for access to container data pointers.
-template <typename C>
-constexpr auto GetDataImpl(C &c, char) noexcept // NOLINT(runtime/references)
-    -> decltype(c.data()) {
-  return c.data();
-}
-
-// Before C++17, std::string::data returns a const char* in all cases.
-inline char *GetDataImpl(std::string &s, // NOLINT(runtime/references)
-                         int) noexcept {
-  return &s[0];
-}
-
-template <typename C>
-constexpr auto GetData(C &c) noexcept // NOLINT(runtime/references)
-    -> decltype(GetDataImpl(c, 0)) {
-  return GetDataImpl(c, 0);
-}
-
-// Detection idioms for size() and data().
-template <typename C>
-using HasSize =
-    std::is_integral<absl::decay_t<decltype(std::declval<C &>().size())>>;
-
-// We want to enable conversion from vector<T*> to Span<const T* const> but
-// disable conversion from vector<Derived> to Span<Base>. Here we use
-// the fact that U** is convertible to Q* const* if and only if Q is the same
-// type or a more cv-qualified version of U.  We also decay the result type of
-// data() to avoid problems with classes which have a member function data()
-// which returns a reference.
-template <typename T, typename C>
-using HasData =
-    std::is_convertible<absl::decay_t<decltype(GetData(std::declval<C &>()))> *,
-                        T *const *>;
-
-// Extracts value type from a Container
-template <typename C> struct ElementType {
-  using type = typename absl::remove_reference_t<C>::value_type;
-};
-
-template <typename T, size_t N> struct ElementType<T (&)[N]> {
-  using type = T;
-};
-
-template <typename C> using ElementT = typename ElementType<C>::type;
-
-template <typename T>
-using EnableIfMutable =
-    typename std::enable_if<!std::is_const<T>::value, int>::type;
-
-template <template <typename> class SpanT, typename T>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool EqualImpl(SpanT<T> a, SpanT<T> b) {
-  static_assert(std::is_const<T>::value, "");
-  return std::equal(a.begin(), a.end(), b.begin(), b.end());
-}
-
-template <template <typename> class SpanT, typename T>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool LessThanImpl(SpanT<T> a, SpanT<T> b) {
-  // We can't use value_type since that is remove_cv_t<T>, so we go the long way
-  // around.
-  static_assert(std::is_const<T>::value, "");
-  return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
-}
-
-template <typename From, typename To>
-using EnableIfConvertibleTo =
-    typename std::enable_if<std::is_convertible<From, To>::value>::type;
-
-// IsView is true for types where the return type of .data() is the same for
-// mutable and const instances. This isn't foolproof, but it's only used to
-// enable a compiler warning.
-template <typename T, typename = void, typename = void> struct IsView {
-  static constexpr bool value = false;
-};
-
-template <typename T>
-struct IsView<
-    T,
-    absl::void_t<decltype(span_internal::GetData(std::declval<const T &>()))>,
-    absl::void_t<decltype(span_internal::GetData(std::declval<T &>()))>> {
-private:
-  using Container = std::remove_const_t<T>;
-  using ConstData =
-      decltype(span_internal::GetData(std::declval<const Container &>()));
-  using MutData = decltype(span_internal::GetData(std::declval<Container &>()));
-
-public:
-  static constexpr bool value = std::is_same<ConstData, MutData>::value;
-};
-
-// These enablers result in 'int' so they can be used as typenames or defaults
-// in template parameters lists.
-template <typename T>
-using EnableIfIsView = std::enable_if_t<IsView<T>::value, int>;
-
-template <typename T>
-using EnableIfNotIsView = std::enable_if_t<!IsView<T>::value, int>;
-
-} // namespace span_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_TYPES_INTERNAL_SPAN_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/types/internal/variant.h b/packages/react-native-executorch/third-party/include/absl/types/internal/variant.h
deleted file mode 100644
index 68226298fc..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/types/internal/variant.h
+++ /dev/null
@@ -1,1535 +0,0 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Implementation details of absl/types/variant.h, pulled into a
-// separate file to avoid cluttering the top of the API header with
-// implementation details.
-
-#ifndef ABSL_TYPES_INTERNAL_VARIANT_H_
-#define ABSL_TYPES_INTERNAL_VARIANT_H_
-
-#include <cassert>
-#include <cstddef>
-#include <cstdlib>
-#include <memory>
-#include <stdexcept>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
-#include "absl/base/config.h"
-#include "absl/base/internal/identity.h"
-#include "absl/base/internal/inline_variable.h"
-#include "absl/base/internal/invoke.h"
-#include "absl/base/macros.h"
-#include "absl/base/optimization.h"
-#include "absl/meta/type_traits.h"
-#include "absl/types/bad_variant_access.h"
-#include "absl/utility/utility.h"
-
-#if !defined(ABSL_USES_STD_VARIANT)
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-template <class... Types> class variant;
-
-ABSL_INTERNAL_INLINE_CONSTEXPR(size_t, variant_npos, static_cast<size_t>(-1));
-
-template <class T> struct variant_size;
-
-template <std::size_t I, class T> struct variant_alternative;
-
-namespace variant_internal {
-
-// NOTE: See specializations below for details.
-template <std::size_t I, class T> struct VariantAlternativeSfinae {};
-
-// Requires: I < variant_size_v<T>.
-//
-// Value: The Ith type of Types...
-template <std::size_t I, class T0, class... Tn>
-struct VariantAlternativeSfinae<I, variant<T0, Tn...>>
-    : VariantAlternativeSfinae<I - 1, variant<Tn...>> {};
-
-// Value: T0
-template <class T0, class... Ts>
-struct VariantAlternativeSfinae<0, variant<T0, Ts...>> {
-  using type = T0;
-};
-
-template <std::size_t I, class T>
-using VariantAlternativeSfinaeT = typename VariantAlternativeSfinae<I, T>::type;
-
-// NOTE: Requires T to be a reference type.
-template <class T, class U> struct GiveQualsTo;
-
-template <class T, class U> struct GiveQualsTo<T &, U> {
-  using type = U &;
-};
-
-template <class T, class U> struct GiveQualsTo<T &&, U> {
-  using type = U &&;
-};
-
-template <class T, class U> struct GiveQualsTo<const T &, U> {
-  using type = const U &;
-};
-
-template <class T, class U> struct GiveQualsTo<const T &&, U> {
-  using type = const U &&;
-};
-
-template <class T, class U> struct GiveQualsTo<volatile T &, U> {
-  using type = volatile U &;
-};
-
-template <class T, class U> struct GiveQualsTo<volatile T &&, U> {
-  using type = volatile U &&;
-};
-
-template <class T, class U> struct GiveQualsTo<volatile const T &, U> {
-  using type = volatile const U &;
-};
-
-template <class T, class U> struct GiveQualsTo<volatile const T &&, U> {
-  using type = volatile const U &&;
-};
-
-template <class T, class U>
-using GiveQualsToT = typename GiveQualsTo<T, U>::type;
-
-// Convenience alias, since size_t integral_constant is used a lot in this file.
-template <std::size_t I> using SizeT = std::integral_constant<std::size_t, I>;
-
-using NPos = SizeT<variant_npos>;
-
-template <class Variant, class T, class = void>
-struct IndexOfConstructedType {};
-
-template <std::size_t I, class Variant> struct VariantAccessResultImpl;
-
-template <std::size_t I, template <class...> class Variantemplate, class... T>
-struct VariantAccessResultImpl<I, Variantemplate<T...> &> {
-  using type = typename absl::variant_alternative<I, variant<T...>>::type &;
-};
-
-template <std::size_t I, template <class...> class Variantemplate, class... T>
-struct VariantAccessResultImpl<I, const Variantemplate<T...> &> {
-  using type =
-      const typename absl::variant_alternative<I, variant<T...>>::type &;
-};
-
-template <std::size_t I, template <class...> class Variantemplate, class... T>
-struct VariantAccessResultImpl<I, Variantemplate<T...> &&> {
-  using type = typename absl::variant_alternative<I, variant<T...>>::type &&;
-};
-
-template <std::size_t I, template <class...> class Variantemplate, class... T>
-struct VariantAccessResultImpl<I, const Variantemplate<T...> &&> {
-  using type =
-      const typename absl::variant_alternative<I, variant<T...>>::type &&;
-};
-
-template <std::size_t I, class Variant>
-using VariantAccessResult =
-    typename VariantAccessResultImpl<I, Variant &&>::type;
-
-// NOTE: This is used instead of std::array to reduce instantiation overhead.
-template <class T, std::size_t Size> struct SimpleArray {
-  static_assert(Size != 0, "");
-  T value[Size];
-};
-
-template <class T> struct AccessedType {
-  using type = T;
-};
-
-template <class T> using AccessedTypeT = typename AccessedType<T>::type;
-
-template <class T, std::size_t Size> struct AccessedType<SimpleArray<T, Size>> {
-  using type = AccessedTypeT<T>;
-};
-
-template <class T> constexpr T AccessSimpleArray(const T &value) {
-  return value;
-}
-
-template <class T, std::size_t Size, class... SizeT>
-constexpr AccessedTypeT<T> AccessSimpleArray(const SimpleArray<T, Size> &table,
-                                             std::size_t head_index,
-                                             SizeT... tail_indices) {
-  return AccessSimpleArray(table.value[head_index], tail_indices...);
-}
-
-// Note: Intentionally is an alias.
-template <class T> using AlwaysZero = SizeT<0>;
-
-template <class Op, class... Vs> struct VisitIndicesResultImpl {
-  using type = absl::result_of_t<Op(AlwaysZero<Vs>...)>;
-};
-
-template <class Op, class... Vs>
-using VisitIndicesResultT = typename VisitIndicesResultImpl<Op, Vs...>::type;
-
-template <class ReturnType, class FunctionObject, class EndIndices,
-          class BoundIndices>
-struct MakeVisitationMatrix;
-
-template <class ReturnType, class FunctionObject, std::size_t... Indices>
-constexpr ReturnType call_with_indices(FunctionObject &&function) {
-  static_assert(
-      std::is_same<ReturnType, decltype(std::declval<FunctionObject>()(
-                                   SizeT<Indices>()...))>::value,
-      "Not all visitation overloads have the same return type.");
-  return std::forward<FunctionObject>(function)(SizeT<Indices>()...);
-}
-
-template <class ReturnType, class FunctionObject, std::size_t... BoundIndices>
-struct MakeVisitationMatrix<ReturnType, FunctionObject, index_sequence<>,
-                            index_sequence<BoundIndices...>> {
-  using ResultType = ReturnType (*)(FunctionObject &&);
-  static constexpr ResultType Run() {
-    return &call_with_indices<ReturnType, FunctionObject,
-                              (BoundIndices - 1)...>;
-  }
-};
-
-template <typename Is, std::size_t J> struct AppendToIndexSequence;
-
-template <typename Is, std::size_t J>
-using AppendToIndexSequenceT = typename AppendToIndexSequence<Is, J>::type;
-
-template <std::size_t... Is, std::size_t J>
-struct AppendToIndexSequence<index_sequence<Is...>, J> {
-  using type = index_sequence<Is..., J>;
-};
-
-template <class ReturnType, class FunctionObject, class EndIndices,
-          class CurrIndices, class BoundIndices>
-struct MakeVisitationMatrixImpl;
-
-template <class ReturnType, class FunctionObject, class EndIndices,
-          std::size_t... CurrIndices, class BoundIndices>
-struct MakeVisitationMatrixImpl<ReturnType, FunctionObject, EndIndices,
-                                index_sequence<CurrIndices...>, BoundIndices> {
-  using ResultType = SimpleArray<
-      typename MakeVisitationMatrix<ReturnType, FunctionObject, EndIndices,
-                                    index_sequence<>>::ResultType,
-      sizeof...(CurrIndices)>;
-
-  static constexpr ResultType Run() {
-    return {{MakeVisitationMatrix<
-        ReturnType, FunctionObject, EndIndices,
-        AppendToIndexSequenceT<BoundIndices, CurrIndices>>::Run()...}};
-  }
-};
-
-template <class ReturnType, class FunctionObject, std::size_t HeadEndIndex,
-          std::size_t... TailEndIndices, std::size_t... BoundIndices>
-struct MakeVisitationMatrix<ReturnType, FunctionObject,
-                            index_sequence<HeadEndIndex, TailEndIndices...>,
-                            index_sequence<BoundIndices...>>
-    : MakeVisitationMatrixImpl<ReturnType, FunctionObject,
-                               index_sequence<TailEndIndices...>,
-                               absl::make_index_sequence<HeadEndIndex>,
-                               index_sequence<BoundIndices...>> {};
-
-struct UnreachableSwitchCase {
-  template <class Op>
-  [[noreturn]] static VisitIndicesResultT<Op, std::size_t>
-  Run(Op && /*ignored*/) {
-    ABSL_UNREACHABLE();
-  }
-};
-
-template <class Op, std::size_t I> struct ReachableSwitchCase {
-  static VisitIndicesResultT<Op, std::size_t> Run(Op &&op) {
-    return absl::base_internal::invoke(std::forward<Op>(op), SizeT<I>());
-  }
-};
-
-// The number 33 is just a guess at a reasonable maximum to our switch. It is
-// not based on any analysis. The reason it is a power of 2 plus 1 instead of a
-// power of 2 is because the number was picked to correspond to a power of 2
-// amount of "normal" alternatives, plus one for the possibility of the user
-// providing "monostate" in addition to the more natural alternatives.
-ABSL_INTERNAL_INLINE_CONSTEXPR(std::size_t, MaxUnrolledVisitCases, 33);
-
-// Note: The default-definition is for unreachable cases.
-template <bool IsReachable> struct PickCaseImpl {
-  template <class Op, std::size_t I> using Apply = UnreachableSwitchCase;
-};
-
-template <> struct PickCaseImpl</*IsReachable =*/true> {
-  template <class Op, std::size_t I> using Apply = ReachableSwitchCase<Op, I>;
-};
-
-// Note: This form of dance with template aliases is to make sure that we
-//       instantiate a number of templates proportional to the number of variant
-//       alternatives rather than a number of templates proportional to our
-//       maximum unrolled amount of visitation cases (aliases are effectively
-//       "free" whereas other template instantiations are costly).
-template <class Op, std::size_t I, std::size_t EndIndex>
-using PickCase = typename PickCaseImpl<(I < EndIndex)>::template Apply<Op, I>;
-
-template <class ReturnType>
-[[noreturn]] ReturnType TypedThrowBadVariantAccess() {
-  absl::variant_internal::ThrowBadVariantAccess();
-}
-
-// Given N variant sizes, determine the number of cases there would need to be
-// in a single switch-statement that would cover every possibility in the
-// corresponding N-ary visit operation.
-template <std::size_t... NumAlternatives> struct NumCasesOfSwitch;
-
-template <std::size_t HeadNumAlternatives, std::size_t... TailNumAlternatives>
-struct NumCasesOfSwitch<HeadNumAlternatives, TailNumAlternatives...> {
-  static constexpr std::size_t value =
-      (HeadNumAlternatives + 1) *
-      NumCasesOfSwitch<TailNumAlternatives...>::value;
-};
-
-template <> struct NumCasesOfSwitch<> {
-  static constexpr std::size_t value = 1;
-};
-
-// A switch statement optimizes better than the table of function pointers.
-template <std::size_t EndIndex> struct VisitIndicesSwitch {
-  static_assert(EndIndex <= MaxUnrolledVisitCases,
-                "Maximum unrolled switch size exceeded.");
-
-  template <class Op>
-  static VisitIndicesResultT<Op, std::size_t> Run(Op &&op, std::size_t i) {
-    switch (i) {
-    case 0:
-      return PickCase<Op, 0, EndIndex>::Run(std::forward<Op>(op));
-    case 1:
-      return PickCase<Op, 1, EndIndex>::Run(std::forward<Op>(op));
-    case 2:
-      return PickCase<Op, 2, EndIndex>::Run(std::forward<Op>(op));
-    case 3:
-      return PickCase<Op, 3, EndIndex>::Run(std::forward<Op>(op));
-    case 4:
-      return PickCase<Op, 4, EndIndex>::Run(std::forward<Op>(op));
-    case 5:
-      return PickCase<Op, 5, EndIndex>::Run(std::forward<Op>(op));
-    case 6:
-      return PickCase<Op, 6, EndIndex>::Run(std::forward<Op>(op));
-    case 7:
-      return PickCase<Op, 7, EndIndex>::Run(std::forward<Op>(op));
-    case 8:
-      return PickCase<Op, 8, EndIndex>::Run(std::forward<Op>(op));
-    case 9:
-      return PickCase<Op, 9, EndIndex>::Run(std::forward<Op>(op));
-    case 10:
-      return PickCase<Op, 10, EndIndex>::Run(std::forward<Op>(op));
-    case 11:
-      return PickCase<Op, 11, EndIndex>::Run(std::forward<Op>(op));
-    case 12:
-      return PickCase<Op, 12, EndIndex>::Run(std::forward<Op>(op));
-    case 13:
-      return PickCase<Op, 13, EndIndex>::Run(std::forward<Op>(op));
-    case 14:
-      return PickCase<Op, 14, EndIndex>::Run(std::forward<Op>(op));
-    case 15:
-      return PickCase<Op, 15, EndIndex>::Run(std::forward<Op>(op));
-    case 16:
-      return PickCase<Op, 16, EndIndex>::Run(std::forward<Op>(op));
-    case 17:
-      return PickCase<Op, 17, EndIndex>::Run(std::forward<Op>(op));
-    case 18:
-      return PickCase<Op, 18, EndIndex>::Run(std::forward<Op>(op));
-    case 19:
-      return PickCase<Op, 19, EndIndex>::Run(std::forward<Op>(op));
-    case 20:
-      return PickCase<Op, 20, EndIndex>::Run(std::forward<Op>(op));
-    case 21:
-      return PickCase<Op, 21, EndIndex>::Run(std::forward<Op>(op));
-    case 22:
-      return PickCase<Op, 22, EndIndex>::Run(std::forward<Op>(op));
-    case 23:
-      return PickCase<Op, 23, EndIndex>::Run(std::forward<Op>(op));
-    case 24:
-      return PickCase<Op, 24, EndIndex>::Run(std::forward<Op>(op));
-    case 25:
-      return PickCase<Op, 25, EndIndex>::Run(std::forward<Op>(op));
-    case 26:
-      return PickCase<Op, 26, EndIndex>::Run(std::forward<Op>(op));
-    case 27:
-      return PickCase<Op, 27, EndIndex>::Run(std::forward<Op>(op));
-    case 28:
-      return PickCase<Op, 28, EndIndex>::Run(std::forward<Op>(op));
-    case 29:
-      return PickCase<Op, 29, EndIndex>::Run(std::forward<Op>(op));
-    case 30:
-      return PickCase<Op, 30, EndIndex>::Run(std::forward<Op>(op));
-    case 31:
-      return PickCase<Op, 31, EndIndex>::Run(std::forward<Op>(op));
-    case 32:
-      return PickCase<Op, 32, EndIndex>::Run(std::forward<Op>(op));
-    default:
-      ABSL_ASSERT(i == variant_npos);
-      return absl::base_internal::invoke(std::forward<Op>(op), NPos());
-    }
-  }
-};
-
-template <std::size_t... EndIndices> struct VisitIndicesFallback {
-  template <class Op, class... SizeT>
-  static VisitIndicesResultT<Op, SizeT...> Run(Op &&op, SizeT... indices) {
-    return AccessSimpleArray(
-        MakeVisitationMatrix<VisitIndicesResultT<Op, SizeT...>, Op,
-                             index_sequence<(EndIndices + 1)...>,
-                             index_sequence<>>::Run(),
-        (indices + 1)...)(std::forward<Op>(op));
-  }
-};
-
-// Take an N-dimensional series of indices and convert them into a single index
-// without loss of information. The purpose of this is to be able to convert an
-// N-ary visit operation into a single switch statement.
-template <std::size_t...> struct FlattenIndices;
-
-template <std::size_t HeadSize, std::size_t... TailSize>
-struct FlattenIndices<HeadSize, TailSize...> {
-  template <class... SizeType>
-  static constexpr std::size_t Run(std::size_t head, SizeType... tail) {
-    return head + HeadSize * FlattenIndices<TailSize...>::Run(tail...);
-  }
-};
-
-template <> struct FlattenIndices<> {
-  static constexpr std::size_t Run() { return 0; }
-};
-
-// Take a single "flattened" index (flattened by FlattenIndices) and determine
-// the value of the index of one of the logically represented dimensions.
-template <std::size_t I, std::size_t IndexToGet, std::size_t HeadSize,
-          std::size_t... TailSize>
-struct UnflattenIndex {
-  static constexpr std::size_t value =
-      UnflattenIndex<I / HeadSize, IndexToGet - 1, TailSize...>::value;
-};
-
-template <std::size_t I, std::size_t HeadSize, std::size_t... TailSize>
-struct UnflattenIndex<I, 0, HeadSize, TailSize...> {
-  static constexpr std::size_t value = (I % HeadSize);
-};
-
-// The backend for converting an N-ary visit operation into a unary visit.
-template <class IndexSequence, std::size_t... EndIndices>
-struct VisitIndicesVariadicImpl;
-
-template <std::size_t... N, std::size_t... EndIndices>
-struct VisitIndicesVariadicImpl<absl::index_sequence<N...>, EndIndices...> {
-  // A type that can take an N-ary function object and converts it to a unary
-  // function object that takes a single, flattened index, and "unflattens" it
-  // into its individual dimensions when forwarding to the wrapped object.
-  template <class Op> struct FlattenedOp {
-    template <std::size_t I>
-    VisitIndicesResultT<Op, decltype(EndIndices)...>
-    operator()(SizeT<I> /*index*/) && {
-      return base_internal::invoke(
-          std::forward<Op>(op),
-          SizeT<UnflattenIndex<I, N, (EndIndices + 1)...>::value -
-                std::size_t{1}>()...);
-    }
-
-    Op &&op;
-  };
-
-  template <class Op, class... SizeType>
-  static VisitIndicesResultT<Op, decltype(EndIndices)...> Run(Op &&op,
-                                                              SizeType... i) {
-    return VisitIndicesSwitch<NumCasesOfSwitch<EndIndices...>::value>::Run(
-        FlattenedOp<Op>{std::forward<Op>(op)},
-        FlattenIndices<(EndIndices + std::size_t{1})...>::Run(
-            (i + std::size_t{1})...));
-  }
-};
-
-template <std::size_t... EndIndices>
-struct VisitIndicesVariadic
-    : VisitIndicesVariadicImpl<absl::make_index_sequence<sizeof...(EndIndices)>,
-                               EndIndices...> {};
-
-// This implementation will flatten N-ary visit operations into a single switch
-// statement when the number of cases would be less than our maximum specified
-// switch-statement size.
-// TODO(calabrese)
-//   Based on benchmarks, determine whether the function table approach actually
-//   does optimize better than a chain of switch statements and possibly update
-//   the implementation accordingly. Also consider increasing the maximum switch
-//   size.
-template <std::size_t... EndIndices>
-struct VisitIndices
-    : absl::conditional_t<(NumCasesOfSwitch<EndIndices...>::value <=
-                           MaxUnrolledVisitCases),
-                          VisitIndicesVariadic<EndIndices...>,
-                          VisitIndicesFallback<EndIndices...>> {};
-
-template <std::size_t EndIndex>
-struct VisitIndices<EndIndex>
-    : absl::conditional_t<(EndIndex <= MaxUnrolledVisitCases),
-                          VisitIndicesSwitch<EndIndex>,
-                          VisitIndicesFallback<EndIndex>> {};
-
-// Suppress bogus warning on MSVC: MSVC complains that the `reinterpret_cast`
-// below is returning the address of a temporary or local object.
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4172)
-#endif // _MSC_VER
-
-// TODO(calabrese) std::launder
-// TODO(calabrese) constexpr
-// NOTE: DO NOT REMOVE the `inline` keyword as it is necessary to work around a
-// MSVC bug. See https://github.com/abseil/abseil-cpp/issues/129 for details.
-template <class Self, std::size_t I>
-inline VariantAccessResult<I, Self> AccessUnion(Self &&self, SizeT<I> /*i*/) {
-  return reinterpret_cast<VariantAccessResult<I, Self>>(self);
-}
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif // _MSC_VER
-
-template <class T> void DeducedDestroy(T &self) { // NOLINT
-  self.~T();
-}
-
-// NOTE: This type exists as a single entity for variant and its bases to
-// befriend. It contains helper functionality that manipulates the state of the
-// variant, such as the implementation of things like assignment and emplace
-// operations.
-struct VariantCoreAccess {
-  template <class VariantType>
-  static typename VariantType::Variant &Derived(VariantType &self) { // NOLINT
-    return static_cast<typename VariantType::Variant &>(self);
-  }
-
-  template <class VariantType>
-  static const typename VariantType::Variant &
-  Derived(const VariantType &self) { // NOLINT
-    return static_cast<const typename VariantType::Variant &>(self);
-  }
-
-  template <class VariantType>
-  static void Destroy(VariantType &self) { // NOLINT
-    Derived(self).destroy();
-    self.index_ = absl::variant_npos;
-  }
-
-  template <class Variant>
-  static void SetIndex(Variant &self, std::size_t i) { // NOLINT
-    self.index_ = i;
-  }
-
-  template <class Variant>
-  static void InitFrom(Variant &self, Variant &&other) { // NOLINT
-    VisitIndices<absl::variant_size<Variant>::value>::Run(
-        InitFromVisitor<Variant, Variant &&>{&self,
-                                             std::forward<Variant>(other)},
-        other.index());
-    self.index_ = other.index();
-  }
-
-  // Access a variant alternative, assuming the index is correct.
-  template <std::size_t I, class Variant>
-  static VariantAccessResult<I, Variant> Access(Variant &&self) {
-    // This cast instead of invocation of AccessUnion with an rvalue is a
-    // workaround for msvc. Without this there is a runtime failure when dealing
-    // with rvalues.
-    // TODO(calabrese) Reduce test case and find a simpler workaround.
-    return static_cast<VariantAccessResult<I, Variant>>(
-        variant_internal::AccessUnion(self.state_, SizeT<I>()));
-  }
-
-  // Access a variant alternative, throwing if the index is incorrect.
-  template <std::size_t I, class Variant>
-  static VariantAccessResult<I, Variant> CheckedAccess(Variant &&self) {
-    if (ABSL_PREDICT_FALSE(self.index_ != I)) {
-      TypedThrowBadVariantAccess<VariantAccessResult<I, Variant>>();
-    }
-
-    return Access<I>(std::forward<Variant>(self));
-  }
-
-  // The implementation of the move-assignment operation for a variant.
-  template <class VType> struct MoveAssignVisitor {
-    using DerivedType = typename VType::Variant;
-    template <std::size_t NewIndex>
-    void operator()(SizeT<NewIndex> /*new_i*/) const {
-      if (left->index_ == NewIndex) {
-        Access<NewIndex>(*left) = std::move(Access<NewIndex>(*right));
-      } else {
-        Derived(*left).template emplace<NewIndex>(
-            std::move(Access<NewIndex>(*right)));
-      }
-    }
-
-    void operator()(SizeT<absl::variant_npos> /*new_i*/) const {
-      Destroy(*left);
-    }
-
-    VType *left;
-    VType *right;
-  };
-
-  template <class VType>
-  static MoveAssignVisitor<VType> MakeMoveAssignVisitor(VType *left,
-                                                        VType *other) {
-    return {left, other};
-  }
-
-  // The implementation of the assignment operation for a variant.
-  template <class VType> struct CopyAssignVisitor {
-    using DerivedType = typename VType::Variant;
-    template <std::size_t NewIndex>
-    void operator()(SizeT<NewIndex> /*new_i*/) const {
-      using New =
-          typename absl::variant_alternative<NewIndex, DerivedType>::type;
-
-      if (left->index_ == NewIndex) {
-        Access<NewIndex>(*left) = Access<NewIndex>(*right);
-      } else if (std::is_nothrow_copy_constructible<New>::value ||
-                 !std::is_nothrow_move_constructible<New>::value) {
-        Derived(*left).template emplace<NewIndex>(Access<NewIndex>(*right));
-      } else {
-        Derived(*left) = DerivedType(Derived(*right));
-      }
-    }
-
-    void operator()(SizeT<absl::variant_npos> /*new_i*/) const {
-      Destroy(*left);
-    }
-
-    VType *left;
-    const VType *right;
-  };
-
-  template <class VType>
-  static CopyAssignVisitor<VType> MakeCopyAssignVisitor(VType *left,
-                                                        const VType &other) {
-    return {left, &other};
-  }
-
-  // The implementation of conversion-assignment operations for variant.
-  template <class Left, class QualifiedNew> struct ConversionAssignVisitor {
-    using NewIndex =
-        variant_internal::IndexOfConstructedType<Left, QualifiedNew>;
-
-    void operator()(SizeT<NewIndex::value> /*old_i*/
-    ) const {
-      Access<NewIndex::value>(*left) = std::forward<QualifiedNew>(other);
-    }
-
-    template <std::size_t OldIndex>
-    void operator()(SizeT<OldIndex> /*old_i*/
-    ) const {
-      using New =
-          typename absl::variant_alternative<NewIndex::value, Left>::type;
-      if (std::is_nothrow_constructible<New, QualifiedNew>::value ||
-          !std::is_nothrow_move_constructible<New>::value) {
-        left->template emplace<NewIndex::value>(
-            std::forward<QualifiedNew>(other));
-      } else {
-        // the standard says "equivalent to
-        // operator=(variant(std::forward<T>(t)))", but we use `emplace` here
-        // because the variant's move assignment operator could be deleted.
-        left->template emplace<NewIndex::value>(
-            New(std::forward<QualifiedNew>(other)));
-      }
-    }
-
-    Left *left;
-    QualifiedNew &&other;
-  };
-
-  template <class Left, class QualifiedNew>
-  static ConversionAssignVisitor<Left, QualifiedNew>
-  MakeConversionAssignVisitor(Left *left, QualifiedNew &&qual) {
-    return {left, std::forward<QualifiedNew>(qual)};
-  }
-
-  // Backend for operations for `emplace()` which destructs `*self` then
-  // construct a new alternative with `Args...`.
-  template <std::size_t NewIndex, class Self, class... Args>
-  static typename absl::variant_alternative<NewIndex, Self>::type &
-  Replace(Self *self, Args &&...args) {
-    Destroy(*self);
-    using New = typename absl::variant_alternative<NewIndex, Self>::type;
-    New *const result = ::new (static_cast<void *>(&self->state_))
-        New(std::forward<Args>(args)...);
-    self->index_ = NewIndex;
-    return *result;
-  }
-
-  template <class LeftVariant, class QualifiedRightVariant>
-  struct InitFromVisitor {
-    template <std::size_t NewIndex>
-    void operator()(SizeT<NewIndex> /*new_i*/) const {
-      using Alternative =
-          typename variant_alternative<NewIndex, LeftVariant>::type;
-      ::new (static_cast<void *>(&left->state_)) Alternative(
-          Access<NewIndex>(std::forward<QualifiedRightVariant>(right)));
-    }
-
-    void operator()(SizeT<absl::variant_npos> /*new_i*/) const {
-      // This space intentionally left blank.
-    }
-    LeftVariant *left;
-    QualifiedRightVariant &&right;
-  };
-};
-
-template <class Expected, class... T> struct IndexOfImpl;
-
-template <class Expected> struct IndexOfImpl<Expected> {
-  using IndexFromEnd = SizeT<0>;
-  using MatchedIndexFromEnd = IndexFromEnd;
-  using MultipleMatches = std::false_type;
-};
-
-template <class Expected, class Head, class... Tail>
-struct IndexOfImpl<Expected, Head, Tail...> : IndexOfImpl<Expected, Tail...> {
-  using IndexFromEnd =
-      SizeT<IndexOfImpl<Expected, Tail...>::IndexFromEnd::value + 1>;
-};
-
-template <class Expected, class... Tail>
-struct IndexOfImpl<Expected, Expected, Tail...>
-    : IndexOfImpl<Expected, Tail...> {
-  using IndexFromEnd =
-      SizeT<IndexOfImpl<Expected, Tail...>::IndexFromEnd::value + 1>;
-  using MatchedIndexFromEnd = IndexFromEnd;
-  using MultipleMatches = std::integral_constant<
-      bool, IndexOfImpl<Expected, Tail...>::MatchedIndexFromEnd::value != 0>;
-};
-
-template <class Expected, class... Types> struct IndexOfMeta {
-  using Results = IndexOfImpl<Expected, Types...>;
-  static_assert(!Results::MultipleMatches::value,
-                "Attempted to access a variant by specifying a type that "
-                "matches more than one alternative.");
-  static_assert(Results::MatchedIndexFromEnd::value != 0,
-                "Attempted to access a variant by specifying a type that does "
-                "not match any alternative.");
-  using type = SizeT<sizeof...(Types) - Results::MatchedIndexFromEnd::value>;
-};
-
-template <class Expected, class... Types>
-using IndexOf = typename IndexOfMeta<Expected, Types...>::type;
-
-template <class Variant, class T, std::size_t CurrIndex>
-struct UnambiguousIndexOfImpl;
-
-// Terminating case encountered once we've checked all of the alternatives
-template <class T, std::size_t CurrIndex>
-struct UnambiguousIndexOfImpl<variant<>, T, CurrIndex> : SizeT<CurrIndex> {};
-
-// Case where T is not Head
-template <class Head, class... Tail, class T, std::size_t CurrIndex>
-struct UnambiguousIndexOfImpl<variant<Head, Tail...>, T, CurrIndex>
-    : UnambiguousIndexOfImpl<variant<Tail...>, T, CurrIndex + 1>::type {};
-
-// Case where T is Head
-template <class Head, class... Tail, std::size_t CurrIndex>
-struct UnambiguousIndexOfImpl<variant<Head, Tail...>, Head, CurrIndex>
-    : SizeT<UnambiguousIndexOfImpl<variant<Tail...>, Head, 0>::value ==
-                    sizeof...(Tail)
-                ? CurrIndex
-                : CurrIndex + sizeof...(Tail) + 1> {};
-
-template <class Variant, class T> struct UnambiguousIndexOf;
-
-struct NoMatch {
-  struct type {};
-};
-
-template <class... Alts, class T>
-struct UnambiguousIndexOf<variant<Alts...>, T>
-    : std::conditional<UnambiguousIndexOfImpl<variant<Alts...>, T, 0>::value !=
-                           sizeof...(Alts),
-                       UnambiguousIndexOfImpl<variant<Alts...>, T, 0>,
-                       NoMatch>::type::type {};
-
-template <class T, std::size_t /*Dummy*/> using UnambiguousTypeOfImpl = T;
-
-template <class Variant, class T>
-using UnambiguousTypeOfT =
-    UnambiguousTypeOfImpl<T, UnambiguousIndexOf<Variant, T>::value>;
-
-template <class H, class... T> class VariantStateBase;
-
-// This is an implementation of the "imaginary function" that is described in
-// [variant.ctor]
-// It is used in order to determine which alternative to construct during
-// initialization from some type T.
-template <class Variant, std::size_t I = 0> struct ImaginaryFun;
-
-template <std::size_t I> struct ImaginaryFun<variant<>, I> {
-  static void Run() = delete;
-};
-
-template <class H, class... T, std::size_t I>
-struct ImaginaryFun<variant<H, T...>, I> : ImaginaryFun<variant<T...>, I + 1> {
-  using ImaginaryFun<variant<T...>, I + 1>::Run;
-
-  // NOTE: const& and && are used instead of by-value due to lack of guaranteed
-  // move elision of C++17. This may have other minor differences, but tests
-  // pass.
-  static SizeT<I> Run(const H &, SizeT<I>);
-  static SizeT<I> Run(H &&, SizeT<I>);
-};
-
-// The following metafunctions are used in constructor and assignment
-// constraints.
-template <class Self, class T>
-struct IsNeitherSelfNorInPlace : std::true_type {};
-
-template <class Self>
-struct IsNeitherSelfNorInPlace<Self, Self> : std::false_type {};
-
-template <class Self, class T>
-struct IsNeitherSelfNorInPlace<Self, in_place_type_t<T>> : std::false_type {};
-
-template <class Self, std::size_t I>
-struct IsNeitherSelfNorInPlace<Self, in_place_index_t<I>> : std::false_type {};
-
-template <class Variant, class T>
-struct IndexOfConstructedType<
-    Variant, T,
-    void_t<decltype(ImaginaryFun<Variant>::Run(std::declval<T>(), {}))>>
-    : decltype(ImaginaryFun<Variant>::Run(std::declval<T>(), {})){};
-
-template <std::size_t... Is>
-struct ContainsVariantNPos
-    : absl::negation<std::is_same< // NOLINT
-          std::integer_sequence<bool, 0 <= Is...>,
-          std::integer_sequence<bool, Is != absl::variant_npos...>>> {};
-
-template <class Op, class... QualifiedVariants>
-using RawVisitResult =
-    absl::result_of_t<Op(VariantAccessResult<0, QualifiedVariants>...)>;
-
-// NOTE: The spec requires that all return-paths yield the same type and is not
-// SFINAE-friendly, so we can deduce the return type by examining the first
-// result. If it's not callable, then we get an error, but are compliant and
-// fast to compile.
-// TODO(calabrese) Possibly rewrite in a way that yields better compile errors
-// at the cost of longer compile-times.
-template <class Op, class... QualifiedVariants> struct VisitResultImpl {
-  using type =
-      absl::result_of_t<Op(VariantAccessResult<0, QualifiedVariants>...)>;
-};
-
-// Done in two steps intentionally so that we don't cause substitution to fail.
-template <class Op, class... QualifiedVariants>
-using VisitResult = typename VisitResultImpl<Op, QualifiedVariants...>::type;
-
-template <class Op, class... QualifiedVariants> struct PerformVisitation {
-  using ReturnType = VisitResult<Op, QualifiedVariants...>;
-
-  template <std::size_t... Is>
-  constexpr ReturnType operator()(SizeT<Is>... indices) const {
-    return Run(typename ContainsVariantNPos<Is...>::type{},
-               absl::index_sequence_for<QualifiedVariants...>(), indices...);
-  }
-
-  template <std::size_t... TupIs, std::size_t... Is>
-  constexpr ReturnType Run(std::false_type /*has_valueless*/,
-                           index_sequence<TupIs...>, SizeT<Is>...) const {
-    static_assert(
-        std::is_same<ReturnType,
-                     absl::result_of_t<Op(VariantAccessResult<
-                                          Is, QualifiedVariants>...)>>::value,
-        "All visitation overloads must have the same return type.");
-    return absl::base_internal::invoke(
-        std::forward<Op>(op),
-        VariantCoreAccess::Access<Is>(
-            std::forward<QualifiedVariants>(std::get<TupIs>(variant_tup)))...);
-  }
-
-  template <std::size_t... TupIs, std::size_t... Is>
-  [[noreturn]] ReturnType Run(std::true_type /*has_valueless*/,
-                              index_sequence<TupIs...>, SizeT<Is>...) const {
-    absl::variant_internal::ThrowBadVariantAccess();
-  }
-
-  // TODO(calabrese) Avoid using a tuple, which causes lots of instantiations
-  // Attempts using lambda variadic captures fail on current GCC.
-  std::tuple<QualifiedVariants &&...> variant_tup;
-  Op &&op;
-};
-
-template <class... T> union Union;
-
-// We want to allow for variant<> to be trivial. For that, we need the default
-// constructor to be trivial, which means we can't define it ourselves.
-// Instead, we use a non-default constructor that takes NoopConstructorTag
-// that doesn't affect the triviality of the types.
-struct NoopConstructorTag {};
-
-template <std::size_t I> struct EmplaceTag {};
-
-template <> union Union<> {
-  constexpr explicit Union(NoopConstructorTag) noexcept {}
-};
-
-// Suppress bogus warning on MSVC: MSVC complains that Union<T...> has a defined
-// deleted destructor from the `std::is_destructible` check below.
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4624)
-#endif // _MSC_VER
-
-template <class Head, class... Tail> union Union<Head, Tail...> {
-  using TailUnion = Union<Tail...>;
-
-  explicit constexpr Union(NoopConstructorTag /*tag*/) noexcept
-      : tail(NoopConstructorTag()) {}
-
-  template <class... P>
-  explicit constexpr Union(EmplaceTag<0>, P &&...args)
-      : head(std::forward<P>(args)...) {}
-
-  template <std::size_t I, class... P>
-  explicit constexpr Union(EmplaceTag<I>, P &&...args)
-      : tail(EmplaceTag<I - 1>{}, std::forward<P>(args)...) {}
-
-  Head head;
-  TailUnion tail;
-};
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif // _MSC_VER
-
-// TODO(calabrese) Just contain a Union in this union (certain configs fail).
-template <class... T> union DestructibleUnionImpl;
-
-template <> union DestructibleUnionImpl<> {
-  constexpr explicit DestructibleUnionImpl(NoopConstructorTag) noexcept {}
-};
-
-template <class Head, class... Tail>
-union DestructibleUnionImpl<Head, Tail...> {
-  using TailUnion = DestructibleUnionImpl<Tail...>;
-
-  explicit constexpr DestructibleUnionImpl(NoopConstructorTag /*tag*/) noexcept
-      : tail(NoopConstructorTag()) {}
-
-  template <class... P>
-  explicit constexpr DestructibleUnionImpl(EmplaceTag<0>, P &&...args)
-      : head(std::forward<P>(args)...) {}
-
-  template <std::size_t I, class... P>
-  explicit constexpr DestructibleUnionImpl(EmplaceTag<I>, P &&...args)
-      : tail(EmplaceTag<I - 1>{}, std::forward<P>(args)...) {}
-
-  ~DestructibleUnionImpl() {}
-
-  Head head;
-  TailUnion tail;
-};
-
-// This union type is destructible even if one or more T are not trivially
-// destructible. In the case that all T are trivially destructible, then so is
-// this resultant type.
-template <class... T>
-using DestructibleUnion =
-    absl::conditional_t<std::is_destructible<Union<T...>>::value, Union<T...>,
-                        DestructibleUnionImpl<T...>>;
-
-// Deepest base, containing the actual union and the discriminator
-template <class H, class... T> class VariantStateBase {
-protected:
-  using Variant = variant<H, T...>;
-
-  template <class LazyH = H,
-            class ConstructibleH = absl::enable_if_t<
-                std::is_default_constructible<LazyH>::value, LazyH>>
-  constexpr VariantStateBase() noexcept(
-      std::is_nothrow_default_constructible<ConstructibleH>::value)
-      : state_(EmplaceTag<0>()), index_(0) {}
-
-  template <std::size_t I, class... P>
-  explicit constexpr VariantStateBase(EmplaceTag<I> tag, P &&...args)
-      : state_(tag, std::forward<P>(args)...), index_(I) {}
-
-  explicit constexpr VariantStateBase(NoopConstructorTag)
-      : state_(NoopConstructorTag()), index_(variant_npos) {}
-
-  void destroy() {} // Does nothing (shadowed in child if non-trivial)
-
-  DestructibleUnion<H, T...> state_;
-  std::size_t index_;
-};
-
-using absl::internal::type_identity;
-
-// OverloadSet::Overload() is a unary function which is overloaded to
-// take any of the element types of the variant, by reference-to-const.
-// The return type of the overload on T is type_identity<T>, so that you
-// can statically determine which overload was called.
-//
-// Overload() is not defined, so it can only be called in unevaluated
-// contexts.
-template <typename... Ts> struct OverloadSet;
-
-template <typename T, typename... Ts>
-struct OverloadSet<T, Ts...> : OverloadSet<Ts...> {
-  using Base = OverloadSet<Ts...>;
-  static type_identity<T> Overload(const T &);
-  using Base::Overload;
-};
-
-template <> struct OverloadSet<> {
-  // For any case not handled above.
-  static void Overload(...);
-};
-
-template <class T>
-using LessThanResult = decltype(std::declval<T>() < std::declval<T>());
-
-template <class T>
-using GreaterThanResult = decltype(std::declval<T>() > std::declval<T>());
-
-template <class T>
-using LessThanOrEqualResult = decltype(std::declval<T>() <= std::declval<T>());
-
-template <class T>
-using GreaterThanOrEqualResult =
-    decltype(std::declval<T>() >= std::declval<T>());
-
-template <class T>
-using EqualResult = decltype(std::declval<T>() == std::declval<T>());
-
-template <class T>
-using NotEqualResult = decltype(std::declval<T>() != std::declval<T>());
-
-using type_traits_internal::is_detected_convertible;
-
-template <class... T>
-using RequireAllHaveEqualT = absl::enable_if_t<
-    absl::conjunction<is_detected_convertible<bool, EqualResult, T>...>::value,
-    bool>;
-
-template <class... T>
-using RequireAllHaveNotEqualT =
-    absl::enable_if_t<absl::conjunction<is_detected_convertible<
-                          bool, NotEqualResult, T>...>::value,
-                      bool>;
-
-template <class... T>
-using RequireAllHaveLessThanT =
-    absl::enable_if_t<absl::conjunction<is_detected_convertible<
-                          bool, LessThanResult, T>...>::value,
-                      bool>;
-
-template <class... T>
-using RequireAllHaveLessThanOrEqualT =
-    absl::enable_if_t<absl::conjunction<is_detected_convertible<
-                          bool, LessThanOrEqualResult, T>...>::value,
-                      bool>;
-
-template <class... T>
-using RequireAllHaveGreaterThanOrEqualT =
-    absl::enable_if_t<absl::conjunction<is_detected_convertible<
-                          bool, GreaterThanOrEqualResult, T>...>::value,
-                      bool>;
-
-template <class... T>
-using RequireAllHaveGreaterThanT =
-    absl::enable_if_t<absl::conjunction<is_detected_convertible<
-                          bool, GreaterThanResult, T>...>::value,
-                      bool>;
-
-// Helper template containing implementations details of variant that can't go
-// in the private section. For convenience, this takes the variant type as a
-// single template parameter.
-template <typename T> struct VariantHelper;
-
-template <typename... Ts> struct VariantHelper<variant<Ts...>> {
-  // Type metafunction which returns the element type selected if
-  // OverloadSet::Overload() is well-formed when called with argument type U.
-  template <typename U>
-  using BestMatch = decltype(variant_internal::OverloadSet<Ts...>::Overload(
-      std::declval<U>()));
-
-  // Type metafunction which returns true if OverloadSet::Overload() is
-  // well-formed when called with argument type U.
-  // CanAccept can't be just an alias because there is a MSVC bug on parameter
-  // pack expansion involving decltype.
-  template <typename U>
-  struct CanAccept
-      : std::integral_constant<bool, !std::is_void<BestMatch<U>>::value> {};
-
-  // Type metafunction which returns true if Other is an instantiation of
-  // variant, and variants's converting constructor from Other will be
-  // well-formed. We will use this to remove constructors that would be
-  // ill-formed from the overload set.
-  template <typename Other> struct CanConvertFrom;
-
-  template <typename... Us>
-  struct CanConvertFrom<variant<Us...>>
-      : public absl::conjunction<CanAccept<Us>...> {};
-};
-
-// A type with nontrivial copy ctor and trivial move ctor.
-struct TrivialMoveOnly {
-  TrivialMoveOnly(TrivialMoveOnly &&) = default;
-};
-
-// Trait class to detect whether a type is trivially move constructible.
-// A union's defaulted copy/move constructor is deleted if any variant member's
-// copy/move constructor is nontrivial.
-template <typename T>
-struct IsTriviallyMoveConstructible
-    : std::is_move_constructible<Union<T, TrivialMoveOnly>> {};
-
-// To guarantee triviality of all special-member functions that can be trivial,
-// we use a chain of conditional bases for each one.
-// The order of inheritance of bases from child to base are logically:
-//
-// variant
-// VariantCopyAssignBase
-// VariantMoveAssignBase
-// VariantCopyBase
-// VariantMoveBase
-// VariantStateBaseDestructor
-// VariantStateBase
-//
-// Note that there is a separate branch at each base that is dependent on
-// whether or not that corresponding special-member-function can be trivial in
-// the resultant variant type.
-
-template <class... T> class VariantStateBaseDestructorNontrivial;
-
-template <class... T> class VariantMoveBaseNontrivial;
-
-template <class... T> class VariantCopyBaseNontrivial;
-
-template <class... T> class VariantMoveAssignBaseNontrivial;
-
-template <class... T> class VariantCopyAssignBaseNontrivial;
-
-// Base that is dependent on whether or not the destructor can be trivial.
-template <class... T>
-using VariantStateBaseDestructor =
-    absl::conditional_t<std::is_destructible<Union<T...>>::value,
-                        VariantStateBase<T...>,
-                        VariantStateBaseDestructorNontrivial<T...>>;
-
-// Base that is dependent on whether or not the move-constructor can be
-// implicitly generated by the compiler (trivial or deleted).
-// Previously we were using `std::is_move_constructible<Union<T...>>` to check
-// whether all Ts have trivial move constructor, but it ran into a GCC bug:
-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=84866
-// So we have to use a different approach (i.e. `HasTrivialMoveConstructor`) to
-// work around the bug.
-template <class... T>
-using VariantMoveBase = absl::conditional_t<
-    absl::disjunction<
-        absl::negation<absl::conjunction<std::is_move_constructible<T>...>>,
-        absl::conjunction<IsTriviallyMoveConstructible<T>...>>::value,
-    VariantStateBaseDestructor<T...>, VariantMoveBaseNontrivial<T...>>;
-
-// Base that is dependent on whether or not the copy-constructor can be trivial.
-template <class... T>
-using VariantCopyBase = absl::conditional_t<
-    absl::disjunction<
-        absl::negation<absl::conjunction<std::is_copy_constructible<T>...>>,
-        std::is_copy_constructible<Union<T...>>>::value,
-    VariantMoveBase<T...>, VariantCopyBaseNontrivial<T...>>;
-
-// Base that is dependent on whether or not the move-assign can be trivial.
-template <class... T>
-using VariantMoveAssignBase = absl::conditional_t<
-    absl::disjunction<
-        absl::conjunction<absl::is_move_assignable<Union<T...>>,
-                          std::is_move_constructible<Union<T...>>,
-                          std::is_destructible<Union<T...>>>,
-        absl::negation<absl::conjunction<std::is_move_constructible<T>...,
-                                         // Note: We're not qualifying this with
-                                         // absl:: because it doesn't compile
-                                         // under MSVC.
-                                         is_move_assignable<T>...>>>::value,
-    VariantCopyBase<T...>, VariantMoveAssignBaseNontrivial<T...>>;
-
-// Base that is dependent on whether or not the copy-assign can be trivial.
-template <class... T>
-using VariantCopyAssignBase = absl::conditional_t<
-    absl::disjunction<
-        absl::conjunction<absl::is_copy_assignable<Union<T...>>,
-                          std::is_copy_constructible<Union<T...>>,
-                          std::is_destructible<Union<T...>>>,
-        absl::negation<absl::conjunction<std::is_copy_constructible<T>...,
-                                         // Note: We're not qualifying this with
-                                         // absl:: because it doesn't compile
-                                         // under MSVC.
-                                         is_copy_assignable<T>...>>>::value,
-    VariantMoveAssignBase<T...>, VariantCopyAssignBaseNontrivial<T...>>;
-
-template <class... T> using VariantBase = VariantCopyAssignBase<T...>;
-
-template <class... T>
-class VariantStateBaseDestructorNontrivial : protected VariantStateBase<T...> {
-private:
-  using Base = VariantStateBase<T...>;
-
-protected:
-  using Base::Base;
-
-  VariantStateBaseDestructorNontrivial() = default;
-  VariantStateBaseDestructorNontrivial(
-      VariantStateBaseDestructorNontrivial &&) = default;
-  VariantStateBaseDestructorNontrivial(
-      const VariantStateBaseDestructorNontrivial &) = default;
-  VariantStateBaseDestructorNontrivial &
-  operator=(VariantStateBaseDestructorNontrivial &&) = default;
-  VariantStateBaseDestructorNontrivial &
-  operator=(const VariantStateBaseDestructorNontrivial &) = default;
-
-  struct Destroyer {
-    template <std::size_t I> void operator()(SizeT<I> i) const {
-      using Alternative =
-          typename absl::variant_alternative<I, variant<T...>>::type;
-      variant_internal::AccessUnion(self->state_, i).~Alternative();
-    }
-
-    void operator()(SizeT<absl::variant_npos> /*i*/) const {
-      // This space intentionally left blank
-    }
-
-    VariantStateBaseDestructorNontrivial *self;
-  };
-
-  void destroy() { VisitIndices<sizeof...(T)>::Run(Destroyer{this}, index_); }
-
-  ~VariantStateBaseDestructorNontrivial() { destroy(); }
-
-protected:
-  using Base::index_;
-  using Base::state_;
-};
-
-template <class... T>
-class VariantMoveBaseNontrivial : protected VariantStateBaseDestructor<T...> {
-private:
-  using Base = VariantStateBaseDestructor<T...>;
-
-protected:
-  using Base::Base;
-
-  struct Construct {
-    template <std::size_t I> void operator()(SizeT<I> i) const {
-      using Alternative =
-          typename absl::variant_alternative<I, variant<T...>>::type;
-      ::new (static_cast<void *>(&self->state_)) Alternative(
-          variant_internal::AccessUnion(std::move(other->state_), i));
-    }
-
-    void operator()(SizeT<absl::variant_npos> /*i*/) const {}
-
-    VariantMoveBaseNontrivial *self;
-    VariantMoveBaseNontrivial *other;
-  };
-
-  VariantMoveBaseNontrivial() = default;
-  VariantMoveBaseNontrivial(VariantMoveBaseNontrivial &&other) noexcept(
-      absl::conjunction<std::is_nothrow_move_constructible<T>...>::value)
-      : Base(NoopConstructorTag()) {
-    VisitIndices<sizeof...(T)>::Run(Construct{this, &other}, other.index_);
-    index_ = other.index_;
-  }
-
-  VariantMoveBaseNontrivial(VariantMoveBaseNontrivial const &) = default;
-
-  VariantMoveBaseNontrivial &operator=(VariantMoveBaseNontrivial &&) = default;
-  VariantMoveBaseNontrivial &
-  operator=(VariantMoveBaseNontrivial const &) = default;
-
-protected:
-  using Base::index_;
-  using Base::state_;
-};
-
-template <class... T>
-class VariantCopyBaseNontrivial : protected VariantMoveBase<T...> {
-private:
-  using Base = VariantMoveBase<T...>;
-
-protected:
-  using Base::Base;
-
-  VariantCopyBaseNontrivial() = default;
-  VariantCopyBaseNontrivial(VariantCopyBaseNontrivial &&) = default;
-
-  struct Construct {
-    template <std::size_t I> void operator()(SizeT<I> i) const {
-      using Alternative =
-          typename absl::variant_alternative<I, variant<T...>>::type;
-      ::new (static_cast<void *>(&self->state_))
-          Alternative(variant_internal::AccessUnion(other->state_, i));
-    }
-
-    void operator()(SizeT<absl::variant_npos> /*i*/) const {}
-
-    VariantCopyBaseNontrivial *self;
-    const VariantCopyBaseNontrivial *other;
-  };
-
-  VariantCopyBaseNontrivial(VariantCopyBaseNontrivial const &other)
-      : Base(NoopConstructorTag()) {
-    VisitIndices<sizeof...(T)>::Run(Construct{this, &other}, other.index_);
-    index_ = other.index_;
-  }
-
-  VariantCopyBaseNontrivial &operator=(VariantCopyBaseNontrivial &&) = default;
-  VariantCopyBaseNontrivial &
-  operator=(VariantCopyBaseNontrivial const &) = default;
-
-protected:
-  using Base::index_;
-  using Base::state_;
-};
-
-template <class... T>
-class VariantMoveAssignBaseNontrivial : protected VariantCopyBase<T...> {
-  friend struct VariantCoreAccess;
-
-private:
-  using Base = VariantCopyBase<T...>;
-
-protected:
-  using Base::Base;
-
-  VariantMoveAssignBaseNontrivial() = default;
-  VariantMoveAssignBaseNontrivial(VariantMoveAssignBaseNontrivial &&) = default;
-  VariantMoveAssignBaseNontrivial(const VariantMoveAssignBaseNontrivial &) =
-      default;
-  VariantMoveAssignBaseNontrivial &
-  operator=(VariantMoveAssignBaseNontrivial const &) = default;
-
-  VariantMoveAssignBaseNontrivial &
-  operator=(VariantMoveAssignBaseNontrivial &&other) noexcept(
-      absl::conjunction<std::is_nothrow_move_constructible<T>...,
-                        std::is_nothrow_move_assignable<T>...>::value) {
-    VisitIndices<sizeof...(T)>::Run(
-        VariantCoreAccess::MakeMoveAssignVisitor(this, &other), other.index_);
-    return *this;
-  }
-
-protected:
-  using Base::index_;
-  using Base::state_;
-};
-
-template <class... T>
-class VariantCopyAssignBaseNontrivial : protected VariantMoveAssignBase<T...> {
-  friend struct VariantCoreAccess;
-
-private:
-  using Base = VariantMoveAssignBase<T...>;
-
-protected:
-  using Base::Base;
-
-  VariantCopyAssignBaseNontrivial() = default;
-  VariantCopyAssignBaseNontrivial(VariantCopyAssignBaseNontrivial &&) = default;
-  VariantCopyAssignBaseNontrivial(const VariantCopyAssignBaseNontrivial &) =
-      default;
-  VariantCopyAssignBaseNontrivial &
-  operator=(VariantCopyAssignBaseNontrivial &&) = default;
-
-  VariantCopyAssignBaseNontrivial &
-  operator=(const VariantCopyAssignBaseNontrivial &other) {
-    VisitIndices<sizeof...(T)>::Run(
-        VariantCoreAccess::MakeCopyAssignVisitor(this, other), other.index_);
-    return *this;
-  }
-
-protected:
-  using Base::index_;
-  using Base::state_;
-};
-
-////////////////////////////////////////
-// Visitors for Comparison Operations //
-////////////////////////////////////////
-
-template <class... Types> struct EqualsOp {
-  const variant<Types...> *v;
-  const variant<Types...> *w;
-
-  constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
-    return true;
-  }
-
-  template <std::size_t I> constexpr bool operator()(SizeT<I> /*v_i*/) const {
-    return VariantCoreAccess::Access<I>(*v) == VariantCoreAccess::Access<I>(*w);
-  }
-};
-
-template <class... Types> struct NotEqualsOp {
-  const variant<Types...> *v;
-  const variant<Types...> *w;
-
-  constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
-    return false;
-  }
-
-  template <std::size_t I> constexpr bool operator()(SizeT<I> /*v_i*/) const {
-    return VariantCoreAccess::Access<I>(*v) != VariantCoreAccess::Access<I>(*w);
-  }
-};
-
-template <class... Types> struct LessThanOp {
-  const variant<Types...> *v;
-  const variant<Types...> *w;
-
-  constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
-    return false;
-  }
-
-  template <std::size_t I> constexpr bool operator()(SizeT<I> /*v_i*/) const {
-    return VariantCoreAccess::Access<I>(*v) < VariantCoreAccess::Access<I>(*w);
-  }
-};
-
-template <class... Types> struct GreaterThanOp {
-  const variant<Types...> *v;
-  const variant<Types...> *w;
-
-  constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
-    return false;
-  }
-
-  template <std::size_t I> constexpr bool operator()(SizeT<I> /*v_i*/) const {
-    return VariantCoreAccess::Access<I>(*v) > VariantCoreAccess::Access<I>(*w);
-  }
-};
-
-template <class... Types> struct LessThanOrEqualsOp {
-  const variant<Types...> *v;
-  const variant<Types...> *w;
-
-  constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
-    return true;
-  }
-
-  template <std::size_t I> constexpr bool operator()(SizeT<I> /*v_i*/) const {
-    return VariantCoreAccess::Access<I>(*v) <= VariantCoreAccess::Access<I>(*w);
-  }
-};
-
-template <class... Types> struct GreaterThanOrEqualsOp {
-  const variant<Types...> *v;
-  const variant<Types...> *w;
-
-  constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
-    return true;
-  }
-
-  template <std::size_t I> constexpr bool operator()(SizeT<I> /*v_i*/) const {
-    return VariantCoreAccess::Access<I>(*v) >= VariantCoreAccess::Access<I>(*w);
-  }
-};
-
-// Precondition: v.index() == w.index();
-template <class... Types> struct SwapSameIndex {
-  variant<Types...> *v;
-  variant<Types...> *w;
-  template <std::size_t I> void operator()(SizeT<I>) const {
-    type_traits_internal::Swap(VariantCoreAccess::Access<I>(*v),
-                               VariantCoreAccess::Access<I>(*w));
-  }
-
-  void operator()(SizeT<variant_npos>) const {}
-};
-
-// TODO(calabrese) do this from a different namespace for proper adl usage
-template <class... Types> struct Swap {
-  variant<Types...> *v;
-  variant<Types...> *w;
-
-  void generic_swap() const {
-    variant<Types...> tmp(std::move(*w));
-    VariantCoreAccess::Destroy(*w);
-    VariantCoreAccess::InitFrom(*w, std::move(*v));
-    VariantCoreAccess::Destroy(*v);
-    VariantCoreAccess::InitFrom(*v, std::move(tmp));
-  }
-
-  void operator()(SizeT<absl::variant_npos> /*w_i*/) const {
-    if (!v->valueless_by_exception()) {
-      generic_swap();
-    }
-  }
-
-  template <std::size_t Wi> void operator()(SizeT<Wi> /*w_i*/) {
-    if (v->index() == Wi) {
-      VisitIndices<sizeof...(Types)>::Run(SwapSameIndex<Types...>{v, w}, Wi);
-    } else {
-      generic_swap();
-    }
-  }
-};
-
-template <typename Variant, typename = void, typename... Ts>
-struct VariantHashBase {
-  VariantHashBase() = delete;
-  VariantHashBase(const VariantHashBase &) = delete;
-  VariantHashBase(VariantHashBase &&) = delete;
-  VariantHashBase &operator=(const VariantHashBase &) = delete;
-  VariantHashBase &operator=(VariantHashBase &&) = delete;
-};
-
-struct VariantHashVisitor {
-  template <typename T> size_t operator()(const T &t) {
-    return std::hash<T>{}(t);
-  }
-};
-
-template <typename Variant, typename... Ts>
-struct VariantHashBase<Variant,
-                       absl::enable_if_t<absl::conjunction<
-                           type_traits_internal::IsHashable<Ts>...>::value>,
-                       Ts...> {
-  using argument_type = Variant;
-  using result_type = size_t;
-  size_t operator()(const Variant &var) const {
-    type_traits_internal::AssertHashEnabled<Ts...>();
-    if (var.valueless_by_exception()) {
-      return 239799884;
-    }
-    size_t result = VisitIndices<variant_size<Variant>::value>::Run(
-        PerformVisitation<VariantHashVisitor, const Variant &>{
-            std::forward_as_tuple(var), VariantHashVisitor{}},
-        var.index());
-    // Combine the index and the hash result in order to distinguish
-    // std::variant<int, int> holding the same value as different alternative.
-    return result ^ var.index();
-  }
-};
-
-} // namespace variant_internal
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // !defined(ABSL_USES_STD_VARIANT)
-#endif // ABSL_TYPES_INTERNAL_VARIANT_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/types/optional.h b/packages/react-native-executorch/third-party/include/absl/types/optional.h
deleted file mode 100644
index 4f4b19507f..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/types/optional.h
+++ /dev/null
@@ -1,775 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// optional.h
-// -----------------------------------------------------------------------------
-//
-// This header file defines the `absl::optional` type for holding a value which
-// may or may not be present. This type is useful for providing value semantics
-// for operations that may either wish to return or hold "something-or-nothing".
-//
-// Example:
-//
-//   // A common way to signal operation failure is to provide an output
-//   // parameter and a bool return type:
-//   bool AcquireResource(const Input&, Resource * out);
-//
-//   // Providing an absl::optional return type provides a cleaner API:
-//   absl::optional<Resource> AcquireResource(const Input&);
-//
-// `absl::optional` is a C++11 compatible version of the C++17 `std::optional`
-// abstraction and is designed to be a drop-in replacement for code compliant
-// with C++17.
-#ifndef ABSL_TYPES_OPTIONAL_H_
-#define ABSL_TYPES_OPTIONAL_H_
-
-#include "absl/base/config.h" // TODO(calabrese) IWYU removal?
-#include "absl/utility/utility.h"
-
-#ifdef ABSL_USES_STD_OPTIONAL
-
-#include <optional> // IWYU pragma: export
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-using std::bad_optional_access;
-using std::make_optional;
-using std::nullopt;
-using std::nullopt_t;
-using std::optional;
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#else // ABSL_USES_STD_OPTIONAL
-
-#include <cassert>
-#include <functional>
-#include <initializer_list>
-#include <type_traits>
-#include <utility>
-
-#include "absl/base/attributes.h"
-#include "absl/base/internal/inline_variable.h"
-#include "absl/base/nullability.h"
-#include "absl/meta/type_traits.h"
-#include "absl/types/bad_optional_access.h"
-#include "absl/types/internal/optional.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// nullopt_t
-//
-// Class type for `absl::nullopt` used to indicate an `absl::optional<T>` type
-// that does not contain a value.
-struct nullopt_t {
-  // It must not be default-constructible to avoid ambiguity for opt = {}.
-  explicit constexpr nullopt_t(optional_internal::init_t) noexcept {}
-};
-
-// nullopt
-//
-// A tag constant of type `absl::nullopt_t` used to indicate an empty
-// `absl::optional` in certain functions, such as construction or assignment.
-ABSL_INTERNAL_INLINE_CONSTEXPR(nullopt_t, nullopt,
-                               nullopt_t(optional_internal::init_t()));
-
-// -----------------------------------------------------------------------------
-// absl::optional
-// -----------------------------------------------------------------------------
-//
-// A value of type `absl::optional<T>` holds either a value of `T` or an
-// "empty" value.  When it holds a value of `T`, it stores it as a direct
-// sub-object, so `sizeof(optional<T>)` is approximately
-// `sizeof(T) + sizeof(bool)`.
-//
-// This implementation is based on the specification in the latest draft of the
-// C++17 `std::optional` specification as of May 2017, section 20.6.
-//
-// Differences between `absl::optional<T>` and `std::optional<T>` include:
-//
-//    * `constexpr` is not used for non-const member functions.
-//      (dependency on some differences between C++11 and C++14.)
-//    * `absl::nullopt` and `absl::in_place` are not declared `constexpr`. We
-//      need the inline variable support in C++17 for external linkage.
-//    * Throws `absl::bad_optional_access` instead of
-//      `std::bad_optional_access`.
-//    * `make_optional()` cannot be declared `constexpr` due to the absence of
-//      guaranteed copy elision.
-//    * The move constructor's `noexcept` specification is stronger, i.e. if the
-//      default allocator is non-throwing (via setting
-//      `ABSL_ALLOCATOR_NOTHROW`), it evaluates to `noexcept(true)`, because
-//      we assume
-//       a) move constructors should only throw due to allocation failure and
-//       b) if T's move constructor allocates, it uses the same allocation
-//          function as the default allocator.
-//
-template <typename T>
-class optional : private optional_internal::optional_data<T>,
-                 private optional_internal::optional_ctor_base<
-                     optional_internal::ctor_copy_traits<T>::traits>,
-                 private optional_internal::optional_assign_base<
-                     optional_internal::assign_copy_traits<T>::traits> {
-  using data_base = optional_internal::optional_data<T>;
-
-public:
-  typedef T value_type;
-
-  // Constructors
-
-  // Constructs an `optional` holding an empty value, NOT a default constructed
-  // `T`.
-  constexpr optional() noexcept = default;
-
-  // Constructs an `optional` initialized with `nullopt` to hold an empty value.
-  constexpr optional(nullopt_t) noexcept {} // NOLINT(runtime/explicit)
-
-  // Copy constructor, standard semantics
-  optional(const optional &) = default;
-
-  // Move constructor, standard semantics
-  optional(optional &&) = default;
-
-  // Constructs a non-empty `optional` direct-initialized value of type `T` from
-  // the arguments `std::forward<Args>(args)...`  within the `optional`.
-  // (The `in_place_t` is a tag used to indicate that the contained object
-  // should be constructed in-place.)
-  template <typename InPlaceT, typename... Args,
-            absl::enable_if_t<absl::conjunction<
-                std::is_same<InPlaceT, in_place_t>,
-                std::is_constructible<T, Args &&...>>::value> * = nullptr>
-  constexpr explicit optional(InPlaceT, Args &&...args)
-      : data_base(in_place_t(), std::forward<Args>(args)...) {}
-
-  // Constructs a non-empty `optional` direct-initialized value of type `T` from
-  // the arguments of an initializer_list and `std::forward<Args>(args)...`.
-  // (The `in_place_t` is a tag used to indicate that the contained object
-  // should be constructed in-place.)
-  template <typename U, typename... Args,
-            typename = typename std::enable_if<std::is_constructible<
-                T, std::initializer_list<U> &, Args &&...>::value>::type>
-  constexpr explicit optional(in_place_t, std::initializer_list<U> il,
-                              Args &&...args)
-      : data_base(in_place_t(), il, std::forward<Args>(args)...) {}
-
-  // Value constructor (implicit)
-  template <
-      typename U = T,
-      typename std::enable_if<
-          absl::conjunction<absl::negation<std::is_same<
-                                in_place_t, typename std::decay<U>::type>>,
-                            absl::negation<std::is_same<
-                                optional<T>, typename std::decay<U>::type>>,
-                            std::is_convertible<U &&, T>,
-                            std::is_constructible<T, U &&>>::value,
-          bool>::type = false>
-  constexpr optional(U &&v) : data_base(in_place_t(), std::forward<U>(v)) {}
-
-  // Value constructor (explicit)
-  template <
-      typename U = T,
-      typename std::enable_if<
-          absl::conjunction<absl::negation<std::is_same<
-                                in_place_t, typename std::decay<U>::type>>,
-                            absl::negation<std::is_same<
-                                optional<T>, typename std::decay<U>::type>>,
-                            absl::negation<std::is_convertible<U &&, T>>,
-                            std::is_constructible<T, U &&>>::value,
-          bool>::type = false>
-  explicit constexpr optional(U &&v)
-      : data_base(in_place_t(), std::forward<U>(v)) {}
-
-  // Converting copy constructor (implicit)
-  template <typename U,
-            typename std::enable_if<
-                absl::conjunction<
-                    absl::negation<std::is_same<T, U>>,
-                    std::is_constructible<T, const U &>,
-                    absl::negation<
-                        optional_internal::
-                            is_constructible_convertible_from_optional<T, U>>,
-                    std::is_convertible<const U &, T>>::value,
-                bool>::type = false>
-  optional(const optional<U> &rhs) {
-    if (rhs) {
-      this->construct(*rhs);
-    }
-  }
-
-  // Converting copy constructor (explicit)
-  template <typename U,
-            typename std::enable_if<
-                absl::conjunction<
-                    absl::negation<std::is_same<T, U>>,
-                    std::is_constructible<T, const U &>,
-                    absl::negation<
-                        optional_internal::
-                            is_constructible_convertible_from_optional<T, U>>,
-                    absl::negation<std::is_convertible<const U &, T>>>::value,
-                bool>::type = false>
-  explicit optional(const optional<U> &rhs) {
-    if (rhs) {
-      this->construct(*rhs);
-    }
-  }
-
-  // Converting move constructor (implicit)
-  template <typename U,
-            typename std::enable_if<
-                absl::conjunction<
-                    absl::negation<std::is_same<T, U>>,
-                    std::is_constructible<T, U &&>,
-                    absl::negation<
-                        optional_internal::
-                            is_constructible_convertible_from_optional<T, U>>,
-                    std::is_convertible<U &&, T>>::value,
-                bool>::type = false>
-  optional(optional<U> &&rhs) {
-    if (rhs) {
-      this->construct(std::move(*rhs));
-    }
-  }
-
-  // Converting move constructor (explicit)
-  template <typename U,
-            typename std::enable_if<
-                absl::conjunction<
-                    absl::negation<std::is_same<T, U>>,
-                    std::is_constructible<T, U &&>,
-                    absl::negation<
-                        optional_internal::
-                            is_constructible_convertible_from_optional<T, U>>,
-                    absl::negation<std::is_convertible<U &&, T>>>::value,
-                bool>::type = false>
-  explicit optional(optional<U> &&rhs) {
-    if (rhs) {
-      this->construct(std::move(*rhs));
-    }
-  }
-
-  // Destructor. Trivial if `T` is trivially destructible.
-  ~optional() = default;
-
-  // Assignment Operators
-
-  // Assignment from `nullopt`
-  //
-  // Example:
-  //
-  //   struct S { int value; };
-  //   optional<S> opt = absl::nullopt;  // Could also use opt = { };
-  optional &operator=(nullopt_t) noexcept {
-    this->destruct();
-    return *this;
-  }
-
-  // Copy assignment operator, standard semantics
-  optional &operator=(const optional &src) = default;
-
-  // Move assignment operator, standard semantics
-  optional &operator=(optional &&src) = default;
-
-  // Value assignment operators
-  template <typename U = T,
-            int &..., // Workaround an internal compiler error in GCC 5 to 10.
-            typename = typename std::enable_if<absl::conjunction<
-                absl::negation<
-                    std::is_same<optional<T>, typename std::decay<U>::type>>,
-                absl::negation<absl::conjunction<
-                    std::is_scalar<T>,
-                    std::is_same<T, typename std::decay<U>::type>>>,
-                std::is_constructible<T, U>,
-                std::is_assignable<T &, U>>::value>::type>
-  optional &operator=(U &&v) {
-    this->assign(std::forward<U>(v));
-    return *this;
-  }
-
-  template <typename U,
-            int &..., // Workaround an internal compiler error in GCC 5 to 10.
-            typename = typename std::enable_if<absl::conjunction<
-                absl::negation<std::is_same<T, U>>,
-                std::is_constructible<T, const U &>,
-                std::is_assignable<T &, const U &>,
-                absl::negation<
-                    optional_internal::
-                        is_constructible_convertible_assignable_from_optional<
-                            T, U>>>::value>::type>
-  optional &operator=(const optional<U> &rhs) {
-    if (rhs) {
-      this->assign(*rhs);
-    } else {
-      this->destruct();
-    }
-    return *this;
-  }
-
-  template <typename U,
-            int &..., // Workaround an internal compiler error in GCC 5 to 10.
-            typename = typename std::enable_if<absl::conjunction<
-                absl::negation<std::is_same<T, U>>, std::is_constructible<T, U>,
-                std::is_assignable<T &, U>,
-                absl::negation<
-                    optional_internal::
-                        is_constructible_convertible_assignable_from_optional<
-                            T, U>>>::value>::type>
-  optional &operator=(optional<U> &&rhs) {
-    if (rhs) {
-      this->assign(std::move(*rhs));
-    } else {
-      this->destruct();
-    }
-    return *this;
-  }
-
-  // Modifiers
-
-  // optional::reset()
-  //
-  // Destroys the inner `T` value of an `absl::optional` if one is present.
-  ABSL_ATTRIBUTE_REINITIALIZES void reset() noexcept { this->destruct(); }
-
-  // optional::emplace()
-  //
-  // (Re)constructs the underlying `T` in-place with the given forwarded
-  // arguments.
-  //
-  // Example:
-  //
-  //   optional<Foo> opt;
-  //   opt.emplace(arg1,arg2,arg3);  // Constructs Foo(arg1,arg2,arg3)
-  //
-  // If the optional is non-empty, and the `args` refer to subobjects of the
-  // current object, then behaviour is undefined, because the current object
-  // will be destructed before the new object is constructed with `args`.
-  template <typename... Args,
-            typename = typename std::enable_if<
-                std::is_constructible<T, Args &&...>::value>::type>
-  T &emplace(Args &&...args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    this->destruct();
-    this->construct(std::forward<Args>(args)...);
-    return reference();
-  }
-
-  // Emplace reconstruction overload for an initializer list and the given
-  // forwarded arguments.
-  //
-  // Example:
-  //
-  //   struct Foo {
-  //     Foo(std::initializer_list<int>);
-  //   };
-  //
-  //   optional<Foo> opt;
-  //   opt.emplace({1,2,3});  // Constructs Foo({1,2,3})
-  template <typename U, typename... Args,
-            typename = typename std::enable_if<std::is_constructible<
-                T, std::initializer_list<U> &, Args &&...>::value>::type>
-  T &emplace(std::initializer_list<U> il,
-             Args &&...args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    this->destruct();
-    this->construct(il, std::forward<Args>(args)...);
-    return reference();
-  }
-
-  // Swaps
-
-  // Swap, standard semantics
-  void swap(optional &rhs) noexcept(
-      std::is_nothrow_move_constructible<T>::value &&
-      type_traits_internal::IsNothrowSwappable<T>::value) {
-    if (*this) {
-      if (rhs) {
-        type_traits_internal::Swap(**this, *rhs);
-      } else {
-        rhs.construct(std::move(**this));
-        this->destruct();
-      }
-    } else {
-      if (rhs) {
-        this->construct(std::move(*rhs));
-        rhs.destruct();
-      } else {
-        // No effect (swap(disengaged, disengaged)).
-      }
-    }
-  }
-
-  // Observers
-
-  // optional::operator->()
-  //
-  // Accesses the underlying `T` value's member `m` of an `optional`. If the
-  // `optional` is empty, behavior is undefined.
-  //
-  // If you need myOpt->foo in constexpr, use (*myOpt).foo instead.
-  absl::Nonnull<const T *> operator->() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    ABSL_HARDENING_ASSERT(this->engaged_);
-    return std::addressof(this->data_);
-  }
-  absl::Nonnull<T *> operator->() ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    ABSL_HARDENING_ASSERT(this->engaged_);
-    return std::addressof(this->data_);
-  }
-
-  // optional::operator*()
-  //
-  // Accesses the underlying `T` value of an `optional`. If the `optional` is
-  // empty, behavior is undefined.
-  constexpr const T &operator*() const &ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    return ABSL_HARDENING_ASSERT(this->engaged_), reference();
-  }
-  T &operator*() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    ABSL_HARDENING_ASSERT(this->engaged_);
-    return reference();
-  }
-  constexpr const T &&operator*() const &&ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    return ABSL_HARDENING_ASSERT(this->engaged_), std::move(reference());
-  }
-  T &&operator*() && ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    ABSL_HARDENING_ASSERT(this->engaged_);
-    return std::move(reference());
-  }
-
-  // optional::operator bool()
-  //
-  // Returns false if and only if the `optional` is empty.
-  //
-  //   if (opt) {
-  //     // do something with *opt or opt->;
-  //   } else {
-  //     // opt is empty.
-  //   }
-  //
-  constexpr explicit operator bool() const noexcept { return this->engaged_; }
-
-  // optional::has_value()
-  //
-  // Determines whether the `optional` contains a value. Returns `false` if and
-  // only if `*this` is empty.
-  constexpr bool has_value() const noexcept { return this->engaged_; }
-
-// Suppress bogus warning on MSVC: MSVC complains call to reference() after
-// throw_bad_optional_access() is unreachable.
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4702)
-#endif // _MSC_VER
-  // optional::value()
-  //
-  // Returns a reference to an `optional`s underlying value. The constness
-  // and lvalue/rvalue-ness of the `optional` is preserved to the view of
-  // the `T` sub-object. Throws `absl::bad_optional_access` when the `optional`
-  // is empty.
-  constexpr const T &value() const &ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    return static_cast<bool>(*this)
-               ? reference()
-               : (optional_internal::throw_bad_optional_access(), reference());
-  }
-  T &value() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    return static_cast<bool>(*this)
-               ? reference()
-               : (optional_internal::throw_bad_optional_access(), reference());
-  }
-  T &&value() && ABSL_ATTRIBUTE_LIFETIME_BOUND { // NOLINT(build/c++11)
-    return std::move(
-        static_cast<bool>(*this)
-            ? reference()
-            : (optional_internal::throw_bad_optional_access(), reference()));
-  }
-  constexpr const T &&
-  value() const &&ABSL_ATTRIBUTE_LIFETIME_BOUND { // NOLINT(build/c++11)
-    return std::move(
-        static_cast<bool>(*this)
-            ? reference()
-            : (optional_internal::throw_bad_optional_access(), reference()));
-  }
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif // _MSC_VER
-
-  // optional::value_or()
-  //
-  // Returns either the value of `T` or a passed default `v` if the `optional`
-  // is empty.
-  template <typename U> constexpr T value_or(U &&v) const & {
-    static_assert(std::is_copy_constructible<value_type>::value,
-                  "optional<T>::value_or: T must be copy constructible");
-    static_assert(std::is_convertible<U &&, value_type>::value,
-                  "optional<T>::value_or: U must be convertible to T");
-    return static_cast<bool>(*this) ? **this
-                                    : static_cast<T>(std::forward<U>(v));
-  }
-  template <typename U> T value_or(U &&v) && { // NOLINT(build/c++11)
-    static_assert(std::is_move_constructible<value_type>::value,
-                  "optional<T>::value_or: T must be move constructible");
-    static_assert(std::is_convertible<U &&, value_type>::value,
-                  "optional<T>::value_or: U must be convertible to T");
-    return static_cast<bool>(*this) ? std::move(**this)
-                                    : static_cast<T>(std::forward<U>(v));
-  }
-
-private:
-  // Private accessors for internal storage viewed as reference to T.
-  constexpr const T &reference() const { return this->data_; }
-  T &reference() { return this->data_; }
-
-  // T constraint checks.  You can't have an optional of nullopt_t, in_place_t
-  // or a reference.
-  static_assert(
-      !std::is_same<nullopt_t, typename std::remove_cv<T>::type>::value,
-      "optional<nullopt_t> is not allowed.");
-  static_assert(
-      !std::is_same<in_place_t, typename std::remove_cv<T>::type>::value,
-      "optional<in_place_t> is not allowed.");
-  static_assert(!std::is_reference<T>::value,
-                "optional<reference> is not allowed.");
-};
-
-// Non-member functions
-
-// swap()
-//
-// Performs a swap between two `absl::optional` objects, using standard
-// semantics.
-template <typename T, typename std::enable_if<
-                          std::is_move_constructible<T>::value &&
-                              type_traits_internal::IsSwappable<T>::value,
-                          bool>::type = false>
-void swap(optional<T> &a, optional<T> &b) noexcept(noexcept(a.swap(b))) {
-  a.swap(b);
-}
-
-// make_optional()
-//
-// Creates a non-empty `optional<T>` where the type of `T` is deduced. An
-// `absl::optional` can also be explicitly instantiated with
-// `make_optional<T>(v)`.
-//
-// Note: `make_optional()` constructions may be declared `constexpr` for
-// trivially copyable types `T`. Non-trivial types require copy elision
-// support in C++17 for `make_optional` to support `constexpr` on such
-// non-trivial types.
-//
-// Example:
-//
-//   constexpr absl::optional<int> opt = absl::make_optional(1);
-//   static_assert(opt.value() == 1, "");
-template <typename T>
-constexpr optional<typename std::decay<T>::type> make_optional(T &&v) {
-  return optional<typename std::decay<T>::type>(std::forward<T>(v));
-}
-
-template <typename T, typename... Args>
-constexpr optional<T> make_optional(Args &&...args) {
-  return optional<T>(in_place_t(), std::forward<Args>(args)...);
-}
-
-template <typename T, typename U, typename... Args>
-constexpr optional<T> make_optional(std::initializer_list<U> il,
-                                    Args &&...args) {
-  return optional<T>(in_place_t(), il, std::forward<Args>(args)...);
-}
-
-// Relational operators [optional.relops]
-
-// Empty optionals are considered equal to each other and less than non-empty
-// optionals. Supports relations between optional<T> and optional<U>, between
-// optional<T> and U, and between optional<T> and nullopt.
-//
-// Note: We're careful to support T having non-bool relationals.
-
-// Requires: The expression, e.g. "*x == *y" shall be well-formed and its result
-// shall be convertible to bool.
-// The C++17 (N4606) "Returns:" statements are translated into
-// code in an obvious way here, and the original text retained as function docs.
-// Returns: If bool(x) != bool(y), false; otherwise if bool(x) == false, true;
-// otherwise *x == *y.
-template <typename T, typename U>
-constexpr auto operator==(const optional<T> &x, const optional<U> &y)
-    -> decltype(optional_internal::convertible_to_bool(*x == *y)) {
-  return static_cast<bool>(x) != static_cast<bool>(y) ? false
-         : static_cast<bool>(x) == false              ? true
-                                         : static_cast<bool>(*x == *y);
-}
-
-// Returns: If bool(x) != bool(y), true; otherwise, if bool(x) == false, false;
-// otherwise *x != *y.
-template <typename T, typename U>
-constexpr auto operator!=(const optional<T> &x, const optional<U> &y)
-    -> decltype(optional_internal::convertible_to_bool(*x != *y)) {
-  return static_cast<bool>(x) != static_cast<bool>(y) ? true
-         : static_cast<bool>(x) == false              ? false
-                                         : static_cast<bool>(*x != *y);
-}
-// Returns: If !y, false; otherwise, if !x, true; otherwise *x < *y.
-template <typename T, typename U>
-constexpr auto operator<(const optional<T> &x, const optional<U> &y)
-    -> decltype(optional_internal::convertible_to_bool(*x < *y)) {
-  return !y ? false : !x ? true : static_cast<bool>(*x < *y);
-}
-// Returns: If !x, false; otherwise, if !y, true; otherwise *x > *y.
-template <typename T, typename U>
-constexpr auto operator>(const optional<T> &x, const optional<U> &y)
-    -> decltype(optional_internal::convertible_to_bool(*x > *y)) {
-  return !x ? false : !y ? true : static_cast<bool>(*x > *y);
-}
-// Returns: If !x, true; otherwise, if !y, false; otherwise *x <= *y.
-template <typename T, typename U>
-constexpr auto operator<=(const optional<T> &x, const optional<U> &y)
-    -> decltype(optional_internal::convertible_to_bool(*x <= *y)) {
-  return !x ? true : !y ? false : static_cast<bool>(*x <= *y);
-}
-// Returns: If !y, true; otherwise, if !x, false; otherwise *x >= *y.
-template <typename T, typename U>
-constexpr auto operator>=(const optional<T> &x, const optional<U> &y)
-    -> decltype(optional_internal::convertible_to_bool(*x >= *y)) {
-  return !y ? true : !x ? false : static_cast<bool>(*x >= *y);
-}
-
-// Comparison with nullopt [optional.nullops]
-// The C++17 (N4606) "Returns:" statements are used directly here.
-template <typename T>
-constexpr bool operator==(const optional<T> &x, nullopt_t) noexcept {
-  return !x;
-}
-template <typename T>
-constexpr bool operator==(nullopt_t, const optional<T> &x) noexcept {
-  return !x;
-}
-template <typename T>
-constexpr bool operator!=(const optional<T> &x, nullopt_t) noexcept {
-  return static_cast<bool>(x);
-}
-template <typename T>
-constexpr bool operator!=(nullopt_t, const optional<T> &x) noexcept {
-  return static_cast<bool>(x);
-}
-template <typename T>
-constexpr bool operator<(const optional<T> &, nullopt_t) noexcept {
-  return false;
-}
-template <typename T>
-constexpr bool operator<(nullopt_t, const optional<T> &x) noexcept {
-  return static_cast<bool>(x);
-}
-template <typename T>
-constexpr bool operator<=(const optional<T> &x, nullopt_t) noexcept {
-  return !x;
-}
-template <typename T>
-constexpr bool operator<=(nullopt_t, const optional<T> &) noexcept {
-  return true;
-}
-template <typename T>
-constexpr bool operator>(const optional<T> &x, nullopt_t) noexcept {
-  return static_cast<bool>(x);
-}
-template <typename T>
-constexpr bool operator>(nullopt_t, const optional<T> &) noexcept {
-  return false;
-}
-template <typename T>
-constexpr bool operator>=(const optional<T> &, nullopt_t) noexcept {
-  return true;
-}
-template <typename T>
-constexpr bool operator>=(nullopt_t, const optional<T> &x) noexcept {
-  return !x;
-}
-
-// Comparison with T [optional.comp_with_t]
-
-// Requires: The expression, e.g. "*x == v" shall be well-formed and its result
-// shall be convertible to bool.
-// The C++17 (N4606) "Equivalent to:" statements are used directly here.
-template <typename T, typename U>
-constexpr auto operator==(const optional<T> &x, const U &v)
-    -> decltype(optional_internal::convertible_to_bool(*x == v)) {
-  return static_cast<bool>(x) ? static_cast<bool>(*x == v) : false;
-}
-template <typename T, typename U>
-constexpr auto operator==(const U &v, const optional<T> &x)
-    -> decltype(optional_internal::convertible_to_bool(v == *x)) {
-  return static_cast<bool>(x) ? static_cast<bool>(v == *x) : false;
-}
-template <typename T, typename U>
-constexpr auto operator!=(const optional<T> &x, const U &v)
-    -> decltype(optional_internal::convertible_to_bool(*x != v)) {
-  return static_cast<bool>(x) ? static_cast<bool>(*x != v) : true;
-}
-template <typename T, typename U>
-constexpr auto operator!=(const U &v, const optional<T> &x)
-    -> decltype(optional_internal::convertible_to_bool(v != *x)) {
-  return static_cast<bool>(x) ? static_cast<bool>(v != *x) : true;
-}
-template <typename T, typename U>
-constexpr auto operator<(const optional<T> &x, const U &v)
-    -> decltype(optional_internal::convertible_to_bool(*x < v)) {
-  return static_cast<bool>(x) ? static_cast<bool>(*x < v) : true;
-}
-template <typename T, typename U>
-constexpr auto operator<(const U &v, const optional<T> &x)
-    -> decltype(optional_internal::convertible_to_bool(v < *x)) {
-  return static_cast<bool>(x) ? static_cast<bool>(v < *x) : false;
-}
-template <typename T, typename U>
-constexpr auto operator<=(const optional<T> &x, const U &v)
-    -> decltype(optional_internal::convertible_to_bool(*x <= v)) {
-  return static_cast<bool>(x) ? static_cast<bool>(*x <= v) : true;
-}
-template <typename T, typename U>
-constexpr auto operator<=(const U &v, const optional<T> &x)
-    -> decltype(optional_internal::convertible_to_bool(v <= *x)) {
-  return static_cast<bool>(x) ? static_cast<bool>(v <= *x) : false;
-}
-template <typename T, typename U>
-constexpr auto operator>(const optional<T> &x, const U &v)
-    -> decltype(optional_internal::convertible_to_bool(*x > v)) {
-  return static_cast<bool>(x) ? static_cast<bool>(*x > v) : false;
-}
-template <typename T, typename U>
-constexpr auto operator>(const U &v, const optional<T> &x)
-    -> decltype(optional_internal::convertible_to_bool(v > *x)) {
-  return static_cast<bool>(x) ? static_cast<bool>(v > *x) : true;
-}
-template <typename T, typename U>
-constexpr auto operator>=(const optional<T> &x, const U &v)
-    -> decltype(optional_internal::convertible_to_bool(*x >= v)) {
-  return static_cast<bool>(x) ? static_cast<bool>(*x >= v) : false;
-}
-template <typename T, typename U>
-constexpr auto operator>=(const U &v, const optional<T> &x)
-    -> decltype(optional_internal::convertible_to_bool(v >= *x)) {
-  return static_cast<bool>(x) ? static_cast<bool>(v >= *x) : true;
-}
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-namespace std {
-
-// std::hash specialization for absl::optional.
-template <typename T>
-struct hash<absl::optional<T>>
-    : absl::optional_internal::optional_hash_base<T> {};
-
-} // namespace std
-
-#undef ABSL_MSVC_CONSTEXPR_BUG_IN_UNION_LIKE_CLASS
-
-#endif // ABSL_USES_STD_OPTIONAL
-
-#endif // ABSL_TYPES_OPTIONAL_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/types/span.h b/packages/react-native-executorch/third-party/include/absl/types/span.h
deleted file mode 100644
index 8ea7ff3e4a..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/types/span.h
+++ /dev/null
@@ -1,787 +0,0 @@
-//
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// span.h
-// -----------------------------------------------------------------------------
-//
-// This header file defines a `Span<T>` type for holding a reference to existing
-// array data. The `Span` object, much like the `absl::string_view` object,
-// does not own such data itself, and the data being referenced by the span must
-// outlive the span itself. Unlike `view` type references, a span can hold a
-// reference to mutable data (and can mutate it for underlying types of
-// non-const T.) A span provides a lightweight way to pass a reference to such
-// data.
-//
-// Additionally, this header file defines `MakeSpan()` and `MakeConstSpan()`
-// factory functions, for clearly creating spans of type `Span<T>` or read-only
-// `Span<const T>` when such types may be difficult to identify due to issues
-// with implicit conversion.
-//
-// The C++20 draft standard includes a `std::span` type. As of June 2020, the
-// differences between `absl::Span` and `std::span` are:
-//    * `absl::Span` has `operator==` (which is likely a design bug,
-//       per https://abseil.io/blog/20180531-regular-types)
-//    * `absl::Span` has the factory functions `MakeSpan()` and
-//      `MakeConstSpan()`
-//    * bounds-checked access to `absl::Span` is accomplished with `at()`
-//    * `absl::Span` has compiler-provided move and copy constructors and
-//      assignment. This is due to them being specified as `constexpr`, but that
-//      implies const in C++11.
-//    * A read-only `absl::Span<const T>` can be implicitly constructed from an
-//      initializer list.
-//    * `absl::Span` has no `bytes()`, `size_bytes()`, `as_bytes()`, or
-//      `as_writable_bytes()` methods
-//    * `absl::Span` has no static extent template parameter, nor constructors
-//      which exist only because of the static extent parameter.
-//    * `absl::Span` has an explicit mutable-reference constructor
-//
-// For more information, see the class comments below.
-#ifndef ABSL_TYPES_SPAN_H_
-#define ABSL_TYPES_SPAN_H_
-
-#include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <initializer_list>
-#include <iterator>
-#include <type_traits>
-#include <utility>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/base/internal/throw_delegate.h"
-#include "absl/base/macros.h"
-#include "absl/base/nullability.h"
-#include "absl/base/optimization.h"
-#include "absl/base/port.h" // TODO(strel): remove this include
-#include "absl/meta/type_traits.h"
-#include "absl/types/internal/span.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-template <typename T> class Span;
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-// If std::ranges is available, mark Span as satisfying the `view` and
-// `borrowed_range` concepts, just like std::span.
-#if !defined(__has_include)
-#define __has_include(header) 0
-#endif
-#if __has_include(<version>)
-#include <version> // NOLINT(misc-include-cleaner)
-#endif
-#if defined(__cpp_lib_ranges) && __cpp_lib_ranges >= 201911L
-#include <ranges> // NOLINT(build/c++20)
-template <typename T>
-// NOLINTNEXTLINE(build/c++20)
-inline constexpr bool std::ranges::enable_view<absl::Span<T>> = true;
-template <typename T>
-// NOLINTNEXTLINE(build/c++20)
-inline constexpr bool std::ranges::enable_borrowed_range<absl::Span<T>> = true;
-#endif
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-//------------------------------------------------------------------------------
-// Span
-//------------------------------------------------------------------------------
-//
-// A `Span` is an "array reference" type for holding a reference of contiguous
-// array data; the `Span` object does not and cannot own such data itself. A
-// span provides an easy way to provide overloads for anything operating on
-// contiguous sequences without needing to manage pointers and array lengths
-// manually.
-
-// A span is conceptually a pointer (ptr) and a length (size) into an already
-// existing array of contiguous memory; the array it represents references the
-// elements "ptr[0] .. ptr[size-1]". Passing a properly-constructed `Span`
-// instead of raw pointers avoids many issues related to index out of bounds
-// errors.
-//
-// Spans may also be constructed from containers holding contiguous sequences.
-// Such containers must supply `data()` and `size() const` methods (e.g
-// `std::vector<T>`, `absl::InlinedVector<T, N>`). All implicit conversions to
-// `absl::Span` from such containers will create spans of type `const T`;
-// spans which can mutate their values (of type `T`) must use explicit
-// constructors.
-//
-// A `Span<T>` is somewhat analogous to an `absl::string_view`, but for an array
-// of elements of type `T`, and unlike an `absl::string_view`, a span can hold a
-// reference to mutable data. A user of `Span` must ensure that the data being
-// pointed to outlives the `Span` itself.
-//
-// You can construct a `Span<T>` in several ways:
-//
-//   * Explicitly from a reference to a container type
-//   * Explicitly from a pointer and size
-//   * Implicitly from a container type (but only for spans of type `const T`)
-//   * Using the `MakeSpan()` or `MakeConstSpan()` factory functions.
-//
-// Examples:
-//
-//   // Construct a Span explicitly from a container:
-//   std::vector<int> v = {1, 2, 3, 4, 5};
-//   auto span = absl::Span<const int>(v);
-//
-//   // Construct a Span explicitly from a C-style array:
-//   int a[5] =  {1, 2, 3, 4, 5};
-//   auto span = absl::Span<const int>(a);
-//
-//   // Construct a Span implicitly from a container
-//   void MyRoutine(absl::Span<const int> a) {
-//     ...
-//   }
-//   std::vector v = {1,2,3,4,5};
-//   MyRoutine(v)                     // convert to Span<const T>
-//
-// Note that `Span` objects, in addition to requiring that the memory they
-// point to remains alive, must also ensure that such memory does not get
-// reallocated. Therefore, to avoid undefined behavior, containers with
-// associated spans should not invoke operations that may reallocate memory
-// (such as resizing) or invalidate iterators into the container.
-//
-// One common use for a `Span` is when passing arguments to a routine that can
-// accept a variety of array types (e.g. a `std::vector`, `absl::InlinedVector`,
-// a C-style array, etc.). Instead of creating overloads for each case, you
-// can simply specify a `Span` as the argument to such a routine.
-//
-// Example:
-//
-//   void MyRoutine(absl::Span<const int> a) {
-//     ...
-//   }
-//
-//   std::vector v = {1,2,3,4,5};
-//   MyRoutine(v);
-//
-//   absl::InlinedVector<int, 4> my_inline_vector;
-//   MyRoutine(my_inline_vector);
-//
-//   // Explicit constructor from pointer,size
-//   int* my_array = new int[10];
-//   MyRoutine(absl::Span<const int>(my_array, 10));
-template <typename T> class ABSL_ATTRIBUTE_VIEW Span {
-private:
-  // Used to determine whether a Span can be constructed from a container of
-  // type C.
-  template <typename C>
-  using EnableIfConvertibleFrom =
-      typename std::enable_if<span_internal::HasData<T, C>::value &&
-                              span_internal::HasSize<C>::value>::type;
-
-  // Used to SFINAE-enable a function when the slice elements are const.
-  template <typename U>
-  using EnableIfValueIsConst =
-      typename std::enable_if<std::is_const<T>::value, U>::type;
-
-  // Used to SFINAE-enable a function when the slice elements are mutable.
-  template <typename U>
-  using EnableIfValueIsMutable =
-      typename std::enable_if<!std::is_const<T>::value, U>::type;
-
-public:
-  using element_type = T;
-  using value_type = absl::remove_cv_t<T>;
-  // TODO(b/316099902) - pointer should be Nullable<T*>, but this makes it hard
-  // to recognize foreach loops as safe.
-  using pointer = T *;
-  using const_pointer = const T *;
-  using reference = T &;
-  using const_reference = const T &;
-  using iterator = pointer;
-  using const_iterator = const_pointer;
-  using reverse_iterator = std::reverse_iterator<iterator>;
-  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-  using size_type = size_t;
-  using difference_type = ptrdiff_t;
-  using absl_internal_is_view = std::true_type;
-
-  // NOLINTNEXTLINE
-  static const size_type npos = ~(size_type(0));
-
-  constexpr Span() noexcept : Span(nullptr, 0) {}
-  constexpr Span(pointer array ABSL_ATTRIBUTE_LIFETIME_BOUND,
-                 size_type length) noexcept
-      : ptr_(array), len_(length) {}
-
-  // Implicit conversion constructors
-  template <size_t N>
-  constexpr Span(T( // NOLINT(google-explicit-constructor)
-      &a ABSL_ATTRIBUTE_LIFETIME_BOUND)[N]) noexcept
-      : Span(a, N) {}
-
-  // Explicit reference constructor for a mutable `Span<T>` type. Can be
-  // replaced with MakeSpan() to infer the type parameter.
-  template <typename V, typename = EnableIfConvertibleFrom<V>,
-            typename = EnableIfValueIsMutable<V>,
-            typename = span_internal::EnableIfNotIsView<V>>
-  explicit Span(
-      V &v ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept // NOLINT(runtime/references)
-      : Span(span_internal::GetData(v), v.size()) {}
-
-  // Implicit reference constructor for a read-only `Span<const T>` type
-  template <typename V, typename = EnableIfConvertibleFrom<V>,
-            typename = EnableIfValueIsConst<V>,
-            typename = span_internal::EnableIfNotIsView<V>>
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  constexpr Span(const V &v ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
-      : Span(span_internal::GetData(v), v.size()) {}
-
-  // Overloads of the above two functions that are only enabled for view types.
-  // This is so we can drop the ABSL_ATTRIBUTE_LIFETIME_BOUND annotation. These
-  // overloads must be made unique by using a different template parameter list
-  // (hence the = 0 for the IsView enabler).
-  template <typename V, typename = EnableIfConvertibleFrom<V>,
-            typename = EnableIfValueIsMutable<V>,
-            span_internal::EnableIfIsView<V> = 0>
-  explicit Span(V &v) noexcept // NOLINT(runtime/references)
-      : Span(span_internal::GetData(v), v.size()) {}
-  template <typename V, typename = EnableIfConvertibleFrom<V>,
-            typename = EnableIfValueIsConst<V>,
-            span_internal::EnableIfIsView<V> = 0>
-  constexpr Span(const V &v) noexcept // NOLINT(google-explicit-constructor)
-      : Span(span_internal::GetData(v), v.size()) {}
-
-  // Implicit constructor from an initializer list, making it possible to pass a
-  // brace-enclosed initializer list to a function expecting a `Span`. Such
-  // spans constructed from an initializer list must be of type `Span<const T>`.
-  //
-  //   void Process(absl::Span<const int> x);
-  //   Process({1, 2, 3});
-  //
-  // Note that as always the array referenced by the span must outlive the span.
-  // Since an initializer list constructor acts as if it is fed a temporary
-  // array (cf. C++ standard [dcl.init.list]/5), it's safe to use this
-  // constructor only when the `std::initializer_list` itself outlives the span.
-  // In order to meet this requirement it's sufficient to ensure that neither
-  // the span nor a copy of it is used outside of the expression in which it's
-  // created:
-  //
-  //   // Assume that this function uses the array directly, not retaining any
-  //   // copy of the span or pointer to any of its elements.
-  //   void Process(absl::Span<const int> ints);
-  //
-  //   // Okay: the std::initializer_list<int> will reference a temporary array
-  //   // that isn't destroyed until after the call to Process returns.
-  //   Process({ 17, 19 });
-  //
-  //   // Not okay: the storage used by the std::initializer_list<int> is not
-  //   // allowed to be referenced after the first line.
-  //   absl::Span<const int> ints = { 17, 19 };
-  //   Process(ints);
-  //
-  //   // Not okay for the same reason as above: even when the elements of the
-  //   // initializer list expression are not temporaries the underlying array
-  //   // is, so the initializer list must still outlive the span.
-  //   const int foo = 17;
-  //   absl::Span<const int> ints = { foo };
-  //   Process(ints);
-  //
-  template <typename LazyT = T,
-            typename = EnableIfValueIsConst<LazyT>>
-  Span(std::initializer_list<value_type> v
-           ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept // NOLINT(runtime/explicit)
-      : Span(v.begin(), v.size()) {}
-
-  // Accessors
-
-  // Span::data()
-  //
-  // Returns a pointer to the span's underlying array of data (which is held
-  // outside the span).
-  constexpr pointer data() const noexcept { return ptr_; }
-
-  // Span::size()
-  //
-  // Returns the size of this span.
-  constexpr size_type size() const noexcept { return len_; }
-
-  // Span::length()
-  //
-  // Returns the length (size) of this span.
-  constexpr size_type length() const noexcept { return size(); }
-
-  // Span::empty()
-  //
-  // Returns a boolean indicating whether or not this span is considered empty.
-  constexpr bool empty() const noexcept { return size() == 0; }
-
-  // Span::operator[]
-  //
-  // Returns a reference to the i'th element of this span.
-  constexpr reference operator[](size_type i) const noexcept {
-    return ABSL_HARDENING_ASSERT(i < size()), ptr_[i];
-  }
-
-  // Span::at()
-  //
-  // Returns a reference to the i'th element of this span.
-  constexpr reference at(size_type i) const {
-    return ABSL_PREDICT_TRUE(i < size()) //
-               ? *(data() + i)
-               : (base_internal::ThrowStdOutOfRange(
-                      "Span::at failed bounds check"),
-                  *(data() + i));
-  }
-
-  // Span::front()
-  //
-  // Returns a reference to the first element of this span. The span must not
-  // be empty.
-  constexpr reference front() const noexcept {
-    return ABSL_HARDENING_ASSERT(size() > 0), *data();
-  }
-
-  // Span::back()
-  //
-  // Returns a reference to the last element of this span. The span must not
-  // be empty.
-  constexpr reference back() const noexcept {
-    return ABSL_HARDENING_ASSERT(size() > 0), *(data() + size() - 1);
-  }
-
-  // Span::begin()
-  //
-  // Returns an iterator pointing to the first element of this span, or `end()`
-  // if the span is empty.
-  constexpr iterator begin() const noexcept { return data(); }
-
-  // Span::cbegin()
-  //
-  // Returns a const iterator pointing to the first element of this span, or
-  // `end()` if the span is empty.
-  constexpr const_iterator cbegin() const noexcept { return begin(); }
-
-  // Span::end()
-  //
-  // Returns an iterator pointing just beyond the last element at the
-  // end of this span. This iterator acts as a placeholder; attempting to
-  // access it results in undefined behavior.
-  constexpr iterator end() const noexcept { return data() + size(); }
-
-  // Span::cend()
-  //
-  // Returns a const iterator pointing just beyond the last element at the
-  // end of this span. This iterator acts as a placeholder; attempting to
-  // access it results in undefined behavior.
-  constexpr const_iterator cend() const noexcept { return end(); }
-
-  // Span::rbegin()
-  //
-  // Returns a reverse iterator pointing to the last element at the end of this
-  // span, or `rend()` if the span is empty.
-  constexpr reverse_iterator rbegin() const noexcept {
-    return reverse_iterator(end());
-  }
-
-  // Span::crbegin()
-  //
-  // Returns a const reverse iterator pointing to the last element at the end of
-  // this span, or `crend()` if the span is empty.
-  constexpr const_reverse_iterator crbegin() const noexcept { return rbegin(); }
-
-  // Span::rend()
-  //
-  // Returns a reverse iterator pointing just before the first element
-  // at the beginning of this span. This pointer acts as a placeholder;
-  // attempting to access its element results in undefined behavior.
-  constexpr reverse_iterator rend() const noexcept {
-    return reverse_iterator(begin());
-  }
-
-  // Span::crend()
-  //
-  // Returns a reverse const iterator pointing just before the first element
-  // at the beginning of this span. This pointer acts as a placeholder;
-  // attempting to access its element results in undefined behavior.
-  constexpr const_reverse_iterator crend() const noexcept { return rend(); }
-
-  // Span mutations
-
-  // Span::remove_prefix()
-  //
-  // Removes the first `n` elements from the span.
-  void remove_prefix(size_type n) noexcept {
-    ABSL_HARDENING_ASSERT(size() >= n);
-    ptr_ += n;
-    len_ -= n;
-  }
-
-  // Span::remove_suffix()
-  //
-  // Removes the last `n` elements from the span.
-  void remove_suffix(size_type n) noexcept {
-    ABSL_HARDENING_ASSERT(size() >= n);
-    len_ -= n;
-  }
-
-  // Span::subspan()
-  //
-  // Returns a `Span` starting at element `pos` and of length `len`. Both `pos`
-  // and `len` are of type `size_type` and thus non-negative. Parameter `pos`
-  // must be <= size(). Any `len` value that points past the end of the span
-  // will be trimmed to at most size() - `pos`. A default `len` value of `npos`
-  // ensures the returned subspan continues until the end of the span.
-  //
-  // Examples:
-  //
-  //   std::vector<int> vec = {10, 11, 12, 13};
-  //   absl::MakeSpan(vec).subspan(1, 2);  // {11, 12}
-  //   absl::MakeSpan(vec).subspan(2, 8);  // {12, 13}
-  //   absl::MakeSpan(vec).subspan(1);     // {11, 12, 13}
-  //   absl::MakeSpan(vec).subspan(4);     // {}
-  //   absl::MakeSpan(vec).subspan(5);     // throws std::out_of_range
-  constexpr Span subspan(size_type pos = 0, size_type len = npos) const {
-    return (pos <= size())
-               ? Span(data() + pos, (std::min)(size() - pos, len))
-               : (base_internal::ThrowStdOutOfRange("pos > size()"), Span());
-  }
-
-  // Span::first()
-  //
-  // Returns a `Span` containing first `len` elements. Parameter `len` is of
-  // type `size_type` and thus non-negative. `len` value must be <= size().
-  //
-  // Examples:
-  //
-  //   std::vector<int> vec = {10, 11, 12, 13};
-  //   absl::MakeSpan(vec).first(1);  // {10}
-  //   absl::MakeSpan(vec).first(3);  // {10, 11, 12}
-  //   absl::MakeSpan(vec).first(5);  // throws std::out_of_range
-  constexpr Span first(size_type len) const {
-    return (len <= size())
-               ? Span(data(), len)
-               : (base_internal::ThrowStdOutOfRange("len > size()"), Span());
-  }
-
-  // Span::last()
-  //
-  // Returns a `Span` containing last `len` elements. Parameter `len` is of
-  // type `size_type` and thus non-negative. `len` value must be <= size().
-  //
-  // Examples:
-  //
-  //   std::vector<int> vec = {10, 11, 12, 13};
-  //   absl::MakeSpan(vec).last(1);  // {13}
-  //   absl::MakeSpan(vec).last(3);  // {11, 12, 13}
-  //   absl::MakeSpan(vec).last(5);  // throws std::out_of_range
-  constexpr Span last(size_type len) const {
-    return (len <= size())
-               ? Span(size() - len + data(), len)
-               : (base_internal::ThrowStdOutOfRange("len > size()"), Span());
-  }
-
-  // Support for absl::Hash.
-  template <typename H> friend H AbslHashValue(H h, Span v) {
-    return H::combine(H::combine_contiguous(std::move(h), v.data(), v.size()),
-                      v.size());
-  }
-
-private:
-  pointer ptr_;
-  size_type len_;
-};
-
-template <typename T> const typename Span<T>::size_type Span<T>::npos;
-
-// Span relationals
-
-// Equality is compared element-by-element, while ordering is lexicographical.
-// We provide three overloads for each operator to cover any combination on the
-// left or right hand side of mutable Span<T>, read-only Span<const T>, and
-// convertible-to-read-only Span<T>.
-// TODO(zhangxy): Due to MSVC overload resolution bug with partial ordering
-// template functions, 5 overloads per operator is needed as a workaround. We
-// should update them to 3 overloads per operator using non-deduced context like
-// string_view, i.e.
-// - (Span<T>, Span<T>)
-// - (Span<T>, non_deduced<Span<const T>>)
-// - (non_deduced<Span<const T>>, Span<T>)
-
-// operator==
-template <typename T>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator==(Span<T> a, Span<T> b) {
-  return span_internal::EqualImpl<Span, const T>(a, b);
-}
-template <typename T>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator==(Span<const T> a,
-                                                    Span<T> b) {
-  return span_internal::EqualImpl<Span, const T>(a, b);
-}
-template <typename T>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator==(Span<T> a,
-                                                    Span<const T> b) {
-  return span_internal::EqualImpl<Span, const T>(a, b);
-}
-template <
-    typename T, typename U,
-    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator==(const U &a, Span<T> b) {
-  return span_internal::EqualImpl<Span, const T>(a, b);
-}
-template <
-    typename T, typename U,
-    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator==(Span<T> a, const U &b) {
-  return span_internal::EqualImpl<Span, const T>(a, b);
-}
-
-// operator!=
-template <typename T>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator!=(Span<T> a, Span<T> b) {
-  return !(a == b);
-}
-template <typename T>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator!=(Span<const T> a,
-                                                    Span<T> b) {
-  return !(a == b);
-}
-template <typename T>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator!=(Span<T> a,
-                                                    Span<const T> b) {
-  return !(a == b);
-}
-template <
-    typename T, typename U,
-    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator!=(const U &a, Span<T> b) {
-  return !(a == b);
-}
-template <
-    typename T, typename U,
-    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator!=(Span<T> a, const U &b) {
-  return !(a == b);
-}
-
-// operator<
-template <typename T>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator<(Span<T> a, Span<T> b) {
-  return span_internal::LessThanImpl<Span, const T>(a, b);
-}
-template <typename T>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator<(Span<const T> a, Span<T> b) {
-  return span_internal::LessThanImpl<Span, const T>(a, b);
-}
-template <typename T>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator<(Span<T> a, Span<const T> b) {
-  return span_internal::LessThanImpl<Span, const T>(a, b);
-}
-template <
-    typename T, typename U,
-    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator<(const U &a, Span<T> b) {
-  return span_internal::LessThanImpl<Span, const T>(a, b);
-}
-template <
-    typename T, typename U,
-    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator<(Span<T> a, const U &b) {
-  return span_internal::LessThanImpl<Span, const T>(a, b);
-}
-
-// operator>
-template <typename T>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator>(Span<T> a, Span<T> b) {
-  return b < a;
-}
-template <typename T>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator>(Span<const T> a, Span<T> b) {
-  return b < a;
-}
-template <typename T>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator>(Span<T> a, Span<const T> b) {
-  return b < a;
-}
-template <
-    typename T, typename U,
-    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator>(const U &a, Span<T> b) {
-  return b < a;
-}
-template <
-    typename T, typename U,
-    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator>(Span<T> a, const U &b) {
-  return b < a;
-}
-
-// operator<=
-template <typename T>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator<=(Span<T> a, Span<T> b) {
-  return !(b < a);
-}
-template <typename T>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator<=(Span<const T> a,
-                                                    Span<T> b) {
-  return !(b < a);
-}
-template <typename T>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator<=(Span<T> a,
-                                                    Span<const T> b) {
-  return !(b < a);
-}
-template <
-    typename T, typename U,
-    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator<=(const U &a, Span<T> b) {
-  return !(b < a);
-}
-template <
-    typename T, typename U,
-    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator<=(Span<T> a, const U &b) {
-  return !(b < a);
-}
-
-// operator>=
-template <typename T>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator>=(Span<T> a, Span<T> b) {
-  return !(a < b);
-}
-template <typename T>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator>=(Span<const T> a,
-                                                    Span<T> b) {
-  return !(a < b);
-}
-template <typename T>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator>=(Span<T> a,
-                                                    Span<const T> b) {
-  return !(a < b);
-}
-template <
-    typename T, typename U,
-    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator>=(const U &a, Span<T> b) {
-  return !(a < b);
-}
-template <
-    typename T, typename U,
-    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
-ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool operator>=(Span<T> a, const U &b) {
-  return !(a < b);
-}
-
-// MakeSpan()
-//
-// Constructs a mutable `Span<T>`, deducing `T` automatically from either a
-// container or pointer+size.
-//
-// Because a read-only `Span<const T>` is implicitly constructed from container
-// types regardless of whether the container itself is a const container,
-// constructing mutable spans of type `Span<T>` from containers requires
-// explicit constructors. The container-accepting version of `MakeSpan()`
-// deduces the type of `T` by the constness of the pointer received from the
-// container's `data()` member. Similarly, the pointer-accepting version returns
-// a `Span<const T>` if `T` is `const`, and a `Span<T>` otherwise.
-//
-// Examples:
-//
-//   void MyRoutine(absl::Span<MyComplicatedType> a) {
-//     ...
-//   };
-//   // my_vector is a container of non-const types
-//   std::vector<MyComplicatedType> my_vector;
-//
-//   // Constructing a Span implicitly attempts to create a Span of type
-//   // `Span<const T>`
-//   MyRoutine(my_vector);                // error, type mismatch
-//
-//   // Explicitly constructing the Span is verbose
-//   MyRoutine(absl::Span<MyComplicatedType>(my_vector));
-//
-//   // Use MakeSpan() to make an absl::Span<T>
-//   MyRoutine(absl::MakeSpan(my_vector));
-//
-//   // Construct a span from an array ptr+size
-//   absl::Span<T> my_span() {
-//     return absl::MakeSpan(&array[0], num_elements_);
-//   }
-//
-template <int &...ExplicitArgumentBarrier, typename T>
-constexpr Span<T> MakeSpan(absl::Nullable<T *> ptr, size_t size) noexcept {
-  return Span<T>(ptr, size);
-}
-
-template <int &...ExplicitArgumentBarrier, typename T>
-Span<T> MakeSpan(absl::Nullable<T *> begin, absl::Nullable<T *> end) noexcept {
-  return ABSL_HARDENING_ASSERT(begin <= end),
-         Span<T>(begin, static_cast<size_t>(end - begin));
-}
-
-template <int &...ExplicitArgumentBarrier, typename C>
-constexpr auto MakeSpan(C &c) noexcept // NOLINT(runtime/references)
-    -> decltype(absl::MakeSpan(span_internal::GetData(c), c.size())) {
-  return MakeSpan(span_internal::GetData(c), c.size());
-}
-
-template <int &...ExplicitArgumentBarrier, typename T, size_t N>
-constexpr Span<T> MakeSpan(T (&array)[N]) noexcept {
-  return Span<T>(array, N);
-}
-
-// MakeConstSpan()
-//
-// Constructs a `Span<const T>` as with `MakeSpan`, deducing `T` automatically,
-// but always returning a `Span<const T>`.
-//
-// Examples:
-//
-//   void ProcessInts(absl::Span<const int> some_ints);
-//
-//   // Call with a pointer and size.
-//   int array[3] = { 0, 0, 0 };
-//   ProcessInts(absl::MakeConstSpan(&array[0], 3));
-//
-//   // Call with a [begin, end) pair.
-//   ProcessInts(absl::MakeConstSpan(&array[0], &array[3]));
-//
-//   // Call directly with an array.
-//   ProcessInts(absl::MakeConstSpan(array));
-//
-//   // Call with a contiguous container.
-//   std::vector<int> some_ints = ...;
-//   ProcessInts(absl::MakeConstSpan(some_ints));
-//   ProcessInts(absl::MakeConstSpan(std::vector<int>{ 0, 0, 0 }));
-//
-template <int &...ExplicitArgumentBarrier, typename T>
-constexpr Span<const T> MakeConstSpan(absl::Nullable<T *> ptr,
-                                      size_t size) noexcept {
-  return Span<const T>(ptr, size);
-}
-
-template <int &...ExplicitArgumentBarrier, typename T>
-Span<const T> MakeConstSpan(absl::Nullable<T *> begin,
-                            absl::Nullable<T *> end) noexcept {
-  return ABSL_HARDENING_ASSERT(begin <= end), Span<const T>(begin, end - begin);
-}
-
-template <int &...ExplicitArgumentBarrier, typename C>
-constexpr auto MakeConstSpan(const C &c) noexcept -> decltype(MakeSpan(c)) {
-  return MakeSpan(c);
-}
-
-template <int &...ExplicitArgumentBarrier, typename T, size_t N>
-constexpr Span<const T> MakeConstSpan(const T (&array)[N]) noexcept {
-  return Span<const T>(array, N);
-}
-ABSL_NAMESPACE_END
-} // namespace absl
-#endif // ABSL_TYPES_SPAN_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/types/variant.h b/packages/react-native-executorch/third-party/include/absl/types/variant.h
deleted file mode 100644
index 321184a0f2..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/types/variant.h
+++ /dev/null
@@ -1,848 +0,0 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// variant.h
-// -----------------------------------------------------------------------------
-//
-// This header file defines an `absl::variant` type for holding a type-safe
-// value of some prescribed set of types (noted as alternative types), and
-// associated functions for managing variants.
-//
-// The `absl::variant` type is a form of type-safe union. An `absl::variant`
-// should always hold a value of one of its alternative types (except in the
-// "valueless by exception state" -- see below). A default-constructed
-// `absl::variant` will hold the value of its first alternative type, provided
-// it is default-constructible.
-//
-// In exceptional cases due to error, an `absl::variant` can hold no
-// value (known as a "valueless by exception" state), though this is not the
-// norm.
-//
-// As with `absl::optional`, an `absl::variant` -- when it holds a value --
-// allocates a value of that type directly within the `variant` itself; it
-// cannot hold a reference, array, or the type `void`; it can, however, hold a
-// pointer to externally managed memory.
-//
-// `absl::variant` is a C++11 compatible version of the C++17 `std::variant`
-// abstraction and is designed to be a drop-in replacement for code compliant
-// with C++17.
-
-#ifndef ABSL_TYPES_VARIANT_H_
-#define ABSL_TYPES_VARIANT_H_
-
-#include "absl/base/config.h"
-#include "absl/utility/utility.h"
-
-#ifdef ABSL_USES_STD_VARIANT
-
-#include <variant> // IWYU pragma: export
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-using std::bad_variant_access;
-using std::get;
-using std::get_if;
-using std::holds_alternative;
-using std::monostate;
-using std::variant;
-using std::variant_alternative;
-using std::variant_alternative_t;
-using std::variant_npos;
-using std::variant_size;
-using std::variant_size_v;
-using std::visit;
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#else // ABSL_USES_STD_VARIANT
-
-#include <functional>
-#include <new>
-#include <type_traits>
-#include <utility>
-
-#include "absl/base/macros.h"
-#include "absl/base/port.h"
-#include "absl/meta/type_traits.h"
-#include "absl/types/internal/variant.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// -----------------------------------------------------------------------------
-// absl::variant
-// -----------------------------------------------------------------------------
-//
-// An `absl::variant` type is a form of type-safe union. An `absl::variant` --
-// except in exceptional cases -- always holds a value of one of its alternative
-// types.
-//
-// Example:
-//
-//   // Construct a variant that holds either an integer or a std::string and
-//   // assign it to a std::string.
-//   absl::variant<int, std::string> v = std::string("abc");
-//
-//   // A default-constructed variant will hold a value-initialized value of
-//   // the first alternative type.
-//   auto a = absl::variant<int, std::string>();   // Holds an int of value '0'.
-//
-//   // variants are assignable.
-//
-//   // copy assignment
-//   auto v1 = absl::variant<int, std::string>("abc");
-//   auto v2 = absl::variant<int, std::string>(10);
-//   v2 = v1;  // copy assign
-//
-//   // move assignment
-//   auto v1 = absl::variant<int, std::string>("abc");
-//   v1 = absl::variant<int, std::string>(10);
-//
-//   // assignment through type conversion
-//   a = 128;         // variant contains int
-//   a = "128";       // variant contains std::string
-//
-// An `absl::variant` holding a value of one of its alternative types `T` holds
-// an allocation of `T` directly within the variant itself. An `absl::variant`
-// is not allowed to allocate additional storage, such as dynamic memory, to
-// allocate the contained value. The contained value shall be allocated in a
-// region of the variant storage suitably aligned for all alternative types.
-template <typename... Ts> class variant;
-
-// swap()
-//
-// Swaps two `absl::variant` values. This function is equivalent to `v.swap(w)`
-// where `v` and `w` are `absl::variant` types.
-//
-// Note that this function requires all alternative types to be both swappable
-// and move-constructible, because any two variants may refer to either the same
-// type (in which case, they will be swapped) or to two different types (in
-// which case the values will need to be moved).
-//
-template <
-    typename... Ts,
-    absl::enable_if_t<
-        absl::conjunction<std::is_move_constructible<Ts>...,
-                          type_traits_internal::IsSwappable<Ts>...>::value,
-        int> = 0>
-void swap(variant<Ts...> &v, variant<Ts...> &w) noexcept(noexcept(v.swap(w))) {
-  v.swap(w);
-}
-
-// variant_size
-//
-// Returns the number of alternative types available for a given `absl::variant`
-// type as a compile-time constant expression. As this is a class template, it
-// is not generally useful for accessing the number of alternative types of
-// any given `absl::variant` instance.
-//
-// Example:
-//
-//   auto a = absl::variant<int, std::string>;
-//   constexpr int num_types =
-//       absl::variant_size<absl::variant<int, std::string>>();
-//
-//   // You can also use the member constant `value`.
-//   constexpr int num_types =
-//       absl::variant_size<absl::variant<int, std::string>>::value;
-//
-//   // `absl::variant_size` is more valuable for use in generic code:
-//   template <typename Variant>
-//   constexpr bool IsVariantMultivalue() {
-//       return absl::variant_size<Variant>() > 1;
-//   }
-//
-// Note that the set of cv-qualified specializations of `variant_size` are
-// provided to ensure that those specializations compile (especially when passed
-// within template logic).
-template <class T> struct variant_size;
-
-template <class... Ts>
-struct variant_size<variant<Ts...>>
-    : std::integral_constant<std::size_t, sizeof...(Ts)> {};
-
-// Specialization of `variant_size` for const qualified variants.
-template <class T> struct variant_size<const T> : variant_size<T>::type {};
-
-// Specialization of `variant_size` for volatile qualified variants.
-template <class T> struct variant_size<volatile T> : variant_size<T>::type {};
-
-// Specialization of `variant_size` for const volatile qualified variants.
-template <class T>
-struct variant_size<const volatile T> : variant_size<T>::type {};
-
-// variant_alternative
-//
-// Returns the alternative type for a given `absl::variant` at the passed
-// index value as a compile-time constant expression. As this is a class
-// template resulting in a type, it is not useful for access of the run-time
-// value of any given `absl::variant` variable.
-//
-// Example:
-//
-//   // The type of the 0th alternative is "int".
-//   using alternative_type_0
-//     = absl::variant_alternative<0, absl::variant<int, std::string>>::type;
-//
-//   static_assert(std::is_same<alternative_type_0, int>::value, "");
-//
-//   // `absl::variant_alternative` is more valuable for use in generic code:
-//   template <typename Variant>
-//   constexpr bool IsFirstElementTrivial() {
-//       return std::is_trivial_v<variant_alternative<0, Variant>::type>;
-//   }
-//
-// Note that the set of cv-qualified specializations of `variant_alternative`
-// are provided to ensure that those specializations compile (especially when
-// passed within template logic).
-template <std::size_t I, class T> struct variant_alternative;
-
-template <std::size_t I, class... Types>
-struct variant_alternative<I, variant<Types...>> {
-  using type =
-      variant_internal::VariantAlternativeSfinaeT<I, variant<Types...>>;
-};
-
-// Specialization of `variant_alternative` for const qualified variants.
-template <std::size_t I, class T> struct variant_alternative<I, const T> {
-  using type = const typename variant_alternative<I, T>::type;
-};
-
-// Specialization of `variant_alternative` for volatile qualified variants.
-template <std::size_t I, class T> struct variant_alternative<I, volatile T> {
-  using type = volatile typename variant_alternative<I, T>::type;
-};
-
-// Specialization of `variant_alternative` for const volatile qualified
-// variants.
-template <std::size_t I, class T>
-struct variant_alternative<I, const volatile T> {
-  using type = const volatile typename variant_alternative<I, T>::type;
-};
-
-// Template type alias for variant_alternative<I, T>::type.
-//
-// Example:
-//
-//   using alternative_type_0
-//     = absl::variant_alternative_t<0, absl::variant<int, std::string>>;
-//   static_assert(std::is_same<alternative_type_0, int>::value, "");
-template <std::size_t I, class T>
-using variant_alternative_t = typename variant_alternative<I, T>::type;
-
-// holds_alternative()
-//
-// Checks whether the given variant currently holds a given alternative type,
-// returning `true` if so.
-//
-// Example:
-//
-//   absl::variant<int, std::string> foo = 42;
-//   if (absl::holds_alternative<int>(foo)) {
-//       std::cout << "The variant holds an integer";
-//   }
-template <class T, class... Types>
-constexpr bool holds_alternative(const variant<Types...> &v) noexcept {
-  static_assert(variant_internal::UnambiguousIndexOfImpl<variant<Types...>, T,
-                                                         0>::value !=
-                    sizeof...(Types),
-                "The type T must occur exactly once in Types...");
-  return v.index() ==
-         variant_internal::UnambiguousIndexOf<variant<Types...>, T>::value;
-}
-
-// get()
-//
-// Returns a reference to the value currently within a given variant, using
-// either a unique alternative type amongst the variant's set of alternative
-// types, or the variant's index value. Attempting to get a variant's value
-// using a type that is not unique within the variant's set of alternative types
-// is a compile-time error. If the index of the alternative being specified is
-// different from the index of the alternative that is currently stored, throws
-// `absl::bad_variant_access`.
-//
-// Example:
-//
-//   auto a = absl::variant<int, std::string>;
-//
-//   // Get the value by type (if unique).
-//   int i = absl::get<int>(a);
-//
-//   auto b = absl::variant<int, int>;
-//
-//   // Getting the value by a type that is not unique is ill-formed.
-//   int j = absl::get<int>(b);     // Compile Error!
-//
-//   // Getting value by index not ambiguous and allowed.
-//   int k = absl::get<1>(b);
-
-// Overload for getting a variant's lvalue by type.
-template <class T, class... Types>
-constexpr T &get(variant<Types...> &v) { // NOLINT
-  return variant_internal::VariantCoreAccess::CheckedAccess<
-      variant_internal::IndexOf<T, Types...>::value>(v);
-}
-
-// Overload for getting a variant's rvalue by type.
-template <class T, class... Types> constexpr T &&get(variant<Types...> &&v) {
-  return variant_internal::VariantCoreAccess::CheckedAccess<
-      variant_internal::IndexOf<T, Types...>::value>(std::move(v));
-}
-
-// Overload for getting a variant's const lvalue by type.
-template <class T, class... Types>
-constexpr const T &get(const variant<Types...> &v) {
-  return variant_internal::VariantCoreAccess::CheckedAccess<
-      variant_internal::IndexOf<T, Types...>::value>(v);
-}
-
-// Overload for getting a variant's const rvalue by type.
-template <class T, class... Types>
-constexpr const T &&get(const variant<Types...> &&v) {
-  return variant_internal::VariantCoreAccess::CheckedAccess<
-      variant_internal::IndexOf<T, Types...>::value>(std::move(v));
-}
-
-// Overload for getting a variant's lvalue by index.
-template <std::size_t I, class... Types>
-constexpr variant_alternative_t<I, variant<Types...>> &
-get(variant<Types...> &v) { // NOLINT
-  return variant_internal::VariantCoreAccess::CheckedAccess<I>(v);
-}
-
-// Overload for getting a variant's rvalue by index.
-template <std::size_t I, class... Types>
-constexpr variant_alternative_t<I, variant<Types...>> &&
-get(variant<Types...> &&v) {
-  return variant_internal::VariantCoreAccess::CheckedAccess<I>(std::move(v));
-}
-
-// Overload for getting a variant's const lvalue by index.
-template <std::size_t I, class... Types>
-constexpr const variant_alternative_t<I, variant<Types...>> &
-get(const variant<Types...> &v) {
-  return variant_internal::VariantCoreAccess::CheckedAccess<I>(v);
-}
-
-// Overload for getting a variant's const rvalue by index.
-template <std::size_t I, class... Types>
-constexpr const variant_alternative_t<I, variant<Types...>> &&
-get(const variant<Types...> &&v) {
-  return variant_internal::VariantCoreAccess::CheckedAccess<I>(std::move(v));
-}
-
-// get_if()
-//
-// Returns a pointer to the value currently stored within a given variant, if
-// present, using either a unique alternative type amongst the variant's set of
-// alternative types, or the variant's index value. If such a value does not
-// exist, returns `nullptr`.
-//
-// As with `get`, attempting to get a variant's value using a type that is not
-// unique within the variant's set of alternative types is a compile-time error.
-
-// Overload for getting a pointer to the value stored in the given variant by
-// index.
-template <std::size_t I, class... Types>
-constexpr absl::add_pointer_t<variant_alternative_t<I, variant<Types...>>>
-get_if(variant<Types...> *v) noexcept {
-  return (v != nullptr && v->index() == I)
-             ? std::addressof(
-                   variant_internal::VariantCoreAccess::Access<I>(*v))
-             : nullptr;
-}
-
-// Overload for getting a pointer to the const value stored in the given
-// variant by index.
-template <std::size_t I, class... Types>
-constexpr absl::add_pointer_t<const variant_alternative_t<I, variant<Types...>>>
-get_if(const variant<Types...> *v) noexcept {
-  return (v != nullptr && v->index() == I)
-             ? std::addressof(
-                   variant_internal::VariantCoreAccess::Access<I>(*v))
-             : nullptr;
-}
-
-// Overload for getting a pointer to the value stored in the given variant by
-// type.
-template <class T, class... Types>
-constexpr absl::add_pointer_t<T> get_if(variant<Types...> *v) noexcept {
-  return absl::get_if<variant_internal::IndexOf<T, Types...>::value>(v);
-}
-
-// Overload for getting a pointer to the const value stored in the given variant
-// by type.
-template <class T, class... Types>
-constexpr absl::add_pointer_t<const T>
-get_if(const variant<Types...> *v) noexcept {
-  return absl::get_if<variant_internal::IndexOf<T, Types...>::value>(v);
-}
-
-// visit()
-//
-// Calls a provided functor on a given set of variants. `absl::visit()` is
-// commonly used to conditionally inspect the state of a given variant (or set
-// of variants).
-//
-// The functor must return the same type when called with any of the variants'
-// alternatives.
-//
-// Example:
-//
-//   // Define a visitor functor
-//   struct GetVariant {
-//       template<typename T>
-//       void operator()(const T& i) const {
-//         std::cout << "The variant's value is: " << i;
-//       }
-//   };
-//
-//   // Declare our variant, and call `absl::visit()` on it.
-//   // Note that `GetVariant()` returns void in either case.
-//   absl::variant<int, std::string> foo = std::string("foo");
-//   GetVariant visitor;
-//   absl::visit(visitor, foo);  // Prints `The variant's value is: foo'
-template <typename Visitor, typename... Variants>
-variant_internal::VisitResult<Visitor, Variants...> visit(Visitor &&vis,
-                                                          Variants &&...vars) {
-  return variant_internal::
-      VisitIndices<variant_size<absl::decay_t<Variants>>::value...>::Run(
-          variant_internal::PerformVisitation<Visitor, Variants...>{
-              std::forward_as_tuple(std::forward<Variants>(vars)...),
-              std::forward<Visitor>(vis)},
-          vars.index()...);
-}
-
-// monostate
-//
-// The monostate class serves as a first alternative type for a variant for
-// which the first variant type is otherwise not default-constructible.
-struct monostate {};
-
-// `absl::monostate` Relational Operators
-
-constexpr bool operator<(monostate, monostate) noexcept { return false; }
-constexpr bool operator>(monostate, monostate) noexcept { return false; }
-constexpr bool operator<=(monostate, monostate) noexcept { return true; }
-constexpr bool operator>=(monostate, monostate) noexcept { return true; }
-constexpr bool operator==(monostate, monostate) noexcept { return true; }
-constexpr bool operator!=(monostate, monostate) noexcept { return false; }
-
-//------------------------------------------------------------------------------
-// `absl::variant` Template Definition
-//------------------------------------------------------------------------------
-template <typename T0, typename... Tn>
-class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> {
-  static_assert(
-      absl::conjunction<std::is_object<T0>, std::is_object<Tn>...>::value,
-      "Attempted to instantiate a variant containing a non-object "
-      "type.");
-  // Intentionally not qualifying `negation` with `absl::` to work around a bug
-  // in MSVC 2015 with inline namespace and variadic template.
-  static_assert(absl::conjunction<negation<std::is_array<T0>>,
-                                  negation<std::is_array<Tn>>...>::value,
-                "Attempted to instantiate a variant containing an array type.");
-  static_assert(absl::conjunction<std::is_nothrow_destructible<T0>,
-                                  std::is_nothrow_destructible<Tn>...>::value,
-                "Attempted to instantiate a variant containing a non-nothrow "
-                "destructible type.");
-
-  friend struct variant_internal::VariantCoreAccess;
-
-private:
-  using Base = variant_internal::VariantBase<T0, Tn...>;
-
-public:
-  // Constructors
-
-  // Constructs a variant holding a default-initialized value of the first
-  // alternative type.
-  constexpr variant() /*noexcept(see 111above)*/ = default;
-
-  // Copy constructor, standard semantics
-  variant(const variant &other) = default;
-
-  // Move constructor, standard semantics
-  variant(variant &&other) /*noexcept(see above)*/ = default;
-
-  // Constructs a variant of an alternative type specified by overload
-  // resolution of the provided forwarding arguments through
-  // direct-initialization.
-  //
-  // Note: If the selected constructor is a constexpr constructor, this
-  // constructor shall be a constexpr constructor.
-  //
-  // NOTE: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0608r1.html
-  // has been voted passed the design phase in the C++ standard meeting in Mar
-  // 2018. It will be implemented and integrated into `absl::variant`.
-  template <
-      class T,
-      std::size_t I = std::enable_if<
-          variant_internal::IsNeitherSelfNorInPlace<variant,
-                                                    absl::decay_t<T>>::value,
-          variant_internal::IndexOfConstructedType<variant, T>>::type::value,
-      class Tj = absl::variant_alternative_t<I, variant>,
-      absl::enable_if_t<std::is_constructible<Tj, T>::value> * = nullptr>
-  constexpr variant(T &&t) noexcept(std::is_nothrow_constructible<Tj, T>::value)
-      : Base(variant_internal::EmplaceTag<I>(), std::forward<T>(t)) {}
-
-  // Constructs a variant of an alternative type from the arguments through
-  // direct-initialization.
-  //
-  // Note: If the selected constructor is a constexpr constructor, this
-  // constructor shall be a constexpr constructor.
-  template <class T, class... Args,
-            typename std::enable_if<std::is_constructible<
-                variant_internal::UnambiguousTypeOfT<variant, T>,
-                Args...>::value>::type * = nullptr>
-  constexpr explicit variant(in_place_type_t<T>, Args &&...args)
-      : Base(variant_internal::EmplaceTag<
-                 variant_internal::UnambiguousIndexOf<variant, T>::value>(),
-             std::forward<Args>(args)...) {}
-
-  // Constructs a variant of an alternative type from an initializer list
-  // and other arguments through direct-initialization.
-  //
-  // Note: If the selected constructor is a constexpr constructor, this
-  // constructor shall be a constexpr constructor.
-  template <class T, class U, class... Args,
-            typename std::enable_if<std::is_constructible<
-                variant_internal::UnambiguousTypeOfT<variant, T>,
-                std::initializer_list<U> &, Args...>::value>::type * = nullptr>
-  constexpr explicit variant(in_place_type_t<T>, std::initializer_list<U> il,
-                             Args &&...args)
-      : Base(variant_internal::EmplaceTag<
-                 variant_internal::UnambiguousIndexOf<variant, T>::value>(),
-             il, std::forward<Args>(args)...) {}
-
-  // Constructs a variant of an alternative type from a provided index,
-  // through value-initialization using the provided forwarded arguments.
-  template <std::size_t I, class... Args,
-            typename std::enable_if<std::is_constructible<
-                variant_internal::VariantAlternativeSfinaeT<I, variant>,
-                Args...>::value>::type * = nullptr>
-  constexpr explicit variant(in_place_index_t<I>, Args &&...args)
-      : Base(variant_internal::EmplaceTag<I>(), std::forward<Args>(args)...) {}
-
-  // Constructs a variant of an alternative type from a provided index,
-  // through value-initialization of an initializer list and the provided
-  // forwarded arguments.
-  template <std::size_t I, class U, class... Args,
-            typename std::enable_if<std::is_constructible<
-                variant_internal::VariantAlternativeSfinaeT<I, variant>,
-                std::initializer_list<U> &, Args...>::value>::type * = nullptr>
-  constexpr explicit variant(in_place_index_t<I>, std::initializer_list<U> il,
-                             Args &&...args)
-      : Base(variant_internal::EmplaceTag<I>(), il,
-             std::forward<Args>(args)...) {}
-
-  // Destructors
-
-  // Destroys the variant's currently contained value, provided that
-  // `absl::valueless_by_exception()` is false.
-  ~variant() = default;
-
-  // Assignment Operators
-
-  // Copy assignment operator
-  variant &operator=(const variant &other) = default;
-
-  // Move assignment operator
-  variant &operator=(variant &&other) /*noexcept(see above)*/ = default;
-
-  // Converting assignment operator
-  //
-  // NOTE: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0608r1.html
-  // has been voted passed the design phase in the C++ standard meeting in Mar
-  // 2018. It will be implemented and integrated into `absl::variant`.
-  template <
-      class T,
-      std::size_t I = std::enable_if<
-          !std::is_same<absl::decay_t<T>, variant>::value,
-          variant_internal::IndexOfConstructedType<variant, T>>::type::value,
-      class Tj = absl::variant_alternative_t<I, variant>,
-      typename std::enable_if<std::is_assignable<Tj &, T>::value &&
-                              std::is_constructible<Tj, T>::value>::type * =
-          nullptr>
-  variant &
-  operator=(T &&t) noexcept(std::is_nothrow_assignable<Tj &, T>::value &&
-                            std::is_nothrow_constructible<Tj, T>::value) {
-    variant_internal::VisitIndices<sizeof...(Tn) + 1>::Run(
-        variant_internal::VariantCoreAccess::MakeConversionAssignVisitor(
-            this, std::forward<T>(t)),
-        index());
-
-    return *this;
-  }
-
-  // emplace() Functions
-
-  // Constructs a value of the given alternative type T within the variant. The
-  // existing value of the variant is destroyed first (provided that
-  // `absl::valueless_by_exception()` is false). Requires that T is unambiguous
-  // in the variant.
-  //
-  // Example:
-  //
-  //   absl::variant<std::vector<int>, int, std::string> v;
-  //   v.emplace<int>(99);
-  //   v.emplace<std::string>("abc");
-  template <
-      class T, class... Args,
-      typename std::enable_if<std::is_constructible<
-          absl::variant_alternative_t<
-              variant_internal::UnambiguousIndexOf<variant, T>::value, variant>,
-          Args...>::value>::type * = nullptr>
-  T &emplace(Args &&...args) {
-    return variant_internal::VariantCoreAccess::Replace<
-        variant_internal::UnambiguousIndexOf<variant, T>::value>(
-        this, std::forward<Args>(args)...);
-  }
-
-  // Constructs a value of the given alternative type T within the variant using
-  // an initializer list. The existing value of the variant is destroyed first
-  // (provided that `absl::valueless_by_exception()` is false). Requires that T
-  // is unambiguous in the variant.
-  //
-  // Example:
-  //
-  //   absl::variant<std::vector<int>, int, std::string> v;
-  //   v.emplace<std::vector<int>>({0, 1, 2});
-  template <
-      class T, class U, class... Args,
-      typename std::enable_if<std::is_constructible<
-          absl::variant_alternative_t<
-              variant_internal::UnambiguousIndexOf<variant, T>::value, variant>,
-          std::initializer_list<U> &, Args...>::value>::type * = nullptr>
-  T &emplace(std::initializer_list<U> il, Args &&...args) {
-    return variant_internal::VariantCoreAccess::Replace<
-        variant_internal::UnambiguousIndexOf<variant, T>::value>(
-        this, il, std::forward<Args>(args)...);
-  }
-
-  // Destroys the current value of the variant (provided that
-  // `absl::valueless_by_exception()` is false) and constructs a new value at
-  // the given index.
-  //
-  // Example:
-  //
-  //   absl::variant<std::vector<int>, int, int> v;
-  //   v.emplace<1>(99);
-  //   v.emplace<2>(98);
-  //   v.emplace<int>(99);  // Won't compile. 'int' isn't a unique type.
-  template <std::size_t I, class... Args,
-            typename std::enable_if<std::is_constructible<
-                absl::variant_alternative_t<I, variant>, Args...>::value>::type
-                * = nullptr>
-  absl::variant_alternative_t<I, variant> &emplace(Args &&...args) {
-    return variant_internal::VariantCoreAccess::Replace<I>(
-        this, std::forward<Args>(args)...);
-  }
-
-  // Destroys the current value of the variant (provided that
-  // `absl::valueless_by_exception()` is false) and constructs a new value at
-  // the given index using an initializer list and the provided arguments.
-  //
-  // Example:
-  //
-  //   absl::variant<std::vector<int>, int, int> v;
-  //   v.emplace<0>({0, 1, 2});
-  template <std::size_t I, class U, class... Args,
-            typename std::enable_if<std::is_constructible<
-                absl::variant_alternative_t<I, variant>,
-                std::initializer_list<U> &, Args...>::value>::type * = nullptr>
-  absl::variant_alternative_t<I, variant> &emplace(std::initializer_list<U> il,
-                                                   Args &&...args) {
-    return variant_internal::VariantCoreAccess::Replace<I>(
-        this, il, std::forward<Args>(args)...);
-  }
-
-  // variant::valueless_by_exception()
-  //
-  // Returns false if and only if the variant currently holds a valid value.
-  constexpr bool valueless_by_exception() const noexcept {
-    return this->index_ == absl::variant_npos;
-  }
-
-  // variant::index()
-  //
-  // Returns the index value of the variant's currently selected alternative
-  // type.
-  constexpr std::size_t index() const noexcept { return this->index_; }
-
-  // variant::swap()
-  //
-  // Swaps the values of two variant objects.
-  //
-  void swap(variant &rhs) noexcept(
-      absl::conjunction<
-          std::is_nothrow_move_constructible<T0>,
-          std::is_nothrow_move_constructible<Tn>...,
-          type_traits_internal::IsNothrowSwappable<T0>,
-          type_traits_internal::IsNothrowSwappable<Tn>...>::value) {
-    return variant_internal::VisitIndices<sizeof...(Tn) + 1>::Run(
-        variant_internal::Swap<T0, Tn...>{this, &rhs}, rhs.index());
-  }
-};
-
-// We need a valid declaration of variant<> for SFINAE and overload resolution
-// to work properly above, but we don't need a full declaration since this type
-// will never be constructed. This declaration, though incomplete, suffices.
-template <> class variant<>;
-
-//------------------------------------------------------------------------------
-// Relational Operators
-//------------------------------------------------------------------------------
-//
-// If neither operand is in the `variant::valueless_by_exception` state:
-//
-//   * If the index of both variants is the same, the relational operator
-//     returns the result of the corresponding relational operator for the
-//     corresponding alternative type.
-//   * If the index of both variants is not the same, the relational operator
-//     returns the result of that operation applied to the value of the left
-//     operand's index and the value of the right operand's index.
-//   * If at least one operand is in the valueless_by_exception state:
-//     - A variant in the valueless_by_exception state is only considered equal
-//       to another variant in the valueless_by_exception state.
-//     - If exactly one operand is in the valueless_by_exception state, the
-//       variant in the valueless_by_exception state is less than the variant
-//       that is not in the valueless_by_exception state.
-//
-// Note: The value 1 is added to each index in the relational comparisons such
-// that the index corresponding to the valueless_by_exception state wraps around
-// to 0 (the lowest value for the index type), and the remaining indices stay in
-// the same relative order.
-
-// Equal-to operator
-template <typename... Types>
-constexpr variant_internal::RequireAllHaveEqualT<Types...>
-operator==(const variant<Types...> &a, const variant<Types...> &b) {
-  return (a.index() == b.index()) &&
-         variant_internal::VisitIndices<sizeof...(Types)>::Run(
-             variant_internal::EqualsOp<Types...>{&a, &b}, a.index());
-}
-
-// Not equal operator
-template <typename... Types>
-constexpr variant_internal::RequireAllHaveNotEqualT<Types...>
-operator!=(const variant<Types...> &a, const variant<Types...> &b) {
-  return (a.index() != b.index()) ||
-         variant_internal::VisitIndices<sizeof...(Types)>::Run(
-             variant_internal::NotEqualsOp<Types...>{&a, &b}, a.index());
-}
-
-// Less-than operator
-template <typename... Types>
-constexpr variant_internal::RequireAllHaveLessThanT<Types...>
-operator<(const variant<Types...> &a, const variant<Types...> &b) {
-  return (a.index() != b.index())
-             ? (a.index() + 1) < (b.index() + 1)
-             : variant_internal::VisitIndices<sizeof...(Types)>::Run(
-                   variant_internal::LessThanOp<Types...>{&a, &b}, a.index());
-}
-
-// Greater-than operator
-template <typename... Types>
-constexpr variant_internal::RequireAllHaveGreaterThanT<Types...>
-operator>(const variant<Types...> &a, const variant<Types...> &b) {
-  return (a.index() != b.index())
-             ? (a.index() + 1) > (b.index() + 1)
-             : variant_internal::VisitIndices<sizeof...(Types)>::Run(
-                   variant_internal::GreaterThanOp<Types...>{&a, &b},
-                   a.index());
-}
-
-// Less-than or equal-to operator
-template <typename... Types>
-constexpr variant_internal::RequireAllHaveLessThanOrEqualT<Types...>
-operator<=(const variant<Types...> &a, const variant<Types...> &b) {
-  return (a.index() != b.index())
-             ? (a.index() + 1) < (b.index() + 1)
-             : variant_internal::VisitIndices<sizeof...(Types)>::Run(
-                   variant_internal::LessThanOrEqualsOp<Types...>{&a, &b},
-                   a.index());
-}
-
-// Greater-than or equal-to operator
-template <typename... Types>
-constexpr variant_internal::RequireAllHaveGreaterThanOrEqualT<Types...>
-operator>=(const variant<Types...> &a, const variant<Types...> &b) {
-  return (a.index() != b.index())
-             ? (a.index() + 1) > (b.index() + 1)
-             : variant_internal::VisitIndices<sizeof...(Types)>::Run(
-                   variant_internal::GreaterThanOrEqualsOp<Types...>{&a, &b},
-                   a.index());
-}
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-namespace std {
-
-// hash()
-template <> // NOLINT
-struct hash<absl::monostate> {
-  std::size_t operator()(absl::monostate) const { return 0; }
-};
-
-template <class... T> // NOLINT
-struct hash<absl::variant<T...>>
-    : absl::variant_internal::VariantHashBase<absl::variant<T...>, void,
-                                              absl::remove_const_t<T>...> {};
-
-} // namespace std
-
-#endif // ABSL_USES_STD_VARIANT
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace variant_internal {
-
-// Helper visitor for converting a variant<Ts...>` into another type (mostly
-// variant) that can be constructed from any type.
-template <typename To> struct ConversionVisitor {
-  template <typename T> To operator()(T &&v) const {
-    return To(std::forward<T>(v));
-  }
-};
-
-} // namespace variant_internal
-
-// ConvertVariantTo()
-//
-// Helper functions to convert an `absl::variant` to a variant of another set of
-// types, provided that the alternative type of the new variant type can be
-// converted from any type in the source variant.
-//
-// Example:
-//
-//   absl::variant<name1, name2, float> InternalReq(const Req&);
-//
-//   // name1 and name2 are convertible to name
-//   absl::variant<name, float> ExternalReq(const Req& req) {
-//     return absl::ConvertVariantTo<absl::variant<name, float>>(
-//              InternalReq(req));
-//   }
-template <typename To, typename Variant>
-To ConvertVariantTo(Variant &&variant) {
-  return absl::visit(variant_internal::ConversionVisitor<To>{},
-                     std::forward<Variant>(variant));
-}
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_TYPES_VARIANT_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/utility/internal/if_constexpr.h b/packages/react-native-executorch/third-party/include/absl/utility/internal/if_constexpr.h
deleted file mode 100644
index 22af5fb5a1..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/utility/internal/if_constexpr.h
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright 2023 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// The IfConstexpr and IfConstexprElse utilities in this file are meant to be
-// used to emulate `if constexpr` in pre-C++17 mode in library implementation.
-// The motivation is to allow for avoiding complex SFINAE.
-//
-// The functions passed in must depend on the type(s) of the object(s) that
-// require SFINAE. For example:
-// template<typename T>
-// int MaybeFoo(T& t) {
-//   if constexpr (HasFoo<T>::value) return t.foo();
-//   return 0;
-// }
-//
-// can be written in pre-C++17 as:
-//
-// template<typename T>
-// int MaybeFoo(T& t) {
-//   int i = 0;
-//   absl::utility_internal::IfConstexpr<HasFoo<T>::value>(
-//       [&](const auto& fooer) { i = fooer.foo(); }, t);
-//   return i;
-// }
-
-#ifndef ABSL_UTILITY_INTERNAL_IF_CONSTEXPR_H_
-#define ABSL_UTILITY_INTERNAL_IF_CONSTEXPR_H_
-
-#include <tuple>
-#include <utility>
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-namespace utility_internal {
-
-template <bool condition, typename TrueFunc, typename FalseFunc,
-          typename... Args>
-auto IfConstexprElse(TrueFunc &&true_func, FalseFunc &&false_func,
-                     Args &&...args) {
-  return std::get<condition>(std::forward_as_tuple(
-      std::forward<FalseFunc>(false_func), std::forward<TrueFunc>(true_func)))(
-      std::forward<Args>(args)...);
-}
-
-template <bool condition, typename Func, typename... Args>
-void IfConstexpr(Func &&func, Args &&...args) {
-  IfConstexprElse<condition>(
-      std::forward<Func>(func), [](auto &&...) {}, std::forward<Args>(args)...);
-}
-
-} // namespace utility_internal
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_UTILITY_INTERNAL_IF_CONSTEXPR_H_
diff --git a/packages/react-native-executorch/third-party/include/absl/utility/utility.h b/packages/react-native-executorch/third-party/include/absl/utility/utility.h
deleted file mode 100644
index 47cbf2d1e1..0000000000
--- a/packages/react-native-executorch/third-party/include/absl/utility/utility.h
+++ /dev/null
@@ -1,225 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// This header file contains C++14 versions of standard <utility> header
-// abstractions available within C++17, and are designed to be drop-in
-// replacement for code compliant with C++14 and C++17.
-//
-// The following abstractions are defined:
-//
-//   * apply<Functor, Tuple>         == std::apply<Functor, Tuple>
-//   * exchange<T>                   == std::exchange<T>
-//   * make_from_tuple<T>            == std::make_from_tuple<T>
-//
-// This header file also provides the tag types `in_place_t`, `in_place_type_t`,
-// and `in_place_index_t`, as well as the constant `in_place`, and
-// `constexpr` `std::move()` and `std::forward()` implementations in C++11.
-//
-// References:
-//
-//  https://en.cppreference.com/w/cpp/utility/apply
-//  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3658.html
-
-#ifndef ABSL_UTILITY_UTILITY_H_
-#define ABSL_UTILITY_UTILITY_H_
-
-#include <cstddef>
-#include <cstdlib>
-#include <tuple>
-#include <utility>
-
-#include "absl/base/config.h"
-#include "absl/base/internal/inline_variable.h"
-#include "absl/base/internal/invoke.h"
-#include "absl/meta/type_traits.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// Historical note: Abseil once provided implementations of these
-// abstractions for platforms that had not yet provided them. Those
-// platforms are no longer supported. New code should simply use the
-// the ones from std directly.
-using std::exchange;
-using std::forward;
-using std::index_sequence;
-using std::index_sequence_for;
-using std::integer_sequence;
-using std::make_index_sequence;
-using std::make_integer_sequence;
-using std::move;
-
-namespace utility_internal {
-
-template <typename T> struct InPlaceTypeTag {
-  explicit InPlaceTypeTag() = delete;
-  InPlaceTypeTag(const InPlaceTypeTag &) = delete;
-  InPlaceTypeTag &operator=(const InPlaceTypeTag &) = delete;
-};
-
-template <size_t I> struct InPlaceIndexTag {
-  explicit InPlaceIndexTag() = delete;
-  InPlaceIndexTag(const InPlaceIndexTag &) = delete;
-  InPlaceIndexTag &operator=(const InPlaceIndexTag &) = delete;
-};
-
-} // namespace utility_internal
-
-// Tag types
-
-#ifdef ABSL_USES_STD_OPTIONAL
-
-using std::in_place;
-using std::in_place_t;
-
-#else // ABSL_USES_STD_OPTIONAL
-
-// in_place_t
-//
-// Tag type used to specify in-place construction, such as with
-// `absl::optional`, designed to be a drop-in replacement for C++17's
-// `std::in_place_t`.
-struct in_place_t {};
-
-ABSL_INTERNAL_INLINE_CONSTEXPR(in_place_t, in_place, {});
-
-#endif // ABSL_USES_STD_OPTIONAL
-
-#if defined(ABSL_USES_STD_ANY) || defined(ABSL_USES_STD_VARIANT)
-using std::in_place_type;
-using std::in_place_type_t;
-#else
-
-// in_place_type_t
-//
-// Tag type used for in-place construction when the type to construct needs to
-// be specified, such as with `absl::any`, designed to be a drop-in replacement
-// for C++17's `std::in_place_type_t`.
-template <typename T>
-using in_place_type_t = void (*)(utility_internal::InPlaceTypeTag<T>);
-
-template <typename T> void in_place_type(utility_internal::InPlaceTypeTag<T>) {}
-#endif // ABSL_USES_STD_ANY || ABSL_USES_STD_VARIANT
-
-#ifdef ABSL_USES_STD_VARIANT
-using std::in_place_index;
-using std::in_place_index_t;
-#else
-
-// in_place_index_t
-//
-// Tag type used for in-place construction when the type to construct needs to
-// be specified, such as with `absl::any`, designed to be a drop-in replacement
-// for C++17's `std::in_place_index_t`.
-template <size_t I>
-using in_place_index_t = void (*)(utility_internal::InPlaceIndexTag<I>);
-
-template <size_t I> void in_place_index(utility_internal::InPlaceIndexTag<I>) {}
-#endif // ABSL_USES_STD_VARIANT
-
-namespace utility_internal {
-// Helper method for expanding tuple into a called method.
-template <typename Functor, typename Tuple, std::size_t... Indexes>
-auto apply_helper(Functor &&functor, Tuple &&t, index_sequence<Indexes...>)
-    -> decltype(absl::base_internal::invoke(
-        absl::forward<Functor>(functor),
-        std::get<Indexes>(absl::forward<Tuple>(t))...)) {
-  return absl::base_internal::invoke(
-      absl::forward<Functor>(functor),
-      std::get<Indexes>(absl::forward<Tuple>(t))...);
-}
-
-} // namespace utility_internal
-
-// apply
-//
-// Invokes a Callable using elements of a tuple as its arguments.
-// Each element of the tuple corresponds to an argument of the call (in order).
-// Both the Callable argument and the tuple argument are perfect-forwarded.
-// For member-function Callables, the first tuple element acts as the `this`
-// pointer. `absl::apply` is designed to be a drop-in replacement for C++17's
-// `std::apply`. Unlike C++17's `std::apply`, this is not currently `constexpr`.
-//
-// Example:
-//
-//   class Foo {
-//    public:
-//     void Bar(int);
-//   };
-//   void user_function1(int, std::string);
-//   void user_function2(std::unique_ptr<Foo>);
-//   auto user_lambda = [](int, int) {};
-//
-//   int main()
-//   {
-//       std::tuple<int, std::string> tuple1(42, "bar");
-//       // Invokes the first user function on int, std::string.
-//       absl::apply(&user_function1, tuple1);
-//
-//       std::tuple<std::unique_ptr<Foo>> tuple2(absl::make_unique<Foo>());
-//       // Invokes the user function that takes ownership of the unique
-//       // pointer.
-//       absl::apply(&user_function2, std::move(tuple2));
-//
-//       auto foo = absl::make_unique<Foo>();
-//       std::tuple<Foo*, int> tuple3(foo.get(), 42);
-//       // Invokes the method Bar on foo with one argument, 42.
-//       absl::apply(&Foo::Bar, tuple3);
-//
-//       std::tuple<int, int> tuple4(8, 9);
-//       // Invokes a lambda.
-//       absl::apply(user_lambda, tuple4);
-//   }
-template <typename Functor, typename Tuple>
-auto apply(Functor &&functor, Tuple &&t)
-    -> decltype(utility_internal::apply_helper(
-        absl::forward<Functor>(functor), absl::forward<Tuple>(t),
-        absl::make_index_sequence<std::tuple_size<
-            typename std::remove_reference<Tuple>::type>::value>{})) {
-  return utility_internal::apply_helper(
-      absl::forward<Functor>(functor), absl::forward<Tuple>(t),
-      absl::make_index_sequence<std::tuple_size<
-          typename std::remove_reference<Tuple>::type>::value>{});
-}
-
-namespace utility_internal {
-template <typename T, typename Tuple, size_t... I>
-T make_from_tuple_impl(Tuple &&tup, absl::index_sequence<I...>) {
-  return T(std::get<I>(std::forward<Tuple>(tup))...);
-}
-} // namespace utility_internal
-
-// make_from_tuple
-//
-// Given the template parameter type `T` and a tuple of arguments
-// `std::tuple(arg0, arg1, ..., argN)` constructs an object of type `T` as if by
-// calling `T(arg0, arg1, ..., argN)`.
-//
-// Example:
-//
-//   std::tuple<const char*, size_t> args("hello world", 5);
-//   auto s = absl::make_from_tuple<std::string>(args);
-//   assert(s == "hello");
-//
-template <typename T, typename Tuple> constexpr T make_from_tuple(Tuple &&tup) {
-  return utility_internal::make_from_tuple_impl<T>(
-      std::forward<Tuple>(tup),
-      absl::make_index_sequence<
-          std::tuple_size<absl::decay_t<Tuple>>::value>{});
-}
-
-ABSL_NAMESPACE_END
-} // namespace absl
-
-#endif // ABSL_UTILITY_UTILITY_H_
diff --git a/packages/react-native-executorch/third-party/include/c10/macros/Export.h b/packages/react-native-executorch/third-party/include/c10/macros/Export.h
deleted file mode 100644
index 1b8a6811c5..0000000000
--- a/packages/react-native-executorch/third-party/include/c10/macros/Export.h
+++ /dev/null
@@ -1 +0,0 @@
-#include <torch/headeronly/macros/Export.h>
diff --git a/packages/react-native-executorch/third-party/include/c10/macros/Macros.h b/packages/react-native-executorch/third-party/include/c10/macros/Macros.h
deleted file mode 100644
index 87ebc4f422..0000000000
--- a/packages/react-native-executorch/third-party/include/c10/macros/Macros.h
+++ /dev/null
@@ -1 +0,0 @@
-#include <torch/headeronly/macros/Macros.h>
diff --git a/packages/react-native-executorch/third-party/include/c10/util/BFloat16-inl.h b/packages/react-native-executorch/third-party/include/c10/util/BFloat16-inl.h
deleted file mode 100644
index 6d3510cd5b..0000000000
--- a/packages/react-native-executorch/third-party/include/c10/util/BFloat16-inl.h
+++ /dev/null
@@ -1 +0,0 @@
-#include <torch/headeronly/util/BFloat16.h>
diff --git a/packages/react-native-executorch/third-party/include/c10/util/BFloat16-math.h b/packages/react-native-executorch/third-party/include/c10/util/BFloat16-math.h
deleted file mode 100644
index e5c7419261..0000000000
--- a/packages/react-native-executorch/third-party/include/c10/util/BFloat16-math.h
+++ /dev/null
@@ -1,266 +0,0 @@
-#pragma once
-
-#include <c10/util/BFloat16.h>
-#include <c10/util/Half.h>
-
-C10_CLANG_DIAGNOSTIC_PUSH()
-#if C10_CLANG_HAS_WARNING("-Wimplicit-float-conversion")
-C10_CLANG_DIAGNOSTIC_IGNORE("-Wimplicit-float-conversion")
-#endif
-
-namespace c10 {
-template <typename T>
-struct is_reduced_floating_point
-    : std::integral_constant<bool, std::is_same_v<T, c10::Half> ||
-                                       std::is_same_v<T, c10::BFloat16>> {};
-
-template <typename T>
-constexpr bool is_reduced_floating_point_v =
-    is_reduced_floating_point<T>::value;
-} // namespace c10
-
-namespace std {
-
-#if !defined(FBCODE_CAFFE2) && !defined(C10_NODEPRECATED)
-using c10::is_reduced_floating_point;
-using c10::is_reduced_floating_point_v;
-#endif // !defined(FBCODE_CAFFE2) && !defined(C10_NODEPRECATED)
-
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T acos(T a) {
-  return std::acos(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T asin(T a) {
-  return std::asin(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T atan(T a) {
-  return std::atan(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T atanh(T a) {
-  return std::atanh(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T erf(T a) {
-  return std::erf(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T erfc(T a) {
-  return std::erfc(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T exp(T a) {
-  return std::exp(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T expm1(T a) {
-  return std::expm1(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline bool isfinite(T a) {
-  return std::isfinite(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T log(T a) {
-  return std::log(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T log10(T a) {
-  return std::log10(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T log1p(T a) {
-  return std::log1p(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T log2(T a) {
-  return std::log2(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T ceil(T a) {
-  return std::ceil(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T cos(T a) {
-  return std::cos(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T floor(T a) {
-  return std::floor(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T nearbyint(T a) {
-  return std::nearbyint(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T sin(T a) {
-  return std::sin(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T tan(T a) {
-  return std::tan(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T sinh(T a) {
-  return std::sinh(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T cosh(T a) {
-  return std::cosh(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T tanh(T a) {
-  return std::tanh(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T trunc(T a) {
-  return std::trunc(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T lgamma(T a) {
-  return std::lgamma(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T sqrt(T a) {
-  return std::sqrt(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T rsqrt(T a) {
-  return 1.0 / std::sqrt(float(a));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T abs(T a) {
-  return std::abs(float(a));
-}
-#if defined(_MSC_VER) && defined(__CUDACC__)
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T pow(T a, double b) {
-  return std::pow(float(a), float(b));
-}
-#else
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T pow(T a, double b) {
-  return std::pow(float(a), b);
-}
-#endif
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T pow(T a, T b) {
-  return std::pow(float(a), float(b));
-}
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-inline T fmod(T a, T b) {
-  return std::fmod(float(a), float(b));
-}
-
-/*
-  The following function is inspired from the implementation in `musl`
-  Link to License: https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
-  ----------------------------------------------------------------------
-  Copyright © 2005-2020 Rich Felker, et al.
-
-  Permission is hereby granted, free of charge, to any person obtaining
-  a copy of this software and associated documentation files (the
-  "Software"), to deal in the Software without restriction, including
-  without limitation the rights to use, copy, modify, merge, publish,
-  distribute, sublicense, and/or sell copies of the Software, and to
-  permit persons to whom the Software is furnished to do so, subject to
-  the following conditions:
-
-  The above copyright notice and this permission notice shall be
-  included in all copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-  ----------------------------------------------------------------------
- */
-template <typename T, typename std::enable_if_t<
-                          c10::is_reduced_floating_point_v<T>, int> = 0>
-C10_HOST_DEVICE inline T nextafter(T from, T to) {
-  // Reference:
-  // https://git.musl-libc.org/cgit/musl/tree/src/math/nextafter.c
-  using int_repr_t = uint16_t;
-  constexpr uint8_t bits = 16;
-  union {
-    T f;
-    int_repr_t i;
-  } ufrom = {from}, uto = {to};
-
-  // get a mask to get the sign bit i.e. MSB
-  int_repr_t sign_mask = int_repr_t{1} << (bits - 1);
-
-  // short-circuit: if either is NaN, return NaN
-  if (from != from || to != to) {
-    return from + to;
-  }
-
-  // short-circuit: if they are exactly the same.
-  if (ufrom.i == uto.i) {
-    return from;
-  }
-
-  // mask the sign-bit to zero i.e. positive
-  // equivalent to abs(x)
-  int_repr_t abs_from = ufrom.i & ~sign_mask;
-  int_repr_t abs_to = uto.i & ~sign_mask;
-  if (abs_from == 0) {
-    // if both are zero but with different sign,
-    // preserve the sign of `to`.
-    if (abs_to == 0) {
-      return to;
-    }
-    // smallest subnormal with sign of `to`.
-    ufrom.i = (uto.i & sign_mask) | int_repr_t{1};
-    return ufrom.f;
-  }
-
-  // if abs(from) > abs(to) or sign(from) != sign(to)
-  if (abs_from > abs_to || ((ufrom.i ^ uto.i) & sign_mask)) {
-    ufrom.i--;
-  } else {
-    ufrom.i++;
-  }
-
-  return ufrom.f;
-}
-
-} // namespace std
-
-C10_CLANG_DIAGNOSTIC_POP()
diff --git a/packages/react-native-executorch/third-party/include/c10/util/BFloat16.h b/packages/react-native-executorch/third-party/include/c10/util/BFloat16.h
deleted file mode 100644
index 6d3510cd5b..0000000000
--- a/packages/react-native-executorch/third-party/include/c10/util/BFloat16.h
+++ /dev/null
@@ -1 +0,0 @@
-#include <torch/headeronly/util/BFloat16.h>
diff --git a/packages/react-native-executorch/third-party/include/c10/util/Half-inl.h b/packages/react-native-executorch/third-party/include/c10/util/Half-inl.h
deleted file mode 100644
index fe66779a0e..0000000000
--- a/packages/react-native-executorch/third-party/include/c10/util/Half-inl.h
+++ /dev/null
@@ -1 +0,0 @@
-#include <torch/headeronly/util/Half.h>
diff --git a/packages/react-native-executorch/third-party/include/c10/util/Half.h b/packages/react-native-executorch/third-party/include/c10/util/Half.h
deleted file mode 100644
index f61adacec6..0000000000
--- a/packages/react-native-executorch/third-party/include/c10/util/Half.h
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <torch/headeronly/util/Half.h>
-
-// need to keep the following for BC because the APIs in here were exposed
-// before migrating Half to torch/headeronly
-#if (defined(CPU_CAPABILITY_AVX2) || defined(CPU_CAPABILITY_AVX512)) &&        \
-    !defined(__APPLE__)
-#include <ATen/cpu/vec/vec_half.h>
-#endif
diff --git a/packages/react-native-executorch/third-party/include/c10/util/TypeSafeSignMath.h b/packages/react-native-executorch/third-party/include/c10/util/TypeSafeSignMath.h
deleted file mode 100644
index 28520225d4..0000000000
--- a/packages/react-native-executorch/third-party/include/c10/util/TypeSafeSignMath.h
+++ /dev/null
@@ -1 +0,0 @@
-#include <torch/headeronly/util/TypeSafeSignMath.h>
diff --git a/packages/react-native-executorch/third-party/include/c10/util/bit_cast.h b/packages/react-native-executorch/third-party/include/c10/util/bit_cast.h
deleted file mode 100644
index 49d0822d94..0000000000
--- a/packages/react-native-executorch/third-party/include/c10/util/bit_cast.h
+++ /dev/null
@@ -1 +0,0 @@
-#include <torch/headeronly/util/bit_cast.h>
diff --git a/packages/react-native-executorch/third-party/include/c10/util/complex.h b/packages/react-native-executorch/third-party/include/c10/util/complex.h
deleted file mode 100644
index 3e7027b802..0000000000
--- a/packages/react-native-executorch/third-party/include/c10/util/complex.h
+++ /dev/null
@@ -1,72 +0,0 @@
-#pragma once
-
-#include <complex>
-
-#include <c10/macros/Macros.h>
-#include <c10/util/Half.h>
-#include <torch/headeronly/util/complex.h>
-
-// std functions
-//
-// The implementation of these functions also follow the design of C++20
-
-namespace std {
-
-template <typename T> constexpr T real(const c10::complex<T> &z) {
-  return z.real();
-}
-
-template <typename T> constexpr T imag(const c10::complex<T> &z) {
-  return z.imag();
-}
-
-template <typename T> C10_HOST_DEVICE T abs(const c10::complex<T> &z) {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  return thrust::abs(static_cast<thrust::complex<T>>(z));
-#else
-  return std::abs(static_cast<std::complex<T>>(z));
-#endif
-}
-
-#if defined(USE_ROCM)
-#define ROCm_Bug(x)
-#else
-#define ROCm_Bug(x) x
-#endif
-
-template <typename T> C10_HOST_DEVICE T arg(const c10::complex<T> &z) {
-  return ROCm_Bug(std)::atan2(std::imag(z), std::real(z));
-}
-
-#undef ROCm_Bug
-
-template <typename T> constexpr T norm(const c10::complex<T> &z) {
-  return z.real() * z.real() + z.imag() * z.imag();
-}
-
-// For std::conj, there are other versions of it:
-//   constexpr std::complex<float> conj( float z );
-//   template< class DoubleOrInteger >
-//   constexpr std::complex<double> conj( DoubleOrInteger z );
-//   constexpr std::complex<long double> conj( long double z );
-// These are not implemented
-// TODO(@zasdfgbnm): implement them as c10::conj
-template <typename T> constexpr c10::complex<T> conj(const c10::complex<T> &z) {
-  return c10::complex<T>(z.real(), -z.imag());
-}
-
-// Thrust does not have complex --> complex version of thrust::proj,
-// so this function is not implemented at c10 right now.
-// TODO(@zasdfgbnm): implement it by ourselves
-
-// There is no c10 version of std::polar, because std::polar always
-// returns std::complex. Use c10::polar instead;
-
-} // namespace std
-
-#define C10_INTERNAL_INCLUDE_COMPLEX_REMAINING_H
-// math functions are included in a separate file
-#include <c10/util/complex_math.h> // IWYU pragma: keep
-// utilities for complex types
-#include <c10/util/complex_utils.h> // IWYU pragma: keep
-#undef C10_INTERNAL_INCLUDE_COMPLEX_REMAINING_H
diff --git a/packages/react-native-executorch/third-party/include/c10/util/complex_math.h b/packages/react-native-executorch/third-party/include/c10/util/complex_math.h
deleted file mode 100644
index 11beaa00fe..0000000000
--- a/packages/react-native-executorch/third-party/include/c10/util/complex_math.h
+++ /dev/null
@@ -1,399 +0,0 @@
-#if !defined(C10_INTERNAL_INCLUDE_COMPLEX_REMAINING_H)
-#error                                                                         \
-    "c10/util/complex_math.h is not meant to be individually included. Include c10/util/complex.h instead."
-#endif
-
-namespace c10_complex_math {
-
-// Exponential functions
-
-template <typename T>
-C10_HOST_DEVICE inline c10::complex<T> exp(const c10::complex<T> &x) {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(
-      thrust::exp(static_cast<thrust::complex<T>>(x)));
-#else
-  return static_cast<c10::complex<T>>(
-      std::exp(static_cast<std::complex<T>>(x)));
-#endif
-}
-
-template <typename T>
-C10_HOST_DEVICE inline c10::complex<T> log(const c10::complex<T> &x) {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(
-      thrust::log(static_cast<thrust::complex<T>>(x)));
-#else
-  return static_cast<c10::complex<T>>(
-      std::log(static_cast<std::complex<T>>(x)));
-#endif
-}
-
-template <typename T>
-C10_HOST_DEVICE inline c10::complex<T> log10(const c10::complex<T> &x) {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(
-      thrust::log10(static_cast<thrust::complex<T>>(x)));
-#else
-  return static_cast<c10::complex<T>>(
-      std::log10(static_cast<std::complex<T>>(x)));
-#endif
-}
-
-template <typename T>
-C10_HOST_DEVICE inline c10::complex<T> log2(const c10::complex<T> &x) {
-  const c10::complex<T> log2 = c10::complex<T>(::log(2.0), 0.0);
-  return c10_complex_math::log(x) / log2;
-}
-
-// Power functions
-//
-#if defined(_LIBCPP_VERSION) ||                                                \
-    (defined(__GLIBCXX__) && !defined(_GLIBCXX11_USE_C99_COMPLEX))
-namespace _detail {
-C10_API c10::complex<float> sqrt(const c10::complex<float> &in);
-C10_API c10::complex<double> sqrt(const c10::complex<double> &in);
-C10_API c10::complex<float> acos(const c10::complex<float> &in);
-C10_API c10::complex<double> acos(const c10::complex<double> &in);
-} // namespace _detail
-#endif
-
-template <typename T>
-C10_HOST_DEVICE inline c10::complex<T> sqrt(const c10::complex<T> &x) {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(
-      thrust::sqrt(static_cast<thrust::complex<T>>(x)));
-#elif !(defined(_LIBCPP_VERSION) ||                                            \
-        (defined(__GLIBCXX__) && !defined(_GLIBCXX11_USE_C99_COMPLEX)))
-  return static_cast<c10::complex<T>>(
-      std::sqrt(static_cast<std::complex<T>>(x)));
-#else
-  return _detail::sqrt(x);
-#endif
-}
-
-template <typename T>
-C10_HOST_DEVICE inline c10::complex<T> pow(const c10::complex<T> &x,
-                                           const c10::complex<T> &y) {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(thrust::pow(
-      static_cast<thrust::complex<T>>(x), static_cast<thrust::complex<T>>(y)));
-#else
-  return static_cast<c10::complex<T>>(std::pow(
-      static_cast<std::complex<T>>(x), static_cast<std::complex<T>>(y)));
-#endif
-}
-
-template <typename T>
-C10_HOST_DEVICE inline c10::complex<T> pow(const c10::complex<T> &x,
-                                           const T &y) {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(
-      thrust::pow(static_cast<thrust::complex<T>>(x), y));
-#else
-  return static_cast<c10::complex<T>>(
-      std::pow(static_cast<std::complex<T>>(x), y));
-#endif
-}
-
-template <typename T>
-C10_HOST_DEVICE inline c10::complex<T> pow(const T &x,
-                                           const c10::complex<T> &y) {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(
-      thrust::pow(x, static_cast<thrust::complex<T>>(y)));
-#else
-  return static_cast<c10::complex<T>>(
-      std::pow(x, static_cast<std::complex<T>>(y)));
-#endif
-}
-
-template <typename T, typename U>
-C10_HOST_DEVICE inline c10::complex<decltype(T() * U())>
-pow(const c10::complex<T> &x, const c10::complex<U> &y) {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(thrust::pow(
-      static_cast<thrust::complex<T>>(x), static_cast<thrust::complex<T>>(y)));
-#else
-  return static_cast<c10::complex<T>>(std::pow(
-      static_cast<std::complex<T>>(x), static_cast<std::complex<T>>(y)));
-#endif
-}
-
-template <typename T, typename U>
-C10_HOST_DEVICE inline c10::complex<decltype(T() * U())>
-pow(const c10::complex<T> &x, const U &y) {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(
-      thrust::pow(static_cast<thrust::complex<T>>(x), y));
-#else
-  return static_cast<c10::complex<T>>(
-      std::pow(static_cast<std::complex<T>>(x), y));
-#endif
-}
-
-template <typename T, typename U>
-C10_HOST_DEVICE inline c10::complex<decltype(T() * U())>
-pow(const T &x, const c10::complex<U> &y) {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(
-      thrust::pow(x, static_cast<thrust::complex<T>>(y)));
-#else
-  return static_cast<c10::complex<T>>(
-      std::pow(x, static_cast<std::complex<T>>(y)));
-#endif
-}
-
-// Trigonometric functions
-
-template <typename T>
-C10_HOST_DEVICE inline c10::complex<T> sin(const c10::complex<T> &x) {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(
-      thrust::sin(static_cast<thrust::complex<T>>(x)));
-#else
-  return static_cast<c10::complex<T>>(
-      std::sin(static_cast<std::complex<T>>(x)));
-#endif
-}
-
-template <typename T>
-C10_HOST_DEVICE inline c10::complex<T> cos(const c10::complex<T> &x) {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(
-      thrust::cos(static_cast<thrust::complex<T>>(x)));
-#else
-  return static_cast<c10::complex<T>>(
-      std::cos(static_cast<std::complex<T>>(x)));
-#endif
-}
-
-template <typename T>
-C10_HOST_DEVICE inline c10::complex<T> tan(const c10::complex<T> &x) {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(
-      thrust::tan(static_cast<thrust::complex<T>>(x)));
-#else
-  return static_cast<c10::complex<T>>(
-      std::tan(static_cast<std::complex<T>>(x)));
-#endif
-}
-
-template <typename T>
-C10_HOST_DEVICE inline c10::complex<T> asin(const c10::complex<T> &x) {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(
-      thrust::asin(static_cast<thrust::complex<T>>(x)));
-#else
-  return static_cast<c10::complex<T>>(
-      std::asin(static_cast<std::complex<T>>(x)));
-#endif
-}
-
-template <typename T>
-C10_HOST_DEVICE inline c10::complex<T> acos(const c10::complex<T> &x) {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(
-      thrust::acos(static_cast<thrust::complex<T>>(x)));
-#elif !defined(_LIBCPP_VERSION)
-  return static_cast<c10::complex<T>>(
-      std::acos(static_cast<std::complex<T>>(x)));
-#else
-  return _detail::acos(x);
-#endif
-}
-
-template <typename T>
-C10_HOST_DEVICE inline c10::complex<T> atan(const c10::complex<T> &x) {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(
-      thrust::atan(static_cast<thrust::complex<T>>(x)));
-#else
-  return static_cast<c10::complex<T>>(
-      std::atan(static_cast<std::complex<T>>(x)));
-#endif
-}
-
-// Hyperbolic functions
-
-template <typename T>
-C10_HOST_DEVICE inline c10::complex<T> sinh(const c10::complex<T> &x) {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(
-      thrust::sinh(static_cast<thrust::complex<T>>(x)));
-#else
-  return static_cast<c10::complex<T>>(
-      std::sinh(static_cast<std::complex<T>>(x)));
-#endif
-}
-
-template <typename T>
-C10_HOST_DEVICE inline c10::complex<T> cosh(const c10::complex<T> &x) {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(
-      thrust::cosh(static_cast<thrust::complex<T>>(x)));
-#else
-  return static_cast<c10::complex<T>>(
-      std::cosh(static_cast<std::complex<T>>(x)));
-#endif
-}
-
-template <typename T>
-C10_HOST_DEVICE inline c10::complex<T> tanh(const c10::complex<T> &x) {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(
-      thrust::tanh(static_cast<thrust::complex<T>>(x)));
-#else
-  return static_cast<c10::complex<T>>(
-      std::tanh(static_cast<std::complex<T>>(x)));
-#endif
-}
-
-template <typename T>
-C10_HOST_DEVICE inline c10::complex<T> asinh(const c10::complex<T> &x) {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(
-      thrust::asinh(static_cast<thrust::complex<T>>(x)));
-#else
-  return static_cast<c10::complex<T>>(
-      std::asinh(static_cast<std::complex<T>>(x)));
-#endif
-}
-
-template <typename T>
-C10_HOST_DEVICE inline c10::complex<T> acosh(const c10::complex<T> &x) {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(
-      thrust::acosh(static_cast<thrust::complex<T>>(x)));
-#else
-  return static_cast<c10::complex<T>>(
-      std::acosh(static_cast<std::complex<T>>(x)));
-#endif
-}
-
-template <typename T>
-C10_HOST_DEVICE inline c10::complex<T> atanh(const c10::complex<T> &x) {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(
-      thrust::atanh(static_cast<thrust::complex<T>>(x)));
-#else
-  return static_cast<c10::complex<T>>(
-      std::atanh(static_cast<std::complex<T>>(x)));
-#endif
-}
-
-template <typename T>
-C10_HOST_DEVICE inline c10::complex<T> log1p(const c10::complex<T> &z) {
-#if defined(__APPLE__) || defined(__MACOSX) || defined(__CUDACC__) ||          \
-    defined(__HIPCC__)
-  // For Mac, the new implementation yielded a high relative error. Falling back
-  // to the old version for now.
-  // See https://github.com/numpy/numpy/pull/22611#issuecomment-1667945354
-  // For CUDA we also use this one, as thrust::log(thrust::complex) takes
-  // *forever* to compile
-
-  // log1p(z) = log(1 + z)
-  // Let's define 1 + z = r * e ^ (i * a), then we have
-  // log(r * e ^ (i * a)) = log(r) + i * a
-  // With z = x + iy, the term r can be written as
-  // r = ((1 + x) ^ 2 + y ^ 2) ^ 0.5
-  //   = (1 + x ^ 2 + 2 * x + y ^ 2) ^ 0.5
-  // So, log(r) is
-  // log(r) = 0.5 * log(1 + x ^ 2 + 2 * x + y ^ 2)
-  //        = 0.5 * log1p(x * (x + 2) + y ^ 2)
-  // we need to use the expression only on certain condition to avoid overflow
-  // and underflow from `(x * (x + 2) + y ^ 2)`
-  T x = z.real();
-  T y = z.imag();
-  T zabs = std::abs(z);
-  T theta = std::atan2(y, x + T(1));
-  if (zabs < 0.5) {
-    T r = x * (T(2) + x) + y * y;
-    if (r == 0) { // handle underflow
-      return {x, theta};
-    }
-    return {T(0.5) * std::log1p(r), theta};
-  } else {
-    T z0 = std::hypot(x + 1, y);
-    return {std::log(z0), theta};
-  }
-#else
-  // CPU path
-  // Based on https://github.com/numpy/numpy/pull/22611#issuecomment-1667945354
-  c10::complex<T> u = z + T(1);
-  if (u == T(1)) {
-    return z;
-  } else {
-    auto log_u = log(u);
-    if (u - T(1) == z) {
-      return log_u;
-    }
-    return log_u * (z / (u - T(1)));
-  }
-#endif
-}
-
-template <typename T>
-C10_HOST_DEVICE inline c10::complex<T> expm1(const c10::complex<T> &z) {
-  // expm1(z) = exp(z) - 1
-  // Define z = x + i * y
-  // f = e ^ (x + i * y) - 1
-  //   = e ^ x * e ^ (i * y) - 1
-  //   = (e ^ x * cos(y) - 1) + i * (e ^ x * sin(y))
-  //   = (e ^ x - 1) * cos(y) - (1 - cos(y)) + i * e ^ x * sin(y)
-  //   = expm1(x) * cos(y) - 2 * sin(y / 2) ^ 2 + i * e ^ x * sin(y)
-  T x = z.real();
-  T y = z.imag();
-  T a = std::sin(y / 2);
-  T er = std::expm1(x) * std::cos(y) - T(2) * a * a;
-  T ei = std::exp(x) * std::sin(y);
-  return {er, ei};
-}
-
-} // namespace c10_complex_math
-
-using c10_complex_math::acos;
-using c10_complex_math::acosh;
-using c10_complex_math::asin;
-using c10_complex_math::asinh;
-using c10_complex_math::atan;
-using c10_complex_math::atanh;
-using c10_complex_math::cos;
-using c10_complex_math::cosh;
-using c10_complex_math::exp;
-using c10_complex_math::expm1;
-using c10_complex_math::log;
-using c10_complex_math::log10;
-using c10_complex_math::log1p;
-using c10_complex_math::log2;
-using c10_complex_math::pow;
-using c10_complex_math::sin;
-using c10_complex_math::sinh;
-using c10_complex_math::sqrt;
-using c10_complex_math::tan;
-using c10_complex_math::tanh;
-
-namespace std {
-
-using c10_complex_math::acos;
-using c10_complex_math::acosh;
-using c10_complex_math::asin;
-using c10_complex_math::asinh;
-using c10_complex_math::atan;
-using c10_complex_math::atanh;
-using c10_complex_math::cos;
-using c10_complex_math::cosh;
-using c10_complex_math::exp;
-using c10_complex_math::expm1;
-using c10_complex_math::log;
-using c10_complex_math::log10;
-using c10_complex_math::log1p;
-using c10_complex_math::log2;
-using c10_complex_math::pow;
-using c10_complex_math::sin;
-using c10_complex_math::sinh;
-using c10_complex_math::sqrt;
-using c10_complex_math::tan;
-using c10_complex_math::tanh;
-
-} // namespace std
diff --git a/packages/react-native-executorch/third-party/include/c10/util/complex_utils.h b/packages/react-native-executorch/third-party/include/c10/util/complex_utils.h
deleted file mode 100644
index 480b06fa59..0000000000
--- a/packages/react-native-executorch/third-party/include/c10/util/complex_utils.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#if !defined(C10_INTERNAL_INCLUDE_COMPLEX_REMAINING_H)
-#error                                                                         \
-    "c10/util/complex_utils.h is not meant to be individually included. Include c10/util/complex.h instead."
-#endif
-
-#include <limits>
-
-namespace c10 {
-
-template <typename T> struct is_complex : public std::false_type {};
-
-template <typename T>
-struct is_complex<std::complex<T>> : public std::true_type {};
-
-template <typename T>
-struct is_complex<c10::complex<T>> : public std::true_type {};
-
-// Extract double from std::complex<double>; is identity otherwise
-// TODO: Write in more idiomatic C++17
-template <typename T> struct scalar_value_type {
-  using type = T;
-};
-template <typename T> struct scalar_value_type<std::complex<T>> {
-  using type = T;
-};
-template <typename T> struct scalar_value_type<c10::complex<T>> {
-  using type = T;
-};
-
-} // namespace c10
-
-namespace std {
-
-template <typename T>
-class numeric_limits<c10::complex<T>> : public numeric_limits<T> {};
-
-template <typename T> bool isnan(const c10::complex<T> &v) {
-  return std::isnan(v.real()) || std::isnan(v.imag());
-}
-
-} // namespace std
diff --git a/packages/react-native-executorch/third-party/include/c10/util/floating_point_utils.h b/packages/react-native-executorch/third-party/include/c10/util/floating_point_utils.h
deleted file mode 100644
index 10aa67c7cb..0000000000
--- a/packages/react-native-executorch/third-party/include/c10/util/floating_point_utils.h
+++ /dev/null
@@ -1 +0,0 @@
-#include <torch/headeronly/util/floating_point_utils.h>
diff --git a/packages/react-native-executorch/third-party/include/c10/util/irange.h b/packages/react-native-executorch/third-party/include/c10/util/irange.h
deleted file mode 100644
index c2f4691388..0000000000
--- a/packages/react-native-executorch/third-party/include/c10/util/irange.h
+++ /dev/null
@@ -1,107 +0,0 @@
-// Copyright 2004-present Facebook. All Rights Reserved.
-
-#pragma once
-
-#include <c10/util/TypeSafeSignMath.h>
-
-#include <algorithm>
-#include <cstddef>
-#include <iterator>
-#include <type_traits>
-
-namespace c10 {
-
-namespace detail {
-
-template <typename I, bool one_sided = false,
-          std::enable_if_t<std::is_integral_v<I>, int> = 0>
-struct integer_iterator {
-  using iterator_category = std::input_iterator_tag;
-  using value_type = I;
-  using difference_type = std::ptrdiff_t;
-  using pointer = I *;
-  using reference = I &;
-
-  explicit constexpr integer_iterator(I val) : value(val) {}
-
-  constexpr I operator*() const { return value; }
-
-  constexpr I const *operator->() const { return &value; }
-
-  constexpr integer_iterator &operator++() {
-    ++value;
-    return *this;
-  }
-
-  constexpr integer_iterator operator++(int) {
-    const auto copy = *this;
-    ++*this;
-    return copy;
-  }
-
-  constexpr bool operator==(const integer_iterator &other) const {
-    if constexpr (one_sided) {
-      // Range-for loops' end test is `begin != end`, not `begin <
-      // end`. To handle `c10::irange(n)` where n < 0 (which should be
-      // empty), we just make `begin != end` fail whenever `end` is
-      // negative.
-      return is_negative(other.value) || value == other.value;
-    } else {
-      return value == other.value;
-    }
-    // Suppress "warning: missing return statement at end of non-void function"
-    // which Nvidia's Robert Crovella confirms is an NVCC compiler error
-    // here https://stackoverflow.com/a/64561686/752843 on 2020-10-27
-    // `__builtin_unreachable();` would be best here, but it's not
-    // available with all compilers. So we instead return an arbitrary
-    // value trusting that this line will, in fact, never be reached.
-    return false; // Horrible hack
-  }
-
-  constexpr bool operator!=(const integer_iterator &other) const {
-    return !(*this == other);
-  }
-
-protected:
-  I value;
-};
-
-} // namespace detail
-
-template <typename I, bool one_sided = false,
-          std::enable_if_t<std::is_integral_v<I>, bool> = true>
-struct integer_range {
-public:
-  constexpr integer_range(I begin, I end) : begin_(begin), end_(end) {}
-  using iterator = detail::integer_iterator<I, one_sided>;
-  constexpr iterator begin() const { return begin_; }
-  constexpr iterator end() const { return end_; }
-
-private:
-  iterator begin_;
-  iterator end_;
-};
-
-/// Creates an integer range for the half-open interval [begin, end)
-/// If end<=begin, then the range is empty.
-/// The range has the type of the `end` integer; `begin` integer is
-/// cast to this type.
-template <typename Integer1, typename Integer2,
-          std::enable_if_t<std::is_integral_v<Integer1>, bool> = true,
-          std::enable_if_t<std::is_integral_v<Integer2>, bool> = true>
-constexpr integer_range<Integer2> irange(Integer1 begin, Integer2 end) {
-  // If end<=begin then the range is empty; we can achieve this effect by
-  // choosing the larger of {begin, end} as the loop terminator
-  return {static_cast<Integer2>(begin),
-          std::max(static_cast<Integer2>(begin), end)};
-}
-
-/// Creates an integer range for the half-open interval [0, end)
-/// If end<=begin, then the range is empty
-template <typename Integer,
-          std::enable_if_t<std::is_integral_v<Integer>, bool> = true>
-constexpr integer_range<Integer, true> irange(Integer end) {
-  return {Integer(), end};
-}
-
-} // namespace c10
diff --git a/packages/react-native-executorch/third-party/include/c10/util/llvmMathExtras.h b/packages/react-native-executorch/third-party/include/c10/util/llvmMathExtras.h
deleted file mode 100644
index 218d336e7c..0000000000
--- a/packages/react-native-executorch/third-party/include/c10/util/llvmMathExtras.h
+++ /dev/null
@@ -1,866 +0,0 @@
-//===-- llvm/Support/MathExtras.h - Useful math functions -------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains some functions that are useful for math stuff.
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <c10/util/bit_cast.h>
-
-#include <algorithm>
-#include <cassert>
-#include <climits>
-#include <cmath>
-#include <cstdint>
-#include <cstring>
-#include <limits>
-#include <type_traits>
-
-#ifdef __ANDROID_NDK__
-#include <android/api-level.h>
-#endif
-
-#ifndef __has_builtin
-#define __has_builtin(x) 0
-#endif
-
-#ifndef LLVM_GNUC_PREREQ
-#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
-#define LLVM_GNUC_PREREQ(maj, min, patch)                                      \
-  ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) + __GNUC_PATCHLEVEL__ >=          \
-   ((maj) << 20) + ((min) << 10) + (patch))
-#elif defined(__GNUC__) && defined(__GNUC_MINOR__)
-#define LLVM_GNUC_PREREQ(maj, min, patch)                                      \
-  ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) >= ((maj) << 20) + ((min) << 10))
-#else
-#define LLVM_GNUC_PREREQ(maj, min, patch) 0
-#endif
-#endif
-
-#ifdef _MSC_VER
-// Declare these intrinsics manually rather including intrin.h. It's very
-// expensive, and MathExtras.h is popular.
-// #include <intrin.h>
-extern "C" {
-unsigned char _BitScanForward(unsigned long *_Index, unsigned long _Mask);
-unsigned char _BitScanForward64(unsigned long *_Index, unsigned __int64 _Mask);
-unsigned char _BitScanReverse(unsigned long *_Index, unsigned long _Mask);
-unsigned char _BitScanReverse64(unsigned long *_Index, unsigned __int64 _Mask);
-}
-#endif
-
-namespace c10::llvm {
-/// The behavior an operation has on an input of 0.
-enum ZeroBehavior {
-  /// The returned value is undefined.
-  ZB_Undefined,
-  /// The returned value is numeric_limits<T>::max()
-  ZB_Max,
-  /// The returned value is numeric_limits<T>::digits
-  ZB_Width
-};
-
-namespace detail {
-template <typename T, std::size_t SizeOfT> struct TrailingZerosCounter {
-  static std::size_t count(T Val, ZeroBehavior /*unused*/) {
-    if (!Val)
-      return std::numeric_limits<T>::digits;
-    if (Val & 0x1)
-      return 0;
-
-    // Bisection method.
-    std::size_t ZeroBits = 0;
-    T Shift = std::numeric_limits<T>::digits >> 1;
-    T Mask = std::numeric_limits<T>::max() >> Shift;
-    while (Shift) {
-      if ((Val & Mask) == 0) {
-        Val >>= Shift;
-        ZeroBits |= Shift;
-      }
-      Shift >>= 1;
-      Mask >>= Shift;
-    }
-    return ZeroBits;
-  }
-};
-
-#if (defined(__GNUC__) && __GNUC__ >= 4) || defined(_MSC_VER)
-template <typename T> struct TrailingZerosCounter<T, 4> {
-  static std::size_t count(T Val, ZeroBehavior ZB) {
-    if (ZB != ZB_Undefined && Val == 0)
-      return 32;
-
-#if __has_builtin(__builtin_ctz) || LLVM_GNUC_PREREQ(4, 0, 0)
-    return __builtin_ctz(Val);
-#elif defined(_MSC_VER)
-    unsigned long Index;
-    _BitScanForward(&Index, Val);
-    return Index;
-#endif
-  }
-};
-
-#if !defined(_MSC_VER) || defined(_M_X64)
-template <typename T> struct TrailingZerosCounter<T, 8> {
-  static std::size_t count(T Val, ZeroBehavior ZB) {
-    if (ZB != ZB_Undefined && Val == 0)
-      return 64;
-
-#if __has_builtin(__builtin_ctzll) || LLVM_GNUC_PREREQ(4, 0, 0)
-    return __builtin_ctzll(Val);
-#elif defined(_MSC_VER)
-    unsigned long Index;
-    _BitScanForward64(&Index, Val);
-    return Index;
-#endif
-  }
-};
-#endif
-#endif
-} // namespace detail
-
-/// Count number of 0's from the least significant bit to the most
-///   stopping at the first 1.
-///
-/// Only unsigned integral types are allowed.
-///
-/// \param ZB the behavior on an input of 0. Only ZB_Width and ZB_Undefined are
-///   valid arguments.
-template <typename T>
-std::size_t countTrailingZeros(T Val, ZeroBehavior ZB = ZB_Width) {
-  static_assert(std::numeric_limits<T>::is_integer &&
-                    !std::numeric_limits<T>::is_signed,
-                "Only unsigned integral types are allowed.");
-  return llvm::detail::TrailingZerosCounter<T, sizeof(T)>::count(Val, ZB);
-}
-
-namespace detail {
-template <typename T, std::size_t SizeOfT> struct LeadingZerosCounter {
-  static std::size_t count(T Val, ZeroBehavior /*unused*/) {
-    if (!Val)
-      return std::numeric_limits<T>::digits;
-
-    // Bisection method.
-    std::size_t ZeroBits = 0;
-    for (T Shift = std::numeric_limits<T>::digits >> 1; Shift; Shift >>= 1) {
-      T Tmp = Val >> Shift;
-      if (Tmp)
-        Val = Tmp;
-      else
-        ZeroBits |= Shift;
-    }
-    return ZeroBits;
-  }
-};
-
-#if (defined(__GNUC__) && __GNUC__ >= 4) || defined(_MSC_VER)
-template <typename T> struct LeadingZerosCounter<T, 4> {
-  static std::size_t count(T Val, ZeroBehavior ZB) {
-    if (ZB != ZB_Undefined && Val == 0)
-      return 32;
-
-#if __has_builtin(__builtin_clz) || LLVM_GNUC_PREREQ(4, 0, 0)
-    return __builtin_clz(Val);
-#elif defined(_MSC_VER)
-    unsigned long Index;
-    _BitScanReverse(&Index, Val);
-    return Index ^ 31;
-#endif
-  }
-};
-
-#if !defined(_MSC_VER) || defined(_M_X64)
-template <typename T> struct LeadingZerosCounter<T, 8> {
-  static std::size_t count(T Val, ZeroBehavior ZB) {
-    if (ZB != ZB_Undefined && Val == 0)
-      return 64;
-
-#if __has_builtin(__builtin_clzll) || LLVM_GNUC_PREREQ(4, 0, 0)
-    return __builtin_clzll(Val);
-#elif defined(_MSC_VER)
-    unsigned long Index;
-    _BitScanReverse64(&Index, Val);
-    return Index ^ 63;
-#endif
-  }
-};
-#endif
-#endif
-} // namespace detail
-
-/// Count number of 0's from the most significant bit to the least
-///   stopping at the first 1.
-///
-/// Only unsigned integral types are allowed.
-///
-/// \param ZB the behavior on an input of 0. Only ZB_Width and ZB_Undefined are
-///   valid arguments.
-template <typename T>
-std::size_t countLeadingZeros(T Val, ZeroBehavior ZB = ZB_Width) {
-  static_assert(std::numeric_limits<T>::is_integer &&
-                    !std::numeric_limits<T>::is_signed,
-                "Only unsigned integral types are allowed.");
-  return llvm::detail::LeadingZerosCounter<T, sizeof(T)>::count(Val, ZB);
-}
-
-/// Get the index of the first set bit starting from the least
-///   significant bit.
-///
-/// Only unsigned integral types are allowed.
-///
-/// \param ZB the behavior on an input of 0. Only ZB_Max and ZB_Undefined are
-///   valid arguments.
-template <typename T> T findFirstSet(T Val, ZeroBehavior ZB = ZB_Max) {
-  if (ZB == ZB_Max && Val == 0)
-    return std::numeric_limits<T>::max();
-
-  return countTrailingZeros(Val, ZB_Undefined);
-}
-
-/// Create a bitmask with the N right-most bits set to 1, and all other
-/// bits set to 0.  Only unsigned types are allowed.
-template <typename T> T maskTrailingOnes(unsigned N) {
-  static_assert(std::is_unsigned_v<T>, "Invalid type!");
-  const unsigned Bits = CHAR_BIT * sizeof(T);
-  assert(N <= Bits && "Invalid bit index");
-  return N == 0 ? 0 : (T(-1) >> (Bits - N));
-}
-
-/// Create a bitmask with the N left-most bits set to 1, and all other
-/// bits set to 0.  Only unsigned types are allowed.
-template <typename T> T maskLeadingOnes(unsigned N) {
-  return ~maskTrailingOnes<T>(CHAR_BIT * sizeof(T) - N);
-}
-
-/// Create a bitmask with the N right-most bits set to 0, and all other
-/// bits set to 1.  Only unsigned types are allowed.
-template <typename T> T maskTrailingZeros(unsigned N) {
-  return maskLeadingOnes<T>(CHAR_BIT * sizeof(T) - N);
-}
-
-/// Create a bitmask with the N left-most bits set to 0, and all other
-/// bits set to 1.  Only unsigned types are allowed.
-template <typename T> T maskLeadingZeros(unsigned N) {
-  return maskTrailingOnes<T>(CHAR_BIT * sizeof(T) - N);
-}
-
-/// Get the index of the last set bit starting from the least
-///   significant bit.
-///
-/// Only unsigned integral types are allowed.
-///
-/// \param ZB the behavior on an input of 0. Only ZB_Max and ZB_Undefined are
-///   valid arguments.
-template <typename T> T findLastSet(T Val, ZeroBehavior ZB = ZB_Max) {
-  if (ZB == ZB_Max && Val == 0)
-    return std::numeric_limits<T>::max();
-
-  // Use ^ instead of - because both gcc and llvm can remove the associated ^
-  // in the __builtin_clz intrinsic on x86.
-  return countLeadingZeros(Val, ZB_Undefined) ^
-         (std::numeric_limits<T>::digits - 1);
-}
-
-/// Macro compressed bit reversal table for 256 bits.
-///
-/// http://graphics.stanford.edu/~seander/bithacks.html#BitReverseTable
-/// NOLINTNEXTLINE(*c-arrays*)
-static constexpr unsigned char BitReverseTable256[256] = {
-#define R2(n) n, n + 2 * 64, n + 1 * 64, n + 3 * 64
-#define R4(n) R2(n), R2(n + 2 * 16), R2(n + 1 * 16), R2(n + 3 * 16)
-#define R6(n) R4(n), R4(n + 2 * 4), R4(n + 1 * 4), R4(n + 3 * 4)
-    R6(0), R6(2), R6(1), R6(3)
-#undef R2
-#undef R4
-#undef R6
-};
-
-/// Reverse the bits in \p Val.
-template <typename T> T reverseBits(T Val) {
-  // NOLINTNEXTLINE(*c-arrays*)
-  unsigned char in[sizeof(Val)];
-  // NOLINTNEXTLINE(*c-arrays*)
-  unsigned char out[sizeof(Val)];
-  std::memcpy(in, &Val, sizeof(Val));
-  for (unsigned i = 0; i < sizeof(Val); ++i)
-    out[(sizeof(Val) - i) - 1] = BitReverseTable256[in[i]];
-  std::memcpy(&Val, out, sizeof(Val));
-  return Val;
-}
-
-// NOTE: The following support functions use the _32/_64 extensions instead of
-// type overloading so that signed and unsigned integers can be used without
-// ambiguity.
-
-/// Return the high 32 bits of a 64 bit value.
-constexpr inline uint32_t Hi_32(uint64_t Value) {
-  return static_cast<uint32_t>(Value >> 32);
-}
-
-/// Return the low 32 bits of a 64 bit value.
-constexpr inline uint32_t Lo_32(uint64_t Value) {
-  return static_cast<uint32_t>(Value);
-}
-
-/// Make a 64-bit integer from a high / low pair of 32-bit integers.
-constexpr inline uint64_t Make_64(uint32_t High, uint32_t Low) {
-  return ((uint64_t)High << 32) | (uint64_t)Low;
-}
-
-/// Checks if an integer fits into the given bit width.
-template <unsigned N> constexpr inline bool isInt(int64_t x) {
-  return N >= 64 ||
-         (-(INT64_C(1) << (N - 1)) <= x && x < (INT64_C(1) << (N - 1)));
-}
-// Template specializations to get better code for common cases.
-template <> constexpr inline bool isInt<8>(int64_t x) {
-  return static_cast<int8_t>(x) == x;
-}
-template <> constexpr inline bool isInt<16>(int64_t x) {
-  return static_cast<int16_t>(x) == x;
-}
-template <> constexpr inline bool isInt<32>(int64_t x) {
-  return static_cast<int32_t>(x) == x;
-}
-
-/// Checks if a signed integer is an N bit number shifted left by S.
-template <unsigned N, unsigned S>
-constexpr inline bool isShiftedInt(int64_t x) {
-  static_assert(
-      N > 0, "isShiftedInt<0> doesn't make sense (refers to a 0-bit number.");
-  static_assert(N + S <= 64, "isShiftedInt<N, S> with N + S > 64 is too wide.");
-  return isInt<N + S>(x) && (x % (UINT64_C(1) << S) == 0);
-}
-
-/// Checks if an unsigned integer fits into the given bit width.
-///
-/// This is written as two functions rather than as simply
-///
-///   return N >= 64 || X < (UINT64_C(1) << N);
-///
-/// to keep MSVC from (incorrectly) warning on isUInt<64> that we're shifting
-/// left too many places.
-template <unsigned N>
-constexpr inline std::enable_if_t<(N < 64), bool> isUInt(uint64_t X) {
-  static_assert(N > 0, "isUInt<0> doesn't make sense");
-  return X < (UINT64_C(1) << N);
-}
-template <unsigned N>
-constexpr inline std::enable_if_t<N >= 64, bool> isUInt(uint64_t /*X*/) {
-  return true;
-}
-
-// Template specializations to get better code for common cases.
-template <> constexpr inline bool isUInt<8>(uint64_t x) {
-  return static_cast<uint8_t>(x) == x;
-}
-template <> constexpr inline bool isUInt<16>(uint64_t x) {
-  return static_cast<uint16_t>(x) == x;
-}
-template <> constexpr inline bool isUInt<32>(uint64_t x) {
-  return static_cast<uint32_t>(x) == x;
-}
-
-/// Checks if a unsigned integer is an N bit number shifted left by S.
-template <unsigned N, unsigned S>
-constexpr inline bool isShiftedUInt(uint64_t x) {
-  static_assert(
-      N > 0, "isShiftedUInt<0> doesn't make sense (refers to a 0-bit number)");
-  static_assert(N + S <= 64,
-                "isShiftedUInt<N, S> with N + S > 64 is too wide.");
-  // Per the two static_asserts above, S must be strictly less than 64.  So
-  // 1 << S is not undefined behavior.
-  return isUInt<N + S>(x) && (x % (UINT64_C(1) << S) == 0);
-}
-
-/// Gets the maximum value for a N-bit unsigned integer.
-inline uint64_t maxUIntN(uint64_t N) {
-  assert(N > 0 && N <= 64 && "integer width out of range");
-
-  // uint64_t(1) << 64 is undefined behavior, so we can't do
-  //   (uint64_t(1) << N) - 1
-  // without checking first that N != 64.  But this works and doesn't have a
-  // branch.
-  return UINT64_MAX >> (64 - N);
-}
-
-// Ignore the false warning "Arithmetic overflow" for MSVC
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4146)
-#endif
-
-/// Gets the minimum value for a N-bit signed integer.
-inline int64_t minIntN(int64_t N) {
-  assert(N > 0 && N <= 64 && "integer width out of range");
-  // NOLINTNEXTLINE(*-narrowing-conversions)
-  return -(UINT64_C(1) << (N - 1));
-}
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-/// Gets the maximum value for a N-bit signed integer.
-inline int64_t maxIntN(int64_t N) {
-  assert(N > 0 && N <= 64 && "integer width out of range");
-
-  // This relies on two's complement wraparound when N == 64, so we convert to
-  // int64_t only at the very end to avoid UB.
-  // NOLINTNEXTLINE(*-narrowing-conversions)
-  return (UINT64_C(1) << (N - 1)) - 1;
-}
-
-/// Checks if an unsigned integer fits into the given (dynamic) bit width.
-inline bool isUIntN(unsigned N, uint64_t x) {
-  return N >= 64 || x <= maxUIntN(N);
-}
-
-/// Checks if an signed integer fits into the given (dynamic) bit width.
-inline bool isIntN(unsigned N, int64_t x) {
-  return N >= 64 || (minIntN(N) <= x && x <= maxIntN(N));
-}
-
-/// Return true if the argument is a non-empty sequence of ones starting at the
-/// least significant bit with the remainder zero (32 bit version).
-/// Ex. isMask_32(0x0000FFFFU) == true.
-constexpr inline bool isMask_32(uint32_t Value) {
-  return Value && ((Value + 1) & Value) == 0;
-}
-
-/// Return true if the argument is a non-empty sequence of ones starting at the
-/// least significant bit with the remainder zero (64 bit version).
-constexpr inline bool isMask_64(uint64_t Value) {
-  return Value && ((Value + 1) & Value) == 0;
-}
-
-/// Return true if the argument contains a non-empty sequence of ones with the
-/// remainder zero (32 bit version.) Ex. isShiftedMask_32(0x0000FF00U) == true.
-constexpr inline bool isShiftedMask_32(uint32_t Value) {
-  return Value && isMask_32((Value - 1) | Value);
-}
-
-/// Return true if the argument contains a non-empty sequence of ones with the
-/// remainder zero (64 bit version.)
-constexpr inline bool isShiftedMask_64(uint64_t Value) {
-  return Value && isMask_64((Value - 1) | Value);
-}
-
-/// Return true if the argument is a power of two > 0.
-/// Ex. isPowerOf2_32(0x00100000U) == true (32 bit edition.)
-constexpr inline bool isPowerOf2_32(uint32_t Value) {
-  return Value && !(Value & (Value - 1));
-}
-
-/// Return true if the argument is a power of two > 0 (64 bit edition.)
-constexpr inline bool isPowerOf2_64(uint64_t Value) {
-  return Value && !(Value & (Value - 1));
-}
-
-/// Count the number of ones from the most significant bit to the first
-/// zero bit.
-///
-/// Ex. countLeadingOnes(0xFF0FFF00) == 8.
-/// Only unsigned integral types are allowed.
-///
-/// \param ZB the behavior on an input of all ones. Only ZB_Width and
-/// ZB_Undefined are valid arguments.
-template <typename T>
-std::size_t countLeadingOnes(T Value, ZeroBehavior ZB = ZB_Width) {
-  static_assert(std::numeric_limits<T>::is_integer &&
-                    !std::numeric_limits<T>::is_signed,
-                "Only unsigned integral types are allowed.");
-  return countLeadingZeros<T>(~Value, ZB);
-}
-
-/// Count the number of ones from the least significant bit to the first
-/// zero bit.
-///
-/// Ex. countTrailingOnes(0x00FF00FF) == 8.
-/// Only unsigned integral types are allowed.
-///
-/// \param ZB the behavior on an input of all ones. Only ZB_Width and
-/// ZB_Undefined are valid arguments.
-template <typename T>
-std::size_t countTrailingOnes(T Value, ZeroBehavior ZB = ZB_Width) {
-  static_assert(std::numeric_limits<T>::is_integer &&
-                    !std::numeric_limits<T>::is_signed,
-                "Only unsigned integral types are allowed.");
-  return countTrailingZeros<T>(~Value, ZB);
-}
-
-namespace detail {
-template <typename T, std::size_t SizeOfT> struct PopulationCounter {
-  static unsigned count(T Value) {
-    // Generic version, forward to 32 bits.
-    static_assert(SizeOfT <= 4, "Not implemented!");
-#if defined(__GNUC__) && __GNUC__ >= 4
-    return __builtin_popcount(Value);
-#else
-    uint32_t v = Value;
-    v = v - ((v >> 1) & 0x55555555);
-    v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
-    return ((v + (v >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
-#endif
-  }
-};
-
-template <typename T> struct PopulationCounter<T, 8> {
-  static unsigned count(T Value) {
-#if defined(__GNUC__) && __GNUC__ >= 4
-    return __builtin_popcountll(Value);
-#else
-    uint64_t v = Value;
-    v = v - ((v >> 1) & 0x5555555555555555ULL);
-    v = (v & 0x3333333333333333ULL) + ((v >> 2) & 0x3333333333333333ULL);
-    v = (v + (v >> 4)) & 0x0F0F0F0F0F0F0F0FULL;
-    return unsigned((uint64_t)(v * 0x0101010101010101ULL) >> 56);
-#endif
-  }
-};
-} // namespace detail
-
-/// Count the number of set bits in a value.
-/// Ex. countPopulation(0xF000F000) = 8
-/// Returns 0 if the word is zero.
-template <typename T> inline unsigned countPopulation(T Value) {
-  static_assert(std::numeric_limits<T>::is_integer &&
-                    !std::numeric_limits<T>::is_signed,
-                "Only unsigned integral types are allowed.");
-  return detail::PopulationCounter<T, sizeof(T)>::count(Value);
-}
-
-/// Return the log base 2 of the specified value.
-inline double Log2(double Value) {
-#if defined(__ANDROID_API__) && __ANDROID_API__ < 18
-  return __builtin_log(Value) / __builtin_log(2.0);
-#else
-  return log2(Value);
-#endif
-}
-
-/// Return the floor log base 2 of the specified value, -1 if the value is zero.
-/// (32 bit edition.)
-/// Ex. Log2_32(32) == 5, Log2_32(1) == 0, Log2_32(0) == -1, Log2_32(6) == 2
-inline unsigned Log2_32(uint32_t Value) {
-  return static_cast<unsigned>(31 - countLeadingZeros(Value));
-}
-
-/// Return the floor log base 2 of the specified value, -1 if the value is zero.
-/// (64 bit edition.)
-inline unsigned Log2_64(uint64_t Value) {
-  return static_cast<unsigned>(63 - countLeadingZeros(Value));
-}
-
-/// Return the ceil log base 2 of the specified value, 32 if the value is zero.
-/// (32 bit edition).
-/// Ex. Log2_32_Ceil(32) == 5, Log2_32_Ceil(1) == 0, Log2_32_Ceil(6) == 3
-inline unsigned Log2_32_Ceil(uint32_t Value) {
-  return static_cast<unsigned>(32 - countLeadingZeros(Value - 1));
-}
-
-/// Return the ceil log base 2 of the specified value, 64 if the value is zero.
-/// (64 bit edition.)
-inline unsigned Log2_64_Ceil(uint64_t Value) {
-  return static_cast<unsigned>(64 - countLeadingZeros(Value - 1));
-}
-
-/// Return the greatest common divisor of the values using Euclid's algorithm.
-inline uint64_t GreatestCommonDivisor64(uint64_t A, uint64_t B) {
-  while (B) {
-    uint64_t T = B;
-    B = A % B;
-    A = T;
-  }
-  return A;
-}
-
-/// This function takes a 64-bit integer and returns the bit equivalent double.
-inline double BitsToDouble(uint64_t Bits) {
-  double D = 0;
-  static_assert(sizeof(uint64_t) == sizeof(double), "Unexpected type sizes");
-  memcpy(&D, &Bits, sizeof(Bits));
-  return D;
-}
-
-/// This function takes a 32-bit integer and returns the bit equivalent float.
-inline float BitsToFloat(uint32_t Bits) {
-  // TODO: Use std::bit_cast once C++20 becomes available.
-  return c10::bit_cast<float>(Bits);
-}
-
-/// This function takes a double and returns the bit equivalent 64-bit integer.
-/// Note that copying doubles around changes the bits of NaNs on some hosts,
-/// notably x86, so this routine cannot be used if these bits are needed.
-inline uint64_t DoubleToBits(double Double) {
-  // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
-  uint64_t Bits;
-  static_assert(sizeof(uint64_t) == sizeof(double), "Unexpected type sizes");
-  memcpy(&Bits, &Double, sizeof(Double));
-  return Bits;
-}
-
-/// This function takes a float and returns the bit equivalent 32-bit integer.
-/// Note that copying floats around changes the bits of NaNs on some hosts,
-/// notably x86, so this routine cannot be used if these bits are needed.
-inline uint32_t FloatToBits(float Float) {
-  // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
-  uint32_t Bits;
-  static_assert(sizeof(uint32_t) == sizeof(float), "Unexpected type sizes");
-  memcpy(&Bits, &Float, sizeof(Float));
-  return Bits;
-}
-
-/// A and B are either alignments or offsets. Return the minimum alignment that
-/// may be assumed after adding the two together.
-constexpr inline uint64_t MinAlign(uint64_t A, uint64_t B) {
-  // The largest power of 2 that divides both A and B.
-  //
-  // Replace "-Value" by "1+~Value" in the following commented code to avoid
-  // MSVC warning C4146
-  //    return (A | B) & -(A | B);
-  return (A | B) & (1 + ~(A | B));
-}
-
-/// Aligns \c Addr to \c Alignment bytes, rounding up.
-///
-/// Alignment should be a power of two.  This method rounds up, so
-/// alignAddr(7, 4) == 8 and alignAddr(8, 4) == 8.
-inline uintptr_t alignAddr(const void *Addr, size_t Alignment) {
-  assert(Alignment && isPowerOf2_64((uint64_t)Alignment) &&
-         "Alignment is not a power of two!");
-
-  assert((uintptr_t)Addr + Alignment - 1 >= (uintptr_t)Addr);
-
-  return (((uintptr_t)Addr + Alignment - 1) & ~(uintptr_t)(Alignment - 1));
-}
-
-/// Returns the necessary adjustment for aligning \c Ptr to \c Alignment
-/// bytes, rounding up.
-inline size_t alignmentAdjustment(const void *Ptr, size_t Alignment) {
-  return alignAddr(Ptr, Alignment) - (uintptr_t)Ptr;
-}
-
-/// Returns the next power of two (in 64-bits) that is strictly greater than A.
-/// Returns zero on overflow.
-inline uint64_t NextPowerOf2(uint64_t A) {
-  A |= (A >> 1);
-  A |= (A >> 2);
-  A |= (A >> 4);
-  A |= (A >> 8);
-  A |= (A >> 16);
-  A |= (A >> 32);
-  return A + 1;
-}
-
-/// Returns the power of two which is less than or equal to the given value.
-/// Essentially, it is a floor operation across the domain of powers of two.
-inline uint64_t PowerOf2Floor(uint64_t A) {
-  if (!A)
-    return 0;
-  return 1ull << (63 - countLeadingZeros(A, ZB_Undefined));
-}
-
-/// Returns the power of two which is greater than or equal to the given value.
-/// Essentially, it is a ceil operation across the domain of powers of two.
-inline uint64_t PowerOf2Ceil(uint64_t A) {
-  if (!A)
-    return 0;
-  return NextPowerOf2(A - 1);
-}
-
-/// Returns the next integer (mod 2**64) that is greater than or equal to
-/// \p Value and is a multiple of \p Align. \p Align must be non-zero.
-///
-/// If non-zero \p Skew is specified, the return value will be a minimal
-/// integer that is greater than or equal to \p Value and equal to
-/// \p Align * N + \p Skew for some integer N. If \p Skew is larger than
-/// \p Align, its value is adjusted to '\p Skew mod \p Align'.
-///
-/// Examples:
-/// \code
-///   alignTo(5, 8) = 8
-///   alignTo(17, 8) = 24
-///   alignTo(~0LL, 8) = 0
-///   alignTo(321, 255) = 510
-///
-///   alignTo(5, 8, 7) = 7
-///   alignTo(17, 8, 1) = 17
-///   alignTo(~0LL, 8, 3) = 3
-///   alignTo(321, 255, 42) = 552
-/// \endcode
-inline uint64_t alignTo(uint64_t Value, uint64_t Align, uint64_t Skew = 0) {
-  assert(Align != 0u && "Align can't be 0.");
-  Skew %= Align;
-  return (Value + Align - 1 - Skew) / Align * Align + Skew;
-}
-
-/// Returns the next integer (mod 2**64) that is greater than or equal to
-/// \p Value and is a multiple of \c Align. \c Align must be non-zero.
-template <uint64_t Align> constexpr inline uint64_t alignTo(uint64_t Value) {
-  static_assert(Align != 0u, "Align must be non-zero");
-  return (Value + Align - 1) / Align * Align;
-}
-
-/// Returns the integer ceil(Numerator / Denominator).
-inline uint64_t divideCeil(uint64_t Numerator, uint64_t Denominator) {
-  return alignTo(Numerator, Denominator) / Denominator;
-}
-
-/// \c alignTo for contexts where a constant expression is required.
-/// \sa alignTo
-///
-/// \todo FIXME: remove when \c constexpr becomes really \c constexpr
-template <uint64_t Align> struct AlignTo {
-  static_assert(Align != 0u, "Align must be non-zero");
-  template <uint64_t Value> struct from_value {
-    static const uint64_t value = (Value + Align - 1) / Align * Align;
-  };
-};
-
-/// Returns the largest uint64_t less than or equal to \p Value and is
-/// \p Skew mod \p Align. \p Align must be non-zero
-inline uint64_t alignDown(uint64_t Value, uint64_t Align, uint64_t Skew = 0) {
-  assert(Align != 0u && "Align can't be 0.");
-  Skew %= Align;
-  return (Value - Skew) / Align * Align + Skew;
-}
-
-/// Returns the offset to the next integer (mod 2**64) that is greater than
-/// or equal to \p Value and is a multiple of \p Align. \p Align must be
-/// non-zero.
-inline uint64_t OffsetToAlignment(uint64_t Value, uint64_t Align) {
-  return alignTo(Value, Align) - Value;
-}
-
-/// Sign-extend the number in the bottom B bits of X to a 32-bit integer.
-/// Requires 0 < B <= 32.
-template <unsigned B> constexpr inline int32_t SignExtend32(uint32_t X) {
-  static_assert(B > 0, "Bit width can't be 0.");
-  static_assert(B <= 32, "Bit width out of range.");
-  return int32_t(X << (32 - B)) >> (32 - B);
-}
-
-/// Sign-extend the number in the bottom B bits of X to a 32-bit integer.
-/// Requires 0 < B < 32.
-inline int32_t SignExtend32(uint32_t X, unsigned B) {
-  assert(B > 0 && "Bit width can't be 0.");
-  assert(B <= 32 && "Bit width out of range.");
-  return int32_t(X << (32 - B)) >> (32 - B);
-}
-
-/// Sign-extend the number in the bottom B bits of X to a 64-bit integer.
-/// Requires 0 < B < 64.
-template <unsigned B> constexpr inline int64_t SignExtend64(uint64_t x) {
-  static_assert(B > 0, "Bit width can't be 0.");
-  static_assert(B <= 64, "Bit width out of range.");
-  return int64_t(x << (64 - B)) >> (64 - B);
-}
-
-/// Sign-extend the number in the bottom B bits of X to a 64-bit integer.
-/// Requires 0 < B < 64.
-inline int64_t SignExtend64(uint64_t X, unsigned B) {
-  assert(B > 0 && "Bit width can't be 0.");
-  assert(B <= 64 && "Bit width out of range.");
-  return int64_t(X << (64 - B)) >> (64 - B);
-}
-
-/// Subtract two unsigned integers, X and Y, of type T and return the absolute
-/// value of the result.
-template <typename T>
-std::enable_if_t<std::is_unsigned_v<T>, T> AbsoluteDifference(T X, T Y) {
-  return std::max(X, Y) - std::min(X, Y);
-}
-
-/// Add two unsigned integers, X and Y, of type T.  Clamp the result to the
-/// maximum representable value of T on overflow.  ResultOverflowed indicates if
-/// the result is larger than the maximum representable value of type T.
-template <typename T>
-std::enable_if_t<std::is_unsigned_v<T>, T>
-SaturatingAdd(T X, T Y, bool *ResultOverflowed = nullptr) {
-  // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
-  bool Dummy;
-  bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
-  // Hacker's Delight, p. 29
-  T Z = X + Y;
-  Overflowed = (Z < X || Z < Y);
-  if (Overflowed)
-    return std::numeric_limits<T>::max();
-  else
-    return Z;
-}
-
-/// Multiply two unsigned integers, X and Y, of type T.  Clamp the result to the
-/// maximum representable value of T on overflow.  ResultOverflowed indicates if
-/// the result is larger than the maximum representable value of type T.
-template <typename T>
-std::enable_if_t<std::is_unsigned_v<T>, T>
-SaturatingMultiply(T X, T Y, bool *ResultOverflowed = nullptr) {
-  // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
-  bool Dummy;
-  bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
-
-  // Hacker's Delight, p. 30 has a different algorithm, but we don't use that
-  // because it fails for uint16_t (where multiplication can have undefined
-  // behavior due to promotion to int), and requires a division in addition
-  // to the multiplication.
-
-  Overflowed = false;
-
-  // Log2(Z) would be either Log2Z or Log2Z + 1.
-  // Special case: if X or Y is 0, Log2_64 gives -1, and Log2Z
-  // will necessarily be less than Log2Max as desired.
-  int Log2Z = Log2_64(X) + Log2_64(Y);
-  const T Max = std::numeric_limits<T>::max();
-  int Log2Max = Log2_64(Max);
-  if (Log2Z < Log2Max) {
-    return X * Y;
-  }
-  if (Log2Z > Log2Max) {
-    Overflowed = true;
-    return Max;
-  }
-
-  // We're going to use the top bit, and maybe overflow one
-  // bit past it. Multiply all but the bottom bit then add
-  // that on at the end.
-  T Z = (X >> 1) * Y;
-  if (Z & ~(Max >> 1)) {
-    Overflowed = true;
-    return Max;
-  }
-  Z <<= 1;
-  if (X & 1)
-    return SaturatingAdd(Z, Y, ResultOverflowed);
-
-  return Z;
-}
-
-/// Multiply two unsigned integers, X and Y, and add the unsigned integer, A to
-/// the product. Clamp the result to the maximum representable value of T on
-/// overflow. ResultOverflowed indicates if the result is larger than the
-/// maximum representable value of type T.
-template <typename T>
-std::enable_if_t<std::is_unsigned_v<T>, T>
-SaturatingMultiplyAdd(T X, T Y, T A, bool *ResultOverflowed = nullptr) {
-  // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
-  bool Dummy;
-  bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
-
-  T Product = SaturatingMultiply(X, Y, &Overflowed);
-  if (Overflowed)
-    return Product;
-
-  return SaturatingAdd(A, Product, &Overflowed);
-}
-
-/// Use this rather than HUGE_VALF; the latter causes warnings on MSVC.
-extern const float huge_valf;
-} // namespace c10::llvm
diff --git a/packages/react-native-executorch/third-party/include/c10/util/overflows.h b/packages/react-native-executorch/third-party/include/c10/util/overflows.h
deleted file mode 100644
index a54dc969d6..0000000000
--- a/packages/react-native-executorch/third-party/include/c10/util/overflows.h
+++ /dev/null
@@ -1,95 +0,0 @@
-#pragma once
-
-#include <c10/macros/Macros.h>
-#include <c10/util/TypeSafeSignMath.h>
-#include <c10/util/complex.h>
-
-#include <cmath>
-#include <limits>
-#include <type_traits>
-
-namespace c10 {
-// In some versions of MSVC, there will be a compiler error when building.
-// C4146: unary minus operator applied to unsigned type, result still unsigned
-// C4804: unsafe use of type 'bool' in operation
-// It can be addressed by disabling the following warning.
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4146)
-#pragma warning(disable : 4804)
-#pragma warning(disable : 4018)
-#endif
-
-// The overflow checks may involve float to int conversion which may
-// trigger precision loss warning. Re-enable the warning once the code
-// is fixed. See T58053069.
-C10_CLANG_DIAGNOSTIC_PUSH()
-#if C10_CLANG_HAS_WARNING("-Wimplicit-float-conversion")
-C10_CLANG_DIAGNOSTIC_IGNORE("-Wimplicit-float-conversion")
-#endif
-
-// bool can be converted to any type.
-// Without specializing on bool, in pytorch_linux_trusty_py2_7_9_build:
-// `error: comparison of constant '255' with boolean expression is always false`
-// for `f > limit::max()` below
-template <typename To, typename From>
-std::enable_if_t<std::is_same_v<From, bool>, bool>
-overflows(From /*f*/, bool strict_unsigned [[maybe_unused]] = false) {
-  return false;
-}
-
-// skip isnan and isinf check for integral types
-template <typename To, typename From>
-std::enable_if_t<std::is_integral_v<From> && !std::is_same_v<From, bool>, bool>
-overflows(From f, bool strict_unsigned = false) {
-  using limit = std::numeric_limits<typename scalar_value_type<To>::type>;
-  if constexpr (!limit::is_signed && std::numeric_limits<From>::is_signed) {
-    // allow for negative numbers to wrap using two's complement arithmetic.
-    // For example, with uint8, this allows for `a - b` to be treated as
-    // `a + 255 * b`.
-    if (!strict_unsigned) {
-      return greater_than_max<To>(f) ||
-             (c10::is_negative(f) &&
-              -static_cast<uint64_t>(f) > static_cast<uint64_t>(limit::max()));
-    }
-  }
-  return c10::less_than_lowest<To>(f) || greater_than_max<To>(f);
-}
-
-template <typename To, typename From>
-std::enable_if_t<std::is_floating_point_v<From>, bool>
-overflows(From f, bool strict_unsigned [[maybe_unused]] = false) {
-  using limit = std::numeric_limits<typename scalar_value_type<To>::type>;
-  if (limit::has_infinity && std::isinf(static_cast<double>(f))) {
-    return false;
-  }
-  if (!limit::has_quiet_NaN && (f != f)) {
-    return true;
-  }
-  return f < limit::lowest() || f > limit::max();
-}
-
-C10_CLANG_DIAGNOSTIC_POP()
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-template <typename To, typename From>
-std::enable_if_t<is_complex<From>::value, bool>
-overflows(From f, bool strict_unsigned = false) {
-  // casts from complex to real are considered to overflow if the
-  // imaginary component is non-zero
-  if (!is_complex<To>::value && f.imag() != 0) {
-    return true;
-  }
-  // Check for overflow componentwise
-  // (Technically, the imag overflow check is guaranteed to be false
-  // when !is_complex<To>, but any optimizer worth its salt will be
-  // able to figure it out.)
-  return overflows<typename scalar_value_type<To>::type,
-                   typename From::value_type>(f.real(), strict_unsigned) ||
-         overflows<typename scalar_value_type<To>::type,
-                   typename From::value_type>(f.imag(), strict_unsigned);
-}
-} // namespace c10
diff --git a/packages/react-native-executorch/third-party/include/c10/util/safe_numerics.h b/packages/react-native-executorch/third-party/include/c10/util/safe_numerics.h
deleted file mode 100644
index 60723db155..0000000000
--- a/packages/react-native-executorch/third-party/include/c10/util/safe_numerics.h
+++ /dev/null
@@ -1,113 +0,0 @@
-#pragma once
-#include <c10/macros/Macros.h>
-
-#include <cstddef>
-#include <cstdint>
-#include <type_traits>
-
-// GCC has __builtin_mul_overflow from before it supported __has_builtin
-#ifdef _MSC_VER
-#define C10_HAS_BUILTIN_OVERFLOW() (0)
-#include <c10/util/llvmMathExtras.h>
-#include <intrin.h>
-#else
-#define C10_HAS_BUILTIN_OVERFLOW() (1)
-#endif
-
-namespace c10 {
-
-template <typename T, typename std::enable_if_t<std::is_integral_v<T>, int> = 0>
-C10_ALWAYS_INLINE bool add_overflows(T a, T b, T *out) {
-#if C10_HAS_BUILTIN_OVERFLOW()
-  return __builtin_add_overflow(a, b, out);
-#else
-  if constexpr (std::is_signed_v<T>) {
-    // For signed types, detect overflow by checking sign changes
-    volatile T tmp = a + b;
-    *out = tmp;
-
-    // If both operands have the same sign, check if result changed sign
-    // unexpectedly.
-    if ((a > 0) == (b > 0)) {
-      if ((a > 0) && (tmp <= 0)) {
-        return true; // Positive overflow
-      }
-      if ((a < 0) && (tmp >= 0)) {
-        return true; // Negative overflow
-      }
-    }
-    return false;
-  } else {
-    // For unsigned types, overflow causes wrap-around
-    volatile T tmp = a + b;
-    *out = tmp;
-    return (tmp < a || tmp < b);
-  }
-#endif
-}
-
-C10_ALWAYS_INLINE bool add_overflows(uint64_t a, uint64_t b, uint64_t *out) {
-  return add_overflows<uint64_t>(a, b, out);
-}
-
-template <typename T, typename std::enable_if_t<std::is_integral_v<T>, int> = 0>
-C10_ALWAYS_INLINE bool mul_overflows(T a, T b, T *out) {
-#if C10_HAS_BUILTIN_OVERFLOW()
-  return __builtin_mul_overflow(a, b, out);
-#else
-  if constexpr (std::is_signed_v<T>) {
-    // For signed types, use the division-based check
-    volatile T tmp = a * b;
-    *out = tmp;
-    if (a == 0 || b == 0) {
-      return false;
-    }
-    return !(a == tmp / b);
-  } else {
-    // For unsigned types, use leading zeros approach
-    // This test isn't exact, but avoids doing integer division
-    *out = a * b;
-    constexpr int bits = sizeof(T) * 8;
-    return ((c10::llvm::countLeadingZeros(a) +
-             c10::llvm::countLeadingZeros(b)) < bits);
-  }
-#endif
-}
-
-C10_ALWAYS_INLINE bool mul_overflows(uint64_t a, uint64_t b, uint64_t *out) {
-  return mul_overflows<uint64_t>(a, b, out);
-}
-
-template <typename It>
-bool safe_multiplies_u64(It first, It last, uint64_t *out) {
-#if C10_HAS_BUILTIN_OVERFLOW()
-  uint64_t prod = 1;
-  bool overflow = false;
-  for (; first != last; ++first) {
-    overflow |= c10::mul_overflows(prod, *first, &prod);
-  }
-  *out = prod;
-  return overflow;
-#else
-  uint64_t prod = 1;
-  uint64_t prod_log2 = 0;
-  bool is_zero = false;
-  for (; first != last; ++first) {
-    auto x = static_cast<uint64_t>(*first);
-    prod *= x;
-    // log2(0) isn't valid, so need to track it specially
-    is_zero |= (x == 0);
-    prod_log2 += c10::llvm::Log2_64_Ceil(x);
-  }
-  *out = prod;
-  // This test isn't exact, but avoids doing integer division
-  return !is_zero && (prod_log2 >= 64);
-#endif
-}
-
-template <typename Container>
-bool safe_multiplies_u64(const Container &c, uint64_t *out) {
-  return safe_multiplies_u64(c.begin(), c.end(), out);
-}
-
-} // namespace c10
diff --git a/packages/react-native-executorch/third-party/include/cpuinfo/cpuinfo.h b/packages/react-native-executorch/third-party/include/cpuinfo/cpuinfo.h
deleted file mode 100644
index 5efecb3a7d..0000000000
--- a/packages/react-native-executorch/third-party/include/cpuinfo/cpuinfo.h
+++ /dev/null
@@ -1,2363 +0,0 @@
-#pragma once
-#ifndef CPUINFO_H
-#define CPUINFO_H
-
-#ifndef __cplusplus
-#include <stdbool.h>
-#endif
-
-#ifdef __APPLE__
-#include <TargetConditionals.h>
-#endif
-
-#include <stdint.h>
-
-/* Identify architecture and define corresponding macro */
-
-#if defined(__i386__) || defined(__i486__) || defined(__i586__) ||             \
-    defined(__i686__) || defined(_M_IX86)
-#define CPUINFO_ARCH_X86 1
-#endif
-
-#if defined(__x86_64__) || defined(__x86_64) || defined(_M_X64) ||             \
-    defined(_M_AMD64)
-#define CPUINFO_ARCH_X86_64 1
-#endif
-
-#if defined(__arm__) || defined(_M_ARM)
-#define CPUINFO_ARCH_ARM 1
-#endif
-
-#if defined(__aarch64__) || defined(_M_ARM64)
-#define CPUINFO_ARCH_ARM64 1
-#endif
-
-#if defined(__PPC64__) || defined(__powerpc64__) || defined(_ARCH_PPC64)
-#define CPUINFO_ARCH_PPC64 1
-#endif
-
-#if defined(__asmjs__)
-#define CPUINFO_ARCH_ASMJS 1
-#endif
-
-#if defined(__wasm__)
-#if defined(__wasm_simd128__)
-#define CPUINFO_ARCH_WASMSIMD 1
-#else
-#define CPUINFO_ARCH_WASM 1
-#endif
-#endif
-
-#if defined(__riscv)
-#if (__riscv_xlen == 32)
-#define CPUINFO_ARCH_RISCV32 1
-#elif (__riscv_xlen == 64)
-#define CPUINFO_ARCH_RISCV64 1
-#endif
-#endif
-
-/* Define other architecture-specific macros as 0 */
-
-#ifndef CPUINFO_ARCH_X86
-#define CPUINFO_ARCH_X86 0
-#endif
-
-#ifndef CPUINFO_ARCH_X86_64
-#define CPUINFO_ARCH_X86_64 0
-#endif
-
-#ifndef CPUINFO_ARCH_ARM
-#define CPUINFO_ARCH_ARM 0
-#endif
-
-#ifndef CPUINFO_ARCH_ARM64
-#define CPUINFO_ARCH_ARM64 0
-#endif
-
-#ifndef CPUINFO_ARCH_PPC64
-#define CPUINFO_ARCH_PPC64 0
-#endif
-
-#ifndef CPUINFO_ARCH_ASMJS
-#define CPUINFO_ARCH_ASMJS 0
-#endif
-
-#ifndef CPUINFO_ARCH_WASM
-#define CPUINFO_ARCH_WASM 0
-#endif
-
-#ifndef CPUINFO_ARCH_WASMSIMD
-#define CPUINFO_ARCH_WASMSIMD 0
-#endif
-
-#ifndef CPUINFO_ARCH_RISCV32
-#define CPUINFO_ARCH_RISCV32 0
-#endif
-
-#ifndef CPUINFO_ARCH_RISCV64
-#define CPUINFO_ARCH_RISCV64 0
-#endif
-
-#if CPUINFO_ARCH_X86 && defined(_MSC_VER)
-#define CPUINFO_ABI __cdecl
-#elif CPUINFO_ARCH_X86 && defined(__GNUC__)
-#define CPUINFO_ABI __attribute__((__cdecl__))
-#else
-#define CPUINFO_ABI
-#endif
-
-#define CPUINFO_CACHE_UNIFIED 0x00000001
-#define CPUINFO_CACHE_INCLUSIVE 0x00000002
-#define CPUINFO_CACHE_COMPLEX_INDEXING 0x00000004
-
-struct cpuinfo_cache {
-  /** Cache size in bytes */
-  uint32_t size;
-  /** Number of ways of associativity */
-  uint32_t associativity;
-  /** Number of sets */
-  uint32_t sets;
-  /** Number of partitions */
-  uint32_t partitions;
-  /** Line size in bytes */
-  uint32_t line_size;
-  /**
-   * Binary characteristics of the cache (unified cache, inclusive cache,
-   * cache with complex indexing).
-   *
-   * @see CPUINFO_CACHE_UNIFIED, CPUINFO_CACHE_INCLUSIVE,
-   * CPUINFO_CACHE_COMPLEX_INDEXING
-   */
-  uint32_t flags;
-  /** Index of the first logical processor that shares this cache */
-  uint32_t processor_start;
-  /** Number of logical processors that share this cache */
-  uint32_t processor_count;
-};
-
-struct cpuinfo_trace_cache {
-  uint32_t uops;
-  uint32_t associativity;
-};
-
-#define CPUINFO_PAGE_SIZE_4KB 0x1000
-#define CPUINFO_PAGE_SIZE_1MB 0x100000
-#define CPUINFO_PAGE_SIZE_2MB 0x200000
-#define CPUINFO_PAGE_SIZE_4MB 0x400000
-#define CPUINFO_PAGE_SIZE_16MB 0x1000000
-#define CPUINFO_PAGE_SIZE_1GB 0x40000000
-
-struct cpuinfo_tlb {
-  uint32_t entries;
-  uint32_t associativity;
-  uint64_t pages;
-};
-
-/** Vendor of processor core design */
-enum cpuinfo_vendor {
-  /** Processor vendor is not known to the library, or the library failed
-     to get vendor information from the OS. */
-  cpuinfo_vendor_unknown = 0,
-
-  /* Active vendors of modern CPUs */
-
-  /**
-   * Intel Corporation. Vendor of x86, x86-64, IA64, and ARM processor
-   * microarchitectures.
-   *
-   * Sold its ARM design subsidiary in 2006. The last ARM processor design
-   * was released in 2004.
-   */
-  cpuinfo_vendor_intel = 1,
-  /** Advanced Micro Devices, Inc. Vendor of x86 and x86-64 processor
-     microarchitectures. */
-  cpuinfo_vendor_amd = 2,
-  /** ARM Holdings plc. Vendor of ARM and ARM64 processor
-     microarchitectures. */
-  cpuinfo_vendor_arm = 3,
-  /** Qualcomm Incorporated. Vendor of ARM and ARM64 processor
-     microarchitectures. */
-  cpuinfo_vendor_qualcomm = 4,
-  /** Apple Inc. Vendor of ARM and ARM64 processor microarchitectures. */
-  cpuinfo_vendor_apple = 5,
-  /** Samsung Electronics Co., Ltd. Vendir if ARM64 processor
-     microarchitectures. */
-  cpuinfo_vendor_samsung = 6,
-  /** Nvidia Corporation. Vendor of ARM64-compatible processor
-     microarchitectures. */
-  cpuinfo_vendor_nvidia = 7,
-  /** MIPS Technologies, Inc. Vendor of MIPS processor microarchitectures.
-   */
-  cpuinfo_vendor_mips = 8,
-  /** International Business Machines Corporation. Vendor of PowerPC
-     processor microarchitectures. */
-  cpuinfo_vendor_ibm = 9,
-  /** Ingenic Semiconductor. Vendor of MIPS processor microarchitectures.
-   */
-  cpuinfo_vendor_ingenic = 10,
-  /**
-   * VIA Technologies, Inc. Vendor of x86 and x86-64 processor
-   * microarchitectures.
-   *
-   * Processors are designed by Centaur Technology, a subsidiary of VIA
-   * Technologies.
-   */
-  cpuinfo_vendor_via = 11,
-  /** Cavium, Inc. Vendor of ARM64 processor microarchitectures. */
-  cpuinfo_vendor_cavium = 12,
-  /** Broadcom, Inc. Vendor of ARM processor microarchitectures. */
-  cpuinfo_vendor_broadcom = 13,
-  /** Applied Micro Circuits Corporation (APM). Vendor of ARM64 processor
-     microarchitectures. */
-  cpuinfo_vendor_apm = 14,
-  /**
-   * Huawei Technologies Co., Ltd. Vendor of ARM64 processor
-   * microarchitectures.
-   *
-   * Processors are designed by HiSilicon, a subsidiary of Huawei.
-   */
-  cpuinfo_vendor_huawei = 15,
-  /**
-   * Hygon (Chengdu Haiguang Integrated Circuit Design Co., Ltd), Vendor
-   * of x86-64 processor microarchitectures.
-   *
-   * Processors are variants of AMD cores.
-   */
-  cpuinfo_vendor_hygon = 16,
-  /** SiFive, Inc. Vendor of RISC-V processor microarchitectures. */
-  cpuinfo_vendor_sifive = 17,
-
-  /* Active vendors of embedded CPUs */
-
-  /** Texas Instruments Inc. Vendor of ARM processor microarchitectures.
-   */
-  cpuinfo_vendor_texas_instruments = 30,
-  /** Marvell Technology Group Ltd. Vendor of ARM processor
-   * microarchitectures.
-   */
-  cpuinfo_vendor_marvell = 31,
-  /** RDC Semiconductor Co., Ltd. Vendor of x86 processor
-     microarchitectures. */
-  cpuinfo_vendor_rdc = 32,
-  /** DM&P Electronics Inc. Vendor of x86 processor microarchitectures. */
-  cpuinfo_vendor_dmp = 33,
-  /** Motorola, Inc. Vendor of PowerPC and ARM processor
-     microarchitectures. */
-  cpuinfo_vendor_motorola = 34,
-
-  /* Defunct CPU vendors */
-
-  /**
-   * Transmeta Corporation. Vendor of x86 processor microarchitectures.
-   *
-   * Now defunct. The last processor design was released in 2004.
-   * Transmeta processors implemented VLIW ISA and used binary translation
-   * to execute x86 code.
-   */
-  cpuinfo_vendor_transmeta = 50,
-  /**
-   * Cyrix Corporation. Vendor of x86 processor microarchitectures.
-   *
-   * Now defunct. The last processor design was released in 1996.
-   */
-  cpuinfo_vendor_cyrix = 51,
-  /**
-   * Rise Technology. Vendor of x86 processor microarchitectures.
-   *
-   * Now defunct. The last processor design was released in 1999.
-   */
-  cpuinfo_vendor_rise = 52,
-  /**
-   * National Semiconductor. Vendor of x86 processor microarchitectures.
-   *
-   * Sold its x86 design subsidiary in 1999. The last processor design was
-   * released in 1998.
-   */
-  cpuinfo_vendor_nsc = 53,
-  /**
-   * Silicon Integrated Systems. Vendor of x86 processor
-   * microarchitectures.
-   *
-   * Sold its x86 design subsidiary in 2001. The last processor design was
-   * released in 2001.
-   */
-  cpuinfo_vendor_sis = 54,
-  /**
-   * NexGen. Vendor of x86 processor microarchitectures.
-   *
-   * Now defunct. The last processor design was released in 1994.
-   * NexGen designed the first x86 microarchitecture which decomposed x86
-   * instructions into simple microoperations.
-   */
-  cpuinfo_vendor_nexgen = 55,
-  /**
-   * United Microelectronics Corporation. Vendor of x86 processor
-   * microarchitectures.
-   *
-   * Ceased x86 in the early 1990s. The last processor design was released
-   * in 1991. Designed U5C and U5D processors. Both are 486 level.
-   */
-  cpuinfo_vendor_umc = 56,
-  /**
-   * Digital Equipment Corporation. Vendor of ARM processor
-   * microarchitecture.
-   *
-   * Sold its ARM designs in 1997. The last processor design was released
-   * in 1997.
-   */
-  cpuinfo_vendor_dec = 57,
-};
-
-/**
- * Processor microarchitecture
- *
- * Processors with different microarchitectures often have different instruction
- * performance characteristics, and may have dramatically different pipeline
- * organization.
- */
-enum cpuinfo_uarch {
-  /** Microarchitecture is unknown, or the library failed to get
-     information about the microarchitecture from OS */
-  cpuinfo_uarch_unknown = 0,
-
-  /** Pentium and Pentium MMX microarchitecture. */
-  cpuinfo_uarch_p5 = 0x00100100,
-  /** Intel Quark microarchitecture. */
-  cpuinfo_uarch_quark = 0x00100101,
-
-  /** Pentium Pro, Pentium II, and Pentium III. */
-  cpuinfo_uarch_p6 = 0x00100200,
-  /** Pentium M. */
-  cpuinfo_uarch_dothan = 0x00100201,
-  /** Intel Core microarchitecture. */
-  cpuinfo_uarch_yonah = 0x00100202,
-  /** Intel Core 2 microarchitecture on 65 nm process. */
-  cpuinfo_uarch_conroe = 0x00100203,
-  /** Intel Core 2 microarchitecture on 45 nm process. */
-  cpuinfo_uarch_penryn = 0x00100204,
-  /** Intel Nehalem and Westmere microarchitectures (Core i3/i5/i7 1st
-     gen). */
-  cpuinfo_uarch_nehalem = 0x00100205,
-  /** Intel Sandy Bridge microarchitecture (Core i3/i5/i7 2nd gen). */
-  cpuinfo_uarch_sandy_bridge = 0x00100206,
-  /** Intel Ivy Bridge microarchitecture (Core i3/i5/i7 3rd gen). */
-  cpuinfo_uarch_ivy_bridge = 0x00100207,
-  /** Intel Haswell microarchitecture (Core i3/i5/i7 4th gen). */
-  cpuinfo_uarch_haswell = 0x00100208,
-  /** Intel Broadwell microarchitecture. */
-  cpuinfo_uarch_broadwell = 0x00100209,
-  /** Intel Sky Lake microarchitecture (14 nm, including
-     Kaby/Coffee/Whiskey/Amber/Comet/Cascade/Cooper Lake). */
-  cpuinfo_uarch_sky_lake = 0x0010020A,
-  /** DEPRECATED (Intel Kaby Lake microarchitecture). */
-  cpuinfo_uarch_kaby_lake = 0x0010020A,
-  /** Intel Palm Cove microarchitecture (10 nm, Cannon Lake). */
-  cpuinfo_uarch_palm_cove = 0x0010020B,
-  /** Intel Sunny Cove microarchitecture (10 nm, Ice Lake). */
-  cpuinfo_uarch_sunny_cove = 0x0010020C,
-  /** Intel Willow Cove microarchitecture (10 nm, Tiger Lake). */
-  cpuinfo_uarch_willow_cove = 0x0010020D,
-
-  /** Pentium 4 with Willamette, Northwood, or Foster cores. */
-  cpuinfo_uarch_willamette = 0x00100300,
-  /** Pentium 4 with Prescott and later cores. */
-  cpuinfo_uarch_prescott = 0x00100301,
-
-  /** Intel Atom on 45 nm process. */
-  cpuinfo_uarch_bonnell = 0x00100400,
-  /** Intel Atom on 32 nm process. */
-  cpuinfo_uarch_saltwell = 0x00100401,
-  /** Intel Silvermont microarchitecture (22 nm out-of-order Atom). */
-  cpuinfo_uarch_silvermont = 0x00100402,
-  /** Intel Airmont microarchitecture (14 nm out-of-order Atom). */
-  cpuinfo_uarch_airmont = 0x00100403,
-  /** Intel Goldmont microarchitecture (Denverton, Apollo Lake). */
-  cpuinfo_uarch_goldmont = 0x00100404,
-  /** Intel Goldmont Plus microarchitecture (Gemini Lake). */
-  cpuinfo_uarch_goldmont_plus = 0x00100405,
-  /** Intel Airmont microarchitecture (10 nm out-of-order Atom). */
-  cpuinfo_uarch_tremont = 0x00100406,
-  /** Intel Gracemont microarchitecture (AlderLake N). */
-  cpuinfo_uarch_gracemont = 0x00100407,
-  /** Intel Crestmont microarchitecture (Sierra Forest). */
-  cpuinfo_uarch_crestmont = 0x00100408,
-  /** Intel Darkmont microarchitecture (e-core used in Clearwater Forest). */
-  cpuinfo_uarch_darkmont = 0x00100409,
-
-  /** Intel Knights Ferry HPC boards. */
-  cpuinfo_uarch_knights_ferry = 0x00100500,
-  /** Intel Knights Corner HPC boards (aka Xeon Phi). */
-  cpuinfo_uarch_knights_corner = 0x00100501,
-  /** Intel Knights Landing microarchitecture (second-gen MIC). */
-  cpuinfo_uarch_knights_landing = 0x00100502,
-  /** Intel Knights Hill microarchitecture (third-gen MIC). */
-  cpuinfo_uarch_knights_hill = 0x00100503,
-  /** Intel Knights Mill Xeon Phi. */
-  cpuinfo_uarch_knights_mill = 0x00100504,
-
-  /** Intel/Marvell XScale series. */
-  cpuinfo_uarch_xscale = 0x00100600,
-
-  /** AMD K5. */
-  cpuinfo_uarch_k5 = 0x00200100,
-  /** AMD K6 and alike. */
-  cpuinfo_uarch_k6 = 0x00200101,
-  /** AMD Athlon and Duron. */
-  cpuinfo_uarch_k7 = 0x00200102,
-  /** AMD Athlon 64, Opteron 64. */
-  cpuinfo_uarch_k8 = 0x00200103,
-  /** AMD Family 10h (Barcelona, Istambul, Magny-Cours). */
-  cpuinfo_uarch_k10 = 0x00200104,
-  /**
-   * AMD Bulldozer microarchitecture
-   * Zambezi FX-series CPUs, Zurich, Valencia and Interlagos Opteron CPUs.
-   */
-  cpuinfo_uarch_bulldozer = 0x00200105,
-  /**
-   * AMD Piledriver microarchitecture
-   * Vishera FX-series CPUs, Trinity and Richland APUs, Delhi, Seoul, Abu
-   * Dhabi Opteron CPUs.
-   */
-  cpuinfo_uarch_piledriver = 0x00200106,
-  /** AMD Steamroller microarchitecture (Kaveri APUs). */
-  cpuinfo_uarch_steamroller = 0x00200107,
-  /** AMD Excavator microarchitecture (Carizzo APUs). */
-  cpuinfo_uarch_excavator = 0x00200108,
-  /** AMD Zen microarchitecture (12/14 nm Ryzen and EPYC CPUs). */
-  cpuinfo_uarch_zen = 0x00200109,
-  /** AMD Zen 2 microarchitecture (7 nm Ryzen and EPYC CPUs). */
-  cpuinfo_uarch_zen2 = 0x0020010A,
-  /** AMD Zen 3 microarchitecture. */
-  cpuinfo_uarch_zen3 = 0x0020010B,
-  /** AMD Zen 4 microarchitecture. */
-  cpuinfo_uarch_zen4 = 0x0020010C,
-  /** AMD Zen 5 microarchitecture. */
-  cpuinfo_uarch_zen5 = 0x0020010D,
-
-  /** NSC Geode and AMD Geode GX and LX. */
-  cpuinfo_uarch_geode = 0x00200200,
-  /** AMD Bobcat mobile microarchitecture. */
-  cpuinfo_uarch_bobcat = 0x00200201,
-  /** AMD Jaguar mobile microarchitecture. */
-  cpuinfo_uarch_jaguar = 0x00200202,
-  /** AMD Puma mobile microarchitecture. */
-  cpuinfo_uarch_puma = 0x00200203,
-
-  /** ARM7 series. */
-  cpuinfo_uarch_arm7 = 0x00300100,
-  /** ARM9 series. */
-  cpuinfo_uarch_arm9 = 0x00300101,
-  /** ARM 1136, ARM 1156, ARM 1176, or ARM 11MPCore. */
-  cpuinfo_uarch_arm11 = 0x00300102,
-
-  /** ARM Cortex-A5. */
-  cpuinfo_uarch_cortex_a5 = 0x00300205,
-  /** ARM Cortex-A7. */
-  cpuinfo_uarch_cortex_a7 = 0x00300207,
-  /** ARM Cortex-A8. */
-  cpuinfo_uarch_cortex_a8 = 0x00300208,
-  /** ARM Cortex-A9. */
-  cpuinfo_uarch_cortex_a9 = 0x00300209,
-  /** ARM Cortex-A12. */
-  cpuinfo_uarch_cortex_a12 = 0x00300212,
-  /** ARM Cortex-A15. */
-  cpuinfo_uarch_cortex_a15 = 0x00300215,
-  /** ARM Cortex-A17. */
-  cpuinfo_uarch_cortex_a17 = 0x00300217,
-
-  /** ARM Cortex-A32. */
-  cpuinfo_uarch_cortex_a32 = 0x00300332,
-  /** ARM Cortex-A35. */
-  cpuinfo_uarch_cortex_a35 = 0x00300335,
-  /** ARM Cortex-A53. */
-  cpuinfo_uarch_cortex_a53 = 0x00300353,
-  /** ARM Cortex-A55 revision 0 (restricted dual-issue capabilities
-     compared to revision 1+). */
-  cpuinfo_uarch_cortex_a55r0 = 0x00300354,
-  /** ARM Cortex-A55. */
-  cpuinfo_uarch_cortex_a55 = 0x00300355,
-  /** ARM Cortex-A57. */
-  cpuinfo_uarch_cortex_a57 = 0x00300357,
-  /** ARM Cortex-A65. */
-  cpuinfo_uarch_cortex_a65 = 0x00300365,
-  /** ARM Cortex-A72. */
-  cpuinfo_uarch_cortex_a72 = 0x00300372,
-  /** ARM Cortex-A73. */
-  cpuinfo_uarch_cortex_a73 = 0x00300373,
-  /** ARM Cortex-A75. */
-  cpuinfo_uarch_cortex_a75 = 0x00300375,
-  /** ARM Cortex-A76. */
-  cpuinfo_uarch_cortex_a76 = 0x00300376,
-  /** ARM Cortex-A77. */
-  cpuinfo_uarch_cortex_a77 = 0x00300377,
-  /** ARM Cortex-A78. */
-  cpuinfo_uarch_cortex_a78 = 0x00300378,
-
-  /** ARM Neoverse N1. */
-  cpuinfo_uarch_neoverse_n1 = 0x00300400,
-  /** ARM Neoverse E1. */
-  cpuinfo_uarch_neoverse_e1 = 0x00300401,
-  /** ARM Neoverse V1. */
-  cpuinfo_uarch_neoverse_v1 = 0x00300402,
-  /** ARM Neoverse N2. */
-  cpuinfo_uarch_neoverse_n2 = 0x00300403,
-  /** ARM Neoverse V2. */
-  cpuinfo_uarch_neoverse_v2 = 0x00300404,
-
-  /** ARM Cortex-X1. */
-  cpuinfo_uarch_cortex_x1 = 0x00300501,
-  /** ARM Cortex-X2. */
-  cpuinfo_uarch_cortex_x2 = 0x00300502,
-  /** ARM Cortex-X3. */
-  cpuinfo_uarch_cortex_x3 = 0x00300503,
-  /** ARM Cortex-X4. */
-  cpuinfo_uarch_cortex_x4 = 0x00300504,
-
-  /** ARM Cortex-A510. */
-  cpuinfo_uarch_cortex_a510 = 0x00300551,
-  /** ARM Cortex-A520. */
-  cpuinfo_uarch_cortex_a520 = 0x00300552,
-  /** ARM Cortex-A710. */
-  cpuinfo_uarch_cortex_a710 = 0x00300571,
-  /** ARM Cortex-A715. */
-  cpuinfo_uarch_cortex_a715 = 0x00300572,
-  /** ARM Cortex-A720. */
-  cpuinfo_uarch_cortex_a720 = 0x00300573,
-
-  /** Qualcomm Scorpion. */
-  cpuinfo_uarch_scorpion = 0x00400100,
-  /** Qualcomm Krait. */
-  cpuinfo_uarch_krait = 0x00400101,
-  /** Qualcomm Kryo. */
-  cpuinfo_uarch_kryo = 0x00400102,
-  /** Qualcomm Falkor. */
-  cpuinfo_uarch_falkor = 0x00400103,
-  /** Qualcomm Saphira. */
-  cpuinfo_uarch_saphira = 0x00400104,
-  /** Qualcomm Oryon. */
-  cpuinfo_uarch_oryon = 0x00400105,
-
-  /** Nvidia Denver. */
-  cpuinfo_uarch_denver = 0x00500100,
-  /** Nvidia Denver 2. */
-  cpuinfo_uarch_denver2 = 0x00500101,
-  /** Nvidia Carmel. */
-  cpuinfo_uarch_carmel = 0x00500102,
-
-  /** Samsung Exynos M1 (Exynos 8890 big cores). */
-  cpuinfo_uarch_exynos_m1 = 0x00600100,
-  /** Samsung Exynos M2 (Exynos 8895 big cores). */
-  cpuinfo_uarch_exynos_m2 = 0x00600101,
-  /** Samsung Exynos M3 (Exynos 9810 big cores). */
-  cpuinfo_uarch_exynos_m3 = 0x00600102,
-  /** Samsung Exynos M4 (Exynos 9820 big cores). */
-  cpuinfo_uarch_exynos_m4 = 0x00600103,
-  /** Samsung Exynos M5 (Exynos 9830 big cores). */
-  cpuinfo_uarch_exynos_m5 = 0x00600104,
-
-  /* Deprecated synonym for Cortex-A76 */
-  cpuinfo_uarch_cortex_a76ae = 0x00300376,
-  /* Deprecated names for Exynos. */
-  cpuinfo_uarch_mongoose_m1 = 0x00600100,
-  cpuinfo_uarch_mongoose_m2 = 0x00600101,
-  cpuinfo_uarch_meerkat_m3 = 0x00600102,
-  cpuinfo_uarch_meerkat_m4 = 0x00600103,
-
-  /** Apple A6 and A6X processors. */
-  cpuinfo_uarch_swift = 0x00700100,
-  /** Apple A7 processor. */
-  cpuinfo_uarch_cyclone = 0x00700101,
-  /** Apple A8 and A8X processor. */
-  cpuinfo_uarch_typhoon = 0x00700102,
-  /** Apple A9 and A9X processor. */
-  cpuinfo_uarch_twister = 0x00700103,
-  /** Apple A10 and A10X processor. */
-  cpuinfo_uarch_hurricane = 0x00700104,
-  /** Apple A11 processor (big cores). */
-  cpuinfo_uarch_monsoon = 0x00700105,
-  /** Apple A11 processor (little cores). */
-  cpuinfo_uarch_mistral = 0x00700106,
-  /** Apple A12 processor (big cores). */
-  cpuinfo_uarch_vortex = 0x00700107,
-  /** Apple A12 processor (little cores). */
-  cpuinfo_uarch_tempest = 0x00700108,
-  /** Apple A13 processor (big cores). */
-  cpuinfo_uarch_lightning = 0x00700109,
-  /** Apple A13 processor (little cores). */
-  cpuinfo_uarch_thunder = 0x0070010A,
-  /** Apple A14 / M1 processor (big cores). */
-  cpuinfo_uarch_firestorm = 0x0070010B,
-  /** Apple A14 / M1 processor (little cores). */
-  cpuinfo_uarch_icestorm = 0x0070010C,
-  /** Apple A15 / M2 processor (big cores). */
-  cpuinfo_uarch_avalanche = 0x0070010D,
-  /** Apple A15 / M2 processor (little cores). */
-  cpuinfo_uarch_blizzard = 0x0070010E,
-  /** Apple A16 processor (big cores). */
-  cpuinfo_uarch_everest = 0x00700200,
-  /** Apple A16 processor (little cores). */
-  cpuinfo_uarch_sawtooth = 0x00700201,
-  /** Apple A17 processor (big cores). */
-  cpuinfo_uarch_coll_everest = 0x00700202,
-  /** Apple A17 processor (little cores). */
-  cpuinfo_uarch_coll_sawtooth = 0x00700203,
-  /** Apple A18 processor (big cores). */
-  cpuinfo_uarch_tupai_everest = 0x00700204,
-  /** Apple A18 processor (little cores). */
-  cpuinfo_uarch_tupai_sawtooth = 0x00700205,
-  /** Apple A18 pro processor (big cores). */
-  cpuinfo_uarch_tahiti_everest = 0x00700206,
-  /** Apple A18 pro processor (little cores). */
-  cpuinfo_uarch_tahiti_sawtooth = 0x00700207,
-
-  /** Cavium ThunderX. */
-  cpuinfo_uarch_thunderx = 0x00800100,
-  /** Cavium ThunderX2 (originally Broadcom Vulkan). */
-  cpuinfo_uarch_thunderx2 = 0x00800200,
-
-  /** Marvell PJ4. */
-  cpuinfo_uarch_pj4 = 0x00900100,
-
-  /** Broadcom Brahma B15. */
-  cpuinfo_uarch_brahma_b15 = 0x00A00100,
-  /** Broadcom Brahma B53. */
-  cpuinfo_uarch_brahma_b53 = 0x00A00101,
-
-  /** Applied Micro X-Gene. */
-  cpuinfo_uarch_xgene = 0x00B00100,
-
-  /* Hygon Dhyana (a modification of AMD Zen for Chinese market). */
-  cpuinfo_uarch_dhyana = 0x01000100,
-
-  /** HiSilicon TaiShan v110 (Huawei Kunpeng 920 series processors). */
-  cpuinfo_uarch_taishan_v110 = 0x00C00100,
-};
-
-struct cpuinfo_processor {
-  /** SMT (hyperthread) ID within a core */
-  uint32_t smt_id;
-  /** Core containing this logical processor */
-  const struct cpuinfo_core *core;
-  /** Cluster of cores containing this logical processor */
-  const struct cpuinfo_cluster *cluster;
-  /** Physical package containing this logical processor */
-  const struct cpuinfo_package *package;
-#if defined(__linux__)
-  /**
-   * Linux-specific ID for the logical processor:
-   * - Linux kernel exposes information about this logical processor in
-   * /sys/devices/system/cpu/cpu<linux_id>/
-   * - Bit <linux_id> in the cpu_set_t identifies this logical processor
-   */
-  int linux_id;
-#endif
-#if defined(_WIN32) || defined(__CYGWIN__)
-  /** Windows-specific ID for the group containing the logical processor.
-   */
-  uint16_t windows_group_id;
-  /**
-   * Windows-specific ID of the logical processor within its group:
-   * - Bit <windows_processor_id> in the KAFFINITY mask identifies this
-   * logical processor within its group.
-   */
-  uint16_t windows_processor_id;
-#endif
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  /** APIC ID (unique x86-specific ID of the logical processor) */
-  uint32_t apic_id;
-#endif
-  struct {
-    /** Level 1 instruction cache */
-    const struct cpuinfo_cache *l1i;
-    /** Level 1 data cache */
-    const struct cpuinfo_cache *l1d;
-    /** Level 2 unified or data cache */
-    const struct cpuinfo_cache *l2;
-    /** Level 3 unified or data cache */
-    const struct cpuinfo_cache *l3;
-    /** Level 4 unified or data cache */
-    const struct cpuinfo_cache *l4;
-  } cache;
-};
-
-struct cpuinfo_core {
-  /** Index of the first logical processor on this core. */
-  uint32_t processor_start;
-  /** Number of logical processors on this core */
-  uint32_t processor_count;
-  /** Core ID within a package */
-  uint32_t core_id;
-  /** Cluster containing this core */
-  const struct cpuinfo_cluster *cluster;
-  /** Physical package containing this core. */
-  const struct cpuinfo_package *package;
-  /** Vendor of the CPU microarchitecture for this core */
-  enum cpuinfo_vendor vendor;
-  /** CPU microarchitecture for this core */
-  enum cpuinfo_uarch uarch;
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  /** Value of CPUID leaf 1 EAX register for this core */
-  uint32_t cpuid;
-#elif CPUINFO_ARCH_ARM || CPUINFO_ARCH_ARM64
-  /** Value of Main ID Register (MIDR) for this core */
-  uint32_t midr;
-#endif
-  /** Clock rate (non-Turbo) of the core, in Hz */
-  uint64_t frequency;
-};
-
-struct cpuinfo_cluster {
-  /** Index of the first logical processor in the cluster */
-  uint32_t processor_start;
-  /** Number of logical processors in the cluster */
-  uint32_t processor_count;
-  /** Index of the first core in the cluster */
-  uint32_t core_start;
-  /** Number of cores on the cluster */
-  uint32_t core_count;
-  /** Cluster ID within a package */
-  uint32_t cluster_id;
-  /** Physical package containing the cluster */
-  const struct cpuinfo_package *package;
-  /** CPU microarchitecture vendor of the cores in the cluster */
-  enum cpuinfo_vendor vendor;
-  /** CPU microarchitecture of the cores in the cluster */
-  enum cpuinfo_uarch uarch;
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  /** Value of CPUID leaf 1 EAX register of the cores in the cluster */
-  uint32_t cpuid;
-#elif CPUINFO_ARCH_ARM || CPUINFO_ARCH_ARM64
-  /** Value of Main ID Register (MIDR) of the cores in the cluster */
-  uint32_t midr;
-#endif
-  /** Clock rate (non-Turbo) of the cores in the cluster, in Hz */
-  uint64_t frequency;
-};
-
-#define CPUINFO_PACKAGE_NAME_MAX 48
-
-struct cpuinfo_package {
-  /** SoC or processor chip model name */
-  char name[CPUINFO_PACKAGE_NAME_MAX];
-  /** Index of the first logical processor on this physical package */
-  uint32_t processor_start;
-  /** Number of logical processors on this physical package */
-  uint32_t processor_count;
-  /** Index of the first core on this physical package */
-  uint32_t core_start;
-  /** Number of cores on this physical package */
-  uint32_t core_count;
-  /** Index of the first cluster of cores on this physical package */
-  uint32_t cluster_start;
-  /** Number of clusters of cores on this physical package */
-  uint32_t cluster_count;
-};
-
-struct cpuinfo_uarch_info {
-  /** Type of CPU microarchitecture */
-  enum cpuinfo_uarch uarch;
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  /** Value of CPUID leaf 1 EAX register for the microarchitecture */
-  uint32_t cpuid;
-#elif CPUINFO_ARCH_ARM || CPUINFO_ARCH_ARM64
-  /** Value of Main ID Register (MIDR) for the microarchitecture */
-  uint32_t midr;
-#endif
-  /** Number of logical processors with the microarchitecture */
-  uint32_t processor_count;
-  /** Number of cores with the microarchitecture */
-  uint32_t core_count;
-};
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-bool CPUINFO_ABI cpuinfo_initialize(void);
-
-void CPUINFO_ABI cpuinfo_deinitialize(void);
-
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-/* This structure is not a part of stable API. Use cpuinfo_has_x86_* functions
- * instead. */
-struct cpuinfo_x86_isa {
-#if CPUINFO_ARCH_X86
-  bool rdtsc;
-#endif
-  bool rdtscp;
-  bool rdpid;
-  bool sysenter;
-#if CPUINFO_ARCH_X86
-  bool syscall;
-#endif
-  bool msr;
-  bool clzero;
-  bool clflush;
-  bool clflushopt;
-  bool mwait;
-  bool mwaitx;
-#if CPUINFO_ARCH_X86
-  bool emmx;
-#endif
-  bool fxsave;
-  bool xsave;
-#if CPUINFO_ARCH_X86
-  bool fpu;
-  bool mmx;
-  bool mmx_plus;
-#endif
-  bool three_d_now;
-  bool three_d_now_plus;
-#if CPUINFO_ARCH_X86
-  bool three_d_now_geode;
-#endif
-  bool prefetch;
-  bool prefetchw;
-  bool prefetchwt1;
-#if CPUINFO_ARCH_X86
-  bool daz;
-  bool sse;
-  bool sse2;
-#endif
-  bool sse3;
-  bool ssse3;
-  bool sse4_1;
-  bool sse4_2;
-  bool sse4a;
-  bool misaligned_sse;
-  bool avx;
-  bool avxvnni;
-  bool fma3;
-  bool fma4;
-  bool xop;
-  bool f16c;
-  bool avx2;
-  bool avx512f;
-  bool avx512pf;
-  bool avx512er;
-  bool avx512cd;
-  bool avx512dq;
-  bool avx512bw;
-  bool avx512vl;
-  bool avx512ifma;
-  bool avx512vbmi;
-  bool avx512vbmi2;
-  bool avx512bitalg;
-  bool avx512vpopcntdq;
-  bool avx512vnni;
-  bool avx512bf16;
-  bool avx512fp16;
-  bool avx512vp2intersect;
-  bool avx512_4vnniw;
-  bool avx512_4fmaps;
-  bool avx10_1;
-  bool avx10_2;
-  bool amx_bf16;
-  bool amx_tile;
-  bool amx_int8;
-  bool amx_fp16;
-  bool avx_vnni_int8;
-  bool avx_vnni_int16;
-  bool avx_ne_convert;
-  bool hle;
-  bool rtm;
-  bool xtest;
-  bool mpx;
-#if CPUINFO_ARCH_X86
-  bool cmov;
-  bool cmpxchg8b;
-#endif
-  bool cmpxchg16b;
-  bool clwb;
-  bool movbe;
-#if CPUINFO_ARCH_X86_64
-  bool lahf_sahf;
-#endif
-  bool fs_gs_base;
-  bool lzcnt;
-  bool popcnt;
-  bool tbm;
-  bool bmi;
-  bool bmi2;
-  bool adx;
-  bool aes;
-  bool vaes;
-  bool pclmulqdq;
-  bool vpclmulqdq;
-  bool gfni;
-  bool rdrand;
-  bool rdseed;
-  bool sha;
-  bool rng;
-  bool ace;
-  bool ace2;
-  bool phe;
-  bool pmm;
-  bool lwp;
-};
-
-extern struct cpuinfo_x86_isa cpuinfo_isa;
-#endif
-
-static inline bool cpuinfo_has_x86_rdtsc(void) {
-#if CPUINFO_ARCH_X86_64
-  return true;
-#elif CPUINFO_ARCH_X86
-#if defined(__ANDROID__)
-  return true;
-#else
-  return cpuinfo_isa.rdtsc;
-#endif
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_rdtscp(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.rdtscp;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_rdpid(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.rdpid;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_clzero(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.clzero;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_mwait(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.mwait;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_mwaitx(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.mwaitx;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_fxsave(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.fxsave;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_xsave(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.xsave;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_fpu(void) {
-#if CPUINFO_ARCH_X86_64
-  return true;
-#elif CPUINFO_ARCH_X86
-#if defined(__ANDROID__)
-  return true;
-#else
-  return cpuinfo_isa.fpu;
-#endif
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_mmx(void) {
-#if CPUINFO_ARCH_X86_64
-  return true;
-#elif CPUINFO_ARCH_X86
-#if defined(__ANDROID__)
-  return true;
-#else
-  return cpuinfo_isa.mmx;
-#endif
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_mmx_plus(void) {
-#if CPUINFO_ARCH_X86_64
-  return true;
-#elif CPUINFO_ARCH_X86
-#if defined(__ANDROID__)
-  return true;
-#else
-  return cpuinfo_isa.mmx_plus;
-#endif
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_3dnow(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.three_d_now;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_3dnow_plus(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.three_d_now_plus;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_3dnow_geode(void) {
-#if CPUINFO_ARCH_X86_64
-  return false;
-#elif CPUINFO_ARCH_X86
-#if defined(__ANDROID__)
-  return false;
-#else
-  return cpuinfo_isa.three_d_now_geode;
-#endif
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_prefetch(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.prefetch;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_prefetchw(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.prefetchw;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_prefetchwt1(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.prefetchwt1;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_daz(void) {
-#if CPUINFO_ARCH_X86_64
-  return true;
-#elif CPUINFO_ARCH_X86
-#if defined(__ANDROID__)
-  return true;
-#else
-  return cpuinfo_isa.daz;
-#endif
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_sse(void) {
-#if CPUINFO_ARCH_X86_64
-  return true;
-#elif CPUINFO_ARCH_X86
-#if defined(__ANDROID__)
-  return true;
-#else
-  return cpuinfo_isa.sse;
-#endif
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_sse2(void) {
-#if CPUINFO_ARCH_X86_64
-  return true;
-#elif CPUINFO_ARCH_X86
-#if defined(__ANDROID__)
-  return true;
-#else
-  return cpuinfo_isa.sse2;
-#endif
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_sse3(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-#if defined(__ANDROID__)
-  return true;
-#else
-  return cpuinfo_isa.sse3;
-#endif
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_ssse3(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-#if defined(__ANDROID__)
-  return true;
-#else
-  return cpuinfo_isa.ssse3;
-#endif
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_sse4_1(void) {
-#if CPUINFO_ARCH_X86_64
-#if defined(__ANDROID__)
-  return true;
-#else
-  return cpuinfo_isa.sse4_1;
-#endif
-#elif CPUINFO_ARCH_X86
-  return cpuinfo_isa.sse4_1;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_sse4_2(void) {
-#if CPUINFO_ARCH_X86_64
-#if defined(__ANDROID__)
-  return true;
-#else
-  return cpuinfo_isa.sse4_2;
-#endif
-#elif CPUINFO_ARCH_X86
-  return cpuinfo_isa.sse4_2;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_sse4a(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.sse4a;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_misaligned_sse(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.misaligned_sse;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_avx(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_avxvnni(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avxvnni;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_fma3(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.fma3;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_fma4(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.fma4;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_xop(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.xop;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_f16c(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.f16c;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_avx2(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx2;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_avx512f(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx512f;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_avx512pf(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx512pf;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_avx512er(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx512er;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_avx512cd(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx512cd;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_avx512dq(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx512dq;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_avx512bw(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx512bw;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_avx512vl(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx512vl;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_avx512ifma(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx512ifma;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_avx512vbmi(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx512vbmi;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_avx512vbmi2(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx512vbmi2;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_avx512bitalg(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx512bitalg;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_avx512vpopcntdq(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx512vpopcntdq;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_avx512vnni(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx512vnni;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_avx512bf16(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx512bf16;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_avx512fp16(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx512fp16;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_avx512vp2intersect(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx512vp2intersect;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_avx512_4vnniw(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx512_4vnniw;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_avx512_4fmaps(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx512_4fmaps;
-#else
-  return false;
-#endif
-}
-
-/* [NOTE] Intel Advanced Matrix Extensions (AMX) detection
- *
- * I.  AMX is a new extensions to the x86 ISA to work on matrices, consists of
- *   1) 2-dimentional registers (tiles), hold sub-matrices from larger matrices
- * in memory 2) Accelerator called Tile Matrix Multiply (TMUL), contains
- * instructions operating on tiles
- *
- * II. Platforms that supports AMX:
- * +-----------------+-----+----------+----------+----------+----------+
- * |    Platforms    | Gen | amx-bf16 | amx-tile | amx-int8 | amx-fp16 |
- * +-----------------+-----+----------+----------+----------+----------+
- * | Sapphire Rapids | 4th |   YES    |   YES    |   YES    |    NO    |
- * +-----------------+-----+----------+----------+----------+----------+
- * | Emerald Rapids  | 5th |   YES    |   YES    |   YES    |    NO    |
- * +-----------------+-----+----------+----------+----------+----------+
- * | Granite Rapids  | 6th |   YES    |   YES    |   YES    |   YES    |
- * +-----------------+-----+----------+----------+----------+----------+
- *
- * Reference: https://www.intel.com/content/www/us/en/products/docs
- *    /accelerator-engines/advanced-matrix-extensions/overview.html
- */
-static inline bool cpuinfo_has_x86_amx_bf16(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.amx_bf16;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_amx_tile(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.amx_tile;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_amx_int8(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.amx_int8;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_amx_fp16(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.amx_fp16;
-#else
-  return false;
-#endif
-}
-
-/*
- * Intel AVX Vector Neural Network Instructions (VNNI) INT8
- * Supported Platfroms: Sierra Forest, Arrow Lake, Lunar Lake
- */
-static inline bool cpuinfo_has_x86_avx_vnni_int8(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx_vnni_int8;
-#else
-  return false;
-#endif
-}
-
-/*
- * Intel AVX Vector Neural Network Instructions (VNNI) INT16
- * Supported Platfroms: Arrow Lake, Lunar Lake
- */
-static inline bool cpuinfo_has_x86_avx_vnni_int16(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx_vnni_int16;
-#else
-  return false;
-#endif
-}
-
-/*
- * A new set of instructions, which can convert low precision floating point
- * like BF16/FP16 to high precision floating point FP32, as well as convert FP32
- * elements to BF16. This instruction allows the platform to have improved AI
- * capabilities and better compatibility.
- *
- * Supported Platforms: Sierra Forest, Arrow Lake, Lunar Lake
- */
-static inline bool cpuinfo_has_x86_avx_ne_convert(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx_ne_convert;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_avx10_1(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx10_1;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_avx10_2(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.avx10_2;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_hle(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.hle;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_rtm(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.rtm;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_xtest(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.xtest;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_mpx(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.mpx;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_cmov(void) {
-#if CPUINFO_ARCH_X86_64
-  return true;
-#elif CPUINFO_ARCH_X86
-  return cpuinfo_isa.cmov;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_cmpxchg8b(void) {
-#if CPUINFO_ARCH_X86_64
-  return true;
-#elif CPUINFO_ARCH_X86
-  return cpuinfo_isa.cmpxchg8b;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_cmpxchg16b(void) {
-#if CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.cmpxchg16b;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_clwb(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.clwb;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_movbe(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.movbe;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_lahf_sahf(void) {
-#if CPUINFO_ARCH_X86
-  return true;
-#elif CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.lahf_sahf;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_lzcnt(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.lzcnt;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_popcnt(void) {
-#if CPUINFO_ARCH_X86_64
-#if defined(__ANDROID__)
-  return true;
-#else
-  return cpuinfo_isa.popcnt;
-#endif
-#elif CPUINFO_ARCH_X86
-  return cpuinfo_isa.popcnt;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_tbm(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.tbm;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_bmi(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.bmi;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_bmi2(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.bmi2;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_adx(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.adx;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_aes(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.aes;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_vaes(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.vaes;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_pclmulqdq(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.pclmulqdq;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_vpclmulqdq(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.vpclmulqdq;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_gfni(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.gfni;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_rdrand(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.rdrand;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_rdseed(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.rdseed;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_x86_sha(void) {
-#if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
-  return cpuinfo_isa.sha;
-#else
-  return false;
-#endif
-}
-
-#if CPUINFO_ARCH_ARM || CPUINFO_ARCH_ARM64
-/* This structure is not a part of stable API. Use cpuinfo_has_arm_* functions
- * instead. */
-struct cpuinfo_arm_isa {
-#if CPUINFO_ARCH_ARM
-  bool thumb;
-  bool thumb2;
-  bool thumbee;
-  bool jazelle;
-  bool armv5e;
-  bool armv6;
-  bool armv6k;
-  bool armv7;
-  bool armv7mp;
-  bool armv8;
-  bool idiv;
-
-  bool vfpv2;
-  bool vfpv3;
-  bool d32;
-  bool fp16;
-  bool fma;
-
-  bool wmmx;
-  bool wmmx2;
-  bool neon;
-#endif
-#if CPUINFO_ARCH_ARM64
-  bool atomics;
-  bool bf16;
-  bool sve;
-  bool sve2;
-  bool i8mm;
-  bool sme;
-  bool sme2;
-  bool sme2p1;
-  bool sme_i16i32;
-  bool sme_bi32i32;
-  bool sme_b16b16;
-  bool sme_f16f16;
-  uint32_t svelen;
-  uint32_t smelen;
-#endif
-  bool rdm;
-  bool fp16arith;
-  bool dot;
-  bool jscvt;
-  bool fcma;
-  bool fhm;
-
-  bool aes;
-  bool sha1;
-  bool sha2;
-  bool pmull;
-  bool crc32;
-};
-
-extern struct cpuinfo_arm_isa cpuinfo_isa;
-#endif
-
-static inline bool cpuinfo_has_arm_thumb(void) {
-#if CPUINFO_ARCH_ARM
-  return cpuinfo_isa.thumb;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_thumb2(void) {
-#if CPUINFO_ARCH_ARM
-  return cpuinfo_isa.thumb2;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_v5e(void) {
-#if CPUINFO_ARCH_ARM
-  return cpuinfo_isa.armv5e;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_v6(void) {
-#if CPUINFO_ARCH_ARM
-  return cpuinfo_isa.armv6;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_v6k(void) {
-#if CPUINFO_ARCH_ARM
-  return cpuinfo_isa.armv6k;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_v7(void) {
-#if CPUINFO_ARCH_ARM
-  return cpuinfo_isa.armv7;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_v7mp(void) {
-#if CPUINFO_ARCH_ARM
-  return cpuinfo_isa.armv7mp;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_v8(void) {
-#if CPUINFO_ARCH_ARM64
-  return true;
-#elif CPUINFO_ARCH_ARM
-  return cpuinfo_isa.armv8;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_idiv(void) {
-#if CPUINFO_ARCH_ARM64
-  return true;
-#elif CPUINFO_ARCH_ARM
-  return cpuinfo_isa.idiv;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_vfpv2(void) {
-#if CPUINFO_ARCH_ARM
-  return cpuinfo_isa.vfpv2;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_vfpv3(void) {
-#if CPUINFO_ARCH_ARM64
-  return true;
-#elif CPUINFO_ARCH_ARM
-  return cpuinfo_isa.vfpv3;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_vfpv3_d32(void) {
-#if CPUINFO_ARCH_ARM64
-  return true;
-#elif CPUINFO_ARCH_ARM
-  return cpuinfo_isa.vfpv3 && cpuinfo_isa.d32;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_vfpv3_fp16(void) {
-#if CPUINFO_ARCH_ARM64
-  return true;
-#elif CPUINFO_ARCH_ARM
-  return cpuinfo_isa.vfpv3 && cpuinfo_isa.fp16;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_vfpv3_fp16_d32(void) {
-#if CPUINFO_ARCH_ARM64
-  return true;
-#elif CPUINFO_ARCH_ARM
-  return cpuinfo_isa.vfpv3 && cpuinfo_isa.fp16 && cpuinfo_isa.d32;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_vfpv4(void) {
-#if CPUINFO_ARCH_ARM64
-  return true;
-#elif CPUINFO_ARCH_ARM
-  return cpuinfo_isa.vfpv3 && cpuinfo_isa.fma;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_vfpv4_d32(void) {
-#if CPUINFO_ARCH_ARM64
-  return true;
-#elif CPUINFO_ARCH_ARM
-  return cpuinfo_isa.vfpv3 && cpuinfo_isa.fma && cpuinfo_isa.d32;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_fp16_arith(void) {
-#if CPUINFO_ARCH_ARM || CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.fp16arith;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_bf16(void) {
-#if CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.bf16;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_wmmx(void) {
-#if CPUINFO_ARCH_ARM
-  return cpuinfo_isa.wmmx;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_wmmx2(void) {
-#if CPUINFO_ARCH_ARM
-  return cpuinfo_isa.wmmx2;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_neon(void) {
-#if CPUINFO_ARCH_ARM64
-  return true;
-#elif CPUINFO_ARCH_ARM
-  return cpuinfo_isa.neon;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_neon_fp16(void) {
-#if CPUINFO_ARCH_ARM64
-  return true;
-#elif CPUINFO_ARCH_ARM
-  return cpuinfo_isa.neon && cpuinfo_isa.fp16;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_neon_fma(void) {
-#if CPUINFO_ARCH_ARM64
-  return true;
-#elif CPUINFO_ARCH_ARM
-  return cpuinfo_isa.neon && cpuinfo_isa.fma;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_neon_v8(void) {
-#if CPUINFO_ARCH_ARM64
-  return true;
-#elif CPUINFO_ARCH_ARM
-  return cpuinfo_isa.neon && cpuinfo_isa.armv8;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_atomics(void) {
-#if CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.atomics;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_neon_rdm(void) {
-#if CPUINFO_ARCH_ARM || CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.rdm;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_neon_fp16_arith(void) {
-#if CPUINFO_ARCH_ARM
-  return cpuinfo_isa.neon && cpuinfo_isa.fp16arith;
-#elif CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.fp16arith;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_fhm(void) {
-#if CPUINFO_ARCH_ARM || CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.fhm;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_neon_dot(void) {
-#if CPUINFO_ARCH_ARM || CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.dot;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_neon_bf16(void) {
-#if CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.bf16;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_jscvt(void) {
-#if CPUINFO_ARCH_ARM || CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.jscvt;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_fcma(void) {
-#if CPUINFO_ARCH_ARM || CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.fcma;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_i8mm(void) {
-#if CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.i8mm;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_aes(void) {
-#if CPUINFO_ARCH_ARM || CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.aes;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_sha1(void) {
-#if CPUINFO_ARCH_ARM || CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.sha1;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_sha2(void) {
-#if CPUINFO_ARCH_ARM || CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.sha2;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_pmull(void) {
-#if CPUINFO_ARCH_ARM || CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.pmull;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_crc32(void) {
-#if CPUINFO_ARCH_ARM || CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.crc32;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_sve(void) {
-#if CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.sve;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_sve_bf16(void) {
-#if CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.sve && cpuinfo_isa.bf16;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_sve2(void) {
-#if CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.sve2;
-#else
-  return false;
-#endif
-}
-
-// Function to get the max SVE vector length on ARM CPU's which support SVE.
-static inline uint32_t cpuinfo_get_max_arm_sve_length(void) {
-#if CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.svelen * 8; // bytes * 8 = bit length(vector length)
-#else
-  return 0;
-#endif
-}
-
-// Function to get the max SME vector length on ARM CPU's which support SME.
-static inline uint32_t cpuinfo_get_max_arm_sme_length(void) {
-#if CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.smelen * 8; // bytes * 8 = bit length(vector length)
-#else
-  return 0;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_sme(void) {
-#if CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.sme;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_sme2(void) {
-#if CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.sme2;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_sme2p1(void) {
-#if CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.sme2p1;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_sme_i16i32(void) {
-#if CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.sme_i16i32;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_sme_bi32i32(void) {
-#if CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.sme_bi32i32;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_sme_b16b16(void) {
-#if CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.sme_b16b16;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_arm_sme_f16f16(void) {
-#if CPUINFO_ARCH_ARM64
-  return cpuinfo_isa.sme_f16f16;
-#else
-  return false;
-#endif
-}
-
-#if CPUINFO_ARCH_RISCV32 || CPUINFO_ARCH_RISCV64
-/* This structure is not a part of stable API. Use cpuinfo_has_riscv_* functions
- * instead. */
-struct cpuinfo_riscv_isa {
-  /**
-   * Keep fields in line with the canonical order as defined by
-   * Section 27.11 Subset Naming Convention.
-   */
-  /* RV32I/64I/128I Base ISA. */
-  bool i;
-#if CPUINFO_ARCH_RISCV32
-  /* RV32E Base ISA. */
-  bool e;
-#endif
-  /* Integer Multiply/Divide Extension. */
-  bool m;
-  /* Atomic Extension. */
-  bool a;
-  /* Single-Precision Floating-Point Extension. */
-  bool f;
-  /* Double-Precision Floating-Point Extension. */
-  bool d;
-  /* Compressed Extension. */
-  bool c;
-  /* Vector Extension. */
-  bool v;
-};
-
-extern struct cpuinfo_riscv_isa cpuinfo_isa;
-#endif
-
-static inline bool cpuinfo_has_riscv_i(void) {
-#if CPUINFO_ARCH_RISCV32 || CPUINFO_ARCH_RISCV64
-  return cpuinfo_isa.i;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_riscv_e(void) {
-#if CPUINFO_ARCH_RISCV32
-  return cpuinfo_isa.e;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_riscv_m(void) {
-#if CPUINFO_ARCH_RISCV32 || CPUINFO_ARCH_RISCV64
-  return cpuinfo_isa.m;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_riscv_a(void) {
-#if CPUINFO_ARCH_RISCV32 || CPUINFO_ARCH_RISCV64
-  return cpuinfo_isa.a;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_riscv_f(void) {
-#if CPUINFO_ARCH_RISCV32 || CPUINFO_ARCH_RISCV64
-  return cpuinfo_isa.f;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_riscv_d(void) {
-#if CPUINFO_ARCH_RISCV32 || CPUINFO_ARCH_RISCV64
-  return cpuinfo_isa.d;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_riscv_g(void) {
-  // The 'G' extension is simply shorthand for 'IMAFD'.
-  return cpuinfo_has_riscv_i() && cpuinfo_has_riscv_m() &&
-         cpuinfo_has_riscv_a() && cpuinfo_has_riscv_f() &&
-         cpuinfo_has_riscv_d();
-}
-
-static inline bool cpuinfo_has_riscv_c(void) {
-#if CPUINFO_ARCH_RISCV32 || CPUINFO_ARCH_RISCV64
-  return cpuinfo_isa.c;
-#else
-  return false;
-#endif
-}
-
-static inline bool cpuinfo_has_riscv_v(void) {
-#if CPUINFO_ARCH_RISCV32 || CPUINFO_ARCH_RISCV64
-  return cpuinfo_isa.v;
-#else
-  return false;
-#endif
-}
-
-const struct cpuinfo_processor *CPUINFO_ABI cpuinfo_get_processors(void);
-const struct cpuinfo_core *CPUINFO_ABI cpuinfo_get_cores(void);
-const struct cpuinfo_cluster *CPUINFO_ABI cpuinfo_get_clusters(void);
-const struct cpuinfo_package *CPUINFO_ABI cpuinfo_get_packages(void);
-const struct cpuinfo_uarch_info *CPUINFO_ABI cpuinfo_get_uarchs(void);
-const struct cpuinfo_cache *CPUINFO_ABI cpuinfo_get_l1i_caches(void);
-const struct cpuinfo_cache *CPUINFO_ABI cpuinfo_get_l1d_caches(void);
-const struct cpuinfo_cache *CPUINFO_ABI cpuinfo_get_l2_caches(void);
-const struct cpuinfo_cache *CPUINFO_ABI cpuinfo_get_l3_caches(void);
-const struct cpuinfo_cache *CPUINFO_ABI cpuinfo_get_l4_caches(void);
-
-const struct cpuinfo_processor *CPUINFO_ABI
-cpuinfo_get_processor(uint32_t index);
-const struct cpuinfo_core *CPUINFO_ABI cpuinfo_get_core(uint32_t index);
-const struct cpuinfo_cluster *CPUINFO_ABI cpuinfo_get_cluster(uint32_t index);
-const struct cpuinfo_package *CPUINFO_ABI cpuinfo_get_package(uint32_t index);
-const struct cpuinfo_uarch_info *CPUINFO_ABI cpuinfo_get_uarch(uint32_t index);
-const struct cpuinfo_cache *CPUINFO_ABI cpuinfo_get_l1i_cache(uint32_t index);
-const struct cpuinfo_cache *CPUINFO_ABI cpuinfo_get_l1d_cache(uint32_t index);
-const struct cpuinfo_cache *CPUINFO_ABI cpuinfo_get_l2_cache(uint32_t index);
-const struct cpuinfo_cache *CPUINFO_ABI cpuinfo_get_l3_cache(uint32_t index);
-const struct cpuinfo_cache *CPUINFO_ABI cpuinfo_get_l4_cache(uint32_t index);
-
-uint32_t CPUINFO_ABI cpuinfo_get_processors_count(void);
-uint32_t CPUINFO_ABI cpuinfo_get_cores_count(void);
-uint32_t CPUINFO_ABI cpuinfo_get_clusters_count(void);
-uint32_t CPUINFO_ABI cpuinfo_get_packages_count(void);
-uint32_t CPUINFO_ABI cpuinfo_get_uarchs_count(void);
-uint32_t CPUINFO_ABI cpuinfo_get_l1i_caches_count(void);
-uint32_t CPUINFO_ABI cpuinfo_get_l1d_caches_count(void);
-uint32_t CPUINFO_ABI cpuinfo_get_l2_caches_count(void);
-uint32_t CPUINFO_ABI cpuinfo_get_l3_caches_count(void);
-uint32_t CPUINFO_ABI cpuinfo_get_l4_caches_count(void);
-
-/**
- * Returns upper bound on cache size.
- */
-uint32_t CPUINFO_ABI cpuinfo_get_max_cache_size(void);
-
-/**
- * Identify the logical processor that executes the current thread.
- *
- * There is no guarantee that the thread will stay on the same logical processor
- * for any time. Callers should treat the result as only a hint, and be prepared
- * to handle NULL return value.
- */
-const struct cpuinfo_processor *CPUINFO_ABI cpuinfo_get_current_processor(void);
-
-/**
- * Identify the core that executes the current thread.
- *
- * There is no guarantee that the thread will stay on the same core for any
- * time. Callers should treat the result as only a hint, and be prepared to
- * handle NULL return value.
- */
-const struct cpuinfo_core *CPUINFO_ABI cpuinfo_get_current_core(void);
-
-/**
- * Identify the microarchitecture index of the core that executes the current
- * thread. If the system does not support such identification, the function
- * returns 0.
- *
- * There is no guarantee that the thread will stay on the same type of core for
- * any time. Callers should treat the result as only a hint.
- */
-uint32_t CPUINFO_ABI cpuinfo_get_current_uarch_index(void);
-
-/**
- * Identify the microarchitecture index of the core that executes the current
- * thread. If the system does not support such identification, the function
- * returns the user-specified default value.
- *
- * There is no guarantee that the thread will stay on the same type of core for
- * any time. Callers should treat the result as only a hint.
- */
-uint32_t CPUINFO_ABI
-cpuinfo_get_current_uarch_index_with_default(uint32_t default_uarch_index);
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /* CPUINFO_H */
diff --git a/packages/react-native-executorch/third-party/include/executorch/ExecuTorch.h b/packages/react-native-executorch/third-party/include/executorch/ExecuTorch.h
deleted file mode 100644
index d0ad6c2840..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/ExecuTorch.h
+++ /dev/null
@@ -1,15 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#import "ExecuTorchBackendOption.h"
-#import "ExecuTorchBackendOptionsMap.h"
-#import "ExecuTorchError.h"
-#import "ExecuTorchLog.h"
-#import "ExecuTorchModule.h"
-#import "ExecuTorchTensor.h"
-#import "ExecuTorchValue.h"
diff --git a/packages/react-native-executorch/third-party/include/executorch/ExecuTorchError.h b/packages/react-native-executorch/third-party/include/executorch/ExecuTorchError.h
deleted file mode 100644
index ea857d150b..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/ExecuTorchError.h
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#import <Foundation/Foundation.h>
-
-NS_ASSUME_NONNULL_BEGIN
-
-FOUNDATION_EXPORT NSErrorDomain const
-    ExecuTorchErrorDomain NS_SWIFT_NAME(ErrorDomain);
-
-/**
- * Enum to define the error codes.
- * Values can be a subset, but must numerically match exactly those defined in
- * runtime/core/error.h
- */
-typedef NS_ERROR_ENUM(ExecuTorchErrorDomain, ExecuTorchErrorCode){
-    // System errors.
-    ExecuTorchErrorCodeOk = 0,
-    ExecuTorchErrorCodeInternal = 1,
-    ExecuTorchErrorCodeInvalidState = 2,
-    ExecuTorchErrorCodeEndOfMethod = 3,
-
-    // Logical errors.
-    ExecuTorchErrorCodeNotSupported = 16,
-    ExecuTorchErrorCodeNotImplemented = 17,
-    ExecuTorchErrorCodeInvalidArgument = 18,
-    ExecuTorchErrorCodeInvalidType = 19,
-    ExecuTorchErrorCodeOperatorMissing = 20,
-
-    // Registration errors.
-    ExecuTorchErrorCodeRegistrationExceedingMaxKernels = 21,
-    ExecuTorchErrorCodeRegistrationAlreadyRegistered = 22,
-
-    // Resource errors.
-    ExecuTorchErrorCodeNotFound = 32,
-    ExecuTorchErrorCodeMemoryAllocationFailed = 33,
-    ExecuTorchErrorCodeAccessFailed = 34,
-    ExecuTorchErrorCodeInvalidProgram = 35,
-    ExecuTorchErrorCodeInvalidExternalData = 36,
-    ExecuTorchErrorCodeOutOfResources = 37,
-
-    // Delegate errors.
-    ExecuTorchErrorCodeDelegateInvalidCompatibility = 48,
-    ExecuTorchErrorCodeDelegateMemoryAllocationFailed = 49,
-    ExecuTorchErrorCodeDelegateInvalidHandle = 50,
-} NS_SWIFT_NAME(ErrorCode);
-
-/**
- * Returns a brief error description for the given error code.
- *
- * @param code An ExecuTorchErrorCode value representing the error code.
- * @return An NSString containing the error description.
- */
-FOUNDATION_EXPORT
-NS_RETURNS_RETAINED
-NSString *ExecuTorchErrorDescription(ExecuTorchErrorCode code)
-    NS_SWIFT_NAME(ErrorDescription(_:));
-
-/**
- * Create an NSError in the ExecuTorch domain for the given code.
- *
- * @param code The ExecuTorchErrorCode to wrap.
- * @return An NSError with ExecuTorchErrorDomain, the specified code, and a
- * localized description.
- */
-FOUNDATION_EXPORT
-NS_RETURNS_RETAINED
-NSError *ExecuTorchErrorWithCode(ExecuTorchErrorCode code)
-    NS_SWIFT_NAME(Error(code:));
-
-/**
- * Create an NSError in the ExecuTorch domain for the given code.
- *
- * @param code The ExecuTorchErrorCode to wrap.
- * @param description Additional error description.
- * @return An NSError with ExecuTorchErrorDomain, the specified code, and a
- * localized description.
- */
-FOUNDATION_EXPORT
-NS_RETURNS_RETAINED
-NSError *ExecuTorchErrorWithCodeAndDescription(ExecuTorchErrorCode code,
-                                               NSString *__nullable description)
-    NS_SWIFT_NAME(Error(code:description:));
-
-NS_ASSUME_NONNULL_END
diff --git a/packages/react-native-executorch/third-party/include/executorch/ExecuTorchLLM/ExecuTorchLLM.h b/packages/react-native-executorch/third-party/include/executorch/ExecuTorchLLM/ExecuTorchLLM.h
deleted file mode 100644
index cef90617a1..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/ExecuTorchLLM/ExecuTorchLLM.h
+++ /dev/null
@@ -1,12 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#import "ExecuTorchLLMConfig.h"
-#import "ExecuTorchLLMError.h"
-#import "ExecuTorchLLMMultimodalRunner.h"
-#import "ExecuTorchLLMTextRunner.h"
diff --git a/packages/react-native-executorch/third-party/include/executorch/ExecuTorchLLM/ExecuTorchLLMConfig.h b/packages/react-native-executorch/third-party/include/executorch/ExecuTorchLLM/ExecuTorchLLMConfig.h
deleted file mode 100644
index 5ecc9a0f00..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/ExecuTorchLLM/ExecuTorchLLMConfig.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#import <Foundation/Foundation.h>
-
-NS_ASSUME_NONNULL_BEGIN
-
-/**
- A configuration object for text generation.
-
- This class wraps the underlying C++ GenerationConfig so that default
- values and future fields remain a single source of truth in C++.
-*/
-NS_SWIFT_NAME(Config)
-__attribute__((deprecated("This API is experimental.")))
-__attribute__((objc_subclassing_restricted))
-@interface ExecuTorchLLMConfig : NSObject<NSCopying>
-
-/** Whether to echo the input prompt in the output. */
-@property(nonatomic, getter=isEchoEnabled) BOOL echoEnabled;
-
-/** Maximum number of new tokens to generate. */
-@property(nonatomic) NSInteger maximumNewTokens;
-
-/** Whether this is a warmup run. */
-@property(nonatomic, getter=isWarming) BOOL warming;
-
-/** Maximum total sequence length. */
-@property(nonatomic) NSInteger sequenceLength;
-
-/** Temperature for sampling. */
-@property(nonatomic) double temperature;
-
-/** Number of BOS tokens to add. */
-@property(nonatomic) NSInteger bosCount;
-
-/** Number of EOS tokens to add. */
-@property(nonatomic) NSInteger eosCount;
-
-/**
- Initializes a configuration and invokes the block to mutate it.
-
- @param block  A block that receives the newly initialized configuration.
- @return An initialized ExecuTorchLLMConfig instance.
-*/
-- (instancetype)initWithBlock:(NS_NOESCAPE void (^)(ExecuTorchLLMConfig *))block
-    NS_SWIFT_NAME(init(_:));
-
-@end
-
-NS_ASSUME_NONNULL_END
diff --git a/packages/react-native-executorch/third-party/include/executorch/ExecuTorchLLM/ExecuTorchLLMError.h b/packages/react-native-executorch/third-party/include/executorch/ExecuTorchLLM/ExecuTorchLLMError.h
deleted file mode 100644
index 3363f901b4..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/ExecuTorchLLM/ExecuTorchLLMError.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#import <Foundation/Foundation.h>
-
-NS_ASSUME_NONNULL_BEGIN
-
-FOUNDATION_EXPORT NSErrorDomain const
-    ExecuTorchLLMErrorDomain NS_SWIFT_NAME(ErrorDomain);
-
-NS_ASSUME_NONNULL_END
diff --git a/packages/react-native-executorch/third-party/include/executorch/ExecuTorchLLM/ExecuTorchLLMMultimodalRunner.h b/packages/react-native-executorch/third-party/include/executorch/ExecuTorchLLM/ExecuTorchLLMMultimodalRunner.h
deleted file mode 100644
index 9e2ec5da26..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/ExecuTorchLLM/ExecuTorchLLMMultimodalRunner.h
+++ /dev/null
@@ -1,227 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#import "ExecuTorchLLMConfig.h"
-
-NS_ASSUME_NONNULL_BEGIN
-
-/**
- Types of multimodal inputs supported by the ExecuTorch LLM APIs.
- Must be in sync with the C++ enum in llm/runner/multimodal_input.h
-*/
-typedef NS_ENUM(NSInteger, ExecuTorchLLMMultimodalInputType) {
-  ExecuTorchLLMMultimodalInputTypeText,
-  ExecuTorchLLMMultimodalInputTypeImage,
-  ExecuTorchLLMMultimodalInputTypeAudio,
-  ExecuTorchLLMMultimodalInputTypeUnsupported,
-} NS_SWIFT_NAME(MultimodalInputType);
-
-/**
- A container for image inputs used with multimodal generation APIs.
-*/
-NS_SWIFT_NAME(Image)
-__attribute__((deprecated("This API is experimental.")))
-__attribute__((objc_subclassing_restricted))
-@interface ExecuTorchLLMImage : NSObject<NSCopying>
-
-/**
- Initializes an image container with the provided data and dimensions.
-
- @param data       Raw image bytes.
- @param width      Image width in pixels.
- @param height     Image height in pixels.
- @param channels   Number of channels.
- @return An initialized ExecuTorchLLMImage instance.
-*/
-- (instancetype)initWithData:(NSData *)data
-                       width:(NSInteger)width
-                      height:(NSInteger)height
-                    channels:(NSInteger)channels NS_DESIGNATED_INITIALIZER;
-
-- (instancetype)initWithFloatData:(NSData *)data
-                            width:(NSInteger)width
-                           height:(NSInteger)height
-                         channels:(NSInteger)channels NS_DESIGNATED_INITIALIZER;
-
-@property(nonatomic, readonly) NSData *data;
-
-@property(nonatomic, readonly) NSInteger width;
-
-@property(nonatomic, readonly) NSInteger height;
-
-@property(nonatomic, readonly) NSInteger channels;
-
-@property(nonatomic, readonly) BOOL isFloat;
-
-+ (instancetype)new NS_UNAVAILABLE;
-- (instancetype)init NS_UNAVAILABLE;
-
-@end
-
-/**
- A container for pre-processed audio features.
-*/
-NS_SWIFT_NAME(Audio)
-__attribute__((deprecated("This API is experimental.")))
-__attribute__((objc_subclassing_restricted))
-@interface ExecuTorchLLMAudio : NSObject<NSCopying>
-
-/**
- Initializes an audio features container with the provided data and shape.
-
- @param data        Feature buffer.
- @param batchSize   Batch dimension size.
- @param bins        Number of frequency bins.
- @param frames      Number of time frames.
- @return An initialized ExecuTorchLLMAudio instance.
-*/
-- (instancetype)initWithData:(NSData *)data
-                   batchSize:(NSInteger)batchSize
-                        bins:(NSInteger)bins
-                      frames:(NSInteger)frames NS_DESIGNATED_INITIALIZER;
-
-- (instancetype)initWithFloatData:(NSData *)data
-                        batchSize:(NSInteger)batchSize
-                             bins:(NSInteger)bins
-                           frames:(NSInteger)frames NS_DESIGNATED_INITIALIZER;
-
-@property(nonatomic, readonly) NSData *data;
-
-@property(nonatomic, readonly) NSInteger batchSize;
-
-@property(nonatomic, readonly) NSInteger bins;
-
-@property(nonatomic, readonly) NSInteger frames;
-
-@property(nonatomic, readonly) BOOL isFloat;
-
-+ (instancetype)new NS_UNAVAILABLE;
-- (instancetype)init NS_UNAVAILABLE;
-
-@end
-
-/**
- A tagged container for a single multimodal input item used by
- multimodal generation APIs.
-*/
-NS_SWIFT_NAME(MultimodalInput)
-__attribute__((deprecated("This API is experimental.")))
-__attribute__((objc_subclassing_restricted))
-@interface ExecuTorchLLMMultimodalInput : NSObject<NSCopying>
-
-/**
- Creates a text input.
-
- @param text  The UTF-8 text to provide as input.
- @return A retained ExecuTorchLLMMultimodalInput instance of type Text.
-*/
-+ (instancetype)inputWithText:(NSString *)text
-    NS_SWIFT_NAME(init(_:)) NS_RETURNS_RETAINED;
-
-/**
- Creates an image input.
-
- @param image  The image payload to provide as input.
- @return A retained ExecuTorchLLMMultimodalInput instance of type Image.
-*/
-+ (instancetype)inputWithImage:(ExecuTorchLLMImage *)image
-    NS_SWIFT_NAME(init(_:)) NS_RETURNS_RETAINED;
-
-/**
- Creates an audio-features input.
-
- @param audio  The pre-processed audio features to provide as input.
- @return A retained ExecuTorchLLMMultimodalInput instance of type Audio.
-*/
-+ (instancetype)inputWithAudio:(ExecuTorchLLMAudio *)audio
-    NS_SWIFT_NAME(init(_:)) NS_RETURNS_RETAINED;
-
-@property(nonatomic, readonly) ExecuTorchLLMMultimodalInputType type;
-
-@property(nonatomic, readonly, nullable) NSString *text;
-
-@property(nonatomic, readonly, nullable) ExecuTorchLLMImage *image;
-
-@property(nonatomic, readonly, nullable) ExecuTorchLLMAudio *audio;
-
-+ (instancetype)new NS_UNAVAILABLE;
-- (instancetype)init NS_UNAVAILABLE;
-
-@end
-
-/**
- A wrapper class for the C++ llm::MultimodalRunner that provides
- Objective-C APIs to load models, manage tokenization, accept mixed
- input modalities, generate text sequences, and stop the runner.
-*/
-NS_SWIFT_NAME(MultimodalRunner)
-__attribute__((deprecated("This API is experimental.")))
-__attribute__((objc_subclassing_restricted))
-@interface ExecuTorchLLMMultimodalRunner : NSObject
-
-/**
- Initializes a multimodal LLM runner with the given model and tokenizer paths.
-
- @param modelPath      File system path to the serialized model.
- @param tokenizerPath  File system path to the tokenizer data.
- @return An initialized ExecuTorchLLMMultimodalRunner instance.
-*/
-- (instancetype)initWithModelPath:(NSString *)modelPath
-                    tokenizerPath:(NSString *)tokenizerPath
-    NS_DESIGNATED_INITIALIZER;
-
-/**
- Checks whether the underlying model has been successfully loaded.
-
- @return YES if the model is loaded, NO otherwise.
-*/
-- (BOOL)isLoaded;
-
-/**
- Loads the model into memory, returning an error if loading fails.
-
- @param error   On failure, populated with an NSError explaining the issue.
- @return YES if loading succeeds, NO if an error occurred.
-*/
-- (BOOL)loadWithError:(NSError **)error;
-
-/**
- Generates text given a list of multimodal inputs. A default configuration
- is created and passed to the configuration block for in-place mutation.
-
- The token callback, if provided, is invoked for each generated token.
-
- @param inputs     An ordered array of multimodal inputs.
- @param config     A configuration object.
- @param callback   A block called with each generated token as an NSString.
- @param error      On failure, populated with an NSError explaining the issue.
- @return YES if generation completes successfully, NO if an error occurred.
-*/
-- (BOOL)generateWithInputs:(NSArray<ExecuTorchLLMMultimodalInput *> *)inputs
-                    config:(ExecuTorchLLMConfig *)config
-             tokenCallback:(nullable void (^)(NSString *))callback
-                     error:(NSError **)error
-    NS_SWIFT_NAME(generate(_:_:tokenCallback:));
-
-/**
- Stop producing new tokens and terminate the current generation process.
-*/
-- (void)stop;
-
-/**
- Remove the prefilled tokens from the KV cache and reset the start position
- to 0. It also clears the stats for previous runs.
-*/
-- (void)reset;
-
-+ (instancetype)new NS_UNAVAILABLE;
-- (instancetype)init NS_UNAVAILABLE;
-
-@end
-
-NS_ASSUME_NONNULL_END
diff --git a/packages/react-native-executorch/third-party/include/executorch/ExecuTorchLLM/ExecuTorchLLMTextRunner.h b/packages/react-native-executorch/third-party/include/executorch/ExecuTorchLLM/ExecuTorchLLMTextRunner.h
deleted file mode 100644
index 6b1159fd54..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/ExecuTorchLLM/ExecuTorchLLMTextRunner.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#import "ExecuTorchLLMConfig.h"
-
-NS_ASSUME_NONNULL_BEGIN
-
-/**
- A wrapper class for the C++ llm::TextLLMRunner that provides
- Objective-C APIs to load models, manage tokenization with custom
- special tokens, generate text sequences, and stop the runner.
-*/
-NS_SWIFT_NAME(TextRunner)
-__attribute__((deprecated("This API is experimental.")))
-@interface ExecuTorchLLMTextRunner : NSObject
-
-/**
- Initializes a text LLM runner with the given model and tokenizer paths,
- and a list of special tokens to include in the tokenizer.
-
- @param modelPath      File system path to the serialized model.
- @param tokenizerPath  File system path to the tokenizer data.
- @return An initialized ExecuTorchLLMTextRunner instance.
-*/
-- (instancetype)initWithModelPath:(NSString *)modelPath
-                    tokenizerPath:(NSString *)tokenizerPath;
-
-/**
- Initializes a text LLM runner with the given model and tokenizer paths,
- and a list of special tokens to include in the tokenizer.
-
- @param modelPath      File system path to the serialized model.
- @param tokenizerPath  File system path to the tokenizer data.
- @param specialTokens  An array of NSString special tokens to use during
- tokenization.
- @return An initialized ExecuTorchLLMTextRunner instance.
-*/
-- (instancetype)initWithModelPath:(NSString *)modelPath
-                    tokenizerPath:(NSString *)tokenizerPath
-                    specialTokens:(NSArray<NSString *> *)specialTokens
-    NS_DESIGNATED_INITIALIZER;
-
-/**
- Checks whether the underlying model has been successfully loaded.
-
- @return YES if the model is loaded, NO otherwise.
-*/
-- (BOOL)isLoaded;
-
-/**
- Loads the model into memory, returning an error if loading fails.
-
- @param error   On failure, populated with an NSError explaining the issue.
- @return YES if loading succeeds, NO if an error occurred.
-*/
-- (BOOL)loadWithError:(NSError **)error;
-
-/**
- Generates text given an input prompt. A default configuration
- is created and passed to the configuration block for in-place mutation.
-
- The token callback, if provided, is invoked for each generated token.
-
- @param prompt     The initial text prompt to generate from.
- @param config     A configuration object.
- @param callback   A block called with each generated token as an NSString.
- @param error      On failure, populated with an NSError explaining the issue.
- @return YES if generation completes successfully, NO if an error occurred.
-*/
-- (BOOL)generateWithPrompt:(NSString *)prompt
-                    config:(ExecuTorchLLMConfig *)config
-             tokenCallback:(nullable void (^)(NSString *token))callback
-                     error:(NSError **)error
-    NS_SWIFT_NAME(generate(_:_:tokenCallback:));
-
-/**
- Stop producing new tokens and terminate the current generation process.
-*/
-- (void)stop;
-
-/**
- Remove the prefilled tokens from the KV cache and reset the start position
- to 0. It also clears the stats for previous runs.
-*/
-- (void)reset;
-
-+ (instancetype)new NS_UNAVAILABLE;
-- (instancetype)init NS_UNAVAILABLE;
-
-@end
-
-NS_ASSUME_NONNULL_END
diff --git a/packages/react-native-executorch/third-party/include/executorch/ExecuTorchLLM/module.modulemap b/packages/react-native-executorch/third-party/include/executorch/ExecuTorchLLM/module.modulemap
deleted file mode 100644
index 1d7a0e77aa..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/ExecuTorchLLM/module.modulemap
+++ /dev/null
@@ -1,4 +0,0 @@
-module ExecuTorchLLM {
-  umbrella header "ExecuTorchLLM.h"
-  export *
-}
diff --git a/packages/react-native-executorch/third-party/include/executorch/ExecuTorchLog.h b/packages/react-native-executorch/third-party/include/executorch/ExecuTorchLog.h
deleted file mode 100644
index 17d9f33961..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/ExecuTorchLog.h
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#import <Foundation/Foundation.h>
-
-NS_ASSUME_NONNULL_BEGIN
-
-/**
- * Defines log levels with specific character codes representing each level.
- */
-typedef NS_ENUM(NSInteger, ExecuTorchLogLevel) {
-  ExecuTorchLogLevelDebug = 'D',
-  ExecuTorchLogLevelInfo = 'I',
-  ExecuTorchLogLevelError = 'E',
-  ExecuTorchLogLevelFatal = 'F',
-  ExecuTorchLogLevelUnknown = '?'
-} NS_SWIFT_NAME(LogLevel);
-
-/**
- * A protocol defining the requirements for a log sink to receive log messages.
- */
-NS_SWIFT_NAME(LogSink)
-@protocol ExecuTorchLogSink
-
-/**
- * Logs a message with the specified additional info.
- *
- * @param level The log level of the message.
- * @param timestamp The timestamp of the log message since ExecuTorch PAL start.
- * @param filename The name of the file generating the log message.
- * @param line The line number in the file where the log message was generated.
- * @param message The log message text.
- */
-- (void)logWithLevel:(ExecuTorchLogLevel)level
-           timestamp:(NSTimeInterval)timestamp
-            filename:(NSString *)filename
-                line:(NSUInteger)line
-             message:(NSString *)message
-    NS_SWIFT_NAME(log(level:timestamp:filename:line:message:));
-
-@end
-
-/**
- * A singleton class for managing log sinks and dispatching log messages.
- */
-NS_SWIFT_NAME(Log)
-__attribute__((objc_subclassing_restricted))
-@interface ExecuTorchLog : NSObject
-
-/// The shared singleton log instance.
-@property(class, readonly) ExecuTorchLog *sharedLog;
-
-/**
- * Adds a log sink to receive log messages.
- *
- * @param sink The log sink to add.
- */
-- (void)addSink:(id<ExecuTorchLogSink>)sink NS_SWIFT_NAME(add(sink:));
-
-/**
- * Removes a previously added log sink.
- *
- * @param sink The log sink to remove.
- */
-- (void)removeSink:(id<ExecuTorchLogSink>)sink NS_SWIFT_NAME(remove(sink:));
-
-+ (instancetype)new NS_UNAVAILABLE;
-- (instancetype)init NS_UNAVAILABLE;
-
-@end
-
-NS_ASSUME_NONNULL_END
diff --git a/packages/react-native-executorch/third-party/include/executorch/ExecuTorchModule.h b/packages/react-native-executorch/third-party/include/executorch/ExecuTorchModule.h
deleted file mode 100644
index 51b8abfa68..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/ExecuTorchModule.h
+++ /dev/null
@@ -1,609 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#import "ExecuTorchBackendOption.h"
-#import "ExecuTorchBackendOptionsMap.h"
-#import "ExecuTorchValue.h"
-
-NS_ASSUME_NONNULL_BEGIN
-
-/**
- * Holds the static metadata for a single tensor: its shape, layout,
- * element type, whether its memory was pre-planned by the runtime,
- * and its debug name.
- */
-NS_SWIFT_NAME(TensorMetadata)
-__attribute__((objc_subclassing_restricted))
-@interface ExecuTorchTensorMetadata : NSObject
-
-/** The size of each dimension. */
-@property(nonatomic, readonly) NSArray<NSNumber *> *shape NS_REFINED_FOR_SWIFT;
-
-/** The order in which dimensions are laid out. */
-@property(nonatomic, readonly)
-    NSArray<NSNumber *> *dimensionOrder NS_REFINED_FOR_SWIFT;
-
-/** The scalar type of each element in the tensor. */
-@property(nonatomic, readonly) ExecuTorchDataType dataType;
-
-/** YES if the runtime pre-allocated memory for this tensor. */
-@property(nonatomic, readonly) BOOL isMemoryPlanned;
-
-/** The (optional) user-visible name of this tensor (may be empty) */
-@property(nonatomic, readonly) NSString *name;
-
-+ (instancetype)new NS_UNAVAILABLE;
-- (instancetype)init NS_UNAVAILABLE;
-
-@end
-
-/**
- * Encapsulates all of the metadata for a loaded method: its name,
- * how many inputs/outputs/attributes it has, per-argument tags,
- * per-tensor metadata, buffer sizes, backends, and instruction count.
- */
-NS_SWIFT_NAME(MethodMetadata)
-__attribute__((objc_subclassing_restricted))
-@interface ExecuTorchMethodMetadata : NSObject
-
-/** The method’s name. */
-@property(nonatomic, readonly) NSString *name;
-
-/** An array of ExecuTorchValueTag raw values, one per declared input. */
-@property(nonatomic, readonly)
-    NSArray<NSNumber *> *inputValueTags NS_REFINED_FOR_SWIFT;
-
-/** An array of ExecuTorchValueTag raw values, one per declared output. */
-@property(nonatomic, readonly)
-    NSArray<NSNumber *> *outputValueTags NS_REFINED_FOR_SWIFT;
-
-/**
- * Mapping from input-index to TensorMetadata.
- * Only present for those indices whose tag == .tensor
- */
-@property(nonatomic, readonly)
-    NSDictionary<NSNumber *, ExecuTorchTensorMetadata *> *inputTensorMetadata
-        NS_REFINED_FOR_SWIFT;
-
-/**
- * Mapping from output-index to TensorMetadata.
- * Only present for those indices whose tag == .tensor
- */
-@property(nonatomic, readonly)
-    NSDictionary<NSNumber *, ExecuTorchTensorMetadata *> *outputTensorMetadata
-        NS_REFINED_FOR_SWIFT;
-
-/** A list of attribute TensorsMetadata. */
-@property(nonatomic, readonly)
-    NSArray<ExecuTorchTensorMetadata *> *attributeTensorMetadata;
-
-/** A list of memory-planned buffer sizes. */
-@property(nonatomic, readonly)
-    NSArray<NSNumber *> *memoryPlannedBufferSizes NS_REFINED_FOR_SWIFT;
-
-/** Names of all backends this method can run on. */
-@property(nonatomic, readonly) NSArray<NSString *> *backendNames;
-
-/** Total number of low-level instructions in this method’s body. */
-@property(nonatomic, readonly) NSInteger instructionCount;
-
-+ (instancetype)new NS_UNAVAILABLE;
-- (instancetype)init NS_UNAVAILABLE;
-
-@end
-
-/**
- * Enum to define loading behavior.
- * Values can be a subset, but must numerically match exactly those defined in
- * extension/module/module.h
- */
-typedef NS_ENUM(NSInteger, ExecuTorchModuleLoadMode) {
-  ExecuTorchModuleLoadModeFile = 0,
-  ExecuTorchModuleLoadModeMmap,
-  ExecuTorchModuleLoadModeMmapUseMlock,
-  ExecuTorchModuleLoadModeMmapUseMlockIgnoreErrors,
-} NS_SWIFT_NAME(ModuleLoadMode);
-
-/**
- * Enum to define the verification level used when loading a module.
- * Values can be a subset, but must numerically match exactly those defined in
- * runtime/executor/program.h
- */
-typedef NS_ENUM(uint8_t, ExecuTorchVerification) {
-  ExecuTorchVerificationMinimal,
-  ExecuTorchVerificationInternalConsistency,
-} NS_SWIFT_NAME(ModuleVerification);
-
-/**
- * Represents a module that encapsulates an ExecuTorch program.
- * This class is a facade for loading programs and executing methods within
- * them.
- */
-NS_SWIFT_NAME(Module)
-@interface ExecuTorchModule : NSObject
-
-/**
- * Initializes a module with a file path, data path and a specified load mode.
- *
- * @param filePath A string representing the path to the ExecuTorch program
- * file.
- * @param dataFilePaths A list of strings representing paths to .ptd files with
- * external tensors and external data.
- * @param loadMode A value from ExecuTorchModuleLoadMode that determines the
- * file loading behavior.
- * @return An initialized ExecuTorchModule instance.
- */
-- (instancetype)initWithFilePath:(NSString *)filePath
-                   dataFilePaths:(NSArray<NSString *> *)dataFilePaths
-                        loadMode:(ExecuTorchModuleLoadMode)loadMode
-    NS_DESIGNATED_INITIALIZER;
-
-/**
- * Initializes a module with a file path, data path and a specified load mode.
- *
- * @param filePath A string representing the path to the ExecuTorch program
- * file.
- * @param dataFilePaths A list of strings representing paths to .ptd files with
- * external tensors and external data.
- * @return An initialized ExecuTorchModule instance.
- */
-- (instancetype)initWithFilePath:(NSString *)filePath
-                   dataFilePaths:(NSArray<NSString *> *)dataFilePaths;
-
-/**
- * Initializes a module with a file path and a specified load mode.
- *
- * @param filePath A string representing the path to the ExecuTorch program
- * file.
- * @param loadMode A value from ExecuTorchModuleLoadMode that determines the
- * file loading behavior.
- * @return An initialized ExecuTorchModule instance.
- */
-- (instancetype)initWithFilePath:(NSString *)filePath
-                        loadMode:(ExecuTorchModuleLoadMode)loadMode;
-
-/**
- * Initializes a module with a file path using the default load mode (File
- * mode).
- *
- * @param filePath A string representing the path to the ExecuTorch program
- * file.
- * @return An initialized ExecuTorchModule instance.
- */
-- (instancetype)initWithFilePath:(NSString *)filePath;
-
-/**
- * Loads the module’s program using the specified verification level.
- *
- * @param verification The verification level to apply when loading the program.
- * @param error A pointer to an NSError pointer that will be set if an error
- * occurs.
- * @return YES if the program was successfully loaded; otherwise, NO.
- */
-- (BOOL)loadWithVerification:(ExecuTorchVerification)verification
-                       error:(NSError **)error;
-
-/**
- * Loads the module’s program using minimal verification.
- *
- * This is a convenience overload that defaults the verification level to
- * Minimal.
- *
- * @param error A pointer to an NSError pointer that will be set if an error
- * occurs.
- * @return YES if the program was successfully loaded; otherwise, NO.
- */
-- (BOOL)load:(NSError **)error;
-
-/**
- * Loads the module's program with per-delegate backend options.
- *
- * The receiver retains @c options for as long as the underlying program
- * references it (lifetime tracked via ARC).
- *
- * @param options A `ExecuTorchBackendOptionsMap` containing per-delegate
- *        load-time configuration, built once via
- *        `[ExecuTorchBackendOptionsMap mapWithOptions:error:]`.
- * @param verification The verification level to apply when loading the program.
- * @param error A pointer to an NSError pointer that will be set if an error
- * occurs.
- * @return YES if the program was successfully loaded; otherwise, NO.
- */
-- (BOOL)loadWithOptions:(ExecuTorchBackendOptionsMap *)options
-           verification:(ExecuTorchVerification)verification
-                  error:(NSError **)error NS_REFINED_FOR_SWIFT;
-
-/**
- * Loads the module's program with per-delegate backend options using minimal
- * verification.
- *
- * @param options A `ExecuTorchBackendOptionsMap` containing per-delegate
- *        load-time configuration.
- * @param error A pointer to an NSError pointer that will be set if an error
- * occurs.
- * @return YES if the program was successfully loaded; otherwise, NO.
- */
-- (BOOL)loadWithOptions:(ExecuTorchBackendOptionsMap *)options
-                  error:(NSError **)error NS_REFINED_FOR_SWIFT;
-
-/**
- * Checks if the module is loaded.
- *
- * @return YES if the module's program is loaded; otherwise, NO.
- */
-- (BOOL)isLoaded;
-
-/**
- * Loads a specific method from the program.
- *
- * @param methodName A string representing the name of the method to load.
- * @param error A pointer to an NSError pointer that is set if an error occurs.
- * @return YES if the method was successfully loaded; otherwise, NO.
- */
-- (BOOL)loadMethod:(NSString *)methodName
-             error:(NSError **)error NS_SWIFT_NAME(load(_:));
-
-/**
- * Loads a specific method from the program with per-delegate backend options.
- *
- * @param methodName A string representing the name of the method to load.
- * @param options A `ExecuTorchBackendOptionsMap` containing per-delegate
- *        load-time configuration.
- * @param error A pointer to an NSError pointer that is set if an error occurs.
- * @return YES if the method was successfully loaded; otherwise, NO.
- */
-- (BOOL)loadMethod:(NSString *)methodName
-           options:(ExecuTorchBackendOptionsMap *)options
-             error:(NSError **)error NS_REFINED_FOR_SWIFT;
-
-/**
- * Checks if a specific method is loaded.
- *
- * @param methodName A string representing the method name.
- * @return YES if the method is loaded; otherwise, NO.
- */
-- (BOOL)isMethodLoaded:(NSString *)methodName NS_SWIFT_NAME(isLoaded(_:));
-
-/**
- * Unloads a method and releases its native resources and planned buffers.
- *
- * @param methodName The method to unload.
- * @return YES if the method was unloaded; NO if it was not loaded at all.
- */
-- (BOOL)unloadMethod:(NSString *)methodName NS_SWIFT_NAME(unload(_:));
-
-/**
- * Retrieves the set of method names available in the loaded program.
- *
- * The method names are returned as an unordered set of strings. The program and
- * methods are loaded as needed.
- *
- * @param error A pointer to an NSError pointer that is set if an error occurs.
- * @return An unordered set of method names, or nil in case of an error.
- */
-- (nullable NSSet<NSString *> *)methodNames:(NSError **)error
-    NS_RETURNS_RETAINED;
-
-/**
- * Retrieves full metadata for a particular method in the loaded module.
- *
- * This includes the method’s name, input/output value tags, tensor shapes
- * and layouts, buffer sizes, backend support list, and instruction count.
- *
- * @param methodName A string representing the method name.
- * @param error A pointer to an NSError pointer that is set if an error occurs.
- * @return An ExecuTorchMethodMetadata object on success, or nil if the method
- * isn’t found or a load error occurred.
- */
-- (nullable ExecuTorchMethodMetadata *)methodMetadata:(NSString *)methodName
-                                                error:(NSError **)error
-    NS_RETURNS_RETAINED;
-
-/**
- * Executes a specific method with the provided input values.
- *
- * The method is loaded on demand if not already loaded.
- *
- * @param methodName A string representing the method name.
- * @param values An NSArray of ExecuTorchValue objects representing the inputs.
- * @param error A pointer to an NSError pointer that is set if an error occurs.
- * @return An NSArray of ExecuTorchValue objects representing the outputs, or
- * nil in case of an error.
- */
-- (nullable NSArray<ExecuTorchValue *> *)
-    executeMethod:(NSString *)methodName
-       withInputs:(NSArray<ExecuTorchValue *> *)values
-            error:(NSError **)error NS_REFINED_FOR_SWIFT NS_RETURNS_RETAINED;
-
-/**
- * Executes a specific method with the provided single input value.
- *
- * The method is loaded on demand if not already loaded.
- *
- * @param methodName A string representing the method name.
- * @param value An ExecuTorchValue object representing the input.
- * @param error A pointer to an NSError pointer that is set if an error occurs.
- * @return An NSArray of ExecuTorchValue objects representing the outputs, or
- * nil in case of an error.
- */
-- (nullable NSArray<ExecuTorchValue *> *)executeMethod:(NSString *)methodName
-                                             withInput:(ExecuTorchValue *)value
-                                                 error:(NSError **)error
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Executes a specific method with no input values.
- *
- * The method is loaded on demand if not already loaded.
- *
- * @param methodName A string representing the method name.
- * @param error A pointer to an NSError pointer that is set if an error occurs.
- * @return An NSArray of ExecuTorchValue objects representing the outputs, or
- * nil in case of an error.
- */
-- (nullable NSArray<ExecuTorchValue *> *)executeMethod:(NSString *)methodName
-                                                 error:(NSError **)error
-    NS_SWIFT_NAME(execute(_:)) NS_RETURNS_RETAINED;
-
-/**
- * Executes a specific method with the provided input tensors.
- *
- * The method is loaded on demand if not already loaded.
- *
- * @param methodName A string representing the method name.
- * @param tensors An NSArray of ExecuTorchTensor objects representing the
- * inputs.
- * @param error A pointer to an NSError pointer that is set if an error occurs.
- * @return An NSArray of ExecuTorchValue objects representing the outputs, or
- * nil in case of an error.
- */
-- (nullable NSArray<ExecuTorchValue *> *)
-    executeMethod:(NSString *)methodName
-      withTensors:(NSArray<ExecuTorchTensor *> *)tensors
-            error:(NSError **)error NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Executes a specific method with the provided single input tensor.
- *
- * The method is loaded on demand if not already loaded.
- *
- * @param methodName A string representing the method name.
- * @param tensor An ExecuTorchTensor object representing the input.
- * @param error A pointer to an NSError pointer that is set if an error occurs.
- * @return An NSArray of ExecuTorchValue objects representing the outputs, or
- * nil in case of an error.
- */
-- (nullable NSArray<ExecuTorchValue *> *)executeMethod:(NSString *)methodName
-                                            withTensor:
-                                                (ExecuTorchTensor *)tensor
-                                                 error:(NSError **)error
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Executes the "forward" method with the provided input values.
- *
- * This is a convenience method that calls the executeMethod with "forward" as
- * the method name.
- *
- * @param values An NSArray of ExecuTorchValue objects representing the inputs.
- * @param error A pointer to an NSError pointer that is set if an error occurs.
- * @return An NSArray of ExecuTorchValue objects representing the outputs, or
- * nil in case of an error.
- */
-- (nullable NSArray<ExecuTorchValue *> *)
-    forwardWithInputs:(NSArray<ExecuTorchValue *> *)values
-                error:(NSError **)error
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Executes the "forward" method with the provided single input value.
- *
- * This is a convenience method that calls the executeMethod with "forward" as
- * the method name.
- *
- * @param value An ExecuTorchValue object representing the input.
- * @param error A pointer to an NSError pointer that is set if an error occurs.
- * @return An NSArray of ExecuTorchValue objects representing the outputs, or
- * nil in case of an error.
- */
-- (nullable NSArray<ExecuTorchValue *> *)forwardWithInput:
-                                             (ExecuTorchValue *)value
-                                                    error:(NSError **)error
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Executes the "forward" method with no inputs.
- *
- * This is a convenience method that calls the executeMethod with "forward" as
- * the method name.
- *
- * @param error A pointer to an NSError pointer that is set if an error occurs.
- * @return An NSArray of ExecuTorchValue objects representing the outputs, or
- * nil in case of an error.
- */
-- (nullable NSArray<ExecuTorchValue *> *)forward:(NSError **)error
-    NS_RETURNS_RETAINED;
-
-/**
- * Executes the "forward" method with the provided input tensors.
- *
- * This is a convenience method that calls the executeMethod with "forward" as
- * the method name.
- *
- * @param tensors An NSArray of ExecuTorchTensor objects representing the
- * inputs.
- * @param error A pointer to an NSError pointer that is set if an error occurs.
- * @return An NSArray of ExecuTorchValue objects representing the outputs, or
- * nil in case of an error.
- */
-- (nullable NSArray<ExecuTorchValue *> *)
-    forwardWithTensors:(NSArray<ExecuTorchTensor *> *)tensors
-                 error:(NSError **)error
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Executes the "forward" method with the provided single input tensor.
- *
- * This is a convenience method that calls the executeMethod with "forward" as
- * the method name.
- *
- * @param tensor An ExecuTorchTensor object representing the input.
- * @param error A pointer to an NSError pointer that is set if an error occurs.
- * @return An NSArray of ExecuTorchValue objects representing the outputs, or
- * nil in case of an error.
- */
-- (nullable NSArray<ExecuTorchValue *> *)forwardWithTensor:
-                                             (ExecuTorchTensor *)tensor
-                                                     error:(NSError **)error
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Sets a single input value for the "forward" method at index 0.
- *
- * @param value The input value.
- * @param error On failure, set to an NSError describing the issue.
- * @return YES on success; NO otherwise.
- */
-- (BOOL)setInput:(ExecuTorchValue *)value
-           error:(NSError **)error NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Sets a single input value for the "forward" method at the specified index.
- *
- * @param value The input value.
- * @param index Zero-based input index.
- * @param error On failure, set to an NSError describing the issue.
- * @return YES on success; NO otherwise.
- */
-- (BOOL)setInput:(ExecuTorchValue *)value
-         atIndex:(NSInteger)index
-           error:(NSError **)error NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Sets a single input value for the specified method at index 0.
- *
- * @param value The input value.
- * @param methodName The method name.
- * @param error On failure, set to an NSError describing the issue.
- * @return YES on success; NO otherwise.
- */
-- (BOOL)setInput:(ExecuTorchValue *)value
-       forMethod:(NSString *)methodName
-           error:(NSError **)error NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Sets a single input value for the specified method at the given index.
- *
- * The module retains the provided value to keep its backing storage alive
- * until the value is overwritten or the module is deallocated.
- *
- * @param value The input value.
- * @param methodName The method name.
- * @param index Zero-based input index.
- * @param error On failure, set to an NSError describing the issue.
- * @return YES on success; NO otherwise.
- */
-- (BOOL)setInput:(ExecuTorchValue *)value
-       forMethod:(NSString *)methodName
-         atIndex:(NSInteger)index
-           error:(NSError **)error NS_REFINED_FOR_SWIFT;
-
-/**
- * Sets all input values for the "forward" method.
- *
- * The number and types of values must match the method’s declared inputs.
- *
- * @param values The input values, one per declared input.
- * @param error On failure, set to an NSError describing the issue.
- * @return YES on success; NO otherwise.
- */
-- (BOOL)setInputs:(NSArray<ExecuTorchValue *> *)values
-            error:(NSError **)error NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Sets all input values for the specified method.
- *
- * The module retains the provided values to keep their backing storage alive
- * until the values are overwritten or the module is deallocated.
- *
- * @param values The input values, one per declared input.
- * @param methodName The method name.
- * @param error On failure, set to an NSError describing the issue.
- * @return YES on success; NO otherwise.
- */
-- (BOOL)setInputs:(NSArray<ExecuTorchValue *> *)values
-        forMethod:(NSString *)methodName
-            error:(NSError **)error NS_REFINED_FOR_SWIFT;
-
-/**
- * Sets the output buffer for the "forward" method at index 0.
- *
- * Only tensor outputs are supported. The provided value must wrap a tensor
- * compatible with the method’s output slot.
- *
- * @param value The output buffer (must wrap a tensor).
- * @param error On failure, set to an NSError describing the issue.
- * @return YES on success; NO otherwise.
- */
-- (BOOL)setOutput:(ExecuTorchValue *)value
-            error:(NSError **)error NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Sets the output buffer for the "forward" method at the specified index.
- *
- * Only tensor outputs are supported. The provided value must wrap a tensor
- * compatible with the method’s output slot.
- *
- * @param value The output buffer (must wrap a tensor).
- * @param index Zero-based output index.
- * @param error On failure, set to an NSError describing the issue.
- * @return YES on success; NO otherwise.
- */
-- (BOOL)setOutput:(ExecuTorchValue *)value
-          atIndex:(NSInteger)index
-            error:(NSError **)error NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Sets the output buffer for the specified method at index 0.
- *
- * Only tensor outputs are supported. The provided value must wrap a tensor
- * compatible with the method’s output slot.
- *
- * @param value The output buffer (must wrap a tensor).
- * @param methodName The method name.
- * @param error On failure, set to an NSError describing the issue.
- * @return YES on success; NO otherwise.
- */
-- (BOOL)setOutput:(ExecuTorchValue *)value
-        forMethod:(NSString *)methodName
-            error:(NSError **)error NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Sets the output buffer for the specified method at the given index.
- *
- * The module retains the provided value to keep its backing storage alive
- * until the value is overwritten or the module is deallocated.
- * Only tensor outputs are supported.
- *
- * @param value The output buffer (must wrap a tensor).
- * @param methodName The method name.
- * @param index Zero-based output index.
- * @param error On failure, set to an NSError describing the issue.
- * @return YES on success; NO otherwise.
- */
-- (BOOL)setOutput:(ExecuTorchValue *)value
-        forMethod:(NSString *)methodName
-          atIndex:(NSInteger)index
-            error:(NSError **)error NS_REFINED_FOR_SWIFT;
-
-+ (instancetype)new NS_UNAVAILABLE;
-- (instancetype)init NS_UNAVAILABLE;
-
-@end
-
-NS_ASSUME_NONNULL_END
diff --git a/packages/react-native-executorch/third-party/include/executorch/ExecuTorchTensor.h b/packages/react-native-executorch/third-party/include/executorch/ExecuTorchTensor.h
deleted file mode 100644
index 6f4ab4bdce..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/ExecuTorchTensor.h
+++ /dev/null
@@ -1,1461 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#import <Foundation/Foundation.h>
-
-NS_ASSUME_NONNULL_BEGIN
-
-/**
- * Enum to define the data type of a Tensor.
- * Values can be a subset, but must numerically match exactly those defined in
- * runtime/core/portable_type/scalar_type.h
- */
-typedef NS_ENUM(int8_t, ExecuTorchDataType) {
-  ExecuTorchDataTypeByte,
-  ExecuTorchDataTypeChar,
-  ExecuTorchDataTypeShort,
-  ExecuTorchDataTypeInt,
-  ExecuTorchDataTypeLong,
-  ExecuTorchDataTypeHalf,
-  ExecuTorchDataTypeFloat,
-  ExecuTorchDataTypeDouble,
-  ExecuTorchDataTypeComplexHalf,
-  ExecuTorchDataTypeComplexFloat,
-  ExecuTorchDataTypeComplexDouble,
-  ExecuTorchDataTypeBool,
-  ExecuTorchDataTypeQInt8,
-  ExecuTorchDataTypeQUInt8,
-  ExecuTorchDataTypeQInt32,
-  ExecuTorchDataTypeBFloat16,
-  ExecuTorchDataTypeQUInt4x2,
-  ExecuTorchDataTypeQUInt2x4,
-  ExecuTorchDataTypeBits1x8,
-  ExecuTorchDataTypeBits2x4,
-  ExecuTorchDataTypeBits4x2,
-  ExecuTorchDataTypeBits8,
-  ExecuTorchDataTypeBits16,
-  ExecuTorchDataTypeFloat8_e5m2,
-  ExecuTorchDataTypeFloat8_e4m3fn,
-  ExecuTorchDataTypeFloat8_e5m2fnuz,
-  ExecuTorchDataTypeFloat8_e4m3fnuz,
-  ExecuTorchDataTypeUInt16,
-  ExecuTorchDataTypeUInt32,
-  ExecuTorchDataTypeUInt64,
-  ExecuTorchDataTypeUndefined,
-  ExecuTorchDataTypeNumOptions,
-} NS_SWIFT_NAME(DataType);
-
-/**
- * Enum to define the shape dynamism of a Tensor.
- * Values can be a subset, but must numerically match exactly those defined in
- * runtime/core/tensor_shape_dynamism.h
- */
-typedef NS_ENUM(uint8_t, ExecuTorchShapeDynamism) {
-  ExecuTorchShapeDynamismStatic,
-  ExecuTorchShapeDynamismDynamicBound,
-  ExecuTorchShapeDynamismDynamicUnbound,
-} NS_SWIFT_NAME(ShapeDynamism);
-
-/**
- * Returns the size in bytes of the specified data type.
- *
- * @param dataType An ExecuTorchDataType value representing the tensor's element
- * type.
- * @return An NSInteger indicating the size in bytes.
- */
-FOUNDATION_EXPORT
-NSInteger ExecuTorchSizeOfDataType(ExecuTorchDataType dataType)
-    NS_SWIFT_NAME(size(ofDataType:));
-
-/**
- * Computes the total number of elements in a tensor based on its shape.
- *
- * @param shape An NSArray of NSNumber objects, where each element represents a
- * dimension size.
- * @return An NSInteger equal to the product of the sizes of all dimensions.
- */
-FOUNDATION_EXPORT
-NSInteger
-ExecuTorchElementCountOfShape(NSArray<NSNumber *> *shape) NS_REFINED_FOR_SWIFT;
-
-/**
- * A tensor class for ExecuTorch operations.
- *
- * This class encapsulates a native TensorPtr instance and provides a variety of
- * initializers and utility methods to work with tensor data.
- */
-NS_SWIFT_NAME(AnyTensor)
-__attribute__((objc_subclassing_restricted))
-@interface ExecuTorchTensor : NSObject<NSCopying>
-
-/**
- * Pointer to the underlying native TensorPtr instance.
- *
- * @return A raw pointer to the native TensorPtr held by this Tensor class.
- */
-@property(nonatomic, readonly) void *nativeInstance NS_SWIFT_UNAVAILABLE("");
-
-/**
- * The data type of the tensor.
- *
- * @return An ExecuTorchDataType value representing the tensor's element type.
- */
-@property(nonatomic, readonly) ExecuTorchDataType dataType;
-
-/**
- * The shape of the tensor.
- *
- * @return An NSArray of NSNumber objects representing the size of each
- * dimension.
- */
-@property(nonatomic, readonly) NSArray<NSNumber *> *shape NS_REFINED_FOR_SWIFT;
-
-/**
- * The order of dimensions in the tensor.
- *
- * @return An NSArray of NSNumber objects representing the tensor’s dimension
- * order.
- */
-@property(nonatomic, readonly)
-    NSArray<NSNumber *> *dimensionOrder NS_REFINED_FOR_SWIFT;
-
-/**
- * The strides of the tensor.
- *
- * @return An NSArray of NSNumber objects representing the step sizes for each
- * dimension.
- */
-@property(nonatomic, readonly)
-    NSArray<NSNumber *> *strides NS_REFINED_FOR_SWIFT;
-
-/**
- * The dynamism of the tensor's shape.
- *
- * @return An ExecuTorchShapeDynamism value indicating whether the tensor shape
- * is static or dynamic.
- */
-@property(nonatomic, readonly) ExecuTorchShapeDynamism shapeDynamism;
-
-/**
- * The total number of elements in the tensor.
- *
- * @return An NSInteger representing the total element count.
- */
-@property(nonatomic, readonly) NSInteger count NS_REFINED_FOR_SWIFT;
-
-/**
- * Initializes a tensor with a native TensorPtr instance.
- *
- * @param nativeInstance A pointer to a native TensorPtr instance.
- * @return An initialized ExecuTorchTensor instance.
- */
-- (instancetype)initWithNativeInstance:(void *)nativeInstance
-    NS_DESIGNATED_INITIALIZER NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Creates a new tensor that shares the underlying data storage with the
- * given tensor, with metadata overrides. An empty array for
- * a parameter signifies that it should be inherited or derived.
- *
- * @param otherTensor The tensor instance to create a view of.
- * @param shape An override for the tensor's shape.
- * @param dimensionOrder An override for the tensor's dimension order.
- * @param strides An override for the tensor's strides.
- * @return A new ExecuTorchTensor instance that shares data with otherTensor.
- */
-- (instancetype)initWithTensor:(ExecuTorchTensor *)otherTensor
-                         shape:(NSArray<NSNumber *> *)shape
-                dimensionOrder:(NSArray<NSNumber *> *)dimensionOrder
-                       strides:(NSArray<NSNumber *> *)strides
-    NS_REFINED_FOR_SWIFT;
-
-/**
- * Creates a new tensor that shares the underlying data storage with the
- * given tensor, with an overridden shape.
- *
- * @param otherTensor The tensor instance to create a view of.
- * @param shape An override for the tensor's shape.
- * @return A new ExecuTorchTensor instance that shares data with otherTensor.
- */
-- (instancetype)initWithTensor:(ExecuTorchTensor *)otherTensor
-                         shape:(NSArray<NSNumber *> *)shape
-    NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Creates a new tensor that shares the underlying data storage with the
- * given tensor. This new tensor is a view and does not own the data.
- *
- * @param otherTensor The tensor instance to create a view of.
- * @return A new ExecuTorchTensor instance that shares data with otherTensor.
- */
-- (instancetype)initWithTensor:(ExecuTorchTensor *)otherTensor
-    NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Creates a deep copy of the tensor.
- * The new tensor will have its own copy of the data.
- *
- * @return A new ExecuTorchTensor instance that is a duplicate of the current
- * tensor.
- */
-- (instancetype)copy;
-
-/**
- * Creates a deep copy of the tensor, potentially casting to a new data type.
- * The new tensor will have its own copy of the data.
- *
- * @param dataType The desired data type for the new tensor.
- * @return A new ExecuTorchTensor instance that is a duplicate (and possibly
-casted) of the current tensor.
-*/
-- (instancetype)copyToDataType:(ExecuTorchDataType)dataType
-    NS_SWIFT_NAME(copy(to:));
-
-/**
- * Executes a block with a pointer to the tensor's immutable byte data.
- *
- * @param handler A block that receives:
- *   - a pointer to the data,
- *   - the total number of elements,
- *   - and the data type.
- */
-- (void)bytesWithHandler:
-    (NS_NOESCAPE void (^)(const void *pointer, NSInteger count,
-                          ExecuTorchDataType dataType))handler
-    NS_SWIFT_NAME(bytes(_:));
-
-/**
- * Executes a block with a pointer to the tensor's mutable byte data.
- *
- * @param handler A block that receives:
- *   - a mutable pointer to the data,
- *   - the total number of elements,
- *   - and the data type.
- */
-- (void)mutableBytesWithHandler:
-    (NS_NOESCAPE void (^)(void *pointer, NSInteger count,
-                          ExecuTorchDataType dataType))handler
-    NS_SWIFT_NAME(mutableBytes(_:));
-
-/**
- * Resizes the tensor to a new shape.
- *
- * @param shape An NSArray of NSNumber objects representing the desired new
- * shape.
- * @param error A pointer to an NSError pointer that is set if an error occurs.
- * @return YES if the tensor was successfully resized; otherwise, NO.
- */
-- (BOOL)resizeToShape:(NSArray<NSNumber *> *)shape
-                error:(NSError **)error NS_REFINED_FOR_SWIFT;
-
-/**
- * Determines whether the current tensor is equal to another tensor.
- *
- * @param other Another ExecuTorchTensor instance to compare against.
- * @return YES if the tensors have the same data type, shape, dimension order,
- * strides, and underlying data; otherwise, NO.
- */
-- (BOOL)isEqualToTensor:(nullable ExecuTorchTensor *)other NS_REFINED_FOR_SWIFT;
-
-+ (instancetype)new NS_UNAVAILABLE;
-- (instancetype)init NS_UNAVAILABLE;
-
-@end
-
-#pragma mark - BytesNoCopy Category
-
-@interface ExecuTorchTensor (BytesNoCopy)
-
-/**
- * Initializes a tensor without copying the provided data.
- *
- * @param pointer A pointer to the data buffer.
- * @param shape An NSArray of NSNumber objects representing the tensor's shape.
- * @param strides An NSArray of NSNumber objects representing the tensor's
- * strides.
- * @param dimensionOrder An NSArray of NSNumber objects indicating the order of
- * dimensions.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value indicating whether the
- * shape is static or dynamic.
- * @return An initialized ExecuTorchTensor instance using the provided data
- * buffer.
- */
-- (instancetype)initWithBytesNoCopy:(void *)pointer
-                              shape:(NSArray<NSNumber *> *)shape
-                            strides:(NSArray<NSNumber *> *)strides
-                     dimensionOrder:(NSArray<NSNumber *> *)dimensionOrder
-                           dataType:(ExecuTorchDataType)dataType
-                      shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism
-    NS_REFINED_FOR_SWIFT;
-
-/**
- * Initializes a tensor without copying data using dynamic bound shape (default
- * strides and dimension order).
- *
- * @param pointer A pointer to the data buffer.
- * @param shape An NSArray of NSNumber objects representing the tensor's shape.
- * @param strides An NSArray of NSNumber objects representing the tensor's
- * strides.
- * @param dimensionOrder An NSArray of NSNumber objects indicating the order of
- * dimensions.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @return An initialized ExecuTorchTensor instance.
- */
-- (instancetype)initWithBytesNoCopy:(void *)pointer
-                              shape:(NSArray<NSNumber *> *)shape
-                            strides:(NSArray<NSNumber *> *)strides
-                     dimensionOrder:(NSArray<NSNumber *> *)dimensionOrder
-                           dataType:(ExecuTorchDataType)dataType
-    NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Initializes a tensor without copying data, with an explicit shape dynamism.
- *
- * @param pointer A pointer to the data buffer.
- * @param shape An NSArray of NSNumber objects representing the tensor's shape.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value indicating the shape
- * dynamism.
- * @return An initialized ExecuTorchTensor instance.
- */
-- (instancetype)initWithBytesNoCopy:(void *)pointer
-                              shape:(NSArray<NSNumber *> *)shape
-                           dataType:(ExecuTorchDataType)dataType
-                      shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism
-    NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Initializes a tensor without copying data, specifying only the shape and data
- * type.
- *
- * @param pointer A pointer to the data buffer.
- * @param shape An NSArray of NSNumber objects representing the tensor's shape.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @return An initialized ExecuTorchTensor instance.
- */
-- (instancetype)initWithBytesNoCopy:(void *)pointer
-                              shape:(NSArray<NSNumber *> *)shape
-                           dataType:(ExecuTorchDataType)dataType
-    NS_SWIFT_UNAVAILABLE("");
-
-@end
-
-#pragma mark - Bytes Category
-
-@interface ExecuTorchTensor (Bytes)
-
-/**
- * Initializes a tensor by copying bytes from the provided pointer.
- *
- * @param pointer A pointer to the source data buffer.
- * @param shape An NSArray of NSNumber objects representing the tensor's shape.
- * @param strides An NSArray of NSNumber objects representing the tensor's
- * strides.
- * @param dimensionOrder An NSArray of NSNumber objects indicating the order of
- * dimensions.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value indicating the shape
- * dynamism.
- * @return An initialized ExecuTorchTensor instance with its own copy of the
- * data.
- */
-- (instancetype)initWithBytes:(const void *)pointer
-                        shape:(NSArray<NSNumber *> *)shape
-                      strides:(NSArray<NSNumber *> *)strides
-               dimensionOrder:(NSArray<NSNumber *> *)dimensionOrder
-                     dataType:(ExecuTorchDataType)dataType
-                shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism
-    NS_REFINED_FOR_SWIFT;
-
-/**
- * Initializes a tensor by copying bytes from the provided pointer with dynamic
- * bound shape.
- *
- * @param pointer A pointer to the source data buffer.
- * @param shape An NSArray of NSNumber objects representing the tensor's shape.
- * @param strides An NSArray of NSNumber objects representing the tensor's
- * strides.
- * @param dimensionOrder An NSArray of NSNumber objects indicating the order of
- * dimensions.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @return An initialized ExecuTorchTensor instance with its own copy of the
- * data.
- */
-- (instancetype)initWithBytes:(const void *)pointer
-                        shape:(NSArray<NSNumber *> *)shape
-                      strides:(NSArray<NSNumber *> *)strides
-               dimensionOrder:(NSArray<NSNumber *> *)dimensionOrder
-                     dataType:(ExecuTorchDataType)dataType
-    NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Initializes a tensor by copying bytes from the provided pointer, specifying
- * shape, data type, and explicit shape dynamism.
- *
- * @param pointer A pointer to the source data buffer.
- * @param shape An NSArray of NSNumber objects representing the tensor's shape.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value indicating the shape
- * dynamism.
- * @return An initialized ExecuTorchTensor instance with its own copy of the
- * data.
- */
-- (instancetype)initWithBytes:(const void *)pointer
-                        shape:(NSArray<NSNumber *> *)shape
-                     dataType:(ExecuTorchDataType)dataType
-                shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism
-    NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Initializes a tensor by copying bytes from the provided pointer, specifying
- * only the shape and data type.
- *
- * @param pointer A pointer to the source data buffer.
- * @param shape An NSArray of NSNumber objects representing the tensor's shape.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @return An initialized ExecuTorchTensor instance with its own copy of the
- * data.
- */
-- (instancetype)initWithBytes:(const void *)pointer
-                        shape:(NSArray<NSNumber *> *)shape
-                     dataType:(ExecuTorchDataType)dataType
-    NS_SWIFT_UNAVAILABLE("");
-
-@end
-
-#pragma mark - Data Category
-
-@interface ExecuTorchTensor (Data)
-
-/**
- * Initializes a tensor using an NSData object. The tensor will hold a
- * strong reference to the NSData object to manage the lifetime of the
- * underlying data buffer, which is not copied.
- *
- * @param data An NSData object containing the tensor data.
- * @param shape An NSArray of NSNumber objects representing the tensor's shape.
- * @param strides An NSArray of NSNumber objects representing the tensor's
- * strides.
- * @param dimensionOrder An NSArray of NSNumber objects indicating the order of
- * dimensions.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value indicating the shape
- * dynamism.
- * @return An initialized ExecuTorchTensor instance using the provided data.
- */
-- (instancetype)initWithData:(NSData *)data
-                       shape:(NSArray<NSNumber *> *)shape
-                     strides:(NSArray<NSNumber *> *)strides
-              dimensionOrder:(NSArray<NSNumber *> *)dimensionOrder
-                    dataType:(ExecuTorchDataType)dataType
-               shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism
-    NS_REFINED_FOR_SWIFT;
-
-/**
- * Initializes a tensor using an NSData object as the underlying data buffer
- * with dynamic bound shape.
- *
- * @param data An NSData object containing the tensor data.
- * @param shape An NSArray of NSNumber objects representing the tensor's shape.
- * @param strides An NSArray of NSNumber objects representing the tensor's
- * strides.
- * @param dimensionOrder An NSArray of NSNumber objects indicating the order of
- * dimensions.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @return An initialized ExecuTorchTensor instance using the provided data.
- */
-- (instancetype)initWithData:(NSData *)data
-                       shape:(NSArray<NSNumber *> *)shape
-                     strides:(NSArray<NSNumber *> *)strides
-              dimensionOrder:(NSArray<NSNumber *> *)dimensionOrder
-                    dataType:(ExecuTorchDataType)dataType
-    NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Initializes a tensor using an NSData object as the underlying data buffer,
- * specifying shape, data type, and explicit shape dynamism.
- *
- * @param data An NSData object containing the tensor data.
- * @param shape An NSArray of NSNumber objects representing the tensor's shape.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value indicating the shape
- * dynamism.
- * @return An initialized ExecuTorchTensor instance using the provided data.
- */
-- (instancetype)initWithData:(NSData *)data
-                       shape:(NSArray<NSNumber *> *)shape
-                    dataType:(ExecuTorchDataType)dataType
-               shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism
-    NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Initializes a tensor using an NSData object as the underlying data buffer,
- * specifying only the shape and data type.
- *
- * @param data An NSData object containing the tensor data.
- * @param shape An NSArray of NSNumber objects representing the tensor's shape.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @return An initialized ExecuTorchTensor instance using the provided data.
- */
-- (instancetype)initWithData:(NSData *)data
-                       shape:(NSArray<NSNumber *> *)shape
-                    dataType:(ExecuTorchDataType)dataType
-    NS_SWIFT_UNAVAILABLE("");
-
-@end
-
-#pragma mark - Scalars Category
-
-@interface ExecuTorchTensor (Scalars)
-
-/**
- * Initializes a tensor with an array of scalar values and full tensor
- * properties.
- *
- * @param scalars An NSArray of NSNumber objects representing the scalar values.
- * @param shape An NSArray of NSNumber objects representing the desired tensor
- * shape.
- * @param strides An NSArray of NSNumber objects representing the tensor
- * strides.
- * @param dimensionOrder An NSArray of NSNumber objects indicating the order of
- * dimensions.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value indicating the shape
- * dynamism.
- * @return An initialized ExecuTorchTensor instance containing the provided
- * scalar values.
- */
-- (instancetype)initWithScalars:(NSArray<NSNumber *> *)scalars
-                          shape:(NSArray<NSNumber *> *)shape
-                        strides:(NSArray<NSNumber *> *)strides
-                 dimensionOrder:(NSArray<NSNumber *> *)dimensionOrder
-                       dataType:(ExecuTorchDataType)dataType
-                  shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism
-    NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Initializes a tensor with an array of scalar values, specifying shape,
- * strides, dimension order, and data type, using a default dynamic bound shape
- * for shape dynamism.
- *
- * @param scalars An NSArray of NSNumber objects representing the scalar values.
- * @param shape An NSArray of NSNumber objects representing the desired tensor
- * shape.
- * @param strides An NSArray of NSNumber objects representing the tensor
- * strides.
- * @param dimensionOrder An NSArray of NSNumber objects indicating the order of
- * dimensions.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @return An initialized ExecuTorchTensor instance containing the scalar
- * values.
- */
-- (instancetype)initWithScalars:(NSArray<NSNumber *> *)scalars
-                          shape:(NSArray<NSNumber *> *)shape
-                        strides:(NSArray<NSNumber *> *)strides
-                 dimensionOrder:(NSArray<NSNumber *> *)dimensionOrder
-                       dataType:(ExecuTorchDataType)dataType
-    NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Initializes a tensor with an array of scalar values, specifying the desired
- * shape, data type, and explicit shape dynamism.
- *
- * @param scalars An NSArray of NSNumber objects representing the scalar values.
- * @param shape An NSArray of NSNumber objects representing the desired tensor
- * shape.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value indicating the shape
- * dynamism.
- * @return An initialized ExecuTorchTensor instance.
- */
-- (instancetype)initWithScalars:(NSArray<NSNumber *> *)scalars
-                          shape:(NSArray<NSNumber *> *)shape
-                       dataType:(ExecuTorchDataType)dataType
-                  shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism
-    NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Initializes a tensor with an array of scalar values and a specified shape,
- * using a default dynamic bound shape for shape dynamism.
- *
- * @param scalars An NSArray of NSNumber objects representing the scalar values.
- * @param shape An NSArray of NSNumber objects representing the desired tensor
- * shape.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @return An initialized ExecuTorchTensor instance.
- */
-- (instancetype)initWithScalars:(NSArray<NSNumber *> *)scalars
-                          shape:(NSArray<NSNumber *> *)shape
-                       dataType:(ExecuTorchDataType)dataType
-    NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Initializes a tensor with an array of scalar values, specifying the tensor
- * data type and explicit shape dynamism. The shape is deduced from the count of
- * the scalar array.
- *
- * @param scalars An NSArray of NSNumber objects representing the scalar values.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value indicating the shape
- * dynamism.
- * @return An initialized ExecuTorchTensor instance with the shape deduced from
- * the scalar count.
- */
-- (instancetype)initWithScalars:(NSArray<NSNumber *> *)scalars
-                       dataType:(ExecuTorchDataType)dataType
-                  shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism
-    NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Initializes a tensor with an array of scalar values, specifying the tensor
- * data type. The shape is deduced from the count of the scalar array.
- *
- * @param scalars An NSArray of NSNumber objects representing the scalar values.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @return An initialized ExecuTorchTensor instance with the shape deduced from
- * the scalar count.
- */
-- (instancetype)initWithScalars:(NSArray<NSNumber *> *)scalars
-                       dataType:(ExecuTorchDataType)dataType
-    NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Initializes a tensor with an array of scalar values, a specified shape and
- * explicit shape dynamism. The data type is automatically deduced from the
- * first element of the array.
- *
- * @param scalars An NSArray of NSNumber objects representing the scalar values.
- * @param shape An NSArray of NSNumber objects representing the desired tensor
- * shape.
- * @param shapeDynamism An ExecuTorchShapeDynamism value indicating the shape
- * dynamism.
- * @return An initialized ExecuTorchTensor instance.
- */
-- (instancetype)initWithScalars:(NSArray<NSNumber *> *)scalars
-                          shape:(NSArray<NSNumber *> *)shape
-                  shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism
-    NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Initializes a tensor with an array of scalar values and a specified shape.
- * The data type is automatically deduced from the first element of the array.
- *
- * @param scalars An NSArray of NSNumber objects representing the scalar values.
- * @param shape An NSArray of NSNumber objects representing the desired tensor
- * shape.
- * @return An initialized ExecuTorchTensor instance.
- */
-- (instancetype)initWithScalars:(NSArray<NSNumber *> *)scalars
-                          shape:(NSArray<NSNumber *> *)shape
-    NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Initializes a tensor with an array of scalar values, automatically deducing
- * the tensor shape and data type.
- *
- * @param scalars An NSArray of NSNumber objects representing the scalar values.
- * @return An initialized ExecuTorchTensor instance with shape and data type
- * deduced.
- */
-- (instancetype)initWithScalars:(NSArray<NSNumber *> *)scalars
-    NS_SWIFT_UNAVAILABLE("");
-
-@end
-
-@interface ExecuTorchTensor (Scalar)
-
-/**
- * Initializes a tensor with a single scalar value and a specified data type.
- *
- * @param scalar An NSNumber representing the scalar value.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @return An initialized ExecuTorchTensor instance representing the scalar.
- */
-- (instancetype)initWithScalar:(NSNumber *)scalar
-                      dataType:(ExecuTorchDataType)dataType
-    NS_REFINED_FOR_SWIFT;
-
-/**
- * Initializes a tensor with a single scalar value, automatically deducing its
- * data type.
- *
- * @param scalar An NSNumber representing the scalar value.
- * @return An initialized ExecuTorchTensor instance representing the scalar.
- */
-- (instancetype)initWithScalar:(NSNumber *)scalar NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Initializes a tensor with a byte scalar value.
- *
- * @param scalar A uint8_t value.
- * @return An initialized ExecuTorchTensor instance.
- */
-- (instancetype)initWithByte:(uint8_t)scalar NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Initializes a tensor with a char scalar value.
- *
- * @param scalar An int8_t value.
- * @return An initialized ExecuTorchTensor instance.
- */
-- (instancetype)initWithChar:(int8_t)scalar NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Initializes a tensor with a short scalar value.
- *
- * @param scalar An int16_t value.
- * @return An initialized ExecuTorchTensor instance.
- */
-- (instancetype)initWithShort:(int16_t)scalar NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Initializes a tensor with an int scalar value.
- *
- * @param scalar An int32_t value.
- * @return An initialized ExecuTorchTensor instance.
- */
-- (instancetype)initWithInt:(int32_t)scalar NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Initializes a tensor with a long scalar value.
- *
- * @param scalar An int64_t value.
- * @return An initialized ExecuTorchTensor instance.
- */
-- (instancetype)initWithLong:(int64_t)scalar NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Initializes a tensor with a float scalar value.
- *
- * @param scalar A float value.
- * @return An initialized ExecuTorchTensor instance.
- */
-- (instancetype)initWithFloat:(float)scalar NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Initializes a tensor with a double scalar value.
- *
- * @param scalar A double value.
- * @return An initialized ExecuTorchTensor instance.
- */
-- (instancetype)initWithDouble:(double)scalar NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Initializes a tensor with a boolean scalar value.
- *
- * @param scalar A BOOL value.
- * @return An initialized ExecuTorchTensor instance.
- */
-- (instancetype)initWithBool:(BOOL)scalar NS_SWIFT_UNAVAILABLE("");
-
-/**
- * Initializes a tensor with a uint16 scalar value.
- *
- * @param scalar A uint16_t value.
- * @return An initialized ExecuTorchTensor instance.
- */
-- (instancetype)initWithUInt16:(uint16_t)scalar NS_SWIFT_NAME(init(_:));
-
-/**
- * Initializes a tensor with a uint32 scalar value.
- *
- * @param scalar A uint32_t value.
- * @return An initialized ExecuTorchTensor instance.
- */
-- (instancetype)initWithUInt32:(uint32_t)scalar NS_SWIFT_NAME(init(_:));
-
-/**
- * Initializes a tensor with a uint64 scalar value.
- *
- * @param scalar A uint64_t value.
- * @return An initialized ExecuTorchTensor instance.
- */
-- (instancetype)initWithUInt64:(uint64_t)scalar NS_SWIFT_NAME(init(_:));
-
-/**
- * Initializes a tensor with an NSInteger scalar value.
- *
- * @param scalar An NSInteger value.
- * @return An initialized ExecuTorchTensor instance.
- */
-- (instancetype)initWithInteger:(NSInteger)scalar NS_SWIFT_NAME(init(_:));
-
-/**
- * Initializes a tensor with an NSUInteger scalar value.
- *
- * @param scalar An NSUInteger value.
- * @return An initialized ExecuTorchTensor instance.
- */
-- (instancetype)initWithUnsignedInteger:(NSUInteger)scalar
-    NS_SWIFT_NAME(init(_:));
-
-@end
-
-#pragma mark - Empty Category
-
-@interface ExecuTorchTensor (Empty)
-
-/**
- * Creates an empty tensor with the specified shape, strides, data type, and
- * shape dynamism.
- *
- * @param shape An NSArray of NSNumber objects representing the desired shape.
- * @param strides An NSArray of NSNumber objects representing the desired
- * strides.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the
- * shape is static or dynamic.
- * @return A new, empty ExecuTorchTensor instance.
- */
-+ (instancetype)emptyTensorWithShape:(NSArray<NSNumber *> *)shape
-                             strides:(NSArray<NSNumber *> *)strides
-                            dataType:(ExecuTorchDataType)dataType
-                       shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism
-    NS_REFINED_FOR_SWIFT NS_RETURNS_RETAINED;
-
-/**
- * Creates an empty tensor with the specified shape, data type, and shape
- * dynamism.
- *
- * @param shape An NSArray of NSNumber objects representing the desired shape.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the
- * shape is static or dynamic.
- * @return A new, empty ExecuTorchTensor instance.
- */
-+ (instancetype)emptyTensorWithShape:(NSArray<NSNumber *> *)shape
-                            dataType:(ExecuTorchDataType)dataType
-                       shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Creates an empty tensor with the specified shape and data type, using dynamic
- * bound shape.
- *
- * @param shape An NSArray of NSNumber objects representing the desired shape.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @return A new, empty ExecuTorchTensor instance.
- */
-+ (instancetype)emptyTensorWithShape:(NSArray<NSNumber *> *)shape
-                            dataType:(ExecuTorchDataType)dataType
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Creates an empty tensor similar to the given tensor, with the specified data
- * type and shape dynamism.
- *
- * @param tensor An existing ExecuTorchTensor instance whose shape and strides
- * are used.
- * @param dataType An ExecuTorchDataType value specifying the desired element
- * type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the
- * shape is static or dynamic.
- * @return A new, empty ExecuTorchTensor instance with the same shape as the
- * provided tensor.
- */
-+ (instancetype)emptyTensorLikeTensor:(ExecuTorchTensor *)tensor
-                             dataType:(ExecuTorchDataType)dataType
-                        shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism
-    NS_REFINED_FOR_SWIFT NS_RETURNS_RETAINED;
-
-/**
- * Creates an empty tensor similar to the given tensor, with the specified data
- * type.
- *
- * @param tensor An existing ExecuTorchTensor instance whose shape and strides
- * are used.
- * @param dataType An ExecuTorchDataType value specifying the desired element
- * type.
- * @return A new, empty ExecuTorchTensor instance with the same shape as the
- * provided tensor.
- */
-+ (instancetype)emptyTensorLikeTensor:(ExecuTorchTensor *)tensor
-                             dataType:(ExecuTorchDataType)dataType
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Creates an empty tensor similar to the given tensor.
- *
- * @param tensor An existing ExecuTorchTensor instance.
- * @return A new, empty ExecuTorchTensor instance with the same properties as
- * the provided tensor.
- */
-+ (instancetype)emptyTensorLikeTensor:(ExecuTorchTensor *)tensor
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-@end
-
-#pragma mark - Full Category
-
-@interface ExecuTorchTensor (Full)
-
-/**
- * Creates a tensor filled with the specified scalar value, with full
- * specification of shape, strides, data type, and shape dynamism.
- *
- * @param shape An NSArray of NSNumber objects representing the desired shape.
- * @param scalar An NSNumber representing the value to fill the tensor.
- * @param strides An NSArray of NSNumber objects representing the desired
- * strides.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the
- * shape is static or dynamic.
- * @return A new ExecuTorchTensor instance filled with the scalar value.
- */
-+ (instancetype)fullTensorWithShape:(NSArray<NSNumber *> *)shape
-                             scalar:(NSNumber *)scalar
-                            strides:(NSArray<NSNumber *> *)strides
-                           dataType:(ExecuTorchDataType)dataType
-                      shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism
-    NS_REFINED_FOR_SWIFT NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor filled with the specified scalar value, with the given
- * shape, data type, and shape dynamism.
- *
- * @param shape An NSArray of NSNumber objects representing the desired shape.
- * @param scalar An NSNumber representing the value to fill the tensor.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the
- * shape is static or dynamic.
- * @return A new ExecuTorchTensor instance filled with the scalar value.
- */
-+ (instancetype)fullTensorWithShape:(NSArray<NSNumber *> *)shape
-                             scalar:(NSNumber *)scalar
-                           dataType:(ExecuTorchDataType)dataType
-                      shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor filled with the specified scalar value, with the given shape
- * and data type, using dynamic bound shape for strides and dimension order.
- *
- * @param shape An NSArray of NSNumber objects representing the desired shape.
- * @param scalar An NSNumber representing the value to fill the tensor.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @return A new ExecuTorchTensor instance filled with the scalar value.
- */
-+ (instancetype)fullTensorWithShape:(NSArray<NSNumber *> *)shape
-                             scalar:(NSNumber *)scalar
-                           dataType:(ExecuTorchDataType)dataType
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor filled with the specified scalar value, similar to an
- * existing tensor, with the given data type and shape dynamism.
- *
- * @param tensr An existing ExecuTorchTensor instance whose shape and strides
- * are used.
- * @param scalar An NSNumber representing the value to fill the tensor.
- * @param dataType An ExecuTorchDataType value specifying the desired element
- * type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the
- * shape is static or dynamic.
- * @return A new ExecuTorchTensor instance filled with the scalar value.
- */
-+ (instancetype)fullTensorLikeTensor:(ExecuTorchTensor *)tensr
-                              scalar:(NSNumber *)scalar
-                            dataType:(ExecuTorchDataType)dataType
-                       shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism
-    NS_REFINED_FOR_SWIFT NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor filled with the specified scalar value, similar to an
- * existing tensor, with the given data type.
- *
- * @param tensr An existing ExecuTorchTensor instance whose shape and strides
- * are used.
- * @param scalar An NSNumber representing the value to fill the tensor.
- * @param dataType An ExecuTorchDataType value specifying the desired element
- * type.
- * @return A new ExecuTorchTensor instance filled with the scalar value.
- */
-+ (instancetype)fullTensorLikeTensor:(ExecuTorchTensor *)tensr
-                              scalar:(NSNumber *)scalar
-                            dataType:(ExecuTorchDataType)dataType
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor filled with the specified scalar value, similar to an
- * existing tensor.
- *
- * @param tensr An existing ExecuTorchTensor instance.
- * @param scalar An NSNumber representing the value to fill the tensor.
- * @return A new ExecuTorchTensor instance filled with the scalar value.
- */
-+ (instancetype)fullTensorLikeTensor:(ExecuTorchTensor *)tensr
-                              scalar:(NSNumber *)scalar
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-@end
-
-#pragma mark - Ones Category
-
-@interface ExecuTorchTensor (Ones)
-
-/**
- * Creates a tensor filled with ones, with the specified shape, data type, and
- * shape dynamism.
- *
- * @param shape An NSArray of NSNumber objects representing the desired shape.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the
- * shape is static or dynamic.
- * @return A new ExecuTorchTensor instance filled with ones.
- */
-+ (instancetype)onesTensorWithShape:(NSArray<NSNumber *> *)shape
-                           dataType:(ExecuTorchDataType)dataType
-                      shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism
-    NS_REFINED_FOR_SWIFT NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor filled with ones, with the specified shape and data type.
- *
- * @param shape An NSArray of NSNumber objects representing the desired shape.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @return A new ExecuTorchTensor instance filled with ones.
- */
-+ (instancetype)onesTensorWithShape:(NSArray<NSNumber *> *)shape
-                           dataType:(ExecuTorchDataType)dataType
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor filled with ones similar to an existing tensor, with the
- * specified data type and shape dynamism.
- *
- * @param tensor An existing ExecuTorchTensor instance whose shape and strides
- * are used.
- * @param dataType An ExecuTorchDataType value specifying the desired element
- * type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the
- * shape is static or dynamic.
- * @return A new ExecuTorchTensor instance filled with ones.
- */
-+ (instancetype)onesTensorLikeTensor:(ExecuTorchTensor *)tensor
-                            dataType:(ExecuTorchDataType)dataType
-                       shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism
-    NS_REFINED_FOR_SWIFT NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor filled with ones similar to an existing tensor, with the
- * specified data type.
- *
- * @param tensor An existing ExecuTorchTensor instance whose shape and strides
- * are used.
- * @param dataType An ExecuTorchDataType value specifying the desired element
- * type.
- * @return A new ExecuTorchTensor instance filled with ones.
- */
-+ (instancetype)onesTensorLikeTensor:(ExecuTorchTensor *)tensor
-                            dataType:(ExecuTorchDataType)dataType
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor filled with ones similar to an existing tensor.
- *
- * @param tensor An existing ExecuTorchTensor instance.
- * @return A new ExecuTorchTensor instance filled with ones.
- */
-+ (instancetype)onesTensorLikeTensor:(ExecuTorchTensor *)tensor
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-@end
-
-#pragma mark - Zeros Category
-
-@interface ExecuTorchTensor (Zeros)
-
-/**
- * Creates a tensor filled with zeros, with the specified shape, data type, and
- * shape dynamism.
- *
- * @param shape An NSArray of NSNumber objects representing the desired shape.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the
- * shape is static or dynamic.
- * @return A new ExecuTorchTensor instance filled with zeros.
- */
-+ (instancetype)zerosTensorWithShape:(NSArray<NSNumber *> *)shape
-                            dataType:(ExecuTorchDataType)dataType
-                       shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism
-    NS_REFINED_FOR_SWIFT NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor filled with zeros, with the specified shape and data type.
- *
- * @param shape An NSArray of NSNumber objects representing the desired shape.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @return A new ExecuTorchTensor instance filled with zeros.
- */
-+ (instancetype)zerosTensorWithShape:(NSArray<NSNumber *> *)shape
-                            dataType:(ExecuTorchDataType)dataType
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor filled with zeros similar to an existing tensor, with the
- * specified data type and shape dynamism.
- *
- * @param tensor An existing ExecuTorchTensor instance whose shape and strides
- * are used.
- * @param dataType An ExecuTorchDataType value specifying the desired element
- * type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the
- * shape is static or dynamic.
- * @return A new ExecuTorchTensor instance filled with zeros.
- */
-+ (instancetype)zerosTensorLikeTensor:(ExecuTorchTensor *)tensor
-                             dataType:(ExecuTorchDataType)dataType
-                        shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism
-    NS_REFINED_FOR_SWIFT NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor filled with zeros similar to an existing tensor, with the
- * specified data type.
- *
- * @param tensor An existing ExecuTorchTensor instance whose shape and strides
- * are used.
- * @param dataType An ExecuTorchDataType value specifying the desired element
- * type.
- * @return A new ExecuTorchTensor instance filled with zeros.
- */
-+ (instancetype)zerosTensorLikeTensor:(ExecuTorchTensor *)tensor
-                             dataType:(ExecuTorchDataType)dataType
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor filled with zeros similar to an existing tensor.
- *
- * @param tensor An existing ExecuTorchTensor instance.
- * @return A new ExecuTorchTensor instance filled with zeros.
- */
-+ (instancetype)zerosTensorLikeTensor:(ExecuTorchTensor *)tensor
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-@end
-
-#pragma mark - Random Category
-
-@interface ExecuTorchTensor (Random)
-
-/**
- * Creates a tensor with random values, with full specification of shape,
- * strides, data type, and shape dynamism.
- *
- * @param shape An NSArray of NSNumber objects representing the desired shape.
- * @param strides An NSArray of NSNumber objects representing the desired
- * strides.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the
- * shape is static or dynamic.
- * @return A new ExecuTorchTensor instance filled with random values.
- */
-+ (instancetype)randomTensorWithShape:(NSArray<NSNumber *> *)shape
-                              strides:(NSArray<NSNumber *> *)strides
-                             dataType:(ExecuTorchDataType)dataType
-                        shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism
-    NS_REFINED_FOR_SWIFT NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor with random values, with the specified shape and data type.
- *
- * @param shape An NSArray of NSNumber objects representing the desired shape.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the
- * shape is static or dynamic.
- * @return A new ExecuTorchTensor instance filled with random values.
- */
-+ (instancetype)randomTensorWithShape:(NSArray<NSNumber *> *)shape
-                             dataType:(ExecuTorchDataType)dataType
-                        shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor with random values, with the specified shape (using dynamic
- * bound shape) and data type.
- *
- * @param shape An NSArray of NSNumber objects representing the desired shape.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @return A new ExecuTorchTensor instance filled with random values.
- */
-+ (instancetype)randomTensorWithShape:(NSArray<NSNumber *> *)shape
-                             dataType:(ExecuTorchDataType)dataType
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor with random values similar to an existing tensor, with the
- * specified data type and shape dynamism.
- *
- * @param tensor An existing ExecuTorchTensor instance whose shape and strides
- * are used.
- * @param dataType An ExecuTorchDataType value specifying the desired element
- * type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the
- * shape is static or dynamic.
- * @return A new ExecuTorchTensor instance filled with random values.
- */
-+ (instancetype)randomTensorLikeTensor:(ExecuTorchTensor *)tensor
-                              dataType:(ExecuTorchDataType)dataType
-                         shapeDynamism:(ExecuTorchShapeDynamism)shapeDynamism
-    NS_REFINED_FOR_SWIFT NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor with random values similar to an existing tensor, with the
- * specified data type.
- *
- * @param tensor An existing ExecuTorchTensor instance whose shape and strides
- * are used.
- * @param dataType An ExecuTorchDataType value specifying the desired element
- * type.
- * @return A new ExecuTorchTensor instance filled with random values.
- */
-+ (instancetype)randomTensorLikeTensor:(ExecuTorchTensor *)tensor
-                              dataType:(ExecuTorchDataType)dataType
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor with random values similar to an existing tensor.
- *
- * @param tensor An existing ExecuTorchTensor instance.
- * @return A new ExecuTorchTensor instance filled with random values.
- */
-+ (instancetype)randomTensorLikeTensor:(ExecuTorchTensor *)tensor
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-@end
-
-#pragma mark - RandomNormal Category
-
-@interface ExecuTorchTensor (RandomNormal)
-
-/**
- * Creates a tensor with random values drawn from a normal distribution,
- * with full specification of shape, strides, data type, and shape dynamism.
- *
- * @param shape An NSArray of NSNumber objects representing the desired shape.
- * @param strides An NSArray of NSNumber objects representing the desired
- * strides.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the
- * shape is static or dynamic.
- * @return A new ExecuTorchTensor instance filled with values from a normal
- * distribution.
- */
-+ (instancetype)randomNormalTensorWithShape:(NSArray<NSNumber *> *)shape
-                                    strides:(NSArray<NSNumber *> *)strides
-                                   dataType:(ExecuTorchDataType)dataType
-                              shapeDynamism:
-                                  (ExecuTorchShapeDynamism)shapeDynamism
-    NS_REFINED_FOR_SWIFT NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor with random values drawn from a normal distribution,
- * with the specified shape and data type.
- *
- * @param shape An NSArray of NSNumber objects representing the desired shape.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the
- * shape is static or dynamic.
- * @return A new ExecuTorchTensor instance filled with values from a normal
- * distribution.
- */
-+ (instancetype)randomNormalTensorWithShape:(NSArray<NSNumber *> *)shape
-                                   dataType:(ExecuTorchDataType)dataType
-                              shapeDynamism:
-                                  (ExecuTorchShapeDynamism)shapeDynamism
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor with random values drawn from a normal distribution,
- * with the specified shape (using dynamic bound shape) and data type.
- *
- * @param shape An NSArray of NSNumber objects representing the desired shape.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @return A new ExecuTorchTensor instance filled with values from a normal
- * distribution.
- */
-+ (instancetype)randomNormalTensorWithShape:(NSArray<NSNumber *> *)shape
-                                   dataType:(ExecuTorchDataType)dataType
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor with random normal values similar to an existing tensor,
- * with the specified data type and shape dynamism.
- *
- * @param tensor An existing ExecuTorchTensor instance whose shape and strides
- * are used.
- * @param dataType An ExecuTorchDataType value specifying the desired element
- * type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the
- * shape is static or dynamic.
- * @return A new ExecuTorchTensor instance filled with values from a normal
- * distribution.
- */
-+ (instancetype)randomNormalTensorLikeTensor:(ExecuTorchTensor *)tensor
-                                    dataType:(ExecuTorchDataType)dataType
-                               shapeDynamism:
-                                   (ExecuTorchShapeDynamism)shapeDynamism
-    NS_REFINED_FOR_SWIFT NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor with random normal values similar to an existing tensor,
- * with the specified data type.
- *
- * @param tensor An existing ExecuTorchTensor instance whose shape and strides
- * are used.
- * @param dataType An ExecuTorchDataType value specifying the desired element
- * type.
- * @return A new ExecuTorchTensor instance filled with values from a normal
- * distribution.
- */
-+ (instancetype)randomNormalTensorLikeTensor:(ExecuTorchTensor *)tensor
-                                    dataType:(ExecuTorchDataType)dataType
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor with random normal values similar to an existing tensor.
- *
- * @param tensor An existing ExecuTorchTensor instance.
- * @return A new ExecuTorchTensor instance filled with values from a normal
- * distribution.
- */
-+ (instancetype)randomNormalTensorLikeTensor:(ExecuTorchTensor *)tensor
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-@end
-
-#pragma mark - RandomInteger Category
-
-@interface ExecuTorchTensor (RandomInteger)
-
-/**
- * Creates a tensor with random integer values in the specified range,
- * with full specification of shape, strides, data type, and shape dynamism.
- *
- * @param low An NSInteger specifying the inclusive lower bound of random
- * values.
- * @param high An NSInteger specifying the exclusive upper bound of random
- * values.
- * @param shape An NSArray of NSNumber objects representing the desired shape.
- * @param strides An NSArray of NSNumber objects representing the desired
- * strides.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the
- * shape is static or dynamic.
- * @return A new ExecuTorchTensor instance filled with random integer values.
- */
-+ (instancetype)randomIntegerTensorWithLow:(NSInteger)low
-                                      high:(NSInteger)high
-                                     shape:(NSArray<NSNumber *> *)shape
-                                   strides:(NSArray<NSNumber *> *)strides
-                                  dataType:(ExecuTorchDataType)dataType
-                             shapeDynamism:
-                                 (ExecuTorchShapeDynamism)shapeDynamism
-    NS_REFINED_FOR_SWIFT NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor with random integer values in the specified range,
- * with the given shape and data type.
- *
- * @param low An NSInteger specifying the inclusive lower bound of random
- * values.
- * @param high An NSInteger specifying the exclusive upper bound of random
- * values.
- * @param shape An NSArray of NSNumber objects representing the desired shape.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the
- * shape is static or dynamic.
- * @return A new ExecuTorchTensor instance filled with random integer values.
- */
-+ (instancetype)randomIntegerTensorWithLow:(NSInteger)low
-                                      high:(NSInteger)high
-                                     shape:(NSArray<NSNumber *> *)shape
-                                  dataType:(ExecuTorchDataType)dataType
-                             shapeDynamism:
-                                 (ExecuTorchShapeDynamism)shapeDynamism
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor with random integer values in the specified range,
- * with the given shape (using dynamic bound shape) and data type.
- *
- * @param low An NSInteger specifying the inclusive lower bound of random
- * values.
- * @param high An NSInteger specifying the exclusive upper bound of random
- * values.
- * @param shape An NSArray of NSNumber objects representing the desired shape.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @return A new ExecuTorchTensor instance filled with random integer values.
- */
-+ (instancetype)randomIntegerTensorWithLow:(NSInteger)low
-                                      high:(NSInteger)high
-                                     shape:(NSArray<NSNumber *> *)shape
-                                  dataType:(ExecuTorchDataType)dataType
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor with random integer values in the specified range, similar
- * to an existing tensor, with the given data type and shape dynamism.
- *
- * @param tensor An existing ExecuTorchTensor instance whose shape and strides
- * are used.
- * @param low An NSInteger specifying the inclusive lower bound of random
- * values.
- * @param high An NSInteger specifying the exclusive upper bound of random
- * values.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @param shapeDynamism An ExecuTorchShapeDynamism value specifying whether the
- * shape is static or dynamic.
- * @return A new ExecuTorchTensor instance filled with random integer values.
- */
-+ (instancetype)randomIntegerTensorLikeTensor:(ExecuTorchTensor *)tensor
-                                          low:(NSInteger)low
-                                         high:(NSInteger)high
-                                     dataType:(ExecuTorchDataType)dataType
-                                shapeDynamism:
-                                    (ExecuTorchShapeDynamism)shapeDynamism
-    NS_REFINED_FOR_SWIFT NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor with random integer values in the specified range, similar
- * to an existing tensor, with the given data type.
- *
- * @param tensor An existing ExecuTorchTensor instance whose shape and strides
- * are used.
- * @param low An NSInteger specifying the inclusive lower bound of random
- * values.
- * @param high An NSInteger specifying the exclusive upper bound of random
- * values.
- * @param dataType An ExecuTorchDataType value specifying the element type.
- * @return A new ExecuTorchTensor instance filled with random integer values.
- */
-+ (instancetype)randomIntegerTensorLikeTensor:(ExecuTorchTensor *)tensor
-                                          low:(NSInteger)low
-                                         high:(NSInteger)high
-                                     dataType:(ExecuTorchDataType)dataType
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-/**
- * Creates a tensor with random integer values in the specified range, similar
- * to an existing tensor.
- *
- * @param tensor An existing ExecuTorchTensor instance.
- * @param low An NSInteger specifying the inclusive lower bound of random
- * values.
- * @param high An NSInteger specifying the exclusive upper bound of random
- * values.
- * @return A new ExecuTorchTensor instance filled with random integer values.
- */
-+ (instancetype)randomIntegerTensorLikeTensor:(ExecuTorchTensor *)tensor
-                                          low:(NSInteger)low
-                                         high:(NSInteger)high
-    NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
-
-@end
-
-NS_ASSUME_NONNULL_END
diff --git a/packages/react-native-executorch/third-party/include/executorch/ExecuTorchValue.h b/packages/react-native-executorch/third-party/include/executorch/ExecuTorchValue.h
deleted file mode 100644
index aeaabcdd45..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/ExecuTorchValue.h
+++ /dev/null
@@ -1,265 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#import "ExecuTorchTensor.h"
-
-NS_ASSUME_NONNULL_BEGIN
-
-/**
- * Enum to define the dynamic type of a Value.
- * Values can be a subset, but must numerically match exactly those defined in
- * runtime/core/tag.h
- */
-typedef NS_ENUM(uint32_t, ExecuTorchValueTag) {
-  ExecuTorchValueTagNone,
-  ExecuTorchValueTagTensor,
-  ExecuTorchValueTagString,
-  ExecuTorchValueTagDouble,
-  ExecuTorchValueTagInteger,
-  ExecuTorchValueTagBoolean,
-} NS_SWIFT_NAME(ValueTag);
-
-typedef NSNumber *
-    ExecuTorchScalarValue NS_SWIFT_BRIDGED_TYPEDEF NS_SWIFT_NAME(ScalarValue);
-typedef NSString *
-    ExecuTorchStringValue NS_SWIFT_BRIDGED_TYPEDEF NS_SWIFT_NAME(StringValue);
-typedef BOOL ExecuTorchBooleanValue NS_SWIFT_NAME(BoolValue);
-typedef NSInteger
-    ExecuTorchIntegerValue NS_SWIFT_BRIDGED_TYPEDEF NS_SWIFT_NAME(IntegerValue);
-typedef double
-    ExecuTorchDoubleValue NS_SWIFT_BRIDGED_TYPEDEF NS_SWIFT_NAME(DoubleValue);
-typedef float
-    ExecuTorchFloatValue NS_SWIFT_BRIDGED_TYPEDEF NS_SWIFT_NAME(FloatValue);
-
-/**
- * A dynamic value type used by ExecuTorch.
- *
- * ExecuTorchValue encapsulates a value that may be of various types such as
- * a tensor or a scalar. The value’s type is indicated by its tag.
- */
-NS_SWIFT_NAME(Value)
-__attribute__((objc_subclassing_restricted))
-@interface ExecuTorchValue : NSObject<NSCopying>
-
-/**
- * The tag that indicates the dynamic type of the value.
- *
- * @return An ExecuTorchValueTag value.
- */
-@property(nonatomic, readonly) ExecuTorchValueTag tag;
-
-/**
- * The tensor value if the tag is ExecuTorchValueTagTensor.
- *
- * @return A Tensor instance or nil.
- */
-@property(nullable, nonatomic, readonly)
-    ExecuTorchTensor *tensorValue NS_REFINED_FOR_SWIFT;
-
-/**
- * The string value if the tag is ExecuTorchValueTagString.
- *
- * @return An NSString instance or nil.
- */
-@property(nullable, nonatomic, readonly)
-    ExecuTorchStringValue stringValue NS_SWIFT_NAME(string);
-
-/**
- * The scalar value if the tag is boolean, integer or double.
- *
- * @return A scalar value or nil.
- */
-@property(nullable, nonatomic, readonly)
-    ExecuTorchScalarValue scalarValue NS_SWIFT_NAME(scalar);
-
-/**
- * The boolean value if the tag is ExecuTorchValueTagBoolean.
- *
- * @return A BOOL representing the boolean value.
- */
-@property(nonatomic, readonly)
-    ExecuTorchBooleanValue boolValue NS_SWIFT_NAME(boolean);
-
-/**
- * The integer value if the tag is ExecuTorchValueTagInteger.
- *
- * @return An NSInteger representing the integer value.
- */
-@property(nonatomic, readonly)
-    ExecuTorchIntegerValue intValue NS_SWIFT_NAME(integer);
-
-/**
- * The double value if the tag is ExecuTorchValueTagDouble.
- *
- * @return A double representing the double value.
- */
-@property(nonatomic, readonly)
-    ExecuTorchDoubleValue doubleValue NS_SWIFT_NAME(double);
-
-/**
- * The float value if the tag is ExecuTorchValueTagDouble.
- *
- * @return An float representing the float value.
- */
-@property(nonatomic, readonly)
-    ExecuTorchFloatValue floatValue NS_SWIFT_NAME(float);
-
-/**
- * Returns YES if the value is of type None.
- *
- * @return A BOOL indicating whether the value is None.
- */
-@property(nonatomic, readonly) BOOL isNone;
-
-/**
- * Returns YES if the value is a Tensor.
- *
- * @return A BOOL indicating whether the value is a Tensor.
- */
-@property(nonatomic, readonly) BOOL isTensor;
-
-/**
- * Returns YES if the value is a string.
- *
- * @return A BOOL indicating whether the value is a string.
- */
-@property(nonatomic, readonly) BOOL isString;
-
-/**
- * Returns YES if the value is a scalar (boolean, integer or double).
- *
- * @return A BOOL indicating whether the value is a scalar.
- */
-@property(nonatomic, readonly) BOOL isScalar;
-
-/**
- * Returns YES if the value is a boolean.
- *
- * @return A BOOL indicating whether the value is a boolean.
- */
-@property(nonatomic, readonly) BOOL isBoolean;
-
-/**
- * Returns YES if the value is an integer.
- *
- * @return A BOOL indicating whether the value is an integer.
- */
-@property(nonatomic, readonly) BOOL isInteger;
-
-/**
- * Returns YES if the value is a double.
- *
- * @return A BOOL indicating whether the value is a double.
- */
-@property(nonatomic, readonly) BOOL isDouble;
-
-/**
- * Returns YES if the value's tag is Double.
- *
- * Note: Since float values are stored with a Double tag, this property will
- * also be YES for values created from floats.
- *
- * @return A BOOL indicating whether the value is a float.
- */
-@property(nonatomic, readonly) BOOL isFloat;
-
-/**
- * Creates an instance encapsulating a Tensor.
- *
- * @param value An ExecuTorchTensor instance.
- * @return A new ExecuTorchValue instance with a tag of
- * ExecuTorchValueTagTensor.
- */
-+ (instancetype)valueWithTensor:(ExecuTorchTensor *)value
-    NS_SWIFT_NAME(init(_:)) NS_RETURNS_RETAINED;
-
-/**
- * Creates an instance encapsulating a string.
- *
- * @param value A string.
- * @return A new ExecuTorchValue instance with a tag of
- * ExecuTorchValueTagString.
- */
-+ (instancetype)valueWithString:(ExecuTorchStringValue)value
-    NS_SWIFT_NAME(init(_:)) NS_RETURNS_RETAINED;
-
-/**
- * Creates an instance encapsulating a boolean.
- *
- * @param value A boolean.
- * @return A new ExecuTorchValue instance with a tag of
- * ExecuTorchValueTagBoolean.
- */
-+ (instancetype)valueWithBoolean:(ExecuTorchBooleanValue)value
-    NS_SWIFT_NAME(init(_:)) NS_RETURNS_RETAINED;
-
-/**
- * Creates an instance encapsulating an integer.
- *
- * @param value An integer.
- * @return A new ExecuTorchValue instance with a tag of
- * ExecuTorchValueTagInteger.
- */
-+ (instancetype)valueWithInteger:(ExecuTorchIntegerValue)value
-    NS_SWIFT_NAME(init(_:)) NS_RETURNS_RETAINED;
-
-/**
- * Creates an instance encapsulating a double value.
- *
- * @param value A double value.
- * @return A new ExecuTorchValue instance with a tag of
- * ExecuTorchValueTagDouble.
- */
-+ (instancetype)valueWithDouble:(ExecuTorchDoubleValue)value
-    NS_SWIFT_NAME(init(_:)) NS_RETURNS_RETAINED;
-
-/**
- * Creates an instance encapsulating a float value.
- *
- * Note: The underlying value will be stored with a tag of
- * ExecuTorchValueTagDouble, as there is no distinct float tag.
- *
- * @param value A float value.
- * @return A new ExecuTorchValue instance with a tag of
- * ExecuTorchValueTagDouble.
- */
-+ (instancetype)valueWithFloat:(ExecuTorchFloatValue)value
-    NS_SWIFT_NAME(init(_:)) NS_RETURNS_RETAINED;
-
-/**
- * Creates an instance encapsulating a scalar value.
- *
- * The value's tag will be set according to the type encoding of the
- * ExecuTorchScalarValue.
- *
- * @param value An ExecuTorchScalarValue.
- * @return A new ExecuTorchValue instance with the appropriate tag.
- */
-+ (instancetype)valueWithScalar:(ExecuTorchScalarValue)value
-    NS_SWIFT_NAME(init(_:)) NS_RETURNS_RETAINED;
-
-/**
- * Returns a copy of the value.
- *
- * @return A new ExecuTorchValue instance that is a duplicate of the current
- * value.
- */
-- (instancetype)copy;
-
-/**
- * Determines whether the current Value is equal to another Value.
- *
- * @param other Another ExecuTorchValue instance to compare against.
- * @return YES if the values have the same tag and equal underlying values;
- * otherwise, NO.
- */
-- (BOOL)isEqualToValue:(nullable ExecuTorchValue *)other;
-
-@end
-
-NS_ASSUME_NONNULL_END
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/data_loader/buffer_data_loader.h b/packages/react-native-executorch/third-party/include/executorch/extension/data_loader/buffer_data_loader.h
deleted file mode 100644
index b3744d0970..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/data_loader/buffer_data_loader.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <c10/util/safe_numerics.h>
-#include <cstring>
-#include <executorch/runtime/core/data_loader.h>
-#include <executorch/runtime/core/error.h>
-#include <executorch/runtime/core/result.h>
-#include <executorch/runtime/platform/log.h>
-
-namespace executorch {
-namespace extension {
-
-/**
- * A DataLoader that wraps a pre-allocated buffer. The FreeableBuffers
- * that it returns do not actually free any data.
- *
- * This can be used to wrap data that is directly embedded into the firmware
- * image, or to wrap data that was allocated elsewhere.
- */
-class BufferDataLoader final : public executorch::runtime::DataLoader {
-public:
-  BufferDataLoader(const void *data, size_t size)
-      : data_(reinterpret_cast<const uint8_t *>(data)), size_(size) {}
-
-  ET_NODISCARD
-  executorch::runtime::Result<executorch::runtime::FreeableBuffer>
-  load(size_t offset, size_t size,
-       ET_UNUSED const DataLoader::SegmentInfo &segment_info) const override {
-    size_t total_size;
-    bool overflow = c10::add_overflows(offset, size, &total_size);
-    ET_CHECK_OR_RETURN_ERROR(
-        !overflow && total_size <= size_, InvalidArgument,
-        "offset %zu + size %zu > size_ %zu, or overflow detected", offset, size,
-        size_);
-    return executorch::runtime::FreeableBuffer(data_ + offset, size,
-                                               /*free_fn=*/nullptr);
-  }
-
-  ET_NODISCARD executorch::runtime::Result<size_t> size() const override {
-    return size_;
-  }
-
-  ET_NODISCARD executorch::runtime::Error
-  load_into(size_t offset, size_t size,
-            ET_UNUSED const SegmentInfo &segment_info,
-            void *buffer) const override {
-    ET_CHECK_OR_RETURN_ERROR(buffer != nullptr, InvalidArgument,
-                             "Destination buffer cannot be null");
-
-    auto result = load(offset, size, segment_info);
-    if (!result.ok()) {
-      return result.error();
-    }
-    std::memcpy(buffer, result->data(), size);
-    return executorch::runtime::Error::Ok;
-  }
-
-private:
-  const uint8_t *const data_; // uint8 is easier to index into.
-  const size_t size_;
-};
-
-} // namespace extension
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-namespace util {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::extension::BufferDataLoader;
-} // namespace util
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/data_loader/file_data_loader.h b/packages/react-native-executorch/third-party/include/executorch/extension/data_loader/file_data_loader.h
deleted file mode 100644
index b5604c6ee4..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/data_loader/file_data_loader.h
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <cstddef>
-
-#include <executorch/runtime/core/data_loader.h>
-#include <executorch/runtime/core/result.h>
-#include <executorch/runtime/platform/compiler.h>
-
-namespace executorch {
-namespace extension {
-
-/**
- * A DataLoader that loads segments from a file, allocating the memory
- * with `malloc()`.
- *
- * Note that this will keep the file open for the duration of its lifetime, to
- * avoid the overhead of opening it again for every load() call.
- */
-class FileDataLoader final : public executorch::runtime::DataLoader {
-public:
-  /**
-   * Creates a new FileDataLoader that wraps the named file.
-   *
-   * @param[in] file_name Path to the file to read from.
-   * @param[in] alignment Alignment in bytes of pointers returned by this
-   *     instance. Must be a power of two.
-   *
-   * @returns A new FileDataLoader on success.
-   * @retval Error::InvalidArgument `alignment` is not a power of two.
-   * @retval Error::AccessFailed `file_name` could not be opened, or its size
-   *     could not be found.
-   * @retval Error::MemoryAllocationFailed Internal memory allocation failure.
-   */
-  static executorch::runtime::Result<FileDataLoader>
-  from(const char *file_name, size_t alignment = alignof(std::max_align_t));
-
-  /// DEPRECATED: Use the lowercase `from()` instead.
-  ET_DEPRECATED static executorch::runtime::Result<FileDataLoader>
-  From(const char *file_name, size_t alignment = alignof(std::max_align_t)) {
-    return from(file_name, alignment);
-  }
-
-  // Movable to be compatible with Result.
-  FileDataLoader(FileDataLoader &&rhs) noexcept
-      : file_name_(rhs.file_name_), file_size_(rhs.file_size_),
-        alignment_(rhs.alignment_), fd_(rhs.fd_) {
-    const_cast<const char *&>(rhs.file_name_) = nullptr;
-    const_cast<size_t &>(rhs.file_size_) = 0;
-    const_cast<std::align_val_t &>(rhs.alignment_) = {};
-    const_cast<int &>(rhs.fd_) = -1;
-  }
-
-  ~FileDataLoader() override;
-
-  ET_NODISCARD
-  executorch::runtime::Result<executorch::runtime::FreeableBuffer>
-  load(size_t offset, size_t size,
-       const DataLoader::SegmentInfo &segment_info) const override;
-
-  ET_NODISCARD executorch::runtime::Result<size_t> size() const override;
-
-  ET_NODISCARD executorch::runtime::Error
-  load_into(size_t offset, size_t size,
-            ET_UNUSED const SegmentInfo &segment_info,
-            void *buffer) const override;
-
-private:
-  FileDataLoader(int fd, size_t file_size, size_t alignment,
-                 const char *file_name)
-      : file_name_(file_name), file_size_(file_size), alignment_{alignment},
-        fd_(fd) {}
-
-  // Not safely copyable.
-  FileDataLoader(const FileDataLoader &) = delete;
-  FileDataLoader &operator=(const FileDataLoader &) = delete;
-  FileDataLoader &operator=(FileDataLoader &&) = delete;
-
-  const char *const file_name_; // Owned by the instance.
-  const size_t file_size_;
-  const std::align_val_t alignment_;
-  const int fd_; // Owned by the instance.
-};
-
-} // namespace extension
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-namespace util {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::extension::FileDataLoader;
-} // namespace util
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/data_loader/file_descriptor_data_loader.h b/packages/react-native-executorch/third-party/include/executorch/extension/data_loader/file_descriptor_data_loader.h
deleted file mode 100644
index 9f57603e89..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/data_loader/file_descriptor_data_loader.h
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <cstddef>
-
-#include <executorch/runtime/core/data_loader.h>
-#include <executorch/runtime/core/result.h>
-#include <executorch/runtime/platform/compiler.h>
-
-namespace executorch {
-namespace extension {
-
-/**
- * A DataLoader that loads segments from a file descriptor, allocating the
- * memory with `malloc()`. This data loader is used when ET is running in a
- * process that does not have access to the filesystem, and the caller is able
- * to open the file and pass the file descriptor.
- *
- * Note that this will keep the file open for the duration of its lifetime, to
- * avoid the overhead of opening it again for every load() call.
- */
-class FileDescriptorDataLoader final : public executorch::runtime::DataLoader {
-public:
-  /**
-   * Creates a new FileDescriptorDataLoader that wraps the named file
-   * descriptor, and the ownership of the file descriptor is passed.
-   *
-   * @param[in] file_descriptor_uri File descriptor with the prefix "fd:///",
-   *     followed by the file descriptor number.
-   * @param[in] alignment Alignment in bytes of pointers returned by this
-   *     instance. Must be a power of two.
-   *
-   * @returns A new FileDescriptorDataLoader on success.
-   * @retval Error::InvalidArgument `alignment` is not a power of two.
-   * @retval Error::AccessFailed `file_descriptor_uri` is incorrectly formatted,
-   * or its size could not be found.
-   * @retval Error::MemoryAllocationFailed Internal memory allocation failure.
-   */
-  static executorch::runtime::Result<FileDescriptorDataLoader>
-  fromFileDescriptorUri(const char *file_descriptor_uri,
-                        size_t alignment = alignof(std::max_align_t));
-
-  // Movable to be compatible with Result.
-  FileDescriptorDataLoader(FileDescriptorDataLoader &&rhs) noexcept
-      : file_descriptor_uri_(rhs.file_descriptor_uri_),
-        file_size_(rhs.file_size_), alignment_(rhs.alignment_), fd_(rhs.fd_) {
-    const_cast<const char *&>(rhs.file_descriptor_uri_) = nullptr;
-    const_cast<size_t &>(rhs.file_size_) = 0;
-    const_cast<std::align_val_t &>(rhs.alignment_) = {};
-    const_cast<int &>(rhs.fd_) = -1;
-  }
-
-  ~FileDescriptorDataLoader() override;
-
-  ET_NODISCARD
-  executorch::runtime::Result<executorch::runtime::FreeableBuffer>
-  load(size_t offset, size_t size,
-       const DataLoader::SegmentInfo &segment_info) const override;
-
-  ET_NODISCARD executorch::runtime::Result<size_t> size() const override;
-
-  ET_NODISCARD executorch::runtime::Error
-  load_into(size_t offset, size_t size,
-            ET_UNUSED const SegmentInfo &segment_info,
-            void *buffer) const override;
-
-private:
-  FileDescriptorDataLoader(int fd, size_t file_size, size_t alignment,
-                           const char *file_descriptor_uri)
-      : file_descriptor_uri_(file_descriptor_uri), file_size_(file_size),
-        alignment_{alignment}, fd_(fd) {}
-
-  // Not safely copyable.
-  FileDescriptorDataLoader(const FileDescriptorDataLoader &) = delete;
-  FileDescriptorDataLoader &
-  operator=(const FileDescriptorDataLoader &) = delete;
-  FileDescriptorDataLoader &operator=(FileDescriptorDataLoader &&) = delete;
-
-  const char *const file_descriptor_uri_; // Owned by the instance.
-  const size_t file_size_;
-  const std::align_val_t alignment_;
-  const int fd_; // Owned by the instance.
-};
-
-} // namespace extension
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-namespace util {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::extension::FileDescriptorDataLoader;
-} // namespace util
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/data_loader/mman.h b/packages/react-native-executorch/third-party/include/executorch/extension/data_loader/mman.h
deleted file mode 100644
index c35fd07f46..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/data_loader/mman.h
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// This file ensures that mman.h compatible functions are defined in the global
-// namespace for windows and posix environments.
-
-#pragma once
-
-#include <cstdint>
-#include <executorch/runtime/platform/compiler.h>
-#include <sys/stat.h>
-
-#ifndef _WIN32
-
-#include <fcntl.h>
-#include <sys/mman.h>
-#include <unistd.h>
-
-ET_INLINE size_t get_os_page_size() { return sysconf(_SC_PAGESIZE); }
-
-/**
- * Platform-specific file stat function.
- */
-ET_INLINE int get_file_stat(int fd, size_t *out_size) {
-  struct stat st;
-  int err = ::fstat(fd, &st);
-  if (err >= 0) {
-    *out_size = static_cast<size_t>(st.st_size);
-  }
-  return err;
-}
-
-/**
- * Platform-specific mmap offset type conversion.
- */
-ET_INLINE off_t get_mmap_offset(size_t offset) {
-  return static_cast<off_t>(offset);
-}
-
-/**
- * Hint the kernel to prefetch pages eagerly and to optimize for sequential
- * reads. Intended to reduce page-fault stutter during model initialization
- * when the caller does not want to mlock the pages into RAM.
- */
-ET_INLINE void madvise_pages_willneed_sequential(void *addr, size_t len) {
-  ::madvise(addr, len, MADV_WILLNEED);
-  ::madvise(addr, len, MADV_SEQUENTIAL);
-}
-
-/**
- * On Apple platforms, schedule kernel read-ahead on the file descriptor itself
- * via fcntl(F_RDADVISE). This is more aggressive than madvise for cold starts:
- * it brings pages into the unified buffer cache so first-touch faults are
- * serviced from RAM instead of storage. No-op on non-Apple POSIX platforms.
- */
-ET_INLINE void fcntl_rdadvise_apple(int fd, size_t file_size) {
-#if defined(__APPLE__)
-  struct radvisory advice;
-  advice.ra_offset = 0;
-  advice.ra_count = static_cast<int>(file_size);
-  ::fcntl(fd, F_RDADVISE, &advice);
-#else
-  (void)fd;
-  (void)file_size;
-#endif
-}
-
-#else
-
-#define NOMINMAX
-#include <windows.h>
-#undef NOMINMAX
-#include <io.h>
-
-#include <executorch/extension/data_loader/mman_windows.h>
-
-ET_INLINE long get_os_page_size() {
-  SYSTEM_INFO si;
-  GetSystemInfo(&si);
-  long pagesize = si.dwAllocationGranularity > si.dwPageSize
-                      ? si.dwAllocationGranularity
-                      : si.dwPageSize;
-  return pagesize;
-}
-
-/**
- * Platform-specific file stat function.
- */
-ET_INLINE int get_file_stat(int fd, size_t *out_size) {
-  struct _stat64 st;
-  int err = ::_fstat64(fd, &st);
-  if (err >= 0) {
-    *out_size = static_cast<size_t>(st.st_size);
-  }
-  return err;
-}
-
-/**
- * Platform-specific mmap offset type conversion.
- */
-ET_INLINE uint64_t get_mmap_offset(size_t offset) {
-  return static_cast<uint64_t>(offset);
-}
-
-/**
- * No-op on Windows: there is no direct equivalent to madvise(MADV_WILLNEED |
- * MADV_SEQUENTIAL) and the existing mman_windows shim does not implement one.
- */
-ET_INLINE void madvise_pages_willneed_sequential(void *addr, size_t len) {
-  (void)addr;
-  (void)len;
-}
-
-/**
- * No-op on Windows: F_RDADVISE is an Apple-specific fcntl command.
- */
-ET_INLINE void fcntl_rdadvise_apple(int fd, size_t file_size) {
-  (void)fd;
-  (void)file_size;
-}
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/data_loader/mman_windows.h b/packages/react-native-executorch/third-party/include/executorch/extension/data_loader/mman_windows.h
deleted file mode 100644
index 05ef07f434..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/data_loader/mman_windows.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * Copyright (c) Google Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the MIT license.
- */
-
-/*
- * Adapted from: https://code.google.com/archive/p/mman-win32/
- *
- * mman-win32
- * mman library for Windows
- *
- * A light implementation of the mmap functions for MinGW.
- *
- * The mmap-win32 library implements a wrapper for mmap functions around the
- * memory mapping Windows API.
- */
-
-#pragma once
-
-#ifndef _WIN32_WINNT // Allow use of features specific to Windows XP or later.
-#define _WIN32_WINNT                                                           \
-  0x0501 // Change this to the appropriate value to target other versions of
-         // Windows.
-#endif
-
-/* All the headers include this file. */
-#ifndef _MSC_VER
-#include <_mingw.h>
-#endif
-
-#include <cstdint>
-#include <sys/types.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define PROT_NONE 0
-#define PROT_READ 1
-#define PROT_WRITE 2
-#define PROT_EXEC 4
-
-#define MAP_FILE 0
-#define MAP_SHARED 1
-#define MAP_PRIVATE 2
-#define MAP_TYPE 0xf
-#define MAP_FIXED 0x10
-#define MAP_ANONYMOUS 0x20
-#define MAP_ANON MAP_ANONYMOUS
-
-#define MAP_FAILED ((void *)-1)
-
-/* Flags for msync. */
-#define MS_ASYNC 1
-#define MS_SYNC 2
-#define MS_INVALIDATE 4
-
-void *mmap(void *addr, size_t len, int prot, int flags, int fildes,
-           uint64_t off);
-int munmap(void *addr, size_t len);
-int mprotect(void *addr, size_t len, int prot);
-int msync(void *addr, size_t len, int flags);
-int mlock(const void *addr, size_t len);
-int munlock(const void *addr, size_t len);
-
-#ifdef __cplusplus
-};
-#endif
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/data_loader/mmap_data_loader.h b/packages/react-native-executorch/third-party/include/executorch/extension/data_loader/mmap_data_loader.h
deleted file mode 100644
index 1b648ce35f..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/data_loader/mmap_data_loader.h
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <executorch/runtime/core/data_loader.h>
-#include <executorch/runtime/core/result.h>
-#include <executorch/runtime/platform/compiler.h>
-
-namespace executorch {
-namespace extension {
-
-/**
- * A DataLoader that loads segments from a file, allocating the memory
- * with `malloc()`.
- *
- * Note that this will keep the file open for the duration of its lifetime, to
- * avoid the overhead of opening it again for every load() call.
- */
-class MmapDataLoader final : public executorch::runtime::DataLoader {
-public:
-  /**
-   * Describes how and whether to lock loaded pages with `mlock()`.
-   *
-   * Using `mlock()` typically loads all of the pages immediately, and will
-   * typically ensure that they are not swapped out. The actual behavior
-   * will depend on the host system.
-   */
-  enum class MlockConfig {
-    /// Do not call `mlock()` on loaded pages.
-    NoMlock,
-    /// Call `mlock()` on loaded pages, failing if it fails.
-    UseMlock,
-    /// Call `mlock()` on loaded pages, ignoring errors if it fails.
-    UseMlockIgnoreErrors,
-    /// Use madvise(MADV_WILLNEED | MADV_SEQUENTIAL) instead of mlock.
-    /// Tells the kernel to prefetch pages eagerly and optimize for
-    /// sequential reads, without pinning them in RAM.
-    UseMadvise,
-  };
-
-  /**
-   * Creates a new MmapDataLoader that wraps the named file. Fails if
-   * the file can't be opened for reading or if its size can't be found.
-   *
-   * @param[in] file_name The path to the file to load from. The file will be
-   *     kept open until the MmapDataLoader is destroyed, to avoid the
-   *     overhead of opening it again for every load() call.
-   * @param[in] mlock_config How and whether to lock loaded pages with
-   *     `mlock()`.
-   */
-  static executorch::runtime::Result<MmapDataLoader>
-  from(const char *file_name, MlockConfig mlock_config = MlockConfig::UseMlock);
-
-  /// DEPRECATED: Use the lowercase `from()` instead.
-  ET_DEPRECATED static executorch::runtime::Result<MmapDataLoader>
-  From(const char *file_name,
-       MlockConfig mlock_config = MlockConfig::UseMlock) {
-    return from(file_name, mlock_config);
-  }
-
-  /// DEPRECATED: Use the version of `from()` that takes an MlockConfig.
-  ET_DEPRECATED
-  static executorch::runtime::Result<MmapDataLoader> From(const char *file_name,
-                                                          bool use_mlock) {
-    MlockConfig mlock_config =
-        use_mlock ? MlockConfig::UseMlock : MlockConfig::NoMlock;
-    return from(file_name, mlock_config);
-  }
-
-  // Movable to be compatible with Result.
-  MmapDataLoader(MmapDataLoader &&rhs) noexcept
-      : file_name_(rhs.file_name_), file_size_(rhs.file_size_),
-        page_size_(rhs.page_size_), fd_(rhs.fd_),
-        mlock_config_(rhs.mlock_config_) {
-    const_cast<const char *&>(rhs.file_name_) = nullptr;
-    const_cast<size_t &>(rhs.file_size_) = 0;
-    const_cast<size_t &>(rhs.page_size_) = 0;
-    const_cast<int &>(rhs.fd_) = -1;
-    const_cast<MlockConfig &>(rhs.mlock_config_) = MlockConfig::NoMlock;
-  }
-
-  ~MmapDataLoader() override;
-
-  ET_NODISCARD
-  executorch::runtime::Result<executorch::runtime::FreeableBuffer>
-  load(size_t offset, size_t size,
-       const DataLoader::SegmentInfo &segment_info) const override;
-
-  ET_NODISCARD executorch::runtime::Result<size_t> size() const override;
-
-  ET_NODISCARD
-  executorch::runtime::Error
-  load_into(size_t offset, size_t size,
-            ET_UNUSED const SegmentInfo &segment_info,
-            void *buffer) const override;
-
-private:
-  MmapDataLoader(int fd, size_t file_size, const char *file_name,
-                 size_t page_size, MlockConfig mlock_config)
-      : file_name_(file_name), file_size_(file_size), page_size_(page_size),
-        fd_(fd), mlock_config_(mlock_config) {}
-
-  // Not safely copyable.
-  MmapDataLoader(const MmapDataLoader &) = delete;
-  MmapDataLoader &operator=(const MmapDataLoader &) = delete;
-  MmapDataLoader &operator=(MmapDataLoader &&) = delete;
-
-  ET_NODISCARD executorch::runtime::Error validate_input(size_t offset,
-                                                         size_t size) const;
-
-  const char *const file_name_; // String data is owned by the instance.
-  const size_t file_size_;
-  const size_t page_size_;
-  const int fd_; // Owned by the instance.
-  const MlockConfig mlock_config_;
-};
-
-} // namespace extension
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-namespace util {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::extension::MmapDataLoader;
-} // namespace util
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/data_loader/shared_ptr_data_loader.h b/packages/react-native-executorch/third-party/include/executorch/extension/data_loader/shared_ptr_data_loader.h
deleted file mode 100644
index e9bb26322f..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/data_loader/shared_ptr_data_loader.h
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <c10/util/safe_numerics.h>
-#include <executorch/runtime/core/data_loader.h>
-#include <executorch/runtime/core/error.h>
-#include <executorch/runtime/core/result.h>
-#include <executorch/runtime/platform/log.h>
-#include <memory>
-
-namespace executorch {
-namespace extension {
-
-/**
- * A DataLoader that wraps a pre-allocated buffer and shares ownership to it.
- * The FreeableBuffers that it returns do not actually free any data.
- *
- * This can be used to wrap data that was allocated elsewhere.
- */
-class SharedPtrDataLoader final : public executorch::runtime::DataLoader {
-public:
-  SharedPtrDataLoader(std::shared_ptr<void> data, size_t size)
-      : data_(data), size_(size) {}
-
-  ET_NODISCARD
-  executorch::runtime::Result<executorch::runtime::FreeableBuffer>
-  load(size_t offset, size_t size,
-       ET_UNUSED const DataLoader::SegmentInfo &segment_info) const override {
-    size_t total_size;
-    bool overflow = c10::add_overflows(offset, size, &total_size);
-    ET_CHECK_OR_RETURN_ERROR(
-        !overflow && total_size <= size_, InvalidArgument,
-        "offset %zu + size %zu > size_ %zu, or overflow detected", offset, size,
-        size_);
-    return executorch::runtime::FreeableBuffer(
-        static_cast<uint8_t *>(data_.get()) + offset, size,
-        /*free_fn=*/nullptr);
-  }
-
-  ET_NODISCARD executorch::runtime::Result<size_t> size() const override {
-    return size_;
-  }
-
-private:
-  const std::shared_ptr<void> data_;
-  const size_t size_;
-};
-
-} // namespace extension
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-namespace util {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::extension::SharedPtrDataLoader;
-} // namespace util
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/kernel_util/make_boxed_from_unboxed_functor.h b/packages/react-native-executorch/third-party/include/executorch/extension/kernel_util/make_boxed_from_unboxed_functor.h
deleted file mode 100644
index 6f96f4b7d6..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/kernel_util/make_boxed_from_unboxed_functor.h
+++ /dev/null
@@ -1,238 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-//===----------------------------------------------------------------------===//
-/// \file extension/kernel_util/make_boxed_from_unboxed_functor.h
-/// Defines a template that can be used to create a boxed version of an unboxed
-/// functor.
-/// Example usage:
-/// ```
-/// Tensor&
-/// my_op(KernelRuntimeContext& ctx, const Tensor& self, const Tensor& other,
-///       Tensor& out)
-/// {
-///   // ...
-///   return out;
-/// }
-///
-/// Kernel my_kernel = Kernel::make_boxed_kernel("my_ns::my_op",
-///   EXECUTORCH_FN(my_op));
-/// static auto res = register_kernels({my_kernel});
-/// ```
-/// Or simply:
-/// ```
-/// EXECUTORCH_LIBRARY(my_ns, "my_op", my_op);
-/// ```
-///
-/// The trick here is to convert each EValue to inferred argument type. This
-/// uses a lot of C++17 features.
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <cstdlib>
-#include <executorch/extension/kernel_util/meta_programming.h>
-#include <executorch/extension/kernel_util/type_list.h>
-#include <executorch/runtime/core/evalue.h>
-#include <executorch/runtime/core/event_tracer_hooks.h>
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <executorch/runtime/kernel/kernel_runtime_context.h>
-#include <executorch/runtime/kernel/operator_registry.h>
-#include <memory>
-#include <type_traits>
-#include <typeinfo>
-
-namespace executorch {
-namespace runtime {
-class KernelRuntimeContext; // Forward declaration
-} // namespace runtime
-} // namespace executorch
-
-namespace executorch {
-namespace extension {
-
-// This extension has a lot of generic internal names like "size"; use a unique
-// internal namespace to avoid conflicts with other extensions.
-namespace kernel_util_internal {
-
-// Template trait to check if a type is a non-const tensor
-template <class T> struct is_nonconst_tensor : std::false_type {};
-
-template <>
-struct is_nonconst_tensor<executorch::aten::Tensor &> : std::true_type {};
-
-// Template trait to check if a type is a non-const tensor
-// Count non-const tensors in a typelist
-template <class TypeList> struct count_nonconst_tensors;
-
-template <> struct count_nonconst_tensors<typelist<>> {
-  static constexpr size_t value = 0;
-};
-
-template <class T> struct count_nonconst_tensors<typelist<T>> {
-  static constexpr size_t value = 0;
-};
-
-template <>
-struct count_nonconst_tensors<typelist<executorch::aten::Tensor &>> {
-  static constexpr size_t value = 1;
-};
-
-template <class Head, class... Tail>
-struct count_nonconst_tensors<typelist<Head, Tail...>> {
-private:
-  static constexpr size_t tail_tensor_count =
-      count_nonconst_tensors<typelist<Tail...>>::value;
-  static constexpr size_t tail_args_count = sizeof...(Tail);
-  static constexpr bool is_head_a_tensor = is_nonconst_tensor<Head>::value;
-  static constexpr bool all_tail_args_are_tensor =
-      tail_tensor_count == tail_args_count;
-
-public:
-  static constexpr size_t value = (is_head_a_tensor && all_tail_args_are_tensor)
-                                      ? tail_tensor_count + 1
-                                      : tail_tensor_count;
-};
-
-template <class T> struct decay_if_not_tensor final {
-  using type = std::decay_t<T>;
-};
-template <> struct decay_if_not_tensor<executorch::aten::Tensor &> final {
-  using type = executorch::aten::Tensor &;
-};
-template <> struct decay_if_not_tensor<const executorch::aten::Tensor &> final {
-  using type = const executorch::aten::Tensor &;
-};
-
-template <class T> struct evalue_to_arg final {
-  static T call(executorch::runtime::EValue &v) { return std::move(v).to<T>(); }
-};
-
-template <> struct evalue_to_arg<executorch::aten::Tensor &> final {
-  static executorch::aten::Tensor &call(executorch::runtime::EValue &v) {
-    return v.toTensor();
-  }
-};
-
-template <> struct evalue_to_arg<const executorch::aten::Tensor &> final {
-  static const executorch::aten::Tensor &call(executorch::runtime::EValue &v) {
-    return v.toTensor();
-  }
-};
-
-template <class T> struct evalue_to_arg<std::optional<T>> final {
-  static std::optional<T> call(executorch::runtime::EValue &v) {
-    return v.toOptional<T>();
-  }
-};
-
-template <class T>
-struct evalue_to_arg<executorch::aten::ArrayRef<std::optional<T>>> final {
-  static executorch::aten::ArrayRef<std::optional<T>>
-  call(executorch::runtime::EValue &v) {
-    return v.toListOptionalTensor();
-  }
-};
-
-template <class Functor, size_t nonconst_tensors_to_log,
-          size_t... evalue_arg_indices, typename... ArgTypes>
-void call_functor_with_args_from_stack(
-    executorch::runtime::KernelRuntimeContext &ctx,
-    executorch::runtime::Span<executorch::runtime::EValue *> stack,
-    std::index_sequence<evalue_arg_indices...>, typelist<ArgTypes...> *) {
-  executorch::runtime::internal::EventTracerProfileOpScope
-      event_tracer_op_scope(ctx.internal_event_tracer(), Functor::func_name_);
-  EXECUTORCH_SCOPE_PROF(Functor::func_name_);
-  (*Functor::func_ptr())(
-      ctx, evalue_to_arg<typename decay_if_not_tensor<ArgTypes>::type>::call(
-               *stack[evalue_arg_indices])...);
-  constexpr size_t num_inputs =
-      std::index_sequence<evalue_arg_indices...>::size();
-  for (size_t i = num_inputs - nonconst_tensors_to_log; i < num_inputs; ++i) {
-    executorch::runtime::internal::event_tracer_log_evalue(
-        ctx.internal_event_tracer(), *stack[i]);
-  }
-}
-
-} // namespace kernel_util_internal
-
-/**
- * WrapUnboxedIntoFunctor: Given a function pointer, wrap it into a functor that
- * takes EValues as input and returns void. The wrapped functor will unbox all
- * inputs and forward them to unboxed kernel.
- */
-template <class FuncType> struct WrapUnboxedIntoFunctor {
-  static_assert(
-      kernel_util_internal::is_compile_time_function_pointer<FuncType>::value,
-      "Can't handle function other than EXECUTORCH_FN");
-  using TrueType = typename FuncType::FuncType;
-  using ReturnType = typename kernel_util_internal::infer_function_traits_t<
-      TrueType>::return_type;
-  using ArgsType = typename kernel_util_internal::infer_function_traits_t<
-      TrueType>::parameter_types;
-  // check if the first argument is KernelRuntimeContext, if so, remove it
-  static constexpr bool first_arg_is_context = std::is_same<
-      ::executorch::runtime::KernelRuntimeContext,
-      std::remove_reference_t<
-          kernel_util_internal::head_with_default_t<void, ArgsType>>>::value;
-  using ContextRemovedArgsType =
-      std::conditional_t<first_arg_is_context,
-                         kernel_util_internal::drop_if_nonempty_t<ArgsType, 1>,
-                         ArgsType>;
-
-  static void
-  call(::executorch::runtime::KernelRuntimeContext &ctx,
-       executorch::runtime::Span<executorch::runtime::EValue *> stack) {
-    constexpr size_t num_inputs =
-        kernel_util_internal::size<ContextRemovedArgsType>::value;
-    constexpr size_t num_nonconst_tensors =
-        kernel_util_internal::count_nonconst_tensors<
-            ContextRemovedArgsType>::value;
-    static_assert(num_nonconst_tensors == 1, "Invalid number of inputs");
-    return kernel_util_internal::call_functor_with_args_from_stack<
-        FuncType, num_nonconst_tensors>(
-        ctx, stack, std::make_index_sequence<num_inputs>(),
-        static_cast<ContextRemovedArgsType *>(nullptr));
-  }
-};
-
-template <typename FuncType>
-static executorch::runtime::Kernel make_boxed_kernel(const char *name,
-                                                     FuncType) {
-  return executorch::runtime::Kernel(name,
-                                     WrapUnboxedIntoFunctor<FuncType>::call);
-}
-
-} // namespace extension
-} // namespace executorch
-
-// Inspired from C10_CONCATENATE
-#define ET_CONCATENATE_IMPL(s1, s2) s1##s2
-#define ET_CONCATENATE(s1, s2) ET_CONCATENATE_IMPL(s1, s2)
-#define ET_UID __LINE__
-
-#define EXECUTORCH_LIBRARY(ns, op_name, func)                                  \
-  _EXECUTORCH_LIBRARY_IMPL(ns, op_name, func, ET_UID)
-
-#define _EXECUTORCH_LIBRARY_IMPL(ns, op_name, func, uid)                       \
-  static constexpr const char ET_CONCATENATE(name_of_op_, uid)[] =             \
-      #ns "::" op_name;                                                        \
-  static auto ET_CONCATENATE(res_##ns##_, uid) =                               \
-      ::executorch::runtime::register_kernel(                                  \
-          ::executorch::extension::make_boxed_kernel(                          \
-              #ns "::" op_name,                                                \
-              EXECUTORCH_FN(func, ET_CONCATENATE(name_of_op_, uid))))
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::extension::make_boxed_kernel;
-using ::executorch::extension::WrapUnboxedIntoFunctor;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/kernel_util/meta_programming.h b/packages/react-native-executorch/third-party/include/executorch/extension/kernel_util/meta_programming.h
deleted file mode 100644
index 762426af7b..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/kernel_util/meta_programming.h
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <cstdlib>
-#include <executorch/extension/kernel_util/type_list.h>
-#include <memory>
-#include <type_traits>
-#include <typeinfo>
-
-namespace executorch {
-namespace extension {
-// This extension has a lot of generic internal names like "size"; use a unique
-// internal namespace to avoid conflicts with other extensions.
-namespace kernel_util_internal {
-
-// Check if a given type is a function
-template <class T> struct is_function_type : std::false_type {};
-template <class Result, class... Args>
-struct is_function_type<Result(Args...)> : std::true_type {};
-template <class T>
-using is_function_type_t = typename is_function_type<T>::type;
-
-// A compile-time wrapper around a function pointer
-template <class FuncType_, FuncType_ *func_ptr_, const char *func_name>
-struct CompileTimeFunctionPointer final {
-  static_assert(is_function_type<FuncType_>::value,
-                "EXECUTORCH_FN can only wrap function types.");
-  using FuncType = FuncType_;
-  static constexpr const char *func_name_ = func_name;
-
-  static constexpr FuncType *func_ptr() { return func_ptr_; }
-};
-
-// Check if a given type is a compile-time function pointer
-template <class T> struct is_compile_time_function_pointer : std::false_type {};
-template <class FuncType, FuncType *func_ptr, const char *func_name>
-struct is_compile_time_function_pointer<
-    CompileTimeFunctionPointer<FuncType, func_ptr, func_name>>
-    : std::true_type {};
-
-#define EXECUTORCH_FN_TYPE(func, name)                                         \
-  ::executorch::extension::kernel_util_internal::CompileTimeFunctionPointer<   \
-      std::remove_pointer_t<std::remove_reference_t<decltype(func)>>, func,    \
-      name>
-#define EXECUTORCH_FN(func, name) EXECUTORCH_FN_TYPE(func, name)()
-
-/**
- * strip_class: helper to remove the class type from pointers to `operator()`.
- */
-template <typename T> struct strip_class {};
-template <typename Class, typename Result, typename... Args>
-struct strip_class<Result (Class::*)(Args...)> {
-  using type = Result(Args...);
-};
-template <typename Class, typename Result, typename... Args>
-struct strip_class<Result (Class::*)(Args...) const> {
-  using type = Result(Args...);
-};
-template <typename T> using strip_class_t = typename strip_class<T>::type;
-
-/**
- * Access information about result type or arguments from a function type.
- * Example:
- * using A = function_traits<int (float, double)>::return_type // A == int
- * using A = function_traits<int (float, double)>::parameter_types::tuple_type
- * // A == tuple<float, double>
- */
-template <class Func> struct function_traits {
-  static_assert(
-      !std::is_same<Func, Func>::value,
-      "In function_traits<Func>, Func must be a plain function type.");
-};
-template <class Result, class... Args> struct function_traits<Result(Args...)> {
-  using func_type = Result(Args...);
-  using return_type = Result;
-  using parameter_types = typelist<Args...>;
-  static constexpr auto number_of_parameters = sizeof...(Args);
-};
-
-/**
- * infer_function_traits: creates a `function_traits` type for a simple
- * function (pointer) or functor (lambda/struct). Currently does not support
- * class methods.
- */
-template <typename Functor> struct infer_function_traits {
-  using type = function_traits<strip_class_t<decltype(&Functor::operator())>>;
-};
-template <typename Result, typename... Args>
-struct infer_function_traits<Result (*)(Args...)> {
-  using type = function_traits<Result(Args...)>;
-};
-template <typename Result, typename... Args>
-struct infer_function_traits<Result(Args...)> {
-  using type = function_traits<Result(Args...)>;
-};
-template <typename T>
-using infer_function_traits_t = typename infer_function_traits<T>::type;
-
-} // namespace kernel_util_internal
-} // namespace extension
-} // namespace executorch
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/kernel_util/type_list.h b/packages/react-native-executorch/third-party/include/executorch/extension/kernel_util/type_list.h
deleted file mode 100644
index 0da2f2dfb8..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/kernel_util/type_list.h
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-///
-/// \file runtime/kernel/type_list.h
-/// Forked from pytorch/c10/util/TypeList.h
-/// \brief Utilities for working with type lists.
-#pragma once
-
-#include <algorithm>
-#include <cstddef>
-#include <type_traits>
-#include <utility>
-
-namespace executorch {
-namespace extension {
-// This extension has a lot of generic internal names like "size"; use a unique
-// internal namespace to avoid conflicts with other extensions.
-namespace kernel_util_internal {
-
-/**
- * Type holding a list of types for compile time type computations
- *     constexpr size_t num = size<typelist<int, double>>::value;
- *     static_assert(num == 2, "");
- */
-template <class... T> struct false_t : std::false_type {};
-
-template <class... Items> struct typelist final {
-public:
-  typelist() = delete; // not for instantiation
-};
-template <class TypeList> struct size final {
-  static_assert(false_t<TypeList>::value,
-                "In typelist::size<T>, T must be typelist<...>.");
-};
-template <class... Types> struct size<typelist<Types...>> final {
-  static constexpr size_t value = sizeof...(Types);
-};
-
-/**
- * is_instantiation_of<T, I> is true_type iff I is a template instantiation of T
- * (e.g. vector<int> is an instantiation of vector) Example:
- *    is_instantiation_of_t<vector, vector<int>> // true
- *    is_instantiation_of_t<pair, pair<int, string>> // true
- *    is_instantiation_of_t<vector, pair<int, string>> // false
- */
-template <template <class...> class Template, class T>
-struct is_instantiation_of : std::false_type {};
-template <template <class...> class Template, class... Args>
-struct is_instantiation_of<Template, Template<Args...>> : std::true_type {};
-template <template <class...> class Template, class T>
-using is_instantiation_of_t = typename is_instantiation_of<Template, T>::type;
-
-/// Base template.
-template <size_t Index, class TypeList> struct element final {
-  static_assert(
-      false_t<TypeList>::value,
-      "In typelist::element<T>, the T argument must be typelist<...>.");
-};
-/// Successful case, we have reached the zero index and can "return" the head
-/// type.
-template <class Head, class... Tail>
-struct element<0, typelist<Head, Tail...>> {
-  using type = Head;
-};
-/// Error case, we have an index but ran out of types! It will only be selected
-/// if `Ts...` is actually empty!
-template <size_t Index, class... Ts> struct element<Index, typelist<Ts...>> {
-  static_assert(Index < sizeof...(Ts),
-                "Index is out of bounds in typelist::element");
-};
-/// Shave off types until we hit the <0, Head, Tail...> or <Index> case.
-template <size_t Index, class Head, class... Tail>
-struct element<Index, typelist<Head, Tail...>>
-    : element<Index - 1, typelist<Tail...>> {};
-/// Convenience alias.
-template <size_t Index, class TypeList>
-using element_t = typename element<Index, TypeList>::type;
-
-/**
- * Returns the first element of a type list, or the specified default if the
- * type list is empty. Example: int  ==  head_t<bool, typelist<int, string>>
- *   bool  ==  head_t<bool, typelist<>>
- */
-template <class Default, class TypeList> struct head_with_default final {
-  using type = Default;
-};
-template <class Default, class Head, class... Tail>
-struct head_with_default<Default, typelist<Head, Tail...>> final {
-  using type = Head;
-};
-template <class Default, class TypeList>
-using head_with_default_t = typename head_with_default<Default, TypeList>::type;
-
-/**
- * Take/drop a number of arguments from a typelist.
- * Example:
- *   typelist<int, string> == take_t<typelist<int, string, bool>, 2>
- *   typelist<bool> == drop_t<typelist<int, string, bool>, 2>
- */
-template <class TypeList, size_t offset, class IndexSequence>
-struct take_elements final {};
-template <class TypeList, size_t offset, size_t... Indices>
-struct take_elements<TypeList, offset, std::index_sequence<Indices...>> final {
-  using type = typelist<typename element<offset + Indices, TypeList>::type...>;
-};
-
-/**
- * Like drop, but returns an empty list rather than an assertion error if `num`
- * is larger than the size of the TypeList.
- * Example:
- *   typelist<> == drop_if_nonempty_t<typelist<string, bool>, 2>
- *   typelist<> == drop_if_nonempty_t<typelist<int, string, bool>, 3>
- */
-template <class TypeList, size_t num> struct drop_if_nonempty final {
-  static_assert(
-      is_instantiation_of<typelist, TypeList>::value,
-      "In typelist::drop<T, num>, the T argument must be typelist<...>.");
-  using type = typename take_elements<
-      TypeList, std::min(num, size<TypeList>::value),
-      std::make_index_sequence<size<TypeList>::value -
-                               std::min(num, size<TypeList>::value)>>::type;
-};
-template <class TypeList, size_t num>
-using drop_if_nonempty_t = typename drop_if_nonempty<TypeList, num>::type;
-
-} // namespace kernel_util_internal
-} // namespace extension
-} // namespace executorch
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/base64.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/base64.h
deleted file mode 100644
index 9034d7c661..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/base64.h
+++ /dev/null
@@ -1,199 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-// @lint-ignore-every LICENSELINT
-/**************************************************************************
-   Copyright (c) 2023 sewenew
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
- *************************************************************************/
-
-#pragma once
-
-#include <cassert>
-#include <cstdint>
-#include <string>
-#include <string_view>
-
-#include "result.h"
-
-namespace base64 {
-
-using tokenizers::Error;
-using tokenizers::Result;
-
-Result<std::string> decode(const std::string_view& input);
-
-namespace detail {
-
-constexpr uint32_t DECODE_TABLE[] = {
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 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};
-
-inline Error validate(uint32_t v) {
-  if (v == 255) {
-    fprintf(stderr, "invalid char");
-    return Error::Base64DecodeFailure;
-  }
-  return Error::Ok;
-}
-
-inline Error decode(const std::string_view& input, std::string& output) {
-  TK_CHECK_OR_RETURN_ERROR(
-      input.size() == 4,
-      Base64DecodeFailure,
-      "input length must be 4, got %zu",
-      input.size());
-
-  uint32_t val = 0;
-
-  uint8_t c = input[0];
-  auto v = DECODE_TABLE[c];
-  TK_CHECK_OK_OR_RETURN_ERROR(validate(v));
-  val = v;
-
-  c = input[1];
-  v = DECODE_TABLE[c];
-  TK_CHECK_OK_OR_RETURN_ERROR(validate(v));
-  val = (val << 6) | v;
-
-  c = input[2];
-  v = DECODE_TABLE[c];
-  TK_CHECK_OK_OR_RETURN_ERROR(validate(v));
-  val = (val << 6) | v;
-
-  c = input[3];
-  v = DECODE_TABLE[c];
-  TK_CHECK_OK_OR_RETURN_ERROR(validate(v));
-  val = (val << 6) | v;
-
-  output.push_back(static_cast<char>((val >> 16) & 0xFF));
-  output.push_back(static_cast<char>((val >> 8) & 0xFF));
-  output.push_back(static_cast<char>(val & 0xFF));
-  return Error::Ok;
-}
-
-inline Error decode_1_padding(
-    const std::string_view& input,
-    std::string& output) {
-  TK_CHECK_OR_RETURN_ERROR(
-      input.size() == 3,
-      Base64DecodeFailure,
-      "input length must be 3, got %zu",
-      input.size());
-
-  uint32_t val = 0;
-
-  uint8_t c = input[0];
-  auto v = DECODE_TABLE[c];
-  TK_CHECK_OK_OR_RETURN_ERROR(validate(v));
-  val = v;
-
-  c = input[1];
-  v = DECODE_TABLE[c];
-  TK_CHECK_OK_OR_RETURN_ERROR(validate(v));
-  val = (val << 6) | v;
-
-  c = input[2];
-  v = DECODE_TABLE[c];
-  TK_CHECK_OK_OR_RETURN_ERROR(validate(v));
-  val = (val << 6) | v;
-
-  output.push_back(static_cast<char>((val >> 10) & 0xFF));
-  output.push_back(static_cast<char>((val >> 2) & 0xFF));
-  return Error::Ok;
-}
-
-inline Error decode_2_padding(
-    const std::string_view& input,
-    std::string& output) {
-  TK_CHECK_OR_RETURN_ERROR(
-      input.size() == 2,
-      Base64DecodeFailure,
-      "input length must be 2, got %zu",
-      input.size());
-
-  uint32_t val = 0;
-
-  uint8_t c = input[0];
-  auto v = DECODE_TABLE[c];
-  TK_CHECK_OK_OR_RETURN_ERROR(validate(v));
-  val = v;
-
-  c = input[1];
-  v = DECODE_TABLE[c];
-  TK_CHECK_OK_OR_RETURN_ERROR(validate(v));
-  val = (val << 6) | v;
-
-  output.push_back(static_cast<char>((val >> 4) & 0xFF));
-  return Error::Ok;
-}
-
-} // namespace detail
-
-inline tokenizers::Result<std::string> decode(const std::string_view& input) {
-  TK_CHECK_OR_RETURN_ERROR(!input.empty(), Base64DecodeFailure, "empty input");
-
-  // Faster than `input.size() % 4`.
-  TK_CHECK_OR_RETURN_ERROR(
-      (input.size() & 3) == 0 && input.size() >= 4,
-      Base64DecodeFailure,
-      "input length must be larger than 4 and is multiple of 4, got %zu",
-      input.size());
-
-  std::string output;
-  output.reserve(input.size() / 4 * 3);
-  auto idx = 0U;
-  for (; idx < input.size() - 4; idx += 4) {
-    TK_CHECK_OK_OR_RETURN_ERROR(detail::decode(input.substr(idx, 4), output));
-  }
-
-  // Last 4 bytes. Might contain paddings.
-  if (input[idx + 3] == '=') {
-    if (input[idx + 2] == '=') {
-      // Tow paddings.
-      TK_CHECK_OK_OR_RETURN_ERROR(
-          detail::decode_2_padding(input.substr(idx, 2), output));
-    } else {
-      // One padding.
-      TK_CHECK_OK_OR_RETURN_ERROR(
-          detail::decode_1_padding(input.substr(idx, 3), output));
-    }
-  } else {
-    // No padding.
-    TK_CHECK_OK_OR_RETURN_ERROR(detail::decode(input.substr(idx, 4), output));
-  }
-
-  return output;
-}
-} // namespace base64
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/bpe_model.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/bpe_model.h
deleted file mode 100644
index 4ee6d4904b..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/bpe_model.h
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-// @lint-ignore-every LICENSELINT
-
-#pragma once
-
-#include <functional>
-#include <memory>
-#include <optional>
-#include <string>
-#include <unordered_set>
-#include <vector>
-
-#include <pytorch/tokenizers/map_utils.h>
-#include <pytorch/tokenizers/model.h>
-#include <pytorch/tokenizers/regex.h>
-#include <pytorch/tokenizers/result.h>
-#include <pytorch/tokenizers/string_integer_map.h>
-
-namespace tokenizers {
-
-class BPEModel : public Model {
- public:
-  explicit BPEModel(
-      detail::TokenMap token_map,
-      detail::TokenMap special_token_map,
-      std::optional<detail::TokenMap> merge_ranks,
-      std::unique_ptr<IRegex> special_token_regex,
-      bool byte_fallback,
-      std::optional<uint64_t> unk_token_id,
-      std::optional<uint64_t> bos_token_id,
-      std::optional<uint64_t> eos_token_id,
-      std::unordered_set<std::string> rstrip_tokens = {},
-      std::unordered_set<std::string> lstrip_tokens = {});
-
-  ~BPEModel() override = default;
-
-  Result<std::vector<uint64_t>> tokenize(
-      const std::string& piece) const override;
-
-  Result<std::string> id_to_piece(uint64_t token) const override;
-  Result<uint64_t> piece_to_id(const std::string& token) const override;
-
-  int32_t vocab_size() const override {
-    return vocab_size_;
-  }
-
-  bool is_special_token(uint64_t token) const override;
-
-  bool is_loaded() const override {
-    return initialized_;
-  }
-
-  std::pair<std::optional<std::string>, std::string>
-  split_with_allowed_special_token(const std::string& input, size_t offset)
-      const override;
-
-  bool special_token_has_rstrip(const std::string& token) const override {
-    return rstrip_tokens_.count(token) > 0;
-  }
-  bool special_token_has_lstrip(const std::string& token) const override {
-    return lstrip_tokens_.count(token) > 0;
-  }
-
-  uint64_t bos_token_id() const override {
-    return bos_token_id_.value_or(0);
-  }
-
-  uint64_t eos_token_id() const override {
-    return eos_token_id_.value_or(0);
-  }
-
- private:
-  Result<std::pair<std::vector<uint64_t>, uint64_t>> encode_with_special_token(
-      const std::string& text) const;
-
-  Result<std::vector<uint64_t>> byte_pair_encode(const std::string& piece) const;
-
-  std::vector<uint64_t> byte_pair_merge(
-      const std::string& piece,
-      const detail::TokenMap& ranks,
-      std::function<uint64_t(uint64_t, uint64_t)> func) const;
-
-  // Real state
-  detail::TokenMap token_map_;
-  detail::TokenMap special_token_map_;
-  std::optional<detail::TokenMap> merge_ranks_;
-  std::unique_ptr<IRegex> special_token_regex_;
-
-  bool byte_fallback_ = false;
-  std::optional<uint64_t> unk_token_id_;
-  std::optional<uint64_t> bos_token_id_;
-  std::optional<uint64_t> eos_token_id_;
-  std::unordered_set<std::string> rstrip_tokens_;
-  std::unordered_set<std::string> lstrip_tokens_;
-
-  bool initialized_ = false;
-  int32_t vocab_size_ = 0;
-};
-
-} // namespace tokenizers
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/bpe_tokenizer_base.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/bpe_tokenizer_base.h
deleted file mode 100644
index f83dc1e78b..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/bpe_tokenizer_base.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-// @lint-ignore-every LICENSELINT
-
-// Base class for all BPE tokenizer implementations
-#pragma once
-
-// Standard
-#include <memory>
-#include <optional>
-#include <string>
-#include <type_traits>
-#include <unordered_map>
-#include <vector>
-
-// Local
-#include <pytorch/tokenizers/error.h>
-#include <pytorch/tokenizers/map_utils.h>
-#include <pytorch/tokenizers/regex.h>
-#include <pytorch/tokenizers/result.h>
-#include <pytorch/tokenizers/string_integer_map.h>
-#include <pytorch/tokenizers/tokenizer.h>
-
-#include "re2/re2.h"
-
-namespace tokenizers {
-namespace detail {
-
-class BPETokenizerBase : public Tokenizer {
- public:
-  Result<std::vector<uint64_t>>
-  encode(const std::string& input, int8_t bos, int8_t eos) const override;
-
-  Result<std::string> id_to_piece(uint64_t token) const override;
-  Result<uint64_t> piece_to_id(const std::string& text) const override;
-
-  Result<std::string> decode(
-      uint64_t prev_token,
-      uint64_t token,
-      bool skip_special_tokens = false) const override;
-
- protected:
-  explicit BPETokenizerBase() {}
-  virtual ~BPETokenizerBase() override {}
-
-  std::pair<std::optional<std::string>, std::string>
-  split_with_allowed_special_token_(
-      const std::string& input,
-      const TokenMap& allowed_special) const;
-
-  std::pair<std::optional<std::string>, std::string>
-  split_with_allowed_special_token_(
-      const std::string& input,
-      size_t offset,
-      const TokenMap& allowed_special) const;
-
-  Result<std::pair<std::vector<uint64_t>, uint64_t>> encode_with_special_token_(
-      const std::string& text,
-      const TokenMap& allowed_special) const;
-
-  virtual Result<std::vector<uint64_t>> byte_pair_encode_(
-      const std::string& piece,
-      const TokenMap& encoder) const;
-
-  // Virtual method for BPE merging - can be overridden by derived classes
-  // The passed in `ranks` param for the base impl is just a regular token map
-  // and that the actual ranks are derived implicitly from the regular token
-  // map. This is the same implementation as Tiktoken.
-  virtual std::vector<uint64_t> _byte_pair_merge(
-      const std::string& piece,
-      const TokenMap& ranks,
-      std::function<uint64_t(uint64_t, uint64_t)> func) const;
-
-  // Protected members that can be overloaded by other BPE tokenizers
-  std::unique_ptr<IRegex> special_token_regex_;
-  std::optional<TokenMap> token_map_;
-  std::optional<TokenMap> special_token_map_;
-
- private:
-  virtual Error _encode(
-      const std::string& input,
-      std::vector<uint64_t>& ret,
-      uint64_t& last_piece_token_len) const = 0;
-
-  virtual void _decode(const std::string& input, std::string& ret) const = 0;
-};
-
-} // namespace detail
-} // namespace tokenizers
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/compiler.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/compiler.h
deleted file mode 100644
index c13042f7aa..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/compiler.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// @lint-ignore-every LICENSELINT
-
-#pragma once
-
-/**
- * @file
- * Compiler and platform-specific declarations.
- */
-
-#ifdef _WIN32
-#include <BaseTsd.h>
-// ssize_t isn't available on Windows. Alias it to the Windows SSIZE_T value.
-typedef SSIZE_T ssize_t;
-#endif
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/error.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/error.h
deleted file mode 100644
index f12fda2a79..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/error.h
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @file
- * Tokenizers Error declarations.
- */
-
-#pragma once
-
-#include <pytorch/tokenizers/log.h>
-#include <stdint.h>
-
-namespace tokenizers {
-
-// Alias error code integral type to minimal platform width (32-bits for now).
-typedef uint32_t error_code_t;
-
-/**
- * ExecuTorch Error type.
- */
-enum class Error : error_code_t {
-  /*
-   * System errors.
-   */
-
-  /// Status indicating a successful operation.
-  Ok = 0x00,
-
-  /// An internal error occurred.
-  Internal = 0x01,
-
-  /// Tokenizer uninitialized.
-  Uninitialized = 0x02,
-
-  /// Token out of range.
-  OutOfRange = 0x03,
-
-  /// Tokenizer artifact load failure.
-  LoadFailure = 0x04,
-
-  /// Encode failure.
-  EncodeFailure = 0x05,
-
-  /// Base64 decode failure.
-  Base64DecodeFailure = 0x06,
-
-  /// Failed to parse tokenizer artifact.
-  ParseFailure = 0x07,
-
-  /// Decode failure.
-  DecodeFailure = 0x08,
-
-  /// No suitable regex implementation found.
-  RegexFailure = 0x09,
-};
-
-} // namespace tokenizers
-
-/**
- * If cond__ is false, return the specified Error
- * from the current function, which must be of return type
- * tokenizers::Error.
- * TODO: Add logging support
- * @param[in] cond__ The condition to be checked, asserted as true.
- * @param[in] error__ Error enum value to return without the `Error::` prefix,
- * like `Base64DecodeFailure`.
- * @param[in] message__ Format string for the log error message.
- * @param[in] ... Optional additional arguments for the format string.
- */
-#define TK_CHECK_OR_RETURN_ERROR(cond__, error__, message__, ...) \
-  {                                                               \
-    if (!(cond__)) {                                              \
-      TK_LOG(Error, message__, ##__VA_ARGS__);                    \
-      return ::tokenizers::Error::error__;                        \
-    }                                                             \
-  }
-
-/**
- * If error__ is not Error::Ok, return the specified Error
- * @param[in] error__ Error enum value to return without the `Error::` prefix,
- * like `Base64DecodeFailure`.
- */
-#define TK_CHECK_OK_OR_RETURN_ERROR(error__)     \
-  do {                                           \
-    const auto et_error__ = (error__);           \
-    if (et_error__ != ::tokenizers::Error::Ok) { \
-      return et_error__;                         \
-    }                                            \
-  } while (0)
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/hf_tokenizer.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/hf_tokenizer.h
deleted file mode 100644
index 130e7e603d..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/hf_tokenizer.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// Used by many Huggingface models. Adapted from a combination of the original
-// rust implementation (https://github.com/huggingface/tokenizers/tree/main)
-// and the corresponding support in llama.cpp
-// (https://github.com/ggerganov/llama.cpp)
-#pragma once
-
-// Standard
-#include <string>
-#include <memory>
-#include <vector>
-
-// Local
-#include <nlohmann/json.hpp>
-#include <pytorch/tokenizers/error.h>
-#include <pytorch/tokenizers/map_utils.h>
-#include <pytorch/tokenizers/model.h>
-#include <pytorch/tokenizers/regex.h>
-#include <pytorch/tokenizers/normalizer.h>
-#include <pytorch/tokenizers/padding.h>
-#include <pytorch/tokenizers/post_processor.h>
-#include <pytorch/tokenizers/pre_tokenizer.h>
-#include <pytorch/tokenizers/result.h>
-#include <pytorch/tokenizers/token_decoder.h>
-#include <pytorch/tokenizers/tokenizer.h>
-#include <pytorch/tokenizers/truncation.h>
-
-namespace tokenizers {
-
-class HFTokenizer : public Tokenizer {
- public:
-  /*-- Public Interface --*/
-
-  /**
-   * Default initialize with no loaded data
-   */
-  explicit HFTokenizer() {}
-  ~HFTokenizer() {}
-
-  /**
-   * Load the model data into the
-   */
-  Error load(const std::string& tokenizer_path) override;
-
-  Result<std::vector<uint64_t>> encode(
-      const std::string& input,
-      int8_t bos = 0,
-      int8_t eos = 0) const override;
-
-  Result<std::string> id_to_piece(uint64_t token) const override;
-  Result<uint64_t> piece_to_id(const std::string& text) const override;
-
-  Result<std::string> decode(
-      uint64_t prev_token,
-      uint64_t token,
-      bool skip_special_tokens = false) const override;
-
-  Result<std::string> decode(
-      const std::vector<uint64_t>& tokens,
-      bool skip_special_tokens = false) const;
-
- private:
-  Error setup_normalizer(const nlohmann::json& parsed_json);
-  Error setup_pretokenizer(const nlohmann::json& parsed_json);
-  Error setup_postprocessor(const nlohmann::json& parsed_json);
-  Error setup_decoder(const nlohmann::json& parsed_json);
-  Error setup_truncation(const nlohmann::json& parsed_json);
-  Error setup_padding(const nlohmann::json& parsed_json);
-  Error setup_model(
-      const nlohmann::json& parsed_json,
-      const std::string& model_config_path,
-      const std::string& special_tokens_map_path);
-
-  /// Split input around the first added_token match. Returns (matched token,
-  /// text before match). Uses _added_token_regex if available, otherwise
-  /// falls back to the model's special-only regex.
-  std::pair<std::optional<std::string>, std::string>
-  split_added_token(const std::string& input, size_t offset) const;
-
-  Normalizer::Ptr normalizer_;
-  PreTokenizer::Ptr pretokenizer_;
-  PostProcessor::Ptr postprocessor_;
-  TokenDecoder::Ptr decoder_;
-  Truncation::Ptr truncation_;
-  Padding::Ptr padding_;
-
-  Model::Ptr model_;
-
-  // Regex matching ALL added_tokens (both special and non-special).
-  // HF matches every added_token as a never-split unit during encoding.
-  // This is separate from the model's special_token_regex which only
-  // contains special=true tokens (for standalone model.tokenize()).
-  std::unique_ptr<IRegex> added_token_regex_;
-  std::unique_ptr<detail::TokenMap> added_token_map_;
-};
-
-} // namespace tokenizers
\ No newline at end of file
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/llama2c_tokenizer.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/llama2c_tokenizer.h
deleted file mode 100644
index 058740d0e2..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/llama2c_tokenizer.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-// @lint-ignore-every CLANGTIDY facebook-hte-RelativeInclude
-#pragma once
-#include <pytorch/tokenizers/tokenizer.h>
-#include <memory>
-
-namespace tokenizers {
-
-// A simple Byte Pair Encoding (BPE) Tokenizer. Note that the current C++ code
-// won't work with this class, it needs to go through tokenizer.py first.
-class Llama2cTokenizer : public Tokenizer {
- public:
-  explicit Llama2cTokenizer();
-  ~Llama2cTokenizer() override;
-
-  Error load(const std::string& tokenizer_path) override;
-
-  Result<std::string> id_to_piece(uint64_t token) const override;
-  Result<uint64_t> piece_to_id(const std::string& text) const override;
-
-  Result<std::vector<uint64_t>>
-  encode(const std::string& input, int8_t bos, int8_t eos) const override;
-
-  Result<std::string> decode(
-      uint64_t prev_token,
-      uint64_t token,
-      bool skip_special_tokens = false) const override;
-
- private:
-  inline Error _decode_verify(uint64_t token) const {
-    if (!initialized_) {
-      return Error::Uninitialized;
-    }
-    if (token >= vocab_size_) {
-      return Error::OutOfRange;
-    }
-    return Error::Ok;
-  }
-  std::unique_ptr<char*[]> vocab_ = nullptr;
-  std::unique_ptr<float[]> vocab_scores_ = nullptr;
-  std::unique_ptr<TokenIndex[]> sorted_vocab_ = nullptr;
-  unsigned int max_token_length_ = 0;
-  unsigned char byte_pieces_[512]; // stores all single-byte strings
-};
-
-} // namespace tokenizers
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/log.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/log.h
deleted file mode 100644
index 0282a2ca21..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/log.h
+++ /dev/null
@@ -1,303 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @file
- * Tokenizers logging API, adopted from ExecuTorch.
- */
-
-#pragma once
-
-#include <cstdarg>
-#include <cstddef>
-#include <cstdint>
-#include <cstdio>
-#include <cstdlib>
-
-// Set minimum log severity if compiler option is not provided.
-#ifndef TK_MIN_LOG_LEVEL
-#define TK_MIN_LOG_LEVEL Info
-#endif // !defined(TK_MIN_LOG_LEVEL)
-
-/*
- * Enable logging by default if compiler option is not provided.
- * This should facilitate less confusion for those developing Tokenizers.
- */
-#ifndef TK_LOG_ENABLED
-#define TK_LOG_ENABLED 1
-#endif // !defined(TK_LOG_ENABLED)
-
-/**
- * Annotation marking a function as printf-like, providing compiler support
- * for format string argument checking.
- */
-#ifdef _MSC_VER
-#include <sal.h>
-#define TK_PRINTFLIKE(_string_index, _va_index) _Printf_format_string_
-#else
-#define TK_PRINTFLIKE(_string_index, _va_index) \
-  __attribute__((format(printf, _string_index, _va_index)))
-#endif
-
-/// Define a C symbol with weak linkage.
-#ifdef _MSC_VER
-// There currently doesn't seem to be a great way to do this in Windows and
-// given that weak linkage is not really critical on Windows, we'll just leave
-// it as a stub.
-#define TK_WEAK
-#else
-#define TK_WEAK __attribute__((weak))
-#endif
-
-#ifndef __has_builtin
-#define __has_builtin(x) (0)
-#endif
-
-#if __has_builtin(__builtin_strrchr)
-/// Name of the source file without a directory string.
-#define TK_SHORT_FILENAME (__builtin_strrchr("/" __FILE__, '/') + 1)
-#else
-#define TK_SHORT_FILENAME __FILE__
-#endif
-
-#if __has_builtin(__builtin_LINE)
-/// Current line as an integer.
-#define TK_LINE __builtin_LINE()
-#else
-#define TK_LINE __LINE__
-#endif // __has_builtin(__builtin_LINE)
-
-#if __has_builtin(__builtin_FUNCTION)
-/// Name of the current function as a const char[].
-#define TK_FUNCTION __builtin_FUNCTION()
-#else
-#define TK_FUNCTION __FUNCTION__
-#endif // __has_builtin(__builtin_FUNCTION)
-
-/**
- * Clients should neither define nor use this macro. Used to optionally declare
- * the tk_pal_*() functions as weak symbols.
- *
- * This provides a way to both:
- * - Include the header and define weak symbols (used by the internal default
- *   implementations)
- * - Include the header and define strong symbols (used by client overrides)
- */
-#ifndef TK_INTERNAL_PLATFORM_WEAKNESS
-#define TK_INTERNAL_PLATFORM_WEAKNESS TK_WEAK
-#endif // !defined(TK_INTERNAL_PLATFORM_WEAKNESS)
-
-// TODO: making an assumption that we have stderr
-#define TK_LOG_OUTPUT_FILE stderr
-
-namespace tokenizers {
-
-extern "C" {
-/**
- * Severity level of a log message. Values must map to printable 7-bit ASCII
- * uppercase letters.
- */
-typedef enum {
-  kDebug = 'D',
-  kInfo = 'I',
-  kError = 'E',
-  kFatal = 'F',
-  kUnknown = '?', // Exception to the "uppercase letter" rule.
-} tk_pal_log_level_t;
-
-/**
- * Emit a log message via platform output (serial port, console, etc).
- *
- * @param[in] level Severity level of the message. Must be a printable 7-bit
- *     ASCII uppercase letter.
- * @param[in] filename Name of the file that created the log event.
- * @param[in] function Name of the function that created the log event.
- * @param[in] line Line in the source file where the log event was created.
- * @param[in] message Message string to log.
- * @param[in] length Message string length.
- */
-inline void TK_INTERNAL_PLATFORM_WEAKNESS tk_pal_emit_log_message(
-    tk_pal_log_level_t level,
-    const char* filename,
-    const char* function,
-    size_t line,
-    const char* message,
-    size_t length) {
-  // Use a format similar to glog and folly::logging, except:
-  // - Print time since et_pal_init since we don't have wall time
-  // - Don't include the thread ID, to avoid adding a threading dependency
-  // - Add the string "tokenizers:" to make the logs more searchable
-  //
-  // Clients who want to change the format or add other fields can override this
-  // weak implementation of et_pal_emit_log_message.
-  fprintf(
-      TK_LOG_OUTPUT_FILE,
-      "%c tokenizers:%s:%zu] %s\n",
-      level,
-      filename,
-      line,
-      message);
-  fflush(TK_LOG_OUTPUT_FILE);
-}
-
-} // extern "C"
-/**
- * Severity level of a log message. Must be ordered from lowest to highest
- * severity.
- */
-enum class LogLevel : uint8_t {
-  /**
-   * Log messages provided for highly granular debuggability.
-   *
-   * Log messages using this severity are unlikely to be compiled by default
-   * into most debug builds.
-   */
-  Debug,
-
-  /**
-   * Log messages providing information about the state of the system
-   * for debuggability.
-   */
-  Info,
-
-  /**
-   * Log messages about errors within Tokenizers during runtime.
-   */
-  Error,
-
-  /**
-   * Log messages that precede a fatal error. However, logging at this level
-   * does not perform the actual abort, something else needs to.
-   */
-  Fatal,
-
-  /**
-   * Number of supported log levels, with values in [0, NumLevels).
-   */
-  NumLevels,
-};
-
-namespace internal {
-
-/**
- * Maps LogLevel values to et_pal_log_level_t values.
- *
- * We don't share values because LogLevel values need to be ordered by severity,
- * and et_pal_log_level_t values need to be printable characters.
- */
-static constexpr tk_pal_log_level_t kLevelToPal[size_t(LogLevel::NumLevels)] = {
-    tk_pal_log_level_t::kDebug,
-    tk_pal_log_level_t::kInfo,
-    tk_pal_log_level_t::kError,
-    tk_pal_log_level_t::kFatal,
-};
-
-// TODO: add timestamp support
-
-/**
- * Log a string message.
- *
- * Note: This is an internal function. Use the `ET_LOG` macro instead.
- *
- * @param[in] level Log severity level.
- * @param[in] filename Name of the source file creating the log event.
- * @param[in] function Name of the function creating the log event.
- * @param[in] line Source file line of the caller.
- * @param[in] format Format string.
- * @param[in] args Variable argument list.
- */
-TK_PRINTFLIKE(5, 0)
-inline void vlogf(
-    LogLevel level,
-    const char* filename,
-    const char* function,
-    size_t line,
-    const char* format,
-    va_list args) {
-  // Maximum length of a log message.
-  static constexpr size_t kMaxLogMessageLength = 256;
-  char buf[kMaxLogMessageLength];
-  size_t len = vsnprintf(buf, kMaxLogMessageLength, format, args);
-  if (len >= kMaxLogMessageLength - 1) {
-    buf[kMaxLogMessageLength - 2] = '$';
-    len = kMaxLogMessageLength - 1;
-  }
-  buf[kMaxLogMessageLength - 1] = 0;
-
-  tk_pal_log_level_t pal_level =
-      (int(level) >= 0 && level < LogLevel::NumLevels)
-      ? kLevelToPal[size_t(level)]
-      : tk_pal_log_level_t::kUnknown;
-
-  tk_pal_emit_log_message(pal_level, filename, function, line, buf, len);
-}
-
-/**
- * Log a string message.
- *
- * Note: This is an internal function. Use the `ET_LOG` macro instead.
- *
- * @param[in] level Log severity level.
- * @param[in] filename Name of the source file creating the log event.
- * @param[in] function Name of the function creating the log event.
- * @param[in] line Source file line of the caller.
- * @param[in] format Format string.
- */
-TK_PRINTFLIKE(5, 6)
-inline void logf(
-    LogLevel level,
-    const char* filename,
-    const char* function,
-    size_t line,
-    const char* format,
-    ...) {
-#if TK_LOG_ENABLED
-  va_list args;
-  va_start(args, format);
-  internal::vlogf(level, filename, function, line, format, args);
-  va_end(args);
-#endif // TK_LOG_ENABLED
-}
-
-} // namespace internal
-
-} // namespace tokenizers
-
-#if TK_LOG_ENABLED
-
-/**
- * Log a message at the given log severity level.
- *
- * @param[in] _level Log severity level.
- * @param[in] _format Log message format string.
- */
-#define TK_LOG(_level, _format, ...)                                       \
-  do {                                                                     \
-    const auto _log_level = ::tokenizers::LogLevel::_level;                \
-    if (static_cast<uint32_t>(_log_level) >=                               \
-        static_cast<uint32_t>(::tokenizers::LogLevel::TK_MIN_LOG_LEVEL)) { \
-      ::tokenizers::internal::logf(                                        \
-          _log_level,                                                      \
-          TK_SHORT_FILENAME,                                               \
-          TK_FUNCTION,                                                     \
-          TK_LINE,                                                         \
-          _format,                                                         \
-          ##__VA_ARGS__);                                                  \
-    }                                                                      \
-  } while (0)
-#else // TK_LOG_ENABLED
-
-/**
- * Log a message at the given log severity level.
- *
- * @param[in] _level Log severity level.
- * @param[in] _format Log message format string.
- */
-#define TK_LOG(_level, _format, ...) ((void)0)
-
-#endif // TK_LOG_ENABLED
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/map_utils.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/map_utils.h
deleted file mode 100644
index 42a049ef8d..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/map_utils.h
+++ /dev/null
@@ -1,217 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-// @lint-ignore-every LICENSELINT
-
-#pragma once
-
-#include <algorithm>
-#include <memory>
-#include <string>
-#include <type_traits>
-#include <unordered_map>
-#include <vector>
-
-#include <pytorch/tokenizers/error.h>
-#include <pytorch/tokenizers/regex.h>
-#include <pytorch/tokenizers/result.h>
-#include <pytorch/tokenizers/string_integer_map.h>
-
-#include "re2/re2.h"
-
-namespace tokenizers {
-namespace detail {
-
-// Hash function for std::pair<uint64_t, uint64_t>
-struct PairHash {
-  std::size_t operator()(const std::pair<uint64_t, uint64_t>& p) const {
-    return std::hash<uint64_t>{}(p.first) ^
-        (std::hash<uint64_t>{}(p.second) << 1);
-  }
-};
-
-// Type alias for BPE merge map: (token_id_1, token_id_2) -> (rank,
-// merged_token_id)
-using MergeMap = std::unordered_map<
-    std::pair<uint64_t, uint64_t>,
-    std::pair<uint64_t, uint64_t>,
-    PairHash>;
-
-using TokenMap = StringIntegerMap<>;
-
-template <typename TToken, typename TRank>
-static Result<TokenMap> build_token_map(
-    std::vector<std::pair<TToken, TRank>> container) {
-  static_assert(
-      std::is_same_v<TToken, std::string> ||
-          std::is_same_v<TToken, std::string_view>,
-      "TToken must be std::string or std::string_view");
-  static_assert(
-      std::is_integral_v<TRank> && std::is_unsigned_v<TRank>,
-      "TRank must be an unsigned integer");
-
-  std::sort(
-      container.begin(), container.end(), [](const auto& a, const auto& b) {
-        return a.first < b.first;
-      });
-
-  auto duplicate_begin = std::unique(
-      container.begin(), container.end(), [](const auto& a, const auto& b) {
-        return a.first == b.first;
-      });
-
-  TK_CHECK_OR_RETURN_ERROR(
-      duplicate_begin == container.end(),
-      ParseFailure,
-      "duplicate token: %s rank: %llu",
-      duplicate_begin->first.c_str(),
-      static_cast<unsigned long long>(duplicate_begin->second));
-
-  std::sort(
-      container.begin(), container.end(), [](const auto& a, const auto& b) {
-        return a.second < b.second;
-      });
-
-  duplicate_begin = std::unique(
-      container.begin(), container.end(), [](const auto& a, const auto& b) {
-        return a.second == b.second;
-      });
-
-  TK_CHECK_OR_RETURN_ERROR(
-      duplicate_begin == container.end(),
-      ParseFailure,
-      "duplicate rank: %llu"
-      " token: %s",
-      static_cast<unsigned long long>(duplicate_begin->second),
-      duplicate_begin->first.c_str());
-
-  return TokenMap(container);
-};
-
-template <typename TContainer, typename TTokenAccessor, typename TRankAccessor>
-static Result<TokenMap> build_token_map(
-    const TContainer& container,
-    TTokenAccessor token_accessor,
-    TRankAccessor rank_accessor) {
-  using TokenType = std::invoke_result_t<TTokenAccessor, const TContainer&>;
-  using RankType = std::invoke_result_t<TRankAccessor, const TContainer&>;
-
-  static_assert(
-      std::is_same_v<TokenType, std::string> ||
-          std::is_same_v<TokenType, std::string_view>,
-      "TokenType must be std::string or std::string_view");
-  static_assert(
-      std::is_integral_v<RankType> && std::is_unsigned_v<RankType>,
-      "RankType must be an unsigned integer");
-
-  std::vector<std::pair<TokenType, RankType>> pairs;
-  pairs.reserve(container.size());
-  for (const auto& value : container) {
-    pairs.emplace_back(token_accessor(value), rank_accessor(value));
-  }
-
-  return build_token_map(std::move(pairs));
-}
-
-// Utility function to build merge ranks map from merge rules
-template <typename TMergeMap>
-inline Result<TokenMap> build_merge_ranks_map(
-    const TMergeMap& merge_map,
-    const TokenMap& token_map) {
-  // Static assertions to verify TMergeMap has the expected key and value types
-  using KeyType = typename TMergeMap::key_type;
-  using ValueType = typename TMergeMap::mapped_type;
-
-  static_assert(
-      std::is_same_v<KeyType, std::pair<uint64_t, uint64_t>>,
-      "TMergeMap key type must be std::pair<uint64_t, uint64_t>");
-
-  static_assert(
-      std::is_same_v<ValueType, std::pair<uint64_t, uint64_t>>,
-      "TMergeMap value type must be std::pair<uint64_t, uint64_t>");
-
-  // Use a map to handle duplicates - keep the lowest rank (highest priority)
-  std::unordered_map<std::string, uint64_t> unique_merge_ranks;
-
-  for (const auto& [pair, rank_and_id] : merge_map) {
-    uint64_t first_id = pair.first;
-    uint64_t second_id = pair.second;
-    uint64_t rank = rank_and_id.first;
-
-    // Get the token strings for the pair
-    auto first_token = token_map.tryGetString(first_id);
-    auto second_token = token_map.tryGetString(second_id);
-
-    if (first_token && second_token) {
-      std::string merged_token =
-          std::string(*first_token) + std::string(*second_token);
-
-      // Keep the entry with the lowest rank (highest priority in BPE)
-      auto it = unique_merge_ranks.find(merged_token);
-      if (it == unique_merge_ranks.end() || rank < it->second) {
-        unique_merge_ranks[merged_token] = rank;
-      }
-    }
-  }
-
-  // Convert to vector for buildTokenMap
-  std::vector<std::pair<std::string, uint64_t>> merge_rank_pairs;
-  merge_rank_pairs.reserve(unique_merge_ranks.size());
-
-  for (const auto& [token, rank] : unique_merge_ranks) {
-    merge_rank_pairs.emplace_back(token, rank);
-  }
-
-  return build_token_map(std::move(merge_rank_pairs));
-}
-
-inline Result<std::unique_ptr<IRegex>> build_special_token_regex(
-    const TokenMap& special_token_map) {
-  std::string special_pattern;
-  const std::size_t count = special_token_map.size();
-
-  for (std::size_t i = 0; i < count; ++i) {
-    const auto& [token, _] = special_token_map.getElement(i);
-    if (!special_pattern.empty()) {
-      special_pattern += "|";
-    }
-    special_pattern += re2::RE2::QuoteMeta(std::string(token));
-  }
-
-  if (special_pattern.empty()) {
-    return static_cast<std::unique_ptr<IRegex>>(nullptr);
-  }
-  // Wrap pattern in parentheses for proper grouping
-  return create_regex("(" + special_pattern + ")");
-}
-
-/// Shared implementation: split input around the first regex-matched token
-/// that exists in the token map. Used by all Model implementations.
-inline std::pair<std::optional<std::string>, std::string>
-split_with_special_token(
-    const IRegex* regex,
-    const TokenMap& token_map,
-    const std::string& input,
-    size_t offset) {
-  if (!regex) {
-    return {std::nullopt, input.substr(offset)};
-  }
-
-  auto matches = regex->find_all(input.substr(offset));
-
-  for (const auto& m : matches) {
-    std::string matched_text = input.substr(offset + m.start, m.end - m.start);
-    if (token_map.tryGetInteger(matched_text).has_value()) {
-      return {matched_text, input.substr(offset, m.start)};
-    }
-  }
-
-  return {std::nullopt, input.substr(offset)};
-}
-
-} // namespace detail
-} // namespace tokenizers
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/model.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/model.h
deleted file mode 100644
index 4bb24ea8d7..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/model.h
+++ /dev/null
@@ -1,201 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-// @lint-ignore-every LICENSELINT
-
-#pragma once
-
-#include <memory>
-#include <optional>
-#include <string>
-#include <unordered_set>
-#include <vector>
-
-#include <nlohmann/json.hpp>
-#include <pytorch/tokenizers/map_utils.h>
-#include <pytorch/tokenizers/result.h>
-#include <pytorch/tokenizers/string_integer_map.h>
-
-namespace tokenizers {
-
-// -- Base ---------------------------------------------------------------------
-
-/**
- * Abstract base class for tokenization models.
- *
- * A Model corresponds to the core logic that converts a piece of text (usually
- * resulting from the pre-tokenization step) into a sequence of token IDs, and
- * vice-versa.
- *
- * It encapsulates the vocabulary and the algorithm (e.g., BPE, WordPiece,
- * Unigram).
- */
-class Model {
- public:
-  using Ptr = std::unique_ptr<Model>;
-
-  virtual ~Model() = default;
-
-  /**
-   * Tokenizes a string piece into a sequence of token IDs.
-   *
-   * @param piece The input string to tokenize.
-   * @return A Result containing the vector of token IDs.
-   */
-  virtual Result<std::vector<uint64_t>> tokenize(
-      const std::string& piece) const = 0;
-
-  /**
-   * Converts a token ID to its string representation.
-   *
-   * @param token The token ID.
-   * @return A Result containing the string representation of the token.
-   */
-  virtual Result<std::string> id_to_piece(uint64_t token) const = 0;
-
-  /**
-   * Converts a string representation to its token ID.
-   *
-   * @param piece The string representation of the token.
-   * @return A Result containing the token ID.
-   */
-  virtual Result<uint64_t> piece_to_id(const std::string& piece) const = 0;
-
-  /**
-   * Returns the size of the vocabulary.
-   *
-   * @return The number of tokens in the vocabulary.
-   */
-  virtual int32_t vocab_size() const = 0;
-
-  /**
-   * Returns whether the token is a special token.
-   *
-   * @param token The token ID.
-   * @return True if the token is a special token, false otherwise.
-   */
-  virtual bool is_special_token(uint64_t token) const = 0;
-
-  /**
-   * Returns whether the model is loaded.
-   *
-   * @return True if the model is loaded, false otherwise.
-   */
-  virtual bool is_loaded() const = 0;
-
-  /**
-   * Helper to split input text into a special token and the preceding regular text.
-   * 
-   * @param input The input string.
-   * @param offset The starting offset.
-   * @return A pair of (matched special token string, preceding regular text).
-   */
-  virtual std::pair<std::optional<std::string>, std::string>
-  split_with_allowed_special_token(const std::string& input, size_t offset)
-      const = 0;
-
-  virtual uint64_t bos_token_id() const = 0;
-  virtual uint64_t eos_token_id() const = 0;
-
-  virtual bool special_token_has_rstrip(const std::string& token) const {
-    return false;
-  }
-  virtual bool special_token_has_lstrip(const std::string& token) const {
-    return false;
-  }
-};
-
-// -- Shared types -------------------------------------------------------------
-
-/// Resolved BOS/EOS/UNK token IDs, produced by resolve_sequence_tokens().
-struct SequenceTokenIds {
-  std::optional<uint64_t> unk_token_id;
-  std::optional<uint64_t> bos_token_id;
-  std::optional<uint64_t> eos_token_id;
-};
-
-// -- Factory ------------------------------------------------------------------
-
-// Helper macro to standardize addition of config member fields
-#define MODEL_CONFIG_MEMBER(type, name) \
-  std::optional<type> name;             \
-  ModelConfig& set_##name(type arg) {   \
-    this->name = std::move(arg);        \
-    return *this;                       \
-  }
-
-/**
- * Factory and config class for creating a new Model
- */
-class ModelConfig {
- public:
-  std::string type;
-
-  // Data for BPEModel
-  using TokenPairs = std::vector<std::pair<std::string, uint64_t>>;
-  MODEL_CONFIG_MEMBER(TokenPairs, token_pairs)
-  MODEL_CONFIG_MEMBER(TokenPairs, special_token_pairs)
-  // All added_tokens (special + non-special) — used for encoding regex only.
-  MODEL_CONFIG_MEMBER(TokenPairs, all_added_token_pairs)
-
-  // Tokens with rstrip=true consume leading whitespace after the token;
-  // tokens with lstrip=true consume trailing whitespace before the token.
-  std::unordered_set<std::string> rstrip_tokens;
-  std::unordered_set<std::string> lstrip_tokens;
-
-  MODEL_CONFIG_MEMBER(std::vector<std::string>, merges)
-  MODEL_CONFIG_MEMBER(bool, byte_fallback)
-  MODEL_CONFIG_MEMBER(std::string, unk_token)
-  MODEL_CONFIG_MEMBER(std::string, bos_token)
-  MODEL_CONFIG_MEMBER(std::string, eos_token)
-  MODEL_CONFIG_MEMBER(std::string, continuing_subword_prefix)
-  MODEL_CONFIG_MEMBER(size_t, max_input_chars_per_word)
-
-  // Data for UnigramModel
-  using UnigramVocab = std::vector<std::pair<std::string, double>>;
-  MODEL_CONFIG_MEMBER(UnigramVocab, unigram_vocab)
-  MODEL_CONFIG_MEMBER(size_t, unigram_unk_id)
-
-  // Paths for extra config files (HuggingFace specific)
-  MODEL_CONFIG_MEMBER(std::string, model_config_path)
-  MODEL_CONFIG_MEMBER(std::string, special_tokens_map_path)
-
-  ModelConfig() = default;
-
-  /**
-   * Populate from a json config file (the root tokenizer.json)
-   */
-  ModelConfig& parse_json(const nlohmann::json& json_config);
-
-  /**
-   * Construct the model instance from the member data
-   */
-  Model::Ptr create() const;
-
- private:
-  // Per-type factory helpers called by create().
-  Model::Ptr create_bpe(
-      detail::TokenMap token_map,
-      detail::TokenMap special_token_map,
-      std::unique_ptr<IRegex> regex,
-      const struct SequenceTokenIds& ids) const;
-  Model::Ptr create_wordpiece(
-      detail::TokenMap token_map,
-      detail::TokenMap special_token_map,
-      const struct SequenceTokenIds& ids) const;
-  Model::Ptr create_unigram(
-      detail::TokenMap special_token_map,
-      std::unique_ptr<IRegex> regex,
-      const struct SequenceTokenIds& ids) const;
-  Model::Ptr create_wordlevel(
-      detail::TokenMap token_map,
-      detail::TokenMap special_token_map,
-      std::unique_ptr<IRegex> regex,
-      const struct SequenceTokenIds& ids) const;
-};
-
-} // namespace tokenizers
\ No newline at end of file
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/normalizer.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/normalizer.h
deleted file mode 100644
index 9a71ae7a7d..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/normalizer.h
+++ /dev/null
@@ -1,242 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-// @lint-ignore-every LICENSELINT
-
-#pragma once
-
-// Standard
-#include <memory>
-#include <optional>
-#include <string>
-#include <vector>
-
-// Third Party
-#include <nlohmann/json.hpp>
-#include <re2/re2.h>
-
-// Local
-#include <pytorch/tokenizers/regex.h>
-
-namespace tokenizers {
-
-// -- Base ---------------------------------------------------------------------
-
-class Normalizer {
- public:
-  using Ptr = std::unique_ptr<Normalizer>;
-
-  virtual std::string normalize(const std::string& input) const = 0;
-  virtual ~Normalizer() = default;
-};
-
-// -- Factory ------------------------------------------------------------------
-
-#define NORMALIZER_CONFIG_MEMBER(type, name) \
-  std::optional<type> name;                  \
-  NormalizerConfig& set_##name(type arg) {   \
-    this->name = std::move(arg);             \
-    return *this;                            \
-  }
-
-class NormalizerConfig {
- public:
-  std::string type;
-
-  // Replace
-  NORMALIZER_CONFIG_MEMBER(std::string, pattern)
-  NORMALIZER_CONFIG_MEMBER(std::string, content)
-
-  // Sequence
-  using Configs = std::vector<NormalizerConfig>;
-  NORMALIZER_CONFIG_MEMBER(Configs, normalizers)
-
-  // Prepend
-  NORMALIZER_CONFIG_MEMBER(std::string, prepend)
-
-  // BertNormalizer
-  NORMALIZER_CONFIG_MEMBER(bool, clean_text)
-  NORMALIZER_CONFIG_MEMBER(bool, handle_chinese_chars)
-  NORMALIZER_CONFIG_MEMBER(bool, lowercase)
-  NORMALIZER_CONFIG_MEMBER(bool, strip_accents)
-
-  // Strip
-  NORMALIZER_CONFIG_MEMBER(bool, strip_left)
-  NORMALIZER_CONFIG_MEMBER(bool, strip_right)
-
-  // Precompiled
-  NORMALIZER_CONFIG_MEMBER(std::string, precompiled_charsmap)
-
-  explicit NormalizerConfig(std::string type = "");
-  Normalizer::Ptr create() const;
-  NormalizerConfig& parse_json(const nlohmann::json& json_config);
-};
-
-// -- Replace ------------------------------------------------------------------
-
-class ReplaceNormalizer : public Normalizer {
- public:
-  explicit ReplaceNormalizer(
-      const std::string& pattern,
-      const std::string& content)
-      : regex_(ReplaceNormalizer::create_regex_(pattern)), content_(content) {}
-
-  std::string normalize(const std::string& input) const override;
-
- protected:
-  static std::unique_ptr<IRegex> create_regex_(const std::string& pattern);
-  std::unique_ptr<IRegex> regex_;
-  const std::string content_;
-};
-
-// -- Prepend ------------------------------------------------------------------
-
-class PrependNormalizer : public Normalizer {
- public:
-  explicit PrependNormalizer(const std::string& prepend) : prepend_(prepend) {}
-  std::string normalize(const std::string& input) const override;
-
- protected:
-  const std::string prepend_;
-};
-
-// -- Sequence -----------------------------------------------------------------
-
-class SequenceNormalizer : public Normalizer {
- public:
-  explicit SequenceNormalizer(std::vector<Normalizer::Ptr> normalizers);
-  std::string normalize(const std::string& input) const override;
-
- private:
-  const std::vector<Normalizer::Ptr> normalizers_;
-};
-
-// -- NFC ----------------------------------------------------------------------
-
-class NFCNormalizer : public Normalizer {
- public:
-  NFCNormalizer() = default;
-  std::string normalize(const std::string& input) const override;
-};
-
-// -- NFD ----------------------------------------------------------------------
-
-class NFDNormalizer : public Normalizer {
- public:
-  NFDNormalizer() = default;
-  std::string normalize(const std::string& input) const override;
-};
-
-// -- NFKC ---------------------------------------------------------------------
-// Note: Full NFKC requires compatibility decomposition data not available in
-// our Unicode library. We approximate with NFC which handles the majority of
-// real-world cases. For models that truly need NFKC (rare), consider the
-// Precompiled normalizer which embeds the exact rules.
-
-class NFKCNormalizer : public Normalizer {
- public:
-  NFKCNormalizer() = default;
-  std::string normalize(const std::string& input) const override;
-};
-
-// -- NFKD ---------------------------------------------------------------------
-// Same caveat as NFKC — approximated with NFD.
-
-class NFKDNormalizer : public Normalizer {
- public:
-  NFKDNormalizer() = default;
-  std::string normalize(const std::string& input) const override;
-};
-
-// -- Lowercase ----------------------------------------------------------------
-
-class LowercaseNormalizer : public Normalizer {
- public:
-  LowercaseNormalizer() = default;
-  std::string normalize(const std::string& input) const override;
-};
-
-// -- BertNormalizer -----------------------------------------------------------
-
-class BertNormalizer : public Normalizer {
- public:
-  explicit BertNormalizer(
-      bool clean_text,
-      bool handle_chinese_chars,
-      bool lowercase,
-      std::optional<bool> strip_accents)
-      : clean_text_(clean_text),
-        handle_chinese_chars_(handle_chinese_chars),
-        lowercase_(lowercase),
-        strip_accents_(strip_accents) {}
-
-  std::string normalize(const std::string& input) const override;
-
- protected:
-  const bool clean_text_;
-  const bool handle_chinese_chars_;
-  const bool lowercase_;
-  const std::optional<bool> strip_accents_;
-};
-
-// -- Strip --------------------------------------------------------------------
-// Strips leading/trailing whitespace.
-
-class StripNormalizer : public Normalizer {
- public:
-  explicit StripNormalizer(bool strip_left = true, bool strip_right = true)
-      : strip_left_(strip_left), strip_right_(strip_right) {}
-  std::string normalize(const std::string& input) const override;
-
- private:
-  const bool strip_left_;
-  const bool strip_right_;
-};
-
-// -- StripAccents -------------------------------------------------------------
-// Removes combining diacritical marks (accents) via NFD decomposition.
-
-class StripAccentsNormalizer : public Normalizer {
- public:
-  StripAccentsNormalizer() = default;
-  std::string normalize(const std::string& input) const override;
-};
-
-// -- Nmt ----------------------------------------------------------------------
-// Normalizes whitespace and control characters (NMT-style).
-
-class NmtNormalizer : public Normalizer {
- public:
-  NmtNormalizer() = default;
-  std::string normalize(const std::string& input) const override;
-};
-
-// -- ByteLevel ----------------------------------------------------------------
-// Maps each byte to a visible UTF-8 character (GPT-2 style byte encoding).
-
-class ByteLevelNormalizer : public Normalizer {
- public:
-  ByteLevelNormalizer() = default;
-  std::string normalize(const std::string& input) const override;
-};
-
-// -- Precompiled --------------------------------------------------------------
-// Uses SentencePiece's precompiled charsmap (double-array trie) for
-// normalization. The binary blob is stored base64-encoded in tokenizer.json.
-
-class PrecompiledNormalizer : public Normalizer {
- public:
-  explicit PrecompiledNormalizer(const std::string& precompiled_charsmap);
-  ~PrecompiledNormalizer() override;
-  std::string normalize(const std::string& input) const override;
-
- private:
-  struct Impl;
-  std::unique_ptr<Impl> impl_;
-};
-
-} // namespace tokenizers
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/padding.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/padding.h
deleted file mode 100644
index 68694ae648..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/padding.h
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-// @lint-ignore-every LICENSELINT
-
-#pragma once
-
-// Standard
-#include <memory>
-#include <optional>
-#include <string>
-#include <vector>
-
-// Third Party
-#include <nlohmann/json.hpp>
-
-namespace tokenizers {
-
-// -- Padding ------------------------------------------------------------------
-
-enum class PaddingDirection {
-  Left,
-  Right,
-};
-
-enum class PaddingStrategy {
-  BatchLongest,
-  Fixed,
-};
-
-struct PaddingParams {
-  PaddingStrategy strategy = PaddingStrategy::BatchLongest;
-  PaddingDirection direction = PaddingDirection::Right;
-  std::optional<size_t> fixed_size;
-  std::optional<size_t> pad_to_multiple_of;
-  uint32_t pad_id = 0;
-  uint32_t pad_type_id = 0;
-  std::string pad_token = "[PAD]";
-};
-
-class Padding {
- public:
-  using Ptr = std::unique_ptr<Padding>;
-
-  /**
-   * @param params: The padding parameters
-   */
-  explicit Padding(const PaddingParams& params);
-
-  /**
-   * Pad the tokens according to the configuration
-   */
-  std::vector<uint64_t> pad(std::vector<uint64_t> tokens) const;
-
-  /**
-   * Generate attention mask for the padded tokens.
-   * 1 for real tokens, 0 for padded tokens.
-   */
-  std::vector<uint32_t> generate_mask(
-      const std::vector<uint64_t>& tokens,
-      size_t padded_size) const;
-
- private:
-  PaddingParams params_;
-};
-
-// -- Factory ------------------------------------------------------------------
-
-// Helper macro to standardize addition of config member fields
-#define PADDING_CONFIG_MEMBER(type, name)  \
-  PaddingConfig& set_##name(type arg) {    \
-    this->params.name = std::move(arg);    \
-    return *this;                          \
-  }
-
-class PaddingConfig {
- public:
-  explicit PaddingConfig(std::string strategy = "");
-
-  /**
-   * Construct the padding instance from the member data
-   */
-  Padding::Ptr create() const;
-
-  /**
-   * Populate from a json config file
-   */
-  PaddingConfig& parse_json(const nlohmann::json& json_config);
-
-  // Configuration members
-  PaddingParams params;
-
-  PADDING_CONFIG_MEMBER(PaddingStrategy, strategy)
-  PADDING_CONFIG_MEMBER(PaddingDirection, direction)
-  
-  PaddingConfig& set_fixed_size(std::optional<size_t> arg) {
-    this->params.fixed_size = std::move(arg);
-    this->params.strategy = PaddingStrategy::Fixed;
-    return *this;
-  }
-
-  PADDING_CONFIG_MEMBER(std::optional<size_t>, pad_to_multiple_of)
-  PADDING_CONFIG_MEMBER(uint32_t, pad_id)
-  PADDING_CONFIG_MEMBER(uint32_t, pad_type_id)
-  PADDING_CONFIG_MEMBER(std::string, pad_token)
-};
-
-} // namespace tokenizers
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/pcre2_regex.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/pcre2_regex.h
deleted file mode 100644
index 4752307939..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/pcre2_regex.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <memory>
-#include <string>
-
-// Define PCRE2 code unit width before including pcre2.h
-#define PCRE2_CODE_UNIT_WIDTH 8
-#include <pcre2.h>
-
-#include <pytorch/tokenizers/regex.h>
-
-namespace tokenizers {
-
-/**
- * @brief PCRE2-based implementation of IRegex.
- */
-class Pcre2Regex : public IRegex {
- public:
-  /**
-   * @brief Construct a PCRE2 regex.
-   */
-  explicit Pcre2Regex() {};
-
-  /**
-   * @brief Compile the given regex pattern.
-   * @param pattern The regex pattern to compile.
-   * @return An Error object indicating success or failure of the compilation.
-   */
-  virtual Error compile(const std::string& pattern) override;
-
-  /**
-   * @brief Destructor to clean up PCRE2 resources.
-   */
-  ~Pcre2Regex();
-
-  /**
-   * @brief Return all non-overlapping matches found in the input string.
-   */
-  virtual std::vector<Match> find_all(const std::string& text) const override;
-
- private:
-  pcre2_code* regex_;
-  pcre2_match_data* match_data_;
-};
-
-} // namespace tokenizers
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/post_processor.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/post_processor.h
deleted file mode 100644
index 9bc89423da..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/post_processor.h
+++ /dev/null
@@ -1,259 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-// @lint-ignore-every LICENSELINT
-
-#pragma once
-
-#include <map>
-#include <memory>
-#include <string>
-#include <variant>
-#include <vector>
-
-#include <nlohmann/json.hpp>
-
-namespace tokenizers {
-
-// -- Base ---------------------------------------------------------------------
-
-/**
- * Base class for all post-processors
- */
-class PostProcessor {
- public:
-  using Ptr = std::unique_ptr<PostProcessor>;
-
-  virtual ~PostProcessor() = default;
-
-  /**
-   * Returns the number of tokens added by this PostProcessor
-   */
-  virtual size_t added_tokens(bool is_pair) const = 0;
-
-  /**
-   * Process the token IDs (single sequence).
-   *
-   * NOTE: Unlike the Rust implementation which  uses a single method
-   * taking  Encoding and an Option<Encoding>, we use overloads here
-   * to explicitly handle single vs pair sequences while processing raw IDs.
-   */
-  virtual std::vector<uint64_t> process(
-      const std::vector<uint64_t>& tokens,
-      bool add_special_tokens = true) const = 0;
-
-  /**
-   * Process the token IDs (pair sequence).
-   */
-  virtual std::vector<uint64_t> process(
-      const std::vector<uint64_t>& tokens_a,
-      const std::vector<uint64_t>& tokens_b,
-      bool add_special_tokens = true) const = 0;
-};
-
-// -- Factory/Common Types -----------------------------------------------------
-
-// Helper macro to standardize addition of config member fields
-#define POST_PROCESSOR_CONFIG_MEMBER(type, name) \
-  std::optional<type> name;                      \
-  PostProcessorConfig& set_##name(type arg) {    \
-    this->name = std::move(arg);                 \
-    return *this;                                \
-  }
-
-enum class SequenceId { A, B };
-
-struct SpecialToken {
-  std::string id;
-  std::vector<uint64_t> ids;
-  std::vector<std::string> tokens;
-};
-
-struct Piece {
-  bool is_special_token;
-  std::string id; // For SpecialToken (e.g. "[CLS]"). For Sequence (e.g. "A").
-  uint64_t type_id;
-
-  static Piece Sequence(SequenceId id, uint64_t type_id) {
-    return {false, id == SequenceId::A ? "A" : "B", type_id};
-  }
-  static Piece SpecialToken(std::string id, uint64_t type_id) {
-    return {true, std::move(id), type_id};
-  }
-};
-
-using Template = std::vector<Piece>;
-// -- Config -------------------------------------------------------------------
-
-class PostProcessorConfig {
- public:
-  using SpecialTokenMap = std::map<std::string, tokenizers::SpecialToken>;
-  using StringIdPair = std::pair<std::string, uint64_t>;
-
-  std::string type;
-
-  // TemplateProcessing
-  POST_PROCESSOR_CONFIG_MEMBER(Template, single)
-  POST_PROCESSOR_CONFIG_MEMBER(Template, pair)
-  POST_PROCESSOR_CONFIG_MEMBER(SpecialTokenMap, special_tokens)
-
-  // Bert / Roberta (unused params in no-op, but kept for parsing logic)
-  POST_PROCESSOR_CONFIG_MEMBER(StringIdPair, sep)
-  POST_PROCESSOR_CONFIG_MEMBER(StringIdPair, cls)
-  POST_PROCESSOR_CONFIG_MEMBER(bool, trim_offsets)
-  POST_PROCESSOR_CONFIG_MEMBER(bool, add_prefix_space)
-
-  // Sequence
-  using Configs = std::vector<PostProcessorConfig>;
-  POST_PROCESSOR_CONFIG_MEMBER(Configs, processors)
-
-  explicit PostProcessorConfig(std::string type = "");
-
-  PostProcessor::Ptr create() const;
-
-  PostProcessorConfig& parse_json(const nlohmann::json& json_config);
-};
-
-// -- TemplateProcessing -------------------------------------------------------
-
-class TemplateProcessing : public PostProcessor {
- public:
-  TemplateProcessing(
-      Template single,
-      Template pair,
-      std::map<std::string, SpecialToken> special_tokens);
-
-  size_t added_tokens(bool is_pair) const override;
-
-  std::vector<uint64_t> process(
-      const std::vector<uint64_t>& tokens,
-      bool add_special_tokens = true) const override;
-
-  std::vector<uint64_t> process(
-      const std::vector<uint64_t>& tokens_a,
-      const std::vector<uint64_t>& tokens_b,
-      bool add_special_tokens = true) const override;
-
- private:
-  Template single_;
-  Template pair_;
-  std::map<std::string, SpecialToken> special_tokens_;
-  size_t added_single_;
-  size_t added_pair_;
-
-  std::vector<uint64_t> apply_template(
-      const Template& tmpl,
-      const std::vector<uint64_t>& tokens_a,
-      const std::vector<uint64_t>* tokens_b,
-      bool add_special_tokens) const;
-};
-
-class Sequence : public PostProcessor {
- public:
-  explicit Sequence(std::vector<PostProcessor::Ptr> processors);
-
-  size_t added_tokens(bool is_pair) const override;
-
-  std::vector<uint64_t> process(
-      const std::vector<uint64_t>& tokens,
-      bool add_special_tokens = true) const override;
-
-  std::vector<uint64_t> process(
-      const std::vector<uint64_t>& tokens_a,
-      const std::vector<uint64_t>& tokens_b,
-      bool add_special_tokens = true) const override;
-
- private:
-  std::vector<PostProcessor::Ptr> processors_;
-};
-
-// -- BertProcessing -----------------------------------------------------------
-// Used for BERT post-processing (adding special tokens)
-class BertProcessing : public PostProcessor {
- public:
-  BertProcessing(
-      std::pair<std::string, uint64_t> sep,
-      std::pair<std::string, uint64_t> cls);
-
-  size_t added_tokens(bool is_pair) const override;
-
-  std::vector<uint64_t> process(
-      const std::vector<uint64_t>& tokens,
-      bool add_special_tokens = true) const override;
-
-  std::vector<uint64_t> process(
-      const std::vector<uint64_t>& tokens_a,
-      const std::vector<uint64_t>& tokens_b,
-      bool add_special_tokens = true) const override;
-
- private:
-  std::pair<std::string, uint64_t> sep_;
-  std::pair<std::string, uint64_t> cls_;
-};
-
-// -- RobertaProcessing --------------------------------------------------------
-// Used for RoBERTa post-processing
-class RobertaProcessing : public PostProcessor {
- public:
-  RobertaProcessing(
-      std::pair<std::string, uint64_t> sep,
-      std::pair<std::string, uint64_t> cls,
-      bool trim_offsets,
-      bool add_prefix_space);
-
-  size_t added_tokens(bool is_pair) const override;
-
-  std::vector<uint64_t> process(
-      const std::vector<uint64_t>& tokens,
-      bool add_special_tokens = true) const override;
-
-  std::vector<uint64_t> process(
-      const std::vector<uint64_t>& tokens_a,
-      const std::vector<uint64_t>& tokens_b,
-      bool add_special_tokens = true) const override;
-
- private:
-  std::pair<std::string, uint64_t> sep_;
-  std::pair<std::string, uint64_t> cls_;
-  bool trim_offsets_;
-  bool add_prefix_space_;
-};
-
-// -- ByteLevel
-// ----------------------------------------------------------------
-// TODO: Implement ByteLevelProcessor
-// This is a broader issue, as most of the processing is done on offsets.
-// Our current implementation doesn't supoort it and would require us to
-// introduce a complex Encoding type. Something similiar to the originl hf
-// implementaiton:
-// https://github.com/huggingface/tokenizers/blob/main/tokenizers/src/tokenizer/encoding.rs
-// so we could store the offsets from pretokenization step.
-/*
-class ByteLevel : public PostProcessor {
- public:
-  ByteLevel(bool trim_offsets, bool add_prefix_space);
-
-  size_t added_tokens(bool is_pair) const override;
-
-  std::vector<uint64_t> process(
-      const std::vector<uint64_t>& tokens,
-      bool add_special_tokens = true) const override;
-
-  std::vector<uint64_t> process(
-      const std::vector<uint64_t>& tokens_a,
-      const std::vector<uint64_t>& tokens_b,
-      bool add_special_tokens = true) const override;
-
- private:
-  bool trim_offsets_;
-  bool add_prefix_space_;
-};
-*/
-
-// -- Sequence
-// -----------------------------------------------------------------
-} // namespace tokenizers
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/pre_tokenizer.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/pre_tokenizer.h
deleted file mode 100644
index 8fe6e8b96f..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/pre_tokenizer.h
+++ /dev/null
@@ -1,263 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-// @lint-ignore-every LICENSELINT
-
-#pragma once
-
-// Standard
-#include <memory>
-#include <optional>
-#include <string>
-#include <vector>
-
-// Third Party
-#include <nlohmann/json.hpp>
-#include <re2/re2.h>
-
-// Local
-#include <pytorch/tokenizers/regex.h>
-
-namespace tokenizers {
-
-// -- Base ---------------------------------------------------------------------
-
-class PreTokenizer {
- public:
-  using Ptr = std::unique_ptr<PreTokenizer>;
-
-  virtual std::vector<std::string> pre_tokenize(
-      const std::string& input) const = 0;
-
-  virtual ~PreTokenizer() = default;
-};
-
-// -- Factory ------------------------------------------------------------------
-
-#define PRETOKENIZER_CONFIG_MEMBER(type, name) \
-  std::optional<type> name;                    \
-  PreTokenizerConfig& set_##name(type arg) {   \
-    this->name = std::move(arg);               \
-    return *this;                              \
-  }
-
-class PreTokenizerConfig {
- public:
-  std::string type;
-
-  // Split / RegexPreTokenizer
-  PRETOKENIZER_CONFIG_MEMBER(std::string, pattern)
-  PRETOKENIZER_CONFIG_MEMBER(bool, is_delimiter)
-  PRETOKENIZER_CONFIG_MEMBER(std::string, behavior)
-  PRETOKENIZER_CONFIG_MEMBER(bool, invert)
-
-  // Digits
-  PRETOKENIZER_CONFIG_MEMBER(bool, individual_digits)
-
-  // ByteLevel
-  PRETOKENIZER_CONFIG_MEMBER(bool, add_prefix_space)
-  PRETOKENIZER_CONFIG_MEMBER(bool, use_regex)
-
-  // Metaspace
-  PRETOKENIZER_CONFIG_MEMBER(std::string, replacement)
-  PRETOKENIZER_CONFIG_MEMBER(std::string, prepend_scheme)
-  PRETOKENIZER_CONFIG_MEMBER(bool, split)
-
-  // CharDelimiterSplit
-  PRETOKENIZER_CONFIG_MEMBER(std::string, delimiter)
-
-  // Punctuation — reuses `behavior`
-
-  // FixedLength
-  PRETOKENIZER_CONFIG_MEMBER(size_t, length)
-
-  // Sequence
-  using Configs = std::vector<PreTokenizerConfig>;
-  PRETOKENIZER_CONFIG_MEMBER(Configs, pretokenizers)
-
-  explicit PreTokenizerConfig(std::string type = "");
-  PreTokenizer::Ptr create() const;
-  PreTokenizerConfig& parse_json(const nlohmann::json& json_config);
-};
-
-// -- Split (Regex) ------------------------------------------------------------
-
-class RegexPreTokenizer : public PreTokenizer {
- public:
-  explicit RegexPreTokenizer(
-      const std::string& pattern,
-      bool is_delimiter = false,
-      const std::string& behavior = "Removed")
-      : regex_(RegexPreTokenizer::create_regex_(pattern)),
-        is_delimiter_(is_delimiter),
-        behavior_(behavior) {}
-
-  std::vector<std::string> pre_tokenize(const std::string& input) const;
-
- protected:
-  static std::unique_ptr<IRegex> create_regex_(const std::string& pattern);
-
-  std::unique_ptr<IRegex> regex_;
-  const bool is_delimiter_;
-  const std::string behavior_;
-};
-
-// -- Digits -------------------------------------------------------------------
-
-class DigitsPreTokenizer : public RegexPreTokenizer {
- public:
-  explicit DigitsPreTokenizer(bool individual_digits = false)
-      : RegexPreTokenizer(
-            individual_digits ? R"([^\p{N}]+|\p{N})"
-                              : R"([^\p{N}]+|[\p{N}]+)") {}
-};
-
-// -- ByteLevel ----------------------------------------------------------------
-
-class ByteLevelPreTokenizer : public PreTokenizer {
- public:
-  ByteLevelPreTokenizer(
-      bool add_prefix_space = true,
-      const std::string& pattern = "",
-      bool use_regex = true);
-  explicit ByteLevelPreTokenizer(const std::string& pattern)
-      : ByteLevelPreTokenizer(true, pattern, true) {}
-
-  std::vector<std::string> pre_tokenize(
-      const std::string& input) const override;
-
- private:
-  const std::string pattern_;
-  const bool add_prefix_space_;
-  const bool use_regex_;
-};
-
-// -- Sequence -----------------------------------------------------------------
-
-class SequencePreTokenizer : public PreTokenizer {
- public:
-  explicit SequencePreTokenizer(std::vector<PreTokenizer::Ptr> pre_tokenizers);
-
-  std::vector<std::string> pre_tokenize(
-      const std::string& input) const override;
-
- private:
-  const std::vector<PreTokenizer::Ptr> pre_tokenizers_;
-};
-
-// -- Bert ---------------------------------------------------------------------
-
-class BertPreTokenizer : public PreTokenizer {
- public:
-  BertPreTokenizer() = default;
-
-  std::vector<std::string> pre_tokenize(
-      const std::string& input) const override;
-};
-
-// -- Metaspace ----------------------------------------------------------------
-// Replaces spaces with a replacement char (default ▁) and optionally splits.
-// Used by SentencePiece-based HF tokenizers (T5, ALBERT, XLNet, etc.)
-
-class MetaspacePreTokenizer : public PreTokenizer {
- public:
-  enum class PrependScheme { Always, First, Never };
-
-  explicit MetaspacePreTokenizer(
-      const std::string& replacement = "\xe2\x96\x81",
-      PrependScheme prepend_scheme = PrependScheme::Always,
-      bool split = true)
-      : replacement_(replacement),
-        prepend_scheme_(prepend_scheme),
-        split_(split) {}
-
-  std::vector<std::string> pre_tokenize(
-      const std::string& input) const override;
-
- private:
-  const std::string replacement_;
-  const PrependScheme prepend_scheme_;
-  const bool split_;
-};
-
-// -- Whitespace ---------------------------------------------------------------
-// Matches word chars and non-whitespace-non-word chars: \w+|[^\w\s]+
-
-class WhitespacePreTokenizer : public RegexPreTokenizer {
- public:
-  WhitespacePreTokenizer()
-      : RegexPreTokenizer(R"(\w+|[^\w\s]+)") {}
-};
-
-// -- WhitespaceSplit ----------------------------------------------------------
-// Splits on any whitespace character (removes whitespace).
-
-class WhitespaceSplitPreTokenizer : public PreTokenizer {
- public:
-  WhitespaceSplitPreTokenizer() = default;
-
-  std::vector<std::string> pre_tokenize(
-      const std::string& input) const override;
-};
-
-// -- Punctuation --------------------------------------------------------------
-// Splits on punctuation characters with configurable behavior (default
-// Isolated).
-
-class PunctuationPreTokenizer : public PreTokenizer {
- public:
-  explicit PunctuationPreTokenizer(const std::string& behavior = "Isolated")
-      : behavior_(behavior) {}
-
-  std::vector<std::string> pre_tokenize(
-      const std::string& input) const override;
-
- private:
-  const std::string behavior_;
-};
-
-// -- CharDelimiterSplit -------------------------------------------------------
-// Splits on a single delimiter character (Removed behavior).
-
-class CharDelimiterSplitPreTokenizer : public PreTokenizer {
- public:
-  explicit CharDelimiterSplitPreTokenizer(const std::string& delimiter)
-      : delimiter_(delimiter) {}
-
-  std::vector<std::string> pre_tokenize(
-      const std::string& input) const override;
-
- private:
-  const std::string delimiter_;
-};
-
-// -- UnicodeScripts -----------------------------------------------------------
-// Splits on Unicode script boundaries.
-
-class UnicodeScriptsPreTokenizer : public PreTokenizer {
- public:
-  UnicodeScriptsPreTokenizer() = default;
-
-  std::vector<std::string> pre_tokenize(
-      const std::string& input) const override;
-};
-
-// -- FixedLength --------------------------------------------------------------
-// Splits into chunks of a fixed number of characters.
-
-class FixedLengthPreTokenizer : public PreTokenizer {
- public:
-  explicit FixedLengthPreTokenizer(size_t length = 5) : length_(length) {}
-
-  std::vector<std::string> pre_tokenize(
-      const std::string& input) const override;
-
- private:
-  const size_t length_;
-};
-
-} // namespace tokenizers
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/re2_regex.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/re2_regex.h
deleted file mode 100644
index e3b7391ed7..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/re2_regex.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <memory>
-#include <string>
-
-#include <re2/re2.h>
-
-#include <pytorch/tokenizers/regex.h>
-
-namespace tokenizers {
-
-/**
- * @brief RE2-based implementation of IRegex.
- */
-class Re2Regex : public IRegex {
- public:
-  /**
-   * @brief Construct a RE2 regex.
-   */
-  explicit Re2Regex() {}
-
-  /**
-   * @brief compile the given regex pattern.
-   * @param pattern The regex pattern to compile.
-   * @return An Error object indicating success or failure of the compilation.
-   */
-  virtual Error compile(const std::string& pattern) override;
-
-  /**
-   * @brief Return all non-overlapping matches found in the input string.
-   */
-  virtual std::vector<Match> find_all(const std::string& text) const override;
-
- private:
-  std::unique_ptr<re2::RE2> regex_;
-};
-
-} // namespace tokenizers
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/regex.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/regex.h
deleted file mode 100644
index 33a7ade66b..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/regex.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include <pytorch/tokenizers/result.h>
-
-namespace tokenizers {
-
-struct Match {
-  size_t start; // starting index of the match
-  size_t end; // ending index of the match (exclusive)
-};
-
-/**
- * @brief Abstract interface for regex wrappers.
- */
-class IRegex {
- public:
-  virtual ~IRegex() = default;
-
-  /**
-   * @brief Compile the given regex pattern.
-   * @param pattern The regex pattern to compile.
-   * @return An Error object indicating success or failure of the compilation.
-   */
-  virtual Error compile(const std::string& pattern) = 0;
-
-  /**
-   * @brief Find all non-overlapping matches in the input string.
-   *
-   * @param text The input string to search.
-   * @return A vector of strings containing all matched substrings.
-   */
-  virtual std::vector<Match> find_all(const std::string& text) const = 0;
-
-  /**
-   * @brief Escape special regex characters in a string to treat it as literal.
-   *
-   * @param input The input string to escape.
-   * @return The escaped string that can be used as a literal pattern in regex.
-   */
-  static std::string escape(const std::string& input);
-};
-
-// Function pointer type for create_fallback_regex implementations
-using FallbackRegexFn = Result<std::unique_ptr<IRegex>> (*)(const std::string&);
-
-/**
- * @brief Creates a regex instance. If no strong symbol defined, only
- * uses RE2. This is a weak symbol to allow other regex libraries to be
- * used.
- *
- * @param pattern The regex pattern to compile.
- * @return A unique pointer to an IRegex-compatible object.
- */
-Result<std::unique_ptr<IRegex>> create_regex(const std::string& pattern);
-
-bool register_override_fallback_regex(FallbackRegexFn fn);
-
-FallbackRegexFn get_fallback_regex();
-
-} // namespace tokenizers
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/result.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/result.h
deleted file mode 100644
index 363e1a722e..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/result.h
+++ /dev/null
@@ -1,256 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @file
- * Result type to be used in conjunction with Tokenizers Error type.
- */
-
-#pragma once
-
-#include <pytorch/tokenizers/error.h>
-#include <cassert>
-#include <new>
-#include <utility>
-
-namespace tokenizers {
-
-/**
- * Result type wrapping either a value of type T or an error.
- *
- * Example use case:
- * @code
- *   Result<std::string> decode(uint64_t token);
- *
- *   void generate()
- * @endcode
- */
-template <typename T>
-class Result final {
- public:
-  /// `value_type` member for generic programming.
-  typedef T value_type;
-
-  /**
-   * Creates a Result object from an Error.
-   *
-   * To preserve the invariant that `(result.error() == Error::Ok) ==
-   * result.ok()`, an `error` parameter value of `Error:Ok` will be converted to
-   * a non-Ok value.
-   */
-  /* implicit */ Result(Error error)
-      : error_(error == Error::Ok ? Error::Internal : error),
-        hasValue_(false) {}
-
-  /// Value copy constructor.
-  /* implicit */ Result(const T& val) : value_(val), hasValue_(true) {}
-
-  /// Value move constructor.
-  /* implicit */ Result(T&& val) : value_(std::move(val)), hasValue_(true) {}
-
-  /// Result move constructor.
-  /* implicit */ Result(Result&& rhs) noexcept : hasValue_(rhs.hasValue_) {
-    if (hasValue_) {
-      // Use the value type's move constructor.
-      new (&value_) T(std::move(rhs.value_));
-    } else {
-      error_ = rhs.error_;
-    }
-  }
-
-  ~Result() {
-    if (hasValue_) {
-      // Manual value destruction.
-      // Result "owns" the memory, so `delete` would segfault.
-      value_.~T();
-    }
-  }
-
-  /**
-   * Returns true if this Result has a value.
-   *
-   * If true, it is guaranteed that `error()` will return `Error::Ok`.
-   * If false, it is guaranteed that `error()` will not return `Error::Ok`.
-   */
-  bool ok() const {
-    return hasValue_;
-  }
-
-  /**
-   * Returns the error code of this Result.
-   *
-   * If this returns `Error::Ok`, it is guaranteed that `ok()` will return true.
-   * If this does not return `Error:Ok`, it is guaranteed that `ok()` will
-   * return false.
-   */
-  Error error() const {
-    if (hasValue_) {
-      return Error::Ok;
-    } else {
-      return error_;
-    }
-  }
-
-  /**
-   * Returns a reference to the Result's value; longhand for operator*().
-   *
-   * Only legal to call if `ok()` returns true.
-   */
-  T& get() {
-    CheckOk();
-    return value_;
-  }
-
-  /**
-   * Returns a reference to the Result's value; longhand for operator*().
-   *
-   * Only legal to call if `ok()` returns true.
-   */
-  const T& get() const {
-    CheckOk();
-    return value_;
-  }
-
-  /*
-   * Returns a reference to the Result's value; shorthand for get().
-   *
-   * Only legal to call if `ok()` returns true.
-   */
-  const T& operator*() const&;
-  T& operator*() &;
-
-  /*
-   * Returns a pointer to the Result's value.
-   *
-   * Only legal to call if `ok()` returns true.
-   */
-  const T* operator->() const;
-  T* operator->();
-
- private:
-  /**
-   * Delete default constructor since all Results should contain a value or
-   * error.
-   */
-  Result() = delete;
-  /// Delete copy constructor since T may not be copyable.
-  Result(const Result&) = delete;
-  /// Delete copy assignment since T may not be copyable.
-  Result& operator=(const Result&) = delete;
-  /// Delete move assignment since it's not a supported pattern to reuse Result.
-  Result& operator=(Result&& rhs) = delete;
-
-  // Panics if ok() would return false;
-  void CheckOk() const {
-    assert(hasValue_ && "Result must be ok to access value.");
-  }
-
-  union {
-    T value_; // Used if hasValue_ is true.
-    Error error_; // Used if hasValue_ is false.
-  };
-
-  /// True if the Result contains a value.
-  const bool hasValue_;
-};
-
-template <typename T>
-const T& Result<T>::operator*() const& {
-  CheckOk();
-  return value_;
-}
-
-template <typename T>
-T& Result<T>::operator*() & {
-  CheckOk();
-  return value_;
-}
-
-template <typename T>
-const T* Result<T>::operator->() const {
-  CheckOk();
-  return &value_;
-}
-
-template <typename T>
-T* Result<T>::operator->() {
-  CheckOk();
-  return &value_;
-}
-
-} // namespace tokenizers
-
-/**
- * Unwraps a Result<T> value, throwing a runtime_error if the result contains an
- * error.
- *
- * @param[in] result__ The Result<T> to unwrap
- */
-#define TK_UNWRAP_THROW(result__)                                     \
-  ({                                                                  \
-    auto unwrap_result__ = (result__);                                \
-    if (!unwrap_result__.ok()) {                                      \
-      throw std::runtime_error(                                       \
-          "Error: " +                                                 \
-          std::to_string(static_cast<int>(unwrap_result__.error()))); \
-    }                                                                 \
-    std::move(unwrap_result__.get());                                 \
-  })
-
-/**
- * Unwrap a Result to obtain its value. If the Result contains an error,
- * propogate the error via trivial function return.
- *
- * Note: A function using TK_UNWRAP should itself return a Result or Error.
- *
- * @param[in] result__ Expression yielding the result to unwrap.
- * @param[in] ... Optional format string for the log error message and its
- * arguments.
- */
-#define TK_UNWRAP(result__, ...) TK_INTERNAL_UNWRAP(result__, ##__VA_ARGS__)
-
-// Internal only: Use TK_UNWRAP() instead.
-#define TK_INTERNAL_UNWRAP(...)                                         \
-  TK_INTERNAL_UNWRAP_SELECT(__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1) \
-  (__VA_ARGS__)
-
-// Internal only: Use TK_UNWRAP() instead.
-#define TK_INTERNAL_UNWRAP_SELECT(                   \
-    _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) \
-  TK_INTERNAL_UNWRAP_##N
-
-// Internal only: Use TK_UNWRAP() instead.
-#define TK_INTERNAL_UNWRAP_1(result__) \
-  ({                                   \
-    auto et_result__ = (result__);     \
-    if (!et_result__.ok()) {           \
-      return et_result__.error();      \
-    }                                  \
-    std::move(*et_result__);           \
-  })
-
-// Internal only: Use TK_UNWRAP() instead.
-#define TK_INTERNAL_UNWRAP_2(result__, message__, ...) \
-  ({                                                   \
-    auto et_result__ = (result__);                     \
-    if (!et_result__.ok()) {                           \
-      TK_LOG(Error, message__, ##__VA_ARGS__);         \
-      return et_result__.error();                      \
-    }                                                  \
-    std::move(*et_result__);                           \
-  })
-
-// Internal only: Use TK_UNWRAP() instead.
-#define TK_INTERNAL_UNWRAP_3 TK_INTERNAL_UNWRAP_2
-#define TK_INTERNAL_UNWRAP_4 TK_INTERNAL_UNWRAP_2
-#define TK_INTERNAL_UNWRAP_5 TK_INTERNAL_UNWRAP_2
-#define TK_INTERNAL_UNWRAP_6 TK_INTERNAL_UNWRAP_2
-#define TK_INTERNAL_UNWRAP_7 TK_INTERNAL_UNWRAP_2
-#define TK_INTERNAL_UNWRAP_8 TK_INTERNAL_UNWRAP_2
-#define TK_INTERNAL_UNWRAP_9 TK_INTERNAL_UNWRAP_2
-#define TK_INTERNAL_UNWRAP_10 TK_INTERNAL_UNWRAP_2
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/sentencepiece.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/sentencepiece.h
deleted file mode 100644
index f75370489c..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/sentencepiece.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-// @lint-ignore-every LICENSELINT
-
-#pragma once
-
-#include <pytorch/tokenizers/tokenizer.h>
-#include <memory>
-#include <vector>
-
-// Forward-declare to avoid leaking sentencepiece headers to consumers.
-namespace sentencepiece {
-class SentencePieceProcessor;
-} // namespace sentencepiece
-
-namespace tokenizers {
-
-/**
- * Tokenizer backed by Google's SentencePiece library.
- *
- * Loads `.model` (protobuf) files produced by the SentencePiece trainer.
- * Used by Llama 2/3, Gemma, T5, ALBERT, XLNet, Mistral, and many others.
- */
-class SPTokenizer : public Tokenizer {
- public:
-  explicit SPTokenizer();
-  ~SPTokenizer() override;
-
-  Error load(const std::string& tokenizer_path) override;
-
-  Result<std::string> id_to_piece(uint64_t token) const override;
-  Result<uint64_t> piece_to_id(const std::string& text) const override;
-
-  Result<std::vector<uint64_t>>
-  encode(const std::string& input, int8_t bos, int8_t eos) const override;
-
-  /// Streaming single-token decode (for incremental inference).
-  Result<std::string> decode(
-      uint64_t prev_token,
-      uint64_t token,
-      bool skip_special_tokens = false) const override;
-
-  /// Batch decode: converts a full token sequence back to text.
-  Result<std::string> decode(
-      const std::vector<uint64_t>& tokens,
-      bool skip_special_tokens = false) const;
-
- private:
-  std::unique_ptr<sentencepiece::SentencePieceProcessor> processor_;
-};
-
-} // namespace tokenizers
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/std_regex.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/std_regex.h
deleted file mode 100644
index 76910c329d..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/std_regex.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <memory>
-#include <regex>
-#include <string>
-#include "regex.h"
-
-namespace tokenizers {
-
-/**
- * @brief std::regex-based implementation of IRegex.
- */
-class StdRegex : public IRegex {
- public:
-  /**
-   * @brief Construct a std::regex wrapper.
-   */
-  explicit StdRegex() {}
-
-  /**
-   * @brief Compile the given regex pattern.
-   * @param pattern The regex pattern to compile.
-   * @return An Error object indicating success or failure of the compilation.
-   */
-  virtual Error compile(const std::string& pattern) override;
-
-  /**
-   * @brief Find all non-overlapping matches in the input string.
-   */
-  virtual std::vector<Match> find_all(const std::string& text) const override;
-
- private:
-  std::regex regex_;
-};
-
-} // namespace tokenizers
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/string_integer_map.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/string_integer_map.h
deleted file mode 100644
index e27289d9f7..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/string_integer_map.h
+++ /dev/null
@@ -1,630 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-// @lint-ignore-every LICENSELINT
-
-#pragma once
-
-#include <algorithm>
-#include <cassert>
-#include <cstdint>
-#include <cstring>
-#include <iterator>
-#include <limits>
-#include <memory>
-#include <optional>
-#include <string>
-#include <string_view>
-#include <unordered_map>
-#include <vector>
-
-namespace tokenizers {
-namespace detail {
-
-/**
- * StringIntegerMap is an immutable bidirectional map between strings and 64 bit
- * unsigned integers. The element data is stored in a contiguous array and is
- * shared between both the string buckets and the integer buckets, offering a
- * compact representation.
- *
- * Variable sized integers are used internally, which are sized based on the
- * data being stored. Custom hash functions are supported, with a stateful hash
- * functor being optionally provided at construction time.
- */
-template <
-    typename TStringHash = std::hash<std::string_view>,
-    typename TIntegerHash = std::hash<std::uint64_t>,
-    typename TAllocator = std::allocator<std::uint8_t>>
-class StringIntegerMap {
- public:
-  /// @name Constructors
-  /// @{
-
-  /// Default constructor is deleted, as this container is intended to be
-  /// constructed with a map of strings to integers.
-  StringIntegerMap() = delete;
-
-  /**
-   * Construct a StringIntegerMap from a map of strings to integers.  Each
-   * string and integer in the map must be unique.
-   * @param map map of strings to integers
-   */
-  template <typename TMap>
-  explicit StringIntegerMap(const TMap& map);
-
-  /**
-   * Construct a StringIntegerMap from a map of strings to integers, explicitly
-   * intializing the integer and string hash objects.  Each string and integer
-   * in the map must be unique.
-   * @param map map of strings to integers
-   */
-  template <typename TMap>
-  StringIntegerMap(
-      const TMap& map,
-      TStringHash string_hasher,
-      TIntegerHash integer_hasher);
-
-  /// @}
-  /// @name Accessors
-  /// @{
-
-  /**
-   * Attempts to retrieve the integer mapped for the given string.
-   * @param str string to lookup
-   * @return a std::optional containing the integer if the string was found,
-   * std::nullopt otherwise
-   */
-  std::optional<std::uint64_t> tryGetInteger(std::string_view str) const;
-
-  /**
-   * Attempts to retrieve the string mapped for the given integer.
-   * @param integer integer to lookup
-   * @return a std::optional containing the string if the integer was found,
-   * std::nullopt otherwise
-   */
-  std::optional<std::string_view> tryGetString(std::uint64_t integer) const;
-
-  /**
-   * Retrieves the number of elements in the map.
-   * @return the number of elements in the map
-   */
-  std::size_t size() const;
-
-  /**
-   * Retrieves the element in the map at the given index.
-   * @return A pair containing the string and integer at the given index.
-   */
-  std::pair<std::string_view, std::uint64_t> getElement(
-      std::size_t index) const;
-
-  /// @}
-
- private:
-  template <typename TLogical>
-  class VariableSizedInteger {
-   public:
-    VariableSizedInteger() = default;
-
-    explicit VariableSizedInteger(TLogical max_value) {
-      while (max_value != 0) {
-        ++byte_count_;
-        max_value >>= 8;
-      }
-
-      mask_ = (TLogical(1) << (byte_count_ * 8)) - TLogical(1);
-    }
-
-    std::size_t getByteCount() const {
-      return byte_count_;
-    }
-
-    TLogical getMask() const {
-      return mask_;
-    }
-
-    std::uint8_t* write(std::uint8_t* target, TLogical value) const {
-      std::memcpy(target, &value, byte_count_);
-      return target + byte_count_;
-    }
-
-    TLogical read(const std::uint8_t* source) const {
-      TLogical value;
-      std::memcpy(&value, source, sizeof(TLogical));
-      return value & mask_;
-    }
-
-   private:
-    std::size_t byte_count_ = 0;
-    TLogical mask_ = 0;
-  };
-
-  bool tryGetInteger(std::string_view str, std::uint64_t& result) const;
-
-  bool tryGetString(std::uint64_t integer, std::string_view& result) const;
-
-  std::size_t getBucketIndex(std::string_view value) const;
-
-  std::size_t getBucketIndex(std::uint64_t value) const;
-
-  static std::uint8_t getSmallHash(std::size_t hash);
-
-  /// Get the string data and string small hash stored in the element buffer at
-  /// the The hasher used for strings.
-  const TStringHash string_hasher_ = {};
-
-  /// The hasher used for integers.
-  const TIntegerHash integer_hasher_ = {};
-
-  /// String bucket references.
-  std::vector<std::uint8_t, TAllocator> integer_bucket_data_;
-
-  /// Integer bucket elements.
-  /// Laid out as:
-  /// struct {
-  ///   std::uint64_t integer; - Physically using integer_ bytes.
-  ///   std::size_t string_size; - Physically using string_size_ bytes
-  ///   std::size_t string_offset; - Physically using string_offset_ bytes
-  /// }
-  std::vector<std::uint8_t, TAllocator> integer_element_data_;
-
-  /// String bucket references.
-  std::vector<std::uint8_t, TAllocator> string_bucket_data_;
-
-  /// String bucket elements.
-  /// Laid out as:
-  /// struct {
-  ///   std::uint64_t integer; - Physically using integer_ bytes.
-  ///   std::size_t string_size; - Physically using string_size_ bytes
-  ///   std::uint8_t small_hash; - Using std::uint8_t bytes.
-  ///   char string[string_size]; - String data, not zero terminated.
-  /// }
-  std::vector<std::uint8_t, TAllocator> string_element_data_;
-
-  /// Number of hash buckets to use.
-  std::size_t bucket_count_ = 0;
-
-  /// Number of elements stored in the map.
-  std::size_t size_ = 0;
-
-  /// Variable sized element offset info.
-  VariableSizedInteger<std::size_t> element_offset_;
-
-  /// Variable size string offset info.
-  VariableSizedInteger<std::size_t> string_offset_;
-
-  /// Variable sized string size info.
-  VariableSizedInteger<std::size_t> string_size_;
-
-  /// Variable sized integer info.
-  VariableSizedInteger<std::uint64_t> integer_;
-};
-
-template <typename TStringHash, typename TIntegerHash, typename TAllocator>
-template <typename TMap>
-StringIntegerMap<TStringHash, TIntegerHash, TAllocator>::StringIntegerMap(
-    const TMap& map)
-    : StringIntegerMap(map, TStringHash(), TIntegerHash()) {}
-
-template <typename TStringHash, typename TIntegerHash, typename TAllocator>
-template <typename TMap>
-StringIntegerMap<TStringHash, TIntegerHash, TAllocator>::StringIntegerMap(
-    const TMap& map,
-    TStringHash string_hasher,
-    TIntegerHash integer_hasher)
-    : string_hasher_(string_hasher), integer_hasher_(integer_hasher) {
-  assert(map.size() <= std::numeric_limits<std::uint32_t>::max());
-  bucket_count_ = size_ = map.size();
-
-  struct BuilderElement {
-    std::uint64_t integer = 0;
-    std::string_view string;
-    std::size_t hash = 0;
-    std::size_t element_offset = 0;
-  };
-
-  std::vector<BuilderElement> builder_string_elements;
-  std::vector<BuilderElement> builder_integer_elements;
-
-  //
-  // Calculate various item sizes and gather the builder elements.
-  //
-
-  std::size_t largest_string_size = 0;
-  std::uint64_t largest_integer = 0;
-  std::size_t total_string_size = 0;
-
-  for (const auto& [str, integer] : map) {
-    total_string_size += str.size();
-    largest_string_size = std::max(largest_string_size, str.size());
-    largest_integer = std::max(largest_integer, integer);
-    builder_string_elements.push_back({integer, str, string_hasher_(str)});
-    builder_integer_elements.push_back(
-        {integer, str, integer_hasher_(integer)});
-  }
-
-  integer_ = VariableSizedInteger<std::uint64_t>(largest_integer);
-  string_size_ = VariableSizedInteger<std::size_t>(largest_string_size);
-
-  const auto string_element_data_size =
-      ((integer_.getByteCount() + string_size_.getByteCount() + 1) *
-       map.size()) +
-      total_string_size;
-
-  // string_offset_ stores byte offsets into string_element_data_, which
-  // includes per-element headers (integer + string_size + small_hash bytes)
-  // on top of the raw string data. Must be sized against the full buffer,
-  // not just total_string_size, to avoid truncating offsets > 255.
-  string_offset_ = VariableSizedInteger<std::size_t>(string_element_data_size);
-  const auto integer_element_size = integer_.getByteCount() +
-      string_offset_.getByteCount() + string_size_.getByteCount();
-  const auto integer_element_data_size = integer_element_size * map.size();
-
-  element_offset_ = VariableSizedInteger<std::size_t>(
-      std::max(string_element_data_size, integer_element_data_size));
-
-  string_bucket_data_.resize(
-      ((bucket_count_ + 1) * element_offset_.getByteCount()) +
-      sizeof(std::uint64_t));
-  integer_bucket_data_.resize(
-      ((bucket_count_ + 1) * element_offset_.getByteCount()) +
-      sizeof(std::uint64_t));
-
-  //
-  // Set up terminal bucket indices.
-  //
-
-  element_offset_.write(
-      string_bucket_data_.data() +
-          (bucket_count_ * element_offset_.getByteCount()),
-      string_element_data_size);
-  element_offset_.write(
-      integer_bucket_data_.data() +
-          (bucket_count_ * element_offset_.getByteCount()),
-      integer_element_data_size);
-  //
-  // Sort the builder elements.
-  //
-
-  std::sort(
-      std::begin(builder_string_elements),
-      std::end(builder_string_elements),
-      [this](const BuilderElement& first, const BuilderElement& second) {
-        const auto first_bucket = first.hash % bucket_count_;
-        const auto second_bucket = second.hash % bucket_count_;
-        if (first_bucket == second_bucket) {
-          const auto first_small_hash = getSmallHash(first.hash);
-          const auto second_small_hash = getSmallHash(second.hash);
-          return first_small_hash < second_small_hash;
-        }
-
-        return first_bucket < second_bucket;
-      });
-
-  std::sort(
-      std::begin(builder_integer_elements),
-      std::end(builder_integer_elements),
-      [this](const BuilderElement& first, const BuilderElement& second) {
-        const auto first_bucket = first.hash % bucket_count_;
-        const auto second_bucket = second.hash % bucket_count_;
-        if (first_bucket == second_bucket) {
-          return first.integer < second.integer;
-        }
-
-        return first_bucket < second_bucket;
-      });
-
-  //
-  // Lay out the string elements and record their positions.
-  //
-
-  std::unordered_map<std::string_view, std::size_t>
-      string_element_byte_index_map;
-  string_element_data_.resize(string_element_data_size + sizeof(std::uint64_t));
-  auto* string_element = string_element_data_.data();
-  for (auto& builder_element : builder_string_elements) {
-    builder_element.element_offset =
-        string_element - string_element_data_.data();
-
-    auto insert_result = string_element_byte_index_map.insert(
-        {builder_element.string, builder_element.element_offset});
-    assert(insert_result.second);
-    (void)insert_result;
-
-    string_element = integer_.write(string_element, builder_element.integer);
-    string_element =
-        string_size_.write(string_element, builder_element.string.size());
-    *string_element = getSmallHash(builder_element.hash);
-    string_element++;
-    std::memcpy(
-        string_element,
-        builder_element.string.data(),
-        builder_element.string.size());
-    string_element += builder_element.string.size();
-    assert(
-        string_element >= string_element_data_.data() &&
-        string_element <=
-            string_element_data_.data() + string_element_data_size);
-  }
-
-  //
-  // Lay out the integer elements.
-  //
-
-  integer_element_data_.resize(
-      integer_element_data_size + sizeof(std::uint64_t));
-  auto* integer_element = integer_element_data_.data();
-  for (auto& builder_element : builder_integer_elements) {
-    builder_element.element_offset =
-        integer_element - integer_element_data_.data();
-    auto string_element_byte_index_iter =
-        string_element_byte_index_map.find(builder_element.string);
-    assert(
-        string_element_byte_index_iter !=
-        std::end(string_element_byte_index_map));
-    integer_element = integer_.write(integer_element, builder_element.integer);
-    integer_element =
-        string_size_.write(integer_element, builder_element.string.size());
-    integer_element = string_offset_.write(
-        integer_element, string_element_byte_index_iter->second);
-    assert(
-        integer_element >= integer_element_data_.data() &&
-        integer_element <=
-            integer_element_data_.data() + integer_element_data_size);
-  }
-
-  //
-  // Both the string elements and integer elements are laid out in order of
-  // their respective hashes. Generate the hash indexes for the string elements
-  // and integer elements.
-  //
-
-  auto builder_string_elements_iter = std::begin(builder_string_elements);
-  auto builder_integer_elements_iter = std::begin(builder_integer_elements);
-
-  for (std::size_t bucket_idx = 0; bucket_idx < bucket_count_; ++bucket_idx) {
-    auto* string_bucket = string_bucket_data_.data() +
-        (bucket_idx * element_offset_.getByteCount());
-    if (builder_string_elements_iter != std::end(builder_string_elements)) {
-      element_offset_.write(
-          string_bucket, builder_string_elements_iter->element_offset);
-    } else {
-      element_offset_.write(string_bucket, string_element_data_size);
-    }
-
-    auto* integer_bucket = integer_bucket_data_.data() +
-        (bucket_idx * element_offset_.getByteCount());
-    if (builder_integer_elements_iter != std::end(builder_integer_elements)) {
-      element_offset_.write(
-          integer_bucket, builder_integer_elements_iter->element_offset);
-    } else {
-      element_offset_.write(integer_bucket, integer_element_data_size);
-    }
-
-    //
-    // Advance the string element iterator past all string elements that map
-    // into this bucket.
-    //
-
-    while (builder_string_elements_iter != std::end(builder_string_elements) &&
-           getBucketIndex(builder_string_elements_iter->string) == bucket_idx) {
-      ++builder_string_elements_iter;
-    }
-
-    //
-    // Advance the integer element index past all integer elements that map into
-    // this bucket.
-    //
-
-    while (
-        builder_integer_elements_iter != std::end(builder_integer_elements) &&
-        getBucketIndex(builder_integer_elements_iter->integer) == bucket_idx) {
-      ++builder_integer_elements_iter;
-    }
-  }
-}
-
-template <typename TStringHash, typename TIntegerHash, typename TAllocator>
-std::optional<std::uint64_t>
-StringIntegerMap<TStringHash, TIntegerHash, TAllocator>::tryGetInteger(
-    std::string_view str) const {
-  std::uint64_t result;
-  return tryGetInteger(str, result) ? std::optional<std::uint64_t>(result)
-                                    : std::nullopt;
-}
-
-template <typename TStringHash, typename TIntegerHash, typename TAllocator>
-bool StringIntegerMap<TStringHash, TIntegerHash, TAllocator>::tryGetInteger(
-    std::string_view str,
-    std::uint64_t& result) const {
-  if (size_ == 0) {
-    return false;
-  }
-
-  const auto hash = string_hasher_(str);
-  const auto bucket_index = hash % bucket_count_;
-  const auto small_hash = getSmallHash(hash);
-
-  const auto* bucket_data = string_bucket_data_.data() +
-      (bucket_index * element_offset_.getByteCount());
-  const auto lower_element_offset = element_offset_.read(bucket_data);
-  const auto upper_element_offset =
-      element_offset_.read(bucket_data + element_offset_.getByteCount());
-
-  const auto integer_size = integer_.getByteCount();
-  const auto string_size_size = string_size_.getByteCount();
-
-  std::size_t element_size = 0;
-  auto* element_data_end = string_element_data_.data() + upper_element_offset;
-  for (auto* element_data = string_element_data_.data() + lower_element_offset;
-       element_data < element_data_end;
-       element_data += element_size) {
-    //
-    // Read the string length.
-    //
-
-    const auto element_string_length =
-        string_size_.read(element_data + integer_size);
-    element_size = integer_size + string_size_size + 1 + element_string_length;
-
-    //
-    // Read the string small hash.
-    //
-
-    const auto element_small_hash =
-        element_data[integer_size + string_size_size];
-    if (element_small_hash < small_hash) {
-      continue;
-    } else if (element_small_hash > small_hash) {
-      break;
-    }
-
-    //
-    // Get a view on the string for a full comparison.
-    //
-
-    std::string_view element_string(
-        reinterpret_cast<const char*>(
-            element_data + integer_size + string_size_size + 1),
-        element_string_length);
-    if (str == element_string) {
-      result = integer_.read(element_data);
-      return true;
-    }
-  }
-
-  return false;
-}
-
-template <typename TStringHash, typename TIntegerHash, typename TAllocator>
-std::optional<std::string_view>
-StringIntegerMap<TStringHash, TIntegerHash, TAllocator>::tryGetString(
-    std::uint64_t integer) const {
-  std::string_view result;
-  return tryGetString(integer, result) ? std::optional<std::string_view>(result)
-                                       : std::nullopt;
-}
-
-template <typename TStringHash, typename TIntegerHash, typename TAllocator>
-bool StringIntegerMap<TStringHash, TIntegerHash, TAllocator>::tryGetString(
-    std::uint64_t integer,
-    std::string_view& result) const {
-  if (size_ == 0) {
-    return false;
-  }
-
-  const auto bucket_index = getBucketIndex(integer);
-
-  const auto* bucket_data = integer_bucket_data_.data() +
-      (bucket_index * element_offset_.getByteCount());
-  const auto lower_element_offset = element_offset_.read(bucket_data);
-  const auto upper_element_offset =
-      element_offset_.read(bucket_data + element_offset_.getByteCount());
-
-  const auto integer_element_size = integer_.getByteCount() +
-      string_offset_.getByteCount() + string_size_.getByteCount();
-  auto* element_data_end = integer_element_data_.data() + upper_element_offset;
-  for (auto* element_data = integer_element_data_.data() + lower_element_offset;
-       element_data < element_data_end;
-       element_data += integer_element_size) {
-    const auto element_integer = integer_.read(element_data);
-    if (element_integer == integer) {
-      const auto element_string_size =
-          string_size_.read(element_data + integer_.getByteCount());
-      const auto element_string_offset = string_offset_.read(
-          element_data + integer_.getByteCount() + string_size_.getByteCount());
-      const auto* string_element =
-          string_element_data_.data() + element_string_offset;
-      const auto* string_data = reinterpret_cast<const char*>(
-          string_element + integer_.getByteCount() +
-          string_size_.getByteCount() + 1);
-      result = std::string_view(string_data, element_string_size);
-      return true;
-    } else if (element_integer > integer) {
-      break;
-    }
-  }
-
-  return false;
-}
-
-template <typename TStringHash, typename TIntegerHash, typename TAllocator>
-std::size_t StringIntegerMap<TStringHash, TIntegerHash, TAllocator>::size()
-    const {
-  return size_;
-}
-
-template <typename TStringHash, typename TIntegerHash, typename TAllocator>
-std::pair<std::string_view, std::uint64_t>
-StringIntegerMap<TStringHash, TIntegerHash, TAllocator>::getElement(
-    std::size_t index) const {
-  assert(index < size_);
-
-  const auto integer_size = integer_.getByteCount();
-  const auto string_offset_size = string_offset_.getByteCount();
-  const auto string_size_size = string_size_.getByteCount();
-  const auto element_size =
-      integer_size + string_offset_size + string_size_size;
-  const auto* element_data = &integer_element_data_[index * element_size];
-
-  const auto integer = integer_.read(element_data);
-  element_data += integer_size;
-  const auto string_size = string_size_.read(element_data);
-  element_data += string_size_size;
-  const auto string_offset = string_offset_.read(element_data);
-  const auto* string_data =
-      &string_element_data_
-          [string_offset + integer_size + string_size_size + 1];
-
-  return std::make_pair(
-      std::string_view(reinterpret_cast<const char*>(string_data), string_size),
-      integer);
-}
-
-template <typename TStringHash, typename TIntegerHash, typename TAllocator>
-std::size_t
-StringIntegerMap<TStringHash, TIntegerHash, TAllocator>::getBucketIndex(
-    std::string_view value) const {
-  return string_hasher_(value) % bucket_count_;
-}
-
-template <typename TStringHash, typename TIntegerHash, typename TAllocator>
-std::size_t
-StringIntegerMap<TStringHash, TIntegerHash, TAllocator>::getBucketIndex(
-    std::uint64_t value) const {
-  return integer_hasher_(value) % bucket_count_;
-}
-
-template <typename TStringHash, typename TIntegerHash, typename TAllocator>
-std::uint8_t
-StringIntegerMap<TStringHash, TIntegerHash, TAllocator>::getSmallHash(
-    std::size_t hash) {
-  const auto shift = (sizeof(std::size_t) * 8) - 8;
-  return static_cast<std::uint8_t>(hash >> shift);
-}
-
-template <
-    typename TStringHash = std::hash<std::string_view>,
-    typename TIntegerHash = std::hash<std::uint64_t>,
-    typename TAllocator = std::allocator<std::uint8_t>>
-struct StringIntegerMapTypeBuilder {
-  using Map = StringIntegerMap<TStringHash, TIntegerHash, TAllocator>;
-
-  template <typename TOtherStringHash>
-  using WithStringHash =
-      StringIntegerMapTypeBuilder<TOtherStringHash, TIntegerHash, TAllocator>;
-
-  template <typename TOtherIntegerHash>
-  using WithIntegerHash =
-      StringIntegerMapTypeBuilder<TStringHash, TOtherIntegerHash, TAllocator>;
-
-  template <typename TOtherAllocator>
-  using WithAllocator =
-      StringIntegerMapTypeBuilder<TStringHash, TIntegerHash, TOtherAllocator>;
-};
-
-} // namespace detail
-} // namespace tokenizers
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/tekken.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/tekken.h
deleted file mode 100644
index da8c5ebccc..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/tekken.h
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @lint-ignore-every LICENSELINT
- */
-
-#pragma once
-
-#include <memory>
-#include <optional>
-#include <string>
-#include <vector>
-
-// Third Party
-#include <nlohmann/json.hpp>
-
-// Local
-#include <pytorch/tokenizers/bpe_tokenizer_base.h>
-#include <pytorch/tokenizers/error.h>
-#include <pytorch/tokenizers/regex.h>
-#include <pytorch/tokenizers/result.h>
-
-namespace tokenizers {
-
-class Tekken : public detail::BPETokenizerBase {
- public:
-  struct TekkenConfig {
-    std::string pattern;
-    size_t num_vocab_tokens;
-    size_t default_vocab_size;
-    size_t default_num_special_tokens;
-    std::string version;
-  };
-
-  struct TokenInfo {
-    uint64_t rank;
-    std::string token_bytes; // Base64 encoded
-    std::optional<std::string> token_str;
-  };
-
-  struct SpecialTokenInfo {
-    uint64_t rank;
-    std::string token_str;
-    bool is_control;
-  };
-
-  explicit Tekken();
-  ~Tekken() override = default;
-
-  // Load from tekken.json file
-  Error load(const std::string& tokenizer_path) override;
-
-  // Support loading with explicit special tokens
-  Error load_with_special_tokens(
-      const std::string& tokenizer_path,
-      const std::vector<SpecialTokenInfo>& special_tokens);
-
-  // Get the version string
-  const std::string& get_version() const {
-    return _version;
-  }
-
- protected:
-  // Virtual methods from BPETokenizerBase
-  Error _encode(
-      const std::string& input,
-      std::vector<uint64_t>& ret,
-      uint64_t& last_piece_token_len) const override;
-
-  void _decode(const std::string& input, std::string& ret) const override;
-
- private:
-  // Parse the JSON configuration
-  Result<TekkenConfig> _parse_config(const nlohmann::json& j) const;
-
-  // Build token map from JSON vocab
-  Result<detail::TokenMap> _load_vocab_from_json(
-      const nlohmann::json& vocab_json,
-      size_t max_vocab) const;
-
-  // Initialize special tokens (fills up to num_special_tokens slots)
-  std::vector<SpecialTokenInfo> _initialize_special_tokens(
-      const std::vector<SpecialTokenInfo>& defined_tokens,
-      size_t num_special_tokens) const;
-
-  // Default Tekken pattern
-  static std::string _get_default_tekken_pattern();
-
-  // Default special tokens for Mistral models
-  static std::vector<SpecialTokenInfo> _get_default_special_tokens();
-
-  size_t _num_special_tokens = 1000; // Tekken reserves 1000 slots
-  std::string _version;
-  std::string _pattern;
-  std::unique_ptr<IRegex> _regex;
-};
-
-} // namespace tokenizers
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/tiktoken.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/tiktoken.h
deleted file mode 100644
index 0e7c543848..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/tiktoken.h
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-// @lint-ignore-every LICENSELINT
-
-// Tiktoken header
-// Used by OpenAI, adapted from https://github.com/sewenew/tokenizer
-#pragma once
-
-// Standard
-#include <cstdint>
-
-// Third Party
-#include <re2/re2.h>
-
-// Local
-#include <pytorch/tokenizers/bpe_tokenizer_base.h>
-#include <pytorch/tokenizers/compiler.h>
-#include <pytorch/tokenizers/regex.h>
-#include <pytorch/tokenizers/result.h>
-#include <pytorch/tokenizers/tokenizer.h>
-
-namespace tokenizers {
-
-static constexpr int32_t kSpecialTokensSize = 256;
-static constexpr size_t kBOSTokenIndex = 0;
-static constexpr size_t kEOSTokenIndex = 1;
-
-class Tiktoken : public detail::BPETokenizerBase {
- public:
-  explicit Tiktoken(
-      std::string pattern,
-      std::unique_ptr<std::vector<std::string>> special_tokens,
-      size_t bos_token_index,
-      size_t eos_token_index)
-      : _pattern(std::move(pattern)),
-        _special_tokens(std::move(special_tokens)),
-        _bos_token_index(bos_token_index),
-        _eos_token_index(eos_token_index) {
-    if (_bos_token_index >= _special_tokens->size() ||
-        _eos_token_index >= _special_tokens->size()) {
-      abort();
-    }
-  }
-
-  explicit Tiktoken(
-      std::string pattern,
-      const std::vector<std::string>& special_tokens,
-      size_t bos_token_index,
-      size_t eos_token_index)
-      : Tiktoken(
-            pattern,
-            std::make_unique<std::vector<std::string>>(special_tokens),
-            bos_token_index,
-            eos_token_index) {}
-
-  explicit Tiktoken(
-      const std::vector<std::string>& special_tokens,
-      size_t bos_token_index,
-      size_t eos_token_index)
-      : Tiktoken(
-            _get_default_patern(),
-            std::make_unique<std::vector<std::string>>(special_tokens),
-            bos_token_index,
-            eos_token_index) {}
-
-  explicit Tiktoken(
-      std::unique_ptr<std::vector<std::string>> special_tokens,
-      size_t bos_token_index,
-      size_t eos_token_index)
-      : Tiktoken(
-            _get_default_patern(),
-            std::move(special_tokens),
-            bos_token_index,
-            eos_token_index) {}
-
-  explicit Tiktoken()
-      : _pattern(_get_default_patern()),
-        _special_tokens(_get_default_special_tokens()),
-        _bos_token_index(kBOSTokenIndex),
-        _eos_token_index(kEOSTokenIndex) {};
-
-  Error load(const std::string& tokenizer_path) override;
-
- private:
-  static inline std::unique_ptr<std::vector<std::string>>
-  _get_default_special_tokens() {
-    auto special_tokens =
-        std::make_unique<std::vector<std::string>>(std::vector<std::string>{
-            "<|begin_of_text|>",
-            "<|end_of_text|>",
-            "<|reserved_special_token_0|>",
-            "<|reserved_special_token_1|>",
-            "<|finetune_right_pad_id|>",
-            "<|step_id|>",
-            "<|start_header_id|>",
-            "<|end_header_id|>",
-            "<|eom_id|>",
-            "<|eot_id|>",
-            "<|python_tag|>"});
-    // pad the rest of the special tokens with reserved tokens
-    ssize_t reserved_special_token_num = 2;
-    while (special_tokens->size() < kSpecialTokensSize) {
-      special_tokens->emplace_back(
-          "<|reserved_special_token_" +
-          std::to_string(reserved_special_token_num++) + "|>");
-    }
-    return special_tokens;
-  }
-
-  static inline std::string _get_default_patern() {
-    // Removed negative lookahead \s+(?!\S) since it's not supported by RE2.
-    return R"((?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\r\n\p{L}\p{N}]?\p{L}+|\p{N}{1,3}| ?[^\s\p{L}\p{N}]+[\r\n]*|\s*[\r\n]+|\s+)";
-  }
-
-  Error _encode(
-      const std::string& input,
-      std::vector<uint64_t>& ret,
-      uint64_t& last_piece_token_len) const override;
-
-  void _decode(const std::string& input, std::string& ret) const override;
-
-  detail::TokenMap _build_special_token_map(ssize_t num_base_tokens) const;
-
-  std::string _pattern;
-  std::unique_ptr<std::vector<std::string>> _special_tokens;
-  size_t _bos_token_index;
-  size_t _eos_token_index;
-
-  std::unique_ptr<IRegex> _regex;
-};
-
-} // namespace tokenizers
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/token_decoder.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/token_decoder.h
deleted file mode 100644
index 0f6e3bc2c5..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/token_decoder.h
+++ /dev/null
@@ -1,273 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-// @lint-ignore-every LICENSELINT
-
-#pragma once
-
-// Standard
-#include <memory>
-#include <optional>
-#include <string>
-#include <vector>
-
-// Third Party
-#include <nlohmann/json.hpp>
-#include <re2/re2.h>
-
-namespace tokenizers {
-
-// -- Base ---------------------------------------------------------------------
-
-/**
- * Base class for all token decoders
- */
-class TokenDecoder {
- public:
-  /* -- Types -- */
-
-  using Ptr = std::unique_ptr<TokenDecoder>;
-
-  /* -- Virtual Methods -- */
-
-  /** Decode a sequence of tokens into another sequence of tokens
-   *
-   * This is the primary virtual method that all decoders must implement. It may
-   * change the size/layout of tokens between the input and output vectors.
-   *
-   * @param token: The pre-decoding token string
-   *
-   * @returns decoded: The decoded token string
-   */
-  virtual std::vector<std::string> decode(
-      const std::vector<std::string>& tokens) const = 0;
-
-  // virtual destructor
-  virtual ~TokenDecoder() = default;
-
-}; // end class TokenDecoder
-
-// -- Factory ------------------------------------------------------------------
-
-// Helper macro to standardize addition of config member fields
-#define TOKEN_DECODER_CONFIG_MEMBER(type, name) \
-  std::optional<type> name;                     \
-  TokenDecoderConfig& set_##name(type arg) {    \
-    this->name = std::move(arg);                \
-    return *this;                               \
-  }
-
-/**
- * Factory and config class for creating a new TokenDecoder
- */
-class TokenDecoderConfig {
- public:
-  /**
-   * The Type name string matching from decoders
-   * https://github.com/huggingface/tokenizers/blob/main/tokenizers/src/decoders/mod.rs#L55
-   */
-  std::string type;
-
-  // Parameters for Replace decoder
-  TOKEN_DECODER_CONFIG_MEMBER(std::string, replace_pattern)
-  TOKEN_DECODER_CONFIG_MEMBER(std::string, replace_content)
-
-  // Parameters for Sequence decoder
-  TOKEN_DECODER_CONFIG_MEMBER(std::vector<nlohmann::json>, sequence_decoders)
-
-  // Parameters for Strip decoder
-  TOKEN_DECODER_CONFIG_MEMBER(std::string, strip_content)
-  TOKEN_DECODER_CONFIG_MEMBER(size_t, strip_start)
-  TOKEN_DECODER_CONFIG_MEMBER(size_t, strip_stop)
-
-  // Parameters for WordPiece decoder
-  TOKEN_DECODER_CONFIG_MEMBER(std::string, wordpiece_prefix)
-  TOKEN_DECODER_CONFIG_MEMBER(bool, wordpiece_cleanup)
-
-  // Parameters for Metaspace decoder
-  TOKEN_DECODER_CONFIG_MEMBER(std::string, metaspace_replacement)
-  TOKEN_DECODER_CONFIG_MEMBER(std::string, metaspace_prepend_scheme)
-
-  // Parameters for BPE decoder
-  TOKEN_DECODER_CONFIG_MEMBER(std::string, bpe_suffix)
-
-  // Parameters for CTC decoder
-  TOKEN_DECODER_CONFIG_MEMBER(std::string, ctc_pad_token)
-  TOKEN_DECODER_CONFIG_MEMBER(std::string, ctc_word_delimiter_token)
-  TOKEN_DECODER_CONFIG_MEMBER(bool, ctc_cleanup)
-
-  /*----------------*/
-  /* Public methods */
-  /*----------------*/
-
-  /**
-   * Construct with the type
-   */
-  explicit TokenDecoderConfig(std::string type = "");
-
-  /**
-   * Construct the pre tokenizer instance from the member data
-   */
-  TokenDecoder::Ptr create() const;
-
-  /**
-   * Populate from a json config file
-   */
-  TokenDecoderConfig& parse_json(const nlohmann::json& json_config);
-}; // end class TokenDecoderConfig
-
-// -- ByteLevel ----------------------------------------------------------------
-// Used by tokenizers
-// CITE:
-// https://github.com/huggingface/tokenizers/blob/main/tokenizers/src/pre_tokenizers/byte_level.rs
-
-class ByteLevelTokenDecoder : public TokenDecoder {
- public:
-  std::vector<std::string> decode(
-      const std::vector<std::string>& tokens) const override;
-
-}; // end class ByteLevelTokenDecoder
-
-// -- Replace ------------------------------------------------------------------
-// Replaces a pattern with a replacement string
-
-class ReplaceTokenDecoder : public TokenDecoder {
- public:
-  explicit ReplaceTokenDecoder(
-      const std::string& pattern,
-      const std::string& content);
-  std::vector<std::string> decode(
-      const std::vector<std::string>& tokens) const override;
-
- private:
-  std::string pattern_;
-  std::string content_;
-}; // end class ReplaceTokenDecoder
-
-// -- ByteFallback -------------------------------------------------------------
-// Handles byte fallback decoding
-
-class ByteFallbackTokenDecoder : public TokenDecoder {
- public:
-  std::vector<std::string> decode(
-      const std::vector<std::string>& tokens) const override;
-
-}; // end class ByteFallbackTokenDecoder
-
-// -- Fuse --------------------------------------------------------------------
-// Fuses tokens together
-
-class FuseTokenDecoder : public TokenDecoder {
- public:
-  std::vector<std::string> decode(
-      const std::vector<std::string>& tokens) const override;
-
-}; // end class FuseTokenDecoder
-
-// -- Strip ------------------------------------------------------------------
-// Strips characters from tokens
-
-class StripTokenDecoder : public TokenDecoder {
- public:
-  explicit StripTokenDecoder(
-      const std::string& content_str,
-      size_t start,
-      size_t stop);
-  std::vector<std::string> decode(
-      const std::vector<std::string>& tokens) const override;
-
- private:
-  uint32_t content_;
-  size_t start_;
-  size_t stop_;
-}; // end class StripTokenDecoder
-
-// -- WordPiece ----------------------------------------------------------------
-// Used for WordPiece decoding
-
-class WordPieceTokenDecoder : public TokenDecoder {
- public:
-  explicit WordPieceTokenDecoder(
-      std::string prefix = "##",
-      bool cleanup = true);
-  std::vector<std::string> decode(
-      const std::vector<std::string>& tokens) const override;
-
- private:
-  std::string prefix_;
-  bool cleanup_;
-}; // end class WordPieceTokenDecoder
-
-// -- Sequence -----------------------------------------------------------------
-// Applies a sequence of decoders in order
-
-class SequenceTokenDecoder : public TokenDecoder {
- public:
-  explicit SequenceTokenDecoder(std::vector<TokenDecoder::Ptr> decoders);
-  std::vector<std::string> decode(
-      const std::vector<std::string>& tokens) const override;
-
- private:
-  std::vector<TokenDecoder::Ptr> decoders_;
-}; // end class SequenceTokenDecoder
-
-// -- Metaspace ----------------------------------------------------------------
-// Replaces the replacement character (▁) with space and handles prepend.
-
-class MetaspaceTokenDecoder : public TokenDecoder {
- public:
-  explicit MetaspaceTokenDecoder(
-      const std::string& replacement = "\xe2\x96\x81",
-      const std::string& prepend_scheme = "always")
-      : replacement_(replacement), prepend_scheme_(prepend_scheme) {}
-
-  std::vector<std::string> decode(
-      const std::vector<std::string>& tokens) const override;
-
- private:
-  std::string replacement_;
-  std::string prepend_scheme_;
-};
-
-// -- BPE ----------------------------------------------------------------------
-// Handles end-of-word suffix (e.g. </w>).
-
-class BPETokenDecoder : public TokenDecoder {
- public:
-  explicit BPETokenDecoder(const std::string& suffix = "</w>")
-      : suffix_(suffix) {}
-
-  std::vector<std::string> decode(
-      const std::vector<std::string>& tokens) const override;
-
- private:
-  std::string suffix_;
-};
-
-// -- CTC ----------------------------------------------------------------------
-// Connectionist Temporal Classification decoder for speech models.
-
-class CTCTokenDecoder : public TokenDecoder {
- public:
-  explicit CTCTokenDecoder(
-      const std::string& pad_token = "<pad>",
-      const std::string& word_delimiter_token = "|",
-      bool cleanup = true)
-      : pad_token_(pad_token),
-        word_delimiter_token_(word_delimiter_token),
-        cleanup_(cleanup) {}
-
-  std::vector<std::string> decode(
-      const std::vector<std::string>& tokens) const override;
-
- private:
-  std::string pad_token_;
-  std::string word_delimiter_token_;
-  bool cleanup_;
-};
-
-} // namespace tokenizers
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/tokenizer.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/tokenizer.h
deleted file mode 100644
index 75195a4bbf..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/tokenizer.h
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @file
- * Tokenizer interface declaration.
- */
-
-#pragma once
-
-#include <pytorch/tokenizers/error.h>
-#include <pytorch/tokenizers/result.h>
-#include <string>
-#include <vector>
-
-namespace tokenizers {
-
-struct TokenIndex {
-  const char* str;
-  int32_t id;
-};
-
-class Tokenizer {
- public:
-  explicit Tokenizer() {}
-  virtual ~Tokenizer() {}
-
-  virtual Error load(const std::string& tokenizer_path) = 0;
-
-  /**
-   * Returns the raw vocabulary piece for a given token id.
-   *
-   * This is the exact token representation stored in the tokenizer vocabulary
-   * (e.g. SentencePiece "▁hello", WordPiece "##ing", or byte-level BPE token
-   * bytes). It is intended for tokenizer introspection and downstream
-   * post-processing, and should not be confused with `decode()`, which may
-   * apply normalization.
-   *
-   * @param token The token id to look up
-   * @return Result containing the raw vocab piece string, or an error if the
-   * token id is invalid or the tokenizer is not initialized
-   */
-  virtual Result<std::string> id_to_piece(uint64_t token) const = 0;
-
-  /**
-   * Returns token id for given raw vocabulary piece.
-   *
-   * This is the exact token representation stored in the tokenizer vocabulary
-   * (e.g. SentencePiece "▁hello", WordPiece "##ing", or byte-level BPE token
-   * bytes). It is intended for tokenizer introspection and downstream
-   * post-processing, and should not be confused with `encode()`, which
-   * applies the full tokenization pipeline including BPE for unknown pieces.
-   *
-   * @param text The raw vocabulary piece string to look up
-   * @return Result containing the token id, or an error if the piece is not
-   * found in the vocabulary or the tokenizer is not initialized
-   */
-  virtual Result<uint64_t> piece_to_id(const std::string& text) const = 0;
-
-  /**
-   * Encode the input string into a vector of token IDs.
-   *
-   * @param input The input string to tokenize
-   * @param bos The number of beginning-of-sequence (BOS) tokens to prepend to
-   * the result
-   * @param eos The number of end-of-sequence (EOS) tokens to append to the
-   * result
-   * @return Result containing a vector of token IDs, or an error if encoding
-   * fails
-   */
-  virtual Result<std::vector<uint64_t>>
-  encode(const std::string& input, int8_t bos = 0, int8_t eos = 0) const = 0;
-
-  virtual Result<std::string> decode(
-      uint64_t prev_token,
-      uint64_t token,
-      bool skip_special_tokens = false) const = 0;
-
-  // getters
-  int32_t vocab_size() const {
-    return vocab_size_;
-  }
-
-  uint64_t bos_tok() const {
-    return bos_tok_;
-  }
-
-  uint64_t eos_tok() const {
-    return eos_tok_;
-  }
-
-  virtual bool is_loaded() const {
-    return initialized_;
-  }
-
- protected:
-  bool initialized_ = false;
-  int32_t vocab_size_ = 0;
-  uint64_t bos_tok_ = 0, eos_tok_ = 0, unk_tok_ = 0;
-};
-
-} // namespace tokenizers
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/truncation.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/truncation.h
deleted file mode 100644
index 4f16ee6f54..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/truncation.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-// @lint-ignore-every LICENSELINT
-
-#pragma once
-
-// Standard
-#include <memory>
-#include <optional>
-#include <string>
-#include <vector>
-
-// Third Party
-#include <nlohmann/json.hpp>
-
-namespace tokenizers {
-
-// -- Truncation ---------------------------------------------------------------
-
-enum class TruncationStrategy {
-  LongestFirst,
-  OnlyFirst,
-  OnlySecond,
-};
-
-enum class TruncationDirection {
-  Left,
-  Right,
-};
-
-struct TruncationParams {
-  TruncationDirection direction = TruncationDirection::Right;
-  size_t max_length = 512;
-  TruncationStrategy strategy = TruncationStrategy::LongestFirst;
-  size_t stride = 0;
-};
-
-class Truncation {
- public:
-  using Ptr = std::unique_ptr<Truncation>;
-
-  /**
-   * @param params: The truncation parameters
-   */
-  explicit Truncation(const TruncationParams& params);
-
-  /**
-   * Truncate the tokens according to the configuration.
-   * 
-   * @param tokens The tokens to truncate.
-   * @param num_tokens_to_add The number of special tokens that will be added later.
-   *                          These are subtracted from max_length during truncation calculation.
-   */
-  std::vector<uint64_t> truncate(
-      std::vector<uint64_t> tokens,
-      size_t num_tokens_to_add = 0) const;
-
-  /**
-   * Truncate a pair of sequences according to the configuration.
-   */
-  std::pair<std::vector<uint64_t>, std::vector<uint64_t>> truncate_pair(
-      std::vector<uint64_t> a,
-      std::vector<uint64_t> b,
-      size_t num_tokens_to_add = 0) const;
-
- private:
-  TruncationParams params_;
-};
-
-// -- Factory ------------------------------------------------------------------
-
-class TruncationConfig {
- public:
-  /**
-   * Construct the truncation instance from the member data
-   */
-  Truncation::Ptr create() const;
-
-  /**
-   * Populate from a json config file
-   */
-  TruncationConfig& parse_json(const nlohmann::json& json_config);
-
-  // Configuration members
-  TruncationParams params;
-};
-
-} // namespace tokenizers
\ No newline at end of file
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/unicode-nfc-data.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/unicode-nfc-data.h
deleted file mode 100644
index 7e169db695..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/unicode-nfc-data.h
+++ /dev/null
@@ -1,4135 +0,0 @@
-/*
- * Auto-generated Unicode NFC/NFD normalization data
- * Generated from UnicodeData.txt
- *
- * This file contains proper canonical decomposition and composition mappings
- * that support multi-codepoint sequences, required for correct NFD/NFC normalization.
- */
-
-#pragma once
-
-#include <cstdint>
-#include <unordered_map>
-#include <vector>
-#include <utility>
-
-namespace tokenizers {
-
-// Canonical decomposition table: composed -> [base, combining_marks...]
-// Only includes canonical decompositions (not compatibility)
-static const std::unordered_map<uint32_t, std::vector<uint32_t>> nfd_decomposition_table = {
-    {0x00C0, {0x0041, 0x0300}},  // 'À'
-    {0x00C1, {0x0041, 0x0301}},  // 'Á'
-    {0x00C2, {0x0041, 0x0302}},  // 'Â'
-    {0x00C3, {0x0041, 0x0303}},  // 'Ã'
-    {0x00C4, {0x0041, 0x0308}},  // 'Ä'
-    {0x00C5, {0x0041, 0x030A}},  // 'Å'
-    {0x00C7, {0x0043, 0x0327}},  // 'Ç'
-    {0x00C8, {0x0045, 0x0300}},  // 'È'
-    {0x00C9, {0x0045, 0x0301}},  // 'É'
-    {0x00CA, {0x0045, 0x0302}},  // 'Ê'
-    {0x00CB, {0x0045, 0x0308}},  // 'Ë'
-    {0x00CC, {0x0049, 0x0300}},  // 'Ì'
-    {0x00CD, {0x0049, 0x0301}},  // 'Í'
-    {0x00CE, {0x0049, 0x0302}},  // 'Î'
-    {0x00CF, {0x0049, 0x0308}},  // 'Ï'
-    {0x00D1, {0x004E, 0x0303}},  // 'Ñ'
-    {0x00D2, {0x004F, 0x0300}},  // 'Ò'
-    {0x00D3, {0x004F, 0x0301}},  // 'Ó'
-    {0x00D4, {0x004F, 0x0302}},  // 'Ô'
-    {0x00D5, {0x004F, 0x0303}},  // 'Õ'
-    {0x00D6, {0x004F, 0x0308}},  // 'Ö'
-    {0x00D9, {0x0055, 0x0300}},  // 'Ù'
-    {0x00DA, {0x0055, 0x0301}},  // 'Ú'
-    {0x00DB, {0x0055, 0x0302}},  // 'Û'
-    {0x00DC, {0x0055, 0x0308}},  // 'Ü'
-    {0x00DD, {0x0059, 0x0301}},  // 'Ý'
-    {0x00E0, {0x0061, 0x0300}},  // 'à'
-    {0x00E1, {0x0061, 0x0301}},  // 'á'
-    {0x00E2, {0x0061, 0x0302}},  // 'â'
-    {0x00E3, {0x0061, 0x0303}},  // 'ã'
-    {0x00E4, {0x0061, 0x0308}},  // 'ä'
-    {0x00E5, {0x0061, 0x030A}},  // 'å'
-    {0x00E7, {0x0063, 0x0327}},  // 'ç'
-    {0x00E8, {0x0065, 0x0300}},  // 'è'
-    {0x00E9, {0x0065, 0x0301}},  // 'é'
-    {0x00EA, {0x0065, 0x0302}},  // 'ê'
-    {0x00EB, {0x0065, 0x0308}},  // 'ë'
-    {0x00EC, {0x0069, 0x0300}},  // 'ì'
-    {0x00ED, {0x0069, 0x0301}},  // 'í'
-    {0x00EE, {0x0069, 0x0302}},  // 'î'
-    {0x00EF, {0x0069, 0x0308}},  // 'ï'
-    {0x00F1, {0x006E, 0x0303}},  // 'ñ'
-    {0x00F2, {0x006F, 0x0300}},  // 'ò'
-    {0x00F3, {0x006F, 0x0301}},  // 'ó'
-    {0x00F4, {0x006F, 0x0302}},  // 'ô'
-    {0x00F5, {0x006F, 0x0303}},  // 'õ'
-    {0x00F6, {0x006F, 0x0308}},  // 'ö'
-    {0x00F9, {0x0075, 0x0300}},  // 'ù'
-    {0x00FA, {0x0075, 0x0301}},  // 'ú'
-    {0x00FB, {0x0075, 0x0302}},  // 'û'
-    {0x00FC, {0x0075, 0x0308}},  // 'ü'
-    {0x00FD, {0x0079, 0x0301}},  // 'ý'
-    {0x00FF, {0x0079, 0x0308}},  // 'ÿ'
-    {0x0100, {0x0041, 0x0304}},  // 'Ā'
-    {0x0101, {0x0061, 0x0304}},  // 'ā'
-    {0x0102, {0x0041, 0x0306}},  // 'Ă'
-    {0x0103, {0x0061, 0x0306}},  // 'ă'
-    {0x0104, {0x0041, 0x0328}},  // 'Ą'
-    {0x0105, {0x0061, 0x0328}},  // 'ą'
-    {0x0106, {0x0043, 0x0301}},  // 'Ć'
-    {0x0107, {0x0063, 0x0301}},  // 'ć'
-    {0x0108, {0x0043, 0x0302}},  // 'Ĉ'
-    {0x0109, {0x0063, 0x0302}},  // 'ĉ'
-    {0x010A, {0x0043, 0x0307}},  // 'Ċ'
-    {0x010B, {0x0063, 0x0307}},  // 'ċ'
-    {0x010C, {0x0043, 0x030C}},  // 'Č'
-    {0x010D, {0x0063, 0x030C}},  // 'č'
-    {0x010E, {0x0044, 0x030C}},  // 'Ď'
-    {0x010F, {0x0064, 0x030C}},  // 'ď'
-    {0x0112, {0x0045, 0x0304}},  // 'Ē'
-    {0x0113, {0x0065, 0x0304}},  // 'ē'
-    {0x0114, {0x0045, 0x0306}},  // 'Ĕ'
-    {0x0115, {0x0065, 0x0306}},  // 'ĕ'
-    {0x0116, {0x0045, 0x0307}},  // 'Ė'
-    {0x0117, {0x0065, 0x0307}},  // 'ė'
-    {0x0118, {0x0045, 0x0328}},  // 'Ę'
-    {0x0119, {0x0065, 0x0328}},  // 'ę'
-    {0x011A, {0x0045, 0x030C}},  // 'Ě'
-    {0x011B, {0x0065, 0x030C}},  // 'ě'
-    {0x011C, {0x0047, 0x0302}},  // 'Ĝ'
-    {0x011D, {0x0067, 0x0302}},  // 'ĝ'
-    {0x011E, {0x0047, 0x0306}},  // 'Ğ'
-    {0x011F, {0x0067, 0x0306}},  // 'ğ'
-    {0x0120, {0x0047, 0x0307}},  // 'Ġ'
-    {0x0121, {0x0067, 0x0307}},  // 'ġ'
-    {0x0122, {0x0047, 0x0327}},  // 'Ģ'
-    {0x0123, {0x0067, 0x0327}},  // 'ģ'
-    {0x0124, {0x0048, 0x0302}},  // 'Ĥ'
-    {0x0125, {0x0068, 0x0302}},  // 'ĥ'
-    {0x0128, {0x0049, 0x0303}},  // 'Ĩ'
-    {0x0129, {0x0069, 0x0303}},  // 'ĩ'
-    {0x012A, {0x0049, 0x0304}},  // 'Ī'
-    {0x012B, {0x0069, 0x0304}},  // 'ī'
-    {0x012C, {0x0049, 0x0306}},  // 'Ĭ'
-    {0x012D, {0x0069, 0x0306}},  // 'ĭ'
-    {0x012E, {0x0049, 0x0328}},  // 'Į'
-    {0x012F, {0x0069, 0x0328}},  // 'į'
-    {0x0130, {0x0049, 0x0307}},  // 'İ'
-    {0x0134, {0x004A, 0x0302}},  // 'Ĵ'
-    {0x0135, {0x006A, 0x0302}},  // 'ĵ'
-    {0x0136, {0x004B, 0x0327}},  // 'Ķ'
-    {0x0137, {0x006B, 0x0327}},  // 'ķ'
-    {0x0139, {0x004C, 0x0301}},  // 'Ĺ'
-    {0x013A, {0x006C, 0x0301}},  // 'ĺ'
-    {0x013B, {0x004C, 0x0327}},  // 'Ļ'
-    {0x013C, {0x006C, 0x0327}},  // 'ļ'
-    {0x013D, {0x004C, 0x030C}},  // 'Ľ'
-    {0x013E, {0x006C, 0x030C}},  // 'ľ'
-    {0x0143, {0x004E, 0x0301}},  // 'Ń'
-    {0x0144, {0x006E, 0x0301}},  // 'ń'
-    {0x0145, {0x004E, 0x0327}},  // 'Ņ'
-    {0x0146, {0x006E, 0x0327}},  // 'ņ'
-    {0x0147, {0x004E, 0x030C}},  // 'Ň'
-    {0x0148, {0x006E, 0x030C}},  // 'ň'
-    {0x014C, {0x004F, 0x0304}},  // 'Ō'
-    {0x014D, {0x006F, 0x0304}},  // 'ō'
-    {0x014E, {0x004F, 0x0306}},  // 'Ŏ'
-    {0x014F, {0x006F, 0x0306}},  // 'ŏ'
-    {0x0150, {0x004F, 0x030B}},  // 'Ő'
-    {0x0151, {0x006F, 0x030B}},  // 'ő'
-    {0x0154, {0x0052, 0x0301}},  // 'Ŕ'
-    {0x0155, {0x0072, 0x0301}},  // 'ŕ'
-    {0x0156, {0x0052, 0x0327}},  // 'Ŗ'
-    {0x0157, {0x0072, 0x0327}},  // 'ŗ'
-    {0x0158, {0x0052, 0x030C}},  // 'Ř'
-    {0x0159, {0x0072, 0x030C}},  // 'ř'
-    {0x015A, {0x0053, 0x0301}},  // 'Ś'
-    {0x015B, {0x0073, 0x0301}},  // 'ś'
-    {0x015C, {0x0053, 0x0302}},  // 'Ŝ'
-    {0x015D, {0x0073, 0x0302}},  // 'ŝ'
-    {0x015E, {0x0053, 0x0327}},  // 'Ş'
-    {0x015F, {0x0073, 0x0327}},  // 'ş'
-    {0x0160, {0x0053, 0x030C}},  // 'Š'
-    {0x0161, {0x0073, 0x030C}},  // 'š'
-    {0x0162, {0x0054, 0x0327}},  // 'Ţ'
-    {0x0163, {0x0074, 0x0327}},  // 'ţ'
-    {0x0164, {0x0054, 0x030C}},  // 'Ť'
-    {0x0165, {0x0074, 0x030C}},  // 'ť'
-    {0x0168, {0x0055, 0x0303}},  // 'Ũ'
-    {0x0169, {0x0075, 0x0303}},  // 'ũ'
-    {0x016A, {0x0055, 0x0304}},  // 'Ū'
-    {0x016B, {0x0075, 0x0304}},  // 'ū'
-    {0x016C, {0x0055, 0x0306}},  // 'Ŭ'
-    {0x016D, {0x0075, 0x0306}},  // 'ŭ'
-    {0x016E, {0x0055, 0x030A}},  // 'Ů'
-    {0x016F, {0x0075, 0x030A}},  // 'ů'
-    {0x0170, {0x0055, 0x030B}},  // 'Ű'
-    {0x0171, {0x0075, 0x030B}},  // 'ű'
-    {0x0172, {0x0055, 0x0328}},  // 'Ų'
-    {0x0173, {0x0075, 0x0328}},  // 'ų'
-    {0x0174, {0x0057, 0x0302}},  // 'Ŵ'
-    {0x0175, {0x0077, 0x0302}},  // 'ŵ'
-    {0x0176, {0x0059, 0x0302}},  // 'Ŷ'
-    {0x0177, {0x0079, 0x0302}},  // 'ŷ'
-    {0x0178, {0x0059, 0x0308}},  // 'Ÿ'
-    {0x0179, {0x005A, 0x0301}},  // 'Ź'
-    {0x017A, {0x007A, 0x0301}},  // 'ź'
-    {0x017B, {0x005A, 0x0307}},  // 'Ż'
-    {0x017C, {0x007A, 0x0307}},  // 'ż'
-    {0x017D, {0x005A, 0x030C}},  // 'Ž'
-    {0x017E, {0x007A, 0x030C}},  // 'ž'
-    {0x01A0, {0x004F, 0x031B}},  // 'Ơ'
-    {0x01A1, {0x006F, 0x031B}},  // 'ơ'
-    {0x01AF, {0x0055, 0x031B}},  // 'Ư'
-    {0x01B0, {0x0075, 0x031B}},  // 'ư'
-    {0x01CD, {0x0041, 0x030C}},  // 'Ǎ'
-    {0x01CE, {0x0061, 0x030C}},  // 'ǎ'
-    {0x01CF, {0x0049, 0x030C}},  // 'Ǐ'
-    {0x01D0, {0x0069, 0x030C}},  // 'ǐ'
-    {0x01D1, {0x004F, 0x030C}},  // 'Ǒ'
-    {0x01D2, {0x006F, 0x030C}},  // 'ǒ'
-    {0x01D3, {0x0055, 0x030C}},  // 'Ǔ'
-    {0x01D4, {0x0075, 0x030C}},  // 'ǔ'
-    {0x01D5, {0x0055, 0x0308, 0x0304}},  // 'Ǖ'
-    {0x01D6, {0x0075, 0x0308, 0x0304}},  // 'ǖ'
-    {0x01D7, {0x0055, 0x0308, 0x0301}},  // 'Ǘ'
-    {0x01D8, {0x0075, 0x0308, 0x0301}},  // 'ǘ'
-    {0x01D9, {0x0055, 0x0308, 0x030C}},  // 'Ǚ'
-    {0x01DA, {0x0075, 0x0308, 0x030C}},  // 'ǚ'
-    {0x01DB, {0x0055, 0x0308, 0x0300}},  // 'Ǜ'
-    {0x01DC, {0x0075, 0x0308, 0x0300}},  // 'ǜ'
-    {0x01DE, {0x0041, 0x0308, 0x0304}},  // 'Ǟ'
-    {0x01DF, {0x0061, 0x0308, 0x0304}},  // 'ǟ'
-    {0x01E0, {0x0041, 0x0307, 0x0304}},  // 'Ǡ'
-    {0x01E1, {0x0061, 0x0307, 0x0304}},  // 'ǡ'
-    {0x01E2, {0x00C6, 0x0304}},  // 'Ǣ'
-    {0x01E3, {0x00E6, 0x0304}},  // 'ǣ'
-    {0x01E6, {0x0047, 0x030C}},  // 'Ǧ'
-    {0x01E7, {0x0067, 0x030C}},  // 'ǧ'
-    {0x01E8, {0x004B, 0x030C}},  // 'Ǩ'
-    {0x01E9, {0x006B, 0x030C}},  // 'ǩ'
-    {0x01EA, {0x004F, 0x0328}},  // 'Ǫ'
-    {0x01EB, {0x006F, 0x0328}},  // 'ǫ'
-    {0x01EC, {0x004F, 0x0328, 0x0304}},  // 'Ǭ'
-    {0x01ED, {0x006F, 0x0328, 0x0304}},  // 'ǭ'
-    {0x01EE, {0x01B7, 0x030C}},  // 'Ǯ'
-    {0x01EF, {0x0292, 0x030C}},  // 'ǯ'
-    {0x01F0, {0x006A, 0x030C}},  // 'ǰ'
-    {0x01F4, {0x0047, 0x0301}},  // 'Ǵ'
-    {0x01F5, {0x0067, 0x0301}},  // 'ǵ'
-    {0x01F8, {0x004E, 0x0300}},  // 'Ǹ'
-    {0x01F9, {0x006E, 0x0300}},  // 'ǹ'
-    {0x01FA, {0x0041, 0x030A, 0x0301}},  // 'Ǻ'
-    {0x01FB, {0x0061, 0x030A, 0x0301}},  // 'ǻ'
-    {0x01FC, {0x00C6, 0x0301}},  // 'Ǽ'
-    {0x01FD, {0x00E6, 0x0301}},  // 'ǽ'
-    {0x01FE, {0x00D8, 0x0301}},  // 'Ǿ'
-    {0x01FF, {0x00F8, 0x0301}},  // 'ǿ'
-    {0x0200, {0x0041, 0x030F}},  // 'Ȁ'
-    {0x0201, {0x0061, 0x030F}},  // 'ȁ'
-    {0x0202, {0x0041, 0x0311}},  // 'Ȃ'
-    {0x0203, {0x0061, 0x0311}},  // 'ȃ'
-    {0x0204, {0x0045, 0x030F}},  // 'Ȅ'
-    {0x0205, {0x0065, 0x030F}},  // 'ȅ'
-    {0x0206, {0x0045, 0x0311}},  // 'Ȇ'
-    {0x0207, {0x0065, 0x0311}},  // 'ȇ'
-    {0x0208, {0x0049, 0x030F}},  // 'Ȉ'
-    {0x0209, {0x0069, 0x030F}},  // 'ȉ'
-    {0x020A, {0x0049, 0x0311}},  // 'Ȋ'
-    {0x020B, {0x0069, 0x0311}},  // 'ȋ'
-    {0x020C, {0x004F, 0x030F}},  // 'Ȍ'
-    {0x020D, {0x006F, 0x030F}},  // 'ȍ'
-    {0x020E, {0x004F, 0x0311}},  // 'Ȏ'
-    {0x020F, {0x006F, 0x0311}},  // 'ȏ'
-    {0x0210, {0x0052, 0x030F}},  // 'Ȑ'
-    {0x0211, {0x0072, 0x030F}},  // 'ȑ'
-    {0x0212, {0x0052, 0x0311}},  // 'Ȓ'
-    {0x0213, {0x0072, 0x0311}},  // 'ȓ'
-    {0x0214, {0x0055, 0x030F}},  // 'Ȕ'
-    {0x0215, {0x0075, 0x030F}},  // 'ȕ'
-    {0x0216, {0x0055, 0x0311}},  // 'Ȗ'
-    {0x0217, {0x0075, 0x0311}},  // 'ȗ'
-    {0x0218, {0x0053, 0x0326}},  // 'Ș'
-    {0x0219, {0x0073, 0x0326}},  // 'ș'
-    {0x021A, {0x0054, 0x0326}},  // 'Ț'
-    {0x021B, {0x0074, 0x0326}},  // 'ț'
-    {0x021E, {0x0048, 0x030C}},  // 'Ȟ'
-    {0x021F, {0x0068, 0x030C}},  // 'ȟ'
-    {0x0226, {0x0041, 0x0307}},  // 'Ȧ'
-    {0x0227, {0x0061, 0x0307}},  // 'ȧ'
-    {0x0228, {0x0045, 0x0327}},  // 'Ȩ'
-    {0x0229, {0x0065, 0x0327}},  // 'ȩ'
-    {0x022A, {0x004F, 0x0308, 0x0304}},  // 'Ȫ'
-    {0x022B, {0x006F, 0x0308, 0x0304}},  // 'ȫ'
-    {0x022C, {0x004F, 0x0303, 0x0304}},  // 'Ȭ'
-    {0x022D, {0x006F, 0x0303, 0x0304}},  // 'ȭ'
-    {0x022E, {0x004F, 0x0307}},  // 'Ȯ'
-    {0x022F, {0x006F, 0x0307}},  // 'ȯ'
-    {0x0230, {0x004F, 0x0307, 0x0304}},  // 'Ȱ'
-    {0x0231, {0x006F, 0x0307, 0x0304}},  // 'ȱ'
-    {0x0232, {0x0059, 0x0304}},  // 'Ȳ'
-    {0x0233, {0x0079, 0x0304}},  // 'ȳ'
-    {0x0340, {0x0300}},  // '̀'
-    {0x0341, {0x0301}},  // '́'
-    {0x0343, {0x0313}},  // '̓'
-    {0x0344, {0x0308, 0x0301}},  // '̈́'
-    {0x0374, {0x02B9}},  // 'ʹ'
-    {0x037E, {0x003B}},  // ';'
-    {0x0385, {0x00A8, 0x0301}},  // '΅'
-    {0x0386, {0x0391, 0x0301}},  // 'Ά'
-    {0x0387, {0x00B7}},  // '·'
-    {0x0388, {0x0395, 0x0301}},  // 'Έ'
-    {0x0389, {0x0397, 0x0301}},  // 'Ή'
-    {0x038A, {0x0399, 0x0301}},  // 'Ί'
-    {0x038C, {0x039F, 0x0301}},  // 'Ό'
-    {0x038E, {0x03A5, 0x0301}},  // 'Ύ'
-    {0x038F, {0x03A9, 0x0301}},  // 'Ώ'
-    {0x0390, {0x03B9, 0x0308, 0x0301}},  // 'ΐ'
-    {0x03AA, {0x0399, 0x0308}},  // 'Ϊ'
-    {0x03AB, {0x03A5, 0x0308}},  // 'Ϋ'
-    {0x03AC, {0x03B1, 0x0301}},  // 'ά'
-    {0x03AD, {0x03B5, 0x0301}},  // 'έ'
-    {0x03AE, {0x03B7, 0x0301}},  // 'ή'
-    {0x03AF, {0x03B9, 0x0301}},  // 'ί'
-    {0x03B0, {0x03C5, 0x0308, 0x0301}},  // 'ΰ'
-    {0x03CA, {0x03B9, 0x0308}},  // 'ϊ'
-    {0x03CB, {0x03C5, 0x0308}},  // 'ϋ'
-    {0x03CC, {0x03BF, 0x0301}},  // 'ό'
-    {0x03CD, {0x03C5, 0x0301}},  // 'ύ'
-    {0x03CE, {0x03C9, 0x0301}},  // 'ώ'
-    {0x03D3, {0x03D2, 0x0301}},  // 'ϓ'
-    {0x03D4, {0x03D2, 0x0308}},  // 'ϔ'
-    {0x0400, {0x0415, 0x0300}},  // 'Ѐ'
-    {0x0401, {0x0415, 0x0308}},  // 'Ё'
-    {0x0403, {0x0413, 0x0301}},  // 'Ѓ'
-    {0x0407, {0x0406, 0x0308}},  // 'Ї'
-    {0x040C, {0x041A, 0x0301}},  // 'Ќ'
-    {0x040D, {0x0418, 0x0300}},  // 'Ѝ'
-    {0x040E, {0x0423, 0x0306}},  // 'Ў'
-    {0x0419, {0x0418, 0x0306}},  // 'Й'
-    {0x0439, {0x0438, 0x0306}},  // 'й'
-    {0x0450, {0x0435, 0x0300}},  // 'ѐ'
-    {0x0451, {0x0435, 0x0308}},  // 'ё'
-    {0x0453, {0x0433, 0x0301}},  // 'ѓ'
-    {0x0457, {0x0456, 0x0308}},  // 'ї'
-    {0x045C, {0x043A, 0x0301}},  // 'ќ'
-    {0x045D, {0x0438, 0x0300}},  // 'ѝ'
-    {0x045E, {0x0443, 0x0306}},  // 'ў'
-    {0x0476, {0x0474, 0x030F}},  // 'Ѷ'
-    {0x0477, {0x0475, 0x030F}},  // 'ѷ'
-    {0x04C1, {0x0416, 0x0306}},  // 'Ӂ'
-    {0x04C2, {0x0436, 0x0306}},  // 'ӂ'
-    {0x04D0, {0x0410, 0x0306}},  // 'Ӑ'
-    {0x04D1, {0x0430, 0x0306}},  // 'ӑ'
-    {0x04D2, {0x0410, 0x0308}},  // 'Ӓ'
-    {0x04D3, {0x0430, 0x0308}},  // 'ӓ'
-    {0x04D6, {0x0415, 0x0306}},  // 'Ӗ'
-    {0x04D7, {0x0435, 0x0306}},  // 'ӗ'
-    {0x04DA, {0x04D8, 0x0308}},  // 'Ӛ'
-    {0x04DB, {0x04D9, 0x0308}},  // 'ӛ'
-    {0x04DC, {0x0416, 0x0308}},  // 'Ӝ'
-    {0x04DD, {0x0436, 0x0308}},  // 'ӝ'
-    {0x04DE, {0x0417, 0x0308}},  // 'Ӟ'
-    {0x04DF, {0x0437, 0x0308}},  // 'ӟ'
-    {0x04E2, {0x0418, 0x0304}},  // 'Ӣ'
-    {0x04E3, {0x0438, 0x0304}},  // 'ӣ'
-    {0x04E4, {0x0418, 0x0308}},  // 'Ӥ'
-    {0x04E5, {0x0438, 0x0308}},  // 'ӥ'
-    {0x04E6, {0x041E, 0x0308}},  // 'Ӧ'
-    {0x04E7, {0x043E, 0x0308}},  // 'ӧ'
-    {0x04EA, {0x04E8, 0x0308}},  // 'Ӫ'
-    {0x04EB, {0x04E9, 0x0308}},  // 'ӫ'
-    {0x04EC, {0x042D, 0x0308}},  // 'Ӭ'
-    {0x04ED, {0x044D, 0x0308}},  // 'ӭ'
-    {0x04EE, {0x0423, 0x0304}},  // 'Ӯ'
-    {0x04EF, {0x0443, 0x0304}},  // 'ӯ'
-    {0x04F0, {0x0423, 0x0308}},  // 'Ӱ'
-    {0x04F1, {0x0443, 0x0308}},  // 'ӱ'
-    {0x04F2, {0x0423, 0x030B}},  // 'Ӳ'
-    {0x04F3, {0x0443, 0x030B}},  // 'ӳ'
-    {0x04F4, {0x0427, 0x0308}},  // 'Ӵ'
-    {0x04F5, {0x0447, 0x0308}},  // 'ӵ'
-    {0x04F8, {0x042B, 0x0308}},  // 'Ӹ'
-    {0x04F9, {0x044B, 0x0308}},  // 'ӹ'
-    {0x0622, {0x0627, 0x0653}},  // 'آ'
-    {0x0623, {0x0627, 0x0654}},  // 'أ'
-    {0x0624, {0x0648, 0x0654}},  // 'ؤ'
-    {0x0625, {0x0627, 0x0655}},  // 'إ'
-    {0x0626, {0x064A, 0x0654}},  // 'ئ'
-    {0x06C0, {0x06D5, 0x0654}},  // 'ۀ'
-    {0x06C2, {0x06C1, 0x0654}},  // 'ۂ'
-    {0x06D3, {0x06D2, 0x0654}},  // 'ۓ'
-    {0x0929, {0x0928, 0x093C}},  // 'ऩ'
-    {0x0931, {0x0930, 0x093C}},  // 'ऱ'
-    {0x0934, {0x0933, 0x093C}},  // 'ऴ'
-    {0x0958, {0x0915, 0x093C}},  // 'क़'
-    {0x0959, {0x0916, 0x093C}},  // 'ख़'
-    {0x095A, {0x0917, 0x093C}},  // 'ग़'
-    {0x095B, {0x091C, 0x093C}},  // 'ज़'
-    {0x095C, {0x0921, 0x093C}},  // 'ड़'
-    {0x095D, {0x0922, 0x093C}},  // 'ढ़'
-    {0x095E, {0x092B, 0x093C}},  // 'फ़'
-    {0x095F, {0x092F, 0x093C}},  // 'य़'
-    {0x09CB, {0x09C7, 0x09BE}},  // 'ো'
-    {0x09CC, {0x09C7, 0x09D7}},  // 'ৌ'
-    {0x09DC, {0x09A1, 0x09BC}},  // 'ড়'
-    {0x09DD, {0x09A2, 0x09BC}},  // 'ঢ়'
-    {0x09DF, {0x09AF, 0x09BC}},  // 'য়'
-    {0x0A33, {0x0A32, 0x0A3C}},  // 'ਲ਼'
-    {0x0A36, {0x0A38, 0x0A3C}},  // 'ਸ਼'
-    {0x0A59, {0x0A16, 0x0A3C}},  // 'ਖ਼'
-    {0x0A5A, {0x0A17, 0x0A3C}},  // 'ਗ਼'
-    {0x0A5B, {0x0A1C, 0x0A3C}},  // 'ਜ਼'
-    {0x0A5E, {0x0A2B, 0x0A3C}},  // 'ਫ਼'
-    {0x0B48, {0x0B47, 0x0B56}},  // 'ୈ'
-    {0x0B4B, {0x0B47, 0x0B3E}},  // 'ୋ'
-    {0x0B4C, {0x0B47, 0x0B57}},  // 'ୌ'
-    {0x0B5C, {0x0B21, 0x0B3C}},  // 'ଡ଼'
-    {0x0B5D, {0x0B22, 0x0B3C}},  // 'ଢ଼'
-    {0x0B94, {0x0B92, 0x0BD7}},  // 'ஔ'
-    {0x0BCA, {0x0BC6, 0x0BBE}},  // 'ொ'
-    {0x0BCB, {0x0BC7, 0x0BBE}},  // 'ோ'
-    {0x0BCC, {0x0BC6, 0x0BD7}},  // 'ௌ'
-    {0x0C48, {0x0C46, 0x0C56}},  // 'ై'
-    {0x0CC0, {0x0CBF, 0x0CD5}},  // 'ೀ'
-    {0x0CC7, {0x0CC6, 0x0CD5}},  // 'ೇ'
-    {0x0CC8, {0x0CC6, 0x0CD6}},  // 'ೈ'
-    {0x0CCA, {0x0CC6, 0x0CC2}},  // 'ೊ'
-    {0x0CCB, {0x0CC6, 0x0CC2, 0x0CD5}},  // 'ೋ'
-    {0x0D4A, {0x0D46, 0x0D3E}},  // 'ൊ'
-    {0x0D4B, {0x0D47, 0x0D3E}},  // 'ോ'
-    {0x0D4C, {0x0D46, 0x0D57}},  // 'ൌ'
-    {0x0DDA, {0x0DD9, 0x0DCA}},  // 'ේ'
-    {0x0DDC, {0x0DD9, 0x0DCF}},  // 'ො'
-    {0x0DDD, {0x0DD9, 0x0DCF, 0x0DCA}},  // 'ෝ'
-    {0x0DDE, {0x0DD9, 0x0DDF}},  // 'ෞ'
-    {0x0F43, {0x0F42, 0x0FB7}},  // 'གྷ'
-    {0x0F4D, {0x0F4C, 0x0FB7}},  // 'ཌྷ'
-    {0x0F52, {0x0F51, 0x0FB7}},  // 'དྷ'
-    {0x0F57, {0x0F56, 0x0FB7}},  // 'བྷ'
-    {0x0F5C, {0x0F5B, 0x0FB7}},  // 'ཛྷ'
-    {0x0F69, {0x0F40, 0x0FB5}},  // 'ཀྵ'
-    {0x0F73, {0x0F71, 0x0F72}},  // 'ཱི'
-    {0x0F75, {0x0F71, 0x0F74}},  // 'ཱུ'
-    {0x0F76, {0x0FB2, 0x0F80}},  // 'ྲྀ'
-    {0x0F78, {0x0FB3, 0x0F80}},  // 'ླྀ'
-    {0x0F81, {0x0F71, 0x0F80}},  // 'ཱྀ'
-    {0x0F93, {0x0F92, 0x0FB7}},  // 'ྒྷ'
-    {0x0F9D, {0x0F9C, 0x0FB7}},  // 'ྜྷ'
-    {0x0FA2, {0x0FA1, 0x0FB7}},  // 'ྡྷ'
-    {0x0FA7, {0x0FA6, 0x0FB7}},  // 'ྦྷ'
-    {0x0FAC, {0x0FAB, 0x0FB7}},  // 'ྫྷ'
-    {0x0FB9, {0x0F90, 0x0FB5}},  // 'ྐྵ'
-    {0x1026, {0x1025, 0x102E}},  // 'ဦ'
-    {0x1B06, {0x1B05, 0x1B35}},  // 'ᬆ'
-    {0x1B08, {0x1B07, 0x1B35}},  // 'ᬈ'
-    {0x1B0A, {0x1B09, 0x1B35}},  // 'ᬊ'
-    {0x1B0C, {0x1B0B, 0x1B35}},  // 'ᬌ'
-    {0x1B0E, {0x1B0D, 0x1B35}},  // 'ᬎ'
-    {0x1B12, {0x1B11, 0x1B35}},  // 'ᬒ'
-    {0x1B3B, {0x1B3A, 0x1B35}},  // 'ᬻ'
-    {0x1B3D, {0x1B3C, 0x1B35}},  // 'ᬽ'
-    {0x1B40, {0x1B3E, 0x1B35}},  // 'ᭀ'
-    {0x1B41, {0x1B3F, 0x1B35}},  // 'ᭁ'
-    {0x1B43, {0x1B42, 0x1B35}},  // 'ᭃ'
-    {0x1E00, {0x0041, 0x0325}},  // 'Ḁ'
-    {0x1E01, {0x0061, 0x0325}},  // 'ḁ'
-    {0x1E02, {0x0042, 0x0307}},  // 'Ḃ'
-    {0x1E03, {0x0062, 0x0307}},  // 'ḃ'
-    {0x1E04, {0x0042, 0x0323}},  // 'Ḅ'
-    {0x1E05, {0x0062, 0x0323}},  // 'ḅ'
-    {0x1E06, {0x0042, 0x0331}},  // 'Ḇ'
-    {0x1E07, {0x0062, 0x0331}},  // 'ḇ'
-    {0x1E08, {0x0043, 0x0327, 0x0301}},  // 'Ḉ'
-    {0x1E09, {0x0063, 0x0327, 0x0301}},  // 'ḉ'
-    {0x1E0A, {0x0044, 0x0307}},  // 'Ḋ'
-    {0x1E0B, {0x0064, 0x0307}},  // 'ḋ'
-    {0x1E0C, {0x0044, 0x0323}},  // 'Ḍ'
-    {0x1E0D, {0x0064, 0x0323}},  // 'ḍ'
-    {0x1E0E, {0x0044, 0x0331}},  // 'Ḏ'
-    {0x1E0F, {0x0064, 0x0331}},  // 'ḏ'
-    {0x1E10, {0x0044, 0x0327}},  // 'Ḑ'
-    {0x1E11, {0x0064, 0x0327}},  // 'ḑ'
-    {0x1E12, {0x0044, 0x032D}},  // 'Ḓ'
-    {0x1E13, {0x0064, 0x032D}},  // 'ḓ'
-    {0x1E14, {0x0045, 0x0304, 0x0300}},  // 'Ḕ'
-    {0x1E15, {0x0065, 0x0304, 0x0300}},  // 'ḕ'
-    {0x1E16, {0x0045, 0x0304, 0x0301}},  // 'Ḗ'
-    {0x1E17, {0x0065, 0x0304, 0x0301}},  // 'ḗ'
-    {0x1E18, {0x0045, 0x032D}},  // 'Ḙ'
-    {0x1E19, {0x0065, 0x032D}},  // 'ḙ'
-    {0x1E1A, {0x0045, 0x0330}},  // 'Ḛ'
-    {0x1E1B, {0x0065, 0x0330}},  // 'ḛ'
-    {0x1E1C, {0x0045, 0x0327, 0x0306}},  // 'Ḝ'
-    {0x1E1D, {0x0065, 0x0327, 0x0306}},  // 'ḝ'
-    {0x1E1E, {0x0046, 0x0307}},  // 'Ḟ'
-    {0x1E1F, {0x0066, 0x0307}},  // 'ḟ'
-    {0x1E20, {0x0047, 0x0304}},  // 'Ḡ'
-    {0x1E21, {0x0067, 0x0304}},  // 'ḡ'
-    {0x1E22, {0x0048, 0x0307}},  // 'Ḣ'
-    {0x1E23, {0x0068, 0x0307}},  // 'ḣ'
-    {0x1E24, {0x0048, 0x0323}},  // 'Ḥ'
-    {0x1E25, {0x0068, 0x0323}},  // 'ḥ'
-    {0x1E26, {0x0048, 0x0308}},  // 'Ḧ'
-    {0x1E27, {0x0068, 0x0308}},  // 'ḧ'
-    {0x1E28, {0x0048, 0x0327}},  // 'Ḩ'
-    {0x1E29, {0x0068, 0x0327}},  // 'ḩ'
-    {0x1E2A, {0x0048, 0x032E}},  // 'Ḫ'
-    {0x1E2B, {0x0068, 0x032E}},  // 'ḫ'
-    {0x1E2C, {0x0049, 0x0330}},  // 'Ḭ'
-    {0x1E2D, {0x0069, 0x0330}},  // 'ḭ'
-    {0x1E2E, {0x0049, 0x0308, 0x0301}},  // 'Ḯ'
-    {0x1E2F, {0x0069, 0x0308, 0x0301}},  // 'ḯ'
-    {0x1E30, {0x004B, 0x0301}},  // 'Ḱ'
-    {0x1E31, {0x006B, 0x0301}},  // 'ḱ'
-    {0x1E32, {0x004B, 0x0323}},  // 'Ḳ'
-    {0x1E33, {0x006B, 0x0323}},  // 'ḳ'
-    {0x1E34, {0x004B, 0x0331}},  // 'Ḵ'
-    {0x1E35, {0x006B, 0x0331}},  // 'ḵ'
-    {0x1E36, {0x004C, 0x0323}},  // 'Ḷ'
-    {0x1E37, {0x006C, 0x0323}},  // 'ḷ'
-    {0x1E38, {0x004C, 0x0323, 0x0304}},  // 'Ḹ'
-    {0x1E39, {0x006C, 0x0323, 0x0304}},  // 'ḹ'
-    {0x1E3A, {0x004C, 0x0331}},  // 'Ḻ'
-    {0x1E3B, {0x006C, 0x0331}},  // 'ḻ'
-    {0x1E3C, {0x004C, 0x032D}},  // 'Ḽ'
-    {0x1E3D, {0x006C, 0x032D}},  // 'ḽ'
-    {0x1E3E, {0x004D, 0x0301}},  // 'Ḿ'
-    {0x1E3F, {0x006D, 0x0301}},  // 'ḿ'
-    {0x1E40, {0x004D, 0x0307}},  // 'Ṁ'
-    {0x1E41, {0x006D, 0x0307}},  // 'ṁ'
-    {0x1E42, {0x004D, 0x0323}},  // 'Ṃ'
-    {0x1E43, {0x006D, 0x0323}},  // 'ṃ'
-    {0x1E44, {0x004E, 0x0307}},  // 'Ṅ'
-    {0x1E45, {0x006E, 0x0307}},  // 'ṅ'
-    {0x1E46, {0x004E, 0x0323}},  // 'Ṇ'
-    {0x1E47, {0x006E, 0x0323}},  // 'ṇ'
-    {0x1E48, {0x004E, 0x0331}},  // 'Ṉ'
-    {0x1E49, {0x006E, 0x0331}},  // 'ṉ'
-    {0x1E4A, {0x004E, 0x032D}},  // 'Ṋ'
-    {0x1E4B, {0x006E, 0x032D}},  // 'ṋ'
-    {0x1E4C, {0x004F, 0x0303, 0x0301}},  // 'Ṍ'
-    {0x1E4D, {0x006F, 0x0303, 0x0301}},  // 'ṍ'
-    {0x1E4E, {0x004F, 0x0303, 0x0308}},  // 'Ṏ'
-    {0x1E4F, {0x006F, 0x0303, 0x0308}},  // 'ṏ'
-    {0x1E50, {0x004F, 0x0304, 0x0300}},  // 'Ṑ'
-    {0x1E51, {0x006F, 0x0304, 0x0300}},  // 'ṑ'
-    {0x1E52, {0x004F, 0x0304, 0x0301}},  // 'Ṓ'
-    {0x1E53, {0x006F, 0x0304, 0x0301}},  // 'ṓ'
-    {0x1E54, {0x0050, 0x0301}},  // 'Ṕ'
-    {0x1E55, {0x0070, 0x0301}},  // 'ṕ'
-    {0x1E56, {0x0050, 0x0307}},  // 'Ṗ'
-    {0x1E57, {0x0070, 0x0307}},  // 'ṗ'
-    {0x1E58, {0x0052, 0x0307}},  // 'Ṙ'
-    {0x1E59, {0x0072, 0x0307}},  // 'ṙ'
-    {0x1E5A, {0x0052, 0x0323}},  // 'Ṛ'
-    {0x1E5B, {0x0072, 0x0323}},  // 'ṛ'
-    {0x1E5C, {0x0052, 0x0323, 0x0304}},  // 'Ṝ'
-    {0x1E5D, {0x0072, 0x0323, 0x0304}},  // 'ṝ'
-    {0x1E5E, {0x0052, 0x0331}},  // 'Ṟ'
-    {0x1E5F, {0x0072, 0x0331}},  // 'ṟ'
-    {0x1E60, {0x0053, 0x0307}},  // 'Ṡ'
-    {0x1E61, {0x0073, 0x0307}},  // 'ṡ'
-    {0x1E62, {0x0053, 0x0323}},  // 'Ṣ'
-    {0x1E63, {0x0073, 0x0323}},  // 'ṣ'
-    {0x1E64, {0x0053, 0x0301, 0x0307}},  // 'Ṥ'
-    {0x1E65, {0x0073, 0x0301, 0x0307}},  // 'ṥ'
-    {0x1E66, {0x0053, 0x030C, 0x0307}},  // 'Ṧ'
-    {0x1E67, {0x0073, 0x030C, 0x0307}},  // 'ṧ'
-    {0x1E68, {0x0053, 0x0323, 0x0307}},  // 'Ṩ'
-    {0x1E69, {0x0073, 0x0323, 0x0307}},  // 'ṩ'
-    {0x1E6A, {0x0054, 0x0307}},  // 'Ṫ'
-    {0x1E6B, {0x0074, 0x0307}},  // 'ṫ'
-    {0x1E6C, {0x0054, 0x0323}},  // 'Ṭ'
-    {0x1E6D, {0x0074, 0x0323}},  // 'ṭ'
-    {0x1E6E, {0x0054, 0x0331}},  // 'Ṯ'
-    {0x1E6F, {0x0074, 0x0331}},  // 'ṯ'
-    {0x1E70, {0x0054, 0x032D}},  // 'Ṱ'
-    {0x1E71, {0x0074, 0x032D}},  // 'ṱ'
-    {0x1E72, {0x0055, 0x0324}},  // 'Ṳ'
-    {0x1E73, {0x0075, 0x0324}},  // 'ṳ'
-    {0x1E74, {0x0055, 0x0330}},  // 'Ṵ'
-    {0x1E75, {0x0075, 0x0330}},  // 'ṵ'
-    {0x1E76, {0x0055, 0x032D}},  // 'Ṷ'
-    {0x1E77, {0x0075, 0x032D}},  // 'ṷ'
-    {0x1E78, {0x0055, 0x0303, 0x0301}},  // 'Ṹ'
-    {0x1E79, {0x0075, 0x0303, 0x0301}},  // 'ṹ'
-    {0x1E7A, {0x0055, 0x0304, 0x0308}},  // 'Ṻ'
-    {0x1E7B, {0x0075, 0x0304, 0x0308}},  // 'ṻ'
-    {0x1E7C, {0x0056, 0x0303}},  // 'Ṽ'
-    {0x1E7D, {0x0076, 0x0303}},  // 'ṽ'
-    {0x1E7E, {0x0056, 0x0323}},  // 'Ṿ'
-    {0x1E7F, {0x0076, 0x0323}},  // 'ṿ'
-    {0x1E80, {0x0057, 0x0300}},  // 'Ẁ'
-    {0x1E81, {0x0077, 0x0300}},  // 'ẁ'
-    {0x1E82, {0x0057, 0x0301}},  // 'Ẃ'
-    {0x1E83, {0x0077, 0x0301}},  // 'ẃ'
-    {0x1E84, {0x0057, 0x0308}},  // 'Ẅ'
-    {0x1E85, {0x0077, 0x0308}},  // 'ẅ'
-    {0x1E86, {0x0057, 0x0307}},  // 'Ẇ'
-    {0x1E87, {0x0077, 0x0307}},  // 'ẇ'
-    {0x1E88, {0x0057, 0x0323}},  // 'Ẉ'
-    {0x1E89, {0x0077, 0x0323}},  // 'ẉ'
-    {0x1E8A, {0x0058, 0x0307}},  // 'Ẋ'
-    {0x1E8B, {0x0078, 0x0307}},  // 'ẋ'
-    {0x1E8C, {0x0058, 0x0308}},  // 'Ẍ'
-    {0x1E8D, {0x0078, 0x0308}},  // 'ẍ'
-    {0x1E8E, {0x0059, 0x0307}},  // 'Ẏ'
-    {0x1E8F, {0x0079, 0x0307}},  // 'ẏ'
-    {0x1E90, {0x005A, 0x0302}},  // 'Ẑ'
-    {0x1E91, {0x007A, 0x0302}},  // 'ẑ'
-    {0x1E92, {0x005A, 0x0323}},  // 'Ẓ'
-    {0x1E93, {0x007A, 0x0323}},  // 'ẓ'
-    {0x1E94, {0x005A, 0x0331}},  // 'Ẕ'
-    {0x1E95, {0x007A, 0x0331}},  // 'ẕ'
-    {0x1E96, {0x0068, 0x0331}},  // 'ẖ'
-    {0x1E97, {0x0074, 0x0308}},  // 'ẗ'
-    {0x1E98, {0x0077, 0x030A}},  // 'ẘ'
-    {0x1E99, {0x0079, 0x030A}},  // 'ẙ'
-    {0x1E9B, {0x017F, 0x0307}},  // 'ẛ'
-    {0x1EA0, {0x0041, 0x0323}},  // 'Ạ'
-    {0x1EA1, {0x0061, 0x0323}},  // 'ạ'
-    {0x1EA2, {0x0041, 0x0309}},  // 'Ả'
-    {0x1EA3, {0x0061, 0x0309}},  // 'ả'
-    {0x1EA4, {0x0041, 0x0302, 0x0301}},  // 'Ấ'
-    {0x1EA5, {0x0061, 0x0302, 0x0301}},  // 'ấ'
-    {0x1EA6, {0x0041, 0x0302, 0x0300}},  // 'Ầ'
-    {0x1EA7, {0x0061, 0x0302, 0x0300}},  // 'ầ'
-    {0x1EA8, {0x0041, 0x0302, 0x0309}},  // 'Ẩ'
-    {0x1EA9, {0x0061, 0x0302, 0x0309}},  // 'ẩ'
-    {0x1EAA, {0x0041, 0x0302, 0x0303}},  // 'Ẫ'
-    {0x1EAB, {0x0061, 0x0302, 0x0303}},  // 'ẫ'
-    {0x1EAC, {0x0041, 0x0323, 0x0302}},  // 'Ậ'
-    {0x1EAD, {0x0061, 0x0323, 0x0302}},  // 'ậ'
-    {0x1EAE, {0x0041, 0x0306, 0x0301}},  // 'Ắ'
-    {0x1EAF, {0x0061, 0x0306, 0x0301}},  // 'ắ'
-    {0x1EB0, {0x0041, 0x0306, 0x0300}},  // 'Ằ'
-    {0x1EB1, {0x0061, 0x0306, 0x0300}},  // 'ằ'
-    {0x1EB2, {0x0041, 0x0306, 0x0309}},  // 'Ẳ'
-    {0x1EB3, {0x0061, 0x0306, 0x0309}},  // 'ẳ'
-    {0x1EB4, {0x0041, 0x0306, 0x0303}},  // 'Ẵ'
-    {0x1EB5, {0x0061, 0x0306, 0x0303}},  // 'ẵ'
-    {0x1EB6, {0x0041, 0x0323, 0x0306}},  // 'Ặ'
-    {0x1EB7, {0x0061, 0x0323, 0x0306}},  // 'ặ'
-    {0x1EB8, {0x0045, 0x0323}},  // 'Ẹ'
-    {0x1EB9, {0x0065, 0x0323}},  // 'ẹ'
-    {0x1EBA, {0x0045, 0x0309}},  // 'Ẻ'
-    {0x1EBB, {0x0065, 0x0309}},  // 'ẻ'
-    {0x1EBC, {0x0045, 0x0303}},  // 'Ẽ'
-    {0x1EBD, {0x0065, 0x0303}},  // 'ẽ'
-    {0x1EBE, {0x0045, 0x0302, 0x0301}},  // 'Ế'
-    {0x1EBF, {0x0065, 0x0302, 0x0301}},  // 'ế'
-    {0x1EC0, {0x0045, 0x0302, 0x0300}},  // 'Ề'
-    {0x1EC1, {0x0065, 0x0302, 0x0300}},  // 'ề'
-    {0x1EC2, {0x0045, 0x0302, 0x0309}},  // 'Ể'
-    {0x1EC3, {0x0065, 0x0302, 0x0309}},  // 'ể'
-    {0x1EC4, {0x0045, 0x0302, 0x0303}},  // 'Ễ'
-    {0x1EC5, {0x0065, 0x0302, 0x0303}},  // 'ễ'
-    {0x1EC6, {0x0045, 0x0323, 0x0302}},  // 'Ệ'
-    {0x1EC7, {0x0065, 0x0323, 0x0302}},  // 'ệ'
-    {0x1EC8, {0x0049, 0x0309}},  // 'Ỉ'
-    {0x1EC9, {0x0069, 0x0309}},  // 'ỉ'
-    {0x1ECA, {0x0049, 0x0323}},  // 'Ị'
-    {0x1ECB, {0x0069, 0x0323}},  // 'ị'
-    {0x1ECC, {0x004F, 0x0323}},  // 'Ọ'
-    {0x1ECD, {0x006F, 0x0323}},  // 'ọ'
-    {0x1ECE, {0x004F, 0x0309}},  // 'Ỏ'
-    {0x1ECF, {0x006F, 0x0309}},  // 'ỏ'
-    {0x1ED0, {0x004F, 0x0302, 0x0301}},  // 'Ố'
-    {0x1ED1, {0x006F, 0x0302, 0x0301}},  // 'ố'
-    {0x1ED2, {0x004F, 0x0302, 0x0300}},  // 'Ồ'
-    {0x1ED3, {0x006F, 0x0302, 0x0300}},  // 'ồ'
-    {0x1ED4, {0x004F, 0x0302, 0x0309}},  // 'Ổ'
-    {0x1ED5, {0x006F, 0x0302, 0x0309}},  // 'ổ'
-    {0x1ED6, {0x004F, 0x0302, 0x0303}},  // 'Ỗ'
-    {0x1ED7, {0x006F, 0x0302, 0x0303}},  // 'ỗ'
-    {0x1ED8, {0x004F, 0x0323, 0x0302}},  // 'Ộ'
-    {0x1ED9, {0x006F, 0x0323, 0x0302}},  // 'ộ'
-    {0x1EDA, {0x004F, 0x031B, 0x0301}},  // 'Ớ'
-    {0x1EDB, {0x006F, 0x031B, 0x0301}},  // 'ớ'
-    {0x1EDC, {0x004F, 0x031B, 0x0300}},  // 'Ờ'
-    {0x1EDD, {0x006F, 0x031B, 0x0300}},  // 'ờ'
-    {0x1EDE, {0x004F, 0x031B, 0x0309}},  // 'Ở'
-    {0x1EDF, {0x006F, 0x031B, 0x0309}},  // 'ở'
-    {0x1EE0, {0x004F, 0x031B, 0x0303}},  // 'Ỡ'
-    {0x1EE1, {0x006F, 0x031B, 0x0303}},  // 'ỡ'
-    {0x1EE2, {0x004F, 0x031B, 0x0323}},  // 'Ợ'
-    {0x1EE3, {0x006F, 0x031B, 0x0323}},  // 'ợ'
-    {0x1EE4, {0x0055, 0x0323}},  // 'Ụ'
-    {0x1EE5, {0x0075, 0x0323}},  // 'ụ'
-    {0x1EE6, {0x0055, 0x0309}},  // 'Ủ'
-    {0x1EE7, {0x0075, 0x0309}},  // 'ủ'
-    {0x1EE8, {0x0055, 0x031B, 0x0301}},  // 'Ứ'
-    {0x1EE9, {0x0075, 0x031B, 0x0301}},  // 'ứ'
-    {0x1EEA, {0x0055, 0x031B, 0x0300}},  // 'Ừ'
-    {0x1EEB, {0x0075, 0x031B, 0x0300}},  // 'ừ'
-    {0x1EEC, {0x0055, 0x031B, 0x0309}},  // 'Ử'
-    {0x1EED, {0x0075, 0x031B, 0x0309}},  // 'ử'
-    {0x1EEE, {0x0055, 0x031B, 0x0303}},  // 'Ữ'
-    {0x1EEF, {0x0075, 0x031B, 0x0303}},  // 'ữ'
-    {0x1EF0, {0x0055, 0x031B, 0x0323}},  // 'Ự'
-    {0x1EF1, {0x0075, 0x031B, 0x0323}},  // 'ự'
-    {0x1EF2, {0x0059, 0x0300}},  // 'Ỳ'
-    {0x1EF3, {0x0079, 0x0300}},  // 'ỳ'
-    {0x1EF4, {0x0059, 0x0323}},  // 'Ỵ'
-    {0x1EF5, {0x0079, 0x0323}},  // 'ỵ'
-    {0x1EF6, {0x0059, 0x0309}},  // 'Ỷ'
-    {0x1EF7, {0x0079, 0x0309}},  // 'ỷ'
-    {0x1EF8, {0x0059, 0x0303}},  // 'Ỹ'
-    {0x1EF9, {0x0079, 0x0303}},  // 'ỹ'
-    {0x1F00, {0x03B1, 0x0313}},  // 'ἀ'
-    {0x1F01, {0x03B1, 0x0314}},  // 'ἁ'
-    {0x1F02, {0x03B1, 0x0313, 0x0300}},  // 'ἂ'
-    {0x1F03, {0x03B1, 0x0314, 0x0300}},  // 'ἃ'
-    {0x1F04, {0x03B1, 0x0313, 0x0301}},  // 'ἄ'
-    {0x1F05, {0x03B1, 0x0314, 0x0301}},  // 'ἅ'
-    {0x1F06, {0x03B1, 0x0313, 0x0342}},  // 'ἆ'
-    {0x1F07, {0x03B1, 0x0314, 0x0342}},  // 'ἇ'
-    {0x1F08, {0x0391, 0x0313}},  // 'Ἀ'
-    {0x1F09, {0x0391, 0x0314}},  // 'Ἁ'
-    {0x1F0A, {0x0391, 0x0313, 0x0300}},  // 'Ἂ'
-    {0x1F0B, {0x0391, 0x0314, 0x0300}},  // 'Ἃ'
-    {0x1F0C, {0x0391, 0x0313, 0x0301}},  // 'Ἄ'
-    {0x1F0D, {0x0391, 0x0314, 0x0301}},  // 'Ἅ'
-    {0x1F0E, {0x0391, 0x0313, 0x0342}},  // 'Ἆ'
-    {0x1F0F, {0x0391, 0x0314, 0x0342}},  // 'Ἇ'
-    {0x1F10, {0x03B5, 0x0313}},  // 'ἐ'
-    {0x1F11, {0x03B5, 0x0314}},  // 'ἑ'
-    {0x1F12, {0x03B5, 0x0313, 0x0300}},  // 'ἒ'
-    {0x1F13, {0x03B5, 0x0314, 0x0300}},  // 'ἓ'
-    {0x1F14, {0x03B5, 0x0313, 0x0301}},  // 'ἔ'
-    {0x1F15, {0x03B5, 0x0314, 0x0301}},  // 'ἕ'
-    {0x1F18, {0x0395, 0x0313}},  // 'Ἐ'
-    {0x1F19, {0x0395, 0x0314}},  // 'Ἑ'
-    {0x1F1A, {0x0395, 0x0313, 0x0300}},  // 'Ἒ'
-    {0x1F1B, {0x0395, 0x0314, 0x0300}},  // 'Ἓ'
-    {0x1F1C, {0x0395, 0x0313, 0x0301}},  // 'Ἔ'
-    {0x1F1D, {0x0395, 0x0314, 0x0301}},  // 'Ἕ'
-    {0x1F20, {0x03B7, 0x0313}},  // 'ἠ'
-    {0x1F21, {0x03B7, 0x0314}},  // 'ἡ'
-    {0x1F22, {0x03B7, 0x0313, 0x0300}},  // 'ἢ'
-    {0x1F23, {0x03B7, 0x0314, 0x0300}},  // 'ἣ'
-    {0x1F24, {0x03B7, 0x0313, 0x0301}},  // 'ἤ'
-    {0x1F25, {0x03B7, 0x0314, 0x0301}},  // 'ἥ'
-    {0x1F26, {0x03B7, 0x0313, 0x0342}},  // 'ἦ'
-    {0x1F27, {0x03B7, 0x0314, 0x0342}},  // 'ἧ'
-    {0x1F28, {0x0397, 0x0313}},  // 'Ἠ'
-    {0x1F29, {0x0397, 0x0314}},  // 'Ἡ'
-    {0x1F2A, {0x0397, 0x0313, 0x0300}},  // 'Ἢ'
-    {0x1F2B, {0x0397, 0x0314, 0x0300}},  // 'Ἣ'
-    {0x1F2C, {0x0397, 0x0313, 0x0301}},  // 'Ἤ'
-    {0x1F2D, {0x0397, 0x0314, 0x0301}},  // 'Ἥ'
-    {0x1F2E, {0x0397, 0x0313, 0x0342}},  // 'Ἦ'
-    {0x1F2F, {0x0397, 0x0314, 0x0342}},  // 'Ἧ'
-    {0x1F30, {0x03B9, 0x0313}},  // 'ἰ'
-    {0x1F31, {0x03B9, 0x0314}},  // 'ἱ'
-    {0x1F32, {0x03B9, 0x0313, 0x0300}},  // 'ἲ'
-    {0x1F33, {0x03B9, 0x0314, 0x0300}},  // 'ἳ'
-    {0x1F34, {0x03B9, 0x0313, 0x0301}},  // 'ἴ'
-    {0x1F35, {0x03B9, 0x0314, 0x0301}},  // 'ἵ'
-    {0x1F36, {0x03B9, 0x0313, 0x0342}},  // 'ἶ'
-    {0x1F37, {0x03B9, 0x0314, 0x0342}},  // 'ἷ'
-    {0x1F38, {0x0399, 0x0313}},  // 'Ἰ'
-    {0x1F39, {0x0399, 0x0314}},  // 'Ἱ'
-    {0x1F3A, {0x0399, 0x0313, 0x0300}},  // 'Ἲ'
-    {0x1F3B, {0x0399, 0x0314, 0x0300}},  // 'Ἳ'
-    {0x1F3C, {0x0399, 0x0313, 0x0301}},  // 'Ἴ'
-    {0x1F3D, {0x0399, 0x0314, 0x0301}},  // 'Ἵ'
-    {0x1F3E, {0x0399, 0x0313, 0x0342}},  // 'Ἶ'
-    {0x1F3F, {0x0399, 0x0314, 0x0342}},  // 'Ἷ'
-    {0x1F40, {0x03BF, 0x0313}},  // 'ὀ'
-    {0x1F41, {0x03BF, 0x0314}},  // 'ὁ'
-    {0x1F42, {0x03BF, 0x0313, 0x0300}},  // 'ὂ'
-    {0x1F43, {0x03BF, 0x0314, 0x0300}},  // 'ὃ'
-    {0x1F44, {0x03BF, 0x0313, 0x0301}},  // 'ὄ'
-    {0x1F45, {0x03BF, 0x0314, 0x0301}},  // 'ὅ'
-    {0x1F48, {0x039F, 0x0313}},  // 'Ὀ'
-    {0x1F49, {0x039F, 0x0314}},  // 'Ὁ'
-    {0x1F4A, {0x039F, 0x0313, 0x0300}},  // 'Ὂ'
-    {0x1F4B, {0x039F, 0x0314, 0x0300}},  // 'Ὃ'
-    {0x1F4C, {0x039F, 0x0313, 0x0301}},  // 'Ὄ'
-    {0x1F4D, {0x039F, 0x0314, 0x0301}},  // 'Ὅ'
-    {0x1F50, {0x03C5, 0x0313}},  // 'ὐ'
-    {0x1F51, {0x03C5, 0x0314}},  // 'ὑ'
-    {0x1F52, {0x03C5, 0x0313, 0x0300}},  // 'ὒ'
-    {0x1F53, {0x03C5, 0x0314, 0x0300}},  // 'ὓ'
-    {0x1F54, {0x03C5, 0x0313, 0x0301}},  // 'ὔ'
-    {0x1F55, {0x03C5, 0x0314, 0x0301}},  // 'ὕ'
-    {0x1F56, {0x03C5, 0x0313, 0x0342}},  // 'ὖ'
-    {0x1F57, {0x03C5, 0x0314, 0x0342}},  // 'ὗ'
-    {0x1F59, {0x03A5, 0x0314}},  // 'Ὑ'
-    {0x1F5B, {0x03A5, 0x0314, 0x0300}},  // 'Ὓ'
-    {0x1F5D, {0x03A5, 0x0314, 0x0301}},  // 'Ὕ'
-    {0x1F5F, {0x03A5, 0x0314, 0x0342}},  // 'Ὗ'
-    {0x1F60, {0x03C9, 0x0313}},  // 'ὠ'
-    {0x1F61, {0x03C9, 0x0314}},  // 'ὡ'
-    {0x1F62, {0x03C9, 0x0313, 0x0300}},  // 'ὢ'
-    {0x1F63, {0x03C9, 0x0314, 0x0300}},  // 'ὣ'
-    {0x1F64, {0x03C9, 0x0313, 0x0301}},  // 'ὤ'
-    {0x1F65, {0x03C9, 0x0314, 0x0301}},  // 'ὥ'
-    {0x1F66, {0x03C9, 0x0313, 0x0342}},  // 'ὦ'
-    {0x1F67, {0x03C9, 0x0314, 0x0342}},  // 'ὧ'
-    {0x1F68, {0x03A9, 0x0313}},  // 'Ὠ'
-    {0x1F69, {0x03A9, 0x0314}},  // 'Ὡ'
-    {0x1F6A, {0x03A9, 0x0313, 0x0300}},  // 'Ὢ'
-    {0x1F6B, {0x03A9, 0x0314, 0x0300}},  // 'Ὣ'
-    {0x1F6C, {0x03A9, 0x0313, 0x0301}},  // 'Ὤ'
-    {0x1F6D, {0x03A9, 0x0314, 0x0301}},  // 'Ὥ'
-    {0x1F6E, {0x03A9, 0x0313, 0x0342}},  // 'Ὦ'
-    {0x1F6F, {0x03A9, 0x0314, 0x0342}},  // 'Ὧ'
-    {0x1F70, {0x03B1, 0x0300}},  // 'ὰ'
-    {0x1F71, {0x03B1, 0x0301}},  // 'ά'
-    {0x1F72, {0x03B5, 0x0300}},  // 'ὲ'
-    {0x1F73, {0x03B5, 0x0301}},  // 'έ'
-    {0x1F74, {0x03B7, 0x0300}},  // 'ὴ'
-    {0x1F75, {0x03B7, 0x0301}},  // 'ή'
-    {0x1F76, {0x03B9, 0x0300}},  // 'ὶ'
-    {0x1F77, {0x03B9, 0x0301}},  // 'ί'
-    {0x1F78, {0x03BF, 0x0300}},  // 'ὸ'
-    {0x1F79, {0x03BF, 0x0301}},  // 'ό'
-    {0x1F7A, {0x03C5, 0x0300}},  // 'ὺ'
-    {0x1F7B, {0x03C5, 0x0301}},  // 'ύ'
-    {0x1F7C, {0x03C9, 0x0300}},  // 'ὼ'
-    {0x1F7D, {0x03C9, 0x0301}},  // 'ώ'
-    {0x1F80, {0x03B1, 0x0313, 0x0345}},  // 'ᾀ'
-    {0x1F81, {0x03B1, 0x0314, 0x0345}},  // 'ᾁ'
-    {0x1F82, {0x03B1, 0x0313, 0x0300, 0x0345}},  // 'ᾂ'
-    {0x1F83, {0x03B1, 0x0314, 0x0300, 0x0345}},  // 'ᾃ'
-    {0x1F84, {0x03B1, 0x0313, 0x0301, 0x0345}},  // 'ᾄ'
-    {0x1F85, {0x03B1, 0x0314, 0x0301, 0x0345}},  // 'ᾅ'
-    {0x1F86, {0x03B1, 0x0313, 0x0342, 0x0345}},  // 'ᾆ'
-    {0x1F87, {0x03B1, 0x0314, 0x0342, 0x0345}},  // 'ᾇ'
-    {0x1F88, {0x0391, 0x0313, 0x0345}},  // 'ᾈ'
-    {0x1F89, {0x0391, 0x0314, 0x0345}},  // 'ᾉ'
-    {0x1F8A, {0x0391, 0x0313, 0x0300, 0x0345}},  // 'ᾊ'
-    {0x1F8B, {0x0391, 0x0314, 0x0300, 0x0345}},  // 'ᾋ'
-    {0x1F8C, {0x0391, 0x0313, 0x0301, 0x0345}},  // 'ᾌ'
-    {0x1F8D, {0x0391, 0x0314, 0x0301, 0x0345}},  // 'ᾍ'
-    {0x1F8E, {0x0391, 0x0313, 0x0342, 0x0345}},  // 'ᾎ'
-    {0x1F8F, {0x0391, 0x0314, 0x0342, 0x0345}},  // 'ᾏ'
-    {0x1F90, {0x03B7, 0x0313, 0x0345}},  // 'ᾐ'
-    {0x1F91, {0x03B7, 0x0314, 0x0345}},  // 'ᾑ'
-    {0x1F92, {0x03B7, 0x0313, 0x0300, 0x0345}},  // 'ᾒ'
-    {0x1F93, {0x03B7, 0x0314, 0x0300, 0x0345}},  // 'ᾓ'
-    {0x1F94, {0x03B7, 0x0313, 0x0301, 0x0345}},  // 'ᾔ'
-    {0x1F95, {0x03B7, 0x0314, 0x0301, 0x0345}},  // 'ᾕ'
-    {0x1F96, {0x03B7, 0x0313, 0x0342, 0x0345}},  // 'ᾖ'
-    {0x1F97, {0x03B7, 0x0314, 0x0342, 0x0345}},  // 'ᾗ'
-    {0x1F98, {0x0397, 0x0313, 0x0345}},  // 'ᾘ'
-    {0x1F99, {0x0397, 0x0314, 0x0345}},  // 'ᾙ'
-    {0x1F9A, {0x0397, 0x0313, 0x0300, 0x0345}},  // 'ᾚ'
-    {0x1F9B, {0x0397, 0x0314, 0x0300, 0x0345}},  // 'ᾛ'
-    {0x1F9C, {0x0397, 0x0313, 0x0301, 0x0345}},  // 'ᾜ'
-    {0x1F9D, {0x0397, 0x0314, 0x0301, 0x0345}},  // 'ᾝ'
-    {0x1F9E, {0x0397, 0x0313, 0x0342, 0x0345}},  // 'ᾞ'
-    {0x1F9F, {0x0397, 0x0314, 0x0342, 0x0345}},  // 'ᾟ'
-    {0x1FA0, {0x03C9, 0x0313, 0x0345}},  // 'ᾠ'
-    {0x1FA1, {0x03C9, 0x0314, 0x0345}},  // 'ᾡ'
-    {0x1FA2, {0x03C9, 0x0313, 0x0300, 0x0345}},  // 'ᾢ'
-    {0x1FA3, {0x03C9, 0x0314, 0x0300, 0x0345}},  // 'ᾣ'
-    {0x1FA4, {0x03C9, 0x0313, 0x0301, 0x0345}},  // 'ᾤ'
-    {0x1FA5, {0x03C9, 0x0314, 0x0301, 0x0345}},  // 'ᾥ'
-    {0x1FA6, {0x03C9, 0x0313, 0x0342, 0x0345}},  // 'ᾦ'
-    {0x1FA7, {0x03C9, 0x0314, 0x0342, 0x0345}},  // 'ᾧ'
-    {0x1FA8, {0x03A9, 0x0313, 0x0345}},  // 'ᾨ'
-    {0x1FA9, {0x03A9, 0x0314, 0x0345}},  // 'ᾩ'
-    {0x1FAA, {0x03A9, 0x0313, 0x0300, 0x0345}},  // 'ᾪ'
-    {0x1FAB, {0x03A9, 0x0314, 0x0300, 0x0345}},  // 'ᾫ'
-    {0x1FAC, {0x03A9, 0x0313, 0x0301, 0x0345}},  // 'ᾬ'
-    {0x1FAD, {0x03A9, 0x0314, 0x0301, 0x0345}},  // 'ᾭ'
-    {0x1FAE, {0x03A9, 0x0313, 0x0342, 0x0345}},  // 'ᾮ'
-    {0x1FAF, {0x03A9, 0x0314, 0x0342, 0x0345}},  // 'ᾯ'
-    {0x1FB0, {0x03B1, 0x0306}},  // 'ᾰ'
-    {0x1FB1, {0x03B1, 0x0304}},  // 'ᾱ'
-    {0x1FB2, {0x03B1, 0x0300, 0x0345}},  // 'ᾲ'
-    {0x1FB3, {0x03B1, 0x0345}},  // 'ᾳ'
-    {0x1FB4, {0x03B1, 0x0301, 0x0345}},  // 'ᾴ'
-    {0x1FB6, {0x03B1, 0x0342}},  // 'ᾶ'
-    {0x1FB7, {0x03B1, 0x0342, 0x0345}},  // 'ᾷ'
-    {0x1FB8, {0x0391, 0x0306}},  // 'Ᾰ'
-    {0x1FB9, {0x0391, 0x0304}},  // 'Ᾱ'
-    {0x1FBA, {0x0391, 0x0300}},  // 'Ὰ'
-    {0x1FBB, {0x0391, 0x0301}},  // 'Ά'
-    {0x1FBC, {0x0391, 0x0345}},  // 'ᾼ'
-    {0x1FBE, {0x03B9}},  // 'ι'
-    {0x1FC1, {0x00A8, 0x0342}},  // '῁'
-    {0x1FC2, {0x03B7, 0x0300, 0x0345}},  // 'ῂ'
-    {0x1FC3, {0x03B7, 0x0345}},  // 'ῃ'
-    {0x1FC4, {0x03B7, 0x0301, 0x0345}},  // 'ῄ'
-    {0x1FC6, {0x03B7, 0x0342}},  // 'ῆ'
-    {0x1FC7, {0x03B7, 0x0342, 0x0345}},  // 'ῇ'
-    {0x1FC8, {0x0395, 0x0300}},  // 'Ὲ'
-    {0x1FC9, {0x0395, 0x0301}},  // 'Έ'
-    {0x1FCA, {0x0397, 0x0300}},  // 'Ὴ'
-    {0x1FCB, {0x0397, 0x0301}},  // 'Ή'
-    {0x1FCC, {0x0397, 0x0345}},  // 'ῌ'
-    {0x1FCD, {0x1FBF, 0x0300}},  // '῍'
-    {0x1FCE, {0x1FBF, 0x0301}},  // '῎'
-    {0x1FCF, {0x1FBF, 0x0342}},  // '῏'
-    {0x1FD0, {0x03B9, 0x0306}},  // 'ῐ'
-    {0x1FD1, {0x03B9, 0x0304}},  // 'ῑ'
-    {0x1FD2, {0x03B9, 0x0308, 0x0300}},  // 'ῒ'
-    {0x1FD3, {0x03B9, 0x0308, 0x0301}},  // 'ΐ'
-    {0x1FD6, {0x03B9, 0x0342}},  // 'ῖ'
-    {0x1FD7, {0x03B9, 0x0308, 0x0342}},  // 'ῗ'
-    {0x1FD8, {0x0399, 0x0306}},  // 'Ῐ'
-    {0x1FD9, {0x0399, 0x0304}},  // 'Ῑ'
-    {0x1FDA, {0x0399, 0x0300}},  // 'Ὶ'
-    {0x1FDB, {0x0399, 0x0301}},  // 'Ί'
-    {0x1FDD, {0x1FFE, 0x0300}},  // '῝'
-    {0x1FDE, {0x1FFE, 0x0301}},  // '῞'
-    {0x1FDF, {0x1FFE, 0x0342}},  // '῟'
-    {0x1FE0, {0x03C5, 0x0306}},  // 'ῠ'
-    {0x1FE1, {0x03C5, 0x0304}},  // 'ῡ'
-    {0x1FE2, {0x03C5, 0x0308, 0x0300}},  // 'ῢ'
-    {0x1FE3, {0x03C5, 0x0308, 0x0301}},  // 'ΰ'
-    {0x1FE4, {0x03C1, 0x0313}},  // 'ῤ'
-    {0x1FE5, {0x03C1, 0x0314}},  // 'ῥ'
-    {0x1FE6, {0x03C5, 0x0342}},  // 'ῦ'
-    {0x1FE7, {0x03C5, 0x0308, 0x0342}},  // 'ῧ'
-    {0x1FE8, {0x03A5, 0x0306}},  // 'Ῠ'
-    {0x1FE9, {0x03A5, 0x0304}},  // 'Ῡ'
-    {0x1FEA, {0x03A5, 0x0300}},  // 'Ὺ'
-    {0x1FEB, {0x03A5, 0x0301}},  // 'Ύ'
-    {0x1FEC, {0x03A1, 0x0314}},  // 'Ῥ'
-    {0x1FED, {0x00A8, 0x0300}},  // '῭'
-    {0x1FEE, {0x00A8, 0x0301}},  // '΅'
-    {0x1FEF, {0x0060}},  // '`'
-    {0x1FF2, {0x03C9, 0x0300, 0x0345}},  // 'ῲ'
-    {0x1FF3, {0x03C9, 0x0345}},  // 'ῳ'
-    {0x1FF4, {0x03C9, 0x0301, 0x0345}},  // 'ῴ'
-    {0x1FF6, {0x03C9, 0x0342}},  // 'ῶ'
-    {0x1FF7, {0x03C9, 0x0342, 0x0345}},  // 'ῷ'
-    {0x1FF8, {0x039F, 0x0300}},  // 'Ὸ'
-    {0x1FF9, {0x039F, 0x0301}},  // 'Ό'
-    {0x1FFA, {0x03A9, 0x0300}},  // 'Ὼ'
-    {0x1FFB, {0x03A9, 0x0301}},  // 'Ώ'
-    {0x1FFC, {0x03A9, 0x0345}},  // 'ῼ'
-    {0x1FFD, {0x00B4}},  // '´'
-    {0x2000, {0x2002}},
-    {0x2001, {0x2003}},
-    {0x2126, {0x03A9}},  // 'Ω'
-    {0x212A, {0x004B}},  // 'K'
-    {0x212B, {0x0041, 0x030A}},  // 'Å'
-    {0x219A, {0x2190, 0x0338}},  // '↚'
-    {0x219B, {0x2192, 0x0338}},  // '↛'
-    {0x21AE, {0x2194, 0x0338}},  // '↮'
-    {0x21CD, {0x21D0, 0x0338}},  // '⇍'
-    {0x21CE, {0x21D4, 0x0338}},  // '⇎'
-    {0x21CF, {0x21D2, 0x0338}},  // '⇏'
-    {0x2204, {0x2203, 0x0338}},  // '∄'
-    {0x2209, {0x2208, 0x0338}},  // '∉'
-    {0x220C, {0x220B, 0x0338}},  // '∌'
-    {0x2224, {0x2223, 0x0338}},  // '∤'
-    {0x2226, {0x2225, 0x0338}},  // '∦'
-    {0x2241, {0x223C, 0x0338}},  // '≁'
-    {0x2244, {0x2243, 0x0338}},  // '≄'
-    {0x2247, {0x2245, 0x0338}},  // '≇'
-    {0x2249, {0x2248, 0x0338}},  // '≉'
-    {0x2260, {0x003D, 0x0338}},  // '≠'
-    {0x2262, {0x2261, 0x0338}},  // '≢'
-    {0x226D, {0x224D, 0x0338}},  // '≭'
-    {0x226E, {0x003C, 0x0338}},  // '≮'
-    {0x226F, {0x003E, 0x0338}},  // '≯'
-    {0x2270, {0x2264, 0x0338}},  // '≰'
-    {0x2271, {0x2265, 0x0338}},  // '≱'
-    {0x2274, {0x2272, 0x0338}},  // '≴'
-    {0x2275, {0x2273, 0x0338}},  // '≵'
-    {0x2278, {0x2276, 0x0338}},  // '≸'
-    {0x2279, {0x2277, 0x0338}},  // '≹'
-    {0x2280, {0x227A, 0x0338}},  // '⊀'
-    {0x2281, {0x227B, 0x0338}},  // '⊁'
-    {0x2284, {0x2282, 0x0338}},  // '⊄'
-    {0x2285, {0x2283, 0x0338}},  // '⊅'
-    {0x2288, {0x2286, 0x0338}},  // '⊈'
-    {0x2289, {0x2287, 0x0338}},  // '⊉'
-    {0x22AC, {0x22A2, 0x0338}},  // '⊬'
-    {0x22AD, {0x22A8, 0x0338}},  // '⊭'
-    {0x22AE, {0x22A9, 0x0338}},  // '⊮'
-    {0x22AF, {0x22AB, 0x0338}},  // '⊯'
-    {0x22E0, {0x227C, 0x0338}},  // '⋠'
-    {0x22E1, {0x227D, 0x0338}},  // '⋡'
-    {0x22E2, {0x2291, 0x0338}},  // '⋢'
-    {0x22E3, {0x2292, 0x0338}},  // '⋣'
-    {0x22EA, {0x22B2, 0x0338}},  // '⋪'
-    {0x22EB, {0x22B3, 0x0338}},  // '⋫'
-    {0x22EC, {0x22B4, 0x0338}},  // '⋬'
-    {0x22ED, {0x22B5, 0x0338}},  // '⋭'
-    {0x2329, {0x3008}},  // '〈'
-    {0x232A, {0x3009}},  // '〉'
-    {0x2ADC, {0x2ADD, 0x0338}},  // '⫝̸'
-    {0x304C, {0x304B, 0x3099}},  // 'が'
-    {0x304E, {0x304D, 0x3099}},  // 'ぎ'
-    {0x3050, {0x304F, 0x3099}},  // 'ぐ'
-    {0x3052, {0x3051, 0x3099}},  // 'げ'
-    {0x3054, {0x3053, 0x3099}},  // 'ご'
-    {0x3056, {0x3055, 0x3099}},  // 'ざ'
-    {0x3058, {0x3057, 0x3099}},  // 'じ'
-    {0x305A, {0x3059, 0x3099}},  // 'ず'
-    {0x305C, {0x305B, 0x3099}},  // 'ぜ'
-    {0x305E, {0x305D, 0x3099}},  // 'ぞ'
-    {0x3060, {0x305F, 0x3099}},  // 'だ'
-    {0x3062, {0x3061, 0x3099}},  // 'ぢ'
-    {0x3065, {0x3064, 0x3099}},  // 'づ'
-    {0x3067, {0x3066, 0x3099}},  // 'で'
-    {0x3069, {0x3068, 0x3099}},  // 'ど'
-    {0x3070, {0x306F, 0x3099}},  // 'ば'
-    {0x3071, {0x306F, 0x309A}},  // 'ぱ'
-    {0x3073, {0x3072, 0x3099}},  // 'び'
-    {0x3074, {0x3072, 0x309A}},  // 'ぴ'
-    {0x3076, {0x3075, 0x3099}},  // 'ぶ'
-    {0x3077, {0x3075, 0x309A}},  // 'ぷ'
-    {0x3079, {0x3078, 0x3099}},  // 'べ'
-    {0x307A, {0x3078, 0x309A}},  // 'ぺ'
-    {0x307C, {0x307B, 0x3099}},  // 'ぼ'
-    {0x307D, {0x307B, 0x309A}},  // 'ぽ'
-    {0x3094, {0x3046, 0x3099}},  // 'ゔ'
-    {0x309E, {0x309D, 0x3099}},  // 'ゞ'
-    {0x30AC, {0x30AB, 0x3099}},  // 'ガ'
-    {0x30AE, {0x30AD, 0x3099}},  // 'ギ'
-    {0x30B0, {0x30AF, 0x3099}},  // 'グ'
-    {0x30B2, {0x30B1, 0x3099}},  // 'ゲ'
-    {0x30B4, {0x30B3, 0x3099}},  // 'ゴ'
-    {0x30B6, {0x30B5, 0x3099}},  // 'ザ'
-    {0x30B8, {0x30B7, 0x3099}},  // 'ジ'
-    {0x30BA, {0x30B9, 0x3099}},  // 'ズ'
-    {0x30BC, {0x30BB, 0x3099}},  // 'ゼ'
-    {0x30BE, {0x30BD, 0x3099}},  // 'ゾ'
-    {0x30C0, {0x30BF, 0x3099}},  // 'ダ'
-    {0x30C2, {0x30C1, 0x3099}},  // 'ヂ'
-    {0x30C5, {0x30C4, 0x3099}},  // 'ヅ'
-    {0x30C7, {0x30C6, 0x3099}},  // 'デ'
-    {0x30C9, {0x30C8, 0x3099}},  // 'ド'
-    {0x30D0, {0x30CF, 0x3099}},  // 'バ'
-    {0x30D1, {0x30CF, 0x309A}},  // 'パ'
-    {0x30D3, {0x30D2, 0x3099}},  // 'ビ'
-    {0x30D4, {0x30D2, 0x309A}},  // 'ピ'
-    {0x30D6, {0x30D5, 0x3099}},  // 'ブ'
-    {0x30D7, {0x30D5, 0x309A}},  // 'プ'
-    {0x30D9, {0x30D8, 0x3099}},  // 'ベ'
-    {0x30DA, {0x30D8, 0x309A}},  // 'ペ'
-    {0x30DC, {0x30DB, 0x3099}},  // 'ボ'
-    {0x30DD, {0x30DB, 0x309A}},  // 'ポ'
-    {0x30F4, {0x30A6, 0x3099}},  // 'ヴ'
-    {0x30F7, {0x30EF, 0x3099}},  // 'ヷ'
-    {0x30F8, {0x30F0, 0x3099}},  // 'ヸ'
-    {0x30F9, {0x30F1, 0x3099}},  // 'ヹ'
-    {0x30FA, {0x30F2, 0x3099}},  // 'ヺ'
-    {0x30FE, {0x30FD, 0x3099}},  // 'ヾ'
-    {0xF900, {0x8C48}},  // '豈'
-    {0xF901, {0x66F4}},  // '更'
-    {0xF902, {0x8ECA}},  // '車'
-    {0xF903, {0x8CC8}},  // '賈'
-    {0xF904, {0x6ED1}},  // '滑'
-    {0xF905, {0x4E32}},  // '串'
-    {0xF906, {0x53E5}},  // '句'
-    {0xF907, {0x9F9C}},  // '龜'
-    {0xF908, {0x9F9C}},  // '龜'
-    {0xF909, {0x5951}},  // '契'
-    {0xF90A, {0x91D1}},  // '金'
-    {0xF90B, {0x5587}},  // '喇'
-    {0xF90C, {0x5948}},  // '奈'
-    {0xF90D, {0x61F6}},  // '懶'
-    {0xF90E, {0x7669}},  // '癩'
-    {0xF90F, {0x7F85}},  // '羅'
-    {0xF910, {0x863F}},  // '蘿'
-    {0xF911, {0x87BA}},  // '螺'
-    {0xF912, {0x88F8}},  // '裸'
-    {0xF913, {0x908F}},  // '邏'
-    {0xF914, {0x6A02}},  // '樂'
-    {0xF915, {0x6D1B}},  // '洛'
-    {0xF916, {0x70D9}},  // '烙'
-    {0xF917, {0x73DE}},  // '珞'
-    {0xF918, {0x843D}},  // '落'
-    {0xF919, {0x916A}},  // '酪'
-    {0xF91A, {0x99F1}},  // '駱'
-    {0xF91B, {0x4E82}},  // '亂'
-    {0xF91C, {0x5375}},  // '卵'
-    {0xF91D, {0x6B04}},  // '欄'
-    {0xF91E, {0x721B}},  // '爛'
-    {0xF91F, {0x862D}},  // '蘭'
-    {0xF920, {0x9E1E}},  // '鸞'
-    {0xF921, {0x5D50}},  // '嵐'
-    {0xF922, {0x6FEB}},  // '濫'
-    {0xF923, {0x85CD}},  // '藍'
-    {0xF924, {0x8964}},  // '襤'
-    {0xF925, {0x62C9}},  // '拉'
-    {0xF926, {0x81D8}},  // '臘'
-    {0xF927, {0x881F}},  // '蠟'
-    {0xF928, {0x5ECA}},  // '廊'
-    {0xF929, {0x6717}},  // '朗'
-    {0xF92A, {0x6D6A}},  // '浪'
-    {0xF92B, {0x72FC}},  // '狼'
-    {0xF92C, {0x90CE}},  // '郎'
-    {0xF92D, {0x4F86}},  // '來'
-    {0xF92E, {0x51B7}},  // '冷'
-    {0xF92F, {0x52DE}},  // '勞'
-    {0xF930, {0x64C4}},  // '擄'
-    {0xF931, {0x6AD3}},  // '櫓'
-    {0xF932, {0x7210}},  // '爐'
-    {0xF933, {0x76E7}},  // '盧'
-    {0xF934, {0x8001}},  // '老'
-    {0xF935, {0x8606}},  // '蘆'
-    {0xF936, {0x865C}},  // '虜'
-    {0xF937, {0x8DEF}},  // '路'
-    {0xF938, {0x9732}},  // '露'
-    {0xF939, {0x9B6F}},  // '魯'
-    {0xF93A, {0x9DFA}},  // '鷺'
-    {0xF93B, {0x788C}},  // '碌'
-    {0xF93C, {0x797F}},  // '祿'
-    {0xF93D, {0x7DA0}},  // '綠'
-    {0xF93E, {0x83C9}},  // '菉'
-    {0xF93F, {0x9304}},  // '錄'
-    {0xF940, {0x9E7F}},  // '鹿'
-    {0xF941, {0x8AD6}},  // '論'
-    {0xF942, {0x58DF}},  // '壟'
-    {0xF943, {0x5F04}},  // '弄'
-    {0xF944, {0x7C60}},  // '籠'
-    {0xF945, {0x807E}},  // '聾'
-    {0xF946, {0x7262}},  // '牢'
-    {0xF947, {0x78CA}},  // '磊'
-    {0xF948, {0x8CC2}},  // '賂'
-    {0xF949, {0x96F7}},  // '雷'
-    {0xF94A, {0x58D8}},  // '壘'
-    {0xF94B, {0x5C62}},  // '屢'
-    {0xF94C, {0x6A13}},  // '樓'
-    {0xF94D, {0x6DDA}},  // '淚'
-    {0xF94E, {0x6F0F}},  // '漏'
-    {0xF94F, {0x7D2F}},  // '累'
-    {0xF950, {0x7E37}},  // '縷'
-    {0xF951, {0x964B}},  // '陋'
-    {0xF952, {0x52D2}},  // '勒'
-    {0xF953, {0x808B}},  // '肋'
-    {0xF954, {0x51DC}},  // '凜'
-    {0xF955, {0x51CC}},  // '凌'
-    {0xF956, {0x7A1C}},  // '稜'
-    {0xF957, {0x7DBE}},  // '綾'
-    {0xF958, {0x83F1}},  // '菱'
-    {0xF959, {0x9675}},  // '陵'
-    {0xF95A, {0x8B80}},  // '讀'
-    {0xF95B, {0x62CF}},  // '拏'
-    {0xF95C, {0x6A02}},  // '樂'
-    {0xF95D, {0x8AFE}},  // '諾'
-    {0xF95E, {0x4E39}},  // '丹'
-    {0xF95F, {0x5BE7}},  // '寧'
-    {0xF960, {0x6012}},  // '怒'
-    {0xF961, {0x7387}},  // '率'
-    {0xF962, {0x7570}},  // '異'
-    {0xF963, {0x5317}},  // '北'
-    {0xF964, {0x78FB}},  // '磻'
-    {0xF965, {0x4FBF}},  // '便'
-    {0xF966, {0x5FA9}},  // '復'
-    {0xF967, {0x4E0D}},  // '不'
-    {0xF968, {0x6CCC}},  // '泌'
-    {0xF969, {0x6578}},  // '數'
-    {0xF96A, {0x7D22}},  // '索'
-    {0xF96B, {0x53C3}},  // '參'
-    {0xF96C, {0x585E}},  // '塞'
-    {0xF96D, {0x7701}},  // '省'
-    {0xF96E, {0x8449}},  // '葉'
-    {0xF96F, {0x8AAA}},  // '說'
-    {0xF970, {0x6BBA}},  // '殺'
-    {0xF971, {0x8FB0}},  // '辰'
-    {0xF972, {0x6C88}},  // '沈'
-    {0xF973, {0x62FE}},  // '拾'
-    {0xF974, {0x82E5}},  // '若'
-    {0xF975, {0x63A0}},  // '掠'
-    {0xF976, {0x7565}},  // '略'
-    {0xF977, {0x4EAE}},  // '亮'
-    {0xF978, {0x5169}},  // '兩'
-    {0xF979, {0x51C9}},  // '凉'
-    {0xF97A, {0x6881}},  // '梁'
-    {0xF97B, {0x7CE7}},  // '糧'
-    {0xF97C, {0x826F}},  // '良'
-    {0xF97D, {0x8AD2}},  // '諒'
-    {0xF97E, {0x91CF}},  // '量'
-    {0xF97F, {0x52F5}},  // '勵'
-    {0xF980, {0x5442}},  // '呂'
-    {0xF981, {0x5973}},  // '女'
-    {0xF982, {0x5EEC}},  // '廬'
-    {0xF983, {0x65C5}},  // '旅'
-    {0xF984, {0x6FFE}},  // '濾'
-    {0xF985, {0x792A}},  // '礪'
-    {0xF986, {0x95AD}},  // '閭'
-    {0xF987, {0x9A6A}},  // '驪'
-    {0xF988, {0x9E97}},  // '麗'
-    {0xF989, {0x9ECE}},  // '黎'
-    {0xF98A, {0x529B}},  // '力'
-    {0xF98B, {0x66C6}},  // '曆'
-    {0xF98C, {0x6B77}},  // '歷'
-    {0xF98D, {0x8F62}},  // '轢'
-    {0xF98E, {0x5E74}},  // '年'
-    {0xF98F, {0x6190}},  // '憐'
-    {0xF990, {0x6200}},  // '戀'
-    {0xF991, {0x649A}},  // '撚'
-    {0xF992, {0x6F23}},  // '漣'
-    {0xF993, {0x7149}},  // '煉'
-    {0xF994, {0x7489}},  // '璉'
-    {0xF995, {0x79CA}},  // '秊'
-    {0xF996, {0x7DF4}},  // '練'
-    {0xF997, {0x806F}},  // '聯'
-    {0xF998, {0x8F26}},  // '輦'
-    {0xF999, {0x84EE}},  // '蓮'
-    {0xF99A, {0x9023}},  // '連'
-    {0xF99B, {0x934A}},  // '鍊'
-    {0xF99C, {0x5217}},  // '列'
-    {0xF99D, {0x52A3}},  // '劣'
-    {0xF99E, {0x54BD}},  // '咽'
-    {0xF99F, {0x70C8}},  // '烈'
-    {0xF9A0, {0x88C2}},  // '裂'
-    {0xF9A1, {0x8AAA}},  // '說'
-    {0xF9A2, {0x5EC9}},  // '廉'
-    {0xF9A3, {0x5FF5}},  // '念'
-    {0xF9A4, {0x637B}},  // '捻'
-    {0xF9A5, {0x6BAE}},  // '殮'
-    {0xF9A6, {0x7C3E}},  // '簾'
-    {0xF9A7, {0x7375}},  // '獵'
-    {0xF9A8, {0x4EE4}},  // '令'
-    {0xF9A9, {0x56F9}},  // '囹'
-    {0xF9AA, {0x5BE7}},  // '寧'
-    {0xF9AB, {0x5DBA}},  // '嶺'
-    {0xF9AC, {0x601C}},  // '怜'
-    {0xF9AD, {0x73B2}},  // '玲'
-    {0xF9AE, {0x7469}},  // '瑩'
-    {0xF9AF, {0x7F9A}},  // '羚'
-    {0xF9B0, {0x8046}},  // '聆'
-    {0xF9B1, {0x9234}},  // '鈴'
-    {0xF9B2, {0x96F6}},  // '零'
-    {0xF9B3, {0x9748}},  // '靈'
-    {0xF9B4, {0x9818}},  // '領'
-    {0xF9B5, {0x4F8B}},  // '例'
-    {0xF9B6, {0x79AE}},  // '禮'
-    {0xF9B7, {0x91B4}},  // '醴'
-    {0xF9B8, {0x96B8}},  // '隸'
-    {0xF9B9, {0x60E1}},  // '惡'
-    {0xF9BA, {0x4E86}},  // '了'
-    {0xF9BB, {0x50DA}},  // '僚'
-    {0xF9BC, {0x5BEE}},  // '寮'
-    {0xF9BD, {0x5C3F}},  // '尿'
-    {0xF9BE, {0x6599}},  // '料'
-    {0xF9BF, {0x6A02}},  // '樂'
-    {0xF9C0, {0x71CE}},  // '燎'
-    {0xF9C1, {0x7642}},  // '療'
-    {0xF9C2, {0x84FC}},  // '蓼'
-    {0xF9C3, {0x907C}},  // '遼'
-    {0xF9C4, {0x9F8D}},  // '龍'
-    {0xF9C5, {0x6688}},  // '暈'
-    {0xF9C6, {0x962E}},  // '阮'
-    {0xF9C7, {0x5289}},  // '劉'
-    {0xF9C8, {0x677B}},  // '杻'
-    {0xF9C9, {0x67F3}},  // '柳'
-    {0xF9CA, {0x6D41}},  // '流'
-    {0xF9CB, {0x6E9C}},  // '溜'
-    {0xF9CC, {0x7409}},  // '琉'
-    {0xF9CD, {0x7559}},  // '留'
-    {0xF9CE, {0x786B}},  // '硫'
-    {0xF9CF, {0x7D10}},  // '紐'
-    {0xF9D0, {0x985E}},  // '類'
-    {0xF9D1, {0x516D}},  // '六'
-    {0xF9D2, {0x622E}},  // '戮'
-    {0xF9D3, {0x9678}},  // '陸'
-    {0xF9D4, {0x502B}},  // '倫'
-    {0xF9D5, {0x5D19}},  // '崙'
-    {0xF9D6, {0x6DEA}},  // '淪'
-    {0xF9D7, {0x8F2A}},  // '輪'
-    {0xF9D8, {0x5F8B}},  // '律'
-    {0xF9D9, {0x6144}},  // '慄'
-    {0xF9DA, {0x6817}},  // '栗'
-    {0xF9DB, {0x7387}},  // '率'
-    {0xF9DC, {0x9686}},  // '隆'
-    {0xF9DD, {0x5229}},  // '利'
-    {0xF9DE, {0x540F}},  // '吏'
-    {0xF9DF, {0x5C65}},  // '履'
-    {0xF9E0, {0x6613}},  // '易'
-    {0xF9E1, {0x674E}},  // '李'
-    {0xF9E2, {0x68A8}},  // '梨'
-    {0xF9E3, {0x6CE5}},  // '泥'
-    {0xF9E4, {0x7406}},  // '理'
-    {0xF9E5, {0x75E2}},  // '痢'
-    {0xF9E6, {0x7F79}},  // '罹'
-    {0xF9E7, {0x88CF}},  // '裏'
-    {0xF9E8, {0x88E1}},  // '裡'
-    {0xF9E9, {0x91CC}},  // '里'
-    {0xF9EA, {0x96E2}},  // '離'
-    {0xF9EB, {0x533F}},  // '匿'
-    {0xF9EC, {0x6EBA}},  // '溺'
-    {0xF9ED, {0x541D}},  // '吝'
-    {0xF9EE, {0x71D0}},  // '燐'
-    {0xF9EF, {0x7498}},  // '璘'
-    {0xF9F0, {0x85FA}},  // '藺'
-    {0xF9F1, {0x96A3}},  // '隣'
-    {0xF9F2, {0x9C57}},  // '鱗'
-    {0xF9F3, {0x9E9F}},  // '麟'
-    {0xF9F4, {0x6797}},  // '林'
-    {0xF9F5, {0x6DCB}},  // '淋'
-    {0xF9F6, {0x81E8}},  // '臨'
-    {0xF9F7, {0x7ACB}},  // '立'
-    {0xF9F8, {0x7B20}},  // '笠'
-    {0xF9F9, {0x7C92}},  // '粒'
-    {0xF9FA, {0x72C0}},  // '狀'
-    {0xF9FB, {0x7099}},  // '炙'
-    {0xF9FC, {0x8B58}},  // '識'
-    {0xF9FD, {0x4EC0}},  // '什'
-    {0xF9FE, {0x8336}},  // '茶'
-    {0xF9FF, {0x523A}},  // '刺'
-    {0xFA00, {0x5207}},  // '切'
-    {0xFA01, {0x5EA6}},  // '度'
-    {0xFA02, {0x62D3}},  // '拓'
-    {0xFA03, {0x7CD6}},  // '糖'
-    {0xFA04, {0x5B85}},  // '宅'
-    {0xFA05, {0x6D1E}},  // '洞'
-    {0xFA06, {0x66B4}},  // '暴'
-    {0xFA07, {0x8F3B}},  // '輻'
-    {0xFA08, {0x884C}},  // '行'
-    {0xFA09, {0x964D}},  // '降'
-    {0xFA0A, {0x898B}},  // '見'
-    {0xFA0B, {0x5ED3}},  // '廓'
-    {0xFA0C, {0x5140}},  // '兀'
-    {0xFA0D, {0x55C0}},  // '嗀'
-    {0xFA10, {0x585A}},  // '塚'
-    {0xFA12, {0x6674}},  // '晴'
-    {0xFA15, {0x51DE}},  // '凞'
-    {0xFA16, {0x732A}},  // '猪'
-    {0xFA17, {0x76CA}},  // '益'
-    {0xFA18, {0x793C}},  // '礼'
-    {0xFA19, {0x795E}},  // '神'
-    {0xFA1A, {0x7965}},  // '祥'
-    {0xFA1B, {0x798F}},  // '福'
-    {0xFA1C, {0x9756}},  // '靖'
-    {0xFA1D, {0x7CBE}},  // '精'
-    {0xFA1E, {0x7FBD}},  // '羽'
-    {0xFA20, {0x8612}},  // '蘒'
-    {0xFA22, {0x8AF8}},  // '諸'
-    {0xFA25, {0x9038}},  // '逸'
-    {0xFA26, {0x90FD}},  // '都'
-    {0xFA2A, {0x98EF}},  // '飯'
-    {0xFA2B, {0x98FC}},  // '飼'
-    {0xFA2C, {0x9928}},  // '館'
-    {0xFA2D, {0x9DB4}},  // '鶴'
-    {0xFA2E, {0x90DE}},  // '郞'
-    {0xFA2F, {0x96B7}},  // '隷'
-    {0xFA30, {0x4FAE}},  // '侮'
-    {0xFA31, {0x50E7}},  // '僧'
-    {0xFA32, {0x514D}},  // '免'
-    {0xFA33, {0x52C9}},  // '勉'
-    {0xFA34, {0x52E4}},  // '勤'
-    {0xFA35, {0x5351}},  // '卑'
-    {0xFA36, {0x559D}},  // '喝'
-    {0xFA37, {0x5606}},  // '嘆'
-    {0xFA38, {0x5668}},  // '器'
-    {0xFA39, {0x5840}},  // '塀'
-    {0xFA3A, {0x58A8}},  // '墨'
-    {0xFA3B, {0x5C64}},  // '層'
-    {0xFA3C, {0x5C6E}},  // '屮'
-    {0xFA3D, {0x6094}},  // '悔'
-    {0xFA3E, {0x6168}},  // '慨'
-    {0xFA3F, {0x618E}},  // '憎'
-    {0xFA40, {0x61F2}},  // '懲'
-    {0xFA41, {0x654F}},  // '敏'
-    {0xFA42, {0x65E2}},  // '既'
-    {0xFA43, {0x6691}},  // '暑'
-    {0xFA44, {0x6885}},  // '梅'
-    {0xFA45, {0x6D77}},  // '海'
-    {0xFA46, {0x6E1A}},  // '渚'
-    {0xFA47, {0x6F22}},  // '漢'
-    {0xFA48, {0x716E}},  // '煮'
-    {0xFA49, {0x722B}},  // '爫'
-    {0xFA4A, {0x7422}},  // '琢'
-    {0xFA4B, {0x7891}},  // '碑'
-    {0xFA4C, {0x793E}},  // '社'
-    {0xFA4D, {0x7949}},  // '祉'
-    {0xFA4E, {0x7948}},  // '祈'
-    {0xFA4F, {0x7950}},  // '祐'
-    {0xFA50, {0x7956}},  // '祖'
-    {0xFA51, {0x795D}},  // '祝'
-    {0xFA52, {0x798D}},  // '禍'
-    {0xFA53, {0x798E}},  // '禎'
-    {0xFA54, {0x7A40}},  // '穀'
-    {0xFA55, {0x7A81}},  // '突'
-    {0xFA56, {0x7BC0}},  // '節'
-    {0xFA57, {0x7DF4}},  // '練'
-    {0xFA58, {0x7E09}},  // '縉'
-    {0xFA59, {0x7E41}},  // '繁'
-    {0xFA5A, {0x7F72}},  // '署'
-    {0xFA5B, {0x8005}},  // '者'
-    {0xFA5C, {0x81ED}},  // '臭'
-    {0xFA5D, {0x8279}},  // '艹'
-    {0xFA5E, {0x8279}},  // '艹'
-    {0xFA5F, {0x8457}},  // '著'
-    {0xFA60, {0x8910}},  // '褐'
-    {0xFA61, {0x8996}},  // '視'
-    {0xFA62, {0x8B01}},  // '謁'
-    {0xFA63, {0x8B39}},  // '謹'
-    {0xFA64, {0x8CD3}},  // '賓'
-    {0xFA65, {0x8D08}},  // '贈'
-    {0xFA66, {0x8FB6}},  // '辶'
-    {0xFA67, {0x9038}},  // '逸'
-    {0xFA68, {0x96E3}},  // '難'
-    {0xFA69, {0x97FF}},  // '響'
-    {0xFA6A, {0x983B}},  // '頻'
-    {0xFA6B, {0x6075}},  // '恵'
-    {0xFA6C, {0x242EE}},  // '𤋮'
-    {0xFA6D, {0x8218}},  // '舘'
-    {0xFA70, {0x4E26}},  // '並'
-    {0xFA71, {0x51B5}},  // '况'
-    {0xFA72, {0x5168}},  // '全'
-    {0xFA73, {0x4F80}},  // '侀'
-    {0xFA74, {0x5145}},  // '充'
-    {0xFA75, {0x5180}},  // '冀'
-    {0xFA76, {0x52C7}},  // '勇'
-    {0xFA77, {0x52FA}},  // '勺'
-    {0xFA78, {0x559D}},  // '喝'
-    {0xFA79, {0x5555}},  // '啕'
-    {0xFA7A, {0x5599}},  // '喙'
-    {0xFA7B, {0x55E2}},  // '嗢'
-    {0xFA7C, {0x585A}},  // '塚'
-    {0xFA7D, {0x58B3}},  // '墳'
-    {0xFA7E, {0x5944}},  // '奄'
-    {0xFA7F, {0x5954}},  // '奔'
-    {0xFA80, {0x5A62}},  // '婢'
-    {0xFA81, {0x5B28}},  // '嬨'
-    {0xFA82, {0x5ED2}},  // '廒'
-    {0xFA83, {0x5ED9}},  // '廙'
-    {0xFA84, {0x5F69}},  // '彩'
-    {0xFA85, {0x5FAD}},  // '徭'
-    {0xFA86, {0x60D8}},  // '惘'
-    {0xFA87, {0x614E}},  // '慎'
-    {0xFA88, {0x6108}},  // '愈'
-    {0xFA89, {0x618E}},  // '憎'
-    {0xFA8A, {0x6160}},  // '慠'
-    {0xFA8B, {0x61F2}},  // '懲'
-    {0xFA8C, {0x6234}},  // '戴'
-    {0xFA8D, {0x63C4}},  // '揄'
-    {0xFA8E, {0x641C}},  // '搜'
-    {0xFA8F, {0x6452}},  // '摒'
-    {0xFA90, {0x6556}},  // '敖'
-    {0xFA91, {0x6674}},  // '晴'
-    {0xFA92, {0x6717}},  // '朗'
-    {0xFA93, {0x671B}},  // '望'
-    {0xFA94, {0x6756}},  // '杖'
-    {0xFA95, {0x6B79}},  // '歹'
-    {0xFA96, {0x6BBA}},  // '殺'
-    {0xFA97, {0x6D41}},  // '流'
-    {0xFA98, {0x6EDB}},  // '滛'
-    {0xFA99, {0x6ECB}},  // '滋'
-    {0xFA9A, {0x6F22}},  // '漢'
-    {0xFA9B, {0x701E}},  // '瀞'
-    {0xFA9C, {0x716E}},  // '煮'
-    {0xFA9D, {0x77A7}},  // '瞧'
-    {0xFA9E, {0x7235}},  // '爵'
-    {0xFA9F, {0x72AF}},  // '犯'
-    {0xFAA0, {0x732A}},  // '猪'
-    {0xFAA1, {0x7471}},  // '瑱'
-    {0xFAA2, {0x7506}},  // '甆'
-    {0xFAA3, {0x753B}},  // '画'
-    {0xFAA4, {0x761D}},  // '瘝'
-    {0xFAA5, {0x761F}},  // '瘟'
-    {0xFAA6, {0x76CA}},  // '益'
-    {0xFAA7, {0x76DB}},  // '盛'
-    {0xFAA8, {0x76F4}},  // '直'
-    {0xFAA9, {0x774A}},  // '睊'
-    {0xFAAA, {0x7740}},  // '着'
-    {0xFAAB, {0x78CC}},  // '磌'
-    {0xFAAC, {0x7AB1}},  // '窱'
-    {0xFAAD, {0x7BC0}},  // '節'
-    {0xFAAE, {0x7C7B}},  // '类'
-    {0xFAAF, {0x7D5B}},  // '絛'
-    {0xFAB0, {0x7DF4}},  // '練'
-    {0xFAB1, {0x7F3E}},  // '缾'
-    {0xFAB2, {0x8005}},  // '者'
-    {0xFAB3, {0x8352}},  // '荒'
-    {0xFAB4, {0x83EF}},  // '華'
-    {0xFAB5, {0x8779}},  // '蝹'
-    {0xFAB6, {0x8941}},  // '襁'
-    {0xFAB7, {0x8986}},  // '覆'
-    {0xFAB8, {0x8996}},  // '視'
-    {0xFAB9, {0x8ABF}},  // '調'
-    {0xFABA, {0x8AF8}},  // '諸'
-    {0xFABB, {0x8ACB}},  // '請'
-    {0xFABC, {0x8B01}},  // '謁'
-    {0xFABD, {0x8AFE}},  // '諾'
-    {0xFABE, {0x8AED}},  // '諭'
-    {0xFABF, {0x8B39}},  // '謹'
-    {0xFAC0, {0x8B8A}},  // '變'
-    {0xFAC1, {0x8D08}},  // '贈'
-    {0xFAC2, {0x8F38}},  // '輸'
-    {0xFAC3, {0x9072}},  // '遲'
-    {0xFAC4, {0x9199}},  // '醙'
-    {0xFAC5, {0x9276}},  // '鉶'
-    {0xFAC6, {0x967C}},  // '陼'
-    {0xFAC7, {0x96E3}},  // '難'
-    {0xFAC8, {0x9756}},  // '靖'
-    {0xFAC9, {0x97DB}},  // '韛'
-    {0xFACA, {0x97FF}},  // '響'
-    {0xFACB, {0x980B}},  // '頋'
-    {0xFACC, {0x983B}},  // '頻'
-    {0xFACD, {0x9B12}},  // '鬒'
-    {0xFACE, {0x9F9C}},  // '龜'
-    {0xFACF, {0x2284A}},  // '𢡊'
-    {0xFAD0, {0x22844}},  // '𢡄'
-    {0xFAD1, {0x233D5}},  // '𣏕'
-    {0xFAD2, {0x3B9D}},  // '㮝'
-    {0xFAD3, {0x4018}},  // '䀘'
-    {0xFAD4, {0x4039}},  // '䀹'
-    {0xFAD5, {0x25249}},  // '𥉉'
-    {0xFAD6, {0x25CD0}},  // '𥳐'
-    {0xFAD7, {0x27ED3}},  // '𧻓'
-    {0xFAD8, {0x9F43}},  // '齃'
-    {0xFAD9, {0x9F8E}},  // '龎'
-    {0xFB1D, {0x05D9, 0x05B4}},  // 'יִ'
-    {0xFB1F, {0x05F2, 0x05B7}},  // 'ײַ'
-    {0xFB2A, {0x05E9, 0x05C1}},  // 'שׁ'
-    {0xFB2B, {0x05E9, 0x05C2}},  // 'שׂ'
-    {0xFB2C, {0x05E9, 0x05BC, 0x05C1}},  // 'שּׁ'
-    {0xFB2D, {0x05E9, 0x05BC, 0x05C2}},  // 'שּׂ'
-    {0xFB2E, {0x05D0, 0x05B7}},  // 'אַ'
-    {0xFB2F, {0x05D0, 0x05B8}},  // 'אָ'
-    {0xFB30, {0x05D0, 0x05BC}},  // 'אּ'
-    {0xFB31, {0x05D1, 0x05BC}},  // 'בּ'
-    {0xFB32, {0x05D2, 0x05BC}},  // 'גּ'
-    {0xFB33, {0x05D3, 0x05BC}},  // 'דּ'
-    {0xFB34, {0x05D4, 0x05BC}},  // 'הּ'
-    {0xFB35, {0x05D5, 0x05BC}},  // 'וּ'
-    {0xFB36, {0x05D6, 0x05BC}},  // 'זּ'
-    {0xFB38, {0x05D8, 0x05BC}},  // 'טּ'
-    {0xFB39, {0x05D9, 0x05BC}},  // 'יּ'
-    {0xFB3A, {0x05DA, 0x05BC}},  // 'ךּ'
-    {0xFB3B, {0x05DB, 0x05BC}},  // 'כּ'
-    {0xFB3C, {0x05DC, 0x05BC}},  // 'לּ'
-    {0xFB3E, {0x05DE, 0x05BC}},  // 'מּ'
-    {0xFB40, {0x05E0, 0x05BC}},  // 'נּ'
-    {0xFB41, {0x05E1, 0x05BC}},  // 'סּ'
-    {0xFB43, {0x05E3, 0x05BC}},  // 'ףּ'
-    {0xFB44, {0x05E4, 0x05BC}},  // 'פּ'
-    {0xFB46, {0x05E6, 0x05BC}},  // 'צּ'
-    {0xFB47, {0x05E7, 0x05BC}},  // 'קּ'
-    {0xFB48, {0x05E8, 0x05BC}},  // 'רּ'
-    {0xFB49, {0x05E9, 0x05BC}},  // 'שּ'
-    {0xFB4A, {0x05EA, 0x05BC}},  // 'תּ'
-    {0xFB4B, {0x05D5, 0x05B9}},  // 'וֹ'
-    {0xFB4C, {0x05D1, 0x05BF}},  // 'בֿ'
-    {0xFB4D, {0x05DB, 0x05BF}},  // 'כֿ'
-    {0xFB4E, {0x05E4, 0x05BF}},  // 'פֿ'
-    {0x105C9, {0x105D2, 0x0307}},
-    {0x105E4, {0x105DA, 0x0307}},
-    {0x1109A, {0x11099, 0x110BA}},  // '𑂚'
-    {0x1109C, {0x1109B, 0x110BA}},  // '𑂜'
-    {0x110AB, {0x110A5, 0x110BA}},  // '𑂫'
-    {0x1112E, {0x11131, 0x11127}},  // '𑄮'
-    {0x1112F, {0x11132, 0x11127}},  // '𑄯'
-    {0x1134B, {0x11347, 0x1133E}},  // '𑍋'
-    {0x1134C, {0x11347, 0x11357}},  // '𑍌'
-    {0x11383, {0x11382, 0x113C9}},
-    {0x11385, {0x11384, 0x113BB}},
-    {0x1138E, {0x1138B, 0x113C2}},
-    {0x11391, {0x11390, 0x113C9}},
-    {0x113C5, {0x113C2, 0x113C2}},
-    {0x113C7, {0x113C2, 0x113B8}},
-    {0x113C8, {0x113C2, 0x113C9}},
-    {0x114BB, {0x114B9, 0x114BA}},  // '𑒻'
-    {0x114BC, {0x114B9, 0x114B0}},  // '𑒼'
-    {0x114BE, {0x114B9, 0x114BD}},  // '𑒾'
-    {0x115BA, {0x115B8, 0x115AF}},  // '𑖺'
-    {0x115BB, {0x115B9, 0x115AF}},  // '𑖻'
-    {0x11938, {0x11935, 0x11930}},  // '𑤸'
-    {0x16121, {0x1611E, 0x1611E}},
-    {0x16122, {0x1611E, 0x16129}},
-    {0x16123, {0x1611E, 0x1611F}},
-    {0x16124, {0x16129, 0x1611F}},
-    {0x16125, {0x1611E, 0x16120}},
-    {0x16126, {0x1611E, 0x1611E, 0x1611F}},
-    {0x16127, {0x1611E, 0x16129, 0x1611F}},
-    {0x16128, {0x1611E, 0x1611E, 0x16120}},
-    {0x16D68, {0x16D67, 0x16D67}},
-    {0x16D69, {0x16D63, 0x16D67}},
-    {0x16D6A, {0x16D63, 0x16D67, 0x16D67}},
-    {0x1D15E, {0x1D157, 0x1D165}},  // '𝅗𝅥'
-    {0x1D15F, {0x1D158, 0x1D165}},  // '𝅘𝅥'
-    {0x1D160, {0x1D158, 0x1D165, 0x1D16E}},  // '𝅘𝅥𝅮'
-    {0x1D161, {0x1D158, 0x1D165, 0x1D16F}},  // '𝅘𝅥𝅯'
-    {0x1D162, {0x1D158, 0x1D165, 0x1D170}},  // '𝅘𝅥𝅰'
-    {0x1D163, {0x1D158, 0x1D165, 0x1D171}},  // '𝅘𝅥𝅱'
-    {0x1D164, {0x1D158, 0x1D165, 0x1D172}},  // '𝅘𝅥𝅲'
-    {0x1D1BB, {0x1D1B9, 0x1D165}},  // '𝆹𝅥'
-    {0x1D1BC, {0x1D1BA, 0x1D165}},  // '𝆺𝅥'
-    {0x1D1BD, {0x1D1B9, 0x1D165, 0x1D16E}},  // '𝆹𝅥𝅮'
-    {0x1D1BE, {0x1D1BA, 0x1D165, 0x1D16E}},  // '𝆺𝅥𝅮'
-    {0x1D1BF, {0x1D1B9, 0x1D165, 0x1D16F}},  // '𝆹𝅥𝅯'
-    {0x1D1C0, {0x1D1BA, 0x1D165, 0x1D16F}},  // '𝆺𝅥𝅯'
-    {0x2F800, {0x4E3D}},  // '丽'
-    {0x2F801, {0x4E38}},  // '丸'
-    {0x2F802, {0x4E41}},  // '乁'
-    {0x2F803, {0x20122}},  // '𠄢'
-    {0x2F804, {0x4F60}},  // '你'
-    {0x2F805, {0x4FAE}},  // '侮'
-    {0x2F806, {0x4FBB}},  // '侻'
-    {0x2F807, {0x5002}},  // '倂'
-    {0x2F808, {0x507A}},  // '偺'
-    {0x2F809, {0x5099}},  // '備'
-    {0x2F80A, {0x50E7}},  // '僧'
-    {0x2F80B, {0x50CF}},  // '像'
-    {0x2F80C, {0x349E}},  // '㒞'
-    {0x2F80D, {0x2063A}},  // '𠘺'
-    {0x2F80E, {0x514D}},  // '免'
-    {0x2F80F, {0x5154}},  // '兔'
-    {0x2F810, {0x5164}},  // '兤'
-    {0x2F811, {0x5177}},  // '具'
-    {0x2F812, {0x2051C}},  // '𠔜'
-    {0x2F813, {0x34B9}},  // '㒹'
-    {0x2F814, {0x5167}},  // '內'
-    {0x2F815, {0x518D}},  // '再'
-    {0x2F816, {0x2054B}},  // '𠕋'
-    {0x2F817, {0x5197}},  // '冗'
-    {0x2F818, {0x51A4}},  // '冤'
-    {0x2F819, {0x4ECC}},  // '仌'
-    {0x2F81A, {0x51AC}},  // '冬'
-    {0x2F81B, {0x51B5}},  // '况'
-    {0x2F81C, {0x291DF}},  // '𩇟'
-    {0x2F81D, {0x51F5}},  // '凵'
-    {0x2F81E, {0x5203}},  // '刃'
-    {0x2F81F, {0x34DF}},  // '㓟'
-    {0x2F820, {0x523B}},  // '刻'
-    {0x2F821, {0x5246}},  // '剆'
-    {0x2F822, {0x5272}},  // '割'
-    {0x2F823, {0x5277}},  // '剷'
-    {0x2F824, {0x3515}},  // '㔕'
-    {0x2F825, {0x52C7}},  // '勇'
-    {0x2F826, {0x52C9}},  // '勉'
-    {0x2F827, {0x52E4}},  // '勤'
-    {0x2F828, {0x52FA}},  // '勺'
-    {0x2F829, {0x5305}},  // '包'
-    {0x2F82A, {0x5306}},  // '匆'
-    {0x2F82B, {0x5317}},  // '北'
-    {0x2F82C, {0x5349}},  // '卉'
-    {0x2F82D, {0x5351}},  // '卑'
-    {0x2F82E, {0x535A}},  // '博'
-    {0x2F82F, {0x5373}},  // '即'
-    {0x2F830, {0x537D}},  // '卽'
-    {0x2F831, {0x537F}},  // '卿'
-    {0x2F832, {0x537F}},  // '卿'
-    {0x2F833, {0x537F}},  // '卿'
-    {0x2F834, {0x20A2C}},  // '𠨬'
-    {0x2F835, {0x7070}},  // '灰'
-    {0x2F836, {0x53CA}},  // '及'
-    {0x2F837, {0x53DF}},  // '叟'
-    {0x2F838, {0x20B63}},  // '𠭣'
-    {0x2F839, {0x53EB}},  // '叫'
-    {0x2F83A, {0x53F1}},  // '叱'
-    {0x2F83B, {0x5406}},  // '吆'
-    {0x2F83C, {0x549E}},  // '咞'
-    {0x2F83D, {0x5438}},  // '吸'
-    {0x2F83E, {0x5448}},  // '呈'
-    {0x2F83F, {0x5468}},  // '周'
-    {0x2F840, {0x54A2}},  // '咢'
-    {0x2F841, {0x54F6}},  // '哶'
-    {0x2F842, {0x5510}},  // '唐'
-    {0x2F843, {0x5553}},  // '啓'
-    {0x2F844, {0x5563}},  // '啣'
-    {0x2F845, {0x5584}},  // '善'
-    {0x2F846, {0x5584}},  // '善'
-    {0x2F847, {0x5599}},  // '喙'
-    {0x2F848, {0x55AB}},  // '喫'
-    {0x2F849, {0x55B3}},  // '喳'
-    {0x2F84A, {0x55C2}},  // '嗂'
-    {0x2F84B, {0x5716}},  // '圖'
-    {0x2F84C, {0x5606}},  // '嘆'
-    {0x2F84D, {0x5717}},  // '圗'
-    {0x2F84E, {0x5651}},  // '噑'
-    {0x2F84F, {0x5674}},  // '噴'
-    {0x2F850, {0x5207}},  // '切'
-    {0x2F851, {0x58EE}},  // '壮'
-    {0x2F852, {0x57CE}},  // '城'
-    {0x2F853, {0x57F4}},  // '埴'
-    {0x2F854, {0x580D}},  // '堍'
-    {0x2F855, {0x578B}},  // '型'
-    {0x2F856, {0x5832}},  // '堲'
-    {0x2F857, {0x5831}},  // '報'
-    {0x2F858, {0x58AC}},  // '墬'
-    {0x2F859, {0x214E4}},  // '𡓤'
-    {0x2F85A, {0x58F2}},  // '売'
-    {0x2F85B, {0x58F7}},  // '壷'
-    {0x2F85C, {0x5906}},  // '夆'
-    {0x2F85D, {0x591A}},  // '多'
-    {0x2F85E, {0x5922}},  // '夢'
-    {0x2F85F, {0x5962}},  // '奢'
-    {0x2F860, {0x216A8}},  // '𡚨'
-    {0x2F861, {0x216EA}},  // '𡛪'
-    {0x2F862, {0x59EC}},  // '姬'
-    {0x2F863, {0x5A1B}},  // '娛'
-    {0x2F864, {0x5A27}},  // '娧'
-    {0x2F865, {0x59D8}},  // '姘'
-    {0x2F866, {0x5A66}},  // '婦'
-    {0x2F867, {0x36EE}},  // '㛮'
-    {0x2F868, {0x36FC}},  // '㛼'
-    {0x2F869, {0x5B08}},  // '嬈'
-    {0x2F86A, {0x5B3E}},  // '嬾'
-    {0x2F86B, {0x5B3E}},  // '嬾'
-    {0x2F86C, {0x219C8}},  // '𡧈'
-    {0x2F86D, {0x5BC3}},  // '寃'
-    {0x2F86E, {0x5BD8}},  // '寘'
-    {0x2F86F, {0x5BE7}},  // '寧'
-    {0x2F870, {0x5BF3}},  // '寳'
-    {0x2F871, {0x21B18}},  // '𡬘'
-    {0x2F872, {0x5BFF}},  // '寿'
-    {0x2F873, {0x5C06}},  // '将'
-    {0x2F874, {0x5F53}},  // '当'
-    {0x2F875, {0x5C22}},  // '尢'
-    {0x2F876, {0x3781}},  // '㞁'
-    {0x2F877, {0x5C60}},  // '屠'
-    {0x2F878, {0x5C6E}},  // '屮'
-    {0x2F879, {0x5CC0}},  // '峀'
-    {0x2F87A, {0x5C8D}},  // '岍'
-    {0x2F87B, {0x21DE4}},  // '𡷤'
-    {0x2F87C, {0x5D43}},  // '嵃'
-    {0x2F87D, {0x21DE6}},  // '𡷦'
-    {0x2F87E, {0x5D6E}},  // '嵮'
-    {0x2F87F, {0x5D6B}},  // '嵫'
-    {0x2F880, {0x5D7C}},  // '嵼'
-    {0x2F881, {0x5DE1}},  // '巡'
-    {0x2F882, {0x5DE2}},  // '巢'
-    {0x2F883, {0x382F}},  // '㠯'
-    {0x2F884, {0x5DFD}},  // '巽'
-    {0x2F885, {0x5E28}},  // '帨'
-    {0x2F886, {0x5E3D}},  // '帽'
-    {0x2F887, {0x5E69}},  // '幩'
-    {0x2F888, {0x3862}},  // '㡢'
-    {0x2F889, {0x22183}},  // '𢆃'
-    {0x2F88A, {0x387C}},  // '㡼'
-    {0x2F88B, {0x5EB0}},  // '庰'
-    {0x2F88C, {0x5EB3}},  // '庳'
-    {0x2F88D, {0x5EB6}},  // '庶'
-    {0x2F88E, {0x5ECA}},  // '廊'
-    {0x2F88F, {0x2A392}},  // '𪎒'
-    {0x2F890, {0x5EFE}},  // '廾'
-    {0x2F891, {0x22331}},  // '𢌱'
-    {0x2F892, {0x22331}},  // '𢌱'
-    {0x2F893, {0x8201}},  // '舁'
-    {0x2F894, {0x5F22}},  // '弢'
-    {0x2F895, {0x5F22}},  // '弢'
-    {0x2F896, {0x38C7}},  // '㣇'
-    {0x2F897, {0x232B8}},  // '𣊸'
-    {0x2F898, {0x261DA}},  // '𦇚'
-    {0x2F899, {0x5F62}},  // '形'
-    {0x2F89A, {0x5F6B}},  // '彫'
-    {0x2F89B, {0x38E3}},  // '㣣'
-    {0x2F89C, {0x5F9A}},  // '徚'
-    {0x2F89D, {0x5FCD}},  // '忍'
-    {0x2F89E, {0x5FD7}},  // '志'
-    {0x2F89F, {0x5FF9}},  // '忹'
-    {0x2F8A0, {0x6081}},  // '悁'
-    {0x2F8A1, {0x393A}},  // '㤺'
-    {0x2F8A2, {0x391C}},  // '㤜'
-    {0x2F8A3, {0x6094}},  // '悔'
-    {0x2F8A4, {0x226D4}},  // '𢛔'
-    {0x2F8A5, {0x60C7}},  // '惇'
-    {0x2F8A6, {0x6148}},  // '慈'
-    {0x2F8A7, {0x614C}},  // '慌'
-    {0x2F8A8, {0x614E}},  // '慎'
-    {0x2F8A9, {0x614C}},  // '慌'
-    {0x2F8AA, {0x617A}},  // '慺'
-    {0x2F8AB, {0x618E}},  // '憎'
-    {0x2F8AC, {0x61B2}},  // '憲'
-    {0x2F8AD, {0x61A4}},  // '憤'
-    {0x2F8AE, {0x61AF}},  // '憯'
-    {0x2F8AF, {0x61DE}},  // '懞'
-    {0x2F8B0, {0x61F2}},  // '懲'
-    {0x2F8B1, {0x61F6}},  // '懶'
-    {0x2F8B2, {0x6210}},  // '成'
-    {0x2F8B3, {0x621B}},  // '戛'
-    {0x2F8B4, {0x625D}},  // '扝'
-    {0x2F8B5, {0x62B1}},  // '抱'
-    {0x2F8B6, {0x62D4}},  // '拔'
-    {0x2F8B7, {0x6350}},  // '捐'
-    {0x2F8B8, {0x22B0C}},  // '𢬌'
-    {0x2F8B9, {0x633D}},  // '挽'
-    {0x2F8BA, {0x62FC}},  // '拼'
-    {0x2F8BB, {0x6368}},  // '捨'
-    {0x2F8BC, {0x6383}},  // '掃'
-    {0x2F8BD, {0x63E4}},  // '揤'
-    {0x2F8BE, {0x22BF1}},  // '𢯱'
-    {0x2F8BF, {0x6422}},  // '搢'
-    {0x2F8C0, {0x63C5}},  // '揅'
-    {0x2F8C1, {0x63A9}},  // '掩'
-    {0x2F8C2, {0x3A2E}},  // '㨮'
-    {0x2F8C3, {0x6469}},  // '摩'
-    {0x2F8C4, {0x647E}},  // '摾'
-    {0x2F8C5, {0x649D}},  // '撝'
-    {0x2F8C6, {0x6477}},  // '摷'
-    {0x2F8C7, {0x3A6C}},  // '㩬'
-    {0x2F8C8, {0x654F}},  // '敏'
-    {0x2F8C9, {0x656C}},  // '敬'
-    {0x2F8CA, {0x2300A}},  // '𣀊'
-    {0x2F8CB, {0x65E3}},  // '旣'
-    {0x2F8CC, {0x66F8}},  // '書'
-    {0x2F8CD, {0x6649}},  // '晉'
-    {0x2F8CE, {0x3B19}},  // '㬙'
-    {0x2F8CF, {0x6691}},  // '暑'
-    {0x2F8D0, {0x3B08}},  // '㬈'
-    {0x2F8D1, {0x3AE4}},  // '㫤'
-    {0x2F8D2, {0x5192}},  // '冒'
-    {0x2F8D3, {0x5195}},  // '冕'
-    {0x2F8D4, {0x6700}},  // '最'
-    {0x2F8D5, {0x669C}},  // '暜'
-    {0x2F8D6, {0x80AD}},  // '肭'
-    {0x2F8D7, {0x43D9}},  // '䏙'
-    {0x2F8D8, {0x6717}},  // '朗'
-    {0x2F8D9, {0x671B}},  // '望'
-    {0x2F8DA, {0x6721}},  // '朡'
-    {0x2F8DB, {0x675E}},  // '杞'
-    {0x2F8DC, {0x6753}},  // '杓'
-    {0x2F8DD, {0x233C3}},  // '𣏃'
-    {0x2F8DE, {0x3B49}},  // '㭉'
-    {0x2F8DF, {0x67FA}},  // '柺'
-    {0x2F8E0, {0x6785}},  // '枅'
-    {0x2F8E1, {0x6852}},  // '桒'
-    {0x2F8E2, {0x6885}},  // '梅'
-    {0x2F8E3, {0x2346D}},  // '𣑭'
-    {0x2F8E4, {0x688E}},  // '梎'
-    {0x2F8E5, {0x681F}},  // '栟'
-    {0x2F8E6, {0x6914}},  // '椔'
-    {0x2F8E7, {0x3B9D}},  // '㮝'
-    {0x2F8E8, {0x6942}},  // '楂'
-    {0x2F8E9, {0x69A3}},  // '榣'
-    {0x2F8EA, {0x69EA}},  // '槪'
-    {0x2F8EB, {0x6AA8}},  // '檨'
-    {0x2F8EC, {0x236A3}},  // '𣚣'
-    {0x2F8ED, {0x6ADB}},  // '櫛'
-    {0x2F8EE, {0x3C18}},  // '㰘'
-    {0x2F8EF, {0x6B21}},  // '次'
-    {0x2F8F0, {0x238A7}},  // '𣢧'
-    {0x2F8F1, {0x6B54}},  // '歔'
-    {0x2F8F2, {0x3C4E}},  // '㱎'
-    {0x2F8F3, {0x6B72}},  // '歲'
-    {0x2F8F4, {0x6B9F}},  // '殟'
-    {0x2F8F5, {0x6BBA}},  // '殺'
-    {0x2F8F6, {0x6BBB}},  // '殻'
-    {0x2F8F7, {0x23A8D}},  // '𣪍'
-    {0x2F8F8, {0x21D0B}},  // '𡴋'
-    {0x2F8F9, {0x23AFA}},  // '𣫺'
-    {0x2F8FA, {0x6C4E}},  // '汎'
-    {0x2F8FB, {0x23CBC}},  // '𣲼'
-    {0x2F8FC, {0x6CBF}},  // '沿'
-    {0x2F8FD, {0x6CCD}},  // '泍'
-    {0x2F8FE, {0x6C67}},  // '汧'
-    {0x2F8FF, {0x6D16}},  // '洖'
-    {0x2F900, {0x6D3E}},  // '派'
-    {0x2F901, {0x6D77}},  // '海'
-    {0x2F902, {0x6D41}},  // '流'
-    {0x2F903, {0x6D69}},  // '浩'
-    {0x2F904, {0x6D78}},  // '浸'
-    {0x2F905, {0x6D85}},  // '涅'
-    {0x2F906, {0x23D1E}},  // '𣴞'
-    {0x2F907, {0x6D34}},  // '洴'
-    {0x2F908, {0x6E2F}},  // '港'
-    {0x2F909, {0x6E6E}},  // '湮'
-    {0x2F90A, {0x3D33}},  // '㴳'
-    {0x2F90B, {0x6ECB}},  // '滋'
-    {0x2F90C, {0x6EC7}},  // '滇'
-    {0x2F90D, {0x23ED1}},  // '𣻑'
-    {0x2F90E, {0x6DF9}},  // '淹'
-    {0x2F90F, {0x6F6E}},  // '潮'
-    {0x2F910, {0x23F5E}},  // '𣽞'
-    {0x2F911, {0x23F8E}},  // '𣾎'
-    {0x2F912, {0x6FC6}},  // '濆'
-    {0x2F913, {0x7039}},  // '瀹'
-    {0x2F914, {0x701E}},  // '瀞'
-    {0x2F915, {0x701B}},  // '瀛'
-    {0x2F916, {0x3D96}},  // '㶖'
-    {0x2F917, {0x704A}},  // '灊'
-    {0x2F918, {0x707D}},  // '災'
-    {0x2F919, {0x7077}},  // '灷'
-    {0x2F91A, {0x70AD}},  // '炭'
-    {0x2F91B, {0x20525}},  // '𠔥'
-    {0x2F91C, {0x7145}},  // '煅'
-    {0x2F91D, {0x24263}},  // '𤉣'
-    {0x2F91E, {0x719C}},  // '熜'
-    {0x2F91F, {0x243AB}},  // '𤎫'
-    {0x2F920, {0x7228}},  // '爨'
-    {0x2F921, {0x7235}},  // '爵'
-    {0x2F922, {0x7250}},  // '牐'
-    {0x2F923, {0x24608}},  // '𤘈'
-    {0x2F924, {0x7280}},  // '犀'
-    {0x2F925, {0x7295}},  // '犕'
-    {0x2F926, {0x24735}},  // '𤜵'
-    {0x2F927, {0x24814}},  // '𤠔'
-    {0x2F928, {0x737A}},  // '獺'
-    {0x2F929, {0x738B}},  // '王'
-    {0x2F92A, {0x3EAC}},  // '㺬'
-    {0x2F92B, {0x73A5}},  // '玥'
-    {0x2F92C, {0x3EB8}},  // '㺸'
-    {0x2F92D, {0x3EB8}},  // '㺸'
-    {0x2F92E, {0x7447}},  // '瑇'
-    {0x2F92F, {0x745C}},  // '瑜'
-    {0x2F930, {0x7471}},  // '瑱'
-    {0x2F931, {0x7485}},  // '璅'
-    {0x2F932, {0x74CA}},  // '瓊'
-    {0x2F933, {0x3F1B}},  // '㼛'
-    {0x2F934, {0x7524}},  // '甤'
-    {0x2F935, {0x24C36}},  // '𤰶'
-    {0x2F936, {0x753E}},  // '甾'
-    {0x2F937, {0x24C92}},  // '𤲒'
-    {0x2F938, {0x7570}},  // '異'
-    {0x2F939, {0x2219F}},  // '𢆟'
-    {0x2F93A, {0x7610}},  // '瘐'
-    {0x2F93B, {0x24FA1}},  // '𤾡'
-    {0x2F93C, {0x24FB8}},  // '𤾸'
-    {0x2F93D, {0x25044}},  // '𥁄'
-    {0x2F93E, {0x3FFC}},  // '㿼'
-    {0x2F93F, {0x4008}},  // '䀈'
-    {0x2F940, {0x76F4}},  // '直'
-    {0x2F941, {0x250F3}},  // '𥃳'
-    {0x2F942, {0x250F2}},  // '𥃲'
-    {0x2F943, {0x25119}},  // '𥄙'
-    {0x2F944, {0x25133}},  // '𥄳'
-    {0x2F945, {0x771E}},  // '眞'
-    {0x2F946, {0x771F}},  // '真'
-    {0x2F947, {0x771F}},  // '真'
-    {0x2F948, {0x774A}},  // '睊'
-    {0x2F949, {0x4039}},  // '䀹'
-    {0x2F94A, {0x778B}},  // '瞋'
-    {0x2F94B, {0x4046}},  // '䁆'
-    {0x2F94C, {0x4096}},  // '䂖'
-    {0x2F94D, {0x2541D}},  // '𥐝'
-    {0x2F94E, {0x784E}},  // '硎'
-    {0x2F94F, {0x788C}},  // '碌'
-    {0x2F950, {0x78CC}},  // '磌'
-    {0x2F951, {0x40E3}},  // '䃣'
-    {0x2F952, {0x25626}},  // '𥘦'
-    {0x2F953, {0x7956}},  // '祖'
-    {0x2F954, {0x2569A}},  // '𥚚'
-    {0x2F955, {0x256C5}},  // '𥛅'
-    {0x2F956, {0x798F}},  // '福'
-    {0x2F957, {0x79EB}},  // '秫'
-    {0x2F958, {0x412F}},  // '䄯'
-    {0x2F959, {0x7A40}},  // '穀'
-    {0x2F95A, {0x7A4A}},  // '穊'
-    {0x2F95B, {0x7A4F}},  // '穏'
-    {0x2F95C, {0x2597C}},  // '𥥼'
-    {0x2F95D, {0x25AA7}},  // '𥪧'
-    {0x2F95E, {0x25AA7}},  // '𥪧'
-    {0x2F95F, {0x7AEE}},  // '竮'
-    {0x2F960, {0x4202}},  // '䈂'
-    {0x2F961, {0x25BAB}},  // '𥮫'
-    {0x2F962, {0x7BC6}},  // '篆'
-    {0x2F963, {0x7BC9}},  // '築'
-    {0x2F964, {0x4227}},  // '䈧'
-    {0x2F965, {0x25C80}},  // '𥲀'
-    {0x2F966, {0x7CD2}},  // '糒'
-    {0x2F967, {0x42A0}},  // '䊠'
-    {0x2F968, {0x7CE8}},  // '糨'
-    {0x2F969, {0x7CE3}},  // '糣'
-    {0x2F96A, {0x7D00}},  // '紀'
-    {0x2F96B, {0x25F86}},  // '𥾆'
-    {0x2F96C, {0x7D63}},  // '絣'
-    {0x2F96D, {0x4301}},  // '䌁'
-    {0x2F96E, {0x7DC7}},  // '緇'
-    {0x2F96F, {0x7E02}},  // '縂'
-    {0x2F970, {0x7E45}},  // '繅'
-    {0x2F971, {0x4334}},  // '䌴'
-    {0x2F972, {0x26228}},  // '𦈨'
-    {0x2F973, {0x26247}},  // '𦉇'
-    {0x2F974, {0x4359}},  // '䍙'
-    {0x2F975, {0x262D9}},  // '𦋙'
-    {0x2F976, {0x7F7A}},  // '罺'
-    {0x2F977, {0x2633E}},  // '𦌾'
-    {0x2F978, {0x7F95}},  // '羕'
-    {0x2F979, {0x7FFA}},  // '翺'
-    {0x2F97A, {0x8005}},  // '者'
-    {0x2F97B, {0x264DA}},  // '𦓚'
-    {0x2F97C, {0x26523}},  // '𦔣'
-    {0x2F97D, {0x8060}},  // '聠'
-    {0x2F97E, {0x265A8}},  // '𦖨'
-    {0x2F97F, {0x8070}},  // '聰'
-    {0x2F980, {0x2335F}},  // '𣍟'
-    {0x2F981, {0x43D5}},  // '䏕'
-    {0x2F982, {0x80B2}},  // '育'
-    {0x2F983, {0x8103}},  // '脃'
-    {0x2F984, {0x440B}},  // '䐋'
-    {0x2F985, {0x813E}},  // '脾'
-    {0x2F986, {0x5AB5}},  // '媵'
-    {0x2F987, {0x267A7}},  // '𦞧'
-    {0x2F988, {0x267B5}},  // '𦞵'
-    {0x2F989, {0x23393}},  // '𣎓'
-    {0x2F98A, {0x2339C}},  // '𣎜'
-    {0x2F98B, {0x8201}},  // '舁'
-    {0x2F98C, {0x8204}},  // '舄'
-    {0x2F98D, {0x8F9E}},  // '辞'
-    {0x2F98E, {0x446B}},  // '䑫'
-    {0x2F98F, {0x8291}},  // '芑'
-    {0x2F990, {0x828B}},  // '芋'
-    {0x2F991, {0x829D}},  // '芝'
-    {0x2F992, {0x52B3}},  // '劳'
-    {0x2F993, {0x82B1}},  // '花'
-    {0x2F994, {0x82B3}},  // '芳'
-    {0x2F995, {0x82BD}},  // '芽'
-    {0x2F996, {0x82E6}},  // '苦'
-    {0x2F997, {0x26B3C}},  // '𦬼'
-    {0x2F998, {0x82E5}},  // '若'
-    {0x2F999, {0x831D}},  // '茝'
-    {0x2F99A, {0x8363}},  // '荣'
-    {0x2F99B, {0x83AD}},  // '莭'
-    {0x2F99C, {0x8323}},  // '茣'
-    {0x2F99D, {0x83BD}},  // '莽'
-    {0x2F99E, {0x83E7}},  // '菧'
-    {0x2F99F, {0x8457}},  // '著'
-    {0x2F9A0, {0x8353}},  // '荓'
-    {0x2F9A1, {0x83CA}},  // '菊'
-    {0x2F9A2, {0x83CC}},  // '菌'
-    {0x2F9A3, {0x83DC}},  // '菜'
-    {0x2F9A4, {0x26C36}},  // '𦰶'
-    {0x2F9A5, {0x26D6B}},  // '𦵫'
-    {0x2F9A6, {0x26CD5}},  // '𦳕'
-    {0x2F9A7, {0x452B}},  // '䔫'
-    {0x2F9A8, {0x84F1}},  // '蓱'
-    {0x2F9A9, {0x84F3}},  // '蓳'
-    {0x2F9AA, {0x8516}},  // '蔖'
-    {0x2F9AB, {0x273CA}},  // '𧏊'
-    {0x2F9AC, {0x8564}},  // '蕤'
-    {0x2F9AD, {0x26F2C}},  // '𦼬'
-    {0x2F9AE, {0x455D}},  // '䕝'
-    {0x2F9AF, {0x4561}},  // '䕡'
-    {0x2F9B0, {0x26FB1}},  // '𦾱'
-    {0x2F9B1, {0x270D2}},  // '𧃒'
-    {0x2F9B2, {0x456B}},  // '䕫'
-    {0x2F9B3, {0x8650}},  // '虐'
-    {0x2F9B4, {0x865C}},  // '虜'
-    {0x2F9B5, {0x8667}},  // '虧'
-    {0x2F9B6, {0x8669}},  // '虩'
-    {0x2F9B7, {0x86A9}},  // '蚩'
-    {0x2F9B8, {0x8688}},  // '蚈'
-    {0x2F9B9, {0x870E}},  // '蜎'
-    {0x2F9BA, {0x86E2}},  // '蛢'
-    {0x2F9BB, {0x8779}},  // '蝹'
-    {0x2F9BC, {0x8728}},  // '蜨'
-    {0x2F9BD, {0x876B}},  // '蝫'
-    {0x2F9BE, {0x8786}},  // '螆'
-    {0x2F9BF, {0x45D7}},  // '䗗'
-    {0x2F9C0, {0x87E1}},  // '蟡'
-    {0x2F9C1, {0x8801}},  // '蠁'
-    {0x2F9C2, {0x45F9}},  // '䗹'
-    {0x2F9C3, {0x8860}},  // '衠'
-    {0x2F9C4, {0x8863}},  // '衣'
-    {0x2F9C5, {0x27667}},  // '𧙧'
-    {0x2F9C6, {0x88D7}},  // '裗'
-    {0x2F9C7, {0x88DE}},  // '裞'
-    {0x2F9C8, {0x4635}},  // '䘵'
-    {0x2F9C9, {0x88FA}},  // '裺'
-    {0x2F9CA, {0x34BB}},  // '㒻'
-    {0x2F9CB, {0x278AE}},  // '𧢮'
-    {0x2F9CC, {0x27966}},  // '𧥦'
-    {0x2F9CD, {0x46BE}},  // '䚾'
-    {0x2F9CE, {0x46C7}},  // '䛇'
-    {0x2F9CF, {0x8AA0}},  // '誠'
-    {0x2F9D0, {0x8AED}},  // '諭'
-    {0x2F9D1, {0x8B8A}},  // '變'
-    {0x2F9D2, {0x8C55}},  // '豕'
-    {0x2F9D3, {0x27CA8}},  // '𧲨'
-    {0x2F9D4, {0x8CAB}},  // '貫'
-    {0x2F9D5, {0x8CC1}},  // '賁'
-    {0x2F9D6, {0x8D1B}},  // '贛'
-    {0x2F9D7, {0x8D77}},  // '起'
-    {0x2F9D8, {0x27F2F}},  // '𧼯'
-    {0x2F9D9, {0x20804}},  // '𠠄'
-    {0x2F9DA, {0x8DCB}},  // '跋'
-    {0x2F9DB, {0x8DBC}},  // '趼'
-    {0x2F9DC, {0x8DF0}},  // '跰'
-    {0x2F9DD, {0x208DE}},  // '𠣞'
-    {0x2F9DE, {0x8ED4}},  // '軔'
-    {0x2F9DF, {0x8F38}},  // '輸'
-    {0x2F9E0, {0x285D2}},  // '𨗒'
-    {0x2F9E1, {0x285ED}},  // '𨗭'
-    {0x2F9E2, {0x9094}},  // '邔'
-    {0x2F9E3, {0x90F1}},  // '郱'
-    {0x2F9E4, {0x9111}},  // '鄑'
-    {0x2F9E5, {0x2872E}},  // '𨜮'
-    {0x2F9E6, {0x911B}},  // '鄛'
-    {0x2F9E7, {0x9238}},  // '鈸'
-    {0x2F9E8, {0x92D7}},  // '鋗'
-    {0x2F9E9, {0x92D8}},  // '鋘'
-    {0x2F9EA, {0x927C}},  // '鉼'
-    {0x2F9EB, {0x93F9}},  // '鏹'
-    {0x2F9EC, {0x9415}},  // '鐕'
-    {0x2F9ED, {0x28BFA}},  // '𨯺'
-    {0x2F9EE, {0x958B}},  // '開'
-    {0x2F9EF, {0x4995}},  // '䦕'
-    {0x2F9F0, {0x95B7}},  // '閷'
-    {0x2F9F1, {0x28D77}},  // '𨵷'
-    {0x2F9F2, {0x49E6}},  // '䧦'
-    {0x2F9F3, {0x96C3}},  // '雃'
-    {0x2F9F4, {0x5DB2}},  // '嶲'
-    {0x2F9F5, {0x9723}},  // '霣'
-    {0x2F9F6, {0x29145}},  // '𩅅'
-    {0x2F9F7, {0x2921A}},  // '𩈚'
-    {0x2F9F8, {0x4A6E}},  // '䩮'
-    {0x2F9F9, {0x4A76}},  // '䩶'
-    {0x2F9FA, {0x97E0}},  // '韠'
-    {0x2F9FB, {0x2940A}},  // '𩐊'
-    {0x2F9FC, {0x4AB2}},  // '䪲'
-    {0x2F9FD, {0x29496}},  // '𩒖'
-    {0x2F9FE, {0x980B}},  // '頋'
-    {0x2F9FF, {0x980B}},  // '頋'
-    {0x2FA00, {0x9829}},  // '頩'
-    {0x2FA01, {0x295B6}},  // '𩖶'
-    {0x2FA02, {0x98E2}},  // '飢'
-    {0x2FA03, {0x4B33}},  // '䬳'
-    {0x2FA04, {0x9929}},  // '餩'
-    {0x2FA05, {0x99A7}},  // '馧'
-    {0x2FA06, {0x99C2}},  // '駂'
-    {0x2FA07, {0x99FE}},  // '駾'
-    {0x2FA08, {0x4BCE}},  // '䯎'
-    {0x2FA09, {0x29B30}},  // '𩬰'
-    {0x2FA0A, {0x9B12}},  // '鬒'
-    {0x2FA0B, {0x9C40}},  // '鱀'
-    {0x2FA0C, {0x9CFD}},  // '鳽'
-    {0x2FA0D, {0x4CCE}},  // '䳎'
-    {0x2FA0E, {0x4CED}},  // '䳭'
-    {0x2FA0F, {0x9D67}},  // '鵧'
-    {0x2FA10, {0x2A0CE}},  // '𪃎'
-    {0x2FA11, {0x4CF8}},  // '䳸'
-    {0x2FA12, {0x2A105}},  // '𪄅'
-    {0x2FA13, {0x2A20E}},  // '𪈎'
-    {0x2FA14, {0x2A291}},  // '𪊑'
-    {0x2FA15, {0x9EBB}},  // '麻'
-    {0x2FA16, {0x4D56}},  // '䵖'
-    {0x2FA17, {0x9EF9}},  // '黹'
-    {0x2FA18, {0x9EFE}},  // '黾'
-    {0x2FA19, {0x9F05}},  // '鼅'
-    {0x2FA1A, {0x9F0F}},  // '鼏'
-    {0x2FA1B, {0x9F16}},  // '鼖'
-    {0x2FA1C, {0x9F3B}},  // '鼻'
-    {0x2FA1D, {0x2A600}},  // '𪘀'
-};
-
-// Hash function for pair<uint32_t, uint32_t>
-struct pair_hash {
-    std::size_t operator()(const std::pair<uint32_t, uint32_t>& p) const {
-        return std::hash<uint64_t>()((uint64_t(p.first) << 32) | p.second);
-    }
-};
-
-// Canonical composition table: (base, combining_mark) -> composed
-// Reverse mapping of decomposition for NFC normalization
-static const std::unordered_map<std::pair<uint32_t, uint32_t>, uint32_t, pair_hash> nfc_composition_table = {
-    {{0x003C, 0x0338}, 0x226E},  // '<' + combining -> '≮'
-    {{0x003D, 0x0338}, 0x2260},  // '=' + combining -> '≠'
-    {{0x003E, 0x0338}, 0x226F},  // '>' + combining -> '≯'
-    {{0x0041, 0x0300}, 0x00C0},  // 'A' + combining -> 'À'
-    {{0x0041, 0x0301}, 0x00C1},  // 'A' + combining -> 'Á'
-    {{0x0041, 0x0302}, 0x00C2},  // 'A' + combining -> 'Â'
-    {{0x0041, 0x0303}, 0x00C3},  // 'A' + combining -> 'Ã'
-    {{0x0041, 0x0304}, 0x0100},  // 'A' + combining -> 'Ā'
-    {{0x0041, 0x0306}, 0x0102},  // 'A' + combining -> 'Ă'
-    {{0x0041, 0x0307}, 0x0226},  // 'A' + combining -> 'Ȧ'
-    {{0x0041, 0x0308}, 0x00C4},  // 'A' + combining -> 'Ä'
-    {{0x0041, 0x0309}, 0x1EA2},  // 'A' + combining -> 'Ả'
-    {{0x0041, 0x030A}, 0x00C5},  // 'A' + combining -> 'Å'
-    {{0x0041, 0x030C}, 0x01CD},  // 'A' + combining -> 'Ǎ'
-    {{0x0041, 0x030F}, 0x0200},  // 'A' + combining -> 'Ȁ'
-    {{0x0041, 0x0311}, 0x0202},  // 'A' + combining -> 'Ȃ'
-    {{0x0041, 0x0323}, 0x1EA0},  // 'A' + combining -> 'Ạ'
-    {{0x0041, 0x0325}, 0x1E00},  // 'A' + combining -> 'Ḁ'
-    {{0x0041, 0x0328}, 0x0104},  // 'A' + combining -> 'Ą'
-    {{0x0042, 0x0307}, 0x1E02},  // 'B' + combining -> 'Ḃ'
-    {{0x0042, 0x0323}, 0x1E04},  // 'B' + combining -> 'Ḅ'
-    {{0x0042, 0x0331}, 0x1E06},  // 'B' + combining -> 'Ḇ'
-    {{0x0043, 0x0301}, 0x0106},  // 'C' + combining -> 'Ć'
-    {{0x0043, 0x0302}, 0x0108},  // 'C' + combining -> 'Ĉ'
-    {{0x0043, 0x0307}, 0x010A},  // 'C' + combining -> 'Ċ'
-    {{0x0043, 0x030C}, 0x010C},  // 'C' + combining -> 'Č'
-    {{0x0043, 0x0327}, 0x00C7},  // 'C' + combining -> 'Ç'
-    {{0x0044, 0x0307}, 0x1E0A},  // 'D' + combining -> 'Ḋ'
-    {{0x0044, 0x030C}, 0x010E},  // 'D' + combining -> 'Ď'
-    {{0x0044, 0x0323}, 0x1E0C},  // 'D' + combining -> 'Ḍ'
-    {{0x0044, 0x0327}, 0x1E10},  // 'D' + combining -> 'Ḑ'
-    {{0x0044, 0x032D}, 0x1E12},  // 'D' + combining -> 'Ḓ'
-    {{0x0044, 0x0331}, 0x1E0E},  // 'D' + combining -> 'Ḏ'
-    {{0x0045, 0x0300}, 0x00C8},  // 'E' + combining -> 'È'
-    {{0x0045, 0x0301}, 0x00C9},  // 'E' + combining -> 'É'
-    {{0x0045, 0x0302}, 0x00CA},  // 'E' + combining -> 'Ê'
-    {{0x0045, 0x0303}, 0x1EBC},  // 'E' + combining -> 'Ẽ'
-    {{0x0045, 0x0304}, 0x0112},  // 'E' + combining -> 'Ē'
-    {{0x0045, 0x0306}, 0x0114},  // 'E' + combining -> 'Ĕ'
-    {{0x0045, 0x0307}, 0x0116},  // 'E' + combining -> 'Ė'
-    {{0x0045, 0x0308}, 0x00CB},  // 'E' + combining -> 'Ë'
-    {{0x0045, 0x0309}, 0x1EBA},  // 'E' + combining -> 'Ẻ'
-    {{0x0045, 0x030C}, 0x011A},  // 'E' + combining -> 'Ě'
-    {{0x0045, 0x030F}, 0x0204},  // 'E' + combining -> 'Ȅ'
-    {{0x0045, 0x0311}, 0x0206},  // 'E' + combining -> 'Ȇ'
-    {{0x0045, 0x0323}, 0x1EB8},  // 'E' + combining -> 'Ẹ'
-    {{0x0045, 0x0327}, 0x0228},  // 'E' + combining -> 'Ȩ'
-    {{0x0045, 0x0328}, 0x0118},  // 'E' + combining -> 'Ę'
-    {{0x0045, 0x032D}, 0x1E18},  // 'E' + combining -> 'Ḙ'
-    {{0x0045, 0x0330}, 0x1E1A},  // 'E' + combining -> 'Ḛ'
-    {{0x0046, 0x0307}, 0x1E1E},  // 'F' + combining -> 'Ḟ'
-    {{0x0047, 0x0301}, 0x01F4},  // 'G' + combining -> 'Ǵ'
-    {{0x0047, 0x0302}, 0x011C},  // 'G' + combining -> 'Ĝ'
-    {{0x0047, 0x0304}, 0x1E20},  // 'G' + combining -> 'Ḡ'
-    {{0x0047, 0x0306}, 0x011E},  // 'G' + combining -> 'Ğ'
-    {{0x0047, 0x0307}, 0x0120},  // 'G' + combining -> 'Ġ'
-    {{0x0047, 0x030C}, 0x01E6},  // 'G' + combining -> 'Ǧ'
-    {{0x0047, 0x0327}, 0x0122},  // 'G' + combining -> 'Ģ'
-    {{0x0048, 0x0302}, 0x0124},  // 'H' + combining -> 'Ĥ'
-    {{0x0048, 0x0307}, 0x1E22},  // 'H' + combining -> 'Ḣ'
-    {{0x0048, 0x0308}, 0x1E26},  // 'H' + combining -> 'Ḧ'
-    {{0x0048, 0x030C}, 0x021E},  // 'H' + combining -> 'Ȟ'
-    {{0x0048, 0x0323}, 0x1E24},  // 'H' + combining -> 'Ḥ'
-    {{0x0048, 0x0327}, 0x1E28},  // 'H' + combining -> 'Ḩ'
-    {{0x0048, 0x032E}, 0x1E2A},  // 'H' + combining -> 'Ḫ'
-    {{0x0049, 0x0300}, 0x00CC},  // 'I' + combining -> 'Ì'
-    {{0x0049, 0x0301}, 0x00CD},  // 'I' + combining -> 'Í'
-    {{0x0049, 0x0302}, 0x00CE},  // 'I' + combining -> 'Î'
-    {{0x0049, 0x0303}, 0x0128},  // 'I' + combining -> 'Ĩ'
-    {{0x0049, 0x0304}, 0x012A},  // 'I' + combining -> 'Ī'
-    {{0x0049, 0x0306}, 0x012C},  // 'I' + combining -> 'Ĭ'
-    {{0x0049, 0x0307}, 0x0130},  // 'I' + combining -> 'İ'
-    {{0x0049, 0x0308}, 0x00CF},  // 'I' + combining -> 'Ï'
-    {{0x0049, 0x0309}, 0x1EC8},  // 'I' + combining -> 'Ỉ'
-    {{0x0049, 0x030C}, 0x01CF},  // 'I' + combining -> 'Ǐ'
-    {{0x0049, 0x030F}, 0x0208},  // 'I' + combining -> 'Ȉ'
-    {{0x0049, 0x0311}, 0x020A},  // 'I' + combining -> 'Ȋ'
-    {{0x0049, 0x0323}, 0x1ECA},  // 'I' + combining -> 'Ị'
-    {{0x0049, 0x0328}, 0x012E},  // 'I' + combining -> 'Į'
-    {{0x0049, 0x0330}, 0x1E2C},  // 'I' + combining -> 'Ḭ'
-    {{0x004A, 0x0302}, 0x0134},  // 'J' + combining -> 'Ĵ'
-    {{0x004B, 0x0301}, 0x1E30},  // 'K' + combining -> 'Ḱ'
-    {{0x004B, 0x030C}, 0x01E8},  // 'K' + combining -> 'Ǩ'
-    {{0x004B, 0x0323}, 0x1E32},  // 'K' + combining -> 'Ḳ'
-    {{0x004B, 0x0327}, 0x0136},  // 'K' + combining -> 'Ķ'
-    {{0x004B, 0x0331}, 0x1E34},  // 'K' + combining -> 'Ḵ'
-    {{0x004C, 0x0301}, 0x0139},  // 'L' + combining -> 'Ĺ'
-    {{0x004C, 0x030C}, 0x013D},  // 'L' + combining -> 'Ľ'
-    {{0x004C, 0x0323}, 0x1E36},  // 'L' + combining -> 'Ḷ'
-    {{0x004C, 0x0327}, 0x013B},  // 'L' + combining -> 'Ļ'
-    {{0x004C, 0x032D}, 0x1E3C},  // 'L' + combining -> 'Ḽ'
-    {{0x004C, 0x0331}, 0x1E3A},  // 'L' + combining -> 'Ḻ'
-    {{0x004D, 0x0301}, 0x1E3E},  // 'M' + combining -> 'Ḿ'
-    {{0x004D, 0x0307}, 0x1E40},  // 'M' + combining -> 'Ṁ'
-    {{0x004D, 0x0323}, 0x1E42},  // 'M' + combining -> 'Ṃ'
-    {{0x004E, 0x0300}, 0x01F8},  // 'N' + combining -> 'Ǹ'
-    {{0x004E, 0x0301}, 0x0143},  // 'N' + combining -> 'Ń'
-    {{0x004E, 0x0303}, 0x00D1},  // 'N' + combining -> 'Ñ'
-    {{0x004E, 0x0307}, 0x1E44},  // 'N' + combining -> 'Ṅ'
-    {{0x004E, 0x030C}, 0x0147},  // 'N' + combining -> 'Ň'
-    {{0x004E, 0x0323}, 0x1E46},  // 'N' + combining -> 'Ṇ'
-    {{0x004E, 0x0327}, 0x0145},  // 'N' + combining -> 'Ņ'
-    {{0x004E, 0x032D}, 0x1E4A},  // 'N' + combining -> 'Ṋ'
-    {{0x004E, 0x0331}, 0x1E48},  // 'N' + combining -> 'Ṉ'
-    {{0x004F, 0x0300}, 0x00D2},  // 'O' + combining -> 'Ò'
-    {{0x004F, 0x0301}, 0x00D3},  // 'O' + combining -> 'Ó'
-    {{0x004F, 0x0302}, 0x00D4},  // 'O' + combining -> 'Ô'
-    {{0x004F, 0x0303}, 0x00D5},  // 'O' + combining -> 'Õ'
-    {{0x004F, 0x0304}, 0x014C},  // 'O' + combining -> 'Ō'
-    {{0x004F, 0x0306}, 0x014E},  // 'O' + combining -> 'Ŏ'
-    {{0x004F, 0x0307}, 0x022E},  // 'O' + combining -> 'Ȯ'
-    {{0x004F, 0x0308}, 0x00D6},  // 'O' + combining -> 'Ö'
-    {{0x004F, 0x0309}, 0x1ECE},  // 'O' + combining -> 'Ỏ'
-    {{0x004F, 0x030B}, 0x0150},  // 'O' + combining -> 'Ő'
-    {{0x004F, 0x030C}, 0x01D1},  // 'O' + combining -> 'Ǒ'
-    {{0x004F, 0x030F}, 0x020C},  // 'O' + combining -> 'Ȍ'
-    {{0x004F, 0x0311}, 0x020E},  // 'O' + combining -> 'Ȏ'
-    {{0x004F, 0x031B}, 0x01A0},  // 'O' + combining -> 'Ơ'
-    {{0x004F, 0x0323}, 0x1ECC},  // 'O' + combining -> 'Ọ'
-    {{0x004F, 0x0328}, 0x01EA},  // 'O' + combining -> 'Ǫ'
-    {{0x0050, 0x0301}, 0x1E54},  // 'P' + combining -> 'Ṕ'
-    {{0x0050, 0x0307}, 0x1E56},  // 'P' + combining -> 'Ṗ'
-    {{0x0052, 0x0301}, 0x0154},  // 'R' + combining -> 'Ŕ'
-    {{0x0052, 0x0307}, 0x1E58},  // 'R' + combining -> 'Ṙ'
-    {{0x0052, 0x030C}, 0x0158},  // 'R' + combining -> 'Ř'
-    {{0x0052, 0x030F}, 0x0210},  // 'R' + combining -> 'Ȑ'
-    {{0x0052, 0x0311}, 0x0212},  // 'R' + combining -> 'Ȓ'
-    {{0x0052, 0x0323}, 0x1E5A},  // 'R' + combining -> 'Ṛ'
-    {{0x0052, 0x0327}, 0x0156},  // 'R' + combining -> 'Ŗ'
-    {{0x0052, 0x0331}, 0x1E5E},  // 'R' + combining -> 'Ṟ'
-    {{0x0053, 0x0301}, 0x015A},  // 'S' + combining -> 'Ś'
-    {{0x0053, 0x0302}, 0x015C},  // 'S' + combining -> 'Ŝ'
-    {{0x0053, 0x0307}, 0x1E60},  // 'S' + combining -> 'Ṡ'
-    {{0x0053, 0x030C}, 0x0160},  // 'S' + combining -> 'Š'
-    {{0x0053, 0x0323}, 0x1E62},  // 'S' + combining -> 'Ṣ'
-    {{0x0053, 0x0326}, 0x0218},  // 'S' + combining -> 'Ș'
-    {{0x0053, 0x0327}, 0x015E},  // 'S' + combining -> 'Ş'
-    {{0x0054, 0x0307}, 0x1E6A},  // 'T' + combining -> 'Ṫ'
-    {{0x0054, 0x030C}, 0x0164},  // 'T' + combining -> 'Ť'
-    {{0x0054, 0x0323}, 0x1E6C},  // 'T' + combining -> 'Ṭ'
-    {{0x0054, 0x0326}, 0x021A},  // 'T' + combining -> 'Ț'
-    {{0x0054, 0x0327}, 0x0162},  // 'T' + combining -> 'Ţ'
-    {{0x0054, 0x032D}, 0x1E70},  // 'T' + combining -> 'Ṱ'
-    {{0x0054, 0x0331}, 0x1E6E},  // 'T' + combining -> 'Ṯ'
-    {{0x0055, 0x0300}, 0x00D9},  // 'U' + combining -> 'Ù'
-    {{0x0055, 0x0301}, 0x00DA},  // 'U' + combining -> 'Ú'
-    {{0x0055, 0x0302}, 0x00DB},  // 'U' + combining -> 'Û'
-    {{0x0055, 0x0303}, 0x0168},  // 'U' + combining -> 'Ũ'
-    {{0x0055, 0x0304}, 0x016A},  // 'U' + combining -> 'Ū'
-    {{0x0055, 0x0306}, 0x016C},  // 'U' + combining -> 'Ŭ'
-    {{0x0055, 0x0308}, 0x00DC},  // 'U' + combining -> 'Ü'
-    {{0x0055, 0x0309}, 0x1EE6},  // 'U' + combining -> 'Ủ'
-    {{0x0055, 0x030A}, 0x016E},  // 'U' + combining -> 'Ů'
-    {{0x0055, 0x030B}, 0x0170},  // 'U' + combining -> 'Ű'
-    {{0x0055, 0x030C}, 0x01D3},  // 'U' + combining -> 'Ǔ'
-    {{0x0055, 0x030F}, 0x0214},  // 'U' + combining -> 'Ȕ'
-    {{0x0055, 0x0311}, 0x0216},  // 'U' + combining -> 'Ȗ'
-    {{0x0055, 0x031B}, 0x01AF},  // 'U' + combining -> 'Ư'
-    {{0x0055, 0x0323}, 0x1EE4},  // 'U' + combining -> 'Ụ'
-    {{0x0055, 0x0324}, 0x1E72},  // 'U' + combining -> 'Ṳ'
-    {{0x0055, 0x0328}, 0x0172},  // 'U' + combining -> 'Ų'
-    {{0x0055, 0x032D}, 0x1E76},  // 'U' + combining -> 'Ṷ'
-    {{0x0055, 0x0330}, 0x1E74},  // 'U' + combining -> 'Ṵ'
-    {{0x0056, 0x0303}, 0x1E7C},  // 'V' + combining -> 'Ṽ'
-    {{0x0056, 0x0323}, 0x1E7E},  // 'V' + combining -> 'Ṿ'
-    {{0x0057, 0x0300}, 0x1E80},  // 'W' + combining -> 'Ẁ'
-    {{0x0057, 0x0301}, 0x1E82},  // 'W' + combining -> 'Ẃ'
-    {{0x0057, 0x0302}, 0x0174},  // 'W' + combining -> 'Ŵ'
-    {{0x0057, 0x0307}, 0x1E86},  // 'W' + combining -> 'Ẇ'
-    {{0x0057, 0x0308}, 0x1E84},  // 'W' + combining -> 'Ẅ'
-    {{0x0057, 0x0323}, 0x1E88},  // 'W' + combining -> 'Ẉ'
-    {{0x0058, 0x0307}, 0x1E8A},  // 'X' + combining -> 'Ẋ'
-    {{0x0058, 0x0308}, 0x1E8C},  // 'X' + combining -> 'Ẍ'
-    {{0x0059, 0x0300}, 0x1EF2},  // 'Y' + combining -> 'Ỳ'
-    {{0x0059, 0x0301}, 0x00DD},  // 'Y' + combining -> 'Ý'
-    {{0x0059, 0x0302}, 0x0176},  // 'Y' + combining -> 'Ŷ'
-    {{0x0059, 0x0303}, 0x1EF8},  // 'Y' + combining -> 'Ỹ'
-    {{0x0059, 0x0304}, 0x0232},  // 'Y' + combining -> 'Ȳ'
-    {{0x0059, 0x0307}, 0x1E8E},  // 'Y' + combining -> 'Ẏ'
-    {{0x0059, 0x0308}, 0x0178},  // 'Y' + combining -> 'Ÿ'
-    {{0x0059, 0x0309}, 0x1EF6},  // 'Y' + combining -> 'Ỷ'
-    {{0x0059, 0x0323}, 0x1EF4},  // 'Y' + combining -> 'Ỵ'
-    {{0x005A, 0x0301}, 0x0179},  // 'Z' + combining -> 'Ź'
-    {{0x005A, 0x0302}, 0x1E90},  // 'Z' + combining -> 'Ẑ'
-    {{0x005A, 0x0307}, 0x017B},  // 'Z' + combining -> 'Ż'
-    {{0x005A, 0x030C}, 0x017D},  // 'Z' + combining -> 'Ž'
-    {{0x005A, 0x0323}, 0x1E92},  // 'Z' + combining -> 'Ẓ'
-    {{0x005A, 0x0331}, 0x1E94},  // 'Z' + combining -> 'Ẕ'
-    {{0x0061, 0x0300}, 0x00E0},  // 'a' + combining -> 'à'
-    {{0x0061, 0x0301}, 0x00E1},  // 'a' + combining -> 'á'
-    {{0x0061, 0x0302}, 0x00E2},  // 'a' + combining -> 'â'
-    {{0x0061, 0x0303}, 0x00E3},  // 'a' + combining -> 'ã'
-    {{0x0061, 0x0304}, 0x0101},  // 'a' + combining -> 'ā'
-    {{0x0061, 0x0306}, 0x0103},  // 'a' + combining -> 'ă'
-    {{0x0061, 0x0307}, 0x0227},  // 'a' + combining -> 'ȧ'
-    {{0x0061, 0x0308}, 0x00E4},  // 'a' + combining -> 'ä'
-    {{0x0061, 0x0309}, 0x1EA3},  // 'a' + combining -> 'ả'
-    {{0x0061, 0x030A}, 0x00E5},  // 'a' + combining -> 'å'
-    {{0x0061, 0x030C}, 0x01CE},  // 'a' + combining -> 'ǎ'
-    {{0x0061, 0x030F}, 0x0201},  // 'a' + combining -> 'ȁ'
-    {{0x0061, 0x0311}, 0x0203},  // 'a' + combining -> 'ȃ'
-    {{0x0061, 0x0323}, 0x1EA1},  // 'a' + combining -> 'ạ'
-    {{0x0061, 0x0325}, 0x1E01},  // 'a' + combining -> 'ḁ'
-    {{0x0061, 0x0328}, 0x0105},  // 'a' + combining -> 'ą'
-    {{0x0062, 0x0307}, 0x1E03},  // 'b' + combining -> 'ḃ'
-    {{0x0062, 0x0323}, 0x1E05},  // 'b' + combining -> 'ḅ'
-    {{0x0062, 0x0331}, 0x1E07},  // 'b' + combining -> 'ḇ'
-    {{0x0063, 0x0301}, 0x0107},  // 'c' + combining -> 'ć'
-    {{0x0063, 0x0302}, 0x0109},  // 'c' + combining -> 'ĉ'
-    {{0x0063, 0x0307}, 0x010B},  // 'c' + combining -> 'ċ'
-    {{0x0063, 0x030C}, 0x010D},  // 'c' + combining -> 'č'
-    {{0x0063, 0x0327}, 0x00E7},  // 'c' + combining -> 'ç'
-    {{0x0064, 0x0307}, 0x1E0B},  // 'd' + combining -> 'ḋ'
-    {{0x0064, 0x030C}, 0x010F},  // 'd' + combining -> 'ď'
-    {{0x0064, 0x0323}, 0x1E0D},  // 'd' + combining -> 'ḍ'
-    {{0x0064, 0x0327}, 0x1E11},  // 'd' + combining -> 'ḑ'
-    {{0x0064, 0x032D}, 0x1E13},  // 'd' + combining -> 'ḓ'
-    {{0x0064, 0x0331}, 0x1E0F},  // 'd' + combining -> 'ḏ'
-    {{0x0065, 0x0300}, 0x00E8},  // 'e' + combining -> 'è'
-    {{0x0065, 0x0301}, 0x00E9},  // 'e' + combining -> 'é'
-    {{0x0065, 0x0302}, 0x00EA},  // 'e' + combining -> 'ê'
-    {{0x0065, 0x0303}, 0x1EBD},  // 'e' + combining -> 'ẽ'
-    {{0x0065, 0x0304}, 0x0113},  // 'e' + combining -> 'ē'
-    {{0x0065, 0x0306}, 0x0115},  // 'e' + combining -> 'ĕ'
-    {{0x0065, 0x0307}, 0x0117},  // 'e' + combining -> 'ė'
-    {{0x0065, 0x0308}, 0x00EB},  // 'e' + combining -> 'ë'
-    {{0x0065, 0x0309}, 0x1EBB},  // 'e' + combining -> 'ẻ'
-    {{0x0065, 0x030C}, 0x011B},  // 'e' + combining -> 'ě'
-    {{0x0065, 0x030F}, 0x0205},  // 'e' + combining -> 'ȅ'
-    {{0x0065, 0x0311}, 0x0207},  // 'e' + combining -> 'ȇ'
-    {{0x0065, 0x0323}, 0x1EB9},  // 'e' + combining -> 'ẹ'
-    {{0x0065, 0x0327}, 0x0229},  // 'e' + combining -> 'ȩ'
-    {{0x0065, 0x0328}, 0x0119},  // 'e' + combining -> 'ę'
-    {{0x0065, 0x032D}, 0x1E19},  // 'e' + combining -> 'ḙ'
-    {{0x0065, 0x0330}, 0x1E1B},  // 'e' + combining -> 'ḛ'
-    {{0x0066, 0x0307}, 0x1E1F},  // 'f' + combining -> 'ḟ'
-    {{0x0067, 0x0301}, 0x01F5},  // 'g' + combining -> 'ǵ'
-    {{0x0067, 0x0302}, 0x011D},  // 'g' + combining -> 'ĝ'
-    {{0x0067, 0x0304}, 0x1E21},  // 'g' + combining -> 'ḡ'
-    {{0x0067, 0x0306}, 0x011F},  // 'g' + combining -> 'ğ'
-    {{0x0067, 0x0307}, 0x0121},  // 'g' + combining -> 'ġ'
-    {{0x0067, 0x030C}, 0x01E7},  // 'g' + combining -> 'ǧ'
-    {{0x0067, 0x0327}, 0x0123},  // 'g' + combining -> 'ģ'
-    {{0x0068, 0x0302}, 0x0125},  // 'h' + combining -> 'ĥ'
-    {{0x0068, 0x0307}, 0x1E23},  // 'h' + combining -> 'ḣ'
-    {{0x0068, 0x0308}, 0x1E27},  // 'h' + combining -> 'ḧ'
-    {{0x0068, 0x030C}, 0x021F},  // 'h' + combining -> 'ȟ'
-    {{0x0068, 0x0323}, 0x1E25},  // 'h' + combining -> 'ḥ'
-    {{0x0068, 0x0327}, 0x1E29},  // 'h' + combining -> 'ḩ'
-    {{0x0068, 0x032E}, 0x1E2B},  // 'h' + combining -> 'ḫ'
-    {{0x0068, 0x0331}, 0x1E96},  // 'h' + combining -> 'ẖ'
-    {{0x0069, 0x0300}, 0x00EC},  // 'i' + combining -> 'ì'
-    {{0x0069, 0x0301}, 0x00ED},  // 'i' + combining -> 'í'
-    {{0x0069, 0x0302}, 0x00EE},  // 'i' + combining -> 'î'
-    {{0x0069, 0x0303}, 0x0129},  // 'i' + combining -> 'ĩ'
-    {{0x0069, 0x0304}, 0x012B},  // 'i' + combining -> 'ī'
-    {{0x0069, 0x0306}, 0x012D},  // 'i' + combining -> 'ĭ'
-    {{0x0069, 0x0308}, 0x00EF},  // 'i' + combining -> 'ï'
-    {{0x0069, 0x0309}, 0x1EC9},  // 'i' + combining -> 'ỉ'
-    {{0x0069, 0x030C}, 0x01D0},  // 'i' + combining -> 'ǐ'
-    {{0x0069, 0x030F}, 0x0209},  // 'i' + combining -> 'ȉ'
-    {{0x0069, 0x0311}, 0x020B},  // 'i' + combining -> 'ȋ'
-    {{0x0069, 0x0323}, 0x1ECB},  // 'i' + combining -> 'ị'
-    {{0x0069, 0x0328}, 0x012F},  // 'i' + combining -> 'į'
-    {{0x0069, 0x0330}, 0x1E2D},  // 'i' + combining -> 'ḭ'
-    {{0x006A, 0x0302}, 0x0135},  // 'j' + combining -> 'ĵ'
-    {{0x006A, 0x030C}, 0x01F0},  // 'j' + combining -> 'ǰ'
-    {{0x006B, 0x0301}, 0x1E31},  // 'k' + combining -> 'ḱ'
-    {{0x006B, 0x030C}, 0x01E9},  // 'k' + combining -> 'ǩ'
-    {{0x006B, 0x0323}, 0x1E33},  // 'k' + combining -> 'ḳ'
-    {{0x006B, 0x0327}, 0x0137},  // 'k' + combining -> 'ķ'
-    {{0x006B, 0x0331}, 0x1E35},  // 'k' + combining -> 'ḵ'
-    {{0x006C, 0x0301}, 0x013A},  // 'l' + combining -> 'ĺ'
-    {{0x006C, 0x030C}, 0x013E},  // 'l' + combining -> 'ľ'
-    {{0x006C, 0x0323}, 0x1E37},  // 'l' + combining -> 'ḷ'
-    {{0x006C, 0x0327}, 0x013C},  // 'l' + combining -> 'ļ'
-    {{0x006C, 0x032D}, 0x1E3D},  // 'l' + combining -> 'ḽ'
-    {{0x006C, 0x0331}, 0x1E3B},  // 'l' + combining -> 'ḻ'
-    {{0x006D, 0x0301}, 0x1E3F},  // 'm' + combining -> 'ḿ'
-    {{0x006D, 0x0307}, 0x1E41},  // 'm' + combining -> 'ṁ'
-    {{0x006D, 0x0323}, 0x1E43},  // 'm' + combining -> 'ṃ'
-    {{0x006E, 0x0300}, 0x01F9},  // 'n' + combining -> 'ǹ'
-    {{0x006E, 0x0301}, 0x0144},  // 'n' + combining -> 'ń'
-    {{0x006E, 0x0303}, 0x00F1},  // 'n' + combining -> 'ñ'
-    {{0x006E, 0x0307}, 0x1E45},  // 'n' + combining -> 'ṅ'
-    {{0x006E, 0x030C}, 0x0148},  // 'n' + combining -> 'ň'
-    {{0x006E, 0x0323}, 0x1E47},  // 'n' + combining -> 'ṇ'
-    {{0x006E, 0x0327}, 0x0146},  // 'n' + combining -> 'ņ'
-    {{0x006E, 0x032D}, 0x1E4B},  // 'n' + combining -> 'ṋ'
-    {{0x006E, 0x0331}, 0x1E49},  // 'n' + combining -> 'ṉ'
-    {{0x006F, 0x0300}, 0x00F2},  // 'o' + combining -> 'ò'
-    {{0x006F, 0x0301}, 0x00F3},  // 'o' + combining -> 'ó'
-    {{0x006F, 0x0302}, 0x00F4},  // 'o' + combining -> 'ô'
-    {{0x006F, 0x0303}, 0x00F5},  // 'o' + combining -> 'õ'
-    {{0x006F, 0x0304}, 0x014D},  // 'o' + combining -> 'ō'
-    {{0x006F, 0x0306}, 0x014F},  // 'o' + combining -> 'ŏ'
-    {{0x006F, 0x0307}, 0x022F},  // 'o' + combining -> 'ȯ'
-    {{0x006F, 0x0308}, 0x00F6},  // 'o' + combining -> 'ö'
-    {{0x006F, 0x0309}, 0x1ECF},  // 'o' + combining -> 'ỏ'
-    {{0x006F, 0x030B}, 0x0151},  // 'o' + combining -> 'ő'
-    {{0x006F, 0x030C}, 0x01D2},  // 'o' + combining -> 'ǒ'
-    {{0x006F, 0x030F}, 0x020D},  // 'o' + combining -> 'ȍ'
-    {{0x006F, 0x0311}, 0x020F},  // 'o' + combining -> 'ȏ'
-    {{0x006F, 0x031B}, 0x01A1},  // 'o' + combining -> 'ơ'
-    {{0x006F, 0x0323}, 0x1ECD},  // 'o' + combining -> 'ọ'
-    {{0x006F, 0x0328}, 0x01EB},  // 'o' + combining -> 'ǫ'
-    {{0x0070, 0x0301}, 0x1E55},  // 'p' + combining -> 'ṕ'
-    {{0x0070, 0x0307}, 0x1E57},  // 'p' + combining -> 'ṗ'
-    {{0x0072, 0x0301}, 0x0155},  // 'r' + combining -> 'ŕ'
-    {{0x0072, 0x0307}, 0x1E59},  // 'r' + combining -> 'ṙ'
-    {{0x0072, 0x030C}, 0x0159},  // 'r' + combining -> 'ř'
-    {{0x0072, 0x030F}, 0x0211},  // 'r' + combining -> 'ȑ'
-    {{0x0072, 0x0311}, 0x0213},  // 'r' + combining -> 'ȓ'
-    {{0x0072, 0x0323}, 0x1E5B},  // 'r' + combining -> 'ṛ'
-    {{0x0072, 0x0327}, 0x0157},  // 'r' + combining -> 'ŗ'
-    {{0x0072, 0x0331}, 0x1E5F},  // 'r' + combining -> 'ṟ'
-    {{0x0073, 0x0301}, 0x015B},  // 's' + combining -> 'ś'
-    {{0x0073, 0x0302}, 0x015D},  // 's' + combining -> 'ŝ'
-    {{0x0073, 0x0307}, 0x1E61},  // 's' + combining -> 'ṡ'
-    {{0x0073, 0x030C}, 0x0161},  // 's' + combining -> 'š'
-    {{0x0073, 0x0323}, 0x1E63},  // 's' + combining -> 'ṣ'
-    {{0x0073, 0x0326}, 0x0219},  // 's' + combining -> 'ș'
-    {{0x0073, 0x0327}, 0x015F},  // 's' + combining -> 'ş'
-    {{0x0074, 0x0307}, 0x1E6B},  // 't' + combining -> 'ṫ'
-    {{0x0074, 0x0308}, 0x1E97},  // 't' + combining -> 'ẗ'
-    {{0x0074, 0x030C}, 0x0165},  // 't' + combining -> 'ť'
-    {{0x0074, 0x0323}, 0x1E6D},  // 't' + combining -> 'ṭ'
-    {{0x0074, 0x0326}, 0x021B},  // 't' + combining -> 'ț'
-    {{0x0074, 0x0327}, 0x0163},  // 't' + combining -> 'ţ'
-    {{0x0074, 0x032D}, 0x1E71},  // 't' + combining -> 'ṱ'
-    {{0x0074, 0x0331}, 0x1E6F},  // 't' + combining -> 'ṯ'
-    {{0x0075, 0x0300}, 0x00F9},  // 'u' + combining -> 'ù'
-    {{0x0075, 0x0301}, 0x00FA},  // 'u' + combining -> 'ú'
-    {{0x0075, 0x0302}, 0x00FB},  // 'u' + combining -> 'û'
-    {{0x0075, 0x0303}, 0x0169},  // 'u' + combining -> 'ũ'
-    {{0x0075, 0x0304}, 0x016B},  // 'u' + combining -> 'ū'
-    {{0x0075, 0x0306}, 0x016D},  // 'u' + combining -> 'ŭ'
-    {{0x0075, 0x0308}, 0x00FC},  // 'u' + combining -> 'ü'
-    {{0x0075, 0x0309}, 0x1EE7},  // 'u' + combining -> 'ủ'
-    {{0x0075, 0x030A}, 0x016F},  // 'u' + combining -> 'ů'
-    {{0x0075, 0x030B}, 0x0171},  // 'u' + combining -> 'ű'
-    {{0x0075, 0x030C}, 0x01D4},  // 'u' + combining -> 'ǔ'
-    {{0x0075, 0x030F}, 0x0215},  // 'u' + combining -> 'ȕ'
-    {{0x0075, 0x0311}, 0x0217},  // 'u' + combining -> 'ȗ'
-    {{0x0075, 0x031B}, 0x01B0},  // 'u' + combining -> 'ư'
-    {{0x0075, 0x0323}, 0x1EE5},  // 'u' + combining -> 'ụ'
-    {{0x0075, 0x0324}, 0x1E73},  // 'u' + combining -> 'ṳ'
-    {{0x0075, 0x0328}, 0x0173},  // 'u' + combining -> 'ų'
-    {{0x0075, 0x032D}, 0x1E77},  // 'u' + combining -> 'ṷ'
-    {{0x0075, 0x0330}, 0x1E75},  // 'u' + combining -> 'ṵ'
-    {{0x0076, 0x0303}, 0x1E7D},  // 'v' + combining -> 'ṽ'
-    {{0x0076, 0x0323}, 0x1E7F},  // 'v' + combining -> 'ṿ'
-    {{0x0077, 0x0300}, 0x1E81},  // 'w' + combining -> 'ẁ'
-    {{0x0077, 0x0301}, 0x1E83},  // 'w' + combining -> 'ẃ'
-    {{0x0077, 0x0302}, 0x0175},  // 'w' + combining -> 'ŵ'
-    {{0x0077, 0x0307}, 0x1E87},  // 'w' + combining -> 'ẇ'
-    {{0x0077, 0x0308}, 0x1E85},  // 'w' + combining -> 'ẅ'
-    {{0x0077, 0x030A}, 0x1E98},  // 'w' + combining -> 'ẘ'
-    {{0x0077, 0x0323}, 0x1E89},  // 'w' + combining -> 'ẉ'
-    {{0x0078, 0x0307}, 0x1E8B},  // 'x' + combining -> 'ẋ'
-    {{0x0078, 0x0308}, 0x1E8D},  // 'x' + combining -> 'ẍ'
-    {{0x0079, 0x0300}, 0x1EF3},  // 'y' + combining -> 'ỳ'
-    {{0x0079, 0x0301}, 0x00FD},  // 'y' + combining -> 'ý'
-    {{0x0079, 0x0302}, 0x0177},  // 'y' + combining -> 'ŷ'
-    {{0x0079, 0x0303}, 0x1EF9},  // 'y' + combining -> 'ỹ'
-    {{0x0079, 0x0304}, 0x0233},  // 'y' + combining -> 'ȳ'
-    {{0x0079, 0x0307}, 0x1E8F},  // 'y' + combining -> 'ẏ'
-    {{0x0079, 0x0308}, 0x00FF},  // 'y' + combining -> 'ÿ'
-    {{0x0079, 0x0309}, 0x1EF7},  // 'y' + combining -> 'ỷ'
-    {{0x0079, 0x030A}, 0x1E99},  // 'y' + combining -> 'ẙ'
-    {{0x0079, 0x0323}, 0x1EF5},  // 'y' + combining -> 'ỵ'
-    {{0x007A, 0x0301}, 0x017A},  // 'z' + combining -> 'ź'
-    {{0x007A, 0x0302}, 0x1E91},  // 'z' + combining -> 'ẑ'
-    {{0x007A, 0x0307}, 0x017C},  // 'z' + combining -> 'ż'
-    {{0x007A, 0x030C}, 0x017E},  // 'z' + combining -> 'ž'
-    {{0x007A, 0x0323}, 0x1E93},  // 'z' + combining -> 'ẓ'
-    {{0x007A, 0x0331}, 0x1E95},  // 'z' + combining -> 'ẕ'
-    {{0x00A8, 0x0300}, 0x1FED},  // '¨' + combining -> '῭'
-    {{0x00A8, 0x0301}, 0x0385},  // '¨' + combining -> '΅'
-    {{0x00A8, 0x0342}, 0x1FC1},  // '¨' + combining -> '῁'
-    {{0x00C2, 0x0300}, 0x1EA6},  // 'Â' + combining -> 'Ầ'
-    {{0x00C2, 0x0301}, 0x1EA4},  // 'Â' + combining -> 'Ấ'
-    {{0x00C2, 0x0303}, 0x1EAA},  // 'Â' + combining -> 'Ẫ'
-    {{0x00C2, 0x0309}, 0x1EA8},  // 'Â' + combining -> 'Ẩ'
-    {{0x00C4, 0x0304}, 0x01DE},  // 'Ä' + combining -> 'Ǟ'
-    {{0x00C5, 0x0301}, 0x01FA},  // 'Å' + combining -> 'Ǻ'
-    {{0x00C6, 0x0301}, 0x01FC},  // 'Æ' + combining -> 'Ǽ'
-    {{0x00C6, 0x0304}, 0x01E2},  // 'Æ' + combining -> 'Ǣ'
-    {{0x00C7, 0x0301}, 0x1E08},  // 'Ç' + combining -> 'Ḉ'
-    {{0x00CA, 0x0300}, 0x1EC0},  // 'Ê' + combining -> 'Ề'
-    {{0x00CA, 0x0301}, 0x1EBE},  // 'Ê' + combining -> 'Ế'
-    {{0x00CA, 0x0303}, 0x1EC4},  // 'Ê' + combining -> 'Ễ'
-    {{0x00CA, 0x0309}, 0x1EC2},  // 'Ê' + combining -> 'Ể'
-    {{0x00CF, 0x0301}, 0x1E2E},  // 'Ï' + combining -> 'Ḯ'
-    {{0x00D4, 0x0300}, 0x1ED2},  // 'Ô' + combining -> 'Ồ'
-    {{0x00D4, 0x0301}, 0x1ED0},  // 'Ô' + combining -> 'Ố'
-    {{0x00D4, 0x0303}, 0x1ED6},  // 'Ô' + combining -> 'Ỗ'
-    {{0x00D4, 0x0309}, 0x1ED4},  // 'Ô' + combining -> 'Ổ'
-    {{0x00D5, 0x0301}, 0x1E4C},  // 'Õ' + combining -> 'Ṍ'
-    {{0x00D5, 0x0304}, 0x022C},  // 'Õ' + combining -> 'Ȭ'
-    {{0x00D5, 0x0308}, 0x1E4E},  // 'Õ' + combining -> 'Ṏ'
-    {{0x00D6, 0x0304}, 0x022A},  // 'Ö' + combining -> 'Ȫ'
-    {{0x00D8, 0x0301}, 0x01FE},  // 'Ø' + combining -> 'Ǿ'
-    {{0x00DC, 0x0300}, 0x01DB},  // 'Ü' + combining -> 'Ǜ'
-    {{0x00DC, 0x0301}, 0x01D7},  // 'Ü' + combining -> 'Ǘ'
-    {{0x00DC, 0x0304}, 0x01D5},  // 'Ü' + combining -> 'Ǖ'
-    {{0x00DC, 0x030C}, 0x01D9},  // 'Ü' + combining -> 'Ǚ'
-    {{0x00E2, 0x0300}, 0x1EA7},  // 'â' + combining -> 'ầ'
-    {{0x00E2, 0x0301}, 0x1EA5},  // 'â' + combining -> 'ấ'
-    {{0x00E2, 0x0303}, 0x1EAB},  // 'â' + combining -> 'ẫ'
-    {{0x00E2, 0x0309}, 0x1EA9},  // 'â' + combining -> 'ẩ'
-    {{0x00E4, 0x0304}, 0x01DF},  // 'ä' + combining -> 'ǟ'
-    {{0x00E5, 0x0301}, 0x01FB},  // 'å' + combining -> 'ǻ'
-    {{0x00E6, 0x0301}, 0x01FD},  // 'æ' + combining -> 'ǽ'
-    {{0x00E6, 0x0304}, 0x01E3},  // 'æ' + combining -> 'ǣ'
-    {{0x00E7, 0x0301}, 0x1E09},  // 'ç' + combining -> 'ḉ'
-    {{0x00EA, 0x0300}, 0x1EC1},  // 'ê' + combining -> 'ề'
-    {{0x00EA, 0x0301}, 0x1EBF},  // 'ê' + combining -> 'ế'
-    {{0x00EA, 0x0303}, 0x1EC5},  // 'ê' + combining -> 'ễ'
-    {{0x00EA, 0x0309}, 0x1EC3},  // 'ê' + combining -> 'ể'
-    {{0x00EF, 0x0301}, 0x1E2F},  // 'ï' + combining -> 'ḯ'
-    {{0x00F4, 0x0300}, 0x1ED3},  // 'ô' + combining -> 'ồ'
-    {{0x00F4, 0x0301}, 0x1ED1},  // 'ô' + combining -> 'ố'
-    {{0x00F4, 0x0303}, 0x1ED7},  // 'ô' + combining -> 'ỗ'
-    {{0x00F4, 0x0309}, 0x1ED5},  // 'ô' + combining -> 'ổ'
-    {{0x00F5, 0x0301}, 0x1E4D},  // 'õ' + combining -> 'ṍ'
-    {{0x00F5, 0x0304}, 0x022D},  // 'õ' + combining -> 'ȭ'
-    {{0x00F5, 0x0308}, 0x1E4F},  // 'õ' + combining -> 'ṏ'
-    {{0x00F6, 0x0304}, 0x022B},  // 'ö' + combining -> 'ȫ'
-    {{0x00F8, 0x0301}, 0x01FF},  // 'ø' + combining -> 'ǿ'
-    {{0x00FC, 0x0300}, 0x01DC},  // 'ü' + combining -> 'ǜ'
-    {{0x00FC, 0x0301}, 0x01D8},  // 'ü' + combining -> 'ǘ'
-    {{0x00FC, 0x0304}, 0x01D6},  // 'ü' + combining -> 'ǖ'
-    {{0x00FC, 0x030C}, 0x01DA},  // 'ü' + combining -> 'ǚ'
-    {{0x0102, 0x0300}, 0x1EB0},  // 'Ă' + combining -> 'Ằ'
-    {{0x0102, 0x0301}, 0x1EAE},  // 'Ă' + combining -> 'Ắ'
-    {{0x0102, 0x0303}, 0x1EB4},  // 'Ă' + combining -> 'Ẵ'
-    {{0x0102, 0x0309}, 0x1EB2},  // 'Ă' + combining -> 'Ẳ'
-    {{0x0103, 0x0300}, 0x1EB1},  // 'ă' + combining -> 'ằ'
-    {{0x0103, 0x0301}, 0x1EAF},  // 'ă' + combining -> 'ắ'
-    {{0x0103, 0x0303}, 0x1EB5},  // 'ă' + combining -> 'ẵ'
-    {{0x0103, 0x0309}, 0x1EB3},  // 'ă' + combining -> 'ẳ'
-    {{0x0112, 0x0300}, 0x1E14},  // 'Ē' + combining -> 'Ḕ'
-    {{0x0112, 0x0301}, 0x1E16},  // 'Ē' + combining -> 'Ḗ'
-    {{0x0113, 0x0300}, 0x1E15},  // 'ē' + combining -> 'ḕ'
-    {{0x0113, 0x0301}, 0x1E17},  // 'ē' + combining -> 'ḗ'
-    {{0x014C, 0x0300}, 0x1E50},  // 'Ō' + combining -> 'Ṑ'
-    {{0x014C, 0x0301}, 0x1E52},  // 'Ō' + combining -> 'Ṓ'
-    {{0x014D, 0x0300}, 0x1E51},  // 'ō' + combining -> 'ṑ'
-    {{0x014D, 0x0301}, 0x1E53},  // 'ō' + combining -> 'ṓ'
-    {{0x015A, 0x0307}, 0x1E64},  // 'Ś' + combining -> 'Ṥ'
-    {{0x015B, 0x0307}, 0x1E65},  // 'ś' + combining -> 'ṥ'
-    {{0x0160, 0x0307}, 0x1E66},  // 'Š' + combining -> 'Ṧ'
-    {{0x0161, 0x0307}, 0x1E67},  // 'š' + combining -> 'ṧ'
-    {{0x0168, 0x0301}, 0x1E78},  // 'Ũ' + combining -> 'Ṹ'
-    {{0x0169, 0x0301}, 0x1E79},  // 'ũ' + combining -> 'ṹ'
-    {{0x016A, 0x0308}, 0x1E7A},  // 'Ū' + combining -> 'Ṻ'
-    {{0x016B, 0x0308}, 0x1E7B},  // 'ū' + combining -> 'ṻ'
-    {{0x017F, 0x0307}, 0x1E9B},  // 'ſ' + combining -> 'ẛ'
-    {{0x01A0, 0x0300}, 0x1EDC},  // 'Ơ' + combining -> 'Ờ'
-    {{0x01A0, 0x0301}, 0x1EDA},  // 'Ơ' + combining -> 'Ớ'
-    {{0x01A0, 0x0303}, 0x1EE0},  // 'Ơ' + combining -> 'Ỡ'
-    {{0x01A0, 0x0309}, 0x1EDE},  // 'Ơ' + combining -> 'Ở'
-    {{0x01A0, 0x0323}, 0x1EE2},  // 'Ơ' + combining -> 'Ợ'
-    {{0x01A1, 0x0300}, 0x1EDD},  // 'ơ' + combining -> 'ờ'
-    {{0x01A1, 0x0301}, 0x1EDB},  // 'ơ' + combining -> 'ớ'
-    {{0x01A1, 0x0303}, 0x1EE1},  // 'ơ' + combining -> 'ỡ'
-    {{0x01A1, 0x0309}, 0x1EDF},  // 'ơ' + combining -> 'ở'
-    {{0x01A1, 0x0323}, 0x1EE3},  // 'ơ' + combining -> 'ợ'
-    {{0x01AF, 0x0300}, 0x1EEA},  // 'Ư' + combining -> 'Ừ'
-    {{0x01AF, 0x0301}, 0x1EE8},  // 'Ư' + combining -> 'Ứ'
-    {{0x01AF, 0x0303}, 0x1EEE},  // 'Ư' + combining -> 'Ữ'
-    {{0x01AF, 0x0309}, 0x1EEC},  // 'Ư' + combining -> 'Ử'
-    {{0x01AF, 0x0323}, 0x1EF0},  // 'Ư' + combining -> 'Ự'
-    {{0x01B0, 0x0300}, 0x1EEB},  // 'ư' + combining -> 'ừ'
-    {{0x01B0, 0x0301}, 0x1EE9},  // 'ư' + combining -> 'ứ'
-    {{0x01B0, 0x0303}, 0x1EEF},  // 'ư' + combining -> 'ữ'
-    {{0x01B0, 0x0309}, 0x1EED},  // 'ư' + combining -> 'ử'
-    {{0x01B0, 0x0323}, 0x1EF1},  // 'ư' + combining -> 'ự'
-    {{0x01B7, 0x030C}, 0x01EE},  // 'Ʒ' + combining -> 'Ǯ'
-    {{0x01EA, 0x0304}, 0x01EC},  // 'Ǫ' + combining -> 'Ǭ'
-    {{0x01EB, 0x0304}, 0x01ED},  // 'ǫ' + combining -> 'ǭ'
-    {{0x0226, 0x0304}, 0x01E0},  // 'Ȧ' + combining -> 'Ǡ'
-    {{0x0227, 0x0304}, 0x01E1},  // 'ȧ' + combining -> 'ǡ'
-    {{0x0228, 0x0306}, 0x1E1C},  // 'Ȩ' + combining -> 'Ḝ'
-    {{0x0229, 0x0306}, 0x1E1D},  // 'ȩ' + combining -> 'ḝ'
-    {{0x022E, 0x0304}, 0x0230},  // 'Ȯ' + combining -> 'Ȱ'
-    {{0x022F, 0x0304}, 0x0231},  // 'ȯ' + combining -> 'ȱ'
-    {{0x0292, 0x030C}, 0x01EF},  // 'ʒ' + combining -> 'ǯ'
-    {{0x0308, 0x0301}, 0x0344},  // '̈' + combining -> '̈́'
-    {{0x0391, 0x0300}, 0x1FBA},  // 'Α' + combining -> 'Ὰ'
-    {{0x0391, 0x0301}, 0x0386},  // 'Α' + combining -> 'Ά'
-    {{0x0391, 0x0304}, 0x1FB9},  // 'Α' + combining -> 'Ᾱ'
-    {{0x0391, 0x0306}, 0x1FB8},  // 'Α' + combining -> 'Ᾰ'
-    {{0x0391, 0x0313}, 0x1F08},  // 'Α' + combining -> 'Ἀ'
-    {{0x0391, 0x0314}, 0x1F09},  // 'Α' + combining -> 'Ἁ'
-    {{0x0391, 0x0345}, 0x1FBC},  // 'Α' + combining -> 'ᾼ'
-    {{0x0395, 0x0300}, 0x1FC8},  // 'Ε' + combining -> 'Ὲ'
-    {{0x0395, 0x0301}, 0x0388},  // 'Ε' + combining -> 'Έ'
-    {{0x0395, 0x0313}, 0x1F18},  // 'Ε' + combining -> 'Ἐ'
-    {{0x0395, 0x0314}, 0x1F19},  // 'Ε' + combining -> 'Ἑ'
-    {{0x0397, 0x0300}, 0x1FCA},  // 'Η' + combining -> 'Ὴ'
-    {{0x0397, 0x0301}, 0x0389},  // 'Η' + combining -> 'Ή'
-    {{0x0397, 0x0313}, 0x1F28},  // 'Η' + combining -> 'Ἠ'
-    {{0x0397, 0x0314}, 0x1F29},  // 'Η' + combining -> 'Ἡ'
-    {{0x0397, 0x0345}, 0x1FCC},  // 'Η' + combining -> 'ῌ'
-    {{0x0399, 0x0300}, 0x1FDA},  // 'Ι' + combining -> 'Ὶ'
-    {{0x0399, 0x0301}, 0x038A},  // 'Ι' + combining -> 'Ί'
-    {{0x0399, 0x0304}, 0x1FD9},  // 'Ι' + combining -> 'Ῑ'
-    {{0x0399, 0x0306}, 0x1FD8},  // 'Ι' + combining -> 'Ῐ'
-    {{0x0399, 0x0308}, 0x03AA},  // 'Ι' + combining -> 'Ϊ'
-    {{0x0399, 0x0313}, 0x1F38},  // 'Ι' + combining -> 'Ἰ'
-    {{0x0399, 0x0314}, 0x1F39},  // 'Ι' + combining -> 'Ἱ'
-    {{0x039F, 0x0300}, 0x1FF8},  // 'Ο' + combining -> 'Ὸ'
-    {{0x039F, 0x0301}, 0x038C},  // 'Ο' + combining -> 'Ό'
-    {{0x039F, 0x0313}, 0x1F48},  // 'Ο' + combining -> 'Ὀ'
-    {{0x039F, 0x0314}, 0x1F49},  // 'Ο' + combining -> 'Ὁ'
-    {{0x03A1, 0x0314}, 0x1FEC},  // 'Ρ' + combining -> 'Ῥ'
-    {{0x03A5, 0x0300}, 0x1FEA},  // 'Υ' + combining -> 'Ὺ'
-    {{0x03A5, 0x0301}, 0x038E},  // 'Υ' + combining -> 'Ύ'
-    {{0x03A5, 0x0304}, 0x1FE9},  // 'Υ' + combining -> 'Ῡ'
-    {{0x03A5, 0x0306}, 0x1FE8},  // 'Υ' + combining -> 'Ῠ'
-    {{0x03A5, 0x0308}, 0x03AB},  // 'Υ' + combining -> 'Ϋ'
-    {{0x03A5, 0x0314}, 0x1F59},  // 'Υ' + combining -> 'Ὑ'
-    {{0x03A9, 0x0300}, 0x1FFA},  // 'Ω' + combining -> 'Ὼ'
-    {{0x03A9, 0x0301}, 0x038F},  // 'Ω' + combining -> 'Ώ'
-    {{0x03A9, 0x0313}, 0x1F68},  // 'Ω' + combining -> 'Ὠ'
-    {{0x03A9, 0x0314}, 0x1F69},  // 'Ω' + combining -> 'Ὡ'
-    {{0x03A9, 0x0345}, 0x1FFC},  // 'Ω' + combining -> 'ῼ'
-    {{0x03AC, 0x0345}, 0x1FB4},  // 'ά' + combining -> 'ᾴ'
-    {{0x03AE, 0x0345}, 0x1FC4},  // 'ή' + combining -> 'ῄ'
-    {{0x03B1, 0x0300}, 0x1F70},  // 'α' + combining -> 'ὰ'
-    {{0x03B1, 0x0301}, 0x03AC},  // 'α' + combining -> 'ά'
-    {{0x03B1, 0x0304}, 0x1FB1},  // 'α' + combining -> 'ᾱ'
-    {{0x03B1, 0x0306}, 0x1FB0},  // 'α' + combining -> 'ᾰ'
-    {{0x03B1, 0x0313}, 0x1F00},  // 'α' + combining -> 'ἀ'
-    {{0x03B1, 0x0314}, 0x1F01},  // 'α' + combining -> 'ἁ'
-    {{0x03B1, 0x0342}, 0x1FB6},  // 'α' + combining -> 'ᾶ'
-    {{0x03B1, 0x0345}, 0x1FB3},  // 'α' + combining -> 'ᾳ'
-    {{0x03B5, 0x0300}, 0x1F72},  // 'ε' + combining -> 'ὲ'
-    {{0x03B5, 0x0301}, 0x03AD},  // 'ε' + combining -> 'έ'
-    {{0x03B5, 0x0313}, 0x1F10},  // 'ε' + combining -> 'ἐ'
-    {{0x03B5, 0x0314}, 0x1F11},  // 'ε' + combining -> 'ἑ'
-    {{0x03B7, 0x0300}, 0x1F74},  // 'η' + combining -> 'ὴ'
-    {{0x03B7, 0x0301}, 0x03AE},  // 'η' + combining -> 'ή'
-    {{0x03B7, 0x0313}, 0x1F20},  // 'η' + combining -> 'ἠ'
-    {{0x03B7, 0x0314}, 0x1F21},  // 'η' + combining -> 'ἡ'
-    {{0x03B7, 0x0342}, 0x1FC6},  // 'η' + combining -> 'ῆ'
-    {{0x03B7, 0x0345}, 0x1FC3},  // 'η' + combining -> 'ῃ'
-    {{0x03B9, 0x0300}, 0x1F76},  // 'ι' + combining -> 'ὶ'
-    {{0x03B9, 0x0301}, 0x03AF},  // 'ι' + combining -> 'ί'
-    {{0x03B9, 0x0304}, 0x1FD1},  // 'ι' + combining -> 'ῑ'
-    {{0x03B9, 0x0306}, 0x1FD0},  // 'ι' + combining -> 'ῐ'
-    {{0x03B9, 0x0308}, 0x03CA},  // 'ι' + combining -> 'ϊ'
-    {{0x03B9, 0x0313}, 0x1F30},  // 'ι' + combining -> 'ἰ'
-    {{0x03B9, 0x0314}, 0x1F31},  // 'ι' + combining -> 'ἱ'
-    {{0x03B9, 0x0342}, 0x1FD6},  // 'ι' + combining -> 'ῖ'
-    {{0x03BF, 0x0300}, 0x1F78},  // 'ο' + combining -> 'ὸ'
-    {{0x03BF, 0x0301}, 0x03CC},  // 'ο' + combining -> 'ό'
-    {{0x03BF, 0x0313}, 0x1F40},  // 'ο' + combining -> 'ὀ'
-    {{0x03BF, 0x0314}, 0x1F41},  // 'ο' + combining -> 'ὁ'
-    {{0x03C1, 0x0313}, 0x1FE4},  // 'ρ' + combining -> 'ῤ'
-    {{0x03C1, 0x0314}, 0x1FE5},  // 'ρ' + combining -> 'ῥ'
-    {{0x03C5, 0x0300}, 0x1F7A},  // 'υ' + combining -> 'ὺ'
-    {{0x03C5, 0x0301}, 0x03CD},  // 'υ' + combining -> 'ύ'
-    {{0x03C5, 0x0304}, 0x1FE1},  // 'υ' + combining -> 'ῡ'
-    {{0x03C5, 0x0306}, 0x1FE0},  // 'υ' + combining -> 'ῠ'
-    {{0x03C5, 0x0308}, 0x03CB},  // 'υ' + combining -> 'ϋ'
-    {{0x03C5, 0x0313}, 0x1F50},  // 'υ' + combining -> 'ὐ'
-    {{0x03C5, 0x0314}, 0x1F51},  // 'υ' + combining -> 'ὑ'
-    {{0x03C5, 0x0342}, 0x1FE6},  // 'υ' + combining -> 'ῦ'
-    {{0x03C9, 0x0300}, 0x1F7C},  // 'ω' + combining -> 'ὼ'
-    {{0x03C9, 0x0301}, 0x03CE},  // 'ω' + combining -> 'ώ'
-    {{0x03C9, 0x0313}, 0x1F60},  // 'ω' + combining -> 'ὠ'
-    {{0x03C9, 0x0314}, 0x1F61},  // 'ω' + combining -> 'ὡ'
-    {{0x03C9, 0x0342}, 0x1FF6},  // 'ω' + combining -> 'ῶ'
-    {{0x03C9, 0x0345}, 0x1FF3},  // 'ω' + combining -> 'ῳ'
-    {{0x03CA, 0x0300}, 0x1FD2},  // 'ϊ' + combining -> 'ῒ'
-    {{0x03CA, 0x0301}, 0x0390},  // 'ϊ' + combining -> 'ΐ'
-    {{0x03CA, 0x0342}, 0x1FD7},  // 'ϊ' + combining -> 'ῗ'
-    {{0x03CB, 0x0300}, 0x1FE2},  // 'ϋ' + combining -> 'ῢ'
-    {{0x03CB, 0x0301}, 0x03B0},  // 'ϋ' + combining -> 'ΰ'
-    {{0x03CB, 0x0342}, 0x1FE7},  // 'ϋ' + combining -> 'ῧ'
-    {{0x03CE, 0x0345}, 0x1FF4},  // 'ώ' + combining -> 'ῴ'
-    {{0x03D2, 0x0301}, 0x03D3},  // 'ϒ' + combining -> 'ϓ'
-    {{0x03D2, 0x0308}, 0x03D4},  // 'ϒ' + combining -> 'ϔ'
-    {{0x0406, 0x0308}, 0x0407},  // 'І' + combining -> 'Ї'
-    {{0x0410, 0x0306}, 0x04D0},  // 'А' + combining -> 'Ӑ'
-    {{0x0410, 0x0308}, 0x04D2},  // 'А' + combining -> 'Ӓ'
-    {{0x0413, 0x0301}, 0x0403},  // 'Г' + combining -> 'Ѓ'
-    {{0x0415, 0x0300}, 0x0400},  // 'Е' + combining -> 'Ѐ'
-    {{0x0415, 0x0306}, 0x04D6},  // 'Е' + combining -> 'Ӗ'
-    {{0x0415, 0x0308}, 0x0401},  // 'Е' + combining -> 'Ё'
-    {{0x0416, 0x0306}, 0x04C1},  // 'Ж' + combining -> 'Ӂ'
-    {{0x0416, 0x0308}, 0x04DC},  // 'Ж' + combining -> 'Ӝ'
-    {{0x0417, 0x0308}, 0x04DE},  // 'З' + combining -> 'Ӟ'
-    {{0x0418, 0x0300}, 0x040D},  // 'И' + combining -> 'Ѝ'
-    {{0x0418, 0x0304}, 0x04E2},  // 'И' + combining -> 'Ӣ'
-    {{0x0418, 0x0306}, 0x0419},  // 'И' + combining -> 'Й'
-    {{0x0418, 0x0308}, 0x04E4},  // 'И' + combining -> 'Ӥ'
-    {{0x041A, 0x0301}, 0x040C},  // 'К' + combining -> 'Ќ'
-    {{0x041E, 0x0308}, 0x04E6},  // 'О' + combining -> 'Ӧ'
-    {{0x0423, 0x0304}, 0x04EE},  // 'У' + combining -> 'Ӯ'
-    {{0x0423, 0x0306}, 0x040E},  // 'У' + combining -> 'Ў'
-    {{0x0423, 0x0308}, 0x04F0},  // 'У' + combining -> 'Ӱ'
-    {{0x0423, 0x030B}, 0x04F2},  // 'У' + combining -> 'Ӳ'
-    {{0x0427, 0x0308}, 0x04F4},  // 'Ч' + combining -> 'Ӵ'
-    {{0x042B, 0x0308}, 0x04F8},  // 'Ы' + combining -> 'Ӹ'
-    {{0x042D, 0x0308}, 0x04EC},  // 'Э' + combining -> 'Ӭ'
-    {{0x0430, 0x0306}, 0x04D1},  // 'а' + combining -> 'ӑ'
-    {{0x0430, 0x0308}, 0x04D3},  // 'а' + combining -> 'ӓ'
-    {{0x0433, 0x0301}, 0x0453},  // 'г' + combining -> 'ѓ'
-    {{0x0435, 0x0300}, 0x0450},  // 'е' + combining -> 'ѐ'
-    {{0x0435, 0x0306}, 0x04D7},  // 'е' + combining -> 'ӗ'
-    {{0x0435, 0x0308}, 0x0451},  // 'е' + combining -> 'ё'
-    {{0x0436, 0x0306}, 0x04C2},  // 'ж' + combining -> 'ӂ'
-    {{0x0436, 0x0308}, 0x04DD},  // 'ж' + combining -> 'ӝ'
-    {{0x0437, 0x0308}, 0x04DF},  // 'з' + combining -> 'ӟ'
-    {{0x0438, 0x0300}, 0x045D},  // 'и' + combining -> 'ѝ'
-    {{0x0438, 0x0304}, 0x04E3},  // 'и' + combining -> 'ӣ'
-    {{0x0438, 0x0306}, 0x0439},  // 'и' + combining -> 'й'
-    {{0x0438, 0x0308}, 0x04E5},  // 'и' + combining -> 'ӥ'
-    {{0x043A, 0x0301}, 0x045C},  // 'к' + combining -> 'ќ'
-    {{0x043E, 0x0308}, 0x04E7},  // 'о' + combining -> 'ӧ'
-    {{0x0443, 0x0304}, 0x04EF},  // 'у' + combining -> 'ӯ'
-    {{0x0443, 0x0306}, 0x045E},  // 'у' + combining -> 'ў'
-    {{0x0443, 0x0308}, 0x04F1},  // 'у' + combining -> 'ӱ'
-    {{0x0443, 0x030B}, 0x04F3},  // 'у' + combining -> 'ӳ'
-    {{0x0447, 0x0308}, 0x04F5},  // 'ч' + combining -> 'ӵ'
-    {{0x044B, 0x0308}, 0x04F9},  // 'ы' + combining -> 'ӹ'
-    {{0x044D, 0x0308}, 0x04ED},  // 'э' + combining -> 'ӭ'
-    {{0x0456, 0x0308}, 0x0457},  // 'і' + combining -> 'ї'
-    {{0x0474, 0x030F}, 0x0476},  // 'Ѵ' + combining -> 'Ѷ'
-    {{0x0475, 0x030F}, 0x0477},  // 'ѵ' + combining -> 'ѷ'
-    {{0x04D8, 0x0308}, 0x04DA},  // 'Ә' + combining -> 'Ӛ'
-    {{0x04D9, 0x0308}, 0x04DB},  // 'ә' + combining -> 'ӛ'
-    {{0x04E8, 0x0308}, 0x04EA},  // 'Ө' + combining -> 'Ӫ'
-    {{0x04E9, 0x0308}, 0x04EB},  // 'ө' + combining -> 'ӫ'
-    {{0x05D0, 0x05B7}, 0xFB2E},  // 'א' + combining -> 'אַ'
-    {{0x05D0, 0x05B8}, 0xFB2F},  // 'א' + combining -> 'אָ'
-    {{0x05D0, 0x05BC}, 0xFB30},  // 'א' + combining -> 'אּ'
-    {{0x05D1, 0x05BC}, 0xFB31},  // 'ב' + combining -> 'בּ'
-    {{0x05D1, 0x05BF}, 0xFB4C},  // 'ב' + combining -> 'בֿ'
-    {{0x05D2, 0x05BC}, 0xFB32},  // 'ג' + combining -> 'גּ'
-    {{0x05D3, 0x05BC}, 0xFB33},  // 'ד' + combining -> 'דּ'
-    {{0x05D4, 0x05BC}, 0xFB34},  // 'ה' + combining -> 'הּ'
-    {{0x05D5, 0x05B9}, 0xFB4B},  // 'ו' + combining -> 'וֹ'
-    {{0x05D5, 0x05BC}, 0xFB35},  // 'ו' + combining -> 'וּ'
-    {{0x05D6, 0x05BC}, 0xFB36},  // 'ז' + combining -> 'זּ'
-    {{0x05D8, 0x05BC}, 0xFB38},  // 'ט' + combining -> 'טּ'
-    {{0x05D9, 0x05B4}, 0xFB1D},  // 'י' + combining -> 'יִ'
-    {{0x05D9, 0x05BC}, 0xFB39},  // 'י' + combining -> 'יּ'
-    {{0x05DA, 0x05BC}, 0xFB3A},  // 'ך' + combining -> 'ךּ'
-    {{0x05DB, 0x05BC}, 0xFB3B},  // 'כ' + combining -> 'כּ'
-    {{0x05DB, 0x05BF}, 0xFB4D},  // 'כ' + combining -> 'כֿ'
-    {{0x05DC, 0x05BC}, 0xFB3C},  // 'ל' + combining -> 'לּ'
-    {{0x05DE, 0x05BC}, 0xFB3E},  // 'מ' + combining -> 'מּ'
-    {{0x05E0, 0x05BC}, 0xFB40},  // 'נ' + combining -> 'נּ'
-    {{0x05E1, 0x05BC}, 0xFB41},  // 'ס' + combining -> 'סּ'
-    {{0x05E3, 0x05BC}, 0xFB43},  // 'ף' + combining -> 'ףּ'
-    {{0x05E4, 0x05BC}, 0xFB44},  // 'פ' + combining -> 'פּ'
-    {{0x05E4, 0x05BF}, 0xFB4E},  // 'פ' + combining -> 'פֿ'
-    {{0x05E6, 0x05BC}, 0xFB46},  // 'צ' + combining -> 'צּ'
-    {{0x05E7, 0x05BC}, 0xFB47},  // 'ק' + combining -> 'קּ'
-    {{0x05E8, 0x05BC}, 0xFB48},  // 'ר' + combining -> 'רּ'
-    {{0x05E9, 0x05BC}, 0xFB49},  // 'ש' + combining -> 'שּ'
-    {{0x05E9, 0x05C1}, 0xFB2A},  // 'ש' + combining -> 'שׁ'
-    {{0x05E9, 0x05C2}, 0xFB2B},  // 'ש' + combining -> 'שׂ'
-    {{0x05EA, 0x05BC}, 0xFB4A},  // 'ת' + combining -> 'תּ'
-    {{0x05F2, 0x05B7}, 0xFB1F},  // 'ײ' + combining -> 'ײַ'
-    {{0x0627, 0x0653}, 0x0622},  // 'ا' + combining -> 'آ'
-    {{0x0627, 0x0654}, 0x0623},  // 'ا' + combining -> 'أ'
-    {{0x0627, 0x0655}, 0x0625},  // 'ا' + combining -> 'إ'
-    {{0x0648, 0x0654}, 0x0624},  // 'و' + combining -> 'ؤ'
-    {{0x064A, 0x0654}, 0x0626},  // 'ي' + combining -> 'ئ'
-    {{0x06C1, 0x0654}, 0x06C2},  // 'ہ' + combining -> 'ۂ'
-    {{0x06D2, 0x0654}, 0x06D3},  // 'ے' + combining -> 'ۓ'
-    {{0x06D5, 0x0654}, 0x06C0},  // 'ە' + combining -> 'ۀ'
-    {{0x0915, 0x093C}, 0x0958},  // 'क' + combining -> 'क़'
-    {{0x0916, 0x093C}, 0x0959},  // 'ख' + combining -> 'ख़'
-    {{0x0917, 0x093C}, 0x095A},  // 'ग' + combining -> 'ग़'
-    {{0x091C, 0x093C}, 0x095B},  // 'ज' + combining -> 'ज़'
-    {{0x0921, 0x093C}, 0x095C},  // 'ड' + combining -> 'ड़'
-    {{0x0922, 0x093C}, 0x095D},  // 'ढ' + combining -> 'ढ़'
-    {{0x0928, 0x093C}, 0x0929},  // 'न' + combining -> 'ऩ'
-    {{0x092B, 0x093C}, 0x095E},  // 'फ' + combining -> 'फ़'
-    {{0x092F, 0x093C}, 0x095F},  // 'य' + combining -> 'य़'
-    {{0x0930, 0x093C}, 0x0931},  // 'र' + combining -> 'ऱ'
-    {{0x0933, 0x093C}, 0x0934},  // 'ळ' + combining -> 'ऴ'
-    {{0x09A1, 0x09BC}, 0x09DC},  // 'ড' + combining -> 'ড়'
-    {{0x09A2, 0x09BC}, 0x09DD},  // 'ঢ' + combining -> 'ঢ়'
-    {{0x09AF, 0x09BC}, 0x09DF},  // 'য' + combining -> 'য়'
-    {{0x09C7, 0x09BE}, 0x09CB},  // 'ে' + combining -> 'ো'
-    {{0x09C7, 0x09D7}, 0x09CC},  // 'ে' + combining -> 'ৌ'
-    {{0x0A16, 0x0A3C}, 0x0A59},  // 'ਖ' + combining -> 'ਖ਼'
-    {{0x0A17, 0x0A3C}, 0x0A5A},  // 'ਗ' + combining -> 'ਗ਼'
-    {{0x0A1C, 0x0A3C}, 0x0A5B},  // 'ਜ' + combining -> 'ਜ਼'
-    {{0x0A2B, 0x0A3C}, 0x0A5E},  // 'ਫ' + combining -> 'ਫ਼'
-    {{0x0A32, 0x0A3C}, 0x0A33},  // 'ਲ' + combining -> 'ਲ਼'
-    {{0x0A38, 0x0A3C}, 0x0A36},  // 'ਸ' + combining -> 'ਸ਼'
-    {{0x0B21, 0x0B3C}, 0x0B5C},  // 'ଡ' + combining -> 'ଡ଼'
-    {{0x0B22, 0x0B3C}, 0x0B5D},  // 'ଢ' + combining -> 'ଢ଼'
-    {{0x0B47, 0x0B3E}, 0x0B4B},  // 'େ' + combining -> 'ୋ'
-    {{0x0B47, 0x0B56}, 0x0B48},  // 'େ' + combining -> 'ୈ'
-    {{0x0B47, 0x0B57}, 0x0B4C},  // 'େ' + combining -> 'ୌ'
-    {{0x0B92, 0x0BD7}, 0x0B94},  // 'ஒ' + combining -> 'ஔ'
-    {{0x0BC6, 0x0BBE}, 0x0BCA},  // 'ெ' + combining -> 'ொ'
-    {{0x0BC6, 0x0BD7}, 0x0BCC},  // 'ெ' + combining -> 'ௌ'
-    {{0x0BC7, 0x0BBE}, 0x0BCB},  // 'ே' + combining -> 'ோ'
-    {{0x0C46, 0x0C56}, 0x0C48},  // 'ె' + combining -> 'ై'
-    {{0x0CBF, 0x0CD5}, 0x0CC0},  // 'ಿ' + combining -> 'ೀ'
-    {{0x0CC6, 0x0CC2}, 0x0CCA},  // 'ೆ' + combining -> 'ೊ'
-    {{0x0CC6, 0x0CD5}, 0x0CC7},  // 'ೆ' + combining -> 'ೇ'
-    {{0x0CC6, 0x0CD6}, 0x0CC8},  // 'ೆ' + combining -> 'ೈ'
-    {{0x0CCA, 0x0CD5}, 0x0CCB},  // 'ೊ' + combining -> 'ೋ'
-    {{0x0D46, 0x0D3E}, 0x0D4A},  // 'െ' + combining -> 'ൊ'
-    {{0x0D46, 0x0D57}, 0x0D4C},  // 'െ' + combining -> 'ൌ'
-    {{0x0D47, 0x0D3E}, 0x0D4B},  // 'േ' + combining -> 'ോ'
-    {{0x0DD9, 0x0DCA}, 0x0DDA},  // 'ෙ' + combining -> 'ේ'
-    {{0x0DD9, 0x0DCF}, 0x0DDC},  // 'ෙ' + combining -> 'ො'
-    {{0x0DD9, 0x0DDF}, 0x0DDE},  // 'ෙ' + combining -> 'ෞ'
-    {{0x0DDC, 0x0DCA}, 0x0DDD},  // 'ො' + combining -> 'ෝ'
-    {{0x0F40, 0x0FB5}, 0x0F69},  // 'ཀ' + combining -> 'ཀྵ'
-    {{0x0F42, 0x0FB7}, 0x0F43},  // 'ག' + combining -> 'གྷ'
-    {{0x0F4C, 0x0FB7}, 0x0F4D},  // 'ཌ' + combining -> 'ཌྷ'
-    {{0x0F51, 0x0FB7}, 0x0F52},  // 'ད' + combining -> 'དྷ'
-    {{0x0F56, 0x0FB7}, 0x0F57},  // 'བ' + combining -> 'བྷ'
-    {{0x0F5B, 0x0FB7}, 0x0F5C},  // 'ཛ' + combining -> 'ཛྷ'
-    {{0x0F71, 0x0F72}, 0x0F73},  // 'ཱ' + combining -> 'ཱི'
-    {{0x0F71, 0x0F74}, 0x0F75},  // 'ཱ' + combining -> 'ཱུ'
-    {{0x0F71, 0x0F80}, 0x0F81},  // 'ཱ' + combining -> 'ཱྀ'
-    {{0x0F90, 0x0FB5}, 0x0FB9},  // 'ྐ' + combining -> 'ྐྵ'
-    {{0x0F92, 0x0FB7}, 0x0F93},  // 'ྒ' + combining -> 'ྒྷ'
-    {{0x0F9C, 0x0FB7}, 0x0F9D},  // 'ྜ' + combining -> 'ྜྷ'
-    {{0x0FA1, 0x0FB7}, 0x0FA2},  // 'ྡ' + combining -> 'ྡྷ'
-    {{0x0FA6, 0x0FB7}, 0x0FA7},  // 'ྦ' + combining -> 'ྦྷ'
-    {{0x0FAB, 0x0FB7}, 0x0FAC},  // 'ྫ' + combining -> 'ྫྷ'
-    {{0x0FB2, 0x0F80}, 0x0F76},  // 'ྲ' + combining -> 'ྲྀ'
-    {{0x0FB3, 0x0F80}, 0x0F78},  // 'ླ' + combining -> 'ླྀ'
-    {{0x1025, 0x102E}, 0x1026},  // 'ဥ' + combining -> 'ဦ'
-    {{0x1B05, 0x1B35}, 0x1B06},  // 'ᬅ' + combining -> 'ᬆ'
-    {{0x1B07, 0x1B35}, 0x1B08},  // 'ᬇ' + combining -> 'ᬈ'
-    {{0x1B09, 0x1B35}, 0x1B0A},  // 'ᬉ' + combining -> 'ᬊ'
-    {{0x1B0B, 0x1B35}, 0x1B0C},  // 'ᬋ' + combining -> 'ᬌ'
-    {{0x1B0D, 0x1B35}, 0x1B0E},  // 'ᬍ' + combining -> 'ᬎ'
-    {{0x1B11, 0x1B35}, 0x1B12},  // 'ᬑ' + combining -> 'ᬒ'
-    {{0x1B3A, 0x1B35}, 0x1B3B},  // 'ᬺ' + combining -> 'ᬻ'
-    {{0x1B3C, 0x1B35}, 0x1B3D},  // 'ᬼ' + combining -> 'ᬽ'
-    {{0x1B3E, 0x1B35}, 0x1B40},  // 'ᬾ' + combining -> 'ᭀ'
-    {{0x1B3F, 0x1B35}, 0x1B41},  // 'ᬿ' + combining -> 'ᭁ'
-    {{0x1B42, 0x1B35}, 0x1B43},  // 'ᭂ' + combining -> 'ᭃ'
-    {{0x1E36, 0x0304}, 0x1E38},  // 'Ḷ' + combining -> 'Ḹ'
-    {{0x1E37, 0x0304}, 0x1E39},  // 'ḷ' + combining -> 'ḹ'
-    {{0x1E5A, 0x0304}, 0x1E5C},  // 'Ṛ' + combining -> 'Ṝ'
-    {{0x1E5B, 0x0304}, 0x1E5D},  // 'ṛ' + combining -> 'ṝ'
-    {{0x1E62, 0x0307}, 0x1E68},  // 'Ṣ' + combining -> 'Ṩ'
-    {{0x1E63, 0x0307}, 0x1E69},  // 'ṣ' + combining -> 'ṩ'
-    {{0x1EA0, 0x0302}, 0x1EAC},  // 'Ạ' + combining -> 'Ậ'
-    {{0x1EA0, 0x0306}, 0x1EB6},  // 'Ạ' + combining -> 'Ặ'
-    {{0x1EA1, 0x0302}, 0x1EAD},  // 'ạ' + combining -> 'ậ'
-    {{0x1EA1, 0x0306}, 0x1EB7},  // 'ạ' + combining -> 'ặ'
-    {{0x1EB8, 0x0302}, 0x1EC6},  // 'Ẹ' + combining -> 'Ệ'
-    {{0x1EB9, 0x0302}, 0x1EC7},  // 'ẹ' + combining -> 'ệ'
-    {{0x1ECC, 0x0302}, 0x1ED8},  // 'Ọ' + combining -> 'Ộ'
-    {{0x1ECD, 0x0302}, 0x1ED9},  // 'ọ' + combining -> 'ộ'
-    {{0x1F00, 0x0300}, 0x1F02},  // 'ἀ' + combining -> 'ἂ'
-    {{0x1F00, 0x0301}, 0x1F04},  // 'ἀ' + combining -> 'ἄ'
-    {{0x1F00, 0x0342}, 0x1F06},  // 'ἀ' + combining -> 'ἆ'
-    {{0x1F00, 0x0345}, 0x1F80},  // 'ἀ' + combining -> 'ᾀ'
-    {{0x1F01, 0x0300}, 0x1F03},  // 'ἁ' + combining -> 'ἃ'
-    {{0x1F01, 0x0301}, 0x1F05},  // 'ἁ' + combining -> 'ἅ'
-    {{0x1F01, 0x0342}, 0x1F07},  // 'ἁ' + combining -> 'ἇ'
-    {{0x1F01, 0x0345}, 0x1F81},  // 'ἁ' + combining -> 'ᾁ'
-    {{0x1F02, 0x0345}, 0x1F82},  // 'ἂ' + combining -> 'ᾂ'
-    {{0x1F03, 0x0345}, 0x1F83},  // 'ἃ' + combining -> 'ᾃ'
-    {{0x1F04, 0x0345}, 0x1F84},  // 'ἄ' + combining -> 'ᾄ'
-    {{0x1F05, 0x0345}, 0x1F85},  // 'ἅ' + combining -> 'ᾅ'
-    {{0x1F06, 0x0345}, 0x1F86},  // 'ἆ' + combining -> 'ᾆ'
-    {{0x1F07, 0x0345}, 0x1F87},  // 'ἇ' + combining -> 'ᾇ'
-    {{0x1F08, 0x0300}, 0x1F0A},  // 'Ἀ' + combining -> 'Ἂ'
-    {{0x1F08, 0x0301}, 0x1F0C},  // 'Ἀ' + combining -> 'Ἄ'
-    {{0x1F08, 0x0342}, 0x1F0E},  // 'Ἀ' + combining -> 'Ἆ'
-    {{0x1F08, 0x0345}, 0x1F88},  // 'Ἀ' + combining -> 'ᾈ'
-    {{0x1F09, 0x0300}, 0x1F0B},  // 'Ἁ' + combining -> 'Ἃ'
-    {{0x1F09, 0x0301}, 0x1F0D},  // 'Ἁ' + combining -> 'Ἅ'
-    {{0x1F09, 0x0342}, 0x1F0F},  // 'Ἁ' + combining -> 'Ἇ'
-    {{0x1F09, 0x0345}, 0x1F89},  // 'Ἁ' + combining -> 'ᾉ'
-    {{0x1F0A, 0x0345}, 0x1F8A},  // 'Ἂ' + combining -> 'ᾊ'
-    {{0x1F0B, 0x0345}, 0x1F8B},  // 'Ἃ' + combining -> 'ᾋ'
-    {{0x1F0C, 0x0345}, 0x1F8C},  // 'Ἄ' + combining -> 'ᾌ'
-    {{0x1F0D, 0x0345}, 0x1F8D},  // 'Ἅ' + combining -> 'ᾍ'
-    {{0x1F0E, 0x0345}, 0x1F8E},  // 'Ἆ' + combining -> 'ᾎ'
-    {{0x1F0F, 0x0345}, 0x1F8F},  // 'Ἇ' + combining -> 'ᾏ'
-    {{0x1F10, 0x0300}, 0x1F12},  // 'ἐ' + combining -> 'ἒ'
-    {{0x1F10, 0x0301}, 0x1F14},  // 'ἐ' + combining -> 'ἔ'
-    {{0x1F11, 0x0300}, 0x1F13},  // 'ἑ' + combining -> 'ἓ'
-    {{0x1F11, 0x0301}, 0x1F15},  // 'ἑ' + combining -> 'ἕ'
-    {{0x1F18, 0x0300}, 0x1F1A},  // 'Ἐ' + combining -> 'Ἒ'
-    {{0x1F18, 0x0301}, 0x1F1C},  // 'Ἐ' + combining -> 'Ἔ'
-    {{0x1F19, 0x0300}, 0x1F1B},  // 'Ἑ' + combining -> 'Ἓ'
-    {{0x1F19, 0x0301}, 0x1F1D},  // 'Ἑ' + combining -> 'Ἕ'
-    {{0x1F20, 0x0300}, 0x1F22},  // 'ἠ' + combining -> 'ἢ'
-    {{0x1F20, 0x0301}, 0x1F24},  // 'ἠ' + combining -> 'ἤ'
-    {{0x1F20, 0x0342}, 0x1F26},  // 'ἠ' + combining -> 'ἦ'
-    {{0x1F20, 0x0345}, 0x1F90},  // 'ἠ' + combining -> 'ᾐ'
-    {{0x1F21, 0x0300}, 0x1F23},  // 'ἡ' + combining -> 'ἣ'
-    {{0x1F21, 0x0301}, 0x1F25},  // 'ἡ' + combining -> 'ἥ'
-    {{0x1F21, 0x0342}, 0x1F27},  // 'ἡ' + combining -> 'ἧ'
-    {{0x1F21, 0x0345}, 0x1F91},  // 'ἡ' + combining -> 'ᾑ'
-    {{0x1F22, 0x0345}, 0x1F92},  // 'ἢ' + combining -> 'ᾒ'
-    {{0x1F23, 0x0345}, 0x1F93},  // 'ἣ' + combining -> 'ᾓ'
-    {{0x1F24, 0x0345}, 0x1F94},  // 'ἤ' + combining -> 'ᾔ'
-    {{0x1F25, 0x0345}, 0x1F95},  // 'ἥ' + combining -> 'ᾕ'
-    {{0x1F26, 0x0345}, 0x1F96},  // 'ἦ' + combining -> 'ᾖ'
-    {{0x1F27, 0x0345}, 0x1F97},  // 'ἧ' + combining -> 'ᾗ'
-    {{0x1F28, 0x0300}, 0x1F2A},  // 'Ἠ' + combining -> 'Ἢ'
-    {{0x1F28, 0x0301}, 0x1F2C},  // 'Ἠ' + combining -> 'Ἤ'
-    {{0x1F28, 0x0342}, 0x1F2E},  // 'Ἠ' + combining -> 'Ἦ'
-    {{0x1F28, 0x0345}, 0x1F98},  // 'Ἠ' + combining -> 'ᾘ'
-    {{0x1F29, 0x0300}, 0x1F2B},  // 'Ἡ' + combining -> 'Ἣ'
-    {{0x1F29, 0x0301}, 0x1F2D},  // 'Ἡ' + combining -> 'Ἥ'
-    {{0x1F29, 0x0342}, 0x1F2F},  // 'Ἡ' + combining -> 'Ἧ'
-    {{0x1F29, 0x0345}, 0x1F99},  // 'Ἡ' + combining -> 'ᾙ'
-    {{0x1F2A, 0x0345}, 0x1F9A},  // 'Ἢ' + combining -> 'ᾚ'
-    {{0x1F2B, 0x0345}, 0x1F9B},  // 'Ἣ' + combining -> 'ᾛ'
-    {{0x1F2C, 0x0345}, 0x1F9C},  // 'Ἤ' + combining -> 'ᾜ'
-    {{0x1F2D, 0x0345}, 0x1F9D},  // 'Ἥ' + combining -> 'ᾝ'
-    {{0x1F2E, 0x0345}, 0x1F9E},  // 'Ἦ' + combining -> 'ᾞ'
-    {{0x1F2F, 0x0345}, 0x1F9F},  // 'Ἧ' + combining -> 'ᾟ'
-    {{0x1F30, 0x0300}, 0x1F32},  // 'ἰ' + combining -> 'ἲ'
-    {{0x1F30, 0x0301}, 0x1F34},  // 'ἰ' + combining -> 'ἴ'
-    {{0x1F30, 0x0342}, 0x1F36},  // 'ἰ' + combining -> 'ἶ'
-    {{0x1F31, 0x0300}, 0x1F33},  // 'ἱ' + combining -> 'ἳ'
-    {{0x1F31, 0x0301}, 0x1F35},  // 'ἱ' + combining -> 'ἵ'
-    {{0x1F31, 0x0342}, 0x1F37},  // 'ἱ' + combining -> 'ἷ'
-    {{0x1F38, 0x0300}, 0x1F3A},  // 'Ἰ' + combining -> 'Ἲ'
-    {{0x1F38, 0x0301}, 0x1F3C},  // 'Ἰ' + combining -> 'Ἴ'
-    {{0x1F38, 0x0342}, 0x1F3E},  // 'Ἰ' + combining -> 'Ἶ'
-    {{0x1F39, 0x0300}, 0x1F3B},  // 'Ἱ' + combining -> 'Ἳ'
-    {{0x1F39, 0x0301}, 0x1F3D},  // 'Ἱ' + combining -> 'Ἵ'
-    {{0x1F39, 0x0342}, 0x1F3F},  // 'Ἱ' + combining -> 'Ἷ'
-    {{0x1F40, 0x0300}, 0x1F42},  // 'ὀ' + combining -> 'ὂ'
-    {{0x1F40, 0x0301}, 0x1F44},  // 'ὀ' + combining -> 'ὄ'
-    {{0x1F41, 0x0300}, 0x1F43},  // 'ὁ' + combining -> 'ὃ'
-    {{0x1F41, 0x0301}, 0x1F45},  // 'ὁ' + combining -> 'ὅ'
-    {{0x1F48, 0x0300}, 0x1F4A},  // 'Ὀ' + combining -> 'Ὂ'
-    {{0x1F48, 0x0301}, 0x1F4C},  // 'Ὀ' + combining -> 'Ὄ'
-    {{0x1F49, 0x0300}, 0x1F4B},  // 'Ὁ' + combining -> 'Ὃ'
-    {{0x1F49, 0x0301}, 0x1F4D},  // 'Ὁ' + combining -> 'Ὅ'
-    {{0x1F50, 0x0300}, 0x1F52},  // 'ὐ' + combining -> 'ὒ'
-    {{0x1F50, 0x0301}, 0x1F54},  // 'ὐ' + combining -> 'ὔ'
-    {{0x1F50, 0x0342}, 0x1F56},  // 'ὐ' + combining -> 'ὖ'
-    {{0x1F51, 0x0300}, 0x1F53},  // 'ὑ' + combining -> 'ὓ'
-    {{0x1F51, 0x0301}, 0x1F55},  // 'ὑ' + combining -> 'ὕ'
-    {{0x1F51, 0x0342}, 0x1F57},  // 'ὑ' + combining -> 'ὗ'
-    {{0x1F59, 0x0300}, 0x1F5B},  // 'Ὑ' + combining -> 'Ὓ'
-    {{0x1F59, 0x0301}, 0x1F5D},  // 'Ὑ' + combining -> 'Ὕ'
-    {{0x1F59, 0x0342}, 0x1F5F},  // 'Ὑ' + combining -> 'Ὗ'
-    {{0x1F60, 0x0300}, 0x1F62},  // 'ὠ' + combining -> 'ὢ'
-    {{0x1F60, 0x0301}, 0x1F64},  // 'ὠ' + combining -> 'ὤ'
-    {{0x1F60, 0x0342}, 0x1F66},  // 'ὠ' + combining -> 'ὦ'
-    {{0x1F60, 0x0345}, 0x1FA0},  // 'ὠ' + combining -> 'ᾠ'
-    {{0x1F61, 0x0300}, 0x1F63},  // 'ὡ' + combining -> 'ὣ'
-    {{0x1F61, 0x0301}, 0x1F65},  // 'ὡ' + combining -> 'ὥ'
-    {{0x1F61, 0x0342}, 0x1F67},  // 'ὡ' + combining -> 'ὧ'
-    {{0x1F61, 0x0345}, 0x1FA1},  // 'ὡ' + combining -> 'ᾡ'
-    {{0x1F62, 0x0345}, 0x1FA2},  // 'ὢ' + combining -> 'ᾢ'
-    {{0x1F63, 0x0345}, 0x1FA3},  // 'ὣ' + combining -> 'ᾣ'
-    {{0x1F64, 0x0345}, 0x1FA4},  // 'ὤ' + combining -> 'ᾤ'
-    {{0x1F65, 0x0345}, 0x1FA5},  // 'ὥ' + combining -> 'ᾥ'
-    {{0x1F66, 0x0345}, 0x1FA6},  // 'ὦ' + combining -> 'ᾦ'
-    {{0x1F67, 0x0345}, 0x1FA7},  // 'ὧ' + combining -> 'ᾧ'
-    {{0x1F68, 0x0300}, 0x1F6A},  // 'Ὠ' + combining -> 'Ὢ'
-    {{0x1F68, 0x0301}, 0x1F6C},  // 'Ὠ' + combining -> 'Ὤ'
-    {{0x1F68, 0x0342}, 0x1F6E},  // 'Ὠ' + combining -> 'Ὦ'
-    {{0x1F68, 0x0345}, 0x1FA8},  // 'Ὠ' + combining -> 'ᾨ'
-    {{0x1F69, 0x0300}, 0x1F6B},  // 'Ὡ' + combining -> 'Ὣ'
-    {{0x1F69, 0x0301}, 0x1F6D},  // 'Ὡ' + combining -> 'Ὥ'
-    {{0x1F69, 0x0342}, 0x1F6F},  // 'Ὡ' + combining -> 'Ὧ'
-    {{0x1F69, 0x0345}, 0x1FA9},  // 'Ὡ' + combining -> 'ᾩ'
-    {{0x1F6A, 0x0345}, 0x1FAA},  // 'Ὢ' + combining -> 'ᾪ'
-    {{0x1F6B, 0x0345}, 0x1FAB},  // 'Ὣ' + combining -> 'ᾫ'
-    {{0x1F6C, 0x0345}, 0x1FAC},  // 'Ὤ' + combining -> 'ᾬ'
-    {{0x1F6D, 0x0345}, 0x1FAD},  // 'Ὥ' + combining -> 'ᾭ'
-    {{0x1F6E, 0x0345}, 0x1FAE},  // 'Ὦ' + combining -> 'ᾮ'
-    {{0x1F6F, 0x0345}, 0x1FAF},  // 'Ὧ' + combining -> 'ᾯ'
-    {{0x1F70, 0x0345}, 0x1FB2},  // 'ὰ' + combining -> 'ᾲ'
-    {{0x1F74, 0x0345}, 0x1FC2},  // 'ὴ' + combining -> 'ῂ'
-    {{0x1F7C, 0x0345}, 0x1FF2},  // 'ὼ' + combining -> 'ῲ'
-    {{0x1FB6, 0x0345}, 0x1FB7},  // 'ᾶ' + combining -> 'ᾷ'
-    {{0x1FBF, 0x0300}, 0x1FCD},  // '᾿' + combining -> '῍'
-    {{0x1FBF, 0x0301}, 0x1FCE},  // '᾿' + combining -> '῎'
-    {{0x1FBF, 0x0342}, 0x1FCF},  // '᾿' + combining -> '῏'
-    {{0x1FC6, 0x0345}, 0x1FC7},  // 'ῆ' + combining -> 'ῇ'
-    {{0x1FF6, 0x0345}, 0x1FF7},  // 'ῶ' + combining -> 'ῷ'
-    {{0x1FFE, 0x0300}, 0x1FDD},  // '῾' + combining -> '῝'
-    {{0x1FFE, 0x0301}, 0x1FDE},  // '῾' + combining -> '῞'
-    {{0x1FFE, 0x0342}, 0x1FDF},  // '῾' + combining -> '῟'
-    {{0x2190, 0x0338}, 0x219A},  // '←' + combining -> '↚'
-    {{0x2192, 0x0338}, 0x219B},  // '→' + combining -> '↛'
-    {{0x2194, 0x0338}, 0x21AE},  // '↔' + combining -> '↮'
-    {{0x21D0, 0x0338}, 0x21CD},  // '⇐' + combining -> '⇍'
-    {{0x21D2, 0x0338}, 0x21CF},  // '⇒' + combining -> '⇏'
-    {{0x21D4, 0x0338}, 0x21CE},  // '⇔' + combining -> '⇎'
-    {{0x2203, 0x0338}, 0x2204},  // '∃' + combining -> '∄'
-    {{0x2208, 0x0338}, 0x2209},  // '∈' + combining -> '∉'
-    {{0x220B, 0x0338}, 0x220C},  // '∋' + combining -> '∌'
-    {{0x2223, 0x0338}, 0x2224},  // '∣' + combining -> '∤'
-    {{0x2225, 0x0338}, 0x2226},  // '∥' + combining -> '∦'
-    {{0x223C, 0x0338}, 0x2241},  // '∼' + combining -> '≁'
-    {{0x2243, 0x0338}, 0x2244},  // '≃' + combining -> '≄'
-    {{0x2245, 0x0338}, 0x2247},  // '≅' + combining -> '≇'
-    {{0x2248, 0x0338}, 0x2249},  // '≈' + combining -> '≉'
-    {{0x224D, 0x0338}, 0x226D},  // '≍' + combining -> '≭'
-    {{0x2261, 0x0338}, 0x2262},  // '≡' + combining -> '≢'
-    {{0x2264, 0x0338}, 0x2270},  // '≤' + combining -> '≰'
-    {{0x2265, 0x0338}, 0x2271},  // '≥' + combining -> '≱'
-    {{0x2272, 0x0338}, 0x2274},  // '≲' + combining -> '≴'
-    {{0x2273, 0x0338}, 0x2275},  // '≳' + combining -> '≵'
-    {{0x2276, 0x0338}, 0x2278},  // '≶' + combining -> '≸'
-    {{0x2277, 0x0338}, 0x2279},  // '≷' + combining -> '≹'
-    {{0x227A, 0x0338}, 0x2280},  // '≺' + combining -> '⊀'
-    {{0x227B, 0x0338}, 0x2281},  // '≻' + combining -> '⊁'
-    {{0x227C, 0x0338}, 0x22E0},  // '≼' + combining -> '⋠'
-    {{0x227D, 0x0338}, 0x22E1},  // '≽' + combining -> '⋡'
-    {{0x2282, 0x0338}, 0x2284},  // '⊂' + combining -> '⊄'
-    {{0x2283, 0x0338}, 0x2285},  // '⊃' + combining -> '⊅'
-    {{0x2286, 0x0338}, 0x2288},  // '⊆' + combining -> '⊈'
-    {{0x2287, 0x0338}, 0x2289},  // '⊇' + combining -> '⊉'
-    {{0x2291, 0x0338}, 0x22E2},  // '⊑' + combining -> '⋢'
-    {{0x2292, 0x0338}, 0x22E3},  // '⊒' + combining -> '⋣'
-    {{0x22A2, 0x0338}, 0x22AC},  // '⊢' + combining -> '⊬'
-    {{0x22A8, 0x0338}, 0x22AD},  // '⊨' + combining -> '⊭'
-    {{0x22A9, 0x0338}, 0x22AE},  // '⊩' + combining -> '⊮'
-    {{0x22AB, 0x0338}, 0x22AF},  // '⊫' + combining -> '⊯'
-    {{0x22B2, 0x0338}, 0x22EA},  // '⊲' + combining -> '⋪'
-    {{0x22B3, 0x0338}, 0x22EB},  // '⊳' + combining -> '⋫'
-    {{0x22B4, 0x0338}, 0x22EC},  // '⊴' + combining -> '⋬'
-    {{0x22B5, 0x0338}, 0x22ED},  // '⊵' + combining -> '⋭'
-    {{0x2ADD, 0x0338}, 0x2ADC},  // '⫝' + combining -> '⫝̸'
-    {{0x3046, 0x3099}, 0x3094},  // 'う' + combining -> 'ゔ'
-    {{0x304B, 0x3099}, 0x304C},  // 'か' + combining -> 'が'
-    {{0x304D, 0x3099}, 0x304E},  // 'き' + combining -> 'ぎ'
-    {{0x304F, 0x3099}, 0x3050},  // 'く' + combining -> 'ぐ'
-    {{0x3051, 0x3099}, 0x3052},  // 'け' + combining -> 'げ'
-    {{0x3053, 0x3099}, 0x3054},  // 'こ' + combining -> 'ご'
-    {{0x3055, 0x3099}, 0x3056},  // 'さ' + combining -> 'ざ'
-    {{0x3057, 0x3099}, 0x3058},  // 'し' + combining -> 'じ'
-    {{0x3059, 0x3099}, 0x305A},  // 'す' + combining -> 'ず'
-    {{0x305B, 0x3099}, 0x305C},  // 'せ' + combining -> 'ぜ'
-    {{0x305D, 0x3099}, 0x305E},  // 'そ' + combining -> 'ぞ'
-    {{0x305F, 0x3099}, 0x3060},  // 'た' + combining -> 'だ'
-    {{0x3061, 0x3099}, 0x3062},  // 'ち' + combining -> 'ぢ'
-    {{0x3064, 0x3099}, 0x3065},  // 'つ' + combining -> 'づ'
-    {{0x3066, 0x3099}, 0x3067},  // 'て' + combining -> 'で'
-    {{0x3068, 0x3099}, 0x3069},  // 'と' + combining -> 'ど'
-    {{0x306F, 0x3099}, 0x3070},  // 'は' + combining -> 'ば'
-    {{0x306F, 0x309A}, 0x3071},  // 'は' + combining -> 'ぱ'
-    {{0x3072, 0x3099}, 0x3073},  // 'ひ' + combining -> 'び'
-    {{0x3072, 0x309A}, 0x3074},  // 'ひ' + combining -> 'ぴ'
-    {{0x3075, 0x3099}, 0x3076},  // 'ふ' + combining -> 'ぶ'
-    {{0x3075, 0x309A}, 0x3077},  // 'ふ' + combining -> 'ぷ'
-    {{0x3078, 0x3099}, 0x3079},  // 'へ' + combining -> 'べ'
-    {{0x3078, 0x309A}, 0x307A},  // 'へ' + combining -> 'ぺ'
-    {{0x307B, 0x3099}, 0x307C},  // 'ほ' + combining -> 'ぼ'
-    {{0x307B, 0x309A}, 0x307D},  // 'ほ' + combining -> 'ぽ'
-    {{0x309D, 0x3099}, 0x309E},  // 'ゝ' + combining -> 'ゞ'
-    {{0x30A6, 0x3099}, 0x30F4},  // 'ウ' + combining -> 'ヴ'
-    {{0x30AB, 0x3099}, 0x30AC},  // 'カ' + combining -> 'ガ'
-    {{0x30AD, 0x3099}, 0x30AE},  // 'キ' + combining -> 'ギ'
-    {{0x30AF, 0x3099}, 0x30B0},  // 'ク' + combining -> 'グ'
-    {{0x30B1, 0x3099}, 0x30B2},  // 'ケ' + combining -> 'ゲ'
-    {{0x30B3, 0x3099}, 0x30B4},  // 'コ' + combining -> 'ゴ'
-    {{0x30B5, 0x3099}, 0x30B6},  // 'サ' + combining -> 'ザ'
-    {{0x30B7, 0x3099}, 0x30B8},  // 'シ' + combining -> 'ジ'
-    {{0x30B9, 0x3099}, 0x30BA},  // 'ス' + combining -> 'ズ'
-    {{0x30BB, 0x3099}, 0x30BC},  // 'セ' + combining -> 'ゼ'
-    {{0x30BD, 0x3099}, 0x30BE},  // 'ソ' + combining -> 'ゾ'
-    {{0x30BF, 0x3099}, 0x30C0},  // 'タ' + combining -> 'ダ'
-    {{0x30C1, 0x3099}, 0x30C2},  // 'チ' + combining -> 'ヂ'
-    {{0x30C4, 0x3099}, 0x30C5},  // 'ツ' + combining -> 'ヅ'
-    {{0x30C6, 0x3099}, 0x30C7},  // 'テ' + combining -> 'デ'
-    {{0x30C8, 0x3099}, 0x30C9},  // 'ト' + combining -> 'ド'
-    {{0x30CF, 0x3099}, 0x30D0},  // 'ハ' + combining -> 'バ'
-    {{0x30CF, 0x309A}, 0x30D1},  // 'ハ' + combining -> 'パ'
-    {{0x30D2, 0x3099}, 0x30D3},  // 'ヒ' + combining -> 'ビ'
-    {{0x30D2, 0x309A}, 0x30D4},  // 'ヒ' + combining -> 'ピ'
-    {{0x30D5, 0x3099}, 0x30D6},  // 'フ' + combining -> 'ブ'
-    {{0x30D5, 0x309A}, 0x30D7},  // 'フ' + combining -> 'プ'
-    {{0x30D8, 0x3099}, 0x30D9},  // 'ヘ' + combining -> 'ベ'
-    {{0x30D8, 0x309A}, 0x30DA},  // 'ヘ' + combining -> 'ペ'
-    {{0x30DB, 0x3099}, 0x30DC},  // 'ホ' + combining -> 'ボ'
-    {{0x30DB, 0x309A}, 0x30DD},  // 'ホ' + combining -> 'ポ'
-    {{0x30EF, 0x3099}, 0x30F7},  // 'ワ' + combining -> 'ヷ'
-    {{0x30F0, 0x3099}, 0x30F8},  // 'ヰ' + combining -> 'ヸ'
-    {{0x30F1, 0x3099}, 0x30F9},  // 'ヱ' + combining -> 'ヹ'
-    {{0x30F2, 0x3099}, 0x30FA},  // 'ヲ' + combining -> 'ヺ'
-    {{0x30FD, 0x3099}, 0x30FE},  // 'ヽ' + combining -> 'ヾ'
-    {{0xFB49, 0x05C1}, 0xFB2C},  // 'שּ' + combining -> 'שּׁ'
-    {{0xFB49, 0x05C2}, 0xFB2D},  // 'שּ' + combining -> 'שּׂ'
-    {{0x105D2, 0x0307}, 0x105C9},
-    {{0x105DA, 0x0307}, 0x105E4},
-    {{0x11099, 0x110BA}, 0x1109A},  // '𑂙' + combining -> '𑂚'
-    {{0x1109B, 0x110BA}, 0x1109C},  // '𑂛' + combining -> '𑂜'
-    {{0x110A5, 0x110BA}, 0x110AB},  // '𑂥' + combining -> '𑂫'
-    {{0x11131, 0x11127}, 0x1112E},  // '𑄱' + combining -> '𑄮'
-    {{0x11132, 0x11127}, 0x1112F},  // '𑄲' + combining -> '𑄯'
-    {{0x11347, 0x1133E}, 0x1134B},  // '𑍇' + combining -> '𑍋'
-    {{0x11347, 0x11357}, 0x1134C},  // '𑍇' + combining -> '𑍌'
-    {{0x11382, 0x113C9}, 0x11383},
-    {{0x11384, 0x113BB}, 0x11385},
-    {{0x1138B, 0x113C2}, 0x1138E},
-    {{0x11390, 0x113C9}, 0x11391},
-    {{0x113C2, 0x113B8}, 0x113C7},
-    {{0x113C2, 0x113C2}, 0x113C5},
-    {{0x113C2, 0x113C9}, 0x113C8},
-    {{0x114B9, 0x114B0}, 0x114BC},  // '𑒹' + combining -> '𑒼'
-    {{0x114B9, 0x114BA}, 0x114BB},  // '𑒹' + combining -> '𑒻'
-    {{0x114B9, 0x114BD}, 0x114BE},  // '𑒹' + combining -> '𑒾'
-    {{0x115B8, 0x115AF}, 0x115BA},  // '𑖸' + combining -> '𑖺'
-    {{0x115B9, 0x115AF}, 0x115BB},  // '𑖹' + combining -> '𑖻'
-    {{0x11935, 0x11930}, 0x11938},  // '𑤵' + combining -> '𑤸'
-    {{0x1611E, 0x1611E}, 0x16121},
-    {{0x1611E, 0x1611F}, 0x16123},
-    {{0x1611E, 0x16120}, 0x16125},
-    {{0x1611E, 0x16129}, 0x16122},
-    {{0x16121, 0x1611F}, 0x16126},
-    {{0x16121, 0x16120}, 0x16128},
-    {{0x16122, 0x1611F}, 0x16127},
-    {{0x16129, 0x1611F}, 0x16124},
-    {{0x16D63, 0x16D67}, 0x16D69},
-    {{0x16D67, 0x16D67}, 0x16D68},
-    {{0x16D69, 0x16D67}, 0x16D6A},
-    {{0x1D157, 0x1D165}, 0x1D15E},  // '𝅗' + combining -> '𝅗𝅥'
-    {{0x1D158, 0x1D165}, 0x1D15F},  // '𝅘' + combining -> '𝅘𝅥'
-    {{0x1D15F, 0x1D16E}, 0x1D160},  // '𝅘𝅥' + combining -> '𝅘𝅥𝅮'
-    {{0x1D15F, 0x1D16F}, 0x1D161},  // '𝅘𝅥' + combining -> '𝅘𝅥𝅯'
-    {{0x1D15F, 0x1D170}, 0x1D162},  // '𝅘𝅥' + combining -> '𝅘𝅥𝅰'
-    {{0x1D15F, 0x1D171}, 0x1D163},  // '𝅘𝅥' + combining -> '𝅘𝅥𝅱'
-    {{0x1D15F, 0x1D172}, 0x1D164},  // '𝅘𝅥' + combining -> '𝅘𝅥𝅲'
-    {{0x1D1B9, 0x1D165}, 0x1D1BB},  // '𝆹' + combining -> '𝆹𝅥'
-    {{0x1D1BA, 0x1D165}, 0x1D1BC},  // '𝆺' + combining -> '𝆺𝅥'
-    {{0x1D1BB, 0x1D16E}, 0x1D1BD},  // '𝆹𝅥' + combining -> '𝆹𝅥𝅮'
-    {{0x1D1BB, 0x1D16F}, 0x1D1BF},  // '𝆹𝅥' + combining -> '𝆹𝅥𝅯'
-    {{0x1D1BC, 0x1D16E}, 0x1D1BE},  // '𝆺𝅥' + combining -> '𝆺𝅥𝅮'
-    {{0x1D1BC, 0x1D16F}, 0x1D1C0},  // '𝆺𝅥' + combining -> '𝆺𝅥𝅯'
-};
-
-// Canonical combining class table: codepoint -> combining_class (0-254)
-// Only non-zero values are stored; missing entries have combining class 0 (starter)
-static const std::unordered_map<uint32_t, uint8_t> combining_class_table = {
-    {0x0300, 230},  // '̀' cc=230
-    {0x0301, 230},  // '́' cc=230
-    {0x0302, 230},  // '̂' cc=230
-    {0x0303, 230},  // '̃' cc=230
-    {0x0304, 230},  // '̄' cc=230
-    {0x0305, 230},  // '̅' cc=230
-    {0x0306, 230},  // '̆' cc=230
-    {0x0307, 230},  // '̇' cc=230
-    {0x0308, 230},  // '̈' cc=230
-    {0x0309, 230},  // '̉' cc=230
-    {0x030A, 230},  // '̊' cc=230
-    {0x030B, 230},  // '̋' cc=230
-    {0x030C, 230},  // '̌' cc=230
-    {0x030D, 230},  // '̍' cc=230
-    {0x030E, 230},  // '̎' cc=230
-    {0x030F, 230},  // '̏' cc=230
-    {0x0310, 230},  // '̐' cc=230
-    {0x0311, 230},  // '̑' cc=230
-    {0x0312, 230},  // '̒' cc=230
-    {0x0313, 230},  // '̓' cc=230
-    {0x0314, 230},  // '̔' cc=230
-    {0x0315, 232},  // '̕' cc=232
-    {0x0316, 220},  // '̖' cc=220
-    {0x0317, 220},  // '̗' cc=220
-    {0x0318, 220},  // '̘' cc=220
-    {0x0319, 220},  // '̙' cc=220
-    {0x031A, 232},  // '̚' cc=232
-    {0x031B, 216},  // '̛' cc=216
-    {0x031C, 220},  // '̜' cc=220
-    {0x031D, 220},  // '̝' cc=220
-    {0x031E, 220},  // '̞' cc=220
-    {0x031F, 220},  // '̟' cc=220
-    {0x0320, 220},  // '̠' cc=220
-    {0x0321, 202},  // '̡' cc=202
-    {0x0322, 202},  // '̢' cc=202
-    {0x0323, 220},  // '̣' cc=220
-    {0x0324, 220},  // '̤' cc=220
-    {0x0325, 220},  // '̥' cc=220
-    {0x0326, 220},  // '̦' cc=220
-    {0x0327, 202},  // '̧' cc=202
-    {0x0328, 202},  // '̨' cc=202
-    {0x0329, 220},  // '̩' cc=220
-    {0x032A, 220},  // '̪' cc=220
-    {0x032B, 220},  // '̫' cc=220
-    {0x032C, 220},  // '̬' cc=220
-    {0x032D, 220},  // '̭' cc=220
-    {0x032E, 220},  // '̮' cc=220
-    {0x032F, 220},  // '̯' cc=220
-    {0x0330, 220},  // '̰' cc=220
-    {0x0331, 220},  // '̱' cc=220
-    {0x0332, 220},  // '̲' cc=220
-    {0x0333, 220},  // '̳' cc=220
-    {0x0334, 1},  // '̴' cc=1
-    {0x0335, 1},  // '̵' cc=1
-    {0x0336, 1},  // '̶' cc=1
-    {0x0337, 1},  // '̷' cc=1
-    {0x0338, 1},  // '̸' cc=1
-    {0x0339, 220},  // '̹' cc=220
-    {0x033A, 220},  // '̺' cc=220
-    {0x033B, 220},  // '̻' cc=220
-    {0x033C, 220},  // '̼' cc=220
-    {0x033D, 230},  // '̽' cc=230
-    {0x033E, 230},  // '̾' cc=230
-    {0x033F, 230},  // '̿' cc=230
-    {0x0340, 230},  // '̀' cc=230
-    {0x0341, 230},  // '́' cc=230
-    {0x0342, 230},  // '͂' cc=230
-    {0x0343, 230},  // '̓' cc=230
-    {0x0344, 230},  // '̈́' cc=230
-    {0x0345, 240},  // 'ͅ' cc=240
-    {0x0346, 230},  // '͆' cc=230
-    {0x0347, 220},  // '͇' cc=220
-    {0x0348, 220},  // '͈' cc=220
-    {0x0349, 220},  // '͉' cc=220
-    {0x034A, 230},  // '͊' cc=230
-    {0x034B, 230},  // '͋' cc=230
-    {0x034C, 230},  // '͌' cc=230
-    {0x034D, 220},  // '͍' cc=220
-    {0x034E, 220},  // '͎' cc=220
-    {0x0350, 230},  // '͐' cc=230
-    {0x0351, 230},  // '͑' cc=230
-    {0x0352, 230},  // '͒' cc=230
-    {0x0353, 220},  // '͓' cc=220
-    {0x0354, 220},  // '͔' cc=220
-    {0x0355, 220},  // '͕' cc=220
-    {0x0356, 220},  // '͖' cc=220
-    {0x0357, 230},  // '͗' cc=230
-    {0x0358, 232},  // '͘' cc=232
-    {0x0359, 220},  // '͙' cc=220
-    {0x035A, 220},  // '͚' cc=220
-    {0x035B, 230},  // '͛' cc=230
-    {0x035C, 233},  // '͜' cc=233
-    {0x035D, 234},  // '͝' cc=234
-    {0x035E, 234},  // '͞' cc=234
-    {0x035F, 233},  // '͟' cc=233
-    {0x0360, 234},  // '͠' cc=234
-    {0x0361, 234},  // '͡' cc=234
-    {0x0362, 233},  // '͢' cc=233
-    {0x0363, 230},  // 'ͣ' cc=230
-    {0x0364, 230},  // 'ͤ' cc=230
-    {0x0365, 230},  // 'ͥ' cc=230
-    {0x0366, 230},  // 'ͦ' cc=230
-    {0x0367, 230},  // 'ͧ' cc=230
-    {0x0368, 230},  // 'ͨ' cc=230
-    {0x0369, 230},  // 'ͩ' cc=230
-    {0x036A, 230},  // 'ͪ' cc=230
-    {0x036B, 230},  // 'ͫ' cc=230
-    {0x036C, 230},  // 'ͬ' cc=230
-    {0x036D, 230},  // 'ͭ' cc=230
-    {0x036E, 230},  // 'ͮ' cc=230
-    {0x036F, 230},  // 'ͯ' cc=230
-    {0x0483, 230},  // '҃' cc=230
-    {0x0484, 230},  // '҄' cc=230
-    {0x0485, 230},  // '҅' cc=230
-    {0x0486, 230},  // '҆' cc=230
-    {0x0487, 230},  // '҇' cc=230
-    {0x0591, 220},  // '֑' cc=220
-    {0x0592, 230},  // '֒' cc=230
-    {0x0593, 230},  // '֓' cc=230
-    {0x0594, 230},  // '֔' cc=230
-    {0x0595, 230},  // '֕' cc=230
-    {0x0596, 220},  // '֖' cc=220
-    {0x0597, 230},  // '֗' cc=230
-    {0x0598, 230},  // '֘' cc=230
-    {0x0599, 230},  // '֙' cc=230
-    {0x059A, 222},  // '֚' cc=222
-    {0x059B, 220},  // '֛' cc=220
-    {0x059C, 230},  // '֜' cc=230
-    {0x059D, 230},  // '֝' cc=230
-    {0x059E, 230},  // '֞' cc=230
-    {0x059F, 230},  // '֟' cc=230
-    {0x05A0, 230},  // '֠' cc=230
-    {0x05A1, 230},  // '֡' cc=230
-    {0x05A2, 220},  // '֢' cc=220
-    {0x05A3, 220},  // '֣' cc=220
-    {0x05A4, 220},  // '֤' cc=220
-    {0x05A5, 220},  // '֥' cc=220
-    {0x05A6, 220},  // '֦' cc=220
-    {0x05A7, 220},  // '֧' cc=220
-    {0x05A8, 230},  // '֨' cc=230
-    {0x05A9, 230},  // '֩' cc=230
-    {0x05AA, 220},  // '֪' cc=220
-    {0x05AB, 230},  // '֫' cc=230
-    {0x05AC, 230},  // '֬' cc=230
-    {0x05AD, 222},  // '֭' cc=222
-    {0x05AE, 228},  // '֮' cc=228
-    {0x05AF, 230},  // '֯' cc=230
-    {0x05B0, 10},  // 'ְ' cc=10
-    {0x05B1, 11},  // 'ֱ' cc=11
-    {0x05B2, 12},  // 'ֲ' cc=12
-    {0x05B3, 13},  // 'ֳ' cc=13
-    {0x05B4, 14},  // 'ִ' cc=14
-    {0x05B5, 15},  // 'ֵ' cc=15
-    {0x05B6, 16},  // 'ֶ' cc=16
-    {0x05B7, 17},  // 'ַ' cc=17
-    {0x05B8, 18},  // 'ָ' cc=18
-    {0x05B9, 19},  // 'ֹ' cc=19
-    {0x05BA, 19},  // 'ֺ' cc=19
-    {0x05BB, 20},  // 'ֻ' cc=20
-    {0x05BC, 21},  // 'ּ' cc=21
-    {0x05BD, 22},  // 'ֽ' cc=22
-    {0x05BF, 23},  // 'ֿ' cc=23
-    {0x05C1, 24},  // 'ׁ' cc=24
-    {0x05C2, 25},  // 'ׂ' cc=25
-    {0x05C4, 230},  // 'ׄ' cc=230
-    {0x05C5, 220},  // 'ׅ' cc=220
-    {0x05C7, 18},  // 'ׇ' cc=18
-    {0x0610, 230},  // 'ؐ' cc=230
-    {0x0611, 230},  // 'ؑ' cc=230
-    {0x0612, 230},  // 'ؒ' cc=230
-    {0x0613, 230},  // 'ؓ' cc=230
-    {0x0614, 230},  // 'ؔ' cc=230
-    {0x0615, 230},  // 'ؕ' cc=230
-    {0x0616, 230},  // 'ؖ' cc=230
-    {0x0617, 230},  // 'ؗ' cc=230
-    {0x0618, 30},  // 'ؘ' cc=30
-    {0x0619, 31},  // 'ؙ' cc=31
-    {0x061A, 32},  // 'ؚ' cc=32
-    {0x064B, 27},  // 'ً' cc=27
-    {0x064C, 28},  // 'ٌ' cc=28
-    {0x064D, 29},  // 'ٍ' cc=29
-    {0x064E, 30},  // 'َ' cc=30
-    {0x064F, 31},  // 'ُ' cc=31
-    {0x0650, 32},  // 'ِ' cc=32
-    {0x0651, 33},  // 'ّ' cc=33
-    {0x0652, 34},  // 'ْ' cc=34
-    {0x0653, 230},  // 'ٓ' cc=230
-    {0x0654, 230},  // 'ٔ' cc=230
-    {0x0655, 220},  // 'ٕ' cc=220
-    {0x0656, 220},  // 'ٖ' cc=220
-    {0x0657, 230},  // 'ٗ' cc=230
-    {0x0658, 230},  // '٘' cc=230
-    {0x0659, 230},  // 'ٙ' cc=230
-    {0x065A, 230},  // 'ٚ' cc=230
-    {0x065B, 230},  // 'ٛ' cc=230
-    {0x065C, 220},  // 'ٜ' cc=220
-    {0x065D, 230},  // 'ٝ' cc=230
-    {0x065E, 230},  // 'ٞ' cc=230
-    {0x065F, 220},  // 'ٟ' cc=220
-    {0x0670, 35},  // 'ٰ' cc=35
-    {0x06D6, 230},  // 'ۖ' cc=230
-    {0x06D7, 230},  // 'ۗ' cc=230
-    {0x06D8, 230},  // 'ۘ' cc=230
-    {0x06D9, 230},  // 'ۙ' cc=230
-    {0x06DA, 230},  // 'ۚ' cc=230
-    {0x06DB, 230},  // 'ۛ' cc=230
-    {0x06DC, 230},  // 'ۜ' cc=230
-    {0x06DF, 230},  // '۟' cc=230
-    {0x06E0, 230},  // '۠' cc=230
-    {0x06E1, 230},  // 'ۡ' cc=230
-    {0x06E2, 230},  // 'ۢ' cc=230
-    {0x06E3, 220},  // 'ۣ' cc=220
-    {0x06E4, 230},  // 'ۤ' cc=230
-    {0x06E7, 230},  // 'ۧ' cc=230
-    {0x06E8, 230},  // 'ۨ' cc=230
-    {0x06EA, 220},  // '۪' cc=220
-    {0x06EB, 230},  // '۫' cc=230
-    {0x06EC, 230},  // '۬' cc=230
-    {0x06ED, 220},  // 'ۭ' cc=220
-    {0x0711, 36},  // 'ܑ' cc=36
-    {0x0730, 230},  // 'ܰ' cc=230
-    {0x0731, 220},  // 'ܱ' cc=220
-    {0x0732, 230},  // 'ܲ' cc=230
-    {0x0733, 230},  // 'ܳ' cc=230
-    {0x0734, 220},  // 'ܴ' cc=220
-    {0x0735, 230},  // 'ܵ' cc=230
-    {0x0736, 230},  // 'ܶ' cc=230
-    {0x0737, 220},  // 'ܷ' cc=220
-    {0x0738, 220},  // 'ܸ' cc=220
-    {0x0739, 220},  // 'ܹ' cc=220
-    {0x073A, 230},  // 'ܺ' cc=230
-    {0x073B, 220},  // 'ܻ' cc=220
-    {0x073C, 220},  // 'ܼ' cc=220
-    {0x073D, 230},  // 'ܽ' cc=230
-    {0x073E, 220},  // 'ܾ' cc=220
-    {0x073F, 230},  // 'ܿ' cc=230
-    {0x0740, 230},  // '݀' cc=230
-    {0x0741, 230},  // '݁' cc=230
-    {0x0742, 220},  // '݂' cc=220
-    {0x0743, 230},  // '݃' cc=230
-    {0x0744, 220},  // '݄' cc=220
-    {0x0745, 230},  // '݅' cc=230
-    {0x0746, 220},  // '݆' cc=220
-    {0x0747, 230},  // '݇' cc=230
-    {0x0748, 220},  // '݈' cc=220
-    {0x0749, 230},  // '݉' cc=230
-    {0x074A, 230},  // '݊' cc=230
-    {0x07EB, 230},  // '߫' cc=230
-    {0x07EC, 230},  // '߬' cc=230
-    {0x07ED, 230},  // '߭' cc=230
-    {0x07EE, 230},  // '߮' cc=230
-    {0x07EF, 230},  // '߯' cc=230
-    {0x07F0, 230},  // '߰' cc=230
-    {0x07F1, 230},  // '߱' cc=230
-    {0x07F2, 220},  // '߲' cc=220
-    {0x07F3, 230},  // '߳' cc=230
-    {0x07FD, 220},  // '߽' cc=220
-    {0x0816, 230},  // 'ࠖ' cc=230
-    {0x0817, 230},  // 'ࠗ' cc=230
-    {0x0818, 230},  // '࠘' cc=230
-    {0x0819, 230},  // '࠙' cc=230
-    {0x081B, 230},  // 'ࠛ' cc=230
-    {0x081C, 230},  // 'ࠜ' cc=230
-    {0x081D, 230},  // 'ࠝ' cc=230
-    {0x081E, 230},  // 'ࠞ' cc=230
-    {0x081F, 230},  // 'ࠟ' cc=230
-    {0x0820, 230},  // 'ࠠ' cc=230
-    {0x0821, 230},  // 'ࠡ' cc=230
-    {0x0822, 230},  // 'ࠢ' cc=230
-    {0x0823, 230},  // 'ࠣ' cc=230
-    {0x0825, 230},  // 'ࠥ' cc=230
-    {0x0826, 230},  // 'ࠦ' cc=230
-    {0x0827, 230},  // 'ࠧ' cc=230
-    {0x0829, 230},  // 'ࠩ' cc=230
-    {0x082A, 230},  // 'ࠪ' cc=230
-    {0x082B, 230},  // 'ࠫ' cc=230
-    {0x082C, 230},  // 'ࠬ' cc=230
-    {0x082D, 230},  // '࠭' cc=230
-    {0x0859, 220},  // '࡙' cc=220
-    {0x085A, 220},  // '࡚' cc=220
-    {0x085B, 220},  // '࡛' cc=220
-    {0x0897, 230},  // cc=230
-    {0x0898, 230},  // cc=230
-    {0x0899, 220},  // cc=220
-    {0x089A, 220},  // cc=220
-    {0x089B, 220},  // cc=220
-    {0x089C, 230},  // cc=230
-    {0x089D, 230},  // cc=230
-    {0x089E, 230},  // cc=230
-    {0x089F, 230},  // cc=230
-    {0x08CA, 230},  // cc=230
-    {0x08CB, 230},  // cc=230
-    {0x08CC, 230},  // cc=230
-    {0x08CD, 230},  // cc=230
-    {0x08CE, 230},  // cc=230
-    {0x08CF, 220},  // cc=220
-    {0x08D0, 220},  // cc=220
-    {0x08D1, 220},  // cc=220
-    {0x08D2, 220},  // cc=220
-    {0x08D3, 220},  // '࣓' cc=220
-    {0x08D4, 230},  // 'ࣔ' cc=230
-    {0x08D5, 230},  // 'ࣕ' cc=230
-    {0x08D6, 230},  // 'ࣖ' cc=230
-    {0x08D7, 230},  // 'ࣗ' cc=230
-    {0x08D8, 230},  // 'ࣘ' cc=230
-    {0x08D9, 230},  // 'ࣙ' cc=230
-    {0x08DA, 230},  // 'ࣚ' cc=230
-    {0x08DB, 230},  // 'ࣛ' cc=230
-    {0x08DC, 230},  // 'ࣜ' cc=230
-    {0x08DD, 230},  // 'ࣝ' cc=230
-    {0x08DE, 230},  // 'ࣞ' cc=230
-    {0x08DF, 230},  // 'ࣟ' cc=230
-    {0x08E0, 230},  // '࣠' cc=230
-    {0x08E1, 230},  // '࣡' cc=230
-    {0x08E3, 220},  // 'ࣣ' cc=220
-    {0x08E4, 230},  // 'ࣤ' cc=230
-    {0x08E5, 230},  // 'ࣥ' cc=230
-    {0x08E6, 220},  // 'ࣦ' cc=220
-    {0x08E7, 230},  // 'ࣧ' cc=230
-    {0x08E8, 230},  // 'ࣨ' cc=230
-    {0x08E9, 220},  // 'ࣩ' cc=220
-    {0x08EA, 230},  // '࣪' cc=230
-    {0x08EB, 230},  // '࣫' cc=230
-    {0x08EC, 230},  // '࣬' cc=230
-    {0x08ED, 220},  // '࣭' cc=220
-    {0x08EE, 220},  // '࣮' cc=220
-    {0x08EF, 220},  // '࣯' cc=220
-    {0x08F0, 27},  // 'ࣰ' cc=27
-    {0x08F1, 28},  // 'ࣱ' cc=28
-    {0x08F2, 29},  // 'ࣲ' cc=29
-    {0x08F3, 230},  // 'ࣳ' cc=230
-    {0x08F4, 230},  // 'ࣴ' cc=230
-    {0x08F5, 230},  // 'ࣵ' cc=230
-    {0x08F6, 220},  // 'ࣶ' cc=220
-    {0x08F7, 230},  // 'ࣷ' cc=230
-    {0x08F8, 230},  // 'ࣸ' cc=230
-    {0x08F9, 220},  // 'ࣹ' cc=220
-    {0x08FA, 220},  // 'ࣺ' cc=220
-    {0x08FB, 230},  // 'ࣻ' cc=230
-    {0x08FC, 230},  // 'ࣼ' cc=230
-    {0x08FD, 230},  // 'ࣽ' cc=230
-    {0x08FE, 230},  // 'ࣾ' cc=230
-    {0x08FF, 230},  // 'ࣿ' cc=230
-    {0x093C, 7},  // '़' cc=7
-    {0x094D, 9},  // '्' cc=9
-    {0x0951, 230},  // '॑' cc=230
-    {0x0952, 220},  // '॒' cc=220
-    {0x0953, 230},  // '॓' cc=230
-    {0x0954, 230},  // '॔' cc=230
-    {0x09BC, 7},  // '়' cc=7
-    {0x09CD, 9},  // '্' cc=9
-    {0x09FE, 230},  // '৾' cc=230
-    {0x0A3C, 7},  // '਼' cc=7
-    {0x0A4D, 9},  // '੍' cc=9
-    {0x0ABC, 7},  // '઼' cc=7
-    {0x0ACD, 9},  // '્' cc=9
-    {0x0B3C, 7},  // '଼' cc=7
-    {0x0B4D, 9},  // '୍' cc=9
-    {0x0BCD, 9},  // '்' cc=9
-    {0x0C3C, 7},  // cc=7
-    {0x0C4D, 9},  // '్' cc=9
-    {0x0C55, 84},  // 'ౕ' cc=84
-    {0x0C56, 91},  // 'ౖ' cc=91
-    {0x0CBC, 7},  // '಼' cc=7
-    {0x0CCD, 9},  // '್' cc=9
-    {0x0D3B, 9},  // '഻' cc=9
-    {0x0D3C, 9},  // '഼' cc=9
-    {0x0D4D, 9},  // '്' cc=9
-    {0x0DCA, 9},  // '්' cc=9
-    {0x0E38, 103},  // 'ุ' cc=103
-    {0x0E39, 103},  // 'ู' cc=103
-    {0x0E3A, 9},  // 'ฺ' cc=9
-    {0x0E48, 107},  // '่' cc=107
-    {0x0E49, 107},  // '้' cc=107
-    {0x0E4A, 107},  // '๊' cc=107
-    {0x0E4B, 107},  // '๋' cc=107
-    {0x0EB8, 118},  // 'ຸ' cc=118
-    {0x0EB9, 118},  // 'ູ' cc=118
-    {0x0EBA, 9},  // '຺' cc=9
-    {0x0EC8, 122},  // '່' cc=122
-    {0x0EC9, 122},  // '້' cc=122
-    {0x0ECA, 122},  // '໊' cc=122
-    {0x0ECB, 122},  // '໋' cc=122
-    {0x0F18, 220},  // '༘' cc=220
-    {0x0F19, 220},  // '༙' cc=220
-    {0x0F35, 220},  // '༵' cc=220
-    {0x0F37, 220},  // '༷' cc=220
-    {0x0F39, 216},  // '༹' cc=216
-    {0x0F71, 129},  // 'ཱ' cc=129
-    {0x0F72, 130},  // 'ི' cc=130
-    {0x0F74, 132},  // 'ུ' cc=132
-    {0x0F7A, 130},  // 'ེ' cc=130
-    {0x0F7B, 130},  // 'ཻ' cc=130
-    {0x0F7C, 130},  // 'ོ' cc=130
-    {0x0F7D, 130},  // 'ཽ' cc=130
-    {0x0F80, 130},  // 'ྀ' cc=130
-    {0x0F82, 230},  // 'ྂ' cc=230
-    {0x0F83, 230},  // 'ྃ' cc=230
-    {0x0F84, 9},  // '྄' cc=9
-    {0x0F86, 230},  // '྆' cc=230
-    {0x0F87, 230},  // '྇' cc=230
-    {0x0FC6, 220},  // '࿆' cc=220
-    {0x1037, 7},  // '့' cc=7
-    {0x1039, 9},  // '္' cc=9
-    {0x103A, 9},  // '်' cc=9
-    {0x108D, 220},  // 'ႍ' cc=220
-    {0x135D, 230},  // '፝' cc=230
-    {0x135E, 230},  // '፞' cc=230
-    {0x135F, 230},  // '፟' cc=230
-    {0x1714, 9},  // '᜔' cc=9
-    {0x1715, 9},  // cc=9
-    {0x1734, 9},  // '᜴' cc=9
-    {0x17D2, 9},  // '្' cc=9
-    {0x17DD, 230},  // '៝' cc=230
-    {0x18A9, 228},  // 'ᢩ' cc=228
-    {0x1939, 222},  // '᤹' cc=222
-    {0x193A, 230},  // '᤺' cc=230
-    {0x193B, 220},  // '᤻' cc=220
-    {0x1A17, 230},  // 'ᨗ' cc=230
-    {0x1A18, 220},  // 'ᨘ' cc=220
-    {0x1A60, 9},  // '᩠' cc=9
-    {0x1A75, 230},  // '᩵' cc=230
-    {0x1A76, 230},  // '᩶' cc=230
-    {0x1A77, 230},  // '᩷' cc=230
-    {0x1A78, 230},  // '᩸' cc=230
-    {0x1A79, 230},  // '᩹' cc=230
-    {0x1A7A, 230},  // '᩺' cc=230
-    {0x1A7B, 230},  // '᩻' cc=230
-    {0x1A7C, 230},  // '᩼' cc=230
-    {0x1A7F, 220},  // '᩿' cc=220
-    {0x1AB0, 230},  // '᪰' cc=230
-    {0x1AB1, 230},  // '᪱' cc=230
-    {0x1AB2, 230},  // '᪲' cc=230
-    {0x1AB3, 230},  // '᪳' cc=230
-    {0x1AB4, 230},  // '᪴' cc=230
-    {0x1AB5, 220},  // '᪵' cc=220
-    {0x1AB6, 220},  // '᪶' cc=220
-    {0x1AB7, 220},  // '᪷' cc=220
-    {0x1AB8, 220},  // '᪸' cc=220
-    {0x1AB9, 220},  // '᪹' cc=220
-    {0x1ABA, 220},  // '᪺' cc=220
-    {0x1ABB, 230},  // '᪻' cc=230
-    {0x1ABC, 230},  // '᪼' cc=230
-    {0x1ABD, 220},  // '᪽' cc=220
-    {0x1ABF, 220},  // 'ᪿ' cc=220
-    {0x1AC0, 220},  // 'ᫀ' cc=220
-    {0x1AC1, 230},  // cc=230
-    {0x1AC2, 230},  // cc=230
-    {0x1AC3, 220},  // cc=220
-    {0x1AC4, 220},  // cc=220
-    {0x1AC5, 230},  // cc=230
-    {0x1AC6, 230},  // cc=230
-    {0x1AC7, 230},  // cc=230
-    {0x1AC8, 230},  // cc=230
-    {0x1AC9, 230},  // cc=230
-    {0x1ACA, 220},  // cc=220
-    {0x1ACB, 230},  // cc=230
-    {0x1ACC, 230},  // cc=230
-    {0x1ACD, 230},  // cc=230
-    {0x1ACE, 230},  // cc=230
-    {0x1ACF, 230},  // cc=230
-    {0x1AD0, 230},  // cc=230
-    {0x1AD1, 230},  // cc=230
-    {0x1AD2, 230},  // cc=230
-    {0x1AD3, 230},  // cc=230
-    {0x1AD4, 230},  // cc=230
-    {0x1AD5, 230},  // cc=230
-    {0x1AD6, 230},  // cc=230
-    {0x1AD7, 230},  // cc=230
-    {0x1AD8, 230},  // cc=230
-    {0x1AD9, 230},  // cc=230
-    {0x1ADA, 230},  // cc=230
-    {0x1ADB, 230},  // cc=230
-    {0x1ADC, 230},  // cc=230
-    {0x1ADD, 220},  // cc=220
-    {0x1AE0, 230},  // cc=230
-    {0x1AE1, 230},  // cc=230
-    {0x1AE2, 230},  // cc=230
-    {0x1AE3, 230},  // cc=230
-    {0x1AE4, 230},  // cc=230
-    {0x1AE5, 230},  // cc=230
-    {0x1AE6, 220},  // cc=220
-    {0x1AE7, 230},  // cc=230
-    {0x1AE8, 230},  // cc=230
-    {0x1AE9, 230},  // cc=230
-    {0x1AEA, 230},  // cc=230
-    {0x1AEB, 234},  // cc=234
-    {0x1B34, 7},  // '᬴' cc=7
-    {0x1B44, 9},  // '᭄' cc=9
-    {0x1B6B, 230},  // '᭫' cc=230
-    {0x1B6C, 220},  // '᭬' cc=220
-    {0x1B6D, 230},  // '᭭' cc=230
-    {0x1B6E, 230},  // '᭮' cc=230
-    {0x1B6F, 230},  // '᭯' cc=230
-    {0x1B70, 230},  // '᭰' cc=230
-    {0x1B71, 230},  // '᭱' cc=230
-    {0x1B72, 230},  // '᭲' cc=230
-    {0x1B73, 230},  // '᭳' cc=230
-    {0x1BAA, 9},  // '᮪' cc=9
-    {0x1BAB, 9},  // '᮫' cc=9
-    {0x1BE6, 7},  // '᯦' cc=7
-    {0x1BF2, 9},  // '᯲' cc=9
-    {0x1BF3, 9},  // '᯳' cc=9
-    {0x1C37, 7},  // '᰷' cc=7
-    {0x1CD0, 230},  // '᳐' cc=230
-    {0x1CD1, 230},  // '᳑' cc=230
-    {0x1CD2, 230},  // '᳒' cc=230
-    {0x1CD4, 1},  // '᳔' cc=1
-    {0x1CD5, 220},  // '᳕' cc=220
-    {0x1CD6, 220},  // '᳖' cc=220
-    {0x1CD7, 220},  // '᳗' cc=220
-    {0x1CD8, 220},  // '᳘' cc=220
-    {0x1CD9, 220},  // '᳙' cc=220
-    {0x1CDA, 230},  // '᳚' cc=230
-    {0x1CDB, 230},  // '᳛' cc=230
-    {0x1CDC, 220},  // '᳜' cc=220
-    {0x1CDD, 220},  // '᳝' cc=220
-    {0x1CDE, 220},  // '᳞' cc=220
-    {0x1CDF, 220},  // '᳟' cc=220
-    {0x1CE0, 230},  // '᳠' cc=230
-    {0x1CE2, 1},  // '᳢' cc=1
-    {0x1CE3, 1},  // '᳣' cc=1
-    {0x1CE4, 1},  // '᳤' cc=1
-    {0x1CE5, 1},  // '᳥' cc=1
-    {0x1CE6, 1},  // '᳦' cc=1
-    {0x1CE7, 1},  // '᳧' cc=1
-    {0x1CE8, 1},  // '᳨' cc=1
-    {0x1CED, 220},  // '᳭' cc=220
-    {0x1CF4, 230},  // '᳴' cc=230
-    {0x1CF8, 230},  // '᳸' cc=230
-    {0x1CF9, 230},  // '᳹' cc=230
-    {0x1DC0, 230},  // '᷀' cc=230
-    {0x1DC1, 230},  // '᷁' cc=230
-    {0x1DC2, 220},  // '᷂' cc=220
-    {0x1DC3, 230},  // '᷃' cc=230
-    {0x1DC4, 230},  // '᷄' cc=230
-    {0x1DC5, 230},  // '᷅' cc=230
-    {0x1DC6, 230},  // '᷆' cc=230
-    {0x1DC7, 230},  // '᷇' cc=230
-    {0x1DC8, 230},  // '᷈' cc=230
-    {0x1DC9, 230},  // '᷉' cc=230
-    {0x1DCA, 220},  // '᷊' cc=220
-    {0x1DCB, 230},  // '᷋' cc=230
-    {0x1DCC, 230},  // '᷌' cc=230
-    {0x1DCD, 234},  // '᷍' cc=234
-    {0x1DCE, 214},  // '᷎' cc=214
-    {0x1DCF, 220},  // '᷏' cc=220
-    {0x1DD0, 202},  // '᷐' cc=202
-    {0x1DD1, 230},  // '᷑' cc=230
-    {0x1DD2, 230},  // '᷒' cc=230
-    {0x1DD3, 230},  // 'ᷓ' cc=230
-    {0x1DD4, 230},  // 'ᷔ' cc=230
-    {0x1DD5, 230},  // 'ᷕ' cc=230
-    {0x1DD6, 230},  // 'ᷖ' cc=230
-    {0x1DD7, 230},  // 'ᷗ' cc=230
-    {0x1DD8, 230},  // 'ᷘ' cc=230
-    {0x1DD9, 230},  // 'ᷙ' cc=230
-    {0x1DDA, 230},  // 'ᷚ' cc=230
-    {0x1DDB, 230},  // 'ᷛ' cc=230
-    {0x1DDC, 230},  // 'ᷜ' cc=230
-    {0x1DDD, 230},  // 'ᷝ' cc=230
-    {0x1DDE, 230},  // 'ᷞ' cc=230
-    {0x1DDF, 230},  // 'ᷟ' cc=230
-    {0x1DE0, 230},  // 'ᷠ' cc=230
-    {0x1DE1, 230},  // 'ᷡ' cc=230
-    {0x1DE2, 230},  // 'ᷢ' cc=230
-    {0x1DE3, 230},  // 'ᷣ' cc=230
-    {0x1DE4, 230},  // 'ᷤ' cc=230
-    {0x1DE5, 230},  // 'ᷥ' cc=230
-    {0x1DE6, 230},  // 'ᷦ' cc=230
-    {0x1DE7, 230},  // 'ᷧ' cc=230
-    {0x1DE8, 230},  // 'ᷨ' cc=230
-    {0x1DE9, 230},  // 'ᷩ' cc=230
-    {0x1DEA, 230},  // 'ᷪ' cc=230
-    {0x1DEB, 230},  // 'ᷫ' cc=230
-    {0x1DEC, 230},  // 'ᷬ' cc=230
-    {0x1DED, 230},  // 'ᷭ' cc=230
-    {0x1DEE, 230},  // 'ᷮ' cc=230
-    {0x1DEF, 230},  // 'ᷯ' cc=230
-    {0x1DF0, 230},  // 'ᷰ' cc=230
-    {0x1DF1, 230},  // 'ᷱ' cc=230
-    {0x1DF2, 230},  // 'ᷲ' cc=230
-    {0x1DF3, 230},  // 'ᷳ' cc=230
-    {0x1DF4, 230},  // 'ᷴ' cc=230
-    {0x1DF5, 230},  // '᷵' cc=230
-    {0x1DF6, 232},  // '᷶' cc=232
-    {0x1DF7, 228},  // '᷷' cc=228
-    {0x1DF8, 228},  // '᷸' cc=228
-    {0x1DF9, 220},  // '᷹' cc=220
-    {0x1DFA, 218},  // cc=218
-    {0x1DFB, 230},  // '᷻' cc=230
-    {0x1DFC, 233},  // '᷼' cc=233
-    {0x1DFD, 220},  // '᷽' cc=220
-    {0x1DFE, 230},  // '᷾' cc=230
-    {0x1DFF, 220},  // '᷿' cc=220
-    {0x20D0, 230},  // '⃐' cc=230
-    {0x20D1, 230},  // '⃑' cc=230
-    {0x20D2, 1},  // '⃒' cc=1
-    {0x20D3, 1},  // '⃓' cc=1
-    {0x20D4, 230},  // '⃔' cc=230
-    {0x20D5, 230},  // '⃕' cc=230
-    {0x20D6, 230},  // '⃖' cc=230
-    {0x20D7, 230},  // '⃗' cc=230
-    {0x20D8, 1},  // '⃘' cc=1
-    {0x20D9, 1},  // '⃙' cc=1
-    {0x20DA, 1},  // '⃚' cc=1
-    {0x20DB, 230},  // '⃛' cc=230
-    {0x20DC, 230},  // '⃜' cc=230
-    {0x20E1, 230},  // '⃡' cc=230
-    {0x20E5, 1},  // '⃥' cc=1
-    {0x20E6, 1},  // '⃦' cc=1
-    {0x20E7, 230},  // '⃧' cc=230
-    {0x20E8, 220},  // '⃨' cc=220
-    {0x20E9, 230},  // '⃩' cc=230
-    {0x20EA, 1},  // '⃪' cc=1
-    {0x20EB, 1},  // '⃫' cc=1
-    {0x20EC, 220},  // '⃬' cc=220
-    {0x20ED, 220},  // '⃭' cc=220
-    {0x20EE, 220},  // '⃮' cc=220
-    {0x20EF, 220},  // '⃯' cc=220
-    {0x20F0, 230},  // '⃰' cc=230
-    {0x2CEF, 230},  // '⳯' cc=230
-    {0x2CF0, 230},  // '⳰' cc=230
-    {0x2CF1, 230},  // '⳱' cc=230
-    {0x2D7F, 9},  // '⵿' cc=9
-    {0x2DE0, 230},  // 'ⷠ' cc=230
-    {0x2DE1, 230},  // 'ⷡ' cc=230
-    {0x2DE2, 230},  // 'ⷢ' cc=230
-    {0x2DE3, 230},  // 'ⷣ' cc=230
-    {0x2DE4, 230},  // 'ⷤ' cc=230
-    {0x2DE5, 230},  // 'ⷥ' cc=230
-    {0x2DE6, 230},  // 'ⷦ' cc=230
-    {0x2DE7, 230},  // 'ⷧ' cc=230
-    {0x2DE8, 230},  // 'ⷨ' cc=230
-    {0x2DE9, 230},  // 'ⷩ' cc=230
-    {0x2DEA, 230},  // 'ⷪ' cc=230
-    {0x2DEB, 230},  // 'ⷫ' cc=230
-    {0x2DEC, 230},  // 'ⷬ' cc=230
-    {0x2DED, 230},  // 'ⷭ' cc=230
-    {0x2DEE, 230},  // 'ⷮ' cc=230
-    {0x2DEF, 230},  // 'ⷯ' cc=230
-    {0x2DF0, 230},  // 'ⷰ' cc=230
-    {0x2DF1, 230},  // 'ⷱ' cc=230
-    {0x2DF2, 230},  // 'ⷲ' cc=230
-    {0x2DF3, 230},  // 'ⷳ' cc=230
-    {0x2DF4, 230},  // 'ⷴ' cc=230
-    {0x2DF5, 230},  // 'ⷵ' cc=230
-    {0x2DF6, 230},  // 'ⷶ' cc=230
-    {0x2DF7, 230},  // 'ⷷ' cc=230
-    {0x2DF8, 230},  // 'ⷸ' cc=230
-    {0x2DF9, 230},  // 'ⷹ' cc=230
-    {0x2DFA, 230},  // 'ⷺ' cc=230
-    {0x2DFB, 230},  // 'ⷻ' cc=230
-    {0x2DFC, 230},  // 'ⷼ' cc=230
-    {0x2DFD, 230},  // 'ⷽ' cc=230
-    {0x2DFE, 230},  // 'ⷾ' cc=230
-    {0x2DFF, 230},  // 'ⷿ' cc=230
-    {0x302A, 218},  // '〪' cc=218
-    {0x302B, 228},  // '〫' cc=228
-    {0x302C, 232},  // '〬' cc=232
-    {0x302D, 222},  // '〭' cc=222
-    {0x302E, 224},  // '〮' cc=224
-    {0x302F, 224},  // '〯' cc=224
-    {0x3099, 8},  // '゙' cc=8
-    {0x309A, 8},  // '゚' cc=8
-    {0xA66F, 230},  // '꙯' cc=230
-    {0xA674, 230},  // 'ꙴ' cc=230
-    {0xA675, 230},  // 'ꙵ' cc=230
-    {0xA676, 230},  // 'ꙶ' cc=230
-    {0xA677, 230},  // 'ꙷ' cc=230
-    {0xA678, 230},  // 'ꙸ' cc=230
-    {0xA679, 230},  // 'ꙹ' cc=230
-    {0xA67A, 230},  // 'ꙺ' cc=230
-    {0xA67B, 230},  // 'ꙻ' cc=230
-    {0xA67C, 230},  // '꙼' cc=230
-    {0xA67D, 230},  // '꙽' cc=230
-    {0xA69E, 230},  // 'ꚞ' cc=230
-    {0xA69F, 230},  // 'ꚟ' cc=230
-    {0xA6F0, 230},  // '꛰' cc=230
-    {0xA6F1, 230},  // '꛱' cc=230
-    {0xA806, 9},  // '꠆' cc=9
-    {0xA82C, 9},  // '꠬' cc=9
-    {0xA8C4, 9},  // '꣄' cc=9
-    {0xA8E0, 230},  // '꣠' cc=230
-    {0xA8E1, 230},  // '꣡' cc=230
-    {0xA8E2, 230},  // '꣢' cc=230
-    {0xA8E3, 230},  // '꣣' cc=230
-    {0xA8E4, 230},  // '꣤' cc=230
-    {0xA8E5, 230},  // '꣥' cc=230
-    {0xA8E6, 230},  // '꣦' cc=230
-    {0xA8E7, 230},  // '꣧' cc=230
-    {0xA8E8, 230},  // '꣨' cc=230
-    {0xA8E9, 230},  // '꣩' cc=230
-    {0xA8EA, 230},  // '꣪' cc=230
-    {0xA8EB, 230},  // '꣫' cc=230
-    {0xA8EC, 230},  // '꣬' cc=230
-    {0xA8ED, 230},  // '꣭' cc=230
-    {0xA8EE, 230},  // '꣮' cc=230
-    {0xA8EF, 230},  // '꣯' cc=230
-    {0xA8F0, 230},  // '꣰' cc=230
-    {0xA8F1, 230},  // '꣱' cc=230
-    {0xA92B, 220},  // '꤫' cc=220
-    {0xA92C, 220},  // '꤬' cc=220
-    {0xA92D, 220},  // '꤭' cc=220
-    {0xA953, 9},  // '꥓' cc=9
-    {0xA9B3, 7},  // '꦳' cc=7
-    {0xA9C0, 9},  // '꧀' cc=9
-    {0xAAB0, 230},  // 'ꪰ' cc=230
-    {0xAAB2, 230},  // 'ꪲ' cc=230
-    {0xAAB3, 230},  // 'ꪳ' cc=230
-    {0xAAB4, 220},  // 'ꪴ' cc=220
-    {0xAAB7, 230},  // 'ꪷ' cc=230
-    {0xAAB8, 230},  // 'ꪸ' cc=230
-    {0xAABE, 230},  // 'ꪾ' cc=230
-    {0xAABF, 230},  // '꪿' cc=230
-    {0xAAC1, 230},  // '꫁' cc=230
-    {0xAAF6, 9},  // '꫶' cc=9
-    {0xABED, 9},  // '꯭' cc=9
-    {0xFB1E, 26},  // 'ﬞ' cc=26
-    {0xFE20, 230},  // '︠' cc=230
-    {0xFE21, 230},  // '︡' cc=230
-    {0xFE22, 230},  // '︢' cc=230
-    {0xFE23, 230},  // '︣' cc=230
-    {0xFE24, 230},  // '︤' cc=230
-    {0xFE25, 230},  // '︥' cc=230
-    {0xFE26, 230},  // '︦' cc=230
-    {0xFE27, 220},  // '︧' cc=220
-    {0xFE28, 220},  // '︨' cc=220
-    {0xFE29, 220},  // '︩' cc=220
-    {0xFE2A, 220},  // '︪' cc=220
-    {0xFE2B, 220},  // '︫' cc=220
-    {0xFE2C, 220},  // '︬' cc=220
-    {0xFE2D, 220},  // '︭' cc=220
-    {0xFE2E, 230},  // '︮' cc=230
-    {0xFE2F, 230},  // '︯' cc=230
-    {0x101FD, 220},  // '𐇽' cc=220
-    {0x102E0, 220},  // '𐋠' cc=220
-    {0x10376, 230},  // '𐍶' cc=230
-    {0x10377, 230},  // '𐍷' cc=230
-    {0x10378, 230},  // '𐍸' cc=230
-    {0x10379, 230},  // '𐍹' cc=230
-    {0x1037A, 230},  // '𐍺' cc=230
-    {0x10A0D, 220},  // '𐨍' cc=220
-    {0x10A0F, 230},  // '𐨏' cc=230
-    {0x10A38, 230},  // '𐨸' cc=230
-    {0x10A39, 1},  // '𐨹' cc=1
-    {0x10A3A, 220},  // '𐨺' cc=220
-    {0x10A3F, 9},  // '𐨿' cc=9
-    {0x10AE5, 230},  // '𐫥' cc=230
-    {0x10AE6, 220},  // '𐫦' cc=220
-    {0x10D24, 230},  // '𐴤' cc=230
-    {0x10D25, 230},  // '𐴥' cc=230
-    {0x10D26, 230},  // '𐴦' cc=230
-    {0x10D27, 230},  // '𐴧' cc=230
-    {0x10D69, 230},  // cc=230
-    {0x10D6A, 230},  // cc=230
-    {0x10D6B, 230},  // cc=230
-    {0x10D6C, 230},  // cc=230
-    {0x10D6D, 230},  // cc=230
-    {0x10EAB, 230},  // '𐺫' cc=230
-    {0x10EAC, 230},  // '𐺬' cc=230
-    {0x10EFA, 220},  // cc=220
-    {0x10EFB, 220},  // cc=220
-    {0x10EFD, 220},  // cc=220
-    {0x10EFE, 220},  // cc=220
-    {0x10EFF, 220},  // cc=220
-    {0x10F46, 220},  // '𐽆' cc=220
-    {0x10F47, 220},  // '𐽇' cc=220
-    {0x10F48, 230},  // '𐽈' cc=230
-    {0x10F49, 230},  // '𐽉' cc=230
-    {0x10F4A, 230},  // '𐽊' cc=230
-    {0x10F4B, 220},  // '𐽋' cc=220
-    {0x10F4C, 230},  // '𐽌' cc=230
-    {0x10F4D, 220},  // '𐽍' cc=220
-    {0x10F4E, 220},  // '𐽎' cc=220
-    {0x10F4F, 220},  // '𐽏' cc=220
-    {0x10F50, 220},  // '𐽐' cc=220
-    {0x10F82, 230},  // cc=230
-    {0x10F83, 220},  // cc=220
-    {0x10F84, 230},  // cc=230
-    {0x10F85, 220},  // cc=220
-    {0x11046, 9},  // '𑁆' cc=9
-    {0x11070, 9},  // cc=9
-    {0x1107F, 9},  // '𑁿' cc=9
-    {0x110B9, 9},  // '𑂹' cc=9
-    {0x110BA, 7},  // '𑂺' cc=7
-    {0x11100, 230},  // '𑄀' cc=230
-    {0x11101, 230},  // '𑄁' cc=230
-    {0x11102, 230},  // '𑄂' cc=230
-    {0x11133, 9},  // '𑄳' cc=9
-    {0x11134, 9},  // '𑄴' cc=9
-    {0x11173, 7},  // '𑅳' cc=7
-    {0x111C0, 9},  // '𑇀' cc=9
-    {0x111CA, 7},  // '𑇊' cc=7
-    {0x11235, 9},  // '𑈵' cc=9
-    {0x11236, 7},  // '𑈶' cc=7
-    {0x112E9, 7},  // '𑋩' cc=7
-    {0x112EA, 9},  // '𑋪' cc=9
-    {0x1133B, 7},  // '𑌻' cc=7
-    {0x1133C, 7},  // '𑌼' cc=7
-    {0x1134D, 9},  // '𑍍' cc=9
-    {0x11366, 230},  // '𑍦' cc=230
-    {0x11367, 230},  // '𑍧' cc=230
-    {0x11368, 230},  // '𑍨' cc=230
-    {0x11369, 230},  // '𑍩' cc=230
-    {0x1136A, 230},  // '𑍪' cc=230
-    {0x1136B, 230},  // '𑍫' cc=230
-    {0x1136C, 230},  // '𑍬' cc=230
-    {0x11370, 230},  // '𑍰' cc=230
-    {0x11371, 230},  // '𑍱' cc=230
-    {0x11372, 230},  // '𑍲' cc=230
-    {0x11373, 230},  // '𑍳' cc=230
-    {0x11374, 230},  // '𑍴' cc=230
-    {0x113CE, 9},  // cc=9
-    {0x113CF, 9},  // cc=9
-    {0x113D0, 9},  // cc=9
-    {0x11442, 9},  // '𑑂' cc=9
-    {0x11446, 7},  // '𑑆' cc=7
-    {0x1145E, 230},  // '𑑞' cc=230
-    {0x114C2, 9},  // '𑓂' cc=9
-    {0x114C3, 7},  // '𑓃' cc=7
-    {0x115BF, 9},  // '𑖿' cc=9
-    {0x115C0, 7},  // '𑗀' cc=7
-    {0x1163F, 9},  // '𑘿' cc=9
-    {0x116B6, 9},  // '𑚶' cc=9
-    {0x116B7, 7},  // '𑚷' cc=7
-    {0x1172B, 9},  // '𑜫' cc=9
-    {0x11839, 9},  // '𑠹' cc=9
-    {0x1183A, 7},  // '𑠺' cc=7
-    {0x1193D, 9},  // '𑤽' cc=9
-    {0x1193E, 9},  // '𑤾' cc=9
-    {0x11943, 7},  // '𑥃' cc=7
-    {0x119E0, 9},  // '𑧠' cc=9
-    {0x11A34, 9},  // '𑨴' cc=9
-    {0x11A47, 9},  // '𑩇' cc=9
-    {0x11A99, 9},  // '𑪙' cc=9
-    {0x11C3F, 9},  // '𑰿' cc=9
-    {0x11D42, 7},  // '𑵂' cc=7
-    {0x11D44, 9},  // '𑵄' cc=9
-    {0x11D45, 9},  // '𑵅' cc=9
-    {0x11D97, 9},  // '𑶗' cc=9
-    {0x11F41, 9},  // cc=9
-    {0x11F42, 9},  // cc=9
-    {0x1612F, 9},  // cc=9
-    {0x16AF0, 1},  // '𖫰' cc=1
-    {0x16AF1, 1},  // '𖫱' cc=1
-    {0x16AF2, 1},  // '𖫲' cc=1
-    {0x16AF3, 1},  // '𖫳' cc=1
-    {0x16AF4, 1},  // '𖫴' cc=1
-    {0x16B30, 230},  // '𖬰' cc=230
-    {0x16B31, 230},  // '𖬱' cc=230
-    {0x16B32, 230},  // '𖬲' cc=230
-    {0x16B33, 230},  // '𖬳' cc=230
-    {0x16B34, 230},  // '𖬴' cc=230
-    {0x16B35, 230},  // '𖬵' cc=230
-    {0x16B36, 230},  // '𖬶' cc=230
-    {0x16FF0, 6},  // '𖿰' cc=6
-    {0x16FF1, 6},  // '𖿱' cc=6
-    {0x1BC9E, 1},  // '𛲞' cc=1
-    {0x1D165, 216},  // '𝅥' cc=216
-    {0x1D166, 216},  // '𝅦' cc=216
-    {0x1D167, 1},  // '𝅧' cc=1
-    {0x1D168, 1},  // '𝅨' cc=1
-    {0x1D169, 1},  // '𝅩' cc=1
-    {0x1D16D, 226},  // '𝅭' cc=226
-    {0x1D16E, 216},  // '𝅮' cc=216
-    {0x1D16F, 216},  // '𝅯' cc=216
-    {0x1D170, 216},  // '𝅰' cc=216
-    {0x1D171, 216},  // '𝅱' cc=216
-    {0x1D172, 216},  // '𝅲' cc=216
-    {0x1D17B, 220},  // '𝅻' cc=220
-    {0x1D17C, 220},  // '𝅼' cc=220
-    {0x1D17D, 220},  // '𝅽' cc=220
-    {0x1D17E, 220},  // '𝅾' cc=220
-    {0x1D17F, 220},  // '𝅿' cc=220
-    {0x1D180, 220},  // '𝆀' cc=220
-    {0x1D181, 220},  // '𝆁' cc=220
-    {0x1D182, 220},  // '𝆂' cc=220
-    {0x1D185, 230},  // '𝆅' cc=230
-    {0x1D186, 230},  // '𝆆' cc=230
-    {0x1D187, 230},  // '𝆇' cc=230
-    {0x1D188, 230},  // '𝆈' cc=230
-    {0x1D189, 230},  // '𝆉' cc=230
-    {0x1D18A, 220},  // '𝆊' cc=220
-    {0x1D18B, 220},  // '𝆋' cc=220
-    {0x1D1AA, 230},  // '𝆪' cc=230
-    {0x1D1AB, 230},  // '𝆫' cc=230
-    {0x1D1AC, 230},  // '𝆬' cc=230
-    {0x1D1AD, 230},  // '𝆭' cc=230
-    {0x1D242, 230},  // '𝉂' cc=230
-    {0x1D243, 230},  // '𝉃' cc=230
-    {0x1D244, 230},  // '𝉄' cc=230
-    {0x1E000, 230},  // '𞀀' cc=230
-    {0x1E001, 230},  // '𞀁' cc=230
-    {0x1E002, 230},  // '𞀂' cc=230
-    {0x1E003, 230},  // '𞀃' cc=230
-    {0x1E004, 230},  // '𞀄' cc=230
-    {0x1E005, 230},  // '𞀅' cc=230
-    {0x1E006, 230},  // '𞀆' cc=230
-    {0x1E008, 230},  // '𞀈' cc=230
-    {0x1E009, 230},  // '𞀉' cc=230
-    {0x1E00A, 230},  // '𞀊' cc=230
-    {0x1E00B, 230},  // '𞀋' cc=230
-    {0x1E00C, 230},  // '𞀌' cc=230
-    {0x1E00D, 230},  // '𞀍' cc=230
-    {0x1E00E, 230},  // '𞀎' cc=230
-    {0x1E00F, 230},  // '𞀏' cc=230
-    {0x1E010, 230},  // '𞀐' cc=230
-    {0x1E011, 230},  // '𞀑' cc=230
-    {0x1E012, 230},  // '𞀒' cc=230
-    {0x1E013, 230},  // '𞀓' cc=230
-    {0x1E014, 230},  // '𞀔' cc=230
-    {0x1E015, 230},  // '𞀕' cc=230
-    {0x1E016, 230},  // '𞀖' cc=230
-    {0x1E017, 230},  // '𞀗' cc=230
-    {0x1E018, 230},  // '𞀘' cc=230
-    {0x1E01B, 230},  // '𞀛' cc=230
-    {0x1E01C, 230},  // '𞀜' cc=230
-    {0x1E01D, 230},  // '𞀝' cc=230
-    {0x1E01E, 230},  // '𞀞' cc=230
-    {0x1E01F, 230},  // '𞀟' cc=230
-    {0x1E020, 230},  // '𞀠' cc=230
-    {0x1E021, 230},  // '𞀡' cc=230
-    {0x1E023, 230},  // '𞀣' cc=230
-    {0x1E024, 230},  // '𞀤' cc=230
-    {0x1E026, 230},  // '𞀦' cc=230
-    {0x1E027, 230},  // '𞀧' cc=230
-    {0x1E028, 230},  // '𞀨' cc=230
-    {0x1E029, 230},  // '𞀩' cc=230
-    {0x1E02A, 230},  // '𞀪' cc=230
-    {0x1E08F, 230},  // cc=230
-    {0x1E130, 230},  // '𞄰' cc=230
-    {0x1E131, 230},  // '𞄱' cc=230
-    {0x1E132, 230},  // '𞄲' cc=230
-    {0x1E133, 230},  // '𞄳' cc=230
-    {0x1E134, 230},  // '𞄴' cc=230
-    {0x1E135, 230},  // '𞄵' cc=230
-    {0x1E136, 230},  // '𞄶' cc=230
-    {0x1E2AE, 230},  // cc=230
-    {0x1E2EC, 230},  // '𞋬' cc=230
-    {0x1E2ED, 230},  // '𞋭' cc=230
-    {0x1E2EE, 230},  // '𞋮' cc=230
-    {0x1E2EF, 230},  // '𞋯' cc=230
-    {0x1E4EC, 232},  // cc=232
-    {0x1E4ED, 232},  // cc=232
-    {0x1E4EE, 220},  // cc=220
-    {0x1E4EF, 230},  // cc=230
-    {0x1E5EE, 230},  // cc=230
-    {0x1E5EF, 220},  // cc=220
-    {0x1E6E3, 230},  // cc=230
-    {0x1E6E6, 230},  // cc=230
-    {0x1E6EE, 230},  // cc=230
-    {0x1E6EF, 230},  // cc=230
-    {0x1E6F5, 230},  // cc=230
-    {0x1E8D0, 220},  // '𞣐' cc=220
-    {0x1E8D1, 220},  // '𞣑' cc=220
-    {0x1E8D2, 220},  // '𞣒' cc=220
-    {0x1E8D3, 220},  // '𞣓' cc=220
-    {0x1E8D4, 220},  // '𞣔' cc=220
-    {0x1E8D5, 220},  // '𞣕' cc=220
-    {0x1E8D6, 220},  // '𞣖' cc=220
-    {0x1E944, 230},  // '𞥄' cc=230
-    {0x1E945, 230},  // '𞥅' cc=230
-    {0x1E946, 230},  // '𞥆' cc=230
-    {0x1E947, 230},  // '𞥇' cc=230
-    {0x1E948, 230},  // '𞥈' cc=230
-    {0x1E949, 230},  // '𞥉' cc=230
-    {0x1E94A, 7},  // '𞥊' cc=7
-};
-
-} // namespace tokenizers
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/unicode-nfc.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/unicode-nfc.h
deleted file mode 100644
index 57a394f6c7..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/unicode-nfc.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * Unicode NFC/NFD normalization implementation
- * This implementation fixes the broken llama.cpp-unicode normalization
- * by using proper multi-codepoint decomposition sequences.
- */
-
-#pragma once
-
-#include <cstdint>
-#include <string>
-#include <vector>
-
-namespace tokenizers {
-
-/**
- * Normalize a sequence of codepoints to NFD (Canonical Decomposition)
- *
- * @param cpts Input codepoint sequence
- * @return NFD-normalized codepoint sequence
- */
-std::vector<uint32_t> unicode_normalize_nfd(const std::vector<uint32_t>& cpts);
-
-/**
- * Normalize a sequence of codepoints to NFC (Canonical Decomposition +
- * Composition)
- *
- * @param cpts Input codepoint sequence
- * @return NFC-normalized codepoint sequence
- */
-std::vector<uint32_t> unicode_normalize_nfc(const std::vector<uint32_t>& cpts);
-
-/**
- * Normalize a UTF-8 string to NFD
- *
- * @param utf8 Input UTF-8 string
- * @return NFD-normalized UTF-8 string
- */
-std::string unicode_normalize_nfd_utf8(const std::string& utf8);
-
-/**
- * Normalize a UTF-8 string to NFC
- *
- * @param utf8 Input UTF-8 string
- * @return NFC-normalized UTF-8 string
- */
-std::string unicode_normalize_nfc_utf8(const std::string& utf8);
-
-} // namespace tokenizers
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/unicode_utils.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/unicode_utils.h
deleted file mode 100644
index 883c81220a..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/unicode_utils.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-// @lint-ignore-every LICENSELINT
-
-#pragma once
-
-#include <cstdint>
-#include <unicode.h>
-
-namespace tokenizers {
-namespace unicode_utils {
-
-/// CJK Unified Ideographs and extensions.
-/// Shared by BertPreTokenizer, BertNormalizer, and UnicodeScriptsPreTokenizer.
-inline bool is_cjk(uint32_t c) {
-  return (c >= 0x4E00 && c <= 0x9FFF) || (c >= 0x3400 && c <= 0x4DBF) ||
-      (c >= 0x20000 && c <= 0x2A6DF) || (c >= 0x2A700 && c <= 0x2B73F) ||
-      (c >= 0x2B740 && c <= 0x2B81F) || (c >= 0x2B920 && c <= 0x2CEAF) ||
-      (c >= 0xF900 && c <= 0xFAFF) || (c >= 0x2F800 && c <= 0x2FA1F);
-}
-
-/// ASCII + Unicode punctuation check.
-/// Shared by BertPreTokenizer and PunctuationPreTokenizer.
-inline bool is_punctuation(uint32_t cp) {
-  if ((cp >= 33 && cp <= 47) || (cp >= 58 && cp <= 64) ||
-      (cp >= 91 && cp <= 96) || (cp >= 123 && cp <= 126)) {
-    return true;
-  }
-  return unicode_cpt_flags(cp).is_punctuation;
-}
-
-} // namespace unicode_utils
-} // namespace tokenizers
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/unigram_model.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/unigram_model.h
deleted file mode 100644
index c3cdc3c04a..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/unigram_model.h
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-// @lint-ignore-every LICENSELINT
-
-#pragma once
-
-#include <memory>
-#include <optional>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-#include <pytorch/tokenizers/model.h>
-#include <pytorch/tokenizers/regex.h>
-#include <pytorch/tokenizers/result.h>
-#include <pytorch/tokenizers/string_integer_map.h>
-
-namespace tokenizers {
-
-/**
- * Unigram (SentencePiece) model.
- *
- * Each vocabulary token has a log-probability score. Tokenization finds the
- * segmentation that maximizes the sum of scores via the Viterbi algorithm.
- *
- * JSON format in tokenizer.json:
- *   "model": {
- *     "type": "Unigram",
- *     "unk_id": 0,
- *     "vocab": [["<unk>", 0.0], ["▁hello", -5.2], ...],
- *     "byte_fallback": true
- *   }
- */
-class UnigramModel : public Model {
- public:
-  explicit UnigramModel(
-      std::vector<std::string> pieces,
-      std::vector<double> scores,
-      detail::TokenMap special_token_map,
-      std::unique_ptr<IRegex> special_token_regex,
-      bool byte_fallback,
-      std::optional<uint64_t> unk_token_id,
-      std::optional<uint64_t> bos_token_id,
-      std::optional<uint64_t> eos_token_id,
-      std::unordered_set<std::string> rstrip_tokens = {},
-      std::unordered_set<std::string> lstrip_tokens = {});
-
-  ~UnigramModel() override = default;
-
-  Result<std::vector<uint64_t>> tokenize(
-      const std::string& piece) const override;
-
-  Result<std::string> id_to_piece(uint64_t token) const override;
-  Result<uint64_t> piece_to_id(const std::string& piece) const override;
-
-  int32_t vocab_size() const override {
-    return vocab_size_;
-  }
-
-  bool is_special_token(uint64_t token) const override;
-
-  bool is_loaded() const override {
-    return initialized_;
-  }
-
-  std::pair<std::optional<std::string>, std::string>
-  split_with_allowed_special_token(const std::string& input, size_t offset)
-      const override;
-
-  bool special_token_has_rstrip(const std::string& token) const override {
-    return rstrip_tokens_.count(token) > 0;
-  }
-  bool special_token_has_lstrip(const std::string& token) const override {
-    return lstrip_tokens_.count(token) > 0;
-  }
-
-  uint64_t bos_token_id() const override {
-    return bos_token_id_.value_or(0);
-  }
-
-  uint64_t eos_token_id() const override {
-    return eos_token_id_.value_or(0);
-  }
-
- private:
-  // --- Trie for efficient prefix matching of vocabulary tokens ---
-  struct TrieNode {
-    std::unordered_map<uint8_t, size_t> children;
-    int64_t token_id = -1; // -1 = no token ends at this node
-  };
-
-  void build_trie();
-
-  // Vocabulary: indexed by token id.
-  std::vector<std::string> pieces_;
-  std::vector<double> scores_;
-  std::unordered_map<std::string, uint64_t> piece_to_id_map_;
-
-  // Byte trie for prefix matching during Viterbi.
-  std::vector<TrieNode> trie_;
-
-  // Special-token handling (same pattern as BPEModel / WordPieceModel).
-  detail::TokenMap special_token_map_;
-  std::unique_ptr<IRegex> special_token_regex_;
-
-  bool byte_fallback_ = false;
-  std::optional<uint64_t> unk_token_id_;
-  std::optional<uint64_t> bos_token_id_;
-  std::optional<uint64_t> eos_token_id_;
-  std::unordered_set<std::string> rstrip_tokens_;
-  std::unordered_set<std::string> lstrip_tokens_;
-
-  double min_score_ = 0.0;
-  int32_t vocab_size_ = 0;
-  bool initialized_ = false;
-};
-
-} // namespace tokenizers
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/wordlevel_model.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/wordlevel_model.h
deleted file mode 100644
index 029da642d3..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/wordlevel_model.h
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-// @lint-ignore-every LICENSELINT
-
-#pragma once
-
-#include <memory>
-#include <optional>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-#include <pytorch/tokenizers/model.h>
-#include <pytorch/tokenizers/regex.h>
-#include <pytorch/tokenizers/result.h>
-#include <pytorch/tokenizers/string_integer_map.h>
-
-namespace tokenizers {
-
-/**
- * WordLevel model — the simplest tokenization model.
- *
- * Maps whole words directly to token IDs via vocabulary lookup.
- * Unknown words map to unk_token_id.
- *
- * JSON format in tokenizer.json:
- *   "model": {
- *     "type": "WordLevel",
- *     "vocab": {"hello": 0, "world": 1, ...},
- *     "unk_token": "[UNK]"
- *   }
- */
-class WordLevelModel : public Model {
- public:
-  explicit WordLevelModel(
-      detail::TokenMap token_map,
-      detail::TokenMap special_token_map,
-      std::unique_ptr<IRegex> special_token_regex,
-      std::optional<uint64_t> unk_token_id,
-      std::optional<uint64_t> bos_token_id,
-      std::optional<uint64_t> eos_token_id,
-      std::unordered_set<std::string> rstrip_tokens = {},
-      std::unordered_set<std::string> lstrip_tokens = {});
-
-  ~WordLevelModel() override = default;
-
-  Result<std::vector<uint64_t>> tokenize(
-      const std::string& piece) const override;
-
-  Result<std::string> id_to_piece(uint64_t token) const override;
-  Result<uint64_t> piece_to_id(const std::string& piece) const override;
-
-  int32_t vocab_size() const override {
-    return vocab_size_;
-  }
-
-  bool is_special_token(uint64_t token) const override;
-
-  bool is_loaded() const override {
-    return initialized_;
-  }
-
-  std::pair<std::optional<std::string>, std::string>
-  split_with_allowed_special_token(const std::string& input, size_t offset)
-      const override;
-
-  bool special_token_has_rstrip(const std::string& token) const override {
-    return rstrip_tokens_.count(token) > 0;
-  }
-  bool special_token_has_lstrip(const std::string& token) const override {
-    return lstrip_tokens_.count(token) > 0;
-  }
-
-  uint64_t bos_token_id() const override {
-    return bos_token_id_.value_or(0);
-  }
-
-  uint64_t eos_token_id() const override {
-    return eos_token_id_.value_or(0);
-  }
-
- private:
-  detail::TokenMap token_map_;
-  detail::TokenMap special_token_map_;
-  std::unique_ptr<IRegex> special_token_regex_;
-
-  std::optional<uint64_t> unk_token_id_;
-  std::optional<uint64_t> bos_token_id_;
-  std::optional<uint64_t> eos_token_id_;
-  std::unordered_set<std::string> rstrip_tokens_;
-  std::unordered_set<std::string> lstrip_tokens_;
-
-  bool initialized_ = false;
-  int32_t vocab_size_ = 0;
-};
-
-} // namespace tokenizers
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/wordpiece_model.h b/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/wordpiece_model.h
deleted file mode 100644
index 2528adb933..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/llm/tokenizers/include/pytorch/tokenizers/wordpiece_model.h
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-// @lint-ignore-every LICENSELINT
-
-#pragma once
-
-#include <memory>
-#include <optional>
-#include <string>
-#include <vector>
-
-#include <pytorch/tokenizers/model.h>
-#include <pytorch/tokenizers/regex.h>
-#include <pytorch/tokenizers/result.h>
-#include <pytorch/tokenizers/string_integer_map.h>
-
-namespace tokenizers {
-
-class WordPieceModel : public Model {
- public:
-  explicit WordPieceModel(
-      detail::TokenMap token_map,
-      detail::TokenMap special_token_map,
-      std::string unk_token,
-      std::string continuing_subword_prefix,
-      size_t max_input_chars_per_word,
-      std::optional<uint64_t> unk_token_id,
-      std::optional<uint64_t> bos_token_id,
-      std::optional<uint64_t> eos_token_id,
-      std::unordered_set<std::string> rstrip_tokens = {},
-      std::unordered_set<std::string> lstrip_tokens = {});
-
-  ~WordPieceModel() override = default;
-
-  Result<std::vector<uint64_t>> tokenize(
-      const std::string& piece) const override;
-
-  Result<std::string> id_to_piece(uint64_t token) const override;
-  Result<uint64_t> piece_to_id(const std::string& token) const override;
-
-  int32_t vocab_size() const override {
-    return vocab_size_;
-  }
-
-  bool is_special_token(uint64_t token) const override;
-
-  bool is_loaded() const override {
-    return initialized_;
-  }
-
-  std::pair<std::optional<std::string>, std::string>
-  split_with_allowed_special_token(const std::string& input, size_t offset)
-      const override;
-
-  uint64_t bos_token_id() const override {
-    return bos_token_id_.value_or(0);
-  }
-
-  uint64_t eos_token_id() const override {
-    return eos_token_id_.value_or(0);
-  }
-
-  bool special_token_has_rstrip(const std::string& token) const override {
-    return rstrip_tokens_.count(token) > 0;
-  }
-  bool special_token_has_lstrip(const std::string& token) const override {
-    return lstrip_tokens_.count(token) > 0;
-  }
-
- private:
-  detail::TokenMap token_map_;
-  detail::TokenMap special_token_map_;
-  std::unique_ptr<IRegex> special_token_regex_;
-  
-  std::string unk_token_;
-  std::string continuing_subword_prefix_;
-  size_t max_input_chars_per_word_;
-
-  std::optional<uint64_t> unk_token_id_;
-  std::optional<uint64_t> bos_token_id_;
-  std::optional<uint64_t> eos_token_id_;
-
-  std::unordered_set<std::string> rstrip_tokens_;
-  std::unordered_set<std::string> lstrip_tokens_;
-
-  bool initialized_ = false;
-  int32_t vocab_size_ = 0;
-};
-
-} // namespace tokenizers
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/module/bundled_module.h b/packages/react-native-executorch/third-party/include/executorch/extension/module/bundled_module.h
deleted file mode 100644
index f412f2760e..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/module/bundled_module.h
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <executorch/extension/module/module.h>
-
-#ifdef USE_ATEN_LIB
-#define ET_BUNDLED_MODULE_NAMESPACE bundled_module::aten
-#else // !USE_ATEN_LIB
-#define ET_BUNDLED_MODULE_NAMESPACE bundled_module
-#endif // USE_ATEN_LIB
-
-namespace executorch {
-namespace extension {
-
-using ET_MODULE_NAMESPACE::Module;
-
-namespace ET_BUNDLED_MODULE_NAMESPACE {
-
-/**
- * A facade class for loading bundled programs and executing methods within
- * them.
- */
-class BundledModule : public Module {
-public:
-  /**
-   * Constructs an instance with the bundled program buffer pointer.
-   *
-   * This constructor reads the program from bundled program buffer to load the
-   * module with data loader. The bundled program pointer is preserved so that
-   * the portion outside of program is accessible.
-   *
-   * @param[in] bundled_program_ptr A DataLoader used for loading program data.
-   * @param[in] memory_allocator A MemoryAllocator used for memory management.
-   * @param[in] temp_allocator A MemoryAllocator to use when allocating
-   * temporary data during kernel or delegate execution.
-   * @param[in] event_tracer A EventTracer used for tracking and logging events.
-   * @param[in] data_map_loader A DataLoader used for loading external weights.
-   */
-  explicit BundledModule(
-      const void *bundled_program_ptr,
-      std::unique_ptr<runtime::MemoryAllocator> memory_allocator = nullptr,
-      std::unique_ptr<runtime::MemoryAllocator> temp_allocator = nullptr,
-      std::unique_ptr<runtime::EventTracer> event_tracer = nullptr,
-      std::unique_ptr<runtime::DataLoader> data_map_loader = nullptr);
-
-  // Disallow copying
-  BundledModule(const BundledModule &) = delete;
-  BundledModule &operator=(const BundledModule &) = delete;
-  // Disallow copying
-  BundledModule(BundledModule &&) = delete;
-  BundledModule &operator=(BundledModule &&) = delete;
-  // Default destructor
-  ~BundledModule() {
-    if (is_loaded_from_file_) {
-      delete[] static_cast<const uint8_t *>(bundled_program_ptr_);
-    }
-  }
-
-  /**
-   * Constructs an instance by loading a bundled program from a file with
-   * specified memory locking behavior.
-   *
-   * @param[in] file_path The path to the ExecuTorch bundled program file to
-   * load.
-   * @param[in] memory_allocator A MemoryAllocator used for memory management.
-   * @param[in] temp_allocator A MemoryAllocator to use when allocating
-   * temporary data during kernel or delegate execution.
-   * @param[in] event_tracer A EventTracer used for tracking and logging events.
-   * @param[in] data_map_loader A DataLoader used for loading external weights.
-   */
-  ET_NODISCARD static runtime::Result<std::unique_ptr<BundledModule>> from_file(
-      const std::string &file_path,
-      std::unique_ptr<runtime::MemoryAllocator> memory_allocator = nullptr,
-      std::unique_ptr<runtime::MemoryAllocator> temp_allocator = nullptr,
-      std::unique_ptr<runtime::EventTracer> event_tracer = nullptr,
-      std::unique_ptr<runtime::DataLoader> data_map_loader = nullptr);
-
-  using Module::execute;
-
-  /**
-   * Execute a specific method with the input value at the given `testset_idx`
-   * from the bundle to the method. Loads the program and method before
-   * executing if needed.
-   *
-   * This function is a wrapper of `load_bundled_input` in `bundled_program`.
-   *
-   * @param[in] method_name The name of the method to execute.
-   * @param[in] testset_idx The index of the input value to be passed to the
-   * method.
-   *
-   * @returns Return Error::Ok on a successful load, or the error happens during
-   * execution.
-   */
-  ET_NODISCARD
-  runtime::Result<std::vector<runtime::EValue>>
-  execute(const std::string &method_name, const size_t testset_idx);
-
-  /**
-   * Verify the output of a specific method with the expected output from the
-   * program bundle at the given `testset_idx`.
-   *
-   * This function is a wrapper of `verify_method_outputs` in `bundled_program`.
-   *
-   * @param[in] method_name The name of the method to extract outputs from.
-   * @param[in] testset_idx  The index of expected output needs to be compared.
-   * @param[in] rtol Relative tolerance used for data comparsion.
-   * @param[in] atol Absolute tolerance used for data comparsion.
-   *
-   * @returns Return Error::Ok if two outputs match, or the error happens during
-   * execution.
-   */
-  ET_NODISCARD
-  runtime::Error verify_method_outputs(const std::string &method_name,
-                                       const size_t testset_idx,
-                                       double rtol = 1e-5, double atol = 1e-8);
-
-private:
-  const void *bundled_program_ptr_;
-  bool is_loaded_from_file_ = false;
-};
-
-} // namespace ET_BUNDLED_MODULE_NAMESPACE
-} // namespace extension
-} // namespace executorch
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/module/module.h b/packages/react-native-executorch/third-party/include/executorch/extension/module/module.h
deleted file mode 100644
index 9dadc846ee..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/module/module.h
+++ /dev/null
@@ -1,764 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-#include <executorch/runtime/backend/backend_options_map.h>
-#include <executorch/runtime/backend/options.h>
-#include <executorch/runtime/executor/program.h>
-
-#ifdef USE_ATEN_LIB
-#define ET_MODULE_NAMESPACE module::aten
-#else // !USE_ATEN_LIB
-#define ET_MODULE_NAMESPACE module
-#endif // USE_ATEN_LIB
-
-namespace executorch {
-namespace extension {
-
-using ET_RUNTIME_NAMESPACE::Kernel;
-using ET_RUNTIME_NAMESPACE::Method;
-using ET_RUNTIME_NAMESPACE::MethodMeta;
-using ET_RUNTIME_NAMESPACE::NamedDataMap;
-using ET_RUNTIME_NAMESPACE::Program;
-using runtime::LoadBackendOptionsMap;
-
-class ExecuTorchJni;
-
-namespace ET_MODULE_NAMESPACE {
-/**
- * A facade class for loading programs and executing methods within them.
- */
-class Module {
-public:
-  /**
-   * Enum to define loading behavior.
-   */
-  enum class LoadMode {
-    /// Load the whole file as a buffer.
-    File,
-    /// Use mmap to load pages into memory.
-    Mmap,
-    /// Use memory locking and handle errors.
-    MmapUseMlock,
-    /// Use memory locking and ignore errors.
-    MmapUseMlockIgnoreErrors,
-    /// Use mmap with madvise(MADV_WILLNEED | MADV_SEQUENTIAL) hints.
-    MmapUseMadvise,
-  };
-
-  /**
-   * Constructs an instance by loading a program from a file with specified
-   * memory locking behavior.
-   *
-   * @param[in] file_path The path to the ExecuTorch program file to load.
-   * @param[in] load_mode The loading mode to use.
-   * @param[in] event_tracer A EventTracer used for tracking and logging events.
-   * @param[in] share_memory_arenas When true, all methods loaded by this Module
-   * share the same memory-planned buffers for mem_id=1 (activation memory)
-   * and mem_id=2 (shared mutable buffer memory), sized to the max
-   * across all methods. mem_id>2 indicates a custom memory plan, and those
-   * receive fresh memory buffers. share_memory_arenas is required for models
-   * exported with share_mutable_buffers=true, where methods access shared
-   * mutable state (e.g., set/get state). When enabled, outputs from one method
-   * may be invalidated by executing another method, since their output tensors
-   * can alias the same underlying buffer. Consume or copy outputs before
-   * calling execute again. NOTE: This class is not thread-safe and performs
-   * no internal synchronization. Calling execute concurrently on the same
-   * Module instance from multiple threads is unsafe, regardless of whether
-   * share_memory_arenas is true or false. When share_memory_arenas is true,
-   * methods may overwrite each other's data in the shared memory arenas,
-   * increasing aliasing and the risk of unintended overwrites.
-   */
-  explicit Module(
-      const std::string &file_path, const LoadMode load_mode = LoadMode::File,
-      std::unique_ptr<runtime::EventTracer> event_tracer = nullptr,
-      std::unique_ptr<runtime::MemoryAllocator> memory_allocator = nullptr,
-      std::unique_ptr<runtime::MemoryAllocator> temp_allocator = nullptr,
-      bool share_memory_arenas = false);
-
-  /**
-   * Constructs an instance by loading a program from a file with specified
-   * memory locking behavior.
-   *
-   * @param[in] file_path The path to the ExecuTorch program file to load.
-   * @param[in] data_map_path The path to a .ptd file.
-   * @param[in] load_mode The loading mode to use.
-   * @param[in] event_tracer A EventTracer used for tracking and logging events.
-   * @param[in] share_memory_arenas When true, all methods loaded by this Module
-   * share a single set of memory-planned buffers.
-   */
-  explicit Module(
-      const std::string &file_path, const std::string &data_map_path,
-      const LoadMode load_mode = LoadMode::File,
-      std::unique_ptr<runtime::EventTracer> event_tracer = nullptr,
-      std::unique_ptr<runtime::MemoryAllocator> memory_allocator = nullptr,
-      std::unique_ptr<runtime::MemoryAllocator> temp_allocator = nullptr,
-      bool share_memory_arenas = false);
-
-  /**
-   * Constructs an instance by loading a program from a file with specified
-   * memory locking behavior.
-   *
-   * @param[in] file_path The path to the ExecuTorch program file to load.
-   * @param[in] data_files The path to one or more .ptd file/s.
-   * @param[in] load_mode The loading mode to use.
-   * @param[in] event_tracer A EventTracer used for tracking and logging events.
-   * @param[in] share_memory_arenas When true, all methods loaded by this Module
-   * share a single set of memory-planned buffers.
-   */
-  explicit Module(
-      const std::string &file_path, std::vector<std::string> data_files,
-      const LoadMode load_mode = LoadMode::File,
-      std::unique_ptr<runtime::EventTracer> event_tracer = nullptr,
-      std::unique_ptr<runtime::MemoryAllocator> memory_allocator = nullptr,
-      std::unique_ptr<runtime::MemoryAllocator> temp_allocator = nullptr,
-      bool share_memory_arenas = false);
-
-  /**
-   * Constructs an instance with the provided data loader and memory allocator.
-   *
-   * @param[in] data_loader A DataLoader used for loading program data.
-   * @param[in] memory_allocator A MemoryAllocator used for memory management.
-   * @param[in] temp_allocator A MemoryAllocator to use when allocating
-   * temporary data during kernel or delegate execution.
-   * @param[in] event_tracer A EventTracer used for tracking and logging events.
-   * @param[in] data_map_loader A DataLoader used for loading external weights.
-   * @param[in] share_memory_arenas When true, all methods loaded by this Module
-   * share a single set of memory-planned buffers.
-   */
-  explicit Module(
-      std::unique_ptr<runtime::DataLoader> data_loader,
-      std::unique_ptr<runtime::MemoryAllocator> memory_allocator = nullptr,
-      std::unique_ptr<runtime::MemoryAllocator> temp_allocator = nullptr,
-      std::unique_ptr<runtime::EventTracer> event_tracer = nullptr,
-      std::unique_ptr<runtime::DataLoader> data_map_loader = nullptr,
-      bool share_memory_arenas = false);
-
-  /**
-   * Constructs an instance using an existing shared program.
-   *
-   * @param[in] program The shared program to use. It's required the data loader
-   * the program uses is valid for the lifetime of the program.
-   * @param[in] memory_allocator A MemoryAllocator used for memory management.
-   * @param[in] temp_allocator A MemoryAllocator to use when allocating
-   * temporary data.
-   * @param[in] event_tracer A EventTracer used for tracking and logging events.
-   * @param[in] data_map_loader A DataLoader used for loading external weights.
-   * @param[in] share_memory_arenas When true, all methods loaded by this Module
-   * share a single set of memory-planned buffers.
-   */
-  explicit Module(
-      std::shared_ptr<Program> program,
-      std::unique_ptr<runtime::MemoryAllocator> memory_allocator = nullptr,
-      std::unique_ptr<runtime::MemoryAllocator> temp_allocator = nullptr,
-      std::unique_ptr<runtime::EventTracer> event_tracer = nullptr,
-      std::unique_ptr<runtime::DataLoader> data_map_loader = nullptr,
-      bool share_memory_arenas = false);
-
-  Module(const Module &) = delete;
-  Module &operator=(const Module &) = delete;
-  Module(Module &&) = delete;
-  Module &operator=(Module &&) = delete;
-  virtual ~Module() = default;
-  /**
-   * Loads the program if needed.
-   *
-   * @param[in] verification The type of verification to do before returning
-   * success.
-   *
-   * @returns An Error to indicate success or failure of the loading process.
-   */
-  ET_NODISCARD virtual runtime::Error
-  load(const Program::Verification verification =
-           Program::Verification::Minimal);
-
-  /**
-   * Loads the program with per-delegate runtime options.
-   *
-   * The Module deep-copies `backend_options` into internal storage, so the
-   * caller may release the input (and any backing BackendOption arrays its
-   * Spans referenced) immediately after this call returns. Future lazy
-   * `load_method` calls (e.g. triggered by `forward`) consume the
-   * Module-owned copy.
-   *
-   * Transactional: on failure, the previously-installed backend options
-   * (if any) are left in place; the input is not committed.
-   *
-   * @param[in] backend_options A LoadBackendOptionsMap containing
-   * per-delegate load-time configuration options. Deep-copied into the
-   * Module on success; not retained on failure.
-   * @param[in] verification The type of verification to do before returning
-   * success.
-   *
-   * @returns An Error to indicate success or failure of the loading process.
-   */
-  ET_NODISCARD virtual runtime::Error
-  load(const LoadBackendOptionsMap &backend_options,
-       const Program::Verification verification =
-           Program::Verification::Minimal);
-
-  /**
-   * Returns the deep-copied LoadBackendOptionsMap most recently installed
-   * via `load(LoadBackendOptionsMap, ...)`. The returned reference is owned
-   * by the Module and remains valid until the next call to
-   * `load(LoadBackendOptionsMap, ...)` or until the Module is destroyed.
-   *
-   * If `load(LoadBackendOptionsMap, ...)` has never been called, returns a
-   * default-constructed (empty, `size() == 0`) map.
-   *
-   * @returns Const reference to the Module-owned LoadBackendOptionsMap.
-   */
-  inline const LoadBackendOptionsMap &backend_options() const {
-    return backend_options_map_;
-  }
-
-  /**
-   * Checks if the program is loaded.
-   *
-   * @returns true if the program is loaded, false otherwise.
-   */
-  virtual inline bool is_loaded() const { return program_ != nullptr; }
-
-  /**
-   * Get the program. The data loader used by the program is guaranteed to be
-   * valid for the lifetime of the program.
-   *
-   * @returns Shared pointer to the program or nullptr if it's not yet loaded.
-   */
-  inline std::shared_ptr<Program> program() const { return program_; }
-
-  /**
-   * Get the number of methods available in the loaded program.
-   *
-   * @returns A Result object containing either the number of methods available
-   *          or an error to indicate failure.
-   */
-  runtime::Result<size_t> num_methods();
-
-  /**
-   * Get a list of method names available in the loaded program.
-   * Loads the program and method if needed.
-   *
-   * @returns A set of strings containing the names of the methods, or an error
-   * if the program or method failed to load.
-   */
-  runtime::Result<std::unordered_set<std::string>> method_names();
-
-  /**
-   * Load a specific method from the program and set up memory management if
-   * needed. The loaded method is cached to reuse the next time it's executed.
-   *
-   * @param[in] method_name The name of the method to load.
-   * @param[in] planned_memory The memory-planned buffers to use for mutable
-   * tensor data when executing a method.
-   * @param[in] event_tracer Per-method event tracer to profile/trace methods
-   * individually. When not given, the event tracer passed to the Module
-   * constructor is used. Otherwise, this per-method event tracer takes
-   * precedence.
-   *
-   * @returns An Error to indicate success or failure.
-   */
-  ET_NODISCARD
-  runtime::Error
-  load_method(const std::string &method_name,
-              runtime::HierarchicalAllocator *planned_memory = nullptr,
-              torch::executor::EventTracer *event_tracer = nullptr,
-              const LoadBackendOptionsMap *backend_options = nullptr,
-              std::vector<Kernel> kernel_registry = {});
-
-  ET_DEPRECATED ET_NODISCARD runtime::Error inline load_method(
-      const std::string &method_name,
-      torch::executor::EventTracer *event_tracer) {
-    return load_method(method_name, nullptr, event_tracer, nullptr);
-  }
-
-  /**
-   * Unload a specific method from the program.
-   *
-   * @param[in] method_name The name of the method to unload.
-   *
-   * @returns True if the method is unloaded, false if no-op.
-   */
-  inline bool unload_method(const std::string &method_name) {
-    return methods_.erase(method_name);
-  }
-
-  /**
-   * DEPRECATED: Module manages each Method exclusively.
-   *
-   * Get a method by it's name. Not recommended to use this method directly as
-   * an end user. It's exposed to allow for composability of module in apis that
-   * operate on method.
-   *
-   * @param[in] method_name The name of the method to get.
-   *
-   * @returns A Result object containing either a pointer to the requested
-   *          method or an error to indicate failure.
-   */
-  ET_DEPRECATED ET_NODISCARD runtime::Result<Method *>
-  method(const std::string &method_name);
-
-  /**
-   * Load the 'forward' method from the program and set up memory management if
-   * needed. The loaded method is cached to reuse the next time it's executed.
-   *
-   * @param[in] planned_memory The memory-planned buffers to use for mutable
-   * tensor data when executing the 'forward' method.
-   * @param[in] event_tracer An event tracer used for tracking and logging
-   * events.
-   *
-   * @returns An Error to indicate success or failure.
-   */
-  ET_NODISCARD inline runtime::Error
-  load_forward(runtime::HierarchicalAllocator *planned_memory = nullptr,
-               torch::executor::EventTracer *event_tracer = nullptr,
-               const LoadBackendOptionsMap *backend_options = nullptr,
-               std::vector<Kernel> kernel_registry = {}) {
-    return load_method("forward", planned_memory, event_tracer, backend_options,
-                       std::move(kernel_registry));
-  }
-
-  ET_DEPRECATED ET_NODISCARD inline runtime::Error
-  load_forward(torch::executor::EventTracer *event_tracer) {
-    return load_forward(nullptr, event_tracer, nullptr);
-  }
-
-  /**
-   * Unload the 'forward' method from the program.
-   *
-   * @returns True if the 'forward' method is unloaded, false if no-op.
-   */
-  inline bool unload_forward() { return unload_method("forward"); }
-
-  /**
-   * Checks if a specific method is loaded.
-   *
-   * @param[in] method_name The name of the method to check.
-   *
-   * @returns true if the method specified by method_name is loaded, false
-   * otherwise.
-   */
-  inline bool is_method_loaded(const std::string &method_name) const {
-    return methods_.count(method_name);
-  }
-
-  /**
-   * Get a method metadata struct by method name.
-   * Loads the program if needed.
-   *
-   * @param[in] method_name The name of the method to get the metadata for.
-   *
-   * @returns A method metadata, or an error if the program or method failed to
-   * load.
-   */
-  runtime::Result<MethodMeta> method_meta(const std::string &method_name);
-
-  /**
-   * Execute a specific method with the given input values and retrieve the
-   * output values. Loads the program and method before executing if needed.
-   *
-   * @param[in] method_name The name of the method to execute.
-   * @param[in] input_values A vector of input values to be passed to the
-   * method.
-   *
-   * @returns A Result object containing either a vector of output values
-   *          from the method or an error to indicate failure.
-   */
-  ET_NODISCARD virtual runtime::Result<std::vector<runtime::EValue>>
-  execute(const std::string &method_name,
-          const std::vector<runtime::EValue> &input_values);
-
-  /**
-   * Execute a specific method with a single input value.
-   * Loads the program and method before executing if needed.
-   *
-   * @param[in] method_name The name of the method to execute.
-   * @param[in] input_value A value to be passed to the method.
-   *
-   * @returns A Result object containing either a vector of output values
-   *          from the method or an error to indicate failure.
-   */
-  ET_NODISCARD inline runtime::Result<std::vector<runtime::EValue>>
-  execute(const std::string &method_name, const runtime::EValue &input_value) {
-    return execute(method_name, std::vector<runtime::EValue>{input_value});
-  }
-
-  /**
-   * Execute a specific method without any input values.
-   * Loads the program and method before executing if needed.
-   *
-   * @param[in] method_name The name of the method to execute.
-   *
-   * @returns A Result object containing either a vector of output values
-   *          from the method or an error to indicate failure.
-   */
-  ET_NODISCARD inline runtime::Result<std::vector<runtime::EValue>>
-  execute(const std::string &method_name) {
-    return execute(method_name, std::vector<runtime::EValue>{});
-  }
-
-  /**
-   * Retrieve the output value of a specific method with the given input values.
-   * Loads the program and method before execution if needed.
-   *
-   * @param[in] method_name The name of the method to execute.
-   * @param[in] input_values A vector of input values to be passed to the
-   * method.
-   *
-   * @returns A Result object containing either the first output value from the
-   * method or an error to indicate failure.
-   */
-  ET_NODISCARD inline runtime::Result<runtime::EValue>
-  get(const std::string &method_name,
-      const std::vector<runtime::EValue> &input_values) {
-    auto execute_result = execute(method_name, input_values);
-    if (!execute_result.ok()) {
-      return execute_result.error();
-    }
-    auto result = std::move(*execute_result);
-    if (result.empty()) {
-      return runtime::Error::InvalidArgument;
-    }
-    return result[0];
-  }
-
-  /**
-   * Retrieve the output value of a specific method with a single input value.
-   * Loads the program and method before execution if needed.
-   *
-   * @param[in] method_name The name of the method to execute.
-   * @param[in] input_value A value to be passed to the method.
-   *
-   * @returns A Result object containing either the first output value from the
-   * method or an error to indicate failure.
-   */
-  ET_NODISCARD inline runtime::Result<runtime::EValue>
-  get(const std::string &method_name, const runtime::EValue &input_value) {
-    return get(method_name, std::vector<runtime::EValue>{input_value});
-  }
-
-  /**
-   * Retrieve the output value of a specific method without any input values.
-   * Loads the program and method before execution if needed.
-   *
-   * @param[in] method_name The name of the method to execute.
-   *
-   * @returns A Result object containing either the first output value from the
-   * method or an error to indicate failure.
-   */
-  ET_NODISCARD inline runtime::Result<runtime::EValue>
-  get(const std::string &method_name) {
-    return get(method_name, std::vector<runtime::EValue>{});
-  }
-
-  /**
-   * Execute the 'forward' method with the given input values and retrieve the
-   * output values. Loads the program and method before executing if needed.
-   *
-   * @param[in] input_values A vector of input values for the 'forward' method.
-   *
-   * @returns A Result object containing either a vector of output values
-   *          from the 'forward' method or an error to indicate failure.
-   */
-  ET_NODISCARD inline runtime::Result<std::vector<runtime::EValue>>
-  forward(const std::vector<runtime::EValue> &input_values) {
-    return execute("forward", input_values);
-  }
-
-  /**
-   * Execute the 'forward' method with a single value.
-   * Loads the program and method before executing if needed.
-   *
-   * @param[in] input_value A value for the 'forward' method.
-   *
-   * @returns A Result object containing either a vector of output values
-   *          from the 'forward' method or an error to indicate failure.
-   */
-  ET_NODISCARD inline runtime::Result<std::vector<runtime::EValue>>
-  forward(const runtime::EValue &input_value) {
-    return forward(std::vector<runtime::EValue>{input_value});
-  }
-
-  /**
-   * Execute the 'forward' method without any input values.
-   * Loads the program and method before executing if needed.
-   *
-   * @returns A Result object containing either a vector of output values
-   *          from the 'forward' method or an error to indicate failure.
-   */
-  ET_NODISCARD inline runtime::Result<std::vector<runtime::EValue>> forward() {
-    return forward(std::vector<runtime::EValue>{});
-  }
-
-  /**
-   * Sets a single input value for a specific method.
-   *
-   * @param[in] method_name The name of the method.
-   * @param[in] input_value The EValue to set as the method input.
-   * @param[in] input_index Zero-based index of the input to set.
-   *
-   * @returns An Error to indicate success or failure.
-   */
-  ET_NODISCARD
-  runtime::Error set_input(const std::string &method_name,
-                           const runtime::EValue &input_value,
-                           size_t input_index);
-
-  /**
-   * Sets a single input value for the "forward" method.
-   *
-   * @param[in] input_value The EValue to set as the method input.
-   * @param[in] input_index Zero-based index of the input to set.
-   *
-   * @returns An Error to indicate success or failure.
-   */
-  ET_NODISCARD
-  inline runtime::Error set_input(const runtime::EValue &input_value,
-                                  size_t input_index) {
-    return set_input("forward", input_value, input_index);
-  }
-
-  /**
-   * Sets all input values for a specific method.
-   *
-   * @param[in] method_name The name of the method.
-   * @param[in] input_values A vector of EValues to set as the method inputs.
-   *
-   * @returns An Error to indicate success or failure.
-   */
-  ET_NODISCARD
-  runtime::Error set_inputs(const std::string &method_name,
-                            const std::vector<runtime::EValue> &input_values);
-
-  /**
-   * Sets all input values for the "forward" method.
-   *
-   * @param[in] input_values A vector of EValues to set as the method inputs.
-   *
-   * @returns An Error to indicate success or failure.
-   */
-  ET_NODISCARD
-  inline runtime::Error
-  set_inputs(const std::vector<runtime::EValue> &input_values) {
-    return set_inputs("forward", input_values);
-  }
-
-  /**
-   * Sets the output tensor for a specific method.
-   *
-   * @param[in] method_name The name of the method.
-   * @param[in] output_value The EValue containing the Tensor to set as the
-   * method output.
-   * @param[in] output_index Zero-based index of the output to set.
-   *
-   * @returns An Error to indicate success or failure.
-   *
-   * @note Only Tensor outputs are currently supported for setting.
-   */
-  ET_NODISCARD
-  runtime::Error set_output(const std::string &method_name,
-                            runtime::EValue output_value,
-                            size_t output_index = 0);
-
-  /**
-   * Sets the output tensor for the "forward" method.
-   *
-   * @param[in] output_value The EValue containing the Tensor to set as the
-   * method output.
-   * @param[in] output_index Zero-based index of the output to set.
-   *
-   * @returns An Error to indicate success or failure.
-   *
-   * @note Only Tensor outputs are currently supported for setting.
-   */
-  ET_NODISCARD
-  inline runtime::Error set_output(runtime::EValue output_value,
-                                   size_t output_index = 0) {
-    return set_output("forward", std::move(output_value), output_index);
-  }
-
-  /**
-   * Sets all output tensors for a specific method.
-   *
-   * Loads the program and method if needed, and for each output uses
-   * the provided tensor's data buffer as the method's output buffer.
-   *
-   * @param[in] method_name The name of the method.
-   * @param[in] output_values A vector of EValues to set as the method outputs.
-   *
-   * @returns An Error to indicate success or failure.
-   *
-   * @note Only Tensor outputs are currently supported for setting.
-   * @note Will fail for outputs that are memory-planned or constants.
-   */
-  ET_NODISCARD
-  runtime::Error set_outputs(const std::string &method_name,
-                             const std::vector<runtime::EValue> &output_values);
-
-  /**
-   * Sets all output tensors for the "forward" method.
-   *
-   * @param[in] output_values A vector of EValues to set as the method outputs.
-   *
-   * @returns An Error to indicate success or failure.
-   *
-   * @note Only Tensor outputs are currently supported for setting.
-   * @note Will fail for outputs that are memory-planned or constants.
-   */
-  ET_NODISCARD
-  inline runtime::Error
-  set_outputs(const std::vector<runtime::EValue> &output_values) {
-    return set_outputs("forward", output_values);
-  }
-
-  /**
-   * Retrieve all current output values of a specific method without executing
-   * it. Loads the program and method before retrieval if needed.
-   *
-   * @param[in] method_name The name of the method.
-   *
-   * @returns A Result containing the vector of output values, or an error.
-   */
-  ET_NODISCARD
-  runtime::Result<std::vector<runtime::EValue>>
-  get_outputs(const std::string &method_name);
-
-  /**
-   * Retrieve all current output values of the "forward" method without
-   * executing it. Loads the program and method before retrieval if needed.
-   *
-   * @returns A Result containing the vector of output values, or an error.
-   */
-  ET_NODISCARD
-  inline runtime::Result<std::vector<runtime::EValue>> get_outputs() {
-    return get_outputs("forward");
-  }
-
-  /**
-   * Retrieve a single current output value of a specific method without
-   * executing it. Loads the program and method before retrieval if needed.
-   *
-   * @param[in] method_name The name of the method.
-   * @param[in] output_index Zero-based index of the output to retrieve.
-   *
-   * @returns A Result containing the requested output value, or an error.
-   */
-  ET_NODISCARD
-  runtime::Result<runtime::EValue> get_output(const std::string &method_name,
-                                              size_t output_index = 0);
-
-  /**
-   * Retrieve a single current output value of the "forward" method without
-   * executing it. Loads the program and method before retrieval if needed.
-   *
-   * @param[in] output_index Zero-based index of the output to retrieve.
-   *
-   * @returns A Result containing the requested output value, or an error.
-   */
-  ET_NODISCARD
-  inline runtime::Result<runtime::EValue> get_output(size_t output_index = 0) {
-    return get_output("forward", output_index);
-  }
-
-  /**
-   * Retrieves the EventTracer instance being used by the Module.
-   * EventTracer is used for tracking and logging events during the execution
-   * of methods.
-   *
-   * @returns A pointer to the EventTracer instance. Returns nullptr if no
-   * EventTracer is set.
-   */
-  inline runtime::EventTracer *event_tracer() const {
-    return event_tracer_.get();
-  }
-
-  // Note: this debug_buffer will always be empty. The one being used is in
-  // the event_tracer attached to module. Please use that one.
-  ET_DEPRECATED ET_NODISCARD runtime::Span<uint8_t> debug_buffer() {
-    return runtime::Span<uint8_t>(debug_buffer_.data(), debug_buffer_.size());
-  }
-
-private:
-  struct PlannedMemory {
-    std::vector<std::vector<uint8_t>> planned_buffers;
-    std::vector<runtime::Span<uint8_t>> planned_spans;
-    std::unique_ptr<runtime::HierarchicalAllocator> planned_memory;
-  };
-  std::unique_ptr<PlannedMemory>
-  make_planned_memory(const std::vector<size_t> &buffer_sizes);
-  std::unique_ptr<PlannedMemory> make_planned_memory_with_shared_arenas(
-      const std::vector<size_t> &buffer_sizes,
-      std::vector<std::vector<uint8_t>> &shared_arenas);
-  runtime::Result<std::vector<size_t>>
-  get_mem_planned_buffer_sizes(const std::string &method_name);
-  runtime::Result<std::vector<size_t>> get_max_mem_planned_buffer_sizes();
-
-  struct MethodHolder {
-    std::unique_ptr<PlannedMemory> planned_memory;
-    std::unique_ptr<runtime::MemoryManager> memory_manager;
-    std::unique_ptr<Method> method;
-    std::vector<Kernel> kernel_registry;
-  };
-
-  std::string file_path_;
-  std::vector<std::string> data_files_;
-  LoadMode load_mode_{LoadMode::File};
-  std::shared_ptr<Program> program_;
-  std::unique_ptr<runtime::DataLoader> data_loader_;
-  std::unique_ptr<runtime::MemoryAllocator> memory_allocator_;
-  std::unique_ptr<runtime::MemoryAllocator> temp_allocator_;
-  std::unique_ptr<runtime::EventTracer> event_tracer_;
-  std::vector<std::unique_ptr<runtime::DataLoader>> data_map_loaders_;
-  std::vector<std::unique_ptr<NamedDataMap>> named_data_maps_;
-  std::unique_ptr<NamedDataMap> merged_data_map_;
-  std::vector<std::vector<uint8_t>> shared_arenas_;
-  ET_DEPRECATED std::vector<uint8_t> debug_buffer_;
-  // Module-owned deep-copy of the backend options most recently installed
-  // via load(LoadBackendOptionsMap, ...). `backend_options_storage_` owns
-  // the per-backend BackendOption arrays; `backend_options_map_` is a
-  // LoadBackendOptionsMap whose Spans reference those owned arrays. An
-  // empty map (`size() == 0`) is observationally indistinguishable from
-  // "never set" by downstream consumers, so we don't track that bit.
-  std::vector<std::vector<runtime::BackendOption>> backend_options_storage_;
-  LoadBackendOptionsMap backend_options_map_;
-  bool share_memory_arenas_;
-
-  ET_NODISCARD runtime::Error
-  load_internal(const Program::Verification verification);
-
-protected:
-  std::unordered_map<std::string, MethodHolder> methods_;
-
-  friend class executorch::extension::ExecuTorchJni;
-};
-
-} // namespace ET_MODULE_NAMESPACE
-} // namespace extension
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::extension::ET_MODULE_NAMESPACE::Module;
-} // namespace executor
-} // namespace torch
-
-namespace executorch {
-namespace extension {
-// backward compatible namespace alias
-using ::executorch::extension::ET_MODULE_NAMESPACE::Module;
-} // namespace extension
-} // namespace executorch
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/runner_util/inputs.h b/packages/react-native-executorch/third-party/include/executorch/extension/runner_util/inputs.h
deleted file mode 100644
index 1aa6bdb8b0..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/runner_util/inputs.h
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- * Copyright 2025 Arm Limited and/or its affiliates.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <vector>
-
-#include <executorch/runtime/core/span.h>
-#include <executorch/runtime/executor/method.h>
-#include <executorch/runtime/executor/method_meta.h>
-
-namespace executorch {
-namespace extension {
-
-using ::executorch::ET_RUNTIME_NAMESPACE::Method;
-using ::executorch::ET_RUNTIME_NAMESPACE::TensorInfo;
-
-/**
- * RAII helper that frees a set of buffers when destroyed. Movable.
- */
-class BufferCleanup final {
-public:
-  /**
-   * Takes ownership of `buffers.data()` and the elements of `buffers`, which
-   * each will be passed to `free()` when the object is destroyed.
-   */
-  explicit BufferCleanup(executorch::runtime::Span<void *> buffers)
-      : buffers_(buffers) {}
-
-  /**
-   * Move ctor. Takes ownership of the data previously owned by `rhs`, leaving
-   * `rhs` with an empty list of buffers.
-   */
-  BufferCleanup(BufferCleanup &&rhs) noexcept : buffers_(rhs.buffers_) {
-    rhs.buffers_ = executorch::runtime::Span<void *>();
-  }
-
-  ~BufferCleanup() {
-    for (auto buffer : buffers_) {
-      free(buffer);
-    }
-    free(buffers_.data());
-  }
-
-private:
-  // Delete other rule-of-five methods.
-  BufferCleanup(const BufferCleanup &) = delete;
-  BufferCleanup &operator=(const BufferCleanup &) = delete;
-  BufferCleanup &operator=(BufferCleanup &&) noexcept = delete;
-
-  executorch::runtime::Span<void *> buffers_;
-};
-
-/// Defines options for `prepare_input_tensors()`.
-struct PrepareInputTensorsOptions {
-  /**
-   * The maximum total size in bytes of all input tensors. If the total size of
-   * all inputs exceeds this, an error is returned. This prevents allocating too
-   * much memory if the PTE file is malformed.
-   */
-  size_t max_total_allocation_size = 1024 * 1024 * 1024;
-
-  /**
-   * The maximum number of inputs to allocate. If the number of inputs exceeds
-   * this, an error is returned. This prevents allocating too much memory if the
-   * PTE file is malformed.
-   */
-  size_t max_inputs = 1024;
-};
-
-/**
- * Allocates input tensors for the provided Method, filling them with ones. Does
- * not modify inputs that are not Tensors.
- *
- * @param[in] method The Method that owns the inputs to prepare.
- * @param[in] options Extra options for preparing the inputs.
- *
- * @returns On success, an object that owns any allocated tensor memory. It must
- *     remain alive when calling `method->execute()`.
- * @returns An error on failure.
- */
-executorch::runtime::Result<BufferCleanup> prepare_input_tensors(
-    Method &method, PrepareInputTensorsOptions options = {},
-    const std::vector<std::pair<char *, size_t>> &input_buffers = {});
-
-namespace internal {
-/**
- * INTERNAL-ONLY: Creates a Tensor using the provided shape and buffer,
- * fills it with ones by default, and sets the input at `input_index`.
- */
-executorch::runtime::Error
-fill_and_set_input(Method &method, TensorInfo &tensor_meta, size_t input_index,
-                   void *data_ptr, bool fill_tensor = true);
-} // namespace internal
-
-} // namespace extension
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-namespace util {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::extension::BufferCleanup;
-using ::executorch::extension::prepare_input_tensors;
-} // namespace util
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/tensor/tensor.h b/packages/react-native-executorch/third-party/include/executorch/extension/tensor/tensor.h
deleted file mode 100644
index 467fbb1c16..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/tensor/tensor.h
+++ /dev/null
@@ -1,14 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-// Umbrella header for the Tensor extension.
-#include <executorch/extension/tensor/tensor_accessor.h>
-#include <executorch/extension/tensor/tensor_ptr.h>
-#include <executorch/extension/tensor/tensor_ptr_maker.h>
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/tensor/tensor_accessor.h b/packages/react-native-executorch/third-party/include/executorch/extension/tensor/tensor_accessor.h
deleted file mode 100644
index d5b59b06f5..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/tensor/tensor_accessor.h
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <executorch/runtime/core/result.h>
-
-namespace executorch {
-namespace extension {
-namespace internal {
-
-/**
- * Base class template storing the underlying data with size and stride helpers.
- * Inherited by TensorAccessor<> which requires specialization on rank.
- */
-template <typename T, ssize_t N> class TensorAccessorBase {
-public:
-  /// Returns the size of the underlying tensor at the given dimension.
-  executorch::aten::SizesType size(ssize_t i) const {
-    ET_CHECK_MSG(i < dim_ && i >= 0, "Dimension outside of [0, %zd], got %zd",
-                 dim_ - 1, i);
-    return sizes_[i];
-  }
-
-  /// Returns the stride of the underlying tensor at the given dimension.
-  executorch::aten::StridesType stride(ssize_t i) const {
-    ET_CHECK_MSG(i < dim_ && i >= 0, "Dimension outside of [0, %zd], got %zd",
-                 dim_ - 1, i);
-    return strides_[i];
-  }
-
-protected:
-  TensorAccessorBase(T *data, const executorch::aten::SizesType *sizes,
-                     const executorch::aten::StridesType *strides, ssize_t dim)
-      : data_(data), sizes_(sizes), strides_(strides), dim_(dim) {}
-
-  T *data_;
-  const executorch::aten::SizesType *sizes_;
-  const executorch::aten::StridesType *strides_;
-  ssize_t dim_;
-};
-
-} // namespace internal
-
-/**
- * TensorAccessor template with data type and rank as template parameters. No
- * public constructors, can only be created using make_tensor_accessor from a
- * given executorch::aten::Tensor. Use operator[] to index and obtain a lower
- * rank accessor or the underlying scalar value.
- */
-template <typename T, ssize_t N>
-class TensorAccessor : public internal::TensorAccessorBase<T, N> {
-public:
-  /**
-   * Index into the the outer most dimension.
-   *
-   * @param i Index.
-   * @return If N > 1, a TensorAccessor with N-1 dimensions. If N == 1, a
-   * reference to the underlying scalar. Refer to the TensorAccessor<T, 1>
-   * specialization.
-   */
-  TensorAccessor<T, N - 1> operator[](ssize_t i) {
-    return TensorAccessor<T, N - 1>(this->data_ + this->strides_[0] * i,
-                                    this->sizes_ + 1, this->strides_ + 1,
-                                    N - 1);
-  }
-
-  /**
-   * Index into the the outer most dimension.
-   *
-   * @param i Index.
-   * @return If N > 1, a constant TensorAccessor with N-1 dimensions. If N == 1,
-   * a constant reference to the underlying scalar. Refer to the
-   * TensorAccessor<T, 1> specialization.
-   */
-  const TensorAccessor<T, N - 1> operator[](ssize_t i) const {
-    return TensorAccessor<T, N - 1>(this->data_ + this->strides_[0] * i,
-                                    this->sizes_ + 1, this->strides_ + 1,
-                                    N - 1);
-  }
-
-private:
-  TensorAccessor(T *data, const executorch::aten::SizesType *sizes,
-                 const executorch::aten::StridesType *strides, ssize_t dim)
-      : internal::TensorAccessorBase<T, N>(data, sizes, strides, dim) {}
-
-  template <typename T2, ssize_t N2> friend class TensorAccessor;
-
-  template <typename T2, ssize_t N2>
-  friend executorch::runtime::Result<TensorAccessor<T2, N2>>
-  make_tensor_accessor(const executorch::aten::Tensor &t);
-};
-
-/**
- * TensorAccessor specialization for N == 1, where operator[] returns a
- * reference to the underlying scalar.
- */
-template <typename T>
-class TensorAccessor<T, 1> : public internal::TensorAccessorBase<T, 1> {
-public:
-  /**
-   * Index into the the outer most dimension.
-   *
-   * @param i Index.
-   * @return Reference to the underlying scalar.
-   */
-  T &operator[](ssize_t i) { return this->data_[this->strides_[0] * i]; }
-
-  /**
-   * Index into the the outer most dimension.
-   *
-   * @param i Index.
-   * @return Constant reference to the underlying scalar.
-   */
-  const T &operator[](ssize_t i) const {
-    return this->data_[this->strides_[0] * i];
-  }
-
-private:
-  TensorAccessor(T *data, const executorch::aten::SizesType *sizes,
-                 const executorch::aten::StridesType *strides, ssize_t dim)
-      : internal::TensorAccessorBase<T, 1>(data, sizes, strides, dim) {}
-
-  template <typename T2, ssize_t N2> friend class TensorAccessor;
-
-  template <typename T2, ssize_t N2>
-  friend executorch::runtime::Result<TensorAccessor<T2, N2>>
-  make_tensor_accessor(const executorch::aten::Tensor &t);
-};
-
-/**
- * Creates a TensorAccessor<T, N> from the given tensor. The number of dimension
- * N and the data type T's size must match those of the input tensor. For
- * Executorch tensors, non-trivial dimension order is not supported.
- *
- * @param tensor Origin tensor. The TensorImpl inside must outlive the returned
- * TensorAccessor.
- * @return TensorAccessor of the input tensor.
- * @retval Error::InvalidArgument Mismatch on data type or number of dimensions.
- * @retval Error::NotSupported Input tensor has non-trivial dimension onrder.
- */
-template <typename T, ssize_t N>
-executorch::runtime::Result<TensorAccessor<T, N>>
-make_tensor_accessor(const executorch::aten::Tensor &tensor) {
-  static_assert(N > 0, "TensorAccessor is used for indexing tensors, for "
-                       "scalar use *_data_ptr<T>()");
-
-  if (N != tensor.dim()) {
-    ET_LOG(Error, "Expecting %zd dimensions but tensor has %zd.",
-           static_cast<ssize_t>(N), static_cast<ssize_t>(tensor.dim()));
-    return executorch::runtime::Error::InvalidArgument;
-  }
-
-  if (sizeof(T) != tensor.element_size()) {
-    ET_LOG(Error,
-           "Size of data type template argument (%zd) not equal to tensor "
-           "element size (%zd)",
-           static_cast<ssize_t>(sizeof(T)),
-           static_cast<ssize_t>(tensor.element_size()));
-    return executorch::runtime::Error::InvalidArgument;
-  }
-
-#ifndef USE_ATEN_LIB
-  auto dim_order = tensor.dim_order();
-  for (ssize_t i = 0; i < dim_order.size(); i++) {
-    if (dim_order[i] != i) {
-      ET_LOG(Error, "Non-trival dim_order not supported.");
-      return executorch::runtime::Error::NotSupported;
-    }
-  }
-#endif
-
-  T *ptr = nullptr;
-  if constexpr (std::is_const_v<T>) {
-    ptr = tensor.const_data_ptr<T>();
-  } else {
-    ptr = tensor.mutable_data_ptr<T>();
-  }
-  return TensorAccessor<T, N>(ptr, tensor.sizes().data(),
-                              tensor.strides().data(), N);
-}
-
-} // namespace extension
-} // namespace executorch
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/tensor/tensor_ptr.h b/packages/react-native-executorch/third-party/include/executorch/extension/tensor/tensor_ptr.h
deleted file mode 100644
index 15321ae608..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/tensor/tensor_ptr.h
+++ /dev/null
@@ -1,457 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <algorithm>
-#include <functional>
-#include <memory>
-#include <vector>
-
-#include <c10/macros/Macros.h>
-#include <c10/util/safe_numerics.h>
-#include <executorch/runtime/core/error.h>
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <executorch/runtime/core/exec_aten/util/scalar_type_util.h>
-
-C10_DIAGNOSTIC_PUSH_AND_IGNORED_IF_DEFINED("-Wswitch-enum")
-
-namespace executorch {
-namespace extension {
-
-/**
- * A smart pointer type for managing the lifecycle of a Tensor.
- */
-using TensorPtr = std::shared_ptr<executorch::aten::Tensor>;
-
-/**
- * Creates a TensorPtr that manages a Tensor with the specified properties.
- *
- * @param sizes A vector specifying the size of each dimension.
- * @param data A pointer to the data buffer.
- * @param dim_order A vector specifying the order of dimensions.
- * @param strides A vector specifying the strides of the tensor.
- * @param type The scalar type of the tensor elements.
- * @param dynamism Specifies the mutability of the tensor's shape.
- * @param deleter A custom deleter function for managing the lifetime of the
- * data buffer. If provided, this deleter will be called when the managed Tensor
- * object is destroyed.
- * @return A TensorPtr that manages the newly created Tensor.
- */
-TensorPtr
-make_tensor_ptr(std::vector<executorch::aten::SizesType> sizes, void *data,
-                std::vector<executorch::aten::DimOrderType> dim_order,
-                std::vector<executorch::aten::StridesType> strides,
-                const executorch::aten::ScalarType type =
-                    executorch::aten::ScalarType::Float,
-                const executorch::aten::TensorShapeDynamism dynamism =
-                    executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND,
-                std::function<void(void *)> deleter = nullptr);
-
-/**
- * Creates a TensorPtr that manages a Tensor with the specified properties.
- *
- * @param sizes A vector specifying the size of each dimension.
- * @param data A pointer to the data buffer.
- * @param type The scalar type of the tensor elements.
- * @param dynamism Specifies the mutability of the tensor's shape.
- * @param deleter A custom deleter function for managing the lifetime of the
- * data buffer. If provided, this deleter will be called when the managed Tensor
- * object is destroyed.
- * @return A TensorPtr that manages the newly created Tensor.
- */
-inline TensorPtr
-make_tensor_ptr(std::vector<executorch::aten::SizesType> sizes, void *data,
-                const executorch::aten::ScalarType type =
-                    executorch::aten::ScalarType::Float,
-                const executorch::aten::TensorShapeDynamism dynamism =
-                    executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND,
-                std::function<void(void *)> deleter = nullptr) {
-  return make_tensor_ptr(std::move(sizes), data, {}, {}, type, dynamism,
-                         std::move(deleter));
-}
-
-/**
- * Creates a TensorPtr that manages a Tensor with the specified properties.
- *
- * This template overload is specialized for cases where the tensor data is
- * provided as a vector. The scalar type is automatically deduced from the
- * vector's data type. If the specified `type` differs from the deduced type of
- * the vector's elements, and casting is allowed, the data will be cast to the
- * specified `type`. This allows for flexible creation of tensors with data
- * vectors of one type and a different scalar type.
- *
- * @tparam T The C++ type of the tensor elements, deduced from the vector.
- * @param sizes A vector specifying the size of each dimension.
- * @param data A vector containing the tensor's data.
- * @param dim_order A vector specifying the order of dimensions.
- * @param strides A vector specifying the strides of each dimension.
- * @param type The scalar type of the tensor elements. If it differs from the
- * deduced type, the data will be cast to this type if allowed.
- * @param dynamism Specifies the mutability of the tensor's shape.
- * @return A TensorPtr that manages the newly created TensorImpl.
- */
-template <typename T = float, executorch::aten::ScalarType deduced_type =
-                                  runtime::CppTypeToScalarType<T>::value>
-inline TensorPtr
-make_tensor_ptr(std::vector<executorch::aten::SizesType> sizes,
-                std::vector<T> data,
-                std::vector<executorch::aten::DimOrderType> dim_order = {},
-                std::vector<executorch::aten::StridesType> strides = {},
-                executorch::aten::ScalarType type = deduced_type,
-                executorch::aten::TensorShapeDynamism dynamism =
-                    executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  auto numel_result = executorch::aten::safe_numel(sizes.data(), sizes.size());
-  ET_CHECK_MSG(numel_result.ok(), "safe_numel failed: %d",
-               static_cast<int>(numel_result.error()));
-  ET_CHECK_MSG(data.size() == static_cast<size_t>(numel_result.get()),
-               "Data size does not match tensor size.");
-  if (type != deduced_type) {
-    ET_CHECK_MSG(runtime::canCast(deduced_type, type),
-                 "Cannot cast deduced type to specified type.");
-    size_t casted_bytes = 0;
-    ET_CHECK_MSG(!c10::mul_overflows(
-                     data.size(), static_cast<size_t>(aten::elementSize(type)),
-                     &casted_bytes),
-                 "casted_data size overflow: %zu elements * %zu bytes/element",
-                 data.size(), static_cast<size_t>(aten::elementSize(type)));
-    std::vector<uint8_t> casted_data(casted_bytes);
-
-    // Create a minimal context for error handling in ET_SWITCH
-    struct {
-      [[noreturn]] void fail(torch::executor::Error /* error */) {
-        ET_CHECK_MSG(false, "Unsupported dtype in make_tensor_ptr");
-      }
-    } ctx;
-
-    ET_SWITCH_REALHBBF16_AND_UINT_TYPES(
-        type, ctx, "make_tensor_ptr", CTYPE, [&] {
-          std::transform(data.begin(), data.end(),
-                         reinterpret_cast<CTYPE *>(casted_data.data()),
-                         [](const T &val) { return static_cast<CTYPE>(val); });
-        });
-    const auto raw_data_ptr = casted_data.data();
-    auto data_ptr =
-        std::make_shared<std::vector<uint8_t>>(std::move(casted_data));
-    return make_tensor_ptr(std::move(sizes), raw_data_ptr, std::move(dim_order),
-                           std::move(strides), type, dynamism,
-                           [data_ptr = std::move(data_ptr)](void *) {});
-  }
-  const auto raw_data_ptr = data.data();
-  auto data_ptr = std::make_shared<std::vector<T>>(std::move(data));
-  return make_tensor_ptr(std::move(sizes), raw_data_ptr, std::move(dim_order),
-                         std::move(strides), type, dynamism,
-                         [data_ptr = std::move(data_ptr)](void *) {});
-}
-
-/**
- * Creates a TensorPtr that manages a Tensor with the specified properties.
- *
- * This template overload is specialized for cases where the tensor data is
- * provided as a vector. The scalar type is automatically deduced from the
- * vector's data type. If the specified `type` differs from the deduced type of
- * the vector's elements, and casting is allowed, the data will be cast to the
- * specified `type`. This allows for flexible creation of tensors with data
- * vectors of one type and a different scalar type.
- *
- * @tparam T The C++ type of the tensor elements, deduced from the vector.
- * @param data A vector containing the tensor's data.
- * @param type The scalar type of the tensor elements. If it differs from the
- * deduced type, the data will be cast to this type if allowed.
- * @param dynamism Specifies the mutability of the tensor's shape.
- * @return A TensorPtr that manages the newly created TensorImpl.
- */
-template <typename T = float, executorch::aten::ScalarType deduced_type =
-                                  runtime::CppTypeToScalarType<T>::value>
-inline TensorPtr
-make_tensor_ptr(std::vector<T> data,
-                executorch::aten::ScalarType type = deduced_type,
-                executorch::aten::TensorShapeDynamism dynamism =
-                    executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  std::vector<executorch::aten::SizesType> sizes{
-      executorch::aten::SizesType(data.size())};
-  return make_tensor_ptr(std::move(sizes), std::move(data), {0}, {1}, type,
-                         dynamism);
-}
-
-/**
- * Creates a TensorPtr that manages a Tensor with the specified properties.
- *
- * This template overload is specialized for cases where the tensor data is
- * provided as an initializer list. The scalar type is automatically deduced
- * from the initializer list's data type. If the specified `type` differs from
- * the deduced type of the initializer list's elements, and casting is allowed,
- * the data will be cast to the specified `type`. This allows for flexible
- * creation of tensors with data vectors of one type and a different scalar
- * type.
- *
- * @tparam T The C++ type of the tensor elements, deduced from the initializer
- * list.
- * @param sizes A vector specifying the size of each dimension.
- * @param list An initializer list containing the tensor's data.
- * @param dim_order A vector specifying the order of dimensions.
- * @param strides A vector specifying the strides of each dimension.
- * @param type The scalar type of the tensor elements. If it differs from the
- * deduced type, the data will be cast to this type if allowed.
- * @param dynamism Specifies the mutability of the tensor's shape.
- * @return A TensorPtr that manages the newly created TensorImpl.
- */
-template <typename T = float, executorch::aten::ScalarType deduced_type =
-                                  runtime::CppTypeToScalarType<T>::value>
-inline TensorPtr
-make_tensor_ptr(std::vector<executorch::aten::SizesType> sizes,
-                std::initializer_list<T> list,
-                std::vector<executorch::aten::DimOrderType> dim_order = {},
-                std::vector<executorch::aten::StridesType> strides = {},
-                executorch::aten::ScalarType type = deduced_type,
-                executorch::aten::TensorShapeDynamism dynamism =
-                    executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  return make_tensor_ptr(std::move(sizes), std::vector<T>(std::move(list)),
-                         std::move(dim_order), std::move(strides), type,
-                         dynamism);
-}
-
-/**
- * Creates a TensorPtr that manages a Tensor with the specified properties.
- *
- * This template overload allows creating a Tensor from an initializer list
- * of data. The scalar type is automatically deduced from the type of the
- * initializer list's elements. If the specified `type` differs from
- * the deduced type of the initializer list's elements, and casting is allowed,
- * the data will be cast to the specified `type`. This allows for flexible
- * creation of tensors with data vectors of one type and a different scalar
- * type.
- *
- * @tparam T The C++ type of the tensor elements, deduced from the initializer
- * list.
- * @param list An initializer list containing the tensor's data.
- * @param type The scalar type of the tensor elements. If it differs from the
- * deduced type, the data will be cast to this type if allowed.
- * @param dynamism Specifies the mutability of the tensor's shape.
- * @return A TensorPtr that manages the newly created TensorImpl.
- */
-template <typename T = float, executorch::aten::ScalarType deduced_type =
-                                  runtime::CppTypeToScalarType<T>::value>
-inline TensorPtr
-make_tensor_ptr(std::initializer_list<T> list,
-                executorch::aten::ScalarType type = deduced_type,
-                executorch::aten::TensorShapeDynamism dynamism =
-                    executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  std::vector<executorch::aten::SizesType> sizes{
-      executorch::aten::SizesType(list.size())};
-  return make_tensor_ptr(std::move(sizes), std::move(list), {0}, {1}, type,
-                         dynamism);
-}
-
-/**
- * Creates a TensorPtr that manages a Tensor with a single scalar value.
- *
- * @tparam T The C++ type of the scalar value.
- * @param value The scalar value to be used for the Tensor.
- * @return A TensorPtr that manages the newly created TensorImpl.
- */
-template <typename T> inline TensorPtr make_tensor_ptr(T value) {
-  return make_tensor_ptr(std::vector<executorch::aten::SizesType>{},
-                         std::vector<T>{value});
-}
-
-/**
- * Creates a TensorPtr that manages a Tensor with the specified properties.
- *
- * This overload accepts a raw memory buffer stored in a std::vector<uint8_t>
- * and a scalar type to interpret the data. The vector is managed, and the
- * memory's lifetime is tied to the TensorImpl.
- *
- * @param sizes A vector specifying the size of each dimension.
- * @param data A vector containing the raw memory for the tensor's data.
- * @param dim_order A vector specifying the order of dimensions.
- * @param strides A vector specifying the strides of each dimension.
- * @param type The scalar type of the tensor elements.
- * @param dynamism Specifies the mutability of the tensor's shape.
- * @return A TensorPtr managing the newly created Tensor.
- */
-TensorPtr make_tensor_ptr(
-    std::vector<executorch::aten::SizesType> sizes, std::vector<uint8_t> data,
-    std::vector<executorch::aten::DimOrderType> dim_order,
-    std::vector<executorch::aten::StridesType> strides,
-    executorch::aten::ScalarType type = executorch::aten::ScalarType::Float,
-    executorch::aten::TensorShapeDynamism dynamism =
-        executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND);
-
-/**
- * Creates a TensorPtr that manages a Tensor with the specified properties.
- *
- * This overload accepts a raw memory buffer stored in a std::vector<uint8_t>
- * and a scalar type to interpret the data. The vector is managed, and the
- * memory's lifetime is tied to the TensorImpl.
- *
- * @param sizes A vector specifying the size of each dimension.
- * @param data A vector containing the raw memory for the tensor's data.
- * @param type The scalar type of the tensor elements.
- * @param dynamism Specifies the mutability of the tensor's shape.
- * @return A TensorPtr managing the newly created Tensor.
- */
-inline TensorPtr make_tensor_ptr(
-    std::vector<executorch::aten::SizesType> sizes, std::vector<uint8_t> data,
-    executorch::aten::ScalarType type = executorch::aten::ScalarType::Float,
-    executorch::aten::TensorShapeDynamism dynamism =
-        executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  return make_tensor_ptr(std::move(sizes), std::move(data), {}, {}, type,
-                         dynamism);
-}
-
-/**
- * Creates a TensorPtr to manage a new Tensor that aliases the given Tensor's
- * storage, with optional metadata overrides. Shape dynamism is inherited from
- * the source tensor.
- *
- * If an override is provided (non-empty), it is passed as-is. If an override is
- * empty, the corresponding metadata is reused from the source tensor when it
- * fits; otherwise it is left empty for the core factory to derive a valid
- * configuration. If `dim_order` is empty but `strides` is provided, `dim_order`
- * is left empty so the core may infer it from the provided strides.
- *
- * @param tensor The source tensor to alias.
- * @param sizes Optional sizes override.
- * @param dim_order Optional dimension order override.
- * @param strides Optional strides override.
- * @param deleter A custom deleter function for managing the lifetime of the
- * original Tensor.
- * @return A TensorPtr aliasing the same storage with requested metadata.
- */
-inline TensorPtr
-make_tensor_ptr(const executorch::aten::Tensor &tensor,
-                std::vector<executorch::aten::SizesType> sizes = {},
-                std::vector<executorch::aten::DimOrderType> dim_order = {},
-                std::vector<executorch::aten::StridesType> strides = {},
-                std::function<void(void *)> deleter = nullptr) {
-  if (sizes.empty()) {
-    sizes.assign(tensor.sizes().begin(), tensor.sizes().end());
-  }
-  const auto same_rank = sizes.size() == static_cast<size_t>(tensor.dim());
-  const auto same_shape = same_rank && std::equal(sizes.begin(), sizes.end(),
-                                                  tensor.sizes().begin());
-  auto element_count_result =
-      executorch::aten::safe_numel(sizes.data(), sizes.size());
-  ET_CHECK_MSG(element_count_result.ok(), "safe_numel failed: %d",
-               static_cast<int>(element_count_result.error()));
-  const auto element_count = element_count_result.get();
-  const auto parent_element_count = tensor.numel();
-  ET_CHECK_MSG(
-      element_count <= parent_element_count,
-      "Requested view has %zd elements, but source tensor only has %zd.",
-      static_cast<ssize_t>(element_count),
-      static_cast<ssize_t>(parent_element_count));
-#ifndef USE_ATEN_LIB
-  if (dim_order.empty() && strides.empty() && same_rank) {
-    dim_order.assign(tensor.dim_order().begin(), tensor.dim_order().end());
-  }
-#endif // USE_ATEN_LIB
-  if (strides.empty() && dim_order.empty() && same_shape) {
-    strides.assign(tensor.strides().begin(), tensor.strides().end());
-  }
-  return make_tensor_ptr(std::move(sizes), tensor.mutable_data_ptr(),
-                         std::move(dim_order), std::move(strides),
-                         tensor.scalar_type(),
-#ifndef USE_ATEN_LIB
-                         tensor.shape_dynamism(),
-#else  // USE_ATEN_LIB
-                         executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND,
-#endif // USE_ATEN_LIB
-                         std::move(deleter));
-}
-
-/**
- * Convenience overload identical to make_tensor_ptr(*tensor_ptr, ...).
- * Keeps the original TensorPtr alive until the returned TensorPtr is destroyed.
- *
- * @param tensor_ptr The source tensor pointer to alias.
- * @param sizes Optional sizes override.
- * @param dim_order Optional dimension order override.
- * @param strides Optional strides override.
- * @return A TensorPtr aliasing the same storage with requested metadata.
- */
-inline TensorPtr
-make_tensor_ptr(const TensorPtr &tensor_ptr,
-                std::vector<executorch::aten::SizesType> sizes = {},
-                std::vector<executorch::aten::DimOrderType> dim_order = {},
-                std::vector<executorch::aten::StridesType> strides = {}) {
-  return make_tensor_ptr(*tensor_ptr, std::move(sizes), std::move(dim_order),
-                         std::move(strides), [tensor_ptr](void *) {});
-}
-
-/**
- * Creates a TensorPtr that manages a new Tensor with the same properties
- * as the given Tensor, but with a copy of the data owned by the returned
- * TensorPtr, or nullptr if the original data is null.
- *
- * @param tensor The Tensor to clone.
- * @param type The data type for the cloned tensor. The data will be cast
- * from the source tensor's type.
- * @return A new TensorPtr that manages a Tensor with the specified type
- * and copied/cast data.
- */
-TensorPtr clone_tensor_ptr(const executorch::aten::Tensor &tensor,
-                           executorch::aten::ScalarType type);
-
-/**
- * Creates a TensorPtr that manages a new Tensor with the same properties
- * as the given Tensor, but with a copy of the data owned by the returned
- * TensorPtr, or nullptr if the original data is null.
- *
- * @param tensor The Tensor to clone.
- * @return A new TensorPtr that manages a Tensor with the same properties as the
- * original but with copied data.
- */
-inline TensorPtr clone_tensor_ptr(const executorch::aten::Tensor &tensor) {
-  return clone_tensor_ptr(tensor, tensor.scalar_type());
-}
-
-/**
- * Creates a new TensorPtr by cloning the given TensorPtr, copying the
- * underlying data.
- *
- * @param tensor The TensorPtr to clone.
- * @param type The data type for the cloned tensor. The data will be cast
- * from the source tensor's type.
- * @return A new TensorPtr that manages a Tensor with the specified type
- * and copied/cast data.
- */
-inline TensorPtr clone_tensor_ptr(const TensorPtr &tensor,
-                                  executorch::aten::ScalarType type) {
-  return clone_tensor_ptr(*tensor, type);
-}
-
-/**
- * Creates a new TensorPtr by cloning the given TensorPtr, copying the
- * underlying data.
- *
- * @param tensor The TensorPtr to clone.
- * @return A new TensorPtr that manages a Tensor with the same properties as the
- * original but with copied data.
- */
-inline TensorPtr clone_tensor_ptr(const TensorPtr &tensor) {
-  return clone_tensor_ptr(*tensor, tensor->scalar_type());
-}
-
-/**
- * Resizes the Tensor managed by the provided TensorPtr to the new sizes.
- *
- * @param tensor A TensorPtr managing the Tensor to resize.
- * @param sizes A vector representing the new sizes for each dimension.
- * @return Error::Ok on success, or an appropriate error code on failure.
- */
-ET_NODISCARD
-runtime::Error
-resize_tensor_ptr(TensorPtr &tensor,
-                  const std::vector<executorch::aten::SizesType> &sizes);
-
-} // namespace extension
-} // namespace executorch
-
-C10_DIAGNOSTIC_POP()
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/tensor/tensor_ptr_maker.h b/packages/react-native-executorch/third-party/include/executorch/extension/tensor/tensor_ptr_maker.h
deleted file mode 100644
index c550b400f4..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/tensor/tensor_ptr_maker.h
+++ /dev/null
@@ -1,653 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <executorch/extension/tensor/tensor_ptr.h>
-
-namespace executorch {
-namespace extension {
-
-/**
- * A helper class for creating TensorPtr instances from raw data and tensor
- * properties. Note that the TensorPtr created by this class does not own the
- * data, so the data must outlive the TensorPtr.
- *
- * TensorPtrMaker provides a fluent interface for specifying various tensor
- * properties, such as type, sizes, data pointer, dimension order, strides, and
- * shape dynamism. The final tensor is created by invoking make_tensor_ptr() or
- * by converting TensorPtrMaker to TensorPtr.
- */
-class TensorPtrMaker final {
-public:
-  // This class may have non-copyable members in the future.
-  TensorPtrMaker(const TensorPtrMaker &) = delete;
-  TensorPtrMaker &operator=(const TensorPtrMaker &) = delete;
-  // But it is movable.
-  TensorPtrMaker(TensorPtrMaker &&) = default;
-  TensorPtrMaker &operator=(TensorPtrMaker &&) = default;
-
-  /**
-   * Sets the scalar type of the tensor elements.
-   *
-   * @param type The scalar type (e.g., float, int, bool).
-   * @return Rvalue to this TensorPtrMaker for method chaining.
-   */
-  TensorPtrMaker &&type(executorch::aten::ScalarType type) {
-    type_ = type;
-    return std::move(*this);
-  }
-
-  /**
-   * Sets the order of dimensions in memory.
-   *
-   * @param dim_order A vector specifying the dimension order.
-   * @return Rvalue to this TensorPtrMaker for method chaining.
-   */
-  TensorPtrMaker &&
-  dim_order(std::vector<executorch::aten::DimOrderType> dim_order) {
-    dim_order_ = std::move(dim_order);
-    return std::move(*this);
-  }
-
-  /**
-   * Sets the strides for each dimension of the tensor.
-   *
-   * @param strides A vector specifying the stride for each dimension.
-   * @return Rvalue to this TensorPtrMaker for method chaining.
-   */
-  TensorPtrMaker &&strides(std::vector<executorch::aten::StridesType> strides) {
-    strides_ = std::move(strides);
-    return std::move(*this);
-  }
-
-  /**
-   * Sets the shape dynamism of the tensor.
-   *
-   * @param dynamism Specifies whether the tensor's shape is static, dynamic, or
-   * bounded.
-   * @return Rvalue to this TensorPtrMaker for method chaining.
-   */
-  TensorPtrMaker &&dynamism(executorch::aten::TensorShapeDynamism dynamism) {
-    dynamism_ = dynamism;
-    return std::move(*this);
-  }
-
-  /**
-   * Sets a custom deleter function to manage the lifetime of the data buffer.
-   *
-   * @param deleter A function that will be called to delete the data buffer
-   * when the Tensor object managed by the TensorPtr is destroyed. Explicitly
-   * consuming an rvalue to avoid unnecessary copies when the deleter is a
-   * lambda that has captured some state.
-   * @return Rvalue to this TensorPtrMaker for method chaining.
-   */
-  TensorPtrMaker &&deleter(std::function<void(void *)> &&deleter) {
-    deleter_ = std::move(deleter);
-    return std::move(*this);
-  }
-
-  /**
-   * Creates and returns a TensorPtr instance using the properties set in this
-   * TensorPtrMaker.
-   *
-   * @return A TensorPtr instance that manages the newly created Tensor.
-   */
-  TensorPtr make_tensor_ptr() && {
-    return ::executorch::extension::make_tensor_ptr(
-        std::move(sizes_), data_, std::move(dim_order_), std::move(strides_),
-        type_, dynamism_, std::move(deleter_));
-  }
-
-  /**
-   * Implicit conversion operator to create a TensorPtr.
-   *
-   * @return A TensorPtr instance that manages the newly created Tensor.
-   */
-  operator TensorPtr() && { return std::move(*this).make_tensor_ptr(); }
-
-private:
-  TensorPtrMaker(void *data, std::vector<executorch::aten::SizesType> sizes,
-                 executorch::aten::ScalarType type)
-      : sizes_(std::move(sizes)), data_(data), type_(type) {}
-
-private:
-  // The following properties are required to create a Tensor.
-  friend TensorPtrMaker for_blob(void *data,
-                                 std::vector<executorch::aten::SizesType> sizes,
-                                 executorch::aten::ScalarType type);
-
-private:
-  std::vector<executorch::aten::SizesType> sizes_;
-  std::vector<executorch::aten::StridesType> strides_;
-  std::vector<executorch::aten::DimOrderType> dim_order_;
-  std::function<void(void *)> deleter_ = nullptr;
-  void *data_ = nullptr;
-  executorch::aten::ScalarType type_ = executorch::aten::ScalarType::Float;
-  executorch::aten::TensorShapeDynamism dynamism_ =
-      executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND;
-};
-
-/**
- * Creates a TensorPtrMaker instance for building a TensorPtr from a raw data
- * pointer and tensor sizes.
- *
- * The TensorPtrMaker returned by this function allows for further customization
- * of the tensor's properties, such as data type, dimension order, strides, and
- * shape dynamism, before finalizing the TensorPtr creation.
- *
- * @param data A pointer to the raw data to be used by the tensor. It must
- * outlive the TensorPtr created by this function.
- * @param sizes A vector specifying the size of each dimension.
- * @param type The scalar type of the tensor elements.
- * @return A TensorPtrMaker instance for creating a TensorPtr.
- */
-inline TensorPtrMaker for_blob(
-    void *data, std::vector<executorch::aten::SizesType> sizes,
-    executorch::aten::ScalarType type = executorch::aten::ScalarType::Float) {
-  return TensorPtrMaker(data, std::move(sizes), type);
-}
-
-/**
- * Creates a TensorPtr from a raw data pointer and tensor sizes, with an
- * optional dynamism setting.
- *
- * This function provides a convenient way to create a tensor from existing
- * data, with the option to specify whether the tensor's shape is static or
- * dynamic.
- *
- * @param data A pointer to the raw data used by the tensor. The data must
- * outlive the TensorPtr created by this function.
- * @param sizes A vector specifying the size of each dimension.
- * @param type The scalar type of the tensor elements.
- * @param dynamism Specifies whether the tensor's shape is static or dynamic.
- * @return A TensorPtr instance managing the newly created Tensor.
- */
-inline TensorPtr from_blob(
-    void *data, std::vector<executorch::aten::SizesType> sizes,
-    executorch::aten::ScalarType type = executorch::aten::ScalarType::Float,
-    executorch::aten::TensorShapeDynamism dynamism =
-        executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  return for_blob(data, std::move(sizes), type)
-      .dynamism(dynamism)
-      .make_tensor_ptr();
-}
-
-/**
- * Creates a TensorPtr from a raw data pointer, tensor sizes, and strides, with
- * an optional dynamism setting.
- *
- * This function allows for the creation of a tensor from existing data, with
- * the option to specify custom strides for each dimension and whether the
- * tensor’s shape is static, dynamic, or bounded.
- *
- * @param data A pointer to the raw data used by the tensor. The data must
- * outlive the TensorPtr created by this function.
- * @param sizes A vector specifying the size of each dimension.
- * @param strides A vector specifying the stride for each dimension.
- * @param type The scalar type of the tensor elements.
- * @param dynamism Specifies whether the tensor's shape is static, dynamic, or
- * bounded.
- * @return A TensorPtr instance managing the newly created Tensor.
- */
-inline TensorPtr from_blob(
-    void *data, std::vector<executorch::aten::SizesType> sizes,
-    std::vector<executorch::aten::StridesType> strides,
-    executorch::aten::ScalarType type = executorch::aten::ScalarType::Float,
-    executorch::aten::TensorShapeDynamism dynamism =
-        executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  return for_blob(data, std::move(sizes), type)
-      .strides(std::move(strides))
-      .dynamism(dynamism)
-      .make_tensor_ptr();
-}
-
-/**
- * Creates a TensorPtr from a raw data pointer and tensor sizes, with an
- * optional dynamism setting.
- *
- * This function is a convenient way to create a tensor from existing data, with
- * the option to specify whether the tensor's shape is static, dynamic, or
- * bounded.
- *
- * @param data A pointer to the raw data to be used by the tensor. It must
- * outlive the TensorPtr created by this function.
- * @param sizes A vector specifying the size of each dimension.
- * @param type The scalar type of the tensor elements.
- * @param deleter A function to delete the data when it's no longer needed.
- * @param dynamism Specifies whether the tensor's shape is static or dynamic.
- * @return A TensorPtr instance that manages the newly created Tensor.
- */
-inline TensorPtr
-from_blob(void *data, std::vector<executorch::aten::SizesType> sizes,
-          executorch::aten::ScalarType type,
-          std::function<void(void *)> &&deleter,
-          executorch::aten::TensorShapeDynamism dynamism =
-              executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  return for_blob(data, std::move(sizes), type)
-      .deleter(std::move(deleter))
-      .dynamism(dynamism)
-      .make_tensor_ptr();
-}
-
-/**
- * Creates a TensorPtr from a raw data pointer, tensor sizes, and strides, with
- * an optional dynamism setting.
- *
- * This function allows for the creation of a tensor from existing data, with
- * the option to specify custom strides for each dimension and whether the
- * tensor's shape is static, dynamic, or bounded.
- *
- * @param data A pointer to the raw data to be used by the tensor. It must
- * outlive the TensorPtr created by this function.
- * @param sizes A vector specifying the size of each dimension.
- * @param strides A vector specifying the stride for each dimension.
- * @param type The scalar type of the tensor elements.
- * @param deleter A function to delete the data when it's no longer needed.
- * @param dynamism Specifies whether the tensor's shape is static or dynamic.
- * @return A TensorPtr instance that manages the newly created Tensor.
- */
-inline TensorPtr
-from_blob(void *data, std::vector<executorch::aten::SizesType> sizes,
-          std::vector<executorch::aten::StridesType> strides,
-          executorch::aten::ScalarType type,
-          std::function<void(void *)> &&deleter,
-          executorch::aten::TensorShapeDynamism dynamism =
-              executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  return for_blob(data, std::move(sizes), type)
-      .strides(std::move(strides))
-      .deleter(std::move(deleter))
-      .dynamism(dynamism)
-      .make_tensor_ptr();
-}
-
-/**
- * Creates a TensorPtr with the specified sizes, strides, and properties.
- *
- * This function allocates memory for the tensor elements but does not
- * initialize them with any specific values. The tensor is created with the
- * specified strides.
- *
- * @param sizes A vector specifying the size of each dimension.
- * @param strides A vector specifying the stride for each dimension.
- * @param type The scalar type of the tensor elements.
- * @param dynamism Specifies whether the tensor's shape is static or dynamic.
- * @return A TensorPtr instance managing the newly created Tensor.
- */
-TensorPtr empty_strided(
-    std::vector<executorch::aten::SizesType> sizes,
-    std::vector<executorch::aten::StridesType> strides,
-    executorch::aten::ScalarType type = executorch::aten::ScalarType::Float,
-    executorch::aten::TensorShapeDynamism dynamism =
-        executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND);
-
-/**
- * Creates an empty TensorPtr with the same size and properties as the given
- * tensor.
- *
- * This function allocates memory for the tensor elements but does not
- * initialize them with any specific values.
- *
- * @param other A reference to another tensor, whose size and properties are
- * used.
- * @param type The scalar type of the tensor elements. If not provided, the
- * scalar type of the other tensor is used.
- * @param dynamism Specifies whether the tensor's shape is static or dynamic.
- * @return A TensorPtr instance managing the newly created Tensor.
- */
-inline TensorPtr empty_like(
-    const TensorPtr &other,
-    executorch::aten::ScalarType type = executorch::aten::ScalarType::Undefined,
-    executorch::aten::TensorShapeDynamism dynamism =
-        executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  if (type == executorch::aten::ScalarType::Undefined) {
-    type = other->scalar_type();
-  }
-  return empty_strided({other->sizes().begin(), other->sizes().end()},
-                       {other->strides().begin(), other->strides().end()}, type,
-                       dynamism);
-}
-
-/**
- * Creates an empty TensorPtr with the specified sizes and properties.
- *
- * This function allocates memory for the tensor elements but does not
- * initialize them with any specific values.
- *
- * @param sizes A vector specifying the size of each dimension.
- * @param type The scalar type of the tensor elements.
- * @param dynamism Specifies whether the tensor's shape is static or dynamic.
- * @return A TensorPtr instance managing the newly created Tensor.
- */
-inline TensorPtr
-empty(std::vector<executorch::aten::SizesType> sizes,
-      executorch::aten::ScalarType type = executorch::aten::ScalarType::Float,
-      executorch::aten::TensorShapeDynamism dynamism =
-          executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  return empty_strided(std::move(sizes), {}, type, dynamism);
-}
-
-/**
- * Creates a TensorPtr filled with the specified value.
- *
- * @param sizes A vector specifying the size of each dimension.
- * @param strides A vector specifying the stride for each dimension.
- * @param fill_value The value to fill the tensor with.
- * @param type The scalar type of the tensor elements.
- * @param dynamism Specifies whether the tensor's shape is static or dynamic.
- * @return A TensorPtr instance managing the newly created Tensor.
- */
-TensorPtr full_strided(
-    std::vector<executorch::aten::SizesType> sizes,
-    std::vector<executorch::aten::StridesType> strides,
-    executorch::aten::Scalar fill_value,
-    executorch::aten::ScalarType type = executorch::aten::ScalarType::Float,
-    executorch::aten::TensorShapeDynamism dynamism =
-        executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND);
-
-/**
- * Creates a TensorPtr filled with the specified value, with the same size and
- * properties as another tensor.
- *
- * @param other A reference to another tensor, whose size and properties will be
- * used.
- * @param fill_value The value to fill the tensor with.
- * @param type The scalar type of the tensor elements. If not specified, the
- * scalar type of the other tensor is used.
- * @param dynamism Specifies whether the tensor's shape is static or dynamic.
- * @return A TensorPtr instance managing the newly created Tensor.
- */
-inline TensorPtr full_like(
-    const TensorPtr &other, executorch::aten::Scalar fill_value,
-    executorch::aten::ScalarType type = executorch::aten::ScalarType::Undefined,
-    executorch::aten::TensorShapeDynamism dynamism =
-        executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  if (type == executorch::aten::ScalarType::Undefined) {
-    type = other->scalar_type();
-  }
-  return full_strided({other->sizes().begin(), other->sizes().end()},
-                      {other->strides().begin(), other->strides().end()},
-                      fill_value, type, dynamism);
-}
-
-/**
- * Creates a TensorPtr filled with the specified value.
- *
- * @param sizes A vector specifying the size of each dimension.
- * @param fill_value The value used to fill the tensor.
- * @param type The scalar type of the tensor elements.
- * @param dynamism Specifies whether the tensor's shape is static or dynamic.
- * @return A TensorPtr instance managing the newly created Tensor.
- */
-inline TensorPtr
-full(std::vector<executorch::aten::SizesType> sizes,
-     executorch::aten::Scalar fill_value,
-     executorch::aten::ScalarType type = executorch::aten::ScalarType::Float,
-     executorch::aten::TensorShapeDynamism dynamism =
-         executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  return full_strided(std::move(sizes), {}, fill_value, type, dynamism);
-}
-
-/**
- * Creates a TensorPtr holding a scalar value.
- *
- * @param value The scalar value for the tensor.
- * @param type The scalar type of the tensor elements.
- * @return A TensorPtr instance managing the newly created scalar Tensor.
- */
-inline TensorPtr scalar_tensor(
-    executorch::aten::Scalar value,
-    executorch::aten::ScalarType type = executorch::aten::ScalarType::Float) {
-  return full({}, value, type);
-}
-
-/**
- * Creates a TensorPtr filled with ones, with the same size and properties as
- * another tensor.
- *
- * @param other A reference to another tensor, whose size and properties are
- * used.
- * @param type The scalar type of the tensor elements. If not provided, the
- * scalar type of the other tensor is used.
- * @param dynamism Specifies whether the tensor's shape is static or dynamic.
- * @return A TensorPtr instance managing the newly created Tensor.
- */
-inline TensorPtr ones_like(
-    const TensorPtr &other,
-    executorch::aten::ScalarType type = executorch::aten::ScalarType::Undefined,
-    executorch::aten::TensorShapeDynamism dynamism =
-        executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  return full_like(other, 1, type, dynamism);
-}
-
-/**
- * Creates a TensorPtr filled with ones.
- *
- * @param sizes A vector specifying the size of each dimension.
- * @param type The scalar type of the tensor elements.
- * @param dynamism Specifies whether the tensor's shape is static or dynamic.
- * @return A TensorPtr instance managing the newly created Tensor.
- */
-inline TensorPtr
-ones(std::vector<executorch::aten::SizesType> sizes,
-     executorch::aten::ScalarType type = executorch::aten::ScalarType::Float,
-     executorch::aten::TensorShapeDynamism dynamism =
-         executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  return full(std::move(sizes), 1, type, dynamism);
-}
-
-/**
- * Creates a TensorPtr filled with zeros, with the same size and properties as
- * another tensor.
- *
- * @param other A reference to another tensor, whose size and properties will be
- * used.
- * @param type The scalar type of the tensor elements. If not specified, the
- * scalar type of the `other` tensor is used.
- * @param dynamism Specifies whether the tensor's shape is static or dynamic.
- * @return A TensorPtr instance managing the newly created Tensor.
- */
-inline TensorPtr zeros_like(
-    const TensorPtr &other,
-    executorch::aten::ScalarType type = executorch::aten::ScalarType::Undefined,
-    executorch::aten::TensorShapeDynamism dynamism =
-        executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  return full_like(other, 0, type, dynamism);
-}
-
-/**
- * Creates a TensorPtr filled with zeros.
- *
- * @param sizes A vector specifying the size of each dimension.
- * @param type The scalar type of the tensor elements.
- * @param dynamism Specifies whether the tensor's shape is static or dynamic.
- * @return A TensorPtr instance managing the newly created Tensor.
- */
-inline TensorPtr
-zeros(std::vector<executorch::aten::SizesType> sizes,
-      executorch::aten::ScalarType type = executorch::aten::ScalarType::Float,
-      executorch::aten::TensorShapeDynamism dynamism =
-          executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  return full(std::move(sizes), 0, type, dynamism);
-}
-
-/**
- * Creates a TensorPtr filled with random values between 0 and 1.
- *
- * @param sizes A vector specifying the size of each dimension.
- * @param strides A vector specifying the stride for each dimension.
- * @param type The scalar type of the tensor elements.
- * @param dynamism Specifies whether the tensor's shape is static or dynamic.
- * @return A TensorPtr instance managing the newly created Tensor.
- **/
-TensorPtr rand_strided(
-    std::vector<executorch::aten::SizesType> sizes,
-    std::vector<executorch::aten::StridesType> strides,
-    executorch::aten::ScalarType type = executorch::aten::ScalarType::Float,
-    executorch::aten::TensorShapeDynamism dynamism =
-        executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND);
-
-/**
- * Creates a TensorPtr filled with random values between 0 and 1.
- *
- * @param other A reference to another tensor, whose size and properties will be
- * used.
- * @param type The scalar type of the tensor elements. If not specified, the
- * scalar type of the other tensor is used.
- * @param dynamism Specifies whether the tensor's shape is static or dynamic.
- * @return A TensorPtr instance managing the newly created Tensor.
- */
-inline TensorPtr rand_like(
-    const TensorPtr &other,
-    executorch::aten::ScalarType type = executorch::aten::ScalarType::Undefined,
-    executorch::aten::TensorShapeDynamism dynamism =
-        executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  if (type == executorch::aten::ScalarType::Undefined) {
-    type = other->scalar_type();
-  }
-  return rand_strided({other->sizes().begin(), other->sizes().end()},
-                      {other->strides().begin(), other->strides().end()}, type,
-                      dynamism);
-}
-
-/**
- * Creates a TensorPtr filled with random values between 0 and 1.
- *
- * @param sizes A vector specifying the size of each dimension.
- * @param type The scalar type of the tensor elements.
- * @param dynamism Specifies whether the tensor's shape is static or dynamic.
- * @return A TensorPtr instance managing the newly created Tensor.
- */
-inline TensorPtr
-rand(std::vector<executorch::aten::SizesType> sizes,
-     executorch::aten::ScalarType type = executorch::aten::ScalarType::Float,
-     executorch::aten::TensorShapeDynamism dynamism =
-         executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  return rand_strided(std::move(sizes), {}, type, dynamism);
-}
-
-/**
- * Creates a TensorPtr filled with random values from a normal distribution.
- *
- * @param sizes A vector specifying the size of each dimension.
- * @param strides A vector specifying the stride for each dimension.
- * @param type The scalar type of the tensor elements.
- * @param dynamism Specifies whether the tensor's shape is static or dynamic.
- * @return A TensorPtr instance managing the newly created Tensor.
- */
-TensorPtr randn_strided(
-    std::vector<executorch::aten::SizesType> sizes,
-    std::vector<executorch::aten::StridesType> strides,
-    executorch::aten::ScalarType type = executorch::aten::ScalarType::Float,
-    executorch::aten::TensorShapeDynamism dynamism =
-        executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND);
-
-/**
- * Creates a TensorPtr filled with random values from a normal distribution.
- *
- * @param other A reference to another tensor, whose size and properties will be
- * used.
- * @param type The scalar type of the tensor elements. If not specified, the
- * scalar type of the other tensor is used.
- * @param dynamism Specifies whether the tensor's shape is static or dynamic.
- * @return A TensorPtr instance managing the newly created Tensor.
- */
-inline TensorPtr randn_like(
-    const TensorPtr &other,
-    executorch::aten::ScalarType type = executorch::aten::ScalarType::Undefined,
-    executorch::aten::TensorShapeDynamism dynamism =
-        executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  if (type == executorch::aten::ScalarType::Undefined) {
-    type = other->scalar_type();
-  }
-  return randn_strided({other->sizes().begin(), other->sizes().end()},
-                       {other->strides().begin(), other->strides().end()}, type,
-                       dynamism);
-}
-
-/**
- * Creates a TensorPtr filled with random values from a normal distribution.
- *
- * @param sizes A vector specifying the size of each dimension.
- * @param type The scalar type of the tensor elements.
- * @param dynamism Specifies whether the tensor's shape is static or dynamic.
- * @return A TensorPtr instance managing the newly created Tensor.
- */
-inline TensorPtr
-randn(std::vector<executorch::aten::SizesType> sizes,
-      executorch::aten::ScalarType type = executorch::aten::ScalarType::Float,
-      executorch::aten::TensorShapeDynamism dynamism =
-          executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  return randn_strided(std::move(sizes), {}, type, dynamism);
-}
-
-/**
- * Creates a TensorPtr filled with random integer values in the given range.
- *
- * @param low The lower bound (inclusive) of the random values.
- * @param high The upper bound (exclusive) of the random values.
- * @param sizes A vector specifying the size of each dimension.
- * @param strides A vector specifying the stride for each dimension.
- * @param type The scalar type of the tensor elements.
- * @param dynamism Specifies whether the tensor's shape is static or dynamic.
- * @return A TensorPtr instance managing the newly created Tensor.
- */
-TensorPtr randint_strided(
-    int64_t low, int64_t high, std::vector<executorch::aten::SizesType> sizes,
-    std::vector<executorch::aten::StridesType> strides,
-    executorch::aten::ScalarType type = executorch::aten::ScalarType::Int,
-    executorch::aten::TensorShapeDynamism dynamism =
-        executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND);
-
-/**
- * Creates a TensorPtr filled with random integer values in the given range.
- *
- * @param other A reference to another tensor, whose size and properties will be
- * used.
- * @param low The lower bound (inclusive) of the random values.
- * @param high The upper bound (exclusive) of the random values.
- * @param type The scalar type of the tensor elements. If not specified, the
- * scalar type of the other tensor is used.
- * @param dynamism Specifies whether the tensor's shape is static or dynamic.
- * @return A TensorPtr instance managing the newly created Tensor.
- */
-inline TensorPtr randint_like(
-    const TensorPtr &other, int64_t low, int64_t high,
-    executorch::aten::ScalarType type = executorch::aten::ScalarType::Undefined,
-    executorch::aten::TensorShapeDynamism dynamism =
-        executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  if (type == executorch::aten::ScalarType::Undefined) {
-    type = other->scalar_type();
-  }
-  return randint_strided(
-      low, high, {other->sizes().begin(), other->sizes().end()},
-      {other->strides().begin(), other->strides().end()}, type, dynamism);
-}
-
-/**
- * Creates a TensorPtr filled with random integer values within the specified
- * range.
- *
- * @param low The inclusive lower bound of the random values.
- * @param high The exclusive upper bound of the random values.
- * @param sizes A vector specifying the size of each dimension.
- * @param type The scalar type of the tensor elements.
- * @param dynamism Specifies whether the tensor's shape is static or dynamic.
- * @return A TensorPtr instance managing the newly created Tensor.
- */
-inline TensorPtr
-randint(int64_t low, int64_t high,
-        std::vector<executorch::aten::SizesType> sizes,
-        executorch::aten::ScalarType type = executorch::aten::ScalarType::Int,
-        executorch::aten::TensorShapeDynamism dynamism =
-            executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
-  return randint_strided(low, high, std::move(sizes), {}, type, dynamism);
-}
-
-} // namespace extension
-} // namespace executorch
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/threadpool/cpuinfo_utils.h b/packages/react-native-executorch/third-party/include/executorch/extension/threadpool/cpuinfo_utils.h
deleted file mode 100644
index d559738b72..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/threadpool/cpuinfo_utils.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <cpuinfo.h>
-
-namespace executorch::extension::cpuinfo {
-
-uint32_t get_num_performant_cores();
-
-} // namespace executorch::extension::cpuinfo
-
-namespace torch::executorch::cpuinfo { // DEPRECATED
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces. Note that threadpool incorrectly used
-// the namespace `torch::executorch` instead of `torch::executor`.
-using ::executorch::extension::cpuinfo::get_num_performant_cores; // DEPRECATED
-} // namespace torch::executorch::cpuinfo
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/threadpool/threadpool.h b/packages/react-native-executorch/third-party/include/executorch/extension/threadpool/threadpool.h
deleted file mode 100644
index e7015e78b0..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/threadpool/threadpool.h
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <functional>
-#include <memory>
-#include <mutex>
-
-#include <pthreadpool.h>
-
-#include <executorch/runtime/core/function_ref.h>
-
-/*
- * Threadpool Options:
- *
- * Threadpool size has a sizble affect on performance. By default, the
- * threadpool will be sized according to the number of performance cores. This
- * behavior can be overriden with the following build-time options. Note that
- * these options are mutually exclusive.
- *
- * - EXECUTORCH_THREADPOOL_USE_PERFORMANCE_CORES (flag) - Sizes the threadpool
- * equal to the number of performance cores on the system. This is the default
- * behavior.
- * - EXECUTORCH_THREADPOOL_USE_ALL_LOGICAL_CORES (flag) - Sizes the threadpool
- * equal to the number of logical cores on system. This is the historical
- * behavior.
- */
-
-namespace executorch::extension::threadpool {
-
-class ThreadPool final {
-public:
-  explicit ThreadPool(size_t thread_count = 0);
-  ~ThreadPool() = default;
-
-  // Make threadpool non copyable
-  // Non-copyable: threadpool cannot be copied because it will
-  // effectively require cloning of threadpool.
-  // Cloning can be done by just calling create_thread_pool.
-  ThreadPool(const ThreadPool &) = delete;
-  ThreadPool &operator=(const ThreadPool &) = delete;
-
-  // Make threadpool non-movable.
-  ThreadPool(ThreadPool &&) = delete;
-  ThreadPool &operator=(ThreadPool &&) = delete;
-
-  size_t get_thread_count() const;
-
-  /**
-   * INTERNAL: Resets the threadpool by creating a new threadpool with requested
-   * # of threads. This is not a thread safe call. When calling this method,
-   * threads of the threadpool might be doing some work. Some other code may
-   * also be holding on to the threadpool pointer, that is no longer valid. This
-   * is a private API, which will later be replaced by something that allows
-   * creating of threadpool with requested size and use such a threadpool with
-   * backend delegates, custom ops or optimized lib.
-   * For Meta internal use, there is
-   * executorch::extension::threadpool::UseNThreadsThreadPoolGuard API that
-   * provides a safer way to select a subset of threads, from threadpool, to run
-   * the model on.
-   */
-  [[deprecated("This API is experimental and may change without notice. "
-               "Consider using UseNThreadsThreadPoolGuard")]]
-  bool _unsafe_reset_threadpool(uint32_t num_threads);
-
-  /**
-   * INTERNAL: Destroys the threadpool. This is not a thread safe call. When
-   * calling this method, threads of the threadpool might be doing some work.
-   * Some other code may also be holding on to the threadpool pointer, that is
-   * no longer valid.
-   */
-  [[deprecated("This API is experimental and may change without notice.")]]
-  void _unsafe_destroy_threadpool();
-
-  /**
-   * Run, in parallel, function fn(task_id) over task_id in range [0, range).
-   * This function is blocking.  All input is processed by the time it returns.
-   * NoThreadPoolGuard (see threadpool_guard.h) can used to disable use of
-   * multiple threads with the scope of the guard When NoThreadPoolGuard is not
-   * used all calls to run method are serialized.
-   */
-  void run(runtime::FunctionRef<void(size_t)> fn, size_t range);
-
-private:
-  friend pthreadpool_t get_pthreadpool();
-
-private:
-  // This mutex is used inside get_thread_count API but it is not really needed
-  // since data members of ThreadPool objects are not really mutable.
-  // TODO(kimishpatel): Figure out if we will allow set_num_threads API, in
-  // which case this mutex will be useful. Otherwise remove it.
-  mutable std::mutex mutex_;
-  std::unique_ptr<pthreadpool, decltype(&pthreadpool_destroy)> threadpool_;
-};
-
-/**
- * Returns the singleton instance of ThreadPool for ATen/TH multithreading.
- */
-ThreadPool *get_threadpool();
-
-/**
- * Returns the underlying pthreadpool instance used by the implementation of
- * ThreadPool returned by `get_threadpool()`. Only for use in external libraries
- * so as to unify threading across internal (i.e. ATen, etc.) and external (e.g.
- * NNPACK, QNNPACK, XNNPACK) use cases.
- */
-pthreadpool_t get_pthreadpool();
-
-} // namespace executorch::extension::threadpool
-
-namespace torch::executorch::threadpool { // DEPRECATED
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces. Note that threadpool incorrectly used
-// the namespace `torch::executorch` instead of `torch::executor`.
-using ::executorch::extension::threadpool::get_pthreadpool; // DEPRECATED
-using ::executorch::extension::threadpool::get_threadpool;  // DEPRECATED
-using ::executorch::extension::threadpool::ThreadPool;      // DEPRECATED
-} // namespace torch::executorch::threadpool
diff --git a/packages/react-native-executorch/third-party/include/executorch/extension/threadpool/threadpool_guard.h b/packages/react-native-executorch/third-party/include/executorch/extension/threadpool/threadpool_guard.h
deleted file mode 100644
index ab4b07765b..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/extension/threadpool/threadpool_guard.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-namespace executorch::extension::threadpool {
-
-// A RAII, thread local (!) guard that enables or disables guard upon
-// construction, and sets it back to the original value upon destruction.
-struct NoThreadPoolGuard {
-  static bool is_enabled();
-  static void set_enabled(bool enabled);
-
-  NoThreadPoolGuard() : prev_mode_(NoThreadPoolGuard::is_enabled()) {
-    NoThreadPoolGuard::set_enabled(true);
-  }
-  ~NoThreadPoolGuard() { NoThreadPoolGuard::set_enabled(prev_mode_); }
-
-private:
-  const bool prev_mode_;
-};
-
-} // namespace executorch::extension::threadpool
-
-namespace torch::executorch::threadpool { // DEPRECATED
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces. Note that threadpool incorrectly used
-// the namespace `torch::executorch` instead of `torch::executor`.
-using ::executorch::extension::threadpool::NoThreadPoolGuard; // DEPRECATED
-} // namespace torch::executorch::threadpool
diff --git a/packages/react-native-executorch/third-party/include/executorch/kernels/optimized/Functions.h b/packages/react-native-executorch/third-party/include/executorch/kernels/optimized/Functions.h
deleted file mode 100644
index cd934e7997..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/kernels/optimized/Functions.h
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// clang-format off
-#pragma once
-
-#include <tuple>
-
-#include <executorch/runtime/core/exec_aten/exec_aten.h> // at::Tensor etc.
-#include <executorch/codegen/macros.h> // TORCH_API
-#include <executorch/runtime/kernel/kernel_runtime_context.h>
-
-// @generated by gen.py from Functions.h
-
-#include "NativeFunctions.h"
-
-namespace torch {
-namespace executor {
-
-
-namespace aten {
-
-// aten::_fft_c2r.out(Tensor self, int[] dim, int normalization, SymInt last_dim_size, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & _fft_c2r_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> dim, int64_t normalization, int64_t last_dim_size, torch::executor::Tensor & out) {
-    return ::torch::executor::native::opt_fft_c2r_out(context, self, dim, normalization, last_dim_size, out);
-}
-
-
-// aten::_fft_r2c.out(Tensor self, int[] dim, int normalization, bool onesided, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & _fft_r2c_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> dim, int64_t normalization, bool onesided, torch::executor::Tensor & out) {
-    return ::torch::executor::native::opt_fft_r2c_out(context, self, dim, normalization, onesided, out);
-}
-
-
-// aten::_log_softmax.out(Tensor self, int dim, bool half_to_float, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & _log_softmax_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, bool half_to_float, torch::executor::Tensor & out) {
-    return ::torch::executor::native::opt_log_softmax_out(context, self, dim, half_to_float, out);
-}
-
-
-// aten::add.out(Tensor self, Tensor other, *, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & add_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out) {
-    return ::torch::executor::native::opt_add_out(context, self, other, alpha, out);
-}
-
-
-// aten::add.Scalar_out(Tensor self, Scalar other, Scalar alpha=1, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & add_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out) {
-    return ::torch::executor::native::opt_add_scalar_out(context, self, other, alpha, out);
-}
-
-
-// aten::bmm.out(Tensor self, Tensor mat2, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & bmm_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & mat2, torch::executor::Tensor & out) {
-    return ::torch::executor::native::opt_bmm_out(context, self, mat2, out);
-}
-
-
-// aten::div.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & div_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::opt_div_out(context, self, other, out);
-}
-
-
-// aten::div.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & div_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::opt_div_scalar_out(context, self, other, out);
-}
-
-
-// aten::elu.out(Tensor self, Scalar alpha=1, Scalar scale=1, Scalar input_scale=1, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & elu_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & alpha, const torch::executor::Scalar & scale, const torch::executor::Scalar & input_scale, torch::executor::Tensor & out) {
-    return ::torch::executor::native::opt_elu_out(context, self, alpha, scale, input_scale, out);
-}
-
-
-// aten::exp.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & exp_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::opt_exp_out(context, self, out);
-}
-
-
-// aten::gelu.out(Tensor self, *, str approximate='none', Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & gelu_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::string_view approximate, torch::executor::Tensor & out) {
-    return ::torch::executor::native::opt_gelu_out(context, self, approximate, out);
-}
-
-
-// aten::grid_sampler_2d.out(Tensor input, Tensor grid, int interpolation_mode, int padding_mode, bool align_corners, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & grid_sampler_2d_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners, torch::executor::Tensor & out) {
-    return ::torch::executor::native::opt_grid_sampler_2d_out(context, input, grid, interpolation_mode, padding_mode, align_corners, out);
-}
-
-
-// aten::le.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & le_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::opt_le_scalar_out(context, self, other, out);
-}
-
-
-// aten::le.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & le_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::opt_le_tensor_out(context, self, other, out);
-}
-
-
-// aten::linear.out(Tensor input, Tensor weight, Tensor? bias=None, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & linear_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & weight, const torch::executor::optional<torch::executor::Tensor> & bias, torch::executor::Tensor & out) {
-    return ::torch::executor::native::opt_linear_out(context, input, weight, bias, out);
-}
-
-
-// aten::mm.out(Tensor self, Tensor mat2, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & mm_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & mat2, torch::executor::Tensor & out) {
-    return ::torch::executor::native::opt_mm_out(context, self, mat2, out);
-}
-
-
-// aten::mul.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & mul_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::opt_mul_out(context, self, other, out);
-}
-
-
-// aten::mul.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & mul_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::opt_mul_scalar_out(context, self, other, out);
-}
-
-
-// aten::native_layer_norm.out(Tensor input, SymInt[] normalized_shape, Tensor? weight, Tensor? bias, float eps, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!))
-TORCH_API inline ::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &,torch::executor::Tensor &> native_layer_norm_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, torch::executor::ArrayRef<int64_t> normalized_shape, const torch::executor::optional<torch::executor::Tensor> & weight, const torch::executor::optional<torch::executor::Tensor> & bias, double eps, torch::executor::Tensor & out0, torch::executor::Tensor & out1, torch::executor::Tensor & out2) {
-    return ::torch::executor::native::opt_native_layer_norm_out(context, input, normalized_shape, weight, bias, eps, out0, out1, out2);
-}
-
-
-// aten::sub.out(Tensor self, Tensor other, *, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & sub_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out) {
-    return ::torch::executor::native::opt_sub_out(context, self, other, alpha, out);
-}
-
-
-// aten::sum.IntList_out(Tensor self, int[1]? dim, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & sum_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, bool keepdim, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out) {
-    return ::torch::executor::native::opt_sum_dim_out(context, self, dim, keepdim, dtype, out);
-}
-
-
-// aten::sub.Scalar_out(Tensor self, Scalar other, Scalar alpha=1, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & sub_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out) {
-    return ::torch::executor::native::opt_sub_scalar_out(context, self, other, alpha, out);
-}
-
-
-// aten::where.self_out(Tensor condition, Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & where_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & condition, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::opt_where_out(context, condition, self, other, out);
-}
-
-} // namespace aten
-
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/kernels/optimized/NativeFunctions.h b/packages/react-native-executorch/third-party/include/executorch/kernels/optimized/NativeFunctions.h
deleted file mode 100644
index 6dff2dae23..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/kernels/optimized/NativeFunctions.h
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// clang-format off
-#pragma once
-
-#include <tuple>
-
-#include <executorch/runtime/core/exec_aten/exec_aten.h> // at::Tensor etc.
-#include <executorch/runtime/kernel/kernel_runtime_context.h>
-#include <executorch/runtime/core/error.h>
-
-// @generated by gen.py from NativeFunctions.h
-
-namespace torch {
-namespace executor {
-namespace native {
-torch::executor::Tensor & opt_fft_c2r_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> dim, int64_t normalization, int64_t last_dim_size, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_fft_c2r_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> dim, int64_t normalization, int64_t last_dim_size, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_fft_r2c_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> dim, int64_t normalization, bool onesided, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_fft_r2c_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> dim, int64_t normalization, bool onesided, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_log_softmax_out(const torch::executor::Tensor & self, int64_t dim, bool half_to_float, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_log_softmax_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, bool half_to_float, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_add_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_add_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_add_scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_add_scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_bmm_out(const torch::executor::Tensor & self, const torch::executor::Tensor & mat2, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_bmm_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & mat2, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_div_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_div_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_div_scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_div_scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_elu_out(const torch::executor::Tensor & self, const torch::executor::Scalar & alpha, const torch::executor::Scalar & scale, const torch::executor::Scalar & input_scale, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_elu_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & alpha, const torch::executor::Scalar & scale, const torch::executor::Scalar & input_scale, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_exp_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_exp_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_gelu_out(const torch::executor::Tensor & self, torch::executor::string_view approximate, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_gelu_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::string_view approximate, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_grid_sampler_2d_out(const torch::executor::Tensor & input, const torch::executor::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_grid_sampler_2d_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_le_scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_le_scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_le_tensor_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_le_tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_linear_out(const torch::executor::Tensor & input, const torch::executor::Tensor & weight, const torch::executor::optional<torch::executor::Tensor> & bias, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_linear_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & weight, const torch::executor::optional<torch::executor::Tensor> & bias, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_mm_out(const torch::executor::Tensor & self, const torch::executor::Tensor & mat2, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_mm_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & mat2, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_mul_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_mul_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_mul_scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_mul_scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &,torch::executor::Tensor &> opt_native_layer_norm_out(const torch::executor::Tensor & input, torch::executor::ArrayRef<int64_t> normalized_shape, const torch::executor::optional<torch::executor::Tensor> & weight, const torch::executor::optional<torch::executor::Tensor> & bias, double eps, torch::executor::Tensor & out0, torch::executor::Tensor & out1, torch::executor::Tensor & out2);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &,torch::executor::Tensor &> opt_native_layer_norm_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, torch::executor::ArrayRef<int64_t> normalized_shape, const torch::executor::optional<torch::executor::Tensor> & weight, const torch::executor::optional<torch::executor::Tensor> & bias, double eps, torch::executor::Tensor & out0, torch::executor::Tensor & out1, torch::executor::Tensor & out2);
-torch::executor::Tensor & opt_sub_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_sub_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_sum_dim_out(const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, bool keepdim, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_sum_dim_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, bool keepdim, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_sub_scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_sub_scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_where_out(const torch::executor::Tensor & condition, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & opt_where_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & condition, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-} // namespace native
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/kernels/portable/Functions.h b/packages/react-native-executorch/third-party/include/executorch/kernels/portable/Functions.h
deleted file mode 100644
index c96f3daf4b..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/kernels/portable/Functions.h
+++ /dev/null
@@ -1,1275 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// clang-format off
-#pragma once
-
-#include <tuple>
-
-#include <executorch/runtime/core/exec_aten/exec_aten.h> // at::Tensor etc.
-#include <executorch/codegen/macros.h> // TORCH_API
-#include <executorch/runtime/kernel/kernel_runtime_context.h>
-
-// @generated by gen.py from Functions.h
-
-#include "NativeFunctions.h"
-
-namespace torch {
-namespace executor {
-
-
-namespace aten {
-
-// aten::_adaptive_avg_pool2d.out(Tensor self, SymInt[2] output_size, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & _adaptive_avg_pool2d_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> output_size, torch::executor::Tensor & out) {
-    return ::torch::executor::native::_adaptive_avg_pool2d_out(context, self, output_size, out);
-}
-
-
-// aten::_cdist_forward.out(Tensor x1, Tensor x2, float p, int? compute_mode, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & _cdist_forward_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & x1, const torch::executor::Tensor & x2, double p, torch::executor::optional<int64_t> compute_mode, torch::executor::Tensor & out) {
-    return ::torch::executor::native::_cdist_forward_out(context, x1, x2, p, compute_mode, out);
-}
-
-
-// aten::_conj_physical.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & _conj_physical_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::_conj_physical_out(context, self, out);
-}
-
-
-// aten::_log_softmax.out(Tensor self, int dim, bool half_to_float, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & _log_softmax_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, bool half_to_float, torch::executor::Tensor & out) {
-    return ::torch::executor::native::log_softmax_out(context, self, dim, half_to_float, out);
-}
-
-
-// aten::_native_batch_norm_legit.out(Tensor input, Tensor? weight, Tensor? bias, Tensor(a!) running_mean, Tensor(b!) running_var, bool training, float momentum, float eps, *, Tensor(d!) out, Tensor(e!) save_mean, Tensor(f!) save_invstd) -> (Tensor(d!), Tensor(e!), Tensor(f!))
-TORCH_API inline ::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &,torch::executor::Tensor &> _native_batch_norm_legit_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::optional<torch::executor::Tensor> & weight, const torch::executor::optional<torch::executor::Tensor> & bias, torch::executor::Tensor & running_mean, torch::executor::Tensor & running_var, bool training, double momentum, double eps, torch::executor::Tensor & out, torch::executor::Tensor & save_mean, torch::executor::Tensor & save_invstd) {
-    return ::torch::executor::native::_native_batch_norm_legit_out(context, input, weight, bias, running_mean, running_var, training, momentum, eps, out, save_mean, save_invstd);
-}
-
-
-// aten::_native_batch_norm_legit.no_stats_out(Tensor input, Tensor? weight, Tensor? bias, bool training, float momentum, float eps, *, Tensor(a!) out, Tensor(b!) save_mean, Tensor(c!) save_invstd) -> (Tensor(a!), Tensor(b!), Tensor(c!))
-TORCH_API inline ::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &,torch::executor::Tensor &> _native_batch_norm_legit_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::optional<torch::executor::Tensor> & weight, const torch::executor::optional<torch::executor::Tensor> & bias, bool training, double momentum, double eps, torch::executor::Tensor & out, torch::executor::Tensor & save_mean, torch::executor::Tensor & save_invstd) {
-    return ::torch::executor::native::_native_batch_norm_legit_no_stats_out(context, input, weight, bias, training, momentum, eps, out, save_mean, save_invstd);
-}
-
-
-// aten::_native_batch_norm_legit_no_training.out(Tensor input, Tensor? weight, Tensor? bias, Tensor running_mean, Tensor running_var, float momentum, float eps, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!))
-TORCH_API inline ::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &,torch::executor::Tensor &> _native_batch_norm_legit_no_training_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::optional<torch::executor::Tensor> & weight, const torch::executor::optional<torch::executor::Tensor> & bias, const torch::executor::Tensor & running_mean, const torch::executor::Tensor & running_var, double momentum, double eps, torch::executor::Tensor & out0, torch::executor::Tensor & out1, torch::executor::Tensor & out2) {
-    return ::torch::executor::native::_native_batch_norm_legit_no_training_out(context, input, weight, bias, running_mean, running_var, momentum, eps, out0, out1, out2);
-}
-
-
-// aten::_pdist_forward.out(Tensor self, float p=2, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & _pdist_forward_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, double p, torch::executor::Tensor & out) {
-    return ::torch::executor::native::_pdist_forward_out(context, self, p, out);
-}
-
-
-// aten::_softmax.out(Tensor self, int dim, bool half_to_float, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & _softmax_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, bool half_to_float, torch::executor::Tensor & out) {
-    return ::torch::executor::native::softmax_out(context, self, dim, half_to_float, out);
-}
-
-
-// aten::_to_copy.out(Tensor self, *, bool non_blocking=False, MemoryFormat? memory_format=None, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & _to_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, bool non_blocking, torch::executor::optional<torch::executor::MemoryFormat> memory_format, torch::executor::Tensor & out) {
-    return ::torch::executor::native::to_copy_out(context, self, non_blocking, memory_format, out);
-}
-
-
-// aten::abs.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & abs_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::abs_out(context, self, out);
-}
-
-
-// aten::acos.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & acos_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::acos_out(context, self, out);
-}
-
-
-// aten::acosh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & acosh_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::acosh_out(context, self, out);
-}
-
-
-// aten::add.out(Tensor self, Tensor other, *, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & add_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out) {
-    return ::torch::executor::native::add_out(context, self, other, alpha, out);
-}
-
-
-// aten::add.Scalar_out(Tensor self, Scalar other, Scalar alpha=1, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & add_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out) {
-    return ::torch::executor::native::add_scalar_out(context, self, other, alpha, out);
-}
-
-
-// aten::addmm.out(Tensor self, Tensor mat1, Tensor mat2, *, Scalar beta=1, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & addmm_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & mat1, const torch::executor::Tensor & mat2, const torch::executor::Scalar & beta, const torch::executor::Scalar & alpha, torch::executor::Tensor & out) {
-    return ::torch::executor::native::addmm_out(context, self, mat1, mat2, beta, alpha, out);
-}
-
-
-// aten::alias_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & alias_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::alias_copy_out(context, self, out);
-}
-
-
-// aten::amax.out(Tensor self, int[1] dim=[], bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & amax_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> dim, bool keepdim, torch::executor::Tensor & out) {
-    return ::torch::executor::native::amax_out(context, self, dim, keepdim, out);
-}
-
-
-// aten::amin.out(Tensor self, int[1] dim=[], bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & amin_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> dim, bool keepdim, torch::executor::Tensor & out) {
-    return ::torch::executor::native::amin_out(context, self, dim, keepdim, out);
-}
-
-
-// aten::any.all_out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & any_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::any_all_out(context, self, out);
-}
-
-
-// aten::any.dims_out(Tensor self, int[]? dim=None, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & any_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, bool keepdim, torch::executor::Tensor & out) {
-    return ::torch::executor::native::any_dims_out(context, self, dim, keepdim, out);
-}
-
-
-// aten::any.out(Tensor self, int dim, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & any_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, bool keepdim, torch::executor::Tensor & out) {
-    return ::torch::executor::native::any_out(context, self, dim, keepdim, out);
-}
-
-
-// aten::arange.out(Scalar end, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & arange_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Scalar & end, torch::executor::Tensor & out) {
-    return ::torch::executor::native::arange_out(context, end, out);
-}
-
-
-// aten::arange.start_out(Scalar start, Scalar end, Scalar step=1, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & arange_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Scalar & start, const torch::executor::Scalar & end, const torch::executor::Scalar & step, torch::executor::Tensor & out) {
-    return ::torch::executor::native::arange_start_out(context, start, end, step, out);
-}
-
-
-// aten::argmax.out(Tensor self, int? dim=None, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & argmax_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<int64_t> dim, bool keepdim, torch::executor::Tensor & out) {
-    return ::torch::executor::native::argmax_out(context, self, dim, keepdim, out);
-}
-
-
-// aten::argmin.out(Tensor self, int? dim=None, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & argmin_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<int64_t> dim, bool keepdim, torch::executor::Tensor & out) {
-    return ::torch::executor::native::argmin_out(context, self, dim, keepdim, out);
-}
-
-
-// aten::as_strided_copy.out(Tensor self, SymInt[] size, SymInt[] stride, SymInt? storage_offset=None, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & as_strided_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> size, torch::executor::ArrayRef<int64_t> stride, torch::executor::optional<int64_t> storage_offset, torch::executor::Tensor & out) {
-    return ::torch::executor::native::as_strided_copy_out(context, self, size, stride, storage_offset, out);
-}
-
-
-// aten::asin.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & asin_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::asin_out(context, self, out);
-}
-
-
-// aten::asinh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & asinh_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::asinh_out(context, self, out);
-}
-
-
-// aten::atan.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & atan_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::atan_out(context, self, out);
-}
-
-
-// aten::atan2.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & atan2_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::atan2_out(context, self, other, out);
-}
-
-
-// aten::atanh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & atanh_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::atanh_out(context, self, out);
-}
-
-
-// aten::avg_pool2d.out(Tensor self, int[2] kernel_size, int[2] stride=[], int[2] padding=0, bool ceil_mode=False, bool count_include_pad=True, int? divisor_override=None, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & avg_pool2d_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> kernel_size, torch::executor::ArrayRef<int64_t> stride, torch::executor::ArrayRef<int64_t> padding, bool ceil_mode, bool count_include_pad, torch::executor::optional<int64_t> divisor_override, torch::executor::Tensor & out) {
-    return ::torch::executor::native::avg_pool2d_out(context, self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override, out);
-}
-
-
-// aten::bitwise_and.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & bitwise_and_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::bitwise_and_Scalar_out(context, self, other, out);
-}
-
-
-// aten::bitwise_and.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & bitwise_and_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::bitwise_and_Tensor_out(context, self, other, out);
-}
-
-
-// aten::bitwise_not.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & bitwise_not_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::bitwise_not_out(context, self, out);
-}
-
-
-// aten::bitwise_or.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & bitwise_or_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::bitwise_or_Scalar_out(context, self, other, out);
-}
-
-
-// aten::bitwise_or.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & bitwise_or_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::bitwise_or_Tensor_out(context, self, other, out);
-}
-
-
-// aten::bitwise_xor.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & bitwise_xor_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::bitwise_xor_Scalar_out(context, self, other, out);
-}
-
-
-// aten::bitwise_xor.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & bitwise_xor_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::bitwise_xor_Tensor_out(context, self, other, out);
-}
-
-
-// aten::bitwise_left_shift.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & bitwise_left_shift_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::bitwise_left_shift_Tensor_out(context, self, other, out);
-}
-
-
-// aten::bitwise_left_shift.Tensor_Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & bitwise_left_shift_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::bitwise_left_shift_Tensor_Scalar_out(context, self, other, out);
-}
-
-
-// aten::bitwise_right_shift.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & bitwise_right_shift_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::bitwise_right_shift_Tensor_out(context, self, other, out);
-}
-
-
-// aten::bitwise_right_shift.Tensor_Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & bitwise_right_shift_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::bitwise_right_shift_Tensor_Scalar_out(context, self, other, out);
-}
-
-
-// aten::bmm.out(Tensor self, Tensor mat2, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & bmm_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & mat2, torch::executor::Tensor & out) {
-    return ::torch::executor::native::bmm_out(context, self, mat2, out);
-}
-
-
-// aten::cat.out(Tensor[] tensors, int dim=0, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & cat_outf(torch::executor::KernelRuntimeContext & context, torch::executor::TensorList tensors, int64_t dim, torch::executor::Tensor & out) {
-    return ::torch::executor::native::cat_out(context, tensors, dim, out);
-}
-
-
-// aten::ceil.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & ceil_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::ceil_out(context, self, out);
-}
-
-
-// aten::clamp.out(Tensor self, Scalar? min=None, Scalar? max=None, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & clamp_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::optional<torch::executor::Scalar> & min, const torch::executor::optional<torch::executor::Scalar> & max, torch::executor::Tensor & out) {
-    return ::torch::executor::native::clamp_out(context, self, min, max, out);
-}
-
-
-// aten::clamp.Tensor_out(Tensor self, Tensor? min=None, Tensor? max=None, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & clamp_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::optional<torch::executor::Tensor> & min, const torch::executor::optional<torch::executor::Tensor> & max, torch::executor::Tensor & out) {
-    return ::torch::executor::native::clamp_tensor_out(context, self, min, max, out);
-}
-
-
-// aten::clone.out(Tensor self, *, MemoryFormat? memory_format=None, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & clone_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<torch::executor::MemoryFormat> memory_format, torch::executor::Tensor & out) {
-    return ::torch::executor::native::clone_out(context, self, memory_format, out);
-}
-
-
-// aten::constant_pad_nd.out(Tensor self, SymInt[] pad, Scalar value=0, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & constant_pad_nd_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> pad, const torch::executor::Scalar & value, torch::executor::Tensor & out) {
-    return ::torch::executor::native::constant_pad_nd_out(context, self, pad, value, out);
-}
-
-
-// aten::convolution.out(Tensor input, Tensor weight, Tensor? bias, SymInt[] stride, SymInt[] padding, SymInt[] dilation, bool transposed, SymInt[] output_padding, SymInt groups, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & convolution_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & weight, const torch::executor::optional<torch::executor::Tensor> & bias, torch::executor::ArrayRef<int64_t> stride, torch::executor::ArrayRef<int64_t> padding, torch::executor::ArrayRef<int64_t> dilation, bool transposed, torch::executor::ArrayRef<int64_t> output_padding, int64_t groups, torch::executor::Tensor & out) {
-    return ::torch::executor::native::convolution_out(context, input, weight, bias, stride, padding, dilation, transposed, output_padding, groups, out);
-}
-
-
-// aten::convolution_backward.out(Tensor grad_output, Tensor input, Tensor weight, SymInt[]? bias_sizes, SymInt[] stride, SymInt[] padding, SymInt[] dilation, bool transposed, SymInt[] output_padding, SymInt groups, bool[3] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!))
-TORCH_API inline ::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &,torch::executor::Tensor &> convolution_backward_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & grad_output, const torch::executor::Tensor & input, const torch::executor::Tensor & weight, torch::executor::optional<torch::executor::ArrayRef<int64_t>> bias_sizes, torch::executor::ArrayRef<int64_t> stride, torch::executor::ArrayRef<int64_t> padding, torch::executor::ArrayRef<int64_t> dilation, bool transposed, torch::executor::ArrayRef<int64_t> output_padding, int64_t groups, torch::executor::ArrayRef<bool> output_mask, torch::executor::Tensor & out0, torch::executor::Tensor & out1, torch::executor::Tensor & out2) {
-    return ::torch::executor::native::convolution_backward_out(context, grad_output, input, weight, bias_sizes, stride, padding, dilation, transposed, output_padding, groups, output_mask, out0, out1, out2);
-}
-
-
-// aten::copy.out(Tensor self, Tensor src, bool non_blocking=False, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & src, bool non_blocking, torch::executor::Tensor & out) {
-    return ::torch::executor::native::copy_out(context, self, src, non_blocking, out);
-}
-
-
-// aten::copy_(Tensor(a!) self, Tensor src, bool non_blocking=False) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & copy_(torch::executor::KernelRuntimeContext & context, torch::executor::Tensor & self, const torch::executor::Tensor & src, bool non_blocking) {
-    return ::torch::executor::native::copy_(context, self, src, non_blocking);
-}
-
-
-// aten::cos.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & cos_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::cos_out(context, self, out);
-}
-
-
-// aten::cosh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & cosh_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::cosh_out(context, self, out);
-}
-
-
-// aten::cumsum.out(Tensor self, int dim, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & cumsum_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out) {
-    return ::torch::executor::native::cumsum_out(context, self, dim, dtype, out);
-}
-
-
-// aten::detach_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & detach_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::detach_copy_out(context, self, out);
-}
-
-
-// aten::diagonal_copy.out(Tensor self, int offset=0, int dim1=0, int dim2=1, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & diagonal_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t offset, int64_t dim1, int64_t dim2, torch::executor::Tensor & out) {
-    return ::torch::executor::native::diagonal_copy_out(context, self, offset, dim1, dim2, out);
-}
-
-
-// aten::div.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & div_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::div_out(context, self, other, out);
-}
-
-
-// aten::div.Scalar_mode_out(Tensor self, Scalar other, *, str? rounding_mode, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & div_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::optional<torch::executor::string_view> rounding_mode, torch::executor::Tensor & out) {
-    return ::torch::executor::native::div_scalar_mode_out(context, self, other, rounding_mode, out);
-}
-
-
-// aten::div.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & div_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::div_scalar_out(context, self, other, out);
-}
-
-
-// aten::div.out_mode(Tensor self, Tensor other, *, str? rounding_mode, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & div_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::optional<torch::executor::string_view> rounding_mode, torch::executor::Tensor & out) {
-    return ::torch::executor::native::div_out_mode(context, self, other, rounding_mode, out);
-}
-
-
-// aten::embedding.out(Tensor weight, Tensor indices, SymInt padding_idx=-1, bool scale_grad_by_freq=False, bool sparse=False, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & embedding_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & weight, const torch::executor::Tensor & indices, int64_t padding_idx, bool scale_grad_by_freq, bool sparse, torch::executor::Tensor & out) {
-    return ::torch::executor::native::embedding_out(context, weight, indices, padding_idx, scale_grad_by_freq, sparse, out);
-}
-
-
-// aten::empty.out(SymInt[] size, *, MemoryFormat? memory_format=None, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & empty_outf(torch::executor::KernelRuntimeContext & context, torch::executor::ArrayRef<int64_t> size, torch::executor::optional<torch::executor::MemoryFormat> memory_format, torch::executor::Tensor & out) {
-    return ::torch::executor::native::empty_out(context, size, memory_format, out);
-}
-
-
-// aten::eq.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & eq_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::eq_scalar_out(context, self, other, out);
-}
-
-
-// aten::eq.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & eq_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::eq_tensor_out(context, self, other, out);
-}
-
-
-// aten::elu.out(Tensor self, Scalar alpha=1, Scalar scale=1, Scalar input_scale=1, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & elu_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & alpha, const torch::executor::Scalar & scale, const torch::executor::Scalar & input_scale, torch::executor::Tensor & out) {
-    return ::torch::executor::native::elu_out(context, self, alpha, scale, input_scale, out);
-}
-
-
-// aten::erf.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & erf_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::erf_out(context, self, out);
-}
-
-
-// aten::exp.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & exp_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::exp_out(context, self, out);
-}
-
-
-// aten::expand_copy.out(Tensor self, SymInt[] size, *, bool implicit=False, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & expand_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> size, bool implicit, torch::executor::Tensor & out) {
-    return ::torch::executor::native::expand_copy_out(context, self, size, implicit, out);
-}
-
-
-// aten::expm1.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & expm1_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::expm1_out(context, self, out);
-}
-
-
-// aten::fill.Scalar_out(Tensor self, Scalar value, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & fill_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & value, torch::executor::Tensor & out) {
-    return ::torch::executor::native::fill_scalar_out(context, self, value, out);
-}
-
-
-// aten::fill.Tensor_out(Tensor self, Tensor value, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & fill_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & value, torch::executor::Tensor & out) {
-    return ::torch::executor::native::fill_tensor_out(context, self, value, out);
-}
-
-
-// aten::flip.out(Tensor self, int[] dims, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & flip_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> dims, torch::executor::Tensor & out) {
-    return ::torch::executor::native::flip_out(context, self, dims, out);
-}
-
-
-// aten::floor.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & floor_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::floor_out(context, self, out);
-}
-
-
-// aten::floor_divide.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & floor_divide_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::floor_divide_out(context, self, other, out);
-}
-
-
-// aten::fmod.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & fmod_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::fmod_Tensor_out(context, self, other, out);
-}
-
-
-// aten::fmod.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & fmod_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::fmod_Scalar_out(context, self, other, out);
-}
-
-
-// aten::full.out(SymInt[] size, Scalar fill_value, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & full_outf(torch::executor::KernelRuntimeContext & context, torch::executor::ArrayRef<int64_t> size, const torch::executor::Scalar & fill_value, torch::executor::Tensor & out) {
-    return ::torch::executor::native::full_out(context, size, fill_value, out);
-}
-
-
-// aten::full_like.out(Tensor self, Scalar fill_value, *, MemoryFormat? memory_format=None, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & full_like_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & fill_value, torch::executor::optional<torch::executor::MemoryFormat> memory_format, torch::executor::Tensor & out) {
-    return ::torch::executor::native::full_like_out(context, self, fill_value, memory_format, out);
-}
-
-
-// aten::gather.out(Tensor self, int dim, Tensor index, *, bool sparse_grad=False, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & gather_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, const torch::executor::Tensor & index, bool sparse_grad, torch::executor::Tensor & out) {
-    return ::torch::executor::native::gather_out(context, self, dim, index, sparse_grad, out);
-}
-
-
-// aten::ge.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & ge_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::ge_scalar_out(context, self, other, out);
-}
-
-
-// aten::ge.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & ge_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::ge_tensor_out(context, self, other, out);
-}
-
-
-// aten::gelu.out(Tensor self, *, str approximate='none', Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & gelu_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::string_view approximate, torch::executor::Tensor & out) {
-    return ::torch::executor::native::gelu_out(context, self, approximate, out);
-}
-
-
-// aten::glu.out(Tensor self, int dim=-1, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & glu_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, torch::executor::Tensor & out) {
-    return ::torch::executor::native::glu_out(context, self, dim, out);
-}
-
-
-// aten::grid_sampler_2d.out(Tensor input, Tensor grid, int interpolation_mode, int padding_mode, bool align_corners, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & grid_sampler_2d_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners, torch::executor::Tensor & out) {
-    return ::torch::executor::native::grid_sampler_2d_out(context, input, grid, interpolation_mode, padding_mode, align_corners, out);
-}
-
-
-// aten::gt.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & gt_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::gt_scalar_out(context, self, other, out);
-}
-
-
-// aten::gt.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & gt_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::gt_tensor_out(context, self, other, out);
-}
-
-
-// aten::hardtanh.out(Tensor self, Scalar min_val=-1, Scalar max_val=1, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & hardtanh_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & min_val, const torch::executor::Scalar & max_val, torch::executor::Tensor & out) {
-    return ::torch::executor::native::hardtanh_out(context, self, min_val, max_val, out);
-}
-
-
-// aten::index.Tensor_out(Tensor self, Tensor?[] indices, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & index_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<torch::executor::optional<torch::executor::Tensor>> indices, torch::executor::Tensor & out) {
-    return ::torch::executor::native::index_Tensor_out(context, self, indices, out);
-}
-
-
-// aten::index_put.out(Tensor self, Tensor?[] indices, Tensor values, bool accumulate=False, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & index_put_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<torch::executor::optional<torch::executor::Tensor>> indices, const torch::executor::Tensor & values, bool accumulate, torch::executor::Tensor & out) {
-    return ::torch::executor::native::index_put_out(context, self, indices, values, accumulate, out);
-}
-
-
-// aten::index_put_(Tensor(a!) self, Tensor?[] indices, Tensor values, bool accumulate=False) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & index_put_(torch::executor::KernelRuntimeContext & context, torch::executor::Tensor & self, torch::executor::ArrayRef<torch::executor::optional<torch::executor::Tensor>> indices, const torch::executor::Tensor & values, bool accumulate) {
-    return ::torch::executor::native::index_put_(context, self, indices, values, accumulate);
-}
-
-
-// aten::index_select.out(Tensor self, int dim, Tensor index, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & index_select_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, const torch::executor::Tensor & index, torch::executor::Tensor & out) {
-    return ::torch::executor::native::index_select_out(context, self, dim, index, out);
-}
-
-
-// aten::isinf.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & isinf_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::isinf_out(context, self, out);
-}
-
-
-// aten::isnan.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & isnan_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::isnan_out(context, self, out);
-}
-
-
-// aten::le.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & le_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::le_scalar_out(context, self, other, out);
-}
-
-
-// aten::le.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & le_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::le_tensor_out(context, self, other, out);
-}
-
-
-// aten::leaky_relu.out(Tensor self, Scalar negative_slope=0.01, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & leaky_relu_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & negative_slope, torch::executor::Tensor & out) {
-    return ::torch::executor::native::leaky_relu_out(context, self, negative_slope, out);
-}
-
-
-// aten::lift_fresh_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & lift_fresh_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::lift_fresh_copy_out(context, self, out);
-}
-
-
-// aten::log.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & log_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::log_out(context, self, out);
-}
-
-
-// aten::log10.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & log10_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::log10_out(context, self, out);
-}
-
-
-// aten::log1p.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & log1p_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::log1p_out(context, self, out);
-}
-
-
-// aten::log2.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & log2_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::log2_out(context, self, out);
-}
-
-
-// aten::logical_and.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & logical_and_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::logical_and_out(context, self, other, out);
-}
-
-
-// aten::logical_not.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & logical_not_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::logical_not_out(context, self, out);
-}
-
-
-// aten::logical_or.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & logical_or_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::logical_or_out(context, self, other, out);
-}
-
-
-// aten::logical_xor.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & logical_xor_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::logical_xor_out(context, self, other, out);
-}
-
-
-// aten::logit.out(Tensor self, float? eps=None, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & logit_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<double> eps, torch::executor::Tensor & out) {
-    return ::torch::executor::native::logit_out(context, self, eps, out);
-}
-
-
-// aten::lt.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & lt_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::lt_scalar_out(context, self, other, out);
-}
-
-
-// aten::lt.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & lt_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::lt_tensor_out(context, self, other, out);
-}
-
-
-// aten::masked_fill.Scalar_out(Tensor self, Tensor mask, Scalar value, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & masked_fill_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & mask, const torch::executor::Scalar & value, torch::executor::Tensor & out) {
-    return ::torch::executor::native::masked_fill_scalar_out(context, self, mask, value, out);
-}
-
-
-// aten::masked_scatter.out(Tensor self, Tensor mask, Tensor source, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & masked_scatter_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & mask, const torch::executor::Tensor & source, torch::executor::Tensor & out) {
-    return ::torch::executor::native::masked_scatter_out(context, self, mask, source, out);
-}
-
-
-// aten::masked_select.out(Tensor self, Tensor mask, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & masked_select_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & mask, torch::executor::Tensor & out) {
-    return ::torch::executor::native::masked_select_out(context, self, mask, out);
-}
-
-
-// aten::max.dim_max(Tensor self, int dim, bool keepdim=False, *, Tensor(a!) max, Tensor(b!) max_values) -> (Tensor(a!) values, Tensor(b!) indices)
-TORCH_API inline ::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> max_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, bool keepdim, torch::executor::Tensor & max, torch::executor::Tensor & max_values) {
-    return ::torch::executor::native::max_out(context, self, dim, keepdim, max, max_values);
-}
-
-
-// aten::max.unary_out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & max_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::max_unary_out(context, self, out);
-}
-
-
-// aten::maximum.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & maximum_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::maximum_out(context, self, other, out);
-}
-
-
-// aten::max_pool2d_with_indices.out(Tensor self, int[2] kernel_size, int[2] stride=[], int[2] padding=0, int[2] dilation=1, bool ceil_mode=False, *, Tensor(a!) out, Tensor(b!) indices) -> (Tensor(a!), Tensor(b!))
-TORCH_API inline ::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> max_pool2d_with_indices_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> kernel_size, torch::executor::ArrayRef<int64_t> stride, torch::executor::ArrayRef<int64_t> padding, torch::executor::ArrayRef<int64_t> dilation, bool ceil_mode, torch::executor::Tensor & out, torch::executor::Tensor & indices) {
-    return ::torch::executor::native::max_pool2d_with_indices_out(context, self, kernel_size, stride, padding, dilation, ceil_mode, out, indices);
-}
-
-
-// aten::max_pool2d_with_indices_backward.grad_input(Tensor grad_output, Tensor self, int[2] kernel_size, int[2] stride, int[2] padding, int[2] dilation, bool ceil_mode, Tensor indices, *, Tensor(a!) grad_input) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & max_pool2d_with_indices_backward_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & grad_output, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> kernel_size, torch::executor::ArrayRef<int64_t> stride, torch::executor::ArrayRef<int64_t> padding, torch::executor::ArrayRef<int64_t> dilation, bool ceil_mode, const torch::executor::Tensor & indices, torch::executor::Tensor & grad_input) {
-    return ::torch::executor::native::max_pool2d_with_indices_backward_out(context, grad_output, self, kernel_size, stride, padding, dilation, ceil_mode, indices, grad_input);
-}
-
-
-// aten::mean.out(Tensor self, int[1]? dim, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & mean_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, bool keepdim, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out) {
-    return ::torch::executor::native::mean_dim_out(context, self, dim, keepdim, dtype, out);
-}
-
-
-// aten::mean.dtype_out(Tensor self, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & mean_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out) {
-    return ::torch::executor::native::mean_dtype_out(context, self, dtype, out);
-}
-
-
-// aten::min.dim_min(Tensor self, int dim, bool keepdim=False, *, Tensor(a!) min, Tensor(b!) min_indices) -> (Tensor(a!) values, Tensor(b!) indices)
-TORCH_API inline ::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> min_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, bool keepdim, torch::executor::Tensor & min, torch::executor::Tensor & min_indices) {
-    return ::torch::executor::native::min_out(context, self, dim, keepdim, min, min_indices);
-}
-
-
-// aten::min.unary_out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & min_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::min_unary_out(context, self, out);
-}
-
-
-// aten::minimum.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & minimum_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::minimum_out(context, self, other, out);
-}
-
-
-// aten::mm.out(Tensor self, Tensor mat2, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & mm_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & mat2, torch::executor::Tensor & out) {
-    return ::torch::executor::native::mm_out(context, self, mat2, out);
-}
-
-
-// aten::mul.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & mul_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::mul_out(context, self, other, out);
-}
-
-
-// aten::mul.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & mul_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::mul_scalar_out(context, self, other, out);
-}
-
-
-// aten::narrow_copy.out(Tensor self, int dim, SymInt start, SymInt length, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & narrow_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, int64_t start, int64_t length, torch::executor::Tensor & out) {
-    return ::torch::executor::native::narrow_copy_out(context, self, dim, start, length, out);
-}
-
-
-// aten::native_dropout.out(Tensor input, float p, bool? train, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!))
-TORCH_API inline ::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> native_dropout_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, double p, torch::executor::optional<bool> train, torch::executor::Tensor & out0, torch::executor::Tensor & out1) {
-    return ::torch::executor::native::native_dropout_out(context, input, p, train, out0, out1);
-}
-
-
-// aten::native_group_norm.out(Tensor input, Tensor? weight, Tensor? bias, SymInt N, SymInt C, SymInt HxW, int group, float eps, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!))
-TORCH_API inline ::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &,torch::executor::Tensor &> native_group_norm_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::optional<torch::executor::Tensor> & weight, const torch::executor::optional<torch::executor::Tensor> & bias, int64_t N, int64_t C, int64_t HxW, int64_t group, double eps, torch::executor::Tensor & out0, torch::executor::Tensor & out1, torch::executor::Tensor & out2) {
-    return ::torch::executor::native::native_group_norm_out(context, input, weight, bias, N, C, HxW, group, eps, out0, out1, out2);
-}
-
-
-// aten::native_layer_norm.out(Tensor input, SymInt[] normalized_shape, Tensor? weight, Tensor? bias, float eps, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!))
-TORCH_API inline ::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &,torch::executor::Tensor &> native_layer_norm_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, torch::executor::ArrayRef<int64_t> normalized_shape, const torch::executor::optional<torch::executor::Tensor> & weight, const torch::executor::optional<torch::executor::Tensor> & bias, double eps, torch::executor::Tensor & out0, torch::executor::Tensor & out1, torch::executor::Tensor & out2) {
-    return ::torch::executor::native::native_layer_norm_out(context, input, normalized_shape, weight, bias, eps, out0, out1, out2);
-}
-
-
-// aten::ne.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & ne_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::ne_scalar_out(context, self, other, out);
-}
-
-
-// aten::ne.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & ne_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::ne_tensor_out(context, self, other, out);
-}
-
-
-// aten::neg.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & neg_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::neg_out(context, self, out);
-}
-
-
-// aten::nonzero.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & nonzero_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::nonzero_out(context, self, out);
-}
-
-
-// aten::ones.out(SymInt[] size, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & ones_outf(torch::executor::KernelRuntimeContext & context, torch::executor::ArrayRef<int64_t> size, torch::executor::Tensor & out) {
-    return ::torch::executor::native::ones_out(context, size, out);
-}
-
-
-// aten::permute_copy.out(Tensor self, int[] dims, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & permute_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> dims, torch::executor::Tensor & out) {
-    return ::torch::executor::native::permute_copy_out(context, self, dims, out);
-}
-
-
-// aten::pixel_shuffle.out(Tensor self, int upscale_factor, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & pixel_shuffle_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t upscale_factor, torch::executor::Tensor & out) {
-    return ::torch::executor::native::pixel_shuffle_out(context, self, upscale_factor, out);
-}
-
-
-// aten::pixel_unshuffle.out(Tensor self, int downscale_factor, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & pixel_unshuffle_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t downscale_factor, torch::executor::Tensor & out) {
-    return ::torch::executor::native::pixel_unshuffle_out(context, self, downscale_factor, out);
-}
-
-
-// aten::pow.Scalar_out(Scalar self, Tensor exponent, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & pow_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Scalar & self, const torch::executor::Tensor & exponent, torch::executor::Tensor & out) {
-    return ::torch::executor::native::pow_Scalar_out(context, self, exponent, out);
-}
-
-
-// aten::pow.Tensor_Scalar_out(Tensor self, Scalar exponent, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & pow_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & exponent, torch::executor::Tensor & out) {
-    return ::torch::executor::native::pow_Tensor_Scalar_out(context, self, exponent, out);
-}
-
-
-// aten::pow.Tensor_Tensor_out(Tensor self, Tensor exponent, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & pow_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & exponent, torch::executor::Tensor & out) {
-    return ::torch::executor::native::pow_Tensor_Tensor_out(context, self, exponent, out);
-}
-
-
-// aten::prod.int_out(Tensor self, int dim, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & prod_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, bool keepdim, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out) {
-    return ::torch::executor::native::prod_int_out(context, self, dim, keepdim, dtype, out);
-}
-
-
-// aten::prod.out(Tensor self, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & prod_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out) {
-    return ::torch::executor::native::prod_out(context, self, dtype, out);
-}
-
-
-// aten::rand.out(SymInt[] size, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & rand_outf(torch::executor::KernelRuntimeContext & context, torch::executor::ArrayRef<int64_t> size, torch::executor::Tensor & out) {
-    return ::torch::executor::native::rand_out(context, size, out);
-}
-
-
-// aten::randn.out(SymInt[] size, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & randn_outf(torch::executor::KernelRuntimeContext & context, torch::executor::ArrayRef<int64_t> size, torch::executor::Tensor & out) {
-    return ::torch::executor::native::randn_out(context, size, out);
-}
-
-
-// aten::reciprocal.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & reciprocal_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::reciprocal_out(context, self, out);
-}
-
-
-// aten::relu.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & relu_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::relu_out(context, self, out);
-}
-
-
-// aten::remainder.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & remainder_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::remainder_Tensor_out(context, self, other, out);
-}
-
-
-// aten::remainder.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & remainder_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::remainder_Scalar_out(context, self, other, out);
-}
-
-
-// aten::repeat.out(Tensor self, SymInt[] repeats, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & repeat_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> repeats, torch::executor::Tensor & out) {
-    return ::torch::executor::native::repeat_out(context, self, repeats, out);
-}
-
-
-// aten::repeat_interleave.Tensor_out(Tensor repeats, *, SymInt? output_size=None, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & repeat_interleave_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & repeats, torch::executor::optional<int64_t> output_size, torch::executor::Tensor & out) {
-    return ::torch::executor::native::repeat_interleave_Tensor_out(context, repeats, output_size, out);
-}
-
-
-// aten::reflection_pad1d.out(Tensor self, SymInt[2] padding, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & reflection_pad1d_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> padding, torch::executor::Tensor & out) {
-    return ::torch::executor::native::reflection_pad1d_out(context, self, padding, out);
-}
-
-
-// aten::reflection_pad2d.out(Tensor self, SymInt[4] padding, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & reflection_pad2d_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> padding, torch::executor::Tensor & out) {
-    return ::torch::executor::native::reflection_pad2d_out(context, self, padding, out);
-}
-
-
-// aten::reflection_pad3d.out(Tensor self, SymInt[6] padding, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & reflection_pad3d_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> padding, torch::executor::Tensor & out) {
-    return ::torch::executor::native::reflection_pad3d_out(context, self, padding, out);
-}
-
-
-// aten::replication_pad1d.out(Tensor self, SymInt[2] padding, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & replication_pad1d_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> padding, torch::executor::Tensor & out) {
-    return ::torch::executor::native::replication_pad1d_out(context, self, padding, out);
-}
-
-
-// aten::replication_pad2d.out(Tensor self, SymInt[4] padding, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & replication_pad2d_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> padding, torch::executor::Tensor & out) {
-    return ::torch::executor::native::replication_pad2d_out(context, self, padding, out);
-}
-
-
-// aten::replication_pad3d.out(Tensor self, SymInt[6] padding, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & replication_pad3d_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> padding, torch::executor::Tensor & out) {
-    return ::torch::executor::native::replication_pad3d_out(context, self, padding, out);
-}
-
-
-// aten::roll.out(Tensor self, SymInt[1] shifts, int[1] dims=[], *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & roll_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> shifts, torch::executor::ArrayRef<int64_t> dims, torch::executor::Tensor & out) {
-    return ::torch::executor::native::roll_out(context, self, shifts, dims, out);
-}
-
-
-// aten::round.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & round_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::round_out(context, self, out);
-}
-
-
-// aten::rsqrt.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & rsqrt_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::rsqrt_out(context, self, out);
-}
-
-
-// aten::rsub.Scalar_out(Tensor self, Scalar other, Scalar alpha=1, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & rsub_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out) {
-    return ::torch::executor::native::rsub_scalar_out(context, self, other, alpha, out);
-}
-
-
-// aten::scalar_tensor.out(Scalar s, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & scalar_tensor_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Scalar & s, torch::executor::Tensor & out) {
-    return ::torch::executor::native::scalar_tensor_out(context, s, out);
-}
-
-
-// aten::scatter.src_out(Tensor self, int dim, Tensor index, Tensor src, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & scatter_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, const torch::executor::Tensor & index, const torch::executor::Tensor & src, torch::executor::Tensor & out) {
-    return ::torch::executor::native::scatter_src_out(context, self, dim, index, src, out);
-}
-
-
-// aten::scatter.value_out(Tensor self, int dim, Tensor index, Scalar value, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & scatter_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, const torch::executor::Tensor & index, const torch::executor::Scalar & value, torch::executor::Tensor & out) {
-    return ::torch::executor::native::scatter_value_out(context, self, dim, index, value, out);
-}
-
-
-// aten::scatter_add.out(Tensor self, int dim, Tensor index, Tensor src, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & scatter_add_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, const torch::executor::Tensor & index, const torch::executor::Tensor & src, torch::executor::Tensor & out) {
-    return ::torch::executor::native::scatter_add_out(context, self, dim, index, src, out);
-}
-
-
-// aten::select_copy.int_out(Tensor self, int dim, SymInt index, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & select_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, int64_t index, torch::executor::Tensor & out) {
-    return ::torch::executor::native::select_copy_int_out(context, self, dim, index, out);
-}
-
-
-// aten::select_scatter.out(Tensor self, Tensor src, int dim, SymInt index, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & select_scatter_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & src, int64_t dim, int64_t index, torch::executor::Tensor & out) {
-    return ::torch::executor::native::select_scatter_out(context, self, src, dim, index, out);
-}
-
-
-// aten::sigmoid.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & sigmoid_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::sigmoid_out(context, self, out);
-}
-
-
-// aten::sign.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & sign_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::sign_out(context, self, out);
-}
-
-
-// aten::sin.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & sin_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::sin_out(context, self, out);
-}
-
-
-// aten::sinh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & sinh_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::sinh_out(context, self, out);
-}
-
-
-// aten::slice_copy.Tensor_out(Tensor self, int dim=0, SymInt? start=None, SymInt? end=None, SymInt step=1, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & slice_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, torch::executor::optional<int64_t> start, torch::executor::optional<int64_t> end, int64_t step, torch::executor::Tensor & out) {
-    return ::torch::executor::native::slice_copy_Tensor_out(context, self, dim, start, end, step, out);
-}
-
-
-// aten::slice_scatter.out(Tensor self, Tensor src, int dim=0, SymInt? start=None, SymInt? end=None, SymInt step=1, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & slice_scatter_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & src, int64_t dim, torch::executor::optional<int64_t> start, torch::executor::optional<int64_t> end, int64_t step, torch::executor::Tensor & out) {
-    return ::torch::executor::native::slice_scatter_out(context, self, src, dim, start, end, step, out);
-}
-
-
-// aten::split_copy.Tensor_out(Tensor self, SymInt split_size, int dim=0, *, Tensor(a!)[] out) -> ()
-TORCH_API inline void split_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t split_size, int64_t dim, torch::executor::TensorList out) {
-    return ::torch::executor::native::split_copy_Tensor_out(context, self, split_size, dim, out);
-}
-
-
-// aten::split_with_sizes_copy.out(Tensor self, SymInt[] split_sizes, int dim=0, *, Tensor(a!)[] out) -> ()
-TORCH_API inline void split_with_sizes_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> split_sizes, int64_t dim, torch::executor::TensorList out) {
-    return ::torch::executor::native::split_with_sizes_copy_out(context, self, split_sizes, dim, out);
-}
-
-
-// aten::sqrt.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & sqrt_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::sqrt_out(context, self, out);
-}
-
-
-// aten::squeeze_copy.dim_out(Tensor self, int dim, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & squeeze_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, torch::executor::Tensor & out) {
-    return ::torch::executor::native::squeeze_copy_dim_out(context, self, dim, out);
-}
-
-
-// aten::squeeze_copy.dims_out(Tensor self, int[] dim, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & squeeze_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> dim, torch::executor::Tensor & out) {
-    return ::torch::executor::native::squeeze_copy_dims_out(context, self, dim, out);
-}
-
-
-// aten::stack.out(Tensor[] tensors, int dim=0, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & stack_outf(torch::executor::KernelRuntimeContext & context, torch::executor::TensorList tensors, int64_t dim, torch::executor::Tensor & out) {
-    return ::torch::executor::native::stack_out(context, tensors, dim, out);
-}
-
-
-// aten::sub.out(Tensor self, Tensor other, *, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & sub_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out) {
-    return ::torch::executor::native::sub_out(context, self, other, alpha, out);
-}
-
-
-// aten::sub.Scalar_out(Tensor self, Scalar other, Scalar alpha=1, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & sub_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out) {
-    return ::torch::executor::native::sub_scalar_out(context, self, other, alpha, out);
-}
-
-
-// aten::sum.IntList_out(Tensor self, int[1]? dim, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & sum_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, bool keepdim, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out) {
-    return ::torch::executor::native::sum_dim_out(context, self, dim, keepdim, dtype, out);
-}
-
-
-// aten::t_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & t_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::t_copy_out(context, self, out);
-}
-
-
-// aten::tan.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & tan_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::tan_out(context, self, out);
-}
-
-
-// aten::tanh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & tanh_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::tanh_out(context, self, out);
-}
-
-
-// aten::topk.values(Tensor self, SymInt k, int dim=-1, bool largest=True, bool sorted=True, *, Tensor(a!) values, Tensor(b!) indices) -> (Tensor(a!) values, Tensor(b!) indices)
-TORCH_API inline ::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> topk_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t k, int64_t dim, bool largest, bool sorted, torch::executor::Tensor & values, torch::executor::Tensor & indices) {
-    return ::torch::executor::native::topk_values(context, self, k, dim, largest, sorted, values, indices);
-}
-
-
-// aten::transpose_copy.int_out(Tensor self, int dim0, int dim1, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & transpose_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim0, int64_t dim1, torch::executor::Tensor & out) {
-    return ::torch::executor::native::transpose_copy_int_out(context, self, dim0, dim1, out);
-}
-
-
-// aten::tril.out(Tensor self, SymInt diagonal=0, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & tril_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t diagonal, torch::executor::Tensor & out) {
-    return ::torch::executor::native::tril_out(context, self, diagonal, out);
-}
-
-
-// aten::trunc.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & trunc_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::trunc_out(context, self, out);
-}
-
-
-// aten::unbind_copy.int_out(Tensor self, int dim=0, *, Tensor(a!)[] out) -> ()
-TORCH_API inline void unbind_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, torch::executor::TensorList out) {
-    return ::torch::executor::native::unbind_copy_int_out(context, self, dim, out);
-}
-
-
-// aten::unfold_copy.out(Tensor self, int dimension, int size, int step, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & unfold_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dimension, int64_t size, int64_t step, torch::executor::Tensor & out) {
-    return ::torch::executor::native::unfold_copy_out(context, self, dimension, size, step, out);
-}
-
-
-// aten::unsqueeze_copy.out(Tensor self, int dim, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & unsqueeze_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, torch::executor::Tensor & out) {
-    return ::torch::executor::native::unsqueeze_copy_out(context, self, dim, out);
-}
-
-
-// aten::upsample_bilinear2d.vec_out(Tensor input, SymInt[]? output_size, bool align_corners, float[]? scale_factors, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & upsample_bilinear2d_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, torch::executor::optional<torch::executor::ArrayRef<int64_t>> output_size, bool align_corners, torch::executor::optional<torch::executor::ArrayRef<double>> scale_factors, torch::executor::Tensor & out) {
-    return ::torch::executor::native::upsample_bilinear2d_vec_out(context, input, output_size, align_corners, scale_factors, out);
-}
-
-
-// aten::_upsample_bilinear2d_aa.out(Tensor self, SymInt[2] output_size, bool align_corners, float? scales_h=None, float? scales_w=None, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & _upsample_bilinear2d_aa_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> output_size, bool align_corners, torch::executor::optional<double> scales_h, torch::executor::optional<double> scales_w, torch::executor::Tensor & out) {
-    return ::torch::executor::native::_upsample_bilinear2d_aa_out(context, self, output_size, align_corners, scales_h, scales_w, out);
-}
-
-
-// aten::upsample_nearest2d.vec_out(Tensor input, SymInt[]? output_size, float[]? scale_factors, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & upsample_nearest2d_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, torch::executor::optional<torch::executor::ArrayRef<int64_t>> output_size, torch::executor::optional<torch::executor::ArrayRef<double>> scale_factors, torch::executor::Tensor & out) {
-    return ::torch::executor::native::upsample_nearest2d_vec_out(context, input, output_size, scale_factors, out);
-}
-
-
-// aten::var.correction_out(Tensor self, int[1]? dim=None, *, Scalar? correction=None, bool keepdim=False, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & var_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, const torch::executor::optional<torch::executor::Scalar> & correction, bool keepdim, torch::executor::Tensor & out) {
-    return ::torch::executor::native::var_correction_out(context, self, dim, correction, keepdim, out);
-}
-
-
-// aten::var_mean.correction_out(Tensor self, int[1]? dim=None, *, Scalar? correction=None, bool keepdim=False, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!))
-TORCH_API inline ::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> var_mean_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, const torch::executor::optional<torch::executor::Scalar> & correction, bool keepdim, torch::executor::Tensor & out0, torch::executor::Tensor & out1) {
-    return ::torch::executor::native::var_mean_correction_out(context, self, dim, correction, keepdim, out0, out1);
-}
-
-
-// aten::var.out(Tensor self, int[1]? dim, bool unbiased=True, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & var_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, bool unbiased, bool keepdim, torch::executor::Tensor & out) {
-    return ::torch::executor::native::var_out(context, self, dim, unbiased, keepdim, out);
-}
-
-
-// aten::view_as_real_copy.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & view_as_real_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
-    return ::torch::executor::native::view_as_real_copy_out(context, self, out);
-}
-
-
-// aten::view_copy.out(Tensor self, SymInt[] size, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & view_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> size, torch::executor::Tensor & out) {
-    return ::torch::executor::native::view_copy_out(context, self, size, out);
-}
-
-
-// aten::where.self_out(Tensor condition, Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & where_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & condition, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out) {
-    return ::torch::executor::native::where_out(context, condition, self, other, out);
-}
-
-
-// aten::zeros.out(SymInt[] size, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & zeros_outf(torch::executor::KernelRuntimeContext & context, torch::executor::ArrayRef<int64_t> size, torch::executor::Tensor & out) {
-    return ::torch::executor::native::zeros_out(context, size, out);
-}
-
-} // namespace aten
-
-namespace dim_order_ops {
-
-// dim_order_ops::_empty_dim_order.out(int[] size, *, int[]? dim_order=None, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & _empty_dim_order_outf(torch::executor::KernelRuntimeContext & context, torch::executor::ArrayRef<int64_t> size, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim_order, torch::executor::Tensor & out) {
-    return ::torch::executor::native::_empty_dim_order_out(context, size, dim_order, out);
-}
-
-
-// dim_order_ops::_to_dim_order_copy.out(Tensor self, *, bool non_blocking=False, int[]? dim_order=None, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & _to_dim_order_copy_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, bool non_blocking, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim_order, torch::executor::Tensor & out) {
-    return ::torch::executor::native::_to_dim_order_copy_out(context, self, non_blocking, dim_order, out);
-}
-
-
-// dim_order_ops::_clone_dim_order.out(Tensor self, *, bool non_blocking=False, int[]? dim_order=None, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & _clone_dim_order_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, bool non_blocking, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim_order, torch::executor::Tensor & out) {
-    return ::torch::executor::native::_clone_dim_order_out(context, self, non_blocking, dim_order, out);
-}
-
-} // namespace dim_order_ops
-
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/kernels/portable/NativeFunctions.h b/packages/react-native-executorch/third-party/include/executorch/kernels/portable/NativeFunctions.h
deleted file mode 100644
index e2a6cc3f52..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/kernels/portable/NativeFunctions.h
+++ /dev/null
@@ -1,439 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// clang-format off
-#pragma once
-
-#include <tuple>
-
-#include <executorch/runtime/core/exec_aten/exec_aten.h> // at::Tensor etc.
-#include <executorch/runtime/kernel/kernel_runtime_context.h>
-#include <executorch/runtime/core/error.h>
-
-// @generated by gen.py from NativeFunctions.h
-
-namespace torch {
-namespace executor {
-namespace native {
-torch::executor::Tensor & _adaptive_avg_pool2d_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> output_size, torch::executor::Tensor & out);
-torch::executor::Tensor & _adaptive_avg_pool2d_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> output_size, torch::executor::Tensor & out);
-torch::executor::Tensor & _cdist_forward_out(const torch::executor::Tensor & x1, const torch::executor::Tensor & x2, double p, torch::executor::optional<int64_t> compute_mode, torch::executor::Tensor & out);
-torch::executor::Tensor & _cdist_forward_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & x1, const torch::executor::Tensor & x2, double p, torch::executor::optional<int64_t> compute_mode, torch::executor::Tensor & out);
-torch::executor::Tensor & _conj_physical_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & _conj_physical_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & log_softmax_out(const torch::executor::Tensor & self, int64_t dim, bool half_to_float, torch::executor::Tensor & out);
-torch::executor::Tensor & log_softmax_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, bool half_to_float, torch::executor::Tensor & out);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &,torch::executor::Tensor &> _native_batch_norm_legit_out(const torch::executor::Tensor & input, const torch::executor::optional<torch::executor::Tensor> & weight, const torch::executor::optional<torch::executor::Tensor> & bias, torch::executor::Tensor & running_mean, torch::executor::Tensor & running_var, bool training, double momentum, double eps, torch::executor::Tensor & out, torch::executor::Tensor & save_mean, torch::executor::Tensor & save_invstd);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &,torch::executor::Tensor &> _native_batch_norm_legit_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::optional<torch::executor::Tensor> & weight, const torch::executor::optional<torch::executor::Tensor> & bias, torch::executor::Tensor & running_mean, torch::executor::Tensor & running_var, bool training, double momentum, double eps, torch::executor::Tensor & out, torch::executor::Tensor & save_mean, torch::executor::Tensor & save_invstd);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &,torch::executor::Tensor &> _native_batch_norm_legit_no_stats_out(const torch::executor::Tensor & input, const torch::executor::optional<torch::executor::Tensor> & weight, const torch::executor::optional<torch::executor::Tensor> & bias, bool training, double momentum, double eps, torch::executor::Tensor & out, torch::executor::Tensor & save_mean, torch::executor::Tensor & save_invstd);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &,torch::executor::Tensor &> _native_batch_norm_legit_no_stats_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::optional<torch::executor::Tensor> & weight, const torch::executor::optional<torch::executor::Tensor> & bias, bool training, double momentum, double eps, torch::executor::Tensor & out, torch::executor::Tensor & save_mean, torch::executor::Tensor & save_invstd);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &,torch::executor::Tensor &> _native_batch_norm_legit_no_training_out(const torch::executor::Tensor & input, const torch::executor::optional<torch::executor::Tensor> & weight, const torch::executor::optional<torch::executor::Tensor> & bias, const torch::executor::Tensor & running_mean, const torch::executor::Tensor & running_var, double momentum, double eps, torch::executor::Tensor & out0, torch::executor::Tensor & out1, torch::executor::Tensor & out2);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &,torch::executor::Tensor &> _native_batch_norm_legit_no_training_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::optional<torch::executor::Tensor> & weight, const torch::executor::optional<torch::executor::Tensor> & bias, const torch::executor::Tensor & running_mean, const torch::executor::Tensor & running_var, double momentum, double eps, torch::executor::Tensor & out0, torch::executor::Tensor & out1, torch::executor::Tensor & out2);
-torch::executor::Tensor & _pdist_forward_out(const torch::executor::Tensor & self, double p, torch::executor::Tensor & out);
-torch::executor::Tensor & _pdist_forward_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, double p, torch::executor::Tensor & out);
-torch::executor::Tensor & softmax_out(const torch::executor::Tensor & self, int64_t dim, bool half_to_float, torch::executor::Tensor & out);
-torch::executor::Tensor & softmax_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, bool half_to_float, torch::executor::Tensor & out);
-torch::executor::Tensor & to_copy_out(const torch::executor::Tensor & self, bool non_blocking, torch::executor::optional<torch::executor::MemoryFormat> memory_format, torch::executor::Tensor & out);
-torch::executor::Tensor & to_copy_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, bool non_blocking, torch::executor::optional<torch::executor::MemoryFormat> memory_format, torch::executor::Tensor & out);
-torch::executor::Tensor & abs_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & abs_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & acos_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & acos_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & acosh_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & acosh_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & add_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out);
-torch::executor::Tensor & add_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out);
-torch::executor::Tensor & add_scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out);
-torch::executor::Tensor & add_scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out);
-torch::executor::Tensor & addmm_out(const torch::executor::Tensor & self, const torch::executor::Tensor & mat1, const torch::executor::Tensor & mat2, const torch::executor::Scalar & beta, const torch::executor::Scalar & alpha, torch::executor::Tensor & out);
-torch::executor::Tensor & addmm_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & mat1, const torch::executor::Tensor & mat2, const torch::executor::Scalar & beta, const torch::executor::Scalar & alpha, torch::executor::Tensor & out);
-torch::executor::Tensor & alias_copy_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & alias_copy_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & amax_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> dim, bool keepdim, torch::executor::Tensor & out);
-torch::executor::Tensor & amax_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> dim, bool keepdim, torch::executor::Tensor & out);
-torch::executor::Tensor & amin_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> dim, bool keepdim, torch::executor::Tensor & out);
-torch::executor::Tensor & amin_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> dim, bool keepdim, torch::executor::Tensor & out);
-torch::executor::Tensor & any_all_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & any_all_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & any_dims_out(const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, bool keepdim, torch::executor::Tensor & out);
-torch::executor::Tensor & any_dims_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, bool keepdim, torch::executor::Tensor & out);
-torch::executor::Tensor & any_out(const torch::executor::Tensor & self, int64_t dim, bool keepdim, torch::executor::Tensor & out);
-torch::executor::Tensor & any_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, bool keepdim, torch::executor::Tensor & out);
-torch::executor::Tensor & arange_out(const torch::executor::Scalar & end, torch::executor::Tensor & out);
-torch::executor::Tensor & arange_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Scalar & end, torch::executor::Tensor & out);
-torch::executor::Tensor & arange_start_out(const torch::executor::Scalar & start, const torch::executor::Scalar & end, const torch::executor::Scalar & step, torch::executor::Tensor & out);
-torch::executor::Tensor & arange_start_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Scalar & start, const torch::executor::Scalar & end, const torch::executor::Scalar & step, torch::executor::Tensor & out);
-torch::executor::Tensor & argmax_out(const torch::executor::Tensor & self, torch::executor::optional<int64_t> dim, bool keepdim, torch::executor::Tensor & out);
-torch::executor::Tensor & argmax_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<int64_t> dim, bool keepdim, torch::executor::Tensor & out);
-torch::executor::Tensor & argmin_out(const torch::executor::Tensor & self, torch::executor::optional<int64_t> dim, bool keepdim, torch::executor::Tensor & out);
-torch::executor::Tensor & argmin_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<int64_t> dim, bool keepdim, torch::executor::Tensor & out);
-torch::executor::Tensor & as_strided_copy_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> size, torch::executor::ArrayRef<int64_t> stride, torch::executor::optional<int64_t> storage_offset, torch::executor::Tensor & out);
-torch::executor::Tensor & as_strided_copy_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> size, torch::executor::ArrayRef<int64_t> stride, torch::executor::optional<int64_t> storage_offset, torch::executor::Tensor & out);
-torch::executor::Tensor & asin_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & asin_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & asinh_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & asinh_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & atan_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & atan_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & atan2_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & atan2_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & atanh_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & atanh_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & avg_pool2d_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> kernel_size, torch::executor::ArrayRef<int64_t> stride, torch::executor::ArrayRef<int64_t> padding, bool ceil_mode, bool count_include_pad, torch::executor::optional<int64_t> divisor_override, torch::executor::Tensor & out);
-torch::executor::Tensor & avg_pool2d_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> kernel_size, torch::executor::ArrayRef<int64_t> stride, torch::executor::ArrayRef<int64_t> padding, bool ceil_mode, bool count_include_pad, torch::executor::optional<int64_t> divisor_override, torch::executor::Tensor & out);
-torch::executor::Tensor & bitwise_and_Scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & bitwise_and_Scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & bitwise_and_Tensor_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & bitwise_and_Tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & bitwise_not_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & bitwise_not_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & bitwise_or_Scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & bitwise_or_Scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & bitwise_or_Tensor_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & bitwise_or_Tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & bitwise_xor_Scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & bitwise_xor_Scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & bitwise_xor_Tensor_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & bitwise_xor_Tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & bitwise_left_shift_Tensor_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & bitwise_left_shift_Tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & bitwise_left_shift_Tensor_Scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & bitwise_left_shift_Tensor_Scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & bitwise_right_shift_Tensor_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & bitwise_right_shift_Tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & bitwise_right_shift_Tensor_Scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & bitwise_right_shift_Tensor_Scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & bmm_out(const torch::executor::Tensor & self, const torch::executor::Tensor & mat2, torch::executor::Tensor & out);
-torch::executor::Tensor & bmm_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & mat2, torch::executor::Tensor & out);
-torch::executor::Tensor & cat_out(torch::executor::TensorList tensors, int64_t dim, torch::executor::Tensor & out);
-torch::executor::Tensor & cat_out(torch::executor::KernelRuntimeContext & context, torch::executor::TensorList tensors, int64_t dim, torch::executor::Tensor & out);
-torch::executor::Tensor & ceil_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & ceil_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & clamp_out(const torch::executor::Tensor & self, const torch::executor::optional<torch::executor::Scalar> & min, const torch::executor::optional<torch::executor::Scalar> & max, torch::executor::Tensor & out);
-torch::executor::Tensor & clamp_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::optional<torch::executor::Scalar> & min, const torch::executor::optional<torch::executor::Scalar> & max, torch::executor::Tensor & out);
-torch::executor::Tensor & clamp_tensor_out(const torch::executor::Tensor & self, const torch::executor::optional<torch::executor::Tensor> & min, const torch::executor::optional<torch::executor::Tensor> & max, torch::executor::Tensor & out);
-torch::executor::Tensor & clamp_tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::optional<torch::executor::Tensor> & min, const torch::executor::optional<torch::executor::Tensor> & max, torch::executor::Tensor & out);
-torch::executor::Tensor & clone_out(const torch::executor::Tensor & self, torch::executor::optional<torch::executor::MemoryFormat> memory_format, torch::executor::Tensor & out);
-torch::executor::Tensor & clone_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<torch::executor::MemoryFormat> memory_format, torch::executor::Tensor & out);
-torch::executor::Tensor & constant_pad_nd_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> pad, const torch::executor::Scalar & value, torch::executor::Tensor & out);
-torch::executor::Tensor & constant_pad_nd_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> pad, const torch::executor::Scalar & value, torch::executor::Tensor & out);
-torch::executor::Tensor & convolution_out(const torch::executor::Tensor & input, const torch::executor::Tensor & weight, const torch::executor::optional<torch::executor::Tensor> & bias, torch::executor::ArrayRef<int64_t> stride, torch::executor::ArrayRef<int64_t> padding, torch::executor::ArrayRef<int64_t> dilation, bool transposed, torch::executor::ArrayRef<int64_t> output_padding, int64_t groups, torch::executor::Tensor & out);
-torch::executor::Tensor & convolution_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & weight, const torch::executor::optional<torch::executor::Tensor> & bias, torch::executor::ArrayRef<int64_t> stride, torch::executor::ArrayRef<int64_t> padding, torch::executor::ArrayRef<int64_t> dilation, bool transposed, torch::executor::ArrayRef<int64_t> output_padding, int64_t groups, torch::executor::Tensor & out);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &,torch::executor::Tensor &> convolution_backward_out(const torch::executor::Tensor & grad_output, const torch::executor::Tensor & input, const torch::executor::Tensor & weight, torch::executor::optional<torch::executor::ArrayRef<int64_t>> bias_sizes, torch::executor::ArrayRef<int64_t> stride, torch::executor::ArrayRef<int64_t> padding, torch::executor::ArrayRef<int64_t> dilation, bool transposed, torch::executor::ArrayRef<int64_t> output_padding, int64_t groups, torch::executor::ArrayRef<bool> output_mask, torch::executor::Tensor & out0, torch::executor::Tensor & out1, torch::executor::Tensor & out2);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &,torch::executor::Tensor &> convolution_backward_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & grad_output, const torch::executor::Tensor & input, const torch::executor::Tensor & weight, torch::executor::optional<torch::executor::ArrayRef<int64_t>> bias_sizes, torch::executor::ArrayRef<int64_t> stride, torch::executor::ArrayRef<int64_t> padding, torch::executor::ArrayRef<int64_t> dilation, bool transposed, torch::executor::ArrayRef<int64_t> output_padding, int64_t groups, torch::executor::ArrayRef<bool> output_mask, torch::executor::Tensor & out0, torch::executor::Tensor & out1, torch::executor::Tensor & out2);
-torch::executor::Tensor & copy_out(const torch::executor::Tensor & self, const torch::executor::Tensor & src, bool non_blocking, torch::executor::Tensor & out);
-torch::executor::Tensor & copy_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & src, bool non_blocking, torch::executor::Tensor & out);
-torch::executor::Tensor & copy_(torch::executor::Tensor & self, const torch::executor::Tensor & src, bool non_blocking);
-torch::executor::Tensor & copy_(torch::executor::KernelRuntimeContext & context, torch::executor::Tensor & self, const torch::executor::Tensor & src, bool non_blocking);
-torch::executor::Tensor & cos_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & cos_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & cosh_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & cosh_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & cumsum_out(const torch::executor::Tensor & self, int64_t dim, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & cumsum_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & detach_copy_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & detach_copy_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & diagonal_copy_out(const torch::executor::Tensor & self, int64_t offset, int64_t dim1, int64_t dim2, torch::executor::Tensor & out);
-torch::executor::Tensor & diagonal_copy_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t offset, int64_t dim1, int64_t dim2, torch::executor::Tensor & out);
-torch::executor::Tensor & div_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & div_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & div_scalar_mode_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::optional<torch::executor::string_view> rounding_mode, torch::executor::Tensor & out);
-torch::executor::Tensor & div_scalar_mode_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::optional<torch::executor::string_view> rounding_mode, torch::executor::Tensor & out);
-torch::executor::Tensor & div_scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & div_scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & div_out_mode(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::optional<torch::executor::string_view> rounding_mode, torch::executor::Tensor & out);
-torch::executor::Tensor & div_out_mode(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::optional<torch::executor::string_view> rounding_mode, torch::executor::Tensor & out);
-torch::executor::Tensor & embedding_out(const torch::executor::Tensor & weight, const torch::executor::Tensor & indices, int64_t padding_idx, bool scale_grad_by_freq, bool sparse, torch::executor::Tensor & out);
-torch::executor::Tensor & embedding_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & weight, const torch::executor::Tensor & indices, int64_t padding_idx, bool scale_grad_by_freq, bool sparse, torch::executor::Tensor & out);
-torch::executor::Tensor & empty_out(torch::executor::ArrayRef<int64_t> size, torch::executor::optional<torch::executor::MemoryFormat> memory_format, torch::executor::Tensor & out);
-torch::executor::Tensor & empty_out(torch::executor::KernelRuntimeContext & context, torch::executor::ArrayRef<int64_t> size, torch::executor::optional<torch::executor::MemoryFormat> memory_format, torch::executor::Tensor & out);
-torch::executor::Tensor & eq_scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & eq_scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & eq_tensor_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & eq_tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & elu_out(const torch::executor::Tensor & self, const torch::executor::Scalar & alpha, const torch::executor::Scalar & scale, const torch::executor::Scalar & input_scale, torch::executor::Tensor & out);
-torch::executor::Tensor & elu_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & alpha, const torch::executor::Scalar & scale, const torch::executor::Scalar & input_scale, torch::executor::Tensor & out);
-torch::executor::Tensor & erf_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & erf_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & exp_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & exp_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & expand_copy_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> size, bool implicit, torch::executor::Tensor & out);
-torch::executor::Tensor & expand_copy_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> size, bool implicit, torch::executor::Tensor & out);
-torch::executor::Tensor & expm1_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & expm1_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & fill_scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & value, torch::executor::Tensor & out);
-torch::executor::Tensor & fill_scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & value, torch::executor::Tensor & out);
-torch::executor::Tensor & fill_tensor_out(const torch::executor::Tensor & self, const torch::executor::Tensor & value, torch::executor::Tensor & out);
-torch::executor::Tensor & fill_tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & value, torch::executor::Tensor & out);
-torch::executor::Tensor & flip_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> dims, torch::executor::Tensor & out);
-torch::executor::Tensor & flip_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> dims, torch::executor::Tensor & out);
-torch::executor::Tensor & floor_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & floor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & floor_divide_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & floor_divide_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & fmod_Tensor_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & fmod_Tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & fmod_Scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & fmod_Scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & full_out(torch::executor::ArrayRef<int64_t> size, const torch::executor::Scalar & fill_value, torch::executor::Tensor & out);
-torch::executor::Tensor & full_out(torch::executor::KernelRuntimeContext & context, torch::executor::ArrayRef<int64_t> size, const torch::executor::Scalar & fill_value, torch::executor::Tensor & out);
-torch::executor::Tensor & full_like_out(const torch::executor::Tensor & self, const torch::executor::Scalar & fill_value, torch::executor::optional<torch::executor::MemoryFormat> memory_format, torch::executor::Tensor & out);
-torch::executor::Tensor & full_like_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & fill_value, torch::executor::optional<torch::executor::MemoryFormat> memory_format, torch::executor::Tensor & out);
-torch::executor::Tensor & gather_out(const torch::executor::Tensor & self, int64_t dim, const torch::executor::Tensor & index, bool sparse_grad, torch::executor::Tensor & out);
-torch::executor::Tensor & gather_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, const torch::executor::Tensor & index, bool sparse_grad, torch::executor::Tensor & out);
-torch::executor::Tensor & ge_scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & ge_scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & ge_tensor_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & ge_tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & gelu_out(const torch::executor::Tensor & self, torch::executor::string_view approximate, torch::executor::Tensor & out);
-torch::executor::Tensor & gelu_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::string_view approximate, torch::executor::Tensor & out);
-torch::executor::Tensor & glu_out(const torch::executor::Tensor & self, int64_t dim, torch::executor::Tensor & out);
-torch::executor::Tensor & glu_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, torch::executor::Tensor & out);
-torch::executor::Tensor & grid_sampler_2d_out(const torch::executor::Tensor & input, const torch::executor::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners, torch::executor::Tensor & out);
-torch::executor::Tensor & grid_sampler_2d_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners, torch::executor::Tensor & out);
-torch::executor::Tensor & gt_scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & gt_scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & gt_tensor_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & gt_tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & hardtanh_out(const torch::executor::Tensor & self, const torch::executor::Scalar & min_val, const torch::executor::Scalar & max_val, torch::executor::Tensor & out);
-torch::executor::Tensor & hardtanh_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & min_val, const torch::executor::Scalar & max_val, torch::executor::Tensor & out);
-torch::executor::Tensor & index_Tensor_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<torch::executor::optional<torch::executor::Tensor>> indices, torch::executor::Tensor & out);
-torch::executor::Tensor & index_Tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<torch::executor::optional<torch::executor::Tensor>> indices, torch::executor::Tensor & out);
-torch::executor::Tensor & index_put_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<torch::executor::optional<torch::executor::Tensor>> indices, const torch::executor::Tensor & values, bool accumulate, torch::executor::Tensor & out);
-torch::executor::Tensor & index_put_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<torch::executor::optional<torch::executor::Tensor>> indices, const torch::executor::Tensor & values, bool accumulate, torch::executor::Tensor & out);
-torch::executor::Tensor & index_put_(torch::executor::Tensor & self, torch::executor::ArrayRef<torch::executor::optional<torch::executor::Tensor>> indices, const torch::executor::Tensor & values, bool accumulate);
-torch::executor::Tensor & index_put_(torch::executor::KernelRuntimeContext & context, torch::executor::Tensor & self, torch::executor::ArrayRef<torch::executor::optional<torch::executor::Tensor>> indices, const torch::executor::Tensor & values, bool accumulate);
-torch::executor::Tensor & index_select_out(const torch::executor::Tensor & self, int64_t dim, const torch::executor::Tensor & index, torch::executor::Tensor & out);
-torch::executor::Tensor & index_select_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, const torch::executor::Tensor & index, torch::executor::Tensor & out);
-torch::executor::Tensor & isinf_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & isinf_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & isnan_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & isnan_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & le_scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & le_scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & le_tensor_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & le_tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & leaky_relu_out(const torch::executor::Tensor & self, const torch::executor::Scalar & negative_slope, torch::executor::Tensor & out);
-torch::executor::Tensor & leaky_relu_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & negative_slope, torch::executor::Tensor & out);
-torch::executor::Tensor & lift_fresh_copy_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & lift_fresh_copy_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & log_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & log_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & log10_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & log10_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & log1p_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & log1p_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & log2_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & log2_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & logical_and_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & logical_and_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & logical_not_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & logical_not_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & logical_or_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & logical_or_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & logical_xor_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & logical_xor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & logit_out(const torch::executor::Tensor & self, torch::executor::optional<double> eps, torch::executor::Tensor & out);
-torch::executor::Tensor & logit_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<double> eps, torch::executor::Tensor & out);
-torch::executor::Tensor & lt_scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & lt_scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & lt_tensor_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & lt_tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & masked_fill_scalar_out(const torch::executor::Tensor & self, const torch::executor::Tensor & mask, const torch::executor::Scalar & value, torch::executor::Tensor & out);
-torch::executor::Tensor & masked_fill_scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & mask, const torch::executor::Scalar & value, torch::executor::Tensor & out);
-torch::executor::Tensor & masked_scatter_out(const torch::executor::Tensor & self, const torch::executor::Tensor & mask, const torch::executor::Tensor & source, torch::executor::Tensor & out);
-torch::executor::Tensor & masked_scatter_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & mask, const torch::executor::Tensor & source, torch::executor::Tensor & out);
-torch::executor::Tensor & masked_select_out(const torch::executor::Tensor & self, const torch::executor::Tensor & mask, torch::executor::Tensor & out);
-torch::executor::Tensor & masked_select_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & mask, torch::executor::Tensor & out);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> max_out(const torch::executor::Tensor & self, int64_t dim, bool keepdim, torch::executor::Tensor & max, torch::executor::Tensor & max_values);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> max_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, bool keepdim, torch::executor::Tensor & max, torch::executor::Tensor & max_values);
-torch::executor::Tensor & max_unary_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & max_unary_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & maximum_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & maximum_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> max_pool2d_with_indices_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> kernel_size, torch::executor::ArrayRef<int64_t> stride, torch::executor::ArrayRef<int64_t> padding, torch::executor::ArrayRef<int64_t> dilation, bool ceil_mode, torch::executor::Tensor & out, torch::executor::Tensor & indices);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> max_pool2d_with_indices_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> kernel_size, torch::executor::ArrayRef<int64_t> stride, torch::executor::ArrayRef<int64_t> padding, torch::executor::ArrayRef<int64_t> dilation, bool ceil_mode, torch::executor::Tensor & out, torch::executor::Tensor & indices);
-torch::executor::Tensor & max_pool2d_with_indices_backward_out(const torch::executor::Tensor & grad_output, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> kernel_size, torch::executor::ArrayRef<int64_t> stride, torch::executor::ArrayRef<int64_t> padding, torch::executor::ArrayRef<int64_t> dilation, bool ceil_mode, const torch::executor::Tensor & indices, torch::executor::Tensor & grad_input);
-torch::executor::Tensor & max_pool2d_with_indices_backward_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & grad_output, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> kernel_size, torch::executor::ArrayRef<int64_t> stride, torch::executor::ArrayRef<int64_t> padding, torch::executor::ArrayRef<int64_t> dilation, bool ceil_mode, const torch::executor::Tensor & indices, torch::executor::Tensor & grad_input);
-torch::executor::Tensor & mean_dim_out(const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, bool keepdim, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & mean_dim_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, bool keepdim, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & mean_dtype_out(const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & mean_dtype_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> min_out(const torch::executor::Tensor & self, int64_t dim, bool keepdim, torch::executor::Tensor & min, torch::executor::Tensor & min_indices);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> min_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, bool keepdim, torch::executor::Tensor & min, torch::executor::Tensor & min_indices);
-torch::executor::Tensor & min_unary_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & min_unary_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & minimum_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & minimum_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & mm_out(const torch::executor::Tensor & self, const torch::executor::Tensor & mat2, torch::executor::Tensor & out);
-torch::executor::Tensor & mm_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & mat2, torch::executor::Tensor & out);
-torch::executor::Tensor & mul_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & mul_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & mul_scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & mul_scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & narrow_copy_out(const torch::executor::Tensor & self, int64_t dim, int64_t start, int64_t length, torch::executor::Tensor & out);
-torch::executor::Tensor & narrow_copy_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, int64_t start, int64_t length, torch::executor::Tensor & out);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> native_dropout_out(const torch::executor::Tensor & input, double p, torch::executor::optional<bool> train, torch::executor::Tensor & out0, torch::executor::Tensor & out1);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> native_dropout_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, double p, torch::executor::optional<bool> train, torch::executor::Tensor & out0, torch::executor::Tensor & out1);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &,torch::executor::Tensor &> native_group_norm_out(const torch::executor::Tensor & input, const torch::executor::optional<torch::executor::Tensor> & weight, const torch::executor::optional<torch::executor::Tensor> & bias, int64_t N, int64_t C, int64_t HxW, int64_t group, double eps, torch::executor::Tensor & out0, torch::executor::Tensor & out1, torch::executor::Tensor & out2);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &,torch::executor::Tensor &> native_group_norm_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::optional<torch::executor::Tensor> & weight, const torch::executor::optional<torch::executor::Tensor> & bias, int64_t N, int64_t C, int64_t HxW, int64_t group, double eps, torch::executor::Tensor & out0, torch::executor::Tensor & out1, torch::executor::Tensor & out2);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &,torch::executor::Tensor &> native_layer_norm_out(const torch::executor::Tensor & input, torch::executor::ArrayRef<int64_t> normalized_shape, const torch::executor::optional<torch::executor::Tensor> & weight, const torch::executor::optional<torch::executor::Tensor> & bias, double eps, torch::executor::Tensor & out0, torch::executor::Tensor & out1, torch::executor::Tensor & out2);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &,torch::executor::Tensor &> native_layer_norm_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, torch::executor::ArrayRef<int64_t> normalized_shape, const torch::executor::optional<torch::executor::Tensor> & weight, const torch::executor::optional<torch::executor::Tensor> & bias, double eps, torch::executor::Tensor & out0, torch::executor::Tensor & out1, torch::executor::Tensor & out2);
-torch::executor::Tensor & ne_scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & ne_scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & ne_tensor_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & ne_tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & neg_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & neg_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & nonzero_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & nonzero_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & ones_out(torch::executor::ArrayRef<int64_t> size, torch::executor::Tensor & out);
-torch::executor::Tensor & ones_out(torch::executor::KernelRuntimeContext & context, torch::executor::ArrayRef<int64_t> size, torch::executor::Tensor & out);
-torch::executor::Tensor & permute_copy_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> dims, torch::executor::Tensor & out);
-torch::executor::Tensor & permute_copy_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> dims, torch::executor::Tensor & out);
-torch::executor::Tensor & pixel_shuffle_out(const torch::executor::Tensor & self, int64_t upscale_factor, torch::executor::Tensor & out);
-torch::executor::Tensor & pixel_shuffle_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t upscale_factor, torch::executor::Tensor & out);
-torch::executor::Tensor & pixel_unshuffle_out(const torch::executor::Tensor & self, int64_t downscale_factor, torch::executor::Tensor & out);
-torch::executor::Tensor & pixel_unshuffle_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t downscale_factor, torch::executor::Tensor & out);
-torch::executor::Tensor & pow_Scalar_out(const torch::executor::Scalar & self, const torch::executor::Tensor & exponent, torch::executor::Tensor & out);
-torch::executor::Tensor & pow_Scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Scalar & self, const torch::executor::Tensor & exponent, torch::executor::Tensor & out);
-torch::executor::Tensor & pow_Tensor_Scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & exponent, torch::executor::Tensor & out);
-torch::executor::Tensor & pow_Tensor_Scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & exponent, torch::executor::Tensor & out);
-torch::executor::Tensor & pow_Tensor_Tensor_out(const torch::executor::Tensor & self, const torch::executor::Tensor & exponent, torch::executor::Tensor & out);
-torch::executor::Tensor & pow_Tensor_Tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & exponent, torch::executor::Tensor & out);
-torch::executor::Tensor & prod_int_out(const torch::executor::Tensor & self, int64_t dim, bool keepdim, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & prod_int_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, bool keepdim, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & prod_out(const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & prod_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & rand_out(torch::executor::ArrayRef<int64_t> size, torch::executor::Tensor & out);
-torch::executor::Tensor & rand_out(torch::executor::KernelRuntimeContext & context, torch::executor::ArrayRef<int64_t> size, torch::executor::Tensor & out);
-torch::executor::Tensor & randn_out(torch::executor::ArrayRef<int64_t> size, torch::executor::Tensor & out);
-torch::executor::Tensor & randn_out(torch::executor::KernelRuntimeContext & context, torch::executor::ArrayRef<int64_t> size, torch::executor::Tensor & out);
-torch::executor::Tensor & reciprocal_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & reciprocal_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & relu_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & relu_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & remainder_Tensor_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & remainder_Tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & remainder_Scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & remainder_Scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
-torch::executor::Tensor & repeat_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> repeats, torch::executor::Tensor & out);
-torch::executor::Tensor & repeat_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> repeats, torch::executor::Tensor & out);
-torch::executor::Tensor & repeat_interleave_Tensor_out(const torch::executor::Tensor & repeats, torch::executor::optional<int64_t> output_size, torch::executor::Tensor & out);
-torch::executor::Tensor & repeat_interleave_Tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & repeats, torch::executor::optional<int64_t> output_size, torch::executor::Tensor & out);
-torch::executor::Tensor & reflection_pad1d_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> padding, torch::executor::Tensor & out);
-torch::executor::Tensor & reflection_pad1d_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> padding, torch::executor::Tensor & out);
-torch::executor::Tensor & reflection_pad2d_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> padding, torch::executor::Tensor & out);
-torch::executor::Tensor & reflection_pad2d_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> padding, torch::executor::Tensor & out);
-torch::executor::Tensor & reflection_pad3d_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> padding, torch::executor::Tensor & out);
-torch::executor::Tensor & reflection_pad3d_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> padding, torch::executor::Tensor & out);
-torch::executor::Tensor & replication_pad1d_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> padding, torch::executor::Tensor & out);
-torch::executor::Tensor & replication_pad1d_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> padding, torch::executor::Tensor & out);
-torch::executor::Tensor & replication_pad2d_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> padding, torch::executor::Tensor & out);
-torch::executor::Tensor & replication_pad2d_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> padding, torch::executor::Tensor & out);
-torch::executor::Tensor & replication_pad3d_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> padding, torch::executor::Tensor & out);
-torch::executor::Tensor & replication_pad3d_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> padding, torch::executor::Tensor & out);
-torch::executor::Tensor & roll_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> shifts, torch::executor::ArrayRef<int64_t> dims, torch::executor::Tensor & out);
-torch::executor::Tensor & roll_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> shifts, torch::executor::ArrayRef<int64_t> dims, torch::executor::Tensor & out);
-torch::executor::Tensor & round_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & round_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & rsqrt_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & rsqrt_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & rsub_scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out);
-torch::executor::Tensor & rsub_scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out);
-torch::executor::Tensor & scalar_tensor_out(const torch::executor::Scalar & s, torch::executor::Tensor & out);
-torch::executor::Tensor & scalar_tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Scalar & s, torch::executor::Tensor & out);
-torch::executor::Tensor & scatter_src_out(const torch::executor::Tensor & self, int64_t dim, const torch::executor::Tensor & index, const torch::executor::Tensor & src, torch::executor::Tensor & out);
-torch::executor::Tensor & scatter_src_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, const torch::executor::Tensor & index, const torch::executor::Tensor & src, torch::executor::Tensor & out);
-torch::executor::Tensor & scatter_value_out(const torch::executor::Tensor & self, int64_t dim, const torch::executor::Tensor & index, const torch::executor::Scalar & value, torch::executor::Tensor & out);
-torch::executor::Tensor & scatter_value_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, const torch::executor::Tensor & index, const torch::executor::Scalar & value, torch::executor::Tensor & out);
-torch::executor::Tensor & scatter_add_out(const torch::executor::Tensor & self, int64_t dim, const torch::executor::Tensor & index, const torch::executor::Tensor & src, torch::executor::Tensor & out);
-torch::executor::Tensor & scatter_add_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, const torch::executor::Tensor & index, const torch::executor::Tensor & src, torch::executor::Tensor & out);
-torch::executor::Tensor & select_copy_int_out(const torch::executor::Tensor & self, int64_t dim, int64_t index, torch::executor::Tensor & out);
-torch::executor::Tensor & select_copy_int_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, int64_t index, torch::executor::Tensor & out);
-torch::executor::Tensor & select_scatter_out(const torch::executor::Tensor & self, const torch::executor::Tensor & src, int64_t dim, int64_t index, torch::executor::Tensor & out);
-torch::executor::Tensor & select_scatter_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & src, int64_t dim, int64_t index, torch::executor::Tensor & out);
-torch::executor::Tensor & sigmoid_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & sigmoid_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & sign_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & sign_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & sin_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & sin_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & sinh_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & sinh_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & slice_copy_Tensor_out(const torch::executor::Tensor & self, int64_t dim, torch::executor::optional<int64_t> start, torch::executor::optional<int64_t> end, int64_t step, torch::executor::Tensor & out);
-torch::executor::Tensor & slice_copy_Tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, torch::executor::optional<int64_t> start, torch::executor::optional<int64_t> end, int64_t step, torch::executor::Tensor & out);
-torch::executor::Tensor & slice_scatter_out(const torch::executor::Tensor & self, const torch::executor::Tensor & src, int64_t dim, torch::executor::optional<int64_t> start, torch::executor::optional<int64_t> end, int64_t step, torch::executor::Tensor & out);
-torch::executor::Tensor & slice_scatter_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & src, int64_t dim, torch::executor::optional<int64_t> start, torch::executor::optional<int64_t> end, int64_t step, torch::executor::Tensor & out);
-void split_copy_Tensor_out(const torch::executor::Tensor & self, int64_t split_size, int64_t dim, torch::executor::TensorList out);
-void split_copy_Tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t split_size, int64_t dim, torch::executor::TensorList out);
-void split_with_sizes_copy_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> split_sizes, int64_t dim, torch::executor::TensorList out);
-void split_with_sizes_copy_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> split_sizes, int64_t dim, torch::executor::TensorList out);
-torch::executor::Tensor & sqrt_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & sqrt_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & squeeze_copy_dim_out(const torch::executor::Tensor & self, int64_t dim, torch::executor::Tensor & out);
-torch::executor::Tensor & squeeze_copy_dim_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, torch::executor::Tensor & out);
-torch::executor::Tensor & squeeze_copy_dims_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> dim, torch::executor::Tensor & out);
-torch::executor::Tensor & squeeze_copy_dims_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> dim, torch::executor::Tensor & out);
-torch::executor::Tensor & stack_out(torch::executor::TensorList tensors, int64_t dim, torch::executor::Tensor & out);
-torch::executor::Tensor & stack_out(torch::executor::KernelRuntimeContext & context, torch::executor::TensorList tensors, int64_t dim, torch::executor::Tensor & out);
-torch::executor::Tensor & sub_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out);
-torch::executor::Tensor & sub_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out);
-torch::executor::Tensor & sub_scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out);
-torch::executor::Tensor & sub_scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out);
-torch::executor::Tensor & sum_dim_out(const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, bool keepdim, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & sum_dim_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, bool keepdim, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & t_copy_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & t_copy_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & tan_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & tan_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & tanh_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & tanh_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> topk_values(const torch::executor::Tensor & self, int64_t k, int64_t dim, bool largest, bool sorted, torch::executor::Tensor & values, torch::executor::Tensor & indices);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> topk_values(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t k, int64_t dim, bool largest, bool sorted, torch::executor::Tensor & values, torch::executor::Tensor & indices);
-torch::executor::Tensor & transpose_copy_int_out(const torch::executor::Tensor & self, int64_t dim0, int64_t dim1, torch::executor::Tensor & out);
-torch::executor::Tensor & transpose_copy_int_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim0, int64_t dim1, torch::executor::Tensor & out);
-torch::executor::Tensor & tril_out(const torch::executor::Tensor & self, int64_t diagonal, torch::executor::Tensor & out);
-torch::executor::Tensor & tril_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t diagonal, torch::executor::Tensor & out);
-torch::executor::Tensor & trunc_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & trunc_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-void unbind_copy_int_out(const torch::executor::Tensor & self, int64_t dim, torch::executor::TensorList out);
-void unbind_copy_int_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, torch::executor::TensorList out);
-torch::executor::Tensor & unfold_copy_out(const torch::executor::Tensor & self, int64_t dimension, int64_t size, int64_t step, torch::executor::Tensor & out);
-torch::executor::Tensor & unfold_copy_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dimension, int64_t size, int64_t step, torch::executor::Tensor & out);
-torch::executor::Tensor & unsqueeze_copy_out(const torch::executor::Tensor & self, int64_t dim, torch::executor::Tensor & out);
-torch::executor::Tensor & unsqueeze_copy_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, torch::executor::Tensor & out);
-torch::executor::Tensor & upsample_bilinear2d_vec_out(const torch::executor::Tensor & input, torch::executor::optional<torch::executor::ArrayRef<int64_t>> output_size, bool align_corners, torch::executor::optional<torch::executor::ArrayRef<double>> scale_factors, torch::executor::Tensor & out);
-torch::executor::Tensor & upsample_bilinear2d_vec_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, torch::executor::optional<torch::executor::ArrayRef<int64_t>> output_size, bool align_corners, torch::executor::optional<torch::executor::ArrayRef<double>> scale_factors, torch::executor::Tensor & out);
-torch::executor::Tensor & _upsample_bilinear2d_aa_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> output_size, bool align_corners, torch::executor::optional<double> scales_h, torch::executor::optional<double> scales_w, torch::executor::Tensor & out);
-torch::executor::Tensor & _upsample_bilinear2d_aa_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> output_size, bool align_corners, torch::executor::optional<double> scales_h, torch::executor::optional<double> scales_w, torch::executor::Tensor & out);
-torch::executor::Tensor & upsample_nearest2d_vec_out(const torch::executor::Tensor & input, torch::executor::optional<torch::executor::ArrayRef<int64_t>> output_size, torch::executor::optional<torch::executor::ArrayRef<double>> scale_factors, torch::executor::Tensor & out);
-torch::executor::Tensor & upsample_nearest2d_vec_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, torch::executor::optional<torch::executor::ArrayRef<int64_t>> output_size, torch::executor::optional<torch::executor::ArrayRef<double>> scale_factors, torch::executor::Tensor & out);
-torch::executor::Tensor & var_correction_out(const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, const torch::executor::optional<torch::executor::Scalar> & correction, bool keepdim, torch::executor::Tensor & out);
-torch::executor::Tensor & var_correction_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, const torch::executor::optional<torch::executor::Scalar> & correction, bool keepdim, torch::executor::Tensor & out);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> var_mean_correction_out(const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, const torch::executor::optional<torch::executor::Scalar> & correction, bool keepdim, torch::executor::Tensor & out0, torch::executor::Tensor & out1);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> var_mean_correction_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, const torch::executor::optional<torch::executor::Scalar> & correction, bool keepdim, torch::executor::Tensor & out0, torch::executor::Tensor & out1);
-torch::executor::Tensor & var_out(const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, bool unbiased, bool keepdim, torch::executor::Tensor & out);
-torch::executor::Tensor & var_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, bool unbiased, bool keepdim, torch::executor::Tensor & out);
-torch::executor::Tensor & view_as_real_copy_out(const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & view_as_real_copy_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
-torch::executor::Tensor & view_copy_out(const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> size, torch::executor::Tensor & out);
-torch::executor::Tensor & view_copy_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> size, torch::executor::Tensor & out);
-torch::executor::Tensor & where_out(const torch::executor::Tensor & condition, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & where_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & condition, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
-torch::executor::Tensor & zeros_out(torch::executor::ArrayRef<int64_t> size, torch::executor::Tensor & out);
-torch::executor::Tensor & zeros_out(torch::executor::KernelRuntimeContext & context, torch::executor::ArrayRef<int64_t> size, torch::executor::Tensor & out);
-torch::executor::Tensor & _empty_dim_order_out(torch::executor::ArrayRef<int64_t> size, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim_order, torch::executor::Tensor & out);
-torch::executor::Tensor & _empty_dim_order_out(torch::executor::KernelRuntimeContext & context, torch::executor::ArrayRef<int64_t> size, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim_order, torch::executor::Tensor & out);
-torch::executor::Tensor & _to_dim_order_copy_out(const torch::executor::Tensor & self, bool non_blocking, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim_order, torch::executor::Tensor & out);
-torch::executor::Tensor & _to_dim_order_copy_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, bool non_blocking, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim_order, torch::executor::Tensor & out);
-torch::executor::Tensor & _clone_dim_order_out(const torch::executor::Tensor & self, bool non_blocking, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim_order, torch::executor::Tensor & out);
-torch::executor::Tensor & _clone_dim_order_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, bool non_blocking, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim_order, torch::executor::Tensor & out);
-} // namespace native
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/kernels/quantized/Functions.h b/packages/react-native-executorch/third-party/include/executorch/kernels/quantized/Functions.h
deleted file mode 100644
index 501fc5485f..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/kernels/quantized/Functions.h
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// clang-format off
-#pragma once
-
-#include <tuple>
-
-#include <executorch/runtime/core/exec_aten/exec_aten.h> // at::Tensor etc.
-#include <executorch/codegen/macros.h> // TORCH_API
-#include <executorch/runtime/kernel/kernel_runtime_context.h>
-
-// @generated by gen.py from Functions.h
-
-#include "NativeFunctions.h"
-
-namespace torch {
-namespace executor {
-
-
-namespace quantized_decomposed {
-
-// quantized_decomposed::add.out(Tensor a, float a_scale, int a_zero_point, int a_quant_min, int a_quant_max, Tensor b, float b_scale, int b_zero_point, int b_quant_min, int b_quant_max, float out_scale, int out_zero_point, int out_quant_min, int out_quant_max, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & add_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & a, double a_scale, int64_t a_zero_point, int64_t a_quant_min, int64_t a_quant_max, const torch::executor::Tensor & b, double b_scale, int64_t b_zero_point, int64_t b_quant_min, int64_t b_quant_max, double out_scale, int64_t out_zero_point, int64_t out_quant_min, int64_t out_quant_max, torch::executor::Tensor & out) {
-    return ::torch::executor::native::quantized_add_out(context, a, a_scale, a_zero_point, a_quant_min, a_quant_max, b, b_scale, b_zero_point, b_quant_min, b_quant_max, out_scale, out_zero_point, out_quant_min, out_quant_max, out);
-}
-
-
-// quantized_decomposed::choose_qparams.Tensor_out(Tensor input, int quant_min, int quant_max, float eps, ScalarType dtype, *, Tensor(a!) scale_out, Tensor(b!) zero_point_out) -> (Tensor(a!), Tensor(b!))
-TORCH_API inline ::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> choose_qparams_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, int64_t quant_min, int64_t quant_max, double eps, torch::executor::ScalarType dtype, torch::executor::Tensor & scale_out, torch::executor::Tensor & zero_point_out) {
-    return ::torch::executor::native::choose_qparams_tensor_out(context, input, quant_min, quant_max, eps, dtype, scale_out, zero_point_out);
-}
-
-
-// quantized_decomposed::dequantize_per_tensor.out(Tensor input, float scale, int zero_point, int quant_min, int quant_max, ScalarType dtype, *, ScalarType? out_dtype=None, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & dequantize_per_tensor_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, double scale, int64_t zero_point, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::optional<torch::executor::ScalarType> out_dtype, torch::executor::Tensor & out) {
-    return ::torch::executor::native::dequantize_per_tensor_out(context, input, scale, zero_point, quant_min, quant_max, dtype, out_dtype, out);
-}
-
-
-// quantized_decomposed::dequantize_per_tensor.Tensor_out(Tensor input, Tensor scale, Tensor zero_point, int quant_min, int quant_max, ScalarType dtype, *, ScalarType? out_dtype=None, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & dequantize_per_tensor_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & scale, const torch::executor::Tensor & zero_point, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::optional<torch::executor::ScalarType> out_dtype, torch::executor::Tensor & out) {
-    return ::torch::executor::native::dequantize_per_tensor_tensor_args_out(context, input, scale, zero_point, quant_min, quant_max, dtype, out_dtype, out);
-}
-
-
-// quantized_decomposed::quantize_per_channel.out(Tensor input, Tensor scales, Tensor zero_points, int axis, int quant_min, int quant_max, ScalarType dtype, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & quantize_per_channel_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & scales, const torch::executor::Tensor & zero_points, int64_t axis, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::Tensor & out) {
-    return ::torch::executor::native::quantize_per_channel_out(context, input, scales, zero_points, axis, quant_min, quant_max, dtype, out);
-}
-
-
-// quantized_decomposed::dequantize_per_channel.out(Tensor input, Tensor scales, Tensor? zero_points, int axis, int quant_min, int quant_max, ScalarType dtype, *, ScalarType? out_dtype=None, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & dequantize_per_channel_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & scales, const torch::executor::optional<torch::executor::Tensor> & zero_points, int64_t axis, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::optional<torch::executor::ScalarType> out_dtype, torch::executor::Tensor & out) {
-    return ::torch::executor::native::dequantize_per_channel_out(context, input, scales, zero_points, axis, quant_min, quant_max, dtype, out_dtype, out);
-}
-
-
-// quantized_decomposed::embedding_byte.out(Tensor weight, Tensor weight_scales, Tensor? weight_zero_points, int weight_quant_min, int weight_quant_max, Tensor indices, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & embedding_byte_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & weight, const torch::executor::Tensor & weight_scales, const torch::executor::optional<torch::executor::Tensor> & weight_zero_points, int64_t weight_quant_min, int64_t weight_quant_max, const torch::executor::Tensor & indices, torch::executor::Tensor & out) {
-    return ::torch::executor::native::quantized_embedding_byte_out(context, weight, weight_scales, weight_zero_points, weight_quant_min, weight_quant_max, indices, out);
-}
-
-
-// quantized_decomposed::embedding_byte.dtype_out(Tensor weight, Tensor weight_scales, Tensor? weight_zero_points, int weight_quant_min, int weight_quant_max, Tensor indices, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & embedding_byte_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & weight, const torch::executor::Tensor & weight_scales, const torch::executor::optional<torch::executor::Tensor> & weight_zero_points, int64_t weight_quant_min, int64_t weight_quant_max, const torch::executor::Tensor & indices, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out) {
-    return ::torch::executor::native::quantized_embedding_byte_dtype_out(context, weight, weight_scales, weight_zero_points, weight_quant_min, weight_quant_max, indices, dtype, out);
-}
-
-
-// quantized_decomposed::embedding_2bit.out(Tensor weight, Tensor weight_scales, Tensor? weight_zero_points, int weight_quant_min, int weight_quant_max, Tensor indices, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & embedding_2bit_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & weight, const torch::executor::Tensor & weight_scales, const torch::executor::optional<torch::executor::Tensor> & weight_zero_points, int64_t weight_quant_min, int64_t weight_quant_max, const torch::executor::Tensor & indices, torch::executor::Tensor & out) {
-    return ::torch::executor::native::quantized_embedding_2bit_out(context, weight, weight_scales, weight_zero_points, weight_quant_min, weight_quant_max, indices, out);
-}
-
-
-// quantized_decomposed::embedding_2bit.dtype_out(Tensor weight, Tensor weight_scales, Tensor? weight_zero_points, int weight_quant_min, int weight_quant_max, Tensor indices, ScalarType? dtype=None, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & embedding_2bit_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & weight, const torch::executor::Tensor & weight_scales, const torch::executor::optional<torch::executor::Tensor> & weight_zero_points, int64_t weight_quant_min, int64_t weight_quant_max, const torch::executor::Tensor & indices, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out) {
-    return ::torch::executor::native::quantized_embedding_2bit_dtype_out(context, weight, weight_scales, weight_zero_points, weight_quant_min, weight_quant_max, indices, dtype, out);
-}
-
-
-// quantized_decomposed::embedding_4bit.out(Tensor weight, Tensor weight_scales, Tensor? weight_zero_points, int weight_quant_min, int weight_quant_max, Tensor indices, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & embedding_4bit_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & weight, const torch::executor::Tensor & weight_scales, const torch::executor::optional<torch::executor::Tensor> & weight_zero_points, int64_t weight_quant_min, int64_t weight_quant_max, const torch::executor::Tensor & indices, torch::executor::Tensor & out) {
-    return ::torch::executor::native::quantized_embedding_4bit_out(context, weight, weight_scales, weight_zero_points, weight_quant_min, weight_quant_max, indices, out);
-}
-
-
-// quantized_decomposed::embedding_4bit.dtype_out(Tensor weight, Tensor weight_scales, Tensor? weight_zero_points, int weight_quant_min, int weight_quant_max, Tensor indices, ScalarType? dtype=None, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & embedding_4bit_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & weight, const torch::executor::Tensor & weight_scales, const torch::executor::optional<torch::executor::Tensor> & weight_zero_points, int64_t weight_quant_min, int64_t weight_quant_max, const torch::executor::Tensor & indices, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out) {
-    return ::torch::executor::native::quantized_embedding_4bit_dtype_out(context, weight, weight_scales, weight_zero_points, weight_quant_min, weight_quant_max, indices, dtype, out);
-}
-
-
-// quantized_decomposed::mixed_mm.out(Tensor input, Tensor weight, Tensor weight_scales, Tensor? weight_zero_points, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & mixed_mm_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & weight, const torch::executor::Tensor & weight_scales, const torch::executor::optional<torch::executor::Tensor> & weight_zero_points, torch::executor::Tensor & out) {
-    return ::torch::executor::native::quantized_mixed_mm_out(context, input, weight, weight_scales, weight_zero_points, out);
-}
-
-
-// quantized_decomposed::mixed_linear.out(Tensor input, Tensor weight, Tensor weight_scales, Tensor? weight_zero_points, ScalarType? dtype=None, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & mixed_linear_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & weight, const torch::executor::Tensor & weight_scales, const torch::executor::optional<torch::executor::Tensor> & weight_zero_points, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out) {
-    return ::torch::executor::native::quantized_mixed_linear_out(context, input, weight, weight_scales, weight_zero_points, dtype, out);
-}
-
-
-// quantized_decomposed::quantize_per_tensor.out(Tensor input, float scale, int zero_point, int quant_min, int quant_max, ScalarType dtype, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & quantize_per_tensor_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, double scale, int64_t zero_point, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::Tensor & out) {
-    return ::torch::executor::native::quantize_per_tensor_out(context, input, scale, zero_point, quant_min, quant_max, dtype, out);
-}
-
-
-// quantized_decomposed::quantize_per_tensor.Tensor_out(Tensor input, Tensor scale, Tensor zero_point, int quant_min, int quant_max, ScalarType dtype, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & quantize_per_tensor_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & scale, const torch::executor::Tensor & zero_point, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::Tensor & out) {
-    return ::torch::executor::native::quantize_per_tensor_tensor_args_out(context, input, scale, zero_point, quant_min, quant_max, dtype, out);
-}
-
-
-// quantized_decomposed::choose_qparams_per_token_asymmetric.out(Tensor input, ScalarType dtype, *, Tensor(a!) scale_out, Tensor(b!) zero_point_out) -> (Tensor(a!), Tensor(b!))
-TORCH_API inline ::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> choose_qparams_per_token_asymmetric_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, torch::executor::ScalarType dtype, torch::executor::Tensor & scale_out, torch::executor::Tensor & zero_point_out) {
-    return ::torch::executor::native::choose_qparams_per_token_asymmetric_out(context, input, dtype, scale_out, zero_point_out);
-}
-
-
-// quantized_decomposed::quantize_per_token.out(Tensor input, Tensor scales, Tensor zero_points, int quant_min, int quant_max, ScalarType dtype, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & quantize_per_token_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & scales, const torch::executor::Tensor & zero_points, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::Tensor & out) {
-    return ::torch::executor::native::quantize_per_token_out(context, input, scales, zero_points, quant_min, quant_max, dtype, out);
-}
-
-
-// quantized_decomposed::dequantize_per_token.out(Tensor input, Tensor scales, Tensor zero_points, int quant_min, int quant_max, ScalarType dtype, ScalarType output_dtype, *, Tensor(a!) out) -> Tensor(a!)
-TORCH_API inline torch::executor::Tensor & dequantize_per_token_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & scales, const torch::executor::Tensor & zero_points, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::ScalarType output_dtype, torch::executor::Tensor & out) {
-    return ::torch::executor::native::dequantize_per_token_out(context, input, scales, zero_points, quant_min, quant_max, dtype, output_dtype, out);
-}
-
-} // namespace quantized_decomposed
-
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/kernels/quantized/NativeFunctions.h b/packages/react-native-executorch/third-party/include/executorch/kernels/quantized/NativeFunctions.h
deleted file mode 100644
index b9f5d67b4c..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/kernels/quantized/NativeFunctions.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// clang-format off
-#pragma once
-
-#include <tuple>
-
-#include <executorch/runtime/core/exec_aten/exec_aten.h> // at::Tensor etc.
-#include <executorch/runtime/kernel/kernel_runtime_context.h>
-#include <executorch/runtime/core/error.h>
-
-// @generated by gen.py from NativeFunctions.h
-
-namespace torch {
-namespace executor {
-namespace native {
-torch::executor::Tensor & quantized_add_out(const torch::executor::Tensor & a, double a_scale, int64_t a_zero_point, int64_t a_quant_min, int64_t a_quant_max, const torch::executor::Tensor & b, double b_scale, int64_t b_zero_point, int64_t b_quant_min, int64_t b_quant_max, double out_scale, int64_t out_zero_point, int64_t out_quant_min, int64_t out_quant_max, torch::executor::Tensor & out);
-torch::executor::Tensor & quantized_add_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & a, double a_scale, int64_t a_zero_point, int64_t a_quant_min, int64_t a_quant_max, const torch::executor::Tensor & b, double b_scale, int64_t b_zero_point, int64_t b_quant_min, int64_t b_quant_max, double out_scale, int64_t out_zero_point, int64_t out_quant_min, int64_t out_quant_max, torch::executor::Tensor & out);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> choose_qparams_tensor_out(const torch::executor::Tensor & input, int64_t quant_min, int64_t quant_max, double eps, torch::executor::ScalarType dtype, torch::executor::Tensor & scale_out, torch::executor::Tensor & zero_point_out);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> choose_qparams_tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, int64_t quant_min, int64_t quant_max, double eps, torch::executor::ScalarType dtype, torch::executor::Tensor & scale_out, torch::executor::Tensor & zero_point_out);
-torch::executor::Tensor & dequantize_per_tensor_out(const torch::executor::Tensor & input, double scale, int64_t zero_point, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::optional<torch::executor::ScalarType> out_dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & dequantize_per_tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, double scale, int64_t zero_point, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::optional<torch::executor::ScalarType> out_dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & dequantize_per_tensor_tensor_args_out(const torch::executor::Tensor & input, const torch::executor::Tensor & scale, const torch::executor::Tensor & zero_point, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::optional<torch::executor::ScalarType> out_dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & dequantize_per_tensor_tensor_args_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & scale, const torch::executor::Tensor & zero_point, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::optional<torch::executor::ScalarType> out_dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & quantize_per_channel_out(const torch::executor::Tensor & input, const torch::executor::Tensor & scales, const torch::executor::Tensor & zero_points, int64_t axis, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & quantize_per_channel_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & scales, const torch::executor::Tensor & zero_points, int64_t axis, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & dequantize_per_channel_out(const torch::executor::Tensor & input, const torch::executor::Tensor & scales, const torch::executor::optional<torch::executor::Tensor> & zero_points, int64_t axis, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::optional<torch::executor::ScalarType> out_dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & dequantize_per_channel_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & scales, const torch::executor::optional<torch::executor::Tensor> & zero_points, int64_t axis, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::optional<torch::executor::ScalarType> out_dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & quantized_embedding_byte_out(const torch::executor::Tensor & weight, const torch::executor::Tensor & weight_scales, const torch::executor::optional<torch::executor::Tensor> & weight_zero_points, int64_t weight_quant_min, int64_t weight_quant_max, const torch::executor::Tensor & indices, torch::executor::Tensor & out);
-torch::executor::Tensor & quantized_embedding_byte_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & weight, const torch::executor::Tensor & weight_scales, const torch::executor::optional<torch::executor::Tensor> & weight_zero_points, int64_t weight_quant_min, int64_t weight_quant_max, const torch::executor::Tensor & indices, torch::executor::Tensor & out);
-torch::executor::Tensor & quantized_embedding_byte_dtype_out(const torch::executor::Tensor & weight, const torch::executor::Tensor & weight_scales, const torch::executor::optional<torch::executor::Tensor> & weight_zero_points, int64_t weight_quant_min, int64_t weight_quant_max, const torch::executor::Tensor & indices, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & quantized_embedding_byte_dtype_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & weight, const torch::executor::Tensor & weight_scales, const torch::executor::optional<torch::executor::Tensor> & weight_zero_points, int64_t weight_quant_min, int64_t weight_quant_max, const torch::executor::Tensor & indices, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & quantized_embedding_2bit_out(const torch::executor::Tensor & weight, const torch::executor::Tensor & weight_scales, const torch::executor::optional<torch::executor::Tensor> & weight_zero_points, int64_t weight_quant_min, int64_t weight_quant_max, const torch::executor::Tensor & indices, torch::executor::Tensor & out);
-torch::executor::Tensor & quantized_embedding_2bit_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & weight, const torch::executor::Tensor & weight_scales, const torch::executor::optional<torch::executor::Tensor> & weight_zero_points, int64_t weight_quant_min, int64_t weight_quant_max, const torch::executor::Tensor & indices, torch::executor::Tensor & out);
-torch::executor::Tensor & quantized_embedding_2bit_dtype_out(const torch::executor::Tensor & weight, const torch::executor::Tensor & weight_scales, const torch::executor::optional<torch::executor::Tensor> & weight_zero_points, int64_t weight_quant_min, int64_t weight_quant_max, const torch::executor::Tensor & indices, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & quantized_embedding_2bit_dtype_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & weight, const torch::executor::Tensor & weight_scales, const torch::executor::optional<torch::executor::Tensor> & weight_zero_points, int64_t weight_quant_min, int64_t weight_quant_max, const torch::executor::Tensor & indices, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & quantized_embedding_4bit_out(const torch::executor::Tensor & weight, const torch::executor::Tensor & weight_scales, const torch::executor::optional<torch::executor::Tensor> & weight_zero_points, int64_t weight_quant_min, int64_t weight_quant_max, const torch::executor::Tensor & indices, torch::executor::Tensor & out);
-torch::executor::Tensor & quantized_embedding_4bit_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & weight, const torch::executor::Tensor & weight_scales, const torch::executor::optional<torch::executor::Tensor> & weight_zero_points, int64_t weight_quant_min, int64_t weight_quant_max, const torch::executor::Tensor & indices, torch::executor::Tensor & out);
-torch::executor::Tensor & quantized_embedding_4bit_dtype_out(const torch::executor::Tensor & weight, const torch::executor::Tensor & weight_scales, const torch::executor::optional<torch::executor::Tensor> & weight_zero_points, int64_t weight_quant_min, int64_t weight_quant_max, const torch::executor::Tensor & indices, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & quantized_embedding_4bit_dtype_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & weight, const torch::executor::Tensor & weight_scales, const torch::executor::optional<torch::executor::Tensor> & weight_zero_points, int64_t weight_quant_min, int64_t weight_quant_max, const torch::executor::Tensor & indices, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & quantized_mixed_mm_out(const torch::executor::Tensor & input, const torch::executor::Tensor & weight, const torch::executor::Tensor & weight_scales, const torch::executor::optional<torch::executor::Tensor> & weight_zero_points, torch::executor::Tensor & out);
-torch::executor::Tensor & quantized_mixed_mm_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & weight, const torch::executor::Tensor & weight_scales, const torch::executor::optional<torch::executor::Tensor> & weight_zero_points, torch::executor::Tensor & out);
-torch::executor::Tensor & quantized_mixed_linear_out(const torch::executor::Tensor & input, const torch::executor::Tensor & weight, const torch::executor::Tensor & weight_scales, const torch::executor::optional<torch::executor::Tensor> & weight_zero_points, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & quantized_mixed_linear_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & weight, const torch::executor::Tensor & weight_scales, const torch::executor::optional<torch::executor::Tensor> & weight_zero_points, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & quantize_per_tensor_out(const torch::executor::Tensor & input, double scale, int64_t zero_point, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & quantize_per_tensor_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, double scale, int64_t zero_point, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & quantize_per_tensor_tensor_args_out(const torch::executor::Tensor & input, const torch::executor::Tensor & scale, const torch::executor::Tensor & zero_point, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & quantize_per_tensor_tensor_args_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & scale, const torch::executor::Tensor & zero_point, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::Tensor & out);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> choose_qparams_per_token_asymmetric_out(const torch::executor::Tensor & input, torch::executor::ScalarType dtype, torch::executor::Tensor & scale_out, torch::executor::Tensor & zero_point_out);
-::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> choose_qparams_per_token_asymmetric_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, torch::executor::ScalarType dtype, torch::executor::Tensor & scale_out, torch::executor::Tensor & zero_point_out);
-torch::executor::Tensor & quantize_per_token_out(const torch::executor::Tensor & input, const torch::executor::Tensor & scales, const torch::executor::Tensor & zero_points, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & quantize_per_token_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & scales, const torch::executor::Tensor & zero_points, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & dequantize_per_token_out(const torch::executor::Tensor & input, const torch::executor::Tensor & scales, const torch::executor::Tensor & zero_points, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::ScalarType output_dtype, torch::executor::Tensor & out);
-torch::executor::Tensor & dequantize_per_token_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & scales, const torch::executor::Tensor & zero_points, int64_t quant_min, int64_t quant_max, torch::executor::ScalarType dtype, torch::executor::ScalarType output_dtype, torch::executor::Tensor & out);
-} // namespace native
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/backend/backend_execution_context.h b/packages/react-native-executorch/third-party/include/executorch/runtime/backend/backend_execution_context.h
deleted file mode 100644
index b1bc222e11..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/backend/backend_execution_context.h
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <executorch/runtime/core/event_tracer.h>
-#include <executorch/runtime/core/memory_allocator.h>
-
-namespace executorch {
-namespace ET_RUNTIME_NAMESPACE {
-
-/**
- * BackendExecutionContext will be used to inject run time context.
- */
-class BackendExecutionContext final {
-public:
-  BackendExecutionContext(EventTracer *event_tracer = nullptr,
-                          MemoryAllocator *temp_allocator = nullptr,
-                          const char *method_name = nullptr)
-      : event_tracer_(event_tracer), temp_allocator_(temp_allocator),
-        method_name_(method_name) {}
-
-  /**
-   * Returns a pointer to an instance of EventTracer to do profiling/debugging
-   * logging inside the delegate backend. Users will need access to this pointer
-   * to use any of the event tracer APIs.
-   */
-  EventTracer *event_tracer() { return event_tracer_; }
-
-  /**
-   * Returns a pointer to the address allocated by temp allocator. This
-   * allocator will be reset after every delegate call during execution.
-   */
-  void *allocate(size_t size,
-                 size_t alignment = MemoryAllocator::kDefaultAlignment) {
-    // TODO(chenlai): depends on the need, we may expose more functionality for
-    // memory allocation.
-    return temp_allocator_->allocate(size, alignment);
-  }
-
-  /**
-   * Returns the temp allocator. This allocator will be reset every instruction.
-   */
-  MemoryAllocator *get_temp_allocator() { return temp_allocator_; }
-
-  /**
-   * Get the name of the executing method from the ExecuTorch runtime.
-   */
-  const char *get_method_name() const { return method_name_; }
-
-private:
-  EventTracer *event_tracer_ = nullptr;
-  MemoryAllocator *temp_allocator_ = nullptr;
-  const char *method_name_ = nullptr;
-};
-
-} // namespace ET_RUNTIME_NAMESPACE
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::ET_RUNTIME_NAMESPACE::BackendExecutionContext;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/backend/backend_init_context.h b/packages/react-native-executorch/third-party/include/executorch/runtime/backend/backend_init_context.h
deleted file mode 100644
index 37aa57b692..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/backend/backend_init_context.h
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-#include <executorch/runtime/backend/options.h>
-#include <executorch/runtime/core/error.h>
-#include <executorch/runtime/core/event_tracer.h>
-#include <executorch/runtime/core/memory_allocator.h>
-#include <executorch/runtime/core/named_data_map.h>
-#include <executorch/runtime/core/result.h>
-#include <executorch/runtime/core/span.h>
-
-#include <cstring>
-
-#ifdef __GNUC__
-// Disable -Wdeprecated-declarations, as some builds use 'Werror'.
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-namespace executorch {
-namespace ET_RUNTIME_NAMESPACE {
-/**
- * BackendInitContext will be used to inject runtime info for to initialize
- * delegate.
- */
-class BackendInitContext final {
-public:
-  explicit BackendInitContext(MemoryAllocator *runtime_allocator,
-                              EventTracer *event_tracer = nullptr,
-                              const char *method_name = nullptr,
-                              const NamedDataMap *named_data_map = nullptr,
-                              Span<const BackendOption> runtime_specs = {})
-      : runtime_allocator_(runtime_allocator),
-#ifdef ET_EVENT_TRACER_ENABLED
-        event_tracer_(event_tracer),
-#else
-        event_tracer_(nullptr),
-#endif
-        method_name_(method_name), named_data_map_(named_data_map),
-        runtime_specs_(runtime_specs) {
-  }
-
-  /** Get the runtime allocator passed from Method. It's the same runtime
-   * executor used by the standard executor runtime and the life span is the
-   * same as the model.
-   */
-  MemoryAllocator *get_runtime_allocator() { return runtime_allocator_; }
-
-  /**
-   * Returns a pointer (null if not installed) to an instance of EventTracer to
-   * do profiling/debugging logging inside the delegate backend. Users will need
-   * access to this pointer to use any of the event tracer APIs.
-   */
-  EventTracer *event_tracer() { return event_tracer_; }
-
-  /** Get the loaded method name from ExecuTorch runtime. Usually it's
-   * "forward", however, if there are multiple methods in the .pte file, it can
-   * be different. One example is that we may have prefill and decode methods in
-   * the same .pte file. In this case, when client loads "prefill" method, the
-   * `get_method_name` function will return "prefill", when client loads
-   * "decode" method, the `get_method_name` function will return "decode".
-   */
-  const char *get_method_name() const { return method_name_; }
-
-  /** Get the named data map from ExecuTorch runtime.
-   * This provides a way for backends to retrieve data blobs by key.
-   */
-  const NamedDataMap *get_named_data_map() const { return named_data_map_; }
-
-  /**
-   * Get the runtime specs (load-time options) for this backend.
-   * These are per-delegate options passed at Module::load() time.
-   *
-   * @return Span of BackendOption containing the runtime specs, or empty span
-   *         if no runtime specs were provided.
-   */
-  Span<const BackendOption> runtime_specs() const { return runtime_specs_; }
-
-  /**
-   * Get a runtime spec value by key and type.
-   *
-   * @tparam T The expected type (bool, int, or const char*)
-   * @param key The option key to look up.
-   * @return Result containing the value if found and type matches,
-   *         Error::NotFound if key doesn't exist,
-   *         Error::InvalidArgument if key exists but type doesn't match.
-   */
-  template <typename T> Result<T> get_runtime_spec(const char *key) const {
-    static_assert(
-        std::is_same_v<T, bool> || std::is_same_v<T, int> ||
-            std::is_same_v<T, const char *>,
-        "get_runtime_spec<T> only supports bool, int, and const char*");
-
-    for (size_t i = 0; i < runtime_specs_.size(); ++i) {
-      const auto &opt = runtime_specs_[i];
-      if (std::strcmp(opt.key, key) == 0) {
-        if constexpr (std::is_same_v<T, const char *>) {
-          if (auto *arr = std::get_if<std::array<char, kMaxOptionValueLength>>(
-                  &opt.value)) {
-            return arr->data();
-          }
-        } else {
-          if (auto *val = std::get_if<T>(&opt.value)) {
-            return *val;
-          }
-        }
-        return Error::InvalidArgument;
-      }
-    }
-    return Error::NotFound;
-  }
-
-private:
-  MemoryAllocator *runtime_allocator_ = nullptr;
-  EventTracer *event_tracer_ = nullptr;
-  const char *method_name_ = nullptr;
-  const NamedDataMap *named_data_map_ = nullptr;
-  Span<const BackendOption> runtime_specs_;
-};
-
-} // namespace ET_RUNTIME_NAMESPACE
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::ET_RUNTIME_NAMESPACE::BackendInitContext;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/backend/backend_option_context.h b/packages/react-native-executorch/third-party/include/executorch/runtime/backend/backend_option_context.h
deleted file mode 100644
index d254c7d8c9..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/backend/backend_option_context.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-#include <executorch/runtime/core/event_tracer.h>
-#include <executorch/runtime/core/memory_allocator.h>
-#include <executorch/runtime/core/named_data_map.h>
-
-namespace executorch {
-namespace ET_RUNTIME_NAMESPACE {
-/**
- * BackendOptionContext will be used to inject runtime info for to initialize
- * delegate.
- */
-class BackendOptionContext final {
-public:
-  explicit BackendOptionContext() {}
-};
-
-} // namespace ET_RUNTIME_NAMESPACE
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::ET_RUNTIME_NAMESPACE::BackendOptionContext;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/backend/backend_options_map.h b/packages/react-native-executorch/third-party/include/executorch/runtime/backend/backend_options_map.h
deleted file mode 100644
index 5acf6cca2d..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/backend/backend_options_map.h
+++ /dev/null
@@ -1,222 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <executorch/runtime/backend/options.h>
-#include <executorch/runtime/core/error.h>
-#include <executorch/runtime/core/span.h>
-#include <executorch/runtime/platform/assert.h>
-
-#include <cstring>
-
-namespace executorch {
-namespace runtime {
-
-/**
- * Maps backend IDs to their load-time options.
- *
- * This class is used to provide per-delegate configuration at Module::load()
- * time. Users can set options for multiple backends, and the runtime will
- * route the appropriate options to each backend during initialization.
- *
- * Example usage:
- * @code
- *   BackendOptions<4> coreml_opts;
- *   coreml_opts.set_option("compute_unit", "cpu_and_gpu");
- *
- *   LoadBackendOptionsMap map;
- *   map.set_options("CoreMLBackend", coreml_opts.view());
- *
- *   // Later, during backend init:
- *   auto opts = map.get_options("CoreMLBackend");
- * @endcode
- *
- * Note: This class does NOT take ownership of the option spans. The caller
- * must ensure that the BackendOptions objects outlive the LoadBackendOptionsMap
- * and any loaded models that use it.
- */
-class LoadBackendOptionsMap final {
-public:
-  /**
-   * Default constructor - creates an empty map.
-   */
-  LoadBackendOptionsMap() : size_(0) {
-    for (size_t i = 0; i < kMaxBackends; ++i) {
-      entries_[i].backend_id[0] = '\0';
-    }
-  }
-
-  /**
-   * Sets options for a specific backend.
-   *
-   * If options for the given backend_id already exist, they will be replaced.
-   *
-   * @param backend_id The backend identifier (e.g., "CoreMLBackend",
-   * "XNNPACKBackend"). Must not be null or empty.
-   * @param options Span of BackendOption to associate with this backend.
-   *                The span's underlying data must outlive this map and any
-   *                models loaded with it.
-   * @return Error::Ok on success.
-   *         Error::InvalidArgument if backend_id is null/empty or max backends
-   * exceeded.
-   */
-  Error set_options(const char *backend_id, Span<BackendOption> options) {
-    if (backend_id == nullptr || backend_id[0] == '\0') {
-      return Error::InvalidArgument;
-    }
-
-    return set_options_impl(backend_id, options);
-  }
-
-  /**
-   * Sets options from a backend options builder.
-   *
-   * This convenience overload accepts any builder type that provides
-   * backend_id() and view() methods, allowing simpler usage:
-   *
-   * @code
-   *   ExampleBackendOptions opts;
-   *   opts.setNumThreads(4).setEnableOptimization(true);
-   *   map.set_options(opts);
-   * @endcode
-   *
-   * @param builder A backend options builder with backend_id() and view()
-   * methods.
-   * @return Error::Ok on success, Error::InvalidArgument on failure.
-   */
-  template <typename Builder> Error set_options(Builder &builder) {
-    return set_options_impl(builder.backend_id(), builder.view());
-  }
-
-private:
-  Error set_options_impl(const char *backend_id, Span<BackendOption> options) {
-    // Check if backend already exists and update it
-    for (size_t i = 0; i < size_; ++i) {
-      if (std::strcmp(entries_[i].backend_id, backend_id) == 0) {
-        entries_[i].options = options;
-        return Error::Ok;
-      }
-    }
-
-    // Add new entry if space available
-    if (size_ >= kMaxBackends) {
-      return Error::InvalidArgument;
-    }
-
-    const size_t id_len = std::strlen(backend_id);
-    if (id_len >= kMaxBackendIdLength) {
-      return Error::InvalidArgument;
-    }
-    std::memcpy(entries_[size_].backend_id, backend_id, id_len);
-    entries_[size_].backend_id[id_len] = '\0';
-    entries_[size_].options = options;
-    ++size_;
-
-    return Error::Ok;
-  }
-
-public:
-  /**
-   * Gets options for a specific backend.
-   *
-   * @param backend_id The backend identifier to look up.
-   * @return Span of options for this backend, or an empty span if the backend
-   *         has no options configured or backend_id is null.
-   */
-  Span<const BackendOption> get_options(const char *backend_id) const {
-    if (backend_id == nullptr) {
-      return Span<const BackendOption>(nullptr, static_cast<size_t>(0));
-    }
-
-    for (size_t i = 0; i < size_; ++i) {
-      if (std::strcmp(entries_[i].backend_id, backend_id) == 0) {
-        return Span<const BackendOption>(entries_[i].options.data(),
-                                         entries_[i].options.size());
-      }
-    }
-
-    return Span<const BackendOption>(nullptr, static_cast<size_t>(0));
-  }
-
-  /**
-   * Checks if options have been configured for a specific backend.
-   *
-   * @param backend_id The backend identifier to check.
-   * @return true if options are set for this backend, false otherwise.
-   */
-  bool has_options(const char *backend_id) const {
-    if (backend_id == nullptr) {
-      return false;
-    }
-
-    for (size_t i = 0; i < size_; ++i) {
-      if (std::strcmp(entries_[i].backend_id, backend_id) == 0) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  /**
-   * Returns the number of backends with configured options.
-   */
-  size_t size() const { return size_; }
-
-  /**
-   * Non-owning view of a single (backend_id, options) entry, returned by
-   * entry_at(). The pointer / span are valid until the map is mutated or
-   * destroyed.
-   */
-  struct EntryView {
-    const char *backend_id = nullptr;
-    Span<const BackendOption> options;
-  };
-
-  /**
-   * Returns the (backend_id, options) entry at the given index for
-   * enumeration over the map's contents.
-   *
-   * @param index The entry index. Must be < size(); behavior is undefined
-   *     otherwise. Use this together with size() to walk every entry.
-   * @return EntryView referencing the entry's backend_id and options. The
-   *     view is valid until the next mutation of, or destruction of, this
-   *     map.
-   *
-   * Example:
-   * @code
-   *   for (size_t i = 0; i < map.size(); ++i) {
-   *     const auto entry = map.entry_at(i);
-   *     // use entry.backend_id and entry.options ...
-   *   }
-   * @endcode
-   */
-  EntryView entry_at(size_t index) const {
-    ET_DCHECK_MSG(index < size_, "entry_at index %zu out of bounds (size=%zu)",
-                  index, size_);
-    return EntryView{entries_[index].backend_id,
-                     Span<const BackendOption>(entries_[index].options.data(),
-                                               entries_[index].options.size())};
-  }
-
-private:
-  static constexpr size_t kMaxBackends = 8;
-  static constexpr size_t kMaxBackendIdLength = 64;
-
-  struct Entry {
-    char backend_id[kMaxBackendIdLength];
-    Span<BackendOption> options;
-  };
-
-  Entry entries_[kMaxBackends];
-  size_t size_;
-};
-
-} // namespace runtime
-} // namespace executorch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/backend/interface.h b/packages/react-native-executorch/third-party/include/executorch/runtime/backend/interface.h
deleted file mode 100644
index 735e98de6d..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/backend/interface.h
+++ /dev/null
@@ -1,227 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <cstring>
-
-#include <executorch/runtime/backend/backend_execution_context.h>
-#include <executorch/runtime/backend/backend_init_context.h>
-#include <executorch/runtime/backend/backend_option_context.h>
-#include <executorch/runtime/backend/options.h>
-#include <executorch/runtime/core/array_ref.h>
-#include <executorch/runtime/core/error.h>
-#include <executorch/runtime/core/evalue.h>
-#include <executorch/runtime/core/freeable_buffer.h>
-#include <executorch/runtime/core/memory_allocator.h>
-#include <executorch/runtime/core/named_data_map.h>
-#include <executorch/runtime/core/result.h>
-#include <executorch/runtime/platform/compiler.h>
-
-namespace executorch {
-namespace ET_RUNTIME_NAMESPACE {
-
-struct SizedBuffer {
-  void *buffer;
-  size_t nbytes; // number of bytes of buffer
-};
-
-struct CompileSpec {
-  const char *key;   // spec key
-  SizedBuffer value; // spec value
-};
-
-/**
- * An opaque handle managed by a backend. Typically points to a backend-private
- * class/struct.
- */
-using DelegateHandle = void;
-
-class BackendInterface {
-public:
-  virtual ~BackendInterface() = 0;
-
-  /**
-   * Returns true if the backend is available to process delegation calls.
-   */
-  ET_NODISCARD virtual bool is_available() const = 0;
-
-  /**
-   * Responsible to further process (compile/transform/optimize) the compiled
-   * unit that was produced, ahead-of-time, as well as perform any backend
-   * initialization to ready it for execution. This method is called every time
-   * the ExecuTorch program is initialized. Consequently, this is the place to
-   * perform any backend initialization as well as transformations,
-   * optimizations, and even compilation that depend on the target device. As
-   * such, it is strongly encouraged to push as much processing as possible to
-   * the ahead-of-time processing.
-   *
-   * @param[in] processed An opaque (to ExecuTorch) backend-specific compiled
-   *     unit from the preprocessor. Can contain anything the backend needs to
-   *     execute the equivalent semantics of the passed-in Module and its
-   *     method. Often passed unmodified to `execute()` as a `DelegateHandle`,
-   *     unless it needs further processing at init time to be fully executable.
-   *     If the data is not needed after init(), calling processed->Free() can
-   *     reclaim its memory.
-   * @param[in] compile_specs The exact same compiler specification that
-   *     was used ahead-of-time to produce `processed`.
-   *
-   * @returns On success, an opaque handle representing the the method
-   *     implemented by the delegate. This handle is passed to `execute()` and
-   *     `destroy()`, and the memory it points to is owned by the backend.
-   *     Typically points to a backend-private class/struct.
-   * @returns On error, returns an error code other than Error::Ok. If the
-   *     compiled unit (the preprocessed result from ahead of time) is not
-   *     compatible with the current backend runtime, return the error code
-   *     Error::DelegateInvalidCompatibility. Other backend delegate
-   *     specific error codes can be found in error.h.
-   */
-  ET_NODISCARD virtual Result<DelegateHandle *>
-  init(BackendInitContext &context, FreeableBuffer *processed,
-       ArrayRef<CompileSpec> compile_specs) const = 0;
-
-  /**
-   * Responsible for executing the given method’s handle, as it was produced
-   * by compile.
-   *
-   * @param[in] handle An opaque handle returned by `init()`. Usually a backend
-   *     executable unit. This executable unit should be ready to execute the
-   *     delegate blobs.
-   * @param[in] args The method’s inputs and outputs.
-   * @retval Error::Ok if successful.
-   */
-  ET_NODISCARD virtual Error execute(BackendExecutionContext &context,
-                                     DelegateHandle *handle,
-                                     Span<EValue *> args) const = 0;
-
-  /**
-   * Responsible update the backend status, if any. The backend options are
-   * passed in by users, and the backend can update its internal status based on
-   * the options.
-   *
-   * @param[in] context Runtime context if any. Currently it's not used.
-   * @param[in] args A list of BackendOptions passed in by users.
-   * @retval Error::Ok if successful.
-   */
-  ET_NODISCARD virtual Error
-  set_option(__ET_UNUSED BackendOptionContext &context,
-             const executorch::runtime::Span<BackendOption> &backend_options) {
-    return Error::Ok;
-  };
-
-  /**
-   * Responsible update the backend status, if any. The backend options are
-   * passed in by users, and the backend can update its internal status based on
-   * the options.
-   *
-   * @param[in] context Runtime context if any. Currently it's not used.
-   * @param[in] args A list of BackendOptions passed in by users, that will be
-   * filled by the backend
-   * @retval Error::Ok if successful.
-   */
-  ET_NODISCARD virtual Error
-  get_option(__ET_UNUSED BackendOptionContext &context,
-             executorch::runtime::Span<BackendOption> &backend_options) {
-    return Error::Ok;
-  };
-
-  /**
-   * Responsible for destroying a handle, if it's required for some backend.
-   * It may be needed for some backends. For example, resources associated with
-   * this handle needs to be released. This method is called when the execution
-   * plan is destroyed (i.e., the program is out of its lifespan).
-   *
-   * @param[in] handle The handle to be destroyed. An opaque handle returned by
-   *     `init()`.
-   */
-  virtual void destroy(ET_UNUSED DelegateHandle *handle) const {}
-};
-
-/**
- * Returns the corresponding object pointer for a given string name.
- * The mapping is populated using register_backend method.
- *
- * @param[in] name Name of the user-defined backend delegate.
- * @retval Pointer to the appropriate object that implements BackendInterface.
- *         Nullptr if it can't find anything with the given name.
- */
-BackendInterface *get_backend_class(const char *name);
-
-/**
- * A named instance of a backend.
- */
-struct Backend {
-  /// The name of the backend. Must match the string used in the PTE file.
-  const char *name;
-  /// The instance of the backend to use when loading and executing programs.
-  BackendInterface *backend;
-};
-
-/**
- * Registers the Backend object (i.e. string name and BackendInterface pair) so
- * that it could be called via the name during the runtime.
- *
- * @param[in] backend Backend object
- * @retval Error code representing whether registration was successful.
- */
-ET_NODISCARD Error register_backend(const Backend &backend);
-
-/**
- * Returns the number of registered backends.
- */
-size_t get_num_registered_backends();
-
-/**
- * Returns the backend name at the given index.
- */
-Result<const char *> get_backend_name(size_t index);
-
-/**
- * Sets backend options for a specific backend.
- *
- * @param backend_name The name of the backend to set options for
- * @param backend_options The backend option list containing the options
- * to set
- * @return Error::Ok on success, Error::NotFound if backend is not found, or
- * other error codes on failure
- */
-Error set_option(
-    const char *backend_name,
-    const executorch::runtime::Span<executorch::runtime::BackendOption>
-        backend_options);
-
-/**
- * Retrieves backend options for a specific backend.
- *
- * @param backend_name The name of the backend to get options from
- * @param backend_options The backend option objects that will be filled with
- * the populated values from the backend
- * @return Error::Ok on success, Error::NotFound if backend is not found, or
- * other error codes on failure
- */
-Error get_option(const char *backend_name,
-                 executorch::runtime::Span<executorch::runtime::BackendOption>
-                     backend_options);
-
-} // namespace ET_RUNTIME_NAMESPACE
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::ET_RUNTIME_NAMESPACE::Backend;
-using ::executorch::ET_RUNTIME_NAMESPACE::CompileSpec;
-using ::executorch::ET_RUNTIME_NAMESPACE::DelegateHandle;
-using ::executorch::ET_RUNTIME_NAMESPACE::get_backend_class;
-using ::executorch::ET_RUNTIME_NAMESPACE::register_backend;
-using ::executorch::ET_RUNTIME_NAMESPACE::SizedBuffer;
-using PyTorchBackendInterface =
-    ::executorch::ET_RUNTIME_NAMESPACE::BackendInterface;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/backend/options.h b/packages/react-native-executorch/third-party/include/executorch/runtime/backend/options.h
deleted file mode 100644
index d3c1f47e28..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/backend/options.h
+++ /dev/null
@@ -1,206 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-#include <array>
-#include <cstddef>
-#include <cstring>
-#include <executorch/runtime/core/error.h>
-#include <executorch/runtime/core/span.h>
-#include <variant>
-
-namespace executorch {
-namespace runtime {
-
-static constexpr size_t kMaxOptionKeyLength = 64;
-static constexpr size_t kMaxOptionValueLength = 256;
-
-// All string keys and values must have static storage duration (string
-// literals, static const char arrays, or global constants). The BackendOptions
-// class does NOT take ownership of strings.
-using OptionValue =
-    std::variant<bool, int, std::array<char, kMaxOptionValueLength>>;
-
-struct BackendOption {
-  // key is the name of the backend option, like num_threads, enable_profiling,
-  // etc
-  char key[kMaxOptionKeyLength]{};
-  // value is the value of the backend option, like 4, true, etc
-  OptionValue value;
-};
-
-/**
- * A template class for storing and managing backend-specific configuration
- * options.
- *
- * This class provides a type-safe way to store key-value pairs for backend
- * configuration, with compile-time capacity limits and runtime type checking.
- * It supports bool, int, and const char* value types.
- *
- * @tparam MaxCapacity The maximum number of options that can be stored
- */
-template <size_t MaxCapacity> class BackendOptions {
-public:
-  /**
-   * Copy constructor
-   */
-  BackendOptions(const BackendOptions &other) : size_(other.size_) {
-    for (size_t i = 0; i < size_; ++i) {
-      options_[i] = other.options_[i];
-    }
-  }
-
-  /**
-   * Copy assignment operator
-   */
-  BackendOptions &operator=(const BackendOptions &other) {
-    if (this != &other) {
-      size_ = other.size_;
-      for (size_t i = 0; i < size_; ++i) {
-        options_[i] = other.options_[i];
-      }
-    }
-    return *this;
-  }
-
-  /**
-   * Default constructor - initializes with zero options.
-   */
-  BackendOptions() : size_(0) {}
-
-  /**
-   * Returns a mutable view of all stored options as a Span.
-   *
-   * @return A mutable Span containing all BackendOption entries
-   */
-  executorch::runtime::Span<BackendOption> view() {
-    return executorch::runtime::Span<BackendOption>(options_, size_);
-  }
-
-  /**
-   * Sets a boolean option value for the given key.
-   * If the key already exists, updates its value. Otherwise, adds a new option.
-   *
-   * @tparam N The length of the key string (automatically deduced)
-   * @param key The option key (must be a string literal or array)
-   * @param value The boolean value to set
-   * @return Error::Ok on success, Error::InvalidArgument if storage is full
-   */
-  template <size_t N>
-  Error set_option(const char (&key)[N], bool value) noexcept {
-    static_assert(N <= kMaxOptionKeyLength, "Option key is too long");
-    return set_option_impl(key, value);
-  }
-
-  /**
-   * Sets an integer option value for the given key.
-   * If the key already exists, updates its value. Otherwise, adds a new option.
-   *
-   * @tparam N The length of the key string (automatically deduced)
-   * @param key The option key (must be a string literal or array)
-   * @param value The integer value to set
-   * @return Error::Ok on success, Error::InvalidArgument if storage is full
-   */
-  template <size_t N>
-  Error set_option(const char (&key)[N], int value) noexcept {
-    static_assert(N <= kMaxOptionKeyLength, "Option key is too long");
-    return set_option_impl(key, value);
-  }
-
-  /**
-   * Sets a string option value for the given key.
-   * If the key already exists, updates its value. Otherwise, adds a new option.
-   *
-   * Note: The string value must have static storage duration. This class does
-   * NOT take ownership of the string - it only stores the pointer.
-   *
-   * @tparam N The length of the key string (automatically deduced)
-   * @param key The option key (must be a string literal or array)
-   * @param value The string value to set (must have static storage duration)
-   * @return Error::Ok on success, Error::InvalidArgument if storage is full
-   */
-  template <size_t N>
-  Error set_option(const char (&key)[N], const char *value) noexcept {
-    static_assert(N <= kMaxOptionKeyLength, "Option key is too long");
-    // Create a fixed-size array and copy the string
-    std::array<char, kMaxOptionValueLength> arr{};
-    strncpy(arr.data(), value, kMaxOptionValueLength - 1);
-    arr[kMaxOptionValueLength - 1] = '\0'; // Ensure null termination
-    return set_option_impl(key, arr);
-  }
-  /**
-   * Retrieves an option value by key and type.
-   *
-   * @tparam T The expected type of the option value (bool, int, or const char*)
-   * @tparam KeyLen The length of the key string (automatically deduced)
-   * @param key The option key to look up
-   * @param out Reference to store the retrieved value
-   * @return Error::Ok if found and type matches, Error::NotFound if key doesn't
-   * exist, Error::InvalidArgument if type doesn't match
-   */
-  template <typename T, size_t KeyLen>
-  Error get_option(const char (&key)[KeyLen], T &out) const {
-    static_assert(KeyLen <= kMaxOptionKeyLength, "Option key is too long");
-    for (size_t i = 0; i < size_; ++i) {
-      if (std::strcmp(options_[i].key, key) == 0) {
-        // Special handling for string (convert array to const char*)
-        if constexpr (std::is_same_v<T, const char *>) {
-          if (auto *arr = std::get_if<std::array<char, kMaxOptionValueLength>>(
-                  &options_[i].value)) {
-            out = arr->data(); // Return pointer to stored array
-            return Error::Ok;
-          }
-        }
-        // Default handling for bool/int
-        else if (auto *val = std::get_if<T>(&options_[i].value)) {
-          out = *val;
-          return Error::Ok;
-        }
-        return Error::InvalidArgument;
-      }
-    }
-    return Error::NotFound;
-  }
-
-private:
-  BackendOption options_[MaxCapacity]{}; // Storage for backend options
-  size_t size_;                          // Current number of options
-
-  /**
-   * Internal implementation for setting option values.
-   * Handles both updating existing options and adding new ones.
-   *
-   * @tparam T The type of the value (bool, int, or const char*)
-   * @param key The option key
-   * @param value The value to set
-   * @return Error::Ok on success, Error::InvalidArgument if storage is full
-   */
-  template <typename T> Error set_option_impl(const char *key, T value) {
-    // Update existing if found
-    for (size_t i = 0; i < size_; ++i) {
-      if (strcmp(options_[i].key, key) == 0) {
-        options_[i].value = value;
-        return Error::Ok;
-      }
-    }
-    if (size_ < MaxCapacity) {
-      BackendOption new_option;
-      const size_t key_len = std::strlen(key);
-      const size_t copy_len = std::min(key_len, kMaxOptionKeyLength - 1);
-      std::memcpy(new_option.key, key, copy_len);
-      new_option.key[copy_len] = '\0';
-      new_option.value = value;       // Restored value assignment
-      options_[size_++] = new_option; // Store option and increment size
-      return Error::Ok;
-    }
-    return Error::InvalidArgument;
-  }
-};
-
-} // namespace runtime
-} // namespace executorch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/array_ref.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/array_ref.h
deleted file mode 100644
index 867520137f..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/array_ref.h
+++ /dev/null
@@ -1,237 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-//===--- ArrayRef.h - Array Reference Wrapper -------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// removed llvm-specific functionality
-// removed some implicit const -> non-const conversions that rely on
-// complicated std::enable_if meta-programming
-// removed a bunch of slice variants for simplicity...
-// remove constructors and operators for std::vector
-// removed some prevention of accidental assignments from temporary that
-// required std::enable_if meta-programming
-// removed reverse iterator
-
-#pragma once
-
-#include <array>
-#include <cstdint>
-
-#include <c10/util/irange.h>
-#include <c10/util/safe_numerics.h>
-#include <executorch/runtime/platform/assert.h>
-
-namespace executorch {
-namespace runtime {
-
-/**
- * Represents a constant reference to an array (0 or more elements
- * consecutively in memory), i.e. a start pointer and a length.  It allows
- * various APIs to take consecutive elements easily and conveniently.
- *
- * This class does not own the underlying data, it is expected to be used in
- * situations where the data resides in some other buffer, whose lifetime
- * extends past that of the ArrayRef. For this reason, it is not in general
- * safe to store an ArrayRef.
- *
- * Span and ArrayRef are extrememly similar with the difference being ArrayRef
- * views a list of constant elements and Span views a list of mutable elements.
- * Clients should decide between the two based on if the list elements for their
- * use case should be mutable.
- *
- * This is intended to be trivially copyable, so it should be passed by
- * value.
- */
-template <typename T> class ArrayRef final {
-public:
-  using iterator = const T *;
-  using const_iterator = const T *;
-  using size_type = size_t;
-  using value_type = T;
-
-private:
-  /// The start of the array, in an external buffer.
-  const T *Data;
-
-  /// The number of elements.
-  size_type Length;
-
-public:
-  /// @name Constructors
-  /// @{
-
-  /// Construct an empty ArrayRef.
-  /* implicit */ constexpr ArrayRef() : Data(nullptr), Length(0) {}
-
-  /// Construct a ArrayRef from a single element. Implicitly convert element
-  /// type. It is aligned with PyTorch's c10::ArrayRef.
-  /* implicit */ constexpr ArrayRef(const T &OneElt)
-      : Data(&OneElt), Length(1) {}
-
-  /// Construct a ArrayRef from a pointer and length.
-  ArrayRef(const T *data, size_t length) : Data(data), Length(length) {
-    ET_DCHECK(Data != nullptr || Length == 0);
-  }
-
-  /// Construct a ArrayRef from a range.
-  ArrayRef(const T *begin, const T *end) : Data(begin), Length(end - begin) {}
-
-  /// Construct an ArrayRef from a std::array
-  template <size_t N>
-  /* implicit */ constexpr ArrayRef(const std::array<T, N> &Arr)
-      : Data(Arr.data()), Length(N) {}
-
-  /// Construct a ArrayRef from a C array.
-  template <size_t N>
-  /* implicit */ constexpr ArrayRef(const T (&Arr)[N]) : Data(Arr), Length(N) {}
-
-  /// @}
-  /// @name Simple Operations
-  /// @{
-
-  constexpr iterator begin() const { return Data; }
-  constexpr iterator end() const { return Data + Length; }
-
-  // These are actually the same as iterator, since ArrayRef only
-  // gives you const iterators.
-  constexpr const_iterator cbegin() const { return Data; }
-  constexpr const_iterator cend() const { return Data + Length; }
-
-  /// empty - Check if the array is empty.
-  constexpr bool empty() const { return Length == 0; }
-
-  constexpr const T *data() const { return Data; }
-
-  /// size - Get the array size.
-  constexpr size_t size() const { return Length; }
-
-  /// front - Get the first element.
-  const T &front() const {
-    // ArrayRef: attempted to access front() of empty list
-    ET_CHECK(!empty());
-    return Data[0];
-  }
-
-  /// back - Get the last element.
-  const T &back() const {
-    // ArrayRef: attempted to access back() of empty list
-    ET_CHECK(!empty());
-    return Data[Length - 1];
-  }
-
-  /// equals - Check for element-wise equality.
-  bool equals(ArrayRef RHS) const {
-    if (Length != RHS.Length) {
-      return false;
-    }
-    for (const auto i : c10::irange(this->Length)) {
-      if (Data[i] != RHS.Data[i]) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  /// slice(n, m) - Take M elements of the array starting at element N
-  ArrayRef<T> slice(size_t N, size_t M) const {
-    // cant slice longer then the array
-    size_t end = 0;
-    ET_CHECK(!c10::add_overflows(N, M, &end) && end <= size());
-    return ArrayRef<T>(data() + N, M);
-  }
-
-  /// slice(n) - Chop off the first N elements of the array.
-  constexpr ArrayRef<T> slice(size_t N) const { return slice(N, size() - N); }
-
-  /// @}
-  /// @name Operator Overloads
-  /// @{
-  constexpr const T &operator[](size_t Index) const { return Data[Index]; }
-
-  /// Vector compatibility
-  const T &at(size_t Index) const {
-    // invalid index
-    ET_CHECK(Index < Length);
-    return Data[Index];
-  }
-
-  /// @}
-};
-
-/// @name ArrayRef Convenience constructors
-/// @{
-
-/// Construct an ArrayRef from a single element.
-template <typename T> ArrayRef<T> makeArrayRef(const T &OneElt) {
-  return OneElt;
-}
-
-/// Construct an ArrayRef from a pointer and length.
-template <typename T> ArrayRef<T> makeArrayRef(const T *data, size_t length) {
-  return ArrayRef<T>(data, length);
-}
-
-/// Construct an ArrayRef from a range.
-template <typename T> ArrayRef<T> makeArrayRef(const T *begin, const T *end) {
-  return ArrayRef<T>(begin, end);
-}
-
-/// Construct an ArrayRef from a std::array.
-template <typename T, std::size_t N>
-ArrayRef<T> makeArrayRef(const std::array<T, N> &Arr) {
-  return Arr;
-}
-
-/// Construct an ArrayRef from an ArrayRef (no-op) (const)
-template <typename T> ArrayRef<T> makeArrayRef(const ArrayRef<T> &Vec) {
-  return Vec;
-}
-
-/// Construct an ArrayRef from an ArrayRef (no-op)
-template <typename T> ArrayRef<T> &makeArrayRef(ArrayRef<T> &Vec) {
-  return Vec;
-}
-
-/// Construct an ArrayRef from a C array.
-template <typename T, size_t N> ArrayRef<T> makeArrayRef(const T (&Arr)[N]) {
-  return ArrayRef<T>(Arr);
-}
-
-// WARNING: Template instantiation will NOT be willing to do an implicit
-// conversions to get you to an ArrayRef, which is why we need so
-// many overloads.
-
-template <typename T> bool operator==(ArrayRef<T> a1, ArrayRef<T> a2) {
-  return a1.equals(a2);
-}
-
-template <typename T> bool operator!=(ArrayRef<T> a1, ArrayRef<T> a2) {
-  return !a1.equals(a2);
-}
-
-using IntArrayRef = ArrayRef<int64_t>;
-
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::ArrayRef;
-using ::executorch::runtime::IntArrayRef;
-using ::executorch::runtime::makeArrayRef;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/data_loader.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/data_loader.h
deleted file mode 100644
index 01fc4caca2..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/data_loader.h
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <cstddef>
-
-#include <executorch/runtime/core/freeable_buffer.h>
-#include <executorch/runtime/core/result.h>
-#include <executorch/runtime/platform/compiler.h>
-
-namespace executorch {
-namespace runtime {
-
-/**
- * Loads from a data source.
- *
- * See //executorch/extension/data_loader for common implementations.
- */
-class DataLoader {
-public:
-  /**
-   * Describes the content of the segment.
-   */
-  struct SegmentInfo {
-    /**
-     * Represents the purpose of the segment.
-     */
-    enum class Type {
-      /**
-       * Data for the actual program.
-       */
-      Program,
-      /**
-       * Holds constant tensor data.
-       */
-      Constant,
-      /**
-       * Data used for initializing a backend.
-       */
-      Backend,
-      /**
-       * Data used for initializing mutable tensors.
-       */
-      Mutable,
-      /**
-       * Data used for initializing external tensors.
-       */
-      External,
-    };
-
-    /// Type of the segment.
-    Type segment_type;
-
-    /// Index of the segment within the segment list. Undefined for program
-    /// segments.
-    size_t segment_index;
-
-    /// An optional, null-terminated string describing the segment. For
-    /// `Backend` segments, this is the backend ID. Null for other segment
-    /// types.
-    const char *descriptor;
-
-    SegmentInfo() = default;
-
-    explicit SegmentInfo(Type segment_type_, size_t segment_index_ = 0,
-                         const char *descriptor_ = nullptr)
-        : segment_type(segment_type_), segment_index(segment_index_),
-          descriptor(descriptor_) {}
-  };
-
-  virtual ~DataLoader() = default;
-
-  /**
-   * Loads data from the underlying data source.
-   *
-   * NOTE: This must be thread-safe. If this call modifies common state, the
-   * implementation must do its own locking.
-   *
-   * @param offset The byte offset in the data source to start loading from.
-   * @param size The number of bytes to load.
-   * @param segment_info Information about the segment being loaded.
-   *
-   * @returns a `FreeableBuffer` that owns the loaded data.
-   */
-  ET_NODISCARD virtual Result<FreeableBuffer>
-  load(size_t offset, size_t size, const SegmentInfo &segment_info) const = 0;
-
-  /**
-   * Loads data from the underlying data source into the provided buffer.
-   *
-   * NOTE: This must be thread-safe. If this call modifies common state, the
-   * implementation must do its own locking.
-   *
-   * @param offset The byte offset in the data source to start loading from.
-   * @param size The number of bytes to load.
-   * @param segment_info Information about the segment being loaded.
-   * @param buffer The buffer to load data into. Must point to at least `size`
-   * bytes of memory.
-   *
-   * @returns an Error indicating if the load was successful.
-   */
-  ET_NODISCARD virtual Error load_into(size_t offset, size_t size,
-                                       const SegmentInfo &segment_info,
-                                       void *buffer) const {
-    // Using a stub implementation here instead of pure virtual to expand the
-    // data_loader interface in a backwards compatible way.
-    (void)buffer;
-    (void)offset;
-    (void)size;
-    (void)segment_info;
-    ET_LOG(Error, "load_into() not implemented for this data loader.");
-    return Error::NotImplemented;
-  }
-
-  /**
-   * Returns the length of the underlying data source, typically the file size.
-   */
-  ET_NODISCARD virtual Result<size_t> size() const = 0;
-};
-
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::DataLoader;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/defines.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/defines.h
deleted file mode 100644
index ee47126826..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/defines.h
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @file
- * Contains preprocessor definitions used by ExecuTorch core.
- */
-
-#pragma once
-
-// Enable ET_ENABLE_ENUM_STRINGS by default. This option gates inclusion of
-// enum string names and can be disabled by explicitly setting it to 0.
-#ifndef ET_ENABLE_ENUM_STRINGS
-#define ET_ENABLE_ENUM_STRINGS 1
-#endif
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/error.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/error.h
deleted file mode 100644
index c107dd43db..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/error.h
+++ /dev/null
@@ -1,262 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @file
- * ExecuTorch Error declarations.
- */
-
-#pragma once
-
-#include <stdint.h>
-
-#include <executorch/runtime/platform/log.h>
-
-namespace executorch {
-namespace runtime {
-
-// Alias error code integral type to minimal platform width (32-bits for now).
-typedef uint32_t error_code_t;
-
-/**
- * ExecuTorch Error type.
- */
-enum class Error : error_code_t {
-  /*
-   * System errors.
-   */
-
-  /// Status indicating a successful operation.
-  Ok = 0x00,
-
-  /// An internal error occurred.
-  Internal = 0x01,
-
-  /// Status indicating the executor is in an invalid state for a target
-  /// operation
-  InvalidState = 0x2,
-
-  /// Status indicating there are no more steps of execution to run
-  EndOfMethod = 0x03,
-
-  /// Status indicating a resource has already been loaded.
-  AlreadyLoaded = 0x04,
-
-  /*
-   * Logical errors.
-   */
-
-  /// Operation is not supported in the current context.
-  NotSupported = 0x10,
-
-  /// Operation is not yet implemented.
-  NotImplemented = 0x11,
-
-  /// User provided an invalid argument.
-  InvalidArgument = 0x12,
-
-  /// Object is an invalid type for the operation.
-  InvalidType = 0x13,
-
-  /// Operator(s) missing in the operator registry.
-  OperatorMissing = 0x14,
-
-  /// Registration error: Exceeding the maximum number of kernels.
-  RegistrationExceedingMaxKernels = 0x15,
-
-  /// Registration error: The kernel is already registered.
-  RegistrationAlreadyRegistered = 0x16,
-
-  /*
-   * Resource errors.
-   */
-
-  /// Requested resource could not be found.
-  NotFound = 0x20,
-
-  /// Could not allocate the requested memory.
-  MemoryAllocationFailed = 0x21,
-
-  /// Could not access a resource.
-  AccessFailed = 0x22,
-
-  /// Error caused by the contents of a program.
-  InvalidProgram = 0x23,
-
-  /// Error caused by the contents of external data.
-  InvalidExternalData = 0x24,
-
-  /// Does not have enough resources to perform the requested operation.
-  OutOfResources = 0x25,
-
-  /*
-   * Delegate errors.
-   */
-
-  /// Init stage: Backend receives an incompatible delegate version.
-  DelegateInvalidCompatibility = 0x30,
-  /// Init stage: Backend fails to allocate memory.
-  DelegateMemoryAllocationFailed = 0x31,
-  /// Execute stage: The handle is invalid.
-  DelegateInvalidHandle = 0x32,
-};
-
-// Stringify the Error enum.
-constexpr const char *to_string(const Error error) {
-  switch (error) {
-  case Error::Ok:
-    return "Error::Ok";
-  case Error::Internal:
-    return "Error::Internal";
-  case Error::InvalidState:
-    return "Error::InvalidState";
-  case Error::EndOfMethod:
-    return "Error::EndOfMethod";
-  case Error::AlreadyLoaded:
-    return "Error::AlreadyLoaded";
-  case Error::NotSupported:
-    return "Error::NotSupported";
-  case Error::NotImplemented:
-    return "Error::NotImplemented";
-  case Error::InvalidArgument:
-    return "Error::InvalidArgument";
-  case Error::InvalidType:
-    return "Error::InvalidType";
-  case Error::OperatorMissing:
-    return "Error::OperatorMissing";
-  case Error::NotFound:
-    return "Error::NotFound";
-  case Error::MemoryAllocationFailed:
-    return "Error::MemoryAllocationFailed";
-  case Error::AccessFailed:
-    return "Error::AccessFailed";
-  case Error::InvalidProgram:
-    return "Error::InvalidProgram";
-  case Error::InvalidExternalData:
-    return "Error::InvalidExternalData";
-  case Error::OutOfResources:
-    return "Error::OutOfResources";
-  case Error::DelegateInvalidCompatibility:
-    return "Error::DelegateInvalidCompatibility";
-  case Error::DelegateMemoryAllocationFailed:
-    return "Error::DelegateMemoryAllocationFailed";
-  case Error::DelegateInvalidHandle:
-    return "Error::DelegateInvalidHandle";
-  case Error::RegistrationExceedingMaxKernels:
-    return "Error::RegistrationExceedingMaxKernels";
-  case Error::RegistrationAlreadyRegistered:
-    return "Error::RegistrationAlreadyRegistered";
-  }
-  return "Error::Unknown";
-}
-
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::Error;
-using ::executorch::runtime::error_code_t;
-} // namespace executor
-} // namespace torch
-
-/**
- * If cond__ is false, log the specified message and return the specified Error
- * from the current function, which must be of return type
- * executorch::runtime::Error.
- *
- * @param[in] cond__ The condition to be checked, asserted as true.
- * @param[in] error__ Error enum value to return without the `Error::` prefix,
- * like `InvalidArgument`.
- * @param[in] message__ Format string for the log error message.
- * @param[in] ... Optional additional arguments for the format string.
- */
-#define ET_CHECK_OR_RETURN_ERROR(cond__, error__, message__, ...)              \
-  {                                                                            \
-    if (!(cond__)) {                                                           \
-      ET_LOG(Error, message__, ##__VA_ARGS__);                                 \
-      return ::executorch::runtime::Error::error__;                            \
-    }                                                                          \
-  }
-
-/**
- * A convenience macro to be used in utility functions that check whether input
- * tensor(s) are valid, which are expected to return a boolean. Checks whether
- * `cond` is true; if not, log the failed check with `message` and return false.
- *
- * @param[in] cond the condition to check
- * @param[in] message an additional message to log with `cond`
- */
-#define ET_CHECK_OR_RETURN_FALSE(cond__, message__, ...)                       \
-  {                                                                            \
-    if (!(cond__)) {                                                           \
-      ET_LOG(Error, "Check failed (%s): " message__, #cond__, ##__VA_ARGS__);  \
-      return false;                                                            \
-    }                                                                          \
-  }
-
-/**
- * If error__ is not Error::Ok, optionally log a message and return the error
- * from the current function, which must be of return type
- * executorch::runtime::Error.
- *
- * @param[in] error__ Error enum value asserted to be Error::Ok.
- * @param[in] ... Optional format string for the log error message and its
- * arguments.
- */
-#define ET_CHECK_OK_OR_RETURN_ERROR(...)                                       \
-  ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR(__VA_ARGS__)
-
-/**
- * Internal only: Use ET_CHECK_OK_OR_RETURN_ERROR() instead.
- * This macro selects the correct version of
- * ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR based on the number of arguments passed.
- * It uses a helper that reliably picks the 1-arg or 2+-arg form on
- * MSVC/Clang/GCC.
- */
-#define ET_INTERNAL_EXPAND(x) x
-#define ET_INTERNAL_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, NAME,   \
-                              ...)                                             \
-  NAME
-
-// Internal only: Use ET_CHECK_OK_OR_RETURN_ERROR() instead.
-// Picks _2 for 2..10 args, _1 for exactly 1 arg.
-#define ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR(...)                              \
-  ET_INTERNAL_EXPAND(ET_INTERNAL_GET_MACRO(                                    \
-      __VA_ARGS__, ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2, /* 10 */            \
-      ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2,              /* 9  */            \
-      ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2,              /* 8  */            \
-      ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2,              /* 7  */            \
-      ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2,              /* 6  */            \
-      ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2,              /* 5  */            \
-      ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2,              /* 4  */            \
-      ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2,              /* 3  */            \
-      ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2,              /* 2  */            \
-      ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_1               /* 1  */            \
-      )(__VA_ARGS__))
-
-// Internal only: Use ET_CHECK_OK_OR_RETURN_ERROR() instead.
-#define ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_1(error__)                        \
-  do {                                                                         \
-    const auto et_error__ = (error__);                                         \
-    if (et_error__ != ::executorch::runtime::Error::Ok) {                      \
-      return et_error__;                                                       \
-    }                                                                          \
-  } while (0)
-
-// Internal only: Use ET_CHECK_OK_OR_RETURN_ERROR() instead.
-#define ET_INTERNAL_CHECK_OK_OR_RETURN_ERROR_2(error__, message__, ...)        \
-  do {                                                                         \
-    const auto et_error__ = (error__);                                         \
-    if (et_error__ != ::executorch::runtime::Error::Ok) {                      \
-      ET_LOG(Error, message__, ##__VA_ARGS__);                                 \
-      return et_error__;                                                       \
-    }                                                                          \
-  } while (0)
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/evalue.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/evalue.h
deleted file mode 100644
index 2e8bb5389e..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/evalue.h
+++ /dev/null
@@ -1,802 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <executorch/runtime/core/result.h>
-#include <executorch/runtime/core/tag.h>
-#include <executorch/runtime/platform/assert.h>
-
-namespace executorch {
-namespace runtime {
-
-struct EValue;
-
-namespace internal {
-
-// Tensor gets proper reference treatment because its expensive to copy in aten
-// mode, all other types are just copied.
-template <typename T> struct evalue_to_const_ref_overload_return {
-  using type = T;
-};
-
-template <>
-struct evalue_to_const_ref_overload_return<executorch::aten::Tensor> {
-  using type = const executorch::aten::Tensor &;
-};
-
-template <typename T> struct evalue_to_ref_overload_return {
-  using type = T;
-};
-
-template <> struct evalue_to_ref_overload_return<executorch::aten::Tensor> {
-  using type = executorch::aten::Tensor &;
-};
-
-} // namespace internal
-
-/*
- * Helper class used to correlate EValues in the executor table, with the
- * unwrapped list of the proper type. Because values in the runtime's values
- * table can change during execution, we cannot statically allocate list of
- * objects at deserialization. Imagine the serialized list says index 0 in the
- * value table is element 2 in the list, but during execution the value in
- * element 2 changes (in the case of tensor this means the TensorImpl* stored in
- * the tensor changes). To solve this instead they must be created dynamically
- * whenever they are used.
- */
-template <typename T> class BoxedEvalueList {
-public:
-  BoxedEvalueList() = default;
-  /*
-   * Wrapped_vals is a list of pointers into the values table of the runtime
-   * whose destinations correlate with the elements of the list, unwrapped_vals
-   * is a container of the same size whose serves as memory to construct the
-   * unwrapped vals.
-   */
-  BoxedEvalueList(EValue **wrapped_vals, T *unwrapped_vals, int size)
-      : wrapped_vals_(checkWrappedVals(wrapped_vals, size), size),
-        unwrapped_vals_(checkUnwrappedVals(unwrapped_vals)) {}
-
-  /*
-   * Constructs and returns the list of T specified by the EValue pointers
-   */
-  executorch::aten::ArrayRef<T> get() const;
-
-  /**
-   * Result-returning counterpart of get(). Validates each wrapped EValue's
-   * tag before materializing; returns Error::InvalidType if any element's
-   * tag does not match T and Error::InvalidState if any element pointer is
-   * null. Use this when materializing lists from untrusted .pte data so that
-   * a malformed program cannot force a process abort inside to<T>() /
-   * ET_CHECK.
-   */
-  Result<executorch::aten::ArrayRef<T>> tryGet() const;
-
-  /**
-   * Destroys the unwrapped elements without re-dereferencing wrapped_vals_.
-   * This is safe to call during EValue destruction because it does not
-   * dereference wrapped_vals_, which may point to EValues mutated by
-   * MoveCall instructions.
-   */
-  void destroy_elements() {
-    for (typename executorch::aten::ArrayRef<T>::size_type i = 0;
-         i < wrapped_vals_.size(); i++) {
-      unwrapped_vals_[i].~T();
-    }
-  }
-
-private:
-  static EValue **checkWrappedVals(EValue **wrapped_vals, int size) {
-    ET_CHECK_MSG(wrapped_vals != nullptr, "wrapped_vals cannot be null");
-    ET_CHECK_MSG(size >= 0, "size cannot be negative");
-    return wrapped_vals;
-  }
-
-  static T *checkUnwrappedVals(T *unwrapped_vals) {
-    ET_CHECK_MSG(unwrapped_vals != nullptr, "unwrapped_vals cannot be null");
-    return unwrapped_vals;
-  }
-
-  // Source of truth for the list
-  executorch::aten::ArrayRef<EValue *> wrapped_vals_;
-  // Same size as wrapped_vals
-  mutable T *unwrapped_vals_;
-};
-
-template <>
-executorch::aten::ArrayRef<std::optional<executorch::aten::Tensor>>
-BoxedEvalueList<std::optional<executorch::aten::Tensor>>::get() const;
-
-template <>
-Result<executorch::aten::ArrayRef<std::optional<executorch::aten::Tensor>>>
-BoxedEvalueList<std::optional<executorch::aten::Tensor>>::tryGet() const;
-
-// Aggregate typing system similar to IValue only slimmed down with less
-// functionality, no dependencies on atomic, and fewer supported types to better
-// suit embedded systems (ie no intrusive ptr)
-struct EValue {
-  union Payload {
-    // When in ATen mode at::Tensor is not trivially copyable, this nested union
-    // lets us handle tensor as a special case while leaving the rest of the
-    // fields in a simple state instead of requiring a switch on tag everywhere.
-    union TriviallyCopyablePayload {
-      TriviallyCopyablePayload() : as_int(0) {}
-      // Scalar supported through these 3 types
-      int64_t as_int;
-      double as_double;
-      bool as_bool;
-
-      executorch::aten::ArrayRef<char> *as_string_ptr;
-      executorch::aten::ArrayRef<double> *as_double_list_ptr;
-      executorch::aten::ArrayRef<bool> *as_bool_list_ptr;
-      BoxedEvalueList<int64_t> *as_int_list_ptr;
-      BoxedEvalueList<executorch::aten::Tensor> *as_tensor_list_ptr;
-      BoxedEvalueList<std::optional<executorch::aten::Tensor>>
-          *as_list_optional_tensor_ptr;
-    } copyable_union;
-
-    // Since a Tensor just holds a TensorImpl*, there's no value to use Tensor*
-    // here.
-    executorch::aten::Tensor as_tensor;
-
-    Payload() {}
-    ~Payload() {}
-  };
-
-  // Data storage and type tag
-  Payload payload;
-  Tag tag;
-
-  // Basic ctors and assignments
-  EValue(const EValue &rhs) : EValue(rhs.payload, rhs.tag) {}
-
-  EValue(EValue &&rhs) noexcept : tag(rhs.tag) { moveFrom(std::move(rhs)); }
-
-  EValue &operator=(EValue &&rhs) & noexcept {
-    if (&rhs == this) {
-      return *this;
-    }
-
-    destroy();
-    moveFrom(std::move(rhs));
-    return *this;
-  }
-
-  EValue &operator=(EValue const &rhs) & {
-    // Define copy assignment through copy ctor and move assignment
-    *this = EValue(rhs);
-    return *this;
-  }
-
-  ~EValue() { destroy(); }
-
-  /****** None Type ******/
-  EValue() : tag(Tag::None) { payload.copyable_union.as_int = 0; }
-
-  bool isNone() const { return tag == Tag::None; }
-
-  /****** Int Type ******/
-  /*implicit*/ EValue(int64_t i) : tag(Tag::Int) {
-    payload.copyable_union.as_int = i;
-  }
-
-  bool isInt() const { return tag == Tag::Int; }
-
-  int64_t toInt() const {
-    ET_CHECK_MSG(isInt(), "EValue is not an int.");
-    return payload.copyable_union.as_int;
-  }
-
-  Result<int64_t> tryToInt() const {
-    if (!isInt()) {
-      return Error::InvalidType;
-    }
-    return payload.copyable_union.as_int;
-  }
-
-  /****** Double Type ******/
-  /*implicit*/ EValue(double d) : tag(Tag::Double) {
-    payload.copyable_union.as_double = d;
-  }
-
-  bool isDouble() const { return tag == Tag::Double; }
-
-  double toDouble() const {
-    ET_CHECK_MSG(isDouble(), "EValue is not a Double.");
-    return payload.copyable_union.as_double;
-  }
-
-  Result<double> tryToDouble() const {
-    if (!isDouble()) {
-      return Error::InvalidType;
-    }
-    return payload.copyable_union.as_double;
-  }
-
-  /****** Bool Type ******/
-  /*implicit*/ EValue(bool b) : tag(Tag::Bool) {
-    payload.copyable_union.as_bool = b;
-  }
-
-  bool isBool() const { return tag == Tag::Bool; }
-
-  bool toBool() const {
-    ET_CHECK_MSG(isBool(), "EValue is not a Bool.");
-    return payload.copyable_union.as_bool;
-  }
-
-  Result<bool> tryToBool() const {
-    if (!isBool()) {
-      return Error::InvalidType;
-    }
-    return payload.copyable_union.as_bool;
-  }
-
-  /****** Scalar Type ******/
-  /// Construct an EValue using the implicit value of a Scalar.
-  /*implicit*/ EValue(executorch::aten::Scalar s) {
-    if (s.isIntegral(false)) {
-      tag = Tag::Int;
-      payload.copyable_union.as_int = s.to<int64_t>();
-    } else if (s.isFloatingPoint()) {
-      tag = Tag::Double;
-      payload.copyable_union.as_double = s.to<double>();
-    } else if (s.isBoolean()) {
-      tag = Tag::Bool;
-      payload.copyable_union.as_bool = s.to<bool>();
-    } else {
-      ET_CHECK_MSG(false, "Scalar passed to EValue is not initialized.");
-    }
-  }
-
-  bool isScalar() const {
-    return tag == Tag::Int || tag == Tag::Double || tag == Tag::Bool;
-  }
-
-  executorch::aten::Scalar toScalar() const {
-    // Convert from implicit value to Scalar using implicit constructors.
-
-    if (isDouble()) {
-      return toDouble();
-    } else if (isInt()) {
-      return toInt();
-    } else if (isBool()) {
-      return toBool();
-    } else {
-      ET_CHECK_MSG(false, "EValue is not a Scalar.");
-    }
-  }
-
-  Result<executorch::aten::Scalar> tryToScalar() const {
-    if (isDouble()) {
-      return executorch::aten::Scalar(payload.copyable_union.as_double);
-    }
-    if (isInt()) {
-      return executorch::aten::Scalar(payload.copyable_union.as_int);
-    }
-    if (isBool()) {
-      return executorch::aten::Scalar(payload.copyable_union.as_bool);
-    }
-    return Error::InvalidType;
-  }
-
-  /****** Tensor Type ******/
-  /*implicit*/ EValue(executorch::aten::Tensor t) : tag(Tag::Tensor) {
-    // When built in aten mode, at::Tensor has a non trivial constructor
-    // destructor, so regular assignment to a union field is UB. Instead we must
-    // go through placement new (which causes a refcount bump).
-    new (&payload.as_tensor) executorch::aten::Tensor(t);
-  }
-
-  // Template constructor that allows construction from types that can be
-  // dereferenced to produce a type that EValue can be implicitly constructed
-  // from.
-  template <typename T,
-            typename = typename std::enable_if<std::is_convertible<
-                decltype(*std::forward<T>(std::declval<T>())), // declval to
-                                                               // simulate
-                                                               // forwarding
-                EValue>::value>::type>
-  /*implicit*/ EValue(T &&value) {
-    ET_CHECK_MSG(value != nullptr, "Pointer is null.");
-    // Note that this ctor does not initialize this->tag directly; it is set by
-    // moving in the new value.
-    moveFrom(*std::forward<T>(value));
-  }
-
-  // Delete constructor for raw pointers to ensure they cannot be used.
-  template <typename T> explicit EValue(T *value) = delete;
-
-  bool isTensor() const { return tag == Tag::Tensor; }
-
-  executorch::aten::Tensor toTensor() && {
-    ET_CHECK_MSG(isTensor(), "EValue is not a Tensor.");
-    auto res = std::move(payload.as_tensor);
-    clearToNone();
-    return res;
-  }
-
-  executorch::aten::Tensor &toTensor() & {
-    ET_CHECK_MSG(isTensor(), "EValue is not a Tensor.");
-    return payload.as_tensor;
-  }
-
-  const executorch::aten::Tensor &toTensor() const & {
-    ET_CHECK_MSG(isTensor(), "EValue is not a Tensor.");
-    return payload.as_tensor;
-  }
-
-  // Returns a copy of the Tensor handle (one intrusive_ptr refcount bump in
-  // ATen mode; free in lean mode). Unlike toTensor()'s const& / & overloads,
-  // tryToTensor() cannot return a reference — Result<T> wraps by value.
-  Result<executorch::aten::Tensor> tryToTensor() const {
-    if (!isTensor()) {
-      return Error::InvalidType;
-    }
-    return payload.as_tensor;
-  }
-
-  /****** String Type ******/
-  /*implicit*/ EValue(executorch::aten::ArrayRef<char> *s) : tag(Tag::String) {
-    ET_CHECK_MSG(s != nullptr, "ArrayRef<char> pointer cannot be null");
-    payload.copyable_union.as_string_ptr = s;
-  }
-
-  bool isString() const { return tag == Tag::String; }
-
-  std::string_view toString() const {
-    ET_CHECK_MSG(isString(), "EValue is not a String.");
-    ET_CHECK_MSG(payload.copyable_union.as_string_ptr != nullptr,
-                 "EValue string pointer is null.");
-    return std::string_view(payload.copyable_union.as_string_ptr->data(),
-                            payload.copyable_union.as_string_ptr->size());
-  }
-
-  Result<std::string_view> tryToString() const {
-    if (!isString()) {
-      return Error::InvalidType;
-    }
-    if (payload.copyable_union.as_string_ptr == nullptr) {
-      return Error::InvalidState;
-    }
-    return std::string_view(payload.copyable_union.as_string_ptr->data(),
-                            payload.copyable_union.as_string_ptr->size());
-  }
-
-  /****** Int List Type ******/
-  /*implicit*/ EValue(BoxedEvalueList<int64_t> *i) : tag(Tag::ListInt) {
-    ET_CHECK_MSG(i != nullptr,
-                 "BoxedEvalueList<int64_t> pointer cannot be null");
-    payload.copyable_union.as_int_list_ptr = i;
-  }
-
-  bool isIntList() const { return tag == Tag::ListInt; }
-
-  executorch::aten::ArrayRef<int64_t> toIntList() const {
-    ET_CHECK_MSG(isIntList(), "EValue is not an Int List.");
-    ET_CHECK_MSG(payload.copyable_union.as_int_list_ptr != nullptr,
-                 "EValue int list pointer is null.");
-    return (payload.copyable_union.as_int_list_ptr)->get();
-  }
-
-  Result<executorch::aten::ArrayRef<int64_t>> tryToIntList() const {
-    if (!isIntList()) {
-      return Error::InvalidType;
-    }
-    if (payload.copyable_union.as_int_list_ptr == nullptr) {
-      return Error::InvalidState;
-    }
-    return (payload.copyable_union.as_int_list_ptr)->tryGet();
-  }
-
-  /****** Bool List Type ******/
-  /*implicit*/ EValue(executorch::aten::ArrayRef<bool> *b)
-      : tag(Tag::ListBool) {
-    ET_CHECK_MSG(b != nullptr, "ArrayRef<bool> pointer cannot be null");
-    payload.copyable_union.as_bool_list_ptr = b;
-  }
-
-  bool isBoolList() const { return tag == Tag::ListBool; }
-
-  executorch::aten::ArrayRef<bool> toBoolList() const {
-    ET_CHECK_MSG(isBoolList(), "EValue is not a Bool List.");
-    ET_CHECK_MSG(payload.copyable_union.as_bool_list_ptr != nullptr,
-                 "EValue bool list pointer is null.");
-    return *(payload.copyable_union.as_bool_list_ptr);
-  }
-
-  Result<executorch::aten::ArrayRef<bool>> tryToBoolList() const {
-    if (!isBoolList()) {
-      return Error::InvalidType;
-    }
-    if (payload.copyable_union.as_bool_list_ptr == nullptr) {
-      return Error::InvalidState;
-    }
-    return *(payload.copyable_union.as_bool_list_ptr);
-  }
-
-  /****** Double List Type ******/
-  /*implicit*/ EValue(executorch::aten::ArrayRef<double> *d)
-      : tag(Tag::ListDouble) {
-    ET_CHECK_MSG(d != nullptr, "ArrayRef<double> pointer cannot be null");
-    payload.copyable_union.as_double_list_ptr = d;
-  }
-
-  bool isDoubleList() const { return tag == Tag::ListDouble; }
-
-  executorch::aten::ArrayRef<double> toDoubleList() const {
-    ET_CHECK_MSG(isDoubleList(), "EValue is not a Double List.");
-    ET_CHECK_MSG(payload.copyable_union.as_double_list_ptr != nullptr,
-                 "EValue double list pointer is null.");
-    return *(payload.copyable_union.as_double_list_ptr);
-  }
-
-  Result<executorch::aten::ArrayRef<double>> tryToDoubleList() const {
-    if (!isDoubleList()) {
-      return Error::InvalidType;
-    }
-    if (payload.copyable_union.as_double_list_ptr == nullptr) {
-      return Error::InvalidState;
-    }
-    return *(payload.copyable_union.as_double_list_ptr);
-  }
-
-  /****** Tensor List Type ******/
-  /*implicit*/ EValue(BoxedEvalueList<executorch::aten::Tensor> *t)
-      : tag(Tag::ListTensor) {
-    ET_CHECK_MSG(t != nullptr,
-                 "BoxedEvalueList<Tensor> pointer cannot be null");
-    payload.copyable_union.as_tensor_list_ptr = t;
-  }
-
-  bool isTensorList() const { return tag == Tag::ListTensor; }
-
-  executorch::aten::ArrayRef<executorch::aten::Tensor> toTensorList() const {
-    ET_CHECK_MSG(isTensorList(), "EValue is not a Tensor List.");
-    ET_CHECK_MSG(payload.copyable_union.as_tensor_list_ptr != nullptr,
-                 "EValue tensor list pointer is null.");
-    return payload.copyable_union.as_tensor_list_ptr->get();
-  }
-
-  Result<executorch::aten::ArrayRef<executorch::aten::Tensor>>
-  tryToTensorList() const {
-    if (!isTensorList()) {
-      return Error::InvalidType;
-    }
-    if (payload.copyable_union.as_tensor_list_ptr == nullptr) {
-      return Error::InvalidState;
-    }
-    return payload.copyable_union.as_tensor_list_ptr->tryGet();
-  }
-
-  /****** List Optional Tensor Type ******/
-  /*implicit*/ EValue(
-      BoxedEvalueList<std::optional<executorch::aten::Tensor>> *t)
-      : tag(Tag::ListOptionalTensor) {
-    ET_CHECK_MSG(t != nullptr,
-                 "BoxedEvalueList<optional<Tensor>> pointer cannot be null");
-    payload.copyable_union.as_list_optional_tensor_ptr = t;
-  }
-
-  bool isListOptionalTensor() const { return tag == Tag::ListOptionalTensor; }
-
-  executorch::aten::ArrayRef<std::optional<executorch::aten::Tensor>>
-  toListOptionalTensor() const {
-    ET_CHECK_MSG(isListOptionalTensor(),
-                 "EValue is not a List Optional Tensor.");
-    ET_CHECK_MSG(payload.copyable_union.as_list_optional_tensor_ptr != nullptr,
-                 "EValue list optional tensor pointer is null.");
-    return payload.copyable_union.as_list_optional_tensor_ptr->get();
-  }
-
-  Result<executorch::aten::ArrayRef<std::optional<executorch::aten::Tensor>>>
-  tryToListOptionalTensor() const {
-    if (!isListOptionalTensor()) {
-      return Error::InvalidType;
-    }
-    if (payload.copyable_union.as_list_optional_tensor_ptr == nullptr) {
-      return Error::InvalidState;
-    }
-    return payload.copyable_union.as_list_optional_tensor_ptr->tryGet();
-  }
-
-  /****** ScalarType Type ******/
-  executorch::aten::ScalarType toScalarType() const {
-    ET_CHECK_MSG(isInt(), "EValue is not a ScalarType.");
-    return static_cast<executorch::aten::ScalarType>(
-        payload.copyable_union.as_int);
-  }
-
-  Result<executorch::aten::ScalarType> tryToScalarType() const {
-    if (!isInt()) {
-      return Error::InvalidType;
-    }
-    return static_cast<executorch::aten::ScalarType>(
-        payload.copyable_union.as_int);
-  }
-
-  /****** MemoryFormat Type ******/
-  executorch::aten::MemoryFormat toMemoryFormat() const {
-    ET_CHECK_MSG(isInt(), "EValue is not a MemoryFormat.");
-    return static_cast<executorch::aten::MemoryFormat>(
-        payload.copyable_union.as_int);
-  }
-
-  Result<executorch::aten::MemoryFormat> tryToMemoryFormat() const {
-    if (!isInt()) {
-      return Error::InvalidType;
-    }
-    return static_cast<executorch::aten::MemoryFormat>(
-        payload.copyable_union.as_int);
-  }
-
-  /****** Layout Type ******/
-  executorch::aten::Layout toLayout() const {
-    ET_CHECK_MSG(isInt(), "EValue is not a Layout.");
-    return static_cast<executorch::aten::Layout>(payload.copyable_union.as_int);
-  }
-
-  Result<executorch::aten::Layout> tryToLayout() const {
-    if (!isInt()) {
-      return Error::InvalidType;
-    }
-    return static_cast<executorch::aten::Layout>(payload.copyable_union.as_int);
-  }
-
-  /****** Device Type ******/
-  executorch::aten::Device toDevice() const {
-    ET_CHECK_MSG(isInt(), "EValue is not a Device.");
-    return executorch::aten::Device(static_cast<executorch::aten::DeviceType>(
-                                        payload.copyable_union.as_int),
-                                    -1);
-  }
-
-  Result<executorch::aten::Device> tryToDevice() const {
-    if (!isInt()) {
-      return Error::InvalidType;
-    }
-    return executorch::aten::Device(static_cast<executorch::aten::DeviceType>(
-                                        payload.copyable_union.as_int),
-                                    -1);
-  }
-
-  template <typename T> T to() &&;
-  template <typename T>
-  typename internal::evalue_to_const_ref_overload_return<T>::type to() const &;
-  template <typename T>
-  typename internal::evalue_to_ref_overload_return<T>::type to() &;
-
-  /**
-   * Result-returning equivalent of `to<T>()`. Tag mismatch returns
-   * `Error::InvalidType`; a null list/string payload returns
-   * `Error::InvalidState`. Specializations are defined below via
-   * `EVALUE_DEFINE_TRY_TO`.
-   */
-  template <typename T> Result<T> tryTo() const;
-
-  /**
-   * Converts the EValue to an optional object that can represent both T and
-   * an uninitialized state.
-   */
-  template <typename T> inline std::optional<T> toOptional() const {
-    if (this->isNone()) {
-      return executorch::aten::nullopt;
-    }
-    return this->to<T>();
-  }
-
-  /**
-   * Result-returning equivalent of `toOptional<T>()`. None maps to an empty
-   * optional; any other tag that doesn't match T propagates `tryTo<T>()`'s
-   * error (`Error::InvalidType`).
-   */
-  template <typename T> inline Result<std::optional<T>> tryToOptional() const {
-    if (this->isNone()) {
-      return std::optional<T>(std::nullopt);
-    }
-    auto r = this->tryTo<T>();
-    if (!r.ok()) {
-      return r.error();
-    }
-    return std::optional<T>(std::move(r.get()));
-  }
-
-private:
-  // Pre cond: the payload value has had its destructor called
-  void clearToNone() noexcept {
-    payload.copyable_union.as_int = 0;
-    tag = Tag::None;
-  }
-
-  // Shared move logic
-  void moveFrom(EValue &&rhs) noexcept {
-    if (rhs.isTensor()) {
-      new (&payload.as_tensor)
-          executorch::aten::Tensor(std::move(rhs.payload.as_tensor));
-      rhs.payload.as_tensor.~Tensor();
-    } else {
-      payload.copyable_union = rhs.payload.copyable_union;
-    }
-    tag = rhs.tag;
-    rhs.clearToNone();
-  }
-
-  // Destructs stored tensor if there is one
-  void destroy() {
-    // Necessary for ATen tensor to refcount decrement the intrusive_ptr to
-    // tensorimpl that got a refcount increment when we placed it in the evalue,
-    // no-op if executorch tensor #ifdef could have a
-    // minor performance bump for a code maintainability hit
-    if (isTensor()) {
-      payload.as_tensor.~Tensor();
-    } else if (isTensorList() &&
-               payload.copyable_union.as_tensor_list_ptr != nullptr) {
-      payload.copyable_union.as_tensor_list_ptr->destroy_elements();
-    } else if (isListOptionalTensor() &&
-               payload.copyable_union.as_list_optional_tensor_ptr != nullptr) {
-      payload.copyable_union.as_list_optional_tensor_ptr->destroy_elements();
-    }
-  }
-
-  EValue(const Payload &p, Tag t) : tag(t) {
-    if (isTensor()) {
-      new (&payload.as_tensor) executorch::aten::Tensor(p.as_tensor);
-    } else {
-      payload.copyable_union = p.copyable_union;
-    }
-  }
-};
-
-#define EVALUE_DEFINE_TO(T, method_name)                                       \
-  template <> inline T EValue::to<T>() && {                                    \
-    return static_cast<T>(std::move(*this).method_name());                     \
-  }                                                                            \
-  template <>                                                                  \
-  inline ::executorch::runtime::internal::evalue_to_const_ref_overload_return< \
-      T>::type                                                                 \
-  EValue::to<T>() const & {                                                    \
-    typedef ::executorch::runtime::internal::                                  \
-        evalue_to_const_ref_overload_return<T>::type return_type;              \
-    return static_cast<return_type>(this->method_name());                      \
-  }                                                                            \
-  template <>                                                                  \
-  inline ::executorch::runtime::internal::evalue_to_ref_overload_return<       \
-      T>::type                                                                 \
-  EValue::to<T>() & {                                                          \
-    typedef ::executorch::runtime::internal::evalue_to_ref_overload_return<    \
-        T>::type return_type;                                                  \
-    return static_cast<return_type>(this->method_name());                      \
-  }
-
-EVALUE_DEFINE_TO(executorch::aten::Scalar, toScalar)
-EVALUE_DEFINE_TO(int64_t, toInt)
-EVALUE_DEFINE_TO(bool, toBool)
-EVALUE_DEFINE_TO(double, toDouble)
-EVALUE_DEFINE_TO(std::string_view, toString)
-EVALUE_DEFINE_TO(executorch::aten::ScalarType, toScalarType)
-EVALUE_DEFINE_TO(executorch::aten::MemoryFormat, toMemoryFormat)
-EVALUE_DEFINE_TO(executorch::aten::Layout, toLayout)
-EVALUE_DEFINE_TO(executorch::aten::Device, toDevice)
-// Tensor and Optional Tensor
-EVALUE_DEFINE_TO(std::optional<executorch::aten::Tensor>,
-                 toOptional<executorch::aten::Tensor>)
-EVALUE_DEFINE_TO(executorch::aten::Tensor, toTensor)
-
-// IntList and Optional IntList
-EVALUE_DEFINE_TO(executorch::aten::ArrayRef<int64_t>, toIntList)
-EVALUE_DEFINE_TO(std::optional<executorch::aten::ArrayRef<int64_t>>,
-                 toOptional<executorch::aten::ArrayRef<int64_t>>)
-
-// DoubleList and Optional DoubleList
-EVALUE_DEFINE_TO(executorch::aten::ArrayRef<double>, toDoubleList)
-EVALUE_DEFINE_TO(std::optional<executorch::aten::ArrayRef<double>>,
-                 toOptional<executorch::aten::ArrayRef<double>>)
-
-// BoolList and Optional BoolList
-EVALUE_DEFINE_TO(executorch::aten::ArrayRef<bool>, toBoolList)
-EVALUE_DEFINE_TO(std::optional<executorch::aten::ArrayRef<bool>>,
-                 toOptional<executorch::aten::ArrayRef<bool>>)
-
-// TensorList and Optional TensorList
-EVALUE_DEFINE_TO(executorch::aten::ArrayRef<executorch::aten::Tensor>,
-                 toTensorList)
-EVALUE_DEFINE_TO(
-    std::optional<executorch::aten::ArrayRef<executorch::aten::Tensor>>,
-    toOptional<executorch::aten::ArrayRef<executorch::aten::Tensor>>)
-
-// List of Optional Tensor
-EVALUE_DEFINE_TO(
-    executorch::aten::ArrayRef<std::optional<executorch::aten::Tensor>>,
-    toListOptionalTensor)
-#undef EVALUE_DEFINE_TO
-
-#define EVALUE_DEFINE_TRY_TO(T, method_name)                                   \
-  template <> inline Result<T> EValue::tryTo<T>() const {                      \
-    return this->method_name();                                                \
-  }
-
-EVALUE_DEFINE_TRY_TO(executorch::aten::Scalar, tryToScalar)
-EVALUE_DEFINE_TRY_TO(int64_t, tryToInt)
-EVALUE_DEFINE_TRY_TO(bool, tryToBool)
-EVALUE_DEFINE_TRY_TO(double, tryToDouble)
-EVALUE_DEFINE_TRY_TO(std::string_view, tryToString)
-EVALUE_DEFINE_TRY_TO(executorch::aten::ScalarType, tryToScalarType)
-EVALUE_DEFINE_TRY_TO(executorch::aten::MemoryFormat, tryToMemoryFormat)
-EVALUE_DEFINE_TRY_TO(executorch::aten::Layout, tryToLayout)
-EVALUE_DEFINE_TRY_TO(executorch::aten::Device, tryToDevice)
-// Tensor and Optional Tensor
-EVALUE_DEFINE_TRY_TO(executorch::aten::Tensor, tryToTensor)
-EVALUE_DEFINE_TRY_TO(std::optional<executorch::aten::Tensor>,
-                     tryToOptional<executorch::aten::Tensor>)
-
-// IntList and Optional IntList
-EVALUE_DEFINE_TRY_TO(executorch::aten::ArrayRef<int64_t>, tryToIntList)
-EVALUE_DEFINE_TRY_TO(std::optional<executorch::aten::ArrayRef<int64_t>>,
-                     tryToOptional<executorch::aten::ArrayRef<int64_t>>)
-
-// DoubleList and Optional DoubleList
-EVALUE_DEFINE_TRY_TO(executorch::aten::ArrayRef<double>, tryToDoubleList)
-EVALUE_DEFINE_TRY_TO(std::optional<executorch::aten::ArrayRef<double>>,
-                     tryToOptional<executorch::aten::ArrayRef<double>>)
-
-// BoolList and Optional BoolList
-EVALUE_DEFINE_TRY_TO(executorch::aten::ArrayRef<bool>, tryToBoolList)
-EVALUE_DEFINE_TRY_TO(std::optional<executorch::aten::ArrayRef<bool>>,
-                     tryToOptional<executorch::aten::ArrayRef<bool>>)
-
-// TensorList and Optional TensorList
-EVALUE_DEFINE_TRY_TO(executorch::aten::ArrayRef<executorch::aten::Tensor>,
-                     tryToTensorList)
-EVALUE_DEFINE_TRY_TO(
-    std::optional<executorch::aten::ArrayRef<executorch::aten::Tensor>>,
-    tryToOptional<executorch::aten::ArrayRef<executorch::aten::Tensor>>)
-
-// List of Optional Tensor
-EVALUE_DEFINE_TRY_TO(
-    executorch::aten::ArrayRef<std::optional<executorch::aten::Tensor>>,
-    tryToListOptionalTensor)
-#undef EVALUE_DEFINE_TRY_TO
-
-template <typename T>
-executorch::aten::ArrayRef<T> BoxedEvalueList<T>::get() const {
-  for (typename executorch::aten::ArrayRef<T>::size_type i = 0;
-       i < wrapped_vals_.size(); i++) {
-    ET_CHECK(wrapped_vals_[i] != nullptr);
-    unwrapped_vals_[i] = wrapped_vals_[i]->template to<T>();
-  }
-  return executorch::aten::ArrayRef<T>{unwrapped_vals_, wrapped_vals_.size()};
-}
-
-template <typename T>
-Result<executorch::aten::ArrayRef<T>> BoxedEvalueList<T>::tryGet() const {
-  for (typename executorch::aten::ArrayRef<T>::size_type i = 0;
-       i < wrapped_vals_.size(); i++) {
-    if (wrapped_vals_[i] == nullptr) {
-      return Error::InvalidState;
-    }
-    auto r = wrapped_vals_[i]->template tryTo<T>();
-    if (!r.ok()) {
-      return r.error();
-    }
-    unwrapped_vals_[i] = std::move(r.get());
-  }
-  return executorch::aten::ArrayRef<T>{unwrapped_vals_, wrapped_vals_.size()};
-}
-
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::BoxedEvalueList;
-using ::executorch::runtime::EValue;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/event_tracer.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/event_tracer.h
deleted file mode 100644
index 58a417e151..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/event_tracer.h
+++ /dev/null
@@ -1,580 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#include <cstdint>
-#include <executorch/runtime/core/array_ref.h>
-#include <executorch/runtime/core/evalue.h>
-#include <executorch/runtime/core/result.h>
-#include <executorch/runtime/platform/platform.h>
-#include <stdlib.h>
-
-#pragma once
-
-namespace executorch {
-namespace runtime {
-
-/// Represents an allocator id returned by track_allocator.
-typedef uint32_t AllocatorID;
-/// Represents the chain id that will be passed in by the user during
-/// event logging.
-typedef int32_t ChainID;
-/// Represents the debug handle that is generally associated with each
-/// op executed in the runtime.
-typedef uint32_t DebugHandle;
-// Represents the delegate debug id that is generally associated with each
-// delegate event.
-typedef int32_t DelegateDebugIntId;
-
-/// Default id's for chain id and debug handle.
-constexpr ChainID kUnsetChainId = -1;
-constexpr DebugHandle kUnsetDebugHandle = 0;
-constexpr DelegateDebugIntId kUnsetDelegateDebugIntId = -1;
-// Default bundled input index to indicate that it hasn't been set yet.
-constexpr int kUnsetBundledInputIndex = -1;
-
-/// Different types of delegate debug identifiers that are supported currently.
-enum class DelegateDebugIdType {
-  /// Default value, indicates that it's not a delegate event.
-  kNone,
-  /// Indicates a delegate event logged using an integer delegate debug
-  /// identifier.
-  kInt,
-  /// Indicates a delegate event logged using a string delegate debug
-  /// identifier i.e. the delegate debug id is a pointer to a string table
-  /// managed by the class implementing EventTracer functionality.
-  kStr
-};
-
-/// Indicates the type of the EValue that was logged. These values could be
-/// serialized and should not be changed.
-enum class LoggedEValueType {
-  /// Intermediate output from an operator.
-  kIntermediateOutput = 0,
-  /// Output at the program level. This is essentially the output
-  /// of the model.
-  kProgramOutput = 1,
-};
-
-/// Indicates the level of event tracer debug logging. Verbosity of the logging
-/// increases as we go down the enum list.
-enum class EventTracerDebugLogLevel {
-  /// No logging.
-  kNoLogging,
-  /// When set to this only the program level outputs will be logged.
-  kProgramOutputs,
-  /// When set to this all intermediate outputs and program level outputs
-  /// will be logged.
-  kIntermediateOutputs,
-};
-
-/**
- * EventTracerFilterBase is an abstract base class that provides an interface
- * for filtering events based on their name or delegate debug index.
- * Derived classes should implement the filter method to define specific
- * filtering logic.
- */
-class EventTracerFilterBase {
-public:
-  /**
-   * Filters events based on the given name or delegate debug index.
-   *
-   * Note that only one of either the name or delegate_debug_index should be
-   * passed in.
-   *
-   * @param[in] name A pointer to a string representing the `name` of the
-   * event. If `delegate_debug_index` is not set to kUnsetDebugHandle, `name`
-   * should be set to nullptr.
-   *
-   * @param[in] delegate_debug_index A DebugHandle representing the debug index
-   * of the delegate. If `name` is not nullptr, this should be set to
-   * kUnsetDebugHandle.
-   *
-   * @return A Result<bool> indicating whether the event matches the filter
-   * criteria.
-   *         - True if the event matches the filter.
-   *         - False if the event does not match or is unknown.
-   *         - An error code if an error occurs during filtering.
-   */
-  virtual Result<bool> filter(const char *name,
-                              DelegateDebugIntId delegate_debug_index) = 0;
-
-  /**
-   * Virtual destructor for the EventTracerFilterBase class.
-   * Ensures proper cleanup of derived class objects.
-   */
-  virtual ~EventTracerFilterBase() = default;
-};
-
-/**
- * Indicates the level of profiling that should be enabled. Profiling
- * events will be logged in increasing order of verbosity as we go down the
- * enum list. Thus it is important to keep the enum values in the right order.
- */
-enum class EventTracerProfilingLevel {
-  /// No operator profiling.
-  kProfileMethodOnly,
-  /// All profiling events enabled.
-  kProfileAllEvents,
-};
-
-/**
- * This is the struct which should be returned when a profiling event is
- * started. This is used to uniquely identify that profiling event and will be
- * required to be passed into the end_profiling call to signal that the event
- * identified by this struct has completed.
- *
- * TODO(gasoonjia): Now this struct is mix-used for both delegate and
- *non-delegate events. In the future we should separate them into two different
- *structs: EventTracerEntry for non-delegate events holding DebugHandle, and
- *DelegateEventTracerEntry for delegate events holding DelegateDebugIntId.
- **/
-struct EventTracerEntry {
-  /// An event id to uniquely identify this event that was generated during a
-  /// call to start the tracking of an event.
-  int64_t event_id;
-  /// The chain to which this event belongs to.
-  ChainID chain_id;
-  /// The debug handle corresponding to this event.
-  DebugHandle debug_handle;
-  /// The time at which this event was started to be tracked.
-  et_timestamp_t start_time;
-  /// When delegate_event_id_type != DelegateDebugIdType::kNone it indicates
-  /// that event_id represents a delegate event. If delegate_event_id_type is:
-  /// 1) kInt then event_id contains an integer delegate debug id.
-  /// 2) kStr then event_id contains a string table index into a string table
-  /// maintained by the class implementing EventTracer functionality that will
-  /// give us the string identifier of this delegate event. For more details
-  /// refer to the DelegateMappingBuilder library present in
-  /// executorch/exir/backend/utils.py.
-  DelegateDebugIdType delegate_event_id_type;
-};
-/**
- * EventTracer is a class that users can inherit and implement to
- * log/serialize/stream etc. the profiling and debugging events that are
- * generated at runtime for a model. An example of this is the ETDump
- * implementation in the devtools codebase that serializes these events to a
- * flatbuffer.
- */
-class EventTracer {
-public:
-  /**
-   * Start a new event block (can consist of profiling and/or debugging events.)
-   * identified by this name. A block is conceptually a set of events that we
-   * want to group together. e.g. all the events that occur during the call to
-   * execute() (i.e. model inference) could be categorized as a block.
-   *
-   * @param[in] name A human readable identifier for the event block. Users
-   * calling this interface do not need to keep the memory pointed to by this
-   * pointer around. The string must be copied over into internal memory during
-   * this call.
-   */
-  virtual void create_event_block(const char *name) = 0;
-
-  /**
-   * Start the profiling of the event identified by name and debug_handle.
-   * The user can pass in a chain_id and debug_handle to this call, or leave
-   * them empty (default values) which would then result in the chain_id and
-   * debug handle stored within (set by set_chain_debug_handle) this class to be
-   * used.
-   * @param[in] name Human readable name for the profiling event. Users calling
-   * this interface do not need to keep the memory pointed to by this pointer
-   * around. The string must be copied over into internal memory during this
-   * call.
-   * @param[in] chain_id The id of the chain to which this event belongs to. If
-   * kUnsetChainId is passed in the chain_id and kUnsetDebugHandle for
-   * debug_handle then the values stored in the class internally for these
-   * properties will be used.
-   * @param[in] debug_handle Debug handle generated ahead-of-time during model
-   * compilation.
-   *
-   * @return Returns an instance of EventTracerEntry which should be passed back
-   * into the end_profiling() call.
-   */
-  virtual EventTracerEntry
-  start_profiling(const char *name, ChainID chain_id = kUnsetChainId,
-                  DebugHandle debug_handle = kUnsetDebugHandle) = 0;
-
-  /**
-   * Start the profiling of a delegate event. Similar to start_profiling it will
-   * return an instance of EventTracerEntry that contains the details of this
-   * event.
-   *
-   * @param[in] name Human readable name for the delegate event. This name has
-   * to be the same name that was passed in during the Debug delegate mapping
-   * generation in the export/ahead-of-time process. If indices and not names
-   * are used by this delegate to identify ops executed in the backend then
-   * nullptr can be passed in. Users calling this interface do not need to keep
-   * the memory pointed to by this pointer around. The string must be copied
-   * over into internal memory during this call.
-   * @param[in] delegate_debug_index The id of the delegate event. If string
-   * based names are used by this delegate to identify ops executed in the
-   * backend then kUnsetDebugHandle should be passed in here.
-   */
-  virtual EventTracerEntry
-  start_profiling_delegate(const char *name,
-                           DelegateDebugIntId delegate_debug_index) = 0;
-
-  /**
-   * Signal the end of the delegate profiling event contained in
-   * event_tracer_entry. Users also have the option to log some some free-from
-   * string based metadata along with this.
-   *
-   * @param[in] event_tracer_entry The EventTracerEntry returned by a call to
-   * start_profiling_delegate().
-   * @param[in] metadata Optional data relevant to the execution that the user
-   * wants to log along with this event. Pointer to metadata doesn't need to be
-   * valid after the call to this function. The contents and format of the data
-   * are transparent to the event tracer. It will just pipe along the data and
-   * make it available for the user again in the post-processing stage.
-   * @param[in] metadata_len Length of the metadata buffer.
-   */
-  virtual void end_profiling_delegate(EventTracerEntry event_tracer_entry,
-                                      const void *metadata = nullptr,
-                                      size_t metadata_len = 0) = 0;
-
-  /**
-   * Some delegates get access to the profiling details only after the complete
-   * graph has been executed. This interface is to support such use cases. It
-   * can be called in a loop etc. to log any number of profiling events that are
-   * part of this delegate.
-   *
-   * @param[in] name Human readable name for the delegate event. This name has
-   * to be the same name that was passed in during the Debug delegate mapping
-   * generation in the export/ahead-of-time process. If indices and not names
-   * are used by this delegate to identify ops executed in the backend then
-   * nullptr can be passed in. Users calling this interface do not need to keep
-   * the memory pointed to by this pointer around. The string must be copied
-   * over into internal memory during this call.
-   * @param[in] delegate_debug_index The id of the delegate event. If string
-   * based names are used by this delegate to identify ops executed in the
-   * backend then kUnsetDebugHandle should be passed in here.
-   * @param[in] start_time The timestamp when the delegate event started.
-   * @param[in] end_time The timestamp when the delegate event finished.
-   * @param[in] metadata Optional data relevant to the execution that the user
-   * wants to log along with this event. Pointer to metadata doesn't need to be
-   * valid after the call to this function. The contents and format of the data
-   * are transparent to the event tracer. It will just pipe along the data and
-   * make it available for the user again in the post-processing stage.
-   * @param[in] metadata_len Length of the metadata buffer.
-   */
-  virtual void log_profiling_delegate(const char *name,
-                                      DelegateDebugIntId delegate_debug_index,
-                                      et_timestamp_t start_time,
-                                      et_timestamp_t end_time,
-                                      const void *metadata = nullptr,
-                                      size_t metadata_len = 0) = 0;
-
-  /**
-   * End the profiling of the event identified by prof_entry
-   *
-   * @param[in] prof_entry Value returned by a call to start_profiling
-   */
-  virtual void end_profiling(EventTracerEntry prof_entry) = 0;
-
-  /**
-   * Track this allocation done via a MemoryAllocator which had profiling
-   * enabled on it.
-   *
-   * @param[in] id Allocator id generated by a call to track_allocator.
-   * @param[in] size The size of the allocation done, in bytes.
-   */
-  virtual void track_allocation(AllocatorID id, size_t size) = 0;
-
-  /**
-   * Generate an allocator id for this memory allocator that will be used in the
-   * future to identify all the allocations done by this allocator.
-   *
-   * @param[in] name Human readable name for the allocator. Users calling
-   * this interface do not need to keep the memory pointed to by this pointer
-   * around. The string should be copied over into internal memory during this
-   * call.
-   *
-   * @return Identifier to uniquely identify this allocator.
-   */
-  virtual AllocatorID track_allocator(const char *name) = 0;
-
-  /**
-   * Log an evalue during the execution of the model. This is useful for
-   * debugging purposes. Model outputs are a special case of this and will
-   * be logged with the output bool enabled.
-   *
-   * Users of this should refer to the chain_id and debug_handle to get the
-   * context for these evalues and their corresponding op.
-   *
-   * @param[in] evalue The value to be logged.
-   * @param[in] evalue_type Indicates what type of output this is logging e.g.
-   * an intermediate output, program output etc.
-   * @return A Result<bool> indicating the status of the logging operation.
-   *         - True if the evalue output was successfully logged.
-   *         - An error code if an error occurs during logging.
-   */
-  virtual Result<bool> log_evalue(const EValue &evalue,
-                                  LoggedEValueType evalue_type) = 0;
-
-  /**
-   * Log an intermediate tensor output from a delegate.
-   *
-   * @param[in] name Human readable name for the delegate event. This name has
-   * to be the same name that was passed in during the Debug delegate mapping
-   * generation in the export/ahead-of-time process. If indices and not names
-   * are used by this delegate to identify ops executed in the backend then
-   * nullptr can be passed in. Users calling this interface do not need to keep
-   * the memory pointed to by this pointer around. The string must be copied
-   * over into internal memory during this call.
-   * @param[in] delegate_debug_index The id of the delegate event. If string
-   * based names are used by this delegate to identify ops executed in the
-   * backend then kUnsetDebugHandle should be passed in here.
-   * @param[in] output The tensor type output to be logged.
-   * @return A Result<bool> indicating the status of the logging operation.
-   *         - True if the tensor type output was successfully logged.
-   *         - False if the tensor type output was filtered out and not logged.
-   *         - An error code if an error occurs during logging.
-   */
-  virtual Result<bool>
-  log_intermediate_output_delegate(const char *name,
-                                   DelegateDebugIntId delegate_debug_index,
-                                   const executorch::aten::Tensor &output) = 0;
-
-  /**
-   * Log an intermediate tensor array output from a delegate.
-   *
-   * @param[in] name Human readable name for the delegate event. This name has
-   * to be the same name that was passed in during the Debug delegate mapping
-   * generation in the export/ahead-of-time process. If indices and not names
-   * are used by this delegate to identify ops executed in the backend then
-   * nullptr can be passed in. Users calling this interface do not need to keep
-   * the memory pointed to by this pointer around. The string must be copied
-   * over into internal memory during this call.
-   * @param[in] delegate_debug_index The id of the delegate event. If string
-   * based names are used by this delegate to identify ops executed in the
-   * backend then kUnsetDebugHandle should be passed in here.
-   * @param[in] output The tensor array type output to be logged.
-   * @return A Result<bool> indicating the status of the logging operation.
-   *         - True if the tensor array type output was successfully logged.
-   *         - False if the tensor array type output was filtered out and not
-   * logged.
-   *         - An error code if an error occurs during logging.
-   */
-  virtual Result<bool> log_intermediate_output_delegate(
-      const char *name, DelegateDebugIntId delegate_debug_index,
-      const ArrayRef<executorch::aten::Tensor> output) = 0;
-
-  /**
-   * Log an intermediate int output from a delegate.
-   *
-   * @param[in] name Human readable name for the delegate event. This name has
-   * to be the same name that was passed in during the Debug delegate mapping
-   * generation in the export/ahead-of-time process. If indices and not names
-   * are used by this delegate to identify ops executed in the backend then
-   * nullptr can be passed in. Users calling this interface do not need to keep
-   * the memory pointed to by this pointer around. The string must be copied
-   * over into internal memory during this call.
-   * @param[in] delegate_debug_index The id of the delegate event. If string
-   * based names are used by this delegate to identify ops executed in the
-   * backend then kUnsetDebugHandle should be passed in here.
-   * @param[in] output The int type output to be logged.
-   * @return A Result<bool> indicating the status of the logging operation.
-   *         - True if the int type output was successfully logged.
-   *         - False if the int type output was filtered out and not logged.
-   *         - An error code if an error occurs during logging.
-   */
-  virtual Result<bool>
-  log_intermediate_output_delegate(const char *name,
-                                   DelegateDebugIntId delegate_debug_index,
-                                   const int &output) = 0;
-
-  /**
-   * Log an intermediate bool output from a delegate.
-   *
-   * @param[in] name Human readable name for the delegate event. This name has
-   * to be the same name that was passed in during the Debug delegate mapping
-   * generation in the export/ahead-of-time process. If indices and not names
-   * are used by this delegate to identify ops executed in the backend then
-   * nullptr can be passed in. Users calling this interface do not need to keep
-   * the memory pointed to by this pointer around. The string must be copied
-   * over into internal memory during this call.
-   * @param[in] delegate_debug_index The id of the delegate event. If string
-   * based names are used by this delegate to identify ops executed in the
-   * backend then kUnsetDebugHandle should be passed in here.
-   * @param[in] output The bool type output to be logged.
-   * @return A Result<bool> indicating the status of the logging operation.
-   *         - True if the bool type output was successfully logged.
-   *         - False if the bool type output was filtered out and not logged.
-   *         - An error code if an error occurs during logging.
-   */
-  virtual Result<bool>
-  log_intermediate_output_delegate(const char *name,
-                                   DelegateDebugIntId delegate_debug_index,
-                                   const bool &output) = 0;
-
-  /**
-   * Log an intermediate double output from a delegate.
-   *
-   * @param[in] name Human readable name for the delegate event. This name has
-   * to be the same name that was passed in during the Debug delegate mapping
-   * generation in the export/ahead-of-time process. If indices and not names
-   * are used by this delegate to identify ops executed in the backend then
-   * nullptr can be passed in. Users calling this interface do not need to keep
-   * the memory pointed to by this pointer around. The string must be copied
-   * over into internal memory during this call.
-   * @param[in] delegate_debug_index The id of the delegate event. If string
-   * based names are used by this delegate to identify ops executed in the
-   * backend then kUnsetDebugHandle should be passed in here.
-   * @param[in] output The double type output to be logged.
-   * @return A Result<bool> indicating the status of the logging operation.
-   *         - True if the double type output was successfully logged.
-   *         - False if the double type output was filtered out and not logged.
-   *         - An error code if an error occurs during logging.
-   */
-  virtual Result<bool>
-  log_intermediate_output_delegate(const char *name,
-                                   DelegateDebugIntId delegate_debug_index,
-                                   const double &output) = 0;
-
-  /**
-   * Set the filter of event tracer for delegation intermediate outputs.
-   */
-  virtual void set_delegation_intermediate_output_filter(
-      EventTracerFilterBase *event_tracer_filter) = 0;
-
-  /**
-   * Helper function to set the chain id ands debug handle. Users have two
-   * options, the first is that they can directly pass in the chain id and debug
-   * handle to start_profiling or they can explicitly set them through this
-   * helper before calling start_profiling.
-   *
-   * The reason this helper exists is to
-   * solve a specific problem. We want to do profiling logging inside the
-   * codegen layer which calls the kernels. The problem though is that the
-   * codegen layer doesn't have access to these ids when calling
-   * start_profiling.
-   *
-   * Users should ideally use these within a RAII scope interface to make sure
-   * that these values are unset after the end_profiling call. If non-default
-   * values are passed into the start_profiling call they will always be given
-   * precedence over the values set by this interface.
-   *
-   * So what we do is call this helper in method.cpp before
-   * we hit the codegen layer and in the codegen layer we do a start_profiling
-   * call without passing in a chain_id or debug_handle. This ensures that the
-   * values set via this helper are the ones associated with that call.
-   *
-   * @param[in] chain_id Chain id of the current instruction being exectuted.
-   * @param[in] debug_handle Debug handle of the current instruction being
-   * executed. In this context debug handle and instruction id are the same
-   * thing.
-   */
-  void set_chain_debug_handle(ChainID chain_id, DebugHandle debug_handle) {
-    chain_id_ = chain_id;
-    debug_handle_ = debug_handle;
-  }
-
-  /**
-   * When running a program wrapped in a bundled program, log the bundled input
-   * index of the current bundled input being tested out on this method.
-   * If users want to unset the index back to the default value, they can call
-   * this method with kUnsetBundledInputIndex.
-   *
-   * @param[in] bundled_input_index Index of the current input being tested
-   */
-  void set_bundled_input_index(int bundled_input_index) {
-    bundled_input_index_ = bundled_input_index;
-  }
-
-  /**
-   * Return the current bundled input index.
-   */
-  int bundled_input_index() { return bundled_input_index_; }
-
-  /**
-   * Set the level of event tracer debug logging that is desired.
-   *
-   */
-  void set_event_tracer_debug_level(EventTracerDebugLogLevel log_level) {
-    event_tracer_debug_level_ = log_level;
-  }
-
-  /**
-   * Return the current level of event tracer debug logging.
-   */
-  EventTracerDebugLogLevel event_tracer_debug_level() {
-    return event_tracer_debug_level_;
-  }
-
-  /**
-   * Set the level of event tracer profiling that is desired.
-   */
-  void
-  set_event_tracer_profiling_level(EventTracerProfilingLevel profiling_level) {
-    event_tracer_profiling_level_ = profiling_level;
-  }
-
-  /**
-   * Return the current level of event tracer profiling.
-   */
-  EventTracerProfilingLevel event_tracer_profiling_level() {
-    return event_tracer_profiling_level_;
-  }
-
-  /**
-   * Return the current status of intermediate outputs logging mode.
-   */
-  bool intermediate_outputs_logging_status() {
-    return log_intermediate_tensors_;
-  }
-
-  /**
-   * Get the current chain id.
-   *
-   * @return Current chain id.
-   */
-  ChainID current_chain_id() { return chain_id_; }
-
-  /**
-   * Get the current debug handle.
-   *
-   * @return Current debug handle.
-   */
-  DebugHandle current_debug_handle() { return debug_handle_; }
-
-  virtual ~EventTracer() {}
-
-protected:
-  ChainID chain_id_ = kUnsetChainId;
-  DebugHandle debug_handle_ = kUnsetDebugHandle;
-  bool event_tracer_enable_debugging_ = false;
-  bool log_intermediate_tensors_ = false;
-  int bundled_input_index_ = kUnsetBundledInputIndex;
-  EventTracerDebugLogLevel event_tracer_debug_level_ =
-      EventTracerDebugLogLevel::kNoLogging;
-  EventTracerProfilingLevel event_tracer_profiling_level_ =
-      EventTracerProfilingLevel::kProfileAllEvents;
-};
-
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::AllocatorID;
-using ::executorch::runtime::ChainID;
-using ::executorch::runtime::DebugHandle;
-using ::executorch::runtime::DelegateDebugIdType;
-using ::executorch::runtime::DelegateDebugIntId;
-using ::executorch::runtime::EventTracer;
-using ::executorch::runtime::EventTracerDebugLogLevel;
-using ::executorch::runtime::EventTracerEntry;
-using ::executorch::runtime::kUnsetBundledInputIndex;
-using ::executorch::runtime::kUnsetChainId;
-using ::executorch::runtime::kUnsetDebugHandle;
-using ::executorch::runtime::kUnsetDelegateDebugIntId;
-using ::executorch::runtime::LoggedEValueType;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/event_tracer_hooks.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/event_tracer_hooks.h
deleted file mode 100644
index 4d686e2f21..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/event_tracer_hooks.h
+++ /dev/null
@@ -1,332 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <executorch/runtime/core/event_tracer.h>
-
-/**
- * @file
- *
- * This file contains the hooks that are inserted across various parts of the
- * core runtime code to call into the EventTracer class for logging of profiling
- * and debugging events. Any calls made to the EventTracer from the runtime must
- * be made via these hooks.
- * Users shouldn't directly add these hooks in their code and it's meant only
- * for usage in ExecuTorch internal code.
- *
- * The benefit of defining these hooks is that we can easily control whether or
- * not we want to compile in the EventTracer code based on the status of the
- * ET_EVENT_TRACER_ENABLED flag.
- *
- * TODO(dbort): Make this a private header of runtime/executor. It only contains
- * runtime-internal functions and should not be part of the public set of
- * headers.
- */
-
-namespace executorch {
-namespace ET_RUNTIME_NAMESPACE {
-namespace internal {
-
-/**
- * This class enables scope based profiling where needed using RAII for
- * operators only. If operator profiling is disabled then this class is a no-op.
- */
-class EventTracerProfileOpScope final {
-public:
-  EventTracerProfileOpScope(EventTracer *event_tracer, const char *name) {
-#ifdef ET_EVENT_TRACER_ENABLED
-    event_tracer_ = event_tracer;
-    if (event_tracer_ == nullptr) {
-      return;
-    }
-    if (event_tracer_->event_tracer_profiling_level() >
-        executorch::runtime::EventTracerProfilingLevel::kProfileMethodOnly) {
-      event_entry_ = event_tracer->start_profiling(name);
-    }
-#else //! ET_EVENT_TRACER_ENABLED
-    (void)event_tracer;
-    (void)name;
-#endif
-  }
-
-  ~EventTracerProfileOpScope() {
-#ifdef ET_EVENT_TRACER_ENABLED
-    if (event_tracer_ == nullptr) {
-      return;
-    }
-    if (event_tracer_->event_tracer_profiling_level() >
-        executorch::runtime::EventTracerProfilingLevel::kProfileMethodOnly) {
-      event_tracer_->end_profiling(event_entry_);
-    }
-#endif
-  }
-
-private:
-#ifdef ET_EVENT_TRACER_ENABLED
-  EventTracer *event_tracer_;
-  EventTracerEntry event_entry_;
-#endif
-};
-
-using EventTracerProfileScope = EventTracerProfileOpScope;
-
-/**
- * This class enables scope based profiling where needed using RAII.
- * Profiling will be started when the object is created and will end
- * when the object goes out of scope. This is specifically intended to
- * be used for profiling methods in the runtime.
- */
-class EventTracerProfileMethodScope final {
-public:
-  EventTracerProfileMethodScope(EventTracer *event_tracer, const char *name) {
-#ifdef ET_EVENT_TRACER_ENABLED
-    event_tracer_ = event_tracer;
-    if (event_tracer_ == nullptr) {
-      return;
-    }
-    event_entry_ = event_tracer->start_profiling(name);
-#else //! ET_EVENT_TRACER_ENABLED
-    (void)event_tracer;
-    (void)name;
-#endif
-  }
-
-  ~EventTracerProfileMethodScope() {
-#ifdef ET_EVENT_TRACER_ENABLED
-    if (event_tracer_ == nullptr) {
-      return;
-    }
-    event_tracer_->end_profiling(event_entry_);
-#endif
-  }
-
-private:
-#ifdef ET_EVENT_TRACER_ENABLED
-  EventTracer *event_tracer_;
-  EventTracerEntry event_entry_;
-#endif
-};
-
-/**
- * This class helps us set and then clear out the chain id and debug handle
- * values stored in the event tracer class using RAII. This is typically called
- * in the executor loop before entering the codegen layer to configure the chain
- * id and debug handle of the current instruction being executed.
- * After we return from the kernel execution we can then reset the chain id and
- * debug handle to defaults when this object goes out of scope.
- */
-class EventTracerProfileInstructionScope final {
-public:
-  EventTracerProfileInstructionScope(EventTracer *event_tracer,
-                                     ChainID chain_idx,
-                                     DebugHandle debug_handle) {
-#ifdef ET_EVENT_TRACER_ENABLED
-    event_tracer_ = event_tracer;
-    if (event_tracer_ == nullptr) {
-      return;
-    }
-    event_tracer_->set_chain_debug_handle(chain_idx, debug_handle);
-#else //! ET_EVENT_TRACER_ENABLED
-    (void)event_tracer;
-    (void)chain_idx;
-    (void)debug_handle;
-#endif
-  }
-
-  ~EventTracerProfileInstructionScope() {
-#ifdef ET_EVENT_TRACER_ENABLED
-    if (event_tracer_ == nullptr) {
-      return;
-    }
-    event_tracer_->set_chain_debug_handle(kUnsetChainId, kUnsetDebugHandle);
-#endif
-  }
-
-private:
-#ifdef ET_EVENT_TRACER_ENABLED
-  EventTracer *event_tracer_;
-#endif
-};
-
-inline bool event_tracer_enabled() {
-#ifdef ET_EVENT_TRACER_ENABLED
-  return true;
-#else //! ET_EVENT_TRACER_ENABLED
-  return false;
-#endif
-}
-/**
- * Create a new event block with the specified name. Any events logged
- * after this will be associated with this new event block.
- */
-inline void event_tracer_create_event_block(EventTracer *event_tracer,
-                                            char const *name) {
-#ifdef ET_EVENT_TRACER_ENABLED
-  if (event_tracer) {
-    event_tracer->create_event_block(name);
-  }
-#else //! ET_EVENT_TRACER_ENABLED
-  (void)event_tracer;
-  (void)name;
-#endif
-}
-
-/**
- * Explicitly mark the beginning of a new profiling event. This returns
- * an instance of an EventTracerEntry object that the user needs to keep
- * around and pass into the corresponding event_tracer_end_profiling_event
- * call.
- */
-inline EventTracerEntry
-event_tracer_begin_profiling_event(EventTracer *event_tracer,
-                                   char const *name) {
-#ifdef ET_EVENT_TRACER_ENABLED
-  if (event_tracer) {
-    return event_tracer->start_profiling(name);
-  }
-#else //! ET_EVENT_TRACER_ENABLED
-  (void)event_tracer;
-  (void)name;
-#endif
-  // There is no active tracer; this value will be ignored.
-  return EventTracerEntry();
-}
-
-/**
- * Mark the end of a profiling event passing in the entry token
- * returned by a previous call to ET_EVENT_TRACER_BEGIN_PROFILING_EVENT.
- */
-inline void event_tracer_end_profiling_event(EventTracer *event_tracer,
-                                             EventTracerEntry event) {
-#ifdef ET_EVENT_TRACER_ENABLED
-  if (event_tracer) {
-    event_tracer->end_profiling(event);
-  }
-#else //! ET_EVENT_TRACER_ENABLED
-  (void)event_tracer;
-  (void)event;
-#endif
-}
-
-/**
- * Start the tracking of the allocator represented by this name and returns
- * an AllocatorID that will be used to track all subsequent allocations done by
- * this allocator.
- */
-inline AllocatorID event_tracer_track_allocator(EventTracer *event_tracer,
-                                                const char *name) {
-#ifdef ET_EVENT_TRACER_ENABLED
-  if (event_tracer) {
-    return event_tracer->track_allocator(name);
-  }
-#else //! ET_EVENT_TRACER_ENABLED
-  (void)event_tracer;
-  (void)name;
-#endif
-  // There is no active tracer; this value will be ignored.
-  return 0;
-}
-
-/// Log the allocation event done via the allocator represented by id.
-inline void event_tracer_track_allocation(EventTracer *event_tracer,
-                                          AllocatorID id, size_t size) {
-#ifdef ET_EVENT_TRACER_ENABLED
-  if (event_tracer) {
-    event_tracer->track_allocation(id, size);
-  }
-#else //! ET_EVENT_TRACER_ENABLED
-  (void)event_tracer;
-  (void)id;
-  (void)size;
-#endif
-}
-
-/// Log an intermediate value.
-inline void event_tracer_log_evalue(EventTracer *event_tracer, EValue &evalue) {
-#ifdef ET_EVENT_TRACER_ENABLED
-  if (event_tracer) {
-    if (event_tracer->event_tracer_debug_level() >=
-        EventTracerDebugLogLevel::kIntermediateOutputs) {
-      event_tracer->log_evalue(evalue, LoggedEValueType::kIntermediateOutput);
-    }
-  }
-#else //! ET_EVENT_TRACER_ENABLED
-  (void)event_tracer;
-  (void)evalue;
-#endif
-}
-
-/// Log a program output.
-inline void event_tracer_log_evalue_output(EventTracer *event_tracer,
-                                           const EValue &evalue) {
-#ifdef ET_EVENT_TRACER_ENABLED
-  /*
-   * If debugging via event tracer is enabled but intermediate output logging is
-   * disabled then we want to only log the outputs.
-   */
-  if (event_tracer) {
-    if (event_tracer->event_tracer_debug_level() >=
-        EventTracerDebugLogLevel::kProgramOutputs) {
-      event_tracer->log_evalue(evalue, LoggedEValueType::kProgramOutput);
-    }
-  }
-#else //! ET_EVENT_TRACER_ENABLED
-  (void)event_tracer;
-  (void)evalue;
-#endif
-}
-
-// Set the bundled input index of the current bundled input being used by the
-// method.
-inline void event_tracer_set_bundled_input_index(EventTracer *event_tracer,
-                                                 int bundled_input_index) {
-#ifdef ET_EVENT_TRACER_ENABLED
-  if (event_tracer) {
-    event_tracer->set_bundled_input_index(bundled_input_index);
-  }
-#else //! ET_EVENT_TRACER_ENABLED
-  (void)event_tracer;
-  (void)bundled_input_index;
-#endif
-}
-
-} // namespace internal
-} // namespace ET_RUNTIME_NAMESPACE
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-namespace internal {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::ET_RUNTIME_NAMESPACE::internal::
-    event_tracer_begin_profiling_event;
-using ::executorch::ET_RUNTIME_NAMESPACE::internal::
-    event_tracer_create_event_block;
-using ::executorch::ET_RUNTIME_NAMESPACE::internal::
-    event_tracer_end_profiling_event;
-using ::executorch::ET_RUNTIME_NAMESPACE::internal::event_tracer_log_evalue;
-using ::executorch::ET_RUNTIME_NAMESPACE::internal::
-    event_tracer_log_evalue_output;
-using ::executorch::ET_RUNTIME_NAMESPACE::internal::
-    event_tracer_set_bundled_input_index;
-using ::executorch::ET_RUNTIME_NAMESPACE::internal::
-    event_tracer_track_allocation;
-using ::executorch::ET_RUNTIME_NAMESPACE::internal::
-    event_tracer_track_allocator;
-using ::executorch::ET_RUNTIME_NAMESPACE::internal::
-    EventTracerProfileInstructionScope;
-using ::executorch::ET_RUNTIME_NAMESPACE::internal::
-    EventTracerProfileMethodScope;
-using ::executorch::ET_RUNTIME_NAMESPACE::internal::EventTracerProfileOpScope;
-using ::executorch::ET_RUNTIME_NAMESPACE::internal::EventTracerProfileScope;
-
-} // namespace internal
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/event_tracer_hooks_delegate.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/event_tracer_hooks_delegate.h
deleted file mode 100644
index 170246305e..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/event_tracer_hooks_delegate.h
+++ /dev/null
@@ -1,197 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <executorch/runtime/core/event_tracer.h>
-
-/**
- * @file
- *
- * This file contains the hooks that can be used by runtime delegate backend
- * authors to log profiling and debugging events from backend code. In order to
- * use these hooks delegate authors would have needed to generate a delegate
- * debug identifier mapping using the DelegateMappingBuilder library present in
- * executorch/exir/backend/utils.py. The delegate debug identifiers generated by
- * that library are the ones that need to be passed to these hooks to log
- * events. Using any other identifiers will cause post-processing of the events
- * data to not properly link back to the nodes in the original lowered graph.
- *
- * The benefit of defining these hooks is that we can easily control whether or
- * not we want to compile in the EventTracer code based on the status of the
- * ET_EVENT_TRACER_ENABLED flag.
- */
-
-namespace executorch {
-namespace runtime {
-
-/**
- * Start the profiling of a delegate event. Similar to start_profiling it will
- * return an instance of EventTracerEntry that contains the details of this
- * event. Can be left in production code as these hooks compile conditionally.
- *
- * @param[in] event_tracer The event tracer instance that is doing the logging.
- * @param[in] name Human readable name for the delegate event. This name has
- * to be the same name that was passed in during the Debug delegate mapping
- * generation in the export/ahead-of-time process. If indices and not names
- * are used by this delegate to identify ops executed in the backend then
- * nullptr can be passed in. Users calling this interface do not need to keep
- * the memory pointed to by this pointer around. The string must be copied over
- * into internal memory during this call.
- * @param[in] delegate_debug_id The id of the delegate event. If string
- * based names are used by this delegate to identify ops executed in the
- * backend then kUnsetDebugHandle should be passed in here.
- */
-inline EventTracerEntry
-event_tracer_start_profiling_delegate(EventTracer *event_tracer,
-                                      const char *name,
-                                      DebugHandle delegate_debug_id) {
-#ifdef ET_EVENT_TRACER_ENABLED
-  if (event_tracer) {
-    return event_tracer->start_profiling_delegate(name, delegate_debug_id);
-  }
-#else //! ET_EVENT_TRACER_ENABLED
-  (void)name;
-  (void)delegate_debug_id;
-#endif
-  // There is no active tracer; this value will be ignored.
-  return EventTracerEntry();
-}
-
-/**
- * Signal the end of the delegate profiling event contained in
- * event_tracer_entry. Users also have the option to log some some free-from
- * string based metadata along with this. Can be left in production code as
- * these hooks compile conditionally.
- *
- * @param[in] event_tracer The event tracer instance that is doing the logging.
- * @param[in] event_tracer_entry The EventTracerEntry returned by a call to
- * start_profiling_delegate().
- * @param[in] metadata Optional data relevant to the execution that the user
- * wants to log along with this event. Pointer to metadata doesn't need to be
- * valid after the call to this function. The contents and format of the data
- * are transparent to the event tracer. It will just pipe along the data and
- * make it available for the user again in the post-processing stage.
- * @param[in] metadata_len Length of the metadata buffer.
- */
-inline void event_tracer_end_profiling_delegate(
-    EventTracer *event_tracer, EventTracerEntry event_tracer_entry,
-    const void *metadata = nullptr, size_t metadata_len = 0) {
-#ifdef ET_EVENT_TRACER_ENABLED
-  if (event_tracer) {
-    event_tracer->end_profiling_delegate(event_tracer_entry, metadata,
-                                         metadata_len);
-  }
-#else //! ET_EVENT_TRACER_ENABLED
-  (void)event_tracer_entry;
-  (void)metadata;
-  (void)metadata_len;
-#endif
-}
-
-/**
- * Some delegates get access to the profiling details only after the complete
- * graph has been executed. This interface is to support such use cases. It
- * can be called in a loop etc. to log any number of profiling events that are
- * part of this delegate. Can be left in production code as these hooks
- * compile conditionally.
- *
- * @param[in] event_tracer The event tracer instance that is doing the logging.
- * @param[in] name Human readable name for the delegate event. This name has
- * to be the same name that was passed in during the Debug delegate mapping
- * generation in the export/ahead-of-time process. If indices and not names
- * are used by this delegate to identify ops executed in the backend then
- * nullptr can be passed in. Users calling this interface do not need to keep
- * the memory pointed to by this pointer around. The string must
- * be copied over into internal memory during this call.
- * @param[in] delegate_debug_id The id of the delegate event. If string
- * based names are used by this delegate to identify ops executed in the
- * backend then -1 should be passed in here.
- * @param[in] start_time The timestamp when the delegate event started.
- * @param[in] end_time The timestamp when the delegate event finished.
- * @param[in] metadata Optional data relevant to the execution that the user
- * wants to log along with this event. Pointer to metadata doesn't need to be
- * valid after the call to this function. The contents and format of the data
- * are transparent to the event tracer. It will just pipe along the data and
- * make it available for the user again in the post-processing stage.
- * @param[in] metadata_len Length of the metadata buffer.
- */
-inline void event_tracer_log_profiling_delegate(
-    EventTracer *event_tracer, const char *name, DebugHandle delegate_debug_id,
-    et_timestamp_t start_time, et_timestamp_t end_time,
-    const void *metadata = nullptr, size_t metadata_len = 0) {
-#ifdef ET_EVENT_TRACER_ENABLED
-  if (event_tracer) {
-    event_tracer->log_profiling_delegate(name, delegate_debug_id, start_time,
-                                         end_time, metadata, metadata_len);
-  }
-#else //! ET_EVENT_TRACER_ENABLED
-  (void)name;
-  (void)delegate_debug_id;
-  (void)start_time;
-  (void)end_time;
-  (void)metadata;
-  (void)metadata_len;
-#endif
-}
-
-/**
- * This templated interfaces can be called in a loop etc. to log any number of
- * debug events that are part of this delegate. Supported values types are int,
- * bool, double, tensor and array of tensors. Can be left in production code as
- * these hooks compile conditionally.
- *
- * @param[in] event_tracer The event tracer instance that is doing the logging.
- * @param[in] name Human readable name for the delegate event. This name has
- * to be the same name that was passed in during the Debug delegate mapping
- * generation in the export/ahead-of-time process. If indices and not names
- * are used by this delegate to identify ops executed in the backend then
- * nullptr can be passed in. Users calling this interface do not need to keep
- * the memory pointed to by this pointer around. The string must
- * be copied over into internal memory during this call.
- * @param[in] delegate_debug_id The id of the delegate event. If string
- * based names are used by this delegate to identify ops executed in the
- * backend then -1 should be passed in here.
- * @param[in] output The output to be logged.
- */
-template <typename T>
-inline void event_tracer_log_output_delegate(EventTracer *event_tracer,
-                                             const char *name,
-                                             DebugHandle delegate_debug_id,
-                                             const T &output) {
-#ifdef ET_EVENT_TRACER_ENABLED
-  if (event_tracer) {
-    static_assert(
-        std::is_same<T, int>::value || std::is_same<T, bool>::value ||
-            std::is_same<T, double>::value ||
-            std::is_same<T, executorch::aten::Tensor>::value ||
-            std::is_same<T, ArrayRef<executorch::aten::Tensor>>::value,
-        "Unsupported type for intermediate output");
-    event_tracer->log_intermediate_output_delegate(name, delegate_debug_id,
-                                                   output);
-  }
-#else //! ET_EVENT_TRACER_ENABLED
-  (void)name;
-  (void)delegate_debug_id;
-  (void)output;
-#endif
-}
-
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::event_tracer_end_profiling_delegate;
-using ::executorch::runtime::event_tracer_log_output_delegate;
-using ::executorch::runtime::event_tracer_log_profiling_delegate;
-using ::executorch::runtime::event_tracer_start_profiling_delegate;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/exec_aten/exec_aten.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/exec_aten/exec_aten.h
deleted file mode 100644
index db5096a46a..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/exec_aten/exec_aten.h
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <executorch/runtime/core/error.h>                 // @manual
-#include <executorch/runtime/core/result.h>                // @manual
-#include <executorch/runtime/core/tensor_shape_dynamism.h> // @manual
-#include <executorch/runtime/platform/assert.h>            // @manual
-#include <executorch/runtime/platform/compiler.h>
-#ifdef USE_ATEN_LIB
-#include <ATen/Tensor.h> // @manual
-#include <c10/core/Device.h>
-#include <c10/core/DeviceType.h>    // @manual
-#include <c10/core/Layout.h>        // @manual
-#include <c10/core/MemoryFormat.h>  // @manual
-#include <c10/core/Scalar.h>        // @manual
-#include <c10/util/ArrayRef.h>      // @manual
-#include <c10/util/BFloat16-math.h> // @manual
-#include <c10/util/BFloat16.h>      // @manual
-#include <c10/util/Half.h>          // @manual
-#include <c10/util/Optional.h>      // @manual
-#include <c10/util/complex.h>       // @manual
-#include <c10/util/qint32.h>        // @manual
-#include <c10/util/qint8.h>         // @manual
-#include <c10/util/quint2x4.h>      // @manual
-#include <c10/util/quint4x2.h>      // @manual
-#include <c10/util/quint8.h>        // @manual
-#include <c10/util/safe_numerics.h> // @manual
-#include <c10/util/string_view.h>   // @manual
-#include <torch/torch.h>
-#else                                                            // use executor
-#include <executorch/runtime/core/array_ref.h>                   // @manual
-#include <executorch/runtime/core/portable_type/bfloat16.h>      // @manual
-#include <executorch/runtime/core/portable_type/bfloat16_math.h> // @manual
-#include <executorch/runtime/core/portable_type/complex.h>       // @manual
-#include <executorch/runtime/core/portable_type/device.h>        // @manual
-#include <executorch/runtime/core/portable_type/half.h>          // @manual
-#include <executorch/runtime/core/portable_type/optional.h>      // @manual
-#include <executorch/runtime/core/portable_type/qint_types.h>    // @manual
-#include <executorch/runtime/core/portable_type/scalar.h>        // @manual
-#include <executorch/runtime/core/portable_type/scalar_type.h>   // @manual
-#include <executorch/runtime/core/portable_type/string_view.h>   // @manual
-#include <executorch/runtime/core/portable_type/tensor.h>        // @manual
-#include <executorch/runtime/core/portable_type/tensor_options.h> // @manual
-
-#endif
-
-/**
- * This hack is for separating out ATen mode vs non-ATen mode. In ATen mode,
- * we use the ATen types directly. In non-ATen mode, we use the portable types.
- * To avoid duplicate symbols and/or duplicate operator registration, when a
- * user depends on both the ATen mode and non-ATen mode versions of the
- * ExecuTorch library.
- */
-#ifndef ET_RUNTIME_NAMESPACE
-#if defined(USE_ATEN_LIB)
-#define ET_RUNTIME_NAMESPACE runtime::aten
-#else
-#define ET_RUNTIME_NAMESPACE runtime
-#endif
-#endif
-
-namespace executorch {
-namespace aten {
-
-using TensorShapeDynamism = executorch::runtime::TensorShapeDynamism;
-
-using std::nullopt;
-using std::nullopt_t;
-using std::optional;
-using std::string_view;
-
-#ifdef USE_ATEN_LIB
-
-using Tensor = at::Tensor;
-using TensorList = at::TensorList;
-using TensorImpl = at::TensorImpl;
-template <typename T> using ArrayRef = c10::ArrayRef<T>;
-using ScalarType = at::ScalarType;
-using Scalar = c10::Scalar;
-using MemoryFormat = c10::MemoryFormat;
-using SizesType = int64_t;
-using DimOrderType = uint8_t;
-using StridesType = int64_t;
-using Device = c10::Device;
-using DeviceType = c10::DeviceType;
-using Layout = c10::Layout;
-
-// Custom types that map to ScalarType
-using Half = c10::Half;
-template <typename T> using complex = c10::complex<T>;
-using qint8 = c10::qint8;
-using quint8 = c10::quint8;
-using qint32 = c10::qint32;
-using BFloat16 = c10::BFloat16;
-using quint4x2 = c10::quint4x2;
-using quint2x4 = c10::quint2x4;
-using IntArrayRef = at::IntArrayRef;
-
-template <typename T> using OptionalArrayRef = c10::OptionalArrayRef<T>;
-using OptionalIntArrayRef = OptionalArrayRef<int64_t>;
-
-inline ssize_t compute_numel(const SizesType *sizes, ssize_t dim) {
-  return static_cast<ssize_t>(
-      c10::multiply_integers(c10::ArrayRef<SizesType>(sizes, dim)));
-}
-
-inline ::executorch::runtime::Result<ssize_t> safe_numel(const SizesType *sizes,
-                                                         ssize_t dim) {
-  ET_CHECK_OR_RETURN_ERROR(dim == 0 || sizes != nullptr, InvalidArgument,
-                           "Sizes must be provided for non-scalar tensors");
-  ssize_t numel = 1;
-  for (ssize_t i = 0; i < dim; i++) {
-    ET_CHECK_OR_RETURN_ERROR(
-        sizes[i] >= 0, InvalidArgument,
-        "Size must be non-negative, got %zd at dimension %zd",
-        static_cast<ssize_t>(sizes[i]), i);
-    ssize_t next_numel;
-    ET_CHECK_OR_RETURN_ERROR(
-        !c10::mul_overflows(numel, static_cast<ssize_t>(sizes[i]), &next_numel),
-        InvalidArgument, "Overflow computing numel at dimension %zd", i);
-    numel = next_numel;
-  }
-  return numel;
-}
-
-#undef ET_PRI_TENSOR_SIZE
-#define ET_PRI_TENSOR_SIZE PRId64
-
-#undef ET_PRI_TENSOR_DIM
-#define ET_PRI_TENSOR_DIM PRId64
-
-#undef ET_PRI_TENSOR_NUMEL
-#define ET_PRI_TENSOR_NUMEL PRId64
-
-#undef ET_PRI_SIZES_AND_STRIDES
-#define ET_PRI_SIZES_AND_STRIDES PRId64
-
-#else // Use executor types
-
-using Tensor = torch::executor::Tensor;
-using TensorImpl = torch::executor::TensorImpl;
-template <typename T> using ArrayRef = torch::executor::ArrayRef<T>;
-using ScalarType = torch::executor::ScalarType;
-using TensorList = ArrayRef<Tensor>;
-using Scalar = torch::executor::Scalar;
-using MemoryFormat = torch::executor::MemoryFormat;
-using SizesType = torch::executor::Tensor::SizesType;
-using DimOrderType = torch::executor::Tensor::DimOrderType;
-using StridesType = torch::executor::Tensor::StridesType;
-using Device = torch::executor::Device;
-using DeviceType = torch::executor::DeviceType;
-using Layout = torch::executor::Layout;
-
-// Custom types that map to ScalarType
-using Half = torch::executor::Half;
-template <typename T> using complex = torch::executor::complex<T>;
-using qint8 = torch::executor::qint8;
-using quint8 = torch::executor::quint8;
-using qint32 = torch::executor::qint32;
-using BFloat16 = torch::executor::BFloat16;
-using quint4x2 = torch::executor::quint4x2;
-using quint2x4 = torch::executor::quint2x4;
-
-using IntArrayRef = torch::executor::IntArrayRef;
-
-template <typename T>
-using OptionalArrayRef =
-    torch::executor::optional<torch::executor::ArrayRef<T>>;
-using OptionalIntArrayRef = OptionalArrayRef<int64_t>;
-
-using torch::executor::compute_numel;
-using torch::executor::safe_numel;
-
-#endif // Use ExecuTorch types
-
-} // namespace aten
-} // namespace executorch
-
-// DEPRECATED: The exec_aten:: namespace is deprecated. Use executorch::aten::
-// instead.
-namespace exec_aten = executorch::aten;
-
-namespace torch {
-namespace executor {
-using TensorList = ::executorch::aten::TensorList;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/exec_aten/testing_util/tensor_factory.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/exec_aten/testing_util/tensor_factory.h
deleted file mode 100644
index 5e5ec3c541..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/exec_aten/testing_util/tensor_factory.h
+++ /dev/null
@@ -1,1069 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-#pragma once
-
-#include <algorithm>
-#include <cstdint>
-
-#include <c10/util/irange.h>
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <executorch/runtime/core/exec_aten/util/dim_order_util.h>
-#include <executorch/runtime/core/exec_aten/util/scalar_type_util.h>
-#include <executorch/runtime/core/tensor_shape_dynamism.h>
-#include <executorch/runtime/platform/assert.h>
-
-#ifdef USE_ATEN_LIB
-#include <ATen/ATen.h>
-#else // !USE_ATEN_LIB
-#include <memory>
-#include <numeric>
-#include <vector>
-#endif // !USE_ATEN_LIB
-
-namespace executorch {
-namespace runtime {
-namespace testing {
-
-namespace internal {
-
-/**
- * Returns the number of elements in the tensor, given the dimension
- * sizes, assuming contiguous data.
- */
-inline size_t sizes_to_numel(const std::vector<int32_t> &sizes) {
-  size_t n = 1;
-  for (auto s : sizes) {
-    n *= s;
-  }
-  return n;
-}
-
-/**
- * Check if given strides is legal under given sizes. In the `make` function,
- * the `strides` shall ensure:
- *  - a. strides.size() == sizes.size()
- *  - b. all strides are positive.
- *  - c. All underlying data be accessed.
- *  - d. All legal indexes can access an underlying data.
- *  - e. No two indexes access a same data.
- *  - f. No out of bounds data can be accessed.
- *
- * @param[in] sizes The sizes of the dimensions of the Tensor.
- * @param[in] strides The desired strides for creating new tensor.
- * @return The strides is legal or not
- */
-
-inline bool
-check_strides(const std::vector<int32_t> sizes,
-              const std::vector<executorch::aten::StridesType> strides) {
-  if (sizes.size() != strides.size()) {
-    // The length of stride vector shall equal to size vector.
-    return false;
-  }
-
-  if (strides.size() == 0) {
-    // Both sizes and strides are empty vector. Legal!
-    return true;
-  }
-
-  // Check if input non-empty strides is legal. The defination of legal is in
-  // the comment above function. To check it, we first reformat the strides into
-  // contiguous style, in where the strides should be sorted from high to low.
-  // Then rearrange the size based on same transformation. After that, we can
-  // check if strides[i] == strides[i + 1] * sizes[i + 1] for all i in
-  // [0, sizes.size() - 1) and strides[sizes.size() - 1] == 1
-
-  // Get the mapping between current strides and sorted strides (from high to
-  // low, if equal then check if correspond size is 1 or 0 in same dimension)
-  // e.g. a = tensor(3, 2, 1).permute(2, 1, 0), a.size() == (1, 2, 3) and
-  // a.strides == (1, 1, 2). We want to sort create a mapping to make the
-  // sorted_stride as (2, 1, 1) while sorted_size == (3, 2, 1)
-  std::vector<std::int32_t> sorted_idx(sizes.size());
-  for (const auto i : c10::irange(sizes.size())) {
-    sorted_idx[i] = i;
-  }
-  std::sort(sorted_idx.begin(), sorted_idx.end(),
-            [&](const int32_t &a, const int32_t &b) {
-              if (strides[a] != strides[b]) {
-                return strides[a] > strides[b];
-              } else {
-                // When strides equal to each other, put the index whose
-                // coresponding size equal to 0 or 1 to the right. Update the
-                // rule to the following comparsion to circumvent strict weak
-                // ordering.
-                return (sizes[a] ? sizes[a] : 1) > (sizes[b] ? sizes[b] : 1);
-              }
-            });
-
-  // Use the mapping to rearrange the sizes and strides
-  std::vector<std::int32_t> sorted_sizes(sizes.size());
-  std::vector<std::int32_t> sorted_strides(sizes.size());
-  for (const auto i : c10::irange(sizes.size())) {
-    sorted_sizes[i] = sizes[sorted_idx[i]] == 0 ? 1 : sizes[sorted_idx[i]];
-    sorted_strides[i] = strides[sorted_idx[i]];
-  }
-
-  // All strides should be positive. We have sorted it mainly based on strides,
-  // so sorted_strides[-1] has lowest value.
-  if (sorted_strides[strides.size() - 1] <= 0) {
-    return false;
-  }
-
-  // Check if strides is legal
-  bool legal = sorted_strides[strides.size() - 1] == 1;
-  for (size_t i = 0; i < strides.size() - 1 && legal; i++) {
-    legal = legal &&
-            (sorted_strides[i] == sorted_strides[i + 1] * sorted_sizes[i + 1]);
-  }
-
-  return legal;
-}
-
-/**
- * Check that a given dim order array is valid. A dim order array is valid if
- * each value from 0 to sizes.size() - 1 appears exactly once in the dim_order
- * array.
- */
-inline bool check_dim_order(const std::vector<int32_t> &sizes,
-                            const std::vector<uint8_t> &dim_order) {
-  if (sizes.size() != dim_order.size()) {
-    return false;
-  }
-  size_t gauss_sum = 0;
-  std::vector<int> count(dim_order.size(), 0);
-  for (const auto i : c10::irange(dim_order.size())) {
-    if (dim_order[i] >= sizes.size()) {
-      return false;
-    }
-    gauss_sum += static_cast<size_t>(dim_order[i]) + 1;
-  }
-  // Use the gaussian sum to verify each dim appears exactly once
-  size_t expected_sum = (sizes.size() * (sizes.size() + 1)) / 2;
-  if (gauss_sum != expected_sum) {
-    return false;
-  }
-
-  return true;
-}
-
-inline std::vector<executorch::aten::StridesType>
-strides_from_dim_order(const std::vector<int32_t> &sizes,
-                       const std::vector<uint8_t> &dim_order) {
-  bool legal = check_dim_order(sizes, dim_order);
-  ET_CHECK_MSG(legal, "The input dim_order variable is illegal.");
-
-  size_t ndim = sizes.size();
-  std::vector<executorch::aten::StridesType> strides(ndim);
-  strides[dim_order[ndim - 1]] = 1;
-  for (int i = ndim - 2; i >= 0; --i) {
-    uint8_t cur_dim = dim_order[i];
-    uint8_t next_dim = dim_order[i + 1];
-    strides[cur_dim] = (!sizes[next_dim]) ? strides[next_dim]
-                                          : strides[next_dim] * sizes[next_dim];
-  }
-  return strides;
-}
-
-inline std::vector<uint8_t> channels_last_dim_order(size_t dims) {
-  ET_CHECK_MSG(
-      dims >= 4 && dims <= 5,
-      "Channels last dim order only valid for 4-dim and 5-dim tensors!");
-
-  std::vector<uint8_t> dim_order(dims);
-  // Channels is always assigned to dim 1
-  dim_order[dims - 1] = 1;
-
-  dim_order[0] = 0;
-  int d = 1;
-  while (d < dims - 1) {
-    dim_order[d] = d + 1;
-    d++;
-  }
-  return dim_order;
-}
-
-} // namespace internal
-
-#ifdef USE_ATEN_LIB
-
-// Note that this USE_ATEN_LIB section uses ATen-specific namespaces instead of
-// exec_aten because we know that we're working with ATen, and many of these
-// names aren't mapped into executorch::aten::.
-
-namespace internal {
-
-// This wrapper lets us override the C type associated with some ScalarType
-// values while using the defaults for everything else.
-template <c10::ScalarType DTYPE> struct ScalarTypeToCppTypeWrapper {
-  using ctype = typename c10::impl::ScalarTypeToCPPTypeT<DTYPE>;
-};
-
-// Use a C type of `uint8_t` instead of `bool`. The C type will be used to
-// declare a `std::vector<CTYPE>`, and `std::vector<bool>` is often optimized to
-// store a single bit per entry instead of using an array of separate `bool`
-// elements. Since the tensor data will point into the vector, it needs to use
-// one byte per element.
-template <> struct ScalarTypeToCppTypeWrapper<c10::ScalarType::Bool> {
-  using ctype = uint8_t;
-};
-
-} // namespace internal
-
-template <at::ScalarType DTYPE> class TensorFactory {
-public:
-  /*
-   * The C types that backs the associated DTYPE. E.g., `float` for
-   * `ScalarType::Float`.
-   */
-
-  /**
-   * Used for the vector provided to the factory functions. May differ
-   * from the type usually associate with the ScalarType.
-   *
-   * Used for the vector<> parameters passed to the factory functions.
-   */
-  using ctype = typename internal::ScalarTypeToCppTypeWrapper<DTYPE>::ctype;
-
-  /**
-   * The official C type for the scalar type. Used when accessing elements
-   * of a constructed Tensor.
-   */
-  using true_ctype = typename c10::impl::ScalarTypeToCPPTypeT<DTYPE>;
-
-  TensorFactory() = default;
-
-  /**
-   * Returns a new Tensor with the specified shape, data and stride.
-   *
-   * @param[in] sizes The sizes of the dimensions of the Tensor.
-   * @param[in] data The data that the Tensor should be initialized with. The
-   *     size of this vector must be equal to the product of the elements of
-   *     `sizes`.
-   * @param[in] strides The strides for each dimensions of the Tensor. If empty
-   *     or not specificed, the function will return a contiguous tensor based
-   *     on data and size. If not, the strides shall follow the rules:
-   *            - a. strides.size() == sizes.size().
-   *            - b. all strides are positive.
-   *            - c. All underlying data be accessed.
-   *            - d. All legal indexes can access an underlying data.
-   *            - e. No two indexes access a same data.
-   *            - f. No out of bounds data can be accessed.
-   *
-   * @return A new Tensor with the specified shape and data.
-   */
-  at::Tensor make(const std::vector<int32_t> &sizes,
-                  const std::vector<ctype> &data,
-                  const std::vector<executorch::aten::StridesType> strides = {},
-                  ET_UNUSED TensorShapeDynamism dynamism =
-                      TensorShapeDynamism::DYNAMIC_UNBOUND) {
-    auto expected_numel = internal::sizes_to_numel(sizes);
-    ET_CHECK_MSG(expected_numel == data.size(),
-                 "Number of data elements %zd "
-                 "does not match expected number of elements %zd",
-                 data.size(), expected_numel);
-
-    at::Tensor t;
-    if (strides.empty()) {
-      t = zeros(sizes);
-    } else {
-      bool legal = internal::check_strides(sizes, strides);
-      ET_CHECK_MSG(legal, "The input strides variable is illegal.");
-
-      t = empty_strided(sizes, strides);
-    }
-    if (t.nbytes() > 0) {
-      std::transform(data.begin(), data.end(), t.template data<true_ctype>(),
-                     [](auto x) { return static_cast<true_ctype>(x); });
-    }
-    return t;
-  }
-
-  /**
-   * Returns a new Tensor with the specified shape, data and dim order.
-   *
-   * @param[in] sizes The sizes of the dimensions of the Tensor.
-   * @param[in] data The data that the Tensor should be initialized with. The
-   *     size of this vector must be equal to the product of the elements of
-   *     `sizes`.
-   * @param[in] dim_order The dim order describing how tensor memory is laid
-   * out. If empty or not specificed, the function will use a contiguous dim
-   * order of {0, 1, 2, 3, ...}
-   *
-   * @return A new Tensor with the specified shape and data.
-   */
-  at::Tensor make_with_dimorder(const std::vector<int32_t> &sizes,
-                                const std::vector<ctype> &data,
-                                const std::vector<uint8_t> dim_order = {},
-                                ET_UNUSED TensorShapeDynamism dynamism =
-                                    TensorShapeDynamism::DYNAMIC_UNBOUND) {
-    auto expected_numel = internal::sizes_to_numel(sizes);
-    ET_CHECK_MSG(expected_numel == data.size(),
-                 "Number of data elements %zd "
-                 "does not match expected number of elements %zd",
-                 data.size(), expected_numel);
-
-    at::Tensor t;
-    if (dim_order.empty()) {
-      t = zeros(sizes);
-    } else {
-      auto strides = internal::strides_from_dim_order(sizes, dim_order);
-      t = empty_strided(sizes, strides);
-    }
-    if (t.nbytes() > 0) {
-      std::transform(data.begin(), data.end(), t.template data<true_ctype>(),
-                     [](auto x) { return static_cast<true_ctype>(x); });
-    }
-    return t;
-  }
-
-  /**
-   * Returns a new Tensor with the specified shape and data in channels last
-   * memory layout.
-   *
-   * @param[in] sizes The sizes of the dimensions of the Tensor.
-   * @param[in] data The data that the Tensor should be initialized with. The
-   *     size of this vector must be equal to the product of the elements of
-   *     `sizes`.
-   *
-   * @return A new Tensor with the specified shape and data.
-   */
-  at::Tensor make_channels_last(const std::vector<int32_t> &sizes,
-                                const std::vector<ctype> &data,
-                                ET_UNUSED TensorShapeDynamism dynamism =
-                                    TensorShapeDynamism::DYNAMIC_UNBOUND) {
-    return make_with_dimorder(
-        sizes, data, internal::channels_last_dim_order(sizes.size()), dynamism);
-  }
-
-  /**
-   * Given data in contiguous memory format, returns a new Tensor with the
-   * specified shape and the same data but in channels last memory format.
-   *
-   * @param[in] sizes The sizes of the dimensions of the Tensor.
-   * @param[in] data The data in contiguous memory format that the Tensor should
-   * be initialized with. The size of this vector must be equal to the product
-   * of the elements of `sizes`.
-   *
-   * @return A new Tensor with the specified shape and data in channls last
-   * memory format.
-   */
-  at::Tensor channels_last_like(
-      const at::Tensor &input,
-      TensorShapeDynamism dynamism = TensorShapeDynamism::STATIC) {
-    ET_CHECK_MSG(input.sizes().size() == 4,
-                 "Only 4D tensors can be channels last");
-
-    const std::vector<int32_t> sizes(input.sizes().begin(),
-                                     input.sizes().end());
-
-    std::vector<uint8_t> contiguous_dim_order(sizes.size());
-    for (uint8_t i = 0; i < sizes.size(); i++) {
-      contiguous_dim_order[i] = i;
-    }
-    std::vector<executorch::aten::StridesType> contiguous_strides =
-        internal::strides_from_dim_order(sizes, contiguous_dim_order);
-
-    for (const auto i : c10::irange(input.dim())) {
-      ET_CHECK_MSG(input.strides()[i] == contiguous_strides[i],
-                   "Input tensor is not contiguous");
-    }
-
-    int32_t N = sizes[0];
-    int32_t C = sizes[1];
-    int32_t H = sizes[2];
-    int32_t W = sizes[3];
-
-    std::vector<ctype> contiguous_data(input.data_ptr<ctype>(),
-                                       input.data_ptr<ctype>() + input.numel());
-    std::vector<ctype> channels_last_data(
-        N * C * H * W); // Create a new blob with the same total size to contain
-                        // channels_last data
-    for (const auto n : c10::irange(N)) {
-      for (const auto c : c10::irange(C)) {
-        for (const auto h : c10::irange(H)) {
-          for (const auto w : c10::irange(W)) {
-            // Calculate the index in the original blob
-            int32_t old_index = ((n * C + c) * H + h) * W + w;
-            // Calculate the index in the new blob
-            int32_t new_index = ((n * H + h) * W + w) * C + c;
-            // Copy the data
-            channels_last_data[new_index] = contiguous_data[old_index];
-          }
-        }
-      }
-    }
-
-    return make_with_dimorder(sizes, channels_last_data,
-                              internal::channels_last_dim_order(sizes.size()),
-                              dynamism);
-  }
-
-  /**
-   * Returns a new Tensor with the specified shape, containing contiguous
-   * data will all elements set to `value`.
-   *
-   * @param[in] sizes The sizes of the dimensions of the Tensor.
-   * @param[in] value The value of all elements of the Tensor.
-   * @return A new Tensor with the specified shape.
-   */
-  at::Tensor full(const std::vector<int32_t> &sizes, ctype value,
-                  ET_UNUSED TensorShapeDynamism dynamism =
-                      TensorShapeDynamism::DYNAMIC_UNBOUND) {
-    auto sizes64 = vec_32_to_64(sizes);
-    return at::full(at::IntArrayRef(sizes64), value, at::dtype(DTYPE));
-  }
-
-  /**
-   * Returns a new Tensor with the specified shape, containing channels-last
-   * contiguous data will all elements set to `value`.
-   *
-   * @param[in] sizes The sizes of the dimensions of the Tensor.
-   * @param[in] value The value of all elements of the Tensor.
-   * @return A new Tensor with the specified shape.
-   */
-  at::Tensor full_channels_last(const std::vector<int32_t> &sizes, ctype value,
-                                ET_UNUSED TensorShapeDynamism dynamism =
-                                    TensorShapeDynamism::DYNAMIC_UNBOUND) {
-    auto sizes64 = vec_32_to_64(sizes);
-    return at::full(at::IntArrayRef(sizes64), value, at::dtype(DTYPE))
-        .to(at::MemoryFormat::ChannelsLast);
-  }
-
-  /**
-   * Returns a new Tensor with the specified shape, containing channels-last
-   * contiguous data with all `0` elements.
-   *
-   * @param[in] sizes The sizes of the dimensions of the Tensor.
-   * @return A new Tensor with the specified shape.
-   */
-  at::Tensor zeros(const std::vector<int32_t> &sizes,
-                   ET_UNUSED TensorShapeDynamism dynamism =
-                       TensorShapeDynamism::DYNAMIC_UNBOUND) {
-    auto sizes64 = vec_32_to_64(sizes);
-    return at::zeros(at::IntArrayRef(sizes64), at::dtype(DTYPE));
-  }
-
-  /**
-   * Returns a new Tensor with the specified shape, containing contiguous data
-   * with all `0` elements.
-   *
-   * @param[in] sizes The sizes of the dimensions of the Tensor.
-   * @return A new Tensor with the specified shape.
-   */
-  at::Tensor zeros_channels_last(const std::vector<int32_t> &sizes,
-                                 ET_UNUSED TensorShapeDynamism dynamism =
-                                     TensorShapeDynamism::DYNAMIC_UNBOUND) {
-    auto sizes64 = vec_32_to_64(sizes);
-    return at::zeros(at::IntArrayRef(sizes64), at::dtype(DTYPE))
-        .to(at::MemoryFormat::ChannelsLast);
-  }
-
-  /**
-   * Returns a new Tensor with the specified shape, containing contiguous data
-   * with all `1` elements.
-   *
-   * @param[in] sizes The sizes of the dimensions of the Tensor.
-   * @return A new Tensor with the specified shape.
-   */
-  at::Tensor ones(const std::vector<int32_t> &sizes,
-                  ET_UNUSED TensorShapeDynamism dynamism =
-                      TensorShapeDynamism::DYNAMIC_UNBOUND) {
-    auto sizes64 = vec_32_to_64(sizes);
-    return at::ones(at::IntArrayRef(sizes64), at::dtype(DTYPE));
-  }
-
-  /**
-   * Returns a new Tensor with the same shape as the input tensor, containing
-   * contiguous data with all `0` elements.
-   *
-   * @param[in] input The tensor that supplies the shape of the new Tensor.
-   * @return A new Tensor with the specified shape.
-   */
-  at::Tensor zeros_like(const at::Tensor &input,
-                        ET_UNUSED TensorShapeDynamism dynamism =
-                            TensorShapeDynamism::DYNAMIC_UNBOUND) {
-    std::vector<int64_t> sizes64 = {input.sizes().begin(), input.sizes().end()};
-    return at::full(at::IntArrayRef(sizes64), 0, at::dtype(DTYPE));
-  }
-
-  /**
-   * Returns a new Tensor with the same shape as the input tensor, containing
-   * contiguous data with all `1` elements.
-   *
-   * @param[in] input The tensor that supplies the shape of the new Tensor.
-   * @return A new Tensor with the specified shape.
-   */
-  at::Tensor ones_like(const at::Tensor &input,
-                       ET_UNUSED TensorShapeDynamism dynamism =
-                           TensorShapeDynamism::DYNAMIC_UNBOUND) {
-    std::vector<int64_t> sizes64 = {input.sizes().begin(), input.sizes().end()};
-    return at::full(at::IntArrayRef(sizes64), 1, at::dtype(DTYPE));
-  }
-
-private:
-  /// Copies an int32_t vector into a new int64_t vector.
-  static std::vector<int64_t> vec_32_to_64(const std::vector<int32_t> &in) {
-    std::vector<int64_t> out{};
-    out.reserve(in.size());
-    for (auto i : in) {
-      out.push_back(i);
-    }
-    return out;
-  }
-
-  /**
-   * Returns a new Tensor with the specified shape and stride.
-   *
-   * @param[in] sizes The sizes of the dimensions of the Tensor.
-   * @param[in] strides The strides for each dimensions of the Tensor
-   * @return A new Tensor with the specified shape and strides.
-   */
-  at::Tensor
-  empty_strided(const std::vector<int32_t> &sizes,
-                const std::vector<executorch::aten::StridesType> &strides,
-                ET_UNUSED TensorShapeDynamism dynamism =
-                    TensorShapeDynamism::DYNAMIC_UNBOUND) {
-    auto sizes64 = vec_32_to_64(sizes);
-    return at::empty_strided(sizes64, strides, DTYPE,
-                             /*layout_opt=*/at::Layout::Strided,
-                             /*device_opt=*/at::Device(at::DeviceType::CPU),
-                             /*pin_memory_opt=*/false);
-  }
-};
-
-#else // !USE_ATEN_LIB
-
-namespace {
-/*
- * Dimension order represents how dimensions are laid out in memory,
- * starting from the inner-most to the outer-most dimension.
- * Thus, the conversion from strides is done by sorting the strides
- * from larger to smaller since the dimension with the largest stride
- * is the outer-most and the dimension with the smallest stride is the
- inner-most.
- * For example, tensor with sizes = (3, 5, 2) and strides = (5, 1, 15), implies
- * dimension order of (2, 0, 1), because 2nd dimension has the biggest stride of
- 15,
- * followed by 0th dimension with stride of 5 and then innermost dimension being
- the 1st
- * dimension with size of 1. This order of (2, 0, 1) can be obtained
- * by sorting strides from large to smaller.
-
- * When strides do not convey dimension order unambiguously, dimension order
- * returned is dependent on stability of sort. We employ stable sort to preserve
- * original order. Thus when strides = (4, 3, 1, 1) returned value is (0, 1, 2,
- 3)
- * Another example is: sizes = (1, 3, 1, 1) with strides = (3, 1, 3, 3),
- returned
- * value is (0, 2, 3, 1)
-*/
-// copied from
-// https://stackoverflow.com/questions/1577475/c-sorting-and-keeping-track-of-indexes
-// TODO: Add assert for strides[i] != 0 because strides of 0 is really used,
-// by pytorch/aten, to convey broadcasting dim.
-
-inline std::vector<uint8_t>
-dim_order_from_stride(const std::vector<int32_t> &v) {
-  std::vector<uint8_t> indices(v.size());
-  std::iota(indices.begin(), indices.end(), 0);
-  stable_sort(indices.begin(), indices.end(),
-              [&v](size_t i1, size_t i2) { return v[i1] > v[i2]; });
-  return indices;
-}
-
-inline void validate_strides(const std::vector<int32_t> &sizes,
-                             const std::vector<int32_t> &strides) {
-  if (sizes.size() != strides.size()) {
-    ET_CHECK_MSG(false, "Stride and sizes are not equal in length");
-  }
-  for (const auto &s : strides) {
-    if (s == 0) {
-      ET_CHECK_MSG(false, "Stride value of 0 is not supported");
-    }
-  }
-  // No two dimensions can have same stride value
-  for (const auto i : c10::irange(strides.size())) {
-    for (int32_t j = i + 1; j < strides.size(); ++j) {
-      if ((sizes[i] == 0) || (sizes[j] == 0) ||
-          ((sizes[i] == 1) || (sizes[j] == 1))) {
-        continue;
-      }
-      if ((strides[i] == strides[j])) {
-        ET_CHECK_MSG(false,
-                     "Stride value and size dont comply at index %d."
-                     " strides[%d]: %d, strides[%d] = %d, sizes[%d] = %d, "
-                     "sizes[%d] = %d",
-                     static_cast<uint32_t>(i), static_cast<uint32_t>(i),
-                     strides[i], j, strides[j], static_cast<uint32_t>(i),
-                     sizes[i], j, sizes[j]);
-      }
-    }
-  }
-}
-
-} // namespace
-
-// Note that this !USE_ATEN_LIB section uses ExecuTorch-specific namespaces
-// instead of exec_aten to make it clear that we're dealing with ETensor, and
-// because many of these names aren't mapped into executorch::aten::.
-
-namespace internal {
-
-// This wrapper lets us override the C type associated with some ScalarType
-// values while using the defaults for everything else.
-template <torch::executor::ScalarType DTYPE> struct ScalarTypeToCppTypeWrapper {
-  using ctype =
-      typename ::executorch::runtime::ScalarTypeToCppType<DTYPE>::type;
-};
-
-// Use a C type of `uint8_t` instead of `bool`. The C type will be used to
-// declare a `std::vector<CTYPE>`, and `std::vector<bool>` is often optimized to
-// store a single bit per entry instead of using an array of separate `bool`
-// elements. Since the tensor data will point into the vector, it needs to use
-// one byte per element.
-template <>
-struct ScalarTypeToCppTypeWrapper<torch::executor::ScalarType::Bool> {
-  using ctype = uint8_t;
-};
-
-// Use a C type of `uint16_t` instead of `Bits16` to simplify code reuse when
-// testing multiple integer types.
-template <>
-struct ScalarTypeToCppTypeWrapper<torch::executor::ScalarType::Bits16> {
-  using ctype = uint16_t;
-};
-
-// Use a C type of `uint16_t` instead of `UInt16` to simplify code reuse when
-// testing multiple integer types.
-template <>
-struct ScalarTypeToCppTypeWrapper<torch::executor::ScalarType::UInt16> {
-  using ctype = uint16_t;
-};
-
-// To allow implicit conversion between simple types to `ctype`
-#define SPECIALIZE_ScalarTypeToCppTypeWrapper(CTYPE, DTYPE)                    \
-  template <>                                                                  \
-  struct ScalarTypeToCppTypeWrapper<torch::executor::ScalarType::DTYPE> {      \
-    using ctype = typename CTYPE::underlying;                                  \
-  };
-
-ET_FORALL_QINT_TYPES(SPECIALIZE_ScalarTypeToCppTypeWrapper)
-
-#undef SPECIALIZE_ScalarTypeToCppTypeWrapper
-
-} // namespace internal
-
-/**
- * A helper class for creating Tensors, simplifying memory management.
- *
- * NOTE: A given TensorFactory instance owns the memory pointed to by all
- * Tensors that it creates, and must live longer than those Tensors.
- *
- * Example:
- * @code{.cpp}
- * // A factory instance will create Tensors of a single dtype.
- * TensorFactory<ScalarType::Int> tf;
- *
- * // You can create more factories if you need tensors of multiple
- * // dtypes.
- * TensorFactory<ScalarType::Float> tf_float;
- *
- * // The factory will copy the vectors provided to it, letting callers provide
- * // inline literals.
- * Tensor t1 = tf.make(
- *     {2, 2}, // sizes
- *     {1, 2, 3, 4}); // data
- *
- * // There are helpers for creating Tensors with all 1 or 0 elements.
- * Tensor z = tf.zeros({2, 2});
- * Tensor o = tf_float.ones({2, 2});
- *
- * // Sometimes it's helpful to share parameters.
- * std::vector<int32_t> sizes = {2, 2};
- * Tensor t3 = tf.make(sizes, {1, 2, 3, 4});
- * Tensor t4 = tf.ones(sizes);
- *
- * // But remember that the inputs are copied, so providing the same data vector
- * // to two Tensors will not share the same underlying data.
- * std::vector<int> data = {1, 2, 3, 4};
- * Tensor t5 = tf.make(sizes, data);
- * Tensor t6 = tf.make(sizes, data);
- * t5.mutable_data_ptr<int>()[0] = 99;
- * EXPECT_NE(t5, t6);
- * @endcode
- *
- * @tparam DTYPE The dtype of Tensors created by this factory, as a ScalarType
- *     value like `ScalarType::Int`.
- */
-template <torch::executor::ScalarType DTYPE> class TensorFactory {
-public:
-  /**
-   * The C type that backs the associated DTYPE. E.g., `float` for
-   * `ScalarType::Float`.
-   */
-  using ctype = typename internal::ScalarTypeToCppTypeWrapper<DTYPE>::ctype;
-
-  /**
-   * The official C type for the scalar type. Used when accessing elements
-   * of a constructed Tensor.
-   */
-  using true_ctype =
-      typename executorch::runtime::ScalarTypeToCppType<DTYPE>::type;
-
-  TensorFactory() = default;
-
-  /**
-   * Returns a new Tensor with the specified shape, data and stride.
-   *
-   * @param[in] sizes The sizes of the dimensions of the Tensor.
-   * @param[in] data The data that the Tensor should be initialized with. The
-   *     size of this vector must be equal to the product of the elements of
-   *     `sizes`.
-   * @param[in] strides The strides for each dimensions of the Tensor. If empty
-   *     or not specificed, the function will return a contiguous tensor based
-   *     on data and size. If not, the strides shall follow the rules:
-   *            - a. strides.size() == sizes.size().
-   *            - b. all strides are positive.
-   *            - c. All underlying data be accessed.
-   *            - d. All legal indexes can access an underlying data.
-   *            - e. No two indexes access a same data.
-   *            - f. No out of bounds data can be accessed.
-   *
-   * @return A new Tensor with the specified shape and data.
-   */
-  torch::executor::Tensor
-  make(const std::vector<int32_t> &sizes, const std::vector<ctype> &data,
-       const std::vector<executorch::aten::StridesType> strides = {},
-       TensorShapeDynamism dynamism = TensorShapeDynamism::STATIC) {
-    std::vector<int32_t> default_strides;
-    // Generate strides from the tensor dimensions, assuming contiguous data if
-    // given strides is empty.
-    if (!sizes.empty() && strides.empty()) {
-      default_strides.resize(sizes.size(), 1);
-      for (size_t i = sizes.size() - 1; i > 0; --i) {
-        // For sizes[i] == 0, treat it as 1 to be consistent with core Pytorch
-        auto sizes_i = sizes[i] ? sizes[i] : 1;
-        default_strides[i - 1] = default_strides[i] * sizes_i;
-      }
-    }
-    auto &actual_strides = default_strides.empty() ? strides : default_strides;
-    validate_strides(sizes, actual_strides);
-    auto dim_order = dim_order_from_stride(actual_strides);
-
-    auto expected_numel = internal::sizes_to_numel(sizes);
-    ET_CHECK_MSG(expected_numel == data.size(),
-                 "Number of data elements %zd "
-                 "does not match expected number of elements %zd",
-                 data.size(), expected_numel);
-
-    bool legal = internal::check_strides(sizes, actual_strides);
-    ET_CHECK_MSG(legal, "The input strides variable is illegal.");
-
-    memory_.emplace_back(std::make_unique<TensorMemory>(
-        sizes, data, dim_order, actual_strides, dynamism));
-    return torch::executor::Tensor(&memory_.back()->impl_);
-  }
-
-  /**
-   * Returns a new Tensor with the specified shape, data and dim order.
-   *
-   * @param[in] sizes The sizes of the dimensions of the Tensor.
-   * @param[in] data The data that the Tensor should be initialized with. The
-   *     size of this vector must be equal to the product of the elements of
-   *     `sizes`.
-   * @param[in] dim_order The dim order describing how tensor memory is laid
-   * out. If empty or not specificed, the function will use a contiguous dim
-   * order of {0, 1, 2, 3, ...}
-   *
-   * @return A new Tensor with the specified shape and data.
-   */
-  torch::executor::Tensor make_with_dimorder(
-      const std::vector<int32_t> &sizes, const std::vector<ctype> &data,
-      const std::vector<uint8_t> dim_order = {},
-      TensorShapeDynamism dynamism = TensorShapeDynamism::STATIC) {
-    std::vector<uint8_t> default_dim_order;
-    // Generate strides from the tensor dimensions, assuming contiguous data if
-    // given strides is empty.
-    if (!sizes.empty() && dim_order.empty()) {
-      default_dim_order.resize(sizes.size(), 1);
-      for (const auto i : c10::irange(sizes.size())) {
-        default_dim_order[i] = i;
-      }
-    }
-    auto &actual_dim_order =
-        default_dim_order.empty() ? dim_order : default_dim_order;
-
-    auto strides = internal::strides_from_dim_order(sizes, actual_dim_order);
-
-    auto expected_numel = internal::sizes_to_numel(sizes);
-    ET_CHECK_MSG(expected_numel == data.size(),
-                 "Number of data elements %zd "
-                 "does not match expected number of elements %zd",
-                 data.size(), expected_numel);
-
-    memory_.emplace_back(std::make_unique<TensorMemory>(
-        sizes, data, actual_dim_order, strides, dynamism));
-    return torch::executor::Tensor(&memory_.back()->impl_);
-  }
-
-  /**
-   * Returns a new Tensor with the specified shape and data in channels last
-   * memory format.
-   *
-   * @param[in] sizes The sizes of the dimensions of the Tensor.
-   * @param[in] data The data that the Tensor should be initialized with. The
-   *     size of this vector must be equal to the product of the elements of
-   *     `sizes`.
-   *
-   * @return A new Tensor with the specified shape and data.
-   */
-  torch::executor::Tensor make_channels_last(
-      const std::vector<int32_t> &sizes, const std::vector<ctype> &data,
-      const std::vector<uint8_t> dim_order = {},
-      TensorShapeDynamism dynamism = TensorShapeDynamism::STATIC) {
-    return make_with_dimorder(
-        sizes, data, internal::channels_last_dim_order(sizes.size()), dynamism);
-  }
-
-  /**
-   * Given data in contiguous memory format, returns a new Tensor with the
-   * specified shape and the same data but in channels last memory format.
-   *
-   * @param[in] sizes The sizes of the dimensions of the Tensor.
-   * @param[in] data The data in contiguous memory format that the Tensor should
-   * be initialized with. The size of this vector must be equal to the product
-   * of the elements of `sizes`.
-   *
-   * @return A new Tensor with the specified shape and data in channls last
-   * memory format.
-   */
-  torch::executor::Tensor channels_last_like(
-      const torch::executor::Tensor &input,
-      TensorShapeDynamism dynamism = TensorShapeDynamism::STATIC) {
-    const std::vector<int32_t> sizes(input.sizes().begin(),
-                                     input.sizes().end());
-
-    ET_CHECK_MSG(sizes.size() == 4, "Only 4D tensors can be channels last");
-    ET_CHECK_MSG(
-        is_contiguous_dim_order(input.dim_order().data(), input.dim()) == true,
-        "Input tensor is not contiguous");
-    int32_t N = sizes[0];
-    int32_t C = sizes[1];
-    int32_t H = sizes[2];
-    int32_t W = sizes[3];
-
-    std::vector<ctype> contiguous_data(input.data_ptr<ctype>(),
-                                       input.data_ptr<ctype>() + input.numel());
-    std::vector<ctype> channels_last_data(
-        N * C * H * W); // Create a new blob with the same total size to contain
-                        // channels_last data
-    for (const auto n : c10::irange(N)) {
-      for (const auto c : c10::irange(C)) {
-        for (const auto h : c10::irange(H)) {
-          for (const auto w : c10::irange(W)) {
-            // Calculate the index in the original blob
-            int32_t old_index = ((n * C + c) * H + h) * W + w;
-            // Calculate the index in the new blob
-            int32_t new_index = ((n * H + h) * W + w) * C + c;
-            // Copy the data
-            channels_last_data[new_index] = contiguous_data[old_index];
-          }
-        }
-      }
-    }
-
-    return make_with_dimorder(sizes, channels_last_data,
-                              internal::channels_last_dim_order(sizes.size()),
-                              dynamism);
-  }
-
-  /**
-   * Returns a new Tensor with the specified shape, containing contiguous data
-   * will all elements set to `value`.
-   *
-   * @param[in] sizes The sizes of the dimensions of the Tensor.
-   * @param[in] value The value of all elements of the Tensor.
-   * @return A new Tensor with the specified shape.
-   */
-  torch::executor::Tensor
-  full(const std::vector<int32_t> &sizes, ctype value,
-       TensorShapeDynamism dynamism = TensorShapeDynamism::STATIC) {
-    std::vector<ctype> data(internal::sizes_to_numel(sizes), value);
-    return make(sizes, data, /* empty strides */ {}, dynamism);
-  }
-
-  /**
-   * Returns a new Tensor with the specified shape, containing channels last
-   * contiguous data will all elements set to `value`.
-   *
-   * @param[in] sizes The sizes of the dimensions of the Tensor.
-   * @param[in] value The value of all elements of the Tensor.
-   * @return A new Tensor with the specified shape.
-   */
-  torch::executor::Tensor full_channels_last(
-      const std::vector<int32_t> &sizes, ctype value,
-      TensorShapeDynamism dynamism = TensorShapeDynamism::STATIC) {
-    std::vector<ctype> data(internal::sizes_to_numel(sizes), value);
-    return make_with_dimorder(
-        sizes, data, internal::channels_last_dim_order(sizes.size()), dynamism);
-  }
-
-  /**
-   * Returns a new Tensor with the specified shape, containing contiguous data
-   * in channels last memory format with all `0` elements.
-   *
-   * @param[in] sizes The sizes of the dimensions of the Tensor.
-   * @return A new Tensor with the specified shape.
-   */
-  torch::executor::Tensor zeros_channels_last(
-      const std::vector<int32_t> &sizes,
-      TensorShapeDynamism dynamism = TensorShapeDynamism::STATIC) {
-    return full_channels_last(sizes, 0, dynamism);
-  }
-
-  /**
-   * Returns a new Tensor with the specified shape, containing contiguous data
-   * in contiguous memory format with all `0` elements.
-   *
-   * @param[in] sizes The sizes of the dimensions of the Tensor.
-   * @return A new Tensor with the specified shape.
-   */
-  torch::executor::Tensor
-  zeros(const std::vector<int32_t> &sizes,
-        TensorShapeDynamism dynamism = TensorShapeDynamism::STATIC) {
-    return full(sizes, 0, dynamism);
-  }
-
-  /**
-   * Returns a new Tensor with the specified shape, containing contiguous data
-   * with all `1` elements.
-   *
-   * @param[in] sizes The sizes of the dimensions of the Tensor.
-   * @return A new Tensor with the specified shape.
-   */
-  torch::executor::Tensor
-  ones(const std::vector<int32_t> &sizes,
-       TensorShapeDynamism dynamism = TensorShapeDynamism::STATIC) {
-    return full(sizes, 1, dynamism);
-  }
-
-  /**
-   * Returns a new Tensor with the same shape as the input tensor, containing
-   * contiguous data with all `0` elements.
-   *
-   * @param[in] input The tensor that supplies the shape of the new Tensor.
-   * @return A new Tensor with the specified shape.
-   */
-  torch::executor::Tensor
-  zeros_like(const torch::executor::Tensor &input,
-             TensorShapeDynamism dynamism = TensorShapeDynamism::STATIC) {
-    std::vector<int32_t> sizes = {input.sizes().begin(), input.sizes().end()};
-    return full(sizes, 0, dynamism);
-  }
-
-  /**
-   * Returns a new Tensor with the same shape as the input tensor, containing
-   * contiguous data with all `1` elements.
-   *
-   * @param[in] input The tensor that supplies the shape of the new Tensor.
-   * @return A new Tensor with the specified shape.
-   */
-  torch::executor::Tensor
-  ones_like(const torch::executor::Tensor &input,
-            TensorShapeDynamism dynamism = TensorShapeDynamism::STATIC) {
-    std::vector<int32_t> sizes = {input.sizes().begin(), input.sizes().end()};
-    return full(sizes, 1, dynamism);
-  }
-
-private:
-  /**
-   * Owns all backing memory for a single Tensor.
-   */
-  struct TensorMemory {
-    TensorMemory(const std::vector<int32_t> &sizes,
-                 const std::vector<ctype> &data,
-                 const std::vector<uint8_t> &dim_order,
-                 const std::vector<int32_t> &strides,
-                 TensorShapeDynamism dynamism = TensorShapeDynamism::STATIC)
-        : sizes_(sizes), data_(data), dim_order_(dim_order), strides_(strides),
-          impl_(DTYPE,
-                /*dim=*/sizes_.size(), sizes_.data(), data_.data(),
-                dim_order_.data(), strides_.data(), dynamism) {
-      // The only valid values for bool are 0 and 1; coerce!
-      if constexpr (std::is_same_v<true_ctype, bool>) {
-        for (auto &x : data_) {
-          x = static_cast<true_ctype>(x);
-        }
-      }
-    }
-
-    std::vector<int32_t> sizes_;
-    std::vector<ctype> data_;
-    std::vector<uint8_t> dim_order_;
-    std::vector<executorch::aten::StridesType> strides_;
-    torch::executor::TensorImpl impl_;
-  };
-
-  /**
-   * The memory pointed to by Tensors created by this factory. This is a vector
-   * of pointers so that the TensorMemory objects won't move if the vector needs
-   * to resize/realloc.
-   */
-  std::vector<std::unique_ptr<TensorMemory>> memory_;
-};
-
-#endif // !USE_ATEN_LIB
-
-/**
- * A helper class for creating TensorLists, simplifying memory management.
- *
- * NOTE: A given TensorListFactory owns the memory pointed to by all TensorLists
- * (and Tensors they contain), and must live longer than those TensorLists and
- * Tensors.
- */
-template <executorch::aten::ScalarType DTYPE> class TensorListFactory final {
-public:
-  TensorListFactory() = default;
-  ~TensorListFactory() = default;
-
-  /**
-   * Returns a TensorList containing Tensors with the same shapes as the
-   * provided Tensors, but filled with zero elements. The dtypes of the template
-   * entries are ignored.
-   */
-  executorch::aten::TensorList
-  zeros_like(const std::vector<executorch::aten::Tensor> &templates) {
-    memory_.emplace_back(
-        std::make_unique<std::vector<executorch::aten::Tensor>>());
-    auto &vec = memory_.back();
-    std::for_each(templates.begin(), templates.end(),
-                  [&](const executorch::aten::Tensor &t) {
-                    vec->push_back(tf_.zeros_like(t));
-                  });
-    return executorch::aten::TensorList(vec->data(), vec->size());
-  }
-
-private:
-  TensorFactory<DTYPE> tf_;
-  /**
-   * The memory pointed to by TensorLists created by this factory. This is a
-   * vector of pointers so that the elements won't move if the vector needs to
-   * resize/realloc.
-   */
-  std::vector<std::unique_ptr<std::vector<executorch::aten::Tensor>>> memory_;
-};
-
-} // namespace testing
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-namespace testing {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::testing::TensorFactory;
-using ::executorch::runtime::testing::TensorListFactory;
-} // namespace testing
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/exec_aten/testing_util/tensor_util.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/exec_aten/testing_util/tensor_util.h
deleted file mode 100644
index 3adb5a74cf..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/exec_aten/testing_util/tensor_util.h
+++ /dev/null
@@ -1,362 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <gmock/gmock.h> // For MATCHER_P
-
-#include <optional>
-
-namespace executorch {
-namespace runtime {
-namespace testing {
-
-namespace internal {
-constexpr double kDefaultRtol = 1e-5;
-constexpr double kDefaultAtol = 1e-8;
-// Per
-// https://en.wikipedia.org/wiki/Half-precision_floating-point_format,
-// float16 has about 3.3 digits of precision.
-constexpr double kDefaultHalfAtol = 1e-3;
-
-// Following similar reasoning to float16, BFloat16 has
-// math.log10(2**8) = 2.4 digits of precision.
-constexpr double kDefaultBFloat16Atol = 1e-2;
-} // namespace internal
-
-/**
- *  Returns true if the tensors are of the same shape and dtype, and if all
- * elements are close to each other.
- *
- * TODO(T132992348): This function will currently fail an ET_CHECK if the
- * strides of the tensors are not identical. Add support for comparing
- * tensors with different strides.
- *
- * Note that gtest users can write `EXPECT_THAT(tensor1, IsCloseTo(tensor2))` or
- * `EXPECT_THAT(tensor1, Not(IsCloseTo(tensor2)))`, or use the helper macros
- * `EXPECT_TENSOR_CLOSE()` and `EXPECT_TENSOR_NOT_CLOSE()`.
- *
- * For exact equality, use `EXPECT_THAT(tensor1, IsEqualTo(tensor2))` or
- * `EXPECT_THAT(tensor1, Not(IsEqualTo(tensor2)))`, or the helper macros
- * `EXPECT_TENSOR_EQ()` and `EXPECT_TENSOR_NE()`.
- *
- * An element A is close to B when one is true:
- *
- * (1) A is equal to B.
- * (2) A and B are both NaN, are both -infinity, or are both +infinity.
- * (3) The error abs(A - B) is finite and less than the max error
- *     (atol + abs(rtol * B)).
- *
- * If both rtol/atol are zero, this function checks for exact equality.
- *
- * NOTE: rtol/atol are ignored and treated as zero for non-floating-point
- * dtypes.
- *
- * @param[in] a The first tensor to compare.
- * @param[in] b The second tensor to compare.
- * @param[in] rtol Relative tolerance; see note above.
- * @param[in] atol Absolute tolerance; see note above.
- * @retval true All corresponding elements of the two tensors are within the
- *     specified tolerance of each other.
- * @retval false One or more corresponding elements of the two tensors are
- *     outside of the specified tolerance of each other.
- */
-bool tensors_are_close(const executorch::aten::Tensor &a,
-                       const executorch::aten::Tensor &b,
-                       double rtol = internal::kDefaultRtol,
-                       std::optional<double> opt_atol = std::nullopt);
-
-/**
- * Returns true if the tensors are of the same numel and dtype, and if all
- * elements are close to each other. The tensor shapes do not need to be same.
- *
- * Note that gtest users can write `EXPECT_THAT(tensor1,
- * IsDataCloseTo(tensor2))` or `EXPECT_THAT(tensor1,
- * Not(IsDataCloseTo(tensor2)))`, or use the helper macros
- * `EXPECT_TENSOR_DATA_CLOSE()` and `EXPECT_TENSOR_DATA_NOT_CLOSE()`.
- *
- * For exact equality, use `EXPECT_THAT(tensor1, IsDataEqualTo(tensor2))` or
- * `EXPECT_THAT(tensor1, Not(IsDataEqualTo(tensor2)))`, or the helper macros
- * `EXPECT_TENSOR_DATA_EQ()` and `EXPECT_TENSOR_DATA_NE()`.
- *
- * The defination of an element A is close to B is in the comment of the
- * function `tensors_are_close`
- *
- * @param[in] a The first tensor to compare.
- * @param[in] b The second tensor to compare.
- * @param[in] rtol Relative tolerance; see note above.
- * @param[in] atol Absolute tolerance; see note above.
- * @retval true All corresponding elements of the two tensors are within the
- *     specified tolerance of each other.
- * @retval false One or more corresponding elements of the two tensors are
- *     outside of the specified tolerance of each other.
- */
-bool tensor_data_is_close(const executorch::aten::Tensor &a,
-                          const executorch::aten::Tensor &b,
-                          double rtol = internal::kDefaultRtol,
-                          std::optional<double> opt_atol = std::nullopt);
-
-/**
- * Returns true if the two lists are of the same length, and
- * tensor_data_is_close(tensors_a[i], tensors_b[i], rtol, atol) is true for all
- * i.
- */
-bool tensor_lists_are_close(const executorch::aten::Tensor *tensors_a,
-                            size_t num_tensors_a,
-                            const executorch::aten::Tensor *tensors_b,
-                            size_t num_tensors_b,
-                            double rtol = internal::kDefaultRtol,
-                            std::optional<double> opt_atol = std::nullopt);
-
-/**
- * Lets gtest users write `EXPECT_THAT(tensor1, IsCloseTo(tensor2))` or
- * `EXPECT_THAT(tensor1, Not(IsCloseTo(tensor2)))`.
- *
- * See also `EXPECT_TENSOR_CLOSE()` and `EXPECT_TENSOR_NOT_CLOSE()`.
- */
-MATCHER_P(IsCloseTo, other, "") { return tensors_are_close(arg, other); }
-
-/**
- * Lets gtest users write
- * `EXPECT_THAT(tensor1, IsCloseToWithTol(tensor2, rtol, atol))`
- * or `EXPECT_THAT(tensor1, Not(IsCloseToWithTol(tensor2, rtol, atol)))`.
- *
- * See also `EXPECT_TENSOR_CLOSE_WITH_TOL()` and
- * `EXPECT_TENSOR_NOT_CLOSE_WITH_TOL()`.
- */
-MATCHER_P3(IsCloseToWithTol, other, rtol, atol, "") {
-  return tensors_are_close(arg, other, rtol, atol);
-}
-
-/**
- * Lets gtest users write `EXPECT_THAT(tensor1, IsEqualTo(tensor2))` or
- * `EXPECT_THAT(tensor1, Not(IsEqualTo(tensor2)))`.
- *
- * See also `EXPECT_TENSOR_EQ()` and `EXPECT_TENSOR_NE()`.
- */
-MATCHER_P(IsEqualTo, other, "") {
-  return tensors_are_close(arg, other, /*rtol=*/0, /*atol=*/0);
-}
-
-/**
- * Lets gtest users write `EXPECT_THAT(tensor1, IsDataCloseTo(tensor2))` or
- * `EXPECT_THAT(tensor1, Not(IsDataCloseTo(tensor2)))`.
- *
- * See also `EXPECT_TENSOR_DATA_CLOSE()` and `EXPECT_TENSOR_DATA_NOT_CLOSE()`.
- */
-MATCHER_P(IsDataCloseTo, other, "") { return tensor_data_is_close(arg, other); }
-
-/**
- * Lets gtest users write
- * `EXPECT_THAT(tensor1, IsDataCloseToWithTol(tensor2, rtol, atol))`
- * or `EXPECT_THAT(tensor1, Not(IsDataCloseToWithTol(tensor2, rtol, atol)))`.
- *
- * See also `EXPECT_TENSOR_CLOSE_WITH_TOL()` and
- * `EXPECT_TENSOR_NOT_CLOSE_WITH_TOL()`.
- */
-MATCHER_P3(IsDataCloseToWithTol, other, rtol, atol, "") {
-  return tensor_data_is_close(arg, other, rtol, atol);
-}
-
-/**
- * Lets gtest users write `EXPECT_THAT(tensor1, IsDataEqualTo(tensor2))` or
- * `EXPECT_THAT(tensor1, Not(IsDataEqualTo(tensor2)))`.
- *
- * See also `EXPECT_TENSOR_DATA_EQ()` and `EXPECT_TENSOR_DATA_NE()`.
- */
-MATCHER_P(IsDataEqualTo, other, "") {
-  return tensor_data_is_close(arg, other, /*rtol=*/0, /*atol=*/0);
-}
-
-/**
- * Lets gtest users write `EXPECT_THAT(tensor_list1,
- * IsListCloseTo(tensor_list2))` or `EXPECT_THAT(tensor_list1,
- * Not(IsListCloseTo(tensor_list2)))`.
- *
- * The lists can be any container of Tensor that supports ::data() and ::size().
- *
- * See also `EXPECT_TENSOR_LISTS_CLOSE()` and `EXPECT_TENSOR_LISTS_NOT_CLOSE()`.
- */
-MATCHER_P(IsListCloseTo, other, "") {
-  return tensor_lists_are_close(arg.data(), arg.size(), other.data(),
-                                other.size());
-}
-
-/**
- * Lets gtest users write `EXPECT_THAT(tensor_list1,
- * IsListEqualTo(tensor_list2))` or `EXPECT_THAT(tensor_list1,
- * Not(IsListEqualTo(tensor_list2)))`.
- *
- * The lists can be any container of Tensor that supports ::data() and ::size().
- *
- * See also `EXPECT_TENSOR_LISTS_EQ()` and `EXPECT_TENSOR_LISTS_NE()`.
- */
-MATCHER_P(IsListEqualTo, other, "") {
-  return tensor_lists_are_close(arg.data(), arg.size(), other.data(),
-                                other.size(),
-                                /*rtol=*/0,
-                                /*atol=*/0);
-}
-
-/*
- * NOTE: Although it would be nice to make `EXPECT_EQ(t1, t2)` and friends work,
- * that would require implementing `bool operator==(Tensor, Tensor)`.
- *
- * at::Tensor implements `Tensor operator==(Tensor, Tensor)`, returning an
- * element-by-element comparison. This causes an ambiguous conflict with the
- * `bool`-returning operator.
- */
-#define EXPECT_TENSOR_EQ(t1, t2)                                               \
-  EXPECT_THAT((t1), ::executorch::runtime::testing::IsEqualTo(t2))
-#define EXPECT_TENSOR_NE(t1, t2)                                               \
-  EXPECT_THAT((t1), ::testing::Not(executorch::runtime::testing::IsEqualTo(t2)))
-#define ASSERT_TENSOR_EQ(t1, t2)                                               \
-  ASSERT_THAT((t1), ::executorch::runtime::testing::IsEqualTo(t2))
-#define ASSERT_TENSOR_NE(t1, t2)                                               \
-  ASSERT_THAT((t1), ::testing::Not(executorch::runtime::testing::IsEqualTo(t2)))
-
-#define EXPECT_TENSOR_CLOSE(t1, t2)                                            \
-  EXPECT_THAT((t1), ::executorch::runtime::testing::IsCloseTo(t2))
-#define EXPECT_TENSOR_NOT_CLOSE(t1, t2)                                        \
-  EXPECT_THAT((t1), ::testing::Not(executorch::runtime::testing::IsCloseTo(t2)))
-#define ASSERT_TENSOR_CLOSE(t1, t2)                                            \
-  ASSERT_THAT((t1), ::executorch::runtime::testing::IsCloseTo(t2))
-#define ASSERT_TENSOR_NOT_CLOSE(t1, t2)                                        \
-  ASSERT_THAT((t1), ::testing::Not(executorch::runtime::testing::IsCloseTo(t2)))
-
-#define EXPECT_TENSOR_CLOSE_WITH_TOL(t1, t2, rtol, atol)                       \
-  EXPECT_THAT(                                                                 \
-      (t1), ::executorch::runtime::testing::IsCloseToWithTol(t2, rtol, atol))
-#define EXPECT_TENSOR_NOT_CLOSE_WITH_TOL(t1, t2, rtol, atol)                   \
-  EXPECT_THAT((t1),                                                            \
-              ::testing::Not(executorch::runtime::testing::IsCloseToWithTol(   \
-                  t2, rtol, atol)))
-#define ASSERT_TENSOR_CLOSE_WITH_TOL(t1, t2, rtol, atol)                       \
-  ASSERT_THAT(                                                                 \
-      (t1), ::executorch::runtime::testing::IsCloseToWithTol(t2, rtol, atol))
-#define ASSERT_TENSOR_NOT_CLOSE_WITH_TOL(t1, t2, rtol, atol)                   \
-  ASSERT_THAT((t1),                                                            \
-              ::testing::Not(executorch::runtime::testing::IsCloseToWithTol(   \
-                  t2, rtol, atol)))
-
-#define EXPECT_TENSOR_DATA_EQ(t1, t2)                                          \
-  EXPECT_THAT((t1), ::executorch::runtime::testing::IsDataEqualTo(t2))
-#define EXPECT_TENSOR_DATA_NE(t1, t2)                                          \
-  EXPECT_THAT((t1),                                                            \
-              ::testing::Not(executorch::runtime::testing::IsDataEqualTo(t2)))
-#define ASSERT_TENSOR_DATA_EQ(t1, t2)                                          \
-  ASSERT_THAT((t1), ::executorch::runtime::testing::IsDataEqualTo(t2))
-#define ASSERT_TENSOR_DATA_NE(t1, t2)                                          \
-  ASSERT_THAT((t1),                                                            \
-              ::testing::Not(executorch::runtime::testing::IsDataEqualTo(t2)))
-
-#define EXPECT_TENSOR_DATA_CLOSE(t1, t2)                                       \
-  EXPECT_THAT((t1), ::executorch::runtime::testing::IsDataCloseTo(t2))
-#define EXPECT_TENSOR_DATA_NOT_CLOSE(t1, t2)                                   \
-  EXPECT_THAT((t1),                                                            \
-              ::testing::Not(executorch::runtime::testing::IsDataCloseTo(t2)))
-#define ASSERT_TENSOR_DATA_CLOSE(t1, t2)                                       \
-  ASSERT_THAT((t1), ::executorch::runtime::testing::IsDataCloseTo(t2))
-#define ASSERT_TENSOR_DATA_NOT_CLOSE(t1, t2)                                   \
-  ASSERT_THAT((t1),                                                            \
-              ::testing::Not(executorch::runtime::testing::IsDataCloseTo(t2)))
-
-#define EXPECT_TENSOR_DATA_CLOSE_WITH_TOL(t1, t2, rtol, atol)                  \
-  EXPECT_THAT((t1), ::executorch::runtime::testing::IsDataCloseToWithTol(      \
-                        t2, rtol, atol))
-#define EXPECT_TENSOR_DATA_NOT_CLOSE_WITH_TOL(t1, t2, rtol, atol)              \
-  EXPECT_THAT(                                                                 \
-      (t1), ::testing::Not(executorch::runtime::testing::IsDataCloseToWithTol( \
-                t2, rtol, atol)))
-#define ASSERT_TENSOR_DATA_CLOSE_WITH_TOL(t1, t2, rtol, atol)                  \
-  ASSERT_THAT((t1), ::executorch::runtime::testing::IsDataCloseToWithTol(      \
-                        t2, rtol, atol))
-#define ASSERT_TENSOR_DATA_NOT_CLOSE_WITH_TOL(t1, t2, rtol, atol)              \
-  ASSERT_THAT(                                                                 \
-      (t1), ::testing::Not(executorch::runtime::testing::IsDataCloseToWithTol( \
-                t2, rtol, atol)))
-
-/*
- * Helpers for comparing lists of Tensors.
- */
-
-#define EXPECT_TENSOR_LISTS_EQ(t1, t2)                                         \
-  EXPECT_THAT((t1), ::executorch::runtime::testing::IsListEqualTo(t2))
-#define EXPECT_TENSOR_LISTS_NE(t1, t2)                                         \
-  EXPECT_THAT((t1),                                                            \
-              ::testing::Not(executorch::runtime::testing::IsListEqualTo(t2)))
-#define ASSERT_TENSOR_LISTS_EQ(t1, t2)                                         \
-  ASSERT_THAT((t1), ::executorch::runtime::testing::IsListEqualTo(t2))
-#define ASSERT_TENSOR_LISTS_NE(t1, t2)                                         \
-  ASSERT_THAT((t1),                                                            \
-              ::testing::Not(executorch::runtime::testing::IsListEqualTo(t2)))
-
-#define EXPECT_TENSOR_LISTS_CLOSE(t1, t2)                                      \
-  EXPECT_THAT((t1), ::executorch::runtime::testing::IsListCloseTo(t2))
-#define EXPECT_TENSOR_LISTS_NOT_CLOSE(t1, t2)                                  \
-  EXPECT_THAT((t1),                                                            \
-              ::testing::Not(executorch::runtime::testing::IsListCloseTo(t2)))
-#define ASSERT_TENSOR_LISTS_CLOSE(t1, t2)                                      \
-  ASSERT_THAT((t1), ::executorch::runtime::testing::IsListCloseTo(t2))
-#define ASSERT_TENSOR_LISTS_NOT_CLOSE(t1, t2)                                  \
-  ASSERT_THAT((t1),                                                            \
-              ::testing::Not(executorch::runtime::testing::IsListCloseTo(t2)))
-
-} // namespace testing
-} // namespace runtime
-} // namespace executorch
-
-// ATen already defines operator<<() for Tensor and ScalarType.
-#ifndef USE_ATEN_LIB
-
-/*
- * These functions must be declared in the original namespaces of their
- * associated types so that C++ can find them.
- */
-namespace executorch {
-namespace runtime {
-namespace etensor {
-
-/**
- * Prints the ScalarType to the stream as a human-readable string.
- *
- * See also executorch::runtime::toString(ScalarType t) in ScalarTypeUtil.h.
- */
-std::ostream &operator<<(std::ostream &os, const ScalarType &t);
-
-/**
- * Prints the Tensor to the stream as a human-readable string.
- */
-std::ostream &operator<<(std::ostream &os, const Tensor &t);
-
-} // namespace etensor
-} // namespace runtime
-} // namespace executorch
-
-#endif // !USE_ATEN_LIB
-
-namespace torch {
-namespace executor {
-namespace testing {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::testing::IsCloseTo;
-using ::executorch::runtime::testing::IsCloseToWithTol;
-using ::executorch::runtime::testing::IsDataCloseTo;
-using ::executorch::runtime::testing::IsDataCloseToWithTol;
-using ::executorch::runtime::testing::IsDataEqualTo;
-using ::executorch::runtime::testing::IsEqualTo;
-using ::executorch::runtime::testing::IsListCloseTo;
-using ::executorch::runtime::testing::IsListEqualTo;
-using ::executorch::runtime::testing::tensor_data_is_close;
-using ::executorch::runtime::testing::tensor_lists_are_close;
-using ::executorch::runtime::testing::tensors_are_close;
-} // namespace testing
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/exec_aten/util/dim_order_util.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/exec_aten/util/dim_order_util.h
deleted file mode 100644
index bc38c0b5a2..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/exec_aten/util/dim_order_util.h
+++ /dev/null
@@ -1,275 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <cstdint>
-#include <cstdio>
-#include <cstring>
-
-#include <c10/util/irange.h>
-#include <executorch/runtime/core/error.h>
-#include <executorch/runtime/core/exec_aten/util/tensor_dimension_limit.h>
-#include <executorch/runtime/platform/assert.h>
-#include <executorch/runtime/platform/compiler.h>
-
-namespace executorch {
-namespace runtime {
-
-namespace {
-template <typename DimOrderType>
-bool validate_dim_order(const DimOrderType *dim_order, const size_t dims) {
-  static_assert(
-      kTensorDimensionLimit <= 16,
-      "Bitmask-based validation requires kTensorDimensionLimit <= 16");
-  if (dims > kTensorDimensionLimit) {
-    return false;
-  }
-  uint16_t seen = 0;
-  for (const auto i : c10::irange(dims)) {
-    if (dim_order[i] >= static_cast<DimOrderType>(dims)) {
-      return false;
-    }
-    const uint16_t mask = 1u << dim_order[i];
-    if (seen & mask) {
-      return false;
-    }
-    seen |= mask;
-  }
-  return true;
-}
-} // namespace
-
-/**
- * Check if a given dim_order array is equivalent to the contiguous dim order of
- * {0, 1, 2, 3, ...}
- *
- * @param[in] dim_order pointer to dim_order array
- * @param[in] dims length of the dim_order array
- */
-template <typename DimOrderType>
-inline bool is_contiguous_dim_order(const DimOrderType *dim_order,
-                                    const size_t dims) {
-  for (const auto i : c10::irange(dims)) {
-    if (dim_order[i] != static_cast<DimOrderType>(i)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-/**
- * Check if a given dim_order array is equivalent to a channels last dim order.
- * Channels last dim order is only valid for 4-dim and 5-dim tensors.
- *
- * @param[in] dim_order pointer to dim_order array
- * @param[in] dims length of the dim_order array
- */
-template <typename DimOrderType>
-bool is_channels_last_dim_order(const DimOrderType *dim_order,
-                                const size_t dims) {
-  if (dims != 4 && dims != 5) {
-    return false;
-  }
-  // 4-dim tensor is interpreted as NCHW, 5-dim tensor is interpreted as NCHWD
-  DimOrderType channels_dim = 1;
-  // Last value in the dim order should be the channels dim
-  if (dim_order[dims - 1] != channels_dim) {
-    return false;
-  }
-
-  if (dim_order[0] != 0) {
-    return false;
-  }
-  DimOrderType d = 1;
-  while (d < static_cast<DimOrderType>(dims) - 1) {
-    if (dim_order[d] != d + 1) {
-      return false;
-    }
-    d++;
-  }
-  return true;
-}
-
-/*
- * This utility translated sizes to strides by using dimension order
- * information. Dimension order specifies how the dimensions are laid out in the
- * memory. For example for Size = [2, 3, 4, 5] dim_names = [N, C, H, W]
- * dim_order = [0, 2, 3, 1]
- * strides = [60, 1, 15, 3]
- * param[in]: sizes, pointer to sizes array
- * param[in]: dim_order, pointer to dimension order array
- * param[in]: dims, number of dims. Sizes and dim_order must be sizes to dims
- * param[out]: strides, pointer to strides array that is filled in
- *
- * NB: Reason for not using ArrayRef is the dependency on kernel_types.h
- * This header cannot be included, because of circular dep it causes.
- * kernel_types depends on executorch_kernel_types in lean mode, which compiles
- * TensorImpl.cpp. executorch_kernel_types needs to depend on dim_order_utils
- * in order to utilize dim_order_to_stride in its resize impl. If
- * dim_order_utils depends on kernel_type, we have circular deps. This is also
- * the reason for templatizing this function. Better ideas welcome!
- * TODO(T148342910)
- *
- * Note that this function does not check that the provided dim order is valid.
- * This function should only be used when the validity of the dim order has been
- * checked beforehand. A safer version of this function is provided below as
- * dim_order_to_stride which will check that the dim order is valid.
- */
-template <typename SizesType, typename DimOrderType, typename StridesType>
-inline void dim_order_to_stride_nocheck(const SizesType *sizes,
-                                        const DimOrderType *dim_order,
-                                        const size_t dims,
-                                        StridesType *strides) {
-  // For 0 dim tensors, just return ok.
-  if (dims == 0) {
-    return;
-  }
-  // Fastest moving dim has stride of 1.
-  // For example:
-  // Size = [2, 3, 4, 5] dim_names = [N, C, H, W]
-  // dim_order = [0, 2, 3, 1]
-  // strides = [60, 1, 15, 3]
-  strides[dim_order[dims - 1]] = 1;
-  for (int32_t i = dims - 2; i >= 0; --i) {
-    if (sizes[dim_order[i + 1]] == 0) {
-      strides[dim_order[i]] = strides[dim_order[i + 1]];
-    } else {
-      strides[dim_order[i]] =
-          strides[dim_order[i + 1]] * sizes[dim_order[i + 1]];
-    }
-  }
-}
-
-template <typename SizesType, typename DimOrderType, typename StridesType>
-ET_NODISCARD inline Error
-dim_order_to_stride(const SizesType *sizes, const DimOrderType *dim_order,
-                    const size_t dims, StridesType *strides) {
-  // For 0 dim tensors, just return ok.
-  if (dims == 0) {
-    return Error::Ok;
-  }
-  ET_CHECK_OR_RETURN_ERROR(
-      validate_dim_order(dim_order, dims), InvalidArgument,
-      "Invalid dim order: values must be a permutation of [0, %zu)", dims);
-
-  dim_order_to_stride_nocheck(sizes, dim_order, dims, strides);
-  return Error::Ok;
-}
-
-namespace internal {
-
-template <typename StridesType, typename DimOrderType> struct StrideDimOrder {
-  StridesType stride;
-  DimOrderType dim_order;
-
-  StrideDimOrder(StridesType stride_, DimOrderType dim_order_)
-      : stride(stride_), dim_order(dim_order_) {}
-  StrideDimOrder() = default;
-  bool operator>(const StrideDimOrder &other) const {
-    // descending order
-    return stride < other.stride;
-  }
-};
-
-template <typename ValueType> struct Sorter {
-public:
-  void quick_sort(ValueType arr[], int32_t low, int32_t high) {
-    if (low < high) {
-      ValueType pivot = arr[high];
-      int32_t pos = partition(arr, low, high, pivot);
-
-      quick_sort(arr, low, pos - 1);
-      quick_sort(arr, pos + 1, high);
-    }
-  }
-
-private:
-  void swap(ValueType arr[], int32_t pos1, int32_t pos2) noexcept {
-    ValueType temp = arr[pos1];
-    arr[pos1] = arr[pos2];
-    arr[pos2] = temp;
-  }
-
-  int32_t partition(ValueType arr[], int32_t low, int32_t high,
-                    ValueType pivot) {
-    int32_t i = low;
-    int32_t j = low;
-    while (i <= high) {
-      if (arr[i] > pivot) {
-        i++;
-      } else {
-        swap(arr, i++, j++);
-      }
-    }
-    return j - 1;
-  }
-};
-
-} // namespace internal
-
-/*
- * This utility translated strides to dimension order
- * information. Dimension order specifies how the dimensions are laid out in the
- * memory. For example for tensor with sizes [3, 5, 2] and strides [5, 1, 15],
- * dim order should be [2, 0, 1], which is obtained by sorting strides in
- * descending order. param[in]: sizes, pointer to sizes array param[in]:
- * dim_order, pointer to dimension order array param[in]: dims, number of dims.
- * Sizes and dim_order must be sizes to dims param[out]: strides, pointer to
- * strides array that is filled in
- *
- * NB: Reason for not using ArrayRef is the dependency on kernel_types.h
- * This header cannot be included, because of circular dep it causes.
- * kernel_types depends on executorch_kernel_types in lean mode, which compiles
- * TensorImpl.cpp. executorch_kernel_types needs to depend on dim_order_utils
- * in order to utilize dim_order_to_stride in its resize impl. If
- * dim_order_utils depends on kernel_type, we have circular deps. This is also
- * the reason for templatizing this function. Better ideas welcome!
- * TODO(T148342910)
- */
-template <typename DimOrderType, typename StridesType>
-ET_NODISCARD inline Error stride_to_dim_order(const StridesType *strides,
-                                              const size_t dims,
-                                              DimOrderType *dim_order) {
-  const size_t kMaxNumOfDimensions = 16;
-  ET_CHECK_OR_RETURN_ERROR(dim_order != nullptr, MemoryAllocationFailed,
-                           "Need memory to get dim_order.");
-  ET_CHECK_OR_RETURN_ERROR(dims <= kMaxNumOfDimensions, NotSupported,
-                           "dims %zu exceeds maximum allowed %zu", dims,
-                           kMaxNumOfDimensions);
-  internal::StrideDimOrder<StridesType, DimOrderType>
-      array[kMaxNumOfDimensions];
-  for (DimOrderType i = 0; i < dims; i++) {
-    array[i].dim_order = i;
-    array[i].stride = strides[i];
-  }
-
-  internal::Sorter<internal::StrideDimOrder<StridesType, DimOrderType>> sorter;
-
-  sorter.quick_sort(array, 0, dims - 1);
-
-  for (const auto i : c10::irange(dims)) {
-    dim_order[i] = array[i].dim_order;
-  }
-  return Error::Ok;
-}
-
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::dim_order_to_stride;
-using ::executorch::runtime::dim_order_to_stride_nocheck;
-using ::executorch::runtime::is_channels_last_dim_order;
-using ::executorch::runtime::is_contiguous_dim_order;
-using ::executorch::runtime::stride_to_dim_order;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/exec_aten/util/scalar_type_util.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/exec_aten/util/scalar_type_util.h
deleted file mode 100644
index 80497eb577..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/exec_aten/util/scalar_type_util.h
+++ /dev/null
@@ -1,1320 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @file
- *
- * Forked from
- * https://github.com/pytorch/pytorch/blob/master/c10/core/ScalarType.h
- *
- * See file comment in ../ScalarType.h.
- *
- * This file contains all of the non-critical parts of the original ScalarType.h
- * that are not required for the core ExecuTorch runtime, but may be helpful for
- * code that uses ScalarType.
- */
-
-#pragma once
-
-#include <array>
-#include <cinttypes>
-#include <cstdint>
-#include <limits>
-#include <type_traits>
-
-#include <c10/macros/Macros.h>
-#include <executorch/runtime/platform/assert.h>
-
-C10_DIAGNOSTIC_PUSH_AND_IGNORED_IF_DEFINED("-Wswitch-enum")
-
-#ifdef USE_ATEN_LIB
-// Note that a lot of the macros/functions defined in this ScalarTypeUtil.h file
-// are also defined in c10/core/ScalarType.h, which is included via
-// kernel_types.h when building in ATen mode. They tend to use different names
-// and a different namespace, but if there are conflicts they should be resolved
-// here.
-#define ET_FORALL_SCALAR_TYPES AT_FORALL_SCALAR_TYPES_WITH_COMPLEX_AND_QINTS
-#include <c10/core/ScalarType.h>
-namespace executorch {
-namespace aten {
-using ScalarType = at::ScalarType;
-} // namespace aten
-} // namespace executorch
-#else // !USE_ATEN_LIB
-#include <executorch/runtime/core/portable_type/scalar_type.h>
-#include <executorch/runtime/core/portable_type/string_view.h>
-namespace executorch {
-namespace aten {
-using ScalarType = torch::executor::ScalarType;
-using string_view = torch::executor::string_view;
-} // namespace aten
-} // namespace executorch
-#endif // USE_ATEN_LIB
-// DEPRECATED: The executorch::aten:: namespace is deprecated. Use
-// executorch::aten:: instead.
-namespace exec_aten = ::executorch::aten;
-
-namespace executorch {
-namespace runtime {
-
-#if !defined(USE_ATEN_LIB)
-// Util to figure out if the scalar type if one of the
-// supported floating point types.
-// In aten mode, aten lib already has these utils as part of
-// its vec_base.h
-template <typename T>
-struct is_floating_point
-    : std::integral_constant<bool,
-                             std::is_floating_point<T>::value ||
-                                 std::is_same_v<T, torch::executor::Half> ||
-                                 std::is_same_v<T, torch::executor::BFloat16>> {
-};
-
-// Util to figure out if the scalar type is one of the
-// reduced precision floating point types.
-template <typename T>
-struct is_reduced_floating_point
-    : std::integral_constant<bool,
-                             std::is_same_v<T, torch::executor::Half> ||
-                                 std::is_same_v<T, torch::executor::BFloat16>> {
-};
-
-template <typename T>
-constexpr bool is_reduced_floating_point_v =
-    is_reduced_floating_point<T>::value;
-#endif
-
-/// Maps ScalarTypes to C++ types.
-template <::executorch::aten::ScalarType N> struct ScalarTypeToCppType;
-
-#define SPECIALIZE_ScalarTypeToCppType(cpp_type, scalar_type)                  \
-  template <>                                                                  \
-  struct ScalarTypeToCppType<::executorch::aten::ScalarType::scalar_type> {    \
-    using type = cpp_type;                                                     \
-  };
-
-ET_FORALL_SCALAR_TYPES(SPECIALIZE_ScalarTypeToCppType)
-
-#undef SPECIALIZE_ScalarTypeToCppType
-
-/// Maps C++ types to ScalarTypes.
-template <typename T> struct CppTypeToScalarType;
-
-#define SPECIALIZE_CppTypeToScalarType(cpp_type, scalar_type)                  \
-  template <>                                                                  \
-  struct CppTypeToScalarType<cpp_type>                                         \
-      : std::integral_constant<::executorch::aten::ScalarType,                 \
-                               ::executorch::aten::ScalarType::scalar_type> {  \
-  };
-
-ET_FORALL_SCALAR_TYPES(SPECIALIZE_CppTypeToScalarType)
-
-#undef SPECIALIZE_CppTypeToScalarType
-
-//
-// Macros that iterate across different subsets of ScalarTypes.
-//
-// See ET_FORALL_SCALAR_TYPES in ScalarType.h to iterate across all ScalarType
-// names and types.
-//
-// For all of these macros, the final `_` parameter is the name of another macro
-// that takes two parameters: the name of a C type, and the name of the
-// corresponding ScalarType enumerator.
-//
-// Note that these macros should use fully-qualified namespaces (starting with
-// `::`) to ensure that they can be called safely in any arbitrary namespace.
-//
-
-// In this context, "INT" means integer C types, which is why the quantized
-// integer types are not included.
-#define ET_FORALL_INT_TYPES(_)                                                 \
-  _(uint8_t, Byte)                                                             \
-  _(int8_t, Char)                                                              \
-  _(int16_t, Short)                                                            \
-  _(int32_t, Int)                                                              \
-  _(int64_t, Long)
-
-// Here `ANOTHER_INPUT` should be another variable to be forwarded to a given
-// function.
-#define ET_FORALL_INT_TYPES_WITH(ANOTHER_INPUT, _)                             \
-  _(ANOTHER_INPUT, uint8_t, Byte)                                              \
-  _(ANOTHER_INPUT, int8_t, Char)                                               \
-  _(ANOTHER_INPUT, int16_t, Short)                                             \
-  _(ANOTHER_INPUT, int32_t, Int)                                               \
-  _(ANOTHER_INPUT, int64_t, Long)
-
-#define ET_FORALL_INT_TYPES_WITH2(ANOTHER_INPUT1, ANOTHER_INPUT2, _)           \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, uint8_t, Byte)                             \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, int8_t, Char)                              \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, int16_t, Short)                            \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, int32_t, Int)                              \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, int64_t, Long)
-
-#define ET_FORALL_INT_TYPES_AND(SCALARTYPE, _)                                 \
-  _(uint8_t, Byte)                                                             \
-  _(int8_t, Char)                                                              \
-  _(int16_t, Short)                                                            \
-  _(int32_t, Int)                                                              \
-  _(int64_t, Long)                                                             \
-  _(::executorch::runtime::ScalarTypeToCppType<                                \
-        ::executorch::aten::ScalarType::SCALARTYPE>::type,                     \
-    SCALARTYPE)
-
-// In this context, "FLOAT" means float C types, which is why BFloat16 is not
-// included.
-#define ET_FORALL_FLOAT_TYPES(_)                                               \
-  _(float, Float)                                                              \
-  _(double, Double)
-
-#define ET_FORALL_FLOAT_TYPES_AND(SCALARTYPE, _)                               \
-  _(float, Float)                                                              \
-  _(double, Double)                                                            \
-  _(::executorch::runtime::ScalarTypeToCppType<                                \
-        ::executorch::aten::ScalarType::SCALARTYPE>::type,                     \
-    SCALARTYPE)
-
-#define ET_FORALL_FLOAT_TYPES_AND2(SCALARTYPE1, SCALARTYPE2, _)                \
-  _(float, Float)                                                              \
-  _(double, Double)                                                            \
-  _(::executorch::runtime::ScalarTypeToCppType<                                \
-        ::executorch::aten::ScalarType::SCALARTYPE1>::type,                    \
-    SCALARTYPE1)                                                               \
-  _(::executorch::runtime::ScalarTypeToCppType<                                \
-        ::executorch::aten::ScalarType::SCALARTYPE2>::type,                    \
-    SCALARTYPE2)
-
-#define ET_FORALL_FLOATH_TYPES(_) ET_FORALL_FLOAT_TYPES_AND(Half, _)
-
-#define ET_FORALL_FLOATHBF16_TYPES(_)                                          \
-  ET_FORALL_FLOAT_TYPES_AND2(Half, BFloat16, _)
-
-// Here `ANOTHER_INPUT` should be another variable to be forwarded to a given
-// function. Not to be confused with another scalar type as in
-// `ET_FORALL_FLOAT_TYPES_AND`.
-#define ET_FORALL_FLOAT_TYPES_WITH(ANOTHER_INPUT, _)                           \
-  _(ANOTHER_INPUT, float, Float)                                               \
-  _(ANOTHER_INPUT, double, Double)
-
-#define ET_FORALL_FLOATH_TYPES_WITH(ANOTHER_INPUT, _)                          \
-  _(ANOTHER_INPUT, float, Float)                                               \
-  _(ANOTHER_INPUT, double, Double)                                             \
-  _(ANOTHER_INPUT, ::executorch::aten::Half, Half)
-
-#define ET_FORALL_FLOAT_TYPES_WITH2(ANOTHER_INPUT1, ANOTHER_INPUT2, _)         \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, float, Float)                              \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, double, Double)
-
-#define ET_FORALL_FLOATHBF16_TYPES_WITH2(ANOTHER_INPUT1, ANOTHER_INPUT2, _)    \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, float, Float)                              \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, double, Double)                            \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, ::executorch::aten::Half, Half)            \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, ::executorch::aten::BFloat16, BFloat16)
-
-// In this context, "REAL" means integer/float C types, which is why BFloat16
-// and Half are not included.
-#define ET_FORALL_REAL_TYPES(_)                                                \
-  _(uint8_t, Byte)                                                             \
-  _(int8_t, Char)                                                              \
-  _(int16_t, Short)                                                            \
-  _(int32_t, Int)                                                              \
-  _(int64_t, Long)                                                             \
-  _(float, Float)                                                              \
-  _(double, Double)
-
-// Here `ANOTHER_INPUT` should be another variable to be forwarded to a given
-// function. Not to be confused with another scalar type as in
-// `ET_FORALL_REAL_TYPES_AND`.
-#define ET_FORALL_REAL_TYPES_WITH(ANOTHER_INPUT, _)                            \
-  _(ANOTHER_INPUT, uint8_t, Byte)                                              \
-  _(ANOTHER_INPUT, int8_t, Char)                                               \
-  _(ANOTHER_INPUT, int16_t, Short)                                             \
-  _(ANOTHER_INPUT, int32_t, Int)                                               \
-  _(ANOTHER_INPUT, int64_t, Long)                                              \
-  _(ANOTHER_INPUT, float, Float)                                               \
-  _(ANOTHER_INPUT, double, Double)
-
-#define ET_FORALL_REAL_TYPES_WITH2(ANOTHER_INPUT1, ANOTHER_INPUT2, _)          \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, uint8_t, Byte)                             \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, int8_t, Char)                              \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, int16_t, Short)                            \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, int32_t, Int)                              \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, int64_t, Long)                             \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, float, Float)                              \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, double, Double)
-
-#define ET_FORALL_REALHBF16_TYPES_WITH2(ANOTHER_INPUT1, ANOTHER_INPUT2, _)     \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, uint8_t, Byte)                             \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, int8_t, Char)                              \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, int16_t, Short)                            \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, int32_t, Int)                              \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, int64_t, Long)                             \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, float, Float)                              \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, double, Double)                            \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, ::executorch::aten::Half, Half)            \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, ::executorch::aten::BFloat16, BFloat16)
-
-#define ET_FORALL_REALHBBF16_TYPES_WITH2(ANOTHER_INPUT1, ANOTHER_INPUT2, _)    \
-  ET_FORALL_REALHBF16_TYPES_WITH2(ANOTHER_INPUT2, ANOTHER_INPUT2, _)           \
-  _(ANOTHER_INPUT1, ANOTHER_INPUT2, bool, Bool)
-
-// For macros that take `SCALARTYPEn` parameters, those parameters should be
-// an unquoted/unqualified enumerator name like `Int` or `Float`.
-#define ET_FORALL_REAL_TYPES_AND(SCALARTYPE, _)                                \
-  _(uint8_t, Byte)                                                             \
-  _(int8_t, Char)                                                              \
-  _(int16_t, Short)                                                            \
-  _(int32_t, Int)                                                              \
-  _(int64_t, Long)                                                             \
-  _(float, Float)                                                              \
-  _(double, Double)                                                            \
-  _(::executorch::runtime::ScalarTypeToCppType<                                \
-        ::executorch::aten::ScalarType::SCALARTYPE>::type,                     \
-    SCALARTYPE)
-
-#define ET_FORALL_REAL_TYPES_AND2(SCALARTYPE1, SCALARTYPE2, _)                 \
-  _(uint8_t, Byte)                                                             \
-  _(int8_t, Char)                                                              \
-  _(int16_t, Short)                                                            \
-  _(int32_t, Int)                                                              \
-  _(int64_t, Long)                                                             \
-  _(float, Float)                                                              \
-  _(double, Double)                                                            \
-  _(::executorch::runtime::ScalarTypeToCppType<                                \
-        ::executorch::aten::ScalarType::SCALARTYPE1>::type,                    \
-    SCALARTYPE1)                                                               \
-  _(::executorch::runtime::ScalarTypeToCppType<                                \
-        ::executorch::aten::ScalarType::SCALARTYPE2>::type,                    \
-    SCALARTYPE2)
-
-#define ET_FORALL_REALH_TYPES(_) ET_FORALL_REAL_TYPES_AND(Half, _)
-
-#define ET_FORALL_REALHBF16_TYPES(_)                                           \
-  ET_FORALL_REAL_TYPES_AND2(Half, BFloat16, _)
-
-#define ET_FORALL_REALHBBF16_TYPES(_)                                          \
-  ET_FORALL_REAL_TYPES_AND3(Bool, Half, BFloat16, _)
-
-#define ET_FORALL_REAL_TYPES_AND_WITH(SCALARTYPE, ANOTHER_INPUT, _)            \
-  _(ANOTHER_INPUT, uint8_t, Byte)                                              \
-  _(ANOTHER_INPUT, int8_t, Char)                                               \
-  _(ANOTHER_INPUT, int16_t, Short)                                             \
-  _(ANOTHER_INPUT, int32_t, Int)                                               \
-  _(ANOTHER_INPUT, int64_t, Long)                                              \
-  _(ANOTHER_INPUT, float, Float)                                               \
-  _(ANOTHER_INPUT, double, Double)                                             \
-  _(ANOTHER_INPUT,                                                             \
-    ::executorch::runtime::ScalarTypeToCppType<                                \
-        ::executorch::aten::ScalarType::SCALARTYPE>::type,                     \
-    SCALARTYPE)
-
-#define ET_FORALL_REAL_TYPES_AND2(SCALARTYPE1, SCALARTYPE2, _)                 \
-  _(uint8_t, Byte)                                                             \
-  _(int8_t, Char)                                                              \
-  _(int16_t, Short)                                                            \
-  _(int32_t, Int)                                                              \
-  _(int64_t, Long)                                                             \
-  _(float, Float)                                                              \
-  _(double, Double)                                                            \
-  _(::executorch::runtime::ScalarTypeToCppType<                                \
-        ::executorch::aten::ScalarType::SCALARTYPE1>::type,                    \
-    SCALARTYPE1)                                                               \
-  _(::executorch::runtime::ScalarTypeToCppType<                                \
-        ::executorch::aten::ScalarType::SCALARTYPE2>::type,                    \
-    SCALARTYPE2)
-
-#define ET_FORALL_REAL_TYPES_AND3(SCALARTYPE1, SCALARTYPE2, SCALARTYPE3, _)    \
-  _(uint8_t, Byte)                                                             \
-  _(int8_t, Char)                                                              \
-  _(int16_t, Short)                                                            \
-  _(int32_t, Int)                                                              \
-  _(int64_t, Long)                                                             \
-  _(float, Float)                                                              \
-  _(double, Double)                                                            \
-  _(::executorch::runtime::ScalarTypeToCppType<                                \
-        ::executorch::aten::ScalarType::SCALARTYPE1>::type,                    \
-    SCALARTYPE1)                                                               \
-  _(::executorch::runtime::ScalarTypeToCppType<                                \
-        ::executorch::aten::ScalarType::SCALARTYPE2>::type,                    \
-    SCALARTYPE2)                                                               \
-  _(::executorch::runtime::ScalarTypeToCppType<                                \
-        ::executorch::aten::ScalarType::SCALARTYPE3>::type,                    \
-    SCALARTYPE3)
-
-#define ET_FORALL_QINT_TYPES(_)                                                \
-  _(::torch::executor::qint8, QInt8)                                           \
-  _(::torch::executor::quint8, QUInt8)                                         \
-  _(::torch::executor::qint32, QInt32)                                         \
-  _(::torch::executor::quint4x2, QUInt4x2)                                     \
-  _(::torch::executor::quint2x4, QUInt2x4)
-
-// In this context, "COMPLEX" means complex types based on primitive C types,
-// which is why ComplexHalf is not included.
-#define ET_FORALL_COMPLEX_TYPES(_)                                             \
-  _(::executorch::aten::complex<float>, ComplexFloat)                          \
-  _(::executorch::aten::complex<double>, ComplexDouble)
-
-#define ET_FORALL_COMPLEXH_TYPES(_)                                            \
-  _(::executorch::aten::complex<::executorch::aten::Half>, ComplexHalf)        \
-  _(::executorch::aten::complex<float>, ComplexFloat)                          \
-  _(::executorch::aten::complex<double>, ComplexDouble)
-
-//
-// Utility functions to retrieve metadata for a given ScalarType
-//
-
-/**
- * Returns true if the parameter is one of the values covered by
- * ET_FORALL_SCALAR_TYPES.
- */
-inline bool isValid(::executorch::aten::ScalarType type) {
-  return static_cast<int8_t>(type) >= 0 &&
-         type < ::executorch::aten::ScalarType::NumOptions &&
-         type != ::executorch::aten::ScalarType::Undefined;
-}
-
-/**
- * Returns the name of a ScalarType as a C string.
- *
- * @param[in] t The type to get the name of.
- * @return The name of the type, or "UNKNOWN_SCALAR" if the type is not known.
- */
-inline const char *toString(::executorch::aten::ScalarType t) {
-#define DEFINE_CASE(_, name)                                                   \
-  case ::executorch::aten::ScalarType::name:                                   \
-    return #name;
-
-  switch (t) {
-    ET_FORALL_SCALAR_TYPES(DEFINE_CASE)
-  case ::executorch::aten::ScalarType::Undefined:
-    return "Undefined";
-  default:
-    return "UNKNOWN_SCALAR";
-  }
-#undef DEFINE_CASE
-}
-
-/**
- * Returns the size in bytes of the C type associated with the ScalarType.
- *
- * Calls ET_CHECK_MSG() if the type is unknown or is ScalarType::Undefined.
- *
- * @param[in] t The type to get the underlying C type size of.
- * @return The size of the associated C type in bytes.
- */
-inline size_t elementSize(::executorch::aten::ScalarType t) {
-#define CASE_ELEMENTSIZE_CASE(ctype, name)                                     \
-  case ::executorch::aten::ScalarType::name:                                   \
-    return sizeof(ctype);
-
-  switch (t) {
-    ET_FORALL_SCALAR_TYPES(CASE_ELEMENTSIZE_CASE)
-  default:
-    ET_CHECK_MSG(false, "Unknown ScalarType %" PRId8, static_cast<int8_t>(t));
-  }
-#undef CASE_ELEMENTSIZE_CASE
-}
-
-inline constexpr bool isIntegralType(::executorch::aten::ScalarType t,
-                                     bool includeBool) {
-  return (includeBool && t == ::executorch::aten::ScalarType::Bool) ||
-         (t == ::executorch::aten::ScalarType::Byte ||
-          t == ::executorch::aten::ScalarType::Char ||
-          t == ::executorch::aten::ScalarType::Int ||
-          t == ::executorch::aten::ScalarType::Long ||
-          t == ::executorch::aten::ScalarType::Short);
-}
-
-template <typename T, bool includeBool>
-struct is_integral_type
-    : public std::integral_constant<
-          bool, isIntegralType(CppTypeToScalarType<T>::value, includeBool)> {};
-
-inline constexpr bool isFloatingType(::executorch::aten::ScalarType t) {
-  return (t == ::executorch::aten::ScalarType::Double ||
-          t == ::executorch::aten::ScalarType::Float ||
-          t == ::executorch::aten::ScalarType::Half ||
-          t == ::executorch::aten::ScalarType::BFloat16);
-}
-
-inline bool isRealType(::executorch::aten::ScalarType t) {
-  return (t == ::executorch::aten::ScalarType::Byte ||
-          t == ::executorch::aten::ScalarType::Char ||
-          t == ::executorch::aten::ScalarType::Short ||
-          t == ::executorch::aten::ScalarType::Int ||
-          t == ::executorch::aten::ScalarType::Long ||
-          t == ::executorch::aten::ScalarType::Float ||
-          t == ::executorch::aten::ScalarType::Double);
-}
-
-inline bool isRealHType(::executorch::aten::ScalarType t) {
-  return (t == ::executorch::aten::ScalarType::Byte ||
-          t == ::executorch::aten::ScalarType::Char ||
-          t == ::executorch::aten::ScalarType::Short ||
-          t == ::executorch::aten::ScalarType::Int ||
-          t == ::executorch::aten::ScalarType::Long ||
-          t == ::executorch::aten::ScalarType::Float ||
-          t == ::executorch::aten::ScalarType::Double ||
-          t == ::executorch::aten::ScalarType::Half);
-}
-
-inline bool isRealHBType(::executorch::aten::ScalarType t) {
-  return (isRealHType(t) || t == ::executorch::aten::ScalarType::Bool);
-}
-
-inline bool isRealHBF16Type(::executorch::aten::ScalarType t) {
-  return (isRealHType(t) || t == ::executorch::aten::ScalarType::BFloat16);
-}
-
-inline bool isRealHBBF16Type(::executorch::aten::ScalarType t) {
-  return (isRealHBType(t) || t == ::executorch::aten::ScalarType::BFloat16);
-}
-
-inline constexpr bool isComplexType(::executorch::aten::ScalarType t) {
-  return (t == ::executorch::aten::ScalarType::ComplexHalf ||
-          t == ::executorch::aten::ScalarType::ComplexFloat ||
-          t == ::executorch::aten::ScalarType::ComplexDouble);
-}
-
-template <typename T>
-struct is_complex_type
-    : std::integral_constant<bool,
-                             isComplexType(CppTypeToScalarType<T>::value)> {};
-
-constexpr bool isBitsType(::executorch::aten::ScalarType t) {
-  return t == ::executorch::aten::ScalarType::Bits1x8 ||
-         t == ::executorch::aten::ScalarType::Bits2x4 ||
-         t == ::executorch::aten::ScalarType::Bits4x2 ||
-         t == ::executorch::aten::ScalarType::Bits8 ||
-         t == ::executorch::aten::ScalarType::Bits16;
-}
-
-template <typename T>
-struct is_bits_type
-    : std::integral_constant<bool, isBitsType(CppTypeToScalarType<T>::value)> {
-};
-
-constexpr bool isQIntType(::executorch::aten::ScalarType t) {
-  // Don't forget to extend this when adding new QInt types
-  return t == ::executorch::aten::ScalarType::QInt8 ||
-         t == ::executorch::aten::ScalarType::QUInt8 ||
-         t == ::executorch::aten::ScalarType::QInt32 ||
-         t == ::executorch::aten::ScalarType::QUInt4x2 ||
-         t == ::executorch::aten::ScalarType::QUInt2x4;
-}
-
-template <typename T>
-struct is_qint_type
-    : std::integral_constant<bool, isQIntType(CppTypeToScalarType<T>::value)> {
-};
-
-constexpr bool isFloat8Type(::executorch::aten::ScalarType t) {
-  // Don't forget to extend this when adding new QInt types
-  return t == ::executorch::aten::ScalarType::Float8_e5m2 ||
-         t == ::executorch::aten::ScalarType::Float8_e4m3fn ||
-         t == ::executorch::aten::ScalarType::Float8_e5m2fnuz ||
-         t == ::executorch::aten::ScalarType::Float8_e4m3fnuz;
-}
-
-template <typename T>
-struct is_float8_type
-    : std::integral_constant<bool,
-                             isFloat8Type(CppTypeToScalarType<T>::value)> {};
-
-constexpr bool isBarebonesUnsignedType(::executorch::aten::ScalarType t) {
-  // Don't forget to extend this when adding new QInt types
-  return t == ::executorch::aten::ScalarType::UInt16 ||
-         t == ::executorch::aten::ScalarType::UInt32 ||
-         t == ::executorch::aten::ScalarType::UInt64;
-}
-
-template <typename T>
-struct is_barebones_unsigned_type
-    : std::integral_constant<bool, isBarebonesUnsignedType(
-                                       CppTypeToScalarType<T>::value)> {};
-
-inline ::executorch::aten::ScalarType
-toQIntType(::executorch::aten::ScalarType t) {
-  switch (t) {
-  case ::executorch::aten::ScalarType::Byte:
-    return ::executorch::aten::ScalarType::QUInt8;
-  case ::executorch::aten::ScalarType::Char:
-    return ::executorch::aten::ScalarType::QInt8;
-  case ::executorch::aten::ScalarType::Int:
-    return ::executorch::aten::ScalarType::QInt32;
-  default:
-    return t;
-  }
-}
-
-inline ::executorch::aten::ScalarType
-toUnderlying(::executorch::aten::ScalarType t) {
-  switch (t) {
-  case ::executorch::aten::ScalarType::QUInt8:
-    return ::executorch::aten::ScalarType::Byte;
-  case ::executorch::aten::ScalarType::QInt8:
-    return ::executorch::aten::ScalarType::Char;
-  case ::executorch::aten::ScalarType::QInt32:
-    return ::executorch::aten::ScalarType::Int;
-  case ::executorch::aten::ScalarType::QUInt4x2:
-    return ::executorch::aten::ScalarType::Byte;
-  case ::executorch::aten::ScalarType::QUInt2x4:
-    return ::executorch::aten::ScalarType::Byte;
-  default:
-    return t;
-  }
-}
-
-inline bool isSignedType(::executorch::aten::ScalarType t) {
-  ET_CHECK_MSG(!::executorch::runtime::isQIntType(t),
-               "isSignedType not supported for quantized types like %" PRId8,
-               static_cast<int8_t>(t));
-#define CASE_SIGNED(ctype, name)                                               \
-  case ::executorch::aten::ScalarType::name:                                   \
-    return std::numeric_limits<ctype>::is_signed;
-
-  switch (t) {
-  case ::executorch::aten::ScalarType::ComplexHalf:
-  case ::executorch::aten::ScalarType::ComplexFloat:
-  case ::executorch::aten::ScalarType::ComplexDouble:
-    return true;
-    ET_FORALL_REAL_TYPES_AND3(Half, Bool, BFloat16, CASE_SIGNED)
-  default:
-    ET_CHECK_MSG(false, "Unknown ScalarType %" PRId8, static_cast<int8_t>(t));
-  }
-#undef CASE_SIGNED
-}
-
-inline bool isUnderlying(::executorch::aten::ScalarType type,
-                         ::executorch::aten::ScalarType qtype) {
-  return type == ::executorch::runtime::toUnderlying(qtype);
-}
-
-inline constexpr ::executorch::aten::ScalarType
-toRealValueType(::executorch::aten::ScalarType t) {
-  switch (t) {
-  case ::executorch::aten::ScalarType::ComplexHalf:
-    return ::executorch::aten::ScalarType::Half;
-  case ::executorch::aten::ScalarType::ComplexFloat:
-    return ::executorch::aten::ScalarType::Float;
-  case ::executorch::aten::ScalarType::ComplexDouble:
-    return ::executorch::aten::ScalarType::Double;
-  default:
-    return t;
-  }
-}
-
-inline constexpr ::executorch::aten::ScalarType
-toComplexType(::executorch::aten::ScalarType t) {
-  switch (t) {
-  case ::executorch::aten::ScalarType::BFloat16:
-    // BFloat16 has range equivalent to Float,
-    // so we map it to ComplexFloat.
-    return ::executorch::aten::ScalarType::ComplexFloat;
-  case ::executorch::aten::ScalarType::Half:
-    return ::executorch::aten::ScalarType::ComplexHalf;
-  case ::executorch::aten::ScalarType::Float:
-    return ::executorch::aten::ScalarType::ComplexFloat;
-  case ::executorch::aten::ScalarType::Double:
-    return ::executorch::aten::ScalarType::ComplexDouble;
-  case ::executorch::aten::ScalarType::ComplexHalf:
-    return ::executorch::aten::ScalarType::ComplexHalf;
-  case ::executorch::aten::ScalarType::ComplexFloat:
-    return ::executorch::aten::ScalarType::ComplexFloat;
-  case ::executorch::aten::ScalarType::ComplexDouble:
-    return ::executorch::aten::ScalarType::ComplexDouble;
-  default:
-    ET_CHECK_MSG(false, "Unknown Complex ScalarType for %" PRId8,
-                 static_cast<int8_t>(t));
-  }
-}
-
-/**
- * Encodes type casting rules that are consistent with ATen behaviour.
- */
-inline constexpr bool canCast(const ::executorch::aten::ScalarType from,
-                              const ::executorch::aten::ScalarType to) {
-  // Disallow complex -> non-complex
-  return !(::executorch::runtime::isComplexType(from) &&
-           !::executorch::runtime::isComplexType(to)) &&
-         // Disallow float -> integral
-         !(::executorch::runtime::isFloatingType(from) &&
-           ::executorch::runtime::isIntegralType(to, /*includeBool=*/false)) &&
-         // Treat bool as a special category. Disallow non-bool -> bool
-         !(from != ::executorch::aten::ScalarType::Bool &&
-           to == ::executorch::aten::ScalarType::Bool);
-}
-
-template <typename T1, typename T2>
-struct can_cast
-    : std::integral_constant<bool, canCast(CppTypeToScalarType<T1>::value,
-                                           CppTypeToScalarType<T2>::value)> {};
-
-/**
- * When casting from floating point to integral type, if the floating value is
- * outside the integral type range, then an error is thrown if sanitization is
- * enabled. To circumvent this, we cast the floating point to int64_t first.
- */
-template <typename To, typename From,
-          std::enable_if_t<(std::is_floating_point<From>::value &&
-                            std::is_integral<To>::value),
-                           int> = 0>
-To convert(From val) {
-  return static_cast<To>(static_cast<int64_t>(val));
-}
-
-template <typename To, typename From,
-          std::enable_if_t<!(std::is_floating_point<From>::value &&
-                             std::is_integral<To>::value),
-                           int> = 0>
-To convert(From val) {
-  return static_cast<To>(val);
-}
-
-namespace internal {
-// This is generated according to NumPy's promote_types
-inline constexpr auto u1 = ::executorch::aten::ScalarType::Byte;
-inline constexpr auto i1 = ::executorch::aten::ScalarType::Char;
-inline constexpr auto i2 = ::executorch::aten::ScalarType::Short;
-inline constexpr auto i4 = ::executorch::aten::ScalarType::Int;
-inline constexpr auto i8 = ::executorch::aten::ScalarType::Long;
-inline constexpr auto f2 = ::executorch::aten::ScalarType::Half;
-inline constexpr auto f4 = ::executorch::aten::ScalarType::Float;
-inline constexpr auto f8 = ::executorch::aten::ScalarType::Double;
-inline constexpr auto c2 = ::executorch::aten::ScalarType::ComplexHalf;
-inline constexpr auto c4 = ::executorch::aten::ScalarType::ComplexFloat;
-inline constexpr auto c8 = ::executorch::aten::ScalarType::ComplexDouble;
-inline constexpr auto b1 = ::executorch::aten::ScalarType::Bool;
-inline constexpr auto bf = ::executorch::aten::ScalarType::BFloat16;
-
-using U1 =
-    typename ScalarTypeToCppType<::executorch::aten::ScalarType::Byte>::type;
-using I1 =
-    typename ScalarTypeToCppType<::executorch::aten::ScalarType::Char>::type;
-using I2 =
-    typename ScalarTypeToCppType<::executorch::aten::ScalarType::Short>::type;
-using I4 =
-    typename ScalarTypeToCppType<::executorch::aten::ScalarType::Int>::type;
-using I8 =
-    typename ScalarTypeToCppType<::executorch::aten::ScalarType::Long>::type;
-using F2 =
-    typename ScalarTypeToCppType<::executorch::aten::ScalarType::Half>::type;
-using F4 =
-    typename ScalarTypeToCppType<::executorch::aten::ScalarType::Float>::type;
-using F8 =
-    typename ScalarTypeToCppType<::executorch::aten::ScalarType::Double>::type;
-using C2 = typename ScalarTypeToCppType<
-    ::executorch::aten::ScalarType::ComplexHalf>::type;
-using C4 = typename ScalarTypeToCppType<
-    ::executorch::aten::ScalarType::ComplexFloat>::type;
-using C8 = typename ScalarTypeToCppType<
-    ::executorch::aten::ScalarType::ComplexDouble>::type;
-using B1 =
-    typename ScalarTypeToCppType<::executorch::aten::ScalarType::Bool>::type;
-using BF = typename ScalarTypeToCppType<
-    ::executorch::aten::ScalarType::BFloat16>::type;
-
-inline constexpr std::array<::executorch::aten::ScalarType, 13> index2dtype = {
-    {u1, i1, i2, i4, i8, f2, f4, f8, c2, c4, c8, b1, bf}};
-
-constexpr std::array<
-    int64_t, static_cast<size_t>(::executorch::aten::ScalarType::NumOptions)>
-calculate_dtype2index() {
-  std::array<int64_t,
-             static_cast<size_t>(::executorch::aten::ScalarType::NumOptions)>
-      inverse = {};
-  for (int64_t i = 0;
-       i < static_cast<int64_t>(::executorch::aten::ScalarType::NumOptions);
-       i++) {
-    inverse[i] = -1;
-  }
-  for (int64_t i = 0; i < static_cast<int64_t>(index2dtype.size()); i++) {
-    inverse[static_cast<int64_t>(index2dtype[i])] = i;
-  }
-  return inverse;
-}
-
-inline constexpr auto dtype2index = calculate_dtype2index();
-inline constexpr int NUM_PROMOTE_TYPES = 13;
-// Should match _promoteTypesLookup in c10/core/ScalarType.cpp so that
-// we match PyTorch core type promotion semantics.
-inline constexpr ::executorch::aten::ScalarType
-    promoteTypesLookup[NUM_PROMOTE_TYPES][NUM_PROMOTE_TYPES] = {
-        /*        u1  i1  i2  i4  i8  f2  f4  f8  c2  c4  c8  b1  bf*/
-        /* u1 */ {u1, i2, i2, i4, i8, f2, f4, f8, c2, c4, c8, u1, bf},
-        /* i1 */ {i2, i1, i2, i4, i8, f2, f4, f8, c2, c4, c8, i1, bf},
-        /* i2 */ {i2, i2, i2, i4, i8, f2, f4, f8, c2, c4, c8, i2, bf},
-        /* i4 */ {i4, i4, i4, i4, i8, f2, f4, f8, c2, c4, c8, i4, bf},
-        /* i8 */ {i8, i8, i8, i8, i8, f2, f4, f8, c2, c4, c8, i8, bf},
-        /* f2 */ {f2, f2, f2, f2, f2, f2, f4, f8, c2, c4, c8, f2, f4},
-        /* f4 */ {f4, f4, f4, f4, f4, f4, f4, f8, c4, c4, c8, f4, f4},
-        /* f8 */ {f8, f8, f8, f8, f8, f8, f8, f8, c8, c8, c8, f8, f8},
-        /* c2 */ {c2, c2, c2, c2, c2, c2, c4, c8, c2, c4, c8, c2, c4},
-        /* c4 */ {c4, c4, c4, c4, c4, c4, c4, c8, c4, c4, c8, c4, c4},
-        /* c8 */ {c8, c8, c8, c8, c8, c8, c8, c8, c8, c8, c8, c8, c8},
-        /* b1 */ {u1, i1, i2, i4, i8, f2, f4, f8, c2, c4, c8, b1, bf},
-        /* bf */ {bf, bf, bf, bf, bf, f4, f4, f8, c4, c4, c8, bf, bf},
-};
-
-} // namespace internal
-
-/**
- * Implements type promotion rules that are consistent with ATen behaviour,
- * which in turn is consistent with NumPy's promote_types.
- * If half_to_float is set to true, then half and bfloat16 will be promoted to
- * float instead
- */
-inline constexpr ::executorch::aten::ScalarType
-promoteTypes(::executorch::aten::ScalarType a, ::executorch::aten::ScalarType b,
-             bool half_to_float = false) {
-  // For QInt types, only allow exact match
-  if (::executorch::runtime::isQIntType(a) && a == b) {
-    return a;
-  }
-  if (::executorch::runtime::isQIntType(a) ||
-      ::executorch::runtime::isQIntType(b)) {
-    ET_CHECK_MSG(false, "promoteTypes not valid for quantized dtypes");
-  }
-
-  // For Bits types, only allow exact match
-  if (::executorch::runtime::isBitsType(a) && a == b) {
-    return a;
-  }
-  if (::executorch::runtime::isBitsType(a) ||
-      ::executorch::runtime::isBitsType(b)) {
-    ET_CHECK_MSG(false, "promoteTypes not valid for bits dtypes");
-  }
-
-  // For Float8 types, only allow exact match
-  if (::executorch::runtime::isFloat8Type(a) && a == b) {
-    return a;
-  }
-  if (::executorch::runtime::isFloat8Type(a) ||
-      ::executorch::runtime::isFloat8Type(b)) {
-    ET_CHECK_MSG(false, "promoteTypes not valid for float8 dtypes");
-  }
-
-  // For barebones uint types, only allow exact match
-  if (::executorch::runtime::isBarebonesUnsignedType(a) && a == b) {
-    return a;
-  }
-  if (::executorch::runtime::isBarebonesUnsignedType(a) ||
-      ::executorch::runtime::isBarebonesUnsignedType(b)) {
-    ET_CHECK_MSG(false, "promoteTypes not valid for barebone unsigned dtypes");
-  }
-
-  auto ix_a = ::executorch::runtime::internal::dtype2index[(int)a];
-  ET_CHECK(ix_a != -1);
-  auto ix_b = ::executorch::runtime::internal::dtype2index[(int)b];
-  ET_CHECK(ix_b != -1);
-  ::executorch::aten::ScalarType promoted_type =
-      ::executorch::runtime::internal::promoteTypesLookup[ix_a][ix_b];
-
-  if (half_to_float &&
-      (promoted_type == ::executorch::aten::ScalarType::Half ||
-       promoted_type == ::executorch::aten::ScalarType::BFloat16)) {
-    promoted_type = ::executorch::aten::ScalarType::Float;
-  }
-
-  return promoted_type;
-}
-
-template <typename T1, typename T2, bool half_to_float = false>
-struct promote_types {
-private:
-  static_assert(std::is_same_v<T1, T2> ||
-                    (!is_qint_type<T1>::value && !is_qint_type<T2>::value),
-                "promote_types not valid for quantized dtypes");
-  static_assert(std::is_same_v<T1, T2> ||
-                    (!is_bits_type<T1>::value && !is_bits_type<T2>::value),
-                "promote_types not valid for bits dtypes");
-  static_assert(std::is_same_v<T1, T2> ||
-                    (!is_float8_type<T1>::value && !is_float8_type<T2>::value),
-                "promote_types not valid for float8 dtypes");
-  static_assert(std::is_same_v<T1, T2> ||
-                    (!is_barebones_unsigned_type<T1>::value &&
-                     !is_barebones_unsigned_type<T2>::value),
-                "promote_types not valid for barebones unsigned dtypes");
-
-  using promoted_type_not_respecting_half_to_float =
-      typename ScalarTypeToCppType<promoteTypes(
-          CppTypeToScalarType<T1>::value,
-          CppTypeToScalarType<T2>::value)>::type;
-
-public:
-  using type = std::conditional_t<
-      half_to_float &&
-          (std::is_same_v<promoted_type_not_respecting_half_to_float,
-                          typename ScalarTypeToCppType<
-                              ::executorch::aten::ScalarType::Half>::type> ||
-           std::is_same_v<promoted_type_not_respecting_half_to_float,
-                          typename ScalarTypeToCppType<
-                              ::executorch::aten::ScalarType::BFloat16>::type>),
-      typename ScalarTypeToCppType<::executorch::aten::ScalarType::Float>::type,
-      promoted_type_not_respecting_half_to_float>;
-};
-
-//
-// Helper macros for switch case macros (see below)
-//
-// These macros are not meant to be used directly. They provide an easy way to
-// generate a switch statement that can handle subsets of ScalarTypes supported
-// by ExecuTorch.
-//
-
-#ifdef ET_INTERNAL_CHECK_SELECTIVE_BUILD
-#define ET_INTERNAL_SWITCH_CASE(enum_type, CTYPE_ALIAS, ...)                   \
-  case enum_type: {                                                            \
-    ET_INTERNAL_CHECK_SELECTIVE_BUILD(enum_type);                              \
-    using CTYPE_ALIAS [[maybe_unused]] =                                       \
-        ::executorch::runtime::ScalarTypeToCppType<enum_type>::type;           \
-    return __VA_ARGS__();                                                      \
-  }
-#else
-#define ET_INTERNAL_SWITCH_CASE(enum_type, CTYPE_ALIAS, ...)                   \
-  case enum_type: {                                                            \
-    using CTYPE_ALIAS [[maybe_unused]] =                                       \
-        ::executorch::runtime::ScalarTypeToCppType<enum_type>::type;           \
-    return __VA_ARGS__();                                                      \
-  }
-#endif
-
-#define ET_INTERNAL_SWITCH(TYPE, CONTEXT, NAME, ...)                           \
-  [&] {                                                                        \
-    const auto &_st = TYPE;                                                    \
-    constexpr const char *et_switch_name = NAME;                               \
-    (void)et_switch_name; /* Suppress unused var */                            \
-    C10_DIAGNOSTIC_PUSH_AND_IGNORED_IF_DEFINED("-Wswitch-enum")                \
-    switch (_st) {                                                             \
-      __VA_ARGS__                                                              \
-    default:                                                                   \
-      CONTEXT.fail(torch::executor::Error::InvalidArgument);                   \
-      ET_LOG(Error, "Unhandled dtype %s for %s",                               \
-             ::executorch::runtime::toString(_st), et_switch_name);            \
-    }                                                                          \
-    C10_DIAGNOSTIC_POP()                                                       \
-  }()
-
-#define ET_INTERNAL_SWITCH_CASE_INT_TYPES(CTYPE_ALIAS, ...)                    \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::Byte, CTYPE_ALIAS,   \
-                          __VA_ARGS__)                                         \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::Char, CTYPE_ALIAS,   \
-                          __VA_ARGS__)                                         \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::Short, CTYPE_ALIAS,  \
-                          __VA_ARGS__)                                         \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::Int, CTYPE_ALIAS,    \
-                          __VA_ARGS__)                                         \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::Long, CTYPE_ALIAS,   \
-                          __VA_ARGS__)
-
-#define ET_INTERNAL_SWITCH_CASE_UINT_TYPES(CTYPE_ALIAS, ...)                   \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::UInt16, CTYPE_ALIAS, \
-                          __VA_ARGS__)                                         \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::UInt32, CTYPE_ALIAS, \
-                          __VA_ARGS__)                                         \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::UInt64, CTYPE_ALIAS, \
-                          __VA_ARGS__)
-
-#define ET_INTERNAL_SWITCH_CASE_FLOAT_TYPES(CTYPE_ALIAS, ...)                  \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::Float, CTYPE_ALIAS,  \
-                          __VA_ARGS__)                                         \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::Double, CTYPE_ALIAS, \
-                          __VA_ARGS__)
-
-#define ET_INTERNAL_SWITCH_CASE_REAL_TYPES(CTYPE_ALIAS, ...)                   \
-  ET_INTERNAL_SWITCH_CASE_INT_TYPES(CTYPE_ALIAS, __VA_ARGS__)                  \
-  ET_INTERNAL_SWITCH_CASE_FLOAT_TYPES(CTYPE_ALIAS, __VA_ARGS__)
-
-#define ET_INTERNAL_SWITCH_CASE_COMPLEX_TYPES(CTYPE_ALIAS, ...)                \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::ComplexFloat,        \
-                          CTYPE_ALIAS, __VA_ARGS__)                            \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::ComplexDouble,       \
-                          CTYPE_ALIAS, __VA_ARGS__)
-
-#define ET_INTERNAL_SWITCH_CASE_COMPLEXH_TYPES(CTYPE_ALIAS, ...)               \
-  ET_INTERNAL_SWITCH_CASE_COMPLEX_TYPES(CTYPE_ALIAS, __VA_ARGS__)              \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::ComplexHalf,         \
-                          CTYPE_ALIAS, __VA_ARGS__)
-
-#define ET_INTERNAL_SWITCH_CASE_QINT_TYPES(CTYPE_ALIAS, ...)                   \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::QInt8, CTYPE_ALIAS,  \
-                          __VA_ARGS__)                                         \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::QUInt8, CTYPE_ALIAS, \
-                          __VA_ARGS__)                                         \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::QInt32, CTYPE_ALIAS, \
-                          __VA_ARGS__)                                         \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::QUInt4x2,            \
-                          CTYPE_ALIAS, __VA_ARGS__)                            \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::QUInt2x4,            \
-                          CTYPE_ALIAS, __VA_ARGS__)
-
-#define ET_INTERNAL_SWITCH_CASE_BITS_TYPES(CTYPE_ALIAS, ...)                   \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::Bits1x8,             \
-                          CTYPE_ALIAS, __VA_ARGS__)                            \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::Bits2x4,             \
-                          CTYPE_ALIAS, __VA_ARGS__)                            \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::Bits4x2,             \
-                          CTYPE_ALIAS, __VA_ARGS__)                            \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::Bits8, CTYPE_ALIAS,  \
-                          __VA_ARGS__)                                         \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::Bits16, CTYPE_ALIAS, \
-                          __VA_ARGS__)
-
-#define ET_INTERNAL_SWITCH_CASE_ALL_TYPES(CTYPE_ALIAS, ...)                    \
-  ET_INTERNAL_SWITCH_CASE_REAL_TYPES(CTYPE_ALIAS, __VA_ARGS__)                 \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::Half, CTYPE_ALIAS,   \
-                          __VA_ARGS__)                                         \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::BFloat16,            \
-                          CTYPE_ALIAS, __VA_ARGS__)                            \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::Bool, CTYPE_ALIAS,   \
-                          __VA_ARGS__)                                         \
-  ET_INTERNAL_SWITCH_CASE_COMPLEXH_TYPES(CTYPE_ALIAS, __VA_ARGS__)             \
-  ET_INTERNAL_SWITCH_CASE_QINT_TYPES(CTYPE_ALIAS, __VA_ARGS__)                 \
-  ET_INTERNAL_SWITCH_CASE_BITS_TYPES(CTYPE_ALIAS, __VA_ARGS__)
-
-#define ET_INTERNAL_SWITCH_CASE_REAL_TYPES_AND(ADDITIONAL, CTYPE_ALIAS, ...)   \
-  ET_INTERNAL_SWITCH_CASE_REAL_TYPES(CTYPE_ALIAS, __VA_ARGS__)                 \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::ADDITIONAL,          \
-                          CTYPE_ALIAS, __VA_ARGS__)
-
-#define ET_INTERNAL_SWITCH_CASE_REAL_TYPES_AND2(ADDITIONAL1, ADDITIONAL2,      \
-                                                CTYPE_ALIAS, ...)              \
-  ET_INTERNAL_SWITCH_CASE_REAL_TYPES(CTYPE_ALIAS, __VA_ARGS__)                 \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::ADDITIONAL1,         \
-                          CTYPE_ALIAS, __VA_ARGS__)                            \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::ADDITIONAL2,         \
-                          CTYPE_ALIAS, __VA_ARGS__)
-
-#define ET_INTERNAL_SWITCH_CASE_REAL_TYPES_AND3(ADDITIONAL1, ADDITIONAL2,      \
-                                                ADDITIONAL3, CTYPE_ALIAS, ...) \
-  ET_INTERNAL_SWITCH_CASE_REAL_TYPES(CTYPE_ALIAS, __VA_ARGS__)                 \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::ADDITIONAL1,         \
-                          CTYPE_ALIAS, __VA_ARGS__)                            \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::ADDITIONAL2,         \
-                          CTYPE_ALIAS, __VA_ARGS__)                            \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::ADDITIONAL3,         \
-                          CTYPE_ALIAS, __VA_ARGS__)
-
-#define ET_INTERNAL_SWITCH_CASE_INT_TYPES_AND(ADDITIONAL, CTYPE_ALIAS, ...)    \
-  ET_INTERNAL_SWITCH_CASE_INT_TYPES(CTYPE_ALIAS, __VA_ARGS__)                  \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::ADDITIONAL,          \
-                          CTYPE_ALIAS, __VA_ARGS__)
-
-#define ET_INTERNAL_SWITCH_CASE_FLOAT_TYPES_AND(ADDITIONAL, CTYPE_ALIAS, ...)  \
-  ET_INTERNAL_SWITCH_CASE_FLOAT_TYPES(CTYPE_ALIAS, __VA_ARGS__)                \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::ADDITIONAL,          \
-                          CTYPE_ALIAS, __VA_ARGS__)
-
-#define ET_INTERNAL_SWITCH_CASE_FLOAT_TYPES_AND2(ADDITIONAL1, ADDITIONAL2,     \
-                                                 CTYPE_ALIAS, ...)             \
-  ET_INTERNAL_SWITCH_CASE_FLOAT_TYPES_AND(ADDITIONAL1, CTYPE_ALIAS,            \
-                                          __VA_ARGS__)                         \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::ADDITIONAL2,         \
-                          CTYPE_ALIAS, __VA_ARGS__)
-
-#define ET_INTERNAL_SWITCH_CASE_FLOAT_TYPES_AND3(                              \
-    ADDITIONAL1, ADDITIONAL2, ADDITIONAL3, CTYPE_ALIAS, ...)                   \
-  ET_INTERNAL_SWITCH_CASE_FLOAT_TYPES_AND2(ADDITIONAL1, ADDITIONAL2,           \
-                                           CTYPE_ALIAS, __VA_ARGS__)           \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::ADDITIONAL3,         \
-                          CTYPE_ALIAS, __VA_ARGS__)
-
-#define ET_INTERNAL_SWITCH_CASE_SCALAR_OBJ_TYPES(CTYPE_ALIAS, ...)             \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::Bool, CTYPE_ALIAS,   \
-                          __VA_ARGS__)                                         \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::Long, CTYPE_ALIAS,   \
-                          __VA_ARGS__)                                         \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::Double, CTYPE_ALIAS, \
-                          __VA_ARGS__)
-
-#define ET_INTERNAL_SWITCH_CASE_SCALAR_OBJ_REAL_TYPES(CTYPE_ALIAS, ...)        \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::Long, CTYPE_ALIAS,   \
-                          __VA_ARGS__)                                         \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::Double, CTYPE_ALIAS, \
-                          __VA_ARGS__)
-
-#define ET_INTERNAL_SWITCH_CASE_SCALAR_OBJ_INTB_TYPES(CTYPE_ALIAS, ...)        \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::Bool, CTYPE_ALIAS,   \
-                          __VA_ARGS__)                                         \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::Long, CTYPE_ALIAS,   \
-                          __VA_ARGS__)
-
-#define ET_INTERNAL_SWITCH_CASE_SCALAR_OBJ_FLOATB_TYPES(CTYPE_ALIAS, ...)      \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::Bool, CTYPE_ALIAS,   \
-                          __VA_ARGS__)                                         \
-  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::Double, CTYPE_ALIAS, \
-                          __VA_ARGS__)
-
-//
-// Switch case macros
-//
-// These macros provide an easy way to generate switch statements that apply a
-// common lambda function to subsets of ScalarTypes supported by ExecuTorch.
-// The lambda function can type specialize to the ctype associated with the
-// ScalarType being handled through an alias passed as the CTYPE_ALIAS argument.
-//
-// Arguments:
-//   - ADDITIONAL: Additional ScalarType case to add
-//   - TYPE: The ScalarType to handle through the switch statement
-//   - CONTEXT: The KernelRuntimeContext instance used for error handling, etc.
-//   - NAME: A name for this operation which will be used in error messages
-//   - CTYPE_ALIAS: A typedef for the ctype associated with the ScalarType.
-//   - [&](){...}: A lambda function to be applied to each ScalarType case
-//
-// An example usage is:
-//
-// ET_SWITCH_REAL_TYPES(input.scalar_type(), "example", CTYPE, [&]() {
-//   output.mutable_data_ptr<CTYPE>[0] = input.const_data_ptr<CTYPE>[0];
-// });
-//
-// Note that these can be nested as well:
-//
-// ET_SWITCH_REAL_TYPES(input.scalar_type(), "example", CTYPE_IN, [&]() {
-//   ET_SWITCH_REAL_TYPES(output.scalar_type(), "example", CTYPE_OUT, [&]() {
-//     output.mutable_data_ptr<CTYPE_OUT>[0] =
-//         input.const_data_ptr<CTYPE_IN>[0];
-//   });
-// });
-//
-// These macros are adapted from Dispatch.h in the ATen library. The primary
-// difference is that the CTYPE_ALIAS argument is exposed to users, which is
-// used to alias the ctype associated with the ScalarType that is being handled.
-//
-
-#define ET_SWITCH_ALL_TYPES(TYPE, CONTEXT, NAME, CTYPE_ALIAS, ...)             \
-  ET_INTERNAL_SWITCH(                                                          \
-      TYPE, CONTEXT, NAME,                                                     \
-      ET_INTERNAL_SWITCH_CASE_ALL_TYPES(CTYPE_ALIAS, __VA_ARGS__))
-
-#define ET_SWITCH_REAL_TYPES(TYPE, CONTEXT, NAME, CTYPE_ALIAS, ...)            \
-  ET_INTERNAL_SWITCH(                                                          \
-      TYPE, CONTEXT, NAME,                                                     \
-      ET_INTERNAL_SWITCH_CASE_REAL_TYPES(CTYPE_ALIAS, __VA_ARGS__))
-
-#define ET_SWITCH_REAL_TYPES_AND(ADDITIONAL, TYPE, CONTEXT, NAME, CTYPE_ALIAS, \
-                                 ...)                                          \
-  ET_INTERNAL_SWITCH(TYPE, CONTEXT, NAME,                                      \
-                     ET_INTERNAL_SWITCH_CASE_REAL_TYPES_AND(                   \
-                         ADDITIONAL, CTYPE_ALIAS, __VA_ARGS__))
-
-#define ET_SWITCH_REAL_TYPES_AND2(ADDITIONAL1, ADDITIONAL2, TYPE, CONTEXT,     \
-                                  NAME, CTYPE_ALIAS, ...)                      \
-  ET_INTERNAL_SWITCH(TYPE, CONTEXT, NAME,                                      \
-                     ET_INTERNAL_SWITCH_CASE_REAL_TYPES_AND2(                  \
-                         ADDITIONAL1, ADDITIONAL2, CTYPE_ALIAS, __VA_ARGS__))
-
-#define ET_SWITCH_REAL_TYPES_AND3(ADDITIONAL1, ADDITIONAL2, ADDITIONAL3, TYPE, \
-                                  CONTEXT, NAME, CTYPE_ALIAS, ...)             \
-  ET_INTERNAL_SWITCH(                                                          \
-      TYPE, CONTEXT, NAME,                                                     \
-      ET_INTERNAL_SWITCH_CASE_REAL_TYPES_AND3(                                 \
-          ADDITIONAL1, ADDITIONAL2, ADDITIONAL3, CTYPE_ALIAS, __VA_ARGS__))
-
-#define ET_SWITCH_REALH_TYPES(TYPE, CONTEXT, NAME, CTYPE_ALIAS, ...)           \
-  ET_SWITCH_REAL_TYPES_AND(Half, TYPE, CONTEXT, NAME, CTYPE_ALIAS, __VA_ARGS__)
-
-#define ET_SWITCH_REALHBF16_TYPES(TYPE, CONTEXT, NAME, CTYPE_ALIAS, ...)       \
-  ET_SWITCH_REAL_TYPES_AND2(Half, BFloat16, TYPE, CONTEXT, NAME, CTYPE_ALIAS,  \
-                            __VA_ARGS__)
-
-#define ET_SWITCH_REALB_TYPES(TYPE, CONTEXT, NAME, CTYPE_ALIAS, ...)           \
-  ET_SWITCH_REAL_TYPES_AND(Bool, TYPE, CONTEXT, NAME, CTYPE_ALIAS, __VA_ARGS__)
-
-#define ET_SWITCH_REALHB_TYPES(TYPE, CONTEXT, NAME, CTYPE_ALIAS, ...)          \
-  ET_SWITCH_REAL_TYPES_AND2(Half, Bool, TYPE, CONTEXT, NAME, CTYPE_ALIAS,      \
-                            __VA_ARGS__)
-
-#define ET_SWITCH_REALHBBF16_TYPES(TYPE, CONTEXT, NAME, CTYPE_ALIAS, ...)      \
-  ET_SWITCH_REAL_TYPES_AND3(Half, Bool, BFloat16, TYPE, CONTEXT, NAME,         \
-                            CTYPE_ALIAS, __VA_ARGS__)
-
-#define ET_SWITCH_REALHBBF16_AND_UINT_TYPES(TYPE, CONTEXT, NAME, CTYPE_ALIAS,  \
-                                            ...)                               \
-  ET_INTERNAL_SWITCH(                                                          \
-      TYPE, CONTEXT, NAME,                                                     \
-      ET_INTERNAL_SWITCH_CASE_REAL_TYPES_AND3(Half, Bool, BFloat16,            \
-                                              CTYPE_ALIAS, __VA_ARGS__)        \
-          ET_INTERNAL_SWITCH_CASE_UINT_TYPES(CTYPE_ALIAS, __VA_ARGS__))
-
-#define ET_SWITCH_INT_TYPES(TYPE, CONTEXT, NAME, CTYPE_ALIAS, ...)             \
-  ET_INTERNAL_SWITCH(                                                          \
-      TYPE, CONTEXT, NAME,                                                     \
-      ET_INTERNAL_SWITCH_CASE_INT_TYPES(CTYPE_ALIAS, __VA_ARGS__))
-
-#define ET_SWITCH_INT_TYPES_AND(ADDITIONAL, TYPE, CONTEXT, NAME, CTYPE_ALIAS,  \
-                                ...)                                           \
-  ET_INTERNAL_SWITCH(TYPE, CONTEXT, NAME,                                      \
-                     ET_INTERNAL_SWITCH_CASE_INT_TYPES_AND(                    \
-                         ADDITIONAL, CTYPE_ALIAS, __VA_ARGS__))
-
-#define ET_SWITCH_FLOAT_TYPES(TYPE, CONTEXT, NAME, CTYPE_ALIAS, ...)           \
-  ET_INTERNAL_SWITCH(                                                          \
-      TYPE, CONTEXT, NAME,                                                     \
-      ET_INTERNAL_SWITCH_CASE_FLOAT_TYPES(CTYPE_ALIAS, __VA_ARGS__))
-
-#define ET_SWITCH_FLOAT_TYPES_AND(ADDITIONAL, TYPE, CONTEXT, NAME,             \
-                                  CTYPE_ALIAS, ...)                            \
-  ET_INTERNAL_SWITCH(TYPE, CONTEXT, NAME,                                      \
-                     ET_INTERNAL_SWITCH_CASE_FLOAT_TYPES_AND(                  \
-                         ADDITIONAL, CTYPE_ALIAS, __VA_ARGS__))
-
-#define ET_SWITCH_FLOAT_TYPES_AND2(ADDITIONAL1, ADDITIONAL2, TYPE, CONTEXT,    \
-                                   NAME, CTYPE_ALIAS, ...)                     \
-  ET_INTERNAL_SWITCH(TYPE, CONTEXT, NAME,                                      \
-                     ET_INTERNAL_SWITCH_CASE_FLOAT_TYPES_AND2(                 \
-                         ADDITIONAL1, ADDITIONAL2, CTYPE_ALIAS, __VA_ARGS__))
-
-#define ET_SWITCH_FLOAT_TYPES_AND3(ADDITIONAL1, ADDITIONAL2, ADDITIONAL3,      \
-                                   TYPE, CONTEXT, NAME, CTYPE_ALIAS, ...)      \
-  ET_INTERNAL_SWITCH(                                                          \
-      TYPE, CONTEXT, NAME,                                                     \
-      ET_INTERNAL_SWITCH_CASE_FLOAT_TYPES_AND3(                                \
-          ADDITIONAL1, ADDITIONAL2, ADDITIONAL3, CTYPE_ALIAS, __VA_ARGS__))
-
-#define ET_SWITCH_FLOATH_TYPES(TYPE, CONTEXT, NAME, CTYPE_ALIAS, ...)          \
-  ET_SWITCH_FLOAT_TYPES_AND(Half, TYPE, CONTEXT, NAME, CTYPE_ALIAS, __VA_ARGS__)
-
-#define ET_SWITCH_FLOATHBF16_TYPES(TYPE, CONTEXT, NAME, CTYPE_ALIAS, ...)      \
-  ET_SWITCH_FLOAT_TYPES_AND2(Half, BFloat16, TYPE, CONTEXT, NAME, CTYPE_ALIAS, \
-                             __VA_ARGS__)
-
-#define ET_SWITCH_FLOATHBF16_TYPES_AND(ADDITIONAL, TYPE, CONTEXT, NAME,        \
-                                       CTYPE_ALIAS, ...)                       \
-  ET_SWITCH_FLOAT_TYPES_AND3(Half, BFloat16, ADDITIONAL, TYPE, CONTEXT, NAME,  \
-                             CTYPE_ALIAS, __VA_ARGS__)
-
-#define ET_SWITCH_QINT_TYPES(TYPE, CONTEXT, NAME, CTYPE_ALIAS, ...)            \
-  ET_INTERNAL_SWITCH(                                                          \
-      TYPE, CONTEXT, NAME,                                                     \
-      ET_INTERNAL_SWITCH_CASE_QINT_TYPES(CTYPE_ALIAS, __VA_ARGS__))
-
-#define ET_SWITCH_COMPLEX_TYPES(TYPE, CONTEXT, NAME, CTYPE_ALIAS, ...)         \
-  ET_INTERNAL_SWITCH(                                                          \
-      TYPE, CONTEXT, NAME,                                                     \
-      ET_INTERNAL_SWITCH_CASE_COMPLEX_TYPES(CTYPE_ALIAS, __VA_ARGS__))
-
-#define ET_SWITCH_COMPLEXH_TYPES(TYPE, CONTEXT, NAME, CTYPE_ALIAS, ...)        \
-  ET_INTERNAL_SWITCH(                                                          \
-      TYPE, CONTEXT, NAME,                                                     \
-      ET_INTERNAL_SWITCH_CASE_COMPLEXH_TYPES(CTYPE_ALIAS, __VA_ARGS__))
-
-#define ET_SWITCH_SCALAR_OBJ_TYPES(TYPE, CONTEXT, NAME, CTYPE_ALIAS, ...)      \
-  ET_INTERNAL_SWITCH(                                                          \
-      TYPE, CONTEXT, NAME,                                                     \
-      ET_INTERNAL_SWITCH_CASE_SCALAR_OBJ_TYPES(CTYPE_ALIAS, __VA_ARGS__))
-
-#define ET_SWITCH_SCALAR_OBJ_REAL_TYPES(TYPE, CONTEXT, NAME, CTYPE_ALIAS, ...) \
-  ET_INTERNAL_SWITCH(                                                          \
-      TYPE, CONTEXT, NAME,                                                     \
-      ET_INTERNAL_SWITCH_CASE_SCALAR_OBJ_REAL_TYPES(CTYPE_ALIAS, __VA_ARGS__))
-
-#define ET_SWITCH_SCALAR_OBJ_INTB_TYPES(TYPE, CONTEXT, NAME, CTYPE_ALIAS, ...) \
-  ET_INTERNAL_SWITCH(                                                          \
-      TYPE, CONTEXT, NAME,                                                     \
-      ET_INTERNAL_SWITCH_CASE_SCALAR_OBJ_INTB_TYPES(CTYPE_ALIAS, __VA_ARGS__))
-
-#define ET_SWITCH_SCALAR_OBJ_FLOATB_TYPES(TYPE, CONTEXT, NAME, CTYPE_ALIAS,    \
-                                          ...)                                 \
-  ET_INTERNAL_SWITCH(TYPE, CONTEXT, NAME,                                      \
-                     ET_INTERNAL_SWITCH_CASE_SCALAR_OBJ_FLOATB_TYPES(          \
-                         CTYPE_ALIAS, __VA_ARGS__))
-
-#define ET_SWITCH_TWO_TYPES(T1, T2, TYPE, CONTEXT, NAME, CTYPE_ALIAS, ...)     \
-  ET_INTERNAL_SWITCH(                                                          \
-      TYPE, CONTEXT, NAME,                                                     \
-      ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::T1, CTYPE_ALIAS, \
-                              __VA_ARGS__)                                     \
-          ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::T2,          \
-                                  CTYPE_ALIAS, __VA_ARGS__))
-
-#define ET_SWITCH_THREE_TYPES(T1, T2, T3, TYPE, CONTEXT, NAME, CTYPE_ALIAS,    \
-                              ...)                                             \
-  ET_INTERNAL_SWITCH(                                                          \
-      TYPE, CONTEXT, NAME,                                                     \
-      ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::T1, CTYPE_ALIAS, \
-                              __VA_ARGS__)                                     \
-          ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::T2,          \
-                                  CTYPE_ALIAS, __VA_ARGS__)                    \
-              ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::T3,      \
-                                      CTYPE_ALIAS, __VA_ARGS__))
-
-#define ET_SWITCH_FOUR_TYPES(T1, T2, T3, T4, TYPE, CONTEXT, NAME, CTYPE_ALIAS, \
-                             ...)                                              \
-  ET_INTERNAL_SWITCH(                                                          \
-      TYPE, CONTEXT, NAME,                                                     \
-      ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::T1, CTYPE_ALIAS, \
-                              __VA_ARGS__)                                     \
-          ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::T2,          \
-                                  CTYPE_ALIAS, __VA_ARGS__)                    \
-              ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::T3,      \
-                                      CTYPE_ALIAS, __VA_ARGS__)                \
-                  ET_INTERNAL_SWITCH_CASE(::executorch::aten::ScalarType::T4,  \
-                                          CTYPE_ALIAS, __VA_ARGS__))
-
-} // namespace runtime
-} // namespace executorch
-
-namespace executorch {
-namespace aten {
-#ifdef USE_ATEN_LIB
-using ::at::elementSize;
-#else  // USE_ATEN_LIB
-using ::executorch::runtime::elementSize;
-#endif // USE_ATEN_LIB
-} // namespace aten
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::can_cast;
-using ::executorch::runtime::canCast;
-using ::executorch::runtime::convert;
-using ::executorch::runtime::CppTypeToScalarType;
-using ::executorch::runtime::elementSize;
-using ::executorch::runtime::is_barebones_unsigned_type;
-using ::executorch::runtime::is_bits_type;
-using ::executorch::runtime::is_complex_type;
-using ::executorch::runtime::is_float8_type;
-using ::executorch::runtime::is_integral_type;
-using ::executorch::runtime::is_qint_type;
-using ::executorch::runtime::isBitsType;
-using ::executorch::runtime::isComplexType;
-using ::executorch::runtime::isFloatingType;
-using ::executorch::runtime::isIntegralType;
-using ::executorch::runtime::isQIntType;
-using ::executorch::runtime::isRealHBType;
-using ::executorch::runtime::isRealHType;
-using ::executorch::runtime::isRealType;
-using ::executorch::runtime::isValid;
-using ::executorch::runtime::promote_types;
-using ::executorch::runtime::promoteTypes;
-using ::executorch::runtime::ScalarTypeToCppType;
-using ::executorch::runtime::toString;
-#if !defined(USE_ATEN_LIB)
-using ::executorch::runtime::is_floating_point;
-using ::executorch::runtime::is_reduced_floating_point;
-#endif
-namespace internal {
-using ::executorch::runtime::internal::B1;
-using ::executorch::runtime::internal::C2;
-using ::executorch::runtime::internal::C4;
-using ::executorch::runtime::internal::C8;
-using ::executorch::runtime::internal::F2;
-using ::executorch::runtime::internal::F4;
-using ::executorch::runtime::internal::F8;
-using ::executorch::runtime::internal::I1;
-using ::executorch::runtime::internal::I2;
-using ::executorch::runtime::internal::I4;
-using ::executorch::runtime::internal::I8;
-using ::executorch::runtime::internal::U1;
-} // namespace internal
-} // namespace executor
-} // namespace torch
-
-C10_DIAGNOSTIC_POP()
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/exec_aten/util/tensor_dimension_limit.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/exec_aten/util/tensor_dimension_limit.h
deleted file mode 100644
index 6e072ab058..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/exec_aten/util/tensor_dimension_limit.h
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-namespace executorch::runtime {
-/**
- * The expected output size may not be the existing size of any inputs and
- * outputs if the operator supports both broadcast and dynamic shape.
- * Therefore such operators needs extra space to store the calculated expected
- * output size. such dynamic allocation is troublesome in executorch so we can
- * just hard code a static value of a relatively small value because users
- * don't create high dimensional tensors.
- */
-constexpr size_t kTensorDimensionLimit = 16;
-} // namespace executorch::runtime
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/exec_aten/util/tensor_shape_to_c_string.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/exec_aten/util/tensor_shape_to_c_string.h
deleted file mode 100644
index 4db9b48fab..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/exec_aten/util/tensor_shape_to_c_string.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <array>
-#include <cstddef>
-#include <cstdint>
-#include <limits>
-
-#include <executorch/runtime/core/exec_aten/util/tensor_dimension_limit.h>
-#include <executorch/runtime/core/span.h>
-
-namespace executorch::runtime {
-
-/**
- * Maximum size of a string returned by tensor_shape_to_c_string, for
- * stack allocation.
- */
-constexpr size_t kTensorShapeStringSizeLimit =
-    1 +                          /* opening parenthesis */
-    10 * kTensorDimensionLimit + /* maximum digits we will print; update
-                                  * kMaximumPrintableTensorShapeElement
-                                  * if changing */
-    2 * kTensorDimensionLimit +  /* comma and space after each item,
-                                  * overwritten with closing paren and
-                                  * NUL terminator for last element */
-    1; /* padding for temporary NUL terminator for simplicity of implementation
-        */
-
-namespace internal {
-constexpr size_t kMaximumPrintableTensorShapeElement =
-    std::numeric_limits<int32_t>::max();
-} // namespace internal
-
-/**
- * Convert a shape to a NUL-terminated C string with limited size. If
- * elements of the shape are larger than
- * kMaximumPrintableTensorShapeElement, those elements will be
- * rendered as ERR instead.
- *
- * NOTE: There are two overloads of this function to support both ATen
- * tensors and ExecuTorch Tensors, which have different SizesType,
- * while also avoiding a dependency on exec_aten.h from this header
- * because that would cause a circular dependency.
- */
-std::array<char, kTensorShapeStringSizeLimit>
-tensor_shape_to_c_string(executorch::runtime::Span<const std::int32_t> shape);
-
-/**
- * Convert a shape to a NUL-terminated C string with limited size. If
- * elements of the shape are larger than
- * kMaximumPrintableTensorShapeElement, those elements will be
- * rendered as ERR instead.
- *
- * NOTE: There are two overloads of this function to support both ATen
- * tensors and ExecuTorch Tensors, which have different SizesType,
- * while also avoiding a dependency on exec_aten.h from this header
- * because that would cause a circular dependency.
- */
-std::array<char, kTensorShapeStringSizeLimit>
-tensor_shape_to_c_string(executorch::runtime::Span<const std::int64_t> shape);
-
-} // namespace executorch::runtime
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/exec_aten/util/tensor_util.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/exec_aten/util/tensor_util.h
deleted file mode 100644
index 05e4c427f3..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/exec_aten/util/tensor_util.h
+++ /dev/null
@@ -1,1255 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <algorithm>
-#include <array> // std::array
-#include <c10/util/irange.h>
-#include <cinttypes> // PRId64
-#include <cmath>
-#include <cstddef> // size_t
-
-#include <limits>
-
-#include <c10/util/irange.h>
-#include <executorch/runtime/core/array_ref.h>
-#include <executorch/runtime/core/error.h>
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <executorch/runtime/core/exec_aten/util/dim_order_util.h>
-#include <executorch/runtime/core/exec_aten/util/scalar_type_util.h>
-#include <executorch/runtime/core/exec_aten/util/tensor_dimension_limit.h>
-#include <executorch/runtime/core/span.h>
-#include <executorch/runtime/platform/assert.h>
-#include <executorch/runtime/platform/compiler.h>
-
-/// All assertion messages should begin with this prefix.
-#define ET_TENSOR_CHECK_PREFIX__ "Tensors do not match"
-#define ET_MIN2(a, b) (std::min(a, b))
-#define ET_MIN3(a, b, c) (std::min(a, std::min(b, c)))
-
-#define ET_NORMALIZE_IX(IX, UPPER_BOUND) IX < 0 ? IX + UPPER_BOUND : IX
-
-#define ET_CHECK_VALID_IX(IX, UPPER_BOUND)                                     \
-  ET_CHECK_MSG(IX >= -static_cast<int64_t>(UPPER_BOUND) &&                     \
-                   IX < static_cast<int64_t>(UPPER_BOUND),                     \
-               "index %" PRId64 " must be within range [-%zd, %zd)", IX,       \
-               UPPER_BOUND, UPPER_BOUND)
-
-#define ET_CHECK_VALID_DIM(DIM, UPPER_BOUND)                                   \
-  ET_CHECK_MSG(DIM >= -static_cast<int64_t>(UPPER_BOUND) &&                    \
-                   DIM < static_cast<int64_t>(UPPER_BOUND),                    \
-               "dim %" PRId64 " must be within range [-%zd, %zd)", DIM,        \
-               UPPER_BOUND, UPPER_BOUND)
-
-#define ET_CHECK_NON_ZERO_DIM_SIZE(DIM, T)                                     \
-  const size_t udim = ET_NORMALIZE_IX(DIM, T.dim());                           \
-  ET_CHECK_MSG(T.size(udim) != 0, "Expected dim %zd to have non-zero size.",   \
-               udim);
-
-/**
- * Asserts that all tensors have the same shape.
- * This also handles a edge case where there is only one element in all the
- * tensors being compared but the number of dimensions >= 0. In the for loop
- * iterating over the dimensions we make sure that we pick the smallest
- * dimension of all the tensors as the upper bound for the for loop.
- */
-#define ET_CHECK_SAME_SHAPE2(a__, b__)                                         \
-  do {                                                                         \
-    const size_t a_numel__ = (a__).numel();                                    \
-    const size_t b_numel__ = (b__).numel();                                    \
-    const size_t a_dim__ = (a__).dim();                                        \
-    const size_t b_dim__ = (b__).dim();                                        \
-    ET_CHECK_MSG(                                                              \
-        a_numel__ == b_numel__ &&                                              \
-            ((a_numel__ == 1 && b_numel__ == 1) || (a_dim__ == b_dim__)),      \
-        ET_TENSOR_CHECK_PREFIX__ ": numel={%zu, %zu}, dim={%zu, %zu}",         \
-        a_numel__, b_numel__, a_dim__, b_dim__);                               \
-    for (size_t dim__ = 0; dim__ < ET_MIN2(a_dim__, b_dim__); ++dim__) {       \
-      size_t a_size__ = (a__).size(dim__);                                     \
-      size_t b_size__ = (b__).size(dim__);                                     \
-      ET_CHECK_MSG(a_size__ == b_size__,                                       \
-                   ET_TENSOR_CHECK_PREFIX__ " at size(%zu): {%zu, %zu}",       \
-                   dim__, a_size__, b_size__);                                 \
-    }                                                                          \
-  } while (0)
-
-#define ET_CHECK_SAME_SHAPE3(a__, b__, c__)                                    \
-  do {                                                                         \
-    const size_t a_numel__ = (a__).numel();                                    \
-    const size_t b_numel__ = (b__).numel();                                    \
-    const size_t c_numel__ = (c__).numel();                                    \
-    const size_t a_dim__ = (a__).dim();                                        \
-    const size_t b_dim__ = (b__).dim();                                        \
-    const size_t c_dim__ = (c__).dim();                                        \
-    ET_CHECK_MSG(a_numel__ == b_numel__ && b_numel__ == c_numel__ &&           \
-                     ((a_numel__ == 1 && b_numel__ == 1 && c_numel__ == 1) ||  \
-                      a_dim__ == b_dim__ && b_dim__ == c_dim__),               \
-                 ET_TENSOR_CHECK_PREFIX__                                      \
-                 ": numel={%zu, %zu, %zu}, dim={%zu, %zu, %zu}",               \
-                 a_numel__, b_numel__, c_numel__, a_dim__, b_dim__, c_dim__);  \
-    for (size_t dim__ = 0; dim__ < ET_MIN3(a_dim__, b_dim__, c_dim__);         \
-         ++dim__) {                                                            \
-      size_t a_size__ = (a__).size(dim__);                                     \
-      size_t b_size__ = (b__).size(dim__);                                     \
-      size_t c_size__ = (c__).size(dim__);                                     \
-      ET_CHECK_MSG(a_size__ == b_size__ && b_size__ == c_size__,               \
-                   ET_TENSOR_CHECK_PREFIX__ " at size(%zu): {%zu, %zu, %zu}",  \
-                   dim__, a_size__, b_size__, c_size__);                       \
-    }                                                                          \
-  } while (0)
-
-/// Asserts that all tensors have the same dtype.
-#define ET_CHECK_SAME_DTYPE2(a__, b__)                                         \
-  do {                                                                         \
-    const ::executorch::aten::ScalarType a_type__ = (a__).scalar_type();       \
-    const ::executorch::aten::ScalarType b_type__ = (b__).scalar_type();       \
-    ET_CHECK_MSG(a_type__ == b_type__,                                         \
-                 ET_TENSOR_CHECK_PREFIX__ ": dtype={%" PRId8 ", %" PRId8 "}",  \
-                 static_cast<int8_t>(a_type__),                                \
-                 static_cast<int8_t>(b_type__));                               \
-  } while (0)
-
-#define ET_CHECK_SAME_DTYPE3(a__, b__, c__)                                    \
-  do {                                                                         \
-    const ::executorch::aten::ScalarType a_type__ = (a__).scalar_type();       \
-    const ::executorch::aten::ScalarType b_type__ = (b__).scalar_type();       \
-    const ::executorch::aten::ScalarType c_type__ = (c__).scalar_type();       \
-    ET_CHECK_MSG(a_type__ == b_type__ && b_type__ == c_type__,                 \
-                 ET_TENSOR_CHECK_PREFIX__ ": dtype={%" PRId8 ", %" PRId8       \
-                                          ", %" PRId8 "}",                     \
-                 static_cast<int8_t>(a_type__), static_cast<int8_t>(b_type__), \
-                 static_cast<int8_t>(c_type__));                               \
-  } while (0)
-
-/**
- * Asserts that all tensors have the same shape and dtype.
- *
- * This macro should produce less code/data than calling the SHAPE and DTYPE
- * macros independently, because it only calls ET_CHECK_MSG once.
- */
-#define ET_CHECK_SAME_SHAPE_AND_DTYPE2(a__, b__)                               \
-  do {                                                                         \
-    const size_t a_numel__ = (a__).numel();                                    \
-    const size_t b_numel__ = (b__).numel();                                    \
-    const size_t a_dim__ = (a__).dim();                                        \
-    const size_t b_dim__ = (b__).dim();                                        \
-    const ::executorch::aten::ScalarType a_type__ = (a__).scalar_type();       \
-    const ::executorch::aten::ScalarType b_type__ = (b__).scalar_type();       \
-                                                                               \
-    ET_CHECK_MSG(                                                              \
-        a_numel__ == b_numel__ &&                                              \
-            ((a_numel__ == 1 && b_numel__ == 1) || a_dim__ == b_dim__) &&      \
-            a_type__ == b_type__,                                              \
-        ET_TENSOR_CHECK_PREFIX__                                               \
-        ": numel={%zu, %zu}, dim={%zu, %zu}, dtype={%" PRId8 ", %" PRId8 "}",  \
-        a_numel__, b_numel__, a_dim__, b_dim__, static_cast<int8_t>(a_type__), \
-        static_cast<int8_t>(b_type__));                                        \
-    for (size_t dim__ = 0; dim__ < ET_MIN2(a_dim__, b_dim__); ++dim__) {       \
-      size_t a_size__ = (a__).size(dim__);                                     \
-      size_t b_size__ = (b__).size(dim__);                                     \
-      ET_CHECK_MSG(a_size__ == b_size__,                                       \
-                   ET_TENSOR_CHECK_PREFIX__ " at size(%zu): {%zu, %zu}",       \
-                   dim__, a_size__, b_size__);                                 \
-    }                                                                          \
-  } while (0)
-
-#define ET_CHECK_SAME_SHAPE_AND_DTYPE3(a__, b__, c__)                          \
-  do {                                                                         \
-    const size_t a_numel__ = (a__).numel();                                    \
-    const size_t b_numel__ = (b__).numel();                                    \
-    const size_t c_numel__ = (c__).numel();                                    \
-    const size_t a_dim__ = (a__).dim();                                        \
-    const size_t b_dim__ = (b__).dim();                                        \
-    const size_t c_dim__ = (c__).dim();                                        \
-    const ::executorch::aten::ScalarType a_type__ = (a__).scalar_type();       \
-    const ::executorch::aten::ScalarType b_type__ = (b__).scalar_type();       \
-    const ::executorch::aten::ScalarType c_type__ = (c__).scalar_type();       \
-                                                                               \
-    ET_CHECK_MSG(a_numel__ == b_numel__ && b_numel__ == c_numel__ &&           \
-                     ((a_numel__ == 1 && b_numel__ == 1 && c_numel__ == 1) ||  \
-                      (a_dim__ == b_dim__ && b_dim__ == c_dim__)) &&           \
-                     a_type__ == b_type__ && b_type__ == c_type__,             \
-                 ET_TENSOR_CHECK_PREFIX__                                      \
-                 ": numel={%zu, %zu, %zu}, dim={%zu, %zu, %zu}, "              \
-                 "dtype={%" PRId8 ", %" PRId8 ", %" PRId8 "}",                 \
-                 a_numel__, b_numel__, c_numel__, a_dim__, b_dim__, c_dim__,   \
-                 static_cast<int8_t>(a_type__), static_cast<int8_t>(b_type__), \
-                 static_cast<int8_t>(c_type__));                               \
-    for (size_t dim__ = 0; dim__ < ET_MIN3(a_dim__, b_dim__, c_dim__);         \
-         ++dim__) {                                                            \
-      size_t a_size__ = (a__).size(dim__);                                     \
-      size_t b_size__ = (b__).size(dim__);                                     \
-      size_t c_size__ = (c__).size(dim__);                                     \
-      ET_CHECK_MSG(a_size__ == b_size__ && b_size__ == c_size__,               \
-                   ET_TENSOR_CHECK_PREFIX__ " at size(%zu): {%zu, %zu, %zu}",  \
-                   dim__, a_size__, b_size__, c_size__);                       \
-    }                                                                          \
-  } while (0)
-
-/**
- * Assert that the input tensor is contiguous tensor.
- */
-#define ET_CHECK_CONTIGUOUS(a__)                                               \
-  do {                                                                         \
-    const ::executorch::aten::ArrayRef<executorch::aten::StridesType>          \
-        strides = a__.strides();                                               \
-    const ::executorch::aten::ArrayRef<executorch::aten::StridesType> sizes =  \
-        a__.sizes();                                                           \
-    ET_CHECK_MSG(                                                              \
-        strides[strides.size() - 1] == 1,                                      \
-        "The stride of the last dimension shall be 1 for contiguous tensor, "  \
-        "not %d",                                                              \
-        strides[strides.size() - 1]);                                          \
-    for (size_t i = strides.size() - 1; i > 0; i--) {                          \
-      ET_CHECK_MSG(strides[i - 1] == strides[i] * sizes[i],                    \
-                   "The stride of the %zu-th dimension shall equal to "        \
-                   "strides[%zu] * sizes[%zu], now is %d and %d",              \
-                   i - 1, i, i, strides[i - 1], strides[i] * sizes[i]);        \
-    }                                                                          \
-  } while (0)
-
-/**
- * Assert the input two tensors share same strides.
- * Noted that this function does not make any check or promise on the contiguity
- * of any input tensors.
- */
-#define ET_CHECK_SAME_STRIDES2(a__, b__)                                       \
-  do {                                                                         \
-    ET_CHECK_MSG(                                                              \
-        a__.dim() == b__.dim(),                                                \
-        "Two tensors shall have same number of strides, but not %zu and %zu.", \
-        a__.dim(), b__.dim());                                                 \
-    const ::executorch::aten::ArrayRef<executorch::aten::StridesType>          \
-        a_strides = a__.strides();                                             \
-    const ::executorch::aten::ArrayRef<executorch::aten::StridesType>          \
-        b_strides = b__.strides();                                             \
-    for (const auto i : c10::irange(a__.dim())) {                              \
-      ET_CHECK_MSG(a_strides[i] == b_strides[i],                               \
-                   "a.strides()[%zu] shall equal to b.strides()[%zu], "        \
-                   "but now is %d and %d.",                                    \
-                   i, i, (int32_t)a_strides[i], (int32_t)b_strides[i]);        \
-    }                                                                          \
-  } while (0)
-
-/**
- * Assert the input three tensors share same strides.
- * Noted that this function does not make any check or promise on the contiguity
- * of any input tensors.
- */
-#define ET_CHECK_SAME_STRIDES3(a__, b__, c__)                                  \
-  do {                                                                         \
-    ET_CHECK_MSG(a__.dim() == b__.dim() && b__.dim() == c__.dim(),             \
-                 "Three tensors shall have same number of strides, "           \
-                 "but not %zu, %zu and %zu.",                                  \
-                 a__.dim(), b__.dim(), c__.dim());                             \
-    const ::executorch::aten::ArrayRef<executorch::aten::StridesType>          \
-        a_strides = a__.strides();                                             \
-    const ::executorch::aten::ArrayRef<executorch::aten::StridesType>          \
-        b_strides = b__.strides();                                             \
-    const ::executorch::aten::ArrayRef<executorch::aten::StridesType>          \
-        c_strides = c__.strides();                                             \
-    for (const auto i : c10::irange(a__.dim())) {                              \
-      ET_CHECK_MSG(a_strides[i] == b_strides[i] &&                             \
-                       b_strides[i] == c_strides[i],                           \
-                   "a_strides[%zu], b_strides[%zu] and c_strides[%zu] "        \
-                   "shall share same value, but now is %d, %d and %d",         \
-                   i, i, i, (int32_t)a_strides[i], (int32_t)b_strides[i],      \
-                   (int32_t)c_strides[i]);                                     \
-    }                                                                          \
-  } while (0)
-
-#define ET_CHECK_DEFAULT_OR_CHANNELSLAST_DIMORDER(t__)                         \
-  do {                                                                         \
-    ET_CHECK_MSG(is_contiguous_dim_order(t__.dim_order().data(),               \
-                                         t__.dim_order().size()) ||            \
-                     is_channels_last_dim_order(t__.dim_order().data(),        \
-                                                t__.dim_order().size()),       \
-                 "Tensor must have default or channels last dim order");       \
-  } while (0)
-
-/**
- * DEPRECATED: Please use ET_CHECK_OR_RETURN_FALSE instead and provide
- * an informative message. (For example, the values of any variables used in
- * `cond` would not be reported automatically by this macro.)
- *
- * A convenience macro to be used in utility functions that check whether input
- * tensor(s) are valid, which are expected to return a boolean. Checks whether
- * `cond` is true; if not, log the failed check and return false.
- *
- * @param[in] cond the condition to check
- */
-#define ET_LOG_AND_RETURN_IF_FALSE(cond) ET_CHECK_OR_RETURN_FALSE(cond, "")
-
-/**
- * DEPRECATED: Please use ET_CHECK_OR_RETURN_FALSE instead.
- */
-#define ET_LOG_MSG_AND_RETURN_IF_FALSE ET_CHECK_OR_RETURN_FALSE
-
-/**
- * If `cond` is false, log `cond` and return from the kernel with a failure
- * state set.
- *
- * @param[in] context the runtime context
- * @param[in] cond the condition to check
- * @param[in] error torch::executor::Error enum value (e.g `InvalidArgument`)
- * @param[in] retval return value of the kernel to allow for early exit
- */
-#define ET_KERNEL_CHECK(context, cond, error, retval)                          \
-  do {                                                                         \
-    if (!(cond)) {                                                             \
-      ET_LOG(Error, "Check failed (%s): ", #cond);                             \
-      context.fail(torch::executor::Error::error);                             \
-      return retval;                                                           \
-    }                                                                          \
-  } while (false)
-
-/**
- * If `cond` is false, log `message` and return from the kernel with a failure
- * state set.
- *
- * @param[in] context the runtime context
- * @param[in] cond the condition to check
- * @param[in] error torch::executor::Error enum value (e.g `InvalidArgument`)
- * @param[in] retval return value of the kernel to allow for early exit
- */
-#define ET_KERNEL_CHECK_MSG(context, cond, error, retval, message, ...)        \
-  do {                                                                         \
-    if (!(cond)) {                                                             \
-      ET_LOG(Error, "Check failed (%s): " message, #cond, ##__VA_ARGS__);      \
-      context.fail(torch::executor::Error::error);                             \
-      return retval;                                                           \
-    }                                                                          \
-  } while (false)
-
-/**
- * Convenience macro to extract a scalar tensor into a value
- */
-#define ET_EXTRACT_SCALAR_TENSOR(scalar_tensor, out_val)                       \
-  ET_CHECK_MSG(extract_scalar_tensor(scalar_tensor, &out_val), #scalar_tensor  \
-               " could not be extracted: wrong type or out of range");
-
-namespace executorch {
-namespace ET_RUNTIME_NAMESPACE {
-//
-// Utility functions for checking tensor attributes
-//
-//
-
-/*
- * Returns true if the given dimension value is between -upper_bound and
- * upper_bound - 1, inclusive.
- */
-inline bool dim_is_valid(int64_t dim, int64_t upper_bound) {
-  ET_CHECK_OR_RETURN_FALSE(
-      dim >= -upper_bound && dim < upper_bound,
-      "Dimension %" PRId64
-      " is out of range. Dimension should be between %" PRId64 " and %" PRId64
-      ", inclusive.",
-      dim, -upper_bound, upper_bound - 1);
-
-  return true;
-}
-
-/*
- * Returns the tensor's number of dimensions, except when the tensor is zero
- * dimensional. In this case, it returns 1. This is used to properly handle
- * the zero dimensional tensors in some kernels, that treat them as 1D tensors
- * with a single element.
- */
-inline ssize_t nonzero_dim(const executorch::aten::Tensor &tensor) {
-  return tensor.dim() == 0 ? 1 : tensor.dim();
-}
-
-/*
- * Returns the size along a dimension dim, except when the tensor is zero
- * dimensional. In this case, it returns 1. This is used to properly handle
- * the zero dimensional tensors in some kernels, that treat them as 1D tensors
- * with a single element.
- */
-inline ssize_t nonempty_size(const executorch::aten::Tensor &tensor,
-                             ssize_t dim) {
-  return tensor.dim() == 0 ? 1 : tensor.size(dim);
-}
-
-inline bool tensor_can_cast_to(executorch::aten::Tensor a,
-                               executorch::aten::ScalarType dtype) {
-  ET_CHECK_OR_RETURN_FALSE(::torch::executor::canCast(a.scalar_type(), dtype),
-                           "Tensor of dtype %s cannot cast to dtype %s",
-                           ::torch::executor::toString(a.scalar_type()),
-                           ::torch::executor::toString(dtype));
-
-  return true;
-}
-
-inline bool tensor_is_bool_type(executorch::aten::Tensor t) {
-  ET_CHECK_OR_RETURN_FALSE(t.scalar_type() ==
-                               executorch::aten::ScalarType::Bool,
-                           "Expected to find bool type, but tensor has type %s",
-                           ::torch::executor::toString(t.scalar_type()));
-
-  return true;
-}
-
-inline bool tensor_is_type(executorch::aten::Tensor t,
-                           executorch::aten::ScalarType dtype) {
-  ET_CHECK_OR_RETURN_FALSE(t.scalar_type() == dtype,
-                           "Expected to find %s type, but tensor has type %s",
-                           ::torch::executor::toString(dtype),
-                           ::torch::executor::toString(t.scalar_type()));
-
-  return true;
-}
-
-inline bool tensor_is_type(executorch::aten::Tensor t,
-                           executorch::aten::ScalarType dtype,
-                           executorch::aten::ScalarType dtype2) {
-  ET_LOG_MSG_AND_RETURN_IF_FALSE(
-      t.scalar_type() == dtype || t.scalar_type() == dtype2,
-      "Expected to find %s or %s type, but tensor has type %s",
-      ::torch::executor::toString(dtype), ::torch::executor::toString(dtype2),
-      ::torch::executor::toString(t.scalar_type()));
-
-  return true;
-}
-
-inline bool tensor_is_type(executorch::aten::Tensor t,
-                           executorch::aten::ScalarType dtype,
-                           executorch::aten::ScalarType dtype2,
-                           executorch::aten::ScalarType dtype3) {
-  ET_LOG_MSG_AND_RETURN_IF_FALSE(
-      t.scalar_type() == dtype || t.scalar_type() == dtype2 ||
-          t.scalar_type() == dtype3,
-      "Expected to find %s, %s, or %s type, but tensor has type %s",
-      ::torch::executor::toString(dtype), ::torch::executor::toString(dtype2),
-      ::torch::executor::toString(dtype3),
-      ::torch::executor::toString(t.scalar_type()));
-
-  return true;
-}
-
-inline bool tensor_is_integral_type(executorch::aten::Tensor t,
-                                    bool includeBool = false) {
-  ET_CHECK_OR_RETURN_FALSE(
-      ::torch::executor::isIntegralType(t.scalar_type(), includeBool),
-      "Expected to find a integral type, but tensor has type %s",
-      ::torch::executor::toString(t.scalar_type()));
-
-  return true;
-}
-
-inline bool tensor_is_floating_type(executorch::aten::Tensor t) {
-  ET_CHECK_OR_RETURN_FALSE(
-      ::torch::executor::isFloatingType(t.scalar_type()),
-      "Expected to find a floating type, but tensor has type %s",
-      ::torch::executor::toString(t.scalar_type()));
-
-  return true;
-}
-
-inline bool tensor_is_real_type(executorch::aten::Tensor t) {
-  ET_CHECK_OR_RETURN_FALSE(
-      ::torch::executor::isRealType(t.scalar_type()),
-      "Expected to find a real type, but tensor has type %s",
-      ::torch::executor::toString(t.scalar_type()));
-
-  return true;
-}
-
-inline bool tensor_is_realh_type(executorch::aten::Tensor t) {
-  ET_CHECK_OR_RETURN_FALSE(
-      ::torch::executor::isRealHType(t.scalar_type()),
-      "Expected to find a real type, but tensor has type %s",
-      ::torch::executor::toString(t.scalar_type()));
-
-  return true;
-}
-
-inline bool tensor_is_realhbf16_type(executorch::aten::Tensor t) {
-  ET_CHECK_OR_RETURN_FALSE(
-      executorch::runtime::isRealHBF16Type(t.scalar_type()),
-      "Expected to find a real type, but tensor has type %s",
-      ::torch::executor::toString(t.scalar_type()));
-
-  return true;
-}
-
-inline bool tensor_is_realhb_type(executorch::aten::Tensor t) {
-  ET_CHECK_OR_RETURN_FALSE(
-      ::torch::executor::isRealHBType(t.scalar_type()),
-      "Expected to find a real type, but tensor has type %s",
-      ::torch::executor::toString(t.scalar_type()));
-
-  return true;
-}
-
-inline bool tensor_is_realhbbf16_type(executorch::aten::Tensor t) {
-  ET_CHECK_OR_RETURN_FALSE(
-      executorch::runtime::isRealHBBF16Type(t.scalar_type()),
-      "Expected to find a real type, but tensor has type %s",
-      ::torch::executor::toString(t.scalar_type()));
-
-  return true;
-}
-
-inline bool tensor_is_complex_type(executorch::aten::Tensor t) {
-  ET_CHECK_OR_RETURN_FALSE(
-      ::torch::executor::isComplexType(t.scalar_type()),
-      "Expected to find a complex type, but tensor has type %s",
-      ::torch::executor::toString(t.scalar_type()));
-
-  return true;
-}
-
-inline bool tensor_is_bits_type(executorch::aten::Tensor t) {
-  ET_CHECK_OR_RETURN_FALSE(
-      ::torch::executor::isBitsType(t.scalar_type()),
-      "Expected to find a bits type, but tensor has type %s",
-      ::torch::executor::toString(t.scalar_type()));
-
-  return true;
-}
-
-inline bool tensors_have_same_dtype(executorch::aten::Tensor a,
-                                    executorch::aten::Tensor b) {
-  ET_CHECK_OR_RETURN_FALSE(a.scalar_type() == b.scalar_type(),
-                           ET_TENSOR_CHECK_PREFIX__ ": dtype={%s, %s}",
-                           ::torch::executor::toString(a.scalar_type()),
-                           ::torch::executor::toString(b.scalar_type()));
-  return true;
-}
-
-inline bool tensors_have_same_dtype(executorch::aten::Tensor a,
-                                    executorch::aten::Tensor b,
-                                    executorch::aten::Tensor c) {
-  ET_CHECK_OR_RETURN_FALSE(a.scalar_type() == b.scalar_type() &&
-                               b.scalar_type() == c.scalar_type(),
-                           ET_TENSOR_CHECK_PREFIX__ ": dtype={%s, %s, %s}",
-                           ::torch::executor::toString(a.scalar_type()),
-                           ::torch::executor::toString(b.scalar_type()),
-                           ::torch::executor::toString(c.scalar_type()));
-  return true;
-}
-
-inline bool tensor_is_rank(executorch::aten::Tensor t, size_t rank) {
-  ET_CHECK_OR_RETURN_FALSE(static_cast<size_t>(t.dim()) == rank,
-                           "Expected tensor.dim() to be %zu, but got %zu",
-                           static_cast<size_t>(rank),
-                           static_cast<size_t>(t.dim()));
-
-  return true;
-}
-
-inline bool tensor_has_rank_greater_or_equal_to(executorch::aten::Tensor t,
-                                                size_t rank) {
-  ET_CHECK_OR_RETURN_FALSE(static_cast<size_t>(t.dim()) >= rank,
-                           "Expected tensor.dim() to be >= %zu, but got %zu",
-                           static_cast<size_t>(rank),
-                           static_cast<size_t>(t.dim()));
-
-  return true;
-}
-
-inline bool tensor_has_rank_smaller_or_equal_to(executorch::aten::Tensor t,
-                                                size_t rank) {
-  ET_CHECK_OR_RETURN_FALSE(static_cast<size_t>(t.dim()) <= rank,
-                           "Expected tensor.dim() to be <= %zu, but got %zu",
-                           static_cast<size_t>(rank),
-                           static_cast<size_t>(t.dim()));
-
-  return true;
-}
-
-inline bool tensor_has_dim(executorch::aten::Tensor t, int64_t d) {
-  if (t.dim() == 0) {
-    ET_CHECK_OR_RETURN_FALSE(
-        d == 0 || d == -1, "dim must be 0 or -1 for 0-dim tensor, got %" PRId64,
-        d);
-  } else {
-    ET_CHECK_OR_RETURN_FALSE(d > 0 ? d < t.dim() : t.dim() + d >= 0,
-                             "%zu-dim tensor does not have dim at index %zu",
-                             static_cast<size_t>(t.dim()),
-                             static_cast<size_t>(d));
-  }
-  return true;
-}
-
-inline bool tensor_has_non_empty_dim(executorch::aten::Tensor t, int64_t d) {
-  const size_t udim = ET_NORMALIZE_IX(d, t.dim());
-  ET_LOG_AND_RETURN_IF_FALSE(tensor_has_dim(t, d));
-  ET_LOG_AND_RETURN_IF_FALSE(t.size(udim) != 0);
-  return true;
-}
-
-inline bool tensor_dim_has_index(executorch::aten::Tensor t, int64_t d,
-                                 int64_t ix) {
-  // Indexing ops don't support zero-dim tensors
-  ET_CHECK(t.dim() != 0);
-  if (d < 0) {
-    d += t.dim();
-  }
-  // Dimension must have been already checked by tensor_has_dim
-  ET_CHECK(d >= 0 && d < t.dim());
-
-  ET_CHECK_OR_RETURN_FALSE(
-      ix >= -t.size(d) && ix < t.size(d),
-      "index %" PRId64 " out of range [-%zu,%zu) at dimension %" PRId64 ")", ix,
-      static_cast<size_t>(t.size(d)), static_cast<size_t>(t.size(d)), d);
-  return true;
-}
-
-inline bool tensors_have_same_size_at_dims(executorch::aten::Tensor a,
-                                           size_t dim_a,
-                                           executorch::aten::Tensor b,
-                                           size_t dim_b) {
-  ET_CHECK_OR_RETURN_FALSE(dim_a < static_cast<size_t>(a.dim()),
-                           "Cannot retrieve dim %zu from tensor with dim %zu",
-                           static_cast<size_t>(dim_a),
-                           static_cast<size_t>(a.dim()));
-  ET_CHECK_OR_RETURN_FALSE(dim_b < static_cast<size_t>(b.dim()),
-                           "Cannot retrieve dim %zu from tensor with dim %zu",
-                           static_cast<size_t>(dim_b),
-                           static_cast<size_t>(b.dim()));
-  ET_CHECK_OR_RETURN_FALSE(
-      a.size(dim_a) == b.size(dim_b),
-      ET_TENSOR_CHECK_PREFIX__
-      ": a.size(%zu) = %zu does not match b.size(%zu) = %zu",
-      static_cast<size_t>(dim_a), static_cast<size_t>(a.size(dim_a)),
-      static_cast<size_t>(dim_b), static_cast<size_t>(b.size(dim_b)));
-
-  return true;
-}
-
-inline bool tensors_have_same_shape(executorch::aten::Tensor a,
-                                    executorch::aten::Tensor b) {
-  if (a.numel() == 1 && b.numel() == 1) {
-    // PyTorch operators treat all scalar tensors as the same shape even if
-    // they have different dims.
-    return true;
-  }
-  if (!(a.sizes() == b.sizes() && a.numel() == b.numel())) {
-    ET_LOG(Error,
-           ET_TENSOR_CHECK_PREFIX__ ": numel=(%zu,  %zu), dim=(%zu, %zu)",
-           static_cast<size_t>(a.numel()), static_cast<size_t>(b.numel()),
-           static_cast<size_t>(a.dim()), static_cast<size_t>(b.dim()));
-    // Using [[maybe_unused]] as ET_LOG may not trigger based on verbosity
-    for ([[maybe_unused]] const auto d :
-         c10::irange(ET_MIN2(a.dim(), b.dim()))) {
-      ET_LOG(Error, "    size(%zu): (%zu, %zu)", static_cast<size_t>(d),
-             static_cast<size_t>(a.size(d)), static_cast<size_t>(b.size(d)));
-    }
-
-    return false;
-  }
-
-  return true;
-}
-
-inline bool tensors_have_same_shape(executorch::aten::Tensor a,
-                                    executorch::aten::Tensor b,
-                                    executorch::aten::Tensor c) {
-  if (a.numel() == 1 && b.numel() == 1 && c.numel() == 1) {
-    // PyTorch operators treat all scalar tensors as the same shape even if
-    // they have different dims.
-    return true;
-  }
-  bool cond1 = (a.sizes() == b.sizes()) && (a.numel() == b.numel());
-  bool cond2 = (b.sizes() == c.sizes()) && (b.numel() == c.numel());
-
-  if (!(cond1 && cond2)) {
-    ET_LOG(Error,
-           ET_TENSOR_CHECK_PREFIX__
-           ": numel=(%zu, %zu, %zu), dim=(%zu, %zu, %zu)",
-           static_cast<size_t>(a.numel()), static_cast<size_t>(b.numel()),
-           static_cast<size_t>(c.numel()), static_cast<size_t>(a.dim()),
-           static_cast<size_t>(b.dim()), static_cast<size_t>(c.dim()));
-    for ([[maybe_unused]] const auto d :
-         c10::irange(ET_MIN3(a.dim(), b.dim(), c.dim()))) {
-      ET_LOG(Error, "    size(%zu): (%zu, %zu, %zu)", static_cast<size_t>(d),
-             static_cast<size_t>(a.size(d)), static_cast<size_t>(b.size(d)),
-             static_cast<size_t>(c.size(d)));
-    }
-
-    return false;
-  }
-
-  return true;
-}
-
-inline bool tensors_have_same_shape_and_dtype(executorch::aten::Tensor a,
-                                              executorch::aten::Tensor b) {
-  return tensors_have_same_shape(a, b) && tensors_have_same_dtype(a, b);
-}
-
-inline bool tensors_have_same_shape_and_dtype(executorch::aten::Tensor a,
-                                              executorch::aten::Tensor b,
-                                              executorch::aten::Tensor c) {
-  return tensors_have_same_shape(a, b, c) && tensors_have_same_dtype(a, b, c);
-}
-
-inline bool tensor_has_expected_size(
-    executorch::aten::Tensor a,
-    executorch::aten::ArrayRef<executorch::aten::SizesType> expected_sizes) {
-  if (!(a.sizes() == expected_sizes)) {
-    ET_LOG(Error, ET_TENSOR_CHECK_PREFIX__ ": dim=(%zu, %zu)",
-           static_cast<size_t>(a.dim()),
-           static_cast<size_t>(expected_sizes.size()));
-    size_t a_dim = static_cast<size_t>(a.dim());
-    size_t expected_dim = static_cast<size_t>(expected_sizes.size());
-    for ([[maybe_unused]] const auto d :
-         c10::irange(ET_MIN2(a_dim, expected_dim))) {
-      ET_LOG(Error, "    size(%zu): (%zu, %zu)", static_cast<size_t>(d),
-             static_cast<size_t>(a.size(d)),
-             static_cast<size_t>(expected_sizes[d]));
-    }
-
-    return false;
-  }
-  return true;
-}
-
-inline bool tensors_have_same_strides(executorch::aten::Tensor a,
-                                      executorch::aten::Tensor b) {
-  if (a.strides() != b.strides()) {
-    ET_LOG(Error, ET_TENSOR_CHECK_PREFIX__ ": dim=(%zu, %zu)",
-           static_cast<size_t>(a.dim()), static_cast<size_t>(b.dim()));
-    for ([[maybe_unused]] const auto d :
-         c10::irange(ET_MIN2(a.dim(), b.dim()))) {
-      ET_LOG(Error, "    stride(%zu): (%zu, %zu)", static_cast<size_t>(d),
-             static_cast<size_t>(a.strides()[d]),
-             static_cast<size_t>(b.strides()[d]));
-    }
-
-    return false;
-  }
-  return true;
-}
-
-inline bool tensors_have_same_strides(executorch::aten::Tensor a,
-                                      executorch::aten::Tensor b,
-                                      executorch::aten::Tensor c) {
-  if (!(a.strides() == b.strides() && b.strides() == c.strides())) {
-    ET_LOG(Error, ET_TENSOR_CHECK_PREFIX__ ": dim=(%zu, %zu, %zu)",
-           static_cast<size_t>(a.dim()), static_cast<size_t>(b.dim()),
-           static_cast<size_t>(c.dim()));
-    for ([[maybe_unused]] const auto d :
-         c10::irange(ET_MIN3(a.dim(), b.dim(), c.dim()))) {
-      ET_LOG(Error, "    stride(%zu): (%zu, %zu, %zu)", static_cast<size_t>(d),
-             static_cast<size_t>(a.strides()[d]),
-             static_cast<size_t>(b.strides()[d]),
-             static_cast<size_t>(c.strides()[d]));
-    }
-
-    return false;
-  }
-  return true;
-}
-
-inline bool tensor_is_contiguous(executorch::aten::Tensor t) {
-  const auto strides = t.strides();
-  const auto sizes = t.sizes();
-  // If tensor is 0-dim (i.e. a scalar tensor) it is contiguous
-  if (strides.size() == 0) {
-    return true;
-  }
-  ET_CHECK_OR_RETURN_FALSE(
-      strides[strides.size() - 1] == 1,
-      "Tensor is not contiguous; the stride of the last dimension must be 1, "
-      "but got %zu",
-      static_cast<size_t>(strides[strides.size() - 1]));
-  for (int i = strides.size() - 1; i > 0; --i) {
-    ET_CHECK_OR_RETURN_FALSE(
-        strides[i - 1] == strides[i] * sizes[i],
-        "Tensor is not contiguous; the stride of dim %zu should be equal to "
-        "strides[%zu] * sizes[%zu] = %zu, but found %zu",
-        static_cast<size_t>(i - 1), static_cast<size_t>(i),
-        static_cast<size_t>(i), static_cast<size_t>(strides[i] * sizes[i]),
-        static_cast<size_t>(strides[i - 1]));
-  }
-  return true;
-}
-
-inline bool tensors_have_same_rank(executorch::aten::Tensor a,
-                                   executorch::aten::Tensor b) {
-  ET_CHECK_OR_RETURN_FALSE(a.dim() == b.dim(),
-                           ET_TENSOR_CHECK_PREFIX__ ": rank={%zd, %zd}",
-                           ssize_t(a.dim()), ssize_t(b.dim()));
-  return true;
-}
-
-inline bool tensor_is_scalar(executorch::aten::Tensor t) {
-  return t.dim() == 0 && t.numel() == 1;
-}
-
-/// Returns the product of dim[0:dim), not including dim.
-inline size_t getLeadingDims(const executorch::aten::Tensor &tensor,
-                             int64_t dim) {
-  ET_CHECK_MSG(dim >= 0 && dim <= tensor.dim(),
-               "Ending dimension %" PRId64
-               " should be in the range [0, tensor.dim() %zd].",
-               dim, ssize_t(tensor.dim()));
-  size_t dims = 1;
-  for (const auto i : c10::irange(dim)) {
-    dims *= static_cast<size_t>(tensor.size(i));
-  }
-  return dims;
-}
-
-/// Returns the product of dim[dim+1:].
-inline size_t getTrailingDims(const executorch::aten::Tensor &tensor,
-                              int64_t dim) {
-  ET_CHECK_MSG(dim >= -1 && dim < tensor.dim(),
-               "Starting dimension %" PRId64
-               " should be in the range [-1, tensor.dim() -1 %zd).",
-               dim, ssize_t(tensor.dim()));
-  size_t dims = 1;
-  for (size_t i = dim + 1; i < static_cast<size_t>(tensor.dim()); ++i) {
-    dims *= static_cast<size_t>(tensor.size(i));
-  }
-  return dims;
-}
-
-/**
- * Given a N-dimensional tensor coordinate, return a linear index that can be
- * used to access the corresponding element in the tensor's data buffer.
- *
- * @param[in] tensor The tensor that will be indexed
- * @param[in] coordinate A n-dimensional array representing the coordinate to
- * index. It is assumed that the array has kTensorDimensionLimit elements.
- * @param[out] index The linear index to element at the specified coordinate
- * in the tensor.
- */
-inline size_t coordinateToIndex(const executorch::aten::Tensor &tensor,
-                                const size_t *const coordinate) {
-  size_t index = 0;
-  for (const auto d : c10::irange(tensor.dim())) {
-    index += coordinate[d] * getTrailingDims(tensor, d);
-  }
-  return index;
-}
-
-/**
- * Produce a memoized array for use with repeated calls to
- * coordinateToIndexWithTrailingDimsMemo, which will be faster than
- * repeated calls to coordinateToIndex.
- */
-inline void
-memoizeTrailingDims(const executorch::aten::Tensor &tensor,
-                    size_t trailing_dims_memo[kTensorDimensionLimit]) {
-  const auto tensorDim = tensor.dim();
-  size_t dims = 1;
-  for (int ii = tensorDim - 1; ii >= 0; --ii) {
-    trailing_dims_memo[ii] = dims;
-    dims *= static_cast<size_t>(tensor.size(ii));
-  }
-}
-
-/**
- * Like coordinateToIndex, but faster for repeated calls with the same
- * tensor. trailing_dims_memo must be produced by a call to
- * memoizeTrailingDims.
- */
-inline size_t coordinateToIndexWithTrailingDimsMemo(
-    const executorch::aten::Tensor &tensor, const size_t *const coordinate,
-    const size_t trailing_dims_memo[kTensorDimensionLimit]) {
-  size_t index = 0;
-  for (const auto d : c10::irange(tensor.dim())) {
-    index += coordinate[d] * trailing_dims_memo[d];
-  }
-  return index;
-}
-
-/**
- * Given the linear index return the N-dimensional tensor coordinate. This is
- * the inverse operation of coordinateToIndex.
- *
- * @param[in] tensor The tensor that will be indexed
- * @param[in] index The linear index to element at the specified coordinate in
- * the tensor.
- * @param[out] coordinate A n-dimensional array representing the coordinate to
- * index. It is assumed that the array has kTensorDimensionLimit elements.
- * @returns void
- */
-inline void indexToCoordinate(const executorch::aten::Tensor &tensor,
-                              size_t index, size_t *coordinate) {
-  ET_CHECK(index < static_cast<size_t>(tensor.numel()));
-  for (const auto i : c10::irange(tensor.dim())) {
-    auto dim = tensor.dim() - 1 - i;
-    size_t dim_size = tensor.size(dim);
-    coordinate[dim] = index % dim_size;
-    index /= dim_size;
-  }
-}
-
-/**
- * Extracts an integer value from a scalar Tensor.
- *
- * @param[in] tensor The source of the value to extract.
- * @param[out] out_val The extracted value, on success.
- * @returns `true` if a value was extracted, and sets `*out_val` to that
- * value. `false` if a value could not be extracted: either it was not an
- * integer Scalar Tensor, or the value of that Scalar Tensor could not be
- * represented by INT_T.
- */
-template <typename INT_T,
-          typename std::enable_if<std::is_integral<INT_T>::value &&
-                                      !std::is_same<INT_T, bool>::value,
-                                  bool>::type = true>
-bool extract_scalar_tensor(executorch::aten::Tensor tensor, INT_T *out_val) {
-  if (tensor.numel() != 1) {
-    return false;
-  }
-#define CASE_INT_DTYPE(TENSOR_CTYPE, TENSOR_DTYPE)                             \
-  case executorch::aten::ScalarType::TENSOR_DTYPE: {                           \
-    const TENSOR_CTYPE val = tensor.const_data_ptr<TENSOR_CTYPE>()[0];         \
-    if (val < std::numeric_limits<INT_T>::lowest() ||                          \
-        val > std::numeric_limits<INT_T>::max()) {                             \
-      return false;                                                            \
-    }                                                                          \
-    *out_val = static_cast<INT_T>(val);                                        \
-    return true;                                                               \
-  }
-
-  switch (tensor.scalar_type()) {
-    ET_FORALL_INT_TYPES(CASE_INT_DTYPE);
-  default:
-    return false;
-  }
-#undef CASE_INT_DTYPE
-}
-
-/**
- * Extracts a floating point value from a scalar Tensor.
- *
- * @param[in] tensor The source of the value to extract.
- * @param[out] out_val The extracted value, on success.
- * @returns `true` if a value was extracted, and sets `*out_val` to that
- * value. `false` if a value could not be extracted: either it was not a
- * floating point Scalar Tensor, or the value of that Scalar Tensor could not
- * be represented by FLOAT_T.
- */
-template <typename FLOAT_T,
-          typename std::enable_if<
-              std::is_floating_point_v<FLOAT_T> ||
-                  std::is_same_v<FLOAT_T, executorch::aten::BFloat16> ||
-                  std::is_same_v<FLOAT_T, executorch::aten::Half>,
-              bool>::type = true>
-bool extract_scalar_tensor(executorch::aten::Tensor tensor, FLOAT_T *out_val) {
-  if (tensor.numel() != 1) {
-    return false;
-  }
-#define CASE_REAL_DTYPE(TENSOR_CTYPE, TENSOR_DTYPE)                            \
-  case executorch::aten::ScalarType::TENSOR_DTYPE: {                           \
-    /* ET_FORALL_REAL_TYPES guarantees TENSOR_CTYPE is a real type. */         \
-    double val =                                                               \
-        static_cast<double>(tensor.const_data_ptr<TENSOR_CTYPE>()[0]);         \
-    if (std::isfinite(val) && (val < std::numeric_limits<FLOAT_T>::lowest() || \
-                               val > std::numeric_limits<FLOAT_T>::max())) {   \
-      return false;                                                            \
-    }                                                                          \
-    *out_val = static_cast<FLOAT_T>(val);                                      \
-    return true;                                                               \
-  }
-
-  switch (tensor.scalar_type()) {
-    ET_FORALL_REALHBF16_TYPES(CASE_REAL_DTYPE);
-  default:
-    return false;
-  }
-#undef CASE_REAL_DTYPE
-}
-
-/**
- * Extracts a boolean value from a Scalar.
- *
- * @param[in] scalar The source of the value to extract.
- * @param[out] out_val The extracted value, on success.
- * @returns `true` if a value was extracted, and sets `*out_val` to that
- * value. `false` if a value could not be extracted, i.e. not a boolean
- */
-template <typename BOOL_T,
-          typename std::enable_if<std::is_same<BOOL_T, bool>::value,
-                                  bool>::type = true>
-bool extract_scalar_tensor(executorch::aten::Tensor tensor, BOOL_T *out_val) {
-  if (tensor.scalar_type() != executorch::aten::ScalarType::Bool) {
-    return false;
-  }
-  if (tensor.numel() != 1) {
-    return false;
-  }
-
-  bool val = tensor.const_data_ptr<bool>()[0];
-
-  *out_val = static_cast<BOOL_T>(val);
-
-  return true;
-}
-
-/// These APIs should not be used outside of Executor.cpp.
-namespace internal {
-/**
- * Share t_src's data_ptr with t_dst.
- */
-ET_NODISCARD Error share_tensor_data(const executorch::aten::Tensor &t_dst,
-                                     const executorch::aten::Tensor &t_src);
-
-/**
- * Copy t_src's data_ptr to t_dst.
- */
-ET_NODISCARD Error copy_tensor_data(const executorch::aten::Tensor &t_dst,
-                                    const executorch::aten::Tensor &t_src);
-
-/**
- * Set the data_ptr of t to buffer.
- */
-ET_NODISCARD Error set_tensor_data(const executorch::aten::Tensor &t,
-                                   void *buffer, size_t buffer_size);
-
-/**
- * Reset tensor's data_ptr, clear all the storage for at::Tensor.
- */
-void reset_data_ptr(const executorch::aten::Tensor &tensor);
-
-/**
- * Resize tensor impl
- */
-ET_NODISCARD Error resize_tensor_impl(
-    executorch::aten::TensorImpl *impl,
-    executorch::aten::ArrayRef<executorch::aten::SizesType> new_sizes);
-
-} // namespace internal
-
-/**
- * Resize a tensor to new_sizes, rank must stay the same. Currently does not
- * expand the tensor if new size exceeds the current capacity. Currently
- * fails an ET_CHECK if the tensor cannot be resized.
- *
- * WARNING: Placeholder API until discussion around runtime context is
- * settled, will likely move to be a class method on a TensorResizer object
- * passed in through runtimeContext.
- */
-ET_NODISCARD inline Error resize_tensor(
-    executorch::aten::Tensor t,
-    executorch::aten::ArrayRef<executorch::aten::SizesType> new_sizes) {
-  return internal::resize_tensor_impl(t.unsafeGetTensorImpl(), new_sizes);
-}
-
-/**
- * Resize a tensor to new_sizes, rank must stay the same. Currently does not
- * expand the tensor if new size exceeds the current capacity. Currently
- * fails an ET_CHECK if the tensor cannot be resized.
- *
- * WARNING: Placeholder API until discussion around runtime context is
- * settled, will likely move to be a class method on a TensorResizer object
- * passed in through runtimeContext.
- */
-template <typename T, typename std::enable_if<
-                          !std::is_same<executorch::aten::SizesType, T>::value,
-                          int>::type = 0>
-ET_NODISCARD inline Error
-resize_tensor(executorch::aten::Tensor t,
-              executorch::aten::ArrayRef<T> new_sizes) {
-  // Need to cast the input array to an array of Tensor::SizesType
-  std::array<executorch::aten::SizesType, kTensorDimensionLimit>
-      new_sizes_casted{};
-  size_t new_sizes_ndim = new_sizes.size();
-  ET_CHECK_OR_RETURN_ERROR(
-      new_sizes_ndim <= kTensorDimensionLimit, InvalidArgument,
-      "new_sizes_ndim %zu is greater than kTensorDimensionLimit %zu",
-      new_sizes_ndim, kTensorDimensionLimit);
-  for (const auto i : c10::irange(new_sizes_ndim)) {
-    new_sizes_casted[i] =
-        static_cast<executorch::aten::SizesType>(new_sizes[i]);
-  }
-
-  return internal::resize_tensor_impl(
-      t.unsafeGetTensorImpl(), {new_sizes_casted.data(), new_sizes_ndim});
-}
-
-/// DEPRECATED: Use `resize_tensor()` instead, which can fail non-fatally.
-ET_DEPRECATED inline void
-resize(executorch::aten::Tensor t,
-       executorch::aten::ArrayRef<executorch::aten::SizesType> new_sizes) {
-  Error err = resize_tensor(t, new_sizes);
-  ET_CHECK_MSG(err == Error::Ok,
-               "Could not resize Tensor; see logs for details");
-}
-/**
- * Get dim_order of a Tensor and write it to out_dim_order.
- * @param tensor The tensor where we want to get dim order from.
- * @param out_dim_order Pointing to an array of DimOrderType where we write
- * dim order into it.
- * @param out_dim_order_size Size of the DimOrderType array.
- */
-ET_NODISCARD Error get_dim_order(const executorch::aten::Tensor &tensor,
-                                 executorch::aten::DimOrderType *out_dim_order,
-                                 size_t out_dim_order_size);
-
-/**
- * Checks whether a tensor has a valid dim order. If the dim order could not
- * be determined, then this function returns false by default.
- */
-bool tensor_has_valid_dim_order(executorch::aten::Tensor t);
-
-/**
- * Checks whether a tensor has either the default of channels last dim order.
- * If the dim order could not be determined, then this function returns false
- * by default.
- */
-bool tensor_is_default_or_channels_last_dim_order(executorch::aten::Tensor t);
-
-/**
- * Checks whether a tensor has the default dimension order.
- * Logs an error message if the tensor does not meet the expected criteria.
- *
- * @param t The tensor to check the dimension order of.
- * @return True if the tensor has the default dimension order, false otherwise.
- */
-bool tensor_is_default_dim_order(executorch::aten::Tensor t);
-
-/**
- * Checks whether a tensor has the channels last dimension order.
- * Logs an error message if the tensor does not meet the expected criteria.
- *
- * @param t The tensor to check the dimension order of.
- * @return True if the tensor has the channels last dimension order, false
- * otherwise.
- */
-bool tensor_is_channels_last_dim_order(executorch::aten::Tensor t);
-
-/**
- * Asserts that four tensors have the same dim_order
- *
- * Note that this macro only tests dim order, but not others like actual data,
- * sizes, etc.
- *
- */
-bool tensors_have_same_dim_order(
-    const executorch::aten::ArrayRef<executorch::aten::Tensor> tensor_list);
-
-/**
- * Asserts that two tensors have the same dim_order
- *
- * Note that this macro only tests dim order, but not others like actual data,
- * sizes, etc.
- */
-
-inline bool tensors_have_same_dim_order(const executorch::aten::Tensor &a,
-                                        const executorch::aten::Tensor &b) {
-  executorch::aten::Tensor tensor_list[2] = {a, b};
-  return tensors_have_same_dim_order(tensor_list);
-}
-
-/**
- * Asserts that three tensors have the same dim_order
- *
- * Note that this macro only tests dim order, but not others like actual data,
- * sizes, etc.
- *
- */
-
-inline bool tensors_have_same_dim_order(const executorch::aten::Tensor &a,
-                                        const executorch::aten::Tensor &b,
-                                        const executorch::aten::Tensor &c) {
-  executorch::aten::Tensor tensor_list[3] = {a, b, c};
-  return tensors_have_same_dim_order(tensor_list);
-}
-
-/**
- * Asserts that four tensors have the same dim_order
- *
- * Note that this macro only tests dim order, but not others like actual data,
- * sizes, etc.
- *
- */
-
-inline bool tensors_have_same_dim_order(const executorch::aten::Tensor &a,
-                                        const executorch::aten::Tensor &b,
-                                        const executorch::aten::Tensor &c,
-                                        const executorch::aten::Tensor &d) {
-  executorch::aten::Tensor tensor_list[4] = {a, b, c, d};
-  return tensors_have_same_dim_order(tensor_list);
-}
-
-/**
- * Given an n-dimensional coordinate array and an array of tensor strides,
- * calculates the linear index that can be used to retrieve the value at the
- * given coordinates.
- * @param coordinate Pointer to the array of coordinates.
- * @param strides Pointer to the array of strides.
- * @param ndim Number of dimensions in the tensor.
- */
-inline size_t
-calculate_linear_index(const executorch::aten::SizesType *coordinate,
-                       const executorch::aten::StridesType *strides,
-                       const size_t ndim) {
-  size_t index = 0;
-  for (const auto i : c10::irange(ndim)) {
-    index += coordinate[i] * strides[i];
-  }
-  return index;
-}
-
-} // namespace ET_RUNTIME_NAMESPACE
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::ET_RUNTIME_NAMESPACE::calculate_linear_index;
-using ::executorch::ET_RUNTIME_NAMESPACE::coordinateToIndex;
-using ::executorch::ET_RUNTIME_NAMESPACE::dim_is_valid;
-using ::executorch::ET_RUNTIME_NAMESPACE::extract_scalar_tensor;
-using ::executorch::ET_RUNTIME_NAMESPACE::get_dim_order;
-using ::executorch::ET_RUNTIME_NAMESPACE::getLeadingDims;
-using ::executorch::ET_RUNTIME_NAMESPACE::getTrailingDims;
-using ::executorch::ET_RUNTIME_NAMESPACE::indexToCoordinate;
-using ::executorch::ET_RUNTIME_NAMESPACE::nonempty_size;
-using ::executorch::ET_RUNTIME_NAMESPACE::nonzero_dim;
-using ::executorch::ET_RUNTIME_NAMESPACE::resize;
-using ::executorch::ET_RUNTIME_NAMESPACE::resize_tensor;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensor_can_cast_to;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensor_dim_has_index;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensor_has_dim;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensor_has_expected_size;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensor_has_non_empty_dim;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensor_has_rank_greater_or_equal_to;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensor_has_rank_smaller_or_equal_to;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensor_has_valid_dim_order;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensor_is_bits_type;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensor_is_bool_type;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensor_is_complex_type;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensor_is_contiguous;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensor_is_default_dim_order;
-using ::executorch::ET_RUNTIME_NAMESPACE::
-    tensor_is_default_or_channels_last_dim_order;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensor_is_floating_type;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensor_is_integral_type;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensor_is_rank;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensor_is_real_type;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensor_is_realh_type;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensor_is_realhb_type;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensor_is_scalar;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensors_have_same_dim_order;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensors_have_same_dtype;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensors_have_same_rank;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensors_have_same_shape;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensors_have_same_shape_and_dtype;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensors_have_same_size_at_dims;
-using ::executorch::ET_RUNTIME_NAMESPACE::tensors_have_same_strides;
-using ::executorch::runtime::kTensorDimensionLimit;
-namespace internal {
-using ::executorch::ET_RUNTIME_NAMESPACE::internal::copy_tensor_data;
-using ::executorch::ET_RUNTIME_NAMESPACE::internal::reset_data_ptr;
-using ::executorch::ET_RUNTIME_NAMESPACE::internal::resize_tensor_impl;
-using ::executorch::ET_RUNTIME_NAMESPACE::internal::set_tensor_data;
-using ::executorch::ET_RUNTIME_NAMESPACE::internal::share_tensor_data;
-} // namespace internal
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/freeable_buffer.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/freeable_buffer.h
deleted file mode 100644
index 90974787d5..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/freeable_buffer.h
+++ /dev/null
@@ -1,203 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <cstddef>
-#include <cstdint>
-#include <variant>
-
-#include <executorch/runtime/core/error.h>
-#include <executorch/runtime/core/result.h>
-#include <executorch/runtime/platform/assert.h>
-
-namespace executorch {
-namespace runtime {
-
-/**
- * A read-only buffer than can be freed.
- */
-class FreeableBuffer final {
-public:
-  // Callback signature for the function that does the freeing.
-  using FreeFn = void (*)(void *context, void *data, size_t size);
-  using FreeUInt64Fn = void (*)(void *context, uint64_t data_uint64,
-                                size_t size);
-
-private:
-  // Forward declare types.
-  struct PointerData {
-    const void *data_;
-    FreeFn free_fn_;
-  };
-
-  struct UInt64Data {
-    // A pointer value cast to uint64_t.
-    uint64_t data_;
-    FreeUInt64Fn free_fn_;
-  };
-
-public:
-  /**
-   * Creates an empty FreeableBuffer with size zero and a null data pointer.
-   */
-  FreeableBuffer()
-      : data_(PointerData{nullptr, nullptr}), free_fn_context_(nullptr),
-        size_(0) {}
-
-  /**
-   * Creates a FreeableBuffer with an optional free function.
-   *
-   * @param[in] data The data of the segment, as a void*.
-   * @param[in] size The size of the segment data, in bytes.
-   * @param[in] free_fn Optional function to free the data. Guaranteed to be
-   *     called exactly once before the FreeableBuffer is destroyed. May be
-   *     nullptr. NOTE: This function must be thread-safe. If it modifies common
-   *     state, the function must do its own locking.
-   * @param[in] free_fn_context Opaque pointer to pass as the `context`
-   *     parameter of `free_fn`. May be nullptr.
-   */
-  FreeableBuffer(const void *data, size_t size, FreeFn free_fn,
-                 void *free_fn_context = nullptr)
-      : data_(PointerData{data, free_fn}), free_fn_context_(free_fn_context),
-        size_(size) {}
-
-  /**
-   * Creates a FreeableBuffer with an optional free function.
-   *
-   * NOTE: most users should use the other ctor with FreeFn.
-   * This variant exists for situations where the FreeableBuffer points to
-   * memory on a different core whose pointer value is larger than the local
-   * core's void*.
-   *
-   * @param[in] data Pointer to the data of the segment, cast to a uint64_t
-   * value.
-   * @param[in] size The size of the segment data, in bytes.
-   * @param[in] free_fn Optional function to free the data. Guaranteed to be
-   *     called exactly once before the FreeableBuffer is destroyed. May be
-   *     nullptr. NOTE: This function must be thread-safe. If it modifies common
-   *     state, the function must do its own locking.
-   * @param[in] free_fn_context Opaque pointer to pass as the `context`
-   *     parameter of `free_fn`. May be nullptr.
-   */
-  explicit FreeableBuffer(const uint64_t data_uint64, size_t size,
-                          FreeUInt64Fn free_fn, void *free_fn_context = nullptr)
-      : data_(UInt64Data{data_uint64, free_fn}),
-        free_fn_context_(free_fn_context), size_(size) {}
-
-  /**
-   * Move ctor. Takes the ownership of the data previously owned by `rhs`,
-   * leaving `rhs` pointing to nullptr.
-   */
-  FreeableBuffer(FreeableBuffer &&rhs) noexcept
-      : data_(rhs.data_), free_fn_context_(rhs.free_fn_context_),
-        size_(rhs.size_) {
-    if (std::holds_alternative<PointerData>(rhs.data_)) {
-      rhs.data_ = PointerData{nullptr, nullptr};
-    } else {
-      rhs.data_ = UInt64Data{0, nullptr};
-    }
-    rhs.free_fn_context_ = nullptr;
-    rhs.size_ = 0;
-  }
-
-  ~FreeableBuffer() { Free(); }
-
-  /**
-   * Frees the data if not already free. Safe to call multiple times.
-   */
-  void Free() {
-    if (std::holds_alternative<PointerData>(data_)) {
-      PointerData &ptr_data = std::get<PointerData>(data_);
-      if (ptr_data.data_ != nullptr && ptr_data.free_fn_ != nullptr) {
-        // Do not need to check for truncation here, as free_fn_ is only set
-        // using the void* ctor.
-        ptr_data.free_fn_(free_fn_context_, const_cast<void *>(ptr_data.data_),
-                          size_);
-      }
-      ptr_data.data_ = nullptr;
-      size_ = 0;
-    } else {
-      UInt64Data &int64_data = std::get<UInt64Data>(data_);
-      if (int64_data.data_ != 0 && int64_data.free_fn_ != nullptr) {
-        int64_data.free_fn_(free_fn_context_, int64_data.data_, size_);
-      }
-      int64_data.data_ = static_cast<uint64_t>(0);
-      size_ = 0;
-    }
-  }
-
-  /**
-   * Size of the data in bytes. Returns 0 if the data has been freed.
-   */
-  size_t size() const { return size_; }
-
-  /**
-   * Pointer to the data. Returns nullptr if the data has been freed.
-   */
-  const void *data() const {
-    ET_CHECK_MSG(std::holds_alternative<PointerData>(data_),
-                 "FreeableBuffer is backed by an uint64_t, please use the "
-                 "data_uint64_type() API.");
-    return std::get<PointerData>(data_).data_;
-  }
-
-  /**
-   * Pointer to the data. Returns nullptr if the data has been freed.
-   * Safe version of data() API that returns an ERror if the data is
-   * backed by int64_t instead of void*.
-   */
-  Result<const void *> data_safe() const {
-    ET_CHECK_OR_RETURN_ERROR(std::holds_alternative<PointerData>(data_),
-                             InvalidType,
-                             "FreeableBuffer is backed by an uint64_t, please "
-                             "use the data_uint64_type() API.");
-    return std::get<PointerData>(data_).data_;
-  }
-
-  /**
-   * Data address as a uint64_t. Returns zero if the data has been freed.
-   * Most users should use data(). data_uint64_type() is only helpful in
-   * situations where the FreeableBuffer points to memory on a different core
-   * whose pointer value is larger than the local core's void *.
-   */
-  Result<uint64_t> data_uint64_type() const {
-    ET_CHECK_OR_RETURN_ERROR(
-        std::holds_alternative<UInt64Data>(data_), InvalidType,
-        "FreeableBuffer is backed by a void*, please use the data() API.");
-    return std::get<UInt64Data>(data_).data_;
-  }
-
-private:
-  // Delete other rule-of-five methods.
-  FreeableBuffer(const FreeableBuffer &rhs) = delete;
-  FreeableBuffer &operator=(FreeableBuffer &&rhs) noexcept = delete;
-  FreeableBuffer &operator=(const FreeableBuffer &rhs) = delete;
-
-  // This stores either a PointerData or a UInt64Data structure. Most users
-  // should use the PointerData variant and the void* ctor. This creates a
-  // FreeableBuffer backed by void*, accessed using the void* getter data().
-  // The UInt64Data variant is only helpful in situations where the
-  // FreeableBuffer points to memory on a different core whose pointer value
-  // is larger than the local core's void*.
-  std::variant<PointerData, UInt64Data> data_;
-
-  void *free_fn_context_;
-  size_t size_;
-};
-
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::FreeableBuffer;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/function_ref.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/function_ref.h
deleted file mode 100644
index 1483437907..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/function_ref.h
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-//===- llvm/ADT/STLFunctionalExtras.h - Extras for <functional> -*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains some extension to <functional>.
-//
-// No library is required when using these functions.
-//
-//===----------------------------------------------------------------------===//
-//     Extra additions to <functional>
-//===----------------------------------------------------------------------===//
-
-/// An efficient, type-erasing, non-owning reference to a callable. This is
-/// intended for use as the type of a function parameter that is not used
-/// after the function in question returns.
-///
-/// This class does not own the callable, so it is not in general safe to store
-/// a FunctionRef.
-
-// torch::executor: modified from llvm::function_ref
-// - renamed to FunctionRef
-// - removed LLVM_GSL_POINTER and LLVM_LIFETIME_BOUND macro uses
-// - use namespaced internal::remove_cvref_t
-
-#pragma once
-
-#include <cstdint>
-#include <type_traits>
-#include <utility>
-
-namespace executorch::runtime {
-
-//===----------------------------------------------------------------------===//
-//     Features from C++20
-//===----------------------------------------------------------------------===//
-
-namespace internal {
-
-template <typename T> struct remove_cvref {
-  using type =
-      typename std::remove_cv<typename std::remove_reference<T>::type>::type;
-};
-
-template <typename T> using remove_cvref_t = typename remove_cvref<T>::type;
-
-} // namespace internal
-
-template <typename Fn> class FunctionRef;
-
-template <typename Ret, typename... Params> class FunctionRef<Ret(Params...)> {
-  Ret (*callback)(intptr_t callable, Params... params) = nullptr;
-  intptr_t callable;
-
-  template <typename Callable>
-  static Ret callback_fn(intptr_t callable, Params... params) {
-    return (*reinterpret_cast<Callable *>(callable))(
-        std::forward<Params>(params)...);
-  }
-
-public:
-  FunctionRef() = default;
-  FunctionRef(std::nullptr_t) {}
-
-  template <typename Callable>
-  FunctionRef(
-      Callable &&callable,
-      // This is not the copy-constructor.
-      std::enable_if_t<!std::is_same<internal::remove_cvref_t<Callable>,
-                                     FunctionRef>::value> * = nullptr,
-      // Functor must be callable and return a suitable type.
-      std::enable_if_t<std::is_void<Ret>::value ||
-                       std::is_convertible<decltype(std::declval<Callable>()(
-                                               std::declval<Params>()...)),
-                                           Ret>::value> * = nullptr)
-      : callback(callback_fn<std::remove_reference_t<Callable>>),
-        callable(reinterpret_cast<intptr_t>(&callable)) {}
-
-  Ret operator()(Params... params) const {
-    return callback(callable, std::forward<Params>(params)...);
-  }
-
-  explicit operator bool() const { return callback; }
-
-  bool operator==(const FunctionRef<Ret(Params...)> &Other) const {
-    return callable == Other.callable;
-  }
-};
-} // namespace executorch::runtime
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/hierarchical_allocator.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/hierarchical_allocator.h
deleted file mode 100644
index e061c9d182..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/hierarchical_allocator.h
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <c10/util/irange.h>
-#include <c10/util/safe_numerics.h>
-
-#include <executorch/runtime/core/memory_allocator.h>
-#include <executorch/runtime/core/result.h>
-#include <executorch/runtime/core/span.h>
-
-namespace executorch {
-namespace runtime {
-
-/**
- * A group of buffers that can be used to represent a device's memory hierarchy.
- */
-class HierarchicalAllocator final {
-public:
-  /**
-   * Constructs a new hierarchical allocator with the given array of buffers.
-   *
-   * - Memory IDs are based on the index into `buffers`: `buffers[N]` will have
-   *   a memory ID of `N`.
-   * - `buffers.size()` must be >= `MethodMeta::num_non_const_buffers()`.
-   * - `buffers[N].size()` must be >= `MethodMeta::non_const_buffer_size(N)`.
-   */
-  explicit HierarchicalAllocator(Span<Span<uint8_t>> buffers)
-      : buffers_(buffers) {}
-
-  /**
-   * DEPRECATED: Use spans instead.
-   */
-  ET_DEPRECATED HierarchicalAllocator(uint32_t n_allocators,
-                                      MemoryAllocator *allocators)
-      : buffers_(to_spans(n_allocators, allocators)) {}
-
-  /**
-   * Returns the address at the byte offset `offset_bytes` from the given
-   * buffer's base address, which points to at least `size_bytes` of memory.
-   *
-   * @param[in] memory_id The ID of the buffer in the hierarchy.
-   * @param[in] offset_bytes The offset in bytes into the specified buffer.
-   * @param[in] size_bytes The amount of memory that should be available at
-   *     the offset.
-   *
-   * @returns On success, the address of the requested byte offset into the
-   *     specified buffer. On failure, a non-Ok Error.
-   */
-  ET_NODISCARD Result<void *> get_offset_address(uint32_t memory_id,
-                                                 size_t offset_bytes,
-                                                 size_t size_bytes) {
-    // Check for integer overflow in offset_bytes + size_bytes.
-    size_t end_bytes = 0;
-    ET_CHECK_OR_RETURN_ERROR(
-        !c10::add_overflows(offset_bytes, size_bytes, &end_bytes),
-        InvalidArgument,
-        "Integer overflow in offset_bytes (%" ET_PRIsize_t
-        ") + size_bytes (%" ET_PRIsize_t ")",
-        offset_bytes, size_bytes);
-    ET_CHECK_OR_RETURN_ERROR(memory_id < buffers_.size(), InvalidArgument,
-                             "id %" PRIu32 " >= %" ET_PRIsize_t, memory_id,
-                             buffers_.size());
-    Span<uint8_t> buffer = buffers_[memory_id];
-    ET_CHECK_OR_RETURN_ERROR(
-        end_bytes <= buffer.size(), MemoryAllocationFailed,
-        "offset_bytes (%" ET_PRIsize_t ") + size_bytes (%" ET_PRIsize_t
-        ") >= allocator size (%" ET_PRIsize_t ") "
-        "for memory_id %" PRIu32,
-        offset_bytes, size_bytes, buffer.size(), memory_id);
-    return buffer.data() + offset_bytes;
-  }
-
-private:
-  // TODO(T162089316): Remove the span array and to_spans once all users move to
-  // spans. This array is necessary to hold the pointers and sizes that were
-  // originally provided as MemoryAllocator instances.
-  static constexpr size_t kSpanArraySize = 16;
-  // NOTE: span_array_ must be declared before buffers_ so that it isn't
-  // re-initialized to zeros after initializing buffers_.
-  Span<uint8_t> span_array_[kSpanArraySize];
-  Span<Span<uint8_t>> to_spans(uint32_t n_allocators,
-                               MemoryAllocator *allocators) {
-    ET_CHECK_MSG(n_allocators <= kSpanArraySize,
-                 "n_allocators %" PRIu32 " > %zu", n_allocators,
-                 kSpanArraySize);
-    for (const auto i : c10::irange(n_allocators)) {
-      span_array_[i] =
-          Span<uint8_t>(allocators[i].base_address(), allocators[i].size());
-    }
-    return {span_array_, n_allocators};
-  }
-
-  /// The underlying buffers.
-  Span<Span<uint8_t>> buffers_;
-};
-
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::HierarchicalAllocator;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/memory_allocator.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/memory_allocator.h
deleted file mode 100644
index f496803f18..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/memory_allocator.h
+++ /dev/null
@@ -1,217 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <cinttypes>
-
-#include <c10/util/safe_numerics.h>
-
-#include <executorch/runtime/core/error.h>
-#include <executorch/runtime/platform/assert.h>
-#include <executorch/runtime/platform/profiler.h>
-
-namespace executorch {
-namespace runtime {
-
-/**
- * A class that does simple allocation based on a size and returns the pointer
- * to the memory address. It bookmarks a buffer with certain size. The
- * allocation is simply checking space and growing the cur_ pointer with each
- * allocation request.
- *
- * Simple example:
- *
- *   // User allocates a 100 byte long memory in the heap.
- *   uint8_t* memory_pool = malloc(100 * sizeof(uint8_t));
- *   MemoryAllocator allocator(100, memory_pool)
- *   // Pass allocator object in the Executor
- *
- *   Underneath the hood, ExecuTorch will call
- *   allocator.allocate() to keep iterating cur_ pointer
- */
-class MemoryAllocator {
-public:
-  /**
-   * Default alignment of memory returned by this class. Ensures that pointer
-   * fields of structs will be aligned. Larger types like `long double` may not
-   * be, however, depending on the toolchain and architecture.
-   */
-  static constexpr size_t kDefaultAlignment = alignof(void *);
-
-  /**
-   * Constructs a new memory allocator of a given `size`, starting at the
-   * provided `base_address`.
-   *
-   * @param[in] size The size in bytes of the buffer at `base_address`.
-   * @param[in] base_address The buffer to allocate from. Does not take
-   *     ownership of this buffer, so it must be valid for the lifetime of of
-   *     the MemoryAllocator.
-   */
-  MemoryAllocator(uint32_t size, uint8_t *base_address)
-      : begin_(base_address),
-        end_(base_address
-                 ? (UINTPTR_MAX - reinterpret_cast<uintptr_t>(base_address) >=
-                            size
-                        ? base_address + size
-                        : nullptr)
-                 : nullptr),
-        cur_(base_address), size_(size) {
-    ET_CHECK_MSG(base_address || size == 0,
-                 "Base address is null but size=%" PRIu32, size);
-    ET_CHECK_MSG(
-        !base_address || size == 0 ||
-            (UINTPTR_MAX - reinterpret_cast<uintptr_t>(base_address) >= size),
-        "Address space overflow in allocator");
-  }
-
-  virtual ~MemoryAllocator() = default;
-
-  /**
-   * Allocates `size` bytes of memory.
-   *
-   * @param[in] size Number of bytes to allocate.
-   * @param[in] alignment Minimum alignment for the returned pointer. Must be a
-   *     power of 2.
-   *
-   * @returns Aligned pointer to the allocated memory on success.
-   * @retval nullptr Not enough memory, or `alignment` was not a power of 2.
-   */
-  virtual void *allocate(size_t size, size_t alignment = kDefaultAlignment) {
-    if ET_UNLIKELY (!begin_ || !end_) {
-      ET_LOG(Error, "allocate() on zero-capacity allocator");
-      return nullptr;
-    }
-    if (!isPowerOf2(alignment)) {
-      ET_LOG(Error, "Alignment %zu is not a power of 2", alignment);
-      return nullptr;
-    }
-
-    // The allocation will occupy [start, end), where the start is the next
-    // position that's a multiple of alignment.
-    uint8_t *start = alignPointer(cur_, alignment);
-    size_t padding = static_cast<size_t>(start - cur_);
-    size_t available = static_cast<size_t>(end_ - cur_);
-    if ET_UNLIKELY (padding > available || size > available - padding) {
-      ET_LOG(Error,
-             "Memory allocation failed: %zuB requested (adjusted for "
-             "alignment), %zuB available",
-             padding + size, available);
-      return nullptr;
-    }
-    uint8_t *end = start + size;
-
-    // Otherwise, record how many bytes were used, advance cur_ to the new end,
-    // and then return start. Note that the number of bytes used is (end - cur_)
-    // instead of (end - start) because start > cur_ if there is a misalignment
-    EXECUTORCH_TRACK_ALLOCATION(prof_id_, end - cur_);
-    cur_ = end;
-    return static_cast<void *>(start);
-  }
-
-  /**
-   * Allocates a buffer large enough for an instance of type T. Note that the
-   * memory will not be initialized.
-   *
-   * Example:
-   * @code
-   *   auto p = memory_allocator->allocateInstance<MyType>();
-   * @endcode
-   *
-   * @param[in] alignment Minimum alignment for the returned pointer. Must be a
-   *     power of 2. Defaults to the natural alignment of T.
-   *
-   * @returns Aligned pointer to the allocated memory on success.
-   * @retval nullptr Not enough memory, or `alignment` was not a power of 2.
-   */
-  template <typename T> T *allocateInstance(size_t alignment = alignof(T)) {
-    return static_cast<T *>(this->allocate(sizeof(T), alignment));
-  }
-
-  /**
-   * Allocates `size` number of chunks of type T, where each chunk is of size
-   * equal to sizeof(T) bytes.
-   *
-   * @param[in] size Number of memory chunks to allocate.
-   * @param[in] alignment Minimum alignment for the returned pointer. Must be a
-   *     power of 2. Defaults to the natural alignment of T.
-   *
-   * @returns Aligned pointer to the allocated memory on success.
-   * @retval nullptr Not enough memory, or `alignment` was not a power of 2.
-   */
-  template <typename T>
-  T *allocateList(size_t size, size_t alignment = alignof(T)) {
-    // Some users of this method allocate lists of pointers, causing the next
-    // line to expand to `sizeof(type *)`, which triggers a clang-tidy warning.
-    // NOLINTNEXTLINE(bugprone-sizeof-expression)
-    size_t bytes_size = 0;
-    bool overflow = c10::mul_overflows(size, sizeof(T), &bytes_size);
-    if (overflow) {
-      ET_LOG(Error,
-             "Failed to allocate list: size(%zu) * sizeof(T)(%zu) overflowed",
-             size, sizeof(T));
-      return nullptr;
-    }
-    return static_cast<T *>(this->allocate(bytes_size, alignment));
-  }
-
-  // Returns the allocator memory's base address.
-  virtual uint8_t *base_address() const { return begin_; }
-
-  // Returns the total size of the allocator's memory buffer.
-  virtual uint32_t size() const { return size_; }
-
-  // Resets the current pointer to the base address. It does nothing to
-  // the contents.
-  virtual void reset() { cur_ = begin_; }
-
-  void enable_profiling(ET_UNUSED const char *name) {
-    prof_id_ = EXECUTORCH_TRACK_ALLOCATOR(name);
-  }
-
-protected:
-  /**
-   * Returns the profiler ID for this allocator.
-   */
-  int32_t prof_id() const { return prof_id_; }
-
-  /**
-   * Returns true if the value is an integer power of 2.
-   */
-  static constexpr bool isPowerOf2(size_t value) {
-    return value && !(value & (value - 1));
-  }
-
-  /**
-   * Returns the next alignment for a given pointer.
-   */
-  static inline uint8_t *alignPointer(void *ptr, size_t alignment) {
-    uintptr_t address = reinterpret_cast<uintptr_t>(ptr);
-    uintptr_t mask = static_cast<uintptr_t>(alignment - 1);
-    address = (address + mask) & ~mask;
-    return reinterpret_cast<uint8_t *>(address);
-  }
-
-private:
-  uint8_t *const begin_;
-  uint8_t *const end_;
-  uint8_t *cur_;
-  uint32_t const size_;
-  int32_t prof_id_ = -1;
-};
-
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::MemoryAllocator;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/named_data_map.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/named_data_map.h
deleted file mode 100644
index c6c490776e..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/named_data_map.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <executorch/runtime/core/freeable_buffer.h>
-#include <executorch/runtime/core/result.h>
-#include <executorch/runtime/core/span.h>
-#include <executorch/runtime/core/tensor_layout.h>
-#include <executorch/runtime/platform/compiler.h>
-
-namespace executorch {
-namespace ET_RUNTIME_NAMESPACE {
-/**
- * Interface to access and retrieve data via name.
- * See executorch/extension/flat_tensor/ for an example.
- */
-class NamedDataMap {
-public:
-  virtual ~NamedDataMap() = default;
-  /**
-   * Get tensor_layout by key.
-   *
-   * @param key The name of the tensor.
-   * @return Result containing TensorLayout.
-   */
-  ET_NODISCARD virtual Result<const TensorLayout>
-  get_tensor_layout(executorch::aten::string_view key) const = 0;
-  /**
-   * Get data by key.
-   *
-   * @param key Name of the data.
-   * @return Result containing a FreeableBuffer.
-   */
-  ET_NODISCARD virtual Result<FreeableBuffer>
-  get_data(executorch::aten::string_view key) const = 0;
-
-  /**
-   * Loads data corresponding to the key into the provided buffer.
-   *
-   * @param key The name of the data.
-   * @param size The number of bytes to load. Use `get_tensor_layout` to
-   * retrieve the size of the data for a given key.
-   * @param buffer The buffer to load the data into. Must point to at least
-   * `size` bytes of memory.
-   * @returns an Error indicating if the load was successful.
-   */
-  ET_NODISCARD virtual Error load_data_into(executorch::aten::string_view key,
-                                            void *buffer,
-                                            size_t size) const = 0;
-
-  /**
-   * Get the number of keys in the NamedDataMap.
-   *
-   * @return Result containing the number of keys.
-   */
-  ET_NODISCARD virtual Result<uint32_t> get_num_keys() const = 0;
-
-  /**
-   * Get the key at the given index.
-   *
-   * @param index The index of the key to retrieve.
-   * @return Result containing the key at the given index. Note: the returned
-   * pointer is only valid for the lifetime of the DataMap.
-   */
-  ET_NODISCARD virtual Result<const char *> get_key(uint32_t index) const = 0;
-};
-
-} // namespace ET_RUNTIME_NAMESPACE
-} // namespace executorch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/bfloat16.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/bfloat16.h
deleted file mode 100644
index 233d571478..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/bfloat16.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <c10/util/BFloat16.h>
-
-namespace executorch::runtime::etensor {
-using c10::BFloat16;
-namespace internal {
-using c10::detail::f32_from_bits;
-using c10::detail::round_to_nearest_even;
-} // namespace internal
-} // namespace executorch::runtime::etensor
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::etensor::BFloat16;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/bfloat16_math.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/bfloat16_math.h
deleted file mode 100644
index 3f6bf14a46..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/bfloat16_math.h
+++ /dev/null
@@ -1,14 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <executorch/runtime/core/portable_type/bfloat16.h>
-#include <executorch/runtime/core/portable_type/half.h>
-
-#include <c10/util/BFloat16-math.h>
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/bits_types.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/bits_types.h
deleted file mode 100644
index cddffc485e..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/bits_types.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-#include <cstdint>
-
-namespace executorch {
-namespace runtime {
-namespace etensor {
-
-/**
- * bits1x8 is an uninterpreted dtype of a tensor with 1 bit (packed to byte
- * boundary), without any semantics defined.
- */
-struct alignas(1) bits1x8 {
-  using underlying = uint8_t;
-  uint8_t val_;
-  bits1x8() = default;
-  explicit bits1x8(uint8_t val) : val_(val) {}
-};
-
-/**
- * bits2x4 is an uninterpreted dtype of a tensor with 2 bits (packed to byte
- * boundary), without any semantics defined.
- */
-struct alignas(1) bits2x4 {
-  using underlying = uint8_t;
-  uint8_t val_;
-  bits2x4() = default;
-  explicit bits2x4(uint8_t val) : val_(val) {}
-};
-
-/**
- * bits4x2 is an uninterpreted dtype of a tensor with 4 bits (packed to byte
- * boundary), without any semantics defined.
- */
-struct alignas(1) bits4x2 {
-  using underlying = uint8_t;
-  uint8_t val_;
-  bits4x2() = default;
-  explicit bits4x2(uint8_t val) : val_(val) {}
-};
-
-/**
- * bits8 is an uninterpreted dtype of a tensor with 8 bits, without any
- * semantics defined.
- */
-struct alignas(1) bits8 {
-  uint8_t val_;
-  bits8() = default;
-  explicit bits8(uint8_t val) : val_(val) {}
-};
-
-/**
- * bits16 is an uninterpreted dtype of a tensor with 16 bits, without any
- * semantics defined.
- */
-struct alignas(2) bits16 {
-  uint16_t val_;
-  bits16() = default;
-  explicit bits16(uint16_t val) : val_(val) {}
-};
-
-} // namespace etensor
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::etensor::bits16;
-using ::executorch::runtime::etensor::bits1x8;
-using ::executorch::runtime::etensor::bits2x4;
-using ::executorch::runtime::etensor::bits4x2;
-using ::executorch::runtime::etensor::bits8;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/complex.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/complex.h
deleted file mode 100644
index faf13a0432..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/complex.h
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <c10/util/complex.h>
-
-namespace executorch::runtime::etensor {
-using c10::complex;
-} // namespace executorch::runtime::etensor
-
-namespace torch::executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::etensor::complex;
-} // namespace torch::executor
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/device.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/device.h
deleted file mode 100644
index 32c53e9570..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/device.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <cstddef>
-#include <cstdint>
-
-namespace executorch {
-namespace runtime {
-namespace etensor {
-
-/// Represents the type of compute device.
-/// Note: ExecuTorch Device is distinct from PyTorch Device.
-enum class DeviceType : int8_t {
-  CPU = 0,
-  CUDA = 1,
-};
-
-/// Total number of device types, used for fixed-size registry arrays.
-constexpr size_t kNumDeviceTypes = 2;
-
-/// An index representing a specific device; e.g. GPU 0 vs GPU 1.
-using DeviceIndex = int8_t;
-
-/**
- * An abstraction for the compute device on which a tensor is located.
- *
- * Tensors carry a Device to express where their underlying data resides
- * (e.g. CPU host memory vs CUDA device memory). The runtime uses this to
- * dispatch memory allocation to the appropriate device allocator.
- */
-struct Device final {
-  using Type = DeviceType;
-
-  /// Constructs a new `Device` from a `DeviceType` and an optional device
-  /// index.
-  /* implicit */ Device(DeviceType type, DeviceIndex index = 0)
-      : type_(type), index_(index) {}
-
-  /// Returns the type of device the tensor data resides on.
-  DeviceType type() const noexcept { return type_; }
-
-  /// Returns true if the device is of CPU type.
-  bool is_cpu() const noexcept { return type_ == DeviceType::CPU; }
-
-  /// Returns the device index.
-  DeviceIndex index() const noexcept { return index_; }
-
-  bool operator==(const Device &other) const noexcept {
-    return type_ == other.type_ && index_ == other.index_;
-  }
-
-  bool operator!=(const Device &other) const noexcept {
-    return !(*this == other);
-  }
-
-private:
-  DeviceType type_;
-  DeviceIndex index_ = 0;
-};
-
-} // namespace etensor
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::etensor::Device;
-using ::executorch::runtime::etensor::DeviceType;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/half.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/half.h
deleted file mode 100644
index bf4c676ce8..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/half.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <c10/util/Half.h>
-
-namespace executorch::runtime::etensor {
-using c10::Half;
-namespace internal {
-using c10::detail::fp16_ieee_from_fp32_value;
-using c10::detail::fp16_ieee_to_fp32_bits;
-using c10::detail::fp16_ieee_to_fp32_value;
-using c10::detail::fp32_from_bits;
-using c10::detail::fp32_to_bits;
-} // namespace internal
-} // namespace executorch::runtime::etensor
-namespace torch::executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::etensor::Half;
-} // namespace torch::executor
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/optional.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/optional.h
deleted file mode 100644
index 31ad06fd09..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/optional.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <optional>
-
-namespace executorch {
-namespace runtime {
-namespace etensor {
-
-// NOLINTNEXTLINE(misc-unused-using-decls)
-using std::nullopt;
-// NOLINTNEXTLINE(misc-unused-using-decls)
-using std::nullopt_t;
-// NOLINTNEXTLINE(misc-unused-using-decls)
-using std::optional;
-
-} // namespace etensor
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::etensor::nullopt;
-using ::executorch::runtime::etensor::nullopt_t;
-using ::executorch::runtime::etensor::optional;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/qint_types.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/qint_types.h
deleted file mode 100644
index 183675e182..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/qint_types.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <cstdint>
-
-namespace executorch {
-namespace runtime {
-namespace etensor {
-
-/**
- * qint8 is for signed 8 bit quantized Tensors
- */
-struct alignas(1) qint8 {
-  using underlying = int8_t;
-  int8_t val_;
-  qint8() = default;
-  explicit qint8(int8_t val) : val_(val) {}
-};
-
-/**
- * quint8 is for unsigned 8 bit quantized Tensors
- */
-struct alignas(1) quint8 {
-  using underlying = uint8_t;
-  uint8_t val_;
-  quint8() = default;
-  explicit quint8(uint8_t val) : val_(val) {}
-};
-
-/**
- * qint32 is for signed 32 bit quantized Tensors
- */
-struct alignas(4) qint32 {
-  using underlying = int32_t;
-  int32_t val_;
-  qint32() = default;
-  explicit qint32(int32_t val) : val_(val) {}
-};
-
-/**
- * quint4x2 is for un-signed 4 bit quantized Tensors that are packed to byte
- * boundary.
- */
-struct alignas(1) quint4x2 {
-  using underlying = uint8_t;
-  uint8_t val_;
-  quint4x2() = default;
-  explicit quint4x2(uint8_t val) : val_(val) {}
-};
-
-/**
- * quint2x4 is for un-signed 2 bit quantized Tensors that are packed to byte
- * boundary.
- */
-struct alignas(1) quint2x4 {
-  using underlying = uint8_t;
-  uint8_t val_;
-  quint2x4() = default;
-  explicit quint2x4(uint8_t val) : val_(val) {}
-};
-
-} // namespace etensor
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::etensor::qint32;
-using ::executorch::runtime::etensor::qint8;
-using ::executorch::runtime::etensor::quint2x4;
-using ::executorch::runtime::etensor::quint4x2;
-using ::executorch::runtime::etensor::quint8;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/scalar.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/scalar.h
deleted file mode 100644
index f503990e15..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/scalar.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <executorch/runtime/core/portable_type/bfloat16.h>
-#include <executorch/runtime/core/portable_type/half.h>
-#include <executorch/runtime/core/tag.h>
-#include <executorch/runtime/platform/assert.h>
-
-#include <cstdint>
-#include <type_traits>
-
-namespace executorch {
-namespace runtime {
-namespace etensor {
-
-/**
- * Represents a scalar value.
- *
- * The API is a source-compatible subset of c10::Scalar, and the
- * semantics/behavior should also match the c10 version.
- */
-class Scalar {
-public:
-  Scalar() : Scalar(int64_t(0)) {}
-
-  template <typename T, typename std::enable_if<std::is_integral<T>::value,
-                                                bool>::type = true>
-  /*implicit*/ Scalar(T val) : tag(Tag::Int) {
-    v.as_int = static_cast<int64_t>(val);
-  }
-  /*implicit*/ Scalar(bool val) : tag(Tag::Bool) { v.as_bool = val; }
-  /*implicit*/ Scalar(double val) : tag(Tag::Double) { v.as_double = val; }
-  /*implicit*/ Scalar(BFloat16 val) : Scalar((double)(float)val) {}
-  /*implicit*/ Scalar(Half val) : Scalar((double)(float)val) {}
-
-  /// Returns the concrete scalar value stored within.
-  template <typename T> T to() const;
-
-  /// Returns true if the scalar is integral, false otherwise.
-  bool isIntegral(bool includeBool) const {
-    return Tag::Int == tag || (includeBool && isBoolean());
-  }
-
-  /// Returns true if the scalar is a floating point, false otherwise.
-  bool isFloatingPoint() const { return tag == Tag::Double; }
-
-  /// Returns true if the scalar is a boolean, false otherwise.
-  bool isBoolean() const { return tag == Tag::Bool; }
-
-private:
-  int64_t toInt() const {
-    if (isIntegral(/*includeBool=*/false)) {
-      return v.as_int;
-    } else if (isBoolean()) {
-      return static_cast<int64_t>(v.as_bool);
-    } else {
-      ET_CHECK_MSG(false, "Scalar is not an int nor a Boolean.");
-    }
-  }
-
-  double toFloatingPoint() const {
-    ET_CHECK_MSG(isFloatingPoint(), "Scalar is not a Double.");
-    return v.as_double;
-  }
-
-  double toDouble() const {
-    ET_CHECK_MSG(isFloatingPoint(), "Scalar is not a Double.");
-    return v.as_double;
-  }
-
-  bool toBool() const {
-    ET_CHECK_MSG(isBoolean(), "Scalar is not a Boolean.");
-    return v.as_bool;
-  }
-
-  Tag tag;
-  union v_t {
-    double as_double;
-    int64_t as_int;
-    bool as_bool;
-    v_t() {} // default constructor
-  } v;
-};
-
-#define ET_DEFINE_SCALAR_TO_METHOD(T, name)                                    \
-  template <> inline T Scalar::to<T>() const { return to##name(); }
-
-ET_DEFINE_SCALAR_TO_METHOD(double, Double)
-ET_DEFINE_SCALAR_TO_METHOD(int64_t, Int)
-ET_DEFINE_SCALAR_TO_METHOD(bool, Bool)
-#undef ET_DEFINE_SCALAR_TO_METHOD
-
-} // namespace etensor
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::etensor::Scalar;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/scalar_type.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/scalar_type.h
deleted file mode 100644
index b7d208721f..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/scalar_type.h
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @file
- *
- * Forked from
- * https://github.com/pytorch/pytorch/blob/master/c10/core/ScalarType.h
- *
- * Everything but the ScalarType definition is in util/ScalarTypeUtil.h
- *
- * Note that these files do not need to be strictly identical to the pytorch
- * core file, as far as names go. The only critical piece is that the types and
- * indices of the main ScalarType enum line up, so that serialization is
- * compatible between the two.
- *
- * Modifications for ExecuTorch:
- * - Namespace torch::executor instead of c10
- * - Macro prefix ET_ instead of AT_
- * - Use ET_CHECK_MSG() instead of TORCH_CHECK()
- * - Don't define standalone constants like `kByte`, `kInt` to keep the
- *   namespace clean
- * - Remove operator<< to avoid a dependency on ostream and stdlib
- * - Make `static inline` functions `inline` to avoid creating multiple
- *   copies of them. See
- *   https://gist.github.com/htfy96/50308afc11678d2e3766a36aa60d5f75#conclusion.
- * - Remove deprecated definitions
- * - Minor cleanup for internal consistency
- */
-
-#pragma once
-
-#include <cstdint>
-
-#include <executorch/runtime/core/portable_type/bfloat16.h>
-#include <executorch/runtime/core/portable_type/bits_types.h>
-#include <executorch/runtime/core/portable_type/complex.h>
-#include <executorch/runtime/core/portable_type/half.h>
-#include <executorch/runtime/core/portable_type/qint_types.h>
-
-namespace executorch {
-namespace runtime {
-namespace etensor {
-
-// Placing a bunch of unused dtypes here as our macros don't make it easy
-// to skip scalar types defined in aten that we dont have.
-namespace unused_dtype {
-struct alignas(1) Float8_e5m2 {
-  uint8_t x;
-  using underlying = uint8_t;
-  Float8_e5m2() = default;
-  explicit Float8_e5m2(uint8_t val) : x(val) {}
-};
-struct alignas(1) Float8_e4m3fn {
-  uint8_t x;
-  using underlying = uint8_t;
-  Float8_e4m3fn() = default;
-  explicit Float8_e4m3fn(uint8_t val) : x(val) {}
-};
-struct alignas(1) Float8_e5m2fnuz {
-  uint8_t x;
-  using underlying = uint8_t;
-  Float8_e5m2fnuz() = default;
-  explicit Float8_e5m2fnuz(uint8_t val) : x(val) {}
-};
-struct alignas(1) Float8_e4m3fnuz {
-  uint8_t x;
-  using underlying = uint8_t;
-  Float8_e4m3fnuz() = default;
-  explicit Float8_e4m3fnuz(uint8_t val) : x(val) {}
-};
-
-} // namespace unused_dtype
-
-/**
- * Calls the provided macro on every ScalarType, providing the C type and the
- * ScalarType name to each call.
- *
- * The indices and C types must be consistent with
- * AT_FORALL_SCALAR_TYPES_WITH_COMPLEX_AND_QINTS in the core pytorch file
- * c10/core/ScalarType.h. This ensures that ExecuTorch serialization is
- * compatible with ATen serialization.
- *
- * @param _ A macro that takes two parameters: the name of a C type, and the
- *     name of the corresponding ScalarType enumerator.
- */
-#define ET_FORALL_SCALAR_TYPES(_)                                              \
-  _(uint8_t, Byte)                              /* 0 */                        \
-  _(int8_t, Char)                               /* 1 */                        \
-  _(int16_t, Short)                             /* 2 */                        \
-  _(int32_t, Int)                               /* 3 */                        \
-  _(int64_t, Long)                              /* 4 */                        \
-  _(::executorch::runtime::etensor::Half, Half) /* 5 */                        \
-  _(float, Float)                               /* 6 */                        \
-  _(double, Double)                             /* 7 */                        \
-  _(::executorch::runtime::etensor::complex<::torch::executor::Half>,          \
-    ComplexHalf)                                                    /* 8 */    \
-  _(::executorch::runtime::etensor::complex<float>, ComplexFloat)   /* 9 */    \
-  _(::executorch::runtime::etensor::complex<double>, ComplexDouble) /* 10 */   \
-  _(bool, Bool)                                                     /* 11 */   \
-  _(::executorch::runtime::etensor::qint8, QInt8)                   /* 12 */   \
-  _(::executorch::runtime::etensor::quint8, QUInt8)                 /* 13 */   \
-  _(::executorch::runtime::etensor::qint32, QInt32)                 /* 14 */   \
-  _(::executorch::runtime::etensor::BFloat16, BFloat16)             /* 15 */   \
-  _(::executorch::runtime::etensor::quint4x2, QUInt4x2)             /* 16 */   \
-  _(::executorch::runtime::etensor::quint2x4, QUInt2x4)             /* 17 */   \
-  _(::executorch::runtime::etensor::bits1x8, Bits1x8)               /* 18 */   \
-  _(::executorch::runtime::etensor::bits2x4, Bits2x4)               /* 19 */   \
-  _(::executorch::runtime::etensor::bits4x2, Bits4x2)               /* 20 */   \
-  _(::executorch::runtime::etensor::bits8, Bits8)                   /* 21 */   \
-  _(::executorch::runtime::etensor::bits16, Bits16)                 /* 22 */   \
-  _(::executorch::runtime::etensor::unused_dtype::Float8_e5m2,                 \
-    Float8_e5m2) /* 23 */                                                      \
-  _(::executorch::runtime::etensor::unused_dtype::Float8_e4m3fn,               \
-    Float8_e4m3fn) /* 24 */                                                    \
-  _(::executorch::runtime::etensor::unused_dtype::Float8_e5m2fnuz,             \
-    Float8_e5m2fnuz) /* 25 */                                                  \
-  _(::executorch::runtime::etensor::unused_dtype::Float8_e4m3fnuz,             \
-    Float8_e4m3fnuz)  /* 26 */                                                 \
-  _(uint16_t, UInt16) /* 27 */                                                 \
-  _(uint32_t, UInt32) /* 28 */                                                 \
-  _(uint64_t, UInt64) /* 29 */
-
-/**
- * Data types (dtypes) that can be used as element types in ETensors.
- */
-enum class ScalarType : int8_t {
-/// Define an enumerator for each ScalarType.
-#define DEFINE_ENUM(unused, name) name,
-  ET_FORALL_SCALAR_TYPES(DEFINE_ENUM)
-#undef DEFINE_ENUM
-
-  /// An explicitly undefined ScalarType. Does not map to any C type.
-  Undefined,
-  /// The number of ScalarType enumerators.
-  NumOptions,
-};
-
-} // namespace etensor
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::etensor::ScalarType;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/string_view.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/string_view.h
deleted file mode 100644
index 8e28fa022c..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/string_view.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <string_view>
-
-namespace executorch {
-namespace runtime {
-namespace etensor {
-
-using std::string_view;
-
-} // namespace etensor
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::etensor::string_view;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/tensor.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/tensor.h
deleted file mode 100644
index 7e9efaa4e3..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/tensor.h
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <executorch/runtime/platform/compiler.h>
-
-#include <executorch/runtime/core/portable_type/tensor_impl.h>
-
-namespace executorch {
-namespace runtime {
-namespace etensor {
-
-/**
- * A minimal Tensor type whose API is a source compatible subset of at::Tensor.
- *
- * NOTE: Instances of this class do not own the TensorImpl given to it,
- * which means that the caller must guarantee that the TensorImpl lives longer
- * than any Tensor instances that point to it.
- *
- * See the documention on TensorImpl for details about the return/parameter
- * types used here and how they relate to at::Tensor.
- */
-class Tensor {
-public:
-  /// The type used for elements of `sizes()`.
-  using SizesType = TensorImpl::SizesType;
-  /// The type used for elements of `dim_order()`.
-  using DimOrderType = TensorImpl::DimOrderType;
-  /// The type used for elements of `strides()`.
-  using StridesType = TensorImpl::StridesType;
-
-  Tensor() = delete;
-  explicit constexpr Tensor(TensorImpl *impl) : impl_(impl) {}
-
-  /**
-   * Returns a pointer to the underlying TensorImpl.
-   *
-   * NOTE: Clients should be wary of operating on the TensorImpl
-   * directly instead of the Tensor. It is easy to break things.
-   */
-  TensorImpl *unsafeGetTensorImpl() const {
-    // TODO(T154114015): See if we can make this api private with friends.
-    return impl_;
-  }
-
-  /**
-   * Returns the size of the tensor in bytes.
-   *
-   * NOTE: Only the alive space is returned not the total capacity of the
-   * underlying data blob.
-   */
-  size_t nbytes() const { return impl_->nbytes(); }
-
-  /**
-   * Returns the size of the tensor at the given dimension.
-   *
-   * NOTE: that size() intentionally does not return SizeType even though it
-   * returns an element of an array of SizeType. This is to help make calls of
-   * this method more compatible with at::Tensor, and more consistent with the
-   * rest of the methods on this class and in ETensor.
-   */
-  ssize_t size(ssize_t dim) const { return impl_->size(dim); }
-
-  /// Returns the tensor's number of dimensions.
-  ssize_t dim() const { return impl_->dim(); }
-
-  /// Returns the number of elements in the tensor.
-  ssize_t numel() const { return impl_->numel(); }
-
-  /// Returns the type of the elements in the tensor (int32, float, bool, etc).
-  ScalarType scalar_type() const { return impl_->scalar_type(); }
-
-  inline ScalarType dtype() const { return scalar_type(); }
-
-  /// Returns the size in bytes of one element of the tensor.
-  ssize_t element_size() const { return impl_->element_size(); }
-
-  /// Returns the sizes of the tensor at each dimension.
-  const ArrayRef<SizesType> sizes() const { return impl_->sizes(); }
-
-  /// Returns the order the dimensions are laid out in memory.
-  const ArrayRef<DimOrderType> dim_order() const { return impl_->dim_order(); }
-
-  /// Returns the strides of the tensor at each dimension.
-  const ArrayRef<StridesType> strides() const { return impl_->strides(); }
-
-  /// Returns the mutability of the shape of the tensor.
-  TensorShapeDynamism shape_dynamism() const { return impl_->shape_dynamism(); }
-
-  /// Returns a pointer of type T to the constant underlying data blob.
-  template <typename T> inline const T *const_data_ptr() const {
-    return impl_->data<T>();
-  }
-
-  /// Returns a pointer to the constant underlying data blob.
-  inline const void *const_data_ptr() const { return impl_->data(); }
-
-  /// Returns a pointer of type T to the mutable underlying data blob.
-  template <typename T> inline T *mutable_data_ptr() const {
-    return impl_->mutable_data<T>();
-  }
-
-  /// Returns a pointer to the mutable underlying data blob.
-  inline void *mutable_data_ptr() const { return impl_->mutable_data(); }
-
-  /// DEPRECATED: Use const_data_ptr or mutable_data_ptr instead.
-  template <typename T> ET_DEPRECATED inline T *data_ptr() const {
-    return impl_->mutable_data<T>();
-  }
-
-  /// DEPRECATED: Use const_data_ptr or mutable_data_ptr instead.
-  ET_DEPRECATED inline void *data_ptr() const { return impl_->mutable_data(); }
-
-  /**
-   * DEPRECATED: Changes the data_ptr the tensor aliases. Does not free the
-   * previously pointed to data, does not assume ownership semantics of the new
-   * ptr. This api does not exist in at::Tensor so kernel developers should
-   * avoid it.
-   */
-  ET_DEPRECATED void set_data(void *ptr) const { impl_->set_data(ptr); }
-
-private:
-  TensorImpl *impl_ = nullptr;
-};
-
-} // namespace etensor
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::etensor::Tensor;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/tensor_impl.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/tensor_impl.h
deleted file mode 100644
index c841aef0c8..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/tensor_impl.h
+++ /dev/null
@@ -1,311 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <executorch/runtime/core/array_ref.h>
-#include <executorch/runtime/core/error.h>
-#include <executorch/runtime/core/portable_type/device.h>
-#include <executorch/runtime/core/portable_type/scalar_type.h>
-#include <executorch/runtime/core/result.h>
-#include <executorch/runtime/core/tensor_shape_dynamism.h>
-#include <executorch/runtime/platform/compiler.h>
-
-// Forward declaration of a helper that provides access to internal resizing
-// methods of TensorImpl. Real definition is in
-// executorch/runtime/core/exec_aten/tensor_util.h.
-namespace executorch {
-namespace runtime {
-namespace internal {
-class TensorResizerFriend;
-} // namespace internal
-} // namespace runtime
-} // namespace executorch
-
-namespace executorch {
-namespace runtime {
-namespace etensor {
-
-/**
- * Manages the storage behind an ETensor (torch::executor::Tensor).
- *
- * Note that instances of this class do not own the arrays given to it
- * (sizes/strides/data), which means that the caller must guarantee that they
- * live longer than a given instance of this class.
- *
- * Note on types:
- *
- * Code that uses ETensor should also be able to build against at::Tensor. So,
- * although the overlapping APIs don't need to be exactly the same, their types
- * should be semantically similar.
- *
- * Many of the methods in at::Tensor use int64_t for parameter and return types.
- * This can be a waste when building for 32-bit environments. So, TensorImpl and
- * ETensor use ssize_t instead: like int64_t it is signed, but it will match the
- * native word size of the target architecture. This will avoid unnecessarily
- * expensive uses of 64-bit integers on 32-bit machines.
- *
- * But, since the types are not identical, code that uses ETensor needs to be
- * generic about the local types it uses when working with these methods. In
- * most cases, `auto` will do the trick. In the worst case, code can be guarded
- * with `#ifdef USE_ATEN_LIB`.
- */
-class TensorImpl {
-public:
-  /**
-   * The type used for elements of `sizes()`.
-   *
-   * This must match the size/signedness of the type used for `Tensor.sizes` in
-   * //executorch/schema/program.fbs.
-   *
-   * Note that at::TensorImpl uses `int64_t` for this type. ExecuTorch uses
-   * `int32_t` to save memory, since no single size value will ever be larger
-   * than 2 billion.
-   */
-  using SizesType = int32_t;
-
-  /**
-   * The type used for elements of `dim_order()`.
-   *
-   * This must match the size/signedness of the type used for `Tensor.dim_order`
-   * in //executorch/schema/program.fbs.
-   */
-  using DimOrderType = uint8_t;
-
-  /**
-   * The type used for elements of `strides()`.
-   *
-   * This must match the size/signedness of the type used for `Tensor.strides`
-   * in //executorch/schema/program.fbs.
-   *
-   * Note that at::TensorImpl uses `int64_t` for this type. ExecuTorch uses
-   * `int32_t` to save memory, since no single stride value will ever be larger
-   * than 2 billion.
-   */
-  using StridesType = int32_t;
-
-  TensorImpl() = delete;
-
-  /**
-   * @param type The type of the data (int, float, bool).
-   * @param dim Number of dimensions, and the length of the `sizes` array.
-   * @param sizes Sizes of the tensor at each dimension. Must contain `dim`
-   *     entries.
-   * @param data Pointer to the data, whose size is determined by `type`,
-   *     `dim`, and `sizes`. The tensor will not own this memory.
-   * @param dim_order Order in which dimensions are laid out in memory.
-   * @param strides Strides of the tensor at each dimension. Must contain `dim`
-   *     entries.
-   * @param dynamism The mutability of the shape of the tensor.
-   * @param device_type The type of device where tensor data resides.
-   * @param device_index The device index for multi-device scenarios.
-   */
-  TensorImpl(ScalarType type, ssize_t dim, SizesType *sizes,
-             void *data = nullptr, DimOrderType *dim_order = nullptr,
-             StridesType *strides = nullptr,
-             TensorShapeDynamism dynamism = TensorShapeDynamism::STATIC,
-             DeviceType device_type = DeviceType::CPU,
-             DeviceIndex device_index = 0);
-
-  /**
-   * Returns the size of the tensor in bytes.
-   *
-   * NOTE: This returns the size of the data used by the tensor's current shape,
-   * not the capacity of the underlying buffer.
-   */
-  size_t nbytes() const;
-
-  /**
-   * Returns the size of the tensor at the given dimension.
-   *
-   * NOTE: size() intentionally does not return SizeType even though it
-   * returns an element of an array of SizeType. This is to help make calls of
-   * this method more compatible with at::Tensor, and more consistent with the
-   * rest of the methods on this class and in ETensor.
-   */
-  ssize_t size(ssize_t dim) const {
-    ET_CHECK_MSG(dim < dim_ && dim >= 0,
-                 "Dimension out of range (expected to be in range of [0, %zd], "
-                 "but got %zd",
-                 dim_ - 1, dim);
-    return sizes_[dim];
-  }
-
-  /// Returns the tensor's number of dimensions.
-  ssize_t dim() const { return dim_; }
-
-  /// Returns the number of elements in the tensor.
-  ssize_t numel() const { return numel_; }
-
-  /// Returns the type of the elements in the tensor (int32, float, bool, etc).
-  ScalarType scalar_type() const { return type_; }
-
-  inline ScalarType dtype() const { return scalar_type(); }
-
-  /// Returns the size in bytes of one element of the tensor.
-  ssize_t element_size() const;
-
-  /// Returns the sizes of the tensor at each dimension.
-  const ArrayRef<SizesType> sizes() const {
-    return ArrayRef<SizesType>{sizes_, static_cast<size_t>(dim_)};
-  }
-
-  /// Returns the order the dimensions are laid out in memory.
-  const ArrayRef<DimOrderType> dim_order() const {
-    return ArrayRef<DimOrderType>{dim_order_, static_cast<size_t>(dim_)};
-  }
-
-  /// Returns the strides of the tensor at each dimension.
-  const ArrayRef<StridesType> strides() const {
-    return ArrayRef<StridesType>{strides_, static_cast<size_t>(dim_)};
-  }
-
-  /// Returns the mutability of the shape of the tensor.
-  TensorShapeDynamism shape_dynamism() const { return shape_dynamism_; }
-
-  /// Returns the device where tensor data resides.
-  Device device() const { return device_; }
-
-  /// Returns the type of device where tensor data resides.
-  DeviceType device_type() const { return device_.type(); }
-
-  /// Returns the device index, or 0 if default/unspecified.
-  DeviceIndex device_index() const { return device_.index(); }
-
-  /// Returns a pointer of type T to the constant underlying data blob.
-  template <typename T> inline const T *data() const {
-    return static_cast<const T *>(data());
-  }
-
-  /// Returns a pointer to the constant underlying data blob.
-  const void *data() const { return data_; }
-
-  /// Returns a pointer of type T to the mutable underlying data blob.
-  template <typename T> inline T *mutable_data() const {
-    return static_cast<T *>(mutable_data());
-  }
-
-  /// Returns a pointer to the mutable underlying data blob.
-  void *mutable_data() const { return data_; }
-
-  /// Sets the underlying data blob to the passed in pointer.
-  void set_data(void *ptr) { data_ = ptr; }
-
-  /*
-   * DEPRECATED: Use torch::executor::resize_tensor() or
-   * torch::executor::resize_tensor_impl().
-   */
-  ET_DEPRECATED
-  void set_sizes_contiguous(ArrayRef<SizesType> new_sizes) {
-    Error err = internal_resize_contiguous(new_sizes);
-    ET_CHECK_MSG(err == Error::Ok,
-                 "Could not resize Tensor; see logs for details");
-  }
-
-private:
-  // For access to internal_resize_contiguous().
-  friend class ::executorch::runtime::internal::TensorResizerFriend;
-
-  /**
-   * Set the sizes and strides of a tensor assuming contiguous strides.
-   * Requires that `new_sizes.size() == this.dim()`.
-   *
-   * Callers must use torch::executor::resize_tensor() or
-   * torch::executor::resize_tensor_impl() instead, defined in TensorUtil.h.
-   *
-   * Same semantics as at::TensorImpl::set_sizes_contiguous(), but returns an
-   * error instead of panicking on failure. This is not part of the at::Tensor
-   * API, and can only be used in lean mode.
-   */
-  ET_NODISCARD Error internal_resize_contiguous(ArrayRef<SizesType> new_sizes);
-
-private:
-  // Keep fields arranged to avoid unnecessary alignment holes.
-
-  /// List of sizes of each dimension in the tensor.
-  SizesType *sizes_;
-
-  /// List of the order that dimensions are laid out in memory.
-  DimOrderType *dim_order_;
-
-  // TODO(T148356881): Get rid of strides from ETensor
-  StridesType *strides_;
-
-  /// Pointer to underlying data blob. NOTE: Can be null.
-  void *data_;
-
-  /// Tensor's number of dimensions.
-  const ssize_t dim_;
-
-  /// Number of elements in the tensor.
-  ssize_t numel_;
-
-  /// Maximum number of elements in the bounded tensor. Used when resizing up
-  /// and down.
-  size_t numel_bound_;
-
-  /// Scalar type (int, float, bool, etc) of the tensor data.
-  const ScalarType type_;
-
-  /// Specifies the mutability of the shape of the tensor.
-  const TensorShapeDynamism shape_dynamism_;
-
-  /// Device where tensor data resides (CPU, CUDA, etc.)
-  Device device_;
-};
-
-/**
- * Compute the number of elements based on the sizes of a tensor.
- */
-ssize_t compute_numel(
-    const ::executorch::runtime::etensor::TensorImpl::SizesType *sizes,
-    ssize_t dim);
-
-/**
- * Compute the number of elements based on the sizes of a tensor.
- * Returns Error::InvalidArgument if any intermediate multiplication would
- * overflow ssize_t, or if a size is negative. Prefer this over compute_numel()
- * for paths that can propagate an Error upward.
- */
-::executorch::runtime::Result<ssize_t>
-safe_numel(const ::executorch::runtime::etensor::TensorImpl::SizesType *sizes,
-           ssize_t dim);
-
-/// Appropriate format specifier for the result of calling
-/// size(). Must be used instead of using zd directly to support ATen
-/// mode.
-#define ET_PRI_TENSOR_SIZE "zd"
-
-/// Appropriate format specifier for the result of calling
-/// dim(). Must be used instead of using zd directly to support ATen
-/// mode.
-#define ET_PRI_TENSOR_DIM "zd"
-
-/// Appropriate format specifier for the result of calling
-/// numel(). Must be used instead of using zd directly to support ATen
-/// mode.
-#define ET_PRI_TENSOR_NUMEL "zd"
-
-// Appropriate format specifier for elements of sizes() and
-// strides(). Must be used instead of using d directly to support ATen
-// mode.
-#define ET_PRI_SIZES_AND_STRIDES "d"
-
-} // namespace etensor
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::etensor::compute_numel;
-using ::executorch::runtime::etensor::safe_numel;
-using ::executorch::runtime::etensor::TensorImpl;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/tensor_options.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/tensor_options.h
deleted file mode 100644
index 8b8f984864..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/portable_type/tensor_options.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <cstdint>
-
-namespace executorch {
-namespace runtime {
-namespace etensor {
-
-/**
- * Tensor data memory formats supported by ExecuTorch. This concept only exists
- * for compatibility with ATen; use dim_order to describe non-contiguous
- * layouts.
- */
-enum class MemoryFormat : int8_t {
-  /**
-   * Row-major contiguous data.
-   */
-  Contiguous = 0,
-  /**
-   * Output tensor format should remain the same as the input tensor format.
-   * E.g. if the input tensor is in channels_last format, operator output
-   * should be in channels_last format.
-   */
-  Preserve = 1,
-};
-
-/**
- * Tensor data memory layout. This concept only exists for compatibility
- * with ATen.
- */
-enum class Layout : int8_t {
-  /**
-   * The tensor occupies memory densely and indexing is managed through strides.
-   * Contrasted with a sparse tensor layout where the memory structure of the
-   * data blob will be more complicated and indexing requires larger structures.
-   *
-   * This is the only layout supported by ExecuTorch.
-   */
-  Strided = 0,
-};
-} // namespace etensor
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::etensor::Layout;
-using ::executorch::runtime::etensor::MemoryFormat;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/result.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/result.h
deleted file mode 100644
index bd9ce433a3..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/result.h
+++ /dev/null
@@ -1,258 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @file
- * Result type to be used in conjunction with ExecuTorch Error type.
- */
-
-#pragma once
-
-#include <new>
-#include <utility>
-
-#include "executorch/runtime/core/error.h"
-#include "executorch/runtime/platform/assert.h"
-
-namespace executorch {
-namespace runtime {
-
-/**
- * Result type wrapping either a value of type T or an error.
- *
- * Example use case:
- * @code
- *   Result<OpFn> getOp(int opcode) {
- *     if (isValidOpCode(opcode)) {
- *       return opFns[opcode];
- *     }
- *     return Error::NotFound;
- *   }
- *
- *   Error useOp(int opcode) {
- *     Result<OpFn> op = getOp(opcode);
- *     if (!op.ok()) {
- *       return op.error();
- *     }
- *     print(op->toString());
- *     execute(*op);
- *     return Error::Ok;
- *   }
- * @endcode
- */
-template <typename T> class Result final {
-public:
-  /// `value_type` member for generic programming.
-  typedef T value_type;
-
-  /**
-   * Creates a Result object from an Error.
-   *
-   * To preserve the invariant that `(result.error() == Error::Ok) ==
-   * result.ok()`, an `error` parameter value of `Error:Ok` will be converted to
-   * a non-Ok value.
-   */
-  /* implicit */ Result(Error error)
-      : error_(error == Error::Ok ? Error::Internal : error), hasValue_(false) {
-    if ET_UNLIKELY (error == Error::Ok) {
-      ET_LOG(Debug, "Attempted to create Result from Error::Ok, this has been "
-                    "converted to Error::Internal.");
-    }
-  }
-
-  /// Value copy constructor.
-  /* implicit */ Result(const T &val) : value_(val), hasValue_(true) {}
-
-  /// Value move constructor.
-  /* implicit */ Result(T &&val) : value_(std::move(val)), hasValue_(true) {}
-
-  /// Result move constructor.
-  /* implicit */ Result(Result &&rhs) noexcept : hasValue_(rhs.hasValue_) {
-    if (hasValue_) {
-      // Use the value type's move constructor.
-      new (&value_) T(std::move(rhs.value_));
-    } else {
-      error_ = rhs.error_;
-    }
-  }
-
-  ~Result() {
-    if (hasValue_) {
-      // Manual value destruction.
-      // Result "owns" the memory, so `delete` would segfault.
-      value_.~T();
-    }
-  }
-
-  /**
-   * Returns true if this Result has a value.
-   *
-   * If true, it is guaranteed that `error()` will return `Error::Ok`.
-   * If false, it is guaranteed that `error()` will not return `Error::Ok`.
-   */
-  ET_NODISCARD bool ok() const { return hasValue_; }
-
-  /**
-   * Returns the error code of this Result.
-   *
-   * If this returns `Error::Ok`, it is guaranteed that `ok()` will return true.
-   * If this does not return `Error:Ok`, it is guaranteed that `ok()` will
-   * return false.
-   */
-  ET_NODISCARD Error error() const {
-    if (hasValue_) {
-      return Error::Ok;
-    } else {
-      return error_;
-    }
-  }
-
-  /**
-   * Returns a reference to the Result's value; longhand for operator*().
-   *
-   * Only legal to call if `ok()` returns true.
-   */
-  T &get() {
-    CheckOk();
-    return value_;
-  }
-
-  /**
-   * Returns a reference to the Result's value; longhand for operator*().
-   *
-   * Only legal to call if `ok()` returns true.
-   */
-  const T &get() const {
-    CheckOk();
-    return value_;
-  }
-
-  /*
-   * Returns a reference to the Result's value; shorthand for get().
-   *
-   * Only legal to call if `ok()` returns true.
-   */
-  const T &operator*() const &;
-  T &operator*() &;
-
-  /*
-   * Returns a pointer to the Result's value.
-   *
-   * Only legal to call if `ok()` returns true.
-   */
-  const T *operator->() const;
-  T *operator->();
-
-private:
-  /**
-   * Delete default constructor since all Results should contain a value or
-   * error.
-   */
-  Result() = delete;
-  /// Delete copy constructor since T may not be copyable.
-  Result(const Result &) = delete;
-  /// Delete copy assignment since T may not be copyable.
-  Result &operator=(const Result &) = delete;
-  /// Delete move assignment since it's not a supported pattern to reuse Result.
-  Result &operator=(Result &&rhs) = delete;
-
-  // Panics if ok() would return false;
-  void CheckOk() const { ET_CHECK(hasValue_); }
-
-  union {
-    T value_;     // Used if hasValue_ is true.
-    Error error_; // Used if hasValue_ is false.
-  };
-
-  /// True if the Result contains a value.
-  const bool hasValue_;
-};
-
-template <typename T> const T &Result<T>::operator*() const & {
-  CheckOk();
-  return value_;
-}
-
-template <typename T> T &Result<T>::operator*() & {
-  CheckOk();
-  return value_;
-}
-
-template <typename T> const T *Result<T>::operator->() const {
-  CheckOk();
-  return &value_;
-}
-
-template <typename T> T *Result<T>::operator->() {
-  CheckOk();
-  return &value_;
-}
-
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::Result;
-} // namespace executor
-} // namespace torch
-
-/**
- * Unwrap a Result to obtain its value. If the Result contains an error,
- * propogate the error via trivial function return.
- *
- * Note: A function using ET_UNWRAP should itself return a Result or Error.
- *
- * @param[in] result__ Expression yielding the result to unwrap.
- * @param[in] ... Optional format string for the log error message and its
- * arguments.
- */
-#define ET_UNWRAP(result__, ...) ET_INTERNAL_UNWRAP(result__, ##__VA_ARGS__)
-
-// Internal only: Use ET_UNWRAP() instead.
-#define ET_INTERNAL_UNWRAP(...)                                                \
-  ET_INTERNAL_UNWRAP_SELECT(__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)        \
-  (__VA_ARGS__)
-
-// Internal only: Use ET_UNWRAP() instead.
-#define ET_INTERNAL_UNWRAP_SELECT(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N,  \
-                                  ...)                                         \
-  ET_INTERNAL_UNWRAP_##N
-
-// Internal only: Use ET_UNWRAP() instead.
-#define ET_INTERNAL_UNWRAP_1(result__)                                         \
-  ({                                                                           \
-    auto et_result__ = (result__);                                             \
-    if (!et_result__.ok()) {                                                   \
-      return et_result__.error();                                              \
-    }                                                                          \
-    std::move(*et_result__);                                                   \
-  })
-
-// Internal only: Use ET_UNWRAP() instead.
-#define ET_INTERNAL_UNWRAP_2(result__, message__, ...)                         \
-  ({                                                                           \
-    auto et_result__ = (result__);                                             \
-    if (!et_result__.ok()) {                                                   \
-      ET_LOG(Error, message__, ##__VA_ARGS__);                                 \
-      return et_result__.error();                                              \
-    }                                                                          \
-    std::move(*et_result__);                                                   \
-  })
-
-// Internal only: Use ET_UNWRAP() instead.
-#define ET_INTERNAL_UNWRAP_3 ET_INTERNAL_UNWRAP_2
-#define ET_INTERNAL_UNWRAP_4 ET_INTERNAL_UNWRAP_2
-#define ET_INTERNAL_UNWRAP_5 ET_INTERNAL_UNWRAP_2
-#define ET_INTERNAL_UNWRAP_6 ET_INTERNAL_UNWRAP_2
-#define ET_INTERNAL_UNWRAP_7 ET_INTERNAL_UNWRAP_2
-#define ET_INTERNAL_UNWRAP_8 ET_INTERNAL_UNWRAP_2
-#define ET_INTERNAL_UNWRAP_9 ET_INTERNAL_UNWRAP_2
-#define ET_INTERNAL_UNWRAP_10 ET_INTERNAL_UNWRAP_2
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/span.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/span.h
deleted file mode 100644
index d87ee8040f..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/span.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <cstdint>
-
-#include <executorch/runtime/platform/assert.h>
-
-namespace executorch {
-namespace runtime {
-
-/**
- * Represent a reference to an array (0 or more elements
- * consecutively in memory), i.e. a start pointer and a length.  It allows
- * various APIs to take consecutive elements easily and conveniently.
- *
- * This class does not own the underlying data, it is expected to be used in
- * situations where the data resides in some other buffer, whose lifetime
- * extends past that of the Span.
- *
- * Span and ArrayRef are extrememly similar with the difference being ArrayRef
- * views a list of constant elements and Span views a list of mutable elements.
- * Clients should decide between the two based on if the list elements for their
- * use case should be mutable.
- *
- * This is intended to be trivially copyable, so it should be passed by
- * value.
- */
-template <typename T> class Span final {
-public:
-  using value_type = T;
-  using iterator = T *;
-  using size_type = size_t;
-
-public:
-  /// Construct an empty Span.
-  /* implicit */ constexpr Span() noexcept : data_(nullptr), length_(0) {}
-
-  /// Construct a Span from a pointer and length.
-  Span(T *data, size_t length) : data_(data), length_(length) {
-    ET_DCHECK(data_ != nullptr || length_ == 0);
-  }
-
-  /// Construct a Span from a range.
-  Span(T *begin, T *end) : data_(begin), length_(end - begin) {}
-
-  /// Construct a Span from a C array.
-  template <size_t N>
-  /* implicit */ constexpr Span(T (&Arr)[N]) : data_(Arr), length_(N) {}
-
-  /// Construct a Span from a single element reference.
-  /* implicit */ constexpr Span(T &single_element)
-      : data_(&single_element), length_(1) {}
-
-  /// @returns a pointer to the start of the underlying element buffer.
-  iterator begin() const noexcept { return data_; }
-
-  /// @returns a pointer to the end of the underlying element buffer.
-  iterator end() const noexcept { return data_ + length_; }
-
-  /// @retval a boolean indicating if the Span is empty.
-  constexpr bool empty() const noexcept { return length_ == 0; }
-
-  /// @returns a pointer to the start of the underlying element buffer.
-  constexpr T *data() const noexcept { return data_; }
-
-  /// @returns the number of elements in the Span.
-  constexpr size_t size() const noexcept { return length_; }
-
-  /// Unchecked index into the array according to the argument index.
-  /// @returns a reference to the element at the specified index.
-  T &operator[](size_t index) const { return data_[index]; }
-
-private:
-  /// The start of the array, in an external buffer.
-  T *data_;
-
-  /// The number of elements.
-  size_type length_;
-};
-
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::Span;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/tag.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/tag.h
deleted file mode 100644
index 8b4b73506d..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/tag.h
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <cstdint>
-#include <executorch/runtime/core/defines.h>
-#include <executorch/runtime/platform/compiler.h>
-
-// X11 headers via volk define None, so we need to undef it
-#if defined(__linux__)
-#undef None
-#endif
-
-namespace executorch {
-namespace runtime {
-
-#define EXECUTORCH_FORALL_TAGS(_)                                              \
-  _(None)                                                                      \
-  _(Tensor)                                                                    \
-  _(String)                                                                    \
-  _(Double)                                                                    \
-  _(Int)                                                                       \
-  _(Bool)                                                                      \
-  _(ListBool)                                                                  \
-  _(ListDouble)                                                                \
-  _(ListInt)                                                                   \
-  _(ListTensor)                                                                \
-  _(ListScalar)                                                                \
-  _(ListOptionalTensor)
-
-/**
- * The dynamic type of an EValue.
- */
-enum class Tag : uint32_t {
-#define DEFINE_TAG(x) x,
-  EXECUTORCH_FORALL_TAGS(DEFINE_TAG)
-#undef DEFINE_TAG
-};
-
-#if ET_ENABLE_ENUM_STRINGS
-inline const char *tag_to_string(Tag tag) {
-  switch (tag) {
-#define CASE_TAG(x)                                                            \
-  case Tag::x:                                                                 \
-    return #x;
-    EXECUTORCH_FORALL_TAGS(CASE_TAG)
-#undef CASE_TAG
-  default:
-    return "Unknown";
-  }
-}
-#endif // ET_ENABLE_ENUM_STRINGS
-
-/**
- * Convert a tag value to a string representation. If ET_ENABLE_ENUM_STRINGS is
- * set (it is on by default), this will return a string name (for example,
- * "Tensor"). Otherwise, it will return a string representation of the index
- * value ("1").
- *
- * If the user buffer is not large enough to hold the string representation, the
- * string will be truncated.
- *
- * The return value is the number of characters written, or in the case of
- * truncation, the number of characters that would be written if the buffer was
- * large enough.
- */
-size_t tag_to_string(Tag tag, char *buffer, size_t buffer_size);
-
-/* The size of the buffer needed to hold the longest tag string, including the
- * null terminator. This value is expected to be updated manually, but it
- * checked in test_tag.cpp.
- */
-constexpr size_t kTagNameBufferSize = 19;
-
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::Tag;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/tensor_layout.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/tensor_layout.h
deleted file mode 100644
index 52f5a306e3..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/tensor_layout.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <executorch/runtime/core/exec_aten/util/scalar_type_util.h>
-#include <executorch/runtime/core/result.h>
-#include <executorch/runtime/core/span.h>
-
-namespace executorch {
-namespace ET_RUNTIME_NAMESPACE {
-
-/**
- * Describes the layout of a tensor.
- */
-class TensorLayout final {
-public:
-  TensorLayout() = delete;
-
-  /**
-   * Creates a TensorLayout from the given parameters.
-   *
-   * @param[in] sizes The sizes of the tensor. Note: the span passed here must
-   * outlive the TensorLayout and all copies of it.
-   * @param[in] dim_order The dim order of the tensor. Note: the span passed
-   * here must outlive the TensorLayout and all copies of it.
-   * @param[in] scalar_type The scalar type of the tensor.
-   * @return A Result containing the TensorLayout on success, or an error.
-   */
-  static executorch::runtime::Result<const TensorLayout>
-  create(Span<const int32_t> sizes, Span<const uint8_t> dim_order,
-         executorch::aten::ScalarType scalar_type);
-
-  /**
-   * Returns the sizes of the tensor.
-   *
-   * NOTE: The TensorLayout must outlive the spans returned here.
-   */
-  Span<const int32_t> sizes() const { return sizes_; }
-
-  /**
-   * Returns the dim order of the tensor.
-   *
-   * NOTE: The TensorLayout must outlive the spans returned here.
-   */
-  Span<const uint8_t> dim_order() const { return dim_order_; }
-
-  /// Returns the scalar type of the tensor.
-  executorch::aten::ScalarType scalar_type() const { return scalar_type_; }
-
-  /// Returns the size of the tensor in bytes.
-  size_t nbytes() const { return nbytes_; }
-
-private:
-  TensorLayout(Span<const int32_t> sizes, Span<const uint8_t> dim_order,
-               executorch::aten::ScalarType scalar_type, size_t nbytes)
-      : sizes_(sizes), dim_order_(dim_order), scalar_type_(scalar_type),
-        nbytes_(nbytes) {}
-  /// The sizes of the tensor.
-  const Span<const int32_t> sizes_;
-
-  /// The dim order of the tensor.
-  const Span<const uint8_t> dim_order_;
-
-  /// The scalar type of the tensor.
-  const executorch::aten::ScalarType scalar_type_;
-
-  /// The size in bytes of the tensor.
-  const size_t nbytes_;
-};
-
-} // namespace ET_RUNTIME_NAMESPACE
-} // namespace executorch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/tensor_shape_dynamism.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/tensor_shape_dynamism.h
deleted file mode 100644
index ee956288d7..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/tensor_shape_dynamism.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <cstdint>
-
-namespace executorch {
-namespace runtime {
-
-/**
- * The resizing capabilities of a Tensor.
- *
- * The rank of an ExecuTorch Tensors can never change, but shape sometimes can.
- */
-enum class TensorShapeDynamism : uint8_t {
-  /// Cannot change shape.
-  STATIC = 0,
-  /// Shape cannot exceed initial capacity.
-  DYNAMIC_BOUND = 1,
-  /// No restriction on shape and capacity.
-  DYNAMIC_UNBOUND = 2,
-};
-
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::TensorShapeDynamism;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/core/testing_util/error_matchers.h b/packages/react-native-executorch/third-party/include/executorch/runtime/core/testing_util/error_matchers.h
deleted file mode 100644
index bac9508780..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/core/testing_util/error_matchers.h
+++ /dev/null
@@ -1,292 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @file
- * Testing utilities for working with `executorch::runtime::Result<T>` and
- * `executorch::runtime::Error`. Provides matchers similar to `absl::StatusOr`
- * and `absl::Status`.
- *
- * Defines the following utilities:
- *
- *   ===============
- *   `IsOkAndHolds(m)`
- *   ===============
- *
- *   This gMock matcher matches a Result<T> value whose error is Ok
- *   and whose inner value matches matcher m.  Example:
- *
- *   ```
- *   using ::testing::MatchesRegex;
- *   using ::executorch::runtime::testing::IsOkAndHolds;
- *   ...
- *   executorch::runtime::Result<string> maybe_name = ...;
- *   EXPECT_THAT(maybe_name, IsOkAndHolds(MatchesRegex("John .*")));
- *   ```
- *
- *   ===============
- *   `ErrorIs(Error::error_code)`
- *   ===============
- *
- *   This gMock matcher matches a Result<T> value whose error matches
- *   the given error matcher. Example:
- *
- *   ```
- *   using ::executorch::runtime::testing::ErrorIs;
- *   ...
- *   executorch::runtime::Result<string> maybe_name = ...;
- *   EXPECT_THAT(maybe_name, ErrorIs(Error::InvalidArgument));
- *   ```
- *
- *   ===============
- *   `IsOk()`
- *   ===============
- *
- *   Matches an `executorch::runtime::Result<T>` value whose error value
- *   is `executorch::runtime::Error::Ok`.
- *
- *   Example:
- *   ```
- *   using ::executorch::runtime::testing::IsOk;
- *   ...
- *   executorch::runtime::Result<string> maybe_name = ...;
- *   EXPECT_THAT(maybe_name, IsOk());
- *   ```
- */
-
-#pragma once
-
-#include <ostream>
-#include <utility>
-
-#include <gmock/gmock-matchers.h>
-#include <gtest/gtest-matchers.h>
-
-#include <executorch/runtime/core/error.h>
-#include <executorch/runtime/core/result.h>
-
-/**
- * Unwrap a Result to obtain its value. If the Result contains an error,
- * fail the test with ASSERT_TRUE.
- *
- * This macro is useful for test code where you want to extract the value
- * from a Result and fail the test if the Result contains an error.
- *
- * Example usage:
- * ```
- *   Result<int> maybe_value = GetSomeValue();
- *   int value = ASSERT_OK_AND_UNWRAP(maybe_value);
- *   // Use value...
- * ```
- *
- * @param[in] result__ Expression yielding the Result to unwrap.
- */
-#define ASSERT_OK_AND_UNWRAP(result__)                                         \
-  ({                                                                           \
-    auto &&et_result__ = (result__);                                           \
-    ASSERT_TRUE(et_result__.ok());                                             \
-    std::move(*et_result__);                                                   \
-  })
-
-namespace executorch {
-namespace runtime {
-namespace testing {
-namespace internal {
-
-// Helper function to get the error from a Result
-template <typename T> inline Error GetError(const Result<T> &result) {
-  return result.error();
-}
-
-// Helper function to get the error from a raw Error (identity function)
-inline Error GetError(const Error &error) { return error; }
-
-////////////////////////////////////////////////////////////
-// Implementation of IsOkAndHolds().
-
-// Monomorphic implementation of matcher IsOkAndHolds(m). ResultType is a
-// reference to Result<T>.
-template <typename ResultType>
-class IsOkAndHoldsMatcherImpl : public ::testing::MatcherInterface<ResultType> {
-public:
-  typedef
-      typename std::remove_reference<ResultType>::type::value_type value_type;
-
-  template <typename InnerMatcher>
-  explicit IsOkAndHoldsMatcherImpl(InnerMatcher &&inner_matcher)
-      : inner_matcher_(::testing::SafeMatcherCast<const value_type &>(
-            std::forward<InnerMatcher>(inner_matcher))) {}
-
-  void DescribeTo(std::ostream *os) const override {
-    *os << "is OK and has a value that ";
-    inner_matcher_.DescribeTo(os);
-  }
-
-  void DescribeNegationTo(std::ostream *os) const override {
-    *os << "isn't OK or has a value that ";
-    inner_matcher_.DescribeNegationTo(os);
-  }
-
-  bool MatchAndExplain(
-      ResultType actual_value,
-      ::testing::MatchResultListener *result_listener) const override {
-    if (!actual_value.ok()) {
-      *result_listener << "which has error "
-                       << ::executorch::runtime::to_string(
-                              GetError(actual_value));
-      return false;
-    }
-
-    // Call through to the inner matcher.
-    return inner_matcher_.MatchAndExplain(*actual_value, result_listener);
-  }
-
-private:
-  const ::testing::Matcher<const value_type &> inner_matcher_;
-};
-
-// Implements IsOkAndHolds(m) as a polymorphic matcher.
-template <typename InnerMatcher> class IsOkAndHoldsMatcher {
-public:
-  explicit IsOkAndHoldsMatcher(InnerMatcher inner_matcher)
-      : inner_matcher_(std::forward<InnerMatcher>(inner_matcher)) {}
-
-  // Converts this polymorphic matcher to a monomorphic matcher of the
-  // given type. ResultType can be either Result<T> or a
-  // reference to Result<T>.
-  template <typename ResultType>
-  operator ::testing::Matcher<ResultType>() const { // NOLINT
-    return ::testing::Matcher<ResultType>(
-        new IsOkAndHoldsMatcherImpl<const ResultType &>(inner_matcher_));
-  }
-
-private:
-  const InnerMatcher inner_matcher_;
-};
-
-////////////////////////////////////////////////////////////
-// Implementation of IsOk().
-
-// Monomorphic implementation of matcher IsOk() for a given type T.
-// T can be Result<U>, Error, or references to either.
-template <typename T>
-class MonoIsOkMatcherImpl : public ::testing::MatcherInterface<T> {
-public:
-  void DescribeTo(std::ostream *os) const override { *os << "is OK"; }
-  void DescribeNegationTo(std::ostream *os) const override {
-    *os << "is not OK";
-  }
-  bool MatchAndExplain(
-      T actual_value,
-      ::testing::MatchResultListener *result_listener) const override {
-    const Error error = GetError(actual_value);
-    if (error != Error::Ok) {
-      *result_listener << "which has error "
-                       << ::executorch::runtime::to_string(error);
-      return false;
-    }
-    return true;
-  }
-};
-
-// Implements IsOk() as a polymorphic matcher.
-class IsOkMatcher {
-public:
-  template <typename T> operator ::testing::Matcher<T>() const { // NOLINT
-    return ::testing::Matcher<T>(new MonoIsOkMatcherImpl<const T &>());
-  }
-};
-
-////////////////////////////////////////////////////////////
-// Implementation of ErrorIs().
-
-// Monomorphic implementation of matcher ErrorIs() for a given type T.
-// T can be Result<U> or a reference to Result<U>.
-template <typename T>
-class MonoErrorIsMatcherImpl : public ::testing::MatcherInterface<T> {
-public:
-  explicit MonoErrorIsMatcherImpl(::testing::Matcher<Error> error_matcher)
-      : error_matcher_(std::move(error_matcher)) {}
-
-  void DescribeTo(std::ostream *os) const override {
-    *os << "has an error that ";
-    error_matcher_.DescribeTo(os);
-  }
-
-  void DescribeNegationTo(std::ostream *os) const override {
-    *os << "does not have an error that ";
-    error_matcher_.DescribeNegationTo(os);
-  }
-
-  bool MatchAndExplain(
-      T actual_value,
-      ::testing::MatchResultListener *result_listener) const override {
-    Error actual_error = GetError(actual_value);
-    *result_listener << "which has error "
-                     << ::executorch::runtime::to_string(actual_error);
-    return error_matcher_.MatchAndExplain(actual_error, result_listener);
-  }
-
-private:
-  const ::testing::Matcher<Error> error_matcher_;
-};
-
-// Implements ErrorIs() as a polymorphic matcher.
-template <typename ErrorMatcher> class ErrorIsMatcher {
-public:
-  explicit ErrorIsMatcher(ErrorMatcher error_matcher)
-      : error_matcher_(std::forward<ErrorMatcher>(error_matcher)) {}
-
-  // Converts this polymorphic matcher to a monomorphic matcher of the
-  // given type. T can be Result<U> or a reference to Result<U>.
-  template <typename T> operator ::testing::Matcher<T>() const { // NOLINT
-    return ::testing::Matcher<T>(new MonoErrorIsMatcherImpl<const T &>(
-        ::testing::MatcherCast<Error>(error_matcher_)));
-  }
-
-private:
-  const ErrorMatcher error_matcher_;
-};
-
-} // namespace internal
-
-// Returns a gMock matcher that matches a Result<> whose error is
-// OK and whose value matches the inner matcher.
-template <typename InnerMatcherT>
-internal::IsOkAndHoldsMatcher<typename std::decay<InnerMatcherT>::type>
-IsOkAndHolds(InnerMatcherT &&inner_matcher) {
-  return internal::IsOkAndHoldsMatcher<
-      typename std::decay<InnerMatcherT>::type>(
-      std::forward<InnerMatcherT>(inner_matcher));
-}
-
-// Returns a gMock matcher that matches a Result<> whose error matches
-// the given error matcher.
-template <typename ErrorMatcherT>
-internal::ErrorIsMatcher<typename std::decay<ErrorMatcherT>::type>
-ErrorIs(ErrorMatcherT &&error_matcher) {
-  return internal::ErrorIsMatcher<typename std::decay<ErrorMatcherT>::type>(
-      std::forward<ErrorMatcherT>(error_matcher));
-}
-
-// Returns a gMock matcher that matches a Result<> which is OK.
-inline internal::IsOkMatcher IsOk() { return internal::IsOkMatcher(); }
-
-} // namespace testing
-} // namespace runtime
-} // namespace executorch
-
-namespace executorch {
-namespace runtime {
-
-// This needs to be defined in the SAME namespace that defines Error.
-// C++'s look-up rules rely on that.
-void PrintTo(const Error &error, std::ostream *os);
-
-} // namespace runtime
-} // namespace executorch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/executor/memory_manager.h b/packages/react-native-executorch/third-party/include/executorch/runtime/executor/memory_manager.h
deleted file mode 100644
index 91cdeb3db7..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/executor/memory_manager.h
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <executorch/runtime/core/hierarchical_allocator.h>
-#include <executorch/runtime/core/memory_allocator.h>
-
-namespace executorch {
-namespace runtime {
-
-/**
- * A container class for allocators used during Method load and execution.
- *
- * This class consolidates all dynamic memory needs for Method load and
- * execution. This can allow for heap-based as well as heap-less execution
- * (relevant to some embedded scenarios), and overall provides more control over
- * memory use.
- *
- * This class, however, cannot ensure all allocation is accounted for since
- * kernel and backend implementations are free to use a separate way to allocate
- * memory (e.g., for things like scratch space). But we do suggest that backends
- * and kernels use these provided allocators whenever possible.
- */
-class MemoryManager final {
-public:
-  /**
-   * Constructs a new MemoryManager.
-   *
-   * @param[in] method_allocator The allocator to use when loading a Method and
-   *     allocating its internal structures. Must outlive the Method that uses
-   *     it.
-   * @param[in] planned_memory The memory-planned buffers to use for mutable
-   *     tensor data when executing a Method. Must outlive the Method that uses
-   *     it. May be `nullptr` if the Method does not use any memory-planned
-   *     tensor data. The sizes of the buffers in this HierarchicalAllocator
-   *     must agree with the corresponding
-   *     `MethodMeta::num_memory_planned_buffers()` and
-   *     `MethodMeta::memory_planned_buffer_size(N)` values, which are embedded
-   *     in the Program.
-   * @param[in] temp_allocator The allocator to use when allocating temporary
-   *     data during kernel or delegate execution. Must outlive the Method that
-   *     uses it. May be `nullptr` if the Method does not use kernels or
-   *     delegates that allocate temporary data. This allocator will be reset
-   *     after every kernel or delegate call during execution.
-   */
-  explicit MemoryManager(MemoryAllocator *method_allocator,
-                         HierarchicalAllocator *planned_memory = nullptr,
-                         MemoryAllocator *temp_allocator = nullptr)
-      : method_allocator_(method_allocator), planned_memory_(planned_memory),
-        temp_allocator_(temp_allocator) {
-    ET_CHECK_MSG(method_allocator != temp_allocator,
-                 "method allocator cannot be the same as temp allocator");
-  }
-
-  /**
-   * DEPRECATED: Use the constructor without `constant_allocator` instead.
-   *
-   * TODO(T162089316): Remove this once all users migrate to the new ctor.
-   */
-  ET_DEPRECATED MemoryManager(MemoryAllocator *constant_allocator,
-                              HierarchicalAllocator *non_constant_allocator,
-                              MemoryAllocator *runtime_allocator,
-                              MemoryAllocator *temporary_allocator)
-      : MemoryManager(
-            /*method_allocator=*/runtime_allocator,
-            /*planned_memory=*/non_constant_allocator,
-            /*temp_allocator=*/temporary_allocator) {
-    (void)constant_allocator; // Suppress unused variable warning
-  }
-
-  /**
-   * Returns the allocator that the runtime will use to allocate internal
-   * structures while loading a Method. Must not be used after its associated
-   * Method has been loaded.
-   */
-  MemoryAllocator *method_allocator() const { return method_allocator_; }
-
-  /**
-   * Returns the memory-planned buffers to use for mutable tensor data.
-   */
-  HierarchicalAllocator *planned_memory() const { return planned_memory_; }
-
-  /**
-   * Returns the allocator to use for allocating temporary data during kernel or
-   * delegate execution.
-   *
-   * This allocator will be reset after every kernel or delegate call during
-   * execution.
-   */
-  MemoryAllocator *temp_allocator() const { return temp_allocator_; }
-
-private:
-  MemoryAllocator *method_allocator_;
-  HierarchicalAllocator *planned_memory_;
-  MemoryAllocator *temp_allocator_;
-};
-
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::MemoryManager;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/executor/merged_data_map.h b/packages/react-native-executorch/third-party/include/executorch/runtime/executor/merged_data_map.h
deleted file mode 100644
index 013230dd65..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/executor/merged_data_map.h
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <executorch/runtime/core/named_data_map.h>
-
-namespace executorch {
-namespace ET_RUNTIME_NAMESPACE {
-namespace internal {
-
-/**
- * A NamedDataMap implementation that wraps other NamedDataMaps.
- */
-class MergedDataMap final : public NamedDataMap {
-public:
-  /**
-   * Creates a new NamedDataMap that wraps two other data maps.
-   *
-   * @param[in] first The first NamedDataMap to merge.
-   * @param[in] second The second NamedDataMap to merge.
-   * Note: the data maps must outlive the MergedDataMap instance.
-   */
-  static Result<MergedDataMap> load(const NamedDataMap *first,
-                                    const NamedDataMap *second) {
-    ET_CHECK_OR_RETURN_ERROR(first != nullptr && second != nullptr,
-                             InvalidArgument, "Input data map is null.");
-
-    // Check for duplicate keys.
-    for (uint32_t k = 0; k < first->get_num_keys().get(); k++) {
-      const auto key = first->get_key(k).get();
-      const auto error = second->get_tensor_layout(key).error();
-      // TODO(lfq): add API to check if key exists.
-      ET_CHECK_OR_RETURN_ERROR(error == Error::NotFound ||
-                                   error == Error::NotImplemented,
-                               InvalidArgument, "Duplicate key %s.", key);
-    }
-    return MergedDataMap(first, second);
-  }
-
-  /**
-   * Retrieve the tensor_layout for the specified key.
-   *
-   * @param[in] key The name of the tensor to get metadata on.
-   *
-   * @return Error::NotFound if the key is not present.
-   */
-  ET_NODISCARD
-  Result<const TensorLayout>
-  get_tensor_layout(executorch::aten::string_view key) const override {
-    auto layout = first_->get_tensor_layout(key);
-    if (layout.ok()) {
-      return layout.get();
-    }
-    if (layout.error() != Error::NotFound) {
-      return layout.error();
-    }
-    return second_->get_tensor_layout(key);
-  }
-
-  /**
-   * Retrieve read-only data for the specified key.
-   *
-   * @param[in] key The name of the tensor to get data on.
-   *
-   * @return error if the key is not present or data cannot be loaded.
-   */
-  ET_NODISCARD
-  Result<FreeableBuffer>
-  get_data(executorch::aten::string_view key) const override {
-    auto data = first_->get_data(key);
-    if (data.error() != Error::NotFound) {
-      return data;
-    }
-    return second_->get_data(key);
-  }
-
-  /**
-   * Loads the data of the specified tensor into the provided buffer.
-   * Not used in the MergedDataMap.
-   *
-   * @param[in] key The name of the tensor to get the data of.
-   * @param[in] buffer The buffer to load data into. Must point to at least
-   * `size` bytes of memory.
-   * @param[in] size The number of bytes to load.
-   *
-   * @returns an Error indicating if the load was successful.
-   */
-  ET_NODISCARD Error load_data_into(ET_UNUSED executorch::aten::string_view key,
-                                    ET_UNUSED void *buffer,
-                                    ET_UNUSED size_t size) const override {
-    return Error::NotImplemented;
-  }
-
-  /**
-   * @returns The number of keys in the map.
-   */
-  ET_NODISCARD Result<uint32_t> get_num_keys() const override {
-    return first_->get_num_keys().get() + second_->get_num_keys().get();
-  }
-
-  /**
-   * @returns The key at the specified index, error if index out of bounds.
-   */
-  ET_NODISCARD Result<const char *> get_key(uint32_t index) const override {
-    uint32_t total_num_keys = get_num_keys().get();
-    ET_CHECK_OR_RETURN_ERROR(index < total_num_keys, InvalidArgument,
-                             "Index %" PRIu32 " out of range of size %" PRIu32,
-                             index, total_num_keys);
-
-    if (index < first_->get_num_keys().get()) {
-      return first_->get_key(index);
-    } else {
-      return second_->get_key(index - first_->get_num_keys().get());
-    }
-  }
-
-  MergedDataMap(MergedDataMap &&) noexcept = default;
-
-  ~MergedDataMap() override = default;
-
-private:
-  MergedDataMap(const NamedDataMap *first, const NamedDataMap *second)
-      : first_{first}, second_{second} {}
-
-  // Not copyable or assignable.
-  MergedDataMap(const MergedDataMap &rhs) = delete;
-  MergedDataMap &operator=(MergedDataMap &&rhs) noexcept = delete;
-  MergedDataMap &operator=(const MergedDataMap &rhs) = delete;
-
-  const NamedDataMap *first_;
-  const NamedDataMap *second_;
-};
-
-} // namespace internal
-} // namespace ET_RUNTIME_NAMESPACE
-} // namespace executorch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/executor/method.h b/packages/react-native-executorch/third-party/include/executorch/runtime/executor/method.h
deleted file mode 100644
index dd66951ca5..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/executor/method.h
+++ /dev/null
@@ -1,440 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#ifdef __GNUC__
-// Disable -Wdeprecated-declarations, as some builds use 'Werror'.
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-#include <executorch/runtime/backend/backend_options_map.h>
-#include <executorch/runtime/core/evalue.h>
-#include <executorch/runtime/core/event_tracer.h>
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <executorch/runtime/core/named_data_map.h>
-#include <executorch/runtime/core/span.h>
-#include <executorch/runtime/executor/memory_manager.h>
-#include <executorch/runtime/executor/merged_data_map.h>
-#include <executorch/runtime/executor/method_meta.h>
-#include <executorch/runtime/kernel/operator_registry.h>
-#include <executorch/runtime/platform/compiler.h>
-
-// Forward declare flatbuffer types. This is a public header and must not
-// include the generated flatbuffer header.
-namespace executorch_flatbuffer {
-struct Chain;
-struct ExecutionPlan;
-struct EValue;
-} // namespace executorch_flatbuffer
-
-namespace executorch {
-namespace ET_RUNTIME_NAMESPACE {
-
-// Forward declare NamedData. This is a public header and must not include
-// internal data types.
-namespace deserialization {
-struct NamedData;
-} // namespace deserialization
-
-// Forward declare Program to avoid a circular reference.
-class Program;
-
-// Forward declare internal types.
-class BackendDelegate;
-struct Chain;
-class KernelRuntimeContext;
-using OpFunction = void (*)(KernelRuntimeContext &, Span<EValue *>);
-/// A list of pointers into the master values table that together compose the
-/// argument list for a single instruction
-using InstructionArgs = Span<EValue *>;
-using deserialization::NamedData;
-
-/**
- * An executable method of an executorch program. Maps to a python method like
- * `forward()` on the original nn.Module.
- */
-class Method final {
-public:
-  /**
-   * Move ctor. Takes ownership of resources previously owned by `rhs`,
-   * and leaves `rhs` in an uninitialized state.
-   */
-  Method(Method &&rhs) noexcept
-      : step_state_(rhs.step_state_), program_(rhs.program_),
-        memory_manager_(rhs.memory_manager_),
-        temp_allocator_(rhs.temp_allocator_),
-        serialization_plan_(rhs.serialization_plan_),
-        event_tracer_(rhs.event_tracer_), n_value_(rhs.n_value_),
-        values_(rhs.values_), input_set_(rhs.input_set_),
-        n_delegate_(rhs.n_delegate_), delegates_(rhs.delegates_),
-        n_chains_(rhs.n_chains_), chains_(rhs.chains_),
-        merged_data_map_(std::move(rhs.merged_data_map_)),
-        external_constants_(rhs.external_constants_),
-        n_external_constants_(rhs.n_external_constants_),
-        kernel_registry_(rhs.kernel_registry_), init_state_(rhs.init_state_) {
-    // Required: clear out fields that the dtor looks at, so that we don't free
-    // anything twice.
-    rhs.n_value_ = 0;
-    rhs.values_ = nullptr;
-    rhs.input_set_ = nullptr;
-    rhs.n_delegate_ = 0;
-    rhs.delegates_ = nullptr;
-
-    rhs.merged_data_map_ = nullptr;
-    rhs.n_external_constants_ = 0;
-    rhs.external_constants_ = nullptr;
-
-    // Helpful: Try to ensure that any other interactions with the old object
-    // result in failures.
-    rhs.init_state_ = InitializationState::Uninitialized;
-    rhs.step_state_ = {};
-    rhs.program_ = nullptr;
-    rhs.memory_manager_ = nullptr;
-    rhs.serialization_plan_ = nullptr;
-    rhs.event_tracer_ = nullptr;
-    rhs.n_chains_ = 0;
-    rhs.chains_ = nullptr;
-  }
-
-  /**
-   * Sets the internal input value to be equivalent to the to the provided
-   * value.
-   *
-   * @param[in] input_evalue The evalue to copy into the method input. If the
-   *     evalue is a tensor, the data is copied in most cases, so the tensor
-   *     passed in here does not always need to outlive this call. But there is
-   *     a case where the Method will keep a pointer to the tensor's data.
-   *     Based on the memory plan of the method, the inputs may not have
-   *     buffer space pre-allocated for them. In this case the executor will
-   *     alias the memory of the tensors provided as inputs here rather then
-   *     deepcopy the input into the memory planned arena.
-   *
-   * @param[in] input_idx Zero-based index of the input to set. Must be less
-   *     than the value returned by inputs_size().
-   *
-   * @returns Error::Ok on success, non-Ok on failure.
-   */
-  ET_NODISCARD Error set_input(const EValue &input_evalue, size_t input_idx);
-
-  /**
-   * Sets the values of all method inputs.
-   *
-   * See set_input() for a more detailed description of the behavior.
-   *
-   * @param[in] input_evalues The new values for all of the method inputs. The
-   *     type of each element must match the type of corresponding input. If the
-   *     value of an element is a tensor, attempts to allow dynamic shape, but
-   *     the dtype must always agree.
-   *
-   * @returns Error::Ok on success, non-Ok on failure.
-   */
-  ET_NODISCARD Error
-  set_inputs(const executorch::aten::ArrayRef<EValue> &input_evalues);
-
-  /**
-   * Sets the data buffer of the specified method output to the provided value.
-   *
-   * NOTE: Based on the memory plan of the method, the output tensors may not
-   * have buffer space pre-allocated for them, in this case the executor will
-   * point those tensors to the buffer provided here, so the user should take
-   * care that the life span of this memory outlasts the executor forward.
-   *
-   * @param[in] buffer The block of memory to point the specified tensor at.
-   *
-   * @param[in] size the length of buffer in bytes, must be >= the nbytes of the
-   * specified tensor.
-   *
-   * @param[in] output_idx The index of the output to set the data_ptr for. Must
-   *     correspond to a tensor, and that tensor must not have had a buffer
-   *     allocated by the memory plan.
-   *
-   * @returns Error::Ok on success, non-Ok on failure.
-   */
-  ET_NODISCARD Error set_output_data_ptr(void *buffer, size_t size,
-                                         size_t output_idx);
-
-  /**
-   * Copies the method's outputs into the provided array.
-   *
-   * WARNING: The output contains shallow copies of internal tensor outputs.
-   * Please do not mutate returned Tensor elements.
-   *
-   * TODO(T139259264): Add checks to detect output mutation, or deep-copy
-   * outputs.
-   *
-   * @param[in] output_evalues The array to copy the outputs into. The first
-   *     `outputs_size()` elements will be set to the corresponding output
-   *     values. The rest of the array will be set to the EValue value None.
-   * @param[in] length The size of the `output_evalues` array in elements. Must
-   *     be greater than or equal to `outputs_size()`.
-   *
-   * @returns Error::Ok on success, non-Ok on failure.
-   */
-  ET_NODISCARD Error get_outputs(EValue *output_evalues, size_t length);
-
-  /**
-   * DEPRECATED: Use MethodMeta instead to access metadata, and set_input to
-   * update Method inputs.
-   *
-   * Copies the method's inputs into the provided array.
-   *
-   * WARNING: The input contains shallow copies of internal tensor inputs.
-   * Please do not mutate returned Tensor elements.
-   *
-   * @param[in] input_evalues The array to copy the inputs into. The first
-   *     `inputs_size()` elements will be set to the corresponding input
-   *     values. The rest of the array will be set to the EValue value None.
-   * @param[in] length The size of the `input_evalues` array in elements. Must
-   *     be greater than or equal to `inputs_size()`.
-   *
-   * @returns Error::Ok on success, non-Ok on failure.
-   */
-  ET_DEPRECATED ET_NODISCARD Error get_inputs(EValue *input_evalues,
-                                              size_t length);
-
-  /**
-   *
-   * Retrieves the attribute tensor associated with the given name.
-   *
-   * @param[in] name The name of the attribute tensor to retrieve.
-   *
-   * @returns Result containing the attribute tensor on success, non-Ok on
-   * failure.
-   */
-  ET_NODISCARD Result<executorch::aten::Tensor>
-  get_attribute(std::string_view name);
-
-  /**
-   * Execute the method.
-   *
-   * NOTE: Will fail with Error::InvalidState if the method has been partially
-   * executed using the `step()` api. Call reset_execution() after step()
-   * reaches EndOfMethod before calling execute().
-   *
-   * If execute() encounters an error mid-execution, the state is automatically
-   * reset to allow retry attempts.
-   *
-   * @returns Error::Ok on success, non-Ok on failure.
-   */
-  ET_NODISCARD Error execute();
-
-  /**
-   * EXPERIMENTAL: Advances/executes a single instruction in the method.
-   *
-   * @retval Error::Ok step succeeded
-   * @retval non-Ok step failed
-   * @retval Error::EndOfMethod method finished executing successfully
-   */
-  ET_EXPERIMENTAL ET_NODISCARD Error step();
-
-  /// DEPRECATED: Use `step()` instead.
-  ET_DEPRECATED ET_NODISCARD Error experimental_step();
-
-  /**
-   * EXPERIMENTAL: Returns true if method execution is in progress.
-   *
-   * Execution is considered "in progress" when step() has been called and
-   * execution is mid-way through the instruction sequence.
-   *
-   * @retval true if execution is in progress (not at initial state, not at end)
-   * @retval false if at initial state, after completion, or after any error
-   *
-   * @note execute() automatically resets state on error, so in_progress()
-   *       returns false immediately after execute() fails.
-   */
-  ET_EXPERIMENTAL ET_NODISCARD bool in_progress() const;
-
-  /**
-   * EXPERIMENTAL: Resets execution state to the start of the Method. For use
-   * with the `step()` API.
-   *
-   * @retval Error::Ok on success
-   * @retval Error::InvalidState if called before step-based execution reached
-   *     the end of the Method. When using step(), you must step through to
-   *     EndOfMethod before resetting. Note: execute() handles its own error
-   *     recovery and does not require manual reset.
-   */
-  ET_EXPERIMENTAL ET_NODISCARD Error reset_execution();
-
-  /// DEPRECATED: Use `reset_execution()` instead.
-  ET_DEPRECATED ET_NODISCARD Error experimental_reset_execution();
-
-  /**
-   * Returns the MethodMeta that corresponds to the calling Method.
-   */
-  MethodMeta method_meta() const;
-
-  /**
-   * Returns the number of inputs the Method expects.
-   */
-  size_t inputs_size() const;
-
-  /**
-   * Returns the number of outputs the Method returns.
-   */
-  size_t outputs_size() const;
-
-  /**
-   * Retrieves the output at the specified index.
-   */
-  const EValue &get_output(size_t i) const;
-
-  EventTracer *get_event_tracer();
-
-  /// DEPRECATED: Use MethodMeta instead to access metadata, and set_input to
-  /// update Method inputs.
-  ET_DEPRECATED const EValue &get_input(size_t i) const;
-  /// DEPRECATED: Use MethodMeta instead to access metadata, and set_input to
-  /// update Method inputs.
-  ET_DEPRECATED EValue &mutable_input(size_t i);
-  /// DEPRECATED: Use MethodMeta instead to access metadata, and get_output to
-  /// retrieve Method outputs.
-  ET_DEPRECATED EValue &mutable_output(size_t i);
-
-  ~Method();
-
-private:
-  // Delete other rule-of-five methods.
-  Method(const Method &) = delete;
-  Method &operator=(const Method &) noexcept = delete;
-  Method &operator=(Method &&) = delete;
-
-  // Let Program call load().
-  friend class Program;
-  // Let Executor call the ctor and init().
-  friend class Executor;
-
-  enum class InitializationState : uint8_t {
-    Uninitialized,
-    Initialized,
-    InitializationFailed,
-  };
-
-  /// Tracks what step in program execution we are on
-  struct StepState {
-    size_t chain_idx;
-    size_t instr_idx;
-  };
-
-  Method(const Program *program, MemoryManager *memory_manager,
-         EventTracer *event_tracer, MemoryAllocator *temp_allocator,
-         Span<const Kernel> kernel_registry = {})
-      : step_state_(), program_(program), memory_manager_(memory_manager),
-        temp_allocator_(temp_allocator), serialization_plan_(nullptr),
-        event_tracer_(event_tracer), n_value_(0), values_(nullptr),
-        input_set_(nullptr), n_delegate_(0), delegates_(nullptr), n_chains_(0),
-        chains_(nullptr), merged_data_map_(nullptr),
-        external_constants_(nullptr), n_external_constants_(0),
-        kernel_registry_(kernel_registry),
-        init_state_(InitializationState::Uninitialized) {}
-
-  /// Static factory used by Program.
-  ET_NODISCARD static Result<Method>
-  load(executorch_flatbuffer::ExecutionPlan *s_plan, const Program *program,
-       MemoryManager *memory_manager, EventTracer *event_tracer,
-       const NamedDataMap *named_data_map,
-       const LoadBackendOptionsMap *backend_options = nullptr,
-       Span<const Kernel> kernel_registry = {});
-
-  /**
-   * Initialize the method from its serialized representation.
-   *
-   * @returns Error::Ok on success, non-Ok on failure.
-   */
-  ET_NODISCARD Error init(executorch_flatbuffer::ExecutionPlan *s_plan,
-                          const NamedDataMap *named_data_map,
-                          const LoadBackendOptionsMap *backend_options);
-
-  /// Returns true if the Method was successfully initialized.
-  inline bool initialized() const {
-    return init_state_ == InitializationState::Initialized;
-  }
-
-  const EValue &get_value(size_t i) const;
-  EValue &mutable_value(size_t i);
-  size_t get_input_index(size_t i) const;
-  size_t get_output_index(size_t i) const;
-
-  // Executes a single instruction using the state in step_state_
-  ET_NODISCARD Error execute_instruction();
-
-  StepState step_state_;
-  const Program *program_;
-  MemoryManager *memory_manager_;
-  MemoryAllocator *temp_allocator_;
-  executorch_flatbuffer::ExecutionPlan *serialization_plan_;
-  EventTracer *event_tracer_;
-
-  size_t n_value_;
-  EValue *values_;
-  bool *input_set_;
-
-  size_t n_delegate_;
-  BackendDelegate *delegates_;
-
-  size_t n_chains_;
-  Chain *chains_;
-
-  internal::MergedDataMap *merged_data_map_;
-  NamedData *external_constants_;
-  size_t n_external_constants_ = 0;
-
-  Span<const Kernel> kernel_registry_;
-
-  InitializationState init_state_;
-
-  /**
-   * Counts the number of tensors marked as EXTERNAL in the flatbuffer
-   * for this method.
-   */
-  ET_NODISCARD Result<size_t> get_num_external_constants();
-
-  /**
-   * Parses the flatbuffer for constant tensors tagged as EXTERNAL.
-   * Retrieves the external constants using the named_data_map and places them
-   * into `external_constants_`. Updates `n_external_constants_` to count the
-   * number of successfully-initialized external constants.
-   * FreeableBuffers returned by the named_data_map are owned by the
-   * method and are freed on method destruction.
-   *
-   * @param[in] named_data_map, to retrieve external constants from.
-   * @returns Error::Ok on success, non-Ok on failure.
-   */
-  ET_NODISCARD Error
-  parse_external_constants(const NamedDataMap *named_data_map);
-
-  /**
-   * Parses the elements of the values_ array. On error, n_value_ will be set to
-   * the number of successfully-initialized entries so that ~Method doesn't try
-   * to clean up uninitialized entries.
-   */
-  ET_NODISCARD Error parse_values(const NamedDataMap *named_data_map);
-
-  ET_NODISCARD Error resolve_operator(int32_t op_index, OpFunction *kernels,
-                                      size_t kernel_index, InstructionArgs args,
-                                      size_t n_args);
-
-  void log_outputs();
-};
-
-} // namespace ET_RUNTIME_NAMESPACE
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::ET_RUNTIME_NAMESPACE::Method;
-} // namespace executor
-} // namespace torch
-
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/executor/method_meta.h b/packages/react-native-executorch/third-party/include/executorch/runtime/executor/method_meta.h
deleted file mode 100644
index 2cacb49506..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/executor/method_meta.h
+++ /dev/null
@@ -1,312 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <executorch/runtime/core/portable_type/device.h>
-#include <executorch/runtime/core/result.h>
-#include <executorch/runtime/core/span.h>
-#include <executorch/runtime/core/tag.h>
-
-// Forward declare flatbuffer types. This is a public header and must not
-// include the generated flatbuffer header.
-namespace executorch_flatbuffer {
-struct ExecutionPlan;
-} // namespace executorch_flatbuffer
-
-namespace executorch {
-namespace ET_RUNTIME_NAMESPACE {
-namespace testing {
-// Provides test access to private Program methods.
-class TensorInfoTestFriend;
-} // namespace testing
-
-/**
- * Metadata about a specific tensor of an ExecuTorch Program.
- *
- * The program used to create the MethodMeta object that created this
- * TensorInfo must outlive this TensorInfo.
- */
-class TensorInfo final {
-public:
-  TensorInfo() = delete;
-  TensorInfo(const TensorInfo &) = default;
-  TensorInfo(TensorInfo &&) = default;
-  TensorInfo &operator=(const TensorInfo &) = default;
-  TensorInfo &operator=(TensorInfo &&other) = default;
-  ~TensorInfo() = default;
-
-  /**
-   * Returns the sizes of the tensor.
-   */
-  Span<const int32_t> sizes() const;
-
-  /**
-   * Returns the dim order of the tensor.
-   */
-  Span<const uint8_t> dim_order() const;
-
-  /**
-   * Returns the scalar type of the input/output.
-   */
-  executorch::aten::ScalarType scalar_type() const;
-
-  /**
-   * Returns whether the tensor's memory was planned during export.
-   */
-  bool is_memory_planned() const;
-
-  /**
-   * Returns the size of the tensor in bytes.
-   */
-  size_t nbytes() const;
-
-  /**
-   * Returns the fully qualified name of the Tensor might be empty if the tensor
-   * is nameless.
-   */
-  std::string_view name() const;
-
-private:
-  // Let MethodMeta create TensorInfo.
-  friend class MethodMeta;
-  friend class testing::TensorInfoTestFriend;
-
-  /**
-   * Create a TensorInfo instance.
-   *
-   * @param[in] sizes The sizes of the tensor.
-   * @param[in] dim_order The dim order of the tensor.
-   * @param[in] scalar_type The scalar type of the tensor.
-   * @param[in] is_memory_planned Whether the tensor's memory was planned.
-   * @param[in] name The fully qualified name of the tensor.
-   * @returns A Result containing the TensorInfo on success, or an error on
-   * failure.
-   */
-  static Result<TensorInfo> create(Span<const int32_t> sizes,
-                                   Span<const uint8_t> dim_order,
-                                   executorch::aten::ScalarType scalar_type,
-                                   const bool is_memory_planned,
-                                   std::string_view name);
-
-  TensorInfo(Span<const int32_t> sizes, Span<const uint8_t> dim_order,
-             executorch::aten::ScalarType scalar_type,
-             const bool is_memory_planned, std::string_view name,
-             size_t nbytes);
-
-  /**
-   * The sizes of the tensor.
-   *
-   * NOTE: References data from the Program, so the Program must outlive the
-   * TensorInfo.
-   */
-  Span<const int32_t> sizes_;
-
-  /**
-   * The dim order of the tensor.
-   *
-   * NOTE: References data from the Program, so the Program must outlive the
-   * TensorInfo.
-   */
-  Span<const uint8_t> dim_order_;
-
-  /// The fully qualified name of the Tensor.
-  std::string_view name_;
-
-  /// The scalar type of the tensor.
-  executorch::aten::ScalarType scalar_type_;
-
-  /// Whether the tensor's memory was planned during export.
-  bool is_memory_planned_;
-
-  /// The size in bytes of the tensor.
-  size_t nbytes_;
-};
-
-/**
- * Describes a a method in an ExecuTorch program.
- *
- * The program used to create a MethodMeta object must outlive the MethodMeta.
- * It is separate from Method so that this information can be accessed without
- * paying the initialization cost of loading the full Method.
- */
-class MethodMeta final {
-public:
-  MethodMeta() = delete;
-  MethodMeta(const MethodMeta &) = default;
-  MethodMeta(MethodMeta &&) = default;
-  MethodMeta &operator=(const MethodMeta &) = default;
-  MethodMeta &operator=(MethodMeta &&other) = default;
-  ~MethodMeta() = default;
-
-  /**
-   * Get the name of this method.
-   *
-   * @returns The method name.
-   */
-  const char *name() const;
-
-  /**
-   * Get the number of inputs to this method.
-   *
-   * @returns The number of inputs.
-   */
-  size_t num_inputs() const;
-
-  /**
-   * Get the tag of the specified input.
-   *
-   * @param[in] index The index of the input to look up.
-   * @returns The tag of input, can only be [Tensor, Int, Bool, Double, String].
-   */
-  Result<Tag> input_tag(size_t index) const;
-
-  /**
-   * Get metadata about the specified input.
-   *
-   * @param[in] index The index of the input to look up.
-   * @returns The metadata on success, or an error on failure. Only valid for
-   * tag::Tensor
-   */
-  Result<TensorInfo> input_tensor_meta(size_t index) const;
-
-  /**
-   * Get the number of outputs to this method.
-   *
-   * @returns The number of outputs.
-   */
-  size_t num_outputs() const;
-
-  /**
-   * Get the tag of the specified output.
-   *
-   * @param[in] index The index of the output to look up.
-   * @returns The tag of output, can only be [Tensor, Int, Bool, Double,
-   * String].
-   */
-  Result<Tag> output_tag(size_t index) const;
-
-  /**
-   * Get metadata about the specified output.
-   *
-   * @param[in] index The index of the output to look up.
-   * @returns The metadata on success, or an error on failure. Only valid for
-   * tag::Tensor
-   */
-  Result<TensorInfo> output_tensor_meta(size_t index) const;
-
-  /**
-   * Get the number of attribute tensors in this method.
-   *
-   * @returns The number of attribute tensors.
-   */
-  size_t num_attributes() const;
-
-  /**
-   * Get metadata about the specified attribute tensor.
-   *
-   * @param[in] index The index of the attribute tensor to look up.
-   * @returns The metadata on success, or an error on failure.
-   */
-  Result<TensorInfo> attribute_tensor_meta(size_t index) const;
-
-  /**
-   * Get the number of memory-planned buffers this method requires.
-   *
-   * @returns The number of memory-planned buffers.
-   */
-  size_t num_memory_planned_buffers() const;
-
-  /**
-   * Get the size in bytes of the specified memory-planned buffer.
-   *
-   * @param[in] index The index of the buffer to look up.
-   * @returns The size in bytes on success, or an error on failure.
-   */
-  Result<int64_t> memory_planned_buffer_size(size_t index) const;
-
-  /**
-   * Get the device placement for the specified memory-planned buffer.
-   *
-   * For CPU-only programs (no non_const_buffer_device in the PTE), all buffers
-   * default to Device{CPU, 0}. For programs with device annotations, returns
-   * the device type and index that the buffer should be allocated on.
-   *
-   * @param[in] index The index of the buffer to look up (0-based, same
-   *     indexing as memory_planned_buffer_size()).
-   * @returns The Device on success, or an error on failure.
-   */
-  Result<etensor::Device> memory_planned_buffer_device(size_t index) const;
-
-  /**
-   * Check to see if a backend is used in this method.
-   *
-   * @param[in] backend_name The name of the backend to search for.
-   * @returns true if a backend is used in this method, otherwise false.
-   */
-  bool uses_backend(const char *backend_name) const;
-
-  /**
-   * Get the number of backends used in this method.
-   *
-   * @returns The total number of backend names.
-   */
-  size_t num_backends() const;
-
-  /**
-   * Get the backend name at the given index.
-   *
-   * @param[in] index The index of the backend name.
-   * @returns A Result wrapping the backend name as a C-style string
-   * on success, or an error if the index is invalid.
-   */
-  Result<const char *> get_backend_name(size_t index) const;
-
-  /**
-   * Get the number of instructions in this method.
-   *
-   * @returns The number of instructions.
-   */
-  ET_EXPERIMENTAL size_t num_instructions() const;
-
-  /**
-   * DEPRECATED: Use num_memory_planned_buffers() instead.
-   */
-  ET_DEPRECATED size_t num_non_const_buffers() const {
-    return num_memory_planned_buffers();
-  }
-
-  /**
-   * DEPRECATED: Use memory_planned_buffer_size() instead.
-   */
-  Result<int64_t> non_const_buffer_size(size_t index) const {
-    return memory_planned_buffer_size(index);
-  }
-
-private:
-  // Let Program create MethodMeta.
-  friend class Program;
-
-  explicit MethodMeta(const executorch_flatbuffer::ExecutionPlan *s_plan);
-
-  /// Source of truth for method information
-  const executorch_flatbuffer::ExecutionPlan *s_plan_;
-};
-
-} // namespace ET_RUNTIME_NAMESPACE
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::ET_RUNTIME_NAMESPACE::MethodMeta;
-using ::executorch::ET_RUNTIME_NAMESPACE::TensorInfo;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/executor/platform_memory_allocator.h b/packages/react-native-executorch/third-party/include/executorch/runtime/executor/platform_memory_allocator.h
deleted file mode 100644
index 181181b923..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/executor/platform_memory_allocator.h
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <cinttypes>
-#include <cstdint>
-#include <stdio.h>
-
-#include <c10/util/safe_numerics.h>
-#include <executorch/runtime/core/memory_allocator.h>
-#include <executorch/runtime/platform/log.h>
-#include <executorch/runtime/platform/platform.h>
-
-namespace executorch {
-namespace ET_RUNTIME_NAMESPACE {
-namespace internal {
-
-/**
- * PlatformMemoryAllocator is a memory allocator that uses a linked list to
- * manage allocated nodes. It overrides the allocate method of MemoryAllocator
- * using the PAL fallback allocator method `et_pal_allocate`.
- */
-class PlatformMemoryAllocator final : public MemoryAllocator {
-private:
-  // We allocate a little more than requested and use that memory as a node in
-  // a linked list, pushing the allocated buffers onto a list that's iterated
-  // and freed when the KernelRuntimeContext is destroyed.
-  struct AllocationNode {
-    void *data;
-    AllocationNode *next;
-  };
-
-  AllocationNode *head_ = nullptr;
-
-public:
-  PlatformMemoryAllocator() : MemoryAllocator(0, nullptr) {}
-
-  void *allocate(size_t size, size_t alignment = kDefaultAlignment) override {
-    if (!isPowerOf2(alignment)) {
-      ET_LOG(Error, "Alignment %zu is not a power of 2", alignment);
-      return nullptr;
-    }
-
-    // Check for overflow before computing total allocation size.
-    // Allocate enough for the node, data, and alignment bump (at most
-    // alignment - 1 extra bytes to align the data pointer).
-    size_t alloc_size = 0;
-    if (c10::add_overflows(sizeof(AllocationNode), size, &alloc_size) ||
-        c10::add_overflows(alloc_size, alignment - 1, &alloc_size)) {
-      ET_LOG(Error, "Allocation size overflow: size %zu, alignment %zu", size,
-             alignment);
-      return nullptr;
-    }
-
-    void *node_memory = runtime::pal_allocate(alloc_size);
-
-    // If allocation failed, log message and return nullptr.
-    if (node_memory == nullptr) {
-      ET_LOG(Error, "Failed to allocate %zu bytes", alloc_size);
-      return nullptr;
-    }
-
-    // Compute data pointer.
-    uint8_t *data_ptr =
-        reinterpret_cast<uint8_t *>(node_memory) + sizeof(AllocationNode);
-
-    // Align the data pointer.
-    void *aligned_data_ptr = alignPointer(data_ptr, alignment);
-
-    // Assert that the alignment didn't overflow the allocated memory.
-    ET_DCHECK_MSG(
-        reinterpret_cast<uintptr_t>(aligned_data_ptr) + size <=
-            reinterpret_cast<uintptr_t>(node_memory) + alloc_size,
-        "aligned_data_ptr %p + size %zu > node_memory %p + alloc_size %zu",
-        aligned_data_ptr, size, node_memory, alloc_size);
-
-    // Construct the node.
-    AllocationNode *new_node = reinterpret_cast<AllocationNode *>(node_memory);
-    new_node->data = aligned_data_ptr;
-    new_node->next = head_;
-    head_ = new_node;
-
-    // Return the aligned data pointer.
-    return head_->data;
-  }
-
-  void reset() override {
-    AllocationNode *current = head_;
-    while (current != nullptr) {
-      AllocationNode *next = current->next;
-      runtime::pal_free(current);
-      current = next;
-    }
-    head_ = nullptr;
-  }
-
-  ~PlatformMemoryAllocator() override { reset(); }
-
-private:
-  // Disable copy and move.
-  PlatformMemoryAllocator(const PlatformMemoryAllocator &) = delete;
-  PlatformMemoryAllocator &operator=(const PlatformMemoryAllocator &) = delete;
-  PlatformMemoryAllocator(PlatformMemoryAllocator &&) noexcept = delete;
-  PlatformMemoryAllocator &
-  operator=(PlatformMemoryAllocator &&) noexcept = delete;
-};
-
-} // namespace internal
-} // namespace ET_RUNTIME_NAMESPACE
-} // namespace executorch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/executor/program.h b/packages/react-native-executorch/third-party/include/executorch/runtime/executor/program.h
deleted file mode 100644
index 01dbc1fdfa..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/executor/program.h
+++ /dev/null
@@ -1,320 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <cstdint>
-#include <optional>
-
-#include <executorch/runtime/backend/backend_options_map.h>
-#include <executorch/runtime/core/data_loader.h>
-#include <executorch/runtime/core/error.h>
-#include <executorch/runtime/core/event_tracer.h>
-#include <executorch/runtime/core/freeable_buffer.h>
-#include <executorch/runtime/core/result.h>
-#include <executorch/runtime/executor/memory_manager.h>
-#include <executorch/runtime/executor/method.h>
-#include <executorch/runtime/executor/method_meta.h>
-#include <executorch/runtime/executor/pte_data_map.h>
-#include <executorch/runtime/kernel/operator_registry.h>
-#include <executorch/runtime/platform/compiler.h>
-
-// Forward declare flatbuffer types. This is a public header and must not
-// include the generated flatbuffer header.
-namespace executorch_flatbuffer {
-struct Program;
-} // namespace executorch_flatbuffer
-
-namespace executorch {
-namespace ET_RUNTIME_NAMESPACE {
-namespace testing {
-// Provides test access to private Program methods.
-class ProgramTestFriend;
-} // namespace testing
-
-namespace deserialization {
-// Provides Tensor deserializaiton access to private Program methods.
-class TensorParser;
-} // namespace deserialization
-
-/**
- * A deserialized ExecuTorch program binary.
- */
-class Program final {
-public:
-  /**
-   * Types of validation that the Program can do before parsing the data.
-   */
-  enum class Verification : uint8_t {
-    /**
-     * Do minimal verification of the data, ensuring that the header appears
-     * correct.
-     *
-     * Has minimal runtime overhead.
-     */
-    Minimal,
-    /**
-     * When ET_ENABLE_PROGRAM_VERIFICATION is enabled,
-     * Do full verification of the data, ensuring that internal pointers are
-     * self-consistent and that the data has not been truncated or obviously
-     * corrupted. May not catch all types of corruption, but should guard
-     * against illegal memory operations during parsing.
-     * Also performs additional semantic validation such as:
-     * - Tensor numel overflow checks (ensuring size calculations don't
-     * overflow)
-     * - List element type validation
-     *
-     * Will have higher runtime overhead, scaling with the complexity of the
-     * proram data.
-     */
-    InternalConsistency,
-  };
-
-  /**
-   * Loads a Program from the provided loader. The Program will hold a pointer
-   * to the loader, which must outlive the returned Program instance.
-   *
-   * @param[in] loader The source to load program data from. The Program will
-   *     hold a pointer to this loader, which must outlive the returned Program
-   *     instance.
-   * @param[in] verification The type of verification to do before returning
-   *     success.
-   */
-  ET_NODISCARD static Result<Program>
-  load(DataLoader *loader, Verification verification = Verification::Minimal);
-
-  /// DEPRECATED: Use the lowercase `load()` instead.
-  ET_DEPRECATED ET_NODISCARD static Result<Program>
-  Load(DataLoader *loader, Verification verification = Verification::Minimal) {
-    return load(loader, verification);
-  }
-
-  // Movable, to be compatible with Result.
-  Program(Program &&) noexcept = default;
-  ~Program() = default;
-
-  /**
-   * Get the constant buffer inside Program with index buffer_idx.
-   * @param[in] buffer_idx the index of the buffer in the constant_buffer.
-   * @param[in] nbytes the number of bytes to read from the buffer.
-   * @return The buffer with corresponding index.
-   */
-  Result<const void *> get_constant_buffer_data(size_t buffer_idx,
-                                                size_t nbytes) const;
-
-  /**
-   * Get the named data map from the program.
-   * @return The named data map.
-   */
-  Result<const NamedDataMap *> get_named_data_map() const;
-
-  /**
-   * Returns the number of methods in the program.
-   */
-  size_t num_methods() const;
-
-  /**
-   * Returns the name of the method at particular index.
-   *
-   * @param[in] method_index The index of the method name to retrieve. Must be
-   * less than the value returned by `num_methods()`.
-   *
-   * @returns The name of the requested method. The pointer is owned by the
-   * Program, and has the same lifetime as the Program.
-   */
-  Result<const char *> get_method_name(size_t method_index) const;
-
-  /**
-   * Loads the named method and prepares it for execution.
-   *
-   * @param[in] method_name The name of the method to load.
-   * @param[in] memory_manager The allocators to use during initialization and
-   *     execution of the loaded method. If `memory_manager.temp_allocator()` is
-   *     null, the runtime will allocate temp memory using `et_pal_allocate()`.
-   * @param[in] event_tracer The event tracer to use for this method run.
-   * @param[in] named_data_map An optional map of {name, blob} used to resolve
-   *     data that is external to the PTE, if any.
-   * @param[in] backend_options An optional map of per-backend load-time options
-   *     (RuntimeSpecs). Each backend will receive its corresponding options
-   *     during initialization.
-   *
-   * @returns The loaded method on success, or an error on failure.
-   */
-  Result<Method>
-  load_method(const char *method_name, MemoryManager *memory_manager,
-              EventTracer *event_tracer = nullptr,
-              const NamedDataMap *named_data_map = nullptr,
-              const LoadBackendOptionsMap *backend_options = nullptr,
-              Span<const Kernel> kernel_registry = {}) const;
-
-  /**
-   * Gathers metadata for the named method.
-   *
-   * @param[in] method_name The name of the method to get metadata for.
-   */
-  Result<MethodMeta> method_meta(const char *method_name) const;
-
-  /**
-   * DEPRECATED: Get the pytree encoding string for the output. Deprecated as
-   * this functionality will eventually move out of the core program into a
-   * higher level structure, but that does not exist at this time.
-   * @param[in] method_name The name of the method to get the encoding for.
-   *
-   * @return The pytree encoding string for the output
-   */
-  ET_DEPRECATED Result<const char *>
-  get_output_flattening_encoding(const char *method_name = "forward") const;
-
-  /**
-   * Describes the presence of an ExecuTorch program header.
-   */
-  enum HeaderStatus {
-    /**
-     * An ExecuTorch program header is present, and its version is compatible
-     * with this version of the runtime.
-     */
-    CompatibleVersion,
-
-    /**
-     * An ExecuTorch program header is present, but its version is not
-     * compatible with this version of the runtime.
-     */
-    IncompatibleVersion,
-
-    /**
-     * An ExecuTorch program header is not present.
-     */
-    NotPresent,
-
-    /**
-     * The data provided was too short to find the program header.
-     */
-    ShortData,
-  };
-
-  /**
-   * The minimum number of bytes necessary for calls to `check_header`.
-   */
-  static constexpr size_t kMinHeadBytes = 64;
-
-  /**
-   * Looks for an ExecuTorch program header in the provided data.
-   *
-   * @param[in] data The data from the beginning of a file that might contain
-   *     an ExecuTorch program.
-   * @param[in] size The size of `data` in bytes. Must be >= `kMinHeadBytes`.
-   *
-   * @returns A value describing the presence of a header in the data.
-   */
-  static HeaderStatus check_header(const void *data, size_t size);
-
-private:
-  // Let some classes call these private methods.
-  friend class BackendDelegate;
-  friend class Executor;
-  friend class Method;
-  friend class deserialization::TensorParser;
-  friend class testing::ProgramTestFriend;
-
-  const executorch_flatbuffer::Program *get_internal_program() const {
-    return internal_program_;
-  }
-
-  // Used by Method to look up entries in the delegate data table.
-  Error get_backend_delegate_data(size_t index, const void **out_data,
-                                  size_t *out_size) const;
-
-  /**
-   * Loads a segment by index.
-   *
-   * @param[in] segment_info Struct containing an index to load from the
-   * Program.segments list. The other fields of the struct, such as
-   * `segment_type` and `descriptor`, need to also be correct.
-   *
-   * @returns The data as a FreeableBuffer, if the index is valid.
-   * @retval Error::NotFound The program does not contain any segments or the
-   *     index is out of range.
-   * @returns Other errors depending on the implementation of
-   *     DataLoader: The Program.segment table is inconsistent, or the
-   *     data cannot be accessed.
-   */
-  ET_NODISCARD Result<FreeableBuffer>
-  LoadSegment(const DataLoader::SegmentInfo &segment_info) const;
-
-  /**
-   * Loads a portion of a mutable segment into the provided buffer.
-   *
-   * @param[in] mutable_data_segments_index The index into the
-   * mutable_data_segments_array.
-   * @param[in] offset_index The index into the segment's offsets array.
-   * @param[in] size The number of bytes to load.
-   * @param[in] buffer The buffer to load data into. Must point to at least
-   * `size` bytes of memory.
-   *
-   * @returns An error code on if the load was successful.
-   * @retval Error::Ok The load was successful.
-   * @retval Error::NotFound The program does not contain any segments or the
-   *     indices are out of range.
-   * @returns Other errors depending on the implementation of
-   *     DataLoader: The Program.segment table is inconsistent, or the
-   *     data cannot be accessed.
-   */
-  ET_NODISCARD Error load_mutable_subsegment_into(
-      size_t mutable_data_segments_index, size_t offset_index, size_t size,
-      void *buffer) const;
-
-private:
-  Program(DataLoader *loader, size_t segment_base_offset,
-          FreeableBuffer &&program_data,
-          const executorch_flatbuffer::Program *internal_program,
-          FreeableBuffer &&constant_segment_data,
-          std::optional<internal::PteDataMap> &&pte_data_map)
-      : program_data_(std::move(program_data)),
-        // Don't need the loader if there are no segments.
-        loader_(segment_base_offset > 0 ? loader : nullptr),
-        internal_program_(internal_program),
-        segment_base_offset_(segment_base_offset),
-        constant_segment_data_(std::move(constant_segment_data)),
-        pte_data_map_(std::move(pte_data_map)) {}
-
-  // Not copyable or assignable.
-  Program(const Program &rhs) = delete;
-  Program &operator=(Program &&rhs) noexcept = delete;
-  Program &operator=(const Program &rhs) = delete;
-
-  /// The serialized program data. Tensors will point directly into this buffer.
-  FreeableBuffer program_data_;
-
-  /// Used to load segment data. Null if there are no segments.
-  DataLoader *loader_;
-
-  /// The flatbuffer representation of the program. Must not be exposed to
-  /// users.
-  const executorch_flatbuffer::Program *internal_program_;
-
-  /// The offset to the first segment, in bytes. If zero, no segments should
-  /// be present in internal_program_.
-  size_t segment_base_offset_;
-
-  /// Constant segment data.
-  FreeableBuffer constant_segment_data_;
-
-  /// NamedDataMap holding named data from the program.
-  std::optional<internal::PteDataMap> pte_data_map_;
-};
-
-} // namespace ET_RUNTIME_NAMESPACE
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::ET_RUNTIME_NAMESPACE::Program;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/executor/pte_data_map.h b/packages/react-native-executorch/third-party/include/executorch/runtime/executor/pte_data_map.h
deleted file mode 100644
index 2b067123a8..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/executor/pte_data_map.h
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <executorch/runtime/core/data_loader.h>
-#include <executorch/runtime/core/named_data_map.h>
-
-// Forward declare flatbuffer types. This is a public header and must not
-// include the generated flatbuffer header.
-namespace executorch_flatbuffer {
-struct NamedData;
-struct DataSegment;
-} // namespace executorch_flatbuffer
-
-namespace flatbuffers {
-template <typename T> struct Offset;
-} // namespace flatbuffers
-
-// @lint-ignore CLANGTIDY facebook-modularize-issue-check
-#if EXECUTORCH_INTERNAL_FLATBUFFERS == 1
-// TODO(T216992074): update internal flatbuffers (v1.12) to match OSS (v24.3.5).
-namespace flatbuffers {
-template <typename T> class Vector;
-using FlatbufferNamedData =
-    flatbuffers::Vector<flatbuffers::Offset<executorch_flatbuffer::NamedData>>;
-using FlatbufferDataSegment = flatbuffers::Vector<
-    flatbuffers::Offset<executorch_flatbuffer::DataSegment>>;
-} // namespace flatbuffers
-#else
-namespace flatbuffers {
-template <typename T, typename SizeT> class Vector;
-using FlatbufferNamedData =
-    flatbuffers::Vector<flatbuffers::Offset<executorch_flatbuffer::NamedData>,
-                        uint32_t>;
-using FlatbufferDataSegment =
-    flatbuffers::Vector<flatbuffers::Offset<executorch_flatbuffer::DataSegment>,
-                        uint32_t>;
-} // namespace flatbuffers
-#endif
-
-namespace executorch {
-namespace ET_RUNTIME_NAMESPACE {
-namespace internal {
-
-/**
- * A NamedDataMap implementation for Flatbuffer-serialized named data
- * originating from a PTE file.
- */
-class PteDataMap final : public NamedDataMap {
-public:
-  /**
-   * Creates a new DataMap that wraps named_data from the PTE file.
-   *
-   * @param[in] loader The DataLoader that accesses the PTE file.
-   * Note: the loader must outlive the PteDataMap instance.
-   * @param[in] segment_base_offset The offset to the first segment in the PTE
-   * file, in bytes.
-   * @param[in] named_data The named_data from the PTE file. Note: the pointer
-   * passed here must outlive the PteDataMap instance.
-   * @param[in] segments The segments from the PTE file. Note: the pointer
-   * passed here must outlive the PteDataMap instance.
-   */
-  static Result<PteDataMap>
-  create(DataLoader *loader, size_t segment_base_offset,
-         const flatbuffers::FlatbufferNamedData *named_data,
-         const flatbuffers::FlatbufferDataSegment *segments);
-
-  /**
-   * The PteDataMap currently only handles opaque data that does not contain
-   * tensor-specific metadata.
-   */
-  ET_NODISCARD
-  Result<const TensorLayout> get_tensor_layout(
-      ET_UNUSED executorch::aten::string_view key) const override {
-    return Error::NotImplemented;
-  }
-
-  /**
-   * Retrieve read-only data for the specified key.
-   *
-   * @param[in] key The name of the blob to get data on.
-   *
-   * @return error if the key is not present or data cannot be loaded.
-   */
-  ET_NODISCARD
-  Result<FreeableBuffer>
-  get_data(executorch::aten::string_view key) const override;
-
-  /**
-   * The PteDataMap currently does not implement load_into.
-   */
-  ET_NODISCARD Error load_data_into(ET_UNUSED executorch::aten::string_view key,
-                                    ET_UNUSED void *buffer,
-                                    ET_UNUSED size_t size) const override {
-    return Error::NotImplemented;
-  }
-
-  /**
-   * @returns The number of keys in the map.
-   */
-  ET_NODISCARD Result<uint32_t> get_num_keys() const override;
-
-  /**
-   * @returns The key at the specified index, error if index out of bounds.
-   */
-  ET_NODISCARD Result<const char *> get_key(uint32_t index) const override;
-
-  // Moveable, to be compatible with Result.
-  PteDataMap(PteDataMap &&) noexcept = default;
-  ~PteDataMap() override = default;
-
-private:
-  PteDataMap(DataLoader *loader, size_t segment_base_offset,
-             const flatbuffers::FlatbufferNamedData *named_data,
-             const flatbuffers::FlatbufferDataSegment *segments)
-      : loader_(loader), segment_base_offset_(segment_base_offset),
-        named_data_(named_data), segments_(segments) {}
-
-  // Not copyable or assignable.
-  PteDataMap(const PteDataMap &rhs) = delete;
-  PteDataMap &operator=(PteDataMap &&rhs) noexcept = delete;
-  PteDataMap &operator=(const PteDataMap &rhs) = delete;
-
-  // Data loader, used to load segment data.
-  DataLoader *loader_;
-
-  // The offset to the first segment in the PTE file, in bytes.
-  size_t segment_base_offset_;
-
-  // Named data, containing name and segment index.
-  const flatbuffers::FlatbufferNamedData *named_data_;
-
-  // Segments, to retrieve offset and size for the loader.
-  const flatbuffers::FlatbufferDataSegment *segments_;
-};
-
-} // namespace internal
-} // namespace ET_RUNTIME_NAMESPACE
-} // namespace executorch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/executor/tensor_parser.h b/packages/react-native-executorch/third-party/include/executorch/runtime/executor/tensor_parser.h
deleted file mode 100644
index 9d18e7a351..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/executor/tensor_parser.h
+++ /dev/null
@@ -1,161 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#ifdef __GNUC__
-// Disable -Wdeprecated-declarations, as some builds use 'Werror'.
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-#include <executorch/runtime/core/evalue.h>
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <executorch/runtime/executor/memory_manager.h>
-#include <executorch/runtime/executor/program.h>
-#include <executorch/schema/program_generated.h>
-
-namespace executorch {
-namespace ET_RUNTIME_NAMESPACE {
-namespace deserialization {
-
-/// Data structure to hold key and data buffer for external data used
-/// in a method.
-struct NamedData {
-  const char *key;
-  FreeableBuffer buffer;
-};
-
-NamedData *get_data_by_key(const char *key, Span<NamedData> entries);
-
-ET_NODISCARD Result<executorch::aten::Tensor>
-parseTensor(const Program *program, MemoryManager *memory_manager,
-            const executorch_flatbuffer::Tensor *s_tensor,
-            const NamedDataMap *named_data_map = nullptr,
-            Span<NamedData> external_constants = {});
-
-ET_NODISCARD Result<BoxedEvalueList<executorch::aten::Tensor>>
-parseTensorList(const flatbuffers::Vector<int32_t> *tensor_indices,
-                EValue *values, size_t values_len,
-                MemoryManager *memory_manager);
-
-// Checks that the sizes, dim_order and scalar_type match between tensors
-// stored in the PTE and externally.
-ET_NODISCARD Error
-validateTensorLayout(const executorch_flatbuffer::Tensor *s_tensor,
-                     const TensorLayout &expected_layout);
-
-// Deserializes a List of optional type. The code here is the same between all
-// list of optionals: list of optional Tensor, list of optional float etc, so we
-// just use a template to avoid boilerplate.
-template <typename T>
-ET_NODISCARD Result<BoxedEvalueList<std::optional<T>>>
-parseListOptionalType(const flatbuffers::Vector<int32_t> *value_indices,
-                      EValue *values, size_t values_len,
-                      MemoryManager *memory_manager) {
-  auto *evalp_list = memory_manager->method_allocator()->allocateList<EValue *>(
-      value_indices->size());
-  if (evalp_list == nullptr) {
-    return Error::MemoryAllocationFailed;
-  }
-
-  auto *optional_tensor_list =
-      memory_manager->method_allocator()->allocateList<std::optional<T>>(
-          value_indices->size());
-  if (optional_tensor_list == nullptr) {
-    return Error::MemoryAllocationFailed;
-  }
-
-  size_t output_idx = 0;
-  // For each index look up the corresponding EValue (which has been
-  // already allocated) and stick it in the list.
-  for (int32_t index : *value_indices) {
-    // Lists of objects are stored in fbb as list[int] where the ints are
-    // indices into values. Currently serialization is deciding if they want to
-    // put -1 for serialized None type indices, or give us a valid index to a
-    // serialized None. We support either for now.
-    // Placement new as the list elements are not initialized, so calling
-    // copy assignment is not defined if its non trivial.
-    if (index == -1) {
-      new (&optional_tensor_list[output_idx])
-          std::optional<T>(executorch::aten::nullopt);
-      // no value to point to. BoxedEvalueList for optional tensor will convert
-      // this to nullopt.
-      // TODO(T161156879): do something less hacky here.
-      evalp_list[output_idx] = nullptr;
-    } else {
-      ET_CHECK_OR_RETURN_ERROR(
-          index >= 0 && static_cast<size_t>(index) < values_len, InvalidProgram,
-          "Invalid value index %" PRId32 " for ListOptional", index);
-      auto optional_result = values[index].tryToOptional<T>();
-      if (!optional_result.ok()) {
-        return optional_result.error();
-      }
-      new (&optional_tensor_list[output_idx])
-          std::optional<T>(std::move(optional_result.get()));
-      evalp_list[output_idx] = &values[static_cast<size_t>(index)];
-    }
-    output_idx++;
-  }
-  return BoxedEvalueList<std::optional<T>>(evalp_list, optional_tensor_list,
-                                           value_indices->size());
-}
-
-/**
- * Returns the appropriate data pointer for `s_tensor`.
- *
- * Overall, a Tensor is either constant or non-constant, except we differentiate
- * 2 special variants of non-constant Tensor ("input" and control-flow
- * "placeholder") as a special optimization to avoid holding unnecessary
- * AllocationDetails. Thus, s_tensor can be configured as 1 of 3 options:
- * - constant_buffer > 0, allocation_info = Null: Constant Tensor.
- * - constant_buffer = 0, allocation_info = Non Null: Non-constant Tensor.
- * - constant_buffer = 0, allocation_info = Null: Input/placeholder Tensor.
- *
- * @param[in] s_tensor The tensor to find the data pointer for.
- * @param[in] program The Program to use for constant buffer data.
- * @param[in] nbytes The amount of memory to get from the allocator.
- * @param[in] allocator The source of memory for non-constant tensors.
- * @param[in] named_data_map An optional map of {name, blob} used to resolve
- *     data that is mutable and external to the PTE, if any.
- * @param[in] external_constants An optional span containing tensor fqn to
- *     corresponding tensor data. Used to resolve data that is constant and
- *     external to the PTE, if any. Referencing data from external_constants is
- *     safe, as it has the same lifetime as the method.
- *
- * @returns On success, the data pointer to use for the tensor. On failure, a
- *     non-Ok Error.
- */
-ET_NODISCARD Result<void *>
-getTensorDataPtr(const executorch_flatbuffer::Tensor *s_tensor,
-                 const Program *program, size_t nbytes,
-                 HierarchicalAllocator *allocator,
-                 const NamedDataMap *named_data_map = nullptr,
-                 Span<NamedData> external_constants = {});
-
-} // namespace deserialization
-} // namespace ET_RUNTIME_NAMESPACE
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-namespace deserialization {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::ET_RUNTIME_NAMESPACE::deserialization::getTensorDataPtr;
-using ::executorch::ET_RUNTIME_NAMESPACE::deserialization::
-    parseListOptionalType;
-using ::executorch::ET_RUNTIME_NAMESPACE::deserialization::parseTensor;
-using ::executorch::ET_RUNTIME_NAMESPACE::deserialization::parseTensorList;
-} // namespace deserialization
-} // namespace executor
-} // namespace torch
-
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/executor/test/managed_memory_manager.h b/packages/react-native-executorch/third-party/include/executorch/runtime/executor/test/managed_memory_manager.h
deleted file mode 100644
index 196d8f0d78..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/executor/test/managed_memory_manager.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <memory>
-#include <vector>
-
-#include <executorch/runtime/core/hierarchical_allocator.h>
-#include <executorch/runtime/core/memory_allocator.h>
-#include <executorch/runtime/executor/memory_manager.h>
-
-namespace executorch {
-namespace runtime {
-namespace testing {
-
-/**
- * Creates and owns a MemoryManager and the allocators that it points to. Easier
- * to manage than creating the allocators separately.
- */
-class ManagedMemoryManager {
-public:
-  ManagedMemoryManager(size_t planned_memory_bytes,
-                       size_t method_allocator_bytes,
-                       MemoryAllocator *temp_allocator = nullptr)
-      : planned_memory_buffer_(new uint8_t[planned_memory_bytes]),
-        planned_memory_span_(planned_memory_buffer_.get(),
-                             planned_memory_bytes),
-        planned_memory_({&planned_memory_span_, 1}),
-        method_allocator_pool_(new uint8_t[method_allocator_bytes]),
-        method_allocator_(method_allocator_bytes, method_allocator_pool_.get()),
-        memory_manager_(&method_allocator_, &planned_memory_, temp_allocator) {}
-
-  MemoryManager &get() { return memory_manager_; }
-
-private:
-  std::unique_ptr<uint8_t[]> planned_memory_buffer_;
-  Span<uint8_t> planned_memory_span_;
-  HierarchicalAllocator planned_memory_;
-
-  std::unique_ptr<uint8_t[]> method_allocator_pool_;
-  MemoryAllocator method_allocator_;
-
-  MemoryManager memory_manager_;
-};
-
-} // namespace testing
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-namespace testing {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::testing::ManagedMemoryManager;
-} // namespace testing
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/kernel/kernel_includes.h b/packages/react-native-executorch/third-party/include/executorch/runtime/kernel/kernel_includes.h
deleted file mode 100644
index 9d6029a9a0..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/kernel/kernel_includes.h
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @file
- *
- * Common includes used by all kernel implementations.
- */
-
-#pragma once
-
-// This list should be very conservative since most kernel .cpp files will
-// include these and depend on their transitive deps. Only add a header if 99%
-// of kernels would have included it anyway.
-#include <executorch/runtime/core/exec_aten/exec_aten.h> // IWYU pragma: export
-#include <executorch/runtime/core/exec_aten/util/scalar_type_util.h> // IWYU pragma: export
-#include <executorch/runtime/core/exec_aten/util/tensor_util.h> // IWYU pragma: export
-#include <executorch/runtime/kernel/kernel_runtime_context.h> // IWYU pragma: export
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/kernel/kernel_runtime_context.h b/packages/react-native-executorch/third-party/include/executorch/runtime/kernel/kernel_runtime_context.h
deleted file mode 100644
index 6adb7b3d34..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/kernel/kernel_runtime_context.h
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <executorch/runtime/core/error.h>
-#include <executorch/runtime/core/event_tracer_hooks.h>
-#include <executorch/runtime/core/memory_allocator.h>
-#include <executorch/runtime/core/result.h>
-#include <executorch/runtime/platform/compiler.h>
-
-namespace executorch {
-namespace ET_RUNTIME_NAMESPACE {
-
-/**
- * Runtime state and functionality for kernel implementations.
- *
- * NOTE: Will not be passed to operators if running in ATen mode as those
- * operators do not expect to receive a KernelRuntimeContext argument.
- */
-class KernelRuntimeContext {
-public:
-  /**
-   * Construct a new kernel runtime context.
-   *
-   * KernelRuntimeContext does not take ownership
-   * of these pointers, so they must outlive the context instance.
-   *
-   * @param[in] event_tracer The optional EventTracer to use for
-   *     profiling/debugging
-   * @param[in] temp_allocator The optional MemoryAllocator used to allocate
-   *     temporary memory for the kernel. If not provided, an error will be
-   *     returned when calling allocate_temp.
-   */
-  KernelRuntimeContext(EventTracer *event_tracer = nullptr,
-                       MemoryAllocator *temp_allocator = nullptr)
-      : event_tracer_(event_tracer), temp_allocator_(temp_allocator) {}
-  /**
-   * Tells the runtime that the kernel call has failed. Prefer this over
-   * ET_CHECK_*(), which fatally panics the process/system.
-   *
-   * If this is not called, the runtime will treat the kernel call as
-   * successful.
-   *
-   * This unusual error-propagation path is required because kernel signatures
-   * do not have a natural way to return errors directly. They are generally
-   * compatible with core PyTorch ATen kernel signatures, which use exceptions
-   * to report errors. But, ExecuTorch does not use exceptions.
-   */
-  void fail(Error error) { failure_state_ = error; }
-
-  /// Returns the current failure state.
-  ET_NODISCARD Error failure_state() const { return failure_state_; }
-
-  /**
-   * INTERNAL ONLY
-   *
-   * Returns a pointer to an instance of EventTracer to do profiling/debugging
-   * logging inside the codegen layer. This is only for internal usage inside
-   * the codegen layer and users should not be accessing this.
-   */
-  EventTracer *internal_event_tracer() { return event_tracer_; }
-
-  /**
-   * Allocates temporary memory that will be freed when the kernel returns. This
-   * returns a pointer to the allocated memory or an error if the allocation
-   * fails.
-   *
-   * @param[in] size Number of bytes to allocate.
-   * @param[in] alignment Minimum alignment for the returned pointer. Must be a
-   *     power of 2.
-   *
-   * @returns A result object containing either a pointer to the allocated
-   *     memory or an error to indicate failure
-   */
-  Result<void *>
-  allocate_temp(size_t size,
-                size_t alignment = MemoryAllocator::kDefaultAlignment) {
-    ET_CHECK_OR_RETURN_ERROR(temp_allocator_ != nullptr, NotFound,
-                             "No temp allocator provided");
-    void *temp_memory = temp_allocator_->allocate(size, alignment);
-    ET_CHECK_OR_RETURN_ERROR(
-        temp_memory != nullptr, MemoryAllocationFailed,
-        "Failed to allocate temp memory. Bytes requested: %zu", size);
-    return temp_memory;
-  }
-
-  // TODO(T147221312): Add a way to resize a tensor.
-
-private:
-  EventTracer *event_tracer_ = nullptr;
-  MemoryAllocator *temp_allocator_ = nullptr;
-  Error failure_state_ = Error::Ok;
-};
-
-} // namespace ET_RUNTIME_NAMESPACE
-} // namespace executorch
-
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-namespace torch {
-namespace executor {
-/// DEPRECATED: Use ::executorch::runtime::KernelRuntimeContext instead.
-using ::executorch::ET_RUNTIME_NAMESPACE::KernelRuntimeContext;
-/// DEPRECATED: Use ::executorch::runtime::KernelRuntimeContext instead.
-using RuntimeContext = ::executorch::ET_RUNTIME_NAMESPACE::KernelRuntimeContext;
-} // namespace executor
-} // namespace torch
-namespace executorch {
-namespace aten {
-/// DEPRECATED: Use ::executorch::runtime::KernelRuntimeContext instead.
-using RuntimeContext = ::executorch::ET_RUNTIME_NAMESPACE::KernelRuntimeContext;
-} // namespace aten
-} // namespace executorch
-// DEPRECATED: The executorch::aten:: namespace is deprecated. Use
-// executorch::aten:: instead.
-namespace exec_aten = ::executorch::aten;
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/kernel/operator_registry.h b/packages/react-native-executorch/third-party/include/executorch/runtime/kernel/operator_registry.h
deleted file mode 100644
index bc6c6729d5..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/kernel/operator_registry.h
+++ /dev/null
@@ -1,290 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <cstring>
-
-#include <executorch/runtime/core/array_ref.h>
-#include <executorch/runtime/core/error.h>
-#include <executorch/runtime/core/evalue.h>
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <executorch/runtime/core/result.h>
-#include <executorch/runtime/core/span.h>
-#include <executorch/runtime/platform/compiler.h>
-#include <executorch/runtime/platform/platform.h>
-
-// Debug switch for operator registry
-#if defined(ET_OP_REGISTRY_DEBUG)
-#include <ostream>
-#endif
-
-#define ET_LOG_KERNEL_KEY(k)                                                   \
-  ET_LOG(Info, "key: %s, is_fallback: %s", k.data(),                           \
-         k.is_fallback() ? "true" : "false");
-#define ET_LOG_TENSOR_META(meta_list)                                          \
-  for (const auto &meta : meta_list) {                                         \
-    ET_LOG(Info, "dtype: %d | dim order: [", int(meta.dtype_));                \
-    for (size_t i = 0; i < meta.dim_order_.size(); i++) {                      \
-      ET_LOG(Info, "%d,", static_cast<int32_t>(meta.dim_order_[i]));           \
-    }                                                                          \
-    ET_LOG(Info, "]");                                                         \
-  }
-
-namespace executorch {
-namespace ET_RUNTIME_NAMESPACE {
-
-class KernelRuntimeContext; // Forward declaration
-using OpFunction = void (*)(KernelRuntimeContext &, Span<EValue *>);
-
-/**
- * Dtype and dim order metadata for a Tensor argument to an operator.
- * Used by the Executor to hold the tensor metadata info and retrieve kernel.
- */
-struct TensorMeta {
-  executorch::aten::ScalarType dtype_;
-  Span<executorch::aten::DimOrderType> dim_order_;
-
-  TensorMeta() = default;
-  TensorMeta(executorch::aten::ScalarType dtype,
-             Span<executorch::aten::DimOrderType> order)
-      : dtype_(dtype), dim_order_(order) {}
-
-  bool operator==(const TensorMeta &other) const { return this->equals(other); }
-
-  bool operator!=(const TensorMeta &other) const {
-    return !this->equals(other);
-  }
-
-  bool equals(const TensorMeta &other) const {
-    if (dtype_ != other.dtype_) {
-      return false;
-    }
-    if (dim_order_.size() != other.dim_order_.size()) {
-      return false;
-    }
-    for (size_t i = 0; i < dim_order_.size(); i++) {
-      if (dim_order_[i] != other.dim_order_[i]) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-#if defined(ET_OP_REGISTRY_DEBUG)
-  friend std::ostream &operator<<(std::ostream &os, const TensorMeta &meta) {
-    os << "dtype: " << int(meta.dtype_) << " | dim order: [";
-    for (int i = 0; i < meta.dim_order_.size(); i++) {
-      os << static_cast<int32_t>(meta.dim_order_[i]) << ", ";
-    }
-    os << "]";
-    return os;
-  }
-#endif
-};
-
-/**
- * Describes which dtype & dim order specialized kernel to be bound to an
- * operator.
- *
- * Kernel key data is a string with the format:
- *
- *     "v<version>/<tensor_meta>|<tensor_meta>..."
- *
- * The version is v1 for now. If the kernel key format changes, update the
- * version to avoid breaking pre-existing kernel keys.
- *
- * Each tensor_meta has the following format: "<dtype>;<dim_order,...>"
- *
- * Example kernel key data: "v1/7;0,1,2,3|1;0,1,2,3,4,5,6,7"
- *
- * This has two tensors: the first with dtype=7 and dim order 0,1,2,3, and the
- * second with dtype=1 and dim order 0,1,2,3,4,5,6,7.
- *
- * IMPORTANT:
- * Users should not construct a kernel key manually. Instead, it should be
- * generated from kernel yaml.
- */
-struct KernelKey {
-public:
-  /**
-   * Creates a fallback (non-specialized) kernel key: this kernel can be used
-   * for all input tensor dtypes and dim orders if the specialized kernel is not
-   * registered.
-   */
-  constexpr KernelKey() = default;
-
-  /**
-   * Creates a specialized (non-fallback) kernel key that matches a specific
-   * set of input tensor dtypes and dim orders. See the class comment for the
-   * expected format of `kernel_key_data`.
-   */
-  /* implicit */ constexpr KernelKey(const char *kernel_key_data)
-      : kernel_key_data_(kernel_key_data) {}
-
-  bool operator==(const KernelKey &other) const { return this->equals(other); }
-
-  bool operator!=(const KernelKey &other) const { return !this->equals(other); }
-
-  bool equals(const KernelKey &other) const {
-    if (is_fallback() != other.is_fallback()) {
-      return false;
-    }
-    if (is_fallback()) {
-      return true;
-    }
-    return strcmp(kernel_key_data_, other.kernel_key_data_) == 0;
-  }
-
-  bool is_fallback() const { return kernel_key_data_ == nullptr; }
-
-  const char *data() const { return kernel_key_data_; }
-
-#if defined(ET_OP_REGISTRY_DEBUG)
-  friend std::ostream &operator<<(std::ostream &os, const KernelKey &key) {
-    os << key.kernel_key_data_ << std::endl;
-    return os;
-  }
-#endif
-
-private:
-  const char *kernel_key_data_ = nullptr;
-};
-
-/**
- * Struct that bundles a kernel key, a function and an op name together. An
- * `Operator` may have more than one `Kernel` (maximum kMaxNumOfKernelPerOp) and
- * they should have the same op name and different kernel key. A "fallback"
- * kernel may or may not live in an `Operator`.
- */
-struct Kernel {
-  const char *name_;
-  // String representation of kernel key, with the same format as
-  // KernelKey.to_string_representation()
-  // Data is not owned by the Kernel struct.
-  KernelKey kernel_key_;
-  OpFunction op_;
-  /**
-   * We are doing a copy of the string pointer instead of duplicating the string
-   * itself, we require the lifetime of the operator name to be at least as long
-   * as the operator registry.
-   */
-  constexpr explicit Kernel(const char *name, OpFunction func)
-      : name_(name), op_(func) {}
-
-  constexpr explicit Kernel(const char *name, KernelKey key, OpFunction func)
-      : name_(name), kernel_key_(key), op_(func) {}
-
-  constexpr Kernel() : name_(nullptr), op_(nullptr) {}
-};
-
-namespace internal {
-
-/**
- * A make_kernel_key_string buffer size that is large enough to hold a kernel
- * key string with 16 tensors of 16 dimensions, plus the trailing NUL byte.
- */
-constexpr size_t kKernelKeyBufSize = 659;
-
-/**
- * Given the list of input tensor dtypes + dim orders, writes the kernel key
- * string into the buffer. Returns an error if the buffer is too small or if the
- * tensors cannot be represented as a valid key string.
- */
-Error make_kernel_key_string(Span<const TensorMeta> key, char *buf,
-                             size_t buf_size);
-
-} // namespace internal
-
-/**
- * Checks whether an operator exists with a given name and TensorMeta list. When
- * TensorMeta is empty, it means this op does not have specialized kernels, so
- * it checks whether it has any fallback kernels.
- */
-bool registry_has_op_function(const char *name,
-                              Span<const TensorMeta> meta_list = {});
-
-/**
- * Returns the operator with a given name and TensorMeta list, if present.
- */
-::executorch::runtime::Result<OpFunction>
-get_op_function_from_registry(const char *name,
-                              Span<const TensorMeta> meta_list = {});
-
-/**
- * Returns the operator with a given name and TensorMeta list from the provided
- * kernel list instead of the global registry.
- */
-::executorch::runtime::Result<OpFunction>
-get_op_function_from_registry(const char *name,
-                              Span<const TensorMeta> meta_list,
-                              Span<const Kernel> kernel_list);
-
-/**
- * Returns all registered kernels.
- */
-Span<const Kernel> get_registered_kernels();
-
-/**
- * Registers the provided kernels.
- *
- * @param[in] kernels Kernel objects to register.
- * @retval Error::Ok always. Panics on error. This function needs to return a
- *     non-void type to run at static initialization time.
- */
-ET_NODISCARD Error register_kernels(const Span<const Kernel>);
-
-/**
- * Registers a single kernel.
- *
- * @param[in] kernel Kernel object to register.
- * @retval Error::Ok always. Panics on error. This function needs to return a
- *     non-void type to run at static initialization time.
- */
-ET_NODISCARD inline Error register_kernel(const Kernel &kernel) {
-  return register_kernels({&kernel, 1});
-};
-
-} // namespace ET_RUNTIME_NAMESPACE
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::ET_RUNTIME_NAMESPACE::Kernel;
-using ::executorch::ET_RUNTIME_NAMESPACE::KernelKey;
-using ::executorch::ET_RUNTIME_NAMESPACE::KernelRuntimeContext;
-using ::executorch::ET_RUNTIME_NAMESPACE::OpFunction;
-using ::executorch::ET_RUNTIME_NAMESPACE::TensorMeta;
-using KernelRuntimeContext =
-    ::executorch::ET_RUNTIME_NAMESPACE::KernelRuntimeContext;
-
-inline ::executorch::runtime::Error register_kernels(ArrayRef<Kernel> kernels) {
-  return ::executorch::ET_RUNTIME_NAMESPACE::register_kernels(
-      {kernels.data(), kernels.size()});
-}
-inline OpFunction getOpsFn(const char *name,
-                           ArrayRef<TensorMeta> meta_list = {}) {
-  auto result =
-      ::executorch::ET_RUNTIME_NAMESPACE::get_op_function_from_registry(
-          name, {meta_list.data(), meta_list.size()});
-  ET_CHECK(result.ok()); // get_op_function_from_registry() logs details.
-  return *result;
-}
-inline bool hasOpsFn(const char *name, ArrayRef<TensorMeta> meta_list = {}) {
-  return ::executorch::ET_RUNTIME_NAMESPACE::registry_has_op_function(
-      name, {meta_list.data(), meta_list.size()});
-}
-inline ArrayRef<Kernel> get_kernels() {
-  Span<const Kernel> kernels =
-      ::executorch::ET_RUNTIME_NAMESPACE::get_registered_kernels();
-  return ArrayRef<Kernel>(kernels.data(), kernels.size());
-}
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/kernel/test/test_util.h b/packages/react-native-executorch/third-party/include/executorch/runtime/kernel/test/test_util.h
deleted file mode 100644
index 424d157a87..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/kernel/test/test_util.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <vector>
-
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <executorch/runtime/kernel/operator_registry.h>
-
-namespace executorch {
-namespace runtime {
-
-namespace testing {
-
-inline Error make_kernel_key(
-    const std::vector<std::pair<executorch::aten::ScalarType,
-                                std::vector<executorch::aten::DimOrderType>>>
-        &tensors,
-    char *buf, size_t buf_size) {
-  std::vector<TensorMeta> meta;
-  for (auto &t : tensors) {
-    Span<executorch::aten::DimOrderType> dim_order(
-        const_cast<unsigned char *>(t.second.data()), t.second.size());
-    meta.emplace_back(t.first, dim_order);
-  }
-  Span<const TensorMeta> metadata(meta.data(), meta.size());
-  return internal::make_kernel_key_string(metadata, buf, buf_size);
-}
-
-} // namespace testing
-
-} // namespace runtime
-} // namespace executorch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/kernel/thread_parallel_interface.h b/packages/react-native-executorch/third-party/include/executorch/runtime/kernel/thread_parallel_interface.h
deleted file mode 100644
index dfbec53798..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/kernel/thread_parallel_interface.h
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <cstdint>
-#include <functional>
-
-#include <c10/util/irange.h>
-#include <executorch/runtime/core/error.h>
-#include <executorch/runtime/core/function_ref.h>
-#include <executorch/runtime/platform/assert.h>
-
-namespace executorch {
-namespace extension {
-namespace internal {
-template <typename Func>
-inline bool parallel_for_no_threadpool(const int64_t begin, const int64_t end,
-                                       const int64_t grain_size,
-                                       const Func &f) {
-  ET_CHECK_OR_RETURN_FALSE(begin >= 0 && end >= 0 && end >= begin,
-                           "begin = %" PRId64 ", end = %" PRId64, begin, end);
-  ET_CHECK_OR_RETURN_FALSE(grain_size > 0, "grain_size = %" PRId64, grain_size);
-#ifndef NDEBUG
-  // Go backwards through the range elementwise to catch code that
-  // assumes parallel_for is in order like a regular for loop.
-  for (const auto i : c10::irange(begin, end)) {
-    const auto offset = i - begin;
-    const auto idx = end - offset - 1;
-    f(idx, idx + 1);
-  }
-#else // NDEBUG
-  f(begin, end);
-#endif
-  return true;
-}
-
-// Match GRAIN_SIZE from PyTorch core.
-// https://github.com/pytorch/pytorch/blob/main/aten/src/ATen/TensorIterator.h#L78
-constexpr int64_t GRAIN_SIZE = 32768;
-} // namespace internal
-
-#ifdef ET_USE_THREADPOOL
-/**
- * A helper to run a function in parallel.
- *
- * begin, end: describe the extent of the workitems via first and last workitem
- * to be processed
- * grain_size: number of workitems processed by user callback which is
- * described below
- * f: user function applied in parallel to the chunks, signature:
- *   void f(int64_t begin, int64_t end)
- * Returns true if all work items are processed successfully, false otherwise
- *
- * Warning: parallel_for does NOT copy thread local states from the current
- * thread to the worker threads. Users need to protect the access to captured
- * data if they mutate them in f.
- */
-bool parallel_for(const int64_t begin, const int64_t end,
-                  const int64_t grain_size,
-                  runtime::FunctionRef<void(int64_t, int64_t)> f);
-
-int64_t get_thread_num();
-
-void set_thread_num(int64_t thread_num);
-#else  // ET_USE_THREADPOOL
-template <typename Func>
-bool parallel_for(const int64_t begin, const int64_t end,
-                  const int64_t grain_size, const Func &func) {
-  return internal::parallel_for_no_threadpool(begin, end, grain_size, func);
-}
-
-inline int64_t get_thread_num() { return 0; }
-
-inline void set_thread_num(int64_t thread_num) {
-  ET_DCHECK_MSG(false, "cannot set_thread_num without threading support!");
-}
-#endif // ET_USE_THREADPOOL
-} // namespace extension
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::extension::get_thread_num;
-using ::executorch::extension::parallel_for;
-using ::executorch::extension::set_thread_num;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/abort.h b/packages/react-native-executorch/third-party/include/executorch/runtime/platform/abort.h
deleted file mode 100644
index ae1a761aa7..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/abort.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @file
- * ExecuTorch global abort wrapper function.
- */
-
-#pragma once
-
-#include <executorch/runtime/platform/compiler.h>
-
-namespace executorch {
-namespace runtime {
-
-/**
- * Trigger the ExecuTorch global runtime to immediately exit without cleaning
- * up, and set an abnormal exit status (platform-defined).
- */
-ET_NORETURN void runtime_abort();
-
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::runtime_abort;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/assert.h b/packages/react-native-executorch/third-party/include/executorch/runtime/platform/assert.h
deleted file mode 100644
index 14ec270699..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/assert.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <executorch/runtime/platform/abort.h>
-#include <executorch/runtime/platform/compiler.h>
-#include <executorch/runtime/platform/log.h>
-
-/**
- * Assertion failure message emit method.
- *
- * @param[in] _format Printf-style message format string.
- * @param[in] ... Format string arguments.
- */
-#define ET_ASSERT_MESSAGE_EMIT(_format, ...)                                   \
-  ET_LOG(Fatal, "In function %s(), assert failed" _format, ET_FUNCTION,        \
-         ##__VA_ARGS__)
-
-/**
- * Abort the runtime if the condition is not true.
- * This check will be performed even in release builds.
- *
- * @param[in] _cond Condition asserted as true.
- * @param[in] _format Printf-style message format string.
- * @param[in] ... Format string arguments.
- */
-#define ET_CHECK_MSG(_cond, _format, ...)                                      \
-  do {                                                                         \
-    if ET_UNLIKELY (!(_cond)) {                                                \
-      ET_ASSERT_MESSAGE_EMIT(" (%s): " _format, #_cond, ##__VA_ARGS__);        \
-      ::executorch::runtime::runtime_abort();                                  \
-    }                                                                          \
-  } while (0)
-
-/**
- * Abort the runtime if the condition is not true.
- * This check will be performed even in release builds.
- *
- * @param[in] _cond Condition asserted as true.
- */
-#define ET_CHECK(_cond)                                                        \
-  do {                                                                         \
-    if ET_UNLIKELY (!(_cond)) {                                                \
-      ET_ASSERT_MESSAGE_EMIT(": %s", #_cond);                                  \
-      ::executorch::runtime::runtime_abort();                                  \
-    }                                                                          \
-  } while (0)
-
-#ifdef NDEBUG
-
-/**
- * Abort the runtime if the condition is not true.
- * This check will be performed in debug builds, but not release builds.
- *
- * @param[in] _cond Condition asserted as true.
- * @param[in] _format Printf-style message format string.
- * @param[in] ... Format string arguments.
- */
-#define ET_DCHECK_MSG(_cond, _format, ...) ((void)0)
-
-/**
- * Abort the runtime if the condition is not true.
- * This check will be performed in debug builds, but not release builds.
- *
- * @param[in] _cond Condition asserted as true.
- */
-#define ET_DCHECK(_cond) ((void)0)
-#define ET_DEBUG_ONLY [[maybe_unused]]
-
-#else // NDEBUG
-
-/**
- * Abort the runtime if the condition is not true.
- * This check will be performed in debug builds, but not release builds.
- *
- * @param[in] _cond Condition asserted as true.
- * @param[in] _format Printf-style message format string.
- * @param[in] ... Format string arguments.
- */
-#define ET_DCHECK_MSG(_cond, _format, ...)                                     \
-  ET_CHECK_MSG(_cond, _format, ##__VA_ARGS__)
-
-/**
- * Abort the runtime if the condition is not true.
- * This check will be performed in debug builds, but not release builds.
- *
- * @param[in] _cond Condition asserted as true.
- */
-#define ET_DCHECK(_cond) ET_CHECK(_cond)
-#define ET_DEBUG_ONLY
-
-#endif // NDEBUG
-
-/**
- * Assert that this code location is unreachable during execution.
- */
-#define ET_ASSERT_UNREACHABLE()                                                \
-  do {                                                                         \
-    ET_CHECK_MSG(false, "Execution should not reach this point");              \
-    ET_UNREACHABLE();                                                          \
-  } while (0)
-
-/**
- * Assert that this code location is unreachable during execution.
- *
- * @param[in] _message Message on how to avoid this assertion error.
- */
-#define ET_ASSERT_UNREACHABLE_MSG(_format, ...)                                \
-  do {                                                                         \
-    ET_CHECK_MSG(false, "Execution should not reach this point. " _format,     \
-                 ##__VA_ARGS__);                                               \
-    ET_UNREACHABLE();                                                          \
-  } while (0)
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/clock.h b/packages/react-native-executorch/third-party/include/executorch/runtime/platform/clock.h
deleted file mode 100644
index 36c25d90c4..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/clock.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @file
- * Clock and timing related methods.
- */
-
-#pragma once
-
-#include <executorch/runtime/platform/platform.h>
-
-namespace executorch {
-namespace runtime {
-
-/**
- * Convert an interval from units of system ticks to nanoseconds.
- * The conversion ratio is platform-dependent, and thus depends on
- * the platform implementation of et_pal_ticks_to_ns_multiplier().
- *
- * @param[in] ticks The interval length in system ticks.
- * @retval The interval length in nanoseconds.
- */
-inline uint64_t ticks_to_ns(et_timestamp_t ticks) {
-  et_tick_ratio_t ratio = et_pal_ticks_to_ns_multiplier();
-  return static_cast<uint64_t>(ticks) * ratio.numerator / ratio.denominator;
-}
-
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::ticks_to_ns;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/compat_unistd.h b/packages/react-native-executorch/third-party/include/executorch/runtime/platform/compat_unistd.h
deleted file mode 100644
index c7bd513d5d..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/compat_unistd.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @file
- * unistd.h related macros for POSIX/Windows compatibility.
- */
-#pragma once
-
-#if defined(_WIN32) && !defined(_WIN64)
-#error                                                                         \
-    "You're trying to build ExecuTorch with a too old version of Windows. We need Windows 64-bit."
-#endif
-
-#if !defined(_WIN64)
-#include <unistd.h>
-#else
-#include <io.h>
-#define O_RDONLY _O_RDONLY
-#define open _open
-#define close _close
-#define read _read
-#define write _write
-#define stat _stat64
-#define fstat _fstat64
-#define off_t _off_t
-#define lseek _lseeki64
-
-#include <executorch/runtime/platform/compiler.h> // For ssize_t.
-#include <windows.h>
-// To avoid conflicts with std::numeric_limits<int32_t>::max() in
-// file_data_loader.cpp.
-#undef max
-
-inline ssize_t pread(int fd, void *buf, size_t nbytes, size_t offset) {
-  OVERLAPPED overlapped; /* The offset for ReadFile. */
-  memset(&overlapped, 0, sizeof(overlapped));
-  overlapped.Offset = offset;
-  overlapped.OffsetHigh = offset >> 32;
-
-  BOOL result;      /* The result of ReadFile. */
-  DWORD bytes_read; /* The number of bytes read. */
-  HANDLE file = (HANDLE)_get_osfhandle(fd);
-
-  result = ReadFile(file, buf, nbytes, &bytes_read, &overlapped);
-  DWORD error = GetLastError();
-  if (!result) {
-    if (error == ERROR_IO_PENDING) {
-      result = GetOverlappedResult(file, &overlapped, &bytes_read, TRUE);
-      if (!result) {
-        error = GetLastError();
-      }
-    }
-  }
-  if (!result) {
-    // Translate error into errno.
-    switch (error) {
-    case ERROR_HANDLE_EOF:
-      errno = 0;
-      break;
-    default:
-      errno = EIO;
-      break;
-    }
-    return -1;
-  }
-  return bytes_read;
-}
-
-#endif // !defined(_WIN64)
\ No newline at end of file
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/compiler.h b/packages/react-native-executorch/third-party/include/executorch/runtime/platform/compiler.h
deleted file mode 100644
index 3b799ba48b..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/compiler.h
+++ /dev/null
@@ -1,214 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @file
- * Compiler utility macros.
- */
-
-#pragma once
-
-/*
- * Compiler support checks. Follows the logic used by pytorch/c10/util/C++17.h
- * but may support older versions.
- */
-
-// https://gcc.gnu.org/projects/cxx-status.html#cxx17
-#if !defined(__clang__) && !defined(_MSC_VER) && defined(__GNUC__) &&          \
-    __GNUC__ < 7
-#error                                                                         \
-    "You're trying to build ExecuTorch with a too old version of GCC. We need GCC 7 or later."
-#endif
-
-// https://clang.llvm.org/cxx_status.html#cxx17
-#if defined(__clang__) && __clang_major__ < 5
-#error                                                                         \
-    "You're trying to build ExecuTorch with a too old version of Clang. We need Clang 5 or later."
-#endif
-
-#if (defined(_MSC_VER) && (!defined(_MSVC_LANG) || _MSVC_LANG < 201703L)) ||   \
-    (!defined(_MSC_VER) && __cplusplus < 201703L)
-#error "You need C++17 to compile ExecuTorch"
-#endif
-
-#if defined(_MSC_VER) && (defined(min) || defined(max))
-#error                                                                         \
-    "Macro clash with min and max -- define NOMINMAX when compiling your program on Windows"
-#endif
-
-/*
- * Define annotations aliasing C++ declaration attributes.
- * See all C++ declaration attributes here:
- *   https://en.cppreference.com/w/cpp/language/attributes
- *
- * Note that ExecuTorch supports a lower C++ standard version than all standard
- * attributes. Therefore, some annotations are defined using their Clang/GNU
- * counterparts.
- *
- * GNU attribute definitions:
- *   https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html
- */
-
-#define ET_NORETURN [[noreturn]]
-
-// Inline/NoInline
-#if defined(_MSC_VER)
-#define ET_NOINLINE __declspec(noinline)
-#define ET_INLINE __forceinline
-#else
-#define ET_NOINLINE __attribute__((noinline))
-#define ET_INLINE __attribute__((always_inline)) inline
-#endif
-
-// Restrict
-#if defined(_MSC_VER)
-#define ET_RESTRICT __restrict
-#else
-#define ET_RESTRICT __restrict__
-#endif
-
-#if defined(__GNUC__)
-
-#define ET_UNREACHABLE() __builtin_unreachable()
-
-#elif defined(_MSC_VER)
-
-#define ET_UNREACHABLE() __assume(0)
-
-#else // defined(__GNUC__)
-
-#define ET_UNREACHABLE()                                                       \
-  while (1)                                                                    \
-    ;
-
-#endif // defined(__GNUC__)
-
-#define ET_DEPRECATED [[deprecated]]
-#define ET_EXPERIMENTAL                                                        \
-  [[deprecated("This API is experimental and may change without notice.")]]
-#define ET_FALLTHROUGH [[fallthrough]]
-#define ET_NODISCARD [[nodiscard]]
-#define ET_UNUSED [[maybe_unused]]
-
-// UNLIKELY Macro
-// example
-// if ET_UNLIKELY(a > 10 && b < 5) {
-//   do something
-// }
-#if (__cplusplus) >= 202002L
-
-#define ET_LIKELY(expr) (expr) [[likely]]
-#define ET_UNLIKELY(expr) (expr) [[unlikely]]
-
-#else
-
-#define ET_LIKELY(expr) (expr)
-#define ET_UNLIKELY(expr) (expr)
-
-#endif // (__cplusplus) >= 202002L
-
-/// Define a C symbol with weak linkage.
-#ifdef _MSC_VER
-// There currently doesn't seem to be a great way to do this in Windows and
-// given that weak linkage is not really critical on Windows, we'll just leave
-// it as a stub.
-#define ET_WEAK
-#else
-#define ET_WEAK __attribute__((weak))
-#endif
-
-/**
- * Annotation marking a function as printf-like, providing compiler support
- * for format string argument checking.
- */
-#ifdef _MSC_VER
-#include <sal.h>
-#define ET_PRINTFLIKE(_string_index, _va_index) _Printf_format_string_
-#else
-#define ET_PRINTFLIKE(_string_index, _va_index)                                \
-  __attribute__((format(printf, _string_index, _va_index)))
-#endif
-
-#ifndef __has_builtin
-#define __has_builtin(x) (0)
-#endif
-
-#if __has_builtin(__builtin_strrchr)
-/// Name of the source file without a directory string.
-#define ET_SHORT_FILENAME (__builtin_strrchr("/" __FILE__, '/') + 1)
-#else
-#define ET_SHORT_FILENAME __FILE__
-#endif
-
-#if __has_builtin(__builtin_LINE)
-/// Current line as an integer.
-#define ET_LINE __builtin_LINE()
-#else
-#define ET_LINE __LINE__
-#endif // __has_builtin(__builtin_LINE)
-
-#if __has_builtin(__builtin_FUNCTION)
-/// Name of the current function as a const char[].
-#define ET_FUNCTION __builtin_FUNCTION()
-#else
-#define ET_FUNCTION __FUNCTION__
-#endif // __has_builtin(__builtin_FUNCTION)
-
-// As of G3 RJ-2024.3 toolchain, zu format specifier is not supported for Xtensa
-#if defined(__XTENSA__)
-#define ET_PRIsize_t "u"
-#define ET_PRIssize_t "d"
-#else
-#define ET_PRIsize_t "zu"
-#define ET_PRIssize_t "zd"
-#endif
-
-// Whether the compiler supports GNU statement expressions.
-// https://gcc.gnu.org/onlinedocs/gcc/Statement-Exprs.html
-#ifndef ET_HAVE_GNU_STATEMENT_EXPRESSIONS
-#if (defined(__GNUC__) && __GNUC__ >= 3) || defined(__clang__)
-#define ET_HAVE_GNU_STATEMENT_EXPRESSIONS 1
-#else
-#define ET_HAVE_GNU_STATEMENT_EXPRESSIONS 0
-#endif
-#endif // ifndef
-
-// Define size_t and ssize_t.
-#ifndef _MSC_VER
-#include <sys/types.h>
-#else
-#include <stddef.h>
-using ssize_t = ptrdiff_t;
-#endif
-
-#ifdef __EXCEPTIONS
-#define ET_HAS_EXCEPTIONS 1
-#elif defined(_MSC_VER) && defined(_HAS_EXCEPTIONS) && _HAS_EXCEPTIONS
-#define ET_HAS_EXCEPTIONS 1
-#else
-#define ET_HAS_EXCEPTIONS 0
-#endif
-
-// DEPRECATED: Use the non-underscore-prefixed versions instead.
-// TODO(T199005537): Remove these once all users have stopped using them.
-#define __ET_DEPRECATED ET_DEPRECATED
-#define __ET_FALLTHROUGH ET_FALLTHROUGH
-#define __ET_FUNCTION ET_FUNCTION
-#define __ET_HAVE_GNU_STATEMENT_EXPRESSIONS ET_HAVE_GNU_STATEMENT_EXPRESSIONS
-#define __ET_INLINE ET_INLINE
-#define __ET_LIKELY ET_LIKELY
-#define __ET_LINE ET_LINE
-#define __ET_NODISCARD ET_NODISCARD
-#define __ET_NOINLINE ET_NOINLINE
-#define __ET_NORETURN ET_NORETURN
-#define __ET_PRINTFLIKE ET_PRINTFLIKE
-#define __ET_SHORT_FILENAME ET_SHORT_FILENAME
-#define __ET_UNLIKELY ET_UNLIKELY
-#define __ET_UNREACHABLE ET_UNREACHABLE
-#define __ET_UNUSED ET_UNUSED
-#define __ET_WEAK ET_WEAK
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/log.h b/packages/react-native-executorch/third-party/include/executorch/runtime/platform/log.h
deleted file mode 100644
index 0d7c4c88b8..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/log.h
+++ /dev/null
@@ -1,199 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @file
- * ExecuTorch logging API.
- */
-
-#pragma once
-
-#include <cstdarg>
-#include <cstddef>
-#include <cstdlib>
-
-#include <executorch/runtime/platform/compiler.h>
-#include <executorch/runtime/platform/types.h>
-
-// Set minimum log severity if compiler option is not provided.
-#ifndef ET_MIN_LOG_LEVEL
-#define ET_MIN_LOG_LEVEL Info
-#endif // !defined(ET_MIN_LOG_LEVEL)
-
-/*
- * Enable logging by default if compiler option is not provided.
- * This should facilitate less confusion for those developing ExecuTorch.
- */
-#ifndef ET_LOG_ENABLED
-#define ET_LOG_ENABLED 1
-#endif // !defined(ET_LOG_ENABLED)
-
-// Even though it is supposed to be "portable" some toolchains
-// do not define, so providing a definition here
-#ifndef PRIu64
-#define PRIu64 "llu"
-#endif
-#ifndef PRId64
-#define PRId64 "lld"
-#endif
-
-namespace executorch {
-namespace runtime {
-
-/**
- * Severity level of a log message. Must be ordered from lowest to highest
- * severity.
- */
-enum class LogLevel : uint8_t {
-  /**
-   * Log messages provided for highly granular debuggability.
-   *
-   * Log messages using this severity are unlikely to be compiled by default
-   * into most debug builds.
-   */
-  Debug,
-
-  /**
-   * Log messages providing information about the state of the system
-   * for debuggability.
-   */
-  Info,
-
-  /**
-   * Log messages about errors within ExecuTorch during runtime.
-   */
-  Error,
-
-  /**
-   * Log messages that precede a fatal error. However, logging at this level
-   * does not perform the actual abort, something else needs to.
-   */
-  Fatal,
-
-  /**
-   * Number of supported log levels, with values in [0, NumLevels).
-   */
-  NumLevels,
-};
-
-namespace internal {
-
-/**
- * Get the current timestamp to construct a log event.
- *
- * @retval Monotonically non-decreasing timestamp in system ticks.
- */
-et_timestamp_t get_log_timestamp();
-
-/**
- * Log a string message.
- *
- * Note: This is an internal function. Use the `ET_LOG` macro instead.
- *
- * @param[in] level Log severity level.
- * @param[in] timestamp Timestamp (in system ticks) of the log event.
- * @param[in] filename Name of the source file creating the log event.
- * @param[in] function Name of the function creating the log event.
- * @param[in] line Source file line of the caller.
- * @param[in] format Format string.
- * @param[in] args Variable argument list.
- */
-ET_PRINTFLIKE(6, 0)
-void vlogf(LogLevel level, et_timestamp_t timestamp, const char *filename,
-           const char *function, size_t line, const char *format, va_list args);
-
-/**
- * Log a string message.
- *
- * Note: This is an internal function. Use the `ET_LOG` macro instead.
- *
- * @param[in] level Log severity level.
- * @param[in] timestamp Timestamp (in system ticks) of the log event.
- * @param[in] filename Name of the source file creating the log event.
- * @param[in] function Name of the function creating the log event.
- * @param[in] line Source file line of the caller.
- * @param[in] format Format string.
- */
-ET_PRINTFLIKE(6, 7)
-inline void logf(LogLevel level, et_timestamp_t timestamp, const char *filename,
-                 const char *function, size_t line, const char *format, ...) {
-#if ET_LOG_ENABLED
-  va_list args;
-  va_start(args, format);
-  internal::vlogf(level, timestamp, filename, function, line, format, args);
-  va_end(args);
-#endif // ET_LOG_ENABLED
-}
-
-} // namespace internal
-
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::LogLevel;
-} // namespace executor
-} // namespace torch
-
-#if ET_LOG_ENABLED
-
-/**
- * Log a message at the given log severity level.
- *
- * @param[in] _level Log severity level.
- * @param[in] _format Log message format string.
- */
-#define ET_LOG(_level, _format, ...)                                           \
-  do {                                                                         \
-    const auto _log_level = ::executorch::runtime::LogLevel::_level;           \
-    if (static_cast<uint32_t>(_log_level) >=                                   \
-        static_cast<uint32_t>(                                                 \
-            ::executorch::runtime::LogLevel::ET_MIN_LOG_LEVEL)) {              \
-      const auto _timestamp =                                                  \
-          ::executorch::runtime::internal::get_log_timestamp();                \
-      ::executorch::runtime::internal::logf(_log_level, _timestamp,            \
-                                            ET_SHORT_FILENAME, ET_FUNCTION,    \
-                                            ET_LINE, _format, ##__VA_ARGS__);  \
-    }                                                                          \
-  } while (0)
-
-/**
- * Check a condition and log an error message if the condition is false.
- *
- * @param[in] _condition The condition to check.
- * @param[in] _format Log message format string.
- */
-#define ET_CHECK_OR_LOG_ERROR(_condition, _format, ...)                        \
-  do {                                                                         \
-    if (!(_condition)) {                                                       \
-      ET_LOG(Error, _format, ##__VA_ARGS__);                                   \
-    }                                                                          \
-  } while (0)
-
-#else // ET_LOG_ENABLED
-
-/**
- * Log a message at the given log severity level.
- *
- * @param[in] _level Log severity level.
- * @param[in] _format Log message format string.
- */
-#define ET_LOG(_level, _format, ...) ((void)0)
-
-/**
- * Check a condition and log an error message if the condition is false.
- *
- * @param[in] _condition The condition to check.
- * @param[in] _format Log message format string.
- */
-#define ET_CHECK_OR_LOG_ERROR(_condition, _format, ...) ((void)0)
-
-#endif // ET_LOG_ENABLED
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/platform.h b/packages/react-native-executorch/third-party/include/executorch/runtime/platform/platform.h
deleted file mode 100644
index 1afb675f9d..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/platform.h
+++ /dev/null
@@ -1,259 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @file
- * Platform abstraction layer to allow individual platform libraries to override
- * symbols in ExecuTorch. PAL functions are defined as C functions so a platform
- * library implementer can use C in lieu of C++.
- *
- * The et_pal_ methods should not be called directly. Use the corresponding
- * methods in the executorch::runtime namespace instead to appropriately
- * dispatch through the PAL function table.
- */
-
-#pragma once
-
-// Use C-style includes so that C code can include this header.
-#include <stddef.h>
-#include <stdint.h>
-
-#include <executorch/runtime/platform/compiler.h>
-#include <executorch/runtime/platform/types.h>
-
-/**
- * Clients should neither define nor use this macro. Used to optionally declare
- * the et_pal_*() functions as weak symbols.
- *
- * This provides a way to both:
- * - Include the header and define weak symbols (used by the internal default
- *   implementations)
- * - Include the header and define strong symbols (used by client overrides)
- */
-#ifndef ET_INTERNAL_PLATFORM_WEAKNESS
-#define ET_INTERNAL_PLATFORM_WEAKNESS
-#endif
-
-extern "C" {
-
-/**
- * Represents the conversion ratio from system ticks to nanoseconds.
- * To convert, use nanoseconds = ticks * numerator / denominator.
- */
-typedef struct {
-  uint64_t numerator;
-  uint64_t denominator;
-} et_tick_ratio_t;
-
-/**
- * Initialize the platform abstraction layer.
- *
- * This function should be called before any other function provided by the PAL
- * to initialize any global state. Typically overridden by PAL implementer.
- */
-void et_pal_init(void) ET_INTERNAL_PLATFORM_WEAKNESS;
-using pal_init_method = void (*)();
-
-/**
- * Immediately abort execution, setting the device into an error state, if
- * available.
- */
-ET_NORETURN void et_pal_abort(void) ET_INTERNAL_PLATFORM_WEAKNESS;
-using pal_abort_method = void (*)();
-
-/**
- * Return a monotonically non-decreasing timestamp in system ticks.
- *
- * @retval Timestamp value in system ticks.
- */
-et_timestamp_t et_pal_current_ticks(void) ET_INTERNAL_PLATFORM_WEAKNESS;
-typedef et_timestamp_t (*et_pal_current_ticks_t)(void);
-using pal_current_ticks_method = et_timestamp_t (*)();
-
-/**
- * Return the conversion rate from system ticks to nanoseconds as a fraction.
- * To convert a system ticks to nanoseconds, multiply the tick count by the
- * numerator and then divide by the denominator:
- *   nanoseconds = ticks * numerator / denominator
- *
- * The utility method executorch::runtime::ticks_to_ns(et_timestamp_t) can also
- * be used to perform the conversion for a given tick count. It is defined in
- * torch/executor/runtime/platform/clock.h.
- *
- * @retval The ratio of nanoseconds to system ticks.
- */
-et_tick_ratio_t
-et_pal_ticks_to_ns_multiplier(void) ET_INTERNAL_PLATFORM_WEAKNESS;
-using pal_ticks_to_ns_multiplier_method = et_tick_ratio_t (*)();
-
-/**
- * Severity level of a log message. Values must map to printable 7-bit ASCII
- * uppercase letters.
- */
-typedef enum {
-  kDebug = 'D',
-  kInfo = 'I',
-  kError = 'E',
-  kFatal = 'F',
-  kUnknown = '?', // Exception to the "uppercase letter" rule.
-} et_pal_log_level_t;
-
-/**
- * Emit a log message via platform output (serial port, console, etc).
- *
- * @param[in] timestamp Timestamp of the log event in system ticks since boot.
- * @param[in] level Severity level of the message. Must be a printable 7-bit
- *     ASCII uppercase letter.
- * @param[in] filename Name of the file that created the log event.
- * @param[in] function Name of the function that created the log event.
- * @param[in] line Line in the source file where the log event was created.
- * @param[in] message Message string to log.
- * @param[in] length Message string length.
- */
-void et_pal_emit_log_message(et_timestamp_t timestamp, et_pal_log_level_t level,
-                             const char *filename, const char *function,
-                             size_t line, const char *message,
-                             size_t length) ET_INTERNAL_PLATFORM_WEAKNESS;
-using pal_emit_log_message_method = void (*)(
-    et_timestamp_t timestamp, et_pal_log_level_t level, const char *filename,
-    const char *function, size_t line, const char *message, size_t length);
-
-/**
- * NOTE: Core runtime code must not call this directly. It may only be called by
- * a MemoryAllocator wrapper.
- *
- * Allocates size bytes of memory.
- *
- * @param[in] size Number of bytes to allocate.
- * @returns the allocated memory, or nullptr on failure. Must be freed using
- *     et_pal_free().
- */
-void *et_pal_allocate(size_t size) ET_INTERNAL_PLATFORM_WEAKNESS;
-using pal_allocate_method = void *(*)(size_t size);
-
-/**
- * Frees memory allocated by et_pal_allocate().
- *
- * @param[in] ptr Pointer to memory to free. May be nullptr.
- */
-void et_pal_free(void *ptr) ET_INTERNAL_PLATFORM_WEAKNESS;
-using pal_free_method = void (*)(void *ptr);
-
-} // extern "C"
-
-namespace executorch::runtime {
-
-/**
- * Table of pointers to platform abstraction layer functions.
- */
-struct PalImpl {
-  // Note that this struct cannot contain constructors in order to ensure that
-  // the singleton instance can be initialized without relying on a global
-  // constructor. If it does require a global constructor, there can be a race
-  // between the init of the default PAL and the user static registration code.
-  static PalImpl create(pal_emit_log_message_method emit_log_message,
-                        const char *source_filename);
-
-  static PalImpl
-  create(pal_init_method init, pal_abort_method abort,
-         pal_current_ticks_method current_ticks,
-         pal_ticks_to_ns_multiplier_method ticks_to_ns_multiplier,
-         pal_emit_log_message_method emit_log_message,
-         pal_allocate_method allocate, pal_free_method free,
-         const char *source_filename);
-
-  pal_init_method init = nullptr;
-  pal_abort_method abort = nullptr;
-  pal_current_ticks_method current_ticks = nullptr;
-  pal_ticks_to_ns_multiplier_method ticks_to_ns_multiplier = nullptr;
-  pal_emit_log_message_method emit_log_message = nullptr;
-  pal_allocate_method allocate = nullptr;
-  pal_free_method free = nullptr;
-
-  // An optional metadata field, indicating the name of the source
-  // file that registered the PAL implementation.
-  const char *source_filename;
-};
-
-/**
- * Override the PAL functions with user implementations. Any null entries in the
- * table are unchanged and will keep the default implementation.
- *
- * Returns true if the registration was successful, false otherwise.
- */
-bool register_pal(PalImpl impl);
-
-/**
- * Returns the PAL function table, which contains function pointers to the
- * active implementation of each PAL function.
- */
-const PalImpl *get_pal_impl();
-
-/**
- * Initialize the platform abstraction layer.
- *
- * This function should be called before any other function provided by the PAL
- * to initialize any global state. Typically overridden by PAL implementer.
- */
-void pal_init();
-
-/**
- * Immediately abort execution, setting the device into an error state, if
- * available.
- */
-ET_NORETURN void pal_abort();
-
-/**
- * Return a monotonically non-decreasing timestamp in system ticks.
- *
- * @retval Timestamp value in system ticks.
- */
-et_timestamp_t pal_current_ticks();
-
-/**
- * Return the conversion rate from system ticks to nanoseconds as a fraction.
- * To convert a system ticks to nanoseconds, multiply the tick count by the
- * numerator and then divide by the denominator:
- *   nanoseconds = ticks * numerator / denominator
- *
- * The utility method executorch::runtime::ticks_to_ns(et_timestamp_t) can also
- * be used to perform the conversion for a given tick count. It is defined in
- * torch/executor/runtime/platform/clock.h.
- *
- * @retval The ratio of nanoseconds to system ticks.
- */
-et_tick_ratio_t pal_ticks_to_ns_multiplier();
-
-/**
- * Severity level of a log message. Values must map to printable 7-bit ASCII
- * uppercase letters.
- */
-void pal_emit_log_message(et_timestamp_t timestamp, et_pal_log_level_t level,
-                          const char *filename, const char *function,
-                          size_t line, const char *message, size_t length);
-
-/**
- * NOTE: Core runtime code must not call this directly. It may only be called by
- * a MemoryAllocator wrapper.
- *
- * Allocates size bytes of memory.
- *
- * @param[in] size Number of bytes to allocate.
- * @returns the allocated memory, or nullptr on failure. Must be freed using
- *     et_pal_free().
- */
-void *pal_allocate(size_t size);
-
-/**
- * Frees memory allocated by et_pal_allocate().
- *
- * @param[in] ptr Pointer to memory to free. May be nullptr.
- */
-void pal_free(void *ptr);
-
-} // namespace executorch::runtime
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/profiler.h b/packages/react-native-executorch/third-party/include/executorch/runtime/platform/profiler.h
deleted file mode 100644
index 9d5671980b..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/profiler.h
+++ /dev/null
@@ -1,290 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-namespace executorch {
-namespace runtime {
-
-// Version string used to check for compatibility with post-processing
-// tool
-#define ET_PROF_VER 0x00000001
-
-// By default we support profiling upto 1024 perf events. Build
-// targets can override this to increase the profiling buffer size
-// during compilation.
-#ifndef MAX_PROFILE_EVENTS
-#define MAX_PROFILE_EVENTS 1024
-#endif
-// By default we support profiling upto 1024 memory allocation events.
-// Build targets can choose to override this, which will consequently have
-// the effect of increasing/decreasing the profiling buffer size.
-#ifndef MAX_MEM_PROFILE_EVENTS
-#define MAX_MEM_PROFILE_EVENTS 1024
-#endif
-// By default we support profiling only upto 16 allocators. If users
-// have more allocators than these then they can override this during
-// compilation time. There will be an increase/decrease in the profiling
-// buffer size based on the way this value is changed.
-#ifndef MEM_PROFILE_MAX_ALLOCATORS
-#define MEM_PROFILE_MAX_ALLOCATORS 32
-#endif
-// By default we support only one profiling block. If users want to profile
-// something that will be iterated on multiple times then they will have to
-// increment this to support their use case. In post-processing the stats for
-// all these iterations will be consolidated.
-#ifndef MAX_PROFILE_BLOCKS
-#define MAX_PROFILE_BLOCKS 2
-#endif
-
-#define PROF_NAME_MAX_LEN 32
-
-typedef struct alignas(8) {
-  union {
-    const char *name_str;
-    char name[PROF_NAME_MAX_LEN];
-  };
-  // chain_idx == -1 is a null value, when profile event happens out of chain
-  // execution
-  int32_t chain_idx;
-  uint32_t instruction_idx;
-  uint64_t start_time;
-  uint64_t end_time;
-} prof_event_t;
-
-typedef struct alignas(8) {
-  uint32_t allocator_id;
-  uint32_t allocation_size;
-} mem_prof_event_t;
-
-typedef struct alignas(8) {
-  char name[PROF_NAME_MAX_LEN];
-  uint64_t allocator_id;
-} prof_allocator_t;
-
-typedef struct alignas(8) {
-  uint8_t *prof_data;
-  uint32_t num_bytes;
-  uint32_t num_blocks;
-} prof_result_t;
-
-typedef struct alignas(8) {
-  char name[32];
-  uint32_t prof_ver;
-  uint32_t max_prof_entries;
-  uint32_t prof_entries;
-  uint32_t max_allocator_entries;
-  uint32_t allocator_entries;
-  uint32_t max_mem_prof_entries;
-  uint32_t mem_prof_entries;
-} prof_header_t;
-
-/*
-This is what the layout of the profiling buffer looks like.
----------------------------------------
-| Profiling header                    |
----------------------------------------
-| Profile events (Perf events)        |
----------------------------------------
-| Memory allocators info              |
----------------------------------------
-| Profile events (Memory allocations) |
----------------------------------------
-*/
-
-// offsets of the various sections in the profiling buffer
-// Total size required for profiling buffer
-constexpr uint32_t prof_buf_size =
-    sizeof(prof_header_t) + sizeof(prof_event_t) * MAX_PROFILE_EVENTS +
-    sizeof(mem_prof_event_t) * MAX_MEM_PROFILE_EVENTS +
-    sizeof(prof_allocator_t) * MEM_PROFILE_MAX_ALLOCATORS;
-
-constexpr size_t prof_header_offset = 0;
-constexpr size_t prof_events_offset = sizeof(prof_header_t);
-constexpr size_t prof_mem_alloc_info_offset =
-    prof_events_offset + sizeof(prof_event_t) * MAX_PROFILE_EVENTS;
-constexpr size_t prof_mem_alloc_events_offset =
-    prof_mem_alloc_info_offset +
-    sizeof(prof_allocator_t) * MEM_PROFILE_MAX_ALLOCATORS;
-
-// Set the initial state for the profiler assuming we're using the
-// statically allocated buffer declared in the profiler module.
-void profiler_init(void);
-
-// This starts the profiling of this event and returns a token
-// by which this event can be referred to in the future.
-uint32_t begin_profiling(const char *name);
-
-// End profiling event represented by token_id
-void end_profiling(uint32_t token_id);
-
-// Dump profiler results, return pointer to prof event array and number of
-// events in it.
-void dump_profile_stats(prof_result_t *prof_result);
-
-void reset_profile_stats();
-
-void track_allocation(int32_t id, uint32_t size);
-
-uint32_t track_allocator(const char *name);
-
-void profiling_create_block(const char *name);
-
-// This class enables scope based profiling where needed. Profiling
-// will be started when the object is created and will end when the
-// object goes out of scope.
-class ExecutorchProfiler {
-public:
-  explicit ExecutorchProfiler(const char *name);
-
-  ~ExecutorchProfiler();
-
-private:
-  uint32_t prof_tok;
-};
-
-typedef struct {
-  int32_t chain_idx;
-  uint32_t instruction_idx;
-} prof_state_t;
-
-const prof_state_t &get_profile_tls_state();
-
-void set_profile_tls_state(const prof_state_t &state);
-
-class ExecutorchProfilerInstructionScope {
-public:
-  explicit ExecutorchProfilerInstructionScope(const prof_state_t &state);
-  ~ExecutorchProfilerInstructionScope();
-
-  // ScopeGuard: non-copyable, non-movable
-  ExecutorchProfilerInstructionScope(
-      const ExecutorchProfilerInstructionScope &) = delete;
-  ExecutorchProfilerInstructionScope &
-  operator=(const ExecutorchProfilerInstructionScope &) = delete;
-
-  ExecutorchProfilerInstructionScope(ExecutorchProfilerInstructionScope &&) =
-      delete;
-  ExecutorchProfilerInstructionScope &
-  operator=(ExecutorchProfilerInstructionScope &&) = delete;
-
-private:
-  prof_state_t old_state_;
-};
-
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::begin_profiling;
-using ::executorch::runtime::dump_profile_stats;
-using ::executorch::runtime::end_profiling;
-using ::executorch::runtime::ExecutorchProfiler;
-using ::executorch::runtime::ExecutorchProfilerInstructionScope;
-using ::executorch::runtime::get_profile_tls_state;
-using ::executorch::runtime::mem_prof_event_t;
-using ::executorch::runtime::prof_allocator_t;
-using ::executorch::runtime::prof_buf_size;
-using ::executorch::runtime::prof_event_t;
-using ::executorch::runtime::prof_events_offset;
-using ::executorch::runtime::prof_header_offset;
-using ::executorch::runtime::prof_header_t;
-using ::executorch::runtime::prof_mem_alloc_events_offset;
-using ::executorch::runtime::prof_mem_alloc_info_offset;
-using ::executorch::runtime::prof_result_t;
-using ::executorch::runtime::prof_state_t;
-using ::executorch::runtime::profiler_init;
-using ::executorch::runtime::profiling_create_block;
-using ::executorch::runtime::reset_profile_stats;
-using ::executorch::runtime::set_profile_tls_state;
-using ::executorch::runtime::track_allocation;
-using ::executorch::runtime::track_allocator;
-} // namespace executor
-} // namespace torch
-
-#ifdef PROFILING_ENABLED
-
-#define EXECUTORCH_PROFILE_CREATE_BLOCK(name)                                  \
-  ::executorch::runtime::profiling_create_block(name);
-
-// Convenience macros to begin and end profiling. These can be inserted
-// anywhere as it'll be ensured that for the prod builds these will
-// essentially be noops.
-#define EXECUTORCH_BEGIN_PROF(name)                                            \
-  ::executorch::runtime::begin_profiling(name);
-
-#define EXECUTORCH_END_PROF(token_id)                                          \
-  ::executorch::runtime::end_profiling(token_id);
-
-#define EXECUTORCH_SCOPE_PROF(name)                                            \
-  ::executorch::runtime::ExecutorchProfiler profiler(name);
-
-#define EXECUTORCH_PROFILE_INSTRUCTION_SCOPE(chain_idx, instruction_idx)       \
-  ::executorch::runtime::ExecutorchProfilerInstructionScope                    \
-      __profiler_instruction_scope({chain_idx, instruction_idx});
-
-#define EXECUTORCH_DUMP_PROFILE_RESULTS(prof_result)                           \
-  ::executorch::runtime::dump_profile_stats(prof_result);
-
-#define EXECUTORCH_RESET_PROFILE_RESULTS()                                     \
-  ::executorch::runtime::reset_profile_stats();
-
-#define EXECUTORCH_TRACK_ALLOCATOR(name)                                       \
-  ::executorch::runtime::track_allocator(name);
-
-#define EXECUTORCH_TRACK_ALLOCATION(id, size)                                  \
-  ::executorch::runtime::track_allocation(id, size);
-
-#else
-
-#define EXECUTORCH_PROFILE_CREATE_BLOCK(name)                                  \
-  do {                                                                         \
-    (void)(name);                                                              \
-  } while (0)
-
-#define EXECUTORCH_BEGIN_PROF(name)                                            \
-  {}
-
-#define EXECUTORCH_END_PROF(token_id)                                          \
-  do {                                                                         \
-    (void)(token_id);                                                          \
-  } while (0)
-
-#define EXECUTORCH_SCOPE_PROF(name)                                            \
-  do {                                                                         \
-    (void)(name);                                                              \
-  } while (0)
-
-#define EXECUTORCH_PROFILE_INSTRUCTION_SCOPE(chain_idx, instruction_idx)       \
-  do {                                                                         \
-    (void)(chain_idx);                                                         \
-    (void)(instruction_idx);                                                   \
-  } while (0)
-
-#define EXECUTORCH_DUMP_PROFILE_RESULTS(prof_result_test)                      \
-  memset(prof_result_test, 0, sizeof(::executorch::runtime::prof_result_t));
-
-#define EXECUTORCH_RESET_PROFILE_RESULTS()                                     \
-  {}
-
-#define EXECUTORCH_TRACK_ALLOCATOR(name) ((void)(name), -1)
-
-#define EXECUTORCH_TRACK_ALLOCATION(id, size)                                  \
-  do {                                                                         \
-    (void)(id);                                                                \
-    (void)(size);                                                              \
-  } while (0)
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/runtime.h b/packages/react-native-executorch/third-party/include/executorch/runtime/platform/runtime.h
deleted file mode 100644
index 375ae7959a..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/runtime.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @file
- * ExecuTorch global runtime wrapper functions.
- */
-
-#pragma once
-
-#include <executorch/runtime/platform/compiler.h>
-
-namespace executorch {
-namespace runtime {
-
-/**
- * Initialize the ExecuTorch global runtime.
- */
-void runtime_init();
-
-} // namespace runtime
-} // namespace executorch
-
-namespace torch {
-namespace executor {
-// TODO(T197294990): Remove these deprecated aliases once all users have moved
-// to the new `::executorch` namespaces.
-using ::executorch::runtime::runtime_init;
-} // namespace executor
-} // namespace torch
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/system.h b/packages/react-native-executorch/third-party/include/executorch/runtime/platform/system.h
deleted file mode 100644
index ae658507ce..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/system.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @file
- * Platform abstraction layer to allow individual host OS to override
- * symbols in ExecuTorch. PAL functions are defined as C functions so an
- * implementer can use C in lieu of C++.
- */
-#pragma once
-
-/**
- * To enable dynamic linking debugging capability on UNIX-like OS. If enabled
- * and see an error like: `undefined symbol: dladdr`, install `libdl` to fix.
- */
-#if defined(ET_USE_LIBDL)
-#include <dlfcn.h>
-#endif
-
-static constexpr const char *DYNAMIC_LIBRARY_NOT_SUPPORTED = "NOT_SUPPORTED";
-static constexpr const char *DYNAMIC_LIBRARY_NOT_FOUND = "NOT_FOUND";
-
-extern "C" {
-
-/**
- * Return shared library .
- *
- * @param[in] addr Address to the symbol we are looking for in shared libraries.
- * @retval The path to the shared library containing the symbol.
- */
-inline const char *et_pal_get_shared_library_name(const void *addr) {
-#if defined(ET_USE_LIBDL)
-  Dl_info info;
-  if (dladdr(addr, &info) && info.dli_fname) {
-    return info.dli_fname;
-  } else {
-    return DYNAMIC_LIBRARY_NOT_FOUND;
-  }
-#endif
-  (void)addr;
-  return DYNAMIC_LIBRARY_NOT_SUPPORTED;
-}
-
-} // extern "C"
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/test/pal_spy.h b/packages/react-native-executorch/third-party/include/executorch/runtime/platform/test/pal_spy.h
deleted file mode 100644
index 43d7922168..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/test/pal_spy.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#include <executorch/runtime/platform/log.h>
-#include <executorch/runtime/platform/runtime.h>
-#include <executorch/runtime/platform/test/stub_platform.h>
-
-#include <string>
-
-class PalSpy : public PlatformIntercept {
-public:
-  PalSpy() = default;
-
-  void init() override { ++init_call_count; }
-
-  static constexpr et_timestamp_t kTimestamp = 1234;
-
-  et_timestamp_t current_ticks() override {
-    ++current_ticks_call_count;
-    return kTimestamp;
-  }
-
-  et_tick_ratio_t ticks_to_ns_multiplier() override {
-    return tick_ns_multiplier;
-  }
-
-  void emit_log_message(et_timestamp_t timestamp, et_pal_log_level_t level,
-                        const char *filename, const char *function, size_t line,
-                        const char *message, size_t length) override {
-    ++emit_log_message_call_count;
-    last_log_message_args.timestamp = timestamp;
-    last_log_message_args.level = level;
-    last_log_message_args.filename = filename;
-    last_log_message_args.function = function;
-    last_log_message_args.line = line;
-    last_log_message_args.message = message;
-    last_log_message_args.length = length;
-  }
-
-  void *allocate(size_t size) override {
-    ++allocate_call_count;
-    last_allocated_size = size;
-    last_allocated_ptr = (void *)0x1234;
-    return nullptr;
-  }
-
-  void free(void *ptr) override {
-    ++free_call_count;
-    last_freed_ptr = ptr;
-  }
-
-  virtual ~PalSpy() = default;
-
-  size_t init_call_count = 0;
-  size_t current_ticks_call_count = 0;
-  size_t emit_log_message_call_count = 0;
-  et_tick_ratio_t tick_ns_multiplier = {1, 1};
-  size_t allocate_call_count = 0;
-  size_t free_call_count = 0;
-  size_t last_allocated_size = 0;
-  void *last_allocated_ptr = nullptr;
-  void *last_freed_ptr = nullptr;
-
-  /// The args that were passed to the most recent call to emit_log_message().
-  struct {
-    et_timestamp_t timestamp;
-    et_pal_log_level_t level;
-    std::string filename; // Copy of the char* to avoid lifetime issues.
-    std::string function;
-    size_t line;
-    std::string message;
-    size_t length;
-  } last_log_message_args = {};
-};
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/test/stub_platform.h b/packages/react-native-executorch/third-party/include/executorch/runtime/platform/test/stub_platform.h
deleted file mode 100644
index 41297be589..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/test/stub_platform.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <cstddef>
-
-#include <executorch/runtime/platform/compiler.h>
-#include <executorch/runtime/platform/platform.h>
-#include <executorch/runtime/platform/types.h>
-
-/**
- * An interface for intercepting calls to the PAL layer.
- */
-class PlatformIntercept {
-public:
-  PlatformIntercept() = default;
-
-  /// Called when et_pal_init() is called.
-  virtual void init() {}
-
-  // We can't intercept et_pal_abort() since it's marked NORETURN.
-
-  /// Called when et_pal_current_ticks() is called.
-  virtual et_timestamp_t current_ticks() { return 0; }
-
-  virtual et_tick_ratio_t ticks_to_ns_multiplier() { return {1, 1}; }
-
-  /// Called when et_pal_emit_log_message() is called.
-  virtual void emit_log_message(ET_UNUSED et_timestamp_t timestamp,
-                                ET_UNUSED et_pal_log_level_t level,
-                                ET_UNUSED const char *filename,
-                                ET_UNUSED const char *function,
-                                ET_UNUSED size_t line,
-                                ET_UNUSED const char *message,
-                                ET_UNUSED size_t length) {}
-
-  virtual void *allocate(ET_UNUSED size_t size) { return nullptr; }
-
-  virtual void free(ET_UNUSED void *ptr) {}
-
-  virtual ~PlatformIntercept() = default;
-};
-
-/**
- * RAII type to install a PlatformIntercept for the duration of a test case.
- */
-class InterceptWith {
-public:
-  explicit InterceptWith(PlatformIntercept &pi) { InterceptWith::install(&pi); }
-
-  ~InterceptWith() { InterceptWith::install(nullptr); }
-
-private:
-  /**
-   * Installs the PlatformIntercept to forward to when et_pal_* functions are
-   * called. To uninstall, pass in `nullptr`.
-   */
-  static void install(PlatformIntercept *pi);
-};
diff --git a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/types.h b/packages/react-native-executorch/third-party/include/executorch/runtime/platform/types.h
deleted file mode 100644
index a91f357fe5..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/runtime/platform/types.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @file
- * Public types used by the ExecuTorch Platform Abstraction Layer.
- */
-
-#pragma once
-
-// Use C-style includes so that C code can include this header.
-#include <stdint.h>
-
-extern "C" {
-
-/// Platform timestamp in system ticks.
-typedef uint64_t et_timestamp_t;
-
-} // extern "C"
diff --git a/packages/react-native-executorch/third-party/include/executorch/schema/extended_header.h b/packages/react-native-executorch/third-party/include/executorch/schema/extended_header.h
deleted file mode 100644
index a74f3f41a2..0000000000
--- a/packages/react-native-executorch/third-party/include/executorch/schema/extended_header.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <executorch/runtime/core/result.h>
-
-namespace executorch {
-namespace runtime {
-
-/**
- * An extended, ExecuTorch-specific header that may be embedded in the
- * serialized Program data header.
- *
- * For details see //executorch/docs/source/pte-file-format.md
- */
-struct ExtendedHeader {
-  /**
-   * To find the header, callers should provide at least this many bytes of the
-   * head of the serialized Program data. Keep this in sync with NUM_HEAD_BYTES
-   * in //executorch/exir/_serialize/program.py
-   */
-  static constexpr size_t kNumHeadBytes = 64;
-
-  /**
-   * The offset into the Program serialized program data where the extended
-   * header should begin.
-   */
-  static constexpr size_t kHeaderOffset = 8;
-
-  /**
-   * The magic bytes that identify the header.
-   *
-   * This is the canonical definition of the expected value. If the header
-   * layout ever changes in a compatibility-breaking way, increment the digits
-   * in the magic. But, doing so will prevent older binaries from recognizing
-   * the presence of the header. The compatibility-preserving way to make
-   * changes is to increase the header's length field and add new fields at the
-   * end.
-   */
-  static constexpr size_t kMagicSize = 4;
-  static constexpr char kMagic[kMagicSize] = {'e', 'h', '0', '0'};
-
-  /**
-   * Look for and parse an ExtendedHeader in the provided data.
-   *
-   * @param[in] data The contents of the beginning of the serialized binary
-   *     Program data, starting at offset 0 (i.e., the head of the file).
-   * @param[in] size Length of `data` in bytes. Must be >= kNumHeadBytes or this
-   *     call will fail.
-   *
-   * @returns an ExtendedHeader if the header was found and is valid. Returns an
-   *     error if size was too short, if the header was not found, or if the
-   *     header appeared to be corrupt.
-   */
-  static Result<ExtendedHeader> Parse(const void *data, size_t size);
-
-  /**
-   * The size in bytes of the Program flatbuffer data, starting from offset
-   * zero.
-   */
-  uint64_t program_size;
-
-  /**
-   * The offset in bytes of the first segment, if present. Zero if no segment
-   * is present.
-   */
-  uint64_t segment_base_offset;
-
-  /**
-   * The size of all the segment data, in bytes. Zero if:
-   * - no segment is present
-   * - the segment_data_size field doesn't exist in the header - the case for
-   *   older PTE files.
-   */
-  uint64_t segment_data_size;
-};
-
-} // namespace runtime
-} // namespace executorch
diff --git a/packages/react-native-executorch/third-party/include/headeronly/macros/Export.h b/packages/react-native-executorch/third-party/include/headeronly/macros/Export.h
deleted file mode 100644
index ab7dc1087f..0000000000
--- a/packages/react-native-executorch/third-party/include/headeronly/macros/Export.h
+++ /dev/null
@@ -1,88 +0,0 @@
-#define C10_USING_CUSTOM_GENERATED_MACROS
-#pragma once
-
-/* Header file to define the common scaffolding for exported symbols.
- *
- * Export is by itself a quite tricky situation to deal with, and if you are
- * hitting this file, make sure you start with the background here:
- * - Linux: https://gcc.gnu.org/wiki/Visibility
- * - Windows:
- * https://docs.microsoft.com/en-us/cpp/cpp/dllexport-dllimport?view=vs-2017
- *
- * Do NOT include this file directly. Instead, use c10/macros/Macros.h
- */
-
-// You do not need to edit this part of file unless you are changing the core
-// pytorch export abstractions.
-//
-// This part defines the C10 core export and import macros. This is controlled
-// by whether we are building shared libraries or not, which is determined
-// during build time and codified in c10/core/cmake_macros.h.
-// When the library is built as a shared lib, EXPORT and IMPORT will contain
-// visibility attributes. If it is being built as a static lib, then EXPORT
-// and IMPORT basically have no effect.
-
-// As a rule of thumb, you should almost NEVER mix static and shared builds for
-// libraries that depend on c10. AKA, if c10 is built as a static library, we
-// recommend everything dependent on c10 to be built statically. If c10 is built
-// as a shared library, everything dependent on it should be built as shared. In
-// the PyTorch project, all native libraries shall use the macro
-// C10_BUILD_SHARED_LIB to check whether pytorch is building shared or static
-// libraries.
-
-// For build systems that do not directly depend on CMake and directly build
-// from the source directory (such as Buck), one may not have a cmake_macros.h
-// file at all. In this case, the build system is responsible for providing
-// correct macro definitions corresponding to the cmake_macros.h.in file.
-//
-// In such scenarios, one should define the macro
-//     C10_USING_CUSTOM_GENERATED_MACROS
-// to inform this header that it does not need to include the cmake_macros.h
-// file.
-
-#ifdef _WIN32
-#define C10_HIDDEN
-#if defined(C10_BUILD_SHARED_LIBS)
-#define C10_EXPORT __declspec(dllexport)
-#define C10_IMPORT __declspec(dllimport)
-#else
-#define C10_EXPORT
-#define C10_IMPORT
-#endif
-#else // _WIN32
-#if defined(__GNUC__)
-#define C10_EXPORT __attribute__((__visibility__("default")))
-#define C10_HIDDEN __attribute__((__visibility__("hidden")))
-#else // defined(__GNUC__)
-#define C10_EXPORT
-#define C10_HIDDEN
-#endif // defined(__GNUC__)
-#define C10_IMPORT C10_EXPORT
-#endif // _WIN32
-
-#ifdef NO_EXPORT
-#undef C10_EXPORT
-#define C10_EXPORT
-#endif
-
-// Definition of an adaptive XX_API macro, that depends on whether you are
-// building the library itself or not, routes to XX_EXPORT and XX_IMPORT.
-// Basically, you will need to do this for each shared library that you are
-// building, and the instruction is as follows: assuming that you are building
-// a library called libawesome.so. You should:
-// (1) for your cmake target (usually done by "add_library(awesome, ...)"),
-//     define a macro called AWESOME_BUILD_MAIN_LIB using
-//     target_compile_options.
-// (2) define the AWESOME_API macro similar to the one below.
-// And in the source file of your awesome library, use AWESOME_API to
-// annotate public symbols.
-
-// Here, for the C10 library, we will define the macro C10_API for both import
-// and export.
-
-// This one is being used by libc10.so
-#ifdef C10_BUILD_MAIN_LIB
-#define C10_API C10_EXPORT
-#else
-#define C10_API C10_IMPORT
-#endif
diff --git a/packages/react-native-executorch/third-party/include/nlohmann/json.hpp b/packages/react-native-executorch/third-party/include/nlohmann/json.hpp
deleted file mode 100644
index 7c23b7bdfb..0000000000
--- a/packages/react-native-executorch/third-party/include/nlohmann/json.hpp
+++ /dev/null
@@ -1,24723 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-/****************************************************************************\
- * Note on documentation: The source files contain links to the online      *
- * documentation of the public API at https://json.nlohmann.me. This URL    *
- * contains the most recent documentation and should also be applicable to  *
- * previous versions; documentation for deprecated functions is not         *
- * removed, but marked deprecated. See "Generate documentation" section in  *
- * file docs/README.md.                                                     *
-\****************************************************************************/
-
-#ifndef INCLUDE_NLOHMANN_JSON_HPP_
-#define INCLUDE_NLOHMANN_JSON_HPP_
-
-#include <algorithm>        // all_of, find, for_each
-#include <cstddef>          // nullptr_t, ptrdiff_t, size_t
-#include <functional>       // hash, less
-#include <initializer_list> // initializer_list
-#ifndef JSON_NO_IO
-#include <iosfwd>   // istream, ostream
-#endif              // JSON_NO_IO
-#include <iterator> // random_access_iterator_tag
-#include <memory>   // unique_ptr
-#include <string>   // string, stoi, to_string
-#include <utility>  // declval, forward, move, pair, swap
-#include <vector>   // vector
-
-// #include <nlohmann/adl_serializer.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <utility>
-
-// #include <nlohmann/detail/abi_macros.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// This file contains all macro definitions affecting or depending on the ABI
-
-#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK
-#if defined(NLOHMANN_JSON_VERSION_MAJOR) &&                                    \
-    defined(NLOHMANN_JSON_VERSION_MINOR) &&                                    \
-    defined(NLOHMANN_JSON_VERSION_PATCH)
-#if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 11 ||   \
-    NLOHMANN_JSON_VERSION_PATCH != 3
-#warning "Already included a different version of the library!"
-#endif
-#endif
-#endif
-
-#define NLOHMANN_JSON_VERSION_MAJOR 3  // NOLINT(modernize-macro-to-enum)
-#define NLOHMANN_JSON_VERSION_MINOR 11 // NOLINT(modernize-macro-to-enum)
-#define NLOHMANN_JSON_VERSION_PATCH 3  // NOLINT(modernize-macro-to-enum)
-
-#ifndef JSON_DIAGNOSTICS
-#define JSON_DIAGNOSTICS 0
-#endif
-
-#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
-#define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0
-#endif
-
-#if JSON_DIAGNOSTICS
-#define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
-#else
-#define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS
-#endif
-
-#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
-#define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp
-#else
-#define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON
-#endif
-
-#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
-#define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
-#endif
-
-// Construct the namespace ABI tags component
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) json_abi##a##b
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b)                                    \
-  NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b)
-
-#define NLOHMANN_JSON_ABI_TAGS                                                 \
-  NLOHMANN_JSON_ABI_TAGS_CONCAT(                                               \
-      NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                                       \
-      NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON)
-
-// Construct the namespace version component
-#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch)         \
-  _v##major##_##minor##_##patch
-#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch)            \
-  NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch)
-
-#if NLOHMANN_JSON_NAMESPACE_NO_VERSION
-#define NLOHMANN_JSON_NAMESPACE_VERSION
-#else
-#define NLOHMANN_JSON_NAMESPACE_VERSION                                        \
-  NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR,          \
-                                         NLOHMANN_JSON_VERSION_MINOR,          \
-                                         NLOHMANN_JSON_VERSION_PATCH)
-#endif
-
-// Combine namespace components
-#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a##b
-#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b)                                   \
-  NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b)
-
-#ifndef NLOHMANN_JSON_NAMESPACE
-#define NLOHMANN_JSON_NAMESPACE                                                \
-  nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT(NLOHMANN_JSON_ABI_TAGS,             \
-                                           NLOHMANN_JSON_NAMESPACE_VERSION)
-#endif
-
-#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN
-#define NLOHMANN_JSON_NAMESPACE_BEGIN                                          \
-  namespace nlohmann {                                                         \
-  inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT(                             \
-      NLOHMANN_JSON_ABI_TAGS, NLOHMANN_JSON_NAMESPACE_VERSION) {
-#endif
-
-#ifndef NLOHMANN_JSON_NAMESPACE_END
-#define NLOHMANN_JSON_NAMESPACE_END                                            \
-  } /* namespace (inline namespace) NOLINT(readability/namespace) */           \
-  } // namespace nlohmann
-#endif
-
-// #include <nlohmann/detail/conversions/from_json.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <algorithm>    // transform
-#include <array>        // array
-#include <forward_list> // forward_list
-#include <iterator>     // inserter, front_inserter, end
-#include <map>          // map
-#ifdef JSON_HAS_CPP_17
-#include <optional> // optional
-#endif
-#include <string> // string
-#include <tuple>  // tuple, make_tuple
-#include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
-#include <unordered_map> // unordered_map
-#include <utility>       // pair, declval
-#include <valarray>      // valarray
-
-// #include <nlohmann/detail/exceptions.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <cstddef>   // nullptr_t
-#include <exception> // exception
-#if JSON_DIAGNOSTICS
-#include <numeric> // accumulate
-#endif
-#include <stdexcept> // runtime_error
-#include <string>    // to_string
-#include <vector>    // vector
-
-// #include <nlohmann/detail/value_t.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <array>   // array
-#include <cstddef> // size_t
-#include <cstdint> // uint8_t
-#include <string>  // string
-
-// #include <nlohmann/detail/macro_scope.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <utility> // declval, pair
-// #include <nlohmann/detail/meta/detected.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <type_traits>
-
-// #include <nlohmann/detail/meta/void_t.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// #include <nlohmann/detail/abi_macros.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-template <typename... Ts> struct make_void {
-  using type = void;
-};
-template <typename... Ts> using void_t = typename make_void<Ts...>::type;
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-// https://en.cppreference.com/w/cpp/experimental/is_detected
-struct nonesuch {
-  nonesuch() = delete;
-  ~nonesuch() = delete;
-  nonesuch(nonesuch const &) = delete;
-  nonesuch(nonesuch const &&) = delete;
-  void operator=(nonesuch const &) = delete;
-  void operator=(nonesuch &&) = delete;
-};
-
-template <class Default, class AlwaysVoid, template <class...> class Op,
-          class... Args>
-struct detector {
-  using value_t = std::false_type;
-  using type = Default;
-};
-
-template <class Default, template <class...> class Op, class... Args>
-struct detector<Default, void_t<Op<Args...>>, Op, Args...> {
-  using value_t = std::true_type;
-  using type = Op<Args...>;
-};
-
-template <template <class...> class Op, class... Args>
-using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
-
-template <template <class...> class Op, class... Args>
-struct is_detected_lazy : is_detected<Op, Args...> {};
-
-template <template <class...> class Op, class... Args>
-using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
-
-template <class Default, template <class...> class Op, class... Args>
-using detected_or = detector<Default, void, Op, Args...>;
-
-template <class Default, template <class...> class Op, class... Args>
-using detected_or_t = typename detected_or<Default, Op, Args...>::type;
-
-template <class Expected, template <class...> class Op, class... Args>
-using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
-
-template <class To, template <class...> class Op, class... Args>
-using is_detected_convertible =
-    std::is_convertible<detected_t<Op, Args...>, To>;
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/thirdparty/hedley/hedley.hpp>
-
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-FileCopyrightText: 2016 - 2021 Evan Nemerson <evan@nemerson.com>
-// SPDX-License-Identifier: MIT
-
-/* Hedley - https://nemequ.github.io/hedley
- * Created by Evan Nemerson <evan@nemerson.com>
- */
-
-#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15)
-#if defined(JSON_HEDLEY_VERSION)
-#undef JSON_HEDLEY_VERSION
-#endif
-#define JSON_HEDLEY_VERSION 15
-
-#if defined(JSON_HEDLEY_STRINGIFY_EX)
-#undef JSON_HEDLEY_STRINGIFY_EX
-#endif
-#define JSON_HEDLEY_STRINGIFY_EX(x) #x
-
-#if defined(JSON_HEDLEY_STRINGIFY)
-#undef JSON_HEDLEY_STRINGIFY
-#endif
-#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
-
-#if defined(JSON_HEDLEY_CONCAT_EX)
-#undef JSON_HEDLEY_CONCAT_EX
-#endif
-#define JSON_HEDLEY_CONCAT_EX(a, b) a##b
-
-#if defined(JSON_HEDLEY_CONCAT)
-#undef JSON_HEDLEY_CONCAT
-#endif
-#define JSON_HEDLEY_CONCAT(a, b) JSON_HEDLEY_CONCAT_EX(a, b)
-
-#if defined(JSON_HEDLEY_CONCAT3_EX)
-#undef JSON_HEDLEY_CONCAT3_EX
-#endif
-#define JSON_HEDLEY_CONCAT3_EX(a, b, c) a##b##c
-
-#if defined(JSON_HEDLEY_CONCAT3)
-#undef JSON_HEDLEY_CONCAT3
-#endif
-#define JSON_HEDLEY_CONCAT3(a, b, c) JSON_HEDLEY_CONCAT3_EX(a, b, c)
-
-#if defined(JSON_HEDLEY_VERSION_ENCODE)
-#undef JSON_HEDLEY_VERSION_ENCODE
-#endif
-#define JSON_HEDLEY_VERSION_ENCODE(major, minor, revision)                     \
-  (((major) * 1000000) + ((minor) * 1000) + (revision))
-
-#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
-#undef JSON_HEDLEY_VERSION_DECODE_MAJOR
-#endif
-#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
-
-#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
-#undef JSON_HEDLEY_VERSION_DECODE_MINOR
-#endif
-#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
-
-#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
-#undef JSON_HEDLEY_VERSION_DECODE_REVISION
-#endif
-#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
-
-#if defined(JSON_HEDLEY_GNUC_VERSION)
-#undef JSON_HEDLEY_GNUC_VERSION
-#endif
-#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
-#define JSON_HEDLEY_GNUC_VERSION                                               \
-  JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
-#elif defined(__GNUC__)
-#define JSON_HEDLEY_GNUC_VERSION                                               \
-  JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
-#endif
-
-#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
-#undef JSON_HEDLEY_GNUC_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_GNUC_VERSION)
-#define JSON_HEDLEY_GNUC_VERSION_CHECK(major, minor, patch)                    \
-  (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-#define JSON_HEDLEY_GNUC_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_MSVC_VERSION)
-#undef JSON_HEDLEY_MSVC_VERSION
-#endif
-#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL)
-#define JSON_HEDLEY_MSVC_VERSION                                               \
-  JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000,                         \
-                             (_MSC_FULL_VER % 10000000) / 100000,              \
-                             (_MSC_FULL_VER % 100000) / 100)
-#elif defined(_MSC_FULL_VER) && !defined(__ICL)
-#define JSON_HEDLEY_MSVC_VERSION                                               \
-  JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000,                          \
-                             (_MSC_FULL_VER % 1000000) / 10000,                \
-                             (_MSC_FULL_VER % 10000) / 10)
-#elif defined(_MSC_VER) && !defined(__ICL)
-#define JSON_HEDLEY_MSVC_VERSION                                               \
-  JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
-#endif
-
-#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
-#undef JSON_HEDLEY_MSVC_VERSION_CHECK
-#endif
-#if !defined(JSON_HEDLEY_MSVC_VERSION)
-#define JSON_HEDLEY_MSVC_VERSION_CHECK(major, minor, patch) (0)
-#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
-#define JSON_HEDLEY_MSVC_VERSION_CHECK(major, minor, patch)                    \
-  (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
-#elif defined(_MSC_VER) && (_MSC_VER >= 1200)
-#define JSON_HEDLEY_MSVC_VERSION_CHECK(major, minor, patch)                    \
-  (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
-#else
-#define JSON_HEDLEY_MSVC_VERSION_CHECK(major, minor, patch)                    \
-  (_MSC_VER >= ((major * 100) + (minor)))
-#endif
-
-#if defined(JSON_HEDLEY_INTEL_VERSION)
-#undef JSON_HEDLEY_INTEL_VERSION
-#endif
-#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) &&           \
-    !defined(__ICL)
-#define JSON_HEDLEY_INTEL_VERSION                                              \
-  JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100,   \
-                             __INTEL_COMPILER_UPDATE)
-#elif defined(__INTEL_COMPILER) && !defined(__ICL)
-#define JSON_HEDLEY_INTEL_VERSION                                              \
-  JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
-#endif
-
-#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
-#undef JSON_HEDLEY_INTEL_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_INTEL_VERSION)
-#define JSON_HEDLEY_INTEL_VERSION_CHECK(major, minor, patch)                   \
-  (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-#define JSON_HEDLEY_INTEL_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
-#undef JSON_HEDLEY_INTEL_CL_VERSION
-#endif
-#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) &&           \
-    defined(__ICL)
-#define JSON_HEDLEY_INTEL_CL_VERSION                                           \
-  JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)
-#endif
-
-#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK)
-#undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
-#define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major, minor, patch)                \
-  (JSON_HEDLEY_INTEL_CL_VERSION >=                                             \
-   JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-#define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_PGI_VERSION)
-#undef JSON_HEDLEY_PGI_VERSION
-#endif
-#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) &&          \
-    defined(__PGIC_PATCHLEVEL__)
-#define JSON_HEDLEY_PGI_VERSION                                                \
-  JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
-#endif
-
-#if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
-#undef JSON_HEDLEY_PGI_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_PGI_VERSION)
-#define JSON_HEDLEY_PGI_VERSION_CHECK(major, minor, patch)                     \
-  (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-#define JSON_HEDLEY_PGI_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_SUNPRO_VERSION)
-#undef JSON_HEDLEY_SUNPRO_VERSION
-#endif
-#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
-#define JSON_HEDLEY_SUNPRO_VERSION                                             \
-  JSON_HEDLEY_VERSION_ENCODE(                                                  \
-      (((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf),          \
-      (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf),            \
-      (__SUNPRO_C & 0xf) * 10)
-#elif defined(__SUNPRO_C)
-#define JSON_HEDLEY_SUNPRO_VERSION                                             \
-  JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, \
-                             (__SUNPRO_C) & 0xf)
-#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
-#define JSON_HEDLEY_SUNPRO_VERSION                                             \
-  JSON_HEDLEY_VERSION_ENCODE(                                                  \
-      (((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf),        \
-      (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf),          \
-      (__SUNPRO_CC & 0xf) * 10)
-#elif defined(__SUNPRO_CC)
-#define JSON_HEDLEY_SUNPRO_VERSION                                             \
-  JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf,                         \
-                             (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
-#endif
-
-#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
-#undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_SUNPRO_VERSION)
-#define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major, minor, patch)                  \
-  (JSON_HEDLEY_SUNPRO_VERSION >=                                               \
-   JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-#define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
-#undef JSON_HEDLEY_EMSCRIPTEN_VERSION
-#endif
-#if defined(__EMSCRIPTEN__)
-#define JSON_HEDLEY_EMSCRIPTEN_VERSION                                         \
-  JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__,       \
-                             __EMSCRIPTEN_tiny__)
-#endif
-
-#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
-#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
-#define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major, minor, patch)              \
-  (JSON_HEDLEY_EMSCRIPTEN_VERSION >=                                           \
-   JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-#define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_ARM_VERSION)
-#undef JSON_HEDLEY_ARM_VERSION
-#endif
-#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
-#define JSON_HEDLEY_ARM_VERSION                                                \
-  JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000,                  \
-                             (__ARMCOMPILER_VERSION % 1000000) / 10000,        \
-                             (__ARMCOMPILER_VERSION % 10000) / 100)
-#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
-#define JSON_HEDLEY_ARM_VERSION                                                \
-  JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000,                        \
-                             (__ARMCC_VERSION % 1000000) / 10000,              \
-                             (__ARMCC_VERSION % 10000) / 100)
-#endif
-
-#if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
-#undef JSON_HEDLEY_ARM_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_ARM_VERSION)
-#define JSON_HEDLEY_ARM_VERSION_CHECK(major, minor, patch)                     \
-  (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-#define JSON_HEDLEY_ARM_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_IBM_VERSION)
-#undef JSON_HEDLEY_IBM_VERSION
-#endif
-#if defined(__ibmxl__)
-#define JSON_HEDLEY_IBM_VERSION                                                \
-  JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__,             \
-                             __ibmxl_modification__)
-#elif defined(__xlC__) && defined(__xlC_ver__)
-#define JSON_HEDLEY_IBM_VERSION                                                \
-  JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff,                     \
-                             (__xlC_ver__ >> 8) & 0xff)
-#elif defined(__xlC__)
-#define JSON_HEDLEY_IBM_VERSION                                                \
-  JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
-#endif
-
-#if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
-#undef JSON_HEDLEY_IBM_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_IBM_VERSION)
-#define JSON_HEDLEY_IBM_VERSION_CHECK(major, minor, patch)                     \
-  (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-#define JSON_HEDLEY_IBM_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_TI_VERSION)
-#undef JSON_HEDLEY_TI_VERSION
-#endif
-#if defined(__TI_COMPILER_VERSION__) &&                                        \
-    (defined(__TMS470__) || defined(__TI_ARM__) || defined(__MSP430__) ||      \
-     defined(__TMS320C2000__))
-#if (__TI_COMPILER_VERSION__ >= 16000000)
-#define JSON_HEDLEY_TI_VERSION                                                 \
-  JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000,                \
-                             (__TI_COMPILER_VERSION__ % 1000000) / 1000,       \
-                             (__TI_COMPILER_VERSION__ % 1000))
-#endif
-#endif
-
-#if defined(JSON_HEDLEY_TI_VERSION_CHECK)
-#undef JSON_HEDLEY_TI_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_TI_VERSION)
-#define JSON_HEDLEY_TI_VERSION_CHECK(major, minor, patch)                      \
-  (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-#define JSON_HEDLEY_TI_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
-#undef JSON_HEDLEY_TI_CL2000_VERSION
-#endif
-#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
-#define JSON_HEDLEY_TI_CL2000_VERSION                                          \
-  JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000,                \
-                             (__TI_COMPILER_VERSION__ % 1000000) / 1000,       \
-                             (__TI_COMPILER_VERSION__ % 1000))
-#endif
-
-#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
-#undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
-#define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major, minor, patch)               \
-  (JSON_HEDLEY_TI_CL2000_VERSION >=                                            \
-   JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-#define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_TI_CL430_VERSION)
-#undef JSON_HEDLEY_TI_CL430_VERSION
-#endif
-#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
-#define JSON_HEDLEY_TI_CL430_VERSION                                           \
-  JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000,                \
-                             (__TI_COMPILER_VERSION__ % 1000000) / 1000,       \
-                             (__TI_COMPILER_VERSION__ % 1000))
-#endif
-
-#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
-#undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_TI_CL430_VERSION)
-#define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major, minor, patch)                \
-  (JSON_HEDLEY_TI_CL430_VERSION >=                                             \
-   JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-#define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
-#undef JSON_HEDLEY_TI_ARMCL_VERSION
-#endif
-#if defined(__TI_COMPILER_VERSION__) &&                                        \
-    (defined(__TMS470__) || defined(__TI_ARM__))
-#define JSON_HEDLEY_TI_ARMCL_VERSION                                           \
-  JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000,                \
-                             (__TI_COMPILER_VERSION__ % 1000000) / 1000,       \
-                             (__TI_COMPILER_VERSION__ % 1000))
-#endif
-
-#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
-#undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
-#define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major, minor, patch)                \
-  (JSON_HEDLEY_TI_ARMCL_VERSION >=                                             \
-   JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-#define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
-#undef JSON_HEDLEY_TI_CL6X_VERSION
-#endif
-#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
-#define JSON_HEDLEY_TI_CL6X_VERSION                                            \
-  JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000,                \
-                             (__TI_COMPILER_VERSION__ % 1000000) / 1000,       \
-                             (__TI_COMPILER_VERSION__ % 1000))
-#endif
-
-#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
-#undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
-#define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major, minor, patch)                 \
-  (JSON_HEDLEY_TI_CL6X_VERSION >=                                              \
-   JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-#define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
-#undef JSON_HEDLEY_TI_CL7X_VERSION
-#endif
-#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
-#define JSON_HEDLEY_TI_CL7X_VERSION                                            \
-  JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000,                \
-                             (__TI_COMPILER_VERSION__ % 1000000) / 1000,       \
-                             (__TI_COMPILER_VERSION__ % 1000))
-#endif
-
-#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
-#undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
-#define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major, minor, patch)                 \
-  (JSON_HEDLEY_TI_CL7X_VERSION >=                                              \
-   JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-#define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
-#undef JSON_HEDLEY_TI_CLPRU_VERSION
-#endif
-#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
-#define JSON_HEDLEY_TI_CLPRU_VERSION                                           \
-  JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000,                \
-                             (__TI_COMPILER_VERSION__ % 1000000) / 1000,       \
-                             (__TI_COMPILER_VERSION__ % 1000))
-#endif
-
-#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
-#undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
-#define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major, minor, patch)                \
-  (JSON_HEDLEY_TI_CLPRU_VERSION >=                                             \
-   JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-#define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_CRAY_VERSION)
-#undef JSON_HEDLEY_CRAY_VERSION
-#endif
-#if defined(_CRAYC)
-#if defined(_RELEASE_PATCHLEVEL)
-#define JSON_HEDLEY_CRAY_VERSION                                               \
-  JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR,                   \
-                             _RELEASE_PATCHLEVEL)
-#else
-#define JSON_HEDLEY_CRAY_VERSION                                               \
-  JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
-#endif
-#endif
-
-#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
-#undef JSON_HEDLEY_CRAY_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_CRAY_VERSION)
-#define JSON_HEDLEY_CRAY_VERSION_CHECK(major, minor, patch)                    \
-  (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-#define JSON_HEDLEY_CRAY_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_IAR_VERSION)
-#undef JSON_HEDLEY_IAR_VERSION
-#endif
-#if defined(__IAR_SYSTEMS_ICC__)
-#if __VER__ > 1000
-#define JSON_HEDLEY_IAR_VERSION                                                \
-  JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000),   \
-                             (__VER__ % 1000))
-#else
-#define JSON_HEDLEY_IAR_VERSION                                                \
-  JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0)
-#endif
-#endif
-
-#if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
-#undef JSON_HEDLEY_IAR_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_IAR_VERSION)
-#define JSON_HEDLEY_IAR_VERSION_CHECK(major, minor, patch)                     \
-  (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-#define JSON_HEDLEY_IAR_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_TINYC_VERSION)
-#undef JSON_HEDLEY_TINYC_VERSION
-#endif
-#if defined(__TINYC__)
-#define JSON_HEDLEY_TINYC_VERSION                                              \
-  JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10,         \
-                             __TINYC__ % 100)
-#endif
-
-#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
-#undef JSON_HEDLEY_TINYC_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_TINYC_VERSION)
-#define JSON_HEDLEY_TINYC_VERSION_CHECK(major, minor, patch)                   \
-  (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-#define JSON_HEDLEY_TINYC_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_DMC_VERSION)
-#undef JSON_HEDLEY_DMC_VERSION
-#endif
-#if defined(__DMC__)
-#define JSON_HEDLEY_DMC_VERSION                                                \
-  JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
-#endif
-
-#if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
-#undef JSON_HEDLEY_DMC_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_DMC_VERSION)
-#define JSON_HEDLEY_DMC_VERSION_CHECK(major, minor, patch)                     \
-  (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-#define JSON_HEDLEY_DMC_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_COMPCERT_VERSION)
-#undef JSON_HEDLEY_COMPCERT_VERSION
-#endif
-#if defined(__COMPCERT_VERSION__)
-#define JSON_HEDLEY_COMPCERT_VERSION                                           \
-  JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000,                     \
-                             (__COMPCERT_VERSION__ / 100) % 100,               \
-                             __COMPCERT_VERSION__ % 100)
-#endif
-
-#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
-#undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_COMPCERT_VERSION)
-#define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major, minor, patch)                \
-  (JSON_HEDLEY_COMPCERT_VERSION >=                                             \
-   JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-#define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_PELLES_VERSION)
-#undef JSON_HEDLEY_PELLES_VERSION
-#endif
-#if defined(__POCC__)
-#define JSON_HEDLEY_PELLES_VERSION                                             \
-  JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
-#endif
-
-#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
-#undef JSON_HEDLEY_PELLES_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_PELLES_VERSION)
-#define JSON_HEDLEY_PELLES_VERSION_CHECK(major, minor, patch)                  \
-  (JSON_HEDLEY_PELLES_VERSION >=                                               \
-   JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-#define JSON_HEDLEY_PELLES_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_MCST_LCC_VERSION)
-#undef JSON_HEDLEY_MCST_LCC_VERSION
-#endif
-#if defined(__LCC__) && defined(__LCC_MINOR__)
-#define JSON_HEDLEY_MCST_LCC_VERSION                                           \
-  JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__)
-#endif
-
-#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK)
-#undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_MCST_LCC_VERSION)
-#define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major, minor, patch)                \
-  (JSON_HEDLEY_MCST_LCC_VERSION >=                                             \
-   JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-#define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_GCC_VERSION)
-#undef JSON_HEDLEY_GCC_VERSION
-#endif
-#if defined(JSON_HEDLEY_GNUC_VERSION) && !defined(__clang__) &&                \
-    !defined(JSON_HEDLEY_INTEL_VERSION) &&                                     \
-    !defined(JSON_HEDLEY_PGI_VERSION) && !defined(JSON_HEDLEY_ARM_VERSION) &&  \
-    !defined(JSON_HEDLEY_CRAY_VERSION) && !defined(JSON_HEDLEY_TI_VERSION) &&  \
-    !defined(JSON_HEDLEY_TI_ARMCL_VERSION) &&                                  \
-    !defined(JSON_HEDLEY_TI_CL430_VERSION) &&                                  \
-    !defined(JSON_HEDLEY_TI_CL2000_VERSION) &&                                 \
-    !defined(JSON_HEDLEY_TI_CL6X_VERSION) &&                                   \
-    !defined(JSON_HEDLEY_TI_CL7X_VERSION) &&                                   \
-    !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && !defined(__COMPCERT__) &&        \
-    !defined(JSON_HEDLEY_MCST_LCC_VERSION)
-#define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
-#endif
-
-#if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
-#undef JSON_HEDLEY_GCC_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_GCC_VERSION)
-#define JSON_HEDLEY_GCC_VERSION_CHECK(major, minor, patch)                     \
-  (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
-#define JSON_HEDLEY_GCC_VERSION_CHECK(major, minor, patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
-#undef JSON_HEDLEY_HAS_ATTRIBUTE
-#endif
-#if defined(__has_attribute) && ((!defined(JSON_HEDLEY_IAR_VERSION) ||         \
-                                  JSON_HEDLEY_IAR_VERSION_CHECK(8, 5, 9)))
-#define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
-#else
-#define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
-#endif
-
-#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
-#undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
-#endif
-#if defined(__has_attribute)
-#define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute, major, minor, patch)         \
-  JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
-#else
-#define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute, major, minor, patch)         \
-  JSON_HEDLEY_GNUC_VERSION_CHECK(major, minor, patch)
-#endif
-
-#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
-#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
-#endif
-#if defined(__has_attribute)
-#define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute, major, minor, patch)          \
-  JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
-#else
-#define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute, major, minor, patch)          \
-  JSON_HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
-#endif
-
-#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
-#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
-#endif
-#if defined(__has_cpp_attribute) && defined(__cplusplus) &&                    \
-    (!defined(JSON_HEDLEY_SUNPRO_VERSION) ||                                   \
-     JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 15, 0))
-#define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
-#else
-#define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
-#endif
-
-#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
-#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
-#endif
-#if !defined(__cplusplus) || !defined(__has_cpp_attribute)
-#define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns, attribute) (0)
-#elif !defined(JSON_HEDLEY_PGI_VERSION) &&                                     \
-    !defined(JSON_HEDLEY_IAR_VERSION) &&                                       \
-    (!defined(JSON_HEDLEY_SUNPRO_VERSION) ||                                   \
-     JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 15, 0)) &&                            \
-    (!defined(JSON_HEDLEY_MSVC_VERSION) ||                                     \
-     JSON_HEDLEY_MSVC_VERSION_CHECK(19, 20, 0))
-#define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns, attribute)                        \
-  JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
-#else
-#define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns, attribute) (0)
-#endif
-
-#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
-#undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
-#endif
-#if defined(__has_cpp_attribute) && defined(__cplusplus)
-#define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute, major, minor, patch)     \
-  __has_cpp_attribute(attribute)
-#else
-#define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute, major, minor, patch)     \
-  JSON_HEDLEY_GNUC_VERSION_CHECK(major, minor, patch)
-#endif
-
-#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
-#undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
-#endif
-#if defined(__has_cpp_attribute) && defined(__cplusplus)
-#define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute, major, minor, patch)      \
-  __has_cpp_attribute(attribute)
-#else
-#define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute, major, minor, patch)      \
-  JSON_HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
-#endif
-
-#if defined(JSON_HEDLEY_HAS_BUILTIN)
-#undef JSON_HEDLEY_HAS_BUILTIN
-#endif
-#if defined(__has_builtin)
-#define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
-#else
-#define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
-#endif
-
-#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
-#undef JSON_HEDLEY_GNUC_HAS_BUILTIN
-#endif
-#if defined(__has_builtin)
-#define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin, major, minor, patch)             \
-  __has_builtin(builtin)
-#else
-#define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin, major, minor, patch)             \
-  JSON_HEDLEY_GNUC_VERSION_CHECK(major, minor, patch)
-#endif
-
-#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
-#undef JSON_HEDLEY_GCC_HAS_BUILTIN
-#endif
-#if defined(__has_builtin)
-#define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin, major, minor, patch)              \
-  __has_builtin(builtin)
-#else
-#define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin, major, minor, patch)              \
-  JSON_HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
-#endif
-
-#if defined(JSON_HEDLEY_HAS_FEATURE)
-#undef JSON_HEDLEY_HAS_FEATURE
-#endif
-#if defined(__has_feature)
-#define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
-#else
-#define JSON_HEDLEY_HAS_FEATURE(feature) (0)
-#endif
-
-#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
-#undef JSON_HEDLEY_GNUC_HAS_FEATURE
-#endif
-#if defined(__has_feature)
-#define JSON_HEDLEY_GNUC_HAS_FEATURE(feature, major, minor, patch)             \
-  __has_feature(feature)
-#else
-#define JSON_HEDLEY_GNUC_HAS_FEATURE(feature, major, minor, patch)             \
-  JSON_HEDLEY_GNUC_VERSION_CHECK(major, minor, patch)
-#endif
-
-#if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
-#undef JSON_HEDLEY_GCC_HAS_FEATURE
-#endif
-#if defined(__has_feature)
-#define JSON_HEDLEY_GCC_HAS_FEATURE(feature, major, minor, patch)              \
-  __has_feature(feature)
-#else
-#define JSON_HEDLEY_GCC_HAS_FEATURE(feature, major, minor, patch)              \
-  JSON_HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
-#endif
-
-#if defined(JSON_HEDLEY_HAS_EXTENSION)
-#undef JSON_HEDLEY_HAS_EXTENSION
-#endif
-#if defined(__has_extension)
-#define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
-#else
-#define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
-#endif
-
-#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
-#undef JSON_HEDLEY_GNUC_HAS_EXTENSION
-#endif
-#if defined(__has_extension)
-#define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension, major, minor, patch)         \
-  __has_extension(extension)
-#else
-#define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension, major, minor, patch)         \
-  JSON_HEDLEY_GNUC_VERSION_CHECK(major, minor, patch)
-#endif
-
-#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
-#undef JSON_HEDLEY_GCC_HAS_EXTENSION
-#endif
-#if defined(__has_extension)
-#define JSON_HEDLEY_GCC_HAS_EXTENSION(extension, major, minor, patch)          \
-  __has_extension(extension)
-#else
-#define JSON_HEDLEY_GCC_HAS_EXTENSION(extension, major, minor, patch)          \
-  JSON_HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
-#endif
-
-#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
-#undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
-#endif
-#if defined(__has_declspec_attribute)
-#define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)                          \
-  __has_declspec_attribute(attribute)
-#else
-#define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
-#endif
-
-#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
-#undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
-#endif
-#if defined(__has_declspec_attribute)
-#define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute, major, minor,       \
-                                                patch)                         \
-  __has_declspec_attribute(attribute)
-#else
-#define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute, major, minor,       \
-                                                patch)                         \
-  JSON_HEDLEY_GNUC_VERSION_CHECK(major, minor, patch)
-#endif
-
-#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
-#undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
-#endif
-#if defined(__has_declspec_attribute)
-#define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute, major, minor, patch) \
-  __has_declspec_attribute(attribute)
-#else
-#define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute, major, minor, patch) \
-  JSON_HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
-#endif
-
-#if defined(JSON_HEDLEY_HAS_WARNING)
-#undef JSON_HEDLEY_HAS_WARNING
-#endif
-#if defined(__has_warning)
-#define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
-#else
-#define JSON_HEDLEY_HAS_WARNING(warning) (0)
-#endif
-
-#if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
-#undef JSON_HEDLEY_GNUC_HAS_WARNING
-#endif
-#if defined(__has_warning)
-#define JSON_HEDLEY_GNUC_HAS_WARNING(warning, major, minor, patch)             \
-  __has_warning(warning)
-#else
-#define JSON_HEDLEY_GNUC_HAS_WARNING(warning, major, minor, patch)             \
-  JSON_HEDLEY_GNUC_VERSION_CHECK(major, minor, patch)
-#endif
-
-#if defined(JSON_HEDLEY_GCC_HAS_WARNING)
-#undef JSON_HEDLEY_GCC_HAS_WARNING
-#endif
-#if defined(__has_warning)
-#define JSON_HEDLEY_GCC_HAS_WARNING(warning, major, minor, patch)              \
-  __has_warning(warning)
-#else
-#define JSON_HEDLEY_GCC_HAS_WARNING(warning, major, minor, patch)              \
-  JSON_HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
-#endif
-
-#if (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) ||            \
-    defined(__clang__) || JSON_HEDLEY_GCC_VERSION_CHECK(3, 0, 0) ||            \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                               \
-    JSON_HEDLEY_IAR_VERSION_CHECK(8, 0, 0) ||                                  \
-    JSON_HEDLEY_PGI_VERSION_CHECK(18, 4, 0) ||                                 \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) ||                                  \
-    JSON_HEDLEY_TI_VERSION_CHECK(15, 12, 0) ||                                 \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4, 7, 0) ||                             \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(2, 0, 1) ||                             \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 1, 0) ||                            \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 0, 0) ||                              \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) ||                              \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) ||                             \
-    JSON_HEDLEY_CRAY_VERSION_CHECK(5, 0, 0) ||                                 \
-    JSON_HEDLEY_TINYC_VERSION_CHECK(0, 9, 17) ||                               \
-    JSON_HEDLEY_SUNPRO_VERSION_CHECK(8, 0, 0) ||                               \
-    (JSON_HEDLEY_IBM_VERSION_CHECK(10, 1, 0) &&                                \
-     defined(__C99_PRAGMA_OPERATOR))
-#define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15, 0, 0)
-#define JSON_HEDLEY_PRAGMA(value) __pragma(value)
-#else
-#define JSON_HEDLEY_PRAGMA(value)
-#endif
-
-#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
-#undef JSON_HEDLEY_DIAGNOSTIC_PUSH
-#endif
-#if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
-#undef JSON_HEDLEY_DIAGNOSTIC_POP
-#endif
-#if defined(__clang__)
-#define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
-#define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
-#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
-#define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
-#elif JSON_HEDLEY_GCC_VERSION_CHECK(4, 6, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
-#define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15, 0, 0) ||                              \
-    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
-#define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
-#elif JSON_HEDLEY_ARM_VERSION_CHECK(5, 6, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
-#define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
-#elif JSON_HEDLEY_TI_VERSION_CHECK(15, 12, 0) ||                               \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) ||                             \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 4, 0) ||                             \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8, 1, 0) ||                              \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) ||                              \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
-#define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
-#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2, 90, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
-#define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
-#else
-#define JSON_HEDLEY_DIAGNOSTIC_PUSH
-#define JSON_HEDLEY_DIAGNOSTIC_POP
-#endif
-
-/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
-   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
-#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
-#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
-#endif
-#if defined(__cplusplus)
-#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
-#if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
-#if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions")
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr)                 \
-  JSON_HEDLEY_DIAGNOSTIC_PUSH                                                  \
-  _Pragma("clang diagnostic ignored \"-Wc++98-compat\"")                       \
-      _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"")               \
-          _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"")           \
-              xpr JSON_HEDLEY_DIAGNOSTIC_POP
-#else
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr)                 \
-  JSON_HEDLEY_DIAGNOSTIC_PUSH                                                  \
-  _Pragma("clang diagnostic ignored \"-Wc++98-compat\"")                       \
-      _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"")               \
-          xpr JSON_HEDLEY_DIAGNOSTIC_POP
-#endif
-#else
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr)                 \
-  JSON_HEDLEY_DIAGNOSTIC_PUSH                                                  \
-  _Pragma("clang diagnostic ignored \"-Wc++98-compat\"")                       \
-      xpr JSON_HEDLEY_DIAGNOSTIC_POP
-#endif
-#endif
-#endif
-#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
-#endif
-
-#if defined(JSON_HEDLEY_CONST_CAST)
-#undef JSON_HEDLEY_CONST_CAST
-#endif
-#if defined(__cplusplus)
-#define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
-#elif JSON_HEDLEY_HAS_WARNING("-Wcast-qual") ||                                \
-    JSON_HEDLEY_GCC_VERSION_CHECK(4, 6, 0) ||                                  \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
-#define JSON_HEDLEY_CONST_CAST(T, expr)                                        \
-  (__extension__({                                                             \
-    JSON_HEDLEY_DIAGNOSTIC_PUSH                                                \
-    JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL((T)(expr));                       \
-    JSON_HEDLEY_DIAGNOSTIC_POP                                                 \
-  }))
-#else
-#define JSON_HEDLEY_CONST_CAST(T, expr) ((T)(expr))
-#endif
-
-#if defined(JSON_HEDLEY_REINTERPRET_CAST)
-#undef JSON_HEDLEY_REINTERPRET_CAST
-#endif
-#if defined(__cplusplus)
-#define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
-#else
-#define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T)(expr))
-#endif
-
-#if defined(JSON_HEDLEY_STATIC_CAST)
-#undef JSON_HEDLEY_STATIC_CAST
-#endif
-#if defined(__cplusplus)
-#define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
-#else
-#define JSON_HEDLEY_STATIC_CAST(T, expr) ((T)(expr))
-#endif
-
-#if defined(JSON_HEDLEY_CPP_CAST)
-#undef JSON_HEDLEY_CPP_CAST
-#endif
-#if defined(__cplusplus)
-#if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
-#define JSON_HEDLEY_CPP_CAST(T, expr)                                          \
-  JSON_HEDLEY_DIAGNOSTIC_PUSH                                                  \
-  _Pragma("clang diagnostic ignored \"-Wold-style-cast\"")((T)(expr))          \
-      JSON_HEDLEY_DIAGNOSTIC_POP
-#elif JSON_HEDLEY_IAR_VERSION_CHECK(8, 3, 0)
-#define JSON_HEDLEY_CPP_CAST(T, expr)                                          \
-  JSON_HEDLEY_DIAGNOSTIC_PUSH                                                  \
-  _Pragma("diag_suppress=Pe137") JSON_HEDLEY_DIAGNOSTIC_POP
-#else
-#define JSON_HEDLEY_CPP_CAST(T, expr) ((T)(expr))
-#endif
-#else
-#define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
-#endif
-
-#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
-#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
-#endif
-#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED                              \
-  _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
-#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED                              \
-  _Pragma("warning(disable:1478 1786)")
-#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED                              \
-  __pragma(warning(disable : 1478 1786))
-#elif JSON_HEDLEY_PGI_VERSION_CHECK(20, 7, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED                              \
-  _Pragma("diag_suppress 1215,1216,1444,1445")
-#elif JSON_HEDLEY_PGI_VERSION_CHECK(17, 10, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED                              \
-  _Pragma("diag_suppress 1215,1444")
-#elif JSON_HEDLEY_GCC_VERSION_CHECK(4, 3, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED                              \
-  _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15, 0, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED                              \
-  __pragma(warning(disable : 4996))
-#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED                              \
-  _Pragma("diag_suppress 1215,1444")
-#elif JSON_HEDLEY_TI_VERSION_CHECK(15, 12, 0) ||                               \
-    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) &&                            \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) ||                             \
-    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) &&                           \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) ||                            \
-    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) &&                            \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) ||                             \
-    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) &&                             \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) ||                              \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) ||                              \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED                              \
-  _Pragma("diag_suppress 1291,1718")
-#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 13, 0) && !defined(__cplusplus)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED                              \
-  _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
-#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 13, 0) && defined(__cplusplus)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED                              \
-  _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
-#elif JSON_HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED                              \
-  _Pragma("diag_suppress=Pe1444,Pe1215")
-#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2, 90, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
-#else
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
-#endif
-
-#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
-#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
-#endif
-#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS                         \
-  _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
-#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS                         \
-  _Pragma("warning(disable:161)")
-#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS                         \
-  __pragma(warning(disable : 161))
-#elif JSON_HEDLEY_PGI_VERSION_CHECK(17, 10, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS                         \
-  _Pragma("diag_suppress 1675")
-#elif JSON_HEDLEY_GCC_VERSION_CHECK(4, 3, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS                         \
-  _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15, 0, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS                         \
-  __pragma(warning(disable : 4068))
-#elif JSON_HEDLEY_TI_VERSION_CHECK(16, 9, 0) ||                                \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8, 0, 0) ||                              \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) ||                              \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 3, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS                         \
-  _Pragma("diag_suppress 163")
-#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8, 0, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS                         \
-  _Pragma("diag_suppress 163")
-#elif JSON_HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS                         \
-  _Pragma("diag_suppress=Pe161")
-#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS                         \
-  _Pragma("diag_suppress 161")
-#else
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
-#endif
-
-#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
-#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
-#endif
-#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES                  \
-  _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
-#elif JSON_HEDLEY_GCC_VERSION_CHECK(4, 6, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES                  \
-  _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
-#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17, 0, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES                  \
-  _Pragma("warning(disable:1292)")
-#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES                  \
-  __pragma(warning(disable : 1292))
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19, 0, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES                  \
-  __pragma(warning(disable : 5030))
-#elif JSON_HEDLEY_PGI_VERSION_CHECK(20, 7, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES                  \
-  _Pragma("diag_suppress 1097,1098")
-#elif JSON_HEDLEY_PGI_VERSION_CHECK(17, 10, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES                  \
-  _Pragma("diag_suppress 1097")
-#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 14, 0) && defined(__cplusplus)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES                  \
-  _Pragma("error_messages(off,attrskipunsup)")
-#elif JSON_HEDLEY_TI_VERSION_CHECK(18, 1, 0) ||                                \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8, 3, 0) ||                              \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES                  \
-  _Pragma("diag_suppress 1173")
-#elif JSON_HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES                  \
-  _Pragma("diag_suppress=Pe1097")
-#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES                  \
-  _Pragma("diag_suppress 1097")
-#else
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
-#endif
-
-#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
-#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
-#endif
-#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL                               \
-  _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
-#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL                               \
-  _Pragma("warning(disable:2203 2331)")
-#elif JSON_HEDLEY_GCC_VERSION_CHECK(3, 0, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL                               \
-  _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
-#else
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
-#endif
-
-#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION)
-#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
-#endif
-#if JSON_HEDLEY_HAS_WARNING("-Wunused-function")
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION                         \
-  _Pragma("clang diagnostic ignored \"-Wunused-function\"")
-#elif JSON_HEDLEY_GCC_VERSION_CHECK(3, 4, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION                         \
-  _Pragma("GCC diagnostic ignored \"-Wunused-function\"")
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1, 0, 0)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION                         \
-  __pragma(warning(disable : 4505))
-#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION                         \
-  _Pragma("diag_suppress 3142")
-#else
-#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
-#endif
-
-#if defined(JSON_HEDLEY_DEPRECATED)
-#undef JSON_HEDLEY_DEPRECATED
-#endif
-#if defined(JSON_HEDLEY_DEPRECATED_FOR)
-#undef JSON_HEDLEY_DEPRECATED_FOR
-#endif
-#if JSON_HEDLEY_MSVC_VERSION_CHECK(14, 0, 0) ||                                \
-    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
-#define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " #since))
-#define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)                         \
-  __declspec(deprecated("Since " #since "; use " #replacement))
-#elif (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) &&         \
-       !defined(JSON_HEDLEY_IAR_VERSION)) ||                                   \
-    JSON_HEDLEY_GCC_VERSION_CHECK(4, 5, 0) ||                                  \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                               \
-    JSON_HEDLEY_ARM_VERSION_CHECK(5, 6, 0) ||                                  \
-    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 13, 0) ||                              \
-    JSON_HEDLEY_PGI_VERSION_CHECK(17, 10, 0) ||                                \
-    JSON_HEDLEY_TI_VERSION_CHECK(18, 1, 0) ||                                  \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18, 1, 0) ||                            \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8, 3, 0) ||                              \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) ||                              \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 3, 0) ||                             \
-    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
-#define JSON_HEDLEY_DEPRECATED(since)                                          \
-  __attribute__((__deprecated__("Since " #since)))
-#define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)                         \
-  __attribute__((__deprecated__("Since " #since "; use " #replacement)))
-#elif defined(__cplusplus) && (__cplusplus >= 201402L)
-#define JSON_HEDLEY_DEPRECATED(since)                                          \
-  JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(                           \
-      [[deprecated("Since " #since)]])
-#define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)                         \
-  JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(                           \
-      [[deprecated("Since " #since "; use " #replacement)]])
-#elif JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) ||                                 \
-    JSON_HEDLEY_GCC_VERSION_CHECK(3, 1, 0) ||                                  \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) ||                                  \
-    JSON_HEDLEY_TI_VERSION_CHECK(15, 12, 0) ||                                 \
-    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) &&                            \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) ||                             \
-    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) &&                           \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) ||                            \
-    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) &&                            \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) ||                             \
-    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) &&                             \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) ||                              \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) ||                              \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) ||                             \
-    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10) ||                           \
-    JSON_HEDLEY_IAR_VERSION_CHECK(8, 10, 0)
-#define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
-#define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)                         \
-  __attribute__((__deprecated__))
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(13, 10, 0) ||                             \
-    JSON_HEDLEY_PELLES_VERSION_CHECK(6, 50, 0) ||                              \
-    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
-#define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
-#define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
-#elif JSON_HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
-#define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
-#define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
-#else
-#define JSON_HEDLEY_DEPRECATED(since)
-#define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
-#endif
-
-#if defined(JSON_HEDLEY_UNAVAILABLE)
-#undef JSON_HEDLEY_UNAVAILABLE
-#endif
-#if JSON_HEDLEY_HAS_ATTRIBUTE(warning) ||                                      \
-    JSON_HEDLEY_GCC_VERSION_CHECK(4, 3, 0) ||                                  \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                               \
-    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
-#define JSON_HEDLEY_UNAVAILABLE(available_since)                               \
-  __attribute__((__warning__("Not available until " #available_since)))
-#else
-#define JSON_HEDLEY_UNAVAILABLE(available_since)
-#endif
-
-#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
-#undef JSON_HEDLEY_WARN_UNUSED_RESULT
-#endif
-#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)
-#undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
-#endif
-#if JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) ||                           \
-    JSON_HEDLEY_GCC_VERSION_CHECK(3, 4, 0) ||                                  \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                               \
-    JSON_HEDLEY_TI_VERSION_CHECK(15, 12, 0) ||                                 \
-    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) &&                            \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) ||                             \
-    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) &&                           \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) ||                            \
-    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) &&                            \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) ||                             \
-    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) &&                             \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) ||                              \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) ||                              \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) ||                             \
-    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 15, 0) && defined(__cplusplus)) ||    \
-    JSON_HEDLEY_PGI_VERSION_CHECK(17, 10, 0) ||                                \
-    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
-#define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
-#define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)                                \
-  __attribute__((__warn_unused_result__))
-#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
-#define JSON_HEDLEY_WARN_UNUSED_RESULT                                         \
-  JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
-#define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)                                \
-  JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
-#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
-#define JSON_HEDLEY_WARN_UNUSED_RESULT                                         \
-  JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
-#define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)                                \
-  JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
-#elif defined(_Check_return_) /* SAL */
-#define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
-#define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
-#else
-#define JSON_HEDLEY_WARN_UNUSED_RESULT
-#define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
-#endif
-
-#if defined(JSON_HEDLEY_SENTINEL)
-#undef JSON_HEDLEY_SENTINEL
-#endif
-#if JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) ||                                     \
-    JSON_HEDLEY_GCC_VERSION_CHECK(4, 0, 0) ||                                  \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                               \
-    JSON_HEDLEY_ARM_VERSION_CHECK(5, 4, 0) ||                                  \
-    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
-#define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
-#else
-#define JSON_HEDLEY_SENTINEL(position)
-#endif
-
-#if defined(JSON_HEDLEY_NO_RETURN)
-#undef JSON_HEDLEY_NO_RETURN
-#endif
-#if JSON_HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
-#define JSON_HEDLEY_NO_RETURN __noreturn
-#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                             \
-    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
-#define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
-#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
-#define JSON_HEDLEY_NO_RETURN _Noreturn
-#elif defined(__cplusplus) && (__cplusplus >= 201103L)
-#define JSON_HEDLEY_NO_RETURN                                                  \
-  JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
-#elif JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) ||                                   \
-    JSON_HEDLEY_GCC_VERSION_CHECK(3, 2, 0) ||                                  \
-    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) ||                              \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) ||                                  \
-    JSON_HEDLEY_IBM_VERSION_CHECK(10, 1, 0) ||                                 \
-    JSON_HEDLEY_TI_VERSION_CHECK(15, 12, 0) ||                                 \
-    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) &&                            \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) ||                             \
-    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) &&                           \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) ||                            \
-    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) &&                            \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) ||                             \
-    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) &&                             \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) ||                              \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) ||                              \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) ||                             \
-    JSON_HEDLEY_IAR_VERSION_CHECK(8, 10, 0)
-#define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
-#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0)
-#define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(13, 10, 0) ||                             \
-    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
-#define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
-#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6, 0, 0) && defined(__cplusplus)
-#define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
-#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3, 2, 0)
-#define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
-#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9, 0, 0)
-#define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
-#else
-#define JSON_HEDLEY_NO_RETURN
-#endif
-
-#if defined(JSON_HEDLEY_NO_ESCAPE)
-#undef JSON_HEDLEY_NO_ESCAPE
-#endif
-#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
-#define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
-#else
-#define JSON_HEDLEY_NO_ESCAPE
-#endif
-
-#if defined(JSON_HEDLEY_UNREACHABLE)
-#undef JSON_HEDLEY_UNREACHABLE
-#endif
-#if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
-#undef JSON_HEDLEY_UNREACHABLE_RETURN
-#endif
-#if defined(JSON_HEDLEY_ASSUME)
-#undef JSON_HEDLEY_ASSUME
-#endif
-#if JSON_HEDLEY_MSVC_VERSION_CHECK(13, 10, 0) ||                               \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                               \
-    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
-#define JSON_HEDLEY_ASSUME(expr) __assume(expr)
-#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
-#define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
-#elif JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 2, 0) ||                          \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4, 0, 0)
-#if defined(__cplusplus)
-#define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
-#else
-#define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
-#endif
-#endif
-#if (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) &&                         \
-     (!defined(JSON_HEDLEY_ARM_VERSION))) ||                                   \
-    JSON_HEDLEY_GCC_VERSION_CHECK(4, 5, 0) ||                                  \
-    JSON_HEDLEY_PGI_VERSION_CHECK(18, 10, 0) ||                                \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                               \
-    JSON_HEDLEY_IBM_VERSION_CHECK(13, 1, 5) ||                                 \
-    JSON_HEDLEY_CRAY_VERSION_CHECK(10, 0, 0) ||                                \
-    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
-#define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
-#elif defined(JSON_HEDLEY_ASSUME)
-#define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
-#endif
-#if !defined(JSON_HEDLEY_ASSUME)
-#if defined(JSON_HEDLEY_UNREACHABLE)
-#define JSON_HEDLEY_ASSUME(expr)                                               \
-  JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
-#else
-#define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
-#endif
-#endif
-#if defined(JSON_HEDLEY_UNREACHABLE)
-#if JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 2, 0) ||                            \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4, 0, 0)
-#define JSON_HEDLEY_UNREACHABLE_RETURN(value)                                  \
-  return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
-#else
-#define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
-#endif
-#else
-#define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
-#endif
-#if !defined(JSON_HEDLEY_UNREACHABLE)
-#define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
-#endif
-
-JSON_HEDLEY_DIAGNOSTIC_PUSH
-#if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
-#pragma clang diagnostic ignored "-Wpedantic"
-#endif
-#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
-#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
-#endif
-#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros", 4, 0, 0)
-#if defined(__clang__)
-#pragma clang diagnostic ignored "-Wvariadic-macros"
-#elif defined(JSON_HEDLEY_GCC_VERSION)
-#pragma GCC diagnostic ignored "-Wvariadic-macros"
-#endif
-#endif
-#if defined(JSON_HEDLEY_NON_NULL)
-#undef JSON_HEDLEY_NON_NULL
-#endif
-#if JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) ||                                      \
-    JSON_HEDLEY_GCC_VERSION_CHECK(3, 3, 0) ||                                  \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                               \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0)
-#define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
-#else
-#define JSON_HEDLEY_NON_NULL(...)
-#endif
-JSON_HEDLEY_DIAGNOSTIC_POP
-
-#if defined(JSON_HEDLEY_PRINTF_FORMAT)
-#undef JSON_HEDLEY_PRINTF_FORMAT
-#endif
-#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format, 4, 4, 0) &&  \
-    !defined(__USE_MINGW_ANSI_STDIO)
-#define JSON_HEDLEY_PRINTF_FORMAT(string_idx, first_to_check)                  \
-  __attribute__((__format__(ms_printf, string_idx, first_to_check)))
-#elif defined(__MINGW32__) &&                                                  \
-    JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format, 4, 4, 0) &&                          \
-    defined(__USE_MINGW_ANSI_STDIO)
-#define JSON_HEDLEY_PRINTF_FORMAT(string_idx, first_to_check)                  \
-  __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
-#elif JSON_HEDLEY_HAS_ATTRIBUTE(format) ||                                     \
-    JSON_HEDLEY_GCC_VERSION_CHECK(3, 1, 0) ||                                  \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                               \
-    JSON_HEDLEY_ARM_VERSION_CHECK(5, 6, 0) ||                                  \
-    JSON_HEDLEY_IBM_VERSION_CHECK(10, 1, 0) ||                                 \
-    JSON_HEDLEY_TI_VERSION_CHECK(15, 12, 0) ||                                 \
-    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) &&                            \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) ||                             \
-    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) &&                           \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) ||                            \
-    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) &&                            \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) ||                             \
-    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) &&                             \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) ||                              \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) ||                              \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) ||                             \
-    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
-#define JSON_HEDLEY_PRINTF_FORMAT(string_idx, first_to_check)                  \
-  __attribute__((__format__(__printf__, string_idx, first_to_check)))
-#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6, 0, 0)
-#define JSON_HEDLEY_PRINTF_FORMAT(string_idx, first_to_check)                  \
-  __declspec(vaformat(printf, string_idx, first_to_check))
-#else
-#define JSON_HEDLEY_PRINTF_FORMAT(string_idx, first_to_check)
-#endif
-
-#if defined(JSON_HEDLEY_CONSTEXPR)
-#undef JSON_HEDLEY_CONSTEXPR
-#endif
-#if defined(__cplusplus)
-#if __cplusplus >= 201103L
-#define JSON_HEDLEY_CONSTEXPR                                                  \
-  JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
-#endif
-#endif
-#if !defined(JSON_HEDLEY_CONSTEXPR)
-#define JSON_HEDLEY_CONSTEXPR
-#endif
-
-#if defined(JSON_HEDLEY_PREDICT)
-#undef JSON_HEDLEY_PREDICT
-#endif
-#if defined(JSON_HEDLEY_LIKELY)
-#undef JSON_HEDLEY_LIKELY
-#endif
-#if defined(JSON_HEDLEY_UNLIKELY)
-#undef JSON_HEDLEY_UNLIKELY
-#endif
-#if defined(JSON_HEDLEY_UNPREDICTABLE)
-#undef JSON_HEDLEY_UNPREDICTABLE
-#endif
-#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
-#define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
-#endif
-#if (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) &&             \
-     !defined(JSON_HEDLEY_PGI_VERSION)) ||                                     \
-    JSON_HEDLEY_GCC_VERSION_CHECK(9, 0, 0) ||                                  \
-    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
-#define JSON_HEDLEY_PREDICT(expr, value, probability)                          \
-  __builtin_expect_with_probability((expr), (value), (probability))
-#define JSON_HEDLEY_PREDICT_TRUE(expr, probability)                            \
-  __builtin_expect_with_probability(!!(expr), 1, (probability))
-#define JSON_HEDLEY_PREDICT_FALSE(expr, probability)                           \
-  __builtin_expect_with_probability(!!(expr), 0, (probability))
-#define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1)
-#define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
-#elif (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) &&                            \
-       !defined(JSON_HEDLEY_INTEL_CL_VERSION)) ||                              \
-    JSON_HEDLEY_GCC_VERSION_CHECK(3, 0, 0) ||                                  \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                               \
-    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 15, 0) && defined(__cplusplus)) ||    \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) ||                                  \
-    JSON_HEDLEY_IBM_VERSION_CHECK(10, 1, 0) ||                                 \
-    JSON_HEDLEY_TI_VERSION_CHECK(15, 12, 0) ||                                 \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4, 7, 0) ||                             \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(3, 1, 0) ||                             \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 1, 0) ||                            \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6, 1, 0) ||                              \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) ||                              \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) ||                             \
-    JSON_HEDLEY_TINYC_VERSION_CHECK(0, 9, 27) ||                               \
-    JSON_HEDLEY_CRAY_VERSION_CHECK(8, 1, 0) ||                                 \
-    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
-#define JSON_HEDLEY_PREDICT(expr, expected, probability)                       \
-  (((probability) >= 0.9) ? __builtin_expect((expr), (expected))               \
-                          : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
-#define JSON_HEDLEY_PREDICT_TRUE(expr, probability)                            \
-  (__extension__({                                                             \
-    double hedley_probability_ = (probability);                                \
-    ((hedley_probability_ >= 0.9)                                              \
-         ? __builtin_expect(!!(expr), 1)                                       \
-         : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0)       \
-                                         : !!(expr)));                         \
-  }))
-#define JSON_HEDLEY_PREDICT_FALSE(expr, probability)                           \
-  (__extension__({                                                             \
-    double hedley_probability_ = (probability);                                \
-    ((hedley_probability_ >= 0.9)                                              \
-         ? __builtin_expect(!!(expr), 0)                                       \
-         : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1)       \
-                                         : !!(expr)));                         \
-  }))
-#define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1)
-#define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
-#else
-#define JSON_HEDLEY_PREDICT(expr, expected, probability)                       \
-  (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))
-#define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
-#define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
-#define JSON_HEDLEY_LIKELY(expr) (!!(expr))
-#define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
-#endif
-#if !defined(JSON_HEDLEY_UNPREDICTABLE)
-#define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
-#endif
-
-#if defined(JSON_HEDLEY_MALLOC)
-#undef JSON_HEDLEY_MALLOC
-#endif
-#if JSON_HEDLEY_HAS_ATTRIBUTE(malloc) ||                                       \
-    JSON_HEDLEY_GCC_VERSION_CHECK(3, 1, 0) ||                                  \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                               \
-    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) ||                              \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) ||                                  \
-    JSON_HEDLEY_IBM_VERSION_CHECK(12, 1, 0) ||                                 \
-    JSON_HEDLEY_TI_VERSION_CHECK(15, 12, 0) ||                                 \
-    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) &&                            \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) ||                             \
-    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) &&                           \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) ||                            \
-    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) &&                            \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) ||                             \
-    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) &&                             \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) ||                              \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) ||                              \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) ||                             \
-    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
-#define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
-#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0)
-#define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(14, 0, 0) ||                              \
-    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
-#define JSON_HEDLEY_MALLOC __declspec(restrict)
-#else
-#define JSON_HEDLEY_MALLOC
-#endif
-
-#if defined(JSON_HEDLEY_PURE)
-#undef JSON_HEDLEY_PURE
-#endif
-#if JSON_HEDLEY_HAS_ATTRIBUTE(pure) ||                                         \
-    JSON_HEDLEY_GCC_VERSION_CHECK(2, 96, 0) ||                                 \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                               \
-    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) ||                              \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) ||                                  \
-    JSON_HEDLEY_IBM_VERSION_CHECK(10, 1, 0) ||                                 \
-    JSON_HEDLEY_TI_VERSION_CHECK(15, 12, 0) ||                                 \
-    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) &&                            \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) ||                             \
-    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) &&                           \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) ||                            \
-    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) &&                            \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) ||                             \
-    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) &&                             \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) ||                              \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) ||                              \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) ||                             \
-    JSON_HEDLEY_PGI_VERSION_CHECK(17, 10, 0) ||                                \
-    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
-#define JSON_HEDLEY_PURE __attribute__((__pure__))
-#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0)
-#define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
-#elif defined(__cplusplus) && (JSON_HEDLEY_TI_CL430_VERSION_CHECK(2, 0, 1) ||  \
-                               JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4, 0, 0) ||   \
-                               JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0))
-#define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
-#else
-#define JSON_HEDLEY_PURE
-#endif
-
-#if defined(JSON_HEDLEY_CONST)
-#undef JSON_HEDLEY_CONST
-#endif
-#if JSON_HEDLEY_HAS_ATTRIBUTE(const) ||                                        \
-    JSON_HEDLEY_GCC_VERSION_CHECK(2, 5, 0) ||                                  \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                               \
-    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) ||                              \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) ||                                  \
-    JSON_HEDLEY_IBM_VERSION_CHECK(10, 1, 0) ||                                 \
-    JSON_HEDLEY_TI_VERSION_CHECK(15, 12, 0) ||                                 \
-    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) &&                            \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) ||                             \
-    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) &&                           \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) ||                            \
-    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) &&                            \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) ||                             \
-    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) &&                             \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) ||                              \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) ||                              \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) ||                             \
-    JSON_HEDLEY_PGI_VERSION_CHECK(17, 10, 0) ||                                \
-    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
-#define JSON_HEDLEY_CONST __attribute__((__const__))
-#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0)
-#define JSON_HEDLEY_CONST _Pragma("no_side_effect")
-#else
-#define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
-#endif
-
-#if defined(JSON_HEDLEY_RESTRICT)
-#undef JSON_HEDLEY_RESTRICT
-#endif
-#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) &&              \
-    !defined(__cplusplus)
-#define JSON_HEDLEY_RESTRICT restrict
-#elif JSON_HEDLEY_GCC_VERSION_CHECK(3, 1, 0) ||                                \
-    JSON_HEDLEY_MSVC_VERSION_CHECK(14, 0, 0) ||                                \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                               \
-    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) ||                          \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) ||                                  \
-    JSON_HEDLEY_IBM_VERSION_CHECK(10, 1, 0) ||                                 \
-    JSON_HEDLEY_PGI_VERSION_CHECK(17, 10, 0) ||                                \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) ||                             \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 2, 4) ||                            \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8, 1, 0) ||                              \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) ||                              \
-    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 14, 0) && defined(__cplusplus)) ||    \
-    JSON_HEDLEY_IAR_VERSION_CHECK(8, 0, 0) || defined(__clang__) ||            \
-    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
-#define JSON_HEDLEY_RESTRICT __restrict
-#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 3, 0) && !defined(__cplusplus)
-#define JSON_HEDLEY_RESTRICT _Restrict
-#else
-#define JSON_HEDLEY_RESTRICT
-#endif
-
-#if defined(JSON_HEDLEY_INLINE)
-#undef JSON_HEDLEY_INLINE
-#endif
-#if (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) ||            \
-    (defined(__cplusplus) && (__cplusplus >= 199711L))
-#define JSON_HEDLEY_INLINE inline
-#elif defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_ARM_VERSION_CHECK(6, 2, 0)
-#define JSON_HEDLEY_INLINE __inline__
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(12, 0, 0) ||                              \
-    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) ||                          \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) ||                                  \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 1, 0) ||                             \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(3, 1, 0) ||                             \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 2, 0) ||                            \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8, 0, 0) ||                              \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) ||                              \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) ||                             \
-    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
-#define JSON_HEDLEY_INLINE __inline
-#else
-#define JSON_HEDLEY_INLINE
-#endif
-
-#if defined(JSON_HEDLEY_ALWAYS_INLINE)
-#undef JSON_HEDLEY_ALWAYS_INLINE
-#endif
-#if JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) ||                                \
-    JSON_HEDLEY_GCC_VERSION_CHECK(4, 0, 0) ||                                  \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                               \
-    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) ||                              \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) ||                                  \
-    JSON_HEDLEY_IBM_VERSION_CHECK(10, 1, 0) ||                                 \
-    JSON_HEDLEY_TI_VERSION_CHECK(15, 12, 0) ||                                 \
-    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) &&                            \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) ||                             \
-    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) &&                           \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) ||                            \
-    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) &&                            \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) ||                             \
-    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) &&                             \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) ||                              \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) ||                              \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) ||                             \
-    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10) ||                           \
-    JSON_HEDLEY_IAR_VERSION_CHECK(8, 10, 0)
-#define JSON_HEDLEY_ALWAYS_INLINE                                              \
-  __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(12, 0, 0) ||                              \
-    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
-#define JSON_HEDLEY_ALWAYS_INLINE __forceinline
-#elif defined(__cplusplus) && (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) ||  \
-                               JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) ||  \
-                               JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || \
-                               JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6, 1, 0) ||   \
-                               JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) ||   \
-                               JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0))
-#define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
-#elif JSON_HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
-#define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
-#else
-#define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
-#endif
-
-#if defined(JSON_HEDLEY_NEVER_INLINE)
-#undef JSON_HEDLEY_NEVER_INLINE
-#endif
-#if JSON_HEDLEY_HAS_ATTRIBUTE(noinline) ||                                     \
-    JSON_HEDLEY_GCC_VERSION_CHECK(4, 0, 0) ||                                  \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                               \
-    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) ||                              \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) ||                                  \
-    JSON_HEDLEY_IBM_VERSION_CHECK(10, 1, 0) ||                                 \
-    JSON_HEDLEY_TI_VERSION_CHECK(15, 12, 0) ||                                 \
-    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) &&                            \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) ||                             \
-    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) &&                           \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) ||                            \
-    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) &&                            \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) ||                             \
-    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) &&                             \
-     defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                                 \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) ||                              \
-    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) ||                              \
-    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) ||                             \
-    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10) ||                           \
-    JSON_HEDLEY_IAR_VERSION_CHECK(8, 10, 0)
-#define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(13, 10, 0) ||                             \
-    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
-#define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
-#elif JSON_HEDLEY_PGI_VERSION_CHECK(10, 2, 0)
-#define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
-#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6, 0, 0) && defined(__cplusplus)
-#define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
-#elif JSON_HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
-#define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
-#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3, 2, 0)
-#define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
-#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9, 0, 0)
-#define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
-#else
-#define JSON_HEDLEY_NEVER_INLINE
-#endif
-
-#if defined(JSON_HEDLEY_PRIVATE)
-#undef JSON_HEDLEY_PRIVATE
-#endif
-#if defined(JSON_HEDLEY_PUBLIC)
-#undef JSON_HEDLEY_PUBLIC
-#endif
-#if defined(JSON_HEDLEY_IMPORT)
-#undef JSON_HEDLEY_IMPORT
-#endif
-#if defined(_WIN32) || defined(__CYGWIN__)
-#define JSON_HEDLEY_PRIVATE
-#define JSON_HEDLEY_PUBLIC __declspec(dllexport)
-#define JSON_HEDLEY_IMPORT __declspec(dllimport)
-#else
-#if JSON_HEDLEY_HAS_ATTRIBUTE(visibility) ||                                   \
-    JSON_HEDLEY_GCC_VERSION_CHECK(3, 3, 0) ||                                  \
-    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) ||                              \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                               \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) ||                                  \
-    JSON_HEDLEY_IBM_VERSION_CHECK(13, 1, 0) ||                                 \
-    (defined(__TI_EABI__) && ((JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) &&   \
-                               defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||       \
-                              JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0))) ||  \
-    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
-#define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
-#define JSON_HEDLEY_PUBLIC __attribute__((__visibility__("default")))
-#else
-#define JSON_HEDLEY_PRIVATE
-#define JSON_HEDLEY_PUBLIC
-#endif
-#define JSON_HEDLEY_IMPORT extern
-#endif
-
-#if defined(JSON_HEDLEY_NO_THROW)
-#undef JSON_HEDLEY_NO_THROW
-#endif
-#if JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) ||                                      \
-    JSON_HEDLEY_GCC_VERSION_CHECK(3, 3, 0) ||                                  \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                               \
-    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
-#define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(13, 1, 0) ||                              \
-    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) ||                          \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0)
-#define JSON_HEDLEY_NO_THROW __declspec(nothrow)
-#else
-#define JSON_HEDLEY_NO_THROW
-#endif
-
-#if defined(JSON_HEDLEY_FALL_THROUGH)
-#undef JSON_HEDLEY_FALL_THROUGH
-#endif
-#if JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) ||                                  \
-    JSON_HEDLEY_GCC_VERSION_CHECK(7, 0, 0) ||                                  \
-    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
-#define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
-#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang, fallthrough)
-#define JSON_HEDLEY_FALL_THROUGH                                               \
-  JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
-#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
-#define JSON_HEDLEY_FALL_THROUGH                                               \
-  JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
-#elif defined(__fallthrough) /* SAL */
-#define JSON_HEDLEY_FALL_THROUGH __fallthrough
-#else
-#define JSON_HEDLEY_FALL_THROUGH
-#endif
-
-#if defined(JSON_HEDLEY_RETURNS_NON_NULL)
-#undef JSON_HEDLEY_RETURNS_NON_NULL
-#endif
-#if JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) ||                              \
-    JSON_HEDLEY_GCC_VERSION_CHECK(4, 9, 0) ||                                  \
-    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
-#define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
-#elif defined(_Ret_notnull_) /* SAL */
-#define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
-#else
-#define JSON_HEDLEY_RETURNS_NON_NULL
-#endif
-
-#if defined(JSON_HEDLEY_ARRAY_PARAM)
-#undef JSON_HEDLEY_ARRAY_PARAM
-#endif
-#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) &&              \
-    !defined(__STDC_NO_VLA__) && !defined(__cplusplus) &&                      \
-    !defined(JSON_HEDLEY_PGI_VERSION) && !defined(JSON_HEDLEY_TINYC_VERSION)
-#define JSON_HEDLEY_ARRAY_PARAM(name) (name)
-#else
-#define JSON_HEDLEY_ARRAY_PARAM(name)
-#endif
-
-#if defined(JSON_HEDLEY_IS_CONSTANT)
-#undef JSON_HEDLEY_IS_CONSTANT
-#endif
-#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
-#undef JSON_HEDLEY_REQUIRE_CONSTEXPR
-#endif
-/* JSON_HEDLEY_IS_CONSTEXPR_ is for
-   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
-#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
-#undef JSON_HEDLEY_IS_CONSTEXPR_
-#endif
-#if JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) ||                           \
-    JSON_HEDLEY_GCC_VERSION_CHECK(3, 4, 0) ||                                  \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                               \
-    JSON_HEDLEY_TINYC_VERSION_CHECK(0, 9, 19) ||                               \
-    JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) ||                                  \
-    JSON_HEDLEY_IBM_VERSION_CHECK(13, 1, 0) ||                                 \
-    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6, 1, 0) ||                              \
-    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0) && !defined(__cplusplus)) ||   \
-    JSON_HEDLEY_CRAY_VERSION_CHECK(8, 1, 0) ||                                 \
-    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
-#define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
-#endif
-#if !defined(__cplusplus)
-#if JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) ||                   \
-    JSON_HEDLEY_GCC_VERSION_CHECK(3, 4, 0) ||                                  \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                               \
-    JSON_HEDLEY_IBM_VERSION_CHECK(13, 1, 0) ||                                 \
-    JSON_HEDLEY_CRAY_VERSION_CHECK(8, 1, 0) ||                                 \
-    JSON_HEDLEY_ARM_VERSION_CHECK(5, 4, 0) ||                                  \
-    JSON_HEDLEY_TINYC_VERSION_CHECK(0, 9, 24)
-#if defined(__INTPTR_TYPE__)
-#define JSON_HEDLEY_IS_CONSTEXPR_(expr)                                        \
-  __builtin_types_compatible_p(                                                \
-      __typeof__((1 ? (void *)((__INTPTR_TYPE__)((expr) * 0)) : (int *)0)),    \
-      int *)
-#else
-#include <stdint.h>
-#define JSON_HEDLEY_IS_CONSTEXPR_(expr)                                        \
-  __builtin_types_compatible_p(                                                \
-      __typeof__((1 ? (void *)((intptr_t)((expr) * 0)) : (int *)0)), int *)
-#endif
-#elif (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) &&           \
-       !defined(JSON_HEDLEY_SUNPRO_VERSION) &&                                 \
-       !defined(JSON_HEDLEY_PGI_VERSION) &&                                    \
-       !defined(JSON_HEDLEY_IAR_VERSION)) ||                                   \
-    (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) &&                        \
-     !defined(JSON_HEDLEY_IAR_VERSION)) ||                                     \
-    JSON_HEDLEY_GCC_VERSION_CHECK(4, 9, 0) ||                                  \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(17, 0, 0) ||                               \
-    JSON_HEDLEY_IBM_VERSION_CHECK(12, 1, 0) ||                                 \
-    JSON_HEDLEY_ARM_VERSION_CHECK(5, 3, 0)
-#if defined(__INTPTR_TYPE__)
-#define JSON_HEDLEY_IS_CONSTEXPR_(expr)                                        \
-  _Generic((1 ? (void *)((__INTPTR_TYPE__)((expr) * 0)) : (int *)0),           \
-      int *: 1,                                                                \
-      void *: 0)
-#else
-#include <stdint.h>
-#define JSON_HEDLEY_IS_CONSTEXPR_(expr)                                        \
-  _Generic((1 ? (void *)((intptr_t)*0) : (int *)0), int *: 1, void *: 0)
-#endif
-#elif defined(JSON_HEDLEY_GCC_VERSION) ||                                      \
-    defined(JSON_HEDLEY_INTEL_VERSION) ||                                      \
-    defined(JSON_HEDLEY_TINYC_VERSION) ||                                      \
-    defined(JSON_HEDLEY_TI_ARMCL_VERSION) ||                                   \
-    JSON_HEDLEY_TI_CL430_VERSION_CHECK(18, 12, 0) ||                           \
-    defined(JSON_HEDLEY_TI_CL2000_VERSION) ||                                  \
-    defined(JSON_HEDLEY_TI_CL6X_VERSION) ||                                    \
-    defined(JSON_HEDLEY_TI_CL7X_VERSION) ||                                    \
-    defined(JSON_HEDLEY_TI_CLPRU_VERSION) || defined(__clang__)
-#define JSON_HEDLEY_IS_CONSTEXPR_(expr)                                        \
-  (sizeof(void) != sizeof(*(1 ? ((void *)((expr) * 0L))                        \
-                              : ((struct { char v[sizeof(void) * 2]; } *)1))))
-#endif
-#endif
-#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
-#if !defined(JSON_HEDLEY_IS_CONSTANT)
-#define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
-#endif
-#define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr)                                    \
-  (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
-#else
-#if !defined(JSON_HEDLEY_IS_CONSTANT)
-#define JSON_HEDLEY_IS_CONSTANT(expr) (0)
-#endif
-#define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
-#endif
-
-#if defined(JSON_HEDLEY_BEGIN_C_DECLS)
-#undef JSON_HEDLEY_BEGIN_C_DECLS
-#endif
-#if defined(JSON_HEDLEY_END_C_DECLS)
-#undef JSON_HEDLEY_END_C_DECLS
-#endif
-#if defined(JSON_HEDLEY_C_DECL)
-#undef JSON_HEDLEY_C_DECL
-#endif
-#if defined(__cplusplus)
-#define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
-#define JSON_HEDLEY_END_C_DECLS }
-#define JSON_HEDLEY_C_DECL extern "C"
-#else
-#define JSON_HEDLEY_BEGIN_C_DECLS
-#define JSON_HEDLEY_END_C_DECLS
-#define JSON_HEDLEY_C_DECL
-#endif
-
-#if defined(JSON_HEDLEY_STATIC_ASSERT)
-#undef JSON_HEDLEY_STATIC_ASSERT
-#endif
-#if !defined(__cplusplus) &&                                                   \
-    ((defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) ||           \
-     (JSON_HEDLEY_HAS_FEATURE(c_static_assert) &&                              \
-      !defined(JSON_HEDLEY_INTEL_CL_VERSION)) ||                               \
-     JSON_HEDLEY_GCC_VERSION_CHECK(6, 0, 0) ||                                 \
-     JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || defined(_Static_assert))
-#define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
-#elif (defined(__cplusplus) && (__cplusplus >= 201103L)) ||                    \
-    JSON_HEDLEY_MSVC_VERSION_CHECK(16, 0, 0) ||                                \
-    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
-#define JSON_HEDLEY_STATIC_ASSERT(expr, message)                               \
-  JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(                           \
-      static_assert(expr, message))
-#else
-#define JSON_HEDLEY_STATIC_ASSERT(expr, message)
-#endif
-
-#if defined(JSON_HEDLEY_NULL)
-#undef JSON_HEDLEY_NULL
-#endif
-#if defined(__cplusplus)
-#if __cplusplus >= 201103L
-#define JSON_HEDLEY_NULL                                                       \
-  JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
-#elif defined(NULL)
-#define JSON_HEDLEY_NULL NULL
-#else
-#define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void *, 0)
-#endif
-#elif defined(NULL)
-#define JSON_HEDLEY_NULL NULL
-#else
-#define JSON_HEDLEY_NULL ((void *)0)
-#endif
-
-#if defined(JSON_HEDLEY_MESSAGE)
-#undef JSON_HEDLEY_MESSAGE
-#endif
-#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
-#define JSON_HEDLEY_MESSAGE(msg)                                               \
-  JSON_HEDLEY_DIAGNOSTIC_PUSH                                                  \
-  JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS                               \
-  JSON_HEDLEY_PRAGMA(message msg)                                              \
-  JSON_HEDLEY_DIAGNOSTIC_POP
-#elif JSON_HEDLEY_GCC_VERSION_CHECK(4, 4, 0) ||                                \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
-#define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
-#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5, 0, 0)
-#define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
-#elif JSON_HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
-#define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
-#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2, 0, 0)
-#define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
-#else
-#define JSON_HEDLEY_MESSAGE(msg)
-#endif
-
-#if defined(JSON_HEDLEY_WARNING)
-#undef JSON_HEDLEY_WARNING
-#endif
-#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
-#define JSON_HEDLEY_WARNING(msg)                                               \
-  JSON_HEDLEY_DIAGNOSTIC_PUSH                                                  \
-  JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS                               \
-  JSON_HEDLEY_PRAGMA(clang warning msg)                                        \
-  JSON_HEDLEY_DIAGNOSTIC_POP
-#elif JSON_HEDLEY_GCC_VERSION_CHECK(4, 8, 0) ||                                \
-    JSON_HEDLEY_PGI_VERSION_CHECK(18, 4, 0) ||                                 \
-    JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
-#define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15, 0, 0) ||                              \
-    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
-#define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
-#else
-#define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
-#endif
-
-#if defined(JSON_HEDLEY_REQUIRE)
-#undef JSON_HEDLEY_REQUIRE
-#endif
-#if defined(JSON_HEDLEY_REQUIRE_MSG)
-#undef JSON_HEDLEY_REQUIRE_MSG
-#endif
-#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
-#if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
-#define JSON_HEDLEY_REQUIRE(expr)                                              \
-  JSON_HEDLEY_DIAGNOSTIC_PUSH                                                  \
-  _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") __attribute__((         \
-      diagnose_if(!(expr), #expr, "error"))) JSON_HEDLEY_DIAGNOSTIC_POP
-#define JSON_HEDLEY_REQUIRE_MSG(expr, msg)                                     \
-  JSON_HEDLEY_DIAGNOSTIC_PUSH                                                  \
-  _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") __attribute__((         \
-      diagnose_if(!(expr), msg, "error"))) JSON_HEDLEY_DIAGNOSTIC_POP
-#else
-#define JSON_HEDLEY_REQUIRE(expr)                                              \
-  __attribute__((diagnose_if(!(expr), #expr, "error")))
-#define JSON_HEDLEY_REQUIRE_MSG(expr, msg)                                     \
-  __attribute__((diagnose_if(!(expr), msg, "error")))
-#endif
-#else
-#define JSON_HEDLEY_REQUIRE(expr)
-#define JSON_HEDLEY_REQUIRE_MSG(expr, msg)
-#endif
-
-#if defined(JSON_HEDLEY_FLAGS)
-#undef JSON_HEDLEY_FLAGS
-#endif
-#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) &&                                    \
-    (!defined(__cplusplus) ||                                                  \
-     JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion"))
-#define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
-#else
-#define JSON_HEDLEY_FLAGS
-#endif
-
-#if defined(JSON_HEDLEY_FLAGS_CAST)
-#undef JSON_HEDLEY_FLAGS_CAST
-#endif
-#if JSON_HEDLEY_INTEL_VERSION_CHECK(19, 0, 0)
-#define JSON_HEDLEY_FLAGS_CAST(T, expr)                                        \
-  (__extension__({                                                             \
-    JSON_HEDLEY_DIAGNOSTIC_PUSH                                                \
-    _Pragma("warning(disable:188)")((T)(expr));                                \
-    JSON_HEDLEY_DIAGNOSTIC_POP                                                 \
-  }))
-#else
-#define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
-#endif
-
-#if defined(JSON_HEDLEY_EMPTY_BASES)
-#undef JSON_HEDLEY_EMPTY_BASES
-#endif
-#if (JSON_HEDLEY_MSVC_VERSION_CHECK(19, 0, 23918) &&                           \
-     !JSON_HEDLEY_MSVC_VERSION_CHECK(20, 0, 0)) ||                             \
-    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
-#define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
-#else
-#define JSON_HEDLEY_EMPTY_BASES
-#endif
-
-/* Remaining macros are deprecated. */
-
-#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
-#undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
-#endif
-#if defined(__clang__)
-#define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major, minor, patch) (0)
-#else
-#define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major, minor, patch)           \
-  JSON_HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
-#endif
-
-#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
-#undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
-#endif
-#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute)                             \
-  JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
-
-#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
-#undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
-#endif
-#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute)                         \
-  JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
-
-#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
-#undef JSON_HEDLEY_CLANG_HAS_BUILTIN
-#endif
-#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
-
-#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
-#undef JSON_HEDLEY_CLANG_HAS_FEATURE
-#endif
-#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
-
-#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
-#undef JSON_HEDLEY_CLANG_HAS_EXTENSION
-#endif
-#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension)                             \
-  JSON_HEDLEY_HAS_EXTENSION(extension)
-
-#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
-#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
-#endif
-#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute)                    \
-  JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
-
-#if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
-#undef JSON_HEDLEY_CLANG_HAS_WARNING
-#endif
-#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
-
-#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */
-
-// This file contains all internal macro definitions (except those affecting
-// ABI) You MUST include macro_unscope.hpp at the end of json.hpp to undef all
-// of them
-
-// #include <nlohmann/detail/abi_macros.hpp>
-
-// exclude unsupported compilers
-#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
-#if defined(__clang__)
-#if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < \
-    30400
-#error                                                                         \
-    "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
-#endif
-#elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
-#if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
-#error                                                                         \
-    "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
-#endif
-#endif
-#endif
-
-// C++ language standard detection
-// if the user manually specified the used c++ version this is skipped
-#if !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) &&                  \
-    !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11)
-#if (defined(__cplusplus) && __cplusplus >= 202002L) ||                        \
-    (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
-#define JSON_HAS_CPP_20
-#define JSON_HAS_CPP_17
-#define JSON_HAS_CPP_14
-#elif (defined(__cplusplus) && __cplusplus >= 201703L) ||                      \
-    (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
-#define JSON_HAS_CPP_17
-#define JSON_HAS_CPP_14
-#elif (defined(__cplusplus) && __cplusplus >= 201402L) ||                      \
-    (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
-#define JSON_HAS_CPP_14
-#endif
-// the cpp 11 flag is always specified because it is the minimal required
-// version
-#define JSON_HAS_CPP_11
-#endif
-
-#ifdef __has_include
-#if __has_include(<version>)
-#include <version>
-#endif
-#endif
-
-#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM)
-#ifdef JSON_HAS_CPP_17
-#if defined(__cpp_lib_filesystem)
-#define JSON_HAS_FILESYSTEM 1
-#elif defined(__cpp_lib_experimental_filesystem)
-#define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
-#elif !defined(__has_include)
-#define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
-#elif __has_include(<filesystem>)
-#define JSON_HAS_FILESYSTEM 1
-#elif __has_include(<experimental/filesystem>)
-#define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
-#endif
-
-// std::filesystem does not work on MinGW GCC 8:
-// https://sourceforge.net/p/mingw-w64/bugs/737/
-#if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8
-#undef JSON_HAS_FILESYSTEM
-#undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
-#endif
-
-// no filesystem support before GCC 8:
-// https://en.cppreference.com/w/cpp/compiler_support
-#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8
-#undef JSON_HAS_FILESYSTEM
-#undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
-#endif
-
-// no filesystem support before Clang 7:
-// https://en.cppreference.com/w/cpp/compiler_support
-#if defined(__clang_major__) && __clang_major__ < 7
-#undef JSON_HAS_FILESYSTEM
-#undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
-#endif
-
-// no filesystem support before MSVC 19.14:
-// https://en.cppreference.com/w/cpp/compiler_support
-#if defined(_MSC_VER) && _MSC_VER < 1914
-#undef JSON_HAS_FILESYSTEM
-#undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
-#endif
-
-// no filesystem support before iOS 13
-#if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) &&                               \
-    __IPHONE_OS_VERSION_MIN_REQUIRED < 130000
-#undef JSON_HAS_FILESYSTEM
-#undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
-#endif
-
-// no filesystem support before macOS Catalina
-#if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) &&                                \
-    __MAC_OS_X_VERSION_MIN_REQUIRED < 101500
-#undef JSON_HAS_FILESYSTEM
-#undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
-#endif
-#endif
-#endif
-
-#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM
-#define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0
-#endif
-
-#ifndef JSON_HAS_FILESYSTEM
-#define JSON_HAS_FILESYSTEM 0
-#endif
-
-#ifndef JSON_HAS_THREE_WAY_COMPARISON
-#if defined(__cpp_impl_three_way_comparison) &&                                \
-    __cpp_impl_three_way_comparison >= 201907L &&                              \
-    defined(__cpp_lib_three_way_comparison) &&                                 \
-    __cpp_lib_three_way_comparison >= 201907L
-#define JSON_HAS_THREE_WAY_COMPARISON 1
-#else
-#define JSON_HAS_THREE_WAY_COMPARISON 0
-#endif
-#endif
-
-#ifndef JSON_HAS_RANGES
-// ranges header shipping in GCC 11.1.0 (released 2021-04-27) has syntax error
-#if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427
-#define JSON_HAS_RANGES 0
-#elif defined(__cpp_lib_ranges)
-#define JSON_HAS_RANGES 1
-#else
-#define JSON_HAS_RANGES 0
-#endif
-#endif
-
-#ifndef JSON_HAS_STATIC_RTTI
-#if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0
-#define JSON_HAS_STATIC_RTTI 1
-#else
-#define JSON_HAS_STATIC_RTTI 0
-#endif
-#endif
-
-#ifdef JSON_HAS_CPP_17
-#define JSON_INLINE_VARIABLE inline
-#else
-#define JSON_INLINE_VARIABLE
-#endif
-
-#if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address)
-#define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]]
-#else
-#define JSON_NO_UNIQUE_ADDRESS
-#endif
-
-// disable documentation warnings on clang
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdocumentation"
-#pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
-#endif
-
-// allow disabling exceptions
-#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) ||                     \
-     defined(_CPPUNWIND)) &&                                                   \
-    !defined(JSON_NOEXCEPTION)
-#define JSON_THROW(exception) throw exception
-#define JSON_TRY try
-#define JSON_CATCH(exception) catch (exception)
-#define JSON_INTERNAL_CATCH(exception) catch (exception)
-#else
-#include <cstdlib>
-#define JSON_THROW(exception) std::abort()
-#define JSON_TRY if (true)
-#define JSON_CATCH(exception) if (false)
-#define JSON_INTERNAL_CATCH(exception) if (false)
-#endif
-
-// override exception macros
-#if defined(JSON_THROW_USER)
-#undef JSON_THROW
-#define JSON_THROW JSON_THROW_USER
-#endif
-#if defined(JSON_TRY_USER)
-#undef JSON_TRY
-#define JSON_TRY JSON_TRY_USER
-#endif
-#if defined(JSON_CATCH_USER)
-#undef JSON_CATCH
-#define JSON_CATCH JSON_CATCH_USER
-#undef JSON_INTERNAL_CATCH
-#define JSON_INTERNAL_CATCH JSON_CATCH_USER
-#endif
-#if defined(JSON_INTERNAL_CATCH_USER)
-#undef JSON_INTERNAL_CATCH
-#define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
-#endif
-
-// allow overriding assert
-#if !defined(JSON_ASSERT)
-#include <cassert> // assert
-#define JSON_ASSERT(x) assert(x)
-#endif
-
-// allow to access some private functions (needed by the test suite)
-#if defined(JSON_TESTS_PRIVATE)
-#define JSON_PRIVATE_UNLESS_TESTED public
-#else
-#define JSON_PRIVATE_UNLESS_TESTED private
-#endif
-
-/*!
-@brief macro to briefly define a mapping between an enum and JSON
-@def NLOHMANN_JSON_SERIALIZE_ENUM
-@since version 3.4.0
-*/
-#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...)                           \
-  template <typename BasicJsonType>                                            \
-  inline void to_json(BasicJsonType &j, const ENUM_TYPE &e) {                  \
-    /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */                   \
-    static_assert(std::is_enum<ENUM_TYPE>::value,                              \
-                  #ENUM_TYPE " must be an enum!");                             \
-    /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on     \
-     * <array> */                                                              \
-    static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;        \
-    auto it = std::find_if(                                                    \
-        std::begin(m), std::end(m),                                            \
-        [e](const std::pair<ENUM_TYPE, BasicJsonType> &ej_pair) -> bool {      \
-          return ej_pair.first == e;                                           \
-        });                                                                    \
-    j = ((it != std::end(m)) ? it : std::begin(m))->second;                    \
-  }                                                                            \
-  template <typename BasicJsonType>                                            \
-  inline void from_json(const BasicJsonType &j, ENUM_TYPE &e) {                \
-    /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */                   \
-    static_assert(std::is_enum<ENUM_TYPE>::value,                              \
-                  #ENUM_TYPE " must be an enum!");                             \
-    /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on     \
-     * <array> */                                                              \
-    static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;        \
-    auto it = std::find_if(                                                    \
-        std::begin(m), std::end(m),                                            \
-        [&j](const std::pair<ENUM_TYPE, BasicJsonType> &ej_pair) -> bool {     \
-          return ej_pair.second == j;                                          \
-        });                                                                    \
-    e = ((it != std::end(m)) ? it : std::begin(m))->first;                     \
-  }
-
-// Ugly macros to avoid uglier copy-paste when specializing basic_json. They
-// may be removed in the future once the class is split.
-
-#define NLOHMANN_BASIC_JSON_TPL_DECLARATION                                    \
-  template <template <typename, typename, typename...> class ObjectType,       \
-            template <typename, typename...> class ArrayType,                  \
-            class StringType, class BooleanType, class NumberIntegerType,      \
-            class NumberUnsignedType, class NumberFloatType,                   \
-            template <typename> class AllocatorType,                           \
-            template <typename, typename = void> class JSONSerializer,         \
-            class BinaryType, class CustomBaseClass>
-
-#define NLOHMANN_BASIC_JSON_TPL                                                \
-  basic_json<ObjectType, ArrayType, StringType, BooleanType,                   \
-             NumberIntegerType, NumberUnsignedType, NumberFloatType,           \
-             AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>
-
-// Macros to simplify conversion from/to types
-
-#define NLOHMANN_JSON_EXPAND(x) x
-#define NLOHMANN_JSON_GET_MACRO(                                               \
-    _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, \
-    _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, \
-    _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, \
-    _62, _63, _64, NAME, ...)                                                  \
-  NAME
-#define NLOHMANN_JSON_PASTE(...)                                               \
-  NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(                                \
-      __VA_ARGS__, NLOHMANN_JSON_PASTE64, NLOHMANN_JSON_PASTE63,               \
-      NLOHMANN_JSON_PASTE62, NLOHMANN_JSON_PASTE61, NLOHMANN_JSON_PASTE60,     \
-      NLOHMANN_JSON_PASTE59, NLOHMANN_JSON_PASTE58, NLOHMANN_JSON_PASTE57,     \
-      NLOHMANN_JSON_PASTE56, NLOHMANN_JSON_PASTE55, NLOHMANN_JSON_PASTE54,     \
-      NLOHMANN_JSON_PASTE53, NLOHMANN_JSON_PASTE52, NLOHMANN_JSON_PASTE51,     \
-      NLOHMANN_JSON_PASTE50, NLOHMANN_JSON_PASTE49, NLOHMANN_JSON_PASTE48,     \
-      NLOHMANN_JSON_PASTE47, NLOHMANN_JSON_PASTE46, NLOHMANN_JSON_PASTE45,     \
-      NLOHMANN_JSON_PASTE44, NLOHMANN_JSON_PASTE43, NLOHMANN_JSON_PASTE42,     \
-      NLOHMANN_JSON_PASTE41, NLOHMANN_JSON_PASTE40, NLOHMANN_JSON_PASTE39,     \
-      NLOHMANN_JSON_PASTE38, NLOHMANN_JSON_PASTE37, NLOHMANN_JSON_PASTE36,     \
-      NLOHMANN_JSON_PASTE35, NLOHMANN_JSON_PASTE34, NLOHMANN_JSON_PASTE33,     \
-      NLOHMANN_JSON_PASTE32, NLOHMANN_JSON_PASTE31, NLOHMANN_JSON_PASTE30,     \
-      NLOHMANN_JSON_PASTE29, NLOHMANN_JSON_PASTE28, NLOHMANN_JSON_PASTE27,     \
-      NLOHMANN_JSON_PASTE26, NLOHMANN_JSON_PASTE25, NLOHMANN_JSON_PASTE24,     \
-      NLOHMANN_JSON_PASTE23, NLOHMANN_JSON_PASTE22, NLOHMANN_JSON_PASTE21,     \
-      NLOHMANN_JSON_PASTE20, NLOHMANN_JSON_PASTE19, NLOHMANN_JSON_PASTE18,     \
-      NLOHMANN_JSON_PASTE17, NLOHMANN_JSON_PASTE16, NLOHMANN_JSON_PASTE15,     \
-      NLOHMANN_JSON_PASTE14, NLOHMANN_JSON_PASTE13, NLOHMANN_JSON_PASTE12,     \
-      NLOHMANN_JSON_PASTE11, NLOHMANN_JSON_PASTE10, NLOHMANN_JSON_PASTE9,      \
-      NLOHMANN_JSON_PASTE8, NLOHMANN_JSON_PASTE7, NLOHMANN_JSON_PASTE6,        \
-      NLOHMANN_JSON_PASTE5, NLOHMANN_JSON_PASTE4, NLOHMANN_JSON_PASTE3,        \
-      NLOHMANN_JSON_PASTE2, NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
-#define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
-#define NLOHMANN_JSON_PASTE3(func, v1, v2)                                     \
-  NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
-#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3)                                 \
-  NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
-#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4)                             \
-  NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)
-#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5)                         \
-  NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)
-#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6)                     \
-  NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6)
-#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7)                 \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7)
-#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8)             \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8)
-#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9)        \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9)
-#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10)   \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10)
-#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,   \
-                              v11)                                             \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
-#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,   \
-                              v11, v12)                                        \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12)
-#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,   \
-                              v11, v12, v13)                                   \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,   \
-                        v13)
-#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,   \
-                              v11, v12, v13, v14)                              \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,   \
-                        v13, v14)
-#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,   \
-                              v11, v12, v13, v14, v15)                         \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,   \
-                        v13, v14, v15)
-#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,   \
-                              v11, v12, v13, v14, v15, v16)                    \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,   \
-                        v13, v14, v15, v16)
-#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,   \
-                              v11, v12, v13, v14, v15, v16, v17)               \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,   \
-                        v13, v14, v15, v16, v17)
-#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,   \
-                              v11, v12, v13, v14, v15, v16, v17, v18)          \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,   \
-                        v13, v14, v15, v16, v17, v18)
-#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,   \
-                              v11, v12, v13, v14, v15, v16, v17, v18, v19)     \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,   \
-                        v13, v14, v15, v16, v17, v18, v19)
-#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,   \
-                              v11, v12, v13, v14, v15, v16, v17, v18, v19,     \
-                              v20)                                             \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,   \
-                        v13, v14, v15, v16, v17, v18, v19, v20)
-#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,   \
-                              v11, v12, v13, v14, v15, v16, v17, v18, v19,     \
-                              v20, v21)                                        \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,   \
-                        v13, v14, v15, v16, v17, v18, v19, v20, v21)
-#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,   \
-                              v11, v12, v13, v14, v15, v16, v17, v18, v19,     \
-                              v20, v21, v22)                                   \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,   \
-                        v13, v14, v15, v16, v17, v18, v19, v20, v21, v22)
-#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,   \
-                              v11, v12, v13, v14, v15, v16, v17, v18, v19,     \
-                              v20, v21, v22, v23)                              \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,   \
-                        v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23)
-#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,   \
-                              v11, v12, v13, v14, v15, v16, v17, v18, v19,     \
-                              v20, v21, v22, v23, v24)                         \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,   \
-                        v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, \
-                        v24)
-#define NLOHMANN_JSON_PASTE26(func, 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)                    \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,   \
-                        v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, \
-                        v24, v25)
-#define NLOHMANN_JSON_PASTE27(func, 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)               \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE26(func, 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)
-#define NLOHMANN_JSON_PASTE28(func, 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)          \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE27(func, 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)
-#define NLOHMANN_JSON_PASTE29(func, 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)     \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE28(func, 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)
-#define NLOHMANN_JSON_PASTE30(                                                 \
-    func, 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)      \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE29(func, 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)
-#define NLOHMANN_JSON_PASTE31(                                                 \
-    func, 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) \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE30(func, 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)
-#define NLOHMANN_JSON_PASTE32(func, 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)                                   \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE31(func, 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)
-#define NLOHMANN_JSON_PASTE33(func, 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, v32)                              \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE32(func, 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, v32)
-#define NLOHMANN_JSON_PASTE34(func, 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, v32, v33)                         \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE33(func, 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, v32, v33)
-#define NLOHMANN_JSON_PASTE35(func, 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, v32, v33, v34)                    \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE34(func, 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, v32, v33, v34)
-#define NLOHMANN_JSON_PASTE36(func, 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, v32, v33, v34, v35)               \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE35(func, 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, v32, v33, v34, \
-                        v35)
-#define NLOHMANN_JSON_PASTE37(func, 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, v32, v33, v34, v35, v36)          \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE36(func, 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, v32, v33, v34, \
-                        v35, v36)
-#define NLOHMANN_JSON_PASTE38(func, 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, v32, v33, v34, v35, v36, v37)     \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE37(func, 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, v32, v33, v34, \
-                        v35, v36, v37)
-#define NLOHMANN_JSON_PASTE39(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38)                                    \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE38(func, 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, v32, v33, v34, \
-                        v35, v36, v37, v38)
-#define NLOHMANN_JSON_PASTE40(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38, v39)                               \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE39(func, 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, v32, v33, v34, \
-                        v35, v36, v37, v38, v39)
-#define NLOHMANN_JSON_PASTE41(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40)                          \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE40(func, 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, v32, v33, v34, \
-                        v35, v36, v37, v38, v39, v40)
-#define NLOHMANN_JSON_PASTE42(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41)                     \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE41(func, 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, v32, v33, v34, \
-                        v35, v36, v37, v38, v39, v40, v41)
-#define NLOHMANN_JSON_PASTE43(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42)                \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE42(func, 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, v32, v33, v34, \
-                        v35, v36, v37, v38, v39, v40, v41, v42)
-#define NLOHMANN_JSON_PASTE44(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43)           \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE43(func, 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, v32, v33, v34, \
-                        v35, v36, v37, v38, v39, v40, v41, v42, v43)
-#define NLOHMANN_JSON_PASTE45(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44)      \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE44(func, 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, v32, v33, v34, \
-                        v35, v36, v37, v38, v39, v40, v41, v42, v43, v44)
-#define NLOHMANN_JSON_PASTE46(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE45(func, 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, v32, v33, v34, \
-                        v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45)
-#define NLOHMANN_JSON_PASTE47(func, 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, v32, v33, v34, v35, v36, v37,     \
-                              v38, v39, v40, v41, v42, v43, v44, v45, v46)     \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE46(func, 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, v32, v33, v34, \
-                        v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-                        v46)
-#define NLOHMANN_JSON_PASTE48(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-    v46, v47)                                                                  \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE47(func, 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, v32, v33, v34, \
-                        v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-                        v46, v47)
-#define NLOHMANN_JSON_PASTE49(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-    v46, v47, v48)                                                             \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE48(func, 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, v32, v33, v34, \
-                        v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-                        v46, v47, v48)
-#define NLOHMANN_JSON_PASTE50(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-    v46, v47, v48, v49)                                                        \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE49(func, 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, v32, v33, v34, \
-                        v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-                        v46, v47, v48, v49)
-#define NLOHMANN_JSON_PASTE51(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-    v46, v47, v48, v49, v50)                                                   \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE50(func, 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, v32, v33, v34, \
-                        v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-                        v46, v47, v48, v49, v50)
-#define NLOHMANN_JSON_PASTE52(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-    v46, v47, v48, v49, v50, v51)                                              \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE51(func, 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, v32, v33, v34, \
-                        v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-                        v46, v47, v48, v49, v50, v51)
-#define NLOHMANN_JSON_PASTE53(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-    v46, v47, v48, v49, v50, v51, v52)                                         \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE52(func, 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, v32, v33, v34, \
-                        v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-                        v46, v47, v48, v49, v50, v51, v52)
-#define NLOHMANN_JSON_PASTE54(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-    v46, v47, v48, v49, v50, v51, v52, v53)                                    \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE53(func, 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, v32, v33, v34, \
-                        v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-                        v46, v47, v48, v49, v50, v51, v52, v53)
-#define NLOHMANN_JSON_PASTE55(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-    v46, v47, v48, v49, v50, v51, v52, v53, v54)                               \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE54(func, 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, v32, v33, v34, \
-                        v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-                        v46, v47, v48, v49, v50, v51, v52, v53, v54)
-#define NLOHMANN_JSON_PASTE56(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-    v46, v47, v48, v49, v50, v51, v52, v53, v54, v55)                          \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE55(func, 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, v32, v33, v34, \
-                        v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-                        v46, v47, v48, v49, v50, v51, v52, v53, v54, v55)
-#define NLOHMANN_JSON_PASTE57(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-    v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56)                     \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE56(func, 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, v32, v33, v34, \
-                        v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-                        v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56)
-#define NLOHMANN_JSON_PASTE58(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-    v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57)                \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE57(                                                       \
-      func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44,    \
-      v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57)
-#define NLOHMANN_JSON_PASTE59(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-    v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58)           \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE58(                                                       \
-      func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44,    \
-      v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58)
-#define NLOHMANN_JSON_PASTE60(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-    v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59)      \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE59(func, 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, v32, v33, v34, \
-                        v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-                        v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, \
-                        v57, v58, v59)
-#define NLOHMANN_JSON_PASTE61(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-    v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE60(func, 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, v32, v33, v34, \
-                        v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-                        v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, \
-                        v57, v58, v59, v60)
-#define NLOHMANN_JSON_PASTE62(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-    v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, \
-    v61)                                                                       \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE61(func, 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, v32, v33, v34, \
-                        v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-                        v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, \
-                        v57, v58, v59, v60, v61)
-#define NLOHMANN_JSON_PASTE63(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-    v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, \
-    v61, v62)                                                                  \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE62(func, 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, v32, v33, v34, \
-                        v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-                        v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, \
-                        v57, v58, v59, v60, v61, v62)
-#define NLOHMANN_JSON_PASTE64(                                                 \
-    func, 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, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-    v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, \
-    v61, v62, v63)                                                             \
-  NLOHMANN_JSON_PASTE2(func, v1)                                               \
-  NLOHMANN_JSON_PASTE63(func, 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, v32, v33, v34, \
-                        v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, \
-                        v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, \
-                        v57, v58, v59, v60, v61, v62, v63)
-
-#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;
-#define NLOHMANN_JSON_FROM(v1)                                                 \
-  nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);
-#define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1)                                    \
-  nlohmann_json_t.v1 = nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1);
-
-/*!
-@brief macro
-@def NLOHMANN_DEFINE_TYPE_INTRUSIVE
-@since version 3.9.0
-*/
-#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...)                              \
-  friend void to_json(nlohmann::json &nlohmann_json_j,                         \
-                      const Type &nlohmann_json_t) {                           \
-    NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__))   \
-  }                                                                            \
-  friend void from_json(const nlohmann::json &nlohmann_json_j,                 \
-                        Type &nlohmann_json_t) {                               \
-    NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) \
-  }
-
-#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...)                 \
-  friend void to_json(nlohmann::json &nlohmann_json_j,                         \
-                      const Type &nlohmann_json_t) {                           \
-    NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__))   \
-  }                                                                            \
-  friend void from_json(const nlohmann::json &nlohmann_json_j,                 \
-                        Type &nlohmann_json_t) {                               \
-    const Type nlohmann_json_default_obj{};                                    \
-    NLOHMANN_JSON_EXPAND(                                                      \
-        NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__))     \
-  }
-
-#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...)               \
-  friend void to_json(nlohmann::json &nlohmann_json_j,                         \
-                      const Type &nlohmann_json_t) {                           \
-    NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__))   \
-  }
-
-/*!
-@brief macro
-@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE
-@since version 3.9.0
-*/
-#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...)                          \
-  inline void to_json(nlohmann::json &nlohmann_json_j,                         \
-                      const Type &nlohmann_json_t) {                           \
-    NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__))   \
-  }                                                                            \
-  inline void from_json(const nlohmann::json &nlohmann_json_j,                 \
-                        Type &nlohmann_json_t) {                               \
-    NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) \
-  }
-
-#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...)           \
-  inline void to_json(nlohmann::json &nlohmann_json_j,                         \
-                      const Type &nlohmann_json_t) {                           \
-    NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__))   \
-  }
-
-#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...)             \
-  inline void to_json(nlohmann::json &nlohmann_json_j,                         \
-                      const Type &nlohmann_json_t) {                           \
-    NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__))   \
-  }                                                                            \
-  inline void from_json(const nlohmann::json &nlohmann_json_j,                 \
-                        Type &nlohmann_json_t) {                               \
-    const Type nlohmann_json_default_obj{};                                    \
-    NLOHMANN_JSON_EXPAND(                                                      \
-        NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__))     \
-  }
-
-/*!
-@brief macro
-@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE
-@since version 3.11.x
-*/
-#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(Type, BaseType, ...)            \
-  friend void to_json(nlohmann::json &nlohmann_json_j,                         \
-                      const Type &nlohmann_json_t) {                           \
-    nlohmann::to_json(nlohmann_json_j,                                         \
-                      static_cast<const BaseType &>(nlohmann_json_t));         \
-    NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__))   \
-  }                                                                            \
-  friend void from_json(const nlohmann::json &nlohmann_json_j,                 \
-                        Type &nlohmann_json_t) {                               \
-    nlohmann::from_json(nlohmann_json_j,                                       \
-                        static_cast<BaseType &>(nlohmann_json_t));             \
-    NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) \
-  }
-
-#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(Type, BaseType,    \
-                                                            ...)               \
-  friend void to_json(nlohmann::json &nlohmann_json_j,                         \
-                      const Type &nlohmann_json_t) {                           \
-    nlohmann::to_json(nlohmann_json_j,                                         \
-                      static_cast<const BaseType &>(nlohmann_json_t));         \
-    NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__))   \
-  }                                                                            \
-  friend void from_json(const nlohmann::json &nlohmann_json_j,                 \
-                        Type &nlohmann_json_t) {                               \
-    nlohmann::from_json(nlohmann_json_j,                                       \
-                        static_cast<BaseType &>(nlohmann_json_t));             \
-    const Type nlohmann_json_default_obj{};                                    \
-    NLOHMANN_JSON_EXPAND(                                                      \
-        NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__))     \
-  }
-
-/*!
-@brief macro
-@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE
-@since version 3.11.x
-*/
-#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(Type, BaseType, ...)        \
-  inline void to_json(nlohmann::json &nlohmann_json_j,                         \
-                      const Type &nlohmann_json_t) {                           \
-    nlohmann::to_json(nlohmann_json_j,                                         \
-                      static_cast<const BaseType &>(nlohmann_json_t));         \
-    NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__))   \
-  }                                                                            \
-  inline void from_json(const nlohmann::json &nlohmann_json_j,                 \
-                        Type &nlohmann_json_t) {                               \
-    nlohmann::from_json(nlohmann_json_j,                                       \
-                        static_cast<BaseType &>(nlohmann_json_t));             \
-    NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) \
-  }
-
-#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type,          \
-                                                                BaseType, ...) \
-  inline void to_json(nlohmann::json &nlohmann_json_j,                         \
-                      const Type &nlohmann_json_t) {                           \
-    nlohmann::to_json(nlohmann_json_j,                                         \
-                      static_cast<const BaseType &>(nlohmann_json_t));         \
-    NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__))   \
-  }                                                                            \
-  inline void from_json(const nlohmann::json &nlohmann_json_j,                 \
-                        Type &nlohmann_json_t) {                               \
-    nlohmann::from_json(nlohmann_json_j,                                       \
-                        static_cast<BaseType &>(nlohmann_json_t));             \
-    const Type nlohmann_json_default_obj{};                                    \
-    NLOHMANN_JSON_EXPAND(                                                      \
-        NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__))     \
-  }
-
-// inspired from https://stackoverflow.com/a/26745591
-// allows to call any std function as if (e.g. with begin):
-// using std::begin; begin(x);
-//
-// it allows using the detected idiom to retrieve the return type
-// of such an expression
-#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name)                              \
-  namespace detail {                                                           \
-  using std::std_name;                                                         \
-                                                                               \
-  template <typename... T>                                                     \
-  using result_of_##std_name = decltype(std_name(std::declval<T>()...));       \
-  }                                                                            \
-                                                                               \
-  namespace detail2 {                                                          \
-  struct std_name##_tag {};                                                    \
-                                                                               \
-  template <typename... T> std_name##_tag std_name(T &&...);                   \
-                                                                               \
-  template <typename... T>                                                     \
-  using result_of_##std_name = decltype(std_name(std::declval<T>()...));       \
-                                                                               \
-  template <typename... T> struct would_call_std_##std_name {                  \
-    static constexpr auto const value = ::nlohmann::detail::is_detected_exact< \
-        std_name##_tag, result_of_##std_name, T...>::value;                    \
-  };                                                                           \
-  } /* namespace detail2 */                                                    \
-                                                                               \
-  template <typename... T>                                                     \
-  struct would_call_std_##std_name                                             \
-      : detail2::would_call_std_##std_name<T...> {}
-
-#ifndef JSON_USE_IMPLICIT_CONVERSIONS
-#define JSON_USE_IMPLICIT_CONVERSIONS 1
-#endif
-
-#if JSON_USE_IMPLICIT_CONVERSIONS
-#define JSON_EXPLICIT
-#else
-#define JSON_EXPLICIT explicit
-#endif
-
-#ifndef JSON_DISABLE_ENUM_SERIALIZATION
-#define JSON_DISABLE_ENUM_SERIALIZATION 0
-#endif
-
-#ifndef JSON_USE_GLOBAL_UDLS
-#define JSON_USE_GLOBAL_UDLS 1
-#endif
-
-#if JSON_HAS_THREE_WAY_COMPARISON
-#include <compare> // partial_ordering
-#endif
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-///////////////////////////
-// JSON type enumeration //
-///////////////////////////
-
-/*!
-@brief the JSON type enumeration
-
-This enumeration collects the different JSON types. It is internally used to
-distinguish the stored values, and the functions @ref basic_json::is_null(),
-@ref basic_json::is_object(), @ref basic_json::is_array(),
-@ref basic_json::is_string(), @ref basic_json::is_boolean(),
-@ref basic_json::is_number() (with @ref basic_json::is_number_integer(),
-@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),
-@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and
-@ref basic_json::is_structured() rely on it.
-
-@note There are three enumeration entries (number_integer, number_unsigned, and
-number_float), because the library distinguishes these three types for numbers:
-@ref basic_json::number_unsigned_t is used for unsigned integers,
-@ref basic_json::number_integer_t is used for signed integers, and
-@ref basic_json::number_float_t is used for floating-point numbers or to
-approximate integers which do not fit in the limits of their respective type.
-
-@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON
-value with the default value for a given type
-
-@since version 1.0.0
-*/
-enum class value_t : std::uint8_t {
-  null,            ///< null value
-  object,          ///< object (unordered set of name/value pairs)
-  array,           ///< array (ordered collection of values)
-  string,          ///< string value
-  boolean,         ///< boolean value
-  number_integer,  ///< number value (signed integer)
-  number_unsigned, ///< number value (unsigned integer)
-  number_float,    ///< number value (floating-point)
-  binary,          ///< binary array (ordered collection of bytes)
-  discarded        ///< discarded by the parser callback function
-};
-
-/*!
-@brief comparison operator for JSON types
-
-Returns an ordering that is similar to Python:
-- order: null < boolean < number < object < array < string < binary
-- furthermore, each type is not smaller than itself
-- discarded values are not comparable
-- binary is represented as a b"" string in python and directly comparable to a
-  string; however, making a binary array directly comparable with a string would
-  be surprising behavior in a JSON file.
-
-@since version 1.0.0
-*/
-#if JSON_HAS_THREE_WAY_COMPARISON
-inline std::partial_ordering operator<=>(const value_t lhs,
-                                         const value_t rhs) noexcept // *NOPAD*
-#else
-inline bool operator<(const value_t lhs, const value_t rhs) noexcept
-#endif
-{
-  static constexpr std::array<std::uint8_t, 9> order = {{
-      0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
-      1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */,
-      6 /* binary */
-  }};
-
-  const auto l_index = static_cast<std::size_t>(lhs);
-  const auto r_index = static_cast<std::size_t>(rhs);
-#if JSON_HAS_THREE_WAY_COMPARISON
-  if (l_index < order.size() && r_index < order.size()) {
-    return order[l_index] <=> order[r_index]; // *NOPAD*
-  }
-  return std::partial_ordering::unordered;
-#else
-  return l_index < order.size() && r_index < order.size() &&
-         order[l_index] < order[r_index];
-#endif
-}
-
-// GCC selects the built-in operator< over an operator rewritten from
-// a user-defined spaceship operator
-// Clang, MSVC, and ICC select the rewritten candidate
-// (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200)
-#if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__)
-inline bool operator<(const value_t lhs, const value_t rhs) noexcept {
-  return std::is_lt(lhs <=> rhs); // *NOPAD*
-}
-#endif
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/string_escape.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// #include <nlohmann/detail/abi_macros.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-/*!
-@brief replace all occurrences of a substring by another string
-
-@param[in,out] s  the string to manipulate; changed so that all
-               occurrences of @a f are replaced with @a t
-@param[in]     f  the substring to replace with @a t
-@param[in]     t  the string to replace @a f
-
-@pre The search string @a f must not be empty. **This precondition is
-enforced with an assertion.**
-
-@since version 2.0.0
-*/
-template <typename StringType>
-inline void replace_substring(StringType &s, const StringType &f,
-                              const StringType &t) {
-  JSON_ASSERT(!f.empty());
-  for (auto pos = s.find(f);            // find first occurrence of f
-       pos != StringType::npos;         // make sure f was found
-       s.replace(pos, f.size(), t),     // replace with t, and
-       pos = s.find(f, pos + t.size())) // find next occurrence of f
-  {
-  }
-}
-
-/*!
- * @brief string escaping as described in RFC 6901 (Sect. 4)
- * @param[in] s string to escape
- * @return    escaped string
- *
- * Note the order of escaping "~" to "~0" and "/" to "~1" is important.
- */
-template <typename StringType> inline StringType escape(StringType s) {
-  replace_substring(s, StringType{"~"}, StringType{"~0"});
-  replace_substring(s, StringType{"/"}, StringType{"~1"});
-  return s;
-}
-
-/*!
- * @brief string unescaping as described in RFC 6901 (Sect. 4)
- * @param[in] s string to unescape
- * @return    unescaped string
- *
- * Note the order of escaping "~1" to "/" and "~0" to "~" is important.
- */
-template <typename StringType> static void unescape(StringType &s) {
-  replace_substring(s, StringType{"~1"}, StringType{"/"});
-  replace_substring(s, StringType{"~0"}, StringType{"~"});
-}
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/input/position_t.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <cstddef> // size_t
-
-// #include <nlohmann/detail/abi_macros.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-/// struct to capture the start position of the current token
-struct position_t {
-  /// the total number of characters read
-  std::size_t chars_read_total = 0;
-  /// the number of characters read in the current line
-  std::size_t chars_read_current_line = 0;
-  /// the number of lines read
-  std::size_t lines_read = 0;
-
-  /// conversion to size_t to preserve SAX interface
-  constexpr operator size_t() const { return chars_read_total; }
-};
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/meta/cpp_future.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-FileCopyrightText: 2018 The Abseil Authors
-// SPDX-License-Identifier: MIT
-
-#include <array>       // array
-#include <cstddef>     // size_t
-#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
-#include <utility> // index_sequence, make_index_sequence, index_sequence_for
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-template <typename T>
-using uncvref_t =
-    typename std::remove_cv<typename std::remove_reference<T>::type>::type;
-
-#ifdef JSON_HAS_CPP_14
-
-// the following utilities are natively available in C++14
-using std::enable_if_t;
-using std::index_sequence;
-using std::index_sequence_for;
-using std::make_index_sequence;
-
-#else
-
-// alias templates to reduce boilerplate
-template <bool B, typename T = void>
-using enable_if_t = typename std::enable_if<B, T>::type;
-
-// The following code is taken from
-// https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h
-// which is part of Google Abseil (https://github.com/abseil/abseil-cpp),
-// licensed under the Apache License 2.0.
-
-//// START OF CODE FROM GOOGLE ABSEIL
-
-// integer_sequence
-//
-// Class template representing a compile-time integer sequence. An instantiation
-// of `integer_sequence<T, Ints...>` has a sequence of integers encoded in its
-// type through its template arguments (which is a common need when
-// working with C++11 variadic templates). `absl::integer_sequence` is designed
-// to be a drop-in replacement for C++14's `std::integer_sequence`.
-//
-// Example:
-//
-//   template< class T, T... Ints >
-//   void user_function(integer_sequence<T, Ints...>);
-//
-//   int main()
-//   {
-//     // user_function's `T` will be deduced to `int` and `Ints...`
-//     // will be deduced to `0, 1, 2, 3, 4`.
-//     user_function(make_integer_sequence<int, 5>());
-//   }
-template <typename T, T... Ints> struct integer_sequence {
-  using value_type = T;
-  static constexpr std::size_t size() noexcept { return sizeof...(Ints); }
-};
-
-// index_sequence
-//
-// A helper template for an `integer_sequence` of `size_t`,
-// `absl::index_sequence` is designed to be a drop-in replacement for C++14's
-// `std::index_sequence`.
-template <size_t... Ints>
-using index_sequence = integer_sequence<size_t, Ints...>;
-
-namespace utility_internal {
-
-template <typename Seq, size_t SeqSize, size_t Rem> struct Extend;
-
-// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency.
-template <typename T, T... Ints, size_t SeqSize>
-struct Extend<integer_sequence<T, Ints...>, SeqSize, 0> {
-  using type = integer_sequence<T, Ints..., (Ints + SeqSize)...>;
-};
-
-template <typename T, T... Ints, size_t SeqSize>
-struct Extend<integer_sequence<T, Ints...>, SeqSize, 1> {
-  using type = integer_sequence<T, Ints..., (Ints + SeqSize)..., 2 * SeqSize>;
-};
-
-// Recursion helper for 'make_integer_sequence<T, N>'.
-// 'Gen<T, N>::type' is an alias for 'integer_sequence<T, 0, 1, ... N-1>'.
-template <typename T, size_t N> struct Gen {
-  using type =
-      typename Extend<typename Gen<T, N / 2>::type, N / 2, N % 2>::type;
-};
-
-template <typename T> struct Gen<T, 0> {
-  using type = integer_sequence<T>;
-};
-
-} // namespace utility_internal
-
-// Compile-time sequences of integers
-
-// make_integer_sequence
-//
-// This template alias is equivalent to
-// `integer_sequence<int, 0, 1, ..., N-1>`, and is designed to be a drop-in
-// replacement for C++14's `std::make_integer_sequence`.
-template <typename T, T N>
-using make_integer_sequence = typename utility_internal::Gen<T, N>::type;
-
-// make_index_sequence
-//
-// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`,
-// and is designed to be a drop-in replacement for C++14's
-// `std::make_index_sequence`.
-template <size_t N>
-using make_index_sequence = make_integer_sequence<size_t, N>;
-
-// index_sequence_for
-//
-// Converts a typename pack into an index sequence of the same length, and
-// is designed to be a drop-in replacement for C++14's
-// `std::index_sequence_for()`
-template <typename... Ts>
-using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
-
-//// END OF CODE FROM GOOGLE ABSEIL
-
-#endif
-
-// dispatch utility (taken from ranges-v3)
-template <unsigned N> struct priority_tag : priority_tag<N - 1> {};
-template <> struct priority_tag<0> {};
-
-// taken from ranges-v3
-template <typename T> struct static_const {
-  static JSON_INLINE_VARIABLE constexpr T value{};
-};
-
-#ifndef JSON_HAS_CPP_17
-template <typename T> constexpr T static_const<T>::value;
-#endif
-
-template <typename T, typename... Args>
-constexpr std::array<T, sizeof...(Args)> make_array(Args &&...args) {
-  return std::array<T, sizeof...(Args)>{
-      {static_cast<T>(std::forward<Args>(args))...}};
-}
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/meta/type_traits.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <limits> // numeric_limits
-#include <string> // char_traits
-#include <tuple>  // tuple
-#include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
-#include <utility> // declval
-
-// #include <nlohmann/detail/iterators/iterator_traits.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <iterator> // random_access_iterator_tag
-
-// #include <nlohmann/detail/abi_macros.hpp>
-
-// #include <nlohmann/detail/meta/void_t.hpp>
-
-// #include <nlohmann/detail/meta/cpp_future.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-template <typename It, typename = void> struct iterator_types {};
-
-template <typename It>
-struct iterator_types<
-    It, void_t<typename It::difference_type, typename It::value_type,
-               typename It::pointer, typename It::reference,
-               typename It::iterator_category>> {
-  using difference_type = typename It::difference_type;
-  using value_type = typename It::value_type;
-  using pointer = typename It::pointer;
-  using reference = typename It::reference;
-  using iterator_category = typename It::iterator_category;
-};
-
-// This is required as some compilers implement std::iterator_traits in a way
-// that doesn't work with SFINAE. See
-// https://github.com/nlohmann/json/issues/1341.
-template <typename T, typename = void> struct iterator_traits {};
-
-template <typename T>
-struct iterator_traits<T, enable_if_t<!std::is_pointer<T>::value>>
-    : iterator_types<T> {};
-
-template <typename T>
-struct iterator_traits<T *, enable_if_t<std::is_object<T>::value>> {
-  using iterator_category = std::random_access_iterator_tag;
-  using value_type = T;
-  using difference_type = ptrdiff_t;
-  using pointer = T *;
-  using reference = T &;
-};
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/meta/call_std/begin.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-
-NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin);
-
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/meta/call_std/end.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-
-NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end);
-
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/meta/cpp_future.hpp>
-
-// #include <nlohmann/detail/meta/detected.hpp>
-
-// #include <nlohmann/json_fwd.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
-#define INCLUDE_NLOHMANN_JSON_FWD_HPP_
-
-#include <cstdint> // int64_t, uint64_t
-#include <map>     // map
-#include <memory>  // allocator
-#include <string>  // string
-#include <vector>  // vector
-
-// #include <nlohmann/detail/abi_macros.hpp>
-
-/*!
-@brief namespace for Niels Lohmann
-@see https://github.com/nlohmann
-@since version 1.0.0
-*/
-NLOHMANN_JSON_NAMESPACE_BEGIN
-
-/*!
-@brief default JSONSerializer template argument
-
-This serializer ignores the template arguments and uses ADL
-([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
-for serialization.
-*/
-template <typename T = void, typename SFINAE = void> struct adl_serializer;
-
-/// a class to store JSON values
-/// @sa https://json.nlohmann.me/api/basic_json/
-template <template <typename U, typename V, typename... Args> class ObjectType =
-              std::map,
-          template <typename U, typename... Args> class ArrayType = std::vector,
-          class StringType = std::string, class BooleanType = bool,
-          class NumberIntegerType = std::int64_t,
-          class NumberUnsignedType = std::uint64_t,
-          class NumberFloatType = double,
-          template <typename U> class AllocatorType = std::allocator,
-          template <typename T, typename SFINAE = void> class JSONSerializer =
-              adl_serializer,
-          class BinaryType =
-              std::vector<std::uint8_t>, // cppcheck-suppress syntaxError
-          class CustomBaseClass = void>
-class basic_json;
-
-/// @brief JSON Pointer defines a string syntax for identifying a specific value
-/// within a JSON document
-/// @sa https://json.nlohmann.me/api/json_pointer/
-template <typename RefStringType> class json_pointer;
-
-/*!
-@brief default specialization
-@sa https://json.nlohmann.me/api/json/
-*/
-using json = basic_json<>;
-
-/// @brief a minimal map-like container that preserves insertion order
-/// @sa https://json.nlohmann.me/api/ordered_map/
-template <class Key, class T, class IgnoredLess, class Allocator>
-struct ordered_map;
-
-/// @brief specialization that maintains the insertion order of object keys
-/// @sa https://json.nlohmann.me/api/ordered_json/
-using ordered_json = basic_json<nlohmann::ordered_map>;
-
-NLOHMANN_JSON_NAMESPACE_END
-
-#endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-/*!
-@brief detail namespace with internal helper functions
-
-This namespace collects functions that should not be exposed,
-implementations of some @ref basic_json methods, and meta-programming helpers.
-
-@since version 2.1.0
-*/
-namespace detail {
-
-/////////////
-// helpers //
-/////////////
-
-// Note to maintainers:
-//
-// Every trait in this file expects a non CV-qualified type.
-// The only exceptions are in the 'aliases for detected' section
-// (i.e. those of the form: decltype(T::member_function(std::declval<T>())))
-//
-// In this case, T has to be properly CV-qualified to constraint the function
-// arguments (e.g. to_json(BasicJsonType&, const T&))
-
-template <typename> struct is_basic_json : std::false_type {};
-
-NLOHMANN_BASIC_JSON_TPL_DECLARATION
-struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
-
-// used by exceptions create() member functions
-// true_type for pointer to possibly cv-qualified basic_json or std::nullptr_t
-// false_type otherwise
-template <typename BasicJsonContext>
-struct is_basic_json_context
-    : std::integral_constant<
-          bool,
-          is_basic_json<typename std::remove_cv<typename std::remove_pointer<
-              BasicJsonContext>::type>::type>::value ||
-              std::is_same<BasicJsonContext, std::nullptr_t>::value> {};
-
-//////////////////////
-// json_ref helpers //
-//////////////////////
-
-template <typename> class json_ref;
-
-template <typename> struct is_json_ref : std::false_type {};
-
-template <typename T> struct is_json_ref<json_ref<T>> : std::true_type {};
-
-//////////////////////////
-// aliases for detected //
-//////////////////////////
-
-template <typename T> using mapped_type_t = typename T::mapped_type;
-
-template <typename T> using key_type_t = typename T::key_type;
-
-template <typename T> using value_type_t = typename T::value_type;
-
-template <typename T> using difference_type_t = typename T::difference_type;
-
-template <typename T> using pointer_t = typename T::pointer;
-
-template <typename T> using reference_t = typename T::reference;
-
-template <typename T> using iterator_category_t = typename T::iterator_category;
-
-template <typename T, typename... Args>
-using to_json_function = decltype(T::to_json(std::declval<Args>()...));
-
-template <typename T, typename... Args>
-using from_json_function = decltype(T::from_json(std::declval<Args>()...));
-
-template <typename T, typename U>
-using get_template_function = decltype(std::declval<T>().template get<U>());
-
-// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
-template <typename BasicJsonType, typename T, typename = void>
-struct has_from_json : std::false_type {};
-
-// trait checking if j.get<T> is valid
-// use this trait instead of std::is_constructible or std::is_convertible,
-// both rely on, or make use of implicit conversions, and thus fail when T
-// has several constructors/operator= (see
-// https://github.com/nlohmann/json/issues/958)
-template <typename BasicJsonType, typename T> struct is_getable {
-  static constexpr bool value =
-      is_detected<get_template_function, const BasicJsonType &, T>::value;
-};
-
-template <typename BasicJsonType, typename T>
-struct has_from_json<BasicJsonType, T, enable_if_t<!is_basic_json<T>::value>> {
-  using serializer = typename BasicJsonType::template json_serializer<T, void>;
-
-  static constexpr bool value =
-      is_detected_exact<void, from_json_function, serializer,
-                        const BasicJsonType &, T &>::value;
-};
-
-// This trait checks if JSONSerializer<T>::from_json(json const&) exists
-// this overload is used for non-default-constructible user-defined-types
-template <typename BasicJsonType, typename T, typename = void>
-struct has_non_default_from_json : std::false_type {};
-
-template <typename BasicJsonType, typename T>
-struct has_non_default_from_json<BasicJsonType, T,
-                                 enable_if_t<!is_basic_json<T>::value>> {
-  using serializer = typename BasicJsonType::template json_serializer<T, void>;
-
-  static constexpr bool value =
-      is_detected_exact<T, from_json_function, serializer,
-                        const BasicJsonType &>::value;
-};
-
-// This trait checks if BasicJsonType::json_serializer<T>::to_json exists
-// Do not evaluate the trait when T is a basic_json type, to avoid template
-// instantiation infinite recursion.
-template <typename BasicJsonType, typename T, typename = void>
-struct has_to_json : std::false_type {};
-
-template <typename BasicJsonType, typename T>
-struct has_to_json<BasicJsonType, T, enable_if_t<!is_basic_json<T>::value>> {
-  using serializer = typename BasicJsonType::template json_serializer<T, void>;
-
-  static constexpr bool value =
-      is_detected_exact<void, to_json_function, serializer, BasicJsonType &,
-                        T>::value;
-};
-
-template <typename T> using detect_key_compare = typename T::key_compare;
-
-template <typename T>
-struct has_key_compare
-    : std::integral_constant<bool, is_detected<detect_key_compare, T>::value> {
-};
-
-// obtains the actual object key comparator
-template <typename BasicJsonType> struct actual_object_comparator {
-  using object_t = typename BasicJsonType::object_t;
-  using object_comparator_t =
-      typename BasicJsonType::default_object_comparator_t;
-  using type = typename std::conditional<has_key_compare<object_t>::value,
-                                         typename object_t::key_compare,
-                                         object_comparator_t>::type;
-};
-
-template <typename BasicJsonType>
-using actual_object_comparator_t =
-    typename actual_object_comparator<BasicJsonType>::type;
-
-/////////////////
-// char_traits //
-/////////////////
-
-// Primary template of char_traits calls std char_traits
-template <typename T> struct char_traits : std::char_traits<T> {};
-
-// Explicitly define char traits for unsigned char since it is not standard
-template <> struct char_traits<unsigned char> : std::char_traits<char> {
-  using char_type = unsigned char;
-  using int_type = uint64_t;
-
-  // Redefine to_int_type function
-  static int_type to_int_type(char_type c) noexcept {
-    return static_cast<int_type>(c);
-  }
-
-  static char_type to_char_type(int_type i) noexcept {
-    return static_cast<char_type>(i);
-  }
-
-  static constexpr int_type eof() noexcept {
-    return static_cast<int_type>(std::char_traits<char>::eof());
-  }
-};
-
-// Explicitly define char traits for signed char since it is not standard
-template <> struct char_traits<signed char> : std::char_traits<char> {
-  using char_type = signed char;
-  using int_type = uint64_t;
-
-  // Redefine to_int_type function
-  static int_type to_int_type(char_type c) noexcept {
-    return static_cast<int_type>(c);
-  }
-
-  static char_type to_char_type(int_type i) noexcept {
-    return static_cast<char_type>(i);
-  }
-
-  static constexpr int_type eof() noexcept {
-    return static_cast<int_type>(std::char_traits<char>::eof());
-  }
-};
-
-///////////////////
-// is_ functions //
-///////////////////
-
-// https://en.cppreference.com/w/cpp/types/conjunction
-template <class...> struct conjunction : std::true_type {};
-template <class B> struct conjunction<B> : B {};
-template <class B, class... Bn>
-struct conjunction<B, Bn...> : std::conditional<static_cast<bool>(B::value),
-                                                conjunction<Bn...>, B>::type {};
-
-// https://en.cppreference.com/w/cpp/types/negation
-template <class B> struct negation : std::integral_constant<bool, !B::value> {};
-
-// Reimplementation of is_constructible and is_default_constructible, due to
-// them being broken for std::pair and std::tuple until LWG 2367 fix (see
-// https://cplusplus.github.io/LWG/lwg-defects.html#2367). This causes compile
-// errors in e.g. clang 3.5 or gcc 4.9.
-template <typename T>
-struct is_default_constructible : std::is_default_constructible<T> {};
-
-template <typename T1, typename T2>
-struct is_default_constructible<std::pair<T1, T2>>
-    : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {
-};
-
-template <typename T1, typename T2>
-struct is_default_constructible<const std::pair<T1, T2>>
-    : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {
-};
-
-template <typename... Ts>
-struct is_default_constructible<std::tuple<Ts...>>
-    : conjunction<is_default_constructible<Ts>...> {};
-
-template <typename... Ts>
-struct is_default_constructible<const std::tuple<Ts...>>
-    : conjunction<is_default_constructible<Ts>...> {};
-
-template <typename T, typename... Args>
-struct is_constructible : std::is_constructible<T, Args...> {};
-
-template <typename T1, typename T2>
-struct is_constructible<std::pair<T1, T2>>
-    : is_default_constructible<std::pair<T1, T2>> {};
-
-template <typename T1, typename T2>
-struct is_constructible<const std::pair<T1, T2>>
-    : is_default_constructible<const std::pair<T1, T2>> {};
-
-template <typename... Ts>
-struct is_constructible<std::tuple<Ts...>>
-    : is_default_constructible<std::tuple<Ts...>> {};
-
-template <typename... Ts>
-struct is_constructible<const std::tuple<Ts...>>
-    : is_default_constructible<const std::tuple<Ts...>> {};
-
-template <typename T, typename = void>
-struct is_iterator_traits : std::false_type {};
-
-template <typename T> struct is_iterator_traits<iterator_traits<T>> {
-private:
-  using traits = iterator_traits<T>;
-
-public:
-  static constexpr auto value =
-      is_detected<value_type_t, traits>::value &&
-      is_detected<difference_type_t, traits>::value &&
-      is_detected<pointer_t, traits>::value &&
-      is_detected<iterator_category_t, traits>::value &&
-      is_detected<reference_t, traits>::value;
-};
-
-template <typename T> struct is_range {
-private:
-  using t_ref = typename std::add_lvalue_reference<T>::type;
-
-  using iterator = detected_t<result_of_begin, t_ref>;
-  using sentinel = detected_t<result_of_end, t_ref>;
-
-  // to be 100% correct, it should use
-  // https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator and
-  // https://en.cppreference.com/w/cpp/iterator/sentinel_for but reimplementing
-  // these would be too much work, as a lot of other concepts are used
-  // underneath
-  static constexpr auto is_iterator_begin =
-      is_iterator_traits<iterator_traits<iterator>>::value;
-
-public:
-  static constexpr bool value = !std::is_same<iterator, nonesuch>::value &&
-                                !std::is_same<sentinel, nonesuch>::value &&
-                                is_iterator_begin;
-};
-
-template <typename R>
-using iterator_t = enable_if_t<is_range<R>::value,
-                               result_of_begin<decltype(std::declval<R &>())>>;
-
-template <typename T>
-using range_value_t = value_type_t<iterator_traits<iterator_t<T>>>;
-
-// The following implementation of is_complete_type is taken from
-// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/
-// and is written by Xiang Fan who agreed to using it in this library.
-
-template <typename T, typename = void>
-struct is_complete_type : std::false_type {};
-
-template <typename T>
-struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
-
-template <typename BasicJsonType, typename CompatibleObjectType,
-          typename = void>
-struct is_compatible_object_type_impl : std::false_type {};
-
-template <typename BasicJsonType, typename CompatibleObjectType>
-struct is_compatible_object_type_impl<
-    BasicJsonType, CompatibleObjectType,
-    enable_if_t<is_detected<mapped_type_t, CompatibleObjectType>::value &&
-                is_detected<key_type_t, CompatibleObjectType>::value>> {
-  using object_t = typename BasicJsonType::object_t;
-
-  // macOS's is_constructible does not play well with nonesuch...
-  static constexpr bool value =
-      is_constructible<typename object_t::key_type,
-                       typename CompatibleObjectType::key_type>::value &&
-      is_constructible<typename object_t::mapped_type,
-                       typename CompatibleObjectType::mapped_type>::value;
-};
-
-template <typename BasicJsonType, typename CompatibleObjectType>
-struct is_compatible_object_type
-    : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
-
-template <typename BasicJsonType, typename ConstructibleObjectType,
-          typename = void>
-struct is_constructible_object_type_impl : std::false_type {};
-
-template <typename BasicJsonType, typename ConstructibleObjectType>
-struct is_constructible_object_type_impl<
-    BasicJsonType, ConstructibleObjectType,
-    enable_if_t<is_detected<mapped_type_t, ConstructibleObjectType>::value &&
-                is_detected<key_type_t, ConstructibleObjectType>::value>> {
-  using object_t = typename BasicJsonType::object_t;
-
-  static constexpr bool value =
-      (is_default_constructible<ConstructibleObjectType>::value &&
-       (std::is_move_assignable<ConstructibleObjectType>::value ||
-        std::is_copy_assignable<ConstructibleObjectType>::value) &&
-       (is_constructible<typename ConstructibleObjectType::key_type,
-                         typename object_t::key_type>::value &&
-        std::is_same<typename object_t::mapped_type,
-                     typename ConstructibleObjectType::mapped_type>::value)) ||
-      (has_from_json<BasicJsonType,
-                     typename ConstructibleObjectType::mapped_type>::value ||
-       has_non_default_from_json<
-           BasicJsonType,
-           typename ConstructibleObjectType::mapped_type>::value);
-};
-
-template <typename BasicJsonType, typename ConstructibleObjectType>
-struct is_constructible_object_type
-    : is_constructible_object_type_impl<BasicJsonType,
-                                        ConstructibleObjectType> {};
-
-template <typename BasicJsonType, typename CompatibleStringType>
-struct is_compatible_string_type {
-  static constexpr auto value =
-      is_constructible<typename BasicJsonType::string_t,
-                       CompatibleStringType>::value;
-};
-
-template <typename BasicJsonType, typename ConstructibleStringType>
-struct is_constructible_string_type {
-  // launder type through decltype() to fix compilation failure on ICPC
-#ifdef __INTEL_COMPILER
-  using laundered_type = decltype(std::declval<ConstructibleStringType>());
-#else
-  using laundered_type = ConstructibleStringType;
-#endif
-
-  static constexpr auto value = conjunction<
-      is_constructible<laundered_type, typename BasicJsonType::string_t>,
-      is_detected_exact<typename BasicJsonType::string_t::value_type,
-                        value_type_t, laundered_type>>::value;
-};
-
-template <typename BasicJsonType, typename CompatibleArrayType, typename = void>
-struct is_compatible_array_type_impl : std::false_type {};
-
-template <typename BasicJsonType, typename CompatibleArrayType>
-struct is_compatible_array_type_impl<
-    BasicJsonType, CompatibleArrayType,
-    enable_if_t<
-        is_detected<iterator_t, CompatibleArrayType>::value &&
-        is_iterator_traits<iterator_traits<
-            detected_t<iterator_t, CompatibleArrayType>>>::value &&
-        // special case for types like std::filesystem::path whose iterator's
-        // value_type are themselves c.f.
-        // https://github.com/nlohmann/json/pull/3073
-        !std::is_same<CompatibleArrayType,
-                      detected_t<range_value_t, CompatibleArrayType>>::value>> {
-  static constexpr bool value =
-      is_constructible<BasicJsonType,
-                       range_value_t<CompatibleArrayType>>::value;
-};
-
-template <typename BasicJsonType, typename CompatibleArrayType>
-struct is_compatible_array_type
-    : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
-
-template <typename BasicJsonType, typename ConstructibleArrayType,
-          typename = void>
-struct is_constructible_array_type_impl : std::false_type {};
-
-template <typename BasicJsonType, typename ConstructibleArrayType>
-struct is_constructible_array_type_impl<
-    BasicJsonType, ConstructibleArrayType,
-    enable_if_t<std::is_same<ConstructibleArrayType,
-                             typename BasicJsonType::value_type>::value>>
-    : std::true_type {};
-
-template <typename BasicJsonType, typename ConstructibleArrayType>
-struct is_constructible_array_type_impl<
-    BasicJsonType, ConstructibleArrayType,
-    enable_if_t<!std::is_same<ConstructibleArrayType,
-                              typename BasicJsonType::value_type>::value &&
-                !is_compatible_string_type<BasicJsonType,
-                                           ConstructibleArrayType>::value &&
-                is_default_constructible<ConstructibleArrayType>::value &&
-                (std::is_move_assignable<ConstructibleArrayType>::value ||
-                 std::is_copy_assignable<ConstructibleArrayType>::value) &&
-                is_detected<iterator_t, ConstructibleArrayType>::value &&
-                is_iterator_traits<iterator_traits<
-                    detected_t<iterator_t, ConstructibleArrayType>>>::value &&
-                is_detected<range_value_t, ConstructibleArrayType>::value &&
-                // special case for types like std::filesystem::path whose
-                // iterator's value_type are themselves c.f.
-                // https://github.com/nlohmann/json/pull/3073
-                !std::is_same<
-                    ConstructibleArrayType,
-                    detected_t<range_value_t, ConstructibleArrayType>>::value &&
-                is_complete_type<detected_t<range_value_t,
-                                            ConstructibleArrayType>>::value>> {
-  using value_type = range_value_t<ConstructibleArrayType>;
-
-  static constexpr bool value =
-      std::is_same<value_type,
-                   typename BasicJsonType::array_t::value_type>::value ||
-      has_from_json<BasicJsonType, value_type>::value ||
-      has_non_default_from_json<BasicJsonType, value_type>::value;
-};
-
-template <typename BasicJsonType, typename ConstructibleArrayType>
-struct is_constructible_array_type
-    : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {
-};
-
-template <typename RealIntegerType, typename CompatibleNumberIntegerType,
-          typename = void>
-struct is_compatible_integer_type_impl : std::false_type {};
-
-template <typename RealIntegerType, typename CompatibleNumberIntegerType>
-struct is_compatible_integer_type_impl<
-    RealIntegerType, CompatibleNumberIntegerType,
-    enable_if_t<std::is_integral<RealIntegerType>::value &&
-                std::is_integral<CompatibleNumberIntegerType>::value &&
-                !std::is_same<bool, CompatibleNumberIntegerType>::value>> {
-  // is there an assert somewhere on overflows?
-  using RealLimits = std::numeric_limits<RealIntegerType>;
-  using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
-
-  static constexpr auto value =
-      is_constructible<RealIntegerType, CompatibleNumberIntegerType>::value &&
-      CompatibleLimits::is_integer &&
-      RealLimits::is_signed == CompatibleLimits::is_signed;
-};
-
-template <typename RealIntegerType, typename CompatibleNumberIntegerType>
-struct is_compatible_integer_type
-    : is_compatible_integer_type_impl<RealIntegerType,
-                                      CompatibleNumberIntegerType> {};
-
-template <typename BasicJsonType, typename CompatibleType, typename = void>
-struct is_compatible_type_impl : std::false_type {};
-
-template <typename BasicJsonType, typename CompatibleType>
-struct is_compatible_type_impl<
-    BasicJsonType, CompatibleType,
-    enable_if_t<is_complete_type<CompatibleType>::value>> {
-  static constexpr bool value =
-      has_to_json<BasicJsonType, CompatibleType>::value;
-};
-
-template <typename BasicJsonType, typename CompatibleType>
-struct is_compatible_type
-    : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
-
-template <typename T1, typename T2>
-struct is_constructible_tuple : std::false_type {};
-
-template <typename T1, typename... Args>
-struct is_constructible_tuple<T1, std::tuple<Args...>>
-    : conjunction<is_constructible<T1, Args>...> {};
-
-template <typename BasicJsonType, typename T>
-struct is_json_iterator_of : std::false_type {};
-
-template <typename BasicJsonType>
-struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::iterator>
-    : std::true_type {};
-
-template <typename BasicJsonType>
-struct is_json_iterator_of<BasicJsonType,
-                           typename BasicJsonType::const_iterator>
-    : std::true_type {};
-
-// checks if a given type T is a template specialization of Primary
-template <template <typename...> class Primary, typename T>
-struct is_specialization_of : std::false_type {};
-
-template <template <typename...> class Primary, typename... Args>
-struct is_specialization_of<Primary, Primary<Args...>> : std::true_type {};
-
-template <typename T>
-using is_json_pointer =
-    is_specialization_of<::nlohmann::json_pointer, uncvref_t<T>>;
-
-// checks if A and B are comparable using Compare functor
-template <typename Compare, typename A, typename B, typename = void>
-struct is_comparable : std::false_type {};
-
-template <typename Compare, typename A, typename B>
-struct is_comparable<Compare, A, B,
-                     void_t<decltype(std::declval<Compare>()(
-                                std::declval<A>(), std::declval<B>())),
-                            decltype(std::declval<Compare>()(
-                                std::declval<B>(), std::declval<A>()))>>
-    : std::true_type {};
-
-template <typename T> using detect_is_transparent = typename T::is_transparent;
-
-// type trait to check if KeyType can be used as object key (without a
-// BasicJsonType) see is_usable_as_basic_json_key_type below
-template <typename Comparator, typename ObjectKeyType, typename KeyTypeCVRef,
-          bool RequireTransparentComparator = true,
-          bool ExcludeObjectKeyType = RequireTransparentComparator,
-          typename KeyType = uncvref_t<KeyTypeCVRef>>
-using is_usable_as_key_type = typename std::conditional<
-    is_comparable<Comparator, ObjectKeyType, KeyTypeCVRef>::value &&
-        !(ExcludeObjectKeyType &&
-          std::is_same<KeyType, ObjectKeyType>::value) &&
-        (!RequireTransparentComparator ||
-         is_detected<detect_is_transparent, Comparator>::value) &&
-        !is_json_pointer<KeyType>::value,
-    std::true_type, std::false_type>::type;
-
-// type trait to check if KeyType can be used as object key
-// true if:
-//   - KeyType is comparable with BasicJsonType::object_t::key_type
-//   - if ExcludeObjectKeyType is true, KeyType is not
-//   BasicJsonType::object_t::key_type
-//   - the comparator is transparent or RequireTransparentComparator is false
-//   - KeyType is not a JSON iterator or json_pointer
-template <typename BasicJsonType, typename KeyTypeCVRef,
-          bool RequireTransparentComparator = true,
-          bool ExcludeObjectKeyType = RequireTransparentComparator,
-          typename KeyType = uncvref_t<KeyTypeCVRef>>
-using is_usable_as_basic_json_key_type = typename std::conditional<
-    is_usable_as_key_type<typename BasicJsonType::object_comparator_t,
-                          typename BasicJsonType::object_t::key_type,
-                          KeyTypeCVRef, RequireTransparentComparator,
-                          ExcludeObjectKeyType>::value &&
-        !is_json_iterator_of<BasicJsonType, KeyType>::value,
-    std::true_type, std::false_type>::type;
-
-template <typename ObjectType, typename KeyType>
-using detect_erase_with_key_type =
-    decltype(std::declval<ObjectType &>().erase(std::declval<KeyType>()));
-
-// type trait to check if object_t has an erase() member functions accepting
-// KeyType
-template <typename BasicJsonType, typename KeyType>
-using has_erase_with_key_type = typename std::conditional<
-    is_detected<detect_erase_with_key_type, typename BasicJsonType::object_t,
-                KeyType>::value,
-    std::true_type, std::false_type>::type;
-
-// a naive helper to check if a type is an ordered_map (exploits the fact that
-// ordered_map inherits capacity() from std::vector)
-template <typename T> struct is_ordered_map {
-  using one = char;
-
-  struct two {
-    char x
-        [2]; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
-  };
-
-  template <typename C> static one test(decltype(&C::capacity));
-  template <typename C> static two test(...);
-
-  enum {
-    value = sizeof(test<T>(nullptr)) == sizeof(char)
-  }; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
-};
-
-// to avoid useless casts (see
-// https://github.com/nlohmann/json/issues/2893#issuecomment-889152324)
-template <typename T, typename U,
-          enable_if_t<!std::is_same<T, U>::value, int> = 0>
-T conditional_static_cast(U value) {
-  return static_cast<T>(value);
-}
-
-template <typename T, typename U,
-          enable_if_t<std::is_same<T, U>::value, int> = 0>
-T conditional_static_cast(U value) {
-  return value;
-}
-
-template <typename... Types>
-using all_integral = conjunction<std::is_integral<Types>...>;
-
-template <typename... Types>
-using all_signed = conjunction<std::is_signed<Types>...>;
-
-template <typename... Types>
-using all_unsigned = conjunction<std::is_unsigned<Types>...>;
-
-// there's a disjunction trait in another PR; replace when merged
-template <typename... Types>
-using same_sign =
-    std::integral_constant<bool, all_signed<Types...>::value ||
-                                     all_unsigned<Types...>::value>;
-
-template <typename OfType, typename T>
-using never_out_of_range = std::integral_constant<
-    bool, (std::is_signed<OfType>::value && (sizeof(T) < sizeof(OfType))) ||
-              (same_sign<OfType, T>::value && sizeof(OfType) == sizeof(T))>;
-
-template <typename OfType, typename T,
-          bool OfTypeSigned = std::is_signed<OfType>::value,
-          bool TSigned = std::is_signed<T>::value>
-struct value_in_range_of_impl2;
-
-template <typename OfType, typename T>
-struct value_in_range_of_impl2<OfType, T, false, false> {
-  static constexpr bool test(T val) {
-    using CommonType = typename std::common_type<OfType, T>::type;
-    return static_cast<CommonType>(val) <=
-           static_cast<CommonType>((std::numeric_limits<OfType>::max)());
-  }
-};
-
-template <typename OfType, typename T>
-struct value_in_range_of_impl2<OfType, T, true, false> {
-  static constexpr bool test(T val) {
-    using CommonType = typename std::common_type<OfType, T>::type;
-    return static_cast<CommonType>(val) <=
-           static_cast<CommonType>((std::numeric_limits<OfType>::max)());
-  }
-};
-
-template <typename OfType, typename T>
-struct value_in_range_of_impl2<OfType, T, false, true> {
-  static constexpr bool test(T val) {
-    using CommonType = typename std::common_type<OfType, T>::type;
-    return val >= 0 &&
-           static_cast<CommonType>(val) <=
-               static_cast<CommonType>((std::numeric_limits<OfType>::max)());
-  }
-};
-
-template <typename OfType, typename T>
-struct value_in_range_of_impl2<OfType, T, true, true> {
-  static constexpr bool test(T val) {
-    using CommonType = typename std::common_type<OfType, T>::type;
-    return static_cast<CommonType>(val) >=
-               static_cast<CommonType>((std::numeric_limits<OfType>::min)()) &&
-           static_cast<CommonType>(val) <=
-               static_cast<CommonType>((std::numeric_limits<OfType>::max)());
-  }
-};
-
-template <typename OfType, typename T,
-          bool NeverOutOfRange = never_out_of_range<OfType, T>::value,
-          typename = detail::enable_if_t<all_integral<OfType, T>::value>>
-struct value_in_range_of_impl1;
-
-template <typename OfType, typename T>
-struct value_in_range_of_impl1<OfType, T, false> {
-  static constexpr bool test(T val) {
-    return value_in_range_of_impl2<OfType, T>::test(val);
-  }
-};
-
-template <typename OfType, typename T>
-struct value_in_range_of_impl1<OfType, T, true> {
-  static constexpr bool test(T /*val*/) { return true; }
-};
-
-template <typename OfType, typename T> constexpr bool value_in_range_of(T val) {
-  return value_in_range_of_impl1<OfType, T>::test(val);
-}
-
-template <bool Value> using bool_constant = std::integral_constant<bool, Value>;
-
-///////////////////////////////////////////////////////////////////////////////
-// is_c_string
-///////////////////////////////////////////////////////////////////////////////
-
-namespace impl {
-
-template <typename T> constexpr bool is_c_string() {
-  using TUnExt = typename std::remove_extent<T>::type;
-  using TUnCVExt = typename std::remove_cv<TUnExt>::type;
-  using TUnPtr = typename std::remove_pointer<T>::type;
-  using TUnCVPtr = typename std::remove_cv<TUnPtr>::type;
-  return (std::is_array<T>::value && std::is_same<TUnCVExt, char>::value) ||
-         (std::is_pointer<T>::value && std::is_same<TUnCVPtr, char>::value);
-}
-
-} // namespace impl
-
-// checks whether T is a [cv] char */[cv] char[] C string
-template <typename T>
-struct is_c_string : bool_constant<impl::is_c_string<T>()> {};
-
-template <typename T> using is_c_string_uncvref = is_c_string<uncvref_t<T>>;
-
-///////////////////////////////////////////////////////////////////////////////
-// is_transparent
-///////////////////////////////////////////////////////////////////////////////
-
-namespace impl {
-
-template <typename T> constexpr bool is_transparent() {
-  return is_detected<detect_is_transparent, T>::value;
-}
-
-} // namespace impl
-
-// checks whether T has a member named is_transparent
-template <typename T>
-struct is_transparent : bool_constant<impl::is_transparent<T>()> {};
-
-///////////////////////////////////////////////////////////////////////////////
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/string_concat.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <cstring> // strlen
-#include <string>  // string
-#include <utility> // forward
-
-// #include <nlohmann/detail/meta/cpp_future.hpp>
-
-// #include <nlohmann/detail/meta/detected.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-inline std::size_t concat_length() { return 0; }
-
-template <typename... Args>
-inline std::size_t concat_length(const char *cstr, const Args &...rest);
-
-template <typename StringType, typename... Args>
-inline std::size_t concat_length(const StringType &str, const Args &...rest);
-
-template <typename... Args>
-inline std::size_t concat_length(const char /*c*/, const Args &...rest) {
-  return 1 + concat_length(rest...);
-}
-
-template <typename... Args>
-inline std::size_t concat_length(const char *cstr, const Args &...rest) {
-  // cppcheck-suppress ignoredReturnValue
-  return ::strlen(cstr) + concat_length(rest...);
-}
-
-template <typename StringType, typename... Args>
-inline std::size_t concat_length(const StringType &str, const Args &...rest) {
-  return str.size() + concat_length(rest...);
-}
-
-template <typename OutStringType>
-inline void concat_into(OutStringType & /*out*/) {}
-
-template <typename StringType, typename Arg>
-using string_can_append =
-    decltype(std::declval<StringType &>().append(std::declval<Arg &&>()));
-
-template <typename StringType, typename Arg>
-using detect_string_can_append =
-    is_detected<string_can_append, StringType, Arg>;
-
-template <typename StringType, typename Arg>
-using string_can_append_op =
-    decltype(std::declval<StringType &>() += std::declval<Arg &&>());
-
-template <typename StringType, typename Arg>
-using detect_string_can_append_op =
-    is_detected<string_can_append_op, StringType, Arg>;
-
-template <typename StringType, typename Arg>
-using string_can_append_iter = decltype(std::declval<StringType &>().append(
-    std::declval<const Arg &>().begin(), std::declval<const Arg &>().end()));
-
-template <typename StringType, typename Arg>
-using detect_string_can_append_iter =
-    is_detected<string_can_append_iter, StringType, Arg>;
-
-template <typename StringType, typename Arg>
-using string_can_append_data = decltype(std::declval<StringType &>().append(
-    std::declval<const Arg &>().data(), std::declval<const Arg &>().size()));
-
-template <typename StringType, typename Arg>
-using detect_string_can_append_data =
-    is_detected<string_can_append_data, StringType, Arg>;
-
-template <
-    typename OutStringType, typename Arg, typename... Args,
-    enable_if_t<!detect_string_can_append<OutStringType, Arg>::value &&
-                    detect_string_can_append_op<OutStringType, Arg>::value,
-                int> = 0>
-inline void concat_into(OutStringType &out, Arg &&arg, Args &&...rest);
-
-template <
-    typename OutStringType, typename Arg, typename... Args,
-    enable_if_t<!detect_string_can_append<OutStringType, Arg>::value &&
-                    !detect_string_can_append_op<OutStringType, Arg>::value &&
-                    detect_string_can_append_iter<OutStringType, Arg>::value,
-                int> = 0>
-inline void concat_into(OutStringType &out, const Arg &arg, Args &&...rest);
-
-template <
-    typename OutStringType, typename Arg, typename... Args,
-    enable_if_t<!detect_string_can_append<OutStringType, Arg>::value &&
-                    !detect_string_can_append_op<OutStringType, Arg>::value &&
-                    !detect_string_can_append_iter<OutStringType, Arg>::value &&
-                    detect_string_can_append_data<OutStringType, Arg>::value,
-                int> = 0>
-inline void concat_into(OutStringType &out, const Arg &arg, Args &&...rest);
-
-template <
-    typename OutStringType, typename Arg, typename... Args,
-    enable_if_t<detect_string_can_append<OutStringType, Arg>::value, int> = 0>
-inline void concat_into(OutStringType &out, Arg &&arg, Args &&...rest) {
-  out.append(std::forward<Arg>(arg));
-  concat_into(out, std::forward<Args>(rest)...);
-}
-
-template <
-    typename OutStringType, typename Arg, typename... Args,
-    enable_if_t<!detect_string_can_append<OutStringType, Arg>::value &&
-                    detect_string_can_append_op<OutStringType, Arg>::value,
-                int>>
-inline void concat_into(OutStringType &out, Arg &&arg, Args &&...rest) {
-  out += std::forward<Arg>(arg);
-  concat_into(out, std::forward<Args>(rest)...);
-}
-
-template <
-    typename OutStringType, typename Arg, typename... Args,
-    enable_if_t<!detect_string_can_append<OutStringType, Arg>::value &&
-                    !detect_string_can_append_op<OutStringType, Arg>::value &&
-                    detect_string_can_append_iter<OutStringType, Arg>::value,
-                int>>
-inline void concat_into(OutStringType &out, const Arg &arg, Args &&...rest) {
-  out.append(arg.begin(), arg.end());
-  concat_into(out, std::forward<Args>(rest)...);
-}
-
-template <
-    typename OutStringType, typename Arg, typename... Args,
-    enable_if_t<!detect_string_can_append<OutStringType, Arg>::value &&
-                    !detect_string_can_append_op<OutStringType, Arg>::value &&
-                    !detect_string_can_append_iter<OutStringType, Arg>::value &&
-                    detect_string_can_append_data<OutStringType, Arg>::value,
-                int>>
-inline void concat_into(OutStringType &out, const Arg &arg, Args &&...rest) {
-  out.append(arg.data(), arg.size());
-  concat_into(out, std::forward<Args>(rest)...);
-}
-
-template <typename OutStringType = std::string, typename... Args>
-inline OutStringType concat(Args &&...args) {
-  OutStringType str;
-  str.reserve(concat_length(args...));
-  concat_into(str, std::forward<Args>(args)...);
-  return str;
-}
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// With -Wweak-vtables, Clang will complain about the exception classes as they
-// have no out-of-line virtual method definitions and their vtable will be
-// emitted in every translation unit. This issue cannot be fixed with a
-// header-only library as there is no implementation file to move these
-// functions to. As a result, we suppress this warning here to avoid client
-// code to stumble over this. See https://github.com/nlohmann/json/issues/4087
-// for a discussion.
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wweak-vtables"
-#endif
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-////////////////
-// exceptions //
-////////////////
-
-/// @brief general exception of the @ref basic_json class
-/// @sa https://json.nlohmann.me/api/basic_json/exception/
-class exception : public std::exception {
-public:
-  /// returns the explanatory string
-  const char *what() const noexcept override { return m.what(); }
-
-  /// the id of the exception
-  const int
-      id; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)
-
-protected:
-  JSON_HEDLEY_NON_NULL(3)
-  exception(int id_, const char *what_arg)
-      : id(id_), m(what_arg) {} // NOLINT(bugprone-throw-keyword-missing)
-
-  static std::string name(const std::string &ename, int id_) {
-    return concat("[json.exception.", ename, '.', std::to_string(id_), "] ");
-  }
-
-  static std::string diagnostics(std::nullptr_t /*leaf_element*/) { return ""; }
-
-  template <typename BasicJsonType>
-  static std::string diagnostics(const BasicJsonType *leaf_element) {
-#if JSON_DIAGNOSTICS
-    std::vector<std::string> tokens;
-    for (const auto *current = leaf_element;
-         current != nullptr && current->m_parent != nullptr;
-         current = current->m_parent) {
-      switch (current->m_parent->type()) {
-      case value_t::array: {
-        for (std::size_t i = 0;
-             i < current->m_parent->m_data.m_value.array->size(); ++i) {
-          if (&current->m_parent->m_data.m_value.array->operator[](i) ==
-              current) {
-            tokens.emplace_back(std::to_string(i));
-            break;
-          }
-        }
-        break;
-      }
-
-      case value_t::object: {
-        for (const auto &element : *current->m_parent->m_data.m_value.object) {
-          if (&element.second == current) {
-            tokens.emplace_back(element.first.c_str());
-            break;
-          }
-        }
-        break;
-      }
-
-      case value_t::null:            // LCOV_EXCL_LINE
-      case value_t::string:          // LCOV_EXCL_LINE
-      case value_t::boolean:         // LCOV_EXCL_LINE
-      case value_t::number_integer:  // LCOV_EXCL_LINE
-      case value_t::number_unsigned: // LCOV_EXCL_LINE
-      case value_t::number_float:    // LCOV_EXCL_LINE
-      case value_t::binary:          // LCOV_EXCL_LINE
-      case value_t::discarded:       // LCOV_EXCL_LINE
-      default:                       // LCOV_EXCL_LINE
-        break;                       // LCOV_EXCL_LINE
-      }
-    }
-
-    if (tokens.empty()) {
-      return "";
-    }
-
-    auto str = std::accumulate(tokens.rbegin(), tokens.rend(), std::string{},
-                               [](const std::string &a, const std::string &b) {
-                                 return concat(a, '/', detail::escape(b));
-                               });
-    return concat('(', str, ") ");
-#else
-    static_cast<void>(leaf_element);
-    return "";
-#endif
-  }
-
-private:
-  /// an exception object as storage for error messages
-  std::runtime_error m;
-};
-
-/// @brief exception indicating a parse error
-/// @sa https://json.nlohmann.me/api/basic_json/parse_error/
-class parse_error : public exception {
-public:
-  /*!
-  @brief create a parse error exception
-  @param[in] id_       the id of the exception
-  @param[in] pos       the position where the error occurred (or with
-                       chars_read_total=0 if the position cannot be
-                       determined)
-  @param[in] what_arg  the explanatory string
-  @return parse_error object
-  */
-  template <
-      typename BasicJsonContext,
-      enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
-  static parse_error create(int id_, const position_t &pos,
-                            const std::string &what_arg,
-                            BasicJsonContext context) {
-    const std::string w = concat(exception::name("parse_error", id_),
-                                 "parse error", position_string(pos), ": ",
-                                 exception::diagnostics(context), what_arg);
-    return {id_, pos.chars_read_total, w.c_str()};
-  }
-
-  template <
-      typename BasicJsonContext,
-      enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
-  static parse_error create(int id_, std::size_t byte_,
-                            const std::string &what_arg,
-                            BasicJsonContext context) {
-    const std::string w =
-        concat(exception::name("parse_error", id_), "parse error",
-               (byte_ != 0 ? (concat(" at byte ", std::to_string(byte_))) : ""),
-               ": ", exception::diagnostics(context), what_arg);
-    return {id_, byte_, w.c_str()};
-  }
-
-  /*!
-  @brief byte index of the parse error
-
-  The byte index of the last read character in the input file.
-
-  @note For an input with n bytes, 1 is the index of the first character and
-        n+1 is the index of the terminating null byte or the end of file.
-        This also holds true when reading a byte vector (CBOR or MessagePack).
-  */
-  const std::size_t byte;
-
-private:
-  parse_error(int id_, std::size_t byte_, const char *what_arg)
-      : exception(id_, what_arg), byte(byte_) {}
-
-  static std::string position_string(const position_t &pos) {
-    return concat(" at line ", std::to_string(pos.lines_read + 1), ", column ",
-                  std::to_string(pos.chars_read_current_line));
-  }
-};
-
-/// @brief exception indicating errors with iterators
-/// @sa https://json.nlohmann.me/api/basic_json/invalid_iterator/
-class invalid_iterator : public exception {
-public:
-  template <
-      typename BasicJsonContext,
-      enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
-  static invalid_iterator create(int id_, const std::string &what_arg,
-                                 BasicJsonContext context) {
-    const std::string w = concat(exception::name("invalid_iterator", id_),
-                                 exception::diagnostics(context), what_arg);
-    return {id_, w.c_str()};
-  }
-
-private:
-  JSON_HEDLEY_NON_NULL(3)
-  invalid_iterator(int id_, const char *what_arg) : exception(id_, what_arg) {}
-};
-
-/// @brief exception indicating executing a member function with a wrong type
-/// @sa https://json.nlohmann.me/api/basic_json/type_error/
-class type_error : public exception {
-public:
-  template <
-      typename BasicJsonContext,
-      enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
-  static type_error create(int id_, const std::string &what_arg,
-                           BasicJsonContext context) {
-    const std::string w = concat(exception::name("type_error", id_),
-                                 exception::diagnostics(context), what_arg);
-    return {id_, w.c_str()};
-  }
-
-private:
-  JSON_HEDLEY_NON_NULL(3)
-  type_error(int id_, const char *what_arg) : exception(id_, what_arg) {}
-};
-
-/// @brief exception indicating access out of the defined range
-/// @sa https://json.nlohmann.me/api/basic_json/out_of_range/
-class out_of_range : public exception {
-public:
-  template <
-      typename BasicJsonContext,
-      enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
-  static out_of_range create(int id_, const std::string &what_arg,
-                             BasicJsonContext context) {
-    const std::string w = concat(exception::name("out_of_range", id_),
-                                 exception::diagnostics(context), what_arg);
-    return {id_, w.c_str()};
-  }
-
-private:
-  JSON_HEDLEY_NON_NULL(3)
-  out_of_range(int id_, const char *what_arg) : exception(id_, what_arg) {}
-};
-
-/// @brief exception indicating other library errors
-/// @sa https://json.nlohmann.me/api/basic_json/other_error/
-class other_error : public exception {
-public:
-  template <
-      typename BasicJsonContext,
-      enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
-  static other_error create(int id_, const std::string &what_arg,
-                            BasicJsonContext context) {
-    const std::string w = concat(exception::name("other_error", id_),
-                                 exception::diagnostics(context), what_arg);
-    return {id_, w.c_str()};
-  }
-
-private:
-  JSON_HEDLEY_NON_NULL(3)
-  other_error(int id_, const char *what_arg) : exception(id_, what_arg) {}
-};
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/meta/cpp_future.hpp>
-
-// #include <nlohmann/detail/meta/identity_tag.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// #include <nlohmann/detail/abi_macros.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-// dispatching helper struct
-template <class T> struct identity_tag {};
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/meta/std_fs.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-#if JSON_HAS_EXPERIMENTAL_FILESYSTEM
-#include <experimental/filesystem>
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-namespace std_fs = std::experimental::filesystem;
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-#elif JSON_HAS_FILESYSTEM
-#include <filesystem> // NOLINT(build/c++17)
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-namespace std_fs = std::filesystem;
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-#endif
-
-// #include <nlohmann/detail/meta/type_traits.hpp>
-
-// #include <nlohmann/detail/string_concat.hpp>
-
-// #include <nlohmann/detail/value_t.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-template <typename BasicJsonType>
-inline void from_json(const BasicJsonType &j, typename std::nullptr_t &n) {
-  if (JSON_HEDLEY_UNLIKELY(!j.is_null())) {
-    JSON_THROW(type_error::create(
-        302, concat("type must be null, but is ", j.type_name()), &j));
-  }
-  n = nullptr;
-}
-
-#ifdef JSON_HAS_CPP_17
-#ifndef JSON_USE_IMPLICIT_CONVERSIONS
-template <typename BasicJsonType, typename T>
-void from_json(const BasicJsonType &j, std::optional<T> &opt) {
-  if (j.is_null()) {
-    opt = std::nullopt;
-  } else {
-    opt.emplace(j.template get<T>());
-  }
-}
-
-#endif // JSON_USE_IMPLICIT_CONVERSIONS
-#endif // JSON_HAS_CPP_17
-
-// overloads for basic_json template parameters
-template <
-    typename BasicJsonType, typename ArithmeticType,
-    enable_if_t<std::is_arithmetic<ArithmeticType>::value &&
-                    !std::is_same<ArithmeticType,
-                                  typename BasicJsonType::boolean_t>::value,
-                int> = 0>
-void get_arithmetic_value(const BasicJsonType &j, ArithmeticType &val) {
-  switch (static_cast<value_t>(j)) {
-  case value_t::number_unsigned: {
-    val = static_cast<ArithmeticType>(
-        *j.template get_ptr<
-            const typename BasicJsonType::number_unsigned_t *>());
-    break;
-  }
-  case value_t::number_integer: {
-    val = static_cast<ArithmeticType>(
-        *j.template get_ptr<
-            const typename BasicJsonType::number_integer_t *>());
-    break;
-  }
-  case value_t::number_float: {
-    val = static_cast<ArithmeticType>(
-        *j.template get_ptr<const typename BasicJsonType::number_float_t *>());
-    break;
-  }
-
-  case value_t::null:
-  case value_t::object:
-  case value_t::array:
-  case value_t::string:
-  case value_t::boolean:
-  case value_t::binary:
-  case value_t::discarded:
-  default:
-    JSON_THROW(type_error::create(
-        302, concat("type must be number, but is ", j.type_name()), &j));
-  }
-}
-
-template <typename BasicJsonType>
-inline void from_json(const BasicJsonType &j,
-                      typename BasicJsonType::boolean_t &b) {
-  if (JSON_HEDLEY_UNLIKELY(!j.is_boolean())) {
-    JSON_THROW(type_error::create(
-        302, concat("type must be boolean, but is ", j.type_name()), &j));
-  }
-  b = *j.template get_ptr<const typename BasicJsonType::boolean_t *>();
-}
-
-template <typename BasicJsonType>
-inline void from_json(const BasicJsonType &j,
-                      typename BasicJsonType::string_t &s) {
-  if (JSON_HEDLEY_UNLIKELY(!j.is_string())) {
-    JSON_THROW(type_error::create(
-        302, concat("type must be string, but is ", j.type_name()), &j));
-  }
-  s = *j.template get_ptr<const typename BasicJsonType::string_t *>();
-}
-
-template <
-    typename BasicJsonType, typename StringType,
-    enable_if_t<
-        std::is_assignable<StringType &,
-                           const typename BasicJsonType::string_t>::value &&
-            is_detected_exact<typename BasicJsonType::string_t::value_type,
-                              value_type_t, StringType>::value &&
-            !std::is_same<typename BasicJsonType::string_t,
-                          StringType>::value &&
-            !is_json_ref<StringType>::value,
-        int> = 0>
-inline void from_json(const BasicJsonType &j, StringType &s) {
-  if (JSON_HEDLEY_UNLIKELY(!j.is_string())) {
-    JSON_THROW(type_error::create(
-        302, concat("type must be string, but is ", j.type_name()), &j));
-  }
-
-  s = *j.template get_ptr<const typename BasicJsonType::string_t *>();
-}
-
-template <typename BasicJsonType>
-inline void from_json(const BasicJsonType &j,
-                      typename BasicJsonType::number_float_t &val) {
-  get_arithmetic_value(j, val);
-}
-
-template <typename BasicJsonType>
-inline void from_json(const BasicJsonType &j,
-                      typename BasicJsonType::number_unsigned_t &val) {
-  get_arithmetic_value(j, val);
-}
-
-template <typename BasicJsonType>
-inline void from_json(const BasicJsonType &j,
-                      typename BasicJsonType::number_integer_t &val) {
-  get_arithmetic_value(j, val);
-}
-
-#if !JSON_DISABLE_ENUM_SERIALIZATION
-template <typename BasicJsonType, typename EnumType,
-          enable_if_t<std::is_enum<EnumType>::value, int> = 0>
-inline void from_json(const BasicJsonType &j, EnumType &e) {
-  typename std::underlying_type<EnumType>::type val;
-  get_arithmetic_value(j, val);
-  e = static_cast<EnumType>(val);
-}
-#endif // JSON_DISABLE_ENUM_SERIALIZATION
-
-// forward_list doesn't have an insert method
-template <typename BasicJsonType, typename T, typename Allocator,
-          enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
-inline void from_json(const BasicJsonType &j,
-                      std::forward_list<T, Allocator> &l) {
-  if (JSON_HEDLEY_UNLIKELY(!j.is_array())) {
-    JSON_THROW(type_error::create(
-        302, concat("type must be array, but is ", j.type_name()), &j));
-  }
-  l.clear();
-  std::transform(j.rbegin(), j.rend(), std::front_inserter(l),
-                 [](const BasicJsonType &i) { return i.template get<T>(); });
-}
-
-// valarray doesn't have an insert method
-template <typename BasicJsonType, typename T,
-          enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
-inline void from_json(const BasicJsonType &j, std::valarray<T> &l) {
-  if (JSON_HEDLEY_UNLIKELY(!j.is_array())) {
-    JSON_THROW(type_error::create(
-        302, concat("type must be array, but is ", j.type_name()), &j));
-  }
-  l.resize(j.size());
-  std::transform(
-      j.begin(), j.end(), std::begin(l),
-      [](const BasicJsonType &elem) { return elem.template get<T>(); });
-}
-
-template <typename BasicJsonType, typename T, std::size_t N>
-auto from_json(
-    const BasicJsonType &j,
-    T (&arr)
-        [N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
-    -> decltype(j.template get<T>(), void()) {
-  for (std::size_t i = 0; i < N; ++i) {
-    arr[i] = j.at(i).template get<T>();
-  }
-}
-
-template <typename BasicJsonType, typename T, std::size_t N1, std::size_t N2>
-auto from_json(
-    const BasicJsonType &j,
-    T (&arr)
-        [N1]
-        [N2]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
-    -> decltype(j.template get<T>(), void()) {
-  for (std::size_t i1 = 0; i1 < N1; ++i1) {
-    for (std::size_t i2 = 0; i2 < N2; ++i2) {
-      arr[i1][i2] = j.at(i1).at(i2).template get<T>();
-    }
-  }
-}
-
-template <typename BasicJsonType, typename T, std::size_t N1, std::size_t N2,
-          std::size_t N3>
-auto from_json(
-    const BasicJsonType &j,
-    T (&arr)
-        [N1][N2]
-        [N3]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
-    -> decltype(j.template get<T>(), void()) {
-  for (std::size_t i1 = 0; i1 < N1; ++i1) {
-    for (std::size_t i2 = 0; i2 < N2; ++i2) {
-      for (std::size_t i3 = 0; i3 < N3; ++i3) {
-        arr[i1][i2][i3] = j.at(i1).at(i2).at(i3).template get<T>();
-      }
-    }
-  }
-}
-
-template <typename BasicJsonType, typename T, std::size_t N1, std::size_t N2,
-          std::size_t N3, std::size_t N4>
-auto from_json(
-    const BasicJsonType &j,
-    T (&arr)
-        [N1][N2][N3]
-        [N4]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
-    -> decltype(j.template get<T>(), void()) {
-  for (std::size_t i1 = 0; i1 < N1; ++i1) {
-    for (std::size_t i2 = 0; i2 < N2; ++i2) {
-      for (std::size_t i3 = 0; i3 < N3; ++i3) {
-        for (std::size_t i4 = 0; i4 < N4; ++i4) {
-          arr[i1][i2][i3][i4] = j.at(i1).at(i2).at(i3).at(i4).template get<T>();
-        }
-      }
-    }
-  }
-}
-
-template <typename BasicJsonType>
-inline void from_json_array_impl(const BasicJsonType &j,
-                                 typename BasicJsonType::array_t &arr,
-                                 priority_tag<3> /*unused*/) {
-  arr = *j.template get_ptr<const typename BasicJsonType::array_t *>();
-}
-
-template <typename BasicJsonType, typename T, std::size_t N>
-auto from_json_array_impl(const BasicJsonType &j, std::array<T, N> &arr,
-                          priority_tag<2> /*unused*/)
-    -> decltype(j.template get<T>(), void()) {
-  for (std::size_t i = 0; i < N; ++i) {
-    arr[i] = j.at(i).template get<T>();
-  }
-}
-
-template <typename BasicJsonType, typename ConstructibleArrayType,
-          enable_if_t<std::is_assignable<ConstructibleArrayType &,
-                                         ConstructibleArrayType>::value,
-                      int> = 0>
-auto from_json_array_impl(const BasicJsonType &j, ConstructibleArrayType &arr,
-                          priority_tag<1> /*unused*/)
-    -> decltype(arr.reserve(
-                    std::declval<typename ConstructibleArrayType::size_type>()),
-                j.template get<typename ConstructibleArrayType::value_type>(),
-                void()) {
-  using std::end;
-
-  ConstructibleArrayType ret;
-  ret.reserve(j.size());
-  std::transform(
-      j.begin(), j.end(), std::inserter(ret, end(ret)),
-      [](const BasicJsonType &i) {
-        // get<BasicJsonType>() returns *this, this won't call a from_json
-        // method when value_type is BasicJsonType
-        return i.template get<typename ConstructibleArrayType::value_type>();
-      });
-  arr = std::move(ret);
-}
-
-template <typename BasicJsonType, typename ConstructibleArrayType,
-          enable_if_t<std::is_assignable<ConstructibleArrayType &,
-                                         ConstructibleArrayType>::value,
-                      int> = 0>
-inline void from_json_array_impl(const BasicJsonType &j,
-                                 ConstructibleArrayType &arr,
-                                 priority_tag<0> /*unused*/) {
-  using std::end;
-
-  ConstructibleArrayType ret;
-  std::transform(
-      j.begin(), j.end(), std::inserter(ret, end(ret)),
-      [](const BasicJsonType &i) {
-        // get<BasicJsonType>() returns *this, this won't call a from_json
-        // method when value_type is BasicJsonType
-        return i.template get<typename ConstructibleArrayType::value_type>();
-      });
-  arr = std::move(ret);
-}
-
-template <
-    typename BasicJsonType, typename ConstructibleArrayType,
-    enable_if_t<is_constructible_array_type<BasicJsonType,
-                                            ConstructibleArrayType>::value &&
-                    !is_constructible_object_type<
-                        BasicJsonType, ConstructibleArrayType>::value &&
-                    !is_constructible_string_type<
-                        BasicJsonType, ConstructibleArrayType>::value &&
-                    !std::is_same<ConstructibleArrayType,
-                                  typename BasicJsonType::binary_t>::value &&
-                    !is_basic_json<ConstructibleArrayType>::value,
-                int> = 0>
-auto from_json(const BasicJsonType &j, ConstructibleArrayType &arr)
-    -> decltype(from_json_array_impl(j, arr, priority_tag<3>{}),
-                j.template get<typename ConstructibleArrayType::value_type>(),
-                void()) {
-  if (JSON_HEDLEY_UNLIKELY(!j.is_array())) {
-    JSON_THROW(type_error::create(
-        302, concat("type must be array, but is ", j.type_name()), &j));
-  }
-
-  from_json_array_impl(j, arr, priority_tag<3>{});
-}
-
-template <typename BasicJsonType, typename T, std::size_t... Idx>
-std::array<T, sizeof...(Idx)> from_json_inplace_array_impl(
-    BasicJsonType &&j, identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/,
-    index_sequence<Idx...> /*unused*/) {
-  return {{std::forward<BasicJsonType>(j).at(Idx).template get<T>()...}};
-}
-
-template <typename BasicJsonType, typename T, std::size_t N>
-auto from_json(BasicJsonType &&j, identity_tag<std::array<T, N>> tag)
-    -> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j),
-                                             tag, make_index_sequence<N>{})) {
-  if (JSON_HEDLEY_UNLIKELY(!j.is_array())) {
-    JSON_THROW(type_error::create(
-        302, concat("type must be array, but is ", j.type_name()), &j));
-  }
-
-  return from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag,
-                                      make_index_sequence<N>{});
-}
-
-template <typename BasicJsonType>
-inline void from_json(const BasicJsonType &j,
-                      typename BasicJsonType::binary_t &bin) {
-  if (JSON_HEDLEY_UNLIKELY(!j.is_binary())) {
-    JSON_THROW(type_error::create(
-        302, concat("type must be binary, but is ", j.type_name()), &j));
-  }
-
-  bin = *j.template get_ptr<const typename BasicJsonType::binary_t *>();
-}
-
-template <typename BasicJsonType, typename ConstructibleObjectType,
-          enable_if_t<is_constructible_object_type<
-                          BasicJsonType, ConstructibleObjectType>::value,
-                      int> = 0>
-inline void from_json(const BasicJsonType &j, ConstructibleObjectType &obj) {
-  if (JSON_HEDLEY_UNLIKELY(!j.is_object())) {
-    JSON_THROW(type_error::create(
-        302, concat("type must be object, but is ", j.type_name()), &j));
-  }
-
-  ConstructibleObjectType ret;
-  const auto *inner_object =
-      j.template get_ptr<const typename BasicJsonType::object_t *>();
-  using value_type = typename ConstructibleObjectType::value_type;
-  std::transform(
-      inner_object->begin(), inner_object->end(),
-      std::inserter(ret, ret.begin()),
-      [](typename BasicJsonType::object_t::value_type const &p) {
-        return value_type(
-            p.first,
-            p.second
-                .template get<typename ConstructibleObjectType::mapped_type>());
-      });
-  obj = std::move(ret);
-}
-
-// overload for arithmetic types, not chosen for basic_json template arguments
-// (BooleanType, etc..); note: Is it really necessary to provide explicit
-// overloads for boolean_t etc. in case of a custom BooleanType which is not
-// an arithmetic type?
-template <
-    typename BasicJsonType, typename ArithmeticType,
-    enable_if_t<
-        std::is_arithmetic<ArithmeticType>::value &&
-            !std::is_same<ArithmeticType,
-                          typename BasicJsonType::number_unsigned_t>::value &&
-            !std::is_same<ArithmeticType,
-                          typename BasicJsonType::number_integer_t>::value &&
-            !std::is_same<ArithmeticType,
-                          typename BasicJsonType::number_float_t>::value &&
-            !std::is_same<ArithmeticType,
-                          typename BasicJsonType::boolean_t>::value,
-        int> = 0>
-inline void from_json(const BasicJsonType &j, ArithmeticType &val) {
-  switch (static_cast<value_t>(j)) {
-  case value_t::number_unsigned: {
-    val = static_cast<ArithmeticType>(
-        *j.template get_ptr<
-            const typename BasicJsonType::number_unsigned_t *>());
-    break;
-  }
-  case value_t::number_integer: {
-    val = static_cast<ArithmeticType>(
-        *j.template get_ptr<
-            const typename BasicJsonType::number_integer_t *>());
-    break;
-  }
-  case value_t::number_float: {
-    val = static_cast<ArithmeticType>(
-        *j.template get_ptr<const typename BasicJsonType::number_float_t *>());
-    break;
-  }
-  case value_t::boolean: {
-    val = static_cast<ArithmeticType>(
-        *j.template get_ptr<const typename BasicJsonType::boolean_t *>());
-    break;
-  }
-
-  case value_t::null:
-  case value_t::object:
-  case value_t::array:
-  case value_t::string:
-  case value_t::binary:
-  case value_t::discarded:
-  default:
-    JSON_THROW(type_error::create(
-        302, concat("type must be number, but is ", j.type_name()), &j));
-  }
-}
-
-template <typename BasicJsonType, typename... Args, std::size_t... Idx>
-std::tuple<Args...>
-from_json_tuple_impl_base(BasicJsonType &&j,
-                          index_sequence<Idx...> /*unused*/) {
-  return std::make_tuple(
-      std::forward<BasicJsonType>(j).at(Idx).template get<Args>()...);
-}
-
-template <typename BasicJsonType, class A1, class A2>
-std::pair<A1, A2>
-from_json_tuple_impl(BasicJsonType &&j,
-                     identity_tag<std::pair<A1, A2>> /*unused*/,
-                     priority_tag<0> /*unused*/) {
-  return {std::forward<BasicJsonType>(j).at(0).template get<A1>(),
-          std::forward<BasicJsonType>(j).at(1).template get<A2>()};
-}
-
-template <typename BasicJsonType, typename A1, typename A2>
-inline void from_json_tuple_impl(BasicJsonType &&j, std::pair<A1, A2> &p,
-                                 priority_tag<1> /*unused*/) {
-  p = from_json_tuple_impl(std::forward<BasicJsonType>(j),
-                           identity_tag<std::pair<A1, A2>>{},
-                           priority_tag<0>{});
-}
-
-template <typename BasicJsonType, typename... Args>
-std::tuple<Args...>
-from_json_tuple_impl(BasicJsonType &&j,
-                     identity_tag<std::tuple<Args...>> /*unused*/,
-                     priority_tag<2> /*unused*/) {
-  return from_json_tuple_impl_base<BasicJsonType, Args...>(
-      std::forward<BasicJsonType>(j), index_sequence_for<Args...>{});
-}
-
-template <typename BasicJsonType, typename... Args>
-inline void from_json_tuple_impl(BasicJsonType &&j, std::tuple<Args...> &t,
-                                 priority_tag<3> /*unused*/) {
-  t = from_json_tuple_impl_base<BasicJsonType, Args...>(
-      std::forward<BasicJsonType>(j), index_sequence_for<Args...>{});
-}
-
-template <typename BasicJsonType, typename TupleRelated>
-auto from_json(BasicJsonType &&j, TupleRelated &&t)
-    -> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j),
-                                     std::forward<TupleRelated>(t),
-                                     priority_tag<3>{})) {
-  if (JSON_HEDLEY_UNLIKELY(!j.is_array())) {
-    JSON_THROW(type_error::create(
-        302, concat("type must be array, but is ", j.type_name()), &j));
-  }
-
-  return from_json_tuple_impl(std::forward<BasicJsonType>(j),
-                              std::forward<TupleRelated>(t), priority_tag<3>{});
-}
-
-template <typename BasicJsonType, typename Key, typename Value,
-          typename Compare, typename Allocator,
-          typename = enable_if_t<!std::is_constructible<
-              typename BasicJsonType::string_t, Key>::value>>
-inline void from_json(const BasicJsonType &j,
-                      std::map<Key, Value, Compare, Allocator> &m) {
-  if (JSON_HEDLEY_UNLIKELY(!j.is_array())) {
-    JSON_THROW(type_error::create(
-        302, concat("type must be array, but is ", j.type_name()), &j));
-  }
-  m.clear();
-  for (const auto &p : j) {
-    if (JSON_HEDLEY_UNLIKELY(!p.is_array())) {
-      JSON_THROW(type_error::create(
-          302, concat("type must be array, but is ", p.type_name()), &j));
-    }
-    m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
-  }
-}
-
-template <typename BasicJsonType, typename Key, typename Value, typename Hash,
-          typename KeyEqual, typename Allocator,
-          typename = enable_if_t<!std::is_constructible<
-              typename BasicJsonType::string_t, Key>::value>>
-inline void
-from_json(const BasicJsonType &j,
-          std::unordered_map<Key, Value, Hash, KeyEqual, Allocator> &m) {
-  if (JSON_HEDLEY_UNLIKELY(!j.is_array())) {
-    JSON_THROW(type_error::create(
-        302, concat("type must be array, but is ", j.type_name()), &j));
-  }
-  m.clear();
-  for (const auto &p : j) {
-    if (JSON_HEDLEY_UNLIKELY(!p.is_array())) {
-      JSON_THROW(type_error::create(
-          302, concat("type must be array, but is ", p.type_name()), &j));
-    }
-    m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
-  }
-}
-
-#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
-template <typename BasicJsonType>
-inline void from_json(const BasicJsonType &j, std_fs::path &p) {
-  if (JSON_HEDLEY_UNLIKELY(!j.is_string())) {
-    JSON_THROW(type_error::create(
-        302, concat("type must be string, but is ", j.type_name()), &j));
-  }
-  p = *j.template get_ptr<const typename BasicJsonType::string_t *>();
-}
-#endif
-
-struct from_json_fn {
-  template <typename BasicJsonType, typename T>
-  auto operator()(const BasicJsonType &j, T &&val) const
-      noexcept(noexcept(from_json(j, std::forward<T>(val))))
-          -> decltype(from_json(j, std::forward<T>(val))) {
-    return from_json(j, std::forward<T>(val));
-  }
-};
-
-} // namespace detail
-
-#ifndef JSON_HAS_CPP_17
-/// namespace to hold default `from_json` function
-/// to see why this is required:
-/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
-namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
-{
-#endif
-JSON_INLINE_VARIABLE constexpr const auto
-    &from_json = // NOLINT(misc-definitions-in-headers)
-    detail::static_const<detail::from_json_fn>::value;
-#ifndef JSON_HAS_CPP_17
-} // namespace
-#endif
-
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/conversions/to_json.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <algorithm> // copy
-#include <iterator>  // begin, end
-#ifdef JSON_HAS_CPP_17
-#include <optional> // optional
-#endif
-#include <string> // string
-#include <tuple>  // tuple, get
-#include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type
-#include <utility>  // move, forward, declval, pair
-#include <valarray> // valarray
-#include <vector>   // vector
-
-// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <cstddef>  // size_t
-#include <iterator> // forward_iterator_tag
-#include <string>   // string, to_string
-#include <tuple>    // tuple_size, get, tuple_element
-#include <utility>  // move
-
-#if JSON_HAS_RANGES
-#include <ranges> // enable_borrowed_range
-#endif
-
-// #include <nlohmann/detail/abi_macros.hpp>
-
-// #include <nlohmann/detail/meta/type_traits.hpp>
-
-// #include <nlohmann/detail/value_t.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-template <typename string_type>
-void int_to_string(string_type &target, std::size_t value) {
-  // For ADL
-  using std::to_string;
-  target = to_string(value);
-}
-template <typename IteratorType> class iteration_proxy_value {
-public:
-  using difference_type = std::ptrdiff_t;
-  using value_type = iteration_proxy_value;
-  using pointer = value_type *;
-  using reference = value_type &;
-  using iterator_category = std::forward_iterator_tag;
-  using string_type = typename std::remove_cv<typename std::remove_reference<
-      decltype(std::declval<IteratorType>().key())>::type>::type;
-
-private:
-  /// the iterator
-  IteratorType anchor{};
-  /// an index for arrays (used to create key names)
-  std::size_t array_index = 0;
-  /// last stringified array index
-  mutable std::size_t array_index_last = 0;
-  /// a string representation of the array index
-  mutable string_type array_index_str = "0";
-  /// an empty string (to return a reference for primitive values)
-  string_type empty_str{};
-
-public:
-  explicit iteration_proxy_value() = default;
-  explicit iteration_proxy_value(
-      IteratorType it,
-      std::size_t array_index_ =
-          0) noexcept(std::is_nothrow_move_constructible<IteratorType>::value &&
-                      std::is_nothrow_default_constructible<string_type>::value)
-      : anchor(std::move(it)), array_index(array_index_) {}
-
-  iteration_proxy_value(iteration_proxy_value const &) = default;
-  iteration_proxy_value &operator=(iteration_proxy_value const &) = default;
-  // older GCCs are a bit fussy and require explicit noexcept specifiers on
-  // defaulted functions
-  iteration_proxy_value(iteration_proxy_value &&) noexcept(
-      std::is_nothrow_move_constructible<IteratorType>::value &&
-      std::is_nothrow_move_constructible<string_type>::value) =
-      default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations)
-  iteration_proxy_value &operator=(iteration_proxy_value &&) noexcept(
-      std::is_nothrow_move_assignable<IteratorType>::value &&
-      std::is_nothrow_move_assignable<string_type>::value) =
-      default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations)
-  ~iteration_proxy_value() = default;
-
-  /// dereference operator (needed for range-based for)
-  const iteration_proxy_value &operator*() const { return *this; }
-
-  /// increment operator (needed for range-based for)
-  iteration_proxy_value &operator++() {
-    ++anchor;
-    ++array_index;
-
-    return *this;
-  }
-
-  iteration_proxy_value operator++(int) & // NOLINT(cert-dcl21-cpp)
-  {
-    auto tmp = iteration_proxy_value(anchor, array_index);
-    ++anchor;
-    ++array_index;
-    return tmp;
-  }
-
-  /// equality operator (needed for InputIterator)
-  bool operator==(const iteration_proxy_value &o) const {
-    return anchor == o.anchor;
-  }
-
-  /// inequality operator (needed for range-based for)
-  bool operator!=(const iteration_proxy_value &o) const {
-    return anchor != o.anchor;
-  }
-
-  /// return key of the iterator
-  const string_type &key() const {
-    JSON_ASSERT(anchor.m_object != nullptr);
-
-    switch (anchor.m_object->type()) {
-    // use integer array index as key
-    case value_t::array: {
-      if (array_index != array_index_last) {
-        int_to_string(array_index_str, array_index);
-        array_index_last = array_index;
-      }
-      return array_index_str;
-    }
-
-    // use key from the object
-    case value_t::object:
-      return anchor.key();
-
-    // use an empty key for all primitive types
-    case value_t::null:
-    case value_t::string:
-    case value_t::boolean:
-    case value_t::number_integer:
-    case value_t::number_unsigned:
-    case value_t::number_float:
-    case value_t::binary:
-    case value_t::discarded:
-    default:
-      return empty_str;
-    }
-  }
-
-  /// return value of the iterator
-  typename IteratorType::reference value() const { return anchor.value(); }
-};
-
-/// proxy class for the items() function
-template <typename IteratorType> class iteration_proxy {
-private:
-  /// the container to iterate
-  typename IteratorType::pointer container = nullptr;
-
-public:
-  explicit iteration_proxy() = default;
-
-  /// construct iteration proxy from a container
-  explicit iteration_proxy(typename IteratorType::reference cont) noexcept
-      : container(&cont) {}
-
-  iteration_proxy(iteration_proxy const &) = default;
-  iteration_proxy &operator=(iteration_proxy const &) = default;
-  iteration_proxy(iteration_proxy &&) noexcept = default;
-  iteration_proxy &operator=(iteration_proxy &&) noexcept = default;
-  ~iteration_proxy() = default;
-
-  /// return iterator begin (needed for range-based for)
-  iteration_proxy_value<IteratorType> begin() const noexcept {
-    return iteration_proxy_value<IteratorType>(container->begin());
-  }
-
-  /// return iterator end (needed for range-based for)
-  iteration_proxy_value<IteratorType> end() const noexcept {
-    return iteration_proxy_value<IteratorType>(container->end());
-  }
-};
-
-// Structured Bindings Support
-// For further reference see https://blog.tartanllama.xyz/structured-bindings/
-// And see https://github.com/nlohmann/json/pull/1391
-template <std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
-auto get(const nlohmann::detail::iteration_proxy_value<IteratorType> &i)
-    -> decltype(i.key()) {
-  return i.key();
-}
-// Structured Bindings Support
-// For further reference see https://blog.tartanllama.xyz/structured-bindings/
-// And see https://github.com/nlohmann/json/pull/1391
-template <std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
-auto get(const nlohmann::detail::iteration_proxy_value<IteratorType> &i)
-    -> decltype(i.value()) {
-  return i.value();
-}
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// The Addition to the STD Namespace is required to add
-// Structured Bindings Support to the iteration_proxy_value class
-// For further reference see https://blog.tartanllama.xyz/structured-bindings/
-// And see https://github.com/nlohmann/json/pull/1391
-namespace std {
-
-#if defined(__clang__)
-// Fix: https://github.com/nlohmann/json/issues/1401
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wmismatched-tags"
-#endif
-template <typename IteratorType>
-class tuple_size<::nlohmann::detail::iteration_proxy_value<
-    IteratorType>> // NOLINT(cert-dcl58-cpp)
-    : public std::integral_constant<std::size_t, 2> {};
-
-template <std::size_t N, typename IteratorType>
-class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<
-                           IteratorType>> // NOLINT(cert-dcl58-cpp)
-{
-public:
-  using type = decltype(get<N>(
-      std::declval<::nlohmann::detail::iteration_proxy_value<IteratorType>>()));
-};
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
-} // namespace std
-
-#if JSON_HAS_RANGES
-template <typename IteratorType>
-inline constexpr bool ::std::ranges::enable_borrowed_range<
-    ::nlohmann::detail::iteration_proxy<IteratorType>> = true;
-#endif
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/meta/cpp_future.hpp>
-
-// #include <nlohmann/detail/meta/std_fs.hpp>
-
-// #include <nlohmann/detail/meta/type_traits.hpp>
-
-// #include <nlohmann/detail/value_t.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-//////////////////
-// constructors //
-//////////////////
-
-/*
- * Note all external_constructor<>::construct functions need to call
- * j.m_data.m_value.destroy(j.m_data.m_type) to avoid a memory leak in case j
- * contains an allocated value (e.g., a string). See bug issue
- * https://github.com/nlohmann/json/issues/2865 for more information.
- */
-
-template <value_t> struct external_constructor;
-
-template <> struct external_constructor<value_t::boolean> {
-  template <typename BasicJsonType>
-  static void construct(BasicJsonType &j,
-                        typename BasicJsonType::boolean_t b) noexcept {
-    j.m_data.m_value.destroy(j.m_data.m_type);
-    j.m_data.m_type = value_t::boolean;
-    j.m_data.m_value = b;
-    j.assert_invariant();
-  }
-};
-
-template <> struct external_constructor<value_t::string> {
-  template <typename BasicJsonType>
-  static void construct(BasicJsonType &j,
-                        const typename BasicJsonType::string_t &s) {
-    j.m_data.m_value.destroy(j.m_data.m_type);
-    j.m_data.m_type = value_t::string;
-    j.m_data.m_value = s;
-    j.assert_invariant();
-  }
-
-  template <typename BasicJsonType>
-  static void construct(BasicJsonType &j,
-                        typename BasicJsonType::string_t &&s) {
-    j.m_data.m_value.destroy(j.m_data.m_type);
-    j.m_data.m_type = value_t::string;
-    j.m_data.m_value = std::move(s);
-    j.assert_invariant();
-  }
-
-  template <typename BasicJsonType, typename CompatibleStringType,
-            enable_if_t<!std::is_same<CompatibleStringType,
-                                      typename BasicJsonType::string_t>::value,
-                        int> = 0>
-  static void construct(BasicJsonType &j, const CompatibleStringType &str) {
-    j.m_data.m_value.destroy(j.m_data.m_type);
-    j.m_data.m_type = value_t::string;
-    j.m_data.m_value.string =
-        j.template create<typename BasicJsonType::string_t>(str);
-    j.assert_invariant();
-  }
-};
-
-template <> struct external_constructor<value_t::binary> {
-  template <typename BasicJsonType>
-  static void construct(BasicJsonType &j,
-                        const typename BasicJsonType::binary_t &b) {
-    j.m_data.m_value.destroy(j.m_data.m_type);
-    j.m_data.m_type = value_t::binary;
-    j.m_data.m_value = typename BasicJsonType::binary_t(b);
-    j.assert_invariant();
-  }
-
-  template <typename BasicJsonType>
-  static void construct(BasicJsonType &j,
-                        typename BasicJsonType::binary_t &&b) {
-    j.m_data.m_value.destroy(j.m_data.m_type);
-    j.m_data.m_type = value_t::binary;
-    j.m_data.m_value = typename BasicJsonType::binary_t(std::move(b));
-    j.assert_invariant();
-  }
-};
-
-template <> struct external_constructor<value_t::number_float> {
-  template <typename BasicJsonType>
-  static void construct(BasicJsonType &j,
-                        typename BasicJsonType::number_float_t val) noexcept {
-    j.m_data.m_value.destroy(j.m_data.m_type);
-    j.m_data.m_type = value_t::number_float;
-    j.m_data.m_value = val;
-    j.assert_invariant();
-  }
-};
-
-template <> struct external_constructor<value_t::number_unsigned> {
-  template <typename BasicJsonType>
-  static void
-  construct(BasicJsonType &j,
-            typename BasicJsonType::number_unsigned_t val) noexcept {
-    j.m_data.m_value.destroy(j.m_data.m_type);
-    j.m_data.m_type = value_t::number_unsigned;
-    j.m_data.m_value = val;
-    j.assert_invariant();
-  }
-};
-
-template <> struct external_constructor<value_t::number_integer> {
-  template <typename BasicJsonType>
-  static void construct(BasicJsonType &j,
-                        typename BasicJsonType::number_integer_t val) noexcept {
-    j.m_data.m_value.destroy(j.m_data.m_type);
-    j.m_data.m_type = value_t::number_integer;
-    j.m_data.m_value = val;
-    j.assert_invariant();
-  }
-};
-
-template <> struct external_constructor<value_t::array> {
-  template <typename BasicJsonType>
-  static void construct(BasicJsonType &j,
-                        const typename BasicJsonType::array_t &arr) {
-    j.m_data.m_value.destroy(j.m_data.m_type);
-    j.m_data.m_type = value_t::array;
-    j.m_data.m_value = arr;
-    j.set_parents();
-    j.assert_invariant();
-  }
-
-  template <typename BasicJsonType>
-  static void construct(BasicJsonType &j,
-                        typename BasicJsonType::array_t &&arr) {
-    j.m_data.m_value.destroy(j.m_data.m_type);
-    j.m_data.m_type = value_t::array;
-    j.m_data.m_value = std::move(arr);
-    j.set_parents();
-    j.assert_invariant();
-  }
-
-  template <typename BasicJsonType, typename CompatibleArrayType,
-            enable_if_t<!std::is_same<CompatibleArrayType,
-                                      typename BasicJsonType::array_t>::value,
-                        int> = 0>
-  static void construct(BasicJsonType &j, const CompatibleArrayType &arr) {
-    using std::begin;
-    using std::end;
-
-    j.m_data.m_value.destroy(j.m_data.m_type);
-    j.m_data.m_type = value_t::array;
-    j.m_data.m_value.array = j.template create<typename BasicJsonType::array_t>(
-        begin(arr), end(arr));
-    j.set_parents();
-    j.assert_invariant();
-  }
-
-  template <typename BasicJsonType>
-  static void construct(BasicJsonType &j, const std::vector<bool> &arr) {
-    j.m_data.m_value.destroy(j.m_data.m_type);
-    j.m_data.m_type = value_t::array;
-    j.m_data.m_value = value_t::array;
-    j.m_data.m_value.array->reserve(arr.size());
-    for (const bool x : arr) {
-      j.m_data.m_value.array->push_back(x);
-      j.set_parent(j.m_data.m_value.array->back());
-    }
-    j.assert_invariant();
-  }
-
-  template <typename BasicJsonType, typename T,
-            enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
-  static void construct(BasicJsonType &j, const std::valarray<T> &arr) {
-    j.m_data.m_value.destroy(j.m_data.m_type);
-    j.m_data.m_type = value_t::array;
-    j.m_data.m_value = value_t::array;
-    j.m_data.m_value.array->resize(arr.size());
-    if (arr.size() > 0) {
-      std::copy(std::begin(arr), std::end(arr),
-                j.m_data.m_value.array->begin());
-    }
-    j.set_parents();
-    j.assert_invariant();
-  }
-};
-
-template <> struct external_constructor<value_t::object> {
-  template <typename BasicJsonType>
-  static void construct(BasicJsonType &j,
-                        const typename BasicJsonType::object_t &obj) {
-    j.m_data.m_value.destroy(j.m_data.m_type);
-    j.m_data.m_type = value_t::object;
-    j.m_data.m_value = obj;
-    j.set_parents();
-    j.assert_invariant();
-  }
-
-  template <typename BasicJsonType>
-  static void construct(BasicJsonType &j,
-                        typename BasicJsonType::object_t &&obj) {
-    j.m_data.m_value.destroy(j.m_data.m_type);
-    j.m_data.m_type = value_t::object;
-    j.m_data.m_value = std::move(obj);
-    j.set_parents();
-    j.assert_invariant();
-  }
-
-  template <typename BasicJsonType, typename CompatibleObjectType,
-            enable_if_t<!std::is_same<CompatibleObjectType,
-                                      typename BasicJsonType::object_t>::value,
-                        int> = 0>
-  static void construct(BasicJsonType &j, const CompatibleObjectType &obj) {
-    using std::begin;
-    using std::end;
-
-    j.m_data.m_value.destroy(j.m_data.m_type);
-    j.m_data.m_type = value_t::object;
-    j.m_data.m_value.object =
-        j.template create<typename BasicJsonType::object_t>(begin(obj),
-                                                            end(obj));
-    j.set_parents();
-    j.assert_invariant();
-  }
-};
-
-/////////////
-// to_json //
-/////////////
-
-#ifdef JSON_HAS_CPP_17
-template <typename BasicJsonType, typename T,
-          enable_if_t<std::is_constructible<BasicJsonType, T>::value, int> = 0>
-void to_json(BasicJsonType &j, const std::optional<T> &opt) {
-  if (opt.has_value()) {
-    j = *opt;
-  } else {
-    j = nullptr;
-  }
-}
-#endif
-
-template <typename BasicJsonType, typename T,
-          enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value,
-                      int> = 0>
-inline void to_json(BasicJsonType &j, T b) noexcept {
-  external_constructor<value_t::boolean>::construct(j, b);
-}
-
-template <
-    typename BasicJsonType, typename BoolRef,
-    enable_if_t<
-        ((std::is_same<std::vector<bool>::reference, BoolRef>::value &&
-          !std::is_same<std::vector<bool>::reference,
-                        typename BasicJsonType::boolean_t &>::value) ||
-         (std::is_same<std::vector<bool>::const_reference, BoolRef>::value &&
-          !std::is_same<detail::uncvref_t<std::vector<bool>::const_reference>,
-                        typename BasicJsonType::boolean_t>::value)) &&
-            std::is_convertible<const BoolRef &,
-                                typename BasicJsonType::boolean_t>::value,
-        int> = 0>
-inline void to_json(BasicJsonType &j, const BoolRef &b) noexcept {
-  external_constructor<value_t::boolean>::construct(
-      j, static_cast<typename BasicJsonType::boolean_t>(b));
-}
-
-template <typename BasicJsonType, typename CompatibleString,
-          enable_if_t<std::is_constructible<typename BasicJsonType::string_t,
-                                            CompatibleString>::value,
-                      int> = 0>
-inline void to_json(BasicJsonType &j, const CompatibleString &s) {
-  external_constructor<value_t::string>::construct(j, s);
-}
-
-template <typename BasicJsonType>
-inline void to_json(BasicJsonType &j, typename BasicJsonType::string_t &&s) {
-  external_constructor<value_t::string>::construct(j, std::move(s));
-}
-
-template <typename BasicJsonType, typename FloatType,
-          enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>
-inline void to_json(BasicJsonType &j, FloatType val) noexcept {
-  external_constructor<value_t::number_float>::construct(
-      j, static_cast<typename BasicJsonType::number_float_t>(val));
-}
-
-template <typename BasicJsonType, typename CompatibleNumberUnsignedType,
-          enable_if_t<is_compatible_integer_type<
-                          typename BasicJsonType::number_unsigned_t,
-                          CompatibleNumberUnsignedType>::value,
-                      int> = 0>
-inline void to_json(BasicJsonType &j,
-                    CompatibleNumberUnsignedType val) noexcept {
-  external_constructor<value_t::number_unsigned>::construct(
-      j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
-}
-
-template <typename BasicJsonType, typename CompatibleNumberIntegerType,
-          enable_if_t<is_compatible_integer_type<
-                          typename BasicJsonType::number_integer_t,
-                          CompatibleNumberIntegerType>::value,
-                      int> = 0>
-inline void to_json(BasicJsonType &j,
-                    CompatibleNumberIntegerType val) noexcept {
-  external_constructor<value_t::number_integer>::construct(
-      j, static_cast<typename BasicJsonType::number_integer_t>(val));
-}
-
-#if !JSON_DISABLE_ENUM_SERIALIZATION
-template <typename BasicJsonType, typename EnumType,
-          enable_if_t<std::is_enum<EnumType>::value, int> = 0>
-inline void to_json(BasicJsonType &j, EnumType e) noexcept {
-  using underlying_type = typename std::underlying_type<EnumType>::type;
-  static constexpr value_t integral_value_t =
-      std::is_unsigned<underlying_type>::value ? value_t::number_unsigned
-                                               : value_t::number_integer;
-  external_constructor<integral_value_t>::construct(
-      j, static_cast<underlying_type>(e));
-}
-#endif // JSON_DISABLE_ENUM_SERIALIZATION
-
-template <typename BasicJsonType>
-inline void to_json(BasicJsonType &j, const std::vector<bool> &e) {
-  external_constructor<value_t::array>::construct(j, e);
-}
-
-template <typename BasicJsonType, typename CompatibleArrayType,
-          enable_if_t<is_compatible_array_type<BasicJsonType,
-                                               CompatibleArrayType>::value &&
-                          !is_compatible_object_type<
-                              BasicJsonType, CompatibleArrayType>::value &&
-                          !is_compatible_string_type<
-                              BasicJsonType, CompatibleArrayType>::value &&
-                          !std::is_same<typename BasicJsonType::binary_t,
-                                        CompatibleArrayType>::value &&
-                          !is_basic_json<CompatibleArrayType>::value,
-                      int> = 0>
-inline void to_json(BasicJsonType &j, const CompatibleArrayType &arr) {
-  external_constructor<value_t::array>::construct(j, arr);
-}
-
-template <typename BasicJsonType>
-inline void to_json(BasicJsonType &j,
-                    const typename BasicJsonType::binary_t &bin) {
-  external_constructor<value_t::binary>::construct(j, bin);
-}
-
-template <typename BasicJsonType, typename T,
-          enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
-inline void to_json(BasicJsonType &j, const std::valarray<T> &arr) {
-  external_constructor<value_t::array>::construct(j, std::move(arr));
-}
-
-template <typename BasicJsonType>
-inline void to_json(BasicJsonType &j, typename BasicJsonType::array_t &&arr) {
-  external_constructor<value_t::array>::construct(j, std::move(arr));
-}
-
-template <typename BasicJsonType, typename CompatibleObjectType,
-          enable_if_t<is_compatible_object_type<BasicJsonType,
-                                                CompatibleObjectType>::value &&
-                          !is_basic_json<CompatibleObjectType>::value,
-                      int> = 0>
-inline void to_json(BasicJsonType &j, const CompatibleObjectType &obj) {
-  external_constructor<value_t::object>::construct(j, obj);
-}
-
-template <typename BasicJsonType>
-inline void to_json(BasicJsonType &j, typename BasicJsonType::object_t &&obj) {
-  external_constructor<value_t::object>::construct(j, std::move(obj));
-}
-
-template <
-    typename BasicJsonType, typename T, std::size_t N,
-    enable_if_t<
-        !std::is_constructible<typename BasicJsonType::string_t,
-                               const T (&)[N]>::
-            value, // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
-        int> = 0>
-inline void to_json(
-    BasicJsonType &j,
-    const T (&arr)
-        [N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
-{
-  external_constructor<value_t::array>::construct(j, arr);
-}
-
-template <typename BasicJsonType, typename T1, typename T2,
-          enable_if_t<std::is_constructible<BasicJsonType, T1>::value &&
-                          std::is_constructible<BasicJsonType, T2>::value,
-                      int> = 0>
-inline void to_json(BasicJsonType &j, const std::pair<T1, T2> &p) {
-  j = {p.first, p.second};
-}
-
-// for https://github.com/nlohmann/json/pull/1134
-template <
-    typename BasicJsonType, typename T,
-    enable_if_t<std::is_same<T, iteration_proxy_value<
-                                    typename BasicJsonType::iterator>>::value,
-                int> = 0>
-inline void to_json(BasicJsonType &j, const T &b) {
-  j = {{b.key(), b.value()}};
-}
-
-template <typename BasicJsonType, typename Tuple, std::size_t... Idx>
-inline void to_json_tuple_impl(BasicJsonType &j, const Tuple &t,
-                               index_sequence<Idx...> /*unused*/) {
-  j = {std::get<Idx>(t)...};
-}
-
-template <typename BasicJsonType, typename T,
-          enable_if_t<is_constructible_tuple<BasicJsonType, T>::value, int> = 0>
-inline void to_json(BasicJsonType &j, const T &t) {
-  to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value>{});
-}
-
-#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
-template <typename BasicJsonType>
-inline void to_json(BasicJsonType &j, const std_fs::path &p) {
-  j = p.string();
-}
-#endif
-
-struct to_json_fn {
-  template <typename BasicJsonType, typename T>
-  auto operator()(BasicJsonType &j, T &&val) const
-      noexcept(noexcept(to_json(j, std::forward<T>(val))))
-          -> decltype(to_json(j, std::forward<T>(val)), void()) {
-    return to_json(j, std::forward<T>(val));
-  }
-};
-} // namespace detail
-
-#ifndef JSON_HAS_CPP_17
-/// namespace to hold default `to_json` function
-/// to see why this is required:
-/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
-namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
-{
-#endif
-JSON_INLINE_VARIABLE constexpr const auto
-    &to_json = // NOLINT(misc-definitions-in-headers)
-    detail::static_const<detail::to_json_fn>::value;
-#ifndef JSON_HAS_CPP_17
-} // namespace
-#endif
-
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/meta/identity_tag.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-
-/// @sa https://json.nlohmann.me/api/adl_serializer/
-template <typename ValueType, typename> struct adl_serializer {
-  /// @brief convert a JSON value to any value type
-  /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
-  template <typename BasicJsonType, typename TargetType = ValueType>
-  static auto from_json(BasicJsonType &&j, TargetType &val) noexcept(
-      noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
-      -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val),
-                  void()) {
-    ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
-  }
-
-  /// @brief convert a JSON value to any value type
-  /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
-  template <typename BasicJsonType, typename TargetType = ValueType>
-  static auto from_json(BasicJsonType &&j) noexcept(
-      noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j),
-                                     detail::identity_tag<TargetType>{})))
-      -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j),
-                                        detail::identity_tag<TargetType>{})) {
-    return ::nlohmann::from_json(std::forward<BasicJsonType>(j),
-                                 detail::identity_tag<TargetType>{});
-  }
-
-  /// @brief convert any value type to a JSON value
-  /// @sa https://json.nlohmann.me/api/adl_serializer/to_json/
-  template <typename BasicJsonType, typename TargetType = ValueType>
-  static auto to_json(BasicJsonType &j, TargetType &&val) noexcept(
-      noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val))))
-      -> decltype(::nlohmann::to_json(j, std::forward<TargetType>(val)),
-                  void()) {
-    ::nlohmann::to_json(j, std::forward<TargetType>(val));
-  }
-};
-
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/byte_container_with_subtype.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <cstdint> // uint8_t, uint64_t
-#include <tuple>   // tie
-#include <utility> // move
-
-// #include <nlohmann/detail/abi_macros.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-
-/// @brief an internal type for a backed binary type
-/// @sa https://json.nlohmann.me/api/byte_container_with_subtype/
-template <typename BinaryType>
-class byte_container_with_subtype : public BinaryType {
-public:
-  using container_type = BinaryType;
-  using subtype_type = std::uint64_t;
-
-  /// @sa
-  /// https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
-  byte_container_with_subtype() noexcept(noexcept(container_type()))
-      : container_type() {}
-
-  /// @sa
-  /// https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
-  byte_container_with_subtype(const container_type &b) noexcept(
-      noexcept(container_type(b)))
-      : container_type(b) {}
-
-  /// @sa
-  /// https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
-  byte_container_with_subtype(container_type &&b) noexcept(
-      noexcept(container_type(std::move(b))))
-      : container_type(std::move(b)) {}
-
-  /// @sa
-  /// https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
-  byte_container_with_subtype(
-      const container_type &b,
-      subtype_type subtype_) noexcept(noexcept(container_type(b)))
-      : container_type(b), m_subtype(subtype_), m_has_subtype(true) {}
-
-  /// @sa
-  /// https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
-  byte_container_with_subtype(
-      container_type &&b,
-      subtype_type subtype_) noexcept(noexcept(container_type(std::move(b))))
-      : container_type(std::move(b)), m_subtype(subtype_), m_has_subtype(true) {
-  }
-
-  bool operator==(const byte_container_with_subtype &rhs) const {
-    return std::tie(static_cast<const BinaryType &>(*this), m_subtype,
-                    m_has_subtype) ==
-           std::tie(static_cast<const BinaryType &>(rhs), rhs.m_subtype,
-                    rhs.m_has_subtype);
-  }
-
-  bool operator!=(const byte_container_with_subtype &rhs) const {
-    return !(rhs == *this);
-  }
-
-  /// @brief sets the binary subtype
-  /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/set_subtype/
-  void set_subtype(subtype_type subtype_) noexcept {
-    m_subtype = subtype_;
-    m_has_subtype = true;
-  }
-
-  /// @brief return the binary subtype
-  /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/subtype/
-  constexpr subtype_type subtype() const noexcept {
-    return m_has_subtype ? m_subtype : static_cast<subtype_type>(-1);
-  }
-
-  /// @brief return whether the value has a subtype
-  /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/has_subtype/
-  constexpr bool has_subtype() const noexcept { return m_has_subtype; }
-
-  /// @brief clears the binary subtype
-  /// @sa
-  /// https://json.nlohmann.me/api/byte_container_with_subtype/clear_subtype/
-  void clear_subtype() noexcept {
-    m_subtype = 0;
-    m_has_subtype = false;
-  }
-
-private:
-  subtype_type m_subtype = 0;
-  bool m_has_subtype = false;
-};
-
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/conversions/from_json.hpp>
-
-// #include <nlohmann/detail/conversions/to_json.hpp>
-
-// #include <nlohmann/detail/exceptions.hpp>
-
-// #include <nlohmann/detail/hash.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <cstddef>    // size_t
-#include <cstdint>    // uint8_t
-#include <functional> // hash
-
-// #include <nlohmann/detail/abi_macros.hpp>
-
-// #include <nlohmann/detail/value_t.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-// boost::hash_combine
-inline std::size_t combine(std::size_t seed, std::size_t h) noexcept {
-  seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
-  return seed;
-}
-
-/*!
-@brief hash a JSON value
-
-The hash function tries to rely on std::hash where possible. Furthermore, the
-type of the JSON value is taken into account to have different hash values for
-null, 0, 0U, and false, etc.
-
-@tparam BasicJsonType basic_json specialization
-@param j JSON value to hash
-@return hash value of j
-*/
-template <typename BasicJsonType> std::size_t hash(const BasicJsonType &j) {
-  using string_t = typename BasicJsonType::string_t;
-  using number_integer_t = typename BasicJsonType::number_integer_t;
-  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-  using number_float_t = typename BasicJsonType::number_float_t;
-
-  const auto type = static_cast<std::size_t>(j.type());
-  switch (j.type()) {
-  case BasicJsonType::value_t::null:
-  case BasicJsonType::value_t::discarded: {
-    return combine(type, 0);
-  }
-
-  case BasicJsonType::value_t::object: {
-    auto seed = combine(type, j.size());
-    for (const auto &element : j.items()) {
-      const auto h = std::hash<string_t>{}(element.key());
-      seed = combine(seed, h);
-      seed = combine(seed, hash(element.value()));
-    }
-    return seed;
-  }
-
-  case BasicJsonType::value_t::array: {
-    auto seed = combine(type, j.size());
-    for (const auto &element : j) {
-      seed = combine(seed, hash(element));
-    }
-    return seed;
-  }
-
-  case BasicJsonType::value_t::string: {
-    const auto h =
-        std::hash<string_t>{}(j.template get_ref<const string_t &>());
-    return combine(type, h);
-  }
-
-  case BasicJsonType::value_t::boolean: {
-    const auto h = std::hash<bool>{}(j.template get<bool>());
-    return combine(type, h);
-  }
-
-  case BasicJsonType::value_t::number_integer: {
-    const auto h =
-        std::hash<number_integer_t>{}(j.template get<number_integer_t>());
-    return combine(type, h);
-  }
-
-  case BasicJsonType::value_t::number_unsigned: {
-    const auto h =
-        std::hash<number_unsigned_t>{}(j.template get<number_unsigned_t>());
-    return combine(type, h);
-  }
-
-  case BasicJsonType::value_t::number_float: {
-    const auto h =
-        std::hash<number_float_t>{}(j.template get<number_float_t>());
-    return combine(type, h);
-  }
-
-  case BasicJsonType::value_t::binary: {
-    auto seed = combine(type, j.get_binary().size());
-    const auto h = std::hash<bool>{}(j.get_binary().has_subtype());
-    seed = combine(seed, h);
-    seed = combine(seed, static_cast<std::size_t>(j.get_binary().subtype()));
-    for (const auto byte : j.get_binary()) {
-      seed = combine(seed, std::hash<std::uint8_t>{}(byte));
-    }
-    return seed;
-  }
-
-  default:              // LCOV_EXCL_LINE
-    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
-                        // LCOV_EXCL_LINE
-    return 0; // LCOV_EXCL_LINE
-  }
-}
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/input/binary_reader.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <algorithm> // generate_n
-#include <array>     // array
-#include <cmath>     // ldexp
-#include <cstddef>   // size_t
-#include <cstdint>   // uint8_t, uint16_t, uint32_t, uint64_t
-#include <cstdio>    // snprintf
-#include <cstring>   // memcpy
-#include <iterator>  // back_inserter
-#include <limits>    // numeric_limits
-#include <string>    // char_traits, string
-#include <utility>   // make_pair, move
-#include <vector>    // vector
-#ifdef __cpp_lib_byteswap
-#include <bit> //byteswap
-#endif
-
-// #include <nlohmann/detail/exceptions.hpp>
-
-// #include <nlohmann/detail/input/input_adapters.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <array>   // array
-#include <cstddef> // size_t
-#include <cstring> // strlen
-#include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next
-#include <memory>  // shared_ptr, make_shared, addressof
-#include <numeric> // accumulate
-#include <string>  // string, char_traits
-#include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
-#include <utility> // pair, declval
-
-#ifndef JSON_NO_IO
-#include <cstdio>  // FILE *
-#include <istream> // istream
-#endif             // JSON_NO_IO
-
-// #include <nlohmann/detail/exceptions.hpp>
-
-// #include <nlohmann/detail/iterators/iterator_traits.hpp>
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/meta/type_traits.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-/// the supported input formats
-enum class input_format_t { json, cbor, msgpack, ubjson, bson, bjdata };
-
-////////////////////
-// input adapters //
-////////////////////
-
-#ifndef JSON_NO_IO
-/*!
-Input adapter for stdio file access. This adapter read only 1 byte and do not
-use any buffer. This adapter is a very low level adapter.
-*/
-class file_input_adapter {
-public:
-  using char_type = char;
-
-  JSON_HEDLEY_NON_NULL(2)
-  explicit file_input_adapter(std::FILE *f) noexcept : m_file(f) {
-    JSON_ASSERT(m_file != nullptr);
-  }
-
-  // make class move-only
-  file_input_adapter(const file_input_adapter &) = delete;
-  file_input_adapter(file_input_adapter &&) noexcept = default;
-  file_input_adapter &operator=(const file_input_adapter &) = delete;
-  file_input_adapter &operator=(file_input_adapter &&) = delete;
-  ~file_input_adapter() = default;
-
-  std::char_traits<char>::int_type get_character() noexcept {
-    return std::fgetc(m_file);
-  }
-
-  // returns the number of characters successfully read
-  template <class T> std::size_t get_elements(T *dest, std::size_t count = 1) {
-    return fread(dest, 1, sizeof(T) * count, m_file);
-  }
-
-private:
-  /// the file pointer to read from
-  std::FILE *m_file;
-};
-
-/*!
-Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at
-beginning of input. Does not support changing the underlying std::streambuf
-in mid-input. Maintains underlying std::istream and std::streambuf to support
-subsequent use of standard std::istream operations to process any input
-characters following those used in parsing the JSON input.  Clears the
-std::istream flags; any input errors (e.g., EOF) will be detected by the first
-subsequent call for input from the std::istream.
-*/
-class input_stream_adapter {
-public:
-  using char_type = char;
-
-  ~input_stream_adapter() {
-    // clear stream flags; we use underlying streambuf I/O, do not
-    // maintain ifstream flags, except eof
-    if (is != nullptr) {
-      is->clear(is->rdstate() & std::ios::eofbit);
-    }
-  }
-
-  explicit input_stream_adapter(std::istream &i) : is(&i), sb(i.rdbuf()) {}
-
-  // delete because of pointer members
-  input_stream_adapter(const input_stream_adapter &) = delete;
-  input_stream_adapter &operator=(input_stream_adapter &) = delete;
-  input_stream_adapter &operator=(input_stream_adapter &&) = delete;
-
-  input_stream_adapter(input_stream_adapter &&rhs) noexcept
-      : is(rhs.is), sb(rhs.sb) {
-    rhs.is = nullptr;
-    rhs.sb = nullptr;
-  }
-
-  // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
-  // ensure that std::char_traits<char>::eof() and the character 0xFF do not
-  // end up as the same value, e.g. 0xFFFFFFFF.
-  std::char_traits<char>::int_type get_character() {
-    auto res = sb->sbumpc();
-    // set eof manually, as we don't use the istream interface.
-    if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof())) {
-      is->clear(is->rdstate() | std::ios::eofbit);
-    }
-    return res;
-  }
-
-  template <class T> std::size_t get_elements(T *dest, std::size_t count = 1) {
-    auto res = static_cast<std::size_t>(
-        sb->sgetn(reinterpret_cast<char *>(dest),
-                  static_cast<std::streamsize>(count * sizeof(T))));
-    if (JSON_HEDLEY_UNLIKELY(res < count * sizeof(T))) {
-      is->clear(is->rdstate() | std::ios::eofbit);
-    }
-    return res;
-  }
-
-private:
-  /// the associated input stream
-  std::istream *is = nullptr;
-  std::streambuf *sb = nullptr;
-};
-#endif // JSON_NO_IO
-
-// General-purpose iterator-based adapter. It might not be as fast as
-// theoretically possible for some containers, but it is extremely versatile.
-template <typename IteratorType> class iterator_input_adapter {
-public:
-  using char_type = typename std::iterator_traits<IteratorType>::value_type;
-
-  iterator_input_adapter(IteratorType first, IteratorType last)
-      : current(std::move(first)), end(std::move(last)) {}
-
-  typename char_traits<char_type>::int_type get_character() {
-    if (JSON_HEDLEY_LIKELY(current != end)) {
-      auto result = char_traits<char_type>::to_int_type(*current);
-      std::advance(current, 1);
-      return result;
-    }
-
-    return char_traits<char_type>::eof();
-  }
-
-  // for general iterators, we cannot really do something better than falling
-  // back to processing the range one-by-one
-  template <class T> std::size_t get_elements(T *dest, std::size_t count = 1) {
-    auto *ptr = reinterpret_cast<char *>(dest);
-    for (std::size_t read_index = 0; read_index < count * sizeof(T);
-         ++read_index) {
-      if (JSON_HEDLEY_LIKELY(current != end)) {
-        ptr[read_index] = static_cast<char>(*current);
-        std::advance(current, 1);
-      } else {
-        return read_index;
-      }
-    }
-    return count * sizeof(T);
-  }
-
-private:
-  IteratorType current;
-  IteratorType end;
-
-  template <typename BaseInputAdapter, size_t T>
-  friend struct wide_string_input_helper;
-
-  bool empty() const { return current == end; }
-};
-
-template <typename BaseInputAdapter, size_t T> struct wide_string_input_helper;
-
-template <typename BaseInputAdapter>
-struct wide_string_input_helper<BaseInputAdapter, 4> {
-  // UTF-32
-  static void
-  fill_buffer(BaseInputAdapter &input,
-              std::array<std::char_traits<char>::int_type, 4> &utf8_bytes,
-              size_t &utf8_bytes_index, size_t &utf8_bytes_filled) {
-    utf8_bytes_index = 0;
-
-    if (JSON_HEDLEY_UNLIKELY(input.empty())) {
-      utf8_bytes[0] = std::char_traits<char>::eof();
-      utf8_bytes_filled = 1;
-    } else {
-      // get the current character
-      const auto wc = input.get_character();
-
-      // UTF-32 to UTF-8 encoding
-      if (wc < 0x80) {
-        utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
-        utf8_bytes_filled = 1;
-      } else if (wc <= 0x7FF) {
-        utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(
-            0xC0u | ((static_cast<unsigned int>(wc) >> 6u) & 0x1Fu));
-        utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(
-            0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
-        utf8_bytes_filled = 2;
-      } else if (wc <= 0xFFFF) {
-        utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(
-            0xE0u | ((static_cast<unsigned int>(wc) >> 12u) & 0x0Fu));
-        utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(
-            0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
-        utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(
-            0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
-        utf8_bytes_filled = 3;
-      } else if (wc <= 0x10FFFF) {
-        utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(
-            0xF0u | ((static_cast<unsigned int>(wc) >> 18u) & 0x07u));
-        utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(
-            0x80u | ((static_cast<unsigned int>(wc) >> 12u) & 0x3Fu));
-        utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(
-            0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
-        utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(
-            0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
-        utf8_bytes_filled = 4;
-      } else {
-        // unknown character
-        utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
-        utf8_bytes_filled = 1;
-      }
-    }
-  }
-};
-
-template <typename BaseInputAdapter>
-struct wide_string_input_helper<BaseInputAdapter, 2> {
-  // UTF-16
-  static void
-  fill_buffer(BaseInputAdapter &input,
-              std::array<std::char_traits<char>::int_type, 4> &utf8_bytes,
-              size_t &utf8_bytes_index, size_t &utf8_bytes_filled) {
-    utf8_bytes_index = 0;
-
-    if (JSON_HEDLEY_UNLIKELY(input.empty())) {
-      utf8_bytes[0] = std::char_traits<char>::eof();
-      utf8_bytes_filled = 1;
-    } else {
-      // get the current character
-      const auto wc = input.get_character();
-
-      // UTF-16 to UTF-8 encoding
-      if (wc < 0x80) {
-        utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
-        utf8_bytes_filled = 1;
-      } else if (wc <= 0x7FF) {
-        utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(
-            0xC0u | ((static_cast<unsigned int>(wc) >> 6u)));
-        utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(
-            0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
-        utf8_bytes_filled = 2;
-      } else if (0xD800 > wc || wc >= 0xE000) {
-        utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(
-            0xE0u | ((static_cast<unsigned int>(wc) >> 12u)));
-        utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(
-            0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
-        utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(
-            0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
-        utf8_bytes_filled = 3;
-      } else {
-        if (JSON_HEDLEY_UNLIKELY(!input.empty())) {
-          const auto wc2 = static_cast<unsigned int>(input.get_character());
-          const auto charcode =
-              0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) |
-                          (wc2 & 0x3FFu));
-          utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(
-              0xF0u | (charcode >> 18u));
-          utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(
-              0x80u | ((charcode >> 12u) & 0x3Fu));
-          utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(
-              0x80u | ((charcode >> 6u) & 0x3Fu));
-          utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(
-              0x80u | (charcode & 0x3Fu));
-          utf8_bytes_filled = 4;
-        } else {
-          utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
-          utf8_bytes_filled = 1;
-        }
-      }
-    }
-  }
-};
-
-// Wraps another input adapter to convert wide character types into individual
-// bytes.
-template <typename BaseInputAdapter, typename WideCharType>
-class wide_string_input_adapter {
-public:
-  using char_type = char;
-
-  wide_string_input_adapter(BaseInputAdapter base) : base_adapter(base) {}
-
-  typename std::char_traits<char>::int_type get_character() noexcept {
-    // check if buffer needs to be filled
-    if (utf8_bytes_index == utf8_bytes_filled) {
-      fill_buffer<sizeof(WideCharType)>();
-
-      JSON_ASSERT(utf8_bytes_filled > 0);
-      JSON_ASSERT(utf8_bytes_index == 0);
-    }
-
-    // use buffer
-    JSON_ASSERT(utf8_bytes_filled > 0);
-    JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);
-    return utf8_bytes[utf8_bytes_index++];
-  }
-
-  // parsing binary with wchar doesn't make sense, but since the parsing mode
-  // can be runtime, we need something here
-  template <class T>
-  std::size_t get_elements(T * /*dest*/, std::size_t /*count*/ = 1) {
-    JSON_THROW(parse_error::create(
-        112, 1, "wide string type cannot be interpreted as binary data",
-        nullptr));
-  }
-
-private:
-  BaseInputAdapter base_adapter;
-
-  template <size_t T> void fill_buffer() {
-    wide_string_input_helper<BaseInputAdapter, T>::fill_buffer(
-        base_adapter, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);
-  }
-
-  /// a buffer for UTF-8 bytes
-  std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};
-
-  /// index to the utf8_codes array for the next valid byte
-  std::size_t utf8_bytes_index = 0;
-  /// number of valid bytes in the utf8_codes array
-  std::size_t utf8_bytes_filled = 0;
-};
-
-template <typename IteratorType, typename Enable = void>
-struct iterator_input_adapter_factory {
-  using iterator_type = IteratorType;
-  using char_type = typename std::iterator_traits<iterator_type>::value_type;
-  using adapter_type = iterator_input_adapter<iterator_type>;
-
-  static adapter_type create(IteratorType first, IteratorType last) {
-    return adapter_type(std::move(first), std::move(last));
-  }
-};
-
-template <typename T> struct is_iterator_of_multibyte {
-  using value_type = typename std::iterator_traits<T>::value_type;
-  enum { value = sizeof(value_type) > 1 };
-};
-
-template <typename IteratorType>
-struct iterator_input_adapter_factory<
-    IteratorType, enable_if_t<is_iterator_of_multibyte<IteratorType>::value>> {
-  using iterator_type = IteratorType;
-  using char_type = typename std::iterator_traits<iterator_type>::value_type;
-  using base_adapter_type = iterator_input_adapter<iterator_type>;
-  using adapter_type = wide_string_input_adapter<base_adapter_type, char_type>;
-
-  static adapter_type create(IteratorType first, IteratorType last) {
-    return adapter_type(base_adapter_type(std::move(first), std::move(last)));
-  }
-};
-
-// General purpose iterator-based input
-template <typename IteratorType>
-typename iterator_input_adapter_factory<IteratorType>::adapter_type
-input_adapter(IteratorType first, IteratorType last) {
-  using factory_type = iterator_input_adapter_factory<IteratorType>;
-  return factory_type::create(first, last);
-}
-
-// Convenience shorthand from container to iterator
-// Enables ADL on begin(container) and end(container)
-// Encloses the using declarations in namespace for not to leak them to outside
-// scope
-
-namespace container_input_adapter_factory_impl {
-
-using std::begin;
-using std::end;
-
-template <typename ContainerType, typename Enable = void>
-struct container_input_adapter_factory {};
-
-template <typename ContainerType>
-struct container_input_adapter_factory<
-    ContainerType, void_t<decltype(begin(std::declval<ContainerType>()),
-                                   end(std::declval<ContainerType>()))>> {
-  using adapter_type =
-      decltype(input_adapter(begin(std::declval<ContainerType>()),
-                             end(std::declval<ContainerType>())));
-
-  static adapter_type create(const ContainerType &container) {
-    return input_adapter(begin(container), end(container));
-  }
-};
-
-} // namespace container_input_adapter_factory_impl
-
-template <typename ContainerType>
-typename container_input_adapter_factory_impl::container_input_adapter_factory<
-    ContainerType>::adapter_type
-input_adapter(const ContainerType &container) {
-  return container_input_adapter_factory_impl::container_input_adapter_factory<
-      ContainerType>::create(container);
-}
-
-#ifndef JSON_NO_IO
-// Special cases with fast paths
-inline file_input_adapter input_adapter(std::FILE *file) {
-  if (file == nullptr) {
-    JSON_THROW(parse_error::create(
-        101, 0,
-        "attempting to parse an empty input; check that your input string or "
-        "stream contains the expected JSON",
-        nullptr));
-  }
-  return file_input_adapter(file);
-}
-
-inline input_stream_adapter input_adapter(std::istream &stream) {
-  return input_stream_adapter(stream);
-}
-
-inline input_stream_adapter input_adapter(std::istream &&stream) {
-  return input_stream_adapter(stream);
-}
-#endif // JSON_NO_IO
-
-using contiguous_bytes_input_adapter = decltype(input_adapter(
-    std::declval<const char *>(), std::declval<const char *>()));
-
-// Null-delimited strings, and the like.
-template <typename CharT,
-          typename std::enable_if<
-              std::is_pointer<CharT>::value && !std::is_array<CharT>::value &&
-                  std::is_integral<
-                      typename std::remove_pointer<CharT>::type>::value &&
-                  sizeof(typename std::remove_pointer<CharT>::type) == 1,
-              int>::type = 0>
-contiguous_bytes_input_adapter input_adapter(CharT b) {
-  if (b == nullptr) {
-    JSON_THROW(parse_error::create(
-        101, 0,
-        "attempting to parse an empty input; check that your input string or "
-        "stream contains the expected JSON",
-        nullptr));
-  }
-  auto length = std::strlen(reinterpret_cast<const char *>(b));
-  const auto *ptr = reinterpret_cast<const char *>(b);
-  return input_adapter(ptr, ptr + length);
-}
-
-template <typename T, std::size_t N>
-auto input_adapter(T (&array)[N]) -> decltype(input_adapter(
-    array,
-    array +
-        N)) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
-{
-  return input_adapter(array, array + N);
-}
-
-// This class only handles inputs of input_buffer_adapter type.
-// It's required so that expressions like {ptr, len} can be implicitly cast
-// to the correct adapter.
-class span_input_adapter {
-public:
-  template <typename CharT,
-            typename std::enable_if<
-                std::is_pointer<CharT>::value &&
-                    std::is_integral<
-                        typename std::remove_pointer<CharT>::type>::value &&
-                    sizeof(typename std::remove_pointer<CharT>::type) == 1,
-                int>::type = 0>
-  span_input_adapter(CharT b, std::size_t l)
-      : ia(reinterpret_cast<const char *>(b),
-           reinterpret_cast<const char *>(b) + l) {}
-
-  template <class IteratorType,
-            typename std::enable_if<
-                std::is_same<
-                    typename iterator_traits<IteratorType>::iterator_category,
-                    std::random_access_iterator_tag>::value,
-                int>::type = 0>
-  span_input_adapter(IteratorType first, IteratorType last)
-      : ia(input_adapter(first, last)) {}
-
-  contiguous_bytes_input_adapter &&get() {
-    return std::move(
-        ia); // NOLINT(hicpp-move-const-arg,performance-move-const-arg)
-  }
-
-private:
-  contiguous_bytes_input_adapter ia;
-};
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/input/json_sax.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <cstddef>
-#include <string>  // string
-#include <utility> // move
-#include <vector>  // vector
-
-// #include <nlohmann/detail/exceptions.hpp>
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/string_concat.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-
-/*!
-@brief SAX interface
-
-This class describes the SAX interface used by @ref nlohmann::json::sax_parse.
-Each function is called in different situations while the input is parsed. The
-boolean return value informs the parser whether to continue processing the
-input.
-*/
-template <typename BasicJsonType> struct json_sax {
-  using number_integer_t = typename BasicJsonType::number_integer_t;
-  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-  using number_float_t = typename BasicJsonType::number_float_t;
-  using string_t = typename BasicJsonType::string_t;
-  using binary_t = typename BasicJsonType::binary_t;
-
-  /*!
-  @brief a null value was read
-  @return whether parsing should proceed
-  */
-  virtual bool null() = 0;
-
-  /*!
-  @brief a boolean value was read
-  @param[in] val  boolean value
-  @return whether parsing should proceed
-  */
-  virtual bool boolean(bool val) = 0;
-
-  /*!
-  @brief an integer number was read
-  @param[in] val  integer value
-  @return whether parsing should proceed
-  */
-  virtual bool number_integer(number_integer_t val) = 0;
-
-  /*!
-  @brief an unsigned integer number was read
-  @param[in] val  unsigned integer value
-  @return whether parsing should proceed
-  */
-  virtual bool number_unsigned(number_unsigned_t val) = 0;
-
-  /*!
-  @brief a floating-point number was read
-  @param[in] val  floating-point value
-  @param[in] s    raw token value
-  @return whether parsing should proceed
-  */
-  virtual bool number_float(number_float_t val, const string_t &s) = 0;
-
-  /*!
-  @brief a string value was read
-  @param[in] val  string value
-  @return whether parsing should proceed
-  @note It is safe to move the passed string value.
-  */
-  virtual bool string(string_t &val) = 0;
-
-  /*!
-  @brief a binary value was read
-  @param[in] val  binary value
-  @return whether parsing should proceed
-  @note It is safe to move the passed binary value.
-  */
-  virtual bool binary(binary_t &val) = 0;
-
-  /*!
-  @brief the beginning of an object was read
-  @param[in] elements  number of object elements or -1 if unknown
-  @return whether parsing should proceed
-  @note binary formats may report the number of elements
-  */
-  virtual bool start_object(std::size_t elements) = 0;
-
-  /*!
-  @brief an object key was read
-  @param[in] val  object key
-  @return whether parsing should proceed
-  @note It is safe to move the passed string.
-  */
-  virtual bool key(string_t &val) = 0;
-
-  /*!
-  @brief the end of an object was read
-  @return whether parsing should proceed
-  */
-  virtual bool end_object() = 0;
-
-  /*!
-  @brief the beginning of an array was read
-  @param[in] elements  number of array elements or -1 if unknown
-  @return whether parsing should proceed
-  @note binary formats may report the number of elements
-  */
-  virtual bool start_array(std::size_t elements) = 0;
-
-  /*!
-  @brief the end of an array was read
-  @return whether parsing should proceed
-  */
-  virtual bool end_array() = 0;
-
-  /*!
-  @brief a parse error occurred
-  @param[in] position    the position in the input where the error occurs
-  @param[in] last_token  the last read token
-  @param[in] ex          an exception object describing the error
-  @return whether parsing should proceed (must return false)
-  */
-  virtual bool parse_error(std::size_t position, const std::string &last_token,
-                           const detail::exception &ex) = 0;
-
-  json_sax() = default;
-  json_sax(const json_sax &) = default;
-  json_sax(json_sax &&) noexcept = default;
-  json_sax &operator=(const json_sax &) = default;
-  json_sax &operator=(json_sax &&) noexcept = default;
-  virtual ~json_sax() = default;
-};
-
-namespace detail {
-/*!
-@brief SAX implementation to create a JSON value from SAX events
-
-This class implements the @ref json_sax interface and processes the SAX events
-to create a JSON value which makes it basically a DOM parser. The structure or
-hierarchy of the JSON value is managed by the stack `ref_stack` which contains
-a pointer to the respective array or object for each recursion depth.
-
-After successful parsing, the value that is passed by reference to the
-constructor contains the parsed value.
-
-@tparam BasicJsonType  the JSON type
-*/
-template <typename BasicJsonType> class json_sax_dom_parser {
-public:
-  using number_integer_t = typename BasicJsonType::number_integer_t;
-  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-  using number_float_t = typename BasicJsonType::number_float_t;
-  using string_t = typename BasicJsonType::string_t;
-  using binary_t = typename BasicJsonType::binary_t;
-
-  /*!
-  @param[in,out] r  reference to a JSON value that is manipulated while
-                     parsing
-  @param[in] allow_exceptions_  whether parse errors yield exceptions
-  */
-  explicit json_sax_dom_parser(BasicJsonType &r,
-                               const bool allow_exceptions_ = true)
-      : root(r), allow_exceptions(allow_exceptions_) {}
-
-  // make class move-only
-  json_sax_dom_parser(const json_sax_dom_parser &) = delete;
-  json_sax_dom_parser(json_sax_dom_parser &&) =
-      default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
-  json_sax_dom_parser &operator=(const json_sax_dom_parser &) = delete;
-  json_sax_dom_parser &operator=(json_sax_dom_parser &&) =
-      default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
-  ~json_sax_dom_parser() = default;
-
-  bool null() {
-    handle_value(nullptr);
-    return true;
-  }
-
-  bool boolean(bool val) {
-    handle_value(val);
-    return true;
-  }
-
-  bool number_integer(number_integer_t val) {
-    handle_value(val);
-    return true;
-  }
-
-  bool number_unsigned(number_unsigned_t val) {
-    handle_value(val);
-    return true;
-  }
-
-  bool number_float(number_float_t val, const string_t & /*unused*/) {
-    handle_value(val);
-    return true;
-  }
-
-  bool string(string_t &val) {
-    handle_value(val);
-    return true;
-  }
-
-  bool binary(binary_t &val) {
-    handle_value(std::move(val));
-    return true;
-  }
-
-  bool start_object(std::size_t len) {
-    ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
-
-    if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) &&
-                             len > ref_stack.back()->max_size())) {
-      JSON_THROW(out_of_range::create(
-          408, concat("excessive object size: ", std::to_string(len)),
-          ref_stack.back()));
-    }
-
-    return true;
-  }
-
-  bool key(string_t &val) {
-    JSON_ASSERT(!ref_stack.empty());
-    JSON_ASSERT(ref_stack.back()->is_object());
-
-    // add null at given key and store the reference for later
-    object_element =
-        &(ref_stack.back()->m_data.m_value.object->operator[](val));
-    return true;
-  }
-
-  bool end_object() {
-    JSON_ASSERT(!ref_stack.empty());
-    JSON_ASSERT(ref_stack.back()->is_object());
-
-    ref_stack.back()->set_parents();
-    ref_stack.pop_back();
-    return true;
-  }
-
-  bool start_array(std::size_t len) {
-    ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
-
-    if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) &&
-                             len > ref_stack.back()->max_size())) {
-      JSON_THROW(out_of_range::create(
-          408, concat("excessive array size: ", std::to_string(len)),
-          ref_stack.back()));
-    }
-
-    return true;
-  }
-
-  bool end_array() {
-    JSON_ASSERT(!ref_stack.empty());
-    JSON_ASSERT(ref_stack.back()->is_array());
-
-    ref_stack.back()->set_parents();
-    ref_stack.pop_back();
-    return true;
-  }
-
-  template <class Exception>
-  bool parse_error(std::size_t /*unused*/, const std::string & /*unused*/,
-                   const Exception &ex) {
-    errored = true;
-    static_cast<void>(ex);
-    if (allow_exceptions) {
-      JSON_THROW(ex);
-    }
-    return false;
-  }
-
-  constexpr bool is_errored() const { return errored; }
-
-private:
-  /*!
-  @invariant If the ref stack is empty, then the passed value will be the new
-             root.
-  @invariant If the ref stack contains a value, then it is an array or an
-             object to which we can add elements
-  */
-  template <typename Value>
-  JSON_HEDLEY_RETURNS_NON_NULL BasicJsonType *handle_value(Value &&v) {
-    if (ref_stack.empty()) {
-      root = BasicJsonType(std::forward<Value>(v));
-      return &root;
-    }
-
-    JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
-
-    if (ref_stack.back()->is_array()) {
-      ref_stack.back()->m_data.m_value.array->emplace_back(
-          std::forward<Value>(v));
-      return &(ref_stack.back()->m_data.m_value.array->back());
-    }
-
-    JSON_ASSERT(ref_stack.back()->is_object());
-    JSON_ASSERT(object_element);
-    *object_element = BasicJsonType(std::forward<Value>(v));
-    return object_element;
-  }
-
-  /// the parsed JSON value
-  BasicJsonType &root;
-  /// stack to model hierarchy of values
-  std::vector<BasicJsonType *> ref_stack{};
-  /// helper to hold the reference for the next object element
-  BasicJsonType *object_element = nullptr;
-  /// whether a syntax error occurred
-  bool errored = false;
-  /// whether to throw exceptions in case of errors
-  const bool allow_exceptions = true;
-};
-
-template <typename BasicJsonType> class json_sax_dom_callback_parser {
-public:
-  using number_integer_t = typename BasicJsonType::number_integer_t;
-  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-  using number_float_t = typename BasicJsonType::number_float_t;
-  using string_t = typename BasicJsonType::string_t;
-  using binary_t = typename BasicJsonType::binary_t;
-  using parser_callback_t = typename BasicJsonType::parser_callback_t;
-  using parse_event_t = typename BasicJsonType::parse_event_t;
-
-  json_sax_dom_callback_parser(BasicJsonType &r, parser_callback_t cb,
-                               const bool allow_exceptions_ = true)
-      : root(r), callback(std::move(cb)), allow_exceptions(allow_exceptions_) {
-    keep_stack.push_back(true);
-  }
-
-  // make class move-only
-  json_sax_dom_callback_parser(const json_sax_dom_callback_parser &) = delete;
-  json_sax_dom_callback_parser(json_sax_dom_callback_parser &&) =
-      default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
-  json_sax_dom_callback_parser &
-  operator=(const json_sax_dom_callback_parser &) = delete;
-  json_sax_dom_callback_parser &operator=(json_sax_dom_callback_parser &&) =
-      default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
-  ~json_sax_dom_callback_parser() = default;
-
-  bool null() {
-    handle_value(nullptr);
-    return true;
-  }
-
-  bool boolean(bool val) {
-    handle_value(val);
-    return true;
-  }
-
-  bool number_integer(number_integer_t val) {
-    handle_value(val);
-    return true;
-  }
-
-  bool number_unsigned(number_unsigned_t val) {
-    handle_value(val);
-    return true;
-  }
-
-  bool number_float(number_float_t val, const string_t & /*unused*/) {
-    handle_value(val);
-    return true;
-  }
-
-  bool string(string_t &val) {
-    handle_value(val);
-    return true;
-  }
-
-  bool binary(binary_t &val) {
-    handle_value(std::move(val));
-    return true;
-  }
-
-  bool start_object(std::size_t len) {
-    // check callback for object start
-    const bool keep = callback(static_cast<int>(ref_stack.size()),
-                               parse_event_t::object_start, discarded);
-    keep_stack.push_back(keep);
-
-    auto val = handle_value(BasicJsonType::value_t::object, true);
-    ref_stack.push_back(val.second);
-
-    // check object limit
-    if (ref_stack.back() &&
-        JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) &&
-                             len > ref_stack.back()->max_size())) {
-      JSON_THROW(out_of_range::create(
-          408, concat("excessive object size: ", std::to_string(len)),
-          ref_stack.back()));
-    }
-
-    return true;
-  }
-
-  bool key(string_t &val) {
-    BasicJsonType k = BasicJsonType(val);
-
-    // check callback for key
-    const bool keep =
-        callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
-    key_keep_stack.push_back(keep);
-
-    // add discarded value at given key and store the reference for later
-    if (keep && ref_stack.back()) {
-      object_element = &(
-          ref_stack.back()->m_data.m_value.object->operator[](val) = discarded);
-    }
-
-    return true;
-  }
-
-  bool end_object() {
-    if (ref_stack.back()) {
-      if (!callback(static_cast<int>(ref_stack.size()) - 1,
-                    parse_event_t::object_end, *ref_stack.back())) {
-        // discard object
-        *ref_stack.back() = discarded;
-      } else {
-        ref_stack.back()->set_parents();
-      }
-    }
-
-    JSON_ASSERT(!ref_stack.empty());
-    JSON_ASSERT(!keep_stack.empty());
-    ref_stack.pop_back();
-    keep_stack.pop_back();
-
-    if (!ref_stack.empty() && ref_stack.back() &&
-        ref_stack.back()->is_structured()) {
-      // remove discarded value
-      for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end();
-           ++it) {
-        if (it->is_discarded()) {
-          ref_stack.back()->erase(it);
-          break;
-        }
-      }
-    }
-
-    return true;
-  }
-
-  bool start_array(std::size_t len) {
-    const bool keep = callback(static_cast<int>(ref_stack.size()),
-                               parse_event_t::array_start, discarded);
-    keep_stack.push_back(keep);
-
-    auto val = handle_value(BasicJsonType::value_t::array, true);
-    ref_stack.push_back(val.second);
-
-    // check array limit
-    if (ref_stack.back() &&
-        JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) &&
-                             len > ref_stack.back()->max_size())) {
-      JSON_THROW(out_of_range::create(
-          408, concat("excessive array size: ", std::to_string(len)),
-          ref_stack.back()));
-    }
-
-    return true;
-  }
-
-  bool end_array() {
-    bool keep = true;
-
-    if (ref_stack.back()) {
-      keep = callback(static_cast<int>(ref_stack.size()) - 1,
-                      parse_event_t::array_end, *ref_stack.back());
-      if (keep) {
-        ref_stack.back()->set_parents();
-      } else {
-        // discard array
-        *ref_stack.back() = discarded;
-      }
-    }
-
-    JSON_ASSERT(!ref_stack.empty());
-    JSON_ASSERT(!keep_stack.empty());
-    ref_stack.pop_back();
-    keep_stack.pop_back();
-
-    // remove discarded value
-    if (!keep && !ref_stack.empty() && ref_stack.back()->is_array()) {
-      ref_stack.back()->m_data.m_value.array->pop_back();
-    }
-
-    return true;
-  }
-
-  template <class Exception>
-  bool parse_error(std::size_t /*unused*/, const std::string & /*unused*/,
-                   const Exception &ex) {
-    errored = true;
-    static_cast<void>(ex);
-    if (allow_exceptions) {
-      JSON_THROW(ex);
-    }
-    return false;
-  }
-
-  constexpr bool is_errored() const { return errored; }
-
-private:
-  /*!
-  @param[in] v  value to add to the JSON value we build during parsing
-  @param[in] skip_callback  whether we should skip calling the callback
-             function; this is required after start_array() and
-             start_object() SAX events, because otherwise we would call the
-             callback function with an empty array or object, respectively.
-
-  @invariant If the ref stack is empty, then the passed value will be the new
-             root.
-  @invariant If the ref stack contains a value, then it is an array or an
-             object to which we can add elements
-
-  @return pair of boolean (whether value should be kept) and pointer (to the
-          passed value in the ref_stack hierarchy; nullptr if not kept)
-  */
-  template <typename Value>
-  std::pair<bool, BasicJsonType *>
-  handle_value(Value &&v, const bool skip_callback = false) {
-    JSON_ASSERT(!keep_stack.empty());
-
-    // do not handle this value if we know it would be added to a discarded
-    // container
-    if (!keep_stack.back()) {
-      return {false, nullptr};
-    }
-
-    // create value
-    auto value = BasicJsonType(std::forward<Value>(v));
-
-    // check callback
-    const bool keep =
-        skip_callback || callback(static_cast<int>(ref_stack.size()),
-                                  parse_event_t::value, value);
-
-    // do not handle this value if we just learnt it shall be discarded
-    if (!keep) {
-      return {false, nullptr};
-    }
-
-    if (ref_stack.empty()) {
-      root = std::move(value);
-      return {true, &root};
-    }
-
-    // skip this value if we already decided to skip the parent
-    // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
-    if (!ref_stack.back()) {
-      return {false, nullptr};
-    }
-
-    // we now only expect arrays and objects
-    JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
-
-    // array
-    if (ref_stack.back()->is_array()) {
-      ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
-      return {true, &(ref_stack.back()->m_data.m_value.array->back())};
-    }
-
-    // object
-    JSON_ASSERT(ref_stack.back()->is_object());
-    // check if we should store an element for the current key
-    JSON_ASSERT(!key_keep_stack.empty());
-    const bool store_element = key_keep_stack.back();
-    key_keep_stack.pop_back();
-
-    if (!store_element) {
-      return {false, nullptr};
-    }
-
-    JSON_ASSERT(object_element);
-    *object_element = std::move(value);
-    return {true, object_element};
-  }
-
-  /// the parsed JSON value
-  BasicJsonType &root;
-  /// stack to model hierarchy of values
-  std::vector<BasicJsonType *> ref_stack{};
-  /// stack to manage which values to keep
-  std::vector<bool> keep_stack{}; // NOLINT(readability-redundant-member-init)
-  /// stack to manage which object keys to keep
-  std::vector<bool>
-      key_keep_stack{}; // NOLINT(readability-redundant-member-init)
-  /// helper to hold the reference for the next object element
-  BasicJsonType *object_element = nullptr;
-  /// whether a syntax error occurred
-  bool errored = false;
-  /// callback function
-  const parser_callback_t callback = nullptr;
-  /// whether to throw exceptions in case of errors
-  const bool allow_exceptions = true;
-  /// a discarded value for the callback
-  BasicJsonType discarded = BasicJsonType::value_t::discarded;
-};
-
-template <typename BasicJsonType> class json_sax_acceptor {
-public:
-  using number_integer_t = typename BasicJsonType::number_integer_t;
-  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-  using number_float_t = typename BasicJsonType::number_float_t;
-  using string_t = typename BasicJsonType::string_t;
-  using binary_t = typename BasicJsonType::binary_t;
-
-  bool null() { return true; }
-
-  bool boolean(bool /*unused*/) { return true; }
-
-  bool number_integer(number_integer_t /*unused*/) { return true; }
-
-  bool number_unsigned(number_unsigned_t /*unused*/) { return true; }
-
-  bool number_float(number_float_t /*unused*/, const string_t & /*unused*/) {
-    return true;
-  }
-
-  bool string(string_t & /*unused*/) { return true; }
-
-  bool binary(binary_t & /*unused*/) { return true; }
-
-  bool start_object(std::size_t /*unused*/ = static_cast<std::size_t>(-1)) {
-    return true;
-  }
-
-  bool key(string_t & /*unused*/) { return true; }
-
-  bool end_object() { return true; }
-
-  bool start_array(std::size_t /*unused*/ = static_cast<std::size_t>(-1)) {
-    return true;
-  }
-
-  bool end_array() { return true; }
-
-  bool parse_error(std::size_t /*unused*/, const std::string & /*unused*/,
-                   const detail::exception & /*unused*/) {
-    return false;
-  }
-};
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/input/lexer.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <array>            // array
-#include <clocale>          // localeconv
-#include <cstddef>          // size_t
-#include <cstdio>           // snprintf
-#include <cstdlib>          // strtof, strtod, strtold, strtoll, strtoull
-#include <initializer_list> // initializer_list
-#include <string>           // char_traits, string
-#include <utility>          // move
-#include <vector>           // vector
-
-// #include <nlohmann/detail/input/input_adapters.hpp>
-
-// #include <nlohmann/detail/input/position_t.hpp>
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/meta/type_traits.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-///////////
-// lexer //
-///////////
-
-template <typename BasicJsonType> class lexer_base {
-public:
-  /// token types for the parser
-  enum class token_type {
-    uninitialized,  ///< indicating the scanner is uninitialized
-    literal_true,   ///< the `true` literal
-    literal_false,  ///< the `false` literal
-    literal_null,   ///< the `null` literal
-    value_string,   ///< a string -- use get_string() for actual value
-    value_unsigned, ///< an unsigned integer -- use get_number_unsigned() for
-                    ///< actual value
-    value_integer,  ///< a signed integer -- use get_number_integer() for actual
-                    ///< value
-    value_float,    ///< an floating point number -- use get_number_float() for
-                    ///< actual value
-    begin_array,    ///< the character for array begin `[`
-    begin_object,   ///< the character for object begin `{`
-    end_array,      ///< the character for array end `]`
-    end_object,     ///< the character for object end `}`
-    name_separator, ///< the name separator `:`
-    value_separator, ///< the value separator `,`
-    parse_error,     ///< indicating a parse error
-    end_of_input,    ///< indicating the end of the input buffer
-    literal_or_value ///< a literal or the begin of a value (only for
-                     ///< diagnostics)
-  };
-
-  /// return name of values of type token_type (only used for errors)
-  JSON_HEDLEY_RETURNS_NON_NULL
-  JSON_HEDLEY_CONST
-  static const char *token_type_name(const token_type t) noexcept {
-    switch (t) {
-    case token_type::uninitialized:
-      return "<uninitialized>";
-    case token_type::literal_true:
-      return "true literal";
-    case token_type::literal_false:
-      return "false literal";
-    case token_type::literal_null:
-      return "null literal";
-    case token_type::value_string:
-      return "string literal";
-    case token_type::value_unsigned:
-    case token_type::value_integer:
-    case token_type::value_float:
-      return "number literal";
-    case token_type::begin_array:
-      return "'['";
-    case token_type::begin_object:
-      return "'{'";
-    case token_type::end_array:
-      return "']'";
-    case token_type::end_object:
-      return "'}'";
-    case token_type::name_separator:
-      return "':'";
-    case token_type::value_separator:
-      return "','";
-    case token_type::parse_error:
-      return "<parse error>";
-    case token_type::end_of_input:
-      return "end of input";
-    case token_type::literal_or_value:
-      return "'[', '{', or a literal";
-    // LCOV_EXCL_START
-    default: // catch non-enum values
-      return "unknown token";
-      // LCOV_EXCL_STOP
-    }
-  }
-};
-/*!
-@brief lexical analysis
-
-This class organizes the lexical analysis during JSON deserialization.
-*/
-template <typename BasicJsonType, typename InputAdapterType>
-class lexer : public lexer_base<BasicJsonType> {
-  using number_integer_t = typename BasicJsonType::number_integer_t;
-  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-  using number_float_t = typename BasicJsonType::number_float_t;
-  using string_t = typename BasicJsonType::string_t;
-  using char_type = typename InputAdapterType::char_type;
-  using char_int_type = typename char_traits<char_type>::int_type;
-
-public:
-  using token_type = typename lexer_base<BasicJsonType>::token_type;
-
-  explicit lexer(InputAdapterType &&adapter,
-                 bool ignore_comments_ = false) noexcept
-      : ia(std::move(adapter)), ignore_comments(ignore_comments_),
-        decimal_point_char(static_cast<char_int_type>(get_decimal_point())) {}
-
-  // delete because of pointer members
-  lexer(const lexer &) = delete;
-  lexer(lexer &&) =
-      default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
-  lexer &operator=(lexer &) = delete;
-  lexer &operator=(lexer &&) =
-      default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
-  ~lexer() = default;
-
-private:
-  /////////////////////
-  // locales
-  /////////////////////
-
-  /// return the locale-dependent decimal point
-  JSON_HEDLEY_PURE
-  static char get_decimal_point() noexcept {
-    const auto *loc = localeconv();
-    JSON_ASSERT(loc != nullptr);
-    return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
-  }
-
-  /////////////////////
-  // scan functions
-  /////////////////////
-
-  /*!
-  @brief get codepoint from 4 hex characters following `\u`
-
-  For input "\u c1 c2 c3 c4" the codepoint is:
-    (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4
-  = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0)
-
-  Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f'
-  must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The
-  conversion is done by subtracting the offset (0x30, 0x37, and 0x57)
-  between the ASCII value of the character and the desired integer value.
-
-  @return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or
-          non-hex character)
-  */
-  int get_codepoint() {
-    // this function only makes sense after reading `\u`
-    JSON_ASSERT(current == 'u');
-    int codepoint = 0;
-
-    const auto factors = {12u, 8u, 4u, 0u};
-    for (const auto factor : factors) {
-      get();
-
-      if (current >= '0' && current <= '9') {
-        codepoint += static_cast<int>(
-            (static_cast<unsigned int>(current) - 0x30u) << factor);
-      } else if (current >= 'A' && current <= 'F') {
-        codepoint += static_cast<int>(
-            (static_cast<unsigned int>(current) - 0x37u) << factor);
-      } else if (current >= 'a' && current <= 'f') {
-        codepoint += static_cast<int>(
-            (static_cast<unsigned int>(current) - 0x57u) << factor);
-      } else {
-        return -1;
-      }
-    }
-
-    JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
-    return codepoint;
-  }
-
-  /*!
-  @brief check if the next byte(s) are inside a given range
-
-  Adds the current byte and, for each passed range, reads a new byte and
-  checks if it is inside the range. If a violation was detected, set up an
-  error message and return false. Otherwise, return true.
-
-  @param[in] ranges  list of integers; interpreted as list of pairs of
-                     inclusive lower and upper bound, respectively
-
-  @pre The passed list @a ranges must have 2, 4, or 6 elements; that is,
-       1, 2, or 3 pairs. This precondition is enforced by an assertion.
-
-  @return true if and only if no range violation was detected
-  */
-  bool next_byte_in_range(std::initializer_list<char_int_type> ranges) {
-    JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
-    add(current);
-
-    for (auto range = ranges.begin(); range != ranges.end(); ++range) {
-      get();
-      if (JSON_HEDLEY_LIKELY(
-              *range <= current &&
-              current <= *(++range))) // NOLINT(bugprone-inc-dec-in-conditions)
-      {
-        add(current);
-      } else {
-        error_message = "invalid string: ill-formed UTF-8 byte";
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  /*!
-  @brief scan a string literal
-
-  This function scans a string according to Sect. 7 of RFC 8259. While
-  scanning, bytes are escaped and copied into buffer token_buffer. Then the
-  function returns successfully, token_buffer is *not* null-terminated (as it
-  may contain \0 bytes), and token_buffer.size() is the number of bytes in the
-  string.
-
-  @return token_type::value_string if string could be successfully scanned,
-          token_type::parse_error otherwise
-
-  @note In case of errors, variable error_message contains a textual
-        description.
-  */
-  token_type scan_string() {
-    // reset token_buffer (ignore opening quote)
-    reset();
-
-    // we entered the function by reading an open quote
-    JSON_ASSERT(current == '\"');
-
-    while (true) {
-      // get next character
-      switch (get()) {
-      // end of file while parsing string
-      case char_traits<char_type>::eof(): {
-        error_message = "invalid string: missing closing quote";
-        return token_type::parse_error;
-      }
-
-      // closing quote
-      case '\"': {
-        return token_type::value_string;
-      }
-
-      // escapes
-      case '\\': {
-        switch (get()) {
-        // quotation mark
-        case '\"':
-          add('\"');
-          break;
-        // reverse solidus
-        case '\\':
-          add('\\');
-          break;
-        // solidus
-        case '/':
-          add('/');
-          break;
-        // backspace
-        case 'b':
-          add('\b');
-          break;
-        // form feed
-        case 'f':
-          add('\f');
-          break;
-        // line feed
-        case 'n':
-          add('\n');
-          break;
-        // carriage return
-        case 'r':
-          add('\r');
-          break;
-        // tab
-        case 't':
-          add('\t');
-          break;
-
-        // unicode escapes
-        case 'u': {
-          const int codepoint1 = get_codepoint();
-          int codepoint = codepoint1; // start with codepoint1
-
-          if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1)) {
-            error_message =
-                "invalid string: '\\u' must be followed by 4 hex digits";
-            return token_type::parse_error;
-          }
-
-          // check if code point is a high surrogate
-          if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF) {
-            // expect next \uxxxx entry
-            if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u')) {
-              const int codepoint2 = get_codepoint();
-
-              if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1)) {
-                error_message =
-                    "invalid string: '\\u' must be followed by 4 hex digits";
-                return token_type::parse_error;
-              }
-
-              // check if codepoint2 is a low surrogate
-              if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 &&
-                                     codepoint2 <= 0xDFFF)) {
-                // overwrite codepoint
-                codepoint = static_cast<int>(
-                    // high surrogate occupies the most significant 22 bits
-                    (static_cast<unsigned int>(codepoint1) << 10u)
-                    // low surrogate occupies the least significant 15 bits
-                    + static_cast<unsigned int>(codepoint2)
-                    // there is still the 0xD800, 0xDC00 and 0x10000 noise
-                    // in the result, so we have to subtract with:
-                    // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
-                    - 0x35FDC00u);
-              } else {
-                error_message = "invalid string: surrogate U+D800..U+DBFF must "
-                                "be followed by U+DC00..U+DFFF";
-                return token_type::parse_error;
-              }
-            } else {
-              error_message = "invalid string: surrogate U+D800..U+DBFF must "
-                              "be followed by U+DC00..U+DFFF";
-              return token_type::parse_error;
-            }
-          } else {
-            if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 &&
-                                     codepoint1 <= 0xDFFF)) {
-              error_message = "invalid string: surrogate U+DC00..U+DFFF must "
-                              "follow U+D800..U+DBFF";
-              return token_type::parse_error;
-            }
-          }
-
-          // result of the above calculation yields a proper codepoint
-          JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
-
-          // translate codepoint into bytes
-          if (codepoint < 0x80) {
-            // 1-byte characters: 0xxxxxxx (ASCII)
-            add(static_cast<char_int_type>(codepoint));
-          } else if (codepoint <= 0x7FF) {
-            // 2-byte characters: 110xxxxx 10xxxxxx
-            add(static_cast<char_int_type>(
-                0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
-            add(static_cast<char_int_type>(
-                0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
-          } else if (codepoint <= 0xFFFF) {
-            // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
-            add(static_cast<char_int_type>(
-                0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
-            add(static_cast<char_int_type>(
-                0x80u |
-                ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
-            add(static_cast<char_int_type>(
-                0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
-          } else {
-            // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
-            add(static_cast<char_int_type>(
-                0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
-            add(static_cast<char_int_type>(
-                0x80u |
-                ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
-            add(static_cast<char_int_type>(
-                0x80u |
-                ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
-            add(static_cast<char_int_type>(
-                0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
-          }
-
-          break;
-        }
-
-        // other characters after escape
-        default:
-          error_message = "invalid string: forbidden character after backslash";
-          return token_type::parse_error;
-        }
-
-        break;
-      }
-
-      // invalid control characters
-      case 0x00: {
-        error_message = "invalid string: control character U+0000 (NUL) must "
-                        "be escaped to \\u0000";
-        return token_type::parse_error;
-      }
-
-      case 0x01: {
-        error_message = "invalid string: control character U+0001 (SOH) must "
-                        "be escaped to \\u0001";
-        return token_type::parse_error;
-      }
-
-      case 0x02: {
-        error_message = "invalid string: control character U+0002 (STX) must "
-                        "be escaped to \\u0002";
-        return token_type::parse_error;
-      }
-
-      case 0x03: {
-        error_message = "invalid string: control character U+0003 (ETX) must "
-                        "be escaped to \\u0003";
-        return token_type::parse_error;
-      }
-
-      case 0x04: {
-        error_message = "invalid string: control character U+0004 (EOT) must "
-                        "be escaped to \\u0004";
-        return token_type::parse_error;
-      }
-
-      case 0x05: {
-        error_message = "invalid string: control character U+0005 (ENQ) must "
-                        "be escaped to \\u0005";
-        return token_type::parse_error;
-      }
-
-      case 0x06: {
-        error_message = "invalid string: control character U+0006 (ACK) must "
-                        "be escaped to \\u0006";
-        return token_type::parse_error;
-      }
-
-      case 0x07: {
-        error_message = "invalid string: control character U+0007 (BEL) must "
-                        "be escaped to \\u0007";
-        return token_type::parse_error;
-      }
-
-      case 0x08: {
-        error_message = "invalid string: control character U+0008 (BS) must be "
-                        "escaped to \\u0008 or \\b";
-        return token_type::parse_error;
-      }
-
-      case 0x09: {
-        error_message = "invalid string: control character U+0009 (HT) must be "
-                        "escaped to \\u0009 or \\t";
-        return token_type::parse_error;
-      }
-
-      case 0x0A: {
-        error_message = "invalid string: control character U+000A (LF) must be "
-                        "escaped to \\u000A or \\n";
-        return token_type::parse_error;
-      }
-
-      case 0x0B: {
-        error_message = "invalid string: control character U+000B (VT) must be "
-                        "escaped to \\u000B";
-        return token_type::parse_error;
-      }
-
-      case 0x0C: {
-        error_message = "invalid string: control character U+000C (FF) must be "
-                        "escaped to \\u000C or \\f";
-        return token_type::parse_error;
-      }
-
-      case 0x0D: {
-        error_message = "invalid string: control character U+000D (CR) must be "
-                        "escaped to \\u000D or \\r";
-        return token_type::parse_error;
-      }
-
-      case 0x0E: {
-        error_message = "invalid string: control character U+000E (SO) must be "
-                        "escaped to \\u000E";
-        return token_type::parse_error;
-      }
-
-      case 0x0F: {
-        error_message = "invalid string: control character U+000F (SI) must be "
-                        "escaped to \\u000F";
-        return token_type::parse_error;
-      }
-
-      case 0x10: {
-        error_message = "invalid string: control character U+0010 (DLE) must "
-                        "be escaped to \\u0010";
-        return token_type::parse_error;
-      }
-
-      case 0x11: {
-        error_message = "invalid string: control character U+0011 (DC1) must "
-                        "be escaped to \\u0011";
-        return token_type::parse_error;
-      }
-
-      case 0x12: {
-        error_message = "invalid string: control character U+0012 (DC2) must "
-                        "be escaped to \\u0012";
-        return token_type::parse_error;
-      }
-
-      case 0x13: {
-        error_message = "invalid string: control character U+0013 (DC3) must "
-                        "be escaped to \\u0013";
-        return token_type::parse_error;
-      }
-
-      case 0x14: {
-        error_message = "invalid string: control character U+0014 (DC4) must "
-                        "be escaped to \\u0014";
-        return token_type::parse_error;
-      }
-
-      case 0x15: {
-        error_message = "invalid string: control character U+0015 (NAK) must "
-                        "be escaped to \\u0015";
-        return token_type::parse_error;
-      }
-
-      case 0x16: {
-        error_message = "invalid string: control character U+0016 (SYN) must "
-                        "be escaped to \\u0016";
-        return token_type::parse_error;
-      }
-
-      case 0x17: {
-        error_message = "invalid string: control character U+0017 (ETB) must "
-                        "be escaped to \\u0017";
-        return token_type::parse_error;
-      }
-
-      case 0x18: {
-        error_message = "invalid string: control character U+0018 (CAN) must "
-                        "be escaped to \\u0018";
-        return token_type::parse_error;
-      }
-
-      case 0x19: {
-        error_message = "invalid string: control character U+0019 (EM) must be "
-                        "escaped to \\u0019";
-        return token_type::parse_error;
-      }
-
-      case 0x1A: {
-        error_message = "invalid string: control character U+001A (SUB) must "
-                        "be escaped to \\u001A";
-        return token_type::parse_error;
-      }
-
-      case 0x1B: {
-        error_message = "invalid string: control character U+001B (ESC) must "
-                        "be escaped to \\u001B";
-        return token_type::parse_error;
-      }
-
-      case 0x1C: {
-        error_message = "invalid string: control character U+001C (FS) must be "
-                        "escaped to \\u001C";
-        return token_type::parse_error;
-      }
-
-      case 0x1D: {
-        error_message = "invalid string: control character U+001D (GS) must be "
-                        "escaped to \\u001D";
-        return token_type::parse_error;
-      }
-
-      case 0x1E: {
-        error_message = "invalid string: control character U+001E (RS) must be "
-                        "escaped to \\u001E";
-        return token_type::parse_error;
-      }
-
-      case 0x1F: {
-        error_message = "invalid string: control character U+001F (US) must be "
-                        "escaped to \\u001F";
-        return token_type::parse_error;
-      }
-
-      // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
-      case 0x20:
-      case 0x21:
-      case 0x23:
-      case 0x24:
-      case 0x25:
-      case 0x26:
-      case 0x27:
-      case 0x28:
-      case 0x29:
-      case 0x2A:
-      case 0x2B:
-      case 0x2C:
-      case 0x2D:
-      case 0x2E:
-      case 0x2F:
-      case 0x30:
-      case 0x31:
-      case 0x32:
-      case 0x33:
-      case 0x34:
-      case 0x35:
-      case 0x36:
-      case 0x37:
-      case 0x38:
-      case 0x39:
-      case 0x3A:
-      case 0x3B:
-      case 0x3C:
-      case 0x3D:
-      case 0x3E:
-      case 0x3F:
-      case 0x40:
-      case 0x41:
-      case 0x42:
-      case 0x43:
-      case 0x44:
-      case 0x45:
-      case 0x46:
-      case 0x47:
-      case 0x48:
-      case 0x49:
-      case 0x4A:
-      case 0x4B:
-      case 0x4C:
-      case 0x4D:
-      case 0x4E:
-      case 0x4F:
-      case 0x50:
-      case 0x51:
-      case 0x52:
-      case 0x53:
-      case 0x54:
-      case 0x55:
-      case 0x56:
-      case 0x57:
-      case 0x58:
-      case 0x59:
-      case 0x5A:
-      case 0x5B:
-      case 0x5D:
-      case 0x5E:
-      case 0x5F:
-      case 0x60:
-      case 0x61:
-      case 0x62:
-      case 0x63:
-      case 0x64:
-      case 0x65:
-      case 0x66:
-      case 0x67:
-      case 0x68:
-      case 0x69:
-      case 0x6A:
-      case 0x6B:
-      case 0x6C:
-      case 0x6D:
-      case 0x6E:
-      case 0x6F:
-      case 0x70:
-      case 0x71:
-      case 0x72:
-      case 0x73:
-      case 0x74:
-      case 0x75:
-      case 0x76:
-      case 0x77:
-      case 0x78:
-      case 0x79:
-      case 0x7A:
-      case 0x7B:
-      case 0x7C:
-      case 0x7D:
-      case 0x7E:
-      case 0x7F: {
-        add(current);
-        break;
-      }
-
-      // U+0080..U+07FF: bytes C2..DF 80..BF
-      case 0xC2:
-      case 0xC3:
-      case 0xC4:
-      case 0xC5:
-      case 0xC6:
-      case 0xC7:
-      case 0xC8:
-      case 0xC9:
-      case 0xCA:
-      case 0xCB:
-      case 0xCC:
-      case 0xCD:
-      case 0xCE:
-      case 0xCF:
-      case 0xD0:
-      case 0xD1:
-      case 0xD2:
-      case 0xD3:
-      case 0xD4:
-      case 0xD5:
-      case 0xD6:
-      case 0xD7:
-      case 0xD8:
-      case 0xD9:
-      case 0xDA:
-      case 0xDB:
-      case 0xDC:
-      case 0xDD:
-      case 0xDE:
-      case 0xDF: {
-        if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF}))) {
-          return token_type::parse_error;
-        }
-        break;
-      }
-
-      // U+0800..U+0FFF: bytes E0 A0..BF 80..BF
-      case 0xE0: {
-        if (JSON_HEDLEY_UNLIKELY(
-                !(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF})))) {
-          return token_type::parse_error;
-        }
-        break;
-      }
-
-      // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
-      // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
-      case 0xE1:
-      case 0xE2:
-      case 0xE3:
-      case 0xE4:
-      case 0xE5:
-      case 0xE6:
-      case 0xE7:
-      case 0xE8:
-      case 0xE9:
-      case 0xEA:
-      case 0xEB:
-      case 0xEC:
-      case 0xEE:
-      case 0xEF: {
-        if (JSON_HEDLEY_UNLIKELY(
-                !(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF})))) {
-          return token_type::parse_error;
-        }
-        break;
-      }
-
-      // U+D000..U+D7FF: bytes ED 80..9F 80..BF
-      case 0xED: {
-        if (JSON_HEDLEY_UNLIKELY(
-                !(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF})))) {
-          return token_type::parse_error;
-        }
-        break;
-      }
-
-      // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
-      case 0xF0: {
-        if (JSON_HEDLEY_UNLIKELY(
-                !(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF})))) {
-          return token_type::parse_error;
-        }
-        break;
-      }
-
-      // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
-      case 0xF1:
-      case 0xF2:
-      case 0xF3: {
-        if (JSON_HEDLEY_UNLIKELY(
-                !(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF})))) {
-          return token_type::parse_error;
-        }
-        break;
-      }
-
-      // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
-      case 0xF4: {
-        if (JSON_HEDLEY_UNLIKELY(
-                !(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF})))) {
-          return token_type::parse_error;
-        }
-        break;
-      }
-
-      // remaining bytes (80..C1 and F5..FF) are ill-formed
-      default: {
-        error_message = "invalid string: ill-formed UTF-8 byte";
-        return token_type::parse_error;
-      }
-      }
-    }
-  }
-
-  /*!
-   * @brief scan a comment
-   * @return whether comment could be scanned successfully
-   */
-  bool scan_comment() {
-    switch (get()) {
-    // single-line comments skip input until a newline or EOF is read
-    case '/': {
-      while (true) {
-        switch (get()) {
-        case '\n':
-        case '\r':
-        case char_traits<char_type>::eof():
-        case '\0':
-          return true;
-
-        default:
-          break;
-        }
-      }
-    }
-
-    // multi-line comments skip input until */ is read
-    case '*': {
-      while (true) {
-        switch (get()) {
-        case char_traits<char_type>::eof():
-        case '\0': {
-          error_message = "invalid comment; missing closing '*/'";
-          return false;
-        }
-
-        case '*': {
-          switch (get()) {
-          case '/':
-            return true;
-
-          default: {
-            unget();
-            continue;
-          }
-          }
-        }
-
-        default:
-          continue;
-        }
-      }
-    }
-
-    // unexpected character after reading '/'
-    default: {
-      error_message = "invalid comment; expecting '/' or '*' after '/'";
-      return false;
-    }
-    }
-  }
-
-  JSON_HEDLEY_NON_NULL(2)
-  static void strtof(float &f, const char *str, char **endptr) noexcept {
-    f = std::strtof(str, endptr);
-  }
-
-  JSON_HEDLEY_NON_NULL(2)
-  static void strtof(double &f, const char *str, char **endptr) noexcept {
-    f = std::strtod(str, endptr);
-  }
-
-  JSON_HEDLEY_NON_NULL(2)
-  static void strtof(long double &f, const char *str, char **endptr) noexcept {
-    f = std::strtold(str, endptr);
-  }
-
-  /*!
-  @brief scan a number literal
-
-  This function scans a string according to Sect. 6 of RFC 8259.
-
-  The function is realized with a deterministic finite state machine derived
-  from the grammar described in RFC 8259. Starting in state "init", the
-  input is read and used to determined the next state. Only state "done"
-  accepts the number. State "error" is a trap state to model errors. In the
-  table below, "anything" means any character but the ones listed before.
-
-  state    | 0        | 1-9      | e E      | +       | -       | .        |
-  anything
-  ---------|----------|----------|----------|---------|---------|----------|-----------
-  init     | zero     | any1     | [error]  | [error] | minus   | [error]  |
-  [error] minus    | zero     | any1     | [error]  | [error] | [error] |
-  [error]  | [error] zero     | done     | done     | exponent | done    | done
-  | decimal1 | done any1     | any1     | any1     | exponent | done    | done
-  | decimal1 | done decimal1 | decimal2 | decimal2 | [error]  | [error] |
-  [error] | [error]  | [error] decimal2 | decimal2 | decimal2 | exponent | done
-  | done    | done     | done exponent | any2     | any2     | [error]  | sign
-  | sign    | [error]  | [error] sign     | any2     | any2     | [error]  |
-  [error] | [error] | [error]  | [error] any2     | any2     | any2     | done
-  | done    | done    | done     | done
-
-  The state machine is realized with one label per state (prefixed with
-  "scan_number_") and `goto` statements between them. The state machine
-  contains cycles, but any cycle can be left when EOF is read. Therefore,
-  the function is guaranteed to terminate.
-
-  During scanning, the read bytes are stored in token_buffer. This string is
-  then converted to a signed integer, an unsigned integer, or a
-  floating-point number.
-
-  @return token_type::value_unsigned, token_type::value_integer, or
-          token_type::value_float if number could be successfully scanned,
-          token_type::parse_error otherwise
-
-  @note The scanner is independent of the current locale. Internally, the
-        locale's decimal point is used instead of `.` to work with the
-        locale-dependent converters.
-  */
-  token_type
-  scan_number() // lgtm [cpp/use-of-goto] `goto` is used in this function to
-                // implement the number-parsing state machine described above.
-                // By design, any finite input will eventually reach the "done"
-                // state or return token_type::parse_error. In each intermediate
-                // state, 1 byte of the input is appended to the token_buffer
-                // vector, and only the already initialized variables
-                // token_buffer, number_type, and error_message are manipulated.
-  {
-    // reset token_buffer to store the number's bytes
-    reset();
-
-    // the type of the parsed number; initially set to unsigned; will be
-    // changed if minus sign, decimal point or exponent is read
-    token_type number_type = token_type::value_unsigned;
-
-    // state (init): we just found out we need to scan a number
-    switch (current) {
-    case '-': {
-      add(current);
-      goto scan_number_minus;
-    }
-
-    case '0': {
-      add(current);
-      goto scan_number_zero;
-    }
-
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9': {
-      add(current);
-      goto scan_number_any1;
-    }
-
-    // all other characters are rejected outside scan_number()
-    default:              // LCOV_EXCL_LINE
-      JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
-                          // LCOV_EXCL_LINE
-    }
-
-  scan_number_minus:
-    // state: we just parsed a leading minus sign
-    number_type = token_type::value_integer;
-    switch (get()) {
-    case '0': {
-      add(current);
-      goto scan_number_zero;
-    }
-
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9': {
-      add(current);
-      goto scan_number_any1;
-    }
-
-    default: {
-      error_message = "invalid number; expected digit after '-'";
-      return token_type::parse_error;
-    }
-    }
-
-  scan_number_zero:
-    // state: we just parse a zero (maybe with a leading minus sign)
-    switch (get()) {
-    case '.': {
-      add(decimal_point_char);
-      decimal_point_position = token_buffer.size() - 1;
-      goto scan_number_decimal1;
-    }
-
-    case 'e':
-    case 'E': {
-      add(current);
-      goto scan_number_exponent;
-    }
-
-    default:
-      goto scan_number_done;
-    }
-
-  scan_number_any1:
-    // state: we just parsed a number 0-9 (maybe with a leading minus sign)
-    switch (get()) {
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9': {
-      add(current);
-      goto scan_number_any1;
-    }
-
-    case '.': {
-      add(decimal_point_char);
-      decimal_point_position = token_buffer.size() - 1;
-      goto scan_number_decimal1;
-    }
-
-    case 'e':
-    case 'E': {
-      add(current);
-      goto scan_number_exponent;
-    }
-
-    default:
-      goto scan_number_done;
-    }
-
-  scan_number_decimal1:
-    // state: we just parsed a decimal point
-    number_type = token_type::value_float;
-    switch (get()) {
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9': {
-      add(current);
-      goto scan_number_decimal2;
-    }
-
-    default: {
-      error_message = "invalid number; expected digit after '.'";
-      return token_type::parse_error;
-    }
-    }
-
-  scan_number_decimal2:
-    // we just parsed at least one number after a decimal point
-    switch (get()) {
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9': {
-      add(current);
-      goto scan_number_decimal2;
-    }
-
-    case 'e':
-    case 'E': {
-      add(current);
-      goto scan_number_exponent;
-    }
-
-    default:
-      goto scan_number_done;
-    }
-
-  scan_number_exponent:
-    // we just parsed an exponent
-    number_type = token_type::value_float;
-    switch (get()) {
-    case '+':
-    case '-': {
-      add(current);
-      goto scan_number_sign;
-    }
-
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9': {
-      add(current);
-      goto scan_number_any2;
-    }
-
-    default: {
-      error_message =
-          "invalid number; expected '+', '-', or digit after exponent";
-      return token_type::parse_error;
-    }
-    }
-
-  scan_number_sign:
-    // we just parsed an exponent sign
-    switch (get()) {
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9': {
-      add(current);
-      goto scan_number_any2;
-    }
-
-    default: {
-      error_message = "invalid number; expected digit after exponent sign";
-      return token_type::parse_error;
-    }
-    }
-
-  scan_number_any2:
-    // we just parsed a number after the exponent or exponent sign
-    switch (get()) {
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9': {
-      add(current);
-      goto scan_number_any2;
-    }
-
-    default:
-      goto scan_number_done;
-    }
-
-  scan_number_done:
-    // unget the character after the number (we only read it to know that
-    // we are done scanning a number)
-    unget();
-
-    char *endptr =
-        nullptr; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
-    errno = 0;
-
-    // try to parse integers first and fall back to floats
-    if (number_type == token_type::value_unsigned) {
-      const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
-
-      // we checked the number format before
-      JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
-
-      if (errno != ERANGE) {
-        value_unsigned = static_cast<number_unsigned_t>(x);
-        if (value_unsigned == x) {
-          return token_type::value_unsigned;
-        }
-      }
-    } else if (number_type == token_type::value_integer) {
-      const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
-
-      // we checked the number format before
-      JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
-
-      if (errno != ERANGE) {
-        value_integer = static_cast<number_integer_t>(x);
-        if (value_integer == x) {
-          return token_type::value_integer;
-        }
-      }
-    }
-
-    // this code is reached if we parse a floating-point number or if an
-    // integer conversion above failed
-    strtof(value_float, token_buffer.data(), &endptr);
-
-    // we checked the number format before
-    JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
-
-    return token_type::value_float;
-  }
-
-  /*!
-  @param[in] literal_text  the literal text to expect
-  @param[in] length        the length of the passed literal text
-  @param[in] return_type   the token type to return on success
-  */
-  JSON_HEDLEY_NON_NULL(2)
-  token_type scan_literal(const char_type *literal_text,
-                          const std::size_t length, token_type return_type) {
-    JSON_ASSERT(char_traits<char_type>::to_char_type(current) ==
-                literal_text[0]);
-    for (std::size_t i = 1; i < length; ++i) {
-      if (JSON_HEDLEY_UNLIKELY(char_traits<char_type>::to_char_type(get()) !=
-                               literal_text[i])) {
-        error_message = "invalid literal";
-        return token_type::parse_error;
-      }
-    }
-    return return_type;
-  }
-
-  /////////////////////
-  // input management
-  /////////////////////
-
-  /// reset token_buffer; current character is beginning of token
-  void reset() noexcept {
-    token_buffer.clear();
-    token_string.clear();
-    decimal_point_position = std::string::npos;
-    token_string.push_back(char_traits<char_type>::to_char_type(current));
-  }
-
-  /*
-  @brief get next character from the input
-
-  This function provides the interface to the used input adapter. It does
-  not throw in case the input reached EOF, but returns a
-  `char_traits<char>::eof()` in that case.  Stores the scanned characters
-  for use in error messages.
-
-  @return character read from the input
-  */
-  char_int_type get() {
-    ++position.chars_read_total;
-    ++position.chars_read_current_line;
-
-    if (next_unget) {
-      // just reset the next_unget variable and work with current
-      next_unget = false;
-    } else {
-      current = ia.get_character();
-    }
-
-    if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof())) {
-      token_string.push_back(char_traits<char_type>::to_char_type(current));
-    }
-
-    if (current == '\n') {
-      ++position.lines_read;
-      position.chars_read_current_line = 0;
-    }
-
-    return current;
-  }
-
-  /*!
-  @brief unget current character (read it again on next get)
-
-  We implement unget by setting variable next_unget to true. The input is not
-  changed - we just simulate ungetting by modifying chars_read_total,
-  chars_read_current_line, and token_string. The next call to get() will
-  behave as if the unget character is read again.
-  */
-  void unget() {
-    next_unget = true;
-
-    --position.chars_read_total;
-
-    // in case we "unget" a newline, we have to also decrement the lines_read
-    if (position.chars_read_current_line == 0) {
-      if (position.lines_read > 0) {
-        --position.lines_read;
-      }
-    } else {
-      --position.chars_read_current_line;
-    }
-
-    if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof())) {
-      JSON_ASSERT(!token_string.empty());
-      token_string.pop_back();
-    }
-  }
-
-  /// add a character to token_buffer
-  void add(char_int_type c) {
-    token_buffer.push_back(static_cast<typename string_t::value_type>(c));
-  }
-
-public:
-  /////////////////////
-  // value getters
-  /////////////////////
-
-  /// return integer value
-  constexpr number_integer_t get_number_integer() const noexcept {
-    return value_integer;
-  }
-
-  /// return unsigned integer value
-  constexpr number_unsigned_t get_number_unsigned() const noexcept {
-    return value_unsigned;
-  }
-
-  /// return floating-point value
-  constexpr number_float_t get_number_float() const noexcept {
-    return value_float;
-  }
-
-  /// return current string value (implicitly resets the token; useful only
-  /// once)
-  string_t &get_string() {
-    // translate decimal points from locale back to '.' (#4084)
-    if (decimal_point_char != '.' &&
-        decimal_point_position != std::string::npos) {
-      token_buffer[decimal_point_position] = '.';
-    }
-    return token_buffer;
-  }
-
-  /////////////////////
-  // diagnostics
-  /////////////////////
-
-  /// return position of last read token
-  constexpr position_t get_position() const noexcept { return position; }
-
-  /// return the last read token (for errors only).  Will never contain EOF
-  /// (an arbitrary value that is not a valid char value, often -1), because
-  /// 255 may legitimately occur.  May contain NUL, which should be escaped.
-  std::string get_token_string() const {
-    // escape control characters
-    std::string result;
-    for (const auto c : token_string) {
-      if (static_cast<unsigned char>(c) <= '\x1F') {
-        // escape control characters
-        std::array<char, 9> cs{{}};
-        static_cast<void>((
-            std::
-                snprintf)(cs.data(), cs.size(), "<U+%.4X>",
-                          static_cast<unsigned char>(
-                              c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
-        result += cs.data();
-      } else {
-        // add character as is
-        result.push_back(static_cast<std::string::value_type>(c));
-      }
-    }
-
-    return result;
-  }
-
-  /// return syntax error message
-  JSON_HEDLEY_RETURNS_NON_NULL
-  constexpr const char *get_error_message() const noexcept {
-    return error_message;
-  }
-
-  /////////////////////
-  // actual scanner
-  /////////////////////
-
-  /*!
-  @brief skip the UTF-8 byte order mark
-  @return true iff there is no BOM or the correct BOM has been skipped
-  */
-  bool skip_bom() {
-    if (get() == 0xEF) {
-      // check if we completely parse the BOM
-      return get() == 0xBB && get() == 0xBF;
-    }
-
-    // the first character is not the beginning of the BOM; unget it to
-    // process is later
-    unget();
-    return true;
-  }
-
-  void skip_whitespace() {
-    do {
-      get();
-    } while (current == ' ' || current == '\t' || current == '\n' ||
-             current == '\r');
-  }
-
-  token_type scan() {
-    // initially, skip the BOM
-    if (position.chars_read_total == 0 && !skip_bom()) {
-      error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
-      return token_type::parse_error;
-    }
-
-    // read next character and ignore whitespace
-    skip_whitespace();
-
-    // ignore comments
-    while (ignore_comments && current == '/') {
-      if (!scan_comment()) {
-        return token_type::parse_error;
-      }
-
-      // skip following whitespace
-      skip_whitespace();
-    }
-
-    switch (current) {
-    // structural characters
-    case '[':
-      return token_type::begin_array;
-    case ']':
-      return token_type::end_array;
-    case '{':
-      return token_type::begin_object;
-    case '}':
-      return token_type::end_object;
-    case ':':
-      return token_type::name_separator;
-    case ',':
-      return token_type::value_separator;
-
-    // literals
-    case 't': {
-      std::array<char_type, 4> true_literal = {
-          {static_cast<char_type>('t'), static_cast<char_type>('r'),
-           static_cast<char_type>('u'), static_cast<char_type>('e')}};
-      return scan_literal(true_literal.data(), true_literal.size(),
-                          token_type::literal_true);
-    }
-    case 'f': {
-      std::array<char_type, 5> false_literal = {
-          {static_cast<char_type>('f'), static_cast<char_type>('a'),
-           static_cast<char_type>('l'), static_cast<char_type>('s'),
-           static_cast<char_type>('e')}};
-      return scan_literal(false_literal.data(), false_literal.size(),
-                          token_type::literal_false);
-    }
-    case 'n': {
-      std::array<char_type, 4> null_literal = {
-          {static_cast<char_type>('n'), static_cast<char_type>('u'),
-           static_cast<char_type>('l'), static_cast<char_type>('l')}};
-      return scan_literal(null_literal.data(), null_literal.size(),
-                          token_type::literal_null);
-    }
-
-    // string
-    case '\"':
-      return scan_string();
-
-    // number
-    case '-':
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9':
-      return scan_number();
-
-    // end of input (the null byte is needed when parsing from
-    // string literals)
-    case '\0':
-    case char_traits<char_type>::eof():
-      return token_type::end_of_input;
-
-    // error
-    default:
-      error_message = "invalid literal";
-      return token_type::parse_error;
-    }
-  }
-
-private:
-  /// input adapter
-  InputAdapterType ia;
-
-  /// whether comments should be ignored (true) or signaled as errors (false)
-  const bool ignore_comments = false;
-
-  /// the current character
-  char_int_type current = char_traits<char_type>::eof();
-
-  /// whether the next get() call should just return current
-  bool next_unget = false;
-
-  /// the start position of the current token
-  position_t position{};
-
-  /// raw input token string (for error messages)
-  std::vector<char_type> token_string{};
-
-  /// buffer for variable-length tokens (numbers, strings)
-  string_t token_buffer{};
-
-  /// a description of occurred lexer errors
-  const char *error_message = "";
-
-  // number values
-  number_integer_t value_integer = 0;
-  number_unsigned_t value_unsigned = 0;
-  number_float_t value_float = 0;
-
-  /// the decimal point
-  const char_int_type decimal_point_char = '.';
-  /// the position of the decimal point in the input
-  std::size_t decimal_point_position = std::string::npos;
-};
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/meta/is_sax.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <cstdint> // size_t
-#include <string>  // string
-#include <utility> // declval
-
-// #include <nlohmann/detail/abi_macros.hpp>
-
-// #include <nlohmann/detail/meta/detected.hpp>
-
-// #include <nlohmann/detail/meta/type_traits.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-template <typename T>
-using null_function_t = decltype(std::declval<T &>().null());
-
-template <typename T>
-using boolean_function_t =
-    decltype(std::declval<T &>().boolean(std::declval<bool>()));
-
-template <typename T, typename Integer>
-using number_integer_function_t =
-    decltype(std::declval<T &>().number_integer(std::declval<Integer>()));
-
-template <typename T, typename Unsigned>
-using number_unsigned_function_t =
-    decltype(std::declval<T &>().number_unsigned(std::declval<Unsigned>()));
-
-template <typename T, typename Float, typename String>
-using number_float_function_t = decltype(std::declval<T &>().number_float(
-    std::declval<Float>(), std::declval<const String &>()));
-
-template <typename T, typename String>
-using string_function_t =
-    decltype(std::declval<T &>().string(std::declval<String &>()));
-
-template <typename T, typename Binary>
-using binary_function_t =
-    decltype(std::declval<T &>().binary(std::declval<Binary &>()));
-
-template <typename T>
-using start_object_function_t =
-    decltype(std::declval<T &>().start_object(std::declval<std::size_t>()));
-
-template <typename T, typename String>
-using key_function_t =
-    decltype(std::declval<T &>().key(std::declval<String &>()));
-
-template <typename T>
-using end_object_function_t = decltype(std::declval<T &>().end_object());
-
-template <typename T>
-using start_array_function_t =
-    decltype(std::declval<T &>().start_array(std::declval<std::size_t>()));
-
-template <typename T>
-using end_array_function_t = decltype(std::declval<T &>().end_array());
-
-template <typename T, typename Exception>
-using parse_error_function_t = decltype(std::declval<T &>().parse_error(
-    std::declval<std::size_t>(), std::declval<const std::string &>(),
-    std::declval<const Exception &>()));
-
-template <typename SAX, typename BasicJsonType> struct is_sax {
-private:
-  static_assert(is_basic_json<BasicJsonType>::value,
-                "BasicJsonType must be of type basic_json<...>");
-
-  using number_integer_t = typename BasicJsonType::number_integer_t;
-  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-  using number_float_t = typename BasicJsonType::number_float_t;
-  using string_t = typename BasicJsonType::string_t;
-  using binary_t = typename BasicJsonType::binary_t;
-  using exception_t = typename BasicJsonType::exception;
-
-public:
-  static constexpr bool value =
-      is_detected_exact<bool, null_function_t, SAX>::value &&
-      is_detected_exact<bool, boolean_function_t, SAX>::value &&
-      is_detected_exact<bool, number_integer_function_t, SAX,
-                        number_integer_t>::value &&
-      is_detected_exact<bool, number_unsigned_function_t, SAX,
-                        number_unsigned_t>::value &&
-      is_detected_exact<bool, number_float_function_t, SAX, number_float_t,
-                        string_t>::value &&
-      is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
-      is_detected_exact<bool, binary_function_t, SAX, binary_t>::value &&
-      is_detected_exact<bool, start_object_function_t, SAX>::value &&
-      is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
-      is_detected_exact<bool, end_object_function_t, SAX>::value &&
-      is_detected_exact<bool, start_array_function_t, SAX>::value &&
-      is_detected_exact<bool, end_array_function_t, SAX>::value &&
-      is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
-};
-
-template <typename SAX, typename BasicJsonType> struct is_sax_static_asserts {
-private:
-  static_assert(is_basic_json<BasicJsonType>::value,
-                "BasicJsonType must be of type basic_json<...>");
-
-  using number_integer_t = typename BasicJsonType::number_integer_t;
-  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-  using number_float_t = typename BasicJsonType::number_float_t;
-  using string_t = typename BasicJsonType::string_t;
-  using binary_t = typename BasicJsonType::binary_t;
-  using exception_t = typename BasicJsonType::exception;
-
-public:
-  static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
-                "Missing/invalid function: bool null()");
-  static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
-                "Missing/invalid function: bool boolean(bool)");
-  static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
-                "Missing/invalid function: bool boolean(bool)");
-  static_assert(
-      is_detected_exact<bool, number_integer_function_t, SAX,
-                        number_integer_t>::value,
-      "Missing/invalid function: bool number_integer(number_integer_t)");
-  static_assert(
-      is_detected_exact<bool, number_unsigned_function_t, SAX,
-                        number_unsigned_t>::value,
-      "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
-  static_assert(is_detected_exact<bool, number_float_function_t, SAX,
-                                  number_float_t, string_t>::value,
-                "Missing/invalid function: bool number_float(number_float_t, "
-                "const string_t&)");
-  static_assert(
-      is_detected_exact<bool, string_function_t, SAX, string_t>::value,
-      "Missing/invalid function: bool string(string_t&)");
-  static_assert(
-      is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,
-      "Missing/invalid function: bool binary(binary_t&)");
-  static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
-                "Missing/invalid function: bool start_object(std::size_t)");
-  static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
-                "Missing/invalid function: bool key(string_t&)");
-  static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
-                "Missing/invalid function: bool end_object()");
-  static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
-                "Missing/invalid function: bool start_array(std::size_t)");
-  static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
-                "Missing/invalid function: bool end_array()");
-  static_assert(
-      is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
-      "Missing/invalid function: bool parse_error(std::size_t, const "
-      "std::string&, const exception&)");
-};
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/meta/type_traits.hpp>
-
-// #include <nlohmann/detail/string_concat.hpp>
-
-// #include <nlohmann/detail/value_t.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-/// how to treat CBOR tags
-enum class cbor_tag_handler_t {
-  error,  ///< throw a parse_error exception in case of a tag
-  ignore, ///< ignore tags
-  store   ///< store tags as binary type
-};
-
-/*!
-@brief determine system byte order
-
-@return true if and only if system's byte order is little endian
-
-@note from https://stackoverflow.com/a/1001328/266378
-*/
-static inline bool little_endianness(int num = 1) noexcept {
-  return *reinterpret_cast<char *>(&num) == 1;
-}
-
-///////////////////
-// binary reader //
-///////////////////
-
-/*!
-@brief deserialization of CBOR, MessagePack, and UBJSON values
-*/
-template <typename BasicJsonType, typename InputAdapterType,
-          typename SAX = json_sax_dom_parser<BasicJsonType>>
-class binary_reader {
-  using number_integer_t = typename BasicJsonType::number_integer_t;
-  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-  using number_float_t = typename BasicJsonType::number_float_t;
-  using string_t = typename BasicJsonType::string_t;
-  using binary_t = typename BasicJsonType::binary_t;
-  using json_sax_t = SAX;
-  using char_type = typename InputAdapterType::char_type;
-  using char_int_type = typename char_traits<char_type>::int_type;
-
-public:
-  /*!
-  @brief create a binary reader
-
-  @param[in] adapter  input adapter to read from
-  */
-  explicit binary_reader(
-      InputAdapterType &&adapter,
-      const input_format_t format = input_format_t::json) noexcept
-      : ia(std::move(adapter)), input_format(format) {
-    (void)detail::is_sax_static_asserts<SAX, BasicJsonType>{};
-  }
-
-  // make class move-only
-  binary_reader(const binary_reader &) = delete;
-  binary_reader(binary_reader &&) =
-      default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
-  binary_reader &operator=(const binary_reader &) = delete;
-  binary_reader &operator=(binary_reader &&) =
-      default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
-  ~binary_reader() = default;
-
-  /*!
-  @param[in] format  the binary format to parse
-  @param[in] sax_    a SAX event processor
-  @param[in] strict  whether to expect the input to be consumed completed
-  @param[in] tag_handler  how to treat CBOR tags
-
-  @return whether parsing was successful
-  */
-  JSON_HEDLEY_NON_NULL(3)
-  bool
-  sax_parse(const input_format_t format, json_sax_t *sax_,
-            const bool strict = true,
-            const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error) {
-    sax = sax_;
-    bool result = false;
-
-    switch (format) {
-    case input_format_t::bson:
-      result = parse_bson_internal();
-      break;
-
-    case input_format_t::cbor:
-      result = parse_cbor_internal(true, tag_handler);
-      break;
-
-    case input_format_t::msgpack:
-      result = parse_msgpack_internal();
-      break;
-
-    case input_format_t::ubjson:
-    case input_format_t::bjdata:
-      result = parse_ubjson_internal();
-      break;
-
-    case input_format_t::json: // LCOV_EXCL_LINE
-    default:                   // LCOV_EXCL_LINE
-      JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
-                          // LCOV_EXCL_LINE
-    }
-
-    // strict mode: next byte must be EOF
-    if (result && strict) {
-      if (input_format == input_format_t::ubjson ||
-          input_format == input_format_t::bjdata) {
-        get_ignore_noop();
-      } else {
-        get();
-      }
-
-      if (JSON_HEDLEY_UNLIKELY(current != char_traits<char_type>::eof())) {
-        return sax->parse_error(
-            chars_read, get_token_string(),
-            parse_error::create(
-                110, chars_read,
-                exception_message(input_format,
-                                  concat("expected end of input; last byte: 0x",
-                                         get_token_string()),
-                                  "value"),
-                nullptr));
-      }
-    }
-
-    return result;
-  }
-
-private:
-  //////////
-  // BSON //
-  //////////
-
-  /*!
-  @brief Reads in a BSON-object and passes it to the SAX-parser.
-  @return whether a valid BSON-value was passed to the SAX parser
-  */
-  bool parse_bson_internal() {
-    std::int32_t document_size{};
-    get_number<std::int32_t, true>(input_format_t::bson, document_size);
-
-    if (JSON_HEDLEY_UNLIKELY(
-            !sax->start_object(static_cast<std::size_t>(-1)))) {
-      return false;
-    }
-
-    if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/ false))) {
-      return false;
-    }
-
-    return sax->end_object();
-  }
-
-  /*!
-  @brief Parses a C-style string from the BSON input.
-  @param[in,out] result  A reference to the string variable where the read
-                          string is to be stored.
-  @return `true` if the \x00-byte indicating the end of the string was
-           encountered before the EOF; false` indicates an unexpected EOF.
-  */
-  bool get_bson_cstr(string_t &result) {
-    auto out = std::back_inserter(result);
-    while (true) {
-      get();
-      if (JSON_HEDLEY_UNLIKELY(
-              !unexpect_eof(input_format_t::bson, "cstring"))) {
-        return false;
-      }
-      if (current == 0x00) {
-        return true;
-      }
-      *out++ = static_cast<typename string_t::value_type>(current);
-    }
-  }
-
-  /*!
-  @brief Parses a zero-terminated string of length @a len from the BSON
-         input.
-  @param[in] len  The length (including the zero-byte at the end) of the
-                  string to be read.
-  @param[in,out] result  A reference to the string variable where the read
-                          string is to be stored.
-  @tparam NumberType The type of the length @a len
-  @pre len >= 1
-  @return `true` if the string was successfully parsed
-  */
-  template <typename NumberType>
-  bool get_bson_string(const NumberType len, string_t &result) {
-    if (JSON_HEDLEY_UNLIKELY(len < 1)) {
-      auto last_token = get_token_string();
-      return sax->parse_error(
-          chars_read, last_token,
-          parse_error::create(
-              112, chars_read,
-              exception_message(input_format_t::bson,
-                                concat("string length must be at least 1, is ",
-                                       std::to_string(len)),
-                                "string"),
-              nullptr));
-    }
-
-    return get_string(input_format_t::bson, len - static_cast<NumberType>(1),
-                      result) &&
-           get() != char_traits<char_type>::eof();
-  }
-
-  /*!
-  @brief Parses a byte array input of length @a len from the BSON input.
-  @param[in] len  The length of the byte array to be read.
-  @param[in,out] result  A reference to the binary variable where the read
-                          array is to be stored.
-  @tparam NumberType The type of the length @a len
-  @pre len >= 0
-  @return `true` if the byte array was successfully parsed
-  */
-  template <typename NumberType>
-  bool get_bson_binary(const NumberType len, binary_t &result) {
-    if (JSON_HEDLEY_UNLIKELY(len < 0)) {
-      auto last_token = get_token_string();
-      return sax->parse_error(
-          chars_read, last_token,
-          parse_error::create(
-              112, chars_read,
-              exception_message(
-                  input_format_t::bson,
-                  concat("byte array length cannot be negative, is ",
-                         std::to_string(len)),
-                  "binary"),
-              nullptr));
-    }
-
-    // All BSON binary values have a subtype
-    std::uint8_t subtype{};
-    get_number<std::uint8_t>(input_format_t::bson, subtype);
-    result.set_subtype(subtype);
-
-    return get_binary(input_format_t::bson, len, result);
-  }
-
-  /*!
-  @brief Read a BSON document element of the given @a element_type.
-  @param[in] element_type The BSON element type, c.f.
-  http://bsonspec.org/spec.html
-  @param[in] element_type_parse_position The position in the input stream,
-             where the `element_type` was read.
-  @warning Not all BSON element types are supported yet. An unsupported
-           @a element_type will give rise to a parse_error.114:
-           Unsupported BSON record type 0x...
-  @return whether a valid BSON-object/array was passed to the SAX parser
-  */
-  bool
-  parse_bson_element_internal(const char_int_type element_type,
-                              const std::size_t element_type_parse_position) {
-    switch (element_type) {
-    case 0x01: // double
-    {
-      double number{};
-      return get_number<double, true>(input_format_t::bson, number) &&
-             sax->number_float(static_cast<number_float_t>(number), "");
-    }
-
-    case 0x02: // string
-    {
-      std::int32_t len{};
-      string_t value;
-      return get_number<std::int32_t, true>(input_format_t::bson, len) &&
-             get_bson_string(len, value) && sax->string(value);
-    }
-
-    case 0x03: // object
-    {
-      return parse_bson_internal();
-    }
-
-    case 0x04: // array
-    {
-      return parse_bson_array();
-    }
-
-    case 0x05: // binary
-    {
-      std::int32_t len{};
-      binary_t value;
-      return get_number<std::int32_t, true>(input_format_t::bson, len) &&
-             get_bson_binary(len, value) && sax->binary(value);
-    }
-
-    case 0x08: // boolean
-    {
-      return sax->boolean(get() != 0);
-    }
-
-    case 0x0A: // null
-    {
-      return sax->null();
-    }
-
-    case 0x10: // int32
-    {
-      std::int32_t value{};
-      return get_number<std::int32_t, true>(input_format_t::bson, value) &&
-             sax->number_integer(value);
-    }
-
-    case 0x12: // int64
-    {
-      std::int64_t value{};
-      return get_number<std::int64_t, true>(input_format_t::bson, value) &&
-             sax->number_integer(value);
-    }
-
-    default: // anything else not supported (yet)
-    {
-      std::array<char, 3> cr{{}};
-      static_cast<void>((
-          std::
-              snprintf)(cr.data(), cr.size(), "%.2hhX",
-                        static_cast<unsigned char>(
-                            element_type))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
-      const std::string cr_str{cr.data()};
-      return sax->parse_error(
-          element_type_parse_position, cr_str,
-          parse_error::create(114, element_type_parse_position,
-                              concat("Unsupported BSON record type 0x", cr_str),
-                              nullptr));
-    }
-    }
-  }
-
-  /*!
-  @brief Read a BSON element list (as specified in the BSON-spec)
-
-  The same binary layout is used for objects and arrays, hence it must be
-  indicated with the argument @a is_array which one is expected
-  (true --> array, false --> object).
-
-  @param[in] is_array Determines if the element list being read is to be
-                      treated as an object (@a is_array == false), or as an
-                      array (@a is_array == true).
-  @return whether a valid BSON-object/array was passed to the SAX parser
-  */
-  bool parse_bson_element_list(const bool is_array) {
-    string_t key;
-
-    while (auto element_type = get()) {
-      if (JSON_HEDLEY_UNLIKELY(
-              !unexpect_eof(input_format_t::bson, "element list"))) {
-        return false;
-      }
-
-      const std::size_t element_type_parse_position = chars_read;
-      if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key))) {
-        return false;
-      }
-
-      if (!is_array && !sax->key(key)) {
-        return false;
-      }
-
-      if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(
-              element_type, element_type_parse_position))) {
-        return false;
-      }
-
-      // get_bson_cstr only appends
-      key.clear();
-    }
-
-    return true;
-  }
-
-  /*!
-  @brief Reads an array from the BSON input and passes it to the SAX-parser.
-  @return whether a valid BSON-array was passed to the SAX parser
-  */
-  bool parse_bson_array() {
-    std::int32_t document_size{};
-    get_number<std::int32_t, true>(input_format_t::bson, document_size);
-
-    if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1)))) {
-      return false;
-    }
-
-    if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/ true))) {
-      return false;
-    }
-
-    return sax->end_array();
-  }
-
-  //////////
-  // CBOR //
-  //////////
-
-  /*!
-  @param[in] get_char  whether a new character should be retrieved from the
-                       input (true) or whether the last read character should
-                       be considered instead (false)
-  @param[in] tag_handler how CBOR tags should be treated
-
-  @return whether a valid CBOR value was passed to the SAX parser
-  */
-  bool parse_cbor_internal(const bool get_char,
-                           const cbor_tag_handler_t tag_handler) {
-    switch (get_char ? get() : current) {
-    // EOF
-    case char_traits<char_type>::eof():
-      return unexpect_eof(input_format_t::cbor, "value");
-
-    // Integer 0x00..0x17 (0..23)
-    case 0x00:
-    case 0x01:
-    case 0x02:
-    case 0x03:
-    case 0x04:
-    case 0x05:
-    case 0x06:
-    case 0x07:
-    case 0x08:
-    case 0x09:
-    case 0x0A:
-    case 0x0B:
-    case 0x0C:
-    case 0x0D:
-    case 0x0E:
-    case 0x0F:
-    case 0x10:
-    case 0x11:
-    case 0x12:
-    case 0x13:
-    case 0x14:
-    case 0x15:
-    case 0x16:
-    case 0x17:
-      return sax->number_unsigned(static_cast<number_unsigned_t>(current));
-
-    case 0x18: // Unsigned integer (one-byte uint8_t follows)
-    {
-      std::uint8_t number{};
-      return get_number(input_format_t::cbor, number) &&
-             sax->number_unsigned(number);
-    }
-
-    case 0x19: // Unsigned integer (two-byte uint16_t follows)
-    {
-      std::uint16_t number{};
-      return get_number(input_format_t::cbor, number) &&
-             sax->number_unsigned(number);
-    }
-
-    case 0x1A: // Unsigned integer (four-byte uint32_t follows)
-    {
-      std::uint32_t number{};
-      return get_number(input_format_t::cbor, number) &&
-             sax->number_unsigned(number);
-    }
-
-    case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
-    {
-      std::uint64_t number{};
-      return get_number(input_format_t::cbor, number) &&
-             sax->number_unsigned(number);
-    }
-
-    // Negative integer -1-0x00..-1-0x17 (-1..-24)
-    case 0x20:
-    case 0x21:
-    case 0x22:
-    case 0x23:
-    case 0x24:
-    case 0x25:
-    case 0x26:
-    case 0x27:
-    case 0x28:
-    case 0x29:
-    case 0x2A:
-    case 0x2B:
-    case 0x2C:
-    case 0x2D:
-    case 0x2E:
-    case 0x2F:
-    case 0x30:
-    case 0x31:
-    case 0x32:
-    case 0x33:
-    case 0x34:
-    case 0x35:
-    case 0x36:
-    case 0x37:
-      return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));
-
-    case 0x38: // Negative integer (one-byte uint8_t follows)
-    {
-      std::uint8_t number{};
-      return get_number(input_format_t::cbor, number) &&
-             sax->number_integer(static_cast<number_integer_t>(-1) - number);
-    }
-
-    case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
-    {
-      std::uint16_t number{};
-      return get_number(input_format_t::cbor, number) &&
-             sax->number_integer(static_cast<number_integer_t>(-1) - number);
-    }
-
-    case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
-    {
-      std::uint32_t number{};
-      return get_number(input_format_t::cbor, number) &&
-             sax->number_integer(static_cast<number_integer_t>(-1) - number);
-    }
-
-    case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
-    {
-      std::uint64_t number{};
-      return get_number(input_format_t::cbor, number) &&
-             sax->number_integer(static_cast<number_integer_t>(-1) -
-                                 static_cast<number_integer_t>(number));
-    }
-
-    // Binary data (0x00..0x17 bytes follow)
-    case 0x40:
-    case 0x41:
-    case 0x42:
-    case 0x43:
-    case 0x44:
-    case 0x45:
-    case 0x46:
-    case 0x47:
-    case 0x48:
-    case 0x49:
-    case 0x4A:
-    case 0x4B:
-    case 0x4C:
-    case 0x4D:
-    case 0x4E:
-    case 0x4F:
-    case 0x50:
-    case 0x51:
-    case 0x52:
-    case 0x53:
-    case 0x54:
-    case 0x55:
-    case 0x56:
-    case 0x57:
-    case 0x58: // Binary data (one-byte uint8_t for n follows)
-    case 0x59: // Binary data (two-byte uint16_t for n follow)
-    case 0x5A: // Binary data (four-byte uint32_t for n follow)
-    case 0x5B: // Binary data (eight-byte uint64_t for n follow)
-    case 0x5F: // Binary data (indefinite length)
-    {
-      binary_t b;
-      return get_cbor_binary(b) && sax->binary(b);
-    }
-
-    // UTF-8 string (0x00..0x17 bytes follow)
-    case 0x60:
-    case 0x61:
-    case 0x62:
-    case 0x63:
-    case 0x64:
-    case 0x65:
-    case 0x66:
-    case 0x67:
-    case 0x68:
-    case 0x69:
-    case 0x6A:
-    case 0x6B:
-    case 0x6C:
-    case 0x6D:
-    case 0x6E:
-    case 0x6F:
-    case 0x70:
-    case 0x71:
-    case 0x72:
-    case 0x73:
-    case 0x74:
-    case 0x75:
-    case 0x76:
-    case 0x77:
-    case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
-    case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
-    case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
-    case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
-    case 0x7F: // UTF-8 string (indefinite length)
-    {
-      string_t s;
-      return get_cbor_string(s) && sax->string(s);
-    }
-
-    // array (0x00..0x17 data items follow)
-    case 0x80:
-    case 0x81:
-    case 0x82:
-    case 0x83:
-    case 0x84:
-    case 0x85:
-    case 0x86:
-    case 0x87:
-    case 0x88:
-    case 0x89:
-    case 0x8A:
-    case 0x8B:
-    case 0x8C:
-    case 0x8D:
-    case 0x8E:
-    case 0x8F:
-    case 0x90:
-    case 0x91:
-    case 0x92:
-    case 0x93:
-    case 0x94:
-    case 0x95:
-    case 0x96:
-    case 0x97:
-      return get_cbor_array(conditional_static_cast<std::size_t>(
-                                static_cast<unsigned int>(current) & 0x1Fu),
-                            tag_handler);
-
-    case 0x98: // array (one-byte uint8_t for n follows)
-    {
-      std::uint8_t len{};
-      return get_number(input_format_t::cbor, len) &&
-             get_cbor_array(static_cast<std::size_t>(len), tag_handler);
-    }
-
-    case 0x99: // array (two-byte uint16_t for n follow)
-    {
-      std::uint16_t len{};
-      return get_number(input_format_t::cbor, len) &&
-             get_cbor_array(static_cast<std::size_t>(len), tag_handler);
-    }
-
-    case 0x9A: // array (four-byte uint32_t for n follow)
-    {
-      std::uint32_t len{};
-      return get_number(input_format_t::cbor, len) &&
-             get_cbor_array(conditional_static_cast<std::size_t>(len),
-                            tag_handler);
-    }
-
-    case 0x9B: // array (eight-byte uint64_t for n follow)
-    {
-      std::uint64_t len{};
-      return get_number(input_format_t::cbor, len) &&
-             get_cbor_array(conditional_static_cast<std::size_t>(len),
-                            tag_handler);
-    }
-
-    case 0x9F: // array (indefinite length)
-      return get_cbor_array(static_cast<std::size_t>(-1), tag_handler);
-
-    // map (0x00..0x17 pairs of data items follow)
-    case 0xA0:
-    case 0xA1:
-    case 0xA2:
-    case 0xA3:
-    case 0xA4:
-    case 0xA5:
-    case 0xA6:
-    case 0xA7:
-    case 0xA8:
-    case 0xA9:
-    case 0xAA:
-    case 0xAB:
-    case 0xAC:
-    case 0xAD:
-    case 0xAE:
-    case 0xAF:
-    case 0xB0:
-    case 0xB1:
-    case 0xB2:
-    case 0xB3:
-    case 0xB4:
-    case 0xB5:
-    case 0xB6:
-    case 0xB7:
-      return get_cbor_object(conditional_static_cast<std::size_t>(
-                                 static_cast<unsigned int>(current) & 0x1Fu),
-                             tag_handler);
-
-    case 0xB8: // map (one-byte uint8_t for n follows)
-    {
-      std::uint8_t len{};
-      return get_number(input_format_t::cbor, len) &&
-             get_cbor_object(static_cast<std::size_t>(len), tag_handler);
-    }
-
-    case 0xB9: // map (two-byte uint16_t for n follow)
-    {
-      std::uint16_t len{};
-      return get_number(input_format_t::cbor, len) &&
-             get_cbor_object(static_cast<std::size_t>(len), tag_handler);
-    }
-
-    case 0xBA: // map (four-byte uint32_t for n follow)
-    {
-      std::uint32_t len{};
-      return get_number(input_format_t::cbor, len) &&
-             get_cbor_object(conditional_static_cast<std::size_t>(len),
-                             tag_handler);
-    }
-
-    case 0xBB: // map (eight-byte uint64_t for n follow)
-    {
-      std::uint64_t len{};
-      return get_number(input_format_t::cbor, len) &&
-             get_cbor_object(conditional_static_cast<std::size_t>(len),
-                             tag_handler);
-    }
-
-    case 0xBF: // map (indefinite length)
-      return get_cbor_object(static_cast<std::size_t>(-1), tag_handler);
-
-    case 0xC6: // tagged item
-    case 0xC7:
-    case 0xC8:
-    case 0xC9:
-    case 0xCA:
-    case 0xCB:
-    case 0xCC:
-    case 0xCD:
-    case 0xCE:
-    case 0xCF:
-    case 0xD0:
-    case 0xD1:
-    case 0xD2:
-    case 0xD3:
-    case 0xD4:
-    case 0xD8: // tagged item (1 bytes follow)
-    case 0xD9: // tagged item (2 bytes follow)
-    case 0xDA: // tagged item (4 bytes follow)
-    case 0xDB: // tagged item (8 bytes follow)
-    {
-      switch (tag_handler) {
-      case cbor_tag_handler_t::error: {
-        auto last_token = get_token_string();
-        return sax->parse_error(
-            chars_read, last_token,
-            parse_error::create(
-                112, chars_read,
-                exception_message(input_format_t::cbor,
-                                  concat("invalid byte: 0x", last_token),
-                                  "value"),
-                nullptr));
-      }
-
-      case cbor_tag_handler_t::ignore: {
-        // ignore binary subtype
-        switch (current) {
-        case 0xD8: {
-          std::uint8_t subtype_to_ignore{};
-          get_number(input_format_t::cbor, subtype_to_ignore);
-          break;
-        }
-        case 0xD9: {
-          std::uint16_t subtype_to_ignore{};
-          get_number(input_format_t::cbor, subtype_to_ignore);
-          break;
-        }
-        case 0xDA: {
-          std::uint32_t subtype_to_ignore{};
-          get_number(input_format_t::cbor, subtype_to_ignore);
-          break;
-        }
-        case 0xDB: {
-          std::uint64_t subtype_to_ignore{};
-          get_number(input_format_t::cbor, subtype_to_ignore);
-          break;
-        }
-        default:
-          break;
-        }
-        return parse_cbor_internal(true, tag_handler);
-      }
-
-      case cbor_tag_handler_t::store: {
-        binary_t b;
-        // use binary subtype and store in binary container
-        switch (current) {
-        case 0xD8: {
-          std::uint8_t subtype{};
-          get_number(input_format_t::cbor, subtype);
-          b.set_subtype(
-              detail::conditional_static_cast<typename binary_t::subtype_type>(
-                  subtype));
-          break;
-        }
-        case 0xD9: {
-          std::uint16_t subtype{};
-          get_number(input_format_t::cbor, subtype);
-          b.set_subtype(
-              detail::conditional_static_cast<typename binary_t::subtype_type>(
-                  subtype));
-          break;
-        }
-        case 0xDA: {
-          std::uint32_t subtype{};
-          get_number(input_format_t::cbor, subtype);
-          b.set_subtype(
-              detail::conditional_static_cast<typename binary_t::subtype_type>(
-                  subtype));
-          break;
-        }
-        case 0xDB: {
-          std::uint64_t subtype{};
-          get_number(input_format_t::cbor, subtype);
-          b.set_subtype(
-              detail::conditional_static_cast<typename binary_t::subtype_type>(
-                  subtype));
-          break;
-        }
-        default:
-          return parse_cbor_internal(true, tag_handler);
-        }
-        get();
-        return get_cbor_binary(b) && sax->binary(b);
-      }
-
-      default:              // LCOV_EXCL_LINE
-        JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
-                            // LCOV_EXCL_LINE
-        return false; // LCOV_EXCL_LINE
-      }
-    }
-
-    case 0xF4: // false
-      return sax->boolean(false);
-
-    case 0xF5: // true
-      return sax->boolean(true);
-
-    case 0xF6: // null
-      return sax->null();
-
-    case 0xF9: // Half-Precision Float (two-byte IEEE 754)
-    {
-      const auto byte1_raw = get();
-      if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number"))) {
-        return false;
-      }
-      const auto byte2_raw = get();
-      if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number"))) {
-        return false;
-      }
-
-      const auto byte1 = static_cast<unsigned char>(byte1_raw);
-      const auto byte2 = static_cast<unsigned char>(byte2_raw);
-
-      // code from RFC 7049, Appendix D, Figure 3:
-      // As half-precision floating-point numbers were only added
-      // to IEEE 754 in 2008, today's programming platforms often
-      // still only have limited support for them. It is very
-      // easy to include at least decoding support for them even
-      // without such support. An example of a small decoder for
-      // half-precision floating-point numbers in the C language
-      // is shown in Fig. 3.
-      const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
-      const double val = [&half] {
-        const int exp = (half >> 10u) & 0x1Fu;
-        const unsigned int mant = half & 0x3FFu;
-        JSON_ASSERT(0 <= exp && exp <= 32);
-        JSON_ASSERT(mant <= 1024);
-        switch (exp) {
-        case 0:
-          return std::ldexp(mant, -24);
-        case 31:
-          return (mant == 0) ? std::numeric_limits<double>::infinity()
-                             : std::numeric_limits<double>::quiet_NaN();
-        default:
-          return std::ldexp(mant + 1024, exp - 25);
-        }
-      }();
-      return sax->number_float((half & 0x8000u) != 0
-                                   ? static_cast<number_float_t>(-val)
-                                   : static_cast<number_float_t>(val),
-                               "");
-    }
-
-    case 0xFA: // Single-Precision Float (four-byte IEEE 754)
-    {
-      float number{};
-      return get_number(input_format_t::cbor, number) &&
-             sax->number_float(static_cast<number_float_t>(number), "");
-    }
-
-    case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
-    {
-      double number{};
-      return get_number(input_format_t::cbor, number) &&
-             sax->number_float(static_cast<number_float_t>(number), "");
-    }
-
-    default: // anything else (0xFF is handled inside the other types)
-    {
-      auto last_token = get_token_string();
-      return sax->parse_error(
-          chars_read, last_token,
-          parse_error::create(
-              112, chars_read,
-              exception_message(input_format_t::cbor,
-                                concat("invalid byte: 0x", last_token),
-                                "value"),
-              nullptr));
-    }
-    }
-  }
-
-  /*!
-  @brief reads a CBOR string
-
-  This function first reads starting bytes to determine the expected
-  string length and then copies this number of bytes into a string.
-  Additionally, CBOR's strings with indefinite lengths are supported.
-
-  @param[out] result  created string
-
-  @return whether string creation completed
-  */
-  bool get_cbor_string(string_t &result) {
-    if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string"))) {
-      return false;
-    }
-
-    switch (current) {
-    // UTF-8 string (0x00..0x17 bytes follow)
-    case 0x60:
-    case 0x61:
-    case 0x62:
-    case 0x63:
-    case 0x64:
-    case 0x65:
-    case 0x66:
-    case 0x67:
-    case 0x68:
-    case 0x69:
-    case 0x6A:
-    case 0x6B:
-    case 0x6C:
-    case 0x6D:
-    case 0x6E:
-    case 0x6F:
-    case 0x70:
-    case 0x71:
-    case 0x72:
-    case 0x73:
-    case 0x74:
-    case 0x75:
-    case 0x76:
-    case 0x77: {
-      return get_string(input_format_t::cbor,
-                        static_cast<unsigned int>(current) & 0x1Fu, result);
-    }
-
-    case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
-    {
-      std::uint8_t len{};
-      return get_number(input_format_t::cbor, len) &&
-             get_string(input_format_t::cbor, len, result);
-    }
-
-    case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
-    {
-      std::uint16_t len{};
-      return get_number(input_format_t::cbor, len) &&
-             get_string(input_format_t::cbor, len, result);
-    }
-
-    case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
-    {
-      std::uint32_t len{};
-      return get_number(input_format_t::cbor, len) &&
-             get_string(input_format_t::cbor, len, result);
-    }
-
-    case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
-    {
-      std::uint64_t len{};
-      return get_number(input_format_t::cbor, len) &&
-             get_string(input_format_t::cbor, len, result);
-    }
-
-    case 0x7F: // UTF-8 string (indefinite length)
-    {
-      while (get() != 0xFF) {
-        string_t chunk;
-        if (!get_cbor_string(chunk)) {
-          return false;
-        }
-        result.append(chunk);
-      }
-      return true;
-    }
-
-    default: {
-      auto last_token = get_token_string();
-      return sax->parse_error(
-          chars_read, last_token,
-          parse_error::create(
-              113, chars_read,
-              exception_message(
-                  input_format_t::cbor,
-                  concat("expected length specification (0x60-0x7B) or "
-                         "indefinite string type (0x7F); last byte: 0x",
-                         last_token),
-                  "string"),
-              nullptr));
-    }
-    }
-  }
-
-  /*!
-  @brief reads a CBOR byte array
-
-  This function first reads starting bytes to determine the expected
-  byte array length and then copies this number of bytes into the byte array.
-  Additionally, CBOR's byte arrays with indefinite lengths are supported.
-
-  @param[out] result  created byte array
-
-  @return whether byte array creation completed
-  */
-  bool get_cbor_binary(binary_t &result) {
-    if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary"))) {
-      return false;
-    }
-
-    switch (current) {
-    // Binary data (0x00..0x17 bytes follow)
-    case 0x40:
-    case 0x41:
-    case 0x42:
-    case 0x43:
-    case 0x44:
-    case 0x45:
-    case 0x46:
-    case 0x47:
-    case 0x48:
-    case 0x49:
-    case 0x4A:
-    case 0x4B:
-    case 0x4C:
-    case 0x4D:
-    case 0x4E:
-    case 0x4F:
-    case 0x50:
-    case 0x51:
-    case 0x52:
-    case 0x53:
-    case 0x54:
-    case 0x55:
-    case 0x56:
-    case 0x57: {
-      return get_binary(input_format_t::cbor,
-                        static_cast<unsigned int>(current) & 0x1Fu, result);
-    }
-
-    case 0x58: // Binary data (one-byte uint8_t for n follows)
-    {
-      std::uint8_t len{};
-      return get_number(input_format_t::cbor, len) &&
-             get_binary(input_format_t::cbor, len, result);
-    }
-
-    case 0x59: // Binary data (two-byte uint16_t for n follow)
-    {
-      std::uint16_t len{};
-      return get_number(input_format_t::cbor, len) &&
-             get_binary(input_format_t::cbor, len, result);
-    }
-
-    case 0x5A: // Binary data (four-byte uint32_t for n follow)
-    {
-      std::uint32_t len{};
-      return get_number(input_format_t::cbor, len) &&
-             get_binary(input_format_t::cbor, len, result);
-    }
-
-    case 0x5B: // Binary data (eight-byte uint64_t for n follow)
-    {
-      std::uint64_t len{};
-      return get_number(input_format_t::cbor, len) &&
-             get_binary(input_format_t::cbor, len, result);
-    }
-
-    case 0x5F: // Binary data (indefinite length)
-    {
-      while (get() != 0xFF) {
-        binary_t chunk;
-        if (!get_cbor_binary(chunk)) {
-          return false;
-        }
-        result.insert(result.end(), chunk.begin(), chunk.end());
-      }
-      return true;
-    }
-
-    default: {
-      auto last_token = get_token_string();
-      return sax->parse_error(
-          chars_read, last_token,
-          parse_error::create(
-              113, chars_read,
-              exception_message(
-                  input_format_t::cbor,
-                  concat("expected length specification (0x40-0x5B) or "
-                         "indefinite binary array type (0x5F); last byte: 0x",
-                         last_token),
-                  "binary"),
-              nullptr));
-    }
-    }
-  }
-
-  /*!
-  @param[in] len  the length of the array or static_cast<std::size_t>(-1) for an
-                  array of indefinite size
-  @param[in] tag_handler how CBOR tags should be treated
-  @return whether array creation completed
-  */
-  bool get_cbor_array(const std::size_t len,
-                      const cbor_tag_handler_t tag_handler) {
-    if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len))) {
-      return false;
-    }
-
-    if (len != static_cast<std::size_t>(-1)) {
-      for (std::size_t i = 0; i < len; ++i) {
-        if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler))) {
-          return false;
-        }
-      }
-    } else {
-      while (get() != 0xFF) {
-        if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler))) {
-          return false;
-        }
-      }
-    }
-
-    return sax->end_array();
-  }
-
-  /*!
-  @param[in] len  the length of the object or static_cast<std::size_t>(-1) for
-  an object of indefinite size
-  @param[in] tag_handler how CBOR tags should be treated
-  @return whether object creation completed
-  */
-  bool get_cbor_object(const std::size_t len,
-                       const cbor_tag_handler_t tag_handler) {
-    if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len))) {
-      return false;
-    }
-
-    if (len != 0) {
-      string_t key;
-      if (len != static_cast<std::size_t>(-1)) {
-        for (std::size_t i = 0; i < len; ++i) {
-          get();
-          if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key))) {
-            return false;
-          }
-
-          if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler))) {
-            return false;
-          }
-          key.clear();
-        }
-      } else {
-        while (get() != 0xFF) {
-          if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key))) {
-            return false;
-          }
-
-          if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler))) {
-            return false;
-          }
-          key.clear();
-        }
-      }
-    }
-
-    return sax->end_object();
-  }
-
-  /////////////
-  // MsgPack //
-  /////////////
-
-  /*!
-  @return whether a valid MessagePack value was passed to the SAX parser
-  */
-  bool parse_msgpack_internal() {
-    switch (get()) {
-    // EOF
-    case char_traits<char_type>::eof():
-      return unexpect_eof(input_format_t::msgpack, "value");
-
-    // positive fixint
-    case 0x00:
-    case 0x01:
-    case 0x02:
-    case 0x03:
-    case 0x04:
-    case 0x05:
-    case 0x06:
-    case 0x07:
-    case 0x08:
-    case 0x09:
-    case 0x0A:
-    case 0x0B:
-    case 0x0C:
-    case 0x0D:
-    case 0x0E:
-    case 0x0F:
-    case 0x10:
-    case 0x11:
-    case 0x12:
-    case 0x13:
-    case 0x14:
-    case 0x15:
-    case 0x16:
-    case 0x17:
-    case 0x18:
-    case 0x19:
-    case 0x1A:
-    case 0x1B:
-    case 0x1C:
-    case 0x1D:
-    case 0x1E:
-    case 0x1F:
-    case 0x20:
-    case 0x21:
-    case 0x22:
-    case 0x23:
-    case 0x24:
-    case 0x25:
-    case 0x26:
-    case 0x27:
-    case 0x28:
-    case 0x29:
-    case 0x2A:
-    case 0x2B:
-    case 0x2C:
-    case 0x2D:
-    case 0x2E:
-    case 0x2F:
-    case 0x30:
-    case 0x31:
-    case 0x32:
-    case 0x33:
-    case 0x34:
-    case 0x35:
-    case 0x36:
-    case 0x37:
-    case 0x38:
-    case 0x39:
-    case 0x3A:
-    case 0x3B:
-    case 0x3C:
-    case 0x3D:
-    case 0x3E:
-    case 0x3F:
-    case 0x40:
-    case 0x41:
-    case 0x42:
-    case 0x43:
-    case 0x44:
-    case 0x45:
-    case 0x46:
-    case 0x47:
-    case 0x48:
-    case 0x49:
-    case 0x4A:
-    case 0x4B:
-    case 0x4C:
-    case 0x4D:
-    case 0x4E:
-    case 0x4F:
-    case 0x50:
-    case 0x51:
-    case 0x52:
-    case 0x53:
-    case 0x54:
-    case 0x55:
-    case 0x56:
-    case 0x57:
-    case 0x58:
-    case 0x59:
-    case 0x5A:
-    case 0x5B:
-    case 0x5C:
-    case 0x5D:
-    case 0x5E:
-    case 0x5F:
-    case 0x60:
-    case 0x61:
-    case 0x62:
-    case 0x63:
-    case 0x64:
-    case 0x65:
-    case 0x66:
-    case 0x67:
-    case 0x68:
-    case 0x69:
-    case 0x6A:
-    case 0x6B:
-    case 0x6C:
-    case 0x6D:
-    case 0x6E:
-    case 0x6F:
-    case 0x70:
-    case 0x71:
-    case 0x72:
-    case 0x73:
-    case 0x74:
-    case 0x75:
-    case 0x76:
-    case 0x77:
-    case 0x78:
-    case 0x79:
-    case 0x7A:
-    case 0x7B:
-    case 0x7C:
-    case 0x7D:
-    case 0x7E:
-    case 0x7F:
-      return sax->number_unsigned(static_cast<number_unsigned_t>(current));
-
-    // fixmap
-    case 0x80:
-    case 0x81:
-    case 0x82:
-    case 0x83:
-    case 0x84:
-    case 0x85:
-    case 0x86:
-    case 0x87:
-    case 0x88:
-    case 0x89:
-    case 0x8A:
-    case 0x8B:
-    case 0x8C:
-    case 0x8D:
-    case 0x8E:
-    case 0x8F:
-      return get_msgpack_object(conditional_static_cast<std::size_t>(
-          static_cast<unsigned int>(current) & 0x0Fu));
-
-    // fixarray
-    case 0x90:
-    case 0x91:
-    case 0x92:
-    case 0x93:
-    case 0x94:
-    case 0x95:
-    case 0x96:
-    case 0x97:
-    case 0x98:
-    case 0x99:
-    case 0x9A:
-    case 0x9B:
-    case 0x9C:
-    case 0x9D:
-    case 0x9E:
-    case 0x9F:
-      return get_msgpack_array(conditional_static_cast<std::size_t>(
-          static_cast<unsigned int>(current) & 0x0Fu));
-
-    // fixstr
-    case 0xA0:
-    case 0xA1:
-    case 0xA2:
-    case 0xA3:
-    case 0xA4:
-    case 0xA5:
-    case 0xA6:
-    case 0xA7:
-    case 0xA8:
-    case 0xA9:
-    case 0xAA:
-    case 0xAB:
-    case 0xAC:
-    case 0xAD:
-    case 0xAE:
-    case 0xAF:
-    case 0xB0:
-    case 0xB1:
-    case 0xB2:
-    case 0xB3:
-    case 0xB4:
-    case 0xB5:
-    case 0xB6:
-    case 0xB7:
-    case 0xB8:
-    case 0xB9:
-    case 0xBA:
-    case 0xBB:
-    case 0xBC:
-    case 0xBD:
-    case 0xBE:
-    case 0xBF:
-    case 0xD9: // str 8
-    case 0xDA: // str 16
-    case 0xDB: // str 32
-    {
-      string_t s;
-      return get_msgpack_string(s) && sax->string(s);
-    }
-
-    case 0xC0: // nil
-      return sax->null();
-
-    case 0xC2: // false
-      return sax->boolean(false);
-
-    case 0xC3: // true
-      return sax->boolean(true);
-
-    case 0xC4: // bin 8
-    case 0xC5: // bin 16
-    case 0xC6: // bin 32
-    case 0xC7: // ext 8
-    case 0xC8: // ext 16
-    case 0xC9: // ext 32
-    case 0xD4: // fixext 1
-    case 0xD5: // fixext 2
-    case 0xD6: // fixext 4
-    case 0xD7: // fixext 8
-    case 0xD8: // fixext 16
-    {
-      binary_t b;
-      return get_msgpack_binary(b) && sax->binary(b);
-    }
-
-    case 0xCA: // float 32
-    {
-      float number{};
-      return get_number(input_format_t::msgpack, number) &&
-             sax->number_float(static_cast<number_float_t>(number), "");
-    }
-
-    case 0xCB: // float 64
-    {
-      double number{};
-      return get_number(input_format_t::msgpack, number) &&
-             sax->number_float(static_cast<number_float_t>(number), "");
-    }
-
-    case 0xCC: // uint 8
-    {
-      std::uint8_t number{};
-      return get_number(input_format_t::msgpack, number) &&
-             sax->number_unsigned(number);
-    }
-
-    case 0xCD: // uint 16
-    {
-      std::uint16_t number{};
-      return get_number(input_format_t::msgpack, number) &&
-             sax->number_unsigned(number);
-    }
-
-    case 0xCE: // uint 32
-    {
-      std::uint32_t number{};
-      return get_number(input_format_t::msgpack, number) &&
-             sax->number_unsigned(number);
-    }
-
-    case 0xCF: // uint 64
-    {
-      std::uint64_t number{};
-      return get_number(input_format_t::msgpack, number) &&
-             sax->number_unsigned(number);
-    }
-
-    case 0xD0: // int 8
-    {
-      std::int8_t number{};
-      return get_number(input_format_t::msgpack, number) &&
-             sax->number_integer(number);
-    }
-
-    case 0xD1: // int 16
-    {
-      std::int16_t number{};
-      return get_number(input_format_t::msgpack, number) &&
-             sax->number_integer(number);
-    }
-
-    case 0xD2: // int 32
-    {
-      std::int32_t number{};
-      return get_number(input_format_t::msgpack, number) &&
-             sax->number_integer(number);
-    }
-
-    case 0xD3: // int 64
-    {
-      std::int64_t number{};
-      return get_number(input_format_t::msgpack, number) &&
-             sax->number_integer(number);
-    }
-
-    case 0xDC: // array 16
-    {
-      std::uint16_t len{};
-      return get_number(input_format_t::msgpack, len) &&
-             get_msgpack_array(static_cast<std::size_t>(len));
-    }
-
-    case 0xDD: // array 32
-    {
-      std::uint32_t len{};
-      return get_number(input_format_t::msgpack, len) &&
-             get_msgpack_array(conditional_static_cast<std::size_t>(len));
-    }
-
-    case 0xDE: // map 16
-    {
-      std::uint16_t len{};
-      return get_number(input_format_t::msgpack, len) &&
-             get_msgpack_object(static_cast<std::size_t>(len));
-    }
-
-    case 0xDF: // map 32
-    {
-      std::uint32_t len{};
-      return get_number(input_format_t::msgpack, len) &&
-             get_msgpack_object(conditional_static_cast<std::size_t>(len));
-    }
-
-    // negative fixint
-    case 0xE0:
-    case 0xE1:
-    case 0xE2:
-    case 0xE3:
-    case 0xE4:
-    case 0xE5:
-    case 0xE6:
-    case 0xE7:
-    case 0xE8:
-    case 0xE9:
-    case 0xEA:
-    case 0xEB:
-    case 0xEC:
-    case 0xED:
-    case 0xEE:
-    case 0xEF:
-    case 0xF0:
-    case 0xF1:
-    case 0xF2:
-    case 0xF3:
-    case 0xF4:
-    case 0xF5:
-    case 0xF6:
-    case 0xF7:
-    case 0xF8:
-    case 0xF9:
-    case 0xFA:
-    case 0xFB:
-    case 0xFC:
-    case 0xFD:
-    case 0xFE:
-    case 0xFF:
-      return sax->number_integer(static_cast<std::int8_t>(current));
-
-    default: // anything else
-    {
-      auto last_token = get_token_string();
-      return sax->parse_error(
-          chars_read, last_token,
-          parse_error::create(
-              112, chars_read,
-              exception_message(input_format_t::msgpack,
-                                concat("invalid byte: 0x", last_token),
-                                "value"),
-              nullptr));
-    }
-    }
-  }
-
-  /*!
-  @brief reads a MessagePack string
-
-  This function first reads starting bytes to determine the expected
-  string length and then copies this number of bytes into a string.
-
-  @param[out] result  created string
-
-  @return whether string creation completed
-  */
-  bool get_msgpack_string(string_t &result) {
-    if (JSON_HEDLEY_UNLIKELY(
-            !unexpect_eof(input_format_t::msgpack, "string"))) {
-      return false;
-    }
-
-    switch (current) {
-    // fixstr
-    case 0xA0:
-    case 0xA1:
-    case 0xA2:
-    case 0xA3:
-    case 0xA4:
-    case 0xA5:
-    case 0xA6:
-    case 0xA7:
-    case 0xA8:
-    case 0xA9:
-    case 0xAA:
-    case 0xAB:
-    case 0xAC:
-    case 0xAD:
-    case 0xAE:
-    case 0xAF:
-    case 0xB0:
-    case 0xB1:
-    case 0xB2:
-    case 0xB3:
-    case 0xB4:
-    case 0xB5:
-    case 0xB6:
-    case 0xB7:
-    case 0xB8:
-    case 0xB9:
-    case 0xBA:
-    case 0xBB:
-    case 0xBC:
-    case 0xBD:
-    case 0xBE:
-    case 0xBF: {
-      return get_string(input_format_t::msgpack,
-                        static_cast<unsigned int>(current) & 0x1Fu, result);
-    }
-
-    case 0xD9: // str 8
-    {
-      std::uint8_t len{};
-      return get_number(input_format_t::msgpack, len) &&
-             get_string(input_format_t::msgpack, len, result);
-    }
-
-    case 0xDA: // str 16
-    {
-      std::uint16_t len{};
-      return get_number(input_format_t::msgpack, len) &&
-             get_string(input_format_t::msgpack, len, result);
-    }
-
-    case 0xDB: // str 32
-    {
-      std::uint32_t len{};
-      return get_number(input_format_t::msgpack, len) &&
-             get_string(input_format_t::msgpack, len, result);
-    }
-
-    default: {
-      auto last_token = get_token_string();
-      return sax->parse_error(
-          chars_read, last_token,
-          parse_error::create(
-              113, chars_read,
-              exception_message(input_format_t::msgpack,
-                                concat("expected length specification "
-                                       "(0xA0-0xBF, 0xD9-0xDB); last byte: 0x",
-                                       last_token),
-                                "string"),
-              nullptr));
-    }
-    }
-  }
-
-  /*!
-  @brief reads a MessagePack byte array
-
-  This function first reads starting bytes to determine the expected
-  byte array length and then copies this number of bytes into a byte array.
-
-  @param[out] result  created byte array
-
-  @return whether byte array creation completed
-  */
-  bool get_msgpack_binary(binary_t &result) {
-    // helper function to set the subtype
-    auto assign_and_return_true = [&result](std::int8_t subtype) {
-      result.set_subtype(static_cast<std::uint8_t>(subtype));
-      return true;
-    };
-
-    switch (current) {
-    case 0xC4: // bin 8
-    {
-      std::uint8_t len{};
-      return get_number(input_format_t::msgpack, len) &&
-             get_binary(input_format_t::msgpack, len, result);
-    }
-
-    case 0xC5: // bin 16
-    {
-      std::uint16_t len{};
-      return get_number(input_format_t::msgpack, len) &&
-             get_binary(input_format_t::msgpack, len, result);
-    }
-
-    case 0xC6: // bin 32
-    {
-      std::uint32_t len{};
-      return get_number(input_format_t::msgpack, len) &&
-             get_binary(input_format_t::msgpack, len, result);
-    }
-
-    case 0xC7: // ext 8
-    {
-      std::uint8_t len{};
-      std::int8_t subtype{};
-      return get_number(input_format_t::msgpack, len) &&
-             get_number(input_format_t::msgpack, subtype) &&
-             get_binary(input_format_t::msgpack, len, result) &&
-             assign_and_return_true(subtype);
-    }
-
-    case 0xC8: // ext 16
-    {
-      std::uint16_t len{};
-      std::int8_t subtype{};
-      return get_number(input_format_t::msgpack, len) &&
-             get_number(input_format_t::msgpack, subtype) &&
-             get_binary(input_format_t::msgpack, len, result) &&
-             assign_and_return_true(subtype);
-    }
-
-    case 0xC9: // ext 32
-    {
-      std::uint32_t len{};
-      std::int8_t subtype{};
-      return get_number(input_format_t::msgpack, len) &&
-             get_number(input_format_t::msgpack, subtype) &&
-             get_binary(input_format_t::msgpack, len, result) &&
-             assign_and_return_true(subtype);
-    }
-
-    case 0xD4: // fixext 1
-    {
-      std::int8_t subtype{};
-      return get_number(input_format_t::msgpack, subtype) &&
-             get_binary(input_format_t::msgpack, 1, result) &&
-             assign_and_return_true(subtype);
-    }
-
-    case 0xD5: // fixext 2
-    {
-      std::int8_t subtype{};
-      return get_number(input_format_t::msgpack, subtype) &&
-             get_binary(input_format_t::msgpack, 2, result) &&
-             assign_and_return_true(subtype);
-    }
-
-    case 0xD6: // fixext 4
-    {
-      std::int8_t subtype{};
-      return get_number(input_format_t::msgpack, subtype) &&
-             get_binary(input_format_t::msgpack, 4, result) &&
-             assign_and_return_true(subtype);
-    }
-
-    case 0xD7: // fixext 8
-    {
-      std::int8_t subtype{};
-      return get_number(input_format_t::msgpack, subtype) &&
-             get_binary(input_format_t::msgpack, 8, result) &&
-             assign_and_return_true(subtype);
-    }
-
-    case 0xD8: // fixext 16
-    {
-      std::int8_t subtype{};
-      return get_number(input_format_t::msgpack, subtype) &&
-             get_binary(input_format_t::msgpack, 16, result) &&
-             assign_and_return_true(subtype);
-    }
-
-    default:        // LCOV_EXCL_LINE
-      return false; // LCOV_EXCL_LINE
-    }
-  }
-
-  /*!
-  @param[in] len  the length of the array
-  @return whether array creation completed
-  */
-  bool get_msgpack_array(const std::size_t len) {
-    if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len))) {
-      return false;
-    }
-
-    for (std::size_t i = 0; i < len; ++i) {
-      if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal())) {
-        return false;
-      }
-    }
-
-    return sax->end_array();
-  }
-
-  /*!
-  @param[in] len  the length of the object
-  @return whether object creation completed
-  */
-  bool get_msgpack_object(const std::size_t len) {
-    if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len))) {
-      return false;
-    }
-
-    string_t key;
-    for (std::size_t i = 0; i < len; ++i) {
-      get();
-      if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key))) {
-        return false;
-      }
-
-      if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal())) {
-        return false;
-      }
-      key.clear();
-    }
-
-    return sax->end_object();
-  }
-
-  ////////////
-  // UBJSON //
-  ////////////
-
-  /*!
-  @param[in] get_char  whether a new character should be retrieved from the
-                       input (true, default) or whether the last read
-                       character should be considered instead
-
-  @return whether a valid UBJSON value was passed to the SAX parser
-  */
-  bool parse_ubjson_internal(const bool get_char = true) {
-    return get_ubjson_value(get_char ? get_ignore_noop() : current);
-  }
-
-  /*!
-  @brief reads a UBJSON string
-
-  This function is either called after reading the 'S' byte explicitly
-  indicating a string, or in case of an object key where the 'S' byte can be
-  left out.
-
-  @param[out] result   created string
-  @param[in] get_char  whether a new character should be retrieved from the
-                       input (true, default) or whether the last read
-                       character should be considered instead
-
-  @return whether string creation completed
-  */
-  bool get_ubjson_string(string_t &result, const bool get_char = true) {
-    if (get_char) {
-      get(); // TODO(niels): may we ignore N here?
-    }
-
-    if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value"))) {
-      return false;
-    }
-
-    switch (current) {
-    case 'U': {
-      std::uint8_t len{};
-      return get_number(input_format, len) &&
-             get_string(input_format, len, result);
-    }
-
-    case 'i': {
-      std::int8_t len{};
-      return get_number(input_format, len) &&
-             get_string(input_format, len, result);
-    }
-
-    case 'I': {
-      std::int16_t len{};
-      return get_number(input_format, len) &&
-             get_string(input_format, len, result);
-    }
-
-    case 'l': {
-      std::int32_t len{};
-      return get_number(input_format, len) &&
-             get_string(input_format, len, result);
-    }
-
-    case 'L': {
-      std::int64_t len{};
-      return get_number(input_format, len) &&
-             get_string(input_format, len, result);
-    }
-
-    case 'u': {
-      if (input_format != input_format_t::bjdata) {
-        break;
-      }
-      std::uint16_t len{};
-      return get_number(input_format, len) &&
-             get_string(input_format, len, result);
-    }
-
-    case 'm': {
-      if (input_format != input_format_t::bjdata) {
-        break;
-      }
-      std::uint32_t len{};
-      return get_number(input_format, len) &&
-             get_string(input_format, len, result);
-    }
-
-    case 'M': {
-      if (input_format != input_format_t::bjdata) {
-        break;
-      }
-      std::uint64_t len{};
-      return get_number(input_format, len) &&
-             get_string(input_format, len, result);
-    }
-
-    default:
-      break;
-    }
-    auto last_token = get_token_string();
-    std::string message;
-
-    if (input_format != input_format_t::bjdata) {
-      message =
-          "expected length type specification (U, i, I, l, L); last byte: 0x" +
-          last_token;
-    } else {
-      message = "expected length type specification (U, i, u, I, m, l, M, L); "
-                "last byte: 0x" +
-                last_token;
-    }
-    return sax->parse_error(
-        chars_read, last_token,
-        parse_error::create(113, chars_read,
-                            exception_message(input_format, message, "string"),
-                            nullptr));
-  }
-
-  /*!
-  @param[out] dim  an integer vector storing the ND array dimensions
-  @return whether reading ND array size vector is successful
-  */
-  bool get_ubjson_ndarray_size(std::vector<size_t> &dim) {
-    std::pair<std::size_t, char_int_type> size_and_type;
-    size_t dimlen = 0;
-    bool no_ndarray = true;
-
-    if (JSON_HEDLEY_UNLIKELY(
-            !get_ubjson_size_type(size_and_type, no_ndarray))) {
-      return false;
-    }
-
-    if (size_and_type.first != npos) {
-      if (size_and_type.second != 0) {
-        if (size_and_type.second != 'N') {
-          for (std::size_t i = 0; i < size_and_type.first; ++i) {
-            if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(
-                    dimlen, no_ndarray, size_and_type.second))) {
-              return false;
-            }
-            dim.push_back(dimlen);
-          }
-        }
-      } else {
-        for (std::size_t i = 0; i < size_and_type.first; ++i) {
-          if (JSON_HEDLEY_UNLIKELY(
-                  !get_ubjson_size_value(dimlen, no_ndarray))) {
-            return false;
-          }
-          dim.push_back(dimlen);
-        }
-      }
-    } else {
-      while (current != ']') {
-        if (JSON_HEDLEY_UNLIKELY(
-                !get_ubjson_size_value(dimlen, no_ndarray, current))) {
-          return false;
-        }
-        dim.push_back(dimlen);
-        get_ignore_noop();
-      }
-    }
-    return true;
-  }
-
-  /*!
-  @param[out] result  determined size
-  @param[in,out] is_ndarray  for input, `true` means already inside an ndarray
-  vector or ndarray dimension is not allowed; `false` means ndarray is allowed;
-  for output, `true` means an ndarray is found; is_ndarray can only return
-  `true` when its initial value is `false`
-  @param[in] prefix  type marker if already read, otherwise set to 0
-
-  @return whether size determination completed
-  */
-  bool get_ubjson_size_value(std::size_t &result, bool &is_ndarray,
-                             char_int_type prefix = 0) {
-    if (prefix == 0) {
-      prefix = get_ignore_noop();
-    }
-
-    switch (prefix) {
-    case 'U': {
-      std::uint8_t number{};
-      if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) {
-        return false;
-      }
-      result = static_cast<std::size_t>(number);
-      return true;
-    }
-
-    case 'i': {
-      std::int8_t number{};
-      if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) {
-        return false;
-      }
-      if (number < 0) {
-        return sax->parse_error(
-            chars_read, get_token_string(),
-            parse_error::create(
-                113, chars_read,
-                exception_message(
-                    input_format,
-                    "count in an optimized container must be positive", "size"),
-                nullptr));
-      }
-      result = static_cast<std::size_t>(number); // NOLINT(bugprone-signed-char-misuse,cert-str34-c):
-                                                 // number is not a char
-      return true;
-    }
-
-    case 'I': {
-      std::int16_t number{};
-      if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) {
-        return false;
-      }
-      if (number < 0) {
-        return sax->parse_error(
-            chars_read, get_token_string(),
-            parse_error::create(
-                113, chars_read,
-                exception_message(
-                    input_format,
-                    "count in an optimized container must be positive", "size"),
-                nullptr));
-      }
-      result = static_cast<std::size_t>(number);
-      return true;
-    }
-
-    case 'l': {
-      std::int32_t number{};
-      if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) {
-        return false;
-      }
-      if (number < 0) {
-        return sax->parse_error(
-            chars_read, get_token_string(),
-            parse_error::create(
-                113, chars_read,
-                exception_message(
-                    input_format,
-                    "count in an optimized container must be positive", "size"),
-                nullptr));
-      }
-      result = static_cast<std::size_t>(number);
-      return true;
-    }
-
-    case 'L': {
-      std::int64_t number{};
-      if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) {
-        return false;
-      }
-      if (number < 0) {
-        return sax->parse_error(
-            chars_read, get_token_string(),
-            parse_error::create(
-                113, chars_read,
-                exception_message(
-                    input_format,
-                    "count in an optimized container must be positive", "size"),
-                nullptr));
-      }
-      if (!value_in_range_of<std::size_t>(number)) {
-        return sax->parse_error(
-            chars_read, get_token_string(),
-            out_of_range::create(408,
-                                 exception_message(input_format,
-                                                   "integer value overflow",
-                                                   "size"),
-                                 nullptr));
-      }
-      result = static_cast<std::size_t>(number);
-      return true;
-    }
-
-    case 'u': {
-      if (input_format != input_format_t::bjdata) {
-        break;
-      }
-      std::uint16_t number{};
-      if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) {
-        return false;
-      }
-      result = static_cast<std::size_t>(number);
-      return true;
-    }
-
-    case 'm': {
-      if (input_format != input_format_t::bjdata) {
-        break;
-      }
-      std::uint32_t number{};
-      if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) {
-        return false;
-      }
-      result = conditional_static_cast<std::size_t>(number);
-      return true;
-    }
-
-    case 'M': {
-      if (input_format != input_format_t::bjdata) {
-        break;
-      }
-      std::uint64_t number{};
-      if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) {
-        return false;
-      }
-      if (!value_in_range_of<std::size_t>(number)) {
-        return sax->parse_error(
-            chars_read, get_token_string(),
-            out_of_range::create(408,
-                                 exception_message(input_format,
-                                                   "integer value overflow",
-                                                   "size"),
-                                 nullptr));
-      }
-      result = detail::conditional_static_cast<std::size_t>(number);
-      return true;
-    }
-
-    case '[': {
-      if (input_format != input_format_t::bjdata) {
-        break;
-      }
-      if (is_ndarray) // ndarray dimensional vector can only contain integers,
-                      // and can not embed another array
-      {
-        return sax->parse_error(
-            chars_read, get_token_string(),
-            parse_error::create(
-                113, chars_read,
-                exception_message(input_format,
-                                  "ndarray dimensional vector is not allowed",
-                                  "size"),
-                nullptr));
-      }
-      std::vector<size_t> dim;
-      if (JSON_HEDLEY_UNLIKELY(!get_ubjson_ndarray_size(dim))) {
-        return false;
-      }
-      if (dim.size() == 1 ||
-          (dim.size() == 2 &&
-           dim.at(0) == 1)) // return normal array size if 1D row vector
-      {
-        result = dim.at(dim.size() - 1);
-        return true;
-      }
-      if (!dim.empty()) // if ndarray, convert to an object in JData annotated
-                        // array format
-      {
-        for (auto i : dim) // test if any dimension in an ndarray is 0, if so,
-                           // return a 1D empty container
-        {
-          if (i == 0) {
-            result = 0;
-            return true;
-          }
-        }
-
-        string_t key = "_ArraySize_";
-        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(3) || !sax->key(key) ||
-                                 !sax->start_array(dim.size()))) {
-          return false;
-        }
-        result = 1;
-        for (auto i : dim) {
-          result *= i;
-          if (result == 0 ||
-              result ==
-                  npos) // because dim elements shall not have zeros, result = 0
-                        // means overflow happened; it also can't be npos as it
-                        // is used to initialize size in get_ubjson_size_type()
-          {
-            return sax->parse_error(
-                chars_read, get_token_string(),
-                out_of_range::create(
-                    408,
-                    exception_message(input_format,
-                                      "excessive ndarray size caused overflow",
-                                      "size"),
-                    nullptr));
-          }
-          if (JSON_HEDLEY_UNLIKELY(
-                  !sax->number_unsigned(static_cast<number_unsigned_t>(i)))) {
-            return false;
-          }
-        }
-        is_ndarray = true;
-        return sax->end_array();
-      }
-      result = 0;
-      return true;
-    }
-
-    default:
-      break;
-    }
-    auto last_token = get_token_string();
-    std::string message;
-
-    if (input_format != input_format_t::bjdata) {
-      message = "expected length type specification (U, i, I, l, L) after '#'; "
-                "last byte: 0x" +
-                last_token;
-    } else {
-      message = "expected length type specification (U, i, u, I, m, l, M, L) "
-                "after '#'; last byte: 0x" +
-                last_token;
-    }
-    return sax->parse_error(
-        chars_read, last_token,
-        parse_error::create(113, chars_read,
-                            exception_message(input_format, message, "size"),
-                            nullptr));
-  }
-
-  /*!
-  @brief determine the type and size for a container
-
-  In the optimized UBJSON format, a type and a size can be provided to allow
-  for a more compact representation.
-
-  @param[out] result  pair of the size and the type
-  @param[in] inside_ndarray  whether the parser is parsing an ND array
-  dimensional vector
-
-  @return whether pair creation completed
-  */
-  bool get_ubjson_size_type(std::pair<std::size_t, char_int_type> &result,
-                            bool inside_ndarray = false) {
-    result.first = npos; // size
-    result.second = 0;   // type
-    bool is_ndarray = false;
-
-    get_ignore_noop();
-
-    if (current == '$') {
-      result.second = get(); // must not ignore 'N', because 'N' maybe the type
-      if (input_format == input_format_t::bjdata &&
-          JSON_HEDLEY_UNLIKELY(std::binary_search(
-              bjd_optimized_type_markers.begin(),
-              bjd_optimized_type_markers.end(), result.second))) {
-        auto last_token = get_token_string();
-        return sax->parse_error(
-            chars_read, last_token,
-            parse_error::create(
-                112, chars_read,
-                exception_message(
-                    input_format,
-                    concat("marker 0x", last_token,
-                           " is not a permitted optimized array type"),
-                    "type"),
-                nullptr));
-      }
-
-      if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "type"))) {
-        return false;
-      }
-
-      get_ignore_noop();
-      if (JSON_HEDLEY_UNLIKELY(current != '#')) {
-        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value"))) {
-          return false;
-        }
-        auto last_token = get_token_string();
-        return sax->parse_error(
-            chars_read, last_token,
-            parse_error::create(
-                112, chars_read,
-                exception_message(
-                    input_format,
-                    concat("expected '#' after type information; last byte: 0x",
-                           last_token),
-                    "size"),
-                nullptr));
-      }
-
-      const bool is_error = get_ubjson_size_value(result.first, is_ndarray);
-      if (input_format == input_format_t::bjdata && is_ndarray) {
-        if (inside_ndarray) {
-          return sax->parse_error(
-              chars_read, get_token_string(),
-              parse_error::create(
-                  112, chars_read,
-                  exception_message(input_format,
-                                    "ndarray can not be recursive", "size"),
-                  nullptr));
-        }
-        result.second |= (1 << 8); // use bit 8 to indicate ndarray, all UBJSON
-                                   // and BJData markers should be ASCII letters
-      }
-      return is_error;
-    }
-
-    if (current == '#') {
-      const bool is_error = get_ubjson_size_value(result.first, is_ndarray);
-      if (input_format == input_format_t::bjdata && is_ndarray) {
-        return sax->parse_error(
-            chars_read, get_token_string(),
-            parse_error::create(
-                112, chars_read,
-                exception_message(input_format,
-                                  "ndarray requires both type and size",
-                                  "size"),
-                nullptr));
-      }
-      return is_error;
-    }
-
-    return true;
-  }
-
-  /*!
-  @param prefix  the previously read or set type prefix
-  @return whether value creation completed
-  */
-  bool get_ubjson_value(const char_int_type prefix) {
-    switch (prefix) {
-    case char_traits<char_type>::eof(): // EOF
-      return unexpect_eof(input_format, "value");
-
-    case 'T': // true
-      return sax->boolean(true);
-    case 'F': // false
-      return sax->boolean(false);
-
-    case 'Z': // null
-      return sax->null();
-
-    case 'U': {
-      std::uint8_t number{};
-      return get_number(input_format, number) && sax->number_unsigned(number);
-    }
-
-    case 'i': {
-      std::int8_t number{};
-      return get_number(input_format, number) && sax->number_integer(number);
-    }
-
-    case 'I': {
-      std::int16_t number{};
-      return get_number(input_format, number) && sax->number_integer(number);
-    }
-
-    case 'l': {
-      std::int32_t number{};
-      return get_number(input_format, number) && sax->number_integer(number);
-    }
-
-    case 'L': {
-      std::int64_t number{};
-      return get_number(input_format, number) && sax->number_integer(number);
-    }
-
-    case 'u': {
-      if (input_format != input_format_t::bjdata) {
-        break;
-      }
-      std::uint16_t number{};
-      return get_number(input_format, number) && sax->number_unsigned(number);
-    }
-
-    case 'm': {
-      if (input_format != input_format_t::bjdata) {
-        break;
-      }
-      std::uint32_t number{};
-      return get_number(input_format, number) && sax->number_unsigned(number);
-    }
-
-    case 'M': {
-      if (input_format != input_format_t::bjdata) {
-        break;
-      }
-      std::uint64_t number{};
-      return get_number(input_format, number) && sax->number_unsigned(number);
-    }
-
-    case 'h': {
-      if (input_format != input_format_t::bjdata) {
-        break;
-      }
-      const auto byte1_raw = get();
-      if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number"))) {
-        return false;
-      }
-      const auto byte2_raw = get();
-      if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number"))) {
-        return false;
-      }
-
-      const auto byte1 = static_cast<unsigned char>(byte1_raw);
-      const auto byte2 = static_cast<unsigned char>(byte2_raw);
-
-      // code from RFC 7049, Appendix D, Figure 3:
-      // As half-precision floating-point numbers were only added
-      // to IEEE 754 in 2008, today's programming platforms often
-      // still only have limited support for them. It is very
-      // easy to include at least decoding support for them even
-      // without such support. An example of a small decoder for
-      // half-precision floating-point numbers in the C language
-      // is shown in Fig. 3.
-      const auto half = static_cast<unsigned int>((byte2 << 8u) + byte1);
-      const double val = [&half] {
-        const int exp = (half >> 10u) & 0x1Fu;
-        const unsigned int mant = half & 0x3FFu;
-        JSON_ASSERT(0 <= exp && exp <= 32);
-        JSON_ASSERT(mant <= 1024);
-        switch (exp) {
-        case 0:
-          return std::ldexp(mant, -24);
-        case 31:
-          return (mant == 0) ? std::numeric_limits<double>::infinity()
-                             : std::numeric_limits<double>::quiet_NaN();
-        default:
-          return std::ldexp(mant + 1024, exp - 25);
-        }
-      }();
-      return sax->number_float((half & 0x8000u) != 0
-                                   ? static_cast<number_float_t>(-val)
-                                   : static_cast<number_float_t>(val),
-                               "");
-    }
-
-    case 'd': {
-      float number{};
-      return get_number(input_format, number) &&
-             sax->number_float(static_cast<number_float_t>(number), "");
-    }
-
-    case 'D': {
-      double number{};
-      return get_number(input_format, number) &&
-             sax->number_float(static_cast<number_float_t>(number), "");
-    }
-
-    case 'H': {
-      return get_ubjson_high_precision_number();
-    }
-
-    case 'C': // char
-    {
-      get();
-      if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "char"))) {
-        return false;
-      }
-      if (JSON_HEDLEY_UNLIKELY(current > 127)) {
-        auto last_token = get_token_string();
-        return sax->parse_error(
-            chars_read, last_token,
-            parse_error::create(
-                113, chars_read,
-                exception_message(input_format,
-                                  concat("byte after 'C' must be in range "
-                                         "0x00..0x7F; last byte: 0x",
-                                         last_token),
-                                  "char"),
-                nullptr));
-      }
-      string_t s(1, static_cast<typename string_t::value_type>(current));
-      return sax->string(s);
-    }
-
-    case 'S': // string
-    {
-      string_t s;
-      return get_ubjson_string(s) && sax->string(s);
-    }
-
-    case '[': // array
-      return get_ubjson_array();
-
-    case '{': // object
-      return get_ubjson_object();
-
-    default: // anything else
-      break;
-    }
-    auto last_token = get_token_string();
-    return sax->parse_error(
-        chars_read, last_token,
-        parse_error::create(112, chars_read,
-                            exception_message(input_format,
-                                              "invalid byte: 0x" + last_token,
-                                              "value"),
-                            nullptr));
-  }
-
-  /*!
-  @return whether array creation completed
-  */
-  bool get_ubjson_array() {
-    std::pair<std::size_t, char_int_type> size_and_type;
-    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type))) {
-      return false;
-    }
-
-    // if bit-8 of size_and_type.second is set to 1, encode bjdata ndarray as an
-    // object in JData annotated array format
-    // (https://github.com/NeuroJSON/jdata):
-    // {"_ArrayType_" : "typeid", "_ArraySize_" : [n1, n2, ...], "_ArrayData_" :
-    // [v1, v2, ...]}
-
-    if (input_format == input_format_t::bjdata && size_and_type.first != npos &&
-        (size_and_type.second & (1 << 8)) != 0) {
-      size_and_type.second &=
-          ~(static_cast<char_int_type>(1)
-            << 8); // use bit 8 to indicate ndarray, here we remove the bit to
-                   // restore the type marker
-      auto it = std::lower_bound(
-          bjd_types_map.begin(), bjd_types_map.end(), size_and_type.second,
-          [](const bjd_type &p, char_int_type t) { return p.first < t; });
-      string_t key = "_ArrayType_";
-      if (JSON_HEDLEY_UNLIKELY(it == bjd_types_map.end() ||
-                               it->first != size_and_type.second)) {
-        auto last_token = get_token_string();
-        return sax->parse_error(
-            chars_read, last_token,
-            parse_error::create(
-                112, chars_read,
-                exception_message(input_format, "invalid byte: 0x" + last_token,
-                                  "type"),
-                nullptr));
-      }
-
-      string_t type = it->second; // sax->string() takes a reference
-      if (JSON_HEDLEY_UNLIKELY(!sax->key(key) || !sax->string(type))) {
-        return false;
-      }
-
-      if (size_and_type.second == 'C') {
-        size_and_type.second = 'U';
-      }
-
-      key = "_ArrayData_";
-      if (JSON_HEDLEY_UNLIKELY(!sax->key(key) ||
-                               !sax->start_array(size_and_type.first))) {
-        return false;
-      }
-
-      for (std::size_t i = 0; i < size_and_type.first; ++i) {
-        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second))) {
-          return false;
-        }
-      }
-
-      return (sax->end_array() && sax->end_object());
-    }
-
-    if (size_and_type.first != npos) {
-      if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first))) {
-        return false;
-      }
-
-      if (size_and_type.second != 0) {
-        if (size_and_type.second != 'N') {
-          for (std::size_t i = 0; i < size_and_type.first; ++i) {
-            if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second))) {
-              return false;
-            }
-          }
-        }
-      } else {
-        for (std::size_t i = 0; i < size_and_type.first; ++i) {
-          if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal())) {
-            return false;
-          }
-        }
-      }
-    } else {
-      if (JSON_HEDLEY_UNLIKELY(
-              !sax->start_array(static_cast<std::size_t>(-1)))) {
-        return false;
-      }
-
-      while (current != ']') {
-        if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(false))) {
-          return false;
-        }
-        get_ignore_noop();
-      }
-    }
-
-    return sax->end_array();
-  }
-
-  /*!
-  @return whether object creation completed
-  */
-  bool get_ubjson_object() {
-    std::pair<std::size_t, char_int_type> size_and_type;
-    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type))) {
-      return false;
-    }
-
-    // do not accept ND-array size in objects in BJData
-    if (input_format == input_format_t::bjdata && size_and_type.first != npos &&
-        (size_and_type.second & (1 << 8)) != 0) {
-      auto last_token = get_token_string();
-      return sax->parse_error(
-          chars_read, last_token,
-          parse_error::create(
-              112, chars_read,
-              exception_message(input_format,
-                                "BJData object does not support ND-array size "
-                                "in optimized format",
-                                "object"),
-              nullptr));
-    }
-
-    string_t key;
-    if (size_and_type.first != npos) {
-      if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first))) {
-        return false;
-      }
-
-      if (size_and_type.second != 0) {
-        for (std::size_t i = 0; i < size_and_type.first; ++i) {
-          if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key))) {
-            return false;
-          }
-          if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second))) {
-            return false;
-          }
-          key.clear();
-        }
-      } else {
-        for (std::size_t i = 0; i < size_and_type.first; ++i) {
-          if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key))) {
-            return false;
-          }
-          if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal())) {
-            return false;
-          }
-          key.clear();
-        }
-      }
-    } else {
-      if (JSON_HEDLEY_UNLIKELY(
-              !sax->start_object(static_cast<std::size_t>(-1)))) {
-        return false;
-      }
-
-      while (current != '}') {
-        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) ||
-                                 !sax->key(key))) {
-          return false;
-        }
-        if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal())) {
-          return false;
-        }
-        get_ignore_noop();
-        key.clear();
-      }
-    }
-
-    return sax->end_object();
-  }
-
-  // Note, no reader for UBJSON binary types is implemented because they do
-  // not exist
-
-  bool get_ubjson_high_precision_number() {
-    // get size of following number string
-    std::size_t size{};
-    bool no_ndarray = true;
-    auto res = get_ubjson_size_value(size, no_ndarray);
-    if (JSON_HEDLEY_UNLIKELY(!res)) {
-      return res;
-    }
-
-    // get number string
-    std::vector<char> number_vector;
-    for (std::size_t i = 0; i < size; ++i) {
-      get();
-      if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number"))) {
-        return false;
-      }
-      number_vector.push_back(static_cast<char>(current));
-    }
-
-    // parse number string
-    using ia_type = decltype(detail::input_adapter(number_vector));
-    auto number_lexer = detail::lexer<BasicJsonType, ia_type>(
-        detail::input_adapter(number_vector), false);
-    const auto result_number = number_lexer.scan();
-    const auto number_string = number_lexer.get_token_string();
-    const auto result_remainder = number_lexer.scan();
-
-    using token_type = typename detail::lexer_base<BasicJsonType>::token_type;
-
-    if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input)) {
-      return sax->parse_error(
-          chars_read, number_string,
-          parse_error::create(
-              115, chars_read,
-              exception_message(input_format,
-                                concat("invalid number text: ",
-                                       number_lexer.get_token_string()),
-                                "high-precision number"),
-              nullptr));
-    }
-
-    switch (result_number) {
-    case token_type::value_integer:
-      return sax->number_integer(number_lexer.get_number_integer());
-    case token_type::value_unsigned:
-      return sax->number_unsigned(number_lexer.get_number_unsigned());
-    case token_type::value_float:
-      return sax->number_float(number_lexer.get_number_float(),
-                               std::move(number_string));
-    case token_type::uninitialized:
-    case token_type::literal_true:
-    case token_type::literal_false:
-    case token_type::literal_null:
-    case token_type::value_string:
-    case token_type::begin_array:
-    case token_type::begin_object:
-    case token_type::end_array:
-    case token_type::end_object:
-    case token_type::name_separator:
-    case token_type::value_separator:
-    case token_type::parse_error:
-    case token_type::end_of_input:
-    case token_type::literal_or_value:
-    default:
-      return sax->parse_error(
-          chars_read, number_string,
-          parse_error::create(
-              115, chars_read,
-              exception_message(input_format,
-                                concat("invalid number text: ",
-                                       number_lexer.get_token_string()),
-                                "high-precision number"),
-              nullptr));
-    }
-  }
-
-  ///////////////////////
-  // Utility functions //
-  ///////////////////////
-
-  /*!
-  @brief get next character from the input
-
-  This function provides the interface to the used input adapter. It does
-  not throw in case the input reached EOF, but returns a -'ve valued
-  `char_traits<char_type>::eof()` in that case.
-
-  @return character read from the input
-  */
-  char_int_type get() {
-    ++chars_read;
-    return current = ia.get_character();
-  }
-
-  /*!
-  @brief get_to read into a primitive type
-
-  This function provides the interface to the used input adapter. It does
-  not throw in case the input reached EOF, but returns false instead
-
-  @return bool, whether the read was successful
-  */
-  template <class T>
-  bool get_to(T &dest, const input_format_t format, const char *context) {
-    auto new_chars_read = ia.get_elements(&dest);
-    chars_read += new_chars_read;
-    if (JSON_HEDLEY_UNLIKELY(new_chars_read < sizeof(T))) {
-      // in case of failure, advance position by 1 to report failing location
-      ++chars_read;
-      sax->parse_error(
-          chars_read, "<end of file>",
-          parse_error::create(
-              110, chars_read,
-              exception_message(format, "unexpected end of input", context),
-              nullptr));
-      return false;
-    }
-    return true;
-  }
-
-  /*!
-  @return character read from the input after ignoring all 'N' entries
-  */
-  char_int_type get_ignore_noop() {
-    do {
-      get();
-    } while (current == 'N');
-
-    return current;
-  }
-
-  template <class NumberType> static void byte_swap(NumberType &number) {
-    constexpr std::size_t sz = sizeof(number);
-#ifdef __cpp_lib_byteswap
-    if constexpr (sz == 1) {
-      return;
-    }
-    if constexpr (std::is_integral_v<NumberType>) {
-      number = std::byteswap(number);
-      return;
-    }
-#endif
-    auto *ptr = reinterpret_cast<std::uint8_t *>(&number);
-    for (std::size_t i = 0; i < sz / 2; ++i) {
-      std::swap(ptr[i], ptr[sz - i - 1]);
-    }
-  }
-
-  /*
-  @brief read a number from the input
-
-  @tparam NumberType the type of the number
-  @param[in] format   the current format (for diagnostics)
-  @param[out] result  number of type @a NumberType
-
-  @return whether conversion completed
-
-  @note This function needs to respect the system's endianness, because
-        bytes in CBOR, MessagePack, and UBJSON are stored in network order
-        (big endian) and therefore need reordering on little endian systems.
-        On the other hand, BSON and BJData use little endian and should reorder
-        on big endian systems.
-  */
-  template <typename NumberType, bool InputIsLittleEndian = false>
-  bool get_number(const input_format_t format, NumberType &result) {
-    // read in the original format
-
-    if (JSON_HEDLEY_UNLIKELY(!get_to(result, format, "number"))) {
-      return false;
-    }
-    if (is_little_endian !=
-        (InputIsLittleEndian || format == input_format_t::bjdata)) {
-      byte_swap(result);
-    }
-    return true;
-  }
-
-  /*!
-  @brief create a string by reading characters from the input
-
-  @tparam NumberType the type of the number
-  @param[in] format the current format (for diagnostics)
-  @param[in] len number of characters to read
-  @param[out] result string created by reading @a len bytes
-
-  @return whether string creation completed
-
-  @note We can not reserve @a len bytes for the result, because @a len
-        may be too large. Usually, @ref unexpect_eof() detects the end of
-        the input before we run out of string memory.
-  */
-  template <typename NumberType>
-  bool get_string(const input_format_t format, const NumberType len,
-                  string_t &result) {
-    bool success = true;
-    for (NumberType i = 0; i < len; i++) {
-      get();
-      if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string"))) {
-        success = false;
-        break;
-      }
-      result.push_back(static_cast<typename string_t::value_type>(current));
-    }
-    return success;
-  }
-
-  /*!
-  @brief create a byte array by reading bytes from the input
-
-  @tparam NumberType the type of the number
-  @param[in] format the current format (for diagnostics)
-  @param[in] len number of bytes to read
-  @param[out] result byte array created by reading @a len bytes
-
-  @return whether byte array creation completed
-
-  @note We can not reserve @a len bytes for the result, because @a len
-        may be too large. Usually, @ref unexpect_eof() detects the end of
-        the input before we run out of memory.
-  */
-  template <typename NumberType>
-  bool get_binary(const input_format_t format, const NumberType len,
-                  binary_t &result) {
-    bool success = true;
-    for (NumberType i = 0; i < len; i++) {
-      get();
-      if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary"))) {
-        success = false;
-        break;
-      }
-      result.push_back(static_cast<std::uint8_t>(current));
-    }
-    return success;
-  }
-
-  /*!
-  @param[in] format   the current format (for diagnostics)
-  @param[in] context  further context information (for diagnostics)
-  @return whether the last read character is not EOF
-  */
-  JSON_HEDLEY_NON_NULL(3)
-  bool unexpect_eof(const input_format_t format, const char *context) const {
-    if (JSON_HEDLEY_UNLIKELY(current == char_traits<char_type>::eof())) {
-      return sax->parse_error(
-          chars_read, "<end of file>",
-          parse_error::create(
-              110, chars_read,
-              exception_message(format, "unexpected end of input", context),
-              nullptr));
-    }
-    return true;
-  }
-
-  /*!
-  @return a string representation of the last read byte
-  */
-  std::string get_token_string() const {
-    std::array<char, 3> cr{{}};
-    static_cast<void>((
-        std::
-            snprintf)(cr.data(), cr.size(), "%.2hhX",
-                      static_cast<unsigned char>(
-                          current))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
-    return std::string{cr.data()};
-  }
-
-  /*!
-  @param[in] format   the current format
-  @param[in] detail   a detailed error message
-  @param[in] context  further context information
-  @return a message string to use in the parse_error exceptions
-  */
-  std::string exception_message(const input_format_t format,
-                                const std::string &detail,
-                                const std::string &context) const {
-    std::string error_msg = "syntax error while parsing ";
-
-    switch (format) {
-    case input_format_t::cbor:
-      error_msg += "CBOR";
-      break;
-
-    case input_format_t::msgpack:
-      error_msg += "MessagePack";
-      break;
-
-    case input_format_t::ubjson:
-      error_msg += "UBJSON";
-      break;
-
-    case input_format_t::bson:
-      error_msg += "BSON";
-      break;
-
-    case input_format_t::bjdata:
-      error_msg += "BJData";
-      break;
-
-    case input_format_t::json: // LCOV_EXCL_LINE
-    default:                   // LCOV_EXCL_LINE
-      JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
-                          // LCOV_EXCL_LINE
-    }
-
-    return concat(error_msg, ' ', context, ": ", detail);
-  }
-
-private:
-  static JSON_INLINE_VARIABLE constexpr std::size_t npos =
-      static_cast<std::size_t>(-1);
-
-  /// input adapter
-  InputAdapterType ia;
-
-  /// the current character
-  char_int_type current = char_traits<char_type>::eof();
-
-  /// the number of characters read
-  std::size_t chars_read = 0;
-
-  /// whether we can assume little endianness
-  const bool is_little_endian = little_endianness();
-
-  /// input format
-  const input_format_t input_format = input_format_t::json;
-
-  /// the SAX parser
-  json_sax_t *sax = nullptr;
-
-  // excluded markers in bjdata optimized type
-#define JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_                    \
-  make_array<char_int_type>('F', 'H', 'N', 'S', 'T', 'Z', '[', '{')
-
-#define JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_                                 \
-  make_array<bjd_type>(                                                        \
-      bjd_type{'C', "char"}, bjd_type{'D', "double"}, bjd_type{'I', "int16"},  \
-      bjd_type{'L', "int64"}, bjd_type{'M', "uint64"}, bjd_type{'U', "uint8"}, \
-      bjd_type{'d', "single"}, bjd_type{'i', "int8"}, bjd_type{'l', "int32"},  \
-      bjd_type{'m', "uint32"}, bjd_type{'u', "uint16"})
-
-  JSON_PRIVATE_UNLESS_TESTED :
-      // lookup tables
-      // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes)
-      const decltype(JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_)
-          bjd_optimized_type_markers =
-              JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_;
-
-  using bjd_type = std::pair<char_int_type, string_t>;
-  // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes)
-  const decltype(JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_) bjd_types_map =
-      JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_;
-
-#undef JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_
-#undef JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_
-};
-
-#ifndef JSON_HAS_CPP_17
-template <typename BasicJsonType, typename InputAdapterType, typename SAX>
-constexpr std::size_t binary_reader<BasicJsonType, InputAdapterType, SAX>::npos;
-#endif
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/input/input_adapters.hpp>
-
-// #include <nlohmann/detail/input/lexer.hpp>
-
-// #include <nlohmann/detail/input/parser.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <cmath>      // isfinite
-#include <cstdint>    // uint8_t
-#include <functional> // function
-#include <string>     // string
-#include <utility>    // move
-#include <vector>     // vector
-
-// #include <nlohmann/detail/exceptions.hpp>
-
-// #include <nlohmann/detail/input/input_adapters.hpp>
-
-// #include <nlohmann/detail/input/json_sax.hpp>
-
-// #include <nlohmann/detail/input/lexer.hpp>
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/meta/is_sax.hpp>
-
-// #include <nlohmann/detail/string_concat.hpp>
-
-// #include <nlohmann/detail/value_t.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-////////////
-// parser //
-////////////
-
-enum class parse_event_t : std::uint8_t {
-  /// the parser read `{` and started to process a JSON object
-  object_start,
-  /// the parser read `}` and finished processing a JSON object
-  object_end,
-  /// the parser read `[` and started to process a JSON array
-  array_start,
-  /// the parser read `]` and finished processing a JSON array
-  array_end,
-  /// the parser read a key of a value in an object
-  key,
-  /// the parser finished reading a JSON value
-  value
-};
-
-template <typename BasicJsonType>
-using parser_callback_t = std::function<bool(
-    int /*depth*/, parse_event_t /*event*/, BasicJsonType & /*parsed*/)>;
-
-/*!
-@brief syntax analysis
-
-This class implements a recursive descent parser.
-*/
-template <typename BasicJsonType, typename InputAdapterType> class parser {
-  using number_integer_t = typename BasicJsonType::number_integer_t;
-  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-  using number_float_t = typename BasicJsonType::number_float_t;
-  using string_t = typename BasicJsonType::string_t;
-  using lexer_t = lexer<BasicJsonType, InputAdapterType>;
-  using token_type = typename lexer_t::token_type;
-
-public:
-  /// a parser reading from an input adapter
-  explicit parser(InputAdapterType &&adapter,
-                  parser_callback_t<BasicJsonType> cb = nullptr,
-                  const bool allow_exceptions_ = true,
-                  const bool skip_comments = false)
-      : callback(std::move(cb)), m_lexer(std::move(adapter), skip_comments),
-        allow_exceptions(allow_exceptions_) {
-    // read first token
-    get_token();
-  }
-
-  /*!
-  @brief public parser interface
-
-  @param[in] strict      whether to expect the last token to be EOF
-  @param[in,out] result  parsed JSON value
-
-  @throw parse_error.101 in case of an unexpected token
-  @throw parse_error.102 if to_unicode fails or surrogate error
-  @throw parse_error.103 if to_unicode fails
-  */
-  void parse(const bool strict, BasicJsonType &result) {
-    if (callback) {
-      json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback,
-                                                      allow_exceptions);
-      sax_parse_internal(&sdp);
-
-      // in strict mode, input must be completely read
-      if (strict && (get_token() != token_type::end_of_input)) {
-        sdp.parse_error(
-            m_lexer.get_position(), m_lexer.get_token_string(),
-            parse_error::create(
-                101, m_lexer.get_position(),
-                exception_message(token_type::end_of_input, "value"), nullptr));
-      }
-
-      // in case of an error, return discarded value
-      if (sdp.is_errored()) {
-        result = value_t::discarded;
-        return;
-      }
-
-      // set top-level value to null if it was discarded by the callback
-      // function
-      if (result.is_discarded()) {
-        result = nullptr;
-      }
-    } else {
-      json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
-      sax_parse_internal(&sdp);
-
-      // in strict mode, input must be completely read
-      if (strict && (get_token() != token_type::end_of_input)) {
-        sdp.parse_error(
-            m_lexer.get_position(), m_lexer.get_token_string(),
-            parse_error::create(
-                101, m_lexer.get_position(),
-                exception_message(token_type::end_of_input, "value"), nullptr));
-      }
-
-      // in case of an error, return discarded value
-      if (sdp.is_errored()) {
-        result = value_t::discarded;
-        return;
-      }
-    }
-
-    result.assert_invariant();
-  }
-
-  /*!
-  @brief public accept interface
-
-  @param[in] strict  whether to expect the last token to be EOF
-  @return whether the input is a proper JSON text
-  */
-  bool accept(const bool strict = true) {
-    json_sax_acceptor<BasicJsonType> sax_acceptor;
-    return sax_parse(&sax_acceptor, strict);
-  }
-
-  template <typename SAX>
-  JSON_HEDLEY_NON_NULL(2)
-  bool sax_parse(SAX *sax, const bool strict = true) {
-    (void)detail::is_sax_static_asserts<SAX, BasicJsonType>{};
-    const bool result = sax_parse_internal(sax);
-
-    // strict mode: next byte must be EOF
-    if (result && strict && (get_token() != token_type::end_of_input)) {
-      return sax->parse_error(
-          m_lexer.get_position(), m_lexer.get_token_string(),
-          parse_error::create(
-              101, m_lexer.get_position(),
-              exception_message(token_type::end_of_input, "value"), nullptr));
-    }
-
-    return result;
-  }
-
-private:
-  template <typename SAX>
-  JSON_HEDLEY_NON_NULL(2)
-  bool sax_parse_internal(SAX *sax) {
-    // stack to remember the hierarchy of structured values we are parsing
-    // true = array; false = object
-    std::vector<bool> states;
-    // value to avoid a goto (see comment where set to true)
-    bool skip_to_state_evaluation = false;
-
-    while (true) {
-      if (!skip_to_state_evaluation) {
-        // invariant: get_token() was called before each iteration
-        switch (last_token) {
-        case token_type::begin_object: {
-          if (JSON_HEDLEY_UNLIKELY(
-                  !sax->start_object(static_cast<std::size_t>(-1)))) {
-            return false;
-          }
-
-          // closing } -> we are done
-          if (get_token() == token_type::end_object) {
-            if (JSON_HEDLEY_UNLIKELY(!sax->end_object())) {
-              return false;
-            }
-            break;
-          }
-
-          // parse key
-          if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string)) {
-            return sax->parse_error(
-                m_lexer.get_position(), m_lexer.get_token_string(),
-                parse_error::create(
-                    101, m_lexer.get_position(),
-                    exception_message(token_type::value_string, "object key"),
-                    nullptr));
-          }
-          if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string()))) {
-            return false;
-          }
-
-          // parse separator (:)
-          if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator)) {
-            return sax->parse_error(
-                m_lexer.get_position(), m_lexer.get_token_string(),
-                parse_error::create(
-                    101, m_lexer.get_position(),
-                    exception_message(token_type::name_separator,
-                                      "object separator"),
-                    nullptr));
-          }
-
-          // remember we are now inside an object
-          states.push_back(false);
-
-          // parse values
-          get_token();
-          continue;
-        }
-
-        case token_type::begin_array: {
-          if (JSON_HEDLEY_UNLIKELY(
-                  !sax->start_array(static_cast<std::size_t>(-1)))) {
-            return false;
-          }
-
-          // closing ] -> we are done
-          if (get_token() == token_type::end_array) {
-            if (JSON_HEDLEY_UNLIKELY(!sax->end_array())) {
-              return false;
-            }
-            break;
-          }
-
-          // remember we are now inside an array
-          states.push_back(true);
-
-          // parse values (no need to call get_token)
-          continue;
-        }
-
-        case token_type::value_float: {
-          const auto res = m_lexer.get_number_float();
-
-          if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res))) {
-            return sax->parse_error(
-                m_lexer.get_position(), m_lexer.get_token_string(),
-                out_of_range::create(406,
-                                     concat("number overflow parsing '",
-                                            m_lexer.get_token_string(), '\''),
-                                     nullptr));
-          }
-
-          if (JSON_HEDLEY_UNLIKELY(
-                  !sax->number_float(res, m_lexer.get_string()))) {
-            return false;
-          }
-
-          break;
-        }
-
-        case token_type::literal_false: {
-          if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false))) {
-            return false;
-          }
-          break;
-        }
-
-        case token_type::literal_null: {
-          if (JSON_HEDLEY_UNLIKELY(!sax->null())) {
-            return false;
-          }
-          break;
-        }
-
-        case token_type::literal_true: {
-          if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true))) {
-            return false;
-          }
-          break;
-        }
-
-        case token_type::value_integer: {
-          if (JSON_HEDLEY_UNLIKELY(
-                  !sax->number_integer(m_lexer.get_number_integer()))) {
-            return false;
-          }
-          break;
-        }
-
-        case token_type::value_string: {
-          if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string()))) {
-            return false;
-          }
-          break;
-        }
-
-        case token_type::value_unsigned: {
-          if (JSON_HEDLEY_UNLIKELY(
-                  !sax->number_unsigned(m_lexer.get_number_unsigned()))) {
-            return false;
-          }
-          break;
-        }
-
-        case token_type::parse_error: {
-          // using "uninitialized" to avoid "expected" message
-          return sax->parse_error(
-              m_lexer.get_position(), m_lexer.get_token_string(),
-              parse_error::create(
-                  101, m_lexer.get_position(),
-                  exception_message(token_type::uninitialized, "value"),
-                  nullptr));
-        }
-        case token_type::end_of_input: {
-          if (JSON_HEDLEY_UNLIKELY(m_lexer.get_position().chars_read_total ==
-                                   1)) {
-            return sax->parse_error(
-                m_lexer.get_position(), m_lexer.get_token_string(),
-                parse_error::create(
-                    101, m_lexer.get_position(),
-                    "attempting to parse an empty input; check that your input "
-                    "string or stream contains the expected JSON",
-                    nullptr));
-          }
-
-          return sax->parse_error(
-              m_lexer.get_position(), m_lexer.get_token_string(),
-              parse_error::create(
-                  101, m_lexer.get_position(),
-                  exception_message(token_type::literal_or_value, "value"),
-                  nullptr));
-        }
-        case token_type::uninitialized:
-        case token_type::end_array:
-        case token_type::end_object:
-        case token_type::name_separator:
-        case token_type::value_separator:
-        case token_type::literal_or_value:
-        default: // the last token was unexpected
-        {
-          return sax->parse_error(
-              m_lexer.get_position(), m_lexer.get_token_string(),
-              parse_error::create(
-                  101, m_lexer.get_position(),
-                  exception_message(token_type::literal_or_value, "value"),
-                  nullptr));
-        }
-        }
-      } else {
-        skip_to_state_evaluation = false;
-      }
-
-      // we reached this line after we successfully parsed a value
-      if (states.empty()) {
-        // empty stack: we reached the end of the hierarchy: done
-        return true;
-      }
-
-      if (states.back()) // array
-      {
-        // comma -> next value
-        if (get_token() == token_type::value_separator) {
-          // parse a new value
-          get_token();
-          continue;
-        }
-
-        // closing ]
-        if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array)) {
-          if (JSON_HEDLEY_UNLIKELY(!sax->end_array())) {
-            return false;
-          }
-
-          // We are done with this array. Before we can parse a
-          // new value, we need to evaluate the new state first.
-          // By setting skip_to_state_evaluation to false, we
-          // are effectively jumping to the beginning of this if.
-          JSON_ASSERT(!states.empty());
-          states.pop_back();
-          skip_to_state_evaluation = true;
-          continue;
-        }
-
-        return sax->parse_error(
-            m_lexer.get_position(), m_lexer.get_token_string(),
-            parse_error::create(
-                101, m_lexer.get_position(),
-                exception_message(token_type::end_array, "array"), nullptr));
-      }
-
-      // states.back() is false -> object
-
-      // comma -> next value
-      if (get_token() == token_type::value_separator) {
-        // parse key
-        if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string)) {
-          return sax->parse_error(
-              m_lexer.get_position(), m_lexer.get_token_string(),
-              parse_error::create(
-                  101, m_lexer.get_position(),
-                  exception_message(token_type::value_string, "object key"),
-                  nullptr));
-        }
-
-        if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string()))) {
-          return false;
-        }
-
-        // parse separator (:)
-        if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator)) {
-          return sax->parse_error(
-              m_lexer.get_position(), m_lexer.get_token_string(),
-              parse_error::create(101, m_lexer.get_position(),
-                                  exception_message(token_type::name_separator,
-                                                    "object separator"),
-                                  nullptr));
-        }
-
-        // parse values
-        get_token();
-        continue;
-      }
-
-      // closing }
-      if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object)) {
-        if (JSON_HEDLEY_UNLIKELY(!sax->end_object())) {
-          return false;
-        }
-
-        // We are done with this object. Before we can parse a
-        // new value, we need to evaluate the new state first.
-        // By setting skip_to_state_evaluation to false, we
-        // are effectively jumping to the beginning of this if.
-        JSON_ASSERT(!states.empty());
-        states.pop_back();
-        skip_to_state_evaluation = true;
-        continue;
-      }
-
-      return sax->parse_error(
-          m_lexer.get_position(), m_lexer.get_token_string(),
-          parse_error::create(
-              101, m_lexer.get_position(),
-              exception_message(token_type::end_object, "object"), nullptr));
-    }
-  }
-
-  /// get next token from lexer
-  token_type get_token() { return last_token = m_lexer.scan(); }
-
-  std::string exception_message(const token_type expected,
-                                const std::string &context) {
-    std::string error_msg = "syntax error ";
-
-    if (!context.empty()) {
-      error_msg += concat("while parsing ", context, ' ');
-    }
-
-    error_msg += "- ";
-
-    if (last_token == token_type::parse_error) {
-      error_msg += concat(m_lexer.get_error_message(), "; last read: '",
-                          m_lexer.get_token_string(), '\'');
-    } else {
-      error_msg += concat("unexpected ", lexer_t::token_type_name(last_token));
-    }
-
-    if (expected != token_type::uninitialized) {
-      error_msg += concat("; expected ", lexer_t::token_type_name(expected));
-    }
-
-    return error_msg;
-  }
-
-private:
-  /// callback function
-  const parser_callback_t<BasicJsonType> callback = nullptr;
-  /// the type of the last read token
-  token_type last_token = token_type::uninitialized;
-  /// the lexer
-  lexer_t m_lexer;
-  /// whether to throw exceptions in case of errors
-  const bool allow_exceptions = true;
-};
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/iterators/internal_iterator.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// #include <nlohmann/detail/abi_macros.hpp>
-
-// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <cstddef> // ptrdiff_t
-#include <limits>  // numeric_limits
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-/*
-@brief an iterator for primitive JSON types
-
-This class models an iterator for primitive JSON types (boolean, number,
-string). It's only purpose is to allow the iterator/const_iterator classes
-to "iterate" over primitive values. Internally, the iterator is modeled by
-a `difference_type` variable. Value begin_value (`0`) models the begin,
-end_value (`1`) models past the end.
-*/
-class primitive_iterator_t {
-private:
-  using difference_type = std::ptrdiff_t;
-  static constexpr difference_type begin_value = 0;
-  static constexpr difference_type end_value = begin_value + 1;
-
-  JSON_PRIVATE_UNLESS_TESTED :
-      /// iterator as signed integer type
-      difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
-
-public:
-  constexpr difference_type get_value() const noexcept { return m_it; }
-
-  /// set iterator to a defined beginning
-  void set_begin() noexcept { m_it = begin_value; }
-
-  /// set iterator to a defined past the end
-  void set_end() noexcept { m_it = end_value; }
-
-  /// return whether the iterator can be dereferenced
-  constexpr bool is_begin() const noexcept { return m_it == begin_value; }
-
-  /// return whether the iterator is at end
-  constexpr bool is_end() const noexcept { return m_it == end_value; }
-
-  friend constexpr bool operator==(primitive_iterator_t lhs,
-                                   primitive_iterator_t rhs) noexcept {
-    return lhs.m_it == rhs.m_it;
-  }
-
-  friend constexpr bool operator<(primitive_iterator_t lhs,
-                                  primitive_iterator_t rhs) noexcept {
-    return lhs.m_it < rhs.m_it;
-  }
-
-  primitive_iterator_t operator+(difference_type n) noexcept {
-    auto result = *this;
-    result += n;
-    return result;
-  }
-
-  friend constexpr difference_type
-  operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept {
-    return lhs.m_it - rhs.m_it;
-  }
-
-  primitive_iterator_t &operator++() noexcept {
-    ++m_it;
-    return *this;
-  }
-
-  primitive_iterator_t operator++(int) & noexcept // NOLINT(cert-dcl21-cpp)
-  {
-    auto result = *this;
-    ++m_it;
-    return result;
-  }
-
-  primitive_iterator_t &operator--() noexcept {
-    --m_it;
-    return *this;
-  }
-
-  primitive_iterator_t operator--(int) & noexcept // NOLINT(cert-dcl21-cpp)
-  {
-    auto result = *this;
-    --m_it;
-    return result;
-  }
-
-  primitive_iterator_t &operator+=(difference_type n) noexcept {
-    m_it += n;
-    return *this;
-  }
-
-  primitive_iterator_t &operator-=(difference_type n) noexcept {
-    m_it -= n;
-    return *this;
-  }
-};
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-/*!
-@brief an iterator value
-
-@note This structure could easily be a union, but MSVC currently does not allow
-unions members with complex constructors, see
-https://github.com/nlohmann/json/pull/105.
-*/
-template <typename BasicJsonType> struct internal_iterator {
-  /// iterator for JSON objects
-  typename BasicJsonType::object_t::iterator object_iterator{};
-  /// iterator for JSON arrays
-  typename BasicJsonType::array_t::iterator array_iterator{};
-  /// generic iterator for all other types
-  primitive_iterator_t primitive_iterator{};
-};
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/iterators/iter_impl.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
-#include <type_traits> // conditional, is_const, remove_const
-
-// #include <nlohmann/detail/exceptions.hpp>
-
-// #include <nlohmann/detail/iterators/internal_iterator.hpp>
-
-// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/meta/cpp_future.hpp>
-
-// #include <nlohmann/detail/meta/type_traits.hpp>
-
-// #include <nlohmann/detail/value_t.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-// forward declare, to be able to friend it later on
-template <typename IteratorType> class iteration_proxy;
-template <typename IteratorType> class iteration_proxy_value;
-
-/*!
-@brief a template for a bidirectional iterator for the @ref basic_json class
-This class implements a both iterators (iterator and const_iterator) for the
-@ref basic_json class.
-@note An iterator is called *initialized* when a pointer to a JSON value has
-      been set (e.g., by a constructor or a copy assignment). If the iterator is
-      default-constructed, it is *uninitialized* and most methods are undefined.
-      **The library uses assertions to detect calls on uninitialized
-iterators.**
-@requirement The class satisfies the following concept requirements:
--
-[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
-  The iterator that can be moved can be moved in both directions (i.e.
-  incremented and decremented).
-@since version 1.0.0, simplified in version 2.0.9, change to bidirectional
-       iterators in version 3.0.0 (see
-https://github.com/nlohmann/json/issues/593)
-*/
-template <typename BasicJsonType>
-class
-    iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
-{
-  /// the iterator with BasicJsonType of different const-ness
-  using other_iter_impl = iter_impl<
-      typename std::conditional<std::is_const<BasicJsonType>::value,
-                                typename std::remove_const<BasicJsonType>::type,
-                                const BasicJsonType>::type>;
-  /// allow basic_json to access private members
-  friend other_iter_impl;
-  friend BasicJsonType;
-  friend iteration_proxy<iter_impl>;
-  friend iteration_proxy_value<iter_impl>;
-
-  using object_t = typename BasicJsonType::object_t;
-  using array_t = typename BasicJsonType::array_t;
-  // make sure BasicJsonType is basic_json or const basic_json
-  static_assert(
-      is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
-      "iter_impl only accepts (const) basic_json");
-  // superficial check for the LegacyBidirectionalIterator named requirement
-  static_assert(
-      std::is_base_of<std::bidirectional_iterator_tag,
-                      std::bidirectional_iterator_tag>::value &&
-          std::is_base_of<
-              std::bidirectional_iterator_tag,
-              typename std::iterator_traits<
-                  typename array_t::iterator>::iterator_category>::value,
-      "basic_json iterator assumes array and object type iterators satisfy the "
-      "LegacyBidirectionalIterator named requirement.");
-
-public:
-  /// The std::iterator class template (used as a base class to provide
-  /// typedefs) is deprecated in C++17. The C++ Standard has never required
-  /// user-defined iterators to derive from std::iterator. A user-defined
-  /// iterator should provide publicly accessible typedefs named
-  /// iterator_category, value_type, difference_type, pointer, and reference.
-  /// Note that value_type is required to be non-const, even for constant
-  /// iterators.
-  using iterator_category = std::bidirectional_iterator_tag;
-
-  /// the type of the values when the iterator is dereferenced
-  using value_type = typename BasicJsonType::value_type;
-  /// a type to represent differences between iterators
-  using difference_type = typename BasicJsonType::difference_type;
-  /// defines a pointer to the type iterated over (value_type)
-  using pointer =
-      typename std::conditional<std::is_const<BasicJsonType>::value,
-                                typename BasicJsonType::const_pointer,
-                                typename BasicJsonType::pointer>::type;
-  /// defines a reference to the type iterated over (value_type)
-  using reference =
-      typename std::conditional<std::is_const<BasicJsonType>::value,
-                                typename BasicJsonType::const_reference,
-                                typename BasicJsonType::reference>::type;
-
-  iter_impl() = default;
-  ~iter_impl() = default;
-  iter_impl(iter_impl &&) noexcept = default;
-  iter_impl &operator=(iter_impl &&) noexcept = default;
-
-  /*!
-  @brief constructor for a given JSON instance
-  @param[in] object  pointer to a JSON object for this iterator
-  @pre object != nullptr
-  @post The iterator is initialized; i.e. `m_object != nullptr`.
-  */
-  explicit iter_impl(pointer object) noexcept : m_object(object) {
-    JSON_ASSERT(m_object != nullptr);
-
-    switch (m_object->m_data.m_type) {
-    case value_t::object: {
-      m_it.object_iterator = typename object_t::iterator();
-      break;
-    }
-
-    case value_t::array: {
-      m_it.array_iterator = typename array_t::iterator();
-      break;
-    }
-
-    case value_t::null:
-    case value_t::string:
-    case value_t::boolean:
-    case value_t::number_integer:
-    case value_t::number_unsigned:
-    case value_t::number_float:
-    case value_t::binary:
-    case value_t::discarded:
-    default: {
-      m_it.primitive_iterator = primitive_iterator_t();
-      break;
-    }
-    }
-  }
-
-  /*!
-  @note The conventional copy constructor and copy assignment are implicitly
-        defined. Combined with the following converting constructor and
-        assignment, they support: (1) copy from iterator to iterator, (2)
-        copy from const iterator to const iterator, and (3) conversion from
-        iterator to const iterator. However conversion from const iterator
-        to iterator is not defined.
-  */
-
-  /*!
-  @brief const copy constructor
-  @param[in] other const iterator to copy from
-  @note This copy constructor had to be defined explicitly to circumvent a bug
-        occurring on msvc v19.0 compiler (VS 2015) debug build. For more
-        information refer to: https://github.com/nlohmann/json/issues/1608
-  */
-  iter_impl(const iter_impl<const BasicJsonType> &other) noexcept
-      : m_object(other.m_object), m_it(other.m_it) {}
-
-  /*!
-  @brief converting assignment
-  @param[in] other const iterator to copy from
-  @return const/non-const iterator
-  @note It is not checked whether @a other is initialized.
-  */
-  iter_impl &operator=(const iter_impl<const BasicJsonType> &other) noexcept {
-    if (&other != this) {
-      m_object = other.m_object;
-      m_it = other.m_it;
-    }
-    return *this;
-  }
-
-  /*!
-  @brief converting constructor
-  @param[in] other  non-const iterator to copy from
-  @note It is not checked whether @a other is initialized.
-  */
-  iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>
-                &other) noexcept
-      : m_object(other.m_object), m_it(other.m_it) {}
-
-  /*!
-  @brief converting assignment
-  @param[in] other  non-const iterator to copy from
-  @return const/non-const iterator
-  @note It is not checked whether @a other is initialized.
-  */
-  iter_impl &
-  operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>
-                &other) noexcept // NOLINT(cert-oop54-cpp)
-  {
-    m_object = other.m_object;
-    m_it = other.m_it;
-    return *this;
-  }
-
-  JSON_PRIVATE_UNLESS_TESTED :
-      /*!
-      @brief set the iterator to the first value
-      @pre The iterator is initialized; i.e. `m_object != nullptr`.
-      */
-      void
-      set_begin() noexcept {
-    JSON_ASSERT(m_object != nullptr);
-
-    switch (m_object->m_data.m_type) {
-    case value_t::object: {
-      m_it.object_iterator = m_object->m_data.m_value.object->begin();
-      break;
-    }
-
-    case value_t::array: {
-      m_it.array_iterator = m_object->m_data.m_value.array->begin();
-      break;
-    }
-
-    case value_t::null: {
-      // set to end so begin()==end() is true: null is empty
-      m_it.primitive_iterator.set_end();
-      break;
-    }
-
-    case value_t::string:
-    case value_t::boolean:
-    case value_t::number_integer:
-    case value_t::number_unsigned:
-    case value_t::number_float:
-    case value_t::binary:
-    case value_t::discarded:
-    default: {
-      m_it.primitive_iterator.set_begin();
-      break;
-    }
-    }
-  }
-
-  /*!
-  @brief set the iterator past the last value
-  @pre The iterator is initialized; i.e. `m_object != nullptr`.
-  */
-  void set_end() noexcept {
-    JSON_ASSERT(m_object != nullptr);
-
-    switch (m_object->m_data.m_type) {
-    case value_t::object: {
-      m_it.object_iterator = m_object->m_data.m_value.object->end();
-      break;
-    }
-
-    case value_t::array: {
-      m_it.array_iterator = m_object->m_data.m_value.array->end();
-      break;
-    }
-
-    case value_t::null:
-    case value_t::string:
-    case value_t::boolean:
-    case value_t::number_integer:
-    case value_t::number_unsigned:
-    case value_t::number_float:
-    case value_t::binary:
-    case value_t::discarded:
-    default: {
-      m_it.primitive_iterator.set_end();
-      break;
-    }
-    }
-  }
-
-public:
-  /*!
-  @brief return a reference to the value pointed to by the iterator
-  @pre The iterator is initialized; i.e. `m_object != nullptr`.
-  */
-  reference operator*() const {
-    JSON_ASSERT(m_object != nullptr);
-
-    switch (m_object->m_data.m_type) {
-    case value_t::object: {
-      JSON_ASSERT(m_it.object_iterator !=
-                  m_object->m_data.m_value.object->end());
-      return m_it.object_iterator->second;
-    }
-
-    case value_t::array: {
-      JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
-      return *m_it.array_iterator;
-    }
-
-    case value_t::null:
-      JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
-
-    case value_t::string:
-    case value_t::boolean:
-    case value_t::number_integer:
-    case value_t::number_unsigned:
-    case value_t::number_float:
-    case value_t::binary:
-    case value_t::discarded:
-    default: {
-      if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin())) {
-        return *m_object;
-      }
-
-      JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
-    }
-    }
-  }
-
-  /*!
-  @brief dereference the iterator
-  @pre The iterator is initialized; i.e. `m_object != nullptr`.
-  */
-  pointer operator->() const {
-    JSON_ASSERT(m_object != nullptr);
-
-    switch (m_object->m_data.m_type) {
-    case value_t::object: {
-      JSON_ASSERT(m_it.object_iterator !=
-                  m_object->m_data.m_value.object->end());
-      return &(m_it.object_iterator->second);
-    }
-
-    case value_t::array: {
-      JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
-      return &*m_it.array_iterator;
-    }
-
-    case value_t::null:
-    case value_t::string:
-    case value_t::boolean:
-    case value_t::number_integer:
-    case value_t::number_unsigned:
-    case value_t::number_float:
-    case value_t::binary:
-    case value_t::discarded:
-    default: {
-      if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin())) {
-        return m_object;
-      }
-
-      JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
-    }
-    }
-  }
-
-  /*!
-  @brief post-increment (it++)
-  @pre The iterator is initialized; i.e. `m_object != nullptr`.
-  */
-  iter_impl operator++(int) & // NOLINT(cert-dcl21-cpp)
-  {
-    auto result = *this;
-    ++(*this);
-    return result;
-  }
-
-  /*!
-  @brief pre-increment (++it)
-  @pre The iterator is initialized; i.e. `m_object != nullptr`.
-  */
-  iter_impl &operator++() {
-    JSON_ASSERT(m_object != nullptr);
-
-    switch (m_object->m_data.m_type) {
-    case value_t::object: {
-      std::advance(m_it.object_iterator, 1);
-      break;
-    }
-
-    case value_t::array: {
-      std::advance(m_it.array_iterator, 1);
-      break;
-    }
-
-    case value_t::null:
-    case value_t::string:
-    case value_t::boolean:
-    case value_t::number_integer:
-    case value_t::number_unsigned:
-    case value_t::number_float:
-    case value_t::binary:
-    case value_t::discarded:
-    default: {
-      ++m_it.primitive_iterator;
-      break;
-    }
-    }
-
-    return *this;
-  }
-
-  /*!
-  @brief post-decrement (it--)
-  @pre The iterator is initialized; i.e. `m_object != nullptr`.
-  */
-  iter_impl operator--(int) & // NOLINT(cert-dcl21-cpp)
-  {
-    auto result = *this;
-    --(*this);
-    return result;
-  }
-
-  /*!
-  @brief pre-decrement (--it)
-  @pre The iterator is initialized; i.e. `m_object != nullptr`.
-  */
-  iter_impl &operator--() {
-    JSON_ASSERT(m_object != nullptr);
-
-    switch (m_object->m_data.m_type) {
-    case value_t::object: {
-      std::advance(m_it.object_iterator, -1);
-      break;
-    }
-
-    case value_t::array: {
-      std::advance(m_it.array_iterator, -1);
-      break;
-    }
-
-    case value_t::null:
-    case value_t::string:
-    case value_t::boolean:
-    case value_t::number_integer:
-    case value_t::number_unsigned:
-    case value_t::number_float:
-    case value_t::binary:
-    case value_t::discarded:
-    default: {
-      --m_it.primitive_iterator;
-      break;
-    }
-    }
-
-    return *this;
-  }
-
-  /*!
-  @brief comparison: equal
-  @pre (1) Both iterators are initialized to point to the same object, or (2)
-  both iterators are value-initialized.
-  */
-  template <
-      typename IterImpl,
-      detail::enable_if_t<(std::is_same<IterImpl, iter_impl>::value ||
-                           std::is_same<IterImpl, other_iter_impl>::value),
-                          std::nullptr_t> = nullptr>
-  bool operator==(const IterImpl &other) const {
-    // if objects are not the same, the comparison is undefined
-    if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object)) {
-      JSON_THROW(invalid_iterator::create(
-          212, "cannot compare iterators of different containers", m_object));
-    }
-
-    // value-initialized forward iterators can be compared, and must compare
-    // equal to other value-initialized iterators of the same type #4493
-    if (m_object == nullptr) {
-      return true;
-    }
-
-    switch (m_object->m_data.m_type) {
-    case value_t::object:
-      return (m_it.object_iterator == other.m_it.object_iterator);
-
-    case value_t::array:
-      return (m_it.array_iterator == other.m_it.array_iterator);
-
-    case value_t::null:
-    case value_t::string:
-    case value_t::boolean:
-    case value_t::number_integer:
-    case value_t::number_unsigned:
-    case value_t::number_float:
-    case value_t::binary:
-    case value_t::discarded:
-    default:
-      return (m_it.primitive_iterator == other.m_it.primitive_iterator);
-    }
-  }
-
-  /*!
-  @brief comparison: not equal
-  @pre (1) Both iterators are initialized to point to the same object, or (2)
-  both iterators are value-initialized.
-  */
-  template <
-      typename IterImpl,
-      detail::enable_if_t<(std::is_same<IterImpl, iter_impl>::value ||
-                           std::is_same<IterImpl, other_iter_impl>::value),
-                          std::nullptr_t> = nullptr>
-  bool operator!=(const IterImpl &other) const {
-    return !operator==(other);
-  }
-
-  /*!
-  @brief comparison: smaller
-  @pre (1) Both iterators are initialized to point to the same object, or (2)
-  both iterators are value-initialized.
-  */
-  bool operator<(const iter_impl &other) const {
-    // if objects are not the same, the comparison is undefined
-    if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object)) {
-      JSON_THROW(invalid_iterator::create(
-          212, "cannot compare iterators of different containers", m_object));
-    }
-
-    // value-initialized forward iterators can be compared, and must compare
-    // equal to other value-initialized iterators of the same type #4493
-    if (m_object == nullptr) {
-      // the iterators are both value-initialized and are to be considered
-      // equal, but this function checks for smaller, so we return false
-      return false;
-    }
-
-    switch (m_object->m_data.m_type) {
-    case value_t::object:
-      JSON_THROW(invalid_iterator::create(
-          213, "cannot compare order of object iterators", m_object));
-
-    case value_t::array:
-      return (m_it.array_iterator < other.m_it.array_iterator);
-
-    case value_t::null:
-    case value_t::string:
-    case value_t::boolean:
-    case value_t::number_integer:
-    case value_t::number_unsigned:
-    case value_t::number_float:
-    case value_t::binary:
-    case value_t::discarded:
-    default:
-      return (m_it.primitive_iterator < other.m_it.primitive_iterator);
-    }
-  }
-
-  /*!
-  @brief comparison: less than or equal
-  @pre (1) Both iterators are initialized to point to the same object, or (2)
-  both iterators are value-initialized.
-  */
-  bool operator<=(const iter_impl &other) const {
-    return !other.operator<(*this);
-  }
-
-  /*!
-  @brief comparison: greater than
-  @pre (1) Both iterators are initialized to point to the same object, or (2)
-  both iterators are value-initialized.
-  */
-  bool operator>(const iter_impl &other) const { return !operator<=(other); }
-
-  /*!
-  @brief comparison: greater than or equal
-  @pre (1) The iterator is initialized; i.e. `m_object != nullptr`, or (2) both
-  iterators are value-initialized.
-  */
-  bool operator>=(const iter_impl &other) const { return !operator<(other); }
-
-  /*!
-  @brief add to iterator
-  @pre The iterator is initialized; i.e. `m_object != nullptr`.
-  */
-  iter_impl &operator+=(difference_type i) {
-    JSON_ASSERT(m_object != nullptr);
-
-    switch (m_object->m_data.m_type) {
-    case value_t::object:
-      JSON_THROW(invalid_iterator::create(
-          209, "cannot use offsets with object iterators", m_object));
-
-    case value_t::array: {
-      std::advance(m_it.array_iterator, i);
-      break;
-    }
-
-    case value_t::null:
-    case value_t::string:
-    case value_t::boolean:
-    case value_t::number_integer:
-    case value_t::number_unsigned:
-    case value_t::number_float:
-    case value_t::binary:
-    case value_t::discarded:
-    default: {
-      m_it.primitive_iterator += i;
-      break;
-    }
-    }
-
-    return *this;
-  }
-
-  /*!
-  @brief subtract from iterator
-  @pre The iterator is initialized; i.e. `m_object != nullptr`.
-  */
-  iter_impl &operator-=(difference_type i) { return operator+=(-i); }
-
-  /*!
-  @brief add to iterator
-  @pre The iterator is initialized; i.e. `m_object != nullptr`.
-  */
-  iter_impl operator+(difference_type i) const {
-    auto result = *this;
-    result += i;
-    return result;
-  }
-
-  /*!
-  @brief addition of distance and iterator
-  @pre The iterator is initialized; i.e. `m_object != nullptr`.
-  */
-  friend iter_impl operator+(difference_type i, const iter_impl &it) {
-    auto result = it;
-    result += i;
-    return result;
-  }
-
-  /*!
-  @brief subtract from iterator
-  @pre The iterator is initialized; i.e. `m_object != nullptr`.
-  */
-  iter_impl operator-(difference_type i) const {
-    auto result = *this;
-    result -= i;
-    return result;
-  }
-
-  /*!
-  @brief return difference
-  @pre The iterator is initialized; i.e. `m_object != nullptr`.
-  */
-  difference_type operator-(const iter_impl &other) const {
-    JSON_ASSERT(m_object != nullptr);
-
-    switch (m_object->m_data.m_type) {
-    case value_t::object:
-      JSON_THROW(invalid_iterator::create(
-          209, "cannot use offsets with object iterators", m_object));
-
-    case value_t::array:
-      return m_it.array_iterator - other.m_it.array_iterator;
-
-    case value_t::null:
-    case value_t::string:
-    case value_t::boolean:
-    case value_t::number_integer:
-    case value_t::number_unsigned:
-    case value_t::number_float:
-    case value_t::binary:
-    case value_t::discarded:
-    default:
-      return m_it.primitive_iterator - other.m_it.primitive_iterator;
-    }
-  }
-
-  /*!
-  @brief access to successor
-  @pre The iterator is initialized; i.e. `m_object != nullptr`.
-  */
-  reference operator[](difference_type n) const {
-    JSON_ASSERT(m_object != nullptr);
-
-    switch (m_object->m_data.m_type) {
-    case value_t::object:
-      JSON_THROW(invalid_iterator::create(
-          208, "cannot use operator[] for object iterators", m_object));
-
-    case value_t::array:
-      return *std::next(m_it.array_iterator, n);
-
-    case value_t::null:
-      JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
-
-    case value_t::string:
-    case value_t::boolean:
-    case value_t::number_integer:
-    case value_t::number_unsigned:
-    case value_t::number_float:
-    case value_t::binary:
-    case value_t::discarded:
-    default: {
-      if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n)) {
-        return *m_object;
-      }
-
-      JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
-    }
-    }
-  }
-
-  /*!
-  @brief return the key of an object iterator
-  @pre The iterator is initialized; i.e. `m_object != nullptr`.
-  */
-  const typename object_t::key_type &key() const {
-    JSON_ASSERT(m_object != nullptr);
-
-    if (JSON_HEDLEY_LIKELY(m_object->is_object())) {
-      return m_it.object_iterator->first;
-    }
-
-    JSON_THROW(invalid_iterator::create(
-        207, "cannot use key() for non-object iterators", m_object));
-  }
-
-  /*!
-  @brief return the value of an iterator
-  @pre The iterator is initialized; i.e. `m_object != nullptr`.
-  */
-  reference value() const { return operator*(); }
-
-  JSON_PRIVATE_UNLESS_TESTED :
-      /// associated JSON instance
-      pointer m_object = nullptr;
-  /// the actual iterator of the associated instance
-  internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it{};
-};
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
-
-// #include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <cstddef>  // ptrdiff_t
-#include <iterator> // reverse_iterator
-#include <utility>  // declval
-
-// #include <nlohmann/detail/abi_macros.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-//////////////////////
-// reverse_iterator //
-//////////////////////
-
-/*!
-@brief a template for a reverse iterator class
-
-@tparam Base the base iterator type to reverse. Valid types are @ref
-iterator (to create @ref reverse_iterator) and @ref const_iterator (to
-create @ref const_reverse_iterator).
-
-@requirement The class satisfies the following concept requirements:
--
-[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
-  The iterator that can be moved can be moved in both directions (i.e.
-  incremented and decremented).
-- [OutputIterator](https://en.cppreference.com/w/cpp/named_req/OutputIterator):
-  It is possible to write to the pointed-to element (only if @a Base is
-  @ref iterator).
-
-@since version 1.0.0
-*/
-template <typename Base>
-class json_reverse_iterator : public std::reverse_iterator<Base> {
-public:
-  using difference_type = std::ptrdiff_t;
-  /// shortcut to the reverse iterator adapter
-  using base_iterator = std::reverse_iterator<Base>;
-  /// the reference type for the pointed-to element
-  using reference = typename Base::reference;
-
-  /// create reverse iterator from iterator
-  explicit json_reverse_iterator(
-      const typename base_iterator::iterator_type &it) noexcept
-      : base_iterator(it) {}
-
-  /// create reverse iterator from base class
-  explicit json_reverse_iterator(const base_iterator &it) noexcept
-      : base_iterator(it) {}
-
-  /// post-increment (it++)
-  json_reverse_iterator operator++(int) & // NOLINT(cert-dcl21-cpp)
-  {
-    return static_cast<json_reverse_iterator>(base_iterator::operator++(1));
-  }
-
-  /// pre-increment (++it)
-  json_reverse_iterator &operator++() {
-    return static_cast<json_reverse_iterator &>(base_iterator::operator++());
-  }
-
-  /// post-decrement (it--)
-  json_reverse_iterator operator--(int) & // NOLINT(cert-dcl21-cpp)
-  {
-    return static_cast<json_reverse_iterator>(base_iterator::operator--(1));
-  }
-
-  /// pre-decrement (--it)
-  json_reverse_iterator &operator--() {
-    return static_cast<json_reverse_iterator &>(base_iterator::operator--());
-  }
-
-  /// add to iterator
-  json_reverse_iterator &operator+=(difference_type i) {
-    return static_cast<json_reverse_iterator &>(base_iterator::operator+=(i));
-  }
-
-  /// add to iterator
-  json_reverse_iterator operator+(difference_type i) const {
-    return static_cast<json_reverse_iterator>(base_iterator::operator+(i));
-  }
-
-  /// subtract from iterator
-  json_reverse_iterator operator-(difference_type i) const {
-    return static_cast<json_reverse_iterator>(base_iterator::operator-(i));
-  }
-
-  /// return difference
-  difference_type operator-(const json_reverse_iterator &other) const {
-    return base_iterator(*this) - base_iterator(other);
-  }
-
-  /// access to successor
-  reference operator[](difference_type n) const {
-    return *(this->operator+(n));
-  }
-
-  /// return the key of an object iterator
-  auto key() const -> decltype(std::declval<Base>().key()) {
-    auto it = --this->base();
-    return it.key();
-  }
-
-  /// return the value of an iterator
-  reference value() const {
-    auto it = --this->base();
-    return it.operator*();
-  }
-};
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
-
-// #include <nlohmann/detail/json_custom_base_class.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <type_traits> // conditional, is_same
-
-// #include <nlohmann/detail/abi_macros.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-/*!
-@brief Default base class of the @ref basic_json class.
-
-So that the correct implementations of the copy / move ctors / assign operators
-of @ref basic_json do not require complex case distinctions
-(no base class / custom base class used as customization point),
-@ref basic_json always has a base class.
-By default, this class is used because it is empty and thus has no effect
-on the behavior of @ref basic_json.
-*/
-struct json_default_base {};
-
-template <class T>
-using json_base_class = typename std::conditional<std::is_same<T, void>::value,
-                                                  json_default_base, T>::type;
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/json_pointer.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <algorithm> // all_of
-#include <cctype>    // isdigit
-#include <cerrno>    // errno, ERANGE
-#include <cstdlib>   // strtoull
-#ifndef JSON_NO_IO
-#include <iosfwd>  // ostream
-#endif             // JSON_NO_IO
-#include <limits>  // max
-#include <numeric> // accumulate
-#include <string>  // string
-#include <utility> // move
-#include <vector>  // vector
-
-// #include <nlohmann/detail/exceptions.hpp>
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/string_concat.hpp>
-
-// #include <nlohmann/detail/string_escape.hpp>
-
-// #include <nlohmann/detail/value_t.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-
-/// @brief JSON Pointer defines a string syntax for identifying a specific value
-/// within a JSON document
-/// @sa https://json.nlohmann.me/api/json_pointer/
-template <typename RefStringType> class json_pointer {
-  // allow basic_json to access private members
-  NLOHMANN_BASIC_JSON_TPL_DECLARATION
-  friend class basic_json;
-
-  template <typename> friend class json_pointer;
-
-  template <typename T> struct string_t_helper {
-    using type = T;
-  };
-
-  NLOHMANN_BASIC_JSON_TPL_DECLARATION
-  struct string_t_helper<NLOHMANN_BASIC_JSON_TPL> {
-    using type = StringType;
-  };
-
-public:
-  // for backwards compatibility accept BasicJsonType
-  using string_t = typename string_t_helper<RefStringType>::type;
-
-  /// @brief create JSON pointer
-  /// @sa https://json.nlohmann.me/api/json_pointer/json_pointer/
-  explicit json_pointer(const string_t &s = "") : reference_tokens(split(s)) {}
-
-  /// @brief return a string representation of the JSON pointer
-  /// @sa https://json.nlohmann.me/api/json_pointer/to_string/
-  string_t to_string() const {
-    return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
-                           string_t{},
-                           [](const string_t &a, const string_t &b) {
-                             return detail::concat(a, '/', detail::escape(b));
-                           });
-  }
-
-  /// @brief return a string representation of the JSON pointer
-  /// @sa https://json.nlohmann.me/api/json_pointer/operator_string/
-  JSON_HEDLEY_DEPRECATED_FOR(3.11.0, to_string())
-  operator string_t() const { return to_string(); }
-
-#ifndef JSON_NO_IO
-  /// @brief write string representation of the JSON pointer to stream
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
-  friend std::ostream &operator<<(std::ostream &o, const json_pointer &ptr) {
-    o << ptr.to_string();
-    return o;
-  }
-#endif
-
-  /// @brief append another JSON pointer at the end of this JSON pointer
-  /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
-  json_pointer &operator/=(const json_pointer &ptr) {
-    reference_tokens.insert(reference_tokens.end(),
-                            ptr.reference_tokens.begin(),
-                            ptr.reference_tokens.end());
-    return *this;
-  }
-
-  /// @brief append an unescaped reference token at the end of this JSON pointer
-  /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
-  json_pointer &operator/=(string_t token) {
-    push_back(std::move(token));
-    return *this;
-  }
-
-  /// @brief append an array index at the end of this JSON pointer
-  /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
-  json_pointer &operator/=(std::size_t array_idx) {
-    return *this /= std::to_string(array_idx);
-  }
-
-  /// @brief create a new JSON pointer by appending the right JSON pointer at
-  /// the end of the left JSON pointer
-  /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
-  friend json_pointer operator/(const json_pointer &lhs,
-                                const json_pointer &rhs) {
-    return json_pointer(lhs) /= rhs;
-  }
-
-  /// @brief create a new JSON pointer by appending the unescaped token at the
-  /// end of the JSON pointer
-  /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
-  friend json_pointer
-  operator/(const json_pointer &lhs,
-            string_t token) // NOLINT(performance-unnecessary-value-param)
-  {
-    return json_pointer(lhs) /= std::move(token);
-  }
-
-  /// @brief create a new JSON pointer by appending the array-index-token at the
-  /// end of the JSON pointer
-  /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
-  friend json_pointer operator/(const json_pointer &lhs,
-                                std::size_t array_idx) {
-    return json_pointer(lhs) /= array_idx;
-  }
-
-  /// @brief returns the parent of this JSON pointer
-  /// @sa https://json.nlohmann.me/api/json_pointer/parent_pointer/
-  json_pointer parent_pointer() const {
-    if (empty()) {
-      return *this;
-    }
-
-    json_pointer res = *this;
-    res.pop_back();
-    return res;
-  }
-
-  /// @brief remove last reference token
-  /// @sa https://json.nlohmann.me/api/json_pointer/pop_back/
-  void pop_back() {
-    if (JSON_HEDLEY_UNLIKELY(empty())) {
-      JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent",
-                                              nullptr));
-    }
-
-    reference_tokens.pop_back();
-  }
-
-  /// @brief return last reference token
-  /// @sa https://json.nlohmann.me/api/json_pointer/back/
-  const string_t &back() const {
-    if (JSON_HEDLEY_UNLIKELY(empty())) {
-      JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent",
-                                              nullptr));
-    }
-
-    return reference_tokens.back();
-  }
-
-  /// @brief append an unescaped token at the end of the reference pointer
-  /// @sa https://json.nlohmann.me/api/json_pointer/push_back/
-  void push_back(const string_t &token) { reference_tokens.push_back(token); }
-
-  /// @brief append an unescaped token at the end of the reference pointer
-  /// @sa https://json.nlohmann.me/api/json_pointer/push_back/
-  void push_back(string_t &&token) {
-    reference_tokens.push_back(std::move(token));
-  }
-
-  /// @brief return whether pointer points to the root document
-  /// @sa https://json.nlohmann.me/api/json_pointer/empty/
-  bool empty() const noexcept { return reference_tokens.empty(); }
-
-private:
-  /*!
-  @param[in] s  reference token to be converted into an array index
-
-  @return integer representation of @a s
-
-  @throw parse_error.106  if an array index begins with '0'
-  @throw parse_error.109  if an array index begins not with a digit
-  @throw out_of_range.404 if string @a s could not be converted to an integer
-  @throw out_of_range.410 if an array index exceeds size_type
-  */
-  template <typename BasicJsonType>
-  static typename BasicJsonType::size_type array_index(const string_t &s) {
-    using size_type = typename BasicJsonType::size_type;
-
-    // error condition (cf. RFC 6901, Sect. 4)
-    if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0')) {
-      JSON_THROW(detail::parse_error::create(
-          106, 0,
-          detail::concat("array index '", s, "' must not begin with '0'"),
-          nullptr));
-    }
-
-    // error condition (cf. RFC 6901, Sect. 4)
-    if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9'))) {
-      JSON_THROW(detail::parse_error::create(
-          109, 0, detail::concat("array index '", s, "' is not a number"),
-          nullptr));
-    }
-
-    const char *p = s.c_str();
-    char *p_end = nullptr;
-    errno = 0; // strtoull doesn't reset errno
-    const unsigned long long res =
-        std::strtoull(p, &p_end, 10); // NOLINT(runtime/int)
-    if (p == p_end                    // invalid input or empty string
-        || errno == ERANGE            // out of range
-        || JSON_HEDLEY_UNLIKELY(static_cast<std::size_t>(p_end - p) !=
-                                s.size())) // incomplete read
-    {
-      JSON_THROW(detail::out_of_range::create(
-          404, detail::concat("unresolved reference token '", s, "'"),
-          nullptr));
-    }
-
-    // only triggered on special platforms (like 32bit), see also
-    // https://github.com/nlohmann/json/pull/2203
-    if (res >=
-        static_cast<unsigned long long>(
-            (std::numeric_limits<size_type>::max)())) // NOLINT(runtime/int)
-    {
-      JSON_THROW(detail::out_of_range::create(
-          410, detail::concat("array index ", s, " exceeds size_type"),
-          nullptr)); // LCOV_EXCL_LINE
-    }
-
-    return static_cast<size_type>(res);
-  }
-
-  JSON_PRIVATE_UNLESS_TESTED : json_pointer top() const {
-    if (JSON_HEDLEY_UNLIKELY(empty())) {
-      JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent",
-                                              nullptr));
-    }
-
-    json_pointer result = *this;
-    result.reference_tokens = {reference_tokens[0]};
-    return result;
-  }
-
-private:
-  /*!
-  @brief create and return a reference to the pointed to value
-
-  @complexity Linear in the number of reference tokens.
-
-  @throw parse_error.109 if array index is not a number
-  @throw type_error.313 if value cannot be unflattened
-  */
-  template <typename BasicJsonType>
-  BasicJsonType &get_and_create(BasicJsonType &j) const {
-    auto *result = &j;
-
-    // in case no reference tokens exist, return a reference to the JSON value
-    // j which will be overwritten by a primitive value
-    for (const auto &reference_token : reference_tokens) {
-      switch (result->type()) {
-      case detail::value_t::null: {
-        if (reference_token == "0") {
-          // start a new array if reference token is 0
-          result = &result->operator[](0);
-        } else {
-          // start a new object otherwise
-          result = &result->operator[](reference_token);
-        }
-        break;
-      }
-
-      case detail::value_t::object: {
-        // create an entry in the object
-        result = &result->operator[](reference_token);
-        break;
-      }
-
-      case detail::value_t::array: {
-        // create an entry in the array
-        result =
-            &result->operator[](array_index<BasicJsonType>(reference_token));
-        break;
-      }
-
-      /*
-      The following code is only reached if there exists a reference
-      token _and_ the current value is primitive. In this case, we have
-      an error situation, because primitive values may only occur as
-      single value; that is, with an empty list of reference tokens.
-      */
-      case detail::value_t::string:
-      case detail::value_t::boolean:
-      case detail::value_t::number_integer:
-      case detail::value_t::number_unsigned:
-      case detail::value_t::number_float:
-      case detail::value_t::binary:
-      case detail::value_t::discarded:
-      default:
-        JSON_THROW(
-            detail::type_error::create(313, "invalid value to unflatten", &j));
-      }
-    }
-
-    return *result;
-  }
-
-  /*!
-  @brief return a reference to the pointed to value
-
-  @note This version does not throw if a value is not present, but tries to
-        create nested values instead. For instance, calling this function
-        with pointer `"/this/that"` on a null value is equivalent to calling
-        `operator[]("this").operator[]("that")` on that value, effectively
-        changing the null value to an object.
-
-  @param[in] ptr  a JSON value
-
-  @return reference to the JSON value pointed to by the JSON pointer
-
-  @complexity Linear in the length of the JSON pointer.
-
-  @throw parse_error.106   if an array index begins with '0'
-  @throw parse_error.109   if an array index was not a number
-  @throw out_of_range.404  if the JSON pointer can not be resolved
-  */
-  template <typename BasicJsonType>
-  BasicJsonType &get_unchecked(BasicJsonType *ptr) const {
-    for (const auto &reference_token : reference_tokens) {
-      // convert null values to arrays or objects before continuing
-      if (ptr->is_null()) {
-        // check if reference token is a number
-        const bool nums =
-            std::all_of(reference_token.begin(), reference_token.end(),
-                        [](const unsigned char x) { return std::isdigit(x); });
-
-        // change value to array for numbers or "-" or to object otherwise
-        *ptr = (nums || reference_token == "-") ? detail::value_t::array
-                                                : detail::value_t::object;
-      }
-
-      switch (ptr->type()) {
-      case detail::value_t::object: {
-        // use unchecked object access
-        ptr = &ptr->operator[](reference_token);
-        break;
-      }
-
-      case detail::value_t::array: {
-        if (reference_token == "-") {
-          // explicitly treat "-" as index beyond the end
-          ptr = &ptr->operator[](ptr->m_data.m_value.array->size());
-        } else {
-          // convert array index to number; unchecked access
-          ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));
-        }
-        break;
-      }
-
-      case detail::value_t::null:
-      case detail::value_t::string:
-      case detail::value_t::boolean:
-      case detail::value_t::number_integer:
-      case detail::value_t::number_unsigned:
-      case detail::value_t::number_float:
-      case detail::value_t::binary:
-      case detail::value_t::discarded:
-      default:
-        JSON_THROW(detail::out_of_range::create(
-            404,
-            detail::concat("unresolved reference token '", reference_token,
-                           "'"),
-            ptr));
-      }
-    }
-
-    return *ptr;
-  }
-
-  /*!
-  @throw parse_error.106   if an array index begins with '0'
-  @throw parse_error.109   if an array index was not a number
-  @throw out_of_range.402  if the array index '-' is used
-  @throw out_of_range.404  if the JSON pointer can not be resolved
-  */
-  template <typename BasicJsonType>
-  BasicJsonType &get_checked(BasicJsonType *ptr) const {
-    for (const auto &reference_token : reference_tokens) {
-      switch (ptr->type()) {
-      case detail::value_t::object: {
-        // note: at performs range check
-        ptr = &ptr->at(reference_token);
-        break;
-      }
-
-      case detail::value_t::array: {
-        if (JSON_HEDLEY_UNLIKELY(reference_token == "-")) {
-          // "-" always fails the range check
-          JSON_THROW(detail::out_of_range::create(
-              402,
-              detail::concat("array index '-' (",
-                             std::to_string(ptr->m_data.m_value.array->size()),
-                             ") is out of range"),
-              ptr));
-        }
-
-        // note: at performs range check
-        ptr = &ptr->at(array_index<BasicJsonType>(reference_token));
-        break;
-      }
-
-      case detail::value_t::null:
-      case detail::value_t::string:
-      case detail::value_t::boolean:
-      case detail::value_t::number_integer:
-      case detail::value_t::number_unsigned:
-      case detail::value_t::number_float:
-      case detail::value_t::binary:
-      case detail::value_t::discarded:
-      default:
-        JSON_THROW(detail::out_of_range::create(
-            404,
-            detail::concat("unresolved reference token '", reference_token,
-                           "'"),
-            ptr));
-      }
-    }
-
-    return *ptr;
-  }
-
-  /*!
-  @brief return a const reference to the pointed to value
-
-  @param[in] ptr  a JSON value
-
-  @return const reference to the JSON value pointed to by the JSON
-  pointer
-
-  @throw parse_error.106   if an array index begins with '0'
-  @throw parse_error.109   if an array index was not a number
-  @throw out_of_range.402  if the array index '-' is used
-  @throw out_of_range.404  if the JSON pointer can not be resolved
-  */
-  template <typename BasicJsonType>
-  const BasicJsonType &get_unchecked(const BasicJsonType *ptr) const {
-    for (const auto &reference_token : reference_tokens) {
-      switch (ptr->type()) {
-      case detail::value_t::object: {
-        // use unchecked object access
-        ptr = &ptr->operator[](reference_token);
-        break;
-      }
-
-      case detail::value_t::array: {
-        if (JSON_HEDLEY_UNLIKELY(reference_token == "-")) {
-          // "-" cannot be used for const access
-          JSON_THROW(detail::out_of_range::create(
-              402,
-              detail::concat("array index '-' (",
-                             std::to_string(ptr->m_data.m_value.array->size()),
-                             ") is out of range"),
-              ptr));
-        }
-
-        // use unchecked array access
-        ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));
-        break;
-      }
-
-      case detail::value_t::null:
-      case detail::value_t::string:
-      case detail::value_t::boolean:
-      case detail::value_t::number_integer:
-      case detail::value_t::number_unsigned:
-      case detail::value_t::number_float:
-      case detail::value_t::binary:
-      case detail::value_t::discarded:
-      default:
-        JSON_THROW(detail::out_of_range::create(
-            404,
-            detail::concat("unresolved reference token '", reference_token,
-                           "'"),
-            ptr));
-      }
-    }
-
-    return *ptr;
-  }
-
-  /*!
-  @throw parse_error.106   if an array index begins with '0'
-  @throw parse_error.109   if an array index was not a number
-  @throw out_of_range.402  if the array index '-' is used
-  @throw out_of_range.404  if the JSON pointer can not be resolved
-  */
-  template <typename BasicJsonType>
-  const BasicJsonType &get_checked(const BasicJsonType *ptr) const {
-    for (const auto &reference_token : reference_tokens) {
-      switch (ptr->type()) {
-      case detail::value_t::object: {
-        // note: at performs range check
-        ptr = &ptr->at(reference_token);
-        break;
-      }
-
-      case detail::value_t::array: {
-        if (JSON_HEDLEY_UNLIKELY(reference_token == "-")) {
-          // "-" always fails the range check
-          JSON_THROW(detail::out_of_range::create(
-              402,
-              detail::concat("array index '-' (",
-                             std::to_string(ptr->m_data.m_value.array->size()),
-                             ") is out of range"),
-              ptr));
-        }
-
-        // note: at performs range check
-        ptr = &ptr->at(array_index<BasicJsonType>(reference_token));
-        break;
-      }
-
-      case detail::value_t::null:
-      case detail::value_t::string:
-      case detail::value_t::boolean:
-      case detail::value_t::number_integer:
-      case detail::value_t::number_unsigned:
-      case detail::value_t::number_float:
-      case detail::value_t::binary:
-      case detail::value_t::discarded:
-      default:
-        JSON_THROW(detail::out_of_range::create(
-            404,
-            detail::concat("unresolved reference token '", reference_token,
-                           "'"),
-            ptr));
-      }
-    }
-
-    return *ptr;
-  }
-
-  /*!
-  @throw parse_error.106   if an array index begins with '0'
-  @throw parse_error.109   if an array index was not a number
-  */
-  template <typename BasicJsonType>
-  bool contains(const BasicJsonType *ptr) const {
-    for (const auto &reference_token : reference_tokens) {
-      switch (ptr->type()) {
-      case detail::value_t::object: {
-        if (!ptr->contains(reference_token)) {
-          // we did not find the key in the object
-          return false;
-        }
-
-        ptr = &ptr->operator[](reference_token);
-        break;
-      }
-
-      case detail::value_t::array: {
-        if (JSON_HEDLEY_UNLIKELY(reference_token == "-")) {
-          // "-" always fails the range check
-          return false;
-        }
-        if (JSON_HEDLEY_UNLIKELY(
-                reference_token.size() == 1 &&
-                !("0" <= reference_token && reference_token <= "9"))) {
-          // invalid char
-          return false;
-        }
-        if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1)) {
-          if (JSON_HEDLEY_UNLIKELY(
-                  !('1' <= reference_token[0] && reference_token[0] <= '9'))) {
-            // first char should be between '1' and '9'
-            return false;
-          }
-          for (std::size_t i = 1; i < reference_token.size(); i++) {
-            if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] &&
-                                       reference_token[i] <= '9'))) {
-              // other char should be between '0' and '9'
-              return false;
-            }
-          }
-        }
-
-        const auto idx = array_index<BasicJsonType>(reference_token);
-        if (idx >= ptr->size()) {
-          // index out of range
-          return false;
-        }
-
-        ptr = &ptr->operator[](idx);
-        break;
-      }
-
-      case detail::value_t::null:
-      case detail::value_t::string:
-      case detail::value_t::boolean:
-      case detail::value_t::number_integer:
-      case detail::value_t::number_unsigned:
-      case detail::value_t::number_float:
-      case detail::value_t::binary:
-      case detail::value_t::discarded:
-      default: {
-        // we do not expect primitive values if there is still a
-        // reference token to process
-        return false;
-      }
-      }
-    }
-
-    // no reference token left means we found a primitive value
-    return true;
-  }
-
-  /*!
-  @brief split the string input to reference tokens
-
-  @note This function is only called by the json_pointer constructor.
-        All exceptions below are documented there.
-
-  @throw parse_error.107  if the pointer is not empty or begins with '/'
-  @throw parse_error.108  if character '~' is not followed by '0' or '1'
-  */
-  static std::vector<string_t> split(const string_t &reference_string) {
-    std::vector<string_t> result;
-
-    // special case: empty reference string -> no reference tokens
-    if (reference_string.empty()) {
-      return result;
-    }
-
-    // check if nonempty reference string begins with slash
-    if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/')) {
-      JSON_THROW(detail::parse_error::create(
-          107, 1,
-          detail::concat(
-              "JSON pointer must be empty or begin with '/' - was: '",
-              reference_string, "'"),
-          nullptr));
-    }
-
-    // extract the reference tokens:
-    // - slash: position of the last read slash (or end of string)
-    // - start: position after the previous slash
-    for (
-        // search for the first slash after the first character
-        std::size_t slash = reference_string.find_first_of('/', 1),
-                    // set the beginning of the first reference token
-        start = 1;
-        // we can stop if start == 0 (if slash == string_t::npos)
-        start != 0;
-        // set the beginning of the next reference token
-        // (will eventually be 0 if slash == string_t::npos)
-        start = (slash == string_t::npos) ? 0 : slash + 1,
-                    // find next slash
-        slash = reference_string.find_first_of('/', start)) {
-      // use the text between the beginning of the reference token
-      // (start) and the last slash (slash).
-      auto reference_token = reference_string.substr(start, slash - start);
-
-      // check reference tokens are properly escaped
-      for (std::size_t pos = reference_token.find_first_of('~');
-           pos != string_t::npos;
-           pos = reference_token.find_first_of('~', pos + 1)) {
-        JSON_ASSERT(reference_token[pos] == '~');
-
-        // ~ must be followed by 0 or 1
-        if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
-                                 (reference_token[pos + 1] != '0' &&
-                                  reference_token[pos + 1] != '1'))) {
-          JSON_THROW(detail::parse_error::create(
-              108, 0, "escape character '~' must be followed with '0' or '1'",
-              nullptr));
-        }
-      }
-
-      // finally, store the reference token
-      detail::unescape(reference_token);
-      result.push_back(reference_token);
-    }
-
-    return result;
-  }
-
-private:
-  /*!
-  @param[in] reference_string  the reference string to the current value
-  @param[in] value             the value to consider
-  @param[in,out] result        the result object to insert values to
-
-  @note Empty objects or arrays are flattened to `null`.
-  */
-  template <typename BasicJsonType>
-  static void flatten(const string_t &reference_string,
-                      const BasicJsonType &value, BasicJsonType &result) {
-    switch (value.type()) {
-    case detail::value_t::array: {
-      if (value.m_data.m_value.array->empty()) {
-        // flatten empty array as null
-        result[reference_string] = nullptr;
-      } else {
-        // iterate array and use index as reference string
-        for (std::size_t i = 0; i < value.m_data.m_value.array->size(); ++i) {
-          flatten(detail::concat(reference_string, '/', std::to_string(i)),
-                  value.m_data.m_value.array->operator[](i), result);
-        }
-      }
-      break;
-    }
-
-    case detail::value_t::object: {
-      if (value.m_data.m_value.object->empty()) {
-        // flatten empty object as null
-        result[reference_string] = nullptr;
-      } else {
-        // iterate object and use keys as reference string
-        for (const auto &element : *value.m_data.m_value.object) {
-          flatten(detail::concat(reference_string, '/',
-                                 detail::escape(element.first)),
-                  element.second, result);
-        }
-      }
-      break;
-    }
-
-    case detail::value_t::null:
-    case detail::value_t::string:
-    case detail::value_t::boolean:
-    case detail::value_t::number_integer:
-    case detail::value_t::number_unsigned:
-    case detail::value_t::number_float:
-    case detail::value_t::binary:
-    case detail::value_t::discarded:
-    default: {
-      // add primitive value with its reference string
-      result[reference_string] = value;
-      break;
-    }
-    }
-  }
-
-  /*!
-  @param[in] value  flattened JSON
-
-  @return unflattened JSON
-
-  @throw parse_error.109 if array index is not a number
-  @throw type_error.314  if value is not an object
-  @throw type_error.315  if object values are not primitive
-  @throw type_error.313  if value cannot be unflattened
-  */
-  template <typename BasicJsonType>
-  static BasicJsonType unflatten(const BasicJsonType &value) {
-    if (JSON_HEDLEY_UNLIKELY(!value.is_object())) {
-      JSON_THROW(detail::type_error::create(
-          314, "only objects can be unflattened", &value));
-    }
-
-    BasicJsonType result;
-
-    // iterate the JSON object values
-    for (const auto &element : *value.m_data.m_value.object) {
-      if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive())) {
-        JSON_THROW(detail::type_error::create(
-            315, "values in object must be primitive", &element.second));
-      }
-
-      // assign value to reference pointed to by JSON pointer; Note that if
-      // the JSON pointer is "" (i.e., points to the whole value), function
-      // get_and_create returns a reference to result itself. An assignment
-      // will then create a primitive value.
-      json_pointer(element.first).get_and_create(result) = element.second;
-    }
-
-    return result;
-  }
-
-  // can't use conversion operator because of ambiguity
-  json_pointer<string_t> convert() const & {
-    json_pointer<string_t> result;
-    result.reference_tokens = reference_tokens;
-    return result;
-  }
-
-  json_pointer<string_t> convert() && {
-    json_pointer<string_t> result;
-    result.reference_tokens = std::move(reference_tokens);
-    return result;
-  }
-
-public:
-#if JSON_HAS_THREE_WAY_COMPARISON
-  /// @brief compares two JSON pointers for equality
-  /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
-  template <typename RefStringTypeRhs>
-  bool operator==(const json_pointer<RefStringTypeRhs> &rhs) const noexcept {
-    return reference_tokens == rhs.reference_tokens;
-  }
-
-  /// @brief compares JSON pointer and string for equality
-  /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
-  JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer))
-  bool operator==(const string_t &rhs) const {
-    return *this == json_pointer(rhs);
-  }
-
-  /// @brief 3-way compares two JSON pointers
-  template <typename RefStringTypeRhs>
-  std::strong_ordering operator<=>(
-      const json_pointer<RefStringTypeRhs> &rhs) const noexcept // *NOPAD*
-  {
-    return reference_tokens <=> rhs.reference_tokens; // *NOPAD*
-  }
-#else
-  /// @brief compares two JSON pointers for equality
-  /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
-  template <typename RefStringTypeLhs, typename RefStringTypeRhs>
-  // NOLINTNEXTLINE(readability-redundant-declaration)
-  friend bool operator==(const json_pointer<RefStringTypeLhs> &lhs,
-                         const json_pointer<RefStringTypeRhs> &rhs) noexcept;
-
-  /// @brief compares JSON pointer and string for equality
-  /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
-  template <typename RefStringTypeLhs, typename StringType>
-  // NOLINTNEXTLINE(readability-redundant-declaration)
-  friend bool operator==(const json_pointer<RefStringTypeLhs> &lhs,
-                         const StringType &rhs);
-
-  /// @brief compares string and JSON pointer for equality
-  /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
-  template <typename RefStringTypeRhs, typename StringType>
-  // NOLINTNEXTLINE(readability-redundant-declaration)
-  friend bool operator==(const StringType &lhs,
-                         const json_pointer<RefStringTypeRhs> &rhs);
-
-  /// @brief compares two JSON pointers for inequality
-  /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
-  template <typename RefStringTypeLhs, typename RefStringTypeRhs>
-  // NOLINTNEXTLINE(readability-redundant-declaration)
-  friend bool operator!=(const json_pointer<RefStringTypeLhs> &lhs,
-                         const json_pointer<RefStringTypeRhs> &rhs) noexcept;
-
-  /// @brief compares JSON pointer and string for inequality
-  /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
-  template <typename RefStringTypeLhs, typename StringType>
-  // NOLINTNEXTLINE(readability-redundant-declaration)
-  friend bool operator!=(const json_pointer<RefStringTypeLhs> &lhs,
-                         const StringType &rhs);
-
-  /// @brief compares string and JSON pointer for inequality
-  /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
-  template <typename RefStringTypeRhs, typename StringType>
-  // NOLINTNEXTLINE(readability-redundant-declaration)
-  friend bool operator!=(const StringType &lhs,
-                         const json_pointer<RefStringTypeRhs> &rhs);
-
-  /// @brief compares two JSON pointer for less-than
-  template <typename RefStringTypeLhs, typename RefStringTypeRhs>
-  // NOLINTNEXTLINE(readability-redundant-declaration)
-  friend bool operator<(const json_pointer<RefStringTypeLhs> &lhs,
-                        const json_pointer<RefStringTypeRhs> &rhs) noexcept;
-#endif
-
-private:
-  /// the reference tokens
-  std::vector<string_t> reference_tokens;
-};
-
-#if !JSON_HAS_THREE_WAY_COMPARISON
-// functions cannot be defined inside class due to ODR violations
-template <typename RefStringTypeLhs, typename RefStringTypeRhs>
-inline bool operator==(const json_pointer<RefStringTypeLhs> &lhs,
-                       const json_pointer<RefStringTypeRhs> &rhs) noexcept {
-  return lhs.reference_tokens == rhs.reference_tokens;
-}
-
-template <
-    typename RefStringTypeLhs,
-    typename StringType = typename json_pointer<RefStringTypeLhs>::string_t>
-JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
-inline bool operator==(const json_pointer<RefStringTypeLhs> &lhs,
-                       const StringType &rhs) {
-  return lhs == json_pointer<RefStringTypeLhs>(rhs);
-}
-
-template <
-    typename RefStringTypeRhs,
-    typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
-JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
-inline bool operator==(const StringType &lhs,
-                       const json_pointer<RefStringTypeRhs> &rhs) {
-  return json_pointer<RefStringTypeRhs>(lhs) == rhs;
-}
-
-template <typename RefStringTypeLhs, typename RefStringTypeRhs>
-inline bool operator!=(const json_pointer<RefStringTypeLhs> &lhs,
-                       const json_pointer<RefStringTypeRhs> &rhs) noexcept {
-  return !(lhs == rhs);
-}
-
-template <
-    typename RefStringTypeLhs,
-    typename StringType = typename json_pointer<RefStringTypeLhs>::string_t>
-JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
-inline bool operator!=(const json_pointer<RefStringTypeLhs> &lhs,
-                       const StringType &rhs) {
-  return !(lhs == rhs);
-}
-
-template <
-    typename RefStringTypeRhs,
-    typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
-JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
-inline bool operator!=(const StringType &lhs,
-                       const json_pointer<RefStringTypeRhs> &rhs) {
-  return !(lhs == rhs);
-}
-
-template <typename RefStringTypeLhs, typename RefStringTypeRhs>
-inline bool operator<(const json_pointer<RefStringTypeLhs> &lhs,
-                      const json_pointer<RefStringTypeRhs> &rhs) noexcept {
-  return lhs.reference_tokens < rhs.reference_tokens;
-}
-#endif
-
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/json_ref.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <initializer_list>
-#include <utility>
-
-// #include <nlohmann/detail/abi_macros.hpp>
-
-// #include <nlohmann/detail/meta/type_traits.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-template <typename BasicJsonType> class json_ref {
-public:
-  using value_type = BasicJsonType;
-
-  json_ref(value_type &&value) : owned_value(std::move(value)) {}
-
-  json_ref(const value_type &value) : value_ref(&value) {}
-
-  json_ref(std::initializer_list<json_ref> init) : owned_value(init) {}
-
-  template <
-      class... Args,
-      enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0>
-  json_ref(Args &&...args) : owned_value(std::forward<Args>(args)...) {}
-
-  // class should be movable only
-  json_ref(json_ref &&) noexcept = default;
-  json_ref(const json_ref &) = delete;
-  json_ref &operator=(const json_ref &) = delete;
-  json_ref &operator=(json_ref &&) = delete;
-  ~json_ref() = default;
-
-  value_type moved_or_copied() const {
-    if (value_ref == nullptr) {
-      return std::move(owned_value);
-    }
-    return *value_ref;
-  }
-
-  value_type const &operator*() const {
-    return value_ref ? *value_ref : owned_value;
-  }
-
-  value_type const *operator->() const { return &**this; }
-
-private:
-  mutable value_type owned_value = nullptr;
-  value_type const *value_ref = nullptr;
-};
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/string_concat.hpp>
-
-// #include <nlohmann/detail/string_escape.hpp>
-
-// #include <nlohmann/detail/meta/cpp_future.hpp>
-
-// #include <nlohmann/detail/meta/type_traits.hpp>
-
-// #include <nlohmann/detail/output/binary_writer.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <algorithm> // reverse
-#include <array>     // array
-#include <cmath>     // isnan, isinf
-#include <cstdint>   // uint8_t, uint16_t, uint32_t, uint64_t
-#include <cstring>   // memcpy
-#include <limits>    // numeric_limits
-#include <map>       // map
-#include <string>    // string
-#include <utility>   // move
-#include <vector>    // vector
-
-// #include <nlohmann/detail/input/binary_reader.hpp>
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/output/output_adapters.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <algorithm> // copy
-#include <cstddef>   // size_t
-#include <iterator>  // back_inserter
-#include <memory>    // shared_ptr, make_shared
-#include <string>    // basic_string
-#include <vector>    // vector
-
-#ifndef JSON_NO_IO
-#include <ios>     // streamsize
-#include <ostream> // basic_ostream
-#endif             // JSON_NO_IO
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-/// abstract output adapter interface
-template <typename CharType> struct output_adapter_protocol {
-  virtual void write_character(CharType c) = 0;
-  virtual void write_characters(const CharType *s, std::size_t length) = 0;
-  virtual ~output_adapter_protocol() = default;
-
-  output_adapter_protocol() = default;
-  output_adapter_protocol(const output_adapter_protocol &) = default;
-  output_adapter_protocol(output_adapter_protocol &&) noexcept = default;
-  output_adapter_protocol &operator=(const output_adapter_protocol &) = default;
-  output_adapter_protocol &
-  operator=(output_adapter_protocol &&) noexcept = default;
-};
-
-/// a type to simplify interfaces
-template <typename CharType>
-using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
-
-/// output adapter for byte vectors
-template <typename CharType, typename AllocatorType = std::allocator<CharType>>
-class output_vector_adapter : public output_adapter_protocol<CharType> {
-public:
-  explicit output_vector_adapter(
-      std::vector<CharType, AllocatorType> &vec) noexcept
-      : v(vec) {}
-
-  void write_character(CharType c) override { v.push_back(c); }
-
-  JSON_HEDLEY_NON_NULL(2)
-  void write_characters(const CharType *s, std::size_t length) override {
-    v.insert(v.end(), s, s + length);
-  }
-
-private:
-  std::vector<CharType, AllocatorType> &v;
-};
-
-#ifndef JSON_NO_IO
-/// output adapter for output streams
-template <typename CharType>
-class output_stream_adapter : public output_adapter_protocol<CharType> {
-public:
-  explicit output_stream_adapter(std::basic_ostream<CharType> &s) noexcept
-      : stream(s) {}
-
-  void write_character(CharType c) override { stream.put(c); }
-
-  JSON_HEDLEY_NON_NULL(2)
-  void write_characters(const CharType *s, std::size_t length) override {
-    stream.write(s, static_cast<std::streamsize>(length));
-  }
-
-private:
-  std::basic_ostream<CharType> &stream;
-};
-#endif // JSON_NO_IO
-
-/// output adapter for basic_string
-template <typename CharType, typename StringType = std::basic_string<CharType>>
-class output_string_adapter : public output_adapter_protocol<CharType> {
-public:
-  explicit output_string_adapter(StringType &s) noexcept : str(s) {}
-
-  void write_character(CharType c) override { str.push_back(c); }
-
-  JSON_HEDLEY_NON_NULL(2)
-  void write_characters(const CharType *s, std::size_t length) override {
-    str.append(s, length);
-  }
-
-private:
-  StringType &str;
-};
-
-template <typename CharType, typename StringType = std::basic_string<CharType>>
-class output_adapter {
-public:
-  template <typename AllocatorType = std::allocator<CharType>>
-  output_adapter(std::vector<CharType, AllocatorType> &vec)
-      : oa(std::make_shared<output_vector_adapter<CharType, AllocatorType>>(
-            vec)) {}
-
-#ifndef JSON_NO_IO
-  output_adapter(std::basic_ostream<CharType> &s)
-      : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
-#endif // JSON_NO_IO
-
-  output_adapter(StringType &s)
-      : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
-
-  operator output_adapter_t<CharType>() { return oa; }
-
-private:
-  output_adapter_t<CharType> oa = nullptr;
-};
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/string_concat.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-///////////////////
-// binary writer //
-///////////////////
-
-/*!
-@brief serialization to CBOR and MessagePack values
-*/
-template <typename BasicJsonType, typename CharType> class binary_writer {
-  using string_t = typename BasicJsonType::string_t;
-  using binary_t = typename BasicJsonType::binary_t;
-  using number_float_t = typename BasicJsonType::number_float_t;
-
-public:
-  /*!
-  @brief create a binary writer
-
-  @param[in] adapter  output adapter to write to
-  */
-  explicit binary_writer(output_adapter_t<CharType> adapter)
-      : oa(std::move(adapter)) {
-    JSON_ASSERT(oa);
-  }
-
-  /*!
-  @param[in] j  JSON value to serialize
-  @pre       j.type() == value_t::object
-  */
-  void write_bson(const BasicJsonType &j) {
-    switch (j.type()) {
-    case value_t::object: {
-      write_bson_object(*j.m_data.m_value.object);
-      break;
-    }
-
-    case value_t::null:
-    case value_t::array:
-    case value_t::string:
-    case value_t::boolean:
-    case value_t::number_integer:
-    case value_t::number_unsigned:
-    case value_t::number_float:
-    case value_t::binary:
-    case value_t::discarded:
-    default: {
-      JSON_THROW(type_error::create(
-          317,
-          concat("to serialize to BSON, top-level type must be object, but is ",
-                 j.type_name()),
-          &j));
-    }
-    }
-  }
-
-  /*!
-  @param[in] j  JSON value to serialize
-  */
-  void write_cbor(const BasicJsonType &j) {
-    switch (j.type()) {
-    case value_t::null: {
-      oa->write_character(to_char_type(0xF6));
-      break;
-    }
-
-    case value_t::boolean: {
-      oa->write_character(j.m_data.m_value.boolean ? to_char_type(0xF5)
-                                                   : to_char_type(0xF4));
-      break;
-    }
-
-    case value_t::number_integer: {
-      if (j.m_data.m_value.number_integer >= 0) {
-        // CBOR does not differentiate between positive signed
-        // integers and unsigned integers. Therefore, we used the
-        // code from the value_t::number_unsigned case here.
-        if (j.m_data.m_value.number_integer <= 0x17) {
-          write_number(
-              static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
-        } else if (j.m_data.m_value.number_integer <=
-                   (std::numeric_limits<std::uint8_t>::max)()) {
-          oa->write_character(to_char_type(0x18));
-          write_number(
-              static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
-        } else if (j.m_data.m_value.number_integer <=
-                   (std::numeric_limits<std::uint16_t>::max)()) {
-          oa->write_character(to_char_type(0x19));
-          write_number(
-              static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
-        } else if (j.m_data.m_value.number_integer <=
-                   (std::numeric_limits<std::uint32_t>::max)()) {
-          oa->write_character(to_char_type(0x1A));
-          write_number(
-              static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
-        } else {
-          oa->write_character(to_char_type(0x1B));
-          write_number(
-              static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
-        }
-      } else {
-        // The conversions below encode the sign in the first
-        // byte, and the value is converted to a positive number.
-        const auto positive_number = -1 - j.m_data.m_value.number_integer;
-        if (j.m_data.m_value.number_integer >= -24) {
-          write_number(static_cast<std::uint8_t>(0x20 + positive_number));
-        } else if (positive_number <=
-                   (std::numeric_limits<std::uint8_t>::max)()) {
-          oa->write_character(to_char_type(0x38));
-          write_number(static_cast<std::uint8_t>(positive_number));
-        } else if (positive_number <=
-                   (std::numeric_limits<std::uint16_t>::max)()) {
-          oa->write_character(to_char_type(0x39));
-          write_number(static_cast<std::uint16_t>(positive_number));
-        } else if (positive_number <=
-                   (std::numeric_limits<std::uint32_t>::max)()) {
-          oa->write_character(to_char_type(0x3A));
-          write_number(static_cast<std::uint32_t>(positive_number));
-        } else {
-          oa->write_character(to_char_type(0x3B));
-          write_number(static_cast<std::uint64_t>(positive_number));
-        }
-      }
-      break;
-    }
-
-    case value_t::number_unsigned: {
-      if (j.m_data.m_value.number_unsigned <= 0x17) {
-        write_number(
-            static_cast<std::uint8_t>(j.m_data.m_value.number_unsigned));
-      } else if (j.m_data.m_value.number_unsigned <=
-                 (std::numeric_limits<std::uint8_t>::max)()) {
-        oa->write_character(to_char_type(0x18));
-        write_number(
-            static_cast<std::uint8_t>(j.m_data.m_value.number_unsigned));
-      } else if (j.m_data.m_value.number_unsigned <=
-                 (std::numeric_limits<std::uint16_t>::max)()) {
-        oa->write_character(to_char_type(0x19));
-        write_number(
-            static_cast<std::uint16_t>(j.m_data.m_value.number_unsigned));
-      } else if (j.m_data.m_value.number_unsigned <=
-                 (std::numeric_limits<std::uint32_t>::max)()) {
-        oa->write_character(to_char_type(0x1A));
-        write_number(
-            static_cast<std::uint32_t>(j.m_data.m_value.number_unsigned));
-      } else {
-        oa->write_character(to_char_type(0x1B));
-        write_number(
-            static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
-      }
-      break;
-    }
-
-    case value_t::number_float: {
-      if (std::isnan(j.m_data.m_value.number_float)) {
-        // NaN is 0xf97e00 in CBOR
-        oa->write_character(to_char_type(0xF9));
-        oa->write_character(to_char_type(0x7E));
-        oa->write_character(to_char_type(0x00));
-      } else if (std::isinf(j.m_data.m_value.number_float)) {
-        // Infinity is 0xf97c00, -Infinity is 0xf9fc00
-        oa->write_character(to_char_type(0xf9));
-        oa->write_character(j.m_data.m_value.number_float > 0
-                                ? to_char_type(0x7C)
-                                : to_char_type(0xFC));
-        oa->write_character(to_char_type(0x00));
-      } else {
-        write_compact_float(j.m_data.m_value.number_float,
-                            detail::input_format_t::cbor);
-      }
-      break;
-    }
-
-    case value_t::string: {
-      // step 1: write control byte and the string length
-      const auto N = j.m_data.m_value.string->size();
-      if (N <= 0x17) {
-        write_number(static_cast<std::uint8_t>(0x60 + N));
-      } else if (N <= (std::numeric_limits<std::uint8_t>::max)()) {
-        oa->write_character(to_char_type(0x78));
-        write_number(static_cast<std::uint8_t>(N));
-      } else if (N <= (std::numeric_limits<std::uint16_t>::max)()) {
-        oa->write_character(to_char_type(0x79));
-        write_number(static_cast<std::uint16_t>(N));
-      } else if (N <= (std::numeric_limits<std::uint32_t>::max)()) {
-        oa->write_character(to_char_type(0x7A));
-        write_number(static_cast<std::uint32_t>(N));
-      }
-      // LCOV_EXCL_START
-      else if (N <= (std::numeric_limits<std::uint64_t>::max)()) {
-        oa->write_character(to_char_type(0x7B));
-        write_number(static_cast<std::uint64_t>(N));
-      }
-      // LCOV_EXCL_STOP
-
-      // step 2: write the string
-      oa->write_characters(
-          reinterpret_cast<const CharType *>(j.m_data.m_value.string->c_str()),
-          j.m_data.m_value.string->size());
-      break;
-    }
-
-    case value_t::array: {
-      // step 1: write control byte and the array size
-      const auto N = j.m_data.m_value.array->size();
-      if (N <= 0x17) {
-        write_number(static_cast<std::uint8_t>(0x80 + N));
-      } else if (N <= (std::numeric_limits<std::uint8_t>::max)()) {
-        oa->write_character(to_char_type(0x98));
-        write_number(static_cast<std::uint8_t>(N));
-      } else if (N <= (std::numeric_limits<std::uint16_t>::max)()) {
-        oa->write_character(to_char_type(0x99));
-        write_number(static_cast<std::uint16_t>(N));
-      } else if (N <= (std::numeric_limits<std::uint32_t>::max)()) {
-        oa->write_character(to_char_type(0x9A));
-        write_number(static_cast<std::uint32_t>(N));
-      }
-      // LCOV_EXCL_START
-      else if (N <= (std::numeric_limits<std::uint64_t>::max)()) {
-        oa->write_character(to_char_type(0x9B));
-        write_number(static_cast<std::uint64_t>(N));
-      }
-      // LCOV_EXCL_STOP
-
-      // step 2: write each element
-      for (const auto &el : *j.m_data.m_value.array) {
-        write_cbor(el);
-      }
-      break;
-    }
-
-    case value_t::binary: {
-      if (j.m_data.m_value.binary->has_subtype()) {
-        if (j.m_data.m_value.binary->subtype() <=
-            (std::numeric_limits<std::uint8_t>::max)()) {
-          write_number(static_cast<std::uint8_t>(0xd8));
-          write_number(
-              static_cast<std::uint8_t>(j.m_data.m_value.binary->subtype()));
-        } else if (j.m_data.m_value.binary->subtype() <=
-                   (std::numeric_limits<std::uint16_t>::max)()) {
-          write_number(static_cast<std::uint8_t>(0xd9));
-          write_number(
-              static_cast<std::uint16_t>(j.m_data.m_value.binary->subtype()));
-        } else if (j.m_data.m_value.binary->subtype() <=
-                   (std::numeric_limits<std::uint32_t>::max)()) {
-          write_number(static_cast<std::uint8_t>(0xda));
-          write_number(
-              static_cast<std::uint32_t>(j.m_data.m_value.binary->subtype()));
-        } else if (j.m_data.m_value.binary->subtype() <=
-                   (std::numeric_limits<std::uint64_t>::max)()) {
-          write_number(static_cast<std::uint8_t>(0xdb));
-          write_number(
-              static_cast<std::uint64_t>(j.m_data.m_value.binary->subtype()));
-        }
-      }
-
-      // step 1: write control byte and the binary array size
-      const auto N = j.m_data.m_value.binary->size();
-      if (N <= 0x17) {
-        write_number(static_cast<std::uint8_t>(0x40 + N));
-      } else if (N <= (std::numeric_limits<std::uint8_t>::max)()) {
-        oa->write_character(to_char_type(0x58));
-        write_number(static_cast<std::uint8_t>(N));
-      } else if (N <= (std::numeric_limits<std::uint16_t>::max)()) {
-        oa->write_character(to_char_type(0x59));
-        write_number(static_cast<std::uint16_t>(N));
-      } else if (N <= (std::numeric_limits<std::uint32_t>::max)()) {
-        oa->write_character(to_char_type(0x5A));
-        write_number(static_cast<std::uint32_t>(N));
-      }
-      // LCOV_EXCL_START
-      else if (N <= (std::numeric_limits<std::uint64_t>::max)()) {
-        oa->write_character(to_char_type(0x5B));
-        write_number(static_cast<std::uint64_t>(N));
-      }
-      // LCOV_EXCL_STOP
-
-      // step 2: write each element
-      oa->write_characters(
-          reinterpret_cast<const CharType *>(j.m_data.m_value.binary->data()),
-          N);
-
-      break;
-    }
-
-    case value_t::object: {
-      // step 1: write control byte and the object size
-      const auto N = j.m_data.m_value.object->size();
-      if (N <= 0x17) {
-        write_number(static_cast<std::uint8_t>(0xA0 + N));
-      } else if (N <= (std::numeric_limits<std::uint8_t>::max)()) {
-        oa->write_character(to_char_type(0xB8));
-        write_number(static_cast<std::uint8_t>(N));
-      } else if (N <= (std::numeric_limits<std::uint16_t>::max)()) {
-        oa->write_character(to_char_type(0xB9));
-        write_number(static_cast<std::uint16_t>(N));
-      } else if (N <= (std::numeric_limits<std::uint32_t>::max)()) {
-        oa->write_character(to_char_type(0xBA));
-        write_number(static_cast<std::uint32_t>(N));
-      }
-      // LCOV_EXCL_START
-      else if (N <= (std::numeric_limits<std::uint64_t>::max)()) {
-        oa->write_character(to_char_type(0xBB));
-        write_number(static_cast<std::uint64_t>(N));
-      }
-      // LCOV_EXCL_STOP
-
-      // step 2: write each element
-      for (const auto &el : *j.m_data.m_value.object) {
-        write_cbor(el.first);
-        write_cbor(el.second);
-      }
-      break;
-    }
-
-    case value_t::discarded:
-    default:
-      break;
-    }
-  }
-
-  /*!
-  @param[in] j  JSON value to serialize
-  */
-  void write_msgpack(const BasicJsonType &j) {
-    switch (j.type()) {
-    case value_t::null: // nil
-    {
-      oa->write_character(to_char_type(0xC0));
-      break;
-    }
-
-    case value_t::boolean: // true and false
-    {
-      oa->write_character(j.m_data.m_value.boolean ? to_char_type(0xC3)
-                                                   : to_char_type(0xC2));
-      break;
-    }
-
-    case value_t::number_integer: {
-      if (j.m_data.m_value.number_integer >= 0) {
-        // MessagePack does not differentiate between positive
-        // signed integers and unsigned integers. Therefore, we used
-        // the code from the value_t::number_unsigned case here.
-        if (j.m_data.m_value.number_unsigned < 128) {
-          // positive fixnum
-          write_number(
-              static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
-        } else if (j.m_data.m_value.number_unsigned <=
-                   (std::numeric_limits<std::uint8_t>::max)()) {
-          // uint 8
-          oa->write_character(to_char_type(0xCC));
-          write_number(
-              static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
-        } else if (j.m_data.m_value.number_unsigned <=
-                   (std::numeric_limits<std::uint16_t>::max)()) {
-          // uint 16
-          oa->write_character(to_char_type(0xCD));
-          write_number(
-              static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
-        } else if (j.m_data.m_value.number_unsigned <=
-                   (std::numeric_limits<std::uint32_t>::max)()) {
-          // uint 32
-          oa->write_character(to_char_type(0xCE));
-          write_number(
-              static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
-        } else if (j.m_data.m_value.number_unsigned <=
-                   (std::numeric_limits<std::uint64_t>::max)()) {
-          // uint 64
-          oa->write_character(to_char_type(0xCF));
-          write_number(
-              static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
-        }
-      } else {
-        if (j.m_data.m_value.number_integer >= -32) {
-          // negative fixnum
-          write_number(
-              static_cast<std::int8_t>(j.m_data.m_value.number_integer));
-        } else if (j.m_data.m_value.number_integer >=
-                       (std::numeric_limits<std::int8_t>::min)() &&
-                   j.m_data.m_value.number_integer <=
-                       (std::numeric_limits<std::int8_t>::max)()) {
-          // int 8
-          oa->write_character(to_char_type(0xD0));
-          write_number(
-              static_cast<std::int8_t>(j.m_data.m_value.number_integer));
-        } else if (j.m_data.m_value.number_integer >=
-                       (std::numeric_limits<std::int16_t>::min)() &&
-                   j.m_data.m_value.number_integer <=
-                       (std::numeric_limits<std::int16_t>::max)()) {
-          // int 16
-          oa->write_character(to_char_type(0xD1));
-          write_number(
-              static_cast<std::int16_t>(j.m_data.m_value.number_integer));
-        } else if (j.m_data.m_value.number_integer >=
-                       (std::numeric_limits<std::int32_t>::min)() &&
-                   j.m_data.m_value.number_integer <=
-                       (std::numeric_limits<std::int32_t>::max)()) {
-          // int 32
-          oa->write_character(to_char_type(0xD2));
-          write_number(
-              static_cast<std::int32_t>(j.m_data.m_value.number_integer));
-        } else if (j.m_data.m_value.number_integer >=
-                       (std::numeric_limits<std::int64_t>::min)() &&
-                   j.m_data.m_value.number_integer <=
-                       (std::numeric_limits<std::int64_t>::max)()) {
-          // int 64
-          oa->write_character(to_char_type(0xD3));
-          write_number(
-              static_cast<std::int64_t>(j.m_data.m_value.number_integer));
-        }
-      }
-      break;
-    }
-
-    case value_t::number_unsigned: {
-      if (j.m_data.m_value.number_unsigned < 128) {
-        // positive fixnum
-        write_number(
-            static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
-      } else if (j.m_data.m_value.number_unsigned <=
-                 (std::numeric_limits<std::uint8_t>::max)()) {
-        // uint 8
-        oa->write_character(to_char_type(0xCC));
-        write_number(
-            static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
-      } else if (j.m_data.m_value.number_unsigned <=
-                 (std::numeric_limits<std::uint16_t>::max)()) {
-        // uint 16
-        oa->write_character(to_char_type(0xCD));
-        write_number(
-            static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
-      } else if (j.m_data.m_value.number_unsigned <=
-                 (std::numeric_limits<std::uint32_t>::max)()) {
-        // uint 32
-        oa->write_character(to_char_type(0xCE));
-        write_number(
-            static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
-      } else if (j.m_data.m_value.number_unsigned <=
-                 (std::numeric_limits<std::uint64_t>::max)()) {
-        // uint 64
-        oa->write_character(to_char_type(0xCF));
-        write_number(
-            static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
-      }
-      break;
-    }
-
-    case value_t::number_float: {
-      write_compact_float(j.m_data.m_value.number_float,
-                          detail::input_format_t::msgpack);
-      break;
-    }
-
-    case value_t::string: {
-      // step 1: write control byte and the string length
-      const auto N = j.m_data.m_value.string->size();
-      if (N <= 31) {
-        // fixstr
-        write_number(static_cast<std::uint8_t>(0xA0 | N));
-      } else if (N <= (std::numeric_limits<std::uint8_t>::max)()) {
-        // str 8
-        oa->write_character(to_char_type(0xD9));
-        write_number(static_cast<std::uint8_t>(N));
-      } else if (N <= (std::numeric_limits<std::uint16_t>::max)()) {
-        // str 16
-        oa->write_character(to_char_type(0xDA));
-        write_number(static_cast<std::uint16_t>(N));
-      } else if (N <= (std::numeric_limits<std::uint32_t>::max)()) {
-        // str 32
-        oa->write_character(to_char_type(0xDB));
-        write_number(static_cast<std::uint32_t>(N));
-      }
-
-      // step 2: write the string
-      oa->write_characters(
-          reinterpret_cast<const CharType *>(j.m_data.m_value.string->c_str()),
-          j.m_data.m_value.string->size());
-      break;
-    }
-
-    case value_t::array: {
-      // step 1: write control byte and the array size
-      const auto N = j.m_data.m_value.array->size();
-      if (N <= 15) {
-        // fixarray
-        write_number(static_cast<std::uint8_t>(0x90 | N));
-      } else if (N <= (std::numeric_limits<std::uint16_t>::max)()) {
-        // array 16
-        oa->write_character(to_char_type(0xDC));
-        write_number(static_cast<std::uint16_t>(N));
-      } else if (N <= (std::numeric_limits<std::uint32_t>::max)()) {
-        // array 32
-        oa->write_character(to_char_type(0xDD));
-        write_number(static_cast<std::uint32_t>(N));
-      }
-
-      // step 2: write each element
-      for (const auto &el : *j.m_data.m_value.array) {
-        write_msgpack(el);
-      }
-      break;
-    }
-
-    case value_t::binary: {
-      // step 0: determine if the binary type has a set subtype to
-      // determine whether to use the ext or fixext types
-      const bool use_ext = j.m_data.m_value.binary->has_subtype();
-
-      // step 1: write control byte and the byte string length
-      const auto N = j.m_data.m_value.binary->size();
-      if (N <= (std::numeric_limits<std::uint8_t>::max)()) {
-        std::uint8_t output_type{};
-        bool fixed = true;
-        if (use_ext) {
-          switch (N) {
-          case 1:
-            output_type = 0xD4; // fixext 1
-            break;
-          case 2:
-            output_type = 0xD5; // fixext 2
-            break;
-          case 4:
-            output_type = 0xD6; // fixext 4
-            break;
-          case 8:
-            output_type = 0xD7; // fixext 8
-            break;
-          case 16:
-            output_type = 0xD8; // fixext 16
-            break;
-          default:
-            output_type = 0xC7; // ext 8
-            fixed = false;
-            break;
-          }
-
-        } else {
-          output_type = 0xC4; // bin 8
-          fixed = false;
-        }
-
-        oa->write_character(to_char_type(output_type));
-        if (!fixed) {
-          write_number(static_cast<std::uint8_t>(N));
-        }
-      } else if (N <= (std::numeric_limits<std::uint16_t>::max)()) {
-        const std::uint8_t output_type = use_ext ? 0xC8  // ext 16
-                                                 : 0xC5; // bin 16
-
-        oa->write_character(to_char_type(output_type));
-        write_number(static_cast<std::uint16_t>(N));
-      } else if (N <= (std::numeric_limits<std::uint32_t>::max)()) {
-        const std::uint8_t output_type = use_ext ? 0xC9  // ext 32
-                                                 : 0xC6; // bin 32
-
-        oa->write_character(to_char_type(output_type));
-        write_number(static_cast<std::uint32_t>(N));
-      }
-
-      // step 1.5: if this is an ext type, write the subtype
-      if (use_ext) {
-        write_number(
-            static_cast<std::int8_t>(j.m_data.m_value.binary->subtype()));
-      }
-
-      // step 2: write the byte string
-      oa->write_characters(
-          reinterpret_cast<const CharType *>(j.m_data.m_value.binary->data()),
-          N);
-
-      break;
-    }
-
-    case value_t::object: {
-      // step 1: write control byte and the object size
-      const auto N = j.m_data.m_value.object->size();
-      if (N <= 15) {
-        // fixmap
-        write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));
-      } else if (N <= (std::numeric_limits<std::uint16_t>::max)()) {
-        // map 16
-        oa->write_character(to_char_type(0xDE));
-        write_number(static_cast<std::uint16_t>(N));
-      } else if (N <= (std::numeric_limits<std::uint32_t>::max)()) {
-        // map 32
-        oa->write_character(to_char_type(0xDF));
-        write_number(static_cast<std::uint32_t>(N));
-      }
-
-      // step 2: write each element
-      for (const auto &el : *j.m_data.m_value.object) {
-        write_msgpack(el.first);
-        write_msgpack(el.second);
-      }
-      break;
-    }
-
-    case value_t::discarded:
-    default:
-      break;
-    }
-  }
-
-  /*!
-  @param[in] j  JSON value to serialize
-  @param[in] use_count   whether to use '#' prefixes (optimized format)
-  @param[in] use_type    whether to use '$' prefixes (optimized format)
-  @param[in] add_prefix  whether prefixes need to be used for this value
-  @param[in] use_bjdata  whether write in BJData format, default is false
-  */
-  void write_ubjson(const BasicJsonType &j, const bool use_count,
-                    const bool use_type, const bool add_prefix = true,
-                    const bool use_bjdata = false) {
-    switch (j.type()) {
-    case value_t::null: {
-      if (add_prefix) {
-        oa->write_character(to_char_type('Z'));
-      }
-      break;
-    }
-
-    case value_t::boolean: {
-      if (add_prefix) {
-        oa->write_character(j.m_data.m_value.boolean ? to_char_type('T')
-                                                     : to_char_type('F'));
-      }
-      break;
-    }
-
-    case value_t::number_integer: {
-      write_number_with_ubjson_prefix(j.m_data.m_value.number_integer,
-                                      add_prefix, use_bjdata);
-      break;
-    }
-
-    case value_t::number_unsigned: {
-      write_number_with_ubjson_prefix(j.m_data.m_value.number_unsigned,
-                                      add_prefix, use_bjdata);
-      break;
-    }
-
-    case value_t::number_float: {
-      write_number_with_ubjson_prefix(j.m_data.m_value.number_float, add_prefix,
-                                      use_bjdata);
-      break;
-    }
-
-    case value_t::string: {
-      if (add_prefix) {
-        oa->write_character(to_char_type('S'));
-      }
-      write_number_with_ubjson_prefix(j.m_data.m_value.string->size(), true,
-                                      use_bjdata);
-      oa->write_characters(
-          reinterpret_cast<const CharType *>(j.m_data.m_value.string->c_str()),
-          j.m_data.m_value.string->size());
-      break;
-    }
-
-    case value_t::array: {
-      if (add_prefix) {
-        oa->write_character(to_char_type('['));
-      }
-
-      bool prefix_required = true;
-      if (use_type && !j.m_data.m_value.array->empty()) {
-        JSON_ASSERT(use_count);
-        const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
-        const bool same_prefix = std::all_of(
-            j.begin() + 1, j.end(),
-            [this, first_prefix, use_bjdata](const BasicJsonType &v) {
-              return ubjson_prefix(v, use_bjdata) == first_prefix;
-            });
-
-        std::vector<CharType> bjdx = {
-            '[', '{', 'S', 'H',
-            'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type
-
-        if (same_prefix &&
-            !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) !=
-                                bjdx.end())) {
-          prefix_required = false;
-          oa->write_character(to_char_type('$'));
-          oa->write_character(first_prefix);
-        }
-      }
-
-      if (use_count) {
-        oa->write_character(to_char_type('#'));
-        write_number_with_ubjson_prefix(j.m_data.m_value.array->size(), true,
-                                        use_bjdata);
-      }
-
-      for (const auto &el : *j.m_data.m_value.array) {
-        write_ubjson(el, use_count, use_type, prefix_required, use_bjdata);
-      }
-
-      if (!use_count) {
-        oa->write_character(to_char_type(']'));
-      }
-
-      break;
-    }
-
-    case value_t::binary: {
-      if (add_prefix) {
-        oa->write_character(to_char_type('['));
-      }
-
-      if (use_type && !j.m_data.m_value.binary->empty()) {
-        JSON_ASSERT(use_count);
-        oa->write_character(to_char_type('$'));
-        oa->write_character('U');
-      }
-
-      if (use_count) {
-        oa->write_character(to_char_type('#'));
-        write_number_with_ubjson_prefix(j.m_data.m_value.binary->size(), true,
-                                        use_bjdata);
-      }
-
-      if (use_type) {
-        oa->write_characters(
-            reinterpret_cast<const CharType *>(j.m_data.m_value.binary->data()),
-            j.m_data.m_value.binary->size());
-      } else {
-        for (size_t i = 0; i < j.m_data.m_value.binary->size(); ++i) {
-          oa->write_character(to_char_type('U'));
-          oa->write_character(j.m_data.m_value.binary->data()[i]);
-        }
-      }
-
-      if (!use_count) {
-        oa->write_character(to_char_type(']'));
-      }
-
-      break;
-    }
-
-    case value_t::object: {
-      if (use_bjdata && j.m_data.m_value.object->size() == 3 &&
-          j.m_data.m_value.object->find("_ArrayType_") !=
-              j.m_data.m_value.object->end() &&
-          j.m_data.m_value.object->find("_ArraySize_") !=
-              j.m_data.m_value.object->end() &&
-          j.m_data.m_value.object->find("_ArrayData_") !=
-              j.m_data.m_value.object->end()) {
-        if (!write_bjdata_ndarray(
-                *j.m_data.m_value.object, use_count,
-                use_type)) // decode bjdata ndarray in the JData format
-                           // (https://github.com/NeuroJSON/jdata)
-        {
-          break;
-        }
-      }
-
-      if (add_prefix) {
-        oa->write_character(to_char_type('{'));
-      }
-
-      bool prefix_required = true;
-      if (use_type && !j.m_data.m_value.object->empty()) {
-        JSON_ASSERT(use_count);
-        const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
-        const bool same_prefix = std::all_of(
-            j.begin(), j.end(),
-            [this, first_prefix, use_bjdata](const BasicJsonType &v) {
-              return ubjson_prefix(v, use_bjdata) == first_prefix;
-            });
-
-        std::vector<CharType> bjdx = {
-            '[', '{', 'S', 'H',
-            'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type
-
-        if (same_prefix &&
-            !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) !=
-                                bjdx.end())) {
-          prefix_required = false;
-          oa->write_character(to_char_type('$'));
-          oa->write_character(first_prefix);
-        }
-      }
-
-      if (use_count) {
-        oa->write_character(to_char_type('#'));
-        write_number_with_ubjson_prefix(j.m_data.m_value.object->size(), true,
-                                        use_bjdata);
-      }
-
-      for (const auto &el : *j.m_data.m_value.object) {
-        write_number_with_ubjson_prefix(el.first.size(), true, use_bjdata);
-        oa->write_characters(
-            reinterpret_cast<const CharType *>(el.first.c_str()),
-            el.first.size());
-        write_ubjson(el.second, use_count, use_type, prefix_required,
-                     use_bjdata);
-      }
-
-      if (!use_count) {
-        oa->write_character(to_char_type('}'));
-      }
-
-      break;
-    }
-
-    case value_t::discarded:
-    default:
-      break;
-    }
-  }
-
-private:
-  //////////
-  // BSON //
-  //////////
-
-  /*!
-  @return The size of a BSON document entry header, including the id marker
-          and the entry name size (and its null-terminator).
-  */
-  static std::size_t calc_bson_entry_header_size(const string_t &name,
-                                                 const BasicJsonType &j) {
-    const auto it = name.find(static_cast<typename string_t::value_type>(0));
-    if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos)) {
-      JSON_THROW(out_of_range::create(
-          409,
-          concat("BSON key cannot contain code point U+0000 (at byte ",
-                 std::to_string(it), ")"),
-          &j));
-      static_cast<void>(j);
-    }
-
-    return /*id*/ 1ul + name.size() + /*zero-terminator*/ 1u;
-  }
-
-  /*!
-  @brief Writes the given @a element_type and @a name to the output adapter
-  */
-  void write_bson_entry_header(const string_t &name,
-                               const std::uint8_t element_type) {
-    oa->write_character(to_char_type(element_type)); // boolean
-    oa->write_characters(reinterpret_cast<const CharType *>(name.c_str()),
-                         name.size() + 1u);
-  }
-
-  /*!
-  @brief Writes a BSON element with key @a name and boolean value @a value
-  */
-  void write_bson_boolean(const string_t &name, const bool value) {
-    write_bson_entry_header(name, 0x08);
-    oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
-  }
-
-  /*!
-  @brief Writes a BSON element with key @a name and double value @a value
-  */
-  void write_bson_double(const string_t &name, const double value) {
-    write_bson_entry_header(name, 0x01);
-    write_number<double>(value, true);
-  }
-
-  /*!
-  @return The size of the BSON-encoded string in @a value
-  */
-  static std::size_t calc_bson_string_size(const string_t &value) {
-    return sizeof(std::int32_t) + value.size() + 1ul;
-  }
-
-  /*!
-  @brief Writes a BSON element with key @a name and string value @a value
-  */
-  void write_bson_string(const string_t &name, const string_t &value) {
-    write_bson_entry_header(name, 0x02);
-
-    write_number<std::int32_t>(static_cast<std::int32_t>(value.size() + 1ul),
-                               true);
-    oa->write_characters(reinterpret_cast<const CharType *>(value.c_str()),
-                         value.size() + 1);
-  }
-
-  /*!
-  @brief Writes a BSON element with key @a name and null value
-  */
-  void write_bson_null(const string_t &name) {
-    write_bson_entry_header(name, 0x0A);
-  }
-
-  /*!
-  @return The size of the BSON-encoded integer @a value
-  */
-  static std::size_t calc_bson_integer_size(const std::int64_t value) {
-    return (std::numeric_limits<std::int32_t>::min)() <= value &&
-                   value <= (std::numeric_limits<std::int32_t>::max)()
-               ? sizeof(std::int32_t)
-               : sizeof(std::int64_t);
-  }
-
-  /*!
-  @brief Writes a BSON element with key @a name and integer @a value
-  */
-  void write_bson_integer(const string_t &name, const std::int64_t value) {
-    if ((std::numeric_limits<std::int32_t>::min)() <= value &&
-        value <= (std::numeric_limits<std::int32_t>::max)()) {
-      write_bson_entry_header(name, 0x10); // int32
-      write_number<std::int32_t>(static_cast<std::int32_t>(value), true);
-    } else {
-      write_bson_entry_header(name, 0x12); // int64
-      write_number<std::int64_t>(static_cast<std::int64_t>(value), true);
-    }
-  }
-
-  /*!
-  @return The size of the BSON-encoded unsigned integer in @a j
-  */
-  static constexpr std::size_t
-  calc_bson_unsigned_size(const std::uint64_t value) noexcept {
-    return (value <= static_cast<std::uint64_t>(
-                         (std::numeric_limits<std::int32_t>::max)()))
-               ? sizeof(std::int32_t)
-               : sizeof(std::int64_t);
-  }
-
-  /*!
-  @brief Writes a BSON element with key @a name and unsigned @a value
-  */
-  void write_bson_unsigned(const string_t &name, const BasicJsonType &j) {
-    if (j.m_data.m_value.number_unsigned <=
-        static_cast<std::uint64_t>(
-            (std::numeric_limits<std::int32_t>::max)())) {
-      write_bson_entry_header(name, 0x10 /* int32 */);
-      write_number<std::int32_t>(
-          static_cast<std::int32_t>(j.m_data.m_value.number_unsigned), true);
-    } else if (j.m_data.m_value.number_unsigned <=
-               static_cast<std::uint64_t>(
-                   (std::numeric_limits<std::int64_t>::max)())) {
-      write_bson_entry_header(name, 0x12 /* int64 */);
-      write_number<std::int64_t>(
-          static_cast<std::int64_t>(j.m_data.m_value.number_unsigned), true);
-    } else {
-      JSON_THROW(out_of_range::create(
-          407,
-          concat("integer number ",
-                 std::to_string(j.m_data.m_value.number_unsigned),
-                 " cannot be represented by BSON as it does not fit int64"),
-          &j));
-    }
-  }
-
-  /*!
-  @brief Writes a BSON element with key @a name and object @a value
-  */
-  void write_bson_object_entry(const string_t &name,
-                               const typename BasicJsonType::object_t &value) {
-    write_bson_entry_header(name, 0x03); // object
-    write_bson_object(value);
-  }
-
-  /*!
-  @return The size of the BSON-encoded array @a value
-  */
-  static std::size_t
-  calc_bson_array_size(const typename BasicJsonType::array_t &value) {
-    std::size_t array_index = 0ul;
-
-    const std::size_t embedded_document_size = std::accumulate(
-        std::begin(value), std::end(value), static_cast<std::size_t>(0),
-        [&array_index](std::size_t result,
-                       const typename BasicJsonType::array_t::value_type &el) {
-          return result +
-                 calc_bson_element_size(std::to_string(array_index++), el);
-        });
-
-    return sizeof(std::int32_t) + embedded_document_size + 1ul;
-  }
-
-  /*!
-  @return The size of the BSON-encoded binary array @a value
-  */
-  static std::size_t
-  calc_bson_binary_size(const typename BasicJsonType::binary_t &value) {
-    return sizeof(std::int32_t) + value.size() + 1ul;
-  }
-
-  /*!
-  @brief Writes a BSON element with key @a name and array @a value
-  */
-  void write_bson_array(const string_t &name,
-                        const typename BasicJsonType::array_t &value) {
-    write_bson_entry_header(name, 0x04); // array
-    write_number<std::int32_t>(
-        static_cast<std::int32_t>(calc_bson_array_size(value)), true);
-
-    std::size_t array_index = 0ul;
-
-    for (const auto &el : value) {
-      write_bson_element(std::to_string(array_index++), el);
-    }
-
-    oa->write_character(to_char_type(0x00));
-  }
-
-  /*!
-  @brief Writes a BSON element with key @a name and binary value @a value
-  */
-  void write_bson_binary(const string_t &name, const binary_t &value) {
-    write_bson_entry_header(name, 0x05);
-
-    write_number<std::int32_t>(static_cast<std::int32_t>(value.size()), true);
-    write_number(value.has_subtype()
-                     ? static_cast<std::uint8_t>(value.subtype())
-                     : static_cast<std::uint8_t>(0x00));
-
-    oa->write_characters(reinterpret_cast<const CharType *>(value.data()),
-                         value.size());
-  }
-
-  /*!
-  @brief Calculates the size necessary to serialize the JSON value @a j with its
-  @a name
-  @return The calculated size for the BSON document entry for @a j with the
-  given @a name.
-  */
-  static std::size_t calc_bson_element_size(const string_t &name,
-                                            const BasicJsonType &j) {
-    const auto header_size = calc_bson_entry_header_size(name, j);
-    switch (j.type()) {
-    case value_t::object:
-      return header_size + calc_bson_object_size(*j.m_data.m_value.object);
-
-    case value_t::array:
-      return header_size + calc_bson_array_size(*j.m_data.m_value.array);
-
-    case value_t::binary:
-      return header_size + calc_bson_binary_size(*j.m_data.m_value.binary);
-
-    case value_t::boolean:
-      return header_size + 1ul;
-
-    case value_t::number_float:
-      return header_size + 8ul;
-
-    case value_t::number_integer:
-      return header_size +
-             calc_bson_integer_size(j.m_data.m_value.number_integer);
-
-    case value_t::number_unsigned:
-      return header_size +
-             calc_bson_unsigned_size(j.m_data.m_value.number_unsigned);
-
-    case value_t::string:
-      return header_size + calc_bson_string_size(*j.m_data.m_value.string);
-
-    case value_t::null:
-      return header_size + 0ul;
-
-    // LCOV_EXCL_START
-    case value_t::discarded:
-    default:
-      JSON_ASSERT(
-          false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
-      return 0ul;
-      // LCOV_EXCL_STOP
-    }
-  }
-
-  /*!
-  @brief Serializes the JSON value @a j to BSON and associates it with the
-         key @a name.
-  @param name The name to associate with the JSON entity @a j within the
-              current BSON document
-  */
-  void write_bson_element(const string_t &name, const BasicJsonType &j) {
-    switch (j.type()) {
-    case value_t::object:
-      return write_bson_object_entry(name, *j.m_data.m_value.object);
-
-    case value_t::array:
-      return write_bson_array(name, *j.m_data.m_value.array);
-
-    case value_t::binary:
-      return write_bson_binary(name, *j.m_data.m_value.binary);
-
-    case value_t::boolean:
-      return write_bson_boolean(name, j.m_data.m_value.boolean);
-
-    case value_t::number_float:
-      return write_bson_double(name, j.m_data.m_value.number_float);
-
-    case value_t::number_integer:
-      return write_bson_integer(name, j.m_data.m_value.number_integer);
-
-    case value_t::number_unsigned:
-      return write_bson_unsigned(name, j);
-
-    case value_t::string:
-      return write_bson_string(name, *j.m_data.m_value.string);
-
-    case value_t::null:
-      return write_bson_null(name);
-
-    // LCOV_EXCL_START
-    case value_t::discarded:
-    default:
-      JSON_ASSERT(
-          false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
-      return;
-      // LCOV_EXCL_STOP
-    }
-  }
-
-  /*!
-  @brief Calculates the size of the BSON serialization of the given
-         JSON-object @a j.
-  @param[in] value  JSON value to serialize
-  @pre       value.type() == value_t::object
-  */
-  static std::size_t
-  calc_bson_object_size(const typename BasicJsonType::object_t &value) {
-    const std::size_t document_size = std::accumulate(
-        value.begin(), value.end(), static_cast<std::size_t>(0),
-        [](size_t result,
-           const typename BasicJsonType::object_t::value_type &el) {
-          return result += calc_bson_element_size(el.first, el.second);
-        });
-
-    return sizeof(std::int32_t) + document_size + 1ul;
-  }
-
-  /*!
-  @param[in] value  JSON value to serialize
-  @pre       value.type() == value_t::object
-  */
-  void write_bson_object(const typename BasicJsonType::object_t &value) {
-    write_number<std::int32_t>(
-        static_cast<std::int32_t>(calc_bson_object_size(value)), true);
-
-    for (const auto &el : value) {
-      write_bson_element(el.first, el.second);
-    }
-
-    oa->write_character(to_char_type(0x00));
-  }
-
-  //////////
-  // CBOR //
-  //////////
-
-  static constexpr CharType get_cbor_float_prefix(float /*unused*/) {
-    return to_char_type(0xFA); // Single-Precision Float
-  }
-
-  static constexpr CharType get_cbor_float_prefix(double /*unused*/) {
-    return to_char_type(0xFB); // Double-Precision Float
-  }
-
-  /////////////
-  // MsgPack //
-  /////////////
-
-  static constexpr CharType get_msgpack_float_prefix(float /*unused*/) {
-    return to_char_type(0xCA); // float 32
-  }
-
-  static constexpr CharType get_msgpack_float_prefix(double /*unused*/) {
-    return to_char_type(0xCB); // float 64
-  }
-
-  ////////////
-  // UBJSON //
-  ////////////
-
-  // UBJSON: write number (floating point)
-  template <typename NumberType,
-            typename std::enable_if<std::is_floating_point<NumberType>::value,
-                                    int>::type = 0>
-  void write_number_with_ubjson_prefix(const NumberType n,
-                                       const bool add_prefix,
-                                       const bool use_bjdata) {
-    if (add_prefix) {
-      oa->write_character(get_ubjson_float_prefix(n));
-    }
-    write_number(n, use_bjdata);
-  }
-
-  // UBJSON: write number (unsigned integer)
-  template <typename NumberType,
-            typename std::enable_if<std::is_unsigned<NumberType>::value,
-                                    int>::type = 0>
-  void write_number_with_ubjson_prefix(const NumberType n,
-                                       const bool add_prefix,
-                                       const bool use_bjdata) {
-    if (n <=
-        static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)())) {
-      if (add_prefix) {
-        oa->write_character(to_char_type('i')); // int8
-      }
-      write_number(static_cast<std::uint8_t>(n), use_bjdata);
-    } else if (n <= (std::numeric_limits<std::uint8_t>::max)()) {
-      if (add_prefix) {
-        oa->write_character(to_char_type('U')); // uint8
-      }
-      write_number(static_cast<std::uint8_t>(n), use_bjdata);
-    } else if (n <= static_cast<std::uint64_t>(
-                        (std::numeric_limits<std::int16_t>::max)())) {
-      if (add_prefix) {
-        oa->write_character(to_char_type('I')); // int16
-      }
-      write_number(static_cast<std::int16_t>(n), use_bjdata);
-    } else if (use_bjdata && n <= static_cast<uint64_t>(
-                                      (std::numeric_limits<uint16_t>::max)())) {
-      if (add_prefix) {
-        oa->write_character(to_char_type('u')); // uint16 - bjdata only
-      }
-      write_number(static_cast<std::uint16_t>(n), use_bjdata);
-    } else if (n <= static_cast<std::uint64_t>(
-                        (std::numeric_limits<std::int32_t>::max)())) {
-      if (add_prefix) {
-        oa->write_character(to_char_type('l')); // int32
-      }
-      write_number(static_cast<std::int32_t>(n), use_bjdata);
-    } else if (use_bjdata && n <= static_cast<uint64_t>(
-                                      (std::numeric_limits<uint32_t>::max)())) {
-      if (add_prefix) {
-        oa->write_character(to_char_type('m')); // uint32 - bjdata only
-      }
-      write_number(static_cast<std::uint32_t>(n), use_bjdata);
-    } else if (n <= static_cast<std::uint64_t>(
-                        (std::numeric_limits<std::int64_t>::max)())) {
-      if (add_prefix) {
-        oa->write_character(to_char_type('L')); // int64
-      }
-      write_number(static_cast<std::int64_t>(n), use_bjdata);
-    } else if (use_bjdata && n <= (std::numeric_limits<uint64_t>::max)()) {
-      if (add_prefix) {
-        oa->write_character(to_char_type('M')); // uint64 - bjdata only
-      }
-      write_number(static_cast<std::uint64_t>(n), use_bjdata);
-    } else {
-      if (add_prefix) {
-        oa->write_character(to_char_type('H')); // high-precision number
-      }
-
-      const auto number = BasicJsonType(n).dump();
-      write_number_with_ubjson_prefix(number.size(), true, use_bjdata);
-      for (std::size_t i = 0; i < number.size(); ++i) {
-        oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
-      }
-    }
-  }
-
-  // UBJSON: write number (signed integer)
-  template <
-      typename NumberType,
-      typename std::enable_if<std::is_signed<NumberType>::value &&
-                                  !std::is_floating_point<NumberType>::value,
-                              int>::type = 0>
-  void write_number_with_ubjson_prefix(const NumberType n,
-                                       const bool add_prefix,
-                                       const bool use_bjdata) {
-    if ((std::numeric_limits<std::int8_t>::min)() <= n &&
-        n <= (std::numeric_limits<std::int8_t>::max)()) {
-      if (add_prefix) {
-        oa->write_character(to_char_type('i')); // int8
-      }
-      write_number(static_cast<std::int8_t>(n), use_bjdata);
-    } else if (static_cast<std::int64_t>(
-                   (std::numeric_limits<std::uint8_t>::min)()) <= n &&
-               n <= static_cast<std::int64_t>(
-                        (std::numeric_limits<std::uint8_t>::max)())) {
-      if (add_prefix) {
-        oa->write_character(to_char_type('U')); // uint8
-      }
-      write_number(static_cast<std::uint8_t>(n), use_bjdata);
-    } else if ((std::numeric_limits<std::int16_t>::min)() <= n &&
-               n <= (std::numeric_limits<std::int16_t>::max)()) {
-      if (add_prefix) {
-        oa->write_character(to_char_type('I')); // int16
-      }
-      write_number(static_cast<std::int16_t>(n), use_bjdata);
-    } else if (use_bjdata &&
-               (static_cast<std::int64_t>(
-                    (std::numeric_limits<std::uint16_t>::min)()) <= n &&
-                n <= static_cast<std::int64_t>(
-                         (std::numeric_limits<std::uint16_t>::max)()))) {
-      if (add_prefix) {
-        oa->write_character(to_char_type('u')); // uint16 - bjdata only
-      }
-      write_number(static_cast<uint16_t>(n), use_bjdata);
-    } else if ((std::numeric_limits<std::int32_t>::min)() <= n &&
-               n <= (std::numeric_limits<std::int32_t>::max)()) {
-      if (add_prefix) {
-        oa->write_character(to_char_type('l')); // int32
-      }
-      write_number(static_cast<std::int32_t>(n), use_bjdata);
-    } else if (use_bjdata &&
-               (static_cast<std::int64_t>(
-                    (std::numeric_limits<std::uint32_t>::min)()) <= n &&
-                n <= static_cast<std::int64_t>(
-                         (std::numeric_limits<std::uint32_t>::max)()))) {
-      if (add_prefix) {
-        oa->write_character(to_char_type('m')); // uint32 - bjdata only
-      }
-      write_number(static_cast<uint32_t>(n), use_bjdata);
-    } else if ((std::numeric_limits<std::int64_t>::min)() <= n &&
-               n <= (std::numeric_limits<std::int64_t>::max)()) {
-      if (add_prefix) {
-        oa->write_character(to_char_type('L')); // int64
-      }
-      write_number(static_cast<std::int64_t>(n), use_bjdata);
-    }
-    // LCOV_EXCL_START
-    else {
-      if (add_prefix) {
-        oa->write_character(to_char_type('H')); // high-precision number
-      }
-
-      const auto number = BasicJsonType(n).dump();
-      write_number_with_ubjson_prefix(number.size(), true, use_bjdata);
-      for (std::size_t i = 0; i < number.size(); ++i) {
-        oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
-      }
-    }
-    // LCOV_EXCL_STOP
-  }
-
-  /*!
-  @brief determine the type prefix of container values
-  */
-  CharType ubjson_prefix(const BasicJsonType &j,
-                         const bool use_bjdata) const noexcept {
-    switch (j.type()) {
-    case value_t::null:
-      return 'Z';
-
-    case value_t::boolean:
-      return j.m_data.m_value.boolean ? 'T' : 'F';
-
-    case value_t::number_integer: {
-      if ((std::numeric_limits<std::int8_t>::min)() <=
-              j.m_data.m_value.number_integer &&
-          j.m_data.m_value.number_integer <=
-              (std::numeric_limits<std::int8_t>::max)()) {
-        return 'i';
-      }
-      if ((std::numeric_limits<std::uint8_t>::min)() <=
-              j.m_data.m_value.number_integer &&
-          j.m_data.m_value.number_integer <=
-              (std::numeric_limits<std::uint8_t>::max)()) {
-        return 'U';
-      }
-      if ((std::numeric_limits<std::int16_t>::min)() <=
-              j.m_data.m_value.number_integer &&
-          j.m_data.m_value.number_integer <=
-              (std::numeric_limits<std::int16_t>::max)()) {
-        return 'I';
-      }
-      if (use_bjdata && ((std::numeric_limits<std::uint16_t>::min)() <=
-                             j.m_data.m_value.number_integer &&
-                         j.m_data.m_value.number_integer <=
-                             (std::numeric_limits<std::uint16_t>::max)())) {
-        return 'u';
-      }
-      if ((std::numeric_limits<std::int32_t>::min)() <=
-              j.m_data.m_value.number_integer &&
-          j.m_data.m_value.number_integer <=
-              (std::numeric_limits<std::int32_t>::max)()) {
-        return 'l';
-      }
-      if (use_bjdata && ((std::numeric_limits<std::uint32_t>::min)() <=
-                             j.m_data.m_value.number_integer &&
-                         j.m_data.m_value.number_integer <=
-                             (std::numeric_limits<std::uint32_t>::max)())) {
-        return 'm';
-      }
-      if ((std::numeric_limits<std::int64_t>::min)() <=
-              j.m_data.m_value.number_integer &&
-          j.m_data.m_value.number_integer <=
-              (std::numeric_limits<std::int64_t>::max)()) {
-        return 'L';
-      }
-      // anything else is treated as high-precision number
-      return 'H'; // LCOV_EXCL_LINE
-    }
-
-    case value_t::number_unsigned: {
-      if (j.m_data.m_value.number_unsigned <=
-          static_cast<std::uint64_t>(
-              (std::numeric_limits<std::int8_t>::max)())) {
-        return 'i';
-      }
-      if (j.m_data.m_value.number_unsigned <=
-          static_cast<std::uint64_t>(
-              (std::numeric_limits<std::uint8_t>::max)())) {
-        return 'U';
-      }
-      if (j.m_data.m_value.number_unsigned <=
-          static_cast<std::uint64_t>(
-              (std::numeric_limits<std::int16_t>::max)())) {
-        return 'I';
-      }
-      if (use_bjdata && j.m_data.m_value.number_unsigned <=
-                            static_cast<std::uint64_t>(
-                                (std::numeric_limits<std::uint16_t>::max)())) {
-        return 'u';
-      }
-      if (j.m_data.m_value.number_unsigned <=
-          static_cast<std::uint64_t>(
-              (std::numeric_limits<std::int32_t>::max)())) {
-        return 'l';
-      }
-      if (use_bjdata && j.m_data.m_value.number_unsigned <=
-                            static_cast<std::uint64_t>(
-                                (std::numeric_limits<std::uint32_t>::max)())) {
-        return 'm';
-      }
-      if (j.m_data.m_value.number_unsigned <=
-          static_cast<std::uint64_t>(
-              (std::numeric_limits<std::int64_t>::max)())) {
-        return 'L';
-      }
-      if (use_bjdata && j.m_data.m_value.number_unsigned <=
-                            (std::numeric_limits<std::uint64_t>::max)()) {
-        return 'M';
-      }
-      // anything else is treated as high-precision number
-      return 'H'; // LCOV_EXCL_LINE
-    }
-
-    case value_t::number_float:
-      return get_ubjson_float_prefix(j.m_data.m_value.number_float);
-
-    case value_t::string:
-      return 'S';
-
-    case value_t::array: // fallthrough
-    case value_t::binary:
-      return '[';
-
-    case value_t::object:
-      return '{';
-
-    case value_t::discarded:
-    default: // discarded values
-      return 'N';
-    }
-  }
-
-  static constexpr CharType get_ubjson_float_prefix(float /*unused*/) {
-    return 'd'; // float 32
-  }
-
-  static constexpr CharType get_ubjson_float_prefix(double /*unused*/) {
-    return 'D'; // float 64
-  }
-
-  /*!
-  @return false if the object is successfully converted to a bjdata ndarray,
-  true if the type or size is invalid
-  */
-  bool write_bjdata_ndarray(const typename BasicJsonType::object_t &value,
-                            const bool use_count, const bool use_type) {
-    std::map<string_t, CharType> bjdtype = {
-        {"uint8", 'U'},  {"int8", 'i'},   {"uint16", 'u'}, {"int16", 'I'},
-        {"uint32", 'm'}, {"int32", 'l'},  {"uint64", 'M'}, {"int64", 'L'},
-        {"single", 'd'}, {"double", 'D'}, {"char", 'C'}};
-
-    string_t key = "_ArrayType_";
-    auto it = bjdtype.find(static_cast<string_t>(value.at(key)));
-    if (it == bjdtype.end()) {
-      return true;
-    }
-    CharType dtype = it->second;
-
-    key = "_ArraySize_";
-    std::size_t len = (value.at(key).empty() ? 0 : 1);
-    for (const auto &el : value.at(key)) {
-      len *= static_cast<std::size_t>(el.m_data.m_value.number_unsigned);
-    }
-
-    key = "_ArrayData_";
-    if (value.at(key).size() != len) {
-      return true;
-    }
-
-    oa->write_character('[');
-    oa->write_character('$');
-    oa->write_character(dtype);
-    oa->write_character('#');
-
-    key = "_ArraySize_";
-    write_ubjson(value.at(key), use_count, use_type, true, true);
-
-    key = "_ArrayData_";
-    if (dtype == 'U' || dtype == 'C') {
-      for (const auto &el : value.at(key)) {
-        write_number(
-            static_cast<std::uint8_t>(el.m_data.m_value.number_unsigned), true);
-      }
-    } else if (dtype == 'i') {
-      for (const auto &el : value.at(key)) {
-        write_number(static_cast<std::int8_t>(el.m_data.m_value.number_integer),
-                     true);
-      }
-    } else if (dtype == 'u') {
-      for (const auto &el : value.at(key)) {
-        write_number(
-            static_cast<std::uint16_t>(el.m_data.m_value.number_unsigned),
-            true);
-      }
-    } else if (dtype == 'I') {
-      for (const auto &el : value.at(key)) {
-        write_number(
-            static_cast<std::int16_t>(el.m_data.m_value.number_integer), true);
-      }
-    } else if (dtype == 'm') {
-      for (const auto &el : value.at(key)) {
-        write_number(
-            static_cast<std::uint32_t>(el.m_data.m_value.number_unsigned),
-            true);
-      }
-    } else if (dtype == 'l') {
-      for (const auto &el : value.at(key)) {
-        write_number(
-            static_cast<std::int32_t>(el.m_data.m_value.number_integer), true);
-      }
-    } else if (dtype == 'M') {
-      for (const auto &el : value.at(key)) {
-        write_number(
-            static_cast<std::uint64_t>(el.m_data.m_value.number_unsigned),
-            true);
-      }
-    } else if (dtype == 'L') {
-      for (const auto &el : value.at(key)) {
-        write_number(
-            static_cast<std::int64_t>(el.m_data.m_value.number_integer), true);
-      }
-    } else if (dtype == 'd') {
-      for (const auto &el : value.at(key)) {
-        write_number(static_cast<float>(el.m_data.m_value.number_float), true);
-      }
-    } else if (dtype == 'D') {
-      for (const auto &el : value.at(key)) {
-        write_number(static_cast<double>(el.m_data.m_value.number_float), true);
-      }
-    }
-    return false;
-  }
-
-  ///////////////////////
-  // Utility functions //
-  ///////////////////////
-
-  /*
-  @brief write a number to output input
-  @param[in] n number of type @a NumberType
-  @param[in] OutputIsLittleEndian Set to true if output data is
-                               required to be little endian
-  @tparam NumberType the type of the number
-
-  @note This function needs to respect the system's endianness, because bytes
-        in CBOR, MessagePack, and UBJSON are stored in network order (big
-        endian) and therefore need reordering on little endian systems.
-        On the other hand, BSON and BJData use little endian and should reorder
-        on big endian systems.
-  */
-  template <typename NumberType>
-  void write_number(const NumberType n,
-                    const bool OutputIsLittleEndian = false) {
-    // step 1: write number to array of length NumberType
-    std::array<CharType, sizeof(NumberType)> vec{};
-    std::memcpy(vec.data(), &n, sizeof(NumberType));
-
-    // step 2: write array to output (with possible reordering)
-    if (is_little_endian != OutputIsLittleEndian) {
-      // reverse byte order prior to conversion if necessary
-      std::reverse(vec.begin(), vec.end());
-    }
-
-    oa->write_characters(vec.data(), sizeof(NumberType));
-  }
-
-  void write_compact_float(const number_float_t n,
-                           detail::input_format_t format) {
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-    if (static_cast<double>(n) >=
-            static_cast<double>(std::numeric_limits<float>::lowest()) &&
-        static_cast<double>(n) <=
-            static_cast<double>((std::numeric_limits<float>::max)()) &&
-        static_cast<double>(static_cast<float>(n)) == static_cast<double>(n)) {
-      oa->write_character(
-          format == detail::input_format_t::cbor
-              ? get_cbor_float_prefix(static_cast<float>(n))
-              : get_msgpack_float_prefix(static_cast<float>(n)));
-      write_number(static_cast<float>(n));
-    } else {
-      oa->write_character(format == detail::input_format_t::cbor
-                              ? get_cbor_float_prefix(n)
-                              : get_msgpack_float_prefix(n));
-      write_number(n);
-    }
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-  }
-
-public:
-  // The following to_char_type functions are implement the conversion
-  // between uint8_t and CharType. In case CharType is not unsigned,
-  // such a conversion is required to allow values greater than 128.
-  // See <https://github.com/nlohmann/json/issues/1286> for a discussion.
-  template <typename C = CharType,
-            enable_if_t<std::is_signed<C>::value && std::is_signed<char>::value>
-                * = nullptr>
-  static constexpr CharType to_char_type(std::uint8_t x) noexcept {
-    return *reinterpret_cast<char *>(&x);
-  }
-
-  template <typename C = CharType,
-            enable_if_t<std::is_signed<C>::value &&
-                        std::is_unsigned<char>::value> * = nullptr>
-  static CharType to_char_type(std::uint8_t x) noexcept {
-    static_assert(sizeof(std::uint8_t) == sizeof(CharType),
-                  "size of CharType must be equal to std::uint8_t");
-    static_assert(std::is_trivial<CharType>::value, "CharType must be trivial");
-    CharType result;
-    std::memcpy(&result, &x, sizeof(x));
-    return result;
-  }
-
-  template <typename C = CharType,
-            enable_if_t<std::is_unsigned<C>::value> * = nullptr>
-  static constexpr CharType to_char_type(std::uint8_t x) noexcept {
-    return x;
-  }
-
-  template <
-      typename InputCharType, typename C = CharType,
-      enable_if_t<std::is_signed<C>::value && std::is_signed<char>::value &&
-                  std::is_same<char, typename std::remove_cv<InputCharType>::
-                                         type>::value> * = nullptr>
-  static constexpr CharType to_char_type(InputCharType x) noexcept {
-    return x;
-  }
-
-private:
-  /// whether we can assume little endianness
-  const bool is_little_endian = little_endianness();
-
-  /// the output
-  output_adapter_t<CharType> oa = nullptr;
-};
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/output/output_adapters.hpp>
-
-// #include <nlohmann/detail/output/serializer.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2008 - 2009 Björn Hoehrmann <bjoern@hoehrmann.de>
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <algorithm>   // reverse, remove, fill, find, none_of
-#include <array>       // array
-#include <clocale>     // localeconv, lconv
-#include <cmath>       // labs, isfinite, isnan, signbit
-#include <cstddef>     // size_t, ptrdiff_t
-#include <cstdint>     // uint8_t
-#include <cstdio>      // snprintf
-#include <iomanip>     // setfill, setw
-#include <limits>      // numeric_limits
-#include <string>      // string, char_traits
-#include <type_traits> // is_same
-#include <utility>     // move
-
-// #include <nlohmann/detail/conversions/to_chars.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2009 Florian Loitsch <https://florian.loitsch.com/>
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <array>       // array
-#include <cmath>       // signbit, isfinite
-#include <cstdint>     // intN_t, uintN_t
-#include <cstring>     // memcpy, memmove
-#include <limits>      // numeric_limits
-#include <type_traits> // conditional
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-/*!
-@brief implements the Grisu2 algorithm for binary to decimal floating-point
-conversion.
-
-This implementation is a slightly modified version of the reference
-implementation which may be obtained from
-http://florian.loitsch.com/publications (bench.tar.gz).
-
-The code is distributed under the MIT license, Copyright (c) 2009 Florian
-Loitsch.
-
-For a detailed description of the algorithm see:
-
-[1] Loitsch, "Printing Floating-Point Numbers Quickly and Accurately with
-    Integers", Proceedings of the ACM SIGPLAN 2010 Conference on Programming
-    Language Design and Implementation, PLDI 2010
-[2] Burger, Dybvig, "Printing Floating-Point Numbers Quickly and Accurately",
-    Proceedings of the ACM SIGPLAN 1996 Conference on Programming Language
-    Design and Implementation, PLDI 1996
-*/
-namespace dtoa_impl {
-
-template <typename Target, typename Source>
-Target reinterpret_bits(const Source source) {
-  static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
-
-  Target target;
-  std::memcpy(&target, &source, sizeof(Source));
-  return target;
-}
-
-struct diyfp // f * 2^e
-{
-  static constexpr int kPrecision = 64; // = q
-
-  std::uint64_t f = 0;
-  int e = 0;
-
-  constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
-
-  /*!
-  @brief returns x - y
-  @pre x.e == y.e and x.f >= y.f
-  */
-  static diyfp sub(const diyfp &x, const diyfp &y) noexcept {
-    JSON_ASSERT(x.e == y.e);
-    JSON_ASSERT(x.f >= y.f);
-
-    return {x.f - y.f, x.e};
-  }
-
-  /*!
-  @brief returns x * y
-  @note The result is rounded. (Only the upper q bits are returned.)
-  */
-  static diyfp mul(const diyfp &x, const diyfp &y) noexcept {
-    static_assert(kPrecision == 64, "internal error");
-
-    // Computes:
-    //  f = round((x.f * y.f) / 2^q)
-    //  e = x.e + y.e + q
-
-    // Emulate the 64-bit * 64-bit multiplication:
-    //
-    // p = u * v
-    //   = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
-    //   = (u_lo v_lo         ) + 2^32 ((u_lo v_hi         ) + (u_hi v_lo )) +
-    //   2^64 (u_hi v_hi         ) = (p0                ) + 2^32 ((p1 ) + (p2 ))
-    //   + 2^64 (p3                ) = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo +
-    //   2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3                ) =
-    //   (p0_lo             ) + 2^32 (p0_hi + p1_lo + p2_lo ) + 2^64 (p1_hi +
-    //   p2_hi + p3) = (p0_lo             ) + 2^32 (Q ) + 2^64 (H ) = (p0_lo ) +
-    //   2^32 (Q_lo + 2^32 Q_hi                           ) + 2^64 (H )
-    //
-    // (Since Q might be larger than 2^32 - 1)
-    //
-    //   = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
-    //
-    // (Q_hi + H does not overflow a 64-bit int)
-    //
-    //   = p_lo + 2^64 p_hi
-
-    const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
-    const std::uint64_t u_hi = x.f >> 32u;
-    const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
-    const std::uint64_t v_hi = y.f >> 32u;
-
-    const std::uint64_t p0 = u_lo * v_lo;
-    const std::uint64_t p1 = u_lo * v_hi;
-    const std::uint64_t p2 = u_hi * v_lo;
-    const std::uint64_t p3 = u_hi * v_hi;
-
-    const std::uint64_t p0_hi = p0 >> 32u;
-    const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
-    const std::uint64_t p1_hi = p1 >> 32u;
-    const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
-    const std::uint64_t p2_hi = p2 >> 32u;
-
-    std::uint64_t Q = p0_hi + p1_lo + p2_lo;
-
-    // The full product might now be computed as
-    //
-    // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
-    // p_lo = p0_lo + (Q << 32)
-    //
-    // But in this particular case here, the full p_lo is not required.
-    // Effectively we only need to add the highest bit in p_lo to p_hi (and
-    // Q_hi + 1 does not overflow).
-
-    Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
-
-    const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
-
-    return {h, x.e + y.e + 64};
-  }
-
-  /*!
-  @brief normalize x such that the significand is >= 2^(q-1)
-  @pre x.f != 0
-  */
-  static diyfp normalize(diyfp x) noexcept {
-    JSON_ASSERT(x.f != 0);
-
-    while ((x.f >> 63u) == 0) {
-      x.f <<= 1u;
-      x.e--;
-    }
-
-    return x;
-  }
-
-  /*!
-  @brief normalize x such that the result has the exponent E
-  @pre e >= x.e and the upper e - x.e bits of x.f must be zero.
-  */
-  static diyfp normalize_to(const diyfp &x,
-                            const int target_exponent) noexcept {
-    const int delta = x.e - target_exponent;
-
-    JSON_ASSERT(delta >= 0);
-    JSON_ASSERT(((x.f << delta) >> delta) == x.f);
-
-    return {x.f << delta, target_exponent};
-  }
-};
-
-struct boundaries {
-  diyfp w;
-  diyfp minus;
-  diyfp plus;
-};
-
-/*!
-Compute the (normalized) diyfp representing the input number 'value' and its
-boundaries.
-
-@pre value must be finite and positive
-*/
-template <typename FloatType> boundaries compute_boundaries(FloatType value) {
-  JSON_ASSERT(std::isfinite(value));
-  JSON_ASSERT(value > 0);
-
-  // Convert the IEEE representation into a diyfp.
-  //
-  // If v is denormal:
-  //      value = 0.F * 2^(1 - bias) = (          F) * 2^(1 - bias - (p-1))
-  // If v is normalized:
-  //      value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
-
-  static_assert(std::numeric_limits<FloatType>::is_iec559,
-                "internal error: dtoa_short requires an IEEE-754 "
-                "floating-point implementation");
-
-  constexpr int kPrecision =
-      std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
-  constexpr int kBias =
-      std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
-  constexpr int kMinExp = 1 - kBias;
-  constexpr std::uint64_t kHiddenBit = std::uint64_t{1}
-                                       << (kPrecision - 1); // = 2^(p-1)
-
-  using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t,
-                                              std::uint64_t>::type;
-
-  const auto bits =
-      static_cast<std::uint64_t>(reinterpret_bits<bits_type>(value));
-  const std::uint64_t E = bits >> (kPrecision - 1);
-  const std::uint64_t F = bits & (kHiddenBit - 1);
-
-  const bool is_denormal = E == 0;
-  const diyfp v = is_denormal
-                      ? diyfp(F, kMinExp)
-                      : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
-
-  // Compute the boundaries m- and m+ of the floating-point value
-  // v = f * 2^e.
-  //
-  // Determine v- and v+, the floating-point predecessor and successor if v,
-  // respectively.
-  //
-  //      v- = v - 2^e        if f != 2^(p-1) or e == e_min                (A)
-  //         = v - 2^(e-1)    if f == 2^(p-1) and e > e_min                (B)
-  //
-  //      v+ = v + 2^e
-  //
-  // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
-  // between m- and m+ round to v, regardless of how the input rounding
-  // algorithm breaks ties.
-  //
-  //      ---+-------------+-------------+-------------+-------------+---  (A)
-  //         v-            m-            v             m+            v+
-  //
-  //      -----------------+------+------+-------------+-------------+---  (B)
-  //                       v-     m-     v             m+            v+
-
-  const bool lower_boundary_is_closer = F == 0 && E > 1;
-  const diyfp m_plus = diyfp((2 * v.f) + 1, v.e - 1);
-  const diyfp m_minus = lower_boundary_is_closer
-                            ? diyfp((4 * v.f) - 1, v.e - 2)  // (B)
-                            : diyfp((2 * v.f) - 1, v.e - 1); // (A)
-
-  // Determine the normalized w+ = m+.
-  const diyfp w_plus = diyfp::normalize(m_plus);
-
-  // Determine w- = m- such that e_(w-) = e_(w+).
-  const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
-
-  return {diyfp::normalize(v), w_minus, w_plus};
-}
-
-// Given normalized diyfp w, Grisu needs to find a (normalized) cached
-// power-of-ten c, such that the exponent of the product c * w = f * 2^e lies
-// within a certain range [alpha, gamma] (Definition 3.2 from [1])
-//
-//      alpha <= e = e_c + e_w + q <= gamma
-//
-// or
-//
-//      f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q
-//                          <= f_c * f_w * 2^gamma
-//
-// Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies
-//
-//      2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma
-//
-// or
-//
-//      2^(q - 2 + alpha) <= c * w < 2^(q + gamma)
-//
-// The choice of (alpha,gamma) determines the size of the table and the form of
-// the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well
-// in practice:
-//
-// The idea is to cut the number c * w = f * 2^e into two parts, which can be
-// processed independently: An integral part p1, and a fractional part p2:
-//
-//      f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e
-//              = (f div 2^-e) + (f mod 2^-e) * 2^e
-//              = p1 + p2 * 2^e
-//
-// The conversion of p1 into decimal form requires a series of divisions and
-// modulos by (a power of) 10. These operations are faster for 32-bit than for
-// 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be
-// achieved by choosing
-//
-//      -e >= 32   or   e <= -32 := gamma
-//
-// In order to convert the fractional part
-//
-//      p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...
-//
-// into decimal form, the fraction is repeatedly multiplied by 10 and the digits
-// d[-i] are extracted in order:
-//
-//      (10 * p2) div 2^-e = d[-1]
-//      (10 * p2) mod 2^-e = d[-2] / 10^1 + ...
-//
-// The multiplication by 10 must not overflow. It is sufficient to choose
-//
-//      10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.
-//
-// Since p2 = f mod 2^-e < 2^-e,
-//
-//      -e <= 60   or   e >= -60 := alpha
-
-constexpr int kAlpha = -60;
-constexpr int kGamma = -32;
-
-struct cached_power // c = f * 2^e ~= 10^k
-{
-  std::uint64_t f;
-  int e;
-  int k;
-};
-
-/*!
-For a normalized diyfp w = f * 2^e, this function returns a (normalized) cached
-power-of-ten c = f_c * 2^e_c, such that the exponent of the product w * c
-satisfies (Definition 3.2 from [1])
-
-     alpha <= e_c + e + q <= gamma.
-*/
-inline cached_power get_cached_power_for_binary_exponent(int e) {
-  // Now
-  //
-  //      alpha <= e_c + e + q <= gamma                                    (1)
-  //      ==> f_c * 2^alpha <= c * 2^e * 2^q
-  //
-  // and since the c's are normalized, 2^(q-1) <= f_c,
-  //
-  //      ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
-  //      ==> 2^(alpha - e - 1) <= c
-  //
-  // If c were an exact power of ten, i.e. c = 10^k, one may determine k as
-  //
-  //      k = ceil( log_10( 2^(alpha - e - 1) ) )
-  //        = ceil( (alpha - e - 1) * log_10(2) )
-  //
-  // From the paper:
-  // "In theory the result of the procedure could be wrong since c is rounded,
-  //  and the computation itself is approximated [...]. In practice, however,
-  //  this simple function is sufficient."
-  //
-  // For IEEE double precision floating-point numbers converted into
-  // normalized diyfp's w = f * 2^e, with q = 64,
-  //
-  //      e >= -1022      (min IEEE exponent)
-  //           -52        (p - 1)
-  //           -52        (p - 1, possibly normalize denormal IEEE numbers)
-  //           -11        (normalize the diyfp)
-  //         = -1137
-  //
-  // and
-  //
-  //      e <= +1023      (max IEEE exponent)
-  //           -52        (p - 1)
-  //           -11        (normalize the diyfp)
-  //         = 960
-  //
-  // This binary exponent range [-1137,960] results in a decimal exponent
-  // range [-307,324]. One does not need to store a cached power for each
-  // k in this range. For each such k it suffices to find a cached power
-  // such that the exponent of the product lies in [alpha,gamma].
-  // This implies that the difference of the decimal exponents of adjacent
-  // table entries must be less than or equal to
-  //
-  //      floor( (gamma - alpha) * log_10(2) ) = 8.
-  //
-  // (A smaller distance gamma-alpha would require a larger table.)
-
-  // NB:
-  // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.
-
-  constexpr int kCachedPowersMinDecExp = -300;
-  constexpr int kCachedPowersDecStep = 8;
-
-  static constexpr std::array<cached_power, 79> kCachedPowers = {{
-      {0xAB70FE17C79AC6CA, -1060, -300}, {0xFF77B1FCBEBCDC4F, -1034, -292},
-      {0xBE5691EF416BD60C, -1007, -284}, {0x8DD01FAD907FFC3C, -980, -276},
-      {0xD3515C2831559A83, -954, -268},  {0x9D71AC8FADA6C9B5, -927, -260},
-      {0xEA9C227723EE8BCB, -901, -252},  {0xAECC49914078536D, -874, -244},
-      {0x823C12795DB6CE57, -847, -236},  {0xC21094364DFB5637, -821, -228},
-      {0x9096EA6F3848984F, -794, -220},  {0xD77485CB25823AC7, -768, -212},
-      {0xA086CFCD97BF97F4, -741, -204},  {0xEF340A98172AACE5, -715, -196},
-      {0xB23867FB2A35B28E, -688, -188},  {0x84C8D4DFD2C63F3B, -661, -180},
-      {0xC5DD44271AD3CDBA, -635, -172},  {0x936B9FCEBB25C996, -608, -164},
-      {0xDBAC6C247D62A584, -582, -156},  {0xA3AB66580D5FDAF6, -555, -148},
-      {0xF3E2F893DEC3F126, -529, -140},  {0xB5B5ADA8AAFF80B8, -502, -132},
-      {0x87625F056C7C4A8B, -475, -124},  {0xC9BCFF6034C13053, -449, -116},
-      {0x964E858C91BA2655, -422, -108},  {0xDFF9772470297EBD, -396, -100},
-      {0xA6DFBD9FB8E5B88F, -369, -92},   {0xF8A95FCF88747D94, -343, -84},
-      {0xB94470938FA89BCF, -316, -76},   {0x8A08F0F8BF0F156B, -289, -68},
-      {0xCDB02555653131B6, -263, -60},   {0x993FE2C6D07B7FAC, -236, -52},
-      {0xE45C10C42A2B3B06, -210, -44},   {0xAA242499697392D3, -183, -36},
-      {0xFD87B5F28300CA0E, -157, -28},   {0xBCE5086492111AEB, -130, -20},
-      {0x8CBCCC096F5088CC, -103, -12},   {0xD1B71758E219652C, -77, -4},
-      {0x9C40000000000000, -50, 4},      {0xE8D4A51000000000, -24, 12},
-      {0xAD78EBC5AC620000, 3, 20},       {0x813F3978F8940984, 30, 28},
-      {0xC097CE7BC90715B3, 56, 36},      {0x8F7E32CE7BEA5C70, 83, 44},
-      {0xD5D238A4ABE98068, 109, 52},     {0x9F4F2726179A2245, 136, 60},
-      {0xED63A231D4C4FB27, 162, 68},     {0xB0DE65388CC8ADA8, 189, 76},
-      {0x83C7088E1AAB65DB, 216, 84},     {0xC45D1DF942711D9A, 242, 92},
-      {0x924D692CA61BE758, 269, 100},    {0xDA01EE641A708DEA, 295, 108},
-      {0xA26DA3999AEF774A, 322, 116},    {0xF209787BB47D6B85, 348, 124},
-      {0xB454E4A179DD1877, 375, 132},    {0x865B86925B9BC5C2, 402, 140},
-      {0xC83553C5C8965D3D, 428, 148},    {0x952AB45CFA97A0B3, 455, 156},
-      {0xDE469FBD99A05FE3, 481, 164},    {0xA59BC234DB398C25, 508, 172},
-      {0xF6C69A72A3989F5C, 534, 180},    {0xB7DCBF5354E9BECE, 561, 188},
-      {0x88FCF317F22241E2, 588, 196},    {0xCC20CE9BD35C78A5, 614, 204},
-      {0x98165AF37B2153DF, 641, 212},    {0xE2A0B5DC971F303A, 667, 220},
-      {0xA8D9D1535CE3B396, 694, 228},    {0xFB9B7CD9A4A7443C, 720, 236},
-      {0xBB764C4CA7A44410, 747, 244},    {0x8BAB8EEFB6409C1A, 774, 252},
-      {0xD01FEF10A657842C, 800, 260},    {0x9B10A4E5E9913129, 827, 268},
-      {0xE7109BFBA19C0C9D, 853, 276},    {0xAC2820D9623BF429, 880, 284},
-      {0x80444B5E7AA7CF85, 907, 292},    {0xBF21E44003ACDD2D, 933, 300},
-      {0x8E679C2F5E44FF8F, 960, 308},    {0xD433179D9C8CB841, 986, 316},
-      {0x9E19DB92B4E31BA9, 1013, 324},
-  }};
-
-  // This computation gives exactly the same results for k as
-  //      k = ceil((kAlpha - e - 1) * 0.30102999566398114)
-  // for |e| <= 1500, but doesn't require floating-point operations.
-  // NB: log_10(2) ~= 78913 / 2^18
-  JSON_ASSERT(e >= -1500);
-  JSON_ASSERT(e <= 1500);
-  const int f = kAlpha - e - 1;
-  const int k = ((f * 78913) / (1 << 18)) + static_cast<int>(f > 0);
-
-  const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) /
-                    kCachedPowersDecStep;
-  JSON_ASSERT(index >= 0);
-  JSON_ASSERT(static_cast<std::size_t>(index) < kCachedPowers.size());
-
-  const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
-  JSON_ASSERT(kAlpha <= cached.e + e + 64);
-  JSON_ASSERT(kGamma >= cached.e + e + 64);
-
-  return cached;
-}
-
-/*!
-For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k.
-For n == 0, returns 1 and sets pow10 := 1.
-*/
-inline int find_largest_pow10(const std::uint32_t n, std::uint32_t &pow10) {
-  // LCOV_EXCL_START
-  if (n >= 1000000000) {
-    pow10 = 1000000000;
-    return 10;
-  }
-  // LCOV_EXCL_STOP
-  if (n >= 100000000) {
-    pow10 = 100000000;
-    return 9;
-  }
-  if (n >= 10000000) {
-    pow10 = 10000000;
-    return 8;
-  }
-  if (n >= 1000000) {
-    pow10 = 1000000;
-    return 7;
-  }
-  if (n >= 100000) {
-    pow10 = 100000;
-    return 6;
-  }
-  if (n >= 10000) {
-    pow10 = 10000;
-    return 5;
-  }
-  if (n >= 1000) {
-    pow10 = 1000;
-    return 4;
-  }
-  if (n >= 100) {
-    pow10 = 100;
-    return 3;
-  }
-  if (n >= 10) {
-    pow10 = 10;
-    return 2;
-  }
-
-  pow10 = 1;
-  return 1;
-}
-
-inline void grisu2_round(char *buf, int len, std::uint64_t dist,
-                         std::uint64_t delta, std::uint64_t rest,
-                         std::uint64_t ten_k) {
-  JSON_ASSERT(len >= 1);
-  JSON_ASSERT(dist <= delta);
-  JSON_ASSERT(rest <= delta);
-  JSON_ASSERT(ten_k > 0);
-
-  //               <--------------------------- delta ---->
-  //                                  <---- dist --------->
-  // --------------[------------------+-------------------]--------------
-  //               M-                 w                   M+
-  //
-  //                                  ten_k
-  //                                <------>
-  //                                       <---- rest ---->
-  // --------------[------------------+----+--------------]--------------
-  //                                  w    V
-  //                                       = buf * 10^k
-  //
-  // ten_k represents a unit-in-the-last-place in the decimal representation
-  // stored in buf.
-  // Decrement buf by ten_k while this takes buf closer to w.
-
-  // The tests are written in this order to avoid overflow in unsigned
-  // integer arithmetic.
-
-  while (rest < dist && delta - rest >= ten_k &&
-         (rest + ten_k < dist || dist - rest > rest + ten_k - dist)) {
-    JSON_ASSERT(buf[len - 1] != '0');
-    buf[len - 1]--;
-    rest += ten_k;
-  }
-}
-
-/*!
-Generates V = buffer * 10^decimal_exponent, such that M- <= V <= M+.
-M- and M+ must be normalized and share the same exponent -60 <= e <= -32.
-*/
-inline void grisu2_digit_gen(char *buffer, int &length, int &decimal_exponent,
-                             diyfp M_minus, diyfp w, diyfp M_plus) {
-  static_assert(kAlpha >= -60, "internal error");
-  static_assert(kGamma <= -32, "internal error");
-
-  // Generates the digits (and the exponent) of a decimal floating-point
-  // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
-  // w, M- and M+ share the same exponent e, which satisfies alpha <= e <=
-  // gamma.
-  //
-  //               <--------------------------- delta ---->
-  //                                  <---- dist --------->
-  // --------------[------------------+-------------------]--------------
-  //               M-                 w                   M+
-  //
-  // Grisu2 generates the digits of M+ from left to right and stops as soon as
-  // V is in [M-,M+].
-
-  JSON_ASSERT(M_plus.e >= kAlpha);
-  JSON_ASSERT(M_plus.e <= kGamma);
-
-  std::uint64_t delta =
-      diyfp::sub(M_plus, M_minus)
-          .f; // (significand of (M+ - M-), implicit exponent is e)
-  std::uint64_t dist =
-      diyfp::sub(M_plus, w)
-          .f; // (significand of (M+ - w ), implicit exponent is e)
-
-  // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
-  //
-  //      M+ = f * 2^e
-  //         = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
-  //         = ((p1        ) * 2^-e + (p2        )) * 2^e
-  //         = p1 + p2 * 2^e
-
-  const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
-
-  auto p1 = static_cast<std::uint32_t>(
-      M_plus.f >>
-      -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
-  std::uint64_t p2 = M_plus.f & (one.f - 1); // p2 = f mod 2^-e
-
-  // 1)
-  //
-  // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
-
-  JSON_ASSERT(p1 > 0);
-
-  std::uint32_t pow10{};
-  const int k = find_largest_pow10(p1, pow10);
-
-  //      10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
-  //
-  //      p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
-  //         = (d[k-1]         ) * 10^(k-1) + (p1 mod 10^(k-1))
-  //
-  //      M+ = p1                                             + p2 * 2^e
-  //         = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1))          + p2 * 2^e
-  //         = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
-  //         = d[k-1] * 10^(k-1) + (                         rest) * 2^e
-  //
-  // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
-  //
-  //      p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
-  //
-  // but stop as soon as
-  //
-  //      rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
-
-  int n = k;
-  while (n > 0) {
-    // Invariants:
-    //      M+ = buffer * 10^n + (p1 + p2 * 2^e)    (buffer = 0 for n = k)
-    //      pow10 = 10^(n-1) <= p1 < 10^n
-    //
-    const std::uint32_t d = p1 / pow10; // d = p1 div 10^(n-1)
-    const std::uint32_t r = p1 % pow10; // r = p1 mod 10^(n-1)
-    //
-    //      M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
-    //         = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
-    //
-    JSON_ASSERT(d <= 9);
-    buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
-    //
-    //      M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
-    //
-    p1 = r;
-    n--;
-    //
-    //      M+ = buffer * 10^n + (p1 + p2 * 2^e)
-    //      pow10 = 10^n
-    //
-
-    // Now check if enough digits have been generated.
-    // Compute
-    //
-    //      p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
-    //
-    // Note:
-    // Since rest and delta share the same exponent e, it suffices to
-    // compare the significands.
-    const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
-    if (rest <= delta) {
-      // V = buffer * 10^n, with M- <= V <= M+.
-
-      decimal_exponent += n;
-
-      // We may now just stop. But instead look if the buffer could be
-      // decremented to bring V closer to w.
-      //
-      // pow10 = 10^n is now 1 ulp in the decimal representation V.
-      // The rounding procedure works with diyfp's with an implicit
-      // exponent of e.
-      //
-      //      10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
-      //
-      const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
-      grisu2_round(buffer, length, dist, delta, rest, ten_n);
-
-      return;
-    }
-
-    pow10 /= 10;
-    //
-    //      pow10 = 10^(n-1) <= p1 < 10^n
-    // Invariants restored.
-  }
-
-  // 2)
-  //
-  // The digits of the integral part have been generated:
-  //
-  //      M+ = d[k-1]...d[1]d[0] + p2 * 2^e
-  //         = buffer            + p2 * 2^e
-  //
-  // Now generate the digits of the fractional part p2 * 2^e.
-  //
-  // Note:
-  // No decimal point is generated: the exponent is adjusted instead.
-  //
-  // p2 actually represents the fraction
-  //
-  //      p2 * 2^e
-  //          = p2 / 2^-e
-  //          = d[-1] / 10^1 + d[-2] / 10^2 + ...
-  //
-  // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
-  //
-  //      p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
-  //                      + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
-  //
-  // using
-  //
-  //      10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
-  //                = (                   d) * 2^-e + (                   r)
-  //
-  // or
-  //      10^m * p2 * 2^e = d + r * 2^e
-  //
-  // i.e.
-  //
-  //      M+ = buffer + p2 * 2^e
-  //         = buffer + 10^-m * (d + r * 2^e)
-  //         = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
-  //
-  // and stop as soon as 10^-m * r * 2^e <= delta * 2^e
-
-  JSON_ASSERT(p2 > delta);
-
-  int m = 0;
-  for (;;) {
-    // Invariant:
-    //      M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...)
-    //      * 2^e
-    //         = buffer * 10^-m + 10^-m * (p2                                 )
-    //         * 2^e = buffer * 10^-m + 10^-m * (1/10 * (10 * p2) ) * 2^e =
-    //         buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e +
-    //         (10*p2 mod 2^-e)) * 2^e
-    //
-    JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
-    p2 *= 10;
-    const std::uint64_t d = p2 >> -one.e;     // d = (10 * p2) div 2^-e
-    const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
-    //
-    //      M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
-    //         = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
-    //         = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
-    //
-    JSON_ASSERT(d <= 9);
-    buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
-    //
-    //      M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
-    //
-    p2 = r;
-    m++;
-    //
-    //      M+ = buffer * 10^-m + 10^-m * p2 * 2^e
-    // Invariant restored.
-
-    // Check if enough digits have been generated.
-    //
-    //      10^-m * p2 * 2^e <= delta * 2^e
-    //              p2 * 2^e <= 10^m * delta * 2^e
-    //                    p2 <= 10^m * delta
-    delta *= 10;
-    dist *= 10;
-    if (p2 <= delta) {
-      break;
-    }
-  }
-
-  // V = buffer * 10^-m, with M- <= V <= M+.
-
-  decimal_exponent -= m;
-
-  // 1 ulp in the decimal representation is now 10^-m.
-  // Since delta and dist are now scaled by 10^m, we need to do the
-  // same with ulp in order to keep the units in sync.
-  //
-  //      10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
-  //
-  const std::uint64_t ten_m = one.f;
-  grisu2_round(buffer, length, dist, delta, p2, ten_m);
-
-  // By construction this algorithm generates the shortest possible decimal
-  // number (Loitsch, Theorem 6.2) which rounds back to w.
-  // For an input number of precision p, at least
-  //
-  //      N = 1 + ceil(p * log_10(2))
-  //
-  // decimal digits are sufficient to identify all binary floating-point
-  // numbers (Matula, "In-and-Out conversions").
-  // This implies that the algorithm does not produce more than N decimal
-  // digits.
-  //
-  //      N = 17 for p = 53 (IEEE double precision)
-  //      N = 9  for p = 24 (IEEE single precision)
-}
-
-/*!
-v = buf * 10^decimal_exponent
-len is the length of the buffer (number of decimal digits)
-The buffer must be large enough, i.e. >= max_digits10.
-*/
-JSON_HEDLEY_NON_NULL(1)
-inline void grisu2(char *buf, int &len, int &decimal_exponent, diyfp m_minus,
-                   diyfp v, diyfp m_plus) {
-  JSON_ASSERT(m_plus.e == m_minus.e);
-  JSON_ASSERT(m_plus.e == v.e);
-
-  //  --------(-----------------------+-----------------------)--------    (A)
-  //          m-                      v                       m+
-  //
-  //  --------------------(-----------+-----------------------)--------    (B)
-  //                      m-          v                       m+
-  //
-  // First scale v (and m- and m+) such that the exponent is in the range
-  // [alpha, gamma].
-
-  const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
-
-  const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
-
-  // The exponent of the products is = v.e + c_minus_k.e + q and is in the range
-  // [alpha,gamma]
-  const diyfp w = diyfp::mul(v, c_minus_k);
-  const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
-  const diyfp w_plus = diyfp::mul(m_plus, c_minus_k);
-
-  //  ----(---+---)---------------(---+---)---------------(---+---)----
-  //          w-                      w                       w+
-  //          = c*m-                  = c*v                   = c*m+
-  //
-  // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
-  // w+ are now off by a small amount.
-  // In fact:
-  //
-  //      w - v * 10^k < 1 ulp
-  //
-  // To account for this inaccuracy, add resp. subtract 1 ulp.
-  //
-  //  --------+---[---------------(---+---)---------------]---+--------
-  //          w-  M-                  w                   M+  w+
-  //
-  // Now any number in [M-, M+] (bounds included) will round to w when input,
-  // regardless of how the input rounding algorithm breaks ties.
-  //
-  // And digit_gen generates the shortest possible such number in [M-, M+].
-  // Note that this does not mean that Grisu2 always generates the shortest
-  // possible number in the interval (m-, m+).
-  const diyfp M_minus(w_minus.f + 1, w_minus.e);
-  const diyfp M_plus(w_plus.f - 1, w_plus.e);
-
-  decimal_exponent = -cached.k; // = -(-k) = k
-
-  grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
-}
-
-/*!
-v = buf * 10^decimal_exponent
-len is the length of the buffer (number of decimal digits)
-The buffer must be large enough, i.e. >= max_digits10.
-*/
-template <typename FloatType>
-JSON_HEDLEY_NON_NULL(1)
-void grisu2(char *buf, int &len, int &decimal_exponent, FloatType value) {
-  static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
-                "internal error: not enough precision");
-
-  JSON_ASSERT(std::isfinite(value));
-  JSON_ASSERT(value > 0);
-
-  // If the neighbors (and boundaries) of 'value' are always computed for
-  // double-precision numbers, all float's can be recovered using strtod (and
-  // strtof). However, the resulting decimal representations are not exactly
-  // "short".
-  //
-  // The documentation for 'std::to_chars'
-  // (https://en.cppreference.com/w/cpp/utility/to_chars) says "value is
-  // converted to a string as if by std::sprintf in the default ("C") locale"
-  // and since sprintf promotes floats to doubles, I think this is exactly what
-  // 'std::to_chars' does. On the other hand, the documentation for
-  // 'std::to_chars' requires that "parsing the representation using the
-  // corresponding std::from_chars function recovers value exactly". That
-  // indicates that single precision floating-point numbers should be recovered
-  // using 'std::strtof'.
-  //
-  // NB: If the neighbors are computed for single-precision numbers, there is a
-  // single float
-  //     (7.0385307e-26f) which can't be recovered using strtod. The resulting
-  //     double precision value is off by 1 ulp.
-#if 0 // NOLINT(readability-avoid-unconditional-preprocessor-if)
-    const boundaries w = compute_boundaries(static_cast<double>(value));
-#else
-  const boundaries w = compute_boundaries(value);
-#endif
-
-  grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
-}
-
-/*!
-@brief appends a decimal representation of e to buf
-@return a pointer to the element following the exponent.
-@pre -1000 < e < 1000
-*/
-JSON_HEDLEY_NON_NULL(1)
-JSON_HEDLEY_RETURNS_NON_NULL
-inline char *append_exponent(char *buf, int e) {
-  JSON_ASSERT(e > -1000);
-  JSON_ASSERT(e < 1000);
-
-  if (e < 0) {
-    e = -e;
-    *buf++ = '-';
-  } else {
-    *buf++ = '+';
-  }
-
-  auto k = static_cast<std::uint32_t>(e);
-  if (k < 10) {
-    // Always print at least two digits in the exponent.
-    // This is for compatibility with printf("%g").
-    *buf++ = '0';
-    *buf++ = static_cast<char>('0' + k);
-  } else if (k < 100) {
-    *buf++ = static_cast<char>('0' + (k / 10));
-    k %= 10;
-    *buf++ = static_cast<char>('0' + k);
-  } else {
-    *buf++ = static_cast<char>('0' + (k / 100));
-    k %= 100;
-    *buf++ = static_cast<char>('0' + (k / 10));
-    k %= 10;
-    *buf++ = static_cast<char>('0' + k);
-  }
-
-  return buf;
-}
-
-/*!
-@brief prettify v = buf * 10^decimal_exponent
-
-If v is in the range [10^min_exp, 10^max_exp) it will be printed in fixed-point
-notation. Otherwise it will be printed in exponential notation.
-
-@pre min_exp < 0
-@pre max_exp > 0
-*/
-JSON_HEDLEY_NON_NULL(1)
-JSON_HEDLEY_RETURNS_NON_NULL
-inline char *format_buffer(char *buf, int len, int decimal_exponent,
-                           int min_exp, int max_exp) {
-  JSON_ASSERT(min_exp < 0);
-  JSON_ASSERT(max_exp > 0);
-
-  const int k = len;
-  const int n = len + decimal_exponent;
-
-  // v = buf * 10^(n-k)
-  // k is the length of the buffer (number of decimal digits)
-  // n is the position of the decimal point relative to the start of the buffer.
-
-  if (k <= n && n <= max_exp) {
-    // digits[000]
-    // len <= max_exp + 2
-
-    std::memset(buf + k, '0', static_cast<size_t>(n) - static_cast<size_t>(k));
-    // Make it look like a floating-point number (#362, #378)
-    buf[n + 0] = '.';
-    buf[n + 1] = '0';
-    return buf + (static_cast<size_t>(n) + 2);
-  }
-
-  if (0 < n && n <= max_exp) {
-    // dig.its
-    // len <= max_digits10 + 1
-
-    JSON_ASSERT(k > n);
-
-    std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n,
-                 static_cast<size_t>(k) - static_cast<size_t>(n));
-    buf[n] = '.';
-    return buf + (static_cast<size_t>(k) + 1U);
-  }
-
-  if (min_exp < n && n <= 0) {
-    // 0.[000]digits
-    // len <= 2 + (-min_exp - 1) + max_digits10
-
-    std::memmove(buf + (2 + static_cast<size_t>(-n)), buf,
-                 static_cast<size_t>(k));
-    buf[0] = '0';
-    buf[1] = '.';
-    std::memset(buf + 2, '0', static_cast<size_t>(-n));
-    return buf + (2U + static_cast<size_t>(-n) + static_cast<size_t>(k));
-  }
-
-  if (k == 1) {
-    // dE+123
-    // len <= 1 + 5
-
-    buf += 1;
-  } else {
-    // d.igitsE+123
-    // len <= max_digits10 + 1 + 5
-
-    std::memmove(buf + 2, buf + 1, static_cast<size_t>(k) - 1);
-    buf[1] = '.';
-    buf += 1 + static_cast<size_t>(k);
-  }
-
-  *buf++ = 'e';
-  return append_exponent(buf, n - 1);
-}
-
-} // namespace dtoa_impl
-
-/*!
-@brief generates a decimal representation of the floating-point number value in
-[first, last).
-
-The format of the resulting decimal representation is similar to printf's %g
-format. Returns an iterator pointing past-the-end of the decimal representation.
-
-@note The input number must be finite, i.e. NaN's and Inf's are not supported.
-@note The buffer must be large enough.
-@note The result is NOT null-terminated.
-*/
-template <typename FloatType>
-JSON_HEDLEY_NON_NULL(1, 2)
-JSON_HEDLEY_RETURNS_NON_NULL
-    char *to_chars(char *first, const char *last, FloatType value) {
-  static_cast<void>(last); // maybe unused - fix warning
-  JSON_ASSERT(std::isfinite(value));
-
-  // Use signbit(value) instead of (value < 0) since signbit works for -0.
-  if (std::signbit(value)) {
-    value = -value;
-    *first++ = '-';
-  }
-
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-  if (value == 0) // +-0
-  {
-    *first++ = '0';
-    // Make it look like a floating-point number (#362, #378)
-    *first++ = '.';
-    *first++ = '0';
-    return first;
-  }
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-
-  JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
-
-  // Compute v = buffer * 10^decimal_exponent.
-  // The decimal digits are stored in the buffer, which needs to be interpreted
-  // as an unsigned decimal integer.
-  // len is the length of the buffer, i.e. the number of decimal digits.
-  int len = 0;
-  int decimal_exponent = 0;
-  dtoa_impl::grisu2(first, len, decimal_exponent, value);
-
-  JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
-
-  // Format the buffer like printf("%.*g", prec, value)
-  constexpr int kMinExp = -4;
-  // Use digits10 here to increase compatibility with version 2.
-  constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
-
-  JSON_ASSERT(last - first >= kMaxExp + 2);
-  JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) +
-                                  std::numeric_limits<FloatType>::max_digits10);
-  JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
-
-  return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp,
-                                  kMaxExp);
-}
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/exceptions.hpp>
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/meta/cpp_future.hpp>
-
-// #include <nlohmann/detail/output/binary_writer.hpp>
-
-// #include <nlohmann/detail/output/output_adapters.hpp>
-
-// #include <nlohmann/detail/string_concat.hpp>
-
-// #include <nlohmann/detail/value_t.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail {
-
-///////////////////
-// serialization //
-///////////////////
-
-/// how to treat decoding errors
-enum class error_handler_t {
-  strict,  ///< throw a type_error exception in case of invalid UTF-8
-  replace, ///< replace invalid UTF-8 sequences with U+FFFD
-  ignore   ///< ignore invalid UTF-8 sequences
-};
-
-template <typename BasicJsonType> class serializer {
-  using string_t = typename BasicJsonType::string_t;
-  using number_float_t = typename BasicJsonType::number_float_t;
-  using number_integer_t = typename BasicJsonType::number_integer_t;
-  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-  using binary_char_t = typename BasicJsonType::binary_t::value_type;
-  static constexpr std::uint8_t UTF8_ACCEPT = 0;
-  static constexpr std::uint8_t UTF8_REJECT = 1;
-
-public:
-  /*!
-  @param[in] s  output stream to serialize to
-  @param[in] ichar  indentation character to use
-  @param[in] error_handler_  how to react on decoding errors
-  */
-  serializer(output_adapter_t<char> s, const char ichar,
-             error_handler_t error_handler_ = error_handler_t::strict)
-      : o(std::move(s)), loc(std::localeconv()),
-        thousands_sep(
-            loc->thousands_sep == nullptr
-                ? '\0'
-                : std::char_traits<char>::to_char_type(*(loc->thousands_sep))),
-        decimal_point(
-            loc->decimal_point == nullptr
-                ? '\0'
-                : std::char_traits<char>::to_char_type(*(loc->decimal_point))),
-        indent_char(ichar), indent_string(512, indent_char),
-        error_handler(error_handler_) {}
-
-  // delete because of pointer members
-  serializer(const serializer &) = delete;
-  serializer &operator=(const serializer &) = delete;
-  serializer(serializer &&) = delete;
-  serializer &operator=(serializer &&) = delete;
-  ~serializer() = default;
-
-  /*!
-  @brief internal implementation of the serialization function
-
-  This function is called by the public member function dump and organizes
-  the serialization internally. The indentation level is propagated as
-  additional parameter. In case of arrays and objects, the function is
-  called recursively.
-
-  - strings and object keys are escaped using `escape_string()`
-  - integer numbers are converted implicitly via `operator<<`
-  - floating-point numbers are converted to a string using `"%g"` format
-  - binary values are serialized as objects containing the subtype and the
-    byte array
-
-  @param[in] val               value to serialize
-  @param[in] pretty_print      whether the output shall be pretty-printed
-  @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters
-  in the output are escaped with `\uXXXX` sequences, and the result consists
-  of ASCII characters only.
-  @param[in] indent_step       the indent level
-  @param[in] current_indent    the current indent level (only used internally)
-  */
-  void dump(const BasicJsonType &val, const bool pretty_print,
-            const bool ensure_ascii, const unsigned int indent_step,
-            const unsigned int current_indent = 0) {
-    switch (val.m_data.m_type) {
-    case value_t::object: {
-      if (val.m_data.m_value.object->empty()) {
-        o->write_characters("{}", 2);
-        return;
-      }
-
-      if (pretty_print) {
-        o->write_characters("{\n", 2);
-
-        // variable to hold indentation for recursive calls
-        const auto new_indent = current_indent + indent_step;
-        if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent)) {
-          indent_string.resize(indent_string.size() * 2, ' ');
-        }
-
-        // first n-1 elements
-        auto i = val.m_data.m_value.object->cbegin();
-        for (std::size_t cnt = 0; cnt < val.m_data.m_value.object->size() - 1;
-             ++cnt, ++i) {
-          o->write_characters(indent_string.c_str(), new_indent);
-          o->write_character('\"');
-          dump_escaped(i->first, ensure_ascii);
-          o->write_characters("\": ", 3);
-          dump(i->second, true, ensure_ascii, indent_step, new_indent);
-          o->write_characters(",\n", 2);
-        }
-
-        // last element
-        JSON_ASSERT(i != val.m_data.m_value.object->cend());
-        JSON_ASSERT(std::next(i) == val.m_data.m_value.object->cend());
-        o->write_characters(indent_string.c_str(), new_indent);
-        o->write_character('\"');
-        dump_escaped(i->first, ensure_ascii);
-        o->write_characters("\": ", 3);
-        dump(i->second, true, ensure_ascii, indent_step, new_indent);
-
-        o->write_character('\n');
-        o->write_characters(indent_string.c_str(), current_indent);
-        o->write_character('}');
-      } else {
-        o->write_character('{');
-
-        // first n-1 elements
-        auto i = val.m_data.m_value.object->cbegin();
-        for (std::size_t cnt = 0; cnt < val.m_data.m_value.object->size() - 1;
-             ++cnt, ++i) {
-          o->write_character('\"');
-          dump_escaped(i->first, ensure_ascii);
-          o->write_characters("\":", 2);
-          dump(i->second, false, ensure_ascii, indent_step, current_indent);
-          o->write_character(',');
-        }
-
-        // last element
-        JSON_ASSERT(i != val.m_data.m_value.object->cend());
-        JSON_ASSERT(std::next(i) == val.m_data.m_value.object->cend());
-        o->write_character('\"');
-        dump_escaped(i->first, ensure_ascii);
-        o->write_characters("\":", 2);
-        dump(i->second, false, ensure_ascii, indent_step, current_indent);
-
-        o->write_character('}');
-      }
-
-      return;
-    }
-
-    case value_t::array: {
-      if (val.m_data.m_value.array->empty()) {
-        o->write_characters("[]", 2);
-        return;
-      }
-
-      if (pretty_print) {
-        o->write_characters("[\n", 2);
-
-        // variable to hold indentation for recursive calls
-        const auto new_indent = current_indent + indent_step;
-        if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent)) {
-          indent_string.resize(indent_string.size() * 2, ' ');
-        }
-
-        // first n-1 elements
-        for (auto i = val.m_data.m_value.array->cbegin();
-             i != val.m_data.m_value.array->cend() - 1; ++i) {
-          o->write_characters(indent_string.c_str(), new_indent);
-          dump(*i, true, ensure_ascii, indent_step, new_indent);
-          o->write_characters(",\n", 2);
-        }
-
-        // last element
-        JSON_ASSERT(!val.m_data.m_value.array->empty());
-        o->write_characters(indent_string.c_str(), new_indent);
-        dump(val.m_data.m_value.array->back(), true, ensure_ascii, indent_step,
-             new_indent);
-
-        o->write_character('\n');
-        o->write_characters(indent_string.c_str(), current_indent);
-        o->write_character(']');
-      } else {
-        o->write_character('[');
-
-        // first n-1 elements
-        for (auto i = val.m_data.m_value.array->cbegin();
-             i != val.m_data.m_value.array->cend() - 1; ++i) {
-          dump(*i, false, ensure_ascii, indent_step, current_indent);
-          o->write_character(',');
-        }
-
-        // last element
-        JSON_ASSERT(!val.m_data.m_value.array->empty());
-        dump(val.m_data.m_value.array->back(), false, ensure_ascii, indent_step,
-             current_indent);
-
-        o->write_character(']');
-      }
-
-      return;
-    }
-
-    case value_t::string: {
-      o->write_character('\"');
-      dump_escaped(*val.m_data.m_value.string, ensure_ascii);
-      o->write_character('\"');
-      return;
-    }
-
-    case value_t::binary: {
-      if (pretty_print) {
-        o->write_characters("{\n", 2);
-
-        // variable to hold indentation for recursive calls
-        const auto new_indent = current_indent + indent_step;
-        if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent)) {
-          indent_string.resize(indent_string.size() * 2, ' ');
-        }
-
-        o->write_characters(indent_string.c_str(), new_indent);
-
-        o->write_characters("\"bytes\": [", 10);
-
-        if (!val.m_data.m_value.binary->empty()) {
-          for (auto i = val.m_data.m_value.binary->cbegin();
-               i != val.m_data.m_value.binary->cend() - 1; ++i) {
-            dump_integer(*i);
-            o->write_characters(", ", 2);
-          }
-          dump_integer(val.m_data.m_value.binary->back());
-        }
-
-        o->write_characters("],\n", 3);
-        o->write_characters(indent_string.c_str(), new_indent);
-
-        o->write_characters("\"subtype\": ", 11);
-        if (val.m_data.m_value.binary->has_subtype()) {
-          dump_integer(val.m_data.m_value.binary->subtype());
-        } else {
-          o->write_characters("null", 4);
-        }
-        o->write_character('\n');
-        o->write_characters(indent_string.c_str(), current_indent);
-        o->write_character('}');
-      } else {
-        o->write_characters("{\"bytes\":[", 10);
-
-        if (!val.m_data.m_value.binary->empty()) {
-          for (auto i = val.m_data.m_value.binary->cbegin();
-               i != val.m_data.m_value.binary->cend() - 1; ++i) {
-            dump_integer(*i);
-            o->write_character(',');
-          }
-          dump_integer(val.m_data.m_value.binary->back());
-        }
-
-        o->write_characters("],\"subtype\":", 12);
-        if (val.m_data.m_value.binary->has_subtype()) {
-          dump_integer(val.m_data.m_value.binary->subtype());
-          o->write_character('}');
-        } else {
-          o->write_characters("null}", 5);
-        }
-      }
-      return;
-    }
-
-    case value_t::boolean: {
-      if (val.m_data.m_value.boolean) {
-        o->write_characters("true", 4);
-      } else {
-        o->write_characters("false", 5);
-      }
-      return;
-    }
-
-    case value_t::number_integer: {
-      dump_integer(val.m_data.m_value.number_integer);
-      return;
-    }
-
-    case value_t::number_unsigned: {
-      dump_integer(val.m_data.m_value.number_unsigned);
-      return;
-    }
-
-    case value_t::number_float: {
-      dump_float(val.m_data.m_value.number_float);
-      return;
-    }
-
-    case value_t::discarded: {
-      o->write_characters("<discarded>", 11);
-      return;
-    }
-
-    case value_t::null: {
-      o->write_characters("null", 4);
-      return;
-    }
-
-    default:              // LCOV_EXCL_LINE
-      JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
-                          // LCOV_EXCL_LINE
-    }
-  }
-
-  JSON_PRIVATE_UNLESS_TESTED :
-      /*!
-      @brief dump escaped string
-
-      Escape a string by replacing certain special characters by a sequence of
-      an escape character (backslash) and another character and other control
-      characters by a sequence of "\u" followed by a four-digit hex
-      representation. The escaped string is written to output stream @a o.
-
-      @param[in] s  the string to escape
-      @param[in] ensure_ascii  whether to escape non-ASCII characters with
-                               \uXXXX sequences
-
-      @complexity Linear in the length of string @a s.
-      */
-      void
-      dump_escaped(const string_t &s, const bool ensure_ascii) {
-    std::uint32_t codepoint{};
-    std::uint8_t state = UTF8_ACCEPT;
-    std::size_t bytes = 0; // number of bytes written to string_buffer
-
-    // number of bytes written at the point of the last valid byte
-    std::size_t bytes_after_last_accept = 0;
-    std::size_t undumped_chars = 0;
-
-    for (std::size_t i = 0; i < s.size(); ++i) {
-      const auto byte = static_cast<std::uint8_t>(s[i]);
-
-      switch (decode(state, codepoint, byte)) {
-      case UTF8_ACCEPT: // decode found a new code point
-      {
-        switch (codepoint) {
-        case 0x08: // backspace
-        {
-          string_buffer[bytes++] = '\\';
-          string_buffer[bytes++] = 'b';
-          break;
-        }
-
-        case 0x09: // horizontal tab
-        {
-          string_buffer[bytes++] = '\\';
-          string_buffer[bytes++] = 't';
-          break;
-        }
-
-        case 0x0A: // newline
-        {
-          string_buffer[bytes++] = '\\';
-          string_buffer[bytes++] = 'n';
-          break;
-        }
-
-        case 0x0C: // formfeed
-        {
-          string_buffer[bytes++] = '\\';
-          string_buffer[bytes++] = 'f';
-          break;
-        }
-
-        case 0x0D: // carriage return
-        {
-          string_buffer[bytes++] = '\\';
-          string_buffer[bytes++] = 'r';
-          break;
-        }
-
-        case 0x22: // quotation mark
-        {
-          string_buffer[bytes++] = '\\';
-          string_buffer[bytes++] = '\"';
-          break;
-        }
-
-        case 0x5C: // reverse solidus
-        {
-          string_buffer[bytes++] = '\\';
-          string_buffer[bytes++] = '\\';
-          break;
-        }
-
-        default: {
-          // escape control characters (0x00..0x1F) or, if
-          // ensure_ascii parameter is used, non-ASCII characters
-          if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F))) {
-            if (codepoint <= 0xFFFF) {
-              // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
-              static_cast<void>(
-                  (std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
-                                  static_cast<std::uint16_t>(codepoint)));
-              bytes += 6;
-            } else {
-              // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
-              static_cast<void>(
-                  (std::snprintf)(string_buffer.data() + bytes, 13,
-                                  "\\u%04x\\u%04x",
-                                  static_cast<std::uint16_t>(
-                                      0xD7C0u + (codepoint >> 10u)),
-                                  static_cast<std::uint16_t>(
-                                      0xDC00u + (codepoint & 0x3FFu))));
-              bytes += 12;
-            }
-          } else {
-            // copy byte to buffer (all previous bytes
-            // been copied have in default case above)
-            string_buffer[bytes++] = s[i];
-          }
-          break;
-        }
-        }
-
-        // write buffer and reset index; there must be 13 bytes
-        // left, as this is the maximal number of bytes to be
-        // written ("\uxxxx\uxxxx\0") for one code point
-        if (string_buffer.size() - bytes < 13) {
-          o->write_characters(string_buffer.data(), bytes);
-          bytes = 0;
-        }
-
-        // remember the byte position of this accept
-        bytes_after_last_accept = bytes;
-        undumped_chars = 0;
-        break;
-      }
-
-      case UTF8_REJECT: // decode found invalid UTF-8 byte
-      {
-        switch (error_handler) {
-        case error_handler_t::strict: {
-          JSON_THROW(type_error::create(316,
-                                        concat("invalid UTF-8 byte at index ",
-                                               std::to_string(i), ": 0x",
-                                               hex_bytes(byte | 0)),
-                                        nullptr));
-        }
-
-        case error_handler_t::ignore:
-        case error_handler_t::replace: {
-          // in case we saw this character the first time, we
-          // would like to read it again, because the byte
-          // may be OK for itself, but just not OK for the
-          // previous sequence
-          if (undumped_chars > 0) {
-            --i;
-          }
-
-          // reset length buffer to the last accepted index;
-          // thus removing/ignoring the invalid characters
-          bytes = bytes_after_last_accept;
-
-          if (error_handler == error_handler_t::replace) {
-            // add a replacement character
-            if (ensure_ascii) {
-              string_buffer[bytes++] = '\\';
-              string_buffer[bytes++] = 'u';
-              string_buffer[bytes++] = 'f';
-              string_buffer[bytes++] = 'f';
-              string_buffer[bytes++] = 'f';
-              string_buffer[bytes++] = 'd';
-            } else {
-              string_buffer[bytes++] =
-                  detail::binary_writer<BasicJsonType, char>::to_char_type(
-                      '\xEF');
-              string_buffer[bytes++] =
-                  detail::binary_writer<BasicJsonType, char>::to_char_type(
-                      '\xBF');
-              string_buffer[bytes++] =
-                  detail::binary_writer<BasicJsonType, char>::to_char_type(
-                      '\xBD');
-            }
-
-            // write buffer and reset index; there must be 13 bytes
-            // left, as this is the maximal number of bytes to be
-            // written ("\uxxxx\uxxxx\0") for one code point
-            if (string_buffer.size() - bytes < 13) {
-              o->write_characters(string_buffer.data(), bytes);
-              bytes = 0;
-            }
-
-            bytes_after_last_accept = bytes;
-          }
-
-          undumped_chars = 0;
-
-          // continue processing the string
-          state = UTF8_ACCEPT;
-          break;
-        }
-
-        default:              // LCOV_EXCL_LINE
-          JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
-                              // LCOV_EXCL_LINE
-        }
-        break;
-      }
-
-      default: // decode found yet incomplete multi-byte code point
-      {
-        if (!ensure_ascii) {
-          // code point will not be escaped - copy byte to buffer
-          string_buffer[bytes++] = s[i];
-        }
-        ++undumped_chars;
-        break;
-      }
-      }
-    }
-
-    // we finished processing the string
-    if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT)) {
-      // write buffer
-      if (bytes > 0) {
-        o->write_characters(string_buffer.data(), bytes);
-      }
-    } else {
-      // we finish reading, but do not accept: string was incomplete
-      switch (error_handler) {
-      case error_handler_t::strict: {
-        JSON_THROW(type_error::create(
-            316,
-            concat("incomplete UTF-8 string; last byte: 0x",
-                   hex_bytes(static_cast<std::uint8_t>(s.back() | 0))),
-            nullptr));
-      }
-
-      case error_handler_t::ignore: {
-        // write all accepted bytes
-        o->write_characters(string_buffer.data(), bytes_after_last_accept);
-        break;
-      }
-
-      case error_handler_t::replace: {
-        // write all accepted bytes
-        o->write_characters(string_buffer.data(), bytes_after_last_accept);
-        // add a replacement character
-        if (ensure_ascii) {
-          o->write_characters("\\ufffd", 6);
-        } else {
-          o->write_characters("\xEF\xBF\xBD", 3);
-        }
-        break;
-      }
-
-      default:              // LCOV_EXCL_LINE
-        JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
-                            // LCOV_EXCL_LINE
-      }
-    }
-  }
-
-private:
-  /*!
-  @brief count digits
-
-  Count the number of decimal (base 10) digits for an input unsigned integer.
-
-  @param[in] x  unsigned integer number to count its digits
-  @return    number of decimal digits
-  */
-  unsigned int count_digits(number_unsigned_t x) noexcept {
-    unsigned int n_digits = 1;
-    for (;;) {
-      if (x < 10) {
-        return n_digits;
-      }
-      if (x < 100) {
-        return n_digits + 1;
-      }
-      if (x < 1000) {
-        return n_digits + 2;
-      }
-      if (x < 10000) {
-        return n_digits + 3;
-      }
-      x = x / 10000u;
-      n_digits += 4;
-    }
-  }
-
-  /*!
-   * @brief convert a byte to a uppercase hex representation
-   * @param[in] byte byte to represent
-   * @return representation ("00".."FF")
-   */
-  static std::string hex_bytes(std::uint8_t byte) {
-    std::string result = "FF";
-    constexpr const char *nibble_to_hex = "0123456789ABCDEF";
-    result[0] = nibble_to_hex[byte / 16];
-    result[1] = nibble_to_hex[byte % 16];
-    return result;
-  }
-
-  // templates to avoid warnings about useless casts
-  template <typename NumberType,
-            enable_if_t<std::is_signed<NumberType>::value, int> = 0>
-  bool is_negative_number(NumberType x) {
-    return x < 0;
-  }
-
-  template <typename NumberType,
-            enable_if_t<std::is_unsigned<NumberType>::value, int> = 0>
-  bool is_negative_number(NumberType /*unused*/) {
-    return false;
-  }
-
-  /*!
-  @brief dump an integer
-
-  Dump a given integer to output stream @a o. Works internally with
-  @a number_buffer.
-
-  @param[in] x  integer number (signed or unsigned) to dump
-  @tparam NumberType either @a number_integer_t or @a number_unsigned_t
-  */
-  template <typename NumberType,
-            detail::enable_if_t<
-                std::is_integral<NumberType>::value ||
-                    std::is_same<NumberType, number_unsigned_t>::value ||
-                    std::is_same<NumberType, number_integer_t>::value ||
-                    std::is_same<NumberType, binary_char_t>::value,
-                int> = 0>
-  void dump_integer(NumberType x) {
-    static constexpr std::array<std::array<char, 2>, 100> digits_to_99{{
-        {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}},
-        {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
-        {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}},
-        {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
-        {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}},
-        {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
-        {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}},
-        {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
-        {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}},
-        {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
-        {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}},
-        {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
-        {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}},
-        {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
-        {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}},
-        {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
-        {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}},
-        {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
-        {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}},
-        {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
-    }};
-
-    // special case for "0"
-    if (x == 0) {
-      o->write_character('0');
-      return;
-    }
-
-    // use a pointer to fill the buffer
-    auto buffer_ptr =
-        number_buffer
-            .begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
-
-    number_unsigned_t abs_value;
-
-    unsigned int n_chars{};
-
-    if (is_negative_number(x)) {
-      *buffer_ptr = '-';
-      abs_value = remove_sign(static_cast<number_integer_t>(x));
-
-      // account one more byte for the minus sign
-      n_chars = 1 + count_digits(abs_value);
-    } else {
-      abs_value = static_cast<number_unsigned_t>(x);
-      n_chars = count_digits(abs_value);
-    }
-
-    // spare 1 byte for '\0'
-    JSON_ASSERT(n_chars < number_buffer.size() - 1);
-
-    // jump to the end to generate the string from backward,
-    // so we later avoid reversing the result
-    buffer_ptr += n_chars;
-
-    // Fast int2ascii implementation inspired by "Fastware" talk by Andrei
-    // Alexandrescu See: https://www.youtube.com/watch?v=o4-CwDo2zpg
-    while (abs_value >= 100) {
-      const auto digits_index = static_cast<unsigned>((abs_value % 100));
-      abs_value /= 100;
-      *(--buffer_ptr) = digits_to_99[digits_index][1];
-      *(--buffer_ptr) = digits_to_99[digits_index][0];
-    }
-
-    if (abs_value >= 10) {
-      const auto digits_index = static_cast<unsigned>(abs_value);
-      *(--buffer_ptr) = digits_to_99[digits_index][1];
-      *(--buffer_ptr) = digits_to_99[digits_index][0];
-    } else {
-      *(--buffer_ptr) = static_cast<char>('0' + abs_value);
-    }
-
-    o->write_characters(number_buffer.data(), n_chars);
-  }
-
-  /*!
-  @brief dump a floating-point number
-
-  Dump a given floating-point number to output stream @a o. Works internally
-  with @a number_buffer.
-
-  @param[in] x  floating-point number to dump
-  */
-  void dump_float(number_float_t x) {
-    // NaN / inf
-    if (!std::isfinite(x)) {
-      o->write_characters("null", 4);
-      return;
-    }
-
-    // If number_float_t is an IEEE-754 single or double precision number,
-    // use the Grisu2 algorithm to produce short numbers which are
-    // guaranteed to round-trip, using strtof and strtod, resp.
-    //
-    // NB: The test below works if <long double> == <double>.
-    static constexpr bool is_ieee_single_or_double =
-        (std::numeric_limits<number_float_t>::is_iec559 &&
-         std::numeric_limits<number_float_t>::digits == 24 &&
-         std::numeric_limits<number_float_t>::max_exponent == 128) ||
-        (std::numeric_limits<number_float_t>::is_iec559 &&
-         std::numeric_limits<number_float_t>::digits == 53 &&
-         std::numeric_limits<number_float_t>::max_exponent == 1024);
-
-    dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
-  }
-
-  void dump_float(number_float_t x,
-                  std::true_type /*is_ieee_single_or_double*/) {
-    auto *begin = number_buffer.data();
-    auto *end =
-        ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
-
-    o->write_characters(begin, static_cast<size_t>(end - begin));
-  }
-
-  void dump_float(number_float_t x,
-                  std::false_type /*is_ieee_single_or_double*/) {
-    // get number of digits for a float -> text -> float round-trip
-    static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
-
-    // the actual conversion
-    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
-    std::ptrdiff_t len = (std::snprintf)(number_buffer.data(),
-                                         number_buffer.size(), "%.*g", d, x);
-
-    // negative value indicates an error
-    JSON_ASSERT(len > 0);
-    // check if buffer was large enough
-    JSON_ASSERT(static_cast<std::size_t>(len) < number_buffer.size());
-
-    // erase thousands separator
-    if (thousands_sep != '\0') {
-      // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto):
-      // std::remove returns an iterator, see
-      // https://github.com/nlohmann/json/issues/3081
-      const auto end = std::remove(number_buffer.begin(),
-                                   number_buffer.begin() + len, thousands_sep);
-      std::fill(end, number_buffer.end(), '\0');
-      JSON_ASSERT((end - number_buffer.begin()) <= len);
-      len = (end - number_buffer.begin());
-    }
-
-    // convert decimal point to '.'
-    if (decimal_point != '\0' && decimal_point != '.') {
-      // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto):
-      // std::find returns an iterator, see
-      // https://github.com/nlohmann/json/issues/3081
-      const auto dec_pos =
-          std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
-      if (dec_pos != number_buffer.end()) {
-        *dec_pos = '.';
-      }
-    }
-
-    o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));
-
-    // determine if we need to append ".0"
-    const bool value_is_int_like =
-        std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
-                     [](char c) { return c == '.' || c == 'e'; });
-
-    if (value_is_int_like) {
-      o->write_characters(".0", 2);
-    }
-  }
-
-  /*!
-  @brief check whether a string is UTF-8 encoded
-
-  The function checks each byte of a string whether it is UTF-8 encoded. The
-  result of the check is stored in the @a state parameter. The function must
-  be called initially with state 0 (accept). State 1 means the string must
-  be rejected, because the current byte is not allowed. If the string is
-  completely processed, but the state is non-zero, the string ended
-  prematurely; that is, the last byte indicated more bytes should have
-  followed.
-
-  @param[in,out] state  the state of the decoding
-  @param[in,out] codep  codepoint (valid only if resulting state is UTF8_ACCEPT)
-  @param[in] byte       next byte to decode
-  @return               new state
-
-  @note The function has been edited: a std::array is used.
-
-  @copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
-  @sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
-  */
-  static std::uint8_t decode(std::uint8_t &state, std::uint32_t &codep,
-                             const std::uint8_t byte) noexcept {
-    static const std::array<std::uint8_t, 400> utf8d = {{
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0, // 00..1F
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0, // 20..3F
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0, // 40..5F
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0, // 60..7F
-        1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
-        1,   1,   1,   1,   1,   9,   9,   9,   9,   9,   9,
-        9,   9,   9,   9,   9,   9,   9,   9,   9,   9, // 80..9F
-        7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,
-        7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,
-        7,   7,   7,   7,   7,   7,   7,   7,   7,   7, // A0..BF
-        8,   8,   2,   2,   2,   2,   2,   2,   2,   2,   2,
-        2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,
-        2,   2,   2,   2,   2,   2,   2,   2,   2,   2, // C0..DF
-        0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3,
-        0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
-        0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8,
-        0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
-        0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4,
-        0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
-        1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
-        1,   1,   1,   1,   1,   1,   0,   1,   1,   1,   1,
-        1,   0,   1,   0,   1,   1,   1,   1,   1,   1, // s1..s2
-        1,   2,   1,   1,   1,   1,   1,   2,   1,   2,   1,
-        1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
-        1,   2,   1,   1,   1,   1,   1,   1,   1,   1, // s3..s4
-        1,   2,   1,   1,   1,   1,   1,   1,   1,   2,   1,
-        1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
-        1,   3,   1,   3,   1,   1,   1,   1,   1,   1, // s5..s6
-        1,   3,   1,   1,   1,   1,   1,   3,   1,   3,   1,
-        1,   1,   1,   1,   1,   1,   3,   1,   1,   1,   1,
-        1,   1,   1,   1,   1,   1,   1,   1,   1,   1 // s7..s8
-    }};
-
-    JSON_ASSERT(byte < utf8d.size());
-    const std::uint8_t type = utf8d[byte];
-
-    codep = (state != UTF8_ACCEPT) ? (byte & 0x3fu) | (codep << 6u)
-                                   : (0xFFu >> type) & (byte);
-
-    const std::size_t index =
-        256u + (static_cast<size_t>(state) * 16u) + static_cast<size_t>(type);
-    JSON_ASSERT(index < utf8d.size());
-    state = utf8d[index];
-    return state;
-  }
-
-  /*
-   * Overload to make the compiler happy while it is instantiating
-   * dump_integer for number_unsigned_t.
-   * Must never be called.
-   */
-  number_unsigned_t remove_sign(number_unsigned_t x) {
-    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
-                        // LCOV_EXCL_LINE
-    return x; // LCOV_EXCL_LINE
-  }
-
-  /*
-   * Helper function for dump_integer
-   *
-   * This function takes a negative signed integer and returns its absolute
-   * value as unsigned integer. The plus/minus shuffling is necessary as we can
-   * not directly remove the sign of an arbitrary signed integer as the
-   * absolute values of INT_MIN and INT_MAX are usually not the same. See
-   * #1708 for details.
-   */
-  number_unsigned_t remove_sign(number_integer_t x) noexcept {
-    JSON_ASSERT(
-        x < 0 &&
-        x < (std::numeric_limits<
-                number_integer_t>::max)()); // NOLINT(misc-redundant-expression)
-    return static_cast<number_unsigned_t>(-(x + 1)) + 1;
-  }
-
-private:
-  /// the output of the serializer
-  output_adapter_t<char> o = nullptr;
-
-  /// a (hopefully) large enough character buffer
-  std::array<char, 64> number_buffer{{}};
-
-  /// the locale
-  const std::lconv *loc = nullptr;
-  /// the locale's thousand separator character
-  const char thousands_sep = '\0';
-  /// the locale's decimal point character
-  const char decimal_point = '\0';
-
-  /// string buffer
-  std::array<char, 512> string_buffer{{}};
-
-  /// the indentation character
-  const char indent_char;
-  /// the indentation string
-  string_t indent_string;
-
-  /// error_handler how to react on decoding errors
-  const error_handler_t error_handler;
-};
-
-} // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
-// #include <nlohmann/detail/value_t.hpp>
-
-// #include <nlohmann/json_fwd.hpp>
-
-// #include <nlohmann/ordered_map.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include <functional>       // equal_to, less
-#include <initializer_list> // initializer_list
-#include <iterator>         // input_iterator_tag, iterator_traits
-#include <memory>           // allocator
-#include <stdexcept>        // for out_of_range
-#include <type_traits>      // enable_if, is_convertible
-#include <utility>          // pair
-#include <vector>           // vector
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/meta/type_traits.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-
-/// ordered_map: a minimal map-like container that preserves insertion order
-/// for use within nlohmann::basic_json<ordered_map>
-template <class Key, class T, class IgnoredLess = std::less<Key>,
-          class Allocator = std::allocator<std::pair<const Key, T>>>
-struct ordered_map : std::vector<std::pair<const Key, T>, Allocator> {
-  using key_type = Key;
-  using mapped_type = T;
-  using Container = std::vector<std::pair<const Key, T>, Allocator>;
-  using iterator = typename Container::iterator;
-  using const_iterator = typename Container::const_iterator;
-  using size_type = typename Container::size_type;
-  using value_type = typename Container::value_type;
-#ifdef JSON_HAS_CPP_14
-  using key_compare = std::equal_to<>;
-#else
-  using key_compare = std::equal_to<Key>;
-#endif
-
-  // Explicit constructors instead of `using Container::Container`
-  // otherwise older compilers choke on it (GCC <= 5.5, xcode <= 9.4)
-  ordered_map() noexcept(noexcept(Container())) : Container{} {}
-  explicit ordered_map(const Allocator &alloc) noexcept(
-      noexcept(Container(alloc)))
-      : Container{alloc} {}
-  template <class It>
-  ordered_map(It first, It last, const Allocator &alloc = Allocator())
-      : Container{first, last, alloc} {}
-  ordered_map(std::initializer_list<value_type> init,
-              const Allocator &alloc = Allocator())
-      : Container{init, alloc} {}
-
-  std::pair<iterator, bool> emplace(const key_type &key, T &&t) {
-    for (auto it = this->begin(); it != this->end(); ++it) {
-      if (m_compare(it->first, key)) {
-        return {it, false};
-      }
-    }
-    Container::emplace_back(key, std::forward<T>(t));
-    return {std::prev(this->end()), true};
-  }
-
-  template <class KeyType,
-            detail::enable_if_t<detail::is_usable_as_key_type<
-                                    key_compare, key_type, KeyType>::value,
-                                int> = 0>
-  std::pair<iterator, bool> emplace(KeyType &&key, T &&t) {
-    for (auto it = this->begin(); it != this->end(); ++it) {
-      if (m_compare(it->first, key)) {
-        return {it, false};
-      }
-    }
-    Container::emplace_back(std::forward<KeyType>(key), std::forward<T>(t));
-    return {std::prev(this->end()), true};
-  }
-
-  T &operator[](const key_type &key) { return emplace(key, T{}).first->second; }
-
-  template <class KeyType,
-            detail::enable_if_t<detail::is_usable_as_key_type<
-                                    key_compare, key_type, KeyType>::value,
-                                int> = 0>
-  T &operator[](KeyType &&key) {
-    return emplace(std::forward<KeyType>(key), T{}).first->second;
-  }
-
-  const T &operator[](const key_type &key) const { return at(key); }
-
-  template <class KeyType,
-            detail::enable_if_t<detail::is_usable_as_key_type<
-                                    key_compare, key_type, KeyType>::value,
-                                int> = 0>
-  const T &operator[](KeyType &&key) const {
-    return at(std::forward<KeyType>(key));
-  }
-
-  T &at(const key_type &key) {
-    for (auto it = this->begin(); it != this->end(); ++it) {
-      if (m_compare(it->first, key)) {
-        return it->second;
-      }
-    }
-
-    JSON_THROW(std::out_of_range("key not found"));
-  }
-
-  template <class KeyType,
-            detail::enable_if_t<detail::is_usable_as_key_type<
-                                    key_compare, key_type, KeyType>::value,
-                                int> = 0>
-  T &at(KeyType &&key) // NOLINT(cppcoreguidelines-missing-std-forward)
-  {
-    for (auto it = this->begin(); it != this->end(); ++it) {
-      if (m_compare(it->first, key)) {
-        return it->second;
-      }
-    }
-
-    JSON_THROW(std::out_of_range("key not found"));
-  }
-
-  const T &at(const key_type &key) const {
-    for (auto it = this->begin(); it != this->end(); ++it) {
-      if (m_compare(it->first, key)) {
-        return it->second;
-      }
-    }
-
-    JSON_THROW(std::out_of_range("key not found"));
-  }
-
-  template <class KeyType,
-            detail::enable_if_t<detail::is_usable_as_key_type<
-                                    key_compare, key_type, KeyType>::value,
-                                int> = 0>
-  const T &
-  at(KeyType &&key) const // NOLINT(cppcoreguidelines-missing-std-forward)
-  {
-    for (auto it = this->begin(); it != this->end(); ++it) {
-      if (m_compare(it->first, key)) {
-        return it->second;
-      }
-    }
-
-    JSON_THROW(std::out_of_range("key not found"));
-  }
-
-  size_type erase(const key_type &key) {
-    for (auto it = this->begin(); it != this->end(); ++it) {
-      if (m_compare(it->first, key)) {
-        // Since we cannot move const Keys, re-construct them in place
-        for (auto next = it; ++next != this->end(); ++it) {
-          it->~value_type(); // Destroy but keep allocation
-          new (&*it) value_type{std::move(*next)};
-        }
-        Container::pop_back();
-        return 1;
-      }
-    }
-    return 0;
-  }
-
-  template <class KeyType,
-            detail::enable_if_t<detail::is_usable_as_key_type<
-                                    key_compare, key_type, KeyType>::value,
-                                int> = 0>
-  size_type
-  erase(KeyType &&key) // NOLINT(cppcoreguidelines-missing-std-forward)
-  {
-    for (auto it = this->begin(); it != this->end(); ++it) {
-      if (m_compare(it->first, key)) {
-        // Since we cannot move const Keys, re-construct them in place
-        for (auto next = it; ++next != this->end(); ++it) {
-          it->~value_type(); // Destroy but keep allocation
-          new (&*it) value_type{std::move(*next)};
-        }
-        Container::pop_back();
-        return 1;
-      }
-    }
-    return 0;
-  }
-
-  iterator erase(iterator pos) { return erase(pos, std::next(pos)); }
-
-  iterator erase(iterator first, iterator last) {
-    if (first == last) {
-      return first;
-    }
-
-    const auto elements_affected = std::distance(first, last);
-    const auto offset = std::distance(Container::begin(), first);
-
-    // This is the start situation. We need to delete elements_affected
-    // elements (3 in this example: e, f, g), and need to return an
-    // iterator past the last deleted element (h in this example).
-    // Note that offset is the distance from the start of the vector
-    // to first. We will need this later.
-
-    // [ a, b, c, d, e, f, g, h, i, j ]
-    //               ^        ^
-    //             first    last
-
-    // Since we cannot move const Keys, we re-construct them in place.
-    // We start at first and re-construct (viz. copy) the elements from
-    // the back of the vector. Example for first iteration:
-
-    //               ,--------.
-    //               v        |   destroy e and re-construct with h
-    // [ a, b, c, d, e, f, g, h, i, j ]
-    //               ^        ^
-    //               it       it + elements_affected
-
-    for (auto it = first; std::next(it, elements_affected) != Container::end();
-         ++it) {
-      it->~value_type(); // destroy but keep allocation
-      new (&*it) value_type{std::move(
-          *std::next(it, elements_affected))}; // "move" next element to it
-    }
-
-    // [ a, b, c, d, h, i, j, h, i, j ]
-    //               ^        ^
-    //             first    last
-
-    // remove the unneeded elements at the end of the vector
-    Container::resize(this->size() - static_cast<size_type>(elements_affected));
-
-    // [ a, b, c, d, h, i, j ]
-    //               ^        ^
-    //             first    last
-
-    // first is now pointing past the last deleted element, but we cannot
-    // use this iterator, because it may have been invalidated by the
-    // resize call. Instead, we can return begin() + offset.
-    return Container::begin() + offset;
-  }
-
-  size_type count(const key_type &key) const {
-    for (auto it = this->begin(); it != this->end(); ++it) {
-      if (m_compare(it->first, key)) {
-        return 1;
-      }
-    }
-    return 0;
-  }
-
-  template <class KeyType,
-            detail::enable_if_t<detail::is_usable_as_key_type<
-                                    key_compare, key_type, KeyType>::value,
-                                int> = 0>
-  size_type
-  count(KeyType &&key) const // NOLINT(cppcoreguidelines-missing-std-forward)
-  {
-    for (auto it = this->begin(); it != this->end(); ++it) {
-      if (m_compare(it->first, key)) {
-        return 1;
-      }
-    }
-    return 0;
-  }
-
-  iterator find(const key_type &key) {
-    for (auto it = this->begin(); it != this->end(); ++it) {
-      if (m_compare(it->first, key)) {
-        return it;
-      }
-    }
-    return Container::end();
-  }
-
-  template <class KeyType,
-            detail::enable_if_t<detail::is_usable_as_key_type<
-                                    key_compare, key_type, KeyType>::value,
-                                int> = 0>
-  iterator find(KeyType &&key) // NOLINT(cppcoreguidelines-missing-std-forward)
-  {
-    for (auto it = this->begin(); it != this->end(); ++it) {
-      if (m_compare(it->first, key)) {
-        return it;
-      }
-    }
-    return Container::end();
-  }
-
-  const_iterator find(const key_type &key) const {
-    for (auto it = this->begin(); it != this->end(); ++it) {
-      if (m_compare(it->first, key)) {
-        return it;
-      }
-    }
-    return Container::end();
-  }
-
-  std::pair<iterator, bool> insert(value_type &&value) {
-    return emplace(value.first, std::move(value.second));
-  }
-
-  std::pair<iterator, bool> insert(const value_type &value) {
-    for (auto it = this->begin(); it != this->end(); ++it) {
-      if (m_compare(it->first, value.first)) {
-        return {it, false};
-      }
-    }
-    Container::push_back(value);
-    return {--this->end(), true};
-  }
-
-  template <typename InputIt>
-  using require_input_iter = typename std::enable_if<std::is_convertible<
-      typename std::iterator_traits<InputIt>::iterator_category,
-      std::input_iterator_tag>::value>::type;
-
-  template <typename InputIt, typename = require_input_iter<InputIt>>
-  void insert(InputIt first, InputIt last) {
-    for (auto it = first; it != last; ++it) {
-      insert(*it);
-    }
-  }
-
-private:
-  JSON_NO_UNIQUE_ADDRESS key_compare m_compare = key_compare();
-};
-
-NLOHMANN_JSON_NAMESPACE_END
-
-#if defined(JSON_HAS_CPP_17)
-#if JSON_HAS_STATIC_RTTI
-#include <any>
-#endif
-#include <string_view>
-#endif
-
-/*!
-@brief namespace for Niels Lohmann
-@see https://github.com/nlohmann
-@since version 1.0.0
-*/
-NLOHMANN_JSON_NAMESPACE_BEGIN
-
-/*!
-@brief a class to store JSON values
-
-@internal
-@invariant The member variables @a m_value and @a m_type have the following
-relationship:
-- If `m_type == value_t::object`, then `m_value.object != nullptr`.
-- If `m_type == value_t::array`, then `m_value.array != nullptr`.
-- If `m_type == value_t::string`, then `m_value.string != nullptr`.
-The invariants are checked by member function assert_invariant().
-
-@note ObjectType trick from https://stackoverflow.com/a/9860911
-@endinternal
-
-@since version 1.0.0
-
-@nosubgrouping
-*/
-NLOHMANN_BASIC_JSON_TPL_DECLARATION
-class
-    basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
-    : public ::nlohmann::detail::json_base_class<CustomBaseClass> {
-private:
-  template <detail::value_t> friend struct detail::external_constructor;
-
-  template <typename> friend class ::nlohmann::json_pointer;
-  // can be restored when json_pointer backwards compatibility is removed
-  // friend ::nlohmann::json_pointer<StringType>;
-
-  template <typename BasicJsonType, typename InputType>
-  friend class ::nlohmann::detail::parser;
-  friend ::nlohmann::detail::serializer<basic_json>;
-  template <typename BasicJsonType> friend class ::nlohmann::detail::iter_impl;
-  template <typename BasicJsonType, typename CharType>
-  friend class ::nlohmann::detail::binary_writer;
-  template <typename BasicJsonType, typename InputType, typename SAX>
-  friend class ::nlohmann::detail::binary_reader;
-  template <typename BasicJsonType>
-  friend class ::nlohmann::detail::json_sax_dom_parser;
-  template <typename BasicJsonType>
-  friend class ::nlohmann::detail::json_sax_dom_callback_parser;
-  friend class ::nlohmann::detail::exception;
-
-  /// workaround type for MSVC
-  using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
-  using json_base_class_t =
-      ::nlohmann::detail::json_base_class<CustomBaseClass>;
-
-  JSON_PRIVATE_UNLESS_TESTED :
-      // convenience aliases for types residing in namespace detail;
-      using lexer = ::nlohmann::detail::lexer_base<basic_json>;
-
-  template <typename InputAdapterType>
-  static ::nlohmann::detail::parser<basic_json, InputAdapterType>
-  parser(InputAdapterType adapter,
-         detail::parser_callback_t<basic_json> cb = nullptr,
-         const bool allow_exceptions = true,
-         const bool ignore_comments = false) {
-    return ::nlohmann::detail::parser<basic_json, InputAdapterType>(
-        std::move(adapter), std::move(cb), allow_exceptions, ignore_comments);
-  }
-
-private:
-  using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
-  template <typename BasicJsonType>
-  using internal_iterator =
-      ::nlohmann::detail::internal_iterator<BasicJsonType>;
-  template <typename BasicJsonType>
-  using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
-  template <typename Iterator>
-  using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
-  template <typename Base>
-  using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
-
-  template <typename CharType>
-  using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
-
-  template <typename InputType>
-  using binary_reader =
-      ::nlohmann::detail::binary_reader<basic_json, InputType>;
-  template <typename CharType>
-  using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
-
-  JSON_PRIVATE_UNLESS_TESTED : using serializer =
-                                   ::nlohmann::detail::serializer<basic_json>;
-
-public:
-  using value_t = detail::value_t;
-  /// JSON Pointer, see @ref nlohmann::json_pointer
-  using json_pointer = ::nlohmann::json_pointer<StringType>;
-  template <typename T, typename SFINAE>
-  using json_serializer = JSONSerializer<T, SFINAE>;
-  /// how to treat decoding errors
-  using error_handler_t = detail::error_handler_t;
-  /// how to treat CBOR tags
-  using cbor_tag_handler_t = detail::cbor_tag_handler_t;
-  /// helper type for initializer lists of basic_json values
-  using initializer_list_t =
-      std::initializer_list<detail::json_ref<basic_json>>;
-
-  using input_format_t = detail::input_format_t;
-  /// SAX interface type, see @ref nlohmann::json_sax
-  using json_sax_t = json_sax<basic_json>;
-
-  ////////////////
-  // exceptions //
-  ////////////////
-
-  /// @name exceptions
-  /// Classes to implement user-defined exceptions.
-  /// @{
-
-  using exception = detail::exception;
-  using parse_error = detail::parse_error;
-  using invalid_iterator = detail::invalid_iterator;
-  using type_error = detail::type_error;
-  using out_of_range = detail::out_of_range;
-  using other_error = detail::other_error;
-
-  /// @}
-
-  /////////////////////
-  // container types //
-  /////////////////////
-
-  /// @name container types
-  /// The canonic container types to use @ref basic_json like any other STL
-  /// container.
-  /// @{
-
-  /// the type of elements in a basic_json container
-  using value_type = basic_json;
-
-  /// the type of an element reference
-  using reference = value_type &;
-  /// the type of an element const reference
-  using const_reference = const value_type &;
-
-  /// a type to represent differences between iterators
-  using difference_type = std::ptrdiff_t;
-  /// a type to represent container sizes
-  using size_type = std::size_t;
-
-  /// the allocator type
-  using allocator_type = AllocatorType<basic_json>;
-
-  /// the type of an element pointer
-  using pointer = typename std::allocator_traits<allocator_type>::pointer;
-  /// the type of an element const pointer
-  using const_pointer =
-      typename std::allocator_traits<allocator_type>::const_pointer;
-
-  /// an iterator for a basic_json container
-  using iterator = iter_impl<basic_json>;
-  /// a const iterator for a basic_json container
-  using const_iterator = iter_impl<const basic_json>;
-  /// a reverse iterator for a basic_json container
-  using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
-  /// a const reverse iterator for a basic_json container
-  using const_reverse_iterator =
-      json_reverse_iterator<typename basic_json::const_iterator>;
-
-  /// @}
-
-  /// @brief returns the allocator associated with the container
-  /// @sa https://json.nlohmann.me/api/basic_json/get_allocator/
-  static allocator_type get_allocator() { return allocator_type(); }
-
-  /// @brief returns version information on the library
-  /// @sa https://json.nlohmann.me/api/basic_json/meta/
-  JSON_HEDLEY_WARN_UNUSED_RESULT
-  static basic_json meta() {
-    basic_json result;
-
-    result["copyright"] = "(C) 2013-2023 Niels Lohmann";
-    result["name"] = "JSON for Modern C++";
-    result["url"] = "https://github.com/nlohmann/json";
-    result["version"]["string"] =
-        detail::concat(std::to_string(NLOHMANN_JSON_VERSION_MAJOR), '.',
-                       std::to_string(NLOHMANN_JSON_VERSION_MINOR), '.',
-                       std::to_string(NLOHMANN_JSON_VERSION_PATCH));
-    result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
-    result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
-    result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
-
-#ifdef _WIN32
-    result["platform"] = "win32";
-#elif defined __linux__
-    result["platform"] = "linux";
-#elif defined __APPLE__
-    result["platform"] = "apple";
-#elif defined __unix__
-    result["platform"] = "unix";
-#else
-    result["platform"] = "unknown";
-#endif
-
-#if defined(__ICC) || defined(__INTEL_COMPILER)
-    result["compiler"] = {{"family", "icc"}, { "version", __INTEL_COMPILER }};
-#elif defined(__clang__)
-    result["compiler"] = {{"family", "clang"},
-                          { "version",
-                            __clang_version__ }};
-#elif defined(__GNUC__) || defined(__GNUG__)
-    result["compiler"] = {
-        {"family", "gcc"},
-        { "version",
-          detail::concat(std::to_string(__GNUC__), '.',
-                         std::to_string(__GNUC_MINOR__), '.',
-                         std::to_string(__GNUC_PATCHLEVEL__)) }};
-#elif defined(__HP_cc) || defined(__HP_aCC)
-    result["compiler"] = "hp"
-#elif defined(__IBMCPP__)
-    result["compiler"] = {{"family", "ilecpp"}, { "version", __IBMCPP__ }};
-#elif defined(_MSC_VER)
-    result["compiler"] = {{"family", "msvc"}, { "version", _MSC_VER }};
-#elif defined(__PGI)
-    result["compiler"] = {{"family", "pgcpp"}, { "version", __PGI }};
-#elif defined(__SUNPRO_CC)
-    result["compiler"] = {{"family", "sunpro"}, { "version", __SUNPRO_CC }};
-#else
-    result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
-#endif
-
-#if defined(_MSVC_LANG)
-    result["compiler"]["c++"] = std::to_string(_MSVC_LANG);
-#elif defined(__cplusplus)
-    result["compiler"]["c++"] = std::to_string(__cplusplus);
-#else
-    result["compiler"]["c++"] = "unknown";
-#endif
-    return result;
-  }
-
-  ///////////////////////////
-  // JSON value data types //
-  ///////////////////////////
-
-  /// @name JSON value data types
-  /// The data types to store a JSON value. These types are derived from
-  /// the template arguments passed to class @ref basic_json.
-  /// @{
-
-  /// @brief default object key comparator type
-  /// The actual object key comparator type (@ref object_comparator_t) may be
-  /// different.
-  /// @sa https://json.nlohmann.me/api/basic_json/default_object_comparator_t/
-#if defined(JSON_HAS_CPP_14)
-  // use of transparent comparator avoids unnecessary repeated construction of
-  // temporaries in functions involving lookup by key with types other than
-  // object_t::key_type (aka. StringType)
-  using default_object_comparator_t = std::less<>;
-#else
-  using default_object_comparator_t = std::less<StringType>;
-#endif
-
-  /// @brief a type for an object
-  /// @sa https://json.nlohmann.me/api/basic_json/object_t/
-  using object_t =
-      ObjectType<StringType, basic_json, default_object_comparator_t,
-                 AllocatorType<std::pair<const StringType, basic_json>>>;
-
-  /// @brief a type for an array
-  /// @sa https://json.nlohmann.me/api/basic_json/array_t/
-  using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
-
-  /// @brief a type for a string
-  /// @sa https://json.nlohmann.me/api/basic_json/string_t/
-  using string_t = StringType;
-
-  /// @brief a type for a boolean
-  /// @sa https://json.nlohmann.me/api/basic_json/boolean_t/
-  using boolean_t = BooleanType;
-
-  /// @brief a type for a number (integer)
-  /// @sa https://json.nlohmann.me/api/basic_json/number_integer_t/
-  using number_integer_t = NumberIntegerType;
-
-  /// @brief a type for a number (unsigned)
-  /// @sa https://json.nlohmann.me/api/basic_json/number_unsigned_t/
-  using number_unsigned_t = NumberUnsignedType;
-
-  /// @brief a type for a number (floating-point)
-  /// @sa https://json.nlohmann.me/api/basic_json/number_float_t/
-  using number_float_t = NumberFloatType;
-
-  /// @brief a type for a packed binary type
-  /// @sa https://json.nlohmann.me/api/basic_json/binary_t/
-  using binary_t = nlohmann::byte_container_with_subtype<BinaryType>;
-
-  /// @brief object key comparator type
-  /// @sa https://json.nlohmann.me/api/basic_json/object_comparator_t/
-  using object_comparator_t = detail::actual_object_comparator_t<basic_json>;
-
-  /// @}
-
-private:
-  /// helper for exception-safe object creation
-  template <typename T, typename... Args>
-  JSON_HEDLEY_RETURNS_NON_NULL static T *create(Args &&...args) {
-    AllocatorType<T> alloc;
-    using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
-
-    auto deleter = [&](T *obj) { AllocatorTraits::deallocate(alloc, obj, 1); };
-    std::unique_ptr<T, decltype(deleter)> obj(
-        AllocatorTraits::allocate(alloc, 1), deleter);
-    AllocatorTraits::construct(alloc, obj.get(), std::forward<Args>(args)...);
-    JSON_ASSERT(obj != nullptr);
-    return obj.release();
-  }
-
-  ////////////////////////
-  // JSON value storage //
-  ////////////////////////
-
-  JSON_PRIVATE_UNLESS_TESTED :
-      /*!
-      @brief a JSON value
-
-      The actual storage for a JSON value of the @ref basic_json class. This
-      union combines the different storage types for the JSON value types
-      defined in @ref value_t.
-
-      JSON type | value_t type    | used type
-      --------- | --------------- | ------------------------
-      object    | object          | pointer to @ref object_t
-      array     | array           | pointer to @ref array_t
-      string    | string          | pointer to @ref string_t
-      boolean   | boolean         | @ref boolean_t
-      number    | number_integer  | @ref number_integer_t
-      number    | number_unsigned | @ref number_unsigned_t
-      number    | number_float    | @ref number_float_t
-      binary    | binary          | pointer to @ref binary_t
-      null      | null            | *no value is stored*
-
-      @note Variable-length types (objects, arrays, and strings) are stored as
-      pointers. The size of the union should not exceed 64 bits if the default
-      value types are used.
-
-      @since version 1.0.0
-      */
-      union json_value {
-    /// object (stored with pointer to save storage)
-    object_t *object;
-    /// array (stored with pointer to save storage)
-    array_t *array;
-    /// string (stored with pointer to save storage)
-    string_t *string;
-    /// binary (stored with pointer to save storage)
-    binary_t *binary;
-    /// boolean
-    boolean_t boolean;
-    /// number (integer)
-    number_integer_t number_integer;
-    /// number (unsigned integer)
-    number_unsigned_t number_unsigned;
-    /// number (floating-point)
-    number_float_t number_float;
-
-    /// default constructor (for null values)
-    json_value() = default;
-    /// constructor for booleans
-    json_value(boolean_t v) noexcept : boolean(v) {}
-    /// constructor for numbers (integer)
-    json_value(number_integer_t v) noexcept : number_integer(v) {}
-    /// constructor for numbers (unsigned)
-    json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
-    /// constructor for numbers (floating-point)
-    json_value(number_float_t v) noexcept : number_float(v) {}
-    /// constructor for empty values of a given type
-    json_value(value_t t) {
-      switch (t) {
-      case value_t::object: {
-        object = create<object_t>();
-        break;
-      }
-
-      case value_t::array: {
-        array = create<array_t>();
-        break;
-      }
-
-      case value_t::string: {
-        string = create<string_t>("");
-        break;
-      }
-
-      case value_t::binary: {
-        binary = create<binary_t>();
-        break;
-      }
-
-      case value_t::boolean: {
-        boolean = static_cast<boolean_t>(false);
-        break;
-      }
-
-      case value_t::number_integer: {
-        number_integer = static_cast<number_integer_t>(0);
-        break;
-      }
-
-      case value_t::number_unsigned: {
-        number_unsigned = static_cast<number_unsigned_t>(0);
-        break;
-      }
-
-      case value_t::number_float: {
-        number_float = static_cast<number_float_t>(0.0);
-        break;
-      }
-
-      case value_t::null: {
-        object = nullptr; // silence warning, see #821
-        break;
-      }
-
-      case value_t::discarded:
-      default: {
-        object = nullptr; // silence warning, see #821
-        if (JSON_HEDLEY_UNLIKELY(t == value_t::null)) {
-          JSON_THROW(other_error::create(
-              500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.11.3",
-              nullptr)); // LCOV_EXCL_LINE
-        }
-        break;
-      }
-      }
-    }
-
-    /// constructor for strings
-    json_value(const string_t &value) : string(create<string_t>(value)) {}
-
-    /// constructor for rvalue strings
-    json_value(string_t &&value) : string(create<string_t>(std::move(value))) {}
-
-    /// constructor for objects
-    json_value(const object_t &value) : object(create<object_t>(value)) {}
-
-    /// constructor for rvalue objects
-    json_value(object_t &&value) : object(create<object_t>(std::move(value))) {}
-
-    /// constructor for arrays
-    json_value(const array_t &value) : array(create<array_t>(value)) {}
-
-    /// constructor for rvalue arrays
-    json_value(array_t &&value) : array(create<array_t>(std::move(value))) {}
-
-    /// constructor for binary arrays
-    json_value(const typename binary_t::container_type &value)
-        : binary(create<binary_t>(value)) {}
-
-    /// constructor for rvalue binary arrays
-    json_value(typename binary_t::container_type &&value)
-        : binary(create<binary_t>(std::move(value))) {}
-
-    /// constructor for binary arrays (internal type)
-    json_value(const binary_t &value) : binary(create<binary_t>(value)) {}
-
-    /// constructor for rvalue binary arrays (internal type)
-    json_value(binary_t &&value) : binary(create<binary_t>(std::move(value))) {}
-
-    void destroy(value_t t) {
-      if ((t == value_t::object && object == nullptr) ||
-          (t == value_t::array && array == nullptr) ||
-          (t == value_t::string && string == nullptr) ||
-          (t == value_t::binary && binary == nullptr)) {
-        // not initialized (e.g. due to exception in the ctor)
-        return;
-      }
-      if (t == value_t::array || t == value_t::object) {
-        // flatten the current json_value to a heap-allocated stack
-        std::vector<basic_json> stack;
-
-        // move the top-level items to stack
-        if (t == value_t::array) {
-          stack.reserve(array->size());
-          std::move(array->begin(), array->end(), std::back_inserter(stack));
-        } else {
-          stack.reserve(object->size());
-          for (auto &&it : *object) {
-            stack.push_back(std::move(it.second));
-          }
-        }
-
-        while (!stack.empty()) {
-          // move the last item to local variable to be processed
-          basic_json current_item(std::move(stack.back()));
-          stack.pop_back();
-
-          // if current_item is array/object, move
-          // its children to the stack to be processed later
-          if (current_item.is_array()) {
-            std::move(current_item.m_data.m_value.array->begin(),
-                      current_item.m_data.m_value.array->end(),
-                      std::back_inserter(stack));
-
-            current_item.m_data.m_value.array->clear();
-          } else if (current_item.is_object()) {
-            for (auto &&it : *current_item.m_data.m_value.object) {
-              stack.push_back(std::move(it.second));
-            }
-
-            current_item.m_data.m_value.object->clear();
-          }
-
-          // it's now safe that current_item get destructed
-          // since it doesn't have any children
-        }
-      }
-
-      switch (t) {
-      case value_t::object: {
-        AllocatorType<object_t> alloc;
-        std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
-        std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
-        break;
-      }
-
-      case value_t::array: {
-        AllocatorType<array_t> alloc;
-        std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
-        std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
-        break;
-      }
-
-      case value_t::string: {
-        AllocatorType<string_t> alloc;
-        std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
-        std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
-        break;
-      }
-
-      case value_t::binary: {
-        AllocatorType<binary_t> alloc;
-        std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
-        std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
-        break;
-      }
-
-      case value_t::null:
-      case value_t::boolean:
-      case value_t::number_integer:
-      case value_t::number_unsigned:
-      case value_t::number_float:
-      case value_t::discarded:
-      default: {
-        break;
-      }
-      }
-    }
-  };
-
-private:
-  /*!
-  @brief checks the class invariants
-
-  This function asserts the class invariants. It needs to be called at the
-  end of every constructor to make sure that created objects respect the
-  invariant. Furthermore, it has to be called each time the type of a JSON
-  value is changed, because the invariant expresses a relationship between
-  @a m_type and @a m_value.
-
-  Furthermore, the parent relation is checked for arrays and objects: If
-  @a check_parents true and the value is an array or object, then the
-  container's elements must have the current value as parent.
-
-  @param[in] check_parents  whether the parent relation should be checked.
-             The value is true by default and should only be set to false
-             during destruction of objects when the invariant does not
-             need to hold.
-  */
-  void assert_invariant(bool check_parents = true) const noexcept {
-    JSON_ASSERT(m_data.m_type != value_t::object ||
-                m_data.m_value.object != nullptr);
-    JSON_ASSERT(m_data.m_type != value_t::array ||
-                m_data.m_value.array != nullptr);
-    JSON_ASSERT(m_data.m_type != value_t::string ||
-                m_data.m_value.string != nullptr);
-    JSON_ASSERT(m_data.m_type != value_t::binary ||
-                m_data.m_value.binary != nullptr);
-
-#if JSON_DIAGNOSTICS
-    JSON_TRY {
-      // cppcheck-suppress assertWithSideEffect
-      JSON_ASSERT(!check_parents || !is_structured() ||
-                  std::all_of(begin(), end(), [this](const basic_json &j) {
-                    return j.m_parent == this;
-                  }));
-    }
-    JSON_CATCH(...) {} // LCOV_EXCL_LINE
-#endif
-    static_cast<void>(check_parents);
-  }
-
-  void set_parents() {
-#if JSON_DIAGNOSTICS
-    switch (m_data.m_type) {
-    case value_t::array: {
-      for (auto &element : *m_data.m_value.array) {
-        element.m_parent = this;
-      }
-      break;
-    }
-
-    case value_t::object: {
-      for (auto &element : *m_data.m_value.object) {
-        element.second.m_parent = this;
-      }
-      break;
-    }
-
-    case value_t::null:
-    case value_t::string:
-    case value_t::boolean:
-    case value_t::number_integer:
-    case value_t::number_unsigned:
-    case value_t::number_float:
-    case value_t::binary:
-    case value_t::discarded:
-    default:
-      break;
-    }
-#endif
-  }
-
-  iterator set_parents(iterator it,
-                       typename iterator::difference_type count_set_parents) {
-#if JSON_DIAGNOSTICS
-    for (typename iterator::difference_type i = 0; i < count_set_parents; ++i) {
-      (it + i)->m_parent = this;
-    }
-#else
-    static_cast<void>(count_set_parents);
-#endif
-    return it;
-  }
-
-  reference
-  set_parent(reference j,
-             std::size_t old_capacity = static_cast<std::size_t>(-1)) {
-#if JSON_DIAGNOSTICS
-    if (old_capacity != static_cast<std::size_t>(-1)) {
-      // see https://github.com/nlohmann/json/issues/2838
-      JSON_ASSERT(type() == value_t::array);
-      if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() !=
-                               old_capacity)) {
-        // capacity has changed: update all parents
-        set_parents();
-        return j;
-      }
-    }
-
-    // ordered_json uses a vector internally, so pointers could have
-    // been invalidated; see https://github.com/nlohmann/json/issues/2962
-#ifdef JSON_HEDLEY_MSVC_VERSION
-#pragma warning(push)
-#pragma warning(disable                                                        \
-                : 4127) // ignore warning to replace if with if constexpr
-#endif
-    if (detail::is_ordered_map<object_t>::value) {
-      set_parents();
-      return j;
-    }
-#ifdef JSON_HEDLEY_MSVC_VERSION
-#pragma warning(pop)
-#endif
-
-    j.m_parent = this;
-#else
-    static_cast<void>(j);
-    static_cast<void>(old_capacity);
-#endif
-    return j;
-  }
-
-public:
-  //////////////////////////
-  // JSON parser callback //
-  //////////////////////////
-
-  /// @brief parser event types
-  /// @sa https://json.nlohmann.me/api/basic_json/parse_event_t/
-  using parse_event_t = detail::parse_event_t;
-
-  /// @brief per-element parser callback type
-  /// @sa https://json.nlohmann.me/api/basic_json/parser_callback_t/
-  using parser_callback_t = detail::parser_callback_t<basic_json>;
-
-  //////////////////
-  // constructors //
-  //////////////////
-
-  /// @name constructors and destructors
-  /// Constructors of class @ref basic_json, copy/move constructor, copy
-  /// assignment, static functions creating objects, and the destructor.
-  /// @{
-
-  /// @brief create an empty value with a given type
-  /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
-  basic_json(const value_t v) : m_data(v) { assert_invariant(); }
-
-  /// @brief create a null object
-  /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
-  basic_json(
-      std::nullptr_t = nullptr) noexcept // NOLINT(bugprone-exception-escape)
-      : basic_json(value_t::null) {
-    assert_invariant();
-  }
-
-  /// @brief create a JSON value from compatible types
-  /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
-  template <typename CompatibleType,
-            typename U = detail::uncvref_t<CompatibleType>,
-            detail::enable_if_t<
-                !detail::is_basic_json<U>::value &&
-                    detail::is_compatible_type<basic_json_t, U>::value,
-                int> = 0>
-  basic_json(CompatibleType &&val) noexcept(
-      noexcept( // NOLINT(bugprone-forwarding-reference-overload,bugprone-exception-escape)
-          JSONSerializer<U>::to_json(std::declval<basic_json_t &>(),
-                                     std::forward<CompatibleType>(val)))) {
-    JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
-    set_parents();
-    assert_invariant();
-  }
-
-  /// @brief create a JSON value from an existing one
-  /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
-  template <
-      typename BasicJsonType,
-      detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value &&
-                              !std::is_same<basic_json, BasicJsonType>::value,
-                          int> = 0>
-  basic_json(const BasicJsonType &val) {
-    using other_boolean_t = typename BasicJsonType::boolean_t;
-    using other_number_float_t = typename BasicJsonType::number_float_t;
-    using other_number_integer_t = typename BasicJsonType::number_integer_t;
-    using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-    using other_string_t = typename BasicJsonType::string_t;
-    using other_object_t = typename BasicJsonType::object_t;
-    using other_array_t = typename BasicJsonType::array_t;
-    using other_binary_t = typename BasicJsonType::binary_t;
-
-    switch (val.type()) {
-    case value_t::boolean:
-      JSONSerializer<other_boolean_t>::to_json(
-          *this, val.template get<other_boolean_t>());
-      break;
-    case value_t::number_float:
-      JSONSerializer<other_number_float_t>::to_json(
-          *this, val.template get<other_number_float_t>());
-      break;
-    case value_t::number_integer:
-      JSONSerializer<other_number_integer_t>::to_json(
-          *this, val.template get<other_number_integer_t>());
-      break;
-    case value_t::number_unsigned:
-      JSONSerializer<other_number_unsigned_t>::to_json(
-          *this, val.template get<other_number_unsigned_t>());
-      break;
-    case value_t::string:
-      JSONSerializer<other_string_t>::to_json(
-          *this, val.template get_ref<const other_string_t &>());
-      break;
-    case value_t::object:
-      JSONSerializer<other_object_t>::to_json(
-          *this, val.template get_ref<const other_object_t &>());
-      break;
-    case value_t::array:
-      JSONSerializer<other_array_t>::to_json(
-          *this, val.template get_ref<const other_array_t &>());
-      break;
-    case value_t::binary:
-      JSONSerializer<other_binary_t>::to_json(
-          *this, val.template get_ref<const other_binary_t &>());
-      break;
-    case value_t::null:
-      *this = nullptr;
-      break;
-    case value_t::discarded:
-      m_data.m_type = value_t::discarded;
-      break;
-    default:              // LCOV_EXCL_LINE
-      JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
-                          // LCOV_EXCL_LINE
-    }
-    JSON_ASSERT(m_data.m_type == val.type());
-    set_parents();
-    assert_invariant();
-  }
-
-  /// @brief create a container (array or object) from an initializer list
-  /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
-  basic_json(initializer_list_t init, bool type_deduction = true,
-             value_t manual_type = value_t::array) {
-    // check if each element is an array with two elements whose first
-    // element is a string
-    bool is_an_object = std::all_of(
-        init.begin(), init.end(),
-        [](const detail::json_ref<basic_json> &element_ref) {
-          // The cast is to ensure op[size_type] is called, bearing in mind
-          // size_type may not be int; (many string types can be constructed
-          // from 0 via its null-pointer guise, so we get a broken call to
-          // op[key_type], the wrong semantics and a 4804 warning on Windows)
-          return element_ref->is_array() && element_ref->size() == 2 &&
-                 (*element_ref)[static_cast<size_type>(0)].is_string();
-        });
-
-    // adjust type if type deduction is not wanted
-    if (!type_deduction) {
-      // if array is wanted, do not create an object though possible
-      if (manual_type == value_t::array) {
-        is_an_object = false;
-      }
-
-      // if object is wanted but impossible, throw an exception
-      if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object &&
-                               !is_an_object)) {
-        JSON_THROW(type_error::create(
-            301, "cannot create object from initializer list", nullptr));
-      }
-    }
-
-    if (is_an_object) {
-      // the initializer list is a list of pairs -> create object
-      m_data.m_type = value_t::object;
-      m_data.m_value = value_t::object;
-
-      for (auto &element_ref : init) {
-        auto element = element_ref.moved_or_copied();
-        m_data.m_value.object->emplace(
-            std::move(
-                *((*element.m_data.m_value.array)[0].m_data.m_value.string)),
-            std::move((*element.m_data.m_value.array)[1]));
-      }
-    } else {
-      // the initializer list describes an array -> create array
-      m_data.m_type = value_t::array;
-      m_data.m_value.array = create<array_t>(init.begin(), init.end());
-    }
-
-    set_parents();
-    assert_invariant();
-  }
-
-  /// @brief explicitly create a binary array (without subtype)
-  /// @sa https://json.nlohmann.me/api/basic_json/binary/
-  JSON_HEDLEY_WARN_UNUSED_RESULT
-  static basic_json binary(const typename binary_t::container_type &init) {
-    auto res = basic_json();
-    res.m_data.m_type = value_t::binary;
-    res.m_data.m_value = init;
-    return res;
-  }
-
-  /// @brief explicitly create a binary array (with subtype)
-  /// @sa https://json.nlohmann.me/api/basic_json/binary/
-  JSON_HEDLEY_WARN_UNUSED_RESULT
-  static basic_json binary(const typename binary_t::container_type &init,
-                           typename binary_t::subtype_type subtype) {
-    auto res = basic_json();
-    res.m_data.m_type = value_t::binary;
-    res.m_data.m_value = binary_t(init, subtype);
-    return res;
-  }
-
-  /// @brief explicitly create a binary array
-  /// @sa https://json.nlohmann.me/api/basic_json/binary/
-  JSON_HEDLEY_WARN_UNUSED_RESULT
-  static basic_json binary(typename binary_t::container_type &&init) {
-    auto res = basic_json();
-    res.m_data.m_type = value_t::binary;
-    res.m_data.m_value = std::move(init);
-    return res;
-  }
-
-  /// @brief explicitly create a binary array (with subtype)
-  /// @sa https://json.nlohmann.me/api/basic_json/binary/
-  JSON_HEDLEY_WARN_UNUSED_RESULT
-  static basic_json binary(typename binary_t::container_type &&init,
-                           typename binary_t::subtype_type subtype) {
-    auto res = basic_json();
-    res.m_data.m_type = value_t::binary;
-    res.m_data.m_value = binary_t(std::move(init), subtype);
-    return res;
-  }
-
-  /// @brief explicitly create an array from an initializer list
-  /// @sa https://json.nlohmann.me/api/basic_json/array/
-  JSON_HEDLEY_WARN_UNUSED_RESULT
-  static basic_json array(initializer_list_t init = {}) {
-    return basic_json(init, false, value_t::array);
-  }
-
-  /// @brief explicitly create an object from an initializer list
-  /// @sa https://json.nlohmann.me/api/basic_json/object/
-  JSON_HEDLEY_WARN_UNUSED_RESULT
-  static basic_json object(initializer_list_t init = {}) {
-    return basic_json(init, false, value_t::object);
-  }
-
-  /// @brief construct an array with count copies of given value
-  /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
-  basic_json(size_type cnt, const basic_json &val) : m_data{cnt, val} {
-    set_parents();
-    assert_invariant();
-  }
-
-  /// @brief construct a JSON container given an iterator range
-  /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
-  template <class InputIT,
-            typename std::enable_if<
-                std::is_same<InputIT, typename basic_json_t::iterator>::value ||
-                    std::is_same<InputIT,
-                                 typename basic_json_t::const_iterator>::value,
-                int>::type = 0>
-  basic_json(InputIT first,
-             InputIT last) // NOLINT(performance-unnecessary-value-param)
-  {
-    JSON_ASSERT(first.m_object != nullptr);
-    JSON_ASSERT(last.m_object != nullptr);
-
-    // make sure iterator fits the current value
-    if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object)) {
-      JSON_THROW(invalid_iterator::create(201, "iterators are not compatible",
-                                          nullptr));
-    }
-
-    // copy type from first iterator
-    m_data.m_type = first.m_object->m_data.m_type;
-
-    // check if iterator range is complete for primitive values
-    switch (m_data.m_type) {
-    case value_t::boolean:
-    case value_t::number_float:
-    case value_t::number_integer:
-    case value_t::number_unsigned:
-    case value_t::string: {
-      if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin() ||
-                               !last.m_it.primitive_iterator.is_end())) {
-        JSON_THROW(invalid_iterator::create(204, "iterators out of range",
-                                            first.m_object));
-      }
-      break;
-    }
-
-    case value_t::null:
-    case value_t::object:
-    case value_t::array:
-    case value_t::binary:
-    case value_t::discarded:
-    default:
-      break;
-    }
-
-    switch (m_data.m_type) {
-    case value_t::number_integer: {
-      m_data.m_value.number_integer =
-          first.m_object->m_data.m_value.number_integer;
-      break;
-    }
-
-    case value_t::number_unsigned: {
-      m_data.m_value.number_unsigned =
-          first.m_object->m_data.m_value.number_unsigned;
-      break;
-    }
-
-    case value_t::number_float: {
-      m_data.m_value.number_float = first.m_object->m_data.m_value.number_float;
-      break;
-    }
-
-    case value_t::boolean: {
-      m_data.m_value.boolean = first.m_object->m_data.m_value.boolean;
-      break;
-    }
-
-    case value_t::string: {
-      m_data.m_value = *first.m_object->m_data.m_value.string;
-      break;
-    }
-
-    case value_t::object: {
-      m_data.m_value.object = create<object_t>(first.m_it.object_iterator,
-                                               last.m_it.object_iterator);
-      break;
-    }
-
-    case value_t::array: {
-      m_data.m_value.array =
-          create<array_t>(first.m_it.array_iterator, last.m_it.array_iterator);
-      break;
-    }
-
-    case value_t::binary: {
-      m_data.m_value = *first.m_object->m_data.m_value.binary;
-      break;
-    }
-
-    case value_t::null:
-    case value_t::discarded:
-    default:
-      JSON_THROW(invalid_iterator::create(
-          206,
-          detail::concat("cannot construct with iterators from ",
-                         first.m_object->type_name()),
-          first.m_object));
-    }
-
-    set_parents();
-    assert_invariant();
-  }
-
-  ///////////////////////////////////////
-  // other constructors and destructor //
-  ///////////////////////////////////////
-
-  template <typename JsonRef,
-            detail::enable_if_t<
-                detail::conjunction<detail::is_json_ref<JsonRef>,
-                                    std::is_same<typename JsonRef::value_type,
-                                                 basic_json>>::value,
-                int> = 0>
-  basic_json(const JsonRef &ref) : basic_json(ref.moved_or_copied()) {}
-
-  /// @brief copy constructor
-  /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
-  basic_json(const basic_json &other) : json_base_class_t(other) {
-    m_data.m_type = other.m_data.m_type;
-    // check of passed value is valid
-    other.assert_invariant();
-
-    switch (m_data.m_type) {
-    case value_t::object: {
-      m_data.m_value = *other.m_data.m_value.object;
-      break;
-    }
-
-    case value_t::array: {
-      m_data.m_value = *other.m_data.m_value.array;
-      break;
-    }
-
-    case value_t::string: {
-      m_data.m_value = *other.m_data.m_value.string;
-      break;
-    }
-
-    case value_t::boolean: {
-      m_data.m_value = other.m_data.m_value.boolean;
-      break;
-    }
-
-    case value_t::number_integer: {
-      m_data.m_value = other.m_data.m_value.number_integer;
-      break;
-    }
-
-    case value_t::number_unsigned: {
-      m_data.m_value = other.m_data.m_value.number_unsigned;
-      break;
-    }
-
-    case value_t::number_float: {
-      m_data.m_value = other.m_data.m_value.number_float;
-      break;
-    }
-
-    case value_t::binary: {
-      m_data.m_value = *other.m_data.m_value.binary;
-      break;
-    }
-
-    case value_t::null:
-    case value_t::discarded:
-    default:
-      break;
-    }
-
-    set_parents();
-    assert_invariant();
-  }
-
-  /// @brief move constructor
-  /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
-  basic_json(basic_json &&other) noexcept
-      : json_base_class_t(std::forward<json_base_class_t>(other)),
-        m_data(std::move(other.m_data)) {
-    // check that passed value is valid
-    other.assert_invariant(false);
-
-    // invalidate payload
-    other.m_data.m_type = value_t::null;
-    other.m_data.m_value = {};
-
-    set_parents();
-    assert_invariant();
-  }
-
-  /// @brief copy assignment
-  /// @sa https://json.nlohmann.me/api/basic_json/operator=/
-  basic_json &operator=(basic_json other) noexcept(
-      std::is_nothrow_move_constructible<value_t>::value &&
-      std::is_nothrow_move_assignable<value_t>::value &&
-      std::is_nothrow_move_constructible<json_value>::value &&
-      std::is_nothrow_move_assignable<json_value>::value &&
-      std::is_nothrow_move_assignable<json_base_class_t>::value) {
-    // check that passed value is valid
-    other.assert_invariant();
-
-    using std::swap;
-    swap(m_data.m_type, other.m_data.m_type);
-    swap(m_data.m_value, other.m_data.m_value);
-    json_base_class_t::operator=(std::move(other));
-
-    set_parents();
-    assert_invariant();
-    return *this;
-  }
-
-  /// @brief destructor
-  /// @sa https://json.nlohmann.me/api/basic_json/~basic_json/
-  ~basic_json() noexcept { assert_invariant(false); }
-
-  /// @}
-
-public:
-  ///////////////////////
-  // object inspection //
-  ///////////////////////
-
-  /// @name object inspection
-  /// Functions to inspect the type of a JSON value.
-  /// @{
-
-  /// @brief serialization
-  /// @sa https://json.nlohmann.me/api/basic_json/dump/
-  string_t
-  dump(const int indent = -1, const char indent_char = ' ',
-       const bool ensure_ascii = false,
-       const error_handler_t error_handler = error_handler_t::strict) const {
-    string_t result;
-    serializer s(detail::output_adapter<char, string_t>(result), indent_char,
-                 error_handler);
-
-    if (indent >= 0) {
-      s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
-    } else {
-      s.dump(*this, false, ensure_ascii, 0);
-    }
-
-    return result;
-  }
-
-  /// @brief return the type of the JSON value (explicit)
-  /// @sa https://json.nlohmann.me/api/basic_json/type/
-  constexpr value_t type() const noexcept { return m_data.m_type; }
-
-  /// @brief return whether type is primitive
-  /// @sa https://json.nlohmann.me/api/basic_json/is_primitive/
-  constexpr bool is_primitive() const noexcept {
-    return is_null() || is_string() || is_boolean() || is_number() ||
-           is_binary();
-  }
-
-  /// @brief return whether type is structured
-  /// @sa https://json.nlohmann.me/api/basic_json/is_structured/
-  constexpr bool is_structured() const noexcept {
-    return is_array() || is_object();
-  }
-
-  /// @brief return whether value is null
-  /// @sa https://json.nlohmann.me/api/basic_json/is_null/
-  constexpr bool is_null() const noexcept {
-    return m_data.m_type == value_t::null;
-  }
-
-  /// @brief return whether value is a boolean
-  /// @sa https://json.nlohmann.me/api/basic_json/is_boolean/
-  constexpr bool is_boolean() const noexcept {
-    return m_data.m_type == value_t::boolean;
-  }
-
-  /// @brief return whether value is a number
-  /// @sa https://json.nlohmann.me/api/basic_json/is_number/
-  constexpr bool is_number() const noexcept {
-    return is_number_integer() || is_number_float();
-  }
-
-  /// @brief return whether value is an integer number
-  /// @sa https://json.nlohmann.me/api/basic_json/is_number_integer/
-  constexpr bool is_number_integer() const noexcept {
-    return m_data.m_type == value_t::number_integer ||
-           m_data.m_type == value_t::number_unsigned;
-  }
-
-  /// @brief return whether value is an unsigned integer number
-  /// @sa https://json.nlohmann.me/api/basic_json/is_number_unsigned/
-  constexpr bool is_number_unsigned() const noexcept {
-    return m_data.m_type == value_t::number_unsigned;
-  }
-
-  /// @brief return whether value is a floating-point number
-  /// @sa https://json.nlohmann.me/api/basic_json/is_number_float/
-  constexpr bool is_number_float() const noexcept {
-    return m_data.m_type == value_t::number_float;
-  }
-
-  /// @brief return whether value is an object
-  /// @sa https://json.nlohmann.me/api/basic_json/is_object/
-  constexpr bool is_object() const noexcept {
-    return m_data.m_type == value_t::object;
-  }
-
-  /// @brief return whether value is an array
-  /// @sa https://json.nlohmann.me/api/basic_json/is_array/
-  constexpr bool is_array() const noexcept {
-    return m_data.m_type == value_t::array;
-  }
-
-  /// @brief return whether value is a string
-  /// @sa https://json.nlohmann.me/api/basic_json/is_string/
-  constexpr bool is_string() const noexcept {
-    return m_data.m_type == value_t::string;
-  }
-
-  /// @brief return whether value is a binary array
-  /// @sa https://json.nlohmann.me/api/basic_json/is_binary/
-  constexpr bool is_binary() const noexcept {
-    return m_data.m_type == value_t::binary;
-  }
-
-  /// @brief return whether value is discarded
-  /// @sa https://json.nlohmann.me/api/basic_json/is_discarded/
-  constexpr bool is_discarded() const noexcept {
-    return m_data.m_type == value_t::discarded;
-  }
-
-  /// @brief return the type of the JSON value (implicit)
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_value_t/
-  constexpr operator value_t() const noexcept { return m_data.m_type; }
-
-  /// @}
-
-private:
-  //////////////////
-  // value access //
-  //////////////////
-
-  /// get a boolean (explicit)
-  boolean_t get_impl(boolean_t * /*unused*/) const {
-    if (JSON_HEDLEY_LIKELY(is_boolean())) {
-      return m_data.m_value.boolean;
-    }
-
-    JSON_THROW(type_error::create(
-        302, detail::concat("type must be boolean, but is ", type_name()),
-        this));
-  }
-
-  /// get a pointer to the value (object)
-  object_t *get_impl_ptr(object_t * /*unused*/) noexcept {
-    return is_object() ? m_data.m_value.object : nullptr;
-  }
-
-  /// get a pointer to the value (object)
-  constexpr const object_t *
-  get_impl_ptr(const object_t * /*unused*/) const noexcept {
-    return is_object() ? m_data.m_value.object : nullptr;
-  }
-
-  /// get a pointer to the value (array)
-  array_t *get_impl_ptr(array_t * /*unused*/) noexcept {
-    return is_array() ? m_data.m_value.array : nullptr;
-  }
-
-  /// get a pointer to the value (array)
-  constexpr const array_t *
-  get_impl_ptr(const array_t * /*unused*/) const noexcept {
-    return is_array() ? m_data.m_value.array : nullptr;
-  }
-
-  /// get a pointer to the value (string)
-  string_t *get_impl_ptr(string_t * /*unused*/) noexcept {
-    return is_string() ? m_data.m_value.string : nullptr;
-  }
-
-  /// get a pointer to the value (string)
-  constexpr const string_t *
-  get_impl_ptr(const string_t * /*unused*/) const noexcept {
-    return is_string() ? m_data.m_value.string : nullptr;
-  }
-
-  /// get a pointer to the value (boolean)
-  boolean_t *get_impl_ptr(boolean_t * /*unused*/) noexcept {
-    return is_boolean() ? &m_data.m_value.boolean : nullptr;
-  }
-
-  /// get a pointer to the value (boolean)
-  constexpr const boolean_t *
-  get_impl_ptr(const boolean_t * /*unused*/) const noexcept {
-    return is_boolean() ? &m_data.m_value.boolean : nullptr;
-  }
-
-  /// get a pointer to the value (integer number)
-  number_integer_t *get_impl_ptr(number_integer_t * /*unused*/) noexcept {
-    return m_data.m_type == value_t::number_integer
-               ? &m_data.m_value.number_integer
-               : nullptr;
-  }
-
-  /// get a pointer to the value (integer number)
-  constexpr const number_integer_t *
-  get_impl_ptr(const number_integer_t * /*unused*/) const noexcept {
-    return m_data.m_type == value_t::number_integer
-               ? &m_data.m_value.number_integer
-               : nullptr;
-  }
-
-  /// get a pointer to the value (unsigned number)
-  number_unsigned_t *get_impl_ptr(number_unsigned_t * /*unused*/) noexcept {
-    return is_number_unsigned() ? &m_data.m_value.number_unsigned : nullptr;
-  }
-
-  /// get a pointer to the value (unsigned number)
-  constexpr const number_unsigned_t *
-  get_impl_ptr(const number_unsigned_t * /*unused*/) const noexcept {
-    return is_number_unsigned() ? &m_data.m_value.number_unsigned : nullptr;
-  }
-
-  /// get a pointer to the value (floating-point number)
-  number_float_t *get_impl_ptr(number_float_t * /*unused*/) noexcept {
-    return is_number_float() ? &m_data.m_value.number_float : nullptr;
-  }
-
-  /// get a pointer to the value (floating-point number)
-  constexpr const number_float_t *
-  get_impl_ptr(const number_float_t * /*unused*/) const noexcept {
-    return is_number_float() ? &m_data.m_value.number_float : nullptr;
-  }
-
-  /// get a pointer to the value (binary)
-  binary_t *get_impl_ptr(binary_t * /*unused*/) noexcept {
-    return is_binary() ? m_data.m_value.binary : nullptr;
-  }
-
-  /// get a pointer to the value (binary)
-  constexpr const binary_t *
-  get_impl_ptr(const binary_t * /*unused*/) const noexcept {
-    return is_binary() ? m_data.m_value.binary : nullptr;
-  }
-
-  /*!
-  @brief helper function to implement get_ref()
-
-  This function helps to implement get_ref() without code duplication for
-  const and non-const overloads
-
-  @tparam ThisType will be deduced as `basic_json` or `const basic_json`
-
-  @throw type_error.303 if ReferenceType does not match underlying value
-  type of the current JSON
-  */
-  template <typename ReferenceType, typename ThisType>
-  static ReferenceType get_ref_impl(ThisType &obj) {
-    // delegate the call to get_ptr<>()
-    auto *ptr =
-        obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
-
-    if (JSON_HEDLEY_LIKELY(ptr != nullptr)) {
-      return *ptr;
-    }
-
-    JSON_THROW(type_error::create(
-        303,
-        detail::concat(
-            "incompatible ReferenceType for get_ref, actual type is ",
-            obj.type_name()),
-        &obj));
-  }
-
-public:
-  /// @name value access
-  /// Direct access to the stored value of a JSON value.
-  /// @{
-
-  /// @brief get a pointer value (implicit)
-  /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
-  template <typename PointerType,
-            typename std::enable_if<std::is_pointer<PointerType>::value,
-                                    int>::type = 0>
-  auto get_ptr() noexcept
-      -> decltype(std::declval<basic_json_t &>().get_impl_ptr(
-          std::declval<PointerType>())) {
-    // delegate the call to get_impl_ptr<>()
-    return get_impl_ptr(static_cast<PointerType>(nullptr));
-  }
-
-  /// @brief get a pointer value (implicit)
-  /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
-  template <
-      typename PointerType,
-      typename std::enable_if<std::is_pointer<PointerType>::value &&
-                                  std::is_const<typename std::remove_pointer<
-                                      PointerType>::type>::value,
-                              int>::type = 0>
-  constexpr auto get_ptr() const noexcept
-      -> decltype(std::declval<const basic_json_t &>().get_impl_ptr(
-          std::declval<PointerType>())) {
-    // delegate the call to get_impl_ptr<>() const
-    return get_impl_ptr(static_cast<PointerType>(nullptr));
-  }
-
-private:
-  /*!
-  @brief get a value (explicit)
-
-  Explicit type conversion between the JSON value and a compatible value
-  which is
-  [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
-  and
-  [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
-  The value is converted by calling the @ref json_serializer<ValueType>
-  `from_json()` method.
-
-  The function is equivalent to executing
-  @code {.cpp}
-  ValueType ret;
-  JSONSerializer<ValueType>::from_json(*this, ret);
-  return ret;
-  @endcode
-
-  This overloads is chosen if:
-  - @a ValueType is not @ref basic_json,
-  - @ref json_serializer<ValueType> has a `from_json()` method of the form
-    `void from_json(const basic_json&, ValueType&)`, and
-  - @ref json_serializer<ValueType> does not have a `from_json()` method of
-    the form `ValueType from_json(const basic_json&)`
-
-  @tparam ValueType the returned value type
-
-  @return copy of the JSON value, converted to @a ValueType
-
-  @throw what @ref json_serializer<ValueType> `from_json()` method throws
-
-  @liveexample{The example below shows several conversions from JSON values
-  to other types. There a few things to note: (1) Floating-point numbers can
-  be converted to integers\, (2) A JSON array can be converted to a standard
-  `std::vector<short>`\, (3) A JSON object can be converted to C++
-  associative containers such as `std::unordered_map<std::string\,
-  json>`.,get__ValueType_const}
-
-  @since version 2.1.0
-  */
-  template <typename ValueType,
-            detail::enable_if_t<
-                detail::is_default_constructible<ValueType>::value &&
-                    detail::has_from_json<basic_json_t, ValueType>::value,
-                int> = 0>
-  ValueType get_impl(detail::priority_tag<0> /*unused*/) const
-      noexcept(noexcept(JSONSerializer<ValueType>::from_json(
-          std::declval<const basic_json_t &>(), std::declval<ValueType &>()))) {
-    auto ret = ValueType();
-    JSONSerializer<ValueType>::from_json(*this, ret);
-    return ret;
-  }
-
-  /*!
-  @brief get a value (explicit); special case
-
-  Explicit type conversion between the JSON value and a compatible value
-  which is **not**
-  [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
-  and **not**
-  [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
-  The value is converted by calling the @ref json_serializer<ValueType>
-  `from_json()` method.
-
-  The function is equivalent to executing
-  @code {.cpp}
-  return JSONSerializer<ValueType>::from_json(*this);
-  @endcode
-
-  This overloads is chosen if:
-  - @a ValueType is not @ref basic_json and
-  - @ref json_serializer<ValueType> has a `from_json()` method of the form
-    `ValueType from_json(const basic_json&)`
-
-  @note If @ref json_serializer<ValueType> has both overloads of
-  `from_json()`, this one is chosen.
-
-  @tparam ValueType the returned value type
-
-  @return copy of the JSON value, converted to @a ValueType
-
-  @throw what @ref json_serializer<ValueType> `from_json()` method throws
-
-  @since version 2.1.0
-  */
-  template <typename ValueType,
-            detail::enable_if_t<detail::has_non_default_from_json<
-                                    basic_json_t, ValueType>::value,
-                                int> = 0>
-  ValueType get_impl(detail::priority_tag<1> /*unused*/) const
-      noexcept(noexcept(JSONSerializer<ValueType>::from_json(
-          std::declval<const basic_json_t &>()))) {
-    return JSONSerializer<ValueType>::from_json(*this);
-  }
-
-  /*!
-  @brief get special-case overload
-
-  This overloads converts the current @ref basic_json in a different
-  @ref basic_json type
-
-  @tparam BasicJsonType == @ref basic_json
-
-  @return a copy of *this, converted into @a BasicJsonType
-
-  @complexity Depending on the implementation of the called `from_json()`
-              method.
-
-  @since version 3.2.0
-  */
-  template <
-      typename BasicJsonType,
-      detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
-  BasicJsonType get_impl(detail::priority_tag<2> /*unused*/) const {
-    return *this;
-  }
-
-  /*!
-  @brief get special-case overload
-
-  This overloads avoids a lot of template boilerplate, it can be seen as the
-  identity method
-
-  @tparam BasicJsonType == @ref basic_json
-
-  @return a copy of *this
-
-  @complexity Constant.
-
-  @since version 2.1.0
-  */
-  template <typename BasicJsonType,
-            detail::enable_if_t<
-                std::is_same<BasicJsonType, basic_json_t>::value, int> = 0>
-  basic_json get_impl(detail::priority_tag<3> /*unused*/) const {
-    return *this;
-  }
-
-  /*!
-  @brief get a pointer value (explicit)
-  @copydoc get()
-  */
-  template <typename PointerType,
-            detail::enable_if_t<std::is_pointer<PointerType>::value, int> = 0>
-  constexpr auto get_impl(detail::priority_tag<4> /*unused*/) const noexcept
-      -> decltype(std::declval<const basic_json_t &>()
-                      .template get_ptr<PointerType>()) {
-    // delegate the call to get_ptr
-    return get_ptr<PointerType>();
-  }
-
-public:
-  /*!
-  @brief get a (pointer) value (explicit)
-
-  Performs explicit type conversion between the JSON value and a compatible
-  value if required.
-
-  - If the requested type is a pointer to the internally stored JSON value that
-  pointer is returned. No copies are made.
-
-  - If the requested type is the current @ref basic_json, or a different @ref
-  basic_json convertible from the current @ref basic_json.
-
-  - Otherwise the value is converted by calling the @ref
-  json_serializer<ValueType> `from_json()` method.
-
-  @tparam ValueTypeCV the provided value type
-  @tparam ValueType the returned value type
-
-  @return copy of the JSON value, converted to @tparam ValueType if necessary
-
-  @throw what @ref json_serializer<ValueType> `from_json()` method throws if
-  conversion is required
-
-  @since version 2.1.0
-  */
-  template <typename ValueTypeCV,
-            typename ValueType = detail::uncvref_t<ValueTypeCV>>
-#if defined(JSON_HAS_CPP_14)
-  constexpr
-#endif
-      auto get() const noexcept(noexcept(
-          std::declval<const basic_json_t &>().template get_impl<ValueType>(
-              detail::priority_tag<4>{})))
-          -> decltype(std::declval<const basic_json_t &>()
-                          .template get_impl<ValueType>(
-                              detail::priority_tag<4>{})) {
-    // we cannot static_assert on ValueTypeCV being non-const, because
-    // there is support for get<const basic_json_t>(), which is why we
-    // still need the uncvref
-    static_assert(!std::is_reference<ValueTypeCV>::value,
-                  "get() cannot be used with reference types, you might want "
-                  "to use get_ref()");
-    return get_impl<ValueType>(detail::priority_tag<4>{});
-  }
-
-  /*!
-  @brief get a pointer value (explicit)
-
-  Explicit pointer access to the internally stored JSON value. No copies are
-  made.
-
-  @warning The pointer becomes invalid if the underlying JSON object
-  changes.
-
-  @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
-  object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
-  @ref number_unsigned_t, or @ref number_float_t.
-
-  @return pointer to the internally stored JSON value if the requested
-  pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
-
-  @complexity Constant.
-
-  @liveexample{The example below shows how pointers to internal values of a
-  JSON value can be requested. Note that no type conversions are made and a
-  `nullptr` is returned if the value and the requested pointer type does not
-  match.,get__PointerType}
-
-  @sa see @ref get_ptr() for explicit pointer-member access
-
-  @since version 1.0.0
-  */
-  template <typename PointerType,
-            typename std::enable_if<std::is_pointer<PointerType>::value,
-                                    int>::type = 0>
-  auto get() noexcept -> decltype(std::declval<basic_json_t &>()
-                                      .template get_ptr<PointerType>()) {
-    // delegate the call to get_ptr
-    return get_ptr<PointerType>();
-  }
-
-  /// @brief get a value (explicit)
-  /// @sa https://json.nlohmann.me/api/basic_json/get_to/
-  template <typename ValueType,
-            detail::enable_if_t<
-                !detail::is_basic_json<ValueType>::value &&
-                    detail::has_from_json<basic_json_t, ValueType>::value,
-                int> = 0>
-  ValueType &get_to(ValueType &v) const
-      noexcept(noexcept(JSONSerializer<ValueType>::from_json(
-          std::declval<const basic_json_t &>(), v))) {
-    JSONSerializer<ValueType>::from_json(*this, v);
-    return v;
-  }
-
-  // specialization to allow calling get_to with a basic_json value
-  // see https://github.com/nlohmann/json/issues/2175
-  template <
-      typename ValueType,
-      detail::enable_if_t<detail::is_basic_json<ValueType>::value, int> = 0>
-  ValueType &get_to(ValueType &v) const {
-    v = *this;
-    return v;
-  }
-
-  template <
-      typename T, std::size_t N,
-      typename Array = T (&)
-          [N], // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
-      detail::enable_if_t<detail::has_from_json<basic_json_t, Array>::value,
-                          int> = 0>
-  Array get_to(T (&v)[N])
-      const // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
-      noexcept(noexcept(JSONSerializer<Array>::from_json(
-          std::declval<const basic_json_t &>(), v))) {
-    JSONSerializer<Array>::from_json(*this, v);
-    return v;
-  }
-
-  /// @brief get a reference value (implicit)
-  /// @sa https://json.nlohmann.me/api/basic_json/get_ref/
-  template <typename ReferenceType,
-            typename std::enable_if<std::is_reference<ReferenceType>::value,
-                                    int>::type = 0>
-  ReferenceType get_ref() {
-    // delegate call to get_ref_impl
-    return get_ref_impl<ReferenceType>(*this);
-  }
-
-  /// @brief get a reference value (implicit)
-  /// @sa https://json.nlohmann.me/api/basic_json/get_ref/
-  template <
-      typename ReferenceType,
-      typename std::enable_if<std::is_reference<ReferenceType>::value &&
-                                  std::is_const<typename std::remove_reference<
-                                      ReferenceType>::type>::value,
-                              int>::type = 0>
-  ReferenceType get_ref() const {
-    // delegate call to get_ref_impl
-    return get_ref_impl<ReferenceType>(*this);
-  }
-
-  /*!
-  @brief get a value (implicit)
-
-  Implicit type conversion between the JSON value and a compatible value.
-  The call is realized by calling @ref get() const.
-
-  @tparam ValueType non-pointer type compatible to the JSON value, for
-  instance `int` for JSON integer numbers, `bool` for JSON booleans, or
-  `std::vector` types for JSON arrays. The character type of @ref string_t
-  as well as an initializer list of this type is excluded to avoid
-  ambiguities as these types implicitly convert to `std::string`.
-
-  @return copy of the JSON value, converted to type @a ValueType
-
-  @throw type_error.302 in case passed type @a ValueType is incompatible
-  to the JSON value type (e.g., the JSON value is of type boolean, but a
-  string is requested); see example below
-
-  @complexity Linear in the size of the JSON value.
-
-  @liveexample{The example below shows several conversions from JSON values
-  to other types. There a few things to note: (1) Floating-point numbers can
-  be converted to integers\, (2) A JSON array can be converted to a standard
-  `std::vector<short>`\, (3) A JSON object can be converted to C++
-  associative containers such as `std::unordered_map<std::string\,
-  json>`.,operator__ValueType}
-
-  @since version 1.0.0
-  */
-  template <
-      typename ValueType,
-      typename std::enable_if<
-          detail::conjunction<
-              detail::negation<std::is_pointer<ValueType>>,
-              detail::negation<std::is_same<ValueType, std::nullptr_t>>,
-              detail::negation<
-                  std::is_same<ValueType, detail::json_ref<basic_json>>>,
-              detail::negation<
-                  std::is_same<ValueType, typename string_t::value_type>>,
-              detail::negation<detail::is_basic_json<ValueType>>,
-              detail::negation<std::is_same<
-                  ValueType,
-                  std::initializer_list<typename string_t::value_type>>>,
-#if defined(JSON_HAS_CPP_17) &&                                                \
-    (defined(__GNUC__) ||                                                      \
-     (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
-              detail::negation<std::is_same<ValueType, std::string_view>>,
-#endif
-#if defined(JSON_HAS_CPP_17) && JSON_HAS_STATIC_RTTI
-              detail::negation<std::is_same<ValueType, std::any>>,
-#endif
-              detail::is_detected_lazy<detail::get_template_function,
-                                       const basic_json_t &, ValueType>>::value,
-          int>::type = 0>
-  JSON_EXPLICIT operator ValueType() const {
-    // delegate the call to get<>() const
-    return get<ValueType>();
-  }
-
-  /// @brief get a binary value
-  /// @sa https://json.nlohmann.me/api/basic_json/get_binary/
-  binary_t &get_binary() {
-    if (!is_binary()) {
-      JSON_THROW(type_error::create(
-          302, detail::concat("type must be binary, but is ", type_name()),
-          this));
-    }
-
-    return *get_ptr<binary_t *>();
-  }
-
-  /// @brief get a binary value
-  /// @sa https://json.nlohmann.me/api/basic_json/get_binary/
-  const binary_t &get_binary() const {
-    if (!is_binary()) {
-      JSON_THROW(type_error::create(
-          302, detail::concat("type must be binary, but is ", type_name()),
-          this));
-    }
-
-    return *get_ptr<const binary_t *>();
-  }
-
-  /// @}
-
-  ////////////////////
-  // element access //
-  ////////////////////
-
-  /// @name element access
-  /// Access to the JSON value.
-  /// @{
-
-  /// @brief access specified array element with bounds checking
-  /// @sa https://json.nlohmann.me/api/basic_json/at/
-  reference at(size_type idx) {
-    // at only works for arrays
-    if (JSON_HEDLEY_LIKELY(is_array())) {
-      JSON_TRY { return set_parent(m_data.m_value.array->at(idx)); }
-      JSON_CATCH(std::out_of_range &) {
-        // create better exception explanation
-        JSON_THROW(out_of_range::create(401,
-                                        detail::concat("array index ",
-                                                       std::to_string(idx),
-                                                       " is out of range"),
-                                        this));
-      }
-    } else {
-      JSON_THROW(type_error::create(
-          304, detail::concat("cannot use at() with ", type_name()), this));
-    }
-  }
-
-  /// @brief access specified array element with bounds checking
-  /// @sa https://json.nlohmann.me/api/basic_json/at/
-  const_reference at(size_type idx) const {
-    // at only works for arrays
-    if (JSON_HEDLEY_LIKELY(is_array())) {
-      JSON_TRY { return m_data.m_value.array->at(idx); }
-      JSON_CATCH(std::out_of_range &) {
-        // create better exception explanation
-        JSON_THROW(out_of_range::create(401,
-                                        detail::concat("array index ",
-                                                       std::to_string(idx),
-                                                       " is out of range"),
-                                        this));
-      }
-    } else {
-      JSON_THROW(type_error::create(
-          304, detail::concat("cannot use at() with ", type_name()), this));
-    }
-  }
-
-  /// @brief access specified object element with bounds checking
-  /// @sa https://json.nlohmann.me/api/basic_json/at/
-  reference at(const typename object_t::key_type &key) {
-    // at only works for objects
-    if (JSON_HEDLEY_UNLIKELY(!is_object())) {
-      JSON_THROW(type_error::create(
-          304, detail::concat("cannot use at() with ", type_name()), this));
-    }
-
-    auto it = m_data.m_value.object->find(key);
-    if (it == m_data.m_value.object->end()) {
-      JSON_THROW(out_of_range::create(
-          403, detail::concat("key '", key, "' not found"), this));
-    }
-    return set_parent(it->second);
-  }
-
-  /// @brief access specified object element with bounds checking
-  /// @sa https://json.nlohmann.me/api/basic_json/at/
-  template <class KeyType,
-            detail::enable_if_t<detail::is_usable_as_basic_json_key_type<
-                                    basic_json_t, KeyType>::value,
-                                int> = 0>
-  reference at(KeyType &&key) {
-    // at only works for objects
-    if (JSON_HEDLEY_UNLIKELY(!is_object())) {
-      JSON_THROW(type_error::create(
-          304, detail::concat("cannot use at() with ", type_name()), this));
-    }
-
-    auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
-    if (it == m_data.m_value.object->end()) {
-      JSON_THROW(out_of_range::create(
-          403,
-          detail::concat("key '", string_t(std::forward<KeyType>(key)),
-                         "' not found"),
-          this));
-    }
-    return set_parent(it->second);
-  }
-
-  /// @brief access specified object element with bounds checking
-  /// @sa https://json.nlohmann.me/api/basic_json/at/
-  const_reference at(const typename object_t::key_type &key) const {
-    // at only works for objects
-    if (JSON_HEDLEY_UNLIKELY(!is_object())) {
-      JSON_THROW(type_error::create(
-          304, detail::concat("cannot use at() with ", type_name()), this));
-    }
-
-    auto it = m_data.m_value.object->find(key);
-    if (it == m_data.m_value.object->end()) {
-      JSON_THROW(out_of_range::create(
-          403, detail::concat("key '", key, "' not found"), this));
-    }
-    return it->second;
-  }
-
-  /// @brief access specified object element with bounds checking
-  /// @sa https://json.nlohmann.me/api/basic_json/at/
-  template <class KeyType,
-            detail::enable_if_t<detail::is_usable_as_basic_json_key_type<
-                                    basic_json_t, KeyType>::value,
-                                int> = 0>
-  const_reference at(KeyType &&key) const {
-    // at only works for objects
-    if (JSON_HEDLEY_UNLIKELY(!is_object())) {
-      JSON_THROW(type_error::create(
-          304, detail::concat("cannot use at() with ", type_name()), this));
-    }
-
-    auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
-    if (it == m_data.m_value.object->end()) {
-      JSON_THROW(out_of_range::create(
-          403,
-          detail::concat("key '", string_t(std::forward<KeyType>(key)),
-                         "' not found"),
-          this));
-    }
-    return it->second;
-  }
-
-  /// @brief access specified array element
-  /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
-  reference operator[](size_type idx) {
-    // implicitly convert null value to an empty array
-    if (is_null()) {
-      m_data.m_type = value_t::array;
-      m_data.m_value.array = create<array_t>();
-      assert_invariant();
-    }
-
-    // operator[] only works for arrays
-    if (JSON_HEDLEY_LIKELY(is_array())) {
-      // fill up array with null values if given idx is outside range
-      if (idx >= m_data.m_value.array->size()) {
-#if JSON_DIAGNOSTICS
-        // remember array size & capacity before resizing
-        const auto old_size = m_data.m_value.array->size();
-        const auto old_capacity = m_data.m_value.array->capacity();
-#endif
-        m_data.m_value.array->resize(idx + 1);
-
-#if JSON_DIAGNOSTICS
-        if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() !=
-                                 old_capacity)) {
-          // capacity has changed: update all parents
-          set_parents();
-        } else {
-          // set parent for values added above
-          set_parents(begin() + static_cast<typename iterator::difference_type>(
-                                    old_size),
-                      static_cast<typename iterator::difference_type>(
-                          idx + 1 - old_size));
-        }
-#endif
-        assert_invariant();
-      }
-
-      return m_data.m_value.array->operator[](idx);
-    }
-
-    JSON_THROW(type_error::create(
-        305,
-        detail::concat("cannot use operator[] with a numeric argument with ",
-                       type_name()),
-        this));
-  }
-
-  /// @brief access specified array element
-  /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
-  const_reference operator[](size_type idx) const {
-    // const operator[] only works for arrays
-    if (JSON_HEDLEY_LIKELY(is_array())) {
-      return m_data.m_value.array->operator[](idx);
-    }
-
-    JSON_THROW(type_error::create(
-        305,
-        detail::concat("cannot use operator[] with a numeric argument with ",
-                       type_name()),
-        this));
-  }
-
-  /// @brief access specified object element
-  /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
-  reference operator[](typename object_t::key_type
-                           key) // NOLINT(performance-unnecessary-value-param)
-  {
-    // implicitly convert null value to an empty object
-    if (is_null()) {
-      m_data.m_type = value_t::object;
-      m_data.m_value.object = create<object_t>();
-      assert_invariant();
-    }
-
-    // operator[] only works for objects
-    if (JSON_HEDLEY_LIKELY(is_object())) {
-      auto result = m_data.m_value.object->emplace(std::move(key), nullptr);
-      return set_parent(result.first->second);
-    }
-
-    JSON_THROW(type_error::create(
-        305,
-        detail::concat("cannot use operator[] with a string argument with ",
-                       type_name()),
-        this));
-  }
-
-  /// @brief access specified object element
-  /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
-  const_reference operator[](const typename object_t::key_type &key) const {
-    // const operator[] only works for objects
-    if (JSON_HEDLEY_LIKELY(is_object())) {
-      auto it = m_data.m_value.object->find(key);
-      JSON_ASSERT(it != m_data.m_value.object->end());
-      return it->second;
-    }
-
-    JSON_THROW(type_error::create(
-        305,
-        detail::concat("cannot use operator[] with a string argument with ",
-                       type_name()),
-        this));
-  }
-
-  // these two functions resolve a (const) char * ambiguity affecting Clang and
-  // MSVC (they seemingly cannot be constrained to resolve the ambiguity)
-  template <typename T> reference operator[](T *key) {
-    return operator[](typename object_t::key_type(key));
-  }
-
-  template <typename T> const_reference operator[](T *key) const {
-    return operator[](typename object_t::key_type(key));
-  }
-
-  /// @brief access specified object element
-  /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
-  template <class KeyType,
-            detail::enable_if_t<detail::is_usable_as_basic_json_key_type<
-                                    basic_json_t, KeyType>::value,
-                                int> = 0>
-  reference operator[](KeyType &&key) {
-    // implicitly convert null value to an empty object
-    if (is_null()) {
-      m_data.m_type = value_t::object;
-      m_data.m_value.object = create<object_t>();
-      assert_invariant();
-    }
-
-    // operator[] only works for objects
-    if (JSON_HEDLEY_LIKELY(is_object())) {
-      auto result =
-          m_data.m_value.object->emplace(std::forward<KeyType>(key), nullptr);
-      return set_parent(result.first->second);
-    }
-
-    JSON_THROW(type_error::create(
-        305,
-        detail::concat("cannot use operator[] with a string argument with ",
-                       type_name()),
-        this));
-  }
-
-  /// @brief access specified object element
-  /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
-  template <class KeyType,
-            detail::enable_if_t<detail::is_usable_as_basic_json_key_type<
-                                    basic_json_t, KeyType>::value,
-                                int> = 0>
-  const_reference operator[](KeyType &&key) const {
-    // const operator[] only works for objects
-    if (JSON_HEDLEY_LIKELY(is_object())) {
-      auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
-      JSON_ASSERT(it != m_data.m_value.object->end());
-      return it->second;
-    }
-
-    JSON_THROW(type_error::create(
-        305,
-        detail::concat("cannot use operator[] with a string argument with ",
-                       type_name()),
-        this));
-  }
-
-private:
-  template <typename KeyType>
-  using is_comparable_with_object_key =
-      detail::is_comparable<object_comparator_t,
-                            const typename object_t::key_type &, KeyType>;
-
-  template <typename ValueType>
-  using value_return_type =
-      std::conditional<detail::is_c_string_uncvref<ValueType>::value, string_t,
-                       typename std::decay<ValueType>::type>;
-
-public:
-  /// @brief access specified object element with default value
-  /// @sa https://json.nlohmann.me/api/basic_json/value/
-  template <class ValueType,
-            detail::enable_if_t<
-                !detail::is_transparent<object_comparator_t>::value &&
-                    detail::is_getable<basic_json_t, ValueType>::value &&
-                    !std::is_same<value_t, detail::uncvref_t<ValueType>>::value,
-                int> = 0>
-  ValueType value(const typename object_t::key_type &key,
-                  const ValueType &default_value) const {
-    // value only works for objects
-    if (JSON_HEDLEY_LIKELY(is_object())) {
-      // if key is found, return value and given default value otherwise
-      const auto it = find(key);
-      if (it != end()) {
-        return it->template get<ValueType>();
-      }
-
-      return default_value;
-    }
-
-    JSON_THROW(type_error::create(
-        306, detail::concat("cannot use value() with ", type_name()), this));
-  }
-
-  /// @brief access specified object element with default value
-  /// @sa https://json.nlohmann.me/api/basic_json/value/
-  template <class ValueType,
-            class ReturnType = typename value_return_type<ValueType>::type,
-            detail::enable_if_t<
-                !detail::is_transparent<object_comparator_t>::value &&
-                    detail::is_getable<basic_json_t, ReturnType>::value &&
-                    !std::is_same<value_t, detail::uncvref_t<ValueType>>::value,
-                int> = 0>
-  ReturnType value(const typename object_t::key_type &key,
-                   ValueType &&default_value) const {
-    // value only works for objects
-    if (JSON_HEDLEY_LIKELY(is_object())) {
-      // if key is found, return value and given default value otherwise
-      const auto it = find(key);
-      if (it != end()) {
-        return it->template get<ReturnType>();
-      }
-
-      return std::forward<ValueType>(default_value);
-    }
-
-    JSON_THROW(type_error::create(
-        306, detail::concat("cannot use value() with ", type_name()), this));
-  }
-
-  /// @brief access specified object element with default value
-  /// @sa https://json.nlohmann.me/api/basic_json/value/
-  template <class ValueType, class KeyType,
-            detail::enable_if_t<
-                detail::is_transparent<object_comparator_t>::value &&
-                    !detail::is_json_pointer<KeyType>::value &&
-                    is_comparable_with_object_key<KeyType>::value &&
-                    detail::is_getable<basic_json_t, ValueType>::value &&
-                    !std::is_same<value_t, detail::uncvref_t<ValueType>>::value,
-                int> = 0>
-  ValueType value(KeyType &&key, const ValueType &default_value) const {
-    // value only works for objects
-    if (JSON_HEDLEY_LIKELY(is_object())) {
-      // if key is found, return value and given default value otherwise
-      const auto it = find(std::forward<KeyType>(key));
-      if (it != end()) {
-        return it->template get<ValueType>();
-      }
-
-      return default_value;
-    }
-
-    JSON_THROW(type_error::create(
-        306, detail::concat("cannot use value() with ", type_name()), this));
-  }
-
-  /// @brief access specified object element via JSON Pointer with default value
-  /// @sa https://json.nlohmann.me/api/basic_json/value/
-  template <class ValueType, class KeyType,
-            class ReturnType = typename value_return_type<ValueType>::type,
-            detail::enable_if_t<
-                detail::is_transparent<object_comparator_t>::value &&
-                    !detail::is_json_pointer<KeyType>::value &&
-                    is_comparable_with_object_key<KeyType>::value &&
-                    detail::is_getable<basic_json_t, ReturnType>::value &&
-                    !std::is_same<value_t, detail::uncvref_t<ValueType>>::value,
-                int> = 0>
-  ReturnType value(KeyType &&key, ValueType &&default_value) const {
-    // value only works for objects
-    if (JSON_HEDLEY_LIKELY(is_object())) {
-      // if key is found, return value and given default value otherwise
-      const auto it = find(std::forward<KeyType>(key));
-      if (it != end()) {
-        return it->template get<ReturnType>();
-      }
-
-      return std::forward<ValueType>(default_value);
-    }
-
-    JSON_THROW(type_error::create(
-        306, detail::concat("cannot use value() with ", type_name()), this));
-  }
-
-  /// @brief access specified object element via JSON Pointer with default value
-  /// @sa https://json.nlohmann.me/api/basic_json/value/
-  template <class ValueType,
-            detail::enable_if_t<
-                detail::is_getable<basic_json_t, ValueType>::value &&
-                    !std::is_same<value_t, detail::uncvref_t<ValueType>>::value,
-                int> = 0>
-  ValueType value(const json_pointer &ptr,
-                  const ValueType &default_value) const {
-    // value only works for objects
-    if (JSON_HEDLEY_LIKELY(is_object())) {
-      // if pointer resolves a value, return it or use default value
-      JSON_TRY { return ptr.get_checked(this).template get<ValueType>(); }
-      JSON_INTERNAL_CATCH(out_of_range &) { return default_value; }
-    }
-
-    JSON_THROW(type_error::create(
-        306, detail::concat("cannot use value() with ", type_name()), this));
-  }
-
-  /// @brief access specified object element via JSON Pointer with default value
-  /// @sa https://json.nlohmann.me/api/basic_json/value/
-  template <class ValueType,
-            class ReturnType = typename value_return_type<ValueType>::type,
-            detail::enable_if_t<
-                detail::is_getable<basic_json_t, ReturnType>::value &&
-                    !std::is_same<value_t, detail::uncvref_t<ValueType>>::value,
-                int> = 0>
-  ReturnType value(const json_pointer &ptr, ValueType &&default_value) const {
-    // value only works for objects
-    if (JSON_HEDLEY_LIKELY(is_object())) {
-      // if pointer resolves a value, return it or use default value
-      JSON_TRY { return ptr.get_checked(this).template get<ReturnType>(); }
-      JSON_INTERNAL_CATCH(out_of_range &) {
-        return std::forward<ValueType>(default_value);
-      }
-    }
-
-    JSON_THROW(type_error::create(
-        306, detail::concat("cannot use value() with ", type_name()), this));
-  }
-
-  template <class ValueType, class BasicJsonType,
-            detail::enable_if_t<
-                detail::is_basic_json<BasicJsonType>::value &&
-                    detail::is_getable<basic_json_t, ValueType>::value &&
-                    !std::is_same<value_t, detail::uncvref_t<ValueType>>::value,
-                int> = 0>
-  JSON_HEDLEY_DEPRECATED_FOR(
-      3.11.0, basic_json::json_pointer or
-                  nlohmann::json_pointer<
-                      basic_json::string_t>) // NOLINT(readability/alt_tokens)
-  ValueType value(const ::nlohmann::json_pointer<BasicJsonType> &ptr,
-                  const ValueType &default_value) const {
-    return value(ptr.convert(), default_value);
-  }
-
-  template <class ValueType, class BasicJsonType,
-            class ReturnType = typename value_return_type<ValueType>::type,
-            detail::enable_if_t<
-                detail::is_basic_json<BasicJsonType>::value &&
-                    detail::is_getable<basic_json_t, ReturnType>::value &&
-                    !std::is_same<value_t, detail::uncvref_t<ValueType>>::value,
-                int> = 0>
-  JSON_HEDLEY_DEPRECATED_FOR(
-      3.11.0, basic_json::json_pointer or
-                  nlohmann::json_pointer<
-                      basic_json::string_t>) // NOLINT(readability/alt_tokens)
-  ReturnType value(const ::nlohmann::json_pointer<BasicJsonType> &ptr,
-                   ValueType &&default_value) const {
-    return value(ptr.convert(), std::forward<ValueType>(default_value));
-  }
-
-  /// @brief access the first element
-  /// @sa https://json.nlohmann.me/api/basic_json/front/
-  reference front() { return *begin(); }
-
-  /// @brief access the first element
-  /// @sa https://json.nlohmann.me/api/basic_json/front/
-  const_reference front() const { return *cbegin(); }
-
-  /// @brief access the last element
-  /// @sa https://json.nlohmann.me/api/basic_json/back/
-  reference back() {
-    auto tmp = end();
-    --tmp;
-    return *tmp;
-  }
-
-  /// @brief access the last element
-  /// @sa https://json.nlohmann.me/api/basic_json/back/
-  const_reference back() const {
-    auto tmp = cend();
-    --tmp;
-    return *tmp;
-  }
-
-  /// @brief remove element given an iterator
-  /// @sa https://json.nlohmann.me/api/basic_json/erase/
-  template <
-      class IteratorType,
-      detail::enable_if_t<
-          std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
-              std::is_same<IteratorType,
-                           typename basic_json_t::const_iterator>::value,
-          int> = 0>
-  IteratorType
-  erase(IteratorType pos) // NOLINT(performance-unnecessary-value-param)
-  {
-    // make sure iterator fits the current value
-    if (JSON_HEDLEY_UNLIKELY(this != pos.m_object)) {
-      JSON_THROW(invalid_iterator::create(
-          202, "iterator does not fit current value", this));
-    }
-
-    IteratorType result = end();
-
-    switch (m_data.m_type) {
-    case value_t::boolean:
-    case value_t::number_float:
-    case value_t::number_integer:
-    case value_t::number_unsigned:
-    case value_t::string:
-    case value_t::binary: {
-      if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin())) {
-        JSON_THROW(
-            invalid_iterator::create(205, "iterator out of range", this));
-      }
-
-      if (is_string()) {
-        AllocatorType<string_t> alloc;
-        std::allocator_traits<decltype(alloc)>::destroy(alloc,
-                                                        m_data.m_value.string);
-        std::allocator_traits<decltype(alloc)>::deallocate(
-            alloc, m_data.m_value.string, 1);
-        m_data.m_value.string = nullptr;
-      } else if (is_binary()) {
-        AllocatorType<binary_t> alloc;
-        std::allocator_traits<decltype(alloc)>::destroy(alloc,
-                                                        m_data.m_value.binary);
-        std::allocator_traits<decltype(alloc)>::deallocate(
-            alloc, m_data.m_value.binary, 1);
-        m_data.m_value.binary = nullptr;
-      }
-
-      m_data.m_type = value_t::null;
-      assert_invariant();
-      break;
-    }
-
-    case value_t::object: {
-      result.m_it.object_iterator =
-          m_data.m_value.object->erase(pos.m_it.object_iterator);
-      break;
-    }
-
-    case value_t::array: {
-      result.m_it.array_iterator =
-          m_data.m_value.array->erase(pos.m_it.array_iterator);
-      break;
-    }
-
-    case value_t::null:
-    case value_t::discarded:
-    default:
-      JSON_THROW(type_error::create(
-          307, detail::concat("cannot use erase() with ", type_name()), this));
-    }
-
-    return result;
-  }
-
-  /// @brief remove elements given an iterator range
-  /// @sa https://json.nlohmann.me/api/basic_json/erase/
-  template <
-      class IteratorType,
-      detail::enable_if_t<
-          std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
-              std::is_same<IteratorType,
-                           typename basic_json_t::const_iterator>::value,
-          int> = 0>
-  IteratorType
-  erase(IteratorType first,
-        IteratorType last) // NOLINT(performance-unnecessary-value-param)
-  {
-    // make sure iterator fits the current value
-    if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object)) {
-      JSON_THROW(invalid_iterator::create(
-          203, "iterators do not fit current value", this));
-    }
-
-    IteratorType result = end();
-
-    switch (m_data.m_type) {
-    case value_t::boolean:
-    case value_t::number_float:
-    case value_t::number_integer:
-    case value_t::number_unsigned:
-    case value_t::string:
-    case value_t::binary: {
-      if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin() ||
-                             !last.m_it.primitive_iterator.is_end())) {
-        JSON_THROW(
-            invalid_iterator::create(204, "iterators out of range", this));
-      }
-
-      if (is_string()) {
-        AllocatorType<string_t> alloc;
-        std::allocator_traits<decltype(alloc)>::destroy(alloc,
-                                                        m_data.m_value.string);
-        std::allocator_traits<decltype(alloc)>::deallocate(
-            alloc, m_data.m_value.string, 1);
-        m_data.m_value.string = nullptr;
-      } else if (is_binary()) {
-        AllocatorType<binary_t> alloc;
-        std::allocator_traits<decltype(alloc)>::destroy(alloc,
-                                                        m_data.m_value.binary);
-        std::allocator_traits<decltype(alloc)>::deallocate(
-            alloc, m_data.m_value.binary, 1);
-        m_data.m_value.binary = nullptr;
-      }
-
-      m_data.m_type = value_t::null;
-      assert_invariant();
-      break;
-    }
-
-    case value_t::object: {
-      result.m_it.object_iterator = m_data.m_value.object->erase(
-          first.m_it.object_iterator, last.m_it.object_iterator);
-      break;
-    }
-
-    case value_t::array: {
-      result.m_it.array_iterator = m_data.m_value.array->erase(
-          first.m_it.array_iterator, last.m_it.array_iterator);
-      break;
-    }
-
-    case value_t::null:
-    case value_t::discarded:
-    default:
-      JSON_THROW(type_error::create(
-          307, detail::concat("cannot use erase() with ", type_name()), this));
-    }
-
-    return result;
-  }
-
-private:
-  template <typename KeyType,
-            detail::enable_if_t<
-                detail::has_erase_with_key_type<basic_json_t, KeyType>::value,
-                int> = 0>
-  size_type erase_internal(KeyType &&key) {
-    // this erase only works for objects
-    if (JSON_HEDLEY_UNLIKELY(!is_object())) {
-      JSON_THROW(type_error::create(
-          307, detail::concat("cannot use erase() with ", type_name()), this));
-    }
-
-    return m_data.m_value.object->erase(std::forward<KeyType>(key));
-  }
-
-  template <typename KeyType,
-            detail::enable_if_t<
-                !detail::has_erase_with_key_type<basic_json_t, KeyType>::value,
-                int> = 0>
-  size_type erase_internal(KeyType &&key) {
-    // this erase only works for objects
-    if (JSON_HEDLEY_UNLIKELY(!is_object())) {
-      JSON_THROW(type_error::create(
-          307, detail::concat("cannot use erase() with ", type_name()), this));
-    }
-
-    const auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
-    if (it != m_data.m_value.object->end()) {
-      m_data.m_value.object->erase(it);
-      return 1;
-    }
-    return 0;
-  }
-
-public:
-  /// @brief remove element from a JSON object given a key
-  /// @sa https://json.nlohmann.me/api/basic_json/erase/
-  size_type erase(const typename object_t::key_type &key) {
-    // the indirection via erase_internal() is added to avoid making this
-    // function a template and thus de-rank it during overload resolution
-    return erase_internal(key);
-  }
-
-  /// @brief remove element from a JSON object given a key
-  /// @sa https://json.nlohmann.me/api/basic_json/erase/
-  template <class KeyType,
-            detail::enable_if_t<detail::is_usable_as_basic_json_key_type<
-                                    basic_json_t, KeyType>::value,
-                                int> = 0>
-  size_type erase(KeyType &&key) {
-    return erase_internal(std::forward<KeyType>(key));
-  }
-
-  /// @brief remove element from a JSON array given an index
-  /// @sa https://json.nlohmann.me/api/basic_json/erase/
-  void erase(const size_type idx) {
-    // this erase only works for arrays
-    if (JSON_HEDLEY_LIKELY(is_array())) {
-      if (JSON_HEDLEY_UNLIKELY(idx >= size())) {
-        JSON_THROW(out_of_range::create(401,
-                                        detail::concat("array index ",
-                                                       std::to_string(idx),
-                                                       " is out of range"),
-                                        this));
-      }
-
-      m_data.m_value.array->erase(m_data.m_value.array->begin() +
-                                  static_cast<difference_type>(idx));
-    } else {
-      JSON_THROW(type_error::create(
-          307, detail::concat("cannot use erase() with ", type_name()), this));
-    }
-  }
-
-  /// @}
-
-  ////////////
-  // lookup //
-  ////////////
-
-  /// @name lookup
-  /// @{
-
-  /// @brief find an element in a JSON object
-  /// @sa https://json.nlohmann.me/api/basic_json/find/
-  iterator find(const typename object_t::key_type &key) {
-    auto result = end();
-
-    if (is_object()) {
-      result.m_it.object_iterator = m_data.m_value.object->find(key);
-    }
-
-    return result;
-  }
-
-  /// @brief find an element in a JSON object
-  /// @sa https://json.nlohmann.me/api/basic_json/find/
-  const_iterator find(const typename object_t::key_type &key) const {
-    auto result = cend();
-
-    if (is_object()) {
-      result.m_it.object_iterator = m_data.m_value.object->find(key);
-    }
-
-    return result;
-  }
-
-  /// @brief find an element in a JSON object
-  /// @sa https://json.nlohmann.me/api/basic_json/find/
-  template <class KeyType,
-            detail::enable_if_t<detail::is_usable_as_basic_json_key_type<
-                                    basic_json_t, KeyType>::value,
-                                int> = 0>
-  iterator find(KeyType &&key) {
-    auto result = end();
-
-    if (is_object()) {
-      result.m_it.object_iterator =
-          m_data.m_value.object->find(std::forward<KeyType>(key));
-    }
-
-    return result;
-  }
-
-  /// @brief find an element in a JSON object
-  /// @sa https://json.nlohmann.me/api/basic_json/find/
-  template <class KeyType,
-            detail::enable_if_t<detail::is_usable_as_basic_json_key_type<
-                                    basic_json_t, KeyType>::value,
-                                int> = 0>
-  const_iterator find(KeyType &&key) const {
-    auto result = cend();
-
-    if (is_object()) {
-      result.m_it.object_iterator =
-          m_data.m_value.object->find(std::forward<KeyType>(key));
-    }
-
-    return result;
-  }
-
-  /// @brief returns the number of occurrences of a key in a JSON object
-  /// @sa https://json.nlohmann.me/api/basic_json/count/
-  size_type count(const typename object_t::key_type &key) const {
-    // return 0 for all nonobject types
-    return is_object() ? m_data.m_value.object->count(key) : 0;
-  }
-
-  /// @brief returns the number of occurrences of a key in a JSON object
-  /// @sa https://json.nlohmann.me/api/basic_json/count/
-  template <class KeyType,
-            detail::enable_if_t<detail::is_usable_as_basic_json_key_type<
-                                    basic_json_t, KeyType>::value,
-                                int> = 0>
-  size_type count(KeyType &&key) const {
-    // return 0 for all nonobject types
-    return is_object()
-               ? m_data.m_value.object->count(std::forward<KeyType>(key))
-               : 0;
-  }
-
-  /// @brief check the existence of an element in a JSON object
-  /// @sa https://json.nlohmann.me/api/basic_json/contains/
-  bool contains(const typename object_t::key_type &key) const {
-    return is_object() &&
-           m_data.m_value.object->find(key) != m_data.m_value.object->end();
-  }
-
-  /// @brief check the existence of an element in a JSON object
-  /// @sa https://json.nlohmann.me/api/basic_json/contains/
-  template <class KeyType,
-            detail::enable_if_t<detail::is_usable_as_basic_json_key_type<
-                                    basic_json_t, KeyType>::value,
-                                int> = 0>
-  bool contains(KeyType &&key) const {
-    return is_object() &&
-           m_data.m_value.object->find(std::forward<KeyType>(key)) !=
-               m_data.m_value.object->end();
-  }
-
-  /// @brief check the existence of an element in a JSON object given a JSON
-  /// pointer
-  /// @sa https://json.nlohmann.me/api/basic_json/contains/
-  bool contains(const json_pointer &ptr) const { return ptr.contains(this); }
-
-  template <
-      typename BasicJsonType,
-      detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
-  JSON_HEDLEY_DEPRECATED_FOR(
-      3.11.0, basic_json::json_pointer or
-                  nlohmann::json_pointer<
-                      basic_json::string_t>) // NOLINT(readability/alt_tokens)
-  bool contains(
-      const typename ::nlohmann::json_pointer<BasicJsonType> &ptr) const {
-    return ptr.contains(this);
-  }
-
-  /// @}
-
-  ///////////////
-  // iterators //
-  ///////////////
-
-  /// @name iterators
-  /// @{
-
-  /// @brief returns an iterator to the first element
-  /// @sa https://json.nlohmann.me/api/basic_json/begin/
-  iterator begin() noexcept {
-    iterator result(this);
-    result.set_begin();
-    return result;
-  }
-
-  /// @brief returns an iterator to the first element
-  /// @sa https://json.nlohmann.me/api/basic_json/begin/
-  const_iterator begin() const noexcept { return cbegin(); }
-
-  /// @brief returns a const iterator to the first element
-  /// @sa https://json.nlohmann.me/api/basic_json/cbegin/
-  const_iterator cbegin() const noexcept {
-    const_iterator result(this);
-    result.set_begin();
-    return result;
-  }
-
-  /// @brief returns an iterator to one past the last element
-  /// @sa https://json.nlohmann.me/api/basic_json/end/
-  iterator end() noexcept {
-    iterator result(this);
-    result.set_end();
-    return result;
-  }
-
-  /// @brief returns an iterator to one past the last element
-  /// @sa https://json.nlohmann.me/api/basic_json/end/
-  const_iterator end() const noexcept { return cend(); }
-
-  /// @brief returns an iterator to one past the last element
-  /// @sa https://json.nlohmann.me/api/basic_json/cend/
-  const_iterator cend() const noexcept {
-    const_iterator result(this);
-    result.set_end();
-    return result;
-  }
-
-  /// @brief returns an iterator to the reverse-beginning
-  /// @sa https://json.nlohmann.me/api/basic_json/rbegin/
-  reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
-
-  /// @brief returns an iterator to the reverse-beginning
-  /// @sa https://json.nlohmann.me/api/basic_json/rbegin/
-  const_reverse_iterator rbegin() const noexcept { return crbegin(); }
-
-  /// @brief returns an iterator to the reverse-end
-  /// @sa https://json.nlohmann.me/api/basic_json/rend/
-  reverse_iterator rend() noexcept { return reverse_iterator(begin()); }
-
-  /// @brief returns an iterator to the reverse-end
-  /// @sa https://json.nlohmann.me/api/basic_json/rend/
-  const_reverse_iterator rend() const noexcept { return crend(); }
-
-  /// @brief returns a const reverse iterator to the last element
-  /// @sa https://json.nlohmann.me/api/basic_json/crbegin/
-  const_reverse_iterator crbegin() const noexcept {
-    return const_reverse_iterator(cend());
-  }
-
-  /// @brief returns a const reverse iterator to one before the first
-  /// @sa https://json.nlohmann.me/api/basic_json/crend/
-  const_reverse_iterator crend() const noexcept {
-    return const_reverse_iterator(cbegin());
-  }
-
-public:
-  /// @brief wrapper to access iterator member functions in range-based for
-  /// @sa https://json.nlohmann.me/api/basic_json/items/
-  /// @deprecated This function is deprecated since 3.1.0 and will be removed in
-  ///             version 4.0.0 of the library. Please use @ref items() instead;
-  ///             that is, replace `json::iterator_wrapper(j)` with `j.items()`.
-  JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
-  static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept {
-    return ref.items();
-  }
-
-  /// @brief wrapper to access iterator member functions in range-based for
-  /// @sa https://json.nlohmann.me/api/basic_json/items/
-  /// @deprecated This function is deprecated since 3.1.0 and will be removed in
-  ///         version 4.0.0 of the library. Please use @ref items() instead;
-  ///         that is, replace `json::iterator_wrapper(j)` with `j.items()`.
-  JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
-  static iteration_proxy<const_iterator>
-  iterator_wrapper(const_reference ref) noexcept {
-    return ref.items();
-  }
-
-  /// @brief helper to access iterator member functions in range-based for
-  /// @sa https://json.nlohmann.me/api/basic_json/items/
-  iteration_proxy<iterator> items() noexcept {
-    return iteration_proxy<iterator>(*this);
-  }
-
-  /// @brief helper to access iterator member functions in range-based for
-  /// @sa https://json.nlohmann.me/api/basic_json/items/
-  iteration_proxy<const_iterator> items() const noexcept {
-    return iteration_proxy<const_iterator>(*this);
-  }
-
-  /// @}
-
-  //////////////
-  // capacity //
-  //////////////
-
-  /// @name capacity
-  /// @{
-
-  /// @brief checks whether the container is empty.
-  /// @sa https://json.nlohmann.me/api/basic_json/empty/
-  bool empty() const noexcept {
-    switch (m_data.m_type) {
-    case value_t::null: {
-      // null values are empty
-      return true;
-    }
-
-    case value_t::array: {
-      // delegate call to array_t::empty()
-      return m_data.m_value.array->empty();
-    }
-
-    case value_t::object: {
-      // delegate call to object_t::empty()
-      return m_data.m_value.object->empty();
-    }
-
-    case value_t::string:
-    case value_t::boolean:
-    case value_t::number_integer:
-    case value_t::number_unsigned:
-    case value_t::number_float:
-    case value_t::binary:
-    case value_t::discarded:
-    default: {
-      // all other types are nonempty
-      return false;
-    }
-    }
-  }
-
-  /// @brief returns the number of elements
-  /// @sa https://json.nlohmann.me/api/basic_json/size/
-  size_type size() const noexcept {
-    switch (m_data.m_type) {
-    case value_t::null: {
-      // null values are empty
-      return 0;
-    }
-
-    case value_t::array: {
-      // delegate call to array_t::size()
-      return m_data.m_value.array->size();
-    }
-
-    case value_t::object: {
-      // delegate call to object_t::size()
-      return m_data.m_value.object->size();
-    }
-
-    case value_t::string:
-    case value_t::boolean:
-    case value_t::number_integer:
-    case value_t::number_unsigned:
-    case value_t::number_float:
-    case value_t::binary:
-    case value_t::discarded:
-    default: {
-      // all other types have size 1
-      return 1;
-    }
-    }
-  }
-
-  /// @brief returns the maximum possible number of elements
-  /// @sa https://json.nlohmann.me/api/basic_json/max_size/
-  size_type max_size() const noexcept {
-    switch (m_data.m_type) {
-    case value_t::array: {
-      // delegate call to array_t::max_size()
-      return m_data.m_value.array->max_size();
-    }
-
-    case value_t::object: {
-      // delegate call to object_t::max_size()
-      return m_data.m_value.object->max_size();
-    }
-
-    case value_t::null:
-    case value_t::string:
-    case value_t::boolean:
-    case value_t::number_integer:
-    case value_t::number_unsigned:
-    case value_t::number_float:
-    case value_t::binary:
-    case value_t::discarded:
-    default: {
-      // all other types have max_size() == size()
-      return size();
-    }
-    }
-  }
-
-  /// @}
-
-  ///////////////
-  // modifiers //
-  ///////////////
-
-  /// @name modifiers
-  /// @{
-
-  /// @brief clears the contents
-  /// @sa https://json.nlohmann.me/api/basic_json/clear/
-  void clear() noexcept {
-    switch (m_data.m_type) {
-    case value_t::number_integer: {
-      m_data.m_value.number_integer = 0;
-      break;
-    }
-
-    case value_t::number_unsigned: {
-      m_data.m_value.number_unsigned = 0;
-      break;
-    }
-
-    case value_t::number_float: {
-      m_data.m_value.number_float = 0.0;
-      break;
-    }
-
-    case value_t::boolean: {
-      m_data.m_value.boolean = false;
-      break;
-    }
-
-    case value_t::string: {
-      m_data.m_value.string->clear();
-      break;
-    }
-
-    case value_t::binary: {
-      m_data.m_value.binary->clear();
-      break;
-    }
-
-    case value_t::array: {
-      m_data.m_value.array->clear();
-      break;
-    }
-
-    case value_t::object: {
-      m_data.m_value.object->clear();
-      break;
-    }
-
-    case value_t::null:
-    case value_t::discarded:
-    default:
-      break;
-    }
-  }
-
-  /// @brief add an object to an array
-  /// @sa https://json.nlohmann.me/api/basic_json/push_back/
-  void push_back(basic_json &&val) {
-    // push_back only works for null objects or arrays
-    if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array()))) {
-      JSON_THROW(type_error::create(
-          308, detail::concat("cannot use push_back() with ", type_name()),
-          this));
-    }
-
-    // transform null object into an array
-    if (is_null()) {
-      m_data.m_type = value_t::array;
-      m_data.m_value = value_t::array;
-      assert_invariant();
-    }
-
-    // add element to array (move semantics)
-    const auto old_capacity = m_data.m_value.array->capacity();
-    m_data.m_value.array->push_back(std::move(val));
-    set_parent(m_data.m_value.array->back(), old_capacity);
-    // if val is moved from, basic_json move constructor marks it null, so we do
-    // not call the destructor
-  }
-
-  /// @brief add an object to an array
-  /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
-  reference operator+=(basic_json &&val) {
-    push_back(std::move(val));
-    return *this;
-  }
-
-  /// @brief add an object to an array
-  /// @sa https://json.nlohmann.me/api/basic_json/push_back/
-  void push_back(const basic_json &val) {
-    // push_back only works for null objects or arrays
-    if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array()))) {
-      JSON_THROW(type_error::create(
-          308, detail::concat("cannot use push_back() with ", type_name()),
-          this));
-    }
-
-    // transform null object into an array
-    if (is_null()) {
-      m_data.m_type = value_t::array;
-      m_data.m_value = value_t::array;
-      assert_invariant();
-    }
-
-    // add element to array
-    const auto old_capacity = m_data.m_value.array->capacity();
-    m_data.m_value.array->push_back(val);
-    set_parent(m_data.m_value.array->back(), old_capacity);
-  }
-
-  /// @brief add an object to an array
-  /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
-  reference operator+=(const basic_json &val) {
-    push_back(val);
-    return *this;
-  }
-
-  /// @brief add an object to an object
-  /// @sa https://json.nlohmann.me/api/basic_json/push_back/
-  void push_back(const typename object_t::value_type &val) {
-    // push_back only works for null objects or objects
-    if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object()))) {
-      JSON_THROW(type_error::create(
-          308, detail::concat("cannot use push_back() with ", type_name()),
-          this));
-    }
-
-    // transform null object into an object
-    if (is_null()) {
-      m_data.m_type = value_t::object;
-      m_data.m_value = value_t::object;
-      assert_invariant();
-    }
-
-    // add element to object
-    auto res = m_data.m_value.object->insert(val);
-    set_parent(res.first->second);
-  }
-
-  /// @brief add an object to an object
-  /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
-  reference operator+=(const typename object_t::value_type &val) {
-    push_back(val);
-    return *this;
-  }
-
-  /// @brief add an object to an object
-  /// @sa https://json.nlohmann.me/api/basic_json/push_back/
-  void push_back(initializer_list_t init) {
-    if (is_object() && init.size() == 2 && (*init.begin())->is_string()) {
-      basic_json &&key = init.begin()->moved_or_copied();
-      push_back(
-          typename object_t::value_type(std::move(key.get_ref<string_t &>()),
-                                        (init.begin() + 1)->moved_or_copied()));
-    } else {
-      push_back(basic_json(init));
-    }
-  }
-
-  /// @brief add an object to an object
-  /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
-  reference operator+=(initializer_list_t init) {
-    push_back(init);
-    return *this;
-  }
-
-  /// @brief add an object to an array
-  /// @sa https://json.nlohmann.me/api/basic_json/emplace_back/
-  template <class... Args> reference emplace_back(Args &&...args) {
-    // emplace_back only works for null objects or arrays
-    if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array()))) {
-      JSON_THROW(type_error::create(
-          311, detail::concat("cannot use emplace_back() with ", type_name()),
-          this));
-    }
-
-    // transform null object into an array
-    if (is_null()) {
-      m_data.m_type = value_t::array;
-      m_data.m_value = value_t::array;
-      assert_invariant();
-    }
-
-    // add element to array (perfect forwarding)
-    const auto old_capacity = m_data.m_value.array->capacity();
-    m_data.m_value.array->emplace_back(std::forward<Args>(args)...);
-    return set_parent(m_data.m_value.array->back(), old_capacity);
-  }
-
-  /// @brief add an object to an object if key does not exist
-  /// @sa https://json.nlohmann.me/api/basic_json/emplace/
-  template <class... Args> std::pair<iterator, bool> emplace(Args &&...args) {
-    // emplace only works for null objects or arrays
-    if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object()))) {
-      JSON_THROW(type_error::create(
-          311, detail::concat("cannot use emplace() with ", type_name()),
-          this));
-    }
-
-    // transform null object into an object
-    if (is_null()) {
-      m_data.m_type = value_t::object;
-      m_data.m_value = value_t::object;
-      assert_invariant();
-    }
-
-    // add element to array (perfect forwarding)
-    auto res = m_data.m_value.object->emplace(std::forward<Args>(args)...);
-    set_parent(res.first->second);
-
-    // create result iterator and set iterator to the result of emplace
-    auto it = begin();
-    it.m_it.object_iterator = res.first;
-
-    // return pair of iterator and boolean
-    return {it, res.second};
-  }
-
-  /// Helper for insertion of an iterator
-  /// @note: This uses std::distance to support GCC 4.8,
-  ///        see https://github.com/nlohmann/json/pull/1257
-  template <typename... Args>
-  iterator
-  insert_iterator(const_iterator pos,
-                  Args &&...args) // NOLINT(performance-unnecessary-value-param)
-  {
-    iterator result(this);
-    JSON_ASSERT(m_data.m_value.array != nullptr);
-
-    auto insert_pos =
-        std::distance(m_data.m_value.array->begin(), pos.m_it.array_iterator);
-    m_data.m_value.array->insert(pos.m_it.array_iterator,
-                                 std::forward<Args>(args)...);
-    result.m_it.array_iterator = m_data.m_value.array->begin() + insert_pos;
-
-    // This could have been written as:
-    // result.m_it.array_iterator =
-    // m_data.m_value.array->insert(pos.m_it.array_iterator, cnt, val); but the
-    // return value of insert is missing in GCC 4.8, so it is written this way
-    // instead.
-
-    set_parents();
-    return result;
-  }
-
-  /// @brief inserts element into array
-  /// @sa https://json.nlohmann.me/api/basic_json/insert/
-  iterator
-  insert(const_iterator pos,
-         const basic_json &val) // NOLINT(performance-unnecessary-value-param)
-  {
-    // insert only works for arrays
-    if (JSON_HEDLEY_LIKELY(is_array())) {
-      // check if iterator pos fits to this JSON value
-      if (JSON_HEDLEY_UNLIKELY(pos.m_object != this)) {
-        JSON_THROW(invalid_iterator::create(
-            202, "iterator does not fit current value", this));
-      }
-
-      // insert to array and return iterator
-      return insert_iterator(pos, val);
-    }
-
-    JSON_THROW(type_error::create(
-        309, detail::concat("cannot use insert() with ", type_name()), this));
-  }
-
-  /// @brief inserts element into array
-  /// @sa https://json.nlohmann.me/api/basic_json/insert/
-  iterator
-  insert(const_iterator pos,
-         basic_json &&val) // NOLINT(performance-unnecessary-value-param)
-  {
-    return insert(pos, val);
-  }
-
-  /// @brief inserts copies of element into array
-  /// @sa https://json.nlohmann.me/api/basic_json/insert/
-  iterator
-  insert(const_iterator pos, size_type cnt,
-         const basic_json &val) // NOLINT(performance-unnecessary-value-param)
-  {
-    // insert only works for arrays
-    if (JSON_HEDLEY_LIKELY(is_array())) {
-      // check if iterator pos fits to this JSON value
-      if (JSON_HEDLEY_UNLIKELY(pos.m_object != this)) {
-        JSON_THROW(invalid_iterator::create(
-            202, "iterator does not fit current value", this));
-      }
-
-      // insert to array and return iterator
-      return insert_iterator(pos, cnt, val);
-    }
-
-    JSON_THROW(type_error::create(
-        309, detail::concat("cannot use insert() with ", type_name()), this));
-  }
-
-  /// @brief inserts range of elements into array
-  /// @sa https://json.nlohmann.me/api/basic_json/insert/
-  iterator
-  insert(const_iterator pos, const_iterator first,
-         const_iterator last) // NOLINT(performance-unnecessary-value-param)
-  {
-    // insert only works for arrays
-    if (JSON_HEDLEY_UNLIKELY(!is_array())) {
-      JSON_THROW(type_error::create(
-          309, detail::concat("cannot use insert() with ", type_name()), this));
-    }
-
-    // check if iterator pos fits to this JSON value
-    if (JSON_HEDLEY_UNLIKELY(pos.m_object != this)) {
-      JSON_THROW(invalid_iterator::create(
-          202, "iterator does not fit current value", this));
-    }
-
-    // check if range iterators belong to the same JSON object
-    if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object)) {
-      JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
-    }
-
-    if (JSON_HEDLEY_UNLIKELY(first.m_object == this)) {
-      JSON_THROW(invalid_iterator::create(
-          211, "passed iterators may not belong to container", this));
-    }
-
-    // insert to array and return iterator
-    return insert_iterator(pos, first.m_it.array_iterator,
-                           last.m_it.array_iterator);
-  }
-
-  /// @brief inserts elements from initializer list into array
-  /// @sa https://json.nlohmann.me/api/basic_json/insert/
-  iterator insert(
-      const_iterator pos,
-      initializer_list_t ilist) // NOLINT(performance-unnecessary-value-param)
-  {
-    // insert only works for arrays
-    if (JSON_HEDLEY_UNLIKELY(!is_array())) {
-      JSON_THROW(type_error::create(
-          309, detail::concat("cannot use insert() with ", type_name()), this));
-    }
-
-    // check if iterator pos fits to this JSON value
-    if (JSON_HEDLEY_UNLIKELY(pos.m_object != this)) {
-      JSON_THROW(invalid_iterator::create(
-          202, "iterator does not fit current value", this));
-    }
-
-    // insert to array and return iterator
-    return insert_iterator(pos, ilist.begin(), ilist.end());
-  }
-
-  /// @brief inserts range of elements into object
-  /// @sa https://json.nlohmann.me/api/basic_json/insert/
-  void
-  insert(const_iterator first,
-         const_iterator last) // NOLINT(performance-unnecessary-value-param)
-  {
-    // insert only works for objects
-    if (JSON_HEDLEY_UNLIKELY(!is_object())) {
-      JSON_THROW(type_error::create(
-          309, detail::concat("cannot use insert() with ", type_name()), this));
-    }
-
-    // check if range iterators belong to the same JSON object
-    if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object)) {
-      JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
-    }
-
-    // passed iterators must belong to objects
-    if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object())) {
-      JSON_THROW(invalid_iterator::create(
-          202, "iterators first and last must point to objects", this));
-    }
-
-    m_data.m_value.object->insert(first.m_it.object_iterator,
-                                  last.m_it.object_iterator);
-  }
-
-  /// @brief updates a JSON object from another object, overwriting existing
-  /// keys
-  /// @sa https://json.nlohmann.me/api/basic_json/update/
-  void update(const_reference j, bool merge_objects = false) {
-    update(j.begin(), j.end(), merge_objects);
-  }
-
-  /// @brief updates a JSON object from another object, overwriting existing
-  /// keys
-  /// @sa https://json.nlohmann.me/api/basic_json/update/
-  void update(
-      const_iterator first, const_iterator last,
-      bool merge_objects = false) // NOLINT(performance-unnecessary-value-param)
-  {
-    // implicitly convert null value to an empty object
-    if (is_null()) {
-      m_data.m_type = value_t::object;
-      m_data.m_value.object = create<object_t>();
-      assert_invariant();
-    }
-
-    if (JSON_HEDLEY_UNLIKELY(!is_object())) {
-      JSON_THROW(type_error::create(
-          312, detail::concat("cannot use update() with ", type_name()), this));
-    }
-
-    // check if range iterators belong to the same JSON object
-    if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object)) {
-      JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
-    }
-
-    // passed iterators must belong to objects
-    if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object())) {
-      JSON_THROW(type_error::create(312,
-                                    detail::concat("cannot use update() with ",
-                                                   first.m_object->type_name()),
-                                    first.m_object));
-    }
-
-    for (auto it = first; it != last; ++it) {
-      if (merge_objects && it.value().is_object()) {
-        auto it2 = m_data.m_value.object->find(it.key());
-        if (it2 != m_data.m_value.object->end()) {
-          it2->second.update(it.value(), true);
-          continue;
-        }
-      }
-      m_data.m_value.object->operator[](it.key()) = it.value();
-#if JSON_DIAGNOSTICS
-      m_data.m_value.object->operator[](it.key()).m_parent = this;
-#endif
-    }
-  }
-
-  /// @brief exchanges the values
-  /// @sa https://json.nlohmann.me/api/basic_json/swap/
-  void swap(reference other) noexcept(
-      std::is_nothrow_move_constructible<value_t>::value &&
-      std::is_nothrow_move_assignable<value_t>::value &&
-      std::is_nothrow_move_constructible<json_value>::
-          value && // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
-      std::is_nothrow_move_assignable<json_value>::value) {
-    std::swap(m_data.m_type, other.m_data.m_type);
-    std::swap(m_data.m_value, other.m_data.m_value);
-
-    set_parents();
-    other.set_parents();
-    assert_invariant();
-  }
-
-  /// @brief exchanges the values
-  /// @sa https://json.nlohmann.me/api/basic_json/swap/
-  friend void swap(reference left, reference right) noexcept(
-      std::is_nothrow_move_constructible<value_t>::value &&
-      std::is_nothrow_move_assignable<value_t>::value &&
-      std::is_nothrow_move_constructible<json_value>::
-          value && // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
-      std::is_nothrow_move_assignable<json_value>::value) {
-    left.swap(right);
-  }
-
-  /// @brief exchanges the values
-  /// @sa https://json.nlohmann.me/api/basic_json/swap/
-  void swap(
-      array_t &
-          other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
-  {
-    // swap only works for arrays
-    if (JSON_HEDLEY_LIKELY(is_array())) {
-      using std::swap;
-      swap(*(m_data.m_value.array), other);
-    } else {
-      JSON_THROW(type_error::create(
-          310, detail::concat("cannot use swap(array_t&) with ", type_name()),
-          this));
-    }
-  }
-
-  /// @brief exchanges the values
-  /// @sa https://json.nlohmann.me/api/basic_json/swap/
-  void swap(
-      object_t &
-          other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
-  {
-    // swap only works for objects
-    if (JSON_HEDLEY_LIKELY(is_object())) {
-      using std::swap;
-      swap(*(m_data.m_value.object), other);
-    } else {
-      JSON_THROW(type_error::create(
-          310, detail::concat("cannot use swap(object_t&) with ", type_name()),
-          this));
-    }
-  }
-
-  /// @brief exchanges the values
-  /// @sa https://json.nlohmann.me/api/basic_json/swap/
-  void swap(
-      string_t &
-          other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
-  {
-    // swap only works for strings
-    if (JSON_HEDLEY_LIKELY(is_string())) {
-      using std::swap;
-      swap(*(m_data.m_value.string), other);
-    } else {
-      JSON_THROW(type_error::create(
-          310, detail::concat("cannot use swap(string_t&) with ", type_name()),
-          this));
-    }
-  }
-
-  /// @brief exchanges the values
-  /// @sa https://json.nlohmann.me/api/basic_json/swap/
-  void swap(
-      binary_t &
-          other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
-  {
-    // swap only works for strings
-    if (JSON_HEDLEY_LIKELY(is_binary())) {
-      using std::swap;
-      swap(*(m_data.m_value.binary), other);
-    } else {
-      JSON_THROW(type_error::create(
-          310, detail::concat("cannot use swap(binary_t&) with ", type_name()),
-          this));
-    }
-  }
-
-  /// @brief exchanges the values
-  /// @sa https://json.nlohmann.me/api/basic_json/swap/
-  void swap(typename binary_t::container_type
-                &other) // NOLINT(bugprone-exception-escape)
-  {
-    // swap only works for strings
-    if (JSON_HEDLEY_LIKELY(is_binary())) {
-      using std::swap;
-      swap(*(m_data.m_value.binary), other);
-    } else {
-      JSON_THROW(type_error::create(
-          310,
-          detail::concat("cannot use swap(binary_t::container_type&) with ",
-                         type_name()),
-          this));
-    }
-  }
-
-  /// @}
-
-  //////////////////////////////////////////
-  // lexicographical comparison operators //
-  //////////////////////////////////////////
-
-  /// @name lexicographical comparison operators
-  /// @{
-
-  // note parentheses around operands are necessary; see
-  // https://github.com/nlohmann/json/issues/1530
-#define JSON_IMPLEMENT_OPERATOR(op, null_result, unordered_result,             \
-                                default_result)                                \
-  const auto lhs_type = lhs.type();                                            \
-  const auto rhs_type = rhs.type();                                            \
-                                                                               \
-  if (lhs_type == rhs_type) /* NOLINT(readability/braces) */                   \
-  {                                                                            \
-    switch (lhs_type) {                                                        \
-    case value_t::array:                                                       \
-      return (*lhs.m_data.m_value.array)op(*rhs.m_data.m_value.array);         \
-                                                                               \
-    case value_t::object:                                                      \
-      return (*lhs.m_data.m_value.object)op(*rhs.m_data.m_value.object);       \
-                                                                               \
-    case value_t::null:                                                        \
-      return (null_result);                                                    \
-                                                                               \
-    case value_t::string:                                                      \
-      return (*lhs.m_data.m_value.string)op(*rhs.m_data.m_value.string);       \
-                                                                               \
-    case value_t::boolean:                                                     \
-      return (lhs.m_data.m_value.boolean)op(rhs.m_data.m_value.boolean);       \
-                                                                               \
-    case value_t::number_integer:                                              \
-      return (lhs.m_data.m_value.number_integer)op(                            \
-          rhs.m_data.m_value.number_integer);                                  \
-                                                                               \
-    case value_t::number_unsigned:                                             \
-      return (lhs.m_data.m_value.number_unsigned)op(                           \
-          rhs.m_data.m_value.number_unsigned);                                 \
-                                                                               \
-    case value_t::number_float:                                                \
-      return (lhs.m_data.m_value.number_float)op(                              \
-          rhs.m_data.m_value.number_float);                                    \
-                                                                               \
-    case value_t::binary:                                                      \
-      return (*lhs.m_data.m_value.binary)op(*rhs.m_data.m_value.binary);       \
-                                                                               \
-    case value_t::discarded:                                                   \
-    default:                                                                   \
-      return (unordered_result);                                               \
-    }                                                                          \
-  } else if (lhs_type == value_t::number_integer &&                            \
-             rhs_type == value_t::number_float) {                              \
-    return static_cast<number_float_t>(lhs.m_data.m_value.number_integer)      \
-        op rhs.m_data.m_value.number_float;                                    \
-  } else if (lhs_type == value_t::number_float &&                              \
-             rhs_type == value_t::number_integer) {                            \
-    return lhs.m_data.m_value.number_float op static_cast<number_float_t>(     \
-        rhs.m_data.m_value.number_integer);                                    \
-  } else if (lhs_type == value_t::number_unsigned &&                           \
-             rhs_type == value_t::number_float) {                              \
-    return static_cast<number_float_t>(lhs.m_data.m_value.number_unsigned)     \
-        op rhs.m_data.m_value.number_float;                                    \
-  } else if (lhs_type == value_t::number_float &&                              \
-             rhs_type == value_t::number_unsigned) {                           \
-    return lhs.m_data.m_value.number_float op static_cast<number_float_t>(     \
-        rhs.m_data.m_value.number_unsigned);                                   \
-  } else if (lhs_type == value_t::number_unsigned &&                           \
-             rhs_type == value_t::number_integer) {                            \
-    return static_cast<number_integer_t>(lhs.m_data.m_value.number_unsigned)   \
-        op rhs.m_data.m_value.number_integer;                                  \
-  } else if (lhs_type == value_t::number_integer &&                            \
-             rhs_type == value_t::number_unsigned) {                           \
-    return lhs.m_data.m_value.number_integer op static_cast<number_integer_t>( \
-        rhs.m_data.m_value.number_unsigned);                                   \
-  } else if (compares_unordered(lhs, rhs)) {                                   \
-    return (unordered_result);                                                 \
-  }                                                                            \
-                                                                               \
-  return (default_result);
-
-  JSON_PRIVATE_UNLESS_TESTED :
-      // returns true if:
-      // - any operand is NaN and the other operand is of number type
-      // - any operand is discarded
-      // in legacy mode, discarded values are considered ordered if
-      // an operation is computed as an odd number of inverses of others
-      static bool compares_unordered(const_reference lhs, const_reference rhs,
-                                     bool inverse = false) noexcept {
-    if ((lhs.is_number_float() && std::isnan(lhs.m_data.m_value.number_float) &&
-         rhs.is_number()) ||
-        (rhs.is_number_float() && std::isnan(rhs.m_data.m_value.number_float) &&
-         lhs.is_number())) {
-      return true;
-    }
-#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
-    return (lhs.is_discarded() || rhs.is_discarded()) && !inverse;
-#else
-    static_cast<void>(inverse);
-    return lhs.is_discarded() || rhs.is_discarded();
-#endif
-  }
-
-private:
-  bool compares_unordered(const_reference rhs,
-                          bool inverse = false) const noexcept {
-    return compares_unordered(*this, rhs, inverse);
-  }
-
-public:
-#if JSON_HAS_THREE_WAY_COMPARISON
-  /// @brief comparison: equal
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
-  bool operator==(const_reference rhs) const noexcept {
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-    const_reference lhs = *this;
-    JSON_IMPLEMENT_OPERATOR(==, true, false, false)
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-  }
-
-  /// @brief comparison: equal
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
-  template <typename ScalarType>
-    requires std::is_scalar_v<ScalarType>
-  bool operator==(ScalarType rhs) const noexcept {
-    return *this == basic_json(rhs);
-  }
-
-  /// @brief comparison: not equal
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
-  bool operator!=(const_reference rhs) const noexcept {
-    if (compares_unordered(rhs, true)) {
-      return false;
-    }
-    return !operator==(rhs);
-  }
-
-  /// @brief comparison: 3-way
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_spaceship/
-  std::partial_ordering
-  operator<=>(const_reference rhs) const noexcept // *NOPAD*
-  {
-    const_reference lhs = *this;
-    // default_result is used if we cannot compare values. In that case,
-    // we compare types.
-    JSON_IMPLEMENT_OPERATOR(<=>, // *NOPAD*
-                            std::partial_ordering::equivalent,
-                            std::partial_ordering::unordered,
-                            lhs_type <=> rhs_type) // *NOPAD*
-  }
-
-  /// @brief comparison: 3-way
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_spaceship/
-  template <typename ScalarType>
-    requires std::is_scalar_v<ScalarType>
-  std::partial_ordering operator<=>(ScalarType rhs) const noexcept // *NOPAD*
-  {
-    return *this <=> basic_json(rhs); // *NOPAD*
-  }
-
-#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
-  // all operators that are computed as an odd number of inverses of others
-  // need to be overloaded to emulate the legacy comparison behavior
-
-  /// @brief comparison: less than or equal
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
-  JSON_HEDLEY_DEPRECATED_FOR(3.11.0,
-                             undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON)
-  bool operator<=(const_reference rhs) const noexcept {
-    if (compares_unordered(rhs, true)) {
-      return false;
-    }
-    return !(rhs < *this);
-  }
-
-  /// @brief comparison: less than or equal
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
-  template <typename ScalarType>
-    requires std::is_scalar_v<ScalarType>
-  bool operator<=(ScalarType rhs) const noexcept {
-    return *this <= basic_json(rhs);
-  }
-
-  /// @brief comparison: greater than or equal
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
-  JSON_HEDLEY_DEPRECATED_FOR(3.11.0,
-                             undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON)
-  bool operator>=(const_reference rhs) const noexcept {
-    if (compares_unordered(rhs, true)) {
-      return false;
-    }
-    return !(*this < rhs);
-  }
-
-  /// @brief comparison: greater than or equal
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
-  template <typename ScalarType>
-    requires std::is_scalar_v<ScalarType>
-  bool operator>=(ScalarType rhs) const noexcept {
-    return *this >= basic_json(rhs);
-  }
-#endif
-#else
-  /// @brief comparison: equal
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
-  friend bool operator==(const_reference lhs, const_reference rhs) noexcept {
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-    JSON_IMPLEMENT_OPERATOR(==, true, false, false)
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-  }
-
-  /// @brief comparison: equal
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
-  template <
-      typename ScalarType,
-      typename std::enable_if<std::is_scalar<ScalarType>::value, int>::type = 0>
-  friend bool operator==(const_reference lhs, ScalarType rhs) noexcept {
-    return lhs == basic_json(rhs);
-  }
-
-  /// @brief comparison: equal
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
-  template <
-      typename ScalarType,
-      typename std::enable_if<std::is_scalar<ScalarType>::value, int>::type = 0>
-  friend bool operator==(ScalarType lhs, const_reference rhs) noexcept {
-    return basic_json(lhs) == rhs;
-  }
-
-  /// @brief comparison: not equal
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
-  friend bool operator!=(const_reference lhs, const_reference rhs) noexcept {
-    if (compares_unordered(lhs, rhs, true)) {
-      return false;
-    }
-    return !(lhs == rhs);
-  }
-
-  /// @brief comparison: not equal
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
-  template <
-      typename ScalarType,
-      typename std::enable_if<std::is_scalar<ScalarType>::value, int>::type = 0>
-  friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept {
-    return lhs != basic_json(rhs);
-  }
-
-  /// @brief comparison: not equal
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
-  template <
-      typename ScalarType,
-      typename std::enable_if<std::is_scalar<ScalarType>::value, int>::type = 0>
-  friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept {
-    return basic_json(lhs) != rhs;
-  }
-
-  /// @brief comparison: less than
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
-  friend bool operator<(const_reference lhs, const_reference rhs) noexcept {
-    // default_result is used if we cannot compare values. In that case,
-    // we compare types. Note we have to call the operator explicitly,
-    // because MSVC has problems otherwise.
-    JSON_IMPLEMENT_OPERATOR(<, false, false, operator<(lhs_type, rhs_type))
-  }
-
-  /// @brief comparison: less than
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
-  template <
-      typename ScalarType,
-      typename std::enable_if<std::is_scalar<ScalarType>::value, int>::type = 0>
-  friend bool operator<(const_reference lhs, ScalarType rhs) noexcept {
-    return lhs < basic_json(rhs);
-  }
-
-  /// @brief comparison: less than
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
-  template <
-      typename ScalarType,
-      typename std::enable_if<std::is_scalar<ScalarType>::value, int>::type = 0>
-  friend bool operator<(ScalarType lhs, const_reference rhs) noexcept {
-    return basic_json(lhs) < rhs;
-  }
-
-  /// @brief comparison: less than or equal
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
-  friend bool operator<=(const_reference lhs, const_reference rhs) noexcept {
-    if (compares_unordered(lhs, rhs, true)) {
-      return false;
-    }
-    return !(rhs < lhs);
-  }
-
-  /// @brief comparison: less than or equal
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
-  template <
-      typename ScalarType,
-      typename std::enable_if<std::is_scalar<ScalarType>::value, int>::type = 0>
-  friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept {
-    return lhs <= basic_json(rhs);
-  }
-
-  /// @brief comparison: less than or equal
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
-  template <
-      typename ScalarType,
-      typename std::enable_if<std::is_scalar<ScalarType>::value, int>::type = 0>
-  friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept {
-    return basic_json(lhs) <= rhs;
-  }
-
-  /// @brief comparison: greater than
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
-  friend bool operator>(const_reference lhs, const_reference rhs) noexcept {
-    // double inverse
-    if (compares_unordered(lhs, rhs)) {
-      return false;
-    }
-    return !(lhs <= rhs);
-  }
-
-  /// @brief comparison: greater than
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
-  template <
-      typename ScalarType,
-      typename std::enable_if<std::is_scalar<ScalarType>::value, int>::type = 0>
-  friend bool operator>(const_reference lhs, ScalarType rhs) noexcept {
-    return lhs > basic_json(rhs);
-  }
-
-  /// @brief comparison: greater than
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
-  template <
-      typename ScalarType,
-      typename std::enable_if<std::is_scalar<ScalarType>::value, int>::type = 0>
-  friend bool operator>(ScalarType lhs, const_reference rhs) noexcept {
-    return basic_json(lhs) > rhs;
-  }
-
-  /// @brief comparison: greater than or equal
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
-  friend bool operator>=(const_reference lhs, const_reference rhs) noexcept {
-    if (compares_unordered(lhs, rhs, true)) {
-      return false;
-    }
-    return !(lhs < rhs);
-  }
-
-  /// @brief comparison: greater than or equal
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
-  template <
-      typename ScalarType,
-      typename std::enable_if<std::is_scalar<ScalarType>::value, int>::type = 0>
-  friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept {
-    return lhs >= basic_json(rhs);
-  }
-
-  /// @brief comparison: greater than or equal
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
-  template <
-      typename ScalarType,
-      typename std::enable_if<std::is_scalar<ScalarType>::value, int>::type = 0>
-  friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept {
-    return basic_json(lhs) >= rhs;
-  }
-#endif
-
-#undef JSON_IMPLEMENT_OPERATOR
-
-  /// @}
-
-  ///////////////////
-  // serialization //
-  ///////////////////
-
-  /// @name serialization
-  /// @{
-#ifndef JSON_NO_IO
-  /// @brief serialize to stream
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
-  friend std::ostream &operator<<(std::ostream &o, const basic_json &j) {
-    // read width member and use it as indentation parameter if nonzero
-    const bool pretty_print = o.width() > 0;
-    const auto indentation = pretty_print ? o.width() : 0;
-
-    // reset width to 0 for subsequent calls to this stream
-    o.width(0);
-
-    // do the actual serialization
-    serializer s(detail::output_adapter<char>(o), o.fill());
-    s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
-    return o;
-  }
-
-  /// @brief serialize to stream
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
-  /// @deprecated This function is deprecated since 3.0.0 and will be removed in
-  ///             version 4.0.0 of the library. Please use
-  ///             operator<<(std::ostream&, const basic_json&) instead; that is,
-  ///             replace calls like `j >> o;` with `o << j;`.
-  JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream &,
-                                               const basic_json &))
-  friend std::ostream &operator>>(const basic_json &j, std::ostream &o) {
-    return o << j;
-  }
-#endif // JSON_NO_IO
-  /// @}
-
-  /////////////////////
-  // deserialization //
-  /////////////////////
-
-  /// @name deserialization
-  /// @{
-
-  /// @brief deserialize from a compatible input
-  /// @sa https://json.nlohmann.me/api/basic_json/parse/
-  template <typename InputType>
-  JSON_HEDLEY_WARN_UNUSED_RESULT static basic_json
-  parse(InputType &&i, parser_callback_t cb = nullptr,
-        const bool allow_exceptions = true,
-        const bool ignore_comments = false) {
-    basic_json result;
-    parser(detail::input_adapter(std::forward<InputType>(i)), std::move(cb),
-           allow_exceptions, ignore_comments)
-        .parse(true, result);
-    return result;
-  }
-
-  /// @brief deserialize from a pair of character iterators
-  /// @sa https://json.nlohmann.me/api/basic_json/parse/
-  template <typename IteratorType>
-  JSON_HEDLEY_WARN_UNUSED_RESULT static basic_json
-  parse(IteratorType first, IteratorType last, parser_callback_t cb = nullptr,
-        const bool allow_exceptions = true,
-        const bool ignore_comments = false) {
-    basic_json result;
-    parser(detail::input_adapter(std::move(first), std::move(last)),
-           std::move(cb), allow_exceptions, ignore_comments)
-        .parse(true, result);
-    return result;
-  }
-
-  JSON_HEDLEY_WARN_UNUSED_RESULT
-  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr + len))
-  static basic_json parse(detail::span_input_adapter &&i,
-                          parser_callback_t cb = nullptr,
-                          const bool allow_exceptions = true,
-                          const bool ignore_comments = false) {
-    basic_json result;
-    parser(i.get(), std::move(cb), allow_exceptions, ignore_comments)
-        .parse(true, result);
-    return result;
-  }
-
-  /// @brief check if the input is valid JSON
-  /// @sa https://json.nlohmann.me/api/basic_json/accept/
-  template <typename InputType>
-  static bool accept(InputType &&i, const bool ignore_comments = false) {
-    return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr,
-                  false, ignore_comments)
-        .accept(true);
-  }
-
-  /// @brief check if the input is valid JSON
-  /// @sa https://json.nlohmann.me/api/basic_json/accept/
-  template <typename IteratorType>
-  static bool accept(IteratorType first, IteratorType last,
-                     const bool ignore_comments = false) {
-    return parser(detail::input_adapter(std::move(first), std::move(last)),
-                  nullptr, false, ignore_comments)
-        .accept(true);
-  }
-
-  JSON_HEDLEY_WARN_UNUSED_RESULT
-  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr + len))
-  static bool accept(detail::span_input_adapter &&i,
-                     const bool ignore_comments = false) {
-    return parser(i.get(), nullptr, false, ignore_comments).accept(true);
-  }
-
-  /// @brief generate SAX events
-  /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
-  template <typename InputType, typename SAX>
-  JSON_HEDLEY_NON_NULL(2)
-  static bool sax_parse(InputType &&i, SAX *sax,
-                        input_format_t format = input_format_t::json,
-                        const bool strict = true,
-                        const bool ignore_comments = false) {
-    auto ia = detail::input_adapter(std::forward<InputType>(i));
-    return format == input_format_t::json
-               ? parser(std::move(ia), nullptr, true, ignore_comments)
-                     .sax_parse(sax, strict)
-               : detail::binary_reader<basic_json, decltype(ia), SAX>(
-                     std::move(ia), format)
-                     .sax_parse(format, sax, strict);
-  }
-
-  /// @brief generate SAX events
-  /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
-  template <class IteratorType, class SAX>
-  JSON_HEDLEY_NON_NULL(3)
-  static bool sax_parse(IteratorType first, IteratorType last, SAX *sax,
-                        input_format_t format = input_format_t::json,
-                        const bool strict = true,
-                        const bool ignore_comments = false) {
-    auto ia = detail::input_adapter(std::move(first), std::move(last));
-    return format == input_format_t::json
-               ? parser(std::move(ia), nullptr, true, ignore_comments)
-                     .sax_parse(sax, strict)
-               : detail::binary_reader<basic_json, decltype(ia), SAX>(
-                     std::move(ia), format)
-                     .sax_parse(format, sax, strict);
-  }
-
-  /// @brief generate SAX events
-  /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
-  /// @deprecated This function is deprecated since 3.8.0 and will be removed in
-  ///             version 4.0.0 of the library. Please use
-  ///             sax_parse(ptr, ptr + len) instead.
-  template <typename SAX>
-  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, sax_parse(ptr, ptr + len, ...))
-  JSON_HEDLEY_NON_NULL(2) static bool sax_parse(
-      detail::span_input_adapter &&i, SAX *sax,
-      input_format_t format = input_format_t::json, const bool strict = true,
-      const bool ignore_comments = false) {
-    auto ia = i.get();
-    return format == input_format_t::json
-               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
-               ? parser(std::move(ia), nullptr, true, ignore_comments)
-                     .sax_parse(sax, strict)
-               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
-               : detail::binary_reader<basic_json, decltype(ia), SAX>(
-                     std::move(ia), format)
-                     .sax_parse(format, sax, strict);
-  }
-#ifndef JSON_NO_IO
-  /// @brief deserialize from stream
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
-  /// @deprecated This stream operator is deprecated since 3.0.0 and will be
-  /// removed in
-  ///             version 4.0.0 of the library. Please use
-  ///             operator>>(std::istream&, basic_json&) instead; that is,
-  ///             replace calls like `j << i;` with `i >> j;`.
-  JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream &, basic_json &))
-  friend std::istream &operator<<(basic_json &j, std::istream &i) {
-    return operator>>(i, j);
-  }
-
-  /// @brief deserialize from stream
-  /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
-  friend std::istream &operator>>(std::istream &i, basic_json &j) {
-    parser(detail::input_adapter(i)).parse(false, j);
-    return i;
-  }
-#endif // JSON_NO_IO
-  /// @}
-
-  ///////////////////////////
-  // convenience functions //
-  ///////////////////////////
-
-  /// @brief return the type as string
-  /// @sa https://json.nlohmann.me/api/basic_json/type_name/
-  JSON_HEDLEY_RETURNS_NON_NULL
-  const char *type_name() const noexcept {
-    switch (m_data.m_type) {
-    case value_t::null:
-      return "null";
-    case value_t::object:
-      return "object";
-    case value_t::array:
-      return "array";
-    case value_t::string:
-      return "string";
-    case value_t::boolean:
-      return "boolean";
-    case value_t::binary:
-      return "binary";
-    case value_t::discarded:
-      return "discarded";
-    case value_t::number_integer:
-    case value_t::number_unsigned:
-    case value_t::number_float:
-    default:
-      return "number";
-    }
-  }
-
-  JSON_PRIVATE_UNLESS_TESTED :
-      //////////////////////
-      // member variables //
-      //////////////////////
-
-      struct data {
-    /// the type of the current element
-    value_t m_type = value_t::null;
-
-    /// the value of the current element
-    json_value m_value = {};
-
-    data(const value_t v) : m_type(v), m_value(v) {}
-
-    data(size_type cnt, const basic_json &val) : m_type(value_t::array) {
-      m_value.array = create<array_t>(cnt, val);
-    }
-
-    data() noexcept = default;
-    data(data &&) noexcept = default;
-    data(const data &) noexcept = delete;
-    data &operator=(data &&) noexcept = delete;
-    data &operator=(const data &) noexcept = delete;
-
-    ~data() noexcept { m_value.destroy(m_type); }
-  };
-
-  data m_data = {};
-
-#if JSON_DIAGNOSTICS
-  /// a pointer to a parent value (for debugging purposes)
-  basic_json *m_parent = nullptr;
-#endif
-
-  //////////////////////////////////////////
-  // binary serialization/deserialization //
-  //////////////////////////////////////////
-
-  /// @name binary serialization/deserialization support
-  /// @{
-
-public:
-  /// @brief create a CBOR serialization of a given JSON value
-  /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
-  static std::vector<std::uint8_t> to_cbor(const basic_json &j) {
-    std::vector<std::uint8_t> result;
-    to_cbor(j, result);
-    return result;
-  }
-
-  /// @brief create a CBOR serialization of a given JSON value
-  /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
-  static void to_cbor(const basic_json &j,
-                      detail::output_adapter<std::uint8_t> o) {
-    binary_writer<std::uint8_t>(o).write_cbor(j);
-  }
-
-  /// @brief create a CBOR serialization of a given JSON value
-  /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
-  static void to_cbor(const basic_json &j, detail::output_adapter<char> o) {
-    binary_writer<char>(o).write_cbor(j);
-  }
-
-  /// @brief create a MessagePack serialization of a given JSON value
-  /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
-  static std::vector<std::uint8_t> to_msgpack(const basic_json &j) {
-    std::vector<std::uint8_t> result;
-    to_msgpack(j, result);
-    return result;
-  }
-
-  /// @brief create a MessagePack serialization of a given JSON value
-  /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
-  static void to_msgpack(const basic_json &j,
-                         detail::output_adapter<std::uint8_t> o) {
-    binary_writer<std::uint8_t>(o).write_msgpack(j);
-  }
-
-  /// @brief create a MessagePack serialization of a given JSON value
-  /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
-  static void to_msgpack(const basic_json &j, detail::output_adapter<char> o) {
-    binary_writer<char>(o).write_msgpack(j);
-  }
-
-  /// @brief create a UBJSON serialization of a given JSON value
-  /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
-  static std::vector<std::uint8_t> to_ubjson(const basic_json &j,
-                                             const bool use_size = false,
-                                             const bool use_type = false) {
-    std::vector<std::uint8_t> result;
-    to_ubjson(j, result, use_size, use_type);
-    return result;
-  }
-
-  /// @brief create a UBJSON serialization of a given JSON value
-  /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
-  static void to_ubjson(const basic_json &j,
-                        detail::output_adapter<std::uint8_t> o,
-                        const bool use_size = false,
-                        const bool use_type = false) {
-    binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type);
-  }
-
-  /// @brief create a UBJSON serialization of a given JSON value
-  /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
-  static void to_ubjson(const basic_json &j, detail::output_adapter<char> o,
-                        const bool use_size = false,
-                        const bool use_type = false) {
-    binary_writer<char>(o).write_ubjson(j, use_size, use_type);
-  }
-
-  /// @brief create a BJData serialization of a given JSON value
-  /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
-  static std::vector<std::uint8_t> to_bjdata(const basic_json &j,
-                                             const bool use_size = false,
-                                             const bool use_type = false) {
-    std::vector<std::uint8_t> result;
-    to_bjdata(j, result, use_size, use_type);
-    return result;
-  }
-
-  /// @brief create a BJData serialization of a given JSON value
-  /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
-  static void to_bjdata(const basic_json &j,
-                        detail::output_adapter<std::uint8_t> o,
-                        const bool use_size = false,
-                        const bool use_type = false) {
-    binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type, true,
-                                                true);
-  }
-
-  /// @brief create a BJData serialization of a given JSON value
-  /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
-  static void to_bjdata(const basic_json &j, detail::output_adapter<char> o,
-                        const bool use_size = false,
-                        const bool use_type = false) {
-    binary_writer<char>(o).write_ubjson(j, use_size, use_type, true, true);
-  }
-
-  /// @brief create a BSON serialization of a given JSON value
-  /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
-  static std::vector<std::uint8_t> to_bson(const basic_json &j) {
-    std::vector<std::uint8_t> result;
-    to_bson(j, result);
-    return result;
-  }
-
-  /// @brief create a BSON serialization of a given JSON value
-  /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
-  static void to_bson(const basic_json &j,
-                      detail::output_adapter<std::uint8_t> o) {
-    binary_writer<std::uint8_t>(o).write_bson(j);
-  }
-
-  /// @brief create a BSON serialization of a given JSON value
-  /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
-  static void to_bson(const basic_json &j, detail::output_adapter<char> o) {
-    binary_writer<char>(o).write_bson(j);
-  }
-
-  /// @brief create a JSON value from an input in CBOR format
-  /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
-  template <typename InputType>
-  JSON_HEDLEY_WARN_UNUSED_RESULT static basic_json
-  from_cbor(InputType &&i, const bool strict = true,
-            const bool allow_exceptions = true,
-            const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error) {
-    basic_json result;
-    detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-    auto ia = detail::input_adapter(std::forward<InputType>(i));
-    const bool res =
-        binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor)
-            .sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
-    return res ? result : basic_json(value_t::discarded);
-  }
-
-  /// @brief create a JSON value from an input in CBOR format
-  /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
-  template <typename IteratorType>
-  JSON_HEDLEY_WARN_UNUSED_RESULT static basic_json
-  from_cbor(IteratorType first, IteratorType last, const bool strict = true,
-            const bool allow_exceptions = true,
-            const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error) {
-    basic_json result;
-    detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-    auto ia = detail::input_adapter(std::move(first), std::move(last));
-    const bool res =
-        binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor)
-            .sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
-    return res ? result : basic_json(value_t::discarded);
-  }
-
-  template <typename T>
-  JSON_HEDLEY_WARN_UNUSED_RESULT
-  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len)) static basic_json
-      from_cbor(
-          const T *ptr, std::size_t len, const bool strict = true,
-          const bool allow_exceptions = true,
-          const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error) {
-    return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
-  }
-
-  JSON_HEDLEY_WARN_UNUSED_RESULT
-  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
-  static basic_json
-  from_cbor(detail::span_input_adapter &&i, const bool strict = true,
-            const bool allow_exceptions = true,
-            const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error) {
-    basic_json result;
-    detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-    auto ia = i.get();
-    // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
-    const bool res =
-        binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor)
-            .sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
-    return res ? result : basic_json(value_t::discarded);
-  }
-
-  /// @brief create a JSON value from an input in MessagePack format
-  /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
-  template <typename InputType>
-  JSON_HEDLEY_WARN_UNUSED_RESULT static basic_json
-  from_msgpack(InputType &&i, const bool strict = true,
-               const bool allow_exceptions = true) {
-    basic_json result;
-    detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-    auto ia = detail::input_adapter(std::forward<InputType>(i));
-    const bool res =
-        binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack)
-            .sax_parse(input_format_t::msgpack, &sdp, strict);
-    return res ? result : basic_json(value_t::discarded);
-  }
-
-  /// @brief create a JSON value from an input in MessagePack format
-  /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
-  template <typename IteratorType>
-  JSON_HEDLEY_WARN_UNUSED_RESULT static basic_json
-  from_msgpack(IteratorType first, IteratorType last, const bool strict = true,
-               const bool allow_exceptions = true) {
-    basic_json result;
-    detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-    auto ia = detail::input_adapter(std::move(first), std::move(last));
-    const bool res =
-        binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack)
-            .sax_parse(input_format_t::msgpack, &sdp, strict);
-    return res ? result : basic_json(value_t::discarded);
-  }
-
-  template <typename T>
-  JSON_HEDLEY_WARN_UNUSED_RESULT
-  JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
-                             from_msgpack(ptr, ptr + len)) static basic_json
-      from_msgpack(const T *ptr, std::size_t len, const bool strict = true,
-                   const bool allow_exceptions = true) {
-    return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
-  }
-
-  JSON_HEDLEY_WARN_UNUSED_RESULT
-  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
-  static basic_json from_msgpack(detail::span_input_adapter &&i,
-                                 const bool strict = true,
-                                 const bool allow_exceptions = true) {
-    basic_json result;
-    detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-    auto ia = i.get();
-    // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
-    const bool res =
-        binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack)
-            .sax_parse(input_format_t::msgpack, &sdp, strict);
-    return res ? result : basic_json(value_t::discarded);
-  }
-
-  /// @brief create a JSON value from an input in UBJSON format
-  /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
-  template <typename InputType>
-  JSON_HEDLEY_WARN_UNUSED_RESULT static basic_json
-  from_ubjson(InputType &&i, const bool strict = true,
-              const bool allow_exceptions = true) {
-    basic_json result;
-    detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-    auto ia = detail::input_adapter(std::forward<InputType>(i));
-    const bool res =
-        binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson)
-            .sax_parse(input_format_t::ubjson, &sdp, strict);
-    return res ? result : basic_json(value_t::discarded);
-  }
-
-  /// @brief create a JSON value from an input in UBJSON format
-  /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
-  template <typename IteratorType>
-  JSON_HEDLEY_WARN_UNUSED_RESULT static basic_json
-  from_ubjson(IteratorType first, IteratorType last, const bool strict = true,
-              const bool allow_exceptions = true) {
-    basic_json result;
-    detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-    auto ia = detail::input_adapter(std::move(first), std::move(last));
-    const bool res =
-        binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson)
-            .sax_parse(input_format_t::ubjson, &sdp, strict);
-    return res ? result : basic_json(value_t::discarded);
-  }
-
-  template <typename T>
-  JSON_HEDLEY_WARN_UNUSED_RESULT
-  JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
-                             from_ubjson(ptr, ptr + len)) static basic_json
-      from_ubjson(const T *ptr, std::size_t len, const bool strict = true,
-                  const bool allow_exceptions = true) {
-    return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
-  }
-
-  JSON_HEDLEY_WARN_UNUSED_RESULT
-  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
-  static basic_json from_ubjson(detail::span_input_adapter &&i,
-                                const bool strict = true,
-                                const bool allow_exceptions = true) {
-    basic_json result;
-    detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-    auto ia = i.get();
-    // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
-    const bool res =
-        binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson)
-            .sax_parse(input_format_t::ubjson, &sdp, strict);
-    return res ? result : basic_json(value_t::discarded);
-  }
-
-  /// @brief create a JSON value from an input in BJData format
-  /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/
-  template <typename InputType>
-  JSON_HEDLEY_WARN_UNUSED_RESULT static basic_json
-  from_bjdata(InputType &&i, const bool strict = true,
-              const bool allow_exceptions = true) {
-    basic_json result;
-    detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-    auto ia = detail::input_adapter(std::forward<InputType>(i));
-    const bool res =
-        binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata)
-            .sax_parse(input_format_t::bjdata, &sdp, strict);
-    return res ? result : basic_json(value_t::discarded);
-  }
-
-  /// @brief create a JSON value from an input in BJData format
-  /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/
-  template <typename IteratorType>
-  JSON_HEDLEY_WARN_UNUSED_RESULT static basic_json
-  from_bjdata(IteratorType first, IteratorType last, const bool strict = true,
-              const bool allow_exceptions = true) {
-    basic_json result;
-    detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-    auto ia = detail::input_adapter(std::move(first), std::move(last));
-    const bool res =
-        binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata)
-            .sax_parse(input_format_t::bjdata, &sdp, strict);
-    return res ? result : basic_json(value_t::discarded);
-  }
-
-  /// @brief create a JSON value from an input in BSON format
-  /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
-  template <typename InputType>
-  JSON_HEDLEY_WARN_UNUSED_RESULT static basic_json
-  from_bson(InputType &&i, const bool strict = true,
-            const bool allow_exceptions = true) {
-    basic_json result;
-    detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-    auto ia = detail::input_adapter(std::forward<InputType>(i));
-    const bool res =
-        binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson)
-            .sax_parse(input_format_t::bson, &sdp, strict);
-    return res ? result : basic_json(value_t::discarded);
-  }
-
-  /// @brief create a JSON value from an input in BSON format
-  /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
-  template <typename IteratorType>
-  JSON_HEDLEY_WARN_UNUSED_RESULT static basic_json
-  from_bson(IteratorType first, IteratorType last, const bool strict = true,
-            const bool allow_exceptions = true) {
-    basic_json result;
-    detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-    auto ia = detail::input_adapter(std::move(first), std::move(last));
-    const bool res =
-        binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson)
-            .sax_parse(input_format_t::bson, &sdp, strict);
-    return res ? result : basic_json(value_t::discarded);
-  }
-
-  template <typename T>
-  JSON_HEDLEY_WARN_UNUSED_RESULT
-  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len)) static basic_json
-      from_bson(const T *ptr, std::size_t len, const bool strict = true,
-                const bool allow_exceptions = true) {
-    return from_bson(ptr, ptr + len, strict, allow_exceptions);
-  }
-
-  JSON_HEDLEY_WARN_UNUSED_RESULT
-  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
-  static basic_json from_bson(detail::span_input_adapter &&i,
-                              const bool strict = true,
-                              const bool allow_exceptions = true) {
-    basic_json result;
-    detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
-    auto ia = i.get();
-    // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
-    const bool res =
-        binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson)
-            .sax_parse(input_format_t::bson, &sdp, strict);
-    return res ? result : basic_json(value_t::discarded);
-  }
-  /// @}
-
-  //////////////////////////
-  // JSON Pointer support //
-  //////////////////////////
-
-  /// @name JSON Pointer functions
-  /// @{
-
-  /// @brief access specified element via JSON Pointer
-  /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
-  reference operator[](const json_pointer &ptr) {
-    return ptr.get_unchecked(this);
-  }
-
-  template <
-      typename BasicJsonType,
-      detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
-  JSON_HEDLEY_DEPRECATED_FOR(
-      3.11.0, basic_json::json_pointer or
-                  nlohmann::json_pointer<
-                      basic_json::string_t>) // NOLINT(readability/alt_tokens)
-  reference operator[](const ::nlohmann::json_pointer<BasicJsonType> &ptr) {
-    return ptr.get_unchecked(this);
-  }
-
-  /// @brief access specified element via JSON Pointer
-  /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
-  const_reference operator[](const json_pointer &ptr) const {
-    return ptr.get_unchecked(this);
-  }
-
-  template <
-      typename BasicJsonType,
-      detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
-  JSON_HEDLEY_DEPRECATED_FOR(
-      3.11.0, basic_json::json_pointer or
-                  nlohmann::json_pointer<
-                      basic_json::string_t>) // NOLINT(readability/alt_tokens)
-  const_reference
-  operator[](const ::nlohmann::json_pointer<BasicJsonType> &ptr) const {
-    return ptr.get_unchecked(this);
-  }
-
-  /// @brief access specified element via JSON Pointer
-  /// @sa https://json.nlohmann.me/api/basic_json/at/
-  reference at(const json_pointer &ptr) { return ptr.get_checked(this); }
-
-  template <
-      typename BasicJsonType,
-      detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
-  JSON_HEDLEY_DEPRECATED_FOR(
-      3.11.0, basic_json::json_pointer or
-                  nlohmann::json_pointer<
-                      basic_json::string_t>) // NOLINT(readability/alt_tokens)
-  reference at(const ::nlohmann::json_pointer<BasicJsonType> &ptr) {
-    return ptr.get_checked(this);
-  }
-
-  /// @brief access specified element via JSON Pointer
-  /// @sa https://json.nlohmann.me/api/basic_json/at/
-  const_reference at(const json_pointer &ptr) const {
-    return ptr.get_checked(this);
-  }
-
-  template <
-      typename BasicJsonType,
-      detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
-  JSON_HEDLEY_DEPRECATED_FOR(
-      3.11.0, basic_json::json_pointer or
-                  nlohmann::json_pointer<
-                      basic_json::string_t>) // NOLINT(readability/alt_tokens)
-  const_reference at(const ::nlohmann::json_pointer<BasicJsonType> &ptr) const {
-    return ptr.get_checked(this);
-  }
-
-  /// @brief return flattened JSON value
-  /// @sa https://json.nlohmann.me/api/basic_json/flatten/
-  basic_json flatten() const {
-    basic_json result(value_t::object);
-    json_pointer::flatten("", *this, result);
-    return result;
-  }
-
-  /// @brief unflatten a previously flattened JSON value
-  /// @sa https://json.nlohmann.me/api/basic_json/unflatten/
-  basic_json unflatten() const { return json_pointer::unflatten(*this); }
-
-  /// @}
-
-  //////////////////////////
-  // JSON Patch functions //
-  //////////////////////////
-
-  /// @name JSON Patch functions
-  /// @{
-
-  /// @brief applies a JSON patch in-place without copying the object
-  /// @sa https://json.nlohmann.me/api/basic_json/patch/
-  void patch_inplace(const basic_json &json_patch) {
-    basic_json &result = *this;
-    // the valid JSON Patch operations
-    enum class patch_operations {
-      add,
-      remove,
-      replace,
-      move,
-      copy,
-      test,
-      invalid
-    };
-
-    const auto get_op = [](const std::string &op) {
-      if (op == "add") {
-        return patch_operations::add;
-      }
-      if (op == "remove") {
-        return patch_operations::remove;
-      }
-      if (op == "replace") {
-        return patch_operations::replace;
-      }
-      if (op == "move") {
-        return patch_operations::move;
-      }
-      if (op == "copy") {
-        return patch_operations::copy;
-      }
-      if (op == "test") {
-        return patch_operations::test;
-      }
-
-      return patch_operations::invalid;
-    };
-
-    // wrapper for "add" operation; add value at ptr
-    const auto operation_add = [&result](json_pointer &ptr,
-                                         const basic_json &val) {
-      // adding to the root of the target document means replacing it
-      if (ptr.empty()) {
-        result = val;
-        return;
-      }
-
-      // make sure the top element of the pointer exists
-      json_pointer const top_pointer = ptr.top();
-      if (top_pointer != ptr) {
-        result.at(top_pointer);
-      }
-
-      // get reference to parent of JSON pointer ptr
-      const auto last_path = ptr.back();
-      ptr.pop_back();
-      // parent must exist when performing patch add per RFC6902 specs
-      basic_json &parent = result.at(ptr);
-
-      switch (parent.m_data.m_type) {
-      case value_t::null:
-      case value_t::object: {
-        // use operator[] to add value
-        parent[last_path] = val;
-        break;
-      }
-
-      case value_t::array: {
-        if (last_path == "-") {
-          // special case: append to back
-          parent.push_back(val);
-        } else {
-          const auto idx =
-              json_pointer::template array_index<basic_json_t>(last_path);
-          if (JSON_HEDLEY_UNLIKELY(idx > parent.size())) {
-            // avoid undefined behavior
-            JSON_THROW(out_of_range::create(401,
-                                            detail::concat("array index ",
-                                                           std::to_string(idx),
-                                                           " is out of range"),
-                                            &parent));
-          }
-
-          // default case: insert add offset
-          parent.insert(parent.begin() + static_cast<difference_type>(idx),
-                        val);
-        }
-        break;
-      }
-
-      // if there exists a parent it cannot be primitive
-      case value_t::string:          // LCOV_EXCL_LINE
-      case value_t::boolean:         // LCOV_EXCL_LINE
-      case value_t::number_integer:  // LCOV_EXCL_LINE
-      case value_t::number_unsigned: // LCOV_EXCL_LINE
-      case value_t::number_float:    // LCOV_EXCL_LINE
-      case value_t::binary:          // LCOV_EXCL_LINE
-      case value_t::discarded:       // LCOV_EXCL_LINE
-      default:                       // LCOV_EXCL_LINE
-        JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
-                            // LCOV_EXCL_LINE
-      }
-    };
-
-    // wrapper for "remove" operation; remove value at ptr
-    const auto operation_remove = [this, &result](json_pointer &ptr) {
-      // get reference to parent of JSON pointer ptr
-      const auto last_path = ptr.back();
-      ptr.pop_back();
-      basic_json &parent = result.at(ptr);
-
-      // remove child
-      if (parent.is_object()) {
-        // perform range check
-        auto it = parent.find(last_path);
-        if (JSON_HEDLEY_LIKELY(it != parent.end())) {
-          parent.erase(it);
-        } else {
-          JSON_THROW(out_of_range::create(
-              403, detail::concat("key '", last_path, "' not found"), this));
-        }
-      } else if (parent.is_array()) {
-        // note erase performs range check
-        parent.erase(
-            json_pointer::template array_index<basic_json_t>(last_path));
-      }
-    };
-
-    // type check: top level value must be an array
-    if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array())) {
-      JSON_THROW(parse_error::create(
-          104, 0, "JSON patch must be an array of objects", &json_patch));
-    }
-
-    // iterate and apply the operations
-    for (const auto &val : json_patch) {
-      // wrapper to get a value for an operation
-      const auto get_value = [&val](const std::string &op,
-                                    const std::string &member,
-                                    bool string_type) -> basic_json & {
-        // find value
-        auto it = val.m_data.m_value.object->find(member);
-
-        // context-sensitive error message
-        const auto error_msg =
-            (op == "op")
-                ? "operation"
-                : detail::concat(
-                      "operation '", op,
-                      '\''); // NOLINT(bugprone-unused-local-non-trivial-variable)
-
-        // check if desired value is present
-        if (JSON_HEDLEY_UNLIKELY(it == val.m_data.m_value.object->end())) {
-          // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
-          JSON_THROW(parse_error::create(
-              105, 0,
-              detail::concat(error_msg, " must have member '", member, "'"),
-              &val));
-        }
-
-        // check if result is of type string
-        if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string())) {
-          // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
-          JSON_THROW(parse_error::create(
-              105, 0,
-              detail::concat(error_msg, " must have string member '", member,
-                             "'"),
-              &val));
-        }
-
-        // no error: return value
-        return it->second;
-      };
-
-      // type check: every element of the array must be an object
-      if (JSON_HEDLEY_UNLIKELY(!val.is_object())) {
-        JSON_THROW(parse_error::create(
-            104, 0, "JSON patch must be an array of objects", &val));
-      }
-
-      // collect mandatory members
-      const auto op = get_value("op", "op", true).template get<std::string>();
-      const auto path = get_value(op, "path", true).template get<std::string>();
-      json_pointer ptr(path);
-
-      switch (get_op(op)) {
-      case patch_operations::add: {
-        operation_add(ptr, get_value("add", "value", false));
-        break;
-      }
-
-      case patch_operations::remove: {
-        operation_remove(ptr);
-        break;
-      }
-
-      case patch_operations::replace: {
-        // the "path" location must exist - use at()
-        result.at(ptr) = get_value("replace", "value", false);
-        break;
-      }
-
-      case patch_operations::move: {
-        const auto from_path =
-            get_value("move", "from", true).template get<std::string>();
-        json_pointer from_ptr(from_path);
-
-        // the "from" location must exist - use at()
-        basic_json const v = result.at(from_ptr);
-
-        // The move operation is functionally identical to a
-        // "remove" operation on the "from" location, followed
-        // immediately by an "add" operation at the target
-        // location with the value that was just removed.
-        operation_remove(from_ptr);
-        operation_add(ptr, v);
-        break;
-      }
-
-      case patch_operations::copy: {
-        const auto from_path =
-            get_value("copy", "from", true).template get<std::string>();
-        const json_pointer from_ptr(from_path);
-
-        // the "from" location must exist - use at()
-        basic_json const v = result.at(from_ptr);
-
-        // The copy is functionally identical to an "add"
-        // operation at the target location using the value
-        // specified in the "from" member.
-        operation_add(ptr, v);
-        break;
-      }
-
-      case patch_operations::test: {
-        bool success = false;
-        JSON_TRY {
-          // check if "value" matches the one at "path"
-          // the "path" location must exist - use at()
-          success = (result.at(ptr) == get_value("test", "value", false));
-        }
-        JSON_INTERNAL_CATCH(out_of_range &) {
-          // ignore out of range errors: success remains false
-        }
-
-        // throw an exception if test fails
-        if (JSON_HEDLEY_UNLIKELY(!success)) {
-          JSON_THROW(other_error::create(
-              501, detail::concat("unsuccessful: ", val.dump()), &val));
-        }
-
-        break;
-      }
-
-      case patch_operations::invalid:
-      default: {
-        // op must be "add", "remove", "replace", "move", "copy", or
-        // "test"
-        JSON_THROW(parse_error::create(
-            105, 0, detail::concat("operation value '", op, "' is invalid"),
-            &val));
-      }
-      }
-    }
-  }
-
-  /// @brief applies a JSON patch to a copy of the current object
-  /// @sa https://json.nlohmann.me/api/basic_json/patch/
-  basic_json patch(const basic_json &json_patch) const {
-    basic_json result = *this;
-    result.patch_inplace(json_patch);
-    return result;
-  }
-
-  /// @brief creates a diff as a JSON patch
-  /// @sa https://json.nlohmann.me/api/basic_json/diff/
-  JSON_HEDLEY_WARN_UNUSED_RESULT
-  static basic_json diff(const basic_json &source, const basic_json &target,
-                         const std::string &path = "") {
-    // the patch
-    basic_json result(value_t::array);
-
-    // if the values are the same, return empty patch
-    if (source == target) {
-      return result;
-    }
-
-    if (source.type() != target.type()) {
-      // different types: replace value
-      result.push_back({{"op", "replace"}, {"path", path}, {"value", target}});
-      return result;
-    }
-
-    switch (source.type()) {
-    case value_t::array: {
-      // first pass: traverse common elements
-      std::size_t i = 0;
-      while (i < source.size() && i < target.size()) {
-        // recursive call to compare array values at index i
-        auto temp_diff = diff(source[i], target[i],
-                              detail::concat(path, '/', std::to_string(i)));
-        result.insert(result.end(), temp_diff.begin(), temp_diff.end());
-        ++i;
-      }
-
-      // We now reached the end of at least one array
-      // in a second pass, traverse the remaining elements
-
-      // remove my remaining elements
-      const auto end_index = static_cast<difference_type>(result.size());
-      while (i < source.size()) {
-        // add operations in reverse order to avoid invalid
-        // indices
-        result.insert(
-            result.begin() + end_index,
-            object({{"op", "remove"},
-                    {"path", detail::concat(path, '/', std::to_string(i))}}));
-        ++i;
-      }
-
-      // add other remaining elements
-      while (i < target.size()) {
-        result.push_back({{"op", "add"},
-                          {"path", detail::concat(path, "/-")},
-                          {"value", target[i]}});
-        ++i;
-      }
-
-      break;
-    }
-
-    case value_t::object: {
-      // first pass: traverse this object's elements
-      for (auto it = source.cbegin(); it != source.cend(); ++it) {
-        // escape the key name to be used in a JSON patch
-        const auto path_key =
-            detail::concat(path, '/', detail::escape(it.key()));
-
-        if (target.find(it.key()) != target.end()) {
-          // recursive call to compare object values at key it
-          auto temp_diff = diff(it.value(), target[it.key()], path_key);
-          result.insert(result.end(), temp_diff.begin(), temp_diff.end());
-        } else {
-          // found a key that is not in o -> remove it
-          result.push_back(object({{"op", "remove"}, {"path", path_key}}));
-        }
-      }
-
-      // second pass: traverse other object's elements
-      for (auto it = target.cbegin(); it != target.cend(); ++it) {
-        if (source.find(it.key()) == source.end()) {
-          // found a key that is not in this -> add it
-          const auto path_key =
-              detail::concat(path, '/', detail::escape(it.key()));
-          result.push_back(
-              {{"op", "add"}, {"path", path_key}, {"value", it.value()}});
-        }
-      }
-
-      break;
-    }
-
-    case value_t::null:
-    case value_t::string:
-    case value_t::boolean:
-    case value_t::number_integer:
-    case value_t::number_unsigned:
-    case value_t::number_float:
-    case value_t::binary:
-    case value_t::discarded:
-    default: {
-      // both primitive type: replace value
-      result.push_back({{"op", "replace"}, {"path", path}, {"value", target}});
-      break;
-    }
-    }
-
-    return result;
-  }
-  /// @}
-
-  ////////////////////////////////
-  // JSON Merge Patch functions //
-  ////////////////////////////////
-
-  /// @name JSON Merge Patch functions
-  /// @{
-
-  /// @brief applies a JSON Merge Patch
-  /// @sa https://json.nlohmann.me/api/basic_json/merge_patch/
-  void merge_patch(const basic_json &apply_patch) {
-    if (apply_patch.is_object()) {
-      if (!is_object()) {
-        *this = object();
-      }
-      for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it) {
-        if (it.value().is_null()) {
-          erase(it.key());
-        } else {
-          operator[](it.key()).merge_patch(it.value());
-        }
-      }
-    } else {
-      *this = apply_patch;
-    }
-  }
-
-  /// @}
-};
-
-/// @brief user-defined to_string function for JSON values
-/// @sa https://json.nlohmann.me/api/basic_json/to_string/
-NLOHMANN_BASIC_JSON_TPL_DECLARATION
-std::string to_string(const NLOHMANN_BASIC_JSON_TPL &j) { return j.dump(); }
-
-inline namespace literals {
-inline namespace json_literals {
-
-/// @brief user-defined string literal for JSON values
-/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json/
-JSON_HEDLEY_NON_NULL(1)
-#if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4, 9, 0)
-inline nlohmann::json operator""_json(const char *s, std::size_t n)
-#else
-inline nlohmann::json operator"" _json(const char *s, std::size_t n)
-#endif
-{
-  return nlohmann::json::parse(s, s + n);
-}
-
-/// @brief user-defined string literal for JSON pointer
-/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json_pointer/
-JSON_HEDLEY_NON_NULL(1)
-#if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4, 9, 0)
-inline nlohmann::json::json_pointer operator""_json_pointer(const char *s,
-                                                            std::size_t n)
-#else
-inline nlohmann::json::json_pointer operator"" _json_pointer(const char *s,
-                                                             std::size_t n)
-#endif
-{
-  return nlohmann::json::json_pointer(std::string(s, n));
-}
-
-} // namespace json_literals
-} // namespace literals
-NLOHMANN_JSON_NAMESPACE_END
-
-///////////////////////
-// nonmember support //
-///////////////////////
-
-namespace std // NOLINT(cert-dcl58-cpp)
-{
-
-/// @brief hash value for JSON objects
-/// @sa https://json.nlohmann.me/api/basic_json/std_hash/
-NLOHMANN_BASIC_JSON_TPL_DECLARATION
-struct hash<nlohmann::NLOHMANN_BASIC_JSON_TPL> // NOLINT(cert-dcl58-cpp)
-{
-  std::size_t operator()(const nlohmann::NLOHMANN_BASIC_JSON_TPL &j) const {
-    return nlohmann::detail::hash(j);
-  }
-};
-
-// specialization for std::less<value_t>
-template <>
-struct less<
-    ::nlohmann::detail::value_t> // do not remove the space after '<', see
-                                 // https://github.com/nlohmann/json/pull/679
-{
-  /*!
-  @brief compare two value_t enum values
-  @since version 3.0.0
-  */
-  bool operator()(::nlohmann::detail::value_t lhs,
-                  ::nlohmann::detail::value_t rhs) const noexcept {
-#if JSON_HAS_THREE_WAY_COMPARISON
-    return std::is_lt(lhs <=> rhs); // *NOPAD*
-#else
-    return ::nlohmann::detail::operator<(lhs, rhs);
-#endif
-  }
-};
-
-// C++20 prohibit function specialization in the std namespace.
-#ifndef JSON_HAS_CPP_20
-
-/// @brief exchanges the values of two JSON objects
-/// @sa https://json.nlohmann.me/api/basic_json/std_swap/
-NLOHMANN_BASIC_JSON_TPL_DECLARATION
-inline void
-swap(nlohmann::NLOHMANN_BASIC_JSON_TPL &j1,
-     nlohmann::NLOHMANN_BASIC_JSON_TPL &j2) noexcept( // NOLINT(readability-inconsistent-declaration-parameter-name,
-                                                      // cert-dcl58-cpp)
-    is_nothrow_move_constructible<nlohmann::NLOHMANN_BASIC_JSON_TPL>::
-        value && // NOLINT(misc-redundant-expression,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
-    is_nothrow_move_assignable<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value) {
-  j1.swap(j2);
-}
-
-#endif
-
-} // namespace std
-
-#if JSON_USE_GLOBAL_UDLS
-#if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4, 9, 0)
-using nlohmann::literals::json_literals::
-operator""_json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
-using nlohmann::literals::json_literals::
-operator""_json_pointer; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
-#else
-using nlohmann::literals::json_literals::
-operator"" _json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
-using nlohmann::literals::json_literals::
-operator"" _json_pointer; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
-#endif
-#endif
-
-// #include <nlohmann/detail/macro_unscope.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// restore clang diagnostic settings
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
-// clean up
-#undef JSON_ASSERT
-#undef JSON_INTERNAL_CATCH
-#undef JSON_THROW
-#undef JSON_PRIVATE_UNLESS_TESTED
-#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
-#undef NLOHMANN_BASIC_JSON_TPL
-#undef JSON_EXPLICIT
-#undef NLOHMANN_CAN_CALL_STD_FUNC_IMPL
-#undef JSON_INLINE_VARIABLE
-#undef JSON_NO_UNIQUE_ADDRESS
-#undef JSON_DISABLE_ENUM_SERIALIZATION
-#undef JSON_USE_GLOBAL_UDLS
-
-#ifndef JSON_TEST_KEEP_MACROS
-#undef JSON_CATCH
-#undef JSON_TRY
-#undef JSON_HAS_CPP_11
-#undef JSON_HAS_CPP_14
-#undef JSON_HAS_CPP_17
-#undef JSON_HAS_CPP_20
-#undef JSON_HAS_FILESYSTEM
-#undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
-#undef JSON_HAS_THREE_WAY_COMPARISON
-#undef JSON_HAS_RANGES
-#undef JSON_HAS_STATIC_RTTI
-#undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
-#endif
-
-// #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.11.3
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2024 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#undef JSON_HEDLEY_ALWAYS_INLINE
-#undef JSON_HEDLEY_ARM_VERSION
-#undef JSON_HEDLEY_ARM_VERSION_CHECK
-#undef JSON_HEDLEY_ARRAY_PARAM
-#undef JSON_HEDLEY_ASSUME
-#undef JSON_HEDLEY_BEGIN_C_DECLS
-#undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
-#undef JSON_HEDLEY_CLANG_HAS_BUILTIN
-#undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
-#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
-#undef JSON_HEDLEY_CLANG_HAS_EXTENSION
-#undef JSON_HEDLEY_CLANG_HAS_FEATURE
-#undef JSON_HEDLEY_CLANG_HAS_WARNING
-#undef JSON_HEDLEY_COMPCERT_VERSION
-#undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
-#undef JSON_HEDLEY_CONCAT
-#undef JSON_HEDLEY_CONCAT3
-#undef JSON_HEDLEY_CONCAT3_EX
-#undef JSON_HEDLEY_CONCAT_EX
-#undef JSON_HEDLEY_CONST
-#undef JSON_HEDLEY_CONSTEXPR
-#undef JSON_HEDLEY_CONST_CAST
-#undef JSON_HEDLEY_CPP_CAST
-#undef JSON_HEDLEY_CRAY_VERSION
-#undef JSON_HEDLEY_CRAY_VERSION_CHECK
-#undef JSON_HEDLEY_C_DECL
-#undef JSON_HEDLEY_DEPRECATED
-#undef JSON_HEDLEY_DEPRECATED_FOR
-#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
-#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
-#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
-#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
-#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
-#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
-#undef JSON_HEDLEY_DIAGNOSTIC_POP
-#undef JSON_HEDLEY_DIAGNOSTIC_PUSH
-#undef JSON_HEDLEY_DMC_VERSION
-#undef JSON_HEDLEY_DMC_VERSION_CHECK
-#undef JSON_HEDLEY_EMPTY_BASES
-#undef JSON_HEDLEY_EMSCRIPTEN_VERSION
-#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
-#undef JSON_HEDLEY_END_C_DECLS
-#undef JSON_HEDLEY_FLAGS
-#undef JSON_HEDLEY_FLAGS_CAST
-#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
-#undef JSON_HEDLEY_GCC_HAS_BUILTIN
-#undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
-#undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
-#undef JSON_HEDLEY_GCC_HAS_EXTENSION
-#undef JSON_HEDLEY_GCC_HAS_FEATURE
-#undef JSON_HEDLEY_GCC_HAS_WARNING
-#undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
-#undef JSON_HEDLEY_GCC_VERSION
-#undef JSON_HEDLEY_GCC_VERSION_CHECK
-#undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
-#undef JSON_HEDLEY_GNUC_HAS_BUILTIN
-#undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
-#undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
-#undef JSON_HEDLEY_GNUC_HAS_EXTENSION
-#undef JSON_HEDLEY_GNUC_HAS_FEATURE
-#undef JSON_HEDLEY_GNUC_HAS_WARNING
-#undef JSON_HEDLEY_GNUC_VERSION
-#undef JSON_HEDLEY_GNUC_VERSION_CHECK
-#undef JSON_HEDLEY_HAS_ATTRIBUTE
-#undef JSON_HEDLEY_HAS_BUILTIN
-#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
-#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
-#undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
-#undef JSON_HEDLEY_HAS_EXTENSION
-#undef JSON_HEDLEY_HAS_FEATURE
-#undef JSON_HEDLEY_HAS_WARNING
-#undef JSON_HEDLEY_IAR_VERSION
-#undef JSON_HEDLEY_IAR_VERSION_CHECK
-#undef JSON_HEDLEY_IBM_VERSION
-#undef JSON_HEDLEY_IBM_VERSION_CHECK
-#undef JSON_HEDLEY_IMPORT
-#undef JSON_HEDLEY_INLINE
-#undef JSON_HEDLEY_INTEL_CL_VERSION
-#undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
-#undef JSON_HEDLEY_INTEL_VERSION
-#undef JSON_HEDLEY_INTEL_VERSION_CHECK
-#undef JSON_HEDLEY_IS_CONSTANT
-#undef JSON_HEDLEY_IS_CONSTEXPR_
-#undef JSON_HEDLEY_LIKELY
-#undef JSON_HEDLEY_MALLOC
-#undef JSON_HEDLEY_MCST_LCC_VERSION
-#undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
-#undef JSON_HEDLEY_MESSAGE
-#undef JSON_HEDLEY_MSVC_VERSION
-#undef JSON_HEDLEY_MSVC_VERSION_CHECK
-#undef JSON_HEDLEY_NEVER_INLINE
-#undef JSON_HEDLEY_NON_NULL
-#undef JSON_HEDLEY_NO_ESCAPE
-#undef JSON_HEDLEY_NO_RETURN
-#undef JSON_HEDLEY_NO_THROW
-#undef JSON_HEDLEY_NULL
-#undef JSON_HEDLEY_PELLES_VERSION
-#undef JSON_HEDLEY_PELLES_VERSION_CHECK
-#undef JSON_HEDLEY_PGI_VERSION
-#undef JSON_HEDLEY_PGI_VERSION_CHECK
-#undef JSON_HEDLEY_PREDICT
-#undef JSON_HEDLEY_PRINTF_FORMAT
-#undef JSON_HEDLEY_PRIVATE
-#undef JSON_HEDLEY_PUBLIC
-#undef JSON_HEDLEY_PURE
-#undef JSON_HEDLEY_REINTERPRET_CAST
-#undef JSON_HEDLEY_REQUIRE
-#undef JSON_HEDLEY_REQUIRE_CONSTEXPR
-#undef JSON_HEDLEY_REQUIRE_MSG
-#undef JSON_HEDLEY_RESTRICT
-#undef JSON_HEDLEY_RETURNS_NON_NULL
-#undef JSON_HEDLEY_SENTINEL
-#undef JSON_HEDLEY_STATIC_ASSERT
-#undef JSON_HEDLEY_STATIC_CAST
-#undef JSON_HEDLEY_STRINGIFY
-#undef JSON_HEDLEY_STRINGIFY_EX
-#undef JSON_HEDLEY_SUNPRO_VERSION
-#undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
-#undef JSON_HEDLEY_TINYC_VERSION
-#undef JSON_HEDLEY_TINYC_VERSION_CHECK
-#undef JSON_HEDLEY_TI_ARMCL_VERSION
-#undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
-#undef JSON_HEDLEY_TI_CL2000_VERSION
-#undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
-#undef JSON_HEDLEY_TI_CL430_VERSION
-#undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
-#undef JSON_HEDLEY_TI_CL6X_VERSION
-#undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
-#undef JSON_HEDLEY_TI_CL7X_VERSION
-#undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
-#undef JSON_HEDLEY_TI_CLPRU_VERSION
-#undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
-#undef JSON_HEDLEY_TI_VERSION
-#undef JSON_HEDLEY_TI_VERSION_CHECK
-#undef JSON_HEDLEY_UNAVAILABLE
-#undef JSON_HEDLEY_UNLIKELY
-#undef JSON_HEDLEY_UNPREDICTABLE
-#undef JSON_HEDLEY_UNREACHABLE
-#undef JSON_HEDLEY_UNREACHABLE_RETURN
-#undef JSON_HEDLEY_VERSION
-#undef JSON_HEDLEY_VERSION_DECODE_MAJOR
-#undef JSON_HEDLEY_VERSION_DECODE_MINOR
-#undef JSON_HEDLEY_VERSION_DECODE_REVISION
-#undef JSON_HEDLEY_VERSION_ENCODE
-#undef JSON_HEDLEY_WARNING
-#undef JSON_HEDLEY_WARN_UNUSED_RESULT
-#undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
-#undef JSON_HEDLEY_FALL_THROUGH
-
-#endif // INCLUDE_NLOHMANN_JSON_HPP_
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core.hpp b/packages/react-native-executorch/third-party/include/opencv2/core.hpp
deleted file mode 100644
index c3e83ae17b..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core.hpp
+++ /dev/null
@@ -1,3699 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                           License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2015, Intel Corporation, all rights reserved.
-// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2015, OpenCV Foundation, all rights reserved.
-// Copyright (C) 2015, Itseez Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_CORE_HPP
-#define OPENCV_CORE_HPP
-
-#ifndef __cplusplus
-#error core.hpp header must be compiled as C++
-#endif
-
-#include "opencv2/core/base.hpp"
-#include "opencv2/core/cvdef.h"
-#include "opencv2/core/cvstd.hpp"
-#include "opencv2/core/mat.hpp"
-#include "opencv2/core/matx.hpp"
-#include "opencv2/core/persistence.hpp"
-#include "opencv2/core/traits.hpp"
-#include "opencv2/core/types.hpp"
-
-/**
-@defgroup core Core functionality
-
-The Core module is the backbone of OpenCV, offering fundamental data structures,
-matrix operations, and utility functions that other modules depend on. It’s
-essential for handling image data, performing mathematical computations, and
-managing memory efficiently within the OpenCV ecosystem.
-
-@{
-    @defgroup core_basic Basic structures
-    @defgroup core_array Operations on arrays
-    @defgroup core_async Asynchronous API
-    @defgroup core_xml XML/YAML/JSON Persistence
-    @defgroup core_cluster Clustering
-    @defgroup core_utils Utility and system functions and macros
-    @{
-        @defgroup core_logging Logging facilities
-        @defgroup core_utils_sse SSE utilities
-        @defgroup core_utils_neon NEON utilities
-        @defgroup core_utils_vsx VSX utilities
-        @defgroup core_utils_softfloat Softfloat support
-        @defgroup core_utils_samples Utility functions for OpenCV samples
-    @}
-    @defgroup core_opengl OpenGL interoperability
-    @defgroup core_optim Optimization Algorithms
-    @defgroup core_directx DirectX interoperability
-    @defgroup core_eigen Eigen support
-    @defgroup core_opencl OpenCL support
-    @defgroup core_va_intel Intel VA-API/OpenCL (CL-VA) interoperability
-    @defgroup core_hal Hardware Acceleration Layer
-    @{
-        @defgroup core_hal_functions Functions
-        @defgroup core_hal_interface Interface
-        @defgroup core_hal_intrin Universal intrinsics
-        @{
-            @defgroup core_hal_intrin_impl Private implementation helpers
-        @}
-        @defgroup core_lowlevel_api Low-level API for external libraries /
-plugins
-    @}
-    @defgroup core_parallel Parallel Processing
-    @{
-        @defgroup core_parallel_backend Parallel backends API
-    @}
-    @defgroup core_quaternion Quaternion
-@}
- */
-
-namespace cv {
-
-//! @addtogroup core_utils
-//! @{
-
-/*! @brief Class passed to an error.
-
-This class encapsulates all or almost all necessary
-information about the error happened in the program. The exception is
-usually constructed and thrown implicitly via CV_Error and CV_Error_ macros.
-@see error
- */
-class CV_EXPORTS Exception : public std::exception {
-public:
-  /*!
-   Default constructor
-   */
-  Exception();
-  /*!
-   Full constructor. Normally the constructor is not called explicitly.
-   Instead, the macros CV_Error(), CV_Error_() and CV_Assert() are used.
-  */
-  Exception(int _code, const String &_err, const String &_func,
-            const String &_file, int _line);
-  virtual ~Exception() CV_NOEXCEPT;
-
-  /*!
-   \return the error description and the context as a text string.
-  */
-  virtual const char *what() const CV_NOEXCEPT CV_OVERRIDE;
-  void formatMessage();
-
-  String msg; ///< the formatted error message
-
-  int code;    ///< error code @see CVStatus
-  String err;  ///< error description
-  String func; ///< function name. Available only when the compiler supports
-               ///< getting it
-  String file; ///< source file name where the error has occurred
-  int line;    ///< line number in the source file where the error has occurred
-};
-
-/*! @brief Signals an error and raises the exception.
-
-By default the function prints information about the error to stderr,
-then it either stops if cv::setBreakOnError() had been called before or raises
-the exception. It is possible to alternate error processing by using
-#redirectError().
-@param exc the exception raisen.
-@deprecated drop this version
- */
-CV_EXPORTS CV_NORETURN void error(const Exception &exc);
-
-enum SortFlags {
-  SORT_EVERY_ROW = 0,    //!< each matrix row is sorted independently
-  SORT_EVERY_COLUMN = 1, //!< each matrix column is sorted
-                         //!< independently; this flag and the previous one are
-                         //!< mutually exclusive.
-  SORT_ASCENDING = 0,    //!< each matrix row is sorted in the ascending
-                         //!< order.
-  SORT_DESCENDING = 16   //!< each matrix row is sorted in the
-                       //!< descending order; this flag and the previous one are
-                       //!< also mutually exclusive.
-};
-
-//! @} core_utils
-
-//! @addtogroup core_array
-//! @{
-
-//! Covariation flags
-enum CovarFlags {
-  /** The output covariance matrix is calculated as:
-     \f[\texttt{scale}   \cdot  [  \texttt{vects}  [0]-  \texttt{mean}  ,
-     \texttt{vects}  [1]-  \texttt{mean}  ,...]^T  \cdot  [ \texttt{vects}  [0]-
-     \texttt{mean}  , \texttt{vects}  [1]- \texttt{mean}  ,...],\f] The
-     covariance matrix will be nsamples x nsamples. Such an unusual covariance
-     matrix is used for fast PCA of a set of very large vectors (see, for
-     example, the EigenFaces technique for face recognition). Eigenvalues of
-     this "scrambled" matrix match the eigenvalues of the true covariance
-     matrix. The "true" eigenvectors can be easily calculated from the
-     eigenvectors of the "scrambled" covariance matrix. */
-  COVAR_SCRAMBLED = 0,
-  /**The output covariance matrix is calculated as:
-      \f[\texttt{scale}   \cdot  [  \texttt{vects}  [0]-  \texttt{mean}  ,
-     \texttt{vects}  [1]-  \texttt{mean}  ,...]  \cdot  [ \texttt{vects}  [0]-
-     \texttt{mean}  , \texttt{vects}  [1]- \texttt{mean}  ,...]^T,\f] covar will
-     be a square matrix of the same size as the total number of elements in each
-     input vector. One and only one of #COVAR_SCRAMBLED and #COVAR_NORMAL must
-     be specified.*/
-  COVAR_NORMAL = 1,
-  /** If the flag is specified, the function does not calculate mean from
-      the input vectors but, instead, uses the passed mean vector. This is
-     useful if mean has been pre-calculated or known in advance, or if the
-     covariance matrix is calculated by parts. In this case, mean is not a mean
-     vector of the input sub-set of vectors but rather the mean vector of the
-     whole set.*/
-  COVAR_USE_AVG = 2,
-  /** If the flag is specified, the covariance matrix is scaled. In the
-      "normal" mode, scale is 1./nsamples . In the "scrambled" mode, scale is
-     the reciprocal of the total number of elements in each input vector. By
-     default (if the flag is not specified), the covariance matrix is not scaled
-     ( scale=1 ).*/
-  COVAR_SCALE = 4,
-  /** If the flag is
-      specified, all the input vectors are stored as rows of the samples matrix.
-     mean should be a single-row vector in this case.*/
-  COVAR_ROWS = 8,
-  /** If the flag is
-      specified, all the input vectors are stored as columns of the samples
-     matrix. mean should be a single-column vector in this case.*/
-  COVAR_COLS = 16
-};
-
-enum ReduceTypes {
-  REDUCE_SUM = 0, //!< the output is the sum of all rows/columns of the matrix.
-  REDUCE_AVG =
-      1, //!< the output is the mean vector of all rows/columns of the matrix.
-  REDUCE_MAX = 2, //!< the output is the maximum (column/row-wise) of all
-                  //!< rows/columns of the matrix.
-  REDUCE_MIN = 3, //!< the output is the minimum (column/row-wise) of all
-                  //!< rows/columns of the matrix.
-  REDUCE_SUM2 =
-      4 //!< the output is the sum of all squared rows/columns of the matrix.
-};
-
-/** @brief Swaps two matrices
- */
-CV_EXPORTS void swap(Mat &a, Mat &b);
-
-/** @brief Computes the source location of an extrapolated pixel.
-
-The function computes and returns the coordinate of a donor pixel corresponding
-to the specified extrapolated pixel when using the specified extrapolation
-border mode. For example, if you use cv::BORDER_WRAP mode in the horizontal
-direction, cv::BORDER_REFLECT_101 in the vertical direction and want to compute
-value of the "virtual" pixel Point(-5, 100) in a floating-point image img, it
-looks like:
-@code{.cpp}
-    float val = img.at<float>(borderInterpolate(100, img.rows,
-cv::BORDER_REFLECT_101), borderInterpolate(-5, img.cols, cv::BORDER_WRAP));
-@endcode
-Normally, the function is not called directly. It is used inside filtering
-functions and also in copyMakeBorder.
-@param p 0-based coordinate of the extrapolated pixel along one of the axes,
-likely \<0 or \>= len
-@param len Length of the array along the corresponding axis.
-@param borderType Border type, one of the #BorderTypes, except for
-#BORDER_TRANSPARENT and #BORDER_ISOLATED. When borderType==#BORDER_CONSTANT, the
-function always returns -1, regardless of p and len.
-
-@sa copyMakeBorder
-*/
-CV_EXPORTS_W int borderInterpolate(int p, int len, int borderType);
-
-/** @example samples/cpp/tutorial_code/ImgTrans/copyMakeBorder_demo.cpp
-An example using copyMakeBorder function.
-Check @ref tutorial_copyMakeBorder "the corresponding tutorial" for more details
-*/
-
-/** @brief Forms a border around an image.
-
-The function copies the source image into the middle of the destination image.
-The areas to the left, to the right, above and below the copied source image
-will be filled with extrapolated pixels. This is not what filtering functions
-based on it do (they extrapolate pixels on-fly), but what other more complex
-functions, including your own, may do to simplify image boundary handling.
-
-The function supports the mode when src is already in the middle of dst . In
-this case, the function does not copy src itself but simply constructs the
-border, for example:
-
-@code{.cpp}
-    // let border be the same in all directions
-    int border=2;
-    // constructs a larger image to fit both the image and the border
-    Mat gray_buf(rgb.rows + border*2, rgb.cols + border*2, rgb.depth());
-    // select the middle part of it w/o copying data
-    Mat gray(gray_canvas, Rect(border, border, rgb.cols, rgb.rows));
-    // convert image from RGB to grayscale
-    cvtColor(rgb, gray, COLOR_RGB2GRAY);
-    // form a border in-place
-    copyMakeBorder(gray, gray_buf, border, border,
-                   border, border, BORDER_REPLICATE);
-    // now do some custom filtering ...
-    ...
-@endcode
-@note When the source image is a part (ROI) of a bigger image, the function will
-try to use the pixels outside of the ROI to form a border. To disable this
-feature and always do extrapolation, as if src was not a ROI, use borderType |
-#BORDER_ISOLATED.
-
-@param src Source image.
-@param dst Destination image of the same type as src and the size
-Size(src.cols+left+right, src.rows+top+bottom) .
-@param top the top pixels
-@param bottom the bottom pixels
-@param left the left pixels
-@param right Parameter specifying how many pixels in each direction from the
-source image rectangle to extrapolate. For example, top=1, bottom=1, left=1,
-right=1 mean that 1 pixel-wide border needs to be built.
-@param borderType Border type. See borderInterpolate for details.
-@param value Border value if borderType==BORDER_CONSTANT .
-
-@sa  borderInterpolate
-*/
-CV_EXPORTS_W void copyMakeBorder(InputArray src, OutputArray dst, int top,
-                                 int bottom, int left, int right,
-                                 int borderType,
-                                 const Scalar &value = Scalar());
-
-/** @brief Calculates the per-element sum of two arrays or an array and a
-scalar.
-
-The function add calculates:
-- Sum of two arrays when both input arrays have the same size and the same
-number of channels:
-\f[\texttt{dst}(I) =  \texttt{saturate} ( \texttt{src1}(I) +  \texttt{src2}(I))
-\quad \texttt{if mask}(I) \ne0\f]
-- Sum of an array and a scalar when src2 is constructed from Scalar or has the
-same number of elements as `src1.channels()`:
-\f[\texttt{dst}(I) =  \texttt{saturate} ( \texttt{src1}(I) +  \texttt{src2} )
-\quad \texttt{if mask}(I) \ne0\f]
-- Sum of a scalar and an array when src1 is constructed from Scalar or has the
-same number of elements as `src2.channels()`:
-\f[\texttt{dst}(I) =  \texttt{saturate} ( \texttt{src1} +  \texttt{src2}(I) )
-\quad \texttt{if mask}(I) \ne0\f] where `I` is a multi-dimensional index of
-array elements. In case of multi-channel arrays, each channel is processed
-independently.
-
-The first function in the list above can be replaced with matrix expressions:
-@code{.cpp}
-    dst = src1 + src2;
-    dst += src1; // equivalent to add(dst, src1, dst);
-@endcode
-The input arrays and the output array can all have the same or different depths.
-For example, you can add a 16-bit unsigned array to a 8-bit signed array and
-store the sum as a 32-bit floating-point array. Depth of the output array is
-determined by the dtype parameter. In the second and third cases above, as well
-as in the first case, when src1.depth() == src2.depth(), dtype can be set to the
-default -1. In this case, the output array will have the same depth as the input
-array, be it src1, src2 or both.
-@note Saturation is not applied when the output array has the depth CV_32S. You
-may even get result of an incorrect sign in the case of overflow.
-@note (Python) Be careful to difference behaviour between src1/src2 are single
-number and they are tuple/array. `add(src,X)` means `add(src,(X,X,X,X))`.
-`add(src,(X,))` means `add(src,(X,0,0,0))`.
-@param src1 first input array or a scalar.
-@param src2 second input array or a scalar.
-@param dst output array that has the same size and number of channels as the
-input array(s); the depth is defined by dtype or src1/src2.
-@param mask optional operation mask - 8-bit single channel array, that specifies
-elements of the output array to be changed.
-@param dtype optional depth of the output array (see the discussion below).
-@sa subtract, addWeighted, scaleAdd, Mat::convertTo
-*/
-CV_EXPORTS_W void add(InputArray src1, InputArray src2, OutputArray dst,
-                      InputArray mask = noArray(), int dtype = -1);
-
-/** @brief Calculates the per-element difference between two arrays or array and
-a scalar.
-
-The function subtract calculates:
-- Difference between two arrays, when both input arrays have the same size and
-the same number of channels:
-    \f[\texttt{dst}(I) =  \texttt{saturate} ( \texttt{src1}(I) -
-\texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\f]
-- Difference between an array and a scalar, when src2 is constructed from Scalar
-or has the same number of elements as `src1.channels()`:
-    \f[\texttt{dst}(I) =  \texttt{saturate} ( \texttt{src1}(I) -  \texttt{src2}
-) \quad \texttt{if mask}(I) \ne0\f]
-- Difference between a scalar and an array, when src1 is constructed from Scalar
-or has the same number of elements as `src2.channels()`:
-    \f[\texttt{dst}(I) =  \texttt{saturate} ( \texttt{src1} -  \texttt{src2}(I)
-) \quad \texttt{if mask}(I) \ne0\f]
-- The reverse difference between a scalar and an array in the case of `SubRS`:
-    \f[\texttt{dst}(I) =  \texttt{saturate} ( \texttt{src2} -  \texttt{src1}(I)
-) \quad \texttt{if mask}(I) \ne0\f] where I is a multi-dimensional index of
-array elements. In case of multi-channel arrays, each channel is processed
-independently.
-
-The first function in the list above can be replaced with matrix expressions:
-@code{.cpp}
-    dst = src1 - src2;
-    dst -= src1; // equivalent to subtract(dst, src1, dst);
-@endcode
-The input arrays and the output array can all have the same or different depths.
-For example, you can subtract to 8-bit unsigned arrays and store the difference
-in a 16-bit signed array. Depth of the output array is determined by dtype
-parameter. In the second and third cases above, as well as in the first case,
-when src1.depth() == src2.depth(), dtype can be set to the default -1. In this
-case the output array will have the same depth as the input array, be it src1,
-src2 or both.
-@note Saturation is not applied when the output array has the depth CV_32S. You
-may even get result of an incorrect sign in the case of overflow.
-@note (Python) Be careful to difference behaviour between src1/src2 are single
-number and they are tuple/array. `subtract(src,X)` means
-`subtract(src,(X,X,X,X))`. `subtract(src,(X,))` means `subtract(src,(X,0,0,0))`.
-@param src1 first input array or a scalar.
-@param src2 second input array or a scalar.
-@param dst output array of the same size and the same number of channels as the
-input array.
-@param mask optional operation mask; this is an 8-bit single channel array that
-specifies elements of the output array to be changed.
-@param dtype optional depth of the output array
-@sa  add, addWeighted, scaleAdd, Mat::convertTo
-  */
-CV_EXPORTS_W void subtract(InputArray src1, InputArray src2, OutputArray dst,
-                           InputArray mask = noArray(), int dtype = -1);
-
-/** @brief Calculates the per-element scaled product of two arrays.
-
-The function multiply calculates the per-element product of two arrays:
-
-\f[\texttt{dst} (I)= \texttt{saturate} ( \texttt{scale} \cdot \texttt{src1} (I)
-\cdot \texttt{src2} (I))\f]
-
-There is also a @ref MatrixExpressions -friendly variant of the first function.
-See Mat::mul .
-
-For a not-per-element matrix product, see gemm .
-
-@note Saturation is not applied when the output array has the depth
-CV_32S. You may even get result of an incorrect sign in the case of
-overflow.
-@note (Python) Be careful to difference behaviour between src1/src2 are single
-number and they are tuple/array. `multiply(src,X)` means
-`multiply(src,(X,X,X,X))`. `multiply(src,(X,))` means `multiply(src,(X,0,0,0))`.
-@param src1 first input array.
-@param src2 second input array of the same size and the same type as src1.
-@param dst output array of the same size and type as src1.
-@param scale optional scale factor.
-@param dtype optional depth of the output array
-@sa add, subtract, divide, scaleAdd, addWeighted, accumulate, accumulateProduct,
-accumulateSquare, Mat::convertTo
-*/
-CV_EXPORTS_W void multiply(InputArray src1, InputArray src2, OutputArray dst,
-                           double scale = 1, int dtype = -1);
-
-/** @brief Performs per-element division of two arrays or a scalar by an array.
-
-The function cv::divide divides one array by another:
-\f[\texttt{dst(I) = saturate(src1(I)*scale/src2(I))}\f]
-or a scalar by an array when there is no src1 :
-\f[\texttt{dst(I) = saturate(scale/src2(I))}\f]
-
-Different channels of multi-channel arrays are processed independently.
-
-For integer types when src2(I) is zero, dst(I) will also be zero.
-
-@note In case of floating point data there is no special defined behavior for
-zero src2(I) values. Regular floating-point division is used. Expect correct
-IEEE-754 behaviour for floating-point data (with NaN, Inf result values).
-
-@note Saturation is not applied when the output array has the depth CV_32S. You
-may even get result of an incorrect sign in the case of overflow.
-@note (Python) Be careful to difference behaviour between src1/src2 are single
-number and they are tuple/array. `divide(src,X)` means `divide(src,(X,X,X,X))`.
-`divide(src,(X,))` means `divide(src,(X,0,0,0))`.
-@param src1 first input array.
-@param src2 second input array of the same size and type as src1.
-@param scale scalar factor.
-@param dst output array of the same size and type as src2.
-@param dtype optional depth of the output array; if -1, dst will have depth
-src2.depth(), but in case of an array-by-array division, you can only pass -1
-when src1.depth()==src2.depth().
-@sa  multiply, add, subtract
-*/
-CV_EXPORTS_W void divide(InputArray src1, InputArray src2, OutputArray dst,
-                         double scale = 1, int dtype = -1);
-
-/** @overload */
-CV_EXPORTS_W void divide(double scale, InputArray src2, OutputArray dst,
-                         int dtype = -1);
-
-/** @brief Calculates the sum of a scaled array and another array.
-
-The function scaleAdd is one of the classical primitive linear algebra
-operations, known as DAXPY or SAXPY in
-[BLAS](http://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms). It
-calculates the sum of a scaled array and another array:
-\f[\texttt{dst} (I)= \texttt{scale} \cdot \texttt{src1} (I) +  \texttt{src2}
-(I)\f] The function can also be emulated with a matrix expression, for example:
-@code{.cpp}
-    Mat A(3, 3, CV_64F);
-    ...
-    A.row(0) = A.row(1)*2 + A.row(2);
-@endcode
-@param src1 first input array.
-@param alpha scale factor for the first array.
-@param src2 second input array of the same size and type as src1.
-@param dst output array of the same size and type as src1.
-@sa add, addWeighted, subtract, Mat::dot, Mat::convertTo
-*/
-CV_EXPORTS_W void scaleAdd(InputArray src1, double alpha, InputArray src2,
-                           OutputArray dst);
-
-/** @brief Calculates the weighted sum of two arrays.
-
-The function addWeighted calculates the weighted sum of two arrays as follows:
-\f[\texttt{dst} (I)= \texttt{saturate} ( \texttt{src1} (I)* \texttt{alpha} +
-\texttt{src2} (I)* \texttt{beta} +  \texttt{gamma} )\f] where I is a
-multi-dimensional index of array elements. In case of multi-channel arrays, each
-channel is processed independently.
-The function can be replaced with a matrix expression:
-@code{.cpp}
-    dst = src1*alpha + src2*beta + gamma;
-@endcode
-@note Saturation is not applied when the output array has the depth CV_32S. You
-may even get result of an incorrect sign in the case of overflow.
-@param src1 first input array.
-@param alpha weight of the first array elements.
-@param src2 second input array of the same size and channel number as src1.
-@param beta weight of the second array elements.
-@param gamma scalar added to each sum.
-@param dst output array that has the same size and number of channels as the
-input arrays.
-@param dtype optional depth of the output array; when both input arrays have the
-same depth, dtype can be set to -1, which will be equivalent to src1.depth().
-@sa  add, subtract, scaleAdd, Mat::convertTo
-*/
-CV_EXPORTS_W void addWeighted(InputArray src1, double alpha, InputArray src2,
-                              double beta, double gamma, OutputArray dst,
-                              int dtype = -1);
-
-/** @brief Scales, calculates absolute values, and converts the result to 8-bit.
-
-On each element of the input array, the function convertScaleAbs
-performs three operations sequentially: scaling, taking an absolute
-value, conversion to an unsigned 8-bit type:
-\f[\texttt{dst} (I)= \texttt{saturate\_cast<uchar>} (| \texttt{src} (I)*
-\texttt{alpha} +  \texttt{beta} |)\f] In case of multi-channel arrays, the
-function processes each channel independently. When the output is not 8-bit, the
-operation can be emulated by calling the Mat::convertTo method (or by using
-matrix expressions) and then by calculating an absolute value of the result. For
-example:
-@code{.cpp}
-    Mat_<float> A(30,30);
-    randu(A, Scalar(-100), Scalar(100));
-    Mat_<float> B = A*5 + 3;
-    B = abs(B);
-    // Mat_<float> B = abs(A*5+3) will also do the job,
-    // but it will allocate a temporary matrix
-@endcode
-@param src input array.
-@param dst output array.
-@param alpha optional scale factor.
-@param beta optional delta added to the scaled values.
-@sa  Mat::convertTo, cv::abs(const Mat&)
-*/
-CV_EXPORTS_W void convertScaleAbs(InputArray src, OutputArray dst,
-                                  double alpha = 1, double beta = 0);
-
-/** @brief Converts an array to half precision floating number.
-
-This function converts FP32 (single precision floating point) from/to FP16 (half
-precision floating point). CV_16S format is used to represent FP16 data. There
-are two use modes (src -> dst): CV_32F -> CV_16S and CV_16S -> CV_32F. The input
-array has to have type of CV_32F or CV_16S to represent the bit depth. If the
-input array is neither of them, the function will raise an error. The format of
-half precision floating point is defined in IEEE 754-2008.
-
-@param src input array.
-@param dst output array.
-
-@deprecated Use Mat::convertTo with CV_16F instead.
-*/
-CV_EXPORTS_W void convertFp16(InputArray src, OutputArray dst);
-
-/** @example
-samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp Check
-@ref tutorial_how_to_scan_images "the corresponding tutorial" for more details
-*/
-
-/** @brief Performs a look-up table transform of an array.
-
-The function LUT fills the output array with values from the look-up table.
-Indices of the entries are taken from the input array. That is, the function
-processes each element of src as follows:
-\f[\texttt{dst} (I)  \leftarrow \texttt{lut(src(I) + d)}\f]
-where
-\f[d =  \fork{0}{if \(\texttt{src}\) has depth \(\texttt{CV_8U}\)}{128}{if
-\(\texttt{src}\) has depth \(\texttt{CV_8S}\)}\f]
-@param src input array of 8-bit elements.
-@param lut look-up table of 256 elements; in case of multi-channel input array,
-the table should either have a single channel (in this case the same table is
-used for all channels) or the same number of channels as in the input array.
-@param dst output array of the same size and number of channels as src, and the
-same depth as lut.
-@sa  convertScaleAbs, Mat::convertTo
-*/
-CV_EXPORTS_W void LUT(InputArray src, InputArray lut, OutputArray dst);
-
-/** @brief Calculates the sum of array elements.
-
-The function cv::sum calculates and returns the sum of array elements,
-independently for each channel.
-@param src input array that must have from 1 to 4 channels.
-@sa  countNonZero, mean, meanStdDev, norm, minMaxLoc, reduce
-*/
-CV_EXPORTS_AS(sumElems) Scalar sum(InputArray src);
-
-/** @brief Checks for the presence of at least one non-zero array element.
-
-The function returns whether there are non-zero elements in src
-
-The function do not work with multi-channel arrays. If you need to check
-non-zero array elements across all the channels, use Mat::reshape first to
-reinterpret the array as single-channel. Or you may extract the particular
-channel using either extractImageCOI, or mixChannels, or split.
-
-@note
-- If the location of non-zero array elements is important, @ref findNonZero is
-helpful.
-- If the count of non-zero array elements is important, @ref countNonZero is
-helpful.
-@param src single-channel array.
-@sa  mean, meanStdDev, norm, minMaxLoc, calcCovarMatrix
-@sa  findNonZero, countNonZero
-*/
-CV_EXPORTS_W bool hasNonZero(InputArray src);
-
-/** @brief Counts non-zero array elements.
-
-The function returns the number of non-zero elements in src :
-\f[\sum _{I: \; \texttt{src} (I) \ne0 } 1\f]
-
-The function do not work with multi-channel arrays. If you need to count
-non-zero array elements across all the channels, use Mat::reshape first to
-reinterpret the array as single-channel. Or you may extract the particular
-channel using either extractImageCOI, or mixChannels, or split.
-
-@note
-- If only whether there are non-zero elements is important, @ref hasNonZero is
-helpful.
-- If the location of non-zero array elements is important, @ref findNonZero is
-helpful.
-@param src single-channel array.
-@sa  mean, meanStdDev, norm, minMaxLoc, calcCovarMatrix
-@sa  findNonZero, hasNonZero
-*/
-CV_EXPORTS_W int countNonZero(InputArray src);
-
-/** @brief Returns the list of locations of non-zero pixels
-
-Given a binary matrix (likely returned from an operation such
-as threshold(), compare(), >, ==, etc, return all of
-the non-zero indices as a cv::Mat or std::vector<cv::Point> (x,y)
-For example:
-@code{.cpp}
-    cv::Mat binaryImage; // input, binary image
-    cv::Mat locations;   // output, locations of non-zero pixels
-    cv::findNonZero(binaryImage, locations);
-
-    // access pixel coordinates
-    Point pnt = locations.at<Point>(i);
-@endcode
-or
-@code{.cpp}
-    cv::Mat binaryImage; // input, binary image
-    vector<Point> locations;   // output, locations of non-zero pixels
-    cv::findNonZero(binaryImage, locations);
-
-    // access pixel coordinates
-    Point pnt = locations[i];
-@endcode
-
-The function do not work with multi-channel arrays. If you need to find non-zero
-elements across all the channels, use Mat::reshape first to reinterpret the
-array as single-channel. Or you may extract the particular channel using either
-extractImageCOI, or mixChannels, or split.
-
-@note
-- If only count of non-zero array elements is important, @ref countNonZero is
-helpful.
-- If only whether there are non-zero elements is important, @ref hasNonZero is
-helpful.
-@param src single-channel array
-@param idx the output array, type of cv::Mat or std::vector<Point>,
-corresponding to non-zero indices in the input
-@sa  countNonZero, hasNonZero
-*/
-CV_EXPORTS_W void findNonZero(InputArray src, OutputArray idx);
-
-/** @brief Calculates an average (mean) of array elements.
-
-The function cv::mean calculates the mean value M of array elements,
-independently for each channel, and return it:
-\f[\begin{array}{l} N =  \sum _{I: \; \texttt{mask} (I) \ne 0} 1 \\ M_c =  \left
-( \sum _{I: \; \texttt{mask} (I) \ne 0}{ \texttt{mtx} (I)_c} \right )/N
-\end{array}\f] When all the mask elements are 0's, the function returns
-Scalar::all(0)
-@param src input array that should have from 1 to 4 channels so that the result
-can be stored in Scalar_ .
-@param mask optional operation mask.
-@sa  countNonZero, meanStdDev, norm, minMaxLoc
-*/
-CV_EXPORTS_W Scalar mean(InputArray src, InputArray mask = noArray());
-
-/** Calculates a mean and standard deviation of array elements.
-
-The function cv::meanStdDev calculates the mean and the standard deviation M
-of array elements independently for each channel and returns it via the
-output parameters:
-\f[\begin{array}{l} N =  \sum _{I, \texttt{mask} (I)  \ne 0} 1 \\ \texttt{mean}
-_c =  \frac{\sum_{ I: \; \texttt{mask}(I) \ne 0} \texttt{src} (I)_c}{N}
-\\ \texttt{stddev} _c =  \sqrt{\frac{\sum_{ I: \; \texttt{mask}(I) \ne 0} \left
-( \texttt{src} (I)_c -  \texttt{mean} _c \right )^2}{N}} \end{array}\f] When all
-the mask elements are 0's, the function returns mean=stddev=Scalar::all(0).
-@note The calculated standard deviation is only the diagonal of the
-complete normalized covariance matrix. If the full matrix is needed, you
-can reshape the multi-channel array M x N to the single-channel array
-M\*N x mtx.channels() (only possible when the matrix is continuous) and
-then pass the matrix to calcCovarMatrix .
-@param src input array that should have from 1 to 4 channels so that the results
-can be stored in Scalar_ 's.
-@param mean output parameter: calculated mean value.
-@param stddev output parameter: calculated standard deviation.
-@param mask optional operation mask.
-@sa  countNonZero, mean, norm, minMaxLoc, calcCovarMatrix
-*/
-CV_EXPORTS_W void meanStdDev(InputArray src, OutputArray mean,
-                             OutputArray stddev, InputArray mask = noArray());
-
-/** @brief Calculates the  absolute norm of an array.
-
-This version of #norm calculates the absolute norm of src1. The type of norm to
-calculate is specified using #NormTypes.
-
-As example for one array consider the function \f$r(x)= \begin{pmatrix} x \\ 1-x
-\end{pmatrix}, x \in [-1;1]\f$. The \f$ L_{1}, L_{2} \f$ and \f$ L_{\infty} \f$
-norm for the sample value \f$r(-1) = \begin{pmatrix} -1 \\ 2 \end{pmatrix}\f$ is
-calculated as follows
-\f{align*}
-    \| r(-1) \|_{L_1} &= |-1| + |2| = 3 \\
-    \| r(-1) \|_{L_2} &= \sqrt{(-1)^{2} + (2)^{2}} = \sqrt{5} \\
-    \| r(-1) \|_{L_\infty} &= \max(|-1|,|2|) = 2
-\f}
-and for \f$r(0.5) = \begin{pmatrix} 0.5 \\ 0.5 \end{pmatrix}\f$ the calculation
-is
-\f{align*}
-    \| r(0.5) \|_{L_1} &= |0.5| + |0.5| = 1 \\
-    \| r(0.5) \|_{L_2} &= \sqrt{(0.5)^{2} + (0.5)^{2}} = \sqrt{0.5} \\
-    \| r(0.5) \|_{L_\infty} &= \max(|0.5|,|0.5|) = 0.5.
-\f}
-The following graphic shows all values for the three norm functions \f$\| r(x)
-\|_{L_1}, \| r(x) \|_{L_2}\f$ and \f$\| r(x) \|_{L_\infty}\f$. It is notable
-that the \f$ L_{1} \f$ norm forms the upper and the \f$ L_{\infty} \f$ norm
-forms the lower border for the example function \f$ r(x) \f$.
-![Graphs for the different norm functions from the above
-example](pics/NormTypes_OneArray_1-2-INF.png)
-
-When the mask parameter is specified and it is not empty, the norm is
-
-If normType is not specified, #NORM_L2 is used.
-calculated only over the region specified by the mask.
-
-Multi-channel input arrays are treated as single-channel arrays, that is,
-the results for all channels are combined.
-
-Hamming norms can only be calculated with CV_8U depth arrays.
-
-@param src1 first input array.
-@param normType type of the norm (see #NormTypes).
-@param mask optional operation mask; it must have the same size as src1 and
-CV_8UC1 type.
-*/
-CV_EXPORTS_W double norm(InputArray src1, int normType = NORM_L2,
-                         InputArray mask = noArray());
-
-/** @brief Calculates an absolute difference norm or a relative difference norm.
-
-This version of cv::norm calculates the absolute difference norm
-or the relative difference norm of arrays src1 and src2.
-The type of norm to calculate is specified using #NormTypes.
-
-@param src1 first input array.
-@param src2 second input array of the same size and the same type as src1.
-@param normType type of the norm (see #NormTypes).
-@param mask optional operation mask; it must have the same size as src1 and
-CV_8UC1 type.
-*/
-CV_EXPORTS_W double norm(InputArray src1, InputArray src2,
-                         int normType = NORM_L2, InputArray mask = noArray());
-/** @overload
-@param src first input array.
-@param normType type of the norm (see #NormTypes).
-*/
-CV_EXPORTS double norm(const SparseMat &src, int normType);
-
-/** @brief Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric.
-
-This function calculates the Peak Signal-to-Noise Ratio (PSNR) image quality
-metric in decibels (dB), between two input arrays src1 and src2. The arrays must
-have the same type.
-
-The PSNR is calculated as follows:
-
-\f[
-\texttt{PSNR} = 10 \cdot \log_{10}{\left( \frac{R^2}{MSE} \right) }
-\f]
-
-where R is the maximum integer value of depth (e.g. 255 in the case of CV_8U
-data) and MSE is the mean squared error between the two arrays.
-
-@param src1 first input array.
-@param src2 second input array of the same size as src1.
-@param R the maximum pixel value (255 by default)
-
-  */
-CV_EXPORTS_W double PSNR(InputArray src1, InputArray src2, double R = 255.);
-
-/** @brief naive nearest neighbor finder
-
-see http://en.wikipedia.org/wiki/Nearest_neighbor_search
-@todo document
-  */
-CV_EXPORTS_W void batchDistance(InputArray src1, InputArray src2,
-                                OutputArray dist, int dtype, OutputArray nidx,
-                                int normType = NORM_L2, int K = 0,
-                                InputArray mask = noArray(), int update = 0,
-                                bool crosscheck = false);
-
-/** @brief Normalizes the norm or value range of an array.
-
-The function cv::normalize normalizes scale and shift the input array elements
-so that
-\f[\| \texttt{dst} \| _{L_p}= \texttt{alpha}\f]
-(where p=Inf, 1 or 2) when normType=NORM_INF, NORM_L1, or NORM_L2, respectively;
-or so that
-\f[\min _I  \texttt{dst} (I)= \texttt{alpha} , \, \, \max _I  \texttt{dst} (I)=
-\texttt{beta}\f]
-
-when normType=NORM_MINMAX (for dense arrays only). The optional mask specifies a
-sub-array to be normalized. This means that the norm or min-n-max are calculated
-over the sub-array, and then this sub-array is modified to be normalized. If you
-want to only use the mask to calculate the norm or min-max but modify the whole
-array, you can use norm and Mat::convertTo.
-
-In case of sparse matrices, only the non-zero values are analyzed and
-transformed. Because of this, the range transformation for sparse matrices is
-not allowed since it can shift the zero level.
-
-Possible usage with some positive example data:
-@code{.cpp}
-    vector<double> positiveData = { 2.0, 8.0, 10.0 };
-    vector<double> normalizedData_l1, normalizedData_l2, normalizedData_inf,
-normalizedData_minmax;
-
-    // Norm to probability (total count)
-    // sum(numbers) = 20.0
-    // 2.0      0.1     (2.0/20.0)
-    // 8.0      0.4     (8.0/20.0)
-    // 10.0     0.5     (10.0/20.0)
-    normalize(positiveData, normalizedData_l1, 1.0, 0.0, NORM_L1);
-
-    // Norm to unit vector: ||positiveData|| = 1.0
-    // 2.0      0.15
-    // 8.0      0.62
-    // 10.0     0.77
-    normalize(positiveData, normalizedData_l2, 1.0, 0.0, NORM_L2);
-
-    // Norm to max element
-    // 2.0      0.2     (2.0/10.0)
-    // 8.0      0.8     (8.0/10.0)
-    // 10.0     1.0     (10.0/10.0)
-    normalize(positiveData, normalizedData_inf, 1.0, 0.0, NORM_INF);
-
-    // Norm to range [0.0;1.0]
-    // 2.0      0.0     (shift to left border)
-    // 8.0      0.75    (6.0/8.0)
-    // 10.0     1.0     (shift to right border)
-    normalize(positiveData, normalizedData_minmax, 1.0, 0.0, NORM_MINMAX);
-@endcode
-
-@param src input array.
-@param dst output array of the same size as src .
-@param alpha norm value to normalize to or the lower range boundary in case of
-the range normalization.
-@param beta upper range boundary in case of the range normalization; it is not
-used for the norm normalization.
-@param norm_type normalization type (see cv::NormTypes).
-@param dtype when negative, the output array has the same type as src;
-otherwise, it has the same number of channels as src and the depth
-=CV_MAT_DEPTH(dtype).
-@param mask optional operation mask.
-@sa norm, Mat::convertTo, SparseMat::convertTo
-*/
-CV_EXPORTS_W void normalize(InputArray src, InputOutputArray dst,
-                            double alpha = 1, double beta = 0,
-                            int norm_type = NORM_L2, int dtype = -1,
-                            InputArray mask = noArray());
-
-/** @overload
-@param src input array.
-@param dst output array of the same size as src .
-@param alpha norm value to normalize to or the lower range boundary in case of
-the range normalization.
-@param normType normalization type (see cv::NormTypes).
-*/
-CV_EXPORTS void normalize(const SparseMat &src, SparseMat &dst, double alpha,
-                          int normType);
-
-/** @brief Finds the global minimum and maximum in an array.
-
-The function cv::minMaxLoc finds the minimum and maximum element values and
-their positions. The extrema are searched across the whole array or, if mask is
-not an empty array, in the specified array region.
-
-In C++, if the input is multi-channel, you should omit the minLoc, maxLoc, and
-mask arguments (i.e. leave them as NULL, NULL, and noArray() respectively).
-These arguments are not supported for multi-channel input arrays. If working
-with multi-channel input and you need the minLoc, maxLoc, or mask arguments,
-then use Mat::reshape first to reinterpret the array as single-channel.
-Alternatively, you can extract the particular channel using either
-extractImageCOI, mixChannels, or split.
-
-In Python, multi-channel input is not supported at all due to a limitation in
-the binding generation process (there is no way to set minLoc and maxLoc to
-NULL). A workaround is to operate on each channel individually or to use NumPy
-to achieve the same functionality.
-
-@param src input single-channel array.
-@param minVal pointer to the returned minimum value; NULL is used if not
-required.
-@param maxVal pointer to the returned maximum value; NULL is used if not
-required.
-@param minLoc pointer to the returned minimum location (in 2D case); NULL is
-used if not required.
-@param maxLoc pointer to the returned maximum location (in 2D case); NULL is
-used if not required.
-@param mask optional mask used to select a sub-array.
-@sa max, min, reduceArgMin, reduceArgMax, compare, inRange, extractImageCOI,
-mixChannels, split, Mat::reshape
-*/
-CV_EXPORTS_W void minMaxLoc(InputArray src, CV_OUT double *minVal,
-                            CV_OUT double *maxVal = 0, CV_OUT Point *minLoc = 0,
-                            CV_OUT Point *maxLoc = 0,
-                            InputArray mask = noArray());
-
-/**
- * @brief Finds indices of min elements along provided axis
- *
- * @note
- *      - If input or output array is not continuous, this function will create
- * an internal copy.
- *      - NaN handling is left unspecified, see patchNaNs().
- *      - The returned index is always in bounds of input matrix.
- *
- * @param src input single-channel array.
- * @param dst output array of type CV_32SC1 with the same dimensionality as src,
- * except for axis being reduced - it should be set to 1.
- * @param lastIndex whether to get the index of first or last occurrence of min.
- * @param axis axis to reduce along.
- * @sa reduceArgMax, minMaxLoc, min, max, compare, reduce
- */
-CV_EXPORTS_W void reduceArgMin(InputArray src, OutputArray dst, int axis,
-                               bool lastIndex = false);
-
-/**
- * @brief Finds indices of max elements along provided axis
- *
- * @note
- *      - If input or output array is not continuous, this function will create
- * an internal copy.
- *      - NaN handling is left unspecified, see patchNaNs().
- *      - The returned index is always in bounds of input matrix.
- *
- * @param src input single-channel array.
- * @param dst output array of type CV_32SC1 with the same dimensionality as src,
- * except for axis being reduced - it should be set to 1.
- * @param lastIndex whether to get the index of first or last occurrence of max.
- * @param axis axis to reduce along.
- * @sa reduceArgMin, minMaxLoc, min, max, compare, reduce
- */
-CV_EXPORTS_W void reduceArgMax(InputArray src, OutputArray dst, int axis,
-                               bool lastIndex = false);
-
-/** @brief Finds the global minimum and maximum in an array
-
-The function cv::minMaxIdx finds the minimum and maximum element values and
-their positions. The extremums are searched across the whole array or, if mask
-is not an empty array, in the specified array region. In case of a sparse
-matrix, the minimum is found among non-zero elements only. Multi-channel input
-is supported without mask and extremums indexes (should be nullptr).
-@note When minIdx is not NULL, it must have at least 2 elements (as well as
-maxIdx), even if src is a single-row or single-column matrix. In OpenCV
-(following MATLAB) each array has at least 2 dimensions, i.e. single-column
-matrix is Mx1 matrix (and therefore minIdx/maxIdx will be (i1,0)/(i2,0)) and
-single-row matrix is 1xN matrix (and therefore minIdx/maxIdx will be
-(0,j1)/(0,j2)).
-@param src input single-channel array.
-@param minVal pointer to the returned minimum value; NULL is used if not
-required.
-@param maxVal pointer to the returned maximum value; NULL is used if not
-required.
-@param minIdx pointer to the returned minimum location (in nD case); NULL is
-used if not required; Otherwise, it must point to an array of src.dims elements,
-the coordinates of the minimum element in each dimension are stored there
-sequentially.
-@param maxIdx pointer to the returned maximum location (in nD case). NULL is
-used if not required.
-@param mask specified array region
-*/
-CV_EXPORTS void minMaxIdx(InputArray src, double *minVal, double *maxVal = 0,
-                          int *minIdx = 0, int *maxIdx = 0,
-                          InputArray mask = noArray());
-
-/** @overload
-@param a input single-channel array.
-@param minVal pointer to the returned minimum value; NULL is used if not
-required.
-@param maxVal pointer to the returned maximum value; NULL is used if not
-required.
-@param minIdx pointer to the returned minimum location (in nD case); NULL is
-used if not required; Otherwise, it must point to an array of src.dims elements,
-the coordinates of the minimum element in each dimension are stored there
-sequentially.
-@param maxIdx pointer to the returned maximum location (in nD case). NULL is
-used if not required.
-*/
-CV_EXPORTS void minMaxLoc(const SparseMat &a, double *minVal, double *maxVal,
-                          int *minIdx = 0, int *maxIdx = 0);
-
-/** @brief Reduces a matrix to a vector.
-
-The function #reduce reduces the matrix to a vector by treating the matrix
-rows/columns as a set of 1D vectors and performing the specified operation on
-the vectors until a single row/column is obtained. For example, the function can
-be used to compute horizontal and vertical projections of a raster image. In
-case of #REDUCE_MAX and #REDUCE_MIN, the output image should have the same type
-as the source one. In case of #REDUCE_SUM, #REDUCE_SUM2 and #REDUCE_AVG, the
-output may have a larger element bit-depth to preserve accuracy. And
-multi-channel arrays are also supported in these two reduction modes.
-
-The following code demonstrates its usage for a single channel matrix.
-@snippet snippets/core_reduce.cpp example
-
-And the following code demonstrates its usage for a two-channel matrix.
-@snippet snippets/core_reduce.cpp example2
-
-@param src input 2D matrix.
-@param dst output vector. Its size and type is defined by dim and dtype
-parameters.
-@param dim dimension index along which the matrix is reduced. 0 means that the
-matrix is reduced to a single row. 1 means that the matrix is reduced to a
-single column.
-@param rtype reduction operation that could be one of #ReduceTypes
-@param dtype when negative, the output vector will have the same type as the
-input matrix, otherwise, its type will be CV_MAKE_TYPE(CV_MAT_DEPTH(dtype),
-src.channels()).
-@sa repeat, reduceArgMin, reduceArgMax
-*/
-CV_EXPORTS_W void reduce(InputArray src, OutputArray dst, int dim, int rtype,
-                         int dtype = -1);
-
-/** @brief Creates one multi-channel array out of several single-channel ones.
-
-The function cv::merge merges several arrays to make a single multi-channel
-array. That is, each element of the output array will be a concatenation of the
-elements of the input arrays, where elements of i-th input array are treated as
-mv[i].channels()-element vectors.
-
-The function cv::split does the reverse operation. If you need to shuffle
-channels in some other advanced way, use cv::mixChannels.
-
-The following example shows how to merge 3 single channel matrices into a single
-3-channel matrix.
-@snippet snippets/core_merge.cpp example
-
-@param mv input array of matrices to be merged; all the matrices in mv must have
-the same size and the same depth.
-@param count number of input matrices when mv is a plain C array; it must be
-greater than zero.
-@param dst output array of the same size and the same depth as mv[0]; The number
-of channels will be equal to the parameter count.
-@sa  mixChannels, split, Mat::reshape
-*/
-CV_EXPORTS void merge(const Mat *mv, size_t count, OutputArray dst);
-
-/** @overload
-@param mv input vector of matrices to be merged; all the matrices in mv must
-have the same size and the same depth.
-@param dst output array of the same size and the same depth as mv[0]; The number
-of channels will be the total number of channels in the matrix array.
-  */
-CV_EXPORTS_W void merge(InputArrayOfArrays mv, OutputArray dst);
-
-/** @brief Divides a multi-channel array into several single-channel arrays.
-
-The function cv::split splits a multi-channel array into separate single-channel
-arrays:
-\f[\texttt{mv} [c](I) =  \texttt{src} (I)_c\f]
-If you need to extract a single channel or do some other sophisticated channel
-permutation, use mixChannels.
-
-The following example demonstrates how to split a 3-channel matrix into 3 single
-channel matrices.
-@snippet snippets/core_split.cpp example
-
-@param src input multi-channel array.
-@param mvbegin output array; the number of arrays must match src.channels(); the
-arrays themselves are reallocated, if needed.
-@sa merge, mixChannels, cvtColor
-*/
-CV_EXPORTS void split(const Mat &src, Mat *mvbegin);
-
-/** @overload
-@param m input multi-channel array.
-@param mv output vector of arrays; the arrays themselves are reallocated, if
-needed.
-*/
-CV_EXPORTS_W void split(InputArray m, OutputArrayOfArrays mv);
-
-/** @brief Copies specified channels from input arrays to the specified channels
-of output arrays.
-
-The function cv::mixChannels provides an advanced mechanism for shuffling image
-channels.
-
-cv::split,cv::merge,cv::extractChannel,cv::insertChannel and some forms of
-cv::cvtColor are partial cases of cv::mixChannels.
-
-In the example below, the code splits a 4-channel BGRA image into a 3-channel
-BGR (with B and R channels swapped) and a separate alpha-channel image:
-@code{.cpp}
-    Mat bgra( 100, 100, CV_8UC4, Scalar(255,0,0,255) );
-    Mat bgr( bgra.rows, bgra.cols, CV_8UC3 );
-    Mat alpha( bgra.rows, bgra.cols, CV_8UC1 );
-
-    // forming an array of matrices is a quite efficient operation,
-    // because the matrix data is not copied, only the headers
-    Mat out[] = { bgr, alpha };
-    // bgra[0] -> bgr[2], bgra[1] -> bgr[1],
-    // bgra[2] -> bgr[0], bgra[3] -> alpha[0]
-    int from_to[] = { 0,2, 1,1, 2,0, 3,3 };
-    mixChannels( &bgra, 1, out, 2, from_to, 4 );
-@endcode
-@note Unlike many other new-style C++ functions in OpenCV (see the introduction
-section and Mat::create ), cv::mixChannels requires the output arrays to be
-pre-allocated before calling the function.
-@param src input array or vector of matrices; all of the matrices must have the
-same size and the same depth.
-@param nsrcs number of matrices in `src`.
-@param dst output array or vector of matrices; all the matrices **must be
-allocated**; their size and depth must be the same as in `src[0]`.
-@param ndsts number of matrices in `dst`.
-@param fromTo array of index pairs specifying which channels are copied and
-where; fromTo[k\*2] is a 0-based index of the input channel in src,
-fromTo[k\*2+1] is an index of the output channel in dst; the continuous channel
-numbering is used: the first input image channels are indexed from 0 to
-src[0].channels()-1, the second input image channels are indexed from
-src[0].channels() to src[0].channels() + src[1].channels()-1, and so on, the
-same scheme is used for the output image channels; as a special case, when
-fromTo[k\*2] is negative, the corresponding output channel is filled with zero .
-@param npairs number of index pairs in `fromTo`.
-@sa split, merge, extractChannel, insertChannel, cvtColor
-*/
-CV_EXPORTS void mixChannels(const Mat *src, size_t nsrcs, Mat *dst,
-                            size_t ndsts, const int *fromTo, size_t npairs);
-
-/** @overload
-@param src input array or vector of matrices; all of the matrices must have the
-same size and the same depth.
-@param dst output array or vector of matrices; all the matrices **must be
-allocated**; their size and depth must be the same as in src[0].
-@param fromTo array of index pairs specifying which channels are copied and
-where; fromTo[k\*2] is a 0-based index of the input channel in src,
-fromTo[k\*2+1] is an index of the output channel in dst; the continuous channel
-numbering is used: the first input image channels are indexed from 0 to
-src[0].channels()-1, the second input image channels are indexed from
-src[0].channels() to src[0].channels() + src[1].channels()-1, and so on, the
-same scheme is used for the output image channels; as a special case, when
-fromTo[k\*2] is negative, the corresponding output channel is filled with zero .
-@param npairs number of index pairs in fromTo.
-*/
-CV_EXPORTS void mixChannels(InputArrayOfArrays src,
-                            InputOutputArrayOfArrays dst, const int *fromTo,
-                            size_t npairs);
-
-/** @overload
-@param src input array or vector of matrices; all of the matrices must have the
-same size and the same depth.
-@param dst output array or vector of matrices; all the matrices **must be
-allocated**; their size and depth must be the same as in src[0].
-@param fromTo array of index pairs specifying which channels are copied and
-where; fromTo[k\*2] is a 0-based index of the input channel in src,
-fromTo[k\*2+1] is an index of the output channel in dst; the continuous channel
-numbering is used: the first input image channels are indexed from 0 to
-src[0].channels()-1, the second input image channels are indexed from
-src[0].channels() to src[0].channels() + src[1].channels()-1, and so on, the
-same scheme is used for the output image channels; as a special case, when
-fromTo[k\*2] is negative, the corresponding output channel is filled with zero .
-*/
-CV_EXPORTS_W void mixChannels(InputArrayOfArrays src,
-                              InputOutputArrayOfArrays dst,
-                              const std::vector<int> &fromTo);
-
-/** @brief Extracts a single channel from src (coi is 0-based index)
-@param src input array
-@param dst output array
-@param coi index of channel to extract
-@sa mixChannels, split
-*/
-CV_EXPORTS_W void extractChannel(InputArray src, OutputArray dst, int coi);
-
-/** @brief Inserts a single channel to dst (coi is 0-based index)
-@param src input array
-@param dst output array
-@param coi index of channel for insertion
-@sa mixChannels, merge
-*/
-CV_EXPORTS_W void insertChannel(InputArray src, InputOutputArray dst, int coi);
-
-/** @brief Flips a 2D array around vertical, horizontal, or both axes.
-
-The function cv::flip flips the array in one of three different ways (row
-and column indices are 0-based):
-\f[\texttt{dst} _{ij} =
-\left\{
-\begin{array}{l l}
-\texttt{src} _{\texttt{src.rows}-i-1,j} & if\;  \texttt{flipCode} = 0 \\
-\texttt{src} _{i, \texttt{src.cols} -j-1} & if\;  \texttt{flipCode} > 0 \\
-\texttt{src} _{ \texttt{src.rows} -i-1, \texttt{src.cols} -j-1} & if\;
-\texttt{flipCode} < 0 \\
-\end{array}
-\right.\f]
-The example scenarios of using the function are the following:
-*   Vertical flipping of the image (flipCode == 0) to switch between
-    top-left and bottom-left image origin. This is a typical operation
-    in video processing on Microsoft Windows\* OS.
-*   Horizontal flipping of the image with the subsequent horizontal
-    shift and absolute difference calculation to check for a
-    vertical-axis symmetry (flipCode \> 0).
-*   Simultaneous horizontal and vertical flipping of the image with
-    the subsequent shift and absolute difference calculation to check
-    for a central symmetry (flipCode \< 0).
-*   Reversing the order of point arrays (flipCode \> 0 or
-    flipCode == 0).
-@param src input array.
-@param dst output array of the same size and type as src.
-@param flipCode a flag to specify how to flip the array; 0 means
-flipping around the x-axis and positive value (for example, 1) means
-flipping around y-axis. Negative value (for example, -1) means flipping
-around both axes.
-@sa transpose, repeat, completeSymm
-*/
-CV_EXPORTS_W void flip(InputArray src, OutputArray dst, int flipCode);
-
-/** @brief Flips a n-dimensional at given axis
- *  @param src input array
- *  @param dst output array that has the same shape of src
- *  @param axis axis that performs a flip on. 0 <= axis < src.dims.
- */
-CV_EXPORTS_W void flipND(InputArray src, OutputArray dst, int axis);
-
-/** @brief Broadcast the given Mat to the given shape.
- * @param src input array
- * @param shape target shape. Should be a list of CV_32S numbers. Note that
- * negative values are not supported.
- * @param dst output array that has the given shape
- */
-CV_EXPORTS_W void broadcast(InputArray src, InputArray shape, OutputArray dst);
-
-enum RotateFlags {
-  ROTATE_90_CLOCKWISE = 0,        //!< Rotate 90 degrees clockwise
-  ROTATE_180 = 1,                 //!< Rotate 180 degrees clockwise
-  ROTATE_90_COUNTERCLOCKWISE = 2, //!< Rotate 270 degrees clockwise
-};
-/** @brief Rotates a 2D array in multiples of 90 degrees.
-The function cv::rotate rotates the array in one of three different ways:
-*   Rotate by 90 degrees clockwise (rotateCode = ROTATE_90_CLOCKWISE).
-*   Rotate by 180 degrees clockwise (rotateCode = ROTATE_180).
-*   Rotate by 270 degrees clockwise (rotateCode = ROTATE_90_COUNTERCLOCKWISE).
-@param src input array.
-@param dst output array of the same type as src.  The size is the same with
-ROTATE_180, and the rows and cols are switched for ROTATE_90_CLOCKWISE and
-ROTATE_90_COUNTERCLOCKWISE.
-@param rotateCode an enum to specify how to rotate the array; see the enum
-#RotateFlags
-@sa transpose, repeat, completeSymm, flip, RotateFlags
-*/
-CV_EXPORTS_W void rotate(InputArray src, OutputArray dst, int rotateCode);
-
-/** @brief Fills the output array with repeated copies of the input array.
-
-The function cv::repeat duplicates the input array one or more times along each
-of the two axes:
-\f[\texttt{dst} _{ij}= \texttt{src} _{i\mod src.rows, \; j\mod src.cols }\f]
-The second variant of the function is more convenient to use with @ref
-MatrixExpressions.
-@param src input array to replicate.
-@param ny Flag to specify how many times the `src` is repeated along the
-vertical axis.
-@param nx Flag to specify how many times the `src` is repeated along the
-horizontal axis.
-@param dst output array of the same type as `src`.
-@sa cv::reduce
-*/
-CV_EXPORTS_W void repeat(InputArray src, int ny, int nx, OutputArray dst);
-
-/** @overload
-@param src input array to replicate.
-@param ny Flag to specify how many times the `src` is repeated along the
-vertical axis.
-@param nx Flag to specify how many times the `src` is repeated along the
-horizontal axis.
-  */
-CV_EXPORTS Mat repeat(const Mat &src, int ny, int nx);
-
-/** @brief Applies horizontal concatenation to given matrices.
-
-The function horizontally concatenates two or more cv::Mat matrices (with the
-same number of rows).
-@code{.cpp}
-    cv::Mat matArray[] = { cv::Mat(4, 1, CV_8UC1, cv::Scalar(1)),
-                           cv::Mat(4, 1, CV_8UC1, cv::Scalar(2)),
-                           cv::Mat(4, 1, CV_8UC1, cv::Scalar(3)),};
-
-    cv::Mat out;
-    cv::hconcat( matArray, 3, out );
-    //out:
-    //[1, 2, 3;
-    // 1, 2, 3;
-    // 1, 2, 3;
-    // 1, 2, 3]
-@endcode
-@param src input array or vector of matrices. all of the matrices must have the
-same number of rows and the same depth.
-@param nsrc number of matrices in src.
-@param dst output array. It has the same number of rows and depth as the src,
-and the sum of cols of the src.
-@sa cv::vconcat(const Mat*, size_t, OutputArray), @sa
-cv::vconcat(InputArrayOfArrays, OutputArray) and @sa cv::vconcat(InputArray,
-InputArray, OutputArray)
-*/
-CV_EXPORTS void hconcat(const Mat *src, size_t nsrc, OutputArray dst);
-/** @overload
- @code{.cpp}
-    cv::Mat_<float> A = (cv::Mat_<float>(3, 2) << 1, 4,
-                                                  2, 5,
-                                                  3, 6);
-    cv::Mat_<float> B = (cv::Mat_<float>(3, 2) << 7, 10,
-                                                  8, 11,
-                                                  9, 12);
-
-    cv::Mat C;
-    cv::hconcat(A, B, C);
-    //C:
-    //[1, 4, 7, 10;
-    // 2, 5, 8, 11;
-    // 3, 6, 9, 12]
- @endcode
- @param src1 first input array to be considered for horizontal concatenation.
- @param src2 second input array to be considered for horizontal concatenation.
- @param dst output array. It has the same number of rows and depth as the src1
- and src2, and the sum of cols of the src1 and src2.
- */
-CV_EXPORTS void hconcat(InputArray src1, InputArray src2, OutputArray dst);
-/** @overload
- @code{.cpp}
-    std::vector<cv::Mat> matrices = { cv::Mat(4, 1, CV_8UC1, cv::Scalar(1)),
-                                      cv::Mat(4, 1, CV_8UC1, cv::Scalar(2)),
-                                      cv::Mat(4, 1, CV_8UC1, cv::Scalar(3)),};
-
-    cv::Mat out;
-    cv::hconcat( matrices, out );
-    //out:
-    //[1, 2, 3;
-    // 1, 2, 3;
-    // 1, 2, 3;
-    // 1, 2, 3]
- @endcode
- @param src input array or vector of matrices. all of the matrices must have the
-same number of rows and the same depth.
- @param dst output array. It has the same number of rows and depth as the src,
-and the sum of cols of the src. same depth.
- */
-CV_EXPORTS_W void hconcat(InputArrayOfArrays src, OutputArray dst);
-
-/** @brief Applies vertical concatenation to given matrices.
-
-The function vertically concatenates two or more cv::Mat matrices (with the same
-number of cols).
-@code{.cpp}
-    cv::Mat matArray[] = { cv::Mat(1, 4, CV_8UC1, cv::Scalar(1)),
-                           cv::Mat(1, 4, CV_8UC1, cv::Scalar(2)),
-                           cv::Mat(1, 4, CV_8UC1, cv::Scalar(3)),};
-
-    cv::Mat out;
-    cv::vconcat( matArray, 3, out );
-    //out:
-    //[1,   1,   1,   1;
-    // 2,   2,   2,   2;
-    // 3,   3,   3,   3]
-@endcode
-@param src input array or vector of matrices. all of the matrices must have the
-same number of cols and the same depth.
-@param nsrc number of matrices in src.
-@param dst output array. It has the same number of cols and depth as the src,
-and the sum of rows of the src.
-@sa cv::hconcat(const Mat*, size_t, OutputArray), @sa
-cv::hconcat(InputArrayOfArrays, OutputArray) and @sa cv::hconcat(InputArray,
-InputArray, OutputArray)
-*/
-CV_EXPORTS void vconcat(const Mat *src, size_t nsrc, OutputArray dst);
-/** @overload
- @code{.cpp}
-    cv::Mat_<float> A = (cv::Mat_<float>(3, 2) << 1, 7,
-                                                  2, 8,
-                                                  3, 9);
-    cv::Mat_<float> B = (cv::Mat_<float>(3, 2) << 4, 10,
-                                                  5, 11,
-                                                  6, 12);
-
-    cv::Mat C;
-    cv::vconcat(A, B, C);
-    //C:
-    //[1, 7;
-    // 2, 8;
-    // 3, 9;
-    // 4, 10;
-    // 5, 11;
-    // 6, 12]
- @endcode
- @param src1 first input array to be considered for vertical concatenation.
- @param src2 second input array to be considered for vertical concatenation.
- @param dst output array. It has the same number of cols and depth as the src1
- and src2, and the sum of rows of the src1 and src2.
- */
-CV_EXPORTS void vconcat(InputArray src1, InputArray src2, OutputArray dst);
-/** @overload
- @code{.cpp}
-    std::vector<cv::Mat> matrices = { cv::Mat(1, 4, CV_8UC1, cv::Scalar(1)),
-                                      cv::Mat(1, 4, CV_8UC1, cv::Scalar(2)),
-                                      cv::Mat(1, 4, CV_8UC1, cv::Scalar(3)),};
-
-    cv::Mat out;
-    cv::vconcat( matrices, out );
-    //out:
-    //[1,   1,   1,   1;
-    // 2,   2,   2,   2;
-    // 3,   3,   3,   3]
- @endcode
- @param src input array or vector of matrices. all of the matrices must have the
-same number of cols and the same depth
- @param dst output array. It has the same number of cols and depth as the src,
-and the sum of rows of the src. same depth.
- */
-CV_EXPORTS_W void vconcat(InputArrayOfArrays src, OutputArray dst);
-
-/** @brief computes bitwise conjunction of the two arrays (dst = src1 & src2)
-Calculates the per-element bit-wise conjunction of two arrays or an
-array and a scalar.
-
-The function cv::bitwise_and calculates the per-element bit-wise logical
-conjunction for:
-*   Two arrays when src1 and src2 have the same size:
-    \f[\texttt{dst} (I) =  \texttt{src1} (I)  \wedge \texttt{src2} (I) \quad
-\texttt{if mask} (I) \ne0\f]
-*   An array and a scalar when src2 is constructed from Scalar or has
-    the same number of elements as `src1.channels()`:
-    \f[\texttt{dst} (I) =  \texttt{src1} (I)  \wedge \texttt{src2} \quad
-\texttt{if mask} (I) \ne0\f]
-*   A scalar and an array when src1 is constructed from Scalar or has
-    the same number of elements as `src2.channels()`:
-    \f[\texttt{dst} (I) =  \texttt{src1}  \wedge \texttt{src2} (I) \quad
-\texttt{if mask} (I) \ne0\f] In case of floating-point arrays, their
-machine-specific bit representations (usually IEEE754-compliant) are used for
-the operation. In case of multi-channel arrays, each channel is processed
-independently. In the second and third cases above, the scalar is first
-converted to the array type.
-@param src1 first input array or a scalar.
-@param src2 second input array or a scalar.
-@param dst output array that has the same size and type as the input
-arrays.
-@param mask optional operation mask, 8-bit single channel array, that
-specifies elements of the output array to be changed.
-*/
-CV_EXPORTS_W void bitwise_and(InputArray src1, InputArray src2, OutputArray dst,
-                              InputArray mask = noArray());
-
-/** @brief Calculates the per-element bit-wise disjunction of two arrays or an
-array and a scalar.
-
-The function cv::bitwise_or calculates the per-element bit-wise logical
-disjunction for:
-*   Two arrays when src1 and src2 have the same size:
-    \f[\texttt{dst} (I) =  \texttt{src1} (I)  \vee \texttt{src2} (I) \quad
-\texttt{if mask} (I) \ne0\f]
-*   An array and a scalar when src2 is constructed from Scalar or has
-    the same number of elements as `src1.channels()`:
-    \f[\texttt{dst} (I) =  \texttt{src1} (I)  \vee \texttt{src2} \quad
-\texttt{if mask} (I) \ne0\f]
-*   A scalar and an array when src1 is constructed from Scalar or has
-    the same number of elements as `src2.channels()`:
-    \f[\texttt{dst} (I) =  \texttt{src1}  \vee \texttt{src2} (I) \quad
-\texttt{if mask} (I) \ne0\f] In case of floating-point arrays, their
-machine-specific bit representations (usually IEEE754-compliant) are used for
-the operation. In case of multi-channel arrays, each channel is processed
-independently. In the second and third cases above, the scalar is first
-converted to the array type.
-@param src1 first input array or a scalar.
-@param src2 second input array or a scalar.
-@param dst output array that has the same size and type as the input
-arrays.
-@param mask optional operation mask, 8-bit single channel array, that
-specifies elements of the output array to be changed.
-*/
-CV_EXPORTS_W void bitwise_or(InputArray src1, InputArray src2, OutputArray dst,
-                             InputArray mask = noArray());
-
-/** @brief Calculates the per-element bit-wise "exclusive or" operation on two
-arrays or an array and a scalar.
-
-The function cv::bitwise_xor calculates the per-element bit-wise logical
-"exclusive-or" operation for:
-*   Two arrays when src1 and src2 have the same size:
-    \f[\texttt{dst} (I) =  \texttt{src1} (I)  \oplus \texttt{src2} (I) \quad
-\texttt{if mask} (I) \ne0\f]
-*   An array and a scalar when src2 is constructed from Scalar or has
-    the same number of elements as `src1.channels()`:
-    \f[\texttt{dst} (I) =  \texttt{src1} (I)  \oplus \texttt{src2} \quad
-\texttt{if mask} (I) \ne0\f]
-*   A scalar and an array when src1 is constructed from Scalar or has
-    the same number of elements as `src2.channels()`:
-    \f[\texttt{dst} (I) =  \texttt{src1}  \oplus \texttt{src2} (I) \quad
-\texttt{if mask} (I) \ne0\f] In case of floating-point arrays, their
-machine-specific bit representations (usually IEEE754-compliant) are used for
-the operation. In case of multi-channel arrays, each channel is processed
-independently. In the 2nd and 3rd cases above, the scalar is first
-converted to the array type.
-@param src1 first input array or a scalar.
-@param src2 second input array or a scalar.
-@param dst output array that has the same size and type as the input
-arrays.
-@param mask optional operation mask, 8-bit single channel array, that
-specifies elements of the output array to be changed.
-*/
-CV_EXPORTS_W void bitwise_xor(InputArray src1, InputArray src2, OutputArray dst,
-                              InputArray mask = noArray());
-
-/** @brief  Inverts every bit of an array.
-
-The function cv::bitwise_not calculates per-element bit-wise inversion of the
-input array:
-\f[\texttt{dst} (I) =  \neg \texttt{src} (I)\f]
-In case of a floating-point input array, its machine-specific bit
-representation (usually IEEE754-compliant) is used for the operation. In
-case of multi-channel arrays, each channel is processed independently.
-@param src input array.
-@param dst output array that has the same size and type as the input
-array.
-@param mask optional operation mask, 8-bit single channel array, that
-specifies elements of the output array to be changed.
-*/
-CV_EXPORTS_W void bitwise_not(InputArray src, OutputArray dst,
-                              InputArray mask = noArray());
-
-/** @brief Calculates the per-element absolute difference between two arrays or
-between an array and a scalar.
-
-The function cv::absdiff calculates:
-*   Absolute difference between two arrays when they have the same
-    size and type:
-    \f[\texttt{dst}(I) =  \texttt{saturate} (| \texttt{src1}(I) -
-\texttt{src2}(I)|)\f]
-*   Absolute difference between an array and a scalar when the second
-    array is constructed from Scalar or has as many elements as the
-    number of channels in `src1`:
-    \f[\texttt{dst}(I) =  \texttt{saturate} (| \texttt{src1}(I) -  \texttt{src2}
-|)\f]
-*   Absolute difference between a scalar and an array when the first
-    array is constructed from Scalar or has as many elements as the
-    number of channels in `src2`:
-    \f[\texttt{dst}(I) =  \texttt{saturate} (| \texttt{src1} -  \texttt{src2}(I)
-|)\f] where I is a multi-dimensional index of array elements. In case of
-    multi-channel arrays, each channel is processed independently.
-@note Saturation is not applied when the arrays have the depth CV_32S.
-You may even get a negative value in the case of overflow.
-@note (Python) Be careful to difference behaviour between src1/src2 are single
-number and they are tuple/array. `absdiff(src,X)` means
-`absdiff(src,(X,X,X,X))`. `absdiff(src,(X,))` means `absdiff(src,(X,0,0,0))`.
-@param src1 first input array or a scalar.
-@param src2 second input array or a scalar.
-@param dst output array that has the same size and type as input arrays.
-@sa cv::abs(const Mat&)
-*/
-CV_EXPORTS_W void absdiff(InputArray src1, InputArray src2, OutputArray dst);
-
-/** @brief  This is an overloaded member function, provided for convenience
-(python) Copies the matrix to another one. When the operation mask is specified,
-if the Mat::create call shown above reallocates the matrix, the newly allocated
-matrix is initialized with all zeros before copying the data.
-@param src source matrix.
-@param dst Destination matrix. If it does not have a proper size or type before
-the operation, it is reallocated.
-@param mask Operation mask of the same size as \*this. Its non-zero elements
-indicate which matrix elements need to be copied. The mask has to be of type
-CV_8U and can have 1 or multiple channels.
-*/
-
-void CV_EXPORTS_W copyTo(InputArray src, OutputArray dst, InputArray mask);
-/** @brief  Checks if array elements lie between the elements of two other
-arrays.
-
-The function checks the range as follows:
--   For every element of a single-channel input array:
-    \f[\texttt{dst} (I)= \texttt{lowerb} (I)_0  \leq \texttt{src} (I)_0 \leq
-\texttt{upperb} (I)_0\f]
--   For two-channel arrays:
-    \f[\texttt{dst} (I)= \texttt{lowerb} (I)_0  \leq \texttt{src} (I)_0 \leq
-\texttt{upperb} (I)_0  \land \texttt{lowerb} (I)_1  \leq \texttt{src} (I)_1 \leq
-\texttt{upperb} (I)_1\f]
--   and so forth.
-
-That is, dst (I) is set to 255 (all 1 -bits) if src (I) is within the
-specified 1D, 2D, 3D, ... box and 0 otherwise.
-
-When the lower and/or upper boundary parameters are scalars, the indexes
-(I) at lowerb and upperb in the above formulas should be omitted.
-@param src first input array.
-@param lowerb inclusive lower boundary array or a scalar.
-@param upperb inclusive upper boundary array or a scalar.
-@param dst output array of the same size as src and CV_8U type.
-*/
-CV_EXPORTS_W void inRange(InputArray src, InputArray lowerb, InputArray upperb,
-                          OutputArray dst);
-
-/** @brief Performs the per-element comparison of two arrays or an array and
-scalar value.
-
-The function compares:
-*   Elements of two arrays when src1 and src2 have the same size:
-    \f[\texttt{dst} (I) =  \texttt{src1} (I)  \,\texttt{cmpop}\, \texttt{src2}
-(I)\f]
-*   Elements of src1 with a scalar src2 when src2 is constructed from
-    Scalar or has a single element:
-    \f[\texttt{dst} (I) =  \texttt{src1}(I) \,\texttt{cmpop}\,  \texttt{src2}\f]
-*   src1 with elements of src2 when src1 is constructed from Scalar or
-    has a single element:
-    \f[\texttt{dst} (I) =  \texttt{src1}  \,\texttt{cmpop}\, \texttt{src2}
-(I)\f] When the comparison result is true, the corresponding element of output
-array is set to 255. The comparison operations can be replaced with the
-equivalent matrix expressions:
-@code{.cpp}
-    Mat dst1 = src1 >= src2;
-    Mat dst2 = src1 < 8;
-    ...
-@endcode
-@param src1 first input array or a scalar; when it is an array, it must have a
-single channel.
-@param src2 second input array or a scalar; when it is an array, it must have a
-single channel.
-@param dst output array of type ref CV_8U that has the same size and the same
-number of channels as the input arrays.
-@param cmpop a flag, that specifies correspondence between the arrays
-(cv::CmpTypes)
-@sa checkRange, min, max, threshold
-*/
-CV_EXPORTS_W void compare(InputArray src1, InputArray src2, OutputArray dst,
-                          int cmpop);
-
-/** @brief Calculates per-element minimum of two arrays or an array and a
-scalar.
-
-The function cv::min calculates the per-element minimum of two arrays:
-\f[\texttt{dst} (I)= \min ( \texttt{src1} (I), \texttt{src2} (I))\f]
-or array and a scalar:
-\f[\texttt{dst} (I)= \min ( \texttt{src1} (I), \texttt{value} )\f]
-@param src1 first input array.
-@param src2 second input array of the same size and type as src1.
-@param dst output array of the same size and type as src1.
-@sa max, compare, inRange, minMaxLoc
-*/
-CV_EXPORTS_W void min(InputArray src1, InputArray src2, OutputArray dst);
-/** @overload
-needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&,
-_Compare)
-*/
-CV_EXPORTS void min(const Mat &src1, const Mat &src2, Mat &dst);
-
-/** @brief Calculates per-element maximum of two arrays or an array and a
-scalar.
-
-The function cv::max calculates the per-element maximum of two arrays:
-\f[\texttt{dst} (I)= \max ( \texttt{src1} (I), \texttt{src2} (I))\f]
-or array and a scalar:
-\f[\texttt{dst} (I)= \max ( \texttt{src1} (I), \texttt{value} )\f]
-@param src1 first input array.
-@param src2 second input array of the same size and type as src1 .
-@param dst output array of the same size and type as src1.
-@sa  min, compare, inRange, minMaxLoc, @ref MatrixExpressions
-*/
-CV_EXPORTS_W void max(InputArray src1, InputArray src2, OutputArray dst);
-/** @overload
-needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&,
-_Compare)
-*/
-CV_EXPORTS void max(const Mat &src1, const Mat &src2, Mat &dst);
-
-/** @brief Calculates a square root of array elements.
-
-The function cv::sqrt calculates a square root of each input array element.
-In case of multi-channel arrays, each channel is processed
-independently. The accuracy is approximately the same as of the built-in
-std::sqrt .
-@param src input floating-point array.
-@param dst output array of the same size and type as src.
-*/
-CV_EXPORTS_W void sqrt(InputArray src, OutputArray dst);
-
-/** @brief Raises every array element to a power.
-
-The function cv::pow raises every element of the input array to power :
-\f[\texttt{dst} (I) =  \fork{\texttt{src}(I)^{power}}{if \(\texttt{power}\) is
-integer}{|\texttt{src}(I)|^{power}}{otherwise}\f]
-
-So, for a non-integer power exponent, the absolute values of input array
-elements are used. However, it is possible to get true values for
-negative values using some extra operations. In the example below,
-computing the 5th root of array src shows:
-@code{.cpp}
-    Mat mask = src < 0;
-    pow(src, 1./5, dst);
-    subtract(Scalar::all(0), dst, dst, mask);
-@endcode
-For some values of power, such as integer values, 0.5 and -0.5,
-specialized faster algorithms are used.
-
-Special values (NaN, Inf) are not handled.
-@param src input array.
-@param power exponent of power.
-@param dst output array of the same size and type as src.
-@sa sqrt, exp, log, cartToPolar, polarToCart
-*/
-CV_EXPORTS_W void pow(InputArray src, double power, OutputArray dst);
-
-/** @brief Calculates the exponent of every array element.
-
-The function cv::exp calculates the exponent of every element of the input
-array:
-\f[\texttt{dst} [I] = e^{ src(I) }\f]
-
-The maximum relative error is about 7e-6 for single-precision input and
-less than 1e-10 for double-precision input. Currently, the function
-converts denormalized values to zeros on output. Special values (NaN,
-Inf) are not handled.
-@param src input array.
-@param dst output array of the same size and type as src.
-@sa log, cartToPolar, polarToCart, phase, pow, sqrt, magnitude
-*/
-CV_EXPORTS_W void exp(InputArray src, OutputArray dst);
-
-/** @brief Calculates the natural logarithm of every array element.
-
-The function cv::log calculates the natural logarithm of every element of the
-input array:
-\f[\texttt{dst} (I) =  \log (\texttt{src}(I)) \f]
-
-Output on zero, negative and special (NaN, Inf) values is undefined.
-
-@param src input array.
-@param dst output array of the same size and type as src .
-@sa exp, cartToPolar, polarToCart, phase, pow, sqrt, magnitude
-*/
-CV_EXPORTS_W void log(InputArray src, OutputArray dst);
-
-/** @brief Calculates x and y coordinates of 2D vectors from their magnitude and
-angle.
-
-The function cv::polarToCart calculates the Cartesian coordinates of each 2D
-vector represented by the corresponding elements of magnitude and angle:
-\f[\begin{array}{l} \texttt{x} (I) =  \texttt{magnitude} (I) \cos (
-\texttt{angle} (I)) \\ \texttt{y} (I) =  \texttt{magnitude} (I) \sin (
-\texttt{angle} (I)) \\ \end{array}\f]
-
-The relative accuracy of the estimated coordinates is about 1e-6.
-@param magnitude input floating-point array of magnitudes of 2D vectors;
-it can be an empty matrix (=Mat()), in this case, the function assumes
-that all the magnitudes are =1; if it is not empty, it must have the
-same size and type as angle.
-@param angle input floating-point array of angles of 2D vectors.
-@param x output array of x-coordinates of 2D vectors; it has the same
-size and type as angle.
-@param y output array of y-coordinates of 2D vectors; it has the same
-size and type as angle.
-@param angleInDegrees when true, the input angles are measured in
-degrees, otherwise, they are measured in radians.
-@sa cartToPolar, magnitude, phase, exp, log, pow, sqrt
-*/
-CV_EXPORTS_W void polarToCart(InputArray magnitude, InputArray angle,
-                              OutputArray x, OutputArray y,
-                              bool angleInDegrees = false);
-
-/** @brief Calculates the magnitude and angle of 2D vectors.
-
-The function cv::cartToPolar calculates either the magnitude, angle, or both
-for every 2D vector (x(I),y(I)):
-\f[\begin{array}{l} \texttt{magnitude} (I)=
-\sqrt{\texttt{x}(I)^2+\texttt{y}(I)^2} , \\ \texttt{angle} (I)= \texttt{atan2} (
-\texttt{y} (I), \texttt{x} (I))[ \cdot180 / \pi ] \end{array}\f]
-
-The angles are calculated with accuracy about 0.3 degrees. For the point
-(0,0), the angle is set to 0.
-@param x array of x-coordinates; this must be a single-precision or
-double-precision floating-point array.
-@param y array of y-coordinates, that must have the same size and same type as
-x.
-@param magnitude output array of magnitudes of the same size and type as x.
-@param angle output array of angles that has the same size and type as
-x; the angles are measured in radians (from 0 to 2\*Pi) or in degrees (0 to 360
-degrees).
-@param angleInDegrees a flag, indicating whether the angles are measured
-in radians (which is by default), or in degrees.
-@sa Sobel, Scharr
-*/
-CV_EXPORTS_W void cartToPolar(InputArray x, InputArray y, OutputArray magnitude,
-                              OutputArray angle, bool angleInDegrees = false);
-
-/** @brief Calculates the rotation angle of 2D vectors.
-
-The function cv::phase calculates the rotation angle of each 2D vector that
-is formed from the corresponding elements of x and y :
-\f[\texttt{angle} (I) =  \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))\f]
-
-The angle estimation accuracy is about 0.3 degrees. When x(I)=y(I)=0 ,
-the corresponding angle(I) is set to 0.
-@param x input floating-point array of x-coordinates of 2D vectors.
-@param y input array of y-coordinates of 2D vectors; it must have the
-same size and the same type as x.
-@param angle output array of vector angles; it has the same size and
-same type as x .
-@param angleInDegrees when true, the function calculates the angle in
-degrees, otherwise, they are measured in radians.
-*/
-CV_EXPORTS_W void phase(InputArray x, InputArray y, OutputArray angle,
-                        bool angleInDegrees = false);
-
-/** @brief Calculates the magnitude of 2D vectors.
-
-The function cv::magnitude calculates the magnitude of 2D vectors formed
-from the corresponding elements of x and y arrays:
-\f[\texttt{dst} (I) =  \sqrt{\texttt{x}(I)^2 + \texttt{y}(I)^2}\f]
-@param x floating-point array of x-coordinates of the vectors.
-@param y floating-point array of y-coordinates of the vectors; it must
-have the same size as x.
-@param magnitude output array of the same size and type as x.
-@sa cartToPolar, polarToCart, phase, sqrt
-*/
-CV_EXPORTS_W void magnitude(InputArray x, InputArray y, OutputArray magnitude);
-
-/** @brief Checks every element of an input array for invalid values.
-
-The function cv::checkRange checks that every array element is neither NaN nor
-infinite. When minVal \> -DBL_MAX and maxVal \< DBL_MAX, the function also
-checks that each value is between minVal and maxVal. In case of multi-channel
-arrays, each channel is processed independently. If some values are out of
-range, position of the first outlier is stored in pos (when pos != NULL). Then,
-the function either returns false (when quiet=true) or throws an exception.
-@param a input array.
-@param quiet a flag, indicating whether the functions quietly return false when
-the array elements are out of range or they throw an exception.
-@param pos optional output parameter, when not NULL, must be a pointer to array
-of src.dims elements.
-@param minVal inclusive lower boundary of valid values range.
-@param maxVal exclusive upper boundary of valid values range.
-*/
-CV_EXPORTS_W bool checkRange(InputArray a, bool quiet = true,
-                             CV_OUT Point *pos = 0, double minVal = -DBL_MAX,
-                             double maxVal = DBL_MAX);
-
-/** @brief Replaces NaNs by given number
-@param a input/output matrix (CV_32F type).
-@param val value to convert the NaNs
-*/
-CV_EXPORTS_W void patchNaNs(InputOutputArray a, double val = 0);
-
-/** @brief Performs generalized matrix multiplication.
-
-The function cv::gemm performs generalized matrix multiplication similar to the
-gemm functions in BLAS level 3. For example,
-`gemm(src1, src2, alpha, src3, beta, dst, GEMM_1_T + GEMM_3_T)`
-corresponds to
-\f[\texttt{dst} =  \texttt{alpha} \cdot \texttt{src1} ^T  \cdot \texttt{src2} +
-\texttt{beta} \cdot \texttt{src3} ^T\f]
-
-In case of complex (two-channel) data, performed a complex matrix
-multiplication.
-
-The function can be replaced with a matrix expression. For example, the
-above call can be replaced with:
-@code{.cpp}
-    dst = alpha*src1.t()*src2 + beta*src3.t();
-@endcode
-@param src1 first multiplied input matrix that could be real(CV_32FC1,
-CV_64FC1) or complex(CV_32FC2, CV_64FC2).
-@param src2 second multiplied input matrix of the same type as src1.
-@param alpha weight of the matrix product.
-@param src3 third optional delta matrix added to the matrix product; it
-should have the same type as src1 and src2.
-@param beta weight of src3.
-@param dst output matrix; it has the proper size and the same type as
-input matrices.
-@param flags operation flags (cv::GemmFlags)
-@sa mulTransposed, transform
-*/
-CV_EXPORTS_W void gemm(InputArray src1, InputArray src2, double alpha,
-                       InputArray src3, double beta, OutputArray dst,
-                       int flags = 0);
-
-/** @brief Calculates the product of a matrix and its transposition.
-
-The function cv::mulTransposed calculates the product of src and its
-transposition:
-\f[\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} )^T (
-\texttt{src} - \texttt{delta} )\f] if aTa=true, and
-\f[\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} ) (
-\texttt{src} - \texttt{delta} )^T\f] otherwise. The function is used to
-calculate the covariance matrix. With zero delta, it can be used as a faster
-substitute for general matrix product A\*B when B=A'
-@param src input single-channel matrix. Note that unlike gemm, the
-function can multiply not only floating-point matrices.
-@param dst output square matrix.
-@param aTa Flag specifying the multiplication ordering. See the
-description below.
-@param delta Optional delta matrix subtracted from src before the
-multiplication. When the matrix is empty ( delta=noArray() ), it is
-assumed to be zero, that is, nothing is subtracted. If it has the same
-size as src, it is simply subtracted. Otherwise, it is "repeated" (see
-repeat ) to cover the full src and then subtracted. Type of the delta
-matrix, when it is not empty, must be the same as the type of created
-output matrix. See the dtype parameter description below.
-@param scale Optional scale factor for the matrix product.
-@param dtype Optional type of the output matrix. When it is negative,
-the output matrix will have the same type as src . Otherwise, it will be
-type=CV_MAT_DEPTH(dtype) that should be either CV_32F or CV_64F .
-@sa calcCovarMatrix, gemm, repeat, reduce
-*/
-CV_EXPORTS_W void mulTransposed(InputArray src, OutputArray dst, bool aTa,
-                                InputArray delta = noArray(), double scale = 1,
-                                int dtype = -1);
-
-/** @brief Transposes a matrix.
-
-The function cv::transpose transposes the matrix src :
-\f[\texttt{dst} (i,j) =  \texttt{src} (j,i)\f]
-@note No complex conjugation is done in case of a complex matrix. It
-should be done separately if needed.
-@param src input array.
-@param dst output array of the same type as src.
-*/
-CV_EXPORTS_W void transpose(InputArray src, OutputArray dst);
-
-/** @brief Transpose for n-dimensional matrices.
- *
- * @note Input should be continuous single-channel matrix.
- * @param src input array.
- * @param order a permutation of [0,1,..,N-1] where N is the number of axes of
- * src. The i'th axis of dst will correspond to the axis numbered order[i] of
- * the input.
- * @param dst output array of the same type as src.
- */
-CV_EXPORTS_W void transposeND(InputArray src, const std::vector<int> &order,
-                              OutputArray dst);
-
-/** @brief Performs the matrix transformation of every array element.
-
-The function cv::transform performs the matrix transformation of every
-element of the array src and stores the results in dst :
-\f[\texttt{dst} (I) =  \texttt{m} \cdot \texttt{src} (I)\f]
-(when m.cols=src.channels() ), or
-\f[\texttt{dst} (I) =  \texttt{m} \cdot [ \texttt{src} (I); 1]\f]
-(when m.cols=src.channels()+1 )
-
-Every element of the N -channel array src is interpreted as N -element
-vector that is transformed using the M x N or M x (N+1) matrix m to
-M-element vector - the corresponding element of the output array dst .
-
-The function may be used for geometrical transformation of
-N -dimensional points, arbitrary linear color space transformation (such
-as various kinds of RGB to YUV transforms), shuffling the image
-channels, and so forth.
-@param src input array that must have as many channels (1 to 4) as
-m.cols or m.cols-1.
-@param dst output array of the same size and depth as src; it has as
-many channels as m.rows.
-@param m transformation 2x2 or 2x3 floating-point matrix.
-@sa perspectiveTransform, getAffineTransform, estimateAffine2D, warpAffine,
-warpPerspective
-*/
-CV_EXPORTS_W void transform(InputArray src, OutputArray dst, InputArray m);
-
-/** @brief Performs the perspective matrix transformation of vectors.
-
-The function cv::perspectiveTransform transforms every element of src by
-treating it as a 2D or 3D vector, in the following way:
-\f[(x, y, z)  \rightarrow (x'/w, y'/w, z'/w)\f]
-where
-\f[(x', y', z', w') =  \texttt{mat} \cdot \begin{bmatrix} x & y & z & 1
-\end{bmatrix}\f] and
-\f[w =  \fork{w'}{if \(w' \ne 0\)}{\infty}{otherwise}\f]
-
-Here a 3D vector transformation is shown. In case of a 2D vector
-transformation, the z component is omitted.
-
-@note The function transforms a sparse set of 2D or 3D vectors. If you
-want to transform an image using perspective transformation, use
-warpPerspective . If you have an inverse problem, that is, you want to
-compute the most probable perspective transformation out of several
-pairs of corresponding points, you can use getPerspectiveTransform or
-findHomography .
-@param src input two-channel or three-channel floating-point array; each
-element is a 2D/3D vector to be transformed.
-@param dst output array of the same size and type as src.
-@param m 3x3 or 4x4 floating-point transformation matrix.
-@sa  transform, warpPerspective, getPerspectiveTransform, findHomography
-*/
-CV_EXPORTS_W void perspectiveTransform(InputArray src, OutputArray dst,
-                                       InputArray m);
-
-/** @brief Copies the lower or the upper half of a square matrix to its another
-half.
-
-The function cv::completeSymm copies the lower or the upper half of a square
-matrix to its another half. The matrix diagonal remains unchanged:
- - \f$\texttt{m}_{ij}=\texttt{m}_{ji}\f$ for \f$i > j\f$ if
-    lowerToUpper=false
- - \f$\texttt{m}_{ij}=\texttt{m}_{ji}\f$ for \f$i < j\f$ if
-    lowerToUpper=true
-
-@param m input-output floating-point square matrix.
-@param lowerToUpper operation flag; if true, the lower half is copied to
-the upper half. Otherwise, the upper half is copied to the lower half.
-@sa flip, transpose
-*/
-CV_EXPORTS_W void completeSymm(InputOutputArray m, bool lowerToUpper = false);
-
-/** @brief Initializes a scaled identity matrix.
-
-The function cv::setIdentity initializes a scaled identity matrix:
-\f[\texttt{mtx} (i,j)= \fork{\texttt{value}}{ if \(i=j\)}{0}{otherwise}\f]
-
-The function can also be emulated using the matrix initializers and the
-matrix expressions:
-@code
-    Mat A = Mat::eye(4, 3, CV_32F)*5;
-    // A will be set to [[5, 0, 0], [0, 5, 0], [0, 0, 5], [0, 0, 0]]
-@endcode
-@param mtx matrix to initialize (not necessarily square).
-@param s value to assign to diagonal elements.
-@sa Mat::zeros, Mat::ones, Mat::setTo, Mat::operator=
-*/
-CV_EXPORTS_W void setIdentity(InputOutputArray mtx,
-                              const Scalar &s = Scalar(1));
-
-/** @brief Returns the determinant of a square floating-point matrix.
-
-The function cv::determinant calculates and returns the determinant of the
-specified matrix. For small matrices ( mtx.cols=mtx.rows\<=3 ), the
-direct method is used. For larger matrices, the function uses LU
-factorization with partial pivoting.
-
-For symmetric positively-determined matrices, it is also possible to use
-eigen decomposition to calculate the determinant.
-@param mtx input matrix that must have CV_32FC1 or CV_64FC1 type and
-square size.
-@sa trace, invert, solve, eigen, @ref MatrixExpressions
-*/
-CV_EXPORTS_W double determinant(InputArray mtx);
-
-/** @brief Returns the trace of a matrix.
-
-The function cv::trace returns the sum of the diagonal elements of the
-matrix mtx .
-\f[\mathrm{tr} ( \texttt{mtx} ) =  \sum _i  \texttt{mtx} (i,i)\f]
-@param mtx input matrix.
-*/
-CV_EXPORTS_W Scalar trace(InputArray mtx);
-
-/** @brief Finds the inverse or pseudo-inverse of a matrix.
-
-The function cv::invert inverts the matrix src and stores the result in dst
-. When the matrix src is singular or non-square, the function calculates
-the pseudo-inverse matrix (the dst matrix) so that norm(src\*dst - I) is
-minimal, where I is an identity matrix.
-
-In case of the #DECOMP_LU method, the function returns non-zero value if
-the inverse has been successfully calculated and 0 if src is singular.
-
-In case of the #DECOMP_SVD method, the function returns the inverse
-condition number of src (the ratio of the smallest singular value to the
-largest singular value) and 0 if src is singular. The SVD method
-calculates a pseudo-inverse matrix if src is singular.
-
-Similarly to #DECOMP_LU, the method #DECOMP_CHOLESKY works only with
-non-singular square matrices that should also be symmetrical and
-positively defined. In this case, the function stores the inverted
-matrix in dst and returns non-zero. Otherwise, it returns 0.
-
-@param src input floating-point M x N matrix.
-@param dst output matrix of N x M size and the same type as src.
-@param flags inversion method (cv::DecompTypes)
-@sa solve, SVD
-*/
-CV_EXPORTS_W double invert(InputArray src, OutputArray dst,
-                           int flags = DECOMP_LU);
-
-/** @brief Solves one or more linear systems or least-squares problems.
-
-The function cv::solve solves a linear system or least-squares problem (the
-latter is possible with SVD or QR methods, or by specifying the flag
-#DECOMP_NORMAL ):
-\f[\texttt{dst} =  \arg \min _X \| \texttt{src1} \cdot \texttt{X} -
-\texttt{src2} \|\f]
-
-If #DECOMP_LU or #DECOMP_CHOLESKY method is used, the function returns 1
-if src1 (or \f$\texttt{src1}^T\texttt{src1}\f$ ) is non-singular. Otherwise,
-it returns 0. In the latter case, dst is not valid. Other methods find a
-pseudo-solution in case of a singular left-hand side part.
-
-@note If you want to find a unity-norm solution of an under-defined
-singular system \f$\texttt{src1}\cdot\texttt{dst}=0\f$ , the function solve
-will not do the work. Use SVD::solveZ instead.
-
-@param src1 input matrix on the left-hand side of the system.
-@param src2 input matrix on the right-hand side of the system.
-@param dst output solution.
-@param flags solution (matrix inversion) method (#DecompTypes)
-@sa invert, SVD, eigen
-*/
-CV_EXPORTS_W bool solve(InputArray src1, InputArray src2, OutputArray dst,
-                        int flags = DECOMP_LU);
-
-/** @brief Sorts each row or each column of a matrix.
-
-The function cv::sort sorts each matrix row or each matrix column in
-ascending or descending order. So you should pass two operation flags to
-get desired behaviour. If you want to sort matrix rows or columns
-lexicographically, you can use STL std::sort generic function with the
-proper comparison predicate.
-
-@param src input single-channel array.
-@param dst output array of the same size and type as src.
-@param flags operation flags, a combination of #SortFlags
-@sa sortIdx, randShuffle
-*/
-CV_EXPORTS_W void sort(InputArray src, OutputArray dst, int flags);
-
-/** @brief Sorts each row or each column of a matrix.
-
-The function cv::sortIdx sorts each matrix row or each matrix column in the
-ascending or descending order. So you should pass two operation flags to
-get desired behaviour. Instead of reordering the elements themselves, it
-stores the indices of sorted elements in the output array. For example:
-@code
-    Mat A = Mat::eye(3,3,CV_32F), B;
-    sortIdx(A, B, SORT_EVERY_ROW + SORT_ASCENDING);
-    // B will probably contain
-    // (because of equal elements in A some permutations are possible):
-    // [[1, 2, 0], [0, 2, 1], [0, 1, 2]]
-@endcode
-@param src input single-channel array.
-@param dst output integer array of the same size as src.
-@param flags operation flags that could be a combination of cv::SortFlags
-@sa sort, randShuffle
-*/
-CV_EXPORTS_W void sortIdx(InputArray src, OutputArray dst, int flags);
-
-/** @brief Finds the real roots of a cubic equation.
-
-The function solveCubic finds the real roots of a cubic equation:
--   if coeffs is a 4-element vector:
-\f[\texttt{coeffs} [0] x^3 +  \texttt{coeffs} [1] x^2 +  \texttt{coeffs} [2] x +
-\texttt{coeffs} [3] = 0\f]
--   if coeffs is a 3-element vector:
-\f[x^3 +  \texttt{coeffs} [0] x^2 +  \texttt{coeffs} [1] x +  \texttt{coeffs}
-[2] = 0\f]
-
-The roots are stored in the roots array.
-@param coeffs equation coefficients, an array of 3 or 4 elements.
-@param roots output array of real roots that has 1 or 3 elements.
-@return number of real roots. It can be 0, 1 or 2.
-*/
-CV_EXPORTS_W int solveCubic(InputArray coeffs, OutputArray roots);
-
-/** @brief Finds the real or complex roots of a polynomial equation.
-
-The function cv::solvePoly finds real and complex roots of a polynomial
-equation:
-\f[\texttt{coeffs} [n] x^{n} +  \texttt{coeffs} [n-1] x^{n-1} + ... +
-\texttt{coeffs} [1] x +  \texttt{coeffs} [0] = 0\f]
-@param coeffs array of polynomial coefficients.
-@param roots output (complex) array of roots.
-@param maxIters maximum number of iterations the algorithm does.
-*/
-CV_EXPORTS_W double solvePoly(InputArray coeffs, OutputArray roots,
-                              int maxIters = 300);
-
-/** @brief Calculates eigenvalues and eigenvectors of a symmetric matrix.
-
-The function cv::eigen calculates just eigenvalues, or eigenvalues and
-eigenvectors of the symmetric matrix src:
-@code
-    src*eigenvectors.row(i).t() =
-eigenvalues.at<srcType>(i)*eigenvectors.row(i).t()
-@endcode
-
-@note Use cv::eigenNonSymmetric for calculation of real eigenvalues and
-eigenvectors of non-symmetric matrix.
-
-@param src input matrix that must have CV_32FC1 or CV_64FC1 type, square size
-and be symmetrical (src ^T^ == src).
-@param eigenvalues output vector of eigenvalues of the same type as src; the
-eigenvalues are stored in the descending order.
-@param eigenvectors output matrix of eigenvectors; it has the same size and type
-as src; the eigenvectors are stored as subsequent matrix rows, in the same order
-as the corresponding eigenvalues.
-@sa eigenNonSymmetric, completeSymm, PCA
-*/
-CV_EXPORTS_W bool eigen(InputArray src, OutputArray eigenvalues,
-                        OutputArray eigenvectors = noArray());
-
-/** @brief Calculates eigenvalues and eigenvectors of a non-symmetric matrix
-(real eigenvalues only).
-
-@note Assumes real eigenvalues.
-
-The function calculates eigenvalues and eigenvectors (optional) of the square
-matrix src:
-@code
-    src*eigenvectors.row(i).t() =
-eigenvalues.at<srcType>(i)*eigenvectors.row(i).t()
-@endcode
-
-@param src input matrix (CV_32FC1 or CV_64FC1 type).
-@param eigenvalues output vector of eigenvalues (type is the same type as src).
-@param eigenvectors output matrix of eigenvectors (type is the same type as
-src). The eigenvectors are stored as subsequent matrix rows, in the same order
-as the corresponding eigenvalues.
-@sa eigen
-*/
-CV_EXPORTS_W void eigenNonSymmetric(InputArray src, OutputArray eigenvalues,
-                                    OutputArray eigenvectors);
-
-/** @brief Calculates the covariance matrix of a set of vectors.
-
-The function cv::calcCovarMatrix calculates the covariance matrix and,
-optionally, the mean vector of the set of input vectors.
-@param samples samples stored as separate matrices
-@param nsamples number of samples
-@param covar output covariance matrix of the type ctype and square size.
-@param mean input or output (depending on the flags) array as the average value
-of the input vectors.
-@param flags operation flags as a combination of #CovarFlags
-@param ctype type of the matrixl; it equals 'CV_64F' by default.
-@sa PCA, mulTransposed, Mahalanobis
-@todo InputArrayOfArrays
-*/
-CV_EXPORTS void calcCovarMatrix(const Mat *samples, int nsamples, Mat &covar,
-                                Mat &mean, int flags, int ctype = CV_64F);
-
-/** @overload
-@note use #COVAR_ROWS or #COVAR_COLS flag
-@param samples samples stored as rows/columns of a single matrix.
-@param covar output covariance matrix of the type ctype and square size.
-@param mean input or output (depending on the flags) array as the average value
-of the input vectors.
-@param flags operation flags as a combination of #CovarFlags
-@param ctype type of the matrixl; it equals 'CV_64F' by default.
-*/
-CV_EXPORTS_W void calcCovarMatrix(InputArray samples, OutputArray covar,
-                                  InputOutputArray mean, int flags,
-                                  int ctype = CV_64F);
-
-/** wrap PCA::operator() */
-CV_EXPORTS_W void PCACompute(InputArray data, InputOutputArray mean,
-                             OutputArray eigenvectors, int maxComponents = 0);
-
-/** wrap PCA::operator() and add eigenvalues output parameter */
-CV_EXPORTS_AS(PCACompute2)
-void PCACompute(InputArray data, InputOutputArray mean,
-                OutputArray eigenvectors, OutputArray eigenvalues,
-                int maxComponents = 0);
-
-/** wrap PCA::operator() */
-CV_EXPORTS_W void PCACompute(InputArray data, InputOutputArray mean,
-                             OutputArray eigenvectors, double retainedVariance);
-
-/** wrap PCA::operator() and add eigenvalues output parameter */
-CV_EXPORTS_AS(PCACompute2)
-void PCACompute(InputArray data, InputOutputArray mean,
-                OutputArray eigenvectors, OutputArray eigenvalues,
-                double retainedVariance);
-
-/** wrap PCA::project */
-CV_EXPORTS_W void PCAProject(InputArray data, InputArray mean,
-                             InputArray eigenvectors, OutputArray result);
-
-/** wrap PCA::backProject */
-CV_EXPORTS_W void PCABackProject(InputArray data, InputArray mean,
-                                 InputArray eigenvectors, OutputArray result);
-
-/** wrap SVD::compute */
-CV_EXPORTS_W void SVDecomp(InputArray src, OutputArray w, OutputArray u,
-                           OutputArray vt, int flags = 0);
-
-/** wrap SVD::backSubst */
-CV_EXPORTS_W void SVBackSubst(InputArray w, InputArray u, InputArray vt,
-                              InputArray rhs, OutputArray dst);
-
-/** @brief Calculates the Mahalanobis distance between two vectors.
-
-The function cv::Mahalanobis calculates and returns the weighted distance
-between two vectors:
-\f[d( \texttt{vec1} , \texttt{vec2} )=
-\sqrt{\sum_{i,j}{\texttt{icovar(i,j)}\cdot(\texttt{vec1}(I)-\texttt{vec2}(I))\cdot(\texttt{vec1(j)}-\texttt{vec2(j)})}
-}\f] The covariance matrix may be calculated using the #calcCovarMatrix function
-and then inverted using the invert function (preferably using the #DECOMP_SVD
-method, as the most accurate).
-@param v1 first 1D input vector.
-@param v2 second 1D input vector.
-@param icovar inverse covariance matrix.
-*/
-CV_EXPORTS_W double Mahalanobis(InputArray v1, InputArray v2,
-                                InputArray icovar);
-
-/** @brief Performs a forward or inverse Discrete Fourier transform of a 1D or
-2D floating-point array.
-
-The function cv::dft performs one of the following:
--   Forward the Fourier transform of a 1D vector of N elements:
-    \f[Y = F^{(N)}  \cdot X,\f]
-    where \f$F^{(N)}_{jk}=\exp(-2\pi i j k/N)\f$ and \f$i=\sqrt{-1}\f$
--   Inverse the Fourier transform of a 1D vector of N elements:
-    \f[\begin{array}{l} X'=  \left (F^{(N)} \right )^{-1}  \cdot Y =  \left
-(F^{(N)} \right )^*  \cdot y  \\ X = (1/N)  \cdot X, \end{array}\f] where
-\f$F^*=\left(\textrm{Re}(F^{(N)})-\textrm{Im}(F^{(N)})\right)^T\f$
--   Forward the 2D Fourier transform of a M x N matrix:
-    \f[Y = F^{(M)}  \cdot X  \cdot F^{(N)}\f]
--   Inverse the 2D Fourier transform of a M x N matrix:
-    \f[\begin{array}{l} X'=  \left (F^{(M)} \right )^*  \cdot Y  \cdot \left
-(F^{(N)} \right )^* \\ X =  \frac{1}{M \cdot N} \cdot X' \end{array}\f]
-
-In case of real (single-channel) data, the output spectrum of the forward
-Fourier transform or input spectrum of the inverse Fourier transform can be
-represented in a packed format called *CCS* (complex-conjugate-symmetrical). It
-was borrowed from IPL (Intel\* Image Processing Library). Here is how 2D *CCS*
-spectrum looks:
-\f[\begin{bmatrix} Re Y_{0,0} & Re Y_{0,1} & Im Y_{0,1} & Re Y_{0,2} & Im
-Y_{0,2} &  \cdots & Re Y_{0,N/2-1} & Im Y_{0,N/2-1} & Re Y_{0,N/2}  \\ Re
-Y_{1,0} & Re Y_{1,1} & Im Y_{1,1} & Re Y_{1,2} & Im Y_{1,2} &  \cdots & Re
-Y_{1,N/2-1} & Im Y_{1,N/2-1} & Re Y_{1,N/2}  \\ Im Y_{1,0} & Re Y_{2,1} & Im
-Y_{2,1} & Re Y_{2,2} & Im Y_{2,2} &  \cdots & Re Y_{2,N/2-1} & Im Y_{2,N/2-1} &
-Im Y_{1,N/2}  \\ \hdotsfor{9} \\ Re Y_{M/2-1,0} &  Re Y_{M-3,1}  & Im Y_{M-3,1}
-&  \hdotsfor{3} & Re Y_{M-3,N/2-1} & Im Y_{M-3,N/2-1}& Re Y_{M/2-1,N/2}  \\ Im
-Y_{M/2-1,0} &  Re Y_{M-2,1}  & Im Y_{M-2,1} &  \hdotsfor{3} & Re Y_{M-2,N/2-1} &
-Im Y_{M-2,N/2-1}& Im Y_{M/2-1,N/2}  \\ Re Y_{M/2,0}  &  Re Y_{M-1,1} &  Im
-Y_{M-1,1} &  \hdotsfor{3} & Re Y_{M-1,N/2-1} & Im Y_{M-1,N/2-1}& Re Y_{M/2,N/2}
-\end{bmatrix}\f]
-
-In case of 1D transform of a real vector, the output looks like the first row of
-the matrix above.
-
-So, the function chooses an operation mode depending on the flags and size of
-the input array:
--   If #DFT_ROWS is set or the input array has a single row or single column,
-the function performs a 1D forward or inverse transform of each row of a matrix
-when #DFT_ROWS is set. Otherwise, it performs a 2D transform.
--   If the input array is real and #DFT_INVERSE is not set, the function
-performs a forward 1D or 2D transform:
-    -   When #DFT_COMPLEX_OUTPUT is set, the output is a complex matrix of the
-same size as input.
-    -   When #DFT_COMPLEX_OUTPUT is not set, the output is a real matrix of the
-same size as input. In case of 2D transform, it uses the packed format as shown
-above. In case of a single 1D transform, it looks like the first row of the
-matrix above. In case of multiple 1D transforms (when using the #DFT_ROWS flag),
-each row of the output matrix looks like the first row of the matrix above.
--   If the input array is complex and either #DFT_INVERSE or #DFT_REAL_OUTPUT
-are not set, the output is a complex array of the same size as input. The
-function performs a forward or inverse 1D or 2D transform of the whole input
-array or each row of the input array independently, depending on the flags
-DFT_INVERSE and DFT_ROWS.
--   When #DFT_INVERSE is set and the input array is real, or it is complex but
-#DFT_REAL_OUTPUT is set, the output is a real array of the same size as input.
-The function performs a 1D or 2D inverse transformation of the whole input array
-or each individual row, depending on the flags #DFT_INVERSE and #DFT_ROWS.
-
-If #DFT_SCALE is set, the scaling is done after the transformation.
-
-Unlike dct, the function supports arrays of arbitrary size. But only those
-arrays are processed efficiently, whose sizes can be factorized in a product of
-small prime numbers (2, 3, and 5 in the current implementation). Such an
-efficient DFT size can be calculated using the getOptimalDFTSize method.
-
-The sample below illustrates how to calculate a DFT-based convolution of two 2D
-real arrays:
-@code
-    void convolveDFT(InputArray A, InputArray B, OutputArray C)
-    {
-        // reallocate the output array if needed
-        C.create(abs(A.rows - B.rows)+1, abs(A.cols - B.cols)+1, A.type());
-        Size dftSize;
-        // calculate the size of DFT transform
-        dftSize.width = getOptimalDFTSize(A.cols + B.cols - 1);
-        dftSize.height = getOptimalDFTSize(A.rows + B.rows - 1);
-
-        // allocate temporary buffers and initialize them with 0's
-        Mat tempA(dftSize, A.type(), Scalar::all(0));
-        Mat tempB(dftSize, B.type(), Scalar::all(0));
-
-        // copy A and B to the top-left corners of tempA and tempB, respectively
-        Mat roiA(tempA, Rect(0,0,A.cols,A.rows));
-        A.copyTo(roiA);
-        Mat roiB(tempB, Rect(0,0,B.cols,B.rows));
-        B.copyTo(roiB);
-
-        // now transform the padded A & B in-place;
-        // use "nonzeroRows" hint for faster processing
-        dft(tempA, tempA, 0, A.rows);
-        dft(tempB, tempB, 0, B.rows);
-
-        // multiply the spectrums;
-        // the function handles packed spectrum representations well
-        mulSpectrums(tempA, tempB, tempA);
-
-        // transform the product back from the frequency domain.
-        // Even though all the result rows will be non-zero,
-        // you need only the first C.rows of them, and thus you
-        // pass nonzeroRows == C.rows
-        dft(tempA, tempA, DFT_INVERSE + DFT_SCALE, C.rows);
-
-        // now copy the result back to C.
-        tempA(Rect(0, 0, C.cols, C.rows)).copyTo(C);
-
-        // all the temporary buffers will be deallocated automatically
-    }
-@endcode
-To optimize this sample, consider the following approaches:
--   Since nonzeroRows != 0 is passed to the forward transform calls and since A
-and B are copied to the top-left corners of tempA and tempB, respectively, it is
-not necessary to clear the whole tempA and tempB. It is only necessary to clear
-the tempA.cols - A.cols ( tempB.cols - B.cols) rightmost columns of the
-matrices.
--   This DFT-based convolution does not have to be applied to the whole big
-arrays, especially if B is significantly smaller than A or vice versa. Instead,
-you can calculate convolution by parts. To do this, you need to split the output
-array C into multiple tiles. For each tile, estimate which parts of A and B are
-required to calculate convolution in this tile. If the tiles in C are too small,
-the speed will decrease a lot because of repeated work. In the ultimate case,
-when each tile in C is a single pixel, the algorithm becomes equivalent to the
-naive convolution algorithm. If the tiles are too big, the temporary arrays
-tempA and tempB become too big and there is also a slowdown because of bad cache
-locality. So, there is an optimal tile size somewhere in the middle.
--   If different tiles in C can be calculated in parallel and, thus, the
-convolution is done by parts, the loop can be threaded.
-
-All of the above improvements have been implemented in #matchTemplate and
-#filter2D . Therefore, by using them, you can get the performance even better
-than with the above theoretically optimal implementation. Though, those two
-functions actually calculate cross-correlation, not convolution, so you need to
-"flip" the second convolution operand B vertically and horizontally using flip .
-@note
--   An example using the discrete fourier transform can be found at
-    opencv_source_code/samples/cpp/dft.cpp
--   (Python) An example using the dft functionality to perform Wiener
-deconvolution can be found at opencv_source/samples/python/deconvolution.py
--   (Python) An example rearranging the quadrants of a Fourier image can be
-found at opencv_source/samples/python/dft.py
-@param src input array that could be real or complex.
-@param dst output array whose size and type depends on the flags .
-@param flags transformation flags, representing a combination of the #DftFlags
-@param nonzeroRows when the parameter is not zero, the function assumes that
-only the first nonzeroRows rows of the input array (#DFT_INVERSE is not set) or
-only the first nonzeroRows of the output array (#DFT_INVERSE is set) contain
-non-zeros, thus, the function can handle the rest of the rows more efficiently
-and save some time; this technique is very useful for calculating array
-cross-correlation or convolution using DFT.
-@sa dct, getOptimalDFTSize, mulSpectrums, filter2D, matchTemplate, flip,
-cartToPolar, magnitude, phase
-*/
-CV_EXPORTS_W void dft(InputArray src, OutputArray dst, int flags = 0,
-                      int nonzeroRows = 0);
-
-/** @brief Calculates the inverse Discrete Fourier Transform of a 1D or 2D
-array.
-
-idft(src, dst, flags) is equivalent to dft(src, dst, flags | #DFT_INVERSE) .
-@note None of dft and idft scales the result by default. So, you should pass
-#DFT_SCALE to one of dft or idft explicitly to make these transforms mutually
-inverse.
-@sa dft, dct, idct, mulSpectrums, getOptimalDFTSize
-@param src input floating-point real or complex array.
-@param dst output array whose size and type depend on the flags.
-@param flags operation flags (see dft and #DftFlags).
-@param nonzeroRows number of dst rows to process; the rest of the rows have
-undefined content (see the convolution sample in dft description.
-*/
-CV_EXPORTS_W void idft(InputArray src, OutputArray dst, int flags = 0,
-                       int nonzeroRows = 0);
-
-/** @brief Performs a forward or inverse discrete Cosine transform of 1D or 2D
-array.
-
-The function cv::dct performs a forward or inverse discrete Cosine transform
-(DCT) of a 1D or 2D floating-point array:
--   Forward Cosine transform of a 1D vector of N elements:
-    \f[Y = C^{(N)}  \cdot X\f]
-    where
-    \f[C^{(N)}_{jk}= \sqrt{\alpha_j/N} \cos \left ( \frac{\pi(2k+1)j}{2N} \right
-)\f] and
-    \f$\alpha_0=1\f$, \f$\alpha_j=2\f$ for *j \> 0*.
--   Inverse Cosine transform of a 1D vector of N elements:
-    \f[X =  \left (C^{(N)} \right )^{-1}  \cdot Y =  \left (C^{(N)} \right )^T
-\cdot Y\f] (since \f$C^{(N)}\f$ is an orthogonal matrix, \f$C^{(N)} \cdot
-\left(C^{(N)}\right)^T = I\f$ )
--   Forward 2D Cosine transform of M x N matrix:
-    \f[Y = C^{(N)}  \cdot X  \cdot \left (C^{(N)} \right )^T\f]
--   Inverse 2D Cosine transform of M x N matrix:
-    \f[X =  \left (C^{(N)} \right )^T  \cdot X  \cdot C^{(N)}\f]
-
-The function chooses the mode of operation by looking at the flags and size of
-the input array:
--   If (flags & #DCT_INVERSE) == 0, the function does a forward 1D or 2D
-transform. Otherwise, it is an inverse 1D or 2D transform.
--   If (flags & #DCT_ROWS) != 0, the function performs a 1D transform of each
-row.
--   If the array is a single column or a single row, the function performs a 1D
-transform.
--   If none of the above is true, the function performs a 2D transform.
-
-@note Currently dct supports even-size arrays (2, 4, 6 ...). For data analysis
-and approximation, you can pad the array when necessary. Also, the function
-performance depends very much, and not monotonically, on the array size (see
-getOptimalDFTSize ). In the current implementation DCT of a vector of size N is
-calculated via DFT of a vector of size N/2 . Thus, the optimal DCT size N1 \>= N
-can be calculated as:
-@code
-    size_t getOptimalDCTSize(size_t N) { return 2*getOptimalDFTSize((N+1)/2); }
-    N1 = getOptimalDCTSize(N);
-@endcode
-@param src input floating-point array.
-@param dst output array of the same size and type as src .
-@param flags transformation flags as a combination of cv::DftFlags (DCT_*)
-@sa dft, getOptimalDFTSize, idct
-*/
-CV_EXPORTS_W void dct(InputArray src, OutputArray dst, int flags = 0);
-
-/** @brief Calculates the inverse Discrete Cosine Transform of a 1D or 2D array.
-
-idct(src, dst, flags) is equivalent to dct(src, dst, flags | DCT_INVERSE).
-@param src input floating-point single-channel array.
-@param dst output array of the same size and type as src.
-@param flags operation flags.
-@sa  dct, dft, idft, getOptimalDFTSize
-*/
-CV_EXPORTS_W void idct(InputArray src, OutputArray dst, int flags = 0);
-
-/** @brief Performs the per-element multiplication of two Fourier spectrums.
-
-The function cv::mulSpectrums performs the per-element multiplication of the two
-CCS-packed or complex matrices that are results of a real or complex Fourier
-transform.
-
-The function, together with dft and idft, may be used to calculate convolution
-(pass conjB=false ) or correlation (pass conjB=true ) of two arrays rapidly.
-When the arrays are complex, they are simply multiplied (per element) with an
-optional conjugation of the second-array elements. When the arrays are real,
-they are assumed to be CCS-packed (see dft for details).
-@param a first input array.
-@param b second input array of the same size and type as src1 .
-@param c output array of the same size and type as src1 .
-@param flags operation flags; currently, the only supported flag is
-cv::DFT_ROWS, which indicates that each row of src1 and src2 is an independent
-1D Fourier spectrum. If you do not want to use this flag, then simply add a `0`
-as value.
-@param conjB optional flag that conjugates the second input array before the
-multiplication (true) or not (false).
-*/
-CV_EXPORTS_W void mulSpectrums(InputArray a, InputArray b, OutputArray c,
-                               int flags, bool conjB = false);
-
-/** @brief Returns the optimal DFT size for a given vector size.
-
-DFT performance is not a monotonic function of a vector size. Therefore, when
-you calculate convolution of two arrays or perform the spectral analysis of an
-array, it usually makes sense to pad the input data with zeros to get a bit
-larger array that can be transformed much faster than the original one. Arrays
-whose size is a power-of-two (2, 4, 8, 16, 32, ...) are the fastest to process.
-Though, the arrays whose size is a product of 2's, 3's, and 5's (for example,
-300 = 5\*5\*3\*2\*2) are also processed quite efficiently.
-
-The function cv::getOptimalDFTSize returns the minimum number N that is greater
-than or equal to vecsize so that the DFT of a vector of size N can be processed
-efficiently. In the current implementation N = 2 ^p^ \* 3 ^q^ \* 5 ^r^ for some
-integer p, q, r.
-
-The function returns a negative number if vecsize is too large (very close to
-INT_MAX ).
-
-While the function cannot be used directly to estimate the optimal vector size
-for DCT transform (since the current DCT implementation supports only even-size
-vectors), it can be easily processed as getOptimalDFTSize((vecsize+1)/2)\*2.
-@param vecsize vector size.
-@sa dft, dct, idft, idct, mulSpectrums
-*/
-CV_EXPORTS_W int getOptimalDFTSize(int vecsize);
-
-/** @brief Returns the default random number generator.
-
-The function cv::theRNG returns the default random number generator. For each
-thread, there is a separate random number generator, so you can use the function
-safely in multi-thread environments. If you just need to get a single random
-number using this generator or initialize an array, you can use randu or randn
-instead. But if you are going to generate many random numbers inside a loop, it
-is much faster to use this function to retrieve the generator and then use
-RNG::operator _Tp() .
-@sa RNG, randu, randn
-*/
-CV_EXPORTS RNG &theRNG();
-
-/** @brief Sets state of default random number generator.
-
-The function cv::setRNGSeed sets state of default random number generator to
-custom value.
-@param seed new state for default random number generator
-@sa RNG, randu, randn
-*/
-CV_EXPORTS_W void setRNGSeed(int seed);
-
-/** @brief Generates a single uniformly-distributed random number or an array of
-random numbers.
-
-Non-template variant of the function fills the matrix dst with
-uniformly-distributed random numbers from the specified range:
-\f[\texttt{low} _c  \leq \texttt{dst} (I)_c <  \texttt{high} _c\f]
-@param dst output array of random numbers; the array must be pre-allocated.
-@param low inclusive lower boundary of the generated random numbers.
-@param high exclusive upper boundary of the generated random numbers.
-@sa RNG, randn, theRNG
-*/
-CV_EXPORTS_W void randu(InputOutputArray dst, InputArray low, InputArray high);
-
-/** @brief Fills the array with normally distributed random numbers.
-
-The function cv::randn fills the matrix dst with normally distributed random
-numbers with the specified mean vector and the standard deviation matrix. The
-generated random numbers are clipped to fit the value range of the output array
-data type.
-@param dst output array of random numbers; the array must be pre-allocated and
-have 1 to 4 channels.
-@param mean mean value (expectation) of the generated random numbers.
-@param stddev standard deviation of the generated random numbers; it can be
-either a vector (in which case a diagonal standard deviation matrix is assumed)
-or a square matrix.
-@sa RNG, randu
-*/
-CV_EXPORTS_W void randn(InputOutputArray dst, InputArray mean,
-                        InputArray stddev);
-
-/** @brief Shuffles the array elements randomly.
-
-The function cv::randShuffle shuffles the specified 1D array by randomly
-choosing pairs of elements and swapping them. The number of such swap operations
-will be dst.rows\*dst.cols\*iterFactor .
-@param dst input/output numerical 1D array.
-@param iterFactor scale factor that determines the number of random swap
-operations (see the details below).
-@param rng optional random number generator used for shuffling; if it is zero,
-theRNG () is used instead.
-@sa RNG, sort
-*/
-CV_EXPORTS_W void randShuffle(InputOutputArray dst, double iterFactor = 1.,
-                              RNG *rng = 0);
-
-/** @brief Principal Component Analysis
-
-The class is used to calculate a special basis for a set of vectors. The
-basis will consist of eigenvectors of the covariance matrix calculated
-from the input set of vectors. The class %PCA can also transform
-vectors to/from the new coordinate space defined by the basis. Usually,
-in this new coordinate system, each vector from the original set (and
-any linear combination of such vectors) can be quite accurately
-approximated by taking its first few components, corresponding to the
-eigenvectors of the largest eigenvalues of the covariance matrix.
-Geometrically it means that you calculate a projection of the vector to
-a subspace formed by a few eigenvectors corresponding to the dominant
-eigenvalues of the covariance matrix. And usually such a projection is
-very close to the original vector. So, you can represent the original
-vector from a high-dimensional space with a much shorter vector
-consisting of the projected vector's coordinates in the subspace. Such a
-transformation is also known as Karhunen-Loeve Transform, or KLT.
-See http://en.wikipedia.org/wiki/Principal_component_analysis
-
-The sample below is the function that takes two matrices. The first
-function stores a set of vectors (a row per vector) that is used to
-calculate PCA. The second function stores another "test" set of vectors
-(a row per vector). First, these vectors are compressed with PCA, then
-reconstructed back, and then the reconstruction error norm is computed
-and printed for each vector. :
-
-@code{.cpp}
-using namespace cv;
-
-PCA compressPCA(const Mat& pcaset, int maxComponents,
-                const Mat& testset, Mat& compressed)
-{
-    PCA pca(pcaset, // pass the data
-            Mat(), // we do not have a pre-computed mean vector,
-                   // so let the PCA engine to compute it
-            PCA::DATA_AS_ROW, // indicate that the vectors
-                                // are stored as matrix rows
-                                // (use PCA::DATA_AS_COL if the vectors are
-                                // the matrix columns)
-            maxComponents // specify, how many principal components to retain
-            );
-    // if there is no test data, just return the computed basis, ready-to-use
-    if( !testset.data )
-        return pca;
-    CV_Assert( testset.cols == pcaset.cols );
-
-    compressed.create(testset.rows, maxComponents, testset.type());
-
-    Mat reconstructed;
-    for( int i = 0; i < testset.rows; i++ )
-    {
-        Mat vec = testset.row(i), coeffs = compressed.row(i), reconstructed;
-        // compress the vector, the result will be stored
-        // in the i-th row of the output matrix
-        pca.project(vec, coeffs);
-        // and then reconstruct it
-        pca.backProject(coeffs, reconstructed);
-        // and measure the error
-        printf("%d. diff = %g\n", i, norm(vec, reconstructed, NORM_L2));
-    }
-    return pca;
-}
-@endcode
-@sa calcCovarMatrix, mulTransposed, SVD, dft, dct
-*/
-class CV_EXPORTS PCA {
-public:
-  enum Flags {
-    DATA_AS_ROW =
-        0, //!< indicates that the input samples are stored as matrix rows
-    DATA_AS_COL =
-        1, //!< indicates that the input samples are stored as matrix columns
-    USE_AVG = 2 //!
-  };
-
-  /** @brief default constructor
-
-  The default constructor initializes an empty %PCA structure. The other
-  constructors initialize the structure and call PCA::operator()().
-  */
-  PCA();
-
-  /** @overload
-  @param data input samples stored as matrix rows or matrix columns.
-  @param mean optional mean value; if the matrix is empty (@c noArray()),
-  the mean is computed from the data.
-  @param flags operation flags; currently the parameter is only used to
-  specify the data layout (PCA::Flags)
-  @param maxComponents maximum number of components that %PCA should
-  retain; by default, all the components are retained.
-  */
-  PCA(InputArray data, InputArray mean, int flags, int maxComponents = 0);
-
-  /** @overload
-  @param data input samples stored as matrix rows or matrix columns.
-  @param mean optional mean value; if the matrix is empty (noArray()),
-  the mean is computed from the data.
-  @param flags operation flags; currently the parameter is only used to
-  specify the data layout (PCA::Flags)
-  @param retainedVariance Percentage of variance that PCA should retain.
-  Using this parameter will let the PCA decided how many components to
-  retain but it will always keep at least 2.
-  */
-  PCA(InputArray data, InputArray mean, int flags, double retainedVariance);
-
-  /** @brief performs %PCA
-
-  The operator performs %PCA of the supplied dataset. It is safe to reuse
-  the same PCA structure for multiple datasets. That is, if the structure
-  has been previously used with another dataset, the existing internal
-  data is reclaimed and the new @ref eigenvalues, @ref eigenvectors and @ref
-  mean are allocated and computed.
-
-  The computed @ref eigenvalues are sorted from the largest to the smallest and
-  the corresponding @ref eigenvectors are stored as eigenvectors rows.
-
-  @param data input samples stored as the matrix rows or as the matrix
-  columns.
-  @param mean optional mean value; if the matrix is empty (noArray()),
-  the mean is computed from the data.
-  @param flags operation flags; currently the parameter is only used to
-  specify the data layout. (Flags)
-  @param maxComponents maximum number of components that PCA should
-  retain; by default, all the components are retained.
-  */
-  PCA &operator()(InputArray data, InputArray mean, int flags,
-                  int maxComponents = 0);
-
-  /** @overload
-  @param data input samples stored as the matrix rows or as the matrix
-  columns.
-  @param mean optional mean value; if the matrix is empty (noArray()),
-  the mean is computed from the data.
-  @param flags operation flags; currently the parameter is only used to
-  specify the data layout. (PCA::Flags)
-  @param retainedVariance Percentage of variance that %PCA should retain.
-  Using this parameter will let the %PCA decided how many components to
-  retain but it will always keep at least 2.
-   */
-  PCA &operator()(InputArray data, InputArray mean, int flags,
-                  double retainedVariance);
-
-  /** @brief Projects vector(s) to the principal component subspace.
-
-  The methods project one or more vectors to the principal component
-  subspace, where each vector projection is represented by coefficients in
-  the principal component basis. The first form of the method returns the
-  matrix that the second form writes to the result. So the first form can
-  be used as a part of expression while the second form can be more
-  efficient in a processing loop.
-  @param vec input vector(s); must have the same dimensionality and the
-  same layout as the input data used at %PCA phase, that is, if
-  DATA_AS_ROW are specified, then `vec.cols==data.cols`
-  (vector dimensionality) and `vec.rows` is the number of vectors to
-  project, and the same is true for the PCA::DATA_AS_COL case.
-  */
-  Mat project(InputArray vec) const;
-
-  /** @overload
-  @param vec input vector(s); must have the same dimensionality and the
-  same layout as the input data used at PCA phase, that is, if
-  DATA_AS_ROW are specified, then `vec.cols==data.cols`
-  (vector dimensionality) and `vec.rows` is the number of vectors to
-  project, and the same is true for the PCA::DATA_AS_COL case.
-  @param result output vectors; in case of PCA::DATA_AS_COL, the
-  output matrix has as many columns as the number of input vectors, this
-  means that `result.cols==vec.cols` and the number of rows match the
-  number of principal components (for example, `maxComponents` parameter
-  passed to the constructor).
-   */
-  void project(InputArray vec, OutputArray result) const;
-
-  /** @brief Reconstructs vectors from their PC projections.
-
-  The methods are inverse operations to PCA::project. They take PC
-  coordinates of projected vectors and reconstruct the original vectors.
-  Unless all the principal components have been retained, the
-  reconstructed vectors are different from the originals. But typically,
-  the difference is small if the number of components is large enough (but
-  still much smaller than the original vector dimensionality). As a
-  result, PCA is used.
-  @param vec coordinates of the vectors in the principal component
-  subspace, the layout and size are the same as of PCA::project output
-  vectors.
-   */
-  Mat backProject(InputArray vec) const;
-
-  /** @overload
-  @param vec coordinates of the vectors in the principal component
-  subspace, the layout and size are the same as of PCA::project output
-  vectors.
-  @param result reconstructed vectors; the layout and size are the same as
-  of PCA::project input vectors.
-   */
-  void backProject(InputArray vec, OutputArray result) const;
-
-  /** @brief write PCA objects
-
-  Writes @ref eigenvalues @ref eigenvectors and @ref mean to specified
-  FileStorage
-   */
-  void write(FileStorage &fs) const;
-
-  /** @brief load PCA objects
-
-  Loads @ref eigenvalues @ref eigenvectors and @ref mean from specified FileNode
-   */
-  void read(const FileNode &fn);
-
-  Mat eigenvectors; //!< eigenvectors of the covariation matrix
-  Mat eigenvalues;  //!< eigenvalues of the covariation matrix
-  Mat mean; //!< mean value subtracted before the projection and added after the
-            //!< back projection
-};
-
-/** @example samples/cpp/pca.cpp
-An example using %PCA for dimensionality reduction while maintaining an amount
-of variance
-*/
-
-/** @example
-samples/cpp/tutorial_code/ml/introduction_to_pca/introduction_to_pca.cpp Check
-@ref tutorial_introduction_to_pca "the corresponding tutorial" for more details
-*/
-
-/**
-@brief Linear Discriminant Analysis
-@todo document this class
-*/
-class CV_EXPORTS LDA {
-public:
-  /** @brief constructor
-  Initializes a LDA with num_components (default 0).
-  */
-  explicit LDA(int num_components = 0);
-
-  /** Initializes and performs a Discriminant Analysis with Fisher's
-   Optimization Criterion on given data in src and corresponding labels
-   in labels. If 0 (or less) number of components are given, they are
-   automatically determined for given data in computation.
-  */
-  LDA(InputArrayOfArrays src, InputArray labels, int num_components = 0);
-
-  /** Serializes this object to a given filename.
-   */
-  void save(const String &filename) const;
-
-  /** Deserializes this object from a given filename.
-   */
-  void load(const String &filename);
-
-  /** Serializes this object to a given cv::FileStorage.
-   */
-  void save(FileStorage &fs) const;
-
-  /** Deserializes this object from a given cv::FileStorage.
-   */
-  void load(const FileStorage &node);
-
-  /** destructor
-   */
-  ~LDA();
-
-  /** Compute the discriminants for data in src (row aligned) and labels.
-   */
-  void compute(InputArrayOfArrays src, InputArray labels);
-
-  /** Projects samples into the LDA subspace.
-      src may be one or more row aligned samples.
-    */
-  Mat project(InputArray src);
-
-  /** Reconstructs projections from the LDA subspace.
-      src may be one or more row aligned projections.
-    */
-  Mat reconstruct(InputArray src);
-
-  /** Returns the eigenvectors of this LDA.
-   */
-  Mat eigenvectors() const { return _eigenvectors; }
-
-  /** Returns the eigenvalues of this LDA.
-   */
-  Mat eigenvalues() const { return _eigenvalues; }
-
-  static Mat subspaceProject(InputArray W, InputArray mean, InputArray src);
-  static Mat subspaceReconstruct(InputArray W, InputArray mean, InputArray src);
-
-protected:
-  int _num_components;
-  Mat _eigenvectors;
-  Mat _eigenvalues;
-  void lda(InputArrayOfArrays src, InputArray labels);
-};
-
-/** @brief Singular Value Decomposition
-
-Class for computing Singular Value Decomposition of a floating-point
-matrix. The Singular Value Decomposition is used to solve least-square
-problems, under-determined linear systems, invert matrices, compute
-condition numbers, and so on.
-
-If you want to compute a condition number of a matrix or an absolute value of
-its determinant, you do not need `u` and `vt`. You can pass
-flags=SVD::NO_UV|... . Another flag SVD::FULL_UV indicates that full-size u
-and vt must be computed, which is not necessary most of the time.
-
-@sa invert, solve, eigen, determinant
-*/
-class CV_EXPORTS SVD {
-public:
-  enum Flags {
-    /** allow the algorithm to modify the decomposed matrix; it can save space
-       and speed up processing. currently ignored. */
-    MODIFY_A = 1,
-    /** indicates that only a vector of singular values `w` is to be processed,
-       while u and vt will be set to empty matrices */
-    NO_UV = 2,
-    /** when the matrix is not square, by default the algorithm produces u and
-       vt matrices of sufficiently large size for the further A reconstruction;
-       if, however, FULL_UV flag is specified, u and vt will be full-size square
-       orthogonal matrices.*/
-    FULL_UV = 4
-  };
-
-  /** @brief the default constructor
-
-  initializes an empty SVD structure
-    */
-  SVD();
-
-  /** @overload
-  initializes an empty SVD structure and then calls SVD::operator()
-  @param src decomposed matrix. The depth has to be CV_32F or CV_64F.
-  @param flags operation flags (SVD::Flags)
-    */
-  SVD(InputArray src, int flags = 0);
-
-  /** @brief the operator that performs SVD. The previously allocated u, w and
-  vt are released.
-
-  The operator performs the singular value decomposition of the supplied
-  matrix. The u,`vt` , and the vector of singular values w are stored in
-  the structure. The same SVD structure can be reused many times with
-  different matrices. Each time, if needed, the previous u,`vt` , and w
-  are reclaimed and the new matrices are created, which is all handled by
-  Mat::create.
-  @param src decomposed matrix. The depth has to be CV_32F or CV_64F.
-  @param flags operation flags (SVD::Flags)
-    */
-  SVD &operator()(InputArray src, int flags = 0);
-
-  /** @brief decomposes matrix and stores the results to user-provided matrices
-
-  The methods/functions perform SVD of matrix. Unlike SVD::SVD constructor
-  and SVD::operator(), they store the results to the user-provided
-  matrices:
-
-  @code{.cpp}
-  Mat A, w, u, vt;
-  SVD::compute(A, w, u, vt);
-  @endcode
-
-  @param src decomposed matrix. The depth has to be CV_32F or CV_64F.
-  @param w calculated singular values
-  @param u calculated left singular vectors
-  @param vt transposed matrix of right singular vectors
-  @param flags operation flags - see SVD::Flags.
-    */
-  static void compute(InputArray src, OutputArray w, OutputArray u,
-                      OutputArray vt, int flags = 0);
-
-  /** @overload
-  computes singular values of a matrix
-  @param src decomposed matrix. The depth has to be CV_32F or CV_64F.
-  @param w calculated singular values
-  @param flags operation flags - see SVD::Flags.
-    */
-  static void compute(InputArray src, OutputArray w, int flags = 0);
-
-  /** @brief performs back substitution
-   */
-  static void backSubst(InputArray w, InputArray u, InputArray vt,
-                        InputArray rhs, OutputArray dst);
-
-  /** @brief solves an under-determined singular linear system
-
-  The method finds a unit-length solution x of a singular linear system
-  A\*x = 0. Depending on the rank of A, there can be no solutions, a
-  single solution or an infinite number of solutions. In general, the
-  algorithm solves the following problem:
-  \f[dst =  \arg \min _{x:  \| x \| =1}  \| src  \cdot x  \|\f]
-  @param src left-hand-side matrix.
-  @param dst found solution.
-    */
-  static void solveZ(InputArray src, OutputArray dst);
-
-  /** @brief performs a singular value back substitution.
-
-  The method calculates a back substitution for the specified right-hand
-  side:
-
-  \f[\texttt{x} =  \texttt{vt} ^T  \cdot diag( \texttt{w} )^{-1}  \cdot
-  \texttt{u} ^T  \cdot \texttt{rhs} \sim \texttt{A} ^{-1}  \cdot \texttt{rhs}\f]
-
-  Using this technique you can either get a very accurate solution of the
-  convenient linear system, or the best (in the least-squares terms)
-  pseudo-solution of an overdetermined linear system.
-
-  @param rhs right-hand side of a linear system (u\*w\*v')\*dst = rhs to
-  be solved, where A has been previously decomposed.
-
-  @param dst found solution of the system.
-
-  @note Explicit SVD with the further back substitution only makes sense
-  if you need to solve many linear systems with the same left-hand side
-  (for example, src ). If all you need is to solve a single system
-  (possibly with multiple rhs immediately available), simply call solve
-  add pass #DECOMP_SVD there. It does absolutely the same thing.
-    */
-  void backSubst(InputArray rhs, OutputArray dst) const;
-
-  /** @todo document */
-  template <typename _Tp, int m, int n, int nm>
-  static void compute(const Matx<_Tp, m, n> &a, Matx<_Tp, nm, 1> &w,
-                      Matx<_Tp, m, nm> &u, Matx<_Tp, n, nm> &vt);
-
-  /** @todo document */
-  template <typename _Tp, int m, int n, int nm>
-  static void compute(const Matx<_Tp, m, n> &a, Matx<_Tp, nm, 1> &w);
-
-  /** @todo document */
-  template <typename _Tp, int m, int n, int nm, int nb>
-  static void backSubst(const Matx<_Tp, nm, 1> &w, const Matx<_Tp, m, nm> &u,
-                        const Matx<_Tp, n, nm> &vt, const Matx<_Tp, m, nb> &rhs,
-                        Matx<_Tp, n, nb> &dst);
-
-  Mat u, w, vt;
-};
-
-/** @brief Random Number Generator
-
-Random number generator. It encapsulates the state (currently, a 64-bit
-integer) and has methods to return scalar random values and to fill
-arrays with random values. Currently it supports uniform and Gaussian
-(normal) distributions. The generator uses Multiply-With-Carry
-algorithm, introduced by G. Marsaglia (
-<http://en.wikipedia.org/wiki/Multiply-with-carry> ).
-Gaussian-distribution random numbers are generated using the Ziggurat
-algorithm ( <http://en.wikipedia.org/wiki/Ziggurat_algorithm> ),
-introduced by G. Marsaglia and W. W. Tsang.
-*/
-class CV_EXPORTS RNG {
-public:
-  enum { UNIFORM = 0, NORMAL = 1 };
-
-  /** @brief constructor
-
-  These are the RNG constructors. The first form sets the state to some
-  pre-defined value, equal to 2\*\*32-1 in the current implementation. The
-  second form sets the state to the specified value. If you passed state=0
-  , the constructor uses the above default value instead to avoid the
-  singular random number sequence, consisting of all zeros.
-  */
-  RNG();
-  /** @overload
-  @param state 64-bit value used to initialize the RNG.
-  */
-  RNG(uint64 state);
-  /**The method updates the state using the MWC algorithm and returns the
-  next 32-bit random number.*/
-  unsigned next();
-
-  /**Each of the methods updates the state using the MWC algorithm and
-  returns the next random number of the specified type. In case of integer
-  types, the returned number is from the available value range for the
-  specified type. In case of floating-point types, the returned value is
-  from [0,1) range.
-  */
-  operator uchar();
-  /** @overload */
-  operator schar();
-  /** @overload */
-  operator ushort();
-  /** @overload */
-  operator short();
-  /** @overload */
-  operator unsigned();
-  /** @overload */
-  operator int();
-  /** @overload */
-  operator float();
-  /** @overload */
-  operator double();
-
-  /** @brief returns a random integer sampled uniformly from [0, N).
-
-  The methods transform the state using the MWC algorithm and return the
-  next random number. The first form is equivalent to RNG::next . The
-  second form returns the random number modulo N, which means that the
-  result is in the range [0, N) .
-  */
-  unsigned operator()();
-  /** @overload
-  @param N upper non-inclusive boundary of the returned random number.
-  */
-  unsigned operator()(unsigned N);
-
-  /** @brief returns uniformly distributed integer random number from [a,b)
-  range
-
-  The methods transform the state using the MWC algorithm and return the
-  next uniformly-distributed random number of the specified type, deduced
-  from the input parameter type, from the range [a, b) . There is a nuance
-  illustrated by the following sample:
-
-  @code{.cpp}
-  RNG rng;
-
-  // always produces 0
-  double a = rng.uniform(0, 1);
-
-  // produces double from [0, 1)
-  double a1 = rng.uniform((double)0, (double)1);
-
-  // produces float from [0, 1)
-  float b = rng.uniform(0.f, 1.f);
-
-  // produces double from [0, 1)
-  double c = rng.uniform(0., 1.);
-
-  // may cause compiler error because of ambiguity:
-  //  RNG::uniform(0, (int)0.999999)? or RNG::uniform((double)0, 0.99999)?
-  double d = rng.uniform(0, 0.999999);
-  @endcode
-
-  The compiler does not take into account the type of the variable to
-  which you assign the result of RNG::uniform . The only thing that
-  matters to the compiler is the type of a and b parameters. So, if you
-  want a floating-point random number, but the range boundaries are
-  integer numbers, either put dots in the end, if they are constants, or
-  use explicit type cast operators, as in the a1 initialization above.
-  @param a lower inclusive boundary of the returned random number.
-  @param b upper non-inclusive boundary of the returned random number.
-  */
-  int uniform(int a, int b);
-  /** @overload */
-  float uniform(float a, float b);
-  /** @overload */
-  double uniform(double a, double b);
-
-  /** @brief Fills arrays with random numbers.
-
-  @param mat 2D or N-dimensional matrix; currently matrices with more than
-  4 channels are not supported by the methods, use Mat::reshape as a
-  possible workaround.
-  @param distType distribution type, RNG::UNIFORM or RNG::NORMAL.
-  @param a first distribution parameter; in case of the uniform
-  distribution, this is an inclusive lower boundary, in case of the normal
-  distribution, this is a mean value.
-  @param b second distribution parameter; in case of the uniform
-  distribution, this is a non-inclusive upper boundary, in case of the
-  normal distribution, this is a standard deviation (diagonal of the
-  standard deviation matrix or the full standard deviation matrix).
-  @param saturateRange pre-saturation flag; for uniform distribution only;
-  if true, the method will first convert a and b to the acceptable value
-  range (according to the mat datatype) and then will generate uniformly
-  distributed random numbers within the range [saturate(a), saturate(b)),
-  if saturateRange=false, the method will generate uniformly distributed
-  random numbers in the original range [a, b) and then will saturate them,
-  it means, for example, that
-  <tt>theRNG().fill(mat_8u, RNG::UNIFORM, -DBL_MAX, DBL_MAX)</tt> will likely
-  produce array mostly filled with 0's and 255's, since the range (0, 255)
-  is significantly smaller than [-DBL_MAX, DBL_MAX).
-
-  Each of the methods fills the matrix with the random values from the
-  specified distribution. As the new numbers are generated, the RNG state
-  is updated accordingly. In case of multiple-channel images, every
-  channel is filled independently, which means that RNG cannot generate
-  samples from the multi-dimensional Gaussian distribution with
-  non-diagonal covariance matrix directly. To do that, the method
-  generates samples from multi-dimensional standard Gaussian distribution
-  with zero mean and identity covariation matrix, and then transforms them
-  using transform to get samples from the specified Gaussian distribution.
-  */
-  void fill(InputOutputArray mat, int distType, InputArray a, InputArray b,
-            bool saturateRange = false);
-
-  /** @brief Returns the next random number sampled from the Gaussian
-  distribution
-  @param sigma standard deviation of the distribution.
-
-  The method transforms the state using the MWC algorithm and returns the
-  next random number from the Gaussian distribution N(0,sigma) . That is,
-  the mean value of the returned random numbers is zero and the standard
-  deviation is the specified sigma .
-  */
-  double gaussian(double sigma);
-
-  uint64 state;
-
-  bool operator==(const RNG &other) const;
-};
-
-/** @brief Mersenne Twister random number generator
-
-Inspired by
-http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/CODES/mt19937ar.c
-@todo document
-*/
-class CV_EXPORTS RNG_MT19937 {
-public:
-  RNG_MT19937();
-  RNG_MT19937(unsigned s);
-  void seed(unsigned s);
-
-  unsigned next();
-
-  operator int();
-  operator unsigned();
-  operator float();
-  operator double();
-
-  unsigned operator()(unsigned N);
-  unsigned operator()();
-
-  /** @brief returns uniformly distributed integer random number from [a,b)
-   * range*/
-  int uniform(int a, int b);
-  /** @brief returns uniformly distributed floating-point random number from
-   * [a,b) range*/
-  float uniform(float a, float b);
-  /** @brief returns uniformly distributed double-precision floating-point
-   * random number from [a,b) range*/
-  double uniform(double a, double b);
-
-private:
-  enum PeriodParameters { N = 624, M = 397 };
-  unsigned state[N];
-  int mti;
-};
-
-//! @} core_array
-
-//! @addtogroup core_cluster
-//!  @{
-
-//! k-means flags
-enum KmeansFlags {
-  /** Select random initial centers in each attempt.*/
-  KMEANS_RANDOM_CENTERS = 0,
-  /** Use kmeans++ center initialization by Arthur and Vassilvitskii
-     [Arthur2007].*/
-  KMEANS_PP_CENTERS = 2,
-  /** During the first (and possibly the only) attempt, use the
-      user-supplied labels instead of computing them from the initial centers.
-     For the second and further attempts, use the random or semi-random centers.
-     Use one of KMEANS_\*_CENTERS flag to specify the exact method.*/
-  KMEANS_USE_INITIAL_LABELS = 1
-};
-
-/** @example samples/cpp/kmeans.cpp
-An example on k-means clustering
-*/
-
-/** @brief Finds centers of clusters and groups input samples around the
-clusters.
-
-The function kmeans implements a k-means algorithm that finds the centers of
-cluster_count clusters and groups the input samples around the clusters. As an
-output, \f$\texttt{bestLabels}_i\f$ contains a 0-based cluster index for the
-sample stored in the \f$i^{th}\f$ row of the samples matrix.
-
-@note
--   (Python) An example on k-means clustering can be found at
-    opencv_source_code/samples/python/kmeans.py
-@param data Data for clustering. An array of N-Dimensional points with float
-coordinates is needed. Examples of this array can be:
--   Mat points(count, 2, CV_32F);
--   Mat points(count, 1, CV_32FC2);
--   Mat points(1, count, CV_32FC2);
--   std::vector\<cv::Point2f\> points(sampleCount);
-@param K Number of clusters to split the set by.
-@param bestLabels Input/output integer array that stores the cluster indices for
-every sample.
-@param criteria The algorithm termination criteria, that is, the maximum number
-of iterations and/or the desired accuracy. The accuracy is specified as
-criteria.epsilon. As soon as each of the cluster centers moves by less than
-criteria.epsilon on some iteration, the algorithm stops.
-@param attempts Flag to specify the number of times the algorithm is executed
-using different initial labellings. The algorithm returns the labels that yield
-the best compactness (see the last function parameter).
-@param flags Flag that can take values of cv::KmeansFlags
-@param centers Output matrix of the cluster centers, one row per each cluster
-center.
-@return The function returns the compactness measure that is computed as
-\f[\sum _i  \| \texttt{samples} _i -  \texttt{centers} _{ \texttt{labels} _i} \|
-^2\f] after every attempt. The best (minimum) value is chosen and the
-corresponding labels and the compactness value are returned by the function.
-Basically, you can use only the core of the function, set the number of attempts
-to 1, initialize labels each time using a custom algorithm, pass them with the (
-flags = #KMEANS_USE_INITIAL_LABELS ) flag, and then choose the best
-(most-compact) clustering.
-*/
-CV_EXPORTS_W double kmeans(InputArray data, int K, InputOutputArray bestLabels,
-                           TermCriteria criteria, int attempts, int flags,
-                           OutputArray centers = noArray());
-
-//! @} core_cluster
-
-//! @addtogroup core_basic
-//! @{
-
-/////////////////////////////// Formatted output of cv::Mat
-//////////////////////////////
-
-/** @todo document */
-class CV_EXPORTS Formatted {
-public:
-  virtual const char *next() = 0;
-  virtual void reset() = 0;
-  virtual ~Formatted();
-};
-
-/** @todo document */
-class CV_EXPORTS Formatter {
-public:
-  enum FormatType {
-    FMT_DEFAULT = 0,
-    FMT_MATLAB = 1,
-    FMT_CSV = 2,
-    FMT_PYTHON = 3,
-    FMT_NUMPY = 4,
-    FMT_C = 5
-  };
-
-  virtual ~Formatter();
-
-  virtual Ptr<Formatted> format(const Mat &mtx) const = 0;
-
-  virtual void set16fPrecision(int p = 4) = 0;
-  virtual void set32fPrecision(int p = 8) = 0;
-  virtual void set64fPrecision(int p = 16) = 0;
-  virtual void setMultiline(bool ml = true) = 0;
-
-  static Ptr<Formatter> get(Formatter::FormatType fmt = FMT_DEFAULT);
-};
-
-static inline String &operator<<(String &out, Ptr<Formatted> fmtd) {
-  fmtd->reset();
-  for (const char *str = fmtd->next(); str; str = fmtd->next())
-    out += cv::String(str);
-  return out;
-}
-
-static inline String &operator<<(String &out, const Mat &mtx) {
-  return out << Formatter::get()->format(mtx);
-}
-
-//////////////////////////////////////// Algorithm
-///////////////////////////////////////
-
-class CV_EXPORTS Algorithm;
-
-template <typename _Tp, typename _EnumTp = void> struct ParamType {};
-
-/** @brief This is a base class for all more or less complex algorithms in
-OpenCV
-
-especially for classes of algorithms, for which there can be multiple
-implementations. The examples are stereo correspondence (for which there are
-algorithms like block matching, semi-global block matching, graph-cut etc.),
-background subtraction (which can be done using mixture-of-gaussians models,
-codebook-based algorithm etc.), optical flow (block matching, Lucas-Kanade,
-Horn-Schunck etc.).
-
-Here is example of SimpleBlobDetector use in your application via Algorithm
-interface:
-@snippet snippets/core_various.cpp Algorithm
-*/
-class CV_EXPORTS_W Algorithm {
-public:
-  Algorithm();
-  virtual ~Algorithm();
-
-  /** @brief Clears the algorithm state
-   */
-  CV_WRAP virtual void clear() {}
-
-  /** @brief Stores algorithm parameters in a file storage
-   */
-  CV_WRAP virtual void write(FileStorage &fs) const { CV_UNUSED(fs); }
-
-  /**
-   * @overload
-   */
-  CV_WRAP void write(FileStorage &fs, const String &name) const;
-#if CV_VERSION_MAJOR < 5
-  /** @deprecated */
-  void write(const Ptr<FileStorage> &fs, const String &name = String()) const;
-#endif
-
-  /** @brief Reads algorithm parameters from a file storage
-   */
-  CV_WRAP virtual void read(const FileNode &fn) { CV_UNUSED(fn); }
-
-  /** @brief Returns true if the Algorithm is empty (e.g. in the very beginning
-   * or after unsuccessful read
-   */
-  CV_WRAP virtual bool empty() const { return false; }
-
-  /** @brief Reads algorithm from the file node
-
-  This is static template method of Algorithm. It's usage is following (in the
-  case of SVM):
-  @code
-  cv::FileStorage fsRead("example.xml", FileStorage::READ);
-  Ptr<SVM> svm = Algorithm::read<SVM>(fsRead.root());
-  @endcode
-  In order to make this method work, the derived class must overwrite
-  Algorithm::read(const FileNode& fn) and also have static create() method
-  without parameters (or with all the optional parameters)
-  */
-  template <typename _Tp> static Ptr<_Tp> read(const FileNode &fn) {
-    Ptr<_Tp> obj = _Tp::create();
-    obj->read(fn);
-    return !obj->empty() ? obj : Ptr<_Tp>();
-  }
-
-  /** @brief Loads algorithm from the file
-
-  @param filename Name of the file to read.
-  @param objname The optional name of the node to read (if empty, the first
-  top-level node will be used)
-
-  This is static template method of Algorithm. It's usage is following (in the
-  case of SVM):
-  @code
-  Ptr<SVM> svm = Algorithm::load<SVM>("my_svm_model.xml");
-  @endcode
-  In order to make this method work, the derived class must overwrite
-  Algorithm::read(const FileNode& fn).
-  */
-  template <typename _Tp>
-  static Ptr<_Tp> load(const String &filename,
-                       const String &objname = String()) {
-    FileStorage fs(filename, FileStorage::READ);
-    CV_Assert(fs.isOpened());
-    FileNode fn = objname.empty() ? fs.getFirstTopLevelNode() : fs[objname];
-    if (fn.empty())
-      return Ptr<_Tp>();
-    Ptr<_Tp> obj = _Tp::create();
-    obj->read(fn);
-    return !obj->empty() ? obj : Ptr<_Tp>();
-  }
-
-  /** @brief Loads algorithm from a String
-
-  @param strModel The string variable containing the model you want to load.
-  @param objname The optional name of the node to read (if empty, the first
-  top-level node will be used)
-
-  This is static template method of Algorithm. It's usage is following (in the
-  case of SVM):
-  @code
-  Ptr<SVM> svm = Algorithm::loadFromString<SVM>(myStringModel);
-  @endcode
-  */
-  template <typename _Tp>
-  static Ptr<_Tp> loadFromString(const String &strModel,
-                                 const String &objname = String()) {
-    FileStorage fs(strModel, FileStorage::READ + FileStorage::MEMORY);
-    FileNode fn = objname.empty() ? fs.getFirstTopLevelNode() : fs[objname];
-    Ptr<_Tp> obj = _Tp::create();
-    obj->read(fn);
-    return !obj->empty() ? obj : Ptr<_Tp>();
-  }
-
-  /** Saves the algorithm to a file.
-  In order to make this method work, the derived class must implement
-  Algorithm::write(FileStorage& fs). */
-  CV_WRAP virtual void save(const String &filename) const;
-
-  /** Returns the algorithm string identifier.
-  This string is used as top level xml/yml node tag when the object is saved to
-  a file or string. */
-  CV_WRAP virtual String getDefaultName() const;
-
-protected:
-  void writeFormat(FileStorage &fs) const;
-};
-
-enum struct Param {
-  INT = 0,
-  BOOLEAN = 1,
-  REAL = 2,
-  STRING = 3,
-  MAT = 4,
-  MAT_VECTOR = 5,
-  ALGORITHM = 6,
-  FLOAT = 7,
-  UNSIGNED_INT = 8,
-  UINT64 = 9,
-  UCHAR = 11,
-  SCALAR = 12
-};
-
-template <> struct ParamType<bool> {
-  typedef bool const_param_type;
-  typedef bool member_type;
-
-  static const Param type = Param::BOOLEAN;
-};
-
-template <> struct ParamType<int> {
-  typedef int const_param_type;
-  typedef int member_type;
-
-  static const Param type = Param::INT;
-};
-
-template <> struct ParamType<double> {
-  typedef double const_param_type;
-  typedef double member_type;
-
-  static const Param type = Param::REAL;
-};
-
-template <> struct ParamType<String> {
-  typedef const String &const_param_type;
-  typedef String member_type;
-
-  static const Param type = Param::STRING;
-};
-
-template <> struct ParamType<Mat> {
-  typedef const Mat &const_param_type;
-  typedef Mat member_type;
-
-  static const Param type = Param::MAT;
-};
-
-template <> struct ParamType<std::vector<Mat>> {
-  typedef const std::vector<Mat> &const_param_type;
-  typedef std::vector<Mat> member_type;
-
-  static const Param type = Param::MAT_VECTOR;
-};
-
-template <> struct ParamType<Algorithm> {
-  typedef const Ptr<Algorithm> &const_param_type;
-  typedef Ptr<Algorithm> member_type;
-
-  static const Param type = Param::ALGORITHM;
-};
-
-template <> struct ParamType<float> {
-  typedef float const_param_type;
-  typedef float member_type;
-
-  static const Param type = Param::FLOAT;
-};
-
-template <> struct ParamType<unsigned> {
-  typedef unsigned const_param_type;
-  typedef unsigned member_type;
-
-  static const Param type = Param::UNSIGNED_INT;
-};
-
-template <> struct ParamType<uint64> {
-  typedef uint64 const_param_type;
-  typedef uint64 member_type;
-
-  static const Param type = Param::UINT64;
-};
-
-template <> struct ParamType<uchar> {
-  typedef uchar const_param_type;
-  typedef uchar member_type;
-
-  static const Param type = Param::UCHAR;
-};
-
-template <> struct ParamType<Scalar> {
-  typedef const Scalar &const_param_type;
-  typedef Scalar member_type;
-
-  static const Param type = Param::SCALAR;
-};
-
-template <typename _Tp>
-struct ParamType<_Tp, typename std::enable_if<std::is_enum<_Tp>::value>::type> {
-  typedef typename std::underlying_type<_Tp>::type const_param_type;
-  typedef typename std::underlying_type<_Tp>::type member_type;
-
-  static const Param type = Param::INT;
-};
-
-//! @} core_basic
-
-} // namespace cv
-
-#include "opencv2/core/cvstd.inl.hpp"
-#include "opencv2/core/operations.hpp"
-#include "opencv2/core/optim.hpp"
-#include "opencv2/core/utility.hpp"
-
-#endif /*OPENCV_CORE_HPP*/
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/affine.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/affine.hpp
deleted file mode 100644
index f4aabb409d..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/affine.hpp
+++ /dev/null
@@ -1,676 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_CORE_AFFINE3_HPP
-#define OPENCV_CORE_AFFINE3_HPP
-
-#ifdef __cplusplus
-
-#include <opencv2/core.hpp>
-
-namespace cv {
-
-//! @addtogroup core_eigen
-//! @{
-
-/** @brief Affine transform
- *
- * It represents a 4x4 homogeneous transformation matrix \f$T\f$
- *
- *  \f[T =
- *  \begin{bmatrix}
- *  R & t\\
- *  0 & 1\\
- *  \end{bmatrix}
- *  \f]
- *
- *  where \f$R\f$ is a 3x3 rotation matrix and \f$t\f$ is a 3x1 translation
- * vector.
- *
- *  You can specify \f$R\f$ either by a 3x3 rotation matrix or by a 3x1 rotation
- * vector, which is converted to a 3x3 rotation matrix by the Rodrigues formula.
- *
- *  To construct a matrix \f$T\f$ representing first rotation around the axis
- * \f$r\f$ with rotation angle \f$|r|\f$ in radian (right hand rule) and then
- * translation by the vector \f$t\f$, you can use
- *
- *  @code
- *  cv::Vec3f r, t;
- *  cv::Affine3f T(r, t);
- *  @endcode
- *
- *  If you already have the rotation matrix \f$R\f$, then you can use
- *
- *  @code
- *  cv::Matx33f R;
- *  cv::Affine3f T(R, t);
- *  @endcode
- *
- *  To extract the rotation matrix \f$R\f$ from \f$T\f$, use
- *
- *  @code
- *  cv::Matx33f R = T.rotation();
- *  @endcode
- *
- *  To extract the translation vector \f$t\f$ from \f$T\f$, use
- *
- *  @code
- *  cv::Vec3f t = T.translation();
- *  @endcode
- *
- *  To extract the rotation vector \f$r\f$ from \f$T\f$, use
- *
- *  @code
- *  cv::Vec3f r = T.rvec();
- *  @endcode
- *
- *  Note that since the mapping from rotation vectors to rotation matrices
- *  is many to one. The returned rotation vector is not necessarily the one
- *  you used before to set the matrix.
- *
- *  If you have two transformations \f$T = T_1 * T_2\f$, use
- *
- *  @code
- *  cv::Affine3f T, T1, T2;
- *  T = T2.concatenate(T1);
- *  @endcode
- *
- *  To get the inverse transform of \f$T\f$, use
- *
- *  @code
- *  cv::Affine3f T, T_inv;
- *  T_inv = T.inv();
- *  @endcode
- *
- */
-template <typename T> class Affine3 {
-public:
-  typedef T float_type;
-  typedef Matx<float_type, 3, 3> Mat3;
-  typedef Matx<float_type, 4, 4> Mat4;
-  typedef Vec<float_type, 3> Vec3;
-
-  //! Default constructor. It represents a 4x4 identity matrix.
-  Affine3();
-
-  //! Augmented affine matrix
-  Affine3(const Mat4 &affine);
-
-  /**
-   *  The resulting 4x4 matrix is
-   *
-   *  \f[
-   *  \begin{bmatrix}
-   *  R & t\\
-   *  0 & 1\\
-   *  \end{bmatrix}
-   *  \f]
-   *
-   * @param R 3x3 rotation matrix.
-   * @param t 3x1 translation vector.
-   */
-  Affine3(const Mat3 &R, const Vec3 &t = Vec3::all(0));
-
-  /**
-   * Rodrigues vector.
-   *
-   * The last row of the current matrix is set to [0,0,0,1].
-   *
-   * @param rvec 3x1 rotation vector. Its direction indicates the rotation axis
-   * and its length indicates the rotation angle in radian (using right hand
-   * rule).
-   * @param t 3x1 translation vector.
-   */
-  Affine3(const Vec3 &rvec, const Vec3 &t = Vec3::all(0));
-
-  /**
-   * Combines all constructors above. Supports 4x4, 3x4, 3x3, 1x3, 3x1 sizes of
-   * data matrix.
-   *
-   * The last row of the current matrix is set to [0,0,0,1] when data is not
-   * 4x4.
-   *
-   * @param data 1-channel matrix.
-   *             when it is 4x4, it is copied to the current matrix and t is not
-   * used. When it is 3x4, it is copied to the upper part 3x4 of the current
-   * matrix and t is not used. When it is 3x3, it is copied to the upper left
-   * 3x3 part of the current matrix. When it is 3x1 or 1x3, it is treated as a
-   * rotation vector and the Rodrigues formula is used to compute a 3x3 rotation
-   * matrix.
-   * @param t 3x1 translation vector. It is used only when data is neither 4x4
-   * nor 3x4.
-   */
-  explicit Affine3(const Mat &data, const Vec3 &t = Vec3::all(0));
-
-  //! From 16-element array
-  explicit Affine3(const float_type *vals);
-
-  //! Create an 4x4 identity transform
-  static Affine3 Identity();
-
-  /**
-   * Rotation matrix.
-   *
-   * Copy the rotation matrix to the upper left 3x3 part of the current matrix.
-   * The remaining elements of the current matrix are not changed.
-   *
-   * @param R 3x3 rotation matrix.
-   *
-   */
-  void rotation(const Mat3 &R);
-
-  /**
-   * Rodrigues vector.
-   *
-   * It sets the upper left 3x3 part of the matrix. The remaining part is
-   * unaffected.
-   *
-   * @param rvec 3x1 rotation vector. The direction indicates the rotation axis
-   * and its length indicates the rotation angle in radian (using the right
-   * thumb convention).
-   */
-  void rotation(const Vec3 &rvec);
-
-  /**
-   * Combines rotation methods above. Supports 3x3, 1x3, 3x1 sizes of data
-   * matrix.
-   *
-   * It sets the upper left 3x3 part of the matrix. The remaining part is
-   * unaffected.
-   *
-   * @param data 1-channel matrix.
-   *             When it is a 3x3 matrix, it sets the upper left 3x3 part of the
-   * current matrix. When it is a 1x3 or 3x1 matrix, it is used as a rotation
-   * vector. The Rodrigues formula is used to compute the rotation matrix and
-   * sets the upper left 3x3 part of the current matrix.
-   */
-  void rotation(const Mat &data);
-
-  /**
-   * Copy the 3x3 matrix L to the upper left part of the current matrix
-   *
-   * It sets the upper left 3x3 part of the matrix. The remaining part is
-   * unaffected.
-   *
-   * @param L 3x3 matrix.
-   */
-  void linear(const Mat3 &L);
-
-  /**
-   * Copy t to the first three elements of the last column of the current matrix
-   *
-   * It sets the upper right 3x1 part of the matrix. The remaining part is
-   * unaffected.
-   *
-   * @param t 3x1 translation vector.
-   */
-  void translation(const Vec3 &t);
-
-  //! @return the upper left 3x3 part
-  Mat3 rotation() const;
-
-  //! @return the upper left 3x3 part
-  Mat3 linear() const;
-
-  //! @return the upper right 3x1 part
-  Vec3 translation() const;
-
-  //! Rodrigues vector.
-  //! @return a vector representing the upper left 3x3 rotation matrix of the
-  //! current matrix.
-  //! @warning  Since the mapping between rotation vectors and rotation matrices
-  //! is many to one,
-  //!           this function returns only one rotation vector that represents
-  //!           the current rotation matrix, which is not necessarily the same
-  //!           one set by `rotation(const Vec3& rvec)`.
-  Vec3 rvec() const;
-
-  //! @return the inverse of the current matrix.
-  Affine3 inv(int method = cv::DECOMP_SVD) const;
-
-  //! a.rotate(R) is equivalent to Affine(R, 0) * a;
-  Affine3 rotate(const Mat3 &R) const;
-
-  //! a.rotate(rvec) is equivalent to Affine(rvec, 0) * a;
-  Affine3 rotate(const Vec3 &rvec) const;
-
-  //! a.translate(t) is equivalent to Affine(E, t) * a, where E is an identity
-  //! matrix
-  Affine3 translate(const Vec3 &t) const;
-
-  //! a.concatenate(affine) is equivalent to affine * a;
-  Affine3 concatenate(const Affine3 &affine) const;
-
-  template <typename Y> operator Affine3<Y>() const;
-
-  template <typename Y> Affine3<Y> cast() const;
-
-  Mat4 matrix;
-
-#if defined EIGEN_WORLD_VERSION && defined EIGEN_GEOMETRY_MODULE_H
-  Affine3(
-      const Eigen::Transform<T, 3, Eigen::Affine, (Eigen::RowMajor)> &affine);
-  Affine3(const Eigen::Transform<T, 3, Eigen::Affine> &affine);
-  operator Eigen::Transform<T, 3, Eigen::Affine, (Eigen::RowMajor)>() const;
-  operator Eigen::Transform<T, 3, Eigen::Affine>() const;
-#endif
-};
-
-template <typename T>
-static Affine3<T> operator*(const Affine3<T> &affine1,
-                            const Affine3<T> &affine2);
-
-//! V is a 3-element vector with member fields x, y and z
-template <typename T, typename V>
-static V operator*(const Affine3<T> &affine, const V &vector);
-
-typedef Affine3<float> Affine3f;
-typedef Affine3<double> Affine3d;
-
-static Vec3f operator*(const Affine3f &affine, const Vec3f &vector);
-static Vec3d operator*(const Affine3d &affine, const Vec3d &vector);
-
-template <typename _Tp> class DataType<Affine3<_Tp>> {
-public:
-  typedef Affine3<_Tp> value_type;
-  typedef Affine3<typename DataType<_Tp>::work_type> work_type;
-  typedef _Tp channel_type;
-
-  enum {
-    generic_type = 0,
-    channels = 16,
-    fmt = traits::SafeFmt<channel_type>::fmt + ((channels - 1) << 8)
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-        ,
-    depth = DataType<channel_type>::depth,
-    type = CV_MAKETYPE(depth, channels)
-#endif
-  };
-
-  typedef Vec<channel_type, channels> vec_type;
-};
-
-namespace traits {
-template <typename _Tp> struct Depth<Affine3<_Tp>> {
-  enum { value = Depth<_Tp>::value };
-};
-template <typename _Tp> struct Type<Affine3<_Tp>> {
-  enum { value = CV_MAKETYPE(Depth<_Tp>::value, 16) };
-};
-} // namespace traits
-
-//! @} core
-
-} // namespace cv
-
-//! @cond IGNORED
-
-///////////////////////////////////////////////////////////////////////////////////
-// Implementation
-
-template <typename T> inline cv::Affine3<T>::Affine3() : matrix(Mat4::eye()) {}
-
-template <typename T>
-inline cv::Affine3<T>::Affine3(const Mat4 &affine) : matrix(affine) {}
-
-template <typename T>
-inline cv::Affine3<T>::Affine3(const Mat3 &R, const Vec3 &t) {
-  rotation(R);
-  translation(t);
-  matrix.val[12] = matrix.val[13] = matrix.val[14] = 0;
-  matrix.val[15] = 1;
-}
-
-template <typename T>
-inline cv::Affine3<T>::Affine3(const Vec3 &_rvec, const Vec3 &t) {
-  rotation(_rvec);
-  translation(t);
-  matrix.val[12] = matrix.val[13] = matrix.val[14] = 0;
-  matrix.val[15] = 1;
-}
-
-template <typename T>
-inline cv::Affine3<T>::Affine3(const cv::Mat &data, const Vec3 &t) {
-  CV_Assert(data.type() == cv::traits::Type<T>::value);
-  CV_Assert(data.channels() == 1);
-
-  if (data.cols == 4 && data.rows == 4) {
-    data.copyTo(matrix);
-    return;
-  } else if (data.cols == 4 && data.rows == 3) {
-    rotation(data(Rect(0, 0, 3, 3)));
-    translation(data(Rect(3, 0, 1, 3)));
-  } else {
-    rotation(data);
-    translation(t);
-  }
-
-  matrix.val[12] = matrix.val[13] = matrix.val[14] = 0;
-  matrix.val[15] = 1;
-}
-
-template <typename T>
-inline cv::Affine3<T>::Affine3(const float_type *vals) : matrix(vals) {}
-
-template <typename T> inline cv::Affine3<T> cv::Affine3<T>::Identity() {
-  return Affine3<T>(cv::Affine3<T>::Mat4::eye());
-}
-
-template <typename T> inline void cv::Affine3<T>::rotation(const Mat3 &R) {
-  linear(R);
-}
-
-template <typename T> inline void cv::Affine3<T>::rotation(const Vec3 &_rvec) {
-  double theta = norm(_rvec);
-
-  if (theta < DBL_EPSILON)
-    rotation(Mat3::eye());
-  else {
-    double c = std::cos(theta);
-    double s = std::sin(theta);
-    double c1 = 1. - c;
-    double itheta = (theta != 0) ? 1. / theta : 0.;
-
-    Point3_<T> r = _rvec * itheta;
-
-    Mat3 rrt(r.x * r.x, r.x * r.y, r.x * r.z, r.x * r.y, r.y * r.y, r.y * r.z,
-             r.x * r.z, r.y * r.z, r.z * r.z);
-    Mat3 r_x(0, -r.z, r.y, r.z, 0, -r.x, -r.y, r.x, 0);
-
-    // R = cos(theta)*I + (1 - cos(theta))*r*rT + sin(theta)*[r_x]
-    // where [r_x] is [0 -rz ry; rz 0 -rx; -ry rx 0]
-    Mat3 R = c * Mat3::eye() + c1 * rrt + s * r_x;
-
-    rotation(R);
-  }
-}
-
-// Combines rotation methods above. Supports 3x3, 1x3, 3x1 sizes of data matrix;
-template <typename T>
-inline void cv::Affine3<T>::rotation(const cv::Mat &data) {
-  CV_Assert(data.type() == cv::traits::Type<T>::value);
-  CV_Assert(data.channels() == 1);
-
-  if (data.cols == 3 && data.rows == 3) {
-    Mat3 R;
-    data.copyTo(R);
-    rotation(R);
-  } else if ((data.cols == 3 && data.rows == 1) ||
-             (data.cols == 1 && data.rows == 3)) {
-    Vec3 _rvec;
-    data.reshape(1, 3).copyTo(_rvec);
-    rotation(_rvec);
-  } else
-    CV_Error(Error::StsError, "Input matrix can only be 3x3, 1x3 or 3x1");
-}
-
-template <typename T> inline void cv::Affine3<T>::linear(const Mat3 &L) {
-  matrix.val[0] = L.val[0];
-  matrix.val[1] = L.val[1];
-  matrix.val[2] = L.val[2];
-  matrix.val[4] = L.val[3];
-  matrix.val[5] = L.val[4];
-  matrix.val[6] = L.val[5];
-  matrix.val[8] = L.val[6];
-  matrix.val[9] = L.val[7];
-  matrix.val[10] = L.val[8];
-}
-
-template <typename T> inline void cv::Affine3<T>::translation(const Vec3 &t) {
-  matrix.val[3] = t[0];
-  matrix.val[7] = t[1];
-  matrix.val[11] = t[2];
-}
-
-template <typename T>
-inline typename cv::Affine3<T>::Mat3 cv::Affine3<T>::rotation() const {
-  return linear();
-}
-
-template <typename T>
-inline typename cv::Affine3<T>::Mat3 cv::Affine3<T>::linear() const {
-  typename cv::Affine3<T>::Mat3 R;
-  R.val[0] = matrix.val[0];
-  R.val[1] = matrix.val[1];
-  R.val[2] = matrix.val[2];
-  R.val[3] = matrix.val[4];
-  R.val[4] = matrix.val[5];
-  R.val[5] = matrix.val[6];
-  R.val[6] = matrix.val[8];
-  R.val[7] = matrix.val[9];
-  R.val[8] = matrix.val[10];
-  return R;
-}
-
-template <typename T>
-inline typename cv::Affine3<T>::Vec3 cv::Affine3<T>::translation() const {
-  return Vec3(matrix.val[3], matrix.val[7], matrix.val[11]);
-}
-
-template <typename T>
-inline typename cv::Affine3<T>::Vec3 cv::Affine3<T>::rvec() const {
-  cv::Vec3d w;
-  cv::Matx33d u, vt, R = rotation();
-  cv::SVD::compute(R, w, u, vt, cv::SVD::FULL_UV + cv::SVD::MODIFY_A);
-  R = u * vt;
-
-  double rx = R.val[7] - R.val[5];
-  double ry = R.val[2] - R.val[6];
-  double rz = R.val[3] - R.val[1];
-
-  double s = std::sqrt((rx * rx + ry * ry + rz * rz) * 0.25);
-  double c = (R.val[0] + R.val[4] + R.val[8] - 1) * 0.5;
-  c = c > 1.0 ? 1.0 : c < -1.0 ? -1.0 : c;
-  double theta = std::acos(c);
-
-  if (s < 1e-5) {
-    if (c > 0)
-      rx = ry = rz = 0;
-    else {
-      double t;
-      t = (R.val[0] + 1) * 0.5;
-      rx = std::sqrt(std::max(t, 0.0));
-      t = (R.val[4] + 1) * 0.5;
-      ry = std::sqrt(std::max(t, 0.0)) * (R.val[1] < 0 ? -1.0 : 1.0);
-      t = (R.val[8] + 1) * 0.5;
-      rz = std::sqrt(std::max(t, 0.0)) * (R.val[2] < 0 ? -1.0 : 1.0);
-
-      if (fabs(rx) < fabs(ry) && fabs(rx) < fabs(rz) &&
-          (R.val[5] > 0) != (ry * rz > 0))
-        rz = -rz;
-      theta /= std::sqrt(rx * rx + ry * ry + rz * rz);
-      rx *= theta;
-      ry *= theta;
-      rz *= theta;
-    }
-  } else {
-    double vth = 1 / (2 * s);
-    vth *= theta;
-    rx *= vth;
-    ry *= vth;
-    rz *= vth;
-  }
-
-  return cv::Vec3d(rx, ry, rz);
-}
-
-template <typename T>
-inline cv::Affine3<T> cv::Affine3<T>::inv(int method) const {
-  return matrix.inv(method);
-}
-
-template <typename T>
-inline cv::Affine3<T> cv::Affine3<T>::rotate(const Mat3 &R) const {
-  Mat3 Lc = linear();
-  Vec3 tc = translation();
-  Mat4 result;
-  result.val[12] = result.val[13] = result.val[14] = 0;
-  result.val[15] = 1;
-
-  for (int j = 0; j < 3; ++j) {
-    for (int i = 0; i < 3; ++i) {
-      float_type value = 0;
-      for (int k = 0; k < 3; ++k)
-        value += R(j, k) * Lc(k, i);
-      result(j, i) = value;
-    }
-
-    result(j, 3) = R.row(j).dot(tc.t());
-  }
-  return result;
-}
-
-template <typename T>
-inline cv::Affine3<T> cv::Affine3<T>::rotate(const Vec3 &_rvec) const {
-  return rotate(Affine3f(_rvec).rotation());
-}
-
-template <typename T>
-inline cv::Affine3<T> cv::Affine3<T>::translate(const Vec3 &t) const {
-  Mat4 m = matrix;
-  m.val[3] += t[0];
-  m.val[7] += t[1];
-  m.val[11] += t[2];
-  return m;
-}
-
-template <typename T>
-inline cv::Affine3<T>
-cv::Affine3<T>::concatenate(const Affine3<T> &affine) const {
-  return (*this).rotate(affine.rotation()).translate(affine.translation());
-}
-
-template <typename T>
-template <typename Y>
-inline cv::Affine3<T>::operator Affine3<Y>() const {
-  return Affine3<Y>(matrix);
-}
-
-template <typename T>
-template <typename Y>
-inline cv::Affine3<Y> cv::Affine3<T>::cast() const {
-  return Affine3<Y>(matrix);
-}
-
-template <typename T>
-inline cv::Affine3<T> cv::operator*(const cv::Affine3<T> &affine1,
-                                    const cv::Affine3<T> &affine2) {
-  return affine2.concatenate(affine1);
-}
-
-template <typename T, typename V>
-inline V cv::operator*(const cv::Affine3<T> &affine, const V &v) {
-  const typename Affine3<T>::Mat4 &m = affine.matrix;
-
-  V r;
-  r.x = m.val[0] * v.x + m.val[1] * v.y + m.val[2] * v.z + m.val[3];
-  r.y = m.val[4] * v.x + m.val[5] * v.y + m.val[6] * v.z + m.val[7];
-  r.z = m.val[8] * v.x + m.val[9] * v.y + m.val[10] * v.z + m.val[11];
-  return r;
-}
-
-static inline cv::Vec3f cv::operator*(const cv::Affine3f &affine,
-                                      const cv::Vec3f &v) {
-  const cv::Matx44f &m = affine.matrix;
-  cv::Vec3f r;
-  r.val[0] = m.val[0] * v[0] + m.val[1] * v[1] + m.val[2] * v[2] + m.val[3];
-  r.val[1] = m.val[4] * v[0] + m.val[5] * v[1] + m.val[6] * v[2] + m.val[7];
-  r.val[2] = m.val[8] * v[0] + m.val[9] * v[1] + m.val[10] * v[2] + m.val[11];
-  return r;
-}
-
-static inline cv::Vec3d cv::operator*(const cv::Affine3d &affine,
-                                      const cv::Vec3d &v) {
-  const cv::Matx44d &m = affine.matrix;
-  cv::Vec3d r;
-  r.val[0] = m.val[0] * v[0] + m.val[1] * v[1] + m.val[2] * v[2] + m.val[3];
-  r.val[1] = m.val[4] * v[0] + m.val[5] * v[1] + m.val[6] * v[2] + m.val[7];
-  r.val[2] = m.val[8] * v[0] + m.val[9] * v[1] + m.val[10] * v[2] + m.val[11];
-  return r;
-}
-
-#if defined EIGEN_WORLD_VERSION && defined EIGEN_GEOMETRY_MODULE_H
-
-template <typename T>
-inline cv::Affine3<T>::Affine3(
-    const Eigen::Transform<T, 3, Eigen::Affine, (Eigen::RowMajor)> &affine) {
-  cv::Mat(4, 4, cv::traits::Type<T>::value, affine.matrix().data())
-      .copyTo(matrix);
-}
-
-template <typename T>
-inline cv::Affine3<T>::Affine3(
-    const Eigen::Transform<T, 3, Eigen::Affine> &affine) {
-  Eigen::Transform<T, 3, Eigen::Affine, (Eigen::RowMajor)> a = affine;
-  cv::Mat(4, 4, cv::traits::Type<T>::value, a.matrix().data()).copyTo(matrix);
-}
-
-template <typename T>
-inline cv::Affine3<T>::operator Eigen::Transform<T, 3, Eigen::Affine,
-                                                 (Eigen::RowMajor)>() const {
-  Eigen::Transform<T, 3, Eigen::Affine, (Eigen::RowMajor)> r;
-  cv::Mat hdr(4, 4, cv::traits::Type<T>::value, r.matrix().data());
-  cv::Mat(matrix, false).copyTo(hdr);
-  return r;
-}
-
-template <typename T>
-inline cv::Affine3<T>::operator Eigen::Transform<T, 3, Eigen::Affine>() const {
-  return this
-      ->operator Eigen::Transform<T, 3, Eigen::Affine, (Eigen::RowMajor)>();
-}
-
-#endif /* defined EIGEN_WORLD_VERSION && defined EIGEN_GEOMETRY_MODULE_H */
-
-//! @endcond
-
-#endif /* __cplusplus */
-
-#endif /* OPENCV_CORE_AFFINE3_HPP */
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/async.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/async.hpp
deleted file mode 100644
index 9c48f1625a..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/async.hpp
+++ /dev/null
@@ -1,107 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_CORE_ASYNC_HPP
-#define OPENCV_CORE_ASYNC_HPP
-
-#include <opencv2/core/mat.hpp>
-
-// #include <future>
-#include <chrono>
-
-namespace cv {
-
-/** @addtogroup core_async
-
-@{
-*/
-
-/** @brief Returns result of asynchronous operations
-
-Object has attached asynchronous state.
-Assignment operator doesn't clone asynchronous state (it is shared between all
-instances).
-
-Result can be fetched via get() method only once.
-
-*/
-class CV_EXPORTS_W AsyncArray {
-public:
-  ~AsyncArray() CV_NOEXCEPT;
-  CV_WRAP AsyncArray() CV_NOEXCEPT;
-  AsyncArray(const AsyncArray &o) CV_NOEXCEPT;
-  AsyncArray &operator=(const AsyncArray &o) CV_NOEXCEPT;
-  CV_WRAP void release() CV_NOEXCEPT;
-
-  /** Fetch the result.
-  @param[out] dst destination array
-
-  Waits for result until container has valid result.
-  Throws exception if exception was stored as a result.
-
-  Throws exception on invalid container state.
-
-  @note Result or stored exception can be fetched only once.
-  */
-  CV_WRAP void get(OutputArray dst) const;
-
-  /** Retrieving the result with timeout
-  @param[out] dst destination array
-  @param[in] timeoutNs timeout in nanoseconds, -1 for infinite wait
-
-  @returns true if result is ready, false if the timeout has expired
-
-  @note Result or stored exception can be fetched only once.
-  */
-  bool get(OutputArray dst, int64 timeoutNs) const;
-
-  CV_WRAP inline bool get(OutputArray dst, double timeoutNs) const {
-    return get(dst, (int64)timeoutNs);
-  }
-
-  bool wait_for(int64 timeoutNs) const;
-
-  CV_WRAP inline bool wait_for(double timeoutNs) const {
-    return wait_for((int64)timeoutNs);
-  }
-
-  CV_WRAP bool valid() const CV_NOEXCEPT;
-
-  inline AsyncArray(AsyncArray &&o) {
-    p = o.p;
-    o.p = NULL;
-  }
-  inline AsyncArray &operator=(AsyncArray &&o) CV_NOEXCEPT {
-    std::swap(p, o.p);
-    return *this;
-  }
-
-  template <typename _Rep, typename _Period>
-  inline bool get(OutputArray dst,
-                  const std::chrono::duration<_Rep, _Period> &timeout) {
-    return get(dst, (int64)(std::chrono::nanoseconds(timeout).count()));
-  }
-
-  template <typename _Rep, typename _Period>
-  inline bool wait_for(const std::chrono::duration<_Rep, _Period> &timeout) {
-    return wait_for((int64)(std::chrono::nanoseconds(timeout).count()));
-  }
-
-#if 0
-    std::future<Mat> getFutureMat() const;
-    std::future<UMat> getFutureUMat() const;
-#endif
-
-  // PImpl
-  struct Impl;
-  friend struct Impl;
-  inline void *_getImpl() const CV_NOEXCEPT { return p; }
-
-protected:
-  Impl *p;
-};
-
-//! @}
-} // namespace cv
-#endif // OPENCV_CORE_ASYNC_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/base.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/base.hpp
deleted file mode 100644
index 3dfa243df6..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/base.hpp
+++ /dev/null
@@ -1,735 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Copyright (C) 2014, Itseez Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_CORE_BASE_HPP
-#define OPENCV_CORE_BASE_HPP
-
-#ifndef __cplusplus
-#error base.hpp header must be compiled as C++
-#endif
-
-#include "opencv2/opencv_modules.hpp"
-
-#include <algorithm>
-#include <climits>
-
-#include "opencv2/core/cvdef.h"
-#include "opencv2/core/cvstd.hpp"
-
-namespace cv {
-
-//! @addtogroup core_utils
-//! @{
-
-namespace Error {
-//! error codes
-enum Code {
-  StsOk = 0,          //!< everything is ok
-  StsBackTrace = -1,  //!< pseudo error for back trace
-  StsError = -2,      //!< unknown /unspecified error
-  StsInternal = -3,   //!< internal error (bad state)
-  StsNoMem = -4,      //!< insufficient memory
-  StsBadArg = -5,     //!< function arg/param is bad
-  StsBadFunc = -6,    //!< unsupported function
-  StsNoConv = -7,     //!< iteration didn't converge
-  StsAutoTrace = -8,  //!< tracing
-  HeaderIsNull = -9,  //!< image header is NULL
-  BadImageSize = -10, //!< image size is invalid
-  BadOffset = -11,    //!< offset is invalid
-  BadDataPtr = -12,   //!<
-  BadStep = -13, //!< image step is wrong, this may happen for a non-continuous
-                 //!< matrix.
-  BadModelOrChSeq = -14, //!<
-  BadNumChannels = -15, //!< bad number of channels, for example, some functions
-                        //!< accept only single channel matrices.
-  BadNumChannel1U = -16, //!<
-  BadDepth = -17,        //!< input image depth is not supported by the function
-  BadAlphaChannel = -18, //!<
-  BadOrder = -19,        //!< number of dimensions is out of range
-  BadOrigin = -20,       //!< incorrect input origin
-  BadAlign = -21,        //!< incorrect input align
-  BadCallBack = -22,     //!<
-  BadTileSize = -23,     //!<
-  BadCOI = -24,          //!< input COI is not supported
-  BadROISize = -25,      //!< incorrect input roi
-  MaskIsTiled = -26,     //!<
-  StsNullPtr = -27,      //!< null pointer
-  StsVecLengthErr = -28, //!< incorrect vector length
-  StsFilterStructContentErr = -29, //!< incorrect filter structure content
-  StsKernelStructContentErr = -30, //!< incorrect transform kernel content
-  StsFilterOffsetErr = -31,        //!< incorrect filter offset value
-  StsBadSize = -201,   //!< the input/output structure size is incorrect
-  StsDivByZero = -202, //!< division by zero
-  StsInplaceNotSupported = -203, //!< in-place operation is not supported
-  StsObjectNotFound = -204,      //!< request can't be completed
-  StsUnmatchedFormats = -205,    //!< formats of input/output arrays differ
-  StsBadFlag = -206,             //!< flag is wrong or not supported
-  StsBadPoint = -207,            //!< bad CvPoint
-  StsBadMask = -208,             //!< bad format of mask (neither 8uC1 nor 8sC1)
-  StsUnmatchedSizes = -209, //!< sizes of input/output structures do not match
-  StsUnsupportedFormat =
-      -210, //!< the data format/type is not supported by the function
-  StsOutOfRange = -211, //!< some of parameters are out of range
-  StsParseError = -212, //!< invalid syntax/structure of the parsed file
-  StsNotImplemented =
-      -213,               //!< the requested function/feature is not implemented
-  StsBadMemBlock = -214,  //!< an allocated block has been corrupted
-  StsAssert = -215,       //!< assertion failed
-  GpuNotSupported = -216, //!< no CUDA support
-  GpuApiCallError = -217, //!< GPU API call error
-  OpenGlNotSupported = -218, //!< no OpenGL support
-  OpenGlApiCallError = -219, //!< OpenGL API call error
-  OpenCLApiCallError = -220, //!< OpenCL API call error
-  OpenCLDoubleNotSupported = -221,
-  OpenCLInitError = -222, //!< OpenCL initialization error
-  OpenCLNoAMDBlasFft = -223
-};
-} // namespace Error
-
-//! @} core_utils
-
-//! @addtogroup core_array
-//! @{
-
-//! matrix decomposition types
-enum DecompTypes {
-  /** Gaussian elimination with the optimal pivot element chosen. */
-  DECOMP_LU = 0,
-  /** singular value decomposition (SVD) method; the system can be over-defined
-  and/or the matrix src1 can be singular */
-  DECOMP_SVD = 1,
-  /** eigenvalue decomposition; the matrix src1 must be symmetrical */
-  DECOMP_EIG = 2,
-  /** Cholesky \f$LL^T\f$ factorization; the matrix src1 must be symmetrical and
-  positively defined */
-  DECOMP_CHOLESKY = 3,
-  /** QR factorization; the system can be over-defined and/or the matrix src1
-     can be singular */
-  DECOMP_QR = 4,
-  /** while all the previous flags are mutually exclusive, this flag can be used
-  together with any of the previous; it means that the normal equations
-  \f$\texttt{src1}^T\cdot\texttt{src1}\cdot\texttt{dst}=\texttt{src1}^T\texttt{src2}\f$
-  are solved instead of the original system
-  \f$\texttt{src1}\cdot\texttt{dst}=\texttt{src2}\f$ */
-  DECOMP_NORMAL = 16
-};
-
-/** norm types
-
-src1 and src2 denote input arrays.
-*/
-
-enum NormTypes {
-  /**
-  \f[
-  norm =  \forkthree
-  {\|\texttt{src1}\|_{L_{\infty}} =  \max _I | \texttt{src1} (I)|}{if
-  \(\texttt{normType} = \texttt{NORM_INF}\) }
-  {\|\texttt{src1}-\texttt{src2}\|_{L_{\infty}} =  \max _I | \texttt{src1} (I) -
-  \texttt{src2} (I)|}{if  \(\texttt{normType} = \texttt{NORM_INF}\) }
-  {\frac{\|\texttt{src1}-\texttt{src2}\|_{L_{\infty}}
-  }{\|\texttt{src2}\|_{L_{\infty}} }}{if  \(\texttt{normType} =
-  \texttt{NORM_RELATIVE | NORM_INF}\) }
-  \f]
-  */
-  NORM_INF = 1,
-  /**
-  \f[
-  norm =  \forkthree
-  {\| \texttt{src1} \| _{L_1} =  \sum _I | \texttt{src1} (I)|}{if
-  \(\texttt{normType} = \texttt{NORM_L1}\)} { \| \texttt{src1} - \texttt{src2}
-  \| _{L_1} =  \sum _I | \texttt{src1} (I) -  \texttt{src2} (I)|}{if
-  \(\texttt{normType} = \texttt{NORM_L1}\) } {
-  \frac{\|\texttt{src1}-\texttt{src2}\|_{L_1} }{\|\texttt{src2}\|_{L_1}} }{if
-  \(\texttt{normType} = \texttt{NORM_RELATIVE | NORM_L1}\) }
-  \f]*/
-  NORM_L1 = 2,
-  /**
-  \f[
-  norm =  \forkthree
-  { \| \texttt{src1} \| _{L_2} =  \sqrt{\sum_I \texttt{src1}(I)^2} }{if
-  \(\texttt{normType} = \texttt{NORM_L2}\) } { \| \texttt{src1} - \texttt{src2}
-  \| _{L_2} =  \sqrt{\sum_I (\texttt{src1}(I) - \texttt{src2}(I))^2} }{if
-  \(\texttt{normType} = \texttt{NORM_L2}\) } {
-  \frac{\|\texttt{src1}-\texttt{src2}\|_{L_2} }{\|\texttt{src2}\|_{L_2}} }{if
-  \(\texttt{normType} = \texttt{NORM_RELATIVE | NORM_L2}\) }
-  \f]
-  */
-  NORM_L2 = 4,
-  /**
-  \f[
-  norm =  \forkthree
-  { \| \texttt{src1} \| _{L_2} ^{2} = \sum_I \texttt{src1}(I)^2} {if
-  \(\texttt{normType} = \texttt{NORM_L2SQR}\)} { \| \texttt{src1} -
-  \texttt{src2} \| _{L_2} ^{2} =  \sum_I (\texttt{src1}(I) - \texttt{src2}(I))^2
-  }{if  \(\texttt{normType} = \texttt{NORM_L2SQR}\) } {
-  \left(\frac{\|\texttt{src1}-\texttt{src2}\|_{L_2}
-  }{\|\texttt{src2}\|_{L_2}}\right)^2 }{if  \(\texttt{normType} =
-  \texttt{NORM_RELATIVE | NORM_L2SQR}\) }
-  \f]
-  */
-  NORM_L2SQR = 5,
-  /**
-  In the case of one input array, calculates the Hamming distance of the array
-  from zero, In the case of two input arrays, calculates the Hamming distance
-  between the arrays.
-  */
-  NORM_HAMMING = 6,
-  /**
-  Similar to NORM_HAMMING, but in the calculation, each two bits of the input
-  sequence will be added and treated as a single bit to be used in the same
-  calculation as NORM_HAMMING.
-  */
-  NORM_HAMMING2 = 7,
-  NORM_TYPE_MASK =
-      7, //!< bit-mask which can be used to separate norm type from norm flags
-  NORM_RELATIVE = 8, //!< flag
-  NORM_MINMAX = 32   //!< flag
-};
-
-//! comparison types
-enum CmpTypes {
-  CMP_EQ = 0, //!< src1 is equal to src2.
-  CMP_GT = 1, //!< src1 is greater than src2.
-  CMP_GE = 2, //!< src1 is greater than or equal to src2.
-  CMP_LT = 3, //!< src1 is less than src2.
-  CMP_LE = 4, //!< src1 is less than or equal to src2.
-  CMP_NE = 5  //!< src1 is unequal to src2.
-};
-
-//! generalized matrix multiplication flags
-enum GemmFlags {
-  GEMM_1_T = 1, //!< transposes src1
-  GEMM_2_T = 2, //!< transposes src2
-  GEMM_3_T = 4  //!< transposes src3
-};
-
-enum DftFlags {
-  /** performs an inverse 1D or 2D transform instead of the default forward
-      transform. */
-  DFT_INVERSE = 1,
-  /** scales the result: divide it by the number of array elements. Normally, it
-     is combined with DFT_INVERSE. */
-  DFT_SCALE = 2,
-  /** performs a forward or inverse transform of every individual row of the
-     input matrix; this flag enables you to transform multiple vectors
-     simultaneously and can be used to decrease the overhead (which is sometimes
-     several times larger than the processing itself) to perform 3D and
-     higher-dimensional transformations and so forth.*/
-  DFT_ROWS = 4,
-  /** performs a forward transformation of 1D or 2D real array; the result,
-      though being a complex array, has complex-conjugate symmetry (*CCS*, see
-     the function description below for details), and such an array can be
-     packed into a real array of the same size as input, which is the fastest
-     option and which is what the function does by default; however, you may
-     wish to get a full complex array (for simpler spectrum analysis, and so on)
-     - pass the flag to enable the function to produce a full-size complex
-     output array. */
-  DFT_COMPLEX_OUTPUT = 16,
-  /** performs an inverse transformation of a 1D or 2D complex array; the
-      result is normally a complex array of the same size, however, if the input
-     array has conjugate-complex symmetry (for example, it is a result of
-     forward transformation with DFT_COMPLEX_OUTPUT flag), the output is a real
-     array; while the function itself does not check whether the input is
-     symmetrical or not, you can pass the flag and then the function will assume
-     the symmetry and produce the real output array (note that when the input is
-     packed into a real array and inverse transformation is executed, the
-     function treats the input as a packed complex-conjugate symmetrical array,
-     and the output will also be a real array). */
-  DFT_REAL_OUTPUT = 32,
-  /** specifies that input is complex input. If this flag is set, the input must
-     have 2 channels. On the other hand, for backwards compatibility reason, if
-     input has 2 channels, input is already considered complex. */
-  DFT_COMPLEX_INPUT = 64,
-  /** performs an inverse 1D or 2D transform instead of the default forward
-     transform. */
-  DCT_INVERSE = DFT_INVERSE,
-  /** performs a forward or inverse transform of every individual row of the
-     input matrix. This flag enables you to transform multiple vectors
-     simultaneously and can be used to decrease the overhead (which is sometimes
-     several times larger than the processing itself) to perform 3D and
-     higher-dimensional transforms and so forth.*/
-  DCT_ROWS = DFT_ROWS
-};
-
-//! Various border types, image boundaries are denoted with `|`
-//! @see borderInterpolate, copyMakeBorder
-enum BorderTypes {
-  BORDER_CONSTANT = 0,  //!< `iiiiii|abcdefgh|iiiiiii`  with some specified `i`
-  BORDER_REPLICATE = 1, //!< `aaaaaa|abcdefgh|hhhhhhh`
-  BORDER_REFLECT = 2,   //!< `fedcba|abcdefgh|hgfedcb`
-  BORDER_WRAP = 3,      //!< `cdefgh|abcdefgh|abcdefg`
-  BORDER_REFLECT_101 = 4, //!< `gfedcb|abcdefgh|gfedcba`
-  BORDER_TRANSPARENT =
-      5, //!< `uvwxyz|abcdefgh|ijklmno` - Treats outliers as transparent.
-
-  BORDER_REFLECT101 = BORDER_REFLECT_101, //!< same as BORDER_REFLECT_101
-  BORDER_DEFAULT = BORDER_REFLECT_101,    //!< same as BORDER_REFLECT_101
-  BORDER_ISOLATED = 16 //!< Interpolation restricted within the ROI boundaries.
-};
-
-//! @} core_array
-
-//! @addtogroup core_utils
-//! @{
-
-/*! @brief Signals an error and raises the exception.
-
-By default the function prints information about the error to stderr,
-then it either stops if setBreakOnError() had been called before or raises the
-exception. It is possible to alternate error processing by using
-redirectError().
-@param code - error code (Error::Code)
-@param err - error description
-@param func - function name. Available only when the compiler supports getting
-it
-@param file - source file name where the error has occurred
-@param line - line number in the source file where the error has occurred
-@see CV_Error, CV_Error_, CV_Assert, CV_DbgAssert
- */
-CV_EXPORTS CV_NORETURN void error(int code, const String &err, const char *func,
-                                  const char *file, int line);
-
-/*! @brief Signals an error and terminate application.
-
-By default the function prints information about the error to stderr, then it
-terminates application with std::terminate. The function is designed for
-invariants check in functions and methods with noexcept attribute.
-@param code - error code (Error::Code)
-@param err - error description
-@param func - function name. Available only when the compiler supports getting
-it
-@param file - source file name where the error has occurred
-@param line - line number in the source file where the error has occurred
-@see CV_AssertTerminate
- */
-CV_EXPORTS CV_NORETURN void terminate(int code, const String &err,
-                                      const char *func, const char *file,
-                                      int line) CV_NOEXCEPT;
-
-#ifdef CV_STATIC_ANALYSIS
-
-// In practice, some macro are not processed correctly (noreturn is not
-// detected). We need to use simplified definition for them.
-#define CV_Error(code, msg)                                                    \
-  do {                                                                         \
-    (void)(code);                                                              \
-    (void)(msg);                                                               \
-    abort();                                                                   \
-  } while (0)
-#define CV_Error_(code, args)                                                  \
-  do {                                                                         \
-    (void)(code);                                                              \
-    (void)(cv::format args);                                                   \
-    abort();                                                                   \
-  } while (0)
-#define CV_Assert(expr)                                                        \
-  do {                                                                         \
-    if (!(expr))                                                               \
-      abort();                                                                 \
-  } while (0)
-
-#else // CV_STATIC_ANALYSIS
-
-/** @brief Call the error handler.
-
-Currently, the error handler prints the error code and the error message to the
-standard error stream `stderr`. In the Debug configuration, it then provokes
-memory access violation, so that the execution stack and all the parameters can
-be analyzed by the debugger. In the Release configuration, the exception is
-thrown.
-
-@param code one of Error::Code
-@param msg error message
-*/
-#define CV_Error(code, msg) cv::error(code, msg, CV_Func, __FILE__, __LINE__)
-
-/**  @brief Call the error handler.
-
-This macro can be used to construct an error message on-fly to include some
-dynamic information, for example:
-@code
-    // note the extra parentheses around the formatted text message
-    CV_Error_(Error::StsOutOfRange,
-    ("the value at (%d, %d)=%g is out of range", badPt.x, badPt.y, badValue));
-@endcode
-@param code one of Error::Code
-@param args printf-like formatted error message in parentheses
-*/
-#define CV_Error_(code, args)                                                  \
-  cv::error(code, cv::format args, CV_Func, __FILE__, __LINE__)
-
-/** @brief Checks a condition at runtime and throws exception if it fails
-
-The macros CV_Assert (and CV_DbgAssert(expr)) evaluate the specified expression.
-If it is 0, the macros raise an error (see cv::error). The macro CV_Assert
-checks the condition in both Debug and Release configurations while CV_DbgAssert
-is only retained in the Debug configuration. CV_AssertTerminate is analog of
-CV_Assert for invariants check in functions with noexcept attribute. It does not
-throw exception, but terminates the application.
-*/
-#define CV_Assert(expr)                                                        \
-  do {                                                                         \
-    if (!!(expr))                                                              \
-      ;                                                                        \
-    else                                                                       \
-      cv::error(cv::Error::StsAssert, #expr, CV_Func, __FILE__, __LINE__);     \
-  } while (0)
-#define CV_AssertTerminate(expr)                                               \
-  do {                                                                         \
-    if (!!(expr))                                                              \
-      ;                                                                        \
-    else                                                                       \
-      cv::terminate(#expr, CV_Func, __FILE__, __LINE__);                       \
-  } while (0)
-
-#endif // CV_STATIC_ANALYSIS
-
-//! @cond IGNORED
-#if !defined(__OPENCV_BUILD) // TODO: backward compatibility only
-#ifndef CV_ErrorNoReturn
-#define CV_ErrorNoReturn CV_Error
-#endif
-#ifndef CV_ErrorNoReturn_
-#define CV_ErrorNoReturn_ CV_Error_
-#endif
-#endif
-
-#define CV_Assert_1 CV_Assert
-#define CV_Assert_2(expr, ...)                                                 \
-  CV_Assert_1(expr);                                                           \
-  __CV_EXPAND(CV_Assert_1(__VA_ARGS__))
-#define CV_Assert_3(expr, ...)                                                 \
-  CV_Assert_1(expr);                                                           \
-  __CV_EXPAND(CV_Assert_2(__VA_ARGS__))
-#define CV_Assert_4(expr, ...)                                                 \
-  CV_Assert_1(expr);                                                           \
-  __CV_EXPAND(CV_Assert_3(__VA_ARGS__))
-#define CV_Assert_5(expr, ...)                                                 \
-  CV_Assert_1(expr);                                                           \
-  __CV_EXPAND(CV_Assert_4(__VA_ARGS__))
-#define CV_Assert_6(expr, ...)                                                 \
-  CV_Assert_1(expr);                                                           \
-  __CV_EXPAND(CV_Assert_5(__VA_ARGS__))
-#define CV_Assert_7(expr, ...)                                                 \
-  CV_Assert_1(expr);                                                           \
-  __CV_EXPAND(CV_Assert_6(__VA_ARGS__))
-#define CV_Assert_8(expr, ...)                                                 \
-  CV_Assert_1(expr);                                                           \
-  __CV_EXPAND(CV_Assert_7(__VA_ARGS__))
-#define CV_Assert_9(expr, ...)                                                 \
-  CV_Assert_1(expr);                                                           \
-  __CV_EXPAND(CV_Assert_8(__VA_ARGS__))
-#define CV_Assert_10(expr, ...)                                                \
-  CV_Assert_1(expr);                                                           \
-  __CV_EXPAND(CV_Assert_9(__VA_ARGS__))
-
-#define CV_Assert_N(...)                                                       \
-  do {                                                                         \
-    __CV_EXPAND(                                                               \
-        __CV_CAT(CV_Assert_, __CV_VA_NUM_ARGS(__VA_ARGS__))(__VA_ARGS__));     \
-  } while (0)
-
-//! @endcond
-
-#if defined _DEBUG || defined CV_STATIC_ANALYSIS
-#define CV_DbgAssert(expr) CV_Assert(expr)
-#else
-/** replaced with CV_Assert(expr) in Debug configuration */
-#define CV_DbgAssert(expr)
-#endif
-
-/*
- * Hamming distance functor - counts the bit differences between two strings -
- * useful for the Brief descriptor bit count of A exclusive XOR'ed with B
- */
-struct CV_EXPORTS Hamming {
-  static const NormTypes normType = NORM_HAMMING;
-  typedef unsigned char ValueType;
-  typedef int ResultType;
-
-  /** this will count the bits in a ^ b
-   */
-  ResultType operator()(const unsigned char *a, const unsigned char *b,
-                        int size) const;
-};
-
-typedef Hamming HammingLUT;
-
-/////////////////////////////////// inline norms
-///////////////////////////////////////
-
-template <typename _Tp> inline _Tp cv_abs(_Tp x) { return std::abs(x); }
-inline int cv_abs(uchar x) { return x; }
-inline int cv_abs(schar x) { return std::abs(x); }
-inline int cv_abs(ushort x) { return x; }
-inline int cv_abs(short x) { return std::abs(x); }
-
-template <typename _Tp, typename _AccTp>
-static inline _AccTp normL2Sqr(const _Tp *a, int n) {
-  _AccTp s = 0;
-  int i = 0;
-#if CV_ENABLE_UNROLLED
-  for (; i <= n - 4; i += 4) {
-    _AccTp v0 = a[i], v1 = a[i + 1], v2 = a[i + 2], v3 = a[i + 3];
-    s += v0 * v0 + v1 * v1 + v2 * v2 + v3 * v3;
-  }
-#endif
-  for (; i < n; i++) {
-    _AccTp v = a[i];
-    s += v * v;
-  }
-  return s;
-}
-
-template <typename _Tp, typename _AccTp>
-static inline _AccTp normL1(const _Tp *a, int n) {
-  _AccTp s = 0;
-  int i = 0;
-#if CV_ENABLE_UNROLLED
-  for (; i <= n - 4; i += 4) {
-    s += (_AccTp)cv_abs(a[i]) + (_AccTp)cv_abs(a[i + 1]) +
-         (_AccTp)cv_abs(a[i + 2]) + (_AccTp)cv_abs(a[i + 3]);
-  }
-#endif
-  for (; i < n; i++)
-    s += cv_abs(a[i]);
-  return s;
-}
-
-template <typename _Tp, typename _AccTp>
-static inline _AccTp normInf(const _Tp *a, int n) {
-  _AccTp s = 0;
-  for (int i = 0; i < n; i++)
-    s = std::max(s, (_AccTp)cv_abs(a[i]));
-  return s;
-}
-
-template <typename _Tp, typename _AccTp>
-static inline _AccTp normL2Sqr(const _Tp *a, const _Tp *b, int n) {
-  _AccTp s = 0;
-  int i = 0;
-#if CV_ENABLE_UNROLLED
-  for (; i <= n - 4; i += 4) {
-    _AccTp v0 = _AccTp(a[i] - b[i]), v1 = _AccTp(a[i + 1] - b[i + 1]),
-           v2 = _AccTp(a[i + 2] - b[i + 2]), v3 = _AccTp(a[i + 3] - b[i + 3]);
-    s += v0 * v0 + v1 * v1 + v2 * v2 + v3 * v3;
-  }
-#endif
-  for (; i < n; i++) {
-    _AccTp v = _AccTp(a[i] - b[i]);
-    s += v * v;
-  }
-  return s;
-}
-
-static inline float normL2Sqr(const float *a, const float *b, int n) {
-  float s = 0.f;
-  for (int i = 0; i < n; i++) {
-    float v = a[i] - b[i];
-    s += v * v;
-  }
-  return s;
-}
-
-template <typename _Tp, typename _AccTp>
-static inline _AccTp normL1(const _Tp *a, const _Tp *b, int n) {
-  _AccTp s = 0;
-  int i = 0;
-#if CV_ENABLE_UNROLLED
-  for (; i <= n - 4; i += 4) {
-    _AccTp v0 = _AccTp(a[i] - b[i]), v1 = _AccTp(a[i + 1] - b[i + 1]),
-           v2 = _AccTp(a[i + 2] - b[i + 2]), v3 = _AccTp(a[i + 3] - b[i + 3]);
-    s += std::abs(v0) + std::abs(v1) + std::abs(v2) + std::abs(v3);
-  }
-#endif
-  for (; i < n; i++) {
-    _AccTp v = _AccTp(a[i] - b[i]);
-    s += std::abs(v);
-  }
-  return s;
-}
-
-inline float normL1(const float *a, const float *b, int n) {
-  float s = 0.f;
-  for (int i = 0; i < n; i++) {
-    s += std::abs(a[i] - b[i]);
-  }
-  return s;
-}
-
-inline int normL1(const uchar *a, const uchar *b, int n) {
-  int s = 0;
-  for (int i = 0; i < n; i++) {
-    s += std::abs(a[i] - b[i]);
-  }
-  return s;
-}
-
-template <typename _Tp, typename _AccTp>
-static inline _AccTp normInf(const _Tp *a, const _Tp *b, int n) {
-  _AccTp s = 0;
-  for (int i = 0; i < n; i++) {
-    _AccTp v0 = a[i] - b[i];
-    s = std::max(s, std::abs(v0));
-  }
-  return s;
-}
-
-/** @brief Computes the cube root of an argument.
-
- The function cubeRoot computes \f$\sqrt[3]{\texttt{val}}\f$. Negative arguments
- are handled correctly. NaN and Inf are not handled. The accuracy approaches the
- maximum possible accuracy for single-precision data.
- @param val A function argument.
- */
-CV_EXPORTS_W float cubeRoot(float val);
-
-/** @overload
-
-cubeRoot with argument of `double` type calls `std::cbrt(double)`
-*/
-static inline double cubeRoot(double val) { return std::cbrt(val); }
-
-/** @brief Calculates the angle of a 2D vector in degrees.
-
- The function fastAtan2 calculates the full-range angle of an input 2D vector.
- The angle is measured in degrees and varies from 0 to 360 degrees. The accuracy
- is about 0.3 degrees.
- @param x x-coordinate of the vector.
- @param y y-coordinate of the vector.
- */
-CV_EXPORTS_W float fastAtan2(float y, float x);
-
-/** proxy for hal::LU */
-CV_EXPORTS int LU(float *A, size_t astep, int m, float *b, size_t bstep, int n);
-/** proxy for hal::LU */
-CV_EXPORTS int LU(double *A, size_t astep, int m, double *b, size_t bstep,
-                  int n);
-/** proxy for hal::Cholesky */
-CV_EXPORTS bool Cholesky(float *A, size_t astep, int m, float *b, size_t bstep,
-                         int n);
-/** proxy for hal::Cholesky */
-CV_EXPORTS bool Cholesky(double *A, size_t astep, int m, double *b,
-                         size_t bstep, int n);
-
-////////////////// forward declarations for important OpenCV types
-/////////////////////
-
-//! @cond IGNORED
-
-template <typename _Tp, int cn> class Vec;
-template <typename _Tp, int m, int n> class Matx;
-
-template <typename _Tp> class Complex;
-template <typename _Tp> class Point_;
-template <typename _Tp> class Point3_;
-template <typename _Tp> class Size_;
-template <typename _Tp> class Rect_;
-template <typename _Tp> class Scalar_;
-
-class CV_EXPORTS RotatedRect;
-class CV_EXPORTS Range;
-class CV_EXPORTS TermCriteria;
-class CV_EXPORTS KeyPoint;
-class CV_EXPORTS DMatch;
-class CV_EXPORTS RNG;
-
-class CV_EXPORTS Mat;
-class CV_EXPORTS MatExpr;
-
-class CV_EXPORTS SparseMat;
-typedef Mat MatND;
-
-template <typename _Tp> class Mat_;
-template <typename _Tp> class SparseMat_;
-
-class CV_EXPORTS MatConstIterator;
-class CV_EXPORTS SparseMatIterator;
-class CV_EXPORTS SparseMatConstIterator;
-template <typename _Tp> class MatIterator_;
-template <typename _Tp> class MatConstIterator_;
-template <typename _Tp> class SparseMatIterator_;
-template <typename _Tp> class SparseMatConstIterator_;
-
-namespace ipp {
-CV_EXPORTS unsigned long long getIppFeatures();
-CV_EXPORTS void setIppStatus(int status, const char *const funcname = NULL,
-                             const char *const filename = NULL, int line = 0);
-CV_EXPORTS int getIppStatus();
-CV_EXPORTS String getIppErrorLocation();
-CV_EXPORTS_W bool useIPP();
-CV_EXPORTS_W void setUseIPP(bool flag);
-CV_EXPORTS_W String getIppVersion();
-
-// IPP Not-Exact mode. This function may force use of IPP then both IPP and
-// OpenCV provide proper results but have internal accuracy differences which
-// have too much direct or indirect impact on accuracy tests.
-CV_EXPORTS_W bool useIPP_NotExact();
-CV_EXPORTS_W void setUseIPP_NotExact(bool flag);
-#ifndef DISABLE_OPENCV_3_COMPATIBILITY
-static inline bool useIPP_NE() { return useIPP_NotExact(); }
-static inline void setUseIPP_NE(bool flag) { setUseIPP_NotExact(flag); }
-#endif
-
-} // namespace ipp
-
-//! @endcond
-
-//! @} core_utils
-
-} // namespace cv
-
-#include "opencv2/core/check.hpp"
-#include "opencv2/core/neon_utils.hpp"
-#include "opencv2/core/vsx_utils.hpp"
-
-#endif // OPENCV_CORE_BASE_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/bindings_utils.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/bindings_utils.hpp
deleted file mode 100644
index 416f3d4747..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/bindings_utils.hpp
+++ /dev/null
@@ -1,279 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_CORE_BINDINGS_UTILS_HPP
-#define OPENCV_CORE_BINDINGS_UTILS_HPP
-
-#include <opencv2/core/async.hpp>
-#include <opencv2/core/detail/async_promise.hpp>
-#include <opencv2/core/utils/logger.hpp>
-
-#include <stdexcept>
-
-namespace cv {
-namespace utils {
-//! @addtogroup core_utils
-//! @{
-
-CV_EXPORTS_W String dumpInputArray(InputArray argument);
-
-CV_EXPORTS_W String dumpInputArrayOfArrays(InputArrayOfArrays argument);
-
-CV_EXPORTS_W String dumpInputOutputArray(InputOutputArray argument);
-
-CV_EXPORTS_W String
-dumpInputOutputArrayOfArrays(InputOutputArrayOfArrays argument);
-
-CV_WRAP static inline String dumpBool(bool argument) {
-  return (argument) ? String("Bool: True") : String("Bool: False");
-}
-
-CV_WRAP static inline String dumpInt(int argument) {
-  return cv::format("Int: %d", argument);
-}
-
-CV_WRAP static inline String dumpInt64(int64 argument) {
-  std::ostringstream oss("Int64: ", std::ios::ate);
-  oss << argument;
-  return oss.str();
-}
-
-CV_WRAP static inline String dumpSizeT(size_t argument) {
-  std::ostringstream oss("size_t: ", std::ios::ate);
-  oss << argument;
-  return oss.str();
-}
-
-CV_WRAP static inline String dumpFloat(float argument) {
-  return cv::format("Float: %.2f", argument);
-}
-
-CV_WRAP static inline String dumpDouble(double argument) {
-  return cv::format("Double: %.2f", argument);
-}
-
-CV_WRAP static inline String dumpCString(const char *argument) {
-  return cv::format("String: %s", argument);
-}
-
-CV_WRAP static inline String dumpString(const String &argument) {
-  return cv::format("String: %s", argument.c_str());
-}
-
-CV_WRAP static inline String dumpRect(const Rect &argument) {
-  return format("rect: (x=%d, y=%d, w=%d, h=%d)", argument.x, argument.y,
-                argument.width, argument.height);
-}
-
-CV_WRAP static inline String dumpTermCriteria(const TermCriteria &argument) {
-  return format("term_criteria: (type=%d, max_count=%d, epsilon=%lf",
-                argument.type, argument.maxCount, argument.epsilon);
-}
-
-CV_WRAP static inline String dumpRotatedRect(const RotatedRect &argument) {
-  return format("rotated_rect: (c_x=%f, c_y=%f, w=%f, h=%f, a=%f)",
-                argument.center.x, argument.center.y, argument.size.width,
-                argument.size.height, argument.angle);
-}
-
-CV_WRAP static inline String dumpRange(const Range &argument) {
-  if (argument == Range::all()) {
-    return "range: all";
-  } else {
-    return format("range: (s=%d, e=%d)", argument.start, argument.end);
-  }
-}
-
-CV_EXPORTS_W String dumpVectorOfInt(const std::vector<int> &vec);
-
-CV_EXPORTS_W String dumpVectorOfDouble(const std::vector<double> &vec);
-
-CV_EXPORTS_W String dumpVectorOfRect(const std::vector<Rect> &vec);
-
-//! @cond IGNORED
-
-CV_WRAP static inline String
-testOverloadResolution(int value, const Point &point = Point(42, 24)) {
-  return format("overload (int=%d, point=(x=%d, y=%d))", value, point.x,
-                point.y);
-}
-
-CV_WRAP static inline String testOverloadResolution(const Rect &rect) {
-  return format("overload (rect=(x=%d, y=%d, w=%d, h=%d))", rect.x, rect.y,
-                rect.width, rect.height);
-}
-
-CV_WRAP static inline RotatedRect testRotatedRect(float x, float y, float w,
-                                                  float h, float angle) {
-  return RotatedRect(Point2f(x, y), Size2f(w, h), angle);
-}
-
-CV_WRAP static inline std::vector<RotatedRect>
-testRotatedRectVector(float x, float y, float w, float h, float angle) {
-  std::vector<RotatedRect> result;
-  for (int i = 0; i < 10; i++)
-    result.push_back(
-        RotatedRect(Point2f(x + i, y + 2 * i), Size2f(w, h), angle + 10 * i));
-  return result;
-}
-
-CV_WRAP static inline int testOverwriteNativeMethod(int argument) {
-  return argument;
-}
-
-CV_WRAP static inline String
-testReservedKeywordConversion(int positional_argument, int lambda = 2,
-                              int from = 3) {
-  return format("arg=%d, lambda=%d, from=%d", positional_argument, lambda,
-                from);
-}
-
-CV_WRAP static inline void generateVectorOfRect(size_t len,
-                                                CV_OUT std::vector<Rect> &vec) {
-  vec.resize(len);
-  if (len > 0) {
-    RNG rng(12345);
-    Mat tmp(static_cast<int>(len), 1, CV_32SC4);
-    rng.fill(tmp, RNG::UNIFORM, 10, 20);
-    tmp.copyTo(vec);
-  }
-}
-
-CV_WRAP static inline void generateVectorOfInt(size_t len,
-                                               CV_OUT std::vector<int> &vec) {
-  vec.resize(len);
-  if (len > 0) {
-    RNG rng(554433);
-    Mat tmp(static_cast<int>(len), 1, CV_32SC1);
-    rng.fill(tmp, RNG::UNIFORM, -10, 10);
-    tmp.copyTo(vec);
-  }
-}
-
-CV_WRAP static inline void generateVectorOfMat(size_t len, int rows, int cols,
-                                               int dtype,
-                                               CV_OUT std::vector<Mat> &vec) {
-  vec.resize(len);
-  if (len > 0) {
-    RNG rng(65431);
-    for (size_t i = 0; i < len; ++i) {
-      vec[i].create(rows, cols, dtype);
-      rng.fill(vec[i], RNG::UNIFORM, 0, 10);
-    }
-  }
-}
-
-CV_WRAP static inline AsyncArray testAsyncArray(InputArray argument) {
-  AsyncPromise p;
-  p.setValue(argument);
-  return p.getArrayResult();
-}
-
-CV_WRAP static inline AsyncArray testAsyncException() {
-  AsyncPromise p;
-  return p.getArrayResult();
-}
-
-CV_WRAP static inline String dumpVec2i(const cv::Vec2i value = cv::Vec2i(42,
-                                                                         24)) {
-  return format("Vec2i(%d, %d)", value[0], value[1]);
-}
-
-struct CV_EXPORTS_W_SIMPLE ClassWithKeywordProperties {
-  CV_PROP_RW int lambda;
-  CV_PROP int except;
-
-  CV_WRAP explicit ClassWithKeywordProperties(int lambda_arg = 24,
-                                              int except_arg = 42) {
-    lambda = lambda_arg;
-    except = except_arg;
-  }
-};
-
-struct CV_EXPORTS_W_PARAMS FunctionParams {
-  CV_PROP_RW int lambda = -1;
-  CV_PROP_RW float sigma = 0.0f;
-
-  FunctionParams &setLambda(int value) CV_NOEXCEPT {
-    lambda = value;
-    return *this;
-  }
-
-  FunctionParams &setSigma(float value) CV_NOEXCEPT {
-    sigma = value;
-    return *this;
-  }
-};
-
-CV_WRAP static inline String
-copyMatAndDumpNamedArguments(InputArray src, OutputArray dst,
-                             const FunctionParams &params = FunctionParams()) {
-  src.copyTo(dst);
-  return format("lambda=%d, sigma=%.1f", params.lambda, params.sigma);
-}
-
-namespace nested {
-CV_WRAP static inline bool testEchoBooleanFunction(bool flag) { return flag; }
-
-class CV_EXPORTS_W CV_WRAP_AS(ExportClassName) OriginalClassName {
-public:
-  struct CV_EXPORTS_W_SIMPLE Params {
-    CV_PROP_RW int int_value;
-    CV_PROP_RW float float_value;
-
-    CV_WRAP explicit Params(int int_param = 123, float float_param = 3.5f) {
-      int_value = int_param;
-      float_value = float_param;
-    }
-  };
-
-  explicit OriginalClassName(
-      const OriginalClassName::Params &params = OriginalClassName::Params()) {
-    params_ = params;
-  }
-
-  CV_WRAP int getIntParam() const { return params_.int_value; }
-
-  CV_WRAP float getFloatParam() const { return params_.float_value; }
-
-  CV_WRAP static std::string originalName() { return "OriginalClassName"; }
-
-  CV_WRAP static Ptr<OriginalClassName> create(
-      const OriginalClassName::Params &params = OriginalClassName::Params()) {
-    return makePtr<OriginalClassName>(params);
-  }
-
-private:
-  OriginalClassName::Params params_;
-};
-
-typedef OriginalClassName::Params OriginalClassName_Params;
-} // namespace nested
-
-//! @endcond IGNORED
-
-namespace fs {
-CV_EXPORTS_W cv::String getCacheDirectoryForDownloads();
-} // namespace fs
-
-//! @}  // core_utils
-} // namespace utils
-
-//! @cond IGNORED
-
-CV_WRAP static inline int setLogLevel(int level) {
-  // NB: Binding generators doesn't work with enums properly yet, so we define
-  // separate overload here
-  return cv::utils::logging::setLogLevel((cv::utils::logging::LogLevel)level);
-}
-
-CV_WRAP static inline int getLogLevel() {
-  return cv::utils::logging::getLogLevel();
-}
-
-//! @endcond IGNORED
-
-} // namespace cv
-
-#endif // OPENCV_CORE_BINDINGS_UTILS_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/bufferpool.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/bufferpool.hpp
deleted file mode 100644
index 8796de938d..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/bufferpool.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-//
-// Copyright (C) 2014, Advanced Micro Devices, Inc., all rights reserved.
-
-#ifndef OPENCV_CORE_BUFFER_POOL_HPP
-#define OPENCV_CORE_BUFFER_POOL_HPP
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4265)
-#endif
-
-namespace cv {
-
-//! @addtogroup core_opencl
-//! @{
-
-class BufferPoolController {
-protected:
-  ~BufferPoolController() {}
-
-public:
-  virtual size_t getReservedSize() const = 0;
-  virtual size_t getMaxReservedSize() const = 0;
-  virtual void setMaxReservedSize(size_t size) = 0;
-  virtual void freeAllReservedBuffers() = 0;
-};
-
-//! @}
-
-} // namespace cv
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-#endif // OPENCV_CORE_BUFFER_POOL_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/check.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/check.hpp
deleted file mode 100644
index cfcfe0e814..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/check.hpp
+++ /dev/null
@@ -1,231 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_CORE_CHECK_HPP
-#define OPENCV_CORE_CHECK_HPP
-
-#include <opencv2/core/base.hpp>
-
-namespace cv {
-
-/** Returns string of cv::Mat depth value: CV_8U -> "CV_8U" or "<invalid depth>"
- */
-CV_EXPORTS const char *depthToString(int depth);
-
-/** Returns string of cv::Mat depth value: CV_8UC3 -> "CV_8UC3" or "<invalid
- * type>" */
-CV_EXPORTS String typeToString(int type);
-
-//! @cond IGNORED
-namespace detail {
-
-/** Returns string of cv::Mat depth value: CV_8U -> "CV_8U" or NULL */
-CV_EXPORTS const char *depthToString_(int depth);
-
-/** Returns string of cv::Mat depth value: CV_8UC3 -> "CV_8UC3" or cv::String()
- */
-CV_EXPORTS cv::String typeToString_(int type);
-
-enum TestOp {
-  TEST_CUSTOM = 0,
-  TEST_EQ = 1,
-  TEST_NE = 2,
-  TEST_LE = 3,
-  TEST_LT = 4,
-  TEST_GE = 5,
-  TEST_GT = 6,
-  CV__LAST_TEST_OP
-};
-
-struct CheckContext {
-  const char *func;
-  const char *file;
-  int line;
-  enum TestOp testOp;
-  const char *message;
-  const char *p1_str;
-  const char *p2_str;
-};
-
-#ifndef CV__CHECK_FILENAME
-#define CV__CHECK_FILENAME __FILE__
-#endif
-
-#ifndef CV__CHECK_FUNCTION
-#if defined _MSC_VER
-#define CV__CHECK_FUNCTION __FUNCSIG__
-#elif defined __GNUC__
-#define CV__CHECK_FUNCTION __PRETTY_FUNCTION__
-#else
-#define CV__CHECK_FUNCTION "<unknown>"
-#endif
-#endif
-
-#define CV__CHECK_LOCATION_VARNAME(id)                                         \
-  CVAUX_CONCAT(CVAUX_CONCAT(__cv_check_, id), __LINE__)
-#define CV__DEFINE_CHECK_CONTEXT(id, message, testOp, p1_str, p2_str)          \
-  static const cv::detail::CheckContext CV__CHECK_LOCATION_VARNAME(id) = {     \
-      CV__CHECK_FUNCTION, CV__CHECK_FILENAME, __LINE__, testOp,                \
-      "" message,         "" p1_str,          "" p2_str}
-
-CV_EXPORTS void CV_NORETURN check_failed_auto(const bool v1, const bool v2,
-                                              const CheckContext &ctx);
-CV_EXPORTS void CV_NORETURN check_failed_auto(const int v1, const int v2,
-                                              const CheckContext &ctx);
-CV_EXPORTS void CV_NORETURN check_failed_auto(const size_t v1, const size_t v2,
-                                              const CheckContext &ctx);
-CV_EXPORTS void CV_NORETURN check_failed_auto(const float v1, const float v2,
-                                              const CheckContext &ctx);
-CV_EXPORTS void CV_NORETURN check_failed_auto(const double v1, const double v2,
-                                              const CheckContext &ctx);
-CV_EXPORTS void CV_NORETURN check_failed_auto(const Size_<int> v1,
-                                              const Size_<int> v2,
-                                              const CheckContext &ctx);
-CV_EXPORTS void CV_NORETURN check_failed_MatDepth(const int v1, const int v2,
-                                                  const CheckContext &ctx);
-CV_EXPORTS void CV_NORETURN check_failed_MatType(const int v1, const int v2,
-                                                 const CheckContext &ctx);
-CV_EXPORTS void CV_NORETURN check_failed_MatChannels(const int v1, const int v2,
-                                                     const CheckContext &ctx);
-
-CV_EXPORTS void CV_NORETURN check_failed_true(const bool v,
-                                              const CheckContext &ctx);
-CV_EXPORTS void CV_NORETURN check_failed_false(const bool v,
-                                               const CheckContext &ctx);
-
-CV_EXPORTS void CV_NORETURN check_failed_auto(const int v,
-                                              const CheckContext &ctx);
-CV_EXPORTS void CV_NORETURN check_failed_auto(const size_t v,
-                                              const CheckContext &ctx);
-CV_EXPORTS void CV_NORETURN check_failed_auto(const float v,
-                                              const CheckContext &ctx);
-CV_EXPORTS void CV_NORETURN check_failed_auto(const double v,
-                                              const CheckContext &ctx);
-CV_EXPORTS void CV_NORETURN check_failed_auto(const Size_<int> v,
-                                              const CheckContext &ctx);
-CV_EXPORTS void CV_NORETURN check_failed_auto(const std::string &v1,
-                                              const CheckContext &ctx);
-CV_EXPORTS void CV_NORETURN check_failed_MatDepth(const int v,
-                                                  const CheckContext &ctx);
-CV_EXPORTS void CV_NORETURN check_failed_MatType(const int v,
-                                                 const CheckContext &ctx);
-CV_EXPORTS void CV_NORETURN check_failed_MatChannels(const int v,
-                                                     const CheckContext &ctx);
-
-#define CV__TEST_EQ(v1, v2) ((v1) == (v2))
-#define CV__TEST_NE(v1, v2) ((v1) != (v2))
-#define CV__TEST_LE(v1, v2) ((v1) <= (v2))
-#define CV__TEST_LT(v1, v2) ((v1) < (v2))
-#define CV__TEST_GE(v1, v2) ((v1) >= (v2))
-#define CV__TEST_GT(v1, v2) ((v1) > (v2))
-
-#define CV__CHECK(id, op, type, v1, v2, v1_str, v2_str, msg_str)               \
-  do {                                                                         \
-    if (CV__TEST_##op((v1), (v2)))                                             \
-      ;                                                                        \
-    else {                                                                     \
-      CV__DEFINE_CHECK_CONTEXT(id, msg_str, cv::detail::TEST_##op, v1_str,     \
-                               v2_str);                                        \
-      cv::detail::check_failed_##type((v1), (v2),                              \
-                                      CV__CHECK_LOCATION_VARNAME(id));         \
-    }                                                                          \
-  } while (0)
-
-#define CV__CHECK_CUSTOM_TEST(id, type, v, test_expr, v_str, test_expr_str,    \
-                              msg_str)                                         \
-  do {                                                                         \
-    if (!!(test_expr))                                                         \
-      ;                                                                        \
-    else {                                                                     \
-      CV__DEFINE_CHECK_CONTEXT(id, msg_str, cv::detail::TEST_CUSTOM, v_str,    \
-                               test_expr_str);                                 \
-      cv::detail::check_failed_##type((v), CV__CHECK_LOCATION_VARNAME(id));    \
-    }                                                                          \
-  } while (0)
-
-} // namespace detail
-//! @endcond
-
-/// Supported values of these types: int, float, double
-#define CV_CheckEQ(v1, v2, msg) CV__CHECK(_, EQ, auto, v1, v2, #v1, #v2, msg)
-#define CV_CheckNE(v1, v2, msg) CV__CHECK(_, NE, auto, v1, v2, #v1, #v2, msg)
-#define CV_CheckLE(v1, v2, msg) CV__CHECK(_, LE, auto, v1, v2, #v1, #v2, msg)
-#define CV_CheckLT(v1, v2, msg) CV__CHECK(_, LT, auto, v1, v2, #v1, #v2, msg)
-#define CV_CheckGE(v1, v2, msg) CV__CHECK(_, GE, auto, v1, v2, #v1, #v2, msg)
-#define CV_CheckGT(v1, v2, msg) CV__CHECK(_, GT, auto, v1, v2, #v1, #v2, msg)
-
-/// Check with additional "decoding" of type values in error message
-#define CV_CheckTypeEQ(t1, t2, msg)                                            \
-  CV__CHECK(_, EQ, MatType, t1, t2, #t1, #t2, msg)
-/// Check with additional "decoding" of depth values in error message
-#define CV_CheckDepthEQ(d1, d2, msg)                                           \
-  CV__CHECK(_, EQ, MatDepth, d1, d2, #d1, #d2, msg)
-
-#define CV_CheckChannelsEQ(c1, c2, msg)                                        \
-  CV__CHECK(_, EQ, MatChannels, c1, c2, #c1, #c2, msg)
-
-/// Example: type == CV_8UC1 || type == CV_8UC3
-#define CV_CheckType(t, test_expr, msg)                                        \
-  CV__CHECK_CUSTOM_TEST(_, MatType, t, (test_expr), #t, #test_expr, msg)
-
-/// Example: depth == CV_32F || depth == CV_64F
-#define CV_CheckDepth(t, test_expr, msg)                                       \
-  CV__CHECK_CUSTOM_TEST(_, MatDepth, t, (test_expr), #t, #test_expr, msg)
-
-/// Example: channel == 1 || channel == 3
-#define CV_CheckChannels(t, test_expr, msg)                                    \
-  CV__CHECK_CUSTOM_TEST(_, MatChannels, t, (test_expr), #t, #test_expr, msg)
-
-/// Example: v == A || v == B
-#define CV_Check(v, test_expr, msg)                                            \
-  CV__CHECK_CUSTOM_TEST(_, auto, v, (test_expr), #v, #test_expr, msg)
-
-/// Example: v == true
-#define CV_CheckTrue(v, msg) CV__CHECK_CUSTOM_TEST(_, true, v, v, #v, "", msg)
-
-/// Example: v == false
-#define CV_CheckFalse(v, msg)                                                  \
-  CV__CHECK_CUSTOM_TEST(_, false, v, (!(v)), #v, "", msg)
-
-/// Some complex conditions: CV_Check(src2, src2.empty() || (src2.type() ==
-/// src1.type() && src2.size() == src1.size()), "src2 should have same size/type
-/// as src1")
-// TODO define pretty-printers
-
-#ifndef NDEBUG
-#define CV_DbgCheck(v, test_expr, msg)                                         \
-  CV__CHECK_CUSTOM_TEST(_, auto, v, (test_expr), #v, #test_expr, msg)
-#define CV_DbgCheckEQ(v1, v2, msg) CV__CHECK(_, EQ, auto, v1, v2, #v1, #v2, msg)
-#define CV_DbgCheckNE(v1, v2, msg) CV__CHECK(_, NE, auto, v1, v2, #v1, #v2, msg)
-#define CV_DbgCheckLE(v1, v2, msg) CV__CHECK(_, LE, auto, v1, v2, #v1, #v2, msg)
-#define CV_DbgCheckLT(v1, v2, msg) CV__CHECK(_, LT, auto, v1, v2, #v1, #v2, msg)
-#define CV_DbgCheckGE(v1, v2, msg) CV__CHECK(_, GE, auto, v1, v2, #v1, #v2, msg)
-#define CV_DbgCheckGT(v1, v2, msg) CV__CHECK(_, GT, auto, v1, v2, #v1, #v2, msg)
-#else
-#define CV_DbgCheck(v, test_expr, msg)                                         \
-  do {                                                                         \
-  } while (0)
-#define CV_DbgCheckEQ(v1, v2, msg)                                             \
-  do {                                                                         \
-  } while (0)
-#define CV_DbgCheckNE(v1, v2, msg)                                             \
-  do {                                                                         \
-  } while (0)
-#define CV_DbgCheckLE(v1, v2, msg)                                             \
-  do {                                                                         \
-  } while (0)
-#define CV_DbgCheckLT(v1, v2, msg)                                             \
-  do {                                                                         \
-  } while (0)
-#define CV_DbgCheckGE(v1, v2, msg)                                             \
-  do {                                                                         \
-  } while (0)
-#define CV_DbgCheckGT(v1, v2, msg)                                             \
-  do {                                                                         \
-  } while (0)
-#endif
-
-} // namespace cv
-
-#endif // OPENCV_CORE_CHECK_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/core.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/core.hpp
deleted file mode 100644
index a81cf56630..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/core.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifdef __OPENCV_BUILD
-#error this is a compatibility header which should not be used inside the OpenCV library
-#endif
-
-#include "opencv2/core.hpp"
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/core_c.h b/packages/react-native-executorch/third-party/include/opencv2/core/core_c.h
deleted file mode 100644
index 657d6bfd54..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/core_c.h
+++ /dev/null
@@ -1,3261 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_CORE_C_H
-#define OPENCV_CORE_C_H
-
-#include "opencv2/core/types_c.h"
-
-#ifdef __cplusplus
-/* disable MSVC warning C4190 / clang-cl -Wreturn-type-c-linkage:
-       'function' has C-linkage specified, but returns UDT 'typename'
-       which is incompatible with C
-
-   It is OK to disable it because we only extend few plain structures with
-   C++ constructors for simpler interoperability with C++ API of the library
-*/
-#if defined(__clang__)
-// handle clang on Linux and clang-cl (i. e. clang on Windows) first
-#pragma GCC diagnostic ignored "-Wreturn-type-c-linkage"
-#elif defined(_MSC_VER)
-// then handle MSVC
-#pragma warning(disable : 4190)
-#endif
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** @addtogroup core_c
-    @{
-*/
-
-/****************************************************************************************\
-*          Array allocation, deallocation, initialization and access to elements
-*
-\****************************************************************************************/
-
-/** `malloc` wrapper.
-   If there is no enough memory, the function
-   (as well as other OpenCV functions that call cvAlloc)
-   raises an error. */
-CVAPI(void *) cvAlloc(size_t size);
-
-/** `free` wrapper.
-   Here and further all the memory releasing functions
-   (that all call cvFree) take double pointer in order to
-   to clear pointer to the data after releasing it.
-   Passing pointer to NULL pointer is Ok: nothing happens in this case
-*/
-CVAPI(void) cvFree_(void *ptr);
-#define cvFree(ptr) (cvFree_(*(ptr)), *(ptr) = 0)
-
-/** @brief Creates an image header but does not allocate the image data.
-
-@param size Image width and height
-@param depth Image depth (see cvCreateImage )
-@param channels Number of channels (see cvCreateImage )
- */
-CVAPI(IplImage *) cvCreateImageHeader(CvSize size, int depth, int channels);
-
-/** @brief Initializes an image header that was previously allocated.
-
-The returned IplImage\* points to the initialized header.
-@param image Image header to initialize
-@param size Image width and height
-@param depth Image depth (see cvCreateImage )
-@param channels Number of channels (see cvCreateImage )
-@param origin Top-left IPL_ORIGIN_TL or bottom-left IPL_ORIGIN_BL
-@param align Alignment for image rows, typically 4 or 8 bytes
- */
-CVAPI(IplImage *)
-cvInitImageHeader(IplImage *image, CvSize size, int depth, int channels,
-                  int origin CV_DEFAULT(0), int align CV_DEFAULT(4));
-
-/** @brief Creates an image header and allocates the image data.
-
-This function call is equivalent to the following code:
-@code
-    header = cvCreateImageHeader(size, depth, channels);
-    cvCreateData(header);
-@endcode
-@param size Image width and height
-@param depth Bit depth of image elements. See IplImage for valid depths.
-@param channels Number of channels per pixel. See IplImage for details. This
-function only creates images with interleaved channels.
- */
-CVAPI(IplImage *) cvCreateImage(CvSize size, int depth, int channels);
-
-/** @brief Deallocates an image header.
-
-This call is an analogue of :
-@code
-    if(image )
-    {
-        iplDeallocate(*image, IPL_IMAGE_HEADER | IPL_IMAGE_ROI);
-        *image = 0;
-    }
-@endcode
-but it does not use IPL functions by default (see the
-CV_TURN_ON_IPL_COMPATIBILITY macro).
-@param image Double pointer to the image header
- */
-CVAPI(void) cvReleaseImageHeader(IplImage **image);
-
-/** @brief Deallocates the image header and the image data.
-
-This call is a shortened form of :
-@code
-    if(*image )
-    {
-        cvReleaseData(*image);
-        cvReleaseImageHeader(image);
-    }
-@endcode
-@param image Double pointer to the image header
-*/
-CVAPI(void) cvReleaseImage(IplImage **image);
-
-/** Creates a copy of IPL image (widthStep may differ) */
-CVAPI(IplImage *) cvCloneImage(const IplImage *image);
-
-/** @brief Sets the channel of interest in an IplImage.
-
-If the ROI is set to NULL and the coi is *not* 0, the ROI is allocated. Most
-OpenCV functions do *not* support the COI setting, so to process an individual
-image/matrix channel one may copy (via cvCopy or cvSplit) the channel to a
-separate image/matrix, process it and then copy the result back (via cvCopy or
-cvMerge) if needed.
-@param image A pointer to the image header
-@param coi The channel of interest. 0 - all channels are selected, 1 - first
-channel is selected, etc. Note that the channel indices become 1-based.
- */
-CVAPI(void) cvSetImageCOI(IplImage *image, int coi);
-
-/** @brief Returns the index of the channel of interest.
-
-Returns the channel of interest of in an IplImage. Returned values correspond to
-the coi in cvSetImageCOI.
-@param image A pointer to the image header
- */
-CVAPI(int) cvGetImageCOI(const IplImage *image);
-
-/** @brief Sets an image Region Of Interest (ROI) for a given rectangle.
-
-If the original image ROI was NULL and the rect is not the whole image, the ROI
-structure is allocated.
-
-Most OpenCV functions support the use of ROI and treat the image rectangle as a
-separate image. For example, all of the pixel coordinates are counted from the
-top-left (or bottom-left) corner of the ROI, not the original image.
-@param image A pointer to the image header
-@param rect The ROI rectangle
- */
-CVAPI(void) cvSetImageROI(IplImage *image, CvRect rect);
-
-/** @brief Resets the image ROI to include the entire image and releases the ROI
-structure.
-
-This produces a similar result to the following, but in addition it releases the
-ROI structure. :
-@code
-    cvSetImageROI(image, cvRect(0, 0, image->width, image->height ));
-    cvSetImageCOI(image, 0);
-@endcode
-@param image A pointer to the image header
- */
-CVAPI(void) cvResetImageROI(IplImage *image);
-
-/** @brief Returns the image ROI.
-
-If there is no ROI set, cvRect(0,0,image-\>width,image-\>height) is returned.
-@param image A pointer to the image header
- */
-CVAPI(CvRect) cvGetImageROI(const IplImage *image);
-
-/** @brief Creates a matrix header but does not allocate the matrix data.
-
-The function allocates a new matrix header and returns a pointer to it. The
-matrix data can then be allocated using cvCreateData or set explicitly to
-user-allocated data via cvSetData.
-@param rows Number of rows in the matrix
-@param cols Number of columns in the matrix
-@param type Type of the matrix elements, see cvCreateMat
- */
-CVAPI(CvMat *) cvCreateMatHeader(int rows, int cols, int type);
-
-#define CV_AUTOSTEP 0x7fffffff
-
-/** @brief Initializes a pre-allocated matrix header.
-
-This function is often used to process raw data with OpenCV matrix functions.
-For example, the following code computes the matrix product of two matrices,
-stored as ordinary arrays:
-@code
-    double a[] = { 1, 2, 3, 4,
-                   5, 6, 7, 8,
-                   9, 10, 11, 12 };
-
-    double b[] = { 1, 5, 9,
-                   2, 6, 10,
-                   3, 7, 11,
-                   4, 8, 12 };
-
-    double c[9];
-    CvMat Ma, Mb, Mc ;
-
-    cvInitMatHeader(&Ma, 3, 4, CV_64FC1, a);
-    cvInitMatHeader(&Mb, 4, 3, CV_64FC1, b);
-    cvInitMatHeader(&Mc, 3, 3, CV_64FC1, c);
-
-    cvMatMulAdd(&Ma, &Mb, 0, &Mc);
-    // the c array now contains the product of a (3x4) and b (4x3)
-@endcode
-@param mat A pointer to the matrix header to be initialized
-@param rows Number of rows in the matrix
-@param cols Number of columns in the matrix
-@param type Type of the matrix elements, see cvCreateMat .
-@param data Optional: data pointer assigned to the matrix header
-@param step Optional: full row width in bytes of the assigned data. By default,
-the minimal possible step is used which assumes there are no gaps between
-subsequent rows of the matrix.
- */
-CVAPI(CvMat *)
-cvInitMatHeader(CvMat *mat, int rows, int cols, int type,
-                void *data CV_DEFAULT(NULL), int step CV_DEFAULT(CV_AUTOSTEP));
-
-/** @brief Creates a matrix header and allocates the matrix data.
-
-The function call is equivalent to the following code:
-@code
-    CvMat* mat = cvCreateMatHeader(rows, cols, type);
-    cvCreateData(mat);
-@endcode
-@param rows Number of rows in the matrix
-@param cols Number of columns in the matrix
-@param type The type of the matrix elements in the form
-CV_\<bit depth\>\<S|U|F\>C\<number of channels\> , where S=signed, U=unsigned,
-F=float. For example, CV _ 8UC1 means the elements are 8-bit unsigned and the
-there is 1 channel, and CV _ 32SC2 means the elements are 32-bit signed and
-there are 2 channels.
- */
-CVAPI(CvMat *) cvCreateMat(int rows, int cols, int type);
-
-/** @brief Deallocates a matrix.
-
-The function decrements the matrix data reference counter and deallocates matrix
-header. If the data reference counter is 0, it also deallocates the data. :
-@code
-    if(*mat )
-        cvDecRefData(*mat);
-    cvFree((void**)mat);
-@endcode
-@param mat Double pointer to the matrix
- */
-CVAPI(void) cvReleaseMat(CvMat **mat);
-
-/** @brief Decrements an array data reference counter.
-
-The function decrements the data reference counter in a CvMat or CvMatND if the
-reference counter
-
-pointer is not NULL. If the counter reaches zero, the data is deallocated. In
-the current implementation the reference counter is not NULL only if the data
-was allocated using the cvCreateData function. The counter will be NULL in other
-cases such as: external data was assigned to the header using cvSetData, header
-is part of a larger matrix or image, or the header was converted from an image
-or n-dimensional matrix header.
-@param arr Pointer to an array header
- */
-CV_INLINE void cvDecRefData(CvArr *arr) {
-  if (CV_IS_MAT(arr)) {
-    CvMat *mat = (CvMat *)arr;
-    mat->data.ptr = NULL;
-    if (mat->refcount != NULL && --*mat->refcount == 0)
-      cvFree(&mat->refcount);
-    mat->refcount = NULL;
-  } else if (CV_IS_MATND(arr)) {
-    CvMatND *mat = (CvMatND *)arr;
-    mat->data.ptr = NULL;
-    if (mat->refcount != NULL && --*mat->refcount == 0)
-      cvFree(&mat->refcount);
-    mat->refcount = NULL;
-  }
-}
-
-/** @brief Increments array data reference counter.
-
-The function increments CvMat or CvMatND data reference counter and returns the
-new counter value if the reference counter pointer is not NULL, otherwise it
-returns zero.
-@param arr Array header
- */
-CV_INLINE int cvIncRefData(CvArr *arr) {
-  int refcount = 0;
-  if (CV_IS_MAT(arr)) {
-    CvMat *mat = (CvMat *)arr;
-    if (mat->refcount != NULL)
-      refcount = ++*mat->refcount;
-  } else if (CV_IS_MATND(arr)) {
-    CvMatND *mat = (CvMatND *)arr;
-    if (mat->refcount != NULL)
-      refcount = ++*mat->refcount;
-  }
-  return refcount;
-}
-
-/** Creates an exact copy of the input matrix (except, may be, step value) */
-CVAPI(CvMat *) cvCloneMat(const CvMat *mat);
-
-/** @brief Returns matrix header corresponding to the rectangular sub-array of
-input image or matrix.
-
-The function returns header, corresponding to a specified rectangle of the input
-array. In other
-
-words, it allows the user to treat a rectangular part of input array as a
-stand-alone array. ROI is taken into account by the function so the sub-array of
-ROI is actually extracted.
-@param arr Input array
-@param submat Pointer to the resultant sub-array header
-@param rect Zero-based coordinates of the rectangle of interest
- */
-CVAPI(CvMat *) cvGetSubRect(const CvArr *arr, CvMat *submat, CvRect rect);
-#define cvGetSubArr cvGetSubRect
-
-/** @brief Returns array row or row span.
-
-The function returns the header, corresponding to a specified row/row span of
-the input array. cvGetRow(arr, submat, row) is a shortcut for cvGetRows(arr,
-submat, row, row+1).
-@param arr Input array
-@param submat Pointer to the resulting sub-array header
-@param start_row Zero-based index of the starting row (inclusive) of the span
-@param end_row Zero-based index of the ending row (exclusive) of the span
-@param delta_row Index step in the row span. That is, the function extracts
-every delta_row -th row from start_row and up to (but not including) end_row .
- */
-CVAPI(CvMat *)
-cvGetRows(const CvArr *arr, CvMat *submat, int start_row, int end_row,
-          int delta_row CV_DEFAULT(1));
-
-/** @overload
-@param arr Input array
-@param submat Pointer to the resulting sub-array header
-@param row Zero-based index of the selected row
-*/
-CV_INLINE CvMat *cvGetRow(const CvArr *arr, CvMat *submat, int row) {
-  return cvGetRows(arr, submat, row, row + 1, 1);
-}
-
-/** @brief Returns one of more array columns.
-
-The function returns the header, corresponding to a specified column span of the
-input array. That
-
-is, no data is copied. Therefore, any modifications of the submatrix will affect
-the original array. If you need to copy the columns, use cvCloneMat.
-cvGetCol(arr, submat, col) is a shortcut for cvGetCols(arr, submat, col, col+1).
-@param arr Input array
-@param submat Pointer to the resulting sub-array header
-@param start_col Zero-based index of the starting column (inclusive) of the span
-@param end_col Zero-based index of the ending column (exclusive) of the span
- */
-CVAPI(CvMat *)
-cvGetCols(const CvArr *arr, CvMat *submat, int start_col, int end_col);
-
-/** @overload
-@param arr Input array
-@param submat Pointer to the resulting sub-array header
-@param col Zero-based index of the selected column
-*/
-CV_INLINE CvMat *cvGetCol(const CvArr *arr, CvMat *submat, int col) {
-  return cvGetCols(arr, submat, col, col + 1);
-}
-
-/** @brief Returns one of array diagonals.
-
-The function returns the header, corresponding to a specified diagonal of the
-input array.
-@param arr Input array
-@param submat Pointer to the resulting sub-array header
-@param diag Index of the array diagonal. Zero value corresponds to the main
-diagonal, -1 corresponds to the diagonal above the main, 1 corresponds to the
-diagonal below the main, and so forth.
- */
-CVAPI(CvMat *)
-cvGetDiag(const CvArr *arr, CvMat *submat, int diag CV_DEFAULT(0));
-
-/** low-level scalar <-> raw data conversion functions */
-CVAPI(void)
-cvScalarToRawData(const CvScalar *scalar, void *data, int type,
-                  int extend_to_12 CV_DEFAULT(0));
-
-CVAPI(void) cvRawDataToScalar(const void *data, int type, CvScalar *scalar);
-
-/** @brief Creates a new matrix header but does not allocate the matrix data.
-
-The function allocates a header for a multi-dimensional dense array. The array
-data can further be allocated using cvCreateData or set explicitly to
-user-allocated data via cvSetData.
-@param dims Number of array dimensions
-@param sizes Array of dimension sizes
-@param type Type of array elements, see cvCreateMat
- */
-CVAPI(CvMatND *) cvCreateMatNDHeader(int dims, const int *sizes, int type);
-
-/** @brief Creates the header and allocates the data for a multi-dimensional
-dense array.
-
-This function call is equivalent to the following code:
-@code
-    CvMatND* mat = cvCreateMatNDHeader(dims, sizes, type);
-    cvCreateData(mat);
-@endcode
-@param dims Number of array dimensions. This must not exceed CV_MAX_DIM (32 by
-default, but can be changed at build time).
-@param sizes Array of dimension sizes.
-@param type Type of array elements, see cvCreateMat .
- */
-CVAPI(CvMatND *) cvCreateMatND(int dims, const int *sizes, int type);
-
-/** @brief Initializes a pre-allocated multi-dimensional array header.
-
-@param mat A pointer to the array header to be initialized
-@param dims The number of array dimensions
-@param sizes An array of dimension sizes
-@param type Type of array elements, see cvCreateMat
-@param data Optional data pointer assigned to the matrix header
- */
-CVAPI(CvMatND *)
-cvInitMatNDHeader(CvMatND *mat, int dims, const int *sizes, int type,
-                  void *data CV_DEFAULT(NULL));
-
-/** @brief Deallocates a multi-dimensional array.
-
-The function decrements the array data reference counter and releases the array
-header. If the reference counter reaches 0, it also deallocates the data. :
-@code
-    if(*mat )
-        cvDecRefData(*mat);
-    cvFree((void**)mat);
-@endcode
-@param mat Double pointer to the array
- */
-CV_INLINE void cvReleaseMatND(CvMatND **mat) { cvReleaseMat((CvMat **)mat); }
-
-/** Creates a copy of CvMatND (except, may be, steps) */
-CVAPI(CvMatND *) cvCloneMatND(const CvMatND *mat);
-
-/** @brief Creates sparse array.
-
-The function allocates a multi-dimensional sparse array. Initially the array
-contain no elements, that is PtrND and other related functions will return 0 for
-every index.
-@param dims Number of array dimensions. In contrast to the dense matrix, the
-number of dimensions is practically unlimited (up to \f$2^{16}\f$ ).
-@param sizes Array of dimension sizes
-@param type Type of array elements. The same as for CvMat
- */
-CVAPI(CvSparseMat *) cvCreateSparseMat(int dims, const int *sizes, int type);
-
-/** @brief Deallocates sparse array.
-
-The function releases the sparse array and clears the array pointer upon exit.
-@param mat Double pointer to the array
- */
-CVAPI(void) cvReleaseSparseMat(CvSparseMat **mat);
-
-/** Creates a copy of CvSparseMat (except, may be, zero items) */
-CVAPI(CvSparseMat *) cvCloneSparseMat(const CvSparseMat *mat);
-
-/** @brief Initializes sparse array elements iterator.
-
-The function initializes iterator of sparse array elements and returns pointer
-to the first element, or NULL if the array is empty.
-@param mat Input array
-@param mat_iterator Initialized iterator
- */
-CVAPI(CvSparseNode *)
-cvInitSparseMatIterator(const CvSparseMat *mat,
-                        CvSparseMatIterator *mat_iterator);
-
-/** @brief Returns the next sparse matrix element
-
-The function moves iterator to the next sparse matrix element and returns
-pointer to it. In the current version there is no any particular order of the
-elements, because they are stored in the hash table. The sample below
-demonstrates how to iterate through the sparse matrix:
-@code
-    // print all the non-zero sparse matrix elements and compute their sum
-    double sum = 0;
-    int i, dims = cvGetDims(sparsemat);
-    CvSparseMatIterator it;
-    CvSparseNode* node = cvInitSparseMatIterator(sparsemat, &it);
-
-    for(; node != 0; node = cvGetNextSparseNode(&it))
-    {
-        int* idx = CV_NODE_IDX(array, node);
-        float val = *(float*)CV_NODE_VAL(array, node);
-        printf("M");
-        for(i = 0; i < dims; i++ )
-            printf("[%d]", idx[i]);
-        printf("=%g\n", val);
-
-        sum += val;
-    }
-
-    printf("nTotal sum = %g\n", sum);
-@endcode
-@param mat_iterator Sparse array iterator
- */
-CV_INLINE CvSparseNode *cvGetNextSparseNode(CvSparseMatIterator *mat_iterator) {
-  if (mat_iterator->node->next)
-    return mat_iterator->node = mat_iterator->node->next;
-  else {
-    int idx;
-    for (idx = ++mat_iterator->curidx; idx < mat_iterator->mat->hashsize;
-         idx++) {
-      CvSparseNode *node = (CvSparseNode *)mat_iterator->mat->hashtable[idx];
-      if (node) {
-        mat_iterator->curidx = idx;
-        return mat_iterator->node = node;
-      }
-    }
-    return NULL;
-  }
-}
-
-#define CV_MAX_ARR 10
-
-/** matrix iterator: used for n-ary operations on dense arrays */
-typedef struct CvNArrayIterator {
-  int count;   /**< number of arrays */
-  int dims;    /**< number of dimensions to iterate */
-  CvSize size; /**< maximal common linear size: { width = size, height = 1 } */
-  uchar *ptr[CV_MAX_ARR];   /**< pointers to the array slices */
-  int stack[CV_MAX_DIM];    /**< for internal use */
-  CvMatND *hdr[CV_MAX_ARR]; /**< pointers to the headers of the
-                               matrices that are processed */
-} CvNArrayIterator;
-
-#define CV_NO_DEPTH_CHECK 1
-#define CV_NO_CN_CHECK 2
-#define CV_NO_SIZE_CHECK 4
-
-/** initializes iterator that traverses through several arrays simultaneously
-   (the function together with cvNextArraySlice is used for
-    N-ari element-wise operations) */
-CVAPI(int)
-cvInitNArrayIterator(int count, CvArr **arrs, const CvArr *mask, CvMatND *stubs,
-                     CvNArrayIterator *array_iterator, int flags CV_DEFAULT(0));
-
-/** returns zero value if iteration is finished, non-zero (slice length)
- * otherwise */
-CVAPI(int) cvNextNArraySlice(CvNArrayIterator *array_iterator);
-
-/** @brief Returns type of array elements.
-
-The function returns type of the array elements. In the case of IplImage the
-type is converted to CvMat-like representation. For example, if the image has
-been created as:
-@code
-    IplImage* img = cvCreateImage(cvSize(640, 480), IPL_DEPTH_8U, 3);
-@endcode
-The code cvGetElemType(img) will return CV_8UC3.
-@param arr Input array
- */
-CVAPI(int) cvGetElemType(const CvArr *arr);
-
-/** @brief Return number of array dimensions
-
-The function returns the array dimensionality and the array of dimension sizes.
-In the case of IplImage or CvMat it always returns 2 regardless of number of
-image/matrix rows. For example, the following code calculates total number of
-array elements:
-@code
-    int sizes[CV_MAX_DIM];
-    int i, total = 1;
-    int dims = cvGetDims(arr, size);
-    for(i = 0; i < dims; i++ )
-        total *= sizes[i];
-@endcode
-@param arr Input array
-@param sizes Optional output vector of the array dimension sizes. For 2d arrays
-the number of rows (height) goes first, number of columns (width) next.
- */
-CVAPI(int) cvGetDims(const CvArr *arr, int *sizes CV_DEFAULT(NULL));
-
-/** @brief Returns array size along the specified dimension.
-
-@param arr Input array
-@param index Zero-based dimension index (for matrices 0 means number of rows, 1
-means number of columns; for images 0 means height, 1 means width)
- */
-CVAPI(int) cvGetDimSize(const CvArr *arr, int index);
-
-/** @brief Return pointer to a particular array element.
-
-The functions return a pointer to a specific array element. Number of array
-dimension should match to the number of indices passed to the function except
-for cvPtr1D function that can be used for sequential access to 1D, 2D or nD
-dense arrays.
-
-The functions can be used for sparse arrays as well - if the requested node does
-not exist they create it and set it to zero.
-
-All these as well as other functions accessing array elements ( cvGetND ,
-cvGetRealND , cvSet , cvSetND , cvSetRealND ) raise an error in case if the
-element index is out of range.
-@param arr Input array
-@param idx0 The first zero-based component of the element index
-@param type Optional output parameter: type of matrix elements
- */
-CVAPI(uchar *) cvPtr1D(const CvArr *arr, int idx0, int *type CV_DEFAULT(NULL));
-/** @overload */
-CVAPI(uchar *)
-cvPtr2D(const CvArr *arr, int idx0, int idx1, int *type CV_DEFAULT(NULL));
-/** @overload */
-CVAPI(uchar *)
-cvPtr3D(const CvArr *arr, int idx0, int idx1, int idx2,
-        int *type CV_DEFAULT(NULL));
-/** @overload
-@param arr Input array
-@param idx Array of the element indices
-@param type Optional output parameter: type of matrix elements
-@param create_node Optional input parameter for sparse matrices. Non-zero value
-of the parameter means that the requested element is created if it does not
-exist already.
-@param precalc_hashval Optional input parameter for sparse matrices. If the
-pointer is not NULL, the function does not recalculate the node hash value, but
-takes it from the specified location. It is useful for speeding up pair-wise
-operations (TODO: provide an example)
-*/
-CVAPI(uchar *)
-cvPtrND(const CvArr *arr, const int *idx, int *type CV_DEFAULT(NULL),
-        int create_node CV_DEFAULT(1),
-        unsigned *precalc_hashval CV_DEFAULT(NULL));
-
-/** @brief Return a specific array element.
-
-The functions return a specific array element. In the case of a sparse array the
-functions return 0 if the requested node does not exist (no new node is created
-by the functions).
-@param arr Input array
-@param idx0 The first zero-based component of the element index
- */
-CVAPI(CvScalar) cvGet1D(const CvArr *arr, int idx0);
-/** @overload */
-CVAPI(CvScalar) cvGet2D(const CvArr *arr, int idx0, int idx1);
-/** @overload */
-CVAPI(CvScalar) cvGet3D(const CvArr *arr, int idx0, int idx1, int idx2);
-/** @overload
-@param arr Input array
-@param idx Array of the element indices
-*/
-CVAPI(CvScalar) cvGetND(const CvArr *arr, const int *idx);
-
-/** @brief Return a specific element of single-channel 1D, 2D, 3D or nD array.
-
-Returns a specific element of a single-channel array. If the array has multiple
-channels, a runtime error is raised. Note that Get?D functions can be used
-safely for both single-channel and multiple-channel arrays though they are a bit
-slower.
-
-In the case of a sparse array the functions return 0 if the requested node does
-not exist (no new node is created by the functions).
-@param arr Input array. Must have a single channel.
-@param idx0 The first zero-based component of the element index
- */
-CVAPI(double) cvGetReal1D(const CvArr *arr, int idx0);
-/** @overload */
-CVAPI(double) cvGetReal2D(const CvArr *arr, int idx0, int idx1);
-/** @overload */
-CVAPI(double) cvGetReal3D(const CvArr *arr, int idx0, int idx1, int idx2);
-/** @overload
-@param arr Input array. Must have a single channel.
-@param idx Array of the element indices
-*/
-CVAPI(double) cvGetRealND(const CvArr *arr, const int *idx);
-
-/** @brief Change the particular array element.
-
-The functions assign the new value to a particular array element. In the case of
-a sparse array the functions create the node if it does not exist yet.
-@param arr Input array
-@param idx0 The first zero-based component of the element index
-@param value The assigned value
- */
-CVAPI(void) cvSet1D(CvArr *arr, int idx0, CvScalar value);
-/** @overload */
-CVAPI(void) cvSet2D(CvArr *arr, int idx0, int idx1, CvScalar value);
-/** @overload */
-CVAPI(void) cvSet3D(CvArr *arr, int idx0, int idx1, int idx2, CvScalar value);
-/** @overload
-@param arr Input array
-@param idx Array of the element indices
-@param value The assigned value
-*/
-CVAPI(void) cvSetND(CvArr *arr, const int *idx, CvScalar value);
-
-/** @brief Change a specific array element.
-
-The functions assign a new value to a specific element of a single-channel
-array. If the array has multiple channels, a runtime error is raised. Note that
-the Set\*D function can be used safely for both single-channel and
-multiple-channel arrays, though they are a bit slower.
-
-In the case of a sparse array the functions create the node if it does not yet
-exist.
-@param arr Input array
-@param idx0 The first zero-based component of the element index
-@param value The assigned value
- */
-CVAPI(void) cvSetReal1D(CvArr *arr, int idx0, double value);
-/** @overload */
-CVAPI(void) cvSetReal2D(CvArr *arr, int idx0, int idx1, double value);
-/** @overload */
-CVAPI(void) cvSetReal3D(CvArr *arr, int idx0, int idx1, int idx2, double value);
-/** @overload
-@param arr Input array
-@param idx Array of the element indices
-@param value The assigned value
-*/
-CVAPI(void) cvSetRealND(CvArr *arr, const int *idx, double value);
-
-/** clears element of ND dense array,
-   in case of sparse arrays it deletes the specified node */
-CVAPI(void) cvClearND(CvArr *arr, const int *idx);
-
-/** @brief Returns matrix header for arbitrary array.
-
-The function returns a matrix header for the input array that can be a matrix -
-CvMat, an image - IplImage, or a multi-dimensional dense array - CvMatND (the
-third option is allowed only if allowND != 0) . In the case of matrix the
-function simply returns the input pointer. In the case of IplImage\* or CvMatND
-it initializes the header structure with parameters of the current image ROI and
-returns &header. Because COI is not supported by CvMat, it is returned
-separately.
-
-The function provides an easy way to handle both types of arrays - IplImage and
-CvMat using the same code. Input array must have non-zero data pointer,
-otherwise the function will report an error.
-
-@note If the input array is IplImage with planar data layout and COI set, the
-function returns the pointer to the selected plane and COI == 0. This feature
-allows user to process IplImage structures with planar data layout, even though
-OpenCV does not support such images.
-@param arr Input array
-@param header Pointer to CvMat structure used as a temporary buffer
-@param coi Optional output parameter for storing COI
-@param allowND If non-zero, the function accepts multi-dimensional dense arrays
-(CvMatND\*) and returns 2D matrix (if CvMatND has two dimensions) or 1D matrix
-(when CvMatND has 1 dimension or more than 2 dimensions). The CvMatND array must
-be continuous.
-@sa cvGetImage, cvarrToMat.
- */
-CVAPI(CvMat *)
-cvGetMat(const CvArr *arr, CvMat *header, int *coi CV_DEFAULT(NULL),
-         int allowND CV_DEFAULT(0));
-
-/** @brief Returns image header for arbitrary array.
-
-The function returns the image header for the input array that can be a matrix
-(CvMat) or image (IplImage). In the case of an image the function simply returns
-the input pointer. In the case of CvMat it initializes an image_header structure
-with the parameters of the input matrix. Note that if we transform IplImage to
-CvMat using cvGetMat and then transform CvMat back to IplImage using this
-function, we will get different headers if the ROI is set in the original image.
-@param arr Input array
-@param image_header Pointer to IplImage structure used as a temporary buffer
- */
-CVAPI(IplImage *) cvGetImage(const CvArr *arr, IplImage *image_header);
-
-/** @brief Changes the shape of a multi-dimensional array without copying the
-data.
-
-The function is an advanced version of cvReshape that can work with
-multi-dimensional arrays as well (though it can work with ordinary images and
-matrices) and change the number of dimensions.
-
-Below are the two samples from the cvReshape description rewritten using
-cvReshapeMatND:
-@code
-    IplImage* color_img = cvCreateImage(cvSize(320,240), IPL_DEPTH_8U, 3);
-    IplImage gray_img_hdr, *gray_img;
-    gray_img = (IplImage*)cvReshapeMatND(color_img, sizeof(gray_img_hdr),
-&gray_img_hdr, 1, 0, 0);
-    ...
-    int size[] = { 2, 2, 2 };
-    CvMatND* mat = cvCreateMatND(3, size, CV_32F);
-    CvMat row_header, *row;
-    row = (CvMat*)cvReshapeMatND(mat, sizeof(row_header), &row_header, 0, 1, 0);
-@endcode
-In C, the header file for this function includes a convenient macro cvReshapeND
-that does away with the sizeof_header parameter. So, the lines containing the
-call to cvReshapeMatND in the examples may be replaced as follow:
-@code
-    gray_img = (IplImage*)cvReshapeND(color_img, &gray_img_hdr, 1, 0, 0);
-    ...
-    row = (CvMat*)cvReshapeND(mat, &row_header, 0, 1, 0);
-@endcode
-@param arr Input array
-@param sizeof_header Size of output header to distinguish between IplImage,
-CvMat and CvMatND output headers
-@param header Output header to be filled
-@param new_cn New number of channels. new_cn = 0 means that the number of
-channels remains unchanged.
-@param new_dims New number of dimensions. new_dims = 0 means that the number of
-dimensions remains the same.
-@param new_sizes Array of new dimension sizes. Only new_dims-1 values are used,
-because the total number of elements must remain the same. Thus, if new_dims =
-1, new_sizes array is not used.
- */
-CVAPI(CvArr *)
-cvReshapeMatND(const CvArr *arr, int sizeof_header, CvArr *header, int new_cn,
-               int new_dims, int *new_sizes);
-
-#define cvReshapeND(arr, header, new_cn, new_dims, new_sizes)                  \
-  cvReshapeMatND((arr), sizeof(*(header)), (header), (new_cn), (new_dims),     \
-                 (new_sizes))
-
-/** @brief Changes shape of matrix/image without copying data.
-
-The function initializes the CvMat header so that it points to the same data as
-the original array but has a different shape - different number of channels,
-different number of rows, or both.
-
-The following example code creates one image buffer and two image headers, the
-first is for a 320x240x3 image and the second is for a 960x240x1 image:
-@code
-    IplImage* color_img = cvCreateImage(cvSize(320,240), IPL_DEPTH_8U, 3);
-    CvMat gray_mat_hdr;
-    IplImage gray_img_hdr, *gray_img;
-    cvReshape(color_img, &gray_mat_hdr, 1);
-    gray_img = cvGetImage(&gray_mat_hdr, &gray_img_hdr);
-@endcode
-And the next example converts a 3x3 matrix to a single 1x9 vector:
-@code
-    CvMat* mat = cvCreateMat(3, 3, CV_32F);
-    CvMat row_header, *row;
-    row = cvReshape(mat, &row_header, 0, 1);
-@endcode
-@param arr Input array
-@param header Output header to be filled
-@param new_cn New number of channels. 'new_cn = 0' means that the number of
-channels remains unchanged.
-@param new_rows New number of rows. 'new_rows = 0' means that the number of rows
-remains unchanged unless it needs to be changed according to new_cn value.
-*/
-CVAPI(CvMat *)
-cvReshape(const CvArr *arr, CvMat *header, int new_cn,
-          int new_rows CV_DEFAULT(0));
-
-/** Repeats source 2d array several times in both horizontal and
-   vertical direction to fill destination array */
-CVAPI(void) cvRepeat(const CvArr *src, CvArr *dst);
-
-/** @brief Allocates array data
-
-The function allocates image, matrix or multi-dimensional dense array data. Note
-that in the case of matrix types OpenCV allocation functions are used. In the
-case of IplImage they are used unless CV_TURN_ON_IPL_COMPATIBILITY() has been
-called before. In the latter case IPL functions are used to allocate the data.
-@param arr Array header
- */
-CVAPI(void) cvCreateData(CvArr *arr);
-
-/** @brief Releases array data.
-
-The function releases the array data. In the case of CvMat or CvMatND it simply
-calls cvDecRefData(), that is the function can not deallocate external data. See
-also the note to cvCreateData .
-@param arr Array header
- */
-CVAPI(void) cvReleaseData(CvArr *arr);
-
-/** @brief Assigns user data to the array header.
-
-The function assigns user data to the array header. Header should be initialized
-before using cvCreateMatHeader, cvCreateImageHeader, cvCreateMatNDHeader,
-cvInitMatHeader, cvInitImageHeader or cvInitMatNDHeader.
-@param arr Array header
-@param data User data
-@param step Full row length in bytes
- */
-CVAPI(void) cvSetData(CvArr *arr, void *data, int step);
-
-/** @brief Retrieves low-level information about the array.
-
-The function fills output variables with low-level information about the array
-data. All output
-
-parameters are optional, so some of the pointers may be set to NULL. If the
-array is IplImage with ROI set, the parameters of ROI are returned.
-
-The following example shows how to get access to array elements. It computes
-absolute values of the array elements :
-@code
-    float* data;
-    int step;
-    CvSize size;
-
-    cvGetRawData(array, (uchar**)&data, &step, &size);
-    step /= sizeof(data[0]);
-
-    for(int y = 0; y < size.height; y++, data += step )
-        for(int x = 0; x < size.width; x++ )
-            data[x] = (float)fabs(data[x]);
-@endcode
-@param arr Array header
-@param data Output pointer to the whole image origin or ROI origin if ROI is set
-@param step Output full row length in bytes
-@param roi_size Output ROI size
- */
-CVAPI(void)
-cvGetRawData(const CvArr *arr, uchar **data, int *step CV_DEFAULT(NULL),
-             CvSize *roi_size CV_DEFAULT(NULL));
-
-/** @brief Returns size of matrix or image ROI.
-
-The function returns number of rows (CvSize::height) and number of columns
-(CvSize::width) of the input matrix or image. In the case of image the size of
-ROI is returned.
-@param arr array header
- */
-CVAPI(CvSize) cvGetSize(const CvArr *arr);
-
-/** @brief Copies one array to another.
-
-The function copies selected elements from an input array to an output array:
-
-\f[\texttt{dst} (I)= \texttt{src} (I)  \quad \text{if} \quad \texttt{mask} (I)
-\ne 0.\f]
-
-If any of the passed arrays is of IplImage type, then its ROI and COI fields are
-used. Both arrays must have the same type, the same number of dimensions, and
-the same size. The function can also copy sparse arrays (mask is not supported
-in this case).
-@param src The source array
-@param dst The destination array
-@param mask Operation mask, 8-bit single channel array; specifies elements of
-the destination array to be changed
- */
-CVAPI(void)
-cvCopy(const CvArr *src, CvArr *dst, const CvArr *mask CV_DEFAULT(NULL));
-
-/** @brief Sets every element of an array to a given value.
-
-The function copies the scalar value to every selected element of the
-destination array:
-\f[\texttt{arr} (I)= \texttt{value} \quad \text{if} \quad \texttt{mask} (I)  \ne
-0\f] If array arr is of IplImage type, then is ROI used, but COI must not be
-set.
-@param arr The destination array
-@param value Fill value
-@param mask Operation mask, 8-bit single channel array; specifies elements of
-the destination array to be changed
- */
-CVAPI(void)
-cvSet(CvArr *arr, CvScalar value, const CvArr *mask CV_DEFAULT(NULL));
-
-/** @brief Clears the array.
-
-The function clears the array. In the case of dense arrays (CvMat, CvMatND or
-IplImage), cvZero(array) is equivalent to cvSet(array,cvScalarAll(0),0). In the
-case of sparse arrays all the elements are removed.
-@param arr Array to be cleared
- */
-CVAPI(void) cvSetZero(CvArr *arr);
-#define cvZero cvSetZero
-
-/** Splits a multi-channel array into the set of single-channel arrays or
-   extracts particular [color] plane */
-CVAPI(void)
-cvSplit(const CvArr *src, CvArr *dst0, CvArr *dst1, CvArr *dst2, CvArr *dst3);
-
-/** Merges a set of single-channel arrays into the single multi-channel array
-   or inserts one particular [color] plane to the array */
-CVAPI(void)
-cvMerge(const CvArr *src0, const CvArr *src1, const CvArr *src2,
-        const CvArr *src3, CvArr *dst);
-
-/** Copies several channels from input arrays to
-   certain channels of output arrays */
-CVAPI(void)
-cvMixChannels(const CvArr **src, int src_count, CvArr **dst, int dst_count,
-              const int *from_to, int pair_count);
-
-/** @brief Converts one array to another with optional linear transformation.
-
-The function has several different purposes, and thus has several different
-names. It copies one array to another with optional scaling, which is performed
-first, and/or optional type conversion, performed after:
-
-\f[\texttt{dst} (I) =  \texttt{scale} \texttt{src} (I) + ( \texttt{shift} _0,
-\texttt{shift} _1,...)\f]
-
-All the channels of multi-channel arrays are processed independently.
-
-The type of conversion is done with rounding and saturation, that is if the
-result of scaling + conversion can not be represented exactly by a value of the
-destination array element type, it is set to the nearest representable value on
-the real axis.
-@param src Source array
-@param dst Destination array
-@param scale Scale factor
-@param shift Value added to the scaled source array elements
- */
-CVAPI(void)
-cvConvertScale(const CvArr *src, CvArr *dst, double scale CV_DEFAULT(1),
-               double shift CV_DEFAULT(0));
-#define cvCvtScale cvConvertScale
-#define cvScale cvConvertScale
-#define cvConvert(src, dst) cvConvertScale((src), (dst), 1, 0)
-
-/** Performs linear transformation on every source array element,
-   stores absolute value of the result:
-   dst(x,y,c) = abs(scale*src(x,y,c)+shift).
-   destination array must have 8u type.
-   In other cases one may use cvConvertScale + cvAbsDiffS */
-CVAPI(void)
-cvConvertScaleAbs(const CvArr *src, CvArr *dst, double scale CV_DEFAULT(1),
-                  double shift CV_DEFAULT(0));
-#define cvCvtScaleAbs cvConvertScaleAbs
-
-/** checks termination criteria validity and
-   sets eps to default_eps (if it is not set),
-   max_iter to default_max_iters (if it is not set)
-*/
-CVAPI(CvTermCriteria)
-cvCheckTermCriteria(CvTermCriteria criteria, double default_eps,
-                    int default_max_iters);
-
-/****************************************************************************************\
-*                   Arithmetic, logic and comparison operations *
-\****************************************************************************************/
-
-/** dst(mask) = src1(mask) + src2(mask) */
-CVAPI(void)
-cvAdd(const CvArr *src1, const CvArr *src2, CvArr *dst,
-      const CvArr *mask CV_DEFAULT(NULL));
-
-/** dst(mask) = src(mask) + value */
-CVAPI(void)
-cvAddS(const CvArr *src, CvScalar value, CvArr *dst,
-       const CvArr *mask CV_DEFAULT(NULL));
-
-/** dst(mask) = src1(mask) - src2(mask) */
-CVAPI(void)
-cvSub(const CvArr *src1, const CvArr *src2, CvArr *dst,
-      const CvArr *mask CV_DEFAULT(NULL));
-
-/** dst(mask) = src(mask) - value = src(mask) + (-value) */
-CV_INLINE void cvSubS(const CvArr *src, CvScalar value, CvArr *dst,
-                      const CvArr *mask CV_DEFAULT(NULL)) {
-  cvAddS(src,
-         cvScalar(-value.val[0], -value.val[1], -value.val[2], -value.val[3]),
-         dst, mask);
-}
-
-/** dst(mask) = value - src(mask) */
-CVAPI(void)
-cvSubRS(const CvArr *src, CvScalar value, CvArr *dst,
-        const CvArr *mask CV_DEFAULT(NULL));
-
-/** dst(idx) = src1(idx) * src2(idx) * scale
-   (scaled element-wise multiplication of 2 arrays) */
-CVAPI(void)
-cvMul(const CvArr *src1, const CvArr *src2, CvArr *dst,
-      double scale CV_DEFAULT(1));
-
-/** element-wise division/inversion with scaling:
-    dst(idx) = src1(idx) * scale / src2(idx)
-    or dst(idx) = scale / src2(idx) if src1 == 0 */
-CVAPI(void)
-cvDiv(const CvArr *src1, const CvArr *src2, CvArr *dst,
-      double scale CV_DEFAULT(1));
-
-/** dst = src1 * scale + src2 */
-CVAPI(void)
-cvScaleAdd(const CvArr *src1, CvScalar scale, const CvArr *src2, CvArr *dst);
-#define cvAXPY(A, real_scalar, B, C)                                           \
-  cvScaleAdd(A, cvRealScalar(real_scalar), B, C)
-
-/** dst = src1 * alpha + src2 * beta + gamma */
-CVAPI(void)
-cvAddWeighted(const CvArr *src1, double alpha, const CvArr *src2, double beta,
-              double gamma, CvArr *dst);
-
-/** @brief Calculates the dot product of two arrays in Euclidean metrics.
-
-The function calculates and returns the Euclidean dot product of two arrays.
-
-\f[src1  \bullet src2 =  \sum _I ( \texttt{src1} (I)  \texttt{src2} (I))\f]
-
-In the case of multiple channel arrays, the results for all channels are
-accumulated. In particular, cvDotProduct(a,a) where a is a complex vector, will
-return \f$||\texttt{a}||^2\f$. The function can process multi-dimensional
-arrays, row by row, layer by layer, and so on.
-@param src1 The first source array
-@param src2 The second source array
- */
-CVAPI(double) cvDotProduct(const CvArr *src1, const CvArr *src2);
-
-/** dst(idx) = src1(idx) & src2(idx) */
-CVAPI(void)
-cvAnd(const CvArr *src1, const CvArr *src2, CvArr *dst,
-      const CvArr *mask CV_DEFAULT(NULL));
-
-/** dst(idx) = src(idx) & value */
-CVAPI(void)
-cvAndS(const CvArr *src, CvScalar value, CvArr *dst,
-       const CvArr *mask CV_DEFAULT(NULL));
-
-/** dst(idx) = src1(idx) | src2(idx) */
-CVAPI(void)
-cvOr(const CvArr *src1, const CvArr *src2, CvArr *dst,
-     const CvArr *mask CV_DEFAULT(NULL));
-
-/** dst(idx) = src(idx) | value */
-CVAPI(void)
-cvOrS(const CvArr *src, CvScalar value, CvArr *dst,
-      const CvArr *mask CV_DEFAULT(NULL));
-
-/** dst(idx) = src1(idx) ^ src2(idx) */
-CVAPI(void)
-cvXor(const CvArr *src1, const CvArr *src2, CvArr *dst,
-      const CvArr *mask CV_DEFAULT(NULL));
-
-/** dst(idx) = src(idx) ^ value */
-CVAPI(void)
-cvXorS(const CvArr *src, CvScalar value, CvArr *dst,
-       const CvArr *mask CV_DEFAULT(NULL));
-
-/** dst(idx) = ~src(idx) */
-CVAPI(void) cvNot(const CvArr *src, CvArr *dst);
-
-/** dst(idx) = lower(idx) <= src(idx) < upper(idx) */
-CVAPI(void)
-cvInRange(const CvArr *src, const CvArr *lower, const CvArr *upper, CvArr *dst);
-
-/** dst(idx) = lower <= src(idx) < upper */
-CVAPI(void)
-cvInRangeS(const CvArr *src, CvScalar lower, CvScalar upper, CvArr *dst);
-
-#define CV_CMP_EQ 0
-#define CV_CMP_GT 1
-#define CV_CMP_GE 2
-#define CV_CMP_LT 3
-#define CV_CMP_LE 4
-#define CV_CMP_NE 5
-
-/** The comparison operation support single-channel arrays only.
-   Destination image should be 8uC1 or 8sC1 */
-
-/** dst(idx) = src1(idx) _cmp_op_ src2(idx) */
-CVAPI(void) cvCmp(const CvArr *src1, const CvArr *src2, CvArr *dst, int cmp_op);
-
-/** dst(idx) = src1(idx) _cmp_op_ value */
-CVAPI(void) cvCmpS(const CvArr *src, double value, CvArr *dst, int cmp_op);
-
-/** dst(idx) = min(src1(idx),src2(idx)) */
-CVAPI(void) cvMin(const CvArr *src1, const CvArr *src2, CvArr *dst);
-
-/** dst(idx) = max(src1(idx),src2(idx)) */
-CVAPI(void) cvMax(const CvArr *src1, const CvArr *src2, CvArr *dst);
-
-/** dst(idx) = min(src(idx),value) */
-CVAPI(void) cvMinS(const CvArr *src, double value, CvArr *dst);
-
-/** dst(idx) = max(src(idx),value) */
-CVAPI(void) cvMaxS(const CvArr *src, double value, CvArr *dst);
-
-/** dst(x,y,c) = abs(src1(x,y,c) - src2(x,y,c)) */
-CVAPI(void) cvAbsDiff(const CvArr *src1, const CvArr *src2, CvArr *dst);
-
-/** dst(x,y,c) = abs(src(x,y,c) - value(c)) */
-CVAPI(void) cvAbsDiffS(const CvArr *src, CvArr *dst, CvScalar value);
-#define cvAbs(src, dst) cvAbsDiffS((src), (dst), cvScalarAll(0))
-
-/****************************************************************************************\
-*                                Math operations *
-\****************************************************************************************/
-
-/** Does cartesian->polar coordinates conversion.
-   Either of output components (magnitude or angle) is optional */
-CVAPI(void)
-cvCartToPolar(const CvArr *x, const CvArr *y, CvArr *magnitude,
-              CvArr *angle CV_DEFAULT(NULL),
-              int angle_in_degrees CV_DEFAULT(0));
-
-/** Does polar->cartesian coordinates conversion.
-   Either of output components (magnitude or angle) is optional.
-   If magnitude is missing it is assumed to be all 1's */
-CVAPI(void)
-cvPolarToCart(const CvArr *magnitude, const CvArr *angle, CvArr *x, CvArr *y,
-              int angle_in_degrees CV_DEFAULT(0));
-
-/** Does powering: dst(idx) = src(idx)^power */
-CVAPI(void) cvPow(const CvArr *src, CvArr *dst, double power);
-
-/** Does exponention: dst(idx) = exp(src(idx)).
-   Overflow is not handled yet. Underflow is handled.
-   Maximal relative error is ~7e-6 for single-precision input */
-CVAPI(void) cvExp(const CvArr *src, CvArr *dst);
-
-/** Calculates natural logarithms: dst(idx) = log(abs(src(idx))).
-   Logarithm of 0 gives large negative number(~-700)
-   Maximal relative error is ~3e-7 for single-precision output
-*/
-CVAPI(void) cvLog(const CvArr *src, CvArr *dst);
-
-/** Fast arctangent calculation */
-CVAPI(float) cvFastArctan(float y, float x);
-
-/** Fast cubic root calculation */
-CVAPI(float) cvCbrt(float value);
-
-#define CV_CHECK_RANGE 1
-#define CV_CHECK_QUIET 2
-/** Checks array values for NaNs, Infs or simply for too large numbers
-   (if CV_CHECK_RANGE is set). If CV_CHECK_QUIET is set,
-   no runtime errors is raised (function returns zero value in case of "bad"
-   values). Otherwise cvError is called */
-CVAPI(int)
-cvCheckArr(const CvArr *arr, int flags CV_DEFAULT(0),
-           double min_val CV_DEFAULT(0), double max_val CV_DEFAULT(0));
-#define cvCheckArray cvCheckArr
-
-#define CV_RAND_UNI 0
-#define CV_RAND_NORMAL 1
-
-/** @brief Fills an array with random numbers and updates the RNG state.
-
-The function fills the destination array with uniformly or normally distributed
-random numbers.
-@param rng CvRNG state initialized by cvRNG
-@param arr The destination array
-@param dist_type Distribution type
-> -   **CV_RAND_UNI** uniform distribution
-> -   **CV_RAND_NORMAL** normal or Gaussian distribution
-@param param1 The first parameter of the distribution. In the case of a uniform
-distribution it is the inclusive lower boundary of the random numbers range. In
-the case of a normal distribution it is the mean value of the random numbers.
-@param param2 The second parameter of the distribution. In the case of a uniform
-distribution it is the exclusive upper boundary of the random numbers range. In
-the case of a normal distribution it is the standard deviation of the random
-numbers.
-@sa randu, randn, RNG::fill.
- */
-CVAPI(void)
-cvRandArr(CvRNG *rng, CvArr *arr, int dist_type, CvScalar param1,
-          CvScalar param2);
-
-CVAPI(void)
-cvRandShuffle(CvArr *mat, CvRNG *rng, double iter_factor CV_DEFAULT(1.));
-
-#define CV_SORT_EVERY_ROW 0
-#define CV_SORT_EVERY_COLUMN 1
-#define CV_SORT_ASCENDING 0
-#define CV_SORT_DESCENDING 16
-
-CVAPI(void)
-cvSort(const CvArr *src, CvArr *dst CV_DEFAULT(NULL),
-       CvArr *idxmat CV_DEFAULT(NULL), int flags CV_DEFAULT(0));
-
-/** Finds real roots of a cubic equation */
-CVAPI(int) cvSolveCubic(const CvMat *coeffs, CvMat *roots);
-
-/** Finds all real and complex roots of a polynomial equation */
-CVAPI(void)
-cvSolvePoly(const CvMat *coeffs, CvMat *roots2, int maxiter CV_DEFAULT(20),
-            int fig CV_DEFAULT(100));
-
-/****************************************************************************************\
-*                                Matrix operations *
-\****************************************************************************************/
-
-/** @brief Calculates the cross product of two 3D vectors.
-
-The function calculates the cross product of two 3D vectors:
-\f[\texttt{dst} =  \texttt{src1} \times \texttt{src2}\f]
-or:
-\f[\begin{array}{l} \texttt{dst} _1 =  \texttt{src1} _2  \texttt{src2} _3 -
-\texttt{src1} _3  \texttt{src2} _2 \\ \texttt{dst} _2 =  \texttt{src1} _3
-\texttt{src2} _1 -  \texttt{src1} _1  \texttt{src2} _3 \\ \texttt{dst} _3 =
-\texttt{src1} _1  \texttt{src2} _2 -  \texttt{src1} _2  \texttt{src2} _1
-\end{array}\f]
-@param src1 The first source vector
-@param src2 The second source vector
-@param dst The destination vector
- */
-CVAPI(void) cvCrossProduct(const CvArr *src1, const CvArr *src2, CvArr *dst);
-
-/** Matrix transform: dst = A*B + C, C is optional */
-#define cvMatMulAdd(src1, src2, src3, dst)                                     \
-  cvGEMM((src1), (src2), 1., (src3), 1., (dst), 0)
-#define cvMatMul(src1, src2, dst) cvMatMulAdd((src1), (src2), NULL, (dst))
-
-#define CV_GEMM_A_T 1
-#define CV_GEMM_B_T 2
-#define CV_GEMM_C_T 4
-/** Extended matrix transform:
-   dst = alpha*op(A)*op(B) + beta*op(C), where op(X) is X or X^T */
-CVAPI(void)
-cvGEMM(const CvArr *src1, const CvArr *src2, double alpha, const CvArr *src3,
-       double beta, CvArr *dst, int tABC CV_DEFAULT(0));
-#define cvMatMulAddEx cvGEMM
-
-/** Transforms each element of source array and stores
-   resultant vectors in destination array */
-CVAPI(void)
-cvTransform(const CvArr *src, CvArr *dst, const CvMat *transmat,
-            const CvMat *shiftvec CV_DEFAULT(NULL));
-#define cvMatMulAddS cvTransform
-
-/** Does perspective transform on every element of input array */
-CVAPI(void)
-cvPerspectiveTransform(const CvArr *src, CvArr *dst, const CvMat *mat);
-
-/** Calculates (A-delta)*(A-delta)^T (order=0) or (A-delta)^T*(A-delta)
- * (order=1) */
-CVAPI(void)
-cvMulTransposed(const CvArr *src, CvArr *dst, int order,
-                const CvArr *delta CV_DEFAULT(NULL),
-                double scale CV_DEFAULT(1.));
-
-/** Transposes matrix. Square matrices can be transposed in-place */
-CVAPI(void) cvTranspose(const CvArr *src, CvArr *dst);
-#define cvT cvTranspose
-
-/** Completes the symmetric matrix from the lower (LtoR=0) or from the upper
- * (LtoR!=0) part */
-CVAPI(void) cvCompleteSymm(CvMat *matrix, int LtoR CV_DEFAULT(0));
-
-/** Mirror array data around horizontal (flip=0),
-   vertical (flip=1) or both(flip=-1) axises:
-   cvFlip(src) flips images vertically and sequences horizontally (inplace) */
-CVAPI(void)
-cvFlip(const CvArr *src, CvArr *dst CV_DEFAULT(NULL),
-       int flip_mode CV_DEFAULT(0));
-#define cvMirror cvFlip
-
-#define CV_SVD_MODIFY_A 1
-#define CV_SVD_U_T 2
-#define CV_SVD_V_T 4
-
-/** Performs Singular Value Decomposition of a matrix */
-CVAPI(void)
-cvSVD(CvArr *A, CvArr *W, CvArr *U CV_DEFAULT(NULL), CvArr *V CV_DEFAULT(NULL),
-      int flags CV_DEFAULT(0));
-
-/** Performs Singular Value Back Substitution (solves A*X = B):
-   flags must be the same as in cvSVD */
-CVAPI(void)
-cvSVBkSb(const CvArr *W, const CvArr *U, const CvArr *V, const CvArr *B,
-         CvArr *X, int flags);
-
-#define CV_LU 0
-#define CV_SVD 1
-#define CV_SVD_SYM 2
-#define CV_CHOLESKY 3
-#define CV_QR 4
-#define CV_NORMAL 16
-
-/** Inverts matrix */
-CVAPI(double)
-cvInvert(const CvArr *src, CvArr *dst, int method CV_DEFAULT(CV_LU));
-#define cvInv cvInvert
-
-/** Solves linear system (src1)*(dst) = (src2)
-   (returns 0 if src1 is a singular and CV_LU method is used) */
-CVAPI(int)
-cvSolve(const CvArr *src1, const CvArr *src2, CvArr *dst,
-        int method CV_DEFAULT(CV_LU));
-
-/** Calculates determinant of input matrix */
-CVAPI(double) cvDet(const CvArr *mat);
-
-/** Calculates trace of the matrix (sum of elements on the main diagonal) */
-CVAPI(CvScalar) cvTrace(const CvArr *mat);
-
-/** Finds eigen values and vectors of a symmetric matrix */
-CVAPI(void)
-cvEigenVV(CvArr *mat, CvArr *evects, CvArr *evals, double eps CV_DEFAULT(0),
-          int lowindex CV_DEFAULT(-1), int highindex CV_DEFAULT(-1));
-
-///* Finds selected eigen values and vectors of a symmetric matrix */
-// CVAPI(void)  cvSelectedEigenVV( CvArr* mat, CvArr* evects, CvArr* evals,
-//                                 int lowindex, int highindex );
-
-/** Makes an identity matrix (mat_ij = i == j) */
-CVAPI(void)
-cvSetIdentity(CvArr *mat, CvScalar value CV_DEFAULT(cvRealScalar(1)));
-
-/** Fills matrix with given range of numbers */
-CVAPI(CvArr *) cvRange(CvArr *mat, double start, double end);
-
-/**   @anchor core_c_CovarFlags
-@name Flags for cvCalcCovarMatrix
-@see cvCalcCovarMatrix
-  @{
-*/
-
-/** flag for cvCalcCovarMatrix, transpose([v1-avg, v2-avg,...]) *
- * [v1-avg,v2-avg,...] */
-#define CV_COVAR_SCRAMBLED 0
-
-/** flag for cvCalcCovarMatrix, [v1-avg, v2-avg,...] *
- * transpose([v1-avg,v2-avg,...]) */
-#define CV_COVAR_NORMAL 1
-
-/** flag for cvCalcCovarMatrix, do not calc average (i.e. mean vector) - use the
-   input vector instead (useful for calculating covariance matrix by parts) */
-#define CV_COVAR_USE_AVG 2
-
-/** flag for cvCalcCovarMatrix, scale the covariance matrix coefficients by
- * number of the vectors */
-#define CV_COVAR_SCALE 4
-
-/** flag for cvCalcCovarMatrix, all the input vectors are stored in a single
- * matrix, as its rows */
-#define CV_COVAR_ROWS 8
-
-/** flag for cvCalcCovarMatrix, all the input vectors are stored in a single
- * matrix, as its columns */
-#define CV_COVAR_COLS 16
-
-/** @} */
-
-/** Calculates covariation matrix for a set of vectors
-@see @ref core_c_CovarFlags "flags"
-*/
-CVAPI(void)
-cvCalcCovarMatrix(const CvArr **vects, int count, CvArr *cov_mat, CvArr *avg,
-                  int flags);
-
-#define CV_PCA_DATA_AS_ROW 0
-#define CV_PCA_DATA_AS_COL 1
-#define CV_PCA_USE_AVG 2
-CVAPI(void)
-cvCalcPCA(const CvArr *data, CvArr *mean, CvArr *eigenvals, CvArr *eigenvects,
-          int flags);
-
-CVAPI(void)
-cvProjectPCA(const CvArr *data, const CvArr *mean, const CvArr *eigenvects,
-             CvArr *result);
-
-CVAPI(void)
-cvBackProjectPCA(const CvArr *proj, const CvArr *mean, const CvArr *eigenvects,
-                 CvArr *result);
-
-/** Calculates Mahalanobis(weighted) distance */
-CVAPI(double)
-cvMahalanobis(const CvArr *vec1, const CvArr *vec2, const CvArr *mat);
-#define cvMahalonobis cvMahalanobis
-
-/****************************************************************************************\
-*                                    Array Statistics *
-\****************************************************************************************/
-
-/** Finds sum of array elements */
-CVAPI(CvScalar) cvSum(const CvArr *arr);
-
-/** Calculates number of non-zero pixels */
-CVAPI(int) cvCountNonZero(const CvArr *arr);
-
-/** Calculates mean value of array elements */
-CVAPI(CvScalar) cvAvg(const CvArr *arr, const CvArr *mask CV_DEFAULT(NULL));
-
-/** Calculates mean and standard deviation of pixel values */
-CVAPI(void)
-cvAvgSdv(const CvArr *arr, CvScalar *mean, CvScalar *std_dev,
-         const CvArr *mask CV_DEFAULT(NULL));
-
-/** Finds global minimum, maximum and their positions */
-CVAPI(void)
-cvMinMaxLoc(const CvArr *arr, double *min_val, double *max_val,
-            CvPoint *min_loc CV_DEFAULT(NULL),
-            CvPoint *max_loc CV_DEFAULT(NULL),
-            const CvArr *mask CV_DEFAULT(NULL));
-
-/** @anchor core_c_NormFlags
-  @name Flags for cvNorm and cvNormalize
-  @{
-*/
-#define CV_C 1
-#define CV_L1 2
-#define CV_L2 4
-#define CV_NORM_MASK 7
-#define CV_RELATIVE 8
-#define CV_DIFF 16
-#define CV_MINMAX 32
-
-#define CV_DIFF_C (CV_DIFF | CV_C)
-#define CV_DIFF_L1 (CV_DIFF | CV_L1)
-#define CV_DIFF_L2 (CV_DIFF | CV_L2)
-#define CV_RELATIVE_C (CV_RELATIVE | CV_C)
-#define CV_RELATIVE_L1 (CV_RELATIVE | CV_L1)
-#define CV_RELATIVE_L2 (CV_RELATIVE | CV_L2)
-/** @} */
-
-/** Finds norm, difference norm or relative difference norm for an array (or two
-arrays)
-@see ref core_c_NormFlags "flags"
-*/
-CVAPI(double)
-cvNorm(const CvArr *arr1, const CvArr *arr2 CV_DEFAULT(NULL),
-       int norm_type CV_DEFAULT(CV_L2), const CvArr *mask CV_DEFAULT(NULL));
-
-/** @see ref core_c_NormFlags "flags" */
-CVAPI(void)
-cvNormalize(const CvArr *src, CvArr *dst, double a CV_DEFAULT(1.),
-            double b CV_DEFAULT(0.), int norm_type CV_DEFAULT(CV_L2),
-            const CvArr *mask CV_DEFAULT(NULL));
-
-/** @anchor core_c_ReduceFlags
-  @name Flags for cvReduce
-  @{
-*/
-#define CV_REDUCE_SUM 0
-#define CV_REDUCE_AVG 1
-#define CV_REDUCE_MAX 2
-#define CV_REDUCE_MIN 3
-/** @} */
-
-/** @see @ref core_c_ReduceFlags "flags" */
-CVAPI(void)
-cvReduce(const CvArr *src, CvArr *dst, int dim CV_DEFAULT(-1),
-         int op CV_DEFAULT(CV_REDUCE_SUM));
-
-/****************************************************************************************\
-*                      Discrete Linear Transforms and Related Functions *
-\****************************************************************************************/
-
-/** @anchor core_c_DftFlags
-  @name Flags for cvDFT, cvDCT and cvMulSpectrums
-  @{
-  */
-#define CV_DXT_FORWARD 0
-#define CV_DXT_INVERSE 1
-#define CV_DXT_SCALE 2 /**< divide result by size of array */
-#define CV_DXT_INV_SCALE (CV_DXT_INVERSE + CV_DXT_SCALE)
-#define CV_DXT_INVERSE_SCALE CV_DXT_INV_SCALE
-#define CV_DXT_ROWS 4 /**< transform each row individually */
-#define CV_DXT_MUL_CONJ                                                        \
-  8 /**< conjugate the second argument of cvMulSpectrums */
-/** @} */
-
-/** Discrete Fourier Transform:
-    complex->complex,
-    real->ccs (forward),
-    ccs->real (inverse)
-@see core_c_DftFlags "flags"
-*/
-CVAPI(void)
-cvDFT(const CvArr *src, CvArr *dst, int flags, int nonzero_rows CV_DEFAULT(0));
-#define cvFFT cvDFT
-
-/** Multiply results of DFTs: DFT(X)*DFT(Y) or DFT(X)*conj(DFT(Y))
-@see core_c_DftFlags "flags"
-*/
-CVAPI(void)
-cvMulSpectrums(const CvArr *src1, const CvArr *src2, CvArr *dst, int flags);
-
-/** Finds optimal DFT vector size >= size0 */
-CVAPI(int) cvGetOptimalDFTSize(int size0);
-
-/** Discrete Cosine Transform
-@see core_c_DftFlags "flags"
-*/
-CVAPI(void) cvDCT(const CvArr *src, CvArr *dst, int flags);
-
-/****************************************************************************************\
-*                              Dynamic data structures *
-\****************************************************************************************/
-
-/** Calculates length of sequence slice (with support of negative indices). */
-CVAPI(int) cvSliceLength(CvSlice slice, const CvSeq *seq);
-
-/** Creates new memory storage.
-   block_size == 0 means that default,
-   somewhat optimal size, is used (currently, it is 64K) */
-CVAPI(CvMemStorage *) cvCreateMemStorage(int block_size CV_DEFAULT(0));
-
-/** Creates a memory storage that will borrow memory blocks from parent storage
- */
-CVAPI(CvMemStorage *) cvCreateChildMemStorage(CvMemStorage *parent);
-
-/** Releases memory storage. All the children of a parent must be released
-   before the parent. A child storage returns all the blocks to parent when it
-   is released */
-CVAPI(void) cvReleaseMemStorage(CvMemStorage **storage);
-
-/** Clears memory storage. This is the only way(!!!) (besides
-   cvRestoreMemStoragePos) to reuse memory allocated for the storage -
-   cvClearSeq,cvClearSet ... do not free any memory. A child storage returns all
-   the blocks to the parent when it is cleared */
-CVAPI(void) cvClearMemStorage(CvMemStorage *storage);
-
-/** Remember a storage "free memory" position */
-CVAPI(void)
-cvSaveMemStoragePos(const CvMemStorage *storage, CvMemStoragePos *pos);
-
-/** Restore a storage "free memory" position */
-CVAPI(void) cvRestoreMemStoragePos(CvMemStorage *storage, CvMemStoragePos *pos);
-
-/** Allocates continuous buffer of the specified size in the storage */
-CVAPI(void *) cvMemStorageAlloc(CvMemStorage *storage, size_t size);
-
-/** Allocates string in memory storage */
-// CVAPI(CvString) cvMemStorageAllocString( CvMemStorage* storage, const char*
-// ptr,
-//                                          int len CV_DEFAULT(-1) );
-
-/** Creates new empty sequence that will reside in the specified storage */
-CVAPI(CvSeq *)
-cvCreateSeq(int seq_flags, size_t header_size, size_t elem_size,
-            CvMemStorage *storage);
-
-/** Changes default size (granularity) of sequence blocks.
-   The default size is ~1Kbyte */
-CVAPI(void) cvSetSeqBlockSize(CvSeq *seq, int delta_elems);
-
-/** Adds new element to the end of sequence. Returns pointer to the element */
-CVAPI(schar *) cvSeqPush(CvSeq *seq, const void *element CV_DEFAULT(NULL));
-
-/** Adds new element to the beginning of sequence. Returns pointer to it */
-CVAPI(schar *) cvSeqPushFront(CvSeq *seq, const void *element CV_DEFAULT(NULL));
-
-/** Removes the last element from sequence and optionally saves it */
-CVAPI(void) cvSeqPop(CvSeq *seq, void *element CV_DEFAULT(NULL));
-
-/** Removes the first element from sequence and optioanally saves it */
-CVAPI(void) cvSeqPopFront(CvSeq *seq, void *element CV_DEFAULT(NULL));
-
-#define CV_FRONT 1
-#define CV_BACK 0
-/** Adds several new elements to the end of sequence */
-CVAPI(void)
-cvSeqPushMulti(CvSeq *seq, const void *elements, int count,
-               int in_front CV_DEFAULT(0));
-
-/** Removes several elements from the end of sequence and optionally saves them
- */
-CVAPI(void)
-cvSeqPopMulti(CvSeq *seq, void *elements, int count,
-              int in_front CV_DEFAULT(0));
-
-/** Inserts a new element in the middle of sequence.
-   cvSeqInsert(seq,0,elem) == cvSeqPushFront(seq,elem) */
-CVAPI(schar *)
-cvSeqInsert(CvSeq *seq, int before_index, const void *element CV_DEFAULT(NULL));
-
-/** Removes specified sequence element */
-CVAPI(void) cvSeqRemove(CvSeq *seq, int index);
-
-/** Removes all the elements from the sequence. The freed memory
-   can be reused later only by the same sequence unless cvClearMemStorage
-   or cvRestoreMemStoragePos is called */
-CVAPI(void) cvClearSeq(CvSeq *seq);
-
-/** Retrieves pointer to specified sequence element.
-   Negative indices are supported and mean counting from the end
-   (e.g -1 means the last sequence element) */
-CVAPI(schar *) cvGetSeqElem(const CvSeq *seq, int index);
-
-/** Calculates index of the specified sequence element.
-   Returns -1 if element does not belong to the sequence */
-CVAPI(int)
-cvSeqElemIdx(const CvSeq *seq, const void *element,
-             CvSeqBlock **block CV_DEFAULT(NULL));
-
-/** Initializes sequence writer. The new elements will be added to the end of
- * sequence */
-CVAPI(void) cvStartAppendToSeq(CvSeq *seq, CvSeqWriter *writer);
-
-/** Combination of cvCreateSeq and cvStartAppendToSeq */
-CVAPI(void)
-cvStartWriteSeq(int seq_flags, int header_size, int elem_size,
-                CvMemStorage *storage, CvSeqWriter *writer);
-
-/** Closes sequence writer, updates sequence header and returns pointer
-   to the resultant sequence
-   (which may be useful if the sequence was created using cvStartWriteSeq))
-*/
-CVAPI(CvSeq *) cvEndWriteSeq(CvSeqWriter *writer);
-
-/** Updates sequence header. May be useful to get access to some of previously
-   written elements via cvGetSeqElem or sequence reader */
-CVAPI(void) cvFlushSeqWriter(CvSeqWriter *writer);
-
-/** Initializes sequence reader.
-   The sequence can be read in forward or backward direction */
-CVAPI(void)
-cvStartReadSeq(const CvSeq *seq, CvSeqReader *reader,
-               int reverse CV_DEFAULT(0));
-
-/** Returns current sequence reader position (currently observed sequence
- * element) */
-CVAPI(int) cvGetSeqReaderPos(CvSeqReader *reader);
-
-/** Changes sequence reader position. It may seek to an absolute or
-   to relative to the current position */
-CVAPI(void)
-cvSetSeqReaderPos(CvSeqReader *reader, int index,
-                  int is_relative CV_DEFAULT(0));
-
-/** Copies sequence content to a continuous piece of memory */
-CVAPI(void *)
-cvCvtSeqToArray(const CvSeq *seq, void *elements,
-                CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ));
-
-/** Creates sequence header for array.
-   After that all the operations on sequences that do not alter the content
-   can be applied to the resultant sequence */
-CVAPI(CvSeq *)
-cvMakeSeqHeaderForArray(int seq_type, int header_size, int elem_size,
-                        void *elements, int total, CvSeq *seq,
-                        CvSeqBlock *block);
-
-/** Extracts sequence slice (with or without copying sequence elements) */
-CVAPI(CvSeq *)
-cvSeqSlice(const CvSeq *seq, CvSlice slice,
-           CvMemStorage *storage CV_DEFAULT(NULL), int copy_data CV_DEFAULT(0));
-
-CV_INLINE CvSeq *cvCloneSeq(const CvSeq *seq,
-                            CvMemStorage *storage CV_DEFAULT(NULL)) {
-  return cvSeqSlice(seq, CV_WHOLE_SEQ, storage, 1);
-}
-
-/** Removes sequence slice */
-CVAPI(void) cvSeqRemoveSlice(CvSeq *seq, CvSlice slice);
-
-/** Inserts a sequence or array into another sequence */
-CVAPI(void)
-cvSeqInsertSlice(CvSeq *seq, int before_index, const CvArr *from_arr);
-
-/** a < b ? -1 : a > b ? 1 : 0 */
-typedef int(CV_CDECL *CvCmpFunc)(const void *a, const void *b, void *userdata);
-
-/** Sorts sequence in-place given element comparison function */
-CVAPI(void)
-cvSeqSort(CvSeq *seq, CvCmpFunc func, void *userdata CV_DEFAULT(NULL));
-
-/** Finds element in a [sorted] sequence */
-CVAPI(schar *)
-cvSeqSearch(CvSeq *seq, const void *elem, CvCmpFunc func, int is_sorted,
-            int *elem_idx, void *userdata CV_DEFAULT(NULL));
-
-/** Reverses order of sequence elements in-place */
-CVAPI(void) cvSeqInvert(CvSeq *seq);
-
-/** Splits sequence into one or more equivalence classes using the specified
- * criteria */
-CVAPI(int)
-cvSeqPartition(const CvSeq *seq, CvMemStorage *storage, CvSeq **labels,
-               CvCmpFunc is_equal, void *userdata);
-
-/************ Internal sequence functions ************/
-CVAPI(void) cvChangeSeqBlock(void *reader, int direction);
-CVAPI(void) cvCreateSeqBlock(CvSeqWriter *writer);
-
-/** Creates a new set */
-CVAPI(CvSet *)
-cvCreateSet(int set_flags, int header_size, int elem_size,
-            CvMemStorage *storage);
-
-/** Adds new element to the set and returns pointer to it */
-CVAPI(int)
-cvSetAdd(CvSet *set_header, CvSetElem *elem CV_DEFAULT(NULL),
-         CvSetElem **inserted_elem CV_DEFAULT(NULL));
-
-/** Fast variant of cvSetAdd */
-CV_INLINE CvSetElem *cvSetNew(CvSet *set_header) {
-  CvSetElem *elem = set_header->free_elems;
-  if (elem) {
-    set_header->free_elems = elem->next_free;
-    elem->flags = elem->flags & CV_SET_ELEM_IDX_MASK;
-    set_header->active_count++;
-  } else
-    cvSetAdd(set_header, NULL, &elem);
-  return elem;
-}
-
-/** Removes set element given its pointer */
-CV_INLINE void cvSetRemoveByPtr(CvSet *set_header, void *elem) {
-  CvSetElem *_elem = (CvSetElem *)elem;
-  assert(_elem->flags >=
-         0 /*&& (elem->flags & CV_SET_ELEM_IDX_MASK) < set_header->total*/);
-  _elem->next_free = set_header->free_elems;
-  _elem->flags = (_elem->flags & CV_SET_ELEM_IDX_MASK) | CV_SET_ELEM_FREE_FLAG;
-  set_header->free_elems = _elem;
-  set_header->active_count--;
-}
-
-/** Removes element from the set by its index  */
-CVAPI(void) cvSetRemove(CvSet *set_header, int index);
-
-/** Returns a set element by index. If the element doesn't belong to the set,
-   NULL is returned */
-CV_INLINE CvSetElem *cvGetSetElem(const CvSet *set_header, int idx) {
-  CvSetElem *elem = (CvSetElem *)(void *)cvGetSeqElem((CvSeq *)set_header, idx);
-  return elem && CV_IS_SET_ELEM(elem) ? elem : 0;
-}
-
-/** Removes all the elements from the set */
-CVAPI(void) cvClearSet(CvSet *set_header);
-
-/** Creates new graph */
-CVAPI(CvGraph *)
-cvCreateGraph(int graph_flags, int header_size, int vtx_size, int edge_size,
-              CvMemStorage *storage);
-
-/** Adds new vertex to the graph */
-CVAPI(int)
-cvGraphAddVtx(CvGraph *graph, const CvGraphVtx *vtx CV_DEFAULT(NULL),
-              CvGraphVtx **inserted_vtx CV_DEFAULT(NULL));
-
-/** Removes vertex from the graph together with all incident edges */
-CVAPI(int) cvGraphRemoveVtx(CvGraph *graph, int index);
-CVAPI(int) cvGraphRemoveVtxByPtr(CvGraph *graph, CvGraphVtx *vtx);
-
-/** Link two vertices specified by indices or pointers if they
-   are not connected or return pointer to already existing edge
-   connecting the vertices.
-   Functions return 1 if a new edge was created, 0 otherwise */
-CVAPI(int)
-cvGraphAddEdge(CvGraph *graph, int start_idx, int end_idx,
-               const CvGraphEdge *edge CV_DEFAULT(NULL),
-               CvGraphEdge **inserted_edge CV_DEFAULT(NULL));
-
-CVAPI(int)
-cvGraphAddEdgeByPtr(CvGraph *graph, CvGraphVtx *start_vtx, CvGraphVtx *end_vtx,
-                    const CvGraphEdge *edge CV_DEFAULT(NULL),
-                    CvGraphEdge **inserted_edge CV_DEFAULT(NULL));
-
-/** Remove edge connecting two vertices */
-CVAPI(void) cvGraphRemoveEdge(CvGraph *graph, int start_idx, int end_idx);
-CVAPI(void)
-cvGraphRemoveEdgeByPtr(CvGraph *graph, CvGraphVtx *start_vtx,
-                       CvGraphVtx *end_vtx);
-
-/** Find edge connecting two vertices */
-CVAPI(CvGraphEdge *)
-cvFindGraphEdge(const CvGraph *graph, int start_idx, int end_idx);
-CVAPI(CvGraphEdge *)
-cvFindGraphEdgeByPtr(const CvGraph *graph, const CvGraphVtx *start_vtx,
-                     const CvGraphVtx *end_vtx);
-#define cvGraphFindEdge cvFindGraphEdge
-#define cvGraphFindEdgeByPtr cvFindGraphEdgeByPtr
-
-/** Remove all vertices and edges from the graph */
-CVAPI(void) cvClearGraph(CvGraph *graph);
-
-/** Count number of edges incident to the vertex */
-CVAPI(int) cvGraphVtxDegree(const CvGraph *graph, int vtx_idx);
-CVAPI(int) cvGraphVtxDegreeByPtr(const CvGraph *graph, const CvGraphVtx *vtx);
-
-/** Retrieves graph vertex by given index */
-#define cvGetGraphVtx(graph, idx)                                              \
-  (CvGraphVtx *)cvGetSetElem((CvSet *)(graph), (idx))
-
-/** Retrieves index of a graph vertex given its pointer */
-#define cvGraphVtxIdx(graph, vtx) ((vtx)->flags & CV_SET_ELEM_IDX_MASK)
-
-/** Retrieves index of a graph edge given its pointer */
-#define cvGraphEdgeIdx(graph, edge) ((edge)->flags & CV_SET_ELEM_IDX_MASK)
-
-#define cvGraphGetVtxCount(graph) ((graph)->active_count)
-#define cvGraphGetEdgeCount(graph) ((graph)->edges->active_count)
-
-#define CV_GRAPH_VERTEX 1
-#define CV_GRAPH_TREE_EDGE 2
-#define CV_GRAPH_BACK_EDGE 4
-#define CV_GRAPH_FORWARD_EDGE 8
-#define CV_GRAPH_CROSS_EDGE 16
-#define CV_GRAPH_ANY_EDGE 30
-#define CV_GRAPH_NEW_TREE 32
-#define CV_GRAPH_BACKTRACKING 64
-#define CV_GRAPH_OVER -1
-
-#define CV_GRAPH_ALL_ITEMS -1
-
-/** flags for graph vertices and edges */
-#define CV_GRAPH_ITEM_VISITED_FLAG (1 << 30)
-#define CV_IS_GRAPH_VERTEX_VISITED(vtx)                                        \
-  (((CvGraphVtx *)(vtx))->flags & CV_GRAPH_ITEM_VISITED_FLAG)
-#define CV_IS_GRAPH_EDGE_VISITED(edge)                                         \
-  (((CvGraphEdge *)(edge))->flags & CV_GRAPH_ITEM_VISITED_FLAG)
-#define CV_GRAPH_SEARCH_TREE_NODE_FLAG (1 << 29)
-#define CV_GRAPH_FORWARD_EDGE_FLAG (1 << 28)
-
-typedef struct CvGraphScanner {
-  CvGraphVtx *vtx;   /* current graph vertex (or current edge origin) */
-  CvGraphVtx *dst;   /* current graph edge destination vertex */
-  CvGraphEdge *edge; /* current edge */
-
-  CvGraph *graph; /* the graph */
-  CvSeq *stack;   /* the graph vertex stack */
-  int index;      /* the lower bound of certainly visited vertices */
-  int mask;       /* event mask */
-} CvGraphScanner;
-
-/** Creates new graph scanner. */
-CVAPI(CvGraphScanner *)
-cvCreateGraphScanner(CvGraph *graph, CvGraphVtx *vtx CV_DEFAULT(NULL),
-                     int mask CV_DEFAULT(CV_GRAPH_ALL_ITEMS));
-
-/** Releases graph scanner. */
-CVAPI(void) cvReleaseGraphScanner(CvGraphScanner **scanner);
-
-/** Get next graph element */
-CVAPI(int) cvNextGraphItem(CvGraphScanner *scanner);
-
-/** Creates a copy of graph */
-CVAPI(CvGraph *) cvCloneGraph(const CvGraph *graph, CvMemStorage *storage);
-
-/** Does look-up transformation. Elements of the source array
-   (that should be 8uC1 or 8sC1) are used as indexes in lutarr 256-element table
- */
-CVAPI(void) cvLUT(const CvArr *src, CvArr *dst, const CvArr *lut);
-
-/******************* Iteration through the sequence tree *****************/
-typedef struct CvTreeNodeIterator {
-  const void *node;
-  int level;
-  int max_level;
-} CvTreeNodeIterator;
-
-CVAPI(void)
-cvInitTreeNodeIterator(CvTreeNodeIterator *tree_iterator, const void *first,
-                       int max_level);
-CVAPI(void *) cvNextTreeNode(CvTreeNodeIterator *tree_iterator);
-CVAPI(void *) cvPrevTreeNode(CvTreeNodeIterator *tree_iterator);
-
-/** Inserts sequence into tree with specified "parent" sequence.
-   If parent is equal to frame (e.g. the most external contour),
-   then added contour will have null pointer to parent. */
-CVAPI(void) cvInsertNodeIntoTree(void *node, void *parent, void *frame);
-
-/** Removes contour from tree (together with the contour children). */
-CVAPI(void) cvRemoveNodeFromTree(void *node, void *frame);
-
-/** Gathers pointers to all the sequences,
-   accessible from the `first`, to the single sequence */
-CVAPI(CvSeq *)
-cvTreeToNodeSeq(const void *first, int header_size, CvMemStorage *storage);
-
-/** The function implements the K-means algorithm for clustering an array of
-   sample vectors in a specified number of classes */
-#define CV_KMEANS_USE_INITIAL_LABELS 1
-CVAPI(int)
-cvKMeans2(const CvArr *samples, int cluster_count, CvArr *labels,
-          CvTermCriteria termcrit, int attempts CV_DEFAULT(1),
-          CvRNG *rng CV_DEFAULT(0), int flags CV_DEFAULT(0),
-          CvArr *_centers CV_DEFAULT(0), double *compactness CV_DEFAULT(0));
-
-/****************************************************************************************\
-*                                    System functions *
-\****************************************************************************************/
-
-/** Loads optimized functions from IPP, MKL etc. or switches back to pure C code
- */
-CVAPI(int) cvUseOptimized(int on_off);
-
-typedef IplImage *(CV_STDCALL *Cv_iplCreateImageHeader)(int, int, int, char *,
-                                                        char *, int, int, int,
-                                                        int, int, IplROI *,
-                                                        IplImage *, void *,
-                                                        IplTileInfo *);
-typedef void(CV_STDCALL *Cv_iplAllocateImageData)(IplImage *, int, int);
-typedef void(CV_STDCALL *Cv_iplDeallocate)(IplImage *, int);
-typedef IplROI *(CV_STDCALL *Cv_iplCreateROI)(int, int, int, int, int);
-typedef IplImage *(CV_STDCALL *Cv_iplCloneImage)(const IplImage *);
-
-/** @brief Makes OpenCV use IPL functions for allocating IplImage and IplROI
-structures.
-
-Normally, the function is not called directly. Instead, a simple macro
-CV_TURN_ON_IPL_COMPATIBILITY() is used that calls cvSetIPLAllocators and passes
-there pointers to IPL allocation functions. :
-@code
-    ...
-    CV_TURN_ON_IPL_COMPATIBILITY()
-    ...
-@endcode
-@param create_header pointer to a function, creating IPL image header.
-@param allocate_data pointer to a function, allocating IPL image data.
-@param deallocate pointer to a function, deallocating IPL image.
-@param create_roi pointer to a function, creating IPL image ROI (i.e. Region of
-Interest).
-@param clone_image pointer to a function, cloning an IPL image.
- */
-CVAPI(void)
-cvSetIPLAllocators(Cv_iplCreateImageHeader create_header,
-                   Cv_iplAllocateImageData allocate_data,
-                   Cv_iplDeallocate deallocate, Cv_iplCreateROI create_roi,
-                   Cv_iplCloneImage clone_image);
-
-#define CV_TURN_ON_IPL_COMPATIBILITY()                                         \
-  cvSetIPLAllocators(iplCreateImageHeader, iplAllocateImage, iplDeallocate,    \
-                     iplCreateROI, iplCloneImage)
-
-/****************************************************************************************\
-*                                    Data Persistence *
-\****************************************************************************************/
-
-#if 0
-/********************************** High-level functions ********************************/
-
-/** @brief Opens file storage for reading or writing data.
-
-The function opens file storage for reading or writing data. In the latter case, a new file is
-created or an existing file is rewritten. The type of the read or written file is determined by the
-filename extension: .xml for XML, .yml or .yaml for YAML and .json for JSON.
-
-At the same time, it also supports adding parameters like "example.xml?base64".
-
-The function returns a pointer to the CvFileStorage structure.
-If the file cannot be opened then the function returns NULL.
-@param filename Name of the file associated with the storage
-@param memstorage Memory storage used for temporary data and for
-:   storing dynamic structures, such as CvSeq or CvGraph . If it is NULL, a temporary memory
-    storage is created and used.
-@param flags Can be one of the following:
-> -   **CV_STORAGE_READ** the storage is open for reading
-> -   **CV_STORAGE_WRITE** the storage is open for writing
-      (use **CV_STORAGE_WRITE | CV_STORAGE_WRITE_BASE64** to write rawdata in Base64)
-@param encoding
- */
-CVAPI(CvFileStorage*)  cvOpenFileStorage( const char* filename, CvMemStorage* memstorage,
-                                          int flags, const char* encoding CV_DEFAULT(NULL) );
-
-/** @brief Releases file storage.
-
-The function closes the file associated with the storage and releases all the temporary structures.
-It must be called after all I/O operations with the storage are finished.
-@param fs Double pointer to the released file storage
- */
-CVAPI(void) cvReleaseFileStorage( CvFileStorage** fs );
-
-/** returns attribute value or 0 (NULL) if there is no such attribute */
-CVAPI(const char*) cvAttrValue( const CvAttrList* attr, const char* attr_name );
-
-/** @brief Starts writing a new structure.
-
-The function starts writing a compound structure (collection) that can be a sequence or a map. After
-all the structure fields, which can be scalars or structures, are written, cvEndWriteStruct should
-be called. The function can be used to group some objects or to implement the write function for a
-some user object (see CvTypeInfo).
-@param fs File storage
-@param name Name of the written structure. The structure can be accessed by this name when the
-storage is read.
-@param struct_flags A combination one of the following values:
--   **CV_NODE_SEQ** the written structure is a sequence (see discussion of CvFileStorage ),
-    that is, its elements do not have a name.
--   **CV_NODE_MAP** the written structure is a map (see discussion of CvFileStorage ), that
-    is, all its elements have names.
-One and only one of the two above flags must be specified
--   **CV_NODE_FLOW** the optional flag that makes sense only for YAML streams. It means that
-     the structure is written as a flow (not as a block), which is more compact. It is
-     recommended to use this flag for structures or arrays whose elements are all scalars.
-@param type_name Optional parameter - the object type name. In
-    case of XML it is written as a type_id attribute of the structure opening tag. In the case of
-    YAML it is written after a colon following the structure name (see the example in
-    CvFileStorage description). In case of JSON it is written as a name/value pair.
-    Mainly it is used with user objects. When the storage is read, the
-    encoded type name is used to determine the object type (see CvTypeInfo and cvFindType ).
-@param attributes This parameter is not used in the current implementation
- */
-CVAPI(void) cvStartWriteStruct( CvFileStorage* fs, const char* name,
-                                int struct_flags, const char* type_name CV_DEFAULT(NULL),
-                                CvAttrList attributes CV_DEFAULT(cvAttrList()));
-
-/** @brief Finishes writing to a file node collection.
-@param fs File storage
-@sa cvStartWriteStruct.
- */
-CVAPI(void) cvEndWriteStruct( CvFileStorage* fs );
-
-/** @brief Writes an integer value.
-
-The function writes a single integer value (with or without a name) to the file storage.
-@param fs File storage
-@param name Name of the written value. Should be NULL if and only if the parent structure is a
-sequence.
-@param value The written value
- */
-CVAPI(void) cvWriteInt( CvFileStorage* fs, const char* name, int value );
-
-/** @brief Writes a floating-point value.
-
-The function writes a single floating-point value (with or without a name) to file storage. Special
-values are encoded as follows: NaN (Not A Number) as .NaN, infinity as +.Inf or -.Inf.
-
-The following example shows how to use the low-level writing functions to store custom structures,
-such as termination criteria, without registering a new type. :
-@code
-    void write_termcriteria( CvFileStorage* fs, const char* struct_name,
-                             CvTermCriteria* termcrit )
-    {
-        cvStartWriteStruct( fs, struct_name, CV_NODE_MAP, NULL, cvAttrList(0,0));
-        cvWriteComment( fs, "termination criteria", 1 ); // just a description
-        if( termcrit->type & CV_TERMCRIT_ITER )
-            cvWriteInteger( fs, "max_iterations", termcrit->max_iter );
-        if( termcrit->type & CV_TERMCRIT_EPS )
-            cvWriteReal( fs, "accuracy", termcrit->epsilon );
-        cvEndWriteStruct( fs );
-    }
-@endcode
-@param fs File storage
-@param name Name of the written value. Should be NULL if and only if the parent structure is a
-sequence.
-@param value The written value
-*/
-CVAPI(void) cvWriteReal( CvFileStorage* fs, const char* name, double value );
-
-/** @brief Writes a text string.
-
-The function writes a text string to file storage.
-@param fs File storage
-@param name Name of the written string . Should be NULL if and only if the parent structure is a
-sequence.
-@param str The written text string
-@param quote If non-zero, the written string is put in quotes, regardless of whether they are
-required. Otherwise, if the flag is zero, quotes are used only when they are required (e.g. when
-the string starts with a digit or contains spaces).
- */
-CVAPI(void) cvWriteString( CvFileStorage* fs, const char* name,
-                           const char* str, int quote CV_DEFAULT(0) );
-
-/** @brief Writes a comment.
-
-The function writes a comment into file storage. The comments are skipped when the storage is read.
-@param fs File storage
-@param comment The written comment, single-line or multi-line
-@param eol_comment If non-zero, the function tries to put the comment at the end of current line.
-If the flag is zero, if the comment is multi-line, or if it does not fit at the end of the current
-line, the comment starts a new line.
- */
-CVAPI(void) cvWriteComment( CvFileStorage* fs, const char* comment,
-                            int eol_comment );
-
-/** @brief Writes an object to file storage.
-
-The function writes an object to file storage. First, the appropriate type info is found using
-cvTypeOf. Then, the write method associated with the type info is called.
-
-Attributes are used to customize the writing procedure. The standard types support the following
-attributes (all the dt attributes have the same format as in cvWriteRawData):
-
--# CvSeq
-    -   **header_dt** description of user fields of the sequence header that follow CvSeq, or
-        CvChain (if the sequence is a Freeman chain) or CvContour (if the sequence is a contour or
-        point sequence)
-    -   **dt** description of the sequence elements.
-    -   **recursive** if the attribute is present and is not equal to "0" or "false", the whole
-        tree of sequences (contours) is stored.
--# CvGraph
-    -   **header_dt** description of user fields of the graph header that follows CvGraph;
-    -   **vertex_dt** description of user fields of graph vertices
-    -   **edge_dt** description of user fields of graph edges (note that the edge weight is
-        always written, so there is no need to specify it explicitly)
-
-Below is the code that creates the YAML file shown in the CvFileStorage description:
-@code
-    #include "cxcore.h"
-
-    int main( int argc, char** argv )
-    {
-        CvMat* mat = cvCreateMat( 3, 3, CV_32F );
-        CvFileStorage* fs = cvOpenFileStorage( "example.yml", 0, CV_STORAGE_WRITE );
-
-        cvSetIdentity( mat );
-        cvWrite( fs, "A", mat, cvAttrList(0,0) );
-
-        cvReleaseFileStorage( &fs );
-        cvReleaseMat( &mat );
-        return 0;
-    }
-@endcode
-@param fs File storage
-@param name Name of the written object. Should be NULL if and only if the parent structure is a
-sequence.
-@param ptr Pointer to the object
-@param attributes The attributes of the object. They are specific for each particular type (see
-the discussion below).
- */
-CVAPI(void) cvWrite( CvFileStorage* fs, const char* name, const void* ptr,
-                         CvAttrList attributes CV_DEFAULT(cvAttrList()));
-
-/** @brief Starts the next stream.
-
-The function finishes the currently written stream and starts the next stream. In the case of XML
-the file with multiple streams looks like this:
-@code{.xml}
-    <opencv_storage>
-    <!-- stream #1 data -->
-    </opencv_storage>
-    <opencv_storage>
-    <!-- stream #2 data -->
-    </opencv_storage>
-    ...
-@endcode
-The YAML file will look like this:
-@code{.yaml}
-    %YAML 1.0
-    # stream #1 data
-    ...
-    ---
-    # stream #2 data
-@endcode
-This is useful for concatenating files or for resuming the writing process.
-@param fs File storage
- */
-CVAPI(void) cvStartNextStream( CvFileStorage* fs );
-
-/** @brief Writes multiple numbers.
-
-The function writes an array, whose elements consist of single or multiple numbers. The function
-call can be replaced with a loop containing a few cvWriteInt and cvWriteReal calls, but a single
-call is more efficient. Note that because none of the elements have a name, they should be written
-to a sequence rather than a map.
-@param fs File storage
-@param src Pointer to the written array
-@param len Number of the array elements to write
-@param dt Specification of each array element, see @ref format_spec "format specification"
- */
-CVAPI(void) cvWriteRawData( CvFileStorage* fs, const void* src,
-                                int len, const char* dt );
-
-/** @brief Writes multiple numbers in Base64.
-
-If either CV_STORAGE_WRITE_BASE64 or cv::FileStorage::WRITE_BASE64 is used,
-this function will be the same as cvWriteRawData. If neither, the main
-difference is that it outputs a sequence in Base64 encoding rather than
-in plain text.
-
-This function can only be used to write a sequence with a type "binary".
-
-@param fs File storage
-@param src Pointer to the written array
-@param len Number of the array elements to write
-@param dt Specification of each array element, see @ref format_spec "format specification"
-*/
-CVAPI(void) cvWriteRawDataBase64( CvFileStorage* fs, const void* src,
-                                 int len, const char* dt );
-
-/** @brief Returns a unique pointer for a given name.
-
-The function returns a unique pointer for each particular file node name. This pointer can be then
-passed to the cvGetFileNode function that is faster than cvGetFileNodeByName because it compares
-text strings by comparing pointers rather than the strings' content.
-
-Consider the following example where an array of points is encoded as a sequence of 2-entry maps:
-@code
-    points:
-      - { x: 10, y: 10 }
-      - { x: 20, y: 20 }
-      - { x: 30, y: 30 }
-      # ...
-@endcode
-Then, it is possible to get hashed "x" and "y" pointers to speed up decoding of the points. :
-@code
-    #include "cxcore.h"
-
-    int main( int argc, char** argv )
-    {
-        CvFileStorage* fs = cvOpenFileStorage( "points.yml", 0, CV_STORAGE_READ );
-        CvStringHashNode* x_key = cvGetHashedNode( fs, "x", -1, 1 );
-        CvStringHashNode* y_key = cvGetHashedNode( fs, "y", -1, 1 );
-        CvFileNode* points = cvGetFileNodeByName( fs, 0, "points" );
-
-        if( CV_NODE_IS_SEQ(points->tag) )
-        {
-            CvSeq* seq = points->data.seq;
-            int i, total = seq->total;
-            CvSeqReader reader;
-            cvStartReadSeq( seq, &reader, 0 );
-            for( i = 0; i < total; i++ )
-            {
-                CvFileNode* pt = (CvFileNode*)reader.ptr;
-    #if 1 // faster variant
-                CvFileNode* xnode = cvGetFileNode( fs, pt, x_key, 0 );
-                CvFileNode* ynode = cvGetFileNode( fs, pt, y_key, 0 );
-                assert( xnode && CV_NODE_IS_INT(xnode->tag) &&
-                        ynode && CV_NODE_IS_INT(ynode->tag));
-                int x = xnode->data.i; // or x = cvReadInt( xnode, 0 );
-                int y = ynode->data.i; // or y = cvReadInt( ynode, 0 );
-    #elif 1 // slower variant; does not use x_key & y_key
-                CvFileNode* xnode = cvGetFileNodeByName( fs, pt, "x" );
-                CvFileNode* ynode = cvGetFileNodeByName( fs, pt, "y" );
-                assert( xnode && CV_NODE_IS_INT(xnode->tag) &&
-                        ynode && CV_NODE_IS_INT(ynode->tag));
-                int x = xnode->data.i; // or x = cvReadInt( xnode, 0 );
-                int y = ynode->data.i; // or y = cvReadInt( ynode, 0 );
-    #else // the slowest yet the easiest to use variant
-                int x = cvReadIntByName( fs, pt, "x", 0 );
-                int y = cvReadIntByName( fs, pt, "y", 0 );
-    #endif
-                CV_NEXT_SEQ_ELEM( seq->elem_size, reader );
-                printf("
-            }
-        }
-        cvReleaseFileStorage( &fs );
-        return 0;
-    }
-@endcode
-Please note that whatever method of accessing a map you are using, it is still much slower than
-using plain sequences; for example, in the above example, it is more efficient to encode the points
-as pairs of integers in a single numeric sequence.
-@param fs File storage
-@param name Literal node name
-@param len Length of the name (if it is known apriori), or -1 if it needs to be calculated
-@param create_missing Flag that specifies, whether an absent key should be added into the hash table
-*/
-CVAPI(CvStringHashNode*) cvGetHashedKey( CvFileStorage* fs, const char* name,
-                                        int len CV_DEFAULT(-1),
-                                        int create_missing CV_DEFAULT(0));
-
-/** @brief Retrieves one of the top-level nodes of the file storage.
-
-The function returns one of the top-level file nodes. The top-level nodes do not have a name, they
-correspond to the streams that are stored one after another in the file storage. If the index is out
-of range, the function returns a NULL pointer, so all the top-level nodes can be iterated by
-subsequent calls to the function with stream_index=0,1,..., until the NULL pointer is returned.
-This function can be used as a base for recursive traversal of the file storage.
-@param fs File storage
-@param stream_index Zero-based index of the stream. See cvStartNextStream . In most cases,
-there is only one stream in the file; however, there can be several.
- */
-CVAPI(CvFileNode*) cvGetRootFileNode( const CvFileStorage* fs,
-                                     int stream_index CV_DEFAULT(0) );
-
-/** @brief Finds a node in a map or file storage.
-
-The function finds a file node. It is a faster version of cvGetFileNodeByName (see
-cvGetHashedKey discussion). Also, the function can insert a new node, if it is not in the map yet.
-@param fs File storage
-@param map The parent map. If it is NULL, the function searches a top-level node. If both map and
-key are NULLs, the function returns the root file node - a map that contains top-level nodes.
-@param key Unique pointer to the node name, retrieved with cvGetHashedKey
-@param create_missing Flag that specifies whether an absent node should be added to the map
- */
-CVAPI(CvFileNode*) cvGetFileNode( CvFileStorage* fs, CvFileNode* map,
-                                 const CvStringHashNode* key,
-                                 int create_missing CV_DEFAULT(0) );
-
-/** @brief Finds a node in a map or file storage.
-
-The function finds a file node by name. The node is searched either in map or, if the pointer is
-NULL, among the top-level file storage nodes. Using this function for maps and cvGetSeqElem (or
-sequence reader) for sequences, it is possible to navigate through the file storage. To speed up
-multiple queries for a certain key (e.g., in the case of an array of structures) one may use a
-combination of cvGetHashedKey and cvGetFileNode.
-@param fs File storage
-@param map The parent map. If it is NULL, the function searches in all the top-level nodes
-(streams), starting with the first one.
-@param name The file node name
- */
-CVAPI(CvFileNode*) cvGetFileNodeByName( const CvFileStorage* fs,
-                                       const CvFileNode* map,
-                                       const char* name );
-
-/** @brief Retrieves an integer value from a file node.
-
-The function returns an integer that is represented by the file node. If the file node is NULL, the
-default_value is returned (thus, it is convenient to call the function right after cvGetFileNode
-without checking for a NULL pointer). If the file node has type CV_NODE_INT, then node-\>data.i is
-returned. If the file node has type CV_NODE_REAL, then node-\>data.f is converted to an integer
-and returned. Otherwise the error is reported.
-@param node File node
-@param default_value The value that is returned if node is NULL
- */
-CV_INLINE int cvReadInt( const CvFileNode* node, int default_value CV_DEFAULT(0) )
-{
-    return !node ? default_value :
-        CV_NODE_IS_INT(node->tag) ? node->data.i :
-        CV_NODE_IS_REAL(node->tag) ? cvRound(node->data.f) : 0x7fffffff;
-}
-
-/** @brief Finds a file node and returns its value.
-
-The function is a simple superposition of cvGetFileNodeByName and cvReadInt.
-@param fs File storage
-@param map The parent map. If it is NULL, the function searches a top-level node.
-@param name The node name
-@param default_value The value that is returned if the file node is not found
- */
-CV_INLINE int cvReadIntByName( const CvFileStorage* fs, const CvFileNode* map,
-                         const char* name, int default_value CV_DEFAULT(0) )
-{
-    return cvReadInt( cvGetFileNodeByName( fs, map, name ), default_value );
-}
-
-/** @brief Retrieves a floating-point value from a file node.
-
-The function returns a floating-point value that is represented by the file node. If the file node
-is NULL, the default_value is returned (thus, it is convenient to call the function right after
-cvGetFileNode without checking for a NULL pointer). If the file node has type CV_NODE_REAL ,
-then node-\>data.f is returned. If the file node has type CV_NODE_INT , then node-:math:\>data.f
-is converted to floating-point and returned. Otherwise the result is not determined.
-@param node File node
-@param default_value The value that is returned if node is NULL
- */
-CV_INLINE double cvReadReal( const CvFileNode* node, double default_value CV_DEFAULT(0.) )
-{
-    return !node ? default_value :
-        CV_NODE_IS_INT(node->tag) ? (double)node->data.i :
-        CV_NODE_IS_REAL(node->tag) ? node->data.f : 1e300;
-}
-
-/** @brief Finds a file node and returns its value.
-
-The function is a simple superposition of cvGetFileNodeByName and cvReadReal .
-@param fs File storage
-@param map The parent map. If it is NULL, the function searches a top-level node.
-@param name The node name
-@param default_value The value that is returned if the file node is not found
- */
-CV_INLINE double cvReadRealByName( const CvFileStorage* fs, const CvFileNode* map,
-                        const char* name, double default_value CV_DEFAULT(0.) )
-{
-    return cvReadReal( cvGetFileNodeByName( fs, map, name ), default_value );
-}
-
-/** @brief Retrieves a text string from a file node.
-
-The function returns a text string that is represented by the file node. If the file node is NULL,
-the default_value is returned (thus, it is convenient to call the function right after
-cvGetFileNode without checking for a NULL pointer). If the file node has type CV_NODE_STR , then
-node-:math:\>data.str.ptr is returned. Otherwise the result is not determined.
-@param node File node
-@param default_value The value that is returned if node is NULL
- */
-CV_INLINE const char* cvReadString( const CvFileNode* node,
-                        const char* default_value CV_DEFAULT(NULL) )
-{
-    return !node ? default_value : CV_NODE_IS_STRING(node->tag) ? node->data.str.ptr : 0;
-}
-
-/** @brief Finds a file node by its name and returns its value.
-
-The function is a simple superposition of cvGetFileNodeByName and cvReadString .
-@param fs File storage
-@param map The parent map. If it is NULL, the function searches a top-level node.
-@param name The node name
-@param default_value The value that is returned if the file node is not found
- */
-CV_INLINE const char* cvReadStringByName( const CvFileStorage* fs, const CvFileNode* map,
-                        const char* name, const char* default_value CV_DEFAULT(NULL) )
-{
-    return cvReadString( cvGetFileNodeByName( fs, map, name ), default_value );
-}
-
-
-/** @brief Decodes an object and returns a pointer to it.
-
-The function decodes a user object (creates an object in a native representation from the file
-storage subtree) and returns it. The object to be decoded must be an instance of a registered type
-that supports the read method (see CvTypeInfo). The type of the object is determined by the type
-name that is encoded in the file. If the object is a dynamic structure, it is created either in
-memory storage and passed to cvOpenFileStorage or, if a NULL pointer was passed, in temporary
-memory storage, which is released when cvReleaseFileStorage is called. Otherwise, if the object is
-not a dynamic structure, it is created in a heap and should be released with a specialized function
-or by using the generic cvRelease.
-@param fs File storage
-@param node The root object node
-@param attributes Unused parameter
- */
-CVAPI(void*) cvRead( CvFileStorage* fs, CvFileNode* node,
-                        CvAttrList* attributes CV_DEFAULT(NULL));
-
-/** @brief Finds an object by name and decodes it.
-
-The function is a simple superposition of cvGetFileNodeByName and cvRead.
-@param fs File storage
-@param map The parent map. If it is NULL, the function searches a top-level node.
-@param name The node name
-@param attributes Unused parameter
- */
-CV_INLINE void* cvReadByName( CvFileStorage* fs, const CvFileNode* map,
-                              const char* name, CvAttrList* attributes CV_DEFAULT(NULL) )
-{
-    return cvRead( fs, cvGetFileNodeByName( fs, map, name ), attributes );
-}
-
-
-/** @brief Initializes the file node sequence reader.
-
-The function initializes the sequence reader to read data from a file node. The initialized reader
-can be then passed to cvReadRawDataSlice.
-@param fs File storage
-@param src The file node (a sequence) to read numbers from
-@param reader Pointer to the sequence reader
- */
-CVAPI(void) cvStartReadRawData( const CvFileStorage* fs, const CvFileNode* src,
-                               CvSeqReader* reader );
-
-/** @brief Initializes file node sequence reader.
-
-The function reads one or more elements from the file node, representing a sequence, to a
-user-specified array. The total number of read sequence elements is a product of total and the
-number of components in each array element. For example, if dt=2if, the function will read total\*3
-sequence elements. As with any sequence, some parts of the file node sequence can be skipped or read
-repeatedly by repositioning the reader using cvSetSeqReaderPos.
-@param fs File storage
-@param reader The sequence reader. Initialize it with cvStartReadRawData .
-@param count The number of elements to read
-@param dst Pointer to the destination array
-@param dt Specification of each array element. It has the same format as in cvWriteRawData .
- */
-CVAPI(void) cvReadRawDataSlice( const CvFileStorage* fs, CvSeqReader* reader,
-                               int count, void* dst, const char* dt );
-
-/** @brief Reads multiple numbers.
-
-The function reads elements from a file node that represents a sequence of scalars.
-@param fs File storage
-@param src The file node (a sequence) to read numbers from
-@param dst Pointer to the destination array
-@param dt Specification of each array element. It has the same format as in cvWriteRawData .
- */
-CVAPI(void) cvReadRawData( const CvFileStorage* fs, const CvFileNode* src,
-                          void* dst, const char* dt );
-
-/** @brief Writes a file node to another file storage.
-
-The function writes a copy of a file node to file storage. Possible applications of the function are
-merging several file storages into one and conversion between XML, YAML and JSON formats.
-@param fs Destination file storage
-@param new_node_name New name of the file node in the destination file storage. To keep the
-existing name, use cvcvGetFileNodeName
-@param node The written node
-@param embed If the written node is a collection and this parameter is not zero, no extra level of
-hierarchy is created. Instead, all the elements of node are written into the currently written
-structure. Of course, map elements can only be embedded into another map, and sequence elements
-can only be embedded into another sequence.
- */
-CVAPI(void) cvWriteFileNode( CvFileStorage* fs, const char* new_node_name,
-                            const CvFileNode* node, int embed );
-
-/** @brief Returns the name of a file node.
-
-The function returns the name of a file node or NULL, if the file node does not have a name or if
-node is NULL.
-@param node File node
- */
-CVAPI(const char*) cvGetFileNodeName( const CvFileNode* node );
-
-/*********************************** Adding own types ***********************************/
-
-/** @brief Registers a new type.
-
-The function registers a new type, which is described by info . The function creates a copy of the
-structure, so the user should delete it after calling the function.
-@param info Type info structure
- */
-CVAPI(void) cvRegisterType( const CvTypeInfo* info );
-
-/** @brief Unregisters the type.
-
-The function unregisters a type with a specified name. If the name is unknown, it is possible to
-locate the type info by an instance of the type using cvTypeOf or by iterating the type list,
-starting from cvFirstType, and then calling cvUnregisterType(info-\>typeName).
-@param type_name Name of an unregistered type
- */
-CVAPI(void) cvUnregisterType( const char* type_name );
-
-/** @brief Returns the beginning of a type list.
-
-The function returns the first type in the list of registered types. Navigation through the list can
-be done via the prev and next fields of the CvTypeInfo structure.
- */
-CVAPI(CvTypeInfo*) cvFirstType(void);
-
-/** @brief Finds a type by its name.
-
-The function finds a registered type by its name. It returns NULL if there is no type with the
-specified name.
-@param type_name Type name
- */
-CVAPI(CvTypeInfo*) cvFindType( const char* type_name );
-
-/** @brief Returns the type of an object.
-
-The function finds the type of a given object. It iterates through the list of registered types and
-calls the is_instance function/method for every type info structure with that object until one of
-them returns non-zero or until the whole list has been traversed. In the latter case, the function
-returns NULL.
-@param struct_ptr The object pointer
- */
-CVAPI(CvTypeInfo*) cvTypeOf( const void* struct_ptr );
-
-#endif
-
-/** @brief Releases an object.
-
- The function finds the type of a given object and calls release with the double
- pointer.
- @param struct_ptr Double pointer to the object
- */
-CVAPI(void) cvRelease(void **struct_ptr);
-
-/** @brief Makes a clone of an object.
-
-The function finds the type of a given object and calls clone with the passed
-object. Of course, if you know the object type, for example, struct_ptr is
-CvMat\*, it is faster to call the specific function, like cvCloneMat.
-@param struct_ptr The object to clone
- */
-CVAPI(void *) cvClone(const void *struct_ptr);
-
-/*********************************** Measuring Execution Time
- * ***************************/
-
-/** helper functions for RNG initialization and accurate time measurement:
-   uses internal clock counter on x86 */
-CVAPI(int64) cvGetTickCount(void);
-CVAPI(double) cvGetTickFrequency(void);
-
-/*********************************** CPU capabilities
- * ***********************************/
-
-CVAPI(int) cvCheckHardwareSupport(int feature);
-
-/*********************************** Multi-Threading
- * ************************************/
-
-/** retrieve/set the number of threads used in OpenMP implementations */
-CVAPI(int) cvGetNumThreads(void);
-CVAPI(void) cvSetNumThreads(int threads CV_DEFAULT(0));
-/** get index of the thread being executed */
-CVAPI(int) cvGetThreadNum(void);
-
-/********************************** Error Handling
- * **************************************/
-
-/** Get current OpenCV error status */
-CVAPI(int) cvGetErrStatus(void);
-
-/** Sets error status silently */
-CVAPI(void) cvSetErrStatus(int status);
-
-#define CV_ErrModeLeaf 0   /* Print error and exit program */
-#define CV_ErrModeParent 1 /* Print error and continue */
-#define CV_ErrModeSilent 2 /* Don't print and continue */
-
-/** Retrieves current error processing mode */
-CVAPI(int) cvGetErrMode(void);
-
-/** Sets error processing mode, returns previously used mode */
-CVAPI(int) cvSetErrMode(int mode);
-
-/** Sets error status and performs some additional actions (displaying message
- box, writing message to stderr, terminating application etc.) depending on the
- current error mode */
-CVAPI(void)
-cvError(int status, const char *func_name, const char *err_msg,
-        const char *file_name, int line);
-
-/** Retrieves textual description of the error given its code */
-CVAPI(const char *) cvErrorStr(int status);
-
-/** Retrieves detailed information about the last error occurred */
-CVAPI(int)
-cvGetErrInfo(const char **errcode_desc, const char **description,
-             const char **filename, int *line);
-
-/** Maps IPP error codes to the counterparts from OpenCV */
-CVAPI(int) cvErrorFromIppStatus(int ipp_status);
-
-typedef int(CV_CDECL *CvErrorCallback)(int status, const char *func_name,
-                                       const char *err_msg,
-                                       const char *file_name, int line,
-                                       void *userdata);
-
-/** Assigns a new error-handling function */
-CVAPI(CvErrorCallback)
-cvRedirectError(CvErrorCallback error_handler, void *userdata CV_DEFAULT(NULL),
-                void **prev_userdata CV_DEFAULT(NULL));
-
-/** Output nothing */
-CVAPI(int)
-cvNulDevReport(int status, const char *func_name, const char *err_msg,
-               const char *file_name, int line, void *userdata);
-
-/** Output to console(fprintf(stderr,...)) */
-CVAPI(int)
-cvStdErrReport(int status, const char *func_name, const char *err_msg,
-               const char *file_name, int line, void *userdata);
-
-/** Output to MessageBox(WIN32) */
-CVAPI(int)
-cvGuiBoxReport(int status, const char *func_name, const char *err_msg,
-               const char *file_name, int line, void *userdata);
-
-#define OPENCV_ERROR(status, func, context)                                    \
-  cvError((status), (func), (context), __FILE__, __LINE__)
-
-#define OPENCV_ASSERT(expr, func, context)                                     \
-  {                                                                            \
-    if (!(expr)) {                                                             \
-      OPENCV_ERROR(CV_StsInternal, (func), (context));                         \
-    }                                                                          \
-  }
-
-#define OPENCV_CALL(Func)                                                      \
-  {                                                                            \
-    Func;                                                                      \
-  }
-
-/** CV_FUNCNAME macro defines icvFuncName constant which is used by CV_ERROR
- * macro */
-#ifdef CV_NO_FUNC_NAMES
-#define CV_FUNCNAME(Name)
-#define cvFuncName ""
-#else
-#define CV_FUNCNAME(Name) static char cvFuncName[] = Name
-#endif
-
-/**
- CV_ERROR macro unconditionally raises error with passed code and message.
- After raising error, control will be transferred to the exit label.
- */
-#define CV_ERROR(Code, Msg)                                                    \
-  {                                                                            \
-    cvError((Code), cvFuncName, Msg, __FILE__, __LINE__);                      \
-    __CV_EXIT__;                                                               \
-  }
-
-/**
- CV_CHECK macro checks error status after CV (or IPL)
- function call. If error detected, control will be transferred to the exit
- label.
- */
-#define CV_CHECK()                                                             \
-  {                                                                            \
-    if (cvGetErrStatus() < 0)                                                  \
-      CV_ERROR(CV_StsBackTrace, "Inner function failed.");                     \
-  }
-
-/**
- CV_CALL macro calls CV (or IPL) function, checks error status and
- signals a error if the function failed. Useful in "parent node"
- error processing mode
- */
-#define CV_CALL(Func)                                                          \
-  {                                                                            \
-    Func;                                                                      \
-    CV_CHECK();                                                                \
-  }
-
-/** Runtime assertion macro */
-#define CV_ASSERT(Condition)                                                   \
-  {                                                                            \
-    if (!(Condition))                                                          \
-      CV_ERROR(CV_StsInternal, "Assertion: " #Condition " failed");            \
-  }
-
-#define __CV_BEGIN__ {
-#define __CV_END__                                                             \
-  goto exit;                                                                   \
-  exit:;                                                                       \
-  }
-#define __CV_EXIT__ goto exit
-
-/** @} core_c */
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-#ifdef __cplusplus
-
-#include "opencv2/core/utility.hpp"
-
-namespace cv {
-
-//! @addtogroup core_c_glue
-//! @{
-
-/////////////////////////////////////////// glue
-//////////////////////////////////////////////
-
-//! converts array (CvMat or IplImage) to cv::Mat
-CV_EXPORTS Mat cvarrToMat(const CvArr *arr, bool copyData = false,
-                          bool allowND = true, int coiMode = 0,
-                          AutoBuffer<double> *buf = 0);
-
-static inline Mat cvarrToMatND(const CvArr *arr, bool copyData = false,
-                               int coiMode = 0) {
-  return cvarrToMat(arr, copyData, true, coiMode);
-}
-
-//! extracts Channel of Interest from CvMat or IplImage and makes cv::Mat out of
-//! it.
-CV_EXPORTS void extractImageCOI(const CvArr *arr, OutputArray coiimg,
-                                int coi = -1);
-//! inserts single-channel cv::Mat into a multi-channel CvMat or IplImage
-CV_EXPORTS void insertImageCOI(InputArray coiimg, CvArr *arr, int coi = -1);
-
-////// specialized implementations of DefaultDeleter::operator() for classic
-/// OpenCV types //////
-
-template <> struct DefaultDeleter<CvMat> {
-  CV_EXPORTS void operator()(CvMat *obj) const;
-};
-template <> struct DefaultDeleter<IplImage> {
-  CV_EXPORTS void operator()(IplImage *obj) const;
-};
-template <> struct DefaultDeleter<CvMatND> {
-  CV_EXPORTS void operator()(CvMatND *obj) const;
-};
-template <> struct DefaultDeleter<CvSparseMat> {
-  CV_EXPORTS void operator()(CvSparseMat *obj) const;
-};
-template <> struct DefaultDeleter<CvMemStorage> {
-  CV_EXPORTS void operator()(CvMemStorage *obj) const;
-};
-
-////////////// convenient wrappers for operating old-style dynamic structures
-/////////////////
-
-template <typename _Tp> class SeqIterator;
-
-typedef Ptr<CvMemStorage> MemStorage;
-
-/*!
- Template Sequence Class derived from CvSeq
-
- The class provides more convenient access to sequence elements,
- STL-style operations and iterators.
-
- \note The class is targeted for simple data types,
-    i.e. no constructors or destructors
-    are called for the sequence elements.
-*/
-template <typename _Tp> class Seq {
-public:
-  typedef SeqIterator<_Tp> iterator;
-  typedef SeqIterator<_Tp> const_iterator;
-
-  //! the default constructor
-  Seq();
-  //! the constructor for wrapping CvSeq structure. The real element type in
-  //! CvSeq should match _Tp.
-  Seq(const CvSeq *seq);
-  //! creates the empty sequence that resides in the specified storage
-  Seq(MemStorage &storage, int headerSize = sizeof(CvSeq));
-  //! returns read-write reference to the specified element
-  _Tp &operator[](int idx);
-  //! returns read-only reference to the specified element
-  const _Tp &operator[](int idx) const;
-  //! returns iterator pointing to the beginning of the sequence
-  SeqIterator<_Tp> begin() const;
-  //! returns iterator pointing to the element following the last sequence
-  //! element
-  SeqIterator<_Tp> end() const;
-  //! returns the number of elements in the sequence
-  size_t size() const;
-  //! returns the type of sequence elements (CV_8UC1 ... CV_64FC(CV_CN_MAX) ...)
-  int type() const;
-  //! returns the depth of sequence elements (CV_8U ... CV_64F)
-  int depth() const;
-  //! returns the number of channels in each sequence element
-  int channels() const;
-  //! returns the size of each sequence element
-  size_t elemSize() const;
-  //! returns index of the specified sequence element
-  size_t index(const _Tp &elem) const;
-  //! appends the specified element to the end of the sequence
-  void push_back(const _Tp &elem);
-  //! appends the specified element to the front of the sequence
-  void push_front(const _Tp &elem);
-  //! appends zero or more elements to the end of the sequence
-  void push_back(const _Tp *elems, size_t count);
-  //! appends zero or more elements to the front of the sequence
-  void push_front(const _Tp *elems, size_t count);
-  //! inserts the specified element to the specified position
-  void insert(int idx, const _Tp &elem);
-  //! inserts zero or more elements to the specified position
-  void insert(int idx, const _Tp *elems, size_t count);
-  //! removes element at the specified position
-  void remove(int idx);
-  //! removes the specified subsequence
-  void remove(const Range &r);
-
-  //! returns reference to the first sequence element
-  _Tp &front();
-  //! returns read-only reference to the first sequence element
-  const _Tp &front() const;
-  //! returns reference to the last sequence element
-  _Tp &back();
-  //! returns read-only reference to the last sequence element
-  const _Tp &back() const;
-  //! returns true iff the sequence contains no elements
-  bool empty() const;
-
-  //! removes all the elements from the sequence
-  void clear();
-  //! removes the first element from the sequence
-  void pop_front();
-  //! removes the last element from the sequence
-  void pop_back();
-  //! removes zero or more elements from the beginning of the sequence
-  void pop_front(_Tp *elems, size_t count);
-  //! removes zero or more elements from the end of the sequence
-  void pop_back(_Tp *elems, size_t count);
-
-  //! copies the whole sequence or the sequence slice to the specified vector
-  void copyTo(std::vector<_Tp> &vec, const Range &range = Range::all()) const;
-  //! returns the vector containing all the sequence elements
-  operator std::vector<_Tp>() const;
-
-  CvSeq *seq;
-};
-
-/*!
- STL-style Sequence Iterator inherited from the CvSeqReader structure
-*/
-template <typename _Tp> class SeqIterator : public CvSeqReader {
-public:
-  //! the default constructor
-  SeqIterator();
-  //! the constructor setting the iterator to the beginning or to the end of the
-  //! sequence
-  SeqIterator(const Seq<_Tp> &seq, bool seekEnd = false);
-  //! positions the iterator within the sequence
-  void seek(size_t pos);
-  //! reports the current iterator position
-  size_t tell() const;
-  //! returns reference to the current sequence element
-  _Tp &operator*();
-  //! returns read-only reference to the current sequence element
-  const _Tp &operator*() const;
-  //! moves iterator to the next sequence element
-  SeqIterator &operator++();
-  //! moves iterator to the next sequence element
-  SeqIterator operator++(int) const;
-  //! moves iterator to the previous sequence element
-  SeqIterator &operator--();
-  //! moves iterator to the previous sequence element
-  SeqIterator operator--(int) const;
-
-  //! moves iterator forward by the specified offset (possibly negative)
-  SeqIterator &operator+=(int);
-  //! moves iterator backward by the specified offset (possibly negative)
-  SeqIterator &operator-=(int);
-
-  // this is index of the current element module seq->total*2
-  // (to distinguish between 0 and seq->total)
-  int index;
-};
-
-// bridge C++ => C Seq API
-CV_EXPORTS schar *seqPush(CvSeq *seq, const void *element = 0);
-CV_EXPORTS schar *seqPushFront(CvSeq *seq, const void *element = 0);
-CV_EXPORTS void seqPop(CvSeq *seq, void *element = 0);
-CV_EXPORTS void seqPopFront(CvSeq *seq, void *element = 0);
-CV_EXPORTS void seqPopMulti(CvSeq *seq, void *elements, int count,
-                            int in_front = 0);
-CV_EXPORTS void seqRemove(CvSeq *seq, int index);
-CV_EXPORTS void clearSeq(CvSeq *seq);
-CV_EXPORTS schar *getSeqElem(const CvSeq *seq, int index);
-CV_EXPORTS void seqRemoveSlice(CvSeq *seq, CvSlice slice);
-CV_EXPORTS void seqInsertSlice(CvSeq *seq, int before_index,
-                               const CvArr *from_arr);
-
-template <typename _Tp> inline Seq<_Tp>::Seq() : seq(0) {}
-template <typename _Tp>
-inline Seq<_Tp>::Seq(const CvSeq *_seq) : seq((CvSeq *)_seq) {
-  CV_Assert(!_seq || _seq->elem_size == sizeof(_Tp));
-}
-
-template <typename _Tp>
-inline Seq<_Tp>::Seq(MemStorage &storage, int headerSize) {
-  CV_Assert(headerSize >= (int)sizeof(CvSeq));
-  seq = cvCreateSeq(DataType<_Tp>::type, headerSize, sizeof(_Tp), storage);
-}
-
-template <typename _Tp> inline _Tp &Seq<_Tp>::operator[](int idx) {
-  return *(_Tp *)getSeqElem(seq, idx);
-}
-
-template <typename _Tp> inline const _Tp &Seq<_Tp>::operator[](int idx) const {
-  return *(_Tp *)getSeqElem(seq, idx);
-}
-
-template <typename _Tp> inline SeqIterator<_Tp> Seq<_Tp>::begin() const {
-  return SeqIterator<_Tp>(*this);
-}
-
-template <typename _Tp> inline SeqIterator<_Tp> Seq<_Tp>::end() const {
-  return SeqIterator<_Tp>(*this, true);
-}
-
-template <typename _Tp> inline size_t Seq<_Tp>::size() const {
-  return seq ? seq->total : 0;
-}
-
-template <typename _Tp> inline int Seq<_Tp>::type() const {
-  return seq ? CV_MAT_TYPE(seq->flags) : 0;
-}
-
-template <typename _Tp> inline int Seq<_Tp>::depth() const {
-  return seq ? CV_MAT_DEPTH(seq->flags) : 0;
-}
-
-template <typename _Tp> inline int Seq<_Tp>::channels() const {
-  return seq ? CV_MAT_CN(seq->flags) : 0;
-}
-
-template <typename _Tp> inline size_t Seq<_Tp>::elemSize() const {
-  return seq ? seq->elem_size : 0;
-}
-
-template <typename _Tp> inline size_t Seq<_Tp>::index(const _Tp &elem) const {
-  return cvSeqElemIdx(seq, &elem);
-}
-
-template <typename _Tp> inline void Seq<_Tp>::push_back(const _Tp &elem) {
-  cvSeqPush(seq, &elem);
-}
-
-template <typename _Tp> inline void Seq<_Tp>::push_front(const _Tp &elem) {
-  cvSeqPushFront(seq, &elem);
-}
-
-template <typename _Tp>
-inline void Seq<_Tp>::push_back(const _Tp *elem, size_t count) {
-  cvSeqPushMulti(seq, elem, (int)count, 0);
-}
-
-template <typename _Tp>
-inline void Seq<_Tp>::push_front(const _Tp *elem, size_t count) {
-  cvSeqPushMulti(seq, elem, (int)count, 1);
-}
-
-template <typename _Tp> inline _Tp &Seq<_Tp>::back() {
-  return *(_Tp *)getSeqElem(seq, -1);
-}
-
-template <typename _Tp> inline const _Tp &Seq<_Tp>::back() const {
-  return *(const _Tp *)getSeqElem(seq, -1);
-}
-
-template <typename _Tp> inline _Tp &Seq<_Tp>::front() {
-  return *(_Tp *)getSeqElem(seq, 0);
-}
-
-template <typename _Tp> inline const _Tp &Seq<_Tp>::front() const {
-  return *(const _Tp *)getSeqElem(seq, 0);
-}
-
-template <typename _Tp> inline bool Seq<_Tp>::empty() const {
-  return !seq || seq->total == 0;
-}
-
-template <typename _Tp> inline void Seq<_Tp>::clear() {
-  if (seq)
-    clearSeq(seq);
-}
-
-template <typename _Tp> inline void Seq<_Tp>::pop_back() { seqPop(seq); }
-
-template <typename _Tp> inline void Seq<_Tp>::pop_front() { seqPopFront(seq); }
-
-template <typename _Tp>
-inline void Seq<_Tp>::pop_back(_Tp *elem, size_t count) {
-  seqPopMulti(seq, elem, (int)count, 0);
-}
-
-template <typename _Tp>
-inline void Seq<_Tp>::pop_front(_Tp *elem, size_t count) {
-  seqPopMulti(seq, elem, (int)count, 1);
-}
-
-template <typename _Tp> inline void Seq<_Tp>::insert(int idx, const _Tp &elem) {
-  seqInsert(seq, idx, &elem);
-}
-
-template <typename _Tp>
-inline void Seq<_Tp>::insert(int idx, const _Tp *elems, size_t count) {
-  CvMat m = cvMat(1, count, DataType<_Tp>::type, elems);
-  seqInsertSlice(seq, idx, &m);
-}
-
-template <typename _Tp> inline void Seq<_Tp>::remove(int idx) {
-  seqRemove(seq, idx);
-}
-
-template <typename _Tp> inline void Seq<_Tp>::remove(const Range &r) {
-  seqRemoveSlice(seq, cvSlice(r.start, r.end));
-}
-
-template <typename _Tp>
-inline void Seq<_Tp>::copyTo(std::vector<_Tp> &vec, const Range &range) const {
-  size_t len = !seq                    ? 0
-               : range == Range::all() ? seq->total
-                                       : range.end - range.start;
-  vec.resize(len);
-  if (seq && len)
-    cvCvtSeqToArray(seq, &vec[0], cvSlice(range));
-}
-
-template <typename _Tp> inline Seq<_Tp>::operator std::vector<_Tp>() const {
-  std::vector<_Tp> vec;
-  copyTo(vec);
-  return vec;
-}
-
-template <typename _Tp> inline SeqIterator<_Tp>::SeqIterator() {
-  memset(this, 0, sizeof(*this));
-}
-
-template <typename _Tp>
-inline SeqIterator<_Tp>::SeqIterator(const Seq<_Tp> &_seq, bool seekEnd) {
-  cvStartReadSeq(_seq.seq, this);
-  index = seekEnd ? _seq.seq->total : 0;
-}
-
-template <typename _Tp> inline void SeqIterator<_Tp>::seek(size_t pos) {
-  cvSetSeqReaderPos(this, (int)pos, false);
-  index = pos;
-}
-
-template <typename _Tp> inline size_t SeqIterator<_Tp>::tell() const {
-  return index;
-}
-
-template <typename _Tp> inline _Tp &SeqIterator<_Tp>::operator*() {
-  return *(_Tp *)ptr;
-}
-
-template <typename _Tp> inline const _Tp &SeqIterator<_Tp>::operator*() const {
-  return *(const _Tp *)ptr;
-}
-
-template <typename _Tp>
-inline SeqIterator<_Tp> &SeqIterator<_Tp>::operator++() {
-  CV_NEXT_SEQ_ELEM(sizeof(_Tp), *this);
-  if (++index >= seq->total * 2)
-    index = 0;
-  return *this;
-}
-
-template <typename _Tp>
-inline SeqIterator<_Tp> SeqIterator<_Tp>::operator++(int) const {
-  SeqIterator<_Tp> it = *this;
-  ++*this;
-  return it;
-}
-
-template <typename _Tp>
-inline SeqIterator<_Tp> &SeqIterator<_Tp>::operator--() {
-  CV_PREV_SEQ_ELEM(sizeof(_Tp), *this);
-  if (--index < 0)
-    index = seq->total * 2 - 1;
-  return *this;
-}
-
-template <typename _Tp>
-inline SeqIterator<_Tp> SeqIterator<_Tp>::operator--(int) const {
-  SeqIterator<_Tp> it = *this;
-  --*this;
-  return it;
-}
-
-template <typename _Tp>
-inline SeqIterator<_Tp> &SeqIterator<_Tp>::operator+=(int delta) {
-  cvSetSeqReaderPos(this, delta, 1);
-  index += delta;
-  int n = seq->total * 2;
-  if (index < 0)
-    index += n;
-  if (index >= n)
-    index -= n;
-  return *this;
-}
-
-template <typename _Tp>
-inline SeqIterator<_Tp> &SeqIterator<_Tp>::operator-=(int delta) {
-  return (*this += -delta);
-}
-
-template <typename _Tp>
-inline ptrdiff_t operator-(const SeqIterator<_Tp> &a,
-                           const SeqIterator<_Tp> &b) {
-  ptrdiff_t delta = a.index - b.index, n = a.seq->total;
-  if (delta > n || delta < -n)
-    delta += delta < 0 ? n : -n;
-  return delta;
-}
-
-template <typename _Tp>
-inline bool operator==(const SeqIterator<_Tp> &a, const SeqIterator<_Tp> &b) {
-  return a.seq == b.seq && a.index == b.index;
-}
-
-template <typename _Tp>
-inline bool operator!=(const SeqIterator<_Tp> &a, const SeqIterator<_Tp> &b) {
-  return !(a == b);
-}
-
-//! @}
-
-} // namespace cv
-
-#endif
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/cv_cpu_dispatch.h b/packages/react-native-executorch/third-party/include/opencv2/core/cv_cpu_dispatch.h
deleted file mode 100644
index 8a0c1b3935..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/cv_cpu_dispatch.h
+++ /dev/null
@@ -1,404 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#if defined __OPENCV_BUILD
-
-#include "cv_cpu_config.h"
-#include "cv_cpu_helper.h"
-
-#ifdef CV_CPU_DISPATCH_MODE
-#define CV_CPU_OPTIMIZATION_NAMESPACE __CV_CAT(opt_, CV_CPU_DISPATCH_MODE)
-#define CV_CPU_OPTIMIZATION_NAMESPACE_BEGIN                                    \
-  namespace __CV_CAT(opt_, CV_CPU_DISPATCH_MODE) {
-#define CV_CPU_OPTIMIZATION_NAMESPACE_END }
-#else
-#define CV_CPU_OPTIMIZATION_NAMESPACE cpu_baseline
-#define CV_CPU_OPTIMIZATION_NAMESPACE_BEGIN namespace cpu_baseline {
-#define CV_CPU_OPTIMIZATION_NAMESPACE_END }
-#define CV_CPU_BASELINE_MODE 1
-#endif
-
-#define __CV_CPU_DISPATCH_CHAIN_END(fn, args, mode, ...) /* done */
-#define __CV_CPU_DISPATCH(fn, args, mode, ...)                                 \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-#define __CV_CPU_DISPATCH_EXPAND(fn, args, ...)                                \
-  __CV_EXPAND(__CV_CPU_DISPATCH(fn, args, __VA_ARGS__))
-#define CV_CPU_DISPATCH(fn, args, ...)                                         \
-  __CV_CPU_DISPATCH_EXPAND(fn, args, __VA_ARGS__, END) // expand macros
-
-#if defined CV_ENABLE_INTRINSICS && !defined CV_DISABLE_OPTIMIZATION &&        \
-    !defined __CUDACC__ /* do not include SSE/AVX/NEON headers for NVCC        \
-                           compiler */
-
-#ifdef CV_CPU_COMPILE_SSE2
-#include <emmintrin.h>
-#define CV_MMX 1
-#define CV_SSE 1
-#define CV_SSE2 1
-#endif
-#ifdef CV_CPU_COMPILE_SSE3
-#include <pmmintrin.h>
-#define CV_SSE3 1
-#endif
-#ifdef CV_CPU_COMPILE_SSSE3
-#include <tmmintrin.h>
-#define CV_SSSE3 1
-#endif
-#ifdef CV_CPU_COMPILE_SSE4_1
-#include <smmintrin.h>
-#define CV_SSE4_1 1
-#endif
-#ifdef CV_CPU_COMPILE_SSE4_2
-#include <nmmintrin.h>
-#define CV_SSE4_2 1
-#endif
-#ifdef CV_CPU_COMPILE_POPCNT
-#ifdef _MSC_VER
-#include <nmmintrin.h>
-#if defined(_M_X64)
-#define CV_POPCNT_U64 (int)_mm_popcnt_u64
-#endif
-#define CV_POPCNT_U32 _mm_popcnt_u32
-#else
-#include <popcntintrin.h>
-#if defined(__x86_64__)
-#define CV_POPCNT_U64 __builtin_popcountll
-#endif
-#define CV_POPCNT_U32 __builtin_popcount
-#endif
-#define CV_POPCNT 1
-#endif
-#ifdef CV_CPU_COMPILE_AVX
-#include <immintrin.h>
-#define CV_AVX 1
-#endif
-#ifdef CV_CPU_COMPILE_FP16
-#if defined(__arm__) || defined(__aarch64__) || defined(_M_ARM) ||             \
-    defined(_M_ARM64)
-#include <arm_neon.h>
-#else
-#include <immintrin.h>
-#endif
-#define CV_FP16 1
-#endif
-#ifdef CV_CPU_COMPILE_NEON_DOTPROD
-#include <arm_neon.h>
-#define CV_NEON_DOT 1
-#endif
-#ifdef CV_CPU_COMPILE_AVX2
-#include <immintrin.h>
-#define CV_AVX2 1
-#endif
-#ifdef CV_CPU_COMPILE_AVX_512F
-#include <immintrin.h>
-#define CV_AVX_512F 1
-#endif
-#ifdef CV_CPU_COMPILE_AVX512_COMMON
-#define CV_AVX512_COMMON 1
-#define CV_AVX_512CD 1
-#endif
-#ifdef CV_CPU_COMPILE_AVX512_KNL
-#define CV_AVX512_KNL 1
-#define CV_AVX_512ER 1
-#define CV_AVX_512PF 1
-#endif
-#ifdef CV_CPU_COMPILE_AVX512_KNM
-#define CV_AVX512_KNM 1
-#define CV_AVX_5124FMAPS 1
-#define CV_AVX_5124VNNIW 1
-#define CV_AVX_512VPOPCNTDQ 1
-#endif
-#ifdef CV_CPU_COMPILE_AVX512_SKX
-#define CV_AVX512_SKX 1
-#define CV_AVX_512VL 1
-#define CV_AVX_512BW 1
-#define CV_AVX_512DQ 1
-#endif
-#ifdef CV_CPU_COMPILE_AVX512_CNL
-#define CV_AVX512_CNL 1
-#define CV_AVX_512IFMA 1
-#define CV_AVX_512VBMI 1
-#endif
-#ifdef CV_CPU_COMPILE_AVX512_CLX
-#define CV_AVX512_CLX 1
-#define CV_AVX_512VNNI 1
-#endif
-#ifdef CV_CPU_COMPILE_AVX512_ICL
-#define CV_AVX512_ICL 1
-#undef CV_AVX_512IFMA
-#define CV_AVX_512IFMA 1
-#undef CV_AVX_512VBMI
-#define CV_AVX_512VBMI 1
-#undef CV_AVX_512VNNI
-#define CV_AVX_512VNNI 1
-#define CV_AVX_512VBMI2 1
-#define CV_AVX_512BITALG 1
-#define CV_AVX_512VPOPCNTDQ 1
-#endif
-#ifdef CV_CPU_COMPILE_FMA3
-#define CV_FMA3 1
-#endif
-
-#if defined _WIN32 && (defined(_M_ARM) || defined(_M_ARM64)) &&                \
-    (defined(CV_CPU_COMPILE_NEON) || !defined(_MSC_VER))
-#include <Intrin.h>
-#include <arm_neon.h>
-#define CV_NEON 1
-#elif defined(__ARM_NEON)
-#include <arm_neon.h>
-#define CV_NEON 1
-#endif
-
-/* RVV-related macro states with different compiler
-// +--------------------+----------+----------+
-// | Macro              | Upstream | XuanTie  |
-// +--------------------+----------+----------+
-// | CV_CPU_COMPILE_RVV | defined  | defined  |
-// | CV_RVV             | 1        | 0        |
-// | CV_RVV071          | 0        | 1        |
-// | CV_TRY_RVV         | 1        | 1        |
-// +--------------------+----------+----------+
-*/
-#ifdef CV_CPU_COMPILE_RVV
-#ifdef __riscv_vector_071
-#define CV_RVV071 1
-#else
-#define CV_RVV 1
-#endif
-#include <riscv_vector.h>
-#endif
-
-#ifdef CV_CPU_COMPILE_VSX
-#include <altivec.h>
-#undef vector
-#undef pixel
-#undef bool
-#define CV_VSX 1
-#endif
-
-#ifdef CV_CPU_COMPILE_VSX3
-#define CV_VSX3 1
-#endif
-
-#ifdef CV_CPU_COMPILE_MSA
-#include "hal/msa_macros.h"
-#define CV_MSA 1
-#endif
-
-#ifdef CV_CPU_COMPILE_LSX
-#include <lsxintrin.h>
-#define CV_LSX 1
-#endif
-
-#ifdef CV_CPU_COMPILE_LASX
-#include <lasxintrin.h>
-#define CV_LASX 1
-#endif
-
-#ifdef __EMSCRIPTEN__
-#define CV_WASM_SIMD 1
-#include <wasm_simd128.h>
-#endif
-
-#endif // CV_ENABLE_INTRINSICS && !CV_DISABLE_OPTIMIZATION && !__CUDACC__
-
-#if defined CV_CPU_COMPILE_AVX && !defined CV_CPU_BASELINE_COMPILE_AVX
-struct VZeroUpperGuard {
-#ifdef __GNUC__
-  __attribute__((always_inline))
-#endif
-  inline VZeroUpperGuard() {
-    _mm256_zeroupper();
-  }
-#ifdef __GNUC__
-  __attribute__((always_inline))
-#endif
-  inline ~VZeroUpperGuard() {
-    _mm256_zeroupper();
-  }
-};
-#define __CV_AVX_GUARD                                                         \
-  VZeroUpperGuard __vzeroupper_guard;                                          \
-  CV_UNUSED(__vzeroupper_guard);
-#endif
-
-#ifdef __CV_AVX_GUARD
-#define CV_AVX_GUARD __CV_AVX_GUARD
-#else
-#define CV_AVX_GUARD
-#endif
-
-#endif // __OPENCV_BUILD
-
-#if !defined __OPENCV_BUILD /* Compatibility code */                           \
-    && !defined __CUDACC__  /* do not include SSE/AVX/NEON headers for NVCC    \
-                               compiler */
-#if defined __SSE2__ || defined _M_X64 ||                                      \
-    (defined _M_IX86_FP && _M_IX86_FP >= 2)
-#include <emmintrin.h>
-#define CV_MMX 1
-#define CV_SSE 1
-#define CV_SSE2 1
-#elif defined _WIN32 && (defined(_M_ARM) || defined(_M_ARM64)) &&              \
-    (defined(CV_CPU_COMPILE_NEON) || !defined(_MSC_VER))
-#include <Intrin.h>
-#include <arm_neon.h>
-#define CV_NEON 1
-#elif defined(__ARM_NEON)
-#include <arm_neon.h>
-#define CV_NEON 1
-#elif defined(__VSX__) && defined(__PPC64__) && defined(__LITTLE_ENDIAN__)
-#include <altivec.h>
-#undef vector
-#undef pixel
-#undef bool
-#define CV_VSX 1
-#endif
-
-#ifdef __F16C__
-#include <immintrin.h>
-#define CV_FP16 1
-#endif
-
-#endif // !__OPENCV_BUILD && !__CUDACC (Compatibility code)
-
-#ifndef CV_MMX
-#define CV_MMX 0
-#endif
-#ifndef CV_SSE
-#define CV_SSE 0
-#endif
-#ifndef CV_SSE2
-#define CV_SSE2 0
-#endif
-#ifndef CV_SSE3
-#define CV_SSE3 0
-#endif
-#ifndef CV_SSSE3
-#define CV_SSSE3 0
-#endif
-#ifndef CV_SSE4_1
-#define CV_SSE4_1 0
-#endif
-#ifndef CV_SSE4_2
-#define CV_SSE4_2 0
-#endif
-#ifndef CV_POPCNT
-#define CV_POPCNT 0
-#endif
-#ifndef CV_AVX
-#define CV_AVX 0
-#endif
-#ifndef CV_FP16
-#define CV_FP16 0
-#endif
-#ifndef CV_AVX2
-#define CV_AVX2 0
-#endif
-#ifndef CV_FMA3
-#define CV_FMA3 0
-#endif
-#ifndef CV_AVX_512F
-#define CV_AVX_512F 0
-#endif
-#ifndef CV_AVX_512BW
-#define CV_AVX_512BW 0
-#endif
-#ifndef CV_AVX_512CD
-#define CV_AVX_512CD 0
-#endif
-#ifndef CV_AVX_512DQ
-#define CV_AVX_512DQ 0
-#endif
-#ifndef CV_AVX_512ER
-#define CV_AVX_512ER 0
-#endif
-#ifndef CV_AVX_512IFMA
-#define CV_AVX_512IFMA 0
-#endif
-#define CV_AVX_512IFMA512 CV_AVX_512IFMA // deprecated
-#ifndef CV_AVX_512PF
-#define CV_AVX_512PF 0
-#endif
-#ifndef CV_AVX_512VBMI
-#define CV_AVX_512VBMI 0
-#endif
-#ifndef CV_AVX_512VL
-#define CV_AVX_512VL 0
-#endif
-#ifndef CV_AVX_5124FMAPS
-#define CV_AVX_5124FMAPS 0
-#endif
-#ifndef CV_AVX_5124VNNIW
-#define CV_AVX_5124VNNIW 0
-#endif
-#ifndef CV_AVX_512VPOPCNTDQ
-#define CV_AVX_512VPOPCNTDQ 0
-#endif
-#ifndef CV_AVX_512VNNI
-#define CV_AVX_512VNNI 0
-#endif
-#ifndef CV_AVX_512VBMI2
-#define CV_AVX_512VBMI2 0
-#endif
-#ifndef CV_AVX_512BITALG
-#define CV_AVX_512BITALG 0
-#endif
-#ifndef CV_AVX512_COMMON
-#define CV_AVX512_COMMON 0
-#endif
-#ifndef CV_AVX512_KNL
-#define CV_AVX512_KNL 0
-#endif
-#ifndef CV_AVX512_KNM
-#define CV_AVX512_KNM 0
-#endif
-#ifndef CV_AVX512_SKX
-#define CV_AVX512_SKX 0
-#endif
-#ifndef CV_AVX512_CNL
-#define CV_AVX512_CNL 0
-#endif
-#ifndef CV_AVX512_CLX
-#define CV_AVX512_CLX 0
-#endif
-#ifndef CV_AVX512_ICL
-#define CV_AVX512_ICL 0
-#endif
-
-#ifndef CV_NEON
-#define CV_NEON 0
-#endif
-
-#ifndef CV_RVV071
-#define CV_RVV071 0
-#endif
-
-#ifndef CV_VSX
-#define CV_VSX 0
-#endif
-
-#ifndef CV_VSX3
-#define CV_VSX3 0
-#endif
-
-#ifndef CV_MSA
-#define CV_MSA 0
-#endif
-
-#ifndef CV_WASM_SIMD
-#define CV_WASM_SIMD 0
-#endif
-
-#ifndef CV_RVV
-#define CV_RVV 0
-#endif
-
-#ifndef CV_LSX
-#define CV_LSX 0
-#endif
-
-#ifndef CV_LASX
-#define CV_LASX 0
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/cv_cpu_helper.h b/packages/react-native-executorch/third-party/include/opencv2/core/cv_cpu_helper.h
deleted file mode 100644
index 088eb47c0d..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/cv_cpu_helper.h
+++ /dev/null
@@ -1,856 +0,0 @@
-// AUTOGENERATED, DO NOT EDIT
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_SSE
-#define CV_TRY_SSE 1
-#define CV_CPU_FORCE_SSE 1
-#define CV_CPU_HAS_SUPPORT_SSE 1
-#define CV_CPU_CALL_SSE(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_SSE_(fn, args) return (opt_SSE::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_SSE
-#define CV_TRY_SSE 1
-#define CV_CPU_FORCE_SSE 0
-#define CV_CPU_HAS_SUPPORT_SSE (cv::checkHardwareSupport(CV_CPU_SSE))
-#define CV_CPU_CALL_SSE(fn, args)                                              \
-  if (CV_CPU_HAS_SUPPORT_SSE)                                                  \
-  return (opt_SSE::fn args)
-#define CV_CPU_CALL_SSE_(fn, args)                                             \
-  if (CV_CPU_HAS_SUPPORT_SSE)                                                  \
-  return (opt_SSE::fn args)
-#else
-#define CV_TRY_SSE 0
-#define CV_CPU_FORCE_SSE 0
-#define CV_CPU_HAS_SUPPORT_SSE 0
-#define CV_CPU_CALL_SSE(fn, args)
-#define CV_CPU_CALL_SSE_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_SSE(fn, args, mode, ...)                       \
-  CV_CPU_CALL_SSE(fn, args);                                                   \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_SSE2
-#define CV_TRY_SSE2 1
-#define CV_CPU_FORCE_SSE2 1
-#define CV_CPU_HAS_SUPPORT_SSE2 1
-#define CV_CPU_CALL_SSE2(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_SSE2_(fn, args) return (opt_SSE2::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_SSE2
-#define CV_TRY_SSE2 1
-#define CV_CPU_FORCE_SSE2 0
-#define CV_CPU_HAS_SUPPORT_SSE2 (cv::checkHardwareSupport(CV_CPU_SSE2))
-#define CV_CPU_CALL_SSE2(fn, args)                                             \
-  if (CV_CPU_HAS_SUPPORT_SSE2)                                                 \
-  return (opt_SSE2::fn args)
-#define CV_CPU_CALL_SSE2_(fn, args)                                            \
-  if (CV_CPU_HAS_SUPPORT_SSE2)                                                 \
-  return (opt_SSE2::fn args)
-#else
-#define CV_TRY_SSE2 0
-#define CV_CPU_FORCE_SSE2 0
-#define CV_CPU_HAS_SUPPORT_SSE2 0
-#define CV_CPU_CALL_SSE2(fn, args)
-#define CV_CPU_CALL_SSE2_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_SSE2(fn, args, mode, ...)                      \
-  CV_CPU_CALL_SSE2(fn, args);                                                  \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_SSE3
-#define CV_TRY_SSE3 1
-#define CV_CPU_FORCE_SSE3 1
-#define CV_CPU_HAS_SUPPORT_SSE3 1
-#define CV_CPU_CALL_SSE3(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_SSE3_(fn, args) return (opt_SSE3::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_SSE3
-#define CV_TRY_SSE3 1
-#define CV_CPU_FORCE_SSE3 0
-#define CV_CPU_HAS_SUPPORT_SSE3 (cv::checkHardwareSupport(CV_CPU_SSE3))
-#define CV_CPU_CALL_SSE3(fn, args)                                             \
-  if (CV_CPU_HAS_SUPPORT_SSE3)                                                 \
-  return (opt_SSE3::fn args)
-#define CV_CPU_CALL_SSE3_(fn, args)                                            \
-  if (CV_CPU_HAS_SUPPORT_SSE3)                                                 \
-  return (opt_SSE3::fn args)
-#else
-#define CV_TRY_SSE3 0
-#define CV_CPU_FORCE_SSE3 0
-#define CV_CPU_HAS_SUPPORT_SSE3 0
-#define CV_CPU_CALL_SSE3(fn, args)
-#define CV_CPU_CALL_SSE3_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_SSE3(fn, args, mode, ...)                      \
-  CV_CPU_CALL_SSE3(fn, args);                                                  \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_SSSE3
-#define CV_TRY_SSSE3 1
-#define CV_CPU_FORCE_SSSE3 1
-#define CV_CPU_HAS_SUPPORT_SSSE3 1
-#define CV_CPU_CALL_SSSE3(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_SSSE3_(fn, args) return (opt_SSSE3::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_SSSE3
-#define CV_TRY_SSSE3 1
-#define CV_CPU_FORCE_SSSE3 0
-#define CV_CPU_HAS_SUPPORT_SSSE3 (cv::checkHardwareSupport(CV_CPU_SSSE3))
-#define CV_CPU_CALL_SSSE3(fn, args)                                            \
-  if (CV_CPU_HAS_SUPPORT_SSSE3)                                                \
-  return (opt_SSSE3::fn args)
-#define CV_CPU_CALL_SSSE3_(fn, args)                                           \
-  if (CV_CPU_HAS_SUPPORT_SSSE3)                                                \
-  return (opt_SSSE3::fn args)
-#else
-#define CV_TRY_SSSE3 0
-#define CV_CPU_FORCE_SSSE3 0
-#define CV_CPU_HAS_SUPPORT_SSSE3 0
-#define CV_CPU_CALL_SSSE3(fn, args)
-#define CV_CPU_CALL_SSSE3_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_SSSE3(fn, args, mode, ...)                     \
-  CV_CPU_CALL_SSSE3(fn, args);                                                 \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_SSE4_1
-#define CV_TRY_SSE4_1 1
-#define CV_CPU_FORCE_SSE4_1 1
-#define CV_CPU_HAS_SUPPORT_SSE4_1 1
-#define CV_CPU_CALL_SSE4_1(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_SSE4_1_(fn, args) return (opt_SSE4_1::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_SSE4_1
-#define CV_TRY_SSE4_1 1
-#define CV_CPU_FORCE_SSE4_1 0
-#define CV_CPU_HAS_SUPPORT_SSE4_1 (cv::checkHardwareSupport(CV_CPU_SSE4_1))
-#define CV_CPU_CALL_SSE4_1(fn, args)                                           \
-  if (CV_CPU_HAS_SUPPORT_SSE4_1)                                               \
-  return (opt_SSE4_1::fn args)
-#define CV_CPU_CALL_SSE4_1_(fn, args)                                          \
-  if (CV_CPU_HAS_SUPPORT_SSE4_1)                                               \
-  return (opt_SSE4_1::fn args)
-#else
-#define CV_TRY_SSE4_1 0
-#define CV_CPU_FORCE_SSE4_1 0
-#define CV_CPU_HAS_SUPPORT_SSE4_1 0
-#define CV_CPU_CALL_SSE4_1(fn, args)
-#define CV_CPU_CALL_SSE4_1_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_SSE4_1(fn, args, mode, ...)                    \
-  CV_CPU_CALL_SSE4_1(fn, args);                                                \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_SSE4_2
-#define CV_TRY_SSE4_2 1
-#define CV_CPU_FORCE_SSE4_2 1
-#define CV_CPU_HAS_SUPPORT_SSE4_2 1
-#define CV_CPU_CALL_SSE4_2(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_SSE4_2_(fn, args) return (opt_SSE4_2::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_SSE4_2
-#define CV_TRY_SSE4_2 1
-#define CV_CPU_FORCE_SSE4_2 0
-#define CV_CPU_HAS_SUPPORT_SSE4_2 (cv::checkHardwareSupport(CV_CPU_SSE4_2))
-#define CV_CPU_CALL_SSE4_2(fn, args)                                           \
-  if (CV_CPU_HAS_SUPPORT_SSE4_2)                                               \
-  return (opt_SSE4_2::fn args)
-#define CV_CPU_CALL_SSE4_2_(fn, args)                                          \
-  if (CV_CPU_HAS_SUPPORT_SSE4_2)                                               \
-  return (opt_SSE4_2::fn args)
-#else
-#define CV_TRY_SSE4_2 0
-#define CV_CPU_FORCE_SSE4_2 0
-#define CV_CPU_HAS_SUPPORT_SSE4_2 0
-#define CV_CPU_CALL_SSE4_2(fn, args)
-#define CV_CPU_CALL_SSE4_2_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_SSE4_2(fn, args, mode, ...)                    \
-  CV_CPU_CALL_SSE4_2(fn, args);                                                \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_POPCNT
-#define CV_TRY_POPCNT 1
-#define CV_CPU_FORCE_POPCNT 1
-#define CV_CPU_HAS_SUPPORT_POPCNT 1
-#define CV_CPU_CALL_POPCNT(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_POPCNT_(fn, args) return (opt_POPCNT::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_POPCNT
-#define CV_TRY_POPCNT 1
-#define CV_CPU_FORCE_POPCNT 0
-#define CV_CPU_HAS_SUPPORT_POPCNT (cv::checkHardwareSupport(CV_CPU_POPCNT))
-#define CV_CPU_CALL_POPCNT(fn, args)                                           \
-  if (CV_CPU_HAS_SUPPORT_POPCNT)                                               \
-  return (opt_POPCNT::fn args)
-#define CV_CPU_CALL_POPCNT_(fn, args)                                          \
-  if (CV_CPU_HAS_SUPPORT_POPCNT)                                               \
-  return (opt_POPCNT::fn args)
-#else
-#define CV_TRY_POPCNT 0
-#define CV_CPU_FORCE_POPCNT 0
-#define CV_CPU_HAS_SUPPORT_POPCNT 0
-#define CV_CPU_CALL_POPCNT(fn, args)
-#define CV_CPU_CALL_POPCNT_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_POPCNT(fn, args, mode, ...)                    \
-  CV_CPU_CALL_POPCNT(fn, args);                                                \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_AVX
-#define CV_TRY_AVX 1
-#define CV_CPU_FORCE_AVX 1
-#define CV_CPU_HAS_SUPPORT_AVX 1
-#define CV_CPU_CALL_AVX(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_AVX_(fn, args) return (opt_AVX::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_AVX
-#define CV_TRY_AVX 1
-#define CV_CPU_FORCE_AVX 0
-#define CV_CPU_HAS_SUPPORT_AVX (cv::checkHardwareSupport(CV_CPU_AVX))
-#define CV_CPU_CALL_AVX(fn, args)                                              \
-  if (CV_CPU_HAS_SUPPORT_AVX)                                                  \
-  return (opt_AVX::fn args)
-#define CV_CPU_CALL_AVX_(fn, args)                                             \
-  if (CV_CPU_HAS_SUPPORT_AVX)                                                  \
-  return (opt_AVX::fn args)
-#else
-#define CV_TRY_AVX 0
-#define CV_CPU_FORCE_AVX 0
-#define CV_CPU_HAS_SUPPORT_AVX 0
-#define CV_CPU_CALL_AVX(fn, args)
-#define CV_CPU_CALL_AVX_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_AVX(fn, args, mode, ...)                       \
-  CV_CPU_CALL_AVX(fn, args);                                                   \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_FP16
-#define CV_TRY_FP16 1
-#define CV_CPU_FORCE_FP16 1
-#define CV_CPU_HAS_SUPPORT_FP16 1
-#define CV_CPU_CALL_FP16(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_FP16_(fn, args) return (opt_FP16::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_FP16
-#define CV_TRY_FP16 1
-#define CV_CPU_FORCE_FP16 0
-#define CV_CPU_HAS_SUPPORT_FP16 (cv::checkHardwareSupport(CV_CPU_FP16))
-#define CV_CPU_CALL_FP16(fn, args)                                             \
-  if (CV_CPU_HAS_SUPPORT_FP16)                                                 \
-  return (opt_FP16::fn args)
-#define CV_CPU_CALL_FP16_(fn, args)                                            \
-  if (CV_CPU_HAS_SUPPORT_FP16)                                                 \
-  return (opt_FP16::fn args)
-#else
-#define CV_TRY_FP16 0
-#define CV_CPU_FORCE_FP16 0
-#define CV_CPU_HAS_SUPPORT_FP16 0
-#define CV_CPU_CALL_FP16(fn, args)
-#define CV_CPU_CALL_FP16_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_FP16(fn, args, mode, ...)                      \
-  CV_CPU_CALL_FP16(fn, args);                                                  \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_AVX2
-#define CV_TRY_AVX2 1
-#define CV_CPU_FORCE_AVX2 1
-#define CV_CPU_HAS_SUPPORT_AVX2 1
-#define CV_CPU_CALL_AVX2(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_AVX2_(fn, args) return (opt_AVX2::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_AVX2
-#define CV_TRY_AVX2 1
-#define CV_CPU_FORCE_AVX2 0
-#define CV_CPU_HAS_SUPPORT_AVX2 (cv::checkHardwareSupport(CV_CPU_AVX2))
-#define CV_CPU_CALL_AVX2(fn, args)                                             \
-  if (CV_CPU_HAS_SUPPORT_AVX2)                                                 \
-  return (opt_AVX2::fn args)
-#define CV_CPU_CALL_AVX2_(fn, args)                                            \
-  if (CV_CPU_HAS_SUPPORT_AVX2)                                                 \
-  return (opt_AVX2::fn args)
-#else
-#define CV_TRY_AVX2 0
-#define CV_CPU_FORCE_AVX2 0
-#define CV_CPU_HAS_SUPPORT_AVX2 0
-#define CV_CPU_CALL_AVX2(fn, args)
-#define CV_CPU_CALL_AVX2_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_AVX2(fn, args, mode, ...)                      \
-  CV_CPU_CALL_AVX2(fn, args);                                                  \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_FMA3
-#define CV_TRY_FMA3 1
-#define CV_CPU_FORCE_FMA3 1
-#define CV_CPU_HAS_SUPPORT_FMA3 1
-#define CV_CPU_CALL_FMA3(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_FMA3_(fn, args) return (opt_FMA3::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_FMA3
-#define CV_TRY_FMA3 1
-#define CV_CPU_FORCE_FMA3 0
-#define CV_CPU_HAS_SUPPORT_FMA3 (cv::checkHardwareSupport(CV_CPU_FMA3))
-#define CV_CPU_CALL_FMA3(fn, args)                                             \
-  if (CV_CPU_HAS_SUPPORT_FMA3)                                                 \
-  return (opt_FMA3::fn args)
-#define CV_CPU_CALL_FMA3_(fn, args)                                            \
-  if (CV_CPU_HAS_SUPPORT_FMA3)                                                 \
-  return (opt_FMA3::fn args)
-#else
-#define CV_TRY_FMA3 0
-#define CV_CPU_FORCE_FMA3 0
-#define CV_CPU_HAS_SUPPORT_FMA3 0
-#define CV_CPU_CALL_FMA3(fn, args)
-#define CV_CPU_CALL_FMA3_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_FMA3(fn, args, mode, ...)                      \
-  CV_CPU_CALL_FMA3(fn, args);                                                  \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_AVX_512F
-#define CV_TRY_AVX_512F 1
-#define CV_CPU_FORCE_AVX_512F 1
-#define CV_CPU_HAS_SUPPORT_AVX_512F 1
-#define CV_CPU_CALL_AVX_512F(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_AVX_512F_(fn, args) return (opt_AVX_512F::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_AVX_512F
-#define CV_TRY_AVX_512F 1
-#define CV_CPU_FORCE_AVX_512F 0
-#define CV_CPU_HAS_SUPPORT_AVX_512F (cv::checkHardwareSupport(CV_CPU_AVX_512F))
-#define CV_CPU_CALL_AVX_512F(fn, args)                                         \
-  if (CV_CPU_HAS_SUPPORT_AVX_512F)                                             \
-  return (opt_AVX_512F::fn args)
-#define CV_CPU_CALL_AVX_512F_(fn, args)                                        \
-  if (CV_CPU_HAS_SUPPORT_AVX_512F)                                             \
-  return (opt_AVX_512F::fn args)
-#else
-#define CV_TRY_AVX_512F 0
-#define CV_CPU_FORCE_AVX_512F 0
-#define CV_CPU_HAS_SUPPORT_AVX_512F 0
-#define CV_CPU_CALL_AVX_512F(fn, args)
-#define CV_CPU_CALL_AVX_512F_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_AVX_512F(fn, args, mode, ...)                  \
-  CV_CPU_CALL_AVX_512F(fn, args);                                              \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_AVX512_COMMON
-#define CV_TRY_AVX512_COMMON 1
-#define CV_CPU_FORCE_AVX512_COMMON 1
-#define CV_CPU_HAS_SUPPORT_AVX512_COMMON 1
-#define CV_CPU_CALL_AVX512_COMMON(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_AVX512_COMMON_(fn, args) return (opt_AVX512_COMMON::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_AVX512_COMMON
-#define CV_TRY_AVX512_COMMON 1
-#define CV_CPU_FORCE_AVX512_COMMON 0
-#define CV_CPU_HAS_SUPPORT_AVX512_COMMON                                       \
-  (cv::checkHardwareSupport(CV_CPU_AVX512_COMMON))
-#define CV_CPU_CALL_AVX512_COMMON(fn, args)                                    \
-  if (CV_CPU_HAS_SUPPORT_AVX512_COMMON)                                        \
-  return (opt_AVX512_COMMON::fn args)
-#define CV_CPU_CALL_AVX512_COMMON_(fn, args)                                   \
-  if (CV_CPU_HAS_SUPPORT_AVX512_COMMON)                                        \
-  return (opt_AVX512_COMMON::fn args)
-#else
-#define CV_TRY_AVX512_COMMON 0
-#define CV_CPU_FORCE_AVX512_COMMON 0
-#define CV_CPU_HAS_SUPPORT_AVX512_COMMON 0
-#define CV_CPU_CALL_AVX512_COMMON(fn, args)
-#define CV_CPU_CALL_AVX512_COMMON_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_AVX512_COMMON(fn, args, mode, ...)             \
-  CV_CPU_CALL_AVX512_COMMON(fn, args);                                         \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_AVX512_KNL
-#define CV_TRY_AVX512_KNL 1
-#define CV_CPU_FORCE_AVX512_KNL 1
-#define CV_CPU_HAS_SUPPORT_AVX512_KNL 1
-#define CV_CPU_CALL_AVX512_KNL(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_AVX512_KNL_(fn, args) return (opt_AVX512_KNL::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_AVX512_KNL
-#define CV_TRY_AVX512_KNL 1
-#define CV_CPU_FORCE_AVX512_KNL 0
-#define CV_CPU_HAS_SUPPORT_AVX512_KNL                                          \
-  (cv::checkHardwareSupport(CV_CPU_AVX512_KNL))
-#define CV_CPU_CALL_AVX512_KNL(fn, args)                                       \
-  if (CV_CPU_HAS_SUPPORT_AVX512_KNL)                                           \
-  return (opt_AVX512_KNL::fn args)
-#define CV_CPU_CALL_AVX512_KNL_(fn, args)                                      \
-  if (CV_CPU_HAS_SUPPORT_AVX512_KNL)                                           \
-  return (opt_AVX512_KNL::fn args)
-#else
-#define CV_TRY_AVX512_KNL 0
-#define CV_CPU_FORCE_AVX512_KNL 0
-#define CV_CPU_HAS_SUPPORT_AVX512_KNL 0
-#define CV_CPU_CALL_AVX512_KNL(fn, args)
-#define CV_CPU_CALL_AVX512_KNL_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_AVX512_KNL(fn, args, mode, ...)                \
-  CV_CPU_CALL_AVX512_KNL(fn, args);                                            \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_AVX512_KNM
-#define CV_TRY_AVX512_KNM 1
-#define CV_CPU_FORCE_AVX512_KNM 1
-#define CV_CPU_HAS_SUPPORT_AVX512_KNM 1
-#define CV_CPU_CALL_AVX512_KNM(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_AVX512_KNM_(fn, args) return (opt_AVX512_KNM::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_AVX512_KNM
-#define CV_TRY_AVX512_KNM 1
-#define CV_CPU_FORCE_AVX512_KNM 0
-#define CV_CPU_HAS_SUPPORT_AVX512_KNM                                          \
-  (cv::checkHardwareSupport(CV_CPU_AVX512_KNM))
-#define CV_CPU_CALL_AVX512_KNM(fn, args)                                       \
-  if (CV_CPU_HAS_SUPPORT_AVX512_KNM)                                           \
-  return (opt_AVX512_KNM::fn args)
-#define CV_CPU_CALL_AVX512_KNM_(fn, args)                                      \
-  if (CV_CPU_HAS_SUPPORT_AVX512_KNM)                                           \
-  return (opt_AVX512_KNM::fn args)
-#else
-#define CV_TRY_AVX512_KNM 0
-#define CV_CPU_FORCE_AVX512_KNM 0
-#define CV_CPU_HAS_SUPPORT_AVX512_KNM 0
-#define CV_CPU_CALL_AVX512_KNM(fn, args)
-#define CV_CPU_CALL_AVX512_KNM_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_AVX512_KNM(fn, args, mode, ...)                \
-  CV_CPU_CALL_AVX512_KNM(fn, args);                                            \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_AVX512_SKX
-#define CV_TRY_AVX512_SKX 1
-#define CV_CPU_FORCE_AVX512_SKX 1
-#define CV_CPU_HAS_SUPPORT_AVX512_SKX 1
-#define CV_CPU_CALL_AVX512_SKX(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_AVX512_SKX_(fn, args) return (opt_AVX512_SKX::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_AVX512_SKX
-#define CV_TRY_AVX512_SKX 1
-#define CV_CPU_FORCE_AVX512_SKX 0
-#define CV_CPU_HAS_SUPPORT_AVX512_SKX                                          \
-  (cv::checkHardwareSupport(CV_CPU_AVX512_SKX))
-#define CV_CPU_CALL_AVX512_SKX(fn, args)                                       \
-  if (CV_CPU_HAS_SUPPORT_AVX512_SKX)                                           \
-  return (opt_AVX512_SKX::fn args)
-#define CV_CPU_CALL_AVX512_SKX_(fn, args)                                      \
-  if (CV_CPU_HAS_SUPPORT_AVX512_SKX)                                           \
-  return (opt_AVX512_SKX::fn args)
-#else
-#define CV_TRY_AVX512_SKX 0
-#define CV_CPU_FORCE_AVX512_SKX 0
-#define CV_CPU_HAS_SUPPORT_AVX512_SKX 0
-#define CV_CPU_CALL_AVX512_SKX(fn, args)
-#define CV_CPU_CALL_AVX512_SKX_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_AVX512_SKX(fn, args, mode, ...)                \
-  CV_CPU_CALL_AVX512_SKX(fn, args);                                            \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_AVX512_CNL
-#define CV_TRY_AVX512_CNL 1
-#define CV_CPU_FORCE_AVX512_CNL 1
-#define CV_CPU_HAS_SUPPORT_AVX512_CNL 1
-#define CV_CPU_CALL_AVX512_CNL(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_AVX512_CNL_(fn, args) return (opt_AVX512_CNL::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_AVX512_CNL
-#define CV_TRY_AVX512_CNL 1
-#define CV_CPU_FORCE_AVX512_CNL 0
-#define CV_CPU_HAS_SUPPORT_AVX512_CNL                                          \
-  (cv::checkHardwareSupport(CV_CPU_AVX512_CNL))
-#define CV_CPU_CALL_AVX512_CNL(fn, args)                                       \
-  if (CV_CPU_HAS_SUPPORT_AVX512_CNL)                                           \
-  return (opt_AVX512_CNL::fn args)
-#define CV_CPU_CALL_AVX512_CNL_(fn, args)                                      \
-  if (CV_CPU_HAS_SUPPORT_AVX512_CNL)                                           \
-  return (opt_AVX512_CNL::fn args)
-#else
-#define CV_TRY_AVX512_CNL 0
-#define CV_CPU_FORCE_AVX512_CNL 0
-#define CV_CPU_HAS_SUPPORT_AVX512_CNL 0
-#define CV_CPU_CALL_AVX512_CNL(fn, args)
-#define CV_CPU_CALL_AVX512_CNL_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_AVX512_CNL(fn, args, mode, ...)                \
-  CV_CPU_CALL_AVX512_CNL(fn, args);                                            \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_AVX512_CLX
-#define CV_TRY_AVX512_CLX 1
-#define CV_CPU_FORCE_AVX512_CLX 1
-#define CV_CPU_HAS_SUPPORT_AVX512_CLX 1
-#define CV_CPU_CALL_AVX512_CLX(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_AVX512_CLX_(fn, args) return (opt_AVX512_CLX::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_AVX512_CLX
-#define CV_TRY_AVX512_CLX 1
-#define CV_CPU_FORCE_AVX512_CLX 0
-#define CV_CPU_HAS_SUPPORT_AVX512_CLX                                          \
-  (cv::checkHardwareSupport(CV_CPU_AVX512_CLX))
-#define CV_CPU_CALL_AVX512_CLX(fn, args)                                       \
-  if (CV_CPU_HAS_SUPPORT_AVX512_CLX)                                           \
-  return (opt_AVX512_CLX::fn args)
-#define CV_CPU_CALL_AVX512_CLX_(fn, args)                                      \
-  if (CV_CPU_HAS_SUPPORT_AVX512_CLX)                                           \
-  return (opt_AVX512_CLX::fn args)
-#else
-#define CV_TRY_AVX512_CLX 0
-#define CV_CPU_FORCE_AVX512_CLX 0
-#define CV_CPU_HAS_SUPPORT_AVX512_CLX 0
-#define CV_CPU_CALL_AVX512_CLX(fn, args)
-#define CV_CPU_CALL_AVX512_CLX_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_AVX512_CLX(fn, args, mode, ...)                \
-  CV_CPU_CALL_AVX512_CLX(fn, args);                                            \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_AVX512_ICL
-#define CV_TRY_AVX512_ICL 1
-#define CV_CPU_FORCE_AVX512_ICL 1
-#define CV_CPU_HAS_SUPPORT_AVX512_ICL 1
-#define CV_CPU_CALL_AVX512_ICL(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_AVX512_ICL_(fn, args) return (opt_AVX512_ICL::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_AVX512_ICL
-#define CV_TRY_AVX512_ICL 1
-#define CV_CPU_FORCE_AVX512_ICL 0
-#define CV_CPU_HAS_SUPPORT_AVX512_ICL                                          \
-  (cv::checkHardwareSupport(CV_CPU_AVX512_ICL))
-#define CV_CPU_CALL_AVX512_ICL(fn, args)                                       \
-  if (CV_CPU_HAS_SUPPORT_AVX512_ICL)                                           \
-  return (opt_AVX512_ICL::fn args)
-#define CV_CPU_CALL_AVX512_ICL_(fn, args)                                      \
-  if (CV_CPU_HAS_SUPPORT_AVX512_ICL)                                           \
-  return (opt_AVX512_ICL::fn args)
-#else
-#define CV_TRY_AVX512_ICL 0
-#define CV_CPU_FORCE_AVX512_ICL 0
-#define CV_CPU_HAS_SUPPORT_AVX512_ICL 0
-#define CV_CPU_CALL_AVX512_ICL(fn, args)
-#define CV_CPU_CALL_AVX512_ICL_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_AVX512_ICL(fn, args, mode, ...)                \
-  CV_CPU_CALL_AVX512_ICL(fn, args);                                            \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_NEON
-#define CV_TRY_NEON 1
-#define CV_CPU_FORCE_NEON 1
-#define CV_CPU_HAS_SUPPORT_NEON 1
-#define CV_CPU_CALL_NEON(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_NEON_(fn, args) return (opt_NEON::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_NEON
-#define CV_TRY_NEON 1
-#define CV_CPU_FORCE_NEON 0
-#define CV_CPU_HAS_SUPPORT_NEON (cv::checkHardwareSupport(CV_CPU_NEON))
-#define CV_CPU_CALL_NEON(fn, args)                                             \
-  if (CV_CPU_HAS_SUPPORT_NEON)                                                 \
-  return (opt_NEON::fn args)
-#define CV_CPU_CALL_NEON_(fn, args)                                            \
-  if (CV_CPU_HAS_SUPPORT_NEON)                                                 \
-  return (opt_NEON::fn args)
-#else
-#define CV_TRY_NEON 0
-#define CV_CPU_FORCE_NEON 0
-#define CV_CPU_HAS_SUPPORT_NEON 0
-#define CV_CPU_CALL_NEON(fn, args)
-#define CV_CPU_CALL_NEON_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_NEON(fn, args, mode, ...)                      \
-  CV_CPU_CALL_NEON(fn, args);                                                  \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_NEON_DOTPROD
-#define CV_TRY_NEON_DOTPROD 1
-#define CV_CPU_FORCE_NEON_DOTPROD 1
-#define CV_CPU_HAS_SUPPORT_NEON_DOTPROD 1
-#define CV_CPU_CALL_NEON_DOTPROD(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_NEON_DOTPROD_(fn, args) return (opt_NEON_DOTPROD::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_NEON_DOTPROD
-#define CV_TRY_NEON_DOTPROD 1
-#define CV_CPU_FORCE_NEON_DOTPROD 0
-#define CV_CPU_HAS_SUPPORT_NEON_DOTPROD                                        \
-  (cv::checkHardwareSupport(CV_CPU_NEON_DOTPROD))
-#define CV_CPU_CALL_NEON_DOTPROD(fn, args)                                     \
-  if (CV_CPU_HAS_SUPPORT_NEON_DOTPROD)                                         \
-  return (opt_NEON_DOTPROD::fn args)
-#define CV_CPU_CALL_NEON_DOTPROD_(fn, args)                                    \
-  if (CV_CPU_HAS_SUPPORT_NEON_DOTPROD)                                         \
-  return (opt_NEON_DOTPROD::fn args)
-#else
-#define CV_TRY_NEON_DOTPROD 0
-#define CV_CPU_FORCE_NEON_DOTPROD 0
-#define CV_CPU_HAS_SUPPORT_NEON_DOTPROD 0
-#define CV_CPU_CALL_NEON_DOTPROD(fn, args)
-#define CV_CPU_CALL_NEON_DOTPROD_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_NEON_DOTPROD(fn, args, mode, ...)              \
-  CV_CPU_CALL_NEON_DOTPROD(fn, args);                                          \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_NEON_FP16
-#define CV_TRY_NEON_FP16 1
-#define CV_CPU_FORCE_NEON_FP16 1
-#define CV_CPU_HAS_SUPPORT_NEON_FP16 1
-#define CV_CPU_CALL_NEON_FP16(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_NEON_FP16_(fn, args) return (opt_NEON_FP16::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_NEON_FP16
-#define CV_TRY_NEON_FP16 1
-#define CV_CPU_FORCE_NEON_FP16 0
-#define CV_CPU_HAS_SUPPORT_NEON_FP16                                           \
-  (cv::checkHardwareSupport(CV_CPU_NEON_FP16))
-#define CV_CPU_CALL_NEON_FP16(fn, args)                                        \
-  if (CV_CPU_HAS_SUPPORT_NEON_FP16)                                            \
-  return (opt_NEON_FP16::fn args)
-#define CV_CPU_CALL_NEON_FP16_(fn, args)                                       \
-  if (CV_CPU_HAS_SUPPORT_NEON_FP16)                                            \
-  return (opt_NEON_FP16::fn args)
-#else
-#define CV_TRY_NEON_FP16 0
-#define CV_CPU_FORCE_NEON_FP16 0
-#define CV_CPU_HAS_SUPPORT_NEON_FP16 0
-#define CV_CPU_CALL_NEON_FP16(fn, args)
-#define CV_CPU_CALL_NEON_FP16_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_NEON_FP16(fn, args, mode, ...)                 \
-  CV_CPU_CALL_NEON_FP16(fn, args);                                             \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_NEON_BF16
-#define CV_TRY_NEON_BF16 1
-#define CV_CPU_FORCE_NEON_BF16 1
-#define CV_CPU_HAS_SUPPORT_NEON_BF16 1
-#define CV_CPU_CALL_NEON_BF16(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_NEON_BF16_(fn, args) return (opt_NEON_BF16::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_NEON_BF16
-#define CV_TRY_NEON_BF16 1
-#define CV_CPU_FORCE_NEON_BF16 0
-#define CV_CPU_HAS_SUPPORT_NEON_BF16                                           \
-  (cv::checkHardwareSupport(CV_CPU_NEON_BF16))
-#define CV_CPU_CALL_NEON_BF16(fn, args)                                        \
-  if (CV_CPU_HAS_SUPPORT_NEON_BF16)                                            \
-  return (opt_NEON_BF16::fn args)
-#define CV_CPU_CALL_NEON_BF16_(fn, args)                                       \
-  if (CV_CPU_HAS_SUPPORT_NEON_BF16)                                            \
-  return (opt_NEON_BF16::fn args)
-#else
-#define CV_TRY_NEON_BF16 0
-#define CV_CPU_FORCE_NEON_BF16 0
-#define CV_CPU_HAS_SUPPORT_NEON_BF16 0
-#define CV_CPU_CALL_NEON_BF16(fn, args)
-#define CV_CPU_CALL_NEON_BF16_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_NEON_BF16(fn, args, mode, ...)                 \
-  CV_CPU_CALL_NEON_BF16(fn, args);                                             \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_MSA
-#define CV_TRY_MSA 1
-#define CV_CPU_FORCE_MSA 1
-#define CV_CPU_HAS_SUPPORT_MSA 1
-#define CV_CPU_CALL_MSA(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_MSA_(fn, args) return (opt_MSA::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_MSA
-#define CV_TRY_MSA 1
-#define CV_CPU_FORCE_MSA 0
-#define CV_CPU_HAS_SUPPORT_MSA (cv::checkHardwareSupport(CV_CPU_MSA))
-#define CV_CPU_CALL_MSA(fn, args)                                              \
-  if (CV_CPU_HAS_SUPPORT_MSA)                                                  \
-  return (opt_MSA::fn args)
-#define CV_CPU_CALL_MSA_(fn, args)                                             \
-  if (CV_CPU_HAS_SUPPORT_MSA)                                                  \
-  return (opt_MSA::fn args)
-#else
-#define CV_TRY_MSA 0
-#define CV_CPU_FORCE_MSA 0
-#define CV_CPU_HAS_SUPPORT_MSA 0
-#define CV_CPU_CALL_MSA(fn, args)
-#define CV_CPU_CALL_MSA_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_MSA(fn, args, mode, ...)                       \
-  CV_CPU_CALL_MSA(fn, args);                                                   \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_VSX
-#define CV_TRY_VSX 1
-#define CV_CPU_FORCE_VSX 1
-#define CV_CPU_HAS_SUPPORT_VSX 1
-#define CV_CPU_CALL_VSX(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_VSX_(fn, args) return (opt_VSX::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_VSX
-#define CV_TRY_VSX 1
-#define CV_CPU_FORCE_VSX 0
-#define CV_CPU_HAS_SUPPORT_VSX (cv::checkHardwareSupport(CV_CPU_VSX))
-#define CV_CPU_CALL_VSX(fn, args)                                              \
-  if (CV_CPU_HAS_SUPPORT_VSX)                                                  \
-  return (opt_VSX::fn args)
-#define CV_CPU_CALL_VSX_(fn, args)                                             \
-  if (CV_CPU_HAS_SUPPORT_VSX)                                                  \
-  return (opt_VSX::fn args)
-#else
-#define CV_TRY_VSX 0
-#define CV_CPU_FORCE_VSX 0
-#define CV_CPU_HAS_SUPPORT_VSX 0
-#define CV_CPU_CALL_VSX(fn, args)
-#define CV_CPU_CALL_VSX_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_VSX(fn, args, mode, ...)                       \
-  CV_CPU_CALL_VSX(fn, args);                                                   \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_VSX3
-#define CV_TRY_VSX3 1
-#define CV_CPU_FORCE_VSX3 1
-#define CV_CPU_HAS_SUPPORT_VSX3 1
-#define CV_CPU_CALL_VSX3(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_VSX3_(fn, args) return (opt_VSX3::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_VSX3
-#define CV_TRY_VSX3 1
-#define CV_CPU_FORCE_VSX3 0
-#define CV_CPU_HAS_SUPPORT_VSX3 (cv::checkHardwareSupport(CV_CPU_VSX3))
-#define CV_CPU_CALL_VSX3(fn, args)                                             \
-  if (CV_CPU_HAS_SUPPORT_VSX3)                                                 \
-  return (opt_VSX3::fn args)
-#define CV_CPU_CALL_VSX3_(fn, args)                                            \
-  if (CV_CPU_HAS_SUPPORT_VSX3)                                                 \
-  return (opt_VSX3::fn args)
-#else
-#define CV_TRY_VSX3 0
-#define CV_CPU_FORCE_VSX3 0
-#define CV_CPU_HAS_SUPPORT_VSX3 0
-#define CV_CPU_CALL_VSX3(fn, args)
-#define CV_CPU_CALL_VSX3_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_VSX3(fn, args, mode, ...)                      \
-  CV_CPU_CALL_VSX3(fn, args);                                                  \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_RVV
-#define CV_TRY_RVV 1
-#define CV_CPU_FORCE_RVV 1
-#define CV_CPU_HAS_SUPPORT_RVV 1
-#define CV_CPU_CALL_RVV(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_RVV_(fn, args) return (opt_RVV::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_RVV
-#define CV_TRY_RVV 1
-#define CV_CPU_FORCE_RVV 0
-#define CV_CPU_HAS_SUPPORT_RVV (cv::checkHardwareSupport(CV_CPU_RVV))
-#define CV_CPU_CALL_RVV(fn, args)                                              \
-  if (CV_CPU_HAS_SUPPORT_RVV)                                                  \
-  return (opt_RVV::fn args)
-#define CV_CPU_CALL_RVV_(fn, args)                                             \
-  if (CV_CPU_HAS_SUPPORT_RVV)                                                  \
-  return (opt_RVV::fn args)
-#else
-#define CV_TRY_RVV 0
-#define CV_CPU_FORCE_RVV 0
-#define CV_CPU_HAS_SUPPORT_RVV 0
-#define CV_CPU_CALL_RVV(fn, args)
-#define CV_CPU_CALL_RVV_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_RVV(fn, args, mode, ...)                       \
-  CV_CPU_CALL_RVV(fn, args);                                                   \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_LSX
-#define CV_TRY_LSX 1
-#define CV_CPU_FORCE_LSX 1
-#define CV_CPU_HAS_SUPPORT_LSX 1
-#define CV_CPU_CALL_LSX(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_LSX_(fn, args) return (opt_LSX::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_LSX
-#define CV_TRY_LSX 1
-#define CV_CPU_FORCE_LSX 0
-#define CV_CPU_HAS_SUPPORT_LSX (cv::checkHardwareSupport(CV_CPU_LSX))
-#define CV_CPU_CALL_LSX(fn, args)                                              \
-  if (CV_CPU_HAS_SUPPORT_LSX)                                                  \
-  return (opt_LSX::fn args)
-#define CV_CPU_CALL_LSX_(fn, args)                                             \
-  if (CV_CPU_HAS_SUPPORT_LSX)                                                  \
-  return (opt_LSX::fn args)
-#else
-#define CV_TRY_LSX 0
-#define CV_CPU_FORCE_LSX 0
-#define CV_CPU_HAS_SUPPORT_LSX 0
-#define CV_CPU_CALL_LSX(fn, args)
-#define CV_CPU_CALL_LSX_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_LSX(fn, args, mode, ...)                       \
-  CV_CPU_CALL_LSX(fn, args);                                                   \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#if !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&        \
-    defined CV_CPU_COMPILE_LASX
-#define CV_TRY_LASX 1
-#define CV_CPU_FORCE_LASX 1
-#define CV_CPU_HAS_SUPPORT_LASX 1
-#define CV_CPU_CALL_LASX(fn, args) return (cpu_baseline::fn args)
-#define CV_CPU_CALL_LASX_(fn, args) return (opt_LASX::fn args)
-#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS &&      \
-    defined CV_CPU_DISPATCH_COMPILE_LASX
-#define CV_TRY_LASX 1
-#define CV_CPU_FORCE_LASX 0
-#define CV_CPU_HAS_SUPPORT_LASX (cv::checkHardwareSupport(CV_CPU_LASX))
-#define CV_CPU_CALL_LASX(fn, args)                                             \
-  if (CV_CPU_HAS_SUPPORT_LASX)                                                 \
-  return (opt_LASX::fn args)
-#define CV_CPU_CALL_LASX_(fn, args)                                            \
-  if (CV_CPU_HAS_SUPPORT_LASX)                                                 \
-  return (opt_LASX::fn args)
-#else
-#define CV_TRY_LASX 0
-#define CV_CPU_FORCE_LASX 0
-#define CV_CPU_HAS_SUPPORT_LASX 0
-#define CV_CPU_CALL_LASX(fn, args)
-#define CV_CPU_CALL_LASX_(fn, args)
-#endif
-#define __CV_CPU_DISPATCH_CHAIN_LASX(fn, args, mode, ...)                      \
-  CV_CPU_CALL_LASX(fn, args);                                                  \
-  __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_##mode(fn, args, __VA_ARGS__))
-
-#define CV_CPU_CALL_BASELINE(fn, args) return (cpu_baseline::fn args)
-#define __CV_CPU_DISPATCH_CHAIN_BASELINE(fn, args, mode, ...)                  \
-  CV_CPU_CALL_BASELINE(fn, args) /* last in sequence */
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/cvdef.h b/packages/react-native-executorch/third-party/include/opencv2/core/cvdef.h
deleted file mode 100644
index 105a4c3386..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/cvdef.h
+++ /dev/null
@@ -1,1003 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Copyright (C) 2015, Itseez Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_CORE_CVDEF_H
-#define OPENCV_CORE_CVDEF_H
-
-#include "opencv2/core/version.hpp"
-
-//! @addtogroup core_utils
-//! @{
-
-#ifdef OPENCV_INCLUDE_PORT_FILE // User-provided header file with custom
-                                // platform configuration
-#include OPENCV_INCLUDE_PORT_FILE
-#endif
-
-#if !defined CV_DOXYGEN && !defined CV_IGNORE_DEBUG_BUILD_GUARD
-#if (defined(_MSC_VER) && (defined(DEBUG) || defined(_DEBUG))) ||              \
-    (defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_DEBUG_PEDANTIC))
-// Guard to prevent using of binary incompatible binaries / runtimes
-// https://github.com/opencv/opencv/pull/9161
-#define CV__DEBUG_NS_BEGIN namespace debug_build_guard {
-#define CV__DEBUG_NS_END }
-namespace cv {
-namespace debug_build_guard {}
-using namespace debug_build_guard;
-} // namespace cv
-#endif
-#endif
-
-#ifndef CV__DEBUG_NS_BEGIN
-#define CV__DEBUG_NS_BEGIN
-#define CV__DEBUG_NS_END
-#endif
-
-#ifdef __OPENCV_BUILD
-#include "cvconfig.h"
-#endif
-
-#ifndef __CV_EXPAND
-#define __CV_EXPAND(x) x
-#endif
-
-#ifndef __CV_CAT
-#define __CV_CAT__(x, y) x##y
-#define __CV_CAT_(x, y) __CV_CAT__(x, y)
-#define __CV_CAT(x, y) __CV_CAT_(x, y)
-#endif
-
-#define __CV_VA_NUM_ARGS_HELPER(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N,    \
-                                ...)                                           \
-  N
-#define __CV_VA_NUM_ARGS(...)                                                  \
-  __CV_EXPAND(                                                                 \
-      __CV_VA_NUM_ARGS_HELPER(__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0))
-
-#ifdef CV_Func
-// keep current value (through OpenCV port file)
-#elif defined __GNUC__ || (defined(__cpluscplus) && (__cpluscplus >= 201103))
-#define CV_Func __func__
-#elif defined __clang__ && (__clang_minor__ * 100 + __clang_major__ >= 305)
-#define CV_Func __func__
-#elif defined(__STDC_VERSION__) && (__STDC_VERSION >= 199901)
-#define CV_Func __func__
-#elif defined _MSC_VER
-#define CV_Func __FUNCTION__
-#elif defined(__INTEL_COMPILER) && (_INTEL_COMPILER >= 600)
-#define CV_Func __FUNCTION__
-#elif defined __IBMCPP__ && __IBMCPP__ >= 500
-#define CV_Func __FUNCTION__
-#elif defined __BORLAND__ && (__BORLANDC__ >= 0x550)
-#define CV_Func __FUNC__
-#else
-#define CV_Func "<unknown>"
-#endif
-
-//! @cond IGNORED
-
-//////////////// static assert /////////////////
-#define CVAUX_CONCAT_EXP(a, b) a##b
-#define CVAUX_CONCAT(a, b) CVAUX_CONCAT_EXP(a, b)
-
-#if defined(__clang__)
-#ifndef __has_extension
-#define __has_extension                                                        \
-  __has_feature /* compatibility, for older versions of clang */
-#endif
-#if __has_extension(cxx_static_assert)
-#define CV_StaticAssert(condition, reason)                                     \
-  static_assert((condition), reason " " #condition)
-#elif __has_extension(c_static_assert)
-#define CV_StaticAssert(condition, reason)                                     \
-  _Static_assert((condition), reason " " #condition)
-#endif
-#elif defined(__GNUC__)
-#if (defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L)
-#define CV_StaticAssert(condition, reason)                                     \
-  static_assert((condition), reason " " #condition)
-#endif
-#elif defined(_MSC_VER)
-#if _MSC_VER >= 1600 /* MSVC 10 */
-#define CV_StaticAssert(condition, reason)                                     \
-  static_assert((condition), reason " " #condition)
-#endif
-#endif
-#ifndef CV_StaticAssert
-#if !defined(__clang__) && defined(__GNUC__) &&                                \
-    (__GNUC__ * 100 + __GNUC_MINOR__ > 302)
-#define CV_StaticAssert(condition, reason)                                     \
-  ({                                                                           \
-    extern int                                                                 \
-        __attribute__((error("CV_StaticAssert: " reason " " #condition)))      \
-        CV_StaticAssert();                                                     \
-    ((condition) ? 0 : CV_StaticAssert());                                     \
-  })
-#else
-namespace cv {
-template <bool x> struct CV_StaticAssert_failed;
-template <> struct CV_StaticAssert_failed<true> {
-  enum { val = 1 };
-};
-template <int x> struct CV_StaticAssert_test {};
-} // namespace cv
-#define CV_StaticAssert(condition, reason)                                     \
-  typedef cv::CV_StaticAssert_test<sizeof(                                     \
-      cv::CV_StaticAssert_failed<static_cast<bool>(condition)>)>               \
-  CVAUX_CONCAT(CV_StaticAssert_failed_at_, __LINE__)
-#endif
-#endif
-
-// Suppress warning "-Wdeprecated-declarations" / C4996
-#if defined(_MSC_VER)
-#define CV_DO_PRAGMA(x) __pragma(x)
-#elif defined(__GNUC__)
-#define CV_DO_PRAGMA(x) _Pragma(#x)
-#else
-#define CV_DO_PRAGMA(x)
-#endif
-
-#ifdef _MSC_VER
-#define CV_SUPPRESS_DEPRECATED_START                                           \
-  CV_DO_PRAGMA(warning(push))                                                  \
-  CV_DO_PRAGMA(warning(disable : 4996))
-#define CV_SUPPRESS_DEPRECATED_END CV_DO_PRAGMA(warning(pop))
-#elif defined(__clang__) ||                                                    \
-    ((__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ > 405))
-#define CV_SUPPRESS_DEPRECATED_START                                           \
-  CV_DO_PRAGMA(GCC diagnostic push)                                            \
-  CV_DO_PRAGMA(GCC diagnostic ignored "-Wdeprecated-declarations")
-#define CV_SUPPRESS_DEPRECATED_END CV_DO_PRAGMA(GCC diagnostic pop)
-#else
-#define CV_SUPPRESS_DEPRECATED_START
-#define CV_SUPPRESS_DEPRECATED_END
-#endif
-
-#define CV_UNUSED(name) (void)name
-
-//! @endcond
-
-// undef problematic defines sometimes defined by system headers (windows.h in
-// particular)
-#undef small
-#undef min
-#undef max
-#undef abs
-#undef Complex
-
-#if defined __cplusplus
-#include <limits>
-#else
-#include <limits.h>
-#endif
-
-#include "opencv2/core/hal/interface.h"
-
-#if defined __ICL
-#define CV_ICC __ICL
-#elif defined __ICC
-#define CV_ICC __ICC
-#elif defined __ECL
-#define CV_ICC __ECL
-#elif defined __ECC
-#define CV_ICC __ECC
-#elif defined __INTEL_COMPILER
-#define CV_ICC __INTEL_COMPILER
-#endif
-
-#if defined _WIN32
-#define CV_CDECL __cdecl
-#define CV_STDCALL __stdcall
-#else
-#define CV_CDECL
-#define CV_STDCALL
-#endif
-
-#ifndef CV_INLINE
-#if defined __cplusplus
-#define CV_INLINE static inline
-#elif defined _MSC_VER
-#define CV_INLINE __inline
-#else
-#define CV_INLINE static
-#endif
-#endif
-
-#ifndef CV_ALWAYS_INLINE
-#if defined(__GNUC__) &&                                                       \
-    (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
-#define CV_ALWAYS_INLINE inline __attribute__((always_inline))
-#elif defined(_MSC_VER)
-#define CV_ALWAYS_INLINE __forceinline
-#else
-#define CV_ALWAYS_INLINE inline
-#endif
-#endif
-
-#if defined CV_DISABLE_OPTIMIZATION ||                                         \
-    (defined CV_ICC && !defined CV_ENABLE_UNROLLED)
-#define CV_ENABLE_UNROLLED 0
-#else
-#define CV_ENABLE_UNROLLED 1
-#endif
-
-#ifdef __GNUC__
-#define CV_DECL_ALIGNED(x) __attribute__((aligned(x)))
-#elif defined _MSC_VER
-#define CV_DECL_ALIGNED(x) __declspec(align(x))
-#else
-#define CV_DECL_ALIGNED(x)
-#endif
-
-/* CPU features and intrinsics support */
-#define CV_CPU_NONE 0
-#define CV_CPU_MMX 1
-#define CV_CPU_SSE 2
-#define CV_CPU_SSE2 3
-#define CV_CPU_SSE3 4
-#define CV_CPU_SSSE3 5
-#define CV_CPU_SSE4_1 6
-#define CV_CPU_SSE4_2 7
-#define CV_CPU_POPCNT 8
-#define CV_CPU_FP16 9
-#define CV_CPU_AVX 10
-#define CV_CPU_AVX2 11
-#define CV_CPU_FMA3 12
-
-#define CV_CPU_AVX_512F 13
-#define CV_CPU_AVX_512BW 14
-#define CV_CPU_AVX_512CD 15
-#define CV_CPU_AVX_512DQ 16
-#define CV_CPU_AVX_512ER 17
-#define CV_CPU_AVX_512IFMA512 18 // deprecated
-#define CV_CPU_AVX_512IFMA 18
-#define CV_CPU_AVX_512PF 19
-#define CV_CPU_AVX_512VBMI 20
-#define CV_CPU_AVX_512VL 21
-#define CV_CPU_AVX_512VBMI2 22
-#define CV_CPU_AVX_512VNNI 23
-#define CV_CPU_AVX_512BITALG 24
-#define CV_CPU_AVX_512VPOPCNTDQ 25
-#define CV_CPU_AVX_5124VNNIW 26
-#define CV_CPU_AVX_5124FMAPS 27
-
-#define CV_CPU_NEON 100
-#define CV_CPU_NEON_DOTPROD 101
-#define CV_CPU_NEON_FP16 102
-#define CV_CPU_NEON_BF16 103
-
-#define CV_CPU_MSA 150
-
-#define CV_CPU_RISCVV 170
-
-#define CV_CPU_VSX 200
-#define CV_CPU_VSX3 201
-
-#define CV_CPU_RVV 210
-
-#define CV_CPU_LSX 230
-#define CV_CPU_LASX 231
-
-// CPU features groups
-#define CV_CPU_AVX512_SKX 256
-#define CV_CPU_AVX512_COMMON 257
-#define CV_CPU_AVX512_KNL 258
-#define CV_CPU_AVX512_KNM 259
-#define CV_CPU_AVX512_CNL 260
-#define CV_CPU_AVX512_CLX 261
-#define CV_CPU_AVX512_ICL 262
-
-// when adding to this list remember to update the following enum
-#define CV_HARDWARE_MAX_FEATURE 512
-
-/** @brief Available CPU features.
- */
-enum CpuFeatures {
-  CPU_MMX = 1,
-  CPU_SSE = 2,
-  CPU_SSE2 = 3,
-  CPU_SSE3 = 4,
-  CPU_SSSE3 = 5,
-  CPU_SSE4_1 = 6,
-  CPU_SSE4_2 = 7,
-  CPU_POPCNT = 8,
-  CPU_FP16 = 9,
-  CPU_AVX = 10,
-  CPU_AVX2 = 11,
-  CPU_FMA3 = 12,
-
-  CPU_AVX_512F = 13,
-  CPU_AVX_512BW = 14,
-  CPU_AVX_512CD = 15,
-  CPU_AVX_512DQ = 16,
-  CPU_AVX_512ER = 17,
-  CPU_AVX_512IFMA512 = 18, // deprecated
-  CPU_AVX_512IFMA = 18,
-  CPU_AVX_512PF = 19,
-  CPU_AVX_512VBMI = 20,
-  CPU_AVX_512VL = 21,
-  CPU_AVX_512VBMI2 = 22,
-  CPU_AVX_512VNNI = 23,
-  CPU_AVX_512BITALG = 24,
-  CPU_AVX_512VPOPCNTDQ = 25,
-  CPU_AVX_5124VNNIW = 26,
-  CPU_AVX_5124FMAPS = 27,
-
-  CPU_NEON = 100,
-  CPU_NEON_DOTPROD = 101,
-  CPU_NEON_FP16 = 102,
-  CPU_NEON_BF16 = 103,
-
-  CPU_MSA = 150,
-
-  CPU_RISCVV = 170,
-
-  CPU_VSX = 200,
-  CPU_VSX3 = 201,
-
-  CPU_RVV = 210,
-
-  CPU_LSX = 230,
-  CPU_LASX = 231,
-
-  CPU_AVX512_SKX = 256,    //!< Skylake-X with AVX-512F/CD/BW/DQ/VL
-  CPU_AVX512_COMMON = 257, //!< Common instructions AVX-512F/CD for all CPUs
-                           //!< that support AVX-512
-  CPU_AVX512_KNL = 258,    //!< Knights Landing with AVX-512F/CD/ER/PF
-  CPU_AVX512_KNM =
-      259, //!< Knights Mill with AVX-512F/CD/ER/PF/4FMAPS/4VNNIW/VPOPCNTDQ
-  CPU_AVX512_CNL = 260, //!< Cannon Lake with AVX-512F/CD/BW/DQ/VL/IFMA/VBMI
-  CPU_AVX512_CLX = 261, //!< Cascade Lake with AVX-512F/CD/BW/DQ/VL/VNNI
-  CPU_AVX512_ICL =
-      262, //!< Ice Lake with
-           //!< AVX-512F/CD/BW/DQ/VL/IFMA/VBMI/VNNI/VBMI2/BITALG/VPOPCNTDQ
-
-  CPU_MAX_FEATURE = 512 // see CV_HARDWARE_MAX_FEATURE
-};
-
-#include "cv_cpu_dispatch.h"
-
-#if !defined(CV_STRONG_ALIGNMENT) && defined(__arm__) &&                       \
-    !(defined(__aarch64__) || defined(_M_ARM64))
-// int*, int64* should be propertly aligned pointers on ARMv7
-#define CV_STRONG_ALIGNMENT 1
-#endif
-#if !defined(CV_STRONG_ALIGNMENT)
-#define CV_STRONG_ALIGNMENT 0
-#endif
-
-/* fundamental constants */
-#define CV_PI 3.1415926535897932384626433832795
-#define CV_2PI 6.283185307179586476925286766559
-#define CV_LOG2 0.69314718055994530941723212145818
-
-#if defined __ARM_FP16_FORMAT_IEEE && !defined __CUDACC__
-#define CV_FP16_TYPE 1
-#else
-#define CV_FP16_TYPE 0
-#endif
-
-typedef union Cv16suf {
-  short i;
-  ushort u;
-#if CV_FP16_TYPE
-  __fp16 h;
-#endif
-} Cv16suf;
-
-typedef union Cv32suf {
-  int i;
-  unsigned u;
-  float f;
-} Cv32suf;
-
-typedef union Cv64suf {
-  int64 i;
-  uint64 u;
-  double f;
-} Cv64suf;
-
-#ifndef OPENCV_ABI_COMPATIBILITY
-#define OPENCV_ABI_COMPATIBILITY 400
-#endif
-
-#ifdef __OPENCV_BUILD
-#define DISABLE_OPENCV_3_COMPATIBILITY
-#define OPENCV_DISABLE_DEPRECATED_COMPATIBILITY
-#endif
-
-#ifndef CV_EXPORTS
-#if (defined _WIN32 || defined WINCE || defined __CYGWIN__) &&                 \
-    defined(CVAPI_EXPORTS)
-#define CV_EXPORTS __declspec(dllexport)
-#elif defined __GNUC__ && __GNUC__ >= 4 &&                                     \
-    (defined(CVAPI_EXPORTS) || defined(__APPLE__))
-#define CV_EXPORTS __attribute__((visibility("default")))
-#endif
-#endif
-
-#ifndef CV_EXPORTS
-#define CV_EXPORTS
-#endif
-
-#ifdef _MSC_VER
-#define CV_EXPORTS_TEMPLATE
-#else
-#define CV_EXPORTS_TEMPLATE CV_EXPORTS
-#endif
-
-#ifndef CV_DEPRECATED
-#if defined(__GNUC__)
-#define CV_DEPRECATED __attribute__((deprecated))
-#elif defined(_MSC_VER)
-#define CV_DEPRECATED __declspec(deprecated)
-#else
-#define CV_DEPRECATED
-#endif
-#endif
-
-#ifndef CV_DEPRECATED_EXTERNAL
-#if defined(__OPENCV_BUILD)
-#define CV_DEPRECATED_EXTERNAL /* nothing */
-#else
-#define CV_DEPRECATED_EXTERNAL CV_DEPRECATED
-#endif
-#endif
-
-#ifndef CV_EXTERN_C
-#ifdef __cplusplus
-#define CV_EXTERN_C extern "C"
-#else
-#define CV_EXTERN_C
-#endif
-#endif
-
-/* special informative macros for wrapper generators */
-#define CV_EXPORTS_W CV_EXPORTS
-#define CV_EXPORTS_W_SIMPLE CV_EXPORTS
-#define CV_EXPORTS_AS(synonym) CV_EXPORTS
-#define CV_EXPORTS_W_MAP CV_EXPORTS
-#define CV_EXPORTS_W_PARAMS CV_EXPORTS
-#define CV_IN_OUT
-#define CV_OUT
-#define CV_PROP
-#define CV_PROP_RW
-#define CV_ND // Indicates that input data should be parsed into Mat without
-              // channels
-#define CV_WRAP
-#define CV_WRAP_AS(synonym)
-#define CV_WRAP_MAPPABLE(mappable)
-#define CV_WRAP_PHANTOM(phantom_header)
-#define CV_WRAP_DEFAULT(val)
-/* Indicates that the function parameter has filesystem path semantic */
-#define CV_WRAP_FILE_PATH
-
-/****************************************************************************************\
-*                                  Matrix type (Mat) *
-\****************************************************************************************/
-
-#define CV_MAX_DIM 32
-#define CV_MAT_CN_MASK ((CV_CN_MAX - 1) << CV_CN_SHIFT)
-#define CV_MAT_CN(flags) ((((flags) & CV_MAT_CN_MASK) >> CV_CN_SHIFT) + 1)
-#define CV_MAT_TYPE_MASK (CV_DEPTH_MAX * CV_CN_MAX - 1)
-#define CV_MAT_TYPE(flags) ((flags) & CV_MAT_TYPE_MASK)
-#define CV_MAT_CONT_FLAG_SHIFT 14
-#define CV_MAT_CONT_FLAG (1 << CV_MAT_CONT_FLAG_SHIFT)
-#define CV_IS_MAT_CONT(flags) ((flags) & CV_MAT_CONT_FLAG)
-#define CV_IS_CONT_MAT CV_IS_MAT_CONT
-#define CV_SUBMAT_FLAG_SHIFT 15
-#define CV_SUBMAT_FLAG (1 << CV_SUBMAT_FLAG_SHIFT)
-#define CV_IS_SUBMAT(flags) ((flags) & CV_MAT_SUBMAT_FLAG)
-
-/** Size of each channel item,
-   0x28442211 = 0010 1000 0100 0100 0010 0010 0001 0001 ~ array of
-   sizeof(arr_type_elem) */
-#define CV_ELEM_SIZE1(type) ((0x28442211 >> CV_MAT_DEPTH(type) * 4) & 15)
-
-#define CV_ELEM_SIZE(type) (CV_MAT_CN(type) * CV_ELEM_SIZE1(type))
-
-#ifndef MIN
-#define MIN(a, b) ((a) > (b) ? (b) : (a))
-#endif
-
-#ifndef MAX
-#define MAX(a, b) ((a) < (b) ? (b) : (a))
-#endif
-
-/** min & max without jumps */
-#define CV_IMIN(a, b) ((a) ^ (((a) ^ (b)) & (((a) < (b)) - 1)))
-#define CV_IMAX(a, b) ((a) ^ (((a) ^ (b)) & (((a) > (b)) - 1)))
-#define CV_SWAP(a, b, t) ((t) = (a), (a) = (b), (b) = (t))
-#define CV_CMP(a, b) (((a) > (b)) - ((a) < (b)))
-#define CV_SIGN(a) CV_CMP((a), 0)
-
-///////////////////////////////////////// Enum operators
-//////////////////////////////////////////
-
-/**
-
-Provides compatibility operators for both classical and C++11 enum classes,
-as well as exposing the C++11 enum class members for backwards compatibility
-
-@code
-    // Provides operators required for flag enums
-    CV_ENUM_FLAGS(AccessFlag)
-
-    // Exposes the listed members of the enum class AccessFlag to the current
-namespace CV_ENUM_CLASS_EXPOSE(AccessFlag, ACCESS_READ [, ACCESS_WRITE [, ...]
-]);
-@endcode
-*/
-
-#define __CV_ENUM_CLASS_EXPOSE_1(EnumType, MEMBER_CONST)                       \
-  static const EnumType MEMBER_CONST = EnumType::MEMBER_CONST;
-
-#define __CV_ENUM_CLASS_EXPOSE_2(EnumType, MEMBER_CONST, ...)                  \
-  __CV_ENUM_CLASS_EXPOSE_1(EnumType, MEMBER_CONST);                            \
-  __CV_EXPAND(__CV_ENUM_CLASS_EXPOSE_1(EnumType, __VA_ARGS__));
-
-#define __CV_ENUM_CLASS_EXPOSE_3(EnumType, MEMBER_CONST, ...)                  \
-  __CV_ENUM_CLASS_EXPOSE_1(EnumType, MEMBER_CONST);                            \
-  __CV_EXPAND(__CV_ENUM_CLASS_EXPOSE_2(EnumType, __VA_ARGS__));
-
-#define __CV_ENUM_CLASS_EXPOSE_4(EnumType, MEMBER_CONST, ...)                  \
-  __CV_ENUM_CLASS_EXPOSE_1(EnumType, MEMBER_CONST);                            \
-  __CV_EXPAND(__CV_ENUM_CLASS_EXPOSE_3(EnumType, __VA_ARGS__));
-
-#define __CV_ENUM_CLASS_EXPOSE_5(EnumType, MEMBER_CONST, ...)                  \
-  __CV_ENUM_CLASS_EXPOSE_1(EnumType, MEMBER_CONST);                            \
-  __CV_EXPAND(__CV_ENUM_CLASS_EXPOSE_4(EnumType, __VA_ARGS__));
-
-#define __CV_ENUM_CLASS_EXPOSE_6(EnumType, MEMBER_CONST, ...)                  \
-  __CV_ENUM_CLASS_EXPOSE_1(EnumType, MEMBER_CONST);                            \
-  __CV_EXPAND(__CV_ENUM_CLASS_EXPOSE_5(EnumType, __VA_ARGS__));
-
-#define __CV_ENUM_CLASS_EXPOSE_7(EnumType, MEMBER_CONST, ...)                  \
-  __CV_ENUM_CLASS_EXPOSE_1(EnumType, MEMBER_CONST);                            \
-  __CV_EXPAND(__CV_ENUM_CLASS_EXPOSE_6(EnumType, __VA_ARGS__));
-
-#define __CV_ENUM_CLASS_EXPOSE_8(EnumType, MEMBER_CONST, ...)                  \
-  __CV_ENUM_CLASS_EXPOSE_1(EnumType, MEMBER_CONST);                            \
-  __CV_EXPAND(__CV_ENUM_CLASS_EXPOSE_7(EnumType, __VA_ARGS__));
-
-#define __CV_ENUM_CLASS_EXPOSE_9(EnumType, MEMBER_CONST, ...)                  \
-  __CV_ENUM_CLASS_EXPOSE_1(EnumType, MEMBER_CONST);                            \
-  __CV_EXPAND(__CV_ENUM_CLASS_EXPOSE_8(EnumType, __VA_ARGS__));
-
-#define __CV_ENUM_FLAGS_LOGICAL_NOT(EnumType)                                  \
-  static inline bool operator!(const EnumType &val) {                          \
-    typedef std::underlying_type<EnumType>::type UnderlyingType;               \
-    return !static_cast<UnderlyingType>(val);                                  \
-  }
-
-#define __CV_ENUM_FLAGS_LOGICAL_NOT_EQ(Arg1Type, Arg2Type)                     \
-  static inline bool operator!=(const Arg1Type &a, const Arg2Type &b) {        \
-    return static_cast<int>(a) != static_cast<int>(b);                         \
-  }
-
-#define __CV_ENUM_FLAGS_LOGICAL_EQ(Arg1Type, Arg2Type)                         \
-  static inline bool operator==(const Arg1Type &a, const Arg2Type &b) {        \
-    return static_cast<int>(a) == static_cast<int>(b);                         \
-  }
-
-#define __CV_ENUM_FLAGS_BITWISE_NOT(EnumType)                                  \
-  static inline EnumType operator~(const EnumType &val) {                      \
-    typedef std::underlying_type<EnumType>::type UnderlyingType;               \
-    return static_cast<EnumType>(~static_cast<UnderlyingType>(val));           \
-  }
-
-#define __CV_ENUM_FLAGS_BITWISE_OR(EnumType, Arg1Type, Arg2Type)               \
-  static inline EnumType operator|(const Arg1Type &a, const Arg2Type &b) {     \
-    typedef std::underlying_type<EnumType>::type UnderlyingType;               \
-    return static_cast<EnumType>(static_cast<UnderlyingType>(a) |              \
-                                 static_cast<UnderlyingType>(b));              \
-  }
-
-#define __CV_ENUM_FLAGS_BITWISE_AND(EnumType, Arg1Type, Arg2Type)              \
-  static inline EnumType operator&(const Arg1Type &a, const Arg2Type &b) {     \
-    typedef std::underlying_type<EnumType>::type UnderlyingType;               \
-    return static_cast<EnumType>(static_cast<UnderlyingType>(a) &              \
-                                 static_cast<UnderlyingType>(b));              \
-  }
-
-#define __CV_ENUM_FLAGS_BITWISE_XOR(EnumType, Arg1Type, Arg2Type)              \
-  static inline EnumType operator^(const Arg1Type &a, const Arg2Type &b) {     \
-    typedef std::underlying_type<EnumType>::type UnderlyingType;               \
-    return static_cast<EnumType>(static_cast<UnderlyingType>(a) ^              \
-                                 static_cast<UnderlyingType>(b));              \
-  }
-
-#define __CV_ENUM_FLAGS_BITWISE_OR_EQ(EnumType, Arg1Type)                      \
-  static inline EnumType &operator|=(EnumType &_this, const Arg1Type &val) {   \
-    _this = static_cast<EnumType>(static_cast<int>(_this) |                    \
-                                  static_cast<int>(val));                      \
-    return _this;                                                              \
-  }
-
-#define __CV_ENUM_FLAGS_BITWISE_AND_EQ(EnumType, Arg1Type)                     \
-  static inline EnumType &operator&=(EnumType &_this, const Arg1Type &val) {   \
-    _this = static_cast<EnumType>(static_cast<int>(_this) &                    \
-                                  static_cast<int>(val));                      \
-    return _this;                                                              \
-  }
-
-#define __CV_ENUM_FLAGS_BITWISE_XOR_EQ(EnumType, Arg1Type)                     \
-  static inline EnumType &operator^=(EnumType &_this, const Arg1Type &val) {   \
-    _this = static_cast<EnumType>(static_cast<int>(_this) ^                    \
-                                  static_cast<int>(val));                      \
-    return _this;                                                              \
-  }
-
-#define CV_ENUM_CLASS_EXPOSE(EnumType, ...)                                    \
-  __CV_EXPAND(__CV_CAT(__CV_ENUM_CLASS_EXPOSE_,                                \
-                       __CV_VA_NUM_ARGS(__VA_ARGS__))(EnumType, __VA_ARGS__));
-
-#define CV_ENUM_FLAGS(EnumType)                                                \
-  __CV_ENUM_FLAGS_LOGICAL_NOT(EnumType)                                        \
-  __CV_ENUM_FLAGS_LOGICAL_EQ(EnumType, int)                                    \
-  __CV_ENUM_FLAGS_LOGICAL_NOT_EQ(EnumType, int)                                \
-                                                                               \
-  __CV_ENUM_FLAGS_BITWISE_NOT(EnumType)                                        \
-  __CV_ENUM_FLAGS_BITWISE_OR(EnumType, EnumType, EnumType)                     \
-  __CV_ENUM_FLAGS_BITWISE_AND(EnumType, EnumType, EnumType)                    \
-  __CV_ENUM_FLAGS_BITWISE_XOR(EnumType, EnumType, EnumType)                    \
-                                                                               \
-  __CV_ENUM_FLAGS_BITWISE_OR_EQ(EnumType, EnumType)                            \
-  __CV_ENUM_FLAGS_BITWISE_AND_EQ(EnumType, EnumType)                           \
-  __CV_ENUM_FLAGS_BITWISE_XOR_EQ(EnumType, EnumType)
-
-/****************************************************************************************\
-*                                    static analysys *
-\****************************************************************************************/
-
-// In practice, some macro are not processed correctly (noreturn is not
-// detected). We need to use simplified definition for them.
-#ifndef CV_STATIC_ANALYSIS
-#if defined(__KLOCWORK__) || defined(__clang_analyzer__) ||                    \
-    defined(__COVERITY__)
-#define CV_STATIC_ANALYSIS 1
-#endif
-#else
-#if defined(CV_STATIC_ANALYSIS) &&                                             \
-    !(__CV_CAT(1, CV_STATIC_ANALYSIS) == 1) // defined and not empty
-#if 0 == CV_STATIC_ANALYSIS
-#undef CV_STATIC_ANALYSIS
-#endif
-#endif
-#endif
-
-/****************************************************************************************\
-*                                    Thread sanitizer *
-\****************************************************************************************/
-#ifndef CV_THREAD_SANITIZER
-#if defined(__has_feature)
-#if __has_feature(thread_sanitizer)
-#define CV_THREAD_SANITIZER
-#endif
-#endif
-#endif
-
-/****************************************************************************************\
-*          exchange-add operation for atomic operations on reference counters *
-\****************************************************************************************/
-
-#ifdef CV_XADD
-// allow to use user-defined macro
-#elif defined __GNUC__ || defined __clang__
-#if defined __clang__ && __clang_major__ >= 3 && !defined __ANDROID__ &&       \
-    !defined __EMSCRIPTEN__ && !defined(__CUDACC__) &&                         \
-    !defined __INTEL_COMPILER
-#ifdef __ATOMIC_ACQ_REL
-#define CV_XADD(addr, delta)                                                   \
-  __c11_atomic_fetch_add((_Atomic(int) *)(addr), delta, __ATOMIC_ACQ_REL)
-#else
-#define CV_XADD(addr, delta)                                                   \
-  __atomic_fetch_add((_Atomic(int) *)(addr), delta, 4)
-#endif
-#else
-#if defined __ATOMIC_ACQ_REL && !defined __clang__
-// version for gcc >= 4.7
-#define CV_XADD(addr, delta)                                                   \
-  (int)__atomic_fetch_add((unsigned *)(addr), (unsigned)(delta),               \
-                          __ATOMIC_ACQ_REL)
-#else
-#define CV_XADD(addr, delta)                                                   \
-  (int)__sync_fetch_and_add((unsigned *)(addr), (unsigned)(delta))
-#endif
-#endif
-#elif defined _MSC_VER && !defined RC_INVOKED
-#include <intrin.h>
-#define CV_XADD(addr, delta)                                                   \
-  (int)_InterlockedExchangeAdd((long volatile *)addr, delta)
-#else
-#ifdef OPENCV_FORCE_UNSAFE_XADD
-CV_INLINE int CV_XADD(int *addr, int delta) {
-  int tmp = *addr;
-  *addr += delta;
-  return tmp;
-}
-#else
-#error                                                                         \
-    "OpenCV: can't define safe CV_XADD macro for current platform (unsupported). Define CV_XADD macro through custom port header (see OPENCV_INCLUDE_PORT_FILE)"
-#endif
-#endif
-
-/****************************************************************************************\
-*                                  CV_NORETURN attribute *
-\****************************************************************************************/
-
-#ifndef CV_NORETURN
-#if defined(__GNUC__)
-#define CV_NORETURN __attribute__((__noreturn__))
-#elif defined(_MSC_VER) && (_MSC_VER >= 1300)
-#define CV_NORETURN __declspec(noreturn)
-#else
-#define CV_NORETURN /* nothing by default */
-#endif
-#endif
-
-/****************************************************************************************\
-*                       CV_NODISCARD_STD attribute (C++17) *
-* encourages the compiler to issue a warning if the return value is discarded *
-\****************************************************************************************/
-#ifndef CV_NODISCARD_STD
-#ifndef __has_cpp_attribute
-//   workaround preprocessor non-compliance https://reviews.llvm.org/D57851
-#define __has_cpp_attribute(__x) 0
-#endif
-#if __has_cpp_attribute(nodiscard)
-#if defined(__NVCC__) && __CUDACC_VER_MAJOR__ < 12
-#define CV_NODISCARD_STD
-#else
-#define CV_NODISCARD_STD [[nodiscard]]
-#endif
-#elif __cplusplus >= 201703L
-//   available when compiler is C++17 compliant
-#define CV_NODISCARD_STD [[nodiscard]]
-#elif defined(__INTEL_COMPILER)
-// see above, available when C++17 is enabled
-#elif defined(_MSC_VER) && _MSC_VER >= 1911 && _MSVC_LANG >= 201703L
-//   available with VS2017 v15.3+ with /std:c++17 or higher; works on functions
-//   and classes
-#define CV_NODISCARD_STD [[nodiscard]]
-#elif defined(__GNUC__) && (((__GNUC__ * 100) + __GNUC_MINOR__) >= 700) &&     \
-    (__cplusplus >= 201103L)
-//   available with GCC 7.0+; works on functions, works or silently fails on
-//   classes
-#define CV_NODISCARD_STD [[nodiscard]]
-#elif defined(__GNUC__) && (((__GNUC__ * 100) + __GNUC_MINOR__) >= 408) &&     \
-    (__cplusplus >= 201103L)
-//   available with GCC 4.8+ but it usually does nothing and can fail noisily --
-//   therefore not used define CV_NODISCARD_STD [[gnu::warn_unused_result]]
-#endif
-#endif
-#ifndef CV_NODISCARD_STD
-#define CV_NODISCARD_STD /* nothing by default */
-#endif
-
-/****************************************************************************************\
-*                                    C++ 11 *
-\****************************************************************************************/
-#ifdef __cplusplus
-// MSVC was stuck at __cplusplus == 199711L for a long time, even where it
-// supports C++11, so check _MSC_VER instead. See:
-// <https://devblogs.microsoft.com/cppblog/msvc-now-correctly-reports-__cplusplus>
-#if defined(_MSC_VER)
-#if _MSC_VER < 1800
-#error "OpenCV 4.x+ requires enabled C++11 support"
-#endif
-#elif __cplusplus < 201103L
-#error "OpenCV 4.x+ requires enabled C++11 support"
-#endif
-#endif
-
-#ifndef CV_CXX11
-#define CV_CXX11 1
-#endif
-
-#ifndef CV_OVERRIDE
-#define CV_OVERRIDE override
-#endif
-
-#ifndef CV_FINAL
-#define CV_FINAL final
-#endif
-
-#ifndef CV_NOEXCEPT
-#define CV_NOEXCEPT noexcept
-#endif
-
-#ifndef CV_CONSTEXPR
-#define CV_CONSTEXPR constexpr
-#endif
-
-// Integer types portability
-#ifdef __cplusplus
-#include <cstdint>
-namespace cv {
-using std::int16_t;
-using std::int32_t;
-using std::int64_t;
-using std::int8_t;
-using std::uint16_t;
-using std::uint32_t;
-using std::uint64_t;
-using std::uint8_t;
-} // namespace cv
-#else // pure C
-#include <stdint.h>
-#endif
-
-#ifdef __cplusplus
-namespace cv {
-
-class hfloat {
-public:
-#if CV_FP16_TYPE
-
-  hfloat() : h(0) {}
-  explicit hfloat(float x) { h = (__fp16)x; }
-  operator float() const { return (float)h; }
-
-protected:
-  __fp16 h;
-
-#else
-  hfloat() : w(0) {}
-  explicit hfloat(float x) {
-#if CV_FP16 && CV_AVX2
-    __m128 v = _mm_load_ss(&x);
-    w = (ushort)_mm_cvtsi128_si32(_mm_cvtps_ph(v, 0));
-#else
-    Cv32suf in;
-    in.f = x;
-    unsigned sign = in.u & 0x80000000;
-    in.u ^= sign;
-
-    if (in.u >= 0x47800000)
-      w = (ushort)(in.u > 0x7f800000 ? 0x7e00 : 0x7c00);
-    else {
-      if (in.u < 0x38800000) {
-        in.f += 0.5f;
-        w = (ushort)(in.u - 0x3f000000);
-      } else {
-        unsigned t = in.u + 0xc8000fff;
-        w = (ushort)((t + ((in.u >> 13) & 1)) >> 13);
-      }
-    }
-
-    w = (ushort)(w | (sign >> 16));
-#endif
-  }
-
-  operator float() const {
-#if CV_FP16 && CV_AVX2
-    float f;
-    _mm_store_ss(&f, _mm_cvtph_ps(_mm_cvtsi32_si128(w)));
-    return f;
-#else
-    Cv32suf out;
-
-    unsigned t = ((w & 0x7fff) << 13) + 0x38000000;
-    unsigned sign = (w & 0x8000) << 16;
-    unsigned e = w & 0x7c00;
-
-    out.u = t + (1 << 23);
-    out.u = (e >= 0x7c00 ? t + 0x38000000
-             : e == 0    ? (static_cast<void>(out.f -= 6.103515625e-05f), out.u)
-                         : t) |
-            sign;
-    return out.f;
-#endif
-  }
-
-protected:
-  ushort w;
-
-#endif
-};
-
-inline hfloat hfloatFromBits(ushort w) {
-#if CV_FP16_TYPE
-  Cv16suf u;
-  u.u = w;
-  hfloat res(float(u.h));
-  return res;
-#else
-  Cv32suf out;
-
-  unsigned t = ((w & 0x7fff) << 13) + 0x38000000;
-  unsigned sign = (w & 0x8000) << 16;
-  unsigned e = w & 0x7c00;
-
-  out.u = t + (1 << 23);
-  out.u = (e >= 0x7c00 ? t + 0x38000000
-           : e == 0    ? (static_cast<void>(out.f -= 6.103515625e-05f), out.u)
-                       : t) |
-          sign;
-  hfloat res(out.f);
-  return res;
-#endif
-}
-
-#if !defined(__OPENCV_BUILD) && !(defined __STDCPP_FLOAT16_T__) &&             \
-    !(defined __ARM_NEON)
-typedef hfloat float16_t;
-#endif
-
-} // namespace cv
-#endif
-
-/** @brief Constructs the 'fourcc' code, used in video codecs and many other
-   places. Simply call it with 4 chars like `CV_FOURCC('I', 'Y', 'U', 'V')`
-*/
-CV_INLINE int CV_FOURCC(char c1, char c2, char c3, char c4) {
-  return (c1 & 255) + ((c2 & 255) << 8) + ((c3 & 255) << 16) +
-         ((c4 & 255) << 24);
-}
-
-//! Macro to construct the fourcc code of the codec. Same as CV_FOURCC()
-#define CV_FOURCC_MACRO(c1, c2, c3, c4)                                        \
-  (((c1) & 255) + (((c2) & 255) << 8) + (((c3) & 255) << 16) +                 \
-   (((c4) & 255) << 24))
-
-//! @}
-
-#ifndef __cplusplus
-#include "opencv2/core/fast_math.hpp" // define cvRound(double)
-#endif
-
-#define CV_OCL_RUN_(condition, func, ...)
-#define CV_OCL_RUN(condition, func) CV_OCL_RUN_(condition, func)
-
-#define CV_OVX_RUN(condition, func, ...)
-
-#endif // OPENCV_CORE_CVDEF_H
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/cvstd.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/cvstd.hpp
deleted file mode 100644
index 481cf8da1f..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/cvstd.hpp
+++ /dev/null
@@ -1,196 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_CORE_CVSTD_HPP
-#define OPENCV_CORE_CVSTD_HPP
-
-#ifndef __cplusplus
-#error cvstd.hpp header must be compiled as C++
-#endif
-
-#include "opencv2/core/cvdef.h"
-#include <cctype>
-#include <cstddef>
-#include <cstring>
-
-#include <string>
-
-// import useful primitives from stl
-#include <algorithm>
-#include <cmath>
-#include <cstdlib> //for abs(int)
-#include <utility>
-
-namespace cv {
-static inline uchar abs(uchar a) { return a; }
-static inline ushort abs(ushort a) { return a; }
-static inline unsigned abs(unsigned a) { return a; }
-static inline uint64 abs(uint64 a) { return a; }
-
-using std::abs;
-using std::exp;
-using std::log;
-using std::max;
-using std::min;
-using std::pow;
-using std::sqrt;
-using std::swap;
-} // namespace cv
-
-#include "cvstd_wrapper.hpp"
-
-namespace cv {
-
-//! @addtogroup core_utils
-//! @{
-
-//////////////////////////// memory management functions
-///////////////////////////////
-
-/** @brief Allocates an aligned memory buffer.
-
-The function allocates the buffer of the specified size and returns it. When the
-buffer size is 16 bytes or more, the returned buffer is aligned to 16 bytes.
-@param bufSize Allocated buffer size.
- */
-CV_EXPORTS void *fastMalloc(size_t bufSize);
-
-/** @brief Deallocates a memory buffer.
-
-The function deallocates the buffer allocated with fastMalloc . If NULL pointer
-is passed, the function does nothing. C version of the function clears the
-pointer *pptr* to avoid problems with double memory deallocation.
-@param ptr Pointer to the allocated buffer.
- */
-CV_EXPORTS void fastFree(void *ptr);
-
-/*!
-  The STL-compliant memory Allocator based on cv::fastMalloc() and
-  cv::fastFree()
-*/
-template <typename _Tp> class Allocator {
-public:
-  typedef _Tp value_type;
-  typedef value_type *pointer;
-  typedef const value_type *const_pointer;
-  typedef value_type &reference;
-  typedef const value_type &const_reference;
-  typedef size_t size_type;
-  typedef ptrdiff_t difference_type;
-  template <typename U> class rebind {
-    typedef Allocator<U> other;
-  };
-
-  explicit Allocator() {}
-  ~Allocator() {}
-  explicit Allocator(Allocator const &) {}
-  template <typename U> explicit Allocator(Allocator<U> const &) {}
-
-  // address
-  pointer address(reference r) { return &r; }
-  const_pointer address(const_reference r) { return &r; }
-
-  pointer allocate(size_type count, const void * = 0) {
-    return reinterpret_cast<pointer>(fastMalloc(count * sizeof(_Tp)));
-  }
-  void deallocate(pointer p, size_type) { fastFree(p); }
-
-  void construct(pointer p, const _Tp &v) {
-    new (static_cast<void *>(p)) _Tp(v);
-  }
-  void destroy(pointer p) { p->~_Tp(); }
-
-  size_type max_size() const {
-    return cv::max(static_cast<_Tp>(-1) / sizeof(_Tp), 1);
-  }
-};
-
-//! @} core_utils
-
-//! @addtogroup core_basic
-//! @{
-
-//////////////////////////////// string class ////////////////////////////////
-
-class CV_EXPORTS FileNode; // for string constructor from FileNode
-
-typedef std::string String;
-
-#ifndef OPENCV_DISABLE_STRING_LOWER_UPPER_CONVERSIONS
-
-//! @cond IGNORED
-namespace details {
-// std::tolower is int->int
-static inline char char_tolower(char ch) { return (char)std::tolower((int)ch); }
-// std::toupper is int->int
-static inline char char_toupper(char ch) { return (char)std::toupper((int)ch); }
-} // namespace details
-//! @endcond
-
-static inline std::string toLowerCase(const std::string &str) {
-  std::string result(str);
-  std::transform(result.begin(), result.end(), result.begin(),
-                 details::char_tolower);
-  return result;
-}
-
-static inline std::string toUpperCase(const std::string &str) {
-  std::string result(str);
-  std::transform(result.begin(), result.end(), result.begin(),
-                 details::char_toupper);
-  return result;
-}
-
-#endif // OPENCV_DISABLE_STRING_LOWER_UPPER_CONVERSIONS
-
-//! @} core_basic
-} // namespace cv
-
-#endif // OPENCV_CORE_CVSTD_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/cvstd.inl.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/cvstd.inl.hpp
deleted file mode 100644
index 0a18f75698..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/cvstd.inl.hpp
+++ /dev/null
@@ -1,188 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_CORE_CVSTDINL_HPP
-#define OPENCV_CORE_CVSTDINL_HPP
-
-#include <complex>
-#include <ostream>
-#include <sstream>
-
-//! @cond IGNORED
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4127)
-#endif
-
-namespace cv {
-
-template <typename _Tp> class DataType<std::complex<_Tp>> {
-public:
-  typedef std::complex<_Tp> value_type;
-  typedef value_type work_type;
-  typedef _Tp channel_type;
-
-  enum {
-    generic_type = 0,
-    depth = DataType<channel_type>::depth,
-    channels = 2,
-    fmt = DataType<channel_type>::fmt + ((channels - 1) << 8),
-    type = CV_MAKETYPE(depth, channels)
-  };
-
-  typedef Vec<channel_type, channels> vec_type;
-};
-
-static inline std::ostream &operator<<(std::ostream &out, Ptr<Formatted> fmtd) {
-  fmtd->reset();
-  for (const char *str = fmtd->next(); str; str = fmtd->next())
-    out << str;
-  return out;
-}
-
-static inline std::ostream &operator<<(std::ostream &out, const Mat &mtx) {
-  return out << Formatter::get()->format(mtx);
-}
-
-template <typename _Tp>
-static inline std::ostream &operator<<(std::ostream &out,
-                                       const Complex<_Tp> &c) {
-  return out << "(" << c.re << "," << c.im << ")";
-}
-
-template <typename _Tp>
-static inline std::ostream &operator<<(std::ostream &out,
-                                       const std::vector<Point_<_Tp>> &vec) {
-  return out << Formatter::get()->format(Mat(vec));
-}
-
-template <typename _Tp>
-static inline std::ostream &operator<<(std::ostream &out,
-                                       const std::vector<Point3_<_Tp>> &vec) {
-  return out << Formatter::get()->format(Mat(vec));
-}
-
-template <typename _Tp, int m, int n>
-static inline std::ostream &operator<<(std::ostream &out,
-                                       const Matx<_Tp, m, n> &matx) {
-  return out << Formatter::get()->format(Mat(matx));
-}
-
-template <typename _Tp>
-static inline std::ostream &operator<<(std::ostream &out,
-                                       const Point_<_Tp> &p) {
-  out << "[" << p.x << ", " << p.y << "]";
-  return out;
-}
-
-template <typename _Tp>
-static inline std::ostream &operator<<(std::ostream &out,
-                                       const Point3_<_Tp> &p) {
-  out << "[" << p.x << ", " << p.y << ", " << p.z << "]";
-  return out;
-}
-
-template <typename _Tp, int n>
-static inline std::ostream &operator<<(std::ostream &out,
-                                       const Vec<_Tp, n> &vec) {
-  out << "[";
-  if (cv::traits::Depth<_Tp>::value <= CV_32S) {
-    for (int i = 0; i < n - 1; ++i) {
-      out << (int)vec[i] << ", ";
-    }
-    out << (int)vec[n - 1] << "]";
-  } else {
-    for (int i = 0; i < n - 1; ++i) {
-      out << vec[i] << ", ";
-    }
-    out << vec[n - 1] << "]";
-  }
-
-  return out;
-}
-
-template <typename _Tp>
-static inline std::ostream &operator<<(std::ostream &out,
-                                       const Size_<_Tp> &size) {
-  return out << "[" << size.width << " x " << size.height << "]";
-}
-
-template <typename _Tp>
-static inline std::ostream &operator<<(std::ostream &out,
-                                       const Rect_<_Tp> &rect) {
-  return out << "[" << rect.width << " x " << rect.height << " from (" << rect.x
-             << ", " << rect.y << ")]";
-}
-
-static inline std::ostream &operator<<(std::ostream &out,
-                                       const MatSize &msize) {
-  int i, dims = msize.dims();
-  for (i = 0; i < dims; i++) {
-    out << msize[i];
-    if (i < dims - 1)
-      out << " x ";
-  }
-  return out;
-}
-
-static inline std::ostream &operator<<(std::ostream &s, cv::Range &r) {
-  return s << "[" << r.start << " : " << r.end << ")";
-}
-
-} // namespace cv
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-//! @endcond
-
-#endif // OPENCV_CORE_CVSTDINL_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/cvstd_wrapper.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/cvstd_wrapper.hpp
deleted file mode 100644
index 8725beb753..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/cvstd_wrapper.hpp
+++ /dev/null
@@ -1,187 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_CORE_CVSTD_WRAPPER_HPP
-#define OPENCV_CORE_CVSTD_WRAPPER_HPP
-
-#include "opencv2/core/cvdef.h"
-
-#include <memory> // std::shared_ptr
-#include <string>
-#include <type_traits> // std::enable_if
-
-namespace cv {
-
-using std::nullptr_t;
-
-//! @addtogroup core_basic
-//! @{
-
-#ifdef CV_DOXYGEN
-
-template <typename _Tp>
-using Ptr =
-    std::shared_ptr<_Tp>; // In ideal world it should look like this, but we
-                          // need some compatibility workarounds below
-
-template <typename _Tp, typename... A1>
-static inline Ptr<_Tp> makePtr(const A1 &...a1) {
-  return std::make_shared<_Tp>(a1...);
-}
-
-#else // cv::Ptr with compatibility workarounds
-
-// It should be defined for C-API types only.
-// C++ types should use regular "delete" operator.
-template <typename Y> struct DefaultDeleter;
-#if 0
-{
-    void operator()(Y* p) const;
-};
-#endif
-
-namespace sfinae {
-template <typename C, typename Ret, typename... Args>
-struct has_parenthesis_operator {
-private:
-  template <typename T>
-  static CV_CONSTEXPR std::true_type has_parenthesis_operator_check(
-      typename std::is_same<
-          typename std::decay<decltype(std::declval<T>().operator()(
-              std::declval<Args>()...))>::type,
-          Ret>::type *);
-
-  template <typename>
-  static CV_CONSTEXPR std::false_type has_parenthesis_operator_check(...);
-
-  typedef decltype(has_parenthesis_operator_check<C>(0)) type;
-
-public:
-#if __cplusplus >= 201103L ||                                                  \
-    (defined(_MSC_VER) && _MSC_VER >= 1900 /*MSVS 2015*/)
-  static CV_CONSTEXPR bool value = type::value;
-#else
-  // support MSVS 2013
-  static const int value = type::value;
-#endif
-};
-} // namespace sfinae
-
-template <typename T, typename = void>
-struct has_custom_delete : public std::false_type {};
-
-// Force has_custom_delete to std::false_type when NVCC is compiling CUDA source
-// files
-#ifndef __CUDACC__
-template <typename T>
-struct has_custom_delete<
-    T, typename std::enable_if<sfinae::has_parenthesis_operator<
-           DefaultDeleter<T>, void, T *>::value>::type>
-    : public std::true_type {};
-#endif
-
-template <typename T> struct Ptr : public std::shared_ptr<T> {
-#if 0
-    using std::shared_ptr<T>::shared_ptr;  // GCC 5.x can't handle this
-#else
-  inline Ptr() CV_NOEXCEPT : std::shared_ptr<T>() {}
-  inline Ptr(nullptr_t) CV_NOEXCEPT : std::shared_ptr<T>(nullptr) {}
-  template <typename Y, typename D>
-  inline Ptr(Y *p, D d) : std::shared_ptr<T>(p, d) {}
-  template <typename D>
-  inline Ptr(nullptr_t, D d) : std::shared_ptr<T>(nullptr, d) {}
-
-  template <typename Y>
-  inline Ptr(const Ptr<Y> &r, T *ptr) CV_NOEXCEPT : std::shared_ptr<T>(r, ptr) {
-  }
-
-  inline Ptr(const Ptr<T> &o) CV_NOEXCEPT : std::shared_ptr<T>(o) {}
-  inline Ptr(Ptr<T> &&o) CV_NOEXCEPT : std::shared_ptr<T>(std::move(o)) {}
-
-  template <typename Y>
-  inline Ptr(const Ptr<Y> &o) CV_NOEXCEPT : std::shared_ptr<T>(o) {}
-  template <typename Y>
-  inline Ptr(Ptr<Y> &&o) CV_NOEXCEPT : std::shared_ptr<T>(std::move(o)) {}
-#endif
-  inline Ptr(const std::shared_ptr<T> &o) CV_NOEXCEPT : std::shared_ptr<T>(o) {}
-  inline Ptr(std::shared_ptr<T> &&o) CV_NOEXCEPT
-      : std::shared_ptr<T>(std::move(o)) {}
-
-  // Overload with custom DefaultDeleter: Ptr<IplImage>(...)
-  template <typename Y>
-  inline Ptr(const std::true_type &, Y *ptr)
-      : std::shared_ptr<T>(ptr, DefaultDeleter<Y>()) {}
-
-  // Overload without custom deleter: Ptr<std::string>(...);
-  template <typename Y>
-  inline Ptr(const std::false_type &, Y *ptr) : std::shared_ptr<T>(ptr) {}
-
-  template <typename Y = T>
-  inline Ptr(Y *ptr) : Ptr(has_custom_delete<Y>(), ptr) {}
-
-  // Overload with custom DefaultDeleter: Ptr<IplImage>(...)
-  template <typename Y> inline void reset(const std::true_type &, Y *ptr) {
-    std::shared_ptr<T>::reset(ptr, DefaultDeleter<Y>());
-  }
-
-  // Overload without custom deleter: Ptr<std::string>(...);
-  template <typename Y> inline void reset(const std::false_type &, Y *ptr) {
-    std::shared_ptr<T>::reset(ptr);
-  }
-
-  template <typename Y> inline void reset(Y *ptr) {
-    Ptr<T>::reset(has_custom_delete<Y>(), ptr);
-  }
-
-  template <class Y, class Deleter> void reset(Y *ptr, Deleter d) {
-    std::shared_ptr<T>::reset(ptr, d);
-  }
-
-  void reset() CV_NOEXCEPT { std::shared_ptr<T>::reset(); }
-
-  Ptr &operator=(const Ptr &o) {
-    std::shared_ptr<T>::operator=(o);
-    return *this;
-  }
-  template <typename Y> inline Ptr &operator=(const Ptr<Y> &o) {
-    std::shared_ptr<T>::operator=(o);
-    return *this;
-  }
-
-  T *operator->() const CV_NOEXCEPT { return std::shared_ptr<T>::get(); }
-  typename std::add_lvalue_reference<T>::type operator*() const CV_NOEXCEPT {
-    return *std::shared_ptr<T>::get();
-  }
-
-  // OpenCV 3.x methods (not a part of standard C++ library)
-  inline void release() { std::shared_ptr<T>::reset(); }
-  inline operator T *() const { return std::shared_ptr<T>::get(); }
-  inline bool empty() const { return std::shared_ptr<T>::get() == nullptr; }
-
-  template <typename Y> inline Ptr<Y> staticCast() const CV_NOEXCEPT {
-    return std::static_pointer_cast<Y>(*this);
-  }
-
-  template <typename Y> inline Ptr<Y> constCast() const CV_NOEXCEPT {
-    return std::const_pointer_cast<Y>(*this);
-  }
-
-  template <typename Y> inline Ptr<Y> dynamicCast() const CV_NOEXCEPT {
-    return std::dynamic_pointer_cast<Y>(*this);
-  }
-};
-
-template <typename _Tp, typename... A1>
-static inline Ptr<_Tp> makePtr(const A1 &...a1) {
-  static_assert(!has_custom_delete<_Tp>::value,
-                "Can't use this makePtr with custom DefaultDeleter");
-  return (Ptr<_Tp>)std::make_shared<_Tp>(a1...);
-}
-
-#endif // CV_DOXYGEN
-
-//! @} core_basic
-} // namespace cv
-
-#endif // OPENCV_CORE_CVSTD_WRAPPER_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/detail/async_promise.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/detail/async_promise.hpp
deleted file mode 100644
index 1367275498..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/detail/async_promise.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_CORE_ASYNC_PROMISE_HPP
-#define OPENCV_CORE_ASYNC_PROMISE_HPP
-
-#include "../async.hpp"
-
-#include "exception_ptr.hpp"
-
-namespace cv {
-
-/** @addtogroup core_async
-@{
-*/
-
-/** @brief Provides result of asynchronous operations
-
-*/
-class CV_EXPORTS AsyncPromise {
-public:
-  ~AsyncPromise() CV_NOEXCEPT;
-  AsyncPromise() CV_NOEXCEPT;
-  explicit AsyncPromise(const AsyncPromise &o) CV_NOEXCEPT;
-  AsyncPromise &operator=(const AsyncPromise &o) CV_NOEXCEPT;
-  void release() CV_NOEXCEPT;
-
-  /** Returns associated AsyncArray
-  @note Can be called once
-  */
-  AsyncArray getArrayResult();
-
-  /** Stores asynchronous result.
-  @param[in] value result
-  */
-  void setValue(InputArray value);
-
-  // TODO "move" setters
-
-#if CV__EXCEPTION_PTR
-  /** Stores exception.
-  @param[in] exception exception to be raised in AsyncArray
-  */
-  void setException(std::exception_ptr exception);
-#endif
-
-  /** Stores exception.
-  @param[in] exception exception to be raised in AsyncArray
-  */
-  void setException(const cv::Exception &exception);
-
-  explicit AsyncPromise(AsyncPromise &&o) {
-    p = o.p;
-    o.p = NULL;
-  }
-  AsyncPromise &operator=(AsyncPromise &&o) CV_NOEXCEPT {
-    std::swap(p, o.p);
-    return *this;
-  }
-
-  // PImpl
-  typedef struct AsyncArray::Impl Impl;
-  friend struct AsyncArray::Impl;
-  inline void *_getImpl() const CV_NOEXCEPT { return p; }
-
-protected:
-  Impl *p;
-};
-
-//! @}
-} // namespace cv
-#endif // OPENCV_CORE_ASYNC_PROMISE_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/detail/dispatch_helper.impl.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/detail/dispatch_helper.impl.hpp
deleted file mode 100644
index e4ccc39e96..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/detail/dispatch_helper.impl.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_CORE_DETAIL_DISPATCH_HELPER_IMPL_HPP
-#define OPENCV_CORE_DETAIL_DISPATCH_HELPER_IMPL_HPP
-
-//! @cond IGNORED
-
-namespace cv {
-namespace detail {
-
-template <template <typename> class Functor, typename... Args>
-static inline void depthDispatch(const int depth, Args &&...args) {
-  switch (depth) {
-  case CV_8U:
-    Functor<uint8_t>{}(std::forward<Args>(args)...);
-    break;
-  case CV_8S:
-    Functor<int8_t>{}(std::forward<Args>(args)...);
-    break;
-  case CV_16U:
-    Functor<uint16_t>{}(std::forward<Args>(args)...);
-    break;
-  case CV_16S:
-    Functor<int16_t>{}(std::forward<Args>(args)...);
-    break;
-  case CV_32S:
-    Functor<int32_t>{}(std::forward<Args>(args)...);
-    break;
-  case CV_32F:
-    Functor<float>{}(std::forward<Args>(args)...);
-    break;
-  case CV_64F:
-    Functor<double>{}(std::forward<Args>(args)...);
-    break;
-  case CV_16F:
-  default:
-    CV_Error(cv::Error::BadDepth, "Unsupported matrix type.");
-  };
-}
-
-} // namespace detail
-} // namespace cv
-
-//! @endcond
-
-#endif // OPENCV_CORE_DETAIL_DISPATCH_HELPER_IMPL_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/detail/exception_ptr.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/detail/exception_ptr.hpp
deleted file mode 100644
index 1df3f457b6..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/detail/exception_ptr.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_CORE_DETAILS_EXCEPTION_PTR_H
-#define OPENCV_CORE_DETAILS_EXCEPTION_PTR_H
-
-#ifndef CV__EXCEPTION_PTR
-#if defined(__ANDROID__) && defined(ATOMIC_INT_LOCK_FREE) &&                   \
-    ATOMIC_INT_LOCK_FREE < 2
-#define CV__EXCEPTION_PTR                                                      \
-  0 // Not supported, details:
-    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=58938
-#else
-#define CV__EXCEPTION_PTR 1
-#endif
-#endif
-#ifndef CV__EXCEPTION_PTR
-#define CV__EXCEPTION_PTR 0
-#elif CV__EXCEPTION_PTR
-#include <exception> // std::exception_ptr
-#endif
-
-#endif // OPENCV_CORE_DETAILS_EXCEPTION_PTR_H
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/dualquaternion.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/dualquaternion.hpp
deleted file mode 100644
index 2b66e33f3c..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/dualquaternion.hpp
+++ /dev/null
@@ -1,1054 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2020, Huawei Technologies Co., Ltd. All rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//       http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Author: Liangqian Kong <kongliangqian@huawei.com>
-//         Longbu Wang <wanglongbu@huawei.com>
-#ifndef OPENCV_CORE_DUALQUATERNION_HPP
-#define OPENCV_CORE_DUALQUATERNION_HPP
-
-#include <opencv2/core/affine.hpp>
-#include <opencv2/core/quaternion.hpp>
-
-namespace cv {
-//! @addtogroup core_quaternion
-//! @{
-
-template <typename _Tp> class DualQuat;
-template <typename _Tp>
-std::ostream &operator<<(std::ostream &, const DualQuat<_Tp> &);
-
-/**
- * Dual quaternions were introduced to describe rotation together with
- * translation while ordinary quaternions can only describe rotation. It can be
- * used for shortest path pose interpolation, local pose optimization or
- * volumetric deformation. More details can be found
- * - https://en.wikipedia.org/wiki/Dual_quaternion
- * - ["A beginners guide to dual-quaternions: what they are, how they work, and
- * how to use them for 3D character hierarchies", Ben Kenwright,
- * 2012](https://borodust.org/public/shared/beginner_dual_quats.pdf)
- * - ["Dual Quaternions", Yan-Bin Jia,
- * 2013](http://web.cs.iastate.edu/~cs577/handouts/dual-quaternion.pdf)
- * - ["Geometric Skinning with Approximate Dual Quaternion Blending", Kavan,
- * 2008](https://www.cs.utah.edu/~ladislav/kavan08geometric/kavan08geometric)
- * - http://rodolphe-vaillant.fr/?e=29
- *
- * A unit dual quaternion can be classically represented as:
- * \f[
- * \begin{equation}
- * \begin{split}
- * \sigma &= \left(r+\frac{\epsilon}{2}tr\right)\\
- * &= [w, x, y, z, w\_, x\_, y\_, z\_]
- * \end{split}
- * \end{equation}
- * \f]
- * where \f$r, t\f$ represents the rotation (ordinary unit quaternion) and
- * translation (pure ordinary quaternion) respectively.
- *
- * A general dual quaternions which consist of two quaternions is usually
- * represented in form of:
- * \f[
- * \sigma = p + \epsilon q
- * \f]
- * where the introduced dual unit \f$\epsilon\f$ satisfies \f$\epsilon^2 =
- * \epsilon^3 =...=0\f$, and \f$p, q\f$ are quaternions.
- *
- * Alternatively, dual quaternions can also be interpreted as four components
- * which are all [dual
- * numbers](https://www.cs.utah.edu/~ladislav/kavan08geometric/kavan08geometric):
- * \f[
- * \sigma = \hat{q}_w + \hat{q}_xi + \hat{q}_yj + \hat{q}_zk
- * \f]
- * If we set \f$\hat{q}_x, \hat{q}_y\f$ and \f$\hat{q}_z\f$ equal to 0, a dual
- * quaternion is transformed to a dual number. see normalize().
- *
- * If you want to create a dual quaternion, you can use:
- *
- * ```
- * using namespace cv;
- * double angle = CV_PI;
- *
- * // create from eight number
- * DualQuatd dq1(1, 2, 3, 4, 5, 6, 7, 8); //p = [1,2,3,4]. q=[5,6,7,8]
- *
- * // create from Vec
- * Vec<double, 8> v{1,2,3,4,5,6,7,8};
- * DualQuatd dq_v{v};
- *
- * // create from two quaternion
- * Quatd p(1, 2, 3, 4);
- * Quatd q(5, 6, 7, 8);
- * DualQuatd dq2 = DualQuatd::createFromQuat(p, q);
- *
- * // create from an angle, an axis and a translation
- * Vec3d axis{0, 0, 1};
- * Vec3d trans{3, 4, 5};
- * DualQuatd dq3 = DualQuatd::createFromAngleAxisTrans(angle, axis, trans);
- *
- * // If you already have an instance of class Affine3, then you can use
- * Affine3d R = dq3.toAffine3();
- * DualQuatd dq4 = DualQuatd::createFromAffine3(R);
- *
- * // or create directly by affine transformation matrix Rt
- * // see createFromMat() in detail for the form of Rt
- * Matx44d Rt = dq3.toMat();
- * DualQuatd dq5 = DualQuatd::createFromMat(Rt);
- *
- * // Any rotation + translation movement can
- * // be expressed as a rotation + translation around the same line in space
- * (expressed by Plucker
- * // coords), and here's a way to represent it this way.
- * Vec3d axis{1, 1, 1}; // axis will be normalized in createFromPitch
- * Vec3d trans{3, 4 ,5};
- * axis = axis / std::sqrt(axis.dot(axis));// The formula for computing moment
- * that I use below requires a normalized axis Vec3d moment = 1.0 / 2 *
- * (trans.cross(axis) + axis.cross(trans.cross(axis)) * std::cos(rotation_angle
- * / 2) / std::sin(rotation_angle / 2)); double d = trans.dot(qaxis); DualQuatd
- * dq6 = DualQuatd::createFromPitch(angle, d, axis, moment);
- * ```
- *
- * A point \f$v=(x, y, z)\f$ in form of dual quaternion is \f$[1+\epsilon
- * v]=[1,0,0,0,0,x,y,z]\f$. The transformation of a point \f$v_1\f$ to another
- * point \f$v_2\f$ under the dual quaternion \f$\sigma\f$ is
- * \f[
- * 1 + \epsilon v_2 = \sigma * (1 + \epsilon v_1) * \sigma^{\star}
- * \f]
- * where \f$\sigma^{\star}=p^*-\epsilon q^*.\f$
- *
- * A line in the \f$Pl\ddot{u}cker\f$ coordinates \f$(\hat{l}, m)\f$ defined by
- * the dual quaternion \f$l=\hat{l}+\epsilon m\f$. To transform a line, \f[l_2 =
- * \sigma * l_1 * \sigma^*,\f] where \f$\sigma=r+\frac{\epsilon}{2}rt\f$ and
- * \f$\sigma^*=p^*+\epsilon q^*\f$.
- *
- * To extract the Vec<double, 8> or Vec<float, 8>, see toVec();
- *
- * To extract the affine transformation matrix, see toMat();
- *
- * To extract the instance of Affine3, see toAffine3();
- *
- * If two quaternions \f$q_0, q_1\f$ are needed to be interpolated, you can use
- * sclerp()
- * ```
- * DualQuatd::sclerp(q0, q1, t)
- * ```
- * or dqblend().
- * ```
- * DualQuatd::dqblend(q0, q1, t)
- * ```
- * With more than two dual quaternions to be blended, you can use generalize
- * linear dual quaternion blending with the corresponding weights, i.e.
- * gdqblend().
- *
- */
-template <typename _Tp> class CV_EXPORTS DualQuat {
-  static_assert(std::is_floating_point<_Tp>::value,
-                "Dual quaternion only make sense with type of float or double");
-  using value_type = _Tp;
-
-public:
-  static constexpr _Tp CV_DUAL_QUAT_EPS = (_Tp)1.e-6;
-
-  DualQuat();
-
-  /**
-   * @brief create from eight same type numbers.
-   */
-  DualQuat(const _Tp w, const _Tp x, const _Tp y, const _Tp z, const _Tp w_,
-           const _Tp x_, const _Tp y_, const _Tp z_);
-
-  /**
-   * @brief create from a double or float vector.
-   */
-  DualQuat(const Vec<_Tp, 8> &q);
-
-  _Tp w, x, y, z, w_, x_, y_, z_;
-
-  /**
-   * @brief create Dual Quaternion from two same type quaternions p and q.
-   * A Dual Quaternion \f$\sigma\f$ has the form:
-   * \f[\sigma = p + \epsilon q\f]
-   * where p and q are defined as follows:
-   * \f[\begin{equation}
-   *    \begin{split}
-   *    p &= w + x\boldsymbol{i} + y\boldsymbol{j} + z\boldsymbol{k}\\
-   *    q &= w\_ + x\_\boldsymbol{i} + y\_\boldsymbol{j} + z\_\boldsymbol{k}.
-   *    \end{split}
-   *   \end{equation}
-   * \f]
-   * The p and q are the real part and dual part respectively.
-   * @param realPart a quaternion, real part of dual quaternion.
-   * @param dualPart a quaternion, dual part of dual quaternion.
-   * @sa Quat
-   */
-  static DualQuat<_Tp> createFromQuat(const Quat<_Tp> &realPart,
-                                      const Quat<_Tp> &dualPart);
-
-  /**
-   * @brief create a dual quaternion from a rotation angle \f$\theta\f$, a
-   * rotation axis
-   * \f$\boldsymbol{u}\f$ and a translation \f$\boldsymbol{t}\f$.
-   * It generates a dual quaternion \f$\sigma\f$ in the form of
-   * \f[\begin{equation}
-   *    \begin{split}
-   *    \sigma &= r + \frac{\epsilon}{2}\boldsymbol{t}r \\
-   *           &= [\cos(\frac{\theta}{2}), \boldsymbol{u}\sin(\frac{\theta}{2})]
-   *           + \frac{\epsilon}{2}[0, \boldsymbol{t}][[\cos(\frac{\theta}{2}),
-   *           \boldsymbol{u}\sin(\frac{\theta}{2})]]\\
-   *           &= \cos(\frac{\theta}{2}) + \boldsymbol{u}\sin(\frac{\theta}{2})
-   *           + \frac{\epsilon}{2}(-(\boldsymbol{t} \cdot
-   * \boldsymbol{u})\sin(\frac{\theta}{2})
-   *           + \boldsymbol{t}\cos(\frac{\theta}{2}) + \boldsymbol{u} \times
-   * \boldsymbol{t} \sin(\frac{\theta}{2})).
-   *    \end{split}
-   *    \end{equation}\f]
-   * @param angle rotation angle.
-   * @param axis rotation axis.
-   * @param translation a vector of length 3.
-   * @note Axis will be normalized in this function. And translation is applied
-   * after the rotation. Use @ref createFromQuat(r, r * t / 2) to create a dual
-   * quaternion which translation is applied before rotation.
-   * @sa Quat
-   */
-  static DualQuat<_Tp> createFromAngleAxisTrans(const _Tp angle,
-                                                const Vec<_Tp, 3> &axis,
-                                                const Vec<_Tp, 3> &translation);
-
-  /**
-   * @brief Transform this dual quaternion to an affine transformation matrix
-   * \f$M\f$. Dual quaternion consists of a rotation \f$r=[a,b,c,d]\f$ and a
-   * translation \f$t=[\Delta x,\Delta y,\Delta z]\f$. The affine transformation
-   * matrix \f$M\f$ has the form
-   * \f[
-   * \begin{bmatrix}
-   * 1-2(e_2^2 +e_3^2) &2(e_1e_2-e_0e_3) &2(e_0e_2+e_1e_3) &\Delta x\\
-   * 2(e_0e_3+e_1e_2)  &1-2(e_1^2+e_3^2) &2(e_2e_3-e_0e_1) &\Delta y\\
-   * 2(e_1e_3-e_0e_2)  &2(e_0e_1+e_2e_3) &1-2(e_1^2-e_2^2) &\Delta z\\
-   * 0&0&0&1
-   * \end{bmatrix}
-   * \f]
-   *  if A is a matrix consisting of  n points to be transformed, this could be
-   * achieved by
-   * \f[
-   *  new\_A = M * A
-   * \f]
-   * where A has the form
-   * \f[
-   * \begin{bmatrix}
-   * x_0& x_1& x_2&...&x_n\\
-   * y_0& y_1& y_2&...&y_n\\
-   * z_0& z_1& z_2&...&z_n\\
-   * 1&1&1&...&1
-   * \end{bmatrix}
-   * \f]
-   * where the same subscript represent the same point. The size of A should be
-   * \f$[4,n]\f$. and the same size for matrix new_A.
-   * @param _R 4x4 matrix that represents rotations and translation.
-   * @note Translation is applied after the rotation. Use createFromQuat(r, r *
-   * t / 2) to create a dual quaternion which translation is applied before
-   * rotation.
-   */
-  static DualQuat<_Tp> createFromMat(InputArray _R);
-
-  /**
-   * @brief create dual quaternion from an affine matrix. The definition of
-   * affine matrix can refer to  createFromMat()
-   */
-  static DualQuat<_Tp> createFromAffine3(const Affine3<_Tp> &R);
-
-  /**
-   * @brief A dual quaternion is a vector in form of
-   * \f[
-   * \begin{equation}
-   * \begin{split}
-   * \sigma &=\boldsymbol{p} + \epsilon \boldsymbol{q}\\
-   * &= \cos\hat{\frac{\theta}{2}}+\overline{\hat{l}}\sin\frac{\hat{\theta}}{2}
-   * \end{split}
-   * \end{equation}
-   * \f]
-   * where \f$\hat{\theta}\f$ is dual angle and \f$\overline{\hat{l}}\f$ is dual
-   * axis:
-   * \f[
-   * \hat{\theta}=\theta + \epsilon d,\\
-   * \overline{\hat{l}}= \hat{l} +\epsilon m.
-   * \f]
-   * In this representation, \f$\theta\f$ is rotation angle and
-   * \f$(\hat{l},m)\f$ is the screw axis, d is the translation distance along
-   * the axis.
-   *
-   * @param angle rotation angle.
-   * @param d translation along the rotation axis.
-   * @param axis rotation axis represented by quaternion with w = 0.
-   * @param moment the moment of line, and it should be orthogonal to axis.
-   * @note Translation is applied after the rotation. Use createFromQuat(r, r *
-   * t / 2) to create a dual quaternion which translation is applied before
-   * rotation.
-   */
-  static DualQuat<_Tp> createFromPitch(const _Tp angle, const _Tp d,
-                                       const Vec<_Tp, 3> &axis,
-                                       const Vec<_Tp, 3> &moment);
-
-  /**
-   * @brief return a quaternion which represent the real part of dual
-   * quaternion. The definition of real part is in createFromQuat().
-   * @sa createFromQuat, getDualPart
-   */
-  Quat<_Tp> getRealPart() const;
-
-  /**
-   * @brief return a quaternion which represent the dual part of dual
-   * quaternion. The definition of dual part is in createFromQuat().
-   * @sa createFromQuat, getRealPart
-   */
-  Quat<_Tp> getDualPart() const;
-
-  /**
-   * @brief return the conjugate of a dual quaternion.
-   * \f[
-   * \begin{equation}
-   * \begin{split}
-   * \sigma^* &= (p + \epsilon q)^*
-   *          &= (p^* + \epsilon q^*)
-   * \end{split}
-   * \end{equation}
-   * \f]
-   * @param dq a dual quaternion.
-   */
-  template <typename T> friend DualQuat<T> conjugate(const DualQuat<T> &dq);
-
-  /**
-   * @brief return the conjugate of a dual quaternion.
-   * \f[
-   * \begin{equation}
-   * \begin{split}
-   * \sigma^* &= (p + \epsilon q)^*
-   *          &= (p^* + \epsilon q^*)
-   * \end{split}
-   * \end{equation}
-   * \f]
-   */
-  DualQuat<_Tp> conjugate() const;
-
-  /**
-   * @brief return the rotation in quaternion form.
-   */
-  Quat<_Tp> getRotation(QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
-
-  /**
-   * @brief return the translation vector.
-   * The rotation \f$r\f$ in this dual quaternion \f$\sigma\f$ is applied before
-   * translation \f$t\f$. The dual quaternion \f$\sigma\f$ is defined as
-   * \f[\begin{equation}
-   * \begin{split}
-   * \sigma &= p + \epsilon q \\
-   *        &= r + \frac{\epsilon}{2}{t}r.
-   * \end{split}
-   * \end{equation}\f]
-   * Thus, the translation can be obtained as follows
-   * \f[t = 2qp^*.\f]
-   * @param assumeUnit if @ref QUAT_ASSUME_UNIT, this dual quaternion assume to
-   * be a unit dual quaternion and this function will save some computations.
-   * @note This dual quaternion's translation is applied after the rotation.
-   */
-  Vec<_Tp, 3>
-  getTranslation(QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
-
-  /**
-   * @brief return the norm \f$||\sigma||\f$ of dual quaternion \f$\sigma = p +
-   * \epsilon q\f$.
-   * \f[
-   *  \begin{equation}
-   *  \begin{split}
-   *  ||\sigma|| &= \sqrt{\sigma * \sigma^*} \\
-   *        &= ||p|| + \epsilon \frac{p \cdot q}{||p||}.
-   *  \end{split}
-   *  \end{equation}
-   *  \f]
-   * Generally speaking, the norm of a not unit dual
-   * quaternion is a dual number. For convenience, we return it in the form of a
-   * dual quaternion , i.e.
-   * \f[ ||\sigma|| = [||p||, 0, 0, 0, \frac{p \cdot q}{||p||}, 0, 0, 0].\f]
-   *
-   * @note The data type of dual number is dual quaternion.
-   */
-  DualQuat<_Tp> norm() const;
-
-  /**
-   * @brief return a normalized dual quaternion.
-   * A dual quaternion can be expressed as
-   * \f[
-   * \begin{equation}
-   * \begin{split}
-   * \sigma &= p + \epsilon q\\
-   * &=||\sigma||\left(r+\frac{1}{2}tr\right)
-   * \end{split}
-   * \end{equation}
-   * \f]
-   * where \f$r, t\f$ represents the rotation (ordinary quaternion) and
-   * translation (pure ordinary quaternion) respectively, and \f$||\sigma||\f$
-   * is the norm of dual quaternion(a dual number). A dual quaternion is unit if
-   * and only if
-   * \f[
-   * ||p||=1, p \cdot q=0
-   * \f]
-   * where \f$\cdot\f$ means dot product.
-   * The process of normalization is
-   * \f[
-   * \sigma_{u}=\frac{\sigma}{||\sigma||}
-   * \f]
-   * Next, we simply proof \f$\sigma_u\f$ is a unit dual quaternion:
-   * \f[
-   * \renewcommand{\Im}{\operatorname{Im}}
-   * \begin{equation}
-   * \begin{split}
-   * \sigma_{u}=\frac{\sigma}{||\sigma||}&=\frac{p + \epsilon
-   * q}{||p||+\epsilon\frac{p\cdot q}{||p||}}\\
-   * &=\frac{p}{||p||}+\epsilon\left(\frac{q}{||p||}-p\frac{p\cdot
-   * q}{||p||^3}\right)\\
-   * &=\frac{p}{||p||}+\epsilon\frac{1}{||p||^2}\left(qp^{*}-p\cdot
-   * q\right)\frac{p}{||p||}\\
-   * &=\frac{p}{||p||}+\epsilon\frac{1}{||p||^2}\Im(qp^*)\frac{p}{||p||}.\\
-   * \end{split}
-   * \end{equation}
-   * \f]
-   * As expected, the real part is a rotation and dual part is a pure
-   * quaternion.
-   */
-  DualQuat<_Tp> normalize() const;
-
-  /**
-   * @brief if \f$\sigma = p + \epsilon q\f$ is a dual quaternion, p is not
-   * zero, the inverse dual quaternion is
-   * \f[\sigma^{-1} = \frac{\sigma^*}{||\sigma||^2}, \f]
-   * or equivalentlly,
-   * \f[\sigma^{-1} = p^{-1} - \epsilon p^{-1}qp^{-1}.\f]
-   * @param dq a dual quaternion.
-   * @param assumeUnit if @ref QUAT_ASSUME_UNIT, dual quaternion dq assume to be
-   * a unit dual quaternion and this function will save some computations.
-   */
-  template <typename T>
-  friend DualQuat<T> inv(const DualQuat<T> &dq, QuatAssumeType assumeUnit);
-
-  /**
-   * @brief if \f$\sigma = p + \epsilon q\f$ is a dual quaternion, p is not
-   * zero, the inverse dual quaternion is
-   * \f[\sigma^{-1} = \frac{\sigma^*}{||\sigma||^2}, \f]
-   * or equivalentlly,
-   * \f[\sigma^{-1} = p^{-1} - \epsilon p^{-1}qp^{-1}.\f]
-   * @param assumeUnit if @ref QUAT_ASSUME_UNIT, this dual quaternion assume to
-   * be a unit dual quaternion and this function will save some computations.
-   */
-  DualQuat<_Tp> inv(QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
-
-  /**
-   * @brief return the dot product of two dual quaternion.
-   * @param p other dual quaternion.
-   */
-  _Tp dot(DualQuat<_Tp> p) const;
-
-  /**
-   ** @brief return the value of \f$p^t\f$ where p is a dual quaternion.
-   * This could be calculated as:
-   * \f[
-   * p^t = \exp(t\ln p)
-   * \f]
-   * @param dq a dual quaternion.
-   * @param t index of power function.
-   * @param assumeUnit if @ref QUAT_ASSUME_UNIT, dual quaternion dq assume to be
-   *a unit dual quaternion and this function will save some computations.
-   */
-  template <typename T>
-  friend DualQuat<T> power(const DualQuat<T> &dq, const T t,
-                           QuatAssumeType assumeUnit);
-
-  /**
-   ** @brief return the value of \f$p^t\f$ where p is a dual quaternion.
-   * This could be calculated as:
-   * \f[
-   * p^t = \exp(t\ln p)
-   * \f]
-   *
-   * @param t index of power function.
-   * @param assumeUnit if @ref QUAT_ASSUME_UNIT, this dual quaternion assume to
-   *be a unit dual quaternion and this function will save some computations.
-   */
-  DualQuat<_Tp> power(const _Tp t,
-                      QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
-
-  /**
-   * @brief return the value of \f$p^q\f$ where p and q are dual quaternions.
-   * This could be calculated as:
-   * \f[
-   * p^q = \exp(q\ln p)
-   * \f]
-   * @param p a dual quaternion.
-   * @param q a dual quaternion.
-   * @param assumeUnit if @ref QUAT_ASSUME_UNIT, dual quaternion p assume to be
-   * a dual unit quaternion and this function will save some computations.
-   */
-  template <typename T>
-  friend DualQuat<T> power(const DualQuat<T> &p, const DualQuat<T> &q,
-                           QuatAssumeType assumeUnit);
-
-  /**
-   * @brief return the value of \f$p^q\f$ where p and q are dual quaternions.
-   * This could be calculated as:
-   * \f[
-   * p^q = \exp(q\ln p)
-   * \f]
-   *
-   * @param q a dual quaternion
-   * @param assumeUnit if @ref QUAT_ASSUME_UNIT, this dual quaternion assume to
-   * be a dual unit quaternion and this function will save some computations.
-   */
-  DualQuat<_Tp> power(const DualQuat<_Tp> &q,
-                      QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
-
-  /**
-   * @brief return the value of exponential function value
-   * @param dq a dual quaternion.
-   */
-  template <typename T> friend DualQuat<T> exp(const DualQuat<T> &dq);
-
-  /**
-   * @brief return the value of exponential function value
-   */
-  DualQuat<_Tp> exp() const;
-
-  /**
-   * @brief return the value of logarithm function value
-   *
-   * @param dq a dual quaternion.
-   * @param assumeUnit if @ref QUAT_ASSUME_UNIT, dual quaternion dq assume to be
-   * a unit dual quaternion and this function will save some computations.
-   */
-  template <typename T>
-  friend DualQuat<T> log(const DualQuat<T> &dq, QuatAssumeType assumeUnit);
-
-  /**
-   * @brief return the value of logarithm function value
-   * @param assumeUnit if @ref QUAT_ASSUME_UNIT, this dual quaternion assume to
-   * be a unit dual quaternion and this function will save some computations.
-   */
-  DualQuat<_Tp> log(QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
-
-  /**
-   * @brief Transform this dual quaternion to a vector.
-   */
-  Vec<_Tp, 8> toVec() const;
-
-  /**
-   * @brief Transform this dual quaternion to a affine transformation matrix
-   * the form of matrix, see createFromMat().
-   */
-  Matx<_Tp, 4, 4> toMat(QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
-
-  /**
-   * @brief Transform this dual quaternion to a instance of Affine3.
-   */
-  Affine3<_Tp>
-  toAffine3(QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
-
-  /**
-   * @brief The screw linear interpolation(ScLERP) is an extension of spherical
-   * linear interpolation of dual quaternion. If \f$\sigma_1\f$ and
-   * \f$\sigma_2\f$ are two dual quaternions representing the initial and final
-   * pose. The interpolation of ScLERP function can be defined as:
-   * \f[
-   * ScLERP(t;\sigma_1,\sigma_2) = \sigma_1 * (\sigma_1^{-1} * \sigma_2)^t,
-   * t\in[0,1]
-   * \f]
-   *
-   * @param q1 a dual quaternion represents a initial pose.
-   * @param q2 a dual quaternion represents a final pose.
-   * @param t interpolation parameter
-   * @param directChange if true, it always return the shortest path.
-   * @param assumeUnit if @ref QUAT_ASSUME_UNIT, this dual quaternion assume to
-   * be a unit dual quaternion and this function will save some computations.
-   *
-   * For example
-   * ```
-   * double angle1 = CV_PI / 2;
-   * Vec3d axis{0, 0, 1};
-   * Vec3d t(0, 0, 3);
-   * DualQuatd initial = DualQuatd::createFromAngleAxisTrans(angle1, axis, t);
-   * double angle2 = CV_PI;
-   * DualQuatd final = DualQuatd::createFromAngleAxisTrans(angle2, axis, t);
-   * DualQuatd inter = DualQuatd::sclerp(initial, final, 0.5);
-   * ```
-   */
-  static DualQuat<_Tp> sclerp(const DualQuat<_Tp> &q1, const DualQuat<_Tp> &q2,
-                              const _Tp t, bool directChange = true,
-                              QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT);
-  /**
-   * @brief The method of Dual Quaternion linear Blending(DQB) is to compute a
-   * transformation between dual quaternion
-   * \f$q_1\f$ and \f$q_2\f$ and can be defined as:
-   * \f[
-   * DQB(t;{\boldsymbol{q}}_1,{\boldsymbol{q}}_2)=
-   * \frac{(1-t){\boldsymbol{q}}_1+t{\boldsymbol{q}}_2}{||(1-t){\boldsymbol{q}}_1+t{\boldsymbol{q}}_2||}.
-   * \f]
-   * where \f$q_1\f$ and \f$q_2\f$ are unit dual quaternions representing the
-   * input transformations. If you want to use DQB that works for more than two
-   * rigid transformations, see @ref gdqblend
-   *
-   * @param q1 a unit dual quaternion representing the input transformations.
-   * @param q2 a unit dual quaternion representing the input transformations.
-   * @param t parameter \f$t\in[0,1]\f$.
-   * @param assumeUnit if @ref QUAT_ASSUME_UNIT, this dual quaternion assume to
-   * be a unit dual quaternion and this function will save some computations.
-   *
-   * @sa gdqblend
-   */
-  static DualQuat<_Tp>
-  dqblend(const DualQuat<_Tp> &q1, const DualQuat<_Tp> &q2, const _Tp t,
-          QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT);
-
-  /**
-   * @brief The generalized Dual Quaternion linear Blending works for more than
-   * two rigid transformations. If these transformations are expressed as unit
-   * dual quaternions \f$q_1,...,q_n\f$ with convex weights
-   * \f$w = (w_1,...,w_n)\f$, the generalized DQB is simply
-   * \f[
-   * gDQB(\boldsymbol{w};{\boldsymbol{q}}_1,...,{\boldsymbol{q}}_n)=\frac{w_1{\boldsymbol{q}}_1+...+w_n{\boldsymbol{q}}_n}
-   * {||w_1{\boldsymbol{q}}_1+...+w_n{\boldsymbol{q}}_n||}.
-   * \f]
-   * @param dualquat vector of dual quaternions
-   * @param weights vector of weights, the size of weights should be the same as
-   * dualquat, and the weights should satisfy \f$\sum_0^n w_{i} = 1\f$ and
-   * \f$w_i>0\f$.
-   * @param assumeUnit if @ref QUAT_ASSUME_UNIT, these dual quaternions assume
-   * to be unit quaternions and this function will save some computations.
-   * @note the type of weights' element should be the same as the date type of
-   * dual quaternion inside the dualquat.
-   */
-  template <int cn>
-  static DualQuat<_Tp>
-  gdqblend(const Vec<DualQuat<_Tp>, cn> &dualquat, InputArray weights,
-           QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT);
-
-  /**
-   * @brief The generalized Dual Quaternion linear Blending works for more than
-   * two rigid transformations. If these transformations are expressed as unit
-   * dual quaternions \f$q_1,...,q_n\f$ with convex weights
-   * \f$w = (w_1,...,w_n)\f$, the generalized DQB is simply
-   * \f[
-   * gDQB(\boldsymbol{w};{\boldsymbol{q}}_1,...,{\boldsymbol{q}}_n)=\frac{w_1{\boldsymbol{q}}_1+...+w_n{\boldsymbol{q}}_n}
-   * {||w_1{\boldsymbol{q}}_1+...+w_n{\boldsymbol{q}}_n||}.
-   * \f]
-   * @param dualquat The dual quaternions which have 8 channels and 1 row or 1
-   * col.
-   * @param weights vector of weights, the size of weights should be the same as
-   * dualquat, and the weights should satisfy \f$\sum_0^n w_{i} = 1\f$ and
-   * \f$w_i>0\f$.
-   * @param assumeUnit if @ref QUAT_ASSUME_UNIT, these dual quaternions assume
-   * to be unit quaternions and this function will save some computations.
-   * @note the type of weights' element should be the same as the date type of
-   * dual quaternion inside the dualquat.
-   */
-  static DualQuat<_Tp>
-  gdqblend(InputArray dualquat, InputArray weights,
-           QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT);
-
-  /**
-   * @brief Return opposite dual quaternion \f$-p\f$
-   * which satisfies \f$p + (-p) = 0.\f$
-   *
-   * For example
-   * ```
-   * DualQuatd q{1, 2, 3, 4, 5, 6, 7, 8};
-   * std::cout << -q << std::endl; // [-1, -2, -3, -4, -5, -6, -7, -8]
-   * ```
-   */
-  DualQuat<_Tp> operator-() const;
-
-  /**
-   * @brief return true if two dual quaternions p and q are nearly equal, i.e.
-   * when the absolute value of each \f$p_i\f$ and \f$q_i\f$ is less than
-   * CV_DUAL_QUAT_EPS.
-   */
-  bool operator==(const DualQuat<_Tp> &) const;
-
-  /**
-   * @brief Subtraction operator of two dual quaternions p and q.
-   * It returns a new dual quaternion that each value is the sum of \f$p_i\f$
-   * and \f$-q_i\f$.
-   *
-   * For example
-   * ```
-   * DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
-   * DualQuatd q{5, 6, 7, 8, 9, 10, 11, 12};
-   * std::cout << p - q << std::endl; //[-4, -4, -4, -4, 4, -4, -4, -4]
-   * ```
-   */
-  DualQuat<_Tp> operator-(const DualQuat<_Tp> &) const;
-
-  /**
-   * @brief Subtraction assignment operator of two dual quaternions p and q.
-   * It subtracts right operand from the left operand and assign the result to
-   * left operand.
-   *
-   * For example
-   * ```
-   * DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
-   * DualQuatd q{5, 6, 7, 8, 9, 10, 11, 12};
-   * p -= q; // equivalent to p = p - q
-   * std::cout << p << std::endl; //[-4, -4, -4, -4, 4, -4, -4, -4]
-   *
-   * ```
-   */
-  DualQuat<_Tp> &operator-=(const DualQuat<_Tp> &);
-
-  /**
-   * @brief Addition operator of two dual quaternions p and q.
-   * It returns a new dual quaternion that each value is the sum of \f$p_i\f$
-   * and \f$q_i\f$.
-   *
-   * For example
-   * ```
-   * DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
-   * DualQuatd q{5, 6, 7, 8, 9, 10, 11, 12};
-   * std::cout << p + q << std::endl; //[6, 8, 10, 12, 14, 16, 18, 20]
-   * ```
-   */
-  DualQuat<_Tp> operator+(const DualQuat<_Tp> &) const;
-
-  /**
-   * @brief Addition assignment operator of two dual quaternions p and q.
-   * It adds right operand to the left operand and assign the result to left
-   * operand.
-   *
-   * For example
-   * ```
-   * DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
-   * DualQuatd q{5, 6, 7, 8, 9, 10, 11, 12};
-   * p += q; // equivalent to p = p + q
-   * std::cout << p << std::endl; //[6, 8, 10, 12, 14, 16, 18, 20]
-   *
-   * ```
-   */
-  DualQuat<_Tp> &operator+=(const DualQuat<_Tp> &);
-
-  /**
-   * @brief Multiplication assignment operator of two quaternions.
-   * It multiplies right operand with the left operand and assign the result to
-   * left operand.
-   *
-   * Rule of dual quaternion multiplication:
-   * The dual quaternion can be written as an ordered pair of quaternions [A,
-   * B]. Thus
-   * \f[
-   * \begin{equation}
-   * \begin{split}
-   * p * q &= [A, B][C, D]\\
-   * &=[AC, AD + BC]
-   * \end{split}
-   * \end{equation}
-   * \f]
-   *
-   * For example
-   * ```
-   * DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
-   * DualQuatd q{5, 6, 7, 8, 9, 10, 11, 12};
-   * p *= q;
-   * std::cout << p << std::endl; //[-60, 12, 30, 24, -216, 80, 124, 120]
-   * ```
-   */
-  DualQuat<_Tp> &operator*=(const DualQuat<_Tp> &);
-
-  /**
-   * @brief Multiplication assignment operator of a quaternions and a scalar.
-   * It multiplies right operand with the left operand and assign the result to
-   * left operand.
-   *
-   * Rule of dual quaternion multiplication with a scalar:
-   * \f[
-   * \begin{equation}
-   * \begin{split}
-   * p * s &= [w, x, y, z, w\_, x\_, y\_, z\_] * s\\
-   *  &=[w   s, x   s, y   s, z   s, w\_  \space  s, x\_  \space  s, y\_ \space
-   * s, z\_ \space  s].
-   * \end{split}
-   * \end{equation}
-   * \f]
-   *
-   * For example
-   * ```
-   * DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
-   * double s = 2.0;
-   * p *= s;
-   * std::cout << p << std::endl; //[2, 4, 6, 8, 10, 12, 14, 16]
-   * ```
-   * @note the type of scalar should be equal to the dual quaternion.
-   */
-  DualQuat<_Tp> operator*=(const _Tp s);
-
-  /**
-   * @brief Multiplication operator of two dual quaternions q and p.
-   * Multiplies values on either side of the operator.
-   *
-   * Rule of dual quaternion multiplication:
-   * The dual quaternion can be written as an ordered pair of quaternions [A,
-   * B]. Thus
-   * \f[
-   * \begin{equation}
-   * \begin{split}
-   * p * q &= [A, B][C, D]\\
-   * &=[AC, AD + BC]
-   * \end{split}
-   * \end{equation}
-   * \f]
-   *
-   * For example
-   * ```
-   * DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
-   * DualQuatd q{5, 6, 7, 8, 9, 10, 11, 12};
-   * std::cout << p * q << std::endl; //[-60, 12, 30, 24, -216, 80, 124, 120]
-   * ```
-   */
-  DualQuat<_Tp> operator*(const DualQuat<_Tp> &) const;
-
-  /**
-   * @brief Division operator of a dual quaternions and a scalar.
-   * It divides left operand with the right operand and assign the result to
-   * left operand.
-   *
-   * Rule of dual quaternion division with a scalar:
-   * \f[
-   * \begin{equation}
-   * \begin{split}
-   * p / s &= [w, x, y, z, w\_, x\_, y\_, z\_] / s\\
-   * &=[w/s, x/s, y/s, z/s, w\_/s, x\_/s, y\_/s, z\_/s].
-   * \end{split}
-   * \end{equation}
-   * \f]
-   *
-   * For example
-   * ```
-   * DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
-   * double s = 2.0;
-   * p /= s; // equivalent to p = p / s
-   * std::cout << p << std::endl; //[0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4]
-   * ```
-   * @note the type of scalar should be equal to this dual quaternion.
-   */
-  DualQuat<_Tp> operator/(const _Tp s) const;
-
-  /**
-   * @brief Division operator of two dual quaternions p and q.
-   * Divides left hand operand by right hand operand.
-   *
-   * Rule of dual quaternion division with a dual quaternion:
-   * \f[
-   * \begin{equation}
-   * \begin{split}
-   * p / q &= p * q.inv()\\
-   * \end{split}
-   * \end{equation}
-   * \f]
-   *
-   * For example
-   * ```
-   * DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
-   * DualQuatd q{5, 6, 7, 8, 9, 10, 11, 12};
-   * std::cout << p / q << std::endl; // equivalent to p * q.inv()
-   * ```
-   */
-  DualQuat<_Tp> operator/(const DualQuat<_Tp> &) const;
-
-  /**
-   * @brief Division assignment operator of two dual quaternions p and q;
-   * It divides left operand with the right operand and assign the result to
-   * left operand.
-   *
-   * Rule of dual quaternion division with a quaternion:
-   * \f[
-   * \begin{equation}
-   * \begin{split}
-   * p / q&= p * q.inv()\\
-   * \end{split}
-   * \end{equation}
-   * \f]
-   *
-   * For example
-   * ```
-   * DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
-   * DualQuatd q{5, 6, 7, 8, 9, 10, 11, 12};
-   * p /= q; // equivalent to p = p * q.inv()
-   * std::cout << p << std::endl;
-   * ```
-   */
-  DualQuat<_Tp> &operator/=(const DualQuat<_Tp> &);
-
-  /**
-   * @brief Division assignment operator of a dual quaternions and a scalar.
-   * It divides left operand with the right operand and assign the result to
-   * left operand.
-   *
-   * Rule of dual quaternion division with a scalar:
-   * \f[
-   * \begin{equation}
-   * \begin{split}
-   * p / s &= [w, x, y, z, w\_, x\_, y\_ ,z\_] / s\\
-   * &=[w / s, x / s, y / s, z / s, w\_ / \space s, x\_ / \space s, y\_ / \space
-   * s, z\_ / \space s].
-   * \end{split}
-   * \end{equation}
-   * \f]
-   *
-   * For example
-   * ```
-   * DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
-   * double s = 2.0;;
-   * p /= s; // equivalent to p = p / s
-   * std::cout << p << std::endl; //[0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0]
-   * ```
-   * @note the type of scalar should be equal to the dual quaternion.
-   */
-  Quat<_Tp> &operator/=(const _Tp s);
-
-  /**
-   * @brief Addition operator of a scalar and a dual quaternions.
-   * Adds right hand operand from left hand operand.
-   *
-   * For example
-   * ```
-   * DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
-   * double scalar = 2.0;
-   * std::cout << scalar + p << std::endl; //[3.0, 2, 3, 4, 5, 6, 7, 8]
-   * ```
-   * @note the type of scalar should be equal to the dual quaternion.
-   */
-  template <typename T>
-  friend DualQuat<T> cv::operator+(const T s, const DualQuat<T> &);
-
-  /**
-   * @brief Addition operator of a dual quaternions and a scalar.
-   * Adds right hand operand from left hand operand.
-   *
-   * For example
-   * ```
-   * DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
-   * double scalar = 2.0;
-   * std::cout << p + scalar << std::endl; //[3.0, 2, 3, 4, 5, 6, 7, 8]
-   * ```
-   * @note the type of scalar should be equal to the dual quaternion.
-   */
-  template <typename T>
-  friend DualQuat<T> cv::operator+(const DualQuat<T> &, const T s);
-
-  /**
-   * @brief Multiplication operator of a scalar and a dual quaternions.
-   * It multiplies right operand with the left operand and assign the result to
-   * left operand.
-   *
-   * Rule of dual quaternion multiplication with a scalar:
-   * \f[
-   * \begin{equation}
-   * \begin{split}
-   * p * s &= [w, x, y, z, w\_, x\_, y\_, z\_] * s\\
-   * &=[w s, x s, y s, z s, w\_ \space s, x\_ \space s, y\_ \space s, z\_ \space
-   * s].
-   * \end{split}
-   * \end{equation}
-   * \f]
-   *
-   * For example
-   * ```
-   * DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
-   * double s = 2.0;
-   * std::cout << s * p << std::endl; //[2, 4, 6, 8, 10, 12, 14, 16]
-   * ```
-   * @note the type of scalar should be equal to the dual quaternion.
-   */
-  template <typename T>
-  friend DualQuat<T> cv::operator*(const T s, const DualQuat<T> &);
-
-  /**
-   * @brief Subtraction operator of a dual quaternion and a scalar.
-   * Subtracts right hand operand from left hand operand.
-   *
-   * For example
-   * ```
-   * DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
-   * double scalar = 2.0;
-   * std::cout << p - scalar << std::endl; //[-1, 2, 3, 4, 5, 6, 7, 8]
-   * ```
-   * @note the type of scalar should be equal to the dual quaternion.
-   */
-  template <typename T>
-  friend DualQuat<T> cv::operator-(const DualQuat<T> &, const T s);
-
-  /**
-   * @brief Subtraction operator of a scalar and a dual quaternions.
-   * Subtracts right hand operand from left hand operand.
-   *
-   * For example
-   * ```
-   * DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
-   * double scalar = 2.0;
-   * std::cout << scalar - p << std::endl; //[1.0, -2, -3, -4, -5, -6, -7, -8]
-   * ```
-   * @note the type of scalar should be equal to the dual quaternion.
-   */
-  template <typename T>
-  friend DualQuat<T> cv::operator-(const T s, const DualQuat<T> &);
-
-  /**
-   * @brief Multiplication operator of a dual quaternions and a scalar.
-   * It multiplies right operand with the left operand and assign the result to
-   * left operand.
-   *
-   * Rule of dual quaternion multiplication with a scalar:
-   * \f[
-   * \begin{equation}
-   * \begin{split}
-   * p * s &= [w, x, y, z, w\_, x\_, y\_, z\_] * s\\
-   * &=[w s, x s, y s, z s, w\_ \space s, x\_ \space s, y\_ \space s, z\_ \space
-   * s].
-   * \end{split}
-   * \end{equation}
-   * \f]
-   *
-   * For example
-   * ```
-   * DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
-   * double s = 2.0;
-   * std::cout << p * s << std::endl; //[2, 4, 6, 8, 10, 12, 14, 16]
-   * ```
-   * @note the type of scalar should be equal to the dual quaternion.
-   */
-  template <typename T>
-  friend DualQuat<T> cv::operator*(const DualQuat<T> &, const T s);
-
-  template <typename S>
-  friend std::ostream &cv::operator<<(std::ostream &, const DualQuat<S> &);
-};
-
-using DualQuatd = DualQuat<double>;
-using DualQuatf = DualQuat<float>;
-
-//! @} core
-} // namespace cv
-
-#include "dualquaternion.inl.hpp"
-
-#endif /* OPENCV_CORE_QUATERNION_HPP */
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/dualquaternion.inl.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/dualquaternion.inl.hpp
deleted file mode 100644
index fba598e866..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/dualquaternion.inl.hpp
+++ /dev/null
@@ -1,464 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2020, Huawei Technologies Co., Ltd. All rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//       http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Author: Liangqian Kong <kongliangqian@huawei.com>
-//         Longbu Wang <wanglongbu@huawei.com>
-
-#ifndef OPENCV_CORE_DUALQUATERNION_INL_HPP
-#define OPENCV_CORE_DUALQUATERNION_INL_HPP
-
-#ifndef OPENCV_CORE_DUALQUATERNION_HPP
-#error This is not a standalone header. Include dualquaternion.hpp instead.
-#endif
-
-///////////////////////////////////////////////////////////////////////////////////////
-// Implementation
-namespace cv {
-
-template <typename T>
-DualQuat<T>::DualQuat() : w(0), x(0), y(0), z(0), w_(0), x_(0), y_(0), z_(0) {}
-
-template <typename T>
-DualQuat<T>::DualQuat(const T vw, const T vx, const T vy, const T vz,
-                      const T _w, const T _x, const T _y, const T _z)
-    : w(vw), x(vx), y(vy), z(vz), w_(_w), x_(_x), y_(_y), z_(_z) {}
-
-template <typename T>
-DualQuat<T>::DualQuat(const Vec<T, 8> &q)
-    : w(q[0]), x(q[1]), y(q[2]), z(q[3]), w_(q[4]), x_(q[5]), y_(q[6]),
-      z_(q[7]) {}
-
-template <typename T>
-DualQuat<T> DualQuat<T>::createFromQuat(const Quat<T> &realPart,
-                                        const Quat<T> &dualPart) {
-  T w = realPart.w;
-  T x = realPart.x;
-  T y = realPart.y;
-  T z = realPart.z;
-  T w_ = dualPart.w;
-  T x_ = dualPart.x;
-  T y_ = dualPart.y;
-  T z_ = dualPart.z;
-  return DualQuat<T>(w, x, y, z, w_, x_, y_, z_);
-}
-
-template <typename T>
-DualQuat<T> DualQuat<T>::createFromAngleAxisTrans(const T angle,
-                                                  const Vec<T, 3> &axis,
-                                                  const Vec<T, 3> &trans) {
-  Quat<T> r = Quat<T>::createFromAngleAxis(angle, axis);
-  Quat<T> t{0, trans[0], trans[1], trans[2]};
-  return createFromQuat(r, t * r * T(0.5));
-}
-
-template <typename T> DualQuat<T> DualQuat<T>::createFromMat(InputArray _R) {
-  CV_CheckTypeEQ(_R.type(), cv::traits::Type<T>::value, "");
-  if (_R.size() != Size(4, 4)) {
-    CV_Error(Error::StsBadArg,
-             "The input matrix must have 4 columns and 4 rows");
-  }
-  Mat R = _R.getMat();
-  Quat<T> r = Quat<T>::createFromRotMat(R.colRange(0, 3).rowRange(0, 3));
-  Quat<T> trans(0, R.at<T>(0, 3), R.at<T>(1, 3), R.at<T>(2, 3));
-  return createFromQuat(r, trans * r * T(0.5));
-}
-
-template <typename T>
-DualQuat<T> DualQuat<T>::createFromAffine3(const Affine3<T> &R) {
-  return createFromMat(R.matrix);
-}
-
-template <typename T>
-DualQuat<T> DualQuat<T>::createFromPitch(const T angle, const T d,
-                                         const Vec<T, 3> &axis,
-                                         const Vec<T, 3> &moment) {
-  T half_angle = angle * T(0.5), half_d = d * T(0.5);
-  Quat<T> qaxis = Quat<T>(0, axis[0], axis[1], axis[2]).normalize();
-  Quat<T> qmoment = Quat<T>(0, moment[0], moment[1], moment[2]);
-  qmoment -= qaxis * axis.dot(moment);
-  Quat<T> dual = -half_d * std::sin(half_angle) +
-                 std::sin(half_angle) * qmoment +
-                 half_d * std::cos(half_angle) * qaxis;
-  return createFromQuat(Quat<T>::createFromAngleAxis(angle, axis), dual);
-}
-
-template <typename T>
-inline bool DualQuat<T>::operator==(const DualQuat<T> &q) const {
-  return (
-      abs(w - q.w) < CV_DUAL_QUAT_EPS && abs(x - q.x) < CV_DUAL_QUAT_EPS &&
-      abs(y - q.y) < CV_DUAL_QUAT_EPS && abs(z - q.z) < CV_DUAL_QUAT_EPS &&
-      abs(w_ - q.w_) < CV_DUAL_QUAT_EPS && abs(x_ - q.x_) < CV_DUAL_QUAT_EPS &&
-      abs(y_ - q.y_) < CV_DUAL_QUAT_EPS && abs(z_ - q.z_) < CV_DUAL_QUAT_EPS);
-}
-
-template <typename T> inline Quat<T> DualQuat<T>::getRealPart() const {
-  return Quat<T>(w, x, y, z);
-}
-
-template <typename T> inline Quat<T> DualQuat<T>::getDualPart() const {
-  return Quat<T>(w_, x_, y_, z_);
-}
-
-template <typename T> inline DualQuat<T> conjugate(const DualQuat<T> &dq) {
-  return dq.conjugate();
-}
-
-template <typename T> inline DualQuat<T> DualQuat<T>::conjugate() const {
-  return DualQuat<T>(w, -x, -y, -z, w_, -x_, -y_, -z_);
-}
-
-template <typename T> DualQuat<T> DualQuat<T>::norm() const {
-  Quat<T> real = getRealPart();
-  T realNorm = real.norm();
-  Quat<T> dual = getDualPart();
-  if (realNorm < CV_DUAL_QUAT_EPS) {
-    return DualQuat<T>(0, 0, 0, 0, 0, 0, 0, 0);
-  }
-  return DualQuat<T>(realNorm, 0, 0, 0, real.dot(dual) / realNorm, 0, 0, 0);
-}
-
-template <typename T>
-inline Quat<T> DualQuat<T>::getRotation(QuatAssumeType assumeUnit) const {
-  if (assumeUnit) {
-    return getRealPart();
-  }
-  return getRealPart().normalize();
-}
-
-template <typename T>
-inline Vec<T, 3> DualQuat<T>::getTranslation(QuatAssumeType assumeUnit) const {
-  Quat<T> trans = T(2.0) * (getDualPart() * getRealPart().inv(assumeUnit));
-  return Vec<T, 3>{trans[1], trans[2], trans[3]};
-}
-
-template <typename T> DualQuat<T> DualQuat<T>::normalize() const {
-  Quat<T> p = getRealPart();
-  Quat<T> q = getDualPart();
-  T p_norm = p.norm();
-  if (p_norm < CV_DUAL_QUAT_EPS) {
-    CV_Error(Error::StsBadArg,
-             "Cannot normalize this dual quaternion: the norm is too small.");
-  }
-  Quat<T> p_nr = p / p_norm;
-  Quat<T> q_nr = q / p_norm;
-  return createFromQuat(p_nr, q_nr - p_nr * p_nr.dot(q_nr));
-}
-
-template <typename T> inline T DualQuat<T>::dot(DualQuat<T> q) const {
-  return q.w * w + q.x * x + q.y * y + q.z * z + q.w_ * w_ + q.x_ * x_ +
-         q.y_ * y_ + q.z_ * z_;
-}
-
-template <typename T>
-inline DualQuat<T> inv(const DualQuat<T> &dq,
-                       QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) {
-  return dq.inv(assumeUnit);
-}
-
-template <typename T>
-inline DualQuat<T> DualQuat<T>::inv(QuatAssumeType assumeUnit) const {
-  Quat<T> real = getRealPart();
-  Quat<T> dual = getDualPart();
-  return createFromQuat(real.inv(assumeUnit),
-                        -real.inv(assumeUnit) * dual * real.inv(assumeUnit));
-}
-
-template <typename T>
-inline DualQuat<T> DualQuat<T>::operator-(const DualQuat<T> &q) const {
-  return DualQuat<T>(w - q.w, x - q.x, y - q.y, z - q.z, w_ - q.w_, x_ - q.x_,
-                     y_ - q.y_, z_ - q.z_);
-}
-
-template <typename T> inline DualQuat<T> DualQuat<T>::operator-() const {
-  return DualQuat<T>(-w, -x, -y, -z, -w_, -x_, -y_, -z_);
-}
-
-template <typename T>
-inline DualQuat<T> DualQuat<T>::operator+(const DualQuat<T> &q) const {
-  return DualQuat<T>(w + q.w, x + q.x, y + q.y, z + q.z, w_ + q.w_, x_ + q.x_,
-                     y_ + q.y_, z_ + q.z_);
-}
-
-template <typename T>
-inline DualQuat<T> &DualQuat<T>::operator+=(const DualQuat<T> &q) {
-  *this = *this + q;
-  return *this;
-}
-
-template <typename T>
-inline DualQuat<T> DualQuat<T>::operator*(const DualQuat<T> &q) const {
-  Quat<T> A = getRealPart();
-  Quat<T> B = getDualPart();
-  Quat<T> C = q.getRealPart();
-  Quat<T> D = q.getDualPart();
-  return DualQuat<T>::createFromQuat(A * C, A * D + B * C);
-}
-
-template <typename T>
-inline DualQuat<T> &DualQuat<T>::operator*=(const DualQuat<T> &q) {
-  *this = *this * q;
-  return *this;
-}
-
-template <typename T>
-inline DualQuat<T> operator+(const T a, const DualQuat<T> &q) {
-  return DualQuat<T>(a + q.w, q.x, q.y, q.z, q.w_, q.x_, q.y_, q.z_);
-}
-
-template <typename T>
-inline DualQuat<T> operator+(const DualQuat<T> &q, const T a) {
-  return DualQuat<T>(a + q.w, q.x, q.y, q.z, q.w_, q.x_, q.y_, q.z_);
-}
-
-template <typename T>
-inline DualQuat<T> operator-(const DualQuat<T> &q, const T a) {
-  return DualQuat<T>(q.w - a, q.x, q.y, q.z, q.w_, q.x_, q.y_, q.z_);
-}
-
-template <typename T>
-inline DualQuat<T> &DualQuat<T>::operator-=(const DualQuat<T> &q) {
-  *this = *this - q;
-  return *this;
-}
-
-template <typename T>
-inline DualQuat<T> operator-(const T a, const DualQuat<T> &q) {
-  return DualQuat<T>(a - q.w, -q.x, -q.y, -q.z, -q.w_, -q.x_, -q.y_, -q.z_);
-}
-
-template <typename T>
-inline DualQuat<T> operator*(const T a, const DualQuat<T> &q) {
-  return DualQuat<T>(q.w * a, q.x * a, q.y * a, q.z * a, q.w_ * a, q.x_ * a,
-                     q.y_ * a, q.z_ * a);
-}
-
-template <typename T>
-inline DualQuat<T> operator*(const DualQuat<T> &q, const T a) {
-  return DualQuat<T>(q.w * a, q.x * a, q.y * a, q.z * a, q.w_ * a, q.x_ * a,
-                     q.y_ * a, q.z_ * a);
-}
-
-template <typename T>
-inline DualQuat<T> DualQuat<T>::operator/(const T a) const {
-  return DualQuat<T>(w / a, x / a, y / a, z / a, w_ / a, x_ / a, y_ / a,
-                     z_ / a);
-}
-
-template <typename T>
-inline DualQuat<T> DualQuat<T>::operator/(const DualQuat<T> &q) const {
-  return *this * q.inv();
-}
-
-template <typename T>
-inline DualQuat<T> &DualQuat<T>::operator/=(const DualQuat<T> &q) {
-  *this = *this / q;
-  return *this;
-}
-
-template <typename T>
-std::ostream &operator<<(std::ostream &os, const DualQuat<T> &q) {
-  os << "DualQuat " << Vec<T, 8>{q.w, q.x, q.y, q.z, q.w_, q.x_, q.y_, q.z_};
-  return os;
-}
-
-template <typename T> inline DualQuat<T> exp(const DualQuat<T> &dq) {
-  return dq.exp();
-}
-
-namespace detail {
-
-template <typename _Tp> Matx<_Tp, 4, 4> jacob_exp(const Quat<_Tp> &q) {
-  _Tp nv = std::sqrt(q.x * q.x + q.y * q.y + q.z * q.z);
-  _Tp sinc_nv = abs(nv) < cv::DualQuat<_Tp>::CV_DUAL_QUAT_EPS
-                    ? _Tp(1.0) - nv * nv * _Tp(1.0 / 6.0)
-                    : std::sin(nv) / nv;
-  _Tp csiii_nv = abs(nv) < cv::DualQuat<_Tp>::CV_DUAL_QUAT_EPS
-                     ? -_Tp(1.0 / 3.0)
-                     : (std::cos(nv) - sinc_nv) / nv / nv;
-  Matx<_Tp, 4, 4> J_exp_quat{std::cos(nv),
-                             -sinc_nv * q.x,
-                             -sinc_nv * q.y,
-                             -sinc_nv * q.z,
-                             sinc_nv * q.x,
-                             csiii_nv * q.x * q.x + sinc_nv,
-                             csiii_nv * q.x * q.y,
-                             csiii_nv * q.x * q.z,
-                             sinc_nv * q.y,
-                             csiii_nv * q.y * q.x,
-                             csiii_nv * q.y * q.y + sinc_nv,
-                             csiii_nv * q.y * q.z,
-                             sinc_nv * q.z,
-                             csiii_nv * q.z * q.x,
-                             csiii_nv * q.z * q.y,
-                             csiii_nv * q.z * q.z + sinc_nv};
-  return std::exp(q.w) * J_exp_quat;
-}
-
-} // namespace detail
-
-template <typename T> DualQuat<T> DualQuat<T>::exp() const {
-  Quat<T> real = getRealPart();
-  return createFromQuat(
-      real.exp(), Quat<T>(detail::jacob_exp(real) * getDualPart().toVec()));
-}
-
-template <typename T>
-DualQuat<T> log(const DualQuat<T> &dq,
-                QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) {
-  return dq.log(assumeUnit);
-}
-
-template <typename T>
-DualQuat<T> DualQuat<T>::log(QuatAssumeType assumeUnit) const {
-  Quat<T> plog = getRealPart().log(assumeUnit);
-  Matx<T, 4, 4> jacob = detail::jacob_exp(plog);
-  return createFromQuat(plog, Quat<T>(jacob.inv() * getDualPart().toVec()));
-}
-
-template <typename T>
-inline DualQuat<T> power(const DualQuat<T> &dq, const T t,
-                         QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) {
-  return dq.power(t, assumeUnit);
-}
-
-template <typename T>
-inline DualQuat<T> DualQuat<T>::power(const T t,
-                                      QuatAssumeType assumeUnit) const {
-  return (t * log(assumeUnit)).exp();
-}
-
-template <typename T>
-inline DualQuat<T> power(const DualQuat<T> &p, const DualQuat<T> &q,
-                         QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) {
-  return p.power(q, assumeUnit);
-}
-
-template <typename T>
-inline DualQuat<T> DualQuat<T>::power(const DualQuat<T> &q,
-                                      QuatAssumeType assumeUnit) const {
-  return (q * log(assumeUnit)).exp();
-}
-
-template <typename T> inline Vec<T, 8> DualQuat<T>::toVec() const {
-  return Vec<T, 8>(w, x, y, z, w_, x_, y_, z_);
-}
-
-template <typename T>
-Affine3<T> DualQuat<T>::toAffine3(QuatAssumeType assumeUnit) const {
-  return Affine3<T>(toMat(assumeUnit));
-}
-
-template <typename T>
-Matx<T, 4, 4> DualQuat<T>::toMat(QuatAssumeType assumeUnit) const {
-  Matx<T, 4, 4> rot44 = getRotation(assumeUnit).toRotMat4x4();
-  Vec<T, 3> translation = getTranslation(assumeUnit);
-  rot44(0, 3) = translation[0];
-  rot44(1, 3) = translation[1];
-  rot44(2, 3) = translation[2];
-  return rot44;
-}
-
-template <typename T>
-DualQuat<T> DualQuat<T>::sclerp(const DualQuat<T> &q0, const DualQuat<T> &q1,
-                                const T t, bool directChange,
-                                QuatAssumeType assumeUnit) {
-  DualQuat<T> v0(q0), v1(q1);
-  if (!assumeUnit) {
-    v0 = v0.normalize();
-    v1 = v1.normalize();
-  }
-  Quat<T> v0Real = v0.getRealPart();
-  Quat<T> v1Real = v1.getRealPart();
-  if (directChange && v1Real.dot(v0Real) < 0) {
-    v0 = -v0;
-  }
-  DualQuat<T> v0inv1 = v0.inv() * v1;
-  return v0 * v0inv1.power(t, QUAT_ASSUME_UNIT);
-}
-
-template <typename T>
-DualQuat<T> DualQuat<T>::dqblend(const DualQuat<T> &q1, const DualQuat<T> &q2,
-                                 const T t, QuatAssumeType assumeUnit) {
-  DualQuat<T> v1(q1), v2(q2);
-  if (!assumeUnit) {
-    v1 = v1.normalize();
-    v2 = v2.normalize();
-  }
-  if (v1.getRotation(assumeUnit).dot(v2.getRotation(assumeUnit)) < 0) {
-    return ((1 - t) * v1 - t * v2).normalize();
-  }
-  return ((1 - t) * v1 + t * v2).normalize();
-}
-
-template <typename T>
-DualQuat<T> DualQuat<T>::gdqblend(InputArray _dualquat, InputArray _weight,
-                                  QuatAssumeType assumeUnit) {
-  CV_CheckTypeEQ(_weight.type(), cv::traits::Type<T>::value, "");
-  CV_CheckTypeEQ(_dualquat.type(),
-                 CV_MAKETYPE(CV_MAT_DEPTH(cv::traits::Type<T>::value), 8), "");
-  Size dq_s = _dualquat.size();
-  if (dq_s != _weight.size() || (dq_s.height != 1 && dq_s.width != 1)) {
-    CV_Error(Error::StsBadArg,
-             "The size of weight must be the same as dualquat, both of them "
-             "should be (1, n) or (n, 1)");
-  }
-  Mat dualquat = _dualquat.getMat(), weight = _weight.getMat();
-  const int cn = std::max(dq_s.width, dq_s.height);
-  if (!assumeUnit) {
-    for (int i = 0; i < cn; ++i) {
-      dualquat.at<Vec<T, 8>>(i) =
-          DualQuat<T>{dualquat.at<Vec<T, 8>>(i)}.normalize().toVec();
-    }
-  }
-  Vec<T, 8> dq_blend = dualquat.at<Vec<T, 8>>(0) * weight.at<T>(0);
-  Quat<T> q0 = DualQuat<T>{dualquat.at<Vec<T, 8>>(0)}.getRotation(assumeUnit);
-  for (int i = 1; i < cn; ++i) {
-    T k =
-        q0.dot(DualQuat<T>{dualquat.at<Vec<T, 8>>(i)}.getRotation(assumeUnit)) <
-                0
-            ? -1
-            : 1;
-    dq_blend = dq_blend + dualquat.at<Vec<T, 8>>(i) * k * weight.at<T>(i);
-  }
-  return DualQuat<T>{dq_blend}.normalize();
-}
-
-template <typename T>
-template <int cn>
-DualQuat<T> DualQuat<T>::gdqblend(const Vec<DualQuat<T>, cn> &_dualquat,
-                                  InputArray _weight,
-                                  QuatAssumeType assumeUnit) {
-  Vec<DualQuat<T>, cn> dualquat(_dualquat);
-  if (cn == 0) {
-    return DualQuat<T>(1, 0, 0, 0, 0, 0, 0, 0);
-  }
-  Mat dualquat_mat(cn, 1, CV_64FC(8));
-  for (int i = 0; i < cn; ++i) {
-    dualquat_mat.at<Vec<T, 8>>(i) = dualquat[i].toVec();
-  }
-  return gdqblend(dualquat_mat, _weight, assumeUnit);
-}
-
-} // namespace cv
-
-#endif /*OPENCV_CORE_DUALQUATERNION_INL_HPP*/
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/eigen.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/eigen.hpp
deleted file mode 100644
index 1ffc6b5f6f..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/eigen.hpp
+++ /dev/null
@@ -1,405 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_CORE_EIGEN_HPP
-#define OPENCV_CORE_EIGEN_HPP
-
-#ifndef EIGEN_WORLD_VERSION
-#error                                                                         \
-    "Wrong usage of OpenCV's Eigen utility header. Include Eigen's headers first. See https://github.com/opencv/opencv/issues/17366"
-#endif
-
-#include "opencv2/core.hpp"
-
-#if defined _MSC_VER && _MSC_VER >= 1200
-#ifndef NOMINMAX
-#define NOMINMAX // fix https://github.com/opencv/opencv/issues/17548
-#endif
-#pragma warning(disable : 4714) //__forceinline is not inlined
-#pragma warning(disable : 4127) // conditional expression is constant
-#pragma warning(disable : 4244) // conversion from '__int64' to 'int', possible
-                                // loss of data
-#endif
-
-#if !defined(OPENCV_DISABLE_EIGEN_TENSOR_SUPPORT)
-#if EIGEN_WORLD_VERSION == 3 && EIGEN_MAJOR_VERSION >= 3
-#include <unsupported/Eigen/CXX11/Tensor>
-#define OPENCV_EIGEN_TENSOR_SUPPORT 1
-#endif // EIGEN_WORLD_VERSION == 3 && EIGEN_MAJOR_VERSION >= 3
-#endif // !defined(OPENCV_DISABLE_EIGEN_TENSOR_SUPPORT)
-
-namespace cv {
-
-/** @addtogroup core_eigen
-These functions are provided for OpenCV-Eigen interoperability. They convert
-`Mat` objects to corresponding `Eigen::Matrix` objects and vice-versa. Consult
-the [Eigen
-documentation](https://eigen.tuxfamily.org/dox/group__TutorialMatrixClass.html)
-for information about the `Matrix` template type.
-
-@note Using these functions requires the `Eigen/Dense` or similar header to be
-included before this header.
-*/
-//! @{
-
-#if defined(OPENCV_EIGEN_TENSOR_SUPPORT) || defined(CV_DOXYGEN)
-/** @brief Converts an Eigen::Tensor to a cv::Mat.
-
-The method converts an Eigen::Tensor with shape (H x W x C) to a cv::Mat where:
- H = number of rows
- W = number of columns
- C = number of channels
-
-Usage:
-\code
-Eigen::Tensor<float, 3, Eigen::RowMajor> a_tensor(...);
-// populate tensor with values
-Mat a_mat;
-eigen2cv(a_tensor, a_mat);
-\endcode
-*/
-template <typename _Tp, int _layout>
-static inline void eigen2cv(const Eigen::Tensor<_Tp, 3, _layout> &src,
-                            OutputArray dst) {
-  if (!(_layout & Eigen::RowMajorBit)) {
-    const std::array<int, 3> shuffle{2, 1, 0};
-    Eigen::Tensor<_Tp, 3, !_layout> row_major_tensor =
-        src.swap_layout().shuffle(shuffle);
-    Mat _src(src.dimension(0), src.dimension(1),
-             CV_MAKETYPE(DataType<_Tp>::type, src.dimension(2)),
-             row_major_tensor.data());
-    _src.copyTo(dst);
-  } else {
-    Mat _src(src.dimension(0), src.dimension(1),
-             CV_MAKETYPE(DataType<_Tp>::type, src.dimension(2)),
-             (void *)src.data());
-    _src.copyTo(dst);
-  }
-}
-
-/** @brief Converts a cv::Mat to an Eigen::Tensor.
-
-The method converts a cv::Mat to an Eigen Tensor with shape (H x W x C) where:
- H = number of rows
- W = number of columns
- C = number of channels
-
-Usage:
-\code
-Mat a_mat(...);
-// populate Mat with values
-Eigen::Tensor<float, 3, Eigen::RowMajor> a_tensor(...);
-cv2eigen(a_mat, a_tensor);
-\endcode
-*/
-template <typename _Tp, int _layout>
-static inline void cv2eigen(const Mat &src,
-                            Eigen::Tensor<_Tp, 3, _layout> &dst) {
-  if (!(_layout & Eigen::RowMajorBit)) {
-    Eigen::Tensor<_Tp, 3, !_layout> row_major_tensor(src.rows, src.cols,
-                                                     src.channels());
-    Mat _dst(src.rows, src.cols,
-             CV_MAKETYPE(DataType<_Tp>::type, src.channels()),
-             row_major_tensor.data());
-    if (src.type() == _dst.type())
-      src.copyTo(_dst);
-    else
-      src.convertTo(_dst, _dst.type());
-    const std::array<int, 3> shuffle{2, 1, 0};
-    dst = row_major_tensor.swap_layout().shuffle(shuffle);
-  } else {
-    dst.resize(src.rows, src.cols, src.channels());
-    Mat _dst(src.rows, src.cols,
-             CV_MAKETYPE(DataType<_Tp>::type, src.channels()), dst.data());
-    if (src.type() == _dst.type())
-      src.copyTo(_dst);
-    else
-      src.convertTo(_dst, _dst.type());
-  }
-}
-
-/** @brief Maps cv::Mat data to an Eigen::TensorMap.
-
-The method wraps an existing Mat data array with an Eigen TensorMap of shape (H
-x W x C) where: H = number of rows W = number of columns C = number of channels
-
-Explicit instantiation of the return type is required.
-
-@note Caller should be aware of the lifetime of the cv::Mat instance and take
-appropriate safety measures. The cv::Mat instance will retain ownership of the
-data and the Eigen::TensorMap will lose access when the cv::Mat data is
-deallocated.
-
-The example below initializes a cv::Mat and produces an Eigen::TensorMap:
-\code
-float arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
-Mat a_mat(2, 2, CV_32FC3, arr);
-Eigen::TensorMap<Eigen::Tensor<float, 3, Eigen::RowMajor>> a_tensormap =
-cv2eigen_tensormap<float>(a_mat);
-\endcode
-*/
-template <typename _Tp>
-static inline Eigen::TensorMap<Eigen::Tensor<_Tp, 3, Eigen::RowMajor>>
-cv2eigen_tensormap(InputArray src) {
-  Mat mat = src.getMat();
-  CV_CheckTypeEQ(mat.type(),
-                 CV_MAKETYPE(traits::Type<_Tp>::value, mat.channels()), "");
-  return Eigen::TensorMap<Eigen::Tensor<_Tp, 3, Eigen::RowMajor>>(
-      (_Tp *)mat.data, mat.rows, mat.cols, mat.channels());
-}
-#endif // OPENCV_EIGEN_TENSOR_SUPPORT
-
-template <typename _Tp, int _rows, int _cols, int _options, int _maxRows,
-          int _maxCols>
-static inline void eigen2cv(
-    const Eigen::Matrix<_Tp, _rows, _cols, _options, _maxRows, _maxCols> &src,
-    OutputArray dst) {
-  if (!(src.Flags & Eigen::RowMajorBit)) {
-    Mat _src(src.cols(), src.rows(), traits::Type<_Tp>::value,
-             (void *)src.data(), src.outerStride() * sizeof(_Tp));
-    transpose(_src, dst);
-  } else {
-    Mat _src(src.rows(), src.cols(), traits::Type<_Tp>::value,
-             (void *)src.data(), src.outerStride() * sizeof(_Tp));
-    _src.copyTo(dst);
-  }
-}
-
-// Matx case
-template <typename _Tp, int _rows, int _cols, int _options, int _maxRows,
-          int _maxCols>
-static inline void eigen2cv(
-    const Eigen::Matrix<_Tp, _rows, _cols, _options, _maxRows, _maxCols> &src,
-    Matx<_Tp, _rows, _cols> &dst) {
-  if (!(src.Flags & Eigen::RowMajorBit)) {
-    dst = Matx<_Tp, _cols, _rows>(static_cast<const _Tp *>(src.data())).t();
-  } else {
-    dst = Matx<_Tp, _rows, _cols>(static_cast<const _Tp *>(src.data()));
-  }
-}
-
-template <typename _Tp, int _rows, int _cols, int _options, int _maxRows,
-          int _maxCols>
-static inline void
-cv2eigen(const Mat &src,
-         Eigen::Matrix<_Tp, _rows, _cols, _options, _maxRows, _maxCols> &dst) {
-  CV_DbgAssert(src.rows == _rows && src.cols == _cols);
-  if (!(dst.Flags & Eigen::RowMajorBit)) {
-    const Mat _dst(src.cols, src.rows, traits::Type<_Tp>::value, dst.data(),
-                   (size_t)(dst.outerStride() * sizeof(_Tp)));
-    if (src.type() == _dst.type())
-      transpose(src, _dst);
-    else if (src.cols == src.rows) {
-      src.convertTo(_dst, _dst.type());
-      transpose(_dst, _dst);
-    } else
-      Mat(src.t()).convertTo(_dst, _dst.type());
-  } else {
-    const Mat _dst(src.rows, src.cols, traits::Type<_Tp>::value, dst.data(),
-                   (size_t)(dst.outerStride() * sizeof(_Tp)));
-    src.convertTo(_dst, _dst.type());
-  }
-}
-
-// Matx case
-template <typename _Tp, int _rows, int _cols, int _options, int _maxRows,
-          int _maxCols>
-static inline void
-cv2eigen(const Matx<_Tp, _rows, _cols> &src,
-         Eigen::Matrix<_Tp, _rows, _cols, _options, _maxRows, _maxCols> &dst) {
-  if (!(dst.Flags & Eigen::RowMajorBit)) {
-    const Mat _dst(_cols, _rows, traits::Type<_Tp>::value, dst.data(),
-                   (size_t)(dst.outerStride() * sizeof(_Tp)));
-    transpose(src, _dst);
-  } else {
-    const Mat _dst(_rows, _cols, traits::Type<_Tp>::value, dst.data(),
-                   (size_t)(dst.outerStride() * sizeof(_Tp)));
-    Mat(src).copyTo(_dst);
-  }
-}
-
-template <typename _Tp>
-static inline void
-cv2eigen(const Mat &src,
-         Eigen::Matrix<_Tp, Eigen::Dynamic, Eigen::Dynamic> &dst) {
-  dst.resize(src.rows, src.cols);
-  if (!(dst.Flags & Eigen::RowMajorBit)) {
-    const Mat _dst(src.cols, src.rows, traits::Type<_Tp>::value, dst.data(),
-                   (size_t)(dst.outerStride() * sizeof(_Tp)));
-    if (src.type() == _dst.type())
-      transpose(src, _dst);
-    else if (src.cols == src.rows) {
-      src.convertTo(_dst, _dst.type());
-      transpose(_dst, _dst);
-    } else
-      Mat(src.t()).convertTo(_dst, _dst.type());
-  } else {
-    const Mat _dst(src.rows, src.cols, traits::Type<_Tp>::value, dst.data(),
-                   (size_t)(dst.outerStride() * sizeof(_Tp)));
-    src.convertTo(_dst, _dst.type());
-  }
-}
-
-template <typename _Tp>
-static inline void cv2eigen(
-    const Mat &src,
-    Eigen::Matrix<_Tp, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> &dst) {
-  CV_CheckEQ(src.dims, 2, "");
-  dst.resize(src.rows, src.cols);
-  const Mat _dst(src.rows, src.cols, traits::Type<_Tp>::value, dst.data(),
-                 (size_t)(dst.outerStride() * sizeof(_Tp)));
-  src.convertTo(_dst, _dst.type());
-}
-
-// Matx case
-template <typename _Tp, int _rows, int _cols>
-static inline void
-cv2eigen(const Matx<_Tp, _rows, _cols> &src,
-         Eigen::Matrix<_Tp, Eigen::Dynamic, Eigen::Dynamic> &dst) {
-  dst.resize(_rows, _cols);
-  if (!(dst.Flags & Eigen::RowMajorBit)) {
-    const Mat _dst(_cols, _rows, traits::Type<_Tp>::value, dst.data(),
-                   (size_t)(dst.outerStride() * sizeof(_Tp)));
-    transpose(src, _dst);
-  } else {
-    const Mat _dst(_rows, _cols, traits::Type<_Tp>::value, dst.data(),
-                   (size_t)(dst.outerStride() * sizeof(_Tp)));
-    Mat(src).copyTo(_dst);
-  }
-}
-
-template <typename _Tp, int _rows, int _cols>
-static inline void cv2eigen(
-    const Matx<_Tp, _rows, _cols> &src,
-    Eigen::Matrix<_Tp, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> &dst) {
-  CV_CheckEQ(src.dims, 2, "");
-  dst.resize(_rows, _cols);
-  const Mat _dst(_rows, _cols, traits::Type<_Tp>::value, dst.data(),
-                 (size_t)(dst.outerStride() * sizeof(_Tp)));
-  Mat(src).copyTo(_dst);
-}
-
-template <typename _Tp>
-static inline void cv2eigen(const Mat &src,
-                            Eigen::Matrix<_Tp, Eigen::Dynamic, 1> &dst) {
-  CV_Assert(src.cols == 1);
-  dst.resize(src.rows);
-
-  if (!(dst.Flags & Eigen::RowMajorBit)) {
-    const Mat _dst(src.cols, src.rows, traits::Type<_Tp>::value, dst.data(),
-                   (size_t)(dst.outerStride() * sizeof(_Tp)));
-    if (src.type() == _dst.type())
-      transpose(src, _dst);
-    else
-      Mat(src.t()).convertTo(_dst, _dst.type());
-  } else {
-    const Mat _dst(src.rows, src.cols, traits::Type<_Tp>::value, dst.data(),
-                   (size_t)(dst.outerStride() * sizeof(_Tp)));
-    src.convertTo(_dst, _dst.type());
-  }
-}
-
-// Matx case
-template <typename _Tp, int _rows>
-static inline void cv2eigen(const Matx<_Tp, _rows, 1> &src,
-                            Eigen::Matrix<_Tp, Eigen::Dynamic, 1> &dst) {
-  dst.resize(_rows);
-
-  if (!(dst.Flags & Eigen::RowMajorBit)) {
-    const Mat _dst(1, _rows, traits::Type<_Tp>::value, dst.data(),
-                   (size_t)(dst.outerStride() * sizeof(_Tp)));
-    transpose(src, _dst);
-  } else {
-    const Mat _dst(_rows, 1, traits::Type<_Tp>::value, dst.data(),
-                   (size_t)(dst.outerStride() * sizeof(_Tp)));
-    src.copyTo(_dst);
-  }
-}
-
-template <typename _Tp>
-static inline void cv2eigen(const Mat &src,
-                            Eigen::Matrix<_Tp, 1, Eigen::Dynamic> &dst) {
-  CV_Assert(src.rows == 1);
-  dst.resize(src.cols);
-  if (!(dst.Flags & Eigen::RowMajorBit)) {
-    const Mat _dst(src.cols, src.rows, traits::Type<_Tp>::value, dst.data(),
-                   (size_t)(dst.outerStride() * sizeof(_Tp)));
-    if (src.type() == _dst.type())
-      transpose(src, _dst);
-    else
-      Mat(src.t()).convertTo(_dst, _dst.type());
-  } else {
-    const Mat _dst(src.rows, src.cols, traits::Type<_Tp>::value, dst.data(),
-                   (size_t)(dst.outerStride() * sizeof(_Tp)));
-    src.convertTo(_dst, _dst.type());
-  }
-}
-
-// Matx
-template <typename _Tp, int _cols>
-static inline void cv2eigen(const Matx<_Tp, 1, _cols> &src,
-                            Eigen::Matrix<_Tp, 1, Eigen::Dynamic> &dst) {
-  dst.resize(_cols);
-  if (!(dst.Flags & Eigen::RowMajorBit)) {
-    const Mat _dst(_cols, 1, traits::Type<_Tp>::value, dst.data(),
-                   (size_t)(dst.outerStride() * sizeof(_Tp)));
-    transpose(src, _dst);
-  } else {
-    const Mat _dst(1, _cols, traits::Type<_Tp>::value, dst.data(),
-                   (size_t)(dst.outerStride() * sizeof(_Tp)));
-    Mat(src).copyTo(_dst);
-  }
-}
-
-//! @}
-
-} // namespace cv
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/fast_math.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/fast_math.hpp
deleted file mode 100644
index 30405adb3f..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/fast_math.hpp
+++ /dev/null
@@ -1,433 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Copyright (C) 2015, Itseez Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_CORE_FAST_MATH_HPP
-#define OPENCV_CORE_FAST_MATH_HPP
-
-#include "opencv2/core/cvdef.h"
-
-//! @addtogroup core_utils
-//! @{
-
-/****************************************************************************************\
-*                                      fast math *
-\****************************************************************************************/
-
-#ifdef __cplusplus
-#include <cmath>
-#else
-#ifdef __BORLANDC__
-#include <fastmath.h>
-#else
-#include <math.h>
-#endif
-#endif
-
-#if defined(__CUDACC__)
-// nothing, intrinsics/asm code is not supported
-#else
-#if ((defined _MSC_VER && defined _M_X64) ||                                   \
-     (defined __GNUC__ && defined __SSE2__)) &&                                \
-    !defined(OPENCV_SKIP_INCLUDE_EMMINTRIN_H)
-#include <emmintrin.h>
-#endif
-
-#if defined __PPC64__ && defined __GNUC__ && defined _ARCH_PWR8 &&             \
-    !defined(OPENCV_SKIP_INCLUDE_ALTIVEC_H)
-#include <altivec.h>
-#undef vector
-#undef bool
-#undef pixel
-#endif
-
-#if defined(CV_INLINE_ROUND_FLT)
-// user-specified version
-// CV_INLINE_ROUND_DBL should be defined too
-#elif defined __GNUC__ && defined __arm__ &&                                   \
-    (defined __ARM_PCS_VFP || defined __ARM_VFPV3__ || defined __ARM_NEON) &&  \
-    !defined __SOFTFP__
-// 1. general scheme
-#define ARM_ROUND(_value, _asm_string)                                         \
-  int res;                                                                     \
-  float temp;                                                                  \
-  CV_UNUSED(temp);                                                             \
-  __asm__(_asm_string                                                          \
-          : [res] "=r"(res), [temp] "=w"(temp)                                 \
-          : [value] "w"(_value));                                              \
-  return res
-// 2. version for double
-#ifdef __clang__
-#define CV_INLINE_ROUND_DBL(value)                                             \
-  ARM_ROUND(value, "vcvtr.s32.f64 %[temp], %[value] \n vmov %[res], %[temp]")
-#else
-#define CV_INLINE_ROUND_DBL(value)                                             \
-  ARM_ROUND(value, "vcvtr.s32.f64 %[temp], %P[value] \n vmov %[res], %[temp]")
-#endif
-// 3. version for float
-#define CV_INLINE_ROUND_FLT(value)                                             \
-  ARM_ROUND(value, "vcvtr.s32.f32 %[temp], %[value]\n vmov %[res], %[temp]")
-#elif defined __PPC64__ && defined __GNUC__ && defined _ARCH_PWR8
-// P8 and newer machines can convert fp32/64 to int quickly.
-#define CV_INLINE_ROUND_DBL(value)                                             \
-  int out;                                                                     \
-  double temp;                                                                 \
-  __asm__("fctiw %[temp],%[in]\n\tmfvsrwz %[out],%[temp]\n\t"                  \
-          : [out] "=r"(out), [temp] "=d"(temp)                                 \
-          : [in] "d"((double)(value))                                          \
-          :);                                                                  \
-  return out;
-
-// FP32 also works with FP64 routine above
-#define CV_INLINE_ROUND_FLT(value) CV_INLINE_ROUND_DBL(value)
-#endif
-
-#ifdef CV_INLINE_ISINF_FLT
-// user-specified version
-// CV_INLINE_ISINF_DBL should be defined too
-#elif defined __PPC64__ && defined _ARCH_PWR9 && defined(scalar_test_data_class)
-#define CV_INLINE_ISINF_DBL(value) return scalar_test_data_class(value, 0x30);
-#define CV_INLINE_ISINF_FLT(value) CV_INLINE_ISINF_DBL(value)
-#endif
-
-#ifdef CV_INLINE_ISNAN_FLT
-// user-specified version
-// CV_INLINE_ISNAN_DBL should be defined too
-#elif defined __PPC64__ && defined _ARCH_PWR9 && defined(scalar_test_data_class)
-#define CV_INLINE_ISNAN_DBL(value) return scalar_test_data_class(value, 0x40);
-#define CV_INLINE_ISNAN_FLT(value) CV_INLINE_ISNAN_DBL(value)
-#endif
-
-#if !defined(OPENCV_USE_FASTMATH_BUILTINS) &&                                  \
-    (defined(__x86_64__) || defined(__i686__) || defined(__arm__) ||           \
-     defined(__PPC64__))
-/* Let builtin C math functions when available. Dedicated hardware is available
-   to round and convert FP values. */
-#define OPENCV_USE_FASTMATH_BUILTINS 1
-#endif
-
-/* Enable builtin math functions if possible, desired, and available.
-   Note, not all math functions inline equally. E.g lrint will not inline
-   without the -fno-math-errno option. */
-#if defined(CV_ICC)
-// nothing
-#elif defined(OPENCV_USE_FASTMATH_BUILTINS) && OPENCV_USE_FASTMATH_BUILTINS
-#if defined(__clang__)
-#define CV__FASTMATH_ENABLE_CLANG_MATH_BUILTINS
-#if !defined(CV_INLINE_ISNAN_DBL) && __has_builtin(__builtin_isnan)
-#define CV_INLINE_ISNAN_DBL(value) return __builtin_isnan(value);
-#endif
-#if !defined(CV_INLINE_ISNAN_FLT) && __has_builtin(__builtin_isnan)
-#define CV_INLINE_ISNAN_FLT(value) return __builtin_isnan(value);
-#endif
-#if !defined(CV_INLINE_ISINF_DBL) && __has_builtin(__builtin_isinf)
-#define CV_INLINE_ISINF_DBL(value) return __builtin_isinf(value);
-#endif
-#if !defined(CV_INLINE_ISINF_FLT) && __has_builtin(__builtin_isinf)
-#define CV_INLINE_ISINF_FLT(value) return __builtin_isinf(value);
-#endif
-#elif defined(__GNUC__)
-#define CV__FASTMATH_ENABLE_GCC_MATH_BUILTINS
-#if !defined(CV_INLINE_ISNAN_DBL)
-#define CV_INLINE_ISNAN_DBL(value) return __builtin_isnan(value);
-#endif
-#if !defined(CV_INLINE_ISNAN_FLT)
-#define CV_INLINE_ISNAN_FLT(value) return __builtin_isnanf(value);
-#endif
-#if !defined(CV_INLINE_ISINF_DBL)
-#define CV_INLINE_ISINF_DBL(value) return __builtin_isinf(value);
-#endif
-#if !defined(CV_INLINE_ISINF_FLT)
-#define CV_INLINE_ISINF_FLT(value) return __builtin_isinff(value);
-#endif
-#elif defined(_MSC_VER)
-#if !defined(CV_INLINE_ISNAN_DBL)
-#define CV_INLINE_ISNAN_DBL(value) return isnan(value);
-#endif
-#if !defined(CV_INLINE_ISNAN_FLT)
-#define CV_INLINE_ISNAN_FLT(value) return isnan(value);
-#endif
-#if !defined(CV_INLINE_ISINF_DBL)
-#define CV_INLINE_ISINF_DBL(value) return isinf(value);
-#endif
-#if !defined(CV_INLINE_ISINF_FLT)
-#define CV_INLINE_ISINF_FLT(value) return isinf(value);
-#endif
-#endif
-#endif
-
-#endif // defined(__CUDACC__)
-
-/** @brief Rounds floating-point number to the nearest integer
-
- @param value floating-point number. If the value is outside of INT_MIN ...
- INT_MAX range, the result is not defined.
- */
-CV_INLINE int cvRound(double value) {
-#if defined CV_INLINE_ROUND_DBL
-  CV_INLINE_ROUND_DBL(value);
-#elif ((defined _MSC_VER && defined _M_X64) ||                                 \
-       (defined __GNUC__ && defined __SSE2__)) &&                              \
-    !defined(__CUDACC__)
-  __m128d t = _mm_set_sd(value);
-  return _mm_cvtsd_si32(t);
-#elif defined _MSC_VER && defined _M_IX86
-  int t;
-  __asm
-  {
-        fld value;
-        fistp t;
-  }
-  return t;
-#elif defined CV__FASTMATH_ENABLE_GCC_MATH_BUILTINS ||                         \
-    defined CV__FASTMATH_ENABLE_CLANG_MATH_BUILTINS
-  return (int)__builtin_lrint(value);
-#else
-  return (int)lrint(value);
-#endif
-}
-
-/** @brief Rounds floating-point number to the nearest integer not larger than
- the original.
-
- The function computes an integer i such that:
- \f[i \le \texttt{value} < i+1\f]
- @param value floating-point number. If the value is outside of INT_MIN ...
- INT_MAX range, the result is not defined.
- */
-CV_INLINE int cvFloor(double value) {
-#if defined CV__FASTMATH_ENABLE_GCC_MATH_BUILTINS ||                           \
-    defined CV__FASTMATH_ENABLE_CLANG_MATH_BUILTINS
-  return (int)__builtin_floor(value);
-#elif defined __loongarch64
-  int i;
-  double tmp;
-  __asm__("ftintrm.l.d     %[tmp],    %[in]       \n\t"
-          "movfr2gr.d      %[i],      %[tmp]      \n\t"
-          : [i] "=r"(i), [tmp] "=f"(tmp)
-          : [in] "f"(value)
-          :);
-  return i;
-#else
-  int i = (int)value;
-  return i - (i > value);
-#endif
-}
-
-/** @brief Rounds floating-point number to the nearest integer not smaller than
- the original.
-
- The function computes an integer i such that:
- \f[i \le \texttt{value} < i+1\f]
- @param value floating-point number. If the value is outside of INT_MIN ...
- INT_MAX range, the result is not defined.
- */
-CV_INLINE int cvCeil(double value) {
-#if defined CV__FASTMATH_ENABLE_GCC_MATH_BUILTINS ||                           \
-    defined CV__FASTMATH_ENABLE_CLANG_MATH_BUILTINS
-  return (int)__builtin_ceil(value);
-#elif defined __loongarch64
-  int i;
-  double tmp;
-  __asm__("ftintrp.l.d     %[tmp],    %[in]       \n\t"
-          "movfr2gr.d      %[i],      %[tmp]      \n\t"
-          : [i] "=r"(i), [tmp] "=f"(tmp)
-          : [in] "f"(value)
-          :);
-  return i;
-#else
-  int i = (int)value;
-  return i + (i < value);
-#endif
-}
-
-/** @brief Determines if the argument is Not A Number.
-
- @param value The input floating-point value
-
- The function returns 1 if the argument is Not A Number (as defined by IEEE754
- standard), 0 otherwise. */
-CV_INLINE int cvIsNaN(double value) {
-#if defined CV_INLINE_ISNAN_DBL
-  CV_INLINE_ISNAN_DBL(value);
-#else
-  Cv64suf ieee754;
-  ieee754.f = value;
-  return ((unsigned)(ieee754.u >> 32) & 0x7fffffff) +
-             ((unsigned)ieee754.u != 0) >
-         0x7ff00000;
-#endif
-}
-
-/** @brief Determines if the argument is Infinity.
-
- @param value The input floating-point value
-
- The function returns 1 if the argument is a plus or minus infinity (as defined
- by IEEE754 standard) and 0 otherwise. */
-CV_INLINE int cvIsInf(double value) {
-#if defined CV_INLINE_ISINF_DBL
-  CV_INLINE_ISINF_DBL(value);
-#elif defined(__x86_64__) || defined(_M_X64) || defined(__aarch64__) ||        \
-    defined(_M_ARM64) || defined(__PPC64__) || defined(__loongarch64)
-  Cv64suf ieee754;
-  ieee754.f = value;
-  return (ieee754.u & 0x7fffffffffffffff) == 0x7ff0000000000000;
-#else
-  Cv64suf ieee754;
-  ieee754.f = value;
-  return ((unsigned)(ieee754.u >> 32) & 0x7fffffff) == 0x7ff00000 &&
-         (unsigned)ieee754.u == 0;
-#endif
-}
-
-#ifdef __cplusplus
-
-/** @overload */
-CV_INLINE int cvRound(float value) {
-#if defined CV_INLINE_ROUND_FLT
-  CV_INLINE_ROUND_FLT(value);
-#elif ((defined _MSC_VER && defined _M_X64) ||                                 \
-       (defined __GNUC__ && defined __SSE2__)) &&                              \
-    !defined(__CUDACC__)
-  __m128 t = _mm_set_ss(value);
-  return _mm_cvtss_si32(t);
-#elif defined _MSC_VER && defined _M_IX86
-  int t;
-  __asm
-  {
-        fld value;
-        fistp t;
-  }
-  return t;
-#elif defined CV__FASTMATH_ENABLE_GCC_MATH_BUILTINS ||                         \
-    defined CV__FASTMATH_ENABLE_CLANG_MATH_BUILTINS
-  return (int)__builtin_lrintf(value);
-#else
-  return (int)lrintf(value);
-#endif
-}
-
-/** @overload */
-CV_INLINE int cvRound(int value) { return value; }
-
-/** @overload */
-CV_INLINE int cvFloor(float value) {
-#if defined CV__FASTMATH_ENABLE_GCC_MATH_BUILTINS ||                           \
-    defined CV__FASTMATH_ENABLE_CLANG_MATH_BUILTINS
-  return (int)__builtin_floorf(value);
-#elif defined __loongarch__
-  int i;
-  float tmp;
-  __asm__("ftintrm.w.s     %[tmp],    %[in]       \n\t"
-          "movfr2gr.s      %[i],      %[tmp]      \n\t"
-          : [i] "=r"(i), [tmp] "=f"(tmp)
-          : [in] "f"(value)
-          :);
-  return i;
-#else
-  int i = (int)value;
-  return i - (i > value);
-#endif
-}
-
-/** @overload */
-CV_INLINE int cvFloor(int value) { return value; }
-
-/** @overload */
-CV_INLINE int cvCeil(float value) {
-#if defined CV__FASTMATH_ENABLE_GCC_MATH_BUILTINS ||                           \
-    defined CV__FASTMATH_ENABLE_CLANG_MATH_BUILTINS
-  return (int)__builtin_ceilf(value);
-#elif defined __loongarch__
-  int i;
-  float tmp;
-  __asm__("ftintrp.w.s     %[tmp],    %[in]       \n\t"
-          "movfr2gr.s      %[i],      %[tmp]      \n\t"
-          : [i] "=r"(i), [tmp] "=f"(tmp)
-          : [in] "f"(value)
-          :);
-  return i;
-#else
-  int i = (int)value;
-  return i + (i < value);
-#endif
-}
-
-/** @overload */
-CV_INLINE int cvCeil(int value) { return value; }
-
-/** @overload */
-CV_INLINE int cvIsNaN(float value) {
-#if defined CV_INLINE_ISNAN_FLT
-  CV_INLINE_ISNAN_FLT(value);
-#else
-  Cv32suf ieee754;
-  ieee754.f = value;
-  return (ieee754.u & 0x7fffffff) > 0x7f800000;
-#endif
-}
-
-/** @overload */
-CV_INLINE int cvIsInf(float value) {
-#if defined CV_INLINE_ISINF_FLT
-  CV_INLINE_ISINF_FLT(value);
-#else
-  Cv32suf ieee754;
-  ieee754.f = value;
-  return (ieee754.u & 0x7fffffff) == 0x7f800000;
-#endif
-}
-
-#endif // __cplusplus
-
-//! @} core_utils
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/hal/hal.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/hal/hal.hpp
deleted file mode 100644
index 996e301dab..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/hal/hal.hpp
+++ /dev/null
@@ -1,451 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Copyright (C) 2015, Itseez Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_HAL_HPP
-#define OPENCV_HAL_HPP
-
-#include "opencv2/core/cvdef.h"
-#include "opencv2/core/cvstd.hpp"
-#include "opencv2/core/hal/interface.h"
-
-namespace cv {
-namespace hal {
-
-//! @addtogroup core_hal_functions
-//! @{
-
-CV_EXPORTS int normHamming(const uchar *a, int n);
-CV_EXPORTS int normHamming(const uchar *a, const uchar *b, int n);
-
-CV_EXPORTS int normHamming(const uchar *a, int n, int cellSize);
-CV_EXPORTS int normHamming(const uchar *a, const uchar *b, int n, int cellSize);
-
-CV_EXPORTS int LU32f(float *A, size_t astep, int m, float *b, size_t bstep,
-                     int n);
-CV_EXPORTS int LU64f(double *A, size_t astep, int m, double *b, size_t bstep,
-                     int n);
-CV_EXPORTS bool Cholesky32f(float *A, size_t astep, int m, float *b,
-                            size_t bstep, int n);
-CV_EXPORTS bool Cholesky64f(double *A, size_t astep, int m, double *b,
-                            size_t bstep, int n);
-CV_EXPORTS void SVD32f(float *At, size_t astep, float *W, float *U,
-                       size_t ustep, float *Vt, size_t vstep, int m, int n,
-                       int flags);
-CV_EXPORTS void SVD64f(double *At, size_t astep, double *W, double *U,
-                       size_t ustep, double *Vt, size_t vstep, int m, int n,
-                       int flags);
-CV_EXPORTS int QR32f(float *A, size_t astep, int m, int n, int k, float *b,
-                     size_t bstep, float *hFactors);
-CV_EXPORTS int QR64f(double *A, size_t astep, int m, int n, int k, double *b,
-                     size_t bstep, double *hFactors);
-
-CV_EXPORTS void gemm32f(const float *src1, size_t src1_step, const float *src2,
-                        size_t src2_step, float alpha, const float *src3,
-                        size_t src3_step, float beta, float *dst,
-                        size_t dst_step, int m_a, int n_a, int n_d, int flags);
-CV_EXPORTS void gemm64f(const double *src1, size_t src1_step,
-                        const double *src2, size_t src2_step, double alpha,
-                        const double *src3, size_t src3_step, double beta,
-                        double *dst, size_t dst_step, int m_a, int n_a, int n_d,
-                        int flags);
-CV_EXPORTS void gemm32fc(const float *src1, size_t src1_step, const float *src2,
-                         size_t src2_step, float alpha, const float *src3,
-                         size_t src3_step, float beta, float *dst,
-                         size_t dst_step, int m_a, int n_a, int n_d, int flags);
-CV_EXPORTS void gemm64fc(const double *src1, size_t src1_step,
-                         const double *src2, size_t src2_step, double alpha,
-                         const double *src3, size_t src3_step, double beta,
-                         double *dst, size_t dst_step, int m_a, int n_a,
-                         int n_d, int flags);
-
-CV_EXPORTS int normL1_(const uchar *a, const uchar *b, int n);
-CV_EXPORTS float normL1_(const float *a, const float *b, int n);
-CV_EXPORTS float normL2Sqr_(const float *a, const float *b, int n);
-
-CV_EXPORTS void exp32f(const float *src, float *dst, int n);
-CV_EXPORTS void exp64f(const double *src, double *dst, int n);
-CV_EXPORTS void log32f(const float *src, float *dst, int n);
-CV_EXPORTS void log64f(const double *src, double *dst, int n);
-
-CV_EXPORTS void cartToPolar32f(const float *x, const float *y, float *mag,
-                               float *angle, int n, bool angleInDegrees);
-CV_EXPORTS void cartToPolar64f(const double *x, const double *y, double *mag,
-                               double *angle, int n, bool angleInDegrees);
-CV_EXPORTS void fastAtan32f(const float *y, const float *x, float *dst, int n,
-                            bool angleInDegrees);
-CV_EXPORTS void fastAtan64f(const double *y, const double *x, double *dst,
-                            int n, bool angleInDegrees);
-CV_EXPORTS void magnitude32f(const float *x, const float *y, float *dst, int n);
-CV_EXPORTS void magnitude64f(const double *x, const double *y, double *dst,
-                             int n);
-CV_EXPORTS void polarToCart32f(const float *mag, const float *angle, float *x,
-                               float *y, int n, bool angleInDegrees);
-CV_EXPORTS void polarToCart64f(const double *mag, const double *angle,
-                               double *x, double *y, int n,
-                               bool angleInDegrees);
-CV_EXPORTS void sqrt32f(const float *src, float *dst, int len);
-CV_EXPORTS void sqrt64f(const double *src, double *dst, int len);
-CV_EXPORTS void invSqrt32f(const float *src, float *dst, int len);
-CV_EXPORTS void invSqrt64f(const double *src, double *dst, int len);
-
-CV_EXPORTS void split8u(const uchar *src, uchar **dst, int len, int cn);
-CV_EXPORTS void split16u(const ushort *src, ushort **dst, int len, int cn);
-CV_EXPORTS void split32s(const int *src, int **dst, int len, int cn);
-CV_EXPORTS void split64s(const int64 *src, int64 **dst, int len, int cn);
-
-CV_EXPORTS void merge8u(const uchar **src, uchar *dst, int len, int cn);
-CV_EXPORTS void merge16u(const ushort **src, ushort *dst, int len, int cn);
-CV_EXPORTS void merge32s(const int **src, int *dst, int len, int cn);
-CV_EXPORTS void merge64s(const int64 **src, int64 *dst, int len, int cn);
-
-CV_EXPORTS void add8u(const uchar *src1, size_t step1, const uchar *src2,
-                      size_t step2, uchar *dst, size_t step, int width,
-                      int height, void *);
-CV_EXPORTS void add8s(const schar *src1, size_t step1, const schar *src2,
-                      size_t step2, schar *dst, size_t step, int width,
-                      int height, void *);
-CV_EXPORTS void add16u(const ushort *src1, size_t step1, const ushort *src2,
-                       size_t step2, ushort *dst, size_t step, int width,
-                       int height, void *);
-CV_EXPORTS void add16s(const short *src1, size_t step1, const short *src2,
-                       size_t step2, short *dst, size_t step, int width,
-                       int height, void *);
-CV_EXPORTS void add32s(const int *src1, size_t step1, const int *src2,
-                       size_t step2, int *dst, size_t step, int width,
-                       int height, void *);
-CV_EXPORTS void add32f(const float *src1, size_t step1, const float *src2,
-                       size_t step2, float *dst, size_t step, int width,
-                       int height, void *);
-CV_EXPORTS void add64f(const double *src1, size_t step1, const double *src2,
-                       size_t step2, double *dst, size_t step, int width,
-                       int height, void *);
-
-CV_EXPORTS void sub8u(const uchar *src1, size_t step1, const uchar *src2,
-                      size_t step2, uchar *dst, size_t step, int width,
-                      int height, void *);
-CV_EXPORTS void sub8s(const schar *src1, size_t step1, const schar *src2,
-                      size_t step2, schar *dst, size_t step, int width,
-                      int height, void *);
-CV_EXPORTS void sub16u(const ushort *src1, size_t step1, const ushort *src2,
-                       size_t step2, ushort *dst, size_t step, int width,
-                       int height, void *);
-CV_EXPORTS void sub16s(const short *src1, size_t step1, const short *src2,
-                       size_t step2, short *dst, size_t step, int width,
-                       int height, void *);
-CV_EXPORTS void sub32s(const int *src1, size_t step1, const int *src2,
-                       size_t step2, int *dst, size_t step, int width,
-                       int height, void *);
-CV_EXPORTS void sub32f(const float *src1, size_t step1, const float *src2,
-                       size_t step2, float *dst, size_t step, int width,
-                       int height, void *);
-CV_EXPORTS void sub64f(const double *src1, size_t step1, const double *src2,
-                       size_t step2, double *dst, size_t step, int width,
-                       int height, void *);
-
-CV_EXPORTS void max8u(const uchar *src1, size_t step1, const uchar *src2,
-                      size_t step2, uchar *dst, size_t step, int width,
-                      int height, void *);
-CV_EXPORTS void max8s(const schar *src1, size_t step1, const schar *src2,
-                      size_t step2, schar *dst, size_t step, int width,
-                      int height, void *);
-CV_EXPORTS void max16u(const ushort *src1, size_t step1, const ushort *src2,
-                       size_t step2, ushort *dst, size_t step, int width,
-                       int height, void *);
-CV_EXPORTS void max16s(const short *src1, size_t step1, const short *src2,
-                       size_t step2, short *dst, size_t step, int width,
-                       int height, void *);
-CV_EXPORTS void max32s(const int *src1, size_t step1, const int *src2,
-                       size_t step2, int *dst, size_t step, int width,
-                       int height, void *);
-CV_EXPORTS void max32f(const float *src1, size_t step1, const float *src2,
-                       size_t step2, float *dst, size_t step, int width,
-                       int height, void *);
-CV_EXPORTS void max64f(const double *src1, size_t step1, const double *src2,
-                       size_t step2, double *dst, size_t step, int width,
-                       int height, void *);
-
-CV_EXPORTS void min8u(const uchar *src1, size_t step1, const uchar *src2,
-                      size_t step2, uchar *dst, size_t step, int width,
-                      int height, void *);
-CV_EXPORTS void min8s(const schar *src1, size_t step1, const schar *src2,
-                      size_t step2, schar *dst, size_t step, int width,
-                      int height, void *);
-CV_EXPORTS void min16u(const ushort *src1, size_t step1, const ushort *src2,
-                       size_t step2, ushort *dst, size_t step, int width,
-                       int height, void *);
-CV_EXPORTS void min16s(const short *src1, size_t step1, const short *src2,
-                       size_t step2, short *dst, size_t step, int width,
-                       int height, void *);
-CV_EXPORTS void min32s(const int *src1, size_t step1, const int *src2,
-                       size_t step2, int *dst, size_t step, int width,
-                       int height, void *);
-CV_EXPORTS void min32f(const float *src1, size_t step1, const float *src2,
-                       size_t step2, float *dst, size_t step, int width,
-                       int height, void *);
-CV_EXPORTS void min64f(const double *src1, size_t step1, const double *src2,
-                       size_t step2, double *dst, size_t step, int width,
-                       int height, void *);
-
-CV_EXPORTS void absdiff8u(const uchar *src1, size_t step1, const uchar *src2,
-                          size_t step2, uchar *dst, size_t step, int width,
-                          int height, void *);
-CV_EXPORTS void absdiff8s(const schar *src1, size_t step1, const schar *src2,
-                          size_t step2, schar *dst, size_t step, int width,
-                          int height, void *);
-CV_EXPORTS void absdiff16u(const ushort *src1, size_t step1, const ushort *src2,
-                           size_t step2, ushort *dst, size_t step, int width,
-                           int height, void *);
-CV_EXPORTS void absdiff16s(const short *src1, size_t step1, const short *src2,
-                           size_t step2, short *dst, size_t step, int width,
-                           int height, void *);
-CV_EXPORTS void absdiff32s(const int *src1, size_t step1, const int *src2,
-                           size_t step2, int *dst, size_t step, int width,
-                           int height, void *);
-CV_EXPORTS void absdiff32f(const float *src1, size_t step1, const float *src2,
-                           size_t step2, float *dst, size_t step, int width,
-                           int height, void *);
-CV_EXPORTS void absdiff64f(const double *src1, size_t step1, const double *src2,
-                           size_t step2, double *dst, size_t step, int width,
-                           int height, void *);
-
-CV_EXPORTS void and8u(const uchar *src1, size_t step1, const uchar *src2,
-                      size_t step2, uchar *dst, size_t step, int width,
-                      int height, void *);
-CV_EXPORTS void or8u(const uchar *src1, size_t step1, const uchar *src2,
-                     size_t step2, uchar *dst, size_t step, int width,
-                     int height, void *);
-CV_EXPORTS void xor8u(const uchar *src1, size_t step1, const uchar *src2,
-                      size_t step2, uchar *dst, size_t step, int width,
-                      int height, void *);
-CV_EXPORTS void not8u(const uchar *src1, size_t step1, const uchar *src2,
-                      size_t step2, uchar *dst, size_t step, int width,
-                      int height, void *);
-
-CV_EXPORTS void cmp8u(const uchar *src1, size_t step1, const uchar *src2,
-                      size_t step2, uchar *dst, size_t step, int width,
-                      int height, void *_cmpop);
-CV_EXPORTS void cmp8s(const schar *src1, size_t step1, const schar *src2,
-                      size_t step2, uchar *dst, size_t step, int width,
-                      int height, void *_cmpop);
-CV_EXPORTS void cmp16u(const ushort *src1, size_t step1, const ushort *src2,
-                       size_t step2, uchar *dst, size_t step, int width,
-                       int height, void *_cmpop);
-CV_EXPORTS void cmp16s(const short *src1, size_t step1, const short *src2,
-                       size_t step2, uchar *dst, size_t step, int width,
-                       int height, void *_cmpop);
-CV_EXPORTS void cmp32s(const int *src1, size_t step1, const int *src2,
-                       size_t step2, uchar *dst, size_t step, int width,
-                       int height, void *_cmpop);
-CV_EXPORTS void cmp32f(const float *src1, size_t step1, const float *src2,
-                       size_t step2, uchar *dst, size_t step, int width,
-                       int height, void *_cmpop);
-CV_EXPORTS void cmp64f(const double *src1, size_t step1, const double *src2,
-                       size_t step2, uchar *dst, size_t step, int width,
-                       int height, void *_cmpop);
-
-CV_EXPORTS void mul8u(const uchar *src1, size_t step1, const uchar *src2,
-                      size_t step2, uchar *dst, size_t step, int width,
-                      int height, void *scale);
-CV_EXPORTS void mul8s(const schar *src1, size_t step1, const schar *src2,
-                      size_t step2, schar *dst, size_t step, int width,
-                      int height, void *scale);
-CV_EXPORTS void mul16u(const ushort *src1, size_t step1, const ushort *src2,
-                       size_t step2, ushort *dst, size_t step, int width,
-                       int height, void *scale);
-CV_EXPORTS void mul16s(const short *src1, size_t step1, const short *src2,
-                       size_t step2, short *dst, size_t step, int width,
-                       int height, void *scale);
-CV_EXPORTS void mul32s(const int *src1, size_t step1, const int *src2,
-                       size_t step2, int *dst, size_t step, int width,
-                       int height, void *scale);
-CV_EXPORTS void mul32f(const float *src1, size_t step1, const float *src2,
-                       size_t step2, float *dst, size_t step, int width,
-                       int height, void *scale);
-CV_EXPORTS void mul64f(const double *src1, size_t step1, const double *src2,
-                       size_t step2, double *dst, size_t step, int width,
-                       int height, void *scale);
-
-CV_EXPORTS void div8u(const uchar *src1, size_t step1, const uchar *src2,
-                      size_t step2, uchar *dst, size_t step, int width,
-                      int height, void *scale);
-CV_EXPORTS void div8s(const schar *src1, size_t step1, const schar *src2,
-                      size_t step2, schar *dst, size_t step, int width,
-                      int height, void *scale);
-CV_EXPORTS void div16u(const ushort *src1, size_t step1, const ushort *src2,
-                       size_t step2, ushort *dst, size_t step, int width,
-                       int height, void *scale);
-CV_EXPORTS void div16s(const short *src1, size_t step1, const short *src2,
-                       size_t step2, short *dst, size_t step, int width,
-                       int height, void *scale);
-CV_EXPORTS void div32s(const int *src1, size_t step1, const int *src2,
-                       size_t step2, int *dst, size_t step, int width,
-                       int height, void *scale);
-CV_EXPORTS void div32f(const float *src1, size_t step1, const float *src2,
-                       size_t step2, float *dst, size_t step, int width,
-                       int height, void *scale);
-CV_EXPORTS void div64f(const double *src1, size_t step1, const double *src2,
-                       size_t step2, double *dst, size_t step, int width,
-                       int height, void *scale);
-
-CV_EXPORTS void recip8u(const uchar *, size_t, const uchar *src2, size_t step2,
-                        uchar *dst, size_t step, int width, int height,
-                        void *scale);
-CV_EXPORTS void recip8s(const schar *, size_t, const schar *src2, size_t step2,
-                        schar *dst, size_t step, int width, int height,
-                        void *scale);
-CV_EXPORTS void recip16u(const ushort *, size_t, const ushort *src2,
-                         size_t step2, ushort *dst, size_t step, int width,
-                         int height, void *scale);
-CV_EXPORTS void recip16s(const short *, size_t, const short *src2, size_t step2,
-                         short *dst, size_t step, int width, int height,
-                         void *scale);
-CV_EXPORTS void recip32s(const int *, size_t, const int *src2, size_t step2,
-                         int *dst, size_t step, int width, int height,
-                         void *scale);
-CV_EXPORTS void recip32f(const float *, size_t, const float *src2, size_t step2,
-                         float *dst, size_t step, int width, int height,
-                         void *scale);
-CV_EXPORTS void recip64f(const double *, size_t, const double *src2,
-                         size_t step2, double *dst, size_t step, int width,
-                         int height, void *scale);
-
-CV_EXPORTS void addWeighted8u(const uchar *src1, size_t step1,
-                              const uchar *src2, size_t step2, uchar *dst,
-                              size_t step, int width, int height,
-                              void *_scalars);
-CV_EXPORTS void addWeighted8s(const schar *src1, size_t step1,
-                              const schar *src2, size_t step2, schar *dst,
-                              size_t step, int width, int height,
-                              void *scalars);
-CV_EXPORTS void addWeighted16u(const ushort *src1, size_t step1,
-                               const ushort *src2, size_t step2, ushort *dst,
-                               size_t step, int width, int height,
-                               void *scalars);
-CV_EXPORTS void addWeighted16s(const short *src1, size_t step1,
-                               const short *src2, size_t step2, short *dst,
-                               size_t step, int width, int height,
-                               void *scalars);
-CV_EXPORTS void addWeighted32s(const int *src1, size_t step1, const int *src2,
-                               size_t step2, int *dst, size_t step, int width,
-                               int height, void *scalars);
-CV_EXPORTS void addWeighted32f(const float *src1, size_t step1,
-                               const float *src2, size_t step2, float *dst,
-                               size_t step, int width, int height,
-                               void *scalars);
-CV_EXPORTS void addWeighted64f(const double *src1, size_t step1,
-                               const double *src2, size_t step2, double *dst,
-                               size_t step, int width, int height,
-                               void *scalars);
-
-CV_EXPORTS void cvt16f32f(const hfloat *src, float *dst, int len);
-CV_EXPORTS void cvt32f16f(const float *src, hfloat *dst, int len);
-
-CV_EXPORTS void addRNGBias32f(float *arr, const float *scaleBiasPairs, int len);
-CV_EXPORTS void addRNGBias64f(double *arr, const double *scaleBiasPairs,
-                              int len);
-
-struct CV_EXPORTS DFT1D {
-  static Ptr<DFT1D> create(int len, int count, int depth, int flags,
-                           bool *useBuffer = 0);
-  virtual void apply(const uchar *src, uchar *dst) = 0;
-  virtual ~DFT1D() {}
-};
-
-struct CV_EXPORTS DFT2D {
-  static Ptr<DFT2D> create(int width, int height, int depth, int src_channels,
-                           int dst_channels, int flags, int nonzero_rows = 0);
-  virtual void apply(const uchar *src_data, size_t src_step, uchar *dst_data,
-                     size_t dst_step) = 0;
-  virtual ~DFT2D() {}
-};
-
-struct CV_EXPORTS DCT2D {
-  static Ptr<DCT2D> create(int width, int height, int depth, int flags);
-  virtual void apply(const uchar *src_data, size_t src_step, uchar *dst_data,
-                     size_t dst_step) = 0;
-  virtual ~DCT2D() {}
-};
-
-//! @} core_hal
-
-//=============================================================================
-// for binary compatibility with 3.0
-
-//! @cond IGNORED
-
-CV_EXPORTS int LU(float *A, size_t astep, int m, float *b, size_t bstep, int n);
-CV_EXPORTS int LU(double *A, size_t astep, int m, double *b, size_t bstep,
-                  int n);
-CV_EXPORTS bool Cholesky(float *A, size_t astep, int m, float *b, size_t bstep,
-                         int n);
-CV_EXPORTS bool Cholesky(double *A, size_t astep, int m, double *b,
-                         size_t bstep, int n);
-
-CV_EXPORTS void exp(const float *src, float *dst, int n);
-CV_EXPORTS void exp(const double *src, double *dst, int n);
-CV_EXPORTS void log(const float *src, float *dst, int n);
-CV_EXPORTS void log(const double *src, double *dst, int n);
-
-CV_EXPORTS void fastAtan2(const float *y, const float *x, float *dst, int n,
-                          bool angleInDegrees);
-CV_EXPORTS void magnitude(const float *x, const float *y, float *dst, int n);
-CV_EXPORTS void magnitude(const double *x, const double *y, double *dst, int n);
-CV_EXPORTS void sqrt(const float *src, float *dst, int len);
-CV_EXPORTS void sqrt(const double *src, double *dst, int len);
-CV_EXPORTS void invSqrt(const float *src, float *dst, int len);
-CV_EXPORTS void invSqrt(const double *src, double *dst, int len);
-
-//! @endcond
-
-} // namespace hal
-} // namespace cv
-
-#endif // OPENCV_HAL_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/hal/interface.h b/packages/react-native-executorch/third-party/include/opencv2/core/hal/interface.h
deleted file mode 100644
index bf29def709..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/hal/interface.h
+++ /dev/null
@@ -1,191 +0,0 @@
-#ifndef OPENCV_CORE_HAL_INTERFACE_H
-#define OPENCV_CORE_HAL_INTERFACE_H
-
-//! @addtogroup core_hal_interface
-//! @{
-
-//! @name Return codes
-//! @{
-#define CV_HAL_ERROR_OK 0
-#define CV_HAL_ERROR_NOT_IMPLEMENTED 1
-#define CV_HAL_ERROR_UNKNOWN -1
-//! @}
-
-#ifdef __cplusplus
-#include <cstddef>
-#else
-#include <stdbool.h>
-#include <stddef.h>
-#endif
-
-//! @name Data types
-//! primitive types
-//! - schar  - signed 1 byte integer
-//! - uchar  - unsigned 1 byte integer
-//! - short  - signed 2 byte integer
-//! - ushort - unsigned 2 byte integer
-//! - int    - signed 4 byte integer
-//! - uint   - unsigned 4 byte integer
-//! - int64  - signed 8 byte integer
-//! - uint64 - unsigned 8 byte integer
-//! @{
-#if !defined _MSC_VER && !defined __BORLANDC__
-#if defined __cplusplus && __cplusplus >= 201103L && !defined __APPLE__
-#include <cstdint>
-#ifdef __NEWLIB__
-typedef unsigned int uint;
-#else
-typedef std::uint32_t uint;
-#endif
-#else
-#include <stdint.h>
-typedef uint32_t uint;
-#endif
-#else
-typedef unsigned uint;
-#endif
-
-typedef signed char schar;
-
-#ifndef __IPL_H__
-typedef unsigned char uchar;
-typedef unsigned short ushort;
-#endif
-
-#if defined _MSC_VER || defined __BORLANDC__
-typedef __int64 int64;
-typedef unsigned __int64 uint64;
-#define CV_BIG_INT(n) n##I64
-#define CV_BIG_UINT(n) n##UI64
-#else
-typedef int64_t int64;
-typedef uint64_t uint64;
-#define CV_BIG_INT(n) n##LL
-#define CV_BIG_UINT(n) n##ULL
-#endif
-
-#define CV_USRTYPE1 (void)"CV_USRTYPE1 support has been dropped in OpenCV 4.0"
-
-#define CV_CN_MAX 512
-#define CV_CN_SHIFT 3
-#define CV_DEPTH_MAX (1 << CV_CN_SHIFT)
-
-#define CV_8U 0
-#define CV_8S 1
-#define CV_16U 2
-#define CV_16S 3
-#define CV_32S 4
-#define CV_32F 5
-#define CV_64F 6
-#define CV_16F 7
-
-#define CV_MAT_DEPTH_MASK (CV_DEPTH_MAX - 1)
-#define CV_MAT_DEPTH(flags) ((flags) & CV_MAT_DEPTH_MASK)
-
-#define CV_MAKETYPE(depth, cn)                                                 \
-  (CV_MAT_DEPTH(depth) + (((cn) - 1) << CV_CN_SHIFT))
-#define CV_MAKE_TYPE CV_MAKETYPE
-
-#define CV_8UC1 CV_MAKETYPE(CV_8U, 1)
-#define CV_8UC2 CV_MAKETYPE(CV_8U, 2)
-#define CV_8UC3 CV_MAKETYPE(CV_8U, 3)
-#define CV_8UC4 CV_MAKETYPE(CV_8U, 4)
-#define CV_8UC(n) CV_MAKETYPE(CV_8U, (n))
-
-#define CV_8SC1 CV_MAKETYPE(CV_8S, 1)
-#define CV_8SC2 CV_MAKETYPE(CV_8S, 2)
-#define CV_8SC3 CV_MAKETYPE(CV_8S, 3)
-#define CV_8SC4 CV_MAKETYPE(CV_8S, 4)
-#define CV_8SC(n) CV_MAKETYPE(CV_8S, (n))
-
-#define CV_16UC1 CV_MAKETYPE(CV_16U, 1)
-#define CV_16UC2 CV_MAKETYPE(CV_16U, 2)
-#define CV_16UC3 CV_MAKETYPE(CV_16U, 3)
-#define CV_16UC4 CV_MAKETYPE(CV_16U, 4)
-#define CV_16UC(n) CV_MAKETYPE(CV_16U, (n))
-
-#define CV_16SC1 CV_MAKETYPE(CV_16S, 1)
-#define CV_16SC2 CV_MAKETYPE(CV_16S, 2)
-#define CV_16SC3 CV_MAKETYPE(CV_16S, 3)
-#define CV_16SC4 CV_MAKETYPE(CV_16S, 4)
-#define CV_16SC(n) CV_MAKETYPE(CV_16S, (n))
-
-#define CV_32SC1 CV_MAKETYPE(CV_32S, 1)
-#define CV_32SC2 CV_MAKETYPE(CV_32S, 2)
-#define CV_32SC3 CV_MAKETYPE(CV_32S, 3)
-#define CV_32SC4 CV_MAKETYPE(CV_32S, 4)
-#define CV_32SC(n) CV_MAKETYPE(CV_32S, (n))
-
-#define CV_32FC1 CV_MAKETYPE(CV_32F, 1)
-#define CV_32FC2 CV_MAKETYPE(CV_32F, 2)
-#define CV_32FC3 CV_MAKETYPE(CV_32F, 3)
-#define CV_32FC4 CV_MAKETYPE(CV_32F, 4)
-#define CV_32FC(n) CV_MAKETYPE(CV_32F, (n))
-
-#define CV_64FC1 CV_MAKETYPE(CV_64F, 1)
-#define CV_64FC2 CV_MAKETYPE(CV_64F, 2)
-#define CV_64FC3 CV_MAKETYPE(CV_64F, 3)
-#define CV_64FC4 CV_MAKETYPE(CV_64F, 4)
-#define CV_64FC(n) CV_MAKETYPE(CV_64F, (n))
-
-#define CV_16FC1 CV_MAKETYPE(CV_16F, 1)
-#define CV_16FC2 CV_MAKETYPE(CV_16F, 2)
-#define CV_16FC3 CV_MAKETYPE(CV_16F, 3)
-#define CV_16FC4 CV_MAKETYPE(CV_16F, 4)
-#define CV_16FC(n) CV_MAKETYPE(CV_16F, (n))
-//! @}
-
-//! @name Comparison operation
-//! @sa cv::CmpTypes
-//! @{
-#define CV_HAL_CMP_EQ 0
-#define CV_HAL_CMP_GT 1
-#define CV_HAL_CMP_GE 2
-#define CV_HAL_CMP_LT 3
-#define CV_HAL_CMP_LE 4
-#define CV_HAL_CMP_NE 5
-//! @}
-
-//! @name Border processing modes
-//! @sa cv::BorderTypes
-//! @{
-#define CV_HAL_BORDER_CONSTANT 0
-#define CV_HAL_BORDER_REPLICATE 1
-#define CV_HAL_BORDER_REFLECT 2
-#define CV_HAL_BORDER_WRAP 3
-#define CV_HAL_BORDER_REFLECT_101 4
-#define CV_HAL_BORDER_TRANSPARENT 5
-#define CV_HAL_BORDER_ISOLATED 16
-//! @}
-
-//! @name DFT flags
-//! @{
-#define CV_HAL_DFT_INVERSE 1
-#define CV_HAL_DFT_SCALE 2
-#define CV_HAL_DFT_ROWS 4
-#define CV_HAL_DFT_COMPLEX_OUTPUT 16
-#define CV_HAL_DFT_REAL_OUTPUT 32
-#define CV_HAL_DFT_TWO_STAGE 64
-#define CV_HAL_DFT_STAGE_COLS 128
-#define CV_HAL_DFT_IS_CONTINUOUS 512
-#define CV_HAL_DFT_IS_INPLACE 1024
-//! @}
-
-//! @name SVD flags
-//! @{
-#define CV_HAL_SVD_NO_UV 1
-#define CV_HAL_SVD_SHORT_UV 2
-#define CV_HAL_SVD_MODIFY_A 4
-#define CV_HAL_SVD_FULL_UV 8
-//! @}
-
-//! @name Gemm flags
-//! @{
-#define CV_HAL_GEMM_1_T 1
-#define CV_HAL_GEMM_2_T 2
-#define CV_HAL_GEMM_3_T 4
-//! @}
-
-//! @}
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin.hpp
deleted file mode 100644
index b946b41ac1..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin.hpp
+++ /dev/null
@@ -1,1222 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Copyright (C) 2015, Itseez Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_HAL_INTRIN_HPP
-#define OPENCV_HAL_INTRIN_HPP
-
-#include "opencv2/core/cvdef.h"
-#include <cmath>
-#include <float.h>
-#include <stdlib.h>
-
-#if defined(__GNUC__) && __GNUC__ == 12
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wuninitialized"
-#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif
-
-#define OPENCV_HAL_ADD(a, b) ((a) + (b))
-#define OPENCV_HAL_AND(a, b) ((a) & (b))
-#define OPENCV_HAL_NOP(a) (a)
-#define OPENCV_HAL_1ST(a, b) (a)
-
-namespace {
-inline unsigned int trailingZeros32(unsigned int value) {
-#if defined(_MSC_VER)
-#if (_MSC_VER < 1700) || defined(_M_ARM) || defined(_M_ARM64) ||               \
-    defined(_M_ARM64EC)
-  unsigned long index = 0;
-  _BitScanForward(&index, value);
-  return (unsigned int)index;
-#elif defined(__clang__)
-  // clang-cl doesn't export _tzcnt_u32 for non BMI systems
-  return value ? __builtin_ctz(value) : 32;
-#else
-  return _tzcnt_u32(value);
-#endif
-#elif defined(__GNUC__) || defined(__GNUG__)
-  return __builtin_ctz(value);
-#elif defined(__ICC) || defined(__INTEL_COMPILER)
-  return _bit_scan_forward(value);
-#elif defined(__clang__)
-  return llvm.cttz.i32(value, true);
-#else
-  static const int MultiplyDeBruijnBitPosition[32] = {
-      0,  1,  28, 2,  29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4,  8,
-      31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6,  11, 5,  10, 9};
-  return MultiplyDeBruijnBitPosition[((uint32_t)((value & -value) *
-                                                 0x077CB531U)) >>
-                                     27];
-#endif
-}
-} // namespace
-
-// unlike HAL API, which is in cv::hal,
-// we put intrinsics into cv namespace to make its
-// access from within opencv code more accessible
-namespace cv {
-
-namespace hal {
-
-enum StoreMode {
-  STORE_UNALIGNED = 0,
-  STORE_ALIGNED = 1,
-  STORE_ALIGNED_NOCACHE = 2
-};
-
-}
-
-// TODO FIXIT: Don't use "God" traits. Split on separate cases.
-template <typename _Tp> struct V_TypeTraits {};
-
-#define CV_INTRIN_DEF_TYPE_TRAITS(type, int_type_, uint_type_, abs_type_,      \
-                                  w_type_, q_type_, sum_type_)                 \
-  template <> struct V_TypeTraits<type> {                                      \
-    typedef type value_type;                                                   \
-    typedef int_type_ int_type;                                                \
-    typedef abs_type_ abs_type;                                                \
-    typedef uint_type_ uint_type;                                              \
-    typedef w_type_ w_type;                                                    \
-    typedef q_type_ q_type;                                                    \
-    typedef sum_type_ sum_type;                                                \
-                                                                               \
-    static inline int_type reinterpret_int(type x) {                           \
-      union {                                                                  \
-        type l;                                                                \
-        int_type i;                                                            \
-      } v;                                                                     \
-      v.l = x;                                                                 \
-      return v.i;                                                              \
-    }                                                                          \
-                                                                               \
-    static inline type reinterpret_from_int(int_type x) {                      \
-      union {                                                                  \
-        type l;                                                                \
-        int_type i;                                                            \
-      } v;                                                                     \
-      v.i = x;                                                                 \
-      return v.l;                                                              \
-    }                                                                          \
-  }
-
-#define CV_INTRIN_DEF_TYPE_TRAITS_NO_Q_TYPE(type, int_type_, uint_type_,       \
-                                            abs_type_, w_type_, sum_type_)     \
-  template <> struct V_TypeTraits<type> {                                      \
-    typedef type value_type;                                                   \
-    typedef int_type_ int_type;                                                \
-    typedef abs_type_ abs_type;                                                \
-    typedef uint_type_ uint_type;                                              \
-    typedef w_type_ w_type;                                                    \
-    typedef sum_type_ sum_type;                                                \
-                                                                               \
-    static inline int_type reinterpret_int(type x) {                           \
-      union {                                                                  \
-        type l;                                                                \
-        int_type i;                                                            \
-      } v;                                                                     \
-      v.l = x;                                                                 \
-      return v.i;                                                              \
-    }                                                                          \
-                                                                               \
-    static inline type reinterpret_from_int(int_type x) {                      \
-      union {                                                                  \
-        type l;                                                                \
-        int_type i;                                                            \
-      } v;                                                                     \
-      v.i = x;                                                                 \
-      return v.l;                                                              \
-    }                                                                          \
-  }
-
-CV_INTRIN_DEF_TYPE_TRAITS(uchar, schar, uchar, uchar, ushort, unsigned,
-                          unsigned);
-CV_INTRIN_DEF_TYPE_TRAITS(schar, schar, uchar, uchar, short, int, int);
-CV_INTRIN_DEF_TYPE_TRAITS(ushort, short, ushort, ushort, unsigned, uint64,
-                          unsigned);
-CV_INTRIN_DEF_TYPE_TRAITS(short, short, ushort, ushort, int, int64, int);
-CV_INTRIN_DEF_TYPE_TRAITS_NO_Q_TYPE(unsigned, int, unsigned, unsigned, uint64,
-                                    unsigned);
-CV_INTRIN_DEF_TYPE_TRAITS_NO_Q_TYPE(int, int, unsigned, unsigned, int64, int);
-CV_INTRIN_DEF_TYPE_TRAITS_NO_Q_TYPE(float, int, unsigned, float, double, float);
-CV_INTRIN_DEF_TYPE_TRAITS_NO_Q_TYPE(uint64, int64, uint64, uint64, void,
-                                    uint64);
-CV_INTRIN_DEF_TYPE_TRAITS_NO_Q_TYPE(int64, int64, uint64, uint64, void, int64);
-CV_INTRIN_DEF_TYPE_TRAITS_NO_Q_TYPE(double, int64, uint64, double, void,
-                                    double);
-
-#ifndef CV_DOXYGEN
-
-#ifndef CV_CPU_OPTIMIZATION_HAL_NAMESPACE
-#ifdef CV_FORCE_SIMD128_CPP
-#define CV_CPU_OPTIMIZATION_HAL_NAMESPACE hal_EMULATOR_CPP
-#define CV_CPU_OPTIMIZATION_HAL_NAMESPACE_BEGIN namespace hal_EMULATOR_CPP {
-#define CV_CPU_OPTIMIZATION_HAL_NAMESPACE_END }
-#elif defined(CV_CPU_DISPATCH_MODE)
-#define CV_CPU_OPTIMIZATION_HAL_NAMESPACE __CV_CAT(hal_, CV_CPU_DISPATCH_MODE)
-#define CV_CPU_OPTIMIZATION_HAL_NAMESPACE_BEGIN                                \
-  namespace __CV_CAT(hal_, CV_CPU_DISPATCH_MODE) {
-#define CV_CPU_OPTIMIZATION_HAL_NAMESPACE_END }
-#else
-#define CV_CPU_OPTIMIZATION_HAL_NAMESPACE hal_baseline
-#define CV_CPU_OPTIMIZATION_HAL_NAMESPACE_BEGIN namespace hal_baseline {
-#define CV_CPU_OPTIMIZATION_HAL_NAMESPACE_END }
-#endif
-#endif // CV_CPU_OPTIMIZATION_HAL_NAMESPACE
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_BEGIN
-
-template <typename _VecTp> inline _VecTp v_setzero_();
-template <typename _VecTp> inline _VecTp v_setall_(uchar);
-template <typename _VecTp> inline _VecTp v_setall_(schar);
-template <typename _VecTp> inline _VecTp v_setall_(ushort);
-template <typename _VecTp> inline _VecTp v_setall_(short);
-template <typename _VecTp> inline _VecTp v_setall_(unsigned);
-template <typename _VecTp> inline _VecTp v_setall_(int);
-template <typename _VecTp> inline _VecTp v_setall_(uint64);
-template <typename _VecTp> inline _VecTp v_setall_(int64);
-template <typename _VecTp> inline _VecTp v_setall_(float);
-template <typename _VecTp> inline _VecTp v_setall_(double);
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_END
-using namespace CV_CPU_OPTIMIZATION_HAL_NAMESPACE;
-#endif
-} // namespace cv
-
-#ifdef CV_DOXYGEN
-#undef CV_AVX2
-#undef CV_SSE2
-#undef CV_NEON
-#undef CV_VSX
-#undef CV_FP16
-#undef CV_MSA
-#undef CV_RVV
-#endif
-
-#if (CV_SSE2 || CV_NEON || CV_VSX || CV_MSA || CV_WASM_SIMD || CV_RVV071 ||    \
-     CV_LSX) &&                                                                \
-    !defined(CV_FORCE_SIMD128_CPP)
-#define CV__SIMD_FORWARD 128
-#include "opencv2/core/hal/intrin_forward.hpp"
-#endif
-
-#if CV_SSE2 && !defined(CV_FORCE_SIMD128_CPP)
-
-#include "opencv2/core/hal/intrin_sse.hpp"
-#include "opencv2/core/hal/intrin_sse_em.hpp"
-
-#elif CV_NEON && !defined(CV_FORCE_SIMD128_CPP)
-
-#include "opencv2/core/hal/intrin_neon.hpp"
-
-#elif CV_RVV071 && !defined(CV_FORCE_SIMD128_CPP)
-#define CV_SIMD128_CPP 0
-#include "opencv2/core/hal/intrin_rvv071.hpp"
-
-#elif CV_VSX && !defined(CV_FORCE_SIMD128_CPP)
-
-#include "opencv2/core/hal/intrin_vsx.hpp"
-
-#elif CV_MSA && !defined(CV_FORCE_SIMD128_CPP)
-
-#include "opencv2/core/hal/intrin_msa.hpp"
-
-#elif CV_WASM_SIMD && !defined(CV_FORCE_SIMD128_CPP)
-#include "opencv2/core/hal/intrin_wasm.hpp"
-
-#elif CV_RVV && !defined(CV_FORCE_SIMD128_CPP)
-#include "opencv2/core/hal/intrin_rvv_scalable.hpp"
-
-#elif CV_LSX && !defined(CV_FORCE_SIMD128_CPP)
-
-#include "opencv2/core/hal/intrin_lsx.hpp"
-
-#else
-
-#include "opencv2/core/hal/intrin_cpp.hpp"
-
-#endif
-
-// AVX2 can be used together with SSE2, so
-// we define those two sets of intrinsics at once.
-// Most of the intrinsics do not conflict (the proper overloaded variant is
-// resolved by the argument types, e.g. v_float32x4 ~ SSE2, v_float32x8 ~ AVX2),
-// but some of AVX2 intrinsics get v256_ prefix instead of v_, e.g. v256_load()
-// vs v_load(). Correspondingly, the wide intrinsics (which are mapped to the
-// "widest" available instruction set) will get vx_ prefix (and will be mapped
-// to v256_ counterparts) (e.g. vx_load() => v256_load())
-#if CV_AVX2
-
-#define CV__SIMD_FORWARD 256
-#include "opencv2/core/hal/intrin_avx.hpp"
-#include "opencv2/core/hal/intrin_forward.hpp"
-
-#endif
-
-// AVX512 can be used together with SSE2 and AVX2, so
-// we define those sets of intrinsics at once.
-// For some of AVX512 intrinsics get v512_ prefix instead of v_, e.g.
-// v512_load() vs v_load(). Wide intrinsics will be mapped to v512_ counterparts
-// in this case(e.g. vx_load() => v512_load())
-#if CV_AVX512_SKX
-
-#define CV__SIMD_FORWARD 512
-#include "opencv2/core/hal/intrin_avx512.hpp"
-#include "opencv2/core/hal/intrin_forward.hpp"
-
-#endif
-
-#if CV_LASX
-
-#define CV__SIMD_FORWARD 256
-#include "opencv2/core/hal/intrin_forward.hpp"
-#include "opencv2/core/hal/intrin_lasx.hpp"
-
-#endif
-
-//! @cond IGNORED
-
-namespace cv {
-
-#ifndef CV_DOXYGEN
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_BEGIN
-#endif
-
-#ifndef CV_SIMD128
-#define CV_SIMD128 0
-#endif
-
-#ifndef CV_SIMD128_CPP
-#define CV_SIMD128_CPP 0
-#endif
-
-#ifndef CV_SIMD128_64F
-#define CV_SIMD128_64F 0
-#endif
-
-#ifndef CV_SIMD256
-#define CV_SIMD256 0
-#endif
-
-#ifndef CV_SIMD256_64F
-#define CV_SIMD256_64F 0
-#endif
-
-#ifndef CV_SIMD512
-#define CV_SIMD512 0
-#endif
-
-#ifndef CV_SIMD512_64F
-#define CV_SIMD512_64F 0
-#endif
-
-#ifndef CV_SIMD128_FP16
-#define CV_SIMD128_FP16 0
-#endif
-
-#ifndef CV_SIMD256_FP16
-#define CV_SIMD256_FP16 0
-#endif
-
-#ifndef CV_SIMD512_FP16
-#define CV_SIMD512_FP16 0
-#endif
-
-#ifndef CV_SIMD_SCALABLE
-#define CV_SIMD_SCALABLE 0
-#endif
-
-#ifndef CV_SIMD_SCALABLE_64F
-#define CV_SIMD_SCALABLE_64F 0
-#endif
-
-//==================================================================================================
-
-template <typename _Tp> struct V_RegTraits {};
-
-#define CV_DEF_REG_TRAITS(prefix, _reg, lane_type, suffix, _u_reg, _w_reg,     \
-                          _q_reg, _int_reg, _round_reg)                        \
-  template <> struct V_RegTraits<_reg> {                                       \
-    typedef _reg reg;                                                          \
-    typedef _u_reg u_reg;                                                      \
-    typedef _w_reg w_reg;                                                      \
-    typedef _q_reg q_reg;                                                      \
-    typedef _int_reg int_reg;                                                  \
-    typedef _round_reg round_reg;                                              \
-  }
-
-#if CV_SIMD128 || CV_SIMD128_CPP
-CV_DEF_REG_TRAITS(v, v_uint8x16, uchar, u8, v_uint8x16, v_uint16x8, v_uint32x4,
-                  v_int8x16, void);
-CV_DEF_REG_TRAITS(v, v_int8x16, schar, s8, v_uint8x16, v_int16x8, v_int32x4,
-                  v_int8x16, void);
-CV_DEF_REG_TRAITS(v, v_uint16x8, ushort, u16, v_uint16x8, v_uint32x4,
-                  v_uint64x2, v_int16x8, void);
-CV_DEF_REG_TRAITS(v, v_int16x8, short, s16, v_uint16x8, v_int32x4, v_int64x2,
-                  v_int16x8, void);
-CV_DEF_REG_TRAITS(v, v_uint32x4, unsigned, u32, v_uint32x4, v_uint64x2, void,
-                  v_int32x4, void);
-CV_DEF_REG_TRAITS(v, v_int32x4, int, s32, v_uint32x4, v_int64x2, void,
-                  v_int32x4, void);
-#if CV_SIMD128_64F || CV_SIMD128_CPP
-CV_DEF_REG_TRAITS(v, v_float32x4, float, f32, v_float32x4, v_float64x2, void,
-                  v_int32x4, v_int32x4);
-#else
-CV_DEF_REG_TRAITS(v, v_float32x4, float, f32, v_float32x4, void, void,
-                  v_int32x4, v_int32x4);
-#endif
-CV_DEF_REG_TRAITS(v, v_uint64x2, uint64, u64, v_uint64x2, void, void, v_int64x2,
-                  void);
-CV_DEF_REG_TRAITS(v, v_int64x2, int64, s64, v_uint64x2, void, void, v_int64x2,
-                  void);
-#if CV_SIMD128_64F
-CV_DEF_REG_TRAITS(v, v_float64x2, double, f64, v_float64x2, void, void,
-                  v_int64x2, v_int32x4);
-#endif
-#endif
-
-#if CV_SIMD256
-CV_DEF_REG_TRAITS(v256, v_uint8x32, uchar, u8, v_uint8x32, v_uint16x16,
-                  v_uint32x8, v_int8x32, void);
-CV_DEF_REG_TRAITS(v256, v_int8x32, schar, s8, v_uint8x32, v_int16x16, v_int32x8,
-                  v_int8x32, void);
-CV_DEF_REG_TRAITS(v256, v_uint16x16, ushort, u16, v_uint16x16, v_uint32x8,
-                  v_uint64x4, v_int16x16, void);
-CV_DEF_REG_TRAITS(v256, v_int16x16, short, s16, v_uint16x16, v_int32x8,
-                  v_int64x4, v_int16x16, void);
-CV_DEF_REG_TRAITS(v256, v_uint32x8, unsigned, u32, v_uint32x8, v_uint64x4, void,
-                  v_int32x8, void);
-CV_DEF_REG_TRAITS(v256, v_int32x8, int, s32, v_uint32x8, v_int64x4, void,
-                  v_int32x8, void);
-CV_DEF_REG_TRAITS(v256, v_float32x8, float, f32, v_float32x8, v_float64x4, void,
-                  v_int32x8, v_int32x8);
-CV_DEF_REG_TRAITS(v256, v_uint64x4, uint64, u64, v_uint64x4, void, void,
-                  v_int64x4, void);
-CV_DEF_REG_TRAITS(v256, v_int64x4, int64, s64, v_uint64x4, void, void,
-                  v_int64x4, void);
-CV_DEF_REG_TRAITS(v256, v_float64x4, double, f64, v_float64x4, void, void,
-                  v_int64x4, v_int32x8);
-#endif
-
-#if CV_SIMD512
-CV_DEF_REG_TRAITS(v512, v_uint8x64, uchar, u8, v_uint8x64, v_uint16x32,
-                  v_uint32x16, v_int8x64, void);
-CV_DEF_REG_TRAITS(v512, v_int8x64, schar, s8, v_uint8x64, v_int16x32,
-                  v_int32x16, v_int8x64, void);
-CV_DEF_REG_TRAITS(v512, v_uint16x32, ushort, u16, v_uint16x32, v_uint32x16,
-                  v_uint64x8, v_int16x32, void);
-CV_DEF_REG_TRAITS(v512, v_int16x32, short, s16, v_uint16x32, v_int32x16,
-                  v_int64x8, v_int16x32, void);
-CV_DEF_REG_TRAITS(v512, v_uint32x16, unsigned, u32, v_uint32x16, v_uint64x8,
-                  void, v_int32x16, void);
-CV_DEF_REG_TRAITS(v512, v_int32x16, int, s32, v_uint32x16, v_int64x8, void,
-                  v_int32x16, void);
-CV_DEF_REG_TRAITS(v512, v_float32x16, float, f32, v_float32x16, v_float64x8,
-                  void, v_int32x16, v_int32x16);
-CV_DEF_REG_TRAITS(v512, v_uint64x8, uint64, u64, v_uint64x8, void, void,
-                  v_int64x8, void);
-CV_DEF_REG_TRAITS(v512, v_int64x8, int64, s64, v_uint64x8, void, void,
-                  v_int64x8, void);
-CV_DEF_REG_TRAITS(v512, v_float64x8, double, f64, v_float64x8, void, void,
-                  v_int64x8, v_int32x16);
-#endif
-#if CV_SIMD_SCALABLE
-CV_DEF_REG_TRAITS(v, v_uint8, uchar, u8, v_uint8, v_uint16, v_uint32, v_int8,
-                  void);
-CV_DEF_REG_TRAITS(v, v_int8, schar, s8, v_uint8, v_int16, v_int32, v_int8,
-                  void);
-CV_DEF_REG_TRAITS(v, v_uint16, ushort, u16, v_uint16, v_uint32, v_uint64,
-                  v_int16, void);
-CV_DEF_REG_TRAITS(v, v_int16, short, s16, v_uint16, v_int32, v_int64, v_int16,
-                  void);
-CV_DEF_REG_TRAITS(v, v_uint32, unsigned, u32, v_uint32, v_uint64, void, v_int32,
-                  void);
-CV_DEF_REG_TRAITS(v, v_int32, int, s32, v_uint32, v_int64, void, v_int32, void);
-CV_DEF_REG_TRAITS(v, v_float32, float, f32, v_float32, v_float64, void, v_int32,
-                  v_int32);
-CV_DEF_REG_TRAITS(v, v_uint64, uint64, u64, v_uint64, void, void, v_int64,
-                  void);
-CV_DEF_REG_TRAITS(v, v_int64, int64, s64, v_uint64, void, void, v_int64, void);
-CV_DEF_REG_TRAITS(v, v_float64, double, f64, v_float64, void, void, v_int64,
-                  v_int32);
-#endif
-//! @endcond
-
-#if CV_SIMD512 &&                                                              \
-    (!defined(CV__SIMD_FORCE_WIDTH) || CV__SIMD_FORCE_WIDTH == 512)
-#define CV__SIMD_NAMESPACE simd512
-namespace CV__SIMD_NAMESPACE {
-#define CV_SIMD 1
-#define CV_SIMD_64F CV_SIMD512_64F
-#define CV_SIMD_FP16 CV_SIMD512_FP16
-#define CV_SIMD_WIDTH 64
-//! @addtogroup core_hal_intrin
-//! @{
-//! @brief Maximum available vector register capacity 8-bit unsigned integer
-//! values
-typedef v_uint8x64 v_uint8;
-//! @brief Maximum available vector register capacity 8-bit signed integer
-//! values
-typedef v_int8x64 v_int8;
-//! @brief Maximum available vector register capacity 16-bit unsigned integer
-//! values
-typedef v_uint16x32 v_uint16;
-//! @brief Maximum available vector register capacity 16-bit signed integer
-//! values
-typedef v_int16x32 v_int16;
-//! @brief Maximum available vector register capacity 32-bit unsigned integer
-//! values
-typedef v_uint32x16 v_uint32;
-//! @brief Maximum available vector register capacity 32-bit signed integer
-//! values
-typedef v_int32x16 v_int32;
-//! @brief Maximum available vector register capacity 64-bit unsigned integer
-//! values
-typedef v_uint64x8 v_uint64;
-//! @brief Maximum available vector register capacity 64-bit signed integer
-//! values
-typedef v_int64x8 v_int64;
-//! @brief Maximum available vector register capacity 32-bit floating point
-//! values (single precision)
-typedef v_float32x16 v_float32;
-#if CV_SIMD512_64F
-//! @brief Maximum available vector register capacity 64-bit floating point
-//! values (double precision)
-typedef v_float64x8 v_float64;
-#endif
-//! @}
-
-#define VXPREFIX(func) v512##func
-} // namespace CV__SIMD_NAMESPACE
-using namespace CV__SIMD_NAMESPACE;
-#elif CV_SIMD256 &&                                                            \
-    (!defined(CV__SIMD_FORCE_WIDTH) || CV__SIMD_FORCE_WIDTH == 256)
-#define CV__SIMD_NAMESPACE simd256
-namespace CV__SIMD_NAMESPACE {
-#define CV_SIMD 1
-#define CV_SIMD_64F CV_SIMD256_64F
-#define CV_SIMD_FP16 CV_SIMD256_FP16
-#define CV_SIMD_WIDTH 32
-//! @addtogroup core_hal_intrin
-//! @{
-//! @brief Maximum available vector register capacity 8-bit unsigned integer
-//! values
-typedef v_uint8x32 v_uint8;
-//! @brief Maximum available vector register capacity 8-bit signed integer
-//! values
-typedef v_int8x32 v_int8;
-//! @brief Maximum available vector register capacity 16-bit unsigned integer
-//! values
-typedef v_uint16x16 v_uint16;
-//! @brief Maximum available vector register capacity 16-bit signed integer
-//! values
-typedef v_int16x16 v_int16;
-//! @brief Maximum available vector register capacity 32-bit unsigned integer
-//! values
-typedef v_uint32x8 v_uint32;
-//! @brief Maximum available vector register capacity 32-bit signed integer
-//! values
-typedef v_int32x8 v_int32;
-//! @brief Maximum available vector register capacity 64-bit unsigned integer
-//! values
-typedef v_uint64x4 v_uint64;
-//! @brief Maximum available vector register capacity 64-bit signed integer
-//! values
-typedef v_int64x4 v_int64;
-//! @brief Maximum available vector register capacity 32-bit floating point
-//! values (single precision)
-typedef v_float32x8 v_float32;
-#if CV_SIMD256_64F
-//! @brief Maximum available vector register capacity 64-bit floating point
-//! values (double precision)
-typedef v_float64x4 v_float64;
-#endif
-//! @}
-
-#define VXPREFIX(func) v256##func
-} // namespace CV__SIMD_NAMESPACE
-using namespace CV__SIMD_NAMESPACE;
-#elif (CV_SIMD128 || CV_SIMD128_CPP) &&                                        \
-    (!defined(CV__SIMD_FORCE_WIDTH) || CV__SIMD_FORCE_WIDTH == 128)
-#if defined CV_SIMD128_CPP
-#define CV__SIMD_NAMESPACE simd128_cpp
-#else
-#define CV__SIMD_NAMESPACE simd128
-#endif
-namespace CV__SIMD_NAMESPACE {
-#define CV_SIMD CV_SIMD128
-#define CV_SIMD_64F CV_SIMD128_64F
-#define CV_SIMD_WIDTH 16
-//! @addtogroup core_hal_intrin
-//! @{
-//! @brief Maximum available vector register capacity 8-bit unsigned integer
-//! values
-typedef v_uint8x16 v_uint8;
-//! @brief Maximum available vector register capacity 8-bit signed integer
-//! values
-typedef v_int8x16 v_int8;
-//! @brief Maximum available vector register capacity 16-bit unsigned integer
-//! values
-typedef v_uint16x8 v_uint16;
-//! @brief Maximum available vector register capacity 16-bit signed integer
-//! values
-typedef v_int16x8 v_int16;
-//! @brief Maximum available vector register capacity 32-bit unsigned integer
-//! values
-typedef v_uint32x4 v_uint32;
-//! @brief Maximum available vector register capacity 32-bit signed integer
-//! values
-typedef v_int32x4 v_int32;
-//! @brief Maximum available vector register capacity 64-bit unsigned integer
-//! values
-typedef v_uint64x2 v_uint64;
-//! @brief Maximum available vector register capacity 64-bit signed integer
-//! values
-typedef v_int64x2 v_int64;
-//! @brief Maximum available vector register capacity 32-bit floating point
-//! values (single precision)
-typedef v_float32x4 v_float32;
-#if CV_SIMD128_64F
-//! @brief Maximum available vector register capacity 64-bit floating point
-//! values (double precision)
-typedef v_float64x2 v_float64;
-#endif
-//! @}
-
-#define VXPREFIX(func) v##func
-} // namespace CV__SIMD_NAMESPACE
-using namespace CV__SIMD_NAMESPACE;
-
-#elif CV_SIMD_SCALABLE
-#define CV__SIMD_NAMESPACE simd
-namespace CV__SIMD_NAMESPACE {
-#define CV_SIMD 0
-#define CV_SIMD_WIDTH 128 /* 1024/8 */
-
-#define VXPREFIX(func) v##func
-} // namespace CV__SIMD_NAMESPACE
-using namespace CV__SIMD_NAMESPACE;
-
-#endif
-
-//! @cond IGNORED
-#ifndef CV_SIMD_64F
-#define CV_SIMD_64F 0
-#endif
-
-namespace CV__SIMD_NAMESPACE {
-//! @addtogroup core_hal_intrin
-//! @{
-//! @name Wide init with value
-//! @{
-//! @brief Create maximum available capacity vector with elements set to a
-//! specific value
-inline v_uint8 vx_setall_u8(uchar v) { return VXPREFIX(_setall_u8)(v); }
-inline v_int8 vx_setall_s8(schar v) { return VXPREFIX(_setall_s8)(v); }
-inline v_uint16 vx_setall_u16(ushort v) { return VXPREFIX(_setall_u16)(v); }
-inline v_int16 vx_setall_s16(short v) { return VXPREFIX(_setall_s16)(v); }
-inline v_int32 vx_setall_s32(int v) { return VXPREFIX(_setall_s32)(v); }
-inline v_uint32 vx_setall_u32(unsigned v) { return VXPREFIX(_setall_u32)(v); }
-inline v_float32 vx_setall_f32(float v) { return VXPREFIX(_setall_f32)(v); }
-inline v_int64 vx_setall_s64(int64 v) { return VXPREFIX(_setall_s64)(v); }
-inline v_uint64 vx_setall_u64(uint64 v) { return VXPREFIX(_setall_u64)(v); }
-#if CV_SIMD_64F || CV_SIMD_SCALABLE_64F
-inline v_float64 vx_setall_f64(double v) { return VXPREFIX(_setall_f64)(v); }
-#endif
-//! @}
-
-//! @name Wide init with zero
-//! @{
-//! @brief Create maximum available capacity vector with elements set to zero
-inline v_uint8 vx_setzero_u8() { return VXPREFIX(_setzero_u8)(); }
-inline v_int8 vx_setzero_s8() { return VXPREFIX(_setzero_s8)(); }
-inline v_uint16 vx_setzero_u16() { return VXPREFIX(_setzero_u16)(); }
-inline v_int16 vx_setzero_s16() { return VXPREFIX(_setzero_s16)(); }
-inline v_int32 vx_setzero_s32() { return VXPREFIX(_setzero_s32)(); }
-inline v_uint32 vx_setzero_u32() { return VXPREFIX(_setzero_u32)(); }
-inline v_float32 vx_setzero_f32() { return VXPREFIX(_setzero_f32)(); }
-inline v_int64 vx_setzero_s64() { return VXPREFIX(_setzero_s64)(); }
-inline v_uint64 vx_setzero_u64() { return VXPREFIX(_setzero_u64)(); }
-#if CV_SIMD_64F || CV_SIMD_SCALABLE_64F
-inline v_float64 vx_setzero_f64() { return VXPREFIX(_setzero_f64)(); }
-#endif
-//! @}
-
-//! @name Wide load from memory
-//! @{
-//! @brief Load maximum available capacity register contents from memory
-inline v_uint8 vx_load(const uchar *ptr) { return VXPREFIX(_load)(ptr); }
-inline v_int8 vx_load(const schar *ptr) { return VXPREFIX(_load)(ptr); }
-inline v_uint16 vx_load(const ushort *ptr) { return VXPREFIX(_load)(ptr); }
-inline v_int16 vx_load(const short *ptr) { return VXPREFIX(_load)(ptr); }
-inline v_int32 vx_load(const int *ptr) { return VXPREFIX(_load)(ptr); }
-inline v_uint32 vx_load(const unsigned *ptr) { return VXPREFIX(_load)(ptr); }
-inline v_float32 vx_load(const float *ptr) { return VXPREFIX(_load)(ptr); }
-inline v_int64 vx_load(const int64 *ptr) { return VXPREFIX(_load)(ptr); }
-inline v_uint64 vx_load(const uint64 *ptr) { return VXPREFIX(_load)(ptr); }
-#if CV_SIMD_64F || CV_SIMD_SCALABLE_64F
-inline v_float64 vx_load(const double *ptr) { return VXPREFIX(_load)(ptr); }
-#endif
-//! @}
-
-//! @name Wide load from memory(aligned)
-//! @{
-//! @brief Load maximum available capacity register contents from
-//! memory(aligned)
-inline v_uint8 vx_load_aligned(const uchar *ptr) {
-  return VXPREFIX(_load_aligned)(ptr);
-}
-inline v_int8 vx_load_aligned(const schar *ptr) {
-  return VXPREFIX(_load_aligned)(ptr);
-}
-inline v_uint16 vx_load_aligned(const ushort *ptr) {
-  return VXPREFIX(_load_aligned)(ptr);
-}
-inline v_int16 vx_load_aligned(const short *ptr) {
-  return VXPREFIX(_load_aligned)(ptr);
-}
-inline v_int32 vx_load_aligned(const int *ptr) {
-  return VXPREFIX(_load_aligned)(ptr);
-}
-inline v_uint32 vx_load_aligned(const unsigned *ptr) {
-  return VXPREFIX(_load_aligned)(ptr);
-}
-inline v_float32 vx_load_aligned(const float *ptr) {
-  return VXPREFIX(_load_aligned)(ptr);
-}
-inline v_int64 vx_load_aligned(const int64 *ptr) {
-  return VXPREFIX(_load_aligned)(ptr);
-}
-inline v_uint64 vx_load_aligned(const uint64 *ptr) {
-  return VXPREFIX(_load_aligned)(ptr);
-}
-#if CV_SIMD_64F || CV_SIMD_SCALABLE_64F
-inline v_float64 vx_load_aligned(const double *ptr) {
-  return VXPREFIX(_load_aligned)(ptr);
-}
-#endif
-//! @}
-
-//! @name Wide load lower half from memory
-//! @{
-//! @brief Load lower half of maximum available capacity register from memory
-inline v_uint8 vx_load_low(const uchar *ptr) {
-  return VXPREFIX(_load_low)(ptr);
-}
-inline v_int8 vx_load_low(const schar *ptr) { return VXPREFIX(_load_low)(ptr); }
-inline v_uint16 vx_load_low(const ushort *ptr) {
-  return VXPREFIX(_load_low)(ptr);
-}
-inline v_int16 vx_load_low(const short *ptr) {
-  return VXPREFIX(_load_low)(ptr);
-}
-inline v_int32 vx_load_low(const int *ptr) { return VXPREFIX(_load_low)(ptr); }
-inline v_uint32 vx_load_low(const unsigned *ptr) {
-  return VXPREFIX(_load_low)(ptr);
-}
-inline v_float32 vx_load_low(const float *ptr) {
-  return VXPREFIX(_load_low)(ptr);
-}
-inline v_int64 vx_load_low(const int64 *ptr) {
-  return VXPREFIX(_load_low)(ptr);
-}
-inline v_uint64 vx_load_low(const uint64 *ptr) {
-  return VXPREFIX(_load_low)(ptr);
-}
-#if CV_SIMD_64F || CV_SIMD_SCALABLE_64F
-inline v_float64 vx_load_low(const double *ptr) {
-  return VXPREFIX(_load_low)(ptr);
-}
-#endif
-//! @}
-
-//! @name Wide load halfs from memory
-//! @{
-//! @brief Load maximum available capacity register contents from two memory
-//! blocks
-inline v_uint8 vx_load_halves(const uchar *ptr0, const uchar *ptr1) {
-  return VXPREFIX(_load_halves)(ptr0, ptr1);
-}
-inline v_int8 vx_load_halves(const schar *ptr0, const schar *ptr1) {
-  return VXPREFIX(_load_halves)(ptr0, ptr1);
-}
-inline v_uint16 vx_load_halves(const ushort *ptr0, const ushort *ptr1) {
-  return VXPREFIX(_load_halves)(ptr0, ptr1);
-}
-inline v_int16 vx_load_halves(const short *ptr0, const short *ptr1) {
-  return VXPREFIX(_load_halves)(ptr0, ptr1);
-}
-inline v_int32 vx_load_halves(const int *ptr0, const int *ptr1) {
-  return VXPREFIX(_load_halves)(ptr0, ptr1);
-}
-inline v_uint32 vx_load_halves(const unsigned *ptr0, const unsigned *ptr1) {
-  return VXPREFIX(_load_halves)(ptr0, ptr1);
-}
-inline v_float32 vx_load_halves(const float *ptr0, const float *ptr1) {
-  return VXPREFIX(_load_halves)(ptr0, ptr1);
-}
-inline v_int64 vx_load_halves(const int64 *ptr0, const int64 *ptr1) {
-  return VXPREFIX(_load_halves)(ptr0, ptr1);
-}
-inline v_uint64 vx_load_halves(const uint64 *ptr0, const uint64 *ptr1) {
-  return VXPREFIX(_load_halves)(ptr0, ptr1);
-}
-#if CV_SIMD_64F || CV_SIMD_SCALABLE_64F
-inline v_float64 vx_load_halves(const double *ptr0, const double *ptr1) {
-  return VXPREFIX(_load_halves)(ptr0, ptr1);
-}
-#endif
-//! @}
-
-//! @name Wide LUT of elements
-//! @{
-//! @brief Load maximum available capacity register contents with array elements
-//! by provided indexes
-inline v_uint8 vx_lut(const uchar *ptr, const int *idx) {
-  return VXPREFIX(_lut)(ptr, idx);
-}
-inline v_int8 vx_lut(const schar *ptr, const int *idx) {
-  return VXPREFIX(_lut)(ptr, idx);
-}
-inline v_uint16 vx_lut(const ushort *ptr, const int *idx) {
-  return VXPREFIX(_lut)(ptr, idx);
-}
-inline v_int16 vx_lut(const short *ptr, const int *idx) {
-  return VXPREFIX(_lut)(ptr, idx);
-}
-inline v_int32 vx_lut(const int *ptr, const int *idx) {
-  return VXPREFIX(_lut)(ptr, idx);
-}
-inline v_uint32 vx_lut(const unsigned *ptr, const int *idx) {
-  return VXPREFIX(_lut)(ptr, idx);
-}
-inline v_float32 vx_lut(const float *ptr, const int *idx) {
-  return VXPREFIX(_lut)(ptr, idx);
-}
-inline v_int64 vx_lut(const int64 *ptr, const int *idx) {
-  return VXPREFIX(_lut)(ptr, idx);
-}
-inline v_uint64 vx_lut(const uint64 *ptr, const int *idx) {
-  return VXPREFIX(_lut)(ptr, idx);
-}
-#if CV_SIMD_64F || CV_SIMD_SCALABLE_64F
-inline v_float64 vx_lut(const double *ptr, const int *idx) {
-  return VXPREFIX(_lut)(ptr, idx);
-}
-#endif
-//! @}
-
-//! @name Wide LUT of element pairs
-//! @{
-//! @brief Load maximum available capacity register contents with array element
-//! pairs by provided indexes
-inline v_uint8 vx_lut_pairs(const uchar *ptr, const int *idx) {
-  return VXPREFIX(_lut_pairs)(ptr, idx);
-}
-inline v_int8 vx_lut_pairs(const schar *ptr, const int *idx) {
-  return VXPREFIX(_lut_pairs)(ptr, idx);
-}
-inline v_uint16 vx_lut_pairs(const ushort *ptr, const int *idx) {
-  return VXPREFIX(_lut_pairs)(ptr, idx);
-}
-inline v_int16 vx_lut_pairs(const short *ptr, const int *idx) {
-  return VXPREFIX(_lut_pairs)(ptr, idx);
-}
-inline v_int32 vx_lut_pairs(const int *ptr, const int *idx) {
-  return VXPREFIX(_lut_pairs)(ptr, idx);
-}
-inline v_uint32 vx_lut_pairs(const unsigned *ptr, const int *idx) {
-  return VXPREFIX(_lut_pairs)(ptr, idx);
-}
-inline v_float32 vx_lut_pairs(const float *ptr, const int *idx) {
-  return VXPREFIX(_lut_pairs)(ptr, idx);
-}
-inline v_int64 vx_lut_pairs(const int64 *ptr, const int *idx) {
-  return VXPREFIX(_lut_pairs)(ptr, idx);
-}
-inline v_uint64 vx_lut_pairs(const uint64 *ptr, const int *idx) {
-  return VXPREFIX(_lut_pairs)(ptr, idx);
-}
-#if CV_SIMD_64F || CV_SIMD_SCALABLE_64F
-inline v_float64 vx_lut_pairs(const double *ptr, const int *idx) {
-  return VXPREFIX(_lut_pairs)(ptr, idx);
-}
-#endif
-//! @}
-
-//! @name Wide LUT of element quads
-//! @{
-//! @brief Load maximum available capacity register contents with array element
-//! quads by provided indexes
-inline v_uint8 vx_lut_quads(const uchar *ptr, const int *idx) {
-  return VXPREFIX(_lut_quads)(ptr, idx);
-}
-inline v_int8 vx_lut_quads(const schar *ptr, const int *idx) {
-  return VXPREFIX(_lut_quads)(ptr, idx);
-}
-inline v_uint16 vx_lut_quads(const ushort *ptr, const int *idx) {
-  return VXPREFIX(_lut_quads)(ptr, idx);
-}
-inline v_int16 vx_lut_quads(const short *ptr, const int *idx) {
-  return VXPREFIX(_lut_quads)(ptr, idx);
-}
-inline v_int32 vx_lut_quads(const int *ptr, const int *idx) {
-  return VXPREFIX(_lut_quads)(ptr, idx);
-}
-inline v_uint32 vx_lut_quads(const unsigned *ptr, const int *idx) {
-  return VXPREFIX(_lut_quads)(ptr, idx);
-}
-inline v_float32 vx_lut_quads(const float *ptr, const int *idx) {
-  return VXPREFIX(_lut_quads)(ptr, idx);
-}
-//! @}
-
-//! @name Wide load with double expansion
-//! @{
-//! @brief Load maximum available capacity register contents from memory with
-//! double expand
-inline v_uint16 vx_load_expand(const uchar *ptr) {
-  return VXPREFIX(_load_expand)(ptr);
-}
-inline v_int16 vx_load_expand(const schar *ptr) {
-  return VXPREFIX(_load_expand)(ptr);
-}
-inline v_uint32 vx_load_expand(const ushort *ptr) {
-  return VXPREFIX(_load_expand)(ptr);
-}
-inline v_int32 vx_load_expand(const short *ptr) {
-  return VXPREFIX(_load_expand)(ptr);
-}
-inline v_int64 vx_load_expand(const int *ptr) {
-  return VXPREFIX(_load_expand)(ptr);
-}
-inline v_uint64 vx_load_expand(const unsigned *ptr) {
-  return VXPREFIX(_load_expand)(ptr);
-}
-inline v_float32 vx_load_expand(const hfloat *ptr) {
-  return VXPREFIX(_load_expand)(ptr);
-}
-//! @}
-
-//! @name Wide load with quad expansion
-//! @{
-//! @brief Load maximum available capacity register contents from memory with
-//! quad expand
-inline v_uint32 vx_load_expand_q(const uchar *ptr) {
-  return VXPREFIX(_load_expand_q)(ptr);
-}
-inline v_int32 vx_load_expand_q(const schar *ptr) {
-  return VXPREFIX(_load_expand_q)(ptr);
-}
-//! @}
-
-/** @brief SIMD processing state cleanup call */
-inline void vx_cleanup() { VXPREFIX(_cleanup)(); }
-
-#if !CV_SIMD_SCALABLE
-// Compatibility layer
-#if !(CV_NEON && !defined(CV_FORCE_SIMD128_CPP))
-template <typename T> struct VTraits {
-  static inline int vlanes() { return T::nlanes; }
-  enum { nlanes = T::nlanes, max_nlanes = T::nlanes };
-  using lane_type = typename T::lane_type;
-};
-
-//////////// get0 ////////////
-#define OPENCV_HAL_WRAP_GRT0(_Tpvec)                                           \
-  inline typename VTraits<_Tpvec>::lane_type v_get0(const _Tpvec &v) {         \
-    return v.get0();                                                           \
-  }
-
-OPENCV_HAL_WRAP_GRT0(v_uint8)
-OPENCV_HAL_WRAP_GRT0(v_int8)
-OPENCV_HAL_WRAP_GRT0(v_uint16)
-OPENCV_HAL_WRAP_GRT0(v_int16)
-OPENCV_HAL_WRAP_GRT0(v_uint32)
-OPENCV_HAL_WRAP_GRT0(v_int32)
-OPENCV_HAL_WRAP_GRT0(v_uint64)
-OPENCV_HAL_WRAP_GRT0(v_int64)
-OPENCV_HAL_WRAP_GRT0(v_float32)
-#if CV_SIMD_64F
-OPENCV_HAL_WRAP_GRT0(v_float64)
-#endif
-#if CV_SIMD_WIDTH != 16 /*128*/ && CV_SIMD128
-OPENCV_HAL_WRAP_GRT0(v_uint8x16)
-OPENCV_HAL_WRAP_GRT0(v_uint16x8)
-OPENCV_HAL_WRAP_GRT0(v_uint32x4)
-OPENCV_HAL_WRAP_GRT0(v_uint64x2)
-OPENCV_HAL_WRAP_GRT0(v_int8x16)
-OPENCV_HAL_WRAP_GRT0(v_int16x8)
-OPENCV_HAL_WRAP_GRT0(v_int32x4)
-OPENCV_HAL_WRAP_GRT0(v_int64x2)
-OPENCV_HAL_WRAP_GRT0(v_float32x4)
-#if CV_SIMD_64F
-OPENCV_HAL_WRAP_GRT0(v_float64x2)
-#endif
-#endif
-#if CV_SIMD_WIDTH != 32 /*256*/ && CV_SIMD256
-OPENCV_HAL_WRAP_GRT0(v_uint8x32)
-OPENCV_HAL_WRAP_GRT0(v_uint16x16)
-OPENCV_HAL_WRAP_GRT0(v_uint32x8)
-OPENCV_HAL_WRAP_GRT0(v_uint64x4)
-OPENCV_HAL_WRAP_GRT0(v_int8x32)
-OPENCV_HAL_WRAP_GRT0(v_int16x16)
-OPENCV_HAL_WRAP_GRT0(v_int32x8)
-OPENCV_HAL_WRAP_GRT0(v_int64x4)
-OPENCV_HAL_WRAP_GRT0(v_float32x8)
-#if CV_SIMD_64F
-OPENCV_HAL_WRAP_GRT0(v_float64x4)
-#endif
-#endif
-#endif
-
-#define OPENCV_HAL_WRAP_BIN_OP_ADDSUB(_Tpvec)                                  \
-  template <typename... Args>                                                  \
-  inline _Tpvec v_add(const _Tpvec &f1, const _Tpvec &f2, const _Tpvec &f3,    \
-                      const Args &...vf) {                                     \
-    return v_add(v_add(f1, f2), f3, vf...);                                    \
-  }
-
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_uint8)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_uint16)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_uint32)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_uint64)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_int8)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_int16)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_int32)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_int64)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_float32)
-#if CV_SIMD_64F
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_float64)
-#endif
-#if CV_SIMD_WIDTH != 16 /*128*/ && CV_SIMD128
-// when we use CV_SIMD128 with 256/512 bit SIMD (e.g. AVX2 or AVX512)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_uint8x16)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_uint16x8)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_uint32x4)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_uint64x2)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_int8x16)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_int16x8)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_int32x4)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_int64x2)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_float32x4)
-#if CV_SIMD_64F
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_float64x2)
-#endif
-#endif
-#if CV_SIMD_WIDTH != 32 /*256*/ && CV_SIMD256
-// when we use CV_SIMD256 with 512 bit SIMD (e.g. AVX512)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_uint8x32)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_uint16x16)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_uint32x8)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_uint64x4)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_int8x32)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_int16x16)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_int32x8)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_int64x4)
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_float32x8)
-#if CV_SIMD_64F
-OPENCV_HAL_WRAP_BIN_OP_ADDSUB(v_float64x4)
-#endif
-#endif
-
-#define OPENCV_HAL_WRAP_BIN_OP_MUL(_Tpvec)                                     \
-  template <typename... Args>                                                  \
-  inline _Tpvec v_mul(const _Tpvec &f1, const _Tpvec &f2, const _Tpvec &f3,    \
-                      const Args &...vf) {                                     \
-    return v_mul(v_mul(f1, f2), f3, vf...);                                    \
-  }
-OPENCV_HAL_WRAP_BIN_OP_MUL(v_uint8)
-OPENCV_HAL_WRAP_BIN_OP_MUL(v_int8)
-OPENCV_HAL_WRAP_BIN_OP_MUL(v_uint16)
-OPENCV_HAL_WRAP_BIN_OP_MUL(v_uint32)
-OPENCV_HAL_WRAP_BIN_OP_MUL(v_int16)
-OPENCV_HAL_WRAP_BIN_OP_MUL(v_int32)
-OPENCV_HAL_WRAP_BIN_OP_MUL(v_float32)
-#if CV_SIMD_64F
-OPENCV_HAL_WRAP_BIN_OP_MUL(v_float64)
-#endif
-#if CV_SIMD_WIDTH != 16 /*128*/ && CV_SIMD128
-OPENCV_HAL_WRAP_BIN_OP_MUL(v_uint8x16)
-OPENCV_HAL_WRAP_BIN_OP_MUL(v_uint16x8)
-OPENCV_HAL_WRAP_BIN_OP_MUL(v_uint32x4)
-OPENCV_HAL_WRAP_BIN_OP_MUL(v_int8x16)
-OPENCV_HAL_WRAP_BIN_OP_MUL(v_int16x8)
-OPENCV_HAL_WRAP_BIN_OP_MUL(v_int32x4)
-OPENCV_HAL_WRAP_BIN_OP_MUL(v_float32x4)
-#if CV_SIMD_64F
-OPENCV_HAL_WRAP_BIN_OP_MUL(v_float64x2)
-#endif
-#endif
-#if CV_SIMD_WIDTH != 32 /*256*/ && CV_SIMD256
-OPENCV_HAL_WRAP_BIN_OP_MUL(v_uint8x32)
-OPENCV_HAL_WRAP_BIN_OP_MUL(v_uint16x16)
-OPENCV_HAL_WRAP_BIN_OP_MUL(v_uint32x8)
-OPENCV_HAL_WRAP_BIN_OP_MUL(v_int8x32)
-OPENCV_HAL_WRAP_BIN_OP_MUL(v_int16x16)
-OPENCV_HAL_WRAP_BIN_OP_MUL(v_int32x8)
-OPENCV_HAL_WRAP_BIN_OP_MUL(v_float32x8)
-#if CV_SIMD_64F
-OPENCV_HAL_WRAP_BIN_OP_MUL(v_float64x4)
-#endif
-#endif
-
-#define OPENCV_HAL_WRAP_EXTRACT(_Tpvec)                                        \
-  inline typename VTraits<_Tpvec>::lane_type v_extract_highest(                \
-      const _Tpvec &v) {                                                       \
-    return v_extract_n<VTraits<_Tpvec>::nlanes - 1>(v);                        \
-  }
-
-OPENCV_HAL_WRAP_EXTRACT(v_uint8)
-OPENCV_HAL_WRAP_EXTRACT(v_int8)
-OPENCV_HAL_WRAP_EXTRACT(v_uint16)
-OPENCV_HAL_WRAP_EXTRACT(v_int16)
-OPENCV_HAL_WRAP_EXTRACT(v_uint32)
-OPENCV_HAL_WRAP_EXTRACT(v_int32)
-OPENCV_HAL_WRAP_EXTRACT(v_uint64)
-OPENCV_HAL_WRAP_EXTRACT(v_int64)
-OPENCV_HAL_WRAP_EXTRACT(v_float32)
-#if CV_SIMD_64F
-OPENCV_HAL_WRAP_EXTRACT(v_float64)
-#endif
-#if CV_SIMD_WIDTH != 16 /*128*/ && CV_SIMD128
-OPENCV_HAL_WRAP_EXTRACT(v_uint8x16)
-OPENCV_HAL_WRAP_EXTRACT(v_uint16x8)
-OPENCV_HAL_WRAP_EXTRACT(v_uint32x4)
-OPENCV_HAL_WRAP_EXTRACT(v_uint64x2)
-OPENCV_HAL_WRAP_EXTRACT(v_int8x16)
-OPENCV_HAL_WRAP_EXTRACT(v_int16x8)
-OPENCV_HAL_WRAP_EXTRACT(v_int32x4)
-OPENCV_HAL_WRAP_EXTRACT(v_int64x2)
-OPENCV_HAL_WRAP_EXTRACT(v_float32x4)
-#if CV_SIMD_64F
-OPENCV_HAL_WRAP_EXTRACT(v_float64x2)
-#endif
-#endif
-#if CV_SIMD_WIDTH != 32 /*256*/ && CV_SIMD256
-OPENCV_HAL_WRAP_EXTRACT(v_uint8x32)
-OPENCV_HAL_WRAP_EXTRACT(v_uint16x16)
-OPENCV_HAL_WRAP_EXTRACT(v_uint32x8)
-OPENCV_HAL_WRAP_EXTRACT(v_uint64x4)
-OPENCV_HAL_WRAP_EXTRACT(v_int8x32)
-OPENCV_HAL_WRAP_EXTRACT(v_int16x16)
-OPENCV_HAL_WRAP_EXTRACT(v_int32x8)
-OPENCV_HAL_WRAP_EXTRACT(v_int64x4)
-OPENCV_HAL_WRAP_EXTRACT(v_float32x8)
-#if CV_SIMD_64F
-OPENCV_HAL_WRAP_EXTRACT(v_float64x4)
-#endif
-#endif
-
-#define OPENCV_HAL_WRAP_BROADCAST(_Tpvec)                                      \
-  inline _Tpvec v_broadcast_highest(const _Tpvec &v) {                         \
-    return v_broadcast_element<VTraits<_Tpvec>::nlanes - 1>(v);                \
-  }
-
-OPENCV_HAL_WRAP_BROADCAST(v_uint32)
-OPENCV_HAL_WRAP_BROADCAST(v_int32)
-OPENCV_HAL_WRAP_BROADCAST(v_float32)
-#if CV_SIMD_WIDTH != 16 /*128*/ && CV_SIMD128
-OPENCV_HAL_WRAP_BROADCAST(v_uint32x4)
-OPENCV_HAL_WRAP_BROADCAST(v_int32x4)
-OPENCV_HAL_WRAP_BROADCAST(v_float32x4)
-#endif
-#if CV_SIMD_WIDTH != 32 /*256*/ && CV_SIMD256
-OPENCV_HAL_WRAP_BROADCAST(v_uint32x8)
-OPENCV_HAL_WRAP_BROADCAST(v_int32x8)
-OPENCV_HAL_WRAP_BROADCAST(v_float32x8)
-#endif
-
-#endif //! CV_SIMD_SCALABLE
-
-//! @cond IGNORED
-
-// backward compatibility
-template <typename _Tp, typename _Tvec>
-static inline void vx_store(_Tp *dst, const _Tvec &v) {
-  return v_store(dst, v);
-}
-// backward compatibility
-template <typename _Tp, typename _Tvec>
-static inline void vx_store_aligned(_Tp *dst, const _Tvec &v) {
-  return v_store_aligned(dst, v);
-}
-
-//! @endcond
-
-//! @}
-#undef VXPREFIX
-} // namespace CV__SIMD_NAMESPACE
-
-#ifndef CV_SIMD_FP16
-#define CV_SIMD_FP16                                                           \
-  0 //!< Defined to 1 on native support of operations with float16x8_t /
-    //!< float16x16_t (SIMD256) types
-#endif
-
-#ifndef CV_SIMD
-#define CV_SIMD 0
-#endif
-
-#include "simd_utils.impl.hpp"
-
-#ifndef CV_DOXYGEN
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_END
-#endif
-
-} // namespace cv
-
-//! @endcond
-
-#if defined(__GNUC__) && __GNUC__ == 12
-#pragma GCC diagnostic pop
-#endif
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_avx.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_avx.hpp
deleted file mode 100644
index 3ad2256ff1..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_avx.hpp
+++ /dev/null
@@ -1,3378 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html
-
-#ifndef OPENCV_HAL_INTRIN_AVX_HPP
-#define OPENCV_HAL_INTRIN_AVX_HPP
-
-#define CV_SIMD256 1
-#define CV_SIMD256_64F 1
-#define CV_SIMD256_FP16                                                        \
-  0 // no native operations with FP16 type. Only load/store from float32x8 are
-    // available (if CV_FP16 == 1)
-
-namespace cv {
-
-//! @cond IGNORED
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_BEGIN
-
-///////// Utils ////////////
-
-inline __m256i _v256_combine(const __m128i &lo, const __m128i &hi) {
-  return _mm256_inserti128_si256(_mm256_castsi128_si256(lo), hi, 1);
-}
-
-inline __m256 _v256_combine(const __m128 &lo, const __m128 &hi) {
-  return _mm256_insertf128_ps(_mm256_castps128_ps256(lo), hi, 1);
-}
-
-inline __m256d _v256_combine(const __m128d &lo, const __m128d &hi) {
-  return _mm256_insertf128_pd(_mm256_castpd128_pd256(lo), hi, 1);
-}
-
-inline int _v_cvtsi256_si32(const __m256i &a) {
-  return _mm_cvtsi128_si32(_mm256_castsi256_si128(a));
-}
-
-inline __m256i _v256_shuffle_odd_64(const __m256i &v) {
-  return _mm256_permute4x64_epi64(v, _MM_SHUFFLE(3, 1, 2, 0));
-}
-
-inline __m256d _v256_shuffle_odd_64(const __m256d &v) {
-  return _mm256_permute4x64_pd(v, _MM_SHUFFLE(3, 1, 2, 0));
-}
-
-template <int imm>
-inline __m256i _v256_permute2x128(const __m256i &a, const __m256i &b) {
-  return _mm256_permute2x128_si256(a, b, imm);
-}
-
-template <int imm>
-inline __m256 _v256_permute2x128(const __m256 &a, const __m256 &b) {
-  return _mm256_permute2f128_ps(a, b, imm);
-}
-
-template <int imm>
-inline __m256d _v256_permute2x128(const __m256d &a, const __m256d &b) {
-  return _mm256_permute2f128_pd(a, b, imm);
-}
-
-template <int imm, typename _Tpvec>
-inline _Tpvec v256_permute2x128(const _Tpvec &a, const _Tpvec &b) {
-  return _Tpvec(_v256_permute2x128<imm>(a.val, b.val));
-}
-
-template <int imm> inline __m256i _v256_permute4x64(const __m256i &a) {
-  return _mm256_permute4x64_epi64(a, imm);
-}
-
-template <int imm> inline __m256d _v256_permute4x64(const __m256d &a) {
-  return _mm256_permute4x64_pd(a, imm);
-}
-
-template <int imm, typename _Tpvec>
-inline _Tpvec v256_permute4x64(const _Tpvec &a) {
-  return _Tpvec(_v256_permute4x64<imm>(a.val));
-}
-
-inline __m128i _v256_extract_high(const __m256i &v) {
-  return _mm256_extracti128_si256(v, 1);
-}
-
-inline __m128 _v256_extract_high(const __m256 &v) {
-  return _mm256_extractf128_ps(v, 1);
-}
-
-inline __m128d _v256_extract_high(const __m256d &v) {
-  return _mm256_extractf128_pd(v, 1);
-}
-
-inline __m128i _v256_extract_low(const __m256i &v) {
-  return _mm256_castsi256_si128(v);
-}
-
-inline __m128 _v256_extract_low(const __m256 &v) {
-  return _mm256_castps256_ps128(v);
-}
-
-inline __m128d _v256_extract_low(const __m256d &v) {
-  return _mm256_castpd256_pd128(v);
-}
-
-inline __m256i _v256_packs_epu32(const __m256i &a, const __m256i &b) {
-  const __m256i m = _mm256_set1_epi32(65535);
-  __m256i am = _mm256_min_epu32(a, m);
-  __m256i bm = _mm256_min_epu32(b, m);
-  return _mm256_packus_epi32(am, bm);
-}
-
-template <int i> inline int _v256_extract_epi8(const __m256i &a) {
-#if defined(CV__SIMD_HAVE_mm256_extract_epi8) ||                               \
-    (CV_AVX2 && (!defined(_MSC_VER) || _MSC_VER >= 1910 /*MSVS 2017*/))
-  return _mm256_extract_epi8(a, i);
-#else
-  __m128i b = _mm256_extractf128_si256(a, ((i) >> 4));
-  return _mm_extract_epi8(b, i & 15); // SSE4.1
-#endif
-}
-
-template <int i> inline int _v256_extract_epi16(const __m256i &a) {
-#if defined(CV__SIMD_HAVE_mm256_extract_epi8) ||                               \
-    (CV_AVX2 && (!defined(_MSC_VER) || _MSC_VER >= 1910 /*MSVS 2017*/))
-  return _mm256_extract_epi16(a, i);
-#else
-  __m128i b = _mm256_extractf128_si256(a, ((i) >> 3));
-  return _mm_extract_epi16(b, i & 7); // SSE2
-#endif
-}
-
-template <int i> inline int _v256_extract_epi32(const __m256i &a) {
-#if defined(CV__SIMD_HAVE_mm256_extract_epi8) ||                               \
-    (CV_AVX2 && (!defined(_MSC_VER) || _MSC_VER >= 1910 /*MSVS 2017*/))
-  return _mm256_extract_epi32(a, i);
-#else
-  __m128i b = _mm256_extractf128_si256(a, ((i) >> 2));
-  return _mm_extract_epi32(b, i & 3); // SSE4.1
-#endif
-}
-
-template <int i> inline int64 _v256_extract_epi64(const __m256i &a) {
-#if defined(CV__SIMD_HAVE_mm256_extract_epi8) ||                               \
-    (CV_AVX2 && (!defined(_MSC_VER) || _MSC_VER >= 1910 /*MSVS 2017*/))
-  return _mm256_extract_epi64(a, i);
-#else
-  __m128i b = _mm256_extractf128_si256(a, ((i) >> 1));
-  return _mm_extract_epi64(b, i & 1); // SSE4.1
-#endif
-}
-
-///////// Types ////////////
-
-struct v_uint8x32 {
-  typedef uchar lane_type;
-  enum { nlanes = 32 };
-  __m256i val;
-
-  explicit v_uint8x32(__m256i v) : val(v) {}
-  v_uint8x32(uchar v0, uchar v1, uchar v2, uchar v3, uchar v4, uchar v5,
-             uchar v6, uchar v7, uchar v8, uchar v9, uchar v10, uchar v11,
-             uchar v12, uchar v13, uchar v14, uchar v15, uchar v16, uchar v17,
-             uchar v18, uchar v19, uchar v20, uchar v21, uchar v22, uchar v23,
-             uchar v24, uchar v25, uchar v26, uchar v27, uchar v28, uchar v29,
-             uchar v30, uchar v31) {
-    val = _mm256_setr_epi8(
-        (char)v0, (char)v1, (char)v2, (char)v3, (char)v4, (char)v5, (char)v6,
-        (char)v7, (char)v8, (char)v9, (char)v10, (char)v11, (char)v12,
-        (char)v13, (char)v14, (char)v15, (char)v16, (char)v17, (char)v18,
-        (char)v19, (char)v20, (char)v21, (char)v22, (char)v23, (char)v24,
-        (char)v25, (char)v26, (char)v27, (char)v28, (char)v29, (char)v30,
-        (char)v31);
-  }
-  /* coverity[uninit_ctor]: suppress warning */
-  v_uint8x32() {}
-
-  uchar get0() const { return (uchar)_v_cvtsi256_si32(val); }
-};
-
-struct v_int8x32 {
-  typedef schar lane_type;
-  enum { nlanes = 32 };
-  __m256i val;
-
-  explicit v_int8x32(__m256i v) : val(v) {}
-  v_int8x32(schar v0, schar v1, schar v2, schar v3, schar v4, schar v5,
-            schar v6, schar v7, schar v8, schar v9, schar v10, schar v11,
-            schar v12, schar v13, schar v14, schar v15, schar v16, schar v17,
-            schar v18, schar v19, schar v20, schar v21, schar v22, schar v23,
-            schar v24, schar v25, schar v26, schar v27, schar v28, schar v29,
-            schar v30, schar v31) {
-    val = _mm256_setr_epi8(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);
-  }
-  /* coverity[uninit_ctor]: suppress warning */
-  v_int8x32() {}
-
-  schar get0() const { return (schar)_v_cvtsi256_si32(val); }
-};
-
-struct v_uint16x16 {
-  typedef ushort lane_type;
-  enum { nlanes = 16 };
-  __m256i val;
-
-  explicit v_uint16x16(__m256i v) : val(v) {}
-  v_uint16x16(ushort v0, ushort v1, ushort v2, ushort v3, ushort v4, ushort v5,
-              ushort v6, ushort v7, ushort v8, ushort v9, ushort v10,
-              ushort v11, ushort v12, ushort v13, ushort v14, ushort v15) {
-    val = _mm256_setr_epi16((short)v0, (short)v1, (short)v2, (short)v3,
-                            (short)v4, (short)v5, (short)v6, (short)v7,
-                            (short)v8, (short)v9, (short)v10, (short)v11,
-                            (short)v12, (short)v13, (short)v14, (short)v15);
-  }
-  /* coverity[uninit_ctor]: suppress warning */
-  v_uint16x16() {}
-
-  ushort get0() const { return (ushort)_v_cvtsi256_si32(val); }
-};
-
-struct v_int16x16 {
-  typedef short lane_type;
-  enum { nlanes = 16 };
-  __m256i val;
-
-  explicit v_int16x16(__m256i v) : val(v) {}
-  v_int16x16(short v0, short v1, short v2, short v3, short v4, short v5,
-             short v6, short v7, short v8, short v9, short v10, short v11,
-             short v12, short v13, short v14, short v15) {
-    val = _mm256_setr_epi16(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
-                            v12, v13, v14, v15);
-  }
-  /* coverity[uninit_ctor]: suppress warning */
-  v_int16x16() {}
-
-  short get0() const { return (short)_v_cvtsi256_si32(val); }
-};
-
-struct v_uint32x8 {
-  typedef unsigned lane_type;
-  enum { nlanes = 8 };
-  __m256i val;
-
-  explicit v_uint32x8(__m256i v) : val(v) {}
-  v_uint32x8(unsigned v0, unsigned v1, unsigned v2, unsigned v3, unsigned v4,
-             unsigned v5, unsigned v6, unsigned v7) {
-    val = _mm256_setr_epi32((unsigned)v0, (unsigned)v1, (unsigned)v2,
-                            (unsigned)v3, (unsigned)v4, (unsigned)v5,
-                            (unsigned)v6, (unsigned)v7);
-  }
-  /* coverity[uninit_ctor]: suppress warning */
-  v_uint32x8() {}
-
-  unsigned get0() const { return (unsigned)_v_cvtsi256_si32(val); }
-};
-
-struct v_int32x8 {
-  typedef int lane_type;
-  enum { nlanes = 8 };
-  __m256i val;
-
-  explicit v_int32x8(__m256i v) : val(v) {}
-  v_int32x8(int v0, int v1, int v2, int v3, int v4, int v5, int v6, int v7) {
-    val = _mm256_setr_epi32(v0, v1, v2, v3, v4, v5, v6, v7);
-  }
-  /* coverity[uninit_ctor]: suppress warning */
-  v_int32x8() {}
-
-  int get0() const { return _v_cvtsi256_si32(val); }
-};
-
-struct v_float32x8 {
-  typedef float lane_type;
-  enum { nlanes = 8 };
-  __m256 val;
-
-  explicit v_float32x8(__m256 v) : val(v) {}
-  v_float32x8(float v0, float v1, float v2, float v3, float v4, float v5,
-              float v6, float v7) {
-    val = _mm256_setr_ps(v0, v1, v2, v3, v4, v5, v6, v7);
-  }
-  /* coverity[uninit_ctor]: suppress warning */
-  v_float32x8() {}
-
-  float get0() const { return _mm_cvtss_f32(_mm256_castps256_ps128(val)); }
-};
-
-struct v_uint64x4 {
-  typedef uint64 lane_type;
-  enum { nlanes = 4 };
-  __m256i val;
-
-  explicit v_uint64x4(__m256i v) : val(v) {}
-  v_uint64x4(uint64 v0, uint64 v1, uint64 v2, uint64 v3) {
-    val = _mm256_setr_epi64x((int64)v0, (int64)v1, (int64)v2, (int64)v3);
-  }
-  /* coverity[uninit_ctor]: suppress warning */
-  v_uint64x4() {}
-
-  uint64 get0() const {
-#if defined __x86_64__ || defined _M_X64
-    return (uint64)_mm_cvtsi128_si64(_mm256_castsi256_si128(val));
-#else
-    int a = _mm_cvtsi128_si32(_mm256_castsi256_si128(val));
-    int b =
-        _mm_cvtsi128_si32(_mm256_castsi256_si128(_mm256_srli_epi64(val, 32)));
-    return (unsigned)a | ((uint64)(unsigned)b << 32);
-#endif
-  }
-};
-
-struct v_int64x4 {
-  typedef int64 lane_type;
-  enum { nlanes = 4 };
-  __m256i val;
-
-  explicit v_int64x4(__m256i v) : val(v) {}
-  v_int64x4(int64 v0, int64 v1, int64 v2, int64 v3) {
-    val = _mm256_setr_epi64x(v0, v1, v2, v3);
-  }
-  /* coverity[uninit_ctor]: suppress warning */
-  v_int64x4() {}
-
-  int64 get0() const {
-#if defined __x86_64__ || defined _M_X64
-    return (int64)_mm_cvtsi128_si64(_mm256_castsi256_si128(val));
-#else
-    int a = _mm_cvtsi128_si32(_mm256_castsi256_si128(val));
-    int b =
-        _mm_cvtsi128_si32(_mm256_castsi256_si128(_mm256_srli_epi64(val, 32)));
-    return (int64)((unsigned)a | ((uint64)(unsigned)b << 32));
-#endif
-  }
-};
-
-struct v_float64x4 {
-  typedef double lane_type;
-  enum { nlanes = 4 };
-  __m256d val;
-
-  explicit v_float64x4(__m256d v) : val(v) {}
-  v_float64x4(double v0, double v1, double v2, double v3) {
-    val = _mm256_setr_pd(v0, v1, v2, v3);
-  }
-  /* coverity[uninit_ctor]: suppress warning */
-  v_float64x4() {}
-
-  double get0() const { return _mm_cvtsd_f64(_mm256_castpd256_pd128(val)); }
-};
-
-//////////////// Load and store operations ///////////////
-
-#define OPENCV_HAL_IMPL_AVX_LOADSTORE(_Tpvec, _Tp)                             \
-  inline _Tpvec v256_load(const _Tp *ptr) {                                    \
-    return _Tpvec(_mm256_loadu_si256((const __m256i *)ptr));                   \
-  }                                                                            \
-  inline _Tpvec v256_load_aligned(const _Tp *ptr) {                            \
-    return _Tpvec(_mm256_load_si256((const __m256i *)ptr));                    \
-  }                                                                            \
-  inline _Tpvec v256_load_low(const _Tp *ptr) {                                \
-    __m128i v128 = _mm_loadu_si128((const __m128i *)ptr);                      \
-    return _Tpvec(_mm256_castsi128_si256(v128));                               \
-  }                                                                            \
-  inline _Tpvec v256_load_halves(const _Tp *ptr0, const _Tp *ptr1) {           \
-    __m128i vlo = _mm_loadu_si128((const __m128i *)ptr0);                      \
-    __m128i vhi = _mm_loadu_si128((const __m128i *)ptr1);                      \
-    return _Tpvec(_v256_combine(vlo, vhi));                                    \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a) {                             \
-    _mm256_storeu_si256((__m256i *)ptr, a.val);                                \
-  }                                                                            \
-  inline void v_store_aligned(_Tp *ptr, const _Tpvec &a) {                     \
-    _mm256_store_si256((__m256i *)ptr, a.val);                                 \
-  }                                                                            \
-  inline void v_store_aligned_nocache(_Tp *ptr, const _Tpvec &a) {             \
-    _mm256_stream_si256((__m256i *)ptr, a.val);                                \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a, hal::StoreMode mode) {        \
-    if (mode == hal::STORE_UNALIGNED)                                          \
-      _mm256_storeu_si256((__m256i *)ptr, a.val);                              \
-    else if (mode == hal::STORE_ALIGNED_NOCACHE)                               \
-      _mm256_stream_si256((__m256i *)ptr, a.val);                              \
-    else                                                                       \
-      _mm256_store_si256((__m256i *)ptr, a.val);                               \
-  }                                                                            \
-  inline void v_store_low(_Tp *ptr, const _Tpvec &a) {                         \
-    _mm_storeu_si128((__m128i *)ptr, _v256_extract_low(a.val));                \
-  }                                                                            \
-  inline void v_store_high(_Tp *ptr, const _Tpvec &a) {                        \
-    _mm_storeu_si128((__m128i *)ptr, _v256_extract_high(a.val));               \
-  }
-
-OPENCV_HAL_IMPL_AVX_LOADSTORE(v_uint8x32, uchar)
-OPENCV_HAL_IMPL_AVX_LOADSTORE(v_int8x32, schar)
-OPENCV_HAL_IMPL_AVX_LOADSTORE(v_uint16x16, ushort)
-OPENCV_HAL_IMPL_AVX_LOADSTORE(v_int16x16, short)
-OPENCV_HAL_IMPL_AVX_LOADSTORE(v_uint32x8, unsigned)
-OPENCV_HAL_IMPL_AVX_LOADSTORE(v_int32x8, int)
-OPENCV_HAL_IMPL_AVX_LOADSTORE(v_uint64x4, uint64)
-OPENCV_HAL_IMPL_AVX_LOADSTORE(v_int64x4, int64)
-
-#define OPENCV_HAL_IMPL_AVX_LOADSTORE_FLT(_Tpvec, _Tp, suffix, halfreg)        \
-  inline _Tpvec v256_load(const _Tp *ptr) {                                    \
-    return _Tpvec(_mm256_loadu_##suffix(ptr));                                 \
-  }                                                                            \
-  inline _Tpvec v256_load_aligned(const _Tp *ptr) {                            \
-    return _Tpvec(_mm256_load_##suffix(ptr));                                  \
-  }                                                                            \
-  inline _Tpvec v256_load_low(const _Tp *ptr) {                                \
-    return _Tpvec(                                                             \
-        _mm256_cast##suffix##128_##suffix##256(_mm_loadu_##suffix(ptr)));      \
-  }                                                                            \
-  inline _Tpvec v256_load_halves(const _Tp *ptr0, const _Tp *ptr1) {           \
-    halfreg vlo = _mm_loadu_##suffix(ptr0);                                    \
-    halfreg vhi = _mm_loadu_##suffix(ptr1);                                    \
-    return _Tpvec(_v256_combine(vlo, vhi));                                    \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a) {                             \
-    _mm256_storeu_##suffix(ptr, a.val);                                        \
-  }                                                                            \
-  inline void v_store_aligned(_Tp *ptr, const _Tpvec &a) {                     \
-    _mm256_store_##suffix(ptr, a.val);                                         \
-  }                                                                            \
-  inline void v_store_aligned_nocache(_Tp *ptr, const _Tpvec &a) {             \
-    _mm256_stream_##suffix(ptr, a.val);                                        \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a, hal::StoreMode mode) {        \
-    if (mode == hal::STORE_UNALIGNED)                                          \
-      _mm256_storeu_##suffix(ptr, a.val);                                      \
-    else if (mode == hal::STORE_ALIGNED_NOCACHE)                               \
-      _mm256_stream_##suffix(ptr, a.val);                                      \
-    else                                                                       \
-      _mm256_store_##suffix(ptr, a.val);                                       \
-  }                                                                            \
-  inline void v_store_low(_Tp *ptr, const _Tpvec &a) {                         \
-    _mm_storeu_##suffix(ptr, _v256_extract_low(a.val));                        \
-  }                                                                            \
-  inline void v_store_high(_Tp *ptr, const _Tpvec &a) {                        \
-    _mm_storeu_##suffix(ptr, _v256_extract_high(a.val));                       \
-  }
-
-OPENCV_HAL_IMPL_AVX_LOADSTORE_FLT(v_float32x8, float, ps, __m128)
-OPENCV_HAL_IMPL_AVX_LOADSTORE_FLT(v_float64x4, double, pd, __m128d)
-
-#define OPENCV_HAL_IMPL_AVX_CAST(_Tpvec, _Tpvecf, suffix, cast)                \
-  inline _Tpvec v_reinterpret_as_##suffix(const _Tpvecf &a) {                  \
-    return _Tpvec(cast(a.val));                                                \
-  }
-
-#define OPENCV_HAL_IMPL_AVX_INIT(_Tpvec, _Tp, suffix, ssuffix, ctype_s)        \
-  inline _Tpvec v256_setzero_##suffix() {                                      \
-    return _Tpvec(_mm256_setzero_si256());                                     \
-  }                                                                            \
-  inline _Tpvec v256_setall_##suffix(_Tp v) {                                  \
-    return _Tpvec(_mm256_set1_##ssuffix((ctype_s)v));                          \
-  }                                                                            \
-  template <> inline _Tpvec v_setzero_() { return v256_setzero_##suffix(); }   \
-  template <> inline _Tpvec v_setall_(_Tp v) {                                 \
-    return v256_setall_##suffix(v);                                            \
-  }                                                                            \
-  OPENCV_HAL_IMPL_AVX_CAST(_Tpvec, v_uint8x32, suffix, OPENCV_HAL_NOP)         \
-  OPENCV_HAL_IMPL_AVX_CAST(_Tpvec, v_int8x32, suffix, OPENCV_HAL_NOP)          \
-  OPENCV_HAL_IMPL_AVX_CAST(_Tpvec, v_uint16x16, suffix, OPENCV_HAL_NOP)        \
-  OPENCV_HAL_IMPL_AVX_CAST(_Tpvec, v_int16x16, suffix, OPENCV_HAL_NOP)         \
-  OPENCV_HAL_IMPL_AVX_CAST(_Tpvec, v_uint32x8, suffix, OPENCV_HAL_NOP)         \
-  OPENCV_HAL_IMPL_AVX_CAST(_Tpvec, v_int32x8, suffix, OPENCV_HAL_NOP)          \
-  OPENCV_HAL_IMPL_AVX_CAST(_Tpvec, v_uint64x4, suffix, OPENCV_HAL_NOP)         \
-  OPENCV_HAL_IMPL_AVX_CAST(_Tpvec, v_int64x4, suffix, OPENCV_HAL_NOP)          \
-  OPENCV_HAL_IMPL_AVX_CAST(_Tpvec, v_float32x8, suffix, _mm256_castps_si256)   \
-  OPENCV_HAL_IMPL_AVX_CAST(_Tpvec, v_float64x4, suffix, _mm256_castpd_si256)
-
-OPENCV_HAL_IMPL_AVX_INIT(v_uint8x32, uchar, u8, epi8, char)
-OPENCV_HAL_IMPL_AVX_INIT(v_int8x32, schar, s8, epi8, char)
-OPENCV_HAL_IMPL_AVX_INIT(v_uint16x16, ushort, u16, epi16, short)
-OPENCV_HAL_IMPL_AVX_INIT(v_int16x16, short, s16, epi16, short)
-OPENCV_HAL_IMPL_AVX_INIT(v_uint32x8, unsigned, u32, epi32, int)
-OPENCV_HAL_IMPL_AVX_INIT(v_int32x8, int, s32, epi32, int)
-OPENCV_HAL_IMPL_AVX_INIT(v_uint64x4, uint64, u64, epi64x, int64)
-OPENCV_HAL_IMPL_AVX_INIT(v_int64x4, int64, s64, epi64x, int64)
-
-#define OPENCV_HAL_IMPL_AVX_INIT_FLT(_Tpvec, _Tp, suffix, zsuffix, cast)       \
-  inline _Tpvec v256_setzero_##suffix() {                                      \
-    return _Tpvec(_mm256_setzero_##zsuffix());                                 \
-  }                                                                            \
-  inline _Tpvec v256_setall_##suffix(_Tp v) {                                  \
-    return _Tpvec(_mm256_set1_##zsuffix(v));                                   \
-  }                                                                            \
-  template <> inline _Tpvec v_setzero_() { return v256_setzero_##suffix(); }   \
-  template <> inline _Tpvec v_setall_(_Tp v) {                                 \
-    return v256_setall_##suffix(v);                                            \
-  }                                                                            \
-  OPENCV_HAL_IMPL_AVX_CAST(_Tpvec, v_uint8x32, suffix, cast)                   \
-  OPENCV_HAL_IMPL_AVX_CAST(_Tpvec, v_int8x32, suffix, cast)                    \
-  OPENCV_HAL_IMPL_AVX_CAST(_Tpvec, v_uint16x16, suffix, cast)                  \
-  OPENCV_HAL_IMPL_AVX_CAST(_Tpvec, v_int16x16, suffix, cast)                   \
-  OPENCV_HAL_IMPL_AVX_CAST(_Tpvec, v_uint32x8, suffix, cast)                   \
-  OPENCV_HAL_IMPL_AVX_CAST(_Tpvec, v_int32x8, suffix, cast)                    \
-  OPENCV_HAL_IMPL_AVX_CAST(_Tpvec, v_uint64x4, suffix, cast)                   \
-  OPENCV_HAL_IMPL_AVX_CAST(_Tpvec, v_int64x4, suffix, cast)
-
-OPENCV_HAL_IMPL_AVX_INIT_FLT(v_float32x8, float, f32, ps, _mm256_castsi256_ps)
-OPENCV_HAL_IMPL_AVX_INIT_FLT(v_float64x4, double, f64, pd, _mm256_castsi256_pd)
-
-inline v_float32x8 v_reinterpret_as_f32(const v_float32x8 &a) { return a; }
-inline v_float32x8 v_reinterpret_as_f32(const v_float64x4 &a) {
-  return v_float32x8(_mm256_castpd_ps(a.val));
-}
-
-inline v_float64x4 v_reinterpret_as_f64(const v_float64x4 &a) { return a; }
-inline v_float64x4 v_reinterpret_as_f64(const v_float32x8 &a) {
-  return v_float64x4(_mm256_castps_pd(a.val));
-}
-
-/* Recombine */
-/*#define OPENCV_HAL_IMPL_AVX_COMBINE(_Tpvec, perm)                    \
-    inline _Tpvec v_combine_low(const _Tpvec& a, const _Tpvec& b)    \
-    { return _Tpvec(perm(a.val, b.val, 0x20)); }                     \
-    inline _Tpvec v_combine_high(const _Tpvec& a, const _Tpvec& b)   \
-    { return _Tpvec(perm(a.val, b.val, 0x31)); }                     \
-    inline void v_recombine(const _Tpvec& a, const _Tpvec& b,        \
-                             _Tpvec& c, _Tpvec& d)                   \
-    { c = v_combine_low(a, b); d = v_combine_high(a, b); }
-
-#define OPENCV_HAL_IMPL_AVX_UNPACKS(_Tpvec, suffix)                  \
-    OPENCV_HAL_IMPL_AVX_COMBINE(_Tpvec, _mm256_permute2x128_si256)   \
-    inline void v_zip(const _Tpvec& a0, const _Tpvec& a1,            \
-                             _Tpvec& b0, _Tpvec& b1)                 \
-    {                                                                \
-        __m256i v0 = _v256_shuffle_odd_64(a0.val);                   \
-        __m256i v1 = _v256_shuffle_odd_64(a1.val);                   \
-        b0.val = _mm256_unpacklo_##suffix(v0, v1);                   \
-        b1.val = _mm256_unpackhi_##suffix(v0, v1);                   \
-    }
-
-OPENCV_HAL_IMPL_AVX_UNPACKS(v_uint8x32,  epi8)
-OPENCV_HAL_IMPL_AVX_UNPACKS(v_int8x32,   epi8)
-OPENCV_HAL_IMPL_AVX_UNPACKS(v_uint16x16, epi16)
-OPENCV_HAL_IMPL_AVX_UNPACKS(v_int16x16,  epi16)
-OPENCV_HAL_IMPL_AVX_UNPACKS(v_uint32x8,  epi32)
-OPENCV_HAL_IMPL_AVX_UNPACKS(v_int32x8,   epi32)
-OPENCV_HAL_IMPL_AVX_UNPACKS(v_uint64x4,  epi64)
-OPENCV_HAL_IMPL_AVX_UNPACKS(v_int64x4,   epi64)
-OPENCV_HAL_IMPL_AVX_COMBINE(v_float32x8, _mm256_permute2f128_ps)
-OPENCV_HAL_IMPL_AVX_COMBINE(v_float64x4, _mm256_permute2f128_pd)
-
-inline void v_zip(const v_float32x8& a0, const v_float32x8& a1, v_float32x8& b0,
-v_float32x8& b1)
-{
-    __m256 v0 = _mm256_unpacklo_ps(a0.val, a1.val);
-    __m256 v1 = _mm256_unpackhi_ps(a0.val, a1.val);
-    v_recombine(v_float32x8(v0), v_float32x8(v1), b0, b1);
-}
-
-inline void v_zip(const v_float64x4& a0, const v_float64x4& a1, v_float64x4& b0,
-v_float64x4& b1)
-{
-    __m256d v0 = _v_shuffle_odd_64(a0.val);
-    __m256d v1 = _v_shuffle_odd_64(a1.val);
-    b0.val = _mm256_unpacklo_pd(v0, v1);
-    b1.val = _mm256_unpackhi_pd(v0, v1);
-}*/
-
-//////////////// Variant Value reordering ///////////////
-
-// unpacks
-#define OPENCV_HAL_IMPL_AVX_UNPACK(_Tpvec, suffix)                             \
-  inline _Tpvec v256_unpacklo(const _Tpvec &a, const _Tpvec &b) {              \
-    return _Tpvec(_mm256_unpacklo_##suffix(a.val, b.val));                     \
-  }                                                                            \
-  inline _Tpvec v256_unpackhi(const _Tpvec &a, const _Tpvec &b) {              \
-    return _Tpvec(_mm256_unpackhi_##suffix(a.val, b.val));                     \
-  }
-
-OPENCV_HAL_IMPL_AVX_UNPACK(v_uint8x32, epi8)
-OPENCV_HAL_IMPL_AVX_UNPACK(v_int8x32, epi8)
-OPENCV_HAL_IMPL_AVX_UNPACK(v_uint16x16, epi16)
-OPENCV_HAL_IMPL_AVX_UNPACK(v_int16x16, epi16)
-OPENCV_HAL_IMPL_AVX_UNPACK(v_uint32x8, epi32)
-OPENCV_HAL_IMPL_AVX_UNPACK(v_int32x8, epi32)
-OPENCV_HAL_IMPL_AVX_UNPACK(v_uint64x4, epi64)
-OPENCV_HAL_IMPL_AVX_UNPACK(v_int64x4, epi64)
-OPENCV_HAL_IMPL_AVX_UNPACK(v_float32x8, ps)
-OPENCV_HAL_IMPL_AVX_UNPACK(v_float64x4, pd)
-
-// blend
-#define OPENCV_HAL_IMPL_AVX_BLEND(_Tpvec, suffix)                              \
-  template <int m>                                                             \
-  inline _Tpvec v256_blend(const _Tpvec &a, const _Tpvec &b) {                 \
-    return _Tpvec(_mm256_blend_##suffix(a.val, b.val, m));                     \
-  }
-
-OPENCV_HAL_IMPL_AVX_BLEND(v_uint16x16, epi16)
-OPENCV_HAL_IMPL_AVX_BLEND(v_int16x16, epi16)
-OPENCV_HAL_IMPL_AVX_BLEND(v_uint32x8, epi32)
-OPENCV_HAL_IMPL_AVX_BLEND(v_int32x8, epi32)
-OPENCV_HAL_IMPL_AVX_BLEND(v_float32x8, ps)
-OPENCV_HAL_IMPL_AVX_BLEND(v_float64x4, pd)
-
-template <int m>
-inline v_uint64x4 v256_blend(const v_uint64x4 &a, const v_uint64x4 &b) {
-  enum { M0 = m };
-  enum { M1 = (M0 | (M0 << 2)) & 0x33 };
-  enum { M2 = (M1 | (M1 << 1)) & 0x55 };
-  enum { MM = M2 | (M2 << 1) };
-  return v_uint64x4(_mm256_blend_epi32(a.val, b.val, MM));
-}
-template <int m>
-inline v_int64x4 v256_blend(const v_int64x4 &a, const v_int64x4 &b) {
-  return v_int64x4(v256_blend<m>(v_uint64x4(a.val), v_uint64x4(b.val)).val);
-}
-
-// shuffle
-// todo: emulate 64bit
-#define OPENCV_HAL_IMPL_AVX_SHUFFLE(_Tpvec, intrin)                            \
-  template <int m> inline _Tpvec v256_shuffle(const _Tpvec &a) {               \
-    return _Tpvec(_mm256_##intrin(a.val, m));                                  \
-  }
-
-OPENCV_HAL_IMPL_AVX_SHUFFLE(v_uint32x8, shuffle_epi32)
-OPENCV_HAL_IMPL_AVX_SHUFFLE(v_int32x8, shuffle_epi32)
-OPENCV_HAL_IMPL_AVX_SHUFFLE(v_float32x8, permute_ps)
-OPENCV_HAL_IMPL_AVX_SHUFFLE(v_float64x4, permute_pd)
-
-template <typename _Tpvec>
-inline void v256_zip(const _Tpvec &a, const _Tpvec &b, _Tpvec &ab0,
-                     _Tpvec &ab1) {
-  ab0 = v256_unpacklo(a, b);
-  ab1 = v256_unpackhi(a, b);
-}
-
-template <typename _Tpvec>
-inline _Tpvec v256_combine_diagonal(const _Tpvec &a, const _Tpvec &b) {
-  return _Tpvec(_mm256_blend_epi32(a.val, b.val, 0xf0));
-}
-
-inline v_float32x8 v256_combine_diagonal(const v_float32x8 &a,
-                                         const v_float32x8 &b) {
-  return v256_blend<0xf0>(a, b);
-}
-
-inline v_float64x4 v256_combine_diagonal(const v_float64x4 &a,
-                                         const v_float64x4 &b) {
-  return v256_blend<0xc>(a, b);
-}
-
-template <typename _Tpvec>
-inline _Tpvec v256_alignr_128(const _Tpvec &a, const _Tpvec &b) {
-  return v256_permute2x128<0x21>(a, b);
-}
-
-template <typename _Tpvec>
-inline _Tpvec v256_alignr_64(const _Tpvec &a, const _Tpvec &b) {
-  return _Tpvec(_mm256_alignr_epi8(a.val, b.val, 8));
-}
-inline v_float64x4 v256_alignr_64(const v_float64x4 &a, const v_float64x4 &b) {
-  return v_float64x4(_mm256_shuffle_pd(b.val, a.val, _MM_SHUFFLE(0, 0, 1, 1)));
-}
-// todo: emulate float32
-
-template <typename _Tpvec> inline _Tpvec v256_swap_halves(const _Tpvec &a) {
-  return v256_permute2x128<1>(a, a);
-}
-
-template <typename _Tpvec> inline _Tpvec v256_reverse_64(const _Tpvec &a) {
-  return v256_permute4x64<_MM_SHUFFLE(0, 1, 2, 3)>(a);
-}
-
-// ZIP
-#define OPENCV_HAL_IMPL_AVX_ZIP(_Tpvec)                                        \
-  inline _Tpvec v_combine_low(const _Tpvec &a, const _Tpvec &b) {              \
-    return v256_permute2x128<0x20>(a, b);                                      \
-  }                                                                            \
-  inline _Tpvec v_combine_high(const _Tpvec &a, const _Tpvec &b) {             \
-    return v256_permute2x128<0x31>(a, b);                                      \
-  }                                                                            \
-  inline void v_recombine(const _Tpvec &a, const _Tpvec &b, _Tpvec &c,         \
-                          _Tpvec &d) {                                         \
-    _Tpvec a1b0 = v256_alignr_128(a, b);                                       \
-    c = v256_combine_diagonal(a, a1b0);                                        \
-    d = v256_combine_diagonal(a1b0, b);                                        \
-  }                                                                            \
-  inline void v_zip(const _Tpvec &a, const _Tpvec &b, _Tpvec &ab0,             \
-                    _Tpvec &ab1) {                                             \
-    _Tpvec ab0ab2, ab1ab3;                                                     \
-    v256_zip(a, b, ab0ab2, ab1ab3);                                            \
-    v_recombine(ab0ab2, ab1ab3, ab0, ab1);                                     \
-  }
-
-OPENCV_HAL_IMPL_AVX_ZIP(v_uint8x32)
-OPENCV_HAL_IMPL_AVX_ZIP(v_int8x32)
-OPENCV_HAL_IMPL_AVX_ZIP(v_uint16x16)
-OPENCV_HAL_IMPL_AVX_ZIP(v_int16x16)
-OPENCV_HAL_IMPL_AVX_ZIP(v_uint32x8)
-OPENCV_HAL_IMPL_AVX_ZIP(v_int32x8)
-OPENCV_HAL_IMPL_AVX_ZIP(v_uint64x4)
-OPENCV_HAL_IMPL_AVX_ZIP(v_int64x4)
-OPENCV_HAL_IMPL_AVX_ZIP(v_float32x8)
-OPENCV_HAL_IMPL_AVX_ZIP(v_float64x4)
-
-////////// Arithmetic, bitwise and comparison operations /////////
-
-/* Element-wise binary and unary operations */
-
-/** Arithmetics **/
-#define OPENCV_HAL_IMPL_AVX_BIN_OP(bin_op, _Tpvec, intrin)                     \
-  inline _Tpvec bin_op(const _Tpvec &a, const _Tpvec &b) {                     \
-    return _Tpvec(intrin(a.val, b.val));                                       \
-  }
-
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_add, v_uint8x32, _mm256_adds_epu8)
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_sub, v_uint8x32, _mm256_subs_epu8)
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_add, v_int8x32, _mm256_adds_epi8)
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_sub, v_int8x32, _mm256_subs_epi8)
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_add, v_uint16x16, _mm256_adds_epu16)
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_sub, v_uint16x16, _mm256_subs_epu16)
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_add, v_int16x16, _mm256_adds_epi16)
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_sub, v_int16x16, _mm256_subs_epi16)
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_add, v_uint32x8, _mm256_add_epi32)
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_sub, v_uint32x8, _mm256_sub_epi32)
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_mul, v_uint32x8, _mm256_mullo_epi32)
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_add, v_int32x8, _mm256_add_epi32)
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_sub, v_int32x8, _mm256_sub_epi32)
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_mul, v_int32x8, _mm256_mullo_epi32)
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_add, v_uint64x4, _mm256_add_epi64)
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_sub, v_uint64x4, _mm256_sub_epi64)
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_add, v_int64x4, _mm256_add_epi64)
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_sub, v_int64x4, _mm256_sub_epi64)
-
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_add, v_float32x8, _mm256_add_ps)
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_sub, v_float32x8, _mm256_sub_ps)
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_mul, v_float32x8, _mm256_mul_ps)
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_div, v_float32x8, _mm256_div_ps)
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_add, v_float64x4, _mm256_add_pd)
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_sub, v_float64x4, _mm256_sub_pd)
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_mul, v_float64x4, _mm256_mul_pd)
-OPENCV_HAL_IMPL_AVX_BIN_OP(v_div, v_float64x4, _mm256_div_pd)
-
-// saturating multiply 8-bit, 16-bit
-inline v_uint8x32 v_mul(const v_uint8x32 &a, const v_uint8x32 &b) {
-  v_uint16x16 c, d;
-  v_mul_expand(a, b, c, d);
-  return v_pack(c, d);
-}
-inline v_int8x32 v_mul(const v_int8x32 &a, const v_int8x32 &b) {
-  v_int16x16 c, d;
-  v_mul_expand(a, b, c, d);
-  return v_pack(c, d);
-}
-inline v_uint16x16 v_mul(const v_uint16x16 &a, const v_uint16x16 &b) {
-  __m256i pl = _mm256_mullo_epi16(a.val, b.val);
-  __m256i ph = _mm256_mulhi_epu16(a.val, b.val);
-  __m256i p0 = _mm256_unpacklo_epi16(pl, ph);
-  __m256i p1 = _mm256_unpackhi_epi16(pl, ph);
-  return v_uint16x16(_v256_packs_epu32(p0, p1));
-}
-inline v_int16x16 v_mul(const v_int16x16 &a, const v_int16x16 &b) {
-  __m256i pl = _mm256_mullo_epi16(a.val, b.val);
-  __m256i ph = _mm256_mulhi_epi16(a.val, b.val);
-  __m256i p0 = _mm256_unpacklo_epi16(pl, ph);
-  __m256i p1 = _mm256_unpackhi_epi16(pl, ph);
-  return v_int16x16(_mm256_packs_epi32(p0, p1));
-}
-
-/** Non-saturating arithmetics **/
-#define OPENCV_HAL_IMPL_AVX_BIN_FUNC(func, _Tpvec, intrin)                     \
-  inline _Tpvec func(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(intrin(a.val, b.val));                                       \
-  }
-
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_add_wrap, v_uint8x32, _mm256_add_epi8)
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_add_wrap, v_int8x32, _mm256_add_epi8)
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_add_wrap, v_uint16x16, _mm256_add_epi16)
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_add_wrap, v_int16x16, _mm256_add_epi16)
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_sub_wrap, v_uint8x32, _mm256_sub_epi8)
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_sub_wrap, v_int8x32, _mm256_sub_epi8)
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_sub_wrap, v_uint16x16, _mm256_sub_epi16)
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_sub_wrap, v_int16x16, _mm256_sub_epi16)
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_mul_wrap, v_uint16x16, _mm256_mullo_epi16)
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_mul_wrap, v_int16x16, _mm256_mullo_epi16)
-
-inline v_uint8x32 v_mul_wrap(const v_uint8x32 &a, const v_uint8x32 &b) {
-  __m256i ad = _mm256_srai_epi16(a.val, 8);
-  __m256i bd = _mm256_srai_epi16(b.val, 8);
-  __m256i p0 = _mm256_mullo_epi16(a.val, b.val);                 // even
-  __m256i p1 = _mm256_slli_epi16(_mm256_mullo_epi16(ad, bd), 8); // odd
-
-  const __m256i b01 = _mm256_set1_epi32(0xFF00FF00);
-  return v_uint8x32(_mm256_blendv_epi8(p0, p1, b01));
-}
-inline v_int8x32 v_mul_wrap(const v_int8x32 &a, const v_int8x32 &b) {
-  return v_reinterpret_as_s8(
-      v_mul_wrap(v_reinterpret_as_u8(a), v_reinterpret_as_u8(b)));
-}
-
-//  Multiply and expand
-inline void v_mul_expand(const v_uint8x32 &a, const v_uint8x32 &b,
-                         v_uint16x16 &c, v_uint16x16 &d) {
-  v_uint16x16 a0, a1, b0, b1;
-  v_expand(a, a0, a1);
-  v_expand(b, b0, b1);
-  c = v_mul_wrap(a0, b0);
-  d = v_mul_wrap(a1, b1);
-}
-
-inline void v_mul_expand(const v_int8x32 &a, const v_int8x32 &b, v_int16x16 &c,
-                         v_int16x16 &d) {
-  v_int16x16 a0, a1, b0, b1;
-  v_expand(a, a0, a1);
-  v_expand(b, b0, b1);
-  c = v_mul_wrap(a0, b0);
-  d = v_mul_wrap(a1, b1);
-}
-
-inline void v_mul_expand(const v_int16x16 &a, const v_int16x16 &b, v_int32x8 &c,
-                         v_int32x8 &d) {
-  v_int16x16 vhi = v_int16x16(_mm256_mulhi_epi16(a.val, b.val));
-
-  v_int16x16 v0, v1;
-  v_zip(v_mul_wrap(a, b), vhi, v0, v1);
-
-  c = v_reinterpret_as_s32(v0);
-  d = v_reinterpret_as_s32(v1);
-}
-
-inline void v_mul_expand(const v_uint16x16 &a, const v_uint16x16 &b,
-                         v_uint32x8 &c, v_uint32x8 &d) {
-  v_uint16x16 vhi = v_uint16x16(_mm256_mulhi_epu16(a.val, b.val));
-
-  v_uint16x16 v0, v1;
-  v_zip(v_mul_wrap(a, b), vhi, v0, v1);
-
-  c = v_reinterpret_as_u32(v0);
-  d = v_reinterpret_as_u32(v1);
-}
-
-inline void v_mul_expand(const v_uint32x8 &a, const v_uint32x8 &b,
-                         v_uint64x4 &c, v_uint64x4 &d) {
-  __m256i v0 = _mm256_mul_epu32(a.val, b.val);
-  __m256i v1 = _mm256_mul_epu32(_mm256_srli_epi64(a.val, 32),
-                                _mm256_srli_epi64(b.val, 32));
-  v_zip(v_uint64x4(v0), v_uint64x4(v1), c, d);
-}
-
-inline v_int16x16 v_mul_hi(const v_int16x16 &a, const v_int16x16 &b) {
-  return v_int16x16(_mm256_mulhi_epi16(a.val, b.val));
-}
-inline v_uint16x16 v_mul_hi(const v_uint16x16 &a, const v_uint16x16 &b) {
-  return v_uint16x16(_mm256_mulhi_epu16(a.val, b.val));
-}
-
-/** Bitwise shifts **/
-#define OPENCV_HAL_IMPL_AVX_SHIFT_OP(_Tpuvec, _Tpsvec, suffix, srai)           \
-  inline _Tpuvec v_shl(const _Tpuvec &a, int imm) {                            \
-    return _Tpuvec(_mm256_slli_##suffix(a.val, imm));                          \
-  }                                                                            \
-  inline _Tpsvec v_shl(const _Tpsvec &a, int imm) {                            \
-    return _Tpsvec(_mm256_slli_##suffix(a.val, imm));                          \
-  }                                                                            \
-  inline _Tpuvec v_shr(const _Tpuvec &a, int imm) {                            \
-    return _Tpuvec(_mm256_srli_##suffix(a.val, imm));                          \
-  }                                                                            \
-  inline _Tpsvec v_shr(const _Tpsvec &a, int imm) {                            \
-    return _Tpsvec(srai(a.val, imm));                                          \
-  }                                                                            \
-  template <int imm> inline _Tpuvec v_shl(const _Tpuvec &a) {                  \
-    return _Tpuvec(_mm256_slli_##suffix(a.val, imm));                          \
-  }                                                                            \
-  template <int imm> inline _Tpsvec v_shl(const _Tpsvec &a) {                  \
-    return _Tpsvec(_mm256_slli_##suffix(a.val, imm));                          \
-  }                                                                            \
-  template <int imm> inline _Tpuvec v_shr(const _Tpuvec &a) {                  \
-    return _Tpuvec(_mm256_srli_##suffix(a.val, imm));                          \
-  }                                                                            \
-  template <int imm> inline _Tpsvec v_shr(const _Tpsvec &a) {                  \
-    return _Tpsvec(srai(a.val, imm));                                          \
-  }
-
-OPENCV_HAL_IMPL_AVX_SHIFT_OP(v_uint16x16, v_int16x16, epi16, _mm256_srai_epi16)
-OPENCV_HAL_IMPL_AVX_SHIFT_OP(v_uint32x8, v_int32x8, epi32, _mm256_srai_epi32)
-
-inline __m256i _mm256_srai_epi64xx(const __m256i a, int imm) {
-  __m256i d = _mm256_set1_epi64x((int64)1 << 63);
-  __m256i r = _mm256_srli_epi64(_mm256_add_epi64(a, d), imm);
-  return _mm256_sub_epi64(r, _mm256_srli_epi64(d, imm));
-}
-OPENCV_HAL_IMPL_AVX_SHIFT_OP(v_uint64x4, v_int64x4, epi64, _mm256_srai_epi64xx)
-
-/** Bitwise logic **/
-#define OPENCV_HAL_IMPL_AVX_LOGIC_OP(_Tpvec, suffix, not_const)                \
-  OPENCV_HAL_IMPL_AVX_BIN_OP(v_and, _Tpvec, _mm256_and_##suffix)               \
-  OPENCV_HAL_IMPL_AVX_BIN_OP(v_or, _Tpvec, _mm256_or_##suffix)                 \
-  OPENCV_HAL_IMPL_AVX_BIN_OP(v_xor, _Tpvec, _mm256_xor_##suffix)               \
-  inline _Tpvec v_not(const _Tpvec &a) {                                       \
-    return _Tpvec(_mm256_xor_##suffix(a.val, not_const));                      \
-  }
-
-OPENCV_HAL_IMPL_AVX_LOGIC_OP(v_uint8x32, si256, _mm256_set1_epi32(-1))
-OPENCV_HAL_IMPL_AVX_LOGIC_OP(v_int8x32, si256, _mm256_set1_epi32(-1))
-OPENCV_HAL_IMPL_AVX_LOGIC_OP(v_uint16x16, si256, _mm256_set1_epi32(-1))
-OPENCV_HAL_IMPL_AVX_LOGIC_OP(v_int16x16, si256, _mm256_set1_epi32(-1))
-OPENCV_HAL_IMPL_AVX_LOGIC_OP(v_uint32x8, si256, _mm256_set1_epi32(-1))
-OPENCV_HAL_IMPL_AVX_LOGIC_OP(v_int32x8, si256, _mm256_set1_epi32(-1))
-OPENCV_HAL_IMPL_AVX_LOGIC_OP(v_uint64x4, si256, _mm256_set1_epi64x(-1))
-OPENCV_HAL_IMPL_AVX_LOGIC_OP(v_int64x4, si256, _mm256_set1_epi64x(-1))
-OPENCV_HAL_IMPL_AVX_LOGIC_OP(v_float32x8, ps,
-                             _mm256_castsi256_ps(_mm256_set1_epi32(-1)))
-OPENCV_HAL_IMPL_AVX_LOGIC_OP(v_float64x4, pd,
-                             _mm256_castsi256_pd(_mm256_set1_epi32(-1)))
-
-/** Select **/
-#define OPENCV_HAL_IMPL_AVX_SELECT(_Tpvec, suffix)                             \
-  inline _Tpvec v_select(const _Tpvec &mask, const _Tpvec &a,                  \
-                         const _Tpvec &b) {                                    \
-    return _Tpvec(_mm256_blendv_##suffix(b.val, a.val, mask.val));             \
-  }
-
-OPENCV_HAL_IMPL_AVX_SELECT(v_uint8x32, epi8)
-OPENCV_HAL_IMPL_AVX_SELECT(v_int8x32, epi8)
-OPENCV_HAL_IMPL_AVX_SELECT(v_uint16x16, epi8)
-OPENCV_HAL_IMPL_AVX_SELECT(v_int16x16, epi8)
-OPENCV_HAL_IMPL_AVX_SELECT(v_uint32x8, epi8)
-OPENCV_HAL_IMPL_AVX_SELECT(v_int32x8, epi8)
-OPENCV_HAL_IMPL_AVX_SELECT(v_float32x8, ps)
-OPENCV_HAL_IMPL_AVX_SELECT(v_float64x4, pd)
-
-/** Comparison **/
-#define OPENCV_HAL_IMPL_AVX_CMP_OP_OV(_Tpvec)                                  \
-  inline _Tpvec v_ne(const _Tpvec &a, const _Tpvec &b) {                       \
-    return v_not(v_eq(a, b));                                                  \
-  }                                                                            \
-  inline _Tpvec v_lt(const _Tpvec &a, const _Tpvec &b) { return v_gt(b, a); }  \
-  inline _Tpvec v_ge(const _Tpvec &a, const _Tpvec &b) {                       \
-    return v_not(v_lt(a, b));                                                  \
-  }                                                                            \
-  inline _Tpvec v_le(const _Tpvec &a, const _Tpvec &b) { return v_ge(b, a); }
-
-#define OPENCV_HAL_IMPL_AVX_CMP_OP_INT(_Tpuvec, _Tpsvec, suffix, sbit)         \
-  inline _Tpuvec v_eq(const _Tpuvec &a, const _Tpuvec &b) {                    \
-    return _Tpuvec(_mm256_cmpeq_##suffix(a.val, b.val));                       \
-  }                                                                            \
-  inline _Tpuvec v_gt(const _Tpuvec &a, const _Tpuvec &b) {                    \
-    __m256i smask = _mm256_set1_##suffix(sbit);                                \
-    return _Tpuvec(_mm256_cmpgt_##suffix(_mm256_xor_si256(a.val, smask),       \
-                                         _mm256_xor_si256(b.val, smask)));     \
-  }                                                                            \
-  inline _Tpsvec v_eq(const _Tpsvec &a, const _Tpsvec &b) {                    \
-    return _Tpsvec(_mm256_cmpeq_##suffix(a.val, b.val));                       \
-  }                                                                            \
-  inline _Tpsvec v_gt(const _Tpsvec &a, const _Tpsvec &b) {                    \
-    return _Tpsvec(_mm256_cmpgt_##suffix(a.val, b.val));                       \
-  }                                                                            \
-  OPENCV_HAL_IMPL_AVX_CMP_OP_OV(_Tpuvec)                                       \
-  OPENCV_HAL_IMPL_AVX_CMP_OP_OV(_Tpsvec)
-
-OPENCV_HAL_IMPL_AVX_CMP_OP_INT(v_uint8x32, v_int8x32, epi8, (char)-128)
-OPENCV_HAL_IMPL_AVX_CMP_OP_INT(v_uint16x16, v_int16x16, epi16, (short)-32768)
-OPENCV_HAL_IMPL_AVX_CMP_OP_INT(v_uint32x8, v_int32x8, epi32, (int)0x80000000)
-
-#define OPENCV_HAL_IMPL_AVX_CMP_OP_64BIT(_Tpvec)                               \
-  inline _Tpvec v_eq(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(_mm256_cmpeq_epi64(a.val, b.val));                           \
-  }                                                                            \
-  inline _Tpvec v_ne(const _Tpvec &a, const _Tpvec &b) {                       \
-    return v_not(v_eq(a, b));                                                  \
-  }
-
-OPENCV_HAL_IMPL_AVX_CMP_OP_64BIT(v_uint64x4)
-OPENCV_HAL_IMPL_AVX_CMP_OP_64BIT(v_int64x4)
-
-#define OPENCV_HAL_IMPL_AVX_CMP_FLT(bin_op, imm8, _Tpvec, suffix)              \
-  inline _Tpvec bin_op(const _Tpvec &a, const _Tpvec &b) {                     \
-    return _Tpvec(_mm256_cmp_##suffix(a.val, b.val, imm8));                    \
-  }
-
-#define OPENCV_HAL_IMPL_AVX_CMP_OP_FLT(_Tpvec, suffix)                         \
-  OPENCV_HAL_IMPL_AVX_CMP_FLT(v_eq, _CMP_EQ_OQ, _Tpvec, suffix)                \
-  OPENCV_HAL_IMPL_AVX_CMP_FLT(v_ne, _CMP_NEQ_OQ, _Tpvec, suffix)               \
-  OPENCV_HAL_IMPL_AVX_CMP_FLT(v_lt, _CMP_LT_OQ, _Tpvec, suffix)                \
-  OPENCV_HAL_IMPL_AVX_CMP_FLT(v_gt, _CMP_GT_OQ, _Tpvec, suffix)                \
-  OPENCV_HAL_IMPL_AVX_CMP_FLT(v_le, _CMP_LE_OQ, _Tpvec, suffix)                \
-  OPENCV_HAL_IMPL_AVX_CMP_FLT(v_ge, _CMP_GE_OQ, _Tpvec, suffix)
-
-OPENCV_HAL_IMPL_AVX_CMP_OP_FLT(v_float32x8, ps)
-OPENCV_HAL_IMPL_AVX_CMP_OP_FLT(v_float64x4, pd)
-
-inline v_float32x8 v_not_nan(const v_float32x8 &a) {
-  return v_float32x8(_mm256_cmp_ps(a.val, a.val, _CMP_ORD_Q));
-}
-inline v_float64x4 v_not_nan(const v_float64x4 &a) {
-  return v_float64x4(_mm256_cmp_pd(a.val, a.val, _CMP_ORD_Q));
-}
-
-/** min/max **/
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_min, v_uint8x32, _mm256_min_epu8)
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_max, v_uint8x32, _mm256_max_epu8)
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_min, v_int8x32, _mm256_min_epi8)
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_max, v_int8x32, _mm256_max_epi8)
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_min, v_uint16x16, _mm256_min_epu16)
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_max, v_uint16x16, _mm256_max_epu16)
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_min, v_int16x16, _mm256_min_epi16)
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_max, v_int16x16, _mm256_max_epi16)
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_min, v_uint32x8, _mm256_min_epu32)
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_max, v_uint32x8, _mm256_max_epu32)
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_min, v_int32x8, _mm256_min_epi32)
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_max, v_int32x8, _mm256_max_epi32)
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_min, v_float32x8, _mm256_min_ps)
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_max, v_float32x8, _mm256_max_ps)
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_min, v_float64x4, _mm256_min_pd)
-OPENCV_HAL_IMPL_AVX_BIN_FUNC(v_max, v_float64x4, _mm256_max_pd)
-
-/** Rotate **/
-template <int imm>
-inline v_uint8x32 v_rotate_left(const v_uint8x32 &a, const v_uint8x32 &b) {
-  enum { IMM_R = (16 - imm) & 0xFF };
-  enum { IMM_R2 = (32 - imm) & 0xFF };
-
-  if (imm == 0)
-    return a;
-  if (imm == 32)
-    return b;
-  if (imm > 32)
-    return v_uint8x32();
-
-  __m256i swap = _mm256_permute2x128_si256(a.val, b.val, 0x03);
-  if (imm == 16)
-    return v_uint8x32(swap);
-  if (imm < 16)
-    return v_uint8x32(_mm256_alignr_epi8(a.val, swap, IMM_R));
-  return v_uint8x32(_mm256_alignr_epi8(swap, b.val, IMM_R2)); // imm < 32
-}
-
-template <int imm>
-inline v_uint8x32 v_rotate_right(const v_uint8x32 &a, const v_uint8x32 &b) {
-  enum { IMM_L = (imm - 16) & 0xFF };
-
-  if (imm == 0)
-    return a;
-  if (imm == 32)
-    return b;
-  if (imm > 32)
-    return v_uint8x32();
-
-  __m256i swap = _mm256_permute2x128_si256(a.val, b.val, 0x21);
-  if (imm == 16)
-    return v_uint8x32(swap);
-  if (imm < 16)
-    return v_uint8x32(_mm256_alignr_epi8(swap, a.val, imm));
-  return v_uint8x32(_mm256_alignr_epi8(b.val, swap, IMM_L));
-}
-
-template <int imm> inline v_uint8x32 v_rotate_left(const v_uint8x32 &a) {
-  enum { IMM_L = (imm - 16) & 0xFF };
-  enum { IMM_R = (16 - imm) & 0xFF };
-
-  if (imm == 0)
-    return a;
-  if (imm > 32)
-    return v_uint8x32();
-
-  // ESAC control[3] ? [127:0] = 0
-  __m256i swapz =
-      _mm256_permute2x128_si256(a.val, a.val, _MM_SHUFFLE(0, 0, 2, 0));
-  if (imm == 16)
-    return v_uint8x32(swapz);
-  if (imm < 16)
-    return v_uint8x32(_mm256_alignr_epi8(a.val, swapz, IMM_R));
-  return v_uint8x32(_mm256_slli_si256(swapz, IMM_L));
-}
-
-template <int imm> inline v_uint8x32 v_rotate_right(const v_uint8x32 &a) {
-  enum { IMM_L = (imm - 16) & 0xFF };
-
-  if (imm == 0)
-    return a;
-  if (imm > 32)
-    return v_uint8x32();
-
-  // ESAC control[3] ? [127:0] = 0
-  __m256i swapz =
-      _mm256_permute2x128_si256(a.val, a.val, _MM_SHUFFLE(2, 0, 0, 1));
-  if (imm == 16)
-    return v_uint8x32(swapz);
-  if (imm < 16)
-    return v_uint8x32(_mm256_alignr_epi8(swapz, a.val, imm));
-  return v_uint8x32(_mm256_srli_si256(swapz, IMM_L));
-}
-
-#define OPENCV_HAL_IMPL_AVX_ROTATE_CAST(intrin, _Tpvec, cast)                  \
-  template <int imm> inline _Tpvec intrin(const _Tpvec &a, const _Tpvec &b) {  \
-    enum { IMMxW = imm * sizeof(typename _Tpvec::lane_type) };                 \
-    v_uint8x32 ret =                                                           \
-        intrin<IMMxW>(v_reinterpret_as_u8(a), v_reinterpret_as_u8(b));         \
-    return _Tpvec(cast(ret.val));                                              \
-  }                                                                            \
-  template <int imm> inline _Tpvec intrin(const _Tpvec &a) {                   \
-    enum { IMMxW = imm * sizeof(typename _Tpvec::lane_type) };                 \
-    v_uint8x32 ret = intrin<IMMxW>(v_reinterpret_as_u8(a));                    \
-    return _Tpvec(cast(ret.val));                                              \
-  }
-
-#define OPENCV_HAL_IMPL_AVX_ROTATE(_Tpvec)                                     \
-  OPENCV_HAL_IMPL_AVX_ROTATE_CAST(v_rotate_left, _Tpvec, OPENCV_HAL_NOP)       \
-  OPENCV_HAL_IMPL_AVX_ROTATE_CAST(v_rotate_right, _Tpvec, OPENCV_HAL_NOP)
-
-OPENCV_HAL_IMPL_AVX_ROTATE(v_int8x32)
-OPENCV_HAL_IMPL_AVX_ROTATE(v_uint16x16)
-OPENCV_HAL_IMPL_AVX_ROTATE(v_int16x16)
-OPENCV_HAL_IMPL_AVX_ROTATE(v_uint32x8)
-OPENCV_HAL_IMPL_AVX_ROTATE(v_int32x8)
-OPENCV_HAL_IMPL_AVX_ROTATE(v_uint64x4)
-OPENCV_HAL_IMPL_AVX_ROTATE(v_int64x4)
-
-OPENCV_HAL_IMPL_AVX_ROTATE_CAST(v_rotate_left, v_float32x8, _mm256_castsi256_ps)
-OPENCV_HAL_IMPL_AVX_ROTATE_CAST(v_rotate_right, v_float32x8,
-                                _mm256_castsi256_ps)
-OPENCV_HAL_IMPL_AVX_ROTATE_CAST(v_rotate_left, v_float64x4, _mm256_castsi256_pd)
-OPENCV_HAL_IMPL_AVX_ROTATE_CAST(v_rotate_right, v_float64x4,
-                                _mm256_castsi256_pd)
-
-/** Reverse **/
-inline v_uint8x32 v_reverse(const v_uint8x32 &a) {
-  static const __m256i perm =
-      _mm256_setr_epi8(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 15,
-                       14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
-  __m256i vec = _mm256_shuffle_epi8(a.val, perm);
-  return v_uint8x32(_mm256_permute2x128_si256(vec, vec, 1));
-}
-
-inline v_int8x32 v_reverse(const v_int8x32 &a) {
-  return v_reinterpret_as_s8(v_reverse(v_reinterpret_as_u8(a)));
-}
-
-inline v_uint16x16 v_reverse(const v_uint16x16 &a) {
-  static const __m256i perm =
-      _mm256_setr_epi8(14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 0, 1, 14,
-                       15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 0, 1);
-  __m256i vec = _mm256_shuffle_epi8(a.val, perm);
-  return v_uint16x16(_mm256_permute2x128_si256(vec, vec, 1));
-}
-
-inline v_int16x16 v_reverse(const v_int16x16 &a) {
-  return v_reinterpret_as_s16(v_reverse(v_reinterpret_as_u16(a)));
-}
-
-inline v_uint32x8 v_reverse(const v_uint32x8 &a) {
-  static const __m256i perm = _mm256_setr_epi32(7, 6, 5, 4, 3, 2, 1, 0);
-  return v_uint32x8(_mm256_permutevar8x32_epi32(a.val, perm));
-}
-
-inline v_int32x8 v_reverse(const v_int32x8 &a) {
-  return v_reinterpret_as_s32(v_reverse(v_reinterpret_as_u32(a)));
-}
-
-inline v_float32x8 v_reverse(const v_float32x8 &a) {
-  return v_reinterpret_as_f32(v_reverse(v_reinterpret_as_u32(a)));
-}
-
-inline v_uint64x4 v_reverse(const v_uint64x4 &a) {
-  return v_uint64x4(_mm256_permute4x64_epi64(a.val, _MM_SHUFFLE(0, 1, 2, 3)));
-}
-
-inline v_int64x4 v_reverse(const v_int64x4 &a) {
-  return v_reinterpret_as_s64(v_reverse(v_reinterpret_as_u64(a)));
-}
-
-inline v_float64x4 v_reverse(const v_float64x4 &a) {
-  return v_reinterpret_as_f64(v_reverse(v_reinterpret_as_u64(a)));
-}
-
-////////// Reduce and mask /////////
-
-/** Reduce **/
-inline unsigned v_reduce_sum(const v_uint8x32 &a) {
-  __m256i half = _mm256_sad_epu8(a.val, _mm256_setzero_si256());
-  __m128i quarter =
-      _mm_add_epi32(_v256_extract_low(half), _v256_extract_high(half));
-  return (unsigned)_mm_cvtsi128_si32(
-      _mm_add_epi32(quarter, _mm_unpackhi_epi64(quarter, quarter)));
-}
-inline int v_reduce_sum(const v_int8x32 &a) {
-  __m256i half =
-      _mm256_sad_epu8(_mm256_xor_si256(a.val, _mm256_set1_epi8((schar)-128)),
-                      _mm256_setzero_si256());
-  __m128i quarter =
-      _mm_add_epi32(_v256_extract_low(half), _v256_extract_high(half));
-  return (unsigned)_mm_cvtsi128_si32(
-             _mm_add_epi32(quarter, _mm_unpackhi_epi64(quarter, quarter))) -
-         4096;
-}
-#define OPENCV_HAL_IMPL_AVX_REDUCE_32(_Tpvec, sctype, func, intrin)            \
-  inline sctype v_reduce_##func(const _Tpvec &a) {                             \
-    __m128i val = intrin(_v256_extract_low(a.val), _v256_extract_high(a.val)); \
-    val = intrin(val, _mm_srli_si128(val, 8));                                 \
-    val = intrin(val, _mm_srli_si128(val, 4));                                 \
-    val = intrin(val, _mm_srli_si128(val, 2));                                 \
-    val = intrin(val, _mm_srli_si128(val, 1));                                 \
-    return (sctype)_mm_cvtsi128_si32(val);                                     \
-  }
-
-OPENCV_HAL_IMPL_AVX_REDUCE_32(v_uint8x32, uchar, min, _mm_min_epu8)
-OPENCV_HAL_IMPL_AVX_REDUCE_32(v_int8x32, schar, min, _mm_min_epi8)
-OPENCV_HAL_IMPL_AVX_REDUCE_32(v_uint8x32, uchar, max, _mm_max_epu8)
-OPENCV_HAL_IMPL_AVX_REDUCE_32(v_int8x32, schar, max, _mm_max_epi8)
-
-#define OPENCV_HAL_IMPL_AVX_REDUCE_16(_Tpvec, sctype, func, intrin)            \
-  inline sctype v_reduce_##func(const _Tpvec &a) {                             \
-    __m128i v0 = _v256_extract_low(a.val);                                     \
-    __m128i v1 = _v256_extract_high(a.val);                                    \
-    v0 = intrin(v0, v1);                                                       \
-    v0 = intrin(v0, _mm_srli_si128(v0, 8));                                    \
-    v0 = intrin(v0, _mm_srli_si128(v0, 4));                                    \
-    v0 = intrin(v0, _mm_srli_si128(v0, 2));                                    \
-    return (sctype)_mm_cvtsi128_si32(v0);                                      \
-  }
-
-OPENCV_HAL_IMPL_AVX_REDUCE_16(v_uint16x16, ushort, min, _mm_min_epu16)
-OPENCV_HAL_IMPL_AVX_REDUCE_16(v_int16x16, short, min, _mm_min_epi16)
-OPENCV_HAL_IMPL_AVX_REDUCE_16(v_uint16x16, ushort, max, _mm_max_epu16)
-OPENCV_HAL_IMPL_AVX_REDUCE_16(v_int16x16, short, max, _mm_max_epi16)
-
-#define OPENCV_HAL_IMPL_AVX_REDUCE_8(_Tpvec, sctype, func, intrin)             \
-  inline sctype v_reduce_##func(const _Tpvec &a) {                             \
-    __m128i v0 = _v256_extract_low(a.val);                                     \
-    __m128i v1 = _v256_extract_high(a.val);                                    \
-    v0 = intrin(v0, v1);                                                       \
-    v0 = intrin(v0, _mm_srli_si128(v0, 8));                                    \
-    v0 = intrin(v0, _mm_srli_si128(v0, 4));                                    \
-    return (sctype)_mm_cvtsi128_si32(v0);                                      \
-  }
-
-OPENCV_HAL_IMPL_AVX_REDUCE_8(v_uint32x8, unsigned, min, _mm_min_epu32)
-OPENCV_HAL_IMPL_AVX_REDUCE_8(v_int32x8, int, min, _mm_min_epi32)
-OPENCV_HAL_IMPL_AVX_REDUCE_8(v_uint32x8, unsigned, max, _mm_max_epu32)
-OPENCV_HAL_IMPL_AVX_REDUCE_8(v_int32x8, int, max, _mm_max_epi32)
-
-#define OPENCV_HAL_IMPL_AVX_REDUCE_FLT(func, intrin)                           \
-  inline float v_reduce_##func(const v_float32x8 &a) {                         \
-    __m128 v0 = _v256_extract_low(a.val);                                      \
-    __m128 v1 = _v256_extract_high(a.val);                                     \
-    v0 = intrin(v0, v1);                                                       \
-    v0 = intrin(v0, _mm_permute_ps(v0, _MM_SHUFFLE(0, 0, 3, 2)));              \
-    v0 = intrin(v0, _mm_permute_ps(v0, _MM_SHUFFLE(0, 0, 0, 1)));              \
-    return _mm_cvtss_f32(v0);                                                  \
-  }
-
-OPENCV_HAL_IMPL_AVX_REDUCE_FLT(min, _mm_min_ps)
-OPENCV_HAL_IMPL_AVX_REDUCE_FLT(max, _mm_max_ps)
-
-inline int v_reduce_sum(const v_int32x8 &a) {
-  __m256i s0 = _mm256_hadd_epi32(a.val, a.val);
-  s0 = _mm256_hadd_epi32(s0, s0);
-
-  __m128i s1 = _v256_extract_high(s0);
-  s1 = _mm_add_epi32(_v256_extract_low(s0), s1);
-
-  return _mm_cvtsi128_si32(s1);
-}
-
-inline unsigned v_reduce_sum(const v_uint32x8 &a) {
-  return v_reduce_sum(v_reinterpret_as_s32(a));
-}
-
-inline int v_reduce_sum(const v_int16x16 &a) {
-  return v_reduce_sum(v_add(v_expand_low(a), v_expand_high(a)));
-}
-inline unsigned v_reduce_sum(const v_uint16x16 &a) {
-  return v_reduce_sum(v_add(v_expand_low(a), v_expand_high(a)));
-}
-
-inline float v_reduce_sum(const v_float32x8 &a) {
-  __m256 s0 = _mm256_hadd_ps(a.val, a.val);
-  s0 = _mm256_hadd_ps(s0, s0);
-
-  __m128 s1 = _v256_extract_high(s0);
-  s1 = _mm_add_ps(_v256_extract_low(s0), s1);
-
-  return _mm_cvtss_f32(s1);
-}
-
-inline uint64 v_reduce_sum(const v_uint64x4 &a) {
-  uint64 CV_DECL_ALIGNED(32) idx[2];
-  _mm_store_si128((__m128i *)idx, _mm_add_epi64(_v256_extract_low(a.val),
-                                                _v256_extract_high(a.val)));
-  return idx[0] + idx[1];
-}
-inline int64 v_reduce_sum(const v_int64x4 &a) {
-  int64 CV_DECL_ALIGNED(32) idx[2];
-  _mm_store_si128((__m128i *)idx, _mm_add_epi64(_v256_extract_low(a.val),
-                                                _v256_extract_high(a.val)));
-  return idx[0] + idx[1];
-}
-inline double v_reduce_sum(const v_float64x4 &a) {
-  __m256d s0 = _mm256_hadd_pd(a.val, a.val);
-  return _mm_cvtsd_f64(
-      _mm_add_pd(_v256_extract_low(s0), _v256_extract_high(s0)));
-}
-
-inline v_float32x8 v_reduce_sum4(const v_float32x8 &a, const v_float32x8 &b,
-                                 const v_float32x8 &c, const v_float32x8 &d) {
-  __m256 ab = _mm256_hadd_ps(a.val, b.val);
-  __m256 cd = _mm256_hadd_ps(c.val, d.val);
-  return v_float32x8(_mm256_hadd_ps(ab, cd));
-}
-
-inline unsigned v_reduce_sad(const v_uint8x32 &a, const v_uint8x32 &b) {
-  __m256i half = _mm256_sad_epu8(a.val, b.val);
-  __m128i quarter =
-      _mm_add_epi32(_v256_extract_low(half), _v256_extract_high(half));
-  return (unsigned)_mm_cvtsi128_si32(
-      _mm_add_epi32(quarter, _mm_unpackhi_epi64(quarter, quarter)));
-}
-inline unsigned v_reduce_sad(const v_int8x32 &a, const v_int8x32 &b) {
-  __m256i half = _mm256_set1_epi8(0x7f);
-  half = _mm256_sad_epu8(_mm256_add_epi8(a.val, half),
-                         _mm256_add_epi8(b.val, half));
-  __m128i quarter =
-      _mm_add_epi32(_v256_extract_low(half), _v256_extract_high(half));
-  return (unsigned)_mm_cvtsi128_si32(
-      _mm_add_epi32(quarter, _mm_unpackhi_epi64(quarter, quarter)));
-}
-inline unsigned v_reduce_sad(const v_uint16x16 &a, const v_uint16x16 &b) {
-  v_uint32x8 l, h;
-  v_expand(v_add_wrap(v_sub(a, b), v_sub(b, a)), l, h);
-  return v_reduce_sum(v_add(l, h));
-}
-inline unsigned v_reduce_sad(const v_int16x16 &a, const v_int16x16 &b) {
-  v_uint32x8 l, h;
-  v_expand(v_reinterpret_as_u16(v_sub_wrap(v_max(a, b), v_min(a, b))), l, h);
-  return v_reduce_sum(v_add(l, h));
-}
-inline unsigned v_reduce_sad(const v_uint32x8 &a, const v_uint32x8 &b) {
-  return v_reduce_sum(v_sub(v_max(a, b), v_min(a, b)));
-}
-inline unsigned v_reduce_sad(const v_int32x8 &a, const v_int32x8 &b) {
-  v_int32x8 m = v_lt(a, b);
-  return v_reduce_sum(v_reinterpret_as_u32(v_sub(v_xor(v_sub(a, b), m), m)));
-}
-inline float v_reduce_sad(const v_float32x8 &a, const v_float32x8 &b) {
-  return v_reduce_sum(v_and(v_sub(a, b), v_float32x8(_mm256_castsi256_ps(
-                                             _mm256_set1_epi32(0x7fffffff)))));
-}
-
-/** Popcount **/
-inline v_uint8x32 v_popcount(const v_uint8x32 &a) {
-  __m256i _popcnt_table =
-      _mm256_setr_epi8(0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 0, 1, 1,
-                       2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4);
-  __m256i _popcnt_mask = _mm256_set1_epi8(0x0F);
-  return v_uint8x32(_mm256_add_epi8(
-      _mm256_shuffle_epi8(_popcnt_table, _mm256_and_si256(a.val, _popcnt_mask)),
-      _mm256_shuffle_epi8(
-          _popcnt_table,
-          _mm256_and_si256(_mm256_srli_epi16(a.val, 4), _popcnt_mask))));
-}
-inline v_uint16x16 v_popcount(const v_uint16x16 &a) {
-  v_uint8x32 p = v_popcount(v_reinterpret_as_u8(a));
-  p = v_add(p, v_rotate_right<1>(p));
-  return v_and(v_reinterpret_as_u16(p), v256_setall_u16(0x00ff));
-}
-inline v_uint32x8 v_popcount(const v_uint32x8 &a) {
-  v_uint8x32 p = v_popcount(v_reinterpret_as_u8(a));
-  p = v_add(p, v_rotate_right<1>(p));
-  p = v_add(p, v_rotate_right<2>(p));
-  return v_and(v_reinterpret_as_u32(p), v256_setall_u32(0x000000ff));
-}
-inline v_uint64x4 v_popcount(const v_uint64x4 &a) {
-  return v_uint64x4(_mm256_sad_epu8(v_popcount(v_reinterpret_as_u8(a)).val,
-                                    _mm256_setzero_si256()));
-}
-inline v_uint8x32 v_popcount(const v_int8x32 &a) {
-  return v_popcount(v_reinterpret_as_u8(a));
-}
-inline v_uint16x16 v_popcount(const v_int16x16 &a) {
-  return v_popcount(v_reinterpret_as_u16(a));
-}
-inline v_uint32x8 v_popcount(const v_int32x8 &a) {
-  return v_popcount(v_reinterpret_as_u32(a));
-}
-inline v_uint64x4 v_popcount(const v_int64x4 &a) {
-  return v_popcount(v_reinterpret_as_u64(a));
-}
-
-/** Mask **/
-inline int v_signmask(const v_int8x32 &a) {
-  return _mm256_movemask_epi8(a.val);
-}
-inline int v_signmask(const v_uint8x32 &a) {
-  return v_signmask(v_reinterpret_as_s8(a));
-}
-
-inline int v_signmask(const v_int16x16 &a) {
-  return v_signmask(v_pack(a, a)) & 0xFFFF;
-}
-inline int v_signmask(const v_uint16x16 &a) {
-  return v_signmask(v_reinterpret_as_s16(a));
-}
-
-inline int v_signmask(const v_float32x8 &a) {
-  return _mm256_movemask_ps(a.val);
-}
-inline int v_signmask(const v_float64x4 &a) {
-  return _mm256_movemask_pd(a.val);
-}
-
-inline int v_signmask(const v_int32x8 &a) {
-  return v_signmask(v_reinterpret_as_f32(a));
-}
-inline int v_signmask(const v_uint32x8 &a) {
-  return v_signmask(v_reinterpret_as_f32(a));
-}
-
-inline int v_signmask(const v_int64x4 &a) {
-  return v_signmask(v_reinterpret_as_f64(a));
-}
-inline int v_signmask(const v_uint64x4 &a) {
-  return v_signmask(v_reinterpret_as_f64(a));
-}
-
-inline int v_scan_forward(const v_int8x32 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a)));
-}
-inline int v_scan_forward(const v_uint8x32 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a)));
-}
-inline int v_scan_forward(const v_int16x16 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 2;
-}
-inline int v_scan_forward(const v_uint16x16 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 2;
-}
-inline int v_scan_forward(const v_int32x8 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 4;
-}
-inline int v_scan_forward(const v_uint32x8 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 4;
-}
-inline int v_scan_forward(const v_float32x8 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 4;
-}
-inline int v_scan_forward(const v_int64x4 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 8;
-}
-inline int v_scan_forward(const v_uint64x4 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 8;
-}
-inline int v_scan_forward(const v_float64x4 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 8;
-}
-
-/** Checks **/
-#define OPENCV_HAL_IMPL_AVX_CHECK(_Tpvec, allmask)                             \
-  inline bool v_check_all(const _Tpvec &a) {                                   \
-    return v_signmask(a) == allmask;                                           \
-  }                                                                            \
-  inline bool v_check_any(const _Tpvec &a) { return v_signmask(a) != 0; }
-OPENCV_HAL_IMPL_AVX_CHECK(v_uint8x32, -1)
-OPENCV_HAL_IMPL_AVX_CHECK(v_int8x32, -1)
-OPENCV_HAL_IMPL_AVX_CHECK(v_uint32x8, 255)
-OPENCV_HAL_IMPL_AVX_CHECK(v_int32x8, 255)
-OPENCV_HAL_IMPL_AVX_CHECK(v_uint64x4, 15)
-OPENCV_HAL_IMPL_AVX_CHECK(v_int64x4, 15)
-OPENCV_HAL_IMPL_AVX_CHECK(v_float32x8, 255)
-OPENCV_HAL_IMPL_AVX_CHECK(v_float64x4, 15)
-
-#define OPENCV_HAL_IMPL_AVX_CHECK_SHORT(_Tpvec)                                \
-  inline bool v_check_all(const _Tpvec &a) {                                   \
-    return (v_signmask(v_reinterpret_as_s8(a)) & 0xaaaaaaaa) == 0xaaaaaaaa;    \
-  }                                                                            \
-  inline bool v_check_any(const _Tpvec &a) {                                   \
-    return (v_signmask(v_reinterpret_as_s8(a)) & 0xaaaaaaaa) != 0;             \
-  }
-OPENCV_HAL_IMPL_AVX_CHECK_SHORT(v_uint16x16)
-OPENCV_HAL_IMPL_AVX_CHECK_SHORT(v_int16x16)
-
-////////// Other math /////////
-
-/** Some frequent operations **/
-#if CV_FMA3
-#define OPENCV_HAL_IMPL_AVX_MULADD(_Tpvec, suffix)                             \
-  inline _Tpvec v_fma(const _Tpvec &a, const _Tpvec &b, const _Tpvec &c) {     \
-    return _Tpvec(_mm256_fmadd_##suffix(a.val, b.val, c.val));                 \
-  }                                                                            \
-  inline _Tpvec v_muladd(const _Tpvec &a, const _Tpvec &b, const _Tpvec &c) {  \
-    return _Tpvec(_mm256_fmadd_##suffix(a.val, b.val, c.val));                 \
-  }
-#else
-#define OPENCV_HAL_IMPL_AVX_MULADD(_Tpvec, suffix)                             \
-  inline _Tpvec v_fma(const _Tpvec &a, const _Tpvec &b, const _Tpvec &c) {     \
-    return _Tpvec(                                                             \
-        _mm256_add_##suffix(_mm256_mul_##suffix(a.val, b.val), c.val));        \
-  }                                                                            \
-  inline _Tpvec v_muladd(const _Tpvec &a, const _Tpvec &b, const _Tpvec &c) {  \
-    return _Tpvec(                                                             \
-        _mm256_add_##suffix(_mm256_mul_##suffix(a.val, b.val), c.val));        \
-  }
-#endif
-
-#define OPENCV_HAL_IMPL_AVX_MISC(_Tpvec, suffix)                               \
-  inline _Tpvec v_sqrt(const _Tpvec &x) {                                      \
-    return _Tpvec(_mm256_sqrt_##suffix(x.val));                                \
-  }                                                                            \
-  inline _Tpvec v_sqr_magnitude(const _Tpvec &a, const _Tpvec &b) {            \
-    return v_fma(a, a, v_mul(b, b));                                           \
-  }                                                                            \
-  inline _Tpvec v_magnitude(const _Tpvec &a, const _Tpvec &b) {                \
-    return v_sqrt(v_fma(a, a, v_mul(b, b)));                                   \
-  }
-
-OPENCV_HAL_IMPL_AVX_MULADD(v_float32x8, ps)
-OPENCV_HAL_IMPL_AVX_MULADD(v_float64x4, pd)
-OPENCV_HAL_IMPL_AVX_MISC(v_float32x8, ps)
-OPENCV_HAL_IMPL_AVX_MISC(v_float64x4, pd)
-
-inline v_int32x8 v_fma(const v_int32x8 &a, const v_int32x8 &b,
-                       const v_int32x8 &c) {
-  return v_add(v_mul(a, b), c);
-}
-
-inline v_int32x8 v_muladd(const v_int32x8 &a, const v_int32x8 &b,
-                          const v_int32x8 &c) {
-  return v_fma(a, b, c);
-}
-
-inline v_float32x8 v_invsqrt(const v_float32x8 &x) {
-  v_float32x8 half = v_mul(x, v256_setall_f32(0.5));
-  v_float32x8 t = v_float32x8(_mm256_rsqrt_ps(x.val));
-  // todo: _mm256_fnmsub_ps
-  t = v_mul(t, v_sub(v256_setall_f32(1.5), v_mul(v_mul(t, t), half)));
-  return t;
-}
-
-inline v_float64x4 v_invsqrt(const v_float64x4 &x) {
-  return v_div(v256_setall_f64(1.), v_sqrt(x));
-}
-
-/** Absolute values **/
-#define OPENCV_HAL_IMPL_AVX_ABS(_Tpvec, suffix)                                \
-  inline v_u##_Tpvec v_abs(const v_##_Tpvec &x) {                              \
-    return v_u##_Tpvec(_mm256_abs_##suffix(x.val));                            \
-  }
-
-OPENCV_HAL_IMPL_AVX_ABS(int8x32, epi8)
-OPENCV_HAL_IMPL_AVX_ABS(int16x16, epi16)
-OPENCV_HAL_IMPL_AVX_ABS(int32x8, epi32)
-
-inline v_float32x8 v_abs(const v_float32x8 &x) {
-  return v_and(x,
-               v_float32x8(_mm256_castsi256_ps(_mm256_set1_epi32(0x7fffffff))));
-}
-inline v_float64x4 v_abs(const v_float64x4 &x) {
-  return v_and(x, v_float64x4(_mm256_castsi256_pd(
-                      _mm256_srli_epi64(_mm256_set1_epi64x(-1), 1))));
-}
-
-/** Absolute difference **/
-inline v_uint8x32 v_absdiff(const v_uint8x32 &a, const v_uint8x32 &b) {
-  return v_add_wrap(v_sub(a, b), v_sub(b, a));
-}
-inline v_uint16x16 v_absdiff(const v_uint16x16 &a, const v_uint16x16 &b) {
-  return v_add_wrap(v_sub(a, b), v_sub(b, a));
-}
-inline v_uint32x8 v_absdiff(const v_uint32x8 &a, const v_uint32x8 &b) {
-  return v_sub(v_max(a, b), v_min(a, b));
-}
-
-inline v_uint8x32 v_absdiff(const v_int8x32 &a, const v_int8x32 &b) {
-  v_int8x32 d = v_sub_wrap(a, b);
-  v_int8x32 m = v_lt(a, b);
-  return v_reinterpret_as_u8(v_sub_wrap(v_xor(d, m), m));
-}
-
-inline v_uint16x16 v_absdiff(const v_int16x16 &a, const v_int16x16 &b) {
-  return v_reinterpret_as_u16(v_sub_wrap(v_max(a, b), v_min(a, b)));
-}
-
-inline v_uint32x8 v_absdiff(const v_int32x8 &a, const v_int32x8 &b) {
-  v_int32x8 d = v_sub(a, b);
-  v_int32x8 m = v_lt(a, b);
-  return v_reinterpret_as_u32(v_sub(v_xor(d, m), m));
-}
-
-inline v_float32x8 v_absdiff(const v_float32x8 &a, const v_float32x8 &b) {
-  return v_abs(v_sub(a, b));
-}
-
-inline v_float64x4 v_absdiff(const v_float64x4 &a, const v_float64x4 &b) {
-  return v_abs(v_sub(a, b));
-}
-
-/** Saturating absolute difference **/
-inline v_int8x32 v_absdiffs(const v_int8x32 &a, const v_int8x32 &b) {
-  v_int8x32 d = v_sub(a, b);
-  v_int8x32 m = v_lt(a, b);
-  return v_sub(v_xor(d, m), m);
-}
-inline v_int16x16 v_absdiffs(const v_int16x16 &a, const v_int16x16 &b) {
-  return v_sub(v_max(a, b), v_min(a, b));
-}
-
-////////// Conversions /////////
-
-/** Rounding **/
-inline v_int32x8 v_round(const v_float32x8 &a) {
-  return v_int32x8(_mm256_cvtps_epi32(a.val));
-}
-
-inline v_int32x8 v_round(const v_float64x4 &a) {
-  return v_int32x8(_mm256_castsi128_si256(_mm256_cvtpd_epi32(a.val)));
-}
-
-inline v_int32x8 v_round(const v_float64x4 &a, const v_float64x4 &b) {
-  __m128i ai = _mm256_cvtpd_epi32(a.val), bi = _mm256_cvtpd_epi32(b.val);
-  return v_int32x8(_v256_combine(ai, bi));
-}
-
-inline v_int32x8 v_trunc(const v_float32x8 &a) {
-  return v_int32x8(_mm256_cvttps_epi32(a.val));
-}
-
-inline v_int32x8 v_trunc(const v_float64x4 &a) {
-  return v_int32x8(_mm256_castsi128_si256(_mm256_cvttpd_epi32(a.val)));
-}
-
-inline v_int32x8 v_floor(const v_float32x8 &a) {
-  return v_int32x8(_mm256_cvttps_epi32(_mm256_floor_ps(a.val)));
-}
-
-inline v_int32x8 v_floor(const v_float64x4 &a) {
-  return v_trunc(v_float64x4(_mm256_floor_pd(a.val)));
-}
-
-inline v_int32x8 v_ceil(const v_float32x8 &a) {
-  return v_int32x8(_mm256_cvttps_epi32(_mm256_ceil_ps(a.val)));
-}
-
-inline v_int32x8 v_ceil(const v_float64x4 &a) {
-  return v_trunc(v_float64x4(_mm256_ceil_pd(a.val)));
-}
-
-/** To float **/
-inline v_float32x8 v_cvt_f32(const v_int32x8 &a) {
-  return v_float32x8(_mm256_cvtepi32_ps(a.val));
-}
-
-inline v_float32x8 v_cvt_f32(const v_float64x4 &a) {
-  return v_float32x8(_mm256_castps128_ps256(_mm256_cvtpd_ps(a.val)));
-}
-
-inline v_float32x8 v_cvt_f32(const v_float64x4 &a, const v_float64x4 &b) {
-  __m128 af = _mm256_cvtpd_ps(a.val), bf = _mm256_cvtpd_ps(b.val);
-  return v_float32x8(_v256_combine(af, bf));
-}
-
-inline v_float64x4 v_cvt_f64(const v_int32x8 &a) {
-  return v_float64x4(_mm256_cvtepi32_pd(_v256_extract_low(a.val)));
-}
-
-inline v_float64x4 v_cvt_f64_high(const v_int32x8 &a) {
-  return v_float64x4(_mm256_cvtepi32_pd(_v256_extract_high(a.val)));
-}
-
-inline v_float64x4 v_cvt_f64(const v_float32x8 &a) {
-  return v_float64x4(_mm256_cvtps_pd(_v256_extract_low(a.val)));
-}
-
-inline v_float64x4 v_cvt_f64_high(const v_float32x8 &a) {
-  return v_float64x4(_mm256_cvtps_pd(_v256_extract_high(a.val)));
-}
-
-// from (Mysticial and wim) https://stackoverflow.com/q/41144668
-inline v_float64x4 v_cvt_f64(const v_int64x4 &v) {
-  // constants encoded as floating-point
-  __m256i magic_i_lo = _mm256_set1_epi64x(0x4330000000000000);   // 2^52
-  __m256i magic_i_hi32 = _mm256_set1_epi64x(0x4530000080000000); // 2^84 + 2^63
-  __m256i magic_i_all =
-      _mm256_set1_epi64x(0x4530000080100000); // 2^84 + 2^63 + 2^52
-  __m256d magic_d_all = _mm256_castsi256_pd(magic_i_all);
-
-  // Blend the 32 lowest significant bits of v with magic_int_lo
-  __m256i v_lo = _mm256_blend_epi32(magic_i_lo, v.val, 0x55);
-  // Extract the 32 most significant bits of v
-  __m256i v_hi = _mm256_srli_epi64(v.val, 32);
-  // Flip the msb of v_hi and blend with 0x45300000
-  v_hi = _mm256_xor_si256(v_hi, magic_i_hi32);
-  // Compute in double precision
-  __m256d v_hi_dbl = _mm256_sub_pd(_mm256_castsi256_pd(v_hi), magic_d_all);
-  // (v_hi - magic_d_all) + v_lo  Do not assume associativity of floating point
-  // addition
-  __m256d result = _mm256_add_pd(v_hi_dbl, _mm256_castsi256_pd(v_lo));
-  return v_float64x4(result);
-}
-
-////////////// Lookup table access ////////////////////
-
-inline v_int8x32 v256_lut(const schar *tab, const int *idx) {
-  return v_int8x32(_mm256_setr_epi8(
-      tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]], tab[idx[4]],
-      tab[idx[5]], tab[idx[6]], tab[idx[7]], tab[idx[8]], tab[idx[9]],
-      tab[idx[10]], tab[idx[11]], tab[idx[12]], tab[idx[13]], tab[idx[14]],
-      tab[idx[15]], tab[idx[16]], tab[idx[17]], tab[idx[18]], tab[idx[19]],
-      tab[idx[20]], tab[idx[21]], tab[idx[22]], tab[idx[23]], tab[idx[24]],
-      tab[idx[25]], tab[idx[26]], tab[idx[27]], tab[idx[28]], tab[idx[29]],
-      tab[idx[30]], tab[idx[31]]));
-}
-inline v_int8x32 v256_lut_pairs(const schar *tab, const int *idx) {
-  return v_int8x32(_mm256_setr_epi16(
-      *(const short *)(tab + idx[0]), *(const short *)(tab + idx[1]),
-      *(const short *)(tab + idx[2]), *(const short *)(tab + idx[3]),
-      *(const short *)(tab + idx[4]), *(const short *)(tab + idx[5]),
-      *(const short *)(tab + idx[6]), *(const short *)(tab + idx[7]),
-      *(const short *)(tab + idx[8]), *(const short *)(tab + idx[9]),
-      *(const short *)(tab + idx[10]), *(const short *)(tab + idx[11]),
-      *(const short *)(tab + idx[12]), *(const short *)(tab + idx[13]),
-      *(const short *)(tab + idx[14]), *(const short *)(tab + idx[15])));
-}
-inline v_int8x32 v256_lut_quads(const schar *tab, const int *idx) {
-  return v_int8x32(_mm256_i32gather_epi32(
-      (const int *)tab, _mm256_loadu_si256((const __m256i *)idx), 1));
-}
-inline v_uint8x32 v256_lut(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v256_lut((const schar *)tab, idx));
-}
-inline v_uint8x32 v256_lut_pairs(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v256_lut_pairs((const schar *)tab, idx));
-}
-inline v_uint8x32 v256_lut_quads(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v256_lut_quads((const schar *)tab, idx));
-}
-
-inline v_int16x16 v256_lut(const short *tab, const int *idx) {
-  return v_int16x16(_mm256_setr_epi16(
-      tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]], tab[idx[4]],
-      tab[idx[5]], tab[idx[6]], tab[idx[7]], tab[idx[8]], tab[idx[9]],
-      tab[idx[10]], tab[idx[11]], tab[idx[12]], tab[idx[13]], tab[idx[14]],
-      tab[idx[15]]));
-}
-inline v_int16x16 v256_lut_pairs(const short *tab, const int *idx) {
-  return v_int16x16(_mm256_i32gather_epi32(
-      (const int *)tab, _mm256_loadu_si256((const __m256i *)idx), 2));
-}
-inline v_int16x16 v256_lut_quads(const short *tab, const int *idx) {
-#if defined(__GNUC__)
-  return v_int16x16(_mm256_i32gather_epi64(
-      (const long long int *)tab, _mm_loadu_si128((const __m128i *)idx),
-      2)); // Looks like intrinsic has wrong definition
-#else
-  return v_int16x16(_mm256_i32gather_epi64(
-      (const int64 *)tab, _mm_loadu_si128((const __m128i *)idx), 2));
-#endif
-}
-inline v_uint16x16 v256_lut(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v256_lut((const short *)tab, idx));
-}
-inline v_uint16x16 v256_lut_pairs(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v256_lut_pairs((const short *)tab, idx));
-}
-inline v_uint16x16 v256_lut_quads(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v256_lut_quads((const short *)tab, idx));
-}
-
-inline v_int32x8 v256_lut(const int *tab, const int *idx) {
-  return v_int32x8(
-      _mm256_i32gather_epi32(tab, _mm256_loadu_si256((const __m256i *)idx), 4));
-}
-inline v_int32x8 v256_lut_pairs(const int *tab, const int *idx) {
-#if defined(__GNUC__)
-  return v_int32x8(_mm256_i32gather_epi64(
-      (const long long int *)tab, _mm_loadu_si128((const __m128i *)idx), 4));
-#else
-  return v_int32x8(_mm256_i32gather_epi64(
-      (const int64 *)tab, _mm_loadu_si128((const __m128i *)idx), 4));
-#endif
-}
-inline v_int32x8 v256_lut_quads(const int *tab, const int *idx) {
-  return v_int32x8(
-      _v256_combine(_mm_loadu_si128((const __m128i *)(tab + idx[0])),
-                    _mm_loadu_si128((const __m128i *)(tab + idx[1]))));
-}
-inline v_uint32x8 v256_lut(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v256_lut((const int *)tab, idx));
-}
-inline v_uint32x8 v256_lut_pairs(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v256_lut_pairs((const int *)tab, idx));
-}
-inline v_uint32x8 v256_lut_quads(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v256_lut_quads((const int *)tab, idx));
-}
-
-inline v_int64x4 v256_lut(const int64 *tab, const int *idx) {
-#if defined(__GNUC__)
-  return v_int64x4(_mm256_i32gather_epi64(
-      (const long long int *)tab, _mm_loadu_si128((const __m128i *)idx), 8));
-#else
-  return v_int64x4(
-      _mm256_i32gather_epi64(tab, _mm_loadu_si128((const __m128i *)idx), 8));
-#endif
-}
-inline v_int64x4 v256_lut_pairs(const int64 *tab, const int *idx) {
-  return v_int64x4(
-      _v256_combine(_mm_loadu_si128((const __m128i *)(tab + idx[0])),
-                    _mm_loadu_si128((const __m128i *)(tab + idx[1]))));
-}
-inline v_uint64x4 v256_lut(const uint64 *tab, const int *idx) {
-  return v_reinterpret_as_u64(v256_lut((const int64 *)tab, idx));
-}
-inline v_uint64x4 v256_lut_pairs(const uint64 *tab, const int *idx) {
-  return v_reinterpret_as_u64(v256_lut_pairs((const int64 *)tab, idx));
-}
-
-inline v_float32x8 v256_lut(const float *tab, const int *idx) {
-  return v_float32x8(
-      _mm256_i32gather_ps(tab, _mm256_loadu_si256((const __m256i *)idx), 4));
-}
-inline v_float32x8 v256_lut_pairs(const float *tab, const int *idx) {
-  return v_reinterpret_as_f32(v256_lut_pairs((const int *)tab, idx));
-}
-inline v_float32x8 v256_lut_quads(const float *tab, const int *idx) {
-  return v_reinterpret_as_f32(v256_lut_quads((const int *)tab, idx));
-}
-
-inline v_float64x4 v256_lut(const double *tab, const int *idx) {
-  return v_float64x4(
-      _mm256_i32gather_pd(tab, _mm_loadu_si128((const __m128i *)idx), 8));
-}
-inline v_float64x4 v256_lut_pairs(const double *tab, const int *idx) {
-  return v_float64x4(
-      _v256_combine(_mm_loadu_pd(tab + idx[0]), _mm_loadu_pd(tab + idx[1])));
-}
-
-inline v_int32x8 v_lut(const int *tab, const v_int32x8 &idxvec) {
-  return v_int32x8(_mm256_i32gather_epi32(tab, idxvec.val, 4));
-}
-
-inline v_uint32x8 v_lut(const unsigned *tab, const v_int32x8 &idxvec) {
-  return v_reinterpret_as_u32(v_lut((const int *)tab, idxvec));
-}
-
-inline v_float32x8 v_lut(const float *tab, const v_int32x8 &idxvec) {
-  return v_float32x8(_mm256_i32gather_ps(tab, idxvec.val, 4));
-}
-
-inline v_float64x4 v_lut(const double *tab, const v_int32x8 &idxvec) {
-  return v_float64x4(
-      _mm256_i32gather_pd(tab, _mm256_castsi256_si128(idxvec.val), 8));
-}
-
-inline void v_lut_deinterleave(const float *tab, const v_int32x8 &idxvec,
-                               v_float32x8 &x, v_float32x8 &y) {
-  int CV_DECL_ALIGNED(32) idx[8];
-  v_store_aligned(idx, idxvec);
-  __m128 z = _mm_setzero_ps();
-  __m128 xy01, xy45, xy23, xy67;
-  xy01 = _mm_loadl_pi(z, (const __m64 *)(tab + idx[0]));
-  xy01 = _mm_loadh_pi(xy01, (const __m64 *)(tab + idx[1]));
-  xy45 = _mm_loadl_pi(z, (const __m64 *)(tab + idx[4]));
-  xy45 = _mm_loadh_pi(xy45, (const __m64 *)(tab + idx[5]));
-  __m256 xy0145 = _v256_combine(xy01, xy45);
-  xy23 = _mm_loadl_pi(z, (const __m64 *)(tab + idx[2]));
-  xy23 = _mm_loadh_pi(xy23, (const __m64 *)(tab + idx[3]));
-  xy67 = _mm_loadl_pi(z, (const __m64 *)(tab + idx[6]));
-  xy67 = _mm_loadh_pi(xy67, (const __m64 *)(tab + idx[7]));
-  __m256 xy2367 = _v256_combine(xy23, xy67);
-
-  __m256 xxyy0145 = _mm256_unpacklo_ps(xy0145, xy2367);
-  __m256 xxyy2367 = _mm256_unpackhi_ps(xy0145, xy2367);
-
-  x = v_float32x8(_mm256_unpacklo_ps(xxyy0145, xxyy2367));
-  y = v_float32x8(_mm256_unpackhi_ps(xxyy0145, xxyy2367));
-}
-
-inline void v_lut_deinterleave(const double *tab, const v_int32x8 &idxvec,
-                               v_float64x4 &x, v_float64x4 &y) {
-  int CV_DECL_ALIGNED(32) idx[4];
-  v_store_low(idx, idxvec);
-  __m128d xy0 = _mm_loadu_pd(tab + idx[0]);
-  __m128d xy2 = _mm_loadu_pd(tab + idx[2]);
-  __m128d xy1 = _mm_loadu_pd(tab + idx[1]);
-  __m128d xy3 = _mm_loadu_pd(tab + idx[3]);
-  __m256d xy02 = _v256_combine(xy0, xy2);
-  __m256d xy13 = _v256_combine(xy1, xy3);
-
-  x = v_float64x4(_mm256_unpacklo_pd(xy02, xy13));
-  y = v_float64x4(_mm256_unpackhi_pd(xy02, xy13));
-}
-
-inline v_int8x32 v_interleave_pairs(const v_int8x32 &vec) {
-  return v_int8x32(_mm256_shuffle_epi8(
-      vec.val, _mm256_set_epi64x(0x0f0d0e0c0b090a08, 0x0705060403010200,
-                                 0x0f0d0e0c0b090a08, 0x0705060403010200)));
-}
-inline v_uint8x32 v_interleave_pairs(const v_uint8x32 &vec) {
-  return v_reinterpret_as_u8(v_interleave_pairs(v_reinterpret_as_s8(vec)));
-}
-inline v_int8x32 v_interleave_quads(const v_int8x32 &vec) {
-  return v_int8x32(_mm256_shuffle_epi8(
-      vec.val, _mm256_set_epi64x(0x0f0b0e0a0d090c08, 0x0703060205010400,
-                                 0x0f0b0e0a0d090c08, 0x0703060205010400)));
-}
-inline v_uint8x32 v_interleave_quads(const v_uint8x32 &vec) {
-  return v_reinterpret_as_u8(v_interleave_quads(v_reinterpret_as_s8(vec)));
-}
-
-inline v_int16x16 v_interleave_pairs(const v_int16x16 &vec) {
-  return v_int16x16(_mm256_shuffle_epi8(
-      vec.val, _mm256_set_epi64x(0x0f0e0b0a0d0c0908, 0x0706030205040100,
-                                 0x0f0e0b0a0d0c0908, 0x0706030205040100)));
-}
-inline v_uint16x16 v_interleave_pairs(const v_uint16x16 &vec) {
-  return v_reinterpret_as_u16(v_interleave_pairs(v_reinterpret_as_s16(vec)));
-}
-inline v_int16x16 v_interleave_quads(const v_int16x16 &vec) {
-  return v_int16x16(_mm256_shuffle_epi8(
-      vec.val, _mm256_set_epi64x(0x0f0e07060d0c0504, 0x0b0a030209080100,
-                                 0x0f0e07060d0c0504, 0x0b0a030209080100)));
-}
-inline v_uint16x16 v_interleave_quads(const v_uint16x16 &vec) {
-  return v_reinterpret_as_u16(v_interleave_quads(v_reinterpret_as_s16(vec)));
-}
-
-inline v_int32x8 v_interleave_pairs(const v_int32x8 &vec) {
-  return v_int32x8(_mm256_shuffle_epi32(vec.val, _MM_SHUFFLE(3, 1, 2, 0)));
-}
-inline v_uint32x8 v_interleave_pairs(const v_uint32x8 &vec) {
-  return v_reinterpret_as_u32(v_interleave_pairs(v_reinterpret_as_s32(vec)));
-}
-inline v_float32x8 v_interleave_pairs(const v_float32x8 &vec) {
-  return v_reinterpret_as_f32(v_interleave_pairs(v_reinterpret_as_s32(vec)));
-}
-
-inline v_int8x32 v_pack_triplets(const v_int8x32 &vec) {
-  return v_int8x32(_mm256_permutevar8x32_epi32(
-      _mm256_shuffle_epi8(
-          vec.val, _mm256_broadcastsi128_si256(
-                       _mm_set_epi64x(0xffffff0f0e0d0c0a, 0x0908060504020100))),
-      _mm256_set_epi64x(0x0000000700000007, 0x0000000600000005,
-                        0x0000000400000002, 0x0000000100000000)));
-}
-inline v_uint8x32 v_pack_triplets(const v_uint8x32 &vec) {
-  return v_reinterpret_as_u8(v_pack_triplets(v_reinterpret_as_s8(vec)));
-}
-
-inline v_int16x16 v_pack_triplets(const v_int16x16 &vec) {
-  return v_int16x16(_mm256_permutevar8x32_epi32(
-      _mm256_shuffle_epi8(
-          vec.val, _mm256_broadcastsi128_si256(
-                       _mm_set_epi64x(0xffff0f0e0d0c0b0a, 0x0908050403020100))),
-      _mm256_set_epi64x(0x0000000700000007, 0x0000000600000005,
-                        0x0000000400000002, 0x0000000100000000)));
-}
-inline v_uint16x16 v_pack_triplets(const v_uint16x16 &vec) {
-  return v_reinterpret_as_u16(v_pack_triplets(v_reinterpret_as_s16(vec)));
-}
-
-inline v_int32x8 v_pack_triplets(const v_int32x8 &vec) {
-  return v_int32x8(_mm256_permutevar8x32_epi32(
-      vec.val, _mm256_set_epi64x(0x0000000700000007, 0x0000000600000005,
-                                 0x0000000400000002, 0x0000000100000000)));
-}
-inline v_uint32x8 v_pack_triplets(const v_uint32x8 &vec) {
-  return v_reinterpret_as_u32(v_pack_triplets(v_reinterpret_as_s32(vec)));
-}
-inline v_float32x8 v_pack_triplets(const v_float32x8 &vec) {
-  return v_float32x8(_mm256_permutevar8x32_ps(
-      vec.val, _mm256_set_epi64x(0x0000000700000007, 0x0000000600000005,
-                                 0x0000000400000002, 0x0000000100000000)));
-}
-
-////////// Matrix operations /////////
-
-//////// Dot Product ////////
-
-// 16 >> 32
-inline v_int32x8 v_dotprod(const v_int16x16 &a, const v_int16x16 &b) {
-  return v_int32x8(_mm256_madd_epi16(a.val, b.val));
-}
-inline v_int32x8 v_dotprod(const v_int16x16 &a, const v_int16x16 &b,
-                           const v_int32x8 &c) {
-  return v_add(v_dotprod(a, b), c);
-}
-
-// 32 >> 64
-inline v_int64x4 v_dotprod(const v_int32x8 &a, const v_int32x8 &b) {
-  __m256i even = _mm256_mul_epi32(a.val, b.val);
-  __m256i odd = _mm256_mul_epi32(_mm256_srli_epi64(a.val, 32),
-                                 _mm256_srli_epi64(b.val, 32));
-  return v_int64x4(_mm256_add_epi64(even, odd));
-}
-inline v_int64x4 v_dotprod(const v_int32x8 &a, const v_int32x8 &b,
-                           const v_int64x4 &c) {
-  return v_add(v_dotprod(a, b), c);
-}
-
-// 8 >> 32
-inline v_uint32x8 v_dotprod_expand(const v_uint8x32 &a, const v_uint8x32 &b) {
-  __m256i even_m = _mm256_set1_epi32(0xFF00FF00);
-  __m256i even_a = _mm256_blendv_epi8(a.val, _mm256_setzero_si256(), even_m);
-  __m256i odd_a = _mm256_srli_epi16(a.val, 8);
-
-  __m256i even_b = _mm256_blendv_epi8(b.val, _mm256_setzero_si256(), even_m);
-  __m256i odd_b = _mm256_srli_epi16(b.val, 8);
-
-  __m256i prod0 = _mm256_madd_epi16(even_a, even_b);
-  __m256i prod1 = _mm256_madd_epi16(odd_a, odd_b);
-  return v_uint32x8(_mm256_add_epi32(prod0, prod1));
-}
-inline v_uint32x8 v_dotprod_expand(const v_uint8x32 &a, const v_uint8x32 &b,
-                                   const v_uint32x8 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-inline v_int32x8 v_dotprod_expand(const v_int8x32 &a, const v_int8x32 &b) {
-  __m256i even_a = _mm256_srai_epi16(_mm256_bslli_epi128(a.val, 1), 8);
-  __m256i odd_a = _mm256_srai_epi16(a.val, 8);
-
-  __m256i even_b = _mm256_srai_epi16(_mm256_bslli_epi128(b.val, 1), 8);
-  __m256i odd_b = _mm256_srai_epi16(b.val, 8);
-
-  __m256i prod0 = _mm256_madd_epi16(even_a, even_b);
-  __m256i prod1 = _mm256_madd_epi16(odd_a, odd_b);
-  return v_int32x8(_mm256_add_epi32(prod0, prod1));
-}
-inline v_int32x8 v_dotprod_expand(const v_int8x32 &a, const v_int8x32 &b,
-                                  const v_int32x8 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-// 16 >> 64
-inline v_uint64x4 v_dotprod_expand(const v_uint16x16 &a, const v_uint16x16 &b) {
-  __m256i mullo = _mm256_mullo_epi16(a.val, b.val);
-  __m256i mulhi = _mm256_mulhi_epu16(a.val, b.val);
-  __m256i mul0 = _mm256_unpacklo_epi16(mullo, mulhi);
-  __m256i mul1 = _mm256_unpackhi_epi16(mullo, mulhi);
-
-  __m256i p02 = _mm256_blend_epi32(mul0, _mm256_setzero_si256(), 0xAA);
-  __m256i p13 = _mm256_srli_epi64(mul0, 32);
-  __m256i p46 = _mm256_blend_epi32(mul1, _mm256_setzero_si256(), 0xAA);
-  __m256i p57 = _mm256_srli_epi64(mul1, 32);
-
-  __m256i p15_ = _mm256_add_epi64(p02, p13);
-  __m256i p9d_ = _mm256_add_epi64(p46, p57);
-
-  return v_uint64x4(_mm256_add_epi64(_mm256_unpacklo_epi64(p15_, p9d_),
-                                     _mm256_unpackhi_epi64(p15_, p9d_)));
-}
-inline v_uint64x4 v_dotprod_expand(const v_uint16x16 &a, const v_uint16x16 &b,
-                                   const v_uint64x4 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-inline v_int64x4 v_dotprod_expand(const v_int16x16 &a, const v_int16x16 &b) {
-  __m256i prod = _mm256_madd_epi16(a.val, b.val);
-  __m256i sign = _mm256_srai_epi32(prod, 31);
-
-  __m256i lo = _mm256_unpacklo_epi32(prod, sign);
-  __m256i hi = _mm256_unpackhi_epi32(prod, sign);
-
-  return v_int64x4(_mm256_add_epi64(_mm256_unpacklo_epi64(lo, hi),
-                                    _mm256_unpackhi_epi64(lo, hi)));
-}
-inline v_int64x4 v_dotprod_expand(const v_int16x16 &a, const v_int16x16 &b,
-                                  const v_int64x4 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-// 32 >> 64f
-inline v_float64x4 v_dotprod_expand(const v_int32x8 &a, const v_int32x8 &b) {
-  return v_cvt_f64(v_dotprod(a, b));
-}
-inline v_float64x4 v_dotprod_expand(const v_int32x8 &a, const v_int32x8 &b,
-                                    const v_float64x4 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-//////// Fast Dot Product ////////
-
-// 16 >> 32
-inline v_int32x8 v_dotprod_fast(const v_int16x16 &a, const v_int16x16 &b) {
-  return v_dotprod(a, b);
-}
-inline v_int32x8 v_dotprod_fast(const v_int16x16 &a, const v_int16x16 &b,
-                                const v_int32x8 &c) {
-  return v_dotprod(a, b, c);
-}
-
-// 32 >> 64
-inline v_int64x4 v_dotprod_fast(const v_int32x8 &a, const v_int32x8 &b) {
-  return v_dotprod(a, b);
-}
-inline v_int64x4 v_dotprod_fast(const v_int32x8 &a, const v_int32x8 &b,
-                                const v_int64x4 &c) {
-  return v_dotprod(a, b, c);
-}
-
-// 8 >> 32
-inline v_uint32x8 v_dotprod_expand_fast(const v_uint8x32 &a,
-                                        const v_uint8x32 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_uint32x8 v_dotprod_expand_fast(const v_uint8x32 &a,
-                                        const v_uint8x32 &b,
-                                        const v_uint32x8 &c) {
-  return v_dotprod_expand(a, b, c);
-}
-
-inline v_int32x8 v_dotprod_expand_fast(const v_int8x32 &a, const v_int8x32 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_int32x8 v_dotprod_expand_fast(const v_int8x32 &a, const v_int8x32 &b,
-                                       const v_int32x8 &c) {
-  return v_dotprod_expand(a, b, c);
-}
-
-// 16 >> 64
-inline v_uint64x4 v_dotprod_expand_fast(const v_uint16x16 &a,
-                                        const v_uint16x16 &b) {
-  __m256i mullo = _mm256_mullo_epi16(a.val, b.val);
-  __m256i mulhi = _mm256_mulhi_epu16(a.val, b.val);
-  __m256i mul0 = _mm256_unpacklo_epi16(mullo, mulhi);
-  __m256i mul1 = _mm256_unpackhi_epi16(mullo, mulhi);
-
-  __m256i p02 = _mm256_blend_epi32(mul0, _mm256_setzero_si256(), 0xAA);
-  __m256i p13 = _mm256_srli_epi64(mul0, 32);
-  __m256i p46 = _mm256_blend_epi32(mul1, _mm256_setzero_si256(), 0xAA);
-  __m256i p57 = _mm256_srli_epi64(mul1, 32);
-
-  __m256i p15_ = _mm256_add_epi64(p02, p13);
-  __m256i p9d_ = _mm256_add_epi64(p46, p57);
-
-  return v_uint64x4(_mm256_add_epi64(p15_, p9d_));
-}
-inline v_uint64x4 v_dotprod_expand_fast(const v_uint16x16 &a,
-                                        const v_uint16x16 &b,
-                                        const v_uint64x4 &c) {
-  return v_add(v_dotprod_expand_fast(a, b), c);
-}
-
-inline v_int64x4 v_dotprod_expand_fast(const v_int16x16 &a,
-                                       const v_int16x16 &b) {
-  __m256i prod = _mm256_madd_epi16(a.val, b.val);
-  __m256i sign = _mm256_srai_epi32(prod, 31);
-  __m256i lo = _mm256_unpacklo_epi32(prod, sign);
-  __m256i hi = _mm256_unpackhi_epi32(prod, sign);
-  return v_int64x4(_mm256_add_epi64(lo, hi));
-}
-inline v_int64x4 v_dotprod_expand_fast(const v_int16x16 &a, const v_int16x16 &b,
-                                       const v_int64x4 &c) {
-  return v_add(v_dotprod_expand_fast(a, b), c);
-}
-
-// 32 >> 64f
-inline v_float64x4 v_dotprod_expand_fast(const v_int32x8 &a,
-                                         const v_int32x8 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_float64x4 v_dotprod_expand_fast(const v_int32x8 &a, const v_int32x8 &b,
-                                         const v_float64x4 &c) {
-  return v_dotprod_expand(a, b, c);
-}
-
-#define OPENCV_HAL_AVX_SPLAT2_PS(a, im)                                        \
-  v_float32x8(_mm256_permute_ps(a.val, _MM_SHUFFLE(im, im, im, im)))
-
-inline v_float32x8 v_matmul(const v_float32x8 &v, const v_float32x8 &m0,
-                            const v_float32x8 &m1, const v_float32x8 &m2,
-                            const v_float32x8 &m3) {
-  v_float32x8 v04 = OPENCV_HAL_AVX_SPLAT2_PS(v, 0);
-  v_float32x8 v15 = OPENCV_HAL_AVX_SPLAT2_PS(v, 1);
-  v_float32x8 v26 = OPENCV_HAL_AVX_SPLAT2_PS(v, 2);
-  v_float32x8 v37 = OPENCV_HAL_AVX_SPLAT2_PS(v, 3);
-  return v_fma(v04, m0, v_fma(v15, m1, v_fma(v26, m2, v_mul(v37, m3))));
-}
-
-inline v_float32x8 v_matmuladd(const v_float32x8 &v, const v_float32x8 &m0,
-                               const v_float32x8 &m1, const v_float32x8 &m2,
-                               const v_float32x8 &a) {
-  v_float32x8 v04 = OPENCV_HAL_AVX_SPLAT2_PS(v, 0);
-  v_float32x8 v15 = OPENCV_HAL_AVX_SPLAT2_PS(v, 1);
-  v_float32x8 v26 = OPENCV_HAL_AVX_SPLAT2_PS(v, 2);
-  return v_fma(v04, m0, v_fma(v15, m1, v_fma(v26, m2, a)));
-}
-
-#define OPENCV_HAL_IMPL_AVX_TRANSPOSE4x4(_Tpvec, suffix, cast_from, cast_to)   \
-  inline void v_transpose4x4(const _Tpvec &a0, const _Tpvec &a1,               \
-                             const _Tpvec &a2, const _Tpvec &a3, _Tpvec &b0,   \
-                             _Tpvec &b1, _Tpvec &b2, _Tpvec &b3) {             \
-    __m256i t0 = cast_from(_mm256_unpacklo_##suffix(a0.val, a1.val));          \
-    __m256i t1 = cast_from(_mm256_unpacklo_##suffix(a2.val, a3.val));          \
-    __m256i t2 = cast_from(_mm256_unpackhi_##suffix(a0.val, a1.val));          \
-    __m256i t3 = cast_from(_mm256_unpackhi_##suffix(a2.val, a3.val));          \
-    b0.val = cast_to(_mm256_unpacklo_epi64(t0, t1));                           \
-    b1.val = cast_to(_mm256_unpackhi_epi64(t0, t1));                           \
-    b2.val = cast_to(_mm256_unpacklo_epi64(t2, t3));                           \
-    b3.val = cast_to(_mm256_unpackhi_epi64(t2, t3));                           \
-  }
-
-OPENCV_HAL_IMPL_AVX_TRANSPOSE4x4(v_uint32x8, epi32, OPENCV_HAL_NOP,
-                                 OPENCV_HAL_NOP)
-    OPENCV_HAL_IMPL_AVX_TRANSPOSE4x4(v_int32x8, epi32, OPENCV_HAL_NOP,
-                                     OPENCV_HAL_NOP)
-        OPENCV_HAL_IMPL_AVX_TRANSPOSE4x4(v_float32x8, ps, _mm256_castps_si256,
-                                         _mm256_castsi256_ps)
-
-//////////////// Value reordering ///////////////
-
-/* Expand */
-#define OPENCV_HAL_IMPL_AVX_EXPAND(_Tpvec, _Tpwvec, _Tp, intrin)               \
-  inline void v_expand(const _Tpvec &a, _Tpwvec &b0, _Tpwvec &b1) {            \
-    b0.val = intrin(_v256_extract_low(a.val));                                 \
-    b1.val = intrin(_v256_extract_high(a.val));                                \
-  }                                                                            \
-  inline _Tpwvec v_expand_low(const _Tpvec &a) {                               \
-    return _Tpwvec(intrin(_v256_extract_low(a.val)));                          \
-  }                                                                            \
-  inline _Tpwvec v_expand_high(const _Tpvec &a) {                              \
-    return _Tpwvec(intrin(_v256_extract_high(a.val)));                         \
-  }                                                                            \
-  inline _Tpwvec v256_load_expand(const _Tp *ptr) {                            \
-    __m128i a = _mm_loadu_si128((const __m128i *)ptr);                         \
-    return _Tpwvec(intrin(a));                                                 \
-  }
-
-            OPENCV_HAL_IMPL_AVX_EXPAND(v_uint8x32, v_uint16x16, uchar,
-                                       _mm256_cvtepu8_epi16)
-                OPENCV_HAL_IMPL_AVX_EXPAND(v_int8x32, v_int16x16, schar,
-                                           _mm256_cvtepi8_epi16)
-                    OPENCV_HAL_IMPL_AVX_EXPAND(v_uint16x16, v_uint32x8, ushort,
-                                               _mm256_cvtepu16_epi32)
-                        OPENCV_HAL_IMPL_AVX_EXPAND(v_int16x16, v_int32x8, short,
-                                                   _mm256_cvtepi16_epi32)
-                            OPENCV_HAL_IMPL_AVX_EXPAND(v_uint32x8, v_uint64x4,
-                                                       unsigned,
-                                                       _mm256_cvtepu32_epi64)
-                                OPENCV_HAL_IMPL_AVX_EXPAND(
-                                    v_int32x8, v_int64x4, int,
-                                    _mm256_cvtepi32_epi64)
-
-#define OPENCV_HAL_IMPL_AVX_EXPAND_Q(_Tpvec, _Tp, intrin)                      \
-  inline _Tpvec v256_load_expand_q(const _Tp *ptr) {                           \
-    __m128i a = _mm_loadl_epi64((const __m128i *)ptr);                         \
-    return _Tpvec(intrin(a));                                                  \
-  }
-
-                                    OPENCV_HAL_IMPL_AVX_EXPAND_Q(
-                                        v_uint32x8, uchar, _mm256_cvtepu8_epi32)
-                                        OPENCV_HAL_IMPL_AVX_EXPAND_Q(
-                                            v_int32x8, schar,
-                                            _mm256_cvtepi8_epi32)
-
-    /* pack */
-    // 16
-    inline v_int8x32 v_pack(const v_int16x16 &a, const v_int16x16 &b) {
-  return v_int8x32(_v256_shuffle_odd_64(_mm256_packs_epi16(a.val, b.val)));
-}
-
-inline v_uint8x32 v_pack(const v_uint16x16 &a, const v_uint16x16 &b) {
-  __m256i t = _mm256_set1_epi16(255);
-  __m256i a1 = _mm256_min_epu16(a.val, t);
-  __m256i b1 = _mm256_min_epu16(b.val, t);
-  return v_uint8x32(_v256_shuffle_odd_64(_mm256_packus_epi16(a1, b1)));
-}
-
-inline v_uint8x32 v_pack_u(const v_int16x16 &a, const v_int16x16 &b) {
-  return v_uint8x32(_v256_shuffle_odd_64(_mm256_packus_epi16(a.val, b.val)));
-}
-
-inline void v_pack_store(schar *ptr, const v_int16x16 &a) {
-  v_store_low(ptr, v_pack(a, a));
-}
-
-inline void v_pack_store(uchar *ptr, const v_uint16x16 &a) {
-  const __m256i m = _mm256_set1_epi16(255);
-  __m256i am = _mm256_min_epu16(a.val, m);
-  am = _v256_shuffle_odd_64(_mm256_packus_epi16(am, am));
-  v_store_low(ptr, v_uint8x32(am));
-}
-
-inline void v_pack_u_store(uchar *ptr, const v_int16x16 &a) {
-  v_store_low(ptr, v_pack_u(a, a));
-}
-
-template <int n>
-inline v_uint8x32 v_rshr_pack(const v_uint16x16 &a, const v_uint16x16 &b) {
-  // we assume that n > 0, and so the shifted 16-bit values can be treated as
-  // signed numbers.
-  v_uint16x16 delta = v256_setall_u16((short)(1 << (n - 1)));
-  return v_pack_u(v_reinterpret_as_s16(v_shr(v_add(a, delta), n)),
-                  v_reinterpret_as_s16(v_shr(v_add(b, delta), n)));
-}
-
-template <int n>
-inline void v_rshr_pack_store(uchar *ptr, const v_uint16x16 &a) {
-  v_uint16x16 delta = v256_setall_u16((short)(1 << (n - 1)));
-  v_pack_u_store(ptr, v_reinterpret_as_s16(v_shr(v_add(a, delta), n)));
-}
-
-template <int n>
-inline v_uint8x32 v_rshr_pack_u(const v_int16x16 &a, const v_int16x16 &b) {
-  v_int16x16 delta = v256_setall_s16((short)(1 << (n - 1)));
-  return v_pack_u(v_shr(v_add(a, delta), n), v_shr(v_add(b, delta), n));
-}
-
-template <int n>
-inline void v_rshr_pack_u_store(uchar *ptr, const v_int16x16 &a) {
-  v_int16x16 delta = v256_setall_s16((short)(1 << (n - 1)));
-  v_pack_u_store(ptr, v_shr(v_add(a, delta), n));
-}
-
-template <int n>
-inline v_int8x32 v_rshr_pack(const v_int16x16 &a, const v_int16x16 &b) {
-  v_int16x16 delta = v256_setall_s16((short)(1 << (n - 1)));
-  return v_pack(v_shr(v_add(a, delta), n), v_shr(v_add(b, delta), n));
-}
-
-template <int n>
-inline void v_rshr_pack_store(schar *ptr, const v_int16x16 &a) {
-  v_int16x16 delta = v256_setall_s16((short)(1 << (n - 1)));
-  v_pack_store(ptr, v_shr(v_add(a, delta), n));
-}
-
-// 32
-inline v_int16x16 v_pack(const v_int32x8 &a, const v_int32x8 &b) {
-  return v_int16x16(_v256_shuffle_odd_64(_mm256_packs_epi32(a.val, b.val)));
-}
-
-inline v_uint16x16 v_pack(const v_uint32x8 &a, const v_uint32x8 &b) {
-  return v_uint16x16(_v256_shuffle_odd_64(_v256_packs_epu32(a.val, b.val)));
-}
-
-inline v_uint16x16 v_pack_u(const v_int32x8 &a, const v_int32x8 &b) {
-  return v_uint16x16(_v256_shuffle_odd_64(_mm256_packus_epi32(a.val, b.val)));
-}
-
-inline void v_pack_store(short *ptr, const v_int32x8 &a) {
-  v_store_low(ptr, v_pack(a, a));
-}
-
-inline void v_pack_store(ushort *ptr, const v_uint32x8 &a) {
-  const __m256i m = _mm256_set1_epi32(65535);
-  __m256i am = _mm256_min_epu32(a.val, m);
-  am = _v256_shuffle_odd_64(_mm256_packus_epi32(am, am));
-  v_store_low(ptr, v_uint16x16(am));
-}
-
-inline void v_pack_u_store(ushort *ptr, const v_int32x8 &a) {
-  v_store_low(ptr, v_pack_u(a, a));
-}
-
-template <int n>
-inline v_uint16x16 v_rshr_pack(const v_uint32x8 &a, const v_uint32x8 &b) {
-  // we assume that n > 0, and so the shifted 32-bit values can be treated as
-  // signed numbers.
-  v_uint32x8 delta = v256_setall_u32(1 << (n - 1));
-  return v_pack_u(v_reinterpret_as_s32(v_shr(v_add(a, delta), n)),
-                  v_reinterpret_as_s32(v_shr(v_add(b, delta), n)));
-}
-
-template <int n>
-inline void v_rshr_pack_store(ushort *ptr, const v_uint32x8 &a) {
-  v_uint32x8 delta = v256_setall_u32(1 << (n - 1));
-  v_pack_u_store(ptr, v_reinterpret_as_s32(v_shr(v_add(a, delta), n)));
-}
-
-template <int n>
-inline v_uint16x16 v_rshr_pack_u(const v_int32x8 &a, const v_int32x8 &b) {
-  v_int32x8 delta = v256_setall_s32(1 << (n - 1));
-  return v_pack_u(v_shr(v_add(a, delta), n), v_shr(v_add(b, delta), n));
-}
-
-template <int n>
-inline void v_rshr_pack_u_store(ushort *ptr, const v_int32x8 &a) {
-  v_int32x8 delta = v256_setall_s32(1 << (n - 1));
-  v_pack_u_store(ptr, v_shr(v_add(a, delta), n));
-}
-
-template <int n>
-inline v_int16x16 v_rshr_pack(const v_int32x8 &a, const v_int32x8 &b) {
-  v_int32x8 delta = v256_setall_s32(1 << (n - 1));
-  return v_pack(v_shr(v_add(a, delta), n), v_shr(v_add(b, delta), n));
-}
-
-template <int n> inline void v_rshr_pack_store(short *ptr, const v_int32x8 &a) {
-  v_int32x8 delta = v256_setall_s32(1 << (n - 1));
-  v_pack_store(ptr, v_shr(v_add(a, delta), n));
-}
-
-// 64
-// Non-saturating pack
-inline v_uint32x8 v_pack(const v_uint64x4 &a, const v_uint64x4 &b) {
-  __m256i a0 = _mm256_shuffle_epi32(a.val, _MM_SHUFFLE(0, 0, 2, 0));
-  __m256i b0 = _mm256_shuffle_epi32(b.val, _MM_SHUFFLE(0, 0, 2, 0));
-  __m256i ab = _mm256_unpacklo_epi64(a0, b0); // a0, a1, b0, b1, a2, a3, b2, b3
-  return v_uint32x8(_v256_shuffle_odd_64(ab));
-}
-
-inline v_int32x8 v_pack(const v_int64x4 &a, const v_int64x4 &b) {
-  return v_reinterpret_as_s32(
-      v_pack(v_reinterpret_as_u64(a), v_reinterpret_as_u64(b)));
-}
-
-inline void v_pack_store(unsigned *ptr, const v_uint64x4 &a) {
-  __m256i a0 = _mm256_shuffle_epi32(a.val, _MM_SHUFFLE(0, 0, 2, 0));
-  v_store_low(ptr, v_uint32x8(_v256_shuffle_odd_64(a0)));
-}
-
-inline void v_pack_store(int *ptr, const v_int64x4 &b) {
-  v_pack_store((unsigned *)ptr, v_reinterpret_as_u64(b));
-}
-
-template <int n>
-inline v_uint32x8 v_rshr_pack(const v_uint64x4 &a, const v_uint64x4 &b) {
-  v_uint64x4 delta = v256_setall_u64((uint64)1 << (n - 1));
-  return v_pack(v_shr(v_add(a, delta), n), v_shr(v_add(b, delta), n));
-}
-
-template <int n>
-inline void v_rshr_pack_store(unsigned *ptr, const v_uint64x4 &a) {
-  v_uint64x4 delta = v256_setall_u64((uint64)1 << (n - 1));
-  v_pack_store(ptr, v_shr(v_add(a, delta), n));
-}
-
-template <int n>
-inline v_int32x8 v_rshr_pack(const v_int64x4 &a, const v_int64x4 &b) {
-  v_int64x4 delta = v256_setall_s64((int64)1 << (n - 1));
-  return v_pack(v_shr(v_add(a, delta), n), v_shr(v_add(b, delta), n));
-}
-
-template <int n> inline void v_rshr_pack_store(int *ptr, const v_int64x4 &a) {
-  v_int64x4 delta = v256_setall_s64((int64)1 << (n - 1));
-  v_pack_store(ptr, v_shr(v_add(a, delta), n));
-}
-
-// pack boolean
-inline v_uint8x32 v_pack_b(const v_uint16x16 &a, const v_uint16x16 &b) {
-  __m256i ab = _mm256_packs_epi16(a.val, b.val);
-  return v_uint8x32(_v256_shuffle_odd_64(ab));
-}
-
-inline v_uint8x32 v_pack_b(const v_uint32x8 &a, const v_uint32x8 &b,
-                           const v_uint32x8 &c, const v_uint32x8 &d) {
-  __m256i ab = _mm256_packs_epi32(a.val, b.val);
-  __m256i cd = _mm256_packs_epi32(c.val, d.val);
-
-  __m256i abcd = _v256_shuffle_odd_64(_mm256_packs_epi16(ab, cd));
-  return v_uint8x32(_mm256_shuffle_epi32(abcd, _MM_SHUFFLE(3, 1, 2, 0)));
-}
-
-inline v_uint8x32 v_pack_b(const v_uint64x4 &a, const v_uint64x4 &b,
-                           const v_uint64x4 &c, const v_uint64x4 &d,
-                           const v_uint64x4 &e, const v_uint64x4 &f,
-                           const v_uint64x4 &g, const v_uint64x4 &h) {
-  __m256i ab = _mm256_packs_epi32(a.val, b.val);
-  __m256i cd = _mm256_packs_epi32(c.val, d.val);
-  __m256i ef = _mm256_packs_epi32(e.val, f.val);
-  __m256i gh = _mm256_packs_epi32(g.val, h.val);
-
-  __m256i abcd = _mm256_packs_epi32(ab, cd);
-  __m256i efgh = _mm256_packs_epi32(ef, gh);
-  __m256i pkall = _v256_shuffle_odd_64(_mm256_packs_epi16(abcd, efgh));
-
-  __m256i rev = _mm256_alignr_epi8(pkall, pkall, 8);
-  return v_uint8x32(_mm256_unpacklo_epi16(pkall, rev));
-}
-
-/* Recombine */
-// its up there with load and store operations
-
-/* Extract */
-#define OPENCV_HAL_IMPL_AVX_EXTRACT(_Tpvec)                                    \
-  template <int s> inline _Tpvec v_extract(const _Tpvec &a, const _Tpvec &b) { \
-    return v_rotate_right<s>(a, b);                                            \
-  }
-
-OPENCV_HAL_IMPL_AVX_EXTRACT(v_uint8x32)
-OPENCV_HAL_IMPL_AVX_EXTRACT(v_int8x32)
-OPENCV_HAL_IMPL_AVX_EXTRACT(v_uint16x16)
-OPENCV_HAL_IMPL_AVX_EXTRACT(v_int16x16)
-OPENCV_HAL_IMPL_AVX_EXTRACT(v_uint32x8)
-OPENCV_HAL_IMPL_AVX_EXTRACT(v_int32x8)
-OPENCV_HAL_IMPL_AVX_EXTRACT(v_uint64x4)
-OPENCV_HAL_IMPL_AVX_EXTRACT(v_int64x4)
-OPENCV_HAL_IMPL_AVX_EXTRACT(v_float32x8)
-OPENCV_HAL_IMPL_AVX_EXTRACT(v_float64x4)
-
-template <int i> inline uchar v_extract_n(v_uint8x32 a) {
-  return (uchar)_v256_extract_epi8<i>(a.val);
-}
-
-template <int i> inline schar v_extract_n(v_int8x32 a) {
-  return (schar)v_extract_n<i>(v_reinterpret_as_u8(a));
-}
-
-template <int i> inline ushort v_extract_n(v_uint16x16 a) {
-  return (ushort)_v256_extract_epi16<i>(a.val);
-}
-
-template <int i> inline short v_extract_n(v_int16x16 a) {
-  return (short)v_extract_n<i>(v_reinterpret_as_u16(a));
-}
-
-template <int i> inline uint v_extract_n(v_uint32x8 a) {
-  return (uint)_v256_extract_epi32<i>(a.val);
-}
-
-template <int i> inline int v_extract_n(v_int32x8 a) {
-  return (int)v_extract_n<i>(v_reinterpret_as_u32(a));
-}
-
-template <int i> inline uint64 v_extract_n(v_uint64x4 a) {
-  return (uint64)_v256_extract_epi64<i>(a.val);
-}
-
-template <int i> inline int64 v_extract_n(v_int64x4 v) {
-  return (int64)v_extract_n<i>(v_reinterpret_as_u64(v));
-}
-
-template <int i> inline float v_extract_n(v_float32x8 v) {
-  union {
-    uint iv;
-    float fv;
-  } d;
-  d.iv = v_extract_n<i>(v_reinterpret_as_u32(v));
-  return d.fv;
-}
-
-template <int i> inline double v_extract_n(v_float64x4 v) {
-  union {
-    uint64 iv;
-    double dv;
-  } d;
-  d.iv = v_extract_n<i>(v_reinterpret_as_u64(v));
-  return d.dv;
-}
-
-template <int i> inline v_uint32x8 v_broadcast_element(v_uint32x8 a) {
-  static const __m256i perm = _mm256_set1_epi32((char)i);
-  return v_uint32x8(_mm256_permutevar8x32_epi32(a.val, perm));
-}
-
-template <int i> inline v_int32x8 v_broadcast_element(const v_int32x8 &a) {
-  return v_reinterpret_as_s32(v_broadcast_element<i>(v_reinterpret_as_u32(a)));
-}
-
-template <int i> inline v_float32x8 v_broadcast_element(const v_float32x8 &a) {
-  return v_reinterpret_as_f32(v_broadcast_element<i>(v_reinterpret_as_u32(a)));
-}
-
-///////////////////// load deinterleave /////////////////////////////
-
-inline void v_load_deinterleave(const uchar *ptr, v_uint8x32 &a,
-                                v_uint8x32 &b) {
-  __m256i ab0 = _mm256_loadu_si256((const __m256i *)ptr);
-  __m256i ab1 = _mm256_loadu_si256((const __m256i *)(ptr + 32));
-
-  const __m256i sh =
-      _mm256_setr_epi8(0, 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 15, 0,
-                       2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 15);
-  __m256i p0 = _mm256_shuffle_epi8(ab0, sh);
-  __m256i p1 = _mm256_shuffle_epi8(ab1, sh);
-  __m256i pl = _mm256_permute2x128_si256(p0, p1, 0 + 2 * 16);
-  __m256i ph = _mm256_permute2x128_si256(p0, p1, 1 + 3 * 16);
-  __m256i a0 = _mm256_unpacklo_epi64(pl, ph);
-  __m256i b0 = _mm256_unpackhi_epi64(pl, ph);
-  a = v_uint8x32(a0);
-  b = v_uint8x32(b0);
-}
-
-inline void v_load_deinterleave(const ushort *ptr, v_uint16x16 &a,
-                                v_uint16x16 &b) {
-  __m256i ab0 = _mm256_loadu_si256((const __m256i *)ptr);
-  __m256i ab1 = _mm256_loadu_si256((const __m256i *)(ptr + 16));
-
-  const __m256i sh =
-      _mm256_setr_epi8(0, 1, 4, 5, 8, 9, 12, 13, 2, 3, 6, 7, 10, 11, 14, 15, 0,
-                       1, 4, 5, 8, 9, 12, 13, 2, 3, 6, 7, 10, 11, 14, 15);
-  __m256i p0 = _mm256_shuffle_epi8(ab0, sh);
-  __m256i p1 = _mm256_shuffle_epi8(ab1, sh);
-  __m256i pl = _mm256_permute2x128_si256(p0, p1, 0 + 2 * 16);
-  __m256i ph = _mm256_permute2x128_si256(p0, p1, 1 + 3 * 16);
-  __m256i a0 = _mm256_unpacklo_epi64(pl, ph);
-  __m256i b0 = _mm256_unpackhi_epi64(pl, ph);
-  a = v_uint16x16(a0);
-  b = v_uint16x16(b0);
-}
-
-inline void v_load_deinterleave(const unsigned *ptr, v_uint32x8 &a,
-                                v_uint32x8 &b) {
-  __m256i ab0 = _mm256_loadu_si256((const __m256i *)ptr);
-  __m256i ab1 = _mm256_loadu_si256((const __m256i *)(ptr + 8));
-
-  enum { sh = 0 + 2 * 4 + 1 * 16 + 3 * 64 };
-  __m256i p0 = _mm256_shuffle_epi32(ab0, sh);
-  __m256i p1 = _mm256_shuffle_epi32(ab1, sh);
-  __m256i pl = _mm256_permute2x128_si256(p0, p1, 0 + 2 * 16);
-  __m256i ph = _mm256_permute2x128_si256(p0, p1, 1 + 3 * 16);
-  __m256i a0 = _mm256_unpacklo_epi64(pl, ph);
-  __m256i b0 = _mm256_unpackhi_epi64(pl, ph);
-  a = v_uint32x8(a0);
-  b = v_uint32x8(b0);
-}
-
-inline void v_load_deinterleave(const uint64 *ptr, v_uint64x4 &a,
-                                v_uint64x4 &b) {
-  __m256i ab0 = _mm256_loadu_si256((const __m256i *)ptr);
-  __m256i ab1 = _mm256_loadu_si256((const __m256i *)(ptr + 4));
-
-  __m256i pl = _mm256_permute2x128_si256(ab0, ab1, 0 + 2 * 16);
-  __m256i ph = _mm256_permute2x128_si256(ab0, ab1, 1 + 3 * 16);
-  __m256i a0 = _mm256_unpacklo_epi64(pl, ph);
-  __m256i b0 = _mm256_unpackhi_epi64(pl, ph);
-  a = v_uint64x4(a0);
-  b = v_uint64x4(b0);
-}
-
-inline void v_load_deinterleave(const uchar *ptr, v_uint8x32 &a, v_uint8x32 &b,
-                                v_uint8x32 &c) {
-  __m256i bgr0 = _mm256_loadu_si256((const __m256i *)ptr);
-  __m256i bgr1 = _mm256_loadu_si256((const __m256i *)(ptr + 32));
-  __m256i bgr2 = _mm256_loadu_si256((const __m256i *)(ptr + 64));
-
-  __m256i s02_low = _mm256_permute2x128_si256(bgr0, bgr2, 0 + 2 * 16);
-  __m256i s02_high = _mm256_permute2x128_si256(bgr0, bgr2, 1 + 3 * 16);
-
-  const __m256i m0 =
-      _mm256_setr_epi8(0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0,
-                       -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0);
-  const __m256i m1 =
-      _mm256_setr_epi8(0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1,
-                       0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1);
-
-  __m256i b0 =
-      _mm256_blendv_epi8(_mm256_blendv_epi8(s02_low, s02_high, m0), bgr1, m1);
-  __m256i g0 =
-      _mm256_blendv_epi8(_mm256_blendv_epi8(s02_high, s02_low, m1), bgr1, m0);
-  __m256i r0 =
-      _mm256_blendv_epi8(_mm256_blendv_epi8(bgr1, s02_low, m0), s02_high, m1);
-
-  const __m256i sh_b = _mm256_setr_epi8(0, 3, 6, 9, 12, 15, 2, 5, 8, 11, 14, 1,
-                                        4, 7, 10, 13, 0, 3, 6, 9, 12, 15, 2, 5,
-                                        8, 11, 14, 1, 4, 7, 10, 13),
-                sh_g = _mm256_setr_epi8(1, 4, 7, 10, 13, 0, 3, 6, 9, 12, 15, 2,
-                                        5, 8, 11, 14, 1, 4, 7, 10, 13, 0, 3, 6,
-                                        9, 12, 15, 2, 5, 8, 11, 14),
-                sh_r = _mm256_setr_epi8(2, 5, 8, 11, 14, 1, 4, 7, 10, 13, 0, 3,
-                                        6, 9, 12, 15, 2, 5, 8, 11, 14, 1, 4, 7,
-                                        10, 13, 0, 3, 6, 9, 12, 15);
-  b0 = _mm256_shuffle_epi8(b0, sh_b);
-  g0 = _mm256_shuffle_epi8(g0, sh_g);
-  r0 = _mm256_shuffle_epi8(r0, sh_r);
-
-  a = v_uint8x32(b0);
-  b = v_uint8x32(g0);
-  c = v_uint8x32(r0);
-}
-
-inline void v_load_deinterleave(const ushort *ptr, v_uint16x16 &a,
-                                v_uint16x16 &b, v_uint16x16 &c) {
-  __m256i bgr0 = _mm256_loadu_si256((const __m256i *)ptr);
-  __m256i bgr1 = _mm256_loadu_si256((const __m256i *)(ptr + 16));
-  __m256i bgr2 = _mm256_loadu_si256((const __m256i *)(ptr + 32));
-
-  __m256i s02_low = _mm256_permute2x128_si256(bgr0, bgr2, 0 + 2 * 16);
-  __m256i s02_high = _mm256_permute2x128_si256(bgr0, bgr2, 1 + 3 * 16);
-
-  const __m256i m0 =
-      _mm256_setr_epi8(0, 0, -1, -1, 0, 0, 0, 0, -1, -1, 0, 0, 0, 0, -1, -1, 0,
-                       0, 0, 0, -1, -1, 0, 0, 0, 0, -1, -1, 0, 0, 0, 0);
-  const __m256i m1 =
-      _mm256_setr_epi8(0, 0, 0, 0, -1, -1, 0, 0, 0, 0, -1, -1, 0, 0, 0, 0, -1,
-                       -1, 0, 0, 0, 0, -1, -1, 0, 0, 0, 0, -1, -1, 0, 0);
-  __m256i b0 =
-      _mm256_blendv_epi8(_mm256_blendv_epi8(s02_low, s02_high, m0), bgr1, m1);
-  __m256i g0 =
-      _mm256_blendv_epi8(_mm256_blendv_epi8(bgr1, s02_low, m0), s02_high, m1);
-  __m256i r0 =
-      _mm256_blendv_epi8(_mm256_blendv_epi8(s02_high, s02_low, m1), bgr1, m0);
-  const __m256i sh_b =
-      _mm256_setr_epi8(0, 1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15, 4, 5, 10, 11, 0,
-                       1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15, 4, 5, 10, 11);
-  const __m256i sh_g =
-      _mm256_setr_epi8(2, 3, 8, 9, 14, 15, 4, 5, 10, 11, 0, 1, 6, 7, 12, 13, 2,
-                       3, 8, 9, 14, 15, 4, 5, 10, 11, 0, 1, 6, 7, 12, 13);
-  const __m256i sh_r =
-      _mm256_setr_epi8(4, 5, 10, 11, 0, 1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15, 4,
-                       5, 10, 11, 0, 1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15);
-  b0 = _mm256_shuffle_epi8(b0, sh_b);
-  g0 = _mm256_shuffle_epi8(g0, sh_g);
-  r0 = _mm256_shuffle_epi8(r0, sh_r);
-
-  a = v_uint16x16(b0);
-  b = v_uint16x16(g0);
-  c = v_uint16x16(r0);
-}
-
-inline void v_load_deinterleave(const unsigned *ptr, v_uint32x8 &a,
-                                v_uint32x8 &b, v_uint32x8 &c) {
-  __m256i bgr0 = _mm256_loadu_si256((const __m256i *)ptr);
-  __m256i bgr1 = _mm256_loadu_si256((const __m256i *)(ptr + 8));
-  __m256i bgr2 = _mm256_loadu_si256((const __m256i *)(ptr + 16));
-
-  __m256i s02_low = _mm256_permute2x128_si256(bgr0, bgr2, 0 + 2 * 16);
-  __m256i s02_high = _mm256_permute2x128_si256(bgr0, bgr2, 1 + 3 * 16);
-
-  __m256i b0 = _mm256_blend_epi32(_mm256_blend_epi32(s02_low, s02_high, 0x24),
-                                  bgr1, 0x92);
-  __m256i g0 = _mm256_blend_epi32(_mm256_blend_epi32(s02_high, s02_low, 0x92),
-                                  bgr1, 0x24);
-  __m256i r0 = _mm256_blend_epi32(_mm256_blend_epi32(bgr1, s02_low, 0x24),
-                                  s02_high, 0x92);
-
-  b0 = _mm256_shuffle_epi32(b0, 0x6c);
-  g0 = _mm256_shuffle_epi32(g0, 0xb1);
-  r0 = _mm256_shuffle_epi32(r0, 0xc6);
-
-  a = v_uint32x8(b0);
-  b = v_uint32x8(g0);
-  c = v_uint32x8(r0);
-}
-
-inline void v_load_deinterleave(const uint64 *ptr, v_uint64x4 &a, v_uint64x4 &b,
-                                v_uint64x4 &c) {
-  __m256i bgr0 = _mm256_loadu_si256((const __m256i *)ptr);
-  __m256i bgr1 = _mm256_loadu_si256((const __m256i *)(ptr + 4));
-  __m256i bgr2 = _mm256_loadu_si256((const __m256i *)(ptr + 8));
-
-  __m256i s01 = _mm256_blend_epi32(bgr0, bgr1, 0xf0);
-  __m256i s12 = _mm256_blend_epi32(bgr1, bgr2, 0xf0);
-  __m256i s20r =
-      _mm256_permute4x64_epi64(_mm256_blend_epi32(bgr2, bgr0, 0xf0), 0x1b);
-  __m256i b0 = _mm256_unpacklo_epi64(s01, s20r);
-  __m256i g0 = _mm256_alignr_epi8(s12, s01, 8);
-  __m256i r0 = _mm256_unpackhi_epi64(s20r, s12);
-
-  a = v_uint64x4(b0);
-  b = v_uint64x4(g0);
-  c = v_uint64x4(r0);
-}
-
-inline void v_load_deinterleave(const uchar *ptr, v_uint8x32 &a, v_uint8x32 &b,
-                                v_uint8x32 &c, v_uint8x32 &d) {
-  __m256i bgr0 = _mm256_loadu_si256((const __m256i *)ptr);
-  __m256i bgr1 = _mm256_loadu_si256((const __m256i *)(ptr + 32));
-  __m256i bgr2 = _mm256_loadu_si256((const __m256i *)(ptr + 64));
-  __m256i bgr3 = _mm256_loadu_si256((const __m256i *)(ptr + 96));
-  const __m256i sh =
-      _mm256_setr_epi8(0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15, 0,
-                       4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15);
-
-  __m256i p0 = _mm256_shuffle_epi8(bgr0, sh);
-  __m256i p1 = _mm256_shuffle_epi8(bgr1, sh);
-  __m256i p2 = _mm256_shuffle_epi8(bgr2, sh);
-  __m256i p3 = _mm256_shuffle_epi8(bgr3, sh);
-
-  __m256i p01l = _mm256_unpacklo_epi32(p0, p1);
-  __m256i p01h = _mm256_unpackhi_epi32(p0, p1);
-  __m256i p23l = _mm256_unpacklo_epi32(p2, p3);
-  __m256i p23h = _mm256_unpackhi_epi32(p2, p3);
-
-  __m256i pll = _mm256_permute2x128_si256(p01l, p23l, 0 + 2 * 16);
-  __m256i plh = _mm256_permute2x128_si256(p01l, p23l, 1 + 3 * 16);
-  __m256i phl = _mm256_permute2x128_si256(p01h, p23h, 0 + 2 * 16);
-  __m256i phh = _mm256_permute2x128_si256(p01h, p23h, 1 + 3 * 16);
-
-  __m256i b0 = _mm256_unpacklo_epi32(pll, plh);
-  __m256i g0 = _mm256_unpackhi_epi32(pll, plh);
-  __m256i r0 = _mm256_unpacklo_epi32(phl, phh);
-  __m256i a0 = _mm256_unpackhi_epi32(phl, phh);
-
-  a = v_uint8x32(b0);
-  b = v_uint8x32(g0);
-  c = v_uint8x32(r0);
-  d = v_uint8x32(a0);
-}
-
-inline void v_load_deinterleave(const ushort *ptr, v_uint16x16 &a,
-                                v_uint16x16 &b, v_uint16x16 &c,
-                                v_uint16x16 &d) {
-  __m256i bgr0 = _mm256_loadu_si256((const __m256i *)ptr);
-  __m256i bgr1 = _mm256_loadu_si256((const __m256i *)(ptr + 16));
-  __m256i bgr2 = _mm256_loadu_si256((const __m256i *)(ptr + 32));
-  __m256i bgr3 = _mm256_loadu_si256((const __m256i *)(ptr + 48));
-  const __m256i sh =
-      _mm256_setr_epi8(0, 1, 8, 9, 2, 3, 10, 11, 4, 5, 12, 13, 6, 7, 14, 15, 0,
-                       1, 8, 9, 2, 3, 10, 11, 4, 5, 12, 13, 6, 7, 14, 15);
-  __m256i p0 = _mm256_shuffle_epi8(bgr0, sh);
-  __m256i p1 = _mm256_shuffle_epi8(bgr1, sh);
-  __m256i p2 = _mm256_shuffle_epi8(bgr2, sh);
-  __m256i p3 = _mm256_shuffle_epi8(bgr3, sh);
-
-  __m256i p01l = _mm256_unpacklo_epi32(p0, p1);
-  __m256i p01h = _mm256_unpackhi_epi32(p0, p1);
-  __m256i p23l = _mm256_unpacklo_epi32(p2, p3);
-  __m256i p23h = _mm256_unpackhi_epi32(p2, p3);
-
-  __m256i pll = _mm256_permute2x128_si256(p01l, p23l, 0 + 2 * 16);
-  __m256i plh = _mm256_permute2x128_si256(p01l, p23l, 1 + 3 * 16);
-  __m256i phl = _mm256_permute2x128_si256(p01h, p23h, 0 + 2 * 16);
-  __m256i phh = _mm256_permute2x128_si256(p01h, p23h, 1 + 3 * 16);
-
-  __m256i b0 = _mm256_unpacklo_epi32(pll, plh);
-  __m256i g0 = _mm256_unpackhi_epi32(pll, plh);
-  __m256i r0 = _mm256_unpacklo_epi32(phl, phh);
-  __m256i a0 = _mm256_unpackhi_epi32(phl, phh);
-
-  a = v_uint16x16(b0);
-  b = v_uint16x16(g0);
-  c = v_uint16x16(r0);
-  d = v_uint16x16(a0);
-}
-
-inline void v_load_deinterleave(const unsigned *ptr, v_uint32x8 &a,
-                                v_uint32x8 &b, v_uint32x8 &c, v_uint32x8 &d) {
-  __m256i p0 = _mm256_loadu_si256((const __m256i *)ptr);
-  __m256i p1 = _mm256_loadu_si256((const __m256i *)(ptr + 8));
-  __m256i p2 = _mm256_loadu_si256((const __m256i *)(ptr + 16));
-  __m256i p3 = _mm256_loadu_si256((const __m256i *)(ptr + 24));
-
-  __m256i p01l = _mm256_unpacklo_epi32(p0, p1);
-  __m256i p01h = _mm256_unpackhi_epi32(p0, p1);
-  __m256i p23l = _mm256_unpacklo_epi32(p2, p3);
-  __m256i p23h = _mm256_unpackhi_epi32(p2, p3);
-
-  __m256i pll = _mm256_permute2x128_si256(p01l, p23l, 0 + 2 * 16);
-  __m256i plh = _mm256_permute2x128_si256(p01l, p23l, 1 + 3 * 16);
-  __m256i phl = _mm256_permute2x128_si256(p01h, p23h, 0 + 2 * 16);
-  __m256i phh = _mm256_permute2x128_si256(p01h, p23h, 1 + 3 * 16);
-
-  __m256i b0 = _mm256_unpacklo_epi32(pll, plh);
-  __m256i g0 = _mm256_unpackhi_epi32(pll, plh);
-  __m256i r0 = _mm256_unpacklo_epi32(phl, phh);
-  __m256i a0 = _mm256_unpackhi_epi32(phl, phh);
-
-  a = v_uint32x8(b0);
-  b = v_uint32x8(g0);
-  c = v_uint32x8(r0);
-  d = v_uint32x8(a0);
-}
-
-inline void v_load_deinterleave(const uint64 *ptr, v_uint64x4 &a, v_uint64x4 &b,
-                                v_uint64x4 &c, v_uint64x4 &d) {
-  __m256i bgra0 = _mm256_loadu_si256((const __m256i *)ptr);
-  __m256i bgra1 = _mm256_loadu_si256((const __m256i *)(ptr + 4));
-  __m256i bgra2 = _mm256_loadu_si256((const __m256i *)(ptr + 8));
-  __m256i bgra3 = _mm256_loadu_si256((const __m256i *)(ptr + 12));
-
-  __m256i l02 = _mm256_permute2x128_si256(bgra0, bgra2, 0 + 2 * 16);
-  __m256i h02 = _mm256_permute2x128_si256(bgra0, bgra2, 1 + 3 * 16);
-  __m256i l13 = _mm256_permute2x128_si256(bgra1, bgra3, 0 + 2 * 16);
-  __m256i h13 = _mm256_permute2x128_si256(bgra1, bgra3, 1 + 3 * 16);
-
-  __m256i b0 = _mm256_unpacklo_epi64(l02, l13);
-  __m256i g0 = _mm256_unpackhi_epi64(l02, l13);
-  __m256i r0 = _mm256_unpacklo_epi64(h02, h13);
-  __m256i a0 = _mm256_unpackhi_epi64(h02, h13);
-
-  a = v_uint64x4(b0);
-  b = v_uint64x4(g0);
-  c = v_uint64x4(r0);
-  d = v_uint64x4(a0);
-}
-
-///////////////////////////// store interleave
-////////////////////////////////////////
-
-inline void v_store_interleave(uchar *ptr, const v_uint8x32 &x,
-                               const v_uint8x32 &y,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  __m256i xy_l = _mm256_unpacklo_epi8(x.val, y.val);
-  __m256i xy_h = _mm256_unpackhi_epi8(x.val, y.val);
-
-  __m256i xy0 = _mm256_permute2x128_si256(xy_l, xy_h, 0 + 2 * 16);
-  __m256i xy1 = _mm256_permute2x128_si256(xy_l, xy_h, 1 + 3 * 16);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm256_stream_si256((__m256i *)ptr, xy0);
-    _mm256_stream_si256((__m256i *)(ptr + 32), xy1);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm256_store_si256((__m256i *)ptr, xy0);
-    _mm256_store_si256((__m256i *)(ptr + 32), xy1);
-  } else {
-    _mm256_storeu_si256((__m256i *)ptr, xy0);
-    _mm256_storeu_si256((__m256i *)(ptr + 32), xy1);
-  }
-}
-
-inline void v_store_interleave(ushort *ptr, const v_uint16x16 &x,
-                               const v_uint16x16 &y,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  __m256i xy_l = _mm256_unpacklo_epi16(x.val, y.val);
-  __m256i xy_h = _mm256_unpackhi_epi16(x.val, y.val);
-
-  __m256i xy0 = _mm256_permute2x128_si256(xy_l, xy_h, 0 + 2 * 16);
-  __m256i xy1 = _mm256_permute2x128_si256(xy_l, xy_h, 1 + 3 * 16);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm256_stream_si256((__m256i *)ptr, xy0);
-    _mm256_stream_si256((__m256i *)(ptr + 16), xy1);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm256_store_si256((__m256i *)ptr, xy0);
-    _mm256_store_si256((__m256i *)(ptr + 16), xy1);
-  } else {
-    _mm256_storeu_si256((__m256i *)ptr, xy0);
-    _mm256_storeu_si256((__m256i *)(ptr + 16), xy1);
-  }
-}
-
-inline void v_store_interleave(unsigned *ptr, const v_uint32x8 &x,
-                               const v_uint32x8 &y,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  __m256i xy_l = _mm256_unpacklo_epi32(x.val, y.val);
-  __m256i xy_h = _mm256_unpackhi_epi32(x.val, y.val);
-
-  __m256i xy0 = _mm256_permute2x128_si256(xy_l, xy_h, 0 + 2 * 16);
-  __m256i xy1 = _mm256_permute2x128_si256(xy_l, xy_h, 1 + 3 * 16);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm256_stream_si256((__m256i *)ptr, xy0);
-    _mm256_stream_si256((__m256i *)(ptr + 8), xy1);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm256_store_si256((__m256i *)ptr, xy0);
-    _mm256_store_si256((__m256i *)(ptr + 8), xy1);
-  } else {
-    _mm256_storeu_si256((__m256i *)ptr, xy0);
-    _mm256_storeu_si256((__m256i *)(ptr + 8), xy1);
-  }
-}
-
-inline void v_store_interleave(uint64 *ptr, const v_uint64x4 &x,
-                               const v_uint64x4 &y,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  __m256i xy_l = _mm256_unpacklo_epi64(x.val, y.val);
-  __m256i xy_h = _mm256_unpackhi_epi64(x.val, y.val);
-
-  __m256i xy0 = _mm256_permute2x128_si256(xy_l, xy_h, 0 + 2 * 16);
-  __m256i xy1 = _mm256_permute2x128_si256(xy_l, xy_h, 1 + 3 * 16);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm256_stream_si256((__m256i *)ptr, xy0);
-    _mm256_stream_si256((__m256i *)(ptr + 4), xy1);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm256_store_si256((__m256i *)ptr, xy0);
-    _mm256_store_si256((__m256i *)(ptr + 4), xy1);
-  } else {
-    _mm256_storeu_si256((__m256i *)ptr, xy0);
-    _mm256_storeu_si256((__m256i *)(ptr + 4), xy1);
-  }
-}
-
-inline void v_store_interleave(uchar *ptr, const v_uint8x32 &a,
-                               const v_uint8x32 &b, const v_uint8x32 &c,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  const __m256i sh_b =
-      _mm256_setr_epi8(0, 11, 6, 1, 12, 7, 2, 13, 8, 3, 14, 9, 4, 15, 10, 5, 0,
-                       11, 6, 1, 12, 7, 2, 13, 8, 3, 14, 9, 4, 15, 10, 5);
-  const __m256i sh_g =
-      _mm256_setr_epi8(5, 0, 11, 6, 1, 12, 7, 2, 13, 8, 3, 14, 9, 4, 15, 10, 5,
-                       0, 11, 6, 1, 12, 7, 2, 13, 8, 3, 14, 9, 4, 15, 10);
-  const __m256i sh_r =
-      _mm256_setr_epi8(10, 5, 0, 11, 6, 1, 12, 7, 2, 13, 8, 3, 14, 9, 4, 15, 10,
-                       5, 0, 11, 6, 1, 12, 7, 2, 13, 8, 3, 14, 9, 4, 15);
-
-  __m256i b0 = _mm256_shuffle_epi8(a.val, sh_b);
-  __m256i g0 = _mm256_shuffle_epi8(b.val, sh_g);
-  __m256i r0 = _mm256_shuffle_epi8(c.val, sh_r);
-
-  const __m256i m0 =
-      _mm256_setr_epi8(0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0,
-                       -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0);
-  const __m256i m1 =
-      _mm256_setr_epi8(0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0,
-                       0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0);
-
-  __m256i p0 = _mm256_blendv_epi8(_mm256_blendv_epi8(b0, g0, m0), r0, m1);
-  __m256i p1 = _mm256_blendv_epi8(_mm256_blendv_epi8(g0, r0, m0), b0, m1);
-  __m256i p2 = _mm256_blendv_epi8(_mm256_blendv_epi8(r0, b0, m0), g0, m1);
-
-  __m256i bgr0 = _mm256_permute2x128_si256(p0, p1, 0 + 2 * 16);
-  __m256i bgr1 = _mm256_permute2x128_si256(p2, p0, 0 + 3 * 16);
-  __m256i bgr2 = _mm256_permute2x128_si256(p1, p2, 1 + 3 * 16);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm256_stream_si256((__m256i *)ptr, bgr0);
-    _mm256_stream_si256((__m256i *)(ptr + 32), bgr1);
-    _mm256_stream_si256((__m256i *)(ptr + 64), bgr2);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm256_store_si256((__m256i *)ptr, bgr0);
-    _mm256_store_si256((__m256i *)(ptr + 32), bgr1);
-    _mm256_store_si256((__m256i *)(ptr + 64), bgr2);
-  } else {
-    _mm256_storeu_si256((__m256i *)ptr, bgr0);
-    _mm256_storeu_si256((__m256i *)(ptr + 32), bgr1);
-    _mm256_storeu_si256((__m256i *)(ptr + 64), bgr2);
-  }
-}
-
-inline void v_store_interleave(ushort *ptr, const v_uint16x16 &a,
-                               const v_uint16x16 &b, const v_uint16x16 &c,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  const __m256i sh_b =
-      _mm256_setr_epi8(0, 1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15, 4, 5, 10, 11, 0,
-                       1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15, 4, 5, 10, 11);
-  const __m256i sh_g =
-      _mm256_setr_epi8(10, 11, 0, 1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15, 4, 5, 10,
-                       11, 0, 1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15, 4, 5);
-  const __m256i sh_r =
-      _mm256_setr_epi8(4, 5, 10, 11, 0, 1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15, 4,
-                       5, 10, 11, 0, 1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15);
-
-  __m256i b0 = _mm256_shuffle_epi8(a.val, sh_b);
-  __m256i g0 = _mm256_shuffle_epi8(b.val, sh_g);
-  __m256i r0 = _mm256_shuffle_epi8(c.val, sh_r);
-
-  const __m256i m0 =
-      _mm256_setr_epi8(0, 0, -1, -1, 0, 0, 0, 0, -1, -1, 0, 0, 0, 0, -1, -1, 0,
-                       0, 0, 0, -1, -1, 0, 0, 0, 0, -1, -1, 0, 0, 0, 0);
-  const __m256i m1 =
-      _mm256_setr_epi8(0, 0, 0, 0, -1, -1, 0, 0, 0, 0, -1, -1, 0, 0, 0, 0, -1,
-                       -1, 0, 0, 0, 0, -1, -1, 0, 0, 0, 0, -1, -1, 0, 0);
-
-  __m256i p0 = _mm256_blendv_epi8(_mm256_blendv_epi8(b0, g0, m0), r0, m1);
-  __m256i p1 = _mm256_blendv_epi8(_mm256_blendv_epi8(g0, r0, m0), b0, m1);
-  __m256i p2 = _mm256_blendv_epi8(_mm256_blendv_epi8(r0, b0, m0), g0, m1);
-
-  __m256i bgr0 = _mm256_permute2x128_si256(p0, p2, 0 + 2 * 16);
-  //__m256i bgr1 = p1;
-  __m256i bgr2 = _mm256_permute2x128_si256(p0, p2, 1 + 3 * 16);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm256_stream_si256((__m256i *)ptr, bgr0);
-    _mm256_stream_si256((__m256i *)(ptr + 16), p1);
-    _mm256_stream_si256((__m256i *)(ptr + 32), bgr2);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm256_store_si256((__m256i *)ptr, bgr0);
-    _mm256_store_si256((__m256i *)(ptr + 16), p1);
-    _mm256_store_si256((__m256i *)(ptr + 32), bgr2);
-  } else {
-    _mm256_storeu_si256((__m256i *)ptr, bgr0);
-    _mm256_storeu_si256((__m256i *)(ptr + 16), p1);
-    _mm256_storeu_si256((__m256i *)(ptr + 32), bgr2);
-  }
-}
-
-inline void v_store_interleave(unsigned *ptr, const v_uint32x8 &a,
-                               const v_uint32x8 &b, const v_uint32x8 &c,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  __m256i b0 = _mm256_shuffle_epi32(a.val, 0x6c);
-  __m256i g0 = _mm256_shuffle_epi32(b.val, 0xb1);
-  __m256i r0 = _mm256_shuffle_epi32(c.val, 0xc6);
-
-  __m256i p0 = _mm256_blend_epi32(_mm256_blend_epi32(b0, g0, 0x92), r0, 0x24);
-  __m256i p1 = _mm256_blend_epi32(_mm256_blend_epi32(g0, r0, 0x92), b0, 0x24);
-  __m256i p2 = _mm256_blend_epi32(_mm256_blend_epi32(r0, b0, 0x92), g0, 0x24);
-
-  __m256i bgr0 = _mm256_permute2x128_si256(p0, p1, 0 + 2 * 16);
-  //__m256i bgr1 = p2;
-  __m256i bgr2 = _mm256_permute2x128_si256(p0, p1, 1 + 3 * 16);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm256_stream_si256((__m256i *)ptr, bgr0);
-    _mm256_stream_si256((__m256i *)(ptr + 8), p2);
-    _mm256_stream_si256((__m256i *)(ptr + 16), bgr2);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm256_store_si256((__m256i *)ptr, bgr0);
-    _mm256_store_si256((__m256i *)(ptr + 8), p2);
-    _mm256_store_si256((__m256i *)(ptr + 16), bgr2);
-  } else {
-    _mm256_storeu_si256((__m256i *)ptr, bgr0);
-    _mm256_storeu_si256((__m256i *)(ptr + 8), p2);
-    _mm256_storeu_si256((__m256i *)(ptr + 16), bgr2);
-  }
-}
-
-inline void v_store_interleave(uint64 *ptr, const v_uint64x4 &a,
-                               const v_uint64x4 &b, const v_uint64x4 &c,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  __m256i s01 = _mm256_unpacklo_epi64(a.val, b.val);
-  __m256i s12 = _mm256_unpackhi_epi64(b.val, c.val);
-  __m256i s20 = _mm256_blend_epi32(c.val, a.val, 0xcc);
-
-  __m256i bgr0 = _mm256_permute2x128_si256(s01, s20, 0 + 2 * 16);
-  __m256i bgr1 = _mm256_blend_epi32(s01, s12, 0x0f);
-  __m256i bgr2 = _mm256_permute2x128_si256(s20, s12, 1 + 3 * 16);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm256_stream_si256((__m256i *)ptr, bgr0);
-    _mm256_stream_si256((__m256i *)(ptr + 4), bgr1);
-    _mm256_stream_si256((__m256i *)(ptr + 8), bgr2);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm256_store_si256((__m256i *)ptr, bgr0);
-    _mm256_store_si256((__m256i *)(ptr + 4), bgr1);
-    _mm256_store_si256((__m256i *)(ptr + 8), bgr2);
-  } else {
-    _mm256_storeu_si256((__m256i *)ptr, bgr0);
-    _mm256_storeu_si256((__m256i *)(ptr + 4), bgr1);
-    _mm256_storeu_si256((__m256i *)(ptr + 8), bgr2);
-  }
-}
-
-inline void v_store_interleave(uchar *ptr, const v_uint8x32 &a,
-                               const v_uint8x32 &b, const v_uint8x32 &c,
-                               const v_uint8x32 &d,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  __m256i bg0 = _mm256_unpacklo_epi8(a.val, b.val);
-  __m256i bg1 = _mm256_unpackhi_epi8(a.val, b.val);
-  __m256i ra0 = _mm256_unpacklo_epi8(c.val, d.val);
-  __m256i ra1 = _mm256_unpackhi_epi8(c.val, d.val);
-
-  __m256i bgra0_ = _mm256_unpacklo_epi16(bg0, ra0);
-  __m256i bgra1_ = _mm256_unpackhi_epi16(bg0, ra0);
-  __m256i bgra2_ = _mm256_unpacklo_epi16(bg1, ra1);
-  __m256i bgra3_ = _mm256_unpackhi_epi16(bg1, ra1);
-
-  __m256i bgra0 = _mm256_permute2x128_si256(bgra0_, bgra1_, 0 + 2 * 16);
-  __m256i bgra2 = _mm256_permute2x128_si256(bgra0_, bgra1_, 1 + 3 * 16);
-  __m256i bgra1 = _mm256_permute2x128_si256(bgra2_, bgra3_, 0 + 2 * 16);
-  __m256i bgra3 = _mm256_permute2x128_si256(bgra2_, bgra3_, 1 + 3 * 16);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm256_stream_si256((__m256i *)ptr, bgra0);
-    _mm256_stream_si256((__m256i *)(ptr + 32), bgra1);
-    _mm256_stream_si256((__m256i *)(ptr + 64), bgra2);
-    _mm256_stream_si256((__m256i *)(ptr + 96), bgra3);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm256_store_si256((__m256i *)ptr, bgra0);
-    _mm256_store_si256((__m256i *)(ptr + 32), bgra1);
-    _mm256_store_si256((__m256i *)(ptr + 64), bgra2);
-    _mm256_store_si256((__m256i *)(ptr + 96), bgra3);
-  } else {
-    _mm256_storeu_si256((__m256i *)ptr, bgra0);
-    _mm256_storeu_si256((__m256i *)(ptr + 32), bgra1);
-    _mm256_storeu_si256((__m256i *)(ptr + 64), bgra2);
-    _mm256_storeu_si256((__m256i *)(ptr + 96), bgra3);
-  }
-}
-
-inline void v_store_interleave(ushort *ptr, const v_uint16x16 &a,
-                               const v_uint16x16 &b, const v_uint16x16 &c,
-                               const v_uint16x16 &d,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  __m256i bg0 = _mm256_unpacklo_epi16(a.val, b.val);
-  __m256i bg1 = _mm256_unpackhi_epi16(a.val, b.val);
-  __m256i ra0 = _mm256_unpacklo_epi16(c.val, d.val);
-  __m256i ra1 = _mm256_unpackhi_epi16(c.val, d.val);
-
-  __m256i bgra0_ = _mm256_unpacklo_epi32(bg0, ra0);
-  __m256i bgra1_ = _mm256_unpackhi_epi32(bg0, ra0);
-  __m256i bgra2_ = _mm256_unpacklo_epi32(bg1, ra1);
-  __m256i bgra3_ = _mm256_unpackhi_epi32(bg1, ra1);
-
-  __m256i bgra0 = _mm256_permute2x128_si256(bgra0_, bgra1_, 0 + 2 * 16);
-  __m256i bgra2 = _mm256_permute2x128_si256(bgra0_, bgra1_, 1 + 3 * 16);
-  __m256i bgra1 = _mm256_permute2x128_si256(bgra2_, bgra3_, 0 + 2 * 16);
-  __m256i bgra3 = _mm256_permute2x128_si256(bgra2_, bgra3_, 1 + 3 * 16);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm256_stream_si256((__m256i *)ptr, bgra0);
-    _mm256_stream_si256((__m256i *)(ptr + 16), bgra1);
-    _mm256_stream_si256((__m256i *)(ptr + 32), bgra2);
-    _mm256_stream_si256((__m256i *)(ptr + 48), bgra3);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm256_store_si256((__m256i *)ptr, bgra0);
-    _mm256_store_si256((__m256i *)(ptr + 16), bgra1);
-    _mm256_store_si256((__m256i *)(ptr + 32), bgra2);
-    _mm256_store_si256((__m256i *)(ptr + 48), bgra3);
-  } else {
-    _mm256_storeu_si256((__m256i *)ptr, bgra0);
-    _mm256_storeu_si256((__m256i *)(ptr + 16), bgra1);
-    _mm256_storeu_si256((__m256i *)(ptr + 32), bgra2);
-    _mm256_storeu_si256((__m256i *)(ptr + 48), bgra3);
-  }
-}
-
-inline void v_store_interleave(unsigned *ptr, const v_uint32x8 &a,
-                               const v_uint32x8 &b, const v_uint32x8 &c,
-                               const v_uint32x8 &d,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  __m256i bg0 = _mm256_unpacklo_epi32(a.val, b.val);
-  __m256i bg1 = _mm256_unpackhi_epi32(a.val, b.val);
-  __m256i ra0 = _mm256_unpacklo_epi32(c.val, d.val);
-  __m256i ra1 = _mm256_unpackhi_epi32(c.val, d.val);
-
-  __m256i bgra0_ = _mm256_unpacklo_epi64(bg0, ra0);
-  __m256i bgra1_ = _mm256_unpackhi_epi64(bg0, ra0);
-  __m256i bgra2_ = _mm256_unpacklo_epi64(bg1, ra1);
-  __m256i bgra3_ = _mm256_unpackhi_epi64(bg1, ra1);
-
-  __m256i bgra0 = _mm256_permute2x128_si256(bgra0_, bgra1_, 0 + 2 * 16);
-  __m256i bgra2 = _mm256_permute2x128_si256(bgra0_, bgra1_, 1 + 3 * 16);
-  __m256i bgra1 = _mm256_permute2x128_si256(bgra2_, bgra3_, 0 + 2 * 16);
-  __m256i bgra3 = _mm256_permute2x128_si256(bgra2_, bgra3_, 1 + 3 * 16);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm256_stream_si256((__m256i *)ptr, bgra0);
-    _mm256_stream_si256((__m256i *)(ptr + 8), bgra1);
-    _mm256_stream_si256((__m256i *)(ptr + 16), bgra2);
-    _mm256_stream_si256((__m256i *)(ptr + 24), bgra3);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm256_store_si256((__m256i *)ptr, bgra0);
-    _mm256_store_si256((__m256i *)(ptr + 8), bgra1);
-    _mm256_store_si256((__m256i *)(ptr + 16), bgra2);
-    _mm256_store_si256((__m256i *)(ptr + 24), bgra3);
-  } else {
-    _mm256_storeu_si256((__m256i *)ptr, bgra0);
-    _mm256_storeu_si256((__m256i *)(ptr + 8), bgra1);
-    _mm256_storeu_si256((__m256i *)(ptr + 16), bgra2);
-    _mm256_storeu_si256((__m256i *)(ptr + 24), bgra3);
-  }
-}
-
-inline void v_store_interleave(uint64 *ptr, const v_uint64x4 &a,
-                               const v_uint64x4 &b, const v_uint64x4 &c,
-                               const v_uint64x4 &d,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  __m256i bg0 = _mm256_unpacklo_epi64(a.val, b.val);
-  __m256i bg1 = _mm256_unpackhi_epi64(a.val, b.val);
-  __m256i ra0 = _mm256_unpacklo_epi64(c.val, d.val);
-  __m256i ra1 = _mm256_unpackhi_epi64(c.val, d.val);
-
-  __m256i bgra0 = _mm256_permute2x128_si256(bg0, ra0, 0 + 2 * 16);
-  __m256i bgra1 = _mm256_permute2x128_si256(bg1, ra1, 0 + 2 * 16);
-  __m256i bgra2 = _mm256_permute2x128_si256(bg0, ra0, 1 + 3 * 16);
-  __m256i bgra3 = _mm256_permute2x128_si256(bg1, ra1, 1 + 3 * 16);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm256_stream_si256((__m256i *)ptr, bgra0);
-    _mm256_stream_si256((__m256i *)(ptr + 4), bgra1);
-    _mm256_stream_si256((__m256i *)(ptr + 8), bgra2);
-    _mm256_stream_si256((__m256i *)(ptr + 12), bgra3);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm256_store_si256((__m256i *)ptr, bgra0);
-    _mm256_store_si256((__m256i *)(ptr + 4), bgra1);
-    _mm256_store_si256((__m256i *)(ptr + 8), bgra2);
-    _mm256_store_si256((__m256i *)(ptr + 12), bgra3);
-  } else {
-    _mm256_storeu_si256((__m256i *)ptr, bgra0);
-    _mm256_storeu_si256((__m256i *)(ptr + 4), bgra1);
-    _mm256_storeu_si256((__m256i *)(ptr + 8), bgra2);
-    _mm256_storeu_si256((__m256i *)(ptr + 12), bgra3);
-  }
-}
-
-#define OPENCV_HAL_IMPL_AVX_LOADSTORE_INTERLEAVE(_Tpvec0, _Tp0, suffix0,       \
-                                                 _Tpvec1, _Tp1, suffix1)       \
-  inline void v_load_deinterleave(const _Tp0 *ptr, _Tpvec0 &a0, _Tpvec0 &b0) { \
-    _Tpvec1 a1, b1;                                                            \
-    v_load_deinterleave((const _Tp1 *)ptr, a1, b1);                            \
-    a0 = v_reinterpret_as_##suffix0(a1);                                       \
-    b0 = v_reinterpret_as_##suffix0(b1);                                       \
-  }                                                                            \
-  inline void v_load_deinterleave(const _Tp0 *ptr, _Tpvec0 &a0, _Tpvec0 &b0,   \
-                                  _Tpvec0 &c0) {                               \
-    _Tpvec1 a1, b1, c1;                                                        \
-    v_load_deinterleave((const _Tp1 *)ptr, a1, b1, c1);                        \
-    a0 = v_reinterpret_as_##suffix0(a1);                                       \
-    b0 = v_reinterpret_as_##suffix0(b1);                                       \
-    c0 = v_reinterpret_as_##suffix0(c1);                                       \
-  }                                                                            \
-  inline void v_load_deinterleave(const _Tp0 *ptr, _Tpvec0 &a0, _Tpvec0 &b0,   \
-                                  _Tpvec0 &c0, _Tpvec0 &d0) {                  \
-    _Tpvec1 a1, b1, c1, d1;                                                    \
-    v_load_deinterleave((const _Tp1 *)ptr, a1, b1, c1, d1);                    \
-    a0 = v_reinterpret_as_##suffix0(a1);                                       \
-    b0 = v_reinterpret_as_##suffix0(b1);                                       \
-    c0 = v_reinterpret_as_##suffix0(c1);                                       \
-    d0 = v_reinterpret_as_##suffix0(d1);                                       \
-  }                                                                            \
-  inline void v_store_interleave(_Tp0 *ptr, const _Tpvec0 &a0,                 \
-                                 const _Tpvec0 &b0,                            \
-                                 hal::StoreMode mode = hal::STORE_UNALIGNED) { \
-    _Tpvec1 a1 = v_reinterpret_as_##suffix1(a0);                               \
-    _Tpvec1 b1 = v_reinterpret_as_##suffix1(b0);                               \
-    v_store_interleave((_Tp1 *)ptr, a1, b1, mode);                             \
-  }                                                                            \
-  inline void v_store_interleave(_Tp0 *ptr, const _Tpvec0 &a0,                 \
-                                 const _Tpvec0 &b0, const _Tpvec0 &c0,         \
-                                 hal::StoreMode mode = hal::STORE_UNALIGNED) { \
-    _Tpvec1 a1 = v_reinterpret_as_##suffix1(a0);                               \
-    _Tpvec1 b1 = v_reinterpret_as_##suffix1(b0);                               \
-    _Tpvec1 c1 = v_reinterpret_as_##suffix1(c0);                               \
-    v_store_interleave((_Tp1 *)ptr, a1, b1, c1, mode);                         \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp0 *ptr, const _Tpvec0 &a0, const _Tpvec0 &b0, const _Tpvec0 &c0,      \
-      const _Tpvec0 &d0, hal::StoreMode mode = hal::STORE_UNALIGNED) {         \
-    _Tpvec1 a1 = v_reinterpret_as_##suffix1(a0);                               \
-    _Tpvec1 b1 = v_reinterpret_as_##suffix1(b0);                               \
-    _Tpvec1 c1 = v_reinterpret_as_##suffix1(c0);                               \
-    _Tpvec1 d1 = v_reinterpret_as_##suffix1(d0);                               \
-    v_store_interleave((_Tp1 *)ptr, a1, b1, c1, d1, mode);                     \
-  }
-
-OPENCV_HAL_IMPL_AVX_LOADSTORE_INTERLEAVE(v_int8x32, schar, s8, v_uint8x32,
-                                         uchar, u8)
-OPENCV_HAL_IMPL_AVX_LOADSTORE_INTERLEAVE(v_int16x16, short, s16, v_uint16x16,
-                                         ushort, u16)
-OPENCV_HAL_IMPL_AVX_LOADSTORE_INTERLEAVE(v_int32x8, int, s32, v_uint32x8,
-                                         unsigned, u32)
-OPENCV_HAL_IMPL_AVX_LOADSTORE_INTERLEAVE(v_float32x8, float, f32, v_uint32x8,
-                                         unsigned, u32)
-OPENCV_HAL_IMPL_AVX_LOADSTORE_INTERLEAVE(v_int64x4, int64, s64, v_uint64x4,
-                                         uint64, u64)
-OPENCV_HAL_IMPL_AVX_LOADSTORE_INTERLEAVE(v_float64x4, double, f64, v_uint64x4,
-                                         uint64, u64)
-
-//
-// FP16
-//
-
-inline v_float32x8 v256_load_expand(const hfloat *ptr) {
-#if CV_FP16
-  return v_float32x8(_mm256_cvtph_ps(_mm_loadu_si128((const __m128i *)ptr)));
-#else
-  float CV_DECL_ALIGNED(32) buf[8];
-  for (int i = 0; i < 8; i++)
-    buf[i] = (float)ptr[i];
-  return v256_load_aligned(buf);
-#endif
-}
-
-inline void v_pack_store(hfloat *ptr, const v_float32x8 &a) {
-#if CV_FP16
-  __m128i ah = _mm256_cvtps_ph(a.val, 0);
-  _mm_storeu_si128((__m128i *)ptr, ah);
-#else
-  float CV_DECL_ALIGNED(32) buf[8];
-  v_store_aligned(buf, a);
-  for (int i = 0; i < 8; i++)
-    ptr[i] = hfloat(buf[i]);
-#endif
-}
-
-//
-// end of FP16
-//
-
-inline void v256_cleanup() { _mm256_zeroall(); }
-
-#include "intrin_math.hpp"
-inline v_float32x8 v_exp(const v_float32x8 &x) {
-  return v_exp_default_32f<v_float32x8, v_int32x8>(x);
-}
-inline v_float32x8 v_log(const v_float32x8 &x) {
-  return v_log_default_32f<v_float32x8, v_int32x8>(x);
-}
-inline void v_sincos(const v_float32x8 &x, v_float32x8 &s, v_float32x8 &c) {
-  v_sincos_default_32f<v_float32x8, v_int32x8>(x, s, c);
-}
-inline v_float32x8 v_sin(const v_float32x8 &x) {
-  return v_sin_default_32f<v_float32x8, v_int32x8>(x);
-}
-inline v_float32x8 v_cos(const v_float32x8 &x) {
-  return v_cos_default_32f<v_float32x8, v_int32x8>(x);
-}
-inline v_float32x8 v_erf(const v_float32x8 &x) {
-  return v_erf_default_32f<v_float32x8, v_int32x8>(x);
-}
-
-inline v_float64x4 v_exp(const v_float64x4 &x) {
-  return v_exp_default_64f<v_float64x4, v_int64x4>(x);
-}
-inline v_float64x4 v_log(const v_float64x4 &x) {
-  return v_log_default_64f<v_float64x4, v_int64x4>(x);
-}
-inline void v_sincos(const v_float64x4 &x, v_float64x4 &s, v_float64x4 &c) {
-  v_sincos_default_64f<v_float64x4, v_int64x4>(x, s, c);
-}
-inline v_float64x4 v_sin(const v_float64x4 &x) {
-  return v_sin_default_64f<v_float64x4, v_int64x4>(x);
-}
-inline v_float64x4 v_cos(const v_float64x4 &x) {
-  return v_cos_default_64f<v_float64x4, v_int64x4>(x);
-}
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_END
-
-//! @endcond
-
-} // namespace cv
-
-#endif // OPENCV_HAL_INTRIN_AVX_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_avx512.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_avx512.hpp
deleted file mode 100644
index 7a6d997b4f..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_avx512.hpp
+++ /dev/null
@@ -1,3688 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html
-
-#ifndef OPENCV_HAL_INTRIN_AVX512_HPP
-#define OPENCV_HAL_INTRIN_AVX512_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER < 1920 /*MSVS2019*/)
-#pragma warning(disable : 4146) // unary minus operator applied to unsigned
-                                // type, result still unsigned
-#pragma warning(disable : 4309) // 'argument': truncation of constant value
-#pragma warning(disable : 4310) // cast truncates constant value
-#endif
-
-#define CVT_ROUND_MODES_IMPLEMENTED 0
-
-#define CV_SIMD512 1
-#define CV_SIMD512_64F 1
-#define CV_SIMD512_FP16                                                        \
-  0 // no native operations with FP16 type. Only load/store from float32x8 are
-    // available (if CV_FP16 == 1)
-
-#define _v512_set_epu64(a7, a6, a5, a4, a3, a2, a1, a0)                        \
-  _mm512_set_epi64((int64)(a7), (int64)(a6), (int64)(a5), (int64)(a4),         \
-                   (int64)(a3), (int64)(a2), (int64)(a1), (int64)(a0))
-#define _v512_set_epu32(a15, a14, a13, a12, a11, a10, a9, a8, a7, a6, a5, a4,  \
-                        a3, a2, a1, a0)                                        \
-  _mm512_set_epi64(                                                            \
-      ((int64)(a15) << 32) | (int64)(a14),                                     \
-      ((int64)(a13) << 32) | (int64)(a12),                                     \
-      ((int64)(a11) << 32) | (int64)(a10), ((int64)(a9) << 32) | (int64)(a8),  \
-      ((int64)(a7) << 32) | (int64)(a6), ((int64)(a5) << 32) | (int64)(a4),    \
-      ((int64)(a3) << 32) | (int64)(a2), ((int64)(a1) << 32) | (int64)(a0))
-#define _v512_set_epu16(a31, a30, a29, a28, a27, a26, a25, a24, a23, a22, a21, \
-                        a20, a19, a18, a17, a16, a15, a14, a13, a12, a11, a10, \
-                        a9, a8, a7, a6, a5, a4, a3, a2, a1, a0)                \
-  _v512_set_epu32(((unsigned)(a31) << 16) | (unsigned)(a30),                   \
-                  ((unsigned)(a29) << 16) | (unsigned)(a28),                   \
-                  ((unsigned)(a27) << 16) | (unsigned)(a26),                   \
-                  ((unsigned)(a25) << 16) | (unsigned)(a24),                   \
-                  ((unsigned)(a23) << 16) | (unsigned)(a22),                   \
-                  ((unsigned)(a21) << 16) | (unsigned)(a20),                   \
-                  ((unsigned)(a19) << 16) | (unsigned)(a18),                   \
-                  ((unsigned)(a17) << 16) | (unsigned)(a16),                   \
-                  ((unsigned)(a15) << 16) | (unsigned)(a14),                   \
-                  ((unsigned)(a13) << 16) | (unsigned)(a12),                   \
-                  ((unsigned)(a11) << 16) | (unsigned)(a10),                   \
-                  ((unsigned)(a9) << 16) | (unsigned)(a8),                     \
-                  ((unsigned)(a7) << 16) | (unsigned)(a6),                     \
-                  ((unsigned)(a5) << 16) | (unsigned)(a4),                     \
-                  ((unsigned)(a3) << 16) | (unsigned)(a2),                     \
-                  ((unsigned)(a1) << 16) | (unsigned)(a0))
-#define _v512_set_epu8(a63, a62, a61, a60, a59, a58, a57, a56, a55, a54, a53,  \
-                       a52, a51, a50, a49, a48, a47, a46, a45, a44, a43, a42,  \
-                       a41, a40, a39, a38, a37, a36, a35, a34, a33, a32, a31,  \
-                       a30, a29, a28, a27, a26, a25, a24, a23, a22, a21, a20,  \
-                       a19, a18, a17, a16, a15, a14, a13, a12, a11, a10, a9,   \
-                       a8, a7, a6, a5, a4, a3, a2, a1, a0)                     \
-  _v512_set_epu32(((unsigned)(a63) << 24) | ((unsigned)(a62) << 16) |          \
-                      ((unsigned)(a61) << 8) | (unsigned)(a60),                \
-                  ((unsigned)(a59) << 24) | ((unsigned)(a58) << 16) |          \
-                      ((unsigned)(a57) << 8) | (unsigned)(a56),                \
-                  ((unsigned)(a55) << 24) | ((unsigned)(a54) << 16) |          \
-                      ((unsigned)(a53) << 8) | (unsigned)(a52),                \
-                  ((unsigned)(a51) << 24) | ((unsigned)(a50) << 16) |          \
-                      ((unsigned)(a49) << 8) | (unsigned)(a48),                \
-                  ((unsigned)(a47) << 24) | ((unsigned)(a46) << 16) |          \
-                      ((unsigned)(a45) << 8) | (unsigned)(a44),                \
-                  ((unsigned)(a43) << 24) | ((unsigned)(a42) << 16) |          \
-                      ((unsigned)(a41) << 8) | (unsigned)(a40),                \
-                  ((unsigned)(a39) << 24) | ((unsigned)(a38) << 16) |          \
-                      ((unsigned)(a37) << 8) | (unsigned)(a36),                \
-                  ((unsigned)(a35) << 24) | ((unsigned)(a34) << 16) |          \
-                      ((unsigned)(a33) << 8) | (unsigned)(a32),                \
-                  ((unsigned)(a31) << 24) | ((unsigned)(a30) << 16) |          \
-                      ((unsigned)(a29) << 8) | (unsigned)(a28),                \
-                  ((unsigned)(a27) << 24) | ((unsigned)(a26) << 16) |          \
-                      ((unsigned)(a25) << 8) | (unsigned)(a24),                \
-                  ((unsigned)(a23) << 24) | ((unsigned)(a22) << 16) |          \
-                      ((unsigned)(a21) << 8) | (unsigned)(a20),                \
-                  ((unsigned)(a19) << 24) | ((unsigned)(a18) << 16) |          \
-                      ((unsigned)(a17) << 8) | (unsigned)(a16),                \
-                  ((unsigned)(a15) << 24) | ((unsigned)(a14) << 16) |          \
-                      ((unsigned)(a13) << 8) | (unsigned)(a12),                \
-                  ((unsigned)(a11) << 24) | ((unsigned)(a10) << 16) |          \
-                      ((unsigned)(a9) << 8) | (unsigned)(a8),                  \
-                  ((unsigned)(a7) << 24) | ((unsigned)(a6) << 16) |            \
-                      ((unsigned)(a5) << 8) | (unsigned)(a4),                  \
-                  ((unsigned)(a3) << 24) | ((unsigned)(a2) << 16) |            \
-                      ((unsigned)(a1) << 8) | (unsigned)(a0))
-#define _v512_set_epi8(a63, a62, a61, a60, a59, a58, a57, a56, a55, a54, a53,  \
-                       a52, a51, a50, a49, a48, a47, a46, a45, a44, a43, a42,  \
-                       a41, a40, a39, a38, a37, a36, a35, a34, a33, a32, a31,  \
-                       a30, a29, a28, a27, a26, a25, a24, a23, a22, a21, a20,  \
-                       a19, a18, a17, a16, a15, a14, a13, a12, a11, a10, a9,   \
-                       a8, a7, a6, a5, a4, a3, a2, a1, a0)                     \
-  _v512_set_epu8(                                                              \
-      (uchar)(a63), (uchar)(a62), (uchar)(a61), (uchar)(a60), (uchar)(a59),    \
-      (uchar)(a58), (uchar)(a57), (uchar)(a56), (uchar)(a55), (uchar)(a54),    \
-      (uchar)(a53), (uchar)(a52), (uchar)(a51), (uchar)(a50), (uchar)(a49),    \
-      (uchar)(a48), (uchar)(a47), (uchar)(a46), (uchar)(a45), (uchar)(a44),    \
-      (uchar)(a43), (uchar)(a42), (uchar)(a41), (uchar)(a40), (uchar)(a39),    \
-      (uchar)(a38), (uchar)(a37), (uchar)(a36), (uchar)(a35), (uchar)(a34),    \
-      (uchar)(a33), (uchar)(a32), (uchar)(a31), (uchar)(a30), (uchar)(a29),    \
-      (uchar)(a28), (uchar)(a27), (uchar)(a26), (uchar)(a25), (uchar)(a24),    \
-      (uchar)(a23), (uchar)(a22), (uchar)(a21), (uchar)(a20), (uchar)(a19),    \
-      (uchar)(a18), (uchar)(a17), (uchar)(a16), (uchar)(a15), (uchar)(a14),    \
-      (uchar)(a13), (uchar)(a12), (uchar)(a11), (uchar)(a10), (uchar)(a9),     \
-      (uchar)(a8), (uchar)(a7), (uchar)(a6), (uchar)(a5), (uchar)(a4),         \
-      (uchar)(a3), (uchar)(a2), (uchar)(a1), (uchar)(a0))
-
-#ifndef _mm512_cvtpd_pslo
-#ifdef _mm512_zextsi256_si512
-#define _mm512_cvtpd_pslo(a) _mm512_zextps256_ps512(_mm512_cvtpd_ps(a))
-#else
-// if preferred way to extend with zeros is unavailable
-#define _mm512_cvtpd_pslo(a) _mm512_castps256_ps512(_mm512_cvtpd_ps(a))
-#endif
-#endif
-///////// Utils ////////////
-
-namespace {
-
-inline __m512i _v512_combine(const __m256i &lo, const __m256i &hi) {
-  return _mm512_inserti32x8(_mm512_castsi256_si512(lo), hi, 1);
-}
-
-inline __m512 _v512_combine(const __m256 &lo, const __m256 &hi) {
-  return _mm512_insertf32x8(_mm512_castps256_ps512(lo), hi, 1);
-}
-
-inline __m512d _v512_combine(const __m256d &lo, const __m256d &hi) {
-  return _mm512_insertf64x4(_mm512_castpd256_pd512(lo), hi, 1);
-}
-
-inline int _v_cvtsi512_si32(const __m512i &a) {
-  return _mm_cvtsi128_si32(_mm512_castsi512_si128(a));
-}
-
-inline __m256i _v512_extract_high(const __m512i &v) {
-  return _mm512_extracti32x8_epi32(v, 1);
-}
-
-inline __m256 _v512_extract_high(const __m512 &v) {
-  return _mm512_extractf32x8_ps(v, 1);
-}
-
-inline __m256d _v512_extract_high(const __m512d &v) {
-  return _mm512_extractf64x4_pd(v, 1);
-}
-
-inline __m256i _v512_extract_low(const __m512i &v) {
-  return _mm512_castsi512_si256(v);
-}
-
-inline __m256 _v512_extract_low(const __m512 &v) {
-  return _mm512_castps512_ps256(v);
-}
-
-inline __m256d _v512_extract_low(const __m512d &v) {
-  return _mm512_castpd512_pd256(v);
-}
-
-inline __m512i _v512_insert(const __m512i &a, const __m256i &b) {
-  return _mm512_inserti32x8(a, b, 0);
-}
-
-inline __m512 _v512_insert(const __m512 &a, const __m256 &b) {
-  return _mm512_insertf32x8(a, b, 0);
-}
-
-inline __m512d _v512_insert(const __m512d &a, const __m256d &b) {
-  return _mm512_insertf64x4(a, b, 0);
-}
-
-} // namespace
-
-namespace cv {
-
-//! @cond IGNORED
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_BEGIN
-
-///////// Types ////////////
-
-struct v_uint8x64 {
-  typedef uchar lane_type;
-  enum { nlanes = 64 };
-  __m512i val;
-
-  explicit v_uint8x64(__m512i v) : val(v) {}
-  v_uint8x64(uchar v0, uchar v1, uchar v2, uchar v3, uchar v4, uchar v5,
-             uchar v6, uchar v7, uchar v8, uchar v9, uchar v10, uchar v11,
-             uchar v12, uchar v13, uchar v14, uchar v15, uchar v16, uchar v17,
-             uchar v18, uchar v19, uchar v20, uchar v21, uchar v22, uchar v23,
-             uchar v24, uchar v25, uchar v26, uchar v27, uchar v28, uchar v29,
-             uchar v30, uchar v31, uchar v32, uchar v33, uchar v34, uchar v35,
-             uchar v36, uchar v37, uchar v38, uchar v39, uchar v40, uchar v41,
-             uchar v42, uchar v43, uchar v44, uchar v45, uchar v46, uchar v47,
-             uchar v48, uchar v49, uchar v50, uchar v51, uchar v52, uchar v53,
-             uchar v54, uchar v55, uchar v56, uchar v57, uchar v58, uchar v59,
-             uchar v60, uchar v61, uchar v62, uchar v63) {
-    val = _v512_set_epu8(v63, v62, v61, v60, v59, v58, v57, v56, v55, v54, v53,
-                         v52, v51, v50, v49, v48, v47, v46, v45, v44, v43, v42,
-                         v41, v40, v39, v38, v37, v36, v35, v34, v33, v32, v31,
-                         v30, v29, v28, v27, v26, v25, v24, v23, v22, v21, v20,
-                         v19, v18, v17, v16, v15, v14, v13, v12, v11, v10, v9,
-                         v8, v7, v6, v5, v4, v3, v2, v1, v0);
-  }
-  v_uint8x64() {}
-
-  static inline v_uint8x64 zero() { return v_uint8x64(_mm512_setzero_si512()); }
-
-  uchar get0() const { return (uchar)_v_cvtsi512_si32(val); }
-};
-
-struct v_int8x64 {
-  typedef schar lane_type;
-  enum { nlanes = 64 };
-  __m512i val;
-
-  explicit v_int8x64(__m512i v) : val(v) {}
-  v_int8x64(schar v0, schar v1, schar v2, schar v3, schar v4, schar v5,
-            schar v6, schar v7, schar v8, schar v9, schar v10, schar v11,
-            schar v12, schar v13, schar v14, schar v15, schar v16, schar v17,
-            schar v18, schar v19, schar v20, schar v21, schar v22, schar v23,
-            schar v24, schar v25, schar v26, schar v27, schar v28, schar v29,
-            schar v30, schar v31, schar v32, schar v33, schar v34, schar v35,
-            schar v36, schar v37, schar v38, schar v39, schar v40, schar v41,
-            schar v42, schar v43, schar v44, schar v45, schar v46, schar v47,
-            schar v48, schar v49, schar v50, schar v51, schar v52, schar v53,
-            schar v54, schar v55, schar v56, schar v57, schar v58, schar v59,
-            schar v60, schar v61, schar v62, schar v63) {
-    val = _v512_set_epi8(v63, v62, v61, v60, v59, v58, v57, v56, v55, v54, v53,
-                         v52, v51, v50, v49, v48, v47, v46, v45, v44, v43, v42,
-                         v41, v40, v39, v38, v37, v36, v35, v34, v33, v32, v31,
-                         v30, v29, v28, v27, v26, v25, v24, v23, v22, v21, v20,
-                         v19, v18, v17, v16, v15, v14, v13, v12, v11, v10, v9,
-                         v8, v7, v6, v5, v4, v3, v2, v1, v0);
-  }
-  v_int8x64() {}
-
-  static inline v_int8x64 zero() { return v_int8x64(_mm512_setzero_si512()); }
-
-  schar get0() const { return (schar)_v_cvtsi512_si32(val); }
-};
-
-struct v_uint16x32 {
-  typedef ushort lane_type;
-  enum { nlanes = 32 };
-  __m512i val;
-
-  explicit v_uint16x32(__m512i v) : val(v) {}
-  v_uint16x32(ushort v0, ushort v1, ushort v2, ushort v3, ushort v4, ushort v5,
-              ushort v6, ushort v7, ushort v8, ushort v9, ushort v10,
-              ushort v11, ushort v12, ushort v13, ushort v14, ushort v15,
-              ushort v16, ushort v17, ushort v18, ushort v19, ushort v20,
-              ushort v21, ushort v22, ushort v23, ushort v24, ushort v25,
-              ushort v26, ushort v27, ushort v28, ushort v29, ushort v30,
-              ushort v31) {
-    val = _v512_set_epu16(v31, v30, v29, v28, v27, v26, v25, v24, v23, v22, v21,
-                          v20, v19, v18, v17, v16, v15, v14, v13, v12, v11, v10,
-                          v9, v8, v7, v6, v5, v4, v3, v2, v1, v0);
-  }
-  v_uint16x32() {}
-
-  static inline v_uint16x32 zero() {
-    return v_uint16x32(_mm512_setzero_si512());
-  }
-
-  ushort get0() const { return (ushort)_v_cvtsi512_si32(val); }
-};
-
-struct v_int16x32 {
-  typedef short lane_type;
-  enum { nlanes = 32 };
-  __m512i val;
-
-  explicit v_int16x32(__m512i v) : val(v) {}
-  v_int16x32(short v0, short v1, short v2, short v3, short v4, short v5,
-             short v6, short v7, short v8, short v9, short v10, short v11,
-             short v12, short v13, short v14, short v15, short v16, short v17,
-             short v18, short v19, short v20, short v21, short v22, short v23,
-             short v24, short v25, short v26, short v27, short v28, short v29,
-             short v30, short v31) {
-    val = _v512_set_epu16((ushort)v31, (ushort)v30, (ushort)v29, (ushort)v28,
-                          (ushort)v27, (ushort)v26, (ushort)v25, (ushort)v24,
-                          (ushort)v23, (ushort)v22, (ushort)v21, (ushort)v20,
-                          (ushort)v19, (ushort)v18, (ushort)v17, (ushort)v16,
-                          (ushort)v15, (ushort)v14, (ushort)v13, (ushort)v12,
-                          (ushort)v11, (ushort)v10, (ushort)v9, (ushort)v8,
-                          (ushort)v7, (ushort)v6, (ushort)v5, (ushort)v4,
-                          (ushort)v3, (ushort)v2, (ushort)v1, (ushort)v0);
-  }
-  v_int16x32() {}
-
-  static inline v_int16x32 zero() { return v_int16x32(_mm512_setzero_si512()); }
-
-  short get0() const { return (short)_v_cvtsi512_si32(val); }
-};
-
-struct v_uint32x16 {
-  typedef unsigned lane_type;
-  enum { nlanes = 16 };
-  __m512i val;
-
-  explicit v_uint32x16(__m512i v) : val(v) {}
-  v_uint32x16(unsigned v0, unsigned v1, unsigned v2, unsigned v3, unsigned v4,
-              unsigned v5, unsigned v6, unsigned v7, unsigned v8, unsigned v9,
-              unsigned v10, unsigned v11, unsigned v12, unsigned v13,
-              unsigned v14, unsigned v15) {
-    val =
-        _mm512_setr_epi32((int)v0, (int)v1, (int)v2, (int)v3, (int)v4, (int)v5,
-                          (int)v6, (int)v7, (int)v8, (int)v9, (int)v10,
-                          (int)v11, (int)v12, (int)v13, (int)v14, (int)v15);
-  }
-  v_uint32x16() {}
-
-  static inline v_uint32x16 zero() {
-    return v_uint32x16(_mm512_setzero_si512());
-  }
-
-  unsigned get0() const { return (unsigned)_v_cvtsi512_si32(val); }
-};
-
-struct v_int32x16 {
-  typedef int lane_type;
-  enum { nlanes = 16 };
-  __m512i val;
-
-  explicit v_int32x16(__m512i v) : val(v) {}
-  v_int32x16(int v0, int v1, int v2, int v3, int v4, int v5, int v6, int v7,
-             int v8, int v9, int v10, int v11, int v12, int v13, int v14,
-             int v15) {
-    val = _mm512_setr_epi32(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
-                            v12, v13, v14, v15);
-  }
-  v_int32x16() {}
-
-  static inline v_int32x16 zero() { return v_int32x16(_mm512_setzero_si512()); }
-
-  int get0() const { return _v_cvtsi512_si32(val); }
-};
-
-struct v_float32x16 {
-  typedef float lane_type;
-  enum { nlanes = 16 };
-  __m512 val;
-
-  explicit v_float32x16(__m512 v) : val(v) {}
-  v_float32x16(float v0, float v1, float v2, float v3, float v4, float v5,
-               float v6, float v7, float v8, float v9, float v10, float v11,
-               float v12, float v13, float v14, float v15) {
-    val = _mm512_setr_ps(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
-                         v13, v14, v15);
-  }
-  v_float32x16() {}
-
-  static inline v_float32x16 zero() {
-    return v_float32x16(_mm512_setzero_ps());
-  }
-
-  float get0() const { return _mm_cvtss_f32(_mm512_castps512_ps128(val)); }
-};
-
-struct v_uint64x8 {
-  typedef uint64 lane_type;
-  enum { nlanes = 8 };
-  __m512i val;
-
-  explicit v_uint64x8(__m512i v) : val(v) {}
-  v_uint64x8(uint64 v0, uint64 v1, uint64 v2, uint64 v3, uint64 v4, uint64 v5,
-             uint64 v6, uint64 v7) {
-    val = _mm512_setr_epi64((int64)v0, (int64)v1, (int64)v2, (int64)v3,
-                            (int64)v4, (int64)v5, (int64)v6, (int64)v7);
-  }
-  v_uint64x8() {}
-
-  static inline v_uint64x8 zero() { return v_uint64x8(_mm512_setzero_si512()); }
-
-  uint64 get0() const {
-#if defined __x86_64__ || defined _M_X64
-    return (uint64)_mm_cvtsi128_si64(_mm512_castsi512_si128(val));
-#else
-    int a = _mm_cvtsi128_si32(_mm512_castsi512_si128(val));
-    int b =
-        _mm_cvtsi128_si32(_mm512_castsi512_si128(_mm512_srli_epi64(val, 32)));
-    return (unsigned)a | ((uint64)(unsigned)b << 32);
-#endif
-  }
-};
-
-struct v_int64x8 {
-  typedef int64 lane_type;
-  enum { nlanes = 8 };
-  __m512i val;
-
-  explicit v_int64x8(__m512i v) : val(v) {}
-  v_int64x8(int64 v0, int64 v1, int64 v2, int64 v3, int64 v4, int64 v5,
-            int64 v6, int64 v7) {
-    val = _mm512_setr_epi64(v0, v1, v2, v3, v4, v5, v6, v7);
-  }
-  v_int64x8() {}
-
-  static inline v_int64x8 zero() { return v_int64x8(_mm512_setzero_si512()); }
-
-  int64 get0() const {
-#if defined __x86_64__ || defined _M_X64
-    return (int64)_mm_cvtsi128_si64(_mm512_castsi512_si128(val));
-#else
-    int a = _mm_cvtsi128_si32(_mm512_castsi512_si128(val));
-    int b =
-        _mm_cvtsi128_si32(_mm512_castsi512_si128(_mm512_srli_epi64(val, 32)));
-    return (int64)((unsigned)a | ((uint64)(unsigned)b << 32));
-#endif
-  }
-};
-
-struct v_float64x8 {
-  typedef double lane_type;
-  enum { nlanes = 8 };
-  __m512d val;
-
-  explicit v_float64x8(__m512d v) : val(v) {}
-  v_float64x8(double v0, double v1, double v2, double v3, double v4, double v5,
-              double v6, double v7) {
-    val = _mm512_setr_pd(v0, v1, v2, v3, v4, v5, v6, v7);
-  }
-  v_float64x8() {}
-
-  static inline v_float64x8 zero() { return v_float64x8(_mm512_setzero_pd()); }
-
-  double get0() const { return _mm_cvtsd_f64(_mm512_castpd512_pd128(val)); }
-};
-
-//////////////// Load and store operations ///////////////
-
-#define OPENCV_HAL_IMPL_AVX512_LOADSTORE(_Tpvec, _Tp)                          \
-  inline _Tpvec v512_load(const _Tp *ptr) {                                    \
-    return _Tpvec(_mm512_loadu_si512((const __m512i *)ptr));                   \
-  }                                                                            \
-  inline _Tpvec v512_load_aligned(const _Tp *ptr) {                            \
-    return _Tpvec(_mm512_load_si512((const __m512i *)ptr));                    \
-  }                                                                            \
-  inline _Tpvec v512_load_low(const _Tp *ptr) {                                \
-    __m256i v256 = _mm256_loadu_si256((const __m256i *)ptr);                   \
-    return _Tpvec(_mm512_castsi256_si512(v256));                               \
-  }                                                                            \
-  inline _Tpvec v512_load_halves(const _Tp *ptr0, const _Tp *ptr1) {           \
-    __m256i vlo = _mm256_loadu_si256((const __m256i *)ptr0);                   \
-    __m256i vhi = _mm256_loadu_si256((const __m256i *)ptr1);                   \
-    return _Tpvec(_v512_combine(vlo, vhi));                                    \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a) {                             \
-    _mm512_storeu_si512((__m512i *)ptr, a.val);                                \
-  }                                                                            \
-  inline void v_store_aligned(_Tp *ptr, const _Tpvec &a) {                     \
-    _mm512_store_si512((__m512i *)ptr, a.val);                                 \
-  }                                                                            \
-  inline void v_store_aligned_nocache(_Tp *ptr, const _Tpvec &a) {             \
-    _mm512_stream_si512((__m512i *)ptr, a.val);                                \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a, hal::StoreMode mode) {        \
-    if (mode == hal::STORE_UNALIGNED)                                          \
-      _mm512_storeu_si512((__m512i *)ptr, a.val);                              \
-    else if (mode == hal::STORE_ALIGNED_NOCACHE)                               \
-      _mm512_stream_si512((__m512i *)ptr, a.val);                              \
-    else                                                                       \
-      _mm512_store_si512((__m512i *)ptr, a.val);                               \
-  }                                                                            \
-  inline void v_store_low(_Tp *ptr, const _Tpvec &a) {                         \
-    _mm256_storeu_si256((__m256i *)ptr, _v512_extract_low(a.val));             \
-  }                                                                            \
-  inline void v_store_high(_Tp *ptr, const _Tpvec &a) {                        \
-    _mm256_storeu_si256((__m256i *)ptr, _v512_extract_high(a.val));            \
-  }
-
-OPENCV_HAL_IMPL_AVX512_LOADSTORE(v_uint8x64, uchar)
-OPENCV_HAL_IMPL_AVX512_LOADSTORE(v_int8x64, schar)
-OPENCV_HAL_IMPL_AVX512_LOADSTORE(v_uint16x32, ushort)
-OPENCV_HAL_IMPL_AVX512_LOADSTORE(v_int16x32, short)
-OPENCV_HAL_IMPL_AVX512_LOADSTORE(v_uint32x16, unsigned)
-OPENCV_HAL_IMPL_AVX512_LOADSTORE(v_int32x16, int)
-OPENCV_HAL_IMPL_AVX512_LOADSTORE(v_uint64x8, uint64)
-OPENCV_HAL_IMPL_AVX512_LOADSTORE(v_int64x8, int64)
-
-#define OPENCV_HAL_IMPL_AVX512_LOADSTORE_FLT(_Tpvec, _Tp, suffix, halfreg)     \
-  inline _Tpvec v512_load(const _Tp *ptr) {                                    \
-    return _Tpvec(_mm512_loadu_##suffix(ptr));                                 \
-  }                                                                            \
-  inline _Tpvec v512_load_aligned(const _Tp *ptr) {                            \
-    return _Tpvec(_mm512_load_##suffix(ptr));                                  \
-  }                                                                            \
-  inline _Tpvec v512_load_low(const _Tp *ptr) {                                \
-    return _Tpvec(                                                             \
-        _mm512_cast##suffix##256_##suffix##512(_mm256_loadu_##suffix(ptr)));   \
-  }                                                                            \
-  inline _Tpvec v512_load_halves(const _Tp *ptr0, const _Tp *ptr1) {           \
-    halfreg vlo = _mm256_loadu_##suffix(ptr0);                                 \
-    halfreg vhi = _mm256_loadu_##suffix(ptr1);                                 \
-    return _Tpvec(_v512_combine(vlo, vhi));                                    \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a) {                             \
-    _mm512_storeu_##suffix(ptr, a.val);                                        \
-  }                                                                            \
-  inline void v_store_aligned(_Tp *ptr, const _Tpvec &a) {                     \
-    _mm512_store_##suffix(ptr, a.val);                                         \
-  }                                                                            \
-  inline void v_store_aligned_nocache(_Tp *ptr, const _Tpvec &a) {             \
-    _mm512_stream_##suffix(ptr, a.val);                                        \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a, hal::StoreMode mode) {        \
-    if (mode == hal::STORE_UNALIGNED)                                          \
-      _mm512_storeu_##suffix(ptr, a.val);                                      \
-    else if (mode == hal::STORE_ALIGNED_NOCACHE)                               \
-      _mm512_stream_##suffix(ptr, a.val);                                      \
-    else                                                                       \
-      _mm512_store_##suffix(ptr, a.val);                                       \
-  }                                                                            \
-  inline void v_store_low(_Tp *ptr, const _Tpvec &a) {                         \
-    _mm256_storeu_##suffix(ptr, _v512_extract_low(a.val));                     \
-  }                                                                            \
-  inline void v_store_high(_Tp *ptr, const _Tpvec &a) {                        \
-    _mm256_storeu_##suffix(ptr, _v512_extract_high(a.val));                    \
-  }
-
-OPENCV_HAL_IMPL_AVX512_LOADSTORE_FLT(v_float32x16, float, ps, __m256)
-OPENCV_HAL_IMPL_AVX512_LOADSTORE_FLT(v_float64x8, double, pd, __m256d)
-
-#define OPENCV_HAL_IMPL_AVX512_CAST(_Tpvec, _Tpvecf, suffix, cast)             \
-  inline _Tpvec v_reinterpret_as_##suffix(const _Tpvecf &a) {                  \
-    return _Tpvec(cast(a.val));                                                \
-  }
-
-#define OPENCV_HAL_IMPL_AVX512_INIT(_Tpvec, _Tp, suffix, ssuffix, ctype_s)     \
-  inline _Tpvec v512_setzero_##suffix() {                                      \
-    return _Tpvec(_mm512_setzero_si512());                                     \
-  }                                                                            \
-  inline _Tpvec v512_setall_##suffix(_Tp v) {                                  \
-    return _Tpvec(_mm512_set1_##ssuffix((ctype_s)v));                          \
-  }                                                                            \
-  template <> inline _Tpvec v_setzero_() { return v512_setzero_##suffix(); }   \
-  template <> inline _Tpvec v_setall_(_Tp v) {                                 \
-    return v512_setall_##suffix(v);                                            \
-  }                                                                            \
-  OPENCV_HAL_IMPL_AVX512_CAST(_Tpvec, v_uint8x64, suffix, OPENCV_HAL_NOP)      \
-  OPENCV_HAL_IMPL_AVX512_CAST(_Tpvec, v_int8x64, suffix, OPENCV_HAL_NOP)       \
-  OPENCV_HAL_IMPL_AVX512_CAST(_Tpvec, v_uint16x32, suffix, OPENCV_HAL_NOP)     \
-  OPENCV_HAL_IMPL_AVX512_CAST(_Tpvec, v_int16x32, suffix, OPENCV_HAL_NOP)      \
-  OPENCV_HAL_IMPL_AVX512_CAST(_Tpvec, v_uint32x16, suffix, OPENCV_HAL_NOP)     \
-  OPENCV_HAL_IMPL_AVX512_CAST(_Tpvec, v_int32x16, suffix, OPENCV_HAL_NOP)      \
-  OPENCV_HAL_IMPL_AVX512_CAST(_Tpvec, v_uint64x8, suffix, OPENCV_HAL_NOP)      \
-  OPENCV_HAL_IMPL_AVX512_CAST(_Tpvec, v_int64x8, suffix, OPENCV_HAL_NOP)       \
-  OPENCV_HAL_IMPL_AVX512_CAST(_Tpvec, v_float32x16, suffix,                    \
-                              _mm512_castps_si512)                             \
-  OPENCV_HAL_IMPL_AVX512_CAST(_Tpvec, v_float64x8, suffix, _mm512_castpd_si512)
-
-OPENCV_HAL_IMPL_AVX512_INIT(v_uint8x64, uchar, u8, epi8, char)
-OPENCV_HAL_IMPL_AVX512_INIT(v_int8x64, schar, s8, epi8, char)
-OPENCV_HAL_IMPL_AVX512_INIT(v_uint16x32, ushort, u16, epi16, short)
-OPENCV_HAL_IMPL_AVX512_INIT(v_int16x32, short, s16, epi16, short)
-OPENCV_HAL_IMPL_AVX512_INIT(v_uint32x16, unsigned, u32, epi32, int)
-OPENCV_HAL_IMPL_AVX512_INIT(v_int32x16, int, s32, epi32, int)
-OPENCV_HAL_IMPL_AVX512_INIT(v_uint64x8, uint64, u64, epi64, int64)
-OPENCV_HAL_IMPL_AVX512_INIT(v_int64x8, int64, s64, epi64, int64)
-
-#define OPENCV_HAL_IMPL_AVX512_INIT_FLT(_Tpvec, _Tp, suffix, zsuffix, cast)    \
-  inline _Tpvec v512_setzero_##suffix() {                                      \
-    return _Tpvec(_mm512_setzero_##zsuffix());                                 \
-  }                                                                            \
-  inline _Tpvec v512_setall_##suffix(_Tp v) {                                  \
-    return _Tpvec(_mm512_set1_##zsuffix(v));                                   \
-  }                                                                            \
-  template <> inline _Tpvec v_setzero_() { return v512_setzero_##suffix(); }   \
-  template <> inline _Tpvec v_setall_(_Tp v) {                                 \
-    return v512_setall_##suffix(v);                                            \
-  }                                                                            \
-  OPENCV_HAL_IMPL_AVX512_CAST(_Tpvec, v_uint8x64, suffix, cast)                \
-  OPENCV_HAL_IMPL_AVX512_CAST(_Tpvec, v_int8x64, suffix, cast)                 \
-  OPENCV_HAL_IMPL_AVX512_CAST(_Tpvec, v_uint16x32, suffix, cast)               \
-  OPENCV_HAL_IMPL_AVX512_CAST(_Tpvec, v_int16x32, suffix, cast)                \
-  OPENCV_HAL_IMPL_AVX512_CAST(_Tpvec, v_uint32x16, suffix, cast)               \
-  OPENCV_HAL_IMPL_AVX512_CAST(_Tpvec, v_int32x16, suffix, cast)                \
-  OPENCV_HAL_IMPL_AVX512_CAST(_Tpvec, v_uint64x8, suffix, cast)                \
-  OPENCV_HAL_IMPL_AVX512_CAST(_Tpvec, v_int64x8, suffix, cast)
-
-OPENCV_HAL_IMPL_AVX512_INIT_FLT(v_float32x16, float, f32, ps,
-                                _mm512_castsi512_ps)
-OPENCV_HAL_IMPL_AVX512_INIT_FLT(v_float64x8, double, f64, pd,
-                                _mm512_castsi512_pd)
-
-inline v_float32x16 v_reinterpret_as_f32(const v_float32x16 &a) { return a; }
-inline v_float32x16 v_reinterpret_as_f32(const v_float64x8 &a) {
-  return v_float32x16(_mm512_castpd_ps(a.val));
-}
-
-inline v_float64x8 v_reinterpret_as_f64(const v_float64x8 &a) { return a; }
-inline v_float64x8 v_reinterpret_as_f64(const v_float32x16 &a) {
-  return v_float64x8(_mm512_castps_pd(a.val));
-}
-
-// FP16
-inline v_float32x16 v512_load_expand(const hfloat *ptr) {
-  return v_float32x16(
-      _mm512_cvtph_ps(_mm256_loadu_si256((const __m256i *)ptr)));
-}
-
-inline void v_pack_store(hfloat *ptr, const v_float32x16 &a) {
-  __m256i ah = _mm512_cvtps_ph(a.val, 0);
-  _mm256_storeu_si256((__m256i *)ptr, ah);
-}
-
-/* Recombine & ZIP */
-inline void v_zip(const v_int8x64 &a, const v_int8x64 &b, v_int8x64 &ab0,
-                  v_int8x64 &ab1) {
-#if CV_AVX_512VBMI
-  __m512i mask0 = _v512_set_epu8(
-      95, 31, 94, 30, 93, 29, 92, 28, 91, 27, 90, 26, 89, 25, 88, 24, 87, 23,
-      86, 22, 85, 21, 84, 20, 83, 19, 82, 18, 81, 17, 80, 16, 79, 15, 78, 14,
-      77, 13, 76, 12, 75, 11, 74, 10, 73, 9, 72, 8, 71, 7, 70, 6, 69, 5, 68, 4,
-      67, 3, 66, 2, 65, 1, 64, 0);
-  ab0 = v_int8x64(_mm512_permutex2var_epi8(a.val, mask0, b.val));
-  __m512i mask1 = _v512_set_epu8(
-      127, 63, 126, 62, 125, 61, 124, 60, 123, 59, 122, 58, 121, 57, 120, 56,
-      119, 55, 118, 54, 117, 53, 116, 52, 115, 51, 114, 50, 113, 49, 112, 48,
-      111, 47, 110, 46, 109, 45, 108, 44, 107, 43, 106, 42, 105, 41, 104, 40,
-      103, 39, 102, 38, 101, 37, 100, 36, 99, 35, 98, 34, 97, 33, 96, 32);
-  ab1 = v_int8x64(_mm512_permutex2var_epi8(a.val, mask1, b.val));
-#else
-  __m512i low = _mm512_unpacklo_epi8(a.val, b.val);
-  __m512i high = _mm512_unpackhi_epi8(a.val, b.val);
-  ab0 = v_int8x64(_mm512_permutex2var_epi64(
-      low, _v512_set_epu64(11, 10, 3, 2, 9, 8, 1, 0), high));
-  ab1 = v_int8x64(_mm512_permutex2var_epi64(
-      low, _v512_set_epu64(15, 14, 7, 6, 13, 12, 5, 4), high));
-#endif
-}
-inline void v_zip(const v_int16x32 &a, const v_int16x32 &b, v_int16x32 &ab0,
-                  v_int16x32 &ab1) {
-  __m512i mask0 = _v512_set_epu16(47, 15, 46, 14, 45, 13, 44, 12, 43, 11, 42,
-                                  10, 41, 9, 40, 8, 39, 7, 38, 6, 37, 5, 36, 4,
-                                  35, 3, 34, 2, 33, 1, 32, 0);
-  ab0 = v_int16x32(_mm512_permutex2var_epi16(a.val, mask0, b.val));
-  __m512i mask1 = _v512_set_epu16(63, 31, 62, 30, 61, 29, 60, 28, 59, 27, 58,
-                                  26, 57, 25, 56, 24, 55, 23, 54, 22, 53, 21,
-                                  52, 20, 51, 19, 50, 18, 49, 17, 48, 16);
-  ab1 = v_int16x32(_mm512_permutex2var_epi16(a.val, mask1, b.val));
-}
-inline void v_zip(const v_int32x16 &a, const v_int32x16 &b, v_int32x16 &ab0,
-                  v_int32x16 &ab1) {
-  __m512i mask0 =
-      _v512_set_epu32(23, 7, 22, 6, 21, 5, 20, 4, 19, 3, 18, 2, 17, 1, 16, 0);
-  ab0 = v_int32x16(_mm512_permutex2var_epi32(a.val, mask0, b.val));
-  __m512i mask1 = _v512_set_epu32(31, 15, 30, 14, 29, 13, 28, 12, 27, 11, 26,
-                                  10, 25, 9, 24, 8);
-  ab1 = v_int32x16(_mm512_permutex2var_epi32(a.val, mask1, b.val));
-}
-inline void v_zip(const v_int64x8 &a, const v_int64x8 &b, v_int64x8 &ab0,
-                  v_int64x8 &ab1) {
-  __m512i mask0 = _v512_set_epu64(11, 3, 10, 2, 9, 1, 8, 0);
-  ab0 = v_int64x8(_mm512_permutex2var_epi64(a.val, mask0, b.val));
-  __m512i mask1 = _v512_set_epu64(15, 7, 14, 6, 13, 5, 12, 4);
-  ab1 = v_int64x8(_mm512_permutex2var_epi64(a.val, mask1, b.val));
-}
-
-inline void v_zip(const v_uint8x64 &a, const v_uint8x64 &b, v_uint8x64 &ab0,
-                  v_uint8x64 &ab1) {
-  v_int8x64 i0, i1;
-  v_zip(v_reinterpret_as_s8(a), v_reinterpret_as_s8(b), i0, i1);
-  ab0 = v_reinterpret_as_u8(i0);
-  ab1 = v_reinterpret_as_u8(i1);
-}
-inline void v_zip(const v_uint16x32 &a, const v_uint16x32 &b, v_uint16x32 &ab0,
-                  v_uint16x32 &ab1) {
-  v_int16x32 i0, i1;
-  v_zip(v_reinterpret_as_s16(a), v_reinterpret_as_s16(b), i0, i1);
-  ab0 = v_reinterpret_as_u16(i0);
-  ab1 = v_reinterpret_as_u16(i1);
-}
-inline void v_zip(const v_uint32x16 &a, const v_uint32x16 &b, v_uint32x16 &ab0,
-                  v_uint32x16 &ab1) {
-  v_int32x16 i0, i1;
-  v_zip(v_reinterpret_as_s32(a), v_reinterpret_as_s32(b), i0, i1);
-  ab0 = v_reinterpret_as_u32(i0);
-  ab1 = v_reinterpret_as_u32(i1);
-}
-inline void v_zip(const v_uint64x8 &a, const v_uint64x8 &b, v_uint64x8 &ab0,
-                  v_uint64x8 &ab1) {
-  v_int64x8 i0, i1;
-  v_zip(v_reinterpret_as_s64(a), v_reinterpret_as_s64(b), i0, i1);
-  ab0 = v_reinterpret_as_u64(i0);
-  ab1 = v_reinterpret_as_u64(i1);
-}
-inline void v_zip(const v_float32x16 &a, const v_float32x16 &b,
-                  v_float32x16 &ab0, v_float32x16 &ab1) {
-  v_int32x16 i0, i1;
-  v_zip(v_reinterpret_as_s32(a), v_reinterpret_as_s32(b), i0, i1);
-  ab0 = v_reinterpret_as_f32(i0);
-  ab1 = v_reinterpret_as_f32(i1);
-}
-inline void v_zip(const v_float64x8 &a, const v_float64x8 &b, v_float64x8 &ab0,
-                  v_float64x8 &ab1) {
-  v_int64x8 i0, i1;
-  v_zip(v_reinterpret_as_s64(a), v_reinterpret_as_s64(b), i0, i1);
-  ab0 = v_reinterpret_as_f64(i0);
-  ab1 = v_reinterpret_as_f64(i1);
-}
-
-#define OPENCV_HAL_IMPL_AVX512_COMBINE(_Tpvec, suffix)                         \
-  inline _Tpvec v_combine_low(const _Tpvec &a, const _Tpvec &b) {              \
-    return _Tpvec(                                                             \
-        _v512_combine(_v512_extract_low(a.val), _v512_extract_low(b.val)));    \
-  }                                                                            \
-  inline _Tpvec v_combine_high(const _Tpvec &a, const _Tpvec &b) {             \
-    return _Tpvec(_v512_insert(b.val, _v512_extract_high(a.val)));             \
-  }                                                                            \
-  inline void v_recombine(const _Tpvec &a, const _Tpvec &b, _Tpvec &c,         \
-                          _Tpvec &d) {                                         \
-    c.val = _v512_combine(_v512_extract_low(a.val), _v512_extract_low(b.val)); \
-    d.val = _v512_insert(b.val, _v512_extract_high(a.val));                    \
-  }
-
-OPENCV_HAL_IMPL_AVX512_COMBINE(v_uint8x64, epi8)
-OPENCV_HAL_IMPL_AVX512_COMBINE(v_int8x64, epi8)
-OPENCV_HAL_IMPL_AVX512_COMBINE(v_uint16x32, epi16)
-OPENCV_HAL_IMPL_AVX512_COMBINE(v_int16x32, epi16)
-OPENCV_HAL_IMPL_AVX512_COMBINE(v_uint32x16, epi32)
-OPENCV_HAL_IMPL_AVX512_COMBINE(v_int32x16, epi32)
-OPENCV_HAL_IMPL_AVX512_COMBINE(v_uint64x8, epi64)
-OPENCV_HAL_IMPL_AVX512_COMBINE(v_int64x8, epi64)
-OPENCV_HAL_IMPL_AVX512_COMBINE(v_float32x16, ps)
-OPENCV_HAL_IMPL_AVX512_COMBINE(v_float64x8, pd)
-
-////////// Arithmetic, bitwise and comparison operations /////////
-
-/* Element-wise binary and unary operations */
-
-/** Non-saturating arithmetics **/
-#define OPENCV_HAL_IMPL_AVX512_BIN_FUNC(func, _Tpvec, intrin)                  \
-  inline _Tpvec func(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(intrin(a.val, b.val));                                       \
-  }
-
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_add_wrap, v_uint8x64, _mm512_add_epi8)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_add_wrap, v_int8x64, _mm512_add_epi8)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_add_wrap, v_uint16x32, _mm512_add_epi16)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_add_wrap, v_int16x32, _mm512_add_epi16)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_sub_wrap, v_uint8x64, _mm512_sub_epi8)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_sub_wrap, v_int8x64, _mm512_sub_epi8)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_sub_wrap, v_uint16x32, _mm512_sub_epi16)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_sub_wrap, v_int16x32, _mm512_sub_epi16)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_mul_wrap, v_uint16x32, _mm512_mullo_epi16)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_mul_wrap, v_int16x32, _mm512_mullo_epi16)
-
-inline v_uint8x64 v_mul_wrap(const v_uint8x64 &a, const v_uint8x64 &b) {
-  __m512i ad = _mm512_srai_epi16(a.val, 8);
-  __m512i bd = _mm512_srai_epi16(b.val, 8);
-  __m512i p0 = _mm512_mullo_epi16(a.val, b.val);                 // even
-  __m512i p1 = _mm512_slli_epi16(_mm512_mullo_epi16(ad, bd), 8); // odd
-  return v_uint8x64(_mm512_mask_blend_epi8(0xAAAAAAAAAAAAAAAA, p0, p1));
-}
-inline v_int8x64 v_mul_wrap(const v_int8x64 &a, const v_int8x64 &b) {
-  return v_reinterpret_as_s8(
-      v_mul_wrap(v_reinterpret_as_u8(a), v_reinterpret_as_u8(b)));
-}
-
-#define OPENCV_HAL_IMPL_AVX512_BIN_OP(bin_op, _Tpvec, intrin)                  \
-  inline _Tpvec bin_op(const _Tpvec &a, const _Tpvec &b) {                     \
-    return _Tpvec(intrin(a.val, b.val));                                       \
-  }
-
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_add, v_uint32x16, _mm512_add_epi32)
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_sub, v_uint32x16, _mm512_sub_epi32)
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_add, v_int32x16, _mm512_add_epi32)
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_sub, v_int32x16, _mm512_sub_epi32)
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_add, v_uint64x8, _mm512_add_epi64)
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_sub, v_uint64x8, _mm512_sub_epi64)
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_add, v_int64x8, _mm512_add_epi64)
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_sub, v_int64x8, _mm512_sub_epi64)
-
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_mul, v_uint32x16, _mm512_mullo_epi32)
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_mul, v_int32x16, _mm512_mullo_epi32)
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_mul, v_uint64x8, _mm512_mullo_epi64)
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_mul, v_int64x8, _mm512_mullo_epi64)
-
-/** Saturating arithmetics **/
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_add, v_uint8x64, _mm512_adds_epu8)
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_sub, v_uint8x64, _mm512_subs_epu8)
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_add, v_int8x64, _mm512_adds_epi8)
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_sub, v_int8x64, _mm512_subs_epi8)
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_add, v_uint16x32, _mm512_adds_epu16)
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_sub, v_uint16x32, _mm512_subs_epu16)
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_add, v_int16x32, _mm512_adds_epi16)
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_sub, v_int16x32, _mm512_subs_epi16)
-
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_add, v_float32x16, _mm512_add_ps)
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_sub, v_float32x16, _mm512_sub_ps)
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_mul, v_float32x16, _mm512_mul_ps)
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_div, v_float32x16, _mm512_div_ps)
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_add, v_float64x8, _mm512_add_pd)
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_sub, v_float64x8, _mm512_sub_pd)
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_mul, v_float64x8, _mm512_mul_pd)
-OPENCV_HAL_IMPL_AVX512_BIN_OP(v_div, v_float64x8, _mm512_div_pd)
-
-// saturating multiply
-inline v_uint8x64 v_mul(const v_uint8x64 &a, const v_uint8x64 &b) {
-  v_uint16x32 c, d;
-  v_mul_expand(a, b, c, d);
-  return v_pack(c, d);
-}
-inline v_int8x64 v_mul(const v_int8x64 &a, const v_int8x64 &b) {
-  v_int16x32 c, d;
-  v_mul_expand(a, b, c, d);
-  return v_pack(c, d);
-}
-inline v_uint16x32 v_mul(const v_uint16x32 &a, const v_uint16x32 &b) {
-  __m512i pl = _mm512_mullo_epi16(a.val, b.val);
-  __m512i ph = _mm512_mulhi_epu16(a.val, b.val);
-  __m512i p0 = _mm512_unpacklo_epi16(pl, ph);
-  __m512i p1 = _mm512_unpackhi_epi16(pl, ph);
-
-  const __m512i m = _mm512_set1_epi32(65535);
-  return v_uint16x32(
-      _mm512_packus_epi32(_mm512_min_epu32(p0, m), _mm512_min_epu32(p1, m)));
-}
-inline v_int16x32 v_mul(const v_int16x32 &a, const v_int16x32 &b) {
-  __m512i pl = _mm512_mullo_epi16(a.val, b.val);
-  __m512i ph = _mm512_mulhi_epi16(a.val, b.val);
-  __m512i p0 = _mm512_unpacklo_epi16(pl, ph);
-  __m512i p1 = _mm512_unpackhi_epi16(pl, ph);
-  return v_int16x32(_mm512_packs_epi32(p0, p1));
-}
-
-inline v_int16x32 v_mul_hi(const v_int16x32 &a, const v_int16x32 &b) {
-  return v_int16x32(_mm512_mulhi_epi16(a.val, b.val));
-}
-inline v_uint16x32 v_mul_hi(const v_uint16x32 &a, const v_uint16x32 &b) {
-  return v_uint16x32(_mm512_mulhi_epu16(a.val, b.val));
-}
-
-//  Multiply and expand
-inline void v_mul_expand(const v_uint8x64 &a, const v_uint8x64 &b,
-                         v_uint16x32 &c, v_uint16x32 &d) {
-  v_uint16x32 a0, a1, b0, b1;
-  v_expand(a, a0, a1);
-  v_expand(b, b0, b1);
-  c = v_mul_wrap(a0, b0);
-  d = v_mul_wrap(a1, b1);
-}
-
-inline void v_mul_expand(const v_int8x64 &a, const v_int8x64 &b, v_int16x32 &c,
-                         v_int16x32 &d) {
-  v_int16x32 a0, a1, b0, b1;
-  v_expand(a, a0, a1);
-  v_expand(b, b0, b1);
-  c = v_mul_wrap(a0, b0);
-  d = v_mul_wrap(a1, b1);
-}
-
-inline void v_mul_expand(const v_int16x32 &a, const v_int16x32 &b,
-                         v_int32x16 &c, v_int32x16 &d) {
-  v_int16x32 v0, v1;
-  v_zip(v_mul_wrap(a, b), v_mul_hi(a, b), v0, v1);
-
-  c = v_reinterpret_as_s32(v0);
-  d = v_reinterpret_as_s32(v1);
-}
-
-inline void v_mul_expand(const v_uint16x32 &a, const v_uint16x32 &b,
-                         v_uint32x16 &c, v_uint32x16 &d) {
-  v_uint16x32 v0, v1;
-  v_zip(v_mul_wrap(a, b), v_mul_hi(a, b), v0, v1);
-
-  c = v_reinterpret_as_u32(v0);
-  d = v_reinterpret_as_u32(v1);
-}
-
-inline void v_mul_expand(const v_uint32x16 &a, const v_uint32x16 &b,
-                         v_uint64x8 &c, v_uint64x8 &d) {
-  v_zip(v_uint64x8(_mm512_mul_epu32(a.val, b.val)),
-        v_uint64x8(_mm512_mul_epu32(_mm512_srli_epi64(a.val, 32),
-                                    _mm512_srli_epi64(b.val, 32))),
-        c, d);
-}
-
-inline void v_mul_expand(const v_int32x16 &a, const v_int32x16 &b, v_int64x8 &c,
-                         v_int64x8 &d) {
-  v_zip(v_int64x8(_mm512_mul_epi32(a.val, b.val)),
-        v_int64x8(_mm512_mul_epi32(_mm512_srli_epi64(a.val, 32),
-                                   _mm512_srli_epi64(b.val, 32))),
-        c, d);
-}
-
-/** Bitwise shifts **/
-#define OPENCV_HAL_IMPL_AVX512_SHIFT_OP(_Tpuvec, _Tpsvec, suffix)              \
-  inline _Tpuvec v_shl(const _Tpuvec &a, int imm) {                            \
-    return _Tpuvec(_mm512_slli_##suffix(a.val, imm));                          \
-  }                                                                            \
-  inline _Tpsvec v_shl(const _Tpsvec &a, int imm) {                            \
-    return _Tpsvec(_mm512_slli_##suffix(a.val, imm));                          \
-  }                                                                            \
-  inline _Tpuvec v_shr(const _Tpuvec &a, int imm) {                            \
-    return _Tpuvec(_mm512_srli_##suffix(a.val, imm));                          \
-  }                                                                            \
-  inline _Tpsvec v_shr(const _Tpsvec &a, int imm) {                            \
-    return _Tpsvec(_mm512_srai_##suffix(a.val, imm));                          \
-  }                                                                            \
-  template <int imm> inline _Tpuvec v_shl(const _Tpuvec &a) {                  \
-    return _Tpuvec(_mm512_slli_##suffix(a.val, imm));                          \
-  }                                                                            \
-  template <int imm> inline _Tpsvec v_shl(const _Tpsvec &a) {                  \
-    return _Tpsvec(_mm512_slli_##suffix(a.val, imm));                          \
-  }                                                                            \
-  template <int imm> inline _Tpuvec v_shr(const _Tpuvec &a) {                  \
-    return _Tpuvec(_mm512_srli_##suffix(a.val, imm));                          \
-  }                                                                            \
-  template <int imm> inline _Tpsvec v_shr(const _Tpsvec &a) {                  \
-    return _Tpsvec(_mm512_srai_##suffix(a.val, imm));                          \
-  }
-
-OPENCV_HAL_IMPL_AVX512_SHIFT_OP(v_uint16x32, v_int16x32, epi16)
-OPENCV_HAL_IMPL_AVX512_SHIFT_OP(v_uint32x16, v_int32x16, epi32)
-OPENCV_HAL_IMPL_AVX512_SHIFT_OP(v_uint64x8, v_int64x8, epi64)
-
-/** Bitwise logic **/
-#define OPENCV_HAL_IMPL_AVX512_LOGIC_OP(_Tpvec, suffix, not_const)             \
-  OPENCV_HAL_IMPL_AVX512_BIN_OP(v_and, _Tpvec, _mm512_and_##suffix)            \
-  OPENCV_HAL_IMPL_AVX512_BIN_OP(v_or, _Tpvec, _mm512_or_##suffix)              \
-  OPENCV_HAL_IMPL_AVX512_BIN_OP(v_xor, _Tpvec, _mm512_xor_##suffix)            \
-  inline _Tpvec v_not(const _Tpvec &a) {                                       \
-    return _Tpvec(_mm512_xor_##suffix(a.val, not_const));                      \
-  }
-
-OPENCV_HAL_IMPL_AVX512_LOGIC_OP(v_uint8x64, si512, _mm512_set1_epi32(-1))
-OPENCV_HAL_IMPL_AVX512_LOGIC_OP(v_int8x64, si512, _mm512_set1_epi32(-1))
-OPENCV_HAL_IMPL_AVX512_LOGIC_OP(v_uint16x32, si512, _mm512_set1_epi32(-1))
-OPENCV_HAL_IMPL_AVX512_LOGIC_OP(v_int16x32, si512, _mm512_set1_epi32(-1))
-OPENCV_HAL_IMPL_AVX512_LOGIC_OP(v_uint32x16, si512, _mm512_set1_epi32(-1))
-OPENCV_HAL_IMPL_AVX512_LOGIC_OP(v_int32x16, si512, _mm512_set1_epi32(-1))
-OPENCV_HAL_IMPL_AVX512_LOGIC_OP(v_uint64x8, si512, _mm512_set1_epi64(-1))
-OPENCV_HAL_IMPL_AVX512_LOGIC_OP(v_int64x8, si512, _mm512_set1_epi64(-1))
-OPENCV_HAL_IMPL_AVX512_LOGIC_OP(v_float32x16, ps,
-                                _mm512_castsi512_ps(_mm512_set1_epi32(-1)))
-OPENCV_HAL_IMPL_AVX512_LOGIC_OP(v_float64x8, pd,
-                                _mm512_castsi512_pd(_mm512_set1_epi32(-1)))
-
-/** Select **/
-#define OPENCV_HAL_IMPL_AVX512_SELECT(_Tpvec, suffix, zsuf)                    \
-  inline _Tpvec v_select(const _Tpvec &mask, const _Tpvec &a,                  \
-                         const _Tpvec &b) {                                    \
-    return _Tpvec(_mm512_mask_blend_##suffix(                                  \
-        _mm512_cmp_##suffix##_mask(mask.val, _mm512_setzero_##zsuf(),          \
-                                   _MM_CMPINT_EQ),                             \
-        a.val, b.val));                                                        \
-  }
-
-OPENCV_HAL_IMPL_AVX512_SELECT(v_uint8x64, epi8, si512)
-OPENCV_HAL_IMPL_AVX512_SELECT(v_int8x64, epi8, si512)
-OPENCV_HAL_IMPL_AVX512_SELECT(v_uint16x32, epi16, si512)
-OPENCV_HAL_IMPL_AVX512_SELECT(v_int16x32, epi16, si512)
-OPENCV_HAL_IMPL_AVX512_SELECT(v_uint32x16, epi32, si512)
-OPENCV_HAL_IMPL_AVX512_SELECT(v_int32x16, epi32, si512)
-OPENCV_HAL_IMPL_AVX512_SELECT(v_uint64x8, epi64, si512)
-OPENCV_HAL_IMPL_AVX512_SELECT(v_int64x8, epi64, si512)
-OPENCV_HAL_IMPL_AVX512_SELECT(v_float32x16, ps, ps)
-OPENCV_HAL_IMPL_AVX512_SELECT(v_float64x8, pd, pd)
-
-/** Comparison **/
-#define OPENCV_HAL_IMPL_AVX512_CMP_INT(bin_op, imm8, _Tpvec, sufcmp, sufset,   \
-                                       tval)                                   \
-  inline _Tpvec bin_op(const _Tpvec &a, const _Tpvec &b) {                     \
-    return _Tpvec(_mm512_maskz_set1_##sufset(                                  \
-        _mm512_cmp_##sufcmp##_mask(a.val, b.val, imm8), tval));                \
-  }
-
-#define OPENCV_HAL_IMPL_AVX512_CMP_OP_INT(_Tpvec, sufcmp, sufset, tval)        \
-  OPENCV_HAL_IMPL_AVX512_CMP_INT(v_eq, _MM_CMPINT_EQ, _Tpvec, sufcmp, sufset,  \
-                                 tval)                                         \
-  OPENCV_HAL_IMPL_AVX512_CMP_INT(v_ne, _MM_CMPINT_NE, _Tpvec, sufcmp, sufset,  \
-                                 tval)                                         \
-  OPENCV_HAL_IMPL_AVX512_CMP_INT(v_lt, _MM_CMPINT_LT, _Tpvec, sufcmp, sufset,  \
-                                 tval)                                         \
-  OPENCV_HAL_IMPL_AVX512_CMP_INT(v_gt, _MM_CMPINT_NLE, _Tpvec, sufcmp, sufset, \
-                                 tval)                                         \
-  OPENCV_HAL_IMPL_AVX512_CMP_INT(v_le, _MM_CMPINT_LE, _Tpvec, sufcmp, sufset,  \
-                                 tval)                                         \
-  OPENCV_HAL_IMPL_AVX512_CMP_INT(v_ge, _MM_CMPINT_NLT, _Tpvec, sufcmp, sufset, \
-                                 tval)
-
-OPENCV_HAL_IMPL_AVX512_CMP_OP_INT(v_uint8x64, epu8, epi8, (char)-1)
-OPENCV_HAL_IMPL_AVX512_CMP_OP_INT(v_int8x64, epi8, epi8, (char)-1)
-OPENCV_HAL_IMPL_AVX512_CMP_OP_INT(v_uint16x32, epu16, epi16, (short)-1)
-OPENCV_HAL_IMPL_AVX512_CMP_OP_INT(v_int16x32, epi16, epi16, (short)-1)
-OPENCV_HAL_IMPL_AVX512_CMP_OP_INT(v_uint32x16, epu32, epi32, (int)-1)
-OPENCV_HAL_IMPL_AVX512_CMP_OP_INT(v_int32x16, epi32, epi32, (int)-1)
-OPENCV_HAL_IMPL_AVX512_CMP_OP_INT(v_uint64x8, epu64, epi64, (int64)-1)
-OPENCV_HAL_IMPL_AVX512_CMP_OP_INT(v_int64x8, epi64, epi64, (int64)-1)
-
-#define OPENCV_HAL_IMPL_AVX512_CMP_FLT(bin_op, imm8, _Tpvec, sufcmp, sufset,   \
-                                       tval)                                   \
-  inline _Tpvec bin_op(const _Tpvec &a, const _Tpvec &b) {                     \
-    return _Tpvec(_mm512_castsi512_##sufcmp(_mm512_maskz_set1_##sufset(        \
-        _mm512_cmp_##sufcmp##_mask(a.val, b.val, imm8), tval)));               \
-  }
-
-#define OPENCV_HAL_IMPL_AVX512_CMP_OP_FLT(_Tpvec, sufcmp, sufset, tval)        \
-  OPENCV_HAL_IMPL_AVX512_CMP_FLT(v_eq, _CMP_EQ_OQ, _Tpvec, sufcmp, sufset,     \
-                                 tval)                                         \
-  OPENCV_HAL_IMPL_AVX512_CMP_FLT(v_ne, _CMP_NEQ_OQ, _Tpvec, sufcmp, sufset,    \
-                                 tval)                                         \
-  OPENCV_HAL_IMPL_AVX512_CMP_FLT(v_lt, _CMP_LT_OQ, _Tpvec, sufcmp, sufset,     \
-                                 tval)                                         \
-  OPENCV_HAL_IMPL_AVX512_CMP_FLT(v_gt, _CMP_GT_OQ, _Tpvec, sufcmp, sufset,     \
-                                 tval)                                         \
-  OPENCV_HAL_IMPL_AVX512_CMP_FLT(v_le, _CMP_LE_OQ, _Tpvec, sufcmp, sufset,     \
-                                 tval)                                         \
-  OPENCV_HAL_IMPL_AVX512_CMP_FLT(v_ge, _CMP_GE_OQ, _Tpvec, sufcmp, sufset, tval)
-
-OPENCV_HAL_IMPL_AVX512_CMP_OP_FLT(v_float32x16, ps, epi32, (int)-1)
-OPENCV_HAL_IMPL_AVX512_CMP_OP_FLT(v_float64x8, pd, epi64, (int64)-1)
-
-inline v_float32x16 v_not_nan(const v_float32x16 &a) {
-  return v_float32x16(_mm512_castsi512_ps(_mm512_maskz_set1_epi32(
-      _mm512_cmp_ps_mask(a.val, a.val, _CMP_ORD_Q), (int)-1)));
-}
-inline v_float64x8 v_not_nan(const v_float64x8 &a) {
-  return v_float64x8(_mm512_castsi512_pd(_mm512_maskz_set1_epi64(
-      _mm512_cmp_pd_mask(a.val, a.val, _CMP_ORD_Q), (int64)-1)));
-}
-
-/** min/max **/
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_min, v_uint8x64, _mm512_min_epu8)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_max, v_uint8x64, _mm512_max_epu8)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_min, v_int8x64, _mm512_min_epi8)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_max, v_int8x64, _mm512_max_epi8)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_min, v_uint16x32, _mm512_min_epu16)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_max, v_uint16x32, _mm512_max_epu16)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_min, v_int16x32, _mm512_min_epi16)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_max, v_int16x32, _mm512_max_epi16)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_min, v_uint32x16, _mm512_min_epu32)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_max, v_uint32x16, _mm512_max_epu32)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_min, v_int32x16, _mm512_min_epi32)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_max, v_int32x16, _mm512_max_epi32)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_min, v_uint64x8, _mm512_min_epu64)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_max, v_uint64x8, _mm512_max_epu64)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_min, v_int64x8, _mm512_min_epi64)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_max, v_int64x8, _mm512_max_epi64)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_min, v_float32x16, _mm512_min_ps)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_max, v_float32x16, _mm512_max_ps)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_min, v_float64x8, _mm512_min_pd)
-OPENCV_HAL_IMPL_AVX512_BIN_FUNC(v_max, v_float64x8, _mm512_max_pd)
-
-/** Rotate **/
-namespace {
-template <bool prec, int imm4, bool part, int imm32> struct _v_rotate_right {
-  static inline v_int8x64 eval(const v_int8x64 &, const v_int8x64 &) {
-    return v_int8x64();
-  }
-};
-template <int imm4, int imm32>
-struct _v_rotate_right<true, imm4, false, imm32> {
-  static inline v_int8x64 eval(const v_int8x64 &a, const v_int8x64 &b) {
-    return v_int8x64(_mm512_or_si512(
-        _mm512_srli_epi32(_mm512_alignr_epi32(b.val, a.val, imm32), imm4 * 8),
-        _mm512_slli_epi32(_mm512_alignr_epi32(b.val, a.val, imm32 + 1),
-                          (4 - imm4) * 8)));
-  }
-};
-template <int imm4> struct _v_rotate_right<true, imm4, false, 15> {
-  static inline v_int8x64 eval(const v_int8x64 &a, const v_int8x64 &b) {
-    return v_int8x64(_mm512_or_si512(
-        _mm512_srli_epi32(_mm512_alignr_epi32(b.val, a.val, 15), imm4 * 8),
-        _mm512_slli_epi32(b.val, (4 - imm4) * 8)));
-  }
-};
-template <int imm4, int imm32> struct _v_rotate_right<true, imm4, true, imm32> {
-  static inline v_int8x64 eval(const v_int8x64 &, const v_int8x64 &b) {
-    return v_int8x64(_mm512_or_si512(
-        _mm512_srli_epi32(
-            _mm512_alignr_epi32(_mm512_setzero_si512(), b.val, imm32 - 16),
-            imm4 * 8),
-        _mm512_slli_epi32(
-            _mm512_alignr_epi32(_mm512_setzero_si512(), b.val, imm32 - 15),
-            (4 - imm4) * 8)));
-  }
-};
-template <int imm4> struct _v_rotate_right<true, imm4, true, 31> {
-  static inline v_int8x64 eval(const v_int8x64 &, const v_int8x64 &b) {
-    return v_int8x64(_mm512_srli_epi32(
-        _mm512_alignr_epi32(_mm512_setzero_si512(), b.val, 15), imm4 * 8));
-  }
-};
-template <int imm32> struct _v_rotate_right<false, 0, false, imm32> {
-  static inline v_int8x64 eval(const v_int8x64 &a, const v_int8x64 &b) {
-    return v_int8x64(_mm512_alignr_epi32(b.val, a.val, imm32));
-  }
-};
-template <> struct _v_rotate_right<false, 0, false, 0> {
-  static inline v_int8x64 eval(const v_int8x64 &a, const v_int8x64 &) {
-    return a;
-  }
-};
-template <int imm32> struct _v_rotate_right<false, 0, true, imm32> {
-  static inline v_int8x64 eval(const v_int8x64 &, const v_int8x64 &b) {
-    return v_int8x64(
-        _mm512_alignr_epi32(_mm512_setzero_si512(), b.val, imm32 - 16));
-  }
-};
-template <> struct _v_rotate_right<false, 0, true, 16> {
-  static inline v_int8x64 eval(const v_int8x64 &, const v_int8x64 &b) {
-    return b;
-  }
-};
-template <> struct _v_rotate_right<false, 0, true, 32> {
-  static inline v_int8x64 eval(const v_int8x64 &, const v_int8x64 &) {
-    return v_int8x64();
-  }
-};
-} // namespace
-template <int imm>
-inline v_int8x64 v_rotate_right(const v_int8x64 &a, const v_int8x64 &b) {
-  return imm >= 128
-             ? v_int8x64()
-             :
-#if CV_AVX_512VBMI
-             v_int8x64(_mm512_permutex2var_epi8(
-                 a.val,
-                 _v512_set_epu8(
-                     0x3f + imm, 0x3e + imm, 0x3d + imm, 0x3c + imm, 0x3b + imm,
-                     0x3a + imm, 0x39 + imm, 0x38 + imm, 0x37 + imm, 0x36 + imm,
-                     0x35 + imm, 0x34 + imm, 0x33 + imm, 0x32 + imm, 0x31 + imm,
-                     0x30 + imm, 0x2f + imm, 0x2e + imm, 0x2d + imm, 0x2c + imm,
-                     0x2b + imm, 0x2a + imm, 0x29 + imm, 0x28 + imm, 0x27 + imm,
-                     0x26 + imm, 0x25 + imm, 0x24 + imm, 0x23 + imm, 0x22 + imm,
-                     0x21 + imm, 0x20 + imm, 0x1f + imm, 0x1e + imm, 0x1d + imm,
-                     0x1c + imm, 0x1b + imm, 0x1a + imm, 0x19 + imm, 0x18 + imm,
-                     0x17 + imm, 0x16 + imm, 0x15 + imm, 0x14 + imm, 0x13 + imm,
-                     0x12 + imm, 0x11 + imm, 0x10 + imm, 0x0f + imm, 0x0e + imm,
-                     0x0d + imm, 0x0c + imm, 0x0b + imm, 0x0a + imm, 0x09 + imm,
-                     0x08 + imm, 0x07 + imm, 0x06 + imm, 0x05 + imm, 0x04 + imm,
-                     0x03 + imm, 0x02 + imm, 0x01 + imm, 0x00 + imm),
-                 b.val));
-#else
-             _v_rotate_right < imm % 4 != 0,
-         imm % 4, (imm / 4 > 15), imm / 4 > ::eval(a, b);
-#endif
-}
-template <int imm>
-inline v_int8x64 v_rotate_left(const v_int8x64 &a, const v_int8x64 &b) {
-  if (imm == 0)
-    return a;
-  if (imm == 64)
-    return b;
-  if (imm >= 128)
-    return v_int8x64();
-#if CV_AVX_512VBMI
-  return v_int8x64(_mm512_permutex2var_epi8(
-      b.val,
-      _v512_set_epi8(0x7f - imm, 0x7e - imm, 0x7d - imm, 0x7c - imm, 0x7b - imm,
-                     0x7a - imm, 0x79 - imm, 0x78 - imm, 0x77 - imm, 0x76 - imm,
-                     0x75 - imm, 0x74 - imm, 0x73 - imm, 0x72 - imm, 0x71 - imm,
-                     0x70 - imm, 0x6f - imm, 0x6e - imm, 0x6d - imm, 0x6c - imm,
-                     0x6b - imm, 0x6a - imm, 0x69 - imm, 0x68 - imm, 0x67 - imm,
-                     0x66 - imm, 0x65 - imm, 0x64 - imm, 0x63 - imm, 0x62 - imm,
-                     0x61 - imm, 0x60 - imm, 0x5f - imm, 0x5e - imm, 0x5d - imm,
-                     0x5c - imm, 0x5b - imm, 0x5a - imm, 0x59 - imm, 0x58 - imm,
-                     0x57 - imm, 0x56 - imm, 0x55 - imm, 0x54 - imm, 0x53 - imm,
-                     0x52 - imm, 0x51 - imm, 0x50 - imm, 0x4f - imm, 0x4e - imm,
-                     0x4d - imm, 0x4c - imm, 0x4b - imm, 0x4a - imm, 0x49 - imm,
-                     0x48 - imm, 0x47 - imm, 0x46 - imm, 0x45 - imm, 0x44 - imm,
-                     0x43 - imm, 0x42 - imm, 0x41 - imm, 0x40 - imm),
-      a.val));
-#else
-  return imm < 64 ? v_rotate_right<64 - imm>(b, a)
-                  : v_rotate_right<128 - imm>(v512_setzero_s8(), b);
-#endif
-}
-template <int imm> inline v_int8x64 v_rotate_right(const v_int8x64 &a) {
-  if (imm == 0)
-    return a;
-  if (imm >= 64)
-    return v_int8x64();
-#if CV_AVX_512VBMI
-  return v_int8x64(_mm512_maskz_permutexvar_epi8(
-      0xFFFFFFFFFFFFFFFF >> imm,
-      _v512_set_epu8(0x3f + imm, 0x3e + imm, 0x3d + imm, 0x3c + imm, 0x3b + imm,
-                     0x3a + imm, 0x39 + imm, 0x38 + imm, 0x37 + imm, 0x36 + imm,
-                     0x35 + imm, 0x34 + imm, 0x33 + imm, 0x32 + imm, 0x31 + imm,
-                     0x30 + imm, 0x2f + imm, 0x2e + imm, 0x2d + imm, 0x2c + imm,
-                     0x2b + imm, 0x2a + imm, 0x29 + imm, 0x28 + imm, 0x27 + imm,
-                     0x26 + imm, 0x25 + imm, 0x24 + imm, 0x23 + imm, 0x22 + imm,
-                     0x21 + imm, 0x20 + imm, 0x1f + imm, 0x1e + imm, 0x1d + imm,
-                     0x1c + imm, 0x1b + imm, 0x1a + imm, 0x19 + imm, 0x18 + imm,
-                     0x17 + imm, 0x16 + imm, 0x15 + imm, 0x14 + imm, 0x13 + imm,
-                     0x12 + imm, 0x11 + imm, 0x10 + imm, 0x0f + imm, 0x0e + imm,
-                     0x0d + imm, 0x0c + imm, 0x0b + imm, 0x0a + imm, 0x09 + imm,
-                     0x08 + imm, 0x07 + imm, 0x06 + imm, 0x05 + imm, 0x04 + imm,
-                     0x03 + imm, 0x02 + imm, 0x01 + imm, 0x00 + imm),
-      a.val));
-#else
-  return v_rotate_right<imm>(a, v512_setzero_s8());
-#endif
-}
-template <int imm> inline v_int8x64 v_rotate_left(const v_int8x64 &a) {
-  if (imm == 0)
-    return a;
-  if (imm >= 64)
-    return v_int8x64();
-#if CV_AVX_512VBMI
-  return v_int8x64(_mm512_maskz_permutexvar_epi8(
-      0xFFFFFFFFFFFFFFFF << imm,
-      _v512_set_epi8(0x3f - imm, 0x3e - imm, 0x3d - imm, 0x3c - imm, 0x3b - imm,
-                     0x3a - imm, 0x39 - imm, 0x38 - imm, 0x37 - imm, 0x36 - imm,
-                     0x35 - imm, 0x34 - imm, 0x33 - imm, 0x32 - imm, 0x31 - imm,
-                     0x30 - imm, 0x2f - imm, 0x2e - imm, 0x2d - imm, 0x2c - imm,
-                     0x2b - imm, 0x2a - imm, 0x29 - imm, 0x28 - imm, 0x27 - imm,
-                     0x26 - imm, 0x25 - imm, 0x24 - imm, 0x23 - imm, 0x22 - imm,
-                     0x21 - imm, 0x20 - imm, 0x1f - imm, 0x1e - imm, 0x1d - imm,
-                     0x1c - imm, 0x1b - imm, 0x1a - imm, 0x19 - imm, 0x18 - imm,
-                     0x17 - imm, 0x16 - imm, 0x15 - imm, 0x14 - imm, 0x13 - imm,
-                     0x12 - imm, 0x11 - imm, 0x10 - imm, 0x0f - imm, 0x0e - imm,
-                     0x0d - imm, 0x0c - imm, 0x0b - imm, 0x0a - imm, 0x09 - imm,
-                     0x08 - imm, 0x07 - imm, 0x06 - imm, 0x05 - imm, 0x04 - imm,
-                     0x03 - imm, 0x02 - imm, 0x01 - imm, 0x00 - imm),
-      a.val));
-#else
-  return v_rotate_right<64 - imm>(v512_setzero_s8(), a);
-#endif
-}
-
-#define OPENCV_HAL_IMPL_AVX512_ROTATE_PM(_Tpvec, suffix)                       \
-  template <int imm>                                                           \
-  inline _Tpvec v_rotate_left(const _Tpvec &a, const _Tpvec &b) {              \
-    return v_reinterpret_as_##suffix(                                          \
-        v_rotate_left<imm * sizeof(_Tpvec::lane_type)>(                        \
-            v_reinterpret_as_s8(a), v_reinterpret_as_s8(b)));                  \
-  }                                                                            \
-  template <int imm>                                                           \
-  inline _Tpvec v_rotate_right(const _Tpvec &a, const _Tpvec &b) {             \
-    return v_reinterpret_as_##suffix(                                          \
-        v_rotate_right<imm * sizeof(_Tpvec::lane_type)>(                       \
-            v_reinterpret_as_s8(a), v_reinterpret_as_s8(b)));                  \
-  }                                                                            \
-  template <int imm> inline _Tpvec v_rotate_left(const _Tpvec &a) {            \
-    return v_reinterpret_as_##suffix(                                          \
-        v_rotate_left<imm * sizeof(_Tpvec::lane_type)>(                        \
-            v_reinterpret_as_s8(a)));                                          \
-  }                                                                            \
-  template <int imm> inline _Tpvec v_rotate_right(const _Tpvec &a) {           \
-    return v_reinterpret_as_##suffix(                                          \
-        v_rotate_right<imm * sizeof(_Tpvec::lane_type)>(                       \
-            v_reinterpret_as_s8(a)));                                          \
-  }
-
-#define OPENCV_HAL_IMPL_AVX512_ROTATE_EC(_Tpvec, suffix)                       \
-  template <int imm>                                                           \
-  inline _Tpvec v_rotate_left(const _Tpvec &a, const _Tpvec &b) {              \
-    enum { SHIFT2 = (_Tpvec::nlanes - imm) };                                  \
-    enum { MASK = ((1 << _Tpvec::nlanes) - 1) };                               \
-    if (imm == 0)                                                              \
-      return a;                                                                \
-    if (imm == _Tpvec::nlanes)                                                 \
-      return b;                                                                \
-    if (imm >= 2 * _Tpvec::nlanes)                                             \
-      return _Tpvec::zero();                                                   \
-    return _Tpvec(_mm512_mask_expand_##suffix(                                 \
-        _mm512_maskz_compress_##suffix((MASK << SHIFT2) & MASK, b.val),        \
-        (MASK << (imm)) & MASK, a.val));                                       \
-  }                                                                            \
-  template <int imm>                                                           \
-  inline _Tpvec v_rotate_right(const _Tpvec &a, const _Tpvec &b) {             \
-    enum { SHIFT2 = (_Tpvec::nlanes - imm) };                                  \
-    enum { MASK = ((1 << _Tpvec::nlanes) - 1) };                               \
-    if (imm == 0)                                                              \
-      return a;                                                                \
-    if (imm == _Tpvec::nlanes)                                                 \
-      return b;                                                                \
-    if (imm >= 2 * _Tpvec::nlanes)                                             \
-      return _Tpvec::zero();                                                   \
-    return _Tpvec(_mm512_mask_expand_##suffix(                                 \
-        _mm512_maskz_compress_##suffix((MASK << (imm)) & MASK, a.val),         \
-        (MASK << SHIFT2) & MASK, b.val));                                      \
-  }                                                                            \
-  template <int imm> inline _Tpvec v_rotate_left(const _Tpvec &a) {            \
-    if (imm == 0)                                                              \
-      return a;                                                                \
-    if (imm >= _Tpvec::nlanes)                                                 \
-      return _Tpvec::zero();                                                   \
-    return _Tpvec(_mm512_maskz_expand_##suffix(                                \
-        (1 << _Tpvec::nlanes) - (1 << (imm)), a.val));                         \
-  }                                                                            \
-  template <int imm> inline _Tpvec v_rotate_right(const _Tpvec &a) {           \
-    if (imm == 0)                                                              \
-      return a;                                                                \
-    if (imm >= _Tpvec::nlanes)                                                 \
-      return _Tpvec::zero();                                                   \
-    return _Tpvec(_mm512_maskz_compress_##suffix(                              \
-        (1 << _Tpvec::nlanes) - (1 << (imm)), a.val));                         \
-  }
-
-OPENCV_HAL_IMPL_AVX512_ROTATE_PM(v_uint8x64, u8)
-OPENCV_HAL_IMPL_AVX512_ROTATE_PM(v_uint16x32, u16)
-OPENCV_HAL_IMPL_AVX512_ROTATE_PM(v_int16x32, s16)
-OPENCV_HAL_IMPL_AVX512_ROTATE_EC(v_uint32x16, epi32)
-OPENCV_HAL_IMPL_AVX512_ROTATE_EC(v_int32x16, epi32)
-OPENCV_HAL_IMPL_AVX512_ROTATE_EC(v_uint64x8, epi64)
-OPENCV_HAL_IMPL_AVX512_ROTATE_EC(v_int64x8, epi64)
-OPENCV_HAL_IMPL_AVX512_ROTATE_EC(v_float32x16, ps)
-OPENCV_HAL_IMPL_AVX512_ROTATE_EC(v_float64x8, pd)
-
-/** Reverse **/
-inline v_uint8x64 v_reverse(const v_uint8x64 &a) {
-#if CV_AVX_512VBMI
-  static const __m512i perm = _mm512_set_epi32(
-      0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f, 0x10111213, 0x14151617,
-      0x18191a1b, 0x1c1d1e1f, 0x20212223, 0x24252627, 0x28292a2b, 0x2c2d2e2f,
-      0x30313233, 0x34353637, 0x38393a3b, 0x3c3d3e3f);
-  return v_uint8x64(_mm512_permutexvar_epi8(perm, a.val));
-#else
-  static const __m512i shuf = _mm512_set_epi32(
-      0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f, 0x00010203, 0x04050607,
-      0x08090a0b, 0x0c0d0e0f, 0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f,
-      0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f);
-  static const __m512i perm = _mm512_set_epi64(1, 0, 3, 2, 5, 4, 7, 6);
-  __m512i vec = _mm512_shuffle_epi8(a.val, shuf);
-  return v_uint8x64(_mm512_permutexvar_epi64(perm, vec));
-#endif
-}
-
-inline v_int8x64 v_reverse(const v_int8x64 &a) {
-  return v_reinterpret_as_s8(v_reverse(v_reinterpret_as_u8(a)));
-}
-
-inline v_uint16x32 v_reverse(const v_uint16x32 &a) {
-#if CV_AVX_512VBMI
-  static const __m512i perm = _mm512_set_epi32(
-      0x00000001, 0x00020003, 0x00040005, 0x00060007, 0x00080009, 0x000a000b,
-      0x000c000d, 0x000e000f, 0x00100011, 0x00120013, 0x00140015, 0x00160017,
-      0x00180019, 0x001a001b, 0x001c001d, 0x001e001f);
-  return v_uint16x32(_mm512_permutexvar_epi16(perm, a.val));
-#else
-  static const __m512i shuf = _mm512_set_epi32(
-      0x01000302, 0x05040706, 0x09080b0a, 0x0d0c0f0e, 0x01000302, 0x05040706,
-      0x09080b0a, 0x0d0c0f0e, 0x01000302, 0x05040706, 0x09080b0a, 0x0d0c0f0e,
-      0x01000302, 0x05040706, 0x09080b0a, 0x0d0c0f0e);
-  static const __m512i perm = _mm512_set_epi64(1, 0, 3, 2, 5, 4, 7, 6);
-  __m512i vec = _mm512_shuffle_epi8(a.val, shuf);
-  return v_uint16x32(_mm512_permutexvar_epi64(perm, vec));
-#endif
-}
-
-inline v_int16x32 v_reverse(const v_int16x32 &a) {
-  return v_reinterpret_as_s16(v_reverse(v_reinterpret_as_u16(a)));
-}
-
-inline v_uint32x16 v_reverse(const v_uint32x16 &a) {
-  static const __m512i perm =
-      _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
-  return v_uint32x16(_mm512_permutexvar_epi32(perm, a.val));
-}
-
-inline v_int32x16 v_reverse(const v_int32x16 &a) {
-  return v_reinterpret_as_s32(v_reverse(v_reinterpret_as_u32(a)));
-}
-
-inline v_float32x16 v_reverse(const v_float32x16 &a) {
-  return v_reinterpret_as_f32(v_reverse(v_reinterpret_as_u32(a)));
-}
-
-inline v_uint64x8 v_reverse(const v_uint64x8 &a) {
-  static const __m512i perm = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 7);
-  return v_uint64x8(_mm512_permutexvar_epi64(perm, a.val));
-}
-
-inline v_int64x8 v_reverse(const v_int64x8 &a) {
-  return v_reinterpret_as_s64(v_reverse(v_reinterpret_as_u64(a)));
-}
-
-inline v_float64x8 v_reverse(const v_float64x8 &a) {
-  return v_reinterpret_as_f64(v_reverse(v_reinterpret_as_u64(a)));
-}
-
-////////// Reduce /////////
-
-/** Reduce **/
-#define OPENCV_HAL_IMPL_AVX512_REDUCE_ADD64(a, b) a + b
-#define OPENCV_HAL_IMPL_AVX512_REDUCE_8(sctype, func, _Tpvec, ifunc, scop)     \
-  inline sctype v_reduce_##func(const _Tpvec &a) {                             \
-    __m256i half =                                                             \
-        _mm256_##ifunc(_v512_extract_low(a.val), _v512_extract_high(a.val));   \
-    sctype CV_DECL_ALIGNED(64) idx[2];                                         \
-    _mm_store_si128((__m128i *)idx,                                            \
-                    _mm_##ifunc(_mm256_castsi256_si128(half),                  \
-                                _mm256_extracti128_si256(half, 1)));           \
-    return scop(idx[0], idx[1]);                                               \
-  }
-OPENCV_HAL_IMPL_AVX512_REDUCE_8(uint64, min, v_uint64x8, min_epu64, min)
-OPENCV_HAL_IMPL_AVX512_REDUCE_8(uint64, max, v_uint64x8, max_epu64, max)
-OPENCV_HAL_IMPL_AVX512_REDUCE_8(uint64, sum, v_uint64x8, add_epi64,
-                                OPENCV_HAL_IMPL_AVX512_REDUCE_ADD64)
-OPENCV_HAL_IMPL_AVX512_REDUCE_8(int64, min, v_int64x8, min_epi64, min)
-OPENCV_HAL_IMPL_AVX512_REDUCE_8(int64, max, v_int64x8, max_epi64, max)
-OPENCV_HAL_IMPL_AVX512_REDUCE_8(int64, sum, v_int64x8, add_epi64,
-                                OPENCV_HAL_IMPL_AVX512_REDUCE_ADD64)
-
-#define OPENCV_HAL_IMPL_AVX512_REDUCE_8F(func, ifunc, scop)                    \
-  inline double v_reduce_##func(const v_float64x8 &a) {                        \
-    __m256d half =                                                             \
-        _mm256_##ifunc(_v512_extract_low(a.val), _v512_extract_high(a.val));   \
-    double CV_DECL_ALIGNED(64) idx[2];                                         \
-    _mm_store_pd(idx, _mm_##ifunc(_mm256_castpd256_pd128(half),                \
-                                  _mm256_extractf128_pd(half, 1)));            \
-    return scop(idx[0], idx[1]);                                               \
-  }
-OPENCV_HAL_IMPL_AVX512_REDUCE_8F(min, min_pd, min)
-OPENCV_HAL_IMPL_AVX512_REDUCE_8F(max, max_pd, max)
-OPENCV_HAL_IMPL_AVX512_REDUCE_8F(sum, add_pd,
-                                 OPENCV_HAL_IMPL_AVX512_REDUCE_ADD64)
-
-#define OPENCV_HAL_IMPL_AVX512_REDUCE_16(sctype, func, _Tpvec, ifunc)          \
-  inline sctype v_reduce_##func(const _Tpvec &a) {                             \
-    __m256i half =                                                             \
-        _mm256_##ifunc(_v512_extract_low(a.val), _v512_extract_high(a.val));   \
-    __m128i quarter = _mm_##ifunc(_mm256_castsi256_si128(half),                \
-                                  _mm256_extracti128_si256(half, 1));          \
-    quarter = _mm_##ifunc(quarter, _mm_srli_si128(quarter, 8));                \
-    quarter = _mm_##ifunc(quarter, _mm_srli_si128(quarter, 4));                \
-    return (sctype)_mm_cvtsi128_si32(quarter);                                 \
-  }
-OPENCV_HAL_IMPL_AVX512_REDUCE_16(uint, min, v_uint32x16, min_epu32)
-OPENCV_HAL_IMPL_AVX512_REDUCE_16(uint, max, v_uint32x16, max_epu32)
-OPENCV_HAL_IMPL_AVX512_REDUCE_16(int, min, v_int32x16, min_epi32)
-OPENCV_HAL_IMPL_AVX512_REDUCE_16(int, max, v_int32x16, max_epi32)
-
-#define OPENCV_HAL_IMPL_AVX512_REDUCE_16F(func, ifunc)                         \
-  inline float v_reduce_##func(const v_float32x16 &a) {                        \
-    __m256 half =                                                              \
-        _mm256_##ifunc(_v512_extract_low(a.val), _v512_extract_high(a.val));   \
-    __m128 quarter = _mm_##ifunc(_mm256_castps256_ps128(half),                 \
-                                 _mm256_extractf128_ps(half, 1));              \
-    quarter = _mm_##ifunc(quarter,                                             \
-                          _mm_permute_ps(quarter, _MM_SHUFFLE(0, 0, 3, 2)));   \
-    quarter = _mm_##ifunc(quarter,                                             \
-                          _mm_permute_ps(quarter, _MM_SHUFFLE(0, 0, 0, 1)));   \
-    return _mm_cvtss_f32(quarter);                                             \
-  }
-OPENCV_HAL_IMPL_AVX512_REDUCE_16F(min, min_ps)
-OPENCV_HAL_IMPL_AVX512_REDUCE_16F(max, max_ps)
-
-inline float v_reduce_sum(const v_float32x16 &a) {
-  __m256 half =
-      _mm256_add_ps(_v512_extract_low(a.val), _v512_extract_high(a.val));
-  __m128 quarter =
-      _mm_add_ps(_mm256_castps256_ps128(half), _mm256_extractf128_ps(half, 1));
-  quarter = _mm_hadd_ps(quarter, quarter);
-  return _mm_cvtss_f32(_mm_hadd_ps(quarter, quarter));
-}
-inline int v_reduce_sum(const v_int32x16 &a) {
-  __m256i half =
-      _mm256_add_epi32(_v512_extract_low(a.val), _v512_extract_high(a.val));
-  __m128i quarter = _mm_add_epi32(_mm256_castsi256_si128(half),
-                                  _mm256_extracti128_si256(half, 1));
-  quarter = _mm_hadd_epi32(quarter, quarter);
-  return _mm_cvtsi128_si32(_mm_hadd_epi32(quarter, quarter));
-}
-inline uint v_reduce_sum(const v_uint32x16 &a) {
-  return (uint)v_reduce_sum(v_reinterpret_as_s32(a));
-}
-
-#define OPENCV_HAL_IMPL_AVX512_REDUCE_32(sctype, func, _Tpvec, ifunc)          \
-  inline sctype v_reduce_##func(const _Tpvec &a) {                             \
-    __m256i half =                                                             \
-        _mm256_##ifunc(_v512_extract_low(a.val), _v512_extract_high(a.val));   \
-    __m128i quarter = _mm_##ifunc(_mm256_castsi256_si128(half),                \
-                                  _mm256_extracti128_si256(half, 1));          \
-    quarter = _mm_##ifunc(quarter, _mm_srli_si128(quarter, 8));                \
-    quarter = _mm_##ifunc(quarter, _mm_srli_si128(quarter, 4));                \
-    quarter = _mm_##ifunc(quarter, _mm_srli_si128(quarter, 2));                \
-    return (sctype)_mm_cvtsi128_si32(quarter);                                 \
-  }
-OPENCV_HAL_IMPL_AVX512_REDUCE_32(ushort, min, v_uint16x32, min_epu16)
-OPENCV_HAL_IMPL_AVX512_REDUCE_32(ushort, max, v_uint16x32, max_epu16)
-OPENCV_HAL_IMPL_AVX512_REDUCE_32(short, min, v_int16x32, min_epi16)
-OPENCV_HAL_IMPL_AVX512_REDUCE_32(short, max, v_int16x32, max_epi16)
-
-inline int v_reduce_sum(const v_int16x32 &a) {
-  return v_reduce_sum(v_add(v_expand_low(a), v_expand_high(a)));
-}
-inline uint v_reduce_sum(const v_uint16x32 &a) {
-  return v_reduce_sum(v_add(v_expand_low(a), v_expand_high(a)));
-}
-
-#define OPENCV_HAL_IMPL_AVX512_REDUCE_64(sctype, func, _Tpvec, ifunc)          \
-  inline sctype v_reduce_##func(const _Tpvec &a) {                             \
-    __m256i half =                                                             \
-        _mm256_##ifunc(_v512_extract_low(a.val), _v512_extract_high(a.val));   \
-    __m128i quarter = _mm_##ifunc(_mm256_castsi256_si128(half),                \
-                                  _mm256_extracti128_si256(half, 1));          \
-    quarter = _mm_##ifunc(quarter, _mm_srli_si128(quarter, 8));                \
-    quarter = _mm_##ifunc(quarter, _mm_srli_si128(quarter, 4));                \
-    quarter = _mm_##ifunc(quarter, _mm_srli_si128(quarter, 2));                \
-    quarter = _mm_##ifunc(quarter, _mm_srli_si128(quarter, 1));                \
-    return (sctype)_mm_cvtsi128_si32(quarter);                                 \
-  }
-OPENCV_HAL_IMPL_AVX512_REDUCE_64(uchar, min, v_uint8x64, min_epu8)
-OPENCV_HAL_IMPL_AVX512_REDUCE_64(uchar, max, v_uint8x64, max_epu8)
-OPENCV_HAL_IMPL_AVX512_REDUCE_64(schar, min, v_int8x64, min_epi8)
-OPENCV_HAL_IMPL_AVX512_REDUCE_64(schar, max, v_int8x64, max_epi8)
-
-#define OPENCV_HAL_IMPL_AVX512_REDUCE_64_SUM(sctype, _Tpvec, suffix)           \
-  inline sctype v_reduce_sum(const _Tpvec &a) {                                \
-    __m512i a16 = _mm512_add_epi16(                                            \
-        _mm512_cvt##suffix##_epi16(_v512_extract_low(a.val)),                  \
-        _mm512_cvt##suffix##_epi16(_v512_extract_high(a.val)));                \
-    a16 = _mm512_cvtepi16_epi32(                                               \
-        _mm256_add_epi16(_v512_extract_low(a16), _v512_extract_high(a16)));    \
-    __m256i a8 =                                                               \
-        _mm256_add_epi32(_v512_extract_low(a16), _v512_extract_high(a16));     \
-    __m128i a4 = _mm_add_epi32(_mm256_castsi256_si128(a8),                     \
-                               _mm256_extracti128_si256(a8, 1));               \
-    a4 = _mm_hadd_epi32(a4, a4);                                               \
-    return (sctype)_mm_cvtsi128_si32(_mm_hadd_epi32(a4, a4));                  \
-  }
-OPENCV_HAL_IMPL_AVX512_REDUCE_64_SUM(uint, v_uint8x64, epu8)
-OPENCV_HAL_IMPL_AVX512_REDUCE_64_SUM(int, v_int8x64, epi8)
-
-inline v_float32x16 v_reduce_sum4(const v_float32x16 &a, const v_float32x16 &b,
-                                  const v_float32x16 &c,
-                                  const v_float32x16 &d) {
-  __m256 abl =
-      _mm256_hadd_ps(_v512_extract_low(a.val), _v512_extract_low(b.val));
-  __m256 abh =
-      _mm256_hadd_ps(_v512_extract_high(a.val), _v512_extract_high(b.val));
-  __m256 cdl =
-      _mm256_hadd_ps(_v512_extract_low(c.val), _v512_extract_low(d.val));
-  __m256 cdh =
-      _mm256_hadd_ps(_v512_extract_high(c.val), _v512_extract_high(d.val));
-  return v_float32x16(
-      _v512_combine(_mm256_hadd_ps(abl, cdl), _mm256_hadd_ps(abh, cdh)));
-}
-
-inline unsigned v_reduce_sad(const v_uint8x64 &a, const v_uint8x64 &b) {
-  __m512i val = _mm512_sad_epu8(a.val, b.val);
-  __m256i half =
-      _mm256_add_epi32(_v512_extract_low(val), _v512_extract_high(val));
-  __m128i quarter = _mm_add_epi32(_mm256_castsi256_si128(half),
-                                  _mm256_extracti128_si256(half, 1));
-  return (unsigned)_mm_cvtsi128_si32(
-      _mm_add_epi32(quarter, _mm_unpackhi_epi64(quarter, quarter)));
-}
-inline unsigned v_reduce_sad(const v_int8x64 &a, const v_int8x64 &b) {
-  __m512i val = _mm512_set1_epi8(-128);
-  val =
-      _mm512_sad_epu8(_mm512_add_epi8(a.val, val), _mm512_add_epi8(b.val, val));
-  __m256i half =
-      _mm256_add_epi32(_v512_extract_low(val), _v512_extract_high(val));
-  __m128i quarter = _mm_add_epi32(_mm256_castsi256_si128(half),
-                                  _mm256_extracti128_si256(half, 1));
-  return (unsigned)_mm_cvtsi128_si32(
-      _mm_add_epi32(quarter, _mm_unpackhi_epi64(quarter, quarter)));
-}
-inline unsigned v_reduce_sad(const v_uint16x32 &a, const v_uint16x32 &b) {
-  return v_reduce_sum(v_add_wrap(v_sub(a, b), v_sub(b, a)));
-}
-inline unsigned v_reduce_sad(const v_int16x32 &a, const v_int16x32 &b) {
-  return v_reduce_sum(
-      v_reinterpret_as_u16(v_sub_wrap(v_max(a, b), v_min(a, b))));
-}
-inline unsigned v_reduce_sad(const v_uint32x16 &a, const v_uint32x16 &b) {
-  return v_reduce_sum(v_sub(v_max(a, b), v_min(a, b)));
-}
-inline unsigned v_reduce_sad(const v_int32x16 &a, const v_int32x16 &b) {
-  return v_reduce_sum(v_reinterpret_as_u32(v_sub(v_max(a, b), v_min(a, b))));
-}
-inline float v_reduce_sad(const v_float32x16 &a, const v_float32x16 &b) {
-  return v_reduce_sum(v_and(v_sub(a, b), v_float32x16(_mm512_castsi512_ps(
-                                             _mm512_set1_epi32(0x7fffffff)))));
-}
-inline double v_reduce_sad(const v_float64x8 &a, const v_float64x8 &b) {
-  return v_reduce_sum(v_and(
-      v_sub(a, b),
-      v_float64x8(_mm512_castsi512_pd(_mm512_set1_epi64(0x7fffffffffffffff)))));
-}
-
-/** Popcount **/
-inline v_uint8x64 v_popcount(const v_int8x64 &a) {
-#if CV_AVX_512BITALG
-  return v_uint8x64(_mm512_popcnt_epi8(a.val));
-#elif CV_AVX_512VBMI
-  __m512i _popcnt_table0 = _v512_set_epu8(
-      7, 6, 6, 5, 6, 5, 5, 4, 6, 5, 5, 4, 5, 4, 4, 3, 5, 4, 4, 3, 4, 3, 3, 2, 4,
-      3, 3, 2, 3, 2, 2, 1, 5, 4, 4, 3, 4, 3, 3, 2, 4, 3, 3, 2, 3, 2, 2, 1, 4, 3,
-      3, 2, 3, 2, 2, 1, 3, 2, 2, 1, 2, 1, 1, 0);
-  __m512i _popcnt_table1 = _v512_set_epu8(
-      7, 6, 6, 5, 6, 5, 5, 4, 6, 5, 5, 4, 5, 4, 4, 3, 6, 5, 5, 4, 5, 4, 4, 3, 5,
-      4, 4, 3, 4, 3, 3, 2, 6, 5, 5, 4, 5, 4, 4, 3, 5, 4, 4, 3, 4, 3, 3, 2, 5, 4,
-      4, 3, 4, 3, 3, 2, 4, 3, 3, 2, 3, 2, 2, 1);
-  return v_uint8x64(_mm512_sub_epi8(
-      _mm512_permutex2var_epi8(_popcnt_table0, a.val, _popcnt_table1),
-      _mm512_movm_epi8(_mm512_movepi8_mask(a.val))));
-#else
-  __m512i _popcnt_table =
-      _mm512_set4_epi32(0x04030302, 0x03020201, 0x03020201, 0x02010100);
-  __m512i _popcnt_mask = _mm512_set1_epi8(0x0F);
-
-  return v_uint8x64(_mm512_add_epi8(
-      _mm512_shuffle_epi8(_popcnt_table, _mm512_and_si512(a.val, _popcnt_mask)),
-      _mm512_shuffle_epi8(
-          _popcnt_table,
-          _mm512_and_si512(_mm512_srli_epi16(a.val, 4), _popcnt_mask))));
-#endif
-}
-inline v_uint16x32 v_popcount(const v_int16x32 &a) {
-#if CV_AVX_512BITALG
-  return v_uint16x32(_mm512_popcnt_epi16(a.val));
-#elif CV_AVX_512VPOPCNTDQ
-  __m512i zero = _mm512_setzero_si512();
-  return v_uint16x32(_mm512_packs_epi32(
-      _mm512_popcnt_epi32(_mm512_unpacklo_epi16(a.val, zero)),
-      _mm512_popcnt_epi32(_mm512_unpackhi_epi16(a.val, zero))));
-#else
-  v_uint8x64 p = v_popcount(v_reinterpret_as_s8(a));
-  p = v_add(p, v_rotate_right<1>(p));
-  return v_and(v_reinterpret_as_u16(p), v512_setall_u16(0x00ff));
-#endif
-}
-inline v_uint32x16 v_popcount(const v_int32x16 &a) {
-#if CV_AVX_512VPOPCNTDQ
-  return v_uint32x16(_mm512_popcnt_epi32(a.val));
-#else
-  v_uint8x64 p = v_popcount(v_reinterpret_as_s8(a));
-  p = v_add(p, v_rotate_right<1>(p));
-  p = v_add(p, v_rotate_right<2>(p));
-  return v_and(v_reinterpret_as_u32(p), v512_setall_u32(0x000000ff));
-#endif
-}
-inline v_uint64x8 v_popcount(const v_int64x8 &a) {
-#if CV_AVX_512VPOPCNTDQ
-  return v_uint64x8(_mm512_popcnt_epi64(a.val));
-#else
-  return v_uint64x8(_mm512_sad_epu8(v_popcount(v_reinterpret_as_s8(a)).val,
-                                    _mm512_setzero_si512()));
-#endif
-}
-
-inline v_uint8x64 v_popcount(const v_uint8x64 &a) {
-  return v_popcount(v_reinterpret_as_s8(a));
-}
-inline v_uint16x32 v_popcount(const v_uint16x32 &a) {
-  return v_popcount(v_reinterpret_as_s16(a));
-}
-inline v_uint32x16 v_popcount(const v_uint32x16 &a) {
-  return v_popcount(v_reinterpret_as_s32(a));
-}
-inline v_uint64x8 v_popcount(const v_uint64x8 &a) {
-  return v_popcount(v_reinterpret_as_s64(a));
-}
-
-////////// Other math /////////
-
-/** Some frequent operations **/
-#if CV_FMA3
-#define OPENCV_HAL_IMPL_AVX512_MULADD(_Tpvec, suffix)                          \
-  inline _Tpvec v_fma(const _Tpvec &a, const _Tpvec &b, const _Tpvec &c) {     \
-    return _Tpvec(_mm512_fmadd_##suffix(a.val, b.val, c.val));                 \
-  }                                                                            \
-  inline _Tpvec v_muladd(const _Tpvec &a, const _Tpvec &b, const _Tpvec &c) {  \
-    return _Tpvec(_mm512_fmadd_##suffix(a.val, b.val, c.val));                 \
-  }
-#else
-#define OPENCV_HAL_IMPL_AVX512_MULADD(_Tpvec, suffix)                          \
-  inline _Tpvec v_fma(const _Tpvec &a, const _Tpvec &b, const _Tpvec &c) {     \
-    return _Tpvec(                                                             \
-        _mm512_add_##suffix(_mm512_mul_##suffix(a.val, b.val), c.val));        \
-  }                                                                            \
-  inline _Tpvec v_muladd(const _Tpvec &a, const _Tpvec &b, const _Tpvec &c) {  \
-    return _Tpvec(                                                             \
-        _mm512_add_##suffix(_mm512_mul_##suffix(a.val, b.val), c.val));        \
-  }
-#endif
-
-#define OPENCV_HAL_IMPL_AVX512_MISC(_Tpvec, suffix)                            \
-  inline _Tpvec v_sqrt(const _Tpvec &x) {                                      \
-    return _Tpvec(_mm512_sqrt_##suffix(x.val));                                \
-  }                                                                            \
-  inline _Tpvec v_sqr_magnitude(const _Tpvec &a, const _Tpvec &b) {            \
-    return v_fma(a, a, v_mul(b, b));                                           \
-  }                                                                            \
-  inline _Tpvec v_magnitude(const _Tpvec &a, const _Tpvec &b) {                \
-    return v_sqrt(v_fma(a, a, v_mul(b, b)));                                   \
-  }
-
-OPENCV_HAL_IMPL_AVX512_MULADD(v_float32x16, ps)
-OPENCV_HAL_IMPL_AVX512_MULADD(v_float64x8, pd)
-OPENCV_HAL_IMPL_AVX512_MISC(v_float32x16, ps)
-OPENCV_HAL_IMPL_AVX512_MISC(v_float64x8, pd)
-
-inline v_int32x16 v_fma(const v_int32x16 &a, const v_int32x16 &b,
-                        const v_int32x16 &c) {
-  return v_add(v_mul(a, b), c);
-}
-inline v_int32x16 v_muladd(const v_int32x16 &a, const v_int32x16 &b,
-                           const v_int32x16 &c) {
-  return v_fma(a, b, c);
-}
-
-inline v_float32x16 v_invsqrt(const v_float32x16 &x) {
-#if CV_AVX_512ER
-  return v_float32x16(_mm512_rsqrt28_ps(x.val));
-#else
-  v_float32x16 half = v_mul(x, v512_setall_f32(0.5));
-  v_float32x16 t = v_float32x16(_mm512_rsqrt14_ps(x.val));
-  t = v_mul(t, v_sub(v512_setall_f32(1.5), v_mul(v_mul(t, t), half)));
-  return t;
-#endif
-}
-
-inline v_float64x8 v_invsqrt(const v_float64x8 &x) {
-#if CV_AVX_512ER
-  return v_float64x8(_mm512_rsqrt28_pd(x.val));
-#else
-  return v_div(v512_setall_f64(1.), v_sqrt(x));
-//    v_float64x8 half = x * v512_setall_f64(0.5);
-//    v_float64x8 t = v_float64x8(_mm512_rsqrt14_pd(x.val));
-//    t *= v512_setall_f64(1.5) - ((t * t) * half);
-//    t *= v512_setall_f64(1.5) - ((t * t) * half);
-//    return t;
-#endif
-}
-
-/** Absolute values **/
-#define OPENCV_HAL_IMPL_AVX512_ABS(_Tpvec, _Tpuvec, suffix)                    \
-  inline _Tpuvec v_abs(const _Tpvec &x) {                                      \
-    return _Tpuvec(_mm512_abs_##suffix(x.val));                                \
-  }
-
-OPENCV_HAL_IMPL_AVX512_ABS(v_int8x64, v_uint8x64, epi8)
-OPENCV_HAL_IMPL_AVX512_ABS(v_int16x32, v_uint16x32, epi16)
-OPENCV_HAL_IMPL_AVX512_ABS(v_int32x16, v_uint32x16, epi32)
-OPENCV_HAL_IMPL_AVX512_ABS(v_int64x8, v_uint64x8, epi64)
-
-inline v_float32x16 v_abs(const v_float32x16 &x) {
-#ifdef _mm512_abs_pd
-  return v_float32x16(_mm512_abs_ps(x.val));
-#else
-  return v_float32x16(_mm512_castsi512_ps(_mm512_and_si512(
-      _mm512_castps_si512(x.val),
-      _v512_set_epu64(0x7FFFFFFF7FFFFFFF, 0x7FFFFFFF7FFFFFFF,
-                      0x7FFFFFFF7FFFFFFF, 0x7FFFFFFF7FFFFFFF,
-                      0x7FFFFFFF7FFFFFFF, 0x7FFFFFFF7FFFFFFF,
-                      0x7FFFFFFF7FFFFFFF, 0x7FFFFFFF7FFFFFFF))));
-#endif
-}
-
-inline v_float64x8 v_abs(const v_float64x8 &x) {
-#ifdef _mm512_abs_pd
-#if defined __GNUC__ &&                                                        \
-    (__GNUC__ < 7 || (__GNUC__ == 7 && __GNUC_MINOR__ <= 3) ||                 \
-     (__GNUC__ == 8 && __GNUC_MINOR__ <= 2))
-  // Workaround for https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87476
-  return v_float64x8(_mm512_abs_pd(_mm512_castpd_ps(x.val)));
-#else
-  return v_float64x8(_mm512_abs_pd(x.val));
-#endif
-#else
-  return v_float64x8(_mm512_castsi512_pd(_mm512_and_si512(
-      _mm512_castpd_si512(x.val),
-      _v512_set_epu64(0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFF,
-                      0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFF,
-                      0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFF,
-                      0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFF))));
-#endif
-}
-
-/** Absolute difference **/
-inline v_uint8x64 v_absdiff(const v_uint8x64 &a, const v_uint8x64 &b) {
-  return v_add_wrap(v_sub(a, b), v_sub(b, a));
-}
-inline v_uint16x32 v_absdiff(const v_uint16x32 &a, const v_uint16x32 &b) {
-  return v_add_wrap(v_sub(a, b), v_sub(b, a));
-}
-inline v_uint32x16 v_absdiff(const v_uint32x16 &a, const v_uint32x16 &b) {
-  return v_sub(v_max(a, b), v_min(a, b));
-}
-
-inline v_uint8x64 v_absdiff(const v_int8x64 &a, const v_int8x64 &b) {
-  v_int8x64 d = v_sub_wrap(a, b);
-  v_int8x64 m = v_lt(a, b);
-  return v_reinterpret_as_u8(v_sub_wrap(v_xor(d, m), m));
-}
-
-inline v_uint16x32 v_absdiff(const v_int16x32 &a, const v_int16x32 &b) {
-  return v_reinterpret_as_u16(v_sub_wrap(v_max(a, b), v_min(a, b)));
-}
-
-inline v_uint32x16 v_absdiff(const v_int32x16 &a, const v_int32x16 &b) {
-  v_int32x16 d = v_sub(a, b);
-  v_int32x16 m = v_lt(a, b);
-  return v_reinterpret_as_u32(v_sub(v_xor(d, m), m));
-}
-
-inline v_float32x16 v_absdiff(const v_float32x16 &a, const v_float32x16 &b) {
-  return v_abs(v_sub(a, b));
-}
-
-inline v_float64x8 v_absdiff(const v_float64x8 &a, const v_float64x8 &b) {
-  return v_abs(v_sub(a, b));
-}
-
-/** Saturating absolute difference **/
-inline v_int8x64 v_absdiffs(const v_int8x64 &a, const v_int8x64 &b) {
-  v_int8x64 d = v_sub(a, b);
-  v_int8x64 m = v_lt(a, b);
-  return v_sub(v_xor(d, m), m);
-}
-inline v_int16x32 v_absdiffs(const v_int16x32 &a, const v_int16x32 &b) {
-  return v_sub(v_max(a, b), v_min(a, b));
-}
-
-////////// Conversions /////////
-
-/** Rounding **/
-inline v_int32x16 v_round(const v_float32x16 &a) {
-  return v_int32x16(_mm512_cvtps_epi32(a.val));
-}
-
-inline v_int32x16 v_round(const v_float64x8 &a) {
-  return v_int32x16(_mm512_castsi256_si512(_mm512_cvtpd_epi32(a.val)));
-}
-
-inline v_int32x16 v_round(const v_float64x8 &a, const v_float64x8 &b) {
-  return v_int32x16(
-      _v512_combine(_mm512_cvtpd_epi32(a.val), _mm512_cvtpd_epi32(b.val)));
-}
-
-inline v_int32x16 v_trunc(const v_float32x16 &a) {
-  return v_int32x16(_mm512_cvttps_epi32(a.val));
-}
-
-inline v_int32x16 v_trunc(const v_float64x8 &a) {
-  return v_int32x16(_mm512_castsi256_si512(_mm512_cvttpd_epi32(a.val)));
-}
-
-#if CVT_ROUND_MODES_IMPLEMENTED
-inline v_int32x16 v_floor(const v_float32x16 &a) {
-  return v_int32x16(_mm512_cvt_roundps_epi32(a.val, _MM_FROUND_TO_NEG_INF |
-                                                        _MM_FROUND_NO_EXC));
-}
-
-inline v_int32x16 v_floor(const v_float64x8 &a) {
-  return v_int32x16(_mm512_castsi256_si512(_mm512_cvt_roundpd_epi32(
-      a.val, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC)));
-}
-
-inline v_int32x16 v_ceil(const v_float32x16 &a) {
-  return v_int32x16(_mm512_cvt_roundps_epi32(a.val, _MM_FROUND_TO_POS_INF |
-                                                        _MM_FROUND_NO_EXC));
-}
-
-inline v_int32x16 v_ceil(const v_float64x8 &a) {
-  return v_int32x16(_mm512_castsi256_si512(_mm512_cvt_roundpd_epi32(
-      a.val, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC)));
-}
-#else
-inline v_int32x16 v_floor(const v_float32x16 &a) {
-  return v_int32x16(_mm512_cvtps_epi32(_mm512_roundscale_ps(a.val, 1)));
-}
-
-inline v_int32x16 v_floor(const v_float64x8 &a) {
-  return v_int32x16(_mm512_castsi256_si512(
-      _mm512_cvtpd_epi32(_mm512_roundscale_pd(a.val, 1))));
-}
-
-inline v_int32x16 v_ceil(const v_float32x16 &a) {
-  return v_int32x16(_mm512_cvtps_epi32(_mm512_roundscale_ps(a.val, 2)));
-}
-
-inline v_int32x16 v_ceil(const v_float64x8 &a) {
-  return v_int32x16(_mm512_castsi256_si512(
-      _mm512_cvtpd_epi32(_mm512_roundscale_pd(a.val, 2))));
-}
-#endif
-
-/** To float **/
-inline v_float32x16 v_cvt_f32(const v_int32x16 &a) {
-  return v_float32x16(_mm512_cvtepi32_ps(a.val));
-}
-
-inline v_float32x16 v_cvt_f32(const v_float64x8 &a) {
-  return v_float32x16(_mm512_cvtpd_pslo(a.val));
-}
-
-inline v_float32x16 v_cvt_f32(const v_float64x8 &a, const v_float64x8 &b) {
-  return v_float32x16(
-      _v512_combine(_mm512_cvtpd_ps(a.val), _mm512_cvtpd_ps(b.val)));
-}
-
-inline v_float64x8 v_cvt_f64(const v_int32x16 &a) {
-  return v_float64x8(_mm512_cvtepi32_pd(_v512_extract_low(a.val)));
-}
-
-inline v_float64x8 v_cvt_f64_high(const v_int32x16 &a) {
-  return v_float64x8(_mm512_cvtepi32_pd(_v512_extract_high(a.val)));
-}
-
-inline v_float64x8 v_cvt_f64(const v_float32x16 &a) {
-  return v_float64x8(_mm512_cvtps_pd(_v512_extract_low(a.val)));
-}
-
-inline v_float64x8 v_cvt_f64_high(const v_float32x16 &a) {
-  return v_float64x8(_mm512_cvtps_pd(_v512_extract_high(a.val)));
-}
-
-// from (Mysticial and wim) https://stackoverflow.com/q/41144668
-inline v_float64x8 v_cvt_f64(const v_int64x8 &v) {
-#if CV_AVX_512DQ
-  return v_float64x8(_mm512_cvtepi64_pd(v.val));
-#else
-  // constants encoded as floating-point
-  __m512i magic_i_lo = _mm512_set1_epi64(0x4330000000000000);   // 2^52
-  __m512i magic_i_hi32 = _mm512_set1_epi64(0x4530000080000000); // 2^84 + 2^63
-  __m512i magic_i_all =
-      _mm512_set1_epi64(0x4530000080100000); // 2^84 + 2^63 + 2^52
-  __m512d magic_d_all = _mm512_castsi512_pd(magic_i_all);
-
-  // Blend the 32 lowest significant bits of v with magic_int_lo
-  __m512i v_lo = _mm512_mask_blend_epi32(0x5555, magic_i_lo, v.val);
-  // Extract the 32 most significant bits of v
-  __m512i v_hi = _mm512_srli_epi64(v.val, 32);
-  // Flip the msb of v_hi and blend with 0x45300000
-  v_hi = _mm512_xor_si512(v_hi, magic_i_hi32);
-  // Compute in double precision
-  __m512d v_hi_dbl = _mm512_sub_pd(_mm512_castsi512_pd(v_hi), magic_d_all);
-  // (v_hi - magic_d_all) + v_lo  Do not assume associativity of floating point
-  // addition
-  __m512d result = _mm512_add_pd(v_hi_dbl, _mm512_castsi512_pd(v_lo));
-  return v_float64x8(result);
-#endif
-}
-
-////////////// Lookup table access ////////////////////
-
-inline v_int8x64 v512_lut(const schar *tab, const int *idx) {
-  __m128i p0 = _mm512_cvtepi32_epi8(_mm512_i32gather_epi32(
-      _mm512_loadu_si512((const __m512i *)idx), (const int *)tab, 1));
-  __m128i p1 = _mm512_cvtepi32_epi8(_mm512_i32gather_epi32(
-      _mm512_loadu_si512((const __m512i *)idx + 1), (const int *)tab, 1));
-  __m128i p2 = _mm512_cvtepi32_epi8(_mm512_i32gather_epi32(
-      _mm512_loadu_si512((const __m512i *)idx + 2), (const int *)tab, 1));
-  __m128i p3 = _mm512_cvtepi32_epi8(_mm512_i32gather_epi32(
-      _mm512_loadu_si512((const __m512i *)idx + 3), (const int *)tab, 1));
-  return v_int8x64(_mm512_inserti32x4(
-      _mm512_inserti32x4(_mm512_inserti32x4(_mm512_castsi128_si512(p0), p1, 1),
-                         p2, 2),
-      p3, 3));
-}
-inline v_int8x64 v512_lut_pairs(const schar *tab, const int *idx) {
-  __m256i p0 = _mm512_cvtepi32_epi16(_mm512_i32gather_epi32(
-      _mm512_loadu_si512((const __m512i *)idx), (const int *)tab, 1));
-  __m256i p1 = _mm512_cvtepi32_epi16(_mm512_i32gather_epi32(
-      _mm512_loadu_si512((const __m512i *)idx + 1), (const int *)tab, 1));
-  return v_int8x64(_v512_combine(p0, p1));
-}
-inline v_int8x64 v512_lut_quads(const schar *tab, const int *idx) {
-  return v_int8x64(_mm512_i32gather_epi32(
-      _mm512_loadu_si512((const __m512i *)idx), (const int *)tab, 1));
-}
-inline v_uint8x64 v512_lut(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v512_lut((const schar *)tab, idx));
-}
-inline v_uint8x64 v512_lut_pairs(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v512_lut_pairs((const schar *)tab, idx));
-}
-inline v_uint8x64 v512_lut_quads(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v512_lut_quads((const schar *)tab, idx));
-}
-
-inline v_int16x32 v512_lut(const short *tab, const int *idx) {
-  __m256i p0 = _mm512_cvtepi32_epi16(_mm512_i32gather_epi32(
-      _mm512_loadu_si512((const __m512i *)idx), (const int *)tab, 2));
-  __m256i p1 = _mm512_cvtepi32_epi16(_mm512_i32gather_epi32(
-      _mm512_loadu_si512((const __m512i *)idx + 1), (const int *)tab, 2));
-  return v_int16x32(_v512_combine(p0, p1));
-}
-inline v_int16x32 v512_lut_pairs(const short *tab, const int *idx) {
-  return v_int16x32(_mm512_i32gather_epi32(
-      _mm512_loadu_si512((const __m512i *)idx), (const int *)tab, 2));
-}
-inline v_int16x32 v512_lut_quads(const short *tab, const int *idx) {
-#if defined(__GNUC__)
-  return v_int16x32(_mm512_i32gather_epi64(
-      _mm256_loadu_si256((const __m256i *)idx), (const long long int *)tab, 2));
-#else
-  return v_int16x32(_mm512_i32gather_epi64(
-      _mm256_loadu_si256((const __m256i *)idx), (const int64 *)tab, 2));
-#endif
-}
-inline v_uint16x32 v512_lut(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v512_lut((const short *)tab, idx));
-}
-inline v_uint16x32 v512_lut_pairs(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v512_lut_pairs((const short *)tab, idx));
-}
-inline v_uint16x32 v512_lut_quads(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v512_lut_quads((const short *)tab, idx));
-}
-
-inline v_int32x16 v512_lut(const int *tab, const int *idx) {
-  return v_int32x16(
-      _mm512_i32gather_epi32(_mm512_loadu_si512((const __m512i *)idx), tab, 4));
-}
-inline v_int32x16 v512_lut_pairs(const int *tab, const int *idx) {
-#if defined(__GNUC__)
-  return v_int32x16(_mm512_i32gather_epi64(
-      _mm256_loadu_si256((const __m256i *)idx), (const long long int *)tab, 4));
-#else
-  return v_int32x16(_mm512_i32gather_epi64(
-      _mm256_loadu_si256((const __m256i *)idx), (const int64 *)tab, 4));
-#endif
-}
-inline v_int32x16 v512_lut_quads(const int *tab, const int *idx) {
-  return v_int32x16(_mm512_inserti32x4(
-      _mm512_inserti32x4(
-          _mm512_inserti32x4(_mm512_castsi128_si512(_mm_loadu_si128(
-                                 (const __m128i *)(tab + idx[0]))),
-                             _mm_loadu_si128((const __m128i *)(tab + idx[1])),
-                             1),
-          _mm_loadu_si128((const __m128i *)(tab + idx[2])), 2),
-      _mm_loadu_si128((const __m128i *)(tab + idx[3])), 3));
-}
-inline v_uint32x16 v512_lut(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v512_lut((const int *)tab, idx));
-}
-inline v_uint32x16 v512_lut_pairs(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v512_lut_pairs((const int *)tab, idx));
-}
-inline v_uint32x16 v512_lut_quads(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v512_lut_quads((const int *)tab, idx));
-}
-
-inline v_int64x8 v512_lut(const int64 *tab, const int *idx) {
-#if defined(__GNUC__)
-  return v_int64x8(_mm512_i32gather_epi64(
-      _mm256_loadu_si256((const __m256i *)idx), (const long long int *)tab, 8));
-#else
-  return v_int64x8(
-      _mm512_i32gather_epi64(_mm256_loadu_si256((const __m256i *)idx), tab, 8));
-#endif
-}
-inline v_int64x8 v512_lut_pairs(const int64 *tab, const int *idx) {
-  return v_int64x8(_mm512_inserti32x4(
-      _mm512_inserti32x4(
-          _mm512_inserti32x4(_mm512_castsi128_si512(_mm_loadu_si128(
-                                 (const __m128i *)(tab + idx[0]))),
-                             _mm_loadu_si128((const __m128i *)(tab + idx[1])),
-                             1),
-          _mm_loadu_si128((const __m128i *)(tab + idx[2])), 2),
-      _mm_loadu_si128((const __m128i *)(tab + idx[3])), 3));
-}
-inline v_uint64x8 v512_lut(const uint64 *tab, const int *idx) {
-  return v_reinterpret_as_u64(v512_lut((const int64 *)tab, idx));
-}
-inline v_uint64x8 v512_lut_pairs(const uint64 *tab, const int *idx) {
-  return v_reinterpret_as_u64(v512_lut_pairs((const int64 *)tab, idx));
-}
-
-inline v_float32x16 v512_lut(const float *tab, const int *idx) {
-  return v_float32x16(
-      _mm512_i32gather_ps(_mm512_loadu_si512((const __m512i *)idx), tab, 4));
-}
-inline v_float32x16 v512_lut_pairs(const float *tab, const int *idx) {
-  return v_reinterpret_as_f32(v512_lut_pairs((const int *)tab, idx));
-}
-inline v_float32x16 v512_lut_quads(const float *tab, const int *idx) {
-  return v_reinterpret_as_f32(v512_lut_quads((const int *)tab, idx));
-}
-
-inline v_float64x8 v512_lut(const double *tab, const int *idx) {
-  return v_float64x8(
-      _mm512_i32gather_pd(_mm256_loadu_si256((const __m256i *)idx), tab, 8));
-}
-inline v_float64x8 v512_lut_pairs(const double *tab, const int *idx) {
-  return v_float64x8(_mm512_insertf64x2(
-      _mm512_insertf64x2(
-          _mm512_insertf64x2(_mm512_castpd128_pd512(_mm_loadu_pd(tab + idx[0])),
-                             _mm_loadu_pd(tab + idx[1]), 1),
-          _mm_loadu_pd(tab + idx[2]), 2),
-      _mm_loadu_pd(tab + idx[3]), 3));
-}
-
-inline v_int32x16 v_lut(const int *tab, const v_int32x16 &idxvec) {
-  return v_int32x16(_mm512_i32gather_epi32(idxvec.val, tab, 4));
-}
-
-inline v_uint32x16 v_lut(const unsigned *tab, const v_int32x16 &idxvec) {
-  return v_reinterpret_as_u32(v_lut((const int *)tab, idxvec));
-}
-
-inline v_float32x16 v_lut(const float *tab, const v_int32x16 &idxvec) {
-  return v_float32x16(_mm512_i32gather_ps(idxvec.val, tab, 4));
-}
-
-inline v_float64x8 v_lut(const double *tab, const v_int32x16 &idxvec) {
-  return v_float64x8(
-      _mm512_i32gather_pd(_v512_extract_low(idxvec.val), tab, 8));
-}
-
-inline void v_lut_deinterleave(const float *tab, const v_int32x16 &idxvec,
-                               v_float32x16 &x, v_float32x16 &y) {
-  x.val = _mm512_i32gather_ps(idxvec.val, tab, 4);
-  y.val = _mm512_i32gather_ps(idxvec.val, &tab[1], 4);
-}
-
-inline void v_lut_deinterleave(const double *tab, const v_int32x16 &idxvec,
-                               v_float64x8 &x, v_float64x8 &y) {
-  x.val = _mm512_i32gather_pd(_v512_extract_low(idxvec.val), tab, 8);
-  y.val = _mm512_i32gather_pd(_v512_extract_low(idxvec.val), &tab[1], 8);
-}
-
-inline v_int8x64 v_interleave_pairs(const v_int8x64 &vec) {
-  return v_int8x64(
-      _mm512_shuffle_epi8(vec.val, _mm512_set4_epi32(0x0f0d0e0c, 0x0b090a08,
-                                                     0x07050604, 0x03010200)));
-}
-inline v_uint8x64 v_interleave_pairs(const v_uint8x64 &vec) {
-  return v_reinterpret_as_u8(v_interleave_pairs(v_reinterpret_as_s8(vec)));
-}
-inline v_int8x64 v_interleave_quads(const v_int8x64 &vec) {
-  return v_int8x64(
-      _mm512_shuffle_epi8(vec.val, _mm512_set4_epi32(0x0f0b0e0a, 0x0d090c08,
-                                                     0x07030602, 0x05010400)));
-}
-inline v_uint8x64 v_interleave_quads(const v_uint8x64 &vec) {
-  return v_reinterpret_as_u8(v_interleave_quads(v_reinterpret_as_s8(vec)));
-}
-
-inline v_int16x32 v_interleave_pairs(const v_int16x32 &vec) {
-  return v_int16x32(
-      _mm512_shuffle_epi8(vec.val, _mm512_set4_epi32(0x0f0e0b0a, 0x0d0c0908,
-                                                     0x07060302, 0x05040100)));
-}
-inline v_uint16x32 v_interleave_pairs(const v_uint16x32 &vec) {
-  return v_reinterpret_as_u16(v_interleave_pairs(v_reinterpret_as_s16(vec)));
-}
-inline v_int16x32 v_interleave_quads(const v_int16x32 &vec) {
-  return v_int16x32(
-      _mm512_shuffle_epi8(vec.val, _mm512_set4_epi32(0x0f0e0706, 0x0d0c0504,
-                                                     0x0b0a0302, 0x09080100)));
-}
-inline v_uint16x32 v_interleave_quads(const v_uint16x32 &vec) {
-  return v_reinterpret_as_u16(v_interleave_quads(v_reinterpret_as_s16(vec)));
-}
-
-inline v_int32x16 v_interleave_pairs(const v_int32x16 &vec) {
-  return v_int32x16(_mm512_shuffle_epi32(vec.val, _MM_PERM_ACBD));
-}
-inline v_uint32x16 v_interleave_pairs(const v_uint32x16 &vec) {
-  return v_reinterpret_as_u32(v_interleave_pairs(v_reinterpret_as_s32(vec)));
-}
-inline v_float32x16 v_interleave_pairs(const v_float32x16 &vec) {
-  return v_reinterpret_as_f32(v_interleave_pairs(v_reinterpret_as_s32(vec)));
-}
-
-inline v_int8x64 v_pack_triplets(const v_int8x64 &vec) {
-  return v_int8x64(_mm512_permutexvar_epi32(
-      _v512_set_epu64(0x0000000f0000000f, 0x0000000f0000000f,
-                      0x0000000e0000000d, 0x0000000c0000000a,
-                      0x0000000900000008, 0x0000000600000005,
-                      0x0000000400000002, 0x0000000100000000),
-      _mm512_shuffle_epi8(vec.val, _mm512_set4_epi32(0xffffff0f, 0x0e0d0c0a,
-                                                     0x09080605, 0x04020100))));
-}
-inline v_uint8x64 v_pack_triplets(const v_uint8x64 &vec) {
-  return v_reinterpret_as_u8(v_pack_triplets(v_reinterpret_as_s8(vec)));
-}
-
-inline v_int16x32 v_pack_triplets(const v_int16x32 &vec) {
-  return v_int16x32(_mm512_permutexvar_epi16(
-      _v512_set_epu64(0x001f001f001f001f, 0x001f001f001f001f,
-                      0x001e001d001c001a, 0x0019001800160015,
-                      0x0014001200110010, 0x000e000d000c000a,
-                      0x0009000800060005, 0x0004000200010000),
-      vec.val));
-}
-inline v_uint16x32 v_pack_triplets(const v_uint16x32 &vec) {
-  return v_reinterpret_as_u16(v_pack_triplets(v_reinterpret_as_s16(vec)));
-}
-
-inline v_int32x16 v_pack_triplets(const v_int32x16 &vec) {
-  return v_int32x16(_mm512_permutexvar_epi32(
-      _v512_set_epu64(0x0000000f0000000f, 0x0000000f0000000f,
-                      0x0000000e0000000d, 0x0000000c0000000a,
-                      0x0000000900000008, 0x0000000600000005,
-                      0x0000000400000002, 0x0000000100000000),
-      vec.val));
-}
-inline v_uint32x16 v_pack_triplets(const v_uint32x16 &vec) {
-  return v_reinterpret_as_u32(v_pack_triplets(v_reinterpret_as_s32(vec)));
-}
-inline v_float32x16 v_pack_triplets(const v_float32x16 &vec) {
-  return v_float32x16(_mm512_permutexvar_ps(
-      _v512_set_epu64(0x0000000f0000000f, 0x0000000f0000000f,
-                      0x0000000e0000000d, 0x0000000c0000000a,
-                      0x0000000900000008, 0x0000000600000005,
-                      0x0000000400000002, 0x0000000100000000),
-      vec.val));
-}
-
-////////// Matrix operations /////////
-
-//////// Dot Product ////////
-
-// 16 >> 32
-inline v_int32x16 v_dotprod(const v_int16x32 &a, const v_int16x32 &b) {
-  return v_int32x16(_mm512_madd_epi16(a.val, b.val));
-}
-inline v_int32x16 v_dotprod(const v_int16x32 &a, const v_int16x32 &b,
-                            const v_int32x16 &c) {
-  return v_add(v_dotprod(a, b), c);
-}
-
-// 32 >> 64
-inline v_int64x8 v_dotprod(const v_int32x16 &a, const v_int32x16 &b) {
-  __m512i even = _mm512_mul_epi32(a.val, b.val);
-  __m512i odd = _mm512_mul_epi32(_mm512_srli_epi64(a.val, 32),
-                                 _mm512_srli_epi64(b.val, 32));
-  return v_int64x8(_mm512_add_epi64(even, odd));
-}
-inline v_int64x8 v_dotprod(const v_int32x16 &a, const v_int32x16 &b,
-                           const v_int64x8 &c) {
-  return v_add(v_dotprod(a, b), c);
-}
-
-// 8 >> 32
-inline v_uint32x16 v_dotprod_expand(const v_uint8x64 &a, const v_uint8x64 &b) {
-  __m512i even_a =
-      _mm512_mask_blend_epi8(0xAAAAAAAAAAAAAAAA, a.val, _mm512_setzero_si512());
-  __m512i odd_a = _mm512_srli_epi16(a.val, 8);
-
-  __m512i even_b =
-      _mm512_mask_blend_epi8(0xAAAAAAAAAAAAAAAA, b.val, _mm512_setzero_si512());
-  __m512i odd_b = _mm512_srli_epi16(b.val, 8);
-
-  __m512i prod0 = _mm512_madd_epi16(even_a, even_b);
-  __m512i prod1 = _mm512_madd_epi16(odd_a, odd_b);
-  return v_uint32x16(_mm512_add_epi32(prod0, prod1));
-}
-inline v_uint32x16 v_dotprod_expand(const v_uint8x64 &a, const v_uint8x64 &b,
-                                    const v_uint32x16 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-inline v_int32x16 v_dotprod_expand(const v_int8x64 &a, const v_int8x64 &b) {
-  __m512i even_a = _mm512_srai_epi16(_mm512_bslli_epi128(a.val, 1), 8);
-  __m512i odd_a = _mm512_srai_epi16(a.val, 8);
-
-  __m512i even_b = _mm512_srai_epi16(_mm512_bslli_epi128(b.val, 1), 8);
-  __m512i odd_b = _mm512_srai_epi16(b.val, 8);
-
-  __m512i prod0 = _mm512_madd_epi16(even_a, even_b);
-  __m512i prod1 = _mm512_madd_epi16(odd_a, odd_b);
-  return v_int32x16(_mm512_add_epi32(prod0, prod1));
-}
-inline v_int32x16 v_dotprod_expand(const v_int8x64 &a, const v_int8x64 &b,
-                                   const v_int32x16 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-// 16 >> 64
-inline v_uint64x8 v_dotprod_expand(const v_uint16x32 &a, const v_uint16x32 &b) {
-  __m512i mullo = _mm512_mullo_epi16(a.val, b.val);
-  __m512i mulhi = _mm512_mulhi_epu16(a.val, b.val);
-  __m512i mul0 = _mm512_unpacklo_epi16(mullo, mulhi);
-  __m512i mul1 = _mm512_unpackhi_epi16(mullo, mulhi);
-
-  __m512i p02 = _mm512_mask_blend_epi32(0xAAAA, mul0, _mm512_setzero_si512());
-  __m512i p13 = _mm512_srli_epi64(mul0, 32);
-  __m512i p46 = _mm512_mask_blend_epi32(0xAAAA, mul1, _mm512_setzero_si512());
-  __m512i p57 = _mm512_srli_epi64(mul1, 32);
-
-  __m512i p15_ = _mm512_add_epi64(p02, p13);
-  __m512i p9d_ = _mm512_add_epi64(p46, p57);
-
-  return v_uint64x8(_mm512_add_epi64(_mm512_unpacklo_epi64(p15_, p9d_),
-                                     _mm512_unpackhi_epi64(p15_, p9d_)));
-}
-inline v_uint64x8 v_dotprod_expand(const v_uint16x32 &a, const v_uint16x32 &b,
-                                   const v_uint64x8 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-inline v_int64x8 v_dotprod_expand(const v_int16x32 &a, const v_int16x32 &b) {
-  __m512i prod = _mm512_madd_epi16(a.val, b.val);
-  __m512i even = _mm512_srai_epi64(_mm512_bslli_epi128(prod, 4), 32);
-  __m512i odd = _mm512_srai_epi64(prod, 32);
-  return v_int64x8(_mm512_add_epi64(even, odd));
-}
-inline v_int64x8 v_dotprod_expand(const v_int16x32 &a, const v_int16x32 &b,
-                                  const v_int64x8 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-// 32 >> 64f
-inline v_float64x8 v_dotprod_expand(const v_int32x16 &a, const v_int32x16 &b) {
-  return v_cvt_f64(v_dotprod(a, b));
-}
-inline v_float64x8 v_dotprod_expand(const v_int32x16 &a, const v_int32x16 &b,
-                                    const v_float64x8 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-//////// Fast Dot Product ////////
-
-// 16 >> 32
-inline v_int32x16 v_dotprod_fast(const v_int16x32 &a, const v_int16x32 &b) {
-  return v_dotprod(a, b);
-}
-inline v_int32x16 v_dotprod_fast(const v_int16x32 &a, const v_int16x32 &b,
-                                 const v_int32x16 &c) {
-  return v_dotprod(a, b, c);
-}
-
-// 32 >> 64
-inline v_int64x8 v_dotprod_fast(const v_int32x16 &a, const v_int32x16 &b) {
-  return v_dotprod(a, b);
-}
-inline v_int64x8 v_dotprod_fast(const v_int32x16 &a, const v_int32x16 &b,
-                                const v_int64x8 &c) {
-  return v_dotprod(a, b, c);
-}
-
-// 8 >> 32
-inline v_uint32x16 v_dotprod_expand_fast(const v_uint8x64 &a,
-                                         const v_uint8x64 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_uint32x16 v_dotprod_expand_fast(const v_uint8x64 &a,
-                                         const v_uint8x64 &b,
-                                         const v_uint32x16 &c) {
-  return v_dotprod_expand(a, b, c);
-}
-
-inline v_int32x16 v_dotprod_expand_fast(const v_int8x64 &a,
-                                        const v_int8x64 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_int32x16 v_dotprod_expand_fast(const v_int8x64 &a, const v_int8x64 &b,
-                                        const v_int32x16 &c) {
-  return v_dotprod_expand(a, b, c);
-}
-
-// 16 >> 64
-inline v_uint64x8 v_dotprod_expand_fast(const v_uint16x32 &a,
-                                        const v_uint16x32 &b) {
-  __m512i mullo = _mm512_mullo_epi16(a.val, b.val);
-  __m512i mulhi = _mm512_mulhi_epu16(a.val, b.val);
-  __m512i mul0 = _mm512_unpacklo_epi16(mullo, mulhi);
-  __m512i mul1 = _mm512_unpackhi_epi16(mullo, mulhi);
-
-  __m512i p02 = _mm512_mask_blend_epi32(0xAAAA, mul0, _mm512_setzero_si512());
-  __m512i p13 = _mm512_srli_epi64(mul0, 32);
-  __m512i p46 = _mm512_mask_blend_epi32(0xAAAA, mul1, _mm512_setzero_si512());
-  __m512i p57 = _mm512_srli_epi64(mul1, 32);
-
-  __m512i p15_ = _mm512_add_epi64(p02, p13);
-  __m512i p9d_ = _mm512_add_epi64(p46, p57);
-  return v_uint64x8(_mm512_add_epi64(p15_, p9d_));
-}
-inline v_uint64x8 v_dotprod_expand_fast(const v_uint16x32 &a,
-                                        const v_uint16x32 &b,
-                                        const v_uint64x8 &c) {
-  return v_add(v_dotprod_expand_fast(a, b), c);
-}
-
-inline v_int64x8 v_dotprod_expand_fast(const v_int16x32 &a,
-                                       const v_int16x32 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_int64x8 v_dotprod_expand_fast(const v_int16x32 &a, const v_int16x32 &b,
-                                       const v_int64x8 &c) {
-  return v_dotprod_expand(a, b, c);
-}
-
-// 32 >> 64f
-inline v_float64x8 v_dotprod_expand_fast(const v_int32x16 &a,
-                                         const v_int32x16 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_float64x8 v_dotprod_expand_fast(const v_int32x16 &a,
-                                         const v_int32x16 &b,
-                                         const v_float64x8 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-#define OPENCV_HAL_AVX512_SPLAT2_PS(a, im)                                     \
-  v_float32x16(_mm512_permute_ps(a.val, _MM_SHUFFLE(im, im, im, im)))
-
-inline v_float32x16 v_matmul(const v_float32x16 &v, const v_float32x16 &m0,
-                             const v_float32x16 &m1, const v_float32x16 &m2,
-                             const v_float32x16 &m3) {
-  v_float32x16 v04 = OPENCV_HAL_AVX512_SPLAT2_PS(v, 0);
-  v_float32x16 v15 = OPENCV_HAL_AVX512_SPLAT2_PS(v, 1);
-  v_float32x16 v26 = OPENCV_HAL_AVX512_SPLAT2_PS(v, 2);
-  v_float32x16 v37 = OPENCV_HAL_AVX512_SPLAT2_PS(v, 3);
-  return v_fma(v04, m0, v_fma(v15, m1, v_fma(v26, m2, v_mul(v37, m3))));
-}
-
-inline v_float32x16 v_matmuladd(const v_float32x16 &v, const v_float32x16 &m0,
-                                const v_float32x16 &m1, const v_float32x16 &m2,
-                                const v_float32x16 &a) {
-  v_float32x16 v04 = OPENCV_HAL_AVX512_SPLAT2_PS(v, 0);
-  v_float32x16 v15 = OPENCV_HAL_AVX512_SPLAT2_PS(v, 1);
-  v_float32x16 v26 = OPENCV_HAL_AVX512_SPLAT2_PS(v, 2);
-  return v_fma(v04, m0, v_fma(v15, m1, v_fma(v26, m2, a)));
-}
-
-#define OPENCV_HAL_IMPL_AVX512_TRANSPOSE4x4(_Tpvec, suffix, cast_from,         \
-                                            cast_to)                           \
-  inline void v_transpose4x4(const _Tpvec &a0, const _Tpvec &a1,               \
-                             const _Tpvec &a2, const _Tpvec &a3, _Tpvec &b0,   \
-                             _Tpvec &b1, _Tpvec &b2, _Tpvec &b3) {             \
-    __m512i t0 = cast_from(_mm512_unpacklo_##suffix(a0.val, a1.val));          \
-    __m512i t1 = cast_from(_mm512_unpacklo_##suffix(a2.val, a3.val));          \
-    __m512i t2 = cast_from(_mm512_unpackhi_##suffix(a0.val, a1.val));          \
-    __m512i t3 = cast_from(_mm512_unpackhi_##suffix(a2.val, a3.val));          \
-    b0.val = cast_to(_mm512_unpacklo_epi64(t0, t1));                           \
-    b1.val = cast_to(_mm512_unpackhi_epi64(t0, t1));                           \
-    b2.val = cast_to(_mm512_unpacklo_epi64(t2, t3));                           \
-    b3.val = cast_to(_mm512_unpackhi_epi64(t2, t3));                           \
-  }
-
-OPENCV_HAL_IMPL_AVX512_TRANSPOSE4x4(
-    v_uint32x16, epi32, OPENCV_HAL_NOP,
-    OPENCV_HAL_NOP) OPENCV_HAL_IMPL_AVX512_TRANSPOSE4x4(v_int32x16, epi32,
-                                                        OPENCV_HAL_NOP,
-                                                        OPENCV_HAL_NOP)
-    OPENCV_HAL_IMPL_AVX512_TRANSPOSE4x4(v_float32x16, ps, _mm512_castps_si512,
-                                        _mm512_castsi512_ps)
-
-//////////////// Value reordering ///////////////
-
-/* Expand */
-#define OPENCV_HAL_IMPL_AVX512_EXPAND(_Tpvec, _Tpwvec, _Tp, intrin)            \
-  inline void v_expand(const _Tpvec &a, _Tpwvec &b0, _Tpwvec &b1) {            \
-    b0.val = intrin(_v512_extract_low(a.val));                                 \
-    b1.val = intrin(_v512_extract_high(a.val));                                \
-  }                                                                            \
-  inline _Tpwvec v_expand_low(const _Tpvec &a) {                               \
-    return _Tpwvec(intrin(_v512_extract_low(a.val)));                          \
-  }                                                                            \
-  inline _Tpwvec v_expand_high(const _Tpvec &a) {                              \
-    return _Tpwvec(intrin(_v512_extract_high(a.val)));                         \
-  }                                                                            \
-  inline _Tpwvec v512_load_expand(const _Tp *ptr) {                            \
-    __m256i a = _mm256_loadu_si256((const __m256i *)ptr);                      \
-    return _Tpwvec(intrin(a));                                                 \
-  }
-
-        OPENCV_HAL_IMPL_AVX512_EXPAND(v_uint8x64, v_uint16x32, uchar,
-                                      _mm512_cvtepu8_epi16)
-            OPENCV_HAL_IMPL_AVX512_EXPAND(v_int8x64, v_int16x32, schar,
-                                          _mm512_cvtepi8_epi16)
-                OPENCV_HAL_IMPL_AVX512_EXPAND(v_uint16x32, v_uint32x16, ushort,
-                                              _mm512_cvtepu16_epi32)
-                    OPENCV_HAL_IMPL_AVX512_EXPAND(v_int16x32, v_int32x16, short,
-                                                  _mm512_cvtepi16_epi32)
-                        OPENCV_HAL_IMPL_AVX512_EXPAND(v_uint32x16, v_uint64x8,
-                                                      unsigned,
-                                                      _mm512_cvtepu32_epi64)
-                            OPENCV_HAL_IMPL_AVX512_EXPAND(v_int32x16, v_int64x8,
-                                                          int,
-                                                          _mm512_cvtepi32_epi64)
-
-#define OPENCV_HAL_IMPL_AVX512_EXPAND_Q(_Tpvec, _Tp, intrin)                   \
-  inline _Tpvec v512_load_expand_q(const _Tp *ptr) {                           \
-    __m128i a = _mm_loadu_si128((const __m128i *)ptr);                         \
-    return _Tpvec(intrin(a));                                                  \
-  }
-
-                                OPENCV_HAL_IMPL_AVX512_EXPAND_Q(
-                                    v_uint32x16, uchar, _mm512_cvtepu8_epi32)
-                                    OPENCV_HAL_IMPL_AVX512_EXPAND_Q(
-                                        v_int32x16, schar, _mm512_cvtepi8_epi32)
-
-    /* pack */
-    // 16
-    inline v_int8x64 v_pack(const v_int16x32 &a, const v_int16x32 &b) {
-  return v_int8x64(
-      _mm512_permutexvar_epi64(_v512_set_epu64(7, 5, 3, 1, 6, 4, 2, 0),
-                               _mm512_packs_epi16(a.val, b.val)));
-}
-
-inline v_uint8x64 v_pack(const v_uint16x32 &a, const v_uint16x32 &b) {
-  const __m512i t = _mm512_set1_epi16(255);
-  return v_uint8x64(
-      _v512_combine(_mm512_cvtepi16_epi8(_mm512_min_epu16(a.val, t)),
-                    _mm512_cvtepi16_epi8(_mm512_min_epu16(b.val, t))));
-}
-
-inline v_uint8x64 v_pack_u(const v_int16x32 &a, const v_int16x32 &b) {
-  return v_uint8x64(
-      _mm512_permutexvar_epi64(_v512_set_epu64(7, 5, 3, 1, 6, 4, 2, 0),
-                               _mm512_packus_epi16(a.val, b.val)));
-}
-
-inline void v_pack_store(schar *ptr, const v_int16x32 &a) {
-  v_store_low(ptr, v_pack(a, a));
-}
-
-inline void v_pack_store(uchar *ptr, const v_uint16x32 &a) {
-  const __m512i m = _mm512_set1_epi16(255);
-  _mm256_storeu_si256((__m256i *)ptr,
-                      _mm512_cvtepi16_epi8(_mm512_min_epu16(a.val, m)));
-}
-
-inline void v_pack_u_store(uchar *ptr, const v_int16x32 &a) {
-  v_store_low(ptr, v_pack_u(a, a));
-}
-
-template <int n>
-inline v_uint8x64 v_rshr_pack(const v_uint16x32 &a, const v_uint16x32 &b) {
-  // we assume that n > 0, and so the shifted 16-bit values can be treated as
-  // signed numbers.
-  v_uint16x32 delta = v512_setall_u16((short)(1 << (n - 1)));
-  return v_pack_u(v_reinterpret_as_s16(v_shr(v_add(a, delta), n)),
-                  v_reinterpret_as_s16(v_shr(v_add(b, delta), n)));
-}
-
-template <int n>
-inline void v_rshr_pack_store(uchar *ptr, const v_uint16x32 &a) {
-  v_uint16x32 delta = v512_setall_u16((short)(1 << (n - 1)));
-  v_pack_u_store(ptr, v_reinterpret_as_s16(v_shr(v_add(a, delta), n)));
-}
-
-template <int n>
-inline v_uint8x64 v_rshr_pack_u(const v_int16x32 &a, const v_int16x32 &b) {
-  v_int16x32 delta = v512_setall_s16((short)(1 << (n - 1)));
-  return v_pack_u(v_shr(v_add(a, delta), n), v_shr(v_add(b, delta), n));
-}
-
-template <int n>
-inline void v_rshr_pack_u_store(uchar *ptr, const v_int16x32 &a) {
-  v_int16x32 delta = v512_setall_s16((short)(1 << (n - 1)));
-  v_pack_u_store(ptr, v_shr(v_add(a, delta), n));
-}
-
-template <int n>
-inline v_int8x64 v_rshr_pack(const v_int16x32 &a, const v_int16x32 &b) {
-  v_int16x32 delta = v512_setall_s16((short)(1 << (n - 1)));
-  return v_pack(v_shr(v_add(a, delta), n), v_shr(v_add(b, delta), n));
-}
-
-template <int n>
-inline void v_rshr_pack_store(schar *ptr, const v_int16x32 &a) {
-  v_int16x32 delta = v512_setall_s16((short)(1 << (n - 1)));
-  v_pack_store(ptr, v_shr(v_add(a, delta), n));
-}
-
-// 32
-inline v_int16x32 v_pack(const v_int32x16 &a, const v_int32x16 &b) {
-  return v_int16x32(
-      _mm512_permutexvar_epi64(_v512_set_epu64(7, 5, 3, 1, 6, 4, 2, 0),
-                               _mm512_packs_epi32(a.val, b.val)));
-}
-
-inline v_uint16x32 v_pack(const v_uint32x16 &a, const v_uint32x16 &b) {
-  const __m512i m = _mm512_set1_epi32(65535);
-  return v_uint16x32(
-      _v512_combine(_mm512_cvtepi32_epi16(_mm512_min_epu32(a.val, m)),
-                    _mm512_cvtepi32_epi16(_mm512_min_epu32(b.val, m))));
-}
-
-inline v_uint16x32 v_pack_u(const v_int32x16 &a, const v_int32x16 &b) {
-  return v_uint16x32(
-      _mm512_permutexvar_epi64(_v512_set_epu64(7, 5, 3, 1, 6, 4, 2, 0),
-                               _mm512_packus_epi32(a.val, b.val)));
-}
-
-inline void v_pack_store(short *ptr, const v_int32x16 &a) {
-  v_store_low(ptr, v_pack(a, a));
-}
-
-inline void v_pack_store(ushort *ptr, const v_uint32x16 &a) {
-  const __m512i m = _mm512_set1_epi32(65535);
-  _mm256_storeu_si256((__m256i *)ptr,
-                      _mm512_cvtepi32_epi16(_mm512_min_epu32(a.val, m)));
-}
-
-inline void v_pack_u_store(ushort *ptr, const v_int32x16 &a) {
-  v_store_low(ptr, v_pack_u(a, a));
-}
-
-template <int n>
-inline v_uint16x32 v_rshr_pack(const v_uint32x16 &a, const v_uint32x16 &b) {
-  v_uint32x16 delta = v512_setall_u32(1 << (n - 1));
-  return v_pack_u(v_reinterpret_as_s32(v_shr(v_add(a, delta), n)),
-                  v_reinterpret_as_s32(v_shr(v_add(b, delta), n)));
-}
-
-template <int n>
-inline void v_rshr_pack_store(ushort *ptr, const v_uint32x16 &a) {
-  v_uint32x16 delta = v512_setall_u32(1 << (n - 1));
-  v_pack_u_store(ptr, v_reinterpret_as_s32(v_shr(v_add(a, delta), n)));
-}
-
-template <int n>
-inline v_uint16x32 v_rshr_pack_u(const v_int32x16 &a, const v_int32x16 &b) {
-  v_int32x16 delta = v512_setall_s32(1 << (n - 1));
-  return v_pack_u(v_shr(v_add(a, delta), n), v_shr(v_add(b, delta), n));
-}
-
-template <int n>
-inline void v_rshr_pack_u_store(ushort *ptr, const v_int32x16 &a) {
-  v_int32x16 delta = v512_setall_s32(1 << (n - 1));
-  v_pack_u_store(ptr, v_shr(v_add(a, delta), n));
-}
-
-template <int n>
-inline v_int16x32 v_rshr_pack(const v_int32x16 &a, const v_int32x16 &b) {
-  v_int32x16 delta = v512_setall_s32(1 << (n - 1));
-  return v_pack(v_shr(v_add(a, delta), n), v_shr(v_add(b, delta), n));
-}
-
-template <int n>
-inline void v_rshr_pack_store(short *ptr, const v_int32x16 &a) {
-  v_int32x16 delta = v512_setall_s32(1 << (n - 1));
-  v_pack_store(ptr, v_shr(v_add(a, delta), n));
-}
-
-// 64
-// Non-saturating pack
-inline v_uint32x16 v_pack(const v_uint64x8 &a, const v_uint64x8 &b) {
-  return v_uint32x16(_v512_combine(_mm512_cvtepi64_epi32(a.val),
-                                   _mm512_cvtepi64_epi32(b.val)));
-}
-
-inline v_int32x16 v_pack(const v_int64x8 &a, const v_int64x8 &b) {
-  return v_reinterpret_as_s32(
-      v_pack(v_reinterpret_as_u64(a), v_reinterpret_as_u64(b)));
-}
-
-inline void v_pack_store(unsigned *ptr, const v_uint64x8 &a) {
-  _mm256_storeu_si256((__m256i *)ptr, _mm512_cvtepi64_epi32(a.val));
-}
-
-inline void v_pack_store(int *ptr, const v_int64x8 &b) {
-  v_pack_store((unsigned *)ptr, v_reinterpret_as_u64(b));
-}
-
-template <int n>
-inline v_uint32x16 v_rshr_pack(const v_uint64x8 &a, const v_uint64x8 &b) {
-  v_uint64x8 delta = v512_setall_u64((uint64)1 << (n - 1));
-  return v_pack(v_shr(v_add(a, delta), n), v_shr(v_add(b, delta), n));
-}
-
-template <int n>
-inline void v_rshr_pack_store(unsigned *ptr, const v_uint64x8 &a) {
-  v_uint64x8 delta = v512_setall_u64((uint64)1 << (n - 1));
-  v_pack_store(ptr, v_shr(v_add(a, delta), n));
-}
-
-template <int n>
-inline v_int32x16 v_rshr_pack(const v_int64x8 &a, const v_int64x8 &b) {
-  v_int64x8 delta = v512_setall_s64((int64)1 << (n - 1));
-  return v_pack(v_shr(v_add(a, delta), n), v_shr(v_add(b, delta), n));
-}
-
-template <int n> inline void v_rshr_pack_store(int *ptr, const v_int64x8 &a) {
-  v_int64x8 delta = v512_setall_s64((int64)1 << (n - 1));
-  v_pack_store(ptr, v_shr(v_add(a, delta), n));
-}
-
-// pack boolean
-inline v_uint8x64 v_pack_b(const v_uint16x32 &a, const v_uint16x32 &b) {
-  return v_uint8x64(
-      _mm512_permutexvar_epi64(_v512_set_epu64(7, 5, 3, 1, 6, 4, 2, 0),
-                               _mm512_packs_epi16(a.val, b.val)));
-}
-
-inline v_uint8x64 v_pack_b(const v_uint32x16 &a, const v_uint32x16 &b,
-                           const v_uint32x16 &c, const v_uint32x16 &d) {
-  __m512i ab = _mm512_packs_epi32(a.val, b.val);
-  __m512i cd = _mm512_packs_epi32(c.val, d.val);
-
-  return v_uint8x64(_mm512_permutexvar_epi32(
-      _v512_set_epu32(15, 11, 7, 3, 14, 10, 6, 2, 13, 9, 5, 1, 12, 8, 4, 0),
-      _mm512_packs_epi16(ab, cd)));
-}
-
-inline v_uint8x64 v_pack_b(const v_uint64x8 &a, const v_uint64x8 &b,
-                           const v_uint64x8 &c, const v_uint64x8 &d,
-                           const v_uint64x8 &e, const v_uint64x8 &f,
-                           const v_uint64x8 &g, const v_uint64x8 &h) {
-  __m512i ab = _mm512_packs_epi32(a.val, b.val);
-  __m512i cd = _mm512_packs_epi32(c.val, d.val);
-  __m512i ef = _mm512_packs_epi32(e.val, f.val);
-  __m512i gh = _mm512_packs_epi32(g.val, h.val);
-
-  __m512i abcd = _mm512_packs_epi32(ab, cd);
-  __m512i efgh = _mm512_packs_epi32(ef, gh);
-
-  return v_uint8x64(_mm512_permutexvar_epi16(
-      _v512_set_epu16(31, 23, 15, 7, 30, 22, 14, 6, 29, 21, 13, 5, 28, 20, 12,
-                      4, 27, 19, 11, 3, 26, 18, 10, 2, 25, 17, 9, 1, 24, 16, 8,
-                      0),
-      _mm512_packs_epi16(abcd, efgh)));
-}
-
-/* Recombine */
-// its up there with load and store operations
-
-/* Extract */
-#define OPENCV_HAL_IMPL_AVX512_EXTRACT(_Tpvec)                                 \
-  template <int s> inline _Tpvec v_extract(const _Tpvec &a, const _Tpvec &b) { \
-    return v_rotate_right<s>(a, b);                                            \
-  }
-
-OPENCV_HAL_IMPL_AVX512_EXTRACT(v_uint8x64)
-OPENCV_HAL_IMPL_AVX512_EXTRACT(v_int8x64)
-OPENCV_HAL_IMPL_AVX512_EXTRACT(v_uint16x32)
-OPENCV_HAL_IMPL_AVX512_EXTRACT(v_int16x32)
-OPENCV_HAL_IMPL_AVX512_EXTRACT(v_uint32x16)
-OPENCV_HAL_IMPL_AVX512_EXTRACT(v_int32x16)
-OPENCV_HAL_IMPL_AVX512_EXTRACT(v_uint64x8)
-OPENCV_HAL_IMPL_AVX512_EXTRACT(v_int64x8)
-OPENCV_HAL_IMPL_AVX512_EXTRACT(v_float32x16)
-OPENCV_HAL_IMPL_AVX512_EXTRACT(v_float64x8)
-
-#define OPENCV_HAL_IMPL_AVX512_EXTRACT_N(_Tpvec, _Tp)                          \
-  template <int i> inline _Tp v_extract_n(_Tpvec v) {                          \
-    return v_rotate_right<i>(v).get0();                                        \
-  }
-
-OPENCV_HAL_IMPL_AVX512_EXTRACT_N(v_uint8x64, uchar)
-OPENCV_HAL_IMPL_AVX512_EXTRACT_N(v_int8x64, schar)
-OPENCV_HAL_IMPL_AVX512_EXTRACT_N(v_uint16x32, ushort)
-OPENCV_HAL_IMPL_AVX512_EXTRACT_N(v_int16x32, short)
-OPENCV_HAL_IMPL_AVX512_EXTRACT_N(v_uint32x16, uint)
-OPENCV_HAL_IMPL_AVX512_EXTRACT_N(v_int32x16, int)
-OPENCV_HAL_IMPL_AVX512_EXTRACT_N(v_uint64x8, uint64)
-OPENCV_HAL_IMPL_AVX512_EXTRACT_N(v_int64x8, int64)
-OPENCV_HAL_IMPL_AVX512_EXTRACT_N(v_float32x16, float)
-OPENCV_HAL_IMPL_AVX512_EXTRACT_N(v_float64x8, double)
-
-template <int i> inline v_uint32x16 v_broadcast_element(v_uint32x16 a) {
-  static const __m512i perm = _mm512_set1_epi32((char)i);
-  return v_uint32x16(_mm512_permutexvar_epi32(perm, a.val));
-}
-
-template <int i> inline v_int32x16 v_broadcast_element(const v_int32x16 &a) {
-  return v_reinterpret_as_s32(v_broadcast_element<i>(v_reinterpret_as_u32(a)));
-}
-
-template <int i>
-inline v_float32x16 v_broadcast_element(const v_float32x16 &a) {
-  return v_reinterpret_as_f32(v_broadcast_element<i>(v_reinterpret_as_u32(a)));
-}
-
-///////////////////// load deinterleave /////////////////////////////
-
-inline void v_load_deinterleave(const uchar *ptr, v_uint8x64 &a,
-                                v_uint8x64 &b) {
-  __m512i ab0 = _mm512_loadu_si512((const __m512i *)ptr);
-  __m512i ab1 = _mm512_loadu_si512((const __m512i *)(ptr + 64));
-#if CV_AVX_512VBMI
-  __m512i mask0 = _v512_set_epu8(
-      126, 124, 122, 120, 118, 116, 114, 112, 110, 108, 106, 104, 102, 100, 98,
-      96, 94, 92, 90, 88, 86, 84, 82, 80, 78, 76, 74, 72, 70, 68, 66, 64, 62,
-      60, 58, 56, 54, 52, 50, 48, 46, 44, 42, 40, 38, 36, 34, 32, 30, 28, 26,
-      24, 22, 20, 18, 16, 14, 12, 10, 8, 6, 4, 2, 0);
-  __m512i mask1 = _v512_set_epu8(
-      127, 125, 123, 121, 119, 117, 115, 113, 111, 109, 107, 105, 103, 101, 99,
-      97, 95, 93, 91, 89, 87, 85, 83, 81, 79, 77, 75, 73, 71, 69, 67, 65, 63,
-      61, 59, 57, 55, 53, 51, 49, 47, 45, 43, 41, 39, 37, 35, 33, 31, 29, 27,
-      25, 23, 21, 19, 17, 15, 13, 11, 9, 7, 5, 3, 1);
-  a = v_uint8x64(_mm512_permutex2var_epi8(ab0, mask0, ab1));
-  b = v_uint8x64(_mm512_permutex2var_epi8(ab0, mask1, ab1));
-#else
-  __m512i mask0 =
-      _mm512_set4_epi32(0x0f0d0b09, 0x07050301, 0x0e0c0a08, 0x06040200);
-  __m512i a0b0 = _mm512_shuffle_epi8(ab0, mask0);
-  __m512i a1b1 = _mm512_shuffle_epi8(ab1, mask0);
-  __m512i mask1 = _v512_set_epu64(14, 12, 10, 8, 6, 4, 2, 0);
-  __m512i mask2 = _v512_set_epu64(15, 13, 11, 9, 7, 5, 3, 1);
-  a = v_uint8x64(_mm512_permutex2var_epi64(a0b0, mask1, a1b1));
-  b = v_uint8x64(_mm512_permutex2var_epi64(a0b0, mask2, a1b1));
-#endif
-}
-
-inline void v_load_deinterleave(const ushort *ptr, v_uint16x32 &a,
-                                v_uint16x32 &b) {
-  __m512i ab0 = _mm512_loadu_si512((const __m512i *)ptr);
-  __m512i ab1 = _mm512_loadu_si512((const __m512i *)(ptr + 32));
-  __m512i mask0 = _v512_set_epu16(62, 60, 58, 56, 54, 52, 50, 48, 46, 44, 42,
-                                  40, 38, 36, 34, 32, 30, 28, 26, 24, 22, 20,
-                                  18, 16, 14, 12, 10, 8, 6, 4, 2, 0);
-  __m512i mask1 = _v512_set_epu16(63, 61, 59, 57, 55, 53, 51, 49, 47, 45, 43,
-                                  41, 39, 37, 35, 33, 31, 29, 27, 25, 23, 21,
-                                  19, 17, 15, 13, 11, 9, 7, 5, 3, 1);
-  a = v_uint16x32(_mm512_permutex2var_epi16(ab0, mask0, ab1));
-  b = v_uint16x32(_mm512_permutex2var_epi16(ab0, mask1, ab1));
-}
-
-inline void v_load_deinterleave(const unsigned *ptr, v_uint32x16 &a,
-                                v_uint32x16 &b) {
-  __m512i ab0 = _mm512_loadu_si512((const __m512i *)ptr);
-  __m512i ab1 = _mm512_loadu_si512((const __m512i *)(ptr + 16));
-  __m512i mask0 = _v512_set_epu32(30, 28, 26, 24, 22, 20, 18, 16, 14, 12, 10, 8,
-                                  6, 4, 2, 0);
-  __m512i mask1 = _v512_set_epu32(31, 29, 27, 25, 23, 21, 19, 17, 15, 13, 11, 9,
-                                  7, 5, 3, 1);
-  a = v_uint32x16(_mm512_permutex2var_epi32(ab0, mask0, ab1));
-  b = v_uint32x16(_mm512_permutex2var_epi32(ab0, mask1, ab1));
-}
-
-inline void v_load_deinterleave(const uint64 *ptr, v_uint64x8 &a,
-                                v_uint64x8 &b) {
-  __m512i ab0 = _mm512_loadu_si512((const __m512i *)ptr);
-  __m512i ab1 = _mm512_loadu_si512((const __m512i *)(ptr + 8));
-  __m512i mask0 = _v512_set_epu64(14, 12, 10, 8, 6, 4, 2, 0);
-  __m512i mask1 = _v512_set_epu64(15, 13, 11, 9, 7, 5, 3, 1);
-  a = v_uint64x8(_mm512_permutex2var_epi64(ab0, mask0, ab1));
-  b = v_uint64x8(_mm512_permutex2var_epi64(ab0, mask1, ab1));
-}
-
-inline void v_load_deinterleave(const uchar *ptr, v_uint8x64 &a, v_uint8x64 &b,
-                                v_uint8x64 &c) {
-  __m512i bgr0 = _mm512_loadu_si512((const __m512i *)ptr);
-  __m512i bgr1 = _mm512_loadu_si512((const __m512i *)(ptr + 64));
-  __m512i bgr2 = _mm512_loadu_si512((const __m512i *)(ptr + 128));
-
-#if CV_AVX_512VBMI2
-  __m512i mask0 = _v512_set_epu8(
-      126, 123, 120, 117, 114, 111, 108, 105, 102, 99, 96, 93, 90, 87, 84, 81,
-      78, 75, 72, 69, 66, 63, 60, 57, 54, 51, 48, 45, 42, 39, 36, 33, 30, 27,
-      24, 21, 18, 15, 12, 9, 6, 3, 0, 62, 59, 56, 53, 50, 47, 44, 41, 38, 35,
-      32, 29, 26, 23, 20, 17, 14, 11, 8, 5, 2);
-  __m512i r0b01 = _mm512_permutex2var_epi8(bgr0, mask0, bgr1);
-  __m512i b1g12 = _mm512_permutex2var_epi8(bgr1, mask0, bgr2);
-  __m512i r12b2 = _mm512_permutex2var_epi8(
-      bgr1,
-      _v512_set_epu8(125, 122, 119, 116, 113, 110, 107, 104, 101, 98, 95, 92,
-                     89, 86, 83, 80, 77, 74, 71, 68, 65, 127, 124, 121, 118,
-                     115, 112, 109, 106, 103, 100, 97, 94, 91, 88, 85, 82, 79,
-                     76, 73, 70, 67, 64, 61, 58, 55, 52, 49, 46, 43, 40, 37, 34,
-                     31, 28, 25, 22, 19, 16, 13, 10, 7, 4, 1),
-      bgr2);
-  a = v_uint8x64(_mm512_mask_compress_epi8(r12b2, 0xffffffffffe00000, r0b01));
-  b = v_uint8x64(_mm512_mask_compress_epi8(b1g12, 0x2492492492492492, bgr0));
-  c = v_uint8x64(_mm512_mask_expand_epi8(r0b01, 0xffffffffffe00000, r12b2));
-#elif CV_AVX_512VBMI
-  __m512i b0g0b1 = _mm512_mask_blend_epi8(0xb6db6db6db6db6db, bgr1, bgr0);
-  __m512i g1r1g2 = _mm512_mask_blend_epi8(0xb6db6db6db6db6db, bgr2, bgr1);
-  __m512i r2b2r0 = _mm512_mask_blend_epi8(0xb6db6db6db6db6db, bgr0, bgr2);
-  a = v_uint8x64(_mm512_permutex2var_epi8(
-      b0g0b1,
-      _v512_set_epu8(125, 122, 119, 116, 113, 110, 107, 104, 101, 98, 95, 92,
-                     89, 86, 83, 80, 77, 74, 71, 68, 65, 63, 61, 60, 58, 57, 55,
-                     54, 52, 51, 49, 48, 46, 45, 43, 42, 40, 39, 37, 36, 34, 33,
-                     31, 30, 28, 27, 25, 24, 23, 21, 20, 18, 17, 15, 14, 12, 11,
-                     9, 8, 6, 5, 3, 2, 0),
-      bgr2));
-  b = v_uint8x64(_mm512_permutex2var_epi8(
-      g1r1g2,
-      _v512_set_epu8(63, 61, 60, 58, 57, 55, 54, 52, 51, 49, 48, 46, 45, 43, 42,
-                     40, 39, 37, 36, 34, 33, 31, 30, 28, 27, 25, 24, 23, 21, 20,
-                     18, 17, 15, 14, 12, 11, 9, 8, 6, 5, 3, 2, 0, 126, 123, 120,
-                     117, 114, 111, 108, 105, 102, 99, 96, 93, 90, 87, 84, 81,
-                     78, 75, 72, 69, 66),
-      bgr0));
-  c = v_uint8x64(_mm512_permutex2var_epi8(
-      r2b2r0,
-      _v512_set_epu8(63, 60, 57, 54, 51, 48, 45, 42, 39, 36, 33, 30, 27, 24, 21,
-                     18, 15, 12, 9, 6, 3, 0, 125, 122, 119, 116, 113, 110, 107,
-                     104, 101, 98, 95, 92, 89, 86, 83, 80, 77, 74, 71, 68, 65,
-                     62, 59, 56, 53, 50, 47, 44, 41, 38, 35, 32, 29, 26, 23, 20,
-                     17, 14, 11, 8, 5, 2),
-      bgr1));
-#else
-  __m512i mask0 = _v512_set_epu16(61, 58, 55, 52, 49, 46, 43, 40, 37, 34, 63,
-                                  60, 57, 54, 51, 48, 45, 42, 39, 36, 33, 30,
-                                  27, 24, 21, 18, 15, 12, 9, 6, 3, 0);
-  __m512i b01g1 = _mm512_permutex2var_epi16(bgr0, mask0, bgr1);
-  __m512i r12b2 = _mm512_permutex2var_epi16(bgr1, mask0, bgr2);
-  __m512i g20r0 = _mm512_permutex2var_epi16(bgr2, mask0, bgr0);
-
-  __m512i b0g0 = _mm512_mask_blend_epi32(0xf800, b01g1, r12b2);
-  __m512i r0b1 = _mm512_permutex2var_epi16(
-      bgr1,
-      _v512_set_epu16(42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 29, 26, 23,
-                      20, 17, 14, 11, 8, 5, 2, 53, 52, 51, 50, 49, 48, 47, 46,
-                      45, 44, 43),
-      g20r0);
-  __m512i g1r1 = _mm512_alignr_epi32(r12b2, g20r0, 11);
-  a = v_uint8x64(_mm512_mask_blend_epi8(0xAAAAAAAAAAAAAAAA, b0g0, r0b1));
-  c = v_uint8x64(_mm512_mask_blend_epi8(0xAAAAAAAAAAAAAAAA, r0b1, g1r1));
-  b = v_uint8x64(_mm512_shuffle_epi8(
-      _mm512_mask_blend_epi8(0xAAAAAAAAAAAAAAAA, g1r1, b0g0),
-      _mm512_set4_epi32(0x0e0f0c0d, 0x0a0b0809, 0x06070405, 0x02030001)));
-#endif
-}
-
-inline void v_load_deinterleave(const ushort *ptr, v_uint16x32 &a,
-                                v_uint16x32 &b, v_uint16x32 &c) {
-  __m512i bgr0 = _mm512_loadu_si512((const __m512i *)ptr);
-  __m512i bgr1 = _mm512_loadu_si512((const __m512i *)(ptr + 32));
-  __m512i bgr2 = _mm512_loadu_si512((const __m512i *)(ptr + 64));
-
-  __m512i mask0 = _v512_set_epu16(61, 58, 55, 52, 49, 46, 43, 40, 37, 34, 63,
-                                  60, 57, 54, 51, 48, 45, 42, 39, 36, 33, 30,
-                                  27, 24, 21, 18, 15, 12, 9, 6, 3, 0);
-  __m512i b01g1 = _mm512_permutex2var_epi16(bgr0, mask0, bgr1);
-  __m512i r12b2 = _mm512_permutex2var_epi16(bgr1, mask0, bgr2);
-  __m512i g20r0 = _mm512_permutex2var_epi16(bgr2, mask0, bgr0);
-
-  a = v_uint16x32(_mm512_mask_blend_epi32(0xf800, b01g1, r12b2));
-  b = v_uint16x32(_mm512_permutex2var_epi16(
-      bgr1,
-      _v512_set_epu16(42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 29, 26, 23,
-                      20, 17, 14, 11, 8, 5, 2, 53, 52, 51, 50, 49, 48, 47, 46,
-                      45, 44, 43),
-      g20r0));
-  c = v_uint16x32(_mm512_alignr_epi32(r12b2, g20r0, 11));
-}
-
-inline void v_load_deinterleave(const unsigned *ptr, v_uint32x16 &a,
-                                v_uint32x16 &b, v_uint32x16 &c) {
-  __m512i bgr0 = _mm512_loadu_si512((const __m512i *)ptr);
-  __m512i bgr1 = _mm512_loadu_si512((const __m512i *)(ptr + 16));
-  __m512i bgr2 = _mm512_loadu_si512((const __m512i *)(ptr + 32));
-
-  __m512i mask0 = _v512_set_epu32(29, 26, 23, 20, 17, 30, 27, 24, 21, 18, 15,
-                                  12, 9, 6, 3, 0);
-  __m512i b01r1 = _mm512_permutex2var_epi32(bgr0, mask0, bgr1);
-  __m512i g12b2 = _mm512_permutex2var_epi32(bgr1, mask0, bgr2);
-  __m512i r20g0 = _mm512_permutex2var_epi32(bgr2, mask0, bgr0);
-
-  a = v_uint32x16(_mm512_mask_blend_epi32(0xf800, b01r1, g12b2));
-  b = v_uint32x16(_mm512_alignr_epi32(g12b2, r20g0, 11));
-  c = v_uint32x16(
-      _mm512_permutex2var_epi32(bgr1,
-                                _v512_set_epu32(21, 20, 19, 18, 17, 16, 13, 10,
-                                                7, 4, 1, 26, 25, 24, 23, 22),
-                                r20g0));
-}
-
-inline void v_load_deinterleave(const uint64 *ptr, v_uint64x8 &a, v_uint64x8 &b,
-                                v_uint64x8 &c) {
-  __m512i bgr0 = _mm512_loadu_si512((const __m512i *)ptr);
-  __m512i bgr1 = _mm512_loadu_si512((const __m512i *)(ptr + 8));
-  __m512i bgr2 = _mm512_loadu_si512((const __m512i *)(ptr + 16));
-
-  __m512i mask0 = _v512_set_epu64(13, 10, 15, 12, 9, 6, 3, 0);
-  __m512i b01g1 = _mm512_permutex2var_epi64(bgr0, mask0, bgr1);
-  __m512i r12b2 = _mm512_permutex2var_epi64(bgr1, mask0, bgr2);
-  __m512i g20r0 = _mm512_permutex2var_epi64(bgr2, mask0, bgr0);
-
-  a = v_uint64x8(_mm512_mask_blend_epi64(0xc0, b01g1, r12b2));
-  c = v_uint64x8(_mm512_alignr_epi64(r12b2, g20r0, 6));
-  b = v_uint64x8(_mm512_permutex2var_epi64(
-      bgr1, _v512_set_epu64(10, 9, 8, 5, 2, 13, 12, 11), g20r0));
-}
-
-inline void v_load_deinterleave(const uchar *ptr, v_uint8x64 &a, v_uint8x64 &b,
-                                v_uint8x64 &c, v_uint8x64 &d) {
-  __m512i bgra0 = _mm512_loadu_si512((const __m512i *)ptr);
-  __m512i bgra1 = _mm512_loadu_si512((const __m512i *)(ptr + 64));
-  __m512i bgra2 = _mm512_loadu_si512((const __m512i *)(ptr + 128));
-  __m512i bgra3 = _mm512_loadu_si512((const __m512i *)(ptr + 192));
-
-#if CV_AVX_512VBMI
-  __m512i mask0 = _v512_set_epu8(
-      126, 124, 122, 120, 118, 116, 114, 112, 110, 108, 106, 104, 102, 100, 98,
-      96, 94, 92, 90, 88, 86, 84, 82, 80, 78, 76, 74, 72, 70, 68, 66, 64, 62,
-      60, 58, 56, 54, 52, 50, 48, 46, 44, 42, 40, 38, 36, 34, 32, 30, 28, 26,
-      24, 22, 20, 18, 16, 14, 12, 10, 8, 6, 4, 2, 0);
-  __m512i mask1 = _v512_set_epu8(
-      127, 125, 123, 121, 119, 117, 115, 113, 111, 109, 107, 105, 103, 101, 99,
-      97, 95, 93, 91, 89, 87, 85, 83, 81, 79, 77, 75, 73, 71, 69, 67, 65, 63,
-      61, 59, 57, 55, 53, 51, 49, 47, 45, 43, 41, 39, 37, 35, 33, 31, 29, 27,
-      25, 23, 21, 19, 17, 15, 13, 11, 9, 7, 5, 3, 1);
-
-  __m512i br01 = _mm512_permutex2var_epi8(bgra0, mask0, bgra1);
-  __m512i ga01 = _mm512_permutex2var_epi8(bgra0, mask1, bgra1);
-  __m512i br23 = _mm512_permutex2var_epi8(bgra2, mask0, bgra3);
-  __m512i ga23 = _mm512_permutex2var_epi8(bgra2, mask1, bgra3);
-
-  a = v_uint8x64(_mm512_permutex2var_epi8(br01, mask0, br23));
-  c = v_uint8x64(_mm512_permutex2var_epi8(br01, mask1, br23));
-  b = v_uint8x64(_mm512_permutex2var_epi8(ga01, mask0, ga23));
-  d = v_uint8x64(_mm512_permutex2var_epi8(ga01, mask1, ga23));
-#else
-  __m512i mask =
-      _mm512_set4_epi32(0x0f0b0703, 0x0e0a0602, 0x0d090501, 0x0c080400);
-  __m512i b0g0r0a0 = _mm512_shuffle_epi8(bgra0, mask);
-  __m512i b1g1r1a1 = _mm512_shuffle_epi8(bgra1, mask);
-  __m512i b2g2r2a2 = _mm512_shuffle_epi8(bgra2, mask);
-  __m512i b3g3r3a3 = _mm512_shuffle_epi8(bgra3, mask);
-
-  __m512i mask0 = _v512_set_epu32(30, 28, 26, 24, 22, 20, 18, 16, 14, 12, 10, 8,
-                                  6, 4, 2, 0);
-  __m512i mask1 = _v512_set_epu32(31, 29, 27, 25, 23, 21, 19, 17, 15, 13, 11, 9,
-                                  7, 5, 3, 1);
-
-  __m512i br01 = _mm512_permutex2var_epi32(b0g0r0a0, mask0, b1g1r1a1);
-  __m512i ga01 = _mm512_permutex2var_epi32(b0g0r0a0, mask1, b1g1r1a1);
-  __m512i br23 = _mm512_permutex2var_epi32(b2g2r2a2, mask0, b3g3r3a3);
-  __m512i ga23 = _mm512_permutex2var_epi32(b2g2r2a2, mask1, b3g3r3a3);
-
-  a = v_uint8x64(_mm512_permutex2var_epi32(br01, mask0, br23));
-  c = v_uint8x64(_mm512_permutex2var_epi32(br01, mask1, br23));
-  b = v_uint8x64(_mm512_permutex2var_epi32(ga01, mask0, ga23));
-  d = v_uint8x64(_mm512_permutex2var_epi32(ga01, mask1, ga23));
-#endif
-}
-
-inline void v_load_deinterleave(const ushort *ptr, v_uint16x32 &a,
-                                v_uint16x32 &b, v_uint16x32 &c,
-                                v_uint16x32 &d) {
-  __m512i bgra0 = _mm512_loadu_si512((const __m512i *)ptr);
-  __m512i bgra1 = _mm512_loadu_si512((const __m512i *)(ptr + 32));
-  __m512i bgra2 = _mm512_loadu_si512((const __m512i *)(ptr + 64));
-  __m512i bgra3 = _mm512_loadu_si512((const __m512i *)(ptr + 96));
-
-  __m512i mask0 = _v512_set_epu16(62, 60, 58, 56, 54, 52, 50, 48, 46, 44, 42,
-                                  40, 38, 36, 34, 32, 30, 28, 26, 24, 22, 20,
-                                  18, 16, 14, 12, 10, 8, 6, 4, 2, 0);
-  __m512i mask1 = _v512_set_epu16(63, 61, 59, 57, 55, 53, 51, 49, 47, 45, 43,
-                                  41, 39, 37, 35, 33, 31, 29, 27, 25, 23, 21,
-                                  19, 17, 15, 13, 11, 9, 7, 5, 3, 1);
-
-  __m512i br01 = _mm512_permutex2var_epi16(bgra0, mask0, bgra1);
-  __m512i ga01 = _mm512_permutex2var_epi16(bgra0, mask1, bgra1);
-  __m512i br23 = _mm512_permutex2var_epi16(bgra2, mask0, bgra3);
-  __m512i ga23 = _mm512_permutex2var_epi16(bgra2, mask1, bgra3);
-
-  a = v_uint16x32(_mm512_permutex2var_epi16(br01, mask0, br23));
-  c = v_uint16x32(_mm512_permutex2var_epi16(br01, mask1, br23));
-  b = v_uint16x32(_mm512_permutex2var_epi16(ga01, mask0, ga23));
-  d = v_uint16x32(_mm512_permutex2var_epi16(ga01, mask1, ga23));
-}
-
-inline void v_load_deinterleave(const unsigned *ptr, v_uint32x16 &a,
-                                v_uint32x16 &b, v_uint32x16 &c,
-                                v_uint32x16 &d) {
-  __m512i bgra0 = _mm512_loadu_si512((const __m512i *)ptr);
-  __m512i bgra1 = _mm512_loadu_si512((const __m512i *)(ptr + 16));
-  __m512i bgra2 = _mm512_loadu_si512((const __m512i *)(ptr + 32));
-  __m512i bgra3 = _mm512_loadu_si512((const __m512i *)(ptr + 48));
-
-  __m512i mask0 = _v512_set_epu32(30, 28, 26, 24, 22, 20, 18, 16, 14, 12, 10, 8,
-                                  6, 4, 2, 0);
-  __m512i mask1 = _v512_set_epu32(31, 29, 27, 25, 23, 21, 19, 17, 15, 13, 11, 9,
-                                  7, 5, 3, 1);
-
-  __m512i br01 = _mm512_permutex2var_epi32(bgra0, mask0, bgra1);
-  __m512i ga01 = _mm512_permutex2var_epi32(bgra0, mask1, bgra1);
-  __m512i br23 = _mm512_permutex2var_epi32(bgra2, mask0, bgra3);
-  __m512i ga23 = _mm512_permutex2var_epi32(bgra2, mask1, bgra3);
-
-  a = v_uint32x16(_mm512_permutex2var_epi32(br01, mask0, br23));
-  c = v_uint32x16(_mm512_permutex2var_epi32(br01, mask1, br23));
-  b = v_uint32x16(_mm512_permutex2var_epi32(ga01, mask0, ga23));
-  d = v_uint32x16(_mm512_permutex2var_epi32(ga01, mask1, ga23));
-}
-
-inline void v_load_deinterleave(const uint64 *ptr, v_uint64x8 &a, v_uint64x8 &b,
-                                v_uint64x8 &c, v_uint64x8 &d) {
-  __m512i bgra0 = _mm512_loadu_si512((const __m512i *)ptr);
-  __m512i bgra1 = _mm512_loadu_si512((const __m512i *)(ptr + 8));
-  __m512i bgra2 = _mm512_loadu_si512((const __m512i *)(ptr + 16));
-  __m512i bgra3 = _mm512_loadu_si512((const __m512i *)(ptr + 24));
-
-  __m512i mask0 = _v512_set_epu64(14, 12, 10, 8, 6, 4, 2, 0);
-  __m512i mask1 = _v512_set_epu64(15, 13, 11, 9, 7, 5, 3, 1);
-
-  __m512i br01 = _mm512_permutex2var_epi64(bgra0, mask0, bgra1);
-  __m512i ga01 = _mm512_permutex2var_epi64(bgra0, mask1, bgra1);
-  __m512i br23 = _mm512_permutex2var_epi64(bgra2, mask0, bgra3);
-  __m512i ga23 = _mm512_permutex2var_epi64(bgra2, mask1, bgra3);
-
-  a = v_uint64x8(_mm512_permutex2var_epi64(br01, mask0, br23));
-  c = v_uint64x8(_mm512_permutex2var_epi64(br01, mask1, br23));
-  b = v_uint64x8(_mm512_permutex2var_epi64(ga01, mask0, ga23));
-  d = v_uint64x8(_mm512_permutex2var_epi64(ga01, mask1, ga23));
-}
-
-///////////////////////////// store interleave
-////////////////////////////////////////
-
-inline void v_store_interleave(uchar *ptr, const v_uint8x64 &x,
-                               const v_uint8x64 &y,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  v_uint8x64 low, high;
-  v_zip(x, y, low, high);
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm512_stream_si512((__m512i *)ptr, low.val);
-    _mm512_stream_si512((__m512i *)(ptr + 64), high.val);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm512_store_si512((__m512i *)ptr, low.val);
-    _mm512_store_si512((__m512i *)(ptr + 64), high.val);
-  } else {
-    _mm512_storeu_si512((__m512i *)ptr, low.val);
-    _mm512_storeu_si512((__m512i *)(ptr + 64), high.val);
-  }
-}
-
-inline void v_store_interleave(ushort *ptr, const v_uint16x32 &x,
-                               const v_uint16x32 &y,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  v_uint16x32 low, high;
-  v_zip(x, y, low, high);
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm512_stream_si512((__m512i *)ptr, low.val);
-    _mm512_stream_si512((__m512i *)(ptr + 32), high.val);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm512_store_si512((__m512i *)ptr, low.val);
-    _mm512_store_si512((__m512i *)(ptr + 32), high.val);
-  } else {
-    _mm512_storeu_si512((__m512i *)ptr, low.val);
-    _mm512_storeu_si512((__m512i *)(ptr + 32), high.val);
-  }
-}
-
-inline void v_store_interleave(unsigned *ptr, const v_uint32x16 &x,
-                               const v_uint32x16 &y,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  v_uint32x16 low, high;
-  v_zip(x, y, low, high);
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm512_stream_si512((__m512i *)ptr, low.val);
-    _mm512_stream_si512((__m512i *)(ptr + 16), high.val);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm512_store_si512((__m512i *)ptr, low.val);
-    _mm512_store_si512((__m512i *)(ptr + 16), high.val);
-  } else {
-    _mm512_storeu_si512((__m512i *)ptr, low.val);
-    _mm512_storeu_si512((__m512i *)(ptr + 16), high.val);
-  }
-}
-
-inline void v_store_interleave(uint64 *ptr, const v_uint64x8 &x,
-                               const v_uint64x8 &y,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  v_uint64x8 low, high;
-  v_zip(x, y, low, high);
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm512_stream_si512((__m512i *)ptr, low.val);
-    _mm512_stream_si512((__m512i *)(ptr + 8), high.val);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm512_store_si512((__m512i *)ptr, low.val);
-    _mm512_store_si512((__m512i *)(ptr + 8), high.val);
-  } else {
-    _mm512_storeu_si512((__m512i *)ptr, low.val);
-    _mm512_storeu_si512((__m512i *)(ptr + 8), high.val);
-  }
-}
-
-inline void v_store_interleave(uchar *ptr, const v_uint8x64 &a,
-                               const v_uint8x64 &b, const v_uint8x64 &c,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-#if CV_AVX_512VBMI
-  __m512i mask0 = _v512_set_epu8(
-      127, 84, 20, 126, 83, 19, 125, 82, 18, 124, 81, 17, 123, 80, 16, 122, 79,
-      15, 121, 78, 14, 120, 77, 13, 119, 76, 12, 118, 75, 11, 117, 74, 10, 116,
-      73, 9, 115, 72, 8, 114, 71, 7, 113, 70, 6, 112, 69, 5, 111, 68, 4, 110,
-      67, 3, 109, 66, 2, 108, 65, 1, 107, 64, 0, 106);
-  __m512i mask1 = _v512_set_epu8(
-      21, 42, 105, 20, 41, 104, 19, 40, 103, 18, 39, 102, 17, 38, 101, 16, 37,
-      100, 15, 36, 99, 14, 35, 98, 13, 34, 97, 12, 33, 96, 11, 32, 95, 10, 31,
-      94, 9, 30, 93, 8, 29, 92, 7, 28, 91, 6, 27, 90, 5, 26, 89, 4, 25, 88, 3,
-      24, 87, 2, 23, 86, 1, 22, 85, 0);
-  __m512i mask2 = _v512_set_epu8(
-      106, 127, 63, 105, 126, 62, 104, 125, 61, 103, 124, 60, 102, 123, 59, 101,
-      122, 58, 100, 121, 57, 99, 120, 56, 98, 119, 55, 97, 118, 54, 96, 117, 53,
-      95, 116, 52, 94, 115, 51, 93, 114, 50, 92, 113, 49, 91, 112, 48, 90, 111,
-      47, 89, 110, 46, 88, 109, 45, 87, 108, 44, 86, 107, 43, 85);
-  __m512i r2g0r0 = _mm512_permutex2var_epi8(b.val, mask0, c.val);
-  __m512i b0r1b1 = _mm512_permutex2var_epi8(a.val, mask1, c.val);
-  __m512i g1b2g2 = _mm512_permutex2var_epi8(a.val, mask2, b.val);
-
-  __m512i bgr0 = _mm512_mask_blend_epi8(0x9249249249249249, r2g0r0, b0r1b1);
-  __m512i bgr1 = _mm512_mask_blend_epi8(0x9249249249249249, b0r1b1, g1b2g2);
-  __m512i bgr2 = _mm512_mask_blend_epi8(0x9249249249249249, g1b2g2, r2g0r0);
-#else
-  __m512i g1g0 = _mm512_shuffle_epi8(
-      b.val, _mm512_set4_epi32(0x0e0f0c0d, 0x0a0b0809, 0x06070405, 0x02030001));
-  __m512i b0g0 = _mm512_mask_blend_epi8(0xAAAAAAAAAAAAAAAA, a.val, g1g0);
-  __m512i r0b1 = _mm512_mask_blend_epi8(0xAAAAAAAAAAAAAAAA, c.val, a.val);
-  __m512i g1r1 = _mm512_mask_blend_epi8(0xAAAAAAAAAAAAAAAA, g1g0, c.val);
-
-  __m512i mask0 = _v512_set_epu16(42, 10, 31, 41, 9, 30, 40, 8, 29, 39, 7, 28,
-                                  38, 6, 27, 37, 5, 26, 36, 4, 25, 35, 3, 24,
-                                  34, 2, 23, 33, 1, 22, 32, 0);
-  __m512i mask1 = _v512_set_epu16(21, 52, 41, 20, 51, 40, 19, 50, 39, 18, 49,
-                                  38, 17, 48, 37, 16, 47, 36, 15, 46, 35, 14,
-                                  45, 34, 13, 44, 33, 12, 43, 32, 11, 42);
-  __m512i mask2 = _v512_set_epu16(63, 31, 20, 62, 30, 19, 61, 29, 18, 60, 28,
-                                  17, 59, 27, 16, 58, 26, 15, 57, 25, 14, 56,
-                                  24, 13, 55, 23, 12, 54, 22, 11, 53, 21);
-  __m512i b0g0b2 = _mm512_permutex2var_epi16(b0g0, mask0, r0b1);
-  __m512i r1b1r0 = _mm512_permutex2var_epi16(b0g0, mask1, g1r1);
-  __m512i g2r2g1 = _mm512_permutex2var_epi16(r0b1, mask2, g1r1);
-
-  __m512i bgr0 = _mm512_mask_blend_epi16(0x24924924, b0g0b2, r1b1r0);
-  __m512i bgr1 = _mm512_mask_blend_epi16(0x24924924, r1b1r0, g2r2g1);
-  __m512i bgr2 = _mm512_mask_blend_epi16(0x24924924, g2r2g1, b0g0b2);
-#endif
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm512_stream_si512((__m512i *)ptr, bgr0);
-    _mm512_stream_si512((__m512i *)(ptr + 64), bgr1);
-    _mm512_stream_si512((__m512i *)(ptr + 128), bgr2);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm512_store_si512((__m512i *)ptr, bgr0);
-    _mm512_store_si512((__m512i *)(ptr + 64), bgr1);
-    _mm512_store_si512((__m512i *)(ptr + 128), bgr2);
-  } else {
-    _mm512_storeu_si512((__m512i *)ptr, bgr0);
-    _mm512_storeu_si512((__m512i *)(ptr + 64), bgr1);
-    _mm512_storeu_si512((__m512i *)(ptr + 128), bgr2);
-  }
-}
-
-inline void v_store_interleave(ushort *ptr, const v_uint16x32 &a,
-                               const v_uint16x32 &b, const v_uint16x32 &c,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  __m512i mask0 = _v512_set_epu16(42, 10, 31, 41, 9, 30, 40, 8, 29, 39, 7, 28,
-                                  38, 6, 27, 37, 5, 26, 36, 4, 25, 35, 3, 24,
-                                  34, 2, 23, 33, 1, 22, 32, 0);
-  __m512i mask1 = _v512_set_epu16(21, 52, 41, 20, 51, 40, 19, 50, 39, 18, 49,
-                                  38, 17, 48, 37, 16, 47, 36, 15, 46, 35, 14,
-                                  45, 34, 13, 44, 33, 12, 43, 32, 11, 42);
-  __m512i mask2 = _v512_set_epu16(63, 31, 20, 62, 30, 19, 61, 29, 18, 60, 28,
-                                  17, 59, 27, 16, 58, 26, 15, 57, 25, 14, 56,
-                                  24, 13, 55, 23, 12, 54, 22, 11, 53, 21);
-  __m512i b0g0b2 = _mm512_permutex2var_epi16(a.val, mask0, b.val);
-  __m512i r1b1r0 = _mm512_permutex2var_epi16(a.val, mask1, c.val);
-  __m512i g2r2g1 = _mm512_permutex2var_epi16(b.val, mask2, c.val);
-
-  __m512i bgr0 = _mm512_mask_blend_epi16(0x24924924, b0g0b2, r1b1r0);
-  __m512i bgr1 = _mm512_mask_blend_epi16(0x24924924, r1b1r0, g2r2g1);
-  __m512i bgr2 = _mm512_mask_blend_epi16(0x24924924, g2r2g1, b0g0b2);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm512_stream_si512((__m512i *)ptr, bgr0);
-    _mm512_stream_si512((__m512i *)(ptr + 32), bgr1);
-    _mm512_stream_si512((__m512i *)(ptr + 64), bgr2);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm512_store_si512((__m512i *)ptr, bgr0);
-    _mm512_store_si512((__m512i *)(ptr + 32), bgr1);
-    _mm512_store_si512((__m512i *)(ptr + 64), bgr2);
-  } else {
-    _mm512_storeu_si512((__m512i *)ptr, bgr0);
-    _mm512_storeu_si512((__m512i *)(ptr + 32), bgr1);
-    _mm512_storeu_si512((__m512i *)(ptr + 64), bgr2);
-  }
-}
-
-inline void v_store_interleave(unsigned *ptr, const v_uint32x16 &a,
-                               const v_uint32x16 &b, const v_uint32x16 &c,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  __m512i mask0 = _v512_set_epu32(26, 31, 15, 25, 30, 14, 24, 29, 13, 23, 28,
-                                  12, 22, 27, 11, 21);
-  __m512i mask1 = _v512_set_epu32(31, 10, 25, 30, 9, 24, 29, 8, 23, 28, 7, 22,
-                                  27, 6, 21, 26);
-  __m512i g1b2g2 = _mm512_permutex2var_epi32(a.val, mask0, b.val);
-  __m512i r2r1b1 = _mm512_permutex2var_epi32(a.val, mask1, c.val);
-
-  __m512i bgr0 = _mm512_mask_expand_epi32(
-      _mm512_mask_expand_epi32(_mm512_maskz_expand_epi32(0x9249, a.val), 0x2492,
-                               b.val),
-      0x4924, c.val);
-  __m512i bgr1 = _mm512_mask_blend_epi32(0x9249, r2r1b1, g1b2g2);
-  __m512i bgr2 = _mm512_mask_blend_epi32(0x9249, g1b2g2, r2r1b1);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm512_stream_si512((__m512i *)ptr, bgr0);
-    _mm512_stream_si512((__m512i *)(ptr + 16), bgr1);
-    _mm512_stream_si512((__m512i *)(ptr + 32), bgr2);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm512_store_si512((__m512i *)ptr, bgr0);
-    _mm512_store_si512((__m512i *)(ptr + 16), bgr1);
-    _mm512_store_si512((__m512i *)(ptr + 32), bgr2);
-  } else {
-    _mm512_storeu_si512((__m512i *)ptr, bgr0);
-    _mm512_storeu_si512((__m512i *)(ptr + 16), bgr1);
-    _mm512_storeu_si512((__m512i *)(ptr + 32), bgr2);
-  }
-}
-
-inline void v_store_interleave(uint64 *ptr, const v_uint64x8 &a,
-                               const v_uint64x8 &b, const v_uint64x8 &c,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  __m512i mask0 = _v512_set_epu64(5, 12, 7, 4, 11, 6, 3, 10);
-  __m512i mask1 = _v512_set_epu64(15, 7, 4, 14, 6, 3, 13, 5);
-  __m512i r1b1b2 = _mm512_permutex2var_epi64(a.val, mask0, c.val);
-  __m512i g2r2g1 = _mm512_permutex2var_epi64(b.val, mask1, c.val);
-
-  __m512i bgr0 = _mm512_mask_expand_epi64(
-      _mm512_mask_expand_epi64(_mm512_maskz_expand_epi64(0x49, a.val), 0x92,
-                               b.val),
-      0x24, c.val);
-  __m512i bgr1 = _mm512_mask_blend_epi64(0xdb, g2r2g1, r1b1b2);
-  __m512i bgr2 = _mm512_mask_blend_epi64(0xdb, r1b1b2, g2r2g1);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm512_stream_si512((__m512i *)ptr, bgr0);
-    _mm512_stream_si512((__m512i *)(ptr + 8), bgr1);
-    _mm512_stream_si512((__m512i *)(ptr + 16), bgr2);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm512_store_si512((__m512i *)ptr, bgr0);
-    _mm512_store_si512((__m512i *)(ptr + 8), bgr1);
-    _mm512_store_si512((__m512i *)(ptr + 16), bgr2);
-  } else {
-    _mm512_storeu_si512((__m512i *)ptr, bgr0);
-    _mm512_storeu_si512((__m512i *)(ptr + 8), bgr1);
-    _mm512_storeu_si512((__m512i *)(ptr + 16), bgr2);
-  }
-}
-
-inline void v_store_interleave(uchar *ptr, const v_uint8x64 &a,
-                               const v_uint8x64 &b, const v_uint8x64 &c,
-                               const v_uint8x64 &d,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  v_uint8x64 br01, br23, ga01, ga23;
-  v_zip(a, c, br01, br23);
-  v_zip(b, d, ga01, ga23);
-  v_uint8x64 bgra0, bgra1, bgra2, bgra3;
-  v_zip(br01, ga01, bgra0, bgra1);
-  v_zip(br23, ga23, bgra2, bgra3);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm512_stream_si512((__m512i *)ptr, bgra0.val);
-    _mm512_stream_si512((__m512i *)(ptr + 64), bgra1.val);
-    _mm512_stream_si512((__m512i *)(ptr + 128), bgra2.val);
-    _mm512_stream_si512((__m512i *)(ptr + 192), bgra3.val);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm512_store_si512((__m512i *)ptr, bgra0.val);
-    _mm512_store_si512((__m512i *)(ptr + 64), bgra1.val);
-    _mm512_store_si512((__m512i *)(ptr + 128), bgra2.val);
-    _mm512_store_si512((__m512i *)(ptr + 192), bgra3.val);
-  } else {
-    _mm512_storeu_si512((__m512i *)ptr, bgra0.val);
-    _mm512_storeu_si512((__m512i *)(ptr + 64), bgra1.val);
-    _mm512_storeu_si512((__m512i *)(ptr + 128), bgra2.val);
-    _mm512_storeu_si512((__m512i *)(ptr + 192), bgra3.val);
-  }
-}
-
-inline void v_store_interleave(ushort *ptr, const v_uint16x32 &a,
-                               const v_uint16x32 &b, const v_uint16x32 &c,
-                               const v_uint16x32 &d,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  v_uint16x32 br01, br23, ga01, ga23;
-  v_zip(a, c, br01, br23);
-  v_zip(b, d, ga01, ga23);
-  v_uint16x32 bgra0, bgra1, bgra2, bgra3;
-  v_zip(br01, ga01, bgra0, bgra1);
-  v_zip(br23, ga23, bgra2, bgra3);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm512_stream_si512((__m512i *)ptr, bgra0.val);
-    _mm512_stream_si512((__m512i *)(ptr + 32), bgra1.val);
-    _mm512_stream_si512((__m512i *)(ptr + 64), bgra2.val);
-    _mm512_stream_si512((__m512i *)(ptr + 96), bgra3.val);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm512_store_si512((__m512i *)ptr, bgra0.val);
-    _mm512_store_si512((__m512i *)(ptr + 32), bgra1.val);
-    _mm512_store_si512((__m512i *)(ptr + 64), bgra2.val);
-    _mm512_store_si512((__m512i *)(ptr + 96), bgra3.val);
-  } else {
-    _mm512_storeu_si512((__m512i *)ptr, bgra0.val);
-    _mm512_storeu_si512((__m512i *)(ptr + 32), bgra1.val);
-    _mm512_storeu_si512((__m512i *)(ptr + 64), bgra2.val);
-    _mm512_storeu_si512((__m512i *)(ptr + 96), bgra3.val);
-  }
-}
-
-inline void v_store_interleave(unsigned *ptr, const v_uint32x16 &a,
-                               const v_uint32x16 &b, const v_uint32x16 &c,
-                               const v_uint32x16 &d,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  v_uint32x16 br01, br23, ga01, ga23;
-  v_zip(a, c, br01, br23);
-  v_zip(b, d, ga01, ga23);
-  v_uint32x16 bgra0, bgra1, bgra2, bgra3;
-  v_zip(br01, ga01, bgra0, bgra1);
-  v_zip(br23, ga23, bgra2, bgra3);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm512_stream_si512((__m512i *)ptr, bgra0.val);
-    _mm512_stream_si512((__m512i *)(ptr + 16), bgra1.val);
-    _mm512_stream_si512((__m512i *)(ptr + 32), bgra2.val);
-    _mm512_stream_si512((__m512i *)(ptr + 48), bgra3.val);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm512_store_si512((__m512i *)ptr, bgra0.val);
-    _mm512_store_si512((__m512i *)(ptr + 16), bgra1.val);
-    _mm512_store_si512((__m512i *)(ptr + 32), bgra2.val);
-    _mm512_store_si512((__m512i *)(ptr + 48), bgra3.val);
-  } else {
-    _mm512_storeu_si512((__m512i *)ptr, bgra0.val);
-    _mm512_storeu_si512((__m512i *)(ptr + 16), bgra1.val);
-    _mm512_storeu_si512((__m512i *)(ptr + 32), bgra2.val);
-    _mm512_storeu_si512((__m512i *)(ptr + 48), bgra3.val);
-  }
-}
-
-inline void v_store_interleave(uint64 *ptr, const v_uint64x8 &a,
-                               const v_uint64x8 &b, const v_uint64x8 &c,
-                               const v_uint64x8 &d,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  v_uint64x8 br01, br23, ga01, ga23;
-  v_zip(a, c, br01, br23);
-  v_zip(b, d, ga01, ga23);
-  v_uint64x8 bgra0, bgra1, bgra2, bgra3;
-  v_zip(br01, ga01, bgra0, bgra1);
-  v_zip(br23, ga23, bgra2, bgra3);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm512_stream_si512((__m512i *)ptr, bgra0.val);
-    _mm512_stream_si512((__m512i *)(ptr + 8), bgra1.val);
-    _mm512_stream_si512((__m512i *)(ptr + 16), bgra2.val);
-    _mm512_stream_si512((__m512i *)(ptr + 24), bgra3.val);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm512_store_si512((__m512i *)ptr, bgra0.val);
-    _mm512_store_si512((__m512i *)(ptr + 8), bgra1.val);
-    _mm512_store_si512((__m512i *)(ptr + 16), bgra2.val);
-    _mm512_store_si512((__m512i *)(ptr + 24), bgra3.val);
-  } else {
-    _mm512_storeu_si512((__m512i *)ptr, bgra0.val);
-    _mm512_storeu_si512((__m512i *)(ptr + 8), bgra1.val);
-    _mm512_storeu_si512((__m512i *)(ptr + 16), bgra2.val);
-    _mm512_storeu_si512((__m512i *)(ptr + 24), bgra3.val);
-  }
-}
-
-#define OPENCV_HAL_IMPL_AVX512_LOADSTORE_INTERLEAVE(_Tpvec0, _Tp0, suffix0,    \
-                                                    _Tpvec1, _Tp1, suffix1)    \
-  inline void v_load_deinterleave(const _Tp0 *ptr, _Tpvec0 &a0, _Tpvec0 &b0) { \
-    _Tpvec1 a1, b1;                                                            \
-    v_load_deinterleave((const _Tp1 *)ptr, a1, b1);                            \
-    a0 = v_reinterpret_as_##suffix0(a1);                                       \
-    b0 = v_reinterpret_as_##suffix0(b1);                                       \
-  }                                                                            \
-  inline void v_load_deinterleave(const _Tp0 *ptr, _Tpvec0 &a0, _Tpvec0 &b0,   \
-                                  _Tpvec0 &c0) {                               \
-    _Tpvec1 a1, b1, c1;                                                        \
-    v_load_deinterleave((const _Tp1 *)ptr, a1, b1, c1);                        \
-    a0 = v_reinterpret_as_##suffix0(a1);                                       \
-    b0 = v_reinterpret_as_##suffix0(b1);                                       \
-    c0 = v_reinterpret_as_##suffix0(c1);                                       \
-  }                                                                            \
-  inline void v_load_deinterleave(const _Tp0 *ptr, _Tpvec0 &a0, _Tpvec0 &b0,   \
-                                  _Tpvec0 &c0, _Tpvec0 &d0) {                  \
-    _Tpvec1 a1, b1, c1, d1;                                                    \
-    v_load_deinterleave((const _Tp1 *)ptr, a1, b1, c1, d1);                    \
-    a0 = v_reinterpret_as_##suffix0(a1);                                       \
-    b0 = v_reinterpret_as_##suffix0(b1);                                       \
-    c0 = v_reinterpret_as_##suffix0(c1);                                       \
-    d0 = v_reinterpret_as_##suffix0(d1);                                       \
-  }                                                                            \
-  inline void v_store_interleave(_Tp0 *ptr, const _Tpvec0 &a0,                 \
-                                 const _Tpvec0 &b0,                            \
-                                 hal::StoreMode mode = hal::STORE_UNALIGNED) { \
-    _Tpvec1 a1 = v_reinterpret_as_##suffix1(a0);                               \
-    _Tpvec1 b1 = v_reinterpret_as_##suffix1(b0);                               \
-    v_store_interleave((_Tp1 *)ptr, a1, b1, mode);                             \
-  }                                                                            \
-  inline void v_store_interleave(_Tp0 *ptr, const _Tpvec0 &a0,                 \
-                                 const _Tpvec0 &b0, const _Tpvec0 &c0,         \
-                                 hal::StoreMode mode = hal::STORE_UNALIGNED) { \
-    _Tpvec1 a1 = v_reinterpret_as_##suffix1(a0);                               \
-    _Tpvec1 b1 = v_reinterpret_as_##suffix1(b0);                               \
-    _Tpvec1 c1 = v_reinterpret_as_##suffix1(c0);                               \
-    v_store_interleave((_Tp1 *)ptr, a1, b1, c1, mode);                         \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp0 *ptr, const _Tpvec0 &a0, const _Tpvec0 &b0, const _Tpvec0 &c0,      \
-      const _Tpvec0 &d0, hal::StoreMode mode = hal::STORE_UNALIGNED) {         \
-    _Tpvec1 a1 = v_reinterpret_as_##suffix1(a0);                               \
-    _Tpvec1 b1 = v_reinterpret_as_##suffix1(b0);                               \
-    _Tpvec1 c1 = v_reinterpret_as_##suffix1(c0);                               \
-    _Tpvec1 d1 = v_reinterpret_as_##suffix1(d0);                               \
-    v_store_interleave((_Tp1 *)ptr, a1, b1, c1, d1, mode);                     \
-  }
-
-OPENCV_HAL_IMPL_AVX512_LOADSTORE_INTERLEAVE(v_int8x64, schar, s8, v_uint8x64,
-                                            uchar, u8)
-OPENCV_HAL_IMPL_AVX512_LOADSTORE_INTERLEAVE(v_int16x32, short, s16, v_uint16x32,
-                                            ushort, u16)
-OPENCV_HAL_IMPL_AVX512_LOADSTORE_INTERLEAVE(v_int32x16, int, s32, v_uint32x16,
-                                            unsigned, u32)
-OPENCV_HAL_IMPL_AVX512_LOADSTORE_INTERLEAVE(v_float32x16, float, f32,
-                                            v_uint32x16, unsigned, u32)
-OPENCV_HAL_IMPL_AVX512_LOADSTORE_INTERLEAVE(v_int64x8, int64, s64, v_uint64x8,
-                                            uint64, u64)
-OPENCV_HAL_IMPL_AVX512_LOADSTORE_INTERLEAVE(v_float64x8, double, f64,
-                                            v_uint64x8, uint64, u64)
-
-////////// Mask and checks /////////
-
-/** Mask **/
-inline int64 v_signmask(const v_int8x64 &a) {
-  return (int64)_mm512_movepi8_mask(a.val);
-}
-inline int v_signmask(const v_int16x32 &a) {
-  return (int)_mm512_cmp_epi16_mask(a.val, _mm512_setzero_si512(),
-                                    _MM_CMPINT_LT);
-}
-inline int v_signmask(const v_int32x16 &a) {
-  return (int)_mm512_cmp_epi32_mask(a.val, _mm512_setzero_si512(),
-                                    _MM_CMPINT_LT);
-}
-inline int v_signmask(const v_int64x8 &a) {
-  return (int)_mm512_cmp_epi64_mask(a.val, _mm512_setzero_si512(),
-                                    _MM_CMPINT_LT);
-}
-
-inline int64 v_signmask(const v_uint8x64 &a) {
-  return v_signmask(v_reinterpret_as_s8(a));
-}
-inline int v_signmask(const v_uint16x32 &a) {
-  return v_signmask(v_reinterpret_as_s16(a));
-}
-inline int v_signmask(const v_uint32x16 &a) {
-  return v_signmask(v_reinterpret_as_s32(a));
-}
-inline int v_signmask(const v_uint64x8 &a) {
-  return v_signmask(v_reinterpret_as_s64(a));
-}
-inline int v_signmask(const v_float32x16 &a) {
-  return v_signmask(v_reinterpret_as_s32(a));
-}
-inline int v_signmask(const v_float64x8 &a) {
-  return v_signmask(v_reinterpret_as_s64(a));
-}
-
-/** Checks **/
-inline bool v_check_all(const v_int8x64 &a) {
-  return !(bool)_mm512_cmp_epi8_mask(a.val, _mm512_setzero_si512(),
-                                     _MM_CMPINT_NLT);
-}
-inline bool v_check_any(const v_int8x64 &a) {
-  return (bool)_mm512_movepi8_mask(a.val);
-}
-inline bool v_check_all(const v_int16x32 &a) {
-  return !(bool)_mm512_cmp_epi16_mask(a.val, _mm512_setzero_si512(),
-                                      _MM_CMPINT_NLT);
-}
-inline bool v_check_any(const v_int16x32 &a) {
-  return (bool)_mm512_cmp_epi16_mask(a.val, _mm512_setzero_si512(),
-                                     _MM_CMPINT_LT);
-}
-inline bool v_check_all(const v_int32x16 &a) {
-  return !(bool)_mm512_cmp_epi32_mask(a.val, _mm512_setzero_si512(),
-                                      _MM_CMPINT_NLT);
-}
-inline bool v_check_any(const v_int32x16 &a) {
-  return (bool)_mm512_cmp_epi32_mask(a.val, _mm512_setzero_si512(),
-                                     _MM_CMPINT_LT);
-}
-inline bool v_check_all(const v_int64x8 &a) {
-  return !(bool)_mm512_cmp_epi64_mask(a.val, _mm512_setzero_si512(),
-                                      _MM_CMPINT_NLT);
-}
-inline bool v_check_any(const v_int64x8 &a) {
-  return (bool)_mm512_cmp_epi64_mask(a.val, _mm512_setzero_si512(),
-                                     _MM_CMPINT_LT);
-}
-
-inline bool v_check_all(const v_float32x16 &a) {
-  return v_check_all(v_reinterpret_as_s32(a));
-}
-inline bool v_check_any(const v_float32x16 &a) {
-  return v_check_any(v_reinterpret_as_s32(a));
-}
-inline bool v_check_all(const v_float64x8 &a) {
-  return v_check_all(v_reinterpret_as_s64(a));
-}
-inline bool v_check_any(const v_float64x8 &a) {
-  return v_check_any(v_reinterpret_as_s64(a));
-}
-inline bool v_check_all(const v_uint8x64 &a) {
-  return v_check_all(v_reinterpret_as_s8(a));
-}
-inline bool v_check_all(const v_uint16x32 &a) {
-  return v_check_all(v_reinterpret_as_s16(a));
-}
-inline bool v_check_all(const v_uint32x16 &a) {
-  return v_check_all(v_reinterpret_as_s32(a));
-}
-inline bool v_check_all(const v_uint64x8 &a) {
-  return v_check_all(v_reinterpret_as_s64(a));
-}
-inline bool v_check_any(const v_uint8x64 &a) {
-  return v_check_any(v_reinterpret_as_s8(a));
-}
-inline bool v_check_any(const v_uint16x32 &a) {
-  return v_check_any(v_reinterpret_as_s16(a));
-}
-inline bool v_check_any(const v_uint32x16 &a) {
-  return v_check_any(v_reinterpret_as_s32(a));
-}
-inline bool v_check_any(const v_uint64x8 &a) {
-  return v_check_any(v_reinterpret_as_s64(a));
-}
-
-inline int v_scan_forward(const v_int8x64 &a) {
-  int64 mask = _mm512_movepi8_mask(a.val);
-  int mask32 = (int)mask;
-  return mask != 0 ? mask32 != 0 ? trailingZeros32(mask32)
-                                 : 32 + trailingZeros32((int)(mask >> 32))
-                   : 0;
-}
-inline int v_scan_forward(const v_uint8x64 &a) {
-  return v_scan_forward(v_reinterpret_as_s8(a));
-}
-inline int v_scan_forward(const v_int16x32 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s16(a)));
-}
-inline int v_scan_forward(const v_uint16x32 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s16(a)));
-}
-inline int v_scan_forward(const v_int32x16 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s16(a))) / 2;
-}
-inline int v_scan_forward(const v_uint32x16 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s16(a))) / 2;
-}
-inline int v_scan_forward(const v_float32x16 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s16(a))) / 2;
-}
-inline int v_scan_forward(const v_int64x8 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s16(a))) / 4;
-}
-inline int v_scan_forward(const v_uint64x8 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s16(a))) / 4;
-}
-inline int v_scan_forward(const v_float64x8 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s16(a))) / 4;
-}
-
-inline void v512_cleanup() { _mm256_zeroall(); }
-
-#include "intrin_math.hpp"
-inline v_float32x16 v_exp(const v_float32x16 &x) {
-  return v_exp_default_32f<v_float32x16, v_int32x16>(x);
-}
-inline v_float32x16 v_log(const v_float32x16 &x) {
-  return v_log_default_32f<v_float32x16, v_int32x16>(x);
-}
-inline void v_sincos(const v_float32x16 &x, v_float32x16 &s, v_float32x16 &c) {
-  v_sincos_default_32f<v_float32x16, v_int32x16>(x, s, c);
-}
-inline v_float32x16 v_sin(const v_float32x16 &x) {
-  return v_sin_default_32f<v_float32x16, v_int32x16>(x);
-}
-inline v_float32x16 v_cos(const v_float32x16 &x) {
-  return v_cos_default_32f<v_float32x16, v_int32x16>(x);
-}
-inline v_float32x16 v_erf(const v_float32x16 &x) {
-  return v_erf_default_32f<v_float32x16, v_int32x16>(x);
-}
-
-inline v_float64x8 v_exp(const v_float64x8 &x) {
-  return v_exp_default_64f<v_float64x8, v_int64x8>(x);
-}
-inline v_float64x8 v_log(const v_float64x8 &x) {
-  return v_log_default_64f<v_float64x8, v_int64x8>(x);
-}
-inline void v_sincos(const v_float64x8 &x, v_float64x8 &s, v_float64x8 &c) {
-  v_sincos_default_64f<v_float64x8, v_int64x8>(x, s, c);
-}
-inline v_float64x8 v_sin(const v_float64x8 &x) {
-  return v_sin_default_64f<v_float64x8, v_int64x8>(x);
-}
-inline v_float64x8 v_cos(const v_float64x8 &x) {
-  return v_cos_default_64f<v_float64x8, v_int64x8>(x);
-}
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_END
-
-//! @endcond
-
-} // namespace cv
-
-#endif // OPENCV_HAL_INTRIN_AVX_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_cpp.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_cpp.hpp
deleted file mode 100644
index b0028b2e62..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_cpp.hpp
+++ /dev/null
@@ -1,3446 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Copyright (C) 2015, Itseez Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_HAL_INTRIN_CPP_HPP
-#define OPENCV_HAL_INTRIN_CPP_HPP
-
-#include "opencv2/core/saturate.hpp"
-#include "opencv2/core/utility.hpp"
-#include <algorithm>
-#include <cstring>
-#include <limits>
-
-//! @cond IGNORED
-#define CV_SIMD128_CPP 1
-#if defined(CV_FORCE_SIMD128_CPP)
-#define CV_SIMD128 1
-#define CV_SIMD128_64F 1
-#endif
-#if defined(CV_DOXYGEN)
-#define CV_SIMD128 1
-#define CV_SIMD128_64F 1
-#define CV_SIMD256 1
-#define CV_SIMD256_64F 1
-#define CV_SIMD512 1
-#define CV_SIMD512_64F 1
-#else
-#define CV_SIMD256                                                             \
-  0 // Explicitly disable SIMD256 and SIMD512 support for scalar intrinsic
-    // implementation
-#define CV_SIMD512 0 // to avoid warnings during compilation
-#endif
-//! @endcond
-
-namespace cv {
-
-#ifndef CV_DOXYGEN
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_BEGIN
-#endif
-
-/** @addtogroup core_hal_intrin
-
-"Universal intrinsics" is a types and functions set intended to simplify
-vectorization of code on different platforms. Currently a few different SIMD
-extensions on different architectures are supported. 128 bit registers of
-various types support is implemented for a wide range of architectures including
-x86(__SSE/SSE2/SSE4.2__), ARM(__NEON__), PowerPC(__VSX__), MIPS(__MSA__). 256
-bit long registers are supported on x86(__AVX2__) and 512 bit long registers are
-supported on x86(__AVX512__). In case when there is no SIMD extension available
-during compilation, fallback C++ implementation of intrinsics will be chosen and
-code will work as expected although it could be slower.
-
-### Types
-
-There are several types representing packed values vector registers, each type
-is implemented as a structure based on a one SIMD register.
-
-- cv::v_uint8 and cv::v_int8: 8-bit integer values (unsigned/signed) - char
-- cv::v_uint16 and cv::v_int16: 16-bit integer values (unsigned/signed) - short
-- cv::v_uint32 and cv::v_int32: 32-bit integer values (unsigned/signed) - int
-- cv::v_uint64 and cv::v_int64: 64-bit integer values (unsigned/signed) - int64
-- cv::v_float32: 32-bit floating point values (signed) - float
-- cv::v_float64: 64-bit floating point values (signed) - double
-
-Exact bit length(and value quantity) of listed types is compile time deduced and
-depends on architecture SIMD capabilities chosen as available during compilation
-of the library. All the types contains __nlanes__ enumeration to check for exact
-value quantity of the type.
-
-In case the exact bit length of the type is important it is possible to use
-specific fixed length register types.
-
-There are several types representing 128-bit registers.
-
-- cv::v_uint8x16 and cv::v_int8x16: sixteen 8-bit integer values
-(unsigned/signed) - char
-- cv::v_uint16x8 and cv::v_int16x8: eight 16-bit integer values
-(unsigned/signed) - short
-- cv::v_uint32x4 and cv::v_int32x4: four 32-bit integer values (unsigned/signed)
-- int
-- cv::v_uint64x2 and cv::v_int64x2: two 64-bit integer values (unsigned/signed)
-- int64
-- cv::v_float32x4: four 32-bit floating point values (signed) - float
-- cv::v_float64x2: two 64-bit floating point values (signed) - double
-
-There are several types representing 256-bit registers.
-
-- cv::v_uint8x32 and cv::v_int8x32: thirty two 8-bit integer values
-(unsigned/signed) - char
-- cv::v_uint16x16 and cv::v_int16x16: sixteen 16-bit integer values
-(unsigned/signed) - short
-- cv::v_uint32x8 and cv::v_int32x8: eight 32-bit integer values
-(unsigned/signed) - int
-- cv::v_uint64x4 and cv::v_int64x4: four 64-bit integer values (unsigned/signed)
-- int64
-- cv::v_float32x8: eight 32-bit floating point values (signed) - float
-- cv::v_float64x4: four 64-bit floating point values (signed) - double
-
-@note
-256 bit registers at the moment implemented for AVX2 SIMD extension only, if you
-want to use this type directly, don't forget to check the CV_SIMD256
-preprocessor definition:
-@code
-#if CV_SIMD256
-//...
-#endif
-@endcode
-
-There are several types representing 512-bit registers.
-
-- cv::v_uint8x64 and cv::v_int8x64: sixty four 8-bit integer values
-(unsigned/signed) - char
-- cv::v_uint16x32 and cv::v_int16x32: thirty two 16-bit integer values
-(unsigned/signed) - short
-- cv::v_uint32x16 and cv::v_int32x16: sixteen 32-bit integer values
-(unsigned/signed) - int
-- cv::v_uint64x8 and cv::v_int64x8: eight 64-bit integer values
-(unsigned/signed) - int64
-- cv::v_float32x16: sixteen 32-bit floating point values (signed) - float
-- cv::v_float64x8: eight 64-bit floating point values (signed) - double
-@note
-512 bit registers at the moment implemented for AVX512 SIMD extension only, if
-you want to use this type directly, don't forget to check the CV_SIMD512
-preprocessor definition.
-
-@note
-cv::v_float64x2 is not implemented in NEON variant, if you want to use this
-type, don't forget to check the CV_SIMD128_64F preprocessor definition.
-
-### Load and store operations
-
-These operations allow to set contents of the register explicitly or by loading
-it from some memory block and to save contents of the register to memory block.
-
-There are variable size register load operations that provide result of maximum
-available size depending on chosen platform capabilities.
-- Constructors:
-@ref v_reg::v_reg(const _Tp *ptr) "from memory",
-- Other create methods:
-vx_setall_s8, vx_setall_u8, ...,
-vx_setzero_u8, vx_setzero_s8, ...
-- Memory load operations:
-vx_load, vx_load_aligned, vx_load_low, vx_load_halves,
-- Memory operations with expansion of values:
-vx_load_expand, vx_load_expand_q
-
-Also there are fixed size register load/store operations.
-
-For 128 bit registers
-- Constructors:
-@ref v_reg::v_reg(const _Tp *ptr) "from memory",
-@ref v_reg::v_reg(_Tp s0, _Tp s1) "from two values", ...
-- Other create methods:
-@ref v_setall_s8, @ref v_setall_u8, ...,
-@ref v_setzero_u8, @ref v_setzero_s8, ...
-- Memory load operations:
-@ref v_load, @ref v_load_aligned, @ref v_load_low, @ref v_load_halves,
-- Memory operations with expansion of values:
-@ref v_load_expand, @ref v_load_expand_q
-
-For 256 bit registers(check CV_SIMD256 preprocessor definition)
-- Constructors:
-@ref v_reg::v_reg(const _Tp *ptr) "from memory",
-@ref v_reg::v_reg(_Tp s0, _Tp s1, _Tp s2, _Tp s3) "from four values", ...
-- Other create methods:
-@ref v256_setall_s8, @ref v256_setall_u8, ...,
-@ref v256_setzero_u8, @ref v256_setzero_s8, ...
-- Memory load operations:
-@ref v256_load, @ref v256_load_aligned, @ref v256_load_low, @ref
-v256_load_halves,
-- Memory operations with expansion of values:
-@ref v256_load_expand, @ref v256_load_expand_q
-
-For 512 bit registers(check CV_SIMD512 preprocessor definition)
-- Constructors:
-@ref v_reg::v_reg(const _Tp *ptr) "from memory",
-@ref v_reg::v_reg(_Tp s0, _Tp s1, _Tp s2, _Tp s3, _Tp s4, _Tp s5, _Tp s6, _Tp
-s7) "from eight values", ...
-- Other create methods:
-@ref v512_setall_s8, @ref v512_setall_u8, ...,
-@ref v512_setzero_u8, @ref v512_setzero_s8, ...
-- Memory load operations:
-@ref v512_load, @ref v512_load_aligned, @ref v512_load_low, @ref
-v512_load_halves,
-- Memory operations with expansion of values:
-@ref v512_load_expand, @ref v512_load_expand_q
-
-Store to memory operations are similar across different platform capabilities:
-@ref v_store, @ref v_store_aligned,
-@ref v_store_high, @ref v_store_low
-
-### Value reordering
-
-These operations allow to reorder or recombine elements in one or multiple
-vectors.
-
-- Interleave, deinterleave (2, 3 and 4 channels): @ref v_load_deinterleave, @ref
-v_store_interleave
-- Expand: @ref v_expand, @ref v_expand_low, @ref v_expand_high
-- Pack: @ref v_pack, @ref v_pack_u, @ref v_pack_b, @ref v_rshr_pack, @ref
-v_rshr_pack_u,
-@ref v_pack_store, @ref v_pack_u_store, @ref v_rshr_pack_store, @ref
-v_rshr_pack_u_store
-- Recombine: @ref v_zip, @ref v_recombine, @ref v_combine_low, @ref
-v_combine_high
-- Reverse: @ref v_reverse
-- Extract: @ref v_extract
-
-
-### Arithmetic, bitwise and comparison operations
-
-Element-wise binary and unary operations.
-
-- Arithmetics:
-@ref v_add(const v_reg &a, const v_reg &b) "+",
-@ref v_sub(const v_reg &a, const v_reg &b) "-",
-@ref v_mul(const v_reg &a, const v_reg &b) "*",
-@ref v_div(const v_reg &a, const v_reg &b) "/",
-@ref v_mul_expand
-
-- Non-saturating arithmetics: @ref v_add_wrap, @ref v_sub_wrap
-
-- Bitwise shifts:
-@ref v_shl(const v_reg &a, int s) "<<",
-@ref v_shr(const v_reg &a, int s) ">>",
-@ref v_shl, @ref v_shr
-
-- Bitwise logic:
-@ref v_and(const v_reg &a, const v_reg &b) "&",
-@ref v_or(const v_reg &a, const v_reg &b) "|",
-@ref v_xor(const v_reg &a, const v_reg &b) "^",
-@ref v_not(const v_reg &a) "~"
-
-- Comparison:
-@ref v_gt(const v_reg &a, const v_reg &b) ">",
-@ref v_ge(const v_reg &a, const v_reg &b) ">=",
-@ref v_lt(const v_reg &a, const v_reg &b) "<",
-@ref v_le(const v_reg &a, const v_reg &b) "<=",
-@ref v_eq(const v_reg &a, const v_reg &b) "==",
-@ref v_ne(const v_reg &a, const v_reg &b) "!="
-
-- min/max: @ref v_min, @ref v_max
-
-### Reduce and mask
-
-Most of these operations return only one value.
-
-- Reduce: @ref v_reduce_min, @ref v_reduce_max, @ref v_reduce_sum, @ref
-v_popcount
-- Mask: @ref v_signmask, @ref v_check_all, @ref v_check_any, @ref v_select
-
-### Other math
-
-- Some frequent operations: @ref v_sqrt, @ref v_invsqrt, @ref v_magnitude, @ref
-v_sqr_magnitude, @ref v_exp, @ref v_log,
-                            @ref v_erf, @ref v_sin, @ref v_cos
-- Absolute values: @ref v_abs, @ref v_absdiff, @ref v_absdiffs
-
-### Conversions
-
-Different type conversions and casts:
-
-- Rounding: @ref v_round, @ref v_floor, @ref v_ceil, @ref v_trunc,
-- To float: @ref v_cvt_f32, @ref v_cvt_f64
-- Reinterpret: @ref v_reinterpret_as_u8, @ref v_reinterpret_as_s8, ...
-
-### Matrix operations
-
-In these operations vectors represent matrix rows/columns: @ref v_dotprod, @ref
-v_dotprod_fast,
-@ref v_dotprod_expand, @ref v_dotprod_expand_fast, @ref v_matmul, @ref
-v_transpose4x4
-
-### Usability
-
-Most operations are implemented only for some subset of the available types,
-following matrices shows the applicability of different operations to the types.
-
-Regular integers:
-
-| Operations\\Types | uint 8 | int 8 | uint 16 | int 16 | uint 32 | int 32 |
-|-------------------|:-:|:-:|:-:|:-:|:-:|:-:|
-|load, store        | x | x | x | x | x | x |
-|interleave         | x | x | x | x | x | x |
-|expand             | x | x | x | x | x | x |
-|expand_low         | x | x | x | x | x | x |
-|expand_high        | x | x | x | x | x | x |
-|expand_q           | x | x |   |   |   |   |
-|add, sub           | x | x | x | x | x | x |
-|add_wrap, sub_wrap | x | x | x | x |   |   |
-|mul_wrap           | x | x | x | x |   |   |
-|mul                | x | x | x | x | x | x |
-|mul_expand         | x | x | x | x | x |   |
-|compare            | x | x | x | x | x | x |
-|shift              |   |   | x | x | x | x |
-|dotprod            |   |   |   | x |   | x |
-|dotprod_fast       |   |   |   | x |   | x |
-|dotprod_expand     | x | x | x | x |   | x |
-|dotprod_expand_fast| x | x | x | x |   | x |
-|logical            | x | x | x | x | x | x |
-|min, max           | x | x | x | x | x | x |
-|absdiff            | x | x | x | x | x | x |
-|absdiffs           |   | x |   | x |   |   |
-|reduce             | x | x | x | x | x | x |
-|mask               | x | x | x | x | x | x |
-|pack               | x | x | x | x | x | x |
-|pack_u             | x |   | x |   |   |   |
-|pack_b             | x |   |   |   |   |   |
-|unpack             | x | x | x | x | x | x |
-|extract            | x | x | x | x | x | x |
-|rotate (lanes)     | x | x | x | x | x | x |
-|cvt_flt32          |   |   |   |   |   | x |
-|cvt_flt64          |   |   |   |   |   | x |
-|transpose4x4       |   |   |   |   | x | x |
-|reverse            | x | x | x | x | x | x |
-|extract_n          | x | x | x | x | x | x |
-|broadcast_element  |   |   |   |   | x | x |
-
-Big integers:
-
-| Operations\\Types | uint 64 | int 64 |
-|-------------------|:-:|:-:|
-|load, store        | x | x |
-|add, sub           | x | x |
-|shift              | x | x |
-|logical            | x | x |
-|reverse            | x | x |
-|extract            | x | x |
-|rotate (lanes)     | x | x |
-|cvt_flt64          |   | x |
-|extract_n          | x | x |
-
-Floating point:
-
-| Operations\\Types | float 32 | float 64 |
-|-------------------|:-:|:-:|
-|load, store        | x | x |
-|interleave         | x |   |
-|add, sub           | x | x |
-|mul                | x | x |
-|div                | x | x |
-|compare            | x | x |
-|min, max           | x | x |
-|absdiff            | x | x |
-|reduce             | x |   |
-|mask               | x | x |
-|unpack             | x | x |
-|cvt_flt32          |   | x |
-|cvt_flt64          | x |   |
-|sqrt, abs          | x | x |
-|float math         | x | x |
-|transpose4x4       | x |   |
-|extract            | x | x |
-|rotate (lanes)     | x | x |
-|reverse            | x | x |
-|extract_n          | x | x |
-|broadcast_element  | x |   |
-|exp                | x | x |
-|log                | x | x |
-|sin, cos           | x | x |
-
- @{ */
-
-template <typename _Tp, int n> struct v_reg {
-  //! @cond IGNORED
-  typedef _Tp lane_type;
-  enum { nlanes = n };
-  // !@endcond
-
-  /** @brief Constructor
-
-  Initializes register with data from memory
-  @param ptr pointer to memory block with data for register */
-  explicit v_reg(const _Tp *ptr) {
-    for (int i = 0; i < n; i++)
-      s[i] = ptr[i];
-  }
-
-  /** @brief Constructor
-
-  Initializes register with two 64-bit values */
-  v_reg(_Tp s0, _Tp s1) {
-    s[0] = s0;
-    s[1] = s1;
-  }
-
-  /** @brief Constructor
-
-  Initializes register with four 32-bit values */
-  v_reg(_Tp s0, _Tp s1, _Tp s2, _Tp s3) {
-    s[0] = s0;
-    s[1] = s1;
-    s[2] = s2;
-    s[3] = s3;
-  }
-
-  /** @brief Constructor
-
-  Initializes register with eight 16-bit values */
-  v_reg(_Tp s0, _Tp s1, _Tp s2, _Tp s3, _Tp s4, _Tp s5, _Tp s6, _Tp s7) {
-    s[0] = s0;
-    s[1] = s1;
-    s[2] = s2;
-    s[3] = s3;
-    s[4] = s4;
-    s[5] = s5;
-    s[6] = s6;
-    s[7] = s7;
-  }
-
-  /** @brief Constructor
-
-  Initializes register with sixteen 8-bit values */
-  v_reg(_Tp s0, _Tp s1, _Tp s2, _Tp s3, _Tp s4, _Tp s5, _Tp s6, _Tp s7, _Tp s8,
-        _Tp s9, _Tp s10, _Tp s11, _Tp s12, _Tp s13, _Tp s14, _Tp s15) {
-    s[0] = s0;
-    s[1] = s1;
-    s[2] = s2;
-    s[3] = s3;
-    s[4] = s4;
-    s[5] = s5;
-    s[6] = s6;
-    s[7] = s7;
-    s[8] = s8;
-    s[9] = s9;
-    s[10] = s10;
-    s[11] = s11;
-    s[12] = s12;
-    s[13] = s13;
-    s[14] = s14;
-    s[15] = s15;
-  }
-
-  /** @brief Default constructor
-
-  Does not initialize anything*/
-  v_reg() {}
-
-  /** @brief Copy constructor */
-  v_reg(const v_reg<_Tp, n> &r) {
-    for (int i = 0; i < n; i++)
-      s[i] = r.s[i];
-  }
-  /** @brief Access first value
-
-  Returns value of the first lane according to register type, for example:
-  @code{.cpp}
-  v_int32x4 r(1, 2, 3, 4);
-  int v = r.get0(); // returns 1
-  v_uint64x2 r(1, 2);
-  uint64_t v = r.get0(); // returns 1
-  @endcode
-  */
-  _Tp get0() const { return s[0]; }
-
-  //! @cond IGNORED
-  _Tp get(const int i) const { return s[i]; }
-  v_reg<_Tp, n> high() const {
-    v_reg<_Tp, n> c;
-    int i;
-    for (i = 0; i < n / 2; i++) {
-      c.s[i] = s[i + (n / 2)];
-      c.s[i + (n / 2)] = 0;
-    }
-    return c;
-  }
-
-  static v_reg<_Tp, n> zero() {
-    v_reg<_Tp, n> c;
-    for (int i = 0; i < n; i++)
-      c.s[i] = (_Tp)0;
-    return c;
-  }
-
-  static v_reg<_Tp, n> all(_Tp s) {
-    v_reg<_Tp, n> c;
-    for (int i = 0; i < n; i++)
-      c.s[i] = s;
-    return c;
-  }
-
-  template <typename _Tp2, int n2> v_reg<_Tp2, n2> reinterpret_as() const {
-    size_t bytes = std::min(sizeof(_Tp2) * n2, sizeof(_Tp) * n);
-    v_reg<_Tp2, n2> c;
-    std::memcpy(&c.s[0], &s[0], bytes);
-    return c;
-  }
-
-  v_reg &operator=(const v_reg<_Tp, n> &r) {
-    for (int i = 0; i < n; i++)
-      s[i] = r.s[i];
-    return *this;
-  }
-
-  _Tp s[n];
-  //! @endcond
-};
-
-/** @brief Sixteen 8-bit unsigned integer values */
-typedef v_reg<uchar, 16> v_uint8x16;
-/** @brief Sixteen 8-bit signed integer values */
-typedef v_reg<schar, 16> v_int8x16;
-/** @brief Eight 16-bit unsigned integer values */
-typedef v_reg<ushort, 8> v_uint16x8;
-/** @brief Eight 16-bit signed integer values */
-typedef v_reg<short, 8> v_int16x8;
-/** @brief Four 32-bit unsigned integer values */
-typedef v_reg<unsigned, 4> v_uint32x4;
-/** @brief Four 32-bit signed integer values */
-typedef v_reg<int, 4> v_int32x4;
-/** @brief Four 32-bit floating point values (single precision) */
-typedef v_reg<float, 4> v_float32x4;
-/** @brief Two 64-bit floating point values (double precision) */
-typedef v_reg<double, 2> v_float64x2;
-/** @brief Two 64-bit unsigned integer values */
-typedef v_reg<uint64, 2> v_uint64x2;
-/** @brief Two 64-bit signed integer values */
-typedef v_reg<int64, 2> v_int64x2;
-
-#if CV_SIMD256
-/** @brief Thirty two 8-bit unsigned integer values */
-typedef v_reg<uchar, 32> v_uint8x32;
-/** @brief Thirty two 8-bit signed integer values */
-typedef v_reg<schar, 32> v_int8x32;
-/** @brief Sixteen 16-bit unsigned integer values */
-typedef v_reg<ushort, 16> v_uint16x16;
-/** @brief Sixteen 16-bit signed integer values */
-typedef v_reg<short, 16> v_int16x16;
-/** @brief Eight 32-bit unsigned integer values */
-typedef v_reg<unsigned, 8> v_uint32x8;
-/** @brief Eight 32-bit signed integer values */
-typedef v_reg<int, 8> v_int32x8;
-/** @brief Eight 32-bit floating point values (single precision) */
-typedef v_reg<float, 8> v_float32x8;
-/** @brief Four 64-bit floating point values (double precision) */
-typedef v_reg<double, 4> v_float64x4;
-/** @brief Four 64-bit unsigned integer values */
-typedef v_reg<uint64, 4> v_uint64x4;
-/** @brief Four 64-bit signed integer values */
-typedef v_reg<int64, 4> v_int64x4;
-#endif
-
-#if CV_SIMD512
-/** @brief Sixty four 8-bit unsigned integer values */
-typedef v_reg<uchar, 64> v_uint8x64;
-/** @brief Sixty four 8-bit signed integer values */
-typedef v_reg<schar, 64> v_int8x64;
-/** @brief Thirty two 16-bit unsigned integer values */
-typedef v_reg<ushort, 32> v_uint16x32;
-/** @brief Thirty two 16-bit signed integer values */
-typedef v_reg<short, 32> v_int16x32;
-/** @brief Sixteen 32-bit unsigned integer values */
-typedef v_reg<unsigned, 16> v_uint32x16;
-/** @brief Sixteen 32-bit signed integer values */
-typedef v_reg<int, 16> v_int32x16;
-/** @brief Sixteen 32-bit floating point values (single precision) */
-typedef v_reg<float, 16> v_float32x16;
-/** @brief Eight 64-bit floating point values (double precision) */
-typedef v_reg<double, 8> v_float64x8;
-/** @brief Eight 64-bit unsigned integer values */
-typedef v_reg<uint64, 8> v_uint64x8;
-/** @brief Eight 64-bit signed integer values */
-typedef v_reg<int64, 8> v_int64x8;
-#endif
-
-enum {
-  simd128_width = 16,
-#if CV_SIMD256
-  simd256_width = 32,
-#endif
-#if CV_SIMD512
-  simd512_width = 64,
-  simdmax_width = simd512_width
-#elif CV_SIMD256
-  simdmax_width = simd256_width
-#else
-  simdmax_width = simd128_width
-#endif
-};
-
-/** @brief Add values
-
-For all types. */
-template <typename _Tp, int n>
-CV_INLINE v_reg<_Tp, n> v_add(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b);
-
-/** @brief Subtract values
-
-For all types. */
-template <typename _Tp, int n>
-CV_INLINE v_reg<_Tp, n> v_sub(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b);
-
-/** @brief Multiply values
-
-For 16- and 32-bit integer types and floating types. */
-template <typename _Tp, int n>
-CV_INLINE v_reg<_Tp, n> v_mul(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b);
-
-/** @brief Divide values
-
-For floating types only. */
-template <typename _Tp, int n>
-CV_INLINE v_reg<_Tp, n> v_div(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b);
-
-/** @brief Bitwise AND
-
-Only for integer types. */
-template <typename _Tp, int n>
-CV_INLINE v_reg<_Tp, n> v_and(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b);
-
-/** @brief Bitwise OR
-
-Only for integer types. */
-template <typename _Tp, int n>
-CV_INLINE v_reg<_Tp, n> v_or(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b);
-
-/** @brief Bitwise XOR
-
-Only for integer types.*/
-template <typename _Tp, int n>
-CV_INLINE v_reg<_Tp, n> v_xor(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b);
-
-/** @brief Bitwise NOT
-
-Only for integer types.*/
-template <typename _Tp, int n>
-CV_INLINE v_reg<_Tp, n> v_not(const v_reg<_Tp, n> &a);
-
-#ifndef CV_DOXYGEN
-
-#define CV__HAL_INTRIN_EXPAND_WITH_INTEGER_TYPES(macro_name, ...)              \
-  __CV_EXPAND(macro_name(uchar, __VA_ARGS__))                                  \
-  __CV_EXPAND(macro_name(schar, __VA_ARGS__))                                  \
-  __CV_EXPAND(macro_name(ushort, __VA_ARGS__))                                 \
-  __CV_EXPAND(macro_name(short, __VA_ARGS__))                                  \
-  __CV_EXPAND(macro_name(unsigned, __VA_ARGS__))                               \
-  __CV_EXPAND(macro_name(int, __VA_ARGS__))                                    \
-  __CV_EXPAND(macro_name(uint64, __VA_ARGS__))                                 \
-  __CV_EXPAND(macro_name(int64, __VA_ARGS__))
-
-#define CV__HAL_INTRIN_EXPAND_WITH_FP_TYPES(macro_name, ...)                   \
-  __CV_EXPAND(macro_name(float, __VA_ARGS__))                                  \
-  __CV_EXPAND(macro_name(double, __VA_ARGS__))
-
-#define CV__HAL_INTRIN_EXPAND_WITH_ALL_TYPES(macro_name, ...)                  \
-  CV__HAL_INTRIN_EXPAND_WITH_INTEGER_TYPES(macro_name, __VA_ARGS__)            \
-  CV__HAL_INTRIN_EXPAND_WITH_FP_TYPES(macro_name, __VA_ARGS__)
-
-#define CV__HAL_INTRIN_IMPL_BIN_OP_(_Tp, bin_op, func)                         \
-  template <int n>                                                             \
-  inline v_reg<_Tp, n> func(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b) {  \
-    v_reg<_Tp, n> c;                                                           \
-    for (int i = 0; i < n; i++)                                                \
-      c.s[i] = saturate_cast<_Tp>(a.s[i] bin_op b.s[i]);                       \
-    return c;                                                                  \
-  }
-
-#define CV__HAL_INTRIN_IMPL_BIN_OP(bin_op, func)                               \
-  CV__HAL_INTRIN_EXPAND_WITH_ALL_TYPES(CV__HAL_INTRIN_IMPL_BIN_OP_, bin_op,    \
-                                       func)
-
-CV__HAL_INTRIN_IMPL_BIN_OP(+, v_add)
-CV__HAL_INTRIN_IMPL_BIN_OP(-, v_sub)
-CV__HAL_INTRIN_IMPL_BIN_OP(*, v_mul)
-CV__HAL_INTRIN_EXPAND_WITH_FP_TYPES(CV__HAL_INTRIN_IMPL_BIN_OP_, /, v_div)
-
-#define CV__HAL_INTRIN_IMPL_BIT_OP_(_Tp, bit_op, func)                         \
-  template <int n>                                                             \
-  CV_INLINE v_reg<_Tp, n> func(const v_reg<_Tp, n> &a,                         \
-                               const v_reg<_Tp, n> &b) {                       \
-    v_reg<_Tp, n> c;                                                           \
-    typedef typename V_TypeTraits<_Tp>::int_type itype;                        \
-    for (int i = 0; i < n; i++)                                                \
-      c.s[i] = V_TypeTraits<_Tp>::reinterpret_from_int(                        \
-          (itype)(V_TypeTraits<_Tp>::reinterpret_int(a.s[i])                   \
-                      bit_op V_TypeTraits<_Tp>::reinterpret_int(b.s[i])));     \
-    return c;                                                                  \
-  }
-
-#define CV__HAL_INTRIN_IMPL_BIT_OP(bit_op, func)                               \
-  CV__HAL_INTRIN_EXPAND_WITH_INTEGER_TYPES(CV__HAL_INTRIN_IMPL_BIT_OP_,        \
-                                           bit_op, func)                       \
-  CV__HAL_INTRIN_EXPAND_WITH_FP_TYPES(                                         \
-      CV__HAL_INTRIN_IMPL_BIT_OP_, bit_op,                                     \
-      func) /* TODO: FIXIT remove this after masks refactoring */
-
-CV__HAL_INTRIN_IMPL_BIT_OP(&, v_and)
-CV__HAL_INTRIN_IMPL_BIT_OP(|, v_or)
-CV__HAL_INTRIN_IMPL_BIT_OP(^, v_xor)
-
-#define CV__HAL_INTRIN_IMPL_BITWISE_NOT_(_Tp, dummy, dummy2)                   \
-  template <int n> CV_INLINE v_reg<_Tp, n> v_not(const v_reg<_Tp, n> &a) {     \
-    v_reg<_Tp, n> c;                                                           \
-    for (int i = 0; i < n; i++)                                                \
-      c.s[i] = V_TypeTraits<_Tp>::reinterpret_from_int(                        \
-          ~V_TypeTraits<_Tp>::reinterpret_int(a.s[i]));                        \
-    return c;                                                                  \
-  }
-
-CV__HAL_INTRIN_EXPAND_WITH_INTEGER_TYPES(CV__HAL_INTRIN_IMPL_BITWISE_NOT_, ~,
-                                         v_not)
-
-#endif // !CV_DOXYGEN
-
-//! @brief Helper macro
-//! @ingroup core_hal_intrin_impl
-#define OPENCV_HAL_IMPL_MATH_FUNC(func, cfunc, _Tp2)                           \
-  template <typename _Tp, int n>                                               \
-  inline v_reg<_Tp2, n> func(const v_reg<_Tp, n> &a) {                         \
-    v_reg<_Tp2, n> c;                                                          \
-    for (int i = 0; i < n; i++)                                                \
-      c.s[i] = cfunc(a.s[i]);                                                  \
-    return c;                                                                  \
-  }
-
-/** @brief Square root of elements
-
-Only for floating point types.*/
-OPENCV_HAL_IMPL_MATH_FUNC(v_sqrt, std::sqrt, _Tp)
-
-/**
- * @brief Exponential \f$ e^x \f$ of elements
- *
- * Only for floating point types. Core implementation steps:
- * 1. Decompose Input: Convert the input to \f$ 2^{x \cdot \log_2e} \f$ and
- * split its exponential into integer and fractional parts:
- *    \f$ x \cdot \log_2e = n + f \f$, where \f$ n \f$ is the integer part and
- * \f$ f \f$ is the fractional part.
- * 2. Compute \f$ 2^n \f$: Calculated by shifting the bits.
- * 3. Adjust Fractional Part: Compute \f$ f \cdot \ln2 \f$ to convert the
- * fractional part to base \f$ e \f$.
- *    \f$ C1 \f$ and \f$ C2 \f$ are used to adjust the fractional part.
- * 4. Polynomial Approximation for \f$ e^{f \cdot \ln2} \f$: The closer the
- * fractional part is to 0, the more accurate the result.
- *    - For float16 and float32, use a Taylor Series with 6 terms.
- *    - For float64, use Pade Polynomials Approximation with 4 terms.
- * 5. Combine Results: Multiply the two parts together to get the final result:
- *    \f$ e^x = 2^n \cdot e^{f \cdot \ln2} \f$.
- *
- * @note The precision of the calculation depends on the implementation and the
- * data type of the input vector.
- */
-OPENCV_HAL_IMPL_MATH_FUNC(v_exp, std::exp, _Tp)
-#define OPENCV_HAL_MATH_HAVE_EXP 1
-
-/**
- * @brief Natural logarithm \f$ \log(x) \f$ of elements
- *
- * Only for floating point types. Core implementation steps:
- * 1. Decompose Input: Use binary representation to decompose the input into
- * mantissa part \f$ m \f$ and exponent part \f$ e \f$. Such that \f$ \log(x) =
- * \log(m \cdot 2^e) = \log(m) + e \cdot \ln(2) \f$.
- * 2. Adjust Mantissa and Exponent Parts: If the mantissa is less than \f$
- * \sqrt{0.5} \f$, adjust the exponent and mantissa to ensure the mantissa is in
- * the range \f$ (\sqrt{0.5}, \sqrt{2}) \f$ for better approximation.
- * 3. Polynomial Approximation for \f$ \log(m) \f$: The closer the \f$ m \f$ is
- * to 1, the more accurate the result.
- *    - For float16 and float32, use a Taylor Series with 9 terms.
- *    - For float64, use Pade Polynomials Approximation with 6 terms.
- * 4. Combine Results: Add the two parts together to get the final result.
- *
- * @note The precision of the calculation depends on the implementation and the
- * data type of the input.
- *
- * @note Similar to the behavior of std::log(), \f$ \ln(0) = -\infty \f$.
- */
-OPENCV_HAL_IMPL_MATH_FUNC(v_log, std::log, _Tp)
-
-/**
- * @brief Error function.
- *
- * @note Support FP32 precision for now.
- */
-OPENCV_HAL_IMPL_MATH_FUNC(v_erf, std::erf, _Tp)
-
-/**
- * @brief Compute sine \f$ sin(x) \f$ and cosine \f$ cos(x) \f$ of elements at
- * the same time
- *
- * Only for floating point types. Core implementation steps:
- * 1. Input Normalization: Scale the periodicity from 2π to 4 and reduce the
- * angle to the range \f$ [0, \frac{\pi}{4}] \f$ using periodicity and
- * trigonometric identities.
- * 2. Polynomial Approximation for \f$ sin(x) \f$ and \f$ cos(x) \f$:
- *   - For float16 and float32, use a Taylor series with 4 terms for sine and 5
- * terms for cosine.
- *   - For float64, use a Taylor series with 7 terms for sine and 8 terms for
- * cosine.
- * 3. Select Results: select and convert the final sine and cosine values for
- * the original input angle.
- *
- * @note The precision of the calculation depends on the implementation and the
- * data type of the input vector.
- */
-template <typename _Tp, int n>
-inline void v_sincos(const v_reg<_Tp, n> &x, v_reg<_Tp, n> &s,
-                     v_reg<_Tp, n> &c) {
-  for (int i = 0; i < n; i++) {
-    s.s[i] = std::sin(x.s[i]);
-    c.s[i] = std::cos(x.s[i]);
-  }
-}
-
-/**
- * @brief Sine \f$ sin(x) \f$ of elements
- *
- * Only for floating point types. Core implementation the same as @ref v_sincos.
- */
-OPENCV_HAL_IMPL_MATH_FUNC(v_sin, std::sin, _Tp)
-
-/**
- * @brief Cosine \f$ cos(x) \f$ of elements
- *
- * Only for floating point types. Core implementation the same as @ref v_sincos.
- */
-OPENCV_HAL_IMPL_MATH_FUNC(v_cos, std::cos, _Tp)
-
-/** @brief Absolute value of elements
-
-Only for floating point types.*/
-OPENCV_HAL_IMPL_MATH_FUNC(v_abs, (typename V_TypeTraits<_Tp>::abs_type)std::abs,
-                          typename V_TypeTraits<_Tp>::abs_type)
-
-//! @brief Helper macro
-//! @ingroup core_hal_intrin_impl
-#define OPENCV_HAL_IMPL_MINMAX_FUNC(func, cfunc)                               \
-  template <typename _Tp, int n>                                               \
-  inline v_reg<_Tp, n> func(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b) {  \
-    v_reg<_Tp, n> c;                                                           \
-    for (int i = 0; i < n; i++)                                                \
-      c.s[i] = cfunc(a.s[i], b.s[i]);                                          \
-    return c;                                                                  \
-  }
-
-//! @brief Helper macro
-//! @ingroup core_hal_intrin_impl
-#define OPENCV_HAL_IMPL_REDUCE_MINMAX_FUNC(func, cfunc)                        \
-  template <typename _Tp, int n> inline _Tp func(const v_reg<_Tp, n> &a) {     \
-    _Tp c = a.s[0];                                                            \
-    for (int i = 1; i < n; i++)                                                \
-      c = cfunc(c, a.s[i]);                                                    \
-    return c;                                                                  \
-  }
-
-/** @brief Choose min values for each pair
-
-Scheme:
-@code
-{A1 A2 ...}
-{B1 B2 ...}
---------------
-{min(A1,B1) min(A2,B2) ...}
-@endcode
-For all types except 64-bit integer. */
-OPENCV_HAL_IMPL_MINMAX_FUNC(v_min, std::min)
-
-/** @brief Choose max values for each pair
-
-Scheme:
-@code
-{A1 A2 ...}
-{B1 B2 ...}
---------------
-{max(A1,B1) max(A2,B2) ...}
-@endcode
-For all types except 64-bit integer. */
-OPENCV_HAL_IMPL_MINMAX_FUNC(v_max, std::max)
-
-/** @brief Find one min value
-
-Scheme:
-@code
-{A1 A2 A3 ...} => min(A1,A2,A3,...)
-@endcode
-For all types except 64-bit integer and 64-bit floating point types. */
-OPENCV_HAL_IMPL_REDUCE_MINMAX_FUNC(v_reduce_min, std::min)
-
-/** @brief Find one max value
-
-Scheme:
-@code
-{A1 A2 A3 ...} => max(A1,A2,A3,...)
-@endcode
-For all types except 64-bit integer and 64-bit floating point types. */
-OPENCV_HAL_IMPL_REDUCE_MINMAX_FUNC(v_reduce_max, std::max)
-
-static const unsigned char popCountTable[] = {
-    0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4,
-    2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4,
-    2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6,
-    4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5,
-    3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6,
-    4, 5, 5, 6, 5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-    4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,
-};
-/** @brief Count the 1 bits in the vector lanes and return result as
-corresponding unsigned type
-
-Scheme:
-@code
-{A1 A2 A3 ...} => {popcount(A1), popcount(A2), popcount(A3), ...}
-@endcode
-For all integer types. */
-template <typename _Tp, int n>
-inline v_reg<typename V_TypeTraits<_Tp>::abs_type, n>
-v_popcount(const v_reg<_Tp, n> &a) {
-  v_reg<typename V_TypeTraits<_Tp>::abs_type, n> b =
-      v_reg<typename V_TypeTraits<_Tp>::abs_type, n>::zero();
-  for (int i = 0; i < n * (int)sizeof(_Tp); i++)
-    b.s[i / sizeof(_Tp)] += popCountTable[v_reinterpret_as_u8(a).s[i]];
-  return b;
-}
-
-//! @cond IGNORED
-template <typename _Tp, int n>
-inline void v_minmax(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b,
-                     v_reg<_Tp, n> &minval, v_reg<_Tp, n> &maxval) {
-  for (int i = 0; i < n; i++) {
-    minval.s[i] = std::min(a.s[i], b.s[i]);
-    maxval.s[i] = std::max(a.s[i], b.s[i]);
-  }
-}
-//! @endcond
-
-//! @brief Helper macro
-//! @ingroup core_hal_intrin_impl
-#define OPENCV_HAL_IMPL_CMP_OP(cmp_op, func)                                   \
-  template <typename _Tp, int n>                                               \
-  inline v_reg<_Tp, n> func(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b) {  \
-    typedef typename V_TypeTraits<_Tp>::int_type itype;                        \
-    v_reg<_Tp, n> c;                                                           \
-    for (int i = 0; i < n; i++)                                                \
-      c.s[i] = V_TypeTraits<_Tp>::reinterpret_from_int(                        \
-          (itype) - (int)(a.s[i] cmp_op b.s[i]));                              \
-    return c;                                                                  \
-  }
-
-/** @brief Less-than comparison
-
-For all types except 64-bit integer values. */
-OPENCV_HAL_IMPL_CMP_OP(<, v_lt)
-
-/** @brief Greater-than comparison
-
-For all types except 64-bit integer values. */
-OPENCV_HAL_IMPL_CMP_OP(>, v_gt)
-
-/** @brief Less-than or equal comparison
-
-For all types except 64-bit integer values. */
-OPENCV_HAL_IMPL_CMP_OP(<=, v_le)
-
-/** @brief Greater-than or equal comparison
-
-For all types except 64-bit integer values. */
-OPENCV_HAL_IMPL_CMP_OP(>=, v_ge)
-
-/** @brief Equal comparison */
-OPENCV_HAL_IMPL_CMP_OP(==, v_eq)
-
-/** @brief Not equal comparison */
-OPENCV_HAL_IMPL_CMP_OP(!=, v_ne)
-
-template <int n> inline v_reg<float, n> v_not_nan(const v_reg<float, n> &a) {
-  typedef typename V_TypeTraits<float>::int_type itype;
-  v_reg<float, n> c;
-  for (int i = 0; i < n; i++)
-    c.s[i] = V_TypeTraits<float>::reinterpret_from_int((itype) -
-                                                       (int)(a.s[i] == a.s[i]));
-  return c;
-}
-template <int n> inline v_reg<double, n> v_not_nan(const v_reg<double, n> &a) {
-  typedef typename V_TypeTraits<double>::int_type itype;
-  v_reg<double, n> c;
-  for (int i = 0; i < n; i++)
-    c.s[i] = V_TypeTraits<double>::reinterpret_from_int(
-        (itype) - (int)(a.s[i] == a.s[i]));
-  return c;
-}
-
-//! @brief Helper macro
-//! @ingroup core_hal_intrin_impl
-#define OPENCV_HAL_IMPL_ARITHM_OP(func, bin_op, cast_op, _Tp2)                 \
-  template <typename _Tp, int n>                                               \
-  inline v_reg<_Tp2, n> func(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b) { \
-    typedef _Tp2 rtype;                                                        \
-    v_reg<rtype, n> c;                                                         \
-    for (int i = 0; i < n; i++)                                                \
-      c.s[i] = cast_op(a.s[i] bin_op b.s[i]);                                  \
-    return c;                                                                  \
-  }
-
-/** @brief Add values without saturation
-
-For 8- and 16-bit integer values. */
-OPENCV_HAL_IMPL_ARITHM_OP(v_add_wrap, +, (_Tp), _Tp)
-
-/** @brief Subtract values without saturation
-
-For 8- and 16-bit integer values. */
-OPENCV_HAL_IMPL_ARITHM_OP(v_sub_wrap, -, (_Tp), _Tp)
-
-/** @brief Multiply values without saturation
-
-For 8- and 16-bit integer values. */
-OPENCV_HAL_IMPL_ARITHM_OP(v_mul_wrap, *, (_Tp), _Tp)
-
-//! @cond IGNORED
-template <typename T> inline T _absdiff(T a, T b) {
-  return a > b ? a - b : b - a;
-}
-//! @endcond
-
-/** @brief Absolute difference
-
-Returns \f$ |a - b| \f$ converted to corresponding unsigned type.
-Example:
-@code{.cpp}
-v_int32x4 a, b; // {1, 2, 3, 4} and {4, 3, 2, 1}
-v_uint32x4 c = v_absdiff(a, b); // result is {3, 1, 1, 3}
-@endcode
-For 8-, 16-, 32-bit integer source types. */
-template <typename _Tp, int n>
-inline v_reg<typename V_TypeTraits<_Tp>::abs_type, n>
-v_absdiff(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b) {
-  typedef typename V_TypeTraits<_Tp>::abs_type rtype;
-  v_reg<rtype, n> c;
-  const rtype mask = (rtype)(std::numeric_limits<_Tp>::is_signed
-                                 ? (1 << (sizeof(rtype) * 8 - 1))
-                                 : 0);
-  for (int i = 0; i < n; i++) {
-    rtype ua = a.s[i] ^ mask;
-    rtype ub = b.s[i] ^ mask;
-    c.s[i] = _absdiff(ua, ub);
-  }
-  return c;
-}
-
-/** @overload
-
-For 32-bit floating point values */
-template <int n>
-inline v_reg<float, n> v_absdiff(const v_reg<float, n> &a,
-                                 const v_reg<float, n> &b) {
-  v_reg<float, n> c;
-  for (int i = 0; i < c.nlanes; i++)
-    c.s[i] = _absdiff(a.s[i], b.s[i]);
-  return c;
-}
-
-/** @overload
-
-For 64-bit floating point values */
-template <int n>
-inline v_reg<double, n> v_absdiff(const v_reg<double, n> &a,
-                                  const v_reg<double, n> &b) {
-  v_reg<double, n> c;
-  for (int i = 0; i < c.nlanes; i++)
-    c.s[i] = _absdiff(a.s[i], b.s[i]);
-  return c;
-}
-
-/** @brief Saturating absolute difference
-
-Returns \f$ saturate(|a - b|) \f$ .
-For 8-, 16-bit signed integer source types. */
-template <typename _Tp, int n>
-inline v_reg<_Tp, n> v_absdiffs(const v_reg<_Tp, n> &a,
-                                const v_reg<_Tp, n> &b) {
-  v_reg<_Tp, n> c;
-  for (int i = 0; i < n; i++)
-    c.s[i] = saturate_cast<_Tp>(std::abs(a.s[i] - b.s[i]));
-  return c;
-}
-
-/** @brief Inversed square root
-
-Returns \f$ 1/sqrt(a) \f$
-For floating point types only. */
-template <typename _Tp, int n>
-inline v_reg<_Tp, n> v_invsqrt(const v_reg<_Tp, n> &a) {
-  v_reg<_Tp, n> c;
-  for (int i = 0; i < n; i++)
-    c.s[i] = 1.f / std::sqrt(a.s[i]);
-  return c;
-}
-
-/** @brief Magnitude
-
-Returns \f$ sqrt(a^2 + b^2) \f$
-For floating point types only. */
-template <typename _Tp, int n>
-inline v_reg<_Tp, n> v_magnitude(const v_reg<_Tp, n> &a,
-                                 const v_reg<_Tp, n> &b) {
-  v_reg<_Tp, n> c;
-  for (int i = 0; i < n; i++)
-    c.s[i] = std::sqrt(a.s[i] * a.s[i] + b.s[i] * b.s[i]);
-  return c;
-}
-
-/** @brief Square of the magnitude
-
-Returns \f$ a^2 + b^2 \f$
-For floating point types only. */
-template <typename _Tp, int n>
-inline v_reg<_Tp, n> v_sqr_magnitude(const v_reg<_Tp, n> &a,
-                                     const v_reg<_Tp, n> &b) {
-  v_reg<_Tp, n> c;
-  for (int i = 0; i < n; i++)
-    c.s[i] = a.s[i] * a.s[i] + b.s[i] * b.s[i];
-  return c;
-}
-
-/** @brief Multiply and add
-
- Returns \f$ a*b + c \f$
- For floating point types and signed 32bit int only. */
-template <typename _Tp, int n>
-inline v_reg<_Tp, n> v_fma(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b,
-                           const v_reg<_Tp, n> &c) {
-  v_reg<_Tp, n> d;
-  for (int i = 0; i < n; i++)
-    d.s[i] = a.s[i] * b.s[i] + c.s[i];
-  return d;
-}
-
-/** @brief A synonym for v_fma */
-template <typename _Tp, int n>
-inline v_reg<_Tp, n> v_muladd(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b,
-                              const v_reg<_Tp, n> &c) {
-  return v_fma(a, b, c);
-}
-
-/** @brief Dot product of elements
-
-Multiply values in two registers and sum adjacent result pairs.
-
-Scheme:
-@code
-  {A1 A2 ...} // 16-bit
-x {B1 B2 ...} // 16-bit
--------------
-{A1B1+A2B2 ...} // 32-bit
-
-@endcode
-*/
-template <typename _Tp, int n>
-inline v_reg<typename V_TypeTraits<_Tp>::w_type, n / 2>
-v_dotprod(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b) {
-  typedef typename V_TypeTraits<_Tp>::w_type w_type;
-  v_reg<w_type, n / 2> c;
-  for (int i = 0; i < (n / 2); i++)
-    c.s[i] = (w_type)a.s[i * 2] * b.s[i * 2] +
-             (w_type)a.s[i * 2 + 1] * b.s[i * 2 + 1];
-  return c;
-}
-
-/** @brief Dot product of elements
-
-Same as cv::v_dotprod, but add a third element to the sum of adjacent pairs.
-Scheme:
-@code
-  {A1 A2 ...} // 16-bit
-x {B1 B2 ...} // 16-bit
--------------
-  {A1B1+A2B2+C1 ...} // 32-bit
-@endcode
-*/
-template <typename _Tp, int n>
-inline v_reg<typename V_TypeTraits<_Tp>::w_type, n / 2>
-v_dotprod(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b,
-          const v_reg<typename V_TypeTraits<_Tp>::w_type, n / 2> &c) {
-  typedef typename V_TypeTraits<_Tp>::w_type w_type;
-  v_reg<w_type, n / 2> s;
-  for (int i = 0; i < (n / 2); i++)
-    s.s[i] = (w_type)a.s[i * 2] * b.s[i * 2] +
-             (w_type)a.s[i * 2 + 1] * b.s[i * 2 + 1] + c.s[i];
-  return s;
-}
-
-/** @brief Fast Dot product of elements
-
-Same as cv::v_dotprod, but it may perform unorder sum between result pairs in
-some platforms, this intrinsic can be used if the sum among all lanes is only
-matters and also it should be yielding better performance on the affected
-platforms.
-
-*/
-template <typename _Tp, int n>
-inline v_reg<typename V_TypeTraits<_Tp>::w_type, n / 2>
-v_dotprod_fast(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b) {
-  return v_dotprod(a, b);
-}
-
-/** @brief Fast Dot product of elements
-
-Same as cv::v_dotprod_fast, but add a third element to the sum of adjacent
-pairs.
-*/
-template <typename _Tp, int n>
-inline v_reg<typename V_TypeTraits<_Tp>::w_type, n / 2>
-v_dotprod_fast(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b,
-               const v_reg<typename V_TypeTraits<_Tp>::w_type, n / 2> &c) {
-  return v_dotprod(a, b, c);
-}
-
-/** @brief Dot product of elements and expand
-
-Multiply values in two registers and expand the sum of adjacent result pairs.
-
-Scheme:
-@code
-  {A1 A2 A3 A4 ...} // 8-bit
-x {B1 B2 B3 B4 ...} // 8-bit
--------------
-  {A1B1+A2B2+A3B3+A4B4 ...} // 32-bit
-
-@endcode
-*/
-template <typename _Tp, int n>
-inline v_reg<typename V_TypeTraits<_Tp>::q_type, n / 4>
-v_dotprod_expand(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b) {
-  typedef typename V_TypeTraits<_Tp>::q_type q_type;
-  v_reg<q_type, n / 4> s;
-  for (int i = 0; i < (n / 4); i++)
-    s.s[i] = (q_type)a.s[i * 4] * b.s[i * 4] +
-             (q_type)a.s[i * 4 + 1] * b.s[i * 4 + 1] +
-             (q_type)a.s[i * 4 + 2] * b.s[i * 4 + 2] +
-             (q_type)a.s[i * 4 + 3] * b.s[i * 4 + 3];
-  return s;
-}
-
-/** @brief Dot product of elements
-
-Same as cv::v_dotprod_expand, but add a third element to the sum of adjacent
-pairs. Scheme:
-@code
-  {A1 A2 A3 A4 ...} // 8-bit
-x {B1 B2 B3 B4 ...} // 8-bit
--------------
-  {A1B1+A2B2+A3B3+A4B4+C1 ...} // 32-bit
-@endcode
-*/
-template <typename _Tp, int n>
-inline v_reg<typename V_TypeTraits<_Tp>::q_type, n / 4>
-v_dotprod_expand(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b,
-                 const v_reg<typename V_TypeTraits<_Tp>::q_type, n / 4> &c) {
-  typedef typename V_TypeTraits<_Tp>::q_type q_type;
-  v_reg<q_type, n / 4> s;
-  for (int i = 0; i < (n / 4); i++)
-    s.s[i] = (q_type)a.s[i * 4] * b.s[i * 4] +
-             (q_type)a.s[i * 4 + 1] * b.s[i * 4 + 1] +
-             (q_type)a.s[i * 4 + 2] * b.s[i * 4 + 2] +
-             (q_type)a.s[i * 4 + 3] * b.s[i * 4 + 3] + c.s[i];
-  return s;
-}
-
-/** @brief Fast Dot product of elements and expand
-
-Multiply values in two registers and expand the sum of adjacent result pairs.
-
-Same as cv::v_dotprod_expand, but it may perform unorder sum between result
-pairs in some platforms, this intrinsic can be used if the sum among all lanes
-is only matters and also it should be yielding better performance on the
-affected platforms.
-
-*/
-template <typename _Tp, int n>
-inline v_reg<typename V_TypeTraits<_Tp>::q_type, n / 4>
-v_dotprod_expand_fast(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b) {
-  return v_dotprod_expand(a, b);
-}
-
-/** @brief Fast Dot product of elements
-
-Same as cv::v_dotprod_expand_fast, but add a third element to the sum of
-adjacent pairs.
-*/
-template <typename _Tp, int n>
-inline v_reg<typename V_TypeTraits<_Tp>::q_type, n / 4> v_dotprod_expand_fast(
-    const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b,
-    const v_reg<typename V_TypeTraits<_Tp>::q_type, n / 4> &c) {
-  return v_dotprod_expand(a, b, c);
-}
-
-/** @brief Multiply and expand
-
-Multiply values two registers and store results in two registers with wider pack
-type. Scheme:
-@code
-  {A B C D} // 32-bit
-x {E F G H} // 32-bit
----------------
-{AE BF}         // 64-bit
-        {CG DH} // 64-bit
-@endcode
-Example:
-@code{.cpp}
-v_uint32x4 a, b; // {1,2,3,4} and {2,2,2,2}
-v_uint64x2 c, d; // results
-v_mul_expand(a, b, c, d); // c, d = {2,4}, {6, 8}
-@endcode
-Implemented only for 16- and unsigned 32-bit source types (v_int16x8,
-v_uint16x8, v_uint32x4).
-*/
-template <typename _Tp, int n>
-inline void v_mul_expand(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b,
-                         v_reg<typename V_TypeTraits<_Tp>::w_type, n / 2> &c,
-                         v_reg<typename V_TypeTraits<_Tp>::w_type, n / 2> &d) {
-  typedef typename V_TypeTraits<_Tp>::w_type w_type;
-  for (int i = 0; i < (n / 2); i++) {
-    c.s[i] = (w_type)a.s[i] * b.s[i];
-    d.s[i] = (w_type)a.s[i + (n / 2)] * b.s[i + (n / 2)];
-  }
-}
-
-/** @brief Multiply and extract high part
-
-Multiply values two registers and store high part of the results.
-Implemented only for 16-bit source types (v_int16x8, v_uint16x8). Returns \f$
-a*b >> 16 \f$
-*/
-template <typename _Tp, int n>
-inline v_reg<_Tp, n> v_mul_hi(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b) {
-  typedef typename V_TypeTraits<_Tp>::w_type w_type;
-  v_reg<_Tp, n> c;
-  for (int i = 0; i < n; i++)
-    c.s[i] = (_Tp)(((w_type)a.s[i] * b.s[i]) >> sizeof(_Tp) * 8);
-  return c;
-}
-
-//! @cond IGNORED
-template <typename _Tp, int n>
-inline void v_hsum(const v_reg<_Tp, n> &a,
-                   v_reg<typename V_TypeTraits<_Tp>::w_type, n / 2> &c) {
-  typedef typename V_TypeTraits<_Tp>::w_type w_type;
-  for (int i = 0; i < (n / 2); i++) {
-    c.s[i] = (w_type)a.s[i * 2] + a.s[i * 2 + 1];
-  }
-}
-//! @endcond
-
-//! @brief Helper macro
-//! @ingroup core_hal_intrin_impl
-#define OPENCV_HAL_IMPL_SHIFT_OP(shift_op, func)                               \
-  template <typename _Tp, int n>                                               \
-  inline v_reg<_Tp, n> func(const v_reg<_Tp, n> &a, int imm) {                 \
-    v_reg<_Tp, n> c;                                                           \
-    for (int i = 0; i < n; i++)                                                \
-      c.s[i] = (_Tp)(a.s[i] shift_op imm);                                     \
-    return c;                                                                  \
-  }
-
-/** @brief Bitwise shift left
-
-For 16-, 32- and 64-bit integer values. */
-OPENCV_HAL_IMPL_SHIFT_OP(<<, v_shl)
-
-/** @brief Bitwise shift right
-
-For 16-, 32- and 64-bit integer values. */
-OPENCV_HAL_IMPL_SHIFT_OP(>>, v_shr)
-
-//! @brief Helper macro
-//! @ingroup core_hal_intrin_impl
-#define OPENCV_HAL_IMPL_ROTATE_SHIFT_OP(suffix, opA, opB)                      \
-  template <int imm, typename _Tp, int n>                                      \
-  inline v_reg<_Tp, n> v_rotate_##suffix(const v_reg<_Tp, n> &a) {             \
-    v_reg<_Tp, n> b;                                                           \
-    for (int i = 0; i < n; i++) {                                              \
-      int sIndex = i opA imm;                                                  \
-      if (0 <= sIndex && sIndex < n) {                                         \
-        b.s[i] = a.s[sIndex];                                                  \
-      } else {                                                                 \
-        b.s[i] = 0;                                                            \
-      }                                                                        \
-    }                                                                          \
-    return b;                                                                  \
-  }                                                                            \
-  template <int imm, typename _Tp, int n>                                      \
-  inline v_reg<_Tp, n> v_rotate_##suffix(const v_reg<_Tp, n> &a,               \
-                                         const v_reg<_Tp, n> &b) {             \
-    v_reg<_Tp, n> c;                                                           \
-    for (int i = 0; i < n; i++) {                                              \
-      int aIndex = i opA imm;                                                  \
-      int bIndex = i opA imm opB n;                                            \
-      if (0 <= bIndex && bIndex < n) {                                         \
-        c.s[i] = b.s[bIndex];                                                  \
-      } else if (0 <= aIndex && aIndex < n) {                                  \
-        c.s[i] = a.s[aIndex];                                                  \
-      } else {                                                                 \
-        c.s[i] = 0;                                                            \
-      }                                                                        \
-    }                                                                          \
-    return c;                                                                  \
-  }
-
-/** @brief Element shift left among vector
-
-For all type */
-OPENCV_HAL_IMPL_ROTATE_SHIFT_OP(left, -, +)
-
-/** @brief Element shift right among vector
-
-For all type */
-OPENCV_HAL_IMPL_ROTATE_SHIFT_OP(right, +, -)
-
-/** @brief Sum packed values
-
-Scheme:
-@code
-{A1 A2 A3 ...} => sum{A1,A2,A3,...}
-@endcode
-*/
-template <typename _Tp, int n>
-inline typename V_TypeTraits<_Tp>::sum_type
-v_reduce_sum(const v_reg<_Tp, n> &a) {
-  typename V_TypeTraits<_Tp>::sum_type c = a.s[0];
-  for (int i = 1; i < n; i++)
-    c += a.s[i];
-  return c;
-}
-
-/** @brief Sums all elements of each input vector, returns the vector of sums
-
- Scheme:
- @code
- result[0] = a[0] + a[1] + a[2] + a[3]
- result[1] = b[0] + b[1] + b[2] + b[3]
- result[2] = c[0] + c[1] + c[2] + c[3]
- result[3] = d[0] + d[1] + d[2] + d[3]
- @endcode
-*/
-template <int n>
-inline v_reg<float, n>
-v_reduce_sum4(const v_reg<float, n> &a, const v_reg<float, n> &b,
-              const v_reg<float, n> &c, const v_reg<float, n> &d) {
-  v_reg<float, n> r;
-  for (int i = 0; i < (n / 4); i++) {
-    r.s[i * 4 + 0] =
-        a.s[i * 4 + 0] + a.s[i * 4 + 1] + a.s[i * 4 + 2] + a.s[i * 4 + 3];
-    r.s[i * 4 + 1] =
-        b.s[i * 4 + 0] + b.s[i * 4 + 1] + b.s[i * 4 + 2] + b.s[i * 4 + 3];
-    r.s[i * 4 + 2] =
-        c.s[i * 4 + 0] + c.s[i * 4 + 1] + c.s[i * 4 + 2] + c.s[i * 4 + 3];
-    r.s[i * 4 + 3] =
-        d.s[i * 4 + 0] + d.s[i * 4 + 1] + d.s[i * 4 + 2] + d.s[i * 4 + 3];
-  }
-  return r;
-}
-
-/** @brief Sum absolute differences of values
-
-Scheme:
-@code
-{A1 A2 A3 ...} {B1 B2 B3 ...} => sum{ABS(A1-B1),abs(A2-B2),abs(A3-B3),...}
-@endcode
-For all types except 64-bit types.*/
-template <typename _Tp, int n>
-inline typename V_TypeTraits<typename V_TypeTraits<_Tp>::abs_type>::sum_type
-v_reduce_sad(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b) {
-  typename V_TypeTraits<typename V_TypeTraits<_Tp>::abs_type>::sum_type c =
-      _absdiff(a.s[0], b.s[0]);
-  for (int i = 1; i < n; i++)
-    c += _absdiff(a.s[i], b.s[i]);
-  return c;
-}
-
-/** @brief Get negative values mask
-@deprecated v_signmask depends on a lane count heavily and therefore isn't
-universal enough
-
-Returned value is a bit mask with bits set to 1 on places corresponding to
-negative packed values indexes. Example:
-@code{.cpp}
-v_int32x4 r; // set to {-1, -1, 1, 1}
-int mask = v_signmask(r); // mask = 3 <== 00000000 00000000 00000000 00000011
-@endcode
-*/
-template <typename _Tp, int n> inline int v_signmask(const v_reg<_Tp, n> &a) {
-  int mask = 0;
-  for (int i = 0; i < n; i++)
-    mask |= (V_TypeTraits<_Tp>::reinterpret_int(a.s[i]) < 0) << i;
-  return mask;
-}
-
-/** @brief Get first negative lane index
-
-Returned value is an index of first negative lane (undefined for input of all
-positive values) Example:
-@code{.cpp}
-v_int32x4 r; // set to {0, 0, -1, -1}
-int idx = v_heading_zeros(r); // idx = 2
-@endcode
-*/
-template <typename _Tp, int n>
-inline int v_scan_forward(const v_reg<_Tp, n> &a) {
-  for (int i = 0; i < n; i++)
-    if (V_TypeTraits<_Tp>::reinterpret_int(a.s[i]) < 0)
-      return i;
-  return 0;
-}
-
-/** @brief Check if all packed values are less than zero
-
-Unsigned values will be casted to signed: `uchar 254 => char -2`.
-*/
-template <typename _Tp, int n> inline bool v_check_all(const v_reg<_Tp, n> &a) {
-  for (int i = 0; i < n; i++)
-    if (V_TypeTraits<_Tp>::reinterpret_int(a.s[i]) >= 0)
-      return false;
-  return true;
-}
-
-/** @brief Check if any of packed values is less than zero
-
-Unsigned values will be casted to signed: `uchar 254 => char -2`.
-*/
-template <typename _Tp, int n> inline bool v_check_any(const v_reg<_Tp, n> &a) {
-  for (int i = 0; i < n; i++)
-    if (V_TypeTraits<_Tp>::reinterpret_int(a.s[i]) < 0)
-      return true;
-  return false;
-}
-
-/** @brief Per-element select (blend operation)
-
-Return value will be built by combining values _a_ and _b_ using the following
-scheme: result[i] = mask[i] ? a[i] : b[i];
-
-@note: _mask_ element values are restricted to these values:
-- 0: select element from _b_
-- 0xff/0xffff/etc: select element from _a_
-(fully compatible with bitwise-based operator)
-*/
-template <typename _Tp, int n>
-inline v_reg<_Tp, n> v_select(const v_reg<_Tp, n> &mask, const v_reg<_Tp, n> &a,
-                              const v_reg<_Tp, n> &b) {
-  typedef V_TypeTraits<_Tp> Traits;
-  typedef typename Traits::int_type int_type;
-  v_reg<_Tp, n> c;
-  for (int i = 0; i < n; i++) {
-    int_type m = Traits::reinterpret_int(mask.s[i]);
-    CV_DbgAssert(
-        m == 0 ||
-        m == (~(int_type)0)); // restrict mask values: 0 or 0xff/0xffff/etc
-    c.s[i] = m ? a.s[i] : b.s[i];
-  }
-  return c;
-}
-
-/** @brief Expand values to the wider pack type
-
-Copy contents of register to two registers with 2x wider pack type.
-Scheme:
-@code
- int32x4     int64x2 int64x2
-{A B C D} ==> {A B} , {C D}
-@endcode */
-template <typename _Tp, int n>
-inline void v_expand(const v_reg<_Tp, n> &a,
-                     v_reg<typename V_TypeTraits<_Tp>::w_type, n / 2> &b0,
-                     v_reg<typename V_TypeTraits<_Tp>::w_type, n / 2> &b1) {
-  for (int i = 0; i < (n / 2); i++) {
-    b0.s[i] = a.s[i];
-    b1.s[i] = a.s[i + (n / 2)];
-  }
-}
-
-/** @brief Expand lower values to the wider pack type
-
-Same as cv::v_expand, but return lower half of the vector.
-
-Scheme:
-@code
- int32x4     int64x2
-{A B C D} ==> {A B}
-@endcode */
-template <typename _Tp, int n>
-inline v_reg<typename V_TypeTraits<_Tp>::w_type, n / 2>
-v_expand_low(const v_reg<_Tp, n> &a) {
-  v_reg<typename V_TypeTraits<_Tp>::w_type, n / 2> b;
-  for (int i = 0; i < (n / 2); i++)
-    b.s[i] = a.s[i];
-  return b;
-}
-
-/** @brief Expand higher values to the wider pack type
-
-Same as cv::v_expand_low, but expand higher half of the vector instead.
-
-Scheme:
-@code
- int32x4     int64x2
-{A B C D} ==> {C D}
-@endcode */
-template <typename _Tp, int n>
-inline v_reg<typename V_TypeTraits<_Tp>::w_type, n / 2>
-v_expand_high(const v_reg<_Tp, n> &a) {
-  v_reg<typename V_TypeTraits<_Tp>::w_type, n / 2> b;
-  for (int i = 0; i < (n / 2); i++)
-    b.s[i] = a.s[i + (n / 2)];
-  return b;
-}
-
-//! @cond IGNORED
-template <typename _Tp, int n>
-inline v_reg<typename V_TypeTraits<_Tp>::int_type, n>
-v_reinterpret_as_int(const v_reg<_Tp, n> &a) {
-  v_reg<typename V_TypeTraits<_Tp>::int_type, n> c;
-  for (int i = 0; i < n; i++)
-    c.s[i] = V_TypeTraits<_Tp>::reinterpret_int(a.s[i]);
-  return c;
-}
-
-template <typename _Tp, int n>
-inline v_reg<typename V_TypeTraits<_Tp>::uint_type, n>
-v_reinterpret_as_uint(const v_reg<_Tp, n> &a) {
-  v_reg<typename V_TypeTraits<_Tp>::uint_type, n> c;
-  for (int i = 0; i < n; i++)
-    c.s[i] = V_TypeTraits<_Tp>::reinterpret_uint(a.s[i]);
-  return c;
-}
-//! @endcond
-
-/** @brief Interleave two vectors
-
-Scheme:
-@code
-  {A1 A2 A3 A4}
-  {B1 B2 B3 B4}
----------------
-  {A1 B1 A2 B2} and {A3 B3 A4 B4}
-@endcode
-For all types except 64-bit.
-*/
-template <typename _Tp, int n>
-inline void v_zip(const v_reg<_Tp, n> &a0, const v_reg<_Tp, n> &a1,
-                  v_reg<_Tp, n> &b0, v_reg<_Tp, n> &b1) {
-  int i;
-  for (i = 0; i < n / 2; i++) {
-    b0.s[i * 2] = a0.s[i];
-    b0.s[i * 2 + 1] = a1.s[i];
-  }
-  for (; i < n; i++) {
-    b1.s[i * 2 - n] = a0.s[i];
-    b1.s[i * 2 - n + 1] = a1.s[i];
-  }
-}
-
-/** @brief Load register contents from memory
-
-@param ptr pointer to memory block with data
-@return register object
-
-@note Returned type will be detected from passed pointer type, for example uchar
-==> cv::v_uint8x16, int ==> cv::v_int32x4, etc.
-
-@note Use vx_load version to get maximum available register length result
-
-@note Alignment requirement:
-if CV_STRONG_ALIGNMENT=1 then passed pointer must be aligned (`sizeof(lane
-type)` should be enough). Do not cast pointer types without runtime check for
-pointer alignment (like `uchar*` => `int*`).
- */
-template <typename _Tp>
-inline v_reg<_Tp, simd128_width / sizeof(_Tp)> v_load(const _Tp *ptr) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(ptr));
-#endif
-  return v_reg<_Tp, simd128_width / sizeof(_Tp)>(ptr);
-}
-
-#if CV_SIMD256
-/** @brief Load 256-bit length register contents from memory
-
-@param ptr pointer to memory block with data
-@return register object
-
-@note Returned type will be detected from passed pointer type, for example uchar
-==> cv::v_uint8x32, int ==> cv::v_int32x8, etc.
-
-@note Check CV_SIMD256 preprocessor definition prior to use.
-Use vx_load version to get maximum available register length result
-
-@note Alignment requirement:
-if CV_STRONG_ALIGNMENT=1 then passed pointer must be aligned (`sizeof(lane
-type)` should be enough). Do not cast pointer types without runtime check for
-pointer alignment (like `uchar*` => `int*`).
- */
-template <typename _Tp>
-inline v_reg<_Tp, simd256_width / sizeof(_Tp)> v256_load(const _Tp *ptr) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(ptr));
-#endif
-  return v_reg<_Tp, simd256_width / sizeof(_Tp)>(ptr);
-}
-#endif
-
-#if CV_SIMD512
-/** @brief Load 512-bit length register contents from memory
-
-@param ptr pointer to memory block with data
-@return register object
-
-@note Returned type will be detected from passed pointer type, for example uchar
-==> cv::v_uint8x64, int ==> cv::v_int32x16, etc.
-
-@note Check CV_SIMD512 preprocessor definition prior to use.
-Use vx_load version to get maximum available register length result
-
-@note Alignment requirement:
-if CV_STRONG_ALIGNMENT=1 then passed pointer must be aligned (`sizeof(lane
-type)` should be enough). Do not cast pointer types without runtime check for
-pointer alignment (like `uchar*` => `int*`).
- */
-template <typename _Tp>
-inline v_reg<_Tp, simd512_width / sizeof(_Tp)> v512_load(const _Tp *ptr) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(ptr));
-#endif
-  return v_reg<_Tp, simd512_width / sizeof(_Tp)>(ptr);
-}
-#endif
-
-/** @brief Load register contents from memory (aligned)
-
-similar to cv::v_load, but source memory block should be aligned (to 16-byte
-boundary in case of SIMD128, 32-byte - SIMD256, etc)
-
-@note Use vx_load_aligned version to get maximum available register length
-result
-*/
-template <typename _Tp>
-inline v_reg<_Tp, simd128_width / sizeof(_Tp)> v_load_aligned(const _Tp *ptr) {
-  CV_Assert(isAligned<sizeof(v_reg<_Tp, simd128_width / sizeof(_Tp)>)>(ptr));
-  return v_reg<_Tp, simd128_width / sizeof(_Tp)>(ptr);
-}
-
-#if CV_SIMD256
-/** @brief Load register contents from memory (aligned)
-
-similar to cv::v256_load, but source memory block should be aligned (to 32-byte
-boundary in case of SIMD256, 64-byte - SIMD512, etc)
-
-@note Check CV_SIMD256 preprocessor definition prior to use.
-Use vx_load_aligned version to get maximum available register length result
-*/
-template <typename _Tp>
-inline v_reg<_Tp, simd256_width / sizeof(_Tp)>
-v256_load_aligned(const _Tp *ptr) {
-  CV_Assert(isAligned<sizeof(v_reg<_Tp, simd256_width / sizeof(_Tp)>)>(ptr));
-  return v_reg<_Tp, simd256_width / sizeof(_Tp)>(ptr);
-}
-#endif
-
-#if CV_SIMD512
-/** @brief Load register contents from memory (aligned)
-
-similar to cv::v512_load, but source memory block should be aligned (to 64-byte
-boundary in case of SIMD512, etc)
-
-@note Check CV_SIMD512 preprocessor definition prior to use.
-Use vx_load_aligned version to get maximum available register length result
-*/
-template <typename _Tp>
-inline v_reg<_Tp, simd512_width / sizeof(_Tp)>
-v512_load_aligned(const _Tp *ptr) {
-  CV_Assert(isAligned<sizeof(v_reg<_Tp, simd512_width / sizeof(_Tp)>)>(ptr));
-  return v_reg<_Tp, simd512_width / sizeof(_Tp)>(ptr);
-}
-#endif
-
-/** @brief Load 64-bits of data to lower part (high part is undefined).
-
-@param ptr memory block containing data for first half (0..n/2)
-
-@code{.cpp}
-int lo[2] = { 1, 2 };
-v_int32x4 r = v_load_low(lo);
-@endcode
-
-@note Use vx_load_low version to get maximum available register length result
-*/
-template <typename _Tp>
-inline v_reg<_Tp, simd128_width / sizeof(_Tp)> v_load_low(const _Tp *ptr) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(ptr));
-#endif
-  v_reg<_Tp, simd128_width / sizeof(_Tp)> c;
-  for (int i = 0; i < c.nlanes / 2; i++) {
-    c.s[i] = ptr[i];
-  }
-  return c;
-}
-
-#if CV_SIMD256
-/** @brief Load 128-bits of data to lower part (high part is undefined).
-
-@param ptr memory block containing data for first half (0..n/2)
-
-@code{.cpp}
-int lo[4] = { 1, 2, 3, 4 };
-v_int32x8 r = v256_load_low(lo);
-@endcode
-
-@note Check CV_SIMD256 preprocessor definition prior to use.
-Use vx_load_low version to get maximum available register length result
-*/
-template <typename _Tp>
-inline v_reg<_Tp, simd256_width / sizeof(_Tp)> v256_load_low(const _Tp *ptr) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(ptr));
-#endif
-  v_reg<_Tp, simd256_width / sizeof(_Tp)> c;
-  for (int i = 0; i < c.nlanes / 2; i++) {
-    c.s[i] = ptr[i];
-  }
-  return c;
-}
-#endif
-
-#if CV_SIMD512
-/** @brief Load 256-bits of data to lower part (high part is undefined).
-
-@param ptr memory block containing data for first half (0..n/2)
-
-@code{.cpp}
-int lo[8] = { 1, 2, 3, 4, 5, 6, 7, 8 };
-v_int32x16 r = v512_load_low(lo);
-@endcode
-
-@note Check CV_SIMD512 preprocessor definition prior to use.
-Use vx_load_low version to get maximum available register length result
-*/
-template <typename _Tp>
-inline v_reg<_Tp, simd512_width / sizeof(_Tp)> v512_load_low(const _Tp *ptr) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(ptr));
-#endif
-  v_reg<_Tp, simd512_width / sizeof(_Tp)> c;
-  for (int i = 0; i < c.nlanes / 2; i++) {
-    c.s[i] = ptr[i];
-  }
-  return c;
-}
-#endif
-
-/** @brief Load register contents from two memory blocks
-
-@param loptr memory block containing data for first half (0..n/2)
-@param hiptr memory block containing data for second half (n/2..n)
-
-@code{.cpp}
-int lo[2] = { 1, 2 }, hi[2] = { 3, 4 };
-v_int32x4 r = v_load_halves(lo, hi);
-@endcode
-
-@note Use vx_load_halves version to get maximum available register length result
-*/
-template <typename _Tp>
-inline v_reg<_Tp, simd128_width / sizeof(_Tp)> v_load_halves(const _Tp *loptr,
-                                                             const _Tp *hiptr) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(loptr));
-  CV_Assert(isAligned<sizeof(_Tp)>(hiptr));
-#endif
-  v_reg<_Tp, simd128_width / sizeof(_Tp)> c;
-  for (int i = 0; i < c.nlanes / 2; i++) {
-    c.s[i] = loptr[i];
-    c.s[i + c.nlanes / 2] = hiptr[i];
-  }
-  return c;
-}
-
-#if CV_SIMD256
-/** @brief Load register contents from two memory blocks
-
-@param loptr memory block containing data for first half (0..n/2)
-@param hiptr memory block containing data for second half (n/2..n)
-
-@code{.cpp}
-int lo[4] = { 1, 2, 3, 4 }, hi[4] = { 5, 6, 7, 8 };
-v_int32x8 r = v256_load_halves(lo, hi);
-@endcode
-
-@note Check CV_SIMD256 preprocessor definition prior to use.
-Use vx_load_halves version to get maximum available register length result
-*/
-template <typename _Tp>
-inline v_reg<_Tp, simd256_width / sizeof(_Tp)>
-v256_load_halves(const _Tp *loptr, const _Tp *hiptr) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(loptr));
-  CV_Assert(isAligned<sizeof(_Tp)>(hiptr));
-#endif
-  v_reg<_Tp, simd256_width / sizeof(_Tp)> c;
-  for (int i = 0; i < c.nlanes / 2; i++) {
-    c.s[i] = loptr[i];
-    c.s[i + c.nlanes / 2] = hiptr[i];
-  }
-  return c;
-}
-#endif
-
-#if CV_SIMD512
-/** @brief Load register contents from two memory blocks
-
-@param loptr memory block containing data for first half (0..n/2)
-@param hiptr memory block containing data for second half (n/2..n)
-
-@code{.cpp}
-int lo[4] = { 1, 2, 3, 4, 5, 6, 7, 8 }, hi[4] = { 9, 10, 11, 12, 13, 14, 15, 16
-}; v_int32x16 r = v512_load_halves(lo, hi);
-@endcode
-
-@note Check CV_SIMD512 preprocessor definition prior to use.
-Use vx_load_halves version to get maximum available register length result
-*/
-template <typename _Tp>
-inline v_reg<_Tp, simd512_width / sizeof(_Tp)>
-v512_load_halves(const _Tp *loptr, const _Tp *hiptr) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(loptr));
-  CV_Assert(isAligned<sizeof(_Tp)>(hiptr));
-#endif
-  v_reg<_Tp, simd512_width / sizeof(_Tp)> c;
-  for (int i = 0; i < c.nlanes / 2; i++) {
-    c.s[i] = loptr[i];
-    c.s[i + c.nlanes / 2] = hiptr[i];
-  }
-  return c;
-}
-#endif
-
-/** @brief Load register contents from memory with double expand
-
-Same as cv::v_load, but result pack type will be 2x wider than memory type.
-
-@code{.cpp}
-short buf[4] = {1, 2, 3, 4}; // type is int16
-v_int32x4 r = v_load_expand(buf); // r = {1, 2, 3, 4} - type is int32
-@endcode
-For 8-, 16-, 32-bit integer source types.
-
-@note Use vx_load_expand version to get maximum available register length result
-*/
-template <typename _Tp>
-inline v_reg<typename V_TypeTraits<_Tp>::w_type,
-             simd128_width / sizeof(typename V_TypeTraits<_Tp>::w_type)>
-v_load_expand(const _Tp *ptr) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(ptr));
-#endif
-  typedef typename V_TypeTraits<_Tp>::w_type w_type;
-  v_reg<w_type, simd128_width / sizeof(w_type)> c;
-  for (int i = 0; i < c.nlanes; i++) {
-    c.s[i] = ptr[i];
-  }
-  return c;
-}
-
-#if CV_SIMD256
-/** @brief Load register contents from memory with double expand
-
-Same as cv::v256_load, but result pack type will be 2x wider than memory type.
-
-@code{.cpp}
-short buf[8] = {1, 2, 3, 4, 5, 6, 7, 8}; // type is int16
-v_int32x8 r = v256_load_expand(buf); // r = {1, 2, 3, 4, 5, 6, 7, 8} - type is
-int32
-@endcode
-For 8-, 16-, 32-bit integer source types.
-
-@note Check CV_SIMD256 preprocessor definition prior to use.
-Use vx_load_expand version to get maximum available register length result
-*/
-template <typename _Tp>
-inline v_reg<typename V_TypeTraits<_Tp>::w_type,
-             simd256_width / sizeof(typename V_TypeTraits<_Tp>::w_type)>
-v256_load_expand(const _Tp *ptr) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(ptr));
-#endif
-  typedef typename V_TypeTraits<_Tp>::w_type w_type;
-  v_reg<w_type, simd256_width / sizeof(w_type)> c;
-  for (int i = 0; i < c.nlanes; i++) {
-    c.s[i] = ptr[i];
-  }
-  return c;
-}
-#endif
-
-#if CV_SIMD512
-/** @brief Load register contents from memory with double expand
-
-Same as cv::v512_load, but result pack type will be 2x wider than memory type.
-
-@code{.cpp}
-short buf[8] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}; // type
-is int16 v_int32x16 r = v512_load_expand(buf); // r = {1, 2, 3, 4, 5, 6, 7, 8,
-9, 10, 11, 12, 13, 14, 15, 16} - type is int32
-@endcode
-For 8-, 16-, 32-bit integer source types.
-
-@note Check CV_SIMD512 preprocessor definition prior to use.
-Use vx_load_expand version to get maximum available register length result
-*/
-template <typename _Tp>
-inline v_reg<typename V_TypeTraits<_Tp>::w_type,
-             simd512_width / sizeof(typename V_TypeTraits<_Tp>::w_type)>
-v512_load_expand(const _Tp *ptr) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(ptr));
-#endif
-  typedef typename V_TypeTraits<_Tp>::w_type w_type;
-  v_reg<w_type, simd512_width / sizeof(w_type)> c;
-  for (int i = 0; i < c.nlanes; i++) {
-    c.s[i] = ptr[i];
-  }
-  return c;
-}
-#endif
-
-/** @brief Load register contents from memory with quad expand
-
-Same as cv::v_load_expand, but result type is 4 times wider than source.
-@code{.cpp}
-char buf[4] = {1, 2, 3, 4}; // type is int8
-v_int32x4 r = v_load_expand_q(buf); // r = {1, 2, 3, 4} - type is int32
-@endcode
-For 8-bit integer source types.
-
-@note Use vx_load_expand_q version to get maximum available register length
-result
-*/
-template <typename _Tp>
-inline v_reg<typename V_TypeTraits<_Tp>::q_type,
-             simd128_width / sizeof(typename V_TypeTraits<_Tp>::q_type)>
-v_load_expand_q(const _Tp *ptr) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(ptr));
-#endif
-  typedef typename V_TypeTraits<_Tp>::q_type q_type;
-  v_reg<q_type, simd128_width / sizeof(q_type)> c;
-  for (int i = 0; i < c.nlanes; i++) {
-    c.s[i] = ptr[i];
-  }
-  return c;
-}
-
-#if CV_SIMD256
-/** @brief Load register contents from memory with quad expand
-
-Same as cv::v256_load_expand, but result type is 4 times wider than source.
-@code{.cpp}
-char buf[8] = {1, 2, 3, 4, 5, 6, 7, 8}; // type is int8
-v_int32x8 r = v256_load_expand_q(buf); // r = {1, 2, 3, 4, 5, 6, 7, 8} - type is
-int32
-@endcode
-For 8-bit integer source types.
-
-@note Check CV_SIMD256 preprocessor definition prior to use.
-Use vx_load_expand_q version to get maximum available register length result
-*/
-template <typename _Tp>
-inline v_reg<typename V_TypeTraits<_Tp>::q_type,
-             simd256_width / sizeof(typename V_TypeTraits<_Tp>::q_type)>
-v256_load_expand_q(const _Tp *ptr) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(ptr));
-#endif
-  typedef typename V_TypeTraits<_Tp>::q_type q_type;
-  v_reg<q_type, simd256_width / sizeof(q_type)> c;
-  for (int i = 0; i < c.nlanes; i++) {
-    c.s[i] = ptr[i];
-  }
-  return c;
-}
-#endif
-
-#if CV_SIMD512
-/** @brief Load register contents from memory with quad expand
-
-Same as cv::v512_load_expand, but result type is 4 times wider than source.
-@code{.cpp}
-char buf[16] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}; // type
-is int8 v_int32x16 r = v512_load_expand_q(buf); // r = {1, 2, 3, 4, 5, 6, 7, 8,
-9, 10, 11, 12, 13, 14, 15, 16} - type is int32
-@endcode
-For 8-bit integer source types.
-
-@note Check CV_SIMD512 preprocessor definition prior to use.
-Use vx_load_expand_q version to get maximum available register length result
-*/
-template <typename _Tp>
-inline v_reg<typename V_TypeTraits<_Tp>::q_type,
-             simd512_width / sizeof(typename V_TypeTraits<_Tp>::q_type)>
-v512_load_expand_q(const _Tp *ptr) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(ptr));
-#endif
-  typedef typename V_TypeTraits<_Tp>::q_type q_type;
-  v_reg<q_type, simd512_width / sizeof(q_type)> c;
-  for (int i = 0; i < c.nlanes; i++) {
-    c.s[i] = ptr[i];
-  }
-  return c;
-}
-#endif
-
-/** @brief Load and deinterleave (2 channels)
-
-Load data from memory deinterleave and store to 2 registers.
-Scheme:
-@code
-{A1 B1 A2 B2 ...} ==> {A1 A2 ...}, {B1 B2 ...}
-@endcode
-For all types except 64-bit. */
-template <typename _Tp, int n>
-inline void v_load_deinterleave(const _Tp *ptr, v_reg<_Tp, n> &a,
-                                v_reg<_Tp, n> &b) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(ptr));
-#endif
-  int i, i2;
-  for (i = i2 = 0; i < n; i++, i2 += 2) {
-    a.s[i] = ptr[i2];
-    b.s[i] = ptr[i2 + 1];
-  }
-}
-
-/** @brief Load and deinterleave (3 channels)
-
-Load data from memory deinterleave and store to 3 registers.
-Scheme:
-@code
-{A1 B1 C1 A2 B2 C2 ...} ==> {A1 A2 ...}, {B1 B2 ...}, {C1 C2 ...}
-@endcode
-For all types except 64-bit. */
-template <typename _Tp, int n>
-inline void v_load_deinterleave(const _Tp *ptr, v_reg<_Tp, n> &a,
-                                v_reg<_Tp, n> &b, v_reg<_Tp, n> &c) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(ptr));
-#endif
-  int i, i3;
-  for (i = i3 = 0; i < n; i++, i3 += 3) {
-    a.s[i] = ptr[i3];
-    b.s[i] = ptr[i3 + 1];
-    c.s[i] = ptr[i3 + 2];
-  }
-}
-
-/** @brief Load and deinterleave (4 channels)
-
-Load data from memory deinterleave and store to 4 registers.
-Scheme:
-@code
-{A1 B1 C1 D1 A2 B2 C2 D2 ...} ==> {A1 A2 ...}, {B1 B2 ...}, {C1 C2 ...}, {D1 D2
-...}
-@endcode
-For all types except 64-bit. */
-template <typename _Tp, int n>
-inline void v_load_deinterleave(const _Tp *ptr, v_reg<_Tp, n> &a,
-                                v_reg<_Tp, n> &b, v_reg<_Tp, n> &c,
-                                v_reg<_Tp, n> &d) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(ptr));
-#endif
-  int i, i4;
-  for (i = i4 = 0; i < n; i++, i4 += 4) {
-    a.s[i] = ptr[i4];
-    b.s[i] = ptr[i4 + 1];
-    c.s[i] = ptr[i4 + 2];
-    d.s[i] = ptr[i4 + 3];
-  }
-}
-
-/** @brief Interleave and store (2 channels)
-
-Interleave and store data from 2 registers to memory.
-Scheme:
-@code
-{A1 A2 ...}, {B1 B2 ...} ==> {A1 B1 A2 B2 ...}
-@endcode
-For all types except 64-bit. */
-template <typename _Tp, int n>
-inline void v_store_interleave(_Tp *ptr, const v_reg<_Tp, n> &a,
-                               const v_reg<_Tp, n> &b,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(ptr));
-#endif
-  int i, i2;
-  for (i = i2 = 0; i < n; i++, i2 += 2) {
-    ptr[i2] = a.s[i];
-    ptr[i2 + 1] = b.s[i];
-  }
-}
-
-/** @brief Interleave and store (3 channels)
-
-Interleave and store data from 3 registers to memory.
-Scheme:
-@code
-{A1 A2 ...}, {B1 B2 ...}, {C1 C2 ...} ==> {A1 B1 C1 A2 B2 C2 ...}
-@endcode
-For all types except 64-bit. */
-template <typename _Tp, int n>
-inline void v_store_interleave(_Tp *ptr, const v_reg<_Tp, n> &a,
-                               const v_reg<_Tp, n> &b, const v_reg<_Tp, n> &c,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(ptr));
-#endif
-  int i, i3;
-  for (i = i3 = 0; i < n; i++, i3 += 3) {
-    ptr[i3] = a.s[i];
-    ptr[i3 + 1] = b.s[i];
-    ptr[i3 + 2] = c.s[i];
-  }
-}
-
-/** @brief Interleave and store (4 channels)
-
-Interleave and store data from 4 registers to memory.
-Scheme:
-@code
-{A1 A2 ...}, {B1 B2 ...}, {C1 C2 ...}, {D1 D2 ...} ==> {A1 B1 C1 D1 A2 B2 C2 D2
-...}
-@endcode
-For all types except 64-bit. */
-template <typename _Tp, int n>
-inline void v_store_interleave(_Tp *ptr, const v_reg<_Tp, n> &a,
-                               const v_reg<_Tp, n> &b, const v_reg<_Tp, n> &c,
-                               const v_reg<_Tp, n> &d,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(ptr));
-#endif
-  int i, i4;
-  for (i = i4 = 0; i < n; i++, i4 += 4) {
-    ptr[i4] = a.s[i];
-    ptr[i4 + 1] = b.s[i];
-    ptr[i4 + 2] = c.s[i];
-    ptr[i4 + 3] = d.s[i];
-  }
-}
-
-/** @brief Store data to memory
-
-Store register contents to memory.
-Scheme:
-@code
-  REG {A B C D} ==> MEM {A B C D}
-@endcode
-Pointer can be unaligned. */
-template <typename _Tp, int n>
-inline void v_store(_Tp *ptr, const v_reg<_Tp, n> &a) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(ptr));
-#endif
-  for (int i = 0; i < n; i++)
-    ptr[i] = a.s[i];
-}
-
-template <typename _Tp, int n>
-inline void v_store(_Tp *ptr, const v_reg<_Tp, n> &a, hal::StoreMode /*mode*/) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(ptr));
-#endif
-  v_store(ptr, a);
-}
-
-/** @brief Store data to memory (lower half)
-
-Store lower half of register contents to memory.
-Scheme:
-@code
-  REG {A B C D} ==> MEM {A B}
-@endcode */
-template <typename _Tp, int n>
-inline void v_store_low(_Tp *ptr, const v_reg<_Tp, n> &a) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(ptr));
-#endif
-  for (int i = 0; i < (n / 2); i++)
-    ptr[i] = a.s[i];
-}
-
-/** @brief Store data to memory (higher half)
-
-Store higher half of register contents to memory.
-Scheme:
-@code
-  REG {A B C D} ==> MEM {C D}
-@endcode */
-template <typename _Tp, int n>
-inline void v_store_high(_Tp *ptr, const v_reg<_Tp, n> &a) {
-#if CV_STRONG_ALIGNMENT
-  CV_Assert(isAligned<sizeof(_Tp)>(ptr));
-#endif
-  for (int i = 0; i < (n / 2); i++)
-    ptr[i] = a.s[i + (n / 2)];
-}
-
-/** @brief Store data to memory (aligned)
-
-Store register contents to memory.
-Scheme:
-@code
-  REG {A B C D} ==> MEM {A B C D}
-@endcode
-Pointer __should__ be aligned by 16-byte boundary. */
-template <typename _Tp, int n>
-inline void v_store_aligned(_Tp *ptr, const v_reg<_Tp, n> &a) {
-  CV_Assert(isAligned<sizeof(v_reg<_Tp, n>)>(ptr));
-  v_store(ptr, a);
-}
-
-template <typename _Tp, int n>
-inline void v_store_aligned_nocache(_Tp *ptr, const v_reg<_Tp, n> &a) {
-  CV_Assert(isAligned<sizeof(v_reg<_Tp, n>)>(ptr));
-  v_store(ptr, a);
-}
-
-template <typename _Tp, int n>
-inline void v_store_aligned(_Tp *ptr, const v_reg<_Tp, n> &a,
-                            hal::StoreMode /*mode*/) {
-  CV_Assert(isAligned<sizeof(v_reg<_Tp, n>)>(ptr));
-  v_store(ptr, a);
-}
-
-/** @brief Combine vector from first elements of two vectors
-
-Scheme:
-@code
-  {A1 A2 A3 A4}
-  {B1 B2 B3 B4}
----------------
-  {A1 A2 B1 B2}
-@endcode
-For all types except 64-bit. */
-template <typename _Tp, int n>
-inline v_reg<_Tp, n> v_combine_low(const v_reg<_Tp, n> &a,
-                                   const v_reg<_Tp, n> &b) {
-  v_reg<_Tp, n> c;
-  for (int i = 0; i < (n / 2); i++) {
-    c.s[i] = a.s[i];
-    c.s[i + (n / 2)] = b.s[i];
-  }
-  return c;
-}
-
-/** @brief Combine vector from last elements of two vectors
-
-Scheme:
-@code
-  {A1 A2 A3 A4}
-  {B1 B2 B3 B4}
----------------
-  {A3 A4 B3 B4}
-@endcode
-For all types except 64-bit. */
-template <typename _Tp, int n>
-inline v_reg<_Tp, n> v_combine_high(const v_reg<_Tp, n> &a,
-                                    const v_reg<_Tp, n> &b) {
-  v_reg<_Tp, n> c;
-  for (int i = 0; i < (n / 2); i++) {
-    c.s[i] = a.s[i + (n / 2)];
-    c.s[i + (n / 2)] = b.s[i + (n / 2)];
-  }
-  return c;
-}
-
-/** @brief Combine two vectors from lower and higher parts of two other vectors
-
-@code{.cpp}
-low = cv::v_combine_low(a, b);
-high = cv::v_combine_high(a, b);
-@endcode */
-template <typename _Tp, int n>
-inline void v_recombine(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b,
-                        v_reg<_Tp, n> &low, v_reg<_Tp, n> &high) {
-  for (int i = 0; i < (n / 2); i++) {
-    low.s[i] = a.s[i];
-    low.s[i + (n / 2)] = b.s[i];
-    high.s[i] = a.s[i + (n / 2)];
-    high.s[i + (n / 2)] = b.s[i + (n / 2)];
-  }
-}
-
-/** @brief Vector reverse order
-
-Reverse the order of the vector
-Scheme:
-@code
-  REG {A1 ... An} ==> REG {An ... A1}
-@endcode
-For all types. */
-template <typename _Tp, int n>
-inline v_reg<_Tp, n> v_reverse(const v_reg<_Tp, n> &a) {
-  v_reg<_Tp, n> c;
-  for (int i = 0; i < n; i++)
-    c.s[i] = a.s[n - i - 1];
-  return c;
-}
-
-/** @brief Vector extract
-
-Scheme:
-@code
-  {A1 A2 A3 A4}
-  {B1 B2 B3 B4}
-========================
-shift = 1  {A2 A3 A4 B1}
-shift = 2  {A3 A4 B1 B2}
-shift = 3  {A4 B1 B2 B3}
-@endcode
-Restriction: 0 <= shift < nlanes
-
-Usage:
-@code
-v_int32x4 a, b, c;
-c = v_extract<2>(a, b);
-@endcode
-For all types. */
-template <int s, typename _Tp, int n>
-inline v_reg<_Tp, n> v_extract(const v_reg<_Tp, n> &a, const v_reg<_Tp, n> &b) {
-  v_reg<_Tp, n> r;
-  const int shift = n - s;
-  int i = 0;
-  for (; i < shift; ++i)
-    r.s[i] = a.s[i + s];
-  for (; i < n; ++i)
-    r.s[i] = b.s[i - shift];
-  return r;
-}
-
-/** @brief Vector extract
-
-Scheme:
-Return the s-th element of v.
-Restriction: 0 <= s < nlanes
-
-Usage:
-@code
-v_int32x4 a;
-int r;
-r = v_extract_n<2>(a);
-@endcode
-For all types. */
-template <int s, typename _Tp, int n>
-inline _Tp v_extract_n(const v_reg<_Tp, n> &v) {
-  CV_DbgAssert(s >= 0 && s < n);
-  return v.s[s];
-}
-
-/** @brief Broadcast i-th element of vector
-
-Scheme:
-@code
-{ v[0] v[1] v[2] ... v[SZ] } => { v[i], v[i], v[i] ... v[i] }
-@endcode
-Restriction: 0 <= i < nlanes
-Supported types: 32-bit integers and floats (s32/u32/f32)
- */
-template <int i, typename _Tp, int n>
-inline v_reg<_Tp, n> v_broadcast_element(const v_reg<_Tp, n> &a) {
-  CV_DbgAssert(i >= 0 && i < n);
-  return v_reg<_Tp, n>::all(a.s[i]);
-}
-
-/** @brief Round elements
-
-Rounds each value. Input type is float vector ==> output type is int vector.
-@note Only for floating point types.
-*/
-template <int n> inline v_reg<int, n> v_round(const v_reg<float, n> &a) {
-  v_reg<int, n> c;
-  for (int i = 0; i < n; i++)
-    c.s[i] = cvRound(a.s[i]);
-  return c;
-}
-
-/** @overload */
-template <int n>
-inline v_reg<int, n * 2> v_round(const v_reg<double, n> &a,
-                                 const v_reg<double, n> &b) {
-  v_reg<int, n * 2> c;
-  for (int i = 0; i < n; i++) {
-    c.s[i] = cvRound(a.s[i]);
-    c.s[i + n] = cvRound(b.s[i]);
-  }
-  return c;
-}
-
-/** @brief Floor elements
-
-Floor each value. Input type is float vector ==> output type is int vector.
-@note Only for floating point types.
-*/
-template <int n> inline v_reg<int, n> v_floor(const v_reg<float, n> &a) {
-  v_reg<int, n> c;
-  for (int i = 0; i < n; i++)
-    c.s[i] = cvFloor(a.s[i]);
-  return c;
-}
-
-/** @brief Ceil elements
-
-Ceil each value. Input type is float vector ==> output type is int vector.
-@note Only for floating point types.
-*/
-template <int n> inline v_reg<int, n> v_ceil(const v_reg<float, n> &a) {
-  v_reg<int, n> c;
-  for (int i = 0; i < n; i++)
-    c.s[i] = cvCeil(a.s[i]);
-  return c;
-}
-
-/** @brief Truncate elements
-
-Truncate each value. Input type is float vector ==> output type is int vector.
-@note Only for floating point types.
-*/
-template <int n> inline v_reg<int, n> v_trunc(const v_reg<float, n> &a) {
-  v_reg<int, n> c;
-  for (int i = 0; i < n; i++)
-    c.s[i] = (int)(a.s[i]);
-  return c;
-}
-
-/** @overload */
-template <int n> inline v_reg<int, n * 2> v_round(const v_reg<double, n> &a) {
-  v_reg<int, n * 2> c;
-  for (int i = 0; i < n; i++) {
-    c.s[i] = cvRound(a.s[i]);
-    c.s[i + n] = 0;
-  }
-  return c;
-}
-
-/** @overload */
-template <int n> inline v_reg<int, n * 2> v_floor(const v_reg<double, n> &a) {
-  v_reg<int, n * 2> c;
-  for (int i = 0; i < n; i++) {
-    c.s[i] = cvFloor(a.s[i]);
-    c.s[i + n] = 0;
-  }
-  return c;
-}
-
-/** @overload */
-template <int n> inline v_reg<int, n * 2> v_ceil(const v_reg<double, n> &a) {
-  v_reg<int, n * 2> c;
-  for (int i = 0; i < n; i++) {
-    c.s[i] = cvCeil(a.s[i]);
-    c.s[i + n] = 0;
-  }
-  return c;
-}
-
-/** @overload */
-template <int n> inline v_reg<int, n * 2> v_trunc(const v_reg<double, n> &a) {
-  v_reg<int, n * 2> c;
-  for (int i = 0; i < n; i++) {
-    c.s[i] = (int)(a.s[i]);
-    c.s[i + n] = 0;
-  }
-  return c;
-}
-
-/** @brief Convert to float
-
-Supported input type is cv::v_int32. */
-template <int n> inline v_reg<float, n> v_cvt_f32(const v_reg<int, n> &a) {
-  v_reg<float, n> c;
-  for (int i = 0; i < n; i++)
-    c.s[i] = (float)a.s[i];
-  return c;
-}
-
-/** @brief Convert lower half to float
-
-Supported input type is cv::v_float64. */
-template <int n>
-inline v_reg<float, n * 2> v_cvt_f32(const v_reg<double, n> &a) {
-  v_reg<float, n * 2> c;
-  for (int i = 0; i < n; i++) {
-    c.s[i] = (float)a.s[i];
-    c.s[i + n] = 0;
-  }
-  return c;
-}
-
-/** @brief Convert to float
-
-Supported input type is cv::v_float64. */
-template <int n>
-inline v_reg<float, n * 2> v_cvt_f32(const v_reg<double, n> &a,
-                                     const v_reg<double, n> &b) {
-  v_reg<float, n * 2> c;
-  for (int i = 0; i < n; i++) {
-    c.s[i] = (float)a.s[i];
-    c.s[i + n] = (float)b.s[i];
-  }
-  return c;
-}
-
-/** @brief Convert lower half to double
-
-Supported input type is cv::v_int32. */
-template <int n>
-CV_INLINE v_reg<double, n / 2> v_cvt_f64(const v_reg<int, n> &a) {
-  v_reg<double, (n / 2)> c;
-  for (int i = 0; i < (n / 2); i++)
-    c.s[i] = (double)a.s[i];
-  return c;
-}
-
-/** @brief Convert to double high part of vector
-
-Supported input type is cv::v_int32. */
-template <int n>
-CV_INLINE v_reg<double, (n / 2)> v_cvt_f64_high(const v_reg<int, n> &a) {
-  v_reg<double, (n / 2)> c;
-  for (int i = 0; i < (n / 2); i++)
-    c.s[i] = (double)a.s[i + (n / 2)];
-  return c;
-}
-
-/** @brief Convert lower half to double
-
-Supported input type is cv::v_float32. */
-template <int n>
-CV_INLINE v_reg<double, (n / 2)> v_cvt_f64(const v_reg<float, n> &a) {
-  v_reg<double, (n / 2)> c;
-  for (int i = 0; i < (n / 2); i++)
-    c.s[i] = (double)a.s[i];
-  return c;
-}
-
-/** @brief Convert to double high part of vector
-
-Supported input type is cv::v_float32. */
-template <int n>
-CV_INLINE v_reg<double, (n / 2)> v_cvt_f64_high(const v_reg<float, n> &a) {
-  v_reg<double, (n / 2)> c;
-  for (int i = 0; i < (n / 2); i++)
-    c.s[i] = (double)a.s[i + (n / 2)];
-  return c;
-}
-
-/** @brief Convert to double
-
-Supported input type is cv::v_int64. */
-template <int n>
-CV_INLINE v_reg<double, n> v_cvt_f64(const v_reg<int64, n> &a) {
-  v_reg<double, n> c;
-  for (int i = 0; i < n; i++)
-    c.s[i] = (double)a.s[i];
-  return c;
-}
-
-template <typename _Tp>
-inline v_reg<_Tp, simd128_width / sizeof(_Tp)> v_lut(const _Tp *tab,
-                                                     const int *idx) {
-  v_reg<_Tp, simd128_width / sizeof(_Tp)> c;
-  for (int i = 0; i < c.nlanes; i++)
-    c.s[i] = tab[idx[i]];
-  return c;
-}
-template <typename _Tp>
-inline v_reg<_Tp, simd128_width / sizeof(_Tp)> v_lut_pairs(const _Tp *tab,
-                                                           const int *idx) {
-  v_reg<_Tp, simd128_width / sizeof(_Tp)> c;
-  for (int i = 0; i < c.nlanes; i++)
-    c.s[i] = tab[idx[i / 2] + i % 2];
-  return c;
-}
-template <typename _Tp>
-inline v_reg<_Tp, simd128_width / sizeof(_Tp)> v_lut_quads(const _Tp *tab,
-                                                           const int *idx) {
-  v_reg<_Tp, simd128_width / sizeof(_Tp)> c;
-  for (int i = 0; i < c.nlanes; i++)
-    c.s[i] = tab[idx[i / 4] + i % 4];
-  return c;
-}
-
-template <int n>
-inline v_reg<int, n> v_lut(const int *tab, const v_reg<int, n> &idx) {
-  v_reg<int, n> c;
-  for (int i = 0; i < n; i++)
-    c.s[i] = tab[idx.s[i]];
-  return c;
-}
-
-template <int n>
-inline v_reg<unsigned, n> v_lut(const unsigned *tab, const v_reg<int, n> &idx) {
-  v_reg<int, n> c;
-  for (int i = 0; i < n; i++)
-    c.s[i] = tab[idx.s[i]];
-  return c;
-}
-
-template <int n>
-inline v_reg<float, n> v_lut(const float *tab, const v_reg<int, n> &idx) {
-  v_reg<float, n> c;
-  for (int i = 0; i < n; i++)
-    c.s[i] = tab[idx.s[i]];
-  return c;
-}
-
-template <int n>
-inline v_reg<double, n / 2> v_lut(const double *tab, const v_reg<int, n> &idx) {
-  v_reg<double, n / 2> c;
-  for (int i = 0; i < n / 2; i++)
-    c.s[i] = tab[idx.s[i]];
-  return c;
-}
-
-template <int n>
-inline void v_lut_deinterleave(const float *tab, const v_reg<int, n> &idx,
-                               v_reg<float, n> &x, v_reg<float, n> &y) {
-  for (int i = 0; i < n; i++) {
-    int j = idx.s[i];
-    x.s[i] = tab[j];
-    y.s[i] = tab[j + 1];
-  }
-}
-
-template <int n>
-inline void v_lut_deinterleave(const double *tab, const v_reg<int, n * 2> &idx,
-                               v_reg<double, n> &x, v_reg<double, n> &y) {
-  for (int i = 0; i < n; i++) {
-    int j = idx.s[i];
-    x.s[i] = tab[j];
-    y.s[i] = tab[j + 1];
-  }
-}
-
-template <typename _Tp, int n>
-inline v_reg<_Tp, n> v_interleave_pairs(const v_reg<_Tp, n> &vec) {
-  v_reg<_Tp, n> c;
-  for (int i = 0; i < n / 4; i++) {
-    c.s[4 * i] = vec.s[4 * i];
-    c.s[4 * i + 1] = vec.s[4 * i + 2];
-    c.s[4 * i + 2] = vec.s[4 * i + 1];
-    c.s[4 * i + 3] = vec.s[4 * i + 3];
-  }
-  return c;
-}
-
-template <typename _Tp, int n>
-inline v_reg<_Tp, n> v_interleave_quads(const v_reg<_Tp, n> &vec) {
-  v_reg<_Tp, n> c;
-  for (int i = 0; i < n / 8; i++) {
-    c.s[8 * i] = vec.s[8 * i];
-    c.s[8 * i + 1] = vec.s[8 * i + 4];
-    c.s[8 * i + 2] = vec.s[8 * i + 1];
-    c.s[8 * i + 3] = vec.s[8 * i + 5];
-    c.s[8 * i + 4] = vec.s[8 * i + 2];
-    c.s[8 * i + 5] = vec.s[8 * i + 6];
-    c.s[8 * i + 6] = vec.s[8 * i + 3];
-    c.s[8 * i + 7] = vec.s[8 * i + 7];
-  }
-  return c;
-}
-
-template <typename _Tp, int n>
-inline v_reg<_Tp, n> v_pack_triplets(const v_reg<_Tp, n> &vec) {
-  v_reg<_Tp, n> c;
-  for (int i = 0; i < n / 4; i++) {
-    c.s[3 * i] = vec.s[4 * i];
-    c.s[3 * i + 1] = vec.s[4 * i + 1];
-    c.s[3 * i + 2] = vec.s[4 * i + 2];
-  }
-  return c;
-}
-
-/** @brief Transpose 4x4 matrix
-
-Scheme:
-@code
-a0  {A1 A2 A3 A4}
-a1  {B1 B2 B3 B4}
-a2  {C1 C2 C3 C4}
-a3  {D1 D2 D3 D4}
-===============
-b0  {A1 B1 C1 D1}
-b1  {A2 B2 C2 D2}
-b2  {A3 B3 C3 D3}
-b3  {A4 B4 C4 D4}
-@endcode
-*/
-template <typename _Tp, int n>
-inline void v_transpose4x4(v_reg<_Tp, n> &a0, const v_reg<_Tp, n> &a1,
-                           const v_reg<_Tp, n> &a2, const v_reg<_Tp, n> &a3,
-                           v_reg<_Tp, n> &b0, v_reg<_Tp, n> &b1,
-                           v_reg<_Tp, n> &b2, v_reg<_Tp, n> &b3) {
-  for (int i = 0; i < n / 4; i++) {
-    b0.s[0 + i * 4] = a0.s[0 + i * 4];
-    b0.s[1 + i * 4] = a1.s[0 + i * 4];
-    b0.s[2 + i * 4] = a2.s[0 + i * 4];
-    b0.s[3 + i * 4] = a3.s[0 + i * 4];
-    b1.s[0 + i * 4] = a0.s[1 + i * 4];
-    b1.s[1 + i * 4] = a1.s[1 + i * 4];
-    b1.s[2 + i * 4] = a2.s[1 + i * 4];
-    b1.s[3 + i * 4] = a3.s[1 + i * 4];
-    b2.s[0 + i * 4] = a0.s[2 + i * 4];
-    b2.s[1 + i * 4] = a1.s[2 + i * 4];
-    b2.s[2 + i * 4] = a2.s[2 + i * 4];
-    b2.s[3 + i * 4] = a3.s[2 + i * 4];
-    b3.s[0 + i * 4] = a0.s[3 + i * 4];
-    b3.s[1 + i * 4] = a1.s[3 + i * 4];
-    b3.s[2 + i * 4] = a2.s[3 + i * 4];
-    b3.s[3 + i * 4] = a3.s[3 + i * 4];
-  }
-}
-
-//! @brief Helper macro
-//! @ingroup core_hal_intrin_impl
-#define OPENCV_HAL_IMPL_C_INIT_ZERO(_Tpvec, prefix, suffix)                    \
-  inline _Tpvec prefix##_setzero_##suffix() { return _Tpvec::zero(); }         \
-  template <> inline _Tpvec v_setzero_() { return _Tpvec::zero(); }
-
-//! @name Init with zero
-//! @{
-//! @brief Create new vector with zero elements
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_uint8x16, v, u8)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_int8x16, v, s8)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_uint16x8, v, u16)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_int16x8, v, s16)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_uint32x4, v, u32)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_int32x4, v, s32)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_float32x4, v, f32)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_float64x2, v, f64)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_uint64x2, v, u64)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_int64x2, v, s64)
-
-#if CV_SIMD256
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_uint8x32, v256, u8)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_int8x32, v256, s8)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_uint16x16, v256, u16)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_int16x16, v256, s16)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_uint32x8, v256, u32)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_int32x8, v256, s32)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_float32x8, v256, f32)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_float64x4, v256, f64)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_uint64x4, v256, u64)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_int64x4, v256, s64)
-#endif
-
-#if CV_SIMD512
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_uint8x64, v512, u8)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_int8x64, v512, s8)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_uint16x32, v512, u16)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_int16x32, v512, s16)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_uint32x16, v512, u32)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_int32x16, v512, s32)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_float32x16, v512, f32)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_float64x8, v512, f64)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_uint64x8, v512, u64)
-OPENCV_HAL_IMPL_C_INIT_ZERO(v_int64x8, v512, s64)
-#endif
-//! @}
-
-//! @brief Helper macro
-//! @ingroup core_hal_intrin_impl
-#define OPENCV_HAL_IMPL_C_INIT_VAL(_Tpvec, _Tp, prefix, suffix)                \
-  inline _Tpvec prefix##_setall_##suffix(_Tp val) { return _Tpvec::all(val); } \
-  template <> inline _Tpvec v_setall_(_Tp val) { return _Tpvec::all(val); }
-
-//! @name Init with value
-//! @{
-//! @brief Create new vector with elements set to a specific value
-OPENCV_HAL_IMPL_C_INIT_VAL(v_uint8x16, uchar, v, u8)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_int8x16, schar, v, s8)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_uint16x8, ushort, v, u16)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_int16x8, short, v, s16)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_uint32x4, unsigned, v, u32)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_int32x4, int, v, s32)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_float32x4, float, v, f32)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_float64x2, double, v, f64)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_uint64x2, uint64, v, u64)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_int64x2, int64, v, s64)
-
-#if CV_SIMD256
-OPENCV_HAL_IMPL_C_INIT_VAL(v_uint8x32, uchar, v256, u8)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_int8x32, schar, v256, s8)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_uint16x16, ushort, v256, u16)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_int16x16, short, v256, s16)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_uint32x8, unsigned, v256, u32)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_int32x8, int, v256, s32)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_float32x8, float, v256, f32)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_float64x4, double, v256, f64)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_uint64x4, uint64, v256, u64)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_int64x4, int64, v256, s64)
-#endif
-
-#if CV_SIMD512
-OPENCV_HAL_IMPL_C_INIT_VAL(v_uint8x64, uchar, v512, u8)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_int8x64, schar, v512, s8)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_uint16x32, ushort, v512, u16)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_int16x32, short, v512, s16)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_uint32x16, unsigned, v512, u32)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_int32x16, int, v512, s32)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_float32x16, float, v512, f32)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_float64x8, double, v512, f64)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_uint64x8, uint64, v512, u64)
-OPENCV_HAL_IMPL_C_INIT_VAL(v_int64x8, int64, v512, s64)
-#endif
-//! @}
-
-//! @brief Helper macro
-//! @ingroup core_hal_intrin_impl
-#define OPENCV_HAL_IMPL_C_REINTERPRET(_Tp, suffix)                             \
-  template <typename _Tp0, int n0>                                             \
-  inline v_reg<_Tp, n0 * sizeof(_Tp0) / sizeof(_Tp)>                           \
-      v_reinterpret_as_##suffix(const v_reg<_Tp0, n0> &a) {                    \
-    return a.template reinterpret_as<_Tp, n0 * sizeof(_Tp0) / sizeof(_Tp)>();  \
-  }
-
-//! @name Reinterpret
-//! @{
-//! @brief Convert vector to different type without modifying underlying data.
-OPENCV_HAL_IMPL_C_REINTERPRET(uchar, u8)
-OPENCV_HAL_IMPL_C_REINTERPRET(schar, s8)
-OPENCV_HAL_IMPL_C_REINTERPRET(ushort, u16)
-OPENCV_HAL_IMPL_C_REINTERPRET(short, s16)
-OPENCV_HAL_IMPL_C_REINTERPRET(unsigned, u32)
-OPENCV_HAL_IMPL_C_REINTERPRET(int, s32)
-OPENCV_HAL_IMPL_C_REINTERPRET(float, f32)
-OPENCV_HAL_IMPL_C_REINTERPRET(double, f64)
-OPENCV_HAL_IMPL_C_REINTERPRET(uint64, u64)
-OPENCV_HAL_IMPL_C_REINTERPRET(int64, s64)
-//! @}
-
-//! @brief Helper macro
-//! @ingroup core_hal_intrin_impl
-#define OPENCV_HAL_IMPL_C_SHIFTL(_Tp)                                          \
-  template <int shift, int n>                                                  \
-  inline v_reg<_Tp, n> v_shl(const v_reg<_Tp, n> &a) {                         \
-    return v_shl(a, shift);                                                    \
-  }
-
-//! @name Left shift
-//! @{
-//! @brief Shift left
-OPENCV_HAL_IMPL_C_SHIFTL(ushort)
-OPENCV_HAL_IMPL_C_SHIFTL(short)
-OPENCV_HAL_IMPL_C_SHIFTL(unsigned)
-OPENCV_HAL_IMPL_C_SHIFTL(int)
-OPENCV_HAL_IMPL_C_SHIFTL(uint64)
-OPENCV_HAL_IMPL_C_SHIFTL(int64)
-//! @}
-
-//! @brief Helper macro
-//! @ingroup core_hal_intrin_impl
-#define OPENCV_HAL_IMPL_C_SHIFTR(_Tp)                                          \
-  template <int shift, int n>                                                  \
-  inline v_reg<_Tp, n> v_shr(const v_reg<_Tp, n> &a) {                         \
-    return v_shr(a, shift);                                                    \
-  }
-
-//! @name Right shift
-//! @{
-//! @brief Shift right
-OPENCV_HAL_IMPL_C_SHIFTR(ushort)
-OPENCV_HAL_IMPL_C_SHIFTR(short)
-OPENCV_HAL_IMPL_C_SHIFTR(unsigned)
-OPENCV_HAL_IMPL_C_SHIFTR(int)
-OPENCV_HAL_IMPL_C_SHIFTR(uint64)
-OPENCV_HAL_IMPL_C_SHIFTR(int64)
-//! @}
-
-//! @brief Helper macro
-//! @ingroup core_hal_intrin_impl
-#define OPENCV_HAL_IMPL_C_RSHIFTR(_Tp)                                         \
-  template <int shift, int n>                                                  \
-  inline v_reg<_Tp, n> v_rshr(const v_reg<_Tp, n> &a) {                        \
-    v_reg<_Tp, n> c;                                                           \
-    for (int i = 0; i < n; i++)                                                \
-      c.s[i] = (_Tp)((a.s[i] + ((_Tp)1 << (shift - 1))) >> shift);             \
-    return c;                                                                  \
-  }
-
-//! @name Rounding shift
-//! @{
-//! @brief Rounding shift right
-OPENCV_HAL_IMPL_C_RSHIFTR(ushort)
-OPENCV_HAL_IMPL_C_RSHIFTR(short)
-OPENCV_HAL_IMPL_C_RSHIFTR(unsigned)
-OPENCV_HAL_IMPL_C_RSHIFTR(int)
-OPENCV_HAL_IMPL_C_RSHIFTR(uint64)
-OPENCV_HAL_IMPL_C_RSHIFTR(int64)
-//! @}
-
-//! @brief Helper macro
-//! @ingroup core_hal_intrin_impl
-#define OPENCV_HAL_IMPL_C_PACK(_Tp, _Tpn, pack_suffix, cast)                   \
-  template <int n>                                                             \
-  inline v_reg<_Tpn, 2 * n> v_##pack_suffix(const v_reg<_Tp, n> &a,            \
-                                            const v_reg<_Tp, n> &b) {          \
-    v_reg<_Tpn, 2 * n> c;                                                      \
-    for (int i = 0; i < n; i++) {                                              \
-      c.s[i] = cast<_Tpn>(a.s[i]);                                             \
-      c.s[i + n] = cast<_Tpn>(b.s[i]);                                         \
-    }                                                                          \
-    return c;                                                                  \
-  }
-
-//! @name Pack
-//! @{
-//! @brief Pack values from two vectors to one
-//!
-//! Return vector type have twice more elements than input vector types. Variant
-//! with _u_ suffix also converts to corresponding unsigned type.
-//!
-//! - pack: for 16-, 32- and 64-bit integer input types
-//! - pack_u: for 16- and 32-bit signed integer input types
-//!
-//! @note All variants except 64-bit use saturation.
-OPENCV_HAL_IMPL_C_PACK(ushort, uchar, pack, saturate_cast)
-OPENCV_HAL_IMPL_C_PACK(short, schar, pack, saturate_cast)
-OPENCV_HAL_IMPL_C_PACK(unsigned, ushort, pack, saturate_cast)
-OPENCV_HAL_IMPL_C_PACK(int, short, pack, saturate_cast)
-OPENCV_HAL_IMPL_C_PACK(uint64, unsigned, pack, static_cast)
-OPENCV_HAL_IMPL_C_PACK(int64, int, pack, static_cast)
-OPENCV_HAL_IMPL_C_PACK(short, uchar, pack_u, saturate_cast)
-OPENCV_HAL_IMPL_C_PACK(int, ushort, pack_u, saturate_cast)
-//! @}
-
-//! @brief Helper macro
-//! @ingroup core_hal_intrin_impl
-#define OPENCV_HAL_IMPL_C_RSHR_PACK(_Tp, _Tpn, pack_suffix, cast)              \
-  template <int shift, int n>                                                  \
-  inline v_reg<_Tpn, 2 * n> v_rshr_##pack_suffix(const v_reg<_Tp, n> &a,       \
-                                                 const v_reg<_Tp, n> &b) {     \
-    v_reg<_Tpn, 2 * n> c;                                                      \
-    for (int i = 0; i < n; i++) {                                              \
-      c.s[i] = cast<_Tpn>((a.s[i] + ((_Tp)1 << (shift - 1))) >> shift);        \
-      c.s[i + n] = cast<_Tpn>((b.s[i] + ((_Tp)1 << (shift - 1))) >> shift);    \
-    }                                                                          \
-    return c;                                                                  \
-  }
-
-//! @name Pack with rounding shift
-//! @{
-//! @brief Pack values from two vectors to one with rounding shift
-//!
-//! Values from the input vectors will be shifted right by _n_ bits with
-//! rounding, converted to narrower type and returned in the result vector.
-//! Variant with _u_ suffix converts to unsigned type.
-//!
-//! - pack: for 16-, 32- and 64-bit integer input types
-//! - pack_u: for 16- and 32-bit signed integer input types
-//!
-//! @note All variants except 64-bit use saturation.
-OPENCV_HAL_IMPL_C_RSHR_PACK(ushort, uchar, pack, saturate_cast)
-OPENCV_HAL_IMPL_C_RSHR_PACK(short, schar, pack, saturate_cast)
-OPENCV_HAL_IMPL_C_RSHR_PACK(unsigned, ushort, pack, saturate_cast)
-OPENCV_HAL_IMPL_C_RSHR_PACK(int, short, pack, saturate_cast)
-OPENCV_HAL_IMPL_C_RSHR_PACK(uint64, unsigned, pack, static_cast)
-OPENCV_HAL_IMPL_C_RSHR_PACK(int64, int, pack, static_cast)
-OPENCV_HAL_IMPL_C_RSHR_PACK(short, uchar, pack_u, saturate_cast)
-OPENCV_HAL_IMPL_C_RSHR_PACK(int, ushort, pack_u, saturate_cast)
-//! @}
-
-//! @brief Helper macro
-//! @ingroup core_hal_intrin_impl
-#define OPENCV_HAL_IMPL_C_PACK_STORE(_Tp, _Tpn, pack_suffix, cast)             \
-  template <int n>                                                             \
-  inline void v_##pack_suffix##_store(_Tpn *ptr, const v_reg<_Tp, n> &a) {     \
-    for (int i = 0; i < n; i++)                                                \
-      ptr[i] = cast<_Tpn>(a.s[i]);                                             \
-  }
-
-//! @name Pack and store
-//! @{
-//! @brief Store values from the input vector into memory with pack
-//!
-//! Values will be stored into memory with conversion to narrower type.
-//! Variant with _u_ suffix converts to corresponding unsigned type.
-//!
-//! - pack: for 16-, 32- and 64-bit integer input types
-//! - pack_u: for 16- and 32-bit signed integer input types
-//!
-//! @note All variants except 64-bit use saturation.
-OPENCV_HAL_IMPL_C_PACK_STORE(ushort, uchar, pack, saturate_cast)
-OPENCV_HAL_IMPL_C_PACK_STORE(short, schar, pack, saturate_cast)
-OPENCV_HAL_IMPL_C_PACK_STORE(unsigned, ushort, pack, saturate_cast)
-OPENCV_HAL_IMPL_C_PACK_STORE(int, short, pack, saturate_cast)
-OPENCV_HAL_IMPL_C_PACK_STORE(uint64, unsigned, pack, static_cast)
-OPENCV_HAL_IMPL_C_PACK_STORE(int64, int, pack, static_cast)
-OPENCV_HAL_IMPL_C_PACK_STORE(short, uchar, pack_u, saturate_cast)
-OPENCV_HAL_IMPL_C_PACK_STORE(int, ushort, pack_u, saturate_cast)
-//! @}
-
-//! @brief Helper macro
-//! @ingroup core_hal_intrin_impl
-#define OPENCV_HAL_IMPL_C_RSHR_PACK_STORE(_Tp, _Tpn, pack_suffix, cast)        \
-  template <int shift, int n>                                                  \
-  inline void v_rshr_##pack_suffix##_store(_Tpn *ptr,                          \
-                                           const v_reg<_Tp, n> &a) {           \
-    for (int i = 0; i < n; i++)                                                \
-      ptr[i] = cast<_Tpn>((a.s[i] + ((_Tp)1 << (shift - 1))) >> shift);        \
-  }
-
-//! @name Pack and store with rounding shift
-//! @{
-//! @brief Store values from the input vector into memory with pack
-//!
-//! Values will be shifted _n_ bits right with rounding, converted to narrower
-//! type and stored into memory. Variant with _u_ suffix converts to unsigned
-//! type.
-//!
-//! - pack: for 16-, 32- and 64-bit integer input types
-//! - pack_u: for 16- and 32-bit signed integer input types
-//!
-//! @note All variants except 64-bit use saturation.
-OPENCV_HAL_IMPL_C_RSHR_PACK_STORE(ushort, uchar, pack, saturate_cast)
-OPENCV_HAL_IMPL_C_RSHR_PACK_STORE(short, schar, pack, saturate_cast)
-OPENCV_HAL_IMPL_C_RSHR_PACK_STORE(unsigned, ushort, pack, saturate_cast)
-OPENCV_HAL_IMPL_C_RSHR_PACK_STORE(int, short, pack, saturate_cast)
-OPENCV_HAL_IMPL_C_RSHR_PACK_STORE(uint64, unsigned, pack, static_cast)
-OPENCV_HAL_IMPL_C_RSHR_PACK_STORE(int64, int, pack, static_cast)
-OPENCV_HAL_IMPL_C_RSHR_PACK_STORE(short, uchar, pack_u, saturate_cast)
-OPENCV_HAL_IMPL_C_RSHR_PACK_STORE(int, ushort, pack_u, saturate_cast)
-//! @}
-
-//! @cond IGNORED
-template <typename _Tpm, typename _Tp, int n>
-inline void _pack_b(_Tpm *mptr, const v_reg<_Tp, n> &a,
-                    const v_reg<_Tp, n> &b) {
-  for (int i = 0; i < n; ++i) {
-    mptr[i] = (_Tpm)a.s[i];
-    mptr[i + n] = (_Tpm)b.s[i];
-  }
-}
-//! @endcond
-
-//! @name Pack boolean values
-//! @{
-//! @brief Pack boolean values from multiple vectors to one unsigned 8-bit
-//! integer vector
-//!
-//! @note Must provide valid boolean values to guarantee same result for all
-//! architectures.
-
-/** @brief
-//! For 16-bit boolean values
-
-Scheme:
-@code
-a  {0xFFFF 0 0 0xFFFF 0 0xFFFF 0xFFFF 0}
-b  {0xFFFF 0 0xFFFF 0 0 0xFFFF 0 0xFFFF}
-===============
-{
-   0xFF 0 0 0xFF 0 0xFF 0xFF 0
-   0xFF 0 0xFF 0 0 0xFF 0 0xFF
-}
-@endcode */
-
-template <int n>
-inline v_reg<uchar, 2 * n> v_pack_b(const v_reg<ushort, n> &a,
-                                    const v_reg<ushort, n> &b) {
-  v_reg<uchar, 2 * n> mask;
-  _pack_b(mask.s, a, b);
-  return mask;
-}
-
-/** @overload
-For 32-bit boolean values
-
-Scheme:
-@code
-a  {0xFFFF.. 0 0 0xFFFF..}
-b  {0 0xFFFF.. 0xFFFF.. 0}
-c  {0xFFFF.. 0 0xFFFF.. 0}
-d  {0 0xFFFF.. 0 0xFFFF..}
-===============
-{
-   0xFF 0 0 0xFF 0 0xFF 0xFF 0
-   0xFF 0 0xFF 0 0 0xFF 0 0xFF
-}
-@endcode */
-
-template <int n>
-inline v_reg<uchar, 4 * n>
-v_pack_b(const v_reg<unsigned, n> &a, const v_reg<unsigned, n> &b,
-         const v_reg<unsigned, n> &c, const v_reg<unsigned, n> &d) {
-  v_reg<uchar, 4 * n> mask;
-  _pack_b(mask.s, a, b);
-  _pack_b(mask.s + 2 * n, c, d);
-  return mask;
-}
-
-/** @overload
-For 64-bit boolean values
-
-Scheme:
-@code
-a  {0xFFFF.. 0}
-b  {0 0xFFFF..}
-c  {0xFFFF.. 0}
-d  {0 0xFFFF..}
-
-e  {0xFFFF.. 0}
-f  {0xFFFF.. 0}
-g  {0 0xFFFF..}
-h  {0 0xFFFF..}
-===============
-{
-   0xFF 0 0 0xFF 0xFF 0 0 0xFF
-   0xFF 0 0xFF 0 0 0xFF 0 0xFF
-}
-@endcode */
-template <int n>
-inline v_reg<uchar, 8 * n>
-v_pack_b(const v_reg<uint64, n> &a, const v_reg<uint64, n> &b,
-         const v_reg<uint64, n> &c, const v_reg<uint64, n> &d,
-         const v_reg<uint64, n> &e, const v_reg<uint64, n> &f,
-         const v_reg<uint64, n> &g, const v_reg<uint64, n> &h) {
-  v_reg<uchar, 8 * n> mask;
-  _pack_b(mask.s, a, b);
-  _pack_b(mask.s + 2 * n, c, d);
-  _pack_b(mask.s + 4 * n, e, f);
-  _pack_b(mask.s + 6 * n, g, h);
-  return mask;
-}
-//! @}
-
-/** @brief Matrix multiplication
-
-Scheme:
-@code
-{A0 A1 A2 A3}   |V0|
-{B0 B1 B2 B3}   |V1|
-{C0 C1 C2 C3}   |V2|
-{D0 D1 D2 D3} x |V3|
-====================
-{R0 R1 R2 R3}, where:
-R0 = A0V0 + B0V1 + C0V2 + D0V3,
-R1 = A1V0 + B1V1 + C1V2 + D1V3
-...
-@endcode
-*/
-template <int n>
-inline v_reg<float, n>
-v_matmul(const v_reg<float, n> &v, const v_reg<float, n> &a,
-         const v_reg<float, n> &b, const v_reg<float, n> &c,
-         const v_reg<float, n> &d) {
-  v_reg<float, n> res;
-  for (int i = 0; i < n / 4; i++) {
-    res.s[0 + i * 4] =
-        v.s[0 + i * 4] * a.s[0 + i * 4] + v.s[1 + i * 4] * b.s[0 + i * 4] +
-        v.s[2 + i * 4] * c.s[0 + i * 4] + v.s[3 + i * 4] * d.s[0 + i * 4];
-    res.s[1 + i * 4] =
-        v.s[0 + i * 4] * a.s[1 + i * 4] + v.s[1 + i * 4] * b.s[1 + i * 4] +
-        v.s[2 + i * 4] * c.s[1 + i * 4] + v.s[3 + i * 4] * d.s[1 + i * 4];
-    res.s[2 + i * 4] =
-        v.s[0 + i * 4] * a.s[2 + i * 4] + v.s[1 + i * 4] * b.s[2 + i * 4] +
-        v.s[2 + i * 4] * c.s[2 + i * 4] + v.s[3 + i * 4] * d.s[2 + i * 4];
-    res.s[3 + i * 4] =
-        v.s[0 + i * 4] * a.s[3 + i * 4] + v.s[1 + i * 4] * b.s[3 + i * 4] +
-        v.s[2 + i * 4] * c.s[3 + i * 4] + v.s[3 + i * 4] * d.s[3 + i * 4];
-  }
-  return res;
-}
-
-/** @brief Matrix multiplication and add
-
-Scheme:
-@code
-{A0 A1 A2 A3}   |V0|   |D0|
-{B0 B1 B2 B3}   |V1|   |D1|
-{C0 C1 C2 C3} x |V2| + |D2|
-====================   |D3|
-{R0 R1 R2 R3}, where:
-R0 = A0V0 + B0V1 + C0V2 + D0,
-R1 = A1V0 + B1V1 + C1V2 + D1
-...
-@endcode
-*/
-template <int n>
-inline v_reg<float, n>
-v_matmuladd(const v_reg<float, n> &v, const v_reg<float, n> &a,
-            const v_reg<float, n> &b, const v_reg<float, n> &c,
-            const v_reg<float, n> &d) {
-  v_reg<float, n> res;
-  for (int i = 0; i < n / 4; i++) {
-    res.s[0 + i * 4] = v.s[0 + i * 4] * a.s[0 + i * 4] +
-                       v.s[1 + i * 4] * b.s[0 + i * 4] +
-                       v.s[2 + i * 4] * c.s[0 + i * 4] + d.s[0 + i * 4];
-    res.s[1 + i * 4] = v.s[0 + i * 4] * a.s[1 + i * 4] +
-                       v.s[1 + i * 4] * b.s[1 + i * 4] +
-                       v.s[2 + i * 4] * c.s[1 + i * 4] + d.s[1 + i * 4];
-    res.s[2 + i * 4] = v.s[0 + i * 4] * a.s[2 + i * 4] +
-                       v.s[1 + i * 4] * b.s[2 + i * 4] +
-                       v.s[2 + i * 4] * c.s[2 + i * 4] + d.s[2 + i * 4];
-    res.s[3 + i * 4] = v.s[0 + i * 4] * a.s[3 + i * 4] +
-                       v.s[1 + i * 4] * b.s[3 + i * 4] +
-                       v.s[2 + i * 4] * c.s[3 + i * 4] + d.s[3 + i * 4];
-  }
-  return res;
-}
-
-template <int n>
-inline v_reg<double, n / 2> v_dotprod_expand(const v_reg<int, n> &a,
-                                             const v_reg<int, n> &b) {
-  return v_fma(v_cvt_f64(a), v_cvt_f64(b),
-               v_mul(v_cvt_f64_high(a), v_cvt_f64_high(b)));
-}
-template <int n>
-inline v_reg<double, n / 2> v_dotprod_expand(const v_reg<int, n> &a,
-                                             const v_reg<int, n> &b,
-                                             const v_reg<double, n / 2> &c) {
-  return v_fma(v_cvt_f64(a), v_cvt_f64(b),
-               v_fma(v_cvt_f64_high(a), v_cvt_f64_high(b), c));
-}
-
-template <int n>
-inline v_reg<double, n / 2> v_dotprod_expand_fast(const v_reg<int, n> &a,
-                                                  const v_reg<int, n> &b) {
-  return v_dotprod_expand(a, b);
-}
-template <int n>
-inline v_reg<double, n / 2>
-v_dotprod_expand_fast(const v_reg<int, n> &a, const v_reg<int, n> &b,
-                      const v_reg<double, n / 2> &c) {
-  return v_dotprod_expand(a, b, c);
-}
-
-////// FP16 support ///////
-
-inline v_reg<float, simd128_width / sizeof(float)>
-v_load_expand(const hfloat *ptr) {
-  v_reg<float, simd128_width / sizeof(float)> v;
-  for (int i = 0; i < v.nlanes; i++) {
-    v.s[i] = ptr[i];
-  }
-  return v;
-}
-#if CV_SIMD256
-inline v_reg<float, simd256_width / sizeof(float)>
-v256_load_expand(const hfloat *ptr) {
-  v_reg<float, simd256_width / sizeof(float)> v;
-  for (int i = 0; i < v.nlanes; i++) {
-    v.s[i] = ptr[i];
-  }
-  return v;
-}
-#endif
-#if CV_SIMD512
-inline v_reg<float, simd512_width / sizeof(float)>
-v512_load_expand(const hfloat *ptr) {
-  v_reg<float, simd512_width / sizeof(float)> v;
-  for (int i = 0; i < v.nlanes; i++) {
-    v.s[i] = ptr[i];
-  }
-  return v;
-}
-#endif
-
-template <int n>
-inline void v_pack_store(hfloat *ptr, const v_reg<float, n> &v) {
-  for (int i = 0; i < v.nlanes; i++) {
-    ptr[i] = hfloat(v.s[i]);
-  }
-}
-
-inline void v_cleanup() {}
-#if CV_SIMD256
-inline void v256_cleanup() {}
-#endif
-#if CV_SIMD512
-inline void v512_cleanup() {}
-#endif
-
-//! @}
-
-#ifndef CV_DOXYGEN
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_END
-#endif
-} // namespace cv
-
-#if !defined(CV_DOXYGEN)
-#undef CV_SIMD256
-#undef CV_SIMD512
-#endif
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_forward.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_forward.hpp
deleted file mode 100644
index de7f6d39a0..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_forward.hpp
+++ /dev/null
@@ -1,195 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html
-
-#ifndef CV__SIMD_FORWARD
-#error "Need to pre-define forward width"
-#endif
-
-namespace cv {
-
-//! @cond IGNORED
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_BEGIN
-
-/** Types **/
-#if CV__SIMD_FORWARD == 1024
-// [todo] 1024
-#error "1024-long ops not implemented yet"
-#elif CV__SIMD_FORWARD == 512
-// 512
-#define __CV_VX(fun) v512_##fun
-#define __CV_V_UINT8 v_uint8x64
-#define __CV_V_INT8 v_int8x64
-#define __CV_V_UINT16 v_uint16x32
-#define __CV_V_INT16 v_int16x32
-#define __CV_V_UINT32 v_uint32x16
-#define __CV_V_INT32 v_int32x16
-#define __CV_V_UINT64 v_uint64x8
-#define __CV_V_INT64 v_int64x8
-#define __CV_V_FLOAT32 v_float32x16
-#define __CV_V_FLOAT64 v_float64x8
-struct v_uint8x64;
-struct v_int8x64;
-struct v_uint16x32;
-struct v_int16x32;
-struct v_uint32x16;
-struct v_int32x16;
-struct v_uint64x8;
-struct v_int64x8;
-struct v_float32x16;
-struct v_float64x8;
-#elif CV__SIMD_FORWARD == 256
-// 256
-#define __CV_VX(fun) v256_##fun
-#define __CV_V_UINT8 v_uint8x32
-#define __CV_V_INT8 v_int8x32
-#define __CV_V_UINT16 v_uint16x16
-#define __CV_V_INT16 v_int16x16
-#define __CV_V_UINT32 v_uint32x8
-#define __CV_V_INT32 v_int32x8
-#define __CV_V_UINT64 v_uint64x4
-#define __CV_V_INT64 v_int64x4
-#define __CV_V_FLOAT32 v_float32x8
-#define __CV_V_FLOAT64 v_float64x4
-struct v_uint8x32;
-struct v_int8x32;
-struct v_uint16x16;
-struct v_int16x16;
-struct v_uint32x8;
-struct v_int32x8;
-struct v_uint64x4;
-struct v_int64x4;
-struct v_float32x8;
-struct v_float64x4;
-#else
-// 128
-#define __CV_VX(fun) v_##fun
-#define __CV_V_UINT8 v_uint8x16
-#define __CV_V_INT8 v_int8x16
-#define __CV_V_UINT16 v_uint16x8
-#define __CV_V_INT16 v_int16x8
-#define __CV_V_UINT32 v_uint32x4
-#define __CV_V_INT32 v_int32x4
-#define __CV_V_UINT64 v_uint64x2
-#define __CV_V_INT64 v_int64x2
-#define __CV_V_FLOAT32 v_float32x4
-#define __CV_V_FLOAT64 v_float64x2
-struct v_uint8x16;
-struct v_int8x16;
-struct v_uint16x8;
-struct v_int16x8;
-struct v_uint32x4;
-struct v_int32x4;
-struct v_uint64x2;
-struct v_int64x2;
-struct v_float32x4;
-struct v_float64x2;
-#endif
-
-/** Value reordering **/
-
-// Expansion
-void v_expand(const __CV_V_UINT8 &, __CV_V_UINT16 &, __CV_V_UINT16 &);
-void v_expand(const __CV_V_INT8 &, __CV_V_INT16 &, __CV_V_INT16 &);
-void v_expand(const __CV_V_UINT16 &, __CV_V_UINT32 &, __CV_V_UINT32 &);
-void v_expand(const __CV_V_INT16 &, __CV_V_INT32 &, __CV_V_INT32 &);
-void v_expand(const __CV_V_UINT32 &, __CV_V_UINT64 &, __CV_V_UINT64 &);
-void v_expand(const __CV_V_INT32 &, __CV_V_INT64 &, __CV_V_INT64 &);
-// Low Expansion
-__CV_V_UINT16 v_expand_low(const __CV_V_UINT8 &);
-__CV_V_INT16 v_expand_low(const __CV_V_INT8 &);
-__CV_V_UINT32 v_expand_low(const __CV_V_UINT16 &);
-__CV_V_INT32 v_expand_low(const __CV_V_INT16 &);
-__CV_V_UINT64 v_expand_low(const __CV_V_UINT32 &);
-__CV_V_INT64 v_expand_low(const __CV_V_INT32 &);
-// High Expansion
-__CV_V_UINT16 v_expand_high(const __CV_V_UINT8 &);
-__CV_V_INT16 v_expand_high(const __CV_V_INT8 &);
-__CV_V_UINT32 v_expand_high(const __CV_V_UINT16 &);
-__CV_V_INT32 v_expand_high(const __CV_V_INT16 &);
-__CV_V_UINT64 v_expand_high(const __CV_V_UINT32 &);
-__CV_V_INT64 v_expand_high(const __CV_V_INT32 &);
-// Load & Low Expansion
-__CV_V_UINT16 __CV_VX(load_expand)(const uchar *);
-__CV_V_INT16 __CV_VX(load_expand)(const schar *);
-__CV_V_UINT32 __CV_VX(load_expand)(const ushort *);
-__CV_V_INT32 __CV_VX(load_expand)(const short *);
-__CV_V_UINT64 __CV_VX(load_expand)(const uint *);
-__CV_V_INT64 __CV_VX(load_expand)(const int *);
-// Load lower 8-bit and expand into 32-bit
-__CV_V_UINT32 __CV_VX(load_expand_q)(const uchar *);
-__CV_V_INT32 __CV_VX(load_expand_q)(const schar *);
-
-// Saturating Pack
-__CV_V_UINT8 v_pack(const __CV_V_UINT16 &, const __CV_V_UINT16 &);
-__CV_V_INT8 v_pack(const __CV_V_INT16 &, const __CV_V_INT16 &);
-__CV_V_UINT16 v_pack(const __CV_V_UINT32 &, const __CV_V_UINT32 &);
-__CV_V_INT16 v_pack(const __CV_V_INT32 &, const __CV_V_INT32 &);
-// Non-saturating Pack
-__CV_V_UINT32 v_pack(const __CV_V_UINT64 &, const __CV_V_UINT64 &);
-__CV_V_INT32 v_pack(const __CV_V_INT64 &, const __CV_V_INT64 &);
-// Pack signed integers with unsigned saturation
-__CV_V_UINT8 v_pack_u(const __CV_V_INT16 &, const __CV_V_INT16 &);
-__CV_V_UINT16 v_pack_u(const __CV_V_INT32 &, const __CV_V_INT32 &);
-
-/** Arithmetic, bitwise and comparison operations **/
-
-// Non-saturating multiply
-#if CV_VSX
-template <typename Tvec> Tvec v_mul_wrap(const Tvec &a, const Tvec &b);
-#else
-__CV_V_UINT8 v_mul_wrap(const __CV_V_UINT8 &, const __CV_V_UINT8 &);
-__CV_V_INT8 v_mul_wrap(const __CV_V_INT8 &, const __CV_V_INT8 &);
-__CV_V_UINT16 v_mul_wrap(const __CV_V_UINT16 &, const __CV_V_UINT16 &);
-__CV_V_INT16 v_mul_wrap(const __CV_V_INT16 &, const __CV_V_INT16 &);
-#endif
-
-//  Multiply and expand
-#if CV_VSX
-template <typename Tvec, typename Twvec>
-void v_mul_expand(const Tvec &a, const Tvec &b, Twvec &c, Twvec &d);
-#else
-void v_mul_expand(const __CV_V_UINT8 &, const __CV_V_UINT8 &, __CV_V_UINT16 &,
-                  __CV_V_UINT16 &);
-void v_mul_expand(const __CV_V_INT8 &, const __CV_V_INT8 &, __CV_V_INT16 &,
-                  __CV_V_INT16 &);
-void v_mul_expand(const __CV_V_UINT16 &, const __CV_V_UINT16 &, __CV_V_UINT32 &,
-                  __CV_V_UINT32 &);
-void v_mul_expand(const __CV_V_INT16 &, const __CV_V_INT16 &, __CV_V_INT32 &,
-                  __CV_V_INT32 &);
-void v_mul_expand(const __CV_V_UINT32 &, const __CV_V_UINT32 &, __CV_V_UINT64 &,
-                  __CV_V_UINT64 &);
-void v_mul_expand(const __CV_V_INT32 &, const __CV_V_INT32 &, __CV_V_INT64 &,
-                  __CV_V_INT64 &);
-#endif
-
-// Conversions
-__CV_V_FLOAT32 v_cvt_f32(const __CV_V_INT32 &a);
-__CV_V_FLOAT32 v_cvt_f32(const __CV_V_FLOAT64 &a);
-__CV_V_FLOAT32 v_cvt_f32(const __CV_V_FLOAT64 &a, const __CV_V_FLOAT64 &b);
-__CV_V_FLOAT64 v_cvt_f64(const __CV_V_INT32 &a);
-__CV_V_FLOAT64 v_cvt_f64_high(const __CV_V_INT32 &a);
-__CV_V_FLOAT64 v_cvt_f64(const __CV_V_FLOAT32 &a);
-__CV_V_FLOAT64 v_cvt_f64_high(const __CV_V_FLOAT32 &a);
-__CV_V_FLOAT64 v_cvt_f64(const __CV_V_INT64 &a);
-
-/** Cleanup **/
-#undef CV__SIMD_FORWARD
-#undef __CV_VX
-#undef __CV_V_UINT8
-#undef __CV_V_INT8
-#undef __CV_V_UINT16
-#undef __CV_V_INT16
-#undef __CV_V_UINT32
-#undef __CV_V_INT32
-#undef __CV_V_UINT64
-#undef __CV_V_INT64
-#undef __CV_V_FLOAT32
-#undef __CV_V_FLOAT64
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_END
-
-//! @endcond
-
-} // namespace cv
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_lasx.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_lasx.hpp
deleted file mode 100644
index 58339ebaee..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_lasx.hpp
+++ /dev/null
@@ -1,3243 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html
-
-#ifndef OPENCV_HAL_INTRIN_LASX_HPP
-#define OPENCV_HAL_INTRIN_LASX_HPP
-
-#include <lasxintrin.h>
-#include <lsxintrin.h>
-
-#define CV_SIMD256 1
-#define CV_SIMD256_64F 1
-#define CV_SIMD256_FP16 0
-
-namespace cv {
-
-//! @cond IGNORED
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_BEGIN
-
-///////// Utils ////////////
-
-inline __m256i _v256_setr_b(char v0, char v1, char v2, char v3, char v4,
-                            char v5, char v6, char v7, char v8, char v9,
-                            char v10, char v11, char v12, char v13, char v14,
-                            char v15, char v16, char v17, char v18, char v19,
-                            char v20, char v21, char v22, char v23, char v24,
-                            char v25, char v26, char v27, char v28, char v29,
-                            char v30, char v31) {
-  return (__m256i)v32i8{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};
-}
-
-inline __m256i _v256_set_b(char v0, char v1, char v2, char v3, char v4, char v5,
-                           char v6, char v7, char v8, char v9, char v10,
-                           char v11, char v12, char v13, char v14, char v15,
-                           char v16, char v17, char v18, char v19, char v20,
-                           char v21, char v22, char v23, char v24, char v25,
-                           char v26, char v27, char v28, char v29, char v30,
-                           char v31) {
-  return (__m256i)v32i8{v31, v30, v29, v28, v27, v26, v25, v24, v23, v22, v21,
-                        v20, v19, v18, v17, v16, v15, v14, v13, v12, v11, v10,
-                        v9,  v8,  v7,  v6,  v5,  v4,  v3,  v2,  v1,  v0};
-}
-
-inline __m256i _v256_setr_h(short v0, short v1, short v2, short v3, short v4,
-                            short v5, short v6, short v7, short v8, short v9,
-                            short v10, short v11, short v12, short v13,
-                            short v14, short v15) {
-  return (__m256i)v16i16{v0, v1, v2,  v3,  v4,  v5,  v6,  v7,
-                         v8, v9, v10, v11, v12, v13, v14, v15};
-}
-
-inline __m256i _v256_setr_w(int v0, int v1, int v2, int v3, int v4, int v5,
-                            int v6, int v7) {
-  return (__m256i)v8i32{v0, v1, v2, v3, v4, v5, v6, v7};
-}
-
-inline __m256i _v256_set_w(int v0, int v1, int v2, int v3, int v4, int v5,
-                           int v6, int v7) {
-  return (__m256i)v8i32{v7, v6, v5, v4, v3, v2, v1, v0};
-}
-
-inline __m256i _v256_setall_w(int v0) {
-  return (__m256i)v8i32{v0, v0, v0, v0, v0, v0, v0, v0};
-}
-
-inline __m256i _v256_setr_d(int64 v0, int64 v1, int64 v2, int64 v3) {
-  return (__m256i)v4i64{v0, v1, v2, v3};
-}
-
-inline __m256i _v256_set_d(int64 v0, int64 v1, int64 v2, int64 v3) {
-  return (__m256i)v4i64{v3, v2, v1, v0};
-}
-
-inline __m256 _v256_setr_ps(float v0, float v1, float v2, float v3, float v4,
-                            float v5, float v6, float v7) {
-  return (__m256)v8f32{v0, v1, v2, v3, v4, v5, v6, v7};
-}
-
-inline __m256 _v256_setall_ps(float f32) {
-  return (__m256)v8f32{f32, f32, f32, f32, f32, f32, f32, f32};
-}
-
-inline __m256d _v256_setr_pd(double v0, double v1, double v2, double v3) {
-  return (__m256d)v4f64{v0, v1, v2, v3};
-}
-
-inline __m256d _v256_setall_pd(double f64) {
-  return (__m256d)v4f64{f64, f64, f64, f64};
-}
-
-inline __m256i _lasx_packus_h(const __m256i &a, const __m256i &b) {
-  return __lasx_xvssrarni_bu_h(b, a, 0);
-}
-
-inline __m256i _lasx_packs_h(const __m256i &a, const __m256i &b) {
-  return __lasx_xvssrarni_b_h(b, a, 0);
-}
-
-inline __m256i _lasx_packus_w(const __m256i &a, const __m256i &b) {
-  return __lasx_xvssrarni_hu_w(b, a, 0);
-}
-
-inline __m256i _lasx_packs_w(const __m256i &a, const __m256i &b) {
-  return __lasx_xvssrarni_h_w(b, a, 0);
-}
-
-inline __m256i _v256_combine(const __m128i &lo, const __m128i &hi) {
-  return __lasx_xvpermi_q(*((__m256i *)&lo), *((__m256i *)&hi), 0x02);
-}
-
-inline __m256 _v256_combine(const __m128 &lo, const __m128 &hi) {
-  return __m256(__lasx_xvpermi_q(*((__m256i *)&lo), *((__m256i *)&hi), 0x02));
-}
-
-inline __m256d _v256_combine(const __m128d &lo, const __m128d &hi) {
-  return __m256d(__lasx_xvpermi_q(*((__m256i *)&lo), *((__m256i *)&hi), 0x02));
-}
-
-inline __m256i _v256_shuffle_odd_64(const __m256i &v) {
-  return __lasx_xvpermi_d(v, 0xd8);
-}
-
-inline __m256d _v256_shuffle_odd_64(const __m256d &v) {
-  return __m256d(__lasx_xvpermi_d(*((__m256i *)&v), 0xd8));
-}
-
-// LASX: only use for permute WITHOUT zero clearing
-template <int imm>
-inline __m256i _v256_permute2x128(const __m256i &a, const __m256i &b) {
-  return __lasx_xvpermi_q(a, b, imm);
-}
-
-template <int imm>
-inline __m256 _v256_permute2x128(const __m256 &a, const __m256 &b) {
-  return __m256(__lasx_xvpermi_q(*((__m256i *)&a), *((__m256i *)&b), imm));
-}
-
-template <int imm>
-inline __m256d _v256_permute2x128(const __m256d &a, const __m256d &b) {
-  return __m256d(__lasx_xvpermi_q(*((__m256i *)&a), *((__m256i *)&b), imm));
-}
-
-template <int imm, typename _Tpvec>
-inline _Tpvec v256_permute2x128(const _Tpvec &a, const _Tpvec &b) {
-  return _Tpvec(_v256_permute2x128<imm>(a.val, b.val));
-}
-
-template <int imm> inline __m256i _v256_permute4x64(const __m256i &a) {
-  return __lasx_xvpermi_d(a, imm);
-}
-
-template <int imm> inline __m256d _v256_permute4x64(const __m256d &a) {
-  return __m256d(__lasx_xvpermi_d(*((__m256i *)&a), imm));
-}
-
-template <int imm, typename _Tpvec>
-inline _Tpvec v256_permute4x64(const _Tpvec &a) {
-  return _Tpvec(_v256_permute4x64<imm>(a.val));
-}
-
-inline __m128i _v256_extract_high(const __m256i &v) {
-  __m256i temp256i = __lasx_xvpermi_d(v, 0x4E);
-  return *((__m128i *)&temp256i);
-}
-
-inline __m128 _v256_extract_high(const __m256 &v) {
-  return __m128(_v256_extract_high(*((__m256i *)&v)));
-}
-
-inline __m128d _v256_extract_high(const __m256d &v) {
-  return __m128d(_v256_extract_high(*((__m256i *)&v)));
-}
-
-inline __m128i _v256_extract_low(const __m256i &v) { return *((__m128i *)&v); }
-
-inline __m128 _v256_extract_low(const __m256 &v) {
-  return __m128(_v256_extract_low(*((__m256i *)&v)));
-}
-
-inline __m128d _v256_extract_low(const __m256d &v) {
-  return __m128d(_v256_extract_low(*((__m256i *)&v)));
-}
-
-inline __m256i _v256_packs_epu32(const __m256i &a, const __m256i &b) {
-  return __lasx_xvssrlrni_hu_w(b, a, 0);
-}
-
-template <int i> inline int _v256_extract_b(const __m256i &a) {
-  int des[1] = {0};
-  __lasx_xvstelm_b(a, des, 0, i);
-  return des[0];
-}
-
-template <int i> inline int _v256_extract_h(const __m256i &a) {
-  int des[1] = {0};
-  __lasx_xvstelm_h(a, des, 0, i);
-  return des[0];
-}
-
-template <int i> inline int _v256_extract_w(const __m256i &a) {
-  return __lasx_xvpickve2gr_w(a, i);
-}
-
-template <int i> inline int64 _v256_extract_d(const __m256i &a) {
-  return __lasx_xvpickve2gr_d(a, i);
-}
-
-///////// Types ////////////
-
-struct v_uint8x32 {
-  typedef uchar lane_type;
-  enum { nlanes = 32 };
-  __m256i val;
-
-  explicit v_uint8x32(__m256i v) : val(v) {}
-  v_uint8x32(uchar v0, uchar v1, uchar v2, uchar v3, uchar v4, uchar v5,
-             uchar v6, uchar v7, uchar v8, uchar v9, uchar v10, uchar v11,
-             uchar v12, uchar v13, uchar v14, uchar v15, uchar v16, uchar v17,
-             uchar v18, uchar v19, uchar v20, uchar v21, uchar v22, uchar v23,
-             uchar v24, uchar v25, uchar v26, uchar v27, uchar v28, uchar v29,
-             uchar v30, uchar v31) {
-    val = _v256_setr_b((char)v0, (char)v1, (char)v2, (char)v3, (char)v4,
-                       (char)v5, (char)v6, (char)v7, (char)v8, (char)v9,
-                       (char)v10, (char)v11, (char)v12, (char)v13, (char)v14,
-                       (char)v15, (char)v16, (char)v17, (char)v18, (char)v19,
-                       (char)v20, (char)v21, (char)v22, (char)v23, (char)v24,
-                       (char)v25, (char)v26, (char)v27, (char)v28, (char)v29,
-                       (char)v30, (char)v31);
-  }
-  /* coverity[uninit_ctor]: suppress warning */
-  v_uint8x32() {}
-
-  uchar get0() const {
-    uchar des[1] = {0};
-    __lasx_xvstelm_b(val, des, 0, 0);
-    return des[0];
-  }
-};
-
-struct v_int8x32 {
-  typedef schar lane_type;
-  enum { nlanes = 32 };
-  __m256i val;
-
-  explicit v_int8x32(__m256i v) : val(v) {}
-  v_int8x32(schar v0, schar v1, schar v2, schar v3, schar v4, schar v5,
-            schar v6, schar v7, schar v8, schar v9, schar v10, schar v11,
-            schar v12, schar v13, schar v14, schar v15, schar v16, schar v17,
-            schar v18, schar v19, schar v20, schar v21, schar v22, schar v23,
-            schar v24, schar v25, schar v26, schar v27, schar v28, schar v29,
-            schar v30, schar v31) {
-    val = _v256_setr_b(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);
-  }
-  /* coverity[uninit_ctor]: suppress warning */
-  v_int8x32() {}
-
-  schar get0() const {
-    schar des[1] = {0};
-    __lasx_xvstelm_b(val, des, 0, 0);
-    return des[0];
-  }
-};
-
-struct v_uint16x16 {
-  typedef ushort lane_type;
-  enum { nlanes = 16 };
-  __m256i val;
-
-  explicit v_uint16x16(__m256i v) : val(v) {}
-  v_uint16x16(ushort v0, ushort v1, ushort v2, ushort v3, ushort v4, ushort v5,
-              ushort v6, ushort v7, ushort v8, ushort v9, ushort v10,
-              ushort v11, ushort v12, ushort v13, ushort v14, ushort v15) {
-    val = _v256_setr_h((short)v0, (short)v1, (short)v2, (short)v3, (short)v4,
-                       (short)v5, (short)v6, (short)v7, (short)v8, (short)v9,
-                       (short)v10, (short)v11, (short)v12, (short)v13,
-                       (short)v14, (short)v15);
-  }
-  /* coverity[uninit_ctor]: suppress warning */
-  v_uint16x16() {}
-
-  ushort get0() const {
-    ushort des[1] = {0};
-    __lasx_xvstelm_h(val, des, 0, 0);
-    return des[0];
-  }
-};
-
-struct v_int16x16 {
-  typedef short lane_type;
-  enum { nlanes = 16 };
-  __m256i val;
-
-  explicit v_int16x16(__m256i v) : val(v) {}
-  v_int16x16(short v0, short v1, short v2, short v3, short v4, short v5,
-             short v6, short v7, short v8, short v9, short v10, short v11,
-             short v12, short v13, short v14, short v15) {
-    val = _v256_setr_h(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
-                       v13, v14, v15);
-  }
-  /* coverity[uninit_ctor]: suppress warning */
-  v_int16x16() {}
-
-  short get0() const {
-    short des[1] = {0};
-    __lasx_xvstelm_h(val, des, 0, 0);
-    return des[0];
-  }
-};
-
-struct v_uint32x8 {
-  typedef unsigned lane_type;
-  enum { nlanes = 8 };
-  __m256i val;
-
-  explicit v_uint32x8(__m256i v) : val(v) {}
-  v_uint32x8(unsigned v0, unsigned v1, unsigned v2, unsigned v3, unsigned v4,
-             unsigned v5, unsigned v6, unsigned v7) {
-    val = _v256_setr_w((unsigned)v0, (unsigned)v1, (unsigned)v2, (unsigned)v3,
-                       (unsigned)v4, (unsigned)v5, (unsigned)v6, (unsigned)v7);
-  }
-  /* coverity[uninit_ctor]: suppress warning */
-  v_uint32x8() {}
-
-  unsigned get0() const { return __lasx_xvpickve2gr_wu(val, 0); }
-};
-
-struct v_int32x8 {
-  typedef int lane_type;
-  enum { nlanes = 8 };
-  __m256i val;
-
-  explicit v_int32x8(__m256i v) : val(v) {}
-  v_int32x8(int v0, int v1, int v2, int v3, int v4, int v5, int v6, int v7) {
-    val = _v256_setr_w(v0, v1, v2, v3, v4, v5, v6, v7);
-  }
-  /* coverity[uninit_ctor]: suppress warning */
-  v_int32x8() {}
-
-  int get0() const { return __lasx_xvpickve2gr_w(val, 0); }
-};
-
-struct v_float32x8 {
-  typedef float lane_type;
-  enum { nlanes = 8 };
-  __m256 val;
-
-  explicit v_float32x8(__m256 v) : val(v) {}
-  explicit v_float32x8(__m256i v) { val = *((__m256 *)&v); }
-  v_float32x8(float v0, float v1, float v2, float v3, float v4, float v5,
-              float v6, float v7) {
-    val = _v256_setr_ps(v0, v1, v2, v3, v4, v5, v6, v7);
-  }
-  /* coverity[uninit_ctor]: suppress warning */
-  v_float32x8() {}
-
-  float get0() const {
-    float des[1] = {0};
-    __lasx_xvstelm_w(*((__m256i *)&val), des, 0, 0);
-    return des[0];
-  }
-
-  int get0toint() const {
-    int des[1] = {0};
-    __lasx_xvstelm_w(*((__m256i *)&val), des, 0, 0);
-    return des[0];
-  }
-};
-
-struct v_uint64x4 {
-  typedef uint64 lane_type;
-  enum { nlanes = 4 };
-  __m256i val;
-
-  explicit v_uint64x4(__m256i v) : val(v) {}
-  v_uint64x4(uint64 v0, uint64 v1, uint64 v2, uint64 v3) {
-    val = _v256_setr_d((int64)v0, (int64)v1, (int64)v2, (int64)v3);
-  }
-  /* coverity[uninit_ctor]: suppress warning */
-  v_uint64x4() {}
-
-  uint64 get0() const { return __lasx_xvpickve2gr_du(val, 0); }
-};
-
-struct v_int64x4 {
-  typedef int64 lane_type;
-  enum { nlanes = 4 };
-  __m256i val;
-
-  explicit v_int64x4(__m256i v) : val(v) {}
-  v_int64x4(int64 v0, int64 v1, int64 v2, int64 v3) {
-    val = _v256_setr_d(v0, v1, v2, v3);
-  }
-  /* coverity[uninit_ctor]: suppress warning */
-  v_int64x4() {}
-
-  int64 get0() const { return __lasx_xvpickve2gr_d(val, 0); }
-};
-
-struct v_float64x4 {
-  typedef double lane_type;
-  enum { nlanes = 4 };
-  __m256d val;
-
-  explicit v_float64x4(__m256d v) : val(v) {}
-  explicit v_float64x4(__m256i v) { val = *((__m256d *)&v); }
-  v_float64x4(double v0, double v1, double v2, double v3) {
-    val = _v256_setr_pd(v0, v1, v2, v3);
-  }
-  /* coverity[uninit_ctor]: suppress warning */
-  v_float64x4() {}
-
-  double get0() const {
-    double des[1] = {0};
-    __lasx_xvstelm_d(*((__m256i *)&val), des, 0, 0);
-    return des[0];
-  }
-
-  int64 get0toint64() const {
-    int64 des[1] = {0};
-    __lasx_xvstelm_d(*((__m256i *)&val), des, 0, 0);
-    return des[0];
-  }
-};
-
-//////////////// Load and store operations ///////////////
-
-#define OPENCV_HAL_IMPL_LASX_LOADSTORE(_Tpvec, _Tp)                            \
-  inline _Tpvec v256_load(const _Tp *ptr) {                                    \
-    return _Tpvec(__lasx_xvld(ptr, 0));                                        \
-  }                                                                            \
-  inline _Tpvec v256_load_aligned(const _Tp *ptr) {                            \
-    return _Tpvec(__lasx_xvld(ptr, 0));                                        \
-  }                                                                            \
-  inline _Tpvec v256_load_low(const _Tp *ptr) {                                \
-    __m128i v128 = __lsx_vld(ptr, 0);                                          \
-    return _Tpvec(*((__m256i *)&v128));                                        \
-  }                                                                            \
-  inline _Tpvec v256_load_halves(const _Tp *ptr0, const _Tp *ptr1) {           \
-    __m128i vlo = __lsx_vld(ptr0, 0);                                          \
-    __m128i vhi = __lsx_vld(ptr1, 0);                                          \
-    return _Tpvec(_v256_combine(vlo, vhi));                                    \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a) {                             \
-    __lasx_xvst(a.val, ptr, 0);                                                \
-  }                                                                            \
-  inline void v_store_aligned(_Tp *ptr, const _Tpvec &a) {                     \
-    __lasx_xvst(a.val, ptr, 0);                                                \
-  }                                                                            \
-  inline void v_store_aligned_nocache(_Tp *ptr, const _Tpvec &a) {             \
-    __lasx_xvst(a.val, ptr, 0);                                                \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a, hal::StoreMode mode) {        \
-    if (mode == hal::STORE_UNALIGNED)                                          \
-      __lasx_xvst(a.val, ptr, 0);                                              \
-    else if (mode == hal::STORE_ALIGNED_NOCACHE)                               \
-      __lasx_xvst(a.val, ptr, 0);                                              \
-    else                                                                       \
-      __lasx_xvst(a.val, ptr, 0);                                              \
-  }                                                                            \
-  inline void v_store_low(_Tp *ptr, const _Tpvec &a) {                         \
-    __lsx_vst(_v256_extract_low(a.val), ptr, 0);                               \
-  }                                                                            \
-  inline void v_store_high(_Tp *ptr, const _Tpvec &a) {                        \
-    __lsx_vst(_v256_extract_high(a.val), ptr, 0);                              \
-  }
-
-OPENCV_HAL_IMPL_LASX_LOADSTORE(v_uint8x32, uchar)
-OPENCV_HAL_IMPL_LASX_LOADSTORE(v_int8x32, schar)
-OPENCV_HAL_IMPL_LASX_LOADSTORE(v_uint16x16, ushort)
-OPENCV_HAL_IMPL_LASX_LOADSTORE(v_int16x16, short)
-OPENCV_HAL_IMPL_LASX_LOADSTORE(v_uint32x8, unsigned)
-OPENCV_HAL_IMPL_LASX_LOADSTORE(v_int32x8, int)
-OPENCV_HAL_IMPL_LASX_LOADSTORE(v_uint64x4, uint64)
-OPENCV_HAL_IMPL_LASX_LOADSTORE(v_int64x4, int64)
-
-#define OPENCV_HAL_IMPL_LASX_LOADSTORE_FLT(_Tpvec, _Tp, halfreg)               \
-  inline _Tpvec v256_load(const _Tp *ptr) {                                    \
-    return _Tpvec(__lasx_xvld(ptr, 0));                                        \
-  }                                                                            \
-  inline _Tpvec v256_load_aligned(const _Tp *ptr) {                            \
-    return _Tpvec(__lasx_xvld(ptr, 0));                                        \
-  }                                                                            \
-  inline _Tpvec v256_load_low(const _Tp *ptr) {                                \
-    __m128i v128 = __lsx_vld(ptr, 0);                                          \
-    return _Tpvec(*((__m256i *)&v128));                                        \
-  }                                                                            \
-  inline _Tpvec v256_load_halves(const _Tp *ptr0, const _Tp *ptr1) {           \
-    halfreg vlo = __lsx_vld(ptr0, 0);                                          \
-    halfreg vhi = __lsx_vld(ptr1, 0);                                          \
-    return _Tpvec(_v256_combine(vlo, vhi));                                    \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a) {                             \
-    __lasx_xvst(a.val, ptr, 0);                                                \
-  }                                                                            \
-  inline void v_store_aligned(_Tp *ptr, const _Tpvec &a) {                     \
-    __lasx_xvst(a.val, ptr, 0);                                                \
-  }                                                                            \
-  inline void v_store_aligned_nocache(_Tp *ptr, const _Tpvec &a) {             \
-    __lasx_xvst(a.val, ptr, 0);                                                \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a, hal::StoreMode mode) {        \
-    if (mode == hal::STORE_UNALIGNED)                                          \
-      __lasx_xvst(a.val, ptr, 0);                                              \
-    else if (mode == hal::STORE_ALIGNED_NOCACHE)                               \
-      __lasx_xvst(a.val, ptr, 0);                                              \
-    else                                                                       \
-      __lasx_xvst(a.val, ptr, 0);                                              \
-  }                                                                            \
-  inline void v_store_low(_Tp *ptr, const _Tpvec &a) {                         \
-    __lsx_vst(_v256_extract_low(a.val), ptr, 0);                               \
-  }                                                                            \
-  inline void v_store_high(_Tp *ptr, const _Tpvec &a) {                        \
-    __lsx_vst(_v256_extract_high(a.val), ptr, 0);                              \
-  }
-
-OPENCV_HAL_IMPL_LASX_LOADSTORE_FLT(v_float32x8, float, __m128i)
-OPENCV_HAL_IMPL_LASX_LOADSTORE_FLT(v_float64x4, double, __m128i)
-
-inline __m256i _lasx_256_castps_si256(const __m256 &v) { return __m256i(v); }
-
-inline __m256i _lasx_256_castpd_si256(const __m256d &v) { return __m256i(v); }
-
-#define OPENCV_HAL_IMPL_LASX_CAST(_Tpvec, _Tpvecf, suffix, cast)               \
-  inline _Tpvec v_reinterpret_as_##suffix(const _Tpvecf &a) {                  \
-    return _Tpvec(cast(a.val));                                                \
-  }
-
-#define OPENCV_HAL_IMPL_LASX_INIT(_Tpvec, _Tp, suffix, ssuffix, ctype_s)       \
-  inline _Tpvec v256_setzero_##suffix() {                                      \
-    return _Tpvec(__lasx_xvreplgr2vr_d(0));                                    \
-  }                                                                            \
-  inline _Tpvec v256_setall_##suffix(_Tp v) {                                  \
-    return _Tpvec(__lasx_xvreplgr2vr_##ssuffix((ctype_s)v));                   \
-  }                                                                            \
-  template <> inline _Tpvec v_setzero_() { return v256_setzero_##suffix(); }   \
-  template <> inline _Tpvec v_setall_(_Tp v) {                                 \
-    return v256_setall_##suffix(v);                                            \
-  }                                                                            \
-  OPENCV_HAL_IMPL_LASX_CAST(_Tpvec, v_uint8x32, suffix, OPENCV_HAL_NOP)        \
-  OPENCV_HAL_IMPL_LASX_CAST(_Tpvec, v_int8x32, suffix, OPENCV_HAL_NOP)         \
-  OPENCV_HAL_IMPL_LASX_CAST(_Tpvec, v_uint16x16, suffix, OPENCV_HAL_NOP)       \
-  OPENCV_HAL_IMPL_LASX_CAST(_Tpvec, v_int16x16, suffix, OPENCV_HAL_NOP)        \
-  OPENCV_HAL_IMPL_LASX_CAST(_Tpvec, v_uint32x8, suffix, OPENCV_HAL_NOP)        \
-  OPENCV_HAL_IMPL_LASX_CAST(_Tpvec, v_int32x8, suffix, OPENCV_HAL_NOP)         \
-  OPENCV_HAL_IMPL_LASX_CAST(_Tpvec, v_uint64x4, suffix, OPENCV_HAL_NOP)        \
-  OPENCV_HAL_IMPL_LASX_CAST(_Tpvec, v_int64x4, suffix, OPENCV_HAL_NOP)         \
-  OPENCV_HAL_IMPL_LASX_CAST(_Tpvec, v_float32x8, suffix,                       \
-                            _lasx_256_castps_si256)                            \
-  OPENCV_HAL_IMPL_LASX_CAST(_Tpvec, v_float64x4, suffix, _lasx_256_castpd_si256)
-
-OPENCV_HAL_IMPL_LASX_INIT(v_uint8x32, uchar, u8, b, int)
-OPENCV_HAL_IMPL_LASX_INIT(v_int8x32, schar, s8, b, int)
-OPENCV_HAL_IMPL_LASX_INIT(v_uint16x16, ushort, u16, h, int)
-OPENCV_HAL_IMPL_LASX_INIT(v_int16x16, short, s16, h, int)
-OPENCV_HAL_IMPL_LASX_INIT(v_uint32x8, unsigned, u32, w, int)
-OPENCV_HAL_IMPL_LASX_INIT(v_int32x8, int, s32, w, int)
-OPENCV_HAL_IMPL_LASX_INIT(v_uint64x4, uint64, u64, d, long int)
-OPENCV_HAL_IMPL_LASX_INIT(v_int64x4, int64, s64, d, long int)
-
-inline __m256 _lasx_256_castsi256_ps(const __m256i &v) { return __m256(v); }
-
-inline __m256d _lasx_256_castsi256_pd(const __m256i &v) { return __m256d(v); }
-
-#define OPENCV_HAL_IMPL_LASX_INIT_FLT(_Tpvec, _Tp, suffix, zsuffix, cast)      \
-  inline _Tpvec v256_setzero_##suffix() {                                      \
-    return _Tpvec(__lasx_xvreplgr2vr_d(0));                                    \
-  }                                                                            \
-  inline _Tpvec v256_setall_##suffix(_Tp v) {                                  \
-    return _Tpvec(_v256_setall_##zsuffix(v));                                  \
-  }                                                                            \
-  template <> inline _Tpvec v_setzero_() { return v256_setzero_##suffix(); }   \
-  template <> inline _Tpvec v_setall_(_Tp v) {                                 \
-    return v256_setall_##suffix(v);                                            \
-  }                                                                            \
-  OPENCV_HAL_IMPL_LASX_CAST(_Tpvec, v_uint8x32, suffix, cast)                  \
-  OPENCV_HAL_IMPL_LASX_CAST(_Tpvec, v_int8x32, suffix, cast)                   \
-  OPENCV_HAL_IMPL_LASX_CAST(_Tpvec, v_uint16x16, suffix, cast)                 \
-  OPENCV_HAL_IMPL_LASX_CAST(_Tpvec, v_int16x16, suffix, cast)                  \
-  OPENCV_HAL_IMPL_LASX_CAST(_Tpvec, v_uint32x8, suffix, cast)                  \
-  OPENCV_HAL_IMPL_LASX_CAST(_Tpvec, v_int32x8, suffix, cast)                   \
-  OPENCV_HAL_IMPL_LASX_CAST(_Tpvec, v_uint64x4, suffix, cast)                  \
-  OPENCV_HAL_IMPL_LASX_CAST(_Tpvec, v_int64x4, suffix, cast)
-
-OPENCV_HAL_IMPL_LASX_INIT_FLT(v_float32x8, float, f32, ps,
-                              _lasx_256_castsi256_ps)
-OPENCV_HAL_IMPL_LASX_INIT_FLT(v_float64x4, double, f64, pd,
-                              _lasx_256_castsi256_pd)
-
-inline v_float32x8 v_reinterpret_as_f32(const v_float32x8 &a) { return a; }
-inline v_float32x8 v_reinterpret_as_f32(const v_float64x4 &a) {
-  return v_float32x8(_lasx_256_castps_si256(__m256(a.val)));
-}
-
-inline v_float64x4 v_reinterpret_as_f64(const v_float64x4 &a) { return a; }
-inline v_float64x4 v_reinterpret_as_f64(const v_float32x8 &a) {
-  return v_float64x4(_lasx_256_castpd_si256(__m256d(a.val)));
-}
-
-//////////////// Variant Value reordering ///////////////
-
-// unpacks
-#define OPENCV_HAL_IMPL_LASX_UNPACK(_Tpvec, suffix)                            \
-  inline _Tpvec v256_unpacklo(const _Tpvec &a, const _Tpvec &b) {              \
-    return _Tpvec(__lasx_xvilvl_##suffix(__m256i(b.val), __m256i(a.val)));     \
-  }                                                                            \
-  inline _Tpvec v256_unpackhi(const _Tpvec &a, const _Tpvec &b) {              \
-    return _Tpvec(__lasx_xvilvh_##suffix(__m256i(b.val), __m256i(a.val)));     \
-  }
-
-OPENCV_HAL_IMPL_LASX_UNPACK(v_uint8x32, b)
-OPENCV_HAL_IMPL_LASX_UNPACK(v_int8x32, b)
-OPENCV_HAL_IMPL_LASX_UNPACK(v_uint16x16, h)
-OPENCV_HAL_IMPL_LASX_UNPACK(v_int16x16, h)
-OPENCV_HAL_IMPL_LASX_UNPACK(v_uint32x8, w)
-OPENCV_HAL_IMPL_LASX_UNPACK(v_int32x8, w)
-OPENCV_HAL_IMPL_LASX_UNPACK(v_uint64x4, d)
-OPENCV_HAL_IMPL_LASX_UNPACK(v_int64x4, d)
-OPENCV_HAL_IMPL_LASX_UNPACK(v_float32x8, w)
-OPENCV_HAL_IMPL_LASX_UNPACK(v_float64x4, d)
-
-// shuffle
-// todo: emulate 64bit
-#define OPENCV_HAL_IMPL_LASX_SHUFFLE(_Tpvec, intrin)                           \
-  template <int m> inline _Tpvec v256_shuffle(const _Tpvec &a) {               \
-    return _Tpvec(__lasx_xvshuf4i_##intrin(a.val, m));                         \
-  }
-
-OPENCV_HAL_IMPL_LASX_SHUFFLE(v_uint32x8, w)
-OPENCV_HAL_IMPL_LASX_SHUFFLE(v_int32x8, w)
-
-template <int m> inline v_float32x8 v256_shuffle(const v_float32x8 &a) {
-  return v_float32x8(__lasx_xvshuf4i_w(*((__m256i *)&a.val), m));
-}
-
-template <int m> inline v_float64x4 v256_shuffle(const v_float64x4 &a) {
-  const int m1 = m & 0b1;
-  const int m2 = m & 0b10;
-  const int m3 = m & 0b100;
-  const int m4 = m & 0b1000;
-  const int m5 = m2 << 1;
-  const int m6 = m3 << 2;
-  const int m7 = m4 << 3;
-  const int m8 = m1 & m5 & m6 & m7;
-
-  return v_float64x4(
-      __lasx_xvshuf4i_d(*((__m256i *)&a.val), *((__m256i *)&a.val), m8));
-}
-
-template <typename _Tpvec>
-inline void v256_zip(const _Tpvec &a, const _Tpvec &b, _Tpvec &ab0,
-                     _Tpvec &ab1) {
-  ab0 = v256_unpacklo(a, b);
-  ab1 = v256_unpackhi(a, b);
-}
-
-template <typename _Tpvec>
-inline _Tpvec v256_combine_diagonal(const _Tpvec &a, const _Tpvec &b) {
-  return _Tpvec(__lasx_xvpermi_q(a.val, b.val, 0x12));
-}
-
-inline v_float32x8 v256_combine_diagonal(const v_float32x8 &a,
-                                         const v_float32x8 &b) {
-  return v_float32x8(__lasx_xvpermi_q(a.val, b.val, 0x12));
-}
-
-inline v_float64x4 v256_combine_diagonal(const v_float64x4 &a,
-                                         const v_float64x4 &b) {
-  return v_float64x4(__lasx_xvpermi_q(a.val, b.val, 0x12));
-}
-
-template <typename _Tpvec>
-inline _Tpvec v256_alignr_128(const _Tpvec &a, const _Tpvec &b) {
-  return v256_permute2x128<0x03>(a, b);
-}
-
-inline __m256i _v256_alignr_b(const __m256i &a, const __m256i &b,
-                              const int imm) {
-  if (imm == 8) {
-    return __lasx_xvshuf4i_d(b, a, 0x9); // b.d1 a.d0 b.d3 a.d2
-  } else {
-    __m256i byteIndex =
-        _v256_setr_b(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);
-    return __lasx_xvshuf_b(
-        a, b, __lasx_xvadd_b(__lasx_xvreplgr2vr_b(imm), byteIndex));
-  }
-}
-
-template <typename _Tpvec>
-inline _Tpvec v256_alignr_64(const _Tpvec &a, const _Tpvec &b) {
-  return _Tpvec(_v256_alignr_b(a.val, b.val, 8));
-}
-inline v_float64x4 v256_alignr_64(const v_float64x4 &a, const v_float64x4 &b) {
-  return v_float64x4(__lasx_xvshuf4i_d(b.val, a.val, 0x9));
-} // b.d1 a.d0 b.d3 a.d2
-// todo: emulate float32
-
-template <typename _Tpvec> inline _Tpvec v256_swap_halves(const _Tpvec &a) {
-  return v256_permute2x128<1>(a, a);
-}
-
-template <typename _Tpvec> inline _Tpvec v256_reverse_64(const _Tpvec &a) {
-  return v256_permute4x64<0x1b>(a);
-}
-
-// ZIP
-#define OPENCV_HAL_IMPL_LASX_ZIP(_Tpvec)                                       \
-  inline _Tpvec v_combine_low(const _Tpvec &a, const _Tpvec &b) {              \
-    return v256_permute2x128<0x02>(a, b);                                      \
-  }                                                                            \
-  inline _Tpvec v_combine_high(const _Tpvec &a, const _Tpvec &b) {             \
-    return v256_permute2x128<0x13>(a, b);                                      \
-  }                                                                            \
-  inline void v_recombine(const _Tpvec &a, const _Tpvec &b, _Tpvec &c,         \
-                          _Tpvec &d) {                                         \
-    _Tpvec a1b0 = v256_alignr_128(a, b);                                       \
-    c = v256_combine_diagonal(a, a1b0);                                        \
-    d = v256_combine_diagonal(a1b0, b);                                        \
-  }                                                                            \
-  inline void v_zip(const _Tpvec &a, const _Tpvec &b, _Tpvec &ab0,             \
-                    _Tpvec &ab1) {                                             \
-    _Tpvec ab0ab2, ab1ab3;                                                     \
-    v256_zip(a, b, ab0ab2, ab1ab3);                                            \
-    v_recombine(ab0ab2, ab1ab3, ab0, ab1);                                     \
-  }
-
-OPENCV_HAL_IMPL_LASX_ZIP(v_uint8x32)
-OPENCV_HAL_IMPL_LASX_ZIP(v_int8x32)
-OPENCV_HAL_IMPL_LASX_ZIP(v_uint16x16)
-OPENCV_HAL_IMPL_LASX_ZIP(v_int16x16)
-OPENCV_HAL_IMPL_LASX_ZIP(v_uint32x8)
-OPENCV_HAL_IMPL_LASX_ZIP(v_int32x8)
-OPENCV_HAL_IMPL_LASX_ZIP(v_uint64x4)
-OPENCV_HAL_IMPL_LASX_ZIP(v_int64x4)
-OPENCV_HAL_IMPL_LASX_ZIP(v_float32x8)
-OPENCV_HAL_IMPL_LASX_ZIP(v_float64x4)
-
-////////// Arithmetic, bitwise and comparison operations /////////
-
-/** Arithmetics **/
-#define OPENCV_HAL_IMPL_LASX_BIN_OP(bin_op, _Tpvec, intrin)                    \
-  inline _Tpvec bin_op(const _Tpvec &a, const _Tpvec &b) {                     \
-    return _Tpvec(intrin(a.val, b.val));                                       \
-  }
-
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_add, v_uint8x32, __lasx_xvsadd_bu)
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_sub, v_uint8x32, __lasx_xvssub_bu)
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_add, v_int8x32, __lasx_xvsadd_b)
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_sub, v_int8x32, __lasx_xvssub_b)
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_add, v_uint16x16, __lasx_xvsadd_hu)
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_sub, v_uint16x16, __lasx_xvssub_hu)
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_add, v_int16x16, __lasx_xvsadd_h)
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_sub, v_int16x16, __lasx_xvssub_h)
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_add, v_uint32x8, __lasx_xvadd_w)
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_sub, v_uint32x8, __lasx_xvsub_w)
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_mul, v_uint32x8, __lasx_xvmul_w)
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_add, v_int32x8, __lasx_xvadd_w)
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_sub, v_int32x8, __lasx_xvsub_w)
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_mul, v_int32x8, __lasx_xvmul_w)
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_add, v_uint64x4, __lasx_xvadd_d)
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_sub, v_uint64x4, __lasx_xvsub_d)
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_add, v_int64x4, __lasx_xvadd_d)
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_sub, v_int64x4, __lasx_xvsub_d)
-
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_add, v_float32x8, __lasx_xvfadd_s)
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_sub, v_float32x8, __lasx_xvfsub_s)
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_mul, v_float32x8, __lasx_xvfmul_s)
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_div, v_float32x8, __lasx_xvfdiv_s)
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_add, v_float64x4, __lasx_xvfadd_d)
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_sub, v_float64x4, __lasx_xvfsub_d)
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_mul, v_float64x4, __lasx_xvfmul_d)
-OPENCV_HAL_IMPL_LASX_BIN_OP(v_div, v_float64x4, __lasx_xvfdiv_d)
-
-// saturating multiply 8-bit, 16-bit
-inline v_uint8x32 v_mul(const v_uint8x32 &a, const v_uint8x32 &b) {
-  v_uint16x16 c, d;
-  v_mul_expand(a, b, c, d);
-  return v_pack(c, d);
-}
-inline v_int8x32 v_mul(const v_int8x32 &a, const v_int8x32 &b) {
-  v_int16x16 c, d;
-  v_mul_expand(a, b, c, d);
-  return v_pack(c, d);
-}
-inline v_uint16x16 v_mul(const v_uint16x16 &a, const v_uint16x16 &b) {
-  __m256i pl = __lasx_xvmul_h(a.val, b.val);
-  __m256i ph = __lasx_xvmuh_hu(a.val, b.val);
-  __m256i p0 = __lasx_xvilvl_h(ph, pl);
-  __m256i p1 = __lasx_xvilvh_h(ph, pl);
-  return v_uint16x16(_v256_packs_epu32(p0, p1));
-}
-inline v_int16x16 v_mul(const v_int16x16 &a, const v_int16x16 &b) {
-  __m256i pl = __lasx_xvmul_h(a.val, b.val);
-  __m256i ph = __lasx_xvmuh_h(a.val, b.val);
-  __m256i p0 = __lasx_xvilvl_h(ph, pl);
-  __m256i p1 = __lasx_xvilvh_h(ph, pl);
-  return v_int16x16(_lasx_packs_w(p0, p1));
-}
-
-/** Non-saturating arithmetics **/
-
-#define OPENCV_HAL_IMPL_LASX_BIN_FUNC(func, _Tpvec, intrin)                    \
-  inline _Tpvec func(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(intrin(a.val, b.val));                                       \
-  }
-
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_add_wrap, v_uint8x32, __lasx_xvadd_b)
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_add_wrap, v_int8x32, __lasx_xvadd_b)
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_add_wrap, v_uint16x16, __lasx_xvadd_h)
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_add_wrap, v_int16x16, __lasx_xvadd_h)
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_sub_wrap, v_uint8x32, __lasx_xvsub_b)
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_sub_wrap, v_int8x32, __lasx_xvsub_b)
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_sub_wrap, v_uint16x16, __lasx_xvsub_h)
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_sub_wrap, v_int16x16, __lasx_xvsub_h)
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_mul_wrap, v_uint16x16, __lasx_xvmul_h)
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_mul_wrap, v_int16x16, __lasx_xvmul_h)
-
-inline v_uint8x32 v_mul_wrap(const v_uint8x32 &a, const v_uint8x32 &b) {
-  __m256i p0 = __lasx_xvmulwev_h_bu(a.val, b.val);
-  __m256i p1 = __lasx_xvmulwod_h_bu(a.val, b.val);
-  return v_uint8x32(__lasx_xvpackev_b(p1, p0));
-}
-
-inline v_int8x32 v_mul_wrap(const v_int8x32 &a, const v_int8x32 &b) {
-  return v_reinterpret_as_s8(
-      v_mul_wrap(v_reinterpret_as_u8(a), v_reinterpret_as_u8(b)));
-}
-
-//  Multiply and expand
-inline void v_mul_expand(const v_uint8x32 &a, const v_uint8x32 &b,
-                         v_uint16x16 &c, v_uint16x16 &d) {
-  v_uint16x16 a0, a1, b0, b1;
-  v_expand(a, a0, a1);
-  v_expand(b, b0, b1);
-  c = v_mul_wrap(a0, b0);
-  d = v_mul_wrap(a1, b1);
-}
-
-inline void v_mul_expand(const v_int8x32 &a, const v_int8x32 &b, v_int16x16 &c,
-                         v_int16x16 &d) {
-  v_int16x16 a0, a1, b0, b1;
-  v_expand(a, a0, a1);
-  v_expand(b, b0, b1);
-  c = v_mul_wrap(a0, b0);
-  d = v_mul_wrap(a1, b1);
-}
-
-inline void v_mul_expand(const v_int16x16 &a, const v_int16x16 &b, v_int32x8 &c,
-                         v_int32x8 &d) {
-  v_int16x16 vhi = v_int16x16(__lasx_xvmuh_h(a.val, b.val));
-
-  v_int16x16 v0, v1;
-  v_zip(v_mul_wrap(a, b), vhi, v0, v1);
-
-  c = v_reinterpret_as_s32(v0);
-  d = v_reinterpret_as_s32(v1);
-}
-
-inline void v_mul_expand(const v_uint16x16 &a, const v_uint16x16 &b,
-                         v_uint32x8 &c, v_uint32x8 &d) {
-  v_uint16x16 vhi = v_uint16x16(__lasx_xvmuh_hu(a.val, b.val));
-
-  v_uint16x16 v0, v1;
-  v_zip(v_mul_wrap(a, b), vhi, v0, v1);
-
-  c = v_reinterpret_as_u32(v0);
-  d = v_reinterpret_as_u32(v1);
-}
-
-inline void v_mul_expand(const v_uint32x8 &a, const v_uint32x8 &b,
-                         v_uint64x4 &c, v_uint64x4 &d) {
-  __m256i v0 = __lasx_xvmulwev_d_wu(a.val, b.val);
-  __m256i v1 = __lasx_xvmulwod_d_wu(a.val, b.val);
-  v_zip(v_uint64x4(v0), v_uint64x4(v1), c, d);
-}
-
-inline v_int16x16 v_mul_hi(const v_int16x16 &a, const v_int16x16 &b) {
-  return v_int16x16(__lasx_xvmuh_h(a.val, b.val));
-}
-inline v_uint16x16 v_mul_hi(const v_uint16x16 &a, const v_uint16x16 &b) {
-  return v_uint16x16(__lasx_xvmuh_hu(a.val, b.val));
-}
-
-/** Bitwise shifts **/
-#define OPENCV_HAL_IMPL_LASX_SHIFT_OP(_Tpuvec, _Tpsvec, suffix, srai)          \
-  inline _Tpuvec v_shl(const _Tpuvec &a, int imm) {                            \
-    return _Tpuvec(                                                            \
-        __lasx_xvsll_##suffix(a.val, __lasx_xvreplgr2vr_##suffix(imm)));       \
-  }                                                                            \
-  inline _Tpsvec v_shl(const _Tpsvec &a, int imm) {                            \
-    return _Tpsvec(                                                            \
-        __lasx_xvsll_##suffix(a.val, __lasx_xvreplgr2vr_##suffix(imm)));       \
-  }                                                                            \
-  inline _Tpuvec v_shr(const _Tpuvec &a, int imm) {                            \
-    return _Tpuvec(                                                            \
-        __lasx_xvsrl_##suffix(a.val, __lasx_xvreplgr2vr_##suffix(imm)));       \
-  }                                                                            \
-  inline _Tpsvec v_shr(const _Tpsvec &a, int imm) {                            \
-    return _Tpsvec(srai(a.val, __lasx_xvreplgr2vr_##suffix(imm)));             \
-  }                                                                            \
-  template <int imm> inline _Tpuvec v_shl(const _Tpuvec &a) {                  \
-    return _Tpuvec(                                                            \
-        __lasx_xvsll_##suffix(a.val, __lasx_xvreplgr2vr_##suffix(imm)));       \
-  }                                                                            \
-  template <int imm> inline _Tpsvec v_shl(const _Tpsvec &a) {                  \
-    return _Tpsvec(                                                            \
-        __lasx_xvsll_##suffix(a.val, __lasx_xvreplgr2vr_##suffix(imm)));       \
-  }                                                                            \
-  template <int imm> inline _Tpuvec v_shr(const _Tpuvec &a) {                  \
-    return _Tpuvec(                                                            \
-        __lasx_xvsrl_##suffix(a.val, __lasx_xvreplgr2vr_##suffix(imm)));       \
-  }                                                                            \
-  template <int imm> inline _Tpsvec v_shr(const _Tpsvec &a) {                  \
-    return _Tpsvec(srai(a.val, __lasx_xvreplgr2vr_##suffix(imm)));             \
-  }
-
-OPENCV_HAL_IMPL_LASX_SHIFT_OP(v_uint16x16, v_int16x16, h, __lasx_xvsra_h)
-OPENCV_HAL_IMPL_LASX_SHIFT_OP(v_uint32x8, v_int32x8, w, __lasx_xvsra_w)
-OPENCV_HAL_IMPL_LASX_SHIFT_OP(v_uint64x4, v_int64x4, d, __lasx_xvsra_d)
-
-/** Bitwise logic **/
-#define OPENCV_HAL_IMPL_LASX_LOGIC_OP(_Tpvec, suffix, not_const)               \
-  OPENCV_HAL_IMPL_LASX_BIN_OP(v_and, _Tpvec, __lasx_xvand_##suffix)            \
-  OPENCV_HAL_IMPL_LASX_BIN_OP(v_or, _Tpvec, __lasx_xvor_##suffix)              \
-  OPENCV_HAL_IMPL_LASX_BIN_OP(v_xor, _Tpvec, __lasx_xvxor_##suffix)            \
-  inline _Tpvec v_not(const _Tpvec &a) {                                       \
-    return _Tpvec(__lasx_xvnori_b(a.val, 0));                                  \
-  }
-
-OPENCV_HAL_IMPL_LASX_LOGIC_OP(v_uint8x32, v, __lasx_xvreplgr2vr_w(-1))
-OPENCV_HAL_IMPL_LASX_LOGIC_OP(v_int8x32, v, __lasx_xvreplgr2vr_w(-1))
-OPENCV_HAL_IMPL_LASX_LOGIC_OP(v_uint16x16, v, __lasx_xvreplgr2vr_w(-1))
-OPENCV_HAL_IMPL_LASX_LOGIC_OP(v_int16x16, v, __lasx_xvreplgr2vr_w(-1))
-OPENCV_HAL_IMPL_LASX_LOGIC_OP(v_uint32x8, v, __lasx_xvreplgr2vr_w(-1))
-OPENCV_HAL_IMPL_LASX_LOGIC_OP(v_int32x8, v, __lasx_xvreplgr2vr_w(-1))
-OPENCV_HAL_IMPL_LASX_LOGIC_OP(v_uint64x4, v, __lasx_xvreplgr2vr_d(-1))
-OPENCV_HAL_IMPL_LASX_LOGIC_OP(v_int64x4, v, __lasx_xvreplgr2vr_d(-1))
-
-#define OPENCV_HAL_IMPL_LASX_FLOAT_BIN_OP(bin_op, _Tpvec, intrin, cast)        \
-  inline _Tpvec bin_op(const _Tpvec &a, const _Tpvec &b) {                     \
-    return _Tpvec(intrin(*((__m256i *)(&a.val)), *((__m256i *)(&b.val))));     \
-  }
-
-#define OPENCV_HAL_IMPL_LASX_FLOAT_LOGIC_OP(_Tpvec, suffix, not_const, cast)   \
-  OPENCV_HAL_IMPL_LASX_FLOAT_BIN_OP(v_and, _Tpvec, __lasx_xvand_##suffix,      \
-                                    cast)                                      \
-  OPENCV_HAL_IMPL_LASX_FLOAT_BIN_OP(v_or, _Tpvec, __lasx_xvor_##suffix, cast)  \
-  OPENCV_HAL_IMPL_LASX_FLOAT_BIN_OP(v_xor, _Tpvec, __lasx_xvxor_##suffix,      \
-                                    cast)                                      \
-  inline _Tpvec v_not(const _Tpvec &a) {                                       \
-    return _Tpvec(__lasx_xvxor_##suffix(*((__m256i *)(&a.val)), not_const));   \
-  }
-
-OPENCV_HAL_IMPL_LASX_FLOAT_LOGIC_OP(v_float32x8, v, __lasx_xvreplgr2vr_w(-1),
-                                    _lasx_256_castsi256_ps)
-OPENCV_HAL_IMPL_LASX_FLOAT_LOGIC_OP(v_float64x4, v, __lasx_xvreplgr2vr_d(-1),
-                                    _lasx_256_castsi256_pd)
-
-/** Select **/
-#define OPENCV_HAL_IMPL_LASX_SELECT(_Tpvec)                                    \
-  inline _Tpvec v_select(const _Tpvec &mask, const _Tpvec &a,                  \
-                         const _Tpvec &b) {                                    \
-    return _Tpvec(__lasx_xvbitsel_v(b.val, a.val, mask.val));                  \
-  }
-
-OPENCV_HAL_IMPL_LASX_SELECT(v_uint8x32)
-OPENCV_HAL_IMPL_LASX_SELECT(v_int8x32)
-OPENCV_HAL_IMPL_LASX_SELECT(v_uint16x16)
-OPENCV_HAL_IMPL_LASX_SELECT(v_int16x16)
-OPENCV_HAL_IMPL_LASX_SELECT(v_uint32x8)
-OPENCV_HAL_IMPL_LASX_SELECT(v_int32x8)
-
-inline v_float32x8 v_select(const v_float32x8 &mask, const v_float32x8 &a,
-                            const v_float32x8 &b) {
-  return v_float32x8(__lasx_xvbitsel_v(
-      *((__m256i *)&b.val), *((__m256i *)&a.val), *((__m256i *)&mask.val)));
-}
-
-inline v_float64x4 v_select(const v_float64x4 &mask, const v_float64x4 &a,
-                            const v_float64x4 &b) {
-  return v_float64x4(__lasx_xvbitsel_v(
-      *((__m256i *)&b.val), *((__m256i *)&a.val), *((__m256i *)&mask.val)));
-}
-
-/** Comparison **/
-#define OPENCV_HAL_IMPL_LASX_CMP_OP_OV(_Tpvec)                                 \
-  inline _Tpvec v_ne(const _Tpvec &a, const _Tpvec &b) {                       \
-    return v_not(v_eq(a, b));                                                  \
-  }                                                                            \
-  inline _Tpvec v_lt(const _Tpvec &a, const _Tpvec &b) { return v_gt(b, a); }  \
-  inline _Tpvec v_ge(const _Tpvec &a, const _Tpvec &b) {                       \
-    return v_not(v_lt(a, b));                                                  \
-  }                                                                            \
-  inline _Tpvec v_le(const _Tpvec &a, const _Tpvec &b) { return v_ge(b, a); }
-
-#define OPENCV_HAL_IMPL_LASX_CMP_OP_INT(_Tpuvec, _Tpsvec, suffix, usuffix)     \
-  inline _Tpuvec v_eq(const _Tpuvec &a, const _Tpuvec &b) {                    \
-    return _Tpuvec(__lasx_xvseq_##suffix(a.val, b.val));                       \
-  }                                                                            \
-  inline _Tpuvec v_gt(const _Tpuvec &a, const _Tpuvec &b) {                    \
-    return _Tpuvec(__lasx_xvslt_##usuffix(b.val, a.val));                      \
-  }                                                                            \
-  inline _Tpsvec v_eq(const _Tpsvec &a, const _Tpsvec &b) {                    \
-    return _Tpsvec(__lasx_xvseq_##suffix(a.val, b.val));                       \
-  }                                                                            \
-  inline _Tpsvec v_gt(const _Tpsvec &a, const _Tpsvec &b) {                    \
-    return _Tpsvec(__lasx_xvslt_##suffix(b.val, a.val));                       \
-  }                                                                            \
-  OPENCV_HAL_IMPL_LASX_CMP_OP_OV(_Tpuvec)                                      \
-  OPENCV_HAL_IMPL_LASX_CMP_OP_OV(_Tpsvec)
-
-OPENCV_HAL_IMPL_LASX_CMP_OP_INT(v_uint8x32, v_int8x32, b, bu)
-OPENCV_HAL_IMPL_LASX_CMP_OP_INT(v_uint16x16, v_int16x16, h, hu)
-OPENCV_HAL_IMPL_LASX_CMP_OP_INT(v_uint32x8, v_int32x8, w, wu)
-
-#define OPENCV_HAL_IMPL_LASX_CMP_OP_64BIT(_Tpvec, suffix)                      \
-  inline _Tpvec v_eq(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(__lasx_xvseq_##suffix(a.val, b.val));                        \
-  }                                                                            \
-  inline _Tpvec v_ne(const _Tpvec &a, const _Tpvec &b) {                       \
-    return v_not(v_eq(a, b));                                                  \
-  }
-
-OPENCV_HAL_IMPL_LASX_CMP_OP_64BIT(v_uint64x4, d)
-OPENCV_HAL_IMPL_LASX_CMP_OP_64BIT(v_int64x4, d)
-
-#define OPENCV_HAL_IMPL_LASX_CMP_FLT(bin_op, suffix, _Tpvec, ssuffix)          \
-  inline _Tpvec bin_op(const _Tpvec &a, const _Tpvec &b) {                     \
-    return _Tpvec(__lasx_##suffix##_##ssuffix(a.val, b.val));                  \
-  }
-
-#define OPENCV_HAL_IMPL_LASX_CMP_OP_FLT(_Tpvec, ssuffix)                       \
-  OPENCV_HAL_IMPL_LASX_CMP_FLT(v_eq, xvfcmp_ceq, _Tpvec, ssuffix)              \
-  OPENCV_HAL_IMPL_LASX_CMP_FLT(v_ne, xvfcmp_cne, _Tpvec, ssuffix)              \
-  OPENCV_HAL_IMPL_LASX_CMP_FLT(v_lt, xvfcmp_clt, _Tpvec, ssuffix)              \
-  OPENCV_HAL_IMPL_LASX_CMP_FLT(v_le, xvfcmp_cle, _Tpvec, ssuffix)
-
-OPENCV_HAL_IMPL_LASX_CMP_OP_FLT(v_float32x8, s)
-OPENCV_HAL_IMPL_LASX_CMP_OP_FLT(v_float64x4, d)
-
-inline v_float32x8 v_gt(const v_float32x8 &a, const v_float32x8 &b) {
-  return v_float32x8(__lasx_xvfcmp_clt_s(b.val, a.val));
-}
-
-inline v_float32x8 v_ge(const v_float32x8 &a, const v_float32x8 &b) {
-  return v_float32x8(__lasx_xvfcmp_cle_s(b.val, a.val));
-}
-
-inline v_float64x4 v_gt(const v_float64x4 &a, const v_float64x4 &b) {
-  return v_float64x4(__lasx_xvfcmp_clt_d(b.val, a.val));
-}
-
-inline v_float64x4 v_ge(const v_float64x4 &a, const v_float64x4 &b) {
-  return v_float64x4(__lasx_xvfcmp_cle_d(b.val, a.val));
-}
-
-inline v_float32x8 v_not_nan(const v_float32x8 &a) {
-  return v_float32x8(__lasx_xvfcmp_cor_s(a.val, a.val));
-}
-inline v_float64x4 v_not_nan(const v_float64x4 &a) {
-  return v_float64x4(__lasx_xvfcmp_cor_d(a.val, a.val));
-}
-
-/** min/max **/
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_min, v_uint8x32, __lasx_xvmin_bu)
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_max, v_uint8x32, __lasx_xvmax_bu)
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_min, v_int8x32, __lasx_xvmin_b)
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_max, v_int8x32, __lasx_xvmax_b)
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_min, v_uint16x16, __lasx_xvmin_hu)
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_max, v_uint16x16, __lasx_xvmax_hu)
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_min, v_int16x16, __lasx_xvmin_h)
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_max, v_int16x16, __lasx_xvmax_h)
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_min, v_uint32x8, __lasx_xvmin_wu)
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_max, v_uint32x8, __lasx_xvmax_wu)
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_min, v_int32x8, __lasx_xvmin_w)
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_max, v_int32x8, __lasx_xvmax_w)
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_min, v_float32x8, __lasx_xvfmin_s)
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_max, v_float32x8, __lasx_xvfmax_s)
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_min, v_float64x4, __lasx_xvfmin_d)
-OPENCV_HAL_IMPL_LASX_BIN_FUNC(v_max, v_float64x4, __lasx_xvfmax_d)
-
-/** Rotate **/
-template <int imm>
-inline v_uint8x32 v_rotate_left(const v_uint8x32 &a, const v_uint8x32 &b) {
-  enum { IMM_R = (16 - imm) & 0xFF };
-  enum { IMM_R2 = (32 - imm) & 0xFF };
-
-  if (imm == 0)
-    return a;
-  if (imm == 32)
-    return b;
-  if (imm > 32)
-    return v_uint8x32();
-
-  __m256i swap = _v256_permute2x128<0x21>(a.val, b.val);
-  if (imm == 16)
-    return v_uint8x32(swap);
-  if (imm < 16)
-    return v_uint8x32(_v256_alignr_b(a.val, swap, IMM_R));
-  return v_uint8x32(_v256_alignr_b(swap, b.val, IMM_R2)); // imm < 32
-}
-
-template <int imm>
-inline v_uint8x32 v_rotate_right(const v_uint8x32 &a, const v_uint8x32 &b) {
-  enum { IMM_L = (imm - 16) & 0xFF };
-
-  if (imm == 0)
-    return a;
-  if (imm == 32)
-    return b;
-  if (imm > 32)
-    return v_uint8x32();
-
-  __m256i swap = _v256_permute2x128<0x03>(a.val, b.val);
-  if (imm == 16)
-    return v_uint8x32(swap);
-  if (imm < 16)
-    return v_uint8x32(_v256_alignr_b(swap, a.val, imm));
-  return v_uint8x32(_v256_alignr_b(b.val, swap, IMM_L));
-}
-
-template <int imm> inline v_uint8x32 v_rotate_left(const v_uint8x32 &a) {
-  enum { IMM_L = ((imm - 16) & 0xFF) > 31 ? 31 : ((imm - 16) & 0xFF) };
-  enum { IMM_R = (16 - imm) & 0xFF };
-
-  if (imm == 0)
-    return a;
-  if (imm > 32)
-    return v_uint8x32();
-
-  // ESAC control[3] ? [127:0] = 0
-  __m256i vzero = __lasx_xvreplgr2vr_w(0);
-  __m256i swapz = __lasx_xvpermi_q(a.val, vzero, 0x20);
-  ;
-  if (imm == 16)
-    return v_uint8x32(swapz);
-  if (imm < 16)
-    return v_uint8x32(_v256_alignr_b(a.val, swapz, IMM_R));
-  return v_uint8x32(__lasx_xvbsll_v(swapz, IMM_L));
-}
-
-template <int imm> inline v_uint8x32 v_rotate_right(const v_uint8x32 &a) {
-  enum { IMM_L = ((imm - 16) & 0xFF) > 31 ? 31 : ((imm - 16) & 0xFF) };
-
-  if (imm == 0)
-    return a;
-  if (imm > 32)
-    return v_uint8x32();
-
-  // ESAC control[3] ? [127:0] = 0
-  __m256i vzero = __lasx_xvreplgr2vr_w(0);
-  __m256i swapz = __lasx_xvpermi_q(vzero, a.val, 0x21);
-  ;
-  if (imm == 16)
-    return v_uint8x32(swapz);
-  if (imm < 16)
-    return v_uint8x32(_v256_alignr_b(swapz, a.val, imm));
-  return v_uint8x32(__lasx_xvbsrl_v(swapz, IMM_L));
-}
-
-#define OPENCV_HAL_IMPL_LASX_ROTATE_CAST(intrin, _Tpvec, cast)                 \
-  template <int imm> inline _Tpvec intrin(const _Tpvec &a, const _Tpvec &b) {  \
-    enum { IMMxW = imm * sizeof(typename _Tpvec::lane_type) };                 \
-    v_uint8x32 ret =                                                           \
-        intrin<IMMxW>(v_reinterpret_as_u8(a), v_reinterpret_as_u8(b));         \
-    return _Tpvec(cast(ret.val));                                              \
-  }                                                                            \
-  template <int imm> inline _Tpvec intrin(const _Tpvec &a) {                   \
-    enum { IMMxW = imm * sizeof(typename _Tpvec::lane_type) };                 \
-    v_uint8x32 ret = intrin<IMMxW>(v_reinterpret_as_u8(a));                    \
-    return _Tpvec(cast(ret.val));                                              \
-  }
-
-#define OPENCV_HAL_IMPL_LASX_ROTATE(_Tpvec)                                    \
-  OPENCV_HAL_IMPL_LASX_ROTATE_CAST(v_rotate_left, _Tpvec, OPENCV_HAL_NOP)      \
-  OPENCV_HAL_IMPL_LASX_ROTATE_CAST(v_rotate_right, _Tpvec, OPENCV_HAL_NOP)
-
-OPENCV_HAL_IMPL_LASX_ROTATE(v_int8x32)
-OPENCV_HAL_IMPL_LASX_ROTATE(v_uint16x16)
-OPENCV_HAL_IMPL_LASX_ROTATE(v_int16x16)
-OPENCV_HAL_IMPL_LASX_ROTATE(v_uint32x8)
-OPENCV_HAL_IMPL_LASX_ROTATE(v_int32x8)
-OPENCV_HAL_IMPL_LASX_ROTATE(v_uint64x4)
-OPENCV_HAL_IMPL_LASX_ROTATE(v_int64x4)
-
-OPENCV_HAL_IMPL_LASX_ROTATE_CAST(v_rotate_left, v_float32x8,
-                                 _lasx_256_castsi256_ps)
-OPENCV_HAL_IMPL_LASX_ROTATE_CAST(v_rotate_right, v_float32x8,
-                                 _lasx_256_castsi256_ps)
-OPENCV_HAL_IMPL_LASX_ROTATE_CAST(v_rotate_left, v_float64x4,
-                                 _lasx_256_castsi256_pd)
-OPENCV_HAL_IMPL_LASX_ROTATE_CAST(v_rotate_right, v_float64x4,
-                                 _lasx_256_castsi256_pd)
-
-/** Reverse **/
-inline v_uint8x32 v_reverse(const v_uint8x32 &a) {
-  static const __m256i perm =
-      _v256_setr_b(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
-                   13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
-  __m256i vec = __lasx_xvshuf_b(a.val, a.val, perm);
-  return v_uint8x32(__lasx_xvpermi_q(vec, vec, 1));
-}
-
-inline v_int8x32 v_reverse(const v_int8x32 &a) {
-  return v_reinterpret_as_s8(v_reverse(v_reinterpret_as_u8(a)));
-}
-
-inline v_uint16x16 v_reverse(const v_uint16x16 &a) {
-  __m256i vec = __lasx_xvshuf4i_h(a.val, 0x1B);
-  vec = __lasx_xvshuf4i_w(vec, 0x4E);
-  return v_uint16x16(__lasx_xvpermi_d(vec, 0x4E));
-}
-
-inline v_int16x16 v_reverse(const v_int16x16 &a) {
-  return v_reinterpret_as_s16(v_reverse(v_reinterpret_as_u16(a)));
-}
-
-inline v_uint32x8 v_reverse(const v_uint32x8 &a) {
-  __m256i vec = __lasx_xvshuf4i_w(a.val, 0x1B);
-  return v_uint32x8(__lasx_xvpermi_d(vec, 0x4E));
-}
-
-inline v_int32x8 v_reverse(const v_int32x8 &a) {
-  return v_reinterpret_as_s32(v_reverse(v_reinterpret_as_u32(a)));
-}
-
-inline v_float32x8 v_reverse(const v_float32x8 &a) {
-  return v_reinterpret_as_f32(v_reverse(v_reinterpret_as_u32(a)));
-}
-
-inline v_uint64x4 v_reverse(const v_uint64x4 &a) {
-  return v_uint64x4(__lasx_xvpermi_d(a.val, 0x1b));
-}
-
-inline v_int64x4 v_reverse(const v_int64x4 &a) {
-  return v_reinterpret_as_s64(v_reverse(v_reinterpret_as_u64(a)));
-}
-
-inline v_float64x4 v_reverse(const v_float64x4 &a) {
-  return v_reinterpret_as_f64(v_reverse(v_reinterpret_as_u64(a)));
-}
-
-////////// Reduce and mask /////////
-
-/** Reduce **/
-// this function is return a[0]+a[1]+...+a[31]
-inline unsigned v_reduce_sum(const v_uint8x32 &a) {
-  __m256i t1 = __lasx_xvhaddw_hu_bu(a.val, a.val);
-  __m256i t2 = __lasx_xvhaddw_wu_hu(t1, t1);
-  __m256i t3 = __lasx_xvhaddw_du_wu(t2, t2);
-  __m256i t4 = __lasx_xvhaddw_qu_du(t3, t3);
-  return (unsigned)(((v8u32)t4)[0] + ((v8u32)t4)[4]);
-}
-
-inline int v_reduce_sum(const v_int8x32 &a) {
-  __m256i t1 = __lasx_xvhaddw_h_b(a.val, a.val);
-  __m256i t2 = __lasx_xvhaddw_w_h(t1, t1);
-  __m256i t3 = __lasx_xvhaddw_d_w(t2, t2);
-  __m256i t4 = __lasx_xvhaddw_q_d(t3, t3);
-  return (int)(((v8i32)t4)[0] + ((v8i32)t4)[4]);
-}
-
-#define OPENCV_HAL_IMPL_LASX_REDUCE_32(_Tpvec, sctype, func, intrin)           \
-  inline sctype v_reduce_##func(const _Tpvec &a) {                             \
-    __m128i val = intrin(_v256_extract_low(a.val), _v256_extract_high(a.val)); \
-    val = intrin(val, __lsx_vbsrl_v(val, 8));                                  \
-    val = intrin(val, __lsx_vbsrl_v(val, 4));                                  \
-    val = intrin(val, __lsx_vbsrl_v(val, 2));                                  \
-    val = intrin(val, __lsx_vbsrl_v(val, 1));                                  \
-    return (sctype)__lsx_vpickve2gr_w(val, 0);                                 \
-  }
-
-OPENCV_HAL_IMPL_LASX_REDUCE_32(v_uint8x32, uchar, min, __lsx_vmin_bu)
-OPENCV_HAL_IMPL_LASX_REDUCE_32(v_int8x32, schar, min, __lsx_vmin_b)
-OPENCV_HAL_IMPL_LASX_REDUCE_32(v_uint8x32, uchar, max, __lsx_vmax_bu)
-OPENCV_HAL_IMPL_LASX_REDUCE_32(v_int8x32, schar, max, __lsx_vmax_b)
-
-#define OPENCV_HAL_IMPL_LASX_REDUCE_16(_Tpvec, sctype, func, intrin)           \
-  inline sctype v_reduce_##func(const _Tpvec &a) {                             \
-    __m128i v0 = _v256_extract_low(a.val);                                     \
-    __m128i v1 = _v256_extract_high(a.val);                                    \
-    v0 = intrin(v0, v1);                                                       \
-    v0 = intrin(v0, __lsx_vbsrl_v(v0, 8));                                     \
-    v0 = intrin(v0, __lsx_vbsrl_v(v0, 4));                                     \
-    v0 = intrin(v0, __lsx_vbsrl_v(v0, 2));                                     \
-    return (sctype)__lsx_vpickve2gr_w(v0, 0);                                  \
-  }
-
-OPENCV_HAL_IMPL_LASX_REDUCE_16(v_uint16x16, ushort, min, __lsx_vmin_hu)
-OPENCV_HAL_IMPL_LASX_REDUCE_16(v_int16x16, short, min, __lsx_vmin_h)
-OPENCV_HAL_IMPL_LASX_REDUCE_16(v_uint16x16, ushort, max, __lsx_vmax_hu)
-OPENCV_HAL_IMPL_LASX_REDUCE_16(v_int16x16, short, max, __lsx_vmax_h)
-
-#define OPENCV_HAL_IMPL_LASX_REDUCE_8(_Tpvec, sctype, func, intrin)            \
-  inline sctype v_reduce_##func(const _Tpvec &a) {                             \
-    __m128i v0 = _v256_extract_low(a.val);                                     \
-    __m128i v1 = _v256_extract_high(a.val);                                    \
-    v0 = intrin(v0, v1);                                                       \
-    v0 = intrin(v0, __lsx_vbsrl_v(v0, 8));                                     \
-    v0 = intrin(v0, __lsx_vbsrl_v(v0, 4));                                     \
-    return (sctype)__lsx_vpickve2gr_w(v0, 0);                                  \
-  }
-
-OPENCV_HAL_IMPL_LASX_REDUCE_8(v_uint32x8, unsigned, min, __lsx_vmin_wu)
-OPENCV_HAL_IMPL_LASX_REDUCE_8(v_int32x8, int, min, __lsx_vmin_w)
-OPENCV_HAL_IMPL_LASX_REDUCE_8(v_uint32x8, unsigned, max, __lsx_vmax_wu)
-OPENCV_HAL_IMPL_LASX_REDUCE_8(v_int32x8, int, max, __lsx_vmax_w)
-
-#define OPENCV_HAL_IMPL_LASX_REDUCE_FLT(func, intrin)                          \
-  inline float v_reduce_##func(const v_float32x8 &a) {                         \
-    __m128 v0 = _v256_extract_low(a.val);                                      \
-    __m128 v1 = _v256_extract_high(a.val);                                     \
-    v0 = intrin(v0, v1);                                                       \
-    v0 = intrin(v0, __m128(__lsx_vpermi_w(*((__m128i *)&v0),                   \
-                                          *((__m128i *)&v0), 0x0e)));          \
-    v0 = intrin(v0, __m128(__lsx_vpermi_w(*((__m128i *)&v0),                   \
-                                          *((__m128i *)&v0), 0x01)));          \
-    float *fvalue = (float *)&v0;                                              \
-    return fvalue[0];                                                          \
-  }
-
-OPENCV_HAL_IMPL_LASX_REDUCE_FLT(min, __lsx_vfmin_s)
-OPENCV_HAL_IMPL_LASX_REDUCE_FLT(max, __lsx_vfmax_s)
-
-inline int v_reduce_sum(const v_int32x8 &a) {
-  __m256i t1 = __lasx_xvhaddw_d_w(a.val, a.val);
-  __m256i t2 = __lasx_xvhaddw_q_d(t1, t1);
-  return (int)(((v8i32)t2)[0] + ((v8i32)t2)[4]);
-}
-
-inline unsigned v_reduce_sum(const v_uint32x8 &a) {
-  return v_reduce_sum(v_reinterpret_as_s32(a));
-}
-
-inline int v_reduce_sum(const v_int16x16 &a) {
-  return v_reduce_sum(v_add(v_expand_low(a), v_expand_high(a)));
-}
-inline unsigned v_reduce_sum(const v_uint16x16 &a) {
-  return v_reduce_sum(v_add(v_expand_low(a), v_expand_high(a)));
-}
-
-inline float v_reduce_sum(const v_float32x8 &a) {
-  float result = 0;
-  float *pa = (float *)&a;
-  for (int i = 0; i < 2; ++i) {
-    result += pa[i * 4] + pa[i * 4 + 1] + pa[i * 4 + 2] + pa[i * 4 + 3];
-  }
-  return result;
-}
-
-inline uint64 v_reduce_sum(const v_uint64x4 &a) {
-  __m256i t0 = __lasx_xvhaddw_qu_du(a.val, a.val);
-  return (uint64)(((v4u64)t0)[0] + ((v4u64)t0)[2]);
-}
-inline int64 v_reduce_sum(const v_int64x4 &a) {
-  __m256i t0 = __lasx_xvhaddw_q_d(a.val, a.val);
-  return (int64)(((v4i64)t0)[0] + ((v4i64)t0)[2]);
-}
-inline double v_reduce_sum(const v_float64x4 &a) {
-  double *pa = (double *)&a;
-  return pa[0] + pa[1] + pa[2] + pa[3];
-}
-
-inline v_float32x8 v_reduce_sum4(const v_float32x8 &a, const v_float32x8 &b,
-                                 const v_float32x8 &c, const v_float32x8 &d) {
-  float *pa = (float *)&a;
-  float *pb = (float *)&b;
-  float *pc = (float *)&c;
-  float *pd = (float *)&d;
-
-  float v0 = pa[0] + pa[1] + pa[2] + pa[3];
-  float v1 = pb[0] + pb[1] + pb[2] + pb[3];
-  float v2 = pc[0] + pc[1] + pc[2] + pc[3];
-  float v3 = pd[0] + pd[1] + pd[2] + pd[3];
-  float v4 = pa[4] + pa[5] + pa[6] + pa[7];
-  float v5 = pb[4] + pb[5] + pb[6] + pb[7];
-  float v6 = pc[4] + pc[5] + pc[6] + pc[7];
-  float v7 = pd[4] + pd[5] + pd[6] + pd[7];
-  return v_float32x8(v0, v1, v2, v3, v4, v5, v6, v7);
-}
-
-inline unsigned v_reduce_sad(const v_uint8x32 &a, const v_uint8x32 &b) {
-  __m256i t0 = __lasx_xvabsd_bu(a.val, b.val);
-  __m256i t1 = __lasx_xvhaddw_hu_bu(t0, t0);
-  __m256i t2 = __lasx_xvhaddw_wu_hu(t1, t1);
-  __m256i t3 = __lasx_xvhaddw_du_wu(t2, t2);
-  __m256i t4 = __lasx_xvhaddw_qu_du(t3, t3);
-  return (unsigned)(((v8u32)t4)[0] + ((v8u32)t4)[4]);
-}
-inline unsigned v_reduce_sad(const v_int8x32 &a, const v_int8x32 &b) {
-  __m256i t0 = __lasx_xvabsd_b(a.val, b.val);
-  __m256i t1 = __lasx_xvhaddw_hu_bu(t0, t0);
-  __m256i t2 = __lasx_xvhaddw_wu_hu(t1, t1);
-  __m256i t3 = __lasx_xvhaddw_du_wu(t2, t2);
-  __m256i t4 = __lasx_xvhaddw_qu_du(t3, t3);
-  return (unsigned)(((v8u32)t4)[0] + ((v8u32)t4)[4]);
-}
-inline unsigned v_reduce_sad(const v_uint16x16 &a, const v_uint16x16 &b) {
-  v_uint32x8 l, h;
-  v_expand(v_add_wrap(v_sub(a, b), v_sub(b, a)), l, h);
-  return v_reduce_sum(v_add(l, h));
-}
-inline unsigned v_reduce_sad(const v_int16x16 &a, const v_int16x16 &b) {
-  v_uint32x8 l, h;
-  v_expand(v_reinterpret_as_u16(v_sub_wrap(v_max(a, b), v_min(a, b))), l, h);
-  return v_reduce_sum(v_add(l, h));
-}
-inline unsigned v_reduce_sad(const v_uint32x8 &a, const v_uint32x8 &b) {
-  return v_reduce_sum(v_sub(v_max(a, b), v_min(a, b)));
-}
-inline unsigned v_reduce_sad(const v_int32x8 &a, const v_int32x8 &b) {
-  v_int32x8 m = v_lt(a, b);
-  return v_reduce_sum(v_reinterpret_as_u32(v_sub(v_xor(v_sub(a, b), m), m)));
-}
-inline float v_reduce_sad(const v_float32x8 &a, const v_float32x8 &b) {
-  v_float32x8 a_b = v_sub(a, b);
-  return v_reduce_sum(
-      v_float32x8(*((__m256i *)&a_b.val) & __lasx_xvreplgr2vr_w(0x7fffffff)));
-}
-
-/** Popcount **/
-inline v_uint8x32 v_popcount(const v_uint8x32 &a) {
-  return v_uint8x32(__lasx_xvpcnt_b(a.val));
-}
-inline v_uint16x16 v_popcount(const v_uint16x16 &a) {
-  return v_uint16x16(__lasx_xvpcnt_h(a.val));
-}
-inline v_uint32x8 v_popcount(const v_uint32x8 &a) {
-  return v_uint32x8(__lasx_xvpcnt_w(a.val));
-}
-inline v_uint64x4 v_popcount(const v_uint64x4 &a) {
-  return v_uint64x4(__lasx_xvpcnt_d(a.val));
-}
-inline v_uint8x32 v_popcount(const v_int8x32 &a) {
-  return v_popcount(v_reinterpret_as_u8(a));
-}
-inline v_uint16x16 v_popcount(const v_int16x16 &a) {
-  return v_popcount(v_reinterpret_as_u16(a));
-}
-inline v_uint32x8 v_popcount(const v_int32x8 &a) {
-  return v_popcount(v_reinterpret_as_u32(a));
-}
-inline v_uint64x4 v_popcount(const v_int64x4 &a) {
-  return v_popcount(v_reinterpret_as_u64(a));
-}
-
-inline int v_signmask(const v_int8x32 &a) {
-  __m256i result = __lasx_xvmskltz_b(a.val);
-  int mask = __lasx_xvpickve2gr_w(result, 0);
-  mask |= (__lasx_xvpickve2gr_w(result, 4) << 16);
-  return mask;
-}
-inline int v_signmask(const v_uint8x32 &a) {
-  return v_signmask(v_reinterpret_as_s8(a));
-}
-
-inline int v_signmask(const v_int16x16 &a) {
-  return v_signmask(v_pack(a, a)) & 0xFFFF;
-}
-inline int v_signmask(const v_uint16x16 &a) {
-  return v_signmask(v_reinterpret_as_s16(a));
-}
-
-inline int v_signmask(const v_int32x8 &a) {
-  __m256i result = __lasx_xvmskltz_w(a.val);
-  int mask = __lasx_xvpickve2gr_w(result, 0);
-  mask |= (__lasx_xvpickve2gr_w(result, 4) << 4);
-  return mask;
-}
-inline int v_signmask(const v_uint32x8 &a) {
-  return v_signmask(*(v_int32x8 *)(&a));
-}
-
-inline int v_signmask(const v_int64x4 &a) {
-  __m256i result = __lasx_xvmskltz_d(a.val);
-  int mask = __lasx_xvpickve2gr_d(result, 0);
-  mask |= (__lasx_xvpickve2gr_w(result, 4) << 2);
-  return mask;
-}
-inline int v_signmask(const v_uint64x4 &a) {
-  return v_signmask(v_reinterpret_as_s64(a));
-}
-
-inline int v_signmask(const v_float32x8 &a) {
-  return v_signmask(*(v_int32x8 *)(&a));
-}
-
-inline int v_signmask(const v_float64x4 &a) {
-  return v_signmask(*(v_int64x4 *)(&a));
-}
-
-inline int v_scan_forward(const v_int8x32 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a)));
-}
-inline int v_scan_forward(const v_uint8x32 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a)));
-}
-inline int v_scan_forward(const v_int16x16 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 2;
-}
-inline int v_scan_forward(const v_uint16x16 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 2;
-}
-inline int v_scan_forward(const v_int32x8 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 4;
-}
-inline int v_scan_forward(const v_uint32x8 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 4;
-}
-inline int v_scan_forward(const v_float32x8 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 4;
-}
-inline int v_scan_forward(const v_int64x4 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 8;
-}
-inline int v_scan_forward(const v_uint64x4 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 8;
-}
-inline int v_scan_forward(const v_float64x4 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 8;
-}
-
-/** Checks **/
-#define OPENCV_HAL_IMPL_LASX_CHECK(_Tpvec, allmask)                            \
-  inline bool v_check_all(const _Tpvec &a) {                                   \
-    return v_signmask(a) == allmask;                                           \
-  }                                                                            \
-  inline bool v_check_any(const _Tpvec &a) { return v_signmask(a) != 0; }
-OPENCV_HAL_IMPL_LASX_CHECK(v_uint8x32, -1)
-OPENCV_HAL_IMPL_LASX_CHECK(v_int8x32, -1)
-OPENCV_HAL_IMPL_LASX_CHECK(v_uint32x8, 255)
-OPENCV_HAL_IMPL_LASX_CHECK(v_int32x8, 255)
-OPENCV_HAL_IMPL_LASX_CHECK(v_uint64x4, 15)
-OPENCV_HAL_IMPL_LASX_CHECK(v_int64x4, 15)
-OPENCV_HAL_IMPL_LASX_CHECK(v_float32x8, 255)
-OPENCV_HAL_IMPL_LASX_CHECK(v_float64x4, 15)
-
-#define OPENCV_HAL_IMPL_LASX_CHECK_SHORT(_Tpvec)                               \
-  inline bool v_check_all(const _Tpvec &a) {                                   \
-    return (v_signmask(v_reinterpret_as_s8(a)) & 0xaaaaaaaa) == 0xaaaaaaaa;    \
-  }                                                                            \
-  inline bool v_check_any(const _Tpvec &a) {                                   \
-    return (v_signmask(v_reinterpret_as_s8(a)) & 0xaaaaaaaa) != 0;             \
-  }
-OPENCV_HAL_IMPL_LASX_CHECK_SHORT(v_uint16x16)
-OPENCV_HAL_IMPL_LASX_CHECK_SHORT(v_int16x16)
-
-////////// Other math /////////
-
-/** Some frequent operations **/
-#define OPENCV_HAL_IMPL_LASX_MULADD(_Tpvec, suffix)                            \
-  inline _Tpvec v_fma(const _Tpvec &a, const _Tpvec &b, const _Tpvec &c) {     \
-    return _Tpvec(__lasx_xvfmadd_##suffix(a.val, b.val, c.val));               \
-  }                                                                            \
-  inline _Tpvec v_muladd(const _Tpvec &a, const _Tpvec &b, const _Tpvec &c) {  \
-    return _Tpvec(__lasx_xvfmadd_##suffix(a.val, b.val, c.val));               \
-  }                                                                            \
-  inline _Tpvec v_sqrt(const _Tpvec &x) {                                      \
-    return _Tpvec(__lasx_xvfsqrt_##suffix(x.val));                             \
-  }                                                                            \
-  inline _Tpvec v_sqr_magnitude(const _Tpvec &a, const _Tpvec &b) {            \
-    return v_fma(a, a, v_mul(b, b));                                           \
-  }                                                                            \
-  inline _Tpvec v_magnitude(const _Tpvec &a, const _Tpvec &b) {                \
-    return v_sqrt(v_fma(a, a, v_mul(b, b)));                                   \
-  }
-
-OPENCV_HAL_IMPL_LASX_MULADD(v_float32x8, s)
-OPENCV_HAL_IMPL_LASX_MULADD(v_float64x4, d)
-
-inline v_int32x8 v_fma(const v_int32x8 &a, const v_int32x8 &b,
-                       const v_int32x8 &c) {
-  return v_int32x8(__lasx_xvmadd_w(c.val, a.val, b.val));
-}
-
-inline v_int32x8 v_muladd(const v_int32x8 &a, const v_int32x8 &b,
-                          const v_int32x8 &c) {
-  return v_fma(a, b, c);
-}
-
-inline v_float32x8 v_invsqrt(const v_float32x8 &x) {
-  return v_float32x8(__lasx_xvfrsqrt_s(x.val));
-}
-
-inline v_float64x4 v_invsqrt(const v_float64x4 &x) {
-  return v_float64x4(__lasx_xvfrsqrt_d(x.val));
-}
-
-/** Absolute values **/
-#define OPENCV_HAL_IMPL_LASX_ABS(_Tpvec, suffix)                               \
-  inline v_u##_Tpvec v_abs(const v_##_Tpvec &x) {                              \
-    return v_u##_Tpvec(                                                        \
-        __lasx_xvabsd_##suffix(x.val, __lasx_xvreplgr2vr_w(0)));               \
-  }
-
-OPENCV_HAL_IMPL_LASX_ABS(int8x32, b)
-OPENCV_HAL_IMPL_LASX_ABS(int16x16, h)
-OPENCV_HAL_IMPL_LASX_ABS(int32x8, w)
-
-inline v_float32x8 v_abs(const v_float32x8 &x) {
-  return v_float32x8(*((__m256i *)&x) & __lasx_xvreplgr2vr_w(0x7fffffff));
-}
-inline v_float64x4 v_abs(const v_float64x4 &x) {
-  return v_float64x4(*((__m256i *)&x) &
-                     __lasx_xvreplgr2vr_d(0x7fffffffffffffff));
-}
-
-/** Absolute difference **/
-inline v_uint8x32 v_absdiff(const v_uint8x32 &a, const v_uint8x32 &b) {
-  return (v_uint8x32)__lasx_xvabsd_bu(a.val, b.val);
-}
-inline v_uint16x16 v_absdiff(const v_uint16x16 &a, const v_uint16x16 &b) {
-  return (v_uint16x16)__lasx_xvabsd_hu(a.val, b.val);
-}
-inline v_uint32x8 v_absdiff(const v_uint32x8 &a, const v_uint32x8 &b) {
-  return (v_uint32x8)__lasx_xvabsd_wu(a.val, b.val);
-}
-
-inline v_uint8x32 v_absdiff(const v_int8x32 &a, const v_int8x32 &b) {
-  return (v_uint8x32)__lasx_xvabsd_b(a.val, b.val);
-}
-inline v_uint16x16 v_absdiff(const v_int16x16 &a, const v_int16x16 &b) {
-  return (v_uint16x16)__lasx_xvabsd_h(a.val, b.val);
-}
-inline v_uint32x8 v_absdiff(const v_int32x8 &a, const v_int32x8 &b) {
-  return (v_uint32x8)__lasx_xvabsd_w(a.val, b.val);
-}
-
-inline v_float32x8 v_absdiff(const v_float32x8 &a, const v_float32x8 &b) {
-  return v_abs(v_sub(a, b));
-}
-
-inline v_float64x4 v_absdiff(const v_float64x4 &a, const v_float64x4 &b) {
-  return v_abs(v_sub(a, b));
-}
-
-/** Saturating absolute difference **/
-inline v_int8x32 v_absdiffs(const v_int8x32 &a, const v_int8x32 &b) {
-  v_int8x32 d = v_sub(a, b);
-  v_int8x32 m = v_lt(a, b);
-  return v_sub(v_xor(d, m), m);
-}
-inline v_int16x16 v_absdiffs(const v_int16x16 &a, const v_int16x16 &b) {
-  return v_sub(v_max(a, b), v_min(a, b));
-}
-
-////////// Conversions /////////
-
-/** Rounding **/
-inline v_int32x8 v_round(const v_float32x8 &a) {
-  return v_int32x8(__lasx_xvftint_w_s(a.val));
-}
-
-inline v_int32x8 v_round(const v_float64x4 &a) {
-  __m256i t = __lasx_xvftint_w_d(a.val, a.val);
-  return v_int32x8(__lasx_xvpermi_d(t, 0x88));
-}
-
-inline v_int32x8 v_round(const v_float64x4 &a, const v_float64x4 &b) {
-  __m256i abi = __lasx_xvftint_w_d(b.val, a.val);
-  return v_int32x8(__lasx_xvpermi_d(abi, 0b11011000)); // 3120
-}
-
-inline v_int32x8 v_trunc(const v_float32x8 &a) {
-  return v_int32x8(__lasx_xvftintrz_w_s(a.val));
-}
-
-inline v_int32x8 v_trunc(const v_float64x4 &a) {
-  __m256i t = __lasx_xvftintrz_w_d(a.val, a.val);
-  return v_int32x8(__lasx_xvpermi_d(t, 0x88));
-}
-
-inline v_int32x8 v_floor(const v_float32x8 &a) {
-  return v_int32x8(__lasx_xvftintrz_w_s(__m256(__lasx_xvfrintrm_s(a.val))));
-}
-
-inline v_int32x8 v_floor(const v_float64x4 &a) {
-  return v_trunc(v_float64x4(__lasx_xvfrintrm_d(a.val)));
-}
-
-inline v_int32x8 v_ceil(const v_float32x8 &a) {
-  return v_int32x8(__lasx_xvftintrz_w_s(__m256(__lasx_xvfrintrp_s(a.val))));
-}
-
-inline v_int32x8 v_ceil(const v_float64x4 &a) {
-  return v_trunc(v_float64x4(__lasx_xvfrintrp_d(a.val)));
-}
-
-/** To float **/
-inline v_float32x8 v_cvt_f32(const v_int32x8 &a) {
-  return v_float32x8(__lasx_xvffint_s_w(a.val));
-}
-
-inline v_float32x8 v_cvt_f32(const v_float64x4 &a) {
-  return v_float32x8(__lasx_xvpermi_d(__lasx_xvfcvt_s_d(a.val, a.val), 0x88));
-}
-
-inline v_float32x8 v_cvt_f32(const v_float64x4 &a, const v_float64x4 &b) {
-  __m256 abf = __lasx_xvfcvt_s_d(
-      a.val,
-      b.val); // warnning: order of a,b is diff from instruction xvfcvt.s.d
-  return v_float32x8(__lasx_xvpermi_d(abf, 0x8D));
-}
-
-inline v_float64x4 v_cvt_f64(const v_int32x8 &a) {
-  __m256i alow = __lasx_xvpermi_d(a.val, 0x10);
-  return v_float64x4(__lasx_xvffintl_d_w(alow));
-}
-
-inline v_float64x4 v_cvt_f64_high(const v_int32x8 &a) {
-  __m256i ahigh = __lasx_xvpermi_d(a.val, 0x32);
-  return v_float64x4(__lasx_xvffintl_d_w(ahigh));
-}
-
-inline v_float64x4 v_cvt_f64(const v_float32x8 &a) {
-  __m256i alow = __lasx_xvpermi_d(a.val, 0x10);
-  return v_float64x4(__lasx_xvfcvtl_d_s((__m256)alow));
-}
-
-inline v_float64x4 v_cvt_f64_high(const v_float32x8 &a) {
-  __m256i ahigh = __lasx_xvpermi_d(a.val, 0x32);
-  return v_float64x4(__lasx_xvfcvtl_d_s((__m256)ahigh));
-}
-
-inline v_float64x4 v_cvt_f64(const v_int64x4 &v) {
-  return v_float64x4(__lasx_xvffint_d_l(v.val));
-}
-
-////////////// Lookup table access ////////////////////
-
-inline v_int8x32 v256_lut(const schar *tab, const int *idx) {
-  return v_int8x32(_v256_setr_b(
-      tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]], tab[idx[4]],
-      tab[idx[5]], tab[idx[6]], tab[idx[7]], tab[idx[8]], tab[idx[9]],
-      tab[idx[10]], tab[idx[11]], tab[idx[12]], tab[idx[13]], tab[idx[14]],
-      tab[idx[15]], tab[idx[16]], tab[idx[17]], tab[idx[18]], tab[idx[19]],
-      tab[idx[20]], tab[idx[21]], tab[idx[22]], tab[idx[23]], tab[idx[24]],
-      tab[idx[25]], tab[idx[26]], tab[idx[27]], tab[idx[28]], tab[idx[29]],
-      tab[idx[30]], tab[idx[31]]));
-}
-inline v_int8x32 v256_lut_pairs(const schar *tab, const int *idx) {
-  return v_int8x32(_v256_setr_h(
-      *(const short *)(tab + idx[0]), *(const short *)(tab + idx[1]),
-      *(const short *)(tab + idx[2]), *(const short *)(tab + idx[3]),
-      *(const short *)(tab + idx[4]), *(const short *)(tab + idx[5]),
-      *(const short *)(tab + idx[6]), *(const short *)(tab + idx[7]),
-      *(const short *)(tab + idx[8]), *(const short *)(tab + idx[9]),
-      *(const short *)(tab + idx[10]), *(const short *)(tab + idx[11]),
-      *(const short *)(tab + idx[12]), *(const short *)(tab + idx[13]),
-      *(const short *)(tab + idx[14]), *(const short *)(tab + idx[15])));
-}
-inline v_int8x32 v256_lut_quads(const schar *tab, const int *idx) {
-  return v_int8x32(
-      _v256_setr_w(*(const int *)(tab + idx[0]), *(const int *)(tab + idx[1]),
-                   *(const int *)(tab + idx[2]), *(const int *)(tab + idx[3]),
-                   *(const int *)(tab + idx[4]), *(const int *)(tab + idx[5]),
-                   *(const int *)(tab + idx[6]), *(const int *)(tab + idx[7])));
-}
-inline v_uint8x32 v256_lut(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v256_lut((const schar *)tab, idx));
-}
-inline v_uint8x32 v256_lut_pairs(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v256_lut_pairs((const schar *)tab, idx));
-}
-inline v_uint8x32 v256_lut_quads(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v256_lut_quads((const schar *)tab, idx));
-}
-
-inline v_int16x16 v256_lut(const short *tab, const int *idx) {
-  return v_int16x16(
-      _v256_setr_h(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]],
-                   tab[idx[4]], tab[idx[5]], tab[idx[6]], tab[idx[7]],
-                   tab[idx[8]], tab[idx[9]], tab[idx[10]], tab[idx[11]],
-                   tab[idx[12]], tab[idx[13]], tab[idx[14]], tab[idx[15]]));
-}
-inline v_int16x16 v256_lut_pairs(const short *tab, const int *idx) {
-  return v_int16x16(
-      _v256_setr_w(*(const int *)(tab + idx[0]), *(const int *)(tab + idx[1]),
-                   *(const int *)(tab + idx[2]), *(const int *)(tab + idx[3]),
-                   *(const int *)(tab + idx[4]), *(const int *)(tab + idx[5]),
-                   *(const int *)(tab + idx[6]), *(const int *)(tab + idx[7])));
-}
-inline v_int16x16 v256_lut_quads(const short *tab, const int *idx) {
-  return v_int16x16(_v256_setr_d(*(const long long int *)(tab + idx[0]),
-                                 *(const long long int *)(tab + idx[1]),
-                                 *(const long long int *)(tab + idx[2]),
-                                 *(const long long int *)(tab + idx[3])));
-}
-inline v_uint16x16 v256_lut(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v256_lut((const short *)tab, idx));
-}
-inline v_uint16x16 v256_lut_pairs(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v256_lut_pairs((const short *)tab, idx));
-}
-inline v_uint16x16 v256_lut_quads(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v256_lut_quads((const short *)tab, idx));
-}
-
-inline v_int32x8 v256_lut(const int *tab, const int *idx) {
-  return v_int32x8(
-      _v256_setr_w(*(const int *)(tab + idx[0]), *(const int *)(tab + idx[1]),
-                   *(const int *)(tab + idx[2]), *(const int *)(tab + idx[3]),
-                   *(const int *)(tab + idx[4]), *(const int *)(tab + idx[5]),
-                   *(const int *)(tab + idx[6]), *(const int *)(tab + idx[7])));
-}
-inline v_int32x8 v256_lut_pairs(const int *tab, const int *idx) {
-  return v_int32x8(_v256_setr_d(*(const long long int *)(tab + idx[0]),
-                                *(const long long int *)(tab + idx[1]),
-                                *(const long long int *)(tab + idx[2]),
-                                *(const long long int *)(tab + idx[3])));
-}
-inline v_int32x8 v256_lut_quads(const int *tab, const int *idx) {
-  return v_int32x8(
-      _v256_combine(__lsx_vld(tab + idx[0], 0), __lsx_vld(tab + idx[1], 0)));
-}
-inline v_uint32x8 v256_lut(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v256_lut((const int *)tab, idx));
-}
-inline v_uint32x8 v256_lut_pairs(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v256_lut_pairs((const int *)tab, idx));
-}
-inline v_uint32x8 v256_lut_quads(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v256_lut_quads((const int *)tab, idx));
-}
-
-inline v_int64x4 v256_lut(const int64 *tab, const int *idx) {
-  return v_int64x4(_v256_setr_d(*(const long long int *)(tab + idx[0]),
-                                *(const long long int *)(tab + idx[1]),
-                                *(const long long int *)(tab + idx[2]),
-                                *(const long long int *)(tab + idx[3])));
-}
-inline v_int64x4 v256_lut_pairs(const int64 *tab, const int *idx) {
-  return v_int64x4(
-      _v256_combine(__lsx_vld(tab + idx[0], 0), __lsx_vld(tab + idx[1], 0)));
-}
-inline v_uint64x4 v256_lut(const uint64 *tab, const int *idx) {
-  return v_reinterpret_as_u64(v256_lut((const int64 *)tab, idx));
-}
-inline v_uint64x4 v256_lut_pairs(const uint64 *tab, const int *idx) {
-  return v_reinterpret_as_u64(v256_lut_pairs((const int64 *)tab, idx));
-}
-
-inline v_float32x8 v256_lut(const float *tab, const int *idx) {
-  return v_float32x8(_v256_setr_ps(tab[idx[0]], tab[idx[1]], tab[idx[2]],
-                                   tab[idx[3]], tab[idx[4]], tab[idx[5]],
-                                   tab[idx[6]], tab[idx[7]]));
-}
-inline v_float32x8 v256_lut_pairs(const float *tab, const int *idx) {
-  return v_reinterpret_as_f32(v256_lut_pairs((const int *)tab, idx));
-}
-inline v_float32x8 v256_lut_quads(const float *tab, const int *idx) {
-  return v_reinterpret_as_f32(v256_lut_quads((const int *)tab, idx));
-}
-
-inline v_float64x4 v256_lut(const double *tab, const int *idx) {
-  return v_float64x4(
-      _v256_setr_pd(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]));
-}
-inline v_float64x4 v256_lut_pairs(const double *tab, const int *idx) {
-  return v_float64x4(
-      _v256_combine(__lsx_vld(tab + idx[0], 0), __lsx_vld(tab + idx[1], 0)));
-}
-
-inline v_int32x8 v_lut(const int *tab, const v_int32x8 &idxvec) {
-  int *idx = (int *)&idxvec.val;
-  return v256_lut(tab, idx);
-}
-
-inline v_uint32x8 v_lut(const unsigned *tab, const v_int32x8 &idxvec) {
-  return v_reinterpret_as_u32(v_lut((const int *)tab, idxvec));
-}
-
-inline v_float32x8 v_lut(const float *tab, const v_int32x8 &idxvec) {
-  const int *idx = (const int *)&idxvec.val;
-  return v256_lut(tab, idx);
-}
-
-inline v_float64x4 v_lut(const double *tab, const v_int32x8 &idxvec) {
-  const int *idx = (const int *)&idxvec.val;
-  return v256_lut(tab, idx);
-}
-
-inline void v_lut_deinterleave(const float *tab, const v_int32x8 &idxvec,
-                               v_float32x8 &x, v_float32x8 &y) {
-  const int *idx = (const int *)&idxvec.val;
-  __m128i xy01, xy45, xy23, xy67;
-  xy01 = __lsx_vld(tab + idx[0], 0);
-  xy01 = __lsx_vextrins_d(xy01, __lsx_vld(tab + idx[1], 0), 0x10);
-  xy45 = __lsx_vld(tab + idx[4], 0);
-  xy45 = __lsx_vextrins_d(xy45, __lsx_vld(tab + idx[5], 0), 0x10);
-  __m256i xy0145 = _v256_combine(xy01, xy45);
-  xy23 = __lsx_vld(tab + idx[2], 0);
-  xy23 = __lsx_vextrins_d(xy23, __lsx_vld(tab + idx[3], 0), 0x10);
-  xy67 = __lsx_vld(tab + idx[6], 0);
-  xy67 = __lsx_vextrins_d(xy67, __lsx_vld(tab + idx[7], 0), 0x10);
-  __m256i xy2367 = _v256_combine(xy23, xy67);
-
-  __m256i xxyy0145 = __lasx_xvilvl_w(xy2367, xy0145);
-  __m256i xxyy2367 = __lasx_xvilvh_w(xy2367, xy0145);
-
-  x = v_float32x8(__lasx_xvilvl_w(xxyy2367, xxyy0145));
-  y = v_float32x8(__lasx_xvilvh_w(xxyy2367, xxyy0145));
-}
-
-inline void v_lut_deinterleave(const double *tab, const v_int32x8 &idxvec,
-                               v_float64x4 &x, v_float64x4 &y) {
-  // int CV_DECL_ALIGNED(32) idx[4];
-  const int *idx = (const int *)&idxvec.val;
-  __m128i xy0 = __lsx_vld(tab + idx[0], 0);
-  __m128i xy2 = __lsx_vld(tab + idx[2], 0);
-  __m128i xy1 = __lsx_vld(tab + idx[1], 0);
-  __m128i xy3 = __lsx_vld(tab + idx[3], 0);
-  __m256i xy02 = _v256_combine(xy0, xy2);
-  __m256i xy13 = _v256_combine(xy1, xy3);
-
-  x = v_float64x4(__lasx_xvilvl_d(xy13, xy02));
-  y = v_float64x4(__lasx_xvilvh_d(xy13, xy02));
-}
-
-inline v_int8x32 v_interleave_pairs(const v_int8x32 &vec) {
-  return v_int8x32(
-      __lasx_xvshuf_b(vec.val, vec.val,
-                      _v256_set_d(0x0f0d0e0c0b090a08, 0x0705060403010200,
-                                  0x0f0d0e0c0b090a08, 0x0705060403010200)));
-}
-inline v_uint8x32 v_interleave_pairs(const v_uint8x32 &vec) {
-  return v_reinterpret_as_u8(v_interleave_pairs(v_reinterpret_as_s8(vec)));
-}
-inline v_int8x32 v_interleave_quads(const v_int8x32 &vec) {
-  return v_int8x32(
-      __lasx_xvshuf_b(vec.val, vec.val,
-                      _v256_set_d(0x0f0b0e0a0d090c08, 0x0703060205010400,
-                                  0x0f0b0e0a0d090c08, 0x0703060205010400)));
-}
-inline v_uint8x32 v_interleave_quads(const v_uint8x32 &vec) {
-  return v_reinterpret_as_u8(v_interleave_quads(v_reinterpret_as_s8(vec)));
-}
-
-inline v_int16x16 v_interleave_pairs(const v_int16x16 &vec) {
-  return v_int16x16(
-      __lasx_xvshuf_b(vec.val, vec.val,
-                      _v256_set_d(0x0f0e0b0a0d0c0908, 0x0706030205040100,
-                                  0x0f0e0b0a0d0c0908, 0x0706030205040100)));
-}
-inline v_uint16x16 v_interleave_pairs(const v_uint16x16 &vec) {
-  return v_reinterpret_as_u16(v_interleave_pairs(v_reinterpret_as_s16(vec)));
-}
-inline v_int16x16 v_interleave_quads(const v_int16x16 &vec) {
-  return v_int16x16(
-      __lasx_xvshuf_b(vec.val, vec.val,
-                      _v256_set_d(0x0f0e07060d0c0504, 0x0b0a030209080100,
-                                  0x0f0e07060d0c0504, 0x0b0a030209080100)));
-}
-inline v_uint16x16 v_interleave_quads(const v_uint16x16 &vec) {
-  return v_reinterpret_as_u16(v_interleave_quads(v_reinterpret_as_s16(vec)));
-}
-
-inline v_int32x8 v_interleave_pairs(const v_int32x8 &vec) {
-  return v_int32x8(__lasx_xvshuf4i_w(vec.val, 0xd8));
-}
-inline v_uint32x8 v_interleave_pairs(const v_uint32x8 &vec) {
-  return v_reinterpret_as_u32(v_interleave_pairs(v_reinterpret_as_s32(vec)));
-}
-inline v_float32x8 v_interleave_pairs(const v_float32x8 &vec) {
-  return v_reinterpret_as_f32(v_interleave_pairs(v_reinterpret_as_s32(vec)));
-}
-
-inline v_int8x32 v_pack_triplets(const v_int8x32 &vec) {
-  __m256i vzero = __lasx_xvreplgr2vr_w(0);
-  __m256i t1 =
-      __lasx_xvshuf_b(vzero, vec.val,
-                      _v256_set_d(0x1211100f0e0d0c0a, 0x0908060504020100,
-                                  0x1211100f0e0d0c0a, 0x0908060504020100));
-  return v_int8x32(
-      __lasx_xvperm_w(t1, _v256_set_d(0x0000000700000007, 0x0000000600000005,
-                                      0x0000000400000002, 0x0000000100000000)));
-}
-inline v_uint8x32 v_pack_triplets(const v_uint8x32 &vec) {
-  return v_reinterpret_as_u8(v_pack_triplets(v_reinterpret_as_s8(vec)));
-}
-
-inline v_int16x16 v_pack_triplets(const v_int16x16 &vec) {
-  __m256i vzero = __lasx_xvreplgr2vr_w(0);
-  __m256i t1 =
-      __lasx_xvshuf_b(vzero, vec.val,
-                      _v256_set_d(0x11100f0e0d0c0b0a, 0x0908050403020100,
-                                  0x11100f0e0d0c0b0a, 0x0908050403020100));
-  return v_int16x16(
-      __lasx_xvperm_w(t1, _v256_set_d(0x0000000700000007, 0x0000000600000005,
-                                      0x0000000400000002, 0x0000000100000000)));
-}
-inline v_uint16x16 v_pack_triplets(const v_uint16x16 &vec) {
-  return v_reinterpret_as_u16(v_pack_triplets(v_reinterpret_as_s16(vec)));
-}
-
-inline v_int32x8 v_pack_triplets(const v_int32x8 &vec) {
-  return v_int32x8(__lasx_xvperm_w(
-      vec.val, _v256_set_d(0x0000000700000007, 0x0000000600000005,
-                           0x0000000400000002, 0x0000000100000000)));
-}
-inline v_uint32x8 v_pack_triplets(const v_uint32x8 &vec) {
-  return v_reinterpret_as_u32(v_pack_triplets(v_reinterpret_as_s32(vec)));
-}
-inline v_float32x8 v_pack_triplets(const v_float32x8 &vec) {
-  return v_float32x8(
-      __lasx_xvperm_w(*(__m256i *)(&vec.val),
-                      _v256_set_d(0x0000000700000007, 0x0000000600000005,
-                                  0x0000000400000002, 0x0000000100000000)));
-}
-
-////////// Matrix operations /////////
-
-//////// Dot Product ////////
-
-// 16 >> 32
-inline v_int32x8 v_dotprod(const v_int16x16 &a, const v_int16x16 &b) {
-  return v_int32x8(__lasx_xvadd_w(__lasx_xvmulwev_w_h(a.val, b.val),
-                                  __lasx_xvmulwod_w_h(a.val, b.val)));
-}
-
-inline v_int32x8 v_dotprod(const v_int16x16 &a, const v_int16x16 &b,
-                           const v_int32x8 &c) {
-  return v_add(v_dotprod(a, b), c);
-}
-
-// 32 >> 64
-inline v_int64x4 v_dotprod(const v_int32x8 &a, const v_int32x8 &b) {
-  __m256i even = __lasx_xvmulwev_d_w(a.val, b.val);
-  return v_int64x4(__lasx_xvmaddwod_d_w(even, a.val, b.val));
-}
-inline v_int64x4 v_dotprod(const v_int32x8 &a, const v_int32x8 &b,
-                           const v_int64x4 &c) {
-  __m256i even = __lasx_xvmaddwev_d_w(c.val, a.val, b.val);
-  return v_int64x4(__lasx_xvmaddwod_d_w(even, a.val, b.val));
-}
-
-// 8 >> 32
-inline v_uint32x8 v_dotprod_expand(const v_uint8x32 &a, const v_uint8x32 &b) {
-  __m256i even = __lasx_xvmulwev_h_bu(a.val, b.val);
-  __m256i odd = __lasx_xvmulwod_h_bu(a.val, b.val);
-  __m256i prod0 = __lasx_xvhaddw_wu_hu(even, even);
-  __m256i prod1 = __lasx_xvhaddw_wu_hu(odd, odd);
-  return v_uint32x8(__lasx_xvadd_w(prod0, prod1));
-}
-inline v_uint32x8 v_dotprod_expand(const v_uint8x32 &a, const v_uint8x32 &b,
-                                   const v_uint32x8 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-inline v_int32x8 v_dotprod_expand(const v_int8x32 &a, const v_int8x32 &b) {
-  __m256i even = __lasx_xvmulwev_h_b(a.val, b.val);
-  __m256i odd = __lasx_xvmulwod_h_b(a.val, b.val);
-  __m256i prod0 = __lasx_xvhaddw_w_h(even, even);
-  __m256i prod1 = __lasx_xvhaddw_w_h(odd, odd);
-  return v_int32x8(__lasx_xvadd_w(prod0, prod1));
-}
-inline v_int32x8 v_dotprod_expand(const v_int8x32 &a, const v_int8x32 &b,
-                                  const v_int32x8 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-// 16 >> 64
-inline v_uint64x4 v_dotprod_expand(const v_uint16x16 &a, const v_uint16x16 &b) {
-  __m256i even = __lasx_xvmulwev_w_hu(a.val, b.val);
-  __m256i odd = __lasx_xvmulwod_w_hu(a.val, b.val);
-  __m256i prod0 = __lasx_xvhaddw_du_wu(even, even);
-  __m256i prod1 = __lasx_xvhaddw_du_wu(odd, odd);
-  return v_uint64x4(__lasx_xvadd_d(prod0, prod1));
-}
-inline v_uint64x4 v_dotprod_expand(const v_uint16x16 &a, const v_uint16x16 &b,
-                                   const v_uint64x4 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-inline v_int64x4 v_dotprod_expand(const v_int16x16 &a, const v_int16x16 &b) {
-  __m256i even = __lasx_xvmulwev_w_h(a.val, b.val);
-  __m256i odd = __lasx_xvmulwod_w_h(a.val, b.val);
-  __m256i prod0 = __lasx_xvhaddw_d_w(even, even);
-  __m256i prod1 = __lasx_xvhaddw_d_w(odd, odd);
-  return v_int64x4(__lasx_xvadd_d(prod0, prod1));
-}
-
-inline v_int64x4 v_dotprod_expand(const v_int16x16 &a, const v_int16x16 &b,
-                                  const v_int64x4 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-// 32 >> 64f
-inline v_float64x4 v_dotprod_expand(const v_int32x8 &a, const v_int32x8 &b) {
-  return v_cvt_f64(v_dotprod(a, b));
-}
-inline v_float64x4 v_dotprod_expand(const v_int32x8 &a, const v_int32x8 &b,
-                                    const v_float64x4 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-//////// Fast Dot Product ////////
-
-// 16 >> 32
-inline v_int32x8 v_dotprod_fast(const v_int16x16 &a, const v_int16x16 &b) {
-  return v_dotprod(a, b);
-}
-inline v_int32x8 v_dotprod_fast(const v_int16x16 &a, const v_int16x16 &b,
-                                const v_int32x8 &c) {
-  return v_dotprod(a, b, c);
-}
-
-// 32 >> 64
-inline v_int64x4 v_dotprod_fast(const v_int32x8 &a, const v_int32x8 &b) {
-  return v_dotprod(a, b);
-}
-inline v_int64x4 v_dotprod_fast(const v_int32x8 &a, const v_int32x8 &b,
-                                const v_int64x4 &c) {
-  return v_dotprod(a, b, c);
-}
-
-// 8 >> 32
-inline v_uint32x8 v_dotprod_expand_fast(const v_uint8x32 &a,
-                                        const v_uint8x32 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_uint32x8 v_dotprod_expand_fast(const v_uint8x32 &a,
-                                        const v_uint8x32 &b,
-                                        const v_uint32x8 &c) {
-  return v_dotprod_expand(a, b, c);
-}
-
-inline v_int32x8 v_dotprod_expand_fast(const v_int8x32 &a, const v_int8x32 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_int32x8 v_dotprod_expand_fast(const v_int8x32 &a, const v_int8x32 &b,
-                                       const v_int32x8 &c) {
-  return v_dotprod_expand(a, b, c);
-}
-
-// 16 >> 64
-inline v_uint64x4 v_dotprod_expand_fast(const v_uint16x16 &a,
-                                        const v_uint16x16 &b) {
-  __m256i even = __lasx_xvmulwev_w_hu(a.val, b.val);
-  __m256i odd = __lasx_xvmulwod_w_hu(a.val, b.val);
-  __m256i prod0 = __lasx_xvhaddw_du_wu(even, even);
-  __m256i prod1 = __lasx_xvhaddw_du_wu(odd, odd);
-  return v_uint64x4(__lasx_xvadd_d(__lasx_xvilvl_d(prod1, prod0),
-                                   __lasx_xvilvh_d(prod1, prod0)));
-}
-inline v_uint64x4 v_dotprod_expand_fast(const v_uint16x16 &a,
-                                        const v_uint16x16 &b,
-                                        const v_uint64x4 &c) {
-  return v_add(v_dotprod_expand_fast(a, b), c);
-}
-
-inline v_int64x4 v_dotprod_expand_fast(const v_int16x16 &a,
-                                       const v_int16x16 &b) {
-  __m256i prod = __lasx_xvadd_w(__lasx_xvmulwev_w_h(a.val, b.val),
-                                __lasx_xvmulwod_w_h(a.val, b.val));
-  __m256i sign = __lasx_xvsrai_w(prod, 31);
-  __m256i lo = __lasx_xvilvl_w(sign, prod);
-  __m256i hi = __lasx_xvilvh_w(sign, prod);
-  return v_int64x4(__lasx_xvadd_d(lo, hi));
-}
-inline v_int64x4 v_dotprod_expand_fast(const v_int16x16 &a, const v_int16x16 &b,
-                                       const v_int64x4 &c) {
-  return v_add(v_dotprod_expand_fast(a, b), c);
-}
-
-// 32 >> 64f
-inline v_float64x4 v_dotprod_expand_fast(const v_int32x8 &a,
-                                         const v_int32x8 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_float64x4 v_dotprod_expand_fast(const v_int32x8 &a, const v_int32x8 &b,
-                                         const v_float64x4 &c) {
-  return v_dotprod_expand(a, b, c);
-}
-
-#define OPENCV_HAL_LASX_SPLAT2_PS(a, im)                                       \
-  v_float32x8(__lasx_xvpermi_w(a.val, a.val, im))
-
-inline v_float32x8 v_matmul(const v_float32x8 &v, const v_float32x8 &m0,
-                            const v_float32x8 &m1, const v_float32x8 &m2,
-                            const v_float32x8 &m3) {
-  v_float32x8 v04 = OPENCV_HAL_LASX_SPLAT2_PS(v, 0);
-  v_float32x8 v15 = OPENCV_HAL_LASX_SPLAT2_PS(v, 0x55);
-  v_float32x8 v26 = OPENCV_HAL_LASX_SPLAT2_PS(v, 0xAA);
-  v_float32x8 v37 = OPENCV_HAL_LASX_SPLAT2_PS(v, 0xFF);
-  return v_fma(v04, m0, v_fma(v15, m1, v_fma(v26, m2, v_mul(v37, m3))));
-}
-
-inline v_float32x8 v_matmuladd(const v_float32x8 &v, const v_float32x8 &m0,
-                               const v_float32x8 &m1, const v_float32x8 &m2,
-                               const v_float32x8 &a) {
-  v_float32x8 v04 = OPENCV_HAL_LASX_SPLAT2_PS(v, 0);
-  v_float32x8 v15 = OPENCV_HAL_LASX_SPLAT2_PS(v, 0x55);
-  v_float32x8 v26 = OPENCV_HAL_LASX_SPLAT2_PS(v, 0xAA);
-  return v_fma(v04, m0, v_fma(v15, m1, v_fma(v26, m2, a)));
-}
-
-#define OPENCV_HAL_IMPL_LASX_TRANSPOSE4x4(_Tpvec, cast_from, cast_to)          \
-  inline void v_transpose4x4(const _Tpvec &a0, const _Tpvec &a1,               \
-                             const _Tpvec &a2, const _Tpvec &a3, _Tpvec &b0,   \
-                             _Tpvec &b1, _Tpvec &b2, _Tpvec &b3) {             \
-    __m256i t0 = cast_from(__lasx_xvilvl_w(a1.val, a0.val));                   \
-    __m256i t1 = cast_from(__lasx_xvilvl_w(a3.val, a2.val));                   \
-    __m256i t2 = cast_from(__lasx_xvilvh_w(a1.val, a0.val));                   \
-    __m256i t3 = cast_from(__lasx_xvilvh_w(a3.val, a2.val));                   \
-    b0.val = cast_to(__lasx_xvilvl_d(t1, t0));                                 \
-    b1.val = cast_to(__lasx_xvilvh_d(t1, t0));                                 \
-    b2.val = cast_to(__lasx_xvilvl_d(t3, t2));                                 \
-    b3.val = cast_to(__lasx_xvilvh_d(t3, t2));                                 \
-  }
-
-OPENCV_HAL_IMPL_LASX_TRANSPOSE4x4(v_uint32x8, OPENCV_HAL_NOP, OPENCV_HAL_NOP)
-    OPENCV_HAL_IMPL_LASX_TRANSPOSE4x4(v_int32x8, OPENCV_HAL_NOP, OPENCV_HAL_NOP)
-
-        inline void v_transpose4x4(const v_float32x8 &a0, const v_float32x8 &a1,
-                                   const v_float32x8 &a2, const v_float32x8 &a3,
-                                   v_float32x8 &b0, v_float32x8 &b1,
-                                   v_float32x8 &b2, v_float32x8 &b3) {
-  __m256i t0 = __lasx_xvilvl_w(__m256i(a1.val), __m256i(a0.val));
-  __m256i t1 = __lasx_xvilvl_w(__m256i(a3.val), __m256i(a2.val));
-  __m256i t2 = __lasx_xvilvh_w(__m256i(a1.val), __m256i(a0.val));
-  __m256i t3 = __lasx_xvilvh_w(__m256i(a3.val), __m256i(a2.val));
-  b0.val = __m256(__lasx_xvilvl_d(t1, t0));
-  b1.val = __m256(__lasx_xvilvh_d(t1, t0));
-  b2.val = __m256(__lasx_xvilvl_d(t3, t2));
-  b3.val = __m256(__lasx_xvilvh_d(t3, t2));
-}
-
-//////////////// Value reordering ///////////////
-
-/* Expand */
-#define OPENCV_HAL_IMPL_LASX_EXPAND(_Tpvec, _Tpwvec, _Tp, intrin)              \
-  inline void v_expand(const _Tpvec &a, _Tpwvec &b0, _Tpwvec &b1) {            \
-    b0.val = intrin(a.val);                                                    \
-    b1.val = intrin(__lasx_xvpermi_q(a.val, a.val, 0x11));                     \
-  }                                                                            \
-  inline _Tpwvec v_expand_low(const _Tpvec &a) {                               \
-    return _Tpwvec(intrin(a.val));                                             \
-  }                                                                            \
-  inline _Tpwvec v_expand_high(const _Tpvec &a) {                              \
-    return _Tpwvec(intrin(__lasx_xvpermi_q(a.val, a.val, 0x11)));              \
-  }                                                                            \
-  inline _Tpwvec v256_load_expand(const _Tp *ptr) {                            \
-    __m128i a = __lsx_vld(ptr, 0);                                             \
-    return _Tpwvec(intrin(*((__m256i *)&a)));                                  \
-  }
-
-OPENCV_HAL_IMPL_LASX_EXPAND(v_uint8x32, v_uint16x16, uchar,
-                            __lasx_vext2xv_hu_bu)
-OPENCV_HAL_IMPL_LASX_EXPAND(v_int8x32, v_int16x16, schar, __lasx_vext2xv_h_b)
-OPENCV_HAL_IMPL_LASX_EXPAND(v_uint16x16, v_uint32x8, ushort,
-                            __lasx_vext2xv_wu_hu)
-OPENCV_HAL_IMPL_LASX_EXPAND(v_int16x16, v_int32x8, short, __lasx_vext2xv_w_h)
-OPENCV_HAL_IMPL_LASX_EXPAND(v_uint32x8, v_uint64x4, unsigned,
-                            __lasx_vext2xv_du_wu)
-OPENCV_HAL_IMPL_LASX_EXPAND(v_int32x8, v_int64x4, int, __lasx_vext2xv_d_w)
-
-#define OPENCV_HAL_IMPL_LASX_EXPAND_Q(_Tpvec, _Tp, intrin)                     \
-  inline _Tpvec v256_load_expand_q(const _Tp *ptr) {                           \
-    __m128i a = __lsx_vld(ptr, 0);                                             \
-    return _Tpvec(intrin(*((__m256i *)&a)));                                   \
-  }
-
-OPENCV_HAL_IMPL_LASX_EXPAND_Q(v_uint32x8, uchar, __lasx_vext2xv_wu_bu)
-OPENCV_HAL_IMPL_LASX_EXPAND_Q(v_int32x8, schar, __lasx_vext2xv_w_b)
-
-/* pack */
-// 16
-inline v_int8x32 v_pack(const v_int16x16 &a, const v_int16x16 &b) {
-  return v_int8x32(_v256_shuffle_odd_64(_lasx_packs_h(a.val, b.val)));
-}
-
-inline v_uint8x32 v_pack(const v_uint16x16 &a, const v_uint16x16 &b) {
-  return v_uint8x32(
-      _v256_shuffle_odd_64(__lasx_xvssrlrni_bu_h(b.val, a.val, 0)));
-}
-
-inline v_uint8x32 v_pack_u(const v_int16x16 &a, const v_int16x16 &b) {
-  return v_uint8x32(_v256_shuffle_odd_64(_lasx_packus_h(a.val, b.val)));
-}
-
-inline void v_pack_store(schar *ptr, const v_int16x16 &a) {
-  v_store_low(ptr, v_pack(a, a));
-}
-
-inline void v_pack_store(uchar *ptr, const v_uint16x16 &a) {
-  v_store_low(ptr, v_pack(a, a));
-}
-
-inline void v_pack_u_store(uchar *ptr, const v_int16x16 &a) {
-  v_store_low(ptr, v_pack_u(a, a));
-}
-
-template <int n>
-inline v_uint8x32 v_rshr_pack(const v_uint16x16 &a, const v_uint16x16 &b) {
-  __m256i res = __lasx_xvssrlrni_bu_h(b.val, a.val, n);
-  return v_uint8x32(_v256_shuffle_odd_64(res));
-}
-
-template <int n>
-inline void v_rshr_pack_store(uchar *ptr, const v_uint16x16 &a) {
-  __m256i res = __lasx_xvssrlrni_bu_h(a.val, a.val, n);
-  __lasx_xvstelm_d(res, ptr, 0, 0);
-  __lasx_xvstelm_d(res, ptr, 8, 2);
-}
-
-template <int n>
-inline v_uint8x32 v_rshr_pack_u(const v_int16x16 &a, const v_int16x16 &b) {
-  __m256i res = __lasx_xvssrarni_bu_h(b.val, a.val, n);
-  return v_uint8x32(_v256_shuffle_odd_64(res));
-}
-
-template <int n>
-inline void v_rshr_pack_u_store(uchar *ptr, const v_int16x16 &a) {
-  __m256i res = __lasx_xvssrarni_bu_h(a.val, a.val, n);
-  __lasx_xvstelm_d(res, ptr, 0, 0);
-  __lasx_xvstelm_d(res, ptr, 8, 2);
-}
-
-template <int n>
-inline v_int8x32 v_rshr_pack(const v_int16x16 &a, const v_int16x16 &b) {
-  __m256i res = __lasx_xvssrarni_b_h(b.val, a.val, n);
-  return v_int8x32(_v256_shuffle_odd_64(res));
-}
-
-template <int n>
-inline void v_rshr_pack_store(schar *ptr, const v_int16x16 &a) {
-  __m256i res = __lasx_xvssrarni_b_h(a.val, a.val, n);
-  __lasx_xvstelm_d(res, ptr, 0, 0);
-  __lasx_xvstelm_d(res, ptr, 8, 2);
-}
-
-// 32
-inline v_int16x16 v_pack(const v_int32x8 &a, const v_int32x8 &b) {
-  return v_int16x16(_v256_shuffle_odd_64(_lasx_packs_w(a.val, b.val)));
-}
-
-inline v_uint16x16 v_pack(const v_uint32x8 &a, const v_uint32x8 &b) {
-  return v_uint16x16(_v256_shuffle_odd_64(_v256_packs_epu32(a.val, b.val)));
-}
-
-inline v_uint16x16 v_pack_u(const v_int32x8 &a, const v_int32x8 &b) {
-  return v_uint16x16(_v256_shuffle_odd_64(_lasx_packus_w(a.val, b.val)));
-}
-
-inline void v_pack_store(short *ptr, const v_int32x8 &a) {
-  v_store_low(ptr, v_pack(a, a));
-}
-
-inline void v_pack_store(ushort *ptr, const v_uint32x8 &a) {
-  __m256i res = __lasx_xvssrlrni_hu_w(a.val, a.val, 0);
-  __lasx_xvstelm_d(res, ptr, 0, 0);
-  __lasx_xvstelm_d(res, ptr, 8, 2);
-}
-
-inline void v_pack_u_store(ushort *ptr, const v_int32x8 &a) {
-  v_store_low(ptr, v_pack_u(a, a));
-}
-
-template <int n>
-inline v_uint16x16 v_rshr_pack(const v_uint32x8 &a, const v_uint32x8 &b) {
-  return v_uint16x16(
-      _v256_shuffle_odd_64(__lasx_xvssrlrni_hu_w(b.val, a.val, n)));
-}
-
-template <int n>
-inline void v_rshr_pack_store(ushort *ptr, const v_uint32x8 &a) {
-  __m256i res = __lasx_xvssrlrni_hu_w(a.val, a.val, n);
-  __lasx_xvstelm_d(res, ptr, 0, 0);
-  __lasx_xvstelm_d(res, ptr, 8, 2);
-}
-
-template <int n>
-inline v_uint16x16 v_rshr_pack_u(const v_int32x8 &a, const v_int32x8 &b) {
-  return v_uint16x16(
-      _v256_shuffle_odd_64(__lasx_xvssrarni_hu_w(b.val, a.val, n)));
-}
-
-template <int n>
-inline void v_rshr_pack_u_store(ushort *ptr, const v_int32x8 &a) {
-  __m256i res = __lasx_xvssrarni_hu_w(a.val, a.val, n);
-  __lasx_xvstelm_d(res, ptr, 0, 0);
-  __lasx_xvstelm_d(res, ptr, 8, 2);
-}
-
-template <int n>
-inline v_int16x16 v_rshr_pack(const v_int32x8 &a, const v_int32x8 &b) {
-  return v_int16x16(
-      _v256_shuffle_odd_64(__lasx_xvssrarni_h_w(b.val, a.val, n)));
-}
-
-template <int n> inline void v_rshr_pack_store(short *ptr, const v_int32x8 &a) {
-  __m256i res = __lasx_xvssrarni_h_w(a.val, a.val, n);
-  __lasx_xvstelm_d(res, ptr, 0, 0);
-  __lasx_xvstelm_d(res, ptr, 8, 2);
-}
-
-// 64
-// Non-saturating pack
-inline v_uint32x8 v_pack(const v_uint64x4 &a, const v_uint64x4 &b) {
-  __m256i ab = __lasx_xvpickev_w(b.val, a.val);
-  return v_uint32x8(_v256_shuffle_odd_64(ab));
-}
-
-inline v_int32x8 v_pack(const v_int64x4 &a, const v_int64x4 &b) {
-  return v_reinterpret_as_s32(
-      v_pack(v_reinterpret_as_u64(a), v_reinterpret_as_u64(b)));
-}
-
-inline void v_pack_store(unsigned *ptr, const v_uint64x4 &a) {
-  __m256i a0 = __lasx_xvshuf4i_w(a.val, 0x08);
-  v_store_low(ptr, v_uint32x8(_v256_shuffle_odd_64(a0)));
-}
-
-inline void v_pack_store(int *ptr, const v_int64x4 &b) {
-  v_pack_store((unsigned *)ptr, v_reinterpret_as_u64(b));
-}
-
-template <int n>
-inline v_uint32x8 v_rshr_pack(const v_uint64x4 &a, const v_uint64x4 &b) {
-  return v_uint32x8(_v256_shuffle_odd_64(__lasx_xvsrlrni_w_d(b.val, a.val, n)));
-}
-
-template <int n>
-inline void v_rshr_pack_store(unsigned *ptr, const v_uint64x4 &a) {
-  __m256i res = __lasx_xvsrlrni_w_d(a.val, a.val, n);
-  __lasx_xvstelm_d(res, ptr, 0, 0);
-  __lasx_xvstelm_d(res, ptr, 8, 2);
-}
-
-template <int n>
-inline v_int32x8 v_rshr_pack(const v_int64x4 &a, const v_int64x4 &b) {
-  return v_int32x8(_v256_shuffle_odd_64(__lasx_xvsrarni_w_d(b.val, a.val, n)));
-}
-
-template <int n> inline void v_rshr_pack_store(int *ptr, const v_int64x4 &a) {
-  __m256i res = __lasx_xvsrarni_w_d(a.val, a.val, n);
-  __lasx_xvstelm_d(res, ptr, 0, 0);
-  __lasx_xvstelm_d(res, ptr, 8, 2);
-}
-
-// pack boolean
-inline v_uint8x32 v_pack_b(const v_uint16x16 &a, const v_uint16x16 &b) {
-  __m256i ab = _lasx_packs_h(a.val, b.val);
-  return v_uint8x32(_v256_shuffle_odd_64(ab));
-}
-
-inline v_uint8x32 v_pack_b(const v_uint32x8 &a, const v_uint32x8 &b,
-                           const v_uint32x8 &c, const v_uint32x8 &d) {
-  __m256i ab = _lasx_packs_w(a.val, b.val);
-  __m256i cd = _lasx_packs_w(c.val, d.val);
-
-  __m256i abcd = _v256_shuffle_odd_64(_lasx_packs_h(ab, cd));
-  return v_uint8x32(__lasx_xvshuf4i_w(abcd, 0xd8));
-}
-
-inline v_uint8x32 v_pack_b(const v_uint64x4 &a, const v_uint64x4 &b,
-                           const v_uint64x4 &c, const v_uint64x4 &d,
-                           const v_uint64x4 &e, const v_uint64x4 &f,
-                           const v_uint64x4 &g, const v_uint64x4 &h) {
-  __m256i ab = _lasx_packs_w(a.val, b.val);
-  __m256i cd = _lasx_packs_w(c.val, d.val);
-  __m256i ef = _lasx_packs_w(e.val, f.val);
-  __m256i gh = _lasx_packs_w(g.val, h.val);
-
-  __m256i abcd = _lasx_packs_w(ab, cd);
-  __m256i efgh = _lasx_packs_w(ef, gh);
-  __m256i pkall = _v256_shuffle_odd_64(_lasx_packs_h(abcd, efgh));
-
-  __m256i rev = _v256_alignr_b(pkall, pkall, 8);
-  return v_uint8x32(__lasx_xvilvl_h(rev, pkall));
-}
-
-/* Recombine */
-// its up there with load and store operations
-
-/* Extract */
-#define OPENCV_HAL_IMPL_LASX_EXTRACT(_Tpvec)                                   \
-  template <int s> inline _Tpvec v_extract(const _Tpvec &a, const _Tpvec &b) { \
-    return v_rotate_right<s>(a, b);                                            \
-  }
-
-OPENCV_HAL_IMPL_LASX_EXTRACT(v_uint8x32)
-OPENCV_HAL_IMPL_LASX_EXTRACT(v_int8x32)
-OPENCV_HAL_IMPL_LASX_EXTRACT(v_uint16x16)
-OPENCV_HAL_IMPL_LASX_EXTRACT(v_int16x16)
-OPENCV_HAL_IMPL_LASX_EXTRACT(v_uint32x8)
-OPENCV_HAL_IMPL_LASX_EXTRACT(v_int32x8)
-OPENCV_HAL_IMPL_LASX_EXTRACT(v_uint64x4)
-OPENCV_HAL_IMPL_LASX_EXTRACT(v_int64x4)
-OPENCV_HAL_IMPL_LASX_EXTRACT(v_float32x8)
-OPENCV_HAL_IMPL_LASX_EXTRACT(v_float64x4)
-
-template <int i> inline uchar v_extract_n(v_uint8x32 a) {
-  return (uchar)_v256_extract_b<i>(a.val);
-}
-
-template <int i> inline schar v_extract_n(v_int8x32 a) {
-  return (schar)v_extract_n<i>(v_reinterpret_as_u8(a));
-}
-
-template <int i> inline ushort v_extract_n(v_uint16x16 a) {
-  return (ushort)_v256_extract_h<i>(a.val);
-}
-
-template <int i> inline short v_extract_n(v_int16x16 a) {
-  return (short)v_extract_n<i>(v_reinterpret_as_u16(a));
-}
-
-template <int i> inline uint v_extract_n(v_uint32x8 a) {
-  return (uint)_v256_extract_w<i>(a.val);
-}
-
-template <int i> inline int v_extract_n(v_int32x8 a) {
-  return (int)v_extract_n<i>(v_reinterpret_as_u32(a));
-}
-
-template <int i> inline uint64 v_extract_n(v_uint64x4 a) {
-  return (uint64)_v256_extract_d<i>(a.val);
-}
-
-template <int i> inline int64 v_extract_n(v_int64x4 v) {
-  return (int64)v_extract_n<i>(v_reinterpret_as_u64(v));
-}
-
-template <int i> inline float v_extract_n(v_float32x8 v) {
-  union {
-    uint iv;
-    float fv;
-  } d;
-  d.iv = v_extract_n<i>(v_reinterpret_as_u32(v));
-  return d.fv;
-}
-
-template <int i> inline double v_extract_n(v_float64x4 v) {
-  union {
-    uint64 iv;
-    double dv;
-  } d;
-  d.iv = v_extract_n<i>(v_reinterpret_as_u64(v));
-  return d.dv;
-}
-
-template <int i> inline v_uint32x8 v_broadcast_element(v_uint32x8 a) {
-  static const __m256i perm = __lasx_xvreplgr2vr_w((char)i);
-  return v_uint32x8(__lasx_xvperm_w(a.val, perm));
-}
-
-template <int i> inline v_int32x8 v_broadcast_element(const v_int32x8 &a) {
-  return v_reinterpret_as_s32(v_broadcast_element<i>(v_reinterpret_as_u32(a)));
-}
-
-template <int i> inline v_float32x8 v_broadcast_element(const v_float32x8 &a) {
-  return v_reinterpret_as_f32(v_broadcast_element<i>(v_reinterpret_as_u32(a)));
-}
-
-///////////////////// load deinterleave /////////////////////////////
-
-inline void v_load_deinterleave(const uchar *ptr, v_uint8x32 &a,
-                                v_uint8x32 &b) {
-  __m256i t0 = __lasx_xvld(ptr, 0);
-  __m256i t1 = __lasx_xvld(ptr, 32);
-
-  __m256i p0 = __lasx_xvpickev_b(t1, t0);
-  __m256i p1 = __lasx_xvpickod_b(t1, t0);
-
-  a.val = __lasx_xvpermi_d(p0, 0xd8);
-  b.val = __lasx_xvpermi_d(p1, 0xd8);
-}
-
-inline void v_load_deinterleave(const ushort *ptr, v_uint16x16 &a,
-                                v_uint16x16 &b) {
-  __m256i t0 = __lasx_xvld(ptr, 0);
-  __m256i t1 = __lasx_xvld(ptr, 32);
-
-  __m256i p0 = __lasx_xvpickev_h(t1, t0);
-  __m256i p1 = __lasx_xvpickod_h(t1, t0);
-
-  a.val = __lasx_xvpermi_d(p0, 0xd8);
-  b.val = __lasx_xvpermi_d(p1, 0xd8);
-}
-
-inline void v_load_deinterleave(const unsigned *ptr, v_uint32x8 &a,
-                                v_uint32x8 &b) {
-  __m256i t0 = __lasx_xvld(ptr, 0);
-  __m256i t1 = __lasx_xvld(ptr, 32);
-
-  __m256i p0 = __lasx_xvpickev_w(t1, t0);
-  __m256i p1 = __lasx_xvpickod_w(t1, t0);
-
-  a.val = __lasx_xvpermi_d(p0, 0xd8);
-  b.val = __lasx_xvpermi_d(p1, 0xd8);
-}
-
-inline void v_load_deinterleave(const uint64 *ptr, v_uint64x4 &a,
-                                v_uint64x4 &b) {
-  __m256i ab0 = __lasx_xvld(ptr, 0);
-  __m256i ab1 = __lasx_xvld(ptr, 32);
-
-  __m256i pl = __lasx_xvpermi_q(ab0, ab1, 0x02);
-  __m256i ph = __lasx_xvpermi_q(ab0, ab1, 0x13);
-  __m256i a0 = __lasx_xvilvl_d(ph, pl);
-  __m256i b0 = __lasx_xvilvh_d(ph, pl);
-  a = v_uint64x4(a0);
-  b = v_uint64x4(b0);
-}
-
-inline void v_load_deinterleave(const uchar *ptr, v_uint8x32 &a, v_uint8x32 &b,
-                                v_uint8x32 &c) {
-  __m256i bgr0 = __lasx_xvld(ptr, 0);
-  __m256i bgr1 = __lasx_xvld(ptr, 32);
-  __m256i bgr2 = __lasx_xvld(ptr, 64);
-
-  __m256i s02_low = __lasx_xvpermi_q(bgr0, bgr2, 0x02);
-  __m256i s02_high = __lasx_xvpermi_q(bgr0, bgr2, 0x13);
-
-  const __m256i m0 =
-      _v256_setr_b(0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1,
-                   0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0);
-  const __m256i m1 =
-      _v256_setr_b(0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0,
-                   0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1);
-
-  __m256i b0 =
-      __lasx_xvbitsel_v(__lasx_xvbitsel_v(s02_low, s02_high, m0), bgr1, m1);
-  __m256i g0 =
-      __lasx_xvbitsel_v(__lasx_xvbitsel_v(s02_high, s02_low, m1), bgr1, m0);
-  __m256i r0 =
-      __lasx_xvbitsel_v(__lasx_xvbitsel_v(bgr1, s02_low, m0), s02_high, m1);
-
-  const __m256i sh_b = _v256_setr_b(0, 3, 6, 9, 12, 15, 2, 5, 8, 11, 14, 1, 4,
-                                    7, 10, 13, 0, 3, 6, 9, 12, 15, 2, 5, 8, 11,
-                                    14, 1, 4, 7, 10, 13),
-                sh_g = _v256_setr_b(1, 4, 7, 10, 13, 0, 3, 6, 9, 12, 15, 2, 5,
-                                    8, 11, 14, 1, 4, 7, 10, 13, 0, 3, 6, 9, 12,
-                                    15, 2, 5, 8, 11, 14),
-                sh_r = _v256_setr_b(2, 5, 8, 11, 14, 1, 4, 7, 10, 13, 0, 3, 6,
-                                    9, 12, 15, 2, 5, 8, 11, 14, 1, 4, 7, 10, 13,
-                                    0, 3, 6, 9, 12, 15);
-  b0 = __lasx_xvshuf_b(b0, b0, sh_b);
-  g0 = __lasx_xvshuf_b(g0, g0, sh_g);
-  r0 = __lasx_xvshuf_b(r0, r0, sh_r);
-
-  a = v_uint8x32(b0);
-  b = v_uint8x32(g0);
-  c = v_uint8x32(r0);
-}
-
-inline void v_load_deinterleave(const ushort *ptr, v_uint16x16 &a,
-                                v_uint16x16 &b, v_uint16x16 &c) {
-  __m256i bgr0 = __lasx_xvld(ptr, 0);
-  __m256i bgr1 = __lasx_xvld(ptr, 32);
-  __m256i bgr2 = __lasx_xvld(ptr, 64);
-
-  __m256i s02_low = __lasx_xvpermi_q(bgr0, bgr2, 0x02);
-  __m256i s02_high = __lasx_xvpermi_q(bgr0, bgr2, 0x13);
-
-  const __m256i m0 =
-      _v256_setr_b(0, 0, -1, -1, 0, 0, 0, 0, -1, -1, 0, 0, 0, 0, -1, -1, 0, 0,
-                   0, 0, -1, -1, 0, 0, 0, 0, -1, -1, 0, 0, 0, 0);
-  const __m256i m1 =
-      _v256_setr_b(0, 0, 0, 0, -1, -1, 0, 0, 0, 0, -1, -1, 0, 0, 0, 0, -1, -1,
-                   0, 0, 0, 0, -1, -1, 0, 0, 0, 0, -1, -1, 0, 0);
-  __m256i b0 =
-      __lasx_xvbitsel_v(__lasx_xvbitsel_v(s02_low, s02_high, m0), bgr1, m1);
-  __m256i g0 =
-      __lasx_xvbitsel_v(__lasx_xvbitsel_v(bgr1, s02_low, m0), s02_high, m1);
-  __m256i r0 =
-      __lasx_xvbitsel_v(__lasx_xvbitsel_v(s02_high, s02_low, m1), bgr1, m0);
-  const __m256i sh_b =
-      _v256_setr_b(0, 1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15, 4, 5, 10, 11, 0, 1,
-                   6, 7, 12, 13, 2, 3, 8, 9, 14, 15, 4, 5, 10, 11);
-  const __m256i sh_g =
-      _v256_setr_b(2, 3, 8, 9, 14, 15, 4, 5, 10, 11, 0, 1, 6, 7, 12, 13, 2, 3,
-                   8, 9, 14, 15, 4, 5, 10, 11, 0, 1, 6, 7, 12, 13);
-  const __m256i sh_r =
-      _v256_setr_b(4, 5, 10, 11, 0, 1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15, 4, 5,
-                   10, 11, 0, 1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15);
-  b0 = __lasx_xvshuf_b(b0, b0, sh_b);
-  g0 = __lasx_xvshuf_b(g0, g0, sh_g);
-  r0 = __lasx_xvshuf_b(r0, r0, sh_r);
-
-  a = v_uint16x16(b0);
-  b = v_uint16x16(g0);
-  c = v_uint16x16(r0);
-}
-
-inline void v_load_deinterleave(const unsigned *ptr, v_uint32x8 &a,
-                                v_uint32x8 &b, v_uint32x8 &c) {
-  __m256i bgr0 = __lasx_xvld(ptr, 0);
-  __m256i bgr1 = __lasx_xvld(ptr, 32);
-  __m256i bgr2 = __lasx_xvld(ptr, 64);
-
-  __m256i s02_low = __lasx_xvpermi_q(bgr0, bgr2, 0x02);
-  __m256i s02_high = __lasx_xvpermi_q(bgr0, bgr2, 0x13);
-
-  __m256i m24 = _v256_set_w(0, 0, -1, 0, 0, -1, 0, 0);
-  __m256i m92 = _v256_set_w(-1, 0, 0, -1, 0, 0, -1, 0);
-  __m256i b0 =
-      __lasx_xvbitsel_v(__lasx_xvbitsel_v(s02_low, s02_high, m24), bgr1, m92);
-  __m256i g0 =
-      __lasx_xvbitsel_v(__lasx_xvbitsel_v(s02_high, s02_low, m92), bgr1, m24);
-  __m256i r0 =
-      __lasx_xvbitsel_v(__lasx_xvbitsel_v(bgr1, s02_low, m24), s02_high, m92);
-
-  b0 = __lasx_xvshuf4i_w(b0, 0x6c);
-  g0 = __lasx_xvshuf4i_w(g0, 0xb1);
-  r0 = __lasx_xvshuf4i_w(r0, 0xc6);
-
-  a = v_uint32x8(b0);
-  b = v_uint32x8(g0);
-  c = v_uint32x8(r0);
-}
-
-inline void v_load_deinterleave(const uint64 *ptr, v_uint64x4 &a, v_uint64x4 &b,
-                                v_uint64x4 &c) {
-  __m256i bgr0 = __lasx_xvld(ptr, 0);
-  __m256i bgr1 = __lasx_xvld(ptr, 32);
-  __m256i bgr2 = __lasx_xvld(ptr, 64);
-
-  __m256i s01 =
-      __lasx_xvpermi_q(bgr0, bgr1, 0x12); // get bgr0 low 128 and bgr1 high 128
-  __m256i s12 = __lasx_xvpermi_q(bgr1, bgr2, 0x12);
-  __m256i s20r = __lasx_xvpermi_d(__lasx_xvpermi_q(bgr2, bgr0, 0x12), 0x1b);
-  __m256i b0 = __lasx_xvilvl_d(s20r, s01);
-  __m256i g0 = _v256_alignr_b(s12, s01, 8);
-  __m256i r0 = __lasx_xvilvh_d(s12, s20r);
-
-  a = v_uint64x4(b0);
-  b = v_uint64x4(g0);
-  c = v_uint64x4(r0);
-}
-
-inline void v_load_deinterleave(const uchar *ptr, v_uint8x32 &a, v_uint8x32 &b,
-                                v_uint8x32 &c, v_uint8x32 &d) {
-  __m256i t0 = __lasx_xvld(ptr, 0);
-  __m256i t1 = __lasx_xvld(ptr, 32);
-  __m256i t2 = __lasx_xvld(ptr, 64);
-  __m256i t3 = __lasx_xvld(ptr, 96);
-
-  const __m256i sh = _v256_setr_w(0, 4, 1, 5, 2, 6, 3, 7);
-  __m256i ac_lo = __lasx_xvpickev_b(t1, t0);
-  __m256i bd_lo = __lasx_xvpickod_b(t1, t0);
-  __m256i ac_hi = __lasx_xvpickev_b(t3, t2);
-  __m256i bd_hi = __lasx_xvpickod_b(t3, t2);
-
-  __m256i a_pre = __lasx_xvpickev_b(ac_hi, ac_lo);
-  __m256i c_pre = __lasx_xvpickod_b(ac_hi, ac_lo);
-  __m256i b_pre = __lasx_xvpickev_b(bd_hi, bd_lo);
-  __m256i d_pre = __lasx_xvpickod_b(bd_hi, bd_lo);
-
-  a.val = __lasx_xvperm_w(a_pre, sh);
-  b.val = __lasx_xvperm_w(b_pre, sh);
-  c.val = __lasx_xvperm_w(c_pre, sh);
-  d.val = __lasx_xvperm_w(d_pre, sh);
-}
-
-inline void v_load_deinterleave(const ushort *ptr, v_uint16x16 &a,
-                                v_uint16x16 &b, v_uint16x16 &c,
-                                v_uint16x16 &d) {
-  __m256i t0 = __lasx_xvld(ptr, 0);
-  __m256i t1 = __lasx_xvld(ptr, 32);
-  __m256i t2 = __lasx_xvld(ptr, 64);
-  __m256i t3 = __lasx_xvld(ptr, 96);
-
-  const __m256i sh = _v256_setr_w(0, 4, 1, 5, 2, 6, 3, 7);
-  __m256i ac_lo = __lasx_xvpickev_h(t1, t0);
-  __m256i bd_lo = __lasx_xvpickod_h(t1, t0);
-  __m256i ac_hi = __lasx_xvpickev_h(t3, t2);
-  __m256i bd_hi = __lasx_xvpickod_h(t3, t2);
-
-  __m256i a_pre = __lasx_xvpickev_h(ac_hi, ac_lo);
-  __m256i c_pre = __lasx_xvpickod_h(ac_hi, ac_lo);
-  __m256i b_pre = __lasx_xvpickev_h(bd_hi, bd_lo);
-  __m256i d_pre = __lasx_xvpickod_h(bd_hi, bd_lo);
-
-  a.val = __lasx_xvperm_w(a_pre, sh);
-  b.val = __lasx_xvperm_w(b_pre, sh);
-  c.val = __lasx_xvperm_w(c_pre, sh);
-  d.val = __lasx_xvperm_w(d_pre, sh);
-}
-
-inline void v_load_deinterleave(const unsigned *ptr, v_uint32x8 &a,
-                                v_uint32x8 &b, v_uint32x8 &c, v_uint32x8 &d) {
-  __m256i p0 = __lasx_xvld(ptr, 0);
-  __m256i p1 = __lasx_xvld(ptr, 32);
-  __m256i p2 = __lasx_xvld(ptr, 64);
-  __m256i p3 = __lasx_xvld(ptr, 96);
-
-  __m256i p01l = __lasx_xvilvl_w(p1, p0);
-  __m256i p01h = __lasx_xvilvh_w(p1, p0);
-  __m256i p23l = __lasx_xvilvl_w(p3, p2);
-  __m256i p23h = __lasx_xvilvh_w(p3, p2);
-
-  __m256i pll = __lasx_xvpermi_q(p01l, p23l, 0x02);
-  __m256i plh = __lasx_xvpermi_q(p01l, p23l, 0x13);
-  __m256i phl = __lasx_xvpermi_q(p01h, p23h, 0x02);
-  __m256i phh = __lasx_xvpermi_q(p01h, p23h, 0x13);
-
-  __m256i b0 = __lasx_xvilvl_w(plh, pll);
-  __m256i g0 = __lasx_xvilvh_w(plh, pll);
-  __m256i r0 = __lasx_xvilvl_w(phh, phl);
-  __m256i a0 = __lasx_xvilvh_w(phh, phl);
-
-  a = v_uint32x8(b0);
-  b = v_uint32x8(g0);
-  c = v_uint32x8(r0);
-  d = v_uint32x8(a0);
-}
-
-inline void v_load_deinterleave(const uint64 *ptr, v_uint64x4 &a, v_uint64x4 &b,
-                                v_uint64x4 &c, v_uint64x4 &d) {
-  __m256i bgra0 = __lasx_xvld(ptr, 0);
-  __m256i bgra1 = __lasx_xvld(ptr, 32);
-  __m256i bgra2 = __lasx_xvld(ptr, 64);
-  __m256i bgra3 = __lasx_xvld(ptr, 96);
-
-  __m256i l02 = __lasx_xvpermi_q(bgra0, bgra2, 0x02);
-  __m256i h02 = __lasx_xvpermi_q(bgra0, bgra2, 0x13);
-  __m256i l13 = __lasx_xvpermi_q(bgra1, bgra3, 0x02);
-  __m256i h13 = __lasx_xvpermi_q(bgra1, bgra3, 0x13);
-
-  __m256i b0 = __lasx_xvilvl_d(l13, l02);
-  __m256i g0 = __lasx_xvilvh_d(l13, l02);
-  __m256i r0 = __lasx_xvilvl_d(h13, h02);
-  __m256i a0 = __lasx_xvilvh_d(h13, h02);
-
-  a = v_uint64x4(b0);
-  b = v_uint64x4(g0);
-  c = v_uint64x4(r0);
-  d = v_uint64x4(a0);
-}
-
-///////////////////////////// store interleave
-////////////////////////////////////////
-
-inline void v_store_interleave(uchar *ptr, const v_uint8x32 &x,
-                               const v_uint8x32 &y,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  __m256i xy_l = __lasx_xvilvl_b(y.val, x.val);
-  __m256i xy_h = __lasx_xvilvh_b(y.val, x.val);
-
-  __m256i xy0 = __lasx_xvpermi_q(xy_h, xy_l, 0 + 2 * 16);
-  __m256i xy1 = __lasx_xvpermi_q(xy_h, xy_l, 1 + 3 * 16);
-
-  __lasx_xvst(xy0, (__m256i *)ptr, 0);
-  __lasx_xvst(xy1, (__m256i *)ptr, 32 * 1);
-}
-
-inline void v_store_interleave(ushort *ptr, const v_uint16x16 &x,
-                               const v_uint16x16 &y,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  __m256i xy_l = __lasx_xvilvl_h(y.val, x.val);
-  __m256i xy_h = __lasx_xvilvh_h(y.val, x.val);
-
-  __m256i xy0 = __lasx_xvpermi_q(xy_h, xy_l, 0 + 2 * 16);
-  __m256i xy1 = __lasx_xvpermi_q(xy_h, xy_l, 1 + 3 * 16);
-
-  __lasx_xvst(xy0, (__m256i *)ptr, 0);
-  __lasx_xvst(xy1, (__m256i *)ptr, 16 * 2);
-}
-
-inline void v_store_interleave(unsigned *ptr, const v_uint32x8 &x,
-                               const v_uint32x8 &y,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  __m256i xy_l = __lasx_xvilvl_w(y.val, x.val);
-  __m256i xy_h = __lasx_xvilvh_w(y.val, x.val);
-
-  __m256i xy0 = __lasx_xvpermi_q(xy_h, xy_l, 0 + 2 * 16);
-  __m256i xy1 = __lasx_xvpermi_q(xy_h, xy_l, 1 + 3 * 16);
-
-  __lasx_xvst(xy0, (__m256i *)ptr, 0);
-  __lasx_xvst(xy1, (__m256i *)ptr, 8 * 4);
-}
-
-inline void v_store_interleave(uint64 *ptr, const v_uint64x4 &x,
-                               const v_uint64x4 &y,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  __m256i xy_l = __lasx_xvilvl_d(y.val, x.val);
-  __m256i xy_h = __lasx_xvilvh_d(y.val, x.val);
-
-  __m256i xy0 = __lasx_xvpermi_q(xy_h, xy_l, 0 + 2 * 16);
-  __m256i xy1 = __lasx_xvpermi_q(xy_h, xy_l, 1 + 3 * 16);
-
-  __lasx_xvst(xy0, (__m256i *)ptr, 0);
-  __lasx_xvst(xy1, (__m256i *)ptr, 4 * 8);
-}
-
-inline void v_store_interleave(uchar *ptr, const v_uint8x32 &a,
-                               const v_uint8x32 &b, const v_uint8x32 &c,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  const __m256i sh_b =
-      _v256_setr_b(0, 11, 6, 1, 12, 7, 2, 13, 8, 3, 14, 9, 4, 15, 10, 5, 0, 11,
-                   6, 1, 12, 7, 2, 13, 8, 3, 14, 9, 4, 15, 10, 5);
-  const __m256i sh_g =
-      _v256_setr_b(5, 0, 11, 6, 1, 12, 7, 2, 13, 8, 3, 14, 9, 4, 15, 10, 5, 0,
-                   11, 6, 1, 12, 7, 2, 13, 8, 3, 14, 9, 4, 15, 10);
-  const __m256i sh_r =
-      _v256_setr_b(10, 5, 0, 11, 6, 1, 12, 7, 2, 13, 8, 3, 14, 9, 4, 15, 10, 5,
-                   0, 11, 6, 1, 12, 7, 2, 13, 8, 3, 14, 9, 4, 15);
-
-  __m256i b0 = __lasx_xvshuf_b(a.val, a.val, sh_b);
-  __m256i g0 = __lasx_xvshuf_b(b.val, b.val, sh_g);
-  __m256i r0 = __lasx_xvshuf_b(c.val, c.val, sh_r);
-
-  const __m256i m0 =
-      _v256_setr_b(0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, -1,
-                   0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0);
-  const __m256i m1 =
-      _v256_setr_b(0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0,
-                   -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0);
-
-  __m256i p0 = __lasx_xvbitsel_v(__lasx_xvbitsel_v(b0, g0, m0), r0, m1);
-  __m256i p1 = __lasx_xvbitsel_v(__lasx_xvbitsel_v(g0, r0, m0), b0, m1);
-  __m256i p2 = __lasx_xvbitsel_v(__lasx_xvbitsel_v(r0, b0, m0), g0, m1);
-
-  __m256i bgr0 = __lasx_xvpermi_q(p1, p0, 0 + 2 * 16);
-  __m256i bgr1 = __lasx_xvpermi_q(p0, p2, 0 + 3 * 16);
-  __m256i bgr2 = __lasx_xvpermi_q(p2, p1, 1 + 3 * 16);
-
-  __lasx_xvst(bgr0, (__m256i *)ptr, 0);
-  __lasx_xvst(bgr1, (__m256i *)ptr, 32);
-  __lasx_xvst(bgr2, (__m256i *)ptr, 64);
-}
-
-inline void v_store_interleave(ushort *ptr, const v_uint16x16 &a,
-                               const v_uint16x16 &b, const v_uint16x16 &c,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  const __m256i sh_b =
-      _v256_setr_b(0, 1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15, 4, 5, 10, 11, 0, 1,
-                   6, 7, 12, 13, 2, 3, 8, 9, 14, 15, 4, 5, 10, 11);
-  const __m256i sh_g =
-      _v256_setr_b(10, 11, 0, 1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15, 4, 5, 10, 11,
-                   0, 1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15, 4, 5);
-  const __m256i sh_r =
-      _v256_setr_b(4, 5, 10, 11, 0, 1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15, 4, 5,
-                   10, 11, 0, 1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15);
-
-  __m256i b0 = __lasx_xvshuf_b(a.val, a.val, sh_b);
-  __m256i g0 = __lasx_xvshuf_b(b.val, b.val, sh_g);
-  __m256i r0 = __lasx_xvshuf_b(c.val, c.val, sh_r);
-
-  const __m256i m0 =
-      _v256_setr_b(0, 0, -1, -1, 0, 0, 0, 0, -1, -1, 0, 0, 0, 0, -1, -1, 0, 0,
-                   0, 0, -1, -1, 0, 0, 0, 0, -1, -1, 0, 0, 0, 0);
-  const __m256i m1 =
-      _v256_setr_b(0, 0, 0, 0, -1, -1, 0, 0, 0, 0, -1, -1, 0, 0, 0, 0, -1, -1,
-                   0, 0, 0, 0, -1, -1, 0, 0, 0, 0, -1, -1, 0, 0);
-
-  __m256i p0 = __lasx_xvbitsel_v(__lasx_xvbitsel_v(b0, g0, m0), r0, m1);
-  __m256i p1 = __lasx_xvbitsel_v(__lasx_xvbitsel_v(g0, r0, m0), b0, m1);
-  __m256i p2 = __lasx_xvbitsel_v(__lasx_xvbitsel_v(r0, b0, m0), g0, m1);
-
-  __m256i bgr0 = __lasx_xvpermi_q(p2, p0, 0 + 2 * 16);
-  __m256i bgr2 = __lasx_xvpermi_q(p2, p0, 1 + 3 * 16);
-
-  __lasx_xvst(bgr0, (__m256i *)ptr, 0);
-  __lasx_xvst(p1, (__m256i *)ptr, 16 * 2);
-  __lasx_xvst(bgr2, (__m256i *)ptr, 32 * 2);
-}
-
-inline void v_store_interleave(unsigned *ptr, const v_uint32x8 &a,
-                               const v_uint32x8 &b, const v_uint32x8 &c,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  __m256i b0 = __lasx_xvshuf4i_w(a.val, 0x6c);
-  __m256i g0 = __lasx_xvshuf4i_w(b.val, 0xb1);
-  __m256i r0 = __lasx_xvshuf4i_w(c.val, 0xc6);
-
-  __m256i bitmask_1 = _v256_set_w(-1, 0, 0, -1, 0, 0, -1, 0);
-  __m256i bitmask_2 = _v256_set_w(0, 0, -1, 0, 0, -1, 0, 0);
-
-  __m256i p0 =
-      __lasx_xvbitsel_v(__lasx_xvbitsel_v(b0, g0, bitmask_1), r0, bitmask_2);
-  __m256i p1 =
-      __lasx_xvbitsel_v(__lasx_xvbitsel_v(g0, r0, bitmask_1), b0, bitmask_2);
-  __m256i p2 =
-      __lasx_xvbitsel_v(__lasx_xvbitsel_v(r0, b0, bitmask_1), g0, bitmask_2);
-
-  __m256i bgr0 = __lasx_xvpermi_q(p1, p0, 0 + 2 * 16);
-  __m256i bgr2 = __lasx_xvpermi_q(p1, p0, 1 + 3 * 16);
-
-  __lasx_xvst(bgr0, (__m256i *)ptr, 0);
-  __lasx_xvst(p2, (__m256i *)ptr, 8 * 4);
-  __lasx_xvst(bgr2, (__m256i *)ptr, 16 * 4);
-}
-
-inline void v_store_interleave(uint64 *ptr, const v_uint64x4 &a,
-                               const v_uint64x4 &b, const v_uint64x4 &c,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  __m256i s01 = __lasx_xvilvl_d(b.val, a.val);
-  __m256i s12 = __lasx_xvilvh_d(c.val, b.val);
-  __m256i s20 = __lasx_xvpermi_w(a.val, c.val, 0xe4);
-
-  __m256i bgr0 = __lasx_xvpermi_q(s20, s01, 0 + 2 * 16);
-  __m256i bgr1 = __lasx_xvpermi_q(s01, s12, 0x30);
-  __m256i bgr2 = __lasx_xvpermi_q(s12, s20, 1 + 3 * 16);
-
-  __lasx_xvst(bgr0, (__m256i *)ptr, 0);
-  __lasx_xvst(bgr1, (__m256i *)ptr, 4 * 8);
-  __lasx_xvst(bgr2, (__m256i *)ptr, 8 * 8);
-}
-
-inline void v_store_interleave(uchar *ptr, const v_uint8x32 &a,
-                               const v_uint8x32 &b, const v_uint8x32 &c,
-                               const v_uint8x32 &d,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  __m256i bg0 = __lasx_xvilvl_b(b.val, a.val);
-  __m256i bg1 = __lasx_xvilvh_b(b.val, a.val);
-  __m256i ra0 = __lasx_xvilvl_b(d.val, c.val);
-  __m256i ra1 = __lasx_xvilvh_b(d.val, c.val);
-
-  __m256i bgra0_ = __lasx_xvilvl_h(ra0, bg0);
-  __m256i bgra1_ = __lasx_xvilvh_h(ra0, bg0);
-  __m256i bgra2_ = __lasx_xvilvl_h(ra1, bg1);
-  __m256i bgra3_ = __lasx_xvilvh_h(ra1, bg1);
-
-  __m256i bgra0 = __lasx_xvpermi_q(bgra1_, bgra0_, 0 + 2 * 16);
-  __m256i bgra2 = __lasx_xvpermi_q(bgra1_, bgra0_, 1 + 3 * 16);
-  __m256i bgra1 = __lasx_xvpermi_q(bgra3_, bgra2_, 0 + 2 * 16);
-  __m256i bgra3 = __lasx_xvpermi_q(bgra3_, bgra2_, 1 + 3 * 16);
-
-  __lasx_xvst(bgra0, (__m256i *)ptr, 0);
-  __lasx_xvst(bgra1, (__m256i *)ptr, 32);
-  __lasx_xvst(bgra2, (__m256i *)ptr, 64);
-  __lasx_xvst(bgra3, (__m256i *)ptr, 96);
-}
-
-inline void v_store_interleave(ushort *ptr, const v_uint16x16 &a,
-                               const v_uint16x16 &b, const v_uint16x16 &c,
-                               const v_uint16x16 &d,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  __m256i bg0 = __lasx_xvilvl_h(b.val, a.val);
-  __m256i bg1 = __lasx_xvilvh_h(b.val, a.val);
-  __m256i ra0 = __lasx_xvilvl_h(d.val, c.val);
-  __m256i ra1 = __lasx_xvilvh_h(d.val, c.val);
-
-  __m256i bgra0_ = __lasx_xvilvl_w(ra0, bg0);
-  __m256i bgra1_ = __lasx_xvilvh_w(ra0, bg0);
-  __m256i bgra2_ = __lasx_xvilvl_w(ra1, bg1);
-  __m256i bgra3_ = __lasx_xvilvh_w(ra1, bg1);
-
-  __m256i bgra0 = __lasx_xvpermi_q(bgra1_, bgra0_, 0 + 2 * 16);
-  __m256i bgra2 = __lasx_xvpermi_q(bgra1_, bgra0_, 1 + 3 * 16);
-  __m256i bgra1 = __lasx_xvpermi_q(bgra3_, bgra2_, 0 + 2 * 16);
-  __m256i bgra3 = __lasx_xvpermi_q(bgra3_, bgra2_, 1 + 3 * 16);
-
-  __lasx_xvst(bgra0, (__m256i *)ptr, 0);
-  __lasx_xvst(bgra1, (__m256i *)ptr, 16 * 2);
-  __lasx_xvst(bgra2, (__m256i *)ptr, 32 * 2);
-  __lasx_xvst(bgra3, (__m256i *)ptr, 48 * 2);
-}
-
-inline void v_store_interleave(unsigned *ptr, const v_uint32x8 &a,
-                               const v_uint32x8 &b, const v_uint32x8 &c,
-                               const v_uint32x8 &d,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  __m256i bg0 = __lasx_xvilvl_w(b.val, a.val);
-  __m256i bg1 = __lasx_xvilvh_w(b.val, a.val);
-  __m256i ra0 = __lasx_xvilvl_w(d.val, c.val);
-  __m256i ra1 = __lasx_xvilvh_w(d.val, c.val);
-
-  __m256i bgra0_ = __lasx_xvilvl_d(ra0, bg0);
-  __m256i bgra1_ = __lasx_xvilvh_d(ra0, bg0);
-  __m256i bgra2_ = __lasx_xvilvl_d(ra1, bg1);
-  __m256i bgra3_ = __lasx_xvilvh_d(ra1, bg1);
-
-  __m256i bgra0 = __lasx_xvpermi_q(bgra1_, bgra0_, 0 + 2 * 16);
-  __m256i bgra2 = __lasx_xvpermi_q(bgra1_, bgra0_, 1 + 3 * 16);
-  __m256i bgra1 = __lasx_xvpermi_q(bgra3_, bgra2_, 0 + 2 * 16);
-  __m256i bgra3 = __lasx_xvpermi_q(bgra3_, bgra2_, 1 + 3 * 16);
-
-  __lasx_xvst(bgra0, (__m256i *)ptr, 0);
-  __lasx_xvst(bgra1, (__m256i *)ptr, 8 * 4);
-  __lasx_xvst(bgra2, (__m256i *)ptr, 16 * 4);
-  __lasx_xvst(bgra3, (__m256i *)ptr, 24 * 4);
-}
-
-inline void v_store_interleave(uint64 *ptr, const v_uint64x4 &a,
-                               const v_uint64x4 &b, const v_uint64x4 &c,
-                               const v_uint64x4 &d,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  __m256i bg0 = __lasx_xvilvl_d(b.val, a.val);
-  __m256i bg1 = __lasx_xvilvh_d(b.val, a.val);
-  __m256i ra0 = __lasx_xvilvl_d(d.val, c.val);
-  __m256i ra1 = __lasx_xvilvh_d(d.val, c.val);
-
-  __m256i bgra0 = __lasx_xvpermi_q(ra0, bg0, 0 + 2 * 16);
-  __m256i bgra1 = __lasx_xvpermi_q(ra1, bg1, 0 + 2 * 16);
-  __m256i bgra2 = __lasx_xvpermi_q(ra0, bg0, 1 + 3 * 16);
-  __m256i bgra3 = __lasx_xvpermi_q(ra1, bg1, 1 + 3 * 16);
-
-  __lasx_xvst(bgra0, (__m256i *)ptr, 0);
-  __lasx_xvst(bgra1, (__m256i *)(ptr), 4 * 8);
-  __lasx_xvst(bgra2, (__m256i *)(ptr), 8 * 8);
-  __lasx_xvst(bgra3, (__m256i *)(ptr), 12 * 8);
-}
-
-#define OPENCV_HAL_IMPL_LASX_LOADSTORE_INTERLEAVE(_Tpvec0, _Tp0, suffix0,      \
-                                                  _Tpvec1, _Tp1, suffix1)      \
-  inline void v_load_deinterleave(const _Tp0 *ptr, _Tpvec0 &a0, _Tpvec0 &b0) { \
-    _Tpvec1 a1, b1;                                                            \
-    v_load_deinterleave((const _Tp1 *)ptr, a1, b1);                            \
-    a0 = v_reinterpret_as_##suffix0(a1);                                       \
-    b0 = v_reinterpret_as_##suffix0(b1);                                       \
-  }                                                                            \
-  inline void v_load_deinterleave(const _Tp0 *ptr, _Tpvec0 &a0, _Tpvec0 &b0,   \
-                                  _Tpvec0 &c0) {                               \
-    _Tpvec1 a1, b1, c1;                                                        \
-    v_load_deinterleave((const _Tp1 *)ptr, a1, b1, c1);                        \
-    a0 = v_reinterpret_as_##suffix0(a1);                                       \
-    b0 = v_reinterpret_as_##suffix0(b1);                                       \
-    c0 = v_reinterpret_as_##suffix0(c1);                                       \
-  }                                                                            \
-  inline void v_load_deinterleave(const _Tp0 *ptr, _Tpvec0 &a0, _Tpvec0 &b0,   \
-                                  _Tpvec0 &c0, _Tpvec0 &d0) {                  \
-    _Tpvec1 a1, b1, c1, d1;                                                    \
-    v_load_deinterleave((const _Tp1 *)ptr, a1, b1, c1, d1);                    \
-    a0 = v_reinterpret_as_##suffix0(a1);                                       \
-    b0 = v_reinterpret_as_##suffix0(b1);                                       \
-    c0 = v_reinterpret_as_##suffix0(c1);                                       \
-    d0 = v_reinterpret_as_##suffix0(d1);                                       \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp0 *ptr, const _Tpvec0 &a0, const _Tpvec0 &b0,                         \
-      hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {                        \
-    _Tpvec1 a1 = v_reinterpret_as_##suffix1(a0);                               \
-    _Tpvec1 b1 = v_reinterpret_as_##suffix1(b0);                               \
-    v_store_interleave((_Tp1 *)ptr, a1, b1 /*, mode*/);                        \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp0 *ptr, const _Tpvec0 &a0, const _Tpvec0 &b0, const _Tpvec0 &c0,      \
-      hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {                        \
-    _Tpvec1 a1 = v_reinterpret_as_##suffix1(a0);                               \
-    _Tpvec1 b1 = v_reinterpret_as_##suffix1(b0);                               \
-    _Tpvec1 c1 = v_reinterpret_as_##suffix1(c0);                               \
-    v_store_interleave((_Tp1 *)ptr, a1, b1, c1 /*, mode*/);                    \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp0 *ptr, const _Tpvec0 &a0, const _Tpvec0 &b0, const _Tpvec0 &c0,      \
-      const _Tpvec0 &d0, hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {     \
-    _Tpvec1 a1 = v_reinterpret_as_##suffix1(a0);                               \
-    _Tpvec1 b1 = v_reinterpret_as_##suffix1(b0);                               \
-    _Tpvec1 c1 = v_reinterpret_as_##suffix1(c0);                               \
-    _Tpvec1 d1 = v_reinterpret_as_##suffix1(d0);                               \
-    v_store_interleave((_Tp1 *)ptr, a1, b1, c1, d1 /*, mode*/);                \
-  }
-
-OPENCV_HAL_IMPL_LASX_LOADSTORE_INTERLEAVE(v_int8x32, schar, s8, v_uint8x32,
-                                          uchar, u8)
-OPENCV_HAL_IMPL_LASX_LOADSTORE_INTERLEAVE(v_int16x16, short, s16, v_uint16x16,
-                                          ushort, u16)
-OPENCV_HAL_IMPL_LASX_LOADSTORE_INTERLEAVE(v_int32x8, int, s32, v_uint32x8,
-                                          unsigned, u32)
-OPENCV_HAL_IMPL_LASX_LOADSTORE_INTERLEAVE(v_float32x8, float, f32, v_uint32x8,
-                                          unsigned, u32)
-OPENCV_HAL_IMPL_LASX_LOADSTORE_INTERLEAVE(v_int64x4, int64, s64, v_uint64x4,
-                                          uint64, u64)
-OPENCV_HAL_IMPL_LASX_LOADSTORE_INTERLEAVE(v_float64x4, double, f64, v_uint64x4,
-                                          uint64, u64)
-
-//
-// FP16
-//
-
-inline v_float32x8 v256_load_expand(const hfloat *ptr) {
-#if CV_FP16
-  // 1-load128, 2-permi, 3-cvt
-  return v_float32x8(__lasx_xvfcvtl_s_h(
-      __lasx_xvpermi_d(__lsx_vld((const __m128i *)ptr, 0), 0x10)));
-#else
-  float CV_DECL_ALIGNED(32) buf[8];
-  for (int i = 0; i < 8; i++)
-    buf[i] = (float)ptr[i];
-  return v256_load_aligned(buf);
-#endif
-}
-
-inline void v_pack_store(hfloat *ptr, const v_float32x8 &a) {
-#if CV_FP16
-  __m256i ah = __lasx_xvfcvt_h_s(a.val, a.val);
-  __lsx_vst((_m128i)ah, ptr, 0);
-#else
-  float CV_DECL_ALIGNED(32) buf[8];
-  v_store_aligned(buf, a);
-  for (int i = 0; i < 8; i++)
-    ptr[i] = hfloat(buf[i]);
-#endif
-}
-
-//
-// end of FP16
-//
-
-inline void v256_cleanup() {}
-
-#include "intrin_math.hpp"
-inline v_float32x8 v_exp(const v_float32x8 &x) {
-  return v_exp_default_32f<v_float32x8, v_int32x8>(x);
-}
-inline v_float32x8 v_log(const v_float32x8 &x) {
-  return v_log_default_32f<v_float32x8, v_int32x8>(x);
-}
-inline void v_sincos(const v_float32x8 &x, v_float32x8 &s, v_float32x8 &c) {
-  v_sincos_default_32f<v_float32x8, v_int32x8>(x, s, c);
-}
-inline v_float32x8 v_sin(const v_float32x8 &x) {
-  return v_sin_default_32f<v_float32x8, v_int32x8>(x);
-}
-inline v_float32x8 v_cos(const v_float32x8 &x) {
-  return v_cos_default_32f<v_float32x8, v_int32x8>(x);
-}
-inline v_float32x8 v_erf(const v_float32x8 &x) {
-  return v_erf_default_32f<v_float32x8, v_int32x8>(x);
-}
-
-inline v_float64x4 v_exp(const v_float64x4 &x) {
-  return v_exp_default_64f<v_float64x4, v_int64x4>(x);
-}
-inline v_float64x4 v_log(const v_float64x4 &x) {
-  return v_log_default_64f<v_float64x4, v_int64x4>(x);
-}
-inline void v_sincos(const v_float64x4 &x, v_float64x4 &s, v_float64x4 &c) {
-  v_sincos_default_64f<v_float64x4, v_int64x4>(x, s, c);
-}
-inline v_float64x4 v_sin(const v_float64x4 &x) {
-  return v_sin_default_64f<v_float64x4, v_int64x4>(x);
-}
-inline v_float64x4 v_cos(const v_float64x4 &x) {
-  return v_cos_default_64f<v_float64x4, v_int64x4>(x);
-}
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_END
-
-//! @endcond
-
-} // namespace cv
-
-#endif // OPENCV_HAL_INTRIN_LASX_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_lsx.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_lsx.hpp
deleted file mode 100644
index c339cb7bd3..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_lsx.hpp
+++ /dev/null
@@ -1,2671 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html
-
-#ifndef OPENCV_HAL_INTRIN_LSX_HPP
-#define OPENCV_HAL_INTRIN_LSX_HPP
-
-#include <lsxintrin.h>
-
-#define CV_SIMD128 1
-#define CV_SIMD128_64F 1
-#define CV_SIMD128_FP16 0
-
-namespace cv {
-
-//! @cond IGNORED
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_BEGIN
-
-/////////// Utils ////////
-
-inline __m128i _v128_setr_b(char v0, char v1, char v2, char v3, char v4,
-                            char v5, char v6, char v7, char v8, char v9,
-                            char v10, char v11, char v12, char v13, char v14,
-                            char v15) {
-  return (__m128i)v16i8{v0, v1, v2,  v3,  v4,  v5,  v6,  v7,
-                        v8, v9, v10, v11, v12, v13, v14, v15};
-}
-
-inline __m128i _v128_set_b(char v0, char v1, char v2, char v3, char v4, char v5,
-                           char v6, char v7, char v8, char v9, char v10,
-                           char v11, char v12, char v13, char v14, char v15) {
-  return (__m128i)v16i8{v15, v14, v13, v12, v11, v10, v9, v8,
-                        v7,  v6,  v5,  v4,  v3,  v2,  v1, v0};
-}
-
-inline __m128i _v128_setr_h(short v0, short v1, short v2, short v3, short v4,
-                            short v5, short v6, short v7) {
-  return (__m128i)v8i16{v0, v1, v2, v3, v4, v5, v6, v7};
-}
-
-inline __m128i _v128_setr_w(int v0, int v1, int v2, int v3) {
-  return (__m128i)v4i32{v0, v1, v2, v3};
-}
-
-inline __m128i _v128_set_w(int v0, int v1, int v2, int v3) {
-  return (__m128i)v4i32{v3, v2, v1, v0};
-}
-
-inline __m128i _v128_setall_w(int v0) { return __lsx_vreplgr2vr_w(v0); }
-
-inline __m128i _v128_setr_d(int64 v0, int64 v1) {
-  return (__m128i)v2i64{v0, v1};
-}
-
-inline __m128i _v128_set_d(int64 v0, int64 v1) {
-  return (__m128i)v2i64{v1, v0};
-}
-
-inline __m128 _v128_setr_ps(float v0, float v1, float v2, float v3) {
-  return (__m128)v4f32{v0, v1, v2, v3};
-}
-
-inline __m128 _v128_setall_ps(float v0) {
-  return (__m128)v4f32{v0, v0, v0, v0};
-}
-
-inline __m128d _v128_setr_pd(double v0, double v1) {
-  return (__m128d)v2f64{v0, v1};
-}
-
-inline __m128d _v128_setall_pd(double v0) { return (__m128d)v2f64{v0, v0}; }
-
-inline __m128i _lsx_packus_h(const __m128i &a, const __m128i &b) {
-  return __lsx_vssrarni_bu_h(b, a, 0);
-}
-
-inline __m128i _lsx_packs_h(const __m128i &a, const __m128i &b) {
-  return __lsx_vssrarni_b_h(b, a, 0);
-}
-
-inline __m128i _lsx_packus_w(const __m128i &a, const __m128i &b) {
-  return __lsx_vssrarni_hu_w(b, a, 0);
-}
-
-/////// Types ///////
-
-struct v_uint8x16 {
-  typedef uchar lane_type;
-  enum { nlanes = 16 };
-
-  v_uint8x16() {}
-  explicit v_uint8x16(__m128i v) : val(v) {}
-  v_uint8x16(uchar v0, uchar v1, uchar v2, uchar v3, uchar v4, uchar v5,
-             uchar v6, uchar v7, uchar v8, uchar v9, uchar v10, uchar v11,
-             uchar v12, uchar v13, uchar v14, uchar v15) {
-    val = _v128_setr_b(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
-                       v13, v14, v15);
-  }
-
-  uchar get0() const { return (uchar)__lsx_vpickve2gr_bu(val, 0); }
-
-  __m128i val;
-};
-
-struct v_int8x16 {
-  typedef schar lane_type;
-  enum { nlanes = 16 };
-
-  v_int8x16() {}
-  explicit v_int8x16(__m128i v) : val(v) {}
-  v_int8x16(schar v0, schar v1, schar v2, schar v3, schar v4, schar v5,
-            schar v6, schar v7, schar v8, schar v9, schar v10, schar v11,
-            schar v12, schar v13, schar v14, schar v15) {
-    val = _v128_setr_b(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
-                       v13, v14, v15);
-  }
-
-  schar get0() const { return (schar)__lsx_vpickve2gr_b(val, 0); }
-
-  __m128i val;
-};
-
-struct v_uint16x8 {
-  typedef ushort lane_type;
-  enum { nlanes = 8 };
-
-  v_uint16x8() {}
-  explicit v_uint16x8(__m128i v) : val(v) {}
-  v_uint16x8(ushort v0, ushort v1, ushort v2, ushort v3, ushort v4, ushort v5,
-             ushort v6, ushort v7) {
-    val = _v128_setr_h(v0, v1, v2, v3, v4, v5, v6, v7);
-  }
-
-  ushort get0() const { return (ushort)__lsx_vpickve2gr_hu(val, 0); }
-
-  __m128i val;
-};
-
-struct v_int16x8 {
-  typedef short lane_type;
-  enum { nlanes = 8 };
-
-  v_int16x8() {}
-  explicit v_int16x8(__m128i v) : val(v) {}
-  v_int16x8(short v0, short v1, short v2, short v3, short v4, short v5,
-            short v6, short v7) {
-    val = _v128_setr_h(v0, v1, v2, v3, v4, v5, v6, v7);
-  }
-
-  short get0() const { return (short)__lsx_vpickve2gr_h(val, 0); }
-
-  __m128i val;
-};
-
-struct v_uint32x4 {
-  typedef unsigned lane_type;
-  enum { nlanes = 4 };
-
-  v_uint32x4() {}
-  explicit v_uint32x4(__m128i v) : val(v) {}
-  v_uint32x4(unsigned v0, unsigned v1, unsigned v2, unsigned v3) {
-    val = _v128_setr_w(v0, v1, v2, v3);
-  }
-
-  unsigned get0() const { return (unsigned)__lsx_vpickve2gr_wu(val, 0); }
-
-  __m128i val;
-};
-
-struct v_int32x4 {
-  typedef int lane_type;
-  enum { nlanes = 4 };
-
-  v_int32x4() {}
-  explicit v_int32x4(__m128i v) : val(v) {}
-  v_int32x4(int v0, int v1, int v2, int v3) {
-    val = _v128_setr_w(v0, v1, v2, v3);
-  }
-
-  int get0() const { return (int)__lsx_vpickve2gr_w(val, 0); }
-
-  __m128i val;
-};
-
-struct v_float32x4 {
-  typedef float lane_type;
-  enum { nlanes = 4 };
-
-  v_float32x4() {}
-  explicit v_float32x4(__m128 v) : val(v) {}
-  explicit v_float32x4(__m128i v) { val = *((__m128 *)&v); }
-  v_float32x4(float v0, float v1, float v2, float v3) {
-    val = _v128_setr_ps(v0, v1, v2, v3);
-  }
-
-  float get0() const {
-    union {
-      int iv;
-      float fv;
-    } d;
-    d.iv = __lsx_vpickve2gr_w(val, 0);
-    return d.fv;
-  }
-
-  int get0toint() const {
-    __m128i result = __lsx_vftintrz_w_s(val);
-    return (int)__lsx_vpickve2gr_w(result, 0);
-  }
-
-  __m128 val;
-};
-
-struct v_uint64x2 {
-  typedef uint64 lane_type;
-  enum { nlanes = 2 };
-
-  v_uint64x2() {}
-  explicit v_uint64x2(__m128i v) : val(v) {}
-  v_uint64x2(uint64 v0, uint64 v1) { val = _v128_setr_d(v0, v1); }
-
-  uint64 get0() const { return __lsx_vpickve2gr_du(val, 0); }
-
-  __m128i val;
-};
-
-struct v_int64x2 {
-  typedef int64 lane_type;
-  enum { nlanes = 2 };
-
-  v_int64x2() {}
-  explicit v_int64x2(__m128i v) : val(v) {}
-  v_int64x2(int64 v0, int64 v1) { val = _v128_setr_d(v0, v1); }
-
-  uint64 get0() const { return __lsx_vpickve2gr_d(val, 0); }
-
-  __m128i val;
-};
-
-struct v_float64x2 {
-  typedef double lane_type;
-  enum { nlanes = 2 };
-
-  v_float64x2() {}
-  explicit v_float64x2(__m128d v) : val(v) {}
-  explicit v_float64x2(__m128i v) { val = *((__m128d *)&v); }
-  v_float64x2(double v0, double v1) { val = _v128_setr_pd(v0, v1); }
-
-  double get0() const {
-    union {
-      int64 iv;
-      double fv;
-    } d;
-    d.iv = __lsx_vpickve2gr_d(val, 0);
-    return d.fv;
-  }
-
-  int64 get0toint64() const {
-    __m128i result = __lsx_vftintrz_l_d(val);
-    return (int64)__lsx_vpickve2gr_d(result, 0);
-  }
-
-  __m128d val;
-};
-
-////////////// Load and store operations /////////
-
-#define OPENCV_HAL_IMPL_LSX_LOADSTORE(_Tpvec, _Tp)                             \
-  inline _Tpvec v_load(const _Tp *ptr) { return _Tpvec(__lsx_vld(ptr, 0)); }   \
-  inline _Tpvec v_load_aligned(const _Tp *ptr) {                               \
-    return _Tpvec(__lsx_vld(ptr, 0));                                          \
-  }                                                                            \
-  inline _Tpvec v_load_low(const _Tp *ptr) {                                   \
-    return _Tpvec(__lsx_vldrepl_d(ptr, 0));                                    \
-  }                                                                            \
-  inline _Tpvec v_load_halves(const _Tp *ptr0, const _Tp *ptr1) {              \
-    __m128i vl = __lsx_vldrepl_d(ptr0, 0);                                     \
-    __m128i vh = __lsx_vldrepl_d(ptr1, 0);                                     \
-    return _Tpvec(__lsx_vilvl_d(vh, vl));                                      \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a) { __lsx_vst(a.val, ptr, 0); } \
-  inline void v_store_aligned(_Tp *ptr, const _Tpvec &a) {                     \
-    __lsx_vst(a.val, ptr, 0);                                                  \
-  }                                                                            \
-  inline void v_store_aligned_nocache(_Tp *ptr, const _Tpvec &a) {             \
-    __lsx_vst(a.val, ptr, 0);                                                  \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a, hal::StoreMode mode) {        \
-    if (mode == hal::STORE_UNALIGNED)                                          \
-      __lsx_vst(a.val, ptr, 0);                                                \
-    else if (mode == hal::STORE_ALIGNED_NOCACHE)                               \
-      __lsx_vst(a.val, ptr, 0);                                                \
-    else                                                                       \
-      __lsx_vst(a.val, ptr, 0);                                                \
-  }                                                                            \
-  inline void v_store_low(_Tp *ptr, const _Tpvec &a) {                         \
-    __lsx_vstelm_d(a.val, ptr, 0, 0);                                          \
-  }                                                                            \
-  inline void v_store_high(_Tp *ptr, const _Tpvec &a) {                        \
-    __lsx_vstelm_d(a.val, ptr, 0, 1);                                          \
-  }
-
-OPENCV_HAL_IMPL_LSX_LOADSTORE(v_uint8x16, uchar)
-OPENCV_HAL_IMPL_LSX_LOADSTORE(v_int8x16, schar)
-OPENCV_HAL_IMPL_LSX_LOADSTORE(v_uint16x8, ushort)
-OPENCV_HAL_IMPL_LSX_LOADSTORE(v_int16x8, short)
-OPENCV_HAL_IMPL_LSX_LOADSTORE(v_uint32x4, unsigned)
-OPENCV_HAL_IMPL_LSX_LOADSTORE(v_int32x4, int)
-OPENCV_HAL_IMPL_LSX_LOADSTORE(v_uint64x2, uint64)
-OPENCV_HAL_IMPL_LSX_LOADSTORE(v_int64x2, int64)
-
-#define OPENCV_HAL_IMPL_LSX_LOADSTORE_FLT(_Tpvec, _Tp, halfreg)                \
-  inline _Tpvec v_load(const _Tp *ptr) {                                       \
-    return _Tpvec((halfreg)__lsx_vld(ptr, 0));                                 \
-  }                                                                            \
-  inline _Tpvec v_load_aligned(const _Tp *ptr) {                               \
-    return _Tpvec((halfreg)__lsx_vld(ptr, 0));                                 \
-  }                                                                            \
-  inline _Tpvec v_load_low(const _Tp *ptr) {                                   \
-    return _Tpvec((halfreg)__lsx_vldrepl_d(ptr, 0));                           \
-  }                                                                            \
-  inline _Tpvec v_load_halves(const _Tp *ptr0, const _Tp *ptr1) {              \
-    __m128i vl = __lsx_vldrepl_d(ptr0, 0);                                     \
-    __m128i vh = __lsx_vldrepl_d(ptr1, 0);                                     \
-    return _Tpvec((halfreg)__lsx_vilvl_d(vh, vl));                             \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a) {                             \
-    __lsx_vst((__m128i)a.val, ptr, 0);                                         \
-  }                                                                            \
-  inline void v_store_aligned(_Tp *ptr, const _Tpvec &a) {                     \
-    __lsx_vst((__m128i)a.val, ptr, 0);                                         \
-  }                                                                            \
-  inline void v_store_aligned_nocache(_Tp *ptr, const _Tpvec &a) {             \
-    __lsx_vst((__m128i)a.val, ptr, 0);                                         \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a, hal::StoreMode mode) {        \
-    if (mode == hal::STORE_UNALIGNED)                                          \
-      __lsx_vst((__m128i)a.val, ptr, 0);                                       \
-    else if (mode == hal::STORE_ALIGNED_NOCACHE)                               \
-      __lsx_vst((__m128i)a.val, ptr, 0);                                       \
-    else                                                                       \
-      __lsx_vst((__m128i)a.val, ptr, 0);                                       \
-  }                                                                            \
-  inline void v_store_low(_Tp *ptr, const _Tpvec &a) {                         \
-    __lsx_vstelm_d((__m128i)a.val, ptr, 0, 0);                                 \
-  }                                                                            \
-  inline void v_store_high(_Tp *ptr, const _Tpvec &a) {                        \
-    __lsx_vstelm_d((__m128i)a.val, ptr, 0, 1);                                 \
-  }
-
-OPENCV_HAL_IMPL_LSX_LOADSTORE_FLT(v_float32x4, float, __m128)
-OPENCV_HAL_IMPL_LSX_LOADSTORE_FLT(v_float64x2, double, __m128d)
-
-inline __m128i _lsx_128_castps_si128(const __m128 &v) { return __m128i(v); }
-
-inline __m128i _lsx_128_castpd_si128(const __m128d &v) { return __m128i(v); }
-
-#define OPENCV_HAL_IMPL_LSX_CAST(_Tpvec, _Tpvecf, suffix, cast)                \
-  inline _Tpvec v_reinterpret_as_##suffix(const _Tpvecf &a) {                  \
-    return _Tpvec(cast(a.val));                                                \
-  }
-
-#define OPENCV_HAL_IMPL_LSX_INIT(_Tpvec, _Tp, suffix, ssuffix, ctype_s)        \
-  inline _Tpvec v_setzero_##suffix() { return _Tpvec(__lsx_vldi(0)); }         \
-  inline _Tpvec v_setall_##suffix(_Tp v) {                                     \
-    return _Tpvec(__lsx_vreplgr2vr_##ssuffix((ctype_s)v));                     \
-  }                                                                            \
-  template <> inline _Tpvec v_setzero_() { return v_setzero_##suffix(); }      \
-  template <> inline _Tpvec v_setall_(_Tp v) { return v_setall_##suffix(v); }  \
-  OPENCV_HAL_IMPL_LSX_CAST(_Tpvec, v_uint8x16, suffix, OPENCV_HAL_NOP)         \
-  OPENCV_HAL_IMPL_LSX_CAST(_Tpvec, v_int8x16, suffix, OPENCV_HAL_NOP)          \
-  OPENCV_HAL_IMPL_LSX_CAST(_Tpvec, v_uint16x8, suffix, OPENCV_HAL_NOP)         \
-  OPENCV_HAL_IMPL_LSX_CAST(_Tpvec, v_int16x8, suffix, OPENCV_HAL_NOP)          \
-  OPENCV_HAL_IMPL_LSX_CAST(_Tpvec, v_uint32x4, suffix, OPENCV_HAL_NOP)         \
-  OPENCV_HAL_IMPL_LSX_CAST(_Tpvec, v_int32x4, suffix, OPENCV_HAL_NOP)          \
-  OPENCV_HAL_IMPL_LSX_CAST(_Tpvec, v_uint64x2, suffix, OPENCV_HAL_NOP)         \
-  OPENCV_HAL_IMPL_LSX_CAST(_Tpvec, v_int64x2, suffix, OPENCV_HAL_NOP)          \
-  OPENCV_HAL_IMPL_LSX_CAST(_Tpvec, v_float32x4, suffix, _lsx_128_castps_si128) \
-  OPENCV_HAL_IMPL_LSX_CAST(_Tpvec, v_float64x2, suffix, _lsx_128_castpd_si128)
-
-OPENCV_HAL_IMPL_LSX_INIT(v_uint8x16, uchar, u8, b, int)
-OPENCV_HAL_IMPL_LSX_INIT(v_int8x16, schar, s8, b, int)
-OPENCV_HAL_IMPL_LSX_INIT(v_uint16x8, ushort, u16, h, int)
-OPENCV_HAL_IMPL_LSX_INIT(v_int16x8, short, s16, h, int)
-OPENCV_HAL_IMPL_LSX_INIT(v_uint32x4, unsigned, u32, w, int)
-OPENCV_HAL_IMPL_LSX_INIT(v_int32x4, int, s32, w, int)
-OPENCV_HAL_IMPL_LSX_INIT(v_uint64x2, uint64, u64, d, long int)
-OPENCV_HAL_IMPL_LSX_INIT(v_int64x2, int64, s64, d, long int)
-
-inline __m128 _lsx_128_castsi128_ps(const __m128i &v) { return __m128(v); }
-
-inline __m128d _lsx_128_castsi128_pd(const __m128i &v) { return __m128d(v); }
-
-#define OPENCV_HAL_IMPL_LSX_INIT_FLT(_Tpvec, _Tp, suffix, zsuffix, cast)       \
-  inline _Tpvec v_setzero_##suffix() { return _Tpvec(__lsx_vldi(0)); }         \
-  inline _Tpvec v_setall_##suffix(_Tp v) {                                     \
-    return _Tpvec(_v128_setall_##zsuffix(v));                                  \
-  }                                                                            \
-  template <> inline _Tpvec v_setzero_() { return v_setzero_##suffix(); }      \
-  template <> inline _Tpvec v_setall_(_Tp v) { return v_setall_##suffix(v); }  \
-  OPENCV_HAL_IMPL_LSX_CAST(_Tpvec, v_uint8x16, suffix, cast)                   \
-  OPENCV_HAL_IMPL_LSX_CAST(_Tpvec, v_int8x16, suffix, cast)                    \
-  OPENCV_HAL_IMPL_LSX_CAST(_Tpvec, v_uint16x8, suffix, cast)                   \
-  OPENCV_HAL_IMPL_LSX_CAST(_Tpvec, v_int16x8, suffix, cast)                    \
-  OPENCV_HAL_IMPL_LSX_CAST(_Tpvec, v_uint32x4, suffix, cast)                   \
-  OPENCV_HAL_IMPL_LSX_CAST(_Tpvec, v_int32x4, suffix, cast)                    \
-  OPENCV_HAL_IMPL_LSX_CAST(_Tpvec, v_uint64x2, suffix, cast)                   \
-  OPENCV_HAL_IMPL_LSX_CAST(_Tpvec, v_int64x2, suffix, cast)
-
-OPENCV_HAL_IMPL_LSX_INIT_FLT(v_float32x4, float, f32, ps, _lsx_128_castsi128_ps)
-OPENCV_HAL_IMPL_LSX_INIT_FLT(v_float64x2, double, f64, pd,
-                             _lsx_128_castsi128_pd)
-
-inline v_float32x4 v_reinterpret_as_f32(const v_float32x4 &a) { return a; }
-inline v_float32x4 v_reinterpret_as_f32(const v_float64x2 &a) {
-  return v_float32x4(_lsx_128_castps_si128(__m128(a.val)));
-}
-
-inline v_float64x2 v_reinterpret_as_f64(const v_float64x2 &a) { return a; }
-inline v_float64x2 v_reinterpret_as_f64(const v_float32x4 &a) {
-  return v_float64x2(_lsx_128_castpd_si128(__m128d(a.val)));
-}
-
-//////////////// Variant Value reordering ///////////////
-
-// unpacks
-#define OPENCV_HAL_IMPL_LSX_UNPACK(_Tpvec, suffix)                             \
-  inline _Tpvec v128_unpacklo(const _Tpvec &a, const _Tpvec &b) {              \
-    return _Tpvec(__lsx_vilvl_##suffix(__m128i(b.val), __m128i(a.val)));       \
-  }                                                                            \
-  inline _Tpvec v128_unpackhi(const _Tpvec &a, const _Tpvec &b) {              \
-    return _Tpvec(__lsx_vilvh_##suffix(__m128i(b.val), __m128i(a.val)));       \
-  }
-
-OPENCV_HAL_IMPL_LSX_UNPACK(v_uint8x16, b)
-OPENCV_HAL_IMPL_LSX_UNPACK(v_int8x16, b)
-OPENCV_HAL_IMPL_LSX_UNPACK(v_uint16x8, h)
-OPENCV_HAL_IMPL_LSX_UNPACK(v_int16x8, h)
-OPENCV_HAL_IMPL_LSX_UNPACK(v_uint32x4, w)
-OPENCV_HAL_IMPL_LSX_UNPACK(v_int32x4, w)
-OPENCV_HAL_IMPL_LSX_UNPACK(v_uint64x2, d)
-OPENCV_HAL_IMPL_LSX_UNPACK(v_int64x2, d)
-OPENCV_HAL_IMPL_LSX_UNPACK(v_float32x4, w)
-OPENCV_HAL_IMPL_LSX_UNPACK(v_float64x2, d)
-
-// ZIP
-#define OPENCV_HAL_IMPL_LSX_ZIP(_Tpvec)                                        \
-  inline _Tpvec v_combine_low(const _Tpvec &a, const _Tpvec &b) {              \
-    return (_Tpvec)__lsx_vilvl_d((__m128i)b.val, (__m128i)a.val);              \
-  }                                                                            \
-  inline _Tpvec v_combine_high(const _Tpvec &a, const _Tpvec &b) {             \
-    return (_Tpvec)__lsx_vilvh_d((__m128i)b.val, (__m128i)a.val);              \
-  }                                                                            \
-  inline void v_recombine(const _Tpvec &a, const _Tpvec &b, _Tpvec &c,         \
-                          _Tpvec &d) {                                         \
-    __m128i a1 = (__m128i)a.val, b1 = (__m128i)b.val;                          \
-    c = _Tpvec(__lsx_vilvl_d(b1, a1));                                         \
-    d = _Tpvec(__lsx_vilvh_d(b1, a1));                                         \
-  }                                                                            \
-  inline void v_zip(const _Tpvec &a, const _Tpvec &b, _Tpvec &ab0,             \
-                    _Tpvec &ab1) {                                             \
-    ab0 = v128_unpacklo(a, b);                                                 \
-    ab1 = v128_unpackhi(a, b);                                                 \
-  }
-
-OPENCV_HAL_IMPL_LSX_ZIP(v_uint8x16)
-OPENCV_HAL_IMPL_LSX_ZIP(v_int8x16)
-OPENCV_HAL_IMPL_LSX_ZIP(v_uint16x8)
-OPENCV_HAL_IMPL_LSX_ZIP(v_int16x8)
-OPENCV_HAL_IMPL_LSX_ZIP(v_uint32x4)
-OPENCV_HAL_IMPL_LSX_ZIP(v_int32x4)
-OPENCV_HAL_IMPL_LSX_ZIP(v_uint64x2)
-OPENCV_HAL_IMPL_LSX_ZIP(v_int64x2)
-OPENCV_HAL_IMPL_LSX_ZIP(v_float32x4)
-OPENCV_HAL_IMPL_LSX_ZIP(v_float64x2)
-
-////////// Arithmetic, bitwise and comparison operations /////////
-
-/** Arithmetics **/
-#define OPENCV_HAL_IMPL_LSX_BIN_OP(bin_op, _Tpvec, intrin)                     \
-  inline _Tpvec bin_op(const _Tpvec &a, const _Tpvec &b) {                     \
-    return _Tpvec(intrin(a.val, b.val));                                       \
-  }
-
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_add, v_uint8x16, __lsx_vsadd_bu)
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_sub, v_uint8x16, __lsx_vssub_bu)
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_add, v_int8x16, __lsx_vsadd_b)
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_sub, v_int8x16, __lsx_vssub_b)
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_add, v_uint16x8, __lsx_vsadd_hu)
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_sub, v_uint16x8, __lsx_vssub_hu)
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_add, v_int16x8, __lsx_vsadd_h)
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_sub, v_int16x8, __lsx_vssub_h)
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_add, v_uint32x4, __lsx_vadd_w)
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_sub, v_uint32x4, __lsx_vsub_w)
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_mul, v_uint32x4, __lsx_vmul_w)
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_add, v_int32x4, __lsx_vadd_w)
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_sub, v_int32x4, __lsx_vsub_w)
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_mul, v_int32x4, __lsx_vmul_w)
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_add, v_uint64x2, __lsx_vadd_d)
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_sub, v_uint64x2, __lsx_vsub_d)
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_add, v_int64x2, __lsx_vadd_d)
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_sub, v_int64x2, __lsx_vsub_d)
-
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_add, v_float32x4, __lsx_vfadd_s)
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_sub, v_float32x4, __lsx_vfsub_s)
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_mul, v_float32x4, __lsx_vfmul_s)
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_div, v_float32x4, __lsx_vfdiv_s)
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_add, v_float64x2, __lsx_vfadd_d)
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_sub, v_float64x2, __lsx_vfsub_d)
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_mul, v_float64x2, __lsx_vfmul_d)
-OPENCV_HAL_IMPL_LSX_BIN_OP(v_div, v_float64x2, __lsx_vfdiv_d)
-
-// saturating multiply 8-bit, 16-bit
-inline v_uint8x16 v_mul(const v_uint8x16 &a, const v_uint8x16 &b) {
-  v_uint16x8 c, d;
-  v_mul_expand(a, b, c, d);
-  return v_pack(c, d);
-}
-inline v_int8x16 v_mul(const v_int8x16 &a, const v_int8x16 &b) {
-  v_int16x8 c, d;
-  v_mul_expand(a, b, c, d);
-  return v_pack(c, d);
-}
-inline v_uint16x8 v_mul(const v_uint16x8 &a, const v_uint16x8 &b) {
-  __m128i a0 = a.val, b0 = b.val;
-  __m128i pev = __lsx_vmulwev_w_hu(a0, b0);
-  __m128i pod = __lsx_vmulwod_w_hu(a0, b0);
-  __m128i pl = __lsx_vilvl_w(pod, pev);
-  __m128i ph = __lsx_vilvh_w(pod, pev);
-  return (v_uint16x8)__lsx_vssrlrni_hu_w(ph, pl, 0);
-}
-inline v_int16x8 v_mul(const v_int16x8 &a, const v_int16x8 &b) {
-  __m128i a0 = a.val, b0 = b.val;
-  __m128i pev = __lsx_vmulwev_w_h(a0, b0);
-  __m128i pod = __lsx_vmulwod_w_h(a0, b0);
-  __m128i pl = __lsx_vilvl_w(pod, pev);
-  __m128i ph = __lsx_vilvh_w(pod, pev);
-  return (v_int16x8)__lsx_vssrarni_h_w(ph, pl, 0);
-}
-
-/** Non-saturating arithmetics **/
-
-#define OPENCV_HAL_IMPL_LSX_BIN_FUNC(func, _Tpvec, intrin)                     \
-  inline _Tpvec func(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(intrin(a.val, b.val));                                       \
-  }
-
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_add_wrap, v_uint8x16, __lsx_vadd_b)
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_add_wrap, v_int8x16, __lsx_vadd_b)
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_add_wrap, v_uint16x8, __lsx_vadd_h)
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_add_wrap, v_int16x8, __lsx_vadd_h)
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_sub_wrap, v_uint8x16, __lsx_vsub_b)
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_sub_wrap, v_int8x16, __lsx_vsub_b)
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_sub_wrap, v_uint16x8, __lsx_vsub_h)
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_sub_wrap, v_int16x8, __lsx_vsub_h)
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_mul_wrap, v_uint16x8, __lsx_vmul_h)
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_mul_wrap, v_int16x8, __lsx_vmul_h)
-
-inline v_uint8x16 v_mul_wrap(const v_uint8x16 &a, const v_uint8x16 &b) {
-  __m128i a0 = a.val, b0 = b.val;
-  __m128i p0 = __lsx_vmulwev_h_bu(a0, b0);
-  __m128i p1 = __lsx_vmulwod_h_bu(a0, b0);
-  return v_uint8x16(__lsx_vpackev_b(p1, p0));
-}
-
-inline v_int8x16 v_mul_wrap(const v_int8x16 &a, const v_int8x16 &b) {
-  return v_reinterpret_as_s8(
-      v_mul_wrap(v_reinterpret_as_u8(a), v_reinterpret_as_u8(b)));
-}
-
-// Multiply and expand
-inline void v_mul_expand(const v_uint8x16 &a, const v_uint8x16 &b,
-                         v_uint16x8 &c, v_uint16x8 &d) {
-  __m128i a0 = a.val, b0 = b.val;
-  __m128i p0 = __lsx_vmulwev_h_bu(a0, b0);
-  __m128i p1 = __lsx_vmulwod_h_bu(a0, b0);
-  c.val = __lsx_vilvl_h(p1, p0);
-  d.val = __lsx_vilvh_h(p1, p0);
-}
-inline void v_mul_expand(const v_int8x16 &a, const v_int8x16 &b, v_int16x8 &c,
-                         v_int16x8 &d) {
-  __m128i a0 = a.val, b0 = b.val;
-  __m128i p0 = __lsx_vmulwev_h_b(a0, b0);
-  __m128i p1 = __lsx_vmulwod_h_b(a0, b0);
-  c.val = __lsx_vilvl_h(p1, p0);
-  d.val = __lsx_vilvh_h(p1, p0);
-}
-inline void v_mul_expand(const v_int16x8 &a, const v_int16x8 &b, v_int32x4 &c,
-                         v_int32x4 &d) {
-  __m128i a0 = a.val, b0 = b.val;
-  __m128i p0 = __lsx_vmulwev_w_h(a0, b0);
-  __m128i p1 = __lsx_vmulwod_w_h(a0, b0);
-  c.val = __lsx_vilvl_w(p1, p0);
-  d.val = __lsx_vilvh_w(p1, p0);
-}
-inline void v_mul_expand(const v_uint16x8 &a, const v_uint16x8 &b,
-                         v_uint32x4 &c, v_uint32x4 &d) {
-  __m128i a0 = a.val, b0 = b.val;
-  __m128i p0 = __lsx_vmulwev_w_hu(a0, b0);
-  __m128i p1 = __lsx_vmulwod_w_hu(a0, b0);
-  c.val = __lsx_vilvl_w(p1, p0);
-  d.val = __lsx_vilvh_w(p1, p0);
-}
-inline void v_mul_expand(const v_uint32x4 &a, const v_uint32x4 &b,
-                         v_uint64x2 &c, v_uint64x2 &d) {
-  __m128i a0 = a.val, b0 = b.val;
-  __m128i p0 = __lsx_vmulwev_d_wu(a0, b0);
-  __m128i p1 = __lsx_vmulwod_d_wu(a0, b0);
-  c.val = __lsx_vilvl_d(p1, p0);
-  d.val = __lsx_vilvh_d(p1, p0);
-}
-inline v_int16x8 v_mul_hi(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_int16x8(__lsx_vmuh_h(a.val, b.val));
-}
-inline v_uint16x8 v_mul_hi(const v_uint16x8 &a, const v_uint16x8 &b) {
-  return v_uint16x8(__lsx_vmuh_hu(a.val, b.val));
-}
-
-/** Bitwise shifts **/
-#define OPENCV_HAL_IMPL_LSX_SHIFT_OP(_Tpuvec, _Tpsvec, suffix, srai)           \
-  inline _Tpuvec v_shl(const _Tpuvec &a, int imm) {                            \
-    return _Tpuvec(                                                            \
-        __lsx_vsll_##suffix(a.val, __lsx_vreplgr2vr_##suffix(imm)));           \
-  }                                                                            \
-  inline _Tpsvec v_shl(const _Tpsvec &a, int imm) {                            \
-    return _Tpsvec(                                                            \
-        __lsx_vsll_##suffix(a.val, __lsx_vreplgr2vr_##suffix(imm)));           \
-  }                                                                            \
-  inline _Tpuvec v_shr(const _Tpuvec &a, int imm) {                            \
-    return _Tpuvec(                                                            \
-        __lsx_vsrl_##suffix(a.val, __lsx_vreplgr2vr_##suffix(imm)));           \
-  }                                                                            \
-  inline _Tpsvec v_shr(const _Tpsvec &a, int imm) {                            \
-    return _Tpsvec(srai(a.val, __lsx_vreplgr2vr_##suffix(imm)));               \
-  }                                                                            \
-  template <int imm> inline _Tpuvec v_shl(const _Tpuvec &a) {                  \
-    return _Tpuvec(__lsx_vslli_##suffix(a.val, imm));                          \
-  }                                                                            \
-  template <int imm> inline _Tpsvec v_shl(const _Tpsvec &a) {                  \
-    return _Tpsvec(__lsx_vslli_##suffix(a.val, imm));                          \
-  }                                                                            \
-  template <int imm> inline _Tpuvec v_shr(const _Tpuvec &a) {                  \
-    return _Tpuvec(__lsx_vsrli_##suffix(a.val, imm));                          \
-  }                                                                            \
-  template <int imm> inline _Tpsvec v_shr(const _Tpsvec &a) {                  \
-    return _Tpsvec(__lsx_vsrai_##suffix(a.val, imm));                          \
-  }
-
-OPENCV_HAL_IMPL_LSX_SHIFT_OP(v_uint16x8, v_int16x8, h, __lsx_vsra_h)
-OPENCV_HAL_IMPL_LSX_SHIFT_OP(v_uint32x4, v_int32x4, w, __lsx_vsra_w)
-OPENCV_HAL_IMPL_LSX_SHIFT_OP(v_uint64x2, v_int64x2, d, __lsx_vsra_d)
-
-/** Bitwise logic **/
-#define OPENCV_HAL_IMPL_LSX_LOGIC_OP(_Tpvec, suffix)                           \
-  OPENCV_HAL_IMPL_LSX_BIN_OP(v_and, _Tpvec, __lsx_vand_##suffix)               \
-  OPENCV_HAL_IMPL_LSX_BIN_OP(v_or, _Tpvec, __lsx_vor_##suffix)                 \
-  OPENCV_HAL_IMPL_LSX_BIN_OP(v_xor, _Tpvec, __lsx_vxor_##suffix)               \
-  inline _Tpvec v_not(const _Tpvec &a) {                                       \
-    return _Tpvec(__lsx_vnori_b(a.val, 0));                                    \
-  }
-
-OPENCV_HAL_IMPL_LSX_LOGIC_OP(v_uint8x16, v)
-OPENCV_HAL_IMPL_LSX_LOGIC_OP(v_int8x16, v)
-OPENCV_HAL_IMPL_LSX_LOGIC_OP(v_uint16x8, v)
-OPENCV_HAL_IMPL_LSX_LOGIC_OP(v_int16x8, v)
-OPENCV_HAL_IMPL_LSX_LOGIC_OP(v_uint32x4, v)
-OPENCV_HAL_IMPL_LSX_LOGIC_OP(v_int32x4, v)
-OPENCV_HAL_IMPL_LSX_LOGIC_OP(v_uint64x2, v)
-OPENCV_HAL_IMPL_LSX_LOGIC_OP(v_int64x2, v)
-
-#define OPENCV_HAL_IMPL_LSX_FLOAT_BIN_OP(bin_op, _Tpvec, intrin, cast)         \
-  inline _Tpvec bin_op(const _Tpvec &a, const _Tpvec &b) {                     \
-    return _Tpvec(intrin((__m128i)(a.val), (__m128i)(b.val)));                 \
-  }
-
-#define OPENCV_HAL_IMPL_LSX_FLOAT_LOGIC_OP(_Tpvec, cast)                       \
-  OPENCV_HAL_IMPL_LSX_FLOAT_BIN_OP(v_and, _Tpvec, __lsx_vand_v, cast)          \
-  OPENCV_HAL_IMPL_LSX_FLOAT_BIN_OP(v_or, _Tpvec, __lsx_vor_v, cast)            \
-  OPENCV_HAL_IMPL_LSX_FLOAT_BIN_OP(v_xor, _Tpvec, __lsx_vxor_v, cast)          \
-  inline _Tpvec v_not(const _Tpvec &a) {                                       \
-    return _Tpvec(__lsx_vnori_b((__m128i)(a.val), 0));                         \
-  }
-
-OPENCV_HAL_IMPL_LSX_FLOAT_LOGIC_OP(v_float32x4, _lsx_128_castsi128_ps)
-OPENCV_HAL_IMPL_LSX_FLOAT_LOGIC_OP(v_float64x2, _lsx_128_castsi128_pd)
-
-/** Select **/
-#define OPENCV_HAL_IMPL_LSX_SELECT(_Tpvec)                                     \
-  inline _Tpvec v_select(const _Tpvec &mask, const _Tpvec &a,                  \
-                         const _Tpvec &b) {                                    \
-    return _Tpvec(__lsx_vbitsel_v(b.val, a.val, mask.val));                    \
-  }
-
-OPENCV_HAL_IMPL_LSX_SELECT(v_uint8x16)
-OPENCV_HAL_IMPL_LSX_SELECT(v_int8x16)
-OPENCV_HAL_IMPL_LSX_SELECT(v_uint16x8)
-OPENCV_HAL_IMPL_LSX_SELECT(v_int16x8)
-OPENCV_HAL_IMPL_LSX_SELECT(v_uint32x4)
-OPENCV_HAL_IMPL_LSX_SELECT(v_int32x4)
-
-inline v_float32x4 v_select(const v_float32x4 &mask, const v_float32x4 &a,
-                            const v_float32x4 &b) {
-  return v_float32x4(
-      __lsx_vbitsel_v((__m128i)b.val, (__m128i)a.val, (__m128i)mask.val));
-}
-inline v_float64x2 v_select(const v_float64x2 &mask, const v_float64x2 &a,
-                            const v_float64x2 &b) {
-  return v_float64x2(
-      __lsx_vbitsel_v((__m128i)b.val, (__m128i)a.val, (__m128i)mask.val));
-}
-
-/** Comparison **/
-#define OPENCV_HAL_IMPL_LSX_CMP_OP_OV(_Tpvec)                                  \
-  inline _Tpvec v_ne(const _Tpvec &a, const _Tpvec &b) {                       \
-    return v_not(v_eq(a, b));                                                  \
-  }                                                                            \
-  inline _Tpvec v_lt(const _Tpvec &a, const _Tpvec &b) { return v_gt(b, a); }  \
-  inline _Tpvec v_ge(const _Tpvec &a, const _Tpvec &b) {                       \
-    return v_not(v_lt(a, b));                                                  \
-  }                                                                            \
-  inline _Tpvec v_le(const _Tpvec &a, const _Tpvec &b) { return v_ge(b, a); }
-
-#define OPENCV_HAL_IMPL_LSX_CMP_OP_INT(_Tpuvec, _Tpsvec, suffix, usuffix)      \
-  inline _Tpuvec v_eq(const _Tpuvec &a, const _Tpuvec &b) {                    \
-    return _Tpuvec(__lsx_vseq_##suffix(a.val, b.val));                         \
-  }                                                                            \
-  inline _Tpuvec v_gt(const _Tpuvec &a, const _Tpuvec &b) {                    \
-    return _Tpuvec(__lsx_vslt_##usuffix(b.val, a.val));                        \
-  }                                                                            \
-  inline _Tpsvec v_eq(const _Tpsvec &a, const _Tpsvec &b) {                    \
-    return _Tpsvec(__lsx_vseq_##suffix(a.val, b.val));                         \
-  }                                                                            \
-  inline _Tpsvec v_gt(const _Tpsvec &a, const _Tpsvec &b) {                    \
-    return _Tpsvec(__lsx_vslt_##suffix(b.val, a.val));                         \
-  }                                                                            \
-  OPENCV_HAL_IMPL_LSX_CMP_OP_OV(_Tpuvec)                                       \
-  OPENCV_HAL_IMPL_LSX_CMP_OP_OV(_Tpsvec)
-
-OPENCV_HAL_IMPL_LSX_CMP_OP_INT(v_uint8x16, v_int8x16, b, bu)
-OPENCV_HAL_IMPL_LSX_CMP_OP_INT(v_uint16x8, v_int16x8, h, hu)
-OPENCV_HAL_IMPL_LSX_CMP_OP_INT(v_uint32x4, v_int32x4, w, wu)
-
-#define OPENCV_HAL_IMPL_LSX_CMP_OP_64BIT(_Tpvec, suffix)                       \
-  inline _Tpvec v_eq(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(__lsx_vseq_##suffix(a.val, b.val));                          \
-  }                                                                            \
-  inline _Tpvec v_ne(const _Tpvec &a, const _Tpvec &b) {                       \
-    return v_not(v_eq(a, b));                                                  \
-  }
-
-OPENCV_HAL_IMPL_LSX_CMP_OP_64BIT(v_uint64x2, d)
-OPENCV_HAL_IMPL_LSX_CMP_OP_64BIT(v_int64x2, d)
-
-#define OPENCV_HAL_IMPL_LSX_CMP_FLT(bin_op, suffix, _Tpvec, ssuffix)           \
-  inline _Tpvec bin_op(const _Tpvec &a, const _Tpvec &b) {                     \
-    return _Tpvec(__lsx_##suffix##_##ssuffix(a.val, b.val));                   \
-  }
-
-#define OPENCV_HAL_IMPL_LSX_CMP_OP_FLT(_Tpvec, ssuffix)                        \
-  OPENCV_HAL_IMPL_LSX_CMP_FLT(v_eq, vfcmp_ceq, _Tpvec, ssuffix)                \
-  OPENCV_HAL_IMPL_LSX_CMP_FLT(v_ne, vfcmp_cne, _Tpvec, ssuffix)                \
-  OPENCV_HAL_IMPL_LSX_CMP_FLT(v_lt, vfcmp_clt, _Tpvec, ssuffix)                \
-  OPENCV_HAL_IMPL_LSX_CMP_FLT(v_le, vfcmp_cle, _Tpvec, ssuffix)
-
-OPENCV_HAL_IMPL_LSX_CMP_OP_FLT(v_float32x4, s)
-OPENCV_HAL_IMPL_LSX_CMP_OP_FLT(v_float64x2, d)
-
-inline v_float32x4 v_gt(const v_float32x4 &a, const v_float32x4 &b) {
-  return v_float32x4(__lsx_vfcmp_clt_s(b.val, a.val));
-}
-
-inline v_float32x4 v_ge(const v_float32x4 &a, const v_float32x4 &b) {
-  return v_float32x4(__lsx_vfcmp_cle_s(b.val, a.val));
-}
-
-inline v_float64x2 v_gt(const v_float64x2 &a, const v_float64x2 &b) {
-  return v_float64x2(__lsx_vfcmp_clt_d(b.val, a.val));
-}
-
-inline v_float64x2 v_ge(const v_float64x2 &a, const v_float64x2 &b) {
-  return v_float64x2(__lsx_vfcmp_cle_d(b.val, a.val));
-}
-
-inline v_float32x4 v_not_nan(const v_float32x4 &a) {
-  return v_float32x4(__lsx_vfcmp_cor_s(a.val, a.val));
-}
-
-inline v_float64x2 v_not_nan(const v_float64x2 &a) {
-  return v_float64x2(__lsx_vfcmp_cor_d(a.val, a.val));
-}
-
-/** min/max **/
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_min, v_uint8x16, __lsx_vmin_bu)
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_max, v_uint8x16, __lsx_vmax_bu)
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_min, v_int8x16, __lsx_vmin_b)
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_max, v_int8x16, __lsx_vmax_b)
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_min, v_uint16x8, __lsx_vmin_hu)
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_max, v_uint16x8, __lsx_vmax_hu)
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_min, v_int16x8, __lsx_vmin_h)
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_max, v_int16x8, __lsx_vmax_h)
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_min, v_uint32x4, __lsx_vmin_wu)
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_max, v_uint32x4, __lsx_vmax_wu)
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_min, v_int32x4, __lsx_vmin_w)
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_max, v_int32x4, __lsx_vmax_w)
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_min, v_float32x4, __lsx_vfmin_s)
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_max, v_float32x4, __lsx_vfmax_s)
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_min, v_float64x2, __lsx_vfmin_d)
-OPENCV_HAL_IMPL_LSX_BIN_FUNC(v_max, v_float64x2, __lsx_vfmax_d)
-
-template <int imm, bool is_invalid = ((imm < 0) || (imm > 16)),
-          bool is_first = (imm == 0), bool is_half = (imm == 8),
-          bool is_second = (imm == 16),
-          bool is_other =
-              (((imm > 0) && (imm < 8)) || ((imm > 8) && (imm < 16)))>
-class v_lsx_palignr_u8_class;
-
-template <int imm>
-class v_lsx_palignr_u8_class<imm, true, false, false, false, false>;
-
-template <int imm>
-class v_lsx_palignr_u8_class<imm, false, true, false, false, false> {
-public:
-  inline __m128i operator()(const __m128i &a, const __m128i &b) const {
-    CV_UNUSED(b);
-    return a;
-  }
-};
-
-template <int imm>
-class v_lsx_palignr_u8_class<imm, false, false, true, false, false> {
-public:
-  inline __m128i operator()(const __m128i &a, const __m128i &b) const {
-    return __lsx_vshuf4i_d(a, b, 0x9);
-  }
-};
-
-template <int imm>
-class v_lsx_palignr_u8_class<imm, false, false, false, true, false> {
-public:
-  inline __m128i operator()(const __m128i &a, const __m128i &b) const {
-    CV_UNUSED(a);
-    return b;
-  }
-};
-
-template <int imm>
-class v_lsx_palignr_u8_class<imm, false, false, false, false, true> {
-public:
-  inline __m128i operator()(const __m128i &a, const __m128i &b) const {
-    enum { imm2 = (sizeof(__m128i) - imm) };
-    return __lsx_vor_v(__lsx_vbsrl_v(a, imm), __lsx_vbsll_v(b, imm2));
-  }
-};
-
-template <int imm>
-inline __m128i v_lsx_palignr_u8(const __m128i &a, const __m128i &b) {
-  CV_StaticAssert((imm >= 0) && (imm <= 16),
-                  "Invalid imm for v_lsx_palignr_u8");
-  return v_lsx_palignr_u8_class<imm>()(a, b);
-}
-/** Rotate **/
-#define OPENCV_HAL_IMPL_LSX_ROTATE_CAST(_Tpvec, cast)                          \
-  template <int imm> inline _Tpvec v_rotate_right(const _Tpvec &a) {           \
-    enum { imm2 = (imm * sizeof(typename _Tpvec::lane_type)) };                \
-    __m128i ret = __lsx_vbsrl_v((__m128i)a.val, imm2);                         \
-    return _Tpvec(cast(ret));                                                  \
-  }                                                                            \
-  template <int imm> inline _Tpvec v_rotate_left(const _Tpvec &a) {            \
-    enum { imm2 = (imm * sizeof(typename _Tpvec::lane_type)) };                \
-    __m128i ret = __lsx_vbsll_v((__m128i)a.val, imm2);                         \
-    return _Tpvec(cast(ret));                                                  \
-  }                                                                            \
-  template <int imm>                                                           \
-  inline _Tpvec v_rotate_right(const _Tpvec &a, const _Tpvec &b) {             \
-    enum { imm2 = (imm * sizeof(typename _Tpvec::lane_type)) };                \
-    return _Tpvec(                                                             \
-        cast(v_lsx_palignr_u8<imm2>((__m128i)a.val, (__m128i)b.val)));         \
-  }                                                                            \
-  template <int imm>                                                           \
-  inline _Tpvec v_rotate_left(const _Tpvec &a, const _Tpvec &b) {              \
-    enum {                                                                     \
-      imm2 = ((_Tpvec::nlanes - imm) * sizeof(typename _Tpvec::lane_type))     \
-    };                                                                         \
-    return _Tpvec(                                                             \
-        cast(v_lsx_palignr_u8<imm2>((__m128i)b.val, (__m128i)a.val)));         \
-  }
-
-OPENCV_HAL_IMPL_LSX_ROTATE_CAST(v_uint8x16, OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_LSX_ROTATE_CAST(v_int8x16, OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_LSX_ROTATE_CAST(v_uint16x8, OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_LSX_ROTATE_CAST(v_int16x8, OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_LSX_ROTATE_CAST(v_uint32x4, OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_LSX_ROTATE_CAST(v_int32x4, OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_LSX_ROTATE_CAST(v_uint64x2, OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_LSX_ROTATE_CAST(v_int64x2, OPENCV_HAL_NOP)
-
-OPENCV_HAL_IMPL_LSX_ROTATE_CAST(v_float32x4, _lsx_128_castsi128_ps)
-OPENCV_HAL_IMPL_LSX_ROTATE_CAST(v_float64x2, _lsx_128_castsi128_pd)
-
-/** Rverse **/
-inline v_uint8x16 v_reverse(const v_uint8x16 &a) {
-  __m128i vec = __lsx_vshuf4i_b(a.val, 0x1B);
-  return v_uint8x16(__lsx_vshuf4i_w(vec, 0x1B));
-}
-
-inline v_int8x16 v_reverse(const v_int8x16 &a) {
-  return v_reinterpret_as_s8(v_reverse(v_reinterpret_as_u8(a)));
-}
-
-inline v_uint16x8 v_reverse(const v_uint16x8 &a) {
-  __m128i vec = __lsx_vshuf4i_h(a.val, 0x1B);
-  return v_uint16x8(__lsx_vshuf4i_w(vec, 0x4E));
-}
-
-inline v_int16x8 v_reverse(const v_int16x8 &a) {
-  return v_reinterpret_as_s16(v_reverse(v_reinterpret_as_u16(a)));
-}
-
-inline v_uint32x4 v_reverse(const v_uint32x4 &a) {
-  return v_uint32x4(__lsx_vshuf4i_w(a.val, 0x1B));
-}
-
-inline v_int32x4 v_reverse(const v_int32x4 &a) {
-  return v_int32x4(__lsx_vshuf4i_w(a.val, 0x1B));
-}
-
-inline v_uint64x2 v_reverse(const v_uint64x2 &a) {
-  return v_uint64x2(__lsx_vshuf4i_w(a.val, 0x4E));
-}
-
-inline v_int64x2 v_reverse(const v_int64x2 &a) {
-  return v_int64x2(__lsx_vshuf4i_w(a.val, 0x4E));
-}
-
-inline v_float32x4 v_reverse(const v_float32x4 &a) {
-  return v_reinterpret_as_f32(v_reverse(v_reinterpret_as_u32(a)));
-}
-
-inline v_float64x2 v_reverse(const v_float64x2 &a) {
-  return v_reinterpret_as_f64(v_reverse(v_reinterpret_as_u64(a)));
-}
-
-////////////// Reduce and mask ////////////
-
-/** Reduce **/
-// this function is return a[0]+a[1]+...+a[31]
-inline unsigned v_reduce_sum(const v_uint8x16 &a) {
-  __m128i t1 = __lsx_vhaddw_hu_bu(a.val, a.val);
-  __m128i t2 = __lsx_vhaddw_wu_hu(t1, t1);
-  __m128i t3 = __lsx_vhaddw_du_wu(t2, t2);
-  __m128i t4 = __lsx_vhaddw_qu_du(t3, t3);
-  return (unsigned)__lsx_vpickve2gr_w(t4, 0);
-}
-
-inline int v_reduce_sum(const v_int8x16 &a) {
-  __m128i t1 = __lsx_vhaddw_h_b(a.val, a.val);
-  __m128i t2 = __lsx_vhaddw_w_h(t1, t1);
-  __m128i t3 = __lsx_vhaddw_d_w(t2, t2);
-  __m128i t4 = __lsx_vhaddw_q_d(t3, t3);
-  return (int)__lsx_vpickve2gr_w(t4, 0);
-}
-
-#define OPENCV_HAL_IMPL_LSX_REDUCE_16(_Tpvec, sctype, func, intrin)            \
-  inline sctype v_reduce_##func(const _Tpvec &a) {                             \
-    __m128i val = intrin(a.val, __lsx_vbsrl_v(a.val, 8));                      \
-    val = intrin(val, __lsx_vbsrl_v(val, 4));                                  \
-    val = intrin(val, __lsx_vbsrl_v(val, 2));                                  \
-    val = intrin(val, __lsx_vbsrl_v(val, 1));                                  \
-    return (sctype)__lsx_vpickve2gr_b(val, 0);                                 \
-  }
-
-OPENCV_HAL_IMPL_LSX_REDUCE_16(v_uint8x16, uchar, min, __lsx_vmin_bu)
-OPENCV_HAL_IMPL_LSX_REDUCE_16(v_uint8x16, uchar, max, __lsx_vmax_bu)
-OPENCV_HAL_IMPL_LSX_REDUCE_16(v_int8x16, schar, min, __lsx_vmin_b)
-OPENCV_HAL_IMPL_LSX_REDUCE_16(v_int8x16, schar, max, __lsx_vmax_b)
-
-#define OPENCV_HAL_IMPL_LSX_REDUCE_8(_Tpvec, sctype, func, intrin)             \
-  inline sctype v_reduce_##func(const _Tpvec &a) {                             \
-    __m128i val = intrin(a.val, __lsx_vbsrl_v(a.val, 8));                      \
-    val = intrin(val, __lsx_vbsrl_v(val, 4));                                  \
-    val = intrin(val, __lsx_vbsrl_v(val, 2));                                  \
-    return (sctype)__lsx_vpickve2gr_h(val, 0);                                 \
-  }
-
-OPENCV_HAL_IMPL_LSX_REDUCE_8(v_uint16x8, ushort, min, __lsx_vmin_hu)
-OPENCV_HAL_IMPL_LSX_REDUCE_8(v_uint16x8, ushort, max, __lsx_vmax_hu)
-OPENCV_HAL_IMPL_LSX_REDUCE_8(v_int16x8, short, min, __lsx_vmin_h)
-OPENCV_HAL_IMPL_LSX_REDUCE_8(v_int16x8, short, max, __lsx_vmax_h)
-
-#define OPENCV_HAL_IMPL_LSX_REDUCE_4(_Tpvec, sctype, func, intrin)             \
-  inline sctype v_reduce_##func(const _Tpvec &a) {                             \
-    __m128i val = intrin(a.val, __lsx_vbsrl_v(a.val, 8));                      \
-    val = intrin(val, __lsx_vbsrl_v(val, 4));                                  \
-    return (sctype)__lsx_vpickve2gr_w(val, 0);                                 \
-  }
-
-OPENCV_HAL_IMPL_LSX_REDUCE_4(v_uint32x4, unsigned, min, __lsx_vmin_wu)
-OPENCV_HAL_IMPL_LSX_REDUCE_4(v_uint32x4, unsigned, max, __lsx_vmax_wu)
-OPENCV_HAL_IMPL_LSX_REDUCE_4(v_int32x4, int, min, __lsx_vmin_w)
-OPENCV_HAL_IMPL_LSX_REDUCE_4(v_int32x4, int, max, __lsx_vmax_w)
-
-#define OPENCV_HAL_IMPL_LSX_REDUCE_FLT(func, intrin)                           \
-  inline float v_reduce_##func(const v_float32x4 &a) {                         \
-    __m128 val = a.val;                                                        \
-    val = intrin(val, (__m128)__lsx_vbsrl_v((__m128i)val, 8));                 \
-    val = intrin(val, (__m128)__lsx_vbsrl_v((__m128i)val, 4));                 \
-    float *fval = (float *)&val;                                               \
-    return fval[0];                                                            \
-  }
-
-OPENCV_HAL_IMPL_LSX_REDUCE_FLT(min, __lsx_vfmin_s)
-OPENCV_HAL_IMPL_LSX_REDUCE_FLT(max, __lsx_vfmax_s)
-
-inline int v_reduce_sum(const v_int32x4 &a) {
-  __m128i t1 = __lsx_vhaddw_d_w(a.val, a.val);
-  __m128i t2 = __lsx_vhaddw_q_d(t1, t1);
-  return (int)__lsx_vpickve2gr_w(t2, 0);
-}
-
-inline unsigned v_reduce_sum(const v_uint32x4 &a) {
-  __m128i t1 = __lsx_vhaddw_du_wu(a.val, a.val);
-  __m128i t2 = __lsx_vhaddw_qu_du(t1, t1);
-  return (int)__lsx_vpickve2gr_w(t2, 0);
-}
-
-inline int v_reduce_sum(const v_int16x8 &a) {
-  __m128i t1 = __lsx_vhaddw_w_h(a.val, a.val);
-  __m128i t2 = __lsx_vhaddw_d_w(t1, t1);
-  __m128i t3 = __lsx_vhaddw_q_d(t2, t2);
-  return (int)__lsx_vpickve2gr_w(t3, 0);
-}
-
-inline unsigned v_reduce_sum(const v_uint16x8 &a) {
-  __m128i t1 = __lsx_vhaddw_wu_hu(a.val, a.val);
-  __m128i t2 = __lsx_vhaddw_du_wu(t1, t1);
-  __m128i t3 = __lsx_vhaddw_qu_du(t2, t2);
-  return (int)__lsx_vpickve2gr_w(t3, 0);
-}
-
-inline float v_reduce_sum(const v_float32x4 &a) {
-  __m128i val = (__m128i)a.val;
-  val = __lsx_vbsrl_v(val, 8);
-  __m128 result = __lsx_vfadd_s(a.val, (__m128)val);
-  float *pa = (float *)&result;
-  return (float)(pa[0] + pa[1]);
-}
-
-inline uint64 v_reduce_sum(const v_uint64x2 &a) {
-  __m128i t0 = __lsx_vhaddw_qu_du(a.val, a.val);
-  return (uint64)__lsx_vpickve2gr_du(t0, 0);
-}
-
-inline int64 v_reduce_sum(const v_int64x2 &a) {
-  __m128i t0 = __lsx_vhaddw_q_d(a.val, a.val);
-  return (int64)__lsx_vpickve2gr_d(t0, 0);
-}
-
-inline double v_reduce_sum(const v_float64x2 &a) {
-  double *pa = (double *)&a;
-  return pa[0] + pa[1];
-}
-
-inline v_float32x4 v_reduce_sum4(const v_float32x4 &a, const v_float32x4 &b,
-                                 const v_float32x4 &c, const v_float32x4 &d) {
-  __m128i a0 = (__m128i)a.val;
-  __m128i b0 = (__m128i)b.val;
-  __m128i c0 = (__m128i)c.val;
-  __m128i d0 = (__m128i)d.val;
-  __m128i ac_l = __lsx_vilvl_w(c0, a0);
-  __m128i ac_h = __lsx_vilvh_w(c0, a0);
-  __m128i bd_l = __lsx_vilvl_w(d0, b0);
-  __m128i bd_h = __lsx_vilvh_w(d0, b0);
-  __m128 ac = __lsx_vfadd_s((__m128)ac_l, (__m128)ac_h);
-  __m128 bd = __lsx_vfadd_s((__m128)bd_l, (__m128)bd_h);
-  return v_float32x4(
-      __lsx_vfadd_s((__m128)__lsx_vilvl_w((__m128i)bd, (__m128i)ac),
-                    (__m128)__lsx_vilvh_w((__m128i)bd, (__m128i)ac)));
-}
-
-inline unsigned v_reduce_sad(const v_int8x16 &a, const v_int8x16 &b) {
-  __m128i t0 = __lsx_vabsd_b(a.val, b.val);
-  __m128i t1 = __lsx_vhaddw_hu_bu(t0, t0);
-  __m128i t2 = __lsx_vhaddw_wu_hu(t1, t1);
-  __m128i t3 = __lsx_vhaddw_du_wu(t2, t2);
-  __m128i t4 = __lsx_vhaddw_qu_du(t3, t3);
-  return (unsigned)__lsx_vpickve2gr_w(t4, 0);
-}
-
-inline unsigned v_reduce_sad(const v_uint8x16 &a, const v_uint8x16 &b) {
-  __m128i t0 = __lsx_vabsd_bu(a.val, b.val);
-  __m128i t1 = __lsx_vhaddw_hu_bu(t0, t0);
-  __m128i t2 = __lsx_vhaddw_wu_hu(t1, t1);
-  __m128i t3 = __lsx_vhaddw_du_wu(t2, t2);
-  __m128i t4 = __lsx_vhaddw_qu_du(t3, t3);
-  return (unsigned)__lsx_vpickve2gr_w(t4, 0);
-}
-
-inline unsigned v_reduce_sad(const v_uint16x8 &a, const v_uint16x8 &b) {
-  __m128i t0 = __lsx_vabsd_hu(a.val, b.val);
-  __m128i t1 = __lsx_vhaddw_wu_hu(t0, t0);
-  __m128i t2 = __lsx_vhaddw_du_wu(t1, t1);
-  __m128i t3 = __lsx_vhaddw_qu_du(t2, t2);
-  return (unsigned)__lsx_vpickve2gr_w(t3, 0);
-}
-
-inline unsigned v_reduce_sad(const v_int16x8 &a, const v_int16x8 &b) {
-  __m128i t0 = __lsx_vabsd_h(a.val, b.val);
-  __m128i t1 = __lsx_vhaddw_wu_hu(t0, t0);
-  __m128i t2 = __lsx_vhaddw_du_wu(t1, t1);
-  __m128i t3 = __lsx_vhaddw_qu_du(t2, t2);
-  return (unsigned)__lsx_vpickve2gr_w(t3, 0);
-}
-
-inline unsigned v_reduce_sad(const v_uint32x4 &a, const v_uint32x4 &b) {
-  __m128i t0 = __lsx_vabsd_wu(a.val, b.val);
-  __m128i t1 = __lsx_vhaddw_du_wu(t0, t0);
-  __m128i t2 = __lsx_vhaddw_qu_du(t1, t1);
-  return (unsigned)__lsx_vpickve2gr_w(t2, 0);
-}
-
-inline unsigned v_reduce_sad(const v_int32x4 &a, const v_int32x4 &b) {
-  __m128i t0 = __lsx_vabsd_w(a.val, b.val);
-  __m128i t1 = __lsx_vhaddw_du_wu(t0, t0);
-  __m128i t2 = __lsx_vhaddw_qu_du(t1, t1);
-  return (unsigned)__lsx_vpickve2gr_w(t2, 0);
-}
-
-inline float v_reduce_sad(const v_float32x4 &a, const v_float32x4 &b) {
-  v_float32x4 a_b = v_sub(a, b);
-  return v_reduce_sum(
-      v_float32x4((__m128i)a_b.val & __lsx_vreplgr2vr_w(0x7fffffff)));
-}
-
-/** Popcount **/
-#define OPENCV_HAL_IMPL_LSX_POPCOUNT(_Tpvec, _Tp, suffix)                      \
-  inline _Tpvec v_popcount(const _Tp &a) {                                     \
-    return _Tpvec(__lsx_vpcnt_##suffix(a.val));                                \
-  }
-
-OPENCV_HAL_IMPL_LSX_POPCOUNT(v_uint8x16, v_uint8x16, b);
-OPENCV_HAL_IMPL_LSX_POPCOUNT(v_uint8x16, v_int8x16, b);
-OPENCV_HAL_IMPL_LSX_POPCOUNT(v_uint16x8, v_uint16x8, h);
-OPENCV_HAL_IMPL_LSX_POPCOUNT(v_uint16x8, v_int16x8, h);
-OPENCV_HAL_IMPL_LSX_POPCOUNT(v_uint32x4, v_uint32x4, w);
-OPENCV_HAL_IMPL_LSX_POPCOUNT(v_uint32x4, v_int32x4, w);
-OPENCV_HAL_IMPL_LSX_POPCOUNT(v_uint64x2, v_uint64x2, d);
-OPENCV_HAL_IMPL_LSX_POPCOUNT(v_uint64x2, v_int64x2, d);
-
-/** Mask **/
-#define OPENCV_HAL_IMPL_REINTERPRET_INT(ft, tt)                                \
-  inline tt reinterpret_int(ft x) {                                            \
-    union {                                                                    \
-      ft l;                                                                    \
-      tt i;                                                                    \
-    } v;                                                                       \
-    v.l = x;                                                                   \
-    return v.i;                                                                \
-  }
-OPENCV_HAL_IMPL_REINTERPRET_INT(uchar, schar)
-OPENCV_HAL_IMPL_REINTERPRET_INT(schar, schar)
-OPENCV_HAL_IMPL_REINTERPRET_INT(ushort, short)
-OPENCV_HAL_IMPL_REINTERPRET_INT(short, short)
-OPENCV_HAL_IMPL_REINTERPRET_INT(unsigned, int)
-OPENCV_HAL_IMPL_REINTERPRET_INT(int, int)
-OPENCV_HAL_IMPL_REINTERPRET_INT(float, int)
-OPENCV_HAL_IMPL_REINTERPRET_INT(uint64, int64)
-OPENCV_HAL_IMPL_REINTERPRET_INT(int64, int64)
-OPENCV_HAL_IMPL_REINTERPRET_INT(double, int64)
-
-inline int v_signmask(const v_int8x16 &a) {
-  __m128i result = __lsx_vmskltz_b(a.val);
-  return __lsx_vpickve2gr_w(result, 0);
-}
-inline int v_signmask(const v_uint8x16 &a) {
-  return v_signmask(v_reinterpret_as_s8(a));
-}
-
-inline int v_signmask(const v_int16x8 &a) {
-  __m128i result = __lsx_vmskltz_h(a.val);
-  return __lsx_vpickve2gr_w(result, 0);
-}
-inline int v_signmask(const v_uint16x8 &a) {
-  return v_signmask(v_reinterpret_as_s16(a));
-}
-
-inline int v_signmask(const v_uint32x4 &a) {
-  __m128i result = __lsx_vmskltz_w(a.val);
-  return __lsx_vpickve2gr_w(result, 0);
-}
-inline int v_signmask(const v_int32x4 &a) {
-  return v_signmask(v_reinterpret_as_u32(a));
-}
-
-inline int v_signmask(const v_uint64x2 &a) {
-  __m128i result = __lsx_vmskltz_d(a.val);
-  return __lsx_vpickve2gr_w(result, 0);
-}
-inline int v_signmask(const v_int64x2 &a) {
-  return v_signmask(v_reinterpret_as_u64(a));
-}
-
-inline int v_signmask(const v_float32x4 &a) {
-  return v_signmask(*(v_int32x4 *)(&a));
-}
-
-inline int v_signmask(const v_float64x2 &a) {
-  return v_signmask(*(v_int64x2 *)(&a));
-}
-
-inline int v_scan_forward(const v_int8x16 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a)));
-}
-inline int v_scan_forward(const v_uint8x16 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a)));
-}
-inline int v_scan_forward(const v_int16x8 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 2;
-}
-inline int v_scan_forward(const v_uint16x8 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 2;
-}
-inline int v_scan_forward(const v_int32x4 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 4;
-}
-inline int v_scan_forward(const v_uint32x4 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 4;
-}
-inline int v_scan_forward(const v_float32x4 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 4;
-}
-inline int v_scan_forward(const v_int64x2 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 8;
-}
-inline int v_scan_forward(const v_uint64x2 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 8;
-}
-inline int v_scan_forward(const v_float64x2 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 8;
-}
-
-/** Checks **/
-#define OPENCV_HAL_IMPL_LSX_CHECK(_Tpvec, allmask)                             \
-  inline bool v_check_all(const _Tpvec &a) {                                   \
-    return v_signmask(a) == allmask;                                           \
-  }                                                                            \
-  inline bool v_check_any(const _Tpvec &a) { return v_signmask(a) != 0; }
-OPENCV_HAL_IMPL_LSX_CHECK(v_uint8x16, 65535)
-OPENCV_HAL_IMPL_LSX_CHECK(v_int8x16, 65535)
-OPENCV_HAL_IMPL_LSX_CHECK(v_uint16x8, 255);
-OPENCV_HAL_IMPL_LSX_CHECK(v_int16x8, 255);
-OPENCV_HAL_IMPL_LSX_CHECK(v_uint32x4, 15)
-OPENCV_HAL_IMPL_LSX_CHECK(v_int32x4, 15)
-OPENCV_HAL_IMPL_LSX_CHECK(v_uint64x2, 3)
-OPENCV_HAL_IMPL_LSX_CHECK(v_int64x2, 3)
-OPENCV_HAL_IMPL_LSX_CHECK(v_float32x4, 15)
-OPENCV_HAL_IMPL_LSX_CHECK(v_float64x2, 3)
-
-///////////// Other math /////////////
-
-/** Some frequent operations **/
-#define OPENCV_HAL_IMPL_LSX_MULADD(_Tpvec, suffix)                             \
-  inline _Tpvec v_fma(const _Tpvec &a, const _Tpvec &b, const _Tpvec &c) {     \
-    return _Tpvec(__lsx_vfmadd_##suffix(a.val, b.val, c.val));                 \
-  }                                                                            \
-  inline _Tpvec v_muladd(const _Tpvec &a, const _Tpvec &b, const _Tpvec &c) {  \
-    return _Tpvec(__lsx_vfmadd_##suffix(a.val, b.val, c.val));                 \
-  }                                                                            \
-  inline _Tpvec v_sqrt(const _Tpvec &x) {                                      \
-    return _Tpvec(__lsx_vfsqrt_##suffix(x.val));                               \
-  }                                                                            \
-  inline _Tpvec v_sqr_magnitude(const _Tpvec &a, const _Tpvec &b) {            \
-    return v_fma(a, a, v_mul(b, b));                                           \
-  }                                                                            \
-  inline _Tpvec v_magnitude(const _Tpvec &a, const _Tpvec &b) {                \
-    return v_sqrt(v_fma(a, a, v_mul(b, b)));                                   \
-  }
-
-OPENCV_HAL_IMPL_LSX_MULADD(v_float32x4, s)
-OPENCV_HAL_IMPL_LSX_MULADD(v_float64x2, d)
-
-inline v_int32x4 v_fma(const v_int32x4 &a, const v_int32x4 &b,
-                       const v_int32x4 &c) {
-  return v_int32x4(__lsx_vmadd_w(c.val, a.val, b.val));
-}
-
-inline v_int32x4 v_muladd(const v_int32x4 &a, const v_int32x4 &b,
-                          const v_int32x4 &c) {
-  return v_fma(a, b, c);
-}
-
-inline v_float32x4 v_invsqrt(const v_float32x4 &x) {
-  return v_float32x4(__lsx_vfrsqrt_s(x.val));
-}
-
-inline v_float64x2 v_invsqrt(const v_float64x2 &x) {
-  return v_float64x2(__lsx_vfrsqrt_d(x.val));
-}
-
-/** Absolute values **/
-#define OPENCV_HAL_IMPL_LSX_ABS(_Tpvec, suffix)                                \
-  inline v_u##_Tpvec v_abs(const v_##_Tpvec &x) {                              \
-    return v_u##_Tpvec(__lsx_vabsd_##suffix(x.val, __lsx_vldi(0)));            \
-  }
-
-OPENCV_HAL_IMPL_LSX_ABS(int8x16, b)
-OPENCV_HAL_IMPL_LSX_ABS(int16x8, h)
-OPENCV_HAL_IMPL_LSX_ABS(int32x4, w)
-
-inline v_float32x4 v_abs(const v_float32x4 &x) {
-  return v_float32x4(*((__m128i *)&x) & __lsx_vreplgr2vr_w(0x7fffffff));
-}
-inline v_float64x2 v_abs(const v_float64x2 &x) {
-  return v_float64x2(*((__m128i *)&x) & __lsx_vreplgr2vr_d(0x7fffffffffffffff));
-}
-
-/** Absolute difference **/
-
-inline v_uint8x16 v_absdiff(const v_uint8x16 &a, const v_uint8x16 &b) {
-  return (v_uint8x16)__lsx_vabsd_bu(a.val, b.val);
-}
-inline v_uint16x8 v_absdiff(const v_uint16x8 &a, const v_uint16x8 &b) {
-  return (v_uint16x8)__lsx_vabsd_hu(a.val, b.val);
-}
-inline v_uint32x4 v_absdiff(const v_uint32x4 &a, const v_uint32x4 &b) {
-  return (v_uint32x4)__lsx_vabsd_wu(a.val, b.val);
-}
-
-inline v_uint8x16 v_absdiff(const v_int8x16 &a, const v_int8x16 &b) {
-  return (v_uint8x16)__lsx_vabsd_b(a.val, b.val);
-}
-inline v_uint16x8 v_absdiff(const v_int16x8 &a, const v_int16x8 &b) {
-  return (v_uint16x8)__lsx_vabsd_h(a.val, b.val);
-}
-inline v_uint32x4 v_absdiff(const v_int32x4 &a, const v_int32x4 &b) {
-  return (v_uint32x4)__lsx_vabsd_w(a.val, b.val);
-}
-
-inline v_float32x4 v_absdiff(const v_float32x4 &a, const v_float32x4 &b) {
-  return v_abs(v_sub(a, b));
-}
-
-inline v_float64x2 v_absdiff(const v_float64x2 &a, const v_float64x2 &b) {
-  return v_abs(v_sub(a, b));
-}
-
-/** Saturating absolute difference **/
-inline v_int8x16 v_absdiffs(const v_int8x16 &a, const v_int8x16 &b) {
-  v_int8x16 d = v_sub(a, b);
-  v_int8x16 m = v_lt(a, b);
-  return v_sub(v_xor(d, m), m);
-}
-inline v_int16x8 v_absdiffs(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_sub(v_max(a, b), v_min(a, b));
-}
-
-///////// Conversions /////////
-
-/** Rounding **/
-inline v_int32x4 v_round(const v_float32x4 &a) {
-  return v_int32x4(__lsx_vftint_w_s(a.val));
-}
-
-inline v_int32x4 v_round(const v_float64x2 &a) {
-  return v_int32x4(__lsx_vftint_w_d(a.val, a.val));
-}
-
-inline v_int32x4 v_round(const v_float64x2 &a, const v_float64x2 &b) {
-  return v_int32x4(__lsx_vftint_w_d(b.val, a.val));
-}
-
-inline v_int32x4 v_trunc(const v_float32x4 &a) {
-  return v_int32x4(__lsx_vftintrz_w_s(a.val));
-}
-
-inline v_int32x4 v_trunc(const v_float64x2 &a) {
-  return v_int32x4(__lsx_vftintrz_w_d(a.val, a.val));
-}
-
-inline v_int32x4 v_floor(const v_float32x4 &a) {
-  return v_int32x4(__lsx_vftintrz_w_s(__m128(__lsx_vfrintrm_s(a.val))));
-}
-
-inline v_int32x4 v_floor(const v_float64x2 &a) {
-  return v_trunc(v_float64x2(__lsx_vfrintrm_d(a.val)));
-}
-
-inline v_int32x4 v_ceil(const v_float32x4 &a) {
-  return v_int32x4(__lsx_vftintrz_w_s(__m128(__lsx_vfrintrp_s(a.val))));
-}
-
-inline v_int32x4 v_ceil(const v_float64x2 &a) {
-  return v_trunc(v_float64x2(__lsx_vfrintrp_d(a.val)));
-}
-
-/** To float **/
-inline v_float32x4 v_cvt_f32(const v_int32x4 &a) {
-  return v_float32x4(__lsx_vffint_s_w(a.val));
-}
-
-inline v_float32x4 v_cvt_f32(const v_float64x2 &a) {
-  return v_float32x4(__lsx_vfcvt_s_d(a.val, a.val));
-}
-
-inline v_float32x4 v_cvt_f32(const v_float64x2 &a, const v_float64x2 &b) {
-  return v_float32x4(__lsx_vfcvt_s_d(b.val, a.val));
-}
-
-inline v_float64x2 v_cvt_f64(const v_int32x4 &a) {
-  return v_float64x2(__lsx_vffintl_d_w(a.val));
-}
-
-inline v_float64x2 v_cvt_f64_high(const v_int32x4 &a) {
-  return v_float64x2(__lsx_vffinth_d_w(a.val));
-}
-
-inline v_float64x2 v_cvt_f64(const v_float32x4 &a) {
-  return v_float64x2(__lsx_vfcvtl_d_s(a.val));
-}
-
-inline v_float64x2 v_cvt_f64_high(const v_float32x4 &a) {
-  return v_float64x2(__lsx_vfcvth_d_s(a.val));
-}
-
-inline v_float64x2 v_cvt_f64(const v_int64x2 &v) {
-  return v_float64x2(__lsx_vffint_d_l(v.val));
-}
-
-//////////////// Lookup table access ////////////////
-inline v_int8x16 v_lut(const schar *tab, const int *idx) {
-  return v_int8x16(
-      _v128_setr_b(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]],
-                   tab[idx[4]], tab[idx[5]], tab[idx[6]], tab[idx[7]],
-                   tab[idx[8]], tab[idx[9]], tab[idx[10]], tab[idx[11]],
-                   tab[idx[12]], tab[idx[13]], tab[idx[14]], tab[idx[15]]));
-}
-
-inline v_int8x16 v_lut_pairs(const schar *tab, const int *idx) {
-  return v_int8x16(_v128_setr_h(
-      *(const short *)(tab + idx[0]), *(const short *)(tab + idx[1]),
-      *(const short *)(tab + idx[2]), *(const short *)(tab + idx[3]),
-      *(const short *)(tab + idx[4]), *(const short *)(tab + idx[5]),
-      *(const short *)(tab + idx[6]), *(const short *)(tab + idx[7])));
-}
-
-inline v_int8x16 v_lut_quads(const schar *tab, const int *idx) {
-  return v_int8x16(
-      _v128_setr_w(*(const int *)(tab + idx[0]), *(const int *)(tab + idx[1]),
-                   *(const int *)(tab + idx[2]), *(const int *)(tab + idx[3])));
-}
-
-inline v_uint8x16 v_lut(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v_lut((const schar *)tab, idx));
-}
-inline v_uint8x16 v_lut_pairs(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v_lut_pairs((const schar *)tab, idx));
-}
-inline v_uint8x16 v_lut_quads(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v_lut_quads((const schar *)tab, idx));
-}
-
-inline v_int16x8 v_lut(const short *tab, const int *idx) {
-  return v_int16x8(_v128_setr_h(tab[idx[0]], tab[idx[1]], tab[idx[2]],
-                                tab[idx[3]], tab[idx[4]], tab[idx[5]],
-                                tab[idx[6]], tab[idx[7]]));
-}
-inline v_int16x8 v_lut_pairs(const short *tab, const int *idx) {
-  return v_int16x8(
-      _v128_setr_w(*(const int *)(tab + idx[0]), *(const int *)(tab + idx[1]),
-                   *(const int *)(tab + idx[2]), *(const int *)(tab + idx[3])));
-}
-inline v_int16x8 v_lut_quads(const short *tab, const int *idx) {
-  return v_int16x8(_v128_setr_d(*(const int64_t *)(tab + idx[0]),
-                                *(const int64_t *)(tab + idx[1])));
-}
-
-inline v_uint16x8 v_lut(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v_lut((const short *)tab, idx));
-}
-inline v_uint16x8 v_lut_pairs(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v_lut_pairs((const short *)tab, idx));
-}
-inline v_uint16x8 v_lut_quads(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v_lut_quads((const short *)tab, idx));
-}
-
-inline v_int32x4 v_lut(const int *tab, const int *idx) {
-  return v_int32x4(
-      _v128_setr_w(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]));
-}
-inline v_int32x4 v_lut_pairs(const int *tab, const int *idx) {
-  return v_int32x4(_v128_setr_d(*(const int64_t *)(tab + idx[0]),
-                                *(const int64_t *)(tab + idx[1])));
-}
-inline v_int32x4 v_lut_quads(const int *tab, const int *idx) {
-  return v_int32x4(__lsx_vld(tab + idx[0], 0));
-}
-
-inline v_uint32x4 v_lut(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v_lut((const int *)tab, idx));
-}
-inline v_uint32x4 v_lut_pairs(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v_lut_pairs((const int *)tab, idx));
-}
-inline v_uint32x4 v_lut_quads(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v_lut_quads((const int *)tab, idx));
-}
-
-inline v_int64x2 v_lut(const int64_t *tab, const int *idx) {
-  return v_int64x2(_v128_setr_d(tab[idx[0]], tab[idx[1]]));
-}
-inline v_int64x2 v_lut_pairs(const int64_t *tab, const int *idx) {
-  return v_int64x2(__lsx_vld(tab + idx[0], 0));
-}
-
-inline v_uint64x2 v_lut(const uint64_t *tab, const int *idx) {
-  return v_reinterpret_as_u64(v_lut((const int64_t *)tab, idx));
-}
-inline v_uint64x2 v_lut_pairs(const uint64_t *tab, const int *idx) {
-  return v_reinterpret_as_u64(v_lut_pairs((const int64_t *)tab, idx));
-}
-
-inline v_float32x4 v_lut(const float *tab, const int *idx) {
-  return v_float32x4(
-      _v128_setr_ps(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]));
-}
-inline v_float32x4 v_lut_pairs(const float *tab, const int *idx) {
-  return v_float32x4((__m128)_v128_setr_pd(*(const double *)(tab + idx[0]),
-                                           *(const double *)(tab + idx[1])));
-}
-inline v_float32x4 v_lut_quads(const float *tab, const int *idx) {
-  return v_float32x4((__m128)__lsx_vld(tab + idx[0], 0));
-}
-
-inline v_float64x2 v_lut(const double *tab, const int *idx) {
-  return v_float64x2(_v128_setr_pd(tab[idx[0]], tab[idx[1]]));
-}
-inline v_float64x2 v_lut_pairs(const double *tab, const int *idx) {
-  return v_float64x2((__m128d)__lsx_vld(tab + idx[0], 0));
-}
-
-inline v_int32x4 v_lut(const int *tab, const v_int32x4 &idxvec) {
-  int *idx = (int *)&idxvec.val;
-  return v_lut(tab, idx);
-}
-
-inline v_uint32x4 v_lut(const unsigned *tab, const v_int32x4 &idxvec) {
-  return v_reinterpret_as_u32(v_lut((const int *)tab, idxvec));
-}
-
-inline v_float32x4 v_lut(const float *tab, const v_int32x4 &idxvec) {
-  const int *idx = (const int *)&idxvec.val;
-  return v_lut(tab, idx);
-}
-
-inline v_float64x2 v_lut(const double *tab, const v_int32x4 &idxvec) {
-  const int *idx = (const int *)&idxvec.val;
-  return v_lut(tab, idx);
-}
-
-inline void v_lut_deinterleave(const float *tab, const v_int32x4 &idxvec,
-                               v_float32x4 &x, v_float32x4 &y) {
-  const int *idx = (const int *)&idxvec.val;
-  __m128i xy0 = __lsx_vld(tab + idx[0], 0);
-  __m128i xy1 = __lsx_vld(tab + idx[1], 0);
-  __m128i xy2 = __lsx_vld(tab + idx[2], 0);
-  __m128i xy3 = __lsx_vld(tab + idx[3], 0);
-  __m128i xy01 = __lsx_vilvl_d(xy1, xy0);
-  __m128i xy23 = __lsx_vilvl_d(xy3, xy2);
-  __m128i xxyy02 = __lsx_vilvl_w(xy23, xy01);
-  __m128i xxyy13 = __lsx_vilvh_w(xy23, xy01);
-  x = v_float32x4((__m128)__lsx_vilvl_w(xxyy13, xxyy02));
-  y = v_float32x4((__m128)__lsx_vilvh_w(xxyy13, xxyy02));
-}
-
-inline void v_lut_deinterleave(const double *tab, const v_int32x4 &idxvec,
-                               v_float64x2 &x, v_float64x2 &y) {
-  const int *idx = (const int *)&idxvec.val;
-  __m128i xy0 = __lsx_vld(tab + idx[0], 0);
-  __m128i xy1 = __lsx_vld(tab + idx[1], 0);
-  x = v_float64x2((__m128d)__lsx_vilvl_d(xy1, xy0));
-  y = v_float64x2((__m128d)__lsx_vilvh_d(xy1, xy0));
-}
-
-inline v_int8x16 v_interleave_pairs(const v_int8x16 &vec) {
-  return v_int8x16(__lsx_vshuf_b(
-      vec.val, vec.val, _v128_setr_d(0x0705060403010200, 0x0f0d0e0c0b090a08)));
-}
-inline v_uint8x16 v_interleave_pairs(const v_uint8x16 &vec) {
-  return v_reinterpret_as_u8(v_interleave_pairs(v_reinterpret_as_s8(vec)));
-}
-inline v_int8x16 v_interleave_quads(const v_int8x16 &vec) {
-  return v_int8x16(__lsx_vshuf_b(
-      vec.val, vec.val, _v128_setr_d(0x0703060205010400, 0x0f0b0e0a0d090c08)));
-}
-inline v_uint8x16 v_interleave_quads(const v_uint8x16 &vec) {
-  return v_reinterpret_as_u8(v_interleave_quads(v_reinterpret_as_s8(vec)));
-}
-
-inline v_int16x8 v_interleave_pairs(const v_int16x8 &vec) {
-  return v_int16x8(__lsx_vshuf_b(
-      vec.val, vec.val, _v128_setr_d(0x0706030205040100, 0x0f0e0b0a0d0c0908)));
-}
-inline v_uint16x8 v_interleave_pairs(const v_uint16x8 &vec) {
-  return v_reinterpret_as_u16(v_interleave_pairs(v_reinterpret_as_s16(vec)));
-}
-inline v_int16x8 v_interleave_quads(const v_int16x8 &vec) {
-  return v_int16x8(__lsx_vshuf_b(
-      vec.val, vec.val, _v128_setr_d(0x0b0a030209080100, 0x0f0e07060d0c0504)));
-}
-inline v_uint16x8 v_interleave_quads(const v_uint16x8 &vec) {
-  return v_reinterpret_as_u16(v_interleave_quads(v_reinterpret_as_s16(vec)));
-}
-
-inline v_int32x4 v_interleave_pairs(const v_int32x4 &vec) {
-  return v_int32x4(__lsx_vshuf4i_w(vec.val, 0xd8));
-}
-inline v_uint32x4 v_interleave_pairs(const v_uint32x4 &vec) {
-  return v_reinterpret_as_u32(v_interleave_pairs(v_reinterpret_as_s32(vec)));
-}
-
-inline v_float32x4 v_interleave_pairs(const v_float32x4 &vec) {
-  return v_reinterpret_as_f32(v_interleave_pairs(v_reinterpret_as_s32(vec)));
-}
-
-inline v_int8x16 v_pack_triplets(const v_int8x16 &vec) {
-  __m128i zero = __lsx_vldi(0);
-  return v_int8x16(__lsx_vshuf_b(
-      zero, vec.val, _v128_set_d(0x1211100f0e0d0c0a, 0x0908060504020100)));
-}
-inline v_uint8x16 v_pack_triplets(const v_uint8x16 &vec) {
-  return v_reinterpret_as_u8(v_pack_triplets(v_reinterpret_as_s8(vec)));
-}
-
-inline v_int16x8 v_pack_triplets(const v_int16x8 &vec) {
-  __m128i zero = __lsx_vldi(0);
-  return v_int16x8(__lsx_vshuf_b(
-      zero, vec.val, _v128_set_d(0x11100f0e0d0c0b0a, 0x0908050403020100)));
-}
-inline v_uint16x8 v_pack_triplets(const v_uint16x8 &vec) {
-  return v_reinterpret_as_u16(v_pack_triplets(v_reinterpret_as_s16(vec)));
-}
-
-inline v_int32x4 v_pack_triplets(const v_int32x4 &vec) { return vec; }
-inline v_uint32x4 v_pack_triplets(const v_uint32x4 &vec) { return vec; }
-inline v_float32x4 v_pack_triplets(const v_float32x4 &vec) { return vec; }
-
-//////////// Matrix operations /////////
-
-/////////// Dot Product /////////
-
-// 16 >> 32
-inline v_int32x4 v_dotprod(const v_int16x8 &a, const v_int16x8 &b) {
-  __m128i x = a.val, y = b.val;
-  return v_int32x4(__lsx_vmaddwod_w_h(__lsx_vmulwev_w_h(x, y), x, y));
-}
-inline v_int32x4 v_dotprod(const v_int16x8 &a, const v_int16x8 &b,
-                           const v_int32x4 &c) {
-  __m128i x = a.val, y = b.val, z = c.val;
-  __m128i t = __lsx_vmaddwev_w_h(z, x, y);
-  return v_int32x4(__lsx_vmaddwod_w_h(t, x, y));
-}
-
-// 32 >> 64
-inline v_int64x2 v_dotprod(const v_int32x4 &a, const v_int32x4 &b) {
-  __m128i x = a.val, y = b.val;
-  return v_int64x2(__lsx_vmaddwod_d_w(__lsx_vmulwev_d_w(x, y), x, y));
-}
-inline v_int64x2 v_dotprod(const v_int32x4 &a, const v_int32x4 &b,
-                           const v_int64x2 &c) {
-  __m128i x = a.val, y = b.val, z = c.val;
-  __m128i t = __lsx_vmaddwev_d_w(z, x, y);
-  return v_int64x2(__lsx_vmaddwod_d_w(t, x, y));
-}
-
-// 8 >> 32
-inline v_uint32x4 v_dotprod_expand(const v_uint8x16 &a, const v_uint8x16 &b) {
-  __m128i x = a.val, y = b.val;
-  __m128i even = __lsx_vmulwev_h_bu(x, y);
-  __m128i odd = __lsx_vmulwod_h_bu(x, y);
-  __m128i prod0 = __lsx_vhaddw_wu_hu(even, even);
-  __m128i prod1 = __lsx_vhaddw_wu_hu(odd, odd);
-  return v_uint32x4(__lsx_vadd_w(prod0, prod1));
-}
-
-inline v_uint32x4 v_dotprod_expand(const v_uint8x16 &a, const v_uint8x16 &b,
-                                   const v_uint32x4 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-inline v_int32x4 v_dotprod_expand(const v_int8x16 &a, const v_int8x16 &b) {
-  __m128i x = a.val, y = b.val;
-  __m128i even = __lsx_vmulwev_h_b(x, y);
-  __m128i odd = __lsx_vmulwod_h_b(x, y);
-  __m128i prod0 = __lsx_vhaddw_w_h(even, even);
-  __m128i prod1 = __lsx_vhaddw_w_h(odd, odd);
-  return v_int32x4(__lsx_vadd_w(prod0, prod1));
-}
-inline v_int32x4 v_dotprod_expand(const v_int8x16 &a, const v_int8x16 &b,
-                                  const v_int32x4 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-// 16 >> 64
-inline v_uint64x2 v_dotprod_expand(const v_uint16x8 &a, const v_uint16x8 &b) {
-  __m128i x = a.val, y = b.val;
-  __m128i even = __lsx_vmulwev_w_hu(x, y);
-  __m128i odd = __lsx_vmulwod_w_hu(x, y);
-  __m128i prod0 = __lsx_vhaddw_du_wu(even, even);
-  __m128i prod1 = __lsx_vhaddw_du_wu(odd, odd);
-  return v_uint64x2(__lsx_vadd_d(prod0, prod1));
-}
-inline v_uint64x2 v_dotprod_expand(const v_uint16x8 &a, const v_uint16x8 &b,
-                                   const v_uint64x2 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-inline v_int64x2 v_dotprod_expand(const v_int16x8 &a, const v_int16x8 &b) {
-  __m128i x = a.val, y = b.val;
-  __m128i even = __lsx_vmulwev_w_h(x, y);
-  __m128i odd = __lsx_vmulwod_w_h(x, y);
-  __m128i prod0 = __lsx_vhaddw_d_w(even, even);
-  __m128i prod1 = __lsx_vhaddw_d_w(odd, odd);
-  return v_int64x2(__lsx_vadd_d(prod0, prod1));
-}
-inline v_int64x2 v_dotprod_expand(const v_int16x8 &a, const v_int16x8 &b,
-                                  const v_int64x2 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-// 32 >> 64f
-inline v_float64x2 v_dotprod_expand(const v_int32x4 &a, const v_int32x4 &b) {
-  return v_cvt_f64(v_dotprod(a, b));
-}
-inline v_float64x2 v_dotprod_expand(const v_int32x4 &a, const v_int32x4 &b,
-                                    const v_float64x2 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-///////// Fast Dot Product //////
-
-// 16 >> 32
-inline v_int32x4 v_dotprod_fast(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_dotprod(a, b);
-}
-inline v_int32x4 v_dotprod_fast(const v_int16x8 &a, const v_int16x8 &b,
-                                const v_int32x4 &c) {
-  return v_dotprod(a, b, c);
-}
-
-// 32 >> 64
-inline v_int64x2 v_dotprod_fast(const v_int32x4 &a, const v_int32x4 &b) {
-  return v_dotprod(a, b);
-}
-inline v_int64x2 v_dotprod_fast(const v_int32x4 &a, const v_int32x4 &b,
-                                const v_int64x2 &c) {
-  return v_dotprod(a, b, c);
-}
-
-// 8 >> 32
-inline v_uint32x4 v_dotprod_expand_fast(const v_uint8x16 &a,
-                                        const v_uint8x16 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_uint32x4 v_dotprod_expand_fast(const v_uint8x16 &a,
-                                        const v_uint8x16 &b,
-                                        const v_uint32x4 &c) {
-  return v_dotprod_expand(a, b, c);
-}
-
-inline v_int32x4 v_dotprod_expand_fast(const v_int8x16 &a, const v_int8x16 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_int32x4 v_dotprod_expand_fast(const v_int8x16 &a, const v_int8x16 &b,
-                                       const v_int32x4 &c) {
-  return v_dotprod_expand(a, b, c);
-}
-
-// 16 >> 64
-inline v_uint64x2 v_dotprod_expand_fast(const v_uint16x8 &a,
-                                        const v_uint16x8 &b) {
-  __m128i x = a.val, y = b.val;
-  __m128i even = __lsx_vmulwev_w_hu(x, y);
-  __m128i odd = __lsx_vmulwod_w_hu(x, y);
-  __m128i prod0 = __lsx_vhaddw_du_wu(even, even);
-  __m128i prod1 = __lsx_vhaddw_du_wu(odd, odd);
-  return v_uint64x2(__lsx_vilvl_d(__lsx_vhaddw_qu_du(prod0, prod0),
-                                  __lsx_vhaddw_qu_du(prod1, prod1)));
-}
-inline v_uint64x2 v_dotprod_expand_fast(const v_uint16x8 &a,
-                                        const v_uint16x8 &b,
-                                        const v_uint64x2 &c) {
-  return v_add(v_dotprod_expand_fast(a, b), c);
-}
-
-inline v_int64x2 v_dotprod_expand_fast(const v_int16x8 &a, const v_int16x8 &b) {
-  __m128i x = a.val, y = b.val;
-  __m128i prod = __lsx_vmaddwod_w_h(__lsx_vmulwev_w_h(x, y), x, y);
-  __m128i sign = __lsx_vsrai_w(prod, 31);
-  __m128i lo = __lsx_vilvl_w(sign, prod);
-  __m128i hi = __lsx_vilvh_w(sign, prod);
-  return v_int64x2(__lsx_vadd_d(lo, hi));
-}
-inline v_int64x2 v_dotprod_expand_fast(const v_int16x8 &a, const v_int16x8 &b,
-                                       const v_int64x2 &c) {
-  return v_add(v_dotprod_expand_fast(a, b), c);
-}
-
-// 32 >> 64f
-inline v_float64x2 v_dotprod_expand_fast(const v_int32x4 &a,
-                                         const v_int32x4 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_float64x2 v_dotprod_expand_fast(const v_int32x4 &a, const v_int32x4 &b,
-                                         const v_float64x2 &c) {
-  return v_dotprod_expand(a, b, c);
-}
-
-inline v_float32x4 v_matmul(const v_float32x4 &v, const v_float32x4 &m0,
-                            const v_float32x4 &m1, const v_float32x4 &m2,
-                            const v_float32x4 &m3) {
-  __m128i x = (__m128i)v.val;
-  __m128 v0 = __lsx_vfmul_s((__m128)__lsx_vshuf4i_w(x, 0x0), m0.val);
-  __m128 v1 = __lsx_vfmul_s((__m128)__lsx_vshuf4i_w(x, 0x55), m1.val);
-  __m128 v2 = __lsx_vfmul_s((__m128)__lsx_vshuf4i_w(x, 0xAA), m2.val);
-  __m128 v3 = __lsx_vfmul_s((__m128)__lsx_vshuf4i_w(x, 0xFF), m3.val);
-
-  return v_float32x4(
-      __lsx_vfadd_s(__lsx_vfadd_s(v0, v1), __lsx_vfadd_s(v2, v3)));
-}
-
-inline v_float32x4 v_matmuladd(const v_float32x4 &v, const v_float32x4 &m0,
-                               const v_float32x4 &m1, const v_float32x4 &m2,
-                               const v_float32x4 &a) {
-  __m128i x = (__m128i)v.val;
-  __m128 v0 = __lsx_vfmul_s((__m128)__lsx_vshuf4i_w(x, 0x0), m0.val);
-  __m128 v1 = __lsx_vfmul_s((__m128)__lsx_vshuf4i_w(x, 0x55), m1.val);
-  __m128 v2 = __lsx_vfmadd_s((__m128)__lsx_vshuf4i_w(x, 0xAA), m2.val, a.val);
-
-  return v_float32x4(__lsx_vfadd_s(__lsx_vfadd_s(v0, v1), v2));
-}
-
-#define OPENCV_HAL_IMPL_LSX_TRANSPOSE4X4(_Tpvec, cast_from, cast_to)           \
-  inline void v_transpose4x4(const _Tpvec &a0, const _Tpvec &a1,               \
-                             const _Tpvec &a2, const _Tpvec &a3, _Tpvec &b0,   \
-                             _Tpvec &b1, _Tpvec &b2, _Tpvec &b3) {             \
-    __m128i t0 = cast_from(__lsx_vilvl_w(a1.val, a0.val));                     \
-    __m128i t1 = cast_from(__lsx_vilvl_w(a3.val, a2.val));                     \
-    __m128i t2 = cast_from(__lsx_vilvh_w(a1.val, a0.val));                     \
-    __m128i t3 = cast_from(__lsx_vilvh_w(a3.val, a2.val));                     \
-    b0.val = cast_to(__lsx_vilvl_d(t1, t0));                                   \
-    b1.val = cast_to(__lsx_vilvh_d(t1, t0));                                   \
-    b2.val = cast_to(__lsx_vilvl_d(t3, t2));                                   \
-    b3.val = cast_to(__lsx_vilvh_d(t3, t2));                                   \
-  }
-
-OPENCV_HAL_IMPL_LSX_TRANSPOSE4X4(v_uint32x4, OPENCV_HAL_NOP, OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_LSX_TRANSPOSE4X4(v_int32x4, OPENCV_HAL_NOP, OPENCV_HAL_NOP)
-
-inline void v_transpose4x4(const v_float32x4 &a0, const v_float32x4 &a1,
-                           const v_float32x4 &a2, const v_float32x4 &a3,
-                           v_float32x4 &b0, v_float32x4 &b1, v_float32x4 &b2,
-                           v_float32x4 &b3) {
-  __m128i vec0 = (__m128i)a0.val, vec1 = (__m128i)a1.val;
-  __m128i vec2 = (__m128i)a2.val, vec3 = (__m128i)a3.val;
-  __m128i t0 = __lsx_vilvl_w(vec1, vec0);
-  __m128i t1 = __lsx_vilvl_w(vec3, vec2);
-  __m128i t2 = __lsx_vilvh_w(vec1, vec0);
-  __m128i t3 = __lsx_vilvh_w(vec3, vec2);
-  b0.val = __m128(__lsx_vilvl_d(t1, t0));
-  b1.val = __m128(__lsx_vilvh_d(t1, t0));
-  b2.val = __m128(__lsx_vilvl_d(t3, t2));
-  b3.val = __m128(__lsx_vilvh_d(t3, t2));
-}
-
-////////////////// Value reordering ////////////////
-
-/* Expand */
-#define OPENCV_HAL_IMPL_LSX_EXPAND(_Tpvec, _Tpwvec, _Tp, intrin_lo, intrin_hi) \
-  inline void v_expand(const _Tpvec &a, _Tpwvec &b0, _Tpwvec &b1) {            \
-    b0.val = intrin_lo(a.val, 0);                                              \
-    b1.val = intrin_hi(a.val);                                                 \
-  }                                                                            \
-  inline _Tpwvec v_expand_low(const _Tpvec &a) {                               \
-    return _Tpwvec(intrin_lo(a.val, 0));                                       \
-  }                                                                            \
-  inline _Tpwvec v_expand_high(const _Tpvec &a) {                              \
-    return _Tpwvec(intrin_hi(a.val));                                          \
-  }                                                                            \
-  inline _Tpwvec v_load_expand(const _Tp *ptr) {                               \
-    __m128i a = __lsx_vld(ptr, 0);                                             \
-    return _Tpwvec(intrin_lo(a, 0));                                           \
-  }
-
-OPENCV_HAL_IMPL_LSX_EXPAND(v_uint8x16, v_uint16x8, uchar, __lsx_vsllwil_hu_bu,
-                           __lsx_vexth_hu_bu)
-OPENCV_HAL_IMPL_LSX_EXPAND(v_int8x16, v_int16x8, schar, __lsx_vsllwil_h_b,
-                           __lsx_vexth_h_b)
-OPENCV_HAL_IMPL_LSX_EXPAND(v_uint16x8, v_uint32x4, ushort, __lsx_vsllwil_wu_hu,
-                           __lsx_vexth_wu_hu)
-OPENCV_HAL_IMPL_LSX_EXPAND(v_int16x8, v_int32x4, short, __lsx_vsllwil_w_h,
-                           __lsx_vexth_w_h)
-OPENCV_HAL_IMPL_LSX_EXPAND(v_uint32x4, v_uint64x2, unsigned,
-                           __lsx_vsllwil_du_wu, __lsx_vexth_du_wu)
-OPENCV_HAL_IMPL_LSX_EXPAND(v_int32x4, v_int64x2, int, __lsx_vsllwil_d_w,
-                           __lsx_vexth_d_w)
-
-#define OPENCV_HAL_IMPL_LSX_EXPAND_Q(_Tpvec, _Tp, intrin_lo, intrin_hi)        \
-  inline _Tpvec v_load_expand_q(const _Tp *ptr) {                              \
-    __m128i a = __lsx_vld(ptr, 0);                                             \
-    __m128i b = intrin_lo(a, 0);                                               \
-    return _Tpvec(intrin_hi(b, 0));                                            \
-  }
-
-OPENCV_HAL_IMPL_LSX_EXPAND_Q(v_uint32x4, uchar, __lsx_vsllwil_hu_bu,
-                             __lsx_vsllwil_wu_hu)
-OPENCV_HAL_IMPL_LSX_EXPAND_Q(v_int32x4, schar, __lsx_vsllwil_h_b,
-                             __lsx_vsllwil_w_h)
-
-/* pack */
-// 16
-inline v_int8x16 v_pack(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_int8x16(_lsx_packs_h(a.val, b.val));
-}
-
-inline v_uint8x16 v_pack(const v_uint16x8 &a, const v_uint16x8 &b) {
-  return v_uint8x16(__lsx_vssrlrni_bu_h(b.val, a.val, 0));
-}
-
-inline v_uint8x16 v_pack_u(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_uint8x16(_lsx_packus_h(a.val, b.val));
-}
-
-inline void v_pack_store(schar *ptr, const v_int16x8 &a) {
-  v_store_low(ptr, v_pack(a, a));
-}
-
-inline void v_pack_store(uchar *ptr, const v_uint16x8 &a) {
-  v_store_low(ptr, v_pack(a, a));
-}
-
-inline void v_pack_u_store(uchar *ptr, const v_int16x8 &a) {
-  v_store_low(ptr, v_pack_u(a, a));
-}
-
-template <int n>
-inline v_uint8x16 v_rshr_pack(const v_uint16x8 &a, const v_uint16x8 &b) {
-  return v_uint8x16(__lsx_vssrlrni_bu_h(b.val, a.val, n));
-}
-
-template <int n>
-inline void v_rshr_pack_store(uchar *ptr, const v_uint16x8 &a) {
-  __lsx_vstelm_d(__lsx_vssrlrni_bu_h(a.val, a.val, n), ptr, 0, 0);
-}
-
-template <int n>
-inline v_uint8x16 v_rshr_pack_u(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_uint8x16(__lsx_vssrarni_bu_h(b.val, a.val, n));
-}
-
-template <int n>
-inline void v_rshr_pack_u_store(uchar *ptr, const v_int16x8 &a) {
-  __lsx_vstelm_d(__lsx_vssrarni_bu_h(a.val, a.val, n), ptr, 0, 0);
-}
-
-template <int n>
-inline v_int8x16 v_rshr_pack(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_int8x16(__lsx_vssrarni_b_h(b.val, a.val, n));
-}
-
-template <int n> inline void v_rshr_pack_store(schar *ptr, const v_int16x8 &a) {
-  __lsx_vstelm_d(__lsx_vssrarni_b_h(a.val, a.val, n), ptr, 0, 0);
-}
-
-// 32
-inline v_int16x8 v_pack(const v_int32x4 &a, const v_int32x4 &b) {
-  return v_int16x8(__lsx_vssrarni_h_w(b.val, a.val, 0));
-}
-
-inline v_uint16x8 v_pack(const v_uint32x4 &a, const v_uint32x4 &b) {
-  return v_uint16x8(__lsx_vssrlrni_hu_w(b.val, a.val, 0));
-}
-
-inline v_uint16x8 v_pack_u(const v_int32x4 &a, const v_int32x4 &b) {
-  return v_uint16x8(__lsx_vssrarni_hu_w(b.val, a.val, 0));
-}
-
-inline void v_pack_store(short *ptr, const v_int32x4 &a) {
-  v_store_low(ptr, v_pack(a, a));
-}
-
-inline void v_pack_store(ushort *ptr, const v_uint32x4 &a) {
-  __lsx_vstelm_d(__lsx_vssrlrni_hu_w(a.val, a.val, 0), ptr, 0, 0);
-}
-
-inline void v_pack_u_store(ushort *ptr, const v_int32x4 &a) {
-  __lsx_vstelm_d(__lsx_vssrarni_hu_w(a.val, a.val, 0), ptr, 0, 0);
-}
-
-template <int n>
-inline v_uint16x8 v_rshr_pack(const v_uint32x4 &a, const v_uint32x4 &b) {
-  return v_uint16x8(__lsx_vssrlrni_hu_w(b.val, a.val, n));
-}
-
-template <int n>
-inline void v_rshr_pack_store(ushort *ptr, const v_uint32x4 &a) {
-  __lsx_vstelm_d(__lsx_vssrlrni_hu_w(a.val, a.val, n), ptr, 0, 0);
-}
-
-template <int n>
-inline v_uint16x8 v_rshr_pack_u(const v_int32x4 &a, const v_int32x4 &b) {
-  return v_uint16x8(__lsx_vssrarni_hu_w(b.val, a.val, n));
-}
-
-template <int n>
-inline void v_rshr_pack_u_store(ushort *ptr, const v_int32x4 &a) {
-  __lsx_vstelm_d(__lsx_vssrarni_hu_w(a.val, a.val, n), ptr, 0, 0);
-}
-
-template <int n>
-inline v_int16x8 v_rshr_pack(const v_int32x4 &a, const v_int32x4 &b) {
-  return v_int16x8(__lsx_vssrarni_h_w(b.val, a.val, n));
-}
-
-template <int n> inline void v_rshr_pack_store(short *ptr, const v_int32x4 &a) {
-  __lsx_vstelm_d(__lsx_vssrarni_h_w(a.val, a.val, n), ptr, 0, 0);
-}
-
-// 64
-// Non-saturaing pack
-inline v_uint32x4 v_pack(const v_uint64x2 &a, const v_uint64x2 &b) {
-  return v_uint32x4(__lsx_vpickev_w(b.val, a.val));
-}
-
-inline v_int32x4 v_pack(const v_int64x2 &a, const v_int64x2 &b) {
-  return v_reinterpret_as_s32(
-      v_pack(v_reinterpret_as_u64(a), v_reinterpret_as_u64(b)));
-}
-
-inline void v_pack_store(unsigned *ptr, const v_uint64x2 &a) {
-  __lsx_vstelm_d(__lsx_vshuf4i_w(a.val, 0x08), ptr, 0, 0);
-}
-
-inline void v_pack_store(int *ptr, const v_int64x2 &a) {
-  v_pack_store((unsigned *)ptr, v_reinterpret_as_u64(a));
-}
-
-template <int n>
-inline v_uint32x4 v_rshr_pack(const v_uint64x2 &a, const v_uint64x2 &b) {
-  return v_uint32x4(__lsx_vsrlrni_w_d(b.val, a.val, n));
-}
-
-template <int n>
-inline void v_rshr_pack_store(unsigned *ptr, const v_uint64x2 &a) {
-  __lsx_vstelm_d(__lsx_vsrlrni_w_d(a.val, a.val, n), ptr, 0, 0);
-}
-
-template <int n>
-inline v_int32x4 v_rshr_pack(const v_int64x2 &a, const v_int64x2 &b) {
-  return v_int32x4(__lsx_vsrarni_w_d(b.val, a.val, n));
-}
-
-template <int n> inline void v_rshr_pack_store(int *ptr, const v_int64x2 &a) {
-  __lsx_vstelm_d(__lsx_vsrarni_w_d(a.val, a.val, n), ptr, 0, 0);
-}
-
-// pack boolean
-inline v_uint8x16 v_pack_b(const v_uint16x8 &a, const v_uint16x8 &b) {
-  return v_uint8x16(__lsx_vssrarni_b_h(b.val, a.val, 0));
-}
-
-inline v_uint8x16 v_pack_b(const v_uint32x4 &a, const v_uint32x4 &b,
-                           const v_uint32x4 &c, const v_uint32x4 &d) {
-  __m128i ab = __lsx_vssrarni_h_w(b.val, a.val, 0);
-  __m128i cd = __lsx_vssrarni_h_w(d.val, c.val, 0);
-  return v_uint8x16(__lsx_vssrarni_b_h(cd, ab, 0));
-}
-
-inline v_uint8x16 v_pack_b(const v_uint64x2 &a, const v_uint64x2 &b,
-                           const v_uint64x2 &c, const v_uint64x2 &d,
-                           const v_uint64x2 &e, const v_uint64x2 &f,
-                           const v_uint64x2 &g, const v_uint64x2 &h) {
-  __m128i ab = __lsx_vssrarni_w_d(b.val, a.val, 0);
-  __m128i cd = __lsx_vssrarni_w_d(d.val, c.val, 0);
-  __m128i ef = __lsx_vssrarni_w_d(f.val, e.val, 0);
-  __m128i gh = __lsx_vssrarni_w_d(h.val, g.val, 0);
-
-  __m128i abcd = __lsx_vssrarni_h_w(cd, ab, 0);
-  __m128i efgh = __lsx_vssrarni_h_w(gh, ef, 0);
-  return v_uint8x16(__lsx_vssrarni_b_h(efgh, abcd, 0));
-}
-
-/* Recombine */
-// its up there with load and store operations
-
-/* Extract */
-#define OPENCV_HAL_IMPL_LSX_EXTRACT(_Tpvec)                                    \
-  template <int s> inline _Tpvec v_extract(const _Tpvec &a, const _Tpvec &b) { \
-    return v_rotate_right<s>(a, b);                                            \
-  }
-
-OPENCV_HAL_IMPL_LSX_EXTRACT(v_uint8x16)
-OPENCV_HAL_IMPL_LSX_EXTRACT(v_int8x16)
-OPENCV_HAL_IMPL_LSX_EXTRACT(v_uint16x8)
-OPENCV_HAL_IMPL_LSX_EXTRACT(v_int16x8)
-OPENCV_HAL_IMPL_LSX_EXTRACT(v_uint32x4)
-OPENCV_HAL_IMPL_LSX_EXTRACT(v_int32x4)
-OPENCV_HAL_IMPL_LSX_EXTRACT(v_uint64x2)
-OPENCV_HAL_IMPL_LSX_EXTRACT(v_int64x2)
-OPENCV_HAL_IMPL_LSX_EXTRACT(v_float32x4)
-OPENCV_HAL_IMPL_LSX_EXTRACT(v_float64x2)
-
-#define OPENCV_HAL_IMPL_LSX_EXTRACT_N(_Tpvec, _Twvec, intrin)                  \
-  template <int i> inline _Twvec v_extract_n(const _Tpvec &a) {                \
-    return (_Twvec)intrin(a.val, i);                                           \
-  }
-
-OPENCV_HAL_IMPL_LSX_EXTRACT_N(v_uint8x16, uchar, __lsx_vpickve2gr_b)
-OPENCV_HAL_IMPL_LSX_EXTRACT_N(v_int8x16, schar, __lsx_vpickve2gr_b)
-OPENCV_HAL_IMPL_LSX_EXTRACT_N(v_uint16x8, ushort, __lsx_vpickve2gr_h)
-OPENCV_HAL_IMPL_LSX_EXTRACT_N(v_int16x8, short, __lsx_vpickve2gr_h)
-OPENCV_HAL_IMPL_LSX_EXTRACT_N(v_uint32x4, uint, __lsx_vpickve2gr_w)
-OPENCV_HAL_IMPL_LSX_EXTRACT_N(v_int32x4, int, __lsx_vpickve2gr_w)
-OPENCV_HAL_IMPL_LSX_EXTRACT_N(v_uint64x2, uint64, __lsx_vpickve2gr_d)
-OPENCV_HAL_IMPL_LSX_EXTRACT_N(v_int64x2, int64, __lsx_vpickve2gr_d)
-
-template <int i> inline float v_extract_n(const v_float32x4 &v) {
-  union {
-    uint iv;
-    float fv;
-  } d;
-  d.iv = __lsx_vpickve2gr_w(v.val, i);
-  return d.fv;
-}
-
-template <int i> inline double v_extract_n(const v_float64x2 &v) {
-  union {
-    uint64 iv;
-    double dv;
-  } d;
-  d.iv = __lsx_vpickve2gr_d(v.val, i);
-  return d.dv;
-}
-
-template <int i> inline v_uint32x4 v_broadcast_element(const v_uint32x4 &a) {
-  return v_uint32x4(__lsx_vreplvei_w(a.val, i));
-}
-
-template <int i> inline v_int32x4 v_broadcast_element(const v_int32x4 &a) {
-  return v_int32x4(__lsx_vreplvei_w(a.val, i));
-}
-
-template <int i> inline v_float32x4 v_broadcast_element(const v_float32x4 &a) {
-  return v_float32x4((__m128)__lsx_vreplvei_w((__m128i)a.val, i));
-}
-
-/////////////////// load deinterleave //////////////////////////////
-
-inline void v_load_deinterleave(const uchar *ptr, v_uint8x16 &a,
-                                v_uint8x16 &b) {
-  __m128i t0 = __lsx_vld(ptr, 0);
-  __m128i t1 = __lsx_vld(ptr, 16);
-
-  a.val = __lsx_vpickev_b(t1, t0);
-  b.val = __lsx_vpickod_b(t1, t0);
-}
-
-inline void v_load_deinterleave(const ushort *ptr, v_uint16x8 &a,
-                                v_uint16x8 &b) {
-  __m128i t0 = __lsx_vld(ptr, 0);
-  __m128i t1 = __lsx_vld(ptr, 16);
-  a.val = __lsx_vpickev_h(t1, t0);
-  b.val = __lsx_vpickod_h(t1, t0);
-}
-
-inline void v_load_deinterleave(const unsigned *ptr, v_uint32x4 &a,
-                                v_uint32x4 &b) {
-  __m128i t0 = __lsx_vld(ptr, 0);
-  __m128i t1 = __lsx_vld(ptr, 16);
-  a.val = __lsx_vpickev_w(t1, t0);
-  b.val = __lsx_vpickod_w(t1, t0);
-}
-
-inline void v_load_deinterleave(const uint64 *ptr, v_uint64x2 &a,
-                                v_uint64x2 &b) {
-  __m128i t0 = __lsx_vld(ptr, 0);
-  __m128i t1 = __lsx_vld(ptr, 16);
-  a.val = __lsx_vilvl_d(t1, t0);
-  b.val = __lsx_vilvh_d(t1, t0);
-}
-
-inline void v_load_deinterleave(const uchar *ptr, v_uint8x16 &a, v_uint8x16 &b,
-                                v_uint8x16 &c) {
-  __m128i t0 = __lsx_vld(ptr, 0);
-  __m128i t1 = __lsx_vld(ptr, 16);
-  __m128i t2 = __lsx_vld(ptr, 32);
-  const __m128i shuff0 =
-      _v128_setr_b(0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0);
-  const __m128i shuff1 =
-      _v128_setr_b(0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0);
-  __m128i a0 = __lsx_vbitsel_v(t0, t1, shuff0);
-  __m128i b0 = __lsx_vbitsel_v(t1, t0, shuff1);
-  __m128i c0 = __lsx_vbitsel_v(t1, t0, shuff0);
-  const __m128i shuff_a =
-      _v128_setr_b(0, 3, 6, 9, 12, 15, 2, 5, 8, 11, 14, 17, 20, 23, 26, 29);
-  const __m128i shuff_b =
-      _v128_setr_b(1, 4, 7, 10, 13, 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30);
-  const __m128i shuff_c =
-      _v128_setr_b(2, 5, 8, 11, 14, 1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31);
-
-  a.val = __lsx_vshuf_b(t2, a0, shuff_a);
-  b.val = __lsx_vshuf_b(t2, b0, shuff_b);
-  c.val = __lsx_vshuf_b(t2, c0, shuff_c);
-}
-
-inline void v_load_deinterleave(const ushort *ptr, v_uint16x8 &a, v_uint16x8 &b,
-                                v_uint16x8 &c) {
-  __m128i t0 = __lsx_vld(ptr, 0);
-  __m128i t1 = __lsx_vld(ptr, 16);
-  __m128i t2 = __lsx_vld(ptr, 32);
-  const __m128i shuff0 = _v128_setr_h(0, 0, -1, 0, 0, -1, 0, 0);
-  const __m128i shuff1 = _v128_setr_h(0, -1, 0, 0, -1, 0, 0, -1);
-
-  __m128i a0 = __lsx_vbitsel_v(t0, t1, shuff1);
-  __m128i b0 = __lsx_vbitsel_v(t0, t1, shuff0);
-  __m128i c0 = __lsx_vbitsel_v(t1, t0, shuff0);
-
-  const __m128i shuff_a =
-      _v128_setr_b(0, 1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15, 20, 21, 26, 27);
-  const __m128i shuff_b =
-      _v128_setr_b(2, 3, 8, 9, 14, 15, 4, 5, 10, 11, 16, 17, 22, 23, 28, 29);
-  const __m128i shuff_c =
-      _v128_setr_b(4, 5, 10, 11, 0, 1, 6, 7, 12, 13, 18, 19, 24, 25, 30, 31);
-
-  a.val = __lsx_vshuf_b(t2, a0, shuff_a);
-  b.val = __lsx_vshuf_b(t2, b0, shuff_b);
-  c.val = __lsx_vshuf_b(t2, c0, shuff_c);
-}
-
-inline void v_load_deinterleave(const unsigned *ptr, v_uint32x4 &a,
-                                v_uint32x4 &b, v_uint32x4 &c) {
-  __m128i t0 = __lsx_vld(ptr, 0);
-  __m128i t1 = __lsx_vld(ptr, 16);
-  __m128i t2 = __lsx_vld(ptr, 32);
-
-  __m128i a0 = __lsx_vpermi_w(t1, t0, 0xAC);
-  __m128i b0 = __lsx_vpermi_w(t1, t0, 0xC5);
-  __m128i c0 = __lsx_vpermi_w(t1, t0, 0x5A);
-
-  a.val = __lsx_vextrins_w(a0, t2, 0x31);
-  b0 = __lsx_vshuf4i_w(b0, 0x38);
-  c0 = __lsx_vshuf4i_w(c0, 0x8);
-  b.val = __lsx_vextrins_w(b0, t2, 0x32);
-  c.val = __lsx_vpermi_w(t2, c0, 0xC4);
-}
-
-inline void v_load_deinterleave(const uint64 *ptr, v_uint64x2 &a, v_uint64x2 &b,
-                                v_uint64x2 &c) {
-  __m128i t0 = __lsx_vld(ptr, 0);
-  __m128i t1 = __lsx_vld(ptr, 16);
-  __m128i t2 = __lsx_vld(ptr, 32);
-
-  a.val = __lsx_vshuf4i_d(t0, t1, 0xC);
-  b.val = __lsx_vshuf4i_d(t0, t2, 0x9);
-  c.val = __lsx_vshuf4i_d(t1, t2, 0xC);
-}
-
-inline void v_load_deinterleave(const uchar *ptr, v_uint8x16 &a, v_uint8x16 &b,
-                                v_uint8x16 &c, v_uint8x16 &d) {
-  __m128i t0 = __lsx_vld(ptr, 0);
-  __m128i t1 = __lsx_vld(ptr, 16);
-  __m128i t2 = __lsx_vld(ptr, 32);
-  __m128i t3 = __lsx_vld(ptr, 48);
-
-  __m128i ac_lo = __lsx_vpickev_b(t1, t0);
-  __m128i bd_lo = __lsx_vpickod_b(t1, t0);
-  __m128i ac_hi = __lsx_vpickev_b(t3, t2);
-  __m128i bd_hi = __lsx_vpickod_b(t3, t2);
-
-  a.val = __lsx_vpickev_b(ac_hi, ac_lo);
-  c.val = __lsx_vpickod_b(ac_hi, ac_lo);
-  b.val = __lsx_vpickev_b(bd_hi, bd_lo);
-  d.val = __lsx_vpickod_b(bd_hi, bd_lo);
-}
-
-inline void v_load_deinterleave(const ushort *ptr, v_uint16x8 &a, v_uint16x8 &b,
-                                v_uint16x8 &c, v_uint16x8 &d) {
-  __m128i t0 = __lsx_vld(ptr, 0);
-  __m128i t1 = __lsx_vld(ptr, 16);
-  __m128i t2 = __lsx_vld(ptr, 32);
-  __m128i t3 = __lsx_vld(ptr, 48);
-
-  __m128i ac_lo = __lsx_vpickev_h(t1, t0);
-  __m128i bd_lo = __lsx_vpickod_h(t1, t0);
-  __m128i ac_hi = __lsx_vpickev_h(t3, t2);
-  __m128i bd_hi = __lsx_vpickod_h(t3, t2);
-
-  a.val = __lsx_vpickev_h(ac_hi, ac_lo);
-  c.val = __lsx_vpickod_h(ac_hi, ac_lo);
-  b.val = __lsx_vpickev_h(bd_hi, bd_lo);
-  d.val = __lsx_vpickod_h(bd_hi, bd_lo);
-}
-
-inline void v_load_deinterleave(const unsigned *ptr, v_uint32x4 &a,
-                                v_uint32x4 &b, v_uint32x4 &c, v_uint32x4 &d) {
-  __m128i p0 = __lsx_vld(ptr, 0);
-  __m128i p1 = __lsx_vld(ptr, 16);
-  __m128i p2 = __lsx_vld(ptr, 32);
-  __m128i p3 = __lsx_vld(ptr, 48);
-
-  __m128i t0 = __lsx_vilvl_w(p1, p0);
-  __m128i t1 = __lsx_vilvl_w(p3, p2);
-  __m128i t2 = __lsx_vilvh_w(p1, p0);
-  __m128i t3 = __lsx_vilvh_w(p3, p2);
-  a.val = __lsx_vilvl_d(t1, t0);
-  b.val = __lsx_vilvh_d(t1, t0);
-  c.val = __lsx_vilvl_d(t3, t2);
-  d.val = __lsx_vilvh_d(t3, t2);
-}
-
-inline void v_load_deinterleave(const uint64 *ptr, v_uint64x2 &a, v_uint64x2 &b,
-                                v_uint64x2 &c, v_uint64x2 &d) {
-  __m128i t0 = __lsx_vld(ptr, 0);
-  __m128i t1 = __lsx_vld(ptr, 16);
-  __m128i t2 = __lsx_vld(ptr, 32);
-  __m128i t3 = __lsx_vld(ptr, 48);
-
-  a.val = __lsx_vilvl_d(t2, t0);
-  b.val = __lsx_vilvh_d(t2, t0);
-  c.val = __lsx_vilvl_d(t3, t1);
-  d.val = __lsx_vilvh_d(t3, t1);
-}
-
-////////////////////////// store interleave ////////////////////////////////
-
-inline void v_store_interleave(uchar *ptr, const v_uint8x16 &a,
-                               const v_uint8x16 &b,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  __m128i v0 = __lsx_vilvl_b(b.val, a.val);
-  __m128i v1 = __lsx_vilvh_b(b.val, a.val);
-
-  __lsx_vst(v0, ptr, 0);
-  __lsx_vst(v1, ptr, 16);
-}
-
-inline void v_store_interleave(ushort *ptr, const v_uint16x8 &a,
-                               const v_uint16x8 &b,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  __m128i v0 = __lsx_vilvl_h(b.val, a.val);
-  __m128i v1 = __lsx_vilvh_h(b.val, a.val);
-
-  __lsx_vst(v0, ptr, 0);
-  __lsx_vst(v1, ptr, 16);
-}
-
-inline void v_store_interleave(unsigned *ptr, const v_uint32x4 &a,
-                               const v_uint32x4 &b,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  __m128i v0 = __lsx_vilvl_w(b.val, a.val);
-  __m128i v1 = __lsx_vilvh_w(b.val, a.val);
-
-  __lsx_vst(v0, ptr, 0);
-  __lsx_vst(v1, ptr, 16);
-}
-
-inline void v_store_interleave(uint64 *ptr, const v_uint64x2 &a,
-                               const v_uint64x2 &b,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  __m128i v0 = __lsx_vilvl_d(b.val, a.val);
-  __m128i v1 = __lsx_vilvh_d(b.val, a.val);
-
-  __lsx_vst(v0, ptr, 0);
-  __lsx_vst(v1, ptr, 16);
-}
-
-inline void v_store_interleave(uchar *ptr, const v_uint8x16 &a,
-                               const v_uint8x16 &b, const v_uint8x16 &c,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  __m128i ab_lo = __lsx_vilvl_b(b.val, a.val);
-  __m128i ab_hi = __lsx_vilvh_b(b.val, a.val);
-  __m128i v_c = c.val;
-  const __m128i shuff0 =
-      _v128_setr_b(0, 1, 16, 2, 3, 17, 4, 5, 18, 6, 7, 19, 8, 9, 20, 10);
-  const __m128i shuff1 =
-      _v128_setr_b(11, 21, 12, 13, 22, 14, 15, 23, 0, 0, 0, 0, 0, 0, 0, 0);
-  const __m128i shuff2 =
-      _v128_setr_b(0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 24, 18, 19, 25, 20, 21);
-  const __m128i shuff3 =
-      _v128_setr_b(26, 6, 7, 27, 8, 9, 28, 10, 11, 29, 12, 13, 30, 14, 15, 31);
-  __m128i abc = __lsx_vpermi_w(v_c, ab_hi, 0xE4);
-
-  __m128i dst0 = __lsx_vshuf_b(v_c, ab_lo, shuff0);
-  __m128i dst1 = __lsx_vshuf_b(v_c, ab_lo, shuff1);
-  __m128i dst2 = __lsx_vshuf_b(v_c, ab_hi, shuff3);
-  dst1 = __lsx_vshuf_b(abc, dst1, shuff2);
-
-  __lsx_vst(dst0, ptr, 0);
-  __lsx_vst(dst1, ptr, 16);
-  __lsx_vst(dst2, ptr, 32);
-}
-
-inline void v_store_interleave(ushort *ptr, const v_uint16x8 &a,
-                               const v_uint16x8 &b, const v_uint16x8 &c,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  __m128i ab_lo = __lsx_vilvl_h(b.val, a.val);
-  __m128i ab_hi = __lsx_vilvh_h(b.val, a.val);
-  __m128i v_c = c.val;
-  const __m128i shuff0 =
-      _v128_setr_b(0, 1, 2, 3, 16, 17, 4, 5, 6, 7, 18, 19, 8, 9, 10, 11);
-  const __m128i shuff1 =
-      _v128_setr_b(20, 21, 12, 13, 14, 15, 22, 23, 0, 0, 0, 0, 0, 0, 0, 0);
-  const __m128i shuff2 =
-      _v128_setr_b(0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 24, 25, 20, 21);
-  const __m128i shuff3 =
-      _v128_setr_b(6, 7, 26, 27, 8, 9, 10, 11, 28, 29, 12, 13, 14, 15, 30, 31);
-  __m128i abc = __lsx_vpermi_w(v_c, ab_hi, 0xE4);
-
-  __m128i dst0 = __lsx_vshuf_b(v_c, ab_lo, shuff0);
-  __m128i dst1 = __lsx_vshuf_b(v_c, ab_lo, shuff1);
-  __m128i dst2 = __lsx_vshuf_b(v_c, ab_hi, shuff3);
-  dst1 = __lsx_vshuf_b(abc, dst1, shuff2);
-
-  __lsx_vst(dst0, ptr, 0);
-  __lsx_vst(dst1, ptr, 16);
-  __lsx_vst(dst2, ptr, 32);
-}
-
-inline void v_store_interleave(unsigned *ptr, const v_uint32x4 &a,
-                               const v_uint32x4 &b, const v_uint32x4 &c,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  __m128i v_c = c.val;
-  __m128i ab_lo = __lsx_vilvl_w(b.val, a.val); // a0 b0 a1 b1
-  __m128i ab_hi = __lsx_vilvh_w(b.val, a.val); // a2 b2 a3 b3
-  __m128i bc_od = __lsx_vpackod_w(v_c, b.val); // b1 c1 b3 c3
-
-  __m128i dst0 = __lsx_vshuf4i_w(ab_lo, 0xB4);       // a0 b0 b1 a1
-  __m128i dst1 = __lsx_vilvl_d(ab_hi, bc_od);        // b1 c1 a2 b2
-  __m128i dst2 = __lsx_vpermi_w(bc_od, ab_hi, 0xE8); // a2, a3, b3, c3
-
-  dst0 = __lsx_vextrins_w(dst0, v_c, 0x20);
-  dst2 = __lsx_vextrins_w(dst2, v_c, 0x2);
-  __lsx_vst(dst0, ptr, 0);  // a0 b0 c0 a1
-  __lsx_vst(dst1, ptr, 16); // b1 c1 a2 b2
-  __lsx_vst(dst2, ptr, 32); // c2 a3 b3 c3
-}
-
-inline void v_store_interleave(uint64 *ptr, const v_uint64x2 &a,
-                               const v_uint64x2 &b, const v_uint64x2 &c,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  __m128i dst0 = __lsx_vilvl_d(b.val, a.val);
-  __m128i dst1 = __lsx_vpermi_w(a.val, c.val, 0xE4);
-  __m128i dst2 = __lsx_vilvh_d(c.val, b.val);
-
-  __lsx_vst(dst0, ptr, 0);
-  __lsx_vst(dst1, ptr, 16);
-  __lsx_vst(dst2, ptr, 32);
-}
-
-inline void v_store_interleave(uchar *ptr, const v_uint8x16 &a,
-                               const v_uint8x16 &b, const v_uint8x16 &c,
-                               const v_uint8x16 &d,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  __m128i ab_lo = __lsx_vilvl_b(b.val, a.val);
-  __m128i ab_hi = __lsx_vilvh_b(b.val, a.val);
-  __m128i cd_lo = __lsx_vilvl_b(d.val, c.val);
-  __m128i cd_hi = __lsx_vilvh_b(d.val, c.val);
-
-  __m128i dst0 = __lsx_vilvl_h(cd_lo, ab_lo);
-  __m128i dst1 = __lsx_vilvh_h(cd_lo, ab_lo);
-  __m128i dst2 = __lsx_vilvl_h(cd_hi, ab_hi);
-  __m128i dst3 = __lsx_vilvh_h(cd_hi, ab_hi);
-
-  __lsx_vst(dst0, ptr, 0);
-  __lsx_vst(dst1, ptr, 16);
-  __lsx_vst(dst2, ptr, 32);
-  __lsx_vst(dst3, ptr, 48);
-}
-
-inline void v_store_interleave(ushort *ptr, const v_uint16x8 &a,
-                               const v_uint16x8 &b, const v_uint16x8 &c,
-                               const v_uint16x8 &d,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  __m128i ab_lo = __lsx_vilvl_h(b.val, a.val);
-  __m128i ab_hi = __lsx_vilvh_h(b.val, a.val);
-  __m128i cd_lo = __lsx_vilvl_h(d.val, c.val);
-  __m128i cd_hi = __lsx_vilvh_h(d.val, c.val);
-
-  __m128i dst0 = __lsx_vilvl_w(cd_lo, ab_lo);
-  __m128i dst1 = __lsx_vilvh_w(cd_lo, ab_lo);
-  __m128i dst2 = __lsx_vilvl_w(cd_hi, ab_hi);
-  __m128i dst3 = __lsx_vilvh_w(cd_hi, ab_hi);
-
-  __lsx_vst(dst0, ptr, 0);
-  __lsx_vst(dst1, ptr, 16);
-  __lsx_vst(dst2, ptr, 32);
-  __lsx_vst(dst3, ptr, 48);
-}
-
-inline void v_store_interleave(unsigned *ptr, const v_uint32x4 &a,
-                               const v_uint32x4 &b, const v_uint32x4 &c,
-                               const v_uint32x4 &d,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  __m128i ab_lo = __lsx_vilvl_w(b.val, a.val);
-  __m128i ab_hi = __lsx_vilvh_w(b.val, a.val);
-  __m128i cd_lo = __lsx_vilvl_w(d.val, c.val);
-  __m128i cd_hi = __lsx_vilvh_w(d.val, c.val);
-
-  __m128i dst0 = __lsx_vilvl_d(cd_lo, ab_lo);
-  __m128i dst1 = __lsx_vilvh_d(cd_lo, ab_lo);
-  __m128i dst2 = __lsx_vilvl_d(cd_hi, ab_hi);
-  __m128i dst3 = __lsx_vilvh_d(cd_hi, ab_hi);
-
-  __lsx_vst(dst0, ptr, 0);
-  __lsx_vst(dst1, ptr, 16);
-  __lsx_vst(dst2, ptr, 32);
-  __lsx_vst(dst3, ptr, 48);
-}
-
-inline void v_store_interleave(uint64 *ptr, const v_uint64x2 &a,
-                               const v_uint64x2 &b, const v_uint64x2 &c,
-                               const v_uint64x2 &d,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  __m128i dst0 = __lsx_vilvl_d(b.val, a.val);
-  __m128i dst2 = __lsx_vilvh_d(b.val, a.val);
-  __m128i dst1 = __lsx_vilvl_d(d.val, c.val);
-  __m128i dst3 = __lsx_vilvh_d(d.val, c.val);
-
-  __lsx_vst(dst0, ptr, 0);
-  __lsx_vst(dst1, ptr, 16);
-  __lsx_vst(dst2, ptr, 32);
-  __lsx_vst(dst3, ptr, 48);
-}
-
-#define OPENCV_HAL_IMPL_LSX_LOADSTORE_INTERLEAVE(_Tpvec0, _Tp0, suffix0,       \
-                                                 _Tpvec1, _Tp1, suffix1)       \
-  inline void v_load_deinterleave(const _Tp0 *ptr, _Tpvec0 &a0, _Tpvec0 &b0) { \
-    _Tpvec1 a1, b1;                                                            \
-    v_load_deinterleave((const _Tp1 *)ptr, a1, b1);                            \
-    a0 = v_reinterpret_as_##suffix0(a1);                                       \
-    b0 = v_reinterpret_as_##suffix0(b1);                                       \
-  }                                                                            \
-  inline void v_load_deinterleave(const _Tp0 *ptr, _Tpvec0 &a0, _Tpvec0 &b0,   \
-                                  _Tpvec0 &c0) {                               \
-    _Tpvec1 a1, b1, c1;                                                        \
-    v_load_deinterleave((const _Tp1 *)ptr, a1, b1, c1);                        \
-    a0 = v_reinterpret_as_##suffix0(a1);                                       \
-    b0 = v_reinterpret_as_##suffix0(b1);                                       \
-    c0 = v_reinterpret_as_##suffix0(c1);                                       \
-  }                                                                            \
-  inline void v_load_deinterleave(const _Tp0 *ptr, _Tpvec0 &a0, _Tpvec0 &b0,   \
-                                  _Tpvec0 &c0, _Tpvec0 &d0) {                  \
-    _Tpvec1 a1, b1, c1, d1;                                                    \
-    v_load_deinterleave((const _Tp1 *)ptr, a1, b1, c1, d1);                    \
-    a0 = v_reinterpret_as_##suffix0(a1);                                       \
-    b0 = v_reinterpret_as_##suffix0(b1);                                       \
-    c0 = v_reinterpret_as_##suffix0(c1);                                       \
-    d0 = v_reinterpret_as_##suffix0(d1);                                       \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp0 *ptr, const _Tpvec0 &a0, const _Tpvec0 &b0,                         \
-      hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {                        \
-    _Tpvec1 a1 = v_reinterpret_as_##suffix1(a0);                               \
-    _Tpvec1 b1 = v_reinterpret_as_##suffix1(b0);                               \
-    v_store_interleave((_Tp1 *)ptr, a1, b1);                                   \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp0 *ptr, const _Tpvec0 &a0, const _Tpvec0 &b0, const _Tpvec0 &c0,      \
-      hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {                        \
-    _Tpvec1 a1 = v_reinterpret_as_##suffix1(a0);                               \
-    _Tpvec1 b1 = v_reinterpret_as_##suffix1(b0);                               \
-    _Tpvec1 c1 = v_reinterpret_as_##suffix1(c0);                               \
-    v_store_interleave((_Tp1 *)ptr, a1, b1, c1);                               \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp0 *ptr, const _Tpvec0 &a0, const _Tpvec0 &b0, const _Tpvec0 &c0,      \
-      const _Tpvec0 &d0, hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {     \
-    _Tpvec1 a1 = v_reinterpret_as_##suffix1(a0);                               \
-    _Tpvec1 b1 = v_reinterpret_as_##suffix1(b0);                               \
-    _Tpvec1 c1 = v_reinterpret_as_##suffix1(c0);                               \
-    _Tpvec1 d1 = v_reinterpret_as_##suffix1(d0);                               \
-    v_store_interleave((_Tp1 *)ptr, a1, b1, c1, d1);                           \
-  }
-
-OPENCV_HAL_IMPL_LSX_LOADSTORE_INTERLEAVE(v_int8x16, schar, s8, v_uint8x16,
-                                         uchar, u8)
-OPENCV_HAL_IMPL_LSX_LOADSTORE_INTERLEAVE(v_int16x8, short, s16, v_uint16x8,
-                                         ushort, u16)
-OPENCV_HAL_IMPL_LSX_LOADSTORE_INTERLEAVE(v_int32x4, int, s32, v_uint32x4,
-                                         unsigned, u32)
-OPENCV_HAL_IMPL_LSX_LOADSTORE_INTERLEAVE(v_float32x4, float, f32, v_uint32x4,
-                                         unsigned, u32)
-OPENCV_HAL_IMPL_LSX_LOADSTORE_INTERLEAVE(v_int64x2, int64, s64, v_uint64x2,
-                                         uint64, u64)
-OPENCV_HAL_IMPL_LSX_LOADSTORE_INTERLEAVE(v_float64x2, double, f64, v_uint64x2,
-                                         uint64, u64)
-
-//
-// FP16
-//
-
-inline v_float32x4 v_load_expand(const hfloat *ptr) {
-#if CV_FP16
-  return v_float32x4(__lsx_vfcvtl_s_h((__m128)__lsx_vld(ptr, 0)));
-#else
-  float CV_DECL_ALIGNED(32) buf[4];
-  for (int i = 0; i < 4; i++)
-    buf[i] = (float)ptr[i];
-  return v_float32x4((__m128)__lsx_vld(buf, 0));
-#endif
-}
-
-inline void v_pack_store(hfloat *ptr, const v_float32x4 &a) {
-#if CV_FP16
-  __m128i res = (__m218i)__lsx_vfcvt_h_s(a.val, a.val);
-  __lsx_vstelm_d(res, ptr, 0, 0);
-#else
-  float CV_DECL_ALIGNED(32) buf[4];
-  v_store_aligned(buf, a);
-  for (int i = 0; i < 4; i++)
-    ptr[i] = hfloat(buf[i]);
-#endif
-}
-
-//
-// end of FP16
-//
-
-inline void v_cleanup() {}
-
-#include "intrin_math.hpp"
-inline v_float32x4 v_exp(const v_float32x4 &x) {
-  return v_exp_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline v_float32x4 v_log(const v_float32x4 &x) {
-  return v_log_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline void v_sincos(const v_float32x4 &x, v_float32x4 &s, v_float32x4 &c) {
-  v_sincos_default_32f<v_float32x4, v_int32x4>(x, s, c);
-}
-inline v_float32x4 v_sin(const v_float32x4 &x) {
-  return v_sin_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline v_float32x4 v_cos(const v_float32x4 &x) {
-  return v_cos_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline v_float32x4 v_erf(const v_float32x4 &x) {
-  return v_erf_default_32f<v_float32x4, v_int32x4>(x);
-}
-
-inline v_float64x2 v_exp(const v_float64x2 &x) {
-  return v_exp_default_64f<v_float64x2, v_int64x2>(x);
-}
-inline v_float64x2 v_log(const v_float64x2 &x) {
-  return v_log_default_64f<v_float64x2, v_int64x2>(x);
-}
-inline void v_sincos(const v_float64x2 &x, v_float64x2 &s, v_float64x2 &c) {
-  v_sincos_default_64f<v_float64x2, v_int64x2>(x, s, c);
-}
-inline v_float64x2 v_sin(const v_float64x2 &x) {
-  return v_sin_default_64f<v_float64x2, v_int64x2>(x);
-}
-inline v_float64x2 v_cos(const v_float64x2 &x) {
-  return v_cos_default_64f<v_float64x2, v_int64x2>(x);
-}
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_END
-
-//! @endcond
-
-} // namespace cv
-
-#endif // OPENCV_HAL_INTRIN_LSX_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_math.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_math.hpp
deleted file mode 100644
index 0aec02a8e2..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_math.hpp
+++ /dev/null
@@ -1,772 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html
-
-/* Universal Intrinsics implementation of sin, cos, exp and log
-
-   Inspired by Intel Approximate Math library, and based on the
-   corresponding algorithms of the cephes math library
-*/
-
-/* Copyright (C) 2010,2011  RJVB - extensions */
-/* Copyright (C) 2011  Julien Pommier
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-
-  (this is the zlib license)
-*/
-#ifndef OPENCV_HAL_INTRIN_MATH_HPP
-#define OPENCV_HAL_INTRIN_MATH_HPP
-
-//! @name Exponential
-//! @{
-// Implementation is the same as float32 vector.
-template <typename _TpVec16F, typename _TpVec16S>
-inline _TpVec16F v_exp_default_16f(const _TpVec16F &x) {
-  const _TpVec16F _vexp_lo_f16 = v_setall_<_TpVec16F>(-10.7421875f);
-  const _TpVec16F _vexp_hi_f16 = v_setall_<_TpVec16F>(11.f);
-  const _TpVec16F _vexp_half_fp16 = v_setall_<_TpVec16F>(0.5f);
-  const _TpVec16F _vexp_one_fp16 = v_setall_<_TpVec16F>(1.f);
-  const _TpVec16F _vexp_LOG2EF_f16 = v_setall_<_TpVec16F>(1.44269504088896341f);
-  const _TpVec16F _vexp_C1_f16 = v_setall_<_TpVec16F>(-6.93359375E-1f);
-  const _TpVec16F _vexp_C2_f16 = v_setall_<_TpVec16F>(2.12194440E-4f);
-  const _TpVec16F _vexp_p0_f16 = v_setall_<_TpVec16F>(1.9875691500E-4f);
-  const _TpVec16F _vexp_p1_f16 = v_setall_<_TpVec16F>(1.3981999507E-3f);
-  const _TpVec16F _vexp_p2_f16 = v_setall_<_TpVec16F>(8.3334519073E-3f);
-  const _TpVec16F _vexp_p3_f16 = v_setall_<_TpVec16F>(4.1665795894E-2f);
-  const _TpVec16F _vexp_p4_f16 = v_setall_<_TpVec16F>(1.6666665459E-1f);
-  const _TpVec16F _vexp_p5_f16 = v_setall_<_TpVec16F>(5.0000001201E-1f);
-
-  _TpVec16F _vexp_, _vexp_x, _vexp_y, _vexp_xx;
-  _TpVec16S _vexp_mm;
-  const _TpVec16S _vexp_bias_s16 = v_setall_<_TpVec16S>((short)0xf);
-
-  // compute exponential of x
-  _vexp_x = v_max(x, _vexp_lo_f16);
-  _vexp_x = v_min(_vexp_x, _vexp_hi_f16);
-
-  _vexp_ = v_fma(_vexp_x, _vexp_LOG2EF_f16, _vexp_half_fp16);
-  _vexp_mm = v_floor(_vexp_);
-  _vexp_ = v_cvt_f16(_vexp_mm);
-  _vexp_mm = v_add(_vexp_mm, _vexp_bias_s16);
-  _vexp_mm = v_shl(_vexp_mm, 10);
-
-  _vexp_x = v_fma(_vexp_, _vexp_C1_f16, _vexp_x);
-  _vexp_x = v_fma(_vexp_, _vexp_C2_f16, _vexp_x);
-  _vexp_xx = v_mul(_vexp_x, _vexp_x);
-
-  _vexp_y = v_fma(_vexp_x, _vexp_p0_f16, _vexp_p1_f16);
-  _vexp_y = v_fma(_vexp_y, _vexp_x, _vexp_p2_f16);
-  _vexp_y = v_fma(_vexp_y, _vexp_x, _vexp_p3_f16);
-  _vexp_y = v_fma(_vexp_y, _vexp_x, _vexp_p4_f16);
-  _vexp_y = v_fma(_vexp_y, _vexp_x, _vexp_p5_f16);
-
-  _vexp_y = v_fma(_vexp_y, _vexp_xx, _vexp_x);
-  _vexp_y = v_add(_vexp_y, _vexp_one_fp16);
-  _vexp_y = v_mul(_vexp_y, v_reinterpret_as_f16(_vexp_mm));
-
-  // exp(NAN) -> NAN
-  _TpVec16F mask_not_nan = v_not_nan(x);
-  return v_select(mask_not_nan, _vexp_y,
-                  v_reinterpret_as_f16(v_setall_<_TpVec16S>((short)0x7e00)));
-}
-
-template <typename _TpVec32F, typename _TpVec32S>
-inline _TpVec32F v_exp_default_32f(const _TpVec32F &x) {
-  const _TpVec32F _vexp_lo_f32 = v_setall_<_TpVec32F>(-88.3762626647949f);
-  const _TpVec32F _vexp_hi_f32 = v_setall_<_TpVec32F>(89.f);
-  const _TpVec32F _vexp_half_fp32 = v_setall_<_TpVec32F>(0.5f);
-  const _TpVec32F _vexp_one_fp32 = v_setall_<_TpVec32F>(1.f);
-  const _TpVec32F _vexp_LOG2EF_f32 = v_setall_<_TpVec32F>(1.44269504088896341f);
-  const _TpVec32F _vexp_C1_f32 = v_setall_<_TpVec32F>(-6.93359375E-1f);
-  const _TpVec32F _vexp_C2_f32 = v_setall_<_TpVec32F>(2.12194440E-4f);
-  const _TpVec32F _vexp_p0_f32 = v_setall_<_TpVec32F>(1.9875691500E-4f);
-  const _TpVec32F _vexp_p1_f32 = v_setall_<_TpVec32F>(1.3981999507E-3f);
-  const _TpVec32F _vexp_p2_f32 = v_setall_<_TpVec32F>(8.3334519073E-3f);
-  const _TpVec32F _vexp_p3_f32 = v_setall_<_TpVec32F>(4.1665795894E-2f);
-  const _TpVec32F _vexp_p4_f32 = v_setall_<_TpVec32F>(1.6666665459E-1f);
-  const _TpVec32F _vexp_p5_f32 = v_setall_<_TpVec32F>(5.0000001201E-1f);
-
-  _TpVec32F _vexp_, _vexp_x, _vexp_y, _vexp_xx;
-  _TpVec32S _vexp_mm;
-  const _TpVec32S _vexp_bias_s32 = v_setall_<_TpVec32S>((int)0x7f);
-
-  // compute exponential of x
-  _vexp_x = v_max(x, _vexp_lo_f32);
-  _vexp_x = v_min(_vexp_x, _vexp_hi_f32);
-
-  _vexp_ = v_fma(_vexp_x, _vexp_LOG2EF_f32, _vexp_half_fp32);
-  _vexp_mm = v_floor(_vexp_);
-  _vexp_ = v_cvt_f32(_vexp_mm);
-  _vexp_mm = v_add(_vexp_mm, _vexp_bias_s32);
-  _vexp_mm = v_shl(_vexp_mm, 23);
-
-  _vexp_x = v_fma(_vexp_, _vexp_C1_f32, _vexp_x);
-  _vexp_x = v_fma(_vexp_, _vexp_C2_f32, _vexp_x);
-  _vexp_xx = v_mul(_vexp_x, _vexp_x);
-
-  _vexp_y = v_fma(_vexp_x, _vexp_p0_f32, _vexp_p1_f32);
-  _vexp_y = v_fma(_vexp_y, _vexp_x, _vexp_p2_f32);
-  _vexp_y = v_fma(_vexp_y, _vexp_x, _vexp_p3_f32);
-  _vexp_y = v_fma(_vexp_y, _vexp_x, _vexp_p4_f32);
-  _vexp_y = v_fma(_vexp_y, _vexp_x, _vexp_p5_f32);
-
-  _vexp_y = v_fma(_vexp_y, _vexp_xx, _vexp_x);
-  _vexp_y = v_add(_vexp_y, _vexp_one_fp32);
-  _vexp_y = v_mul(_vexp_y, v_reinterpret_as_f32(_vexp_mm));
-
-  // exp(NAN) -> NAN
-  _TpVec32F mask_not_nan = v_not_nan(x);
-  return v_select(mask_not_nan, _vexp_y,
-                  v_reinterpret_as_f32(v_setall_<_TpVec32S>((int)0x7fc00000)));
-}
-
-template <typename _TpVec64F, typename _TpVec64S>
-inline _TpVec64F v_exp_default_64f(const _TpVec64F &x) {
-  const _TpVec64F _vexp_lo_f64 =
-      v_setall_<_TpVec64F>(-709.43613930310391424428);
-  const _TpVec64F _vexp_hi_f64 = v_setall_<_TpVec64F>(710.);
-  const _TpVec64F _vexp_half_f64 = v_setall_<_TpVec64F>(0.5);
-  const _TpVec64F _vexp_one_f64 = v_setall_<_TpVec64F>(1.0);
-  const _TpVec64F _vexp_two_f64 = v_setall_<_TpVec64F>(2.0);
-  const _TpVec64F _vexp_LOG2EF_f64 =
-      v_setall_<_TpVec64F>(1.44269504088896340736);
-  const _TpVec64F _vexp_C1_f64 = v_setall_<_TpVec64F>(-6.93145751953125E-1);
-  const _TpVec64F _vexp_C2_f64 =
-      v_setall_<_TpVec64F>(-1.42860682030941723212E-6);
-  const _TpVec64F _vexp_p0_f64 =
-      v_setall_<_TpVec64F>(1.26177193074810590878E-4);
-  const _TpVec64F _vexp_p1_f64 =
-      v_setall_<_TpVec64F>(3.02994407707441961300E-2);
-  const _TpVec64F _vexp_p2_f64 =
-      v_setall_<_TpVec64F>(9.99999999999999999910E-1);
-  const _TpVec64F _vexp_q0_f64 =
-      v_setall_<_TpVec64F>(3.00198505138664455042E-6);
-  const _TpVec64F _vexp_q1_f64 =
-      v_setall_<_TpVec64F>(2.52448340349684104192E-3);
-  const _TpVec64F _vexp_q2_f64 =
-      v_setall_<_TpVec64F>(2.27265548208155028766E-1);
-  const _TpVec64F _vexp_q3_f64 = v_setall_<_TpVec64F>(2.00000000000000000009E0);
-
-  _TpVec64F _vexp_, _vexp_x, _vexp_y, _vexp_z, _vexp_xx;
-  _TpVec64S _vexp_mm;
-  const _TpVec64S _vexp_bias_s64 = v_setall_<_TpVec64S>((int64)0x3ff);
-
-  // compute exponential of x
-  _vexp_x = v_max(x, _vexp_lo_f64);
-  _vexp_x = v_min(_vexp_x, _vexp_hi_f64);
-
-  _vexp_ = v_fma(_vexp_x, _vexp_LOG2EF_f64, _vexp_half_f64);
-  _vexp_mm = v_expand_low(v_floor(_vexp_));
-  _vexp_ = v_cvt_f64(_vexp_mm);
-  _vexp_mm = v_add(_vexp_mm, _vexp_bias_s64);
-  _vexp_mm = v_shl(_vexp_mm, 52);
-
-  _vexp_x = v_fma(_vexp_, _vexp_C1_f64, _vexp_x);
-  _vexp_x = v_fma(_vexp_, _vexp_C2_f64, _vexp_x);
-  _vexp_xx = v_mul(_vexp_x, _vexp_x);
-
-  _vexp_y = v_fma(_vexp_xx, _vexp_p0_f64, _vexp_p1_f64);
-  _vexp_y = v_fma(_vexp_y, _vexp_xx, _vexp_p2_f64);
-  _vexp_y = v_mul(_vexp_y, _vexp_x);
-
-  _vexp_z = v_fma(_vexp_xx, _vexp_q0_f64, _vexp_q1_f64);
-  _vexp_z = v_fma(_vexp_xx, _vexp_z, _vexp_q2_f64);
-  _vexp_z = v_fma(_vexp_xx, _vexp_z, _vexp_q3_f64);
-
-  _vexp_z = v_div(_vexp_y, v_sub(_vexp_z, _vexp_y));
-  _vexp_z = v_fma(_vexp_two_f64, _vexp_z, _vexp_one_f64);
-  _vexp_z = v_mul(_vexp_z, v_reinterpret_as_f64(_vexp_mm));
-
-  // exp(NAN) -> NAN
-  _TpVec64F mask_not_nan = v_not_nan(x);
-  return v_select(
-      mask_not_nan, _vexp_z,
-      v_reinterpret_as_f64(v_setall_<_TpVec64S>((int64)0x7FF8000000000000)));
-}
-//! @}
-
-//! @name Natural Logarithm
-//! @{
-template <typename _TpVec16F, typename _TpVec16S>
-inline _TpVec16F v_log_default_16f(const _TpVec16F &x) {
-  const _TpVec16F _vlog_one_fp16 = v_setall_<_TpVec16F>(1.0f);
-  const _TpVec16F _vlog_SQRTHF_fp16 =
-      v_setall_<_TpVec16F>(0.707106781186547524f);
-  const _TpVec16F _vlog_q1_fp16 = v_setall_<_TpVec16F>(-2.12194440E-4f);
-  const _TpVec16F _vlog_q2_fp16 = v_setall_<_TpVec16F>(0.693359375f);
-  const _TpVec16F _vlog_p0_fp16 = v_setall_<_TpVec16F>(7.0376836292E-2f);
-  const _TpVec16F _vlog_p1_fp16 = v_setall_<_TpVec16F>(-1.1514610310E-1f);
-  const _TpVec16F _vlog_p2_fp16 = v_setall_<_TpVec16F>(1.1676998740E-1f);
-  const _TpVec16F _vlog_p3_fp16 = v_setall_<_TpVec16F>(-1.2420140846E-1f);
-  const _TpVec16F _vlog_p4_fp16 = v_setall_<_TpVec16F>(1.4249322787E-1f);
-  const _TpVec16F _vlog_p5_fp16 = v_setall_<_TpVec16F>(-1.6668057665E-1f);
-  const _TpVec16F _vlog_p6_fp16 = v_setall_<_TpVec16F>(2.0000714765E-1f);
-  const _TpVec16F _vlog_p7_fp16 = v_setall_<_TpVec16F>(-2.4999993993E-1f);
-  const _TpVec16F _vlog_p8_fp16 = v_setall_<_TpVec16F>(3.3333331174E-1f);
-
-  _TpVec16F _vlog_x, _vlog_e, _vlog_y, _vlog_z, _vlog_tmp;
-  _TpVec16S _vlog_ux, _vlog_emm0;
-  const _TpVec16S _vlog_inv_mant_mask_s16 =
-      v_setall_<_TpVec16S>((short)~0x7c00);
-
-  _vlog_ux = v_reinterpret_as_s16(x);
-  _vlog_emm0 = v_shr(_vlog_ux, 10);
-
-  _vlog_ux = v_and(_vlog_ux, _vlog_inv_mant_mask_s16);
-  _vlog_ux = v_or(_vlog_ux, v_reinterpret_as_s16(v_setall_<_TpVec16F>(0.5f)));
-  _vlog_x = v_reinterpret_as_f16(_vlog_ux);
-
-  _vlog_emm0 = v_sub(_vlog_emm0, v_setall_<_TpVec16S>((short)0xf));
-  _vlog_e = v_cvt_f16(_vlog_emm0);
-
-  _vlog_e = v_add(_vlog_e, _vlog_one_fp16);
-
-  _TpVec16F _vlog_mask = v_lt(_vlog_x, _vlog_SQRTHF_fp16);
-  _vlog_tmp = v_and(_vlog_x, _vlog_mask);
-  _vlog_x = v_sub(_vlog_x, _vlog_one_fp16);
-  _vlog_e = v_sub(_vlog_e, v_and(_vlog_one_fp16, _vlog_mask));
-  _vlog_x = v_add(_vlog_x, _vlog_tmp);
-
-  _vlog_z = v_mul(_vlog_x, _vlog_x);
-
-  _vlog_y = v_fma(_vlog_p0_fp16, _vlog_x, _vlog_p1_fp16);
-  _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p2_fp16);
-  _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p3_fp16);
-  _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p4_fp16);
-  _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p5_fp16);
-  _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p6_fp16);
-  _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p7_fp16);
-  _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p8_fp16);
-  _vlog_y = v_mul(_vlog_y, _vlog_x);
-  _vlog_y = v_mul(_vlog_y, _vlog_z);
-
-  _vlog_y = v_fma(_vlog_e, _vlog_q1_fp16, _vlog_y);
-
-  _vlog_y = v_sub(_vlog_y, v_mul(_vlog_z, v_setall_<_TpVec16F>(0.5f)));
-
-  _vlog_x = v_add(_vlog_x, _vlog_y);
-  _vlog_x = v_fma(_vlog_e, _vlog_q2_fp16, _vlog_x);
-  // log(0) -> -INF
-  _TpVec16F mask_zero = v_eq(x, v_setzero_<_TpVec16F>());
-  _vlog_x = v_select(mask_zero,
-                     v_reinterpret_as_f16(v_setall_<_TpVec16S>((short)0xfc00)),
-                     _vlog_x);
-  // log(NEG), log(NAN) -> NAN
-  _TpVec16F mask_not_nan = v_ge(x, v_setzero_<_TpVec16F>());
-  _vlog_x = v_select(mask_not_nan, _vlog_x,
-                     v_reinterpret_as_f16(v_setall_<_TpVec16S>((short)0x7e00)));
-  // log(INF) -> INF
-  _TpVec16F mask_inf =
-      v_eq(x, v_reinterpret_as_f16(v_setall_<_TpVec16S>((short)0x7c00)));
-  _vlog_x = v_select(mask_inf, x, _vlog_x);
-  return _vlog_x;
-}
-
-template <typename _TpVec32F, typename _TpVec32S>
-inline _TpVec32F v_log_default_32f(const _TpVec32F &x) {
-  const _TpVec32F _vlog_one_fp32 = v_setall_<_TpVec32F>(1.0f);
-  const _TpVec32F _vlog_SQRTHF_fp32 =
-      v_setall_<_TpVec32F>(0.707106781186547524f);
-  const _TpVec32F _vlog_q1_fp32 = v_setall_<_TpVec32F>(-2.12194440E-4f);
-  const _TpVec32F _vlog_q2_fp32 = v_setall_<_TpVec32F>(0.693359375f);
-  const _TpVec32F _vlog_p0_fp32 = v_setall_<_TpVec32F>(7.0376836292E-2f);
-  const _TpVec32F _vlog_p1_fp32 = v_setall_<_TpVec32F>(-1.1514610310E-1f);
-  const _TpVec32F _vlog_p2_fp32 = v_setall_<_TpVec32F>(1.1676998740E-1f);
-  const _TpVec32F _vlog_p3_fp32 = v_setall_<_TpVec32F>(-1.2420140846E-1f);
-  const _TpVec32F _vlog_p4_fp32 = v_setall_<_TpVec32F>(1.4249322787E-1f);
-  const _TpVec32F _vlog_p5_fp32 = v_setall_<_TpVec32F>(-1.6668057665E-1f);
-  const _TpVec32F _vlog_p6_fp32 = v_setall_<_TpVec32F>(2.0000714765E-1f);
-  const _TpVec32F _vlog_p7_fp32 = v_setall_<_TpVec32F>(-2.4999993993E-1f);
-  const _TpVec32F _vlog_p8_fp32 = v_setall_<_TpVec32F>(3.3333331174E-1f);
-
-  _TpVec32F _vlog_x, _vlog_e, _vlog_y, _vlog_z, _vlog_tmp;
-  _TpVec32S _vlog_ux, _vlog_emm0;
-  const _TpVec32S _vlog_inv_mant_mask_s32 =
-      v_setall_<_TpVec32S>((int)~0x7f800000);
-
-  _vlog_ux = v_reinterpret_as_s32(x);
-  _vlog_emm0 = v_shr(_vlog_ux, 23);
-
-  _vlog_ux = v_and(_vlog_ux, _vlog_inv_mant_mask_s32);
-  _vlog_ux = v_or(_vlog_ux, v_reinterpret_as_s32(v_setall_<_TpVec32F>(0.5f)));
-  _vlog_x = v_reinterpret_as_f32(_vlog_ux);
-
-  _vlog_emm0 = v_sub(_vlog_emm0, v_setall_<_TpVec32S>((int)0x7f));
-  _vlog_e = v_cvt_f32(_vlog_emm0);
-
-  _vlog_e = v_add(_vlog_e, _vlog_one_fp32);
-
-  _TpVec32F _vlog_mask = v_lt(_vlog_x, _vlog_SQRTHF_fp32);
-  _vlog_tmp = v_and(_vlog_x, _vlog_mask);
-  _vlog_x = v_sub(_vlog_x, _vlog_one_fp32);
-  _vlog_e = v_sub(_vlog_e, v_and(_vlog_one_fp32, _vlog_mask));
-  _vlog_x = v_add(_vlog_x, _vlog_tmp);
-
-  _vlog_z = v_mul(_vlog_x, _vlog_x);
-
-  _vlog_y = v_fma(_vlog_p0_fp32, _vlog_x, _vlog_p1_fp32);
-  _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p2_fp32);
-  _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p3_fp32);
-  _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p4_fp32);
-  _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p5_fp32);
-  _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p6_fp32);
-  _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p7_fp32);
-  _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p8_fp32);
-  _vlog_y = v_mul(_vlog_y, _vlog_x);
-  _vlog_y = v_mul(_vlog_y, _vlog_z);
-
-  _vlog_y = v_fma(_vlog_e, _vlog_q1_fp32, _vlog_y);
-
-  _vlog_y = v_sub(_vlog_y, v_mul(_vlog_z, v_setall_<_TpVec32F>(0.5f)));
-
-  _vlog_x = v_add(_vlog_x, _vlog_y);
-  _vlog_x = v_fma(_vlog_e, _vlog_q2_fp32, _vlog_x);
-  // log(0) -> -INF
-  _TpVec32F mask_zero = v_eq(x, v_setzero_<_TpVec32F>());
-  _vlog_x = v_select(
-      mask_zero, v_reinterpret_as_f32(v_setall_<_TpVec32S>((int)0xff800000)),
-      _vlog_x);
-  // log(NEG), log(NAN) -> NAN
-  _TpVec32F mask_not_nan = v_ge(x, v_setzero_<_TpVec32F>());
-  _vlog_x =
-      v_select(mask_not_nan, _vlog_x,
-               v_reinterpret_as_f32(v_setall_<_TpVec32S>((int)0x7fc00000)));
-  // log(INF) -> INF
-  _TpVec32F mask_inf =
-      v_eq(x, v_reinterpret_as_f32(v_setall_<_TpVec32S>((int)0x7f800000)));
-  _vlog_x = v_select(mask_inf, x, _vlog_x);
-  return _vlog_x;
-}
-
-template <typename _TpVec64F, typename _TpVec64S>
-inline _TpVec64F v_log_default_64f(const _TpVec64F &x) {
-  const _TpVec64F _vlog_one_fp64 = v_setall_<_TpVec64F>(1.0);
-  const _TpVec64F _vlog_SQRTHF_fp64 =
-      v_setall_<_TpVec64F>(0.7071067811865475244);
-  const _TpVec64F _vlog_p0_fp64 =
-      v_setall_<_TpVec64F>(1.01875663804580931796E-4);
-  const _TpVec64F _vlog_p1_fp64 =
-      v_setall_<_TpVec64F>(4.97494994976747001425E-1);
-  const _TpVec64F _vlog_p2_fp64 = v_setall_<_TpVec64F>(4.70579119878881725854);
-  const _TpVec64F _vlog_p3_fp64 =
-      v_setall_<_TpVec64F>(1.44989225341610930846E1);
-  const _TpVec64F _vlog_p4_fp64 =
-      v_setall_<_TpVec64F>(1.79368678507819816313E1);
-  const _TpVec64F _vlog_p5_fp64 = v_setall_<_TpVec64F>(7.70838733755885391666);
-  const _TpVec64F _vlog_q0_fp64 =
-      v_setall_<_TpVec64F>(1.12873587189167450590E1);
-  const _TpVec64F _vlog_q1_fp64 =
-      v_setall_<_TpVec64F>(4.52279145837532221105E1);
-  const _TpVec64F _vlog_q2_fp64 =
-      v_setall_<_TpVec64F>(8.29875266912776603211E1);
-  const _TpVec64F _vlog_q3_fp64 =
-      v_setall_<_TpVec64F>(7.11544750618563894466E1);
-  const _TpVec64F _vlog_q4_fp64 =
-      v_setall_<_TpVec64F>(2.31251620126765340583E1);
-
-  const _TpVec64F _vlog_C0_fp64 =
-      v_setall_<_TpVec64F>(2.121944400546905827679e-4);
-  const _TpVec64F _vlog_C1_fp64 = v_setall_<_TpVec64F>(0.693359375);
-
-  _TpVec64F _vlog_x, _vlog_e, _vlog_y, _vlog_z, _vlog_tmp, _vlog_xx;
-  _TpVec64S _vlog_ux, _vlog_emm0;
-  const _TpVec64S _vlog_inv_mant_mask_s64 =
-      v_setall_<_TpVec64S>((int64)~0x7ff0000000000000);
-
-  _vlog_ux = v_reinterpret_as_s64(x);
-  _vlog_emm0 = v_shr(_vlog_ux, 52);
-
-  _vlog_ux = v_and(_vlog_ux, _vlog_inv_mant_mask_s64);
-  _vlog_ux = v_or(_vlog_ux, v_reinterpret_as_s64(v_setall_<_TpVec64F>(0.5)));
-  _vlog_x = v_reinterpret_as_f64(_vlog_ux);
-
-  _vlog_emm0 = v_sub(_vlog_emm0, v_setall_<_TpVec64S>((int64)0x3ff));
-  _vlog_e = v_cvt_f64(_vlog_emm0);
-
-  _vlog_e = v_add(_vlog_e, _vlog_one_fp64);
-
-  _TpVec64F _vlog_mask = v_lt(_vlog_x, _vlog_SQRTHF_fp64);
-  _vlog_tmp = v_and(_vlog_x, _vlog_mask);
-  _vlog_x = v_sub(_vlog_x, _vlog_one_fp64);
-  _vlog_e = v_sub(_vlog_e, v_and(_vlog_one_fp64, _vlog_mask));
-  _vlog_x = v_add(_vlog_x, _vlog_tmp);
-
-  _vlog_xx = v_mul(_vlog_x, _vlog_x);
-
-  _vlog_y = v_fma(_vlog_p0_fp64, _vlog_x, _vlog_p1_fp64);
-  _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p2_fp64);
-  _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p3_fp64);
-  _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p4_fp64);
-  _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p5_fp64);
-  _vlog_y = v_mul(_vlog_y, _vlog_x);
-  _vlog_y = v_mul(_vlog_y, _vlog_xx);
-
-  _vlog_z = v_add(_vlog_x, _vlog_q0_fp64);
-  _vlog_z = v_fma(_vlog_z, _vlog_x, _vlog_q1_fp64);
-  _vlog_z = v_fma(_vlog_z, _vlog_x, _vlog_q2_fp64);
-  _vlog_z = v_fma(_vlog_z, _vlog_x, _vlog_q3_fp64);
-  _vlog_z = v_fma(_vlog_z, _vlog_x, _vlog_q4_fp64);
-
-  _vlog_z = v_div(_vlog_y, _vlog_z);
-  _vlog_z = v_sub(_vlog_z, v_mul(_vlog_e, _vlog_C0_fp64));
-  _vlog_z = v_sub(_vlog_z, v_mul(_vlog_xx, v_setall_<_TpVec64F>(0.5)));
-
-  _vlog_z = v_add(_vlog_z, _vlog_x);
-  _vlog_z = v_fma(_vlog_e, _vlog_C1_fp64, _vlog_z);
-
-  // log(0) -> -INF
-  _TpVec64F mask_zero = v_eq(x, v_setzero_<_TpVec64F>());
-  _vlog_z = v_select(
-      mask_zero,
-      v_reinterpret_as_f64(v_setall_<_TpVec64S>((int64)0xfff0000000000000)),
-      _vlog_z);
-  // log(NEG), log(NAN) -> NAN
-  _TpVec64F mask_not_nan = v_ge(x, v_setzero_<_TpVec64F>());
-  _vlog_z = v_select(
-      mask_not_nan, _vlog_z,
-      v_reinterpret_as_f64(v_setall_<_TpVec64S>((int64)0x7ff8000000000000)));
-  // log(INF) -> INF
-  _TpVec64F mask_inf = v_eq(
-      x, v_reinterpret_as_f64(v_setall_<_TpVec64S>((int64)0x7ff0000000000000)));
-  _vlog_z = v_select(mask_inf, x, _vlog_z);
-  return _vlog_z;
-}
-//! @}
-
-//! @name Sine and Cosine
-//! @{
-template <typename _TpVec16F, typename _TpVec16S>
-inline void v_sincos_default_16f(const _TpVec16F &x, _TpVec16F &ysin,
-                                 _TpVec16F &ycos) {
-  const _TpVec16F v_cephes_FOPI =
-      v_setall_<_TpVec16F>(hfloat(1.27323954473516f)); // 4 / M_PI
-  const _TpVec16F v_minus_DP1 = v_setall_<_TpVec16F>(hfloat(-0.78515625f));
-  const _TpVec16F v_minus_DP2 =
-      v_setall_<_TpVec16F>(hfloat(-2.4187564849853515625E-4f));
-  const _TpVec16F v_minus_DP3 =
-      v_setall_<_TpVec16F>(hfloat(-3.77489497744594108E-8f));
-  const _TpVec16F v_sincof_p0 = v_setall_<_TpVec16F>(hfloat(-1.9515295891E-4f));
-  const _TpVec16F v_sincof_p1 = v_setall_<_TpVec16F>(hfloat(8.3321608736E-3f));
-  const _TpVec16F v_sincof_p2 = v_setall_<_TpVec16F>(hfloat(-1.6666654611E-1f));
-  const _TpVec16F v_coscof_p0 =
-      v_setall_<_TpVec16F>(hfloat(2.443315711809948E-5f));
-  const _TpVec16F v_coscof_p1 =
-      v_setall_<_TpVec16F>(hfloat(-1.388731625493765E-3f));
-  const _TpVec16F v_coscof_p2 =
-      v_setall_<_TpVec16F>(hfloat(4.166664568298827E-2f));
-  const _TpVec16F v_nan =
-      v_reinterpret_as_f16(v_setall_<_TpVec16S>((short)0x7e00));
-  const _TpVec16F v_neg_zero = v_setall_<_TpVec16F>(hfloat(-0.f));
-
-  _TpVec16F _vx, _vy, sign_mask_sin, sign_mask_cos;
-  _TpVec16S emm2;
-
-  sign_mask_sin = v_lt(x, v_setzero_<_TpVec16F>());
-  _vx = v_abs(x);
-  _vy = v_mul(_vx, v_cephes_FOPI);
-
-  emm2 = v_trunc(_vy);
-  emm2 = v_add(emm2, v_setall_<_TpVec16S>((short)1));
-  emm2 = v_and(emm2, v_setall_<_TpVec16S>((short)~1));
-  _vy = v_cvt_f16(emm2);
-
-  _TpVec16F poly_mask =
-      v_reinterpret_as_f16(v_eq(v_and(emm2, v_setall_<_TpVec16S>((short)2)),
-                                v_setall_<_TpVec16S>((short)0)));
-
-  _vx = v_fma(_vy, v_minus_DP1, _vx);
-  _vx = v_fma(_vy, v_minus_DP2, _vx);
-  _vx = v_fma(_vy, v_minus_DP3, _vx);
-
-  sign_mask_sin = v_xor(
-      sign_mask_sin,
-      v_reinterpret_as_f16(v_eq(v_and(emm2, v_setall_<_TpVec16S>((short)4)),
-                                v_setall_<_TpVec16S>((short)0))));
-  sign_mask_cos = v_reinterpret_as_f16(
-      v_eq(v_and(v_sub(emm2, v_setall_<_TpVec16S>((short)2)),
-                 v_setall_<_TpVec16S>((short)4)),
-           v_setall_<_TpVec16S>((short)0)));
-
-  _TpVec16F _vxx = v_mul(_vx, _vx);
-  _TpVec16F y1, y2;
-
-  y1 = v_fma(v_coscof_p0, _vxx, v_coscof_p1);
-  y1 = v_fma(y1, _vxx, v_coscof_p2);
-  y1 = v_fma(y1, _vxx, v_setall_<_TpVec16F>(hfloat(-0.5f)));
-  y1 = v_fma(y1, _vxx, v_setall_<_TpVec16F>(hfloat(1.f)));
-
-  y2 = v_fma(v_sincof_p0, _vxx, v_sincof_p1);
-  y2 = v_fma(y2, _vxx, v_sincof_p2);
-  y2 = v_mul(y2, _vxx);
-  y2 = v_fma(y2, _vx, _vx);
-
-  ysin = v_select(poly_mask, y2, y1);
-  ycos = v_select(poly_mask, y1, y2);
-  ysin = v_select(sign_mask_sin, ysin, v_xor(v_neg_zero, ysin));
-  ycos = v_select(sign_mask_cos, v_xor(v_neg_zero, ycos), ycos);
-
-  // sincos(NAN) -> NAN, sincos(±INF) -> NAN
-  _TpVec16F mask_inf =
-      v_eq(_vx, v_reinterpret_as_f16(v_setall_<_TpVec16S>((short)0x7c00)));
-  _TpVec16F mask_nan = v_or(mask_inf, v_ne(x, x));
-  ysin = v_select(mask_nan, v_nan, ysin);
-  ycos = v_select(mask_nan, v_nan, ycos);
-}
-
-template <typename _TpVec16F, typename _TpVec16S>
-inline _TpVec16F v_sin_default_16f(const _TpVec16F &x) {
-  _TpVec16F ysin, ycos;
-  v_sincos_default_16f<_TpVec16F, _TpVec16S>(x, ysin, ycos);
-  return ysin;
-}
-
-template <typename _TpVec16F, typename _TpVec16S>
-inline _TpVec16F v_cos_default_16f(const _TpVec16F &x) {
-  _TpVec16F ysin, ycos;
-  v_sincos_default_16f<_TpVec16F, _TpVec16S>(x, ysin, ycos);
-  return ycos;
-}
-
-template <typename _TpVec32F, typename _TpVec32S>
-inline void v_sincos_default_32f(const _TpVec32F &x, _TpVec32F &ysin,
-                                 _TpVec32F &ycos) {
-  const _TpVec32F v_cephes_FOPI =
-      v_setall_<_TpVec32F>(1.27323954473516f); // 4 / M_PI
-  const _TpVec32F v_minus_DP1 = v_setall_<_TpVec32F>(-0.78515625f);
-  const _TpVec32F v_minus_DP2 =
-      v_setall_<_TpVec32F>(-2.4187564849853515625E-4f);
-  const _TpVec32F v_minus_DP3 = v_setall_<_TpVec32F>(-3.77489497744594108E-8f);
-  const _TpVec32F v_sincof_p0 = v_setall_<_TpVec32F>(-1.9515295891E-4f);
-  const _TpVec32F v_sincof_p1 = v_setall_<_TpVec32F>(8.3321608736E-3f);
-  const _TpVec32F v_sincof_p2 = v_setall_<_TpVec32F>(-1.6666654611E-1f);
-  const _TpVec32F v_coscof_p0 = v_setall_<_TpVec32F>(2.443315711809948E-5f);
-  const _TpVec32F v_coscof_p1 = v_setall_<_TpVec32F>(-1.388731625493765E-3f);
-  const _TpVec32F v_coscof_p2 = v_setall_<_TpVec32F>(4.166664568298827E-2f);
-  const _TpVec32F v_nan =
-      v_reinterpret_as_f32(v_setall_<_TpVec32S>((int)0x7fc00000));
-  const _TpVec32F v_neg_zero = v_setall_<_TpVec32F>(-0.f);
-
-  _TpVec32F _vx, _vy, sign_mask_sin, sign_mask_cos;
-  _TpVec32S emm2;
-
-  sign_mask_sin = v_lt(x, v_setzero_<_TpVec32F>());
-  _vx = v_abs(x);
-  _vy = v_mul(_vx, v_cephes_FOPI);
-
-  emm2 = v_trunc(_vy);
-  emm2 = v_add(emm2, v_setall_<_TpVec32S>(1));
-  emm2 = v_and(emm2, v_setall_<_TpVec32S>(~1));
-  _vy = v_cvt_f32(emm2);
-
-  _TpVec32F poly_mask = v_reinterpret_as_f32(
-      v_eq(v_and(emm2, v_setall_<_TpVec32S>(2)), v_setall_<_TpVec32S>(0)));
-
-  _vx = v_fma(_vy, v_minus_DP1, _vx);
-  _vx = v_fma(_vy, v_minus_DP2, _vx);
-  _vx = v_fma(_vy, v_minus_DP3, _vx);
-
-  sign_mask_sin =
-      v_xor(sign_mask_sin,
-            v_reinterpret_as_f32(v_eq(v_and(emm2, v_setall_<_TpVec32S>(4)),
-                                      v_setall_<_TpVec32S>(0))));
-  sign_mask_cos = v_reinterpret_as_f32(
-      v_eq(v_and(v_sub(emm2, v_setall_<_TpVec32S>(2)), v_setall_<_TpVec32S>(4)),
-           v_setall_<_TpVec32S>(0)));
-
-  _TpVec32F _vxx = v_mul(_vx, _vx);
-  _TpVec32F y1, y2;
-
-  y1 = v_fma(v_coscof_p0, _vxx, v_coscof_p1);
-  y1 = v_fma(y1, _vxx, v_coscof_p2);
-  y1 = v_fma(y1, _vxx, v_setall_<_TpVec32F>(-0.5f));
-  y1 = v_fma(y1, _vxx, v_setall_<_TpVec32F>(1.f));
-
-  y2 = v_fma(v_sincof_p0, _vxx, v_sincof_p1);
-  y2 = v_fma(y2, _vxx, v_sincof_p2);
-  y2 = v_mul(y2, _vxx);
-  y2 = v_fma(y2, _vx, _vx);
-
-  ysin = v_select(poly_mask, y2, y1);
-  ycos = v_select(poly_mask, y1, y2);
-  ysin = v_select(sign_mask_sin, ysin, v_xor(v_neg_zero, ysin));
-  ycos = v_select(sign_mask_cos, v_xor(v_neg_zero, ycos), ycos);
-
-  // sincos(NAN) -> NAN, sincos(±INF) -> NAN
-  _TpVec32F mask_inf =
-      v_eq(_vx, v_reinterpret_as_f32(v_setall_<_TpVec32S>((int)0x7f800000)));
-  _TpVec32F mask_nan = v_or(mask_inf, v_ne(x, x));
-  ysin = v_select(mask_nan, v_nan, ysin);
-  ycos = v_select(mask_nan, v_nan, ycos);
-}
-
-template <typename _TpVec32F, typename _TpVec32S>
-inline _TpVec32F v_sin_default_32f(const _TpVec32F &x) {
-  _TpVec32F ysin, ycos;
-  v_sincos_default_32f<_TpVec32F, _TpVec32S>(x, ysin, ycos);
-  return ysin;
-}
-
-template <typename _TpVec32F, typename _TpVec32S>
-inline _TpVec32F v_cos_default_32f(const _TpVec32F &x) {
-  _TpVec32F ysin, ycos;
-  v_sincos_default_32f<_TpVec32F, _TpVec32S>(x, ysin, ycos);
-  return ycos;
-}
-
-template <typename _TpVec64F, typename _TpVec64S>
-inline void v_sincos_default_64f(const _TpVec64F &x, _TpVec64F &ysin,
-                                 _TpVec64F &ycos) {
-  const _TpVec64F v_cephes_FOPI =
-      v_setall_<_TpVec64F>(1.2732395447351626861510701069801148); // 4 / M_PI
-  const _TpVec64F v_minus_DP1 =
-      v_setall_<_TpVec64F>(-7.853981554508209228515625E-1);
-  const _TpVec64F v_minus_DP2 =
-      v_setall_<_TpVec64F>(-7.94662735614792836714E-9);
-  const _TpVec64F v_minus_DP3 =
-      v_setall_<_TpVec64F>(-3.06161699786838294307E-17);
-  const _TpVec64F v_sin_C1 = v_setall_<_TpVec64F>(1.58962301576546568060E-10);
-  const _TpVec64F v_sin_C2 = v_setall_<_TpVec64F>(-2.50507477628578072866E-8);
-  const _TpVec64F v_sin_C3 = v_setall_<_TpVec64F>(2.75573136213857245213E-6);
-  const _TpVec64F v_sin_C4 = v_setall_<_TpVec64F>(-1.98412698295895385996E-4);
-  const _TpVec64F v_sin_C5 = v_setall_<_TpVec64F>(8.33333333332211858878E-3);
-  const _TpVec64F v_sin_C6 = v_setall_<_TpVec64F>(-1.66666666666666307295E-1);
-  const _TpVec64F v_cos_C1 = v_setall_<_TpVec64F>(-1.13585365213876817300E-11);
-  const _TpVec64F v_cos_C2 = v_setall_<_TpVec64F>(2.08757008419747316778E-9);
-  const _TpVec64F v_cos_C3 = v_setall_<_TpVec64F>(-2.75573141792967388112E-7);
-  const _TpVec64F v_cos_C4 = v_setall_<_TpVec64F>(2.48015872888517045348E-5);
-  const _TpVec64F v_cos_C5 = v_setall_<_TpVec64F>(-1.38888888888730564116E-3);
-  const _TpVec64F v_cos_C6 = v_setall_<_TpVec64F>(4.16666666666665929218E-2);
-  const _TpVec64F v_nan =
-      v_reinterpret_as_f64(v_setall_<_TpVec64S>((int64)0x7ff8000000000000));
-  const _TpVec64F v_neg_zero = v_setall_<_TpVec64F>(-0.0);
-
-  _TpVec64F _vx, _vy, sign_mask_sin, sign_mask_cos;
-  _TpVec64S emm2;
-
-  sign_mask_sin = v_lt(x, v_setzero_<_TpVec64F>());
-  _vx = v_abs(x);
-  _vy = v_mul(_vx, v_cephes_FOPI);
-
-  emm2 = v_expand_low(v_trunc(_vy));
-  emm2 = v_add(emm2, v_setall_<_TpVec64S>((int64)1));
-  emm2 = v_and(emm2, v_setall_<_TpVec64S>((int64)~1));
-  _vy = v_cvt_f64(emm2);
-
-  _TpVec64F poly_mask =
-      v_reinterpret_as_f64(v_eq(v_and(emm2, v_setall_<_TpVec64S>((int64)2)),
-                                v_setall_<_TpVec64S>((int64)0)));
-
-  _vx = v_fma(_vy, v_minus_DP1, _vx);
-  _vx = v_fma(_vy, v_minus_DP2, _vx);
-  _vx = v_fma(_vy, v_minus_DP3, _vx);
-
-  sign_mask_sin = v_xor(
-      sign_mask_sin,
-      v_reinterpret_as_f64(v_eq(v_and(emm2, v_setall_<_TpVec64S>((int64)4)),
-                                v_setall_<_TpVec64S>((int64)0))));
-  sign_mask_cos = v_reinterpret_as_f64(
-      v_eq(v_and(v_sub(emm2, v_setall_<_TpVec64S>((int64)2)),
-                 v_setall_<_TpVec64S>((int64)4)),
-           v_setall_<_TpVec64S>((int64)0)));
-
-  _TpVec64F _vxx = v_mul(_vx, _vx);
-  _TpVec64F y1, y2;
-
-  y1 = v_fma(v_cos_C1, _vxx, v_cos_C2);
-  y1 = v_fma(y1, _vxx, v_cos_C3);
-  y1 = v_fma(y1, _vxx, v_cos_C4);
-  y1 = v_fma(y1, _vxx, v_cos_C5);
-  y1 = v_fma(y1, _vxx, v_cos_C6);
-  y1 = v_fma(y1, _vxx, v_setall_<_TpVec64F>(-0.5));
-  y1 = v_fma(y1, _vxx, v_setall_<_TpVec64F>(1.0));
-
-  y2 = v_fma(v_sin_C1, _vxx, v_sin_C2);
-  y2 = v_fma(y2, _vxx, v_sin_C3);
-  y2 = v_fma(y2, _vxx, v_sin_C4);
-  y2 = v_fma(y2, _vxx, v_sin_C5);
-  y2 = v_fma(y2, _vxx, v_sin_C6);
-  y2 = v_mul(y2, _vxx);
-  y2 = v_fma(y2, _vx, _vx);
-
-  ysin = v_select(poly_mask, y2, y1);
-  ycos = v_select(poly_mask, y1, y2);
-  ysin = v_select(sign_mask_sin, ysin, v_xor(v_neg_zero, ysin));
-  ycos = v_select(sign_mask_cos, v_xor(v_neg_zero, ycos), ycos);
-
-  // sincos(NAN) -> NAN, sincos(±INF) -> NAN
-  _TpVec64F mask_inf = v_eq(_vx, v_reinterpret_as_f64(v_setall_<_TpVec64S>(
-                                     (int64)0x7ff0000000000000)));
-  _TpVec64F mask_nan = v_or(mask_inf, v_ne(x, x));
-  ysin = v_select(mask_nan, v_nan, ysin);
-  ycos = v_select(mask_nan, v_nan, ycos);
-}
-
-template <typename _TpVec64F, typename _TpVec64S>
-inline _TpVec64F v_sin_default_64f(const _TpVec64F &x) {
-  _TpVec64F ysin, ycos;
-  v_sincos_default_64f<_TpVec64F, _TpVec64S>(x, ysin, ycos);
-  return ysin;
-}
-
-template <typename _TpVec64F, typename _TpVec64S>
-inline _TpVec64F v_cos_default_64f(const _TpVec64F &x) {
-  _TpVec64F ysin, ycos;
-  v_sincos_default_64f<_TpVec64F, _TpVec64S>(x, ysin, ycos);
-  return ycos;
-}
-//! @}
-
-/* This implementation is derived from the approximation approach of Error
-   Function (Erf) from PyTorch
-   https://github.com/pytorch/pytorch/blob/9c50ecc84b9a6e699a7f058891b889aafbf976c7/aten/src/ATen/cpu/vec/vec512/vec512_float.h#L189-L220
-*/
-
-//! @name Error Function
-//! @{
-template <typename _TpVec32F, typename _TpVec32S>
-inline _TpVec32F v_erf_default_32f(const _TpVec32F &v) {
-  const _TpVec32F coef0 = v_setall_<_TpVec32F>(0.3275911f),
-                  coef1 = v_setall_<_TpVec32F>(1.061405429f),
-                  coef2 = v_setall_<_TpVec32F>(-1.453152027f),
-                  coef3 = v_setall_<_TpVec32F>(1.421413741f),
-                  coef4 = v_setall_<_TpVec32F>(-0.284496736f),
-                  coef5 = v_setall_<_TpVec32F>(0.254829592f),
-                  ones = v_setall_<_TpVec32F>(1.0f),
-                  neg_zeros = v_setall_<_TpVec32F>(-0.f);
-  _TpVec32F t = v_abs(v);
-  // sign(v)
-  _TpVec32F sign_mask = v_and(neg_zeros, v);
-
-  t = v_div(ones, v_fma(coef0, t, ones));
-  _TpVec32F r = v_fma(coef1, t, coef2);
-  r = v_fma(r, t, coef3);
-  r = v_fma(r, t, coef4);
-  r = v_fma(r, t, coef5);
-  // - v * v
-  _TpVec32F v2 = v_mul(v, v);
-  _TpVec32F mv2 = v_xor(neg_zeros, v2);
-  // - exp(- v * v)
-  _TpVec32F exp = v_exp_default_32f<_TpVec32F, _TpVec32S>(mv2);
-  _TpVec32F neg_exp = v_xor(neg_zeros, exp);
-  _TpVec32F res = v_mul(t, neg_exp);
-  res = v_fma(r, res, ones);
-  return v_xor(sign_mask, res);
-}
-//! @}
-
-#endif // OPENCV_HAL_INTRIN_MATH_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_msa.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_msa.hpp
deleted file mode 100644
index 43dbe3aeb6..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_msa.hpp
+++ /dev/null
@@ -1,1973 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_HAL_INTRIN_MSA_HPP
-#define OPENCV_HAL_INTRIN_MSA_HPP
-
-#include "opencv2/core/utility.hpp"
-#include <algorithm>
-
-namespace cv {
-
-//! @cond IGNORED
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_BEGIN
-
-#define CV_SIMD128 1
-
-// MSA implements 128-bit wide vector registers shared with the 64-bit wide
-// floating-point unit registers. MSA and FPU can not be both present, unless
-// the FPU has 64-bit floating-point registers.
-#define CV_SIMD128_64F 1
-
-struct v_uint8x16 {
-  typedef uchar lane_type;
-  enum { nlanes = 16 };
-
-  v_uint8x16() {}
-  explicit v_uint8x16(v16u8 v) : val(v) {}
-  v_uint8x16(uchar v0, uchar v1, uchar v2, uchar v3, uchar v4, uchar v5,
-             uchar v6, uchar v7, uchar v8, uchar v9, uchar v10, uchar v11,
-             uchar v12, uchar v13, uchar v14, uchar v15) {
-    uchar v[] = {v0, v1, v2,  v3,  v4,  v5,  v6,  v7,
-                 v8, v9, v10, v11, v12, v13, v14, v15};
-    val = msa_ld1q_u8(v);
-  }
-
-  uchar get0() const { return msa_getq_lane_u8(val, 0); }
-
-  v16u8 val;
-};
-
-struct v_int8x16 {
-  typedef schar lane_type;
-  enum { nlanes = 16 };
-
-  v_int8x16() {}
-  explicit v_int8x16(v16i8 v) : val(v) {}
-  v_int8x16(schar v0, schar v1, schar v2, schar v3, schar v4, schar v5,
-            schar v6, schar v7, schar v8, schar v9, schar v10, schar v11,
-            schar v12, schar v13, schar v14, schar v15) {
-    schar v[] = {v0, v1, v2,  v3,  v4,  v5,  v6,  v7,
-                 v8, v9, v10, v11, v12, v13, v14, v15};
-    val = msa_ld1q_s8(v);
-  }
-
-  schar get0() const { return msa_getq_lane_s8(val, 0); }
-
-  v16i8 val;
-};
-
-struct v_uint16x8 {
-  typedef ushort lane_type;
-  enum { nlanes = 8 };
-
-  v_uint16x8() {}
-  explicit v_uint16x8(v8u16 v) : val(v) {}
-  v_uint16x8(ushort v0, ushort v1, ushort v2, ushort v3, ushort v4, ushort v5,
-             ushort v6, ushort v7) {
-    ushort v[] = {v0, v1, v2, v3, v4, v5, v6, v7};
-    val = msa_ld1q_u16(v);
-  }
-
-  ushort get0() const { return msa_getq_lane_u16(val, 0); }
-
-  v8u16 val;
-};
-
-struct v_int16x8 {
-  typedef short lane_type;
-  enum { nlanes = 8 };
-
-  v_int16x8() {}
-  explicit v_int16x8(v8i16 v) : val(v) {}
-  v_int16x8(short v0, short v1, short v2, short v3, short v4, short v5,
-            short v6, short v7) {
-    short v[] = {v0, v1, v2, v3, v4, v5, v6, v7};
-    val = msa_ld1q_s16(v);
-  }
-
-  short get0() const { return msa_getq_lane_s16(val, 0); }
-
-  v8i16 val;
-};
-
-struct v_uint32x4 {
-  typedef unsigned int lane_type;
-  enum { nlanes = 4 };
-
-  v_uint32x4() {}
-  explicit v_uint32x4(v4u32 v) : val(v) {}
-  v_uint32x4(unsigned int v0, unsigned int v1, unsigned int v2,
-             unsigned int v3) {
-    unsigned int v[] = {v0, v1, v2, v3};
-    val = msa_ld1q_u32(v);
-  }
-
-  unsigned int get0() const { return msa_getq_lane_u32(val, 0); }
-
-  v4u32 val;
-};
-
-struct v_int32x4 {
-  typedef int lane_type;
-  enum { nlanes = 4 };
-
-  v_int32x4() {}
-  explicit v_int32x4(v4i32 v) : val(v) {}
-  v_int32x4(int v0, int v1, int v2, int v3) {
-    int v[] = {v0, v1, v2, v3};
-    val = msa_ld1q_s32(v);
-  }
-
-  int get0() const { return msa_getq_lane_s32(val, 0); }
-
-  v4i32 val;
-};
-
-struct v_float32x4 {
-  typedef float lane_type;
-  enum { nlanes = 4 };
-
-  v_float32x4() {}
-  explicit v_float32x4(v4f32 v) : val(v) {}
-  v_float32x4(float v0, float v1, float v2, float v3) {
-    float v[] = {v0, v1, v2, v3};
-    val = msa_ld1q_f32(v);
-  }
-
-  float get0() const { return msa_getq_lane_f32(val, 0); }
-
-  v4f32 val;
-};
-
-struct v_uint64x2 {
-  typedef uint64 lane_type;
-  enum { nlanes = 2 };
-
-  v_uint64x2() {}
-  explicit v_uint64x2(v2u64 v) : val(v) {}
-  v_uint64x2(uint64 v0, uint64 v1) {
-    uint64 v[] = {v0, v1};
-    val = msa_ld1q_u64(v);
-  }
-
-  uint64 get0() const { return msa_getq_lane_u64(val, 0); }
-
-  v2u64 val;
-};
-
-struct v_int64x2 {
-  typedef int64 lane_type;
-  enum { nlanes = 2 };
-
-  v_int64x2() {}
-  explicit v_int64x2(v2i64 v) : val(v) {}
-  v_int64x2(int64 v0, int64 v1) {
-    int64 v[] = {v0, v1};
-    val = msa_ld1q_s64(v);
-  }
-
-  int64 get0() const { return msa_getq_lane_s64(val, 0); }
-
-  v2i64 val;
-};
-
-struct v_float64x2 {
-  typedef double lane_type;
-  enum { nlanes = 2 };
-
-  v_float64x2() {}
-  explicit v_float64x2(v2f64 v) : val(v) {}
-  v_float64x2(double v0, double v1) {
-    double v[] = {v0, v1};
-    val = msa_ld1q_f64(v);
-  }
-
-  double get0() const { return msa_getq_lane_f64(val, 0); }
-
-  v2f64 val;
-};
-
-#define OPENCV_HAL_IMPL_MSA_INIT(_Tpv, _Tp, suffix)                            \
-  inline v_##_Tpv v_setzero_##suffix() {                                       \
-    return v_##_Tpv(msa_dupq_n_##suffix((_Tp)0));                              \
-  }                                                                            \
-  inline v_##_Tpv v_setall_##suffix(_Tp v) {                                   \
-    return v_##_Tpv(msa_dupq_n_##suffix(v));                                   \
-  }                                                                            \
-  template <> inline v_##_Tpv v_setzero_() { return v_setzero_##suffix(); }    \
-  template <> inline v_##_Tpv v_setall_(_Tp v) {                               \
-    return v_setall_##suffix(v);                                               \
-  }                                                                            \
-  inline v_uint8x16 v_reinterpret_as_u8(const v_##_Tpv &v) {                   \
-    return v_uint8x16(MSA_TPV_REINTERPRET(v16u8, v.val));                      \
-  }                                                                            \
-  inline v_int8x16 v_reinterpret_as_s8(const v_##_Tpv &v) {                    \
-    return v_int8x16(MSA_TPV_REINTERPRET(v16i8, v.val));                       \
-  }                                                                            \
-  inline v_uint16x8 v_reinterpret_as_u16(const v_##_Tpv &v) {                  \
-    return v_uint16x8(MSA_TPV_REINTERPRET(v8u16, v.val));                      \
-  }                                                                            \
-  inline v_int16x8 v_reinterpret_as_s16(const v_##_Tpv &v) {                   \
-    return v_int16x8(MSA_TPV_REINTERPRET(v8i16, v.val));                       \
-  }                                                                            \
-  inline v_uint32x4 v_reinterpret_as_u32(const v_##_Tpv &v) {                  \
-    return v_uint32x4(MSA_TPV_REINTERPRET(v4u32, v.val));                      \
-  }                                                                            \
-  inline v_int32x4 v_reinterpret_as_s32(const v_##_Tpv &v) {                   \
-    return v_int32x4(MSA_TPV_REINTERPRET(v4i32, v.val));                       \
-  }                                                                            \
-  inline v_uint64x2 v_reinterpret_as_u64(const v_##_Tpv &v) {                  \
-    return v_uint64x2(MSA_TPV_REINTERPRET(v2u64, v.val));                      \
-  }                                                                            \
-  inline v_int64x2 v_reinterpret_as_s64(const v_##_Tpv &v) {                   \
-    return v_int64x2(MSA_TPV_REINTERPRET(v2i64, v.val));                       \
-  }                                                                            \
-  inline v_float32x4 v_reinterpret_as_f32(const v_##_Tpv &v) {                 \
-    return v_float32x4(MSA_TPV_REINTERPRET(v4f32, v.val));                     \
-  }                                                                            \
-  inline v_float64x2 v_reinterpret_as_f64(const v_##_Tpv &v) {                 \
-    return v_float64x2(MSA_TPV_REINTERPRET(v2f64, v.val));                     \
-  }
-
-OPENCV_HAL_IMPL_MSA_INIT(uint8x16, uchar, u8)
-OPENCV_HAL_IMPL_MSA_INIT(int8x16, schar, s8)
-OPENCV_HAL_IMPL_MSA_INIT(uint16x8, ushort, u16)
-OPENCV_HAL_IMPL_MSA_INIT(int16x8, short, s16)
-OPENCV_HAL_IMPL_MSA_INIT(uint32x4, unsigned int, u32)
-OPENCV_HAL_IMPL_MSA_INIT(int32x4, int, s32)
-OPENCV_HAL_IMPL_MSA_INIT(uint64x2, uint64, u64)
-OPENCV_HAL_IMPL_MSA_INIT(int64x2, int64, s64)
-OPENCV_HAL_IMPL_MSA_INIT(float32x4, float, f32)
-OPENCV_HAL_IMPL_MSA_INIT(float64x2, double, f64)
-
-#define OPENCV_HAL_IMPL_MSA_PACK(_Tpvec, _Tpwvec, pack, mov, rshr)             \
-  inline _Tpvec v_##pack(const _Tpwvec &a, const _Tpwvec &b) {                 \
-    return _Tpvec(mov(a.val, b.val));                                          \
-  }                                                                            \
-  template <int n>                                                             \
-  inline _Tpvec v_rshr_##pack(const _Tpwvec &a, const _Tpwvec &b) {            \
-    return _Tpvec(rshr(a.val, b.val, n));                                      \
-  }
-
-OPENCV_HAL_IMPL_MSA_PACK(v_uint8x16, v_uint16x8, pack, msa_qpack_u16,
-                         msa_qrpackr_u16)
-OPENCV_HAL_IMPL_MSA_PACK(v_int8x16, v_int16x8, pack, msa_qpack_s16,
-                         msa_qrpackr_s16)
-OPENCV_HAL_IMPL_MSA_PACK(v_uint16x8, v_uint32x4, pack, msa_qpack_u32,
-                         msa_qrpackr_u32)
-OPENCV_HAL_IMPL_MSA_PACK(v_int16x8, v_int32x4, pack, msa_qpack_s32,
-                         msa_qrpackr_s32)
-OPENCV_HAL_IMPL_MSA_PACK(v_uint32x4, v_uint64x2, pack, msa_pack_u64,
-                         msa_rpackr_u64)
-OPENCV_HAL_IMPL_MSA_PACK(v_int32x4, v_int64x2, pack, msa_pack_s64,
-                         msa_rpackr_s64)
-OPENCV_HAL_IMPL_MSA_PACK(v_uint8x16, v_int16x8, pack_u, msa_qpacku_s16,
-                         msa_qrpackru_s16)
-OPENCV_HAL_IMPL_MSA_PACK(v_uint16x8, v_int32x4, pack_u, msa_qpacku_s32,
-                         msa_qrpackru_s32)
-
-#define OPENCV_HAL_IMPL_MSA_PACK_STORE(_Tpvec, _Tp, hreg, suffix, _Tpwvec,     \
-                                       pack, mov, rshr)                        \
-  inline void v_##pack##_store(_Tp *ptr, const _Tpwvec &a) {                   \
-    hreg a1 = mov(a.val);                                                      \
-    msa_st1_##suffix(ptr, a1);                                                 \
-  }                                                                            \
-  template <int n>                                                             \
-  inline void v_rshr_##pack##_store(_Tp *ptr, const _Tpwvec &a) {              \
-    hreg a1 = rshr(a.val, n);                                                  \
-    msa_st1_##suffix(ptr, a1);                                                 \
-  }
-
-OPENCV_HAL_IMPL_MSA_PACK_STORE(v_uint8x16, uchar, v8u8, u8, v_uint16x8, pack,
-                               msa_qmovn_u16, msa_qrshrn_n_u16)
-OPENCV_HAL_IMPL_MSA_PACK_STORE(v_int8x16, schar, v8i8, s8, v_int16x8, pack,
-                               msa_qmovn_s16, msa_qrshrn_n_s16)
-OPENCV_HAL_IMPL_MSA_PACK_STORE(v_uint16x8, ushort, v4u16, u16, v_uint32x4, pack,
-                               msa_qmovn_u32, msa_qrshrn_n_u32)
-OPENCV_HAL_IMPL_MSA_PACK_STORE(v_int16x8, short, v4i16, s16, v_int32x4, pack,
-                               msa_qmovn_s32, msa_qrshrn_n_s32)
-OPENCV_HAL_IMPL_MSA_PACK_STORE(v_uint32x4, unsigned, v2u32, u32, v_uint64x2,
-                               pack, msa_movn_u64, msa_rshrn_n_u64)
-OPENCV_HAL_IMPL_MSA_PACK_STORE(v_int32x4, int, v2i32, s32, v_int64x2, pack,
-                               msa_movn_s64, msa_rshrn_n_s64)
-OPENCV_HAL_IMPL_MSA_PACK_STORE(v_uint8x16, uchar, v8u8, u8, v_int16x8, pack_u,
-                               msa_qmovun_s16, msa_qrshrun_n_s16)
-OPENCV_HAL_IMPL_MSA_PACK_STORE(v_uint16x8, ushort, v4u16, u16, v_int32x4,
-                               pack_u, msa_qmovun_s32, msa_qrshrun_n_s32)
-
-// pack boolean
-inline v_uint8x16 v_pack_b(const v_uint16x8 &a, const v_uint16x8 &b) {
-  return v_uint8x16(msa_pack_u16(a.val, b.val));
-}
-
-inline v_uint8x16 v_pack_b(const v_uint32x4 &a, const v_uint32x4 &b,
-                           const v_uint32x4 &c, const v_uint32x4 &d) {
-  return v_uint8x16(
-      msa_pack_u16(msa_pack_u32(a.val, b.val), msa_pack_u32(c.val, d.val)));
-}
-
-inline v_uint8x16 v_pack_b(const v_uint64x2 &a, const v_uint64x2 &b,
-                           const v_uint64x2 &c, const v_uint64x2 &d,
-                           const v_uint64x2 &e, const v_uint64x2 &f,
-                           const v_uint64x2 &g, const v_uint64x2 &h) {
-  v8u16 abcd =
-      msa_pack_u32(msa_pack_u64(a.val, b.val), msa_pack_u64(c.val, d.val));
-  v8u16 efgh =
-      msa_pack_u32(msa_pack_u64(e.val, f.val), msa_pack_u64(g.val, h.val));
-  return v_uint8x16(msa_pack_u16(abcd, efgh));
-}
-
-inline v_float32x4 v_matmul(const v_float32x4 &v, const v_float32x4 &m0,
-                            const v_float32x4 &m1, const v_float32x4 &m2,
-                            const v_float32x4 &m3) {
-  v4f32 v0 = v.val;
-  v4f32 res = msa_mulq_lane_f32(m0.val, v0, 0);
-  res = msa_mlaq_lane_f32(res, m1.val, v0, 1);
-  res = msa_mlaq_lane_f32(res, m2.val, v0, 2);
-  res = msa_mlaq_lane_f32(res, m3.val, v0, 3);
-  return v_float32x4(res);
-}
-
-inline v_float32x4 v_matmuladd(const v_float32x4 &v, const v_float32x4 &m0,
-                               const v_float32x4 &m1, const v_float32x4 &m2,
-                               const v_float32x4 &a) {
-  v4f32 v0 = v.val;
-  v4f32 res = msa_mulq_lane_f32(m0.val, v0, 0);
-  res = msa_mlaq_lane_f32(res, m1.val, v0, 1);
-  res = msa_mlaq_lane_f32(res, m2.val, v0, 2);
-  res = msa_addq_f32(res, a.val);
-  return v_float32x4(res);
-}
-
-#define OPENCV_HAL_IMPL_MSA_BIN_OP(bin_op, _Tpvec, intrin)                     \
-  inline _Tpvec bin_op(const _Tpvec &a, const _Tpvec &b) {                     \
-    return _Tpvec(intrin(a.val, b.val));                                       \
-  }
-
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_add, v_uint8x16, msa_qaddq_u8)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_sub, v_uint8x16, msa_qsubq_u8)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_add, v_int8x16, msa_qaddq_s8)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_sub, v_int8x16, msa_qsubq_s8)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_add, v_uint16x8, msa_qaddq_u16)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_sub, v_uint16x8, msa_qsubq_u16)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_add, v_int16x8, msa_qaddq_s16)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_sub, v_int16x8, msa_qsubq_s16)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_add, v_int32x4, msa_addq_s32)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_sub, v_int32x4, msa_subq_s32)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_mul, v_int32x4, msa_mulq_s32)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_add, v_uint32x4, msa_addq_u32)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_sub, v_uint32x4, msa_subq_u32)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_mul, v_uint32x4, msa_mulq_u32)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_add, v_float32x4, msa_addq_f32)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_sub, v_float32x4, msa_subq_f32)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_mul, v_float32x4, msa_mulq_f32)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_add, v_int64x2, msa_addq_s64)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_sub, v_int64x2, msa_subq_s64)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_add, v_uint64x2, msa_addq_u64)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_sub, v_uint64x2, msa_subq_u64)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_div, v_float32x4, msa_divq_f32)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_add, v_float64x2, msa_addq_f64)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_sub, v_float64x2, msa_subq_f64)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_mul, v_float64x2, msa_mulq_f64)
-OPENCV_HAL_IMPL_MSA_BIN_OP(v_div, v_float64x2, msa_divq_f64)
-
-// saturating multiply 8-bit, 16-bit
-#define OPENCV_HAL_IMPL_MSA_MUL_SAT(_Tpvec, _Tpwvec)                           \
-  inline _Tpvec v_mul(const _Tpvec &a, const _Tpvec &b) {                      \
-    _Tpwvec c, d;                                                              \
-    v_mul_expand(a, b, c, d);                                                  \
-    return v_pack(c, d);                                                       \
-  }
-
-OPENCV_HAL_IMPL_MSA_MUL_SAT(v_int8x16, v_int16x8)
-OPENCV_HAL_IMPL_MSA_MUL_SAT(v_uint8x16, v_uint16x8)
-OPENCV_HAL_IMPL_MSA_MUL_SAT(v_int16x8, v_int32x4)
-OPENCV_HAL_IMPL_MSA_MUL_SAT(v_uint16x8, v_uint32x4)
-
-//  Multiply and expand
-inline void v_mul_expand(const v_int8x16 &a, const v_int8x16 &b, v_int16x8 &c,
-                         v_int16x8 &d) {
-  v16i8 a_lo, a_hi, b_lo, b_hi;
-
-  ILVRL_B2_SB(a.val, msa_dupq_n_s8(0), a_lo, a_hi);
-  ILVRL_B2_SB(b.val, msa_dupq_n_s8(0), b_lo, b_hi);
-  c.val = msa_mulq_s16(msa_paddlq_s8(a_lo), msa_paddlq_s8(b_lo));
-  d.val = msa_mulq_s16(msa_paddlq_s8(a_hi), msa_paddlq_s8(b_hi));
-}
-
-inline void v_mul_expand(const v_uint8x16 &a, const v_uint8x16 &b,
-                         v_uint16x8 &c, v_uint16x8 &d) {
-  v16u8 a_lo, a_hi, b_lo, b_hi;
-
-  ILVRL_B2_UB(a.val, msa_dupq_n_u8(0), a_lo, a_hi);
-  ILVRL_B2_UB(b.val, msa_dupq_n_u8(0), b_lo, b_hi);
-  c.val = msa_mulq_u16(msa_paddlq_u8(a_lo), msa_paddlq_u8(b_lo));
-  d.val = msa_mulq_u16(msa_paddlq_u8(a_hi), msa_paddlq_u8(b_hi));
-}
-
-inline void v_mul_expand(const v_int16x8 &a, const v_int16x8 &b, v_int32x4 &c,
-                         v_int32x4 &d) {
-  v8i16 a_lo, a_hi, b_lo, b_hi;
-
-  ILVRL_H2_SH(a.val, msa_dupq_n_s16(0), a_lo, a_hi);
-  ILVRL_H2_SH(b.val, msa_dupq_n_s16(0), b_lo, b_hi);
-  c.val = msa_mulq_s32(msa_paddlq_s16(a_lo), msa_paddlq_s16(b_lo));
-  d.val = msa_mulq_s32(msa_paddlq_s16(a_hi), msa_paddlq_s16(b_hi));
-}
-
-inline void v_mul_expand(const v_uint16x8 &a, const v_uint16x8 &b,
-                         v_uint32x4 &c, v_uint32x4 &d) {
-  v8u16 a_lo, a_hi, b_lo, b_hi;
-
-  ILVRL_H2_UH(a.val, msa_dupq_n_u16(0), a_lo, a_hi);
-  ILVRL_H2_UH(b.val, msa_dupq_n_u16(0), b_lo, b_hi);
-  c.val = msa_mulq_u32(msa_paddlq_u16(a_lo), msa_paddlq_u16(b_lo));
-  d.val = msa_mulq_u32(msa_paddlq_u16(a_hi), msa_paddlq_u16(b_hi));
-}
-
-inline void v_mul_expand(const v_uint32x4 &a, const v_uint32x4 &b,
-                         v_uint64x2 &c, v_uint64x2 &d) {
-  v4u32 a_lo, a_hi, b_lo, b_hi;
-
-  ILVRL_W2_UW(a.val, msa_dupq_n_u32(0), a_lo, a_hi);
-  ILVRL_W2_UW(b.val, msa_dupq_n_u32(0), b_lo, b_hi);
-  c.val = msa_mulq_u64(msa_paddlq_u32(a_lo), msa_paddlq_u32(b_lo));
-  d.val = msa_mulq_u64(msa_paddlq_u32(a_hi), msa_paddlq_u32(b_hi));
-}
-
-inline v_int16x8 v_mul_hi(const v_int16x8 &a, const v_int16x8 &b) {
-  v8i16 a_lo, a_hi, b_lo, b_hi;
-
-  ILVRL_H2_SH(a.val, msa_dupq_n_s16(0), a_lo, a_hi);
-  ILVRL_H2_SH(b.val, msa_dupq_n_s16(0), b_lo, b_hi);
-
-  return v_int16x8(msa_packr_s32(
-      msa_mulq_s32(msa_paddlq_s16(a_lo), msa_paddlq_s16(b_lo)),
-      msa_mulq_s32(msa_paddlq_s16(a_hi), msa_paddlq_s16(b_hi)), 16));
-}
-
-inline v_uint16x8 v_mul_hi(const v_uint16x8 &a, const v_uint16x8 &b) {
-  v8u16 a_lo, a_hi, b_lo, b_hi;
-
-  ILVRL_H2_UH(a.val, msa_dupq_n_u16(0), a_lo, a_hi);
-  ILVRL_H2_UH(b.val, msa_dupq_n_u16(0), b_lo, b_hi);
-
-  return v_uint16x8(msa_packr_u32(
-      msa_mulq_u32(msa_paddlq_u16(a_lo), msa_paddlq_u16(b_lo)),
-      msa_mulq_u32(msa_paddlq_u16(a_hi), msa_paddlq_u16(b_hi)), 16));
-}
-
-//////// Dot Product ////////
-
-// 16 >> 32
-inline v_int32x4 v_dotprod(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_int32x4(msa_dotp_s_w(a.val, b.val));
-}
-inline v_int32x4 v_dotprod(const v_int16x8 &a, const v_int16x8 &b,
-                           const v_int32x4 &c) {
-  return v_int32x4(msa_dpadd_s_w(c.val, a.val, b.val));
-}
-
-// 32 >> 64
-inline v_int64x2 v_dotprod(const v_int32x4 &a, const v_int32x4 &b) {
-  return v_int64x2(msa_dotp_s_d(a.val, b.val));
-}
-inline v_int64x2 v_dotprod(const v_int32x4 &a, const v_int32x4 &b,
-                           const v_int64x2 &c) {
-  return v_int64x2(msa_dpadd_s_d(c.val, a.val, b.val));
-}
-
-// 8 >> 32
-inline v_uint32x4 v_dotprod_expand(const v_uint8x16 &a, const v_uint8x16 &b) {
-  v8u16 even_a =
-      msa_shrq_n_u16(msa_shlq_n_u16(MSA_TPV_REINTERPRET(v8u16, a.val), 8), 8);
-  v8u16 odd_a = msa_shrq_n_u16(MSA_TPV_REINTERPRET(v8u16, a.val), 8);
-  v8u16 even_b =
-      msa_shrq_n_u16(msa_shlq_n_u16(MSA_TPV_REINTERPRET(v8u16, b.val), 8), 8);
-  v8u16 odd_b = msa_shrq_n_u16(MSA_TPV_REINTERPRET(v8u16, b.val), 8);
-  v4u32 prod = msa_dotp_u_w(even_a, even_b);
-  return v_uint32x4(msa_dpadd_u_w(prod, odd_a, odd_b));
-}
-inline v_uint32x4 v_dotprod_expand(const v_uint8x16 &a, const v_uint8x16 &b,
-                                   const v_uint32x4 &c) {
-  v8u16 even_a =
-      msa_shrq_n_u16(msa_shlq_n_u16(MSA_TPV_REINTERPRET(v8u16, a.val), 8), 8);
-  v8u16 odd_a = msa_shrq_n_u16(MSA_TPV_REINTERPRET(v8u16, a.val), 8);
-  v8u16 even_b =
-      msa_shrq_n_u16(msa_shlq_n_u16(MSA_TPV_REINTERPRET(v8u16, b.val), 8), 8);
-  v8u16 odd_b = msa_shrq_n_u16(MSA_TPV_REINTERPRET(v8u16, b.val), 8);
-  v4u32 prod = msa_dpadd_u_w(c.val, even_a, even_b);
-  return v_uint32x4(msa_dpadd_u_w(prod, odd_a, odd_b));
-}
-
-inline v_int32x4 v_dotprod_expand(const v_int8x16 &a, const v_int8x16 &b) {
-  v8i16 prod = msa_dotp_s_h(a.val, b.val);
-  return v_int32x4(msa_hadd_s32(prod, prod));
-}
-inline v_int32x4 v_dotprod_expand(const v_int8x16 &a, const v_int8x16 &b,
-                                  const v_int32x4 &c) {
-  return v_dotprod_expand(a, b) + c;
-}
-
-// 16 >> 64
-inline v_uint64x2 v_dotprod_expand(const v_uint16x8 &a, const v_uint16x8 &b) {
-  v4u32 even_a =
-      msa_shrq_n_u32(msa_shlq_n_u32(MSA_TPV_REINTERPRET(v4u32, a.val), 16), 16);
-  v4u32 odd_a = msa_shrq_n_u32(MSA_TPV_REINTERPRET(v4u32, a.val), 16);
-  v4u32 even_b =
-      msa_shrq_n_u32(msa_shlq_n_u32(MSA_TPV_REINTERPRET(v4u32, b.val), 16), 16);
-  v4u32 odd_b = msa_shrq_n_u32(MSA_TPV_REINTERPRET(v4u32, b.val), 16);
-  v2u64 prod = msa_dotp_u_d(even_a, even_b);
-  return v_uint64x2(msa_dpadd_u_d(prod, odd_a, odd_b));
-}
-inline v_uint64x2 v_dotprod_expand(const v_uint16x8 &a, const v_uint16x8 &b,
-                                   const v_uint64x2 &c) {
-  v4u32 even_a =
-      msa_shrq_n_u32(msa_shlq_n_u32(MSA_TPV_REINTERPRET(v4u32, a.val), 16), 16);
-  v4u32 odd_a = msa_shrq_n_u32(MSA_TPV_REINTERPRET(v4u32, a.val), 16);
-  v4u32 even_b =
-      msa_shrq_n_u32(msa_shlq_n_u32(MSA_TPV_REINTERPRET(v4u32, b.val), 16), 16);
-  v4u32 odd_b = msa_shrq_n_u32(MSA_TPV_REINTERPRET(v4u32, b.val), 16);
-  v2u64 prod = msa_dpadd_u_d(c.val, even_a, even_b);
-  return v_uint64x2(msa_dpadd_u_d(prod, odd_a, odd_b));
-}
-
-inline v_int64x2 v_dotprod_expand(const v_int16x8 &a, const v_int16x8 &b) {
-  v4i32 prod = msa_dotp_s_w(a.val, b.val);
-  return v_int64x2(msa_hadd_s64(prod, prod));
-}
-inline v_int64x2 v_dotprod_expand(const v_int16x8 &a, const v_int16x8 &b,
-                                  const v_int64x2 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-// 32 >> 64f
-inline v_float64x2 v_dotprod_expand(const v_int32x4 &a, const v_int32x4 &b) {
-  return v_cvt_f64(v_dotprod(a, b));
-}
-inline v_float64x2 v_dotprod_expand(const v_int32x4 &a, const v_int32x4 &b,
-                                    const v_float64x2 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-//////// Fast Dot Product ////////
-
-// 16 >> 32
-inline v_int32x4 v_dotprod_fast(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_dotprod(a, b);
-}
-inline v_int32x4 v_dotprod_fast(const v_int16x8 &a, const v_int16x8 &b,
-                                const v_int32x4 &c) {
-  return v_dotprod(a, b, c);
-}
-
-// 32 >> 64
-inline v_int64x2 v_dotprod_fast(const v_int32x4 &a, const v_int32x4 &b) {
-  return v_dotprod(a, b);
-}
-inline v_int64x2 v_dotprod_fast(const v_int32x4 &a, const v_int32x4 &b,
-                                const v_int64x2 &c) {
-  return v_dotprod(a, b, c);
-}
-
-// 8 >> 32
-inline v_uint32x4 v_dotprod_expand_fast(const v_uint8x16 &a,
-                                        const v_uint8x16 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_uint32x4 v_dotprod_expand_fast(const v_uint8x16 &a,
-                                        const v_uint8x16 &b,
-                                        const v_uint32x4 &c) {
-  return v_dotprod_expand(a, b, c);
-}
-inline v_int32x4 v_dotprod_expand_fast(const v_int8x16 &a, const v_int8x16 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_int32x4 v_dotprod_expand_fast(const v_int8x16 &a, const v_int8x16 &b,
-                                       const v_int32x4 &c) {
-  return v_dotprod_expand(a, b, c);
-}
-
-// 16 >> 64
-inline v_uint64x2 v_dotprod_expand_fast(const v_uint16x8 &a,
-                                        const v_uint16x8 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_uint64x2 v_dotprod_expand_fast(const v_uint16x8 &a,
-                                        const v_uint16x8 &b,
-                                        const v_uint64x2 &c) {
-  return v_dotprod_expand(a, b, c);
-}
-inline v_int64x2 v_dotprod_expand_fast(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_int64x2 v_dotprod_expand_fast(const v_int16x8 &a, const v_int16x8 &b,
-                                       const v_int64x2 &c) {
-  return v_dotprod_expand(a, b, c);
-}
-
-// 32 >> 64f
-inline v_float64x2 v_dotprod_expand_fast(const v_int32x4 &a,
-                                         const v_int32x4 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_float64x2 v_dotprod_expand_fast(const v_int32x4 &a, const v_int32x4 &b,
-                                         const v_float64x2 &c) {
-  return v_dotprod_expand(a, b, c);
-}
-
-#define OPENCV_HAL_IMPL_MSA_LOGIC_OP(_Tpvec, _Tpv, suffix)                     \
-  OPENCV_HAL_IMPL_MSA_BIN_OP(v_and, _Tpvec, msa_andq_##suffix)                 \
-  OPENCV_HAL_IMPL_MSA_BIN_OP(v_or, _Tpvec, msa_orrq_##suffix)                  \
-  OPENCV_HAL_IMPL_MSA_BIN_OP(v_xor, _Tpvec, msa_eorq_##suffix)                 \
-  inline _Tpvec v_not(const _Tpvec &a) {                                       \
-    return _Tpvec(MSA_TPV_REINTERPRET(                                         \
-        _Tpv, msa_mvnq_u8(MSA_TPV_REINTERPRET(v16u8, a.val))));                \
-  }
-
-OPENCV_HAL_IMPL_MSA_LOGIC_OP(v_uint8x16, v16u8, u8)
-OPENCV_HAL_IMPL_MSA_LOGIC_OP(v_int8x16, v16i8, s8)
-OPENCV_HAL_IMPL_MSA_LOGIC_OP(v_uint16x8, v8u16, u16)
-OPENCV_HAL_IMPL_MSA_LOGIC_OP(v_int16x8, v8i16, s16)
-OPENCV_HAL_IMPL_MSA_LOGIC_OP(v_uint32x4, v4u32, u32)
-OPENCV_HAL_IMPL_MSA_LOGIC_OP(v_int32x4, v4i32, s32)
-OPENCV_HAL_IMPL_MSA_LOGIC_OP(v_uint64x2, v2u64, u64)
-OPENCV_HAL_IMPL_MSA_LOGIC_OP(v_int64x2, v2i64, s64)
-
-#define OPENCV_HAL_IMPL_MSA_FLT_BIT_OP(bin_op, intrin)                         \
-  inline v_float32x4 bin_op(const v_float32x4 &a, const v_float32x4 &b) {      \
-    return v_float32x4(MSA_TPV_REINTERPRET(                                    \
-        v4f32, intrin(MSA_TPV_REINTERPRET(v4i32, a.val),                       \
-                      MSA_TPV_REINTERPRET(v4i32, b.val))));                    \
-  }
-
-OPENCV_HAL_IMPL_MSA_FLT_BIT_OP(v_and, msa_andq_s32)
-OPENCV_HAL_IMPL_MSA_FLT_BIT_OP(v_or, msa_orrq_s32)
-OPENCV_HAL_IMPL_MSA_FLT_BIT_OP(v_xor, msa_eorq_s32)
-
-inline v_float32x4 v_not(const v_float32x4 &a) {
-  return v_float32x4(MSA_TPV_REINTERPRET(
-      v4f32, msa_mvnq_s32(MSA_TPV_REINTERPRET(v4i32, a.val))));
-}
-
-/* v_abs */
-#define OPENCV_HAL_IMPL_MSA_ABS(_Tpuvec, _Tpsvec, usuffix, ssuffix)            \
-  inline _Tpuvec v_abs(const _Tpsvec &a) {                                     \
-    return v_reinterpret_as_##usuffix(_Tpsvec(msa_absq_##ssuffix(a.val)));     \
-  }
-
-OPENCV_HAL_IMPL_MSA_ABS(v_uint8x16, v_int8x16, u8, s8)
-OPENCV_HAL_IMPL_MSA_ABS(v_uint16x8, v_int16x8, u16, s16)
-OPENCV_HAL_IMPL_MSA_ABS(v_uint32x4, v_int32x4, u32, s32)
-
-/* v_abs(float), v_sqrt, v_invsqrt */
-#define OPENCV_HAL_IMPL_MSA_BASIC_FUNC(_Tpvec, func, intrin)                   \
-  inline _Tpvec func(const _Tpvec &a) { return _Tpvec(intrin(a.val)); }
-
-OPENCV_HAL_IMPL_MSA_BASIC_FUNC(v_float32x4, v_abs, msa_absq_f32)
-OPENCV_HAL_IMPL_MSA_BASIC_FUNC(v_float64x2, v_abs, msa_absq_f64)
-OPENCV_HAL_IMPL_MSA_BASIC_FUNC(v_float32x4, v_sqrt, msa_sqrtq_f32)
-OPENCV_HAL_IMPL_MSA_BASIC_FUNC(v_float32x4, v_invsqrt, msa_rsqrtq_f32)
-OPENCV_HAL_IMPL_MSA_BASIC_FUNC(v_float64x2, v_sqrt, msa_sqrtq_f64)
-OPENCV_HAL_IMPL_MSA_BASIC_FUNC(v_float64x2, v_invsqrt, msa_rsqrtq_f64)
-
-#define OPENCV_HAL_IMPL_MSA_DBL_BIT_OP(bin_op, intrin)                         \
-  inline v_float64x2 bin_op(const v_float64x2 &a, const v_float64x2 &b) {      \
-    return v_float64x2(MSA_TPV_REINTERPRET(                                    \
-        v2f64, intrin(MSA_TPV_REINTERPRET(v2i64, a.val),                       \
-                      MSA_TPV_REINTERPRET(v2i64, b.val))));                    \
-  }
-
-OPENCV_HAL_IMPL_MSA_DBL_BIT_OP(v_and, msa_andq_s64)
-OPENCV_HAL_IMPL_MSA_DBL_BIT_OP(v_or, msa_orrq_s64)
-OPENCV_HAL_IMPL_MSA_DBL_BIT_OP(v_xor, msa_eorq_s64)
-
-inline v_float64x2 v_not(const v_float64x2 &a) {
-  return v_float64x2(MSA_TPV_REINTERPRET(
-      v2f64, msa_mvnq_s32(MSA_TPV_REINTERPRET(v4i32, a.val))));
-}
-
-// TODO: exp, log, sin, cos
-
-#define OPENCV_HAL_IMPL_MSA_BIN_FUNC(_Tpvec, func, intrin)                     \
-  inline _Tpvec func(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(intrin(a.val, b.val));                                       \
-  }
-
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_uint8x16, v_min, msa_minq_u8)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_uint8x16, v_max, msa_maxq_u8)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_int8x16, v_min, msa_minq_s8)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_int8x16, v_max, msa_maxq_s8)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_uint16x8, v_min, msa_minq_u16)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_uint16x8, v_max, msa_maxq_u16)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_int16x8, v_min, msa_minq_s16)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_int16x8, v_max, msa_maxq_s16)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_uint32x4, v_min, msa_minq_u32)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_uint32x4, v_max, msa_maxq_u32)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_int32x4, v_min, msa_minq_s32)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_int32x4, v_max, msa_maxq_s32)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_float32x4, v_min, msa_minq_f32)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_float32x4, v_max, msa_maxq_f32)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_float64x2, v_min, msa_minq_f64)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_float64x2, v_max, msa_maxq_f64)
-
-#define OPENCV_HAL_IMPL_MSA_INT_CMP_OP(_Tpvec, _Tpv, suffix, not_suffix)       \
-  inline _Tpvec v_eq(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(MSA_TPV_REINTERPRET(_Tpv, msa_ceqq_##suffix(a.val, b.val))); \
-  }                                                                            \
-  inline _Tpvec v_ne(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(MSA_TPV_REINTERPRET(                                         \
-        _Tpv, msa_mvnq_##not_suffix(msa_ceqq_##suffix(a.val, b.val))));        \
-  }                                                                            \
-  inline _Tpvec v_lt(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(MSA_TPV_REINTERPRET(_Tpv, msa_cltq_##suffix(a.val, b.val))); \
-  }                                                                            \
-  inline _Tpvec v_gt(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(MSA_TPV_REINTERPRET(_Tpv, msa_cgtq_##suffix(a.val, b.val))); \
-  }                                                                            \
-  inline _Tpvec v_le(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(MSA_TPV_REINTERPRET(_Tpv, msa_cleq_##suffix(a.val, b.val))); \
-  }                                                                            \
-  inline _Tpvec v_ge(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(MSA_TPV_REINTERPRET(_Tpv, msa_cgeq_##suffix(a.val, b.val))); \
-  }
-
-OPENCV_HAL_IMPL_MSA_INT_CMP_OP(v_uint8x16, v16u8, u8, u8)
-OPENCV_HAL_IMPL_MSA_INT_CMP_OP(v_int8x16, v16i8, s8, u8)
-OPENCV_HAL_IMPL_MSA_INT_CMP_OP(v_uint16x8, v8u16, u16, u16)
-OPENCV_HAL_IMPL_MSA_INT_CMP_OP(v_int16x8, v8i16, s16, u16)
-OPENCV_HAL_IMPL_MSA_INT_CMP_OP(v_uint32x4, v4u32, u32, u32)
-OPENCV_HAL_IMPL_MSA_INT_CMP_OP(v_int32x4, v4i32, s32, u32)
-OPENCV_HAL_IMPL_MSA_INT_CMP_OP(v_float32x4, v4f32, f32, u32)
-OPENCV_HAL_IMPL_MSA_INT_CMP_OP(v_uint64x2, v2u64, u64, u64)
-OPENCV_HAL_IMPL_MSA_INT_CMP_OP(v_int64x2, v2i64, s64, u64)
-OPENCV_HAL_IMPL_MSA_INT_CMP_OP(v_float64x2, v2f64, f64, u64)
-
-inline v_float32x4 v_not_nan(const v_float32x4 &a) {
-  return v_float32x4(MSA_TPV_REINTERPRET(v4f32, msa_ceqq_f32(a.val, a.val)));
-}
-inline v_float64x2 v_not_nan(const v_float64x2 &a) {
-  return v_float64x2(MSA_TPV_REINTERPRET(v2f64, msa_ceqq_f64(a.val, a.val)));
-}
-
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_uint8x16, v_add_wrap, msa_addq_u8)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_int8x16, v_add_wrap, msa_addq_s8)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_uint16x8, v_add_wrap, msa_addq_u16)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_int16x8, v_add_wrap, msa_addq_s16)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_uint8x16, v_sub_wrap, msa_subq_u8)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_int8x16, v_sub_wrap, msa_subq_s8)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_uint16x8, v_sub_wrap, msa_subq_u16)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_int16x8, v_sub_wrap, msa_subq_s16)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_uint8x16, v_mul_wrap, msa_mulq_u8)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_int8x16, v_mul_wrap, msa_mulq_s8)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_uint16x8, v_mul_wrap, msa_mulq_u16)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_int16x8, v_mul_wrap, msa_mulq_s16)
-
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_uint8x16, v_absdiff, msa_abdq_u8)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_uint16x8, v_absdiff, msa_abdq_u16)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_uint32x4, v_absdiff, msa_abdq_u32)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_float32x4, v_absdiff, msa_abdq_f32)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_float64x2, v_absdiff, msa_abdq_f64)
-
-/** Saturating absolute difference **/
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_int8x16, v_absdiffs, msa_qabdq_s8)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC(v_int16x8, v_absdiffs, msa_qabdq_s16)
-
-#define OPENCV_HAL_IMPL_MSA_BIN_FUNC2(_Tpvec, _Tpvec2, _Tpv, func, intrin)     \
-  inline _Tpvec2 func(const _Tpvec &a, const _Tpvec &b) {                      \
-    return _Tpvec2(MSA_TPV_REINTERPRET(_Tpv, intrin(a.val, b.val)));           \
-  }
-
-OPENCV_HAL_IMPL_MSA_BIN_FUNC2(v_int8x16, v_uint8x16, v16u8, v_absdiff,
-                              msa_abdq_s8)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC2(v_int16x8, v_uint16x8, v8u16, v_absdiff,
-                              msa_abdq_s16)
-OPENCV_HAL_IMPL_MSA_BIN_FUNC2(v_int32x4, v_uint32x4, v4u32, v_absdiff,
-                              msa_abdq_s32)
-
-/* v_magnitude, v_sqr_magnitude, v_fma, v_muladd */
-inline v_float32x4 v_magnitude(const v_float32x4 &a, const v_float32x4 &b) {
-  v_float32x4 x(msa_mlaq_f32(msa_mulq_f32(a.val, a.val), b.val, b.val));
-  return v_sqrt(x);
-}
-
-inline v_float32x4 v_sqr_magnitude(const v_float32x4 &a, const v_float32x4 &b) {
-  return v_float32x4(msa_mlaq_f32(msa_mulq_f32(a.val, a.val), b.val, b.val));
-}
-
-inline v_float32x4 v_fma(const v_float32x4 &a, const v_float32x4 &b,
-                         const v_float32x4 &c) {
-  return v_float32x4(msa_mlaq_f32(c.val, a.val, b.val));
-}
-
-inline v_int32x4 v_fma(const v_int32x4 &a, const v_int32x4 &b,
-                       const v_int32x4 &c) {
-  return v_int32x4(msa_mlaq_s32(c.val, a.val, b.val));
-}
-
-inline v_float32x4 v_muladd(const v_float32x4 &a, const v_float32x4 &b,
-                            const v_float32x4 &c) {
-  return v_fma(a, b, c);
-}
-
-inline v_int32x4 v_muladd(const v_int32x4 &a, const v_int32x4 &b,
-                          const v_int32x4 &c) {
-  return v_fma(a, b, c);
-}
-
-inline v_float64x2 v_magnitude(const v_float64x2 &a, const v_float64x2 &b) {
-  v_float64x2 x(msa_mlaq_f64(msa_mulq_f64(a.val, a.val), b.val, b.val));
-  return v_sqrt(x);
-}
-
-inline v_float64x2 v_sqr_magnitude(const v_float64x2 &a, const v_float64x2 &b) {
-  return v_float64x2(msa_mlaq_f64(msa_mulq_f64(a.val, a.val), b.val, b.val));
-}
-
-inline v_float64x2 v_fma(const v_float64x2 &a, const v_float64x2 &b,
-                         const v_float64x2 &c) {
-  return v_float64x2(msa_mlaq_f64(c.val, a.val, b.val));
-}
-
-inline v_float64x2 v_muladd(const v_float64x2 &a, const v_float64x2 &b,
-                            const v_float64x2 &c) {
-  return v_fma(a, b, c);
-}
-
-// trade efficiency for convenience
-#define OPENCV_HAL_IMPL_MSA_SHIFT_OP(_Tpvec, suffix, _Tps, ssuffix)            \
-  inline _Tpvec v_shl(const _Tpvec &a, int n) {                                \
-    return _Tpvec(msa_shlq_##suffix(a.val, msa_dupq_n_##ssuffix((_Tps)n)));    \
-  }                                                                            \
-  inline _Tpvec v_shr(const _Tpvec &a, int n) {                                \
-    return _Tpvec(msa_shrq_##suffix(a.val, msa_dupq_n_##ssuffix((_Tps)n)));    \
-  }                                                                            \
-  template <int n> inline _Tpvec v_shl(const _Tpvec &a) {                      \
-    return _Tpvec(msa_shlq_n_##suffix(a.val, n));                              \
-  }                                                                            \
-  template <int n> inline _Tpvec v_shr(const _Tpvec &a) {                      \
-    return _Tpvec(msa_shrq_n_##suffix(a.val, n));                              \
-  }                                                                            \
-  template <int n> inline _Tpvec v_rshr(const _Tpvec &a) {                     \
-    return _Tpvec(msa_rshrq_n_##suffix(a.val, n));                             \
-  }
-
-OPENCV_HAL_IMPL_MSA_SHIFT_OP(v_uint8x16, u8, schar, s8)
-OPENCV_HAL_IMPL_MSA_SHIFT_OP(v_int8x16, s8, schar, s8)
-OPENCV_HAL_IMPL_MSA_SHIFT_OP(v_uint16x8, u16, short, s16)
-OPENCV_HAL_IMPL_MSA_SHIFT_OP(v_int16x8, s16, short, s16)
-OPENCV_HAL_IMPL_MSA_SHIFT_OP(v_uint32x4, u32, int, s32)
-OPENCV_HAL_IMPL_MSA_SHIFT_OP(v_int32x4, s32, int, s32)
-OPENCV_HAL_IMPL_MSA_SHIFT_OP(v_uint64x2, u64, int64, s64)
-OPENCV_HAL_IMPL_MSA_SHIFT_OP(v_int64x2, s64, int64, s64)
-
-/* v_rotate_right, v_rotate_left */
-#define OPENCV_HAL_IMPL_MSA_ROTATE_OP(_Tpvec, _Tpv, _Tpvs, suffix)             \
-  template <int n> inline _Tpvec v_rotate_right(const _Tpvec &a) {             \
-    return _Tpvec(MSA_TPV_REINTERPRET(                                         \
-        _Tpv, msa_extq_##suffix(MSA_TPV_REINTERPRET(_Tpvs, a.val),             \
-                                msa_dupq_n_##suffix(0), n)));                  \
-  }                                                                            \
-  template <int n> inline _Tpvec v_rotate_left(const _Tpvec &a) {              \
-    return _Tpvec(MSA_TPV_REINTERPRET(                                         \
-        _Tpv, msa_extq_##suffix(msa_dupq_n_##suffix(0),                        \
-                                MSA_TPV_REINTERPRET(_Tpvs, a.val),             \
-                                _Tpvec::nlanes - n)));                         \
-  }                                                                            \
-  template <> inline _Tpvec v_rotate_left<0>(const _Tpvec &a) { return a; }    \
-  template <int n>                                                             \
-  inline _Tpvec v_rotate_right(const _Tpvec &a, const _Tpvec &b) {             \
-    return _Tpvec(MSA_TPV_REINTERPRET(                                         \
-        _Tpv, msa_extq_##suffix(MSA_TPV_REINTERPRET(_Tpvs, a.val),             \
-                                MSA_TPV_REINTERPRET(_Tpvs, b.val), n)));       \
-  }                                                                            \
-  template <int n>                                                             \
-  inline _Tpvec v_rotate_left(const _Tpvec &a, const _Tpvec &b) {              \
-    return _Tpvec(MSA_TPV_REINTERPRET(                                         \
-        _Tpv, msa_extq_##suffix(MSA_TPV_REINTERPRET(_Tpvs, b.val),             \
-                                MSA_TPV_REINTERPRET(_Tpvs, a.val),             \
-                                _Tpvec::nlanes - n)));                         \
-  }                                                                            \
-  template <>                                                                  \
-  inline _Tpvec v_rotate_left<0>(const _Tpvec &a, const _Tpvec &b) {           \
-    CV_UNUSED(b);                                                              \
-    return a;                                                                  \
-  }
-
-OPENCV_HAL_IMPL_MSA_ROTATE_OP(v_uint8x16, v16u8, v16i8, s8)
-OPENCV_HAL_IMPL_MSA_ROTATE_OP(v_int8x16, v16i8, v16i8, s8)
-OPENCV_HAL_IMPL_MSA_ROTATE_OP(v_uint16x8, v8u16, v8i16, s16)
-OPENCV_HAL_IMPL_MSA_ROTATE_OP(v_int16x8, v8i16, v8i16, s16)
-OPENCV_HAL_IMPL_MSA_ROTATE_OP(v_uint32x4, v4u32, v4i32, s32)
-OPENCV_HAL_IMPL_MSA_ROTATE_OP(v_int32x4, v4i32, v4i32, s32)
-OPENCV_HAL_IMPL_MSA_ROTATE_OP(v_float32x4, v4f32, v4i32, s32)
-OPENCV_HAL_IMPL_MSA_ROTATE_OP(v_uint64x2, v2u64, v2i64, s64)
-OPENCV_HAL_IMPL_MSA_ROTATE_OP(v_int64x2, v2i64, v2i64, s64)
-OPENCV_HAL_IMPL_MSA_ROTATE_OP(v_float64x2, v2f64, v2i64, s64)
-
-#define OPENCV_HAL_IMPL_MSA_LOADSTORE_OP(_Tpvec, _Tp, suffix)                  \
-  inline _Tpvec v_load(const _Tp *ptr) {                                       \
-    return _Tpvec(msa_ld1q_##suffix(ptr));                                     \
-  }                                                                            \
-  inline _Tpvec v_load_aligned(const _Tp *ptr) {                               \
-    return _Tpvec(msa_ld1q_##suffix(ptr));                                     \
-  }                                                                            \
-  inline _Tpvec v_load_low(const _Tp *ptr) {                                   \
-    return _Tpvec(msa_combine_##suffix(msa_ld1_##suffix(ptr),                  \
-                                       msa_dup_n_##suffix((_Tp)0)));           \
-  }                                                                            \
-  inline _Tpvec v_load_halves(const _Tp *ptr0, const _Tp *ptr1) {              \
-    return _Tpvec(                                                             \
-        msa_combine_##suffix(msa_ld1_##suffix(ptr0), msa_ld1_##suffix(ptr1))); \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a) {                             \
-    msa_st1q_##suffix(ptr, a.val);                                             \
-  }                                                                            \
-  inline void v_store_aligned(_Tp *ptr, const _Tpvec &a) {                     \
-    msa_st1q_##suffix(ptr, a.val);                                             \
-  }                                                                            \
-  inline void v_store_aligned_nocache(_Tp *ptr, const _Tpvec &a) {             \
-    msa_st1q_##suffix(ptr, a.val);                                             \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a, hal::StoreMode /*mode*/) {    \
-    msa_st1q_##suffix(ptr, a.val);                                             \
-  }                                                                            \
-  inline void v_store_low(_Tp *ptr, const _Tpvec &a) {                         \
-    int n = _Tpvec::nlanes;                                                    \
-    for (int i = 0; i < (n / 2); i++)                                          \
-      ptr[i] = a.val[i];                                                       \
-  }                                                                            \
-  inline void v_store_high(_Tp *ptr, const _Tpvec &a) {                        \
-    int n = _Tpvec::nlanes;                                                    \
-    for (int i = 0; i < (n / 2); i++)                                          \
-      ptr[i] = a.val[i + (n / 2)];                                             \
-  }
-
-OPENCV_HAL_IMPL_MSA_LOADSTORE_OP(v_uint8x16, uchar, u8)
-OPENCV_HAL_IMPL_MSA_LOADSTORE_OP(v_int8x16, schar, s8)
-OPENCV_HAL_IMPL_MSA_LOADSTORE_OP(v_uint16x8, ushort, u16)
-OPENCV_HAL_IMPL_MSA_LOADSTORE_OP(v_int16x8, short, s16)
-OPENCV_HAL_IMPL_MSA_LOADSTORE_OP(v_uint32x4, unsigned, u32)
-OPENCV_HAL_IMPL_MSA_LOADSTORE_OP(v_int32x4, int, s32)
-OPENCV_HAL_IMPL_MSA_LOADSTORE_OP(v_uint64x2, uint64, u64)
-OPENCV_HAL_IMPL_MSA_LOADSTORE_OP(v_int64x2, int64, s64)
-OPENCV_HAL_IMPL_MSA_LOADSTORE_OP(v_float32x4, float, f32)
-OPENCV_HAL_IMPL_MSA_LOADSTORE_OP(v_float64x2, double, f64)
-
-/** Reverse **/
-inline v_uint8x16 v_reverse(const v_uint8x16 &a) {
-  v_uint8x16 c = v_uint8x16((v16u8)__builtin_msa_vshf_b(
-      (v16i8)((v2i64){0x08090A0B0C0D0E0F, 0x0001020304050607}),
-      msa_dupq_n_s8(0), (v16i8)a.val));
-  return c;
-}
-
-inline v_int8x16 v_reverse(const v_int8x16 &a) {
-  return v_reinterpret_as_s8(v_reverse(v_reinterpret_as_u8(a)));
-}
-
-inline v_uint16x8 v_reverse(const v_uint16x8 &a) {
-  v_uint16x8 c = v_uint16x8((v8u16)__builtin_msa_vshf_h(
-      (v8i16)((v2i64){0x0004000500060007, 0x0000000100020003}),
-      msa_dupq_n_s16(0), (v8i16)a.val));
-  return c;
-}
-
-inline v_int16x8 v_reverse(const v_int16x8 &a) {
-  return v_reinterpret_as_s16(v_reverse(v_reinterpret_as_u16(a)));
-}
-
-inline v_uint32x4 v_reverse(const v_uint32x4 &a) {
-  v_uint32x4 c;
-  c.val[0] = a.val[3];
-  c.val[1] = a.val[2];
-  c.val[2] = a.val[1];
-  c.val[3] = a.val[0];
-  return c;
-}
-
-inline v_int32x4 v_reverse(const v_int32x4 &a) {
-  return v_reinterpret_as_s32(v_reverse(v_reinterpret_as_u32(a)));
-}
-
-inline v_float32x4 v_reverse(const v_float32x4 &a) {
-  return v_reinterpret_as_f32(v_reverse(v_reinterpret_as_u32(a)));
-}
-
-inline v_uint64x2 v_reverse(const v_uint64x2 &a) {
-  v_uint64x2 c;
-  c.val[0] = a.val[1];
-  c.val[1] = a.val[0];
-  return c;
-}
-
-inline v_int64x2 v_reverse(const v_int64x2 &a) {
-  return v_reinterpret_as_s64(v_reverse(v_reinterpret_as_u64(a)));
-}
-
-inline v_float64x2 v_reverse(const v_float64x2 &a) {
-  return v_reinterpret_as_f64(v_reverse(v_reinterpret_as_u64(a)));
-}
-
-#define OPENCV_HAL_IMPL_MSA_REDUCE_OP_8U(func, cfunc)                          \
-  inline unsigned short v_reduce_##func(const v_uint16x8 &a) {                 \
-    v8u16 a_lo, a_hi;                                                          \
-    ILVRL_H2_UH(a.val, msa_dupq_n_u16(0), a_lo, a_hi);                         \
-    v4u32 b = msa_##func##q_u32(msa_paddlq_u16(a_lo), msa_paddlq_u16(a_hi));   \
-    v4u32 b_lo, b_hi;                                                          \
-    ILVRL_W2_UW(b, msa_dupq_n_u32(0), b_lo, b_hi);                             \
-    v2u64 c = msa_##func##q_u64(msa_paddlq_u32(b_lo), msa_paddlq_u32(b_hi));   \
-    return (unsigned short)cfunc(c[0], c[1]);                                  \
-  }
-
-OPENCV_HAL_IMPL_MSA_REDUCE_OP_8U(max, std::max)
-OPENCV_HAL_IMPL_MSA_REDUCE_OP_8U(min, std::min)
-
-#define OPENCV_HAL_IMPL_MSA_REDUCE_OP_8S(func, cfunc)                          \
-  inline short v_reduce_##func(const v_int16x8 &a) {                           \
-    v8i16 a_lo, a_hi;                                                          \
-    ILVRL_H2_SH(a.val, msa_dupq_n_s16(0), a_lo, a_hi);                         \
-    v4i32 b = msa_##func##q_s32(msa_paddlq_s16(a_lo), msa_paddlq_s16(a_hi));   \
-    v4i32 b_lo, b_hi;                                                          \
-    ILVRL_W2_SW(b, msa_dupq_n_s32(0), b_lo, b_hi);                             \
-    v2i64 c = msa_##func##q_s64(msa_paddlq_s32(b_lo), msa_paddlq_s32(b_hi));   \
-    return (short)cfunc(c[0], c[1]);                                           \
-  }
-
-OPENCV_HAL_IMPL_MSA_REDUCE_OP_8S(max, std::max)
-OPENCV_HAL_IMPL_MSA_REDUCE_OP_8S(min, std::min)
-
-#define OPENCV_HAL_IMPL_MSA_REDUCE_OP_4(_Tpvec, scalartype, func, cfunc)       \
-  inline scalartype v_reduce_##func(const _Tpvec &a) {                         \
-    return (scalartype)cfunc(cfunc(a.val[0], a.val[1]),                        \
-                             cfunc(a.val[2], a.val[3]));                       \
-  }
-
-OPENCV_HAL_IMPL_MSA_REDUCE_OP_4(v_uint32x4, unsigned, max, std::max)
-OPENCV_HAL_IMPL_MSA_REDUCE_OP_4(v_uint32x4, unsigned, min, std::min)
-OPENCV_HAL_IMPL_MSA_REDUCE_OP_4(v_int32x4, int, max, std::max)
-OPENCV_HAL_IMPL_MSA_REDUCE_OP_4(v_int32x4, int, min, std::min)
-OPENCV_HAL_IMPL_MSA_REDUCE_OP_4(v_float32x4, float, max, std::max)
-OPENCV_HAL_IMPL_MSA_REDUCE_OP_4(v_float32x4, float, min, std::min)
-
-#define OPENCV_HAL_IMPL_MSA_REDUCE_OP_16(_Tpvec, scalartype, _Tpvec2, func)    \
-  inline scalartype v_reduce_##func(const _Tpvec &a) {                         \
-    _Tpvec2 a1, a2;                                                            \
-    v_expand(a, a1, a2);                                                       \
-    return (scalartype)v_reduce_##func(v_##func(a1, a2));                      \
-  }
-
-OPENCV_HAL_IMPL_MSA_REDUCE_OP_16(v_uint8x16, uchar, v_uint16x8, min)
-OPENCV_HAL_IMPL_MSA_REDUCE_OP_16(v_uint8x16, uchar, v_uint16x8, max)
-OPENCV_HAL_IMPL_MSA_REDUCE_OP_16(v_int8x16, char, v_int16x8, min)
-OPENCV_HAL_IMPL_MSA_REDUCE_OP_16(v_int8x16, char, v_int16x8, max)
-
-#define OPENCV_HAL_IMPL_MSA_REDUCE_SUM(_Tpvec, scalartype, suffix)             \
-  inline scalartype v_reduce_sum(const _Tpvec &a) {                            \
-    return (scalartype)msa_sum_##suffix(a.val);                                \
-  }
-
-OPENCV_HAL_IMPL_MSA_REDUCE_SUM(v_uint8x16, unsigned short, u8)
-OPENCV_HAL_IMPL_MSA_REDUCE_SUM(v_int8x16, short, s8)
-OPENCV_HAL_IMPL_MSA_REDUCE_SUM(v_uint16x8, unsigned, u16)
-OPENCV_HAL_IMPL_MSA_REDUCE_SUM(v_int16x8, int, s16)
-OPENCV_HAL_IMPL_MSA_REDUCE_SUM(v_uint32x4, uint64_t, u32)
-OPENCV_HAL_IMPL_MSA_REDUCE_SUM(v_int32x4, int64_t, s32)
-OPENCV_HAL_IMPL_MSA_REDUCE_SUM(v_float32x4, float, f32)
-
-inline uint64 v_reduce_sum(const v_uint64x2 &a) {
-  return (uint64)(msa_getq_lane_u64(a.val, 0) + msa_getq_lane_u64(a.val, 1));
-}
-inline int64 v_reduce_sum(const v_int64x2 &a) {
-  return (int64)(msa_getq_lane_s64(a.val, 0) + msa_getq_lane_s64(a.val, 1));
-}
-inline double v_reduce_sum(const v_float64x2 &a) {
-  return msa_getq_lane_f64(a.val, 0) + msa_getq_lane_f64(a.val, 1);
-}
-
-/* v_reduce_sum4, v_reduce_sad */
-inline v_float32x4 v_reduce_sum4(const v_float32x4 &a, const v_float32x4 &b,
-                                 const v_float32x4 &c, const v_float32x4 &d) {
-  v4f32 u0 = msa_addq_f32(
-      MSA_TPV_REINTERPRET(v4f32,
-                          msa_ilvevq_s32(MSA_TPV_REINTERPRET(v4i32, b.val),
-                                         MSA_TPV_REINTERPRET(v4i32, a.val))),
-      MSA_TPV_REINTERPRET(
-          v4f32, msa_ilvodq_s32(MSA_TPV_REINTERPRET(v4i32, b.val),
-                                MSA_TPV_REINTERPRET(
-                                    v4i32, a.val)))); // a0+a1 b0+b1 a2+a3 b2+b3
-  v4f32 u1 = msa_addq_f32(
-      MSA_TPV_REINTERPRET(v4f32,
-                          msa_ilvevq_s32(MSA_TPV_REINTERPRET(v4i32, d.val),
-                                         MSA_TPV_REINTERPRET(v4i32, c.val))),
-      MSA_TPV_REINTERPRET(
-          v4f32, msa_ilvodq_s32(MSA_TPV_REINTERPRET(v4i32, d.val),
-                                MSA_TPV_REINTERPRET(
-                                    v4i32, c.val)))); // c0+c1 d0+d1 c2+c3 d2+d3
-
-  return v_float32x4(msa_addq_f32(
-      MSA_TPV_REINTERPRET(v4f32, msa_ilvrq_s64(MSA_TPV_REINTERPRET(v2i64, u1),
-                                               MSA_TPV_REINTERPRET(v2i64, u0))),
-      MSA_TPV_REINTERPRET(v4f32,
-                          msa_ilvlq_s64(MSA_TPV_REINTERPRET(v2i64, u1),
-                                        MSA_TPV_REINTERPRET(v2i64, u0)))));
-}
-
-inline unsigned v_reduce_sad(const v_uint8x16 &a, const v_uint8x16 &b) {
-  v16u8 t0 = msa_abdq_u8(a.val, b.val);
-  v8u16 t1 = msa_paddlq_u8(t0);
-  v4u32 t2 = msa_paddlq_u16(t1);
-  return msa_sum_u32(t2);
-}
-inline unsigned v_reduce_sad(const v_int8x16 &a, const v_int8x16 &b) {
-  v16u8 t0 = MSA_TPV_REINTERPRET(v16u8, msa_abdq_s8(a.val, b.val));
-  v8u16 t1 = msa_paddlq_u8(t0);
-  v4u32 t2 = msa_paddlq_u16(t1);
-  return msa_sum_u32(t2);
-}
-inline unsigned v_reduce_sad(const v_uint16x8 &a, const v_uint16x8 &b) {
-  v8u16 t0 = msa_abdq_u16(a.val, b.val);
-  v4u32 t1 = msa_paddlq_u16(t0);
-  return msa_sum_u32(t1);
-}
-inline unsigned v_reduce_sad(const v_int16x8 &a, const v_int16x8 &b) {
-  v8u16 t0 = MSA_TPV_REINTERPRET(v8u16, msa_abdq_s16(a.val, b.val));
-  v4u32 t1 = msa_paddlq_u16(t0);
-  return msa_sum_u32(t1);
-}
-inline unsigned v_reduce_sad(const v_uint32x4 &a, const v_uint32x4 &b) {
-  v4u32 t0 = msa_abdq_u32(a.val, b.val);
-  return msa_sum_u32(t0);
-}
-inline unsigned v_reduce_sad(const v_int32x4 &a, const v_int32x4 &b) {
-  v4u32 t0 = MSA_TPV_REINTERPRET(v4u32, msa_abdq_s32(a.val, b.val));
-  return msa_sum_u32(t0);
-}
-inline float v_reduce_sad(const v_float32x4 &a, const v_float32x4 &b) {
-  v4f32 t0 = msa_abdq_f32(a.val, b.val);
-  return msa_sum_f32(t0);
-}
-
-/* v_popcount */
-#define OPENCV_HAL_IMPL_MSA_POPCOUNT_SIZE8(_Tpvec)                             \
-  inline v_uint8x16 v_popcount(const _Tpvec &a) {                              \
-    v16u8 t = MSA_TPV_REINTERPRET(                                             \
-        v16u8, msa_cntq_s8(MSA_TPV_REINTERPRET(v16i8, a.val)));                \
-    return v_uint8x16(t);                                                      \
-  }
-OPENCV_HAL_IMPL_MSA_POPCOUNT_SIZE8(v_uint8x16)
-OPENCV_HAL_IMPL_MSA_POPCOUNT_SIZE8(v_int8x16)
-
-#define OPENCV_HAL_IMPL_MSA_POPCOUNT_SIZE16(_Tpvec)                            \
-  inline v_uint16x8 v_popcount(const _Tpvec &a) {                              \
-    v8u16 t = MSA_TPV_REINTERPRET(                                             \
-        v8u16, msa_cntq_s16(MSA_TPV_REINTERPRET(v8i16, a.val)));               \
-    return v_uint16x8(t);                                                      \
-  }
-OPENCV_HAL_IMPL_MSA_POPCOUNT_SIZE16(v_uint16x8)
-OPENCV_HAL_IMPL_MSA_POPCOUNT_SIZE16(v_int16x8)
-
-#define OPENCV_HAL_IMPL_MSA_POPCOUNT_SIZE32(_Tpvec)                            \
-  inline v_uint32x4 v_popcount(const _Tpvec &a) {                              \
-    v4u32 t = MSA_TPV_REINTERPRET(                                             \
-        v4u32, msa_cntq_s32(MSA_TPV_REINTERPRET(v4i32, a.val)));               \
-    return v_uint32x4(t);                                                      \
-  }
-OPENCV_HAL_IMPL_MSA_POPCOUNT_SIZE32(v_uint32x4)
-OPENCV_HAL_IMPL_MSA_POPCOUNT_SIZE32(v_int32x4)
-
-#define OPENCV_HAL_IMPL_MSA_POPCOUNT_SIZE64(_Tpvec)                            \
-  inline v_uint64x2 v_popcount(const _Tpvec &a) {                              \
-    v2u64 t = MSA_TPV_REINTERPRET(                                             \
-        v2u64, msa_cntq_s64(MSA_TPV_REINTERPRET(v2i64, a.val)));               \
-    return v_uint64x2(t);                                                      \
-  }
-OPENCV_HAL_IMPL_MSA_POPCOUNT_SIZE64(v_uint64x2)
-OPENCV_HAL_IMPL_MSA_POPCOUNT_SIZE64(v_int64x2)
-
-inline int v_signmask(const v_uint8x16 &a) {
-  v8i8 m0 = msa_create_s8(CV_BIG_UINT(0x0706050403020100));
-  v16u8 v0 = msa_shlq_u8(msa_shrq_n_u8(a.val, 7), msa_combine_s8(m0, m0));
-  v8u16 v1 = msa_paddlq_u8(v0);
-  v4u32 v2 = msa_paddlq_u16(v1);
-  v2u64 v3 = msa_paddlq_u32(v2);
-  return (int)msa_getq_lane_u64(v3, 0) + ((int)msa_getq_lane_u64(v3, 1) << 8);
-}
-inline int v_signmask(const v_int8x16 &a) {
-  return v_signmask(v_reinterpret_as_u8(a));
-}
-
-inline int v_signmask(const v_uint16x8 &a) {
-  v4i16 m0 = msa_create_s16(CV_BIG_UINT(0x0003000200010000));
-  v8u16 v0 = msa_shlq_u16(msa_shrq_n_u16(a.val, 15), msa_combine_s16(m0, m0));
-  v4u32 v1 = msa_paddlq_u16(v0);
-  v2u64 v2 = msa_paddlq_u32(v1);
-  return (int)msa_getq_lane_u64(v2, 0) + ((int)msa_getq_lane_u64(v2, 1) << 4);
-}
-inline int v_signmask(const v_int16x8 &a) {
-  return v_signmask(v_reinterpret_as_u16(a));
-}
-
-inline int v_signmask(const v_uint32x4 &a) {
-  v2i32 m0 = msa_create_s32(CV_BIG_UINT(0x0000000100000000));
-  v4u32 v0 = msa_shlq_u32(msa_shrq_n_u32(a.val, 31), msa_combine_s32(m0, m0));
-  v2u64 v1 = msa_paddlq_u32(v0);
-  return (int)msa_getq_lane_u64(v1, 0) + ((int)msa_getq_lane_u64(v1, 1) << 2);
-}
-inline int v_signmask(const v_int32x4 &a) {
-  return v_signmask(v_reinterpret_as_u32(a));
-}
-inline int v_signmask(const v_float32x4 &a) {
-  return v_signmask(v_reinterpret_as_u32(a));
-}
-
-inline int v_signmask(const v_uint64x2 &a) {
-  v2u64 v0 = msa_shrq_n_u64(a.val, 63);
-  return (int)msa_getq_lane_u64(v0, 0) + ((int)msa_getq_lane_u64(v0, 1) << 1);
-}
-inline int v_signmask(const v_int64x2 &a) {
-  return v_signmask(v_reinterpret_as_u64(a));
-}
-inline int v_signmask(const v_float64x2 &a) {
-  return v_signmask(v_reinterpret_as_u64(a));
-}
-
-inline int v_scan_forward(const v_int8x16 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_uint8x16 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_int16x8 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_uint16x8 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_int32x4 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_uint32x4 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_float32x4 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_int64x2 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_uint64x2 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_float64x2 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-
-#define OPENCV_HAL_IMPL_MSA_CHECK_ALLANY(_Tpvec, _Tpvec2, suffix, shift)       \
-  inline bool v_check_all(const v_##_Tpvec &a) {                               \
-    _Tpvec2 v0 = msa_shrq_n_##suffix(msa_mvnq_##suffix(a.val), shift);         \
-    v2u64 v1 = MSA_TPV_REINTERPRET(v2u64, v0);                                 \
-    return (msa_getq_lane_u64(v1, 0) | msa_getq_lane_u64(v1, 1)) == 0;         \
-  }                                                                            \
-  inline bool v_check_any(const v_##_Tpvec &a) {                               \
-    _Tpvec2 v0 = msa_shrq_n_##suffix(a.val, shift);                            \
-    v2u64 v1 = MSA_TPV_REINTERPRET(v2u64, v0);                                 \
-    return (msa_getq_lane_u64(v1, 0) | msa_getq_lane_u64(v1, 1)) != 0;         \
-  }
-
-OPENCV_HAL_IMPL_MSA_CHECK_ALLANY(uint8x16, v16u8, u8, 7)
-OPENCV_HAL_IMPL_MSA_CHECK_ALLANY(uint16x8, v8u16, u16, 15)
-OPENCV_HAL_IMPL_MSA_CHECK_ALLANY(uint32x4, v4u32, u32, 31)
-OPENCV_HAL_IMPL_MSA_CHECK_ALLANY(uint64x2, v2u64, u64, 63)
-
-inline bool v_check_all(const v_int8x16 &a) {
-  return v_check_all(v_reinterpret_as_u8(a));
-}
-inline bool v_check_all(const v_int16x8 &a) {
-  return v_check_all(v_reinterpret_as_u16(a));
-}
-inline bool v_check_all(const v_int32x4 &a) {
-  return v_check_all(v_reinterpret_as_u32(a));
-}
-inline bool v_check_all(const v_float32x4 &a) {
-  return v_check_all(v_reinterpret_as_u32(a));
-}
-
-inline bool v_check_any(const v_int8x16 &a) {
-  return v_check_any(v_reinterpret_as_u8(a));
-}
-inline bool v_check_any(const v_int16x8 &a) {
-  return v_check_any(v_reinterpret_as_u16(a));
-}
-inline bool v_check_any(const v_int32x4 &a) {
-  return v_check_any(v_reinterpret_as_u32(a));
-}
-inline bool v_check_any(const v_float32x4 &a) {
-  return v_check_any(v_reinterpret_as_u32(a));
-}
-
-inline bool v_check_all(const v_int64x2 &a) {
-  return v_check_all(v_reinterpret_as_u64(a));
-}
-inline bool v_check_all(const v_float64x2 &a) {
-  return v_check_all(v_reinterpret_as_u64(a));
-}
-inline bool v_check_any(const v_int64x2 &a) {
-  return v_check_any(v_reinterpret_as_u64(a));
-}
-inline bool v_check_any(const v_float64x2 &a) {
-  return v_check_any(v_reinterpret_as_u64(a));
-}
-
-/* v_select */
-#define OPENCV_HAL_IMPL_MSA_SELECT(_Tpvec, _Tpv, _Tpvu)                        \
-  inline _Tpvec v_select(const _Tpvec &mask, const _Tpvec &a,                  \
-                         const _Tpvec &b) {                                    \
-    return _Tpvec(MSA_TPV_REINTERPRET(                                         \
-        _Tpv, msa_bslq_u8(MSA_TPV_REINTERPRET(_Tpvu, mask.val),                \
-                          MSA_TPV_REINTERPRET(_Tpvu, b.val),                   \
-                          MSA_TPV_REINTERPRET(_Tpvu, a.val))));                \
-  }
-
-OPENCV_HAL_IMPL_MSA_SELECT(v_uint8x16, v16u8, v16u8)
-OPENCV_HAL_IMPL_MSA_SELECT(v_int8x16, v16i8, v16u8)
-OPENCV_HAL_IMPL_MSA_SELECT(v_uint16x8, v8u16, v16u8)
-OPENCV_HAL_IMPL_MSA_SELECT(v_int16x8, v8i16, v16u8)
-OPENCV_HAL_IMPL_MSA_SELECT(v_uint32x4, v4u32, v16u8)
-OPENCV_HAL_IMPL_MSA_SELECT(v_int32x4, v4i32, v16u8)
-OPENCV_HAL_IMPL_MSA_SELECT(v_float32x4, v4f32, v16u8)
-OPENCV_HAL_IMPL_MSA_SELECT(v_float64x2, v2f64, v16u8)
-
-#define OPENCV_HAL_IMPL_MSA_EXPAND(_Tpvec, _Tpwvec, _Tp, suffix, ssuffix,      \
-                                   _Tpv, _Tpvs)                                \
-  inline void v_expand(const _Tpvec &a, _Tpwvec &b0, _Tpwvec &b1) {            \
-    _Tpv a_lo = MSA_TPV_REINTERPRET(                                           \
-        _Tpv, msa_ilvrq_##ssuffix(MSA_TPV_REINTERPRET(_Tpvs, a.val),           \
-                                  msa_dupq_n_##ssuffix(0)));                   \
-    _Tpv a_hi = MSA_TPV_REINTERPRET(                                           \
-        _Tpv, msa_ilvlq_##ssuffix(MSA_TPV_REINTERPRET(_Tpvs, a.val),           \
-                                  msa_dupq_n_##ssuffix(0)));                   \
-    b0.val = msa_paddlq_##suffix(a_lo);                                        \
-    b1.val = msa_paddlq_##suffix(a_hi);                                        \
-  }                                                                            \
-  inline _Tpwvec v_expand_low(const _Tpvec &a) {                               \
-    _Tpv a_lo = MSA_TPV_REINTERPRET(                                           \
-        _Tpv, msa_ilvrq_##ssuffix(MSA_TPV_REINTERPRET(_Tpvs, a.val),           \
-                                  msa_dupq_n_##ssuffix(0)));                   \
-    return _Tpwvec(msa_paddlq_##suffix(a_lo));                                 \
-  }                                                                            \
-  inline _Tpwvec v_expand_high(const _Tpvec &a) {                              \
-    _Tpv a_hi = MSA_TPV_REINTERPRET(                                           \
-        _Tpv, msa_ilvlq_##ssuffix(MSA_TPV_REINTERPRET(_Tpvs, a.val),           \
-                                  msa_dupq_n_##ssuffix(0)));                   \
-    return _Tpwvec(msa_paddlq_##suffix(a_hi));                                 \
-  }                                                                            \
-  inline _Tpwvec v_load_expand(const _Tp *ptr) {                               \
-    return _Tpwvec(msa_movl_##suffix(msa_ld1_##suffix(ptr)));                  \
-  }
-
-OPENCV_HAL_IMPL_MSA_EXPAND(v_uint8x16, v_uint16x8, uchar, u8, s8, v16u8, v16i8)
-OPENCV_HAL_IMPL_MSA_EXPAND(v_int8x16, v_int16x8, schar, s8, s8, v16i8, v16i8)
-OPENCV_HAL_IMPL_MSA_EXPAND(v_uint16x8, v_uint32x4, ushort, u16, s16, v8u16,
-                           v8i16)
-OPENCV_HAL_IMPL_MSA_EXPAND(v_int16x8, v_int32x4, short, s16, s16, v8i16, v8i16)
-OPENCV_HAL_IMPL_MSA_EXPAND(v_uint32x4, v_uint64x2, uint, u32, s32, v4u32, v4i32)
-OPENCV_HAL_IMPL_MSA_EXPAND(v_int32x4, v_int64x2, int, s32, s32, v4i32, v4i32)
-
-inline v_uint32x4 v_load_expand_q(const uchar *ptr) {
-  return v_uint32x4((v4u32){ptr[0], ptr[1], ptr[2], ptr[3]});
-}
-
-inline v_int32x4 v_load_expand_q(const schar *ptr) {
-  return v_int32x4((v4i32){ptr[0], ptr[1], ptr[2], ptr[3]});
-}
-
-/* v_zip, v_combine_low, v_combine_high, v_recombine */
-#define OPENCV_HAL_IMPL_MSA_UNPACKS(_Tpvec, _Tpv, _Tpvs, ssuffix)              \
-  inline void v_zip(const _Tpvec &a0, const _Tpvec &a1, _Tpvec &b0,            \
-                    _Tpvec &b1) {                                              \
-    b0.val = MSA_TPV_REINTERPRET(                                              \
-        _Tpv, msa_ilvrq_##ssuffix(MSA_TPV_REINTERPRET(_Tpvs, a1.val),          \
-                                  MSA_TPV_REINTERPRET(_Tpvs, a0.val)));        \
-    b1.val = MSA_TPV_REINTERPRET(                                              \
-        _Tpv, msa_ilvlq_##ssuffix(MSA_TPV_REINTERPRET(_Tpvs, a1.val),          \
-                                  MSA_TPV_REINTERPRET(_Tpvs, a0.val)));        \
-  }                                                                            \
-  inline _Tpvec v_combine_low(const _Tpvec &a, const _Tpvec &b) {              \
-    return _Tpvec(MSA_TPV_REINTERPRET(                                         \
-        _Tpv, msa_ilvrq_s64(MSA_TPV_REINTERPRET(v2i64, b.val),                 \
-                            MSA_TPV_REINTERPRET(v2i64, a.val))));              \
-  }                                                                            \
-  inline _Tpvec v_combine_high(const _Tpvec &a, const _Tpvec &b) {             \
-    return _Tpvec(MSA_TPV_REINTERPRET(                                         \
-        _Tpv, msa_ilvlq_s64(MSA_TPV_REINTERPRET(v2i64, b.val),                 \
-                            MSA_TPV_REINTERPRET(v2i64, a.val))));              \
-  }                                                                            \
-  inline void v_recombine(const _Tpvec &a, const _Tpvec &b, _Tpvec &c,         \
-                          _Tpvec &d) {                                         \
-    c.val = MSA_TPV_REINTERPRET(                                               \
-        _Tpv, msa_ilvrq_s64(MSA_TPV_REINTERPRET(v2i64, b.val),                 \
-                            MSA_TPV_REINTERPRET(v2i64, a.val)));               \
-    d.val = MSA_TPV_REINTERPRET(                                               \
-        _Tpv, msa_ilvlq_s64(MSA_TPV_REINTERPRET(v2i64, b.val),                 \
-                            MSA_TPV_REINTERPRET(v2i64, a.val)));               \
-  }
-
-OPENCV_HAL_IMPL_MSA_UNPACKS(v_uint8x16, v16u8, v16i8, s8)
-OPENCV_HAL_IMPL_MSA_UNPACKS(v_int8x16, v16i8, v16i8, s8)
-OPENCV_HAL_IMPL_MSA_UNPACKS(v_uint16x8, v8u16, v8i16, s16)
-OPENCV_HAL_IMPL_MSA_UNPACKS(v_int16x8, v8i16, v8i16, s16)
-OPENCV_HAL_IMPL_MSA_UNPACKS(v_uint32x4, v4u32, v4i32, s32)
-OPENCV_HAL_IMPL_MSA_UNPACKS(v_int32x4, v4i32, v4i32, s32)
-OPENCV_HAL_IMPL_MSA_UNPACKS(v_float32x4, v4f32, v4i32, s32)
-OPENCV_HAL_IMPL_MSA_UNPACKS(v_float64x2, v2f64, v2i64, s64)
-
-/* v_extract */
-#define OPENCV_HAL_IMPL_MSA_EXTRACT(_Tpvec, _Tpv, _Tpvs, suffix)               \
-  template <int s> inline _Tpvec v_extract(const _Tpvec &a, const _Tpvec &b) { \
-    return _Tpvec(MSA_TPV_REINTERPRET(                                         \
-        _Tpv, msa_extq_##suffix(MSA_TPV_REINTERPRET(_Tpvs, a.val),             \
-                                MSA_TPV_REINTERPRET(_Tpvs, b.val), s)));       \
-  }
-
-OPENCV_HAL_IMPL_MSA_EXTRACT(v_uint8x16, v16u8, v16i8, s8)
-OPENCV_HAL_IMPL_MSA_EXTRACT(v_int8x16, v16i8, v16i8, s8)
-OPENCV_HAL_IMPL_MSA_EXTRACT(v_uint16x8, v8u16, v8i16, s16)
-OPENCV_HAL_IMPL_MSA_EXTRACT(v_int16x8, v8i16, v8i16, s16)
-OPENCV_HAL_IMPL_MSA_EXTRACT(v_uint32x4, v4u32, v4i32, s32)
-OPENCV_HAL_IMPL_MSA_EXTRACT(v_int32x4, v4i32, v4i32, s32)
-OPENCV_HAL_IMPL_MSA_EXTRACT(v_uint64x2, v2u64, v2i64, s64)
-OPENCV_HAL_IMPL_MSA_EXTRACT(v_int64x2, v2i64, v2i64, s64)
-OPENCV_HAL_IMPL_MSA_EXTRACT(v_float32x4, v4f32, v4i32, s32)
-OPENCV_HAL_IMPL_MSA_EXTRACT(v_float64x2, v2f64, v2i64, s64)
-
-/* v_round, v_floor, v_ceil, v_trunc */
-inline v_int32x4 v_round(const v_float32x4 &a) {
-  return v_int32x4(msa_cvttintq_s32_f32(a.val));
-}
-
-inline v_int32x4 v_floor(const v_float32x4 &a) {
-  v4i32 a1 = msa_cvttintq_s32_f32(a.val);
-  return v_int32x4(msa_addq_s32(
-      a1, MSA_TPV_REINTERPRET(v4i32,
-                              msa_cgtq_f32(msa_cvtfintq_f32_s32(a1), a.val))));
-}
-
-inline v_int32x4 v_ceil(const v_float32x4 &a) {
-  v4i32 a1 = msa_cvttintq_s32_f32(a.val);
-  return v_int32x4(msa_subq_s32(
-      a1, MSA_TPV_REINTERPRET(v4i32,
-                              msa_cgtq_f32(a.val, msa_cvtfintq_f32_s32(a1)))));
-}
-
-inline v_int32x4 v_trunc(const v_float32x4 &a) {
-  return v_int32x4(msa_cvttruncq_s32_f32(a.val));
-}
-
-inline v_int32x4 v_round(const v_float64x2 &a) {
-  return v_int32x4(
-      msa_pack_s64(msa_cvttintq_s64_f64(a.val), msa_dupq_n_s64(0)));
-}
-
-inline v_int32x4 v_round(const v_float64x2 &a, const v_float64x2 &b) {
-  return v_int32x4(
-      msa_pack_s64(msa_cvttintq_s64_f64(a.val), msa_cvttintq_s64_f64(b.val)));
-}
-
-inline v_int32x4 v_floor(const v_float64x2 &a) {
-  v2f64 a1 = msa_cvtrintq_f64(a.val);
-  return v_int32x4(msa_pack_s64(
-      msa_addq_s64(msa_cvttruncq_s64_f64(a1),
-                   MSA_TPV_REINTERPRET(v2i64, msa_cgtq_f64(a1, a.val))),
-      msa_dupq_n_s64(0)));
-}
-
-inline v_int32x4 v_ceil(const v_float64x2 &a) {
-  v2f64 a1 = msa_cvtrintq_f64(a.val);
-  return v_int32x4(msa_pack_s64(
-      msa_subq_s64(msa_cvttruncq_s64_f64(a1),
-                   MSA_TPV_REINTERPRET(v2i64, msa_cgtq_f64(a.val, a1))),
-      msa_dupq_n_s64(0)));
-}
-
-inline v_int32x4 v_trunc(const v_float64x2 &a) {
-  return v_int32x4(
-      msa_pack_s64(msa_cvttruncq_s64_f64(a.val), msa_dupq_n_s64(0)));
-}
-
-#define OPENCV_HAL_IMPL_MSA_TRANSPOSE4x4(_Tpvec, _Tpv, _Tpvs, ssuffix)         \
-  inline void v_transpose4x4(const _Tpvec &a0, const _Tpvec &a1,               \
-                             const _Tpvec &a2, const _Tpvec &a3, _Tpvec &b0,   \
-                             _Tpvec &b1, _Tpvec &b2, _Tpvec &b3) {             \
-    _Tpv t00 = MSA_TPV_REINTERPRET(                                            \
-        _Tpv, msa_ilvrq_##ssuffix(MSA_TPV_REINTERPRET(_Tpvs, a1.val),          \
-                                  MSA_TPV_REINTERPRET(_Tpvs, a0.val)));        \
-    _Tpv t01 = MSA_TPV_REINTERPRET(                                            \
-        _Tpv, msa_ilvlq_##ssuffix(MSA_TPV_REINTERPRET(_Tpvs, a1.val),          \
-                                  MSA_TPV_REINTERPRET(_Tpvs, a0.val)));        \
-    _Tpv t10 = MSA_TPV_REINTERPRET(                                            \
-        _Tpv, msa_ilvrq_##ssuffix(MSA_TPV_REINTERPRET(_Tpvs, a3.val),          \
-                                  MSA_TPV_REINTERPRET(_Tpvs, a2.val)));        \
-    _Tpv t11 = MSA_TPV_REINTERPRET(                                            \
-        _Tpv, msa_ilvlq_##ssuffix(MSA_TPV_REINTERPRET(_Tpvs, a3.val),          \
-                                  MSA_TPV_REINTERPRET(_Tpvs, a2.val)));        \
-    b0.val = MSA_TPV_REINTERPRET(                                              \
-        _Tpv, msa_ilvrq_s64(MSA_TPV_REINTERPRET(v2i64, t10),                   \
-                            MSA_TPV_REINTERPRET(v2i64, t00)));                 \
-    b1.val = MSA_TPV_REINTERPRET(                                              \
-        _Tpv, msa_ilvlq_s64(MSA_TPV_REINTERPRET(v2i64, t10),                   \
-                            MSA_TPV_REINTERPRET(v2i64, t00)));                 \
-    b2.val = MSA_TPV_REINTERPRET(                                              \
-        _Tpv, msa_ilvrq_s64(MSA_TPV_REINTERPRET(v2i64, t11),                   \
-                            MSA_TPV_REINTERPRET(v2i64, t01)));                 \
-    b3.val = MSA_TPV_REINTERPRET(                                              \
-        _Tpv, msa_ilvlq_s64(MSA_TPV_REINTERPRET(v2i64, t11),                   \
-                            MSA_TPV_REINTERPRET(v2i64, t01)));                 \
-  }
-
-OPENCV_HAL_IMPL_MSA_TRANSPOSE4x4(v_uint32x4, v4u32, v4i32, s32)
-    OPENCV_HAL_IMPL_MSA_TRANSPOSE4x4(v_int32x4, v4i32, v4i32, s32)
-        OPENCV_HAL_IMPL_MSA_TRANSPOSE4x4(v_float32x4, v4f32, v4i32, s32)
-
-#define OPENCV_HAL_IMPL_MSA_INTERLEAVED(_Tpvec, _Tp, suffix)                   \
-  inline void v_load_deinterleave(const _Tp *ptr, v_##_Tpvec &a,               \
-                                  v_##_Tpvec &b) {                             \
-    msa_ld2q_##suffix(ptr, &a.val, &b.val);                                    \
-  }                                                                            \
-  inline void v_load_deinterleave(const _Tp *ptr, v_##_Tpvec &a,               \
-                                  v_##_Tpvec &b, v_##_Tpvec &c) {              \
-    msa_ld3q_##suffix(ptr, &a.val, &b.val, &c.val);                            \
-  }                                                                            \
-  inline void v_load_deinterleave(const _Tp *ptr, v_##_Tpvec &a,               \
-                                  v_##_Tpvec &b, v_##_Tpvec &c,                \
-                                  v_##_Tpvec &d) {                             \
-    msa_ld4q_##suffix(ptr, &a.val, &b.val, &c.val, &d.val);                    \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp *ptr, const v_##_Tpvec &a, const v_##_Tpvec &b,                      \
-      hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {                        \
-    msa_st2q_##suffix(ptr, a.val, b.val);                                      \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp *ptr, const v_##_Tpvec &a, const v_##_Tpvec &b, const v_##_Tpvec &c, \
-      hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {                        \
-    msa_st3q_##suffix(ptr, a.val, b.val, c.val);                               \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp *ptr, const v_##_Tpvec &a, const v_##_Tpvec &b, const v_##_Tpvec &c, \
-      const v_##_Tpvec &d, hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {   \
-    msa_st4q_##suffix(ptr, a.val, b.val, c.val, d.val);                        \
-  }
-
-            OPENCV_HAL_IMPL_MSA_INTERLEAVED(
-                uint8x16, uchar, u8) OPENCV_HAL_IMPL_MSA_INTERLEAVED(int8x16,
-                                                                     schar, s8)
-                OPENCV_HAL_IMPL_MSA_INTERLEAVED(uint16x8, ushort, u16)
-                    OPENCV_HAL_IMPL_MSA_INTERLEAVED(int16x8, short, s16)
-                        OPENCV_HAL_IMPL_MSA_INTERLEAVED(uint32x4, unsigned, u32)
-                            OPENCV_HAL_IMPL_MSA_INTERLEAVED(int32x4, int, s32)
-                                OPENCV_HAL_IMPL_MSA_INTERLEAVED(float32x4,
-                                                                float, f32)
-                                    OPENCV_HAL_IMPL_MSA_INTERLEAVED(uint64x2,
-                                                                    uint64, u64)
-                                        OPENCV_HAL_IMPL_MSA_INTERLEAVED(int64x2,
-                                                                        int64,
-                                                                        s64)
-                                            OPENCV_HAL_IMPL_MSA_INTERLEAVED(
-                                                float64x2, double, f64)
-
-    /* v_cvt_f32, v_cvt_f64, v_cvt_f64_high */
-    inline v_float32x4 v_cvt_f32(const v_int32x4 &a) {
-  return v_float32x4(msa_cvtfintq_f32_s32(a.val));
-}
-
-inline v_float32x4 v_cvt_f32(const v_float64x2 &a) {
-  return v_float32x4(msa_cvtfq_f32_f64(a.val, msa_dupq_n_f64(0.0f)));
-}
-
-inline v_float32x4 v_cvt_f32(const v_float64x2 &a, const v_float64x2 &b) {
-  return v_float32x4(msa_cvtfq_f32_f64(a.val, b.val));
-}
-
-inline v_float64x2 v_cvt_f64(const v_int32x4 &a) {
-  return v_float64x2(msa_cvtflq_f64_f32(msa_cvtfintq_f32_s32(a.val)));
-}
-
-inline v_float64x2 v_cvt_f64_high(const v_int32x4 &a) {
-  return v_float64x2(msa_cvtfhq_f64_f32(msa_cvtfintq_f32_s32(a.val)));
-}
-
-inline v_float64x2 v_cvt_f64(const v_float32x4 &a) {
-  return v_float64x2(msa_cvtflq_f64_f32(a.val));
-}
-
-inline v_float64x2 v_cvt_f64_high(const v_float32x4 &a) {
-  return v_float64x2(msa_cvtfhq_f64_f32(a.val));
-}
-
-inline v_float64x2 v_cvt_f64(const v_int64x2 &a) {
-  return v_float64x2(msa_cvtfintq_f64_s64(a.val));
-}
-
-////////////// Lookup table access ////////////////////
-inline v_int8x16 v_lut(const schar *tab, const int *idx) {
-  schar CV_DECL_ALIGNED(32)
-      elems[16] = {tab[idx[0]],  tab[idx[1]],  tab[idx[2]],  tab[idx[3]],
-                   tab[idx[4]],  tab[idx[5]],  tab[idx[6]],  tab[idx[7]],
-                   tab[idx[8]],  tab[idx[9]],  tab[idx[10]], tab[idx[11]],
-                   tab[idx[12]], tab[idx[13]], tab[idx[14]], tab[idx[15]]};
-  return v_int8x16(msa_ld1q_s8(elems));
-}
-inline v_int8x16 v_lut_pairs(const schar *tab, const int *idx) {
-  schar CV_DECL_ALIGNED(32)
-      elems[16] = {tab[idx[0]], tab[idx[0] + 1], tab[idx[1]], tab[idx[1] + 1],
-                   tab[idx[2]], tab[idx[2] + 1], tab[idx[3]], tab[idx[3] + 1],
-                   tab[idx[4]], tab[idx[4] + 1], tab[idx[5]], tab[idx[5] + 1],
-                   tab[idx[6]], tab[idx[6] + 1], tab[idx[7]], tab[idx[7] + 1]};
-  return v_int8x16(msa_ld1q_s8(elems));
-}
-inline v_int8x16 v_lut_quads(const schar *tab, const int *idx) {
-  schar CV_DECL_ALIGNED(32) elems[16] = {
-      tab[idx[0]], tab[idx[0] + 1], tab[idx[0] + 2], tab[idx[0] + 3],
-      tab[idx[1]], tab[idx[1] + 1], tab[idx[1] + 2], tab[idx[1] + 3],
-      tab[idx[2]], tab[idx[2] + 1], tab[idx[2] + 2], tab[idx[2] + 3],
-      tab[idx[3]], tab[idx[3] + 1], tab[idx[3] + 2], tab[idx[3] + 3]};
-  return v_int8x16(msa_ld1q_s8(elems));
-}
-inline v_uint8x16 v_lut(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v_lut((schar *)tab, idx));
-}
-inline v_uint8x16 v_lut_pairs(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v_lut_pairs((schar *)tab, idx));
-}
-inline v_uint8x16 v_lut_quads(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v_lut_quads((schar *)tab, idx));
-}
-
-inline v_int16x8 v_lut(const short *tab, const int *idx) {
-  short CV_DECL_ALIGNED(32)
-      elems[8] = {tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]],
-                  tab[idx[4]], tab[idx[5]], tab[idx[6]], tab[idx[7]]};
-  return v_int16x8(msa_ld1q_s16(elems));
-}
-inline v_int16x8 v_lut_pairs(const short *tab, const int *idx) {
-  short CV_DECL_ALIGNED(32)
-      elems[8] = {tab[idx[0]], tab[idx[0] + 1], tab[idx[1]], tab[idx[1] + 1],
-                  tab[idx[2]], tab[idx[2] + 1], tab[idx[3]], tab[idx[3] + 1]};
-  return v_int16x8(msa_ld1q_s16(elems));
-}
-inline v_int16x8 v_lut_quads(const short *tab, const int *idx) {
-  return v_int16x8(
-      msa_combine_s16(msa_ld1_s16(tab + idx[0]), msa_ld1_s16(tab + idx[1])));
-}
-inline v_uint16x8 v_lut(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v_lut((short *)tab, idx));
-}
-inline v_uint16x8 v_lut_pairs(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v_lut_pairs((short *)tab, idx));
-}
-inline v_uint16x8 v_lut_quads(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v_lut_quads((short *)tab, idx));
-}
-
-inline v_int32x4 v_lut(const int *tab, const int *idx) {
-  int CV_DECL_ALIGNED(32)
-      elems[4] = {tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]};
-  return v_int32x4(msa_ld1q_s32(elems));
-}
-inline v_int32x4 v_lut_pairs(const int *tab, const int *idx) {
-  return v_int32x4(
-      msa_combine_s32(msa_ld1_s32(tab + idx[0]), msa_ld1_s32(tab + idx[1])));
-}
-inline v_int32x4 v_lut_quads(const int *tab, const int *idx) {
-  return v_int32x4(msa_ld1q_s32(tab + idx[0]));
-}
-inline v_uint32x4 v_lut(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v_lut((int *)tab, idx));
-}
-inline v_uint32x4 v_lut_pairs(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v_lut_pairs((int *)tab, idx));
-}
-inline v_uint32x4 v_lut_quads(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v_lut_quads((int *)tab, idx));
-}
-
-inline v_int64x2 v_lut(const int64_t *tab, const int *idx) {
-  return v_int64x2(msa_combine_s64(msa_create_s64(tab[idx[0]]),
-                                   msa_create_s64(tab[idx[1]])));
-}
-inline v_int64x2 v_lut_pairs(const int64_t *tab, const int *idx) {
-  return v_int64x2(msa_ld1q_s64(tab + idx[0]));
-}
-inline v_uint64x2 v_lut(const uint64_t *tab, const int *idx) {
-  return v_reinterpret_as_u64(v_lut((const int64_t *)tab, idx));
-}
-inline v_uint64x2 v_lut_pairs(const uint64_t *tab, const int *idx) {
-  return v_reinterpret_as_u64(v_lut_pairs((const int64_t *)tab, idx));
-}
-
-inline v_float32x4 v_lut(const float *tab, const int *idx) {
-  float CV_DECL_ALIGNED(32)
-      elems[4] = {tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]};
-  return v_float32x4(msa_ld1q_f32(elems));
-}
-inline v_float32x4 v_lut_pairs(const float *tab, const int *idx) {
-  uint64 CV_DECL_ALIGNED(32)
-      elems[2] = {*(uint64 *)(tab + idx[0]), *(uint64 *)(tab + idx[1])};
-  return v_float32x4(MSA_TPV_REINTERPRET(v4f32, msa_ld1q_u64(elems)));
-}
-inline v_float32x4 v_lut_quads(const float *tab, const int *idx) {
-  return v_float32x4(msa_ld1q_f32(tab + idx[0]));
-}
-
-inline v_int32x4 v_lut(const int *tab, const v_int32x4 &idxvec) {
-  int CV_DECL_ALIGNED(32) idx[4];
-  v_store_aligned(idx, idxvec);
-
-  return v_int32x4(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]);
-}
-
-inline v_uint32x4 v_lut(const unsigned *tab, const v_int32x4 &idxvec) {
-  unsigned CV_DECL_ALIGNED(32)
-      elems[4] = {tab[msa_getq_lane_s32(idxvec.val, 0)],
-                  tab[msa_getq_lane_s32(idxvec.val, 1)],
-                  tab[msa_getq_lane_s32(idxvec.val, 2)],
-                  tab[msa_getq_lane_s32(idxvec.val, 3)]};
-  return v_uint32x4(msa_ld1q_u32(elems));
-}
-
-inline v_float32x4 v_lut(const float *tab, const v_int32x4 &idxvec) {
-  int CV_DECL_ALIGNED(32) idx[4];
-  v_store_aligned(idx, idxvec);
-
-  return v_float32x4(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]);
-}
-
-inline void v_lut_deinterleave(const float *tab, const v_int32x4 &idxvec,
-                               v_float32x4 &x, v_float32x4 &y) {
-  int CV_DECL_ALIGNED(32) idx[4];
-  v_store_aligned(idx, idxvec);
-
-  v4f32 xy02 =
-      msa_combine_f32(msa_ld1_f32(tab + idx[0]), msa_ld1_f32(tab + idx[2]));
-  v4f32 xy13 =
-      msa_combine_f32(msa_ld1_f32(tab + idx[1]), msa_ld1_f32(tab + idx[3]));
-  x = v_float32x4(MSA_TPV_REINTERPRET(
-      v4f32, msa_ilvevq_s32(MSA_TPV_REINTERPRET(v4i32, xy13),
-                            MSA_TPV_REINTERPRET(v4i32, xy02))));
-  y = v_float32x4(MSA_TPV_REINTERPRET(
-      v4f32, msa_ilvodq_s32(MSA_TPV_REINTERPRET(v4i32, xy13),
-                            MSA_TPV_REINTERPRET(v4i32, xy02))));
-}
-
-inline v_int8x16 v_interleave_pairs(const v_int8x16 &vec) {
-  v_int8x16 c = v_int8x16(__builtin_msa_vshf_b(
-      (v16i8)((v2i64){0x0705060403010200, 0x0F0D0E0C0B090A08}),
-      msa_dupq_n_s8(0), vec.val));
-  return c;
-}
-inline v_uint8x16 v_interleave_pairs(const v_uint8x16 &vec) {
-  return v_reinterpret_as_u8(v_interleave_pairs(v_reinterpret_as_s8(vec)));
-}
-inline v_int8x16 v_interleave_quads(const v_int8x16 &vec) {
-  v_int8x16 c = v_int8x16(__builtin_msa_vshf_b(
-      (v16i8)((v2i64){0x0703060205010400, 0x0F0B0E0A0D090C08}),
-      msa_dupq_n_s8(0), vec.val));
-  return c;
-}
-inline v_uint8x16 v_interleave_quads(const v_uint8x16 &vec) {
-  return v_reinterpret_as_u8(v_interleave_quads(v_reinterpret_as_s8(vec)));
-}
-
-inline v_int16x8 v_interleave_pairs(const v_int16x8 &vec) {
-  v_int16x8 c = v_int16x8(__builtin_msa_vshf_h(
-      (v8i16)((v2i64){0x0003000100020000, 0x0007000500060004}),
-      msa_dupq_n_s16(0), vec.val));
-  return c;
-}
-
-inline v_uint16x8 v_interleave_pairs(const v_uint16x8 &vec) {
-  return v_reinterpret_as_u16(v_interleave_pairs(v_reinterpret_as_s16(vec)));
-}
-
-inline v_int16x8 v_interleave_quads(const v_int16x8 &vec) {
-  v_int16x8 c = v_int16x8(__builtin_msa_vshf_h(
-      (v8i16)((v2i64){0x0005000100040000, 0x0007000300060002}),
-      msa_dupq_n_s16(0), vec.val));
-  return c;
-}
-
-inline v_uint16x8 v_interleave_quads(const v_uint16x8 &vec) {
-  return v_reinterpret_as_u16(v_interleave_quads(v_reinterpret_as_s16(vec)));
-}
-
-inline v_int32x4 v_interleave_pairs(const v_int32x4 &vec) {
-  v_int32x4 c;
-  c.val[0] = vec.val[0];
-  c.val[1] = vec.val[2];
-  c.val[2] = vec.val[1];
-  c.val[3] = vec.val[3];
-  return c;
-}
-
-inline v_uint32x4 v_interleave_pairs(const v_uint32x4 &vec) {
-  return v_reinterpret_as_u32(v_interleave_pairs(v_reinterpret_as_s32(vec)));
-}
-inline v_float32x4 v_interleave_pairs(const v_float32x4 &vec) {
-  return v_reinterpret_as_f32(v_interleave_pairs(v_reinterpret_as_s32(vec)));
-}
-
-inline v_int8x16 v_pack_triplets(const v_int8x16 &vec) {
-  v_int8x16 c = v_int8x16(__builtin_msa_vshf_b(
-      (v16i8)((v2i64){0x0908060504020100, 0x131211100E0D0C0A}),
-      msa_dupq_n_s8(0), vec.val));
-  return c;
-}
-
-inline v_uint8x16 v_pack_triplets(const v_uint8x16 &vec) {
-  return v_reinterpret_as_u8(v_pack_triplets(v_reinterpret_as_s8(vec)));
-}
-
-inline v_int16x8 v_pack_triplets(const v_int16x8 &vec) {
-  v_int16x8 c = v_int16x8(__builtin_msa_vshf_h(
-      (v8i16)((v2i64){0x0004000200010000, 0x0009000800060005}),
-      msa_dupq_n_s16(0), vec.val));
-  return c;
-}
-
-inline v_uint16x8 v_pack_triplets(const v_uint16x8 &vec) {
-  return v_reinterpret_as_u16(v_pack_triplets(v_reinterpret_as_s16(vec)));
-}
-inline v_int32x4 v_pack_triplets(const v_int32x4 &vec) { return vec; }
-inline v_uint32x4 v_pack_triplets(const v_uint32x4 &vec) { return vec; }
-inline v_float32x4 v_pack_triplets(const v_float32x4 &vec) { return vec; }
-
-inline v_float64x2 v_lut(const double *tab, const int *idx) {
-  double CV_DECL_ALIGNED(32) elems[2] = {tab[idx[0]], tab[idx[1]]};
-  return v_float64x2(msa_ld1q_f64(elems));
-}
-
-inline v_float64x2 v_lut_pairs(const double *tab, const int *idx) {
-  return v_float64x2(msa_ld1q_f64(tab + idx[0]));
-}
-
-inline v_float64x2 v_lut(const double *tab, const v_int32x4 &idxvec) {
-  int CV_DECL_ALIGNED(32) idx[4];
-  v_store_aligned(idx, idxvec);
-
-  return v_float64x2(tab[idx[0]], tab[idx[1]]);
-}
-
-inline void v_lut_deinterleave(const double *tab, const v_int32x4 &idxvec,
-                               v_float64x2 &x, v_float64x2 &y) {
-  int CV_DECL_ALIGNED(32) idx[4];
-  v_store_aligned(idx, idxvec);
-
-  v2f64 xy0 = msa_ld1q_f64(tab + idx[0]);
-  v2f64 xy1 = msa_ld1q_f64(tab + idx[1]);
-  x = v_float64x2(MSA_TPV_REINTERPRET(
-      v2f64, msa_ilvevq_s64(MSA_TPV_REINTERPRET(v2i64, xy1),
-                            MSA_TPV_REINTERPRET(v2i64, xy0))));
-  y = v_float64x2(MSA_TPV_REINTERPRET(
-      v2f64, msa_ilvodq_s64(MSA_TPV_REINTERPRET(v2i64, xy1),
-                            MSA_TPV_REINTERPRET(v2i64, xy0))));
-}
-
-template <int i, typename _Tp>
-inline typename _Tp::lane_type v_extract_n(const _Tp &a) {
-  return v_rotate_right<i>(a).get0();
-}
-
-template <int i> inline v_uint32x4 v_broadcast_element(const v_uint32x4 &a) {
-  return v_setall_u32(v_extract_n<i>(a));
-}
-template <int i> inline v_int32x4 v_broadcast_element(const v_int32x4 &a) {
-  return v_setall_s32(v_extract_n<i>(a));
-}
-template <int i> inline v_float32x4 v_broadcast_element(const v_float32x4 &a) {
-  return v_setall_f32(v_extract_n<i>(a));
-}
-
-////// FP16 support ///////
-#if CV_FP16
-inline v_float32x4 v_load_expand(const hfloat *ptr) {
-#ifndef msa_ld1_f16
-  v4f16 v = (v4f16)msa_ld1_s16((const short *)ptr);
-#else
-  v4f16 v = msa_ld1_f16((const __fp16 *)ptr);
-#endif
-  return v_float32x4(msa_cvt_f32_f16(v));
-}
-
-inline void v_pack_store(hfloat *ptr, const v_float32x4 &v) {
-  v4f16 hv = msa_cvt_f16_f32(v.val);
-
-#ifndef msa_st1_f16
-  msa_st1_s16((short *)ptr, (int16x4_t)hv);
-#else
-  msa_st1_f16((__fp16 *)ptr, hv);
-#endif
-}
-#else
-inline v_float32x4 v_load_expand(const hfloat *ptr) {
-  float buf[4];
-  for (int i = 0; i < 4; i++)
-    buf[i] = (float)ptr[i];
-  return v_load(buf);
-}
-
-inline void v_pack_store(hfloat *ptr, const v_float32x4 &v) {
-  float buf[4];
-  v_store(buf, v);
-  for (int i = 0; i < 4; i++)
-    ptr[i] = (hfloat)buf[i];
-}
-#endif
-
-inline void v_cleanup() {}
-
-#include "intrin_math.hpp"
-inline v_float32x4 v_exp(const v_float32x4 &x) {
-  return v_exp_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline v_float32x4 v_log(const v_float32x4 &x) {
-  return v_log_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline void v_sincos(const v_float32x4 &x, v_float32x4 &s, v_float32x4 &c) {
-  v_sincos_default_32f<v_float32x4, v_int32x4>(x, s, c);
-}
-inline v_float32x4 v_sin(const v_float32x4 &x) {
-  return v_sin_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline v_float32x4 v_cos(const v_float32x4 &x) {
-  return v_cos_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline v_float32x4 v_erf(const v_float32x4 &x) {
-  return v_erf_default_32f<v_float32x4, v_int32x4>(x);
-}
-
-inline v_float64x2 v_exp(const v_float64x2 &x) {
-  return v_exp_default_64f<v_float64x2, v_int64x2>(x);
-}
-inline v_float64x2 v_log(const v_float64x2 &x) {
-  return v_log_default_64f<v_float64x2, v_int64x2>(x);
-}
-inline void v_sincos(const v_float64x2 &x, v_float64x2 &s, v_float64x2 &c) {
-  v_sincos_default_64f<v_float64x2, v_int64x2>(x, s, c);
-}
-inline v_float64x2 v_sin(const v_float64x2 &x) {
-  return v_sin_default_64f<v_float64x2, v_int64x2>(x);
-}
-inline v_float64x2 v_cos(const v_float64x2 &x) {
-  return v_cos_default_64f<v_float64x2, v_int64x2>(x);
-}
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_END
-
-//! @endcond
-
-} // namespace cv
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_neon.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_neon.hpp
deleted file mode 100644
index b26a52bc1e..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_neon.hpp
+++ /dev/null
@@ -1,2710 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Copyright (C) 2015, Itseez Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_HAL_INTRIN_NEON_HPP
-#define OPENCV_HAL_INTRIN_NEON_HPP
-
-#include "opencv2/core/utility.hpp"
-#include <algorithm>
-
-namespace cv {
-
-//! @cond IGNORED
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_BEGIN
-
-#define CV_SIMD128 1
-#if defined(__aarch64__) || defined(_M_ARM64)
-#define CV_SIMD128_64F 1
-#else
-#define CV_SIMD128_64F 0
-#endif
-
-// The following macro checks if the code is being compiled for the
-// AArch64 execution state of Armv8, to enable the 128-bit
-// intrinsics. The macro `__ARM_64BIT_STATE` is the one recommended by
-// the Arm C Language Extension (ACLE) specifications [1] to check the
-// availability of 128-bit intrinsics, and it is supporrted by clang
-// and gcc. The macro `_M_ARM64` is the equivalent one for Microsoft
-// Visual Studio [2] .
-//
-// [1]
-// https://developer.arm.com/documentation/101028/0012/13--Advanced-SIMD--Neon--intrinsics
-// [2] https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros
-#if defined(__ARM_64BIT_STATE) || defined(_M_ARM64)
-#define CV_NEON_AARCH64 1
-#else
-#define CV_NEON_AARCH64 0
-#endif
-
-//////////// Utils ////////////
-
-#if CV_SIMD128_64F
-#define OPENCV_HAL_IMPL_NEON_UNZIP(_Tpv, _Tpvx2, suffix)                       \
-  inline void _v128_unzip(const _Tpv &a, const _Tpv &b, _Tpv &c, _Tpv &d) {    \
-    c = vuzp1q_##suffix(a, b);                                                 \
-    d = vuzp2q_##suffix(a, b);                                                 \
-  }
-#define OPENCV_HAL_IMPL_NEON_UNZIP_L(_Tpv, _Tpvx2, suffix)                     \
-  inline void _v128_unzip(const _Tpv &a, const _Tpv &b, _Tpv &c, _Tpv &d) {    \
-    c = vuzp1_##suffix(a, b);                                                  \
-    d = vuzp2_##suffix(a, b);                                                  \
-  }
-#else
-#define OPENCV_HAL_IMPL_NEON_UNZIP(_Tpv, _Tpvx2, suffix)                       \
-  inline void _v128_unzip(const _Tpv &a, const _Tpv &b, _Tpv &c, _Tpv &d) {    \
-    _Tpvx2 ab = vuzpq_##suffix(a, b);                                          \
-    c = ab.val[0];                                                             \
-    d = ab.val[1];                                                             \
-  }
-#define OPENCV_HAL_IMPL_NEON_UNZIP_L(_Tpv, _Tpvx2, suffix)                     \
-  inline void _v128_unzip(const _Tpv &a, const _Tpv &b, _Tpv &c, _Tpv &d) {    \
-    _Tpvx2 ab = vuzp_##suffix(a, b);                                           \
-    c = ab.val[0];                                                             \
-    d = ab.val[1];                                                             \
-  }
-#endif
-
-#if CV_SIMD128_64F
-#define OPENCV_HAL_IMPL_NEON_REINTERPRET(_Tpv, suffix)                         \
-  template <typename T> static inline _Tpv vreinterpretq_##suffix##_f64(T a) { \
-    return (_Tpv)a;                                                            \
-  }                                                                            \
-  template <typename T>                                                        \
-  static inline float64x2_t vreinterpretq_f64_##suffix(T a) {                  \
-    return (float64x2_t)a;                                                     \
-  }
-#else
-#define OPENCV_HAL_IMPL_NEON_REINTERPRET(_Tpv, suffix)
-#endif
-
-#define OPENCV_HAL_IMPL_NEON_UTILS_SUFFIX(_Tpv, _Tpvl, suffix)                 \
-  OPENCV_HAL_IMPL_NEON_UNZIP(_Tpv##_t, _Tpv##x2_t, suffix)                     \
-  OPENCV_HAL_IMPL_NEON_UNZIP_L(_Tpvl##_t, _Tpvl##x2_t, suffix)                 \
-  OPENCV_HAL_IMPL_NEON_REINTERPRET(_Tpv##_t, suffix)
-
-#define OPENCV_HAL_IMPL_NEON_UTILS_SUFFIX_I64(_Tpv, _Tpvl, suffix)             \
-  OPENCV_HAL_IMPL_NEON_REINTERPRET(_Tpv##_t, suffix)
-
-#define OPENCV_HAL_IMPL_NEON_UTILS_SUFFIX_F64(_Tpv, _Tpvl, suffix)             \
-  OPENCV_HAL_IMPL_NEON_UNZIP(_Tpv##_t, _Tpv##x2_t, suffix)
-
-OPENCV_HAL_IMPL_NEON_UTILS_SUFFIX(uint8x16, uint8x8, u8)
-OPENCV_HAL_IMPL_NEON_UTILS_SUFFIX(int8x16, int8x8, s8)
-OPENCV_HAL_IMPL_NEON_UTILS_SUFFIX(uint16x8, uint16x4, u16)
-OPENCV_HAL_IMPL_NEON_UTILS_SUFFIX(int16x8, int16x4, s16)
-OPENCV_HAL_IMPL_NEON_UTILS_SUFFIX(uint32x4, uint32x2, u32)
-OPENCV_HAL_IMPL_NEON_UTILS_SUFFIX(int32x4, int32x2, s32)
-OPENCV_HAL_IMPL_NEON_UTILS_SUFFIX(float32x4, float32x2, f32)
-OPENCV_HAL_IMPL_NEON_UTILS_SUFFIX_I64(uint64x2, uint64x1, u64)
-OPENCV_HAL_IMPL_NEON_UTILS_SUFFIX_I64(int64x2, int64x1, s64)
-#if CV_SIMD128_64F
-OPENCV_HAL_IMPL_NEON_UTILS_SUFFIX_F64(float64x2, float64x1, f64)
-#endif
-
-//////////// Compatibility layer ////////////
-template <typename T> struct VTraits {
-  static inline int vlanes() { return T::nlanes; }
-  enum { max_nlanes = T::nlanes, nlanes = T::nlanes };
-  using lane_type = typename T::lane_type;
-};
-
-template <typename T> inline typename VTraits<T>::lane_type v_get0(const T &v) {
-  return v.get0();
-}
-//////////// Types ////////////
-
-struct v_uint8x16 {
-  v_uint8x16() {}
-  explicit v_uint8x16(uint8x16_t v) : val(v) {}
-  v_uint8x16(uchar v0, uchar v1, uchar v2, uchar v3, uchar v4, uchar v5,
-             uchar v6, uchar v7, uchar v8, uchar v9, uchar v10, uchar v11,
-             uchar v12, uchar v13, uchar v14, uchar v15) {
-    uchar v[] = {v0, v1, v2,  v3,  v4,  v5,  v6,  v7,
-                 v8, v9, v10, v11, v12, v13, v14, v15};
-    val = vld1q_u8(v);
-  }
-  uint8x16_t val;
-
-private:
-  friend struct VTraits<v_uint8x16>;
-  enum { nlanes = 16 };
-  typedef uchar lane_type;
-
-  friend typename VTraits<v_uint8x16>::lane_type
-  v_get0<v_uint8x16>(const v_uint8x16 &v);
-  uchar get0() const { return vgetq_lane_u8(val, 0); }
-};
-
-struct v_int8x16 {
-  v_int8x16() {}
-  explicit v_int8x16(int8x16_t v) : val(v) {}
-  v_int8x16(schar v0, schar v1, schar v2, schar v3, schar v4, schar v5,
-            schar v6, schar v7, schar v8, schar v9, schar v10, schar v11,
-            schar v12, schar v13, schar v14, schar v15) {
-    schar v[] = {v0, v1, v2,  v3,  v4,  v5,  v6,  v7,
-                 v8, v9, v10, v11, v12, v13, v14, v15};
-    val = vld1q_s8(v);
-  }
-  int8x16_t val;
-
-private:
-  friend struct VTraits<v_int8x16>;
-  enum { nlanes = 16 };
-  typedef schar lane_type;
-
-  friend typename VTraits<v_int8x16>::lane_type
-  v_get0<v_int8x16>(const v_int8x16 &v);
-  schar get0() const { return vgetq_lane_s8(val, 0); }
-};
-
-struct v_uint16x8 {
-  v_uint16x8() {}
-  explicit v_uint16x8(uint16x8_t v) : val(v) {}
-  v_uint16x8(ushort v0, ushort v1, ushort v2, ushort v3, ushort v4, ushort v5,
-             ushort v6, ushort v7) {
-    ushort v[] = {v0, v1, v2, v3, v4, v5, v6, v7};
-    val = vld1q_u16(v);
-  }
-  uint16x8_t val;
-
-private:
-  friend struct VTraits<v_uint16x8>;
-  enum { nlanes = 8 };
-  typedef ushort lane_type;
-
-  friend typename VTraits<v_uint16x8>::lane_type
-  v_get0<v_uint16x8>(const v_uint16x8 &v);
-  ushort get0() const { return vgetq_lane_u16(val, 0); }
-};
-
-struct v_int16x8 {
-  v_int16x8() {}
-  explicit v_int16x8(int16x8_t v) : val(v) {}
-  v_int16x8(short v0, short v1, short v2, short v3, short v4, short v5,
-            short v6, short v7) {
-    short v[] = {v0, v1, v2, v3, v4, v5, v6, v7};
-    val = vld1q_s16(v);
-  }
-  int16x8_t val;
-
-private:
-  friend struct VTraits<v_int16x8>;
-  enum { nlanes = 8 };
-  typedef short lane_type;
-
-  friend typename VTraits<v_int16x8>::lane_type
-  v_get0<v_int16x8>(const v_int16x8 &v);
-  short get0() const { return vgetq_lane_s16(val, 0); }
-};
-
-struct v_uint32x4 {
-  v_uint32x4() {}
-  explicit v_uint32x4(uint32x4_t v) : val(v) {}
-  v_uint32x4(unsigned v0, unsigned v1, unsigned v2, unsigned v3) {
-    unsigned v[] = {v0, v1, v2, v3};
-    val = vld1q_u32(v);
-  }
-  uint32x4_t val;
-
-private:
-  friend struct VTraits<v_uint32x4>;
-  enum { nlanes = 4 };
-  typedef unsigned lane_type;
-
-  friend typename VTraits<v_uint32x4>::lane_type
-  v_get0<v_uint32x4>(const v_uint32x4 &v);
-  unsigned get0() const { return vgetq_lane_u32(val, 0); }
-};
-
-struct v_int32x4 {
-  v_int32x4() {}
-  explicit v_int32x4(int32x4_t v) : val(v) {}
-  v_int32x4(int v0, int v1, int v2, int v3) {
-    int v[] = {v0, v1, v2, v3};
-    val = vld1q_s32(v);
-  }
-  int32x4_t val;
-
-private:
-  friend struct VTraits<v_int32x4>;
-  enum { nlanes = 4 };
-  typedef int lane_type;
-
-  friend typename VTraits<v_int32x4>::lane_type
-  v_get0<v_int32x4>(const v_int32x4 &v);
-  int get0() const { return vgetq_lane_s32(val, 0); }
-};
-
-struct v_float32x4 {
-  v_float32x4() {}
-  explicit v_float32x4(float32x4_t v) : val(v) {}
-  v_float32x4(float v0, float v1, float v2, float v3) {
-    float v[] = {v0, v1, v2, v3};
-    val = vld1q_f32(v);
-  }
-  float32x4_t val;
-
-private:
-  friend struct VTraits<v_float32x4>;
-  enum { nlanes = 4 };
-  typedef float lane_type;
-
-  friend typename VTraits<v_float32x4>::lane_type
-  v_get0<v_float32x4>(const v_float32x4 &v);
-  float get0() const { return vgetq_lane_f32(val, 0); }
-};
-
-struct v_uint64x2 {
-  v_uint64x2() {}
-  explicit v_uint64x2(uint64x2_t v) : val(v) {}
-  v_uint64x2(uint64 v0, uint64 v1) {
-    uint64 v[] = {v0, v1};
-    val = vld1q_u64(v);
-  }
-  uint64x2_t val;
-
-private:
-  friend struct VTraits<v_uint64x2>;
-  enum { nlanes = 2 };
-  typedef uint64 lane_type;
-
-  friend typename VTraits<v_uint64x2>::lane_type
-  v_get0<v_uint64x2>(const v_uint64x2 &v);
-  uint64 get0() const { return vgetq_lane_u64(val, 0); }
-};
-
-struct v_int64x2 {
-  v_int64x2() {}
-  explicit v_int64x2(int64x2_t v) : val(v) {}
-  v_int64x2(int64 v0, int64 v1) {
-    int64 v[] = {v0, v1};
-    val = vld1q_s64(v);
-  }
-  int64x2_t val;
-
-private:
-  friend struct VTraits<v_int64x2>;
-  enum { nlanes = 2 };
-  typedef int64 lane_type;
-
-  friend typename VTraits<v_int64x2>::lane_type
-  v_get0<v_int64x2>(const v_int64x2 &v);
-  int64 get0() const { return vgetq_lane_s64(val, 0); }
-};
-
-#if CV_SIMD128_64F
-struct v_float64x2 {
-  v_float64x2() {}
-  explicit v_float64x2(float64x2_t v) : val(v) {}
-  v_float64x2(double v0, double v1) {
-    double v[] = {v0, v1};
-    val = vld1q_f64(v);
-  }
-
-  float64x2_t val;
-
-private:
-  friend struct VTraits<v_float64x2>;
-  enum { nlanes = 2 };
-  typedef double lane_type;
-
-  friend typename VTraits<v_float64x2>::lane_type
-  v_get0<v_float64x2>(const v_float64x2 &v);
-  double get0() const { return vgetq_lane_f64(val, 0); }
-};
-#endif
-
-#define OPENCV_HAL_IMPL_NEON_INIT(_Tpv, _Tp, suffix)                           \
-  inline v_##_Tpv v_setzero_##suffix() {                                       \
-    return v_##_Tpv(vdupq_n_##suffix((_Tp)0));                                 \
-  }                                                                            \
-  inline v_##_Tpv v_setall_##suffix(_Tp v) {                                   \
-    return v_##_Tpv(vdupq_n_##suffix(v));                                      \
-  }                                                                            \
-  template <> inline v_##_Tpv v_setzero_() { return v_setzero_##suffix(); }    \
-  template <> inline v_##_Tpv v_setall_(_Tp v) {                               \
-    return v_setall_##suffix(v);                                               \
-  }                                                                            \
-  inline _Tpv##_t vreinterpretq_##suffix##_##suffix(_Tpv##_t v) { return v; }  \
-  inline v_uint8x16 v_reinterpret_as_u8(const v_##_Tpv &v) {                   \
-    return v_uint8x16(vreinterpretq_u8_##suffix(v.val));                       \
-  }                                                                            \
-  inline v_int8x16 v_reinterpret_as_s8(const v_##_Tpv &v) {                    \
-    return v_int8x16(vreinterpretq_s8_##suffix(v.val));                        \
-  }                                                                            \
-  inline v_uint16x8 v_reinterpret_as_u16(const v_##_Tpv &v) {                  \
-    return v_uint16x8(vreinterpretq_u16_##suffix(v.val));                      \
-  }                                                                            \
-  inline v_int16x8 v_reinterpret_as_s16(const v_##_Tpv &v) {                   \
-    return v_int16x8(vreinterpretq_s16_##suffix(v.val));                       \
-  }                                                                            \
-  inline v_uint32x4 v_reinterpret_as_u32(const v_##_Tpv &v) {                  \
-    return v_uint32x4(vreinterpretq_u32_##suffix(v.val));                      \
-  }                                                                            \
-  inline v_int32x4 v_reinterpret_as_s32(const v_##_Tpv &v) {                   \
-    return v_int32x4(vreinterpretq_s32_##suffix(v.val));                       \
-  }                                                                            \
-  inline v_uint64x2 v_reinterpret_as_u64(const v_##_Tpv &v) {                  \
-    return v_uint64x2(vreinterpretq_u64_##suffix(v.val));                      \
-  }                                                                            \
-  inline v_int64x2 v_reinterpret_as_s64(const v_##_Tpv &v) {                   \
-    return v_int64x2(vreinterpretq_s64_##suffix(v.val));                       \
-  }                                                                            \
-  inline v_float32x4 v_reinterpret_as_f32(const v_##_Tpv &v) {                 \
-    return v_float32x4(vreinterpretq_f32_##suffix(v.val));                     \
-  }
-
-OPENCV_HAL_IMPL_NEON_INIT(uint8x16, uchar, u8)
-OPENCV_HAL_IMPL_NEON_INIT(int8x16, schar, s8)
-OPENCV_HAL_IMPL_NEON_INIT(uint16x8, ushort, u16)
-OPENCV_HAL_IMPL_NEON_INIT(int16x8, short, s16)
-OPENCV_HAL_IMPL_NEON_INIT(uint32x4, unsigned, u32)
-OPENCV_HAL_IMPL_NEON_INIT(int32x4, int, s32)
-OPENCV_HAL_IMPL_NEON_INIT(uint64x2, uint64, u64)
-OPENCV_HAL_IMPL_NEON_INIT(int64x2, int64, s64)
-OPENCV_HAL_IMPL_NEON_INIT(float32x4, float, f32)
-#if CV_SIMD128_64F
-#define OPENCV_HAL_IMPL_NEON_INIT_64(_Tpv, suffix)                             \
-  inline v_float64x2 v_reinterpret_as_f64(const v_##_Tpv &v) {                 \
-    return v_float64x2(vreinterpretq_f64_##suffix(v.val));                     \
-  }
-OPENCV_HAL_IMPL_NEON_INIT(float64x2, double, f64)
-OPENCV_HAL_IMPL_NEON_INIT_64(uint8x16, u8)
-OPENCV_HAL_IMPL_NEON_INIT_64(int8x16, s8)
-OPENCV_HAL_IMPL_NEON_INIT_64(uint16x8, u16)
-OPENCV_HAL_IMPL_NEON_INIT_64(int16x8, s16)
-OPENCV_HAL_IMPL_NEON_INIT_64(uint32x4, u32)
-OPENCV_HAL_IMPL_NEON_INIT_64(int32x4, s32)
-OPENCV_HAL_IMPL_NEON_INIT_64(uint64x2, u64)
-OPENCV_HAL_IMPL_NEON_INIT_64(int64x2, s64)
-OPENCV_HAL_IMPL_NEON_INIT_64(float32x4, f32)
-OPENCV_HAL_IMPL_NEON_INIT_64(float64x2, f64)
-#endif
-
-#define OPENCV_HAL_IMPL_NEON_PACK(_Tpvec, _Tp, hreg, suffix, _Tpwvec, pack,    \
-                                  mov, rshr)                                   \
-  inline _Tpvec v_##pack(const _Tpwvec &a, const _Tpwvec &b) {                 \
-    hreg a1 = mov(a.val), b1 = mov(b.val);                                     \
-    return _Tpvec(vcombine_##suffix(a1, b1));                                  \
-  }                                                                            \
-  inline void v_##pack##_store(_Tp *ptr, const _Tpwvec &a) {                   \
-    hreg a1 = mov(a.val);                                                      \
-    vst1_##suffix(ptr, a1);                                                    \
-  }                                                                            \
-  template <int n>                                                             \
-  inline _Tpvec v_rshr_##pack(const _Tpwvec &a, const _Tpwvec &b) {            \
-    hreg a1 = rshr(a.val, n);                                                  \
-    hreg b1 = rshr(b.val, n);                                                  \
-    return _Tpvec(vcombine_##suffix(a1, b1));                                  \
-  }                                                                            \
-  template <int n>                                                             \
-  inline void v_rshr_##pack##_store(_Tp *ptr, const _Tpwvec &a) {              \
-    hreg a1 = rshr(a.val, n);                                                  \
-    vst1_##suffix(ptr, a1);                                                    \
-  }
-
-OPENCV_HAL_IMPL_NEON_PACK(v_uint8x16, uchar, uint8x8_t, u8, v_uint16x8, pack,
-                          vqmovn_u16, vqrshrn_n_u16)
-OPENCV_HAL_IMPL_NEON_PACK(v_int8x16, schar, int8x8_t, s8, v_int16x8, pack,
-                          vqmovn_s16, vqrshrn_n_s16)
-OPENCV_HAL_IMPL_NEON_PACK(v_uint16x8, ushort, uint16x4_t, u16, v_uint32x4, pack,
-                          vqmovn_u32, vqrshrn_n_u32)
-OPENCV_HAL_IMPL_NEON_PACK(v_int16x8, short, int16x4_t, s16, v_int32x4, pack,
-                          vqmovn_s32, vqrshrn_n_s32)
-OPENCV_HAL_IMPL_NEON_PACK(v_uint32x4, unsigned, uint32x2_t, u32, v_uint64x2,
-                          pack, vmovn_u64, vrshrn_n_u64)
-OPENCV_HAL_IMPL_NEON_PACK(v_int32x4, int, int32x2_t, s32, v_int64x2, pack,
-                          vmovn_s64, vrshrn_n_s64)
-
-OPENCV_HAL_IMPL_NEON_PACK(v_uint8x16, uchar, uint8x8_t, u8, v_int16x8, pack_u,
-                          vqmovun_s16, vqrshrun_n_s16)
-OPENCV_HAL_IMPL_NEON_PACK(v_uint16x8, ushort, uint16x4_t, u16, v_int32x4,
-                          pack_u, vqmovun_s32, vqrshrun_n_s32)
-
-// pack boolean
-inline v_uint8x16 v_pack_b(const v_uint16x8 &a, const v_uint16x8 &b) {
-  uint8x16_t ab = vcombine_u8(vmovn_u16(a.val), vmovn_u16(b.val));
-  return v_uint8x16(ab);
-}
-
-inline v_uint8x16 v_pack_b(const v_uint32x4 &a, const v_uint32x4 &b,
-                           const v_uint32x4 &c, const v_uint32x4 &d) {
-  uint16x8_t nab = vcombine_u16(vmovn_u32(a.val), vmovn_u32(b.val));
-  uint16x8_t ncd = vcombine_u16(vmovn_u32(c.val), vmovn_u32(d.val));
-  return v_uint8x16(vcombine_u8(vmovn_u16(nab), vmovn_u16(ncd)));
-}
-
-inline v_uint8x16 v_pack_b(const v_uint64x2 &a, const v_uint64x2 &b,
-                           const v_uint64x2 &c, const v_uint64x2 &d,
-                           const v_uint64x2 &e, const v_uint64x2 &f,
-                           const v_uint64x2 &g, const v_uint64x2 &h) {
-  uint32x4_t ab = vcombine_u32(vmovn_u64(a.val), vmovn_u64(b.val));
-  uint32x4_t cd = vcombine_u32(vmovn_u64(c.val), vmovn_u64(d.val));
-  uint32x4_t ef = vcombine_u32(vmovn_u64(e.val), vmovn_u64(f.val));
-  uint32x4_t gh = vcombine_u32(vmovn_u64(g.val), vmovn_u64(h.val));
-
-  uint16x8_t abcd = vcombine_u16(vmovn_u32(ab), vmovn_u32(cd));
-  uint16x8_t efgh = vcombine_u16(vmovn_u32(ef), vmovn_u32(gh));
-  return v_uint8x16(vcombine_u8(vmovn_u16(abcd), vmovn_u16(efgh)));
-}
-
-inline v_float32x4 v_matmul(const v_float32x4 &v, const v_float32x4 &m0,
-                            const v_float32x4 &m1, const v_float32x4 &m2,
-                            const v_float32x4 &m3) {
-  float32x2_t vl = vget_low_f32(v.val), vh = vget_high_f32(v.val);
-  float32x4_t res = vmulq_lane_f32(m0.val, vl, 0);
-  res = vmlaq_lane_f32(res, m1.val, vl, 1);
-  res = vmlaq_lane_f32(res, m2.val, vh, 0);
-  res = vmlaq_lane_f32(res, m3.val, vh, 1);
-  return v_float32x4(res);
-}
-
-inline v_float32x4 v_matmuladd(const v_float32x4 &v, const v_float32x4 &m0,
-                               const v_float32x4 &m1, const v_float32x4 &m2,
-                               const v_float32x4 &a) {
-  float32x2_t vl = vget_low_f32(v.val), vh = vget_high_f32(v.val);
-  float32x4_t res = vmulq_lane_f32(m0.val, vl, 0);
-  res = vmlaq_lane_f32(res, m1.val, vl, 1);
-  res = vmlaq_lane_f32(res, m2.val, vh, 0);
-  res = vaddq_f32(res, a.val);
-  return v_float32x4(res);
-}
-
-#define OPENCV_HAL_IMPL_NEON_BIN_OP(bin_op, _Tpvec, intrin)                    \
-  inline _Tpvec bin_op(const _Tpvec &a, const _Tpvec &b) {                     \
-    return _Tpvec(intrin(a.val, b.val));                                       \
-  }
-
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_add, v_uint8x16, vqaddq_u8)
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_sub, v_uint8x16, vqsubq_u8)
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_add, v_int8x16, vqaddq_s8)
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_sub, v_int8x16, vqsubq_s8)
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_add, v_uint16x8, vqaddq_u16)
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_sub, v_uint16x8, vqsubq_u16)
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_add, v_int16x8, vqaddq_s16)
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_sub, v_int16x8, vqsubq_s16)
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_add, v_int32x4, vaddq_s32)
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_sub, v_int32x4, vsubq_s32)
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_mul, v_int32x4, vmulq_s32)
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_add, v_uint32x4, vaddq_u32)
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_sub, v_uint32x4, vsubq_u32)
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_mul, v_uint32x4, vmulq_u32)
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_add, v_float32x4, vaddq_f32)
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_sub, v_float32x4, vsubq_f32)
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_mul, v_float32x4, vmulq_f32)
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_add, v_int64x2, vaddq_s64)
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_sub, v_int64x2, vsubq_s64)
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_add, v_uint64x2, vaddq_u64)
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_sub, v_uint64x2, vsubq_u64)
-#if CV_SIMD128_64F
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_div, v_float32x4, vdivq_f32)
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_add, v_float64x2, vaddq_f64)
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_sub, v_float64x2, vsubq_f64)
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_mul, v_float64x2, vmulq_f64)
-OPENCV_HAL_IMPL_NEON_BIN_OP(v_div, v_float64x2, vdivq_f64)
-#else
-inline v_float32x4 v_div(const v_float32x4 &a, const v_float32x4 &b) {
-  float32x4_t reciprocal = vrecpeq_f32(b.val);
-  reciprocal = vmulq_f32(vrecpsq_f32(b.val, reciprocal), reciprocal);
-  reciprocal = vmulq_f32(vrecpsq_f32(b.val, reciprocal), reciprocal);
-  return v_float32x4(vmulq_f32(a.val, reciprocal));
-}
-#endif
-
-// saturating multiply 8-bit, 16-bit
-#define OPENCV_HAL_IMPL_NEON_MUL_SAT(_Tpvec, _Tpwvec)                          \
-  inline _Tpvec v_mul(const _Tpvec &a, const _Tpvec &b) {                      \
-    _Tpwvec c, d;                                                              \
-    v_mul_expand(a, b, c, d);                                                  \
-    return v_pack(c, d);                                                       \
-  }
-
-OPENCV_HAL_IMPL_NEON_MUL_SAT(v_int8x16, v_int16x8)
-OPENCV_HAL_IMPL_NEON_MUL_SAT(v_uint8x16, v_uint16x8)
-OPENCV_HAL_IMPL_NEON_MUL_SAT(v_int16x8, v_int32x4)
-OPENCV_HAL_IMPL_NEON_MUL_SAT(v_uint16x8, v_uint32x4)
-
-//  Multiply and expand
-inline void v_mul_expand(const v_int8x16 &a, const v_int8x16 &b, v_int16x8 &c,
-                         v_int16x8 &d) {
-  c.val = vmull_s8(vget_low_s8(a.val), vget_low_s8(b.val));
-#if CV_NEON_AARCH64
-  d.val = vmull_high_s8(a.val, b.val);
-#else  // #if CV_NEON_AARCH64
-  d.val = vmull_s8(vget_high_s8(a.val), vget_high_s8(b.val));
-#endif // #if CV_NEON_AARCH64
-}
-
-inline void v_mul_expand(const v_uint8x16 &a, const v_uint8x16 &b,
-                         v_uint16x8 &c, v_uint16x8 &d) {
-  c.val = vmull_u8(vget_low_u8(a.val), vget_low_u8(b.val));
-#if CV_NEON_AARCH64
-  d.val = vmull_high_u8(a.val, b.val);
-#else  // #if CV_NEON_AARCH64
-  d.val = vmull_u8(vget_high_u8(a.val), vget_high_u8(b.val));
-#endif // #if CV_NEON_AARCH64
-}
-
-inline void v_mul_expand(const v_int16x8 &a, const v_int16x8 &b, v_int32x4 &c,
-                         v_int32x4 &d) {
-  c.val = vmull_s16(vget_low_s16(a.val), vget_low_s16(b.val));
-#if CV_NEON_AARCH64
-  d.val = vmull_high_s16(a.val, b.val);
-#else  // #if CV_NEON_AARCH64
-  d.val = vmull_s16(vget_high_s16(a.val), vget_high_s16(b.val));
-#endif // #if CV_NEON_AARCH64
-}
-
-inline void v_mul_expand(const v_uint16x8 &a, const v_uint16x8 &b,
-                         v_uint32x4 &c, v_uint32x4 &d) {
-  c.val = vmull_u16(vget_low_u16(a.val), vget_low_u16(b.val));
-#if CV_NEON_AARCH64
-  d.val = vmull_high_u16(a.val, b.val);
-#else  // #if CV_NEON_AARCH64
-  d.val = vmull_u16(vget_high_u16(a.val), vget_high_u16(b.val));
-#endif // #if CV_NEON_AARCH64
-}
-
-inline void v_mul_expand(const v_uint32x4 &a, const v_uint32x4 &b,
-                         v_uint64x2 &c, v_uint64x2 &d) {
-  c.val = vmull_u32(vget_low_u32(a.val), vget_low_u32(b.val));
-#if CV_NEON_AARCH64
-  d.val = vmull_high_u32(a.val, b.val);
-#else  // #if CV_NEON_AARCH64
-  d.val = vmull_u32(vget_high_u32(a.val), vget_high_u32(b.val));
-#endif // #if CV_NEON_AARCH64
-}
-
-inline v_int16x8 v_mul_hi(const v_int16x8 &a, const v_int16x8 &b) {
-#if CV_NEON_AARCH64
-  int32x4_t c = vmull_high_s16(a.val, b.val);
-#else  // #if CV_NEON_AARCH64
-  int32x4_t c = vmull_s16(vget_high_s16(a.val), vget_high_s16(b.val));
-#endif // #if CV_NEON_AARCH64
-  return v_int16x8(vcombine_s16(
-      vshrn_n_s32(vmull_s16(vget_low_s16(a.val), vget_low_s16(b.val)), 16),
-      vshrn_n_s32(c, 16)));
-}
-inline v_uint16x8 v_mul_hi(const v_uint16x8 &a, const v_uint16x8 &b) {
-#if CV_NEON_AARCH64
-  uint32x4_t c = vmull_high_u16(a.val, b.val);
-#else  // #if CV_NEON_AARCH64
-  uint32x4_t c = vmull_u16(vget_high_u16(a.val), vget_high_u16(b.val));
-#endif // #if CV_NEON_AARCH64
-  return v_uint16x8(vcombine_u16(
-      vshrn_n_u32(vmull_u16(vget_low_u16(a.val), vget_low_u16(b.val)), 16),
-      vshrn_n_u32(c, 16)));
-}
-
-//////// Dot Product ////////
-
-// 16 >> 32
-inline v_int32x4 v_dotprod(const v_int16x8 &a, const v_int16x8 &b) {
-  int16x8_t uzp1, uzp2;
-  _v128_unzip(a.val, b.val, uzp1, uzp2);
-  int16x4_t a0 = vget_low_s16(uzp1);
-  int16x4_t b0 = vget_high_s16(uzp1);
-  int16x4_t a1 = vget_low_s16(uzp2);
-  int16x4_t b1 = vget_high_s16(uzp2);
-  int32x4_t p = vmull_s16(a0, b0);
-  return v_int32x4(vmlal_s16(p, a1, b1));
-}
-inline v_int32x4 v_dotprod(const v_int16x8 &a, const v_int16x8 &b,
-                           const v_int32x4 &c) {
-  int16x8_t uzp1, uzp2;
-  _v128_unzip(a.val, b.val, uzp1, uzp2);
-  int16x4_t a0 = vget_low_s16(uzp1);
-  int16x4_t b0 = vget_high_s16(uzp1);
-  int16x4_t a1 = vget_low_s16(uzp2);
-  int16x4_t b1 = vget_high_s16(uzp2);
-  int32x4_t p = vmlal_s16(c.val, a0, b0);
-  return v_int32x4(vmlal_s16(p, a1, b1));
-}
-
-// 32 >> 64
-inline v_int64x2 v_dotprod(const v_int32x4 &a, const v_int32x4 &b) {
-  int32x4_t uzp1, uzp2;
-  _v128_unzip(a.val, b.val, uzp1, uzp2);
-  int32x2_t a0 = vget_low_s32(uzp1);
-  int32x2_t b0 = vget_high_s32(uzp1);
-  int32x2_t a1 = vget_low_s32(uzp2);
-  int32x2_t b1 = vget_high_s32(uzp2);
-  int64x2_t p = vmull_s32(a0, b0);
-  return v_int64x2(vmlal_s32(p, a1, b1));
-}
-inline v_int64x2 v_dotprod(const v_int32x4 &a, const v_int32x4 &b,
-                           const v_int64x2 &c) {
-  int32x4_t uzp1, uzp2;
-  _v128_unzip(a.val, b.val, uzp1, uzp2);
-  int32x2_t a0 = vget_low_s32(uzp1);
-  int32x2_t b0 = vget_high_s32(uzp1);
-  int32x2_t a1 = vget_low_s32(uzp2);
-  int32x2_t b1 = vget_high_s32(uzp2);
-  int64x2_t p = vmlal_s32(c.val, a0, b0);
-  return v_int64x2(vmlal_s32(p, a1, b1));
-}
-
-// 8 >> 32
-#ifdef CV_NEON_DOT
-#define OPENCV_HAL_IMPL_NEON_DOT_PRODUCT_OP(_Tpvec1, _Tpvec2, suffix)          \
-  inline _Tpvec1 v_dotprod_expand(const _Tpvec2 &a, const _Tpvec2 &b) {        \
-    return _Tpvec1(vdotq_##suffix(vdupq_n_##suffix(0), a.val, b.val));         \
-  }                                                                            \
-  inline _Tpvec1 v_dotprod_expand(const _Tpvec2 &a, const _Tpvec2 &b,          \
-                                  const _Tpvec1 &c) {                          \
-    return _Tpvec1(vdotq_##suffix(c.val, a.val, b.val));                       \
-  }
-
-OPENCV_HAL_IMPL_NEON_DOT_PRODUCT_OP(v_uint32x4, v_uint8x16, u32)
-OPENCV_HAL_IMPL_NEON_DOT_PRODUCT_OP(v_int32x4, v_int8x16, s32)
-#else
-inline v_uint32x4 v_dotprod_expand(const v_uint8x16 &a, const v_uint8x16 &b) {
-  const uint8x16_t zero = vreinterpretq_u8_u32(vdupq_n_u32(0));
-  const uint8x16_t mask = vreinterpretq_u8_u32(vdupq_n_u32(0x00FF00FF));
-  const uint16x8_t zero32 = vreinterpretq_u16_u32(vdupq_n_u32(0));
-  const uint16x8_t mask32 = vreinterpretq_u16_u32(vdupq_n_u32(0x0000FFFF));
-
-  uint16x8_t even =
-      vmulq_u16(vreinterpretq_u16_u8(vbslq_u8(mask, a.val, zero)),
-                vreinterpretq_u16_u8(vbslq_u8(mask, b.val, zero)));
-  uint16x8_t odd = vmulq_u16(vshrq_n_u16(vreinterpretq_u16_u8(a.val), 8),
-                             vshrq_n_u16(vreinterpretq_u16_u8(b.val), 8));
-
-  uint32x4_t s0 =
-      vaddq_u32(vreinterpretq_u32_u16(vbslq_u16(mask32, even, zero32)),
-                vreinterpretq_u32_u16(vbslq_u16(mask32, odd, zero32)));
-  uint32x4_t s1 = vaddq_u32(vshrq_n_u32(vreinterpretq_u32_u16(even), 16),
-                            vshrq_n_u32(vreinterpretq_u32_u16(odd), 16));
-  return v_uint32x4(vaddq_u32(s0, s1));
-}
-inline v_uint32x4 v_dotprod_expand(const v_uint8x16 &a, const v_uint8x16 &b,
-                                   const v_uint32x4 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-inline v_int32x4 v_dotprod_expand(const v_int8x16 &a, const v_int8x16 &b) {
-  int16x8_t p0 = vmull_s8(vget_low_s8(a.val), vget_low_s8(b.val));
-  int16x8_t p1 = vmull_s8(vget_high_s8(a.val), vget_high_s8(b.val));
-  int16x8_t uzp1, uzp2;
-  _v128_unzip(p0, p1, uzp1, uzp2);
-  int16x8_t sum = vaddq_s16(uzp1, uzp2);
-  int16x4_t uzpl1, uzpl2;
-  _v128_unzip(vget_low_s16(sum), vget_high_s16(sum), uzpl1, uzpl2);
-  return v_int32x4(vaddl_s16(uzpl1, uzpl2));
-}
-inline v_int32x4 v_dotprod_expand(const v_int8x16 &a, const v_int8x16 &b,
-                                  const v_int32x4 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-#endif
-// 16 >> 64
-inline v_uint64x2 v_dotprod_expand(const v_uint16x8 &a, const v_uint16x8 &b) {
-  const uint16x8_t zero = vreinterpretq_u16_u32(vdupq_n_u32(0));
-  const uint16x8_t mask = vreinterpretq_u16_u32(vdupq_n_u32(0x0000FFFF));
-
-  uint32x4_t even =
-      vmulq_u32(vreinterpretq_u32_u16(vbslq_u16(mask, a.val, zero)),
-                vreinterpretq_u32_u16(vbslq_u16(mask, b.val, zero)));
-  uint32x4_t odd = vmulq_u32(vshrq_n_u32(vreinterpretq_u32_u16(a.val), 16),
-                             vshrq_n_u32(vreinterpretq_u32_u16(b.val), 16));
-  uint32x4_t uzp1, uzp2;
-  _v128_unzip(even, odd, uzp1, uzp2);
-  uint64x2_t s0 = vaddl_u32(vget_low_u32(uzp1), vget_high_u32(uzp1));
-  uint64x2_t s1 = vaddl_u32(vget_low_u32(uzp2), vget_high_u32(uzp2));
-  return v_uint64x2(vaddq_u64(s0, s1));
-}
-inline v_uint64x2 v_dotprod_expand(const v_uint16x8 &a, const v_uint16x8 &b,
-                                   const v_uint64x2 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-inline v_int64x2 v_dotprod_expand(const v_int16x8 &a, const v_int16x8 &b) {
-  int32x4_t p0 = vmull_s16(vget_low_s16(a.val), vget_low_s16(b.val));
-  int32x4_t p1 = vmull_s16(vget_high_s16(a.val), vget_high_s16(b.val));
-
-  int32x4_t uzp1, uzp2;
-  _v128_unzip(p0, p1, uzp1, uzp2);
-  int32x4_t sum = vaddq_s32(uzp1, uzp2);
-
-  int32x2_t uzpl1, uzpl2;
-  _v128_unzip(vget_low_s32(sum), vget_high_s32(sum), uzpl1, uzpl2);
-  return v_int64x2(vaddl_s32(uzpl1, uzpl2));
-}
-inline v_int64x2 v_dotprod_expand(const v_int16x8 &a, const v_int16x8 &b,
-                                  const v_int64x2 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-// 32 >> 64f
-#if CV_SIMD128_64F
-inline v_float64x2 v_dotprod_expand(const v_int32x4 &a, const v_int32x4 &b) {
-  return v_cvt_f64(v_dotprod(a, b));
-}
-inline v_float64x2 v_dotprod_expand(const v_int32x4 &a, const v_int32x4 &b,
-                                    const v_float64x2 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-#endif
-
-//////// Fast Dot Product ////////
-
-// 16 >> 32
-inline v_int32x4 v_dotprod_fast(const v_int16x8 &a, const v_int16x8 &b) {
-#if CV_NEON_AARCH64
-  int32x4_t p = vmull_s16(vget_low_s16(a.val), vget_low_s16(b.val));
-  return v_int32x4(vmlal_high_s16(p, a.val, b.val));
-#else
-  int16x4_t a0 = vget_low_s16(a.val);
-  int16x4_t a1 = vget_high_s16(a.val);
-  int16x4_t b0 = vget_low_s16(b.val);
-  int16x4_t b1 = vget_high_s16(b.val);
-  int32x4_t p = vmull_s16(a0, b0);
-  return v_int32x4(vmlal_s16(p, a1, b1));
-#endif
-}
-inline v_int32x4 v_dotprod_fast(const v_int16x8 &a, const v_int16x8 &b,
-                                const v_int32x4 &c) {
-#if CV_NEON_AARCH64
-  int32x4_t p = vmlal_s16(c.val, vget_low_s16(a.val), vget_low_s16(b.val));
-  return v_int32x4(vmlal_high_s16(p, a.val, b.val));
-#else
-  int16x4_t a0 = vget_low_s16(a.val);
-  int16x4_t a1 = vget_high_s16(a.val);
-  int16x4_t b0 = vget_low_s16(b.val);
-  int16x4_t b1 = vget_high_s16(b.val);
-  int32x4_t p = vmlal_s16(c.val, a0, b0);
-  return v_int32x4(vmlal_s16(p, a1, b1));
-#endif
-}
-
-// 32 >> 64
-inline v_int64x2 v_dotprod_fast(const v_int32x4 &a, const v_int32x4 &b) {
-#if CV_NEON_AARCH64
-  int64x2_t p = vmull_s32(vget_low_s32(a.val), vget_low_s32(b.val));
-  return v_int64x2(vmlal_high_s32(p, a.val, b.val));
-#else
-  int32x2_t a0 = vget_low_s32(a.val);
-  int32x2_t a1 = vget_high_s32(a.val);
-  int32x2_t b0 = vget_low_s32(b.val);
-  int32x2_t b1 = vget_high_s32(b.val);
-  int64x2_t p = vmull_s32(a0, b0);
-  return v_int64x2(vmlal_s32(p, a1, b1));
-#endif
-}
-inline v_int64x2 v_dotprod_fast(const v_int32x4 &a, const v_int32x4 &b,
-                                const v_int64x2 &c) {
-#if CV_NEON_AARCH64
-  int64x2_t p = vmlal_s32(c.val, vget_low_s32(a.val), vget_low_s32(b.val));
-  return v_int64x2(vmlal_high_s32(p, a.val, b.val));
-#else
-  int32x2_t a0 = vget_low_s32(a.val);
-  int32x2_t a1 = vget_high_s32(a.val);
-  int32x2_t b0 = vget_low_s32(b.val);
-  int32x2_t b1 = vget_high_s32(b.val);
-  int64x2_t p = vmlal_s32(c.val, a0, b0);
-  return v_int64x2(vmlal_s32(p, a1, b1));
-#endif
-}
-
-// 8 >> 32
-#ifdef CV_NEON_DOT
-#define OPENCV_HAL_IMPL_NEON_DOT_PRODUCT_FAST_OP(_Tpvec1, _Tpvec2, suffix)     \
-  inline _Tpvec1 v_dotprod_expand_fast(const _Tpvec2 &a, const _Tpvec2 &b) {   \
-    return v_dotprod_expand(a, b);                                             \
-  }                                                                            \
-  inline _Tpvec1 v_dotprod_expand_fast(const _Tpvec2 &a, const _Tpvec2 &b,     \
-                                       const _Tpvec1 &c) {                     \
-    return v_dotprod_expand(a, b, c);                                          \
-  }
-
-OPENCV_HAL_IMPL_NEON_DOT_PRODUCT_FAST_OP(v_uint32x4, v_uint8x16, u32)
-OPENCV_HAL_IMPL_NEON_DOT_PRODUCT_FAST_OP(v_int32x4, v_int8x16, s32)
-#else
-inline v_uint32x4 v_dotprod_expand_fast(const v_uint8x16 &a,
-                                        const v_uint8x16 &b) {
-  uint16x8_t p0 = vmull_u8(vget_low_u8(a.val), vget_low_u8(b.val));
-  uint16x8_t p1 = vmull_u8(vget_high_u8(a.val), vget_high_u8(b.val));
-  uint32x4_t s0 = vaddl_u16(vget_low_u16(p0), vget_low_u16(p1));
-  uint32x4_t s1 = vaddl_u16(vget_high_u16(p0), vget_high_u16(p1));
-  return v_uint32x4(vaddq_u32(s0, s1));
-}
-inline v_uint32x4 v_dotprod_expand_fast(const v_uint8x16 &a,
-                                        const v_uint8x16 &b,
-                                        const v_uint32x4 &c) {
-  return v_add(v_dotprod_expand_fast(a, b), c);
-}
-
-inline v_int32x4 v_dotprod_expand_fast(const v_int8x16 &a, const v_int8x16 &b) {
-  int16x8_t prod = vmull_s8(vget_low_s8(a.val), vget_low_s8(b.val));
-  prod = vmlal_s8(prod, vget_high_s8(a.val), vget_high_s8(b.val));
-  return v_int32x4(vaddl_s16(vget_low_s16(prod), vget_high_s16(prod)));
-}
-inline v_int32x4 v_dotprod_expand_fast(const v_int8x16 &a, const v_int8x16 &b,
-                                       const v_int32x4 &c) {
-  return v_add(v_dotprod_expand_fast(a, b), c);
-}
-#endif
-
-// 16 >> 64
-inline v_uint64x2 v_dotprod_expand_fast(const v_uint16x8 &a,
-                                        const v_uint16x8 &b) {
-  uint32x4_t p0 = vmull_u16(vget_low_u16(a.val), vget_low_u16(b.val));
-  uint32x4_t p1 = vmull_u16(vget_high_u16(a.val), vget_high_u16(b.val));
-  uint64x2_t s0 = vaddl_u32(vget_low_u32(p0), vget_high_u32(p0));
-  uint64x2_t s1 = vaddl_u32(vget_low_u32(p1), vget_high_u32(p1));
-  return v_uint64x2(vaddq_u64(s0, s1));
-}
-inline v_uint64x2 v_dotprod_expand_fast(const v_uint16x8 &a,
-                                        const v_uint16x8 &b,
-                                        const v_uint64x2 &c) {
-  return v_add(v_dotprod_expand_fast(a, b), c);
-}
-
-inline v_int64x2 v_dotprod_expand_fast(const v_int16x8 &a, const v_int16x8 &b) {
-  int32x4_t prod = vmull_s16(vget_low_s16(a.val), vget_low_s16(b.val));
-  prod = vmlal_s16(prod, vget_high_s16(a.val), vget_high_s16(b.val));
-  return v_int64x2(vaddl_s32(vget_low_s32(prod), vget_high_s32(prod)));
-}
-inline v_int64x2 v_dotprod_expand_fast(const v_int16x8 &a, const v_int16x8 &b,
-                                       const v_int64x2 &c) {
-  return v_add(v_dotprod_expand_fast(a, b), c);
-}
-
-// 32 >> 64f
-#if CV_SIMD128_64F
-inline v_float64x2 v_dotprod_expand_fast(const v_int32x4 &a,
-                                         const v_int32x4 &b) {
-  return v_cvt_f64(v_dotprod_fast(a, b));
-}
-inline v_float64x2 v_dotprod_expand_fast(const v_int32x4 &a, const v_int32x4 &b,
-                                         const v_float64x2 &c) {
-  return v_add(v_dotprod_expand_fast(a, b), c);
-}
-#endif
-
-#define OPENCV_HAL_IMPL_NEON_LOGIC_OP(_Tpvec, suffix)                          \
-  OPENCV_HAL_IMPL_NEON_BIN_OP(v_and, _Tpvec, vandq_##suffix)                   \
-  OPENCV_HAL_IMPL_NEON_BIN_OP(v_or, _Tpvec, vorrq_##suffix)                    \
-  OPENCV_HAL_IMPL_NEON_BIN_OP(v_xor, _Tpvec, veorq_##suffix)                   \
-  inline _Tpvec v_not(const _Tpvec &a) {                                       \
-    return _Tpvec(vreinterpretq_##suffix##_u8(                                 \
-        vmvnq_u8(vreinterpretq_u8_##suffix(a.val))));                          \
-  }
-
-OPENCV_HAL_IMPL_NEON_LOGIC_OP(v_uint8x16, u8)
-OPENCV_HAL_IMPL_NEON_LOGIC_OP(v_int8x16, s8)
-OPENCV_HAL_IMPL_NEON_LOGIC_OP(v_uint16x8, u16)
-OPENCV_HAL_IMPL_NEON_LOGIC_OP(v_int16x8, s16)
-OPENCV_HAL_IMPL_NEON_LOGIC_OP(v_uint32x4, u32)
-OPENCV_HAL_IMPL_NEON_LOGIC_OP(v_int32x4, s32)
-OPENCV_HAL_IMPL_NEON_LOGIC_OP(v_uint64x2, u64)
-OPENCV_HAL_IMPL_NEON_LOGIC_OP(v_int64x2, s64)
-
-#define OPENCV_HAL_IMPL_NEON_FLT_BIT_OP(bin_op, intrin)                        \
-  inline v_float32x4 bin_op(const v_float32x4 &a, const v_float32x4 &b) {      \
-    return v_float32x4(vreinterpretq_f32_s32(                                  \
-        intrin(vreinterpretq_s32_f32(a.val), vreinterpretq_s32_f32(b.val))));  \
-  }
-
-OPENCV_HAL_IMPL_NEON_FLT_BIT_OP(v_and, vandq_s32)
-OPENCV_HAL_IMPL_NEON_FLT_BIT_OP(v_or, vorrq_s32)
-OPENCV_HAL_IMPL_NEON_FLT_BIT_OP(v_xor, veorq_s32)
-
-inline v_float32x4 v_not(const v_float32x4 &a) {
-  return v_float32x4(
-      vreinterpretq_f32_s32(vmvnq_s32(vreinterpretq_s32_f32(a.val))));
-}
-
-#if CV_SIMD128_64F
-inline v_float32x4 v_sqrt(const v_float32x4 &x) {
-  return v_float32x4(vsqrtq_f32(x.val));
-}
-
-inline v_float32x4 v_invsqrt(const v_float32x4 &x) {
-  v_float32x4 one = v_setall_f32(1.0f);
-  return v_div(one, v_sqrt(x));
-}
-#else
-inline v_float32x4 v_sqrt(const v_float32x4 &x) {
-  float32x4_t x1 = vmaxq_f32(x.val, vdupq_n_f32(FLT_MIN));
-  float32x4_t e = vrsqrteq_f32(x1);
-  e = vmulq_f32(vrsqrtsq_f32(vmulq_f32(x1, e), e), e);
-  e = vmulq_f32(vrsqrtsq_f32(vmulq_f32(x1, e), e), e);
-  return v_float32x4(vmulq_f32(x.val, e));
-}
-
-inline v_float32x4 v_invsqrt(const v_float32x4 &x) {
-  float32x4_t e = vrsqrteq_f32(x.val);
-  e = vmulq_f32(vrsqrtsq_f32(vmulq_f32(x.val, e), e), e);
-  e = vmulq_f32(vrsqrtsq_f32(vmulq_f32(x.val, e), e), e);
-  return v_float32x4(e);
-}
-#endif
-
-#define OPENCV_HAL_IMPL_NEON_ABS(_Tpuvec, _Tpsvec, usuffix, ssuffix)           \
-  inline _Tpuvec v_abs(const _Tpsvec &a) {                                     \
-    return v_reinterpret_as_##usuffix(_Tpsvec(vabsq_##ssuffix(a.val)));        \
-  }
-
-OPENCV_HAL_IMPL_NEON_ABS(v_uint8x16, v_int8x16, u8, s8)
-OPENCV_HAL_IMPL_NEON_ABS(v_uint16x8, v_int16x8, u16, s16)
-OPENCV_HAL_IMPL_NEON_ABS(v_uint32x4, v_int32x4, u32, s32)
-
-inline v_float32x4 v_abs(v_float32x4 x) {
-  return v_float32x4(vabsq_f32(x.val));
-}
-
-#if CV_SIMD128_64F
-#define OPENCV_HAL_IMPL_NEON_DBL_BIT_OP(bin_op, intrin)                        \
-  inline v_float64x2 bin_op(const v_float64x2 &a, const v_float64x2 &b) {      \
-    return v_float64x2(vreinterpretq_f64_s64(                                  \
-        intrin(vreinterpretq_s64_f64(a.val), vreinterpretq_s64_f64(b.val))));  \
-  }
-
-OPENCV_HAL_IMPL_NEON_DBL_BIT_OP(v_and, vandq_s64)
-OPENCV_HAL_IMPL_NEON_DBL_BIT_OP(v_or, vorrq_s64)
-OPENCV_HAL_IMPL_NEON_DBL_BIT_OP(v_xor, veorq_s64)
-
-inline v_float64x2 v_not(const v_float64x2 &a) {
-  return v_float64x2(
-      vreinterpretq_f64_s32(vmvnq_s32(vreinterpretq_s32_f64(a.val))));
-}
-
-inline v_float64x2 v_sqrt(const v_float64x2 &x) {
-  return v_float64x2(vsqrtq_f64(x.val));
-}
-
-inline v_float64x2 v_invsqrt(const v_float64x2 &x) {
-  v_float64x2 one = v_setall_f64(1.0f);
-  return v_div(one, v_sqrt(x));
-}
-
-inline v_float64x2 v_abs(v_float64x2 x) {
-  return v_float64x2(vabsq_f64(x.val));
-}
-#endif
-
-// TODO: exp, log, sin, cos
-
-#define OPENCV_HAL_IMPL_NEON_BIN_FUNC(_Tpvec, func, intrin)                    \
-  inline _Tpvec func(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(intrin(a.val, b.val));                                       \
-  }
-
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_uint8x16, v_min, vminq_u8)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_uint8x16, v_max, vmaxq_u8)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_int8x16, v_min, vminq_s8)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_int8x16, v_max, vmaxq_s8)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_uint16x8, v_min, vminq_u16)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_uint16x8, v_max, vmaxq_u16)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_int16x8, v_min, vminq_s16)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_int16x8, v_max, vmaxq_s16)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_uint32x4, v_min, vminq_u32)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_uint32x4, v_max, vmaxq_u32)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_int32x4, v_min, vminq_s32)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_int32x4, v_max, vmaxq_s32)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_float32x4, v_min, vminq_f32)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_float32x4, v_max, vmaxq_f32)
-#if CV_SIMD128_64F
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_float64x2, v_min, vminq_f64)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_float64x2, v_max, vmaxq_f64)
-#endif
-
-#define OPENCV_HAL_IMPL_NEON_INT_CMP_OP(_Tpvec, cast, suffix, not_suffix)      \
-  inline _Tpvec v_eq(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(cast(vceqq_##suffix(a.val, b.val)));                         \
-  }                                                                            \
-  inline _Tpvec v_ne(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(cast(vmvnq_##not_suffix(vceqq_##suffix(a.val, b.val))));     \
-  }                                                                            \
-  inline _Tpvec v_lt(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(cast(vcltq_##suffix(a.val, b.val)));                         \
-  }                                                                            \
-  inline _Tpvec v_gt(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(cast(vcgtq_##suffix(a.val, b.val)));                         \
-  }                                                                            \
-  inline _Tpvec v_le(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(cast(vcleq_##suffix(a.val, b.val)));                         \
-  }                                                                            \
-  inline _Tpvec v_ge(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(cast(vcgeq_##suffix(a.val, b.val)));                         \
-  }
-
-OPENCV_HAL_IMPL_NEON_INT_CMP_OP(v_uint8x16, OPENCV_HAL_NOP, u8, u8)
-OPENCV_HAL_IMPL_NEON_INT_CMP_OP(v_int8x16, vreinterpretq_s8_u8, s8, u8)
-OPENCV_HAL_IMPL_NEON_INT_CMP_OP(v_uint16x8, OPENCV_HAL_NOP, u16, u16)
-OPENCV_HAL_IMPL_NEON_INT_CMP_OP(v_int16x8, vreinterpretq_s16_u16, s16, u16)
-OPENCV_HAL_IMPL_NEON_INT_CMP_OP(v_uint32x4, OPENCV_HAL_NOP, u32, u32)
-OPENCV_HAL_IMPL_NEON_INT_CMP_OP(v_int32x4, vreinterpretq_s32_u32, s32, u32)
-OPENCV_HAL_IMPL_NEON_INT_CMP_OP(v_float32x4, vreinterpretq_f32_u32, f32, u32)
-#if defined(__aarch64__) || defined(_M_ARM64)
-static inline uint64x2_t vmvnq_u64(uint64x2_t a) {
-  uint64x2_t vx = vreinterpretq_u64_u32(vdupq_n_u32(0xFFFFFFFF));
-  return veorq_u64(a, vx);
-}
-// OPENCV_HAL_IMPL_NEON_INT_CMP_OP(v_uint64x2, OPENCV_HAL_NOP, u64, u64)
-// OPENCV_HAL_IMPL_NEON_INT_CMP_OP(v_int64x2, vreinterpretq_s64_u64, s64, u64)
-static inline v_uint64x2 v_eq(const v_uint64x2 &a, const v_uint64x2 &b) {
-  return v_uint64x2(vceqq_u64(a.val, b.val));
-}
-static inline v_uint64x2 v_ne(const v_uint64x2 &a, const v_uint64x2 &b) {
-  return v_uint64x2(vmvnq_u64(vceqq_u64(a.val, b.val)));
-}
-static inline v_int64x2 v_eq(const v_int64x2 &a, const v_int64x2 &b) {
-  return v_int64x2(vreinterpretq_s64_u64(vceqq_s64(a.val, b.val)));
-}
-static inline v_int64x2 v_ne(const v_int64x2 &a, const v_int64x2 &b) {
-  return v_int64x2(vreinterpretq_s64_u64(vmvnq_u64(vceqq_s64(a.val, b.val))));
-}
-#else
-static inline v_uint64x2 v_eq(const v_uint64x2 &a, const v_uint64x2 &b) {
-  uint32x4_t cmp =
-      vceqq_u32(vreinterpretq_u32_u64(a.val), vreinterpretq_u32_u64(b.val));
-  uint32x4_t swapped = vrev64q_u32(cmp);
-  return v_uint64x2(vreinterpretq_u64_u32(vandq_u32(cmp, swapped)));
-}
-static inline v_uint64x2 v_ne(const v_uint64x2 &a, const v_uint64x2 &b) {
-  uint32x4_t cmp =
-      vceqq_u32(vreinterpretq_u32_u64(a.val), vreinterpretq_u32_u64(b.val));
-  uint32x4_t swapped = vrev64q_u32(cmp);
-  uint64x2_t v_eq = vreinterpretq_u64_u32(vandq_u32(cmp, swapped));
-  uint64x2_t vx = vreinterpretq_u64_u32(vdupq_n_u32(0xFFFFFFFF));
-  return v_uint64x2(veorq_u64(v_eq, vx));
-}
-static inline v_int64x2 v_eq(const v_int64x2 &a, const v_int64x2 &b) {
-  return v_reinterpret_as_s64(
-      v_eq(v_reinterpret_as_u64(a), v_reinterpret_as_u64(b)));
-}
-static inline v_int64x2 v_ne(const v_int64x2 &a, const v_int64x2 &b) {
-  return v_reinterpret_as_s64(
-      v_ne(v_reinterpret_as_u64(a), v_reinterpret_as_u64(b)));
-}
-#endif
-#if CV_SIMD128_64F
-OPENCV_HAL_IMPL_NEON_INT_CMP_OP(v_float64x2, vreinterpretq_f64_u64, f64, u64)
-#endif
-
-inline v_float32x4 v_not_nan(const v_float32x4 &a) {
-  return v_float32x4(vreinterpretq_f32_u32(vceqq_f32(a.val, a.val)));
-}
-#if CV_SIMD128_64F
-inline v_float64x2 v_not_nan(const v_float64x2 &a) {
-  return v_float64x2(vreinterpretq_f64_u64(vceqq_f64(a.val, a.val)));
-}
-#endif
-
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_uint8x16, v_add_wrap, vaddq_u8)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_int8x16, v_add_wrap, vaddq_s8)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_uint16x8, v_add_wrap, vaddq_u16)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_int16x8, v_add_wrap, vaddq_s16)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_uint8x16, v_sub_wrap, vsubq_u8)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_int8x16, v_sub_wrap, vsubq_s8)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_uint16x8, v_sub_wrap, vsubq_u16)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_int16x8, v_sub_wrap, vsubq_s16)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_uint8x16, v_mul_wrap, vmulq_u8)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_int8x16, v_mul_wrap, vmulq_s8)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_uint16x8, v_mul_wrap, vmulq_u16)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_int16x8, v_mul_wrap, vmulq_s16)
-
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_uint8x16, v_absdiff, vabdq_u8)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_uint16x8, v_absdiff, vabdq_u16)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_uint32x4, v_absdiff, vabdq_u32)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_float32x4, v_absdiff, vabdq_f32)
-#if CV_SIMD128_64F
-OPENCV_HAL_IMPL_NEON_BIN_FUNC(v_float64x2, v_absdiff, vabdq_f64)
-#endif
-
-/** Saturating absolute difference **/
-inline v_int8x16 v_absdiffs(const v_int8x16 &a, const v_int8x16 &b) {
-  return v_int8x16(vqabsq_s8(vqsubq_s8(a.val, b.val)));
-}
-inline v_int16x8 v_absdiffs(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_int16x8(vqabsq_s16(vqsubq_s16(a.val, b.val)));
-}
-
-#define OPENCV_HAL_IMPL_NEON_BIN_FUNC2(_Tpvec, _Tpvec2, cast, func, intrin)    \
-  inline _Tpvec2 func(const _Tpvec &a, const _Tpvec &b) {                      \
-    return _Tpvec2(cast(intrin(a.val, b.val)));                                \
-  }
-
-OPENCV_HAL_IMPL_NEON_BIN_FUNC2(v_int8x16, v_uint8x16, vreinterpretq_u8_s8,
-                               v_absdiff, vabdq_s8)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC2(v_int16x8, v_uint16x8, vreinterpretq_u16_s16,
-                               v_absdiff, vabdq_s16)
-OPENCV_HAL_IMPL_NEON_BIN_FUNC2(v_int32x4, v_uint32x4, vreinterpretq_u32_s32,
-                               v_absdiff, vabdq_s32)
-
-inline v_float32x4 v_magnitude(const v_float32x4 &a, const v_float32x4 &b) {
-  v_float32x4 x(vmlaq_f32(vmulq_f32(a.val, a.val), b.val, b.val));
-  return v_sqrt(x);
-}
-
-inline v_float32x4 v_sqr_magnitude(const v_float32x4 &a, const v_float32x4 &b) {
-  return v_float32x4(vmlaq_f32(vmulq_f32(a.val, a.val), b.val, b.val));
-}
-
-inline v_float32x4 v_fma(const v_float32x4 &a, const v_float32x4 &b,
-                         const v_float32x4 &c) {
-#if CV_SIMD128_64F
-  // ARMv8, which adds support for 64-bit floating-point (so CV_SIMD128_64F is
-  // defined), also adds FMA support both for single- and double-precision
-  // floating-point vectors
-  return v_float32x4(vfmaq_f32(c.val, a.val, b.val));
-#else
-  return v_float32x4(vmlaq_f32(c.val, a.val, b.val));
-#endif
-}
-
-inline v_int32x4 v_fma(const v_int32x4 &a, const v_int32x4 &b,
-                       const v_int32x4 &c) {
-  return v_int32x4(vmlaq_s32(c.val, a.val, b.val));
-}
-
-inline v_float32x4 v_muladd(const v_float32x4 &a, const v_float32x4 &b,
-                            const v_float32x4 &c) {
-  return v_fma(a, b, c);
-}
-
-inline v_int32x4 v_muladd(const v_int32x4 &a, const v_int32x4 &b,
-                          const v_int32x4 &c) {
-  return v_fma(a, b, c);
-}
-
-#if CV_SIMD128_64F
-inline v_float64x2 v_magnitude(const v_float64x2 &a, const v_float64x2 &b) {
-  v_float64x2 x(vaddq_f64(vmulq_f64(a.val, a.val), vmulq_f64(b.val, b.val)));
-  return v_sqrt(x);
-}
-
-inline v_float64x2 v_sqr_magnitude(const v_float64x2 &a, const v_float64x2 &b) {
-  return v_float64x2(
-      vaddq_f64(vmulq_f64(a.val, a.val), vmulq_f64(b.val, b.val)));
-}
-
-inline v_float64x2 v_fma(const v_float64x2 &a, const v_float64x2 &b,
-                         const v_float64x2 &c) {
-  return v_float64x2(vfmaq_f64(c.val, a.val, b.val));
-}
-
-inline v_float64x2 v_muladd(const v_float64x2 &a, const v_float64x2 &b,
-                            const v_float64x2 &c) {
-  return v_fma(a, b, c);
-}
-#endif
-
-// trade efficiency for convenience
-#define OPENCV_HAL_IMPL_NEON_SHIFT_OP(_Tpvec, suffix, _Tps, ssuffix)           \
-  inline _Tpvec v_shl(const _Tpvec &a, int n) {                                \
-    return _Tpvec(vshlq_##suffix(a.val, vdupq_n_##ssuffix((_Tps)n)));          \
-  }                                                                            \
-  inline _Tpvec v_shr(const _Tpvec &a, int n) {                                \
-    return _Tpvec(vshlq_##suffix(a.val, vdupq_n_##ssuffix((_Tps) - n)));       \
-  }                                                                            \
-  template <int n> inline _Tpvec v_shl(const _Tpvec &a) {                      \
-    return _Tpvec(vshlq_n_##suffix(a.val, n));                                 \
-  }                                                                            \
-  template <int n> inline _Tpvec v_shr(const _Tpvec &a) {                      \
-    return _Tpvec(vshrq_n_##suffix(a.val, n));                                 \
-  }                                                                            \
-  template <int n> inline _Tpvec v_rshr(const _Tpvec &a) {                     \
-    return _Tpvec(vrshrq_n_##suffix(a.val, n));                                \
-  }
-
-OPENCV_HAL_IMPL_NEON_SHIFT_OP(v_uint8x16, u8, schar, s8)
-OPENCV_HAL_IMPL_NEON_SHIFT_OP(v_int8x16, s8, schar, s8)
-OPENCV_HAL_IMPL_NEON_SHIFT_OP(v_uint16x8, u16, short, s16)
-OPENCV_HAL_IMPL_NEON_SHIFT_OP(v_int16x8, s16, short, s16)
-OPENCV_HAL_IMPL_NEON_SHIFT_OP(v_uint32x4, u32, int, s32)
-OPENCV_HAL_IMPL_NEON_SHIFT_OP(v_int32x4, s32, int, s32)
-OPENCV_HAL_IMPL_NEON_SHIFT_OP(v_uint64x2, u64, int64, s64)
-OPENCV_HAL_IMPL_NEON_SHIFT_OP(v_int64x2, s64, int64, s64)
-
-#define OPENCV_HAL_IMPL_NEON_ROTATE_OP(_Tpvec, suffix)                         \
-  template <int n> inline _Tpvec v_rotate_right(const _Tpvec &a) {             \
-    return _Tpvec(vextq_##suffix(a.val, vdupq_n_##suffix(0), n));              \
-  }                                                                            \
-  template <int n> inline _Tpvec v_rotate_left(const _Tpvec &a) {              \
-    return _Tpvec(vextq_##suffix(vdupq_n_##suffix(0), a.val,                   \
-                                 VTraits<_Tpvec>::nlanes - n));                \
-  }                                                                            \
-  template <> inline _Tpvec v_rotate_left<0>(const _Tpvec &a) { return a; }    \
-  template <int n>                                                             \
-  inline _Tpvec v_rotate_right(const _Tpvec &a, const _Tpvec &b) {             \
-    return _Tpvec(vextq_##suffix(a.val, b.val, n));                            \
-  }                                                                            \
-  template <int n>                                                             \
-  inline _Tpvec v_rotate_left(const _Tpvec &a, const _Tpvec &b) {              \
-    return _Tpvec(vextq_##suffix(b.val, a.val, VTraits<_Tpvec>::nlanes - n));  \
-  }                                                                            \
-  template <>                                                                  \
-  inline _Tpvec v_rotate_left<0>(const _Tpvec &a, const _Tpvec &b) {           \
-    CV_UNUSED(b);                                                              \
-    return a;                                                                  \
-  }
-
-OPENCV_HAL_IMPL_NEON_ROTATE_OP(v_uint8x16, u8)
-OPENCV_HAL_IMPL_NEON_ROTATE_OP(v_int8x16, s8)
-OPENCV_HAL_IMPL_NEON_ROTATE_OP(v_uint16x8, u16)
-OPENCV_HAL_IMPL_NEON_ROTATE_OP(v_int16x8, s16)
-OPENCV_HAL_IMPL_NEON_ROTATE_OP(v_uint32x4, u32)
-OPENCV_HAL_IMPL_NEON_ROTATE_OP(v_int32x4, s32)
-OPENCV_HAL_IMPL_NEON_ROTATE_OP(v_float32x4, f32)
-OPENCV_HAL_IMPL_NEON_ROTATE_OP(v_uint64x2, u64)
-OPENCV_HAL_IMPL_NEON_ROTATE_OP(v_int64x2, s64)
-#if CV_SIMD128_64F
-OPENCV_HAL_IMPL_NEON_ROTATE_OP(v_float64x2, f64)
-#endif
-
-#if defined(__clang__) && defined(__aarch64__)
-// avoid LD2 instruction. details: https://github.com/opencv/opencv/issues/14863
-#define OPENCV_HAL_IMPL_NEON_LOAD_LOW_OP(_Tpvec, _Tp, suffix)                  \
-  inline _Tpvec v_load_low(const _Tp *ptr) {                                   \
-    typedef uint64 CV_DECL_ALIGNED(1) unaligned_uint64;                        \
-    uint64 v = *(unaligned_uint64 *)ptr;                                       \
-    return _Tpvec(v_reinterpret_as_##suffix(v_uint64x2(v, (uint64)123456)));   \
-  }
-#else
-#define OPENCV_HAL_IMPL_NEON_LOAD_LOW_OP(_Tpvec, _Tp, suffix)                  \
-  inline _Tpvec v_load_low(const _Tp *ptr) {                                   \
-    return _Tpvec(                                                             \
-        vcombine_##suffix(vld1_##suffix(ptr), vdup_n_##suffix((_Tp)0)));       \
-  }
-#endif
-
-#define OPENCV_HAL_IMPL_NEON_LOADSTORE_OP(_Tpvec, _Tp, suffix)                 \
-  inline _Tpvec v_load(const _Tp *ptr) { return _Tpvec(vld1q_##suffix(ptr)); } \
-  inline _Tpvec v_load_aligned(const _Tp *ptr) {                               \
-    return _Tpvec(vld1q_##suffix(ptr));                                        \
-  }                                                                            \
-  OPENCV_HAL_IMPL_NEON_LOAD_LOW_OP(_Tpvec, _Tp, suffix)                        \
-  inline _Tpvec v_load_halves(const _Tp *ptr0, const _Tp *ptr1) {              \
-    return _Tpvec(                                                             \
-        vcombine_##suffix(vld1_##suffix(ptr0), vld1_##suffix(ptr1)));          \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a) {                             \
-    vst1q_##suffix(ptr, a.val);                                                \
-  }                                                                            \
-  inline void v_store_aligned(_Tp *ptr, const _Tpvec &a) {                     \
-    vst1q_##suffix(ptr, a.val);                                                \
-  }                                                                            \
-  inline void v_store_aligned_nocache(_Tp *ptr, const _Tpvec &a) {             \
-    vst1q_##suffix(ptr, a.val);                                                \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a, hal::StoreMode /*mode*/) {    \
-    vst1q_##suffix(ptr, a.val);                                                \
-  }                                                                            \
-  inline void v_store_low(_Tp *ptr, const _Tpvec &a) {                         \
-    vst1_##suffix(ptr, vget_low_##suffix(a.val));                              \
-  }                                                                            \
-  inline void v_store_high(_Tp *ptr, const _Tpvec &a) {                        \
-    vst1_##suffix(ptr, vget_high_##suffix(a.val));                             \
-  }
-
-OPENCV_HAL_IMPL_NEON_LOADSTORE_OP(v_uint8x16, uchar, u8)
-OPENCV_HAL_IMPL_NEON_LOADSTORE_OP(v_int8x16, schar, s8)
-OPENCV_HAL_IMPL_NEON_LOADSTORE_OP(v_uint16x8, ushort, u16)
-OPENCV_HAL_IMPL_NEON_LOADSTORE_OP(v_int16x8, short, s16)
-OPENCV_HAL_IMPL_NEON_LOADSTORE_OP(v_uint32x4, unsigned, u32)
-OPENCV_HAL_IMPL_NEON_LOADSTORE_OP(v_int32x4, int, s32)
-OPENCV_HAL_IMPL_NEON_LOADSTORE_OP(v_uint64x2, uint64, u64)
-OPENCV_HAL_IMPL_NEON_LOADSTORE_OP(v_int64x2, int64, s64)
-OPENCV_HAL_IMPL_NEON_LOADSTORE_OP(v_float32x4, float, f32)
-#if CV_SIMD128_64F
-OPENCV_HAL_IMPL_NEON_LOADSTORE_OP(v_float64x2, double, f64)
-#endif
-
-inline unsigned v_reduce_sum(const v_uint8x16 &a) {
-#if CV_NEON_AARCH64
-  uint16_t t0 = vaddlvq_u8(a.val);
-  return t0;
-#else  // #if CV_NEON_AARCH64
-  uint32x4_t t0 = vpaddlq_u16(vpaddlq_u8(a.val));
-  uint32x2_t t1 = vpadd_u32(vget_low_u32(t0), vget_high_u32(t0));
-  return vget_lane_u32(vpadd_u32(t1, t1), 0);
-#endif // #if CV_NEON_AARCH64
-}
-inline int v_reduce_sum(const v_int8x16 &a) {
-#if CV_NEON_AARCH64
-  int16_t t0 = vaddlvq_s8(a.val);
-  return t0;
-#else  // #if CV_NEON_AARCH64
-  int32x4_t t0 = vpaddlq_s16(vpaddlq_s8(a.val));
-  int32x2_t t1 = vpadd_s32(vget_low_s32(t0), vget_high_s32(t0));
-  return vget_lane_s32(vpadd_s32(t1, t1), 0);
-#endif // #if CV_NEON_AARCH64
-}
-inline unsigned v_reduce_sum(const v_uint16x8 &a) {
-#if CV_NEON_AARCH64
-  uint32_t t0 = vaddlvq_u16(a.val);
-  return t0;
-#else  // #if CV_NEON_AARCH64
-  uint32x4_t t0 = vpaddlq_u16(a.val);
-  uint32x2_t t1 = vpadd_u32(vget_low_u32(t0), vget_high_u32(t0));
-  return vget_lane_u32(vpadd_u32(t1, t1), 0);
-#endif // #if CV_NEON_AARCH64
-}
-inline int v_reduce_sum(const v_int16x8 &a) {
-#if CV_NEON_AARCH64
-  int32_t t0 = vaddlvq_s16(a.val);
-  return t0;
-#else  // #if CV_NEON_AARCH64
-  int32x4_t t0 = vpaddlq_s16(a.val);
-  int32x2_t t1 = vpadd_s32(vget_low_s32(t0), vget_high_s32(t0));
-  return vget_lane_s32(vpadd_s32(t1, t1), 0);
-#endif // #if CV_NEON_AARCH64
-}
-
-#if CV_NEON_AARCH64
-#define OPENCV_HAL_IMPL_NEON_REDUCE_OP_16(_Tpvec, _Tpnvec, scalartype, func,   \
-                                          vectorfunc, suffix)                  \
-  inline scalartype v_reduce_##func(const _Tpvec &a) {                         \
-    return v##vectorfunc##vq_##suffix(a.val);                                  \
-  }
-#else // #if CV_NEON_AARCH64
-#define OPENCV_HAL_IMPL_NEON_REDUCE_OP_16(_Tpvec, _Tpnvec, scalartype, func,   \
-                                          vectorfunc, suffix)                  \
-  inline scalartype v_reduce_##func(const _Tpvec &a) {                         \
-    _Tpnvec##_t a0 = vp##vectorfunc##_##suffix(vget_low_##suffix(a.val),       \
-                                               vget_high_##suffix(a.val));     \
-    a0 = vp##vectorfunc##_##suffix(a0, a0);                                    \
-    a0 = vp##vectorfunc##_##suffix(a0, a0);                                    \
-    return (scalartype)vget_lane_##suffix(vp##vectorfunc##_##suffix(a0, a0),   \
-                                          0);                                  \
-  }
-#endif // #if CV_NEON_AARCH64
-
-OPENCV_HAL_IMPL_NEON_REDUCE_OP_16(v_uint8x16, uint8x8, uchar, max, max, u8)
-OPENCV_HAL_IMPL_NEON_REDUCE_OP_16(v_uint8x16, uint8x8, uchar, min, min, u8)
-OPENCV_HAL_IMPL_NEON_REDUCE_OP_16(v_int8x16, int8x8, schar, max, max, s8)
-OPENCV_HAL_IMPL_NEON_REDUCE_OP_16(v_int8x16, int8x8, schar, min, min, s8)
-
-#if CV_NEON_AARCH64
-#define OPENCV_HAL_IMPL_NEON_REDUCE_OP_8(_Tpvec, _Tpnvec, scalartype, func,    \
-                                         vectorfunc, suffix)                   \
-  inline scalartype v_reduce_##func(const _Tpvec &a) {                         \
-    return v##vectorfunc##vq_##suffix(a.val);                                  \
-  }
-#else // #if CV_NEON_AARCH64
-#define OPENCV_HAL_IMPL_NEON_REDUCE_OP_8(_Tpvec, _Tpnvec, scalartype, func,    \
-                                         vectorfunc, suffix)                   \
-  inline scalartype v_reduce_##func(const _Tpvec &a) {                         \
-    _Tpnvec##_t a0 = vp##vectorfunc##_##suffix(vget_low_##suffix(a.val),       \
-                                               vget_high_##suffix(a.val));     \
-    a0 = vp##vectorfunc##_##suffix(a0, a0);                                    \
-    return (scalartype)vget_lane_##suffix(vp##vectorfunc##_##suffix(a0, a0),   \
-                                          0);                                  \
-  }
-#endif // #if CV_NEON_AARCH64
-
-OPENCV_HAL_IMPL_NEON_REDUCE_OP_8(v_uint16x8, uint16x4, ushort, max, max, u16)
-OPENCV_HAL_IMPL_NEON_REDUCE_OP_8(v_uint16x8, uint16x4, ushort, min, min, u16)
-OPENCV_HAL_IMPL_NEON_REDUCE_OP_8(v_int16x8, int16x4, short, max, max, s16)
-OPENCV_HAL_IMPL_NEON_REDUCE_OP_8(v_int16x8, int16x4, short, min, min, s16)
-
-#if CV_NEON_AARCH64
-#define OPENCV_HAL_IMPL_NEON_REDUCE_OP_4(_Tpvec, _Tpnvec, scalartype, func,    \
-                                         vectorfunc, suffix)                   \
-  inline scalartype v_reduce_##func(const _Tpvec &a) {                         \
-    return v##vectorfunc##vq_##suffix(a.val);                                  \
-  }
-#else // #if CV_NEON_AARCH64
-#define OPENCV_HAL_IMPL_NEON_REDUCE_OP_4(_Tpvec, _Tpnvec, scalartype, func,    \
-                                         vectorfunc, suffix)                   \
-  inline scalartype v_reduce_##func(const _Tpvec &a) {                         \
-    _Tpnvec##_t a0 = vp##vectorfunc##_##suffix(vget_low_##suffix(a.val),       \
-                                               vget_high_##suffix(a.val));     \
-    return (scalartype)vget_lane_##suffix(                                     \
-        vp##vectorfunc##_##suffix(a0, vget_high_##suffix(a.val)), 0);          \
-  }
-#endif // #if CV_NEON_AARCH64
-
-OPENCV_HAL_IMPL_NEON_REDUCE_OP_4(v_uint32x4, uint32x2, unsigned, sum, add, u32)
-OPENCV_HAL_IMPL_NEON_REDUCE_OP_4(v_uint32x4, uint32x2, unsigned, max, max, u32)
-OPENCV_HAL_IMPL_NEON_REDUCE_OP_4(v_uint32x4, uint32x2, unsigned, min, min, u32)
-OPENCV_HAL_IMPL_NEON_REDUCE_OP_4(v_int32x4, int32x2, int, sum, add, s32)
-OPENCV_HAL_IMPL_NEON_REDUCE_OP_4(v_int32x4, int32x2, int, max, max, s32)
-OPENCV_HAL_IMPL_NEON_REDUCE_OP_4(v_int32x4, int32x2, int, min, min, s32)
-OPENCV_HAL_IMPL_NEON_REDUCE_OP_4(v_float32x4, float32x2, float, sum, add, f32)
-OPENCV_HAL_IMPL_NEON_REDUCE_OP_4(v_float32x4, float32x2, float, max, max, f32)
-OPENCV_HAL_IMPL_NEON_REDUCE_OP_4(v_float32x4, float32x2, float, min, min, f32)
-
-inline uint64 v_reduce_sum(const v_uint64x2 &a) {
-#if CV_NEON_AARCH64
-  return vaddvq_u64(a.val);
-#else  // #if CV_NEON_AARCH64
-  return vget_lane_u64(vadd_u64(vget_low_u64(a.val), vget_high_u64(a.val)), 0);
-#endif // #if CV_NEON_AARCH64
-}
-inline int64 v_reduce_sum(const v_int64x2 &a) {
-#if CV_NEON_AARCH64
-  return vaddvq_s64(a.val);
-#else  // #if CV_NEON_AARCH64
-  return vget_lane_s64(vadd_s64(vget_low_s64(a.val), vget_high_s64(a.val)), 0);
-#endif // #if CV_NEON_AARCH64
-}
-#if CV_SIMD128_64F
-inline double v_reduce_sum(const v_float64x2 &a) { return vaddvq_f64(a.val); }
-#endif
-
-inline v_float32x4 v_reduce_sum4(const v_float32x4 &a, const v_float32x4 &b,
-                                 const v_float32x4 &c, const v_float32x4 &d) {
-#if CV_NEON_AARCH64
-  float32x4_t ab = vpaddq_f32(a.val, b.val); // a0+a1 a2+a3 b0+b1 b2+b3
-  float32x4_t cd = vpaddq_f32(c.val, d.val); // c0+c1 d0+d1 c2+c3 d2+d3
-  return v_float32x4(vpaddq_f32(ab, cd));    // sumA sumB sumC sumD
-#else                                        // #if CV_NEON_AARCH64
-  float32x4x2_t ab = vtrnq_f32(a.val, b.val);
-  float32x4x2_t cd = vtrnq_f32(c.val, d.val);
-
-  float32x4_t u0 = vaddq_f32(ab.val[0], ab.val[1]); // a0+a1 b0+b1 a2+a3 b2+b3
-  float32x4_t u1 = vaddq_f32(cd.val[0], cd.val[1]); // c0+c1 d0+d1 c2+c3 d2+d3
-
-  float32x4_t v0 = vcombine_f32(vget_low_f32(u0), vget_low_f32(u1));
-  float32x4_t v1 = vcombine_f32(vget_high_f32(u0), vget_high_f32(u1));
-
-  return v_float32x4(vaddq_f32(v0, v1));
-#endif                                       // #if CV_NEON_AARCH64
-}
-
-inline unsigned v_reduce_sad(const v_uint8x16 &a, const v_uint8x16 &b) {
-#if CV_NEON_AARCH64
-  uint8x16_t t0 = vabdq_u8(a.val, b.val);
-  uint16_t t1 = vaddlvq_u8(t0);
-  return t1;
-#else  // #if CV_NEON_AARCH64
-  uint32x4_t t0 = vpaddlq_u16(vpaddlq_u8(vabdq_u8(a.val, b.val)));
-  uint32x2_t t1 = vpadd_u32(vget_low_u32(t0), vget_high_u32(t0));
-  return vget_lane_u32(vpadd_u32(t1, t1), 0);
-#endif // #if CV_NEON_AARCH64
-}
-inline unsigned v_reduce_sad(const v_int8x16 &a, const v_int8x16 &b) {
-#if CV_NEON_AARCH64
-  uint8x16_t t0 = vreinterpretq_u8_s8(vabdq_s8(a.val, b.val));
-  uint16_t t1 = vaddlvq_u8(t0);
-  return t1;
-#else  // #if CV_NEON_AARCH64
-  uint32x4_t t0 =
-      vpaddlq_u16(vpaddlq_u8(vreinterpretq_u8_s8(vabdq_s8(a.val, b.val))));
-  uint32x2_t t1 = vpadd_u32(vget_low_u32(t0), vget_high_u32(t0));
-  return vget_lane_u32(vpadd_u32(t1, t1), 0);
-#endif // #if CV_NEON_AARCH64
-}
-inline unsigned v_reduce_sad(const v_uint16x8 &a, const v_uint16x8 &b) {
-#if CV_NEON_AARCH64
-  uint16x8_t t0 = vabdq_u16(a.val, b.val);
-  uint32_t t1 = vaddlvq_u16(t0);
-  return t1;
-#else  // #if CV_NEON_AARCH64
-  uint32x4_t t0 = vpaddlq_u16(vabdq_u16(a.val, b.val));
-  uint32x2_t t1 = vpadd_u32(vget_low_u32(t0), vget_high_u32(t0));
-  return vget_lane_u32(vpadd_u32(t1, t1), 0);
-#endif // #if CV_NEON_AARCH64
-}
-inline unsigned v_reduce_sad(const v_int16x8 &a, const v_int16x8 &b) {
-#if CV_NEON_AARCH64
-  uint16x8_t t0 = vreinterpretq_u16_s16(vabdq_s16(a.val, b.val));
-  uint32_t t1 = vaddlvq_u16(t0);
-  return t1;
-#else  // #if CV_NEON_AARCH64
-  uint32x4_t t0 = vpaddlq_u16(vreinterpretq_u16_s16(vabdq_s16(a.val, b.val)));
-  uint32x2_t t1 = vpadd_u32(vget_low_u32(t0), vget_high_u32(t0));
-  return vget_lane_u32(vpadd_u32(t1, t1), 0);
-#endif // #if CV_NEON_AARCH64
-}
-inline unsigned v_reduce_sad(const v_uint32x4 &a, const v_uint32x4 &b) {
-#if CV_NEON_AARCH64
-  uint32x4_t t0 = vabdq_u32(a.val, b.val);
-  uint32_t t1 = vaddvq_u32(t0);
-  return t1;
-#else  // #if CV_NEON_AARCH64
-  uint32x4_t t0 = vabdq_u32(a.val, b.val);
-  uint32x2_t t1 = vpadd_u32(vget_low_u32(t0), vget_high_u32(t0));
-  return vget_lane_u32(vpadd_u32(t1, t1), 0);
-#endif // #if CV_NEON_AARCH64
-}
-inline unsigned v_reduce_sad(const v_int32x4 &a, const v_int32x4 &b) {
-#if CV_NEON_AARCH64
-  uint32x4_t t0 = vreinterpretq_u32_s32(vabdq_s32(a.val, b.val));
-  uint32_t t1 = vaddvq_u32(t0);
-  return t1;
-#else  // #if CV_NEON_AARCH64
-  uint32x4_t t0 = vreinterpretq_u32_s32(vabdq_s32(a.val, b.val));
-  uint32x2_t t1 = vpadd_u32(vget_low_u32(t0), vget_high_u32(t0));
-  return vget_lane_u32(vpadd_u32(t1, t1), 0);
-#endif // #if CV_NEON_AARCH64
-}
-inline float v_reduce_sad(const v_float32x4 &a, const v_float32x4 &b) {
-#if CV_NEON_AARCH64
-  float32x4_t t0 = vabdq_f32(a.val, b.val);
-  return vaddvq_f32(t0);
-#else  // #if CV_NEON_AARCH64
-  float32x4_t t0 = vabdq_f32(a.val, b.val);
-  float32x2_t t1 = vpadd_f32(vget_low_f32(t0), vget_high_f32(t0));
-  return vget_lane_f32(vpadd_f32(t1, t1), 0);
-#endif // #if CV_NEON_AARCH64
-}
-
-inline v_uint8x16 v_popcount(const v_uint8x16 &a) {
-  return v_uint8x16(vcntq_u8(a.val));
-}
-inline v_uint8x16 v_popcount(const v_int8x16 &a) {
-  return v_uint8x16(vcntq_u8(vreinterpretq_u8_s8(a.val)));
-}
-inline v_uint16x8 v_popcount(const v_uint16x8 &a) {
-  return v_uint16x8(vpaddlq_u8(vcntq_u8(vreinterpretq_u8_u16(a.val))));
-}
-inline v_uint16x8 v_popcount(const v_int16x8 &a) {
-  return v_uint16x8(vpaddlq_u8(vcntq_u8(vreinterpretq_u8_s16(a.val))));
-}
-inline v_uint32x4 v_popcount(const v_uint32x4 &a) {
-  return v_uint32x4(
-      vpaddlq_u16(vpaddlq_u8(vcntq_u8(vreinterpretq_u8_u32(a.val)))));
-}
-inline v_uint32x4 v_popcount(const v_int32x4 &a) {
-  return v_uint32x4(
-      vpaddlq_u16(vpaddlq_u8(vcntq_u8(vreinterpretq_u8_s32(a.val)))));
-}
-inline v_uint64x2 v_popcount(const v_uint64x2 &a) {
-  return v_uint64x2(vpaddlq_u32(
-      vpaddlq_u16(vpaddlq_u8(vcntq_u8(vreinterpretq_u8_u64(a.val))))));
-}
-inline v_uint64x2 v_popcount(const v_int64x2 &a) {
-  return v_uint64x2(vpaddlq_u32(
-      vpaddlq_u16(vpaddlq_u8(vcntq_u8(vreinterpretq_u8_s64(a.val))))));
-}
-
-inline int v_signmask(const v_uint8x16 &a) {
-#if CV_NEON_AARCH64
-  const int8x16_t signPosition = {0, 1, 2, 3, 4, 5, 6, 7,
-                                  0, 1, 2, 3, 4, 5, 6, 7};
-  const uint8x16_t byteOrder = {0, 8,  1, 9,  2, 10, 3, 11,
-                                4, 12, 5, 13, 6, 14, 7, 15};
-  uint8x16_t v0 = vshlq_u8(vshrq_n_u8(a.val, 7), signPosition);
-  uint8x16_t v1 = vqtbl1q_u8(v0, byteOrder);
-  uint32_t t0 = vaddlvq_u16(vreinterpretq_u16_u8(v1));
-  return t0;
-#else  // #if CV_NEON_AARCH64
-  int8x8_t m0 = vcreate_s8(CV_BIG_UINT(0x0706050403020100));
-  uint8x16_t v0 = vshlq_u8(vshrq_n_u8(a.val, 7), vcombine_s8(m0, m0));
-  uint64x2_t v1 = vpaddlq_u32(vpaddlq_u16(vpaddlq_u8(v0)));
-  return (int)vgetq_lane_u64(v1, 0) + ((int)vgetq_lane_u64(v1, 1) << 8);
-#endif // #if CV_NEON_AARCH64
-}
-
-inline int v_signmask(const v_int8x16 &a) {
-  return v_signmask(v_reinterpret_as_u8(a));
-}
-
-inline int v_signmask(const v_uint16x8 &a) {
-#if CV_NEON_AARCH64
-  const int16x8_t signPosition = {0, 1, 2, 3, 4, 5, 6, 7};
-  uint16x8_t v0 = vshlq_u16(vshrq_n_u16(a.val, 15), signPosition);
-  uint32_t t0 = vaddlvq_u16(v0);
-  return t0;
-#else  // #if CV_NEON_AARCH64
-  int16x4_t m0 = vcreate_s16(CV_BIG_UINT(0x0003000200010000));
-  uint16x8_t v0 = vshlq_u16(vshrq_n_u16(a.val, 15), vcombine_s16(m0, m0));
-  uint64x2_t v1 = vpaddlq_u32(vpaddlq_u16(v0));
-  return (int)vgetq_lane_u64(v1, 0) + ((int)vgetq_lane_u64(v1, 1) << 4);
-#endif // #if CV_NEON_AARCH64
-}
-inline int v_signmask(const v_int16x8 &a) {
-  return v_signmask(v_reinterpret_as_u16(a));
-}
-
-inline int v_signmask(const v_uint32x4 &a) {
-#if CV_NEON_AARCH64
-  const int32x4_t signPosition = {0, 1, 2, 3};
-  uint32x4_t v0 = vshlq_u32(vshrq_n_u32(a.val, 31), signPosition);
-  uint32_t t0 = vaddvq_u32(v0);
-  return t0;
-#else  // #if CV_NEON_AARCH64
-  int32x2_t m0 = vcreate_s32(CV_BIG_UINT(0x0000000100000000));
-  uint32x4_t v0 = vshlq_u32(vshrq_n_u32(a.val, 31), vcombine_s32(m0, m0));
-  uint64x2_t v1 = vpaddlq_u32(v0);
-  return (int)vgetq_lane_u64(v1, 0) + ((int)vgetq_lane_u64(v1, 1) << 2);
-#endif // #if CV_NEON_AARCH64
-}
-inline int v_signmask(const v_int32x4 &a) {
-  return v_signmask(v_reinterpret_as_u32(a));
-}
-inline int v_signmask(const v_float32x4 &a) {
-  return v_signmask(v_reinterpret_as_u32(a));
-}
-inline int v_signmask(const v_uint64x2 &a) {
-#if CV_NEON_AARCH64
-  const int64x2_t signPosition = {0, 1};
-  uint64x2_t v0 = vshlq_u64(vshrq_n_u64(a.val, 63), signPosition);
-  int t0 = (int)vaddvq_u64(v0);
-  return t0;
-#else  // #if CV_NEON_AARCH64
-  int64x1_t m0 = vdup_n_s64(0);
-  uint64x2_t v0 = vshlq_u64(vshrq_n_u64(a.val, 63), vcombine_s64(m0, m0));
-  return (int)vgetq_lane_u64(v0, 0) + ((int)vgetq_lane_u64(v0, 1) << 1);
-#endif // #if CV_NEON_AARCH64
-}
-inline int v_signmask(const v_int64x2 &a) {
-  return v_signmask(v_reinterpret_as_u64(a));
-}
-#if CV_SIMD128_64F
-inline int v_signmask(const v_float64x2 &a) {
-  return v_signmask(v_reinterpret_as_u64(a));
-}
-#endif
-
-inline int v_scan_forward(const v_int8x16 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_uint8x16 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_int16x8 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_uint16x8 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_int32x4 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_uint32x4 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_float32x4 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_int64x2 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_uint64x2 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-#if CV_SIMD128_64F
-inline int v_scan_forward(const v_float64x2 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-#endif
-
-#if CV_NEON_AARCH64
-#define OPENCV_HAL_IMPL_NEON_CHECK_ALLANY(_Tpvec, suffix, shift)               \
-  inline bool v_check_all(const v_##_Tpvec &a) {                               \
-    return (vminvq_##suffix(a.val) >> shift) != 0;                             \
-  }                                                                            \
-  inline bool v_check_any(const v_##_Tpvec &a) {                               \
-    return (vmaxvq_##suffix(a.val) >> shift) != 0;                             \
-  }
-#else // #if CV_NEON_AARCH64
-#define OPENCV_HAL_IMPL_NEON_CHECK_ALLANY(_Tpvec, suffix, shift)               \
-  inline bool v_check_all(const v_##_Tpvec &a) {                               \
-    _Tpvec##_t v0 = vshrq_n_##suffix(vmvnq_##suffix(a.val), shift);            \
-    uint64x2_t v1 = vreinterpretq_u64_##suffix(v0);                            \
-    return (vgetq_lane_u64(v1, 0) | vgetq_lane_u64(v1, 1)) == 0;               \
-  }                                                                            \
-  inline bool v_check_any(const v_##_Tpvec &a) {                               \
-    _Tpvec##_t v0 = vshrq_n_##suffix(a.val, shift);                            \
-    uint64x2_t v1 = vreinterpretq_u64_##suffix(v0);                            \
-    return (vgetq_lane_u64(v1, 0) | vgetq_lane_u64(v1, 1)) != 0;               \
-  }
-#endif // #if CV_NEON_AARCH64
-
-OPENCV_HAL_IMPL_NEON_CHECK_ALLANY(uint8x16, u8, 7)
-OPENCV_HAL_IMPL_NEON_CHECK_ALLANY(uint16x8, u16, 15)
-OPENCV_HAL_IMPL_NEON_CHECK_ALLANY(uint32x4, u32, 31)
-
-inline bool v_check_all(const v_uint64x2 &a) {
-  uint64x2_t v0 = vshrq_n_u64(a.val, 63);
-  return (vgetq_lane_u64(v0, 0) & vgetq_lane_u64(v0, 1)) == 1;
-}
-inline bool v_check_any(const v_uint64x2 &a) {
-  uint64x2_t v0 = vshrq_n_u64(a.val, 63);
-  return (vgetq_lane_u64(v0, 0) | vgetq_lane_u64(v0, 1)) != 0;
-}
-
-inline bool v_check_all(const v_int8x16 &a) {
-  return v_check_all(v_reinterpret_as_u8(a));
-}
-inline bool v_check_all(const v_int16x8 &a) {
-  return v_check_all(v_reinterpret_as_u16(a));
-}
-inline bool v_check_all(const v_int32x4 &a) {
-  return v_check_all(v_reinterpret_as_u32(a));
-}
-inline bool v_check_all(const v_float32x4 &a) {
-  return v_check_all(v_reinterpret_as_u32(a));
-}
-
-inline bool v_check_any(const v_int8x16 &a) {
-  return v_check_any(v_reinterpret_as_u8(a));
-}
-inline bool v_check_any(const v_int16x8 &a) {
-  return v_check_any(v_reinterpret_as_u16(a));
-}
-inline bool v_check_any(const v_int32x4 &a) {
-  return v_check_any(v_reinterpret_as_u32(a));
-}
-inline bool v_check_any(const v_float32x4 &a) {
-  return v_check_any(v_reinterpret_as_u32(a));
-}
-
-inline bool v_check_all(const v_int64x2 &a) {
-  return v_check_all(v_reinterpret_as_u64(a));
-}
-inline bool v_check_any(const v_int64x2 &a) {
-  return v_check_any(v_reinterpret_as_u64(a));
-}
-#if CV_SIMD128_64F
-inline bool v_check_all(const v_float64x2 &a) {
-  return v_check_all(v_reinterpret_as_u64(a));
-}
-inline bool v_check_any(const v_float64x2 &a) {
-  return v_check_any(v_reinterpret_as_u64(a));
-}
-#endif
-
-#define OPENCV_HAL_IMPL_NEON_SELECT(_Tpvec, suffix, usuffix)                   \
-  inline _Tpvec v_select(const _Tpvec &mask, const _Tpvec &a,                  \
-                         const _Tpvec &b) {                                    \
-    return _Tpvec(vbslq_##suffix(vreinterpretq_##usuffix##_##suffix(mask.val), \
-                                 a.val, b.val));                               \
-  }
-
-OPENCV_HAL_IMPL_NEON_SELECT(v_uint8x16, u8, u8)
-OPENCV_HAL_IMPL_NEON_SELECT(v_int8x16, s8, u8)
-OPENCV_HAL_IMPL_NEON_SELECT(v_uint16x8, u16, u16)
-OPENCV_HAL_IMPL_NEON_SELECT(v_int16x8, s16, u16)
-OPENCV_HAL_IMPL_NEON_SELECT(v_uint32x4, u32, u32)
-OPENCV_HAL_IMPL_NEON_SELECT(v_int32x4, s32, u32)
-OPENCV_HAL_IMPL_NEON_SELECT(v_float32x4, f32, u32)
-#if CV_SIMD128_64F
-OPENCV_HAL_IMPL_NEON_SELECT(v_float64x2, f64, u64)
-#endif
-
-#if CV_NEON_AARCH64
-#define OPENCV_HAL_IMPL_NEON_EXPAND(_Tpvec, _Tpwvec, _Tp, suffix)              \
-  inline void v_expand(const _Tpvec &a, _Tpwvec &b0, _Tpwvec &b1) {            \
-    b0.val = vmovl_##suffix(vget_low_##suffix(a.val));                         \
-    b1.val = vmovl_high_##suffix(a.val);                                       \
-  }                                                                            \
-  inline _Tpwvec v_expand_low(const _Tpvec &a) {                               \
-    return _Tpwvec(vmovl_##suffix(vget_low_##suffix(a.val)));                  \
-  }                                                                            \
-  inline _Tpwvec v_expand_high(const _Tpvec &a) {                              \
-    return _Tpwvec(vmovl_high_##suffix(a.val));                                \
-  }                                                                            \
-  inline _Tpwvec v_load_expand(const _Tp *ptr) {                               \
-    return _Tpwvec(vmovl_##suffix(vld1_##suffix(ptr)));                        \
-  }
-#else
-#define OPENCV_HAL_IMPL_NEON_EXPAND(_Tpvec, _Tpwvec, _Tp, suffix)              \
-  inline void v_expand(const _Tpvec &a, _Tpwvec &b0, _Tpwvec &b1) {            \
-    b0.val = vmovl_##suffix(vget_low_##suffix(a.val));                         \
-    b1.val = vmovl_##suffix(vget_high_##suffix(a.val));                        \
-  }                                                                            \
-  inline _Tpwvec v_expand_low(const _Tpvec &a) {                               \
-    return _Tpwvec(vmovl_##suffix(vget_low_##suffix(a.val)));                  \
-  }                                                                            \
-  inline _Tpwvec v_expand_high(const _Tpvec &a) {                              \
-    return _Tpwvec(vmovl_##suffix(vget_high_##suffix(a.val)));                 \
-  }                                                                            \
-  inline _Tpwvec v_load_expand(const _Tp *ptr) {                               \
-    return _Tpwvec(vmovl_##suffix(vld1_##suffix(ptr)));                        \
-  }
-#endif
-
-OPENCV_HAL_IMPL_NEON_EXPAND(v_uint8x16, v_uint16x8, uchar, u8)
-OPENCV_HAL_IMPL_NEON_EXPAND(v_int8x16, v_int16x8, schar, s8)
-OPENCV_HAL_IMPL_NEON_EXPAND(v_uint16x8, v_uint32x4, ushort, u16)
-OPENCV_HAL_IMPL_NEON_EXPAND(v_int16x8, v_int32x4, short, s16)
-OPENCV_HAL_IMPL_NEON_EXPAND(v_uint32x4, v_uint64x2, uint, u32)
-OPENCV_HAL_IMPL_NEON_EXPAND(v_int32x4, v_int64x2, int, s32)
-
-inline v_uint32x4 v_load_expand_q(const uchar *ptr) {
-  typedef unsigned int CV_DECL_ALIGNED(1) unaligned_uint;
-  uint8x8_t v0 = vcreate_u8(*(unaligned_uint *)ptr);
-  uint16x4_t v1 = vget_low_u16(vmovl_u8(v0));
-  return v_uint32x4(vmovl_u16(v1));
-}
-
-inline v_int32x4 v_load_expand_q(const schar *ptr) {
-  typedef unsigned int CV_DECL_ALIGNED(1) unaligned_uint;
-  int8x8_t v0 = vcreate_s8(*(unaligned_uint *)ptr);
-  int16x4_t v1 = vget_low_s16(vmovl_s8(v0));
-  return v_int32x4(vmovl_s16(v1));
-}
-
-#if defined(__aarch64__) || defined(_M_ARM64)
-#define OPENCV_HAL_IMPL_NEON_UNPACKS(_Tpvec, suffix)                           \
-  inline void v_zip(const v_##_Tpvec &a0, const v_##_Tpvec &a1,                \
-                    v_##_Tpvec &b0, v_##_Tpvec &b1) {                          \
-    b0.val = vzip1q_##suffix(a0.val, a1.val);                                  \
-    b1.val = vzip2q_##suffix(a0.val, a1.val);                                  \
-  }                                                                            \
-  inline v_##_Tpvec v_combine_low(const v_##_Tpvec &a, const v_##_Tpvec &b) {  \
-    return v_##_Tpvec(vcombine_##suffix(vget_low_##suffix(a.val),              \
-                                        vget_low_##suffix(b.val)));            \
-  }                                                                            \
-  inline v_##_Tpvec v_combine_high(const v_##_Tpvec &a, const v_##_Tpvec &b) { \
-    return v_##_Tpvec(vcombine_##suffix(vget_high_##suffix(a.val),             \
-                                        vget_high_##suffix(b.val)));           \
-  }                                                                            \
-  inline void v_recombine(const v_##_Tpvec &a, const v_##_Tpvec &b,            \
-                          v_##_Tpvec &c, v_##_Tpvec &d) {                      \
-    c.val =                                                                    \
-        vcombine_##suffix(vget_low_##suffix(a.val), vget_low_##suffix(b.val)); \
-    d.val = vcombine_##suffix(vget_high_##suffix(a.val),                       \
-                              vget_high_##suffix(b.val));                      \
-  }
-#else
-#define OPENCV_HAL_IMPL_NEON_UNPACKS(_Tpvec, suffix)                           \
-  inline void v_zip(const v_##_Tpvec &a0, const v_##_Tpvec &a1,                \
-                    v_##_Tpvec &b0, v_##_Tpvec &b1) {                          \
-    _Tpvec##x2_t p = vzipq_##suffix(a0.val, a1.val);                           \
-    b0.val = p.val[0];                                                         \
-    b1.val = p.val[1];                                                         \
-  }                                                                            \
-  inline v_##_Tpvec v_combine_low(const v_##_Tpvec &a, const v_##_Tpvec &b) {  \
-    return v_##_Tpvec(vcombine_##suffix(vget_low_##suffix(a.val),              \
-                                        vget_low_##suffix(b.val)));            \
-  }                                                                            \
-  inline v_##_Tpvec v_combine_high(const v_##_Tpvec &a, const v_##_Tpvec &b) { \
-    return v_##_Tpvec(vcombine_##suffix(vget_high_##suffix(a.val),             \
-                                        vget_high_##suffix(b.val)));           \
-  }                                                                            \
-  inline void v_recombine(const v_##_Tpvec &a, const v_##_Tpvec &b,            \
-                          v_##_Tpvec &c, v_##_Tpvec &d) {                      \
-    c.val =                                                                    \
-        vcombine_##suffix(vget_low_##suffix(a.val), vget_low_##suffix(b.val)); \
-    d.val = vcombine_##suffix(vget_high_##suffix(a.val),                       \
-                              vget_high_##suffix(b.val));                      \
-  }
-#endif
-
-OPENCV_HAL_IMPL_NEON_UNPACKS(uint8x16, u8)
-OPENCV_HAL_IMPL_NEON_UNPACKS(int8x16, s8)
-OPENCV_HAL_IMPL_NEON_UNPACKS(uint16x8, u16)
-OPENCV_HAL_IMPL_NEON_UNPACKS(int16x8, s16)
-OPENCV_HAL_IMPL_NEON_UNPACKS(uint32x4, u32)
-OPENCV_HAL_IMPL_NEON_UNPACKS(int32x4, s32)
-OPENCV_HAL_IMPL_NEON_UNPACKS(float32x4, f32)
-#if CV_SIMD128_64F
-OPENCV_HAL_IMPL_NEON_UNPACKS(float64x2, f64)
-#endif
-
-inline v_uint8x16 v_reverse(const v_uint8x16 &a) {
-  uint8x16_t vec = vrev64q_u8(a.val);
-  return v_uint8x16(vextq_u8(vec, vec, 8));
-}
-
-inline v_int8x16 v_reverse(const v_int8x16 &a) {
-  return v_reinterpret_as_s8(v_reverse(v_reinterpret_as_u8(a)));
-}
-
-inline v_uint16x8 v_reverse(const v_uint16x8 &a) {
-  uint16x8_t vec = vrev64q_u16(a.val);
-  return v_uint16x8(vextq_u16(vec, vec, 4));
-}
-
-inline v_int16x8 v_reverse(const v_int16x8 &a) {
-  return v_reinterpret_as_s16(v_reverse(v_reinterpret_as_u16(a)));
-}
-
-inline v_uint32x4 v_reverse(const v_uint32x4 &a) {
-  uint32x4_t vec = vrev64q_u32(a.val);
-  return v_uint32x4(vextq_u32(vec, vec, 2));
-}
-
-inline v_int32x4 v_reverse(const v_int32x4 &a) {
-  return v_reinterpret_as_s32(v_reverse(v_reinterpret_as_u32(a)));
-}
-
-inline v_float32x4 v_reverse(const v_float32x4 &a) {
-  return v_reinterpret_as_f32(v_reverse(v_reinterpret_as_u32(a)));
-}
-
-inline v_uint64x2 v_reverse(const v_uint64x2 &a) {
-  uint64x2_t vec = a.val;
-  uint64x1_t vec_lo = vget_low_u64(vec);
-  uint64x1_t vec_hi = vget_high_u64(vec);
-  return v_uint64x2(vcombine_u64(vec_hi, vec_lo));
-}
-
-inline v_int64x2 v_reverse(const v_int64x2 &a) {
-  return v_reinterpret_as_s64(v_reverse(v_reinterpret_as_u64(a)));
-}
-
-#if CV_SIMD128_64F
-inline v_float64x2 v_reverse(const v_float64x2 &a) {
-  return v_reinterpret_as_f64(v_reverse(v_reinterpret_as_u64(a)));
-}
-#endif
-
-#define OPENCV_HAL_IMPL_NEON_EXTRACT(_Tpvec, suffix)                           \
-  template <int s>                                                             \
-  inline v_##_Tpvec v_extract(const v_##_Tpvec &a, const v_##_Tpvec &b) {      \
-    return v_##_Tpvec(vextq_##suffix(a.val, b.val, s));                        \
-  }
-
-OPENCV_HAL_IMPL_NEON_EXTRACT(uint8x16, u8)
-OPENCV_HAL_IMPL_NEON_EXTRACT(int8x16, s8)
-OPENCV_HAL_IMPL_NEON_EXTRACT(uint16x8, u16)
-OPENCV_HAL_IMPL_NEON_EXTRACT(int16x8, s16)
-OPENCV_HAL_IMPL_NEON_EXTRACT(uint32x4, u32)
-OPENCV_HAL_IMPL_NEON_EXTRACT(int32x4, s32)
-OPENCV_HAL_IMPL_NEON_EXTRACT(uint64x2, u64)
-OPENCV_HAL_IMPL_NEON_EXTRACT(int64x2, s64)
-OPENCV_HAL_IMPL_NEON_EXTRACT(float32x4, f32)
-#if CV_SIMD128_64F
-OPENCV_HAL_IMPL_NEON_EXTRACT(float64x2, f64)
-#endif
-
-#define OPENCV_HAL_IMPL_NEON_EXTRACT_N(_Tpvec, _Tp, suffix)                    \
-  template <int i> inline _Tp v_extract_n(_Tpvec v) {                          \
-    return vgetq_lane_##suffix(v.val, i);                                      \
-  }
-
-OPENCV_HAL_IMPL_NEON_EXTRACT_N(v_uint8x16, uchar, u8)
-OPENCV_HAL_IMPL_NEON_EXTRACT_N(v_int8x16, schar, s8)
-OPENCV_HAL_IMPL_NEON_EXTRACT_N(v_uint16x8, ushort, u16)
-OPENCV_HAL_IMPL_NEON_EXTRACT_N(v_int16x8, short, s16)
-OPENCV_HAL_IMPL_NEON_EXTRACT_N(v_uint32x4, uint, u32)
-OPENCV_HAL_IMPL_NEON_EXTRACT_N(v_int32x4, int, s32)
-OPENCV_HAL_IMPL_NEON_EXTRACT_N(v_uint64x2, uint64, u64)
-OPENCV_HAL_IMPL_NEON_EXTRACT_N(v_int64x2, int64, s64)
-OPENCV_HAL_IMPL_NEON_EXTRACT_N(v_float32x4, float, f32)
-#if CV_SIMD128_64F
-OPENCV_HAL_IMPL_NEON_EXTRACT_N(v_float64x2, double, f64)
-#endif
-
-#define OPENCV_HAL_IMPL_NEON_BROADCAST(_Tpvec, _Tp, suffix)                    \
-  template <int i> inline _Tpvec v_broadcast_element(_Tpvec v) {               \
-    _Tp t = v_extract_n<i>(v);                                                 \
-    return v_setall_##suffix(t);                                               \
-  }
-
-OPENCV_HAL_IMPL_NEON_BROADCAST(v_uint8x16, uchar, u8)
-OPENCV_HAL_IMPL_NEON_BROADCAST(v_int8x16, schar, s8)
-OPENCV_HAL_IMPL_NEON_BROADCAST(v_uint16x8, ushort, u16)
-OPENCV_HAL_IMPL_NEON_BROADCAST(v_int16x8, short, s16)
-OPENCV_HAL_IMPL_NEON_BROADCAST(v_uint32x4, uint, u32)
-OPENCV_HAL_IMPL_NEON_BROADCAST(v_int32x4, int, s32)
-OPENCV_HAL_IMPL_NEON_BROADCAST(v_uint64x2, uint64, u64)
-OPENCV_HAL_IMPL_NEON_BROADCAST(v_int64x2, int64, s64)
-OPENCV_HAL_IMPL_NEON_BROADCAST(v_float32x4, float, f32)
-#if CV_SIMD128_64F
-OPENCV_HAL_IMPL_NEON_BROADCAST(v_float64x2, double, f64)
-#endif
-
-#if CV_SIMD128_64F
-inline v_int32x4 v_round(const v_float32x4 &a) {
-  float32x4_t a_ = a.val;
-  int32x4_t result;
-#if defined _MSC_VER
-  result = vcvtnq_s32_f32(a_);
-#else
-  __asm__("fcvtns %0.4s, %1.4s" : "=w"(result) : "w"(a_) : /* No clobbers */);
-#endif
-  return v_int32x4(result);
-}
-#else
-inline v_int32x4 v_round(const v_float32x4 &a) {
-  // See https://github.com/opencv/opencv/pull/24271#issuecomment-1867318007
-  float32x4_t delta = vdupq_n_f32(12582912.0f);
-  return v_int32x4(vcvtq_s32_f32(vsubq_f32(vaddq_f32(a.val, delta), delta)));
-}
-#endif
-inline v_int32x4 v_floor(const v_float32x4 &a) {
-  int32x4_t a1 = vcvtq_s32_f32(a.val);
-  uint32x4_t mask = vcgtq_f32(vcvtq_f32_s32(a1), a.val);
-  return v_int32x4(vaddq_s32(a1, vreinterpretq_s32_u32(mask)));
-}
-
-inline v_int32x4 v_ceil(const v_float32x4 &a) {
-  int32x4_t a1 = vcvtq_s32_f32(a.val);
-  uint32x4_t mask = vcgtq_f32(a.val, vcvtq_f32_s32(a1));
-  return v_int32x4(vsubq_s32(a1, vreinterpretq_s32_u32(mask)));
-}
-
-inline v_int32x4 v_trunc(const v_float32x4 &a) {
-  return v_int32x4(vcvtq_s32_f32(a.val));
-}
-
-#if CV_SIMD128_64F
-inline v_int32x4 v_round(const v_float64x2 &a) {
-  static const int32x2_t zero = vdup_n_s32(0);
-  return v_int32x4(vcombine_s32(vmovn_s64(vcvtnq_s64_f64(a.val)), zero));
-}
-
-inline v_int32x4 v_round(const v_float64x2 &a, const v_float64x2 &b) {
-  return v_int32x4(vcombine_s32(vmovn_s64(vcvtnq_s64_f64(a.val)),
-                                vmovn_s64(vcvtnq_s64_f64(b.val))));
-}
-
-inline v_int32x4 v_floor(const v_float64x2 &a) {
-  static const int32x2_t zero = vdup_n_s32(0);
-  int64x2_t a1 = vcvtq_s64_f64(a.val);
-  uint64x2_t mask = vcgtq_f64(vcvtq_f64_s64(a1), a.val);
-  a1 = vaddq_s64(a1, vreinterpretq_s64_u64(mask));
-  return v_int32x4(vcombine_s32(vmovn_s64(a1), zero));
-}
-
-inline v_int32x4 v_ceil(const v_float64x2 &a) {
-  static const int32x2_t zero = vdup_n_s32(0);
-  int64x2_t a1 = vcvtq_s64_f64(a.val);
-  uint64x2_t mask = vcgtq_f64(a.val, vcvtq_f64_s64(a1));
-  a1 = vsubq_s64(a1, vreinterpretq_s64_u64(mask));
-  return v_int32x4(vcombine_s32(vmovn_s64(a1), zero));
-}
-
-inline v_int32x4 v_trunc(const v_float64x2 &a) {
-  static const int32x2_t zero = vdup_n_s32(0);
-  return v_int32x4(vcombine_s32(vmovn_s64(vcvtaq_s64_f64(a.val)), zero));
-}
-#endif
-
-#if CV_NEON_AARCH64
-#define OPENCV_HAL_IMPL_NEON_TRANSPOSE4x4(_Tpvec, suffix)                      \
-  inline void v_transpose4x4(const v_##_Tpvec &a0, const v_##_Tpvec &a1,       \
-                             const v_##_Tpvec &a2, const v_##_Tpvec &a3,       \
-                             v_##_Tpvec &b0, v_##_Tpvec &b1, v_##_Tpvec &b2,   \
-                             v_##_Tpvec &b3) {                                 \
-    /* -- Pass 1: 64b transpose */                                             \
-    _Tpvec##_t t0 = vreinterpretq_##suffix##32_##suffix##64(                   \
-        vtrn1q_##suffix##64(vreinterpretq_##suffix##64_##suffix##32(a0.val),   \
-                            vreinterpretq_##suffix##64_##suffix##32(a2.val))); \
-    _Tpvec##_t t1 = vreinterpretq_##suffix##32_##suffix##64(                   \
-        vtrn1q_##suffix##64(vreinterpretq_##suffix##64_##suffix##32(a1.val),   \
-                            vreinterpretq_##suffix##64_##suffix##32(a3.val))); \
-    _Tpvec##_t t2 = vreinterpretq_##suffix##32_##suffix##64(                   \
-        vtrn2q_##suffix##64(vreinterpretq_##suffix##64_##suffix##32(a0.val),   \
-                            vreinterpretq_##suffix##64_##suffix##32(a2.val))); \
-    _Tpvec##_t t3 = vreinterpretq_##suffix##32_##suffix##64(                   \
-        vtrn2q_##suffix##64(vreinterpretq_##suffix##64_##suffix##32(a1.val),   \
-                            vreinterpretq_##suffix##64_##suffix##32(a3.val))); \
-    /* -- Pass 2: 32b transpose */                                             \
-    b0.val = vtrn1q_##suffix##32(t0, t1);                                      \
-    b1.val = vtrn2q_##suffix##32(t0, t1);                                      \
-    b2.val = vtrn1q_##suffix##32(t2, t3);                                      \
-    b3.val = vtrn2q_##suffix##32(t2, t3);                                      \
-  }
-
-OPENCV_HAL_IMPL_NEON_TRANSPOSE4x4(uint32x4,
-                                  u) OPENCV_HAL_IMPL_NEON_TRANSPOSE4x4(int32x4,
-                                                                       s)
-    OPENCV_HAL_IMPL_NEON_TRANSPOSE4x4(float32x4, f)
-#else // #if CV_NEON_AARCH64
-#define OPENCV_HAL_IMPL_NEON_TRANSPOSE4x4(_Tpvec, suffix)                      \
-  inline void v_transpose4x4(const v_##_Tpvec &a0, const v_##_Tpvec &a1,       \
-                             const v_##_Tpvec &a2, const v_##_Tpvec &a3,       \
-                             v_##_Tpvec &b0, v_##_Tpvec &b1, v_##_Tpvec &b2,   \
-                             v_##_Tpvec &b3) {                                 \
-    /* m00 m01 m02 m03 */                                                      \
-    /* m10 m11 m12 m13 */                                                      \
-    /* m20 m21 m22 m23 */                                                      \
-    /* m30 m31 m32 m33 */                                                      \
-    _Tpvec##x2_t t0 = vtrnq_##suffix(a0.val, a1.val);                          \
-    _Tpvec##x2_t t1 = vtrnq_##suffix(a2.val, a3.val);                          \
-    /* m00 m10 m02 m12 */                                                      \
-    /* m01 m11 m03 m13 */                                                      \
-    /* m20 m30 m22 m32 */                                                      \
-    /* m21 m31 m23 m33 */                                                      \
-    b0.val = vcombine_##suffix(vget_low_##suffix(t0.val[0]),                   \
-                               vget_low_##suffix(t1.val[0]));                  \
-    b1.val = vcombine_##suffix(vget_low_##suffix(t0.val[1]),                   \
-                               vget_low_##suffix(t1.val[1]));                  \
-    b2.val = vcombine_##suffix(vget_high_##suffix(t0.val[0]),                  \
-                               vget_high_##suffix(t1.val[0]));                 \
-    b3.val = vcombine_##suffix(vget_high_##suffix(t0.val[1]),                  \
-                               vget_high_##suffix(t1.val[1]));                 \
-  }
-
-OPENCV_HAL_IMPL_NEON_TRANSPOSE4x4(
-    uint32x4, u32) OPENCV_HAL_IMPL_NEON_TRANSPOSE4x4(int32x4, s32)
-    OPENCV_HAL_IMPL_NEON_TRANSPOSE4x4(float32x4, f32)
-#endif // #if CV_NEON_AARCH64
-
-#define OPENCV_HAL_IMPL_NEON_INTERLEAVED(_Tpvec, _Tp, suffix)                  \
-  inline void v_load_deinterleave(const _Tp *ptr, v_##_Tpvec &a,               \
-                                  v_##_Tpvec &b) {                             \
-    _Tpvec##x2_t v = vld2q_##suffix(ptr);                                      \
-    a.val = v.val[0];                                                          \
-    b.val = v.val[1];                                                          \
-  }                                                                            \
-  inline void v_load_deinterleave(const _Tp *ptr, v_##_Tpvec &a,               \
-                                  v_##_Tpvec &b, v_##_Tpvec &c) {              \
-    _Tpvec##x3_t v = vld3q_##suffix(ptr);                                      \
-    a.val = v.val[0];                                                          \
-    b.val = v.val[1];                                                          \
-    c.val = v.val[2];                                                          \
-  }                                                                            \
-  inline void v_load_deinterleave(const _Tp *ptr, v_##_Tpvec &a,               \
-                                  v_##_Tpvec &b, v_##_Tpvec &c,                \
-                                  v_##_Tpvec &d) {                             \
-    _Tpvec##x4_t v = vld4q_##suffix(ptr);                                      \
-    a.val = v.val[0];                                                          \
-    b.val = v.val[1];                                                          \
-    c.val = v.val[2];                                                          \
-    d.val = v.val[3];                                                          \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp *ptr, const v_##_Tpvec &a, const v_##_Tpvec &b,                      \
-      hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {                        \
-    _Tpvec##x2_t v;                                                            \
-    v.val[0] = a.val;                                                          \
-    v.val[1] = b.val;                                                          \
-    vst2q_##suffix(ptr, v);                                                    \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp *ptr, const v_##_Tpvec &a, const v_##_Tpvec &b, const v_##_Tpvec &c, \
-      hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {                        \
-    _Tpvec##x3_t v;                                                            \
-    v.val[0] = a.val;                                                          \
-    v.val[1] = b.val;                                                          \
-    v.val[2] = c.val;                                                          \
-    vst3q_##suffix(ptr, v);                                                    \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp *ptr, const v_##_Tpvec &a, const v_##_Tpvec &b, const v_##_Tpvec &c, \
-      const v_##_Tpvec &d, hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {   \
-    _Tpvec##x4_t v;                                                            \
-    v.val[0] = a.val;                                                          \
-    v.val[1] = b.val;                                                          \
-    v.val[2] = c.val;                                                          \
-    v.val[3] = d.val;                                                          \
-    vst4q_##suffix(ptr, v);                                                    \
-  }
-
-#define OPENCV_HAL_IMPL_NEON_INTERLEAVED_INT64(tp, suffix)                     \
-  inline void v_load_deinterleave(const tp *ptr, v_##tp##x2 &a,                \
-                                  v_##tp##x2 &b) {                             \
-    tp##x1_t a0 = vld1_##suffix(ptr);                                          \
-    tp##x1_t b0 = vld1_##suffix(ptr + 1);                                      \
-    tp##x1_t a1 = vld1_##suffix(ptr + 2);                                      \
-    tp##x1_t b1 = vld1_##suffix(ptr + 3);                                      \
-    a = v_##tp##x2(vcombine_##suffix(a0, a1));                                 \
-    b = v_##tp##x2(vcombine_##suffix(b0, b1));                                 \
-  }                                                                            \
-                                                                               \
-  inline void v_load_deinterleave(const tp *ptr, v_##tp##x2 &a, v_##tp##x2 &b, \
-                                  v_##tp##x2 &c) {                             \
-    tp##x1_t a0 = vld1_##suffix(ptr);                                          \
-    tp##x1_t b0 = vld1_##suffix(ptr + 1);                                      \
-    tp##x1_t c0 = vld1_##suffix(ptr + 2);                                      \
-    tp##x1_t a1 = vld1_##suffix(ptr + 3);                                      \
-    tp##x1_t b1 = vld1_##suffix(ptr + 4);                                      \
-    tp##x1_t c1 = vld1_##suffix(ptr + 5);                                      \
-    a = v_##tp##x2(vcombine_##suffix(a0, a1));                                 \
-    b = v_##tp##x2(vcombine_##suffix(b0, b1));                                 \
-    c = v_##tp##x2(vcombine_##suffix(c0, c1));                                 \
-  }                                                                            \
-                                                                               \
-  inline void v_load_deinterleave(const tp *ptr, v_##tp##x2 &a, v_##tp##x2 &b, \
-                                  v_##tp##x2 &c, v_##tp##x2 &d) {              \
-    tp##x1_t a0 = vld1_##suffix(ptr);                                          \
-    tp##x1_t b0 = vld1_##suffix(ptr + 1);                                      \
-    tp##x1_t c0 = vld1_##suffix(ptr + 2);                                      \
-    tp##x1_t d0 = vld1_##suffix(ptr + 3);                                      \
-    tp##x1_t a1 = vld1_##suffix(ptr + 4);                                      \
-    tp##x1_t b1 = vld1_##suffix(ptr + 5);                                      \
-    tp##x1_t c1 = vld1_##suffix(ptr + 6);                                      \
-    tp##x1_t d1 = vld1_##suffix(ptr + 7);                                      \
-    a = v_##tp##x2(vcombine_##suffix(a0, a1));                                 \
-    b = v_##tp##x2(vcombine_##suffix(b0, b1));                                 \
-    c = v_##tp##x2(vcombine_##suffix(c0, c1));                                 \
-    d = v_##tp##x2(vcombine_##suffix(d0, d1));                                 \
-  }                                                                            \
-                                                                               \
-  inline void v_store_interleave(                                              \
-      tp *ptr, const v_##tp##x2 &a, const v_##tp##x2 &b,                       \
-      hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {                        \
-    vst1_##suffix(ptr, vget_low_##suffix(a.val));                              \
-    vst1_##suffix(ptr + 1, vget_low_##suffix(b.val));                          \
-    vst1_##suffix(ptr + 2, vget_high_##suffix(a.val));                         \
-    vst1_##suffix(ptr + 3, vget_high_##suffix(b.val));                         \
-  }                                                                            \
-                                                                               \
-  inline void v_store_interleave(                                              \
-      tp *ptr, const v_##tp##x2 &a, const v_##tp##x2 &b, const v_##tp##x2 &c,  \
-      hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {                        \
-    vst1_##suffix(ptr, vget_low_##suffix(a.val));                              \
-    vst1_##suffix(ptr + 1, vget_low_##suffix(b.val));                          \
-    vst1_##suffix(ptr + 2, vget_low_##suffix(c.val));                          \
-    vst1_##suffix(ptr + 3, vget_high_##suffix(a.val));                         \
-    vst1_##suffix(ptr + 4, vget_high_##suffix(b.val));                         \
-    vst1_##suffix(ptr + 5, vget_high_##suffix(c.val));                         \
-  }                                                                            \
-                                                                               \
-  inline void v_store_interleave(                                              \
-      tp *ptr, const v_##tp##x2 &a, const v_##tp##x2 &b, const v_##tp##x2 &c,  \
-      const v_##tp##x2 &d, hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {   \
-    vst1_##suffix(ptr, vget_low_##suffix(a.val));                              \
-    vst1_##suffix(ptr + 1, vget_low_##suffix(b.val));                          \
-    vst1_##suffix(ptr + 2, vget_low_##suffix(c.val));                          \
-    vst1_##suffix(ptr + 3, vget_low_##suffix(d.val));                          \
-    vst1_##suffix(ptr + 4, vget_high_##suffix(a.val));                         \
-    vst1_##suffix(ptr + 5, vget_high_##suffix(b.val));                         \
-    vst1_##suffix(ptr + 6, vget_high_##suffix(c.val));                         \
-    vst1_##suffix(ptr + 7, vget_high_##suffix(d.val));                         \
-  }
-
-        OPENCV_HAL_IMPL_NEON_INTERLEAVED(
-            uint8x16, uchar, u8) OPENCV_HAL_IMPL_NEON_INTERLEAVED(int8x16,
-                                                                  schar, s8)
-            OPENCV_HAL_IMPL_NEON_INTERLEAVED(uint16x8, ushort, u16)
-                OPENCV_HAL_IMPL_NEON_INTERLEAVED(int16x8, short, s16)
-                    OPENCV_HAL_IMPL_NEON_INTERLEAVED(uint32x4, unsigned, u32)
-                        OPENCV_HAL_IMPL_NEON_INTERLEAVED(int32x4, int, s32)
-                            OPENCV_HAL_IMPL_NEON_INTERLEAVED(float32x4, float,
-                                                             f32)
-#if CV_SIMD128_64F
-                                OPENCV_HAL_IMPL_NEON_INTERLEAVED(float64x2,
-                                                                 double, f64)
-#endif
-
-                                    OPENCV_HAL_IMPL_NEON_INTERLEAVED_INT64(
-                                        int64, s64)
-                                        OPENCV_HAL_IMPL_NEON_INTERLEAVED_INT64(
-                                            uint64, u64)
-
-                                            inline v_float32x4
-    v_cvt_f32(const v_int32x4 &a) {
-  return v_float32x4(vcvtq_f32_s32(a.val));
-}
-
-#if CV_SIMD128_64F
-inline v_float32x4 v_cvt_f32(const v_float64x2 &a) {
-  float32x2_t zero = vdup_n_f32(0.0f);
-  return v_float32x4(vcombine_f32(vcvt_f32_f64(a.val), zero));
-}
-
-inline v_float32x4 v_cvt_f32(const v_float64x2 &a, const v_float64x2 &b) {
-  return v_float32x4(vcombine_f32(vcvt_f32_f64(a.val), vcvt_f32_f64(b.val)));
-}
-
-inline v_float64x2 v_cvt_f64(const v_int32x4 &a) {
-  return v_float64x2(vcvt_f64_f32(vcvt_f32_s32(vget_low_s32(a.val))));
-}
-
-inline v_float64x2 v_cvt_f64_high(const v_int32x4 &a) {
-  return v_float64x2(vcvt_f64_f32(vcvt_f32_s32(vget_high_s32(a.val))));
-}
-
-inline v_float64x2 v_cvt_f64(const v_float32x4 &a) {
-  return v_float64x2(vcvt_f64_f32(vget_low_f32(a.val)));
-}
-
-inline v_float64x2 v_cvt_f64_high(const v_float32x4 &a) {
-  return v_float64x2(vcvt_f64_f32(vget_high_f32(a.val)));
-}
-
-inline v_float64x2 v_cvt_f64(const v_int64x2 &a) {
-  return v_float64x2(vcvtq_f64_s64(a.val));
-}
-
-#endif
-
-////////////// Lookup table access ////////////////////
-
-inline v_int8x16 v_lut(const schar *tab, const int *idx) {
-  schar CV_DECL_ALIGNED(32)
-      elems[16] = {tab[idx[0]],  tab[idx[1]],  tab[idx[2]],  tab[idx[3]],
-                   tab[idx[4]],  tab[idx[5]],  tab[idx[6]],  tab[idx[7]],
-                   tab[idx[8]],  tab[idx[9]],  tab[idx[10]], tab[idx[11]],
-                   tab[idx[12]], tab[idx[13]], tab[idx[14]], tab[idx[15]]};
-  return v_int8x16(vld1q_s8(elems));
-}
-inline v_int8x16 v_lut_pairs(const schar *tab, const int *idx) {
-  schar CV_DECL_ALIGNED(32)
-      elems[16] = {tab[idx[0]], tab[idx[0] + 1], tab[idx[1]], tab[idx[1] + 1],
-                   tab[idx[2]], tab[idx[2] + 1], tab[idx[3]], tab[idx[3] + 1],
-                   tab[idx[4]], tab[idx[4] + 1], tab[idx[5]], tab[idx[5] + 1],
-                   tab[idx[6]], tab[idx[6] + 1], tab[idx[7]], tab[idx[7] + 1]};
-  return v_int8x16(vld1q_s8(elems));
-}
-inline v_int8x16 v_lut_quads(const schar *tab, const int *idx) {
-  schar CV_DECL_ALIGNED(32) elems[16] = {
-      tab[idx[0]], tab[idx[0] + 1], tab[idx[0] + 2], tab[idx[0] + 3],
-      tab[idx[1]], tab[idx[1] + 1], tab[idx[1] + 2], tab[idx[1] + 3],
-      tab[idx[2]], tab[idx[2] + 1], tab[idx[2] + 2], tab[idx[2] + 3],
-      tab[idx[3]], tab[idx[3] + 1], tab[idx[3] + 2], tab[idx[3] + 3]};
-  return v_int8x16(vld1q_s8(elems));
-}
-inline v_uint8x16 v_lut(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v_lut((schar *)tab, idx));
-}
-inline v_uint8x16 v_lut_pairs(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v_lut_pairs((schar *)tab, idx));
-}
-inline v_uint8x16 v_lut_quads(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v_lut_quads((schar *)tab, idx));
-}
-
-inline v_int16x8 v_lut(const short *tab, const int *idx) {
-  short CV_DECL_ALIGNED(32)
-      elems[8] = {tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]],
-                  tab[idx[4]], tab[idx[5]], tab[idx[6]], tab[idx[7]]};
-  return v_int16x8(vld1q_s16(elems));
-}
-inline v_int16x8 v_lut_pairs(const short *tab, const int *idx) {
-  short CV_DECL_ALIGNED(32)
-      elems[8] = {tab[idx[0]], tab[idx[0] + 1], tab[idx[1]], tab[idx[1] + 1],
-                  tab[idx[2]], tab[idx[2] + 1], tab[idx[3]], tab[idx[3] + 1]};
-  return v_int16x8(vld1q_s16(elems));
-}
-inline v_int16x8 v_lut_quads(const short *tab, const int *idx) {
-  return v_int16x8(
-      vcombine_s16(vld1_s16(tab + idx[0]), vld1_s16(tab + idx[1])));
-}
-inline v_uint16x8 v_lut(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v_lut((short *)tab, idx));
-}
-inline v_uint16x8 v_lut_pairs(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v_lut_pairs((short *)tab, idx));
-}
-inline v_uint16x8 v_lut_quads(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v_lut_quads((short *)tab, idx));
-}
-
-inline v_int32x4 v_lut(const int *tab, const int *idx) {
-  int CV_DECL_ALIGNED(32)
-      elems[4] = {tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]};
-  return v_int32x4(vld1q_s32(elems));
-}
-inline v_int32x4 v_lut_pairs(const int *tab, const int *idx) {
-  return v_int32x4(
-      vcombine_s32(vld1_s32(tab + idx[0]), vld1_s32(tab + idx[1])));
-}
-inline v_int32x4 v_lut_quads(const int *tab, const int *idx) {
-  return v_int32x4(vld1q_s32(tab + idx[0]));
-}
-inline v_uint32x4 v_lut(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v_lut((int *)tab, idx));
-}
-inline v_uint32x4 v_lut_pairs(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v_lut_pairs((int *)tab, idx));
-}
-inline v_uint32x4 v_lut_quads(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v_lut_quads((int *)tab, idx));
-}
-
-inline v_int64x2 v_lut(const int64_t *tab, const int *idx) {
-  return v_int64x2(
-      vcombine_s64(vcreate_s64(tab[idx[0]]), vcreate_s64(tab[idx[1]])));
-}
-inline v_int64x2 v_lut_pairs(const int64_t *tab, const int *idx) {
-  return v_int64x2(vld1q_s64(tab + idx[0]));
-}
-inline v_uint64x2 v_lut(const uint64_t *tab, const int *idx) {
-  return v_reinterpret_as_u64(v_lut((const int64_t *)tab, idx));
-}
-inline v_uint64x2 v_lut_pairs(const uint64_t *tab, const int *idx) {
-  return v_reinterpret_as_u64(v_lut_pairs((const int64_t *)tab, idx));
-}
-
-inline v_float32x4 v_lut(const float *tab, const int *idx) {
-  float CV_DECL_ALIGNED(32)
-      elems[4] = {tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]};
-  return v_float32x4(vld1q_f32(elems));
-}
-inline v_float32x4 v_lut_pairs(const float *tab, const int *idx) {
-  typedef uint64 CV_DECL_ALIGNED(1) unaligned_uint64;
-
-  uint64 CV_DECL_ALIGNED(32) elems[2] = {*(unaligned_uint64 *)(tab + idx[0]),
-                                         *(unaligned_uint64 *)(tab + idx[1])};
-  return v_float32x4(vreinterpretq_f32_u64(vld1q_u64(elems)));
-}
-inline v_float32x4 v_lut_quads(const float *tab, const int *idx) {
-  return v_float32x4(vld1q_f32(tab + idx[0]));
-}
-
-inline v_int32x4 v_lut(const int *tab, const v_int32x4 &idxvec) {
-  int CV_DECL_ALIGNED(32) elems[4] = {
-      tab[vgetq_lane_s32(idxvec.val, 0)], tab[vgetq_lane_s32(idxvec.val, 1)],
-      tab[vgetq_lane_s32(idxvec.val, 2)], tab[vgetq_lane_s32(idxvec.val, 3)]};
-  return v_int32x4(vld1q_s32(elems));
-}
-
-inline v_uint32x4 v_lut(const unsigned *tab, const v_int32x4 &idxvec) {
-  unsigned CV_DECL_ALIGNED(32) elems[4] = {
-      tab[vgetq_lane_s32(idxvec.val, 0)], tab[vgetq_lane_s32(idxvec.val, 1)],
-      tab[vgetq_lane_s32(idxvec.val, 2)], tab[vgetq_lane_s32(idxvec.val, 3)]};
-  return v_uint32x4(vld1q_u32(elems));
-}
-
-inline v_float32x4 v_lut(const float *tab, const v_int32x4 &idxvec) {
-  float CV_DECL_ALIGNED(32) elems[4] = {
-      tab[vgetq_lane_s32(idxvec.val, 0)], tab[vgetq_lane_s32(idxvec.val, 1)],
-      tab[vgetq_lane_s32(idxvec.val, 2)], tab[vgetq_lane_s32(idxvec.val, 3)]};
-  return v_float32x4(vld1q_f32(elems));
-}
-
-inline void v_lut_deinterleave(const float *tab, const v_int32x4 &idxvec,
-                               v_float32x4 &x, v_float32x4 &y) {
-  /*int CV_DECL_ALIGNED(32) idx[4];
-  v_store(idx, idxvec);
-
-  float32x4_t xy02 = vcombine_f32(vld1_f32(tab + idx[0]), vld1_f32(tab +
-  idx[2])); float32x4_t xy13 = vcombine_f32(vld1_f32(tab + idx[1]), vld1_f32(tab
-  + idx[3]));
-
-  float32x4x2_t xxyy = vuzpq_f32(xy02, xy13);
-  x = v_float32x4(xxyy.val[0]);
-  y = v_float32x4(xxyy.val[1]);*/
-  int CV_DECL_ALIGNED(32) idx[4];
-  v_store_aligned(idx, idxvec);
-
-  x = v_float32x4(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]);
-  y = v_float32x4(tab[idx[0] + 1], tab[idx[1] + 1], tab[idx[2] + 1],
-                  tab[idx[3] + 1]);
-}
-
-inline v_int8x16 v_interleave_pairs(const v_int8x16 &vec) {
-  return v_int8x16(vcombine_s8(
-      vtbl1_s8(vget_low_s8(vec.val), vcreate_s8(0x0705060403010200)),
-      vtbl1_s8(vget_high_s8(vec.val), vcreate_s8(0x0705060403010200))));
-}
-inline v_uint8x16 v_interleave_pairs(const v_uint8x16 &vec) {
-  return v_reinterpret_as_u8(v_interleave_pairs(v_reinterpret_as_s8(vec)));
-}
-inline v_int8x16 v_interleave_quads(const v_int8x16 &vec) {
-  return v_int8x16(vcombine_s8(
-      vtbl1_s8(vget_low_s8(vec.val), vcreate_s8(0x0703060205010400)),
-      vtbl1_s8(vget_high_s8(vec.val), vcreate_s8(0x0703060205010400))));
-}
-inline v_uint8x16 v_interleave_quads(const v_uint8x16 &vec) {
-  return v_reinterpret_as_u8(v_interleave_quads(v_reinterpret_as_s8(vec)));
-}
-
-inline v_int16x8 v_interleave_pairs(const v_int16x8 &vec) {
-  return v_int16x8(vreinterpretq_s16_s8(
-      vcombine_s8(vtbl1_s8(vget_low_s8(vreinterpretq_s8_s16(vec.val)),
-                           vcreate_s8(0x0706030205040100)),
-                  vtbl1_s8(vget_high_s8(vreinterpretq_s8_s16(vec.val)),
-                           vcreate_s8(0x0706030205040100)))));
-}
-inline v_uint16x8 v_interleave_pairs(const v_uint16x8 &vec) {
-  return v_reinterpret_as_u16(v_interleave_pairs(v_reinterpret_as_s16(vec)));
-}
-inline v_int16x8 v_interleave_quads(const v_int16x8 &vec) {
-  int16x4x2_t res = vzip_s16(vget_low_s16(vec.val), vget_high_s16(vec.val));
-  return v_int16x8(vcombine_s16(res.val[0], res.val[1]));
-}
-inline v_uint16x8 v_interleave_quads(const v_uint16x8 &vec) {
-  return v_reinterpret_as_u16(v_interleave_quads(v_reinterpret_as_s16(vec)));
-}
-
-inline v_int32x4 v_interleave_pairs(const v_int32x4 &vec) {
-  int32x2x2_t res = vzip_s32(vget_low_s32(vec.val), vget_high_s32(vec.val));
-  return v_int32x4(vcombine_s32(res.val[0], res.val[1]));
-}
-inline v_uint32x4 v_interleave_pairs(const v_uint32x4 &vec) {
-  return v_reinterpret_as_u32(v_interleave_pairs(v_reinterpret_as_s32(vec)));
-}
-inline v_float32x4 v_interleave_pairs(const v_float32x4 &vec) {
-  return v_reinterpret_as_f32(v_interleave_pairs(v_reinterpret_as_s32(vec)));
-}
-
-inline v_int8x16 v_pack_triplets(const v_int8x16 &vec) {
-  return v_int8x16(vextq_s8(
-      vcombine_s8(
-          vtbl1_s8(vget_low_s8(vec.val), vcreate_s8(0x0605040201000000)),
-          vtbl1_s8(vget_high_s8(vec.val), vcreate_s8(0x0807060504020100))),
-      vdupq_n_s8(0), 2));
-}
-inline v_uint8x16 v_pack_triplets(const v_uint8x16 &vec) {
-  return v_reinterpret_as_u8(v_pack_triplets(v_reinterpret_as_s8(vec)));
-}
-
-inline v_int16x8 v_pack_triplets(const v_int16x8 &vec) {
-  return v_int16x8(vreinterpretq_s16_s8(
-      vextq_s8(vcombine_s8(vtbl1_s8(vget_low_s8(vreinterpretq_s8_s16(vec.val)),
-                                    vcreate_s8(0x0504030201000000)),
-                           vget_high_s8(vreinterpretq_s8_s16(vec.val))),
-               vdupq_n_s8(0), 2)));
-}
-inline v_uint16x8 v_pack_triplets(const v_uint16x8 &vec) {
-  return v_reinterpret_as_u16(v_pack_triplets(v_reinterpret_as_s16(vec)));
-}
-
-inline v_int32x4 v_pack_triplets(const v_int32x4 &vec) { return vec; }
-inline v_uint32x4 v_pack_triplets(const v_uint32x4 &vec) { return vec; }
-inline v_float32x4 v_pack_triplets(const v_float32x4 &vec) { return vec; }
-
-#if CV_SIMD128_64F
-inline v_float64x2 v_lut(const double *tab, const int *idx) {
-  double CV_DECL_ALIGNED(32) elems[2] = {tab[idx[0]], tab[idx[1]]};
-  return v_float64x2(vld1q_f64(elems));
-}
-
-inline v_float64x2 v_lut_pairs(const double *tab, const int *idx) {
-  return v_float64x2(vld1q_f64(tab + idx[0]));
-}
-
-inline v_float64x2 v_lut(const double *tab, const v_int32x4 &idxvec) {
-  double CV_DECL_ALIGNED(32) elems[2] = {
-      tab[vgetq_lane_s32(idxvec.val, 0)],
-      tab[vgetq_lane_s32(idxvec.val, 1)],
-  };
-  return v_float64x2(vld1q_f64(elems));
-}
-
-inline void v_lut_deinterleave(const double *tab, const v_int32x4 &idxvec,
-                               v_float64x2 &x, v_float64x2 &y) {
-  int CV_DECL_ALIGNED(32) idx[4];
-  v_store_aligned(idx, idxvec);
-
-  x = v_float64x2(tab[idx[0]], tab[idx[1]]);
-  y = v_float64x2(tab[idx[0] + 1], tab[idx[1] + 1]);
-}
-#endif
-
-////// FP16 support ///////
-#if CV_FP16
-inline v_float32x4 v_load_expand(const hfloat *ptr) {
-  float16x4_t v =
-#ifndef vld1_f16 // APPLE compiler defines vld1_f16 as macro
-      (float16x4_t)vld1_s16((const short *)ptr);
-#else
-      vld1_f16((const __fp16 *)ptr);
-#endif
-  return v_float32x4(vcvt_f32_f16(v));
-}
-
-inline void v_pack_store(hfloat *ptr, const v_float32x4 &v) {
-  float16x4_t hv = vcvt_f16_f32(v.val);
-
-#ifndef vst1_f16 // APPLE compiler defines vst1_f16 as macro
-  vst1_s16((short *)ptr, (int16x4_t)hv);
-#else
-  vst1_f16((__fp16 *)ptr, hv);
-#endif
-}
-#else
-inline v_float32x4 v_load_expand(const hfloat *ptr) {
-  const int N = 4;
-  float buf[N];
-  for (int i = 0; i < N; i++)
-    buf[i] = (float)ptr[i];
-  return v_load(buf);
-}
-
-inline void v_pack_store(hfloat *ptr, const v_float32x4 &v) {
-  const int N = 4;
-  float buf[N];
-  v_store(buf, v);
-  for (int i = 0; i < N; i++)
-    ptr[i] = hfloat(buf[i]);
-}
-#endif
-
-inline void v_cleanup() {}
-
-#include "intrin_math.hpp"
-#if defined(CV_SIMD_FP16) && CV_SIMD_FP16
-inline v_float16x8 v_exp(const v_float16x8 &x) {
-  return v_exp_default_16f<v_float16x8, v_int16x8>(x);
-}
-inline v_float16x8 v_log(const v_float16x8 &x) {
-  return v_log_default_16f<v_float16x8, v_int16x8>(x);
-}
-inline void v_sincos(const v_float16x8 &x, v_float16x8 &s, v_float16x8 &c) {
-  v_sincos_default_16f<v_float16x8, v_int16x8>(x, s, c);
-}
-inline v_float16x8 v_sin(const v_float16x8 &x) {
-  return v_sin_default_16f<v_float16x8, v_int16x8>(x);
-}
-inline v_float16x8 v_cos(const v_float16x8 &x) {
-  return v_cos_default_16f<v_float16x8, v_int16x8>(x);
-}
-#endif
-inline v_float32x4 v_exp(const v_float32x4 &x) {
-  return v_exp_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline v_float32x4 v_log(const v_float32x4 &x) {
-  return v_log_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline void v_sincos(const v_float32x4 &x, v_float32x4 &s, v_float32x4 &c) {
-  v_sincos_default_32f<v_float32x4, v_int32x4>(x, s, c);
-}
-inline v_float32x4 v_sin(const v_float32x4 &x) {
-  return v_sin_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline v_float32x4 v_cos(const v_float32x4 &x) {
-  return v_cos_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline v_float32x4 v_erf(const v_float32x4 &x) {
-  return v_erf_default_32f<v_float32x4, v_int32x4>(x);
-}
-#if CV_SIMD128_64F
-inline v_float64x2 v_exp(const v_float64x2 &x) {
-  return v_exp_default_64f<v_float64x2, v_int64x2>(x);
-}
-inline v_float64x2 v_log(const v_float64x2 &x) {
-  return v_log_default_64f<v_float64x2, v_int64x2>(x);
-}
-inline void v_sincos(const v_float64x2 &x, v_float64x2 &s, v_float64x2 &c) {
-  v_sincos_default_64f<v_float64x2, v_int64x2>(x, s, c);
-}
-inline v_float64x2 v_sin(const v_float64x2 &x) {
-  return v_sin_default_64f<v_float64x2, v_int64x2>(x);
-}
-inline v_float64x2 v_cos(const v_float64x2 &x) {
-  return v_cos_default_64f<v_float64x2, v_int64x2>(x);
-}
-#endif
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_END
-
-//! @endcond
-
-} // namespace cv
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_rvv071.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_rvv071.hpp
deleted file mode 100644
index c3a163f45f..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_rvv071.hpp
+++ /dev/null
@@ -1,3452 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html
-
-// Copyright (C) 2015, PingTouGe Semiconductor Co., Ltd., all rights reserved.
-
-#ifndef OPENCV_HAL_INTRIN_RISCVV_HPP
-#define OPENCV_HAL_INTRIN_RISCVV_HPP
-
-#include "opencv2/core/utility.hpp"
-#include <algorithm>
-#include <float.h>
-
-namespace cv {
-
-//! @cond IGNORED
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_BEGIN
-
-#define CV_SIMD128 1
-#define CV_SIMD128_64F 1
-//////////// Types ////////////
-struct v_uint8x16 {
-  typedef uchar lane_type;
-  enum { nlanes = 16 };
-
-  v_uint8x16() {}
-  explicit v_uint8x16(vuint8m1_t v) : val(v) {}
-  v_uint8x16(uchar v0, uchar v1, uchar v2, uchar v3, uchar v4, uchar v5,
-             uchar v6, uchar v7, uchar v8, uchar v9, uchar v10, uchar v11,
-             uchar v12, uchar v13, uchar v14, uchar v15) {
-    uchar v[] = {v0, v1, v2,  v3,  v4,  v5,  v6,  v7,
-                 v8, v9, v10, v11, v12, v13, v14, v15};
-    val = (vuint8m1_t)vle8_v_u8m1((unsigned char *)v, 16);
-  }
-  uchar get0() const { return vmv_x_s_u8m1_u8(val); }
-
-  vuint8m1_t val;
-};
-
-struct v_int8x16 {
-  typedef schar lane_type;
-  enum { nlanes = 16 };
-
-  v_int8x16() {}
-  explicit v_int8x16(vint8m1_t v) : val(v) {}
-  v_int8x16(schar v0, schar v1, schar v2, schar v3, schar v4, schar v5,
-            schar v6, schar v7, schar v8, schar v9, schar v10, schar v11,
-            schar v12, schar v13, schar v14, schar v15) {
-    schar v[] = {v0, v1, v2,  v3,  v4,  v5,  v6,  v7,
-                 v8, v9, v10, v11, v12, v13, v14, v15};
-    val = (vint8m1_t)vle8_v_i8m1((schar *)v, 16);
-  }
-  schar get0() const { return vmv_x_s_i8m1_i8(val); }
-
-  vint8m1_t val;
-};
-
-struct v_uint16x8 {
-  typedef ushort lane_type;
-  enum { nlanes = 8 };
-
-  v_uint16x8() {}
-  explicit v_uint16x8(vuint16m1_t v) : val(v) {}
-  v_uint16x8(ushort v0, ushort v1, ushort v2, ushort v3, ushort v4, ushort v5,
-             ushort v6, ushort v7) {
-    ushort v[] = {v0, v1, v2, v3, v4, v5, v6, v7};
-    val = (vuint16m1_t)vle16_v_u16m1((unsigned short *)v, 8);
-  }
-  ushort get0() const { return vmv_x_s_u16m1_u16(val); }
-
-  vuint16m1_t val;
-};
-
-struct v_int16x8 {
-  typedef short lane_type;
-  enum { nlanes = 8 };
-
-  v_int16x8() {}
-  explicit v_int16x8(vint16m1_t v) : val(v) {}
-  v_int16x8(short v0, short v1, short v2, short v3, short v4, short v5,
-            short v6, short v7) {
-    short v[] = {v0, v1, v2, v3, v4, v5, v6, v7};
-    val = (vint16m1_t)vle16_v_i16m1((signed short *)v, 8);
-  }
-  short get0() const { return vmv_x_s_i16m1_i16(val); }
-
-  vint16m1_t val;
-};
-
-struct v_uint32x4 {
-  typedef unsigned lane_type;
-  enum { nlanes = 4 };
-
-  v_uint32x4() {}
-  explicit v_uint32x4(vuint32m1_t v) : val(v) {}
-  v_uint32x4(unsigned v0, unsigned v1, unsigned v2, unsigned v3) {
-    unsigned v[] = {v0, v1, v2, v3};
-    val = (vuint32m1_t)vle32_v_u32m1((unsigned int *)v, 4);
-  }
-  unsigned get0() const { return vmv_x_s_u32m1_u32(val); }
-
-  vuint32m1_t val;
-};
-
-struct v_int32x4 {
-  typedef int lane_type;
-  enum { nlanes = 4 };
-
-  v_int32x4() {}
-  explicit v_int32x4(vint32m1_t v) : val(v) {}
-  v_int32x4(int v0, int v1, int v2, int v3) {
-    int v[] = {v0, v1, v2, v3};
-    val = (vint32m1_t)vle32_v_i32m1((signed int *)v, 4);
-  }
-  int get0() const { return vmv_x_s_i32m1_i32(val); }
-  vint32m1_t val;
-};
-
-struct v_float32x4 {
-  typedef float lane_type;
-  enum { nlanes = 4 };
-
-  v_float32x4() {}
-  explicit v_float32x4(vfloat32m1_t v) : val(v) {}
-  v_float32x4(float v0, float v1, float v2, float v3) {
-    float v[] = {v0, v1, v2, v3};
-    val = (vfloat32m1_t)vle32_v_f32m1((float *)v, 4);
-  }
-  float get0() const { return vfmv_f_s_f32m1_f32(val); }
-  vfloat32m1_t val;
-};
-
-struct v_uint64x2 {
-  typedef uint64 lane_type;
-  enum { nlanes = 2 };
-
-  v_uint64x2() {}
-  explicit v_uint64x2(vuint64m1_t v) : val(v) {}
-  v_uint64x2(uint64 v0, uint64 v1) {
-    uint64 v[] = {v0, v1};
-    val = (vuint64m1_t)vle64_v_u64m1((unsigned long *)v, 2);
-  }
-  uint64 get0() const { return vmv_x_s_u64m1_u64(val); }
-  vuint64m1_t val;
-};
-
-struct v_int64x2 {
-  typedef int64 lane_type;
-  enum { nlanes = 2 };
-
-  v_int64x2() {}
-  explicit v_int64x2(vint64m1_t v) : val(v) {}
-  v_int64x2(int64 v0, int64 v1) {
-    int64 v[] = {v0, v1};
-    val = (vint64m1_t)vle64_v_i64m1((long *)v, 2);
-  }
-  int64 get0() const { return vmv_x_s_i64m1_i64(val); }
-  vint64m1_t val;
-};
-
-struct v_float64x2 {
-  typedef double lane_type;
-  enum { nlanes = 2 };
-
-  v_float64x2() {}
-  explicit v_float64x2(vfloat64m1_t v) : val(v) {}
-  v_float64x2(double v0, double v1) {
-    double v[] = {v0, v1};
-    val = (vfloat64m1_t)vle64_v_f64m1((double *)v, 2);
-  }
-  double get0() const { return vfmv_f_s_f64m1_f64(val); }
-  vfloat64m1_t val;
-};
-/*
-#define OPENCV_HAL_IMPL_RISCVV_INIT(_Tpv, _Tp, suffix) \
-inline _Tp##m1_t vreinterpret_v_##suffix##m1_##suffix##m1(_Tp##m1_t v) { return
-v; } \
-inline v_uint8x16 v_reinterpret_as_u8(const v_##_Tpv& v) { return
-v_uint8x16((vuint8m1_t)(v.val)); } \
-inline v_int8x16 v_reinterpret_as_s8(const v_##_Tpv& v) { return
-v_int8x16((vint8m1_t)(v.val)); } \
-inline v_uint16x8 v_reinterpret_as_u16(const v_##_Tpv& v) { return
-v_uint16x8((vuint16m1_t)(v.val)); } \
-inline v_int16x8 v_reinterpret_as_s16(const v_##_Tpv& v) { return
-v_int16x8(vreinterpret_v_i8m1_i16m1(v.val)); } \
-inline v_uint32x4 v_reinterpret_as_u32(const v_##_Tpv& v) { return
-v_uint32x4((vuint32m1_t)(v.val)); } \
-inline v_int32x4 v_reinterpret_as_s32(const v_##_Tpv& v) { return
-v_int32x4((vint32m1_t)(v.val)); } \
-inline v_uint64x2 v_reinterpret_as_u64(const v_##_Tpv& v) { return
-v_uint64x2((vuint64m1_t)(v.val)); } \
-inline v_int64x2 v_reinterpret_as_s64(const v_##_Tpv& v) { return
-v_int64x2((vint64m1_t)(v.val)); } \
-inline v_float32x4 v_reinterpret_as_f32(const v_##_Tpv& v) { return
-v_float32x4((vfloat32m1_t)(v.val)); }\ inline v_float64x2
-v_reinterpret_as_f64(const v_##_Tpv& v) { return
-v_float64x2((vfloat64m1_t)(v.val)); }
-
-
-OPENCV_HAL_IMPL_RISCVV_INIT(uint8x16, vuint8, u8)
-OPENCV_HAL_IMPL_RISCVV_INIT(int8x16, vint8, i8)
-OPENCV_HAL_IMPL_RISCVV_INIT(uint16x8, vuint16, u16)
-OPENCV_HAL_IMPL_RISCVV_INIT(int16x8, vint16, i16)
-OPENCV_HAL_IMPL_RISCVV_INIT(uint32x4, vuint32, u32)
-OPENCV_HAL_IMPL_RISCVV_INIT(int32x4, vint32, i32)
-OPENCV_HAL_IMPL_RISCVV_INIT(uint64x2, vuint64, u64)
-OPENCV_HAL_IMPL_RISCVV_INIT(int64x2, vint64, i64)
-OPENCV_HAL_IMPL_RISCVV_INIT(float64x2, vfloat64, f64)
-OPENCV_HAL_IMPL_RISCVV_INIT(float32x4, vfloat32, f32)
-*/
-inline v_uint8x16 v_reinterpret_as_u8(const v_uint8x16 &v) {
-  return v_uint8x16(v.val);
-}
-inline v_int8x16 v_reinterpret_as_s8(const v_uint8x16 &v) {
-  return v_int8x16(vreinterpret_v_u8m1_i8m1(v.val));
-}
-inline v_uint16x8 v_reinterpret_as_u16(const v_uint8x16 &v) {
-  return v_uint16x8(vreinterpret_v_u8m1_u16m1(v.val));
-}
-inline v_int16x8 v_reinterpret_as_s16(const v_uint8x16 &v) {
-  return v_int16x8(
-      vreinterpret_v_u16m1_i16m1(vreinterpret_v_u8m1_u16m1(v.val)));
-}
-inline v_uint32x4 v_reinterpret_as_u32(const v_uint8x16 &v) {
-  return v_uint32x4(vreinterpret_v_u8m1_u32m1(v.val));
-}
-inline v_int32x4 v_reinterpret_as_s32(const v_uint8x16 &v) {
-  return v_int32x4(
-      vreinterpret_v_u32m1_i32m1(vreinterpret_v_u8m1_u32m1(v.val)));
-}
-inline v_uint64x2 v_reinterpret_as_u64(const v_uint8x16 &v) {
-  return v_uint64x2(vreinterpret_v_u8m1_u64m1(v.val));
-}
-inline v_int64x2 v_reinterpret_as_s64(const v_uint8x16 &v) {
-  return v_int64x2(
-      vreinterpret_v_u64m1_i64m1(vreinterpret_v_u8m1_u64m1(v.val)));
-}
-inline v_float32x4 v_reinterpret_as_f32(const v_uint8x16 &v) {
-  return v_float32x4(
-      vreinterpret_v_u32m1_f32m1(vreinterpret_v_u8m1_u32m1(v.val)));
-}
-inline v_float64x2 v_reinterpret_as_f64(const v_uint8x16 &v) {
-  return v_float64x2(
-      vreinterpret_v_u64m1_f64m1(vreinterpret_v_u8m1_u64m1(v.val)));
-}
-
-inline v_uint8x16 v_reinterpret_as_u8(const v_int8x16 &v) {
-  return v_uint8x16(vreinterpret_v_i8m1_u8m1(v.val));
-}
-inline v_int8x16 v_reinterpret_as_s8(const v_int8x16 &v) {
-  return v_int8x16(v.val);
-}
-inline v_uint16x8 v_reinterpret_as_u16(const v_int8x16 &v) {
-  return v_uint16x8(vreinterpret_v_u8m1_u16m1(vreinterpret_v_i8m1_u8m1(v.val)));
-}
-inline v_int16x8 v_reinterpret_as_s16(const v_int8x16 &v) {
-  return v_int16x8(vreinterpret_v_i8m1_i16m1(v.val));
-}
-inline v_uint32x4 v_reinterpret_as_u32(const v_int8x16 &v) {
-  return v_uint32x4(vreinterpret_v_u8m1_u32m1(vreinterpret_v_i8m1_u8m1(v.val)));
-}
-inline v_int32x4 v_reinterpret_as_s32(const v_int8x16 &v) {
-  return v_int32x4(vreinterpret_v_i8m1_i32m1(v.val));
-}
-inline v_uint64x2 v_reinterpret_as_u64(const v_int8x16 &v) {
-  return v_uint64x2(vreinterpret_v_u8m1_u64m1(vreinterpret_v_i8m1_u8m1(v.val)));
-}
-inline v_int64x2 v_reinterpret_as_s64(const v_int8x16 &v) {
-  return v_int64x2(vreinterpret_v_i8m1_i64m1(v.val));
-}
-inline v_float32x4 v_reinterpret_as_f32(const v_int8x16 &v) {
-  return v_float32x4(
-      vreinterpret_v_i32m1_f32m1(vreinterpret_v_i8m1_i32m1(v.val)));
-}
-inline v_float64x2 v_reinterpret_as_f64(const v_int8x16 &v) {
-  return v_float64x2(
-      vreinterpret_v_i64m1_f64m1(vreinterpret_v_i8m1_i64m1(v.val)));
-}
-
-inline v_uint8x16 v_reinterpret_as_u8(const v_uint16x8 &v) {
-  return v_uint8x16(vreinterpret_v_u16m1_u8m1(v.val));
-}
-inline v_int8x16 v_reinterpret_as_s8(const v_uint16x8 &v) {
-  return v_int8x16(
-      vreinterpret_v_i16m1_i8m1(vreinterpret_v_u16m1_i16m1(v.val)));
-}
-inline v_uint16x8 v_reinterpret_as_u16(const v_uint16x8 &v) {
-  return v_uint16x8(v.val);
-}
-inline v_int16x8 v_reinterpret_as_s16(const v_uint16x8 &v) {
-  return v_int16x8(vreinterpret_v_u16m1_i16m1(v.val));
-}
-inline v_uint32x4 v_reinterpret_as_u32(const v_uint16x8 &v) {
-  return v_uint32x4(vreinterpret_v_u16m1_u32m1(v.val));
-}
-inline v_int32x4 v_reinterpret_as_s32(const v_uint16x8 &v) {
-  return v_int32x4(
-      vreinterpret_v_u32m1_i32m1(vreinterpret_v_u16m1_u32m1(v.val)));
-}
-inline v_uint64x2 v_reinterpret_as_u64(const v_uint16x8 &v) {
-  return v_uint64x2(vreinterpret_v_u16m1_u64m1(v.val));
-}
-inline v_int64x2 v_reinterpret_as_s64(const v_uint16x8 &v) {
-  return v_int64x2(
-      vreinterpret_v_u64m1_i64m1(vreinterpret_v_u16m1_u64m1(v.val)));
-}
-inline v_float32x4 v_reinterpret_as_f32(const v_uint16x8 &v) {
-  return v_float32x4(
-      vreinterpret_v_u32m1_f32m1(vreinterpret_v_u16m1_u32m1(v.val)));
-}
-inline v_float64x2 v_reinterpret_as_f64(const v_uint16x8 &v) {
-  return v_float64x2(
-      vreinterpret_v_u64m1_f64m1(vreinterpret_v_u16m1_u64m1(v.val)));
-}
-
-inline v_uint8x16 v_reinterpret_as_u8(const v_int16x8 &v) {
-  return v_uint8x16(vreinterpret_v_i8m1_u8m1(vreinterpret_v_i16m1_i8m1(v.val)));
-}
-inline v_int8x16 v_reinterpret_as_s8(const v_int16x8 &v) {
-  return v_int8x16(vreinterpret_v_i16m1_i8m1(v.val));
-}
-inline v_uint16x8 v_reinterpret_as_u16(const v_int16x8 &v) {
-  return v_uint16x8(vreinterpret_v_i16m1_u16m1(v.val));
-}
-inline v_int16x8 v_reinterpret_as_s16(const v_int16x8 &v) {
-  return v_int16x8(v.val);
-}
-inline v_uint32x4 v_reinterpret_as_u32(const v_int16x8 &v) {
-  return v_uint32x4(
-      vreinterpret_v_u16m1_u32m1(vreinterpret_v_i16m1_u16m1(v.val)));
-}
-inline v_int32x4 v_reinterpret_as_s32(const v_int16x8 &v) {
-  return v_int32x4(vreinterpret_v_i16m1_i32m1(v.val));
-}
-inline v_uint64x2 v_reinterpret_as_u64(const v_int16x8 &v) {
-  return v_uint64x2(
-      vreinterpret_v_u16m1_u64m1(vreinterpret_v_i16m1_u16m1(v.val)));
-}
-inline v_int64x2 v_reinterpret_as_s64(const v_int16x8 &v) {
-  return v_int64x2(vreinterpret_v_i16m1_i64m1(v.val));
-}
-inline v_float32x4 v_reinterpret_as_f32(const v_int16x8 &v) {
-  return v_float32x4(
-      vreinterpret_v_i32m1_f32m1(vreinterpret_v_i16m1_i32m1(v.val)));
-}
-inline v_float64x2 v_reinterpret_as_f64(const v_int16x8 &v) {
-  return v_float64x2(
-      vreinterpret_v_i64m1_f64m1(vreinterpret_v_i16m1_i64m1(v.val)));
-}
-
-inline v_uint8x16 v_reinterpret_as_u8(const v_uint32x4 &v) {
-  return v_uint8x16(vreinterpret_v_u32m1_u8m1(v.val));
-}
-inline v_int8x16 v_reinterpret_as_s8(const v_uint32x4 &v) {
-  return v_int8x16(
-      vreinterpret_v_i32m1_i8m1(vreinterpret_v_u32m1_i32m1(v.val)));
-}
-inline v_uint16x8 v_reinterpret_as_u16(const v_uint32x4 &v) {
-  return v_uint16x8(vreinterpret_v_u32m1_u16m1(v.val));
-}
-inline v_int16x8 v_reinterpret_as_s16(const v_uint32x4 &v) {
-  return v_int16x8(
-      vreinterpret_v_i32m1_i16m1(vreinterpret_v_u32m1_i32m1(v.val)));
-}
-inline v_uint32x4 v_reinterpret_as_u32(const v_uint32x4 &v) {
-  return v_uint32x4(v.val);
-}
-inline v_int32x4 v_reinterpret_as_s32(const v_uint32x4 &v) {
-  return v_int32x4(vreinterpret_v_u32m1_i32m1(v.val));
-}
-inline v_uint64x2 v_reinterpret_as_u64(const v_uint32x4 &v) {
-  return v_uint64x2(vreinterpret_v_u32m1_u64m1(v.val));
-}
-inline v_int64x2 v_reinterpret_as_s64(const v_uint32x4 &v) {
-  return v_int64x2(
-      vreinterpret_v_u64m1_i64m1(vreinterpret_v_u32m1_u64m1(v.val)));
-}
-inline v_float32x4 v_reinterpret_as_f32(const v_uint32x4 &v) {
-  return v_float32x4(vreinterpret_v_u32m1_f32m1(v.val));
-}
-inline v_float64x2 v_reinterpret_as_f64(const v_uint32x4 &v) {
-  return v_float64x2(
-      vreinterpret_v_u64m1_f64m1(vreinterpret_v_u32m1_u64m1(v.val)));
-}
-
-inline v_uint8x16 v_reinterpret_as_u8(const v_int32x4 &v) {
-  return v_uint8x16(vreinterpret_v_i8m1_u8m1(vreinterpret_v_i32m1_i8m1(v.val)));
-}
-inline v_int8x16 v_reinterpret_as_s8(const v_int32x4 &v) {
-  return v_int8x16(vreinterpret_v_i32m1_i8m1(v.val));
-}
-inline v_uint16x8 v_reinterpret_as_u16(const v_int32x4 &v) {
-  return v_uint16x8(
-      vreinterpret_v_u32m1_u16m1(vreinterpret_v_i32m1_u32m1(v.val)));
-}
-inline v_int16x8 v_reinterpret_as_s16(const v_int32x4 &v) {
-  return v_int16x8(vreinterpret_v_i32m1_i16m1(v.val));
-}
-inline v_uint32x4 v_reinterpret_as_u32(const v_int32x4 &v) {
-  return v_uint32x4(vreinterpret_v_i32m1_u32m1(v.val));
-}
-inline v_int32x4 v_reinterpret_as_s32(const v_int32x4 &v) {
-  return v_int32x4(v.val);
-}
-inline v_uint64x2 v_reinterpret_as_u64(const v_int32x4 &v) {
-  return v_uint64x2(
-      vreinterpret_v_u32m1_u64m1(vreinterpret_v_i32m1_u32m1(v.val)));
-}
-inline v_int64x2 v_reinterpret_as_s64(const v_int32x4 &v) {
-  return v_int64x2(vreinterpret_v_i32m1_i64m1(v.val));
-}
-inline v_float32x4 v_reinterpret_as_f32(const v_int32x4 &v) {
-  return v_float32x4(vreinterpret_v_i32m1_f32m1(v.val));
-}
-inline v_float64x2 v_reinterpret_as_f64(const v_int32x4 &v) {
-  return v_float64x2(
-      vreinterpret_v_i64m1_f64m1(vreinterpret_v_i32m1_i64m1(v.val)));
-}
-
-inline v_uint8x16 v_reinterpret_as_u8(const v_uint64x2 &v) {
-  return v_uint8x16(vreinterpret_v_u64m1_u8m1(v.val));
-}
-inline v_int8x16 v_reinterpret_as_s8(const v_uint64x2 &v) {
-  return v_int8x16(
-      vreinterpret_v_i64m1_i8m1(vreinterpret_v_u64m1_i64m1(v.val)));
-}
-inline v_uint16x8 v_reinterpret_as_u16(const v_uint64x2 &v) {
-  return v_uint16x8(vreinterpret_v_u64m1_u16m1(v.val));
-}
-inline v_int16x8 v_reinterpret_as_s16(const v_uint64x2 &v) {
-  return v_int16x8(
-      vreinterpret_v_i64m1_i16m1(vreinterpret_v_u64m1_i64m1(v.val)));
-}
-inline v_uint32x4 v_reinterpret_as_u32(const v_uint64x2 &v) {
-  return v_uint32x4(vreinterpret_v_u64m1_u32m1(v.val));
-}
-inline v_int32x4 v_reinterpret_as_s32(const v_uint64x2 &v) {
-  return v_int32x4(
-      vreinterpret_v_i64m1_i32m1(vreinterpret_v_u64m1_i64m1(v.val)));
-}
-inline v_uint64x2 v_reinterpret_as_u64(const v_uint64x2 &v) {
-  return v_uint64x2(v.val);
-}
-inline v_int64x2 v_reinterpret_as_s64(const v_uint64x2 &v) {
-  return v_int64x2(vreinterpret_v_u64m1_i64m1(v.val));
-}
-inline v_float32x4 v_reinterpret_as_f32(const v_uint64x2 &v) {
-  return v_float32x4(
-      vreinterpret_v_u32m1_f32m1(vreinterpret_v_u64m1_u32m1(v.val)));
-}
-inline v_float64x2 v_reinterpret_as_f64(const v_uint64x2 &v) {
-  return v_float64x2(vreinterpret_v_u64m1_f64m1(v.val));
-}
-
-inline v_uint8x16 v_reinterpret_as_u8(const v_int64x2 &v) {
-  return v_uint8x16(vreinterpret_v_i8m1_u8m1(vreinterpret_v_i64m1_i8m1(v.val)));
-}
-inline v_int8x16 v_reinterpret_as_s8(const v_int64x2 &v) {
-  return v_int8x16(vreinterpret_v_i64m1_i8m1(v.val));
-}
-inline v_uint16x8 v_reinterpret_as_u16(const v_int64x2 &v) {
-  return v_uint16x8(
-      vreinterpret_v_u64m1_u16m1(vreinterpret_v_i64m1_u64m1(v.val)));
-}
-inline v_int16x8 v_reinterpret_as_s16(const v_int64x2 &v) {
-  return v_int16x8(vreinterpret_v_i64m1_i16m1(v.val));
-}
-inline v_uint32x4 v_reinterpret_as_u32(const v_int64x2 &v) {
-  return v_uint32x4(
-      vreinterpret_v_u64m1_u32m1(vreinterpret_v_i64m1_u64m1(v.val)));
-}
-inline v_int32x4 v_reinterpret_as_s32(const v_int64x2 &v) {
-  return v_int32x4(vreinterpret_v_i64m1_i32m1(v.val));
-}
-inline v_uint64x2 v_reinterpret_as_u64(const v_int64x2 &v) {
-  return v_uint64x2(vreinterpret_v_i64m1_u64m1(v.val));
-}
-inline v_int64x2 v_reinterpret_as_s64(const v_int64x2 &v) {
-  return v_int64x2(v.val);
-}
-inline v_float32x4 v_reinterpret_as_f32(const v_int64x2 &v) {
-  return v_float32x4(
-      vreinterpret_v_i32m1_f32m1(vreinterpret_v_i64m1_i32m1(v.val)));
-}
-inline v_float64x2 v_reinterpret_as_f64(const v_int64x2 &v) {
-  return v_float64x2(vreinterpret_v_i64m1_f64m1(v.val));
-}
-
-inline v_uint8x16 v_reinterpret_as_u8(const v_float32x4 &v) {
-  return v_uint8x16(
-      vreinterpret_v_u32m1_u8m1(vreinterpret_v_f32m1_u32m1(v.val)));
-}
-inline v_int8x16 v_reinterpret_as_s8(const v_float32x4 &v) {
-  return v_int8x16(
-      vreinterpret_v_i32m1_i8m1(vreinterpret_v_f32m1_i32m1(v.val)));
-}
-inline v_uint16x8 v_reinterpret_as_u16(const v_float32x4 &v) {
-  return v_uint16x8(
-      vreinterpret_v_u32m1_u16m1(vreinterpret_v_f32m1_u32m1(v.val)));
-}
-inline v_int16x8 v_reinterpret_as_s16(const v_float32x4 &v) {
-  return v_int16x8(
-      vreinterpret_v_i32m1_i16m1(vreinterpret_v_f32m1_i32m1(v.val)));
-}
-inline v_uint32x4 v_reinterpret_as_u32(const v_float32x4 &v) {
-  return v_uint32x4(vreinterpret_v_f32m1_u32m1(v.val));
-}
-inline v_int32x4 v_reinterpret_as_s32(const v_float32x4 &v) {
-  return v_int32x4(vreinterpret_v_f32m1_i32m1(v.val));
-}
-inline v_uint64x2 v_reinterpret_as_u64(const v_float32x4 &v) {
-  return v_uint64x2(
-      vreinterpret_v_u32m1_u64m1(vreinterpret_v_f32m1_u32m1(v.val)));
-}
-inline v_int64x2 v_reinterpret_as_s64(const v_float32x4 &v) {
-  return v_int64x2(
-      vreinterpret_v_i32m1_i64m1(vreinterpret_v_f32m1_i32m1(v.val)));
-}
-inline v_float32x4 v_reinterpret_as_f32(const v_float32x4 &v) {
-  return v_float32x4(v.val);
-}
-inline v_float64x2 v_reinterpret_as_f64(const v_float32x4 &v) {
-  return v_float64x2(vreinterpret_v_i64m1_f64m1(
-      vreinterpret_v_i32m1_i64m1(vreinterpret_v_f32m1_i32m1(v.val))));
-}
-
-inline v_uint8x16 v_reinterpret_as_u8(const v_float64x2 &v) {
-  return v_uint8x16(
-      vreinterpret_v_u64m1_u8m1(vreinterpret_v_f64m1_u64m1(v.val)));
-}
-inline v_int8x16 v_reinterpret_as_s8(const v_float64x2 &v) {
-  return v_int8x16(
-      vreinterpret_v_i64m1_i8m1(vreinterpret_v_f64m1_i64m1(v.val)));
-}
-inline v_uint16x8 v_reinterpret_as_u16(const v_float64x2 &v) {
-  return v_uint16x8(
-      vreinterpret_v_u64m1_u16m1(vreinterpret_v_f64m1_u64m1(v.val)));
-}
-inline v_int16x8 v_reinterpret_as_s16(const v_float64x2 &v) {
-  return v_int16x8(
-      vreinterpret_v_i64m1_i16m1(vreinterpret_v_f64m1_i64m1(v.val)));
-}
-inline v_uint32x4 v_reinterpret_as_u32(const v_float64x2 &v) {
-  return v_uint32x4(
-      vreinterpret_v_u64m1_u32m1(vreinterpret_v_f64m1_u64m1(v.val)));
-}
-inline v_int32x4 v_reinterpret_as_s32(const v_float64x2 &v) {
-  return v_int32x4(
-      vreinterpret_v_i64m1_i32m1(vreinterpret_v_f64m1_i64m1(v.val)));
-}
-inline v_uint64x2 v_reinterpret_as_u64(const v_float64x2 &v) {
-  return v_uint64x2(vreinterpret_v_f64m1_u64m1(v.val));
-}
-inline v_int64x2 v_reinterpret_as_s64(const v_float64x2 &v) {
-  return v_int64x2(vreinterpret_v_f64m1_i64m1(v.val));
-}
-inline v_float32x4 v_reinterpret_as_f32(const v_float64x2 &v) {
-  return v_float32x4(vreinterpret_v_i32m1_f32m1(
-      vreinterpret_v_i64m1_i32m1(vreinterpret_v_f64m1_i64m1(v.val))));
-}
-inline v_float64x2 v_reinterpret_as_f64(const v_float64x2 &v) {
-  return v_float64x2(v.val);
-}
-
-#define OPENCV_HAL_IMPL_RISCVV_INIT_SET(__Tp, _Tp, suffix, len, num)           \
-  inline v_##_Tp##x##num v_setzero_##suffix() {                                \
-    return v_##_Tp##x##num(vmv_v_x_##len##m1(0, num));                         \
-  }                                                                            \
-  inline v_##_Tp##x##num v_setall_##suffix(__Tp v) {                           \
-    return v_##_Tp##x##num(vmv_v_x_##len##m1(v, num));                         \
-  }                                                                            \
-  template <> inline v_##_Tp##x##num v_setzero_() {                            \
-    return v_setzero_##suffix();                                               \
-  }                                                                            \
-  template <> inline v_##_Tp##x##num v_setall_(__Tp v) {                       \
-    return v_setall_##suffix(v);                                               \
-  }
-
-OPENCV_HAL_IMPL_RISCVV_INIT_SET(uchar, uint8, u8, u8, 16)
-OPENCV_HAL_IMPL_RISCVV_INIT_SET(schar, int8, s8, i8, 16)
-OPENCV_HAL_IMPL_RISCVV_INIT_SET(ushort, uint16, u16, u16, 8)
-OPENCV_HAL_IMPL_RISCVV_INIT_SET(short, int16, s16, i16, 8)
-OPENCV_HAL_IMPL_RISCVV_INIT_SET(unsigned int, uint32, u32, u32, 4)
-OPENCV_HAL_IMPL_RISCVV_INIT_SET(int, int32, s32, i32, 4)
-OPENCV_HAL_IMPL_RISCVV_INIT_SET(unsigned long, uint64, u64, u64, 2)
-OPENCV_HAL_IMPL_RISCVV_INIT_SET(long, int64, s64, i64, 2)
-inline v_float32x4 v_setzero_f32() { return v_float32x4(vfmv_v_f_f32m1(0, 4)); }
-inline v_float32x4 v_setall_f32(float v) {
-  return v_float32x4(vfmv_v_f_f32m1(v, 4));
-}
-
-inline v_float64x2 v_setzero_f64() { return v_float64x2(vfmv_v_f_f64m1(0, 2)); }
-inline v_float64x2 v_setall_f64(double v) {
-  return v_float64x2(vfmv_v_f_f64m1(v, 2));
-}
-
-template <> inline v_float32x4 v_setzero_() { return v_setzero_f32(); }
-template <> inline v_float32x4 v_setall_(float v) { return v_setall_f32(v); }
-
-template <> inline v_float64x2 v_setzero_() { return v_setzero_f64(); }
-template <> inline v_float64x2 v_setall_(double v) { return v_setall_f64(v); }
-
-#define OPENCV_HAL_IMPL_RISCVV_BIN_OP(bin_op, _Tpvec, intrin)                  \
-  inline _Tpvec bin_op(const _Tpvec &a, const _Tpvec &b) {                     \
-    return _Tpvec(intrin(a.val, b.val));                                       \
-  }
-
-#define OPENCV_HAL_IMPL_RISCVV_BIN_OPN(bin_op, _Tpvec, intrin, num)            \
-  inline _Tpvec bin_op(const _Tpvec &a, const _Tpvec &b) {                     \
-    return _Tpvec(intrin(a.val, b.val, num));                                  \
-  }
-
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_add, v_uint8x16, vsaddu_vv_u8m1, 16)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_sub, v_uint8x16, vssubu_vv_u8m1, 16)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_add, v_int8x16, vsadd_vv_i8m1, 16)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_sub, v_int8x16, vssub_vv_i8m1, 16)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_add, v_uint16x8, vsaddu_vv_u16m1, 8)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_sub, v_uint16x8, vssubu_vv_u16m1, 8)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_add, v_int16x8, vsadd_vv_i16m1, 8)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_sub, v_int16x8, vssub_vv_i16m1, 8)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_add, v_int32x4, vadd_vv_i32m1, 4)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_sub, v_int32x4, vsub_vv_i32m1, 4)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_mul, v_int32x4, vmul_vv_i32m1, 4)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_add, v_uint32x4, vadd_vv_u32m1, 4)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_sub, v_uint32x4, vsub_vv_u32m1, 4)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_mul, v_uint32x4, vmul_vv_u32m1, 4)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_add, v_int64x2, vadd_vv_i64m1, 2)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_sub, v_int64x2, vsub_vv_i64m1, 2)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_add, v_uint64x2, vadd_vv_u64m1, 2)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_sub, v_uint64x2, vsub_vv_u64m1, 2)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_add, v_float32x4, vfadd_vv_f32m1, 4)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_sub, v_float32x4, vfsub_vv_f32m1, 4)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_mul, v_float32x4, vfmul_vv_f32m1, 4)
-inline v_float32x4 v_div(const v_float32x4 &a, const v_float32x4 &b) {
-  return v_float32x4(vfdiv_vv_f32m1(a.val, b.val, 4));
-}
-
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_add, v_float64x2, vfadd_vv_f64m1, 2)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_sub, v_float64x2, vfsub_vv_f64m1, 2)
-OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_mul, v_float64x2, vfmul_vv_f64m1, 2)
-inline v_float64x2 v_div(const v_float64x2 &a, const v_float64x2 &b) {
-  return v_float64x2(vfdiv_vv_f64m1(a.val, b.val, 2));
-}
-// TODO: exp, log, sin, cos
-
-#define OPENCV_HAL_IMPL_RISCVV_BIN_FUNC(_Tpvec, func, intrin)                  \
-  inline _Tpvec func(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(intrin(a.val, b.val));                                       \
-  }
-
-#define OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(_Tpvec, func, intrin, num)            \
-  inline _Tpvec func(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(intrin(a.val, b.val, num));                                  \
-  }
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_uint8x16, v_min, vminu_vv_u8m1, 16)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_uint8x16, v_max, vmaxu_vv_u8m1, 16)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_int8x16, v_min, vmin_vv_i8m1, 16)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_int8x16, v_max, vmax_vv_i8m1, 16)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_uint16x8, v_min, vminu_vv_u16m1, 8)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_uint16x8, v_max, vmaxu_vv_u16m1, 8)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_int16x8, v_min, vmin_vv_i16m1, 8)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_int16x8, v_max, vmax_vv_i16m1, 8)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_uint32x4, v_min, vminu_vv_u32m1, 4)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_uint32x4, v_max, vmaxu_vv_u32m1, 4)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_int32x4, v_min, vmin_vv_i32m1, 4)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_int32x4, v_max, vmax_vv_i32m1, 4)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_float32x4, v_min, vfmin_vv_f32m1, 4)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_float32x4, v_max, vfmax_vv_f32m1, 4)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_float64x2, v_min, vfmin_vv_f64m1, 2)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_float64x2, v_max, vfmax_vv_f64m1, 2)
-
-inline v_float32x4 v_sqrt(const v_float32x4 &x) {
-  return v_float32x4(vfsqrt_v_f32m1(x.val, 4));
-}
-
-inline v_float32x4 v_invsqrt(const v_float32x4 &x) {
-  return v_float32x4(vfrdiv_vf_f32m1(vfsqrt_v_f32m1(x.val, 4), 1, 4));
-}
-
-inline v_float32x4 v_magnitude(const v_float32x4 &a, const v_float32x4 &b) {
-  v_float32x4 x(
-      vfmacc_vv_f32m1(vfmul_vv_f32m1(a.val, a.val, 4), b.val, b.val, 4));
-  return v_sqrt(x);
-}
-
-inline v_float32x4 v_sqr_magnitude(const v_float32x4 &a, const v_float32x4 &b) {
-  return v_float32x4(
-      vfmacc_vv_f32m1(vfmul_vv_f32m1(a.val, a.val, 4), b.val, b.val, 4));
-}
-
-inline v_float32x4 v_fma(const v_float32x4 &a, const v_float32x4 &b,
-                         const v_float32x4 &c) {
-  return v_float32x4(vfmadd_vv_f32m1(a.val, b.val, c.val, 4));
-}
-
-inline v_int32x4 v_fma(const v_int32x4 &a, const v_int32x4 &b,
-                       const v_int32x4 &c) {
-  return v_int32x4(vmadd_vv_i32m1(a.val, b.val, c.val, 4));
-}
-
-inline v_float32x4 v_muladd(const v_float32x4 &a, const v_float32x4 &b,
-                            const v_float32x4 &c) {
-  return v_fma(a, b, c);
-}
-
-inline v_int32x4 v_muladd(const v_int32x4 &a, const v_int32x4 &b,
-                          const v_int32x4 &c) {
-  return v_fma(a, b, c);
-}
-
-inline v_float32x4 v_matmul(const v_float32x4 &v, const v_float32x4 &m0,
-                            const v_float32x4 &m1, const v_float32x4 &m2,
-                            const v_float32x4 &m3) {
-  vfloat32m1_t res = vfmul_vv_f32m1(m0.val, vrgather_vx_f32m1(v.val, 0, 4),
-                                    4); // vmuli_f32(m0.val, v.val, 0);
-  res = vfmacc_vv_f32m1(res, vrgather_vx_f32m1(v.val, 1, 4), m1.val,
-                        4); // vmulai_f32(res, m1.val, v.val, 1);
-  res = vfmacc_vv_f32m1(res, vrgather_vx_f32m1(v.val, 2, 4), m2.val,
-                        4); // vmulai_f32(res, m1.val, v.val, 1);
-  res = vfmacc_vv_f32m1(res, vrgather_vx_f32m1(v.val, 3, 4), m3.val,
-                        4); // vmulai_f32(res, m1.val, v.val, 1);
-  return v_float32x4(res);
-}
-
-inline v_float32x4 v_matmuladd(const v_float32x4 &v, const v_float32x4 &m0,
-                               const v_float32x4 &m1, const v_float32x4 &m2,
-                               const v_float32x4 &a) {
-  vfloat32m1_t res = vfmul_vv_f32m1(m0.val, vrgather_vx_f32m1(v.val, 0, 4),
-                                    4); // vmuli_f32(m0.val, v.val, 0);
-  res = vfmacc_vv_f32m1(res, vrgather_vx_f32m1(v.val, 1, 4), m1.val,
-                        4); // vmulai_f32(res, m1.val, v.val, 1);
-  res = vfmacc_vv_f32m1(res, vrgather_vx_f32m1(v.val, 2, 4), m2.val,
-                        4);            // vmulai_f32(res, m1.val, v.val, 1);
-  res = vfadd_vv_f32m1(res, a.val, 4); // vmulai_f32(res, m1.val, v.val, 1);
-  return v_float32x4(res);
-}
-
-inline v_float64x2 v_sqrt(const v_float64x2 &x) {
-  return v_float64x2(vfsqrt_v_f64m1(x.val, 2));
-}
-
-inline v_float64x2 v_invsqrt(const v_float64x2 &x) {
-  return v_float64x2(vfrdiv_vf_f64m1(vfsqrt_v_f64m1(x.val, 2), 1, 2));
-}
-
-inline v_float64x2 v_magnitude(const v_float64x2 &a, const v_float64x2 &b) {
-  v_float64x2 x(
-      vfmacc_vv_f64m1(vfmul_vv_f64m1(a.val, a.val, 2), b.val, b.val, 2));
-  return v_sqrt(x);
-}
-
-inline v_float64x2 v_sqr_magnitude(const v_float64x2 &a, const v_float64x2 &b) {
-  return v_float64x2(
-      vfmacc_vv_f64m1(vfmul_vv_f64m1(a.val, a.val, 2), b.val, b.val, 2));
-}
-
-inline v_float64x2 v_fma(const v_float64x2 &a, const v_float64x2 &b,
-                         const v_float64x2 &c) {
-  return v_float64x2(vfmadd_vv_f64m1(a.val, b.val, c.val, 2));
-}
-
-inline v_float64x2 v_muladd(const v_float64x2 &a, const v_float64x2 &b,
-                            const v_float64x2 &c) {
-  return v_fma(a, b, c);
-}
-
-#define OPENCV_HAL_IMPL_RISCVV_LOGIC_OPN(_Tpvec, suffix, num)                  \
-  OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_and, _Tpvec, vand_vv_##suffix, num)         \
-  OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_or, _Tpvec, vor_vv_##suffix, num)           \
-  OPENCV_HAL_IMPL_RISCVV_BIN_OPN(v_xor, _Tpvec, vxor_vv_##suffix, num)         \
-  inline _Tpvec v_not(const _Tpvec &a) {                                       \
-    return _Tpvec(vnot_v_##suffix(a.val, num));                                \
-  }
-
-OPENCV_HAL_IMPL_RISCVV_LOGIC_OPN(v_uint8x16, u8m1, 16)
-OPENCV_HAL_IMPL_RISCVV_LOGIC_OPN(v_uint16x8, u16m1, 8)
-OPENCV_HAL_IMPL_RISCVV_LOGIC_OPN(v_uint32x4, u32m1, 4)
-OPENCV_HAL_IMPL_RISCVV_LOGIC_OPN(v_uint64x2, u64m1, 2)
-OPENCV_HAL_IMPL_RISCVV_LOGIC_OPN(v_int8x16, i8m1, 16)
-OPENCV_HAL_IMPL_RISCVV_LOGIC_OPN(v_int16x8, i16m1, 8)
-OPENCV_HAL_IMPL_RISCVV_LOGIC_OPN(v_int32x4, i32m1, 4)
-OPENCV_HAL_IMPL_RISCVV_LOGIC_OPN(v_int64x2, i64m1, 2)
-
-#define OPENCV_HAL_IMPL_RISCVV_FLT_BIT_OP(bin_op, intrin)                      \
-  inline v_float32x4 bin_op(const v_float32x4 &a, const v_float32x4 &b) {      \
-    return v_float32x4(vreinterpret_v_i32m1_f32m1(                             \
-        intrin(vreinterpret_v_f32m1_i32m1(a.val),                              \
-               vreinterpret_v_f32m1_i32m1(b.val), 4)));                        \
-  }
-
-OPENCV_HAL_IMPL_RISCVV_FLT_BIT_OP(v_and, vand_vv_i32m1)
-OPENCV_HAL_IMPL_RISCVV_FLT_BIT_OP(v_or, vor_vv_i32m1)
-OPENCV_HAL_IMPL_RISCVV_FLT_BIT_OP(v_xor, vxor_vv_i32m1)
-
-inline v_float32x4 v_not(const v_float32x4 &a) {
-  return v_float32x4(vreinterpret_v_i32m1_f32m1(
-      vnot_v_i32m1(vreinterpret_v_f32m1_i32m1(a.val), 4)));
-}
-
-#define OPENCV_HAL_IMPL_RISCVV_FLT_64BIT_OP(bin_op, intrin)                    \
-  inline v_float64x2 bin_op(const v_float64x2 &a, const v_float64x2 &b) {      \
-    return v_float64x2(vreinterpret_v_i64m1_f64m1(                             \
-        intrin(vreinterpret_v_f64m1_i64m1(a.val),                              \
-               vreinterpret_v_f64m1_i64m1(b.val), 2)));                        \
-  }
-
-OPENCV_HAL_IMPL_RISCVV_FLT_64BIT_OP(v_and, vand_vv_i64m1)
-OPENCV_HAL_IMPL_RISCVV_FLT_64BIT_OP(v_or, vor_vv_i64m1)
-OPENCV_HAL_IMPL_RISCVV_FLT_64BIT_OP(v_xor, vxor_vv_i64m1)
-
-inline v_float64x2 v_not(const v_float64x2 &a) {
-  return v_float64x2(vreinterpret_v_i64m1_f64m1(
-      vnot_v_i64m1(vreinterpret_v_f64m1_i64m1(a.val), 2)));
-}
-inline v_int16x8 v_mul_hi(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_int16x8(vmulh_vv_i16m1(a.val, b.val, 8));
-}
-inline v_uint16x8 v_mul_hi(const v_uint16x8 &a, const v_uint16x8 &b) {
-  return v_uint16x8(vmulhu_vv_u16m1(a.val, b.val, 8));
-}
-
-//#define OPENCV_HAL_IMPL_RISCVV_ABS(_Tpuvec, _Tpsvec, usuffix, ssuffix) \
-//inline _Tpuvec v_abs(const _Tpsvec& a) {    \
-//    E##xm1_t mask=vmflt_vf_e32xm1_f32m1(x.val, 0.0, 4);
-
-// OPENCV_HAL_IMPL_RISCVV_ABS(v_uint8x16, v_int8x16, u8, s8)
-// OPENCV_HAL_IMPL_RISCVV_ABS(v_uint16x8, v_int16x8, u16, s16)
-// OPENCV_HAL_IMPL_RISCVV_ABS(v_uint32x4, v_int32x4, u32, s32)
-
-inline v_uint32x4 v_abs(v_int32x4 x) {
-  vbool32_t mask = vmslt_vx_i32m1_b32(x.val, 0, 4);
-  return v_uint32x4(
-      vreinterpret_v_i32m1_u32m1(vrsub_vx_i32m1_m(mask, x.val, x.val, 0, 4)));
-}
-
-inline v_uint16x8 v_abs(v_int16x8 x) {
-  vbool16_t mask = vmslt_vx_i16m1_b16(x.val, 0, 8);
-  return v_uint16x8(
-      vreinterpret_v_i16m1_u16m1(vrsub_vx_i16m1_m(mask, x.val, x.val, 0, 8)));
-}
-
-inline v_uint8x16 v_abs(v_int8x16 x) {
-  vbool8_t mask = vmslt_vx_i8m1_b8(x.val, 0, 16);
-  return v_uint8x16(
-      vreinterpret_v_i8m1_u8m1(vrsub_vx_i8m1_m(mask, x.val, x.val, 0, 16)));
-}
-
-inline v_float32x4 v_abs(v_float32x4 x) {
-  return (v_float32x4)vfsgnjx_vv_f32m1(x.val, x.val, 4);
-}
-
-inline v_float64x2 v_abs(v_float64x2 x) {
-  return (v_float64x2)vfsgnjx_vv_f64m1(x.val, x.val, 2);
-}
-
-inline v_float32x4 v_absdiff(const v_float32x4 &a, const v_float32x4 &b) {
-  vfloat32m1_t ret = vfsub_vv_f32m1(a.val, b.val, 4);
-  return (v_float32x4)vfsgnjx_vv_f32m1(ret, ret, 4);
-}
-
-inline v_float64x2 v_absdiff(const v_float64x2 &a, const v_float64x2 &b) {
-  vfloat64m1_t ret = vfsub_vv_f64m1(a.val, b.val, 2);
-  return (v_float64x2)vfsgnjx_vv_f64m1(ret, ret, 2);
-}
-
-#define OPENCV_HAL_IMPL_RISCVV_ABSDIFF_U(bit, num)                             \
-  inline v_uint##bit##x##num v_absdiff(v_uint##bit##x##num a,                  \
-                                       v_uint##bit##x##num b) {                \
-    vuint##bit##m1_t vmax = vmaxu_vv_u##bit##m1(a.val, b.val, num);            \
-    vuint##bit##m1_t vmin = vminu_vv_u##bit##m1(a.val, b.val, num);            \
-    return v_uint##bit##x##num(vsub_vv_u##bit##m1(vmax, vmin, num));           \
-  }
-
-OPENCV_HAL_IMPL_RISCVV_ABSDIFF_U(8, 16)
-OPENCV_HAL_IMPL_RISCVV_ABSDIFF_U(16, 8)
-OPENCV_HAL_IMPL_RISCVV_ABSDIFF_U(32, 4)
-
-/** Saturating absolute difference **/
-inline v_int8x16 v_absdiffs(v_int8x16 a, v_int8x16 b) {
-  vint8m1_t vmax = vmax_vv_i8m1(a.val, b.val, 16);
-  vint8m1_t vmin = vmin_vv_i8m1(a.val, b.val, 16);
-  return v_int8x16(vssub_vv_i8m1(vmax, vmin, 16));
-}
-inline v_int16x8 v_absdiffs(v_int16x8 a, v_int16x8 b) {
-  vint16m1_t vmax = vmax_vv_i16m1(a.val, b.val, 8);
-  vint16m1_t vmin = vmin_vv_i16m1(a.val, b.val, 8);
-  return v_int16x8(vssub_vv_i16m1(vmax, vmin, 8));
-}
-
-#define OPENCV_HAL_IMPL_RISCVV_ABSDIFF(_Tpvec, _Tpv, num)                      \
-  inline v_uint##_Tpvec v_absdiff(v_int##_Tpvec a, v_int##_Tpvec b) {          \
-    vint##_Tpv##_t max = vmax_vv_i##_Tpv(a.val, b.val, num);                   \
-    vint##_Tpv##_t min = vmin_vv_i##_Tpv(a.val, b.val, num);                   \
-    return v_uint##_Tpvec(                                                     \
-        vreinterpret_v_i##_Tpv##_u##_Tpv(vsub_vv_i##_Tpv(max, min, num)));     \
-  }
-
-OPENCV_HAL_IMPL_RISCVV_ABSDIFF(8x16, 8m1, 16)
-OPENCV_HAL_IMPL_RISCVV_ABSDIFF(16x8, 16m1, 8)
-OPENCV_HAL_IMPL_RISCVV_ABSDIFF(32x4, 32m1, 4)
-
-//  Multiply and expand
-inline void v_mul_expand(const v_int8x16 &a, const v_int8x16 &b, v_int16x8 &c,
-                         v_int16x8 &d) {
-  vint16m2_t res = vundefined_i16m2();
-  res = vwmul_vv_i16m2(a.val, b.val, 16);
-  c.val = vget_v_i16m2_i16m1(res, 0);
-  d.val = vget_v_i16m2_i16m1(res, 1);
-}
-
-inline void v_mul_expand(const v_uint8x16 &a, const v_uint8x16 &b,
-                         v_uint16x8 &c, v_uint16x8 &d) {
-  vuint16m2_t res = vundefined_u16m2();
-  res = vwmulu_vv_u16m2(a.val, b.val, 16);
-  c.val = vget_v_u16m2_u16m1(res, 0);
-  d.val = vget_v_u16m2_u16m1(res, 1);
-}
-
-inline void v_mul_expand(const v_int16x8 &a, const v_int16x8 &b, v_int32x4 &c,
-                         v_int32x4 &d) {
-  vint32m2_t res = vundefined_i32m2();
-  res = vwmul_vv_i32m2(a.val, b.val, 8);
-  c.val = vget_v_i32m2_i32m1(res, 0);
-  d.val = vget_v_i32m2_i32m1(res, 1);
-}
-
-inline void v_mul_expand(const v_uint16x8 &a, const v_uint16x8 &b,
-                         v_uint32x4 &c, v_uint32x4 &d) {
-  vuint32m2_t res = vundefined_u32m2();
-  res = vwmulu_vv_u32m2(a.val, b.val, 8);
-  c.val = vget_v_u32m2_u32m1(res, 0);
-  d.val = vget_v_u32m2_u32m1(res, 1);
-}
-
-inline void v_mul_expand(const v_int32x4 &a, const v_int32x4 &b, v_int64x2 &c,
-                         v_int64x2 &d) {
-  vint64m2_t res = vundefined_i64m2();
-  res = vwmul_vv_i64m2(a.val, b.val, 4);
-  c.val = vget_v_i64m2_i64m1(res, 0);
-  d.val = vget_v_i64m2_i64m1(res, 1);
-}
-
-inline void v_mul_expand(const v_uint32x4 &a, const v_uint32x4 &b,
-                         v_uint64x2 &c, v_uint64x2 &d) {
-  vuint64m2_t res = vundefined_u64m2();
-  res = vwmulu_vv_u64m2(a.val, b.val, 4);
-  c.val = vget_v_u64m2_u64m1(res, 0);
-  d.val = vget_v_u64m2_u64m1(res, 1);
-}
-
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_uint8x16, v_add_wrap, vadd_vv_u8m1, 16)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_int8x16, v_add_wrap, vadd_vv_i8m1, 16)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_uint16x8, v_add_wrap, vadd_vv_u16m1, 8)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_int16x8, v_add_wrap, vadd_vv_i16m1, 8)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_uint8x16, v_sub_wrap, vsub_vv_u8m1, 16)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_int8x16, v_sub_wrap, vsub_vv_i8m1, 16)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_uint16x8, v_sub_wrap, vsub_vv_u16m1, 8)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_int16x8, v_sub_wrap, vsub_vv_i16m1, 8)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_uint8x16, v_mul_wrap, vmul_vv_u8m1, 16)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_int8x16, v_mul_wrap, vmul_vv_i8m1, 16)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_uint16x8, v_mul_wrap, vmul_vv_u16m1, 8)
-OPENCV_HAL_IMPL_RISCVV_BINN_FUNC(v_int16x8, v_mul_wrap, vmul_vv_i16m1, 8)
-//////// Dot Product ////////
-// 16 >> 32
-inline v_int32x4 v_dotprod(const v_int16x8 &a, const v_int16x8 &b) {
-  vuint32m2_t vindex = vundefined_u32m2();
-  vuint32m1_t vindex0 = vid_v_u32m1(4);
-  vindex0 = vsll_vx_u32m1(vindex0, 1, 4);
-  vindex = vset_v_u32m1_u32m2(vindex, 0, vindex0);
-  vindex = vset_v_u32m1_u32m2(vindex, 1, vadd_vx_u32m1(vindex0, 1, 4));
-  vint32m2_t res = vundefined_i32m2();
-  res = vwmul_vv_i32m2(a.val, b.val, 8);
-  res = vrgather_vv_i32m2(res, vindex, 8);
-  return v_int32x4(
-      vadd_vv_i32m1(vget_v_i32m2_i32m1(res, 0), vget_v_i32m2_i32m1(res, 1), 4));
-}
-inline v_int32x4 v_dotprod(const v_int16x8 &a, const v_int16x8 &b,
-                           const v_int32x4 &c) {
-  vuint32m2_t vindex = vundefined_u32m2();
-  vuint32m1_t vindex0 = vid_v_u32m1(4);
-  vindex0 = vsll_vx_u32m1(vindex0, 1, 4);
-  vindex = vset_v_u32m1_u32m2(vindex, 0, vindex0);
-  vindex = vset_v_u32m1_u32m2(vindex, 1, vadd_vx_u32m1(vindex0, 1, 4));
-  vint32m2_t res = vundefined_i32m2();
-  res = vwmul_vv_i32m2(a.val, b.val, 8);
-  res = vrgather_vv_i32m2(res, vindex, 8);
-  return v_int32x4(vadd_vv_i32m1(
-      vadd_vv_i32m1(vget_v_i32m2_i32m1(res, 0), vget_v_i32m2_i32m1(res, 1), 4),
-      c.val, 4));
-}
-
-// 32 >> 64
-inline v_int64x2 v_dotprod(const v_int32x4 &a, const v_int32x4 &b) {
-  vuint64m2_t vindex = vundefined_u64m2();
-  vuint64m1_t vindex0 = vid_v_u64m1(2);
-  vindex0 = vsll_vx_u64m1(vindex0, 1, 2);
-  vindex = vset_v_u64m1_u64m2(vindex, 0, vindex0);
-  vindex = vset_v_u64m1_u64m2(vindex, 1, vadd_vx_u64m1(vindex0, 1, 2));
-  vint64m2_t res = vundefined_i64m2();
-  res = vwmul_vv_i64m2(a.val, b.val, 4);
-  res = vrgather_vv_i64m2(res, vindex, 4);
-  return v_int64x2(
-      vadd_vv_i64m1(vget_v_i64m2_i64m1(res, 0), vget_v_i64m2_i64m1(res, 1), 2));
-}
-inline v_int64x2 v_dotprod(const v_int32x4 &a, const v_int32x4 &b,
-                           const v_int64x2 &c) {
-  vuint64m2_t vindex = vundefined_u64m2();
-  vuint64m1_t vindex0 = vid_v_u64m1(2);
-  vindex0 = vsll_vx_u64m1(vindex0, 1, 2);
-  vindex = vset_v_u64m1_u64m2(vindex, 0, vindex0);
-  vindex = vset_v_u64m1_u64m2(vindex, 1, vadd_vx_u64m1(vindex0, 1, 2));
-  vint64m2_t res = vundefined_i64m2();
-  res = vwmul_vv_i64m2(a.val, b.val, 4);
-  res = vrgather_vv_i64m2(res, vindex, 4);
-  return v_int64x2(vadd_vv_i64m1(
-      vadd_vv_i64m1(vget_v_i64m2_i64m1(res, 0), vget_v_i64m2_i64m1(res, 1), 2),
-      c.val, 2));
-}
-
-// 8 >> 32
-inline v_uint32x4 v_dotprod_expand(const v_uint8x16 &a, const v_uint8x16 &b) {
-  vuint32m4_t vindex32 = vundefined_u32m4();
-  vuint32m1_t vindex0 = vid_v_u32m1(4);
-  vindex0 = vsll_vx_u32m1(vindex0, 2, 4);
-  vindex32 = vset_v_u32m1_u32m4(vindex32, 0, vindex0);
-  vindex32 = vset_v_u32m1_u32m4(vindex32, 1, vadd_vx_u32m1(vindex0, 1, 4));
-  vindex32 = vset_v_u32m1_u32m4(vindex32, 2, vadd_vx_u32m1(vindex0, 2, 4));
-  vindex32 = vset_v_u32m1_u32m4(vindex32, 3, vadd_vx_u32m1(vindex0, 3, 4));
-  vuint16m2_t vindex = vnsrl_wx_u16m2(vindex32, 0, 16);
-  vuint16m2_t v1 = vundefined_u16m2();
-  vuint32m2_t v2 = vundefined_u32m2();
-  v1 = vwmulu_vv_u16m2(a.val, b.val, 16);
-  v1 = vrgather_vv_u16m2(v1, vindex, 16);
-  v2 = vwaddu_vv_u32m2(vget_v_u16m2_u16m1(v1, 0), vget_v_u16m2_u16m1(v1, 1), 8);
-  return v_uint32x4(
-      vadd_vv_u32m1(vget_v_u32m2_u32m1(v2, 0), vget_v_u32m2_u32m1(v2, 1), 4));
-}
-
-inline v_uint32x4 v_dotprod_expand(const v_uint8x16 &a, const v_uint8x16 &b,
-                                   const v_uint32x4 &c) {
-  vuint32m4_t vindex32 = vundefined_u32m4();
-  vuint32m1_t vindex0 = vid_v_u32m1(4);
-  vindex0 = vsll_vx_u32m1(vindex0, 2, 4);
-  vindex32 = vset_v_u32m1_u32m4(vindex32, 0, vindex0);
-  vindex32 = vset_v_u32m1_u32m4(vindex32, 1, vadd_vx_u32m1(vindex0, 1, 4));
-  vindex32 = vset_v_u32m1_u32m4(vindex32, 2, vadd_vx_u32m1(vindex0, 2, 4));
-  vindex32 = vset_v_u32m1_u32m4(vindex32, 3, vadd_vx_u32m1(vindex0, 3, 4));
-  vuint16m2_t vindex = vnsrl_wx_u16m2(vindex32, 0, 16);
-  vuint16m2_t v1 = vundefined_u16m2();
-  vuint32m2_t v2 = vundefined_u32m2();
-  v1 = vwmulu_vv_u16m2(a.val, b.val, 16);
-  v1 = vrgather_vv_u16m2(v1, vindex, 16);
-  v2 = vwaddu_vv_u32m2(vget_v_u16m2_u16m1(v1, 0), vget_v_u16m2_u16m1(v1, 1), 8);
-  return v_uint32x4(vadd_vv_u32m1(
-      vadd_vv_u32m1(vget_v_u32m2_u32m1(v2, 0), vget_v_u32m2_u32m1(v2, 1), 4),
-      c.val, 4));
-}
-
-inline v_int32x4 v_dotprod_expand(const v_int8x16 &a, const v_int8x16 &b) {
-  vuint32m4_t vindex32 = vundefined_u32m4();
-  vuint32m1_t vindex0 = vid_v_u32m1(4);
-  vindex0 = vsll_vx_u32m1(vindex0, 2, 4);
-  vindex32 = vset_v_u32m1_u32m4(vindex32, 0, vindex0);
-  vindex32 = vset_v_u32m1_u32m4(vindex32, 1, vadd_vx_u32m1(vindex0, 1, 4));
-  vindex32 = vset_v_u32m1_u32m4(vindex32, 2, vadd_vx_u32m1(vindex0, 2, 4));
-  vindex32 = vset_v_u32m1_u32m4(vindex32, 3, vadd_vx_u32m1(vindex0, 3, 4));
-  vuint16m2_t vindex = vnsrl_wx_u16m2(vindex32, 0, 16);
-  vint16m2_t v1 = vundefined_i16m2();
-  vint32m2_t v2 = vundefined_i32m2();
-  v1 = vwmul_vv_i16m2(a.val, b.val, 16);
-  v1 = vrgather_vv_i16m2(v1, vindex, 16);
-  v2 = vwadd_vv_i32m2(vget_v_i16m2_i16m1(v1, 0), vget_v_i16m2_i16m1(v1, 1), 8);
-  return v_int32x4(
-      vadd_vv_i32m1(vget_v_i32m2_i32m1(v2, 0), vget_v_i32m2_i32m1(v2, 1), 4));
-}
-
-inline v_int32x4 v_dotprod_expand(const v_int8x16 &a, const v_int8x16 &b,
-                                  const v_int32x4 &c) {
-  vuint32m4_t vindex32 = vundefined_u32m4();
-  vuint32m1_t vindex0 = vid_v_u32m1(4);
-  vindex0 = vsll_vx_u32m1(vindex0, 2, 4);
-  vindex32 = vset_v_u32m1_u32m4(vindex32, 0, vindex0);
-  vindex32 = vset_v_u32m1_u32m4(vindex32, 1, vadd_vx_u32m1(vindex0, 1, 4));
-  vindex32 = vset_v_u32m1_u32m4(vindex32, 2, vadd_vx_u32m1(vindex0, 2, 4));
-  vindex32 = vset_v_u32m1_u32m4(vindex32, 3, vadd_vx_u32m1(vindex0, 3, 4));
-  vuint16m2_t vindex = vnsrl_wx_u16m2(vindex32, 0, 16);
-  vint16m2_t v1 = vundefined_i16m2();
-  vint32m2_t v2 = vundefined_i32m2();
-  v1 = vwmul_vv_i16m2(a.val, b.val, 16);
-  v1 = vrgather_vv_i16m2(v1, vindex, 16);
-  v2 = vwadd_vv_i32m2(vget_v_i16m2_i16m1(v1, 0), vget_v_i16m2_i16m1(v1, 1), 8);
-  return v_int32x4(vadd_vv_i32m1(
-      vadd_vv_i32m1(vget_v_i32m2_i32m1(v2, 0), vget_v_i32m2_i32m1(v2, 1), 4),
-      c.val, 4));
-}
-
-inline v_uint64x2 v_dotprod_expand(const v_uint16x8 &a, const v_uint16x8 &b) {
-  vuint64m4_t vindex64 = vundefined_u64m4();
-  vuint64m1_t vindex0 = vid_v_u64m1(2);
-  vindex0 = vsll_vx_u64m1(vindex0, 2, 2);
-  vindex64 = vset_v_u64m1_u64m4(vindex64, 0, vindex0);
-  vindex64 = vset_v_u64m1_u64m4(vindex64, 1, vadd_vx_u64m1(vindex0, 1, 2));
-  vindex64 = vset_v_u64m1_u64m4(vindex64, 2, vadd_vx_u64m1(vindex0, 2, 2));
-  vindex64 = vset_v_u64m1_u64m4(vindex64, 3, vadd_vx_u64m1(vindex0, 3, 2));
-  vuint32m2_t vindex = vnsrl_wx_u32m2(vindex64, 0, 8);
-  vuint32m2_t v1 = vundefined_u32m2();
-  vuint64m2_t v2 = vundefined_u64m2();
-  v1 = vwmulu_vv_u32m2(a.val, b.val, 8);
-  v1 = vrgather_vv_u32m2(v1, vindex, 8);
-  v2 = vwaddu_vv_u64m2(vget_v_u32m2_u32m1(v1, 0), vget_v_u32m2_u32m1(v1, 1), 4);
-  return v_uint64x2(
-      vadd_vv_u64m1(vget_v_u64m2_u64m1(v2, 0), vget_v_u64m2_u64m1(v2, 1), 2));
-}
-
-inline v_uint64x2 v_dotprod_expand(const v_uint16x8 &a, const v_uint16x8 &b,
-                                   const v_uint64x2 &c) {
-  vuint64m4_t vindex64 = vundefined_u64m4();
-  vuint64m1_t vindex0 = vid_v_u64m1(2);
-  vindex0 = vsll_vx_u64m1(vindex0, 2, 2);
-  vindex64 = vset_v_u64m1_u64m4(vindex64, 0, vindex0);
-  vindex64 = vset_v_u64m1_u64m4(vindex64, 1, vadd_vx_u64m1(vindex0, 1, 2));
-  vindex64 = vset_v_u64m1_u64m4(vindex64, 2, vadd_vx_u64m1(vindex0, 2, 2));
-  vindex64 = vset_v_u64m1_u64m4(vindex64, 3, vadd_vx_u64m1(vindex0, 3, 2));
-  vuint32m2_t vindex = vnsrl_wx_u32m2(vindex64, 0, 8);
-  vuint32m2_t v1 = vundefined_u32m2();
-  vuint64m2_t v2 = vundefined_u64m2();
-  v1 = vwmulu_vv_u32m2(a.val, b.val, 8);
-  v1 = vrgather_vv_u32m2(v1, vindex, 8);
-  v2 = vwaddu_vv_u64m2(vget_v_u32m2_u32m1(v1, 0), vget_v_u32m2_u32m1(v1, 1), 4);
-  return v_uint64x2(vadd_vv_u64m1(
-      vadd_vv_u64m1(vget_v_u64m2_u64m1(v2, 0), vget_v_u64m2_u64m1(v2, 1), 2),
-      c.val, 2));
-}
-
-inline v_int64x2 v_dotprod_expand(const v_int16x8 &a, const v_int16x8 &b) {
-  vuint64m4_t vindex64 = vundefined_u64m4();
-  vuint64m1_t vindex0 = vid_v_u64m1(2);
-  vindex0 = vsll_vx_u64m1(vindex0, 2, 2);
-  vindex64 = vset_v_u64m1_u64m4(vindex64, 0, vindex0);
-  vindex64 = vset_v_u64m1_u64m4(vindex64, 1, vadd_vx_u64m1(vindex0, 1, 2));
-  vindex64 = vset_v_u64m1_u64m4(vindex64, 2, vadd_vx_u64m1(vindex0, 2, 2));
-  vindex64 = vset_v_u64m1_u64m4(vindex64, 3, vadd_vx_u64m1(vindex0, 3, 2));
-  vuint32m2_t vindex = vnsrl_wx_u32m2(vindex64, 0, 8);
-  vint32m2_t v1 = vundefined_i32m2();
-  vint64m2_t v2 = vundefined_i64m2();
-  v1 = vwmul_vv_i32m2(a.val, b.val, 8);
-  v1 = vrgather_vv_i32m2(v1, vindex, 8);
-  v2 = vwadd_vv_i64m2(vget_v_i32m2_i32m1(v1, 0), vget_v_i32m2_i32m1(v1, 1), 4);
-  return v_int64x2(
-      vadd_vv_i64m1(vget_v_i64m2_i64m1(v2, 0), vget_v_i64m2_i64m1(v2, 1), 2));
-}
-
-inline v_int64x2 v_dotprod_expand(const v_int16x8 &a, const v_int16x8 &b,
-                                  const v_int64x2 &c) {
-  vuint64m4_t vindex64 = vundefined_u64m4();
-  vuint64m1_t vindex0 = vid_v_u64m1(2);
-  vindex0 = vsll_vx_u64m1(vindex0, 2, 2);
-  vindex64 = vset_v_u64m1_u64m4(vindex64, 0, vindex0);
-  vindex64 = vset_v_u64m1_u64m4(vindex64, 1, vadd_vx_u64m1(vindex0, 1, 2));
-  vindex64 = vset_v_u64m1_u64m4(vindex64, 2, vadd_vx_u64m1(vindex0, 2, 2));
-  vindex64 = vset_v_u64m1_u64m4(vindex64, 3, vadd_vx_u64m1(vindex0, 3, 2));
-  vuint32m2_t vindex = vnsrl_wx_u32m2(vindex64, 0, 8);
-  vint32m2_t v1 = vundefined_i32m2();
-  vint64m2_t v2 = vundefined_i64m2();
-  v1 = vwmul_vv_i32m2(a.val, b.val, 8);
-  v1 = vrgather_vv_i32m2(v1, vindex, 8);
-  v2 = vwadd_vv_i64m2(vget_v_i32m2_i32m1(v1, 0), vget_v_i32m2_i32m1(v1, 1), 4);
-  return v_int64x2(vadd_vv_i64m1(
-      vadd_vv_i64m1(vget_v_i64m2_i64m1(v2, 0), vget_v_i64m2_i64m1(v2, 1), 2),
-      c.val, 2));
-}
-
-//////// Fast Dot Product ////////
-// 16 >> 32
-inline v_int32x4 v_dotprod_fast(const v_int16x8 &a, const v_int16x8 &b) {
-  vint32m2_t v1 = vundefined_i32m2();
-  v1 = vwmul_vv_i32m2(a.val, b.val, 8);
-  return v_int32x4(
-      vadd_vv_i32m1(vget_v_i32m2_i32m1(v1, 0), vget_v_i32m2_i32m1(v1, 1), 4));
-}
-
-inline v_int32x4 v_dotprod_fast(const v_int16x8 &a, const v_int16x8 &b,
-                                const v_int32x4 &c) {
-  vint32m2_t v1 = vundefined_i32m2();
-  v1 = vwmul_vv_i32m2(a.val, b.val, 8);
-  return v_int32x4(vadd_vv_i32m1(
-      vadd_vv_i32m1(vget_v_i32m2_i32m1(v1, 0), vget_v_i32m2_i32m1(v1, 1), 4),
-      c.val, 4));
-}
-
-// 32 >> 64
-inline v_int64x2 v_dotprod_fast(const v_int32x4 &a, const v_int32x4 &b) {
-  vint64m2_t v1 = vundefined_i64m2();
-  v1 = vwmul_vv_i64m2(a.val, b.val, 4);
-  return v_int64x2(
-      vadd_vv_i64m1(vget_v_i64m2_i64m1(v1, 0), vget_v_i64m2_i64m1(v1, 1), 2));
-}
-inline v_int64x2 v_dotprod_fast(const v_int32x4 &a, const v_int32x4 &b,
-                                const v_int64x2 &c) {
-  vint64m2_t v1 = vundefined_i64m2();
-  v1 = vwmul_vv_i64m2(a.val, b.val, 8);
-  return v_int64x2(vadd_vv_i64m1(
-      vadd_vv_i64m1(vget_v_i64m2_i64m1(v1, 0), vget_v_i64m2_i64m1(v1, 1), 4),
-      c.val, 4));
-}
-
-// 8 >> 32
-inline v_uint32x4 v_dotprod_expand_fast(const v_uint8x16 &a,
-                                        const v_uint8x16 &b) {
-  vuint16m2_t v1 = vundefined_u16m2();
-  vuint32m2_t v2 = vundefined_u32m2();
-  v1 = vwmulu_vv_u16m2(a.val, b.val, 16);
-  v2 = vwaddu_vv_u32m2(vget_v_u16m2_u16m1(v1, 0), vget_v_u16m2_u16m1(v1, 1), 8);
-  return v_uint32x4(
-      vadd_vv_u32m1(vget_v_u32m2_u32m1(v2, 0), vget_v_u32m2_u32m1(v2, 1), 4));
-}
-
-inline v_uint32x4 v_dotprod_expand_fast(const v_uint8x16 &a,
-                                        const v_uint8x16 &b,
-                                        const v_uint32x4 &c) {
-  vuint16m2_t v1 = vundefined_u16m2();
-  vuint32m2_t v2 = vundefined_u32m2();
-  v1 = vwmulu_vv_u16m2(a.val, b.val, 16);
-  v2 = vwaddu_vv_u32m2(vget_v_u16m2_u16m1(v1, 0), vget_v_u16m2_u16m1(v1, 1), 8);
-  return v_uint32x4(vadd_vv_u32m1(
-      vadd_vv_u32m1(vget_v_u32m2_u32m1(v2, 0), vget_v_u32m2_u32m1(v2, 1), 4),
-      c.val, 4));
-}
-
-inline v_int32x4 v_dotprod_expand_fast(const v_int8x16 &a, const v_int8x16 &b) {
-  vint16m2_t v1 = vundefined_i16m2();
-  vint32m2_t v2 = vundefined_i32m2();
-  v1 = vwmul_vv_i16m2(a.val, b.val, 16);
-  v2 = vwadd_vv_i32m2(vget_v_i16m2_i16m1(v1, 0), vget_v_i16m2_i16m1(v1, 1), 8);
-  return v_int32x4(
-      vadd_vv_i32m1(vget_v_i32m2_i32m1(v2, 0), vget_v_i32m2_i32m1(v2, 1), 4));
-}
-inline v_int32x4 v_dotprod_expand_fast(const v_int8x16 &a, const v_int8x16 &b,
-                                       const v_int32x4 &c) {
-  vint16m2_t v1 = vundefined_i16m2();
-  vint32m2_t v2 = vundefined_i32m2();
-  v1 = vwmul_vv_i16m2(a.val, b.val, 16);
-  v2 = vwadd_vv_i32m2(vget_v_i16m2_i16m1(v1, 0), vget_v_i16m2_i16m1(v1, 1), 8);
-  return v_int32x4(vadd_vv_i32m1(
-      vadd_vv_i32m1(vget_v_i32m2_i32m1(v2, 0), vget_v_i32m2_i32m1(v2, 1), 4),
-      c.val, 4));
-}
-
-// 16 >> 64
-inline v_uint64x2 v_dotprod_expand_fast(const v_uint16x8 &a,
-                                        const v_uint16x8 &b) {
-  vuint32m2_t v1 = vundefined_u32m2();
-  vuint64m2_t v2 = vundefined_u64m2();
-  v1 = vwmulu_vv_u32m2(a.val, b.val, 8);
-  v2 = vwaddu_vv_u64m2(vget_v_u32m2_u32m1(v1, 0), vget_v_u32m2_u32m1(v1, 1), 4);
-  return v_uint64x2(
-      vadd_vv_u64m1(vget_v_u64m2_u64m1(v2, 0), vget_v_u64m2_u64m1(v2, 1), 2));
-}
-inline v_uint64x2 v_dotprod_expand_fast(const v_uint16x8 &a,
-                                        const v_uint16x8 &b,
-                                        const v_uint64x2 &c) {
-  vuint32m2_t v1 = vundefined_u32m2();
-  vuint64m2_t v2 = vundefined_u64m2();
-  v1 = vwmulu_vv_u32m2(a.val, b.val, 8);
-  v2 = vwaddu_vv_u64m2(vget_v_u32m2_u32m1(v1, 0), vget_v_u32m2_u32m1(v1, 1), 4);
-  return v_uint64x2(vadd_vv_u64m1(
-      vadd_vv_u64m1(vget_v_u64m2_u64m1(v2, 0), vget_v_u64m2_u64m1(v2, 1), 2),
-      c.val, 2));
-}
-
-inline v_int64x2 v_dotprod_expand_fast(const v_int16x8 &a, const v_int16x8 &b) {
-  vint32m2_t v1 = vundefined_i32m2();
-  vint64m2_t v2 = vundefined_i64m2();
-  v1 = vwmul_vv_i32m2(a.val, b.val, 8);
-  v2 = vwadd_vv_i64m2(vget_v_i32m2_i32m1(v1, 0), vget_v_i32m2_i32m1(v1, 1), 4);
-  return v_int64x2(
-      vadd_vv_i64m1(vget_v_i64m2_i64m1(v2, 0), vget_v_i64m2_i64m1(v2, 1), 2));
-}
-inline v_int64x2 v_dotprod_expand_fast(const v_int16x8 &a, const v_int16x8 &b,
-                                       const v_int64x2 &c) {
-  vint32m2_t v1 = vundefined_i32m2();
-  vint64m2_t v2 = vundefined_i64m2();
-  v1 = vwmul_vv_i32m2(a.val, b.val, 8);
-  v2 = vwadd_vv_i64m2(vget_v_i32m2_i32m1(v1, 0), vget_v_i32m2_i32m1(v1, 1), 4);
-  return v_int64x2(vadd_vv_i64m1(
-      vadd_vv_i64m1(vget_v_i64m2_i64m1(v2, 0), vget_v_i64m2_i64m1(v2, 1), 2),
-      c.val, 2));
-}
-
-#define OPENCV_HAL_IMPL_RISCVV_REDUCE_OP_W(_Tpvec, _Tpvec2, len, scalartype,   \
-                                           func, intrin, num)                  \
-  inline scalartype v_reduce_##func(const v_##_Tpvec##x##num &a) {             \
-    v##_Tpvec2##m1_t val = vmv_v_x_##len##m1(0, num);                          \
-    val = intrin(val, a.val, val, num);                                        \
-    return vmv_x_s_##len##m1_##len(val);                                       \
-  }
-
-#define OPENCV_HAL_IMPL_RISCVV_REDUCE_OP_(_Tpvec, _Tpvec2, scalartype, func,   \
-                                          funcu, num, scalerfunc)              \
-  inline scalartype v_reduce_##func(const v_##_Tpvec##x##num &a) {             \
-    v##_Tpvec##m1_t val = vundefined_##_Tpvec2##m1();                          \
-    val = v##funcu##_vs_##_Tpvec2##m1_##_Tpvec2##m1(val, a.val, a.val, num);   \
-    return scalerfunc(val);                                                    \
-  }
-OPENCV_HAL_IMPL_RISCVV_REDUCE_OP_W(int8, int16, i16, int, sum,
-                                   vwredsum_vs_i8m1_i16m1, 16)
-OPENCV_HAL_IMPL_RISCVV_REDUCE_OP_W(int16, int32, i32, int, sum,
-                                   vwredsum_vs_i16m1_i32m1, 8)
-OPENCV_HAL_IMPL_RISCVV_REDUCE_OP_W(int32, int64, i64, int, sum,
-                                   vwredsum_vs_i32m1_i64m1, 4)
-OPENCV_HAL_IMPL_RISCVV_REDUCE_OP_W(uint8, uint16, u16, unsigned, sum,
-                                   vwredsumu_vs_u8m1_u16m1, 16)
-OPENCV_HAL_IMPL_RISCVV_REDUCE_OP_W(uint16, uint32, u32, unsigned, sum,
-                                   vwredsumu_vs_u16m1_u32m1, 8)
-OPENCV_HAL_IMPL_RISCVV_REDUCE_OP_W(uint32, uint64, u64, unsigned, sum,
-                                   vwredsumu_vs_u32m1_u64m1, 4)
-inline float v_reduce_sum(const v_float32x4 &a) {
-  vfloat32m1_t val = vfmv_v_f_f32m1(0.0, 4);
-  val = vfredosum_vs_f32m1_f32m1(val, a.val, val, 4);
-  return vfmv_f_s_f32m1_f32(val);
-}
-inline double v_reduce_sum(const v_float64x2 &a) {
-  vfloat64m1_t val = vfmv_v_f_f64m1(0.0, 2);
-  val = vfredosum_vs_f64m1_f64m1(val, a.val, val, 2);
-  return vfmv_f_s_f64m1_f64(val);
-}
-inline uint64 v_reduce_sum(const v_uint64x2 &a) {
-  vuint64m1_t res = vundefined_u64m1();
-  return vmv_x_s_u64m1_u64(
-      vredsum_vs_u64m1_u64m1(res, a.val, vmv_v_x_u64m1(0, 2), 2));
-}
-
-inline int64 v_reduce_sum(const v_int64x2 &a) {
-  vint64m1_t res = vundefined_i64m1();
-  return vmv_x_s_i64m1_i64(
-      vredsum_vs_i64m1_i64m1(res, a.val, vmv_v_x_i64m1(0, 2), 2));
-}
-
-#define OPENCV_HAL_IMPL_RISCVV_REDUCE_OP(func)                                 \
-  OPENCV_HAL_IMPL_RISCVV_REDUCE_OP_(int8, i8, int, func, red##func, 16,        \
-                                    vmv_x_s_i8m1_i8)                           \
-  OPENCV_HAL_IMPL_RISCVV_REDUCE_OP_(int16, i16, int, func, red##func, 8,       \
-                                    vmv_x_s_i16m1_i16)                         \
-  OPENCV_HAL_IMPL_RISCVV_REDUCE_OP_(int32, i32, int, func, red##func, 4,       \
-                                    vmv_x_s_i32m1_i32)                         \
-  OPENCV_HAL_IMPL_RISCVV_REDUCE_OP_(int64, i64, int, func, red##func, 2,       \
-                                    vmv_x_s_i64m1_i64)                         \
-  OPENCV_HAL_IMPL_RISCVV_REDUCE_OP_(uint8, u8, unsigned, func, red##func##u,   \
-                                    16, vmv_x_s_u8m1_u8)                       \
-  OPENCV_HAL_IMPL_RISCVV_REDUCE_OP_(uint16, u16, unsigned, func, red##func##u, \
-                                    8, vmv_x_s_u16m1_u16)                      \
-  OPENCV_HAL_IMPL_RISCVV_REDUCE_OP_(uint32, u32, unsigned, func, red##func##u, \
-                                    4, vmv_x_s_u32m1_u32)                      \
-  OPENCV_HAL_IMPL_RISCVV_REDUCE_OP_(float32, f32, float, func, fred##func, 4,  \
-                                    vfmv_f_s_f32m1_f32)
-OPENCV_HAL_IMPL_RISCVV_REDUCE_OP(max)
-OPENCV_HAL_IMPL_RISCVV_REDUCE_OP(min)
-
-inline v_float32x4 v_reduce_sum4(const v_float32x4 &a, const v_float32x4 &b,
-                                 const v_float32x4 &c, const v_float32x4 &d) {
-  vfloat32m1_t a0 = vfmv_v_f_f32m1(0.0, 4);
-  vfloat32m1_t b0 = vfmv_v_f_f32m1(0.0, 4);
-  vfloat32m1_t c0 = vfmv_v_f_f32m1(0.0, 4);
-  vfloat32m1_t d0 = vfmv_v_f_f32m1(0.0, 4);
-  a0 = vfredosum_vs_f32m1_f32m1(a0, a.val, a0, 4);
-  b0 = vfredosum_vs_f32m1_f32m1(b0, b.val, b0, 4);
-  c0 = vfredosum_vs_f32m1_f32m1(c0, c.val, c0, 4);
-  d0 = vfredosum_vs_f32m1_f32m1(d0, d.val, d0, 4);
-  vfloat32m1_t res;
-  res = vslideup_vx_f32m1(a0, b0, 1, 4);
-  res = vslideup_vx_f32m1(res, c0, 2, 4);
-  res = vslideup_vx_f32m1(res, d0, 3, 4);
-  return v_float32x4(res);
-}
-
-inline float v_reduce_sad(const v_float32x4 &a, const v_float32x4 &b) {
-  vfloat32m1_t a0 = vfmv_v_f_f32m1(0.0, 4);
-  vfloat32m1_t x = vfsub_vv_f32m1(a.val, b.val, 4);
-  vbool32_t mask = vmflt_vf_f32m1_b32(x, 0, 4);
-  vfloat32m1_t val = vfrsub_vf_f32m1_m(mask, x, x, 0, 4);
-  a0 = vfredosum_vs_f32m1_f32m1(a0, val, a0, 4);
-  return vfmv_f_s_f32m1_f32(a0);
-}
-
-#define OPENCV_HAL_IMPL_RISCVV_REDUCE_SAD(_Tpvec, _Tpvec2)                     \
-  inline unsigned v_reduce_sad(const _Tpvec &a, const _Tpvec &b) {             \
-    _Tpvec2 x = v_absdiff(a, b);                                               \
-    return v_reduce_sum(x);                                                    \
-  }
-
-OPENCV_HAL_IMPL_RISCVV_REDUCE_SAD(v_int8x16, v_uint8x16)
-OPENCV_HAL_IMPL_RISCVV_REDUCE_SAD(v_uint8x16, v_uint8x16)
-OPENCV_HAL_IMPL_RISCVV_REDUCE_SAD(v_int16x8, v_uint16x8)
-OPENCV_HAL_IMPL_RISCVV_REDUCE_SAD(v_uint16x8, v_uint16x8)
-OPENCV_HAL_IMPL_RISCVV_REDUCE_SAD(v_int32x4, v_uint32x4)
-OPENCV_HAL_IMPL_RISCVV_REDUCE_SAD(v_uint32x4, v_uint32x4)
-
-#define OPENCV_HAL_IMPL_RISCVV_INT_CMP_OP(_Tpvec, _Tp, _T, num, uv)            \
-  inline _Tpvec v_eq(const _Tpvec &a, const _Tpvec &b) {                       \
-    vbool##_T##_t mask = vmseq_vv_##_Tp##_b##_T(a.val, b.val, num);            \
-    return _Tpvec(vmerge_vxm_##_Tp(mask, vmv_v_x_##_Tp(0, num), -1, num));     \
-  }                                                                            \
-  inline _Tpvec v_ne(const _Tpvec &a, const _Tpvec &b) {                       \
-    vbool##_T##_t mask = vmsne_vv_##_Tp##_b##_T(a.val, b.val, num);            \
-    return _Tpvec(vmerge_vxm_##_Tp(mask, vmv_v_x_##_Tp(0, num), -1, num));     \
-  }                                                                            \
-  inline _Tpvec v_lt(const _Tpvec &a, const _Tpvec &b) {                       \
-    vbool##_T##_t mask = vmslt##uv##_Tp##_b##_T(a.val, b.val, num);            \
-    return _Tpvec(vmerge_vxm_##_Tp(mask, vmv_v_x_##_Tp(0, num), -1, num));     \
-  }                                                                            \
-  inline _Tpvec v_gt(const _Tpvec &a, const _Tpvec &b) {                       \
-    vbool##_T##_t mask = vmslt##uv##_Tp##_b##_T(b.val, a.val, num);            \
-    return _Tpvec(vmerge_vxm_##_Tp(mask, vmv_v_x_##_Tp(0, num), -1, num));     \
-  }                                                                            \
-  inline _Tpvec v_le(const _Tpvec &a, const _Tpvec &b) {                       \
-    vbool##_T##_t mask = vmsle##uv##_Tp##_b##_T(a.val, b.val, num);            \
-    return _Tpvec(vmerge_vxm_##_Tp(mask, vmv_v_x_##_Tp(0, num), -1, num));     \
-  }                                                                            \
-  inline _Tpvec v_ge(const _Tpvec &a, const _Tpvec &b) {                       \
-    vbool##_T##_t mask = vmsle##uv##_Tp##_b##_T(b.val, a.val, num);            \
-    return _Tpvec(vmerge_vxm_##_Tp(mask, vmv_v_x_##_Tp(0, num), -1, num));     \
-  }
-
-OPENCV_HAL_IMPL_RISCVV_INT_CMP_OP(v_int8x16, i8m1, 8, 16, _vv_)
-OPENCV_HAL_IMPL_RISCVV_INT_CMP_OP(v_int16x8, i16m1, 16, 8, _vv_)
-OPENCV_HAL_IMPL_RISCVV_INT_CMP_OP(v_int32x4, i32m1, 32, 4, _vv_)
-OPENCV_HAL_IMPL_RISCVV_INT_CMP_OP(v_int64x2, i64m1, 64, 2, _vv_)
-OPENCV_HAL_IMPL_RISCVV_INT_CMP_OP(v_uint8x16, u8m1, 8, 16, u_vv_)
-OPENCV_HAL_IMPL_RISCVV_INT_CMP_OP(v_uint16x8, u16m1, 16, 8, u_vv_)
-OPENCV_HAL_IMPL_RISCVV_INT_CMP_OP(v_uint32x4, u32m1, 32, 4, u_vv_)
-OPENCV_HAL_IMPL_RISCVV_INT_CMP_OP(v_uint64x2, u64m1, 64, 2, u_vv_)
-
-// TODO: ==
-inline v_float32x4 v_eq(const v_float32x4 &a, const v_float32x4 &b) {
-  vbool32_t mask = vmfeq_vv_f32m1_b32(a.val, b.val, 4);
-  vint32m1_t res = vmerge_vxm_i32m1(mask, vmv_v_x_i32m1(0.0, 4), -1, 4);
-  return v_float32x4(vreinterpret_v_i32m1_f32m1(res));
-}
-inline v_float32x4 v_ne(const v_float32x4 &a, const v_float32x4 &b) {
-  vbool32_t mask = vmfne_vv_f32m1_b32(a.val, b.val, 4);
-  vint32m1_t res = vmerge_vxm_i32m1(mask, vmv_v_x_i32m1(0.0, 4), -1, 4);
-  return v_float32x4(vreinterpret_v_i32m1_f32m1(res));
-}
-inline v_float32x4 v_lt(const v_float32x4 &a, const v_float32x4 &b) {
-  vbool32_t mask = vmflt_vv_f32m1_b32(a.val, b.val, 4);
-  vint32m1_t res = vmerge_vxm_i32m1(mask, vmv_v_x_i32m1(0.0, 4), -1, 4);
-  return v_float32x4(vreinterpret_v_i32m1_f32m1(res));
-}
-inline v_float32x4 v_le(const v_float32x4 &a, const v_float32x4 &b) {
-  vbool32_t mask = vmfle_vv_f32m1_b32(a.val, b.val, 4);
-  vint32m1_t res = vmerge_vxm_i32m1(mask, vmv_v_x_i32m1(0.0, 4), -1, 4);
-  return v_float32x4(vreinterpret_v_i32m1_f32m1(res));
-}
-inline v_float32x4 v_gt(const v_float32x4 &a, const v_float32x4 &b) {
-  vbool32_t mask = vmfgt_vv_f32m1_b32(a.val, b.val, 4);
-  vint32m1_t res = vmerge_vxm_i32m1(mask, vmv_v_x_i32m1(0.0, 4), -1, 4);
-  return v_float32x4(vreinterpret_v_i32m1_f32m1(res));
-}
-inline v_float32x4 v_ge(const v_float32x4 &a, const v_float32x4 &b) {
-  vbool32_t mask = vmfge_vv_f32m1_b32(a.val, b.val, 4);
-  vint32m1_t res = vmerge_vxm_i32m1(mask, vmv_v_x_i32m1(0.0, 4), -1, 4);
-  return v_float32x4(vreinterpret_v_i32m1_f32m1(res));
-} /**/
-inline v_float32x4 v_not_nan(const v_float32x4 &a) {
-  vbool32_t mask = vmfeq_vv_f32m1_b32(a.val, a.val, 4);
-  vint32m1_t res = vmerge_vxm_i32m1(mask, vmv_v_x_i32m1(0.0, 4), -1, 4);
-  return v_float32x4(vreinterpret_v_i32m1_f32m1(res));
-}
-
-// TODO: ==
-inline v_float64x2 v_eq(const v_float64x2 &a, const v_float64x2 &b) {
-  vbool64_t mask = vmfeq_vv_f64m1_b64(a.val, b.val, 2);
-  vint64m1_t res = vmerge_vxm_i64m1(mask, vmv_v_x_i64m1(0.0, 2), -1, 2);
-  return v_float64x2(vreinterpret_v_i64m1_f64m1(res));
-}
-inline v_float64x2 v_ne(const v_float64x2 &a, const v_float64x2 &b) {
-  vbool64_t mask = vmfne_vv_f64m1_b64(a.val, b.val, 2);
-  vint64m1_t res = vmerge_vxm_i64m1(mask, vmv_v_x_i64m1(0.0, 2), -1, 2);
-  return v_float64x2(vreinterpret_v_i64m1_f64m1(res));
-}
-inline v_float64x2 v_lt(const v_float64x2 &a, const v_float64x2 &b) {
-  vbool64_t mask = vmflt_vv_f64m1_b64(a.val, b.val, 2);
-  vint64m1_t res = vmerge_vxm_i64m1(mask, vmv_v_x_i64m1(0.0, 2), -1, 2);
-  return v_float64x2(vreinterpret_v_i64m1_f64m1(res));
-}
-inline v_float64x2 v_le(const v_float64x2 &a, const v_float64x2 &b) {
-  vbool64_t mask = vmfle_vv_f64m1_b64(a.val, b.val, 2);
-  vint64m1_t res = vmerge_vxm_i64m1(mask, vmv_v_x_i64m1(0.0, 2), -1, 2);
-  return v_float64x2(vreinterpret_v_i64m1_f64m1(res));
-}
-inline v_float64x2 v_gt(const v_float64x2 &a, const v_float64x2 &b) {
-  vbool64_t mask = vmfgt_vv_f64m1_b64(a.val, b.val, 2);
-  vint64m1_t res = vmerge_vxm_i64m1(mask, vmv_v_x_i64m1(0.0, 2), -1, 2);
-  return v_float64x2(vreinterpret_v_i64m1_f64m1(res));
-}
-inline v_float64x2 v_ge(const v_float64x2 &a, const v_float64x2 &b) {
-  vbool64_t mask = vmfge_vv_f64m1_b64(a.val, b.val, 2);
-  vint64m1_t res = vmerge_vxm_i64m1(mask, vmv_v_x_i64m1(0.0, 2), -1, 2);
-  return v_float64x2(vreinterpret_v_i64m1_f64m1(res));
-} /**/
-inline v_float64x2 v_not_nan(const v_float64x2 &a) {
-  vbool64_t mask = vmfeq_vv_f64m1_b64(a.val, a.val, 2);
-  vint64m1_t res = vmerge_vxm_i64m1(mask, vmv_v_x_i64m1(0.0, 2), -1, 2);
-  return v_float64x2(vreinterpret_v_i64m1_f64m1(res));
-}
-#define OPENCV_HAL_IMPL_RISCVV_TRANSPOSE4x4(_Tp, _T)                           \
-  inline void v_transpose4x4(                                                  \
-      const v_##_Tp##32x4 & a0, const v_##_Tp##32x4 & a1,                      \
-      const v_##_Tp##32x4 & a2, const v_##_Tp##32x4 & a3, v_##_Tp##32x4 & b0,  \
-      v_##_Tp##32x4 & b1, v_##_Tp##32x4 & b2, v_##_Tp##32x4 & b3) {            \
-    vuint32m4_t vindex = vundefined_u32m4();                                   \
-    vuint32m1_t vindex0 = vid_v_u32m1(4);                                      \
-    vindex0 = vsll_vx_u32m1(vindex0, 2, 4);                                    \
-    vindex = vset_v_u32m1_u32m4(vindex, 0, vindex0);                           \
-    vindex = vset_v_u32m1_u32m4(vindex, 1, vadd_vx_u32m1(vindex0, 1, 4));      \
-    vindex = vset_v_u32m1_u32m4(vindex, 2, vadd_vx_u32m1(vindex0, 2, 4));      \
-    vindex = vset_v_u32m1_u32m4(vindex, 3, vadd_vx_u32m1(vindex0, 3, 4));      \
-    v##_Tp##32m4_t val = vundefined_##_T##m4();                                \
-    val = vset_v_##_T##m1_##_T##m4(val, 0, a0.val);                            \
-    val = vset_v_##_T##m1_##_T##m4(val, 1, a1.val);                            \
-    val = vset_v_##_T##m1_##_T##m4(val, 2, a2.val);                            \
-    val = vset_v_##_T##m1_##_T##m4(val, 3, a3.val);                            \
-    val = vrgather_vv_##_T##m4(val, vindex, 16);                               \
-    b0.val = vget_v_##_T##m4_##_T##m1(val, 0);                                 \
-    b1.val = vget_v_##_T##m4_##_T##m1(val, 1);                                 \
-    b2.val = vget_v_##_T##m4_##_T##m1(val, 2);                                 \
-    b3.val = vget_v_##_T##m4_##_T##m1(val, 3);                                 \
-  }
-OPENCV_HAL_IMPL_RISCVV_TRANSPOSE4x4(uint, u32) OPENCV_HAL_IMPL_RISCVV_TRANSPOSE4x4(
-    int, i32) OPENCV_HAL_IMPL_RISCVV_TRANSPOSE4x4(float, f32)
-
-#define OPENCV_HAL_IMPL_RISCVV_SHIFT_LEFT(_Tpvec, suffix, _T, num)             \
-  inline _Tpvec v_shl(const _Tpvec &a, int n) {                                \
-    return _Tpvec((vsll_vx_##_T##m1(a.val, n, num)));                          \
-  }                                                                            \
-  template <int n> inline _Tpvec v_shl(const _Tpvec &a) {                      \
-    return _Tpvec((vsll_vx_##_T##m1(a.val, n, num)));                          \
-  }
-
-#define OPENCV_HAL_IMPL_RISCVV_SHIFT_RIGHT(_Tpvec, suffix, _T, num, intric)    \
-  inline _Tpvec v_shr(const _Tpvec &a, int n) {                                \
-    return _Tpvec((v##intric##_vx_##_T##m1(a.val, n, num)));                   \
-  }                                                                            \
-  template <int n> inline _Tpvec v_shr(const _Tpvec &a) {                      \
-    return _Tpvec((v##intric##_vx_##_T##m1(a.val, n, num)));                   \
-  }                                                                            \
-  template <int n> inline _Tpvec v_rshr(const _Tpvec &a) {                     \
-    return _Tpvec((v##intric##_vx_##_T##m1(                                    \
-        vadd_vx_##_T##m1(a.val, 1 << (n - 1), num), n, num)));                 \
-  }
-
-// trade efficiency for convenience
-#define OPENCV_HAL_IMPL_RISCVV_SHIFT_OP(suffix, _T, num, intrin)               \
-  OPENCV_HAL_IMPL_RISCVV_SHIFT_LEFT(v_##suffix##x##num, suffix, _T, num)       \
-  OPENCV_HAL_IMPL_RISCVV_SHIFT_RIGHT(v_##suffix##x##num, suffix, _T, num,      \
-                                     intrin)
-
-    OPENCV_HAL_IMPL_RISCVV_SHIFT_OP(uint8, u8, 16, srl) OPENCV_HAL_IMPL_RISCVV_SHIFT_OP(
-        uint16, u16, 8, srl) OPENCV_HAL_IMPL_RISCVV_SHIFT_OP(uint32, u32, 4,
-                                                             srl)
-        OPENCV_HAL_IMPL_RISCVV_SHIFT_OP(uint64, u64, 2, srl) OPENCV_HAL_IMPL_RISCVV_SHIFT_OP(
-            int8, i8, 16, sra) OPENCV_HAL_IMPL_RISCVV_SHIFT_OP(int16, i16, 8,
-                                                               sra)
-            OPENCV_HAL_IMPL_RISCVV_SHIFT_OP(
-                int32, i32, 4, sra) OPENCV_HAL_IMPL_RISCVV_SHIFT_OP(int64, i64,
-                                                                    2, sra)
-
-#if 0
-#define VUP4(n) {0, 1, 2, 3}
-#define VUP8(n) {0, 1, 2, 3, 4, 5, 6, 7}
-#define VUP16(n) {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
-#define VUP2(n) {0, 1}
-#endif
-#define OPENCV_HAL_IMPL_RISCVV_ROTATE_OP(_Tpvec, suffix, _T, num, num2, vmv,   \
-                                         len)                                  \
-  template <int n> inline _Tpvec v_rotate_left(const _Tpvec &a) {              \
-    suffix##m1_t tmp = vmv##_##_T##m1(0, num);                                 \
-    tmp = vslideup_vx_##_T##m1_m(vmset_m_##len(num), tmp, a.val, n, num);      \
-    return _Tpvec(tmp);                                                        \
-  }                                                                            \
-  template <int n> inline _Tpvec v_rotate_right(const _Tpvec &a) {             \
-    suffix##m1_t res = vundefined_##_T##m1();                                  \
-    return _Tpvec(vslidedown_vx_##_T##m1(res, a.val, n, num));                 \
-  }                                                                            \
-  template <> inline _Tpvec v_rotate_left<0>(const _Tpvec &a) { return a; }    \
-  template <int n>                                                             \
-  inline _Tpvec v_rotate_right(const _Tpvec &a, const _Tpvec &b) {             \
-    suffix##m2_t tmp = vundefined_##_T##m2();                                  \
-    suffix##m2_t res = vundefined_##_T##m2();                                  \
-    tmp = vset_v_##_T##m1_##_T##m2(tmp, 0, a.val);                             \
-    tmp = vset_v_##_T##m1_##_T##m2(tmp, 1, b.val);                             \
-    res = vslidedown_vx_##_T##m2(res, tmp, n, num2);                           \
-    return _Tpvec(vget_v_##_T##m2_##_T##m1(res, 0));                           \
-  }                                                                            \
-  template <int n>                                                             \
-  inline _Tpvec v_rotate_left(const _Tpvec &a, const _Tpvec &b) {              \
-    suffix##m2_t tmp = vundefined_##_T##m2();                                  \
-    suffix##m2_t res = vundefined_##_T##m2();                                  \
-    tmp = vset_v_##_T##m1_##_T##m2(tmp, 0, b.val);                             \
-    tmp = vset_v_##_T##m1_##_T##m2(tmp, 1, a.val);                             \
-    res = vslideup_vx_##_T##m2(res, tmp, n, num2);                             \
-    return _Tpvec(vget_v_##_T##m2_##_T##m1(res, 1));                           \
-  }                                                                            \
-  template <>                                                                  \
-  inline _Tpvec v_rotate_left<0>(const _Tpvec &a, const _Tpvec &b) {           \
-    CV_UNUSED(b);                                                              \
-    return a;                                                                  \
-  }
-
-                OPENCV_HAL_IMPL_RISCVV_ROTATE_OP(
-                    v_uint8x16, vuint8, u8, 16, 32, vmv_v_x,
-                    b8) OPENCV_HAL_IMPL_RISCVV_ROTATE_OP(v_int8x16, vint8, i8,
-                                                         16, 32, vmv_v_x, b8)
-                    OPENCV_HAL_IMPL_RISCVV_ROTATE_OP(
-                        v_uint16x8, vuint16, u16, 8, 16, vmv_v_x,
-                        b16) OPENCV_HAL_IMPL_RISCVV_ROTATE_OP(v_int16x8, vint16,
-                                                              i16, 8, 16,
-                                                              vmv_v_x, b16)
-                        OPENCV_HAL_IMPL_RISCVV_ROTATE_OP(
-                            v_uint32x4, vuint32, u32, 4, 8, vmv_v_x,
-                            b32) OPENCV_HAL_IMPL_RISCVV_ROTATE_OP(v_int32x4,
-                                                                  vint32, i32,
-                                                                  4, 8, vmv_v_x,
-                                                                  b32)
-                            OPENCV_HAL_IMPL_RISCVV_ROTATE_OP(
-                                v_uint64x2, vuint64, u64, 2, 4, vmv_v_x,
-                                b64) OPENCV_HAL_IMPL_RISCVV_ROTATE_OP(v_int64x2,
-                                                                      vint64,
-                                                                      i64, 2, 4,
-                                                                      vmv_v_x,
-                                                                      b64)
-                                OPENCV_HAL_IMPL_RISCVV_ROTATE_OP(
-                                    v_float32x4, vfloat32, f32, 4, 8, vfmv_v_f,
-                                    b32) OPENCV_HAL_IMPL_RISCVV_ROTATE_OP(v_float64x2,
-                                                                          vfloat64,
-                                                                          f64,
-                                                                          2, 4,
-                                                                          vfmv_v_f,
-                                                                          b64)
-
-#if 1
-#define vreinterpret_v_i8m1_i8m1
-#define vreinterpret_v_u8m1_u8m1
-#define OPENCV_HAL_IMPL_RISCVV_LOADSTORE_OP(_Tpvec, _Tp, _Tp2, len, hnum, num, \
-                                            elemsize, ldst_len, ldst_type)     \
-  inline _Tpvec v_load_halves(const _Tp *ptr0, const _Tp *ptr1) {              \
-    _Tp2##_t res = vundefined_##len();                                         \
-    _Tp2##_t res1 = vundefined_##len();                                        \
-    res = vreinterpret_v_##ldst_len##_##len(                                   \
-        vle8_v_##ldst_len((ldst_type *)ptr0, 8));                              \
-    res1 = vreinterpret_v_##ldst_len##_##len(                                  \
-        vle8_v_##ldst_len((ldst_type *)ptr1, 8));                              \
-    res = vslideup_vx_##len(res, res1, hnum, num);                             \
-    return _Tpvec(res);                                                        \
-  }                                                                            \
-  inline _Tpvec v_load_low(const _Tp *ptr) {                                   \
-    return _Tpvec(vreinterpret_v_##ldst_len##_##len(                           \
-        vle8_v_##ldst_len((ldst_type *)ptr, 8)));                              \
-  }                                                                            \
-  inline _Tpvec v_load_aligned(const _Tp *ptr) {                               \
-    return _Tpvec(vreinterpret_v_##ldst_len##_##len(                           \
-        vle8_v_##ldst_len((ldst_type *)ptr, 16)));                             \
-  }                                                                            \
-  inline _Tpvec v_load(const _Tp *ptr) {                                       \
-    return _Tpvec(vle##elemsize##_v_##len(ptr, num));                          \
-  }                                                                            \
-  inline void v_store_low(_Tp *ptr, const _Tpvec &a) {                         \
-    vse8_v_##ldst_len((ldst_type *)ptr,                                        \
-                      vreinterpret_v_##len##_##ldst_len(a.val), 8);            \
-  }                                                                            \
-  inline void v_store_high(_Tp *ptr, const _Tpvec &a) {                        \
-    _Tp2##_t a0 = vundefined_##len();                                          \
-    a0 = vslidedown_vx_##len(a0, a.val, hnum, num);                            \
-    vse8_v_##ldst_len((ldst_type *)ptr, vreinterpret_v_##len##_##ldst_len(a0), \
-                      8);                                                      \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a) {                             \
-    vse##elemsize##_v_##len(ptr, a.val, num);                                  \
-  }                                                                            \
-  inline void v_store_aligned(_Tp *ptr, const _Tpvec &a) {                     \
-    vse8_v_##ldst_len((ldst_type *)ptr,                                        \
-                      vreinterpret_v_##len##_##ldst_len(a.val), 16);           \
-  }                                                                            \
-  inline void v_store_aligned_nocache(_Tp *ptr, const _Tpvec &a) {             \
-    vse8_v_##ldst_len((ldst_type *)ptr,                                        \
-                      vreinterpret_v_##len##_##ldst_len(a.val), 16);           \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a, hal::StoreMode /*mode*/) {    \
-    vse8_v_##ldst_len((ldst_type *)ptr,                                        \
-                      vreinterpret_v_##len##_##ldst_len(a.val), 16);           \
-  }
-
-                                    OPENCV_HAL_IMPL_RISCVV_LOADSTORE_OP(
-                                        v_uint8x16, uchar, vuint8m1, u8m1, 8,
-                                        16, 8, u8m1, uchar)
-                                        OPENCV_HAL_IMPL_RISCVV_LOADSTORE_OP(
-                                            v_int8x16, schar, vint8m1, i8m1, 8,
-                                            16, 8, i8m1, schar)
-                                            OPENCV_HAL_IMPL_RISCVV_LOADSTORE_OP(
-                                                v_uint16x8, ushort, vuint16m1,
-                                                u16m1, 4, 8, 16, u8m1, uchar)
-                                                OPENCV_HAL_IMPL_RISCVV_LOADSTORE_OP(
-                                                    v_int16x8, short, vint16m1,
-                                                    i16m1, 4, 8, 16, i8m1,
-                                                    schar)
-                                                    OPENCV_HAL_IMPL_RISCVV_LOADSTORE_OP(
-                                                        v_uint32x4, unsigned,
-                                                        vuint32m1, u32m1, 2, 4,
-                                                        32, u8m1, uchar)
-                                                        OPENCV_HAL_IMPL_RISCVV_LOADSTORE_OP(
-                                                            v_int32x4, int,
-                                                            vint32m1, i32m1, 2,
-                                                            4, 32, i8m1, schar)
-                                                            OPENCV_HAL_IMPL_RISCVV_LOADSTORE_OP(
-                                                                v_uint64x2,
-                                                                unsigned long,
-                                                                vuint64m1,
-                                                                u64m1, 1, 2, 64,
-                                                                u8m1, uchar)
-                                                                OPENCV_HAL_IMPL_RISCVV_LOADSTORE_OP(
-                                                                    v_int64x2,
-                                                                    long,
-                                                                    vint64m1,
-                                                                    i64m1, 1, 2,
-                                                                    64, i8m1,
-                                                                    schar)
-
-#define OPENCV_HAL_IMPL_RISCVV_LOADSTORE_FLOAT_OP(_Tpvec, _Tp, _Tp2, len,      \
-                                                  hnum, num, elemsize)         \
-  inline _Tpvec v_load_halves(const _Tp *ptr0, const _Tp *ptr1) {              \
-    _Tp2##_t res = vundefined_##len();                                         \
-    _Tp2##_t res1 = vundefined_##len();                                        \
-    res = vreinterpret_v_u##elemsize##m1_##len(                                \
-        vreinterpret_v_u8m1_u##elemsize##m1(vle8_v_u8m1((uchar *)ptr0, 8)));   \
-    res1 = vreinterpret_v_u##elemsize##m1_##len(                               \
-        vreinterpret_v_u8m1_u##elemsize##m1(vle8_v_u8m1((uchar *)ptr1, 8)));   \
-    res = vslideup_vx_##len(res, res1, hnum, num);                             \
-    return _Tpvec(res);                                                        \
-  }                                                                            \
-  inline _Tpvec v_load_low(const _Tp *ptr) {                                   \
-    return _Tpvec(vreinterpret_v_u##elemsize##m1_##len(                        \
-        vreinterpret_v_u8m1_u##elemsize##m1(vle8_v_u8m1((uchar *)ptr, 8))));   \
-  }                                                                            \
-  inline _Tpvec v_load_aligned(const _Tp *ptr) {                               \
-    return _Tpvec(vreinterpret_v_u##elemsize##m1_##len(                        \
-        vreinterpret_v_u8m1_u##elemsize##m1(vle8_v_u8m1((uchar *)ptr, 16))));  \
-  }                                                                            \
-  inline _Tpvec v_load(const _Tp *ptr) {                                       \
-    return _Tpvec(vle##elemsize##_v_##len(ptr, num));                          \
-  }                                                                            \
-  inline void v_store_low(_Tp *ptr, const _Tpvec &a) {                         \
-    vse8_v_u8m1((uchar *)ptr,                                                  \
-                vreinterpret_v_u##elemsize##m1_u8m1(                           \
-                    vreinterpret_v_##len##_u##elemsize##m1(a.val)),            \
-                8);                                                            \
-  }                                                                            \
-  inline void v_store_high(_Tp *ptr, const _Tpvec &a) {                        \
-    _Tp2##_t a0 = vundefined_##len();                                          \
-    a0 = vslidedown_vx_##len(a0, a.val, hnum, num);                            \
-    vse8_v_u8m1((uchar *)ptr,                                                  \
-                vreinterpret_v_u##elemsize##m1_u8m1(                           \
-                    vreinterpret_v_##len##_u##elemsize##m1(a0)),               \
-                8);                                                            \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a) {                             \
-    vse##elemsize##_v_##len(ptr, a.val, num);                                  \
-  }                                                                            \
-  inline void v_store_aligned(_Tp *ptr, const _Tpvec &a) {                     \
-    vse8_v_u8m1((uchar *)ptr,                                                  \
-                vreinterpret_v_u##elemsize##m1_u8m1(                           \
-                    vreinterpret_v_##len##_u##elemsize##m1(a.val)),            \
-                16);                                                           \
-  }                                                                            \
-  inline void v_store_aligned_nocache(_Tp *ptr, const _Tpvec &a) {             \
-    vse8_v_u8m1((uchar *)ptr,                                                  \
-                vreinterpret_v_u##elemsize##m1_u8m1(                           \
-                    vreinterpret_v_##len##_u##elemsize##m1(a.val)),            \
-                16);                                                           \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a, hal::StoreMode /*mode*/) {    \
-    vse8_v_u8m1((uchar *)ptr,                                                  \
-                vreinterpret_v_u##elemsize##m1_u8m1(                           \
-                    vreinterpret_v_##len##_u##elemsize##m1(a.val)),            \
-                16);                                                           \
-  }
-                                                                    OPENCV_HAL_IMPL_RISCVV_LOADSTORE_FLOAT_OP(
-                                                                        v_float32x4,
-                                                                        float,
-                                                                        vfloat32m1,
-                                                                        f32m1,
-                                                                        2, 4,
-                                                                        32)
-                                                                        OPENCV_HAL_IMPL_RISCVV_LOADSTORE_FLOAT_OP(
-                                                                            v_float64x2,
-                                                                            double,
-                                                                            vfloat64m1,
-                                                                            f64m1,
-                                                                            1,
-                                                                            2,
-                                                                            64)
-
-#else
-
-#define OPENCV_HAL_IMPL_RISCVV_LOADSTORE_OP(_Tpvec, _Tp, _Tp2, len, hnum, num, \
-                                            elemsize)                          \
-  inline _Tpvec v_load_halves(const _Tp *ptr0, const _Tp *ptr1) {              \
-    _Tp2##_t res, res1;                                                        \
-    res = vle##elemsize##_v_##len(ptr0, hnum);                                 \
-    res1 = vle##elemsize##_v_##len(ptr1, hnum);                                \
-    res = vslideup_vx_##len(res, res1, hnum, num);                             \
-    return _Tpvec(res);                                                        \
-  }                                                                            \
-  inline _Tpvec v_load_low(const _Tp *ptr) {                                   \
-    return _Tpvec(vle##elemsize##_v_##len(ptr, hnum));                         \
-  }                                                                            \
-  inline _Tpvec v_load_aligned(const _Tp *ptr) {                               \
-    return _Tpvec(vle##elemsize##_v_##len(ptr, num));                          \
-  }                                                                            \
-  inline _Tpvec v_load(const _Tp *ptr) {                                       \
-    return _Tpvec((_Tp2##_t)vle##elemsize##_v_##len((const _Tp *)ptr, num));   \
-  }                                                                            \
-  inline void v_store_low(_Tp *ptr, const _Tpvec &a) {                         \
-    vse##elemsize##_v_##len(ptr, a.val, hnum);                                 \
-  }                                                                            \
-  inline void v_store_high(_Tp *ptr, const _Tpvec &a) {                        \
-    _Tp2##_t a0;                                                               \
-    a0 = vslidedown_vx_##len(a0, a.val, hnum, num);                            \
-    vse##elemsize##_v_##len(ptr, a0, hnum);                                    \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a) {                             \
-    vse##elemsize##_v_##len(ptr, a.val, num);                                  \
-  }                                                                            \
-  inline void v_store_aligned(_Tp *ptr, const _Tpvec &a) {                     \
-    vse##elemsize##_v_##len(ptr, a.val, num);                                  \
-  }                                                                            \
-  inline void v_store_aligned_nocache(_Tp *ptr, const _Tpvec &a) {             \
-    vse##elemsize##_v_##len(ptr, a.val, num);                                  \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a, hal::StoreMode /*mode*/) {    \
-    vse##elemsize##_v_##len(ptr, a.val, num);                                  \
-  }
-
-                                    OPENCV_HAL_IMPL_RISCVV_LOADSTORE_OP(
-                                        v_uint8x16, uchar, vuint8m1, u8m1, 8,
-                                        16,
-                                        8) OPENCV_HAL_IMPL_RISCVV_LOADSTORE_OP(v_int8x16,
-                                                                               schar,
-                                                                               vint8m1,
-                                                                               i8m1,
-                                                                               8,
-                                                                               16,
-                                                                               8)
-                                        OPENCV_HAL_IMPL_RISCVV_LOADSTORE_OP(
-                                            v_uint16x8, ushort, vuint16m1,
-                                            u16m1, 4, 8, 16)
-                                            OPENCV_HAL_IMPL_RISCVV_LOADSTORE_OP(
-                                                v_int16x8, short, vint16m1,
-                                                i16m1, 4, 8, 16)
-                                                OPENCV_HAL_IMPL_RISCVV_LOADSTORE_OP(
-                                                    v_uint32x4, unsigned,
-                                                    vuint32m1, u32m1, 2, 4, 32)
-                                                    OPENCV_HAL_IMPL_RISCVV_LOADSTORE_OP(
-                                                        v_int32x4, int,
-                                                        vint32m1, i32m1, 2, 4,
-                                                        32)
-                                                        OPENCV_HAL_IMPL_RISCVV_LOADSTORE_OP(
-                                                            v_uint64x2,
-                                                            unsigned long,
-                                                            vuint64m1, u64m1, 1,
-                                                            2, 64)
-                                                            OPENCV_HAL_IMPL_RISCVV_LOADSTORE_OP(
-                                                                v_int64x2, long,
-                                                                vint64m1, i64m1,
-                                                                1, 2, 64)
-                                                                OPENCV_HAL_IMPL_RISCVV_LOADSTORE_OP(
-                                                                    v_float32x4,
-                                                                    float,
-                                                                    vfloat32m1,
-                                                                    f32m1, 2, 4,
-                                                                    32)
-                                                                    OPENCV_HAL_IMPL_RISCVV_LOADSTORE_OP(
-                                                                        v_float64x2,
-                                                                        double,
-                                                                        vfloat64m1,
-                                                                        f64m1,
-                                                                        1, 2,
-                                                                        64)
-
-#endif
-
-    ////////////// Lookup table access ////////////////////
-
-    inline v_int8x16 v_lut(const schar *tab, const int *idx) {
-#if 0
-    schar CV_DECL_ALIGNED(32) elems[16] =
-    {
-        tab[idx[ 0]],
-        tab[idx[ 1]],
-        tab[idx[ 2]],
-        tab[idx[ 3]],
-        tab[idx[ 4]],
-        tab[idx[ 5]],
-        tab[idx[ 6]],
-        tab[idx[ 7]],
-        tab[idx[ 8]],
-        tab[idx[ 9]],
-        tab[idx[10]],
-        tab[idx[11]],
-        tab[idx[12]],
-        tab[idx[13]],
-        tab[idx[14]],
-        tab[idx[15]]
-    };
-    return v_int8x16(vle8_v_i8m1(elems, 16));
-#else
-#if __riscv_v == 7000
-  return v_int8x16(vnclip_wx_i8m1(
-      vnclip_wx_i16m2(vlxb_v_i32m4((const int *)tab,
-                                   vle32_v_u32m4((unsigned int *)idx, 16), 16),
-                      0, 16),
-      0, 16));
-#else
-  return v_int8x16(
-      vloxei32_v_i8m1(tab, vle32_v_u32m4((unsigned int *)idx, 16), 16));
-#endif
-#endif
-}
-
-inline v_int8x16 v_lut_pairs(const schar *tab, const int *idx) {
-#if 0
-    schar CV_DECL_ALIGNED(32) elems[16] =
-    {
-        tab[idx[0]],
-        tab[idx[0] + 1],
-        tab[idx[1]],
-        tab[idx[1] + 1],
-        tab[idx[2]],
-        tab[idx[2] + 1],
-        tab[idx[3]],
-        tab[idx[3] + 1],
-        tab[idx[4]],
-        tab[idx[4] + 1],
-        tab[idx[5]],
-        tab[idx[5] + 1],
-        tab[idx[6]],
-        tab[idx[6] + 1],
-        tab[idx[7]],
-        tab[idx[7] + 1]
-    };
-    return v_int8x16(vle8_v_i8m1(elems, 16));
-#else
-  vuint32m4_t seq, index;
-  vuint32m4_t vidx = vle32_v_u32m4((unsigned int *)idx, 8);
-  seq = vid_v_u32m4(16);
-  index = vsrl_vx_u32m4(seq, 1, 16);
-  vidx = vrgather_vv_u32m4(vidx, index, 16);
-  index = vadd_vv_u32m4(vand_vx_u32m4(seq, 1, 16), vidx, 16);
-#if __riscv_v == 7000
-  return v_int8x16(vnclip_wx_i8m1(
-      vnclip_wx_i16m2(vlxb_v_i32m4((const int *)tab, index, 16), 0, 16), 0,
-      16));
-#else
-  return v_int8x16(vloxei32_v_i8m1(tab, index, 16));
-#endif
-#endif
-}
-inline v_int8x16 v_lut_quads(const schar *tab, const int *idx) {
-#if 0
-    schar CV_DECL_ALIGNED(32) elems[16] =
-    {
-        tab[idx[0]],
-        tab[idx[0] + 1],
-        tab[idx[0] + 2],
-        tab[idx[0] + 3],
-        tab[idx[1]],
-        tab[idx[1] + 1],
-        tab[idx[1] + 2],
-        tab[idx[1] + 3],
-        tab[idx[2]],
-        tab[idx[2] + 1],
-        tab[idx[2] + 2],
-        tab[idx[2] + 3],
-        tab[idx[3]],
-        tab[idx[3] + 1],
-        tab[idx[3] + 2],
-        tab[idx[3] + 3]
-    };
-    return v_int8x16(vle8_v_i8m1(elems, 16));
-#else
-  vuint32m4_t seq, index;
-  vuint32m4_t vidx = vle32_v_u32m4((unsigned int *)idx, 4);
-  seq = vid_v_u32m4(16);
-  index = vsrl_vx_u32m4(seq, 2, 16);
-  vidx = vrgather_vv_u32m4(vidx, index, 16);
-  seq = vset_v_u32m1_u32m4(seq, 1, vget_v_u32m4_u32m1(seq, 0));
-  seq = vset_v_u32m1_u32m4(seq, 2, vget_v_u32m4_u32m1(seq, 0));
-  seq = vset_v_u32m1_u32m4(seq, 3, vget_v_u32m4_u32m1(seq, 0));
-  index = vadd_vv_u32m4(seq, vidx, 16);
-#if __riscv_v == 7000
-  return v_int8x16(vnclip_wx_i8m1(
-      vnclip_wx_i16m2(vlxb_v_i32m4((const int *)tab, index, 16), 0, 16), 0,
-      16));
-#else
-  return v_int8x16(vloxei32_v_i8m1(tab, index, 16));
-#endif
-#endif
-}
-
-inline v_uint8x16 v_lut(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v_lut((schar *)tab, idx));
-}
-inline v_uint8x16 v_lut_pairs(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v_lut_pairs((schar *)tab, idx));
-}
-inline v_uint8x16 v_lut_quads(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v_lut_quads((schar *)tab, idx));
-}
-
-inline v_int16x8 v_lut(const short *tab, const int *idx) {
-#if 0
-    short CV_DECL_ALIGNED(32) elems[8] =
-    {
-        tab[idx[0]],
-        tab[idx[1]],
-        tab[idx[2]],
-        tab[idx[3]],
-        tab[idx[4]],
-        tab[idx[5]],
-        tab[idx[6]],
-        tab[idx[7]]
-    };
-    return v_int16x8(vle16_v_i16m1(elems, 8));
-#else
-#if __riscv_v == 7000
-  return v_int16x8(vnclip_wx_i16m1(
-      vlxh_v_i32m2((const int *)tab,
-                   vsll_vx_u32m2(vle32_v_u32m2((unsigned int *)idx, 8), 1, 8),
-                   8),
-      0, 8));
-#else
-  return v_int16x8(vloxei32_v_i16m1(
-      tab, vsll_vx_u32m2(vle32_v_u32m2((unsigned int *)idx, 8), 1, 8), 8));
-#endif
-#endif
-}
-inline v_int16x8 v_lut_pairs(const short *tab, const int *idx) {
-#if 0
-    short CV_DECL_ALIGNED(32) elems[8] =
-    {
-        tab[idx[0]],
-        tab[idx[0] + 1],
-        tab[idx[1]],
-        tab[idx[1] + 1],
-        tab[idx[2]],
-        tab[idx[2] + 1],
-        tab[idx[3]],
-        tab[idx[3] + 1]
-    };
-    return v_int16x8(vle16_v_i16m1(elems, 8));
-#else
-  vuint32m2_t seq, index;
-  vuint32m2_t vidx = vle32_v_u32m2((unsigned int *)idx, 4);
-  seq = vid_v_u32m2(8);
-  index = vsrl_vx_u32m2(seq, 1, 8);
-  vidx = vrgather_vv_u32m2(vidx, index, 8);
-  index = vsll_vx_u32m2(vadd_vv_u32m2(vand_vx_u32m2(seq, 1, 8), vidx, 8), 1, 8);
-#if __riscv_v == 7000
-  return v_int16x8(
-      vnclip_wx_i16m1(vlxh_v_i32m2((const int *)tab, index, 8), 0, 8));
-#else
-  return v_int16x8(vloxei32_v_i16m1(tab, index, 8));
-#endif
-#endif
-}
-inline v_int16x8 v_lut_quads(const short *tab, const int *idx) {
-#if 0
-    short CV_DECL_ALIGNED(32) elems[8] =
-    {
-        tab[idx[0]],
-        tab[idx[0] + 1],
-        tab[idx[0] + 2],
-        tab[idx[0] + 3],
-        tab[idx[1]],
-        tab[idx[1] + 1],
-        tab[idx[1] + 2],
-        tab[idx[1] + 3]
-    };
-    return v_int16x8(vle16_v_i16m1(elems, 8));
-#else
-  vuint32m2_t seq, index;
-  vuint32m2_t vidx = vle32_v_u32m2((unsigned int *)idx, 2);
-  seq = vid_v_u32m2(8);
-  index = vsrl_vx_u32m2(seq, 2, 8);
-  vidx = vrgather_vv_u32m2(vidx, index, 8);
-  seq = vset_v_u32m1_u32m2(seq, 1, vget_v_u32m2_u32m1(seq, 0));
-  index = vsll_vx_u32m2(vadd_vv_u32m2(seq, vidx, 8), 1, 8);
-#if __riscv_v == 7000
-  return v_int16x8(
-      vnclip_wx_i16m1(vlxh_v_i32m2((const int *)tab, index, 8), 0, 8));
-#else
-  return v_int16x8(vloxei32_v_i16m1(tab, index, 8));
-#endif
-#endif
-}
-inline v_uint16x8 v_lut(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v_lut((short *)tab, idx));
-}
-inline v_uint16x8 v_lut_pairs(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v_lut_pairs((short *)tab, idx));
-}
-inline v_uint16x8 v_lut_quads(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v_lut_quads((short *)tab, idx));
-}
-
-inline v_int32x4 v_lut(const int *tab, const int *idx) {
-#if 0
-    int CV_DECL_ALIGNED(32) elems[4] =
-    {
-        tab[idx[0]],
-        tab[idx[1]],
-        tab[idx[2]],
-        tab[idx[3]]
-    };
-    return v_int32x4(vle32_v_i32m1(elems, 4));
-#else
-  return v_int32x4(vloxei32_v_i32m1(
-      tab, vsll_vx_u32m1(vle32_v_u32m1((unsigned int *)idx, 4), 2, 4), 4));
-#endif
-}
-inline v_int32x4 v_lut_pairs(const int *tab, const int *idx) {
-#if 0
-    int CV_DECL_ALIGNED(32) elems[4] =
-    {
-        tab[idx[0]],
-        tab[idx[0] + 1],
-        tab[idx[1]],
-        tab[idx[1] + 1]
-    };
-    return v_int32x4(vle32_v_i32m1(elems, 4));
-#else
-  vuint32m1_t seq, index;
-  vuint32m1_t vidx = vle32_v_u32m1((unsigned int *)idx, 2);
-  seq = vid_v_u32m1(4);
-  index = vsrl_vx_u32m1(seq, 1, 4);
-  vidx = vrgather_vv_u32m1(vidx, index, 4);
-  index = vsll_vx_u32m1(vadd_vv_u32m1(vand_vx_u32m1(seq, 1, 4), vidx, 4), 2, 4);
-  return v_int32x4(vloxei32_v_i32m1(tab, index, 4));
-#endif
-}
-inline v_int32x4 v_lut_quads(const int *tab, const int *idx) {
-  return v_int32x4(vle32_v_i32m1(tab + idx[0], 4));
-}
-inline v_uint32x4 v_lut(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v_lut((int *)tab, idx));
-}
-inline v_uint32x4 v_lut_pairs(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v_lut_pairs((int *)tab, idx));
-}
-inline v_uint32x4 v_lut_quads(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v_lut_quads((int *)tab, idx));
-}
-
-inline v_int64x2 v_lut(const int64_t *tab, const int *idx) {
-  // vint64m1_t res = {tab[idx[0]], tab[idx[1]]};
-  return v_int64x2(vloxei64_v_i64m1(
-      tab,
-      vsll_vx_u64m1(
-          vget_v_u64m2_u64m1(
-              vwaddu_vx_u64m2(vle32_v_u32m1((uint32_t *)idx, 2), 0, 2), 0),
-          3, 2),
-      2));
-}
-inline v_int64x2 v_lut_pairs(const int64_t *tab, const int *idx) {
-  return v_int64x2(vle64_v_i64m1(tab + idx[0], 2));
-}
-
-inline v_uint64x2 v_lut(const uint64_t *tab, const int *idx) {
-  // vuint64m1_t res = {tab[idx[0]], tab[idx[1]]};
-  return v_uint64x2(vloxei64_v_u64m1(
-      tab,
-      vsll_vx_u64m1(
-          vget_v_u64m2_u64m1(
-              vwaddu_vx_u64m2(vle32_v_u32m1((uint32_t *)idx, 2), 0, 2), 0),
-          3, 2),
-      2));
-}
-inline v_uint64x2 v_lut_pairs(const uint64_t *tab, const int *idx) {
-  return v_uint64x2(vle64_v_u64m1(tab + idx[0], 2));
-}
-
-inline v_float32x4 v_lut(const float *tab, const int *idx) {
-#if 0
-    float CV_DECL_ALIGNED(32) elems[4] =
-    {
-        tab[idx[0]],
-        tab[idx[1]],
-        tab[idx[2]],
-        tab[idx[3]]
-    };
-    return v_float32x4(vle32_v_f32m1(elems, 4));
-#else
-  return v_float32x4(vloxei32_v_f32m1(
-      tab, vsll_vx_u32m1(vle32_v_u32m1((unsigned int *)idx, 4), 2, 4), 4));
-#endif
-}
-inline v_float32x4 v_lut_pairs(const float *tab, const int *idx) {
-#if 0
-    float CV_DECL_ALIGNED(32) elems[4] =
-    {
-        tab[idx[0]],
-        tab[idx[0]+1],
-        tab[idx[1]],
-        tab[idx[1]+1]
-    };
-    return v_float32x4(vle32_v_f32m1(elems, 4));
-#else
-  vuint32m1_t seq, index;
-  vuint32m1_t vidx = vle32_v_u32m1((unsigned int *)idx, 2);
-  seq = vid_v_u32m1(4);
-  index = vsrl_vx_u32m1(seq, 1, 4);
-  vidx = vrgather_vv_u32m1(vidx, index, 4);
-  index = vsll_vx_u32m1(vadd_vv_u32m1(vand_vx_u32m1(seq, 1, 4), vidx, 4), 2, 4);
-  return v_float32x4(vloxei32_v_f32m1(tab, index, 4));
-#endif
-}
-inline v_float32x4 v_lut_quads(const float *tab, const int *idx) {
-  return v_float32x4(vle32_v_f32m1(tab + idx[0], 4));
-}
-inline v_float64x2 v_lut(const double *tab, const int *idx) {
-  // vfloat64m1_t res = {tab[idx[0]], tab[idx[1]]};
-  return v_float64x2(vloxei64_v_f64m1(
-      tab,
-      vsll_vx_u64m1(
-          vget_v_u64m2_u64m1(
-              vwaddu_vx_u64m2(vle32_v_u32m1((uint32_t *)idx, 2), 0, 2), 0),
-          3, 2),
-      2));
-}
-inline v_float64x2 v_lut_pairs(const double *tab, const int *idx) {
-  return v_float64x2(vle64_v_f64m1(tab + idx[0], 2));
-}
-
-inline v_int32x4 v_lut(const int *tab, const v_int32x4 &idxvec) {
-  /*int CV_DECL_ALIGNED(32) elems[4] =
-  {
-      tab[idxvec.val[0]],
-      tab[idxvec.val[1]],
-      tab[idxvec.val[2]],
-      tab[idxvec.val[3]]
-  };*/
-  return v_int32x4(vloxei32_v_i32m1(
-      tab, vsll_vx_u32m1(vreinterpret_v_i32m1_u32m1(idxvec.val), 2, 4), 4));
-}
-
-inline v_uint32x4 v_lut(const unsigned *tab, const v_int32x4 &idxvec) {
-  /*unsigned CV_DECL_ALIGNED(32) elems[4] =
-  {
-      tab[idxvec.val[0]],
-      tab[idxvec.val[1]],
-      tab[idxvec.val[2]],
-      tab[idxvec.val[3]]
-  };*/
-  return v_uint32x4(vloxei32_v_u32m1(
-      tab, vsll_vx_u32m1(vreinterpret_v_i32m1_u32m1(idxvec.val), 2, 4), 4));
-}
-
-inline v_float32x4 v_lut(const float *tab, const v_int32x4 &idxvec) {
-  /*float CV_DECL_ALIGNED(32) elems[4] =
-  {
-      tab[idxvec.val[0]],
-      tab[idxvec.val[1]],
-      tab[idxvec.val[2]],
-      tab[idxvec.val[3]]
-  };*/
-  return v_float32x4(vloxei32_v_f32m1(
-      tab, vsll_vx_u32m1(vreinterpret_v_i32m1_u32m1(idxvec.val), 2, 4), 4));
-}
-inline v_float64x2 v_lut(const double *tab, const v_int32x4 &idxvec) {
-  // vfloat64m1_t res = {tab[idxvec.val[0]], tab[idxvec.val[1]]};
-  return v_float64x2(vloxei64_v_f64m1(
-      tab,
-      vsll_vx_u64m1(vreinterpret_v_i64m1_u64m1(vget_v_i64m2_i64m1(
-                        vwadd_vx_i64m2(idxvec.val, 0, 2), 0)),
-                    3, 2),
-      2));
-}
-inline void v_lut_deinterleave(const float *tab, const v_int32x4 &idxvec,
-                               v_float32x4 &x, v_float32x4 &y) {
-  vint32m1_t index = vmul_vx_i32m1(idxvec.val, 4, 4);
-  // vint32m1_t index_y = vadd_vx_i32m1(index_x, 4, 4);
-
-  // x.val = vlxe_v_f32m1(tab, index_x, 4);
-  // y.val = vlxe_v_f32m1(tab, index_y, 4);
-  vloxseg2ei32_v_f32m1(&x.val, &y.val, tab, vreinterpret_v_i32m1_u32m1(index),
-                       4);
-}
-
-inline void v_lut_deinterleave(const double *tab, const v_int32x4 &idxvec,
-                               v_float64x2 &x, v_float64x2 &y) {
-  int CV_DECL_ALIGNED(32) idx[4];
-  v_store_aligned(idx, idxvec);
-
-  x = v_float64x2(tab[idx[0]], tab[idx[1]]);
-  y = v_float64x2(tab[idx[0] + 1], tab[idx[1] + 1]);
-}
-
-#define OPENCV_HAL_IMPL_RISCVV_PACKS(_Tp, _Tp2, _T2, num2, _T1, num, intrin,   \
-                                     shr, _Type, elemsize)                     \
-  inline v_##_Tp##x##num v_pack(const v_##_Tp2##x##num2 &a,                    \
-                                const v_##_Tp2##x##num2 &b) {                  \
-    v##_Tp2##m2_t tmp = vundefined_##_T2##m2();                                \
-    tmp = vset_v_##_T2##m1_##_T2##m2(tmp, 0, a.val);                           \
-    tmp = vset_v_##_T2##m1_##_T2##m2(tmp, 1, b.val);                           \
-    return v_##_Tp##x##num(shr##_##_T1##m1(tmp, 0, num));                      \
-  }                                                                            \
-  template <int n>                                                             \
-  inline v_##_Tp##x##num v_rshr_pack(const v_##_Tp2##x##num2 &a,               \
-                                     const v_##_Tp2##x##num2 &b) {             \
-    v##_Tp2##m2_t tmp = vundefined_##_T2##m2();                                \
-    tmp = vset_v_##_T2##m1_##_T2##m2(tmp, 0, a.val);                           \
-    tmp = vset_v_##_T2##m1_##_T2##m2(tmp, 1, b.val);                           \
-    return v_##_Tp##x##num(intrin##_##_T1##m1(tmp, n, num));                   \
-  }                                                                            \
-  inline void v_pack_store(_Type *ptr, const v_##_Tp2##x##num2 &a) {           \
-    v##_Tp2##m2_t tmp = vundefined_##_T2##m2();                                \
-    tmp = vset_v_##_T2##m1_##_T2##m2(tmp, 0, a.val);                           \
-    tmp = vset_v_##_T2##m1_##_T2##m2(tmp, 1, vmv_v_x_##_T2##m1(0, num2));      \
-    asm("" ::: "memory");                                                      \
-    vse##elemsize##_v_##_T1##m1(ptr, shr##_##_T1##m1(tmp, 0, num), num2);      \
-  }                                                                            \
-  template <int n>                                                             \
-  inline void v_rshr_pack_store(_Type *ptr, const v_##_Tp2##x##num2 &a) {      \
-    v##_Tp2##m2_t tmp = vundefined_##_T2##m2();                                \
-    tmp = vset_v_##_T2##m1_##_T2##m2(tmp, 0, a.val);                           \
-    tmp = vset_v_##_T2##m1_##_T2##m2(tmp, 1, vmv_v_x_##_T2##m1(0, num2));      \
-    vse##elemsize##_v_##_T1##m1(ptr, intrin##_##_T1##m1(tmp, n, num), num2);   \
-  }
-OPENCV_HAL_IMPL_RISCVV_PACKS(int8, int16, i16, 8, i8, 16, vnclip_wx, vnclip_wx,
-                             signed char, 8)
-OPENCV_HAL_IMPL_RISCVV_PACKS(int16, int32, i32, 4, i16, 8, vnclip_wx, vnclip_wx,
-                             signed short, 16)
-OPENCV_HAL_IMPL_RISCVV_PACKS(int32, int64, i64, 2, i32, 4, vnclip_wx, vnsra_wx,
-                             int, 32)
-OPENCV_HAL_IMPL_RISCVV_PACKS(uint8, uint16, u16, 8, u8, 16, vnclipu_wx,
-                             vnclipu_wx, unsigned char, 8)
-OPENCV_HAL_IMPL_RISCVV_PACKS(uint16, uint32, u32, 4, u16, 8, vnclipu_wx,
-                             vnclipu_wx, unsigned short, 16)
-OPENCV_HAL_IMPL_RISCVV_PACKS(uint32, uint64, u64, 2, u32, 4, vnclipu_wx,
-                             vnsrl_wx, unsigned int, 32)
-
-// pack boolean
-inline v_uint8x16 v_pack_b(const v_uint16x8 &a, const v_uint16x8 &b) {
-  vuint16m2_t tmp = vundefined_u16m2();
-  tmp = vset_v_u16m1_u16m2(tmp, 0, a.val);
-  tmp = vset_v_u16m1_u16m2(tmp, 1, b.val);
-  return v_uint8x16(vnsrl_wx_u8m1(tmp, 0, 16));
-}
-
-inline v_uint8x16 v_pack_b(const v_uint32x4 &a, const v_uint32x4 &b,
-                           const v_uint32x4 &c, const v_uint32x4 &d) {
-  vuint32m4_t vabcd = vundefined_u32m4();
-  vuint16m2_t v16 = vundefined_u16m2();
-  vabcd = vset_v_u32m1_u32m4(vabcd, 0, a.val);
-  vabcd = vset_v_u32m1_u32m4(vabcd, 1, b.val);
-  vabcd = vset_v_u32m1_u32m4(vabcd, 2, c.val);
-  vabcd = vset_v_u32m1_u32m4(vabcd, 3, d.val);
-  v16 = vnsrl_wx_u16m2(vabcd, 0, 16);
-  return v_uint8x16(vnsrl_wx_u8m1(v16, 0, 16));
-}
-
-inline v_uint8x16 v_pack_b(const v_uint64x2 &a, const v_uint64x2 &b,
-                           const v_uint64x2 &c, const v_uint64x2 &d,
-                           const v_uint64x2 &e, const v_uint64x2 &f,
-                           const v_uint64x2 &g, const v_uint64x2 &h) {
-  vuint64m8_t v64 = vundefined_u64m8();
-  vuint32m4_t v32 = vundefined_u32m4();
-  vuint16m2_t v16 = vundefined_u16m2();
-  v64 = vset_v_u64m1_u64m8(v64, 0, a.val);
-  v64 = vset_v_u64m1_u64m8(v64, 1, b.val);
-  v64 = vset_v_u64m1_u64m8(v64, 2, c.val);
-  v64 = vset_v_u64m1_u64m8(v64, 3, d.val);
-  v64 = vset_v_u64m1_u64m8(v64, 4, e.val);
-  v64 = vset_v_u64m1_u64m8(v64, 5, f.val);
-  v64 = vset_v_u64m1_u64m8(v64, 6, g.val);
-  v64 = vset_v_u64m1_u64m8(v64, 7, h.val);
-  v32 = vnsrl_wx_u32m4(v64, 0, 16);
-  v16 = vnsrl_wx_u16m2(v32, 0, 16);
-  return v_uint8x16(vnsrl_wx_u8m1(v16, 0, 16));
-}
-
-//inline v_uint8x16 v_pack_u(const v_int16x8& a, const v_int16x8& b) \
-//{ \
-//    int16xm2_u tmp;    \
-//    tmp.m1[0] = (vint16m1_t)a.val;    \
-//    tmp.m1[1] = (vint16m1_t)b.val;    \
-//    e8xm1_t mask = (e8xm1_t)vmsge_vx_e16xm2_i16m2(tmp.v, 0, 16);\
-//    return v_uint8x16(vnclipuvi_mask_u8m1_u16m2(vmv_v_x_u8m1(0, 16), (vuint16m2_t)tmp.v, 0, mask, 16));
-//}
-
-#define OPENCV_HAL_IMPL_RISCVV_PACK_U(tp1, num1, tp2, num2, _Tp)               \
-  inline v_uint##tp1##x##num1 v_pack_u(const v_int##tp2##x##num2 &a,           \
-                                       const v_int##tp2##x##num2 &b) {         \
-    vint##tp2##m2_t tmp = vundefined_##i##tp2##m2();                           \
-    tmp = vset_v_##i##tp2##m1_##i##tp2##m2(tmp, 0, a.val);                     \
-    tmp = vset_v_##i##tp2##m1_##i##tp2##m2(tmp, 1, b.val);                     \
-    vint##tp2##m2_t val = vmax_vx_i##tp2##m2(tmp, 0, num1);                    \
-    return v_uint##tp1##x##num1(vnclipu_wx_u##tp1##m1(                         \
-        vreinterpret_v_i##tp2##m2_u##tp2##m2(val), 0, num1));                  \
-  }                                                                            \
-  inline void v_pack_u_store(_Tp *ptr, const v_int##tp2##x##num2 &a) {         \
-    vint##tp2##m2_t tmp = vundefined_##i##tp2##m2();                           \
-    tmp = vset_v_##i##tp2##m1_##i##tp2##m2(tmp, 0, a.val);                     \
-    vint##tp2##m2_t val = vmax_vx_i##tp2##m2(tmp, 0, num1);                    \
-    return vse##tp1##_v_u##tp1##m1(                                            \
-        ptr,                                                                   \
-        vnclipu_wx_u##tp1##m1(vreinterpret_v_i##tp2##m2_u##tp2##m2(val), 0,    \
-                              num1),                                           \
-        num2);                                                                 \
-  }                                                                            \
-  template <int n>                                                             \
-  inline v_uint##tp1##x##num1 v_rshr_pack_u(const v_int##tp2##x##num2 &a,      \
-                                            const v_int##tp2##x##num2 &b) {    \
-    vint##tp2##m2_t tmp = vundefined_##i##tp2##m2();                           \
-    tmp = vset_v_##i##tp2##m1_##i##tp2##m2(tmp, 0, a.val);                     \
-    tmp = vset_v_##i##tp2##m1_##i##tp2##m2(tmp, 1, b.val);                     \
-    vint##tp2##m2_t val = vmax_vx_i##tp2##m2(tmp, 0, num1);                    \
-    return v_uint##tp1##x##num1(vnclipu_wx_u##tp1##m1(                         \
-        vreinterpret_v_i##tp2##m2_u##tp2##m2(val), n, num1));                  \
-  }                                                                            \
-  template <int n>                                                             \
-  inline void v_rshr_pack_u_store(_Tp *ptr, const v_int##tp2##x##num2 &a) {    \
-    vint##tp2##m2_t tmp = vundefined_##i##tp2##m2();                           \
-    tmp = vset_v_##i##tp2##m1_##i##tp2##m2(tmp, 0, a.val);                     \
-    vint##tp2##m2_t val_ = vmax_vx_i##tp2##m2(tmp, 0, num1);                   \
-    vuint##tp1##m1_t val = vnclipu_wx_u##tp1##m1(                              \
-        vreinterpret_v_i##tp2##m2_u##tp2##m2(val_), n, num1);                  \
-    return vse##tp1##_v_u##tp1##m1(ptr, val, num2);                            \
-  }
-OPENCV_HAL_IMPL_RISCVV_PACK_U(8, 16, 16, 8, unsigned char)
-OPENCV_HAL_IMPL_RISCVV_PACK_U(16, 8, 32, 4, unsigned short)
-
-// saturating multiply 8-bit, 16-bit
-#define OPENCV_HAL_IMPL_RISCVV_MUL_SAT(_Tpvec, num, mul, cvt)                  \
-  inline _Tpvec v_mul(const _Tpvec &a, const _Tpvec &b) {                      \
-    auto res = mul(a.val, b.val, num);                                         \
-    return _Tpvec(cvt(res, 0, num));                                           \
-  }
-
-OPENCV_HAL_IMPL_RISCVV_MUL_SAT(v_int8x16, 16, vwmul_vv_i16m2, vnclip_wx_i8m1)
-OPENCV_HAL_IMPL_RISCVV_MUL_SAT(v_uint8x16, 16, vwmulu_vv_u16m2, vnclipu_wx_u8m1)
-OPENCV_HAL_IMPL_RISCVV_MUL_SAT(v_int16x8, 32, vwmul_vv_i32m2, vnclip_wx_i16m1)
-OPENCV_HAL_IMPL_RISCVV_MUL_SAT(v_uint16x8, 32, vwmulu_vv_u32m2,
-                               vnclipu_wx_u16m1)
-
-static const signed char popCountTable[256] = {
-    0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4,
-    2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4,
-    2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6,
-    4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5,
-    3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6,
-    4, 5, 5, 6, 5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-    4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,
-};
-
-inline vuint8m1_t vcnt_u8(vuint8m1_t val) {
-#if __riscv_v == 7000
-  vuint8m1_t v0 = vand_vx_u8m1(val, 1, 16);
-  return vadd_vv_u8m1(vloxei8_v_u8m1((unsigned char *)popCountTable,
-                                     vsrl_vx_u8m1(val, 1, 16), 16),
-                      v0, 16);
-#else
-  return vloxei8_v_u8m1((unsigned char *)popCountTable, val, 16);
-#endif
-}
-
-inline v_uint8x16 v_popcount(const v_uint8x16 &a) {
-  return v_uint8x16(vcnt_u8(a.val));
-}
-
-inline v_uint8x16 v_popcount(const v_int8x16 &a) {
-  return v_uint8x16(vcnt_u8(vreinterpret_v_i8m1_u8m1(a.val)));
-}
-
-inline v_uint16x8 v_popcount(const v_uint16x8 &a) {
-  vuint8m1_t tmp = vcnt_u8(vreinterpret_v_u16m1_u8m1(a.val));
-  vuint8m1_t seq = vid_v_u8m1(8);
-  vuint8m1_t index = vsll_vx_u8m1(seq, 1, 8);
-  return v_uint16x8(vget_v_u16m2_u16m1(
-      vwaddu_vv_u16m2(vrgather_vv_u8m1(tmp, index, 8),
-                      vrgather_vv_u8m1(tmp, vadd_vx_u8m1(index, 1, 8), 8), 8),
-      0));
-}
-
-inline v_uint16x8 v_popcount(const v_int16x8 &a) {
-  vuint8m1_t tmp =
-      vcnt_u8(vreinterpret_v_i8m1_u8m1(vreinterpret_v_i16m1_i8m1(a.val)));
-  vuint8m1_t seq = vid_v_u8m1(8);
-  vuint8m1_t index = vsll_vx_u8m1(seq, 1, 8);
-  return v_uint16x8(vget_v_u16m2_u16m1(
-      vwaddu_vv_u16m2(vrgather_vv_u8m1(tmp, index, 8),
-                      vrgather_vv_u8m1(tmp, vadd_vx_u8m1(index, 1, 8), 8), 8),
-      0));
-}
-
-inline v_uint32x4 v_popcount(const v_uint32x4 &a) {
-  vuint8m1_t tmp = vcnt_u8(vreinterpret_v_u32m1_u8m1(a.val));
-  vuint8m1_t seq = vid_v_u8m1(8);
-  vuint8m1_t index = vsll_vx_u8m1(seq, 1, 8);
-  vuint8m1_t sum =
-      vadd_vv_u8m1(vrgather_vv_u8m1(tmp, index, 8),
-                   vrgather_vv_u8m1(tmp, vadd_vx_u8m1(index, 1, 8), 8), 8);
-  return v_uint32x4(vget_v_u32m4_u32m1(
-      vwaddu_vx_u32m4(
-          vwaddu_vv_u16m2(vrgather_vv_u8m1(sum, index, 4),
-                          vrgather_vv_u8m1(sum, vadd_vx_u8m1(index, 1, 4), 4),
-                          4),
-          0, 4),
-      0));
-}
-
-inline v_uint32x4 v_popcount(const v_int32x4 &a) {
-  vuint8m1_t tmp =
-      vcnt_u8(vreinterpret_v_i8m1_u8m1(vreinterpret_v_i32m1_i8m1(a.val)));
-  vuint8m1_t seq = vid_v_u8m1(8);
-  vuint8m1_t index = vsll_vx_u8m1(seq, 1, 8);
-  vuint8m1_t sum =
-      vadd_vv_u8m1(vrgather_vv_u8m1(tmp, index, 8),
-                   vrgather_vv_u8m1(tmp, vadd_vx_u8m1(index, 1, 8), 8), 8);
-  return v_uint32x4(vget_v_u32m4_u32m1(
-      vwaddu_vx_u32m4(
-          vwaddu_vv_u16m2(vrgather_vv_u8m1(sum, index, 4),
-                          vrgather_vv_u8m1(sum, vadd_vx_u8m1(index, 1, 4), 4),
-                          4),
-          0, 4),
-      0));
-}
-
-inline v_uint64x2 v_popcount(const v_uint64x2 &a) {
-  vuint8m1_t tmp = vcnt_u8(vreinterpret_v_u64m1_u8m1(a.val));
-  vuint16m2_t tmp16 = vwaddu_vx_u16m2(tmp, 0, 16);
-  vuint16m1_t res1 = vundefined_u16m1();
-  vuint16m1_t res2 = vundefined_u16m1();
-  res1 = vredsum_vs_u16m1_u16m1(res1, vget_v_u16m2_u16m1(tmp16, 0),
-                                vmv_v_x_u16m1(0, 8), 8);
-  res2 = vredsum_vs_u16m1_u16m1(res2, vget_v_u16m2_u16m1(tmp16, 1),
-                                vmv_v_x_u16m1(0, 8), 8);
-  return v_uint64x2((unsigned long)vmv_x_s_u16m1_u16(res1),
-                    (unsigned long)vmv_x_s_u16m1_u16(res2));
-}
-
-inline v_uint64x2 v_popcount(const v_int64x2 &a) {
-  vuint8m1_t tmp =
-      vcnt_u8(vreinterpret_v_i8m1_u8m1(vreinterpret_v_i64m1_i8m1(a.val)));
-  vuint16m2_t tmp16 = vwaddu_vx_u16m2(tmp, 0, 16);
-  vuint16m1_t res1 = vundefined_u16m1(), res2 = vundefined_u16m1();
-  res1 = vredsum_vs_u16m1_u16m1(res1, vget_v_u16m2_u16m1(tmp16, 0),
-                                vmv_v_x_u16m1(0, 8), 8);
-  res2 = vredsum_vs_u16m1_u16m1(res2, vget_v_u16m2_u16m1(tmp16, 1),
-                                vmv_v_x_u16m1(0, 8), 8);
-  return v_uint64x2((unsigned long)vmv_x_s_u16m1_u16(res1),
-                    (unsigned long)vmv_x_s_u16m1_u16(res2));
-}
-
-#define SMASK 1, 2, 4, 8, 16, 32, 64, 128
-inline int v_signmask(const v_uint8x16 &a) {
-  vuint16m1_t res = vundefined_u16m1();
-  vuint8m1_t id = vid_v_u8m1(16);
-  vuint16m2_t num =
-      vsll_vv_u16m2(vmv_v_x_u16m2(1, 16), vwaddu_vx_u16m2(id, 0, 16), 16);
-  vuint8m1_t t0 = vsrl_vx_u8m1(a.val, 7, 16);
-  vbool8_t mask = vmseq_vx_u8m1_b8(t0, 1, 16);
-  res = vredsum_vs_u16m2_u16m1_m(mask, res, num, vmv_v_x_u16m1(0, 8), 16);
-  return vmv_x_s_u16m1_u16(res);
-}
-inline int v_signmask(const v_int8x16 &a) {
-  vuint16m1_t res = vundefined_u16m1();
-  vuint8m1_t id = vid_v_u8m1(16);
-  vuint16m2_t num =
-      vsll_vv_u16m2(vmv_v_x_u16m2(1, 16), vwaddu_vx_u16m2(id, 0, 16), 16);
-  vbool8_t mask = vmslt_vx_i8m1_b8(a.val, 0, 16);
-  res = vredsum_vs_u16m2_u16m1_m(mask, res, num, vmv_v_x_u16m1(0, 8), 16);
-  return vmv_x_s_u16m1_u16(res);
-}
-
-inline int v_signmask(const v_int16x8 &a) {
-  vuint16m1_t res = vundefined_u16m1();
-  vuint16m1_t id = vid_v_u16m1(8);
-  vuint16m1_t num = vsll_vv_u16m1(vmv_v_x_u16m1(1, 8), id, 8);
-  vbool16_t mask = vmslt_vx_i16m1_b16(a.val, 0, 8);
-  res = vredsum_vs_u16m1_u16m1_m(mask, res, num, vmv_v_x_u16m1(0, 8), 16);
-  return vmv_x_s_u16m1_u16(res);
-}
-inline int v_signmask(const v_uint16x8 &a) {
-  vuint16m1_t res = vundefined_u16m1();
-  vuint16m1_t id = vid_v_u16m1(8);
-  vuint16m1_t num = vsll_vv_u16m1(vmv_v_x_u16m1(1, 8), id, 8);
-  vuint16m1_t t0 = vsrl_vx_u16m1(a.val, 15, 8);
-  vbool16_t mask = vmseq_vx_u16m1_b16(t0, 1, 8);
-  res = vredsum_vs_u16m1_u16m1_m(mask, res, num, vmv_v_x_u16m1(0, 8), 8);
-  return vmv_x_s_u16m1_u16(res);
-}
-inline int v_signmask(const v_int32x4 &a) {
-  vuint32m1_t res = vundefined_u32m1();
-  vuint32m1_t id = vid_v_u32m1(4);
-  vuint32m1_t num = vsll_vv_u32m1(vmv_v_x_u32m1(1, 4), id, 4);
-  vbool32_t mask = vmslt_vx_i32m1_b32(a.val, 0, 4);
-  res = vredsum_vs_u32m1_u32m1_m(mask, res, num, vmv_v_x_u32m1(0, 4), 4);
-  return vmv_x_s_u32m1_u32(res);
-}
-inline int v_signmask(const v_uint32x4 &a) {
-  vuint32m1_t res = vundefined_u32m1();
-  vuint32m1_t id = vid_v_u32m1(4);
-  vuint32m1_t num = vsll_vv_u32m1(vmv_v_x_u32m1(1, 4), id, 4);
-  vuint32m1_t t0 = vsrl_vx_u32m1(a.val, 31, 4);
-  vbool32_t mask = vmseq_vx_u32m1_b32(t0, 1, 4);
-  res = vredsum_vs_u32m1_u32m1_m(mask, res, num, vmv_v_x_u32m1(0, 4), 4);
-  return vmv_x_s_u32m1_u32(res);
-}
-inline int v_signmask(const v_uint64x2 &a) {
-  vuint64m1_t res = vundefined_u64m1();
-  vuint64m1_t id = vid_v_u64m1(2);
-  vuint64m1_t num = vsll_vv_u64m1(vmv_v_x_u64m1(1, 2), id, 2);
-  vuint64m1_t t0 = vsrl_vx_u64m1(a.val, 63, 2);
-  vbool64_t mask = vmseq_vx_u64m1_b64(t0, 1, 2);
-  res = vredsum_vs_u64m1_u64m1_m(mask, res, num, vmv_v_x_u64m1(0, 2), 2);
-  return vmv_x_s_u64m1_u64(res);
-}
-inline int v_signmask(const v_int64x2 &a) {
-  return v_signmask(v_reinterpret_as_u64(a));
-}
-inline int v_signmask(const v_float64x2 &a) {
-  return v_signmask(v_reinterpret_as_u64(a));
-}
-inline int v_signmask(const v_float32x4 &a) {
-  return v_signmask(v_reinterpret_as_u32(a));
-  /*
-  vuint32m1_t res;
-  vuint32m1_t id = vid_v_u32m1(4);
-  vuint32m1_t num = vsll_vv_u32m1(vmv_v_x_u32m1(1, 4), id, 4);
-  vbool32_t mask = vmflt_vf_f32m1_b32(a.val, 0, 4);
-  res = vredsum_vs_u32m1_u32m1_m(mask, res, num, vmv_v_x_u32m1(0, 4), 4);
-  return vmv_x_s_u32m1_u32(res);*/
-}
-
-inline int v_scan_forward(const v_int8x16 &a) {
-  int val = v_signmask(a);
-  if (val == 0)
-    return 0;
-  else
-    return trailingZeros32(val);
-}
-inline int v_scan_forward(const v_uint8x16 &a) {
-  int val = v_signmask(a);
-  if (val == 0)
-    return 0;
-  else
-    return trailingZeros32(val);
-}
-inline int v_scan_forward(const v_int16x8 &a) {
-  int val = v_signmask(a);
-  if (val == 0)
-    return 0;
-  else
-    return trailingZeros32(val);
-}
-inline int v_scan_forward(const v_uint16x8 &a) {
-  int val = v_signmask(a);
-  if (val == 0)
-    return 0;
-  else
-    return trailingZeros32(val);
-}
-inline int v_scan_forward(const v_int32x4 &a) {
-  int val = v_signmask(a);
-  if (val == 0)
-    return 0;
-  else
-    return trailingZeros32(val);
-}
-inline int v_scan_forward(const v_uint32x4 &a) {
-  int val = v_signmask(a);
-  if (val == 0)
-    return 0;
-  else
-    return trailingZeros32(val);
-}
-inline int v_scan_forward(const v_float32x4 &a) {
-  int val = v_signmask(a);
-  if (val == 0)
-    return 0;
-  else
-    return trailingZeros32(val);
-}
-inline int v_scan_forward(const v_int64x2 &a) {
-  int val = v_signmask(a);
-  if (val == 0)
-    return 0;
-  else
-    return trailingZeros32(val);
-}
-inline int v_scan_forward(const v_uint64x2 &a) {
-  int val = v_signmask(a);
-  if (val == 0)
-    return 0;
-  else
-    return trailingZeros32(val);
-}
-
-#define OPENCV_HAL_IMPL_RISCVV_CHECK_ALLANY(_Tpvec, suffix, _T, shift, num,    \
-                                            mask_b)                            \
-  inline bool v_check_all(const v_##_Tpvec &a) {                               \
-    suffix##m1_t v0 = vsrl_vx_##_T(vnot_v_##_T(a.val, num), shift, num);       \
-    return (vcpop_m_##mask_b(vmseq_vx_##_T##_##mask_b(v0, 1, num), num)) == 0; \
-  }                                                                            \
-  inline bool v_check_any(const v_##_Tpvec &a) {                               \
-    suffix##m1_t v0 = vsrl_vx_##_T(a.val, shift, num);                         \
-    return (vcpop_m_##mask_b(vmseq_vx_##_T##_##mask_b(v0, 1, num), num)) != 0; \
-  }
-
-OPENCV_HAL_IMPL_RISCVV_CHECK_ALLANY(uint8x16, vuint8, u8m1, 7, 16, b8)
-OPENCV_HAL_IMPL_RISCVV_CHECK_ALLANY(uint16x8, vuint16, u16m1, 15, 8, b16)
-OPENCV_HAL_IMPL_RISCVV_CHECK_ALLANY(uint32x4, vuint32, u32m1, 31, 4, b32)
-OPENCV_HAL_IMPL_RISCVV_CHECK_ALLANY(uint64x2, vuint64, u64m1, 63, 2, b64)
-
-inline bool v_check_all(const v_int8x16 &a) {
-  return v_check_all(v_reinterpret_as_u8(a));
-}
-inline bool v_check_all(const v_int16x8 &a) {
-  return v_check_all(v_reinterpret_as_u16(a));
-}
-inline bool v_check_all(const v_int32x4 &a) {
-  return v_check_all(v_reinterpret_as_u32(a));
-}
-inline bool v_check_all(const v_float32x4 &a) {
-  return v_check_all(v_reinterpret_as_u32(a));
-}
-inline bool v_check_all(const v_int64x2 &a) {
-  return v_check_all(v_reinterpret_as_u64(a));
-}
-inline bool v_check_all(const v_float64x2 &a) {
-  return v_check_all(v_reinterpret_as_u64(a));
-}
-
-inline bool v_check_any(const v_int8x16 &a) {
-  return v_check_any(v_reinterpret_as_u8(a));
-}
-inline bool v_check_any(const v_int16x8 &a) {
-  return v_check_any(v_reinterpret_as_u16(a));
-}
-inline bool v_check_any(const v_int32x4 &a) {
-  return v_check_any(v_reinterpret_as_u32(a));
-}
-inline bool v_check_any(const v_float32x4 &a) {
-  return v_check_any(v_reinterpret_as_u32(a));
-}
-inline bool v_check_any(const v_int64x2 &a) {
-  return v_check_any(v_reinterpret_as_u64(a));
-}
-inline bool v_check_any(const v_float64x2 &a) {
-  return v_check_any(v_reinterpret_as_u64(a));
-}
-
-#define OPENCV_HAL_IMPL_RISCVV_SELECT(_Tpvec, suffix, _Tpvec2, num, mask_func) \
-  inline _Tpvec v_select(const _Tpvec &mask, const _Tpvec &a,                  \
-                         const _Tpvec &b) {                                    \
-    return _Tpvec(                                                             \
-        vmerge_vvm_##suffix(mask_func(mask.val, 0, num), b.val, a.val, num));  \
-  }
-
-OPENCV_HAL_IMPL_RISCVV_SELECT(v_int8x16, i8m1, vbool8_t, 16, vmsne_vx_i8m1_b8)
-OPENCV_HAL_IMPL_RISCVV_SELECT(v_int16x8, i16m1, vbool16_t, 8,
-                              vmsne_vx_i16m1_b16)
-OPENCV_HAL_IMPL_RISCVV_SELECT(v_int32x4, i32m1, vbool32_t, 4,
-                              vmsne_vx_i32m1_b32)
-OPENCV_HAL_IMPL_RISCVV_SELECT(v_uint8x16, u8m1, vbool8_t, 16, vmsne_vx_u8m1_b8)
-OPENCV_HAL_IMPL_RISCVV_SELECT(v_uint16x8, u16m1, vbool16_t, 8,
-                              vmsne_vx_u16m1_b16)
-OPENCV_HAL_IMPL_RISCVV_SELECT(v_uint32x4, u32m1, vbool32_t, 4,
-                              vmsne_vx_u32m1_b32)
-inline v_float32x4 v_select(const v_float32x4 &mask, const v_float32x4 &a,
-                            const v_float32x4 &b) {
-  return v_float32x4(
-      vmerge_vvm_f32m1(vmfne_vf_f32m1_b32(mask.val, 0, 4), b.val, a.val, 4));
-}
-inline v_float64x2 v_select(const v_float64x2 &mask, const v_float64x2 &a,
-                            const v_float64x2 &b) {
-  return v_float64x2(
-      vmerge_vvm_f64m1(vmfne_vf_f64m1_b64(mask.val, 0, 2), b.val, a.val, 2));
-}
-
-#define OPENCV_HAL_IMPL_RISCVV_EXPAND(add, _Tpvec, _Tpwvec, _Tp, _Tp1, num1,   \
-                                      _Tp2, num2, _T1, _T2, num3)              \
-  inline void v_expand(const _Tpvec &a, v_##_Tpwvec &b0, v_##_Tpwvec &b1) {    \
-    _T1##_t b = vw##add##_vx_##_Tp2##m2(a.val, 0, num1);                       \
-    b0.val = vget_v_##_Tp2##m2_##_Tp2##m1(b, 0);                               \
-    b1.val = vget_v_##_Tp2##m2_##_Tp2##m1(b, 1);                               \
-  }                                                                            \
-  inline v_##_Tpwvec v_expand_low(const _Tpvec &a) {                           \
-    _T1##_t b = vw##add##_vx_##_Tp2##m2(a.val, 0, num2);                       \
-    return v_##_Tpwvec(vget_v_##_Tp2##m2_##_Tp2##m1(b, 0));                    \
-  }                                                                            \
-  inline v_##_Tpwvec v_expand_high(const _Tpvec &a) {                          \
-    _T1##_t b = vw##add##_vx_##_Tp2##m2(a.val, 0, num1);                       \
-    return v_##_Tpwvec(vget_v_##_Tp2##m2_##_Tp2##m1(b, 1));                    \
-  }                                                                            \
-  inline v_##_Tpwvec v_load_expand(const _Tp *ptr) {                           \
-    _T2##_t val = vle##num3##_v_##_Tp1(ptr, num2);                             \
-    _T1##_t b = vw##add##_vx_##_Tp2##m2(val, 0, num2);                         \
-    return v_##_Tpwvec(vget_v_##_Tp2##m2_##_Tp2##m1(b, 0));                    \
-  }
-
-OPENCV_HAL_IMPL_RISCVV_EXPAND(addu, v_uint8x16, uint16x8, uchar, u8m1, 16, u16,
-                              8, vuint16m2, vuint8m1, 8)
-OPENCV_HAL_IMPL_RISCVV_EXPAND(addu, v_uint16x8, uint32x4, ushort, u16m1, 8, u32,
-                              4, vuint32m2, vuint16m1, 16)
-OPENCV_HAL_IMPL_RISCVV_EXPAND(addu, v_uint32x4, uint64x2, uint, u32m1, 4, u64,
-                              2, vuint64m2, vuint32m1, 32)
-OPENCV_HAL_IMPL_RISCVV_EXPAND(add, v_int8x16, int16x8, schar, i8m1, 16, i16, 8,
-                              vint16m2, vint8m1, 8)
-OPENCV_HAL_IMPL_RISCVV_EXPAND(add, v_int16x8, int32x4, short, i16m1, 8, i32, 4,
-                              vint32m2, vint16m1, 16)
-OPENCV_HAL_IMPL_RISCVV_EXPAND(add, v_int32x4, int64x2, int, i32m1, 4, i64, 2,
-                              vint64m2, vint32m1, 32)
-
-inline v_uint32x4 v_load_expand_q(const uchar *ptr) {
-  vuint16m2_t b = vundefined_u16m2();
-  vuint32m2_t c = vundefined_u32m2();
-  vuint8m1_t val = vle8_v_u8m1(ptr, 4);
-  b = vwaddu_vv_u16m2(val, vmv_v_x_u8m1(0, 4), 4);
-  c = vwaddu_vv_u32m2(vget_v_u16m2_u16m1(b, 0), vmv_v_x_u16m1(0, 4), 4);
-  return v_uint32x4(vget_v_u32m2_u32m1(c, 0));
-}
-
-inline v_int32x4 v_load_expand_q(const schar *ptr) {
-  vint16m2_t b = vundefined_i16m2();
-  vint32m2_t c = vundefined_i32m2();
-  vint8m1_t val = vle8_v_i8m1(ptr, 4);
-  b = vwadd_vv_i16m2(val, vmv_v_x_i8m1(0, 4), 4);
-  c = vwadd_vv_i32m2(vget_v_i16m2_i16m1(b, 0), vmv_v_x_i16m1(0, 4), 4);
-  return v_int32x4(vget_v_i32m2_i32m1(c, 0));
-}
-#define VITL_16                                                                \
-  {0x11011000, 0x13031202, 0x15051404, 0x17071606,                             \
-   0x19091808, 0x1B0B1A0A, 0x1D0D1C0C, 0x1F0F1E0E}
-#define VITL_8                                                                 \
-  {0x00080000, 0x00090001, 0x000A0002, 0x000B0003,                             \
-   0x000C0004, 0x000D0005, 0x000E0006, 0x000F0007}
-#define VITL_4                                                                 \
-  {0x00000000, 0x00000004, 0x00000001, 0x00000005,                             \
-   0x00000002, 0x00000006, 0x00000003, 0x00000007}
-#define VITL_2 {0, 0, 2, 0, 1, 0, 3, 0}
-
-#define OPENCV_HAL_IMPL_RISCVV_UNPACKS(_Tpvec, _Tp, _T, _UTp, _UT, num, num2,  \
-                                       len, numh, refunc)                      \
-  inline void v_zip(const v_##_Tpvec &a0, const v_##_Tpvec &a1,                \
-                    v_##_Tpvec &b0, v_##_Tpvec &b1) {                          \
-    v##_Tp##m2_t tmp = vundefined_##_T##m2();                                  \
-    tmp = vset_v_##_T##m1_##_T##m2(tmp, 0, a0.val);                            \
-    tmp = vset_v_##_T##m1_##_T##m2(tmp, 1, a1.val);                            \
-    unsigned mdata[] = VITL_##num;                                             \
-    vuint32m2_t mask = vle32_v_u32m2(mdata, 8);                                \
-    tmp = (v##_Tp##m2_t)vrgather_vv_##_T##m2((v##_Tp##m2_t)tmp, refunc(mask),  \
-                                             num2);                            \
-    b0.val = vget_v_##_T##m2_##_T##m1(tmp, 0);                                 \
-    b1.val = vget_v_##_T##m2_##_T##m1(tmp, 1);                                 \
-  }                                                                            \
-  inline v_##_Tpvec v_combine_low(const v_##_Tpvec &a, const v_##_Tpvec &b) {  \
-    v##_Tp##m1_t b0 =                                                          \
-        vslideup_vx_##_T##m1_m(vmset_m_##len(num), a.val, b.val, numh, num);   \
-    return v_##_Tpvec(b0);                                                     \
-  }                                                                            \
-  inline v_##_Tpvec v_combine_high(const v_##_Tpvec &a, const v_##_Tpvec &b) { \
-    v##_Tp##m1_t b0 = vundefined_##_T##m1();                                   \
-    v##_Tp##m1_t a0 = vundefined_##_T##m1();                                   \
-    v##_Tp##m1_t b1 = vundefined_##_T##m1();                                   \
-    b0 = vslidedown_vx_##_T##m1(b0, b.val, numh, num);                         \
-    a0 = vslidedown_vx_##_T##m1(a0, a.val, numh, num);                         \
-    b1 = vslideup_vx_##_T##m1_m(vmset_m_##len(num), a0, b0, numh, num);        \
-    return v_##_Tpvec(b1);                                                     \
-  }                                                                            \
-  inline void v_recombine(const v_##_Tpvec &a, const v_##_Tpvec &b,            \
-                          v_##_Tpvec &c, v_##_Tpvec &d) {                      \
-    v##_Tp##m1_t b0 = vundefined_##_T##m1();                                   \
-    v##_Tp##m1_t a0 = vundefined_##_T##m1();                                   \
-    c.val =                                                                    \
-        vslideup_vx_##_T##m1_m(vmset_m_##len(num), a.val, b.val, numh, num);   \
-    b0 = vslidedown_vx_##_T##m1(b0, b.val, numh, num);                         \
-    a0 = vslidedown_vx_##_T##m1(a0, a.val, numh, num);                         \
-    d.val = vslideup_vx_##_T##m1_m(vmset_m_##len(num), a0, b0, numh, num);     \
-  }
-
-OPENCV_HAL_IMPL_RISCVV_UNPACKS(uint8x16, uint8, u8, uint8, u8, 16, 32, b8, 8,
-                               vreinterpret_v_u32m2_u8m2)
-OPENCV_HAL_IMPL_RISCVV_UNPACKS(int8x16, int8, i8, uint8, u8, 16, 32, b8, 8,
-                               vreinterpret_v_u32m2_u8m2)
-OPENCV_HAL_IMPL_RISCVV_UNPACKS(uint16x8, uint16, u16, uint16, u16, 8, 16, b16,
-                               4, vreinterpret_v_u32m2_u16m2)
-OPENCV_HAL_IMPL_RISCVV_UNPACKS(int16x8, int16, i16, uint16, u16, 8, 16, b16, 4,
-                               vreinterpret_v_u32m2_u16m2)
-OPENCV_HAL_IMPL_RISCVV_UNPACKS(uint32x4, uint32, u32, uint32, u32, 4, 8, b32,
-                               2, )
-OPENCV_HAL_IMPL_RISCVV_UNPACKS(int32x4, int32, i32, uint32, u32, 4, 8, b32, 2, )
-OPENCV_HAL_IMPL_RISCVV_UNPACKS(float32x4, float32, f32, uint32, u32, 4, 8, b32,
-                               2, )
-OPENCV_HAL_IMPL_RISCVV_UNPACKS(float64x2, float64, f64, uint64, u64, 2, 4, b64,
-                               1, vreinterpret_v_u32m2_u64m2)
-
-inline v_uint8x16 v_reverse(const v_uint8x16 &a) {
-  return v_uint8x16(
-      vrgather_vv_u8m1(a.val, vrsub_vx_u8m1(vid_v_u8m1(16), 15, 16), 16));
-}
-inline v_int8x16 v_reverse(const v_int8x16 &a) {
-  return v_int8x16(
-      vrgather_vv_i8m1(a.val, vrsub_vx_u8m1(vid_v_u8m1(16), 15, 16), 16));
-}
-
-inline v_uint16x8 v_reverse(const v_uint16x8 &a) {
-  return v_uint16x8(
-      vrgather_vv_u16m1(a.val, vrsub_vx_u16m1(vid_v_u16m1(8), 7, 8), 8));
-}
-
-inline v_int16x8 v_reverse(const v_int16x8 &a) {
-  return v_int16x8(
-      vrgather_vv_i16m1(a.val, vrsub_vx_u16m1(vid_v_u16m1(8), 7, 8), 8));
-}
-inline v_uint32x4 v_reverse(const v_uint32x4 &a) {
-  return v_uint32x4(
-      vrgather_vv_u32m1(a.val, vrsub_vx_u32m1(vid_v_u32m1(4), 3, 4), 4));
-}
-
-inline v_int32x4 v_reverse(const v_int32x4 &a) {
-  return v_int32x4(
-      vrgather_vv_i32m1(a.val, vrsub_vx_u32m1(vid_v_u32m1(4), 3, 4), 4));
-}
-
-inline v_float32x4 v_reverse(const v_float32x4 &a) {
-  return v_reinterpret_as_f32(v_reverse(v_reinterpret_as_u32(a)));
-}
-
-inline v_uint64x2 v_reverse(const v_uint64x2 &a) {
-  return v_uint64x2(
-      vrgather_vv_u64m1(a.val, vrsub_vx_u64m1(vid_v_u64m1(2), 1, 2), 2));
-}
-
-inline v_int64x2 v_reverse(const v_int64x2 &a) {
-  return v_int64x2(
-      vrgather_vv_i64m1(a.val, vrsub_vx_u64m1(vid_v_u64m1(2), 1, 2), 2));
-}
-
-inline v_float64x2 v_reverse(const v_float64x2 &a) {
-  return v_float64x2(
-      vrgather_vv_f64m1(a.val, vrsub_vx_u64m1(vid_v_u64m1(2), 1, 2), 2));
-}
-
-#define OPENCV_HAL_IMPL_RISCVV_EXTRACT(_Tpvec, suffix, size)                   \
-  template <int n> inline _Tpvec v_extract(const _Tpvec &a, const _Tpvec &b) { \
-    return v_rotate_right<n>(a, b);                                            \
-  }
-OPENCV_HAL_IMPL_RISCVV_EXTRACT(v_uint8x16, u8, 0)
-OPENCV_HAL_IMPL_RISCVV_EXTRACT(v_int8x16, s8, 0)
-OPENCV_HAL_IMPL_RISCVV_EXTRACT(v_uint16x8, u16, 1)
-OPENCV_HAL_IMPL_RISCVV_EXTRACT(v_int16x8, s16, 1)
-OPENCV_HAL_IMPL_RISCVV_EXTRACT(v_uint32x4, u32, 2)
-OPENCV_HAL_IMPL_RISCVV_EXTRACT(v_int32x4, s32, 2)
-OPENCV_HAL_IMPL_RISCVV_EXTRACT(v_uint64x2, u64, 3)
-OPENCV_HAL_IMPL_RISCVV_EXTRACT(v_int64x2, s64, 3)
-OPENCV_HAL_IMPL_RISCVV_EXTRACT(v_float32x4, f32, 2)
-OPENCV_HAL_IMPL_RISCVV_EXTRACT(v_float64x2, f64, 3)
-
-#define OPENCV_HAL_IMPL_RISCVV_EXTRACT_N(_Tpvec, _Tp, suffix, vtype, _vtype,   \
-                                         num, mvfunc)                          \
-  template <int i> inline _Tp v_extract_n(_Tpvec v) {                          \
-    vtype tmp = vundefined_##_vtype();                                         \
-    return mvfunc(vslidedown_vx_##_vtype(tmp, v.val, i, num));                 \
-  }
-
-OPENCV_HAL_IMPL_RISCVV_EXTRACT_N(v_uint8x16, uchar, u8, vuint8m1_t, u8m1, 16,
-                                 vmv_x_s_u8m1_u8)
-OPENCV_HAL_IMPL_RISCVV_EXTRACT_N(v_int8x16, schar, s8, vint8m1_t, i8m1, 16,
-                                 vmv_x_s_i8m1_i8)
-OPENCV_HAL_IMPL_RISCVV_EXTRACT_N(v_uint16x8, ushort, u16, vuint16m1_t, u16m1, 8,
-                                 vmv_x_s_u16m1_u16)
-OPENCV_HAL_IMPL_RISCVV_EXTRACT_N(v_int16x8, short, s16, vint16m1_t, i16m1, 8,
-                                 vmv_x_s_i16m1_i16)
-OPENCV_HAL_IMPL_RISCVV_EXTRACT_N(v_uint32x4, uint, u32, vuint32m1_t, u32m1, 4,
-                                 vmv_x_s_u32m1_u32)
-OPENCV_HAL_IMPL_RISCVV_EXTRACT_N(v_int32x4, int, s32, vint32m1_t, i32m1, 4,
-                                 vmv_x_s_i32m1_i32)
-OPENCV_HAL_IMPL_RISCVV_EXTRACT_N(v_uint64x2, uint64, u64, vuint64m1_t, u64m1, 2,
-                                 vmv_x_s_u64m1_u64)
-OPENCV_HAL_IMPL_RISCVV_EXTRACT_N(v_int64x2, int64, s64, vint64m1_t, i64m1, 2,
-                                 vmv_x_s_i64m1_i64)
-OPENCV_HAL_IMPL_RISCVV_EXTRACT_N(v_float32x4, float, f32, vfloat32m1_t, f32m1,
-                                 4, vfmv_f_s_f32m1_f32)
-OPENCV_HAL_IMPL_RISCVV_EXTRACT_N(v_float64x2, double, f64, vfloat64m1_t, f64m1,
-                                 2, vfmv_f_s_f64m1_f64)
-
-#define OPENCV_HAL_IMPL_RISCVV_BROADCAST(_Tpvec, _Tp, num)                     \
-  template <int i> inline _Tpvec v_broadcast_element(_Tpvec v) {               \
-    return _Tpvec(vrgather_vx_##_Tp##m1(v.val, i, num));                       \
-  }
-
-OPENCV_HAL_IMPL_RISCVV_BROADCAST(v_uint8x16, u8, 16)
-OPENCV_HAL_IMPL_RISCVV_BROADCAST(v_int8x16, i8, 16)
-OPENCV_HAL_IMPL_RISCVV_BROADCAST(v_uint16x8, u16, 8)
-OPENCV_HAL_IMPL_RISCVV_BROADCAST(v_int16x8, i16, 8)
-OPENCV_HAL_IMPL_RISCVV_BROADCAST(v_uint32x4, u32, 4)
-OPENCV_HAL_IMPL_RISCVV_BROADCAST(v_int32x4, i32, 4)
-OPENCV_HAL_IMPL_RISCVV_BROADCAST(v_uint64x2, u64, 2)
-OPENCV_HAL_IMPL_RISCVV_BROADCAST(v_int64x2, i64, 2)
-OPENCV_HAL_IMPL_RISCVV_BROADCAST(v_float32x4, f32, 4)
-
-inline void __builtin_riscv_fsrm(int val) {
-  asm("csrw frm, %0\n\t" : : "r"(val));
-  return;
-}
-
-inline void barrier1(void *arg) {
-  __asm__ __volatile__("" : : "r"(arg) : "memory");
-}
-
-inline v_int32x4 v_round(const v_float32x4 &a) {
-  __builtin_riscv_fsrm(0);
-  vint32m1_t nan =
-      vand_vx_i32m1(vreinterpret_v_f32m1_i32m1(a.val), 0x7f800000, 4);
-  barrier1(&nan);
-  vbool32_t mask = vmsne_vx_i32m1_b32(nan, 0x7f800000, 4);
-  vint32m1_t val = vfcvt_x_f_v_i32m1_m(mask, vmv_v_x_i32m1(0, 4), a.val, 4);
-  __builtin_riscv_fsrm(0);
-  return v_int32x4(val);
-}
-inline v_int32x4 v_floor(const v_float32x4 &a) {
-  __builtin_riscv_fsrm(2);
-  vint32m1_t nan =
-      vand_vx_i32m1(vreinterpret_v_f32m1_i32m1(a.val), 0x7f800000, 4);
-  barrier1(&nan);
-  vbool32_t mask = vmsne_vx_i32m1_b32(nan, 0x7f800000, 4);
-  vint32m1_t val = vfcvt_x_f_v_i32m1_m(mask, vmv_v_x_i32m1(0, 4), a.val, 4);
-  __builtin_riscv_fsrm(0);
-  return v_int32x4(val);
-}
-
-inline v_int32x4 v_ceil(const v_float32x4 &a) {
-  __builtin_riscv_fsrm(3);
-  vint32m1_t nan =
-      vand_vx_i32m1(vreinterpret_v_f32m1_i32m1(a.val), 0x7f800000, 4);
-  barrier1(&nan);
-  vbool32_t mask = vmsne_vx_i32m1_b32(nan, 0x7f800000, 4);
-  vint32m1_t val = vfcvt_x_f_v_i32m1_m(mask, vmv_v_x_i32m1(0, 4), a.val, 4);
-  __builtin_riscv_fsrm(0);
-  return v_int32x4(val);
-}
-
-inline v_int32x4 v_trunc(const v_float32x4 &a) {
-  __builtin_riscv_fsrm(1);
-  vint32m1_t nan =
-      vand_vx_i32m1(vreinterpret_v_f32m1_i32m1(a.val), 0x7f800000, 4);
-  barrier1(&nan);
-  vbool32_t mask = vmsne_vx_i32m1_b32(nan, 0x7f800000, 4);
-  vint32m1_t val = vfcvt_x_f_v_i32m1_m(mask, vmv_v_x_i32m1(0, 4), a.val, 4);
-  __builtin_riscv_fsrm(0);
-  return v_int32x4(val);
-}
-
-inline v_int32x4 v_round(const v_float64x2 &a) {
-  __builtin_riscv_fsrm(0);
-  vfloat64m2_t _val = vundefined_f64m2();
-  _val = vset_v_f64m1_f64m2(_val, 0, a.val);
-  //_val = vset_f64m2(_val, 1, a.val);
-  _val = vset_v_f64m1_f64m2(_val, 1, vfmv_v_f_f64m1(0, 2));
-  barrier1(&_val);
-  vint32m1_t val = vfncvt_x_f_w_i32m1(_val, 4);
-  __builtin_riscv_fsrm(0);
-  return v_int32x4(val);
-}
-inline v_int32x4 v_round(const v_float64x2 &a, const v_float64x2 &b) {
-  __builtin_riscv_fsrm(0);
-  vfloat64m2_t _val = vundefined_f64m2();
-  _val = vset_v_f64m1_f64m2(_val, 0, a.val);
-  _val = vset_v_f64m1_f64m2(_val, 1, b.val);
-  barrier1(&_val);
-  vint32m1_t val = vfncvt_x_f_w_i32m1(_val, 4);
-  __builtin_riscv_fsrm(0);
-  return v_int32x4(val);
-}
-inline v_int32x4 v_floor(const v_float64x2 &a) {
-  __builtin_riscv_fsrm(2);
-  vfloat64m2_t _val = vundefined_f64m2();
-  _val = vset_v_f64m1_f64m2(_val, 0, a.val);
-  vfloat32m1_t aval = vfncvt_f_f_w_f32m1(_val, 2);
-  vint32m1_t nan =
-      vand_vx_i32m1(vreinterpret_v_f32m1_i32m1(aval), 0x7f800000, 4);
-  barrier1(&nan);
-  vbool32_t mask = vmsne_vx_i32m1_b32(nan, 0x7f800000, 4);
-  vint32m1_t val = vfcvt_x_f_v_i32m1_m(mask, vmv_v_x_i32m1(0, 4), aval, 4);
-  __builtin_riscv_fsrm(0);
-  return v_int32x4(val);
-}
-
-inline v_int32x4 v_ceil(const v_float64x2 &a) {
-  __builtin_riscv_fsrm(3);
-  vfloat64m2_t _val = vundefined_f64m2();
-  _val = vset_v_f64m1_f64m2(_val, 0, a.val);
-  vfloat32m1_t aval = vfncvt_f_f_w_f32m1(_val, 2);
-  vint32m1_t nan =
-      vand_vx_i32m1(vreinterpret_v_f32m1_i32m1(aval), 0x7f800000, 4);
-  barrier1(&nan);
-  vbool32_t mask = vmsne_vx_i32m1_b32(nan, 0x7f800000, 4);
-  vint32m1_t val = vfcvt_x_f_v_i32m1_m(mask, vmv_v_x_i32m1(0, 4), aval, 4);
-  __builtin_riscv_fsrm(0);
-  return v_int32x4(val);
-}
-
-inline v_int32x4 v_trunc(const v_float64x2 &a) {
-  __builtin_riscv_fsrm(1);
-  vfloat64m2_t _val = vundefined_f64m2();
-  _val = vset_v_f64m1_f64m2(_val, 0, a.val);
-  vfloat32m1_t aval = vfncvt_f_f_w_f32m1(_val, 2);
-  vint32m1_t nan =
-      vand_vx_i32m1(vreinterpret_v_f32m1_i32m1(aval), 0x7f800000, 4);
-  barrier1(&nan);
-  vbool32_t mask = vmsne_vx_i32m1_b32(nan, 0x7f800000, 4);
-  vint32m1_t val = vfcvt_x_f_v_i32m1_m(mask, vmv_v_x_i32m1(0, 4), aval, 4);
-  __builtin_riscv_fsrm(0);
-  return v_int32x4(val);
-}
-
-#define OPENCV_HAL_IMPL_RISCVV_LOAD_DEINTERLEAVED(intrin, _Tpvec, num, _Tp,    \
-                                                  _T, elemsize)                \
-  inline void v_load_deinterleave(const _Tp *ptr, v_##_Tpvec##x##num &a,       \
-                                  v_##_Tpvec##x##num &b) {                     \
-    intrin##2e##elemsize##_v_##_T##m1(&a.val, &b.val, ptr, num);               \
-  }                                                                            \
-  inline void v_load_deinterleave(const _Tp *ptr, v_##_Tpvec##x##num &a,       \
-                                  v_##_Tpvec##x##num &b,                       \
-                                  v_##_Tpvec##x##num &c) {                     \
-    intrin##3e##elemsize##_v_##_T##m1(&a.val, &b.val, &c.val, ptr, num);       \
-  }                                                                            \
-  inline void v_load_deinterleave(                                             \
-      const _Tp *ptr, v_##_Tpvec##x##num &a, v_##_Tpvec##x##num &b,            \
-      v_##_Tpvec##x##num &c, v_##_Tpvec##x##num &d) {                          \
-    intrin##4e##elemsize##_v_##_T##m1(&a.val, &b.val, &c.val, &d.val, ptr,     \
-                                      num);                                    \
-  }
-
-#define OPENCV_HAL_IMPL_RISCVV_STORE_INTERLEAVED(intrin, _Tpvec, num, _Tp, _T, \
-                                                 elemsize)                     \
-  inline void v_store_interleave(                                              \
-      _Tp *ptr, const v_##_Tpvec##x##num &a, const v_##_Tpvec##x##num &b,      \
-      hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {                        \
-    intrin##2e##elemsize##_v_##_T##m1(ptr, a.val, b.val, num);                 \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp *ptr, const v_##_Tpvec##x##num &a, const v_##_Tpvec##x##num &b,      \
-      const v_##_Tpvec##x##num &c,                                             \
-      hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {                        \
-    intrin##3e##elemsize##_v_##_T##m1(ptr, a.val, b.val, c.val, num);          \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp *ptr, const v_##_Tpvec##x##num &a, const v_##_Tpvec##x##num &b,      \
-      const v_##_Tpvec##x##num &c, const v_##_Tpvec##x##num &d,                \
-      hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {                        \
-    intrin##4e##elemsize##_v_##_T##m1(ptr, a.val, b.val, c.val, d.val, num);   \
-  }
-
-#define OPENCV_HAL_IMPL_RISCVV_INTERLEAVED(_Tpvec, _Tp, num, ld, st, _T,       \
-                                           elemsize)                           \
-  OPENCV_HAL_IMPL_RISCVV_LOAD_DEINTERLEAVED(ld, _Tpvec, num, _Tp, _T,          \
-                                            elemsize)                          \
-  OPENCV_HAL_IMPL_RISCVV_STORE_INTERLEAVED(st, _Tpvec, num, _Tp, _T, elemsize)
-
-// OPENCV_HAL_IMPL_RISCVV_INTERLEAVED(uint8, uchar, )
-OPENCV_HAL_IMPL_RISCVV_INTERLEAVED(int8, schar, 16, vlseg, vsseg, i8, 8)
-OPENCV_HAL_IMPL_RISCVV_INTERLEAVED(int16, short, 8, vlseg, vsseg, i16, 16)
-OPENCV_HAL_IMPL_RISCVV_INTERLEAVED(int32, int, 4, vlseg, vsseg, i32, 32)
-
-OPENCV_HAL_IMPL_RISCVV_INTERLEAVED(uint8, unsigned char, 16, vlseg, vsseg, u8,
-                                   8)
-OPENCV_HAL_IMPL_RISCVV_INTERLEAVED(uint16, unsigned short, 8, vlseg, vsseg, u16,
-                                   16)
-OPENCV_HAL_IMPL_RISCVV_INTERLEAVED(uint32, unsigned int, 4, vlseg, vsseg, u32,
-                                   32)
-
-#define OPENCV_HAL_IMPL_RISCVV_INTERLEAVED_(_Tpvec, _Tp, num, _T, _esize)      \
-  inline void v_load_deinterleave(const _Tp *ptr, v_##_Tpvec##x##num &a,       \
-                                  v_##_Tpvec##x##num &b) {                     \
-    vlseg2e##_esize##_v_##_T##m1(&a.val, &b.val, ptr, num);                    \
-  }                                                                            \
-  inline void v_load_deinterleave(const _Tp *ptr, v_##_Tpvec##x##num &a,       \
-                                  v_##_Tpvec##x##num &b,                       \
-                                  v_##_Tpvec##x##num &c) {                     \
-    vlseg3e##_esize##_v_##_T##m1(&a.val, &b.val, &c.val, ptr, num);            \
-  }                                                                            \
-  inline void v_load_deinterleave(                                             \
-      const _Tp *ptr, v_##_Tpvec##x##num &a, v_##_Tpvec##x##num &b,            \
-      v_##_Tpvec##x##num &c, v_##_Tpvec##x##num &d) {                          \
-    vlseg4e##_esize##_v_##_T##m1(&a.val, &b.val, &c.val, &d.val, ptr, num);    \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp *ptr, const v_##_Tpvec##x##num &a, const v_##_Tpvec##x##num &b,      \
-      hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {                        \
-    vsseg2e##_esize##_v_##_T##m1(ptr, a.val, b.val, num);                      \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp *ptr, const v_##_Tpvec##x##num &a, const v_##_Tpvec##x##num &b,      \
-      const v_##_Tpvec##x##num &c,                                             \
-      hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {                        \
-    vsseg3e##_esize##_v_##_T##m1(ptr, a.val, b.val, c.val, num);               \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp *ptr, const v_##_Tpvec##x##num &a, const v_##_Tpvec##x##num &b,      \
-      const v_##_Tpvec##x##num &c, const v_##_Tpvec##x##num &d,                \
-      hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {                        \
-    vsseg4e##_esize##_v_##_T##m1(ptr, a.val, b.val, c.val, d.val, num);        \
-  }
-
-OPENCV_HAL_IMPL_RISCVV_INTERLEAVED_(float32, float, 4, f32, 32)
-OPENCV_HAL_IMPL_RISCVV_INTERLEAVED_(float64, double, 2, f64, 64)
-
-OPENCV_HAL_IMPL_RISCVV_INTERLEAVED_(uint64, unsigned long, 2, u64, 64)
-OPENCV_HAL_IMPL_RISCVV_INTERLEAVED_(int64, long, 2, i64, 64)
-
-inline v_float32x4 v_cvt_f32(const v_int32x4 &a) {
-  return v_float32x4(vfcvt_f_x_v_f32m1(a.val, 4));
-}
-
-#if CV_SIMD128_64F
-inline v_float32x4 v_cvt_f32(const v_float64x2 &a) {
-  vfloat64m2_t _val = vundefined_f64m2();
-  _val = vset_v_f64m1_f64m2(_val, 0, a.val);
-  vfloat32m1_t aval = vfncvt_f_f_w_f32m1(_val, 2);
-  return v_float32x4(aval);
-}
-
-inline v_float32x4 v_cvt_f32(const v_float64x2 &a, const v_float64x2 &b) {
-  vfloat64m2_t _val = vundefined_f64m2();
-  _val = vset_v_f64m1_f64m2(_val, 0, a.val);
-  _val = vset_v_f64m1_f64m2(_val, 1, b.val);
-  vfloat32m1_t aval = vfncvt_f_f_w_f32m1(_val, 4);
-  return v_float32x4(aval);
-}
-
-inline v_float64x2 v_cvt_f64(const v_int32x4 &a) {
-  vfloat32m1_t val = vfcvt_f_x_v_f32m1(a.val, 4);
-  vfloat64m2_t _val = vfwcvt_f_f_v_f64m2(val, 4);
-  return v_float64x2(vget_v_f64m2_f64m1(_val, 0));
-}
-
-inline v_float64x2 v_cvt_f64_high(const v_int32x4 &a) {
-  vfloat32m1_t val = vfcvt_f_x_v_f32m1(a.val, 4);
-  vfloat64m2_t _val = vfwcvt_f_f_v_f64m2(val, 4);
-  return v_float64x2(vget_v_f64m2_f64m1(_val, 1));
-}
-
-inline v_float64x2 v_cvt_f64(const v_float32x4 &a) {
-  vfloat64m2_t _val = vfwcvt_f_f_v_f64m2(a.val, 4);
-  return v_float64x2(vget_v_f64m2_f64m1(_val, 0));
-}
-
-inline v_float64x2 v_cvt_f64_high(const v_float32x4 &a) {
-  vfloat64m2_t _val = vfwcvt_f_f_v_f64m2(a.val, 4);
-  return v_float64x2(vget_v_f64m2_f64m1(_val, 1));
-}
-
-inline v_float64x2 v_cvt_f64(const v_int64x2 &a) {
-  return v_float64x2(vfcvt_f_x_v_f64m1(a.val, 2));
-}
-
-#endif
-inline v_int8x16 v_interleave_pairs(const v_int8x16 &vec) {
-  uint64 mdata[2] = {0x0705060403010200, 0x0F0D0E0C0B090A08};
-  vuint64m1_t m0 = vle64_v_u64m1(mdata, 2);
-  return v_int8x16(
-      vrgather_vv_i8m1(vec.val, vreinterpret_v_u64m1_u8m1(m0), 16));
-}
-inline v_uint8x16 v_interleave_pairs(const v_uint8x16 &vec) {
-  return v_reinterpret_as_u8(v_interleave_pairs(v_reinterpret_as_s8(vec)));
-}
-
-inline v_int8x16 v_interleave_quads(const v_int8x16 &vec) {
-  uint64 mdata[2] = {0x0703060205010400, 0x0F0B0E0A0D090C08};
-  vuint64m1_t m0 = vle64_v_u64m1(mdata, 2);
-  return v_int8x16(
-      vrgather_vv_i8m1(vec.val, vreinterpret_v_u64m1_u8m1(m0), 16));
-}
-inline v_uint8x16 v_interleave_quads(const v_uint8x16 &vec) {
-  return v_reinterpret_as_u8(v_interleave_quads(v_reinterpret_as_s8(vec)));
-}
-
-inline v_int16x8 v_interleave_pairs(const v_int16x8 &vec) {
-  uint64 mdata[2] = {0x0706030205040100, 0x0F0E0B0A0D0C0908};
-  vuint64m1_t m0 = vle64_v_u64m1(mdata, 2);
-  return v_int16x8(
-      vreinterpret_v_i8m1_i16m1(vreinterpret_v_u8m1_i8m1(vrgather_vv_u8m1(
-          vreinterpret_v_i8m1_u8m1(vreinterpret_v_i16m1_i8m1(vec.val)),
-          vreinterpret_v_u64m1_u8m1(m0), 16))));
-}
-inline v_uint16x8 v_interleave_pairs(const v_uint16x8 &vec) {
-  return v_reinterpret_as_u16(v_interleave_pairs(v_reinterpret_as_s16(vec)));
-}
-inline v_int16x8 v_interleave_quads(const v_int16x8 &vec) {
-  uint64 mdata[2] = {0x0B0A030209080100, 0x0F0E07060D0C0504};
-  vuint64m1_t m0 = vle64_v_u64m1(mdata, 2);
-  return v_int16x8(
-      vreinterpret_v_i8m1_i16m1(vreinterpret_v_u8m1_i8m1(vrgather_vv_u8m1(
-          vreinterpret_v_i8m1_u8m1(vreinterpret_v_i16m1_i8m1(vec.val)),
-          vreinterpret_v_u64m1_u8m1(m0), 16))));
-}
-inline v_uint16x8 v_interleave_quads(const v_uint16x8 &vec) {
-  return v_reinterpret_as_u16(v_interleave_quads(v_reinterpret_as_s16(vec)));
-}
-
-inline v_int32x4 v_interleave_pairs(const v_int32x4 &vec) {
-  uint64 mdata[2] = {0x0B0A090803020100, 0x0F0E0D0C07060504};
-  vuint64m1_t m0 = vle64_v_u64m1(mdata, 2);
-  return v_int32x4(
-      vreinterpret_v_i8m1_i32m1(vreinterpret_v_u8m1_i8m1(vrgather_vv_u8m1(
-          vreinterpret_v_i8m1_u8m1(vreinterpret_v_i32m1_i8m1(vec.val)),
-          vreinterpret_v_u64m1_u8m1(m0), 16))));
-}
-inline v_uint32x4 v_interleave_pairs(const v_uint32x4 &vec) {
-  return v_reinterpret_as_u32(v_interleave_pairs(v_reinterpret_as_s32(vec)));
-}
-inline v_float32x4 v_interleave_pairs(const v_float32x4 &vec) {
-  return v_reinterpret_as_f32(v_interleave_pairs(v_reinterpret_as_s32(vec)));
-}
-inline v_int8x16 v_pack_triplets(const v_int8x16 &vec) {
-  uint64 mdata[2] = {0x0908060504020100, 0xFFFFFFFF0E0D0C0A};
-  vuint64m1_t m0 = vle64_v_u64m1(mdata, 2);
-  return v_int8x16(vreinterpret_v_u8m1_i8m1(vrgather_vv_u8m1(
-      vreinterpret_v_i8m1_u8m1(vec.val), vreinterpret_v_u64m1_u8m1(m0), 16)));
-}
-inline v_uint8x16 v_pack_triplets(const v_uint8x16 &vec) {
-  return v_reinterpret_as_u8(v_pack_triplets(v_reinterpret_as_s8(vec)));
-}
-
-inline v_int16x8 v_pack_triplets(const v_int16x8 &vec) {
-  uint64 mdata[2] = {0x0908050403020100, 0xFFFFFFFF0D0C0B0A};
-  vuint64m1_t m0 = vle64_v_u64m1(mdata, 2);
-  return v_int16x8(
-      vreinterpret_v_i8m1_i16m1(vreinterpret_v_u8m1_i8m1(vrgather_vv_u8m1(
-          vreinterpret_v_i8m1_u8m1(vreinterpret_v_i16m1_i8m1(vec.val)),
-          vreinterpret_v_u64m1_u8m1(m0), 16))));
-}
-inline v_uint16x8 v_pack_triplets(const v_uint16x8 &vec) {
-  return v_reinterpret_as_u16(v_pack_triplets(v_reinterpret_as_s16(vec)));
-}
-
-inline v_int32x4 v_pack_triplets(const v_int32x4 &vec) { return vec; }
-inline v_uint32x4 v_pack_triplets(const v_uint32x4 &vec) { return vec; }
-inline v_float32x4 v_pack_triplets(const v_float32x4 &vec) { return vec; }
-
-#if CV_SIMD128_64F
-inline v_float64x2 v_dotprod_expand(const v_int32x4 &a, const v_int32x4 &b) {
-  return v_cvt_f64(v_dotprod(a, b));
-}
-inline v_float64x2 v_dotprod_expand(const v_int32x4 &a, const v_int32x4 &b,
-                                    const v_float64x2 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-inline v_float64x2 v_dotprod_expand_fast(const v_int32x4 &a,
-                                         const v_int32x4 &b) {
-  vint64m2_t v1 = vwmul_vv_i64m2(a.val, b.val, 4);
-  vfloat64m1_t res = vfcvt_f_x_v_f64m1(
-      vadd_vv_i64m1(vget_v_i64m2_i64m1(v1, 0), vget_v_i64m2_i64m1(v1, 1), 2),
-      2);
-  return v_float64x2(res);
-}
-inline v_float64x2 v_dotprod_expand_fast(const v_int32x4 &a, const v_int32x4 &b,
-                                         const v_float64x2 &c) {
-  v_float64x2 res = v_dotprod_expand_fast(a, b);
-  return v_add(res, c);
-}
-#endif
-////// FP16 support ///////
-#if __riscv_v == 7000
-inline v_float32x4 v_load_expand(const hfloat *ptr) {
-  vfloat16m1_t v = vle16_v_f16m1((__fp16 *)ptr, 4);
-  vfloat32m2_t v32 = vfwcvt_f_f_v_f32m2(v, 4);
-  return v_float32x4(vget_v_f32m2_f32m1(v32, 0));
-}
-
-inline void v_pack_store(hfloat *ptr, const v_float32x4 &v) {
-  vfloat32m2_t v32 = vundefined_f32m2();
-  v32 = vset_v_f32m1_f32m2(v32, 0, v.val);
-  vfloat16m1_t hv = vfncvt_f_f_w_f16m1(v32, 4);
-  vse16_v_f16m1((__fp16 *)ptr, hv, 4);
-}
-#else
-inline v_float32x4 v_load_expand(const hfloat *ptr) {
-  vfloat16mf2_t v = vle16_v_f16mf2((__fp16 *)ptr, 4);
-  vfloat32m1_t v32 = vfwcvt_f_f_v_f32m1(v, 4);
-  return v_float32x4(v32);
-}
-
-inline void v_pack_store(hfloat *ptr, const v_float32x4 &v) {
-  // vfloat32m2_t v32 = vundefined_f32m2();
-  // v32 = vset_f32m2(v32, 0, v.val);
-  vfloat16mf2_t hv = vfncvt_f_f_w_f16mf2(v.val, 4);
-  vse16_v_f16mf2((__fp16 *)ptr, hv, 4);
-}
-#endif
-
-inline void v_cleanup() {}
-
-#include "intrin_math.hpp"
-inline v_float32x4 v_exp(const v_float32x4 &x) {
-  return v_exp_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline v_float32x4 v_log(const v_float32x4 &x) {
-  return v_log_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline void v_sincos(const v_float32x4 &x, v_float32x4 &s, v_float32x4 &c) {
-  v_sincos_default_32f<v_float32x4, v_int32x4>(x, s, c);
-}
-inline v_float32x4 v_sin(const v_float32x4 &x) {
-  return v_sin_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline v_float32x4 v_cos(const v_float32x4 &x) {
-  return v_cos_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline v_float32x4 v_erf(const v_float32x4 &x) {
-  return v_erf_default_32f<v_float32x4, v_int32x4>(x);
-}
-
-inline v_float64x2 v_exp(const v_float64x2 &x) {
-  return v_exp_default_64f<v_float64x2, v_int64x2>(x);
-}
-inline v_float64x2 v_log(const v_float64x2 &x) {
-  return v_log_default_64f<v_float64x2, v_int64x2>(x);
-}
-inline void v_sincos(const v_float64x2 &x, v_float64x2 &s, v_float64x2 &c) {
-  v_sincos_default_64f<v_float64x2, v_int64x2>(x, s, c);
-}
-inline v_float64x2 v_sin(const v_float64x2 &x) {
-  return v_sin_default_64f<v_float64x2, v_int64x2>(x);
-}
-inline v_float64x2 v_cos(const v_float64x2 &x) {
-  return v_cos_default_64f<v_float64x2, v_int64x2>(x);
-}
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_END
-
-//! @endcond
-
-} // namespace cv
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_rvv_scalable.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_rvv_scalable.hpp
deleted file mode 100644
index eb6f098e3e..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_rvv_scalable.hpp
+++ /dev/null
@@ -1,2559 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-// The original implementation is contributed by HAN Liutong.
-// Copyright (C) 2022, Institute of Software, Chinese Academy of Sciences.
-
-#ifndef OPENCV_HAL_INTRIN_RVV_SCALABLE_HPP
-#define OPENCV_HAL_INTRIN_RVV_SCALABLE_HPP
-
-#include <opencv2/core/check.hpp>
-
-#if defined(__GNUC__) && !defined(__clang__)
-// FIXIT: eliminate massive warnigs from templates
-// GCC from 'rvv-next': riscv64-unknown-linux-gnu-g++ (g42df3464463) 12.0.1
-// 20220505 (prerelease) doesn't work: #pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wignored-attributes"
-#endif
-
-#ifndef CV_RVV_MAX_VLEN
-#define CV_RVV_MAX_VLEN 1024
-#endif
-
-namespace cv {
-
-//! @cond IGNORED
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_BEGIN
-
-#define CV_SIMD_SCALABLE 1
-#define CV_SIMD_SCALABLE_64F 1
-
-using v_uint8 = vuint8m2_t;
-using v_int8 = vint8m2_t;
-using v_uint16 = vuint16m2_t;
-using v_int16 = vint16m2_t;
-using v_uint32 = vuint32m2_t;
-using v_int32 = vint32m2_t;
-using v_uint64 = vuint64m2_t;
-using v_int64 = vint64m2_t;
-
-using v_float32 = vfloat32m2_t;
-#if CV_SIMD_SCALABLE_64F
-using v_float64 = vfloat64m2_t;
-#endif
-
-using uchar = unsigned char;
-using schar = signed char;
-using ushort = unsigned short;
-using uint = unsigned int;
-using uint64 = unsigned long int;
-using int64 = long int;
-
-template <class T> struct VTraits;
-
-#define OPENCV_HAL_IMPL_RVV_TRAITS(REG, TYP, SUF, SZ)                          \
-  template <> struct VTraits<REG> {                                            \
-    static inline int vlanes() { return __riscv_vsetvlmax_##SUF(); }           \
-    using lane_type = TYP;                                                     \
-    static const int max_nlanes = CV_RVV_MAX_VLEN / SZ;                        \
-  };
-
-OPENCV_HAL_IMPL_RVV_TRAITS(vint8m1_t, int8_t, e8m1, 8)
-OPENCV_HAL_IMPL_RVV_TRAITS(vint8m2_t, int8_t, e8m2, 8)
-OPENCV_HAL_IMPL_RVV_TRAITS(vint8m4_t, int8_t, e8m4, 8)
-OPENCV_HAL_IMPL_RVV_TRAITS(vint8m8_t, int8_t, e8m8, 8)
-OPENCV_HAL_IMPL_RVV_TRAITS(vuint8m1_t, uint8_t, e8m1, 8)
-OPENCV_HAL_IMPL_RVV_TRAITS(vuint8m2_t, uint8_t, e8m2, 8)
-OPENCV_HAL_IMPL_RVV_TRAITS(vuint8m4_t, uint8_t, e8m4, 8)
-OPENCV_HAL_IMPL_RVV_TRAITS(vuint8m8_t, uint8_t, e8m8, 8)
-
-OPENCV_HAL_IMPL_RVV_TRAITS(vint16m1_t, int16_t, e16m1, 16)
-OPENCV_HAL_IMPL_RVV_TRAITS(vint16m2_t, int16_t, e16m2, 16)
-OPENCV_HAL_IMPL_RVV_TRAITS(vint16m4_t, int16_t, e16m4, 16)
-OPENCV_HAL_IMPL_RVV_TRAITS(vint16m8_t, int16_t, e16m8, 16)
-OPENCV_HAL_IMPL_RVV_TRAITS(vuint16m1_t, uint16_t, e16m1, 16)
-OPENCV_HAL_IMPL_RVV_TRAITS(vuint16m2_t, uint16_t, e16m2, 16)
-OPENCV_HAL_IMPL_RVV_TRAITS(vuint16m4_t, uint16_t, e16m4, 16)
-OPENCV_HAL_IMPL_RVV_TRAITS(vuint16m8_t, uint16_t, e16m8, 16)
-
-OPENCV_HAL_IMPL_RVV_TRAITS(vint32m1_t, int32_t, e32m1, 32)
-OPENCV_HAL_IMPL_RVV_TRAITS(vint32m2_t, int32_t, e32m2, 32)
-OPENCV_HAL_IMPL_RVV_TRAITS(vint32m4_t, int32_t, e32m4, 32)
-OPENCV_HAL_IMPL_RVV_TRAITS(vint32m8_t, int32_t, e32m8, 32)
-OPENCV_HAL_IMPL_RVV_TRAITS(vuint32m1_t, uint32_t, e32m1, 32)
-OPENCV_HAL_IMPL_RVV_TRAITS(vuint32m2_t, uint32_t, e32m2, 32)
-OPENCV_HAL_IMPL_RVV_TRAITS(vuint32m4_t, uint32_t, e32m4, 32)
-OPENCV_HAL_IMPL_RVV_TRAITS(vuint32m8_t, uint32_t, e32m8, 32)
-
-OPENCV_HAL_IMPL_RVV_TRAITS(vint64m1_t, int64_t, e64m1, 64)
-OPENCV_HAL_IMPL_RVV_TRAITS(vint64m2_t, int64_t, e64m2, 64)
-OPENCV_HAL_IMPL_RVV_TRAITS(vint64m4_t, int64_t, e64m4, 64)
-OPENCV_HAL_IMPL_RVV_TRAITS(vint64m8_t, int64_t, e64m8, 64)
-OPENCV_HAL_IMPL_RVV_TRAITS(vuint64m1_t, uint64_t, e64m1, 64)
-OPENCV_HAL_IMPL_RVV_TRAITS(vuint64m2_t, uint64_t, e64m2, 64)
-OPENCV_HAL_IMPL_RVV_TRAITS(vuint64m4_t, uint64_t, e64m4, 64)
-OPENCV_HAL_IMPL_RVV_TRAITS(vuint64m8_t, uint64_t, e64m8, 64)
-
-OPENCV_HAL_IMPL_RVV_TRAITS(vfloat32m1_t, float, e32m1, 32)
-OPENCV_HAL_IMPL_RVV_TRAITS(vfloat32m2_t, float, e32m2, 32)
-OPENCV_HAL_IMPL_RVV_TRAITS(vfloat32m4_t, float, e32m4, 32)
-OPENCV_HAL_IMPL_RVV_TRAITS(vfloat32m8_t, float, e32m8, 32)
-
-#if CV_SIMD_SCALABLE_64F
-OPENCV_HAL_IMPL_RVV_TRAITS(vfloat64m1_t, double, e64m1, 64)
-OPENCV_HAL_IMPL_RVV_TRAITS(vfloat64m2_t, double, e64m2, 64)
-OPENCV_HAL_IMPL_RVV_TRAITS(vfloat64m4_t, double, e64m4, 64)
-OPENCV_HAL_IMPL_RVV_TRAITS(vfloat64m8_t, double, e64m8, 64)
-#endif
-
-// LLVM/Clang defines "overloaded intrinsics" e.g. 'vand(op1, op2)'
-// GCC does not have these functions, so we need to implement them manually
-// We implement only selected subset required to build current state of the code
-// Included inside namespace cv::
-// #ifndef __riscv_v_intrinsic_overloading
-// #include "intrin_rvv_compat_overloaded.hpp"
-// #endif // __riscv_v_intrinsic_overloading
-
-//////////// get0 ////////////
-#define OPENCV_HAL_IMPL_RVV_GRT0_INT(_Tpvec, _Tp)                              \
-  inline _Tp v_get0(const v_##_Tpvec &v) { return __riscv_vmv_x(v); }
-
-OPENCV_HAL_IMPL_RVV_GRT0_INT(uint8, uchar)
-OPENCV_HAL_IMPL_RVV_GRT0_INT(int8, schar)
-OPENCV_HAL_IMPL_RVV_GRT0_INT(uint16, ushort)
-OPENCV_HAL_IMPL_RVV_GRT0_INT(int16, short)
-OPENCV_HAL_IMPL_RVV_GRT0_INT(uint32, unsigned)
-OPENCV_HAL_IMPL_RVV_GRT0_INT(int32, int)
-OPENCV_HAL_IMPL_RVV_GRT0_INT(uint64, uint64)
-OPENCV_HAL_IMPL_RVV_GRT0_INT(int64, int64)
-
-inline float v_get0(const v_float32 &v) { return __riscv_vfmv_f(v); }
-#if CV_SIMD_SCALABLE_64F
-inline double v_get0(const v_float64 &v) { return __riscv_vfmv_f(v); }
-#endif
-
-//////////// Initial ////////////
-
-#define OPENCV_HAL_IMPL_RVV_INIT_INTEGER(_Tpvec, _Tp, suffix1, suffix2, vl)    \
-  inline v_##_Tpvec v_setzero_##suffix1() {                                    \
-    return __riscv_vmv_v_x_##suffix2##m2(0, vl);                               \
-  }                                                                            \
-  inline v_##_Tpvec v_setall_##suffix1(_Tp v) {                                \
-    return __riscv_vmv_v_x_##suffix2##m2(v, vl);                               \
-  }                                                                            \
-  template <> inline v_##_Tpvec v_setzero_() { return v_setzero_##suffix1(); } \
-  template <> inline v_##_Tpvec v_setall_(_Tp v) {                             \
-    return v_setall_##suffix1(v);                                              \
-  }
-
-OPENCV_HAL_IMPL_RVV_INIT_INTEGER(uint8, uchar, u8, u8,
-                                 VTraits<v_int8>::vlanes())
-OPENCV_HAL_IMPL_RVV_INIT_INTEGER(int8, schar, s8, i8, VTraits<v_int8>::vlanes())
-OPENCV_HAL_IMPL_RVV_INIT_INTEGER(uint16, ushort, u16, u16,
-                                 VTraits<v_uint16>::vlanes())
-OPENCV_HAL_IMPL_RVV_INIT_INTEGER(int16, short, s16, i16,
-                                 VTraits<v_int16>::vlanes())
-OPENCV_HAL_IMPL_RVV_INIT_INTEGER(uint32, uint, u32, u32,
-                                 VTraits<v_uint32>::vlanes())
-OPENCV_HAL_IMPL_RVV_INIT_INTEGER(int32, int, s32, i32,
-                                 VTraits<v_int32>::vlanes())
-OPENCV_HAL_IMPL_RVV_INIT_INTEGER(uint64, uint64, u64, u64,
-                                 VTraits<v_uint64>::vlanes())
-OPENCV_HAL_IMPL_RVV_INIT_INTEGER(int64, int64, s64, i64,
-                                 VTraits<v_int64>::vlanes())
-
-#define OPENCV_HAL_IMPL_RVV_INIT_FP(_Tpv, _Tp, suffix, vl)                     \
-  inline v_##_Tpv v_setzero_##suffix() {                                       \
-    return __riscv_vfmv_v_f_##suffix##m2(0, vl);                               \
-  }                                                                            \
-  inline v_##_Tpv v_setall_##suffix(_Tp v) {                                   \
-    return __riscv_vfmv_v_f_##suffix##m2(v, vl);                               \
-  }                                                                            \
-  template <> inline v_##_Tpv v_setzero_() { return v_setzero_##suffix(); }    \
-  template <> inline v_##_Tpv v_setall_(_Tp v) { return v_setall_##suffix(v); }
-
-OPENCV_HAL_IMPL_RVV_INIT_FP(float32, float, f32, VTraits<v_float32>::vlanes())
-#if CV_SIMD_SCALABLE_64F
-OPENCV_HAL_IMPL_RVV_INIT_FP(float64, double, f64, VTraits<v_float64>::vlanes())
-#endif
-
-//////////// Reinterpret ////////////
-#define OPENCV_HAL_IMPL_RVV_NOTHING_REINTERPRET(_Tpvec1, suffix1)              \
-  inline v_##_Tpvec1 v_reinterpret_as_##suffix1(const v_##_Tpvec1 &v) {        \
-    return v;                                                                  \
-  }
-OPENCV_HAL_IMPL_RVV_NOTHING_REINTERPRET(uint8, u8)
-OPENCV_HAL_IMPL_RVV_NOTHING_REINTERPRET(uint16, u16)
-OPENCV_HAL_IMPL_RVV_NOTHING_REINTERPRET(uint32, u32)
-OPENCV_HAL_IMPL_RVV_NOTHING_REINTERPRET(uint64, u64)
-OPENCV_HAL_IMPL_RVV_NOTHING_REINTERPRET(int8, s8)
-OPENCV_HAL_IMPL_RVV_NOTHING_REINTERPRET(int16, s16)
-OPENCV_HAL_IMPL_RVV_NOTHING_REINTERPRET(int32, s32)
-OPENCV_HAL_IMPL_RVV_NOTHING_REINTERPRET(int64, s64)
-OPENCV_HAL_IMPL_RVV_NOTHING_REINTERPRET(float32, f32)
-#if CV_SIMD_SCALABLE_64F
-OPENCV_HAL_IMPL_RVV_NOTHING_REINTERPRET(float64, f64)
-#endif
-// TODO: can be simplified by using overloaded RV intrinsic
-#define OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET(_Tpvec1, _Tpvec2, suffix1,      \
-                                               suffix2, nsuffix1, nsuffix2)    \
-  inline v_##_Tpvec1 v_reinterpret_as_##suffix1(const v_##_Tpvec2 &v) {        \
-    return v_##_Tpvec1(                                                        \
-        __riscv_vreinterpret_v_##nsuffix2##m2_##nsuffix1##m2(v));              \
-  }                                                                            \
-  inline v_##_Tpvec2 v_reinterpret_as_##suffix2(const v_##_Tpvec1 &v) {        \
-    return v_##_Tpvec2(                                                        \
-        __riscv_vreinterpret_v_##nsuffix1##m2_##nsuffix2##m2(v));              \
-  }
-
-OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET(uint8, int8, u8, s8, u8, i8)
-OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET(uint16, int16, u16, s16, u16, i16)
-OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET(uint32, int32, u32, s32, u32, i32)
-OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET(uint32, float32, u32, f32, u32, f32)
-OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET(int32, float32, s32, f32, i32, f32)
-OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET(uint64, int64, u64, s64, u64, i64)
-#if CV_SIMD_SCALABLE_64F
-OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET(uint64, float64, u64, f64, u64, f64)
-OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET(int64, float64, s64, f64, i64, f64)
-#endif
-OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET(uint8, uint16, u8, u16, u8, u16)
-OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET(uint8, uint32, u8, u32, u8, u32)
-OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET(uint8, uint64, u8, u64, u8, u64)
-OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET(uint16, uint32, u16, u32, u16, u32)
-OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET(uint16, uint64, u16, u64, u16, u64)
-OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET(uint32, uint64, u32, u64, u32, u64)
-OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET(int8, int16, s8, s16, i8, i16)
-OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET(int8, int32, s8, s32, i8, i32)
-OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET(int8, int64, s8, s64, i8, i64)
-OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET(int16, int32, s16, s32, i16, i32)
-OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET(int16, int64, s16, s64, i16, i64)
-OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET(int32, int64, s32, s64, i32, i64)
-
-#define OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(                               \
-    _Tpvec1, _Tpvec2, suffix1, suffix2, nsuffix1, nsuffix2, width1, width2)      \
-  inline v_##_Tpvec1 v_reinterpret_as_##suffix1(const v_##_Tpvec2 &v) {          \
-    return __riscv_vreinterpret_v_##nsuffix1##width2##m2_##nsuffix1##width1##m2( \
-        __riscv_vreinterpret_v_##nsuffix2##width2##m2_##nsuffix1##width2##m2(    \
-            v));                                                                 \
-  }                                                                              \
-  inline v_##_Tpvec2 v_reinterpret_as_##suffix2(const v_##_Tpvec1 &v) {          \
-    return __riscv_vreinterpret_v_##nsuffix1##width2##m2_##nsuffix2##width2##m2( \
-        __riscv_vreinterpret_v_##nsuffix1##width1##m2_##nsuffix1##width2##m2(    \
-            v));                                                                 \
-  }
-
-OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(uint8, int16, u8, s16, u, i, 8, 16)
-OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(uint8, int32, u8, s32, u, i, 8, 32)
-OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(uint8, int64, u8, s64, u, i, 8, 64)
-OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(uint16, int8, u16, s8, u, i, 16, 8)
-OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(uint16, int32, u16, s32, u, i, 16, 32)
-OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(uint16, int64, u16, s64, u, i, 16, 64)
-OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(uint32, int8, u32, s8, u, i, 32, 8)
-OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(uint32, int16, u32, s16, u, i, 32, 16)
-OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(uint32, int64, u32, s64, u, i, 32, 64)
-OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(uint64, int8, u64, s8, u, i, 64, 8)
-OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(uint64, int16, u64, s16, u, i, 64, 16)
-OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(uint64, int32, u64, s32, u, i, 64, 32)
-OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(uint8, float32, u8, f32, u, f, 8, 32)
-OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(uint16, float32, u16, f32, u, f, 16,
-                                          32)
-OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(uint64, float32, u64, f32, u, f, 64,
-                                          32)
-OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(int8, float32, s8, f32, i, f, 8, 32)
-OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(int16, float32, s16, f32, i, f, 16,
-                                          32)
-OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(int64, float32, s64, f32, i, f, 64,
-                                          32)
-#if CV_SIMD_SCALABLE_64F
-OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(uint8, float64, u8, f64, u, f, 8, 64)
-OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(uint16, float64, u16, f64, u, f, 16,
-                                          64)
-OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(uint32, float64, u32, f64, u, f, 32,
-                                          64)
-OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(int8, float64, s8, f64, i, f, 8, 64)
-OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(int16, float64, s16, f64, i, f, 16,
-                                          64)
-OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(int32, float64, s32, f64, i, f, 32,
-                                          64)
-// Three times reinterpret
-inline v_float32 v_reinterpret_as_f32(const v_float64 &v) {
-  return __riscv_vreinterpret_v_u32m2_f32m2(__riscv_vreinterpret_v_u64m2_u32m2(
-      __riscv_vreinterpret_v_f64m2_u64m2(v)));
-}
-
-inline v_float64 v_reinterpret_as_f64(const v_float32 &v) {
-  return __riscv_vreinterpret_v_u64m2_f64m2(__riscv_vreinterpret_v_u32m2_u64m2(
-      __riscv_vreinterpret_v_f32m2_u32m2(v)));
-}
-#endif
-
-//////////// Extract //////////////
-
-#define OPENCV_HAL_IMPL_RVV_EXTRACT_INTEGER(_Tpvec, _Tp, vl)                   \
-  template <int s = 0>                                                         \
-  inline _Tpvec v_extract(const _Tpvec &a, const _Tpvec &b, int i = s) {       \
-    return __riscv_vslideup(__riscv_vslidedown(a, i, vl), b,                   \
-                            VTraits<_Tpvec>::vlanes() - i, vl);                \
-  }                                                                            \
-  template <int s = 0> inline _Tp v_extract_n(_Tpvec v, int i = s) {           \
-    return __riscv_vmv_x(__riscv_vslidedown(v, i, vl));                        \
-  }
-
-OPENCV_HAL_IMPL_RVV_EXTRACT_INTEGER(v_uint8, uchar, VTraits<v_uint8>::vlanes())
-OPENCV_HAL_IMPL_RVV_EXTRACT_INTEGER(v_int8, schar, VTraits<v_int8>::vlanes())
-OPENCV_HAL_IMPL_RVV_EXTRACT_INTEGER(v_uint16, ushort,
-                                    VTraits<v_uint16>::vlanes())
-OPENCV_HAL_IMPL_RVV_EXTRACT_INTEGER(v_int16, short, VTraits<v_int16>::vlanes())
-OPENCV_HAL_IMPL_RVV_EXTRACT_INTEGER(v_uint32, unsigned int,
-                                    VTraits<v_uint32>::vlanes())
-OPENCV_HAL_IMPL_RVV_EXTRACT_INTEGER(v_int32, int, VTraits<v_int32>::vlanes())
-OPENCV_HAL_IMPL_RVV_EXTRACT_INTEGER(v_uint64, uint64,
-                                    VTraits<v_uint64>::vlanes())
-OPENCV_HAL_IMPL_RVV_EXTRACT_INTEGER(v_int64, int64, VTraits<v_int64>::vlanes())
-
-#define OPENCV_HAL_IMPL_RVV_EXTRACT_FP(_Tpvec, _Tp, vl)                        \
-  template <int s = 0>                                                         \
-  inline _Tpvec v_extract(const _Tpvec &a, const _Tpvec &b, int i = s) {       \
-    return __riscv_vslideup(__riscv_vslidedown(a, i, vl), b,                   \
-                            VTraits<_Tpvec>::vlanes() - i, vl);                \
-  }                                                                            \
-  template <int s = 0> inline _Tp v_extract_n(_Tpvec v, int i = s) {           \
-    return __riscv_vfmv_f(__riscv_vslidedown(v, i, vl));                       \
-  }
-
-OPENCV_HAL_IMPL_RVV_EXTRACT_FP(v_float32, float, VTraits<v_float32>::vlanes())
-#if CV_SIMD_SCALABLE_64F
-OPENCV_HAL_IMPL_RVV_EXTRACT_FP(v_float64, double, VTraits<v_float64>::vlanes())
-#endif
-
-#define OPENCV_HAL_IMPL_RVV_EXTRACT(_Tpvec, _Tp, vl)                           \
-  inline _Tp v_extract_highest(_Tpvec v) { return v_extract_n(v, vl - 1); }
-
-OPENCV_HAL_IMPL_RVV_EXTRACT(v_uint8, uchar, VTraits<v_uint8>::vlanes())
-OPENCV_HAL_IMPL_RVV_EXTRACT(v_int8, schar, VTraits<v_int8>::vlanes())
-OPENCV_HAL_IMPL_RVV_EXTRACT(v_uint16, ushort, VTraits<v_uint16>::vlanes())
-OPENCV_HAL_IMPL_RVV_EXTRACT(v_int16, short, VTraits<v_int16>::vlanes())
-OPENCV_HAL_IMPL_RVV_EXTRACT(v_uint32, unsigned int, VTraits<v_uint32>::vlanes())
-OPENCV_HAL_IMPL_RVV_EXTRACT(v_int32, int, VTraits<v_int32>::vlanes())
-OPENCV_HAL_IMPL_RVV_EXTRACT(v_uint64, uint64, VTraits<v_uint64>::vlanes())
-OPENCV_HAL_IMPL_RVV_EXTRACT(v_int64, int64, VTraits<v_int64>::vlanes())
-OPENCV_HAL_IMPL_RVV_EXTRACT(v_float32, float, VTraits<v_float32>::vlanes())
-#if CV_SIMD_SCALABLE_64F
-OPENCV_HAL_IMPL_RVV_EXTRACT(v_float64, double, VTraits<v_float64>::vlanes())
-#endif
-
-////////////// Load/Store //////////////
-#define OPENCV_HAL_IMPL_RVV_LOADSTORE_OP(_Tpvec, _nTpvec, _Tp, hvl, vl, width, \
-                                         suffix)                               \
-  inline _Tpvec v_load(const _Tp *ptr) {                                       \
-    return __riscv_vle##width##_v_##suffix##m2(ptr, vl);                       \
-  }                                                                            \
-  inline _Tpvec v_load_aligned(const _Tp *ptr) {                               \
-    return __riscv_vle##width##_v_##suffix##m2(ptr, vl);                       \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a, hal::StoreMode /*mode*/) {    \
-    __riscv_vse##width##_v_##suffix##m2(ptr, a, vl);                           \
-  }                                                                            \
-  inline _Tpvec v_load_low(const _Tp *ptr) {                                   \
-    return __riscv_vle##width##_v_##suffix##m2(ptr, hvl);                      \
-  }                                                                            \
-  inline _Tpvec v_load_halves(const _Tp *ptr0, const _Tp *ptr1) {              \
-    return __riscv_vslideup(__riscv_vle##width##_v_##suffix##m2(ptr0, hvl),    \
-                            __riscv_vle##width##_v_##suffix##m2(ptr1, hvl),    \
-                            hvl, vl);                                          \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a) {                             \
-    __riscv_vse##width(ptr, a, vl);                                            \
-  }                                                                            \
-  inline void v_store_aligned(_Tp *ptr, const _Tpvec &a) {                     \
-    __riscv_vse##width(ptr, a, vl);                                            \
-  }                                                                            \
-  inline void v_store_aligned_nocache(_Tp *ptr, const _Tpvec &a) {             \
-    __riscv_vse##width(ptr, a, vl);                                            \
-  }                                                                            \
-  inline void v_store_low(_Tp *ptr, const _Tpvec &a) {                         \
-    __riscv_vse##width(ptr, a, hvl);                                           \
-  }                                                                            \
-  inline void v_store_high(_Tp *ptr, const _Tpvec &a) {                        \
-    __riscv_vse##width(ptr, __riscv_vslidedown_vx_##suffix##m2(a, hvl, vl),    \
-                       hvl);                                                   \
-  }                                                                            \
-  template <typename... Targs> _Tpvec v_load_##suffix(Targs... nScalars) {     \
-    return v_load({nScalars...});                                              \
-  }
-
-OPENCV_HAL_IMPL_RVV_LOADSTORE_OP(v_uint8, vuint8m2_t, uchar,
-                                 VTraits<v_uint8>::vlanes() / 2,
-                                 VTraits<v_uint8>::vlanes(), 8, u8)
-OPENCV_HAL_IMPL_RVV_LOADSTORE_OP(v_int8, vint8m2_t, schar,
-                                 VTraits<v_int8>::vlanes() / 2,
-                                 VTraits<v_int8>::vlanes(), 8, i8)
-OPENCV_HAL_IMPL_RVV_LOADSTORE_OP(v_uint16, vuint16m2_t, ushort,
-                                 VTraits<v_uint16>::vlanes() / 2,
-                                 VTraits<v_uint16>::vlanes(), 16, u16)
-OPENCV_HAL_IMPL_RVV_LOADSTORE_OP(v_int16, vint16m2_t, short,
-                                 VTraits<v_int16>::vlanes() / 2,
-                                 VTraits<v_int16>::vlanes(), 16, i16)
-OPENCV_HAL_IMPL_RVV_LOADSTORE_OP(v_uint32, vuint32m2_t, unsigned int,
-                                 VTraits<v_uint32>::vlanes() / 2,
-                                 VTraits<v_uint32>::vlanes(), 32, u32)
-OPENCV_HAL_IMPL_RVV_LOADSTORE_OP(v_int32, vint32m2_t, int,
-                                 VTraits<v_int32>::vlanes() / 2,
-                                 VTraits<v_int32>::vlanes(), 32, i32)
-OPENCV_HAL_IMPL_RVV_LOADSTORE_OP(v_uint64, vuint64m2_t, uint64,
-                                 VTraits<v_uint64>::vlanes() / 2,
-                                 VTraits<v_uint64>::vlanes(), 64, u64)
-OPENCV_HAL_IMPL_RVV_LOADSTORE_OP(v_int64, vint64m2_t, int64,
-                                 VTraits<v_int64>::vlanes() / 2,
-                                 VTraits<v_int64>::vlanes(), 64, i64)
-OPENCV_HAL_IMPL_RVV_LOADSTORE_OP(v_float32, vfloat32m2_t, float,
-                                 VTraits<v_float32>::vlanes() / 2,
-                                 VTraits<v_float32>::vlanes(), 32, f32)
-
-#if CV_SIMD_SCALABLE_64F
-OPENCV_HAL_IMPL_RVV_LOADSTORE_OP(v_float64, vfloat64m2_t, double,
-                                 VTraits<v_float64>::vlanes() / 2,
-                                 VTraits<v_float64>::vlanes(), 64, f64)
-#endif
-
-////////////// Lookup table access ////////////////////
-#define OPENCV_HAL_IMPL_RVV_LUT(_Tpvec, _Tp, suffix)                           \
-  inline _Tpvec v_lut(const _Tp *tab, const int *idx) {                        \
-    auto vidx = __riscv_vmul(                                                  \
-        __riscv_vreinterpret_u32##suffix(                                      \
-            __riscv_vle32_v_i32##suffix(idx, VTraits<_Tpvec>::vlanes())),      \
-        sizeof(_Tp), VTraits<_Tpvec>::vlanes());                               \
-    return __riscv_vloxei32(tab, vidx, VTraits<_Tpvec>::vlanes());             \
-  }
-OPENCV_HAL_IMPL_RVV_LUT(v_int8, schar, m8)
-OPENCV_HAL_IMPL_RVV_LUT(v_int16, short, m4)
-OPENCV_HAL_IMPL_RVV_LUT(v_int32, int, m2)
-OPENCV_HAL_IMPL_RVV_LUT(v_int64, int64_t, m1)
-OPENCV_HAL_IMPL_RVV_LUT(v_float32, float, m2)
-#if CV_SIMD_SCALABLE_64F
-OPENCV_HAL_IMPL_RVV_LUT(v_float64, double, m1)
-#endif
-
-#define OPENCV_HAL_IMPL_RVV_LUT_PAIRS(_Tpvec, _Tp, suffix1, suffix2, v_trunc)  \
-  inline _Tpvec v_lut_pairs(const _Tp *tab, const int *idx) {                  \
-    auto v0 = __riscv_vle32_v_u32##suffix1((unsigned *)idx,                    \
-                                           VTraits<_Tpvec>::vlanes() / 2);     \
-    auto v1 = __riscv_vadd(v0, 1, VTraits<_Tpvec>::vlanes() / 2);              \
-    auto w0 = __riscv_vwcvtu_x(v0, VTraits<_Tpvec>::vlanes() / 2);             \
-    auto w1 = __riscv_vwcvtu_x(v1, VTraits<_Tpvec>::vlanes() / 2);             \
-    auto sh1 =                                                                 \
-        __riscv_vslide1up(v_trunc(__riscv_vreinterpret_u32##suffix2(w1)), 0,   \
-                          VTraits<_Tpvec>::vlanes());                          \
-    auto vid =                                                                 \
-        __riscv_vor(sh1, v_trunc(__riscv_vreinterpret_u32##suffix2(w0)),       \
-                    VTraits<_Tpvec>::vlanes());                                \
-    auto vidx = __riscv_vmul(vid, sizeof(_Tp), VTraits<_Tpvec>::vlanes());     \
-    return __riscv_vloxei32(tab, vidx, VTraits<_Tpvec>::vlanes());             \
-  }
-OPENCV_HAL_IMPL_RVV_LUT_PAIRS(v_int8, schar, m4, m8, OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_RVV_LUT_PAIRS(v_int16, short, m2, m4, OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_RVV_LUT_PAIRS(v_int32, int, m1, m2, OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_RVV_LUT_PAIRS(v_float32, float, m1, m2, OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_RVV_LUT_PAIRS(v_int64, int64_t, m1, m2,
-                              __riscv_vlmul_trunc_u32m1)
-#if CV_SIMD_SCALABLE_64F
-OPENCV_HAL_IMPL_RVV_LUT_PAIRS(v_float64, double, m1, m2,
-                              __riscv_vlmul_trunc_u32m1)
-#endif
-
-#define OPENCV_HAL_IMPL_RVV_LUT_QUADS(_Tpvec, _Tp, suffix0, suffix1, suffix2,  \
-                                      v_trunc)                                 \
-  inline _Tpvec v_lut_quads(const _Tp *tab, const int *idx) {                  \
-    auto v0 = __riscv_vle32_v_u32##suffix0((unsigned *)idx,                    \
-                                           VTraits<_Tpvec>::vlanes() / 4);     \
-    auto v1 = __riscv_vadd(v0, 1, VTraits<_Tpvec>::vlanes() / 4);              \
-    auto v2 = __riscv_vadd(v0, 2, VTraits<_Tpvec>::vlanes() / 4);              \
-    auto v3 = __riscv_vadd(v0, 3, VTraits<_Tpvec>::vlanes() / 4);              \
-    auto w0 = __riscv_vwcvtu_x(v0, VTraits<_Tpvec>::vlanes() / 4);             \
-    auto w1 = __riscv_vwcvtu_x(v1, VTraits<_Tpvec>::vlanes() / 4);             \
-    auto w2 = __riscv_vwcvtu_x(v2, VTraits<_Tpvec>::vlanes() / 4);             \
-    auto w3 = __riscv_vwcvtu_x(v3, VTraits<_Tpvec>::vlanes() / 4);             \
-    auto sh2 = __riscv_vslide1up(__riscv_vreinterpret_u32##suffix1(w2), 0,     \
-                                 VTraits<_Tpvec>::vlanes() / 2);               \
-    auto sh3 = __riscv_vslide1up(__riscv_vreinterpret_u32##suffix1(w3), 0,     \
-                                 VTraits<_Tpvec>::vlanes() / 2);               \
-    auto vid0 = __riscv_vor(sh2, __riscv_vreinterpret_u32##suffix1(w0),        \
-                            VTraits<_Tpvec>::vlanes() / 2);                    \
-    auto vid1 = __riscv_vor(sh3, __riscv_vreinterpret_u32##suffix1(w1),        \
-                            VTraits<_Tpvec>::vlanes() / 2);                    \
-    auto wid0 =                                                                \
-        __riscv_vwcvtu_x(v_trunc(vid0), VTraits<_Tpvec>::vlanes() / 2);        \
-    auto wid1 =                                                                \
-        __riscv_vwcvtu_x(v_trunc(vid1), VTraits<_Tpvec>::vlanes() / 2);        \
-    auto shwid1 = __riscv_vslide1up(__riscv_vreinterpret_u32##suffix2(wid1),   \
-                                    0, VTraits<_Tpvec>::vlanes());             \
-    auto vid = __riscv_vor(shwid1, __riscv_vreinterpret_u32##suffix2(wid0),    \
-                           VTraits<_Tpvec>::vlanes());                         \
-    auto vidx = __riscv_vmul(vid, sizeof(_Tp), VTraits<_Tpvec>::vlanes());     \
-    return __riscv_vloxei32(tab, vidx, VTraits<_Tpvec>::vlanes());             \
-  }
-OPENCV_HAL_IMPL_RVV_LUT_QUADS(v_int8, schar, m2, m4, m8, OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_RVV_LUT_QUADS(v_int16, short, m1, m2, m4, OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_RVV_LUT_QUADS(v_int32, int, m1, m2, m2,
-                              __riscv_vlmul_trunc_u32m1)
-OPENCV_HAL_IMPL_RVV_LUT_QUADS(v_float32, float, m1, m2, m2,
-                              __riscv_vlmul_trunc_u32m1)
-
-#define OPENCV_HAL_IMPL_RVV_LUT_VEC(_Tpvec, _Tp)                               \
-  inline _Tpvec v_lut(const _Tp *tab, const v_int32 &vidx) {                   \
-    v_uint32 vidx_ = __riscv_vmul(__riscv_vreinterpret_u32m2(vidx),            \
-                                  sizeof(_Tp), VTraits<v_int32>::vlanes());    \
-    return __riscv_vloxei32(tab, vidx_, VTraits<_Tpvec>::vlanes());            \
-  }
-OPENCV_HAL_IMPL_RVV_LUT_VEC(v_float32, float)
-OPENCV_HAL_IMPL_RVV_LUT_VEC(v_int32, int)
-OPENCV_HAL_IMPL_RVV_LUT_VEC(v_uint32, unsigned)
-
-#if CV_SIMD_SCALABLE_64F
-inline v_float64 v_lut(const double *tab, const v_int32 &vidx) {
-  vuint32m1_t vidx_ =
-      __riscv_vmul(__riscv_vlmul_trunc_u32m1(__riscv_vreinterpret_u32m2(vidx)),
-                   sizeof(double), VTraits<v_float64>::vlanes());
-  return __riscv_vloxei32(tab, vidx_, VTraits<v_float64>::vlanes());
-}
-#endif
-
-inline v_uint8 v_lut(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v_lut((schar *)tab, idx));
-}
-inline v_uint8 v_lut_pairs(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v_lut_pairs((schar *)tab, idx));
-}
-inline v_uint8 v_lut_quads(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v_lut_quads((schar *)tab, idx));
-}
-inline v_uint16 v_lut(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v_lut((short *)tab, idx));
-}
-inline v_uint16 v_lut_pairs(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v_lut_pairs((short *)tab, idx));
-}
-inline v_uint16 v_lut_quads(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v_lut_quads((short *)tab, idx));
-}
-inline v_uint32 v_lut(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v_lut((int *)tab, idx));
-}
-inline v_uint32 v_lut_pairs(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v_lut_pairs((int *)tab, idx));
-}
-inline v_uint32 v_lut_quads(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v_lut_quads((int *)tab, idx));
-}
-inline v_uint64 v_lut(const uint64 *tab, const int *idx) {
-  return v_reinterpret_as_u64(v_lut((const int64_t *)tab, idx));
-}
-inline v_uint64 v_lut_pairs(const uint64 *tab, const int *idx) {
-  return v_reinterpret_as_u64(v_lut_pairs((const int64_t *)tab, idx));
-}
-
-////////////// Pack boolean ////////////////////
-inline v_uint8 v_pack_b(const v_uint16 &a, const v_uint16 &b) {
-  return __riscv_vnsrl(__riscv_vset(__riscv_vlmul_ext_v_u16m2_u16m4(a), 1, b),
-                       0, VTraits<v_uint8>::vlanes());
-}
-
-inline v_uint8 v_pack_b(const v_uint32 &a, const v_uint32 &b, const v_uint32 &c,
-                        const v_uint32 &d) {
-
-  return __riscv_vnsrl(
-      __riscv_vnsrl(
-          __riscv_vset(
-              __riscv_vset(__riscv_vset(__riscv_vlmul_ext_u32m8(a), 1, b), 2,
-                           c),
-              3, d),
-          0, VTraits<v_uint8>::vlanes()),
-      0, VTraits<v_uint8>::vlanes());
-}
-
-inline v_uint8 v_pack_b(const v_uint64 &a, const v_uint64 &b, const v_uint64 &c,
-                        const v_uint64 &d, const v_uint64 &e, const v_uint64 &f,
-                        const v_uint64 &g, const v_uint64 &h) {
-  vuint8m1_t t0 = __riscv_vnsrl(
-      __riscv_vnsrl(
-          __riscv_vnsrl(
-              __riscv_vset(
-                  __riscv_vset(__riscv_vset(__riscv_vlmul_ext_u64m8(a), 1, b),
-                               2, c),
-                  3, d),
-              0, VTraits<v_uint8>::vlanes()),
-          0, VTraits<v_uint8>::vlanes()),
-      0, VTraits<v_uint8>::vlanes());
-  vuint8m1_t t1 = __riscv_vnsrl(
-      __riscv_vnsrl(
-          __riscv_vnsrl(
-              __riscv_vset(
-                  __riscv_vset(__riscv_vset(__riscv_vlmul_ext_u64m8(e), 1, f),
-                               2, g),
-                  3, h),
-              0, VTraits<v_uint8>::vlanes()),
-          0, VTraits<v_uint8>::vlanes()),
-      0, VTraits<v_uint8>::vlanes());
-
-  return __riscv_vset(__riscv_vlmul_ext_u8m2(t0), 1, t1);
-}
-
-////////////// Arithmetics //////////////
-#define OPENCV_HAL_IMPL_RVV_BIN_OP(_Tpvec, ocv_intrin, rvv_intrin)             \
-  inline _Tpvec v_##ocv_intrin(const _Tpvec &a, const _Tpvec &b) {             \
-    return rvv_intrin(a, b, VTraits<_Tpvec>::vlanes());                        \
-  }
-
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_uint8, add, __riscv_vsaddu)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_uint8, sub, __riscv_vssubu)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_int8, add, __riscv_vsadd)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_int8, sub, __riscv_vssub)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_uint16, add, __riscv_vsaddu)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_uint16, sub, __riscv_vssubu)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_int16, add, __riscv_vsadd)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_int16, sub, __riscv_vssub)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_uint32, add, __riscv_vadd)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_uint32, sub, __riscv_vsub)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_uint32, mul, __riscv_vmul)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_int32, add, __riscv_vadd)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_int32, sub, __riscv_vsub)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_int32, mul, __riscv_vmul)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_float32, add, __riscv_vfadd)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_float32, sub, __riscv_vfsub)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_float32, mul, __riscv_vfmul)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_float32, div, __riscv_vfdiv)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_uint64, add, __riscv_vadd)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_uint64, sub, __riscv_vsub)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_int64, add, __riscv_vadd)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_int64, sub, __riscv_vsub)
-
-#if CV_SIMD_SCALABLE_64F
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_float64, add, __riscv_vfadd)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_float64, sub, __riscv_vfsub)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_float64, mul, __riscv_vfmul)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_float64, div, __riscv_vfdiv)
-#endif
-
-#define OPENCV_HAL_IMPL_RVV_BIN_MADD(_Tpvec, rvv_add)                          \
-  template <typename... Args>                                                  \
-  inline _Tpvec v_add(const _Tpvec &f1, const _Tpvec &f2, const Args &...vf) { \
-    return v_add(rvv_add(f1, f2, VTraits<_Tpvec>::vlanes()), vf...);           \
-  }
-#define OPENCV_HAL_IMPL_RVV_BIN_MMUL(_Tpvec, rvv_mul)                          \
-  template <typename... Args>                                                  \
-  inline _Tpvec v_mul(const _Tpvec &f1, const _Tpvec &f2, const Args &...vf) { \
-    return v_mul(rvv_mul(f1, f2, VTraits<_Tpvec>::vlanes()), vf...);           \
-  }
-OPENCV_HAL_IMPL_RVV_BIN_MADD(v_uint8, __riscv_vsaddu)
-OPENCV_HAL_IMPL_RVV_BIN_MADD(v_int8, __riscv_vsadd)
-OPENCV_HAL_IMPL_RVV_BIN_MADD(v_uint16, __riscv_vsaddu)
-OPENCV_HAL_IMPL_RVV_BIN_MADD(v_int16, __riscv_vsadd)
-OPENCV_HAL_IMPL_RVV_BIN_MADD(v_uint32, __riscv_vadd)
-OPENCV_HAL_IMPL_RVV_BIN_MADD(v_int32, __riscv_vadd)
-OPENCV_HAL_IMPL_RVV_BIN_MADD(v_float32, __riscv_vfadd)
-OPENCV_HAL_IMPL_RVV_BIN_MADD(v_uint64, __riscv_vadd)
-OPENCV_HAL_IMPL_RVV_BIN_MADD(v_int64, __riscv_vadd)
-
-OPENCV_HAL_IMPL_RVV_BIN_MMUL(v_uint32, __riscv_vmul)
-OPENCV_HAL_IMPL_RVV_BIN_MMUL(v_int32, __riscv_vmul)
-OPENCV_HAL_IMPL_RVV_BIN_MMUL(v_float32, __riscv_vfmul)
-#if CV_SIMD_SCALABLE_64F
-OPENCV_HAL_IMPL_RVV_BIN_MADD(v_float64, __riscv_vfadd)
-OPENCV_HAL_IMPL_RVV_BIN_MMUL(v_float64, __riscv_vfmul)
-#endif
-
-#define OPENCV_HAL_IMPL_RVV_MUL_EXPAND(_Tpvec, _Tpwvec, _TpwvecM2, suffix,     \
-                                       wmul)                                   \
-  inline void v_mul_expand(const _Tpvec &a, const _Tpvec &b, _Tpwvec &c,       \
-                           _Tpwvec &d) {                                       \
-    _TpwvecM2 temp = wmul(a, b, VTraits<_Tpvec>::vlanes());                    \
-    c = __riscv_vget_##suffix##m2(temp, 0);                                    \
-    d = __riscv_vget_##suffix##m2(temp, 1);                                    \
-  }
-
-OPENCV_HAL_IMPL_RVV_MUL_EXPAND(v_uint8, v_uint16, vuint16m4_t, u16,
-                               __riscv_vwmulu)
-OPENCV_HAL_IMPL_RVV_MUL_EXPAND(v_int8, v_int16, vint16m4_t, i16, __riscv_vwmul)
-OPENCV_HAL_IMPL_RVV_MUL_EXPAND(v_uint16, v_uint32, vuint32m4_t, u32,
-                               __riscv_vwmulu)
-OPENCV_HAL_IMPL_RVV_MUL_EXPAND(v_int16, v_int32, vint32m4_t, i32, __riscv_vwmul)
-OPENCV_HAL_IMPL_RVV_MUL_EXPAND(v_uint32, v_uint64, vuint64m4_t, u64,
-                               __riscv_vwmulu)
-
-inline v_int16 v_mul_hi(const v_int16 &a, const v_int16 &b) {
-  return __riscv_vmulh(a, b, VTraits<v_int16>::vlanes());
-}
-inline v_uint16 v_mul_hi(const v_uint16 &a, const v_uint16 &b) {
-  return __riscv_vmulhu(a, b, VTraits<v_uint16>::vlanes());
-}
-
-////////////// Arithmetics (wrap)//////////////
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_uint8, add_wrap, __riscv_vadd)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_int8, add_wrap, __riscv_vadd)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_uint16, add_wrap, __riscv_vadd)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_int16, add_wrap, __riscv_vadd)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_uint8, sub_wrap, __riscv_vsub)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_int8, sub_wrap, __riscv_vsub)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_uint16, sub_wrap, __riscv_vsub)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_int16, sub_wrap, __riscv_vsub)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_uint8, mul_wrap, __riscv_vmul)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_int8, mul_wrap, __riscv_vmul)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_uint16, mul_wrap, __riscv_vmul)
-OPENCV_HAL_IMPL_RVV_BIN_OP(v_int16, mul_wrap, __riscv_vmul)
-
-//////// Saturating Multiply ////////
-#define OPENCV_HAL_IMPL_RVV_MUL_SAT(_Tpvec, _clip, _wmul)                      \
-  inline _Tpvec v_mul(const _Tpvec &a, const _Tpvec &b) {                      \
-    return _clip(_wmul(a, b, VTraits<_Tpvec>::vlanes()), 0, 0,                 \
-                 VTraits<_Tpvec>::vlanes());                                   \
-  }                                                                            \
-  template <typename... Args>                                                  \
-  inline _Tpvec v_mul(const _Tpvec &a1, const _Tpvec &a2, const Args &...va) { \
-    return v_mul(_clip(_wmul(a1, a2, VTraits<_Tpvec>::vlanes()), 0, 0,         \
-                       VTraits<_Tpvec>::vlanes()),                             \
-                 va...);                                                       \
-  }
-
-OPENCV_HAL_IMPL_RVV_MUL_SAT(v_uint8, __riscv_vnclipu, __riscv_vwmulu)
-OPENCV_HAL_IMPL_RVV_MUL_SAT(v_int8, __riscv_vnclip, __riscv_vwmul)
-OPENCV_HAL_IMPL_RVV_MUL_SAT(v_uint16, __riscv_vnclipu, __riscv_vwmulu)
-OPENCV_HAL_IMPL_RVV_MUL_SAT(v_int16, __riscv_vnclip, __riscv_vwmul)
-
-////////////// Bitwise logic //////////////
-
-#define OPENCV_HAL_IMPL_RVV_LOGIC_OP(_Tpvec, vl)                               \
-  inline _Tpvec v_and(const _Tpvec &a, const _Tpvec &b) {                      \
-    return __riscv_vand(a, b, vl);                                             \
-  }                                                                            \
-  inline _Tpvec v_or(const _Tpvec &a, const _Tpvec &b) {                       \
-    return __riscv_vor(a, b, vl);                                              \
-  }                                                                            \
-  inline _Tpvec v_xor(const _Tpvec &a, const _Tpvec &b) {                      \
-    return __riscv_vxor(a, b, vl);                                             \
-  }                                                                            \
-  inline _Tpvec v_not(const _Tpvec &a) { return __riscv_vnot(a, vl); }
-
-OPENCV_HAL_IMPL_RVV_LOGIC_OP(v_uint8, VTraits<v_uint8>::vlanes())
-OPENCV_HAL_IMPL_RVV_LOGIC_OP(v_int8, VTraits<v_int8>::vlanes())
-OPENCV_HAL_IMPL_RVV_LOGIC_OP(v_uint16, VTraits<v_uint16>::vlanes())
-OPENCV_HAL_IMPL_RVV_LOGIC_OP(v_int16, VTraits<v_int16>::vlanes())
-OPENCV_HAL_IMPL_RVV_LOGIC_OP(v_uint32, VTraits<v_uint32>::vlanes())
-OPENCV_HAL_IMPL_RVV_LOGIC_OP(v_int32, VTraits<v_int32>::vlanes())
-OPENCV_HAL_IMPL_RVV_LOGIC_OP(v_uint64, VTraits<v_uint64>::vlanes())
-OPENCV_HAL_IMPL_RVV_LOGIC_OP(v_int64, VTraits<v_int64>::vlanes())
-
-#define OPENCV_HAL_IMPL_RVV_FLT_BIT_OP(intrin)                                 \
-  inline v_float32 intrin(const v_float32 &a, const v_float32 &b) {            \
-    return __riscv_vreinterpret_f32m2(                                         \
-        intrin(__riscv_vreinterpret_i32m2(a), __riscv_vreinterpret_i32m2(b))); \
-  }
-OPENCV_HAL_IMPL_RVV_FLT_BIT_OP(v_and)
-OPENCV_HAL_IMPL_RVV_FLT_BIT_OP(v_or)
-OPENCV_HAL_IMPL_RVV_FLT_BIT_OP(v_xor)
-
-inline v_float32 v_not(const v_float32 &a) {
-  return __riscv_vreinterpret_f32m2(v_not(__riscv_vreinterpret_i32m2(a)));
-}
-
-#if CV_SIMD_SCALABLE_64F
-#define OPENCV_HAL_IMPL_RVV_FLT64_BIT_OP(intrin)                               \
-  inline v_float64 intrin(const v_float64 &a, const v_float64 &b) {            \
-    return __riscv_vreinterpret_f64m2(                                         \
-        intrin(__riscv_vreinterpret_i64m2(a), __riscv_vreinterpret_i64m2(b))); \
-  }
-OPENCV_HAL_IMPL_RVV_FLT64_BIT_OP(v_and)
-OPENCV_HAL_IMPL_RVV_FLT64_BIT_OP(v_or)
-OPENCV_HAL_IMPL_RVV_FLT64_BIT_OP(v_xor)
-
-inline v_float64 v_not(const v_float64 &a) {
-  return __riscv_vreinterpret_f64m2(v_not(__riscv_vreinterpret_i64m2(a)));
-}
-#endif
-
-////////////// Bitwise shifts //////////////
-/*  Usage
-1. v_shl<N>(vec);
-2. v_shl(vec, N); // instead of vec << N, when N is non-constant.
-*/
-
-#define OPENCV_HAL_IMPL_RVV_UNSIGNED_SHIFT_OP(_Tpvec, vl)                      \
-  template <int s = 0> inline _Tpvec v_shl(const _Tpvec &a, int n = s) {       \
-    return _Tpvec(__riscv_vsll(a, uint8_t(n), vl));                            \
-  }                                                                            \
-  template <int s = 0> inline _Tpvec v_shr(const _Tpvec &a, int n = s) {       \
-    return _Tpvec(__riscv_vsrl(a, uint8_t(n), vl));                            \
-  }
-
-#define OPENCV_HAL_IMPL_RVV_SIGNED_SHIFT_OP(_Tpvec, vl)                        \
-  template <int s = 0> inline _Tpvec v_shl(const _Tpvec &a, int n = s) {       \
-    return _Tpvec(__riscv_vsll(a, uint8_t(n), vl));                            \
-  }                                                                            \
-  template <int s = 0> inline _Tpvec v_shr(const _Tpvec &a, int n = s) {       \
-    return _Tpvec(__riscv_vsra(a, uint8_t(n), vl));                            \
-  }
-
-OPENCV_HAL_IMPL_RVV_UNSIGNED_SHIFT_OP(v_uint16, VTraits<v_uint16>::vlanes())
-OPENCV_HAL_IMPL_RVV_UNSIGNED_SHIFT_OP(v_uint32, VTraits<v_uint32>::vlanes())
-OPENCV_HAL_IMPL_RVV_UNSIGNED_SHIFT_OP(v_uint64, VTraits<v_uint64>::vlanes())
-OPENCV_HAL_IMPL_RVV_SIGNED_SHIFT_OP(v_int16, VTraits<v_int16>::vlanes())
-OPENCV_HAL_IMPL_RVV_SIGNED_SHIFT_OP(v_int32, VTraits<v_int32>::vlanes())
-OPENCV_HAL_IMPL_RVV_SIGNED_SHIFT_OP(v_int64, VTraits<v_int64>::vlanes())
-
-////////////// Comparison //////////////
-#define OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, op, intrin, suffix)             \
-  inline _Tpvec v_##op(const _Tpvec &a, const _Tpvec &b) {                     \
-    size_t VLEN = VTraits<_Tpvec>::vlanes();                                   \
-    uint64_t ones = -1;                                                        \
-    return __riscv_vmerge(__riscv_vmv_v_x_##suffix##m2(0, VLEN), ones,         \
-                          intrin(a, b, VLEN), VLEN);                           \
-  }
-
-#define OPENCV_HAL_IMPL_RVV_FLOAT_CMP_OP(_Tpvec, op, intrin, suffix)           \
-  inline _Tpvec v_##op(const _Tpvec &a, const _Tpvec &b) {                     \
-    size_t VLEN = VTraits<_Tpvec>::vlanes();                                   \
-    union {                                                                    \
-      uint64_t u;                                                              \
-      VTraits<_Tpvec>::lane_type d;                                            \
-    } ones;                                                                    \
-    ones.u = -1;                                                               \
-    auto diff = intrin(a, b, VLEN);                                            \
-    auto z = __riscv_vfmv_v_f_##suffix##m2(0, VLEN);                           \
-    auto res = __riscv_vfmerge(z, ones.d, diff, VLEN);                         \
-    return _Tpvec(res);                                                        \
-  } // TODO
-
-#define OPENCV_HAL_IMPL_RVV_UNSIGNED_CMP(_Tpvec, suffix)                       \
-  OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, eq, __riscv_vmseq, suffix)            \
-  OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, ne, __riscv_vmsne, suffix)            \
-  OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, lt, __riscv_vmsltu, suffix)           \
-  OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, gt, __riscv_vmsgtu, suffix)           \
-  OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, le, __riscv_vmsleu, suffix)           \
-  OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, ge, __riscv_vmsgeu, suffix)
-
-#define OPENCV_HAL_IMPL_RVV_SIGNED_CMP(_Tpvec, suffix)                         \
-  OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, eq, __riscv_vmseq, suffix)            \
-  OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, ne, __riscv_vmsne, suffix)            \
-  OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, lt, __riscv_vmslt, suffix)            \
-  OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, gt, __riscv_vmsgt, suffix)            \
-  OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, le, __riscv_vmsle, suffix)            \
-  OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, ge, __riscv_vmsge, suffix)
-
-#define OPENCV_HAL_IMPL_RVV_FLOAT_CMP(_Tpvec, suffix)                          \
-  OPENCV_HAL_IMPL_RVV_FLOAT_CMP_OP(_Tpvec, eq, __riscv_vmfeq, suffix)          \
-  OPENCV_HAL_IMPL_RVV_FLOAT_CMP_OP(_Tpvec, ne, __riscv_vmfne, suffix)          \
-  OPENCV_HAL_IMPL_RVV_FLOAT_CMP_OP(_Tpvec, lt, __riscv_vmflt, suffix)          \
-  OPENCV_HAL_IMPL_RVV_FLOAT_CMP_OP(_Tpvec, gt, __riscv_vmfgt, suffix)          \
-  OPENCV_HAL_IMPL_RVV_FLOAT_CMP_OP(_Tpvec, le, __riscv_vmfle, suffix)          \
-  OPENCV_HAL_IMPL_RVV_FLOAT_CMP_OP(_Tpvec, ge, __riscv_vmfge, suffix)
-
-OPENCV_HAL_IMPL_RVV_UNSIGNED_CMP(v_uint8, u8)
-OPENCV_HAL_IMPL_RVV_UNSIGNED_CMP(v_uint16, u16)
-OPENCV_HAL_IMPL_RVV_UNSIGNED_CMP(v_uint32, u32)
-OPENCV_HAL_IMPL_RVV_UNSIGNED_CMP(v_uint64, u64)
-OPENCV_HAL_IMPL_RVV_SIGNED_CMP(v_int8, i8)
-OPENCV_HAL_IMPL_RVV_SIGNED_CMP(v_int16, i16)
-OPENCV_HAL_IMPL_RVV_SIGNED_CMP(v_int32, i32)
-OPENCV_HAL_IMPL_RVV_SIGNED_CMP(v_int64, i64)
-OPENCV_HAL_IMPL_RVV_FLOAT_CMP(v_float32, f32)
-#if CV_SIMD_SCALABLE_64F
-OPENCV_HAL_IMPL_RVV_FLOAT_CMP(v_float64, f64)
-#endif
-
-inline v_float32 v_not_nan(const v_float32 &a) { return v_eq(a, a); }
-
-#if CV_SIMD_SCALABLE_64F
-inline v_float64 v_not_nan(const v_float64 &a) { return v_eq(a, a); }
-#endif
-
-////////////// Min/Max //////////////
-
-#define OPENCV_HAL_IMPL_RVV_BIN_FUNC(_Tpvec, func, intrin, vl)                 \
-  inline _Tpvec func(const _Tpvec &a, const _Tpvec &b) {                       \
-    return intrin(a, b, vl);                                                   \
-  }
-
-OPENCV_HAL_IMPL_RVV_BIN_FUNC(v_uint8, v_min, __riscv_vminu,
-                             VTraits<v_uint8>::vlanes())
-OPENCV_HAL_IMPL_RVV_BIN_FUNC(v_uint8, v_max, __riscv_vmaxu,
-                             VTraits<v_uint8>::vlanes())
-OPENCV_HAL_IMPL_RVV_BIN_FUNC(v_int8, v_min, __riscv_vmin,
-                             VTraits<v_int8>::vlanes())
-OPENCV_HAL_IMPL_RVV_BIN_FUNC(v_int8, v_max, __riscv_vmax,
-                             VTraits<v_int8>::vlanes())
-OPENCV_HAL_IMPL_RVV_BIN_FUNC(v_uint16, v_min, __riscv_vminu,
-                             VTraits<v_uint16>::vlanes())
-OPENCV_HAL_IMPL_RVV_BIN_FUNC(v_uint16, v_max, __riscv_vmaxu,
-                             VTraits<v_uint16>::vlanes())
-OPENCV_HAL_IMPL_RVV_BIN_FUNC(v_int16, v_min, __riscv_vmin,
-                             VTraits<v_int16>::vlanes())
-OPENCV_HAL_IMPL_RVV_BIN_FUNC(v_int16, v_max, __riscv_vmax,
-                             VTraits<v_int16>::vlanes())
-OPENCV_HAL_IMPL_RVV_BIN_FUNC(v_uint32, v_min, __riscv_vminu,
-                             VTraits<v_uint32>::vlanes())
-OPENCV_HAL_IMPL_RVV_BIN_FUNC(v_uint32, v_max, __riscv_vmaxu,
-                             VTraits<v_uint32>::vlanes())
-OPENCV_HAL_IMPL_RVV_BIN_FUNC(v_int32, v_min, __riscv_vmin,
-                             VTraits<v_int32>::vlanes())
-OPENCV_HAL_IMPL_RVV_BIN_FUNC(v_int32, v_max, __riscv_vmax,
-                             VTraits<v_int32>::vlanes())
-OPENCV_HAL_IMPL_RVV_BIN_FUNC(v_float32, v_min, __riscv_vfmin,
-                             VTraits<v_float32>::vlanes())
-OPENCV_HAL_IMPL_RVV_BIN_FUNC(v_float32, v_max, __riscv_vfmax,
-                             VTraits<v_float32>::vlanes())
-#if CV_SIMD_SCALABLE_64F
-OPENCV_HAL_IMPL_RVV_BIN_FUNC(v_float64, v_min, __riscv_vfmin,
-                             VTraits<v_float64>::vlanes())
-OPENCV_HAL_IMPL_RVV_BIN_FUNC(v_float64, v_max, __riscv_vfmax,
-                             VTraits<v_float64>::vlanes())
-#endif
-
-////////////// Transpose4x4 //////////////
-#define OPENCV_HAL_IMPL_RVV_ZIP4(_Tpvec, _wTpvec, suffix, convert2u, convert)  \
-  inline void v_zip4(const _Tpvec &a0, const _Tpvec &a1, _Tpvec &b0,           \
-                     _Tpvec &b1) {                                             \
-    int vl = 4;                                                                \
-    _wTpvec temp = __riscv_vreinterpret_##suffix##m4(convert2u(__riscv_vor(    \
-        __riscv_vzext_vf2(convert(a0), vl),                                    \
-        __riscv_vreinterpret_u64m4(__riscv_vslide1up(                          \
-            __riscv_vreinterpret_u32m4(__riscv_vzext_vf2(convert(a1), vl)), 0, \
-            vl * 2)),                                                          \
-        vl)));                                                                 \
-    b0 = __riscv_vget_##suffix##m2(temp, 0);                                   \
-    b1 = __riscv_vget_##suffix##m2(                                            \
-        __riscv_vrgather(                                                      \
-            temp, __riscv_vadd(__riscv_vid_v_u32m4(vl), 4, vl) /*{4,5,6,7} */, \
-            vl),                                                               \
-        0);                                                                    \
-  }
-
-OPENCV_HAL_IMPL_RVV_ZIP4(v_uint32, vuint32m4_t, u32, OPENCV_HAL_NOP,
-                         OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_RVV_ZIP4(v_int32, vint32m4_t, i32, __riscv_vreinterpret_u32m4,
-                         __riscv_vreinterpret_u32m2)
-OPENCV_HAL_IMPL_RVV_ZIP4(v_float32, vfloat32m4_t, f32,
-                         __riscv_vreinterpret_u32m4, __riscv_vreinterpret_u32m2)
-
-#define OPENCV_HAL_IMPL_RVV_TRANSPOSE4x4(_Tpvec, suffix)                       \
-  inline void v_transpose4x4(const _Tpvec &a0, const _Tpvec &a1,               \
-                             const _Tpvec &a2, const _Tpvec &a3, _Tpvec &b0,   \
-                             _Tpvec &b1, _Tpvec &b2, _Tpvec &b3) {             \
-    _Tpvec t0, t1, t2, t3;                                                     \
-    v_zip4(a0, a2, t0, t2);                                                    \
-    v_zip4(a1, a3, t1, t3);                                                    \
-    v_zip4(t0, t1, b0, b1);                                                    \
-    v_zip4(t2, t3, b2, b3);                                                    \
-  }
-
-OPENCV_HAL_IMPL_RVV_TRANSPOSE4x4(v_uint32, u32) OPENCV_HAL_IMPL_RVV_TRANSPOSE4x4(
-    v_int32, i32) OPENCV_HAL_IMPL_RVV_TRANSPOSE4x4(v_float32, f32)
-
-////////////// Reduce //////////////
-
-#define OPENCV_HAL_IMPL_RVV_REDUCE_SUM(_Tpvec, _wTpvec, _nwTpvec, scalartype,  \
-                                       wsuffix, vl, red)                       \
-  inline scalartype v_reduce_sum(const _Tpvec &a) {                            \
-    _nwTpvec zero = __riscv_vmv_v_x_##wsuffix##m1(0, vl);                      \
-    _nwTpvec res = __riscv_vmv_v_x_##wsuffix##m1(0, vl);                       \
-    res = __riscv_v##red(a, zero, vl);                                         \
-    return (scalartype)__riscv_vmv_x(res);                                     \
-  }
-    OPENCV_HAL_IMPL_RVV_REDUCE_SUM(
-        v_uint8, v_uint16, vuint16m1_t, unsigned, u16,
-        VTraits<v_uint8>::vlanes(),
-        wredsumu) OPENCV_HAL_IMPL_RVV_REDUCE_SUM(v_int8, v_int16, vint16m1_t,
-                                                 int, i16,
-                                                 VTraits<v_int8>::vlanes(),
-                                                 wredsum)
-        OPENCV_HAL_IMPL_RVV_REDUCE_SUM(
-            v_uint16, v_uint32, vuint32m1_t, unsigned, u32,
-            VTraits<v_uint16>::vlanes(),
-            wredsumu) OPENCV_HAL_IMPL_RVV_REDUCE_SUM(v_int16, v_int32,
-                                                     vint32m1_t, int, i32,
-                                                     VTraits<v_int16>::vlanes(),
-                                                     wredsum)
-            OPENCV_HAL_IMPL_RVV_REDUCE_SUM(
-                v_uint32, v_uint64, vuint64m1_t, unsigned, u64,
-                VTraits<v_uint32>::vlanes(),
-                wredsumu) OPENCV_HAL_IMPL_RVV_REDUCE_SUM(v_int32, v_int64,
-                                                         vint64m1_t, int, i64,
-                                                         VTraits<
-                                                             v_int32>::vlanes(),
-                                                         wredsum)
-                OPENCV_HAL_IMPL_RVV_REDUCE_SUM(
-                    v_uint64, v_uint64, vuint64m1_t, uint64, u64,
-                    VTraits<v_uint64>::vlanes(),
-                    redsum) OPENCV_HAL_IMPL_RVV_REDUCE_SUM(v_int64, v_int64,
-                                                           vint64m1_t, int64,
-                                                           i64,
-                                                           VTraits<v_int64>::
-                                                               vlanes(),
-                                                           redsum)
-
-#define OPENCV_HAL_IMPL_RVV_REDUCE_SUM_FP(_Tpvec, _wTpvec, _nwTpvec,           \
-                                          scalartype, wsuffix, vl)             \
-  inline scalartype v_reduce_sum(const _Tpvec &a) {                            \
-    _nwTpvec zero = __riscv_vfmv_v_f_##wsuffix##m1(0, vl);                     \
-    _nwTpvec res = __riscv_vfmv_v_f_##wsuffix##m1(0, vl);                      \
-    res = __riscv_vfredusum(a, zero, vl);                                      \
-    return (scalartype)__riscv_vfmv_f(res);                                    \
-  }
-                    OPENCV_HAL_IMPL_RVV_REDUCE_SUM_FP(
-                        v_float32, v_float32, vfloat32m1_t, float, f32,
-                        VTraits<v_float32>::vlanes())
-#if CV_SIMD_SCALABLE_64F
-                        OPENCV_HAL_IMPL_RVV_REDUCE_SUM_FP(
-                            v_float64, v_float64, vfloat64m1_t, float, f64,
-                            VTraits<v_float64>::vlanes())
-#endif
-
-#define OPENCV_HAL_IMPL_RVV_REDUCE(_Tpvec, _nTpvec, func, scalartype, suffix,  \
-                                   vl, red)                                    \
-  inline scalartype v_reduce_##func(const _Tpvec &a) {                         \
-    _nTpvec narrowM1 = __riscv_vlmul_trunc_##suffix##m1(a);                    \
-    return (scalartype)__riscv_vmv_x(__riscv_v##red(a, narrowM1, vl));         \
-  }
-
-#define OPENCV_HAL_IMPL_RVV_REDUCE_FP(_Tpvec, _nTpvec, func, scalartype,       \
-                                      suffix, vl, red)                         \
-  inline scalartype v_reduce_##func(const _Tpvec &a) {                         \
-    _nTpvec narrowM1 = __riscv_vlmul_trunc_##suffix##m1(a);                    \
-    return (scalartype)__riscv_vfmv_f(__riscv_v##red(a, narrowM1, vl));        \
-  }
-
-                            OPENCV_HAL_IMPL_RVV_REDUCE(
-                                v_uint8, vuint8m1_t, min, uchar, u8,
-                                VTraits<v_uint8>::vlanes(),
-                                redminu) OPENCV_HAL_IMPL_RVV_REDUCE(v_int8,
-                                                                    vint8m1_t,
-                                                                    min, schar,
-                                                                    i8,
-                                                                    VTraits<
-                                                                        v_int8>::
-                                                                        vlanes(),
-                                                                    redmin)
-                                OPENCV_HAL_IMPL_RVV_REDUCE(
-                                    v_uint16, vuint16m1_t, min, ushort, u16,
-                                    VTraits<v_uint16>::vlanes(),
-                                    redminu) OPENCV_HAL_IMPL_RVV_REDUCE(v_int16,
-                                                                        vint16m1_t,
-                                                                        min,
-                                                                        short,
-                                                                        i16,
-                                                                        VTraits<
-                                                                            v_int16>::
-                                                                            vlanes(),
-                                                                        redmin)
-                                    OPENCV_HAL_IMPL_RVV_REDUCE(
-                                        v_uint32, vuint32m1_t, min, unsigned,
-                                        u32, VTraits<v_uint32>::vlanes(),
-                                        redminu) OPENCV_HAL_IMPL_RVV_REDUCE(v_int32,
-                                                                            vint32m1_t,
-                                                                            min,
-                                                                            int,
-                                                                            i32,
-                                                                            VTraits<
-                                                                                v_int32>::
-                                                                                vlanes(),
-                                                                            redmin)
-                                        OPENCV_HAL_IMPL_RVV_REDUCE_FP(
-                                            v_float32, vfloat32m1_t, min, float,
-                                            f32, VTraits<v_float32>::vlanes(),
-                                            fredmin)
-                                            OPENCV_HAL_IMPL_RVV_REDUCE(
-                                                v_uint8, vuint8m1_t, max, uchar,
-                                                u8, VTraits<v_uint8>::vlanes(),
-                                                redmaxu)
-                                                OPENCV_HAL_IMPL_RVV_REDUCE(
-                                                    v_int8, vint8m1_t, max,
-                                                    schar, i8,
-                                                    VTraits<v_int8>::vlanes(),
-                                                    redmax)
-                                                    OPENCV_HAL_IMPL_RVV_REDUCE(
-                                                        v_uint16, vuint16m1_t,
-                                                        max, ushort, u16,
-                                                        VTraits<
-                                                            v_uint16>::vlanes(),
-                                                        redmaxu)
-                                                        OPENCV_HAL_IMPL_RVV_REDUCE(
-                                                            v_int16, vint16m1_t,
-                                                            max, short, i16,
-                                                            VTraits<v_int16>::
-                                                                vlanes(),
-                                                            redmax)
-                                                            OPENCV_HAL_IMPL_RVV_REDUCE(
-                                                                v_uint32,
-                                                                vuint32m1_t,
-                                                                max, unsigned,
-                                                                u32,
-                                                                VTraits<
-                                                                    v_uint32>::
-                                                                    vlanes(),
-                                                                redmaxu)
-                                                                OPENCV_HAL_IMPL_RVV_REDUCE(
-                                                                    v_int32,
-                                                                    vint32m1_t,
-                                                                    max, int,
-                                                                    i32,
-                                                                    VTraits<
-                                                                        v_int32>::
-                                                                        vlanes(),
-                                                                    redmax)
-                                                                    OPENCV_HAL_IMPL_RVV_REDUCE_FP(
-                                                                        v_float32,
-                                                                        vfloat32m1_t,
-                                                                        max,
-                                                                        float,
-                                                                        f32,
-                                                                        VTraits<
-                                                                            v_float32>::
-                                                                            vlanes(),
-                                                                        fredmax)
-
-                                                                        inline v_float32
-    v_reduce_sum4(const v_float32 &a, const v_float32 &b, const v_float32 &c,
-                  const v_float32 &d) {
-  // 0000 1111 2222 3333 ....
-  vuint64m4_t vid1 = __riscv_vid_v_u64m4(VTraits<vuint32m2_t>::vlanes());
-  vuint16m4_t t1 = __riscv_vreinterpret_u16m4(vid1);
-  vuint16m4_t t2 = __riscv_vslide1up(t1, 0, VTraits<vuint8m2_t>::vlanes());
-  vuint16m4_t t3 = __riscv_vslide1up(t2, 0, VTraits<vuint8m2_t>::vlanes());
-  vuint16m4_t t4 = __riscv_vslide1up(t3, 0, VTraits<vuint8m2_t>::vlanes());
-  t1 = __riscv_vor(__riscv_vor(t1, t2, VTraits<vuint8m2_t>::vlanes()),
-                   __riscv_vor(t3, t4, VTraits<vuint8m2_t>::vlanes()),
-                   VTraits<vuint8m2_t>::vlanes());
-
-  // index for transpose4X4
-  vuint16m4_t vidx0 = __riscv_vmul(t1, 12, VTraits<vuint8m2_t>::vlanes());
-  vidx0 =
-      __riscv_vadd(vidx0, __riscv_vid_v_u16m4(VTraits<vuint8m2_t>::vlanes()),
-                   VTraits<vuint8m2_t>::vlanes());
-  vuint16m4_t vidx1 = __riscv_vadd(vidx0, 4, VTraits<vuint8m2_t>::vlanes());
-  vuint16m4_t vidx2 = __riscv_vadd(vidx0, 8, VTraits<vuint8m2_t>::vlanes());
-  vuint16m4_t vidx3 = __riscv_vadd(vidx0, 12, VTraits<vuint8m2_t>::vlanes());
-
-  // zip
-  vuint32m4_t tempA = __riscv_vreinterpret_u32m4(__riscv_vor(
-      __riscv_vzext_vf2(__riscv_vreinterpret_u32m2(a),
-                        VTraits<vuint16m2_t>::vlanes()),
-      __riscv_vreinterpret_u64m4(__riscv_vslide1up(
-          __riscv_vreinterpret_u32m4(__riscv_vzext_vf2(
-              __riscv_vreinterpret_u32m2(c), VTraits<vuint16m2_t>::vlanes())),
-          0, VTraits<vuint16m2_t>::vlanes())),
-      VTraits<vuint32m2_t>::vlanes()));
-  vuint32m4_t tempB = __riscv_vreinterpret_u32m4(__riscv_vor(
-      __riscv_vzext_vf2(__riscv_vreinterpret_u32m2(b),
-                        VTraits<vuint16m2_t>::vlanes()),
-      __riscv_vreinterpret_u64m4(__riscv_vslide1up(
-          __riscv_vreinterpret_u32m4(__riscv_vzext_vf2(
-              __riscv_vreinterpret_u32m2(d), VTraits<vuint16m2_t>::vlanes())),
-          0, VTraits<vuint16m2_t>::vlanes())),
-      VTraits<vuint32m2_t>::vlanes()));
-  vfloat32m8_t temp = __riscv_vreinterpret_f32m8(__riscv_vreinterpret_u32m8(
-      __riscv_vor(__riscv_vzext_vf2(tempA, VTraits<vuint8m2_t>::vlanes()),
-                  __riscv_vreinterpret_u64m8(__riscv_vslide1up(
-                      __riscv_vreinterpret_u32m8(__riscv_vzext_vf2(
-                          tempB, VTraits<vuint8m2_t>::vlanes())),
-                      0, VTraits<vuint8m2_t>::vlanes())),
-                  VTraits<vuint16m2_t>::vlanes())));
-
-  // transpose
-  vfloat32m2_t b0 = __riscv_vlmul_trunc_f32m2(
-      __riscv_vrgatherei16(temp, vidx0, VTraits<vuint8m2_t>::vlanes()));
-  vfloat32m2_t b1 = __riscv_vlmul_trunc_f32m2(
-      __riscv_vrgatherei16(temp, vidx1, VTraits<vuint8m2_t>::vlanes()));
-  vfloat32m2_t b2 = __riscv_vlmul_trunc_f32m2(
-      __riscv_vrgatherei16(temp, vidx2, VTraits<vuint8m2_t>::vlanes()));
-  vfloat32m2_t b3 = __riscv_vlmul_trunc_f32m2(
-      __riscv_vrgatherei16(temp, vidx3, VTraits<vuint8m2_t>::vlanes()));
-
-  // vector add
-  v_float32 res =
-      __riscv_vfadd(__riscv_vfadd(b0, b1, VTraits<vfloat32m2_t>::vlanes()),
-                    __riscv_vfadd(b2, b3, VTraits<vfloat32m2_t>::vlanes()),
-                    VTraits<vfloat32m2_t>::vlanes());
-  return res;
-}
-
-////////////// Square-Root //////////////
-
-inline v_float32 v_sqrt(const v_float32 &x) {
-  return __riscv_vfsqrt(x, VTraits<v_float32>::vlanes());
-}
-
-inline v_float32 v_invsqrt(const v_float32 &x) {
-  v_float32 one = v_setall_f32(1.0f);
-  return v_div(one, v_sqrt(x));
-}
-
-#if CV_SIMD_SCALABLE_64F
-inline v_float64 v_sqrt(const v_float64 &x) {
-  return __riscv_vfsqrt(x, VTraits<v_float64>::vlanes());
-}
-
-inline v_float64 v_invsqrt(const v_float64 &x) {
-  v_float64 one = v_setall_f64(1.0f);
-  return v_div(one, v_sqrt(x));
-}
-#endif
-
-inline v_float32 v_magnitude(const v_float32 &a, const v_float32 &b) {
-  v_float32 x =
-      __riscv_vfmacc(__riscv_vfmul(a, a, VTraits<v_float32>::vlanes()), b, b,
-                     VTraits<v_float32>::vlanes());
-  return v_sqrt(x);
-}
-
-inline v_float32 v_sqr_magnitude(const v_float32 &a, const v_float32 &b) {
-  return v_float32(
-      __riscv_vfmacc(__riscv_vfmul(a, a, VTraits<v_float32>::vlanes()), b, b,
-                     VTraits<v_float32>::vlanes()));
-}
-
-#if CV_SIMD_SCALABLE_64F
-inline v_float64 v_magnitude(const v_float64 &a, const v_float64 &b) {
-  v_float64 x =
-      __riscv_vfmacc(__riscv_vfmul(a, a, VTraits<v_float64>::vlanes()), b, b,
-                     VTraits<v_float64>::vlanes());
-  return v_sqrt(x);
-}
-
-inline v_float64 v_sqr_magnitude(const v_float64 &a, const v_float64 &b) {
-  return __riscv_vfmacc(__riscv_vfmul(a, a, VTraits<v_float64>::vlanes()), b, b,
-                        VTraits<v_float64>::vlanes());
-}
-#endif
-
-////////////// Multiply-Add //////////////
-
-inline v_float32 v_fma(const v_float32 &a, const v_float32 &b,
-                       const v_float32 &c) {
-  return __riscv_vfmacc(c, a, b, VTraits<v_float32>::vlanes());
-}
-inline v_int32 v_fma(const v_int32 &a, const v_int32 &b, const v_int32 &c) {
-  return __riscv_vmacc(c, a, b, VTraits<v_float32>::vlanes());
-}
-
-inline v_float32 v_muladd(const v_float32 &a, const v_float32 &b,
-                          const v_float32 &c) {
-  return v_fma(a, b, c);
-}
-
-inline v_int32 v_muladd(const v_int32 &a, const v_int32 &b, const v_int32 &c) {
-  return v_fma(a, b, c);
-}
-
-#if CV_SIMD_SCALABLE_64F
-inline v_float64 v_fma(const v_float64 &a, const v_float64 &b,
-                       const v_float64 &c) {
-  return __riscv_vfmacc_vv_f64m2(c, a, b, VTraits<v_float64>::vlanes());
-}
-
-inline v_float64 v_muladd(const v_float64 &a, const v_float64 &b,
-                          const v_float64 &c) {
-  return v_fma(a, b, c);
-}
-#endif
-
-////////////// Check all/any //////////////
-
-#define OPENCV_HAL_IMPL_RVV_CHECK_ALLANY(_Tpvec, vl)                           \
-  inline bool v_check_all(const _Tpvec &a) {                                   \
-    return (int)__riscv_vcpop(__riscv_vmslt(a, 0, vl), vl) == vl;              \
-  }                                                                            \
-  inline bool v_check_any(const _Tpvec &a) {                                   \
-    return (int)__riscv_vcpop(__riscv_vmslt(a, 0, vl), vl) != 0;               \
-  }
-
-OPENCV_HAL_IMPL_RVV_CHECK_ALLANY(v_int8, VTraits<v_int8>::vlanes())
-OPENCV_HAL_IMPL_RVV_CHECK_ALLANY(v_int16, VTraits<v_int16>::vlanes())
-OPENCV_HAL_IMPL_RVV_CHECK_ALLANY(v_int32, VTraits<v_int32>::vlanes())
-OPENCV_HAL_IMPL_RVV_CHECK_ALLANY(v_int64, VTraits<v_int64>::vlanes())
-
-inline bool v_check_all(const v_uint8 &a) {
-  return v_check_all(v_reinterpret_as_s8(a));
-}
-inline bool v_check_any(const v_uint8 &a) {
-  return v_check_any(v_reinterpret_as_s8(a));
-}
-
-inline bool v_check_all(const v_uint16 &a) {
-  return v_check_all(v_reinterpret_as_s16(a));
-}
-inline bool v_check_any(const v_uint16 &a) {
-  return v_check_any(v_reinterpret_as_s16(a));
-}
-
-inline bool v_check_all(const v_uint32 &a) {
-  return v_check_all(v_reinterpret_as_s32(a));
-}
-inline bool v_check_any(const v_uint32 &a) {
-  return v_check_any(v_reinterpret_as_s32(a));
-}
-
-inline bool v_check_all(const v_float32 &a) {
-  return v_check_all(v_reinterpret_as_s32(a));
-}
-inline bool v_check_any(const v_float32 &a) {
-  return v_check_any(v_reinterpret_as_s32(a));
-}
-
-inline bool v_check_all(const v_uint64 &a) {
-  return v_check_all(v_reinterpret_as_s64(a));
-}
-inline bool v_check_any(const v_uint64 &a) {
-  return v_check_any(v_reinterpret_as_s64(a));
-}
-
-#if CV_SIMD_SCALABLE_64F
-inline bool v_check_all(const v_float64 &a) {
-  return v_check_all(v_reinterpret_as_s64(a));
-}
-inline bool v_check_any(const v_float64 &a) {
-  return v_check_any(v_reinterpret_as_s64(a));
-}
-#endif
-
-////////////// abs //////////////
-
-#define OPENCV_HAL_IMPL_RVV_ABSDIFF(_Tpvec, abs)                               \
-  inline _Tpvec v_##abs(const _Tpvec &a, const _Tpvec &b) {                    \
-    return v_sub(v_max(a, b), v_min(a, b));                                    \
-  }
-
-OPENCV_HAL_IMPL_RVV_ABSDIFF(v_uint8, absdiff)
-OPENCV_HAL_IMPL_RVV_ABSDIFF(v_uint16, absdiff)
-OPENCV_HAL_IMPL_RVV_ABSDIFF(v_uint32, absdiff)
-OPENCV_HAL_IMPL_RVV_ABSDIFF(v_float32, absdiff)
-#if CV_SIMD_SCALABLE_64F
-OPENCV_HAL_IMPL_RVV_ABSDIFF(v_float64, absdiff)
-#endif
-OPENCV_HAL_IMPL_RVV_ABSDIFF(v_int8, absdiffs)
-OPENCV_HAL_IMPL_RVV_ABSDIFF(v_int16, absdiffs)
-
-#define OPENCV_HAL_IMPL_RVV_ABSDIFF_S(_Tpvec, _rTpvec, width)                  \
-  inline _rTpvec v_absdiff(const _Tpvec &a, const _Tpvec &b) {                 \
-    return __riscv_vnclipu(                                                    \
-        __riscv_vreinterpret_u##width##m4(__riscv_vwsub_vv(                    \
-            v_max(a, b), v_min(a, b), VTraits<_Tpvec>::vlanes())),             \
-        0, 0, VTraits<_Tpvec>::vlanes());                                      \
-  }
-
-OPENCV_HAL_IMPL_RVV_ABSDIFF_S(v_int8, v_uint8, 16)
-OPENCV_HAL_IMPL_RVV_ABSDIFF_S(v_int16, v_uint16, 32)
-OPENCV_HAL_IMPL_RVV_ABSDIFF_S(v_int32, v_uint32, 64)
-
-#define OPENCV_HAL_IMPL_RVV_ABS(_Tprvec, _Tpvec, suffix)                       \
-  inline _Tprvec v_abs(const _Tpvec &a) {                                      \
-    return v_absdiff(a, v_setzero_##suffix());                                 \
-  }
-
-OPENCV_HAL_IMPL_RVV_ABS(v_uint8, v_int8, s8)
-OPENCV_HAL_IMPL_RVV_ABS(v_uint16, v_int16, s16)
-OPENCV_HAL_IMPL_RVV_ABS(v_uint32, v_int32, s32)
-OPENCV_HAL_IMPL_RVV_ABS(v_float32, v_float32, f32)
-#if CV_SIMD_SCALABLE_64F
-OPENCV_HAL_IMPL_RVV_ABS(v_float64, v_float64, f64)
-#endif
-
-#define OPENCV_HAL_IMPL_RVV_REDUCE_SAD(_Tpvec, scalartype)                     \
-  inline scalartype v_reduce_sad(const _Tpvec &a, const _Tpvec &b) {           \
-    return v_reduce_sum(v_absdiff(a, b));                                      \
-  }
-
-OPENCV_HAL_IMPL_RVV_REDUCE_SAD(v_uint8, unsigned)
-OPENCV_HAL_IMPL_RVV_REDUCE_SAD(v_int8, unsigned)
-OPENCV_HAL_IMPL_RVV_REDUCE_SAD(v_uint16, unsigned)
-OPENCV_HAL_IMPL_RVV_REDUCE_SAD(v_int16, unsigned)
-OPENCV_HAL_IMPL_RVV_REDUCE_SAD(v_uint32, unsigned)
-OPENCV_HAL_IMPL_RVV_REDUCE_SAD(v_int32, unsigned)
-OPENCV_HAL_IMPL_RVV_REDUCE_SAD(v_float32, float)
-
-////////////// Select //////////////
-
-#define OPENCV_HAL_IMPL_RVV_SELECT(_Tpvec, vl)                                 \
-  inline _Tpvec v_select(const _Tpvec &mask, const _Tpvec &a,                  \
-                         const _Tpvec &b) {                                    \
-    return __riscv_vmerge(b, a, __riscv_vmsne(mask, 0, vl), vl);               \
-  }
-
-OPENCV_HAL_IMPL_RVV_SELECT(v_uint8, VTraits<v_uint8>::vlanes())
-OPENCV_HAL_IMPL_RVV_SELECT(v_uint16, VTraits<v_uint16>::vlanes())
-OPENCV_HAL_IMPL_RVV_SELECT(v_uint32, VTraits<v_uint32>::vlanes())
-OPENCV_HAL_IMPL_RVV_SELECT(v_int8, VTraits<v_int8>::vlanes())
-OPENCV_HAL_IMPL_RVV_SELECT(v_int16, VTraits<v_int16>::vlanes())
-OPENCV_HAL_IMPL_RVV_SELECT(v_int32, VTraits<v_int32>::vlanes())
-
-inline v_float32 v_select(const v_float32 &mask, const v_float32 &a,
-                          const v_float32 &b) {
-  return __riscv_vmerge(b, a,
-                        __riscv_vmfne(mask, 0, VTraits<v_float32>::vlanes()),
-                        VTraits<v_float32>::vlanes());
-}
-
-#if CV_SIMD_SCALABLE_64F
-inline v_float64 v_select(const v_float64 &mask, const v_float64 &a,
-                          const v_float64 &b) {
-  return __riscv_vmerge(b, a,
-                        __riscv_vmfne(mask, 0, VTraits<v_float64>::vlanes()),
-                        VTraits<v_float64>::vlanes());
-}
-#endif
-
-////////////// Rotate shift //////////////
-
-#define OPENCV_HAL_IMPL_RVV_ROTATE_INTEGER(_Tpvec, suffix, vl)                 \
-  template <int n> inline _Tpvec v_rotate_right(const _Tpvec &a) {             \
-    return __riscv_vslidedown(a, n, vl);                                       \
-  }                                                                            \
-  template <int n> inline _Tpvec v_rotate_left(const _Tpvec &a) {              \
-    return __riscv_vslideup(__riscv_vmv_v_x_##suffix##m2(0, vl), a, n, vl);    \
-  }                                                                            \
-  template <> inline _Tpvec v_rotate_left<0>(const _Tpvec &a) { return a; }    \
-  template <int n>                                                             \
-  inline _Tpvec v_rotate_right(const _Tpvec &a, const _Tpvec &b) {             \
-    return __riscv_vslideup(__riscv_vslidedown(a, n, vl), b,                   \
-                            VTraits<_Tpvec>::vlanes() - n, vl);                \
-  }                                                                            \
-  template <int n>                                                             \
-  inline _Tpvec v_rotate_left(const _Tpvec &a, const _Tpvec &b) {              \
-    return __riscv_vslideup(                                                   \
-        __riscv_vslidedown(b, VTraits<_Tpvec>::vlanes() - n, vl), a, n, vl);   \
-  }                                                                            \
-  template <>                                                                  \
-  inline _Tpvec v_rotate_left<0>(const _Tpvec &a, const _Tpvec &b) {           \
-    CV_UNUSED(b);                                                              \
-    return a;                                                                  \
-  }
-
-OPENCV_HAL_IMPL_RVV_ROTATE_INTEGER(v_uint8, u8, VTraits<v_uint8>::vlanes())
-OPENCV_HAL_IMPL_RVV_ROTATE_INTEGER(v_int8, i8, VTraits<v_int8>::vlanes())
-OPENCV_HAL_IMPL_RVV_ROTATE_INTEGER(v_uint16, u16, VTraits<v_uint16>::vlanes())
-OPENCV_HAL_IMPL_RVV_ROTATE_INTEGER(v_int16, i16, VTraits<v_int16>::vlanes())
-OPENCV_HAL_IMPL_RVV_ROTATE_INTEGER(v_uint32, u32, VTraits<v_uint32>::vlanes())
-OPENCV_HAL_IMPL_RVV_ROTATE_INTEGER(v_int32, i32, VTraits<v_int32>::vlanes())
-OPENCV_HAL_IMPL_RVV_ROTATE_INTEGER(v_uint64, u64, VTraits<v_uint64>::vlanes())
-OPENCV_HAL_IMPL_RVV_ROTATE_INTEGER(v_int64, i64, VTraits<v_int64>::vlanes())
-
-#define OPENCV_HAL_IMPL_RVV_ROTATE_FP(_Tpvec, suffix, vl)                      \
-  template <int n> inline _Tpvec v_rotate_right(const _Tpvec &a) {             \
-    return __riscv_vslidedown(a, n, vl);                                       \
-  }                                                                            \
-  template <int n> inline _Tpvec v_rotate_left(const _Tpvec &a) {              \
-    return __riscv_vslideup(__riscv_vfmv_v_f_##suffix##m2(0, vl), a, n, vl);   \
-  }                                                                            \
-  template <> inline _Tpvec v_rotate_left<0>(const _Tpvec &a) { return a; }    \
-  template <int n>                                                             \
-  inline _Tpvec v_rotate_right(const _Tpvec &a, const _Tpvec &b) {             \
-    return __riscv_vslideup(__riscv_vslidedown(a, n, vl), b,                   \
-                            VTraits<_Tpvec>::vlanes() - n, vl);                \
-  }                                                                            \
-  template <int n>                                                             \
-  inline _Tpvec v_rotate_left(const _Tpvec &a, const _Tpvec &b) {              \
-    return __riscv_vslideup(                                                   \
-        __riscv_vslidedown(b, VTraits<_Tpvec>::vlanes() - n, vl), a, n, vl);   \
-  }                                                                            \
-  template <>                                                                  \
-  inline _Tpvec v_rotate_left<0>(const _Tpvec &a, const _Tpvec &b) {           \
-    CV_UNUSED(b);                                                              \
-    return a;                                                                  \
-  }
-
-OPENCV_HAL_IMPL_RVV_ROTATE_FP(v_float32, f32, VTraits<v_float32>::vlanes())
-#if CV_SIMD_SCALABLE_64F
-OPENCV_HAL_IMPL_RVV_ROTATE_FP(v_float64, f64, VTraits<v_float64>::vlanes())
-#endif
-
-////////////// Convert to float //////////////
-inline v_float32 v_cvt_f32(const v_int32 &a) {
-  return __riscv_vfcvt_f_x_v_f32m2(a, VTraits<v_float32>::vlanes());
-}
-
-#if CV_SIMD_SCALABLE_64F
-inline v_float32 v_cvt_f32(const v_float64 &a) {
-  return __riscv_vfncvt_f(__riscv_vlmul_ext_f64m4(a),
-                          VTraits<v_float64>::vlanes());
-}
-
-inline v_float32 v_cvt_f32(const v_float64 &a, const v_float64 &b) {
-  return __riscv_vfncvt_f(__riscv_vset(__riscv_vlmul_ext_f64m4(a), 1, b),
-                          VTraits<v_float32>::vlanes());
-}
-
-inline v_float64 v_cvt_f64(const v_int32 &a) {
-  return __riscv_vget_f64m2(__riscv_vfwcvt_f(a, VTraits<v_int32>::vlanes()), 0);
-}
-
-inline v_float64 v_cvt_f64_high(const v_int32 &a) {
-  return __riscv_vget_f64m2(__riscv_vfwcvt_f(a, VTraits<v_int32>::vlanes()), 1);
-}
-
-inline v_float64 v_cvt_f64(const v_float32 &a) {
-  return __riscv_vget_f64m2(__riscv_vfwcvt_f(a, VTraits<v_float32>::vlanes()),
-                            0);
-}
-
-inline v_float64 v_cvt_f64_high(const v_float32 &a) {
-  return __riscv_vget_f64m2(__riscv_vfwcvt_f(a, VTraits<v_float32>::vlanes()),
-                            1);
-}
-
-inline v_float64 v_cvt_f64(const v_int64 &a) {
-  return __riscv_vfcvt_f(a, VTraits<v_int64>::vlanes());
-}
-#endif
-
-//////////// Broadcast //////////////
-
-#define OPENCV_HAL_IMPL_RVV_BROADCAST(_Tpvec, suffix)                          \
-  template <int s = 0>                                                         \
-  inline _Tpvec v_broadcast_element(_Tpvec v, int i = s) {                     \
-    return v_setall_##suffix(v_extract_n(v, i));                               \
-  }                                                                            \
-  inline _Tpvec v_broadcast_highest(_Tpvec v) {                                \
-    return v_setall_##suffix(v_extract_n(v, VTraits<_Tpvec>::vlanes() - 1));   \
-  }
-
-OPENCV_HAL_IMPL_RVV_BROADCAST(v_uint32, u32)
-OPENCV_HAL_IMPL_RVV_BROADCAST(v_int32, s32)
-OPENCV_HAL_IMPL_RVV_BROADCAST(v_float32, f32)
-
-////////////// Reverse //////////////
-#define OPENCV_HAL_IMPL_RVV_REVERSE(_Tpvec, width)                             \
-  inline _Tpvec v_reverse(const _Tpvec &a) {                                   \
-    vuint##width##m2_t vidx = __riscv_vrsub(                                   \
-        __riscv_vid_v_u##width##m2(VTraits<_Tpvec>::vlanes()),                 \
-        VTraits<_Tpvec>::vlanes() - 1, VTraits<_Tpvec>::vlanes());             \
-    return __riscv_vrgather(a, vidx, VTraits<_Tpvec>::vlanes());               \
-  }
-OPENCV_HAL_IMPL_RVV_REVERSE(v_uint8, 8)
-OPENCV_HAL_IMPL_RVV_REVERSE(v_int8, 8)
-OPENCV_HAL_IMPL_RVV_REVERSE(v_uint16, 16)
-OPENCV_HAL_IMPL_RVV_REVERSE(v_int16, 16)
-OPENCV_HAL_IMPL_RVV_REVERSE(v_uint32, 32)
-OPENCV_HAL_IMPL_RVV_REVERSE(v_int32, 32)
-OPENCV_HAL_IMPL_RVV_REVERSE(v_float32, 32)
-OPENCV_HAL_IMPL_RVV_REVERSE(v_uint64, 64)
-OPENCV_HAL_IMPL_RVV_REVERSE(v_int64, 64)
-#if CV_SIMD_SCALABLE_64F
-OPENCV_HAL_IMPL_RVV_REVERSE(v_float64, 64)
-#endif
-
-//////////// Value reordering ////////////
-
-#define OPENCV_HAL_IMPL_RVV_EXPAND(_Tp, _Tpwvec, _Tpwvec_m2, _Tpvec, width,    \
-                                   suffix, suffix2, cvt)                       \
-  inline void v_expand(const _Tpvec &a, _Tpwvec &b0, _Tpwvec &b1) {            \
-    _Tpwvec_m2 temp = cvt(a, VTraits<_Tpvec>::vlanes());                       \
-    b0 = __riscv_vget_##suffix##m2(temp, 0);                                   \
-    b1 = __riscv_vget_##suffix##m2(temp, 1);                                   \
-  }                                                                            \
-  inline _Tpwvec v_expand_low(const _Tpvec &a) {                               \
-    _Tpwvec_m2 temp = cvt(a, VTraits<_Tpvec>::vlanes());                       \
-    return __riscv_vget_##suffix##m2(temp, 0);                                 \
-  }                                                                            \
-  inline _Tpwvec v_expand_high(const _Tpvec &a) {                              \
-    _Tpwvec_m2 temp = cvt(a, VTraits<_Tpvec>::vlanes());                       \
-    return __riscv_vget_##suffix##m2(temp, 1);                                 \
-  }                                                                            \
-  inline _Tpwvec v_load_expand(const _Tp *ptr) {                               \
-    return cvt(                                                                \
-        __riscv_vle##width##_v_##suffix2##m1(ptr, VTraits<_Tpvec>::vlanes()),  \
-        VTraits<_Tpvec>::vlanes());                                            \
-  }
-
-OPENCV_HAL_IMPL_RVV_EXPAND(uchar, v_uint16, vuint16m4_t, v_uint8, 8, u16, u8,
-                           __riscv_vwcvtu_x)
-OPENCV_HAL_IMPL_RVV_EXPAND(schar, v_int16, vint16m4_t, v_int8, 8, i16, i8,
-                           __riscv_vwcvt_x)
-OPENCV_HAL_IMPL_RVV_EXPAND(ushort, v_uint32, vuint32m4_t, v_uint16, 16, u32,
-                           u16, __riscv_vwcvtu_x)
-OPENCV_HAL_IMPL_RVV_EXPAND(short, v_int32, vint32m4_t, v_int16, 16, i32, i16,
-                           __riscv_vwcvt_x)
-OPENCV_HAL_IMPL_RVV_EXPAND(uint, v_uint64, vuint64m4_t, v_uint32, 32, u64, u32,
-                           __riscv_vwcvtu_x)
-OPENCV_HAL_IMPL_RVV_EXPAND(int, v_int64, vint64m4_t, v_int32, 32, i64, i32,
-                           __riscv_vwcvt_x)
-
-inline v_uint32 v_load_expand_q(const uchar *ptr) {
-  return __riscv_vwcvtu_x(
-      __riscv_vwcvtu_x(__riscv_vle8_v_u8mf2(ptr, VTraits<v_uint32>::vlanes()),
-                       VTraits<v_uint32>::vlanes()),
-      VTraits<v_uint32>::vlanes());
-}
-
-inline v_int32 v_load_expand_q(const schar *ptr) {
-  return __riscv_vwcvt_x(
-      __riscv_vwcvt_x(__riscv_vle8_v_i8mf2(ptr, VTraits<v_int32>::vlanes()),
-                      VTraits<v_int32>::vlanes()),
-      VTraits<v_int32>::vlanes());
-}
-
-#define OPENCV_HAL_IMPL_RVV_PACK(_Tpvec, _Tp, _wTpvec, hwidth, hsuffix,        \
-                                 suffix, rshr, shr)                            \
-  inline _Tpvec v_pack(const _wTpvec &a, const _wTpvec &b) {                   \
-    return shr(__riscv_vset(__riscv_vlmul_ext_##suffix##m4(a), 1, b), 0, 0,    \
-               VTraits<_Tpvec>::vlanes());                                     \
-  }                                                                            \
-  inline void v_pack_store(_Tp *ptr, const _wTpvec &a) {                       \
-    __riscv_vse##hwidth##_v_##hsuffix##m1(                                     \
-        ptr, shr(a, 0, 0, VTraits<_Tpvec>::vlanes()),                          \
-        VTraits<_wTpvec>::vlanes());                                           \
-  }                                                                            \
-  template <int n = 0>                                                         \
-  inline _Tpvec v_rshr_pack(const _wTpvec &a, const _wTpvec &b, int N = n) {   \
-    return rshr(__riscv_vset(__riscv_vlmul_ext_##suffix##m4(a), 1, b), N, 0,   \
-                VTraits<_Tpvec>::vlanes());                                    \
-  }                                                                            \
-  template <int n = 0>                                                         \
-  inline void v_rshr_pack_store(_Tp *ptr, const _wTpvec &a, int N = n) {       \
-    __riscv_vse##hwidth##_v_##hsuffix##m1(                                     \
-        ptr, rshr(a, N, 0, VTraits<_Tpvec>::vlanes()),                         \
-        VTraits<_wTpvec>::vlanes());                                           \
-  }
-
-#define OPENCV_HAL_IMPL_RVV_PACK_32(_Tpvec, _Tp, _wTpvec, hwidth, hsuffix,     \
-                                    suffix, rshr, shr)                         \
-  inline _Tpvec v_pack(const _wTpvec &a, const _wTpvec &b) {                   \
-    return shr(__riscv_vset(__riscv_vlmul_ext_##suffix##m4(a), 1, b), 0,       \
-               VTraits<_Tpvec>::vlanes());                                     \
-  }                                                                            \
-  inline void v_pack_store(_Tp *ptr, const _wTpvec &a) {                       \
-    __riscv_vse##hwidth##_v_##hsuffix##m1(                                     \
-        ptr, shr(a, 0, VTraits<_Tpvec>::vlanes()),                             \
-        VTraits<_wTpvec>::vlanes());                                           \
-  }                                                                            \
-  template <int n = 0>                                                         \
-  inline _Tpvec v_rshr_pack(const _wTpvec &a, const _wTpvec &b, int N = n) {   \
-    return rshr(__riscv_vset(__riscv_vlmul_ext_##suffix##m4(a), 1, b), N, 0,   \
-                VTraits<_Tpvec>::vlanes());                                    \
-  }                                                                            \
-  template <int n = 0>                                                         \
-  inline void v_rshr_pack_store(_Tp *ptr, const _wTpvec &a, int N = n) {       \
-    __riscv_vse##hwidth##_v_##hsuffix##m1(                                     \
-        ptr, rshr(a, N, 0, VTraits<_Tpvec>::vlanes()),                         \
-        VTraits<_wTpvec>::vlanes());                                           \
-  }
-
-OPENCV_HAL_IMPL_RVV_PACK(v_uint8, uchar, v_uint16, 8, u8, u16, __riscv_vnclipu,
-                         __riscv_vnclipu)
-OPENCV_HAL_IMPL_RVV_PACK(v_int8, schar, v_int16, 8, i8, i16, __riscv_vnclip,
-                         __riscv_vnclip)
-OPENCV_HAL_IMPL_RVV_PACK(v_uint16, ushort, v_uint32, 16, u16, u32,
-                         __riscv_vnclipu, __riscv_vnclipu)
-OPENCV_HAL_IMPL_RVV_PACK(v_int16, short, v_int32, 16, i16, i32, __riscv_vnclip,
-                         __riscv_vnclip)
-OPENCV_HAL_IMPL_RVV_PACK_32(v_uint32, unsigned, v_uint64, 32, u32, u64,
-                            __riscv_vnclipu, __riscv_vnsrl)
-OPENCV_HAL_IMPL_RVV_PACK_32(v_int32, int, v_int64, 32, i32, i64, __riscv_vnclip,
-                            __riscv_vnsra)
-
-#define OPENCV_HAL_IMPL_RVV_PACK_U(_Tpvec, _Tp, _wTpvec, _wTp, hwidth, width,  \
-                                   hsuffix, suffix, cast, hvl, vl)             \
-  inline _Tpvec v_pack_u(const _wTpvec &a, const _wTpvec &b) {                 \
-    return __riscv_vnclipu(                                                    \
-        cast(__riscv_vmax(                                                     \
-            __riscv_vset(__riscv_vlmul_ext_##suffix##m4(a), 1, b), 0, vl)),    \
-        0, 0, vl);                                                             \
-  }                                                                            \
-  inline void v_pack_u_store(_Tp *ptr, const _wTpvec &a) {                     \
-    __riscv_vse##hwidth##_v_##hsuffix##m1(                                     \
-        ptr,                                                                   \
-        __riscv_vnclipu(                                                       \
-            __riscv_vreinterpret_u##width##m2(__riscv_vmax(a, 0, vl)), 0, 0,   \
-            vl),                                                               \
-        hvl);                                                                  \
-  }                                                                            \
-  template <int N = 0>                                                         \
-  inline _Tpvec v_rshr_pack_u(const _wTpvec &a, const _wTpvec &b, int n = N) { \
-    return __riscv_vnclipu(                                                    \
-        cast(__riscv_vmax(                                                     \
-            __riscv_vset(__riscv_vlmul_ext_##suffix##m4(a), 1, b), 0, vl)),    \
-        n, 0, vl);                                                             \
-  }                                                                            \
-  template <int N = 0>                                                         \
-  inline void v_rshr_pack_u_store(_Tp *ptr, const _wTpvec &a, int n = N) {     \
-    __riscv_vse##hwidth##_v_##hsuffix##m1(                                     \
-        ptr,                                                                   \
-        __riscv_vnclipu(                                                       \
-            __riscv_vreinterpret_u##width##m2(__riscv_vmax(a, 0, vl)), n, 0,   \
-            vl),                                                               \
-        hvl);                                                                  \
-  }
-
-OPENCV_HAL_IMPL_RVV_PACK_U(v_uint8, uchar, v_int16, short, 8, 16, u8, i16,
-                           __riscv_vreinterpret_v_i16m4_u16m4,
-                           VTraits<v_int16>::vlanes(),
-                           VTraits<v_uint8>::vlanes())
-OPENCV_HAL_IMPL_RVV_PACK_U(v_uint16, ushort, v_int32, int, 16, 32, u16, i32,
-                           __riscv_vreinterpret_v_i32m4_u32m4,
-                           VTraits<v_int32>::vlanes(),
-                           VTraits<v_uint16>::vlanes())
-
-/* void v_zip(const _Tpvec& a0, const _Tpvec& a1, _Tpvec& b0, _Tpvec& b1)
-  a0 = {A1 A2 A3 A4}
-  a1 = {B1 B2 B3 B4}
----------------
-  {A1 B1 A2 B2} and {A3 B3 A4 B4}
-*/
-
-#define OPENCV_HAL_IMPL_RVV_ZIP(_Tpvec, _wTpvec, suffix, width, width2,        \
-                                convert2um2, convert2um1)                      \
-  inline void v_zip(const _Tpvec &a0, const _Tpvec &a1, _Tpvec &b0,            \
-                    _Tpvec &b1) {                                              \
-    _wTpvec temp = __riscv_vreinterpret_##suffix##m4(convert2um2(__riscv_vor(  \
-        __riscv_vzext_vf2(convert2um1(a0), VTraits<_Tpvec>::vlanes() * 2),     \
-        __riscv_vreinterpret_u##width2##m4(__riscv_vslide1up(                  \
-            __riscv_vreinterpret_u##width##m4(__riscv_vzext_vf2(               \
-                convert2um1(a1), VTraits<_Tpvec>::vlanes() * 2)),              \
-            0, VTraits<_Tpvec>::vlanes() * 2)),                                \
-        VTraits<_Tpvec>::vlanes())));                                          \
-    b0 = __riscv_vget_##suffix##m2(temp, 0);                                   \
-    b1 = __riscv_vget_##suffix##m2(temp, 1);                                   \
-  }
-OPENCV_HAL_IMPL_RVV_ZIP(v_uint8, vuint8m4_t, u8, 8, 16, OPENCV_HAL_NOP,
-                        OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_RVV_ZIP(v_int8, vint8m4_t, i8, 8, 16, __riscv_vreinterpret_u8m4,
-                        __riscv_vreinterpret_u8m2)
-OPENCV_HAL_IMPL_RVV_ZIP(v_uint16, vuint16m4_t, u16, 16, 32, OPENCV_HAL_NOP,
-                        OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_RVV_ZIP(v_int16, vint16m4_t, i16, 16, 32,
-                        __riscv_vreinterpret_u16m4, __riscv_vreinterpret_u16m2)
-OPENCV_HAL_IMPL_RVV_ZIP(v_uint32, vuint32m4_t, u32, 32, 64, OPENCV_HAL_NOP,
-                        OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_RVV_ZIP(v_int32, vint32m4_t, i32, 32, 64,
-                        __riscv_vreinterpret_u32m4, __riscv_vreinterpret_u32m2)
-OPENCV_HAL_IMPL_RVV_ZIP(v_float32, vfloat32m4_t, f32, 32, 64,
-                        __riscv_vreinterpret_u32m4, __riscv_vreinterpret_u32m2)
-
-#if CV_SIMD_SCALABLE_64F
-inline void v_zip(const v_float64 &a0, const v_float64 &a1, v_float64 &b0,
-                  v_float64 &b1) {
-  vuint16mf2_t idx0 = __riscv_vid_v_u16mf2(VTraits<v_float64>::vlanes());
-  vuint16mf2_t idx1 = __riscv_vadd(idx0, VTraits<v_float64>::vlanes(),
-                                   VTraits<v_float64>::vlanes());
-  vuint16m1_t idx = __riscv_vreinterpret_u16m1(
-      (__riscv_vor(__riscv_vzext_vf2(idx0, VTraits<v_float64>::vlanes()),
-                   __riscv_vreinterpret_u32m1(__riscv_vslide1up(
-                       __riscv_vreinterpret_u16m1(__riscv_vzext_vf2(
-                           idx1, VTraits<v_float64>::vlanes())),
-                       0, VTraits<v_uint32>::vlanes())),
-                   VTraits<v_uint32>::vlanes())));
-#if 0
-    vfloat64m4_t temp = __riscv_vcreate_v_f64m2_f64m4(a0, a1);
-#else // TODO: clean up when RVV Intrinsic is frozen.
-  vfloat64m4_t temp = __riscv_vlmul_ext_f64m4(a0);
-  temp = __riscv_vset(temp, 1, a1);
-#endif
-  temp = __riscv_vrgatherei16(temp, idx, VTraits<v_float64>::vlanes() * 2);
-  b0 = __riscv_vget_f64m2(temp, 0);
-  b1 = __riscv_vget_f64m2(temp, 1);
-}
-#endif
-
-#define OPENCV_HAL_IMPL_RVV_UNPACKS(_Tpvec, width)                             \
-  inline _Tpvec v_combine_low(const _Tpvec &a, const _Tpvec &b) {              \
-    return __riscv_vslideup(a, b, VTraits<_Tpvec>::vlanes() / 2,               \
-                            VTraits<_Tpvec>::vlanes());                        \
-  }                                                                            \
-  inline _Tpvec v_combine_high(const _Tpvec &a, const _Tpvec &b) {             \
-    return __riscv_vslideup(                                                   \
-        __riscv_vslidedown(a, VTraits<_Tpvec>::vlanes() / 2,                   \
-                           VTraits<_Tpvec>::vlanes()),                         \
-        __riscv_vslidedown(b, VTraits<_Tpvec>::vlanes() / 2,                   \
-                           VTraits<_Tpvec>::vlanes()),                         \
-        VTraits<_Tpvec>::vlanes() / 2, VTraits<_Tpvec>::vlanes());             \
-  }                                                                            \
-  inline void v_recombine(const _Tpvec &a, const _Tpvec &b, _Tpvec &c,         \
-                          _Tpvec &d) {                                         \
-    c = v_combine_low(a, b);                                                   \
-    d = v_combine_high(a, b);                                                  \
-  }
-
-OPENCV_HAL_IMPL_RVV_UNPACKS(v_uint8, 8)
-OPENCV_HAL_IMPL_RVV_UNPACKS(v_int8, 8)
-OPENCV_HAL_IMPL_RVV_UNPACKS(v_uint16, 16)
-OPENCV_HAL_IMPL_RVV_UNPACKS(v_int16, 16)
-OPENCV_HAL_IMPL_RVV_UNPACKS(v_uint32, 32)
-OPENCV_HAL_IMPL_RVV_UNPACKS(v_int32, 32)
-OPENCV_HAL_IMPL_RVV_UNPACKS(v_float32, 32)
-#if CV_SIMD_SCALABLE_64F
-OPENCV_HAL_IMPL_RVV_UNPACKS(v_float64, 64)
-#endif
-
-#define OPENCV_HAL_IMPL_RVV_INTERLEAVED(_Tpvec, _Tp, suffix, width, hwidth,    \
-                                        vl)                                    \
-  inline void v_load_deinterleave(const _Tp *ptr, v_##_Tpvec &a,               \
-                                  v_##_Tpvec &b) {                             \
-    a = __riscv_vlse##width##_v_##suffix##m2(ptr, sizeof(_Tp) * 2,             \
-                                             VTraits<v_##_Tpvec>::vlanes());   \
-    b = __riscv_vlse##width##_v_##suffix##m2(ptr + 1, sizeof(_Tp) * 2,         \
-                                             VTraits<v_##_Tpvec>::vlanes());   \
-  }                                                                            \
-  inline void v_load_deinterleave(const _Tp *ptr, v_##_Tpvec &a,               \
-                                  v_##_Tpvec &b, v_##_Tpvec &c) {              \
-    a = __riscv_vlse##width##_v_##suffix##m2(ptr, sizeof(_Tp) * 3,             \
-                                             VTraits<v_##_Tpvec>::vlanes());   \
-    b = __riscv_vlse##width##_v_##suffix##m2(ptr + 1, sizeof(_Tp) * 3,         \
-                                             VTraits<v_##_Tpvec>::vlanes());   \
-    c = __riscv_vlse##width##_v_##suffix##m2(ptr + 2, sizeof(_Tp) * 3,         \
-                                             VTraits<v_##_Tpvec>::vlanes());   \
-  }                                                                            \
-  inline void v_load_deinterleave(const _Tp *ptr, v_##_Tpvec &a,               \
-                                  v_##_Tpvec &b, v_##_Tpvec &c,                \
-                                  v_##_Tpvec &d) {                             \
-                                                                               \
-    a = __riscv_vlse##width##_v_##suffix##m2(ptr, sizeof(_Tp) * 4,             \
-                                             VTraits<v_##_Tpvec>::vlanes());   \
-    b = __riscv_vlse##width##_v_##suffix##m2(ptr + 1, sizeof(_Tp) * 4,         \
-                                             VTraits<v_##_Tpvec>::vlanes());   \
-    c = __riscv_vlse##width##_v_##suffix##m2(ptr + 2, sizeof(_Tp) * 4,         \
-                                             VTraits<v_##_Tpvec>::vlanes());   \
-    d = __riscv_vlse##width##_v_##suffix##m2(ptr + 3, sizeof(_Tp) * 4,         \
-                                             VTraits<v_##_Tpvec>::vlanes());   \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp *ptr, const v_##_Tpvec &a, const v_##_Tpvec &b,                      \
-      hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {                        \
-    __riscv_vsse##width(ptr, sizeof(_Tp) * 2, a,                               \
-                        VTraits<v_##_Tpvec>::vlanes());                        \
-    __riscv_vsse##width(ptr + 1, sizeof(_Tp) * 2, b,                           \
-                        VTraits<v_##_Tpvec>::vlanes());                        \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp *ptr, const v_##_Tpvec &a, const v_##_Tpvec &b, const v_##_Tpvec &c, \
-      hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {                        \
-    __riscv_vsse##width(ptr, sizeof(_Tp) * 3, a,                               \
-                        VTraits<v_##_Tpvec>::vlanes());                        \
-    __riscv_vsse##width(ptr + 1, sizeof(_Tp) * 3, b,                           \
-                        VTraits<v_##_Tpvec>::vlanes());                        \
-    __riscv_vsse##width(ptr + 2, sizeof(_Tp) * 3, c,                           \
-                        VTraits<v_##_Tpvec>::vlanes());                        \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp *ptr, const v_##_Tpvec &a, const v_##_Tpvec &b, const v_##_Tpvec &c, \
-      const v_##_Tpvec &d, hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {   \
-    __riscv_vsse##width(ptr, sizeof(_Tp) * 4, a,                               \
-                        VTraits<v_##_Tpvec>::vlanes());                        \
-    __riscv_vsse##width(ptr + 1, sizeof(_Tp) * 4, b,                           \
-                        VTraits<v_##_Tpvec>::vlanes());                        \
-    __riscv_vsse##width(ptr + 2, sizeof(_Tp) * 4, c,                           \
-                        VTraits<v_##_Tpvec>::vlanes());                        \
-    __riscv_vsse##width(ptr + 3, sizeof(_Tp) * 4, d,                           \
-                        VTraits<v_##_Tpvec>::vlanes());                        \
-  }
-
-OPENCV_HAL_IMPL_RVV_INTERLEAVED(uint8, uchar, u8, 8, 4,
-                                VTraits<v_uint8>::vlanes())
-OPENCV_HAL_IMPL_RVV_INTERLEAVED(int8, schar, i8, 8, 4,
-                                VTraits<v_int8>::vlanes())
-OPENCV_HAL_IMPL_RVV_INTERLEAVED(uint16, ushort, u16, 16, 8,
-                                VTraits<v_uint16>::vlanes())
-OPENCV_HAL_IMPL_RVV_INTERLEAVED(int16, short, i16, 16, 8,
-                                VTraits<v_int16>::vlanes())
-OPENCV_HAL_IMPL_RVV_INTERLEAVED(uint32, unsigned, u32, 32, 16,
-                                VTraits<v_uint32>::vlanes())
-OPENCV_HAL_IMPL_RVV_INTERLEAVED(int32, int, i32, 32, 16,
-                                VTraits<v_int32>::vlanes())
-OPENCV_HAL_IMPL_RVV_INTERLEAVED(float32, float, f32, 32, 16,
-                                VTraits<v_float32>::vlanes())
-OPENCV_HAL_IMPL_RVV_INTERLEAVED(uint64, uint64, u64, 64, 32,
-                                VTraits<v_uint64>::vlanes())
-OPENCV_HAL_IMPL_RVV_INTERLEAVED(int64, int64, i64, 64, 32,
-                                VTraits<v_int64>::vlanes())
-#if CV_SIMD_SCALABLE_64F
-OPENCV_HAL_IMPL_RVV_INTERLEAVED(float64, double, f64, 64, 32,
-                                VTraits<v_float64>::vlanes())
-#endif
-
-static uint64_t idx_interleave_pairs[] = {
-    0x0705060403010200, 0x0f0d0e0c0b090a08, 0x1715161413111210,
-    0x1f1d1e1c1b191a18, 0x2725262423212220, 0x2f2d2e2c2b292a28,
-    0x3735363433313230, 0x3f3d3e3c3b393a38, 0x4745464443414240,
-    0x4f4d4e4c4b494a48, 0x5755565453515250, 0x5f5d5e5c5b595a58,
-    0x6765666463616260, 0x6f6d6e6c6b696a68, 0x7775767473717270,
-    0x7f7d7e7c7b797a78};
-
-static uint64_t idx_interleave_quads[] = {
-    0x0703060205010400, 0x0f0b0e0a0d090c08, 0x1713161215111410,
-    0x1f1b1e1a1d191c18, 0x2723262225212420, 0x2f2b2e2a2d292c28,
-    0x3733363235313430, 0x3f3b3e3a3d393c38, 0x4743464245414440,
-    0x4f4b4e4a4d494c48, 0x5753565255515450, 0x5f5b5e5a5d595c58,
-    0x6763666265616460, 0x6f6b6e6a6d696c68, 0x7773767275717470,
-    0x7f7b7e7a7d797c78};
-
-#define OPENCV_HAL_IMPL_RVV_INTERLEAVED_PQ_NOEXPEND(_Tpvec, func)              \
-  inline _Tpvec v_interleave_##func(const _Tpvec &vec) {                       \
-    CV_CheckLE(                                                                \
-        VTraits<_Tpvec>::vlanes(), VTraits<_Tpvec>::max_nlanes,                \
-        "RVV implementation only supports VLEN in the range [128, 1024]");     \
-    vuint8m2_t vidx = __riscv_vundefined_u8m2();                               \
-    vidx = __riscv_vreinterpret_u8m2(                                          \
-        __riscv_vle64_v_u64m2(idx_interleave_##func, 16));                     \
-    return __riscv_vrgather(vec, vidx, VTraits<v_uint8>::vlanes());            \
-  }
-OPENCV_HAL_IMPL_RVV_INTERLEAVED_PQ_NOEXPEND(v_uint8, pairs)
-OPENCV_HAL_IMPL_RVV_INTERLEAVED_PQ_NOEXPEND(v_int8, pairs)
-OPENCV_HAL_IMPL_RVV_INTERLEAVED_PQ_NOEXPEND(v_uint8, quads)
-OPENCV_HAL_IMPL_RVV_INTERLEAVED_PQ_NOEXPEND(v_int8, quads)
-
-#define OPENCV_HAL_IMPL_RVV_INTERLEAVED_PQ(_Tpvec, width, vzext_vfx, func)     \
-  inline _Tpvec v_interleave_##func(const _Tpvec &vec) {                       \
-    CV_CheckLE(                                                                \
-        VTraits<_Tpvec>::vlanes(), VTraits<_Tpvec>::max_nlanes,                \
-        "RVV implementation only supports VLEN in the range [128, 1024]");     \
-    vuint##width##m2_t vidx = __riscv_vundefined_u##width##m2();               \
-    vidx = __riscv_vget_u##width##m2(                                          \
-        vzext_vfx(__riscv_vreinterpret_u8m2(                                   \
-                      __riscv_vle64_v_u64m2(idx_interleave_##func, 16)),       \
-                  VTraits<v_uint8>::vlanes()),                                 \
-        0);                                                                    \
-    return __riscv_vrgather(vec, vidx, VTraits<_Tpvec>::vlanes());             \
-  }
-
-OPENCV_HAL_IMPL_RVV_INTERLEAVED_PQ(v_uint16, 16, __riscv_vzext_vf2, pairs)
-OPENCV_HAL_IMPL_RVV_INTERLEAVED_PQ(v_int16, 16, __riscv_vzext_vf2, pairs)
-OPENCV_HAL_IMPL_RVV_INTERLEAVED_PQ(v_uint32, 32, __riscv_vzext_vf4, pairs)
-OPENCV_HAL_IMPL_RVV_INTERLEAVED_PQ(v_int32, 32, __riscv_vzext_vf4, pairs)
-OPENCV_HAL_IMPL_RVV_INTERLEAVED_PQ(v_float32, 32, __riscv_vzext_vf4, pairs)
-
-OPENCV_HAL_IMPL_RVV_INTERLEAVED_PQ(v_uint16, 16, __riscv_vzext_vf2, quads)
-OPENCV_HAL_IMPL_RVV_INTERLEAVED_PQ(v_int16, 16, __riscv_vzext_vf2, quads)
-OPENCV_HAL_IMPL_RVV_INTERLEAVED_PQ(v_uint32, 32, __riscv_vzext_vf4, quads)
-OPENCV_HAL_IMPL_RVV_INTERLEAVED_PQ(v_int32, 32, __riscv_vzext_vf4, quads)
-OPENCV_HAL_IMPL_RVV_INTERLEAVED_PQ(v_float32, 32, __riscv_vzext_vf4, quads)
-
-//////////// PopCount //////////
-static const unsigned char popCountTable[256] = {
-    0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4,
-    2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4,
-    2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6,
-    4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5,
-    3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6,
-    4, 5, 5, 6, 5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-    4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,
-};
-#define OPENCV_HAL_IMPL_RVV_HADD(_Tpvec, _Tpvec2, _Tm2, width, width2, suffix, \
-                                 add)                                          \
-  static inline _Tpvec2 v_hadd(_Tpvec a) {                                     \
-    vuint##width2##m2_t oneX2 =                                                \
-        __riscv_vmv_v_x_u##width2##m2(1, VTraits<v_uint##width2>::vlanes());   \
-    vuint##width##m2_t one = __riscv_vreinterpret_u##width##m2(oneX2);         \
-    _Tm2 res =                                                                 \
-        add(a, __riscv_vslide1down(a, 0, VTraits<v_uint##width>::vlanes()),    \
-            VTraits<v_uint##width>::vlanes());                                 \
-    return __riscv_vget_##suffix##m2(                                          \
-        __riscv_vcompress(                                                     \
-            res, __riscv_vmseq(one, 1, VTraits<v_uint##width>::vlanes()),      \
-            VTraits<v_uint##width>::vlanes()),                                 \
-        0);                                                                    \
-  }
-OPENCV_HAL_IMPL_RVV_HADD(v_uint8, v_uint16, vuint16m4_t, 8, 16, u16,
-                         __riscv_vwaddu_vv)
-OPENCV_HAL_IMPL_RVV_HADD(v_uint16, v_uint32, vuint32m4_t, 16, 32, u32,
-                         __riscv_vwaddu_vv)
-OPENCV_HAL_IMPL_RVV_HADD(v_uint32, v_uint64, vuint64m4_t, 32, 64, u64,
-                         __riscv_vwaddu_vv)
-OPENCV_HAL_IMPL_RVV_HADD(v_int8, v_int16, vint16m4_t, 8, 16, i16,
-                         __riscv_vwadd_vv)
-OPENCV_HAL_IMPL_RVV_HADD(v_int16, v_int32, vint32m4_t, 16, 32, i32,
-                         __riscv_vwadd_vv)
-OPENCV_HAL_IMPL_RVV_HADD(v_int32, v_int64, vint64m4_t, 32, 64, i64,
-                         __riscv_vwadd_vv)
-
-OPENCV_HAL_IMPL_RVV_HADD(vint32m4_t, v_int32, vint32m4_t, 16, 32, i32,
-                         __riscv_vadd)
-OPENCV_HAL_IMPL_RVV_HADD(vint64m4_t, v_int64, vint64m4_t, 32, 64, i64,
-                         __riscv_vadd)
-
-inline v_uint8 v_popcount(const v_uint8 &a) {
-  return __riscv_vloxei8(popCountTable, a, VTraits<v_uint8>::vlanes());
-}
-inline v_uint16 v_popcount(const v_uint16 &a) {
-  return v_hadd(v_popcount(__riscv_vreinterpret_u8m2(a)));
-}
-inline v_uint32 v_popcount(const v_uint32 &a) {
-  return v_hadd(v_hadd(v_popcount(__riscv_vreinterpret_u8m2(a))));
-}
-inline v_uint64 v_popcount(const v_uint64 &a) {
-  return v_hadd(v_hadd(v_hadd(v_popcount(__riscv_vreinterpret_u8m2(a)))));
-}
-
-inline v_uint8 v_popcount(const v_int8 &a) { return v_popcount(v_abs(a)); }
-inline v_uint16 v_popcount(const v_int16 &a) { return v_popcount(v_abs(a)); }
-inline v_uint32 v_popcount(const v_int32 &a) { return v_popcount(v_abs(a)); }
-inline v_uint64 v_popcount(const v_int64 &a) {
-  // max(0 - a) is used, since v_abs does not support 64-bit integers.
-  return v_popcount(v_reinterpret_as_u64(
-      __riscv_vmax(a, v_sub(v_setzero_s64(), a), VTraits<v_int64>::vlanes())));
-}
-
-//////////// SignMask ////////////
-#define OPENCV_HAL_IMPL_RVV_SIGNMASK_OP(_Tpvec)                                \
-  inline int v_signmask(const _Tpvec &a) {                                     \
-    uint8_t ans[4] = {0};                                                      \
-    __riscv_vsm(ans, __riscv_vmslt(a, 0, VTraits<_Tpvec>::vlanes()),           \
-                VTraits<_Tpvec>::vlanes());                                    \
-    return *(reinterpret_cast<int *>(ans)) &                                   \
-           (((__int128_t)1 << VTraits<_Tpvec>::vlanes()) - 1);                 \
-  }                                                                            \
-  inline int v_scan_forward(const _Tpvec &a) {                                 \
-    return (int)__riscv_vfirst(__riscv_vmslt(a, 0, VTraits<_Tpvec>::vlanes()), \
-                               VTraits<_Tpvec>::vlanes());                     \
-  }
-
-OPENCV_HAL_IMPL_RVV_SIGNMASK_OP(v_int8)
-OPENCV_HAL_IMPL_RVV_SIGNMASK_OP(v_int16)
-OPENCV_HAL_IMPL_RVV_SIGNMASK_OP(v_int32)
-OPENCV_HAL_IMPL_RVV_SIGNMASK_OP(v_int64)
-
-inline int64 v_signmask(const v_uint8 &a) {
-  return v_signmask(v_reinterpret_as_s8(a));
-}
-inline int64 v_signmask(const v_uint16 &a) {
-  return v_signmask(v_reinterpret_as_s16(a));
-}
-inline int v_signmask(const v_uint32 &a) {
-  return v_signmask(v_reinterpret_as_s32(a));
-}
-inline int v_signmask(const v_float32 &a) {
-  return v_signmask(v_reinterpret_as_s32(a));
-}
-inline int v_signmask(const v_uint64 &a) {
-  return v_signmask(v_reinterpret_as_s64(a));
-}
-#if CV_SIMD_SCALABLE_64F
-inline int v_signmask(const v_float64 &a) {
-  return v_signmask(v_reinterpret_as_s64(a));
-}
-#endif
-
-//////////// Scan forward ////////////
-inline int v_scan_forward(const v_uint8 &a) {
-  return v_scan_forward(v_reinterpret_as_s8(a));
-}
-inline int v_scan_forward(const v_uint16 &a) {
-  return v_scan_forward(v_reinterpret_as_s16(a));
-}
-inline int v_scan_forward(const v_uint32 &a) {
-  return v_scan_forward(v_reinterpret_as_s32(a));
-}
-inline int v_scan_forward(const v_float32 &a) {
-  return v_scan_forward(v_reinterpret_as_s32(a));
-}
-inline int v_scan_forward(const v_uint64 &a) {
-  return v_scan_forward(v_reinterpret_as_s64(a));
-}
-#if CV_SIMD_SCALABLE_64F
-inline int v_scan_forward(const v_float64 &a) {
-  return v_scan_forward(v_reinterpret_as_s64(a));
-}
-#endif
-
-//////////// Pack triplets ////////////
-// {A0, A1, A2, A3, B0, B1, B2, B3, C0 ...} --> {A0, A1, A2, B0, B1, B2, C0 ...}
-// mask: {0,0,0,1, ...} -> {T,T,T,F, ...}
-#define OPENCV_HAL_IMPL_RVV_PACK_TRIPLETS(_Tpvec, v_trunc)                     \
-  inline _Tpvec v_pack_triplets(const _Tpvec &vec) {                           \
-    size_t vl = VTraits<v_uint8>::vlanes();                                    \
-    vuint32m2_t one = __riscv_vmv_v_x_u32m2(1, VTraits<v_uint32>::vlanes());   \
-    vuint8m2_t zero = __riscv_vmv_v_x_u8m2(0, vl);                             \
-    vuint8m2_t mask = __riscv_vreinterpret_u8m2(one);                          \
-    return __riscv_vcompress(                                                  \
-        vec,                                                                   \
-        __riscv_vmseq(v_trunc(__riscv_vslideup(zero, mask, 3, vl)), 0, vl),    \
-        VTraits<_Tpvec>::vlanes());                                            \
-  }
-
-OPENCV_HAL_IMPL_RVV_PACK_TRIPLETS(v_uint8, OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_RVV_PACK_TRIPLETS(v_int8, OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_RVV_PACK_TRIPLETS(v_uint16, __riscv_vlmul_trunc_u8m1)
-OPENCV_HAL_IMPL_RVV_PACK_TRIPLETS(v_int16, __riscv_vlmul_trunc_u8m1)
-OPENCV_HAL_IMPL_RVV_PACK_TRIPLETS(v_uint32, __riscv_vlmul_trunc_u8mf2)
-OPENCV_HAL_IMPL_RVV_PACK_TRIPLETS(v_int32, __riscv_vlmul_trunc_u8mf2)
-OPENCV_HAL_IMPL_RVV_PACK_TRIPLETS(v_float32, __riscv_vlmul_trunc_u8mf2)
-OPENCV_HAL_IMPL_RVV_PACK_TRIPLETS(v_uint64, __riscv_vlmul_trunc_u8mf4)
-OPENCV_HAL_IMPL_RVV_PACK_TRIPLETS(v_int64, __riscv_vlmul_trunc_u8mf4)
-#if CV_SIMD_SCALABLE_64F
-OPENCV_HAL_IMPL_RVV_PACK_TRIPLETS(v_float64, __riscv_vlmul_trunc_u8mf4)
-#endif
-
-////// FP16 support ///////
-
-#if defined(__riscv_zfh) && __riscv_zfh
-inline v_float32 v_load_expand(const hfloat *ptr) {
-  return __riscv_vfwcvt_f(
-      __riscv_vle16_v_f16m1((_Float16 *)ptr, VTraits<v_float32>::vlanes()),
-      VTraits<v_float32>::vlanes());
-  ;
-}
-
-inline void v_pack_store(hfloat *ptr, const v_float32 &v) {
-  __riscv_vse16_v_f16m1(
-      (_Float16 *)ptr,
-      __riscv_vfncvt_f_f_w_f16m1(v, VTraits<v_float32>::vlanes()),
-      VTraits<v_float32>::vlanes());
-}
-#else
-inline v_float32 v_load_expand(const hfloat *ptr) {
-  float buf[32];
-  for (int i = 0; i < VTraits<v_float32>::vlanes(); i++)
-    buf[i] = (float)ptr[i];
-  return v_load(buf);
-}
-
-inline void v_pack_store(hfloat *ptr, const v_float32 &v) {
-  float buf[32];
-  v_store(buf, v);
-  for (int i = 0; i < VTraits<v_float32>::vlanes(); i++)
-    ptr[i] = hfloat(buf[i]);
-}
-#endif
-////////////// Rounding //////////////
-inline v_int32 v_round(const v_float32 &a) {
-  // return vfcvt_x(vfadd(a, 1e-6, VTraits<v_float32>::vlanes()),
-  // VTraits<v_float32>::vlanes());
-  return __riscv_vfcvt_x(a, VTraits<v_float32>::vlanes());
-}
-
-inline v_int32 v_floor(const v_float32 &a) {
-  return __riscv_vfcvt_x(
-      __riscv_vfsub(a, 0.5f - 1e-5, VTraits<v_float32>::vlanes()),
-      VTraits<v_float32>::vlanes());
-  // return vfcvt_x(a, VTraits<v_float32>::vlanes());
-}
-
-inline v_int32 v_ceil(const v_float32 &a) {
-  return __riscv_vfcvt_x(
-      __riscv_vfadd(a, 0.5f - 1e-5, VTraits<v_float32>::vlanes()),
-      VTraits<v_float32>::vlanes());
-}
-
-inline v_int32 v_trunc(const v_float32 &a) {
-  return __riscv_vfcvt_rtz_x(a, VTraits<v_float32>::vlanes());
-}
-#if CV_SIMD_SCALABLE_64F
-inline v_int32 v_round(const v_float64 &a) {
-  return __riscv_vfncvt_x(__riscv_vlmul_ext_f64m4(a),
-                          VTraits<v_float32>::vlanes());
-}
-
-inline v_int32 v_round(const v_float64 &a, const v_float64 &b) {
-  // return vfncvt_x(vset(vlmul_ext_f64m2(vfadd(a, 1e-6,
-  // VTraits<v_float64>::vlanes())), 1, b), VTraits<v_float32>::vlanes()); Fix
-  // https://github.com/opencv/opencv/issues/24746
-  return __riscv_vfncvt_x(__riscv_vset(__riscv_vlmul_ext_f64m4(a), 1, b),
-                          VTraits<v_float32>::vlanes());
-}
-
-inline v_int32 v_floor(const v_float64 &a) {
-  return __riscv_vfncvt_x(__riscv_vlmul_ext_f64m4(__riscv_vfsub(
-                              a, 0.5f - 1e-6, VTraits<v_float64>::vlanes())),
-                          VTraits<v_float32>::vlanes());
-}
-
-inline v_int32 v_ceil(const v_float64 &a) {
-  return __riscv_vfncvt_x(__riscv_vlmul_ext_f64m4(__riscv_vfadd(
-                              a, 0.5f - 1e-6, VTraits<v_float64>::vlanes())),
-                          VTraits<v_float32>::vlanes());
-}
-
-inline v_int32 v_trunc(const v_float64 &a) {
-  return __riscv_vfncvt_rtz_x(__riscv_vlmul_ext_f64m4(a),
-                              VTraits<v_float32>::vlanes());
-}
-#endif
-
-//////// Dot Product ////////
-
-// 16 >> 32
-inline v_int32 v_dotprod(const v_int16 &a, const v_int16 &b) {
-  vint32m4_t temp1 = __riscv_vwmul(a, b, VTraits<v_int16>::vlanes());
-  return v_hadd(temp1);
-}
-
-inline v_int32 v_dotprod(const v_int16 &a, const v_int16 &b, const v_int32 &c) {
-  vint32m4_t temp1 = __riscv_vwmul(a, b, VTraits<v_int16>::vlanes());
-  return __riscv_vadd(v_hadd(temp1), c, VTraits<v_int32>::vlanes());
-}
-
-// 32 >> 64
-inline v_int64 v_dotprod(const v_int32 &a, const v_int32 &b) {
-  vuint64m2_t one64 = __riscv_vmv_v_x_u64m2(1, VTraits<v_uint64>::vlanes());
-  vuint32m2_t one32 = __riscv_vreinterpret_u32m2(one64);
-  vbool16_t mask = __riscv_vmseq(one32, 1, VTraits<v_uint32>::vlanes());
-  vint64m4_t temp1 = __riscv_vwmul(a, b, VTraits<v_int32>::vlanes());
-  vint64m4_t temp2 = __riscv_vslide1down(temp1, 0, VTraits<v_int32>::vlanes());
-  vint64m4_t res = __riscv_vadd(temp1, temp2, VTraits<v_int32>::vlanes());
-  res = __riscv_vcompress(res, mask, VTraits<v_int32>::vlanes());
-  return __riscv_vlmul_trunc_i64m2(res);
-}
-inline v_int64 v_dotprod(const v_int32 &a, const v_int32 &b, const v_int64 &c) {
-  vuint64m2_t one64 = __riscv_vmv_v_x_u64m2(1, VTraits<v_uint64>::vlanes());
-  vuint32m2_t one32 = __riscv_vreinterpret_u32m2(one64);
-  vbool16_t mask = __riscv_vmseq(one32, 1, VTraits<v_uint32>::vlanes());
-  vint64m4_t temp1 = __riscv_vwmul(a, b, VTraits<v_int32>::vlanes());
-  vint64m4_t temp2 = __riscv_vslide1down(temp1, 0, VTraits<v_int32>::vlanes());
-  vint64m4_t res = __riscv_vadd(temp1, temp2, VTraits<v_int32>::vlanes());
-  res = __riscv_vcompress(res, mask, VTraits<v_int32>::vlanes());
-  return __riscv_vadd(__riscv_vlmul_trunc_i64m2(res), c,
-                      VTraits<v_int64>::vlanes());
-}
-
-// 8 >> 32
-inline v_uint32 v_dotprod_expand(const v_uint8 &a, const v_uint8 &b) {
-  vuint32m2_t one32 = __riscv_vmv_v_x_u32m2(1, VTraits<v_uint32>::vlanes());
-  vuint8m2_t one8 = __riscv_vreinterpret_u8m2(one32);
-  vbool4_t mask = __riscv_vmseq(one8, 1, VTraits<v_uint8>::vlanes());
-  vuint16m4_t t0 = __riscv_vwmulu(a, b, VTraits<v_uint8>::vlanes());
-  vuint16m4_t t1 = __riscv_vslide1down(t0, 0, VTraits<v_uint8>::vlanes());
-  vuint16m4_t t2 = __riscv_vslide1down(t1, 0, VTraits<v_uint8>::vlanes());
-  vuint16m4_t t3 = __riscv_vslide1down(t2, 0, VTraits<v_uint8>::vlanes());
-  vuint32m8_t res =
-      __riscv_vadd(__riscv_vwaddu_vv(t2, t3, VTraits<v_uint8>::vlanes()),
-                   __riscv_vwaddu_vv(t0, t1, VTraits<v_uint8>::vlanes()),
-                   VTraits<v_uint8>::vlanes());
-  res = __riscv_vcompress(res, mask, VTraits<v_uint8>::vlanes());
-  return __riscv_vlmul_trunc_u32m2(res);
-}
-
-inline v_uint32 v_dotprod_expand(const v_uint8 &a, const v_uint8 &b,
-                                 const v_uint32 &c) {
-  vuint32m2_t one32 = __riscv_vmv_v_x_u32m2(1, VTraits<v_uint32>::vlanes());
-  vuint8m2_t one8 = __riscv_vreinterpret_u8m2(one32);
-  vbool4_t mask = __riscv_vmseq(one8, 1, VTraits<v_uint8>::vlanes());
-  vuint16m4_t t0 = __riscv_vwmulu(a, b, VTraits<v_uint8>::vlanes());
-  vuint16m4_t t1 = __riscv_vslide1down(t0, 0, VTraits<v_uint8>::vlanes());
-  vuint16m4_t t2 = __riscv_vslide1down(t1, 0, VTraits<v_uint8>::vlanes());
-  vuint16m4_t t3 = __riscv_vslide1down(t2, 0, VTraits<v_uint8>::vlanes());
-  vuint32m8_t res =
-      __riscv_vadd(__riscv_vwaddu_vv(t2, t3, VTraits<v_uint8>::vlanes()),
-                   __riscv_vwaddu_vv(t0, t1, VTraits<v_uint8>::vlanes()),
-                   VTraits<v_uint8>::vlanes());
-  res = __riscv_vcompress(res, mask, VTraits<v_uint8>::vlanes());
-  return __riscv_vadd(__riscv_vlmul_trunc_u32m2(res), c,
-                      VTraits<v_uint8>::vlanes());
-}
-
-inline v_int32 v_dotprod_expand(const v_int8 &a, const v_int8 &b) {
-  vuint32m2_t one32 = __riscv_vmv_v_x_u32m2(1, VTraits<v_uint32>::vlanes());
-  vuint8m2_t one8 = __riscv_vreinterpret_u8m2(one32);
-  vbool4_t mask = __riscv_vmseq(one8, 1, VTraits<v_uint8>::vlanes());
-  vint16m4_t t0 = __riscv_vwmul(a, b, VTraits<v_int8>::vlanes());
-  vint16m4_t t1 = __riscv_vslide1down(t0, 0, VTraits<v_int8>::vlanes());
-  vint16m4_t t2 = __riscv_vslide1down(t1, 0, VTraits<v_int8>::vlanes());
-  vint16m4_t t3 = __riscv_vslide1down(t2, 0, VTraits<v_int8>::vlanes());
-  vint32m8_t res =
-      __riscv_vadd(__riscv_vwadd_vv(t2, t3, VTraits<v_int8>::vlanes()),
-                   __riscv_vwadd_vv(t0, t1, VTraits<v_int8>::vlanes()),
-                   VTraits<v_int8>::vlanes());
-  res = __riscv_vcompress(res, mask, VTraits<v_int8>::vlanes());
-  return __riscv_vlmul_trunc_i32m2(res);
-}
-
-inline v_int32 v_dotprod_expand(const v_int8 &a, const v_int8 &b,
-                                const v_int32 &c) {
-  vuint32m2_t one32 = __riscv_vmv_v_x_u32m2(1, VTraits<v_uint32>::vlanes());
-  vuint8m2_t one8 = __riscv_vreinterpret_u8m2(one32);
-  vbool4_t mask = __riscv_vmseq(one8, 1, VTraits<v_uint8>::vlanes());
-  vint16m4_t t0 = __riscv_vwmul(a, b, VTraits<v_int8>::vlanes());
-  vint16m4_t t1 = __riscv_vslide1down(t0, 0, VTraits<v_int8>::vlanes());
-  vint16m4_t t2 = __riscv_vslide1down(t1, 0, VTraits<v_int8>::vlanes());
-  vint16m4_t t3 = __riscv_vslide1down(t2, 0, VTraits<v_int8>::vlanes());
-  vint32m8_t res =
-      __riscv_vadd(__riscv_vwadd_vv(t2, t3, VTraits<v_int8>::vlanes()),
-                   __riscv_vwadd_vv(t0, t1, VTraits<v_int8>::vlanes()),
-                   VTraits<v_int8>::vlanes());
-  res = __riscv_vcompress(res, mask, VTraits<v_int8>::vlanes());
-  return __riscv_vadd(__riscv_vlmul_trunc_i32m2(res), c,
-                      VTraits<v_int8>::vlanes());
-}
-
-// // 16 >> 64
-inline v_uint64 v_dotprod_expand(const v_uint16 &a, const v_uint16 &b) {
-  vuint64m2_t one64 = __riscv_vmv_v_x_u64m2(1, VTraits<v_uint64>::vlanes());
-  vuint16m2_t one16 = __riscv_vreinterpret_u16m2(one64);
-  vbool8_t mask = __riscv_vmseq(one16, 1, VTraits<v_uint16>::vlanes());
-  vuint32m4_t t0 = __riscv_vwmulu(a, b, VTraits<v_uint16>::vlanes());
-  vuint32m4_t t1 = __riscv_vslide1down(t0, 0, VTraits<v_uint16>::vlanes());
-  vuint32m4_t t2 = __riscv_vslide1down(t1, 0, VTraits<v_uint16>::vlanes());
-  vuint32m4_t t3 = __riscv_vslide1down(t2, 0, VTraits<v_uint16>::vlanes());
-  vuint64m8_t res =
-      __riscv_vadd(__riscv_vwaddu_vv(t2, t3, VTraits<v_uint16>::vlanes()),
-                   __riscv_vwaddu_vv(t0, t1, VTraits<v_uint16>::vlanes()),
-                   VTraits<v_uint16>::vlanes());
-  res = __riscv_vcompress(res, mask, VTraits<v_uint16>::vlanes());
-  return __riscv_vlmul_trunc_u64m2(res);
-}
-inline v_uint64 v_dotprod_expand(const v_uint16 &a, const v_uint16 &b,
-                                 const v_uint64 &c) {
-  vuint64m2_t one64 = __riscv_vmv_v_x_u64m2(1, VTraits<v_uint64>::vlanes());
-  vuint16m2_t one16 = __riscv_vreinterpret_u16m2(one64);
-  vbool8_t mask = __riscv_vmseq(one16, 1, VTraits<v_uint16>::vlanes());
-  vuint32m4_t t0 = __riscv_vwmulu(a, b, VTraits<v_uint16>::vlanes());
-  vuint32m4_t t1 = __riscv_vslide1down(t0, 0, VTraits<v_uint16>::vlanes());
-  vuint32m4_t t2 = __riscv_vslide1down(t1, 0, VTraits<v_uint16>::vlanes());
-  vuint32m4_t t3 = __riscv_vslide1down(t2, 0, VTraits<v_uint16>::vlanes());
-  vuint64m8_t res =
-      __riscv_vadd(__riscv_vwaddu_vv(t2, t3, VTraits<v_uint16>::vlanes()),
-                   __riscv_vwaddu_vv(t0, t1, VTraits<v_uint16>::vlanes()),
-                   VTraits<v_uint16>::vlanes());
-  res = __riscv_vcompress(res, mask, VTraits<v_uint16>::vlanes());
-  return __riscv_vadd(__riscv_vlmul_trunc_u64m2(res), c,
-                      VTraits<v_uint16>::vlanes());
-}
-
-inline v_int64 v_dotprod_expand(const v_int16 &a, const v_int16 &b) {
-  vuint64m2_t one64 = __riscv_vmv_v_x_u64m2(1, VTraits<v_uint64>::vlanes());
-  vuint16m2_t one16 = __riscv_vreinterpret_u16m2(one64);
-  vbool8_t mask = __riscv_vmseq(one16, 1, VTraits<v_uint16>::vlanes());
-  vint32m4_t t0 = __riscv_vwmul(a, b, VTraits<v_int16>::vlanes());
-  vint32m4_t t1 = __riscv_vslide1down(t0, 0, VTraits<v_int16>::vlanes());
-  vint32m4_t t2 = __riscv_vslide1down(t1, 0, VTraits<v_int16>::vlanes());
-  vint32m4_t t3 = __riscv_vslide1down(t2, 0, VTraits<v_int16>::vlanes());
-  vint64m8_t res =
-      __riscv_vadd(__riscv_vwadd_vv(t2, t3, VTraits<v_int16>::vlanes()),
-                   __riscv_vwadd_vv(t0, t1, VTraits<v_int16>::vlanes()),
-                   VTraits<v_int16>::vlanes());
-  res = __riscv_vcompress(res, mask, VTraits<v_int16>::vlanes());
-  return __riscv_vlmul_trunc_i64m2(res);
-}
-inline v_int64 v_dotprod_expand(const v_int16 &a, const v_int16 &b,
-                                const v_int64 &c) {
-  vuint64m2_t one64 = __riscv_vmv_v_x_u64m2(1, VTraits<v_uint64>::vlanes());
-  vuint16m2_t one16 = __riscv_vreinterpret_u16m2(one64);
-  vbool8_t mask = __riscv_vmseq(one16, 1, VTraits<v_uint16>::vlanes());
-  vint32m4_t t0 = __riscv_vwmul(a, b, VTraits<v_int16>::vlanes());
-  vint32m4_t t1 = __riscv_vslide1down(t0, 0, VTraits<v_int16>::vlanes());
-  vint32m4_t t2 = __riscv_vslide1down(t1, 0, VTraits<v_int16>::vlanes());
-  vint32m4_t t3 = __riscv_vslide1down(t2, 0, VTraits<v_int16>::vlanes());
-  vint64m8_t res =
-      __riscv_vadd(__riscv_vwadd_vv(t2, t3, VTraits<v_int16>::vlanes()),
-                   __riscv_vwadd_vv(t0, t1, VTraits<v_int16>::vlanes()),
-                   VTraits<v_int16>::vlanes());
-  res = __riscv_vcompress(res, mask, VTraits<v_int16>::vlanes());
-  return __riscv_vadd(__riscv_vlmul_trunc_i64m2(res), c,
-                      VTraits<v_int16>::vlanes());
-}
-
-// // 32 >> 64f
-#if CV_SIMD_SCALABLE_64F
-inline v_float64 v_dotprod_expand(const v_int32 &a, const v_int32 &b) {
-  return v_cvt_f64(v_dotprod(a, b));
-}
-inline v_float64 v_dotprod_expand(const v_int32 &a, const v_int32 &b,
-                                  const v_float64 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-#endif
-
-//////// Fast Dot Product ////////
-// 16 >> 32
-inline v_int32 v_dotprod_fast(const v_int16 &a, const v_int16 &b) {
-  vint32m1_t zero = __riscv_vmv_v_x_i32m1(0, VTraits<vint32m1_t>::vlanes());
-  return __riscv_vset(
-      __riscv_vmv_v_x_i32m2(0, VTraits<v_int32>::vlanes()), 0,
-      __riscv_vredsum_tu(zero, __riscv_vwmul(a, b, VTraits<v_int16>::vlanes()),
-                         zero, VTraits<v_int16>::vlanes()));
-}
-inline v_int32 v_dotprod_fast(const v_int16 &a, const v_int16 &b,
-                              const v_int32 &c) {
-  vint32m1_t zero = __riscv_vmv_v_x_i32m1(0, VTraits<vint32m1_t>::vlanes());
-  return __riscv_vadd(
-      c,
-      __riscv_vset(__riscv_vmv_v_x_i32m2(0, VTraits<v_int32>::vlanes()), 0,
-                   __riscv_vredsum_tu(
-                       zero, __riscv_vwmul(a, b, VTraits<v_int16>::vlanes()),
-                       zero, VTraits<v_int16>::vlanes())),
-      VTraits<v_int32>::vlanes());
-}
-
-// 32 >> 64
-inline v_int64 v_dotprod_fast(const v_int32 &a, const v_int32 &b) {
-  vint64m1_t zero = __riscv_vmv_v_x_i64m1(0, VTraits<vint64m1_t>::vlanes());
-  return __riscv_vset(
-      __riscv_vmv_v_x_i64m2(0, VTraits<v_int64>::vlanes()), 0,
-      __riscv_vredsum_tu(zero, __riscv_vwmul(a, b, VTraits<v_int32>::vlanes()),
-                         zero, VTraits<v_int32>::vlanes()));
-}
-inline v_int64 v_dotprod_fast(const v_int32 &a, const v_int32 &b,
-                              const v_int64 &c) {
-  vint64m1_t zero = __riscv_vmv_v_x_i64m1(0, VTraits<vint64m1_t>::vlanes());
-  return __riscv_vadd(
-      c,
-      __riscv_vset(__riscv_vmv_v_x_i64m2(0, VTraits<v_int64>::vlanes()), 0,
-                   __riscv_vredsum_tu(
-                       zero, __riscv_vwmul(a, b, VTraits<v_int32>::vlanes()),
-                       zero, VTraits<v_int32>::vlanes())),
-      VTraits<v_int64>::vlanes());
-}
-
-// 8 >> 32
-inline v_uint32 v_dotprod_expand_fast(const v_uint8 &a, const v_uint8 &b) {
-  vuint32m1_t zero = __riscv_vmv_v_x_u32m1(0, VTraits<vuint32m1_t>::vlanes());
-  auto res = __riscv_vwredsumu_tu(
-      zero, __riscv_vwmulu(a, b, VTraits<v_uint8>::vlanes()), zero,
-      VTraits<v_uint8>::vlanes());
-  return __riscv_vset(__riscv_vmv_v_x_u32m2(0, VTraits<v_uint32>::vlanes()), 0,
-                      res);
-}
-inline v_uint32 v_dotprod_expand_fast(const v_uint8 &a, const v_uint8 &b,
-                                      const v_uint32 &c) {
-  vuint32m1_t zero = __riscv_vmv_v_x_u32m1(0, VTraits<vuint32m1_t>::vlanes());
-  auto res = __riscv_vwredsumu_tu(
-      zero, __riscv_vwmulu(a, b, VTraits<v_uint8>::vlanes()), zero,
-      VTraits<v_uint8>::vlanes());
-  return __riscv_vadd(
-      c,
-      __riscv_vset(__riscv_vmv_v_x_u32m2(0, VTraits<v_uint32>::vlanes()), 0,
-                   res),
-      VTraits<v_uint32>::vlanes());
-}
-inline v_int32 v_dotprod_expand_fast(const v_int8 &a, const v_int8 &b) {
-  vint32m1_t zero = __riscv_vmv_v_x_i32m1(0, VTraits<vint32m1_t>::vlanes());
-  return __riscv_vset(
-      __riscv_vmv_v_x_i32m2(0, VTraits<v_uint32>::vlanes()), 0,
-      __riscv_vwredsum_tu(zero, __riscv_vwmul(a, b, VTraits<v_int8>::vlanes()),
-                          zero, VTraits<v_int8>::vlanes()));
-}
-inline v_int32 v_dotprod_expand_fast(const v_int8 &a, const v_int8 &b,
-                                     const v_int32 &c) {
-  vint32m1_t zero = __riscv_vmv_v_x_i32m1(0, VTraits<vint32m1_t>::vlanes());
-  return __riscv_vadd(
-      c,
-      __riscv_vset(__riscv_vmv_v_x_i32m2(0, VTraits<v_uint32>::vlanes()), 0,
-                   __riscv_vwredsum_tu(
-                       zero, __riscv_vwmul(a, b, VTraits<v_int8>::vlanes()),
-                       zero, VTraits<v_int8>::vlanes())),
-      VTraits<v_int32>::vlanes());
-}
-
-// 16 >> 64
-inline v_uint64 v_dotprod_expand_fast(const v_uint16 &a, const v_uint16 &b) {
-  vuint64m1_t zero = __riscv_vmv_v_x_u64m1(0, VTraits<vuint64m1_t>::vlanes());
-  return __riscv_vset(
-      __riscv_vmv_v_x_u64m2(0, VTraits<v_uint64>::vlanes()), 0,
-      __riscv_vwredsumu_tu(zero,
-                           __riscv_vwmulu(a, b, VTraits<v_uint16>::vlanes()),
-                           zero, VTraits<v_uint16>::vlanes()));
-}
-inline v_uint64 v_dotprod_expand_fast(const v_uint16 &a, const v_uint16 &b,
-                                      const v_uint64 &c) {
-  vuint64m1_t zero = __riscv_vmv_v_x_u64m1(0, VTraits<vuint64m1_t>::vlanes());
-  return __riscv_vadd(
-      c,
-      __riscv_vset(__riscv_vmv_v_x_u64m2(0, VTraits<v_uint64>::vlanes()), 0,
-                   __riscv_vwredsumu_tu(
-                       zero, __riscv_vwmulu(a, b, VTraits<v_uint16>::vlanes()),
-                       zero, VTraits<v_uint16>::vlanes())),
-      VTraits<v_uint64>::vlanes());
-}
-inline v_int64 v_dotprod_expand_fast(const v_int16 &a, const v_int16 &b) {
-  vint64m1_t zero = __riscv_vmv_v_x_i64m1(0, VTraits<vint64m1_t>::vlanes());
-  return __riscv_vset(
-      __riscv_vmv_v_x_i64m2(0, VTraits<v_int64>::vlanes()), 0,
-      __riscv_vwredsum_tu(zero, __riscv_vwmul(a, b, VTraits<v_int16>::vlanes()),
-                          zero, VTraits<v_int16>::vlanes()));
-}
-inline v_int64 v_dotprod_expand_fast(const v_int16 &a, const v_int16 &b,
-                                     const v_int64 &c) {
-  vint64m1_t zero = __riscv_vmv_v_x_i64m1(0, VTraits<vint64m1_t>::vlanes());
-  return __riscv_vadd(
-      c,
-      __riscv_vset(__riscv_vmv_v_x_i64m2(0, VTraits<v_int64>::vlanes()), 0,
-                   __riscv_vwredsum_tu(
-                       zero, __riscv_vwmul(a, b, VTraits<v_int16>::vlanes()),
-                       zero, VTraits<v_int16>::vlanes())),
-      VTraits<v_int64>::vlanes());
-}
-
-// 32 >> 64f
-#if CV_SIMD_SCALABLE_64F
-inline v_float64 v_dotprod_expand_fast(const v_int32 &a, const v_int32 &b) {
-  return v_cvt_f64(v_dotprod_fast(a, b));
-}
-inline v_float64 v_dotprod_expand_fast(const v_int32 &a, const v_int32 &b,
-                                       const v_float64 &c) {
-  return v_add(v_dotprod_expand_fast(a, b), c);
-}
-#endif
-
-// TODO: only 128 bit now.
-inline v_float32 v_matmul(const v_float32 &v, const v_float32 &mat0,
-                          const v_float32 &mat1, const v_float32 &mat2,
-                          const v_float32 &mat3) {
-  vfloat32m2_t res;
-  res = __riscv_vfmul_vf_f32m2(mat0, v_extract_n(v, 0),
-                               VTraits<v_float32>::vlanes());
-  res = __riscv_vfmacc_vf_f32m2(res, v_extract_n(v, 1), mat1,
-                                VTraits<v_float32>::vlanes());
-  res = __riscv_vfmacc_vf_f32m2(res, v_extract_n(v, 2), mat2,
-                                VTraits<v_float32>::vlanes());
-  res = __riscv_vfmacc_vf_f32m2(res, v_extract_n(v, 3), mat3,
-                                VTraits<v_float32>::vlanes());
-  return res;
-}
-
-// TODO: only 128 bit now.
-inline v_float32 v_matmuladd(const v_float32 &v, const v_float32 &mat0,
-                             const v_float32 &mat1, const v_float32 &mat2,
-                             const v_float32 &a) {
-  vfloat32m2_t res = __riscv_vfmul_vf_f32m2(mat0, v_extract_n(v, 0),
-                                            VTraits<v_float32>::vlanes());
-  res = __riscv_vfmacc_vf_f32m2(res, v_extract_n(v, 1), mat1,
-                                VTraits<v_float32>::vlanes());
-  res = __riscv_vfmacc_vf_f32m2(res, v_extract_n(v, 2), mat2,
-                                VTraits<v_float32>::vlanes());
-  return __riscv_vfadd(res, a, VTraits<v_float32>::vlanes());
-}
-
-inline void v_cleanup() {}
-
-#include "intrin_math.hpp"
-inline v_float32 v_exp(const v_float32 &x) {
-  return v_exp_default_32f<v_float32, v_int32>(x);
-}
-inline v_float32 v_log(const v_float32 &x) {
-  return v_log_default_32f<v_float32, v_int32>(x);
-}
-inline void v_sincos(const v_float32 &x, v_float32 &s, v_float32 &c) {
-  v_sincos_default_32f<v_float32, v_int32>(x, s, c);
-}
-inline v_float32 v_sin(const v_float32 &x) {
-  return v_sin_default_32f<v_float32, v_int32>(x);
-}
-inline v_float32 v_cos(const v_float32 &x) {
-  return v_cos_default_32f<v_float32, v_int32>(x);
-}
-inline v_float32 v_erf(const v_float32 &x) {
-  return v_erf_default_32f<v_float32, v_int32>(x);
-}
-
-inline v_float64 v_exp(const v_float64 &x) {
-  return v_exp_default_64f<v_float64, v_int64>(x);
-}
-inline v_float64 v_log(const v_float64 &x) {
-  return v_log_default_64f<v_float64, v_int64>(x);
-}
-inline void v_sincos(const v_float64 &x, v_float64 &s, v_float64 &c) {
-  v_sincos_default_64f<v_float64, v_int64>(x, s, c);
-}
-inline v_float64 v_sin(const v_float64 &x) {
-  return v_sin_default_64f<v_float64, v_int64>(x);
-}
-inline v_float64 v_cos(const v_float64 &x) {
-  return v_cos_default_64f<v_float64, v_int64>(x);
-}
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_END
-
-//! @endcond
-
-} // namespace cv
-
-#endif // OPENCV_HAL_INTRIN_RVV_SCALABLE_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_sse.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_sse.hpp
deleted file mode 100644
index cdeda629cb..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_sse.hpp
+++ /dev/null
@@ -1,3528 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Copyright (C) 2015, Itseez Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_HAL_SSE_HPP
-#define OPENCV_HAL_SSE_HPP
-
-#include "opencv2/core/utility.hpp"
-#include <algorithm>
-
-#define CV_SIMD128 1
-#define CV_SIMD128_64F 1
-#define CV_SIMD128_FP16 0 // no native operations with FP16 type.
-
-namespace cv {
-
-//! @cond IGNORED
-
-//
-// Compilation troubleshooting:
-// - MSVC: error C2719: 'a': formal parameter with requested alignment of 16
-// won't be aligned
-//   Replace parameter declaration to const reference:
-//   -v_int32x4 a
-//   +const v_int32x4& a
-//
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_BEGIN
-
-///////// Types ////////////
-
-struct v_uint8x16 {
-  typedef uchar lane_type;
-  typedef __m128i vector_type;
-  enum { nlanes = 16 };
-
-  /* coverity[uninit_ctor]: suppress warning */
-  v_uint8x16() {}
-  explicit v_uint8x16(__m128i v) : val(v) {}
-  v_uint8x16(uchar v0, uchar v1, uchar v2, uchar v3, uchar v4, uchar v5,
-             uchar v6, uchar v7, uchar v8, uchar v9, uchar v10, uchar v11,
-             uchar v12, uchar v13, uchar v14, uchar v15) {
-    val = _mm_setr_epi8((char)v0, (char)v1, (char)v2, (char)v3, (char)v4,
-                        (char)v5, (char)v6, (char)v7, (char)v8, (char)v9,
-                        (char)v10, (char)v11, (char)v12, (char)v13, (char)v14,
-                        (char)v15);
-  }
-
-  uchar get0() const { return (uchar)_mm_cvtsi128_si32(val); }
-
-  __m128i val;
-};
-
-struct v_int8x16 {
-  typedef schar lane_type;
-  typedef __m128i vector_type;
-  enum { nlanes = 16 };
-
-  /* coverity[uninit_ctor]: suppress warning */
-  v_int8x16() {}
-  explicit v_int8x16(__m128i v) : val(v) {}
-  v_int8x16(schar v0, schar v1, schar v2, schar v3, schar v4, schar v5,
-            schar v6, schar v7, schar v8, schar v9, schar v10, schar v11,
-            schar v12, schar v13, schar v14, schar v15) {
-    val = _mm_setr_epi8((char)v0, (char)v1, (char)v2, (char)v3, (char)v4,
-                        (char)v5, (char)v6, (char)v7, (char)v8, (char)v9,
-                        (char)v10, (char)v11, (char)v12, (char)v13, (char)v14,
-                        (char)v15);
-  }
-
-  schar get0() const { return (schar)_mm_cvtsi128_si32(val); }
-
-  __m128i val;
-};
-
-struct v_uint16x8 {
-  typedef ushort lane_type;
-  typedef __m128i vector_type;
-  enum { nlanes = 8 };
-
-  /* coverity[uninit_ctor]: suppress warning */
-  v_uint16x8() {}
-  explicit v_uint16x8(__m128i v) : val(v) {}
-  v_uint16x8(ushort v0, ushort v1, ushort v2, ushort v3, ushort v4, ushort v5,
-             ushort v6, ushort v7) {
-    val = _mm_setr_epi16((short)v0, (short)v1, (short)v2, (short)v3, (short)v4,
-                         (short)v5, (short)v6, (short)v7);
-  }
-
-  ushort get0() const { return (ushort)_mm_cvtsi128_si32(val); }
-
-  __m128i val;
-};
-
-struct v_int16x8 {
-  typedef short lane_type;
-  typedef __m128i vector_type;
-  enum { nlanes = 8 };
-
-  /* coverity[uninit_ctor]: suppress warning */
-  v_int16x8() {}
-  explicit v_int16x8(__m128i v) : val(v) {}
-  v_int16x8(short v0, short v1, short v2, short v3, short v4, short v5,
-            short v6, short v7) {
-    val = _mm_setr_epi16((short)v0, (short)v1, (short)v2, (short)v3, (short)v4,
-                         (short)v5, (short)v6, (short)v7);
-  }
-
-  short get0() const { return (short)_mm_cvtsi128_si32(val); }
-
-  __m128i val;
-};
-
-struct v_uint32x4 {
-  typedef unsigned lane_type;
-  typedef __m128i vector_type;
-  enum { nlanes = 4 };
-
-  /* coverity[uninit_ctor]: suppress warning */
-  v_uint32x4() {}
-  explicit v_uint32x4(__m128i v) : val(v) {}
-  v_uint32x4(unsigned v0, unsigned v1, unsigned v2, unsigned v3) {
-    val = _mm_setr_epi32((int)v0, (int)v1, (int)v2, (int)v3);
-  }
-
-  unsigned get0() const { return (unsigned)_mm_cvtsi128_si32(val); }
-
-  __m128i val;
-};
-
-struct v_int32x4 {
-  typedef int lane_type;
-  typedef __m128i vector_type;
-  enum { nlanes = 4 };
-
-  /* coverity[uninit_ctor]: suppress warning */
-  v_int32x4() {}
-  explicit v_int32x4(__m128i v) : val(v) {}
-  v_int32x4(int v0, int v1, int v2, int v3) {
-    val = _mm_setr_epi32(v0, v1, v2, v3);
-  }
-
-  int get0() const { return _mm_cvtsi128_si32(val); }
-
-  __m128i val;
-};
-
-struct v_float32x4 {
-  typedef float lane_type;
-  typedef __m128 vector_type;
-  enum { nlanes = 4 };
-
-  /* coverity[uninit_ctor]: suppress warning */
-  v_float32x4() {}
-  explicit v_float32x4(__m128 v) : val(v) {}
-  v_float32x4(float v0, float v1, float v2, float v3) {
-    val = _mm_setr_ps(v0, v1, v2, v3);
-  }
-
-  float get0() const { return _mm_cvtss_f32(val); }
-
-  __m128 val;
-};
-
-struct v_uint64x2 {
-  typedef uint64 lane_type;
-  typedef __m128i vector_type;
-  enum { nlanes = 2 };
-
-  /* coverity[uninit_ctor]: suppress warning */
-  v_uint64x2() {}
-  explicit v_uint64x2(__m128i v) : val(v) {}
-  v_uint64x2(uint64 v0, uint64 v1) {
-#if defined(_MSC_VER) && _MSC_VER >= 1920 /*MSVS 2019*/ && defined(_M_X64) &&  \
-    !defined(__clang__)
-    val = _mm_setr_epi64x((int64_t)v0, (int64_t)v1);
-#elif defined(__GNUC__)
-    val = _mm_setr_epi64((__m64)v0, (__m64)v1);
-#else
-    val = _mm_setr_epi32((int)v0, (int)(v0 >> 32), (int)v1, (int)(v1 >> 32));
-#endif
-  }
-
-  uint64 get0() const {
-#if !defined(__x86_64__) && !defined(_M_X64)
-    int a = _mm_cvtsi128_si32(val);
-    int b = _mm_cvtsi128_si32(_mm_srli_epi64(val, 32));
-    return (unsigned)a | ((uint64)(unsigned)b << 32);
-#else
-    return (uint64)_mm_cvtsi128_si64(val);
-#endif
-  }
-
-  __m128i val;
-};
-
-struct v_int64x2 {
-  typedef int64 lane_type;
-  typedef __m128i vector_type;
-  enum { nlanes = 2 };
-
-  /* coverity[uninit_ctor]: suppress warning */
-  v_int64x2() {}
-  explicit v_int64x2(__m128i v) : val(v) {}
-  v_int64x2(int64 v0, int64 v1) {
-#if defined(_MSC_VER) && _MSC_VER >= 1920 /*MSVS 2019*/ && defined(_M_X64) &&  \
-    !defined(__clang__)
-    val = _mm_setr_epi64x((int64_t)v0, (int64_t)v1);
-#elif defined(__GNUC__)
-    val = _mm_setr_epi64((__m64)v0, (__m64)v1);
-#else
-    val = _mm_setr_epi32((int)v0, (int)(v0 >> 32), (int)v1, (int)(v1 >> 32));
-#endif
-  }
-
-  int64 get0() const {
-#if !defined(__x86_64__) && !defined(_M_X64)
-    int a = _mm_cvtsi128_si32(val);
-    int b = _mm_cvtsi128_si32(_mm_srli_epi64(val, 32));
-    return (int64)((unsigned)a | ((uint64)(unsigned)b << 32));
-#else
-    return _mm_cvtsi128_si64(val);
-#endif
-  }
-
-  __m128i val;
-};
-
-struct v_float64x2 {
-  typedef double lane_type;
-  typedef __m128d vector_type;
-  enum { nlanes = 2 };
-
-  /* coverity[uninit_ctor]: suppress warning */
-  v_float64x2() {}
-  explicit v_float64x2(__m128d v) : val(v) {}
-  v_float64x2(double v0, double v1) { val = _mm_setr_pd(v0, v1); }
-
-  double get0() const { return _mm_cvtsd_f64(val); }
-
-  __m128d val;
-};
-
-namespace hal_sse_internal {
-template <typename to_sse_type, typename from_sse_type>
-to_sse_type v_sse_reinterpret_as(const from_sse_type &val);
-
-#define OPENCV_HAL_IMPL_SSE_REINTERPRET_RAW(to_sse_type, from_sse_type,        \
-                                            sse_cast_intrin)                   \
-  template <>                                                                  \
-  inline to_sse_type v_sse_reinterpret_as(const from_sse_type &a) {            \
-    return sse_cast_intrin(a);                                                 \
-  }
-
-OPENCV_HAL_IMPL_SSE_REINTERPRET_RAW(__m128i, __m128i, OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_SSE_REINTERPRET_RAW(__m128i, __m128, _mm_castps_si128)
-OPENCV_HAL_IMPL_SSE_REINTERPRET_RAW(__m128i, __m128d, _mm_castpd_si128)
-OPENCV_HAL_IMPL_SSE_REINTERPRET_RAW(__m128, __m128i, _mm_castsi128_ps)
-OPENCV_HAL_IMPL_SSE_REINTERPRET_RAW(__m128, __m128, OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_SSE_REINTERPRET_RAW(__m128, __m128d, _mm_castpd_ps)
-OPENCV_HAL_IMPL_SSE_REINTERPRET_RAW(__m128d, __m128i, _mm_castsi128_pd)
-OPENCV_HAL_IMPL_SSE_REINTERPRET_RAW(__m128d, __m128, _mm_castps_pd)
-OPENCV_HAL_IMPL_SSE_REINTERPRET_RAW(__m128d, __m128d, OPENCV_HAL_NOP)
-} // namespace hal_sse_internal
-
-#define OPENCV_HAL_IMPL_SSE_INITVEC(_Tpvec, _Tp, suffix, zsuffix, ssuffix,     \
-                                    _Tps, cast)                                \
-  inline _Tpvec v_setzero_##suffix() {                                         \
-    return _Tpvec(_mm_setzero_##zsuffix());                                    \
-  }                                                                            \
-  inline _Tpvec v_setall_##suffix(_Tp v) {                                     \
-    return _Tpvec(_mm_set1_##ssuffix((_Tps)v));                                \
-  }                                                                            \
-  template <> inline _Tpvec v_setzero_() { return v_setzero_##suffix(); }      \
-  template <> inline _Tpvec v_setall_(_Tp v) { return v_setall_##suffix(v); }  \
-  template <typename _Tpvec0>                                                  \
-  inline _Tpvec v_reinterpret_as_##suffix(const _Tpvec0 &a) {                  \
-    return _Tpvec(cast(a.val));                                                \
-  }
-
-OPENCV_HAL_IMPL_SSE_INITVEC(v_uint8x16, uchar, u8, si128, epi8, schar,
-                            OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_SSE_INITVEC(v_int8x16, schar, s8, si128, epi8, schar,
-                            OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_SSE_INITVEC(v_uint16x8, ushort, u16, si128, epi16, short,
-                            OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_SSE_INITVEC(v_int16x8, short, s16, si128, epi16, short,
-                            OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_SSE_INITVEC(v_uint32x4, unsigned, u32, si128, epi32, int,
-                            OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_SSE_INITVEC(v_int32x4, int, s32, si128, epi32, int,
-                            OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_SSE_INITVEC(v_float32x4, float, f32, ps, ps, float,
-                            _mm_castsi128_ps)
-OPENCV_HAL_IMPL_SSE_INITVEC(v_float64x2, double, f64, pd, pd, double,
-                            _mm_castsi128_pd)
-
-inline v_uint64x2 v_setzero_u64() { return v_uint64x2(_mm_setzero_si128()); }
-inline v_int64x2 v_setzero_s64() { return v_int64x2(_mm_setzero_si128()); }
-inline v_uint64x2 v_setall_u64(uint64 val) { return v_uint64x2(val, val); }
-inline v_int64x2 v_setall_s64(int64 val) { return v_int64x2(val, val); }
-
-template <> inline v_uint64x2 v_setzero_() { return v_setzero_u64(); }
-template <> inline v_int64x2 v_setzero_() { return v_setzero_s64(); }
-template <> inline v_uint64x2 v_setall_(uint64 val) {
-  return v_setall_u64(val);
-}
-template <> inline v_int64x2 v_setall_(int64 val) { return v_setall_s64(val); }
-
-template <typename _Tpvec>
-inline v_uint64x2 v_reinterpret_as_u64(const _Tpvec &a) {
-  return v_uint64x2(a.val);
-}
-template <typename _Tpvec>
-inline v_int64x2 v_reinterpret_as_s64(const _Tpvec &a) {
-  return v_int64x2(a.val);
-}
-inline v_float32x4 v_reinterpret_as_f32(const v_uint64x2 &a) {
-  return v_float32x4(_mm_castsi128_ps(a.val));
-}
-inline v_float32x4 v_reinterpret_as_f32(const v_int64x2 &a) {
-  return v_float32x4(_mm_castsi128_ps(a.val));
-}
-inline v_float64x2 v_reinterpret_as_f64(const v_uint64x2 &a) {
-  return v_float64x2(_mm_castsi128_pd(a.val));
-}
-inline v_float64x2 v_reinterpret_as_f64(const v_int64x2 &a) {
-  return v_float64x2(_mm_castsi128_pd(a.val));
-}
-
-#define OPENCV_HAL_IMPL_SSE_INIT_FROM_FLT(_Tpvec, suffix)                      \
-  inline _Tpvec v_reinterpret_as_##suffix(const v_float32x4 &a) {              \
-    return _Tpvec(_mm_castps_si128(a.val));                                    \
-  }                                                                            \
-  inline _Tpvec v_reinterpret_as_##suffix(const v_float64x2 &a) {              \
-    return _Tpvec(_mm_castpd_si128(a.val));                                    \
-  }
-
-OPENCV_HAL_IMPL_SSE_INIT_FROM_FLT(v_uint8x16, u8)
-OPENCV_HAL_IMPL_SSE_INIT_FROM_FLT(v_int8x16, s8)
-OPENCV_HAL_IMPL_SSE_INIT_FROM_FLT(v_uint16x8, u16)
-OPENCV_HAL_IMPL_SSE_INIT_FROM_FLT(v_int16x8, s16)
-OPENCV_HAL_IMPL_SSE_INIT_FROM_FLT(v_uint32x4, u32)
-OPENCV_HAL_IMPL_SSE_INIT_FROM_FLT(v_int32x4, s32)
-OPENCV_HAL_IMPL_SSE_INIT_FROM_FLT(v_uint64x2, u64)
-OPENCV_HAL_IMPL_SSE_INIT_FROM_FLT(v_int64x2, s64)
-
-inline v_float32x4 v_reinterpret_as_f32(const v_float32x4 &a) { return a; }
-inline v_float64x2 v_reinterpret_as_f64(const v_float64x2 &a) { return a; }
-inline v_float32x4 v_reinterpret_as_f32(const v_float64x2 &a) {
-  return v_float32x4(_mm_castpd_ps(a.val));
-}
-inline v_float64x2 v_reinterpret_as_f64(const v_float32x4 &a) {
-  return v_float64x2(_mm_castps_pd(a.val));
-}
-
-//////////////// PACK ///////////////
-inline v_uint8x16 v_pack(const v_uint16x8 &a, const v_uint16x8 &b) {
-  __m128i delta = _mm_set1_epi16(255);
-  return v_uint8x16(
-      _mm_packus_epi16(_mm_subs_epu16(a.val, _mm_subs_epu16(a.val, delta)),
-                       _mm_subs_epu16(b.val, _mm_subs_epu16(b.val, delta))));
-}
-
-inline void v_pack_store(uchar *ptr, const v_uint16x8 &a) {
-  __m128i delta = _mm_set1_epi16(255);
-  __m128i a1 = _mm_subs_epu16(a.val, _mm_subs_epu16(a.val, delta));
-  _mm_storel_epi64((__m128i *)ptr, _mm_packus_epi16(a1, a1));
-}
-
-inline v_uint8x16 v_pack_u(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_uint8x16(_mm_packus_epi16(a.val, b.val));
-}
-
-inline void v_pack_u_store(uchar *ptr, const v_int16x8 &a) {
-  _mm_storel_epi64((__m128i *)ptr, _mm_packus_epi16(a.val, a.val));
-}
-
-template <int n>
-inline v_uint8x16 v_rshr_pack(const v_uint16x8 &a, const v_uint16x8 &b) {
-  // we assume that n > 0, and so the shifted 16-bit values can be treated as
-  // signed numbers.
-  __m128i delta = _mm_set1_epi16((short)(1 << (n - 1)));
-  return v_uint8x16(
-      _mm_packus_epi16(_mm_srli_epi16(_mm_adds_epu16(a.val, delta), n),
-                       _mm_srli_epi16(_mm_adds_epu16(b.val, delta), n)));
-}
-
-template <int n>
-inline void v_rshr_pack_store(uchar *ptr, const v_uint16x8 &a) {
-  __m128i delta = _mm_set1_epi16((short)(1 << (n - 1)));
-  __m128i a1 = _mm_srli_epi16(_mm_adds_epu16(a.val, delta), n);
-  _mm_storel_epi64((__m128i *)ptr, _mm_packus_epi16(a1, a1));
-}
-
-template <int n>
-inline v_uint8x16 v_rshr_pack_u(const v_int16x8 &a, const v_int16x8 &b) {
-  __m128i delta = _mm_set1_epi16((short)(1 << (n - 1)));
-  return v_uint8x16(
-      _mm_packus_epi16(_mm_srai_epi16(_mm_adds_epi16(a.val, delta), n),
-                       _mm_srai_epi16(_mm_adds_epi16(b.val, delta), n)));
-}
-
-template <int n>
-inline void v_rshr_pack_u_store(uchar *ptr, const v_int16x8 &a) {
-  __m128i delta = _mm_set1_epi16((short)(1 << (n - 1)));
-  __m128i a1 = _mm_srai_epi16(_mm_adds_epi16(a.val, delta), n);
-  _mm_storel_epi64((__m128i *)ptr, _mm_packus_epi16(a1, a1));
-}
-
-inline v_int8x16 v_pack(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_int8x16(_mm_packs_epi16(a.val, b.val));
-}
-
-inline void v_pack_store(schar *ptr, const v_int16x8 &a) {
-  _mm_storel_epi64((__m128i *)ptr, _mm_packs_epi16(a.val, a.val));
-}
-
-template <int n>
-inline v_int8x16 v_rshr_pack(const v_int16x8 &a, const v_int16x8 &b) {
-  // we assume that n > 0, and so the shifted 16-bit values can be treated as
-  // signed numbers.
-  __m128i delta = _mm_set1_epi16((short)(1 << (n - 1)));
-  return v_int8x16(
-      _mm_packs_epi16(_mm_srai_epi16(_mm_adds_epi16(a.val, delta), n),
-                      _mm_srai_epi16(_mm_adds_epi16(b.val, delta), n)));
-}
-template <int n> inline void v_rshr_pack_store(schar *ptr, const v_int16x8 &a) {
-  // we assume that n > 0, and so the shifted 16-bit values can be treated as
-  // signed numbers.
-  __m128i delta = _mm_set1_epi16((short)(1 << (n - 1)));
-  __m128i a1 = _mm_srai_epi16(_mm_adds_epi16(a.val, delta), n);
-  _mm_storel_epi64((__m128i *)ptr, _mm_packs_epi16(a1, a1));
-}
-
-// byte-wise "mask ? a : b"
-inline __m128i v_select_si128(__m128i mask, __m128i a, __m128i b) {
-#if CV_SSE4_1
-  return _mm_blendv_epi8(b, a, mask);
-#else
-  return _mm_xor_si128(b, _mm_and_si128(_mm_xor_si128(a, b), mask));
-#endif
-}
-
-inline v_uint16x8 v_pack(const v_uint32x4 &a, const v_uint32x4 &b) {
-  return v_uint16x8(_v128_packs_epu32(a.val, b.val));
-}
-
-inline void v_pack_store(ushort *ptr, const v_uint32x4 &a) {
-  __m128i z = _mm_setzero_si128(), maxval32 = _mm_set1_epi32(65535),
-          delta32 = _mm_set1_epi32(32768);
-  __m128i a1 = _mm_sub_epi32(
-      v_select_si128(_mm_cmpgt_epi32(z, a.val), maxval32, a.val), delta32);
-  __m128i r = _mm_packs_epi32(a1, a1);
-  _mm_storel_epi64((__m128i *)ptr, _mm_sub_epi16(r, _mm_set1_epi16(-32768)));
-}
-
-template <int n>
-inline v_uint16x8 v_rshr_pack(const v_uint32x4 &a, const v_uint32x4 &b) {
-  __m128i delta = _mm_set1_epi32(1 << (n - 1)), delta32 = _mm_set1_epi32(32768);
-  __m128i a1 =
-      _mm_sub_epi32(_mm_srli_epi32(_mm_add_epi32(a.val, delta), n), delta32);
-  __m128i b1 =
-      _mm_sub_epi32(_mm_srli_epi32(_mm_add_epi32(b.val, delta), n), delta32);
-  return v_uint16x8(
-      _mm_sub_epi16(_mm_packs_epi32(a1, b1), _mm_set1_epi16(-32768)));
-}
-
-template <int n>
-inline void v_rshr_pack_store(ushort *ptr, const v_uint32x4 &a) {
-  __m128i delta = _mm_set1_epi32(1 << (n - 1)), delta32 = _mm_set1_epi32(32768);
-  __m128i a1 =
-      _mm_sub_epi32(_mm_srli_epi32(_mm_add_epi32(a.val, delta), n), delta32);
-  __m128i a2 = _mm_sub_epi16(_mm_packs_epi32(a1, a1), _mm_set1_epi16(-32768));
-  _mm_storel_epi64((__m128i *)ptr, a2);
-}
-
-inline v_uint16x8 v_pack_u(const v_int32x4 &a, const v_int32x4 &b) {
-#if CV_SSE4_1
-  return v_uint16x8(_mm_packus_epi32(a.val, b.val));
-#else
-  __m128i delta32 = _mm_set1_epi32(32768);
-
-  // preliminary saturate negative values to zero
-  __m128i a1 = _mm_and_si128(a.val, _mm_cmpgt_epi32(a.val, _mm_set1_epi32(0)));
-  __m128i b1 = _mm_and_si128(b.val, _mm_cmpgt_epi32(b.val, _mm_set1_epi32(0)));
-
-  __m128i r =
-      _mm_packs_epi32(_mm_sub_epi32(a1, delta32), _mm_sub_epi32(b1, delta32));
-  return v_uint16x8(_mm_sub_epi16(r, _mm_set1_epi16(-32768)));
-#endif
-}
-
-inline void v_pack_u_store(ushort *ptr, const v_int32x4 &a) {
-#if CV_SSE4_1
-  _mm_storel_epi64((__m128i *)ptr, _mm_packus_epi32(a.val, a.val));
-#else
-  __m128i delta32 = _mm_set1_epi32(32768);
-  __m128i a1 = _mm_sub_epi32(a.val, delta32);
-  __m128i r = _mm_sub_epi16(_mm_packs_epi32(a1, a1), _mm_set1_epi16(-32768));
-  _mm_storel_epi64((__m128i *)ptr, r);
-#endif
-}
-
-template <int n>
-inline v_uint16x8 v_rshr_pack_u(const v_int32x4 &a, const v_int32x4 &b) {
-#if CV_SSE4_1
-  __m128i delta = _mm_set1_epi32(1 << (n - 1));
-  return v_uint16x8(
-      _mm_packus_epi32(_mm_srai_epi32(_mm_add_epi32(a.val, delta), n),
-                       _mm_srai_epi32(_mm_add_epi32(b.val, delta), n)));
-#else
-  __m128i delta = _mm_set1_epi32(1 << (n - 1)), delta32 = _mm_set1_epi32(32768);
-  __m128i a1 =
-      _mm_sub_epi32(_mm_srai_epi32(_mm_add_epi32(a.val, delta), n), delta32);
-  __m128i a2 = _mm_sub_epi16(_mm_packs_epi32(a1, a1), _mm_set1_epi16(-32768));
-  __m128i b1 =
-      _mm_sub_epi32(_mm_srai_epi32(_mm_add_epi32(b.val, delta), n), delta32);
-  __m128i b2 = _mm_sub_epi16(_mm_packs_epi32(b1, b1), _mm_set1_epi16(-32768));
-  return v_uint16x8(_mm_unpacklo_epi64(a2, b2));
-#endif
-}
-
-template <int n>
-inline void v_rshr_pack_u_store(ushort *ptr, const v_int32x4 &a) {
-#if CV_SSE4_1
-  __m128i delta = _mm_set1_epi32(1 << (n - 1));
-  __m128i a1 = _mm_srai_epi32(_mm_add_epi32(a.val, delta), n);
-  _mm_storel_epi64((__m128i *)ptr, _mm_packus_epi32(a1, a1));
-#else
-  __m128i delta = _mm_set1_epi32(1 << (n - 1)), delta32 = _mm_set1_epi32(32768);
-  __m128i a1 =
-      _mm_sub_epi32(_mm_srai_epi32(_mm_add_epi32(a.val, delta), n), delta32);
-  __m128i a2 = _mm_sub_epi16(_mm_packs_epi32(a1, a1), _mm_set1_epi16(-32768));
-  _mm_storel_epi64((__m128i *)ptr, a2);
-#endif
-}
-
-inline v_int16x8 v_pack(const v_int32x4 &a, const v_int32x4 &b) {
-  return v_int16x8(_mm_packs_epi32(a.val, b.val));
-}
-
-inline void v_pack_store(short *ptr, const v_int32x4 &a) {
-  _mm_storel_epi64((__m128i *)ptr, _mm_packs_epi32(a.val, a.val));
-}
-
-template <int n>
-inline v_int16x8 v_rshr_pack(const v_int32x4 &a, const v_int32x4 &b) {
-  __m128i delta = _mm_set1_epi32(1 << (n - 1));
-  return v_int16x8(
-      _mm_packs_epi32(_mm_srai_epi32(_mm_add_epi32(a.val, delta), n),
-                      _mm_srai_epi32(_mm_add_epi32(b.val, delta), n)));
-}
-
-template <int n> inline void v_rshr_pack_store(short *ptr, const v_int32x4 &a) {
-  __m128i delta = _mm_set1_epi32(1 << (n - 1));
-  __m128i a1 = _mm_srai_epi32(_mm_add_epi32(a.val, delta), n);
-  _mm_storel_epi64((__m128i *)ptr, _mm_packs_epi32(a1, a1));
-}
-
-// [a0 0 | b0 0]  [a1 0 | b1 0]
-inline v_uint32x4 v_pack(const v_uint64x2 &a, const v_uint64x2 &b) {
-  __m128i v0 = _mm_unpacklo_epi32(a.val, b.val); // a0 a1 0 0
-  __m128i v1 = _mm_unpackhi_epi32(a.val, b.val); // b0 b1 0 0
-  return v_uint32x4(_mm_unpacklo_epi32(v0, v1));
-}
-
-inline void v_pack_store(unsigned *ptr, const v_uint64x2 &a) {
-  __m128i a1 = _mm_shuffle_epi32(a.val, _MM_SHUFFLE(0, 2, 2, 0));
-  _mm_storel_epi64((__m128i *)ptr, a1);
-}
-
-// [a0 0 | b0 0]  [a1 0 | b1 0]
-inline v_int32x4 v_pack(const v_int64x2 &a, const v_int64x2 &b) {
-  __m128i v0 = _mm_unpacklo_epi32(a.val, b.val); // a0 a1 0 0
-  __m128i v1 = _mm_unpackhi_epi32(a.val, b.val); // b0 b1 0 0
-  return v_int32x4(_mm_unpacklo_epi32(v0, v1));
-}
-
-inline void v_pack_store(int *ptr, const v_int64x2 &a) {
-  __m128i a1 = _mm_shuffle_epi32(a.val, _MM_SHUFFLE(0, 2, 2, 0));
-  _mm_storel_epi64((__m128i *)ptr, a1);
-}
-
-template <int n>
-inline v_uint32x4 v_rshr_pack(const v_uint64x2 &a, const v_uint64x2 &b) {
-  uint64 delta = (uint64)1 << (n - 1);
-  v_uint64x2 delta2(delta, delta);
-  __m128i a1 = _mm_srli_epi64(_mm_add_epi64(a.val, delta2.val), n);
-  __m128i b1 = _mm_srli_epi64(_mm_add_epi64(b.val, delta2.val), n);
-  __m128i v0 = _mm_unpacklo_epi32(a1, b1); // a0 a1 0 0
-  __m128i v1 = _mm_unpackhi_epi32(a1, b1); // b0 b1 0 0
-  return v_uint32x4(_mm_unpacklo_epi32(v0, v1));
-}
-
-template <int n>
-inline void v_rshr_pack_store(unsigned *ptr, const v_uint64x2 &a) {
-  uint64 delta = (uint64)1 << (n - 1);
-  v_uint64x2 delta2(delta, delta);
-  __m128i a1 = _mm_srli_epi64(_mm_add_epi64(a.val, delta2.val), n);
-  __m128i a2 = _mm_shuffle_epi32(a1, _MM_SHUFFLE(0, 2, 2, 0));
-  _mm_storel_epi64((__m128i *)ptr, a2);
-}
-
-inline __m128i v_sign_epi64(__m128i a) {
-  return _mm_shuffle_epi32(_mm_srai_epi32(a, 31),
-                           _MM_SHUFFLE(3, 3, 1, 1)); // x m0 | x m1
-}
-
-inline __m128i v_srai_epi64(__m128i a, int imm) {
-  __m128i smask = v_sign_epi64(a);
-  return _mm_xor_si128(_mm_srli_epi64(_mm_xor_si128(a, smask), imm), smask);
-}
-
-template <int n>
-inline v_int32x4 v_rshr_pack(const v_int64x2 &a, const v_int64x2 &b) {
-  int64 delta = (int64)1 << (n - 1);
-  v_int64x2 delta2(delta, delta);
-  __m128i a1 = v_srai_epi64(_mm_add_epi64(a.val, delta2.val), n);
-  __m128i b1 = v_srai_epi64(_mm_add_epi64(b.val, delta2.val), n);
-  __m128i v0 = _mm_unpacklo_epi32(a1, b1); // a0 a1 0 0
-  __m128i v1 = _mm_unpackhi_epi32(a1, b1); // b0 b1 0 0
-  return v_int32x4(_mm_unpacklo_epi32(v0, v1));
-}
-
-template <int n> inline void v_rshr_pack_store(int *ptr, const v_int64x2 &a) {
-  int64 delta = (int64)1 << (n - 1);
-  v_int64x2 delta2(delta, delta);
-  __m128i a1 = v_srai_epi64(_mm_add_epi64(a.val, delta2.val), n);
-  __m128i a2 = _mm_shuffle_epi32(a1, _MM_SHUFFLE(0, 2, 2, 0));
-  _mm_storel_epi64((__m128i *)ptr, a2);
-}
-
-// pack boolean
-inline v_uint8x16 v_pack_b(const v_uint16x8 &a, const v_uint16x8 &b) {
-  __m128i ab = _mm_packs_epi16(a.val, b.val);
-  return v_uint8x16(ab);
-}
-
-inline v_uint8x16 v_pack_b(const v_uint32x4 &a, const v_uint32x4 &b,
-                           const v_uint32x4 &c, const v_uint32x4 &d) {
-  __m128i ab = _mm_packs_epi32(a.val, b.val);
-  __m128i cd = _mm_packs_epi32(c.val, d.val);
-  return v_uint8x16(_mm_packs_epi16(ab, cd));
-}
-
-inline v_uint8x16 v_pack_b(const v_uint64x2 &a, const v_uint64x2 &b,
-                           const v_uint64x2 &c, const v_uint64x2 &d,
-                           const v_uint64x2 &e, const v_uint64x2 &f,
-                           const v_uint64x2 &g, const v_uint64x2 &h) {
-  __m128i ab = _mm_packs_epi32(a.val, b.val);
-  __m128i cd = _mm_packs_epi32(c.val, d.val);
-  __m128i ef = _mm_packs_epi32(e.val, f.val);
-  __m128i gh = _mm_packs_epi32(g.val, h.val);
-
-  __m128i abcd = _mm_packs_epi32(ab, cd);
-  __m128i efgh = _mm_packs_epi32(ef, gh);
-  return v_uint8x16(_mm_packs_epi16(abcd, efgh));
-}
-
-inline v_float32x4 v_matmul(const v_float32x4 &v, const v_float32x4 &m0,
-                            const v_float32x4 &m1, const v_float32x4 &m2,
-                            const v_float32x4 &m3) {
-  __m128 v0 =
-      _mm_mul_ps(_mm_shuffle_ps(v.val, v.val, _MM_SHUFFLE(0, 0, 0, 0)), m0.val);
-  __m128 v1 =
-      _mm_mul_ps(_mm_shuffle_ps(v.val, v.val, _MM_SHUFFLE(1, 1, 1, 1)), m1.val);
-  __m128 v2 =
-      _mm_mul_ps(_mm_shuffle_ps(v.val, v.val, _MM_SHUFFLE(2, 2, 2, 2)), m2.val);
-  __m128 v3 =
-      _mm_mul_ps(_mm_shuffle_ps(v.val, v.val, _MM_SHUFFLE(3, 3, 3, 3)), m3.val);
-
-  return v_float32x4(_mm_add_ps(_mm_add_ps(v0, v1), _mm_add_ps(v2, v3)));
-}
-
-inline v_float32x4 v_matmuladd(const v_float32x4 &v, const v_float32x4 &m0,
-                               const v_float32x4 &m1, const v_float32x4 &m2,
-                               const v_float32x4 &a) {
-  __m128 v0 =
-      _mm_mul_ps(_mm_shuffle_ps(v.val, v.val, _MM_SHUFFLE(0, 0, 0, 0)), m0.val);
-  __m128 v1 =
-      _mm_mul_ps(_mm_shuffle_ps(v.val, v.val, _MM_SHUFFLE(1, 1, 1, 1)), m1.val);
-  __m128 v2 =
-      _mm_mul_ps(_mm_shuffle_ps(v.val, v.val, _MM_SHUFFLE(2, 2, 2, 2)), m2.val);
-
-  return v_float32x4(_mm_add_ps(_mm_add_ps(v0, v1), _mm_add_ps(v2, a.val)));
-}
-
-#define OPENCV_HAL_IMPL_SSE_BIN_OP(bin_op, _Tpvec, intrin)                     \
-  inline _Tpvec bin_op(const _Tpvec &a, const _Tpvec &b) {                     \
-    return _Tpvec(intrin(a.val, b.val));                                       \
-  }
-
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_add, v_uint8x16, _mm_adds_epu8)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_sub, v_uint8x16, _mm_subs_epu8)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_add, v_int8x16, _mm_adds_epi8)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_sub, v_int8x16, _mm_subs_epi8)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_add, v_uint16x8, _mm_adds_epu16)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_sub, v_uint16x8, _mm_subs_epu16)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_add, v_int16x8, _mm_adds_epi16)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_sub, v_int16x8, _mm_subs_epi16)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_add, v_uint32x4, _mm_add_epi32)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_sub, v_uint32x4, _mm_sub_epi32)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_mul, v_uint32x4, _v128_mullo_epi32)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_add, v_int32x4, _mm_add_epi32)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_sub, v_int32x4, _mm_sub_epi32)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_mul, v_int32x4, _v128_mullo_epi32)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_add, v_float32x4, _mm_add_ps)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_sub, v_float32x4, _mm_sub_ps)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_mul, v_float32x4, _mm_mul_ps)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_div, v_float32x4, _mm_div_ps)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_add, v_float64x2, _mm_add_pd)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_sub, v_float64x2, _mm_sub_pd)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_mul, v_float64x2, _mm_mul_pd)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_div, v_float64x2, _mm_div_pd)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_add, v_uint64x2, _mm_add_epi64)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_sub, v_uint64x2, _mm_sub_epi64)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_add, v_int64x2, _mm_add_epi64)
-OPENCV_HAL_IMPL_SSE_BIN_OP(v_sub, v_int64x2, _mm_sub_epi64)
-
-// saturating multiply 8-bit, 16-bit
-#define OPENCV_HAL_IMPL_SSE_MUL_SAT(_Tpvec, _Tpwvec)                           \
-  inline _Tpvec v_mul(const _Tpvec &a, const _Tpvec &b) {                      \
-    _Tpwvec c, d;                                                              \
-    v_mul_expand(a, b, c, d);                                                  \
-    return v_pack(c, d);                                                       \
-  }
-
-OPENCV_HAL_IMPL_SSE_MUL_SAT(v_uint8x16, v_uint16x8)
-OPENCV_HAL_IMPL_SSE_MUL_SAT(v_int8x16, v_int16x8)
-OPENCV_HAL_IMPL_SSE_MUL_SAT(v_uint16x8, v_uint32x4)
-OPENCV_HAL_IMPL_SSE_MUL_SAT(v_int16x8, v_int32x4)
-
-//  Multiply and expand
-inline void v_mul_expand(const v_uint8x16 &a, const v_uint8x16 &b,
-                         v_uint16x8 &c, v_uint16x8 &d) {
-  v_uint16x8 a0, a1, b0, b1;
-  v_expand(a, a0, a1);
-  v_expand(b, b0, b1);
-  c = v_mul_wrap(a0, b0);
-  d = v_mul_wrap(a1, b1);
-}
-
-inline void v_mul_expand(const v_int8x16 &a, const v_int8x16 &b, v_int16x8 &c,
-                         v_int16x8 &d) {
-  v_int16x8 a0, a1, b0, b1;
-  v_expand(a, a0, a1);
-  v_expand(b, b0, b1);
-  c = v_mul_wrap(a0, b0);
-  d = v_mul_wrap(a1, b1);
-}
-
-inline void v_mul_expand(const v_int16x8 &a, const v_int16x8 &b, v_int32x4 &c,
-                         v_int32x4 &d) {
-  __m128i v0 = _mm_mullo_epi16(a.val, b.val);
-  __m128i v1 = _mm_mulhi_epi16(a.val, b.val);
-  c.val = _mm_unpacklo_epi16(v0, v1);
-  d.val = _mm_unpackhi_epi16(v0, v1);
-}
-
-inline void v_mul_expand(const v_uint16x8 &a, const v_uint16x8 &b,
-                         v_uint32x4 &c, v_uint32x4 &d) {
-  __m128i v0 = _mm_mullo_epi16(a.val, b.val);
-  __m128i v1 = _mm_mulhi_epu16(a.val, b.val);
-  c.val = _mm_unpacklo_epi16(v0, v1);
-  d.val = _mm_unpackhi_epi16(v0, v1);
-}
-
-inline void v_mul_expand(const v_uint32x4 &a, const v_uint32x4 &b,
-                         v_uint64x2 &c, v_uint64x2 &d) {
-  __m128i c0 = _mm_mul_epu32(a.val, b.val);
-  __m128i c1 =
-      _mm_mul_epu32(_mm_srli_epi64(a.val, 32), _mm_srli_epi64(b.val, 32));
-  c.val = _mm_unpacklo_epi64(c0, c1);
-  d.val = _mm_unpackhi_epi64(c0, c1);
-}
-
-inline v_int16x8 v_mul_hi(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_int16x8(_mm_mulhi_epi16(a.val, b.val));
-}
-inline v_uint16x8 v_mul_hi(const v_uint16x8 &a, const v_uint16x8 &b) {
-  return v_uint16x8(_mm_mulhi_epu16(a.val, b.val));
-}
-
-//////// Dot Product ////////
-
-// 16 >> 32
-inline v_int32x4 v_dotprod(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_int32x4(_mm_madd_epi16(a.val, b.val));
-}
-inline v_int32x4 v_dotprod(const v_int16x8 &a, const v_int16x8 &b,
-                           const v_int32x4 &c) {
-  return v_add(v_dotprod(a, b), c);
-}
-
-// 32 >> 64
-inline v_int64x2 v_dotprod(const v_int32x4 &a, const v_int32x4 &b) {
-#if CV_SSE4_1
-  __m128i even = _mm_mul_epi32(a.val, b.val);
-  __m128i odd =
-      _mm_mul_epi32(_mm_srli_epi64(a.val, 32), _mm_srli_epi64(b.val, 32));
-  return v_int64x2(_mm_add_epi64(even, odd));
-#else
-  __m128i even_u = _mm_mul_epu32(a.val, b.val);
-  __m128i odd_u =
-      _mm_mul_epu32(_mm_srli_epi64(a.val, 32), _mm_srli_epi64(b.val, 32));
-  // convert unsigned to signed high multiplication (from: Agner Fog(veclib) and
-  // H S Warren: Hacker's delight, 2003, p. 132)
-  __m128i a_sign = _mm_srai_epi32(a.val, 31);
-  __m128i b_sign = _mm_srai_epi32(b.val, 31);
-  // |x * sign of x
-  __m128i axb = _mm_and_si128(a.val, b_sign);
-  __m128i bxa = _mm_and_si128(b.val, a_sign);
-  // sum of sign corrections
-  __m128i ssum = _mm_add_epi32(bxa, axb);
-  __m128i even_ssum = _mm_slli_epi64(ssum, 32);
-  __m128i odd_ssum = _mm_and_si128(ssum, _mm_set_epi32(-1, 0, -1, 0));
-  // convert to signed and prod
-  return v_int64x2(_mm_add_epi64(_mm_sub_epi64(even_u, even_ssum),
-                                 _mm_sub_epi64(odd_u, odd_ssum)));
-#endif
-}
-inline v_int64x2 v_dotprod(const v_int32x4 &a, const v_int32x4 &b,
-                           const v_int64x2 &c) {
-  return v_add(v_dotprod(a, b), c);
-}
-
-// 8 >> 32
-inline v_uint32x4 v_dotprod_expand(const v_uint8x16 &a, const v_uint8x16 &b) {
-  __m128i a0 = _mm_srli_epi16(_mm_slli_si128(a.val, 1), 8); // even
-  __m128i a1 = _mm_srli_epi16(a.val, 8);                    // odd
-  __m128i b0 = _mm_srli_epi16(_mm_slli_si128(b.val, 1), 8);
-  __m128i b1 = _mm_srli_epi16(b.val, 8);
-  __m128i p0 = _mm_madd_epi16(a0, b0);
-  __m128i p1 = _mm_madd_epi16(a1, b1);
-  return v_uint32x4(_mm_add_epi32(p0, p1));
-}
-inline v_uint32x4 v_dotprod_expand(const v_uint8x16 &a, const v_uint8x16 &b,
-                                   const v_uint32x4 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-inline v_int32x4 v_dotprod_expand(const v_int8x16 &a, const v_int8x16 &b) {
-  __m128i a0 = _mm_srai_epi16(_mm_slli_si128(a.val, 1), 8); // even
-  __m128i a1 = _mm_srai_epi16(a.val, 8);                    // odd
-  __m128i b0 = _mm_srai_epi16(_mm_slli_si128(b.val, 1), 8);
-  __m128i b1 = _mm_srai_epi16(b.val, 8);
-  __m128i p0 = _mm_madd_epi16(a0, b0);
-  __m128i p1 = _mm_madd_epi16(a1, b1);
-  return v_int32x4(_mm_add_epi32(p0, p1));
-}
-inline v_int32x4 v_dotprod_expand(const v_int8x16 &a, const v_int8x16 &b,
-                                  const v_int32x4 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-// 16 >> 64
-inline v_uint64x2 v_dotprod_expand(const v_uint16x8 &a, const v_uint16x8 &b) {
-  v_uint32x4 c, d;
-  v_mul_expand(a, b, c, d);
-
-  v_uint64x2 c0, c1, d0, d1;
-  v_expand(c, c0, c1);
-  v_expand(d, d0, d1);
-
-  c0 = v_add(c0, c1);
-  d0 = v_add(d0, d1);
-  return v_uint64x2(_mm_add_epi64(_mm_unpacklo_epi64(c0.val, d0.val),
-                                  _mm_unpackhi_epi64(c0.val, d0.val)));
-}
-inline v_uint64x2 v_dotprod_expand(const v_uint16x8 &a, const v_uint16x8 &b,
-                                   const v_uint64x2 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-inline v_int64x2 v_dotprod_expand(const v_int16x8 &a, const v_int16x8 &b) {
-  v_int32x4 prod = v_dotprod(a, b);
-  v_int64x2 c, d;
-  v_expand(prod, c, d);
-  return v_int64x2(_mm_add_epi64(_mm_unpacklo_epi64(c.val, d.val),
-                                 _mm_unpackhi_epi64(c.val, d.val)));
-}
-inline v_int64x2 v_dotprod_expand(const v_int16x8 &a, const v_int16x8 &b,
-                                  const v_int64x2 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-// 32 >> 64f
-inline v_float64x2 v_dotprod_expand(const v_int32x4 &a, const v_int32x4 &b) {
-#if CV_SSE4_1
-  return v_cvt_f64(v_dotprod(a, b));
-#else
-  v_float64x2 c = v_mul(v_cvt_f64(a), v_cvt_f64(b));
-  v_float64x2 d = v_mul(v_cvt_f64_high(a), v_cvt_f64_high(b));
-
-  return v_float64x2(
-      _mm_add_pd(_mm_unpacklo_pd(c.val, d.val), _mm_unpackhi_pd(c.val, d.val)));
-#endif
-}
-inline v_float64x2 v_dotprod_expand(const v_int32x4 &a, const v_int32x4 &b,
-                                    const v_float64x2 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-//////// Fast Dot Product ////////
-
-// 16 >> 32
-inline v_int32x4 v_dotprod_fast(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_dotprod(a, b);
-}
-inline v_int32x4 v_dotprod_fast(const v_int16x8 &a, const v_int16x8 &b,
-                                const v_int32x4 &c) {
-  return v_add(v_dotprod(a, b), c);
-}
-
-// 32 >> 64
-inline v_int64x2 v_dotprod_fast(const v_int32x4 &a, const v_int32x4 &b) {
-  return v_dotprod(a, b);
-}
-inline v_int64x2 v_dotprod_fast(const v_int32x4 &a, const v_int32x4 &b,
-                                const v_int64x2 &c) {
-  return v_add(v_dotprod_fast(a, b), c);
-}
-
-// 8 >> 32
-inline v_uint32x4 v_dotprod_expand_fast(const v_uint8x16 &a,
-                                        const v_uint8x16 &b) {
-  __m128i a0 = v_expand_low(a).val;
-  __m128i a1 = v_expand_high(a).val;
-  __m128i b0 = v_expand_low(b).val;
-  __m128i b1 = v_expand_high(b).val;
-  __m128i p0 = _mm_madd_epi16(a0, b0);
-  __m128i p1 = _mm_madd_epi16(a1, b1);
-  return v_uint32x4(_mm_add_epi32(p0, p1));
-}
-inline v_uint32x4 v_dotprod_expand_fast(const v_uint8x16 &a,
-                                        const v_uint8x16 &b,
-                                        const v_uint32x4 &c) {
-  return v_add(v_dotprod_expand_fast(a, b), c);
-}
-
-inline v_int32x4 v_dotprod_expand_fast(const v_int8x16 &a, const v_int8x16 &b) {
-#if CV_SSE4_1
-  __m128i a0 = _mm_cvtepi8_epi16(a.val);
-  __m128i a1 = v_expand_high(a).val;
-  __m128i b0 = _mm_cvtepi8_epi16(b.val);
-  __m128i b1 = v_expand_high(b).val;
-  __m128i p0 = _mm_madd_epi16(a0, b0);
-  __m128i p1 = _mm_madd_epi16(a1, b1);
-  return v_int32x4(_mm_add_epi32(p0, p1));
-#else
-  return v_dotprod_expand(a, b);
-#endif
-}
-inline v_int32x4 v_dotprod_expand_fast(const v_int8x16 &a, const v_int8x16 &b,
-                                       const v_int32x4 &c) {
-  return v_add(v_dotprod_expand_fast(a, b), c);
-}
-
-// 16 >> 64
-inline v_uint64x2 v_dotprod_expand_fast(const v_uint16x8 &a,
-                                        const v_uint16x8 &b) {
-  v_uint32x4 c, d;
-  v_mul_expand(a, b, c, d);
-
-  v_uint64x2 c0, c1, d0, d1;
-  v_expand(c, c0, c1);
-  v_expand(d, d0, d1);
-
-  c0 = v_add(c0, c1);
-  d0 = v_add(d0, d1);
-  return v_add(c0, d0);
-}
-inline v_uint64x2 v_dotprod_expand_fast(const v_uint16x8 &a,
-                                        const v_uint16x8 &b,
-                                        const v_uint64x2 &c) {
-  return v_add(v_dotprod_expand_fast(a, b), c);
-}
-
-inline v_int64x2 v_dotprod_expand_fast(const v_int16x8 &a, const v_int16x8 &b) {
-  v_int32x4 prod = v_dotprod(a, b);
-  v_int64x2 c, d;
-  v_expand(prod, c, d);
-  return v_add(c, d);
-}
-inline v_int64x2 v_dotprod_expand_fast(const v_int16x8 &a, const v_int16x8 &b,
-                                       const v_int64x2 &c) {
-  return v_add(v_dotprod_expand_fast(a, b), c);
-}
-
-// 32 >> 64f
-v_float64x2 v_fma(const v_float64x2 &a, const v_float64x2 &b,
-                  const v_float64x2 &c);
-inline v_float64x2 v_dotprod_expand_fast(const v_int32x4 &a,
-                                         const v_int32x4 &b) {
-  return v_fma(v_cvt_f64(a), v_cvt_f64(b),
-               v_mul(v_cvt_f64_high(a), v_cvt_f64_high(b)));
-}
-inline v_float64x2 v_dotprod_expand_fast(const v_int32x4 &a, const v_int32x4 &b,
-                                         const v_float64x2 &c) {
-  return v_fma(v_cvt_f64(a), v_cvt_f64(b),
-               v_fma(v_cvt_f64_high(a), v_cvt_f64_high(b), c));
-}
-
-#define OPENCV_HAL_IMPL_SSE_LOGIC_OP(_Tpvec, suffix, not_const)                \
-  OPENCV_HAL_IMPL_SSE_BIN_OP(v_and, _Tpvec, _mm_and_##suffix)                  \
-  OPENCV_HAL_IMPL_SSE_BIN_OP(v_or, _Tpvec, _mm_or_##suffix)                    \
-  OPENCV_HAL_IMPL_SSE_BIN_OP(v_xor, _Tpvec, _mm_xor_##suffix)                  \
-  inline _Tpvec v_not(const _Tpvec &a) {                                       \
-    return _Tpvec(_mm_xor_##suffix(a.val, not_const));                         \
-  }
-
-OPENCV_HAL_IMPL_SSE_LOGIC_OP(v_uint8x16, si128, _mm_set1_epi32(-1))
-OPENCV_HAL_IMPL_SSE_LOGIC_OP(v_int8x16, si128, _mm_set1_epi32(-1))
-OPENCV_HAL_IMPL_SSE_LOGIC_OP(v_uint16x8, si128, _mm_set1_epi32(-1))
-OPENCV_HAL_IMPL_SSE_LOGIC_OP(v_int16x8, si128, _mm_set1_epi32(-1))
-OPENCV_HAL_IMPL_SSE_LOGIC_OP(v_uint32x4, si128, _mm_set1_epi32(-1))
-OPENCV_HAL_IMPL_SSE_LOGIC_OP(v_int32x4, si128, _mm_set1_epi32(-1))
-OPENCV_HAL_IMPL_SSE_LOGIC_OP(v_uint64x2, si128, _mm_set1_epi32(-1))
-OPENCV_HAL_IMPL_SSE_LOGIC_OP(v_int64x2, si128, _mm_set1_epi32(-1))
-OPENCV_HAL_IMPL_SSE_LOGIC_OP(v_float32x4, ps,
-                             _mm_castsi128_ps(_mm_set1_epi32(-1)))
-OPENCV_HAL_IMPL_SSE_LOGIC_OP(v_float64x2, pd,
-                             _mm_castsi128_pd(_mm_set1_epi32(-1)))
-
-inline v_float32x4 v_sqrt(const v_float32x4 &x) {
-  return v_float32x4(_mm_sqrt_ps(x.val));
-}
-
-inline v_float32x4 v_invsqrt(const v_float32x4 &x) {
-  const __m128 _0_5 = _mm_set1_ps(0.5f), _1_5 = _mm_set1_ps(1.5f);
-  __m128 t = x.val;
-  __m128 h = _mm_mul_ps(t, _0_5);
-  t = _mm_rsqrt_ps(t);
-  t = _mm_mul_ps(t, _mm_sub_ps(_1_5, _mm_mul_ps(_mm_mul_ps(t, t), h)));
-  return v_float32x4(t);
-}
-
-inline v_float64x2 v_sqrt(const v_float64x2 &x) {
-  return v_float64x2(_mm_sqrt_pd(x.val));
-}
-
-inline v_float64x2 v_invsqrt(const v_float64x2 &x) {
-  const __m128d v_1 = _mm_set1_pd(1.);
-  return v_float64x2(_mm_div_pd(v_1, _mm_sqrt_pd(x.val)));
-}
-
-#define OPENCV_HAL_IMPL_SSE_ABS_INT_FUNC(_Tpuvec, _Tpsvec, func, suffix,       \
-                                         subWidth)                             \
-  inline _Tpuvec v_abs(const _Tpsvec &x) {                                     \
-    return _Tpuvec(_mm_##func##_ep##suffix(                                    \
-        x.val, _mm_sub_ep##subWidth(_mm_setzero_si128(), x.val)));             \
-  }
-
-OPENCV_HAL_IMPL_SSE_ABS_INT_FUNC(v_uint8x16, v_int8x16, min, u8, i8)
-OPENCV_HAL_IMPL_SSE_ABS_INT_FUNC(v_uint16x8, v_int16x8, max, i16, i16)
-inline v_uint32x4 v_abs(const v_int32x4 &x) {
-  __m128i s = _mm_srli_epi32(x.val, 31);
-  __m128i f = _mm_srai_epi32(x.val, 31);
-  return v_uint32x4(_mm_add_epi32(_mm_xor_si128(x.val, f), s));
-}
-inline v_float32x4 v_abs(const v_float32x4 &x) {
-  return v_float32x4(
-      _mm_and_ps(x.val, _mm_castsi128_ps(_mm_set1_epi32(0x7fffffff))));
-}
-inline v_float64x2 v_abs(const v_float64x2 &x) {
-  return v_float64x2(_mm_and_pd(
-      x.val, _mm_castsi128_pd(_mm_srli_epi64(_mm_set1_epi32(-1), 1))));
-}
-
-// TODO: exp, log, sin, cos
-
-#define OPENCV_HAL_IMPL_SSE_BIN_FUNC(_Tpvec, func, intrin)                     \
-  inline _Tpvec func(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(intrin(a.val, b.val));                                       \
-  }
-
-OPENCV_HAL_IMPL_SSE_BIN_FUNC(v_uint8x16, v_min, _mm_min_epu8)
-OPENCV_HAL_IMPL_SSE_BIN_FUNC(v_uint8x16, v_max, _mm_max_epu8)
-OPENCV_HAL_IMPL_SSE_BIN_FUNC(v_int16x8, v_min, _mm_min_epi16)
-OPENCV_HAL_IMPL_SSE_BIN_FUNC(v_int16x8, v_max, _mm_max_epi16)
-OPENCV_HAL_IMPL_SSE_BIN_FUNC(v_float32x4, v_min, _mm_min_ps)
-OPENCV_HAL_IMPL_SSE_BIN_FUNC(v_float32x4, v_max, _mm_max_ps)
-OPENCV_HAL_IMPL_SSE_BIN_FUNC(v_float64x2, v_min, _mm_min_pd)
-OPENCV_HAL_IMPL_SSE_BIN_FUNC(v_float64x2, v_max, _mm_max_pd)
-
-inline v_int8x16 v_min(const v_int8x16 &a, const v_int8x16 &b) {
-#if CV_SSE4_1
-  return v_int8x16(_mm_min_epi8(a.val, b.val));
-#else
-  __m128i delta = _mm_set1_epi8((char)-128);
-  return v_int8x16(
-      _mm_xor_si128(delta, _mm_min_epu8(_mm_xor_si128(a.val, delta),
-                                        _mm_xor_si128(b.val, delta))));
-#endif
-}
-inline v_int8x16 v_max(const v_int8x16 &a, const v_int8x16 &b) {
-#if CV_SSE4_1
-  return v_int8x16(_mm_max_epi8(a.val, b.val));
-#else
-  __m128i delta = _mm_set1_epi8((char)-128);
-  return v_int8x16(
-      _mm_xor_si128(delta, _mm_max_epu8(_mm_xor_si128(a.val, delta),
-                                        _mm_xor_si128(b.val, delta))));
-#endif
-}
-inline v_uint16x8 v_min(const v_uint16x8 &a, const v_uint16x8 &b) {
-#if CV_SSE4_1
-  return v_uint16x8(_mm_min_epu16(a.val, b.val));
-#else
-  return v_uint16x8(_mm_subs_epu16(a.val, _mm_subs_epu16(a.val, b.val)));
-#endif
-}
-inline v_uint16x8 v_max(const v_uint16x8 &a, const v_uint16x8 &b) {
-#if CV_SSE4_1
-  return v_uint16x8(_mm_max_epu16(a.val, b.val));
-#else
-  return v_uint16x8(_mm_adds_epu16(_mm_subs_epu16(a.val, b.val), b.val));
-#endif
-}
-inline v_uint32x4 v_min(const v_uint32x4 &a, const v_uint32x4 &b) {
-#if CV_SSE4_1
-  return v_uint32x4(_mm_min_epu32(a.val, b.val));
-#else
-  __m128i delta = _mm_set1_epi32((int)0x80000000);
-  __m128i mask =
-      _mm_cmpgt_epi32(_mm_xor_si128(a.val, delta), _mm_xor_si128(b.val, delta));
-  return v_uint32x4(v_select_si128(mask, b.val, a.val));
-#endif
-}
-inline v_uint32x4 v_max(const v_uint32x4 &a, const v_uint32x4 &b) {
-#if CV_SSE4_1
-  return v_uint32x4(_mm_max_epu32(a.val, b.val));
-#else
-  __m128i delta = _mm_set1_epi32((int)0x80000000);
-  __m128i mask =
-      _mm_cmpgt_epi32(_mm_xor_si128(a.val, delta), _mm_xor_si128(b.val, delta));
-  return v_uint32x4(v_select_si128(mask, a.val, b.val));
-#endif
-}
-inline v_int32x4 v_min(const v_int32x4 &a, const v_int32x4 &b) {
-#if CV_SSE4_1
-  return v_int32x4(_mm_min_epi32(a.val, b.val));
-#else
-  return v_int32x4(v_select_si128(_mm_cmpgt_epi32(a.val, b.val), b.val, a.val));
-#endif
-}
-inline v_int32x4 v_max(const v_int32x4 &a, const v_int32x4 &b) {
-#if CV_SSE4_1
-  return v_int32x4(_mm_max_epi32(a.val, b.val));
-#else
-  return v_int32x4(v_select_si128(_mm_cmpgt_epi32(a.val, b.val), a.val, b.val));
-#endif
-}
-
-#define OPENCV_HAL_IMPL_SSE_INT_CMP_OP(_Tpuvec, _Tpsvec, suffix, sbit)         \
-  inline _Tpuvec v_eq(const _Tpuvec &a, const _Tpuvec &b) {                    \
-    return _Tpuvec(_mm_cmpeq_##suffix(a.val, b.val));                          \
-  }                                                                            \
-  inline _Tpuvec v_ne(const _Tpuvec &a, const _Tpuvec &b) {                    \
-    __m128i not_mask = _mm_set1_epi32(-1);                                     \
-    return _Tpuvec(_mm_xor_si128(_mm_cmpeq_##suffix(a.val, b.val), not_mask)); \
-  }                                                                            \
-  inline _Tpsvec v_eq(const _Tpsvec &a, const _Tpsvec &b) {                    \
-    return _Tpsvec(_mm_cmpeq_##suffix(a.val, b.val));                          \
-  }                                                                            \
-  inline _Tpsvec v_ne(const _Tpsvec &a, const _Tpsvec &b) {                    \
-    __m128i not_mask = _mm_set1_epi32(-1);                                     \
-    return _Tpsvec(_mm_xor_si128(_mm_cmpeq_##suffix(a.val, b.val), not_mask)); \
-  }                                                                            \
-  inline _Tpuvec v_lt(const _Tpuvec &a, const _Tpuvec &b) {                    \
-    __m128i smask = _mm_set1_##suffix(sbit);                                   \
-    return _Tpuvec(_mm_cmpgt_##suffix(_mm_xor_si128(b.val, smask),             \
-                                      _mm_xor_si128(a.val, smask)));           \
-  }                                                                            \
-  inline _Tpuvec v_gt(const _Tpuvec &a, const _Tpuvec &b) {                    \
-    __m128i smask = _mm_set1_##suffix(sbit);                                   \
-    return _Tpuvec(_mm_cmpgt_##suffix(_mm_xor_si128(a.val, smask),             \
-                                      _mm_xor_si128(b.val, smask)));           \
-  }                                                                            \
-  inline _Tpuvec v_le(const _Tpuvec &a, const _Tpuvec &b) {                    \
-    __m128i smask = _mm_set1_##suffix(sbit);                                   \
-    __m128i not_mask = _mm_set1_epi32(-1);                                     \
-    __m128i res = _mm_cmpgt_##suffix(_mm_xor_si128(a.val, smask),              \
-                                     _mm_xor_si128(b.val, smask));             \
-    return _Tpuvec(_mm_xor_si128(res, not_mask));                              \
-  }                                                                            \
-  inline _Tpuvec v_ge(const _Tpuvec &a, const _Tpuvec &b) {                    \
-    __m128i smask = _mm_set1_##suffix(sbit);                                   \
-    __m128i not_mask = _mm_set1_epi32(-1);                                     \
-    __m128i res = _mm_cmpgt_##suffix(_mm_xor_si128(b.val, smask),              \
-                                     _mm_xor_si128(a.val, smask));             \
-    return _Tpuvec(_mm_xor_si128(res, not_mask));                              \
-  }                                                                            \
-  inline _Tpsvec v_lt(const _Tpsvec &a, const _Tpsvec &b) {                    \
-    return _Tpsvec(_mm_cmpgt_##suffix(b.val, a.val));                          \
-  }                                                                            \
-  inline _Tpsvec v_gt(const _Tpsvec &a, const _Tpsvec &b) {                    \
-    return _Tpsvec(_mm_cmpgt_##suffix(a.val, b.val));                          \
-  }                                                                            \
-  inline _Tpsvec v_le(const _Tpsvec &a, const _Tpsvec &b) {                    \
-    __m128i not_mask = _mm_set1_epi32(-1);                                     \
-    return _Tpsvec(_mm_xor_si128(_mm_cmpgt_##suffix(a.val, b.val), not_mask)); \
-  }                                                                            \
-  inline _Tpsvec v_ge(const _Tpsvec &a, const _Tpsvec &b) {                    \
-    __m128i not_mask = _mm_set1_epi32(-1);                                     \
-    return _Tpsvec(_mm_xor_si128(_mm_cmpgt_##suffix(b.val, a.val), not_mask)); \
-  }
-
-OPENCV_HAL_IMPL_SSE_INT_CMP_OP(v_uint8x16, v_int8x16, epi8, (char)-128)
-OPENCV_HAL_IMPL_SSE_INT_CMP_OP(v_uint16x8, v_int16x8, epi16, (short)-32768)
-OPENCV_HAL_IMPL_SSE_INT_CMP_OP(v_uint32x4, v_int32x4, epi32, (int)0x80000000)
-
-#define OPENCV_HAL_IMPL_SSE_FLT_CMP_OP(_Tpvec, suffix)                         \
-  inline _Tpvec v_eq(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(_mm_cmpeq_##suffix(a.val, b.val));                           \
-  }                                                                            \
-  inline _Tpvec v_ne(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(_mm_cmpneq_##suffix(a.val, b.val));                          \
-  }                                                                            \
-  inline _Tpvec v_lt(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(_mm_cmplt_##suffix(a.val, b.val));                           \
-  }                                                                            \
-  inline _Tpvec v_gt(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(_mm_cmpgt_##suffix(a.val, b.val));                           \
-  }                                                                            \
-  inline _Tpvec v_le(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(_mm_cmple_##suffix(a.val, b.val));                           \
-  }                                                                            \
-  inline _Tpvec v_ge(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(_mm_cmpge_##suffix(a.val, b.val));                           \
-  }
-
-OPENCV_HAL_IMPL_SSE_FLT_CMP_OP(v_float32x4, ps)
-OPENCV_HAL_IMPL_SSE_FLT_CMP_OP(v_float64x2, pd)
-
-#if CV_SSE4_1
-#define OPENCV_HAL_IMPL_SSE_64BIT_CMP_OP(_Tpvec)                               \
-  inline _Tpvec v_eq(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(_mm_cmpeq_epi64(a.val, b.val));                              \
-  }                                                                            \
-  inline _Tpvec v_ne(const _Tpvec &a, const _Tpvec &b) {                       \
-    return v_not(v_eq(a, b));                                                  \
-  }
-#else
-#define OPENCV_HAL_IMPL_SSE_64BIT_CMP_OP(_Tpvec)                               \
-  inline _Tpvec v_eq(const _Tpvec &a, const _Tpvec &b) {                       \
-    __m128i cmp = _mm_cmpeq_epi32(a.val, b.val);                               \
-    return _Tpvec(                                                             \
-        _mm_and_si128(cmp, _mm_shuffle_epi32(cmp, _MM_SHUFFLE(2, 3, 0, 1))));  \
-  }                                                                            \
-  inline _Tpvec v_ne(const _Tpvec &a, const _Tpvec &b) {                       \
-    return v_not(v_eq(a, b));                                                  \
-  }
-#endif
-
-OPENCV_HAL_IMPL_SSE_64BIT_CMP_OP(v_uint64x2)
-OPENCV_HAL_IMPL_SSE_64BIT_CMP_OP(v_int64x2)
-
-inline v_float32x4 v_not_nan(const v_float32x4 &a) {
-  return v_float32x4(_mm_cmpord_ps(a.val, a.val));
-}
-inline v_float64x2 v_not_nan(const v_float64x2 &a) {
-  return v_float64x2(_mm_cmpord_pd(a.val, a.val));
-}
-
-OPENCV_HAL_IMPL_SSE_BIN_FUNC(v_uint8x16, v_add_wrap, _mm_add_epi8)
-OPENCV_HAL_IMPL_SSE_BIN_FUNC(v_int8x16, v_add_wrap, _mm_add_epi8)
-OPENCV_HAL_IMPL_SSE_BIN_FUNC(v_uint16x8, v_add_wrap, _mm_add_epi16)
-OPENCV_HAL_IMPL_SSE_BIN_FUNC(v_int16x8, v_add_wrap, _mm_add_epi16)
-OPENCV_HAL_IMPL_SSE_BIN_FUNC(v_uint8x16, v_sub_wrap, _mm_sub_epi8)
-OPENCV_HAL_IMPL_SSE_BIN_FUNC(v_int8x16, v_sub_wrap, _mm_sub_epi8)
-OPENCV_HAL_IMPL_SSE_BIN_FUNC(v_uint16x8, v_sub_wrap, _mm_sub_epi16)
-OPENCV_HAL_IMPL_SSE_BIN_FUNC(v_int16x8, v_sub_wrap, _mm_sub_epi16)
-OPENCV_HAL_IMPL_SSE_BIN_FUNC(v_uint16x8, v_mul_wrap, _mm_mullo_epi16)
-OPENCV_HAL_IMPL_SSE_BIN_FUNC(v_int16x8, v_mul_wrap, _mm_mullo_epi16)
-
-inline v_uint8x16 v_mul_wrap(const v_uint8x16 &a, const v_uint8x16 &b) {
-  __m128i ad = _mm_srai_epi16(a.val, 8);
-  __m128i bd = _mm_srai_epi16(b.val, 8);
-  __m128i p0 = _mm_mullo_epi16(a.val, b.val);              // even
-  __m128i p1 = _mm_slli_epi16(_mm_mullo_epi16(ad, bd), 8); // odd
-  const __m128i b01 = _mm_set1_epi32(0xFF00FF00);
-  return v_uint8x16(_v128_blendv_epi8(p0, p1, b01));
-}
-inline v_int8x16 v_mul_wrap(const v_int8x16 &a, const v_int8x16 &b) {
-  return v_reinterpret_as_s8(
-      v_mul_wrap(v_reinterpret_as_u8(a), v_reinterpret_as_u8(b)));
-}
-
-/** Absolute difference **/
-
-inline v_uint8x16 v_absdiff(const v_uint8x16 &a, const v_uint8x16 &b) {
-  return v_add_wrap(v_sub(a, b), v_sub(b, a));
-}
-inline v_uint16x8 v_absdiff(const v_uint16x8 &a, const v_uint16x8 &b) {
-  return v_add_wrap(v_sub(a, b), v_sub(b, a));
-}
-inline v_uint32x4 v_absdiff(const v_uint32x4 &a, const v_uint32x4 &b) {
-  return v_sub(v_max(a, b), v_min(a, b));
-}
-
-inline v_uint8x16 v_absdiff(const v_int8x16 &a, const v_int8x16 &b) {
-  v_int8x16 d = v_sub_wrap(a, b);
-  v_int8x16 m = v_lt(a, b);
-  return v_reinterpret_as_u8(v_sub_wrap(v_xor(d, m), m));
-}
-inline v_uint16x8 v_absdiff(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_reinterpret_as_u16(v_sub_wrap(v_max(a, b), v_min(a, b)));
-}
-inline v_uint32x4 v_absdiff(const v_int32x4 &a, const v_int32x4 &b) {
-  v_int32x4 d = v_sub(a, b);
-  v_int32x4 m = v_lt(a, b);
-  return v_reinterpret_as_u32(v_sub(v_xor(d, m), m));
-}
-
-/** Saturating absolute difference **/
-inline v_int8x16 v_absdiffs(const v_int8x16 &a, const v_int8x16 &b) {
-  v_int8x16 d = v_sub(a, b);
-  v_int8x16 m = v_lt(a, b);
-  return v_sub(v_xor(d, m), m);
-}
-inline v_int16x8 v_absdiffs(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_sub(v_max(a, b), v_min(a, b));
-}
-
-inline v_int32x4 v_fma(const v_int32x4 &a, const v_int32x4 &b,
-                       const v_int32x4 &c) {
-  return v_add(v_mul(a, b), c);
-}
-
-inline v_int32x4 v_muladd(const v_int32x4 &a, const v_int32x4 &b,
-                          const v_int32x4 &c) {
-  return v_fma(a, b, c);
-}
-
-inline v_float32x4 v_fma(const v_float32x4 &a, const v_float32x4 &b,
-                         const v_float32x4 &c) {
-#if CV_FMA3
-  return v_float32x4(_mm_fmadd_ps(a.val, b.val, c.val));
-#else
-  return v_float32x4(_mm_add_ps(_mm_mul_ps(a.val, b.val), c.val));
-#endif
-}
-
-inline v_float64x2 v_fma(const v_float64x2 &a, const v_float64x2 &b,
-                         const v_float64x2 &c) {
-#if CV_FMA3
-  return v_float64x2(_mm_fmadd_pd(a.val, b.val, c.val));
-#else
-  return v_float64x2(_mm_add_pd(_mm_mul_pd(a.val, b.val), c.val));
-#endif
-}
-
-#define OPENCV_HAL_IMPL_SSE_MISC_FLT_OP(_Tpvec, _Tp, _Tpreg, suffix,           \
-                                        absmask_vec)                           \
-  inline _Tpvec v_absdiff(const _Tpvec &a, const _Tpvec &b) {                  \
-    _Tpreg absmask = _mm_castsi128_##suffix(absmask_vec);                      \
-    return _Tpvec(_mm_and_##suffix(_mm_sub_##suffix(a.val, b.val), absmask));  \
-  }                                                                            \
-  inline _Tpvec v_magnitude(const _Tpvec &a, const _Tpvec &b) {                \
-    _Tpvec res = v_fma(a, a, v_mul(b, b));                                     \
-    return _Tpvec(_mm_sqrt_##suffix(res.val));                                 \
-  }                                                                            \
-  inline _Tpvec v_sqr_magnitude(const _Tpvec &a, const _Tpvec &b) {            \
-    return v_fma(a, a, v_mul(b, b));                                           \
-  }                                                                            \
-  inline _Tpvec v_muladd(const _Tpvec &a, const _Tpvec &b, const _Tpvec &c) {  \
-    return v_fma(a, b, c);                                                     \
-  }
-
-OPENCV_HAL_IMPL_SSE_MISC_FLT_OP(v_float32x4, float, __m128, ps,
-                                _mm_set1_epi32((int)0x7fffffff))
-OPENCV_HAL_IMPL_SSE_MISC_FLT_OP(v_float64x2, double, __m128d, pd,
-                                _mm_srli_epi64(_mm_set1_epi32(-1), 1))
-
-#define OPENCV_HAL_IMPL_SSE_SHIFT_OP(_Tpuvec, _Tpsvec, suffix, srai)           \
-  inline _Tpuvec v_shl(const _Tpuvec &a, int imm) {                            \
-    return _Tpuvec(_mm_slli_##suffix(a.val, imm));                             \
-  }                                                                            \
-  inline _Tpsvec v_shl(const _Tpsvec &a, int imm) {                            \
-    return _Tpsvec(_mm_slli_##suffix(a.val, imm));                             \
-  }                                                                            \
-  inline _Tpuvec v_shr(const _Tpuvec &a, int imm) {                            \
-    return _Tpuvec(_mm_srli_##suffix(a.val, imm));                             \
-  }                                                                            \
-  inline _Tpsvec v_shr(const _Tpsvec &a, int imm) {                            \
-    return _Tpsvec(srai(a.val, imm));                                          \
-  }                                                                            \
-  template <int imm> inline _Tpuvec v_shl(const _Tpuvec &a) {                  \
-    return _Tpuvec(_mm_slli_##suffix(a.val, imm));                             \
-  }                                                                            \
-  template <int imm> inline _Tpsvec v_shl(const _Tpsvec &a) {                  \
-    return _Tpsvec(_mm_slli_##suffix(a.val, imm));                             \
-  }                                                                            \
-  template <int imm> inline _Tpuvec v_shr(const _Tpuvec &a) {                  \
-    return _Tpuvec(_mm_srli_##suffix(a.val, imm));                             \
-  }                                                                            \
-  template <int imm> inline _Tpsvec v_shr(const _Tpsvec &a) {                  \
-    return _Tpsvec(srai(a.val, imm));                                          \
-  }
-
-OPENCV_HAL_IMPL_SSE_SHIFT_OP(v_uint16x8, v_int16x8, epi16, _mm_srai_epi16)
-OPENCV_HAL_IMPL_SSE_SHIFT_OP(v_uint32x4, v_int32x4, epi32, _mm_srai_epi32)
-OPENCV_HAL_IMPL_SSE_SHIFT_OP(v_uint64x2, v_int64x2, epi64, v_srai_epi64)
-
-namespace hal_sse_internal {
-template <int imm, bool is_invalid = ((imm < 0) || (imm > 16)),
-          bool is_first = (imm == 0), bool is_half = (imm == 8),
-          bool is_second = (imm == 16),
-          bool is_other =
-              (((imm > 0) && (imm < 8)) || ((imm > 8) && (imm < 16)))>
-class v_sse_palignr_u8_class;
-
-template <int imm>
-class v_sse_palignr_u8_class<imm, true, false, false, false, false>;
-
-template <int imm>
-class v_sse_palignr_u8_class<imm, false, true, false, false, false> {
-public:
-  inline __m128i operator()(const __m128i &a, const __m128i &) const {
-    return a;
-  }
-};
-
-template <int imm>
-class v_sse_palignr_u8_class<imm, false, false, true, false, false> {
-public:
-  inline __m128i operator()(const __m128i &a, const __m128i &b) const {
-    return _mm_unpacklo_epi64(_mm_unpackhi_epi64(a, a), b);
-  }
-};
-
-template <int imm>
-class v_sse_palignr_u8_class<imm, false, false, false, true, false> {
-public:
-  inline __m128i operator()(const __m128i &, const __m128i &b) const {
-    return b;
-  }
-};
-
-template <int imm>
-class v_sse_palignr_u8_class<imm, false, false, false, false, true> {
-#if CV_SSSE3
-public:
-  inline __m128i operator()(const __m128i &a, const __m128i &b) const {
-    return _mm_alignr_epi8(b, a, imm);
-  }
-#else
-public:
-  inline __m128i operator()(const __m128i &a, const __m128i &b) const {
-    enum { imm2 = (sizeof(__m128i) - imm) };
-    return _mm_or_si128(_mm_srli_si128(a, imm), _mm_slli_si128(b, imm2));
-  }
-#endif
-};
-
-template <int imm>
-inline __m128i v_sse_palignr_u8(const __m128i &a, const __m128i &b) {
-  CV_StaticAssert((imm >= 0) && (imm <= 16),
-                  "Invalid imm for v_sse_palignr_u8.");
-  return v_sse_palignr_u8_class<imm>()(a, b);
-}
-} // namespace hal_sse_internal
-
-template <int imm, typename _Tpvec>
-inline _Tpvec v_rotate_right(const _Tpvec &a) {
-  using namespace hal_sse_internal;
-  enum { imm2 = (imm * sizeof(typename _Tpvec::lane_type)) };
-  return _Tpvec(v_sse_reinterpret_as<typename _Tpvec::vector_type>(
-      _mm_srli_si128(v_sse_reinterpret_as<__m128i>(a.val), imm2)));
-}
-
-template <int imm, typename _Tpvec>
-inline _Tpvec v_rotate_left(const _Tpvec &a) {
-  using namespace hal_sse_internal;
-  enum { imm2 = (imm * sizeof(typename _Tpvec::lane_type)) };
-  return _Tpvec(v_sse_reinterpret_as<typename _Tpvec::vector_type>(
-      _mm_slli_si128(v_sse_reinterpret_as<__m128i>(a.val), imm2)));
-}
-
-template <int imm, typename _Tpvec>
-inline _Tpvec v_rotate_right(const _Tpvec &a, const _Tpvec &b) {
-  using namespace hal_sse_internal;
-  enum { imm2 = (imm * sizeof(typename _Tpvec::lane_type)) };
-  return _Tpvec(v_sse_reinterpret_as<typename _Tpvec::vector_type>(
-      v_sse_palignr_u8<imm2>(v_sse_reinterpret_as<__m128i>(a.val),
-                             v_sse_reinterpret_as<__m128i>(b.val))));
-}
-
-template <int imm, typename _Tpvec>
-inline _Tpvec v_rotate_left(const _Tpvec &a, const _Tpvec &b) {
-  using namespace hal_sse_internal;
-  enum { imm2 = ((_Tpvec::nlanes - imm) * sizeof(typename _Tpvec::lane_type)) };
-  return _Tpvec(v_sse_reinterpret_as<typename _Tpvec::vector_type>(
-      v_sse_palignr_u8<imm2>(v_sse_reinterpret_as<__m128i>(b.val),
-                             v_sse_reinterpret_as<__m128i>(a.val))));
-}
-
-#define OPENCV_HAL_IMPL_SSE_LOADSTORE_INT_OP(_Tpvec, _Tp)                      \
-  inline _Tpvec v_load(const _Tp *ptr) {                                       \
-    return _Tpvec(_mm_loadu_si128((const __m128i *)ptr));                      \
-  }                                                                            \
-  inline _Tpvec v_load_aligned(const _Tp *ptr) {                               \
-    return _Tpvec(_mm_load_si128((const __m128i *)ptr));                       \
-  }                                                                            \
-  inline _Tpvec v_load_low(const _Tp *ptr) {                                   \
-    return _Tpvec(_mm_loadl_epi64((const __m128i *)ptr));                      \
-  }                                                                            \
-  inline _Tpvec v_load_halves(const _Tp *ptr0, const _Tp *ptr1) {              \
-    return _Tpvec(_mm_unpacklo_epi64(_mm_loadl_epi64((const __m128i *)ptr0),   \
-                                     _mm_loadl_epi64((const __m128i *)ptr1))); \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a) {                             \
-    _mm_storeu_si128((__m128i *)ptr, a.val);                                   \
-  }                                                                            \
-  inline void v_store_aligned(_Tp *ptr, const _Tpvec &a) {                     \
-    _mm_store_si128((__m128i *)ptr, a.val);                                    \
-  }                                                                            \
-  inline void v_store_aligned_nocache(_Tp *ptr, const _Tpvec &a) {             \
-    _mm_stream_si128((__m128i *)ptr, a.val);                                   \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a, hal::StoreMode mode) {        \
-    if (mode == hal::STORE_UNALIGNED)                                          \
-      _mm_storeu_si128((__m128i *)ptr, a.val);                                 \
-    else if (mode == hal::STORE_ALIGNED_NOCACHE)                               \
-      _mm_stream_si128((__m128i *)ptr, a.val);                                 \
-    else                                                                       \
-      _mm_store_si128((__m128i *)ptr, a.val);                                  \
-  }                                                                            \
-  inline void v_store_low(_Tp *ptr, const _Tpvec &a) {                         \
-    _mm_storel_epi64((__m128i *)ptr, a.val);                                   \
-  }                                                                            \
-  inline void v_store_high(_Tp *ptr, const _Tpvec &a) {                        \
-    _mm_storel_epi64((__m128i *)ptr, _mm_unpackhi_epi64(a.val, a.val));        \
-  }
-
-OPENCV_HAL_IMPL_SSE_LOADSTORE_INT_OP(v_uint8x16, uchar)
-OPENCV_HAL_IMPL_SSE_LOADSTORE_INT_OP(v_int8x16, schar)
-OPENCV_HAL_IMPL_SSE_LOADSTORE_INT_OP(v_uint16x8, ushort)
-OPENCV_HAL_IMPL_SSE_LOADSTORE_INT_OP(v_int16x8, short)
-OPENCV_HAL_IMPL_SSE_LOADSTORE_INT_OP(v_uint32x4, unsigned)
-OPENCV_HAL_IMPL_SSE_LOADSTORE_INT_OP(v_int32x4, int)
-OPENCV_HAL_IMPL_SSE_LOADSTORE_INT_OP(v_uint64x2, uint64)
-OPENCV_HAL_IMPL_SSE_LOADSTORE_INT_OP(v_int64x2, int64)
-
-#define OPENCV_HAL_IMPL_SSE_LOADSTORE_FLT_OP(_Tpvec, _Tp, suffix)              \
-  inline _Tpvec v_load(const _Tp *ptr) {                                       \
-    return _Tpvec(_mm_loadu_##suffix(ptr));                                    \
-  }                                                                            \
-  inline _Tpvec v_load_aligned(const _Tp *ptr) {                               \
-    return _Tpvec(_mm_load_##suffix(ptr));                                     \
-  }                                                                            \
-  inline _Tpvec v_load_low(const _Tp *ptr) {                                   \
-    return _Tpvec(                                                             \
-        _mm_castsi128_##suffix(_mm_loadl_epi64((const __m128i *)ptr)));        \
-  }                                                                            \
-  inline _Tpvec v_load_halves(const _Tp *ptr0, const _Tp *ptr1) {              \
-    return _Tpvec(_mm_castsi128_##suffix(                                      \
-        _mm_unpacklo_epi64(_mm_loadl_epi64((const __m128i *)ptr0),             \
-                           _mm_loadl_epi64((const __m128i *)ptr1))));          \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a) {                             \
-    _mm_storeu_##suffix(ptr, a.val);                                           \
-  }                                                                            \
-  inline void v_store_aligned(_Tp *ptr, const _Tpvec &a) {                     \
-    _mm_store_##suffix(ptr, a.val);                                            \
-  }                                                                            \
-  inline void v_store_aligned_nocache(_Tp *ptr, const _Tpvec &a) {             \
-    _mm_stream_##suffix(ptr, a.val);                                           \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a, hal::StoreMode mode) {        \
-    if (mode == hal::STORE_UNALIGNED)                                          \
-      _mm_storeu_##suffix(ptr, a.val);                                         \
-    else if (mode == hal::STORE_ALIGNED_NOCACHE)                               \
-      _mm_stream_##suffix(ptr, a.val);                                         \
-    else                                                                       \
-      _mm_store_##suffix(ptr, a.val);                                          \
-  }                                                                            \
-  inline void v_store_low(_Tp *ptr, const _Tpvec &a) {                         \
-    _mm_storel_epi64((__m128i *)ptr, _mm_cast##suffix##_si128(a.val));         \
-  }                                                                            \
-  inline void v_store_high(_Tp *ptr, const _Tpvec &a) {                        \
-    __m128i a1 = _mm_cast##suffix##_si128(a.val);                              \
-    _mm_storel_epi64((__m128i *)ptr, _mm_unpackhi_epi64(a1, a1));              \
-  }
-
-OPENCV_HAL_IMPL_SSE_LOADSTORE_FLT_OP(v_float32x4, float, ps)
-OPENCV_HAL_IMPL_SSE_LOADSTORE_FLT_OP(v_float64x2, double, pd)
-
-inline unsigned v_reduce_sum(const v_uint8x16 &a) {
-  __m128i half = _mm_sad_epu8(a.val, _mm_setzero_si128());
-  return (unsigned)_mm_cvtsi128_si32(
-      _mm_add_epi32(half, _mm_unpackhi_epi64(half, half)));
-}
-inline int v_reduce_sum(const v_int8x16 &a) {
-  __m128i half = _mm_set1_epi8((schar)-128);
-  half = _mm_sad_epu8(_mm_xor_si128(a.val, half), _mm_setzero_si128());
-  return _mm_cvtsi128_si32(
-             _mm_add_epi32(half, _mm_unpackhi_epi64(half, half))) -
-         2048;
-}
-#define OPENCV_HAL_IMPL_SSE_REDUCE_OP_16(func)                                 \
-  inline schar v_reduce_##func(const v_int8x16 &a) {                           \
-    __m128i val = a.val;                                                       \
-    __m128i smask = _mm_set1_epi8((schar) - 128);                              \
-    val = _mm_xor_si128(val, smask);                                           \
-    val = _mm_##func##_epu8(val, _mm_srli_si128(val, 8));                      \
-    val = _mm_##func##_epu8(val, _mm_srli_si128(val, 4));                      \
-    val = _mm_##func##_epu8(val, _mm_srli_si128(val, 2));                      \
-    val = _mm_##func##_epu8(val, _mm_srli_si128(val, 1));                      \
-    return (schar)_mm_cvtsi128_si32(val) ^ (schar) - 128;                      \
-  }                                                                            \
-  inline uchar v_reduce_##func(const v_uint8x16 &a) {                          \
-    __m128i val = a.val;                                                       \
-    val = _mm_##func##_epu8(val, _mm_srli_si128(val, 8));                      \
-    val = _mm_##func##_epu8(val, _mm_srli_si128(val, 4));                      \
-    val = _mm_##func##_epu8(val, _mm_srli_si128(val, 2));                      \
-    val = _mm_##func##_epu8(val, _mm_srli_si128(val, 1));                      \
-    return (uchar)_mm_cvtsi128_si32(val);                                      \
-  }
-OPENCV_HAL_IMPL_SSE_REDUCE_OP_16(max)
-OPENCV_HAL_IMPL_SSE_REDUCE_OP_16(min)
-
-#define OPENCV_HAL_IMPL_SSE_REDUCE_OP_8(_Tpvec, scalartype, func, suffix,      \
-                                        sbit)                                  \
-  inline scalartype v_reduce_##func(const v_##_Tpvec &a) {                     \
-    __m128i val = a.val;                                                       \
-    val = _mm_##func##_##suffix(val, _mm_srli_si128(val, 8));                  \
-    val = _mm_##func##_##suffix(val, _mm_srli_si128(val, 4));                  \
-    val = _mm_##func##_##suffix(val, _mm_srli_si128(val, 2));                  \
-    return (scalartype)_mm_cvtsi128_si32(val);                                 \
-  }                                                                            \
-  inline unsigned scalartype v_reduce_##func(const v_u##_Tpvec &a) {           \
-    __m128i val = a.val;                                                       \
-    __m128i smask = _mm_set1_epi16(sbit);                                      \
-    val = _mm_xor_si128(val, smask);                                           \
-    val = _mm_##func##_##suffix(val, _mm_srli_si128(val, 8));                  \
-    val = _mm_##func##_##suffix(val, _mm_srli_si128(val, 4));                  \
-    val = _mm_##func##_##suffix(val, _mm_srli_si128(val, 2));                  \
-    return (unsigned scalartype)(_mm_cvtsi128_si32(val) ^ sbit);               \
-  }
-OPENCV_HAL_IMPL_SSE_REDUCE_OP_8(int16x8, short, max, epi16, (short)-32768)
-OPENCV_HAL_IMPL_SSE_REDUCE_OP_8(int16x8, short, min, epi16, (short)-32768)
-
-#define OPENCV_HAL_IMPL_SSE_REDUCE_OP_4_SUM(                                   \
-    _Tpvec, scalartype, regtype, suffix, cast_from, cast_to, extract)          \
-  inline scalartype v_reduce_sum(const _Tpvec &a) {                            \
-    regtype val = a.val;                                                       \
-    val = _mm_add_##suffix(val, cast_to(_mm_srli_si128(cast_from(val), 8)));   \
-    val = _mm_add_##suffix(val, cast_to(_mm_srli_si128(cast_from(val), 4)));   \
-    return (scalartype)_mm_cvt##extract(val);                                  \
-  }
-
-#define OPENCV_HAL_IMPL_SSE_REDUCE_OP_4(_Tpvec, scalartype, func, scalar_func) \
-  inline scalartype v_reduce_##func(const _Tpvec &a) {                         \
-    scalartype CV_DECL_ALIGNED(16) buf[4];                                     \
-    v_store_aligned(buf, a);                                                   \
-    scalartype s0 = scalar_func(buf[0], buf[1]);                               \
-    scalartype s1 = scalar_func(buf[2], buf[3]);                               \
-    return scalar_func(s0, s1);                                                \
-  }
-
-OPENCV_HAL_IMPL_SSE_REDUCE_OP_4_SUM(v_uint32x4, unsigned, __m128i, epi32,
-                                    OPENCV_HAL_NOP, OPENCV_HAL_NOP, si128_si32)
-OPENCV_HAL_IMPL_SSE_REDUCE_OP_4_SUM(v_int32x4, int, __m128i, epi32,
-                                    OPENCV_HAL_NOP, OPENCV_HAL_NOP, si128_si32)
-OPENCV_HAL_IMPL_SSE_REDUCE_OP_4_SUM(v_float32x4, float, __m128, ps,
-                                    _mm_castps_si128, _mm_castsi128_ps, ss_f32)
-
-inline int v_reduce_sum(const v_int16x8 &a) {
-  return v_reduce_sum(v_add(v_expand_low(a), v_expand_high(a)));
-}
-inline unsigned v_reduce_sum(const v_uint16x8 &a) {
-  return v_reduce_sum(v_add(v_expand_low(a), v_expand_high(a)));
-}
-
-inline uint64 v_reduce_sum(const v_uint64x2 &a) {
-  uint64 CV_DECL_ALIGNED(32) idx[2];
-  v_store_aligned(idx, a);
-  return idx[0] + idx[1];
-}
-inline int64 v_reduce_sum(const v_int64x2 &a) {
-  int64 CV_DECL_ALIGNED(32) idx[2];
-  v_store_aligned(idx, a);
-  return idx[0] + idx[1];
-}
-inline double v_reduce_sum(const v_float64x2 &a) {
-  double CV_DECL_ALIGNED(32) idx[2];
-  v_store_aligned(idx, a);
-  return idx[0] + idx[1];
-}
-
-inline v_float32x4 v_reduce_sum4(const v_float32x4 &a, const v_float32x4 &b,
-                                 const v_float32x4 &c, const v_float32x4 &d) {
-#if CV_SSE3
-  __m128 ab = _mm_hadd_ps(a.val, b.val);
-  __m128 cd = _mm_hadd_ps(c.val, d.val);
-  return v_float32x4(_mm_hadd_ps(ab, cd));
-#else
-  __m128 ac =
-      _mm_add_ps(_mm_unpacklo_ps(a.val, c.val), _mm_unpackhi_ps(a.val, c.val));
-  __m128 bd =
-      _mm_add_ps(_mm_unpacklo_ps(b.val, d.val), _mm_unpackhi_ps(b.val, d.val));
-  return v_float32x4(
-      _mm_add_ps(_mm_unpacklo_ps(ac, bd), _mm_unpackhi_ps(ac, bd)));
-#endif
-}
-
-OPENCV_HAL_IMPL_SSE_REDUCE_OP_4(v_uint32x4, unsigned, max, std::max)
-OPENCV_HAL_IMPL_SSE_REDUCE_OP_4(v_uint32x4, unsigned, min, std::min)
-OPENCV_HAL_IMPL_SSE_REDUCE_OP_4(v_int32x4, int, max, std::max)
-OPENCV_HAL_IMPL_SSE_REDUCE_OP_4(v_int32x4, int, min, std::min)
-OPENCV_HAL_IMPL_SSE_REDUCE_OP_4(v_float32x4, float, max, std::max)
-OPENCV_HAL_IMPL_SSE_REDUCE_OP_4(v_float32x4, float, min, std::min)
-
-inline unsigned v_reduce_sad(const v_uint8x16 &a, const v_uint8x16 &b) {
-  __m128i half = _mm_sad_epu8(a.val, b.val);
-  return (unsigned)_mm_cvtsi128_si32(
-      _mm_add_epi32(half, _mm_unpackhi_epi64(half, half)));
-}
-inline unsigned v_reduce_sad(const v_int8x16 &a, const v_int8x16 &b) {
-  __m128i half = _mm_set1_epi8(0x7f);
-  half = _mm_sad_epu8(_mm_add_epi8(a.val, half), _mm_add_epi8(b.val, half));
-  return (unsigned)_mm_cvtsi128_si32(
-      _mm_add_epi32(half, _mm_unpackhi_epi64(half, half)));
-}
-inline unsigned v_reduce_sad(const v_uint16x8 &a, const v_uint16x8 &b) {
-  v_uint32x4 l, h;
-  v_expand(v_absdiff(a, b), l, h);
-  return v_reduce_sum(v_add(l, h));
-}
-inline unsigned v_reduce_sad(const v_int16x8 &a, const v_int16x8 &b) {
-  v_uint32x4 l, h;
-  v_expand(v_absdiff(a, b), l, h);
-  return v_reduce_sum(v_add(l, h));
-}
-inline unsigned v_reduce_sad(const v_uint32x4 &a, const v_uint32x4 &b) {
-  return v_reduce_sum(v_absdiff(a, b));
-}
-inline unsigned v_reduce_sad(const v_int32x4 &a, const v_int32x4 &b) {
-  return v_reduce_sum(v_absdiff(a, b));
-}
-inline float v_reduce_sad(const v_float32x4 &a, const v_float32x4 &b) {
-  return v_reduce_sum(v_absdiff(a, b));
-}
-
-inline v_uint8x16 v_popcount(const v_uint8x16 &a) {
-  __m128i m1 = _mm_set1_epi32(0x55555555);
-  __m128i m2 = _mm_set1_epi32(0x33333333);
-  __m128i m4 = _mm_set1_epi32(0x0f0f0f0f);
-  __m128i p = a.val;
-  p = _mm_add_epi32(_mm_and_si128(_mm_srli_epi32(p, 1), m1),
-                    _mm_and_si128(p, m1));
-  p = _mm_add_epi32(_mm_and_si128(_mm_srli_epi32(p, 2), m2),
-                    _mm_and_si128(p, m2));
-  p = _mm_add_epi32(_mm_and_si128(_mm_srli_epi32(p, 4), m4),
-                    _mm_and_si128(p, m4));
-  return v_uint8x16(p);
-}
-inline v_uint16x8 v_popcount(const v_uint16x8 &a) {
-  v_uint8x16 p = v_popcount(v_reinterpret_as_u8(a));
-  p = v_add(p, v_rotate_right<1>(p));
-  return v_and(v_reinterpret_as_u16(p), v_setall_u16(0x00ff));
-}
-inline v_uint32x4 v_popcount(const v_uint32x4 &a) {
-  v_uint8x16 p = v_popcount(v_reinterpret_as_u8(a));
-  p = v_add(p, v_rotate_right<1>(p));
-  p = v_add(p, v_rotate_right<2>(p));
-  return v_and(v_reinterpret_as_u32(p), v_setall_u32(0x000000ff));
-}
-inline v_uint64x2 v_popcount(const v_uint64x2 &a) {
-  return v_uint64x2(_mm_sad_epu8(v_popcount(v_reinterpret_as_u8(a)).val,
-                                 _mm_setzero_si128()));
-}
-inline v_uint8x16 v_popcount(const v_int8x16 &a) {
-  return v_popcount(v_reinterpret_as_u8(a));
-}
-inline v_uint16x8 v_popcount(const v_int16x8 &a) {
-  return v_popcount(v_reinterpret_as_u16(a));
-}
-inline v_uint32x4 v_popcount(const v_int32x4 &a) {
-  return v_popcount(v_reinterpret_as_u32(a));
-}
-inline v_uint64x2 v_popcount(const v_int64x2 &a) {
-  return v_popcount(v_reinterpret_as_u64(a));
-}
-
-#define OPENCV_HAL_IMPL_SSE_CHECK_SIGNS(_Tpvec, suffix, cast_op, allmask)      \
-  inline int v_signmask(const _Tpvec &a) {                                     \
-    return _mm_movemask_##suffix(cast_op(a.val));                              \
-  }                                                                            \
-  inline bool v_check_all(const _Tpvec &a) {                                   \
-    return _mm_movemask_##suffix(cast_op(a.val)) == allmask;                   \
-  }                                                                            \
-  inline bool v_check_any(const _Tpvec &a) {                                   \
-    return _mm_movemask_##suffix(cast_op(a.val)) != 0;                         \
-  }
-OPENCV_HAL_IMPL_SSE_CHECK_SIGNS(v_uint8x16, epi8, OPENCV_HAL_NOP, 65535)
-OPENCV_HAL_IMPL_SSE_CHECK_SIGNS(v_int8x16, epi8, OPENCV_HAL_NOP, 65535)
-OPENCV_HAL_IMPL_SSE_CHECK_SIGNS(v_uint32x4, ps, _mm_castsi128_ps, 15)
-OPENCV_HAL_IMPL_SSE_CHECK_SIGNS(v_int32x4, ps, _mm_castsi128_ps, 15)
-OPENCV_HAL_IMPL_SSE_CHECK_SIGNS(v_uint64x2, pd, _mm_castsi128_pd, 3)
-OPENCV_HAL_IMPL_SSE_CHECK_SIGNS(v_int64x2, pd, _mm_castsi128_pd, 3)
-OPENCV_HAL_IMPL_SSE_CHECK_SIGNS(v_float32x4, ps, OPENCV_HAL_NOP, 15)
-OPENCV_HAL_IMPL_SSE_CHECK_SIGNS(v_float64x2, pd, OPENCV_HAL_NOP, 3)
-
-#define OPENCV_HAL_IMPL_SSE_CHECK_SIGNS_SHORT(_Tpvec)                          \
-  inline int v_signmask(const _Tpvec &a) {                                     \
-    return _mm_movemask_epi8(_mm_packs_epi16(a.val, a.val)) & 255;             \
-  }                                                                            \
-  inline bool v_check_all(const _Tpvec &a) {                                   \
-    return (_mm_movemask_epi8(a.val) & 0xaaaa) == 0xaaaa;                      \
-  }                                                                            \
-  inline bool v_check_any(const _Tpvec &a) {                                   \
-    return (_mm_movemask_epi8(a.val) & 0xaaaa) != 0;                           \
-  }
-OPENCV_HAL_IMPL_SSE_CHECK_SIGNS_SHORT(v_uint16x8)
-OPENCV_HAL_IMPL_SSE_CHECK_SIGNS_SHORT(v_int16x8)
-
-inline int v_scan_forward(const v_int8x16 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a)));
-}
-inline int v_scan_forward(const v_uint8x16 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a)));
-}
-inline int v_scan_forward(const v_int16x8 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 2;
-}
-inline int v_scan_forward(const v_uint16x8 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 2;
-}
-inline int v_scan_forward(const v_int32x4 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 4;
-}
-inline int v_scan_forward(const v_uint32x4 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 4;
-}
-inline int v_scan_forward(const v_float32x4 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 4;
-}
-inline int v_scan_forward(const v_int64x2 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 8;
-}
-inline int v_scan_forward(const v_uint64x2 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 8;
-}
-inline int v_scan_forward(const v_float64x2 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 8;
-}
-
-#if CV_SSE4_1
-#define OPENCV_HAL_IMPL_SSE_SELECT(_Tpvec, cast_ret, cast, suffix)             \
-  inline _Tpvec v_select(const _Tpvec &mask, const _Tpvec &a,                  \
-                         const _Tpvec &b) {                                    \
-    return _Tpvec(cast_ret(                                                    \
-        _mm_blendv_##suffix(cast(b.val), cast(a.val), cast(mask.val))));       \
-  }
-
-OPENCV_HAL_IMPL_SSE_SELECT(v_uint8x16, OPENCV_HAL_NOP, OPENCV_HAL_NOP, epi8)
-OPENCV_HAL_IMPL_SSE_SELECT(v_int8x16, OPENCV_HAL_NOP, OPENCV_HAL_NOP, epi8)
-OPENCV_HAL_IMPL_SSE_SELECT(v_uint16x8, OPENCV_HAL_NOP, OPENCV_HAL_NOP, epi8)
-OPENCV_HAL_IMPL_SSE_SELECT(v_int16x8, OPENCV_HAL_NOP, OPENCV_HAL_NOP, epi8)
-OPENCV_HAL_IMPL_SSE_SELECT(v_uint32x4, _mm_castps_si128, _mm_castsi128_ps, ps)
-OPENCV_HAL_IMPL_SSE_SELECT(v_int32x4, _mm_castps_si128, _mm_castsi128_ps, ps)
-// OPENCV_HAL_IMPL_SSE_SELECT(v_uint64x2, TBD, TBD, pd)
-// OPENCV_HAL_IMPL_SSE_SELECT(v_int64x2, TBD, TBD, ps)
-OPENCV_HAL_IMPL_SSE_SELECT(v_float32x4, OPENCV_HAL_NOP, OPENCV_HAL_NOP, ps)
-OPENCV_HAL_IMPL_SSE_SELECT(v_float64x2, OPENCV_HAL_NOP, OPENCV_HAL_NOP, pd)
-
-#else // CV_SSE4_1
-
-#define OPENCV_HAL_IMPL_SSE_SELECT(_Tpvec, suffix)                             \
-  inline _Tpvec v_select(const _Tpvec &mask, const _Tpvec &a,                  \
-                         const _Tpvec &b) {                                    \
-    return _Tpvec(_mm_xor_##suffix(                                            \
-        b.val, _mm_and_##suffix(_mm_xor_##suffix(b.val, a.val), mask.val)));   \
-  }
-
-OPENCV_HAL_IMPL_SSE_SELECT(v_uint8x16, si128)
-OPENCV_HAL_IMPL_SSE_SELECT(v_int8x16, si128)
-OPENCV_HAL_IMPL_SSE_SELECT(v_uint16x8, si128)
-OPENCV_HAL_IMPL_SSE_SELECT(v_int16x8, si128)
-OPENCV_HAL_IMPL_SSE_SELECT(v_uint32x4, si128)
-OPENCV_HAL_IMPL_SSE_SELECT(v_int32x4, si128)
-// OPENCV_HAL_IMPL_SSE_SELECT(v_uint64x2, si128)
-// OPENCV_HAL_IMPL_SSE_SELECT(v_int64x2, si128)
-OPENCV_HAL_IMPL_SSE_SELECT(v_float32x4, ps)
-OPENCV_HAL_IMPL_SSE_SELECT(v_float64x2, pd)
-#endif
-
-/* Expand */
-#define OPENCV_HAL_IMPL_SSE_EXPAND(_Tpvec, _Tpwvec, _Tp, intrin)               \
-  inline void v_expand(const _Tpvec &a, _Tpwvec &b0, _Tpwvec &b1) {            \
-    b0.val = intrin(a.val);                                                    \
-    b1.val = __CV_CAT(intrin, _high)(a.val);                                   \
-  }                                                                            \
-  inline _Tpwvec v_expand_low(const _Tpvec &a) {                               \
-    return _Tpwvec(intrin(a.val));                                             \
-  }                                                                            \
-  inline _Tpwvec v_expand_high(const _Tpvec &a) {                              \
-    return _Tpwvec(__CV_CAT(intrin, _high)(a.val));                            \
-  }                                                                            \
-  inline _Tpwvec v_load_expand(const _Tp *ptr) {                               \
-    __m128i a = _mm_loadl_epi64((const __m128i *)ptr);                         \
-    return _Tpwvec(intrin(a));                                                 \
-  }
-
-OPENCV_HAL_IMPL_SSE_EXPAND(v_uint8x16, v_uint16x8, uchar, _v128_cvtepu8_epi16)
-OPENCV_HAL_IMPL_SSE_EXPAND(v_int8x16, v_int16x8, schar, _v128_cvtepi8_epi16)
-OPENCV_HAL_IMPL_SSE_EXPAND(v_uint16x8, v_uint32x4, ushort, _v128_cvtepu16_epi32)
-OPENCV_HAL_IMPL_SSE_EXPAND(v_int16x8, v_int32x4, short, _v128_cvtepi16_epi32)
-OPENCV_HAL_IMPL_SSE_EXPAND(v_uint32x4, v_uint64x2, unsigned,
-                           _v128_cvtepu32_epi64)
-OPENCV_HAL_IMPL_SSE_EXPAND(v_int32x4, v_int64x2, int, _v128_cvtepi32_epi64)
-
-#define OPENCV_HAL_IMPL_SSE_EXPAND_Q(_Tpvec, _Tp, intrin)                      \
-  inline _Tpvec v_load_expand_q(const _Tp *ptr) {                              \
-    typedef int CV_DECL_ALIGNED(1) unaligned_int;                              \
-    __m128i a = _mm_cvtsi32_si128(*(const unaligned_int *)ptr);                \
-    return _Tpvec(intrin(a));                                                  \
-  }
-
-OPENCV_HAL_IMPL_SSE_EXPAND_Q(v_uint32x4, uchar, _v128_cvtepu8_epi32)
-OPENCV_HAL_IMPL_SSE_EXPAND_Q(v_int32x4, schar, _v128_cvtepi8_epi32)
-
-#define OPENCV_HAL_IMPL_SSE_UNPACKS(_Tpvec, suffix, cast_from, cast_to)        \
-  inline void v_zip(const _Tpvec &a0, const _Tpvec &a1, _Tpvec &b0,            \
-                    _Tpvec &b1) {                                              \
-    b0.val = _mm_unpacklo_##suffix(a0.val, a1.val);                            \
-    b1.val = _mm_unpackhi_##suffix(a0.val, a1.val);                            \
-  }                                                                            \
-  inline _Tpvec v_combine_low(const _Tpvec &a, const _Tpvec &b) {              \
-    __m128i a1 = cast_from(a.val), b1 = cast_from(b.val);                      \
-    return _Tpvec(cast_to(_mm_unpacklo_epi64(a1, b1)));                        \
-  }                                                                            \
-  inline _Tpvec v_combine_high(const _Tpvec &a, const _Tpvec &b) {             \
-    __m128i a1 = cast_from(a.val), b1 = cast_from(b.val);                      \
-    return _Tpvec(cast_to(_mm_unpackhi_epi64(a1, b1)));                        \
-  }                                                                            \
-  inline void v_recombine(const _Tpvec &a, const _Tpvec &b, _Tpvec &c,         \
-                          _Tpvec &d) {                                         \
-    __m128i a1 = cast_from(a.val), b1 = cast_from(b.val);                      \
-    c.val = cast_to(_mm_unpacklo_epi64(a1, b1));                               \
-    d.val = cast_to(_mm_unpackhi_epi64(a1, b1));                               \
-  }
-
-OPENCV_HAL_IMPL_SSE_UNPACKS(v_uint8x16, epi8, OPENCV_HAL_NOP, OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_SSE_UNPACKS(v_int8x16, epi8, OPENCV_HAL_NOP, OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_SSE_UNPACKS(v_uint16x8, epi16, OPENCV_HAL_NOP, OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_SSE_UNPACKS(v_int16x8, epi16, OPENCV_HAL_NOP, OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_SSE_UNPACKS(v_uint32x4, epi32, OPENCV_HAL_NOP, OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_SSE_UNPACKS(v_int32x4, epi32, OPENCV_HAL_NOP, OPENCV_HAL_NOP)
-OPENCV_HAL_IMPL_SSE_UNPACKS(v_float32x4, ps, _mm_castps_si128, _mm_castsi128_ps)
-OPENCV_HAL_IMPL_SSE_UNPACKS(v_float64x2, pd, _mm_castpd_si128, _mm_castsi128_pd)
-
-inline v_uint8x16 v_reverse(const v_uint8x16 &a) {
-#if CV_SSSE3
-  static const __m128i perm =
-      _mm_setr_epi8(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
-  return v_uint8x16(_mm_shuffle_epi8(a.val, perm));
-#else
-  uchar CV_DECL_ALIGNED(32) d[16];
-  v_store_aligned(d, a);
-  return v_uint8x16(d[15], d[14], d[13], d[12], d[11], d[10], d[9], d[8], d[7],
-                    d[6], d[5], d[4], d[3], d[2], d[1], d[0]);
-#endif
-}
-
-inline v_int8x16 v_reverse(const v_int8x16 &a) {
-  return v_reinterpret_as_s8(v_reverse(v_reinterpret_as_u8(a)));
-}
-
-inline v_uint16x8 v_reverse(const v_uint16x8 &a) {
-#if CV_SSSE3
-  static const __m128i perm =
-      _mm_setr_epi8(14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 0, 1);
-  return v_uint16x8(_mm_shuffle_epi8(a.val, perm));
-#else
-  __m128i r = _mm_shuffle_epi32(a.val, _MM_SHUFFLE(0, 1, 2, 3));
-  r = _mm_shufflelo_epi16(r, _MM_SHUFFLE(2, 3, 0, 1));
-  r = _mm_shufflehi_epi16(r, _MM_SHUFFLE(2, 3, 0, 1));
-  return v_uint16x8(r);
-#endif
-}
-
-inline v_int16x8 v_reverse(const v_int16x8 &a) {
-  return v_reinterpret_as_s16(v_reverse(v_reinterpret_as_u16(a)));
-}
-
-inline v_uint32x4 v_reverse(const v_uint32x4 &a) {
-  return v_uint32x4(_mm_shuffle_epi32(a.val, _MM_SHUFFLE(0, 1, 2, 3)));
-}
-
-inline v_int32x4 v_reverse(const v_int32x4 &a) {
-  return v_reinterpret_as_s32(v_reverse(v_reinterpret_as_u32(a)));
-}
-
-inline v_float32x4 v_reverse(const v_float32x4 &a) {
-  return v_reinterpret_as_f32(v_reverse(v_reinterpret_as_u32(a)));
-}
-
-inline v_uint64x2 v_reverse(const v_uint64x2 &a) {
-  return v_uint64x2(_mm_shuffle_epi32(a.val, _MM_SHUFFLE(1, 0, 3, 2)));
-}
-
-inline v_int64x2 v_reverse(const v_int64x2 &a) {
-  return v_reinterpret_as_s64(v_reverse(v_reinterpret_as_u64(a)));
-}
-
-inline v_float64x2 v_reverse(const v_float64x2 &a) {
-  return v_reinterpret_as_f64(v_reverse(v_reinterpret_as_u64(a)));
-}
-
-template <int s, typename _Tpvec>
-inline _Tpvec v_extract(const _Tpvec &a, const _Tpvec &b) {
-  return v_rotate_right<s>(a, b);
-}
-
-inline v_int32x4 v_round(const v_float32x4 &a) {
-  return v_int32x4(_mm_cvtps_epi32(a.val));
-}
-
-inline v_int32x4 v_floor(const v_float32x4 &a) {
-  __m128i a1 = _mm_cvtps_epi32(a.val);
-  __m128i mask = _mm_castps_si128(_mm_cmpgt_ps(_mm_cvtepi32_ps(a1), a.val));
-  return v_int32x4(_mm_add_epi32(a1, mask));
-}
-
-inline v_int32x4 v_ceil(const v_float32x4 &a) {
-  __m128i a1 = _mm_cvtps_epi32(a.val);
-  __m128i mask = _mm_castps_si128(_mm_cmpgt_ps(a.val, _mm_cvtepi32_ps(a1)));
-  return v_int32x4(_mm_sub_epi32(a1, mask));
-}
-
-inline v_int32x4 v_trunc(const v_float32x4 &a) {
-  return v_int32x4(_mm_cvttps_epi32(a.val));
-}
-
-inline v_int32x4 v_round(const v_float64x2 &a) {
-  return v_int32x4(_mm_cvtpd_epi32(a.val));
-}
-
-inline v_int32x4 v_round(const v_float64x2 &a, const v_float64x2 &b) {
-  __m128i ai = _mm_cvtpd_epi32(a.val), bi = _mm_cvtpd_epi32(b.val);
-  return v_int32x4(_mm_unpacklo_epi64(ai, bi));
-}
-
-inline v_int32x4 v_floor(const v_float64x2 &a) {
-  __m128i a1 = _mm_cvtpd_epi32(a.val);
-  __m128i mask = _mm_castpd_si128(_mm_cmpgt_pd(_mm_cvtepi32_pd(a1), a.val));
-  mask = _mm_srli_si128(_mm_slli_si128(mask, 4), 8); // m0 m0 m1 m1 => m0 m1 0 0
-  return v_int32x4(_mm_add_epi32(a1, mask));
-}
-
-inline v_int32x4 v_ceil(const v_float64x2 &a) {
-  __m128i a1 = _mm_cvtpd_epi32(a.val);
-  __m128i mask = _mm_castpd_si128(_mm_cmpgt_pd(a.val, _mm_cvtepi32_pd(a1)));
-  mask = _mm_srli_si128(_mm_slli_si128(mask, 4), 8); // m0 m0 m1 m1 => m0 m1 0 0
-  return v_int32x4(_mm_sub_epi32(a1, mask));
-}
-
-inline v_int32x4 v_trunc(const v_float64x2 &a) {
-  return v_int32x4(_mm_cvttpd_epi32(a.val));
-}
-
-#define OPENCV_HAL_IMPL_SSE_TRANSPOSE4x4(_Tpvec, suffix, cast_from, cast_to)   \
-  inline void v_transpose4x4(const _Tpvec &a0, const _Tpvec &a1,               \
-                             const _Tpvec &a2, const _Tpvec &a3, _Tpvec &b0,   \
-                             _Tpvec &b1, _Tpvec &b2, _Tpvec &b3) {             \
-    __m128i t0 = cast_from(_mm_unpacklo_##suffix(a0.val, a1.val));             \
-    __m128i t1 = cast_from(_mm_unpacklo_##suffix(a2.val, a3.val));             \
-    __m128i t2 = cast_from(_mm_unpackhi_##suffix(a0.val, a1.val));             \
-    __m128i t3 = cast_from(_mm_unpackhi_##suffix(a2.val, a3.val));             \
-                                                                               \
-    b0.val = cast_to(_mm_unpacklo_epi64(t0, t1));                              \
-    b1.val = cast_to(_mm_unpackhi_epi64(t0, t1));                              \
-    b2.val = cast_to(_mm_unpacklo_epi64(t2, t3));                              \
-    b3.val = cast_to(_mm_unpackhi_epi64(t2, t3));                              \
-  }
-
-OPENCV_HAL_IMPL_SSE_TRANSPOSE4x4(v_uint32x4, epi32, OPENCV_HAL_NOP,
-                                 OPENCV_HAL_NOP)
-    OPENCV_HAL_IMPL_SSE_TRANSPOSE4x4(v_int32x4, epi32, OPENCV_HAL_NOP,
-                                     OPENCV_HAL_NOP)
-        OPENCV_HAL_IMPL_SSE_TRANSPOSE4x4(v_float32x4, ps, _mm_castps_si128,
-                                         _mm_castsi128_ps)
-
-    // load deinterleave
-    inline void v_load_deinterleave(const uchar *ptr, v_uint8x16 &a,
-                                    v_uint8x16 &b) {
-  __m128i t00 = _mm_loadu_si128((const __m128i *)ptr);
-  __m128i t01 = _mm_loadu_si128((const __m128i *)(ptr + 16));
-
-  __m128i t10 = _mm_unpacklo_epi8(t00, t01);
-  __m128i t11 = _mm_unpackhi_epi8(t00, t01);
-
-  __m128i t20 = _mm_unpacklo_epi8(t10, t11);
-  __m128i t21 = _mm_unpackhi_epi8(t10, t11);
-
-  __m128i t30 = _mm_unpacklo_epi8(t20, t21);
-  __m128i t31 = _mm_unpackhi_epi8(t20, t21);
-
-  a.val = _mm_unpacklo_epi8(t30, t31);
-  b.val = _mm_unpackhi_epi8(t30, t31);
-}
-
-inline void v_load_deinterleave(const uchar *ptr, v_uint8x16 &a, v_uint8x16 &b,
-                                v_uint8x16 &c) {
-#if CV_SSE4_1
-  const __m128i m0 =
-      _mm_setr_epi8(0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0);
-  const __m128i m1 =
-      _mm_setr_epi8(0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0);
-  __m128i s0 = _mm_loadu_si128((const __m128i *)ptr);
-  __m128i s1 = _mm_loadu_si128((const __m128i *)(ptr + 16));
-  __m128i s2 = _mm_loadu_si128((const __m128i *)(ptr + 32));
-  __m128i a0 = _mm_blendv_epi8(_mm_blendv_epi8(s0, s1, m0), s2, m1);
-  __m128i b0 = _mm_blendv_epi8(_mm_blendv_epi8(s1, s2, m0), s0, m1);
-  __m128i c0 = _mm_blendv_epi8(_mm_blendv_epi8(s2, s0, m0), s1, m1);
-  const __m128i sh_b =
-      _mm_setr_epi8(0, 3, 6, 9, 12, 15, 2, 5, 8, 11, 14, 1, 4, 7, 10, 13);
-  const __m128i sh_g =
-      _mm_setr_epi8(1, 4, 7, 10, 13, 0, 3, 6, 9, 12, 15, 2, 5, 8, 11, 14);
-  const __m128i sh_r =
-      _mm_setr_epi8(2, 5, 8, 11, 14, 1, 4, 7, 10, 13, 0, 3, 6, 9, 12, 15);
-  a0 = _mm_shuffle_epi8(a0, sh_b);
-  b0 = _mm_shuffle_epi8(b0, sh_g);
-  c0 = _mm_shuffle_epi8(c0, sh_r);
-  a.val = a0;
-  b.val = b0;
-  c.val = c0;
-#elif CV_SSSE3
-  const __m128i m0 =
-      _mm_setr_epi8(0, 3, 6, 9, 12, 15, 1, 4, 7, 10, 13, 2, 5, 8, 11, 14);
-  const __m128i m1 = _mm_alignr_epi8(m0, m0, 11);
-  const __m128i m2 = _mm_alignr_epi8(m0, m0, 6);
-
-  __m128i t0 = _mm_loadu_si128((const __m128i *)ptr);
-  __m128i t1 = _mm_loadu_si128((const __m128i *)(ptr + 16));
-  __m128i t2 = _mm_loadu_si128((const __m128i *)(ptr + 32));
-
-  __m128i s0 = _mm_shuffle_epi8(t0, m0);
-  __m128i s1 = _mm_shuffle_epi8(t1, m1);
-  __m128i s2 = _mm_shuffle_epi8(t2, m2);
-
-  t0 = _mm_alignr_epi8(s1, _mm_slli_si128(s0, 10), 5);
-  a.val = _mm_alignr_epi8(s2, t0, 5);
-
-  t1 = _mm_alignr_epi8(_mm_srli_si128(s1, 5), _mm_slli_si128(s0, 5), 6);
-  b.val = _mm_alignr_epi8(_mm_srli_si128(s2, 5), t1, 5);
-
-  t2 = _mm_alignr_epi8(_mm_srli_si128(s2, 10), s1, 11);
-  c.val = _mm_alignr_epi8(t2, s0, 11);
-#else
-  __m128i t00 = _mm_loadu_si128((const __m128i *)ptr);
-  __m128i t01 = _mm_loadu_si128((const __m128i *)(ptr + 16));
-  __m128i t02 = _mm_loadu_si128((const __m128i *)(ptr + 32));
-
-  __m128i t10 = _mm_unpacklo_epi8(t00, _mm_unpackhi_epi64(t01, t01));
-  __m128i t11 = _mm_unpacklo_epi8(_mm_unpackhi_epi64(t00, t00), t02);
-  __m128i t12 = _mm_unpacklo_epi8(t01, _mm_unpackhi_epi64(t02, t02));
-
-  __m128i t20 = _mm_unpacklo_epi8(t10, _mm_unpackhi_epi64(t11, t11));
-  __m128i t21 = _mm_unpacklo_epi8(_mm_unpackhi_epi64(t10, t10), t12);
-  __m128i t22 = _mm_unpacklo_epi8(t11, _mm_unpackhi_epi64(t12, t12));
-
-  __m128i t30 = _mm_unpacklo_epi8(t20, _mm_unpackhi_epi64(t21, t21));
-  __m128i t31 = _mm_unpacklo_epi8(_mm_unpackhi_epi64(t20, t20), t22);
-  __m128i t32 = _mm_unpacklo_epi8(t21, _mm_unpackhi_epi64(t22, t22));
-
-  a.val = _mm_unpacklo_epi8(t30, _mm_unpackhi_epi64(t31, t31));
-  b.val = _mm_unpacklo_epi8(_mm_unpackhi_epi64(t30, t30), t32);
-  c.val = _mm_unpacklo_epi8(t31, _mm_unpackhi_epi64(t32, t32));
-#endif
-}
-
-inline void v_load_deinterleave(const uchar *ptr, v_uint8x16 &a, v_uint8x16 &b,
-                                v_uint8x16 &c, v_uint8x16 &d) {
-  __m128i u0 =
-      _mm_loadu_si128((const __m128i *)ptr); // a0 b0 c0 d0 a1 b1 c1 d1 ...
-  __m128i u1 = _mm_loadu_si128((const __m128i *)(ptr + 16)); // a4 b4 c4 d4 ...
-  __m128i u2 = _mm_loadu_si128((const __m128i *)(ptr + 32)); // a8 b8 c8 d8 ...
-  __m128i u3 =
-      _mm_loadu_si128((const __m128i *)(ptr + 48)); // a12 b12 c12 d12 ...
-
-  __m128i v0 = _mm_unpacklo_epi8(u0, u2); // a0 a8 b0 b8 ...
-  __m128i v1 = _mm_unpackhi_epi8(u0, u2); // a2 a10 b2 b10 ...
-  __m128i v2 = _mm_unpacklo_epi8(u1, u3); // a4 a12 b4 b12 ...
-  __m128i v3 = _mm_unpackhi_epi8(u1, u3); // a6 a14 b6 b14 ...
-
-  u0 = _mm_unpacklo_epi8(v0, v2); // a0 a4 a8 a12 ...
-  u1 = _mm_unpacklo_epi8(v1, v3); // a2 a6 a10 a14 ...
-  u2 = _mm_unpackhi_epi8(v0, v2); // a1 a5 a9 a13 ...
-  u3 = _mm_unpackhi_epi8(v1, v3); // a3 a7 a11 a15 ...
-
-  v0 = _mm_unpacklo_epi8(u0, u1); // a0 a2 a4 a6 ...
-  v1 = _mm_unpacklo_epi8(u2, u3); // a1 a3 a5 a7 ...
-  v2 = _mm_unpackhi_epi8(u0, u1); // c0 c2 c4 c6 ...
-  v3 = _mm_unpackhi_epi8(u2, u3); // c1 c3 c5 c7 ...
-
-  a.val = _mm_unpacklo_epi8(v0, v1);
-  b.val = _mm_unpackhi_epi8(v0, v1);
-  c.val = _mm_unpacklo_epi8(v2, v3);
-  d.val = _mm_unpackhi_epi8(v2, v3);
-}
-
-inline void v_load_deinterleave(const ushort *ptr, v_uint16x8 &a,
-                                v_uint16x8 &b) {
-  __m128i v0 = _mm_loadu_si128((__m128i *)(ptr));     // a0 b0 a1 b1 a2 b2 a3 b3
-  __m128i v1 = _mm_loadu_si128((__m128i *)(ptr + 8)); // a4 b4 a5 b5 a6 b6 a7 b7
-
-  __m128i v2 = _mm_unpacklo_epi16(v0, v1); // a0 a4 b0 b4 a1 a5 b1 b5
-  __m128i v3 = _mm_unpackhi_epi16(v0, v1); // a2 a6 b2 b6 a3 a7 b3 b7
-  __m128i v4 = _mm_unpacklo_epi16(v2, v3); // a0 a2 a4 a6 b0 b2 b4 b6
-  __m128i v5 = _mm_unpackhi_epi16(v2, v3); // a1 a3 a5 a7 b1 b3 b5 b7
-
-  a.val = _mm_unpacklo_epi16(v4, v5); // a0 a1 a2 a3 a4 a5 a6 a7
-  b.val = _mm_unpackhi_epi16(v4, v5); // b0 b1 ab b3 b4 b5 b6 b7
-}
-
-inline void v_load_deinterleave(const ushort *ptr, v_uint16x8 &a, v_uint16x8 &b,
-                                v_uint16x8 &c) {
-#if CV_SSE4_1
-  __m128i v0 = _mm_loadu_si128((__m128i *)(ptr));
-  __m128i v1 = _mm_loadu_si128((__m128i *)(ptr + 8));
-  __m128i v2 = _mm_loadu_si128((__m128i *)(ptr + 16));
-  __m128i a0 = _mm_blend_epi16(_mm_blend_epi16(v0, v1, 0x92), v2, 0x24);
-  __m128i b0 = _mm_blend_epi16(_mm_blend_epi16(v2, v0, 0x92), v1, 0x24);
-  __m128i c0 = _mm_blend_epi16(_mm_blend_epi16(v1, v2, 0x92), v0, 0x24);
-
-  const __m128i sh_a =
-      _mm_setr_epi8(0, 1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15, 4, 5, 10, 11);
-  const __m128i sh_b =
-      _mm_setr_epi8(2, 3, 8, 9, 14, 15, 4, 5, 10, 11, 0, 1, 6, 7, 12, 13);
-  const __m128i sh_c =
-      _mm_setr_epi8(4, 5, 10, 11, 0, 1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15);
-  a0 = _mm_shuffle_epi8(a0, sh_a);
-  b0 = _mm_shuffle_epi8(b0, sh_b);
-  c0 = _mm_shuffle_epi8(c0, sh_c);
-
-  a.val = a0;
-  b.val = b0;
-  c.val = c0;
-#else
-  __m128i t00 = _mm_loadu_si128((const __m128i *)ptr);
-  __m128i t01 = _mm_loadu_si128((const __m128i *)(ptr + 8));
-  __m128i t02 = _mm_loadu_si128((const __m128i *)(ptr + 16));
-
-  __m128i t10 = _mm_unpacklo_epi16(t00, _mm_unpackhi_epi64(t01, t01));
-  __m128i t11 = _mm_unpacklo_epi16(_mm_unpackhi_epi64(t00, t00), t02);
-  __m128i t12 = _mm_unpacklo_epi16(t01, _mm_unpackhi_epi64(t02, t02));
-
-  __m128i t20 = _mm_unpacklo_epi16(t10, _mm_unpackhi_epi64(t11, t11));
-  __m128i t21 = _mm_unpacklo_epi16(_mm_unpackhi_epi64(t10, t10), t12);
-  __m128i t22 = _mm_unpacklo_epi16(t11, _mm_unpackhi_epi64(t12, t12));
-
-  a.val = _mm_unpacklo_epi16(t20, _mm_unpackhi_epi64(t21, t21));
-  b.val = _mm_unpacklo_epi16(_mm_unpackhi_epi64(t20, t20), t22);
-  c.val = _mm_unpacklo_epi16(t21, _mm_unpackhi_epi64(t22, t22));
-#endif
-}
-
-inline void v_load_deinterleave(const ushort *ptr, v_uint16x8 &a, v_uint16x8 &b,
-                                v_uint16x8 &c, v_uint16x8 &d) {
-  __m128i u0 = _mm_loadu_si128((const __m128i *)ptr); // a0 b0 c0 d0 a1 b1 c1 d1
-  __m128i u1 = _mm_loadu_si128((const __m128i *)(ptr + 8));  // a2 b2 c2 d2 ...
-  __m128i u2 = _mm_loadu_si128((const __m128i *)(ptr + 16)); // a4 b4 c4 d4 ...
-  __m128i u3 = _mm_loadu_si128((const __m128i *)(ptr + 24)); // a6 b6 c6 d6 ...
-
-  __m128i v0 = _mm_unpacklo_epi16(u0, u2); // a0 a4 b0 b4 ...
-  __m128i v1 = _mm_unpackhi_epi16(u0, u2); // a1 a5 b1 b5 ...
-  __m128i v2 = _mm_unpacklo_epi16(u1, u3); // a2 a6 b2 b6 ...
-  __m128i v3 = _mm_unpackhi_epi16(u1, u3); // a3 a7 b3 b7 ...
-
-  u0 = _mm_unpacklo_epi16(v0, v2); // a0 a2 a4 a6 ...
-  u1 = _mm_unpacklo_epi16(v1, v3); // a1 a3 a5 a7 ...
-  u2 = _mm_unpackhi_epi16(v0, v2); // c0 c2 c4 c6 ...
-  u3 = _mm_unpackhi_epi16(v1, v3); // c1 c3 c5 c7 ...
-
-  a.val = _mm_unpacklo_epi16(u0, u1);
-  b.val = _mm_unpackhi_epi16(u0, u1);
-  c.val = _mm_unpacklo_epi16(u2, u3);
-  d.val = _mm_unpackhi_epi16(u2, u3);
-}
-
-inline void v_load_deinterleave(const unsigned *ptr, v_uint32x4 &a,
-                                v_uint32x4 &b) {
-  __m128i v0 = _mm_loadu_si128((__m128i *)(ptr));     // a0 b0 a1 b1
-  __m128i v1 = _mm_loadu_si128((__m128i *)(ptr + 4)); // a2 b2 a3 b3
-
-  __m128i v2 = _mm_unpacklo_epi32(v0, v1); // a0 a2 b0 b2
-  __m128i v3 = _mm_unpackhi_epi32(v0, v1); // a1 a3 b1 b3
-
-  a.val = _mm_unpacklo_epi32(v2, v3); // a0 a1 a2 a3
-  b.val = _mm_unpackhi_epi32(v2, v3); // b0 b1 ab b3
-}
-
-inline void v_load_deinterleave(const unsigned *ptr, v_uint32x4 &a,
-                                v_uint32x4 &b, v_uint32x4 &c) {
-  __m128i t00 = _mm_loadu_si128((const __m128i *)ptr);
-  __m128i t01 = _mm_loadu_si128((const __m128i *)(ptr + 4));
-  __m128i t02 = _mm_loadu_si128((const __m128i *)(ptr + 8));
-
-  __m128i t10 = _mm_unpacklo_epi32(t00, _mm_unpackhi_epi64(t01, t01));
-  __m128i t11 = _mm_unpacklo_epi32(_mm_unpackhi_epi64(t00, t00), t02);
-  __m128i t12 = _mm_unpacklo_epi32(t01, _mm_unpackhi_epi64(t02, t02));
-
-  a.val = _mm_unpacklo_epi32(t10, _mm_unpackhi_epi64(t11, t11));
-  b.val = _mm_unpacklo_epi32(_mm_unpackhi_epi64(t10, t10), t12);
-  c.val = _mm_unpacklo_epi32(t11, _mm_unpackhi_epi64(t12, t12));
-}
-
-inline void v_load_deinterleave(const unsigned *ptr, v_uint32x4 &a,
-                                v_uint32x4 &b, v_uint32x4 &c, v_uint32x4 &d) {
-  v_uint32x4 s0(_mm_loadu_si128((const __m128i *)ptr));        // a0 b0 c0 d0
-  v_uint32x4 s1(_mm_loadu_si128((const __m128i *)(ptr + 4)));  // a1 b1 c1 d1
-  v_uint32x4 s2(_mm_loadu_si128((const __m128i *)(ptr + 8)));  // a2 b2 c2 d2
-  v_uint32x4 s3(_mm_loadu_si128((const __m128i *)(ptr + 12))); // a3 b3 c3 d3
-
-  v_transpose4x4(s0, s1, s2, s3, a, b, c, d);
-}
-
-inline void v_load_deinterleave(const float *ptr, v_float32x4 &a,
-                                v_float32x4 &b) {
-  __m128 u0 = _mm_loadu_ps(ptr);       // a0 b0 a1 b1
-  __m128 u1 = _mm_loadu_ps((ptr + 4)); // a2 b2 a3 b3
-
-  a.val = _mm_shuffle_ps(u0, u1, _MM_SHUFFLE(2, 0, 2, 0)); // a0 a1 a2 a3
-  b.val = _mm_shuffle_ps(u0, u1, _MM_SHUFFLE(3, 1, 3, 1)); // b0 b1 ab b3
-}
-
-inline void v_load_deinterleave(const float *ptr, v_float32x4 &a,
-                                v_float32x4 &b, v_float32x4 &c) {
-  __m128 t0 = _mm_loadu_ps(ptr + 0);
-  __m128 t1 = _mm_loadu_ps(ptr + 4);
-  __m128 t2 = _mm_loadu_ps(ptr + 8);
-
-  __m128 at12 = _mm_shuffle_ps(t1, t2, _MM_SHUFFLE(0, 1, 0, 2));
-  a.val = _mm_shuffle_ps(t0, at12, _MM_SHUFFLE(2, 0, 3, 0));
-
-  __m128 bt01 = _mm_shuffle_ps(t0, t1, _MM_SHUFFLE(0, 0, 0, 1));
-  __m128 bt12 = _mm_shuffle_ps(t1, t2, _MM_SHUFFLE(0, 2, 0, 3));
-  b.val = _mm_shuffle_ps(bt01, bt12, _MM_SHUFFLE(2, 0, 2, 0));
-
-  __m128 ct01 = _mm_shuffle_ps(t0, t1, _MM_SHUFFLE(0, 1, 0, 2));
-  c.val = _mm_shuffle_ps(ct01, t2, _MM_SHUFFLE(3, 0, 2, 0));
-}
-
-inline void v_load_deinterleave(const float *ptr, v_float32x4 &a,
-                                v_float32x4 &b, v_float32x4 &c,
-                                v_float32x4 &d) {
-  __m128 t0 = _mm_loadu_ps(ptr + 0);
-  __m128 t1 = _mm_loadu_ps(ptr + 4);
-  __m128 t2 = _mm_loadu_ps(ptr + 8);
-  __m128 t3 = _mm_loadu_ps(ptr + 12);
-  __m128 t02lo = _mm_unpacklo_ps(t0, t2);
-  __m128 t13lo = _mm_unpacklo_ps(t1, t3);
-  __m128 t02hi = _mm_unpackhi_ps(t0, t2);
-  __m128 t13hi = _mm_unpackhi_ps(t1, t3);
-  a.val = _mm_unpacklo_ps(t02lo, t13lo);
-  b.val = _mm_unpackhi_ps(t02lo, t13lo);
-  c.val = _mm_unpacklo_ps(t02hi, t13hi);
-  d.val = _mm_unpackhi_ps(t02hi, t13hi);
-}
-
-inline void v_load_deinterleave(const uint64 *ptr, v_uint64x2 &a,
-                                v_uint64x2 &b) {
-  __m128i t0 = _mm_loadu_si128((const __m128i *)ptr);
-  __m128i t1 = _mm_loadu_si128((const __m128i *)(ptr + 2));
-
-  a = v_uint64x2(_mm_unpacklo_epi64(t0, t1));
-  b = v_uint64x2(_mm_unpackhi_epi64(t0, t1));
-}
-
-inline void v_load_deinterleave(const uint64 *ptr, v_uint64x2 &a, v_uint64x2 &b,
-                                v_uint64x2 &c) {
-  __m128i t0 = _mm_loadu_si128((const __m128i *)ptr);       // a0, b0
-  __m128i t1 = _mm_loadu_si128((const __m128i *)(ptr + 2)); // c0, a1
-  __m128i t2 = _mm_loadu_si128((const __m128i *)(ptr + 4)); // b1, c1
-
-  t1 = _mm_shuffle_epi32(t1, 0x4e); // a1, c0
-
-  a = v_uint64x2(_mm_unpacklo_epi64(t0, t1));
-  b = v_uint64x2(_mm_unpacklo_epi64(_mm_unpackhi_epi64(t0, t0), t2));
-  c = v_uint64x2(_mm_unpackhi_epi64(t1, t2));
-}
-
-inline void v_load_deinterleave(const uint64 *ptr, v_uint64x2 &a, v_uint64x2 &b,
-                                v_uint64x2 &c, v_uint64x2 &d) {
-  __m128i t0 = _mm_loadu_si128((const __m128i *)ptr);       // a0 b0
-  __m128i t1 = _mm_loadu_si128((const __m128i *)(ptr + 2)); // c0 d0
-  __m128i t2 = _mm_loadu_si128((const __m128i *)(ptr + 4)); // a1 b1
-  __m128i t3 = _mm_loadu_si128((const __m128i *)(ptr + 6)); // c1 d1
-
-  a = v_uint64x2(_mm_unpacklo_epi64(t0, t2));
-  b = v_uint64x2(_mm_unpackhi_epi64(t0, t2));
-  c = v_uint64x2(_mm_unpacklo_epi64(t1, t3));
-  d = v_uint64x2(_mm_unpackhi_epi64(t1, t3));
-}
-
-// store interleave
-
-inline void v_store_interleave(uchar *ptr, const v_uint8x16 &a,
-                               const v_uint8x16 &b,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  __m128i v0 = _mm_unpacklo_epi8(a.val, b.val);
-  __m128i v1 = _mm_unpackhi_epi8(a.val, b.val);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm_stream_si128((__m128i *)(ptr), v0);
-    _mm_stream_si128((__m128i *)(ptr + 16), v1);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm_store_si128((__m128i *)(ptr), v0);
-    _mm_store_si128((__m128i *)(ptr + 16), v1);
-  } else {
-    _mm_storeu_si128((__m128i *)(ptr), v0);
-    _mm_storeu_si128((__m128i *)(ptr + 16), v1);
-  }
-}
-
-inline void v_store_interleave(uchar *ptr, const v_uint8x16 &a,
-                               const v_uint8x16 &b, const v_uint8x16 &c,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-#if CV_SSE4_1
-  const __m128i sh_a =
-      _mm_setr_epi8(0, 11, 6, 1, 12, 7, 2, 13, 8, 3, 14, 9, 4, 15, 10, 5);
-  const __m128i sh_b =
-      _mm_setr_epi8(5, 0, 11, 6, 1, 12, 7, 2, 13, 8, 3, 14, 9, 4, 15, 10);
-  const __m128i sh_c =
-      _mm_setr_epi8(10, 5, 0, 11, 6, 1, 12, 7, 2, 13, 8, 3, 14, 9, 4, 15);
-  __m128i a0 = _mm_shuffle_epi8(a.val, sh_a);
-  __m128i b0 = _mm_shuffle_epi8(b.val, sh_b);
-  __m128i c0 = _mm_shuffle_epi8(c.val, sh_c);
-
-  const __m128i m0 =
-      _mm_setr_epi8(0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0);
-  const __m128i m1 =
-      _mm_setr_epi8(0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0);
-  __m128i v0 = _mm_blendv_epi8(_mm_blendv_epi8(a0, b0, m1), c0, m0);
-  __m128i v1 = _mm_blendv_epi8(_mm_blendv_epi8(b0, c0, m1), a0, m0);
-  __m128i v2 = _mm_blendv_epi8(_mm_blendv_epi8(c0, a0, m1), b0, m0);
-#elif CV_SSSE3
-  const __m128i m0 =
-      _mm_setr_epi8(0, 6, 11, 1, 7, 12, 2, 8, 13, 3, 9, 14, 4, 10, 15, 5);
-  const __m128i m1 =
-      _mm_setr_epi8(5, 11, 0, 6, 12, 1, 7, 13, 2, 8, 14, 3, 9, 15, 4, 10);
-  const __m128i m2 =
-      _mm_setr_epi8(10, 0, 5, 11, 1, 6, 12, 2, 7, 13, 3, 8, 14, 4, 9, 15);
-
-  __m128i t0 = _mm_alignr_epi8(b.val, _mm_slli_si128(a.val, 10), 5);
-  t0 = _mm_alignr_epi8(c.val, t0, 5);
-  __m128i v0 = _mm_shuffle_epi8(t0, m0);
-
-  __m128i t1 =
-      _mm_alignr_epi8(_mm_srli_si128(b.val, 5), _mm_slli_si128(a.val, 5), 6);
-  t1 = _mm_alignr_epi8(_mm_srli_si128(c.val, 5), t1, 5);
-  __m128i v1 = _mm_shuffle_epi8(t1, m1);
-
-  __m128i t2 = _mm_alignr_epi8(_mm_srli_si128(c.val, 10), b.val, 11);
-  t2 = _mm_alignr_epi8(t2, a.val, 11);
-  __m128i v2 = _mm_shuffle_epi8(t2, m2);
-#else
-  __m128i z = _mm_setzero_si128();
-  __m128i ab0 = _mm_unpacklo_epi8(a.val, b.val);
-  __m128i ab1 = _mm_unpackhi_epi8(a.val, b.val);
-  __m128i c0 = _mm_unpacklo_epi8(c.val, z);
-  __m128i c1 = _mm_unpackhi_epi8(c.val, z);
-
-  __m128i p00 = _mm_unpacklo_epi16(ab0, c0);
-  __m128i p01 = _mm_unpackhi_epi16(ab0, c0);
-  __m128i p02 = _mm_unpacklo_epi16(ab1, c1);
-  __m128i p03 = _mm_unpackhi_epi16(ab1, c1);
-
-  __m128i p10 = _mm_unpacklo_epi32(p00, p01);
-  __m128i p11 = _mm_unpackhi_epi32(p00, p01);
-  __m128i p12 = _mm_unpacklo_epi32(p02, p03);
-  __m128i p13 = _mm_unpackhi_epi32(p02, p03);
-
-  __m128i p20 = _mm_unpacklo_epi64(p10, p11);
-  __m128i p21 = _mm_unpackhi_epi64(p10, p11);
-  __m128i p22 = _mm_unpacklo_epi64(p12, p13);
-  __m128i p23 = _mm_unpackhi_epi64(p12, p13);
-
-  p20 = _mm_slli_si128(p20, 1);
-  p22 = _mm_slli_si128(p22, 1);
-
-  __m128i p30 = _mm_slli_epi64(_mm_unpacklo_epi32(p20, p21), 8);
-  __m128i p31 = _mm_srli_epi64(_mm_unpackhi_epi32(p20, p21), 8);
-  __m128i p32 = _mm_slli_epi64(_mm_unpacklo_epi32(p22, p23), 8);
-  __m128i p33 = _mm_srli_epi64(_mm_unpackhi_epi32(p22, p23), 8);
-
-  __m128i p40 = _mm_unpacklo_epi64(p30, p31);
-  __m128i p41 = _mm_unpackhi_epi64(p30, p31);
-  __m128i p42 = _mm_unpacklo_epi64(p32, p33);
-  __m128i p43 = _mm_unpackhi_epi64(p32, p33);
-
-  __m128i v0 = _mm_or_si128(_mm_srli_si128(p40, 2), _mm_slli_si128(p41, 10));
-  __m128i v1 = _mm_or_si128(_mm_srli_si128(p41, 6), _mm_slli_si128(p42, 6));
-  __m128i v2 = _mm_or_si128(_mm_srli_si128(p42, 10), _mm_slli_si128(p43, 2));
-#endif
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm_stream_si128((__m128i *)(ptr), v0);
-    _mm_stream_si128((__m128i *)(ptr + 16), v1);
-    _mm_stream_si128((__m128i *)(ptr + 32), v2);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm_store_si128((__m128i *)(ptr), v0);
-    _mm_store_si128((__m128i *)(ptr + 16), v1);
-    _mm_store_si128((__m128i *)(ptr + 32), v2);
-  } else {
-    _mm_storeu_si128((__m128i *)(ptr), v0);
-    _mm_storeu_si128((__m128i *)(ptr + 16), v1);
-    _mm_storeu_si128((__m128i *)(ptr + 32), v2);
-  }
-}
-
-inline void v_store_interleave(uchar *ptr, const v_uint8x16 &a,
-                               const v_uint8x16 &b, const v_uint8x16 &c,
-                               const v_uint8x16 &d,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  // a0 a1 a2 a3 ....
-  // b0 b1 b2 b3 ....
-  // c0 c1 c2 c3 ....
-  // d0 d1 d2 d3 ....
-  __m128i u0 = _mm_unpacklo_epi8(a.val, c.val); // a0 c0 a1 c1 ...
-  __m128i u1 = _mm_unpackhi_epi8(a.val, c.val); // a8 c8 a9 c9 ...
-  __m128i u2 = _mm_unpacklo_epi8(b.val, d.val); // b0 d0 b1 d1 ...
-  __m128i u3 = _mm_unpackhi_epi8(b.val, d.val); // b8 d8 b9 d9 ...
-
-  __m128i v0 = _mm_unpacklo_epi8(u0, u2); // a0 b0 c0 d0 ...
-  __m128i v1 = _mm_unpackhi_epi8(u0, u2); // a4 b4 c4 d4 ...
-  __m128i v2 = _mm_unpacklo_epi8(u1, u3); // a8 b8 c8 d8 ...
-  __m128i v3 = _mm_unpackhi_epi8(u1, u3); // a12 b12 c12 d12 ...
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm_stream_si128((__m128i *)(ptr), v0);
-    _mm_stream_si128((__m128i *)(ptr + 16), v1);
-    _mm_stream_si128((__m128i *)(ptr + 32), v2);
-    _mm_stream_si128((__m128i *)(ptr + 48), v3);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm_store_si128((__m128i *)(ptr), v0);
-    _mm_store_si128((__m128i *)(ptr + 16), v1);
-    _mm_store_si128((__m128i *)(ptr + 32), v2);
-    _mm_store_si128((__m128i *)(ptr + 48), v3);
-  } else {
-    _mm_storeu_si128((__m128i *)(ptr), v0);
-    _mm_storeu_si128((__m128i *)(ptr + 16), v1);
-    _mm_storeu_si128((__m128i *)(ptr + 32), v2);
-    _mm_storeu_si128((__m128i *)(ptr + 48), v3);
-  }
-}
-
-inline void v_store_interleave(ushort *ptr, const v_uint16x8 &a,
-                               const v_uint16x8 &b,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  __m128i v0 = _mm_unpacklo_epi16(a.val, b.val);
-  __m128i v1 = _mm_unpackhi_epi16(a.val, b.val);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm_stream_si128((__m128i *)(ptr), v0);
-    _mm_stream_si128((__m128i *)(ptr + 8), v1);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm_store_si128((__m128i *)(ptr), v0);
-    _mm_store_si128((__m128i *)(ptr + 8), v1);
-  } else {
-    _mm_storeu_si128((__m128i *)(ptr), v0);
-    _mm_storeu_si128((__m128i *)(ptr + 8), v1);
-  }
-}
-
-inline void v_store_interleave(ushort *ptr, const v_uint16x8 &a,
-                               const v_uint16x8 &b, const v_uint16x8 &c,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-#if CV_SSE4_1
-  const __m128i sh_a =
-      _mm_setr_epi8(0, 1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15, 4, 5, 10, 11);
-  const __m128i sh_b =
-      _mm_setr_epi8(10, 11, 0, 1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15, 4, 5);
-  const __m128i sh_c =
-      _mm_setr_epi8(4, 5, 10, 11, 0, 1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15);
-  __m128i a0 = _mm_shuffle_epi8(a.val, sh_a);
-  __m128i b0 = _mm_shuffle_epi8(b.val, sh_b);
-  __m128i c0 = _mm_shuffle_epi8(c.val, sh_c);
-
-  __m128i v0 = _mm_blend_epi16(_mm_blend_epi16(a0, b0, 0x92), c0, 0x24);
-  __m128i v1 = _mm_blend_epi16(_mm_blend_epi16(c0, a0, 0x92), b0, 0x24);
-  __m128i v2 = _mm_blend_epi16(_mm_blend_epi16(b0, c0, 0x92), a0, 0x24);
-#else
-  __m128i z = _mm_setzero_si128();
-  __m128i ab0 = _mm_unpacklo_epi16(a.val, b.val);
-  __m128i ab1 = _mm_unpackhi_epi16(a.val, b.val);
-  __m128i c0 = _mm_unpacklo_epi16(c.val, z);
-  __m128i c1 = _mm_unpackhi_epi16(c.val, z);
-
-  __m128i p10 = _mm_unpacklo_epi32(ab0, c0);
-  __m128i p11 = _mm_unpackhi_epi32(ab0, c0);
-  __m128i p12 = _mm_unpacklo_epi32(ab1, c1);
-  __m128i p13 = _mm_unpackhi_epi32(ab1, c1);
-
-  __m128i p20 = _mm_unpacklo_epi64(p10, p11);
-  __m128i p21 = _mm_unpackhi_epi64(p10, p11);
-  __m128i p22 = _mm_unpacklo_epi64(p12, p13);
-  __m128i p23 = _mm_unpackhi_epi64(p12, p13);
-
-  p20 = _mm_slli_si128(p20, 2);
-  p22 = _mm_slli_si128(p22, 2);
-
-  __m128i p30 = _mm_unpacklo_epi64(p20, p21);
-  __m128i p31 = _mm_unpackhi_epi64(p20, p21);
-  __m128i p32 = _mm_unpacklo_epi64(p22, p23);
-  __m128i p33 = _mm_unpackhi_epi64(p22, p23);
-
-  __m128i v0 = _mm_or_si128(_mm_srli_si128(p30, 2), _mm_slli_si128(p31, 10));
-  __m128i v1 = _mm_or_si128(_mm_srli_si128(p31, 6), _mm_slli_si128(p32, 6));
-  __m128i v2 = _mm_or_si128(_mm_srli_si128(p32, 10), _mm_slli_si128(p33, 2));
-#endif
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm_stream_si128((__m128i *)(ptr), v0);
-    _mm_stream_si128((__m128i *)(ptr + 8), v1);
-    _mm_stream_si128((__m128i *)(ptr + 16), v2);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm_store_si128((__m128i *)(ptr), v0);
-    _mm_store_si128((__m128i *)(ptr + 8), v1);
-    _mm_store_si128((__m128i *)(ptr + 16), v2);
-  } else {
-    _mm_storeu_si128((__m128i *)(ptr), v0);
-    _mm_storeu_si128((__m128i *)(ptr + 8), v1);
-    _mm_storeu_si128((__m128i *)(ptr + 16), v2);
-  }
-}
-
-inline void v_store_interleave(ushort *ptr, const v_uint16x8 &a,
-                               const v_uint16x8 &b, const v_uint16x8 &c,
-                               const v_uint16x8 &d,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  // a0 a1 a2 a3 ....
-  // b0 b1 b2 b3 ....
-  // c0 c1 c2 c3 ....
-  // d0 d1 d2 d3 ....
-  __m128i u0 = _mm_unpacklo_epi16(a.val, c.val); // a0 c0 a1 c1 ...
-  __m128i u1 = _mm_unpackhi_epi16(a.val, c.val); // a4 c4 a5 c5 ...
-  __m128i u2 = _mm_unpacklo_epi16(b.val, d.val); // b0 d0 b1 d1 ...
-  __m128i u3 = _mm_unpackhi_epi16(b.val, d.val); // b4 d4 b5 d5 ...
-
-  __m128i v0 = _mm_unpacklo_epi16(u0, u2); // a0 b0 c0 d0 ...
-  __m128i v1 = _mm_unpackhi_epi16(u0, u2); // a2 b2 c2 d2 ...
-  __m128i v2 = _mm_unpacklo_epi16(u1, u3); // a4 b4 c4 d4 ...
-  __m128i v3 = _mm_unpackhi_epi16(u1, u3); // a6 b6 c6 d6 ...
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm_stream_si128((__m128i *)(ptr), v0);
-    _mm_stream_si128((__m128i *)(ptr + 8), v1);
-    _mm_stream_si128((__m128i *)(ptr + 16), v2);
-    _mm_stream_si128((__m128i *)(ptr + 24), v3);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm_store_si128((__m128i *)(ptr), v0);
-    _mm_store_si128((__m128i *)(ptr + 8), v1);
-    _mm_store_si128((__m128i *)(ptr + 16), v2);
-    _mm_store_si128((__m128i *)(ptr + 24), v3);
-  } else {
-    _mm_storeu_si128((__m128i *)(ptr), v0);
-    _mm_storeu_si128((__m128i *)(ptr + 8), v1);
-    _mm_storeu_si128((__m128i *)(ptr + 16), v2);
-    _mm_storeu_si128((__m128i *)(ptr + 24), v3);
-  }
-}
-
-inline void v_store_interleave(unsigned *ptr, const v_uint32x4 &a,
-                               const v_uint32x4 &b,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  __m128i v0 = _mm_unpacklo_epi32(a.val, b.val);
-  __m128i v1 = _mm_unpackhi_epi32(a.val, b.val);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm_stream_si128((__m128i *)(ptr), v0);
-    _mm_stream_si128((__m128i *)(ptr + 4), v1);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm_store_si128((__m128i *)(ptr), v0);
-    _mm_store_si128((__m128i *)(ptr + 4), v1);
-  } else {
-    _mm_storeu_si128((__m128i *)(ptr), v0);
-    _mm_storeu_si128((__m128i *)(ptr + 4), v1);
-  }
-}
-
-inline void v_store_interleave(unsigned *ptr, const v_uint32x4 &a,
-                               const v_uint32x4 &b, const v_uint32x4 &c,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  v_uint32x4 z = v_setzero_u32(), u0, u1, u2, u3;
-  v_transpose4x4(a, b, c, z, u0, u1, u2, u3);
-
-  __m128i v0 = _mm_or_si128(u0.val, _mm_slli_si128(u1.val, 12));
-  __m128i v1 =
-      _mm_or_si128(_mm_srli_si128(u1.val, 4), _mm_slli_si128(u2.val, 8));
-  __m128i v2 =
-      _mm_or_si128(_mm_srli_si128(u2.val, 8), _mm_slli_si128(u3.val, 4));
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm_stream_si128((__m128i *)(ptr), v0);
-    _mm_stream_si128((__m128i *)(ptr + 4), v1);
-    _mm_stream_si128((__m128i *)(ptr + 8), v2);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm_store_si128((__m128i *)(ptr), v0);
-    _mm_store_si128((__m128i *)(ptr + 4), v1);
-    _mm_store_si128((__m128i *)(ptr + 8), v2);
-  } else {
-    _mm_storeu_si128((__m128i *)(ptr), v0);
-    _mm_storeu_si128((__m128i *)(ptr + 4), v1);
-    _mm_storeu_si128((__m128i *)(ptr + 8), v2);
-  }
-}
-
-inline void v_store_interleave(unsigned *ptr, const v_uint32x4 &a,
-                               const v_uint32x4 &b, const v_uint32x4 &c,
-                               const v_uint32x4 &d,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  v_uint32x4 v0, v1, v2, v3;
-  v_transpose4x4(a, b, c, d, v0, v1, v2, v3);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm_stream_si128((__m128i *)(ptr), v0.val);
-    _mm_stream_si128((__m128i *)(ptr + 4), v1.val);
-    _mm_stream_si128((__m128i *)(ptr + 8), v2.val);
-    _mm_stream_si128((__m128i *)(ptr + 12), v3.val);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm_store_si128((__m128i *)(ptr), v0.val);
-    _mm_store_si128((__m128i *)(ptr + 4), v1.val);
-    _mm_store_si128((__m128i *)(ptr + 8), v2.val);
-    _mm_store_si128((__m128i *)(ptr + 12), v3.val);
-  } else {
-    _mm_storeu_si128((__m128i *)(ptr), v0.val);
-    _mm_storeu_si128((__m128i *)(ptr + 4), v1.val);
-    _mm_storeu_si128((__m128i *)(ptr + 8), v2.val);
-    _mm_storeu_si128((__m128i *)(ptr + 12), v3.val);
-  }
-}
-
-// 2-channel, float only
-inline void v_store_interleave(float *ptr, const v_float32x4 &a,
-                               const v_float32x4 &b,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  __m128 v0 = _mm_unpacklo_ps(a.val, b.val); // a0 b0 a1 b1
-  __m128 v1 = _mm_unpackhi_ps(a.val, b.val); // a2 b2 a3 b3
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm_stream_ps(ptr, v0);
-    _mm_stream_ps(ptr + 4, v1);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm_store_ps(ptr, v0);
-    _mm_store_ps(ptr + 4, v1);
-  } else {
-    _mm_storeu_ps(ptr, v0);
-    _mm_storeu_ps(ptr + 4, v1);
-  }
-}
-
-inline void v_store_interleave(float *ptr, const v_float32x4 &a,
-                               const v_float32x4 &b, const v_float32x4 &c,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  __m128 u0 = _mm_shuffle_ps(a.val, b.val, _MM_SHUFFLE(0, 0, 0, 0));
-  __m128 u1 = _mm_shuffle_ps(c.val, a.val, _MM_SHUFFLE(1, 1, 0, 0));
-  __m128 v0 = _mm_shuffle_ps(u0, u1, _MM_SHUFFLE(2, 0, 2, 0));
-  __m128 u2 = _mm_shuffle_ps(b.val, c.val, _MM_SHUFFLE(1, 1, 1, 1));
-  __m128 u3 = _mm_shuffle_ps(a.val, b.val, _MM_SHUFFLE(2, 2, 2, 2));
-  __m128 v1 = _mm_shuffle_ps(u2, u3, _MM_SHUFFLE(2, 0, 2, 0));
-  __m128 u4 = _mm_shuffle_ps(c.val, a.val, _MM_SHUFFLE(3, 3, 2, 2));
-  __m128 u5 = _mm_shuffle_ps(b.val, c.val, _MM_SHUFFLE(3, 3, 3, 3));
-  __m128 v2 = _mm_shuffle_ps(u4, u5, _MM_SHUFFLE(2, 0, 2, 0));
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm_stream_ps(ptr, v0);
-    _mm_stream_ps(ptr + 4, v1);
-    _mm_stream_ps(ptr + 8, v2);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm_store_ps(ptr, v0);
-    _mm_store_ps(ptr + 4, v1);
-    _mm_store_ps(ptr + 8, v2);
-  } else {
-    _mm_storeu_ps(ptr, v0);
-    _mm_storeu_ps(ptr + 4, v1);
-    _mm_storeu_ps(ptr + 8, v2);
-  }
-}
-
-inline void v_store_interleave(float *ptr, const v_float32x4 &a,
-                               const v_float32x4 &b, const v_float32x4 &c,
-                               const v_float32x4 &d,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  __m128 u0 = _mm_unpacklo_ps(a.val, c.val);
-  __m128 u1 = _mm_unpacklo_ps(b.val, d.val);
-  __m128 u2 = _mm_unpackhi_ps(a.val, c.val);
-  __m128 u3 = _mm_unpackhi_ps(b.val, d.val);
-  __m128 v0 = _mm_unpacklo_ps(u0, u1);
-  __m128 v2 = _mm_unpacklo_ps(u2, u3);
-  __m128 v1 = _mm_unpackhi_ps(u0, u1);
-  __m128 v3 = _mm_unpackhi_ps(u2, u3);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm_stream_ps(ptr, v0);
-    _mm_stream_ps(ptr + 4, v1);
-    _mm_stream_ps(ptr + 8, v2);
-    _mm_stream_ps(ptr + 12, v3);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm_store_ps(ptr, v0);
-    _mm_store_ps(ptr + 4, v1);
-    _mm_store_ps(ptr + 8, v2);
-    _mm_store_ps(ptr + 12, v3);
-  } else {
-    _mm_storeu_ps(ptr, v0);
-    _mm_storeu_ps(ptr + 4, v1);
-    _mm_storeu_ps(ptr + 8, v2);
-    _mm_storeu_ps(ptr + 12, v3);
-  }
-}
-
-inline void v_store_interleave(uint64 *ptr, const v_uint64x2 &a,
-                               const v_uint64x2 &b,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  __m128i v0 = _mm_unpacklo_epi64(a.val, b.val);
-  __m128i v1 = _mm_unpackhi_epi64(a.val, b.val);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm_stream_si128((__m128i *)(ptr), v0);
-    _mm_stream_si128((__m128i *)(ptr + 2), v1);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm_store_si128((__m128i *)(ptr), v0);
-    _mm_store_si128((__m128i *)(ptr + 2), v1);
-  } else {
-    _mm_storeu_si128((__m128i *)(ptr), v0);
-    _mm_storeu_si128((__m128i *)(ptr + 2), v1);
-  }
-}
-
-inline void v_store_interleave(uint64 *ptr, const v_uint64x2 &a,
-                               const v_uint64x2 &b, const v_uint64x2 &c,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  __m128i v0 = _mm_unpacklo_epi64(a.val, b.val);
-  __m128i v1 = _mm_unpacklo_epi64(c.val, _mm_unpackhi_epi64(a.val, a.val));
-  __m128i v2 = _mm_unpackhi_epi64(b.val, c.val);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm_stream_si128((__m128i *)(ptr), v0);
-    _mm_stream_si128((__m128i *)(ptr + 2), v1);
-    _mm_stream_si128((__m128i *)(ptr + 4), v2);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm_store_si128((__m128i *)(ptr), v0);
-    _mm_store_si128((__m128i *)(ptr + 2), v1);
-    _mm_store_si128((__m128i *)(ptr + 4), v2);
-  } else {
-    _mm_storeu_si128((__m128i *)(ptr), v0);
-    _mm_storeu_si128((__m128i *)(ptr + 2), v1);
-    _mm_storeu_si128((__m128i *)(ptr + 4), v2);
-  }
-}
-
-inline void v_store_interleave(uint64 *ptr, const v_uint64x2 &a,
-                               const v_uint64x2 &b, const v_uint64x2 &c,
-                               const v_uint64x2 &d,
-                               hal::StoreMode mode = hal::STORE_UNALIGNED) {
-  __m128i v0 = _mm_unpacklo_epi64(a.val, b.val);
-  __m128i v1 = _mm_unpacklo_epi64(c.val, d.val);
-  __m128i v2 = _mm_unpackhi_epi64(a.val, b.val);
-  __m128i v3 = _mm_unpackhi_epi64(c.val, d.val);
-
-  if (mode == hal::STORE_ALIGNED_NOCACHE) {
-    _mm_stream_si128((__m128i *)(ptr), v0);
-    _mm_stream_si128((__m128i *)(ptr + 2), v1);
-    _mm_stream_si128((__m128i *)(ptr + 4), v2);
-    _mm_stream_si128((__m128i *)(ptr + 6), v3);
-  } else if (mode == hal::STORE_ALIGNED) {
-    _mm_store_si128((__m128i *)(ptr), v0);
-    _mm_store_si128((__m128i *)(ptr + 2), v1);
-    _mm_store_si128((__m128i *)(ptr + 4), v2);
-    _mm_store_si128((__m128i *)(ptr + 6), v3);
-  } else {
-    _mm_storeu_si128((__m128i *)(ptr), v0);
-    _mm_storeu_si128((__m128i *)(ptr + 2), v1);
-    _mm_storeu_si128((__m128i *)(ptr + 4), v2);
-    _mm_storeu_si128((__m128i *)(ptr + 6), v3);
-  }
-}
-
-#define OPENCV_HAL_IMPL_SSE_LOADSTORE_INTERLEAVE(_Tpvec0, _Tp0, suffix0,       \
-                                                 _Tpvec1, _Tp1, suffix1)       \
-  inline void v_load_deinterleave(const _Tp0 *ptr, _Tpvec0 &a0, _Tpvec0 &b0) { \
-    _Tpvec1 a1, b1;                                                            \
-    v_load_deinterleave((const _Tp1 *)ptr, a1, b1);                            \
-    a0 = v_reinterpret_as_##suffix0(a1);                                       \
-    b0 = v_reinterpret_as_##suffix0(b1);                                       \
-  }                                                                            \
-  inline void v_load_deinterleave(const _Tp0 *ptr, _Tpvec0 &a0, _Tpvec0 &b0,   \
-                                  _Tpvec0 &c0) {                               \
-    _Tpvec1 a1, b1, c1;                                                        \
-    v_load_deinterleave((const _Tp1 *)ptr, a1, b1, c1);                        \
-    a0 = v_reinterpret_as_##suffix0(a1);                                       \
-    b0 = v_reinterpret_as_##suffix0(b1);                                       \
-    c0 = v_reinterpret_as_##suffix0(c1);                                       \
-  }                                                                            \
-  inline void v_load_deinterleave(const _Tp0 *ptr, _Tpvec0 &a0, _Tpvec0 &b0,   \
-                                  _Tpvec0 &c0, _Tpvec0 &d0) {                  \
-    _Tpvec1 a1, b1, c1, d1;                                                    \
-    v_load_deinterleave((const _Tp1 *)ptr, a1, b1, c1, d1);                    \
-    a0 = v_reinterpret_as_##suffix0(a1);                                       \
-    b0 = v_reinterpret_as_##suffix0(b1);                                       \
-    c0 = v_reinterpret_as_##suffix0(c1);                                       \
-    d0 = v_reinterpret_as_##suffix0(d1);                                       \
-  }                                                                            \
-  inline void v_store_interleave(_Tp0 *ptr, const _Tpvec0 &a0,                 \
-                                 const _Tpvec0 &b0,                            \
-                                 hal::StoreMode mode = hal::STORE_UNALIGNED) { \
-    _Tpvec1 a1 = v_reinterpret_as_##suffix1(a0);                               \
-    _Tpvec1 b1 = v_reinterpret_as_##suffix1(b0);                               \
-    v_store_interleave((_Tp1 *)ptr, a1, b1, mode);                             \
-  }                                                                            \
-  inline void v_store_interleave(_Tp0 *ptr, const _Tpvec0 &a0,                 \
-                                 const _Tpvec0 &b0, const _Tpvec0 &c0,         \
-                                 hal::StoreMode mode = hal::STORE_UNALIGNED) { \
-    _Tpvec1 a1 = v_reinterpret_as_##suffix1(a0);                               \
-    _Tpvec1 b1 = v_reinterpret_as_##suffix1(b0);                               \
-    _Tpvec1 c1 = v_reinterpret_as_##suffix1(c0);                               \
-    v_store_interleave((_Tp1 *)ptr, a1, b1, c1, mode);                         \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp0 *ptr, const _Tpvec0 &a0, const _Tpvec0 &b0, const _Tpvec0 &c0,      \
-      const _Tpvec0 &d0, hal::StoreMode mode = hal::STORE_UNALIGNED) {         \
-    _Tpvec1 a1 = v_reinterpret_as_##suffix1(a0);                               \
-    _Tpvec1 b1 = v_reinterpret_as_##suffix1(b0);                               \
-    _Tpvec1 c1 = v_reinterpret_as_##suffix1(c0);                               \
-    _Tpvec1 d1 = v_reinterpret_as_##suffix1(d0);                               \
-    v_store_interleave((_Tp1 *)ptr, a1, b1, c1, d1, mode);                     \
-  }
-
-OPENCV_HAL_IMPL_SSE_LOADSTORE_INTERLEAVE(v_int8x16, schar, s8, v_uint8x16,
-                                         uchar, u8)
-OPENCV_HAL_IMPL_SSE_LOADSTORE_INTERLEAVE(v_int16x8, short, s16, v_uint16x8,
-                                         ushort, u16)
-OPENCV_HAL_IMPL_SSE_LOADSTORE_INTERLEAVE(v_int32x4, int, s32, v_uint32x4,
-                                         unsigned, u32)
-OPENCV_HAL_IMPL_SSE_LOADSTORE_INTERLEAVE(v_int64x2, int64, s64, v_uint64x2,
-                                         uint64, u64)
-OPENCV_HAL_IMPL_SSE_LOADSTORE_INTERLEAVE(v_float64x2, double, f64, v_uint64x2,
-                                         uint64, u64)
-
-inline v_float32x4 v_cvt_f32(const v_int32x4 &a) {
-  return v_float32x4(_mm_cvtepi32_ps(a.val));
-}
-
-inline v_float32x4 v_cvt_f32(const v_float64x2 &a) {
-  return v_float32x4(_mm_cvtpd_ps(a.val));
-}
-
-inline v_float32x4 v_cvt_f32(const v_float64x2 &a, const v_float64x2 &b) {
-  return v_float32x4(_mm_movelh_ps(_mm_cvtpd_ps(a.val), _mm_cvtpd_ps(b.val)));
-}
-
-inline v_float64x2 v_cvt_f64(const v_int32x4 &a) {
-  return v_float64x2(_mm_cvtepi32_pd(a.val));
-}
-
-inline v_float64x2 v_cvt_f64_high(const v_int32x4 &a) {
-  return v_float64x2(_mm_cvtepi32_pd(_mm_srli_si128(a.val, 8)));
-}
-
-inline v_float64x2 v_cvt_f64(const v_float32x4 &a) {
-  return v_float64x2(_mm_cvtps_pd(a.val));
-}
-
-inline v_float64x2 v_cvt_f64_high(const v_float32x4 &a) {
-  return v_float64x2(_mm_cvtps_pd(_mm_movehl_ps(a.val, a.val)));
-}
-
-// from (Mysticial and wim) https://stackoverflow.com/q/41144668
-inline v_float64x2 v_cvt_f64(const v_int64x2 &v) {
-  // constants encoded as floating-point
-  __m128i magic_i_hi32 = _mm_set1_epi64x(0x4530000080000000); // 2^84 + 2^63
-  __m128i magic_i_all =
-      _mm_set1_epi64x(0x4530000080100000); // 2^84 + 2^63 + 2^52
-  __m128d magic_d_all = _mm_castsi128_pd(magic_i_all);
-  // Blend the 32 lowest significant bits of v with magic_int_lo
-#if CV_SSE4_1
-  __m128i magic_i_lo = _mm_set1_epi64x(0x4330000000000000); // 2^52
-  __m128i v_lo = _mm_blend_epi16(v.val, magic_i_lo, 0xcc);
-#else
-  __m128i magic_i_lo = _mm_set1_epi32(0x43300000); // 2^52
-  __m128i v_lo = _mm_unpacklo_epi32(
-      _mm_shuffle_epi32(v.val, _MM_SHUFFLE(0, 0, 2, 0)), magic_i_lo);
-#endif
-  // Extract the 32 most significant bits of v
-  __m128i v_hi = _mm_srli_epi64(v.val, 32);
-  // Flip the msb of v_hi and blend with 0x45300000
-  v_hi = _mm_xor_si128(v_hi, magic_i_hi32);
-  // Compute in double precision
-  __m128d v_hi_dbl = _mm_sub_pd(_mm_castsi128_pd(v_hi), magic_d_all);
-  // (v_hi - magic_d_all) + v_lo  Do not assume associativity of floating point
-  // addition
-  __m128d result = _mm_add_pd(v_hi_dbl, _mm_castsi128_pd(v_lo));
-  return v_float64x2(result);
-}
-
-////////////// Lookup table access ////////////////////
-
-inline v_int8x16 v_lut(const schar *tab, const int *idx) {
-#if defined(_MSC_VER)
-  return v_int8x16(
-      _mm_setr_epi8(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]],
-                    tab[idx[4]], tab[idx[5]], tab[idx[6]], tab[idx[7]],
-                    tab[idx[8]], tab[idx[9]], tab[idx[10]], tab[idx[11]],
-                    tab[idx[12]], tab[idx[13]], tab[idx[14]], tab[idx[15]]));
-#else
-  return v_int8x16(_mm_setr_epi64(
-      _mm_setr_pi8(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]],
-                   tab[idx[4]], tab[idx[5]], tab[idx[6]], tab[idx[7]]),
-      _mm_setr_pi8(tab[idx[8]], tab[idx[9]], tab[idx[10]], tab[idx[11]],
-                   tab[idx[12]], tab[idx[13]], tab[idx[14]], tab[idx[15]])));
-#endif
-}
-inline v_int8x16 v_lut_pairs(const schar *tab, const int *idx) {
-#if defined(_MSC_VER)
-  return v_int8x16(_mm_setr_epi16(
-      *(const short *)(tab + idx[0]), *(const short *)(tab + idx[1]),
-      *(const short *)(tab + idx[2]), *(const short *)(tab + idx[3]),
-      *(const short *)(tab + idx[4]), *(const short *)(tab + idx[5]),
-      *(const short *)(tab + idx[6]), *(const short *)(tab + idx[7])));
-#else
-  return v_int8x16(_mm_setr_epi64(
-      _mm_setr_pi16(
-          *(const short *)(tab + idx[0]), *(const short *)(tab + idx[1]),
-          *(const short *)(tab + idx[2]), *(const short *)(tab + idx[3])),
-      _mm_setr_pi16(
-          *(const short *)(tab + idx[4]), *(const short *)(tab + idx[5]),
-          *(const short *)(tab + idx[6]), *(const short *)(tab + idx[7]))));
-#endif
-}
-inline v_int8x16 v_lut_quads(const schar *tab, const int *idx) {
-#if defined(_MSC_VER)
-  return v_int8x16(_mm_setr_epi32(
-      *(const int *)(tab + idx[0]), *(const int *)(tab + idx[1]),
-      *(const int *)(tab + idx[2]), *(const int *)(tab + idx[3])));
-#else
-  return v_int8x16(_mm_setr_epi64(
-      _mm_setr_pi32(*(const int *)(tab + idx[0]), *(const int *)(tab + idx[1])),
-      _mm_setr_pi32(*(const int *)(tab + idx[2]),
-                    *(const int *)(tab + idx[3]))));
-#endif
-}
-inline v_uint8x16 v_lut(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v_lut((const schar *)tab, idx));
-}
-inline v_uint8x16 v_lut_pairs(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v_lut_pairs((const schar *)tab, idx));
-}
-inline v_uint8x16 v_lut_quads(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v_lut_quads((const schar *)tab, idx));
-}
-
-inline v_int16x8 v_lut(const short *tab, const int *idx) {
-#if defined(_MSC_VER)
-  return v_int16x8(_mm_setr_epi16(tab[idx[0]], tab[idx[1]], tab[idx[2]],
-                                  tab[idx[3]], tab[idx[4]], tab[idx[5]],
-                                  tab[idx[6]], tab[idx[7]]));
-#else
-  return v_int16x8(_mm_setr_epi64(
-      _mm_setr_pi16(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]),
-      _mm_setr_pi16(tab[idx[4]], tab[idx[5]], tab[idx[6]], tab[idx[7]])));
-#endif
-}
-inline v_int16x8 v_lut_pairs(const short *tab, const int *idx) {
-#if defined(_MSC_VER)
-  return v_int16x8(_mm_setr_epi32(
-      *(const int *)(tab + idx[0]), *(const int *)(tab + idx[1]),
-      *(const int *)(tab + idx[2]), *(const int *)(tab + idx[3])));
-#else
-  return v_int16x8(_mm_setr_epi64(
-      _mm_setr_pi32(*(const int *)(tab + idx[0]), *(const int *)(tab + idx[1])),
-      _mm_setr_pi32(*(const int *)(tab + idx[2]),
-                    *(const int *)(tab + idx[3]))));
-#endif
-}
-inline v_int16x8 v_lut_quads(const short *tab, const int *idx) {
-  return v_int16x8(_mm_set_epi64x(*(const int64_t *)(tab + idx[1]),
-                                  *(const int64_t *)(tab + idx[0])));
-}
-inline v_uint16x8 v_lut(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v_lut((const short *)tab, idx));
-}
-inline v_uint16x8 v_lut_pairs(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v_lut_pairs((const short *)tab, idx));
-}
-inline v_uint16x8 v_lut_quads(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v_lut_quads((const short *)tab, idx));
-}
-
-inline v_int32x4 v_lut(const int *tab, const int *idx) {
-#if defined(_MSC_VER)
-  return v_int32x4(
-      _mm_setr_epi32(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]));
-#else
-  return v_int32x4(_mm_setr_epi64(_mm_setr_pi32(tab[idx[0]], tab[idx[1]]),
-                                  _mm_setr_pi32(tab[idx[2]], tab[idx[3]])));
-#endif
-}
-inline v_int32x4 v_lut_pairs(const int *tab, const int *idx) {
-  return v_int32x4(_mm_set_epi64x(*(const int64_t *)(tab + idx[1]),
-                                  *(const int64_t *)(tab + idx[0])));
-}
-inline v_int32x4 v_lut_quads(const int *tab, const int *idx) {
-  return v_int32x4(_mm_loadu_si128((const __m128i *)(tab + idx[0])));
-}
-inline v_uint32x4 v_lut(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v_lut((const int *)tab, idx));
-}
-inline v_uint32x4 v_lut_pairs(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v_lut_pairs((const int *)tab, idx));
-}
-inline v_uint32x4 v_lut_quads(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v_lut_quads((const int *)tab, idx));
-}
-
-inline v_int64x2 v_lut(const int64_t *tab, const int *idx) {
-  return v_int64x2(_mm_set_epi64x(tab[idx[1]], tab[idx[0]]));
-}
-inline v_int64x2 v_lut_pairs(const int64_t *tab, const int *idx) {
-  return v_int64x2(_mm_loadu_si128((const __m128i *)(tab + idx[0])));
-}
-inline v_uint64x2 v_lut(const uint64_t *tab, const int *idx) {
-  return v_reinterpret_as_u64(v_lut((const int64_t *)tab, idx));
-}
-inline v_uint64x2 v_lut_pairs(const uint64_t *tab, const int *idx) {
-  return v_reinterpret_as_u64(v_lut_pairs((const int64_t *)tab, idx));
-}
-
-inline v_float32x4 v_lut(const float *tab, const int *idx) {
-  return v_float32x4(
-      _mm_setr_ps(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]));
-}
-inline v_float32x4 v_lut_pairs(const float *tab, const int *idx) {
-  return v_reinterpret_as_f32(v_lut_pairs((const int *)tab, idx));
-}
-inline v_float32x4 v_lut_quads(const float *tab, const int *idx) {
-  return v_reinterpret_as_f32(v_lut_quads((const int *)tab, idx));
-}
-
-inline v_float64x2 v_lut(const double *tab, const int *idx) {
-  return v_float64x2(_mm_setr_pd(tab[idx[0]], tab[idx[1]]));
-}
-inline v_float64x2 v_lut_pairs(const double *tab, const int *idx) {
-  return v_float64x2(
-      _mm_castsi128_pd(_mm_loadu_si128((const __m128i *)(tab + idx[0]))));
-}
-
-inline v_int32x4 v_lut(const int *tab, const v_int32x4 &idxvec) {
-  int CV_DECL_ALIGNED(32) idx[4];
-  v_store_aligned(idx, idxvec);
-  return v_int32x4(
-      _mm_setr_epi32(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]));
-}
-
-inline v_uint32x4 v_lut(const unsigned *tab, const v_int32x4 &idxvec) {
-  return v_reinterpret_as_u32(v_lut((const int *)tab, idxvec));
-}
-
-inline v_float32x4 v_lut(const float *tab, const v_int32x4 &idxvec) {
-  int CV_DECL_ALIGNED(32) idx[4];
-  v_store_aligned(idx, idxvec);
-  return v_float32x4(
-      _mm_setr_ps(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]));
-}
-
-inline v_float64x2 v_lut(const double *tab, const v_int32x4 &idxvec) {
-  int idx[2];
-  v_store_low(idx, idxvec);
-  return v_float64x2(_mm_setr_pd(tab[idx[0]], tab[idx[1]]));
-}
-
-// loads pairs from the table and deinterleaves them, e.g. returns:
-//   x = (tab[idxvec[0], tab[idxvec[1]], tab[idxvec[2]], tab[idxvec[3]]),
-//   y = (tab[idxvec[0]+1], tab[idxvec[1]+1], tab[idxvec[2]+1],
-//   tab[idxvec[3]+1])
-// note that the indices are float's indices, not the float-pair indices.
-// in theory, this function can be used to implement bilinear interpolation,
-// when idxvec are the offsets within the image.
-inline void v_lut_deinterleave(const float *tab, const v_int32x4 &idxvec,
-                               v_float32x4 &x, v_float32x4 &y) {
-  int CV_DECL_ALIGNED(32) idx[4];
-  v_store_aligned(idx, idxvec);
-  __m128 z = _mm_setzero_ps();
-  __m128 xy01 = _mm_loadl_pi(z, (__m64 *)(tab + idx[0]));
-  __m128 xy23 = _mm_loadl_pi(z, (__m64 *)(tab + idx[2]));
-  xy01 = _mm_loadh_pi(xy01, (__m64 *)(tab + idx[1]));
-  xy23 = _mm_loadh_pi(xy23, (__m64 *)(tab + idx[3]));
-  __m128 xxyy02 = _mm_unpacklo_ps(xy01, xy23);
-  __m128 xxyy13 = _mm_unpackhi_ps(xy01, xy23);
-  x = v_float32x4(_mm_unpacklo_ps(xxyy02, xxyy13));
-  y = v_float32x4(_mm_unpackhi_ps(xxyy02, xxyy13));
-}
-
-inline void v_lut_deinterleave(const double *tab, const v_int32x4 &idxvec,
-                               v_float64x2 &x, v_float64x2 &y) {
-  int idx[2];
-  v_store_low(idx, idxvec);
-  __m128d xy0 = _mm_loadu_pd(tab + idx[0]);
-  __m128d xy1 = _mm_loadu_pd(tab + idx[1]);
-  x = v_float64x2(_mm_unpacklo_pd(xy0, xy1));
-  y = v_float64x2(_mm_unpackhi_pd(xy0, xy1));
-}
-
-inline v_int8x16 v_interleave_pairs(const v_int8x16 &vec) {
-#if CV_SSSE3
-  return v_int8x16(_mm_shuffle_epi8(
-      vec.val, _mm_set_epi64x(0x0f0d0e0c0b090a08, 0x0705060403010200)));
-#else
-  __m128i a = _mm_shufflelo_epi16(vec.val, _MM_SHUFFLE(3, 1, 2, 0));
-  a = _mm_shufflehi_epi16(a, _MM_SHUFFLE(3, 1, 2, 0));
-  a = _mm_shuffle_epi32(a, _MM_SHUFFLE(3, 1, 2, 0));
-  return v_int8x16(_mm_unpacklo_epi8(a, _mm_unpackhi_epi64(a, a)));
-#endif
-}
-inline v_uint8x16 v_interleave_pairs(const v_uint8x16 &vec) {
-  return v_reinterpret_as_u8(v_interleave_pairs(v_reinterpret_as_s8(vec)));
-}
-inline v_int8x16 v_interleave_quads(const v_int8x16 &vec) {
-#if CV_SSSE3
-  return v_int8x16(_mm_shuffle_epi8(
-      vec.val, _mm_set_epi64x(0x0f0b0e0a0d090c08, 0x0703060205010400)));
-#else
-  __m128i a = _mm_shuffle_epi32(vec.val, _MM_SHUFFLE(3, 1, 2, 0));
-  return v_int8x16(_mm_unpacklo_epi8(a, _mm_unpackhi_epi64(a, a)));
-#endif
-}
-inline v_uint8x16 v_interleave_quads(const v_uint8x16 &vec) {
-  return v_reinterpret_as_u8(v_interleave_quads(v_reinterpret_as_s8(vec)));
-}
-
-inline v_int16x8 v_interleave_pairs(const v_int16x8 &vec) {
-#if CV_SSSE3
-  return v_int16x8(_mm_shuffle_epi8(
-      vec.val, _mm_set_epi64x(0x0f0e0b0a0d0c0908, 0x0706030205040100)));
-#else
-  __m128i a = _mm_shufflelo_epi16(vec.val, _MM_SHUFFLE(3, 1, 2, 0));
-  return v_int16x8(_mm_shufflehi_epi16(a, _MM_SHUFFLE(3, 1, 2, 0)));
-#endif
-}
-inline v_uint16x8 v_interleave_pairs(const v_uint16x8 &vec) {
-  return v_reinterpret_as_u16(v_interleave_pairs(v_reinterpret_as_s16(vec)));
-}
-inline v_int16x8 v_interleave_quads(const v_int16x8 &vec) {
-#if CV_SSSE3
-  return v_int16x8(_mm_shuffle_epi8(
-      vec.val, _mm_set_epi64x(0x0f0e07060d0c0504, 0x0b0a030209080100)));
-#else
-  return v_int16x8(
-      _mm_unpacklo_epi16(vec.val, _mm_unpackhi_epi64(vec.val, vec.val)));
-#endif
-}
-inline v_uint16x8 v_interleave_quads(const v_uint16x8 &vec) {
-  return v_reinterpret_as_u16(v_interleave_quads(v_reinterpret_as_s16(vec)));
-}
-
-inline v_int32x4 v_interleave_pairs(const v_int32x4 &vec) {
-  return v_int32x4(_mm_shuffle_epi32(vec.val, _MM_SHUFFLE(3, 1, 2, 0)));
-}
-inline v_uint32x4 v_interleave_pairs(const v_uint32x4 &vec) {
-  return v_reinterpret_as_u32(v_interleave_pairs(v_reinterpret_as_s32(vec)));
-}
-inline v_float32x4 v_interleave_pairs(const v_float32x4 &vec) {
-  return v_reinterpret_as_f32(v_interleave_pairs(v_reinterpret_as_s32(vec)));
-}
-
-inline v_int8x16 v_pack_triplets(const v_int8x16 &vec) {
-#if CV_SSSE3
-  return v_int8x16(_mm_shuffle_epi8(
-      vec.val, _mm_set_epi64x(0xffffff0f0e0d0c0a, 0x0908060504020100)));
-#else
-  __m128i mask = _mm_set1_epi64x(0x00000000FFFFFFFF);
-  __m128i a = _mm_srli_si128(
-      _mm_or_si128(
-          _mm_andnot_si128(mask, vec.val),
-          _mm_and_si128(mask, _mm_sll_epi32(vec.val, _mm_set_epi64x(0, 8)))),
-      1);
-  return v_int8x16(
-      _mm_srli_si128(_mm_shufflelo_epi16(a, _MM_SHUFFLE(2, 1, 0, 3)), 2));
-#endif
-}
-inline v_uint8x16 v_pack_triplets(const v_uint8x16 &vec) {
-  return v_reinterpret_as_u8(v_pack_triplets(v_reinterpret_as_s8(vec)));
-}
-
-inline v_int16x8 v_pack_triplets(const v_int16x8 &vec) {
-#if CV_SSSE3
-  return v_int16x8(_mm_shuffle_epi8(
-      vec.val, _mm_set_epi64x(0xffff0f0e0d0c0b0a, 0x0908050403020100)));
-#else
-  return v_int16x8(
-      _mm_srli_si128(_mm_shufflelo_epi16(vec.val, _MM_SHUFFLE(2, 1, 0, 3)), 2));
-#endif
-}
-inline v_uint16x8 v_pack_triplets(const v_uint16x8 &vec) {
-  return v_reinterpret_as_u16(v_pack_triplets(v_reinterpret_as_s16(vec)));
-}
-
-inline v_int32x4 v_pack_triplets(const v_int32x4 &vec) { return vec; }
-inline v_uint32x4 v_pack_triplets(const v_uint32x4 &vec) { return vec; }
-inline v_float32x4 v_pack_triplets(const v_float32x4 &vec) { return vec; }
-
-template <int i> inline uchar v_extract_n(const v_uint8x16 &v) {
-#if CV_SSE4_1
-  return (uchar)_mm_extract_epi8(v.val, i);
-#else
-  return v_rotate_right<i>(v).get0();
-#endif
-}
-
-template <int i> inline schar v_extract_n(const v_int8x16 &v) {
-  return (schar)v_extract_n<i>(v_reinterpret_as_u8(v));
-}
-
-template <int i> inline ushort v_extract_n(const v_uint16x8 &v) {
-  return (ushort)_mm_extract_epi16(v.val, i);
-}
-
-template <int i> inline short v_extract_n(const v_int16x8 &v) {
-  return (short)v_extract_n<i>(v_reinterpret_as_u16(v));
-}
-
-template <int i> inline uint v_extract_n(const v_uint32x4 &v) {
-#if CV_SSE4_1
-  return (uint)_mm_extract_epi32(v.val, i);
-#else
-  return v_rotate_right<i>(v).get0();
-#endif
-}
-
-template <int i> inline int v_extract_n(const v_int32x4 &v) {
-  return (int)v_extract_n<i>(v_reinterpret_as_u32(v));
-}
-
-template <int i> inline uint64 v_extract_n(const v_uint64x2 &v) {
-#ifdef CV__SIMD_NATIVE_mm_extract_epi64
-  return (uint64)_v128_extract_epi64<i>(v.val);
-#else
-  return v_rotate_right<i>(v).get0();
-#endif
-}
-
-template <int i> inline int64 v_extract_n(const v_int64x2 &v) {
-  return (int64)v_extract_n<i>(v_reinterpret_as_u64(v));
-}
-
-template <int i> inline float v_extract_n(const v_float32x4 &v) {
-  union {
-    uint iv;
-    float fv;
-  } d;
-  d.iv = v_extract_n<i>(v_reinterpret_as_u32(v));
-  return d.fv;
-}
-
-template <int i> inline double v_extract_n(const v_float64x2 &v) {
-  union {
-    uint64 iv;
-    double dv;
-  } d;
-  d.iv = v_extract_n<i>(v_reinterpret_as_u64(v));
-  return d.dv;
-}
-
-template <int i> inline v_int32x4 v_broadcast_element(const v_int32x4 &v) {
-  return v_int32x4(_mm_shuffle_epi32(v.val, _MM_SHUFFLE(i, i, i, i)));
-}
-
-template <int i> inline v_uint32x4 v_broadcast_element(const v_uint32x4 &v) {
-  return v_uint32x4(_mm_shuffle_epi32(v.val, _MM_SHUFFLE(i, i, i, i)));
-}
-
-template <int i> inline v_float32x4 v_broadcast_element(const v_float32x4 &v) {
-  return v_float32x4(_mm_shuffle_ps(
-      v.val, v.val, _MM_SHUFFLE((char)i, (char)i, (char)i, (char)i)));
-}
-
-////////////// FP16 support ///////////////////////////
-
-inline v_float32x4 v_load_expand(const hfloat *ptr) {
-#if CV_FP16
-  return v_float32x4(_mm_cvtph_ps(_mm_loadu_si128((const __m128i *)ptr)));
-#else
-  const __m128i z = _mm_setzero_si128(), delta = _mm_set1_epi32(0x38000000);
-  const __m128i signmask = _mm_set1_epi32(0x80000000),
-                maxexp = _mm_set1_epi32(0x7c000000);
-  const __m128 deltaf = _mm_castsi128_ps(_mm_set1_epi32(0x38800000));
-  __m128i bits =
-      _mm_unpacklo_epi16(z, _mm_loadl_epi64((const __m128i *)ptr)); // h << 16
-  __m128i e = _mm_and_si128(bits, maxexp), sign = _mm_and_si128(bits, signmask);
-  __m128i t = _mm_add_epi32(_mm_srli_epi32(_mm_xor_si128(bits, sign), 3),
-                            delta); // ((h & 0x7fff) << 13) + delta
-  __m128i zt = _mm_castps_si128(_mm_sub_ps(
-      _mm_castsi128_ps(_mm_add_epi32(t, _mm_set1_epi32(1 << 23))), deltaf));
-
-  t = _mm_add_epi32(t, _mm_and_si128(delta, _mm_cmpeq_epi32(maxexp, e)));
-  __m128i zmask = _mm_cmpeq_epi32(e, z);
-  __m128i ft = v_select_si128(zmask, zt, t);
-  return v_float32x4(_mm_castsi128_ps(_mm_or_si128(ft, sign)));
-#endif
-}
-
-inline void v_pack_store(hfloat *ptr, const v_float32x4 &v) {
-#if CV_FP16
-  __m128i fp16_value = _mm_cvtps_ph(v.val, 0);
-  _mm_storel_epi64((__m128i *)ptr, fp16_value);
-#else
-  const __m128i signmask = _mm_set1_epi32(0x80000000);
-  const __m128i rval = _mm_set1_epi32(0x3f000000);
-
-  __m128i t = _mm_castps_si128(v.val);
-  __m128i sign = _mm_srai_epi32(_mm_and_si128(t, signmask), 16);
-  t = _mm_andnot_si128(signmask, t);
-
-  __m128i finitemask = _mm_cmpgt_epi32(_mm_set1_epi32(0x47800000), t);
-  __m128i isnan = _mm_cmpgt_epi32(t, _mm_set1_epi32(0x7f800000));
-  __m128i naninf =
-      v_select_si128(isnan, _mm_set1_epi32(0x7e00), _mm_set1_epi32(0x7c00));
-  __m128i tinymask = _mm_cmpgt_epi32(_mm_set1_epi32(0x38800000), t);
-  __m128i tt =
-      _mm_castps_si128(_mm_add_ps(_mm_castsi128_ps(t), _mm_castsi128_ps(rval)));
-  tt = _mm_sub_epi32(tt, rval);
-  __m128i odd = _mm_and_si128(_mm_srli_epi32(t, 13), _mm_set1_epi32(1));
-  __m128i nt = _mm_add_epi32(t, _mm_set1_epi32(0xc8000fff));
-  nt = _mm_srli_epi32(_mm_add_epi32(nt, odd), 13);
-  t = v_select_si128(tinymask, tt, nt);
-  t = v_select_si128(finitemask, t, naninf);
-  t = _mm_or_si128(t, sign);
-  t = _mm_packs_epi32(t, t);
-  _mm_storel_epi64((__m128i *)ptr, t);
-#endif
-}
-
-inline void v_cleanup() {}
-
-#include "intrin_math.hpp"
-inline v_float32x4 v_exp(const v_float32x4 &x) {
-  return v_exp_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline v_float32x4 v_log(const v_float32x4 &x) {
-  return v_log_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline void v_sincos(const v_float32x4 &x, v_float32x4 &s, v_float32x4 &c) {
-  v_sincos_default_32f<v_float32x4, v_int32x4>(x, s, c);
-}
-inline v_float32x4 v_sin(const v_float32x4 &x) {
-  return v_sin_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline v_float32x4 v_cos(const v_float32x4 &x) {
-  return v_cos_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline v_float32x4 v_erf(const v_float32x4 &x) {
-  return v_erf_default_32f<v_float32x4, v_int32x4>(x);
-}
-
-inline v_float64x2 v_exp(const v_float64x2 &x) {
-  return v_exp_default_64f<v_float64x2, v_int64x2>(x);
-}
-inline v_float64x2 v_log(const v_float64x2 &x) {
-  return v_log_default_64f<v_float64x2, v_int64x2>(x);
-}
-inline void v_sincos(const v_float64x2 &x, v_float64x2 &s, v_float64x2 &c) {
-  v_sincos_default_64f<v_float64x2, v_int64x2>(x, s, c);
-}
-inline v_float64x2 v_sin(const v_float64x2 &x) {
-  return v_sin_default_64f<v_float64x2, v_int64x2>(x);
-}
-inline v_float64x2 v_cos(const v_float64x2 &x) {
-  return v_cos_default_64f<v_float64x2, v_int64x2>(x);
-}
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_END
-
-//! @endcond
-
-} // namespace cv
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_sse_em.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_sse_em.hpp
deleted file mode 100644
index 78612034d3..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_sse_em.hpp
+++ /dev/null
@@ -1,175 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html
-
-#ifndef OPENCV_HAL_INTRIN_SSE_EM_HPP
-#define OPENCV_HAL_INTRIN_SSE_EM_HPP
-
-namespace cv {
-
-//! @cond IGNORED
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_BEGIN
-
-#define OPENCV_HAL_SSE_WRAP_1(fun, tp)                                         \
-  inline tp _v128_##fun(const tp &a) { return _mm_##fun(a); }
-
-#define OPENCV_HAL_SSE_WRAP_2(fun, tp)                                         \
-  inline tp _v128_##fun(const tp &a, const tp &b) { return _mm_##fun(a, b); }
-
-#define OPENCV_HAL_SSE_WRAP_3(fun, tp)                                         \
-  inline tp _v128_##fun(const tp &a, const tp &b, const tp &c) {               \
-    return _mm_##fun(a, b, c);                                                 \
-  }
-
-///////////////////////////// XOP /////////////////////////////
-
-// [todo] define CV_XOP
-#if 1 // CV_XOP
-inline __m128i _v128_comgt_epu32(const __m128i &a, const __m128i &b) {
-  const __m128i delta = _mm_set1_epi32((int)0x80000000);
-  return _mm_cmpgt_epi32(_mm_xor_si128(a, delta), _mm_xor_si128(b, delta));
-}
-// wrapping XOP
-#else
-OPENCV_HAL_SSE_WRAP_2(_v128_comgt_epu32, __m128i)
-#endif // !CV_XOP
-
-///////////////////////////// SSE4.1 /////////////////////////////
-
-#if !CV_SSE4_1
-
-/** Swizzle **/
-inline __m128i _v128_blendv_epi8(const __m128i &a, const __m128i &b,
-                                 const __m128i &mask) {
-  return _mm_xor_si128(a, _mm_and_si128(_mm_xor_si128(b, a), mask));
-}
-
-/** Convert **/
-// 8 >> 16
-inline __m128i _v128_cvtepu8_epi16(const __m128i &a) {
-  const __m128i z = _mm_setzero_si128();
-  return _mm_unpacklo_epi8(a, z);
-}
-inline __m128i _v128_cvtepi8_epi16(const __m128i &a) {
-  return _mm_srai_epi16(_mm_unpacklo_epi8(a, a), 8);
-}
-// 8 >> 32
-inline __m128i _v128_cvtepu8_epi32(const __m128i &a) {
-  const __m128i z = _mm_setzero_si128();
-  return _mm_unpacklo_epi16(_mm_unpacklo_epi8(a, z), z);
-}
-inline __m128i _v128_cvtepi8_epi32(const __m128i &a) {
-  __m128i r = _mm_unpacklo_epi8(a, a);
-  r = _mm_unpacklo_epi8(r, r);
-  return _mm_srai_epi32(r, 24);
-}
-// 16 >> 32
-inline __m128i _v128_cvtepu16_epi32(const __m128i &a) {
-  const __m128i z = _mm_setzero_si128();
-  return _mm_unpacklo_epi16(a, z);
-}
-inline __m128i _v128_cvtepi16_epi32(const __m128i &a) {
-  return _mm_srai_epi32(_mm_unpacklo_epi16(a, a), 16);
-}
-// 32 >> 64
-inline __m128i _v128_cvtepu32_epi64(const __m128i &a) {
-  const __m128i z = _mm_setzero_si128();
-  return _mm_unpacklo_epi32(a, z);
-}
-inline __m128i _v128_cvtepi32_epi64(const __m128i &a) {
-  return _mm_unpacklo_epi32(a, _mm_srai_epi32(a, 31));
-}
-
-/** Arithmetic **/
-inline __m128i _v128_mullo_epi32(const __m128i &a, const __m128i &b) {
-  __m128i c0 = _mm_mul_epu32(a, b);
-  __m128i c1 = _mm_mul_epu32(_mm_srli_epi64(a, 32), _mm_srli_epi64(b, 32));
-  __m128i d0 = _mm_unpacklo_epi32(c0, c1);
-  __m128i d1 = _mm_unpackhi_epi32(c0, c1);
-  return _mm_unpacklo_epi64(d0, d1);
-}
-
-/** Math **/
-inline __m128i _v128_min_epu32(const __m128i &a, const __m128i &b) {
-  return _v128_blendv_epi8(a, b, _v128_comgt_epu32(a, b));
-}
-
-// wrapping SSE4.1
-#else
-OPENCV_HAL_SSE_WRAP_1(cvtepu8_epi16, __m128i)
-OPENCV_HAL_SSE_WRAP_1(cvtepi8_epi16, __m128i)
-OPENCV_HAL_SSE_WRAP_1(cvtepu8_epi32, __m128i)
-OPENCV_HAL_SSE_WRAP_1(cvtepi8_epi32, __m128i)
-OPENCV_HAL_SSE_WRAP_1(cvtepu16_epi32, __m128i)
-OPENCV_HAL_SSE_WRAP_1(cvtepi16_epi32, __m128i)
-OPENCV_HAL_SSE_WRAP_1(cvtepu32_epi64, __m128i)
-OPENCV_HAL_SSE_WRAP_1(cvtepi32_epi64, __m128i)
-OPENCV_HAL_SSE_WRAP_2(min_epu32, __m128i)
-OPENCV_HAL_SSE_WRAP_2(mullo_epi32, __m128i)
-OPENCV_HAL_SSE_WRAP_3(blendv_epi8, __m128i)
-#endif // !CV_SSE4_1
-
-///////////////////////////// Revolutionary /////////////////////////////
-
-/** Convert **/
-// 16 << 8
-inline __m128i _v128_cvtepu8_epi16_high(const __m128i &a) {
-  const __m128i z = _mm_setzero_si128();
-  return _mm_unpackhi_epi8(a, z);
-}
-inline __m128i _v128_cvtepi8_epi16_high(const __m128i &a) {
-  return _mm_srai_epi16(_mm_unpackhi_epi8(a, a), 8);
-}
-// 32 << 16
-inline __m128i _v128_cvtepu16_epi32_high(const __m128i &a) {
-  const __m128i z = _mm_setzero_si128();
-  return _mm_unpackhi_epi16(a, z);
-}
-inline __m128i _v128_cvtepi16_epi32_high(const __m128i &a) {
-  return _mm_srai_epi32(_mm_unpackhi_epi16(a, a), 16);
-}
-// 64 << 32
-inline __m128i _v128_cvtepu32_epi64_high(const __m128i &a) {
-  const __m128i z = _mm_setzero_si128();
-  return _mm_unpackhi_epi32(a, z);
-}
-inline __m128i _v128_cvtepi32_epi64_high(const __m128i &a) {
-  return _mm_unpackhi_epi32(a, _mm_srai_epi32(a, 31));
-}
-
-/** Miscellaneous **/
-inline __m128i _v128_packs_epu32(const __m128i &a, const __m128i &b) {
-  const __m128i m = _mm_set1_epi32(65535);
-  __m128i am = _v128_min_epu32(a, m);
-  __m128i bm = _v128_min_epu32(b, m);
-#if CV_SSE4_1
-  return _mm_packus_epi32(am, bm);
-#else
-  const __m128i d = _mm_set1_epi32(32768), nd = _mm_set1_epi16(-32768);
-  am = _mm_sub_epi32(am, d);
-  bm = _mm_sub_epi32(bm, d);
-  am = _mm_packs_epi32(am, bm);
-  return _mm_sub_epi16(am, nd);
-#endif
-}
-
-template <int i> inline int64 _v128_extract_epi64(const __m128i &a) {
-#if defined(CV__SIMD_HAVE_mm_extract_epi64) ||                                 \
-    (CV_SSE4_1 && (defined(__x86_64__) /*GCC*/ || defined(_M_X64) /*MSVC*/))
-#define CV__SIMD_NATIVE_mm_extract_epi64 1
-  return _mm_extract_epi64(a, i);
-#else
-  CV_DECL_ALIGNED(16) int64 tmp[2];
-  _mm_store_si128((__m128i *)tmp, a);
-  return tmp[i];
-#endif
-}
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_END
-
-//! @endcond
-
-} // namespace cv
-
-#endif // OPENCV_HAL_INTRIN_SSE_EM_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_vsx.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_vsx.hpp
deleted file mode 100644
index d9783795ad..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_vsx.hpp
+++ /dev/null
@@ -1,1756 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html
-
-#ifndef OPENCV_HAL_VSX_HPP
-#define OPENCV_HAL_VSX_HPP
-
-#include "opencv2/core/utility.hpp"
-#include <algorithm>
-
-#define CV_SIMD128 1
-#define CV_SIMD128_64F 1
-
-namespace cv {
-
-//! @cond IGNORED
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_BEGIN
-
-///////// Types ////////////
-
-struct v_uint8x16 {
-  typedef uchar lane_type;
-  enum { nlanes = 16 };
-  vec_uchar16 val;
-
-  explicit v_uint8x16(const vec_uchar16 &v) : val(v) {}
-  v_uint8x16() {}
-  v_uint8x16(vec_bchar16 v) : val(vec_uchar16_c(v)) {}
-  v_uint8x16(uchar v0, uchar v1, uchar v2, uchar v3, uchar v4, uchar v5,
-             uchar v6, uchar v7, uchar v8, uchar v9, uchar v10, uchar v11,
-             uchar v12, uchar v13, uchar v14, uchar v15)
-      : val(vec_uchar16_set(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
-                            v12, v13, v14, v15)) {}
-
-  static inline v_uint8x16 zero() { return v_uint8x16(vec_uchar16_z); }
-
-  uchar get0() const { return vec_extract(val, 0); }
-};
-
-struct v_int8x16 {
-  typedef schar lane_type;
-  enum { nlanes = 16 };
-  vec_char16 val;
-
-  explicit v_int8x16(const vec_char16 &v) : val(v) {}
-  v_int8x16() {}
-  v_int8x16(vec_bchar16 v) : val(vec_char16_c(v)) {}
-  v_int8x16(schar v0, schar v1, schar v2, schar v3, schar v4, schar v5,
-            schar v6, schar v7, schar v8, schar v9, schar v10, schar v11,
-            schar v12, schar v13, schar v14, schar v15)
-      : val(vec_char16_set(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
-                           v12, v13, v14, v15)) {}
-
-  static inline v_int8x16 zero() { return v_int8x16(vec_char16_z); }
-
-  schar get0() const { return vec_extract(val, 0); }
-};
-
-struct v_uint16x8 {
-  typedef ushort lane_type;
-  enum { nlanes = 8 };
-  vec_ushort8 val;
-
-  explicit v_uint16x8(const vec_ushort8 &v) : val(v) {}
-  v_uint16x8() {}
-  v_uint16x8(vec_bshort8 v) : val(vec_ushort8_c(v)) {}
-  v_uint16x8(ushort v0, ushort v1, ushort v2, ushort v3, ushort v4, ushort v5,
-             ushort v6, ushort v7)
-      : val(vec_ushort8_set(v0, v1, v2, v3, v4, v5, v6, v7)) {}
-
-  static inline v_uint16x8 zero() { return v_uint16x8(vec_ushort8_z); }
-
-  ushort get0() const { return vec_extract(val, 0); }
-};
-
-struct v_int16x8 {
-  typedef short lane_type;
-  enum { nlanes = 8 };
-  vec_short8 val;
-
-  explicit v_int16x8(const vec_short8 &v) : val(v) {}
-  v_int16x8() {}
-  v_int16x8(vec_bshort8 v) : val(vec_short8_c(v)) {}
-  v_int16x8(short v0, short v1, short v2, short v3, short v4, short v5,
-            short v6, short v7)
-      : val(vec_short8_set(v0, v1, v2, v3, v4, v5, v6, v7)) {}
-
-  static inline v_int16x8 zero() { return v_int16x8(vec_short8_z); }
-
-  short get0() const { return vec_extract(val, 0); }
-};
-
-struct v_uint32x4 {
-  typedef unsigned lane_type;
-  enum { nlanes = 4 };
-  vec_uint4 val;
-
-  explicit v_uint32x4(const vec_uint4 &v) : val(v) {}
-  v_uint32x4() {}
-  v_uint32x4(vec_bint4 v) : val(vec_uint4_c(v)) {}
-  v_uint32x4(unsigned v0, unsigned v1, unsigned v2, unsigned v3)
-      : val(vec_uint4_set(v0, v1, v2, v3)) {}
-
-  static inline v_uint32x4 zero() { return v_uint32x4(vec_uint4_z); }
-
-  uint get0() const { return vec_extract(val, 0); }
-};
-
-struct v_int32x4 {
-  typedef int lane_type;
-  enum { nlanes = 4 };
-  vec_int4 val;
-
-  explicit v_int32x4(const vec_int4 &v) : val(v) {}
-  v_int32x4() {}
-  v_int32x4(vec_bint4 v) : val(vec_int4_c(v)) {}
-  v_int32x4(int v0, int v1, int v2, int v3)
-      : val(vec_int4_set(v0, v1, v2, v3)) {}
-
-  static inline v_int32x4 zero() { return v_int32x4(vec_int4_z); }
-
-  int get0() const { return vec_extract(val, 0); }
-};
-
-struct v_float32x4 {
-  typedef float lane_type;
-  enum { nlanes = 4 };
-  vec_float4 val;
-
-  explicit v_float32x4(const vec_float4 &v) : val(v) {}
-  v_float32x4() {}
-  v_float32x4(vec_bint4 v) : val(vec_float4_c(v)) {}
-  v_float32x4(float v0, float v1, float v2, float v3)
-      : val(vec_float4_set(v0, v1, v2, v3)) {}
-
-  static inline v_float32x4 zero() { return v_float32x4(vec_float4_z); }
-
-  float get0() const { return vec_extract(val, 0); }
-};
-
-struct v_uint64x2 {
-  typedef uint64 lane_type;
-  enum { nlanes = 2 };
-  vec_udword2 val;
-
-  explicit v_uint64x2(const vec_udword2 &v) : val(v) {}
-  v_uint64x2() {}
-  v_uint64x2(vec_bdword2 v) : val(vec_udword2_c(v)) {}
-  v_uint64x2(uint64 v0, uint64 v1) : val(vec_udword2_set(v0, v1)) {}
-
-  static inline v_uint64x2 zero() { return v_uint64x2(vec_udword2_z); }
-
-  uint64 get0() const { return vec_extract(val, 0); }
-};
-
-struct v_int64x2 {
-  typedef int64 lane_type;
-  enum { nlanes = 2 };
-  vec_dword2 val;
-
-  explicit v_int64x2(const vec_dword2 &v) : val(v) {}
-  v_int64x2() {}
-  v_int64x2(vec_bdword2 v) : val(vec_dword2_c(v)) {}
-  v_int64x2(int64 v0, int64 v1) : val(vec_dword2_set(v0, v1)) {}
-
-  static inline v_int64x2 zero() { return v_int64x2(vec_dword2_z); }
-
-  int64 get0() const { return vec_extract(val, 0); }
-};
-
-struct v_float64x2 {
-  typedef double lane_type;
-  enum { nlanes = 2 };
-  vec_double2 val;
-
-  explicit v_float64x2(const vec_double2 &v) : val(v) {}
-  v_float64x2() {}
-  v_float64x2(vec_bdword2 v) : val(vec_double2_c(v)) {}
-  v_float64x2(double v0, double v1) : val(vec_double2_set(v0, v1)) {}
-
-  static inline v_float64x2 zero() { return v_float64x2(vec_double2_z); }
-
-  double get0() const { return vec_extract(val, 0); }
-};
-
-#define OPENCV_HAL_IMPL_VSX_EXTRACT_N(_Tpvec, _Tp)                             \
-  template <int i> inline _Tp v_extract_n(VSX_UNUSED(_Tpvec v)) {              \
-    return vec_extract(v.val, i);                                              \
-  }
-
-OPENCV_HAL_IMPL_VSX_EXTRACT_N(v_uint8x16, uchar)
-OPENCV_HAL_IMPL_VSX_EXTRACT_N(v_int8x16, schar)
-OPENCV_HAL_IMPL_VSX_EXTRACT_N(v_uint16x8, ushort)
-OPENCV_HAL_IMPL_VSX_EXTRACT_N(v_int16x8, short)
-OPENCV_HAL_IMPL_VSX_EXTRACT_N(v_uint32x4, uint)
-OPENCV_HAL_IMPL_VSX_EXTRACT_N(v_int32x4, int)
-OPENCV_HAL_IMPL_VSX_EXTRACT_N(v_uint64x2, uint64)
-OPENCV_HAL_IMPL_VSX_EXTRACT_N(v_int64x2, int64)
-OPENCV_HAL_IMPL_VSX_EXTRACT_N(v_float32x4, float)
-OPENCV_HAL_IMPL_VSX_EXTRACT_N(v_float64x2, double)
-
-//////////////// Load and store operations ///////////////
-
-/*
- * clang-5 aborted during parse "vec_xxx_c" only if it's
- * inside a function template which is defined by preprocessor macro.
- *
- * if vec_xxx_c defined as C++ cast, clang-5 will pass it
- */
-#define OPENCV_HAL_IMPL_VSX_INITVEC(_Tpvec, _Tp, suffix, cast)                 \
-  inline _Tpvec v_setzero_##suffix() { return _Tpvec(vec_splats((_Tp)0)); }    \
-  inline _Tpvec v_setall_##suffix(_Tp v) {                                     \
-    return _Tpvec(vec_splats((_Tp)v));                                         \
-  }                                                                            \
-  template <> inline _Tpvec v_setzero_() { return v_setzero_##suffix(); }      \
-  template <> inline _Tpvec v_setall_(_Tp v) {                                 \
-    return v_setall_##suffix(_Tp v);                                           \
-  }                                                                            \
-  template <typename _Tpvec0>                                                  \
-  inline _Tpvec v_reinterpret_as_##suffix(const _Tpvec0 &a) {                  \
-    return _Tpvec((cast)a.val);                                                \
-  }
-
-OPENCV_HAL_IMPL_VSX_INITVEC(v_uint8x16, uchar, u8, vec_uchar16)
-OPENCV_HAL_IMPL_VSX_INITVEC(v_int8x16, schar, s8, vec_char16)
-OPENCV_HAL_IMPL_VSX_INITVEC(v_uint16x8, ushort, u16, vec_ushort8)
-OPENCV_HAL_IMPL_VSX_INITVEC(v_int16x8, short, s16, vec_short8)
-OPENCV_HAL_IMPL_VSX_INITVEC(v_uint32x4, uint, u32, vec_uint4)
-OPENCV_HAL_IMPL_VSX_INITVEC(v_int32x4, int, s32, vec_int4)
-OPENCV_HAL_IMPL_VSX_INITVEC(v_uint64x2, uint64, u64, vec_udword2)
-OPENCV_HAL_IMPL_VSX_INITVEC(v_int64x2, int64, s64, vec_dword2)
-OPENCV_HAL_IMPL_VSX_INITVEC(v_float32x4, float, f32, vec_float4)
-OPENCV_HAL_IMPL_VSX_INITVEC(v_float64x2, double, f64, vec_double2)
-
-#define OPENCV_HAL_IMPL_VSX_LOADSTORE_C(_Tpvec, _Tp, ld, ld_a, st, st_a)       \
-  inline _Tpvec v_load(const _Tp *ptr) { return _Tpvec(ld(0, ptr)); }          \
-  inline _Tpvec v_load_aligned(VSX_UNUSED(const _Tp *ptr)) {                   \
-    return _Tpvec(ld_a(0, ptr));                                               \
-  }                                                                            \
-  inline _Tpvec v_load_low(const _Tp *ptr) { return _Tpvec(vec_ld_l8(ptr)); }  \
-  inline _Tpvec v_load_halves(const _Tp *ptr0, const _Tp *ptr1) {              \
-    return _Tpvec(vec_mergesqh(vec_ld_l8(ptr0), vec_ld_l8(ptr1)));             \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a) { st(a.val, 0, ptr); }        \
-  inline void v_store_aligned(VSX_UNUSED(_Tp *ptr), const _Tpvec &a) {         \
-    st_a(a.val, 0, ptr);                                                       \
-  }                                                                            \
-  inline void v_store_aligned_nocache(VSX_UNUSED(_Tp *ptr), const _Tpvec &a) { \
-    st_a(a.val, 0, ptr);                                                       \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a, hal::StoreMode mode) {        \
-    if (mode == hal::STORE_UNALIGNED)                                          \
-      st(a.val, 0, ptr);                                                       \
-    else                                                                       \
-      st_a(a.val, 0, ptr);                                                     \
-  }                                                                            \
-  inline void v_store_low(_Tp *ptr, const _Tpvec &a) {                         \
-    vec_st_l8(a.val, ptr);                                                     \
-  }                                                                            \
-  inline void v_store_high(_Tp *ptr, const _Tpvec &a) { vec_st_h8(a.val, ptr); }
-
-// working around gcc bug for aligned ld/st
-// if runtime check for vec_ld/st fail we failback to unaligned ld/st
-// https://github.com/opencv/opencv/issues/13211
-#ifdef CV_COMPILER_VSX_BROKEN_ALIGNED
-#define OPENCV_HAL_IMPL_VSX_LOADSTORE(_Tpvec, _Tp)                             \
-  OPENCV_HAL_IMPL_VSX_LOADSTORE_C(_Tpvec, _Tp, vsx_ld, vsx_ld, vsx_st, vsx_st)
-#else
-#define OPENCV_HAL_IMPL_VSX_LOADSTORE(_Tpvec, _Tp)                             \
-  OPENCV_HAL_IMPL_VSX_LOADSTORE_C(_Tpvec, _Tp, vsx_ld, vec_ld, vsx_st, vec_st)
-#endif
-
-OPENCV_HAL_IMPL_VSX_LOADSTORE(v_uint8x16, uchar)
-OPENCV_HAL_IMPL_VSX_LOADSTORE(v_int8x16, schar)
-OPENCV_HAL_IMPL_VSX_LOADSTORE(v_uint16x8, ushort)
-OPENCV_HAL_IMPL_VSX_LOADSTORE(v_int16x8, short)
-OPENCV_HAL_IMPL_VSX_LOADSTORE(v_uint32x4, uint)
-OPENCV_HAL_IMPL_VSX_LOADSTORE(v_int32x4, int)
-OPENCV_HAL_IMPL_VSX_LOADSTORE(v_float32x4, float)
-
-OPENCV_HAL_IMPL_VSX_LOADSTORE_C(v_float64x2, double, vsx_ld, vsx_ld, vsx_st,
-                                vsx_st)
-OPENCV_HAL_IMPL_VSX_LOADSTORE_C(v_uint64x2, uint64, vsx_ld2, vsx_ld2, vsx_st2,
-                                vsx_st2)
-OPENCV_HAL_IMPL_VSX_LOADSTORE_C(v_int64x2, int64, vsx_ld2, vsx_ld2, vsx_st2,
-                                vsx_st2)
-
-//////////////// Value reordering ///////////////
-
-/* de&interleave */
-#define OPENCV_HAL_IMPL_VSX_INTERLEAVE(_Tp, _Tpvec)                            \
-  inline void v_load_deinterleave(const _Tp *ptr, _Tpvec &a, _Tpvec &b) {      \
-    vec_ld_deinterleave(ptr, a.val, b.val);                                    \
-  }                                                                            \
-  inline void v_load_deinterleave(const _Tp *ptr, _Tpvec &a, _Tpvec &b,        \
-                                  _Tpvec &c) {                                 \
-    vec_ld_deinterleave(ptr, a.val, b.val, c.val);                             \
-  }                                                                            \
-  inline void v_load_deinterleave(const _Tp *ptr, _Tpvec &a, _Tpvec &b,        \
-                                  _Tpvec &c, _Tpvec &d) {                      \
-    vec_ld_deinterleave(ptr, a.val, b.val, c.val, d.val);                      \
-  }                                                                            \
-  inline void v_store_interleave(_Tp *ptr, const _Tpvec &a, const _Tpvec &b,   \
-                                 hal::StoreMode /*mode*/ =                     \
-                                     hal::STORE_UNALIGNED) {                   \
-    vec_st_interleave(a.val, b.val, ptr);                                      \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp *ptr, const _Tpvec &a, const _Tpvec &b, const _Tpvec &c,             \
-      hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {                        \
-    vec_st_interleave(a.val, b.val, c.val, ptr);                               \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp *ptr, const _Tpvec &a, const _Tpvec &b, const _Tpvec &c,             \
-      const _Tpvec &d, hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {       \
-    vec_st_interleave(a.val, b.val, c.val, d.val, ptr);                        \
-  }
-
-OPENCV_HAL_IMPL_VSX_INTERLEAVE(uchar, v_uint8x16)
-OPENCV_HAL_IMPL_VSX_INTERLEAVE(schar, v_int8x16)
-OPENCV_HAL_IMPL_VSX_INTERLEAVE(ushort, v_uint16x8)
-OPENCV_HAL_IMPL_VSX_INTERLEAVE(short, v_int16x8)
-OPENCV_HAL_IMPL_VSX_INTERLEAVE(uint, v_uint32x4)
-OPENCV_HAL_IMPL_VSX_INTERLEAVE(int, v_int32x4)
-OPENCV_HAL_IMPL_VSX_INTERLEAVE(float, v_float32x4)
-OPENCV_HAL_IMPL_VSX_INTERLEAVE(double, v_float64x2)
-OPENCV_HAL_IMPL_VSX_INTERLEAVE(int64, v_int64x2)
-OPENCV_HAL_IMPL_VSX_INTERLEAVE(uint64, v_uint64x2)
-
-/* Expand */
-#define OPENCV_HAL_IMPL_VSX_EXPAND(_Tpvec, _Tpwvec, _Tp, fl, fh)               \
-  inline void v_expand(const _Tpvec &a, _Tpwvec &b0, _Tpwvec &b1) {            \
-    b0.val = fh(a.val);                                                        \
-    b1.val = fl(a.val);                                                        \
-  }                                                                            \
-  inline _Tpwvec v_expand_low(const _Tpvec &a) { return _Tpwvec(fh(a.val)); }  \
-  inline _Tpwvec v_expand_high(const _Tpvec &a) { return _Tpwvec(fl(a.val)); } \
-  inline _Tpwvec v_load_expand(const _Tp *ptr) {                               \
-    return _Tpwvec(fh(vec_ld_l8(ptr)));                                        \
-  }
-
-OPENCV_HAL_IMPL_VSX_EXPAND(v_uint8x16, v_uint16x8, uchar, vec_unpacklu,
-                           vec_unpackhu)
-OPENCV_HAL_IMPL_VSX_EXPAND(v_int8x16, v_int16x8, schar, vec_unpackl,
-                           vec_unpackh)
-OPENCV_HAL_IMPL_VSX_EXPAND(v_uint16x8, v_uint32x4, ushort, vec_unpacklu,
-                           vec_unpackhu)
-OPENCV_HAL_IMPL_VSX_EXPAND(v_int16x8, v_int32x4, short, vec_unpackl,
-                           vec_unpackh)
-OPENCV_HAL_IMPL_VSX_EXPAND(v_uint32x4, v_uint64x2, uint, vec_unpacklu,
-                           vec_unpackhu)
-OPENCV_HAL_IMPL_VSX_EXPAND(v_int32x4, v_int64x2, int, vec_unpackl, vec_unpackh)
-
-/* Load and zero expand a 4 byte value into the second dword, first is don't
- * care. */
-#if !defined(CV_COMPILER_VSX_BROKEN_ASM)
-#define _LXSIWZX(out, ptr, T)                                                  \
-  __asm__("lxsiwzx %x0, 0, %1\r\n" : "=wa"(out) : "r"(ptr) : "memory");
-#else
-/* This is compiler-agnostic, but will introduce an unneeded splat on the
- * critical path. */
-#define _LXSIWZX(out, ptr, T) out = (T)vec_udword2_sp(*(uint32_t *)(ptr));
-#endif
-
-inline v_uint32x4 v_load_expand_q(const uchar *ptr) {
-  // Zero-extend the extra 24B instead of unpacking. Usually faster in small
-  // kernel Likewise note, value is zero extended and upper 4 bytes are zero'ed.
-  vec_uchar16 pmu = {8,  12, 12, 12, 9,  12, 12, 12,
-                     10, 12, 12, 12, 11, 12, 12, 12};
-  vec_uchar16 out;
-
-  _LXSIWZX(out, ptr, vec_uchar16);
-  out = vec_perm(out, out, pmu);
-  return v_uint32x4((vec_uint4)out);
-}
-
-inline v_int32x4 v_load_expand_q(const schar *ptr) {
-  vec_char16 out;
-  vec_short8 outs;
-  vec_int4 outw;
-
-  _LXSIWZX(out, ptr, vec_char16);
-  outs = vec_unpackl(out);
-  outw = vec_unpackh(outs);
-  return v_int32x4(outw);
-}
-
-/* pack */
-#define OPENCV_HAL_IMPL_VSX_PACK(_Tpvec, _Tp, _Tpwvec, _Tpvn, _Tpdel, sfnc,    \
-                                 pkfnc, addfnc, pack)                          \
-  inline _Tpvec v_##pack(const _Tpwvec &a, const _Tpwvec &b) {                 \
-    return _Tpvec(pkfnc(a.val, b.val));                                        \
-  }                                                                            \
-  inline void v_##pack##_store(_Tp *ptr, const _Tpwvec &a) {                   \
-    vec_st_l8(pkfnc(a.val, a.val), ptr);                                       \
-  }                                                                            \
-  template <int n>                                                             \
-  inline _Tpvec v_rshr_##pack(const _Tpwvec &a, const _Tpwvec &b) {            \
-    const __vector _Tpvn vn = vec_splats((_Tpvn)n);                            \
-    const __vector _Tpdel delta = vec_splats((_Tpdel)((_Tpdel)1 << (n - 1)));  \
-    return _Tpvec(pkfnc(sfnc(addfnc(a.val, delta), vn),                        \
-                        sfnc(addfnc(b.val, delta), vn)));                      \
-  }                                                                            \
-  template <int n>                                                             \
-  inline void v_rshr_##pack##_store(_Tp *ptr, const _Tpwvec &a) {              \
-    const __vector _Tpvn vn = vec_splats((_Tpvn)n);                            \
-    const __vector _Tpdel delta = vec_splats((_Tpdel)((_Tpdel)1 << (n - 1)));  \
-    vec_st_l8(pkfnc(sfnc(addfnc(a.val, delta), vn), delta), ptr);              \
-  }
-
-OPENCV_HAL_IMPL_VSX_PACK(v_uint8x16, uchar, v_uint16x8, unsigned short,
-                         unsigned short, vec_sr, vec_packs, vec_adds, pack)
-OPENCV_HAL_IMPL_VSX_PACK(v_int8x16, schar, v_int16x8, unsigned short, short,
-                         vec_sra, vec_packs, vec_adds, pack)
-
-OPENCV_HAL_IMPL_VSX_PACK(v_uint16x8, ushort, v_uint32x4, unsigned int,
-                         unsigned int, vec_sr, vec_packs, vec_add, pack)
-OPENCV_HAL_IMPL_VSX_PACK(v_int16x8, short, v_int32x4, unsigned int, int,
-                         vec_sra, vec_packs, vec_add, pack)
-
-OPENCV_HAL_IMPL_VSX_PACK(v_uint32x4, uint, v_uint64x2, unsigned long long,
-                         unsigned long long, vec_sr, vec_pack, vec_add, pack)
-OPENCV_HAL_IMPL_VSX_PACK(v_int32x4, int, v_int64x2, unsigned long long,
-                         long long, vec_sra, vec_pack, vec_add, pack)
-
-OPENCV_HAL_IMPL_VSX_PACK(v_uint8x16, uchar, v_int16x8, unsigned short, short,
-                         vec_sra, vec_packsu, vec_adds, pack_u)
-OPENCV_HAL_IMPL_VSX_PACK(v_uint16x8, ushort, v_int32x4, unsigned int, int,
-                         vec_sra, vec_packsu, vec_add, pack_u)
-// Following variant is not implemented on other platforms:
-// OPENCV_HAL_IMPL_VSX_PACK(v_uint32x4, uint, v_int64x2, unsigned long long,
-// long long,
-//                         vec_sra, vec_packsu, vec_add, pack_u)
-
-// pack boolean
-inline v_uint8x16 v_pack_b(const v_uint16x8 &a, const v_uint16x8 &b) {
-  vec_uchar16 ab = vec_pack(a.val, b.val);
-  return v_uint8x16(ab);
-}
-
-inline v_uint8x16 v_pack_b(const v_uint32x4 &a, const v_uint32x4 &b,
-                           const v_uint32x4 &c, const v_uint32x4 &d) {
-  vec_ushort8 ab = vec_pack(a.val, b.val);
-  vec_ushort8 cd = vec_pack(c.val, d.val);
-  return v_uint8x16(vec_pack(ab, cd));
-}
-
-inline v_uint8x16 v_pack_b(const v_uint64x2 &a, const v_uint64x2 &b,
-                           const v_uint64x2 &c, const v_uint64x2 &d,
-                           const v_uint64x2 &e, const v_uint64x2 &f,
-                           const v_uint64x2 &g, const v_uint64x2 &h) {
-  vec_uint4 ab = vec_pack(a.val, b.val);
-  vec_uint4 cd = vec_pack(c.val, d.val);
-  vec_uint4 ef = vec_pack(e.val, f.val);
-  vec_uint4 gh = vec_pack(g.val, h.val);
-
-  vec_ushort8 abcd = vec_pack(ab, cd);
-  vec_ushort8 efgh = vec_pack(ef, gh);
-  return v_uint8x16(vec_pack(abcd, efgh));
-}
-
-/* Recombine */
-template <typename _Tpvec>
-inline void v_zip(const _Tpvec &a0, const _Tpvec &a1, _Tpvec &b0, _Tpvec &b1) {
-  b0.val = vec_mergeh(a0.val, a1.val);
-  b1.val = vec_mergel(a0.val, a1.val);
-}
-
-template <typename _Tpvec>
-inline _Tpvec v_combine_high(const _Tpvec &a, const _Tpvec &b) {
-  return _Tpvec(vec_mergesql(a.val, b.val));
-}
-
-template <typename _Tpvec>
-inline _Tpvec v_combine_low(const _Tpvec &a, const _Tpvec &b) {
-  return _Tpvec(vec_mergesqh(a.val, b.val));
-}
-
-template <typename _Tpvec>
-inline void v_recombine(const _Tpvec &a, const _Tpvec &b, _Tpvec &c,
-                        _Tpvec &d) {
-  c.val = vec_mergesqh(a.val, b.val);
-  d.val = vec_mergesql(a.val, b.val);
-}
-
-////////// Arithmetic, bitwise and comparison operations /////////
-
-/* Element-wise binary and unary operations */
-/** Arithmetics **/
-#define OPENCV_HAL_IMPL_VSX_BIN_OP(bin_op, _Tpvec, intrin)                     \
-  inline _Tpvec bin_op(const _Tpvec &a, const _Tpvec &b) {                     \
-    return _Tpvec(intrin(a.val, b.val));                                       \
-  }
-
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_add, v_uint8x16, vec_adds)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_sub, v_uint8x16, vec_subs)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_add, v_int8x16, vec_adds)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_sub, v_int8x16, vec_subs)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_add, v_uint16x8, vec_adds)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_sub, v_uint16x8, vec_subs)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_add, v_int16x8, vec_adds)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_sub, v_int16x8, vec_subs)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_add, v_uint32x4, vec_add)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_sub, v_uint32x4, vec_sub)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_mul, v_uint32x4, vec_mul)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_add, v_int32x4, vec_add)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_sub, v_int32x4, vec_sub)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_mul, v_int32x4, vec_mul)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_add, v_float32x4, vec_add)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_sub, v_float32x4, vec_sub)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_mul, v_float32x4, vec_mul)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_div, v_float32x4, vec_div)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_add, v_float64x2, vec_add)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_sub, v_float64x2, vec_sub)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_mul, v_float64x2, vec_mul)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_div, v_float64x2, vec_div)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_add, v_uint64x2, vec_add)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_sub, v_uint64x2, vec_sub)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_add, v_int64x2, vec_add)
-OPENCV_HAL_IMPL_VSX_BIN_OP(v_sub, v_int64x2, vec_sub)
-
-// saturating multiply
-#define OPENCV_HAL_IMPL_VSX_MUL_SAT(_Tpvec, _Tpwvec)                           \
-  inline _Tpvec v_mul(const _Tpvec &a, const _Tpvec &b) {                      \
-    _Tpwvec c, d;                                                              \
-    v_mul_expand(a, b, c, d);                                                  \
-    return v_pack(c, d);                                                       \
-  }
-
-OPENCV_HAL_IMPL_VSX_MUL_SAT(v_int8x16, v_int16x8)
-OPENCV_HAL_IMPL_VSX_MUL_SAT(v_uint8x16, v_uint16x8)
-OPENCV_HAL_IMPL_VSX_MUL_SAT(v_int16x8, v_int32x4)
-OPENCV_HAL_IMPL_VSX_MUL_SAT(v_uint16x8, v_uint32x4)
-
-template <typename Tvec, typename Twvec>
-inline void v_mul_expand(const Tvec &a, const Tvec &b, Twvec &c, Twvec &d) {
-  Twvec p0 = Twvec(vec_mule(a.val, b.val));
-  Twvec p1 = Twvec(vec_mulo(a.val, b.val));
-  v_zip(p0, p1, c, d);
-}
-
-inline v_int16x8 v_mul_hi(const v_int16x8 &a, const v_int16x8 &b) {
-  vec_int4 p0 = vec_mule(a.val, b.val);
-  vec_int4 p1 = vec_mulo(a.val, b.val);
-  static const vec_uchar16 perm = {2,  3,  18, 19, 6,  7,  22, 23,
-                                   10, 11, 26, 27, 14, 15, 30, 31};
-  return v_int16x8(vec_perm(vec_short8_c(p0), vec_short8_c(p1), perm));
-}
-inline v_uint16x8 v_mul_hi(const v_uint16x8 &a, const v_uint16x8 &b) {
-  vec_uint4 p0 = vec_mule(a.val, b.val);
-  vec_uint4 p1 = vec_mulo(a.val, b.val);
-  static const vec_uchar16 perm = {2,  3,  18, 19, 6,  7,  22, 23,
-                                   10, 11, 26, 27, 14, 15, 30, 31};
-  return v_uint16x8(vec_perm(vec_ushort8_c(p0), vec_ushort8_c(p1), perm));
-}
-
-/** Non-saturating arithmetics **/
-#define OPENCV_HAL_IMPL_VSX_BIN_FUNC(func, intrin)                             \
-  template <typename _Tpvec>                                                   \
-  inline _Tpvec func(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(intrin(a.val, b.val));                                       \
-  }
-
-OPENCV_HAL_IMPL_VSX_BIN_FUNC(v_add_wrap, vec_add)
-OPENCV_HAL_IMPL_VSX_BIN_FUNC(v_sub_wrap, vec_sub)
-OPENCV_HAL_IMPL_VSX_BIN_FUNC(v_mul_wrap, vec_mul)
-
-/** Bitwise shifts **/
-#define OPENCV_HAL_IMPL_VSX_SHIFT_OP(_Tpvec, shr, splfunc)                     \
-  inline _Tpvec v_shl(const _Tpvec &a, int imm) {                              \
-    return _Tpvec(vec_sl(a.val, splfunc(imm)));                                \
-  }                                                                            \
-  inline _Tpvec v_shr(const _Tpvec &a, int imm) {                              \
-    return _Tpvec(shr(a.val, splfunc(imm)));                                   \
-  }                                                                            \
-  template <int imm> inline _Tpvec v_shl(const _Tpvec &a) {                    \
-    return _Tpvec(vec_sl(a.val, splfunc(imm)));                                \
-  }                                                                            \
-  template <int imm> inline _Tpvec v_shr(const _Tpvec &a) {                    \
-    return _Tpvec(shr(a.val, splfunc(imm)));                                   \
-  }
-
-OPENCV_HAL_IMPL_VSX_SHIFT_OP(v_uint8x16, vec_sr, vec_uchar16_sp)
-OPENCV_HAL_IMPL_VSX_SHIFT_OP(v_uint16x8, vec_sr, vec_ushort8_sp)
-OPENCV_HAL_IMPL_VSX_SHIFT_OP(v_uint32x4, vec_sr, vec_uint4_sp)
-OPENCV_HAL_IMPL_VSX_SHIFT_OP(v_uint64x2, vec_sr, vec_udword2_sp)
-// algebraic right shift
-OPENCV_HAL_IMPL_VSX_SHIFT_OP(v_int8x16, vec_sra, vec_uchar16_sp)
-OPENCV_HAL_IMPL_VSX_SHIFT_OP(v_int16x8, vec_sra, vec_ushort8_sp)
-OPENCV_HAL_IMPL_VSX_SHIFT_OP(v_int32x4, vec_sra, vec_uint4_sp)
-OPENCV_HAL_IMPL_VSX_SHIFT_OP(v_int64x2, vec_sra, vec_udword2_sp)
-
-/** Bitwise logic **/
-#define OPENCV_HAL_IMPL_VSX_LOGIC_OP(_Tpvec)                                   \
-  OPENCV_HAL_IMPL_VSX_BIN_OP(v_and, _Tpvec, vec_and)                           \
-  OPENCV_HAL_IMPL_VSX_BIN_OP(v_or, _Tpvec, vec_or)                             \
-  OPENCV_HAL_IMPL_VSX_BIN_OP(v_xor, _Tpvec, vec_xor)                           \
-  inline _Tpvec v_not(const _Tpvec &a) { return _Tpvec(vec_not(a.val)); }
-
-OPENCV_HAL_IMPL_VSX_LOGIC_OP(v_uint8x16)
-OPENCV_HAL_IMPL_VSX_LOGIC_OP(v_int8x16)
-OPENCV_HAL_IMPL_VSX_LOGIC_OP(v_uint16x8)
-OPENCV_HAL_IMPL_VSX_LOGIC_OP(v_int16x8)
-OPENCV_HAL_IMPL_VSX_LOGIC_OP(v_uint32x4)
-OPENCV_HAL_IMPL_VSX_LOGIC_OP(v_int32x4)
-OPENCV_HAL_IMPL_VSX_LOGIC_OP(v_uint64x2)
-OPENCV_HAL_IMPL_VSX_LOGIC_OP(v_int64x2)
-OPENCV_HAL_IMPL_VSX_LOGIC_OP(v_float32x4)
-OPENCV_HAL_IMPL_VSX_LOGIC_OP(v_float64x2)
-
-/** Bitwise select **/
-#define OPENCV_HAL_IMPL_VSX_SELECT(_Tpvec, cast)                               \
-  inline _Tpvec v_select(const _Tpvec &mask, const _Tpvec &a,                  \
-                         const _Tpvec &b) {                                    \
-    return _Tpvec(vec_sel(b.val, a.val, cast(mask.val)));                      \
-  }
-
-OPENCV_HAL_IMPL_VSX_SELECT(v_uint8x16, vec_bchar16_c)
-OPENCV_HAL_IMPL_VSX_SELECT(v_int8x16, vec_bchar16_c)
-OPENCV_HAL_IMPL_VSX_SELECT(v_uint16x8, vec_bshort8_c)
-OPENCV_HAL_IMPL_VSX_SELECT(v_int16x8, vec_bshort8_c)
-OPENCV_HAL_IMPL_VSX_SELECT(v_uint32x4, vec_bint4_c)
-OPENCV_HAL_IMPL_VSX_SELECT(v_int32x4, vec_bint4_c)
-OPENCV_HAL_IMPL_VSX_SELECT(v_float32x4, vec_bint4_c)
-OPENCV_HAL_IMPL_VSX_SELECT(v_float64x2, vec_bdword2_c)
-
-/** Comparison **/
-#define OPENCV_HAL_IMPL_VSX_INT_CMP_OP(_Tpvec)                                 \
-  inline _Tpvec v_eq(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(vec_cmpeq(a.val, b.val));                                    \
-  }                                                                            \
-  inline _Tpvec V_ne(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(vec_cmpne(a.val, b.val));                                    \
-  }                                                                            \
-  inline _Tpvec v_lt(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(vec_cmplt(a.val, b.val));                                    \
-  }                                                                            \
-  inline _Tpvec V_gt(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(vec_cmpgt(a.val, b.val));                                    \
-  }                                                                            \
-  inline _Tpvec v_le(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(vec_cmple(a.val, b.val));                                    \
-  }                                                                            \
-  inline _Tpvec v_ge(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(vec_cmpge(a.val, b.val));                                    \
-  }
-
-OPENCV_HAL_IMPL_VSX_INT_CMP_OP(v_uint8x16)
-OPENCV_HAL_IMPL_VSX_INT_CMP_OP(v_int8x16)
-OPENCV_HAL_IMPL_VSX_INT_CMP_OP(v_uint16x8)
-OPENCV_HAL_IMPL_VSX_INT_CMP_OP(v_int16x8)
-OPENCV_HAL_IMPL_VSX_INT_CMP_OP(v_uint32x4)
-OPENCV_HAL_IMPL_VSX_INT_CMP_OP(v_int32x4)
-OPENCV_HAL_IMPL_VSX_INT_CMP_OP(v_float32x4)
-OPENCV_HAL_IMPL_VSX_INT_CMP_OP(v_float64x2)
-OPENCV_HAL_IMPL_VSX_INT_CMP_OP(v_uint64x2)
-OPENCV_HAL_IMPL_VSX_INT_CMP_OP(v_int64x2)
-
-inline v_float32x4 v_not_nan(const v_float32x4 &a) {
-  return v_float32x4(vec_cmpeq(a.val, a.val));
-}
-inline v_float64x2 v_not_nan(const v_float64x2 &a) {
-  return v_float64x2(vec_cmpeq(a.val, a.val));
-}
-
-/** min/max **/
-OPENCV_HAL_IMPL_VSX_BIN_FUNC(v_min, vec_min)
-OPENCV_HAL_IMPL_VSX_BIN_FUNC(v_max, vec_max)
-
-/** Rotate **/
-#define OPENCV_IMPL_VSX_ROTATE(_Tpvec, suffix, shf, cast)                      \
-  template <int imm> inline _Tpvec v_rotate_##suffix(const _Tpvec &a) {        \
-    const int wd = imm * sizeof(typename _Tpvec::lane_type);                   \
-    if (wd > 15)                                                               \
-      return _Tpvec::zero();                                                   \
-    return _Tpvec((cast)shf(vec_uchar16_c(a.val), vec_uchar16_sp(wd << 3)));   \
-  }
-
-#define OPENCV_IMPL_VSX_ROTATE_LR(_Tpvec, cast)                                \
-  OPENCV_IMPL_VSX_ROTATE(_Tpvec, left, vec_slo, cast)                          \
-  OPENCV_IMPL_VSX_ROTATE(_Tpvec, right, vec_sro, cast)
-
-OPENCV_IMPL_VSX_ROTATE_LR(v_uint8x16, vec_uchar16)
-OPENCV_IMPL_VSX_ROTATE_LR(v_int8x16, vec_char16)
-OPENCV_IMPL_VSX_ROTATE_LR(v_uint16x8, vec_ushort8)
-OPENCV_IMPL_VSX_ROTATE_LR(v_int16x8, vec_short8)
-OPENCV_IMPL_VSX_ROTATE_LR(v_uint32x4, vec_uint4)
-OPENCV_IMPL_VSX_ROTATE_LR(v_int32x4, vec_int4)
-OPENCV_IMPL_VSX_ROTATE_LR(v_float32x4, vec_float4)
-OPENCV_IMPL_VSX_ROTATE_LR(v_uint64x2, vec_udword2)
-OPENCV_IMPL_VSX_ROTATE_LR(v_int64x2, vec_dword2)
-OPENCV_IMPL_VSX_ROTATE_LR(v_float64x2, vec_double2)
-
-template <int imm, typename _Tpvec>
-inline _Tpvec v_rotate_right(const _Tpvec &a, const _Tpvec &b) {
-  enum { CV_SHIFT = 16 - imm * (sizeof(typename _Tpvec::lane_type)) };
-  if (CV_SHIFT == 16)
-    return a;
-#ifdef __IBMCPP__
-  return _Tpvec(vec_sld(b.val, a.val, CV_SHIFT & 15));
-#else
-  return _Tpvec(vec_sld(b.val, a.val, CV_SHIFT));
-#endif
-}
-
-template <int imm, typename _Tpvec>
-inline _Tpvec v_rotate_left(const _Tpvec &a, const _Tpvec &b) {
-  enum { CV_SHIFT = imm * (sizeof(typename _Tpvec::lane_type)) };
-  if (CV_SHIFT == 16)
-    return b;
-  return _Tpvec(vec_sld(a.val, b.val, CV_SHIFT));
-}
-
-#define OPENCV_IMPL_VSX_ROTATE_64_2RG(_Tpvec, suffix, rg1, rg2)                \
-  template <int imm>                                                           \
-  inline _Tpvec v_rotate_##suffix(const _Tpvec &a, const _Tpvec &b) {          \
-    if (imm == 1)                                                              \
-      return _Tpvec(vec_permi(rg1.val, rg2.val, 2));                           \
-    return imm ? b : a;                                                        \
-  }
-
-#define OPENCV_IMPL_VSX_ROTATE_64_2RG_LR(_Tpvec)                               \
-  OPENCV_IMPL_VSX_ROTATE_64_2RG(_Tpvec, left, b, a)                            \
-  OPENCV_IMPL_VSX_ROTATE_64_2RG(_Tpvec, right, a, b)
-
-OPENCV_IMPL_VSX_ROTATE_64_2RG_LR(v_float64x2)
-OPENCV_IMPL_VSX_ROTATE_64_2RG_LR(v_uint64x2)
-OPENCV_IMPL_VSX_ROTATE_64_2RG_LR(v_int64x2)
-
-/* Reverse */
-inline v_uint8x16 v_reverse(const v_uint8x16 &a) {
-  static const vec_uchar16 perm = {15, 14, 13, 12, 11, 10, 9, 8,
-                                   7,  6,  5,  4,  3,  2,  1, 0};
-  vec_uchar16 vec = (vec_uchar16)a.val;
-  return v_uint8x16(vec_perm(vec, vec, perm));
-}
-
-inline v_int8x16 v_reverse(const v_int8x16 &a) {
-  return v_reinterpret_as_s8(v_reverse(v_reinterpret_as_u8(a)));
-}
-
-inline v_uint16x8 v_reverse(const v_uint16x8 &a) {
-  static const vec_uchar16 perm = {14, 15, 12, 13, 10, 11, 8, 9,
-                                   6,  7,  4,  5,  2,  3,  0, 1};
-  vec_uchar16 vec = (vec_uchar16)a.val;
-  return v_reinterpret_as_u16(v_uint8x16(vec_perm(vec, vec, perm)));
-}
-
-inline v_int16x8 v_reverse(const v_int16x8 &a) {
-  return v_reinterpret_as_s16(v_reverse(v_reinterpret_as_u16(a)));
-}
-
-inline v_uint32x4 v_reverse(const v_uint32x4 &a) {
-  static const vec_uchar16 perm = {12, 13, 14, 15, 8, 9, 10, 11,
-                                   4,  5,  6,  7,  0, 1, 2,  3};
-  vec_uchar16 vec = (vec_uchar16)a.val;
-  return v_reinterpret_as_u32(v_uint8x16(vec_perm(vec, vec, perm)));
-}
-
-inline v_int32x4 v_reverse(const v_int32x4 &a) {
-  return v_reinterpret_as_s32(v_reverse(v_reinterpret_as_u32(a)));
-}
-
-inline v_float32x4 v_reverse(const v_float32x4 &a) {
-  return v_reinterpret_as_f32(v_reverse(v_reinterpret_as_u32(a)));
-}
-
-inline v_uint64x2 v_reverse(const v_uint64x2 &a) {
-  static const vec_uchar16 perm = {8, 9, 10, 11, 12, 13, 14, 15,
-                                   0, 1, 2,  3,  4,  5,  6,  7};
-  vec_uchar16 vec = (vec_uchar16)a.val;
-  return v_reinterpret_as_u64(v_uint8x16(vec_perm(vec, vec, perm)));
-}
-
-inline v_int64x2 v_reverse(const v_int64x2 &a) {
-  return v_reinterpret_as_s64(v_reverse(v_reinterpret_as_u64(a)));
-}
-
-inline v_float64x2 v_reverse(const v_float64x2 &a) {
-  return v_reinterpret_as_f64(v_reverse(v_reinterpret_as_u64(a)));
-}
-
-/* Extract */
-template <int s, typename _Tpvec>
-inline _Tpvec v_extract(const _Tpvec &a, const _Tpvec &b) {
-  return v_rotate_right<s>(a, b);
-}
-
-////////// Reduce and mask /////////
-
-/** Reduce **/
-inline uint v_reduce_sum(const v_uint8x16 &a) {
-  const vec_uint4 zero4 = vec_uint4_z;
-  vec_uint4 sum4 = vec_sum4s(a.val, zero4);
-  return (uint)vec_extract(vec_sums(vec_int4_c(sum4), vec_int4_c(zero4)), 3);
-}
-inline int v_reduce_sum(const v_int8x16 &a) {
-  const vec_int4 zero4 = vec_int4_z;
-  vec_int4 sum4 = vec_sum4s(a.val, zero4);
-  return (int)vec_extract(vec_sums(sum4, zero4), 3);
-}
-inline int v_reduce_sum(const v_int16x8 &a) {
-  const vec_int4 zero = vec_int4_z;
-  return saturate_cast<int>(
-      vec_extract(vec_sums(vec_sum4s(a.val, zero), zero), 3));
-}
-inline uint v_reduce_sum(const v_uint16x8 &a) {
-  const vec_int4 v4 =
-      vec_int4_c(vec_unpackhu(vec_adds(a.val, vec_sld(a.val, a.val, 8))));
-  return saturate_cast<uint>(vec_extract(vec_sums(v4, vec_int4_z), 3));
-}
-
-#define OPENCV_HAL_IMPL_VSX_REDUCE_OP_4(_Tpvec, _Tpvec2, scalartype, suffix,   \
-                                        func)                                  \
-  inline scalartype v_reduce_##suffix(const _Tpvec &a) {                       \
-    const _Tpvec2 rs = func(a.val, vec_sld(a.val, a.val, 8));                  \
-    return vec_extract(func(rs, vec_sld(rs, rs, 4)), 0);                       \
-  }
-OPENCV_HAL_IMPL_VSX_REDUCE_OP_4(v_uint32x4, vec_uint4, uint, sum, vec_add)
-OPENCV_HAL_IMPL_VSX_REDUCE_OP_4(v_uint32x4, vec_uint4, uint, max, vec_max)
-OPENCV_HAL_IMPL_VSX_REDUCE_OP_4(v_uint32x4, vec_uint4, uint, min, vec_min)
-OPENCV_HAL_IMPL_VSX_REDUCE_OP_4(v_int32x4, vec_int4, int, sum, vec_add)
-OPENCV_HAL_IMPL_VSX_REDUCE_OP_4(v_int32x4, vec_int4, int, max, vec_max)
-OPENCV_HAL_IMPL_VSX_REDUCE_OP_4(v_int32x4, vec_int4, int, min, vec_min)
-OPENCV_HAL_IMPL_VSX_REDUCE_OP_4(v_float32x4, vec_float4, float, sum, vec_add)
-OPENCV_HAL_IMPL_VSX_REDUCE_OP_4(v_float32x4, vec_float4, float, max, vec_max)
-OPENCV_HAL_IMPL_VSX_REDUCE_OP_4(v_float32x4, vec_float4, float, min, vec_min)
-
-inline uint64 v_reduce_sum(const v_uint64x2 &a) {
-  return vec_extract(vec_add(a.val, vec_permi(a.val, a.val, 3)), 0);
-}
-inline int64 v_reduce_sum(const v_int64x2 &a) {
-  return vec_extract(vec_add(a.val, vec_permi(a.val, a.val, 3)), 0);
-}
-inline double v_reduce_sum(const v_float64x2 &a) {
-  return vec_extract(vec_add(a.val, vec_permi(a.val, a.val, 3)), 0);
-}
-
-#define OPENCV_HAL_IMPL_VSX_REDUCE_OP_8(_Tpvec, _Tpvec2, scalartype, suffix,   \
-                                        func)                                  \
-  inline scalartype v_reduce_##suffix(const _Tpvec &a) {                       \
-    _Tpvec2 rs = func(a.val, vec_sld(a.val, a.val, 8));                        \
-    rs = func(rs, vec_sld(rs, rs, 4));                                         \
-    return vec_extract(func(rs, vec_sld(rs, rs, 2)), 0);                       \
-  }
-OPENCV_HAL_IMPL_VSX_REDUCE_OP_8(v_uint16x8, vec_ushort8, ushort, max, vec_max)
-OPENCV_HAL_IMPL_VSX_REDUCE_OP_8(v_uint16x8, vec_ushort8, ushort, min, vec_min)
-OPENCV_HAL_IMPL_VSX_REDUCE_OP_8(v_int16x8, vec_short8, short, max, vec_max)
-OPENCV_HAL_IMPL_VSX_REDUCE_OP_8(v_int16x8, vec_short8, short, min, vec_min)
-
-#define OPENCV_HAL_IMPL_VSX_REDUCE_OP_16(_Tpvec, _Tpvec2, scalartype, suffix,  \
-                                         func)                                 \
-  inline scalartype v_reduce_##suffix(const _Tpvec &a) {                       \
-    _Tpvec2 rs = func(a.val, vec_sld(a.val, a.val, 8));                        \
-    rs = func(rs, vec_sld(rs, rs, 4));                                         \
-    rs = func(rs, vec_sld(rs, rs, 2));                                         \
-    return vec_extract(func(rs, vec_sld(rs, rs, 1)), 0);                       \
-  }
-OPENCV_HAL_IMPL_VSX_REDUCE_OP_16(v_uint8x16, vec_uchar16, uchar, max, vec_max)
-OPENCV_HAL_IMPL_VSX_REDUCE_OP_16(v_uint8x16, vec_uchar16, uchar, min, vec_min)
-OPENCV_HAL_IMPL_VSX_REDUCE_OP_16(v_int8x16, vec_char16, schar, max, vec_max)
-OPENCV_HAL_IMPL_VSX_REDUCE_OP_16(v_int8x16, vec_char16, schar, min, vec_min)
-
-inline v_float32x4 v_reduce_sum4(const v_float32x4 &a, const v_float32x4 &b,
-                                 const v_float32x4 &c, const v_float32x4 &d) {
-  vec_float4 ac = vec_add(vec_mergel(a.val, c.val), vec_mergeh(a.val, c.val));
-  ac = vec_add(ac, vec_sld(ac, ac, 8));
-
-  vec_float4 bd = vec_add(vec_mergel(b.val, d.val), vec_mergeh(b.val, d.val));
-  bd = vec_add(bd, vec_sld(bd, bd, 8));
-  return v_float32x4(vec_mergeh(ac, bd));
-}
-
-inline unsigned v_reduce_sad(const v_uint8x16 &a, const v_uint8x16 &b) {
-  const vec_uint4 zero4 = vec_uint4_z;
-  vec_uint4 sum4 = vec_sum4s(vec_absd(a.val, b.val), zero4);
-  return (unsigned)vec_extract(vec_sums(vec_int4_c(sum4), vec_int4_c(zero4)),
-                               3);
-}
-inline unsigned v_reduce_sad(const v_int8x16 &a, const v_int8x16 &b) {
-  const vec_int4 zero4 = vec_int4_z;
-  vec_char16 ad = vec_abss(vec_subs(a.val, b.val));
-  vec_int4 sum4 = vec_sum4s(ad, zero4);
-  return (unsigned)vec_extract(vec_sums(sum4, zero4), 3);
-}
-inline unsigned v_reduce_sad(const v_uint16x8 &a, const v_uint16x8 &b) {
-  vec_ushort8 ad = vec_absd(a.val, b.val);
-  VSX_UNUSED(vec_int4)
-  sum = vec_sums(vec_int4_c(vec_unpackhu(ad)) + vec_int4_c(vec_unpacklu(ad)),
-                 vec_int4_z);
-  return (unsigned)vec_extract(sum, 3);
-}
-inline unsigned v_reduce_sad(const v_int16x8 &a, const v_int16x8 &b) {
-  const vec_int4 zero4 = vec_int4_z;
-  vec_short8 ad = vec_abss(vec_subs(a.val, b.val));
-  vec_int4 sum4 = vec_sum4s(ad, zero4);
-  return (unsigned)vec_extract(vec_sums(sum4, zero4), 3);
-}
-inline unsigned v_reduce_sad(const v_uint32x4 &a, const v_uint32x4 &b) {
-  const vec_uint4 ad = vec_absd(a.val, b.val);
-  const vec_uint4 rd = vec_add(ad, vec_sld(ad, ad, 8));
-  return vec_extract(vec_add(rd, vec_sld(rd, rd, 4)), 0);
-}
-inline unsigned v_reduce_sad(const v_int32x4 &a, const v_int32x4 &b) {
-  vec_int4 ad = vec_abss(vec_sub(a.val, b.val));
-  return (unsigned)vec_extract(vec_sums(ad, vec_int4_z), 3);
-}
-inline float v_reduce_sad(const v_float32x4 &a, const v_float32x4 &b) {
-  const vec_float4 ad = vec_abs(vec_sub(a.val, b.val));
-  const vec_float4 rd = vec_add(ad, vec_sld(ad, ad, 8));
-  return vec_extract(vec_add(rd, vec_sld(rd, rd, 4)), 0);
-}
-
-/** Popcount **/
-inline v_uint8x16 v_popcount(const v_uint8x16 &a) {
-  return v_uint8x16(vec_popcntu(a.val));
-}
-inline v_uint8x16 v_popcount(const v_int8x16 &a) {
-  return v_uint8x16(vec_popcntu(a.val));
-}
-inline v_uint16x8 v_popcount(const v_uint16x8 &a) {
-  return v_uint16x8(vec_popcntu(a.val));
-}
-inline v_uint16x8 v_popcount(const v_int16x8 &a) {
-  return v_uint16x8(vec_popcntu(a.val));
-}
-inline v_uint32x4 v_popcount(const v_uint32x4 &a) {
-  return v_uint32x4(vec_popcntu(a.val));
-}
-inline v_uint32x4 v_popcount(const v_int32x4 &a) {
-  return v_uint32x4(vec_popcntu(a.val));
-}
-inline v_uint64x2 v_popcount(const v_uint64x2 &a) {
-  return v_uint64x2(vec_popcntu(a.val));
-}
-inline v_uint64x2 v_popcount(const v_int64x2 &a) {
-  return v_uint64x2(vec_popcntu(a.val));
-}
-
-/** Mask **/
-inline int v_signmask(const v_uint8x16 &a) {
-  static const vec_uchar16 qperm = {120, 112, 104, 96, 88, 80, 72, 64,
-                                    56,  48,  40,  32, 24, 16, 8,  0};
-  return vec_extract((vec_int4)vec_vbpermq(v_reinterpret_as_u8(a).val, qperm),
-                     2);
-}
-inline int v_signmask(const v_int8x16 &a) {
-  return v_signmask(v_reinterpret_as_u8(a));
-}
-
-inline int v_signmask(const v_int16x8 &a) {
-  static const vec_uchar16 qperm = {112, 96,  80,  64,  48,  32,  16,  0,
-                                    128, 128, 128, 128, 128, 128, 128, 128};
-  return vec_extract((vec_int4)vec_vbpermq(v_reinterpret_as_u8(a).val, qperm),
-                     2);
-}
-inline int v_signmask(const v_uint16x8 &a) {
-  return v_signmask(v_reinterpret_as_s16(a));
-}
-
-inline int v_signmask(const v_int32x4 &a) {
-  static const vec_uchar16 qperm = {96,  64,  32,  0,   128, 128, 128, 128,
-                                    128, 128, 128, 128, 128, 128, 128, 128};
-  return vec_extract((vec_int4)vec_vbpermq(v_reinterpret_as_u8(a).val, qperm),
-                     2);
-}
-inline int v_signmask(const v_uint32x4 &a) {
-  return v_signmask(v_reinterpret_as_s32(a));
-}
-inline int v_signmask(const v_float32x4 &a) {
-  return v_signmask(v_reinterpret_as_s32(a));
-}
-
-inline int v_signmask(const v_int64x2 &a) {
-  VSX_UNUSED(const vec_dword2) sv = vec_sr(a.val, vec_udword2_sp(63));
-  return (int)vec_extract(sv, 0) | (int)vec_extract(sv, 1) << 1;
-}
-inline int v_signmask(const v_uint64x2 &a) {
-  return v_signmask(v_reinterpret_as_s64(a));
-}
-inline int v_signmask(const v_float64x2 &a) {
-  return v_signmask(v_reinterpret_as_s64(a));
-}
-
-inline int v_scan_forward(const v_int8x16 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_uint8x16 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_int16x8 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_uint16x8 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_int32x4 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_uint32x4 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_float32x4 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_int64x2 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_uint64x2 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-inline int v_scan_forward(const v_float64x2 &a) {
-  return trailingZeros32(v_signmask(a));
-}
-
-template <typename _Tpvec> inline bool v_check_all(const _Tpvec &a) {
-  return vec_all_lt(a.val, _Tpvec::zero().val);
-}
-inline bool v_check_all(const v_uint8x16 &a) {
-  return v_check_all(v_reinterpret_as_s8(a));
-}
-inline bool v_check_all(const v_uint16x8 &a) {
-  return v_check_all(v_reinterpret_as_s16(a));
-}
-inline bool v_check_all(const v_uint32x4 &a) {
-  return v_check_all(v_reinterpret_as_s32(a));
-}
-inline bool v_check_all(const v_uint64x2 &a) {
-  return v_check_all(v_reinterpret_as_s64(a));
-}
-inline bool v_check_all(const v_float32x4 &a) {
-  return v_check_all(v_reinterpret_as_s32(a));
-}
-inline bool v_check_all(const v_float64x2 &a) {
-  return v_check_all(v_reinterpret_as_s64(a));
-}
-
-template <typename _Tpvec> inline bool v_check_any(const _Tpvec &a) {
-  return vec_any_lt(a.val, _Tpvec::zero().val);
-}
-inline bool v_check_any(const v_uint8x16 &a) {
-  return v_check_any(v_reinterpret_as_s8(a));
-}
-inline bool v_check_any(const v_uint16x8 &a) {
-  return v_check_any(v_reinterpret_as_s16(a));
-}
-inline bool v_check_any(const v_uint32x4 &a) {
-  return v_check_any(v_reinterpret_as_s32(a));
-}
-inline bool v_check_any(const v_uint64x2 &a) {
-  return v_check_any(v_reinterpret_as_s64(a));
-}
-inline bool v_check_any(const v_float32x4 &a) {
-  return v_check_any(v_reinterpret_as_s32(a));
-}
-inline bool v_check_any(const v_float64x2 &a) {
-  return v_check_any(v_reinterpret_as_s64(a));
-}
-
-////////// Other math /////////
-
-/** Some frequent operations **/
-inline v_float32x4 v_sqrt(const v_float32x4 &x) {
-  return v_float32x4(vec_sqrt(x.val));
-}
-inline v_float64x2 v_sqrt(const v_float64x2 &x) {
-  return v_float64x2(vec_sqrt(x.val));
-}
-
-inline v_float32x4 v_invsqrt(const v_float32x4 &x) {
-  return v_float32x4(vec_rsqrt(x.val));
-}
-inline v_float64x2 v_invsqrt(const v_float64x2 &x) {
-  return v_float64x2(vec_rsqrt(x.val));
-}
-
-#define OPENCV_HAL_IMPL_VSX_MULADD(_Tpvec)                                     \
-  inline _Tpvec v_magnitude(const _Tpvec &a, const _Tpvec &b) {                \
-    return _Tpvec(vec_sqrt(vec_madd(a.val, a.val, vec_mul(b.val, b.val))));    \
-  }                                                                            \
-  inline _Tpvec v_sqr_magnitude(const _Tpvec &a, const _Tpvec &b) {            \
-    return _Tpvec(vec_madd(a.val, a.val, vec_mul(b.val, b.val)));              \
-  }                                                                            \
-  inline _Tpvec v_fma(const _Tpvec &a, const _Tpvec &b, const _Tpvec &c) {     \
-    return _Tpvec(vec_madd(a.val, b.val, c.val));                              \
-  }                                                                            \
-  inline _Tpvec v_muladd(const _Tpvec &a, const _Tpvec &b, const _Tpvec &c) {  \
-    return _Tpvec(vec_madd(a.val, b.val, c.val));                              \
-  }
-
-OPENCV_HAL_IMPL_VSX_MULADD(v_float32x4)
-OPENCV_HAL_IMPL_VSX_MULADD(v_float64x2)
-
-inline v_int32x4 v_muladd(const v_int32x4 &a, const v_int32x4 &b,
-                          const v_int32x4 &c) {
-  return v_add(v_mul(a, b), c);
-}
-
-// TODO: exp, log, sin, cos
-
-/** Absolute values **/
-inline v_uint8x16 v_abs(const v_int8x16 &x) {
-  return v_uint8x16(vec_uchar16_c(vec_abs(x.val)));
-}
-
-inline v_uint16x8 v_abs(const v_int16x8 &x) {
-  return v_uint16x8(vec_ushort8_c(vec_abs(x.val)));
-}
-
-inline v_uint32x4 v_abs(const v_int32x4 &x) {
-  return v_uint32x4(vec_uint4_c(vec_abs(x.val)));
-}
-
-inline v_float32x4 v_abs(const v_float32x4 &x) {
-  return v_float32x4(vec_abs(x.val));
-}
-
-inline v_float64x2 v_abs(const v_float64x2 &x) {
-  return v_float64x2(vec_abs(x.val));
-}
-
-/** Absolute difference **/
-// unsigned
-OPENCV_HAL_IMPL_VSX_BIN_FUNC(v_absdiff, vec_absd)
-
-inline v_uint8x16 v_absdiff(const v_int8x16 &a, const v_int8x16 &b) {
-  return v_reinterpret_as_u8(v_sub_wrap(v_max(a, b), v_min(a, b)));
-}
-inline v_uint16x8 v_absdiff(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_reinterpret_as_u16(v_sub_wrap(v_max(a, b), v_min(a, b)));
-}
-inline v_uint32x4 v_absdiff(const v_int32x4 &a, const v_int32x4 &b) {
-  return v_reinterpret_as_u32(v_sub(v_max(a, b), v_min(a, b)));
-}
-
-inline v_float32x4 v_absdiff(const v_float32x4 &a, const v_float32x4 &b) {
-  return v_abs(v_sub(a, b));
-}
-inline v_float64x2 v_absdiff(const v_float64x2 &a, const v_float64x2 &b) {
-  return v_abs(v_sub(a, b));
-}
-
-/** Absolute difference for signed integers **/
-inline v_int8x16 v_absdiffs(const v_int8x16 &a, const v_int8x16 &b) {
-  return v_int8x16(vec_abss(vec_subs(a.val, b.val)));
-}
-inline v_int16x8 v_absdiffs(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_int16x8(vec_abss(vec_subs(a.val, b.val)));
-}
-
-////////// Conversions /////////
-
-/** Rounding **/
-inline v_int32x4 v_round(const v_float32x4 &a) {
-  return v_int32x4(vec_cts(vec_rint(a.val)));
-}
-
-inline v_int32x4 v_round(const v_float64x2 &a) {
-  return v_int32x4(vec_mergesqo(vec_ctso(vec_rint(a.val)), vec_int4_z));
-}
-
-inline v_int32x4 v_round(const v_float64x2 &a, const v_float64x2 &b) {
-  return v_int32x4(
-      vec_mergesqo(vec_ctso(vec_rint(a.val)), vec_ctso(vec_rint(b.val))));
-}
-
-inline v_int32x4 v_floor(const v_float32x4 &a) {
-  return v_int32x4(vec_cts(vec_floor(a.val)));
-}
-
-inline v_int32x4 v_floor(const v_float64x2 &a) {
-  return v_int32x4(vec_mergesqo(vec_ctso(vec_floor(a.val)), vec_int4_z));
-}
-
-inline v_int32x4 v_ceil(const v_float32x4 &a) {
-  return v_int32x4(vec_cts(vec_ceil(a.val)));
-}
-
-inline v_int32x4 v_ceil(const v_float64x2 &a) {
-  return v_int32x4(vec_mergesqo(vec_ctso(vec_ceil(a.val)), vec_int4_z));
-}
-
-inline v_int32x4 v_trunc(const v_float32x4 &a) {
-  return v_int32x4(vec_cts(a.val));
-}
-
-inline v_int32x4 v_trunc(const v_float64x2 &a) {
-  return v_int32x4(vec_mergesqo(vec_ctso(a.val), vec_int4_z));
-}
-
-/** To float **/
-inline v_float32x4 v_cvt_f32(const v_int32x4 &a) {
-  return v_float32x4(vec_ctf(a.val));
-}
-
-inline v_float32x4 v_cvt_f32(const v_float64x2 &a) {
-  return v_float32x4(vec_mergesqo(vec_cvfo(a.val), vec_float4_z));
-}
-
-inline v_float32x4 v_cvt_f32(const v_float64x2 &a, const v_float64x2 &b) {
-  return v_float32x4(vec_mergesqo(vec_cvfo(a.val), vec_cvfo(b.val)));
-}
-
-inline v_float64x2 v_cvt_f64(const v_int32x4 &a) {
-  return v_float64x2(vec_ctdo(vec_mergeh(a.val, a.val)));
-}
-
-inline v_float64x2 v_cvt_f64_high(const v_int32x4 &a) {
-  return v_float64x2(vec_ctdo(vec_mergel(a.val, a.val)));
-}
-
-inline v_float64x2 v_cvt_f64(const v_float32x4 &a) {
-  return v_float64x2(vec_cvfo(vec_mergeh(a.val, a.val)));
-}
-
-inline v_float64x2 v_cvt_f64_high(const v_float32x4 &a) {
-  return v_float64x2(vec_cvfo(vec_mergel(a.val, a.val)));
-}
-
-inline v_float64x2 v_cvt_f64(const v_int64x2 &a) {
-  return v_float64x2(vec_ctd(a.val));
-}
-
-////////////// Lookup table access ////////////////////
-
-inline v_int8x16 v_lut(const schar *tab, const int *idx) {
-  return v_int8x16(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]],
-                   tab[idx[4]], tab[idx[5]], tab[idx[6]], tab[idx[7]],
-                   tab[idx[8]], tab[idx[9]], tab[idx[10]], tab[idx[11]],
-                   tab[idx[12]], tab[idx[13]], tab[idx[14]], tab[idx[15]]);
-}
-inline v_int8x16 v_lut_pairs(const schar *tab, const int *idx) {
-  return v_reinterpret_as_s8(v_int16x8(
-      *(const short *)(tab + idx[0]), *(const short *)(tab + idx[1]),
-      *(const short *)(tab + idx[2]), *(const short *)(tab + idx[3]),
-      *(const short *)(tab + idx[4]), *(const short *)(tab + idx[5]),
-      *(const short *)(tab + idx[6]), *(const short *)(tab + idx[7])));
-}
-inline v_int8x16 v_lut_quads(const schar *tab, const int *idx) {
-  return v_reinterpret_as_s8(
-      v_int32x4(*(const int *)(tab + idx[0]), *(const int *)(tab + idx[1]),
-                *(const int *)(tab + idx[2]), *(const int *)(tab + idx[3])));
-}
-inline v_uint8x16 v_lut(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v_lut((const schar *)tab, idx));
-}
-inline v_uint8x16 v_lut_pairs(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v_lut_pairs((const schar *)tab, idx));
-}
-inline v_uint8x16 v_lut_quads(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v_lut_quads((const schar *)tab, idx));
-}
-
-inline v_int16x8 v_lut(const short *tab, const int *idx) {
-  return v_int16x8(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]],
-                   tab[idx[4]], tab[idx[5]], tab[idx[6]], tab[idx[7]]);
-}
-inline v_int16x8 v_lut_pairs(const short *tab, const int *idx) {
-  return v_reinterpret_as_s16(
-      v_int32x4(*(const int *)(tab + idx[0]), *(const int *)(tab + idx[1]),
-                *(const int *)(tab + idx[2]), *(const int *)(tab + idx[3])));
-}
-inline v_int16x8 v_lut_quads(const short *tab, const int *idx) {
-  return v_reinterpret_as_s16(v_int64x2(*(const int64 *)(tab + idx[0]),
-                                        *(const int64 *)(tab + idx[1])));
-}
-inline v_uint16x8 v_lut(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v_lut((const short *)tab, idx));
-}
-inline v_uint16x8 v_lut_pairs(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v_lut_pairs((const short *)tab, idx));
-}
-inline v_uint16x8 v_lut_quads(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v_lut_quads((const short *)tab, idx));
-}
-
-inline v_int32x4 v_lut(const int *tab, const int *idx) {
-  return v_int32x4(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]);
-}
-inline v_int32x4 v_lut_pairs(const int *tab, const int *idx) {
-  return v_reinterpret_as_s32(v_int64x2(*(const int64 *)(tab + idx[0]),
-                                        *(const int64 *)(tab + idx[1])));
-}
-inline v_int32x4 v_lut_quads(const int *tab, const int *idx) {
-  return v_int32x4(vsx_ld(0, tab + idx[0]));
-}
-inline v_uint32x4 v_lut(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v_lut((const int *)tab, idx));
-}
-inline v_uint32x4 v_lut_pairs(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v_lut_pairs((const int *)tab, idx));
-}
-inline v_uint32x4 v_lut_quads(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v_lut_quads((const int *)tab, idx));
-}
-
-inline v_int64x2 v_lut(const int64_t *tab, const int *idx) {
-  return v_int64x2(tab[idx[0]], tab[idx[1]]);
-}
-inline v_int64x2 v_lut_pairs(const int64_t *tab, const int *idx) {
-  return v_int64x2(vsx_ld2(0, tab + idx[0]));
-}
-inline v_uint64x2 v_lut(const uint64_t *tab, const int *idx) {
-  return v_reinterpret_as_u64(v_lut((const int64_t *)tab, idx));
-}
-inline v_uint64x2 v_lut_pairs(const uint64_t *tab, const int *idx) {
-  return v_reinterpret_as_u64(v_lut_pairs((const int64_t *)tab, idx));
-}
-
-inline v_float32x4 v_lut(const float *tab, const int *idx) {
-  return v_float32x4(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]);
-}
-inline v_float32x4 v_lut_pairs(const float *tab, const int *idx) {
-  return v_reinterpret_as_f32(v_lut_pairs((const int *)tab, idx));
-}
-inline v_float32x4 v_lut_quads(const float *tab, const int *idx) {
-  return v_load(tab + *idx);
-}
-
-inline v_float64x2 v_lut(const double *tab, const int *idx) {
-  return v_float64x2(tab[idx[0]], tab[idx[1]]);
-}
-inline v_float64x2 v_lut_pairs(const double *tab, const int *idx) {
-  return v_load(tab + *idx);
-}
-
-inline v_int32x4 v_lut(const int *tab, const v_int32x4 &idxvec) {
-  const int idx[4] = {vec_extract(idxvec.val, 0), vec_extract(idxvec.val, 1),
-                      vec_extract(idxvec.val, 2), vec_extract(idxvec.val, 3)};
-  return v_int32x4(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]);
-}
-
-inline v_uint32x4 v_lut(const unsigned *tab, const v_int32x4 &idxvec) {
-  const int idx[4] = {vec_extract(idxvec.val, 0), vec_extract(idxvec.val, 1),
-                      vec_extract(idxvec.val, 2), vec_extract(idxvec.val, 3)};
-  return v_uint32x4(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]);
-}
-
-inline v_float32x4 v_lut(const float *tab, const v_int32x4 &idxvec) {
-  const int idx[4] = {vec_extract(idxvec.val, 0), vec_extract(idxvec.val, 1),
-                      vec_extract(idxvec.val, 2), vec_extract(idxvec.val, 3)};
-  return v_float32x4(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]);
-}
-
-inline v_float64x2 v_lut(const double *tab, const v_int32x4 &idxvec) {
-  const int idx[2] = {vec_extract(idxvec.val, 0), vec_extract(idxvec.val, 1)};
-  return v_float64x2(tab[idx[0]], tab[idx[1]]);
-}
-
-inline void v_lut_deinterleave(const float *tab, const v_int32x4 &idxvec,
-                               v_float32x4 &x, v_float32x4 &y) {
-  vec_float4 xy0 = vec_ld_l8(tab + vec_extract(idxvec.val, 0));
-  vec_float4 xy1 = vec_ld_l8(tab + vec_extract(idxvec.val, 1));
-  vec_float4 xy2 = vec_ld_l8(tab + vec_extract(idxvec.val, 2));
-  vec_float4 xy3 = vec_ld_l8(tab + vec_extract(idxvec.val, 3));
-  vec_float4 xy02 = vec_mergeh(xy0, xy2); // x0, x2, y0, y2
-  vec_float4 xy13 = vec_mergeh(xy1, xy3); // x1, x3, y1, y3
-  x.val = vec_mergeh(xy02, xy13);
-  y.val = vec_mergel(xy02, xy13);
-}
-inline void v_lut_deinterleave(const double *tab, const v_int32x4 &idxvec,
-                               v_float64x2 &x, v_float64x2 &y) {
-  vec_double2 xy0 = vsx_ld(vec_extract(idxvec.val, 0), tab);
-  vec_double2 xy1 = vsx_ld(vec_extract(idxvec.val, 1), tab);
-  x.val = vec_mergeh(xy0, xy1);
-  y.val = vec_mergel(xy0, xy1);
-}
-
-inline v_int8x16 v_interleave_pairs(const v_int8x16 &vec) {
-  static const vec_uchar16 perm = {0, 2,  1, 3,  4,  6,  5,  7,
-                                   8, 10, 9, 11, 12, 14, 13, 15};
-  return v_int8x16(vec_perm(vec.val, vec.val, perm));
-}
-inline v_uint8x16 v_interleave_pairs(const v_uint8x16 &vec) {
-  return v_reinterpret_as_u8(v_interleave_pairs(v_reinterpret_as_s8(vec)));
-}
-
-inline v_int8x16 v_interleave_quads(const v_int8x16 &vec) {
-  static const vec_uchar16 perm = {0, 4,  1, 5,  2,  6,  3,  7,
-                                   8, 12, 9, 13, 10, 14, 11, 15};
-  return v_int8x16(vec_perm(vec.val, vec.val, perm));
-}
-inline v_uint8x16 v_interleave_quads(const v_uint8x16 &vec) {
-  return v_reinterpret_as_u8(v_interleave_quads(v_reinterpret_as_s8(vec)));
-}
-
-inline v_int16x8 v_interleave_pairs(const v_int16x8 &vec) {
-  static const vec_uchar16 perm = {0, 1, 4,  5,  2,  3,  6,  7,
-                                   8, 9, 12, 13, 10, 11, 14, 15};
-  return v_int16x8(vec_perm(vec.val, vec.val, perm));
-}
-inline v_uint16x8 v_interleave_pairs(const v_uint16x8 &vec) {
-  return v_reinterpret_as_u16(v_interleave_pairs(v_reinterpret_as_s16(vec)));
-}
-
-inline v_int16x8 v_interleave_quads(const v_int16x8 &vec) {
-  static const vec_uchar16 perm = {0, 1, 8,  9,  2, 3, 10, 11,
-                                   4, 5, 12, 13, 6, 7, 14, 15};
-  return v_int16x8(vec_perm(vec.val, vec.val, perm));
-}
-inline v_uint16x8 v_interleave_quads(const v_uint16x8 &vec) {
-  return v_reinterpret_as_u16(v_interleave_quads(v_reinterpret_as_s16(vec)));
-}
-
-inline v_int32x4 v_interleave_pairs(const v_int32x4 &vec) {
-  static const vec_uchar16 perm = {0, 1, 2, 3, 8,  9,  10, 11,
-                                   4, 5, 6, 7, 12, 13, 14, 15};
-  return v_int32x4(vec_perm(vec.val, vec.val, perm));
-}
-inline v_uint32x4 v_interleave_pairs(const v_uint32x4 &vec) {
-  return v_reinterpret_as_u32(v_interleave_pairs(v_reinterpret_as_s32(vec)));
-}
-inline v_float32x4 v_interleave_pairs(const v_float32x4 &vec) {
-  return v_reinterpret_as_f32(v_interleave_pairs(v_reinterpret_as_s32(vec)));
-}
-
-inline v_int8x16 v_pack_triplets(const v_int8x16 &vec) {
-  static const vec_uchar16 perm = {0,  1,  2,  4,  5,  6,  8,  9,
-                                   10, 12, 13, 14, 15, 15, 15, 15};
-  return v_int8x16(vec_perm(vec.val, vec.val, perm));
-}
-inline v_uint8x16 v_pack_triplets(const v_uint8x16 &vec) {
-  return v_reinterpret_as_u8(v_pack_triplets(v_reinterpret_as_s8(vec)));
-}
-
-inline v_int16x8 v_pack_triplets(const v_int16x8 &vec) {
-  static const vec_uchar16 perm = {0,  1,  2,  3,  4,  5,  8,  9,
-                                   10, 11, 12, 13, 14, 15, 14, 15};
-  return v_int16x8(vec_perm(vec.val, vec.val, perm));
-}
-inline v_uint16x8 v_pack_triplets(const v_uint16x8 &vec) {
-  return v_reinterpret_as_u16(v_pack_triplets(v_reinterpret_as_s16(vec)));
-}
-
-inline v_int32x4 v_pack_triplets(const v_int32x4 &vec) { return vec; }
-inline v_uint32x4 v_pack_triplets(const v_uint32x4 &vec) { return vec; }
-inline v_float32x4 v_pack_triplets(const v_float32x4 &vec) { return vec; }
-
-/////// FP16 support ////////
-
-inline v_float32x4 v_load_expand(const hfloat *ptr) {
-  vec_ushort8 vf16 = vec_ld_l8((const ushort *)ptr);
-#if CV_VSX3 && defined(vec_extract_fp_from_shorth)
-  return v_float32x4(vec_extract_fp_from_shorth(vf16));
-#elif CV_VSX3 && !defined(CV_COMPILER_VSX_BROKEN_ASM)
-  vec_float4 vf32;
-  __asm__ __volatile__("xvcvhpsp %x0,%x1"
-                       : "=wa"(vf32)
-                       : "wa"(vec_mergeh(vf16, vf16)));
-  return v_float32x4(vf32);
-#else
-  const vec_int4 z = vec_int4_z, delta = vec_int4_sp(0x38000000);
-  const vec_int4 signmask = vec_int4_sp(0x80000000);
-  const vec_int4 maxexp = vec_int4_sp(0x7c000000);
-  const vec_float4 deltaf = vec_float4_c(vec_int4_sp(0x38800000));
-
-  vec_int4 bits = vec_int4_c(vec_mergeh(vec_short8_c(z), vec_short8_c(vf16)));
-  vec_int4 e = vec_and(bits, maxexp), sign = vec_and(bits, signmask);
-  vec_int4 t = vec_add(vec_sr(vec_xor(bits, sign), vec_uint4_sp(3)),
-                       delta); // ((h & 0x7fff) << 13) + delta
-  vec_int4 zt = vec_int4_c(
-      vec_sub(vec_float4_c(vec_add(t, vec_int4_sp(1 << 23))), deltaf));
-
-  t = vec_add(t, vec_and(delta, vec_cmpeq(maxexp, e)));
-  vec_bint4 zmask = vec_cmpeq(e, z);
-  vec_int4 ft = vec_sel(t, zt, zmask);
-  return v_float32x4(vec_float4_c(vec_or(ft, sign)));
-#endif
-}
-
-inline void v_pack_store(hfloat *ptr, const v_float32x4 &v) {
-// fixme: Is there any builtin op or intrinsic that cover "xvcvsphp"?
-#if CV_VSX3 && !defined(CV_COMPILER_VSX_BROKEN_ASM)
-  vec_ushort8 vf16;
-  __asm__ __volatile__("xvcvsphp %x0,%x1" : "=wa"(vf16) : "wa"(v.val));
-  vec_st_l8(vec_mergesqe(vf16, vf16), ptr);
-#else
-  const vec_int4 signmask = vec_int4_sp(0x80000000);
-  const vec_int4 rval = vec_int4_sp(0x3f000000);
-
-  vec_int4 t = vec_int4_c(v.val);
-  vec_int4 sign = vec_sra(vec_and(t, signmask), vec_uint4_sp(16));
-  t = vec_and(vec_nor(signmask, signmask), t);
-
-  vec_bint4 finitemask = vec_cmpgt(vec_int4_sp(0x47800000), t);
-  vec_bint4 isnan = vec_cmpgt(t, vec_int4_sp(0x7f800000));
-  vec_int4 naninf = vec_sel(vec_int4_sp(0x7c00), vec_int4_sp(0x7e00), isnan);
-  vec_bint4 tinymask = vec_cmpgt(vec_int4_sp(0x38800000), t);
-  vec_int4 tt = vec_int4_c(vec_add(vec_float4_c(t), vec_float4_c(rval)));
-  tt = vec_sub(tt, rval);
-  vec_int4 odd = vec_and(vec_sr(t, vec_uint4_sp(13)), vec_int4_sp(1));
-  vec_int4 nt = vec_add(t, vec_int4_sp(0xc8000fff));
-  nt = vec_sr(vec_add(nt, odd), vec_uint4_sp(13));
-  t = vec_sel(nt, tt, tinymask);
-  t = vec_sel(naninf, t, finitemask);
-  t = vec_or(t, sign);
-  vec_st_l8(vec_packs(t, t), ptr);
-#endif
-}
-
-inline void v_cleanup() {}
-
-/** Reinterpret **/
-/** its up there with load and store operations **/
-
-////////// Matrix operations /////////
-
-//////// Dot Product ////////
-// 16 >> 32
-inline v_int32x4 v_dotprod(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_int32x4(vec_msum(a.val, b.val, vec_int4_z));
-}
-inline v_int32x4 v_dotprod(const v_int16x8 &a, const v_int16x8 &b,
-                           const v_int32x4 &c) {
-  return v_int32x4(vec_msum(a.val, b.val, c.val));
-}
-
-// 32 >> 64
-inline v_int64x2 v_dotprod(const v_int32x4 &a, const v_int32x4 &b) {
-  vec_dword2 even = vec_mule(a.val, b.val);
-  vec_dword2 odd = vec_mulo(a.val, b.val);
-  return v_int64x2(vec_add(even, odd));
-}
-inline v_int64x2 v_dotprod(const v_int32x4 &a, const v_int32x4 &b,
-                           const v_int64x2 &c) {
-  return v_add(v_dotprod(a, b), c);
-}
-
-// 8 >> 32
-inline v_uint32x4 v_dotprod_expand(const v_uint8x16 &a, const v_uint8x16 &b,
-                                   const v_uint32x4 &c) {
-  return v_uint32x4(vec_msum(a.val, b.val, c.val));
-}
-inline v_uint32x4 v_dotprod_expand(const v_uint8x16 &a, const v_uint8x16 &b) {
-  return v_uint32x4(vec_msum(a.val, b.val, vec_uint4_z));
-}
-
-inline v_int32x4 v_dotprod_expand(const v_int8x16 &a, const v_int8x16 &b) {
-  const vec_ushort8 eight = vec_ushort8_sp(8);
-  vec_short8 a0 = vec_sra((vec_short8)vec_sld(a.val, a.val, 1), eight); // even
-  vec_short8 a1 = vec_sra((vec_short8)a.val, eight);                    // odd
-  vec_short8 b0 = vec_sra((vec_short8)vec_sld(b.val, b.val, 1), eight);
-  vec_short8 b1 = vec_sra((vec_short8)b.val, eight);
-  return v_int32x4(vec_msum(a0, b0, vec_msum(a1, b1, vec_int4_z)));
-}
-
-inline v_int32x4 v_dotprod_expand(const v_int8x16 &a, const v_int8x16 &b,
-                                  const v_int32x4 &c) {
-  const vec_ushort8 eight = vec_ushort8_sp(8);
-  vec_short8 a0 = vec_sra((vec_short8)vec_sld(a.val, a.val, 1), eight); // even
-  vec_short8 a1 = vec_sra((vec_short8)a.val, eight);                    // odd
-  vec_short8 b0 = vec_sra((vec_short8)vec_sld(b.val, b.val, 1), eight);
-  vec_short8 b1 = vec_sra((vec_short8)b.val, eight);
-  return v_int32x4(vec_msum(a0, b0, vec_msum(a1, b1, c.val)));
-}
-
-// 16 >> 64
-inline v_uint64x2 v_dotprod_expand(const v_uint16x8 &a, const v_uint16x8 &b) {
-  const vec_uint4 zero = vec_uint4_z;
-  vec_uint4 even = vec_mule(a.val, b.val);
-  vec_uint4 odd = vec_mulo(a.val, b.val);
-  vec_udword2 e0 = (vec_udword2)vec_mergee(even, zero);
-  vec_udword2 e1 = (vec_udword2)vec_mergeo(even, zero);
-  vec_udword2 o0 = (vec_udword2)vec_mergee(odd, zero);
-  vec_udword2 o1 = (vec_udword2)vec_mergeo(odd, zero);
-  vec_udword2 s0 = vec_add(e0, o0);
-  vec_udword2 s1 = vec_add(e1, o1);
-  return v_uint64x2(vec_add(s0, s1));
-}
-inline v_uint64x2 v_dotprod_expand(const v_uint16x8 &a, const v_uint16x8 &b,
-                                   const v_uint64x2 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-inline v_int64x2 v_dotprod_expand(const v_int16x8 &a, const v_int16x8 &b) {
-  v_int32x4 prod = v_dotprod(a, b);
-  v_int64x2 c, d;
-  v_expand(prod, c, d);
-  return v_int64x2(vec_add(vec_mergeh(c.val, d.val), vec_mergel(c.val, d.val)));
-}
-inline v_int64x2 v_dotprod_expand(const v_int16x8 &a, const v_int16x8 &b,
-                                  const v_int64x2 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-// 32 >> 64f
-inline v_float64x2 v_dotprod_expand(const v_int32x4 &a, const v_int32x4 &b) {
-  return v_cvt_f64(v_dotprod(a, b));
-}
-inline v_float64x2 v_dotprod_expand(const v_int32x4 &a, const v_int32x4 &b,
-                                    const v_float64x2 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-//////// Fast Dot Product ////////
-
-// 16 >> 32
-inline v_int32x4 v_dotprod_fast(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_dotprod(a, b);
-}
-inline v_int32x4 v_dotprod_fast(const v_int16x8 &a, const v_int16x8 &b,
-                                const v_int32x4 &c) {
-  return v_int32x4(vec_msum(a.val, b.val, vec_int4_z)) + c;
-}
-// 32 >> 64
-inline v_int64x2 v_dotprod_fast(const v_int32x4 &a, const v_int32x4 &b) {
-  return v_dotprod(a, b);
-}
-inline v_int64x2 v_dotprod_fast(const v_int32x4 &a, const v_int32x4 &b,
-                                const v_int64x2 &c) {
-  return v_dotprod(a, b, c);
-}
-
-// 8 >> 32
-inline v_uint32x4 v_dotprod_expand_fast(const v_uint8x16 &a,
-                                        const v_uint8x16 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_uint32x4 v_dotprod_expand_fast(const v_uint8x16 &a,
-                                        const v_uint8x16 &b,
-                                        const v_uint32x4 &c) {
-  return v_uint32x4(vec_msum(a.val, b.val, vec_uint4_z)) + c;
-}
-
-inline v_int32x4 v_dotprod_expand_fast(const v_int8x16 &a, const v_int8x16 &b) {
-  vec_short8 a0 = vec_unpackh(a.val);
-  vec_short8 a1 = vec_unpackl(a.val);
-  vec_short8 b0 = vec_unpackh(b.val);
-  vec_short8 b1 = vec_unpackl(b.val);
-  return v_int32x4(vec_msum(a0, b0, vec_msum(a1, b1, vec_int4_z)));
-}
-inline v_int32x4 v_dotprod_expand_fast(const v_int8x16 &a, const v_int8x16 &b,
-                                       const v_int32x4 &c) {
-  return v_add(v_dotprod_expand_fast(a, b), c);
-}
-
-// 16 >> 64
-inline v_uint64x2 v_dotprod_expand_fast(const v_uint16x8 &a,
-                                        const v_uint16x8 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_uint64x2 v_dotprod_expand_fast(const v_uint16x8 &a,
-                                        const v_uint16x8 &b,
-                                        const v_uint64x2 &c) {
-  return v_dotprod_expand(a, b, c);
-}
-
-inline v_int64x2 v_dotprod_expand_fast(const v_int16x8 &a, const v_int16x8 &b) {
-  v_int32x4 prod = v_dotprod(a, b);
-  v_int64x2 c, d;
-  v_expand(prod, c, d);
-  return v_add(c, d);
-}
-inline v_int64x2 v_dotprod_expand_fast(const v_int16x8 &a, const v_int16x8 &b,
-                                       const v_int64x2 &c) {
-  return v_add(v_dotprod_expand_fast(a, b), c);
-}
-
-// 32 >> 64f
-inline v_float64x2 v_dotprod_expand_fast(const v_int32x4 &a,
-                                         const v_int32x4 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_float64x2 v_dotprod_expand_fast(const v_int32x4 &a, const v_int32x4 &b,
-                                         const v_float64x2 &c) {
-  return v_dotprod_expand(a, b, c);
-}
-
-inline v_float32x4 v_matmul(const v_float32x4 &v, const v_float32x4 &m0,
-                            const v_float32x4 &m1, const v_float32x4 &m2,
-                            const v_float32x4 &m3) {
-  const vec_float4 v0 = vec_splat(v.val, 0);
-  const vec_float4 v1 = vec_splat(v.val, 1);
-  const vec_float4 v2 = vec_splat(v.val, 2);
-  VSX_UNUSED(const vec_float4) v3 = vec_splat(v.val, 3);
-  return v_float32x4(vec_madd(
-      v0, m0.val,
-      vec_madd(v1, m1.val, vec_madd(v2, m2.val, vec_mul(v3, m3.val)))));
-}
-
-inline v_float32x4 v_matmuladd(const v_float32x4 &v, const v_float32x4 &m0,
-                               const v_float32x4 &m1, const v_float32x4 &m2,
-                               const v_float32x4 &a) {
-  const vec_float4 v0 = vec_splat(v.val, 0);
-  const vec_float4 v1 = vec_splat(v.val, 1);
-  const vec_float4 v2 = vec_splat(v.val, 2);
-  return v_float32x4(
-      vec_madd(v0, m0.val, vec_madd(v1, m1.val, vec_madd(v2, m2.val, a.val))));
-}
-
-#define OPENCV_HAL_IMPL_VSX_TRANSPOSE4x4(_Tpvec, _Tpvec2)                      \
-  inline void v_transpose4x4(const _Tpvec &a0, const _Tpvec &a1,               \
-                             const _Tpvec &a2, const _Tpvec &a3, _Tpvec &b0,   \
-                             _Tpvec &b1, _Tpvec &b2, _Tpvec &b3) {             \
-    _Tpvec2 a02 = vec_mergeh(a0.val, a2.val);                                  \
-    _Tpvec2 a13 = vec_mergeh(a1.val, a3.val);                                  \
-    b0.val = vec_mergeh(a02, a13);                                             \
-    b1.val = vec_mergel(a02, a13);                                             \
-    a02 = vec_mergel(a0.val, a2.val);                                          \
-    a13 = vec_mergel(a1.val, a3.val);                                          \
-    b2.val = vec_mergeh(a02, a13);                                             \
-    b3.val = vec_mergel(a02, a13);                                             \
-  }
-OPENCV_HAL_IMPL_VSX_TRANSPOSE4x4(v_uint32x4, vec_uint4)
-    OPENCV_HAL_IMPL_VSX_TRANSPOSE4x4(v_int32x4, vec_int4)
-        OPENCV_HAL_IMPL_VSX_TRANSPOSE4x4(v_float32x4, vec_float4)
-
-            template <int i, typename Tvec>
-            inline Tvec v_broadcast_element(const Tvec &v) {
-  return Tvec(vec_splat(v.val, i));
-}
-
-#include "intrin_math.hpp"
-inline v_float32x4 v_exp(const v_float32x4 &x) {
-  return v_exp_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline v_float32x4 v_log(const v_float32x4 &x) {
-  return v_log_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline void v_sincos(const v_float32x4 &x, v_float32x4 &s, v_float32x4 &c) {
-  v_sincos_default_32f<v_float32x4, v_int32x4>(x, s, c);
-}
-inline v_float32x4 v_sin(const v_float32x4 &x) {
-  return v_sin_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline v_float32x4 v_cos(const v_float32x4 &x) {
-  return v_cos_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline v_float32x4 v_erf(const v_float32x4 &x) {
-  return v_erf_default_32f<v_float32x4, v_int32x4>(x);
-}
-
-inline v_float64x2 v_exp(const v_float64x2 &x) {
-  return v_exp_default_64f<v_float64x2, v_int64x2>(x);
-}
-inline v_float64x2 v_log(const v_float64x2 &x) {
-  return v_log_default_64f<v_float64x2, v_int64x2>(x);
-}
-inline void v_sincos(const v_float64x2 &x, v_float64x2 &s, v_float64x2 &c) {
-  v_sincos_default_64f<v_float64x2, v_int64x2>(x, s, c);
-}
-inline v_float64x2 v_sin(const v_float64x2 &x) {
-  return v_sin_default_64f<v_float64x2, v_int64x2>(x);
-}
-inline v_float64x2 v_cos(const v_float64x2 &x) {
-  return v_cos_default_64f<v_float64x2, v_int64x2>(x);
-}
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_END
-
-//! @endcond
-
-} // namespace cv
-
-#endif // OPENCV_HAL_VSX_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_wasm.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_wasm.hpp
deleted file mode 100644
index 7ef7e3e059..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/hal/intrin_wasm.hpp
+++ /dev/null
@@ -1,2911 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_HAL_INTRIN_WASM_HPP
-#define OPENCV_HAL_INTRIN_WASM_HPP
-
-#include "opencv2/core/saturate.hpp"
-#include <algorithm>
-#include <cstring>
-#include <limits>
-
-// Emscripten v2.0.13 (latest officially supported, as of 07/30/2024):
-// __EMSCRIPTEN_major__, __EMSCRIPTEN_minor__ and __EMSCRIPTEN_tiny__ are
-// defined via commandline in
-// https://github.com/emscripten-core/emscripten/blob/1690a5802cd1241adc9714fb7fa2f633d38860dc/tools/shared.py#L506-L515
-//
-// See https://github.com/opencv/opencv/pull/25909
-#ifndef __EMSCRIPTEN_major__
-#include <emscripten/version.h>
-#endif
-
-#define CV_SIMD128 1
-#define CV_SIMD128_64F                                                         \
-  0 // Now all implementation of f64 use fallback, so disable it.
-#define CV_SIMD128_FP16 0
-
-namespace cv {
-
-//! @cond IGNORED
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_BEGIN
-
-#if (__EMSCRIPTEN_major__ * 1000000 + __EMSCRIPTEN_minor__ * 1000 +            \
-     __EMSCRIPTEN_tiny__) < (1038046)
-// handle renames: https://github.com/emscripten-core/emscripten/pull/9440
-// (https://github.com/emscripten-core/emscripten/commit/755d5b46cb84d0aa120c10981b11d05646c29673)
-#define wasm_i32x4_trunc_saturate_f32x4 wasm_trunc_saturate_i32x4_f32x4
-#define wasm_u32x4_trunc_saturate_f32x4 wasm_trunc_saturate_u32x4_f32x4
-#define wasm_i64x2_trunc_saturate_f64x2 wasm_trunc_saturate_i64x2_f64x2
-#define wasm_u64x2_trunc_saturate_f64x2 wasm_trunc_saturate_u64x2_f64x2
-#define wasm_f32x4_convert_i32x4 wasm_convert_f32x4_i32x4
-#define wasm_f32x4_convert_u32x4 wasm_convert_f32x4_u32x4
-#define wasm_f64x2_convert_i64x2 wasm_convert_f64x2_i64x2
-#define wasm_f64x2_convert_u64x2 wasm_convert_f64x2_u64x2
-#endif // COMPATIBILITY: <1.38.46
-
-///////// Types ///////////
-
-struct v_uint8x16 {
-  typedef uchar lane_type;
-  typedef v128_t vector_type;
-  enum { nlanes = 16 };
-
-  v_uint8x16() {}
-  explicit v_uint8x16(v128_t v) : val(v) {}
-  v_uint8x16(uchar v0, uchar v1, uchar v2, uchar v3, uchar v4, uchar v5,
-             uchar v6, uchar v7, uchar v8, uchar v9, uchar v10, uchar v11,
-             uchar v12, uchar v13, uchar v14, uchar v15) {
-    uchar v[] = {v0, v1, v2,  v3,  v4,  v5,  v6,  v7,
-                 v8, v9, v10, v11, v12, v13, v14, v15};
-    val = wasm_v128_load(v);
-  }
-
-  uchar get0() const { return (uchar)wasm_i8x16_extract_lane(val, 0); }
-
-  v128_t val;
-};
-
-struct v_int8x16 {
-  typedef schar lane_type;
-  typedef v128_t vector_type;
-  enum { nlanes = 16 };
-
-  v_int8x16() {}
-  explicit v_int8x16(v128_t v) : val(v) {}
-  v_int8x16(schar v0, schar v1, schar v2, schar v3, schar v4, schar v5,
-            schar v6, schar v7, schar v8, schar v9, schar v10, schar v11,
-            schar v12, schar v13, schar v14, schar v15) {
-    schar v[] = {v0, v1, v2,  v3,  v4,  v5,  v6,  v7,
-                 v8, v9, v10, v11, v12, v13, v14, v15};
-    val = wasm_v128_load(v);
-  }
-
-  schar get0() const { return wasm_i8x16_extract_lane(val, 0); }
-
-  v128_t val;
-};
-
-struct v_uint16x8 {
-  typedef ushort lane_type;
-  typedef v128_t vector_type;
-  enum { nlanes = 8 };
-
-  v_uint16x8() {}
-  explicit v_uint16x8(v128_t v) : val(v) {}
-  v_uint16x8(ushort v0, ushort v1, ushort v2, ushort v3, ushort v4, ushort v5,
-             ushort v6, ushort v7) {
-    ushort v[] = {v0, v1, v2, v3, v4, v5, v6, v7};
-    val = wasm_v128_load(v);
-  }
-
-  ushort get0() const {
-    return (ushort)wasm_i16x8_extract_lane(
-        val, 0); // wasm_u16x8_extract_lane() unimplemented yet
-  }
-
-  v128_t val;
-};
-
-struct v_int16x8 {
-  typedef short lane_type;
-  typedef v128_t vector_type;
-  enum { nlanes = 8 };
-
-  v_int16x8() {}
-  explicit v_int16x8(v128_t v) : val(v) {}
-  v_int16x8(short v0, short v1, short v2, short v3, short v4, short v5,
-            short v6, short v7) {
-    short v[] = {v0, v1, v2, v3, v4, v5, v6, v7};
-    val = wasm_v128_load(v);
-  }
-
-  short get0() const { return wasm_i16x8_extract_lane(val, 0); }
-
-  v128_t val;
-};
-
-struct v_uint32x4 {
-  typedef unsigned lane_type;
-  typedef v128_t vector_type;
-  enum { nlanes = 4 };
-
-  v_uint32x4() {}
-  explicit v_uint32x4(v128_t v) : val(v) {}
-  v_uint32x4(unsigned v0, unsigned v1, unsigned v2, unsigned v3) {
-    unsigned v[] = {v0, v1, v2, v3};
-    val = wasm_v128_load(v);
-  }
-
-  unsigned get0() const { return (unsigned)wasm_i32x4_extract_lane(val, 0); }
-
-  v128_t val;
-};
-
-struct v_int32x4 {
-  typedef int lane_type;
-  typedef v128_t vector_type;
-  enum { nlanes = 4 };
-
-  v_int32x4() {}
-  explicit v_int32x4(v128_t v) : val(v) {}
-  v_int32x4(int v0, int v1, int v2, int v3) {
-    int v[] = {v0, v1, v2, v3};
-    val = wasm_v128_load(v);
-  }
-
-  int get0() const { return wasm_i32x4_extract_lane(val, 0); }
-
-  v128_t val;
-};
-
-struct v_float32x4 {
-  typedef float lane_type;
-  typedef v128_t vector_type;
-  enum { nlanes = 4 };
-
-  v_float32x4() {}
-  explicit v_float32x4(v128_t v) : val(v) {}
-  v_float32x4(float v0, float v1, float v2, float v3) {
-    float v[] = {v0, v1, v2, v3};
-    val = wasm_v128_load(v);
-  }
-
-  float get0() const { return wasm_f32x4_extract_lane(val, 0); }
-
-  v128_t val;
-};
-
-struct v_uint64x2 {
-  typedef uint64 lane_type;
-  typedef v128_t vector_type;
-  enum { nlanes = 2 };
-
-  v_uint64x2() {}
-  explicit v_uint64x2(v128_t v) : val(v) {}
-  v_uint64x2(uint64 v0, uint64 v1) {
-    uint64 v[] = {v0, v1};
-    val = wasm_v128_load(v);
-  }
-
-  uint64 get0() const { return (uint64)wasm_i64x2_extract_lane(val, 0); }
-
-  v128_t val;
-};
-
-struct v_int64x2 {
-  typedef int64 lane_type;
-  typedef v128_t vector_type;
-  enum { nlanes = 2 };
-
-  v_int64x2() {}
-  explicit v_int64x2(v128_t v) : val(v) {}
-  v_int64x2(int64 v0, int64 v1) {
-    int64 v[] = {v0, v1};
-    val = wasm_v128_load(v);
-  }
-
-  int64 get0() const { return wasm_i64x2_extract_lane(val, 0); }
-
-  v128_t val;
-};
-
-struct v_float64x2 {
-  typedef double lane_type;
-  typedef v128_t vector_type;
-  enum { nlanes = 2 };
-
-  v_float64x2() {}
-  explicit v_float64x2(v128_t v) : val(v) {}
-  v_float64x2(double v0, double v1) {
-    double v[] = {v0, v1};
-    val = wasm_v128_load(v);
-  }
-
-  double get0() const { return wasm_f64x2_extract_lane(val, 0); }
-
-  v128_t val;
-};
-
-namespace {
-#define OPENCV_HAL_IMPL_REINTERPRET_INT(ft, tt)                                \
-  inline tt reinterpret_int(ft x) {                                            \
-    union {                                                                    \
-      ft l;                                                                    \
-      tt i;                                                                    \
-    } v;                                                                       \
-    v.l = x;                                                                   \
-    return v.i;                                                                \
-  }
-OPENCV_HAL_IMPL_REINTERPRET_INT(uchar, schar)
-OPENCV_HAL_IMPL_REINTERPRET_INT(schar, schar)
-OPENCV_HAL_IMPL_REINTERPRET_INT(ushort, short)
-OPENCV_HAL_IMPL_REINTERPRET_INT(short, short)
-OPENCV_HAL_IMPL_REINTERPRET_INT(unsigned, int)
-OPENCV_HAL_IMPL_REINTERPRET_INT(int, int)
-OPENCV_HAL_IMPL_REINTERPRET_INT(float, int)
-OPENCV_HAL_IMPL_REINTERPRET_INT(uint64, int64)
-OPENCV_HAL_IMPL_REINTERPRET_INT(int64, int64)
-OPENCV_HAL_IMPL_REINTERPRET_INT(double, int64)
-
-static const unsigned char popCountTable[] = {
-    0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4,
-    2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4,
-    2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6,
-    4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5,
-    3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6,
-    4, 5, 5, 6, 5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-    4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,
-};
-} // namespace
-
-static v128_t wasm_unpacklo_i8x16(v128_t a, v128_t b) {
-  return wasm_i8x16_shuffle(a, b, 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6,
-                            22, 7, 23);
-}
-
-static v128_t wasm_unpacklo_i16x8(v128_t a, v128_t b) {
-  return wasm_i8x16_shuffle(a, b, 0, 1, 16, 17, 2, 3, 18, 19, 4, 5, 20, 21, 6,
-                            7, 22, 23);
-}
-
-static v128_t wasm_unpacklo_i32x4(v128_t a, v128_t b) {
-  return wasm_i8x16_shuffle(a, b, 0, 1, 2, 3, 16, 17, 18, 19, 4, 5, 6, 7, 20,
-                            21, 22, 23);
-}
-
-static v128_t wasm_unpacklo_i64x2(v128_t a, v128_t b) {
-  return wasm_i8x16_shuffle(a, b, 0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20,
-                            21, 22, 23);
-}
-
-static v128_t wasm_unpackhi_i8x16(v128_t a, v128_t b) {
-  return wasm_i8x16_shuffle(a, b, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29,
-                            14, 30, 15, 31);
-}
-
-static v128_t wasm_unpackhi_i16x8(v128_t a, v128_t b) {
-  return wasm_i8x16_shuffle(a, b, 8, 9, 24, 25, 10, 11, 26, 27, 12, 13, 28, 29,
-                            14, 15, 30, 31);
-}
-
-static v128_t wasm_unpackhi_i32x4(v128_t a, v128_t b) {
-  return wasm_i8x16_shuffle(a, b, 8, 9, 10, 11, 24, 25, 26, 27, 12, 13, 14, 15,
-                            28, 29, 30, 31);
-}
-
-static v128_t wasm_unpackhi_i64x2(v128_t a, v128_t b) {
-  return wasm_i8x16_shuffle(a, b, 8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27,
-                            28, 29, 30, 31);
-}
-
-/** Convert **/
-// 8 >> 16
-inline v128_t v128_cvtu8x16_i16x8(const v128_t &a) {
-  const v128_t z = wasm_i8x16_splat(0);
-  return wasm_unpacklo_i8x16(a, z);
-}
-inline v128_t v128_cvti8x16_i16x8(const v128_t &a) {
-  return wasm_i16x8_shr(wasm_unpacklo_i8x16(a, a), 8);
-}
-// 8 >> 32
-inline v128_t v128_cvtu8x16_i32x4(const v128_t &a) {
-  const v128_t z = wasm_i8x16_splat(0);
-  return wasm_unpacklo_i16x8(wasm_unpacklo_i8x16(a, z), z);
-}
-inline v128_t v128_cvti8x16_i32x4(const v128_t &a) {
-  v128_t r = wasm_unpacklo_i8x16(a, a);
-  r = wasm_unpacklo_i8x16(r, r);
-  return wasm_i32x4_shr(r, 24);
-}
-// 16 >> 32
-inline v128_t v128_cvtu16x8_i32x4(const v128_t &a) {
-  const v128_t z = wasm_i8x16_splat(0);
-  return wasm_unpacklo_i16x8(a, z);
-}
-inline v128_t v128_cvti16x8_i32x4(const v128_t &a) {
-  return wasm_i32x4_shr(wasm_unpacklo_i16x8(a, a), 16);
-}
-// 32 >> 64
-inline v128_t v128_cvtu32x4_i64x2(const v128_t &a) {
-  const v128_t z = wasm_i8x16_splat(0);
-  return wasm_unpacklo_i32x4(a, z);
-}
-inline v128_t v128_cvti32x4_i64x2(const v128_t &a) {
-  return wasm_unpacklo_i32x4(a, wasm_i32x4_shr(a, 31));
-}
-
-// 16 << 8
-inline v128_t v128_cvtu8x16_i16x8_high(const v128_t &a) {
-  const v128_t z = wasm_i8x16_splat(0);
-  return wasm_unpackhi_i8x16(a, z);
-}
-inline v128_t v128_cvti8x16_i16x8_high(const v128_t &a) {
-  return wasm_i16x8_shr(wasm_unpackhi_i8x16(a, a), 8);
-}
-// 32 << 16
-inline v128_t v128_cvtu16x8_i32x4_high(const v128_t &a) {
-  const v128_t z = wasm_i8x16_splat(0);
-  return wasm_unpackhi_i16x8(a, z);
-}
-inline v128_t v128_cvti16x8_i32x4_high(const v128_t &a) {
-  return wasm_i32x4_shr(wasm_unpackhi_i16x8(a, a), 16);
-}
-// 64 << 32
-inline v128_t v128_cvtu32x4_i64x2_high(const v128_t &a) {
-  const v128_t z = wasm_i8x16_splat(0);
-  return wasm_unpackhi_i32x4(a, z);
-}
-inline v128_t v128_cvti32x4_i64x2_high(const v128_t &a) {
-  return wasm_unpackhi_i32x4(a, wasm_i32x4_shr(a, 31));
-}
-
-#define OPENCV_HAL_IMPL_WASM_INITVEC(_Tpvec, _Tp, suffix, zsuffix, _Tps)       \
-  inline _Tpvec v_setzero_##suffix() {                                         \
-    return _Tpvec(wasm_##zsuffix##_splat((_Tps)0));                            \
-  }                                                                            \
-  inline _Tpvec v_setall_##suffix(_Tp v) {                                     \
-    return _Tpvec(wasm_##zsuffix##_splat((_Tps)v));                            \
-  }                                                                            \
-  template <> inline _Tpvec v_setzero_() { return v_setzero_##suffix(); }      \
-  template <> inline _Tpvec v_setall_(_Tp v) { return v_setall_##suffix(v); }  \
-  template <typename _Tpvec0>                                                  \
-  inline _Tpvec v_reinterpret_as_##suffix(const _Tpvec0 &a) {                  \
-    return _Tpvec(a.val);                                                      \
-  }
-
-OPENCV_HAL_IMPL_WASM_INITVEC(v_uint8x16, uchar, u8, i8x16, schar)
-OPENCV_HAL_IMPL_WASM_INITVEC(v_int8x16, schar, s8, i8x16, schar)
-OPENCV_HAL_IMPL_WASM_INITVEC(v_uint16x8, ushort, u16, i16x8, short)
-OPENCV_HAL_IMPL_WASM_INITVEC(v_int16x8, short, s16, i16x8, short)
-OPENCV_HAL_IMPL_WASM_INITVEC(v_uint32x4, unsigned, u32, i32x4, int)
-OPENCV_HAL_IMPL_WASM_INITVEC(v_int32x4, int, s32, i32x4, int)
-OPENCV_HAL_IMPL_WASM_INITVEC(v_float32x4, float, f32, f32x4, float)
-OPENCV_HAL_IMPL_WASM_INITVEC(v_uint64x2, uint64, u64, i64x2, int64)
-OPENCV_HAL_IMPL_WASM_INITVEC(v_int64x2, int64, s64, i64x2, int64)
-OPENCV_HAL_IMPL_WASM_INITVEC(v_float64x2, double, f64, f64x2, double)
-
-//////////////// PACK ///////////////
-inline v_uint8x16 v_pack(const v_uint16x8 &a, const v_uint16x8 &b) {
-  v128_t maxval = wasm_i16x8_splat(255);
-  v128_t a1 = wasm_v128_bitselect(maxval, a.val, wasm_u16x8_gt(a.val, maxval));
-  v128_t b1 = wasm_v128_bitselect(maxval, b.val, wasm_u16x8_gt(b.val, maxval));
-  return v_uint8x16(wasm_i8x16_shuffle(a1, b1, 0, 2, 4, 6, 8, 10, 12, 14, 16,
-                                       18, 20, 22, 24, 26, 28, 30));
-}
-inline v_int8x16 v_pack(const v_int16x8 &a, const v_int16x8 &b) {
-  v128_t maxval = wasm_i16x8_splat(127);
-  v128_t minval = wasm_i16x8_splat(-128);
-  v128_t a1 = wasm_v128_bitselect(maxval, a.val, wasm_i16x8_gt(a.val, maxval));
-  v128_t b1 = wasm_v128_bitselect(maxval, b.val, wasm_i16x8_gt(b.val, maxval));
-  v128_t a2 = wasm_v128_bitselect(minval, a1, wasm_i16x8_lt(a1, minval));
-  v128_t b2 = wasm_v128_bitselect(minval, b1, wasm_i16x8_lt(b1, minval));
-  return v_int8x16(wasm_i8x16_shuffle(a2, b2, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18,
-                                      20, 22, 24, 26, 28, 30));
-}
-inline v_uint16x8 v_pack(const v_uint32x4 &a, const v_uint32x4 &b) {
-  v128_t maxval = wasm_i32x4_splat(65535);
-  v128_t a1 = wasm_v128_bitselect(maxval, a.val, wasm_u32x4_gt(a.val, maxval));
-  v128_t b1 = wasm_v128_bitselect(maxval, b.val, wasm_u32x4_gt(b.val, maxval));
-  return v_uint16x8(wasm_i8x16_shuffle(a1, b1, 0, 1, 4, 5, 8, 9, 12, 13, 16, 17,
-                                       20, 21, 24, 25, 28, 29));
-}
-inline v_int16x8 v_pack(const v_int32x4 &a, const v_int32x4 &b) {
-  v128_t maxval = wasm_i32x4_splat(32767);
-  v128_t minval = wasm_i32x4_splat(-32768);
-  v128_t a1 = wasm_v128_bitselect(maxval, a.val, wasm_i32x4_gt(a.val, maxval));
-  v128_t b1 = wasm_v128_bitselect(maxval, b.val, wasm_i32x4_gt(b.val, maxval));
-  v128_t a2 = wasm_v128_bitselect(minval, a1, wasm_i32x4_lt(a1, minval));
-  v128_t b2 = wasm_v128_bitselect(minval, b1, wasm_i32x4_lt(b1, minval));
-  return v_int16x8(wasm_i8x16_shuffle(a2, b2, 0, 1, 4, 5, 8, 9, 12, 13, 16, 17,
-                                      20, 21, 24, 25, 28, 29));
-}
-inline v_uint32x4 v_pack(const v_uint64x2 &a, const v_uint64x2 &b) {
-  return v_uint32x4(wasm_i8x16_shuffle(a.val, b.val, 0, 1, 2, 3, 8, 9, 10, 11,
-                                       16, 17, 18, 19, 24, 25, 26, 27));
-}
-inline v_int32x4 v_pack(const v_int64x2 &a, const v_int64x2 &b) {
-  return v_int32x4(wasm_i8x16_shuffle(a.val, b.val, 0, 1, 2, 3, 8, 9, 10, 11,
-                                      16, 17, 18, 19, 24, 25, 26, 27));
-}
-inline v_uint8x16 v_pack_u(const v_int16x8 &a, const v_int16x8 &b) {
-  v128_t maxval = wasm_i16x8_splat(255);
-  v128_t minval = wasm_i16x8_splat(0);
-  v128_t a1 = wasm_v128_bitselect(maxval, a.val, wasm_i16x8_gt(a.val, maxval));
-  v128_t b1 = wasm_v128_bitselect(maxval, b.val, wasm_i16x8_gt(b.val, maxval));
-  v128_t a2 = wasm_v128_bitselect(minval, a1, wasm_i16x8_lt(a1, minval));
-  v128_t b2 = wasm_v128_bitselect(minval, b1, wasm_i16x8_lt(b1, minval));
-  return v_uint8x16(wasm_i8x16_shuffle(a2, b2, 0, 2, 4, 6, 8, 10, 12, 14, 16,
-                                       18, 20, 22, 24, 26, 28, 30));
-}
-inline v_uint16x8 v_pack_u(const v_int32x4 &a, const v_int32x4 &b) {
-  v128_t maxval = wasm_i32x4_splat(65535);
-  v128_t minval = wasm_i32x4_splat(0);
-  v128_t a1 = wasm_v128_bitselect(maxval, a.val, wasm_i32x4_gt(a.val, maxval));
-  v128_t b1 = wasm_v128_bitselect(maxval, b.val, wasm_i32x4_gt(b.val, maxval));
-  v128_t a2 = wasm_v128_bitselect(minval, a1, wasm_i32x4_lt(a1, minval));
-  v128_t b2 = wasm_v128_bitselect(minval, b1, wasm_i32x4_lt(b1, minval));
-  return v_uint16x8(wasm_i8x16_shuffle(a2, b2, 0, 1, 4, 5, 8, 9, 12, 13, 16, 17,
-                                       20, 21, 24, 25, 28, 29));
-}
-
-template <int n>
-inline v_uint8x16 v_rshr_pack(const v_uint16x8 &a, const v_uint16x8 &b) {
-  v128_t delta = wasm_i16x8_splat(((short)1 << (n - 1)));
-  v128_t a1 = wasm_u16x8_shr(wasm_i16x8_add(a.val, delta), n);
-  v128_t b1 = wasm_u16x8_shr(wasm_i16x8_add(b.val, delta), n);
-  v128_t maxval = wasm_i16x8_splat(255);
-  v128_t a2 = wasm_v128_bitselect(maxval, a1, wasm_u16x8_gt(a1, maxval));
-  v128_t b2 = wasm_v128_bitselect(maxval, b1, wasm_u16x8_gt(b1, maxval));
-  return v_uint8x16(wasm_i8x16_shuffle(a2, b2, 0, 2, 4, 6, 8, 10, 12, 14, 16,
-                                       18, 20, 22, 24, 26, 28, 30));
-}
-template <int n>
-inline v_int8x16 v_rshr_pack(const v_int16x8 &a, const v_int16x8 &b) {
-  v128_t delta = wasm_i16x8_splat(((short)1 << (n - 1)));
-  v128_t a1 = wasm_i16x8_shr(wasm_i16x8_add(a.val, delta), n);
-  v128_t b1 = wasm_i16x8_shr(wasm_i16x8_add(b.val, delta), n);
-  v128_t maxval = wasm_i16x8_splat(127);
-  v128_t minval = wasm_i16x8_splat(-128);
-  v128_t a2 = wasm_v128_bitselect(maxval, a1, wasm_i16x8_gt(a1, maxval));
-  v128_t b2 = wasm_v128_bitselect(maxval, b1, wasm_i16x8_gt(b1, maxval));
-  v128_t a3 = wasm_v128_bitselect(minval, a2, wasm_i16x8_lt(a1, minval));
-  v128_t b3 = wasm_v128_bitselect(minval, b2, wasm_i16x8_lt(b1, minval));
-  return v_int8x16(wasm_i8x16_shuffle(a3, b3, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18,
-                                      20, 22, 24, 26, 28, 30));
-}
-template <int n>
-inline v_uint16x8 v_rshr_pack(const v_uint32x4 &a, const v_uint32x4 &b) {
-  v128_t delta = wasm_i32x4_splat(((int)1 << (n - 1)));
-  v128_t a1 = wasm_u32x4_shr(wasm_i32x4_add(a.val, delta), n);
-  v128_t b1 = wasm_u32x4_shr(wasm_i32x4_add(b.val, delta), n);
-  v128_t maxval = wasm_i32x4_splat(65535);
-  v128_t a2 = wasm_v128_bitselect(maxval, a1, wasm_u32x4_gt(a1, maxval));
-  v128_t b2 = wasm_v128_bitselect(maxval, b1, wasm_u32x4_gt(b1, maxval));
-  return v_uint16x8(wasm_i8x16_shuffle(a2, b2, 0, 1, 4, 5, 8, 9, 12, 13, 16, 17,
-                                       20, 21, 24, 25, 28, 29));
-}
-template <int n>
-inline v_int16x8 v_rshr_pack(const v_int32x4 &a, const v_int32x4 &b) {
-  v128_t delta = wasm_i32x4_splat(((int)1 << (n - 1)));
-  v128_t a1 = wasm_i32x4_shr(wasm_i32x4_add(a.val, delta), n);
-  v128_t b1 = wasm_i32x4_shr(wasm_i32x4_add(b.val, delta), n);
-  v128_t maxval = wasm_i32x4_splat(32767);
-  v128_t minval = wasm_i16x8_splat(-32768);
-  v128_t a2 = wasm_v128_bitselect(maxval, a1, wasm_i32x4_gt(a1, maxval));
-  v128_t b2 = wasm_v128_bitselect(maxval, b1, wasm_i32x4_gt(b1, maxval));
-  v128_t a3 = wasm_v128_bitselect(minval, a2, wasm_i32x4_lt(a1, minval));
-  v128_t b3 = wasm_v128_bitselect(minval, b2, wasm_i32x4_lt(b1, minval));
-  return v_int16x8(wasm_i8x16_shuffle(a3, b3, 0, 1, 4, 5, 8, 9, 12, 13, 16, 17,
-                                      20, 21, 24, 25, 28, 29));
-}
-template <int n>
-inline v_uint32x4 v_rshr_pack(const v_uint64x2 &a, const v_uint64x2 &b) {
-  v128_t delta = wasm_i64x2_splat(((int64)1 << (n - 1)));
-  v128_t a1 = wasm_u64x2_shr(wasm_i64x2_add(a.val, delta), n);
-  v128_t b1 = wasm_u64x2_shr(wasm_i64x2_add(b.val, delta), n);
-  return v_uint32x4(wasm_i8x16_shuffle(a1, b1, 0, 1, 2, 3, 8, 9, 10, 11, 16, 17,
-                                       18, 19, 24, 25, 26, 27));
-}
-template <int n>
-inline v_int32x4 v_rshr_pack(const v_int64x2 &a, const v_int64x2 &b) {
-  v128_t delta = wasm_i64x2_splat(((int64)1 << (n - 1)));
-  v128_t a1 = wasm_i64x2_shr(wasm_i64x2_add(a.val, delta), n);
-  v128_t b1 = wasm_i64x2_shr(wasm_i64x2_add(b.val, delta), n);
-  return v_int32x4(wasm_i8x16_shuffle(a1, b1, 0, 1, 2, 3, 8, 9, 10, 11, 16, 17,
-                                      18, 19, 24, 25, 26, 27));
-}
-template <int n>
-inline v_uint8x16 v_rshr_pack_u(const v_int16x8 &a, const v_int16x8 &b) {
-  v128_t delta = wasm_i16x8_splat(((short)1 << (n - 1)));
-  v128_t a1 = wasm_i16x8_shr(wasm_i16x8_add(a.val, delta), n);
-  v128_t b1 = wasm_i16x8_shr(wasm_i16x8_add(b.val, delta), n);
-  v128_t maxval = wasm_i16x8_splat(255);
-  v128_t minval = wasm_i16x8_splat(0);
-  v128_t a2 = wasm_v128_bitselect(maxval, a1, wasm_i16x8_gt(a1, maxval));
-  v128_t b2 = wasm_v128_bitselect(maxval, b1, wasm_i16x8_gt(b1, maxval));
-  v128_t a3 = wasm_v128_bitselect(minval, a2, wasm_i16x8_lt(a1, minval));
-  v128_t b3 = wasm_v128_bitselect(minval, b2, wasm_i16x8_lt(b1, minval));
-  return v_uint8x16(wasm_i8x16_shuffle(a3, b3, 0, 2, 4, 6, 8, 10, 12, 14, 16,
-                                       18, 20, 22, 24, 26, 28, 30));
-}
-template <int n>
-inline v_uint16x8 v_rshr_pack_u(const v_int32x4 &a, const v_int32x4 &b) {
-  v128_t delta = wasm_i32x4_splat(((int)1 << (n - 1)));
-  v128_t a1 = wasm_i32x4_shr(wasm_i32x4_add(a.val, delta), n);
-  v128_t b1 = wasm_i32x4_shr(wasm_i32x4_add(b.val, delta), n);
-  v128_t maxval = wasm_i32x4_splat(65535);
-  v128_t minval = wasm_i16x8_splat(0);
-  v128_t a2 = wasm_v128_bitselect(maxval, a1, wasm_i32x4_gt(a1, maxval));
-  v128_t b2 = wasm_v128_bitselect(maxval, b1, wasm_i32x4_gt(b1, maxval));
-  v128_t a3 = wasm_v128_bitselect(minval, a2, wasm_i32x4_lt(a1, minval));
-  v128_t b3 = wasm_v128_bitselect(minval, b2, wasm_i32x4_lt(b1, minval));
-  return v_uint16x8(wasm_i8x16_shuffle(a3, b3, 0, 1, 4, 5, 8, 9, 12, 13, 16, 17,
-                                       20, 21, 24, 25, 28, 29));
-}
-
-inline void v_pack_store(uchar *ptr, const v_uint16x8 &a) {
-  v128_t maxval = wasm_i16x8_splat(255);
-  v128_t a1 = wasm_v128_bitselect(maxval, a.val, wasm_u16x8_gt(a.val, maxval));
-  v128_t r = wasm_i8x16_shuffle(a1, a1, 0, 2, 4, 6, 8, 10, 12, 14, 0, 2, 4, 6,
-                                8, 10, 12, 14);
-  uchar t_ptr[16];
-  wasm_v128_store(t_ptr, r);
-  for (int i = 0; i < 8; ++i) {
-    ptr[i] = t_ptr[i];
-  }
-}
-inline void v_pack_store(schar *ptr, const v_int16x8 &a) {
-  v128_t maxval = wasm_i16x8_splat(127);
-  v128_t minval = wasm_i16x8_splat(-128);
-  v128_t a1 = wasm_v128_bitselect(maxval, a.val, wasm_i16x8_gt(a.val, maxval));
-  v128_t a2 = wasm_v128_bitselect(minval, a1, wasm_i16x8_lt(a1, minval));
-  v128_t r = wasm_i8x16_shuffle(a2, a2, 0, 2, 4, 6, 8, 10, 12, 14, 0, 2, 4, 6,
-                                8, 10, 12, 14);
-  schar t_ptr[16];
-  wasm_v128_store(t_ptr, r);
-  for (int i = 0; i < 8; ++i) {
-    ptr[i] = t_ptr[i];
-  }
-}
-inline void v_pack_store(ushort *ptr, const v_uint32x4 &a) {
-  v128_t maxval = wasm_i32x4_splat(65535);
-  v128_t a1 = wasm_v128_bitselect(maxval, a.val, wasm_u32x4_gt(a.val, maxval));
-  v128_t r = wasm_i8x16_shuffle(a1, a1, 0, 1, 4, 5, 8, 9, 12, 13, 0, 1, 4, 5, 8,
-                                9, 12, 13);
-  ushort t_ptr[8];
-  wasm_v128_store(t_ptr, r);
-  for (int i = 0; i < 4; ++i) {
-    ptr[i] = t_ptr[i];
-  }
-}
-inline void v_pack_store(short *ptr, const v_int32x4 &a) {
-  v128_t maxval = wasm_i32x4_splat(32767);
-  v128_t minval = wasm_i32x4_splat(-32768);
-  v128_t a1 = wasm_v128_bitselect(maxval, a.val, wasm_i32x4_gt(a.val, maxval));
-  v128_t a2 = wasm_v128_bitselect(minval, a1, wasm_i32x4_lt(a1, minval));
-  v128_t r = wasm_i8x16_shuffle(a2, a2, 0, 1, 4, 5, 8, 9, 12, 13, 0, 1, 4, 5, 8,
-                                9, 12, 13);
-  short t_ptr[8];
-  wasm_v128_store(t_ptr, r);
-  for (int i = 0; i < 4; ++i) {
-    ptr[i] = t_ptr[i];
-  }
-}
-inline void v_pack_store(unsigned *ptr, const v_uint64x2 &a) {
-  v128_t r = wasm_i8x16_shuffle(a.val, a.val, 0, 1, 2, 3, 8, 9, 10, 11, 0, 1, 2,
-                                3, 8, 9, 10, 11);
-  unsigned t_ptr[4];
-  wasm_v128_store(t_ptr, r);
-  for (int i = 0; i < 2; ++i) {
-    ptr[i] = t_ptr[i];
-  }
-}
-inline void v_pack_store(int *ptr, const v_int64x2 &a) {
-  v128_t r = wasm_i8x16_shuffle(a.val, a.val, 0, 1, 2, 3, 8, 9, 10, 11, 0, 1, 2,
-                                3, 8, 9, 10, 11);
-  int t_ptr[4];
-  wasm_v128_store(t_ptr, r);
-  for (int i = 0; i < 2; ++i) {
-    ptr[i] = t_ptr[i];
-  }
-}
-inline void v_pack_u_store(uchar *ptr, const v_int16x8 &a) {
-  v128_t maxval = wasm_i16x8_splat(255);
-  v128_t minval = wasm_i16x8_splat(0);
-  v128_t a1 = wasm_v128_bitselect(maxval, a.val, wasm_i16x8_gt(a.val, maxval));
-  v128_t a2 = wasm_v128_bitselect(minval, a1, wasm_i16x8_lt(a1, minval));
-  v128_t r = wasm_i8x16_shuffle(a2, a2, 0, 2, 4, 6, 8, 10, 12, 14, 0, 2, 4, 6,
-                                8, 10, 12, 14);
-  uchar t_ptr[16];
-  wasm_v128_store(t_ptr, r);
-  for (int i = 0; i < 8; ++i) {
-    ptr[i] = t_ptr[i];
-  }
-}
-inline void v_pack_u_store(ushort *ptr, const v_int32x4 &a) {
-  v128_t maxval = wasm_i32x4_splat(65535);
-  v128_t minval = wasm_i32x4_splat(0);
-  v128_t a1 = wasm_v128_bitselect(maxval, a.val, wasm_i32x4_gt(a.val, maxval));
-  v128_t a2 = wasm_v128_bitselect(minval, a1, wasm_i32x4_lt(a1, minval));
-  v128_t r = wasm_i8x16_shuffle(a2, a2, 0, 1, 4, 5, 8, 9, 12, 13, 0, 1, 4, 5, 8,
-                                9, 12, 13);
-  ushort t_ptr[8];
-  wasm_v128_store(t_ptr, r);
-  for (int i = 0; i < 4; ++i) {
-    ptr[i] = t_ptr[i];
-  }
-}
-
-template <int n>
-inline void v_rshr_pack_store(uchar *ptr, const v_uint16x8 &a) {
-  v128_t delta = wasm_i16x8_splat((short)(1 << (n - 1)));
-  v128_t a1 = wasm_u16x8_shr(wasm_i16x8_add(a.val, delta), n);
-  v128_t maxval = wasm_i16x8_splat(255);
-  v128_t a2 = wasm_v128_bitselect(maxval, a1, wasm_u16x8_gt(a1, maxval));
-  v128_t r = wasm_i8x16_shuffle(a2, a2, 0, 2, 4, 6, 8, 10, 12, 14, 0, 2, 4, 6,
-                                8, 10, 12, 14);
-  uchar t_ptr[16];
-  wasm_v128_store(t_ptr, r);
-  for (int i = 0; i < 8; ++i) {
-    ptr[i] = t_ptr[i];
-  }
-}
-template <int n> inline void v_rshr_pack_store(schar *ptr, const v_int16x8 &a) {
-  v128_t delta = wasm_i16x8_splat(((short)1 << (n - 1)));
-  v128_t a1 = wasm_i16x8_shr(wasm_i16x8_add(a.val, delta), n);
-  v128_t maxval = wasm_i16x8_splat(127);
-  v128_t minval = wasm_i16x8_splat(-128);
-  v128_t a2 = wasm_v128_bitselect(maxval, a1, wasm_i16x8_gt(a1, maxval));
-  v128_t a3 = wasm_v128_bitselect(minval, a2, wasm_i16x8_lt(a1, minval));
-  v128_t r = wasm_i8x16_shuffle(a3, a3, 0, 2, 4, 6, 8, 10, 12, 14, 0, 2, 4, 6,
-                                8, 10, 12, 14);
-  schar t_ptr[16];
-  wasm_v128_store(t_ptr, r);
-  for (int i = 0; i < 8; ++i) {
-    ptr[i] = t_ptr[i];
-  }
-}
-template <int n>
-inline void v_rshr_pack_store(ushort *ptr, const v_uint32x4 &a) {
-  v128_t delta = wasm_i32x4_splat(((int)1 << (n - 1)));
-  v128_t a1 = wasm_u32x4_shr(wasm_i32x4_add(a.val, delta), n);
-  v128_t maxval = wasm_i32x4_splat(65535);
-  v128_t a2 = wasm_v128_bitselect(maxval, a1, wasm_u32x4_gt(a1, maxval));
-  v128_t r = wasm_i8x16_shuffle(a2, a2, 0, 1, 4, 5, 8, 9, 12, 13, 0, 1, 4, 5, 8,
-                                9, 12, 13);
-  ushort t_ptr[8];
-  wasm_v128_store(t_ptr, r);
-  for (int i = 0; i < 4; ++i) {
-    ptr[i] = t_ptr[i];
-  }
-}
-template <int n> inline void v_rshr_pack_store(short *ptr, const v_int32x4 &a) {
-  v128_t delta = wasm_i32x4_splat(((int)1 << (n - 1)));
-  v128_t a1 = wasm_i32x4_shr(wasm_i32x4_add(a.val, delta), n);
-  v128_t maxval = wasm_i32x4_splat(32767);
-  v128_t minval = wasm_i32x4_splat(-32768);
-  v128_t a2 = wasm_v128_bitselect(maxval, a1, wasm_i32x4_gt(a1, maxval));
-  v128_t a3 = wasm_v128_bitselect(minval, a2, wasm_i32x4_lt(a1, minval));
-  v128_t r = wasm_i8x16_shuffle(a3, a3, 0, 1, 4, 5, 8, 9, 12, 13, 0, 1, 4, 5, 8,
-                                9, 12, 13);
-  short t_ptr[8];
-  wasm_v128_store(t_ptr, r);
-  for (int i = 0; i < 4; ++i) {
-    ptr[i] = t_ptr[i];
-  }
-}
-template <int n>
-inline void v_rshr_pack_store(unsigned *ptr, const v_uint64x2 &a) {
-  v128_t delta = wasm_i64x2_splat(((int64)1 << (n - 1)));
-  v128_t a1 = wasm_u64x2_shr(wasm_i64x2_add(a.val, delta), n);
-  v128_t r = wasm_i8x16_shuffle(a1, a1, 0, 1, 2, 3, 8, 9, 10, 11, 0, 1, 2, 3, 8,
-                                9, 10, 11);
-  unsigned t_ptr[4];
-  wasm_v128_store(t_ptr, r);
-  for (int i = 0; i < 2; ++i) {
-    ptr[i] = t_ptr[i];
-  }
-}
-template <int n> inline void v_rshr_pack_store(int *ptr, const v_int64x2 &a) {
-  v128_t delta = wasm_i64x2_splat(((int64)1 << (n - 1)));
-  v128_t a1 = wasm_i64x2_shr(wasm_i64x2_add(a.val, delta), n);
-  v128_t r = wasm_i8x16_shuffle(a1, a1, 0, 1, 2, 3, 8, 9, 10, 11, 0, 1, 2, 3, 8,
-                                9, 10, 11);
-  int t_ptr[4];
-  wasm_v128_store(t_ptr, r);
-  for (int i = 0; i < 2; ++i) {
-    ptr[i] = t_ptr[i];
-  }
-}
-template <int n>
-inline void v_rshr_pack_u_store(uchar *ptr, const v_int16x8 &a) {
-  v128_t delta = wasm_i16x8_splat(((short)1 << (n - 1)));
-  v128_t a1 = wasm_i16x8_shr(wasm_i16x8_add(a.val, delta), n);
-  v128_t maxval = wasm_i16x8_splat(255);
-  v128_t minval = wasm_i16x8_splat(0);
-  v128_t a2 = wasm_v128_bitselect(maxval, a1, wasm_i16x8_gt(a1, maxval));
-  v128_t a3 = wasm_v128_bitselect(minval, a2, wasm_i16x8_lt(a1, minval));
-  v128_t r = wasm_i8x16_shuffle(a3, a3, 0, 2, 4, 6, 8, 10, 12, 14, 0, 2, 4, 6,
-                                8, 10, 12, 14);
-  uchar t_ptr[16];
-  wasm_v128_store(t_ptr, r);
-  for (int i = 0; i < 8; ++i) {
-    ptr[i] = t_ptr[i];
-  }
-}
-template <int n>
-inline void v_rshr_pack_u_store(ushort *ptr, const v_int32x4 &a) {
-  v128_t delta = wasm_i32x4_splat(((int)1 << (n - 1)));
-  v128_t a1 = wasm_i32x4_shr(wasm_i32x4_add(a.val, delta), n);
-  v128_t maxval = wasm_i32x4_splat(65535);
-  v128_t minval = wasm_i32x4_splat(0);
-  v128_t a2 = wasm_v128_bitselect(maxval, a1, wasm_i32x4_gt(a1, maxval));
-  v128_t a3 = wasm_v128_bitselect(minval, a2, wasm_i32x4_lt(a1, minval));
-  v128_t r = wasm_i8x16_shuffle(a3, a3, 0, 1, 4, 5, 8, 9, 12, 13, 0, 1, 4, 5, 8,
-                                9, 12, 13);
-  ushort t_ptr[8];
-  wasm_v128_store(t_ptr, r);
-  for (int i = 0; i < 4; ++i) {
-    ptr[i] = t_ptr[i];
-  }
-}
-
-inline v_uint8x16 v_pack_b(const v_uint16x8 &a, const v_uint16x8 &b) {
-  v128_t maxval = wasm_i16x8_splat(255);
-  v128_t a1 = wasm_v128_bitselect(maxval, a.val, wasm_u16x8_gt(a.val, maxval));
-  v128_t b1 = wasm_v128_bitselect(maxval, b.val, wasm_u16x8_gt(b.val, maxval));
-  return v_uint8x16(wasm_i8x16_shuffle(a1, b1, 0, 2, 4, 6, 8, 10, 12, 14, 16,
-                                       18, 20, 22, 24, 26, 28, 30));
-}
-
-inline v_uint8x16 v_pack_b(const v_uint32x4 &a, const v_uint32x4 &b,
-                           const v_uint32x4 &c, const v_uint32x4 &d) {
-  v128_t maxval = wasm_i32x4_splat(255);
-  v128_t a1 = wasm_v128_bitselect(maxval, a.val, wasm_u32x4_gt(a.val, maxval));
-  v128_t b1 = wasm_v128_bitselect(maxval, b.val, wasm_u32x4_gt(b.val, maxval));
-  v128_t c1 = wasm_v128_bitselect(maxval, c.val, wasm_u32x4_gt(c.val, maxval));
-  v128_t d1 = wasm_v128_bitselect(maxval, d.val, wasm_u32x4_gt(d.val, maxval));
-  v128_t ab = wasm_i8x16_shuffle(a1, b1, 0, 4, 8, 12, 16, 20, 24, 28, 0, 4, 8,
-                                 12, 16, 20, 24, 28);
-  v128_t cd = wasm_i8x16_shuffle(c1, d1, 0, 4, 8, 12, 16, 20, 24, 28, 0, 4, 8,
-                                 12, 16, 20, 24, 28);
-  return v_uint8x16(wasm_i8x16_shuffle(ab, cd, 0, 1, 2, 3, 4, 5, 6, 7, 16, 17,
-                                       18, 19, 20, 21, 22, 23));
-}
-
-inline v_uint8x16 v_pack_b(const v_uint64x2 &a, const v_uint64x2 &b,
-                           const v_uint64x2 &c, const v_uint64x2 &d,
-                           const v_uint64x2 &e, const v_uint64x2 &f,
-                           const v_uint64x2 &g, const v_uint64x2 &h) {
-  v128_t maxval = wasm_i32x4_splat(255);
-  v128_t a1 =
-      wasm_v128_bitselect(maxval, a.val, ((__u64x2)(a.val) > (__u64x2)maxval));
-  v128_t b1 =
-      wasm_v128_bitselect(maxval, b.val, ((__u64x2)(b.val) > (__u64x2)maxval));
-  v128_t c1 =
-      wasm_v128_bitselect(maxval, c.val, ((__u64x2)(c.val) > (__u64x2)maxval));
-  v128_t d1 =
-      wasm_v128_bitselect(maxval, d.val, ((__u64x2)(d.val) > (__u64x2)maxval));
-  v128_t e1 =
-      wasm_v128_bitselect(maxval, e.val, ((__u64x2)(e.val) > (__u64x2)maxval));
-  v128_t f1 =
-      wasm_v128_bitselect(maxval, f.val, ((__u64x2)(f.val) > (__u64x2)maxval));
-  v128_t g1 =
-      wasm_v128_bitselect(maxval, g.val, ((__u64x2)(g.val) > (__u64x2)maxval));
-  v128_t h1 =
-      wasm_v128_bitselect(maxval, h.val, ((__u64x2)(h.val) > (__u64x2)maxval));
-  v128_t ab = wasm_i8x16_shuffle(a1, b1, 0, 8, 16, 24, 0, 8, 16, 24, 0, 8, 16,
-                                 24, 0, 8, 16, 24);
-  v128_t cd = wasm_i8x16_shuffle(c1, d1, 0, 8, 16, 24, 0, 8, 16, 24, 0, 8, 16,
-                                 24, 0, 8, 16, 24);
-  v128_t ef = wasm_i8x16_shuffle(e1, f1, 0, 8, 16, 24, 0, 8, 16, 24, 0, 8, 16,
-                                 24, 0, 8, 16, 24);
-  v128_t gh = wasm_i8x16_shuffle(g1, h1, 0, 8, 16, 24, 0, 8, 16, 24, 0, 8, 16,
-                                 24, 0, 8, 16, 24);
-  v128_t abcd = wasm_i8x16_shuffle(ab, cd, 0, 1, 2, 3, 16, 17, 18, 19, 0, 1, 2,
-                                   3, 16, 17, 18, 19);
-  v128_t efgh = wasm_i8x16_shuffle(ef, gh, 0, 1, 2, 3, 16, 17, 18, 19, 0, 1, 2,
-                                   3, 16, 17, 18, 19);
-  return v_uint8x16(wasm_i8x16_shuffle(abcd, efgh, 0, 1, 2, 3, 4, 5, 6, 7, 16,
-                                       17, 18, 19, 20, 21, 22, 23));
-}
-
-inline v_float32x4 v_matmul(const v_float32x4 &v, const v_float32x4 &m0,
-                            const v_float32x4 &m1, const v_float32x4 &m2,
-                            const v_float32x4 &m3) {
-  v128_t v0 = wasm_f32x4_splat(wasm_f32x4_extract_lane(v.val, 0));
-  v128_t v1 = wasm_f32x4_splat(wasm_f32x4_extract_lane(v.val, 1));
-  v128_t v2 = wasm_f32x4_splat(wasm_f32x4_extract_lane(v.val, 2));
-  v128_t v3 = wasm_f32x4_splat(wasm_f32x4_extract_lane(v.val, 3));
-  v0 = wasm_f32x4_mul(v0, m0.val);
-  v1 = wasm_f32x4_mul(v1, m1.val);
-  v2 = wasm_f32x4_mul(v2, m2.val);
-  v3 = wasm_f32x4_mul(v3, m3.val);
-
-  return v_float32x4(
-      wasm_f32x4_add(wasm_f32x4_add(v0, v1), wasm_f32x4_add(v2, v3)));
-}
-
-inline v_float32x4 v_matmuladd(const v_float32x4 &v, const v_float32x4 &m0,
-                               const v_float32x4 &m1, const v_float32x4 &m2,
-                               const v_float32x4 &a) {
-  v128_t v0 = wasm_f32x4_splat(wasm_f32x4_extract_lane(v.val, 0));
-  v128_t v1 = wasm_f32x4_splat(wasm_f32x4_extract_lane(v.val, 1));
-  v128_t v2 = wasm_f32x4_splat(wasm_f32x4_extract_lane(v.val, 2));
-  v0 = wasm_f32x4_mul(v0, m0.val);
-  v1 = wasm_f32x4_mul(v1, m1.val);
-  v2 = wasm_f32x4_mul(v2, m2.val);
-
-  return v_float32x4(
-      wasm_f32x4_add(wasm_f32x4_add(v0, v1), wasm_f32x4_add(v2, a.val)));
-}
-
-#define OPENCV_HAL_IMPL_WASM_BIN_OP(bin_op, _Tpvec, intrin)                    \
-  inline _Tpvec bin_op(const _Tpvec &a, const _Tpvec &b) {                     \
-    return _Tpvec(intrin(a.val, b.val));                                       \
-  }
-
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_add, v_uint8x16, wasm_u8x16_add_saturate)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_sub, v_uint8x16, wasm_u8x16_sub_saturate)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_add, v_int8x16, wasm_i8x16_add_saturate)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_sub, v_int8x16, wasm_i8x16_sub_saturate)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_add, v_uint16x8, wasm_u16x8_add_saturate)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_sub, v_uint16x8, wasm_u16x8_sub_saturate)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_add, v_int16x8, wasm_i16x8_add_saturate)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_sub, v_int16x8, wasm_i16x8_sub_saturate)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_add, v_uint32x4, wasm_i32x4_add)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_sub, v_uint32x4, wasm_i32x4_sub)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_mul, v_uint32x4, wasm_i32x4_mul)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_add, v_int32x4, wasm_i32x4_add)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_sub, v_int32x4, wasm_i32x4_sub)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_mul, v_int32x4, wasm_i32x4_mul)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_add, v_float32x4, wasm_f32x4_add)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_sub, v_float32x4, wasm_f32x4_sub)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_mul, v_float32x4, wasm_f32x4_mul)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_div, v_float32x4, wasm_f32x4_div)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_add, v_uint64x2, wasm_i64x2_add)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_sub, v_uint64x2, wasm_i64x2_sub)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_add, v_int64x2, wasm_i64x2_add)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_sub, v_int64x2, wasm_i64x2_sub)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_add, v_float64x2, wasm_f64x2_add)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_sub, v_float64x2, wasm_f64x2_sub)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_mul, v_float64x2, wasm_f64x2_mul)
-OPENCV_HAL_IMPL_WASM_BIN_OP(v_div, v_float64x2, wasm_f64x2_div)
-
-// saturating multiply 8-bit, 16-bit
-#define OPENCV_HAL_IMPL_WASM_MUL_SAT(_Tpvec, _Tpwvec)                          \
-  inline _Tpvec v_mul(const _Tpvec &a, const _Tpvec &b) {                      \
-    _Tpwvec c, d;                                                              \
-    v_mul_expand(a, b, c, d);                                                  \
-    return v_pack(c, d);                                                       \
-  }
-
-OPENCV_HAL_IMPL_WASM_MUL_SAT(v_uint8x16, v_uint16x8)
-OPENCV_HAL_IMPL_WASM_MUL_SAT(v_int8x16, v_int16x8)
-OPENCV_HAL_IMPL_WASM_MUL_SAT(v_uint16x8, v_uint32x4)
-OPENCV_HAL_IMPL_WASM_MUL_SAT(v_int16x8, v_int32x4)
-
-//  Multiply and expand
-inline void v_mul_expand(const v_uint8x16 &a, const v_uint8x16 &b,
-                         v_uint16x8 &c, v_uint16x8 &d) {
-  v_uint16x8 a0, a1, b0, b1;
-  v_expand(a, a0, a1);
-  v_expand(b, b0, b1);
-  c = v_mul_wrap(a0, b0);
-  d = v_mul_wrap(a1, b1);
-}
-
-inline void v_mul_expand(const v_int8x16 &a, const v_int8x16 &b, v_int16x8 &c,
-                         v_int16x8 &d) {
-  v_int16x8 a0, a1, b0, b1;
-  v_expand(a, a0, a1);
-  v_expand(b, b0, b1);
-  c = v_mul_wrap(a0, b0);
-  d = v_mul_wrap(a1, b1);
-}
-
-inline void v_mul_expand(const v_int16x8 &a, const v_int16x8 &b, v_int32x4 &c,
-                         v_int32x4 &d) {
-  v_int32x4 a0, a1, b0, b1;
-  v_expand(a, a0, a1);
-  v_expand(b, b0, b1);
-  c.val = wasm_i32x4_mul(a0.val, b0.val);
-  d.val = wasm_i32x4_mul(a1.val, b1.val);
-}
-
-inline void v_mul_expand(const v_uint16x8 &a, const v_uint16x8 &b,
-                         v_uint32x4 &c, v_uint32x4 &d) {
-  v_uint32x4 a0, a1, b0, b1;
-  v_expand(a, a0, a1);
-  v_expand(b, b0, b1);
-  c.val = wasm_i32x4_mul(a0.val, b0.val);
-  d.val = wasm_i32x4_mul(a1.val, b1.val);
-}
-
-inline void v_mul_expand(const v_uint32x4 &a, const v_uint32x4 &b,
-                         v_uint64x2 &c, v_uint64x2 &d) {
-  v_uint64x2 a0, a1, b0, b1;
-  v_expand(a, a0, a1);
-  v_expand(b, b0, b1);
-  c.val = ((__u64x2)(a0.val) * (__u64x2)(b0.val));
-  d.val = ((__u64x2)(a1.val) * (__u64x2)(b1.val));
-}
-
-inline v_int16x8 v_mul_hi(const v_int16x8 &a, const v_int16x8 &b) {
-  v_int32x4 a0, a1, b0, b1;
-  v_expand(a, a0, a1);
-  v_expand(b, b0, b1);
-  v128_t c = wasm_i32x4_mul(a0.val, b0.val);
-  v128_t d = wasm_i32x4_mul(a1.val, b1.val);
-  return v_int16x8(wasm_i8x16_shuffle(c, d, 2, 3, 6, 7, 10, 11, 14, 15, 18, 19,
-                                      22, 23, 26, 27, 30, 31));
-}
-inline v_uint16x8 v_mul_hi(const v_uint16x8 &a, const v_uint16x8 &b) {
-  v_uint32x4 a0, a1, b0, b1;
-  v_expand(a, a0, a1);
-  v_expand(b, b0, b1);
-  v128_t c = wasm_i32x4_mul(a0.val, b0.val);
-  v128_t d = wasm_i32x4_mul(a1.val, b1.val);
-  return v_uint16x8(wasm_i8x16_shuffle(c, d, 2, 3, 6, 7, 10, 11, 14, 15, 18, 19,
-                                       22, 23, 26, 27, 30, 31));
-}
-
-//////// Dot Product ////////
-
-inline v_int32x4 v_dotprod(const v_int16x8 &a, const v_int16x8 &b) {
-  v128_t a0 = wasm_i32x4_shr(wasm_i32x4_shl(a.val, 16), 16);
-  v128_t a1 = wasm_i32x4_shr(a.val, 16);
-  v128_t b0 = wasm_i32x4_shr(wasm_i32x4_shl(b.val, 16), 16);
-  v128_t b1 = wasm_i32x4_shr(b.val, 16);
-  v128_t c = wasm_i32x4_mul(a0, b0);
-  v128_t d = wasm_i32x4_mul(a1, b1);
-  return v_int32x4(wasm_i32x4_add(c, d));
-}
-
-inline v_int32x4 v_dotprod(const v_int16x8 &a, const v_int16x8 &b,
-                           const v_int32x4 &c) {
-  return v_add(v_dotprod(a, b), c);
-}
-
-inline v_int64x2 v_dotprod(const v_int32x4 &a, const v_int32x4 &b) {
-  v128_t a0 = wasm_i64x2_shr(wasm_i64x2_shl(a.val, 32), 32);
-  v128_t a1 = wasm_i64x2_shr(a.val, 32);
-  v128_t b0 = wasm_i64x2_shr(wasm_i64x2_shl(b.val, 32), 32);
-  v128_t b1 = wasm_i64x2_shr(b.val, 32);
-  v128_t c = (v128_t)((__i64x2)a0 * (__i64x2)b0);
-  v128_t d = (v128_t)((__i64x2)a1 * (__i64x2)b1);
-  return v_int64x2(wasm_i64x2_add(c, d));
-}
-inline v_int64x2 v_dotprod(const v_int32x4 &a, const v_int32x4 &b,
-                           const v_int64x2 &c) {
-  return v_add(v_dotprod(a, b), c);
-}
-
-// 8 >> 32
-inline v_uint32x4 v_dotprod_expand(const v_uint8x16 &a, const v_uint8x16 &b) {
-  v128_t a0 = wasm_u16x8_shr(wasm_i16x8_shl(a.val, 8), 8);
-  v128_t a1 = wasm_u16x8_shr(a.val, 8);
-  v128_t b0 = wasm_u16x8_shr(wasm_i16x8_shl(b.val, 8), 8);
-  v128_t b1 = wasm_u16x8_shr(b.val, 8);
-  return v_uint32x4((v_add(v_dotprod(v_int16x8(a0), v_int16x8(b0)),
-                           v_dotprod(v_int16x8(a1), v_int16x8(b1))))
-                        .val);
-}
-inline v_uint32x4 v_dotprod_expand(const v_uint8x16 &a, const v_uint8x16 &b,
-                                   const v_uint32x4 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-inline v_int32x4 v_dotprod_expand(const v_int8x16 &a, const v_int8x16 &b) {
-  v128_t a0 = wasm_i16x8_shr(wasm_i16x8_shl(a.val, 8), 8);
-  v128_t a1 = wasm_i16x8_shr(a.val, 8);
-  v128_t b0 = wasm_i16x8_shr(wasm_i16x8_shl(b.val, 8), 8);
-  v128_t b1 = wasm_i16x8_shr(b.val, 8);
-  return v_int32x4(v_add(v_dotprod(v_int16x8(a0), v_int16x8(b0)),
-                         v_dotprod(v_int16x8(a1), v_int16x8(b1))));
-}
-inline v_int32x4 v_dotprod_expand(const v_int8x16 &a, const v_int8x16 &b,
-                                  const v_int32x4 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-// 16 >> 64
-inline v_uint64x2 v_dotprod_expand(const v_uint16x8 &a, const v_uint16x8 &b) {
-  v128_t a0 = wasm_u32x4_shr(wasm_i32x4_shl(a.val, 16), 16);
-  v128_t a1 = wasm_u32x4_shr(a.val, 16);
-  v128_t b0 = wasm_u32x4_shr(wasm_i32x4_shl(b.val, 16), 16);
-  v128_t b1 = wasm_u32x4_shr(b.val, 16);
-  return v_uint64x2((v_add(v_dotprod(v_int32x4(a0), v_int32x4(b0)),
-                           v_dotprod(v_int32x4(a1), v_int32x4(b1)))
-                         .val));
-}
-inline v_uint64x2 v_dotprod_expand(const v_uint16x8 &a, const v_uint16x8 &b,
-                                   const v_uint64x2 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-inline v_int64x2 v_dotprod_expand(const v_int16x8 &a, const v_int16x8 &b) {
-  v128_t a0 = wasm_i32x4_shr(wasm_i32x4_shl(a.val, 16), 16);
-  v128_t a1 = wasm_i32x4_shr(a.val, 16);
-  v128_t b0 = wasm_i32x4_shr(wasm_i32x4_shl(b.val, 16), 16);
-  v128_t b1 = wasm_i32x4_shr(b.val, 16);
-  return v_int64x2((v_add(v_dotprod(v_int32x4(a0), v_int32x4(b0)),
-                          v_dotprod(v_int32x4(a1), v_int32x4(b1)))));
-}
-
-inline v_int64x2 v_dotprod_expand(const v_int16x8 &a, const v_int16x8 &b,
-                                  const v_int64x2 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-// 32 >> 64f
-inline v_float64x2 v_dotprod_expand(const v_int32x4 &a, const v_int32x4 &b) {
-  return v_cvt_f64(v_dotprod(a, b));
-}
-inline v_float64x2 v_dotprod_expand(const v_int32x4 &a, const v_int32x4 &b,
-                                    const v_float64x2 &c) {
-  return v_add(v_dotprod_expand(a, b), c);
-}
-
-//////// Fast Dot Product ////////
-
-// 16 >> 32
-inline v_int32x4 v_dotprod_fast(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_dotprod(a, b);
-}
-inline v_int32x4 v_dotprod_fast(const v_int16x8 &a, const v_int16x8 &b,
-                                const v_int32x4 &c) {
-  return v_dotprod(a, b, c);
-}
-
-// 32 >> 64
-inline v_int64x2 v_dotprod_fast(const v_int32x4 &a, const v_int32x4 &b) {
-  return v_dotprod(a, b);
-}
-inline v_int64x2 v_dotprod_fast(const v_int32x4 &a, const v_int32x4 &b,
-                                const v_int64x2 &c) {
-  return v_dotprod(a, b, c);
-}
-
-// 8 >> 32
-inline v_uint32x4 v_dotprod_expand_fast(const v_uint8x16 &a,
-                                        const v_uint8x16 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_uint32x4 v_dotprod_expand_fast(const v_uint8x16 &a,
-                                        const v_uint8x16 &b,
-                                        const v_uint32x4 &c) {
-  return v_dotprod_expand(a, b, c);
-}
-inline v_int32x4 v_dotprod_expand_fast(const v_int8x16 &a, const v_int8x16 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_int32x4 v_dotprod_expand_fast(const v_int8x16 &a, const v_int8x16 &b,
-                                       const v_int32x4 &c) {
-  return v_dotprod_expand(a, b, c);
-}
-
-// 16 >> 64
-inline v_uint64x2 v_dotprod_expand_fast(const v_uint16x8 &a,
-                                        const v_uint16x8 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_uint64x2 v_dotprod_expand_fast(const v_uint16x8 &a,
-                                        const v_uint16x8 &b,
-                                        const v_uint64x2 &c) {
-  return v_dotprod_expand(a, b, c);
-}
-inline v_int64x2 v_dotprod_expand_fast(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_int64x2 v_dotprod_expand_fast(const v_int16x8 &a, const v_int16x8 &b,
-                                       const v_int64x2 &c) {
-  return v_dotprod_expand(a, b, c);
-}
-
-// 32 >> 64f
-inline v_float64x2 v_dotprod_expand_fast(const v_int32x4 &a,
-                                         const v_int32x4 &b) {
-  return v_dotprod_expand(a, b);
-}
-inline v_float64x2 v_dotprod_expand_fast(const v_int32x4 &a, const v_int32x4 &b,
-                                         const v_float64x2 &c) {
-  return v_dotprod_expand(a, b, c);
-}
-
-#define OPENCV_HAL_IMPL_WASM_LOGIC_OP(_Tpvec)                                  \
-  OPENCV_HAL_IMPL_WASM_BIN_OP(v_and, _Tpvec, wasm_v128_and)                    \
-  OPENCV_HAL_IMPL_WASM_BIN_OP(v_or, _Tpvec, wasm_v128_or)                      \
-  OPENCV_HAL_IMPL_WASM_BIN_OP(v_xor, _Tpvec, wasm_v128_xor)                    \
-  inline _Tpvec v_not(const _Tpvec &a) { return _Tpvec(wasm_v128_not(a.val)); }
-
-OPENCV_HAL_IMPL_WASM_LOGIC_OP(v_uint8x16)
-OPENCV_HAL_IMPL_WASM_LOGIC_OP(v_int8x16)
-OPENCV_HAL_IMPL_WASM_LOGIC_OP(v_uint16x8)
-OPENCV_HAL_IMPL_WASM_LOGIC_OP(v_int16x8)
-OPENCV_HAL_IMPL_WASM_LOGIC_OP(v_uint32x4)
-OPENCV_HAL_IMPL_WASM_LOGIC_OP(v_int32x4)
-OPENCV_HAL_IMPL_WASM_LOGIC_OP(v_uint64x2)
-OPENCV_HAL_IMPL_WASM_LOGIC_OP(v_int64x2)
-OPENCV_HAL_IMPL_WASM_LOGIC_OP(v_float32x4)
-OPENCV_HAL_IMPL_WASM_LOGIC_OP(v_float64x2)
-
-inline v_float32x4 v_sqrt(const v_float32x4 &x) {
-  return v_float32x4(wasm_f32x4_sqrt(x.val));
-}
-
-inline v_float32x4 v_invsqrt(const v_float32x4 &x) {
-  const v128_t _1_0 = wasm_f32x4_splat(1.0);
-  return v_float32x4(wasm_f32x4_div(_1_0, wasm_f32x4_sqrt(x.val)));
-}
-
-inline v_float64x2 v_sqrt(const v_float64x2 &x) {
-  return v_float64x2(wasm_f64x2_sqrt(x.val));
-}
-
-inline v_float64x2 v_invsqrt(const v_float64x2 &x) {
-  const v128_t _1_0 = wasm_f64x2_splat(1.0);
-  return v_float64x2(wasm_f64x2_div(_1_0, wasm_f64x2_sqrt(x.val)));
-}
-
-#define OPENCV_HAL_IMPL_WASM_ABS_INT_FUNC(_Tpuvec, _Tpsvec, suffix, zsuffix,   \
-                                          shiftWidth)                          \
-  inline _Tpuvec v_abs(const _Tpsvec &x) {                                     \
-    v128_t s = wasm_##suffix##_shr(x.val, shiftWidth);                         \
-    v128_t f = wasm_##zsuffix##_shr(x.val, shiftWidth);                        \
-    return _Tpuvec(wasm_##zsuffix##_add(wasm_v128_xor(x.val, f), s));          \
-  }
-
-OPENCV_HAL_IMPL_WASM_ABS_INT_FUNC(v_uint8x16, v_int8x16, u8x16, i8x16, 7)
-OPENCV_HAL_IMPL_WASM_ABS_INT_FUNC(v_uint16x8, v_int16x8, u16x8, i16x8, 15)
-OPENCV_HAL_IMPL_WASM_ABS_INT_FUNC(v_uint32x4, v_int32x4, u32x4, i32x4, 31)
-
-inline v_float32x4 v_abs(const v_float32x4 &x) {
-  return v_float32x4(wasm_f32x4_abs(x.val));
-}
-inline v_float64x2 v_abs(const v_float64x2 &x) {
-  return v_float64x2(wasm_f64x2_abs(x.val));
-}
-
-// TODO: exp, log, sin, cos
-
-#define OPENCV_HAL_IMPL_WASM_BIN_FUNC(_Tpvec, func, intrin)                    \
-  inline _Tpvec func(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(intrin(a.val, b.val));                                       \
-  }
-
-OPENCV_HAL_IMPL_WASM_BIN_FUNC(v_float32x4, v_min, wasm_f32x4_min)
-OPENCV_HAL_IMPL_WASM_BIN_FUNC(v_float32x4, v_max, wasm_f32x4_max)
-OPENCV_HAL_IMPL_WASM_BIN_FUNC(v_float64x2, v_min, wasm_f64x2_min)
-OPENCV_HAL_IMPL_WASM_BIN_FUNC(v_float64x2, v_max, wasm_f64x2_max)
-
-#define OPENCV_HAL_IMPL_WASM_MINMAX_S_INIT_FUNC(_Tpvec, suffix)                \
-  inline _Tpvec v_min(const _Tpvec &a, const _Tpvec &b) {                      \
-    return _Tpvec(                                                             \
-        wasm_v128_bitselect(b.val, a.val, wasm_##suffix##_gt(a.val, b.val)));  \
-  }                                                                            \
-  inline _Tpvec v_max(const _Tpvec &a, const _Tpvec &b) {                      \
-    return _Tpvec(                                                             \
-        wasm_v128_bitselect(a.val, b.val, wasm_##suffix##_gt(a.val, b.val)));  \
-  }
-
-OPENCV_HAL_IMPL_WASM_MINMAX_S_INIT_FUNC(v_int8x16, i8x16)
-OPENCV_HAL_IMPL_WASM_MINMAX_S_INIT_FUNC(v_int16x8, i16x8)
-OPENCV_HAL_IMPL_WASM_MINMAX_S_INIT_FUNC(v_int32x4, i32x4)
-
-#define OPENCV_HAL_IMPL_WASM_MINMAX_U_INIT_FUNC(_Tpvec, suffix, deltaNum)      \
-  inline _Tpvec v_min(const _Tpvec &a, const _Tpvec &b) {                      \
-    v128_t delta = wasm_##suffix##_splat(deltaNum);                            \
-    v128_t mask = wasm_##suffix##_gt(wasm_v128_xor(a.val, delta),              \
-                                     wasm_v128_xor(b.val, delta));             \
-    return _Tpvec(wasm_v128_bitselect(b.val, a.val, mask));                    \
-  }                                                                            \
-  inline _Tpvec v_max(const _Tpvec &a, const _Tpvec &b) {                      \
-    v128_t delta = wasm_##suffix##_splat(deltaNum);                            \
-    v128_t mask = wasm_##suffix##_gt(wasm_v128_xor(a.val, delta),              \
-                                     wasm_v128_xor(b.val, delta));             \
-    return _Tpvec(wasm_v128_bitselect(a.val, b.val, mask));                    \
-  }
-
-OPENCV_HAL_IMPL_WASM_MINMAX_U_INIT_FUNC(v_uint8x16, i8x16, (schar)0x80)
-OPENCV_HAL_IMPL_WASM_MINMAX_U_INIT_FUNC(v_uint16x8, i16x8, (short)0x8000)
-OPENCV_HAL_IMPL_WASM_MINMAX_U_INIT_FUNC(v_uint32x4, i32x4, (int)0x80000000)
-
-#define OPENCV_HAL_IMPL_WASM_INIT_CMP_OP(_Tpvec, suffix, esuffix)              \
-  inline _Tpvec v_eq(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(wasm_##esuffix##_eq(a.val, b.val));                          \
-  }                                                                            \
-  inline _Tpvec v_ne(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(wasm_##esuffix##_ne(a.val, b.val));                          \
-  }                                                                            \
-  inline _Tpvec v_lt(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(wasm_##suffix##_lt(a.val, b.val));                           \
-  }                                                                            \
-  inline _Tpvec v_gt(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(wasm_##suffix##_gt(a.val, b.val));                           \
-  }                                                                            \
-  inline _Tpvec v_le(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(wasm_##suffix##_le(a.val, b.val));                           \
-  }                                                                            \
-  inline _Tpvec v_ge(const _Tpvec &a, const _Tpvec &b) {                       \
-    return _Tpvec(wasm_##suffix##_ge(a.val, b.val));                           \
-  }
-
-OPENCV_HAL_IMPL_WASM_INIT_CMP_OP(v_uint8x16, u8x16, i8x16)
-OPENCV_HAL_IMPL_WASM_INIT_CMP_OP(v_int8x16, i8x16, i8x16)
-OPENCV_HAL_IMPL_WASM_INIT_CMP_OP(v_uint16x8, u16x8, i16x8)
-OPENCV_HAL_IMPL_WASM_INIT_CMP_OP(v_int16x8, i16x8, i16x8)
-OPENCV_HAL_IMPL_WASM_INIT_CMP_OP(v_uint32x4, u32x4, i32x4)
-OPENCV_HAL_IMPL_WASM_INIT_CMP_OP(v_int32x4, i32x4, i32x4)
-OPENCV_HAL_IMPL_WASM_INIT_CMP_OP(v_float32x4, f32x4, f32x4)
-OPENCV_HAL_IMPL_WASM_INIT_CMP_OP(v_float64x2, f64x2, f64x2)
-
-#define OPENCV_HAL_IMPL_WASM_64BIT_CMP_OP(_Tpvec, cast)                        \
-  inline _Tpvec v_eq(const _Tpvec &a, const _Tpvec &b) {                       \
-    return cast(v_eq(v_reinterpret_as_f64(a), v_reinterpret_as_f64(b)));       \
-  }                                                                            \
-  inline _Tpvec v_ne(const _Tpvec &a, const _Tpvec &b) {                       \
-    return cast(v_ne(v_reinterpret_as_f64(a), v_reinterpret_as_f64(b)));       \
-  }
-
-OPENCV_HAL_IMPL_WASM_64BIT_CMP_OP(v_uint64x2, v_reinterpret_as_u64)
-OPENCV_HAL_IMPL_WASM_64BIT_CMP_OP(v_int64x2, v_reinterpret_as_s64)
-
-inline v_float32x4 v_not_nan(const v_float32x4 &a) {
-  v128_t z = wasm_i32x4_splat(0x7fffffff);
-  v128_t t = wasm_i32x4_splat(0x7f800000);
-  return v_float32x4(wasm_u32x4_lt(wasm_v128_and(a.val, z), t));
-}
-inline v_float64x2 v_not_nan(const v_float64x2 &a) {
-  v128_t z = wasm_i64x2_splat(0x7fffffffffffffff);
-  v128_t t = wasm_i64x2_splat(0x7ff0000000000000);
-  return v_float64x2((__u64x2)(wasm_v128_and(a.val, z)) < (__u64x2)t);
-}
-
-OPENCV_HAL_IMPL_WASM_BIN_FUNC(v_uint8x16, v_add_wrap, wasm_i8x16_add)
-OPENCV_HAL_IMPL_WASM_BIN_FUNC(v_int8x16, v_add_wrap, wasm_i8x16_add)
-OPENCV_HAL_IMPL_WASM_BIN_FUNC(v_uint16x8, v_add_wrap, wasm_i16x8_add)
-OPENCV_HAL_IMPL_WASM_BIN_FUNC(v_int16x8, v_add_wrap, wasm_i16x8_add)
-OPENCV_HAL_IMPL_WASM_BIN_FUNC(v_uint8x16, v_sub_wrap, wasm_i8x16_sub)
-OPENCV_HAL_IMPL_WASM_BIN_FUNC(v_int8x16, v_sub_wrap, wasm_i8x16_sub)
-OPENCV_HAL_IMPL_WASM_BIN_FUNC(v_uint16x8, v_sub_wrap, wasm_i16x8_sub)
-OPENCV_HAL_IMPL_WASM_BIN_FUNC(v_int16x8, v_sub_wrap, wasm_i16x8_sub)
-#if (__EMSCRIPTEN_major__ * 1000000 + __EMSCRIPTEN_minor__ * 1000 +            \
-     __EMSCRIPTEN_tiny__) >= (1039012)
-// details: https://github.com/opencv/opencv/issues/18097 (
-// https://github.com/emscripten-core/emscripten/issues/12018 ) 1.39.12:
-// https://github.com/emscripten-core/emscripten/commit/cd801d0f110facfd694212a3c8b2ed2ffcd630e2
-inline v_uint8x16 v_mul_wrap(const v_uint8x16 &a, const v_uint8x16 &b) {
-  uchar a_[16], b_[16];
-  wasm_v128_store(a_, a.val);
-  wasm_v128_store(b_, b.val);
-  for (int i = 0; i < 16; i++)
-    a_[i] = (uchar)(a_[i] * b_[i]);
-  return v_uint8x16(wasm_v128_load(a_));
-}
-inline v_int8x16 v_mul_wrap(const v_int8x16 &a, const v_int8x16 &b) {
-  schar a_[16], b_[16];
-  wasm_v128_store(a_, a.val);
-  wasm_v128_store(b_, b.val);
-  for (int i = 0; i < 16; i++)
-    a_[i] = (schar)(a_[i] * b_[i]);
-  return v_int8x16(wasm_v128_load(a_));
-}
-#else
-OPENCV_HAL_IMPL_WASM_BIN_FUNC(v_uint8x16, v_mul_wrap, wasm_i8x16_mul)
-OPENCV_HAL_IMPL_WASM_BIN_FUNC(v_int8x16, v_mul_wrap, wasm_i8x16_mul)
-#endif
-OPENCV_HAL_IMPL_WASM_BIN_FUNC(v_uint16x8, v_mul_wrap, wasm_i16x8_mul)
-OPENCV_HAL_IMPL_WASM_BIN_FUNC(v_int16x8, v_mul_wrap, wasm_i16x8_mul)
-
-/** Absolute difference **/
-
-inline v_uint8x16 v_absdiff(const v_uint8x16 &a, const v_uint8x16 &b) {
-  return v_add_wrap(v_sub(a, b), v_sub(b, a));
-}
-inline v_uint16x8 v_absdiff(const v_uint16x8 &a, const v_uint16x8 &b) {
-  return v_add_wrap(v_sub(a, b), v_sub(b, a));
-}
-inline v_uint32x4 v_absdiff(const v_uint32x4 &a, const v_uint32x4 &b) {
-  return v_sub(v_max(a, b), v_min(a, b));
-}
-
-inline v_uint8x16 v_absdiff(const v_int8x16 &a, const v_int8x16 &b) {
-  v_int8x16 d = v_sub_wrap(a, b);
-  v_int8x16 m = v_lt(a, b);
-  return v_reinterpret_as_u8(v_sub_wrap(v_xor(d, m), m));
-}
-inline v_uint16x8 v_absdiff(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_reinterpret_as_u16(v_sub_wrap(v_max(a, b), v_min(a, b)));
-}
-inline v_uint32x4 v_absdiff(const v_int32x4 &a, const v_int32x4 &b) {
-  v_int32x4 d = v_sub(a, b);
-  v_int32x4 m = v_lt(a, b);
-  return v_reinterpret_as_u32(v_sub(v_xor(d, m), m));
-}
-
-/** Saturating absolute difference **/
-inline v_int8x16 v_absdiffs(const v_int8x16 &a, const v_int8x16 &b) {
-  v_int8x16 d = v_sub(a, b);
-  v_int8x16 m = v_lt(a, b);
-  return v_sub(v_xor(d, m), m);
-}
-inline v_int16x8 v_absdiffs(const v_int16x8 &a, const v_int16x8 &b) {
-  return v_sub(v_max(a, b), v_min(a, b));
-}
-
-inline v_int32x4 v_fma(const v_int32x4 &a, const v_int32x4 &b,
-                       const v_int32x4 &c) {
-  return v_add(v_mul(a, b), c);
-}
-
-inline v_int32x4 v_muladd(const v_int32x4 &a, const v_int32x4 &b,
-                          const v_int32x4 &c) {
-  return v_fma(a, b, c);
-}
-
-inline v_float32x4 v_fma(const v_float32x4 &a, const v_float32x4 &b,
-                         const v_float32x4 &c) {
-  return v_add(v_mul(a, b), c);
-}
-
-inline v_float64x2 v_fma(const v_float64x2 &a, const v_float64x2 &b,
-                         const v_float64x2 &c) {
-  return v_add(v_mul(a, b), c);
-}
-
-inline v_float32x4 v_absdiff(const v_float32x4 &a, const v_float32x4 &b) {
-  v128_t absmask_vec = wasm_i32x4_splat(0x7fffffff);
-  return v_float32x4(wasm_v128_and(wasm_f32x4_sub(a.val, b.val), absmask_vec));
-}
-inline v_float64x2 v_absdiff(const v_float64x2 &a, const v_float64x2 &b) {
-  v128_t absmask_vec = wasm_u64x2_shr(wasm_i32x4_splat(-1), 1);
-  return v_float64x2(wasm_v128_and(wasm_f64x2_sub(a.val, b.val), absmask_vec));
-}
-
-#define OPENCV_HAL_IMPL_WASM_MISC_FLT_OP(_Tpvec, suffix)                       \
-  inline _Tpvec v_magnitude(const _Tpvec &a, const _Tpvec &b) {                \
-    v128_t a_Square = wasm_##suffix##_mul(a.val, a.val);                       \
-    v128_t b_Square = wasm_##suffix##_mul(b.val, b.val);                       \
-    return _Tpvec(                                                             \
-        wasm_##suffix##_sqrt(wasm_##suffix##_add(a_Square, b_Square)));        \
-  }                                                                            \
-  inline _Tpvec v_sqr_magnitude(const _Tpvec &a, const _Tpvec &b) {            \
-    v128_t a_Square = wasm_##suffix##_mul(a.val, a.val);                       \
-    v128_t b_Square = wasm_##suffix##_mul(b.val, b.val);                       \
-    return _Tpvec(wasm_##suffix##_add(a_Square, b_Square));                    \
-  }                                                                            \
-  inline _Tpvec v_muladd(const _Tpvec &a, const _Tpvec &b, const _Tpvec &c) {  \
-    return _Tpvec(                                                             \
-        wasm_##suffix##_add(wasm_##suffix##_mul(a.val, b.val), c.val));        \
-  }
-
-OPENCV_HAL_IMPL_WASM_MISC_FLT_OP(v_float32x4, f32x4)
-OPENCV_HAL_IMPL_WASM_MISC_FLT_OP(v_float64x2, f64x2)
-
-#define OPENCV_HAL_IMPL_WASM_SHIFT_OP(_Tpuvec, _Tpsvec, suffix, ssuffix)       \
-  inline _Tpuvec v_shl(const _Tpuvec &a, int imm) {                            \
-    return _Tpuvec(wasm_##suffix##_shl(a.val, imm));                           \
-  }                                                                            \
-  inline _Tpsvec v_shl(const _Tpsvec &a, int imm) {                            \
-    return _Tpsvec(wasm_##suffix##_shl(a.val, imm));                           \
-  }                                                                            \
-  inline _Tpuvec v_shr(const _Tpuvec &a, int imm) {                            \
-    return _Tpuvec(wasm_##ssuffix##_shr(a.val, imm));                          \
-  }                                                                            \
-  inline _Tpsvec v_shr(const _Tpsvec &a, int imm) {                            \
-    return _Tpsvec(wasm_##suffix##_shr(a.val, imm));                           \
-  }                                                                            \
-  template <int imm> inline _Tpuvec v_shl(const _Tpuvec &a) {                  \
-    return _Tpuvec(wasm_##suffix##_shl(a.val, imm));                           \
-  }                                                                            \
-  template <int imm> inline _Tpsvec v_shl(const _Tpsvec &a) {                  \
-    return _Tpsvec(wasm_##suffix##_shl(a.val, imm));                           \
-  }                                                                            \
-  template <int imm> inline _Tpuvec v_shr(const _Tpuvec &a) {                  \
-    return _Tpuvec(wasm_##ssuffix##_shr(a.val, imm));                          \
-  }                                                                            \
-  template <int imm> inline _Tpsvec v_shr(const _Tpsvec &a) {                  \
-    return _Tpsvec(wasm_##suffix##_shr(a.val, imm));                           \
-  }
-
-OPENCV_HAL_IMPL_WASM_SHIFT_OP(v_uint8x16, v_int8x16, i8x16, u8x16)
-OPENCV_HAL_IMPL_WASM_SHIFT_OP(v_uint16x8, v_int16x8, i16x8, u16x8)
-OPENCV_HAL_IMPL_WASM_SHIFT_OP(v_uint32x4, v_int32x4, i32x4, u32x4)
-OPENCV_HAL_IMPL_WASM_SHIFT_OP(v_uint64x2, v_int64x2, i64x2, u64x2)
-
-namespace hal_wasm_internal {
-template <int imm, bool is_invalid = ((imm < 0) || (imm > 16)),
-          bool is_first = (imm == 0), bool is_second = (imm == 16),
-          bool is_other = (((imm > 0) && (imm < 16)))>
-class v_wasm_palignr_u8_class;
-
-template <int imm>
-class v_wasm_palignr_u8_class<imm, true, false, false, false>;
-
-template <int imm>
-class v_wasm_palignr_u8_class<imm, false, true, false, false> {
-public:
-  inline v128_t operator()(const v128_t &a, const v128_t &) const { return a; }
-};
-
-template <int imm>
-class v_wasm_palignr_u8_class<imm, false, false, true, false> {
-public:
-  inline v128_t operator()(const v128_t &, const v128_t &b) const { return b; }
-};
-
-template <int imm>
-class v_wasm_palignr_u8_class<imm, false, false, false, true> {
-public:
-  inline v128_t operator()(const v128_t &a, const v128_t &b) const {
-    enum { imm2 = (sizeof(v128_t) - imm) };
-    return wasm_i8x16_shuffle(a, b, imm, imm + 1, imm + 2, imm + 3, imm + 4,
-                              imm + 5, imm + 6, imm + 7, imm + 8, imm + 9,
-                              imm + 10, imm + 11, imm + 12, imm + 13, imm + 14,
-                              imm + 15);
-  }
-};
-
-template <int imm>
-inline v128_t v_wasm_palignr_u8(const v128_t &a, const v128_t &b) {
-  CV_StaticAssert((imm >= 0) && (imm <= 16),
-                  "Invalid imm for v_wasm_palignr_u8.");
-  return v_wasm_palignr_u8_class<imm>()(a, b);
-}
-} // namespace hal_wasm_internal
-
-template <int imm, typename _Tpvec>
-inline _Tpvec v_rotate_right(const _Tpvec &a) {
-  using namespace hal_wasm_internal;
-  enum { imm2 = (imm * sizeof(typename _Tpvec::lane_type)) };
-  v128_t z = wasm_i8x16_splat(0);
-  return _Tpvec(v_wasm_palignr_u8<imm2>(a.val, z));
-}
-
-template <int imm, typename _Tpvec>
-inline _Tpvec v_rotate_left(const _Tpvec &a) {
-  using namespace hal_wasm_internal;
-  enum { imm2 = ((_Tpvec::nlanes - imm) * sizeof(typename _Tpvec::lane_type)) };
-  v128_t z = wasm_i8x16_splat(0);
-  return _Tpvec(v_wasm_palignr_u8<imm2>(z, a.val));
-}
-
-template <int imm, typename _Tpvec>
-inline _Tpvec v_rotate_right(const _Tpvec &a, const _Tpvec &b) {
-  using namespace hal_wasm_internal;
-  enum { imm2 = (imm * sizeof(typename _Tpvec::lane_type)) };
-  return _Tpvec(v_wasm_palignr_u8<imm2>(a.val, b.val));
-}
-
-template <int imm, typename _Tpvec>
-inline _Tpvec v_rotate_left(const _Tpvec &a, const _Tpvec &b) {
-  using namespace hal_wasm_internal;
-  enum { imm2 = ((_Tpvec::nlanes - imm) * sizeof(typename _Tpvec::lane_type)) };
-  return _Tpvec(v_wasm_palignr_u8<imm2>(b.val, a.val));
-}
-
-#define OPENCV_HAL_IMPL_WASM_LOADSTORE_INT_OP(_Tpvec, _Tp)                     \
-  inline _Tpvec v_load(const _Tp *ptr) { return _Tpvec(wasm_v128_load(ptr)); } \
-  inline _Tpvec v_load_aligned(const _Tp *ptr) {                               \
-    return _Tpvec(wasm_v128_load(ptr));                                        \
-  }                                                                            \
-  inline _Tpvec v_load_low(const _Tp *ptr) {                                   \
-    _Tp tmp[_Tpvec::nlanes] = {0};                                             \
-    for (int i = 0; i < _Tpvec::nlanes / 2; ++i) {                             \
-      tmp[i] = ptr[i];                                                         \
-    }                                                                          \
-    return _Tpvec(wasm_v128_load(tmp));                                        \
-  }                                                                            \
-  inline _Tpvec v_load_halves(const _Tp *ptr0, const _Tp *ptr1) {              \
-    _Tp tmp[_Tpvec::nlanes];                                                   \
-    for (int i = 0; i < _Tpvec::nlanes / 2; ++i) {                             \
-      tmp[i] = ptr0[i];                                                        \
-      tmp[i + _Tpvec::nlanes / 2] = ptr1[i];                                   \
-    }                                                                          \
-    return _Tpvec(wasm_v128_load(tmp));                                        \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a) {                             \
-    wasm_v128_store(ptr, a.val);                                               \
-  }                                                                            \
-  inline void v_store_aligned(_Tp *ptr, const _Tpvec &a) {                     \
-    wasm_v128_store(ptr, a.val);                                               \
-  }                                                                            \
-  inline void v_store_aligned_nocache(_Tp *ptr, const _Tpvec &a) {             \
-    wasm_v128_store(ptr, a.val);                                               \
-  }                                                                            \
-  inline void v_store(_Tp *ptr, const _Tpvec &a, hal::StoreMode /*mode*/) {    \
-    wasm_v128_store(ptr, a.val);                                               \
-  }                                                                            \
-  inline void v_store_low(_Tp *ptr, const _Tpvec &a) {                         \
-    _Tpvec::lane_type a_[_Tpvec::nlanes];                                      \
-    wasm_v128_store(a_, a.val);                                                \
-    for (int i = 0; i < (_Tpvec::nlanes / 2); i++)                             \
-      ptr[i] = a_[i];                                                          \
-  }                                                                            \
-  inline void v_store_high(_Tp *ptr, const _Tpvec &a) {                        \
-    _Tpvec::lane_type a_[_Tpvec::nlanes];                                      \
-    wasm_v128_store(a_, a.val);                                                \
-    for (int i = 0; i < (_Tpvec::nlanes / 2); i++)                             \
-      ptr[i] = a_[i + (_Tpvec::nlanes / 2)];                                   \
-  }
-
-OPENCV_HAL_IMPL_WASM_LOADSTORE_INT_OP(v_uint8x16, uchar)
-OPENCV_HAL_IMPL_WASM_LOADSTORE_INT_OP(v_int8x16, schar)
-OPENCV_HAL_IMPL_WASM_LOADSTORE_INT_OP(v_uint16x8, ushort)
-OPENCV_HAL_IMPL_WASM_LOADSTORE_INT_OP(v_int16x8, short)
-OPENCV_HAL_IMPL_WASM_LOADSTORE_INT_OP(v_uint32x4, unsigned)
-OPENCV_HAL_IMPL_WASM_LOADSTORE_INT_OP(v_int32x4, int)
-OPENCV_HAL_IMPL_WASM_LOADSTORE_INT_OP(v_uint64x2, uint64)
-OPENCV_HAL_IMPL_WASM_LOADSTORE_INT_OP(v_int64x2, int64)
-OPENCV_HAL_IMPL_WASM_LOADSTORE_INT_OP(v_float32x4, float)
-OPENCV_HAL_IMPL_WASM_LOADSTORE_INT_OP(v_float64x2, double)
-
-/** Reverse **/
-inline v_uint8x16 v_reverse(const v_uint8x16 &a) {
-  return v_uint8x16(wasm_i8x16_shuffle(a.val, a.val, 15, 14, 13, 12, 11, 10, 9,
-                                       8, 7, 6, 5, 4, 3, 2, 1, 0));
-}
-
-inline v_int8x16 v_reverse(const v_int8x16 &a) {
-  return v_reinterpret_as_s8(v_reverse(v_reinterpret_as_u8(a)));
-}
-
-inline v_uint16x8 v_reverse(const v_uint16x8 &a) {
-  return v_uint16x8(wasm_i8x16_shuffle(a.val, a.val, 14, 15, 12, 13, 10, 11, 8,
-                                       9, 6, 7, 4, 5, 2, 3, 0, 1));
-}
-
-inline v_int16x8 v_reverse(const v_int16x8 &a) {
-  return v_reinterpret_as_s16(v_reverse(v_reinterpret_as_u16(a)));
-}
-
-inline v_uint32x4 v_reverse(const v_uint32x4 &a) {
-  return v_uint32x4(wasm_i8x16_shuffle(a.val, a.val, 12, 13, 14, 15, 8, 9, 10,
-                                       11, 4, 5, 6, 7, 0, 1, 2, 3));
-}
-
-inline v_int32x4 v_reverse(const v_int32x4 &a) {
-  return v_reinterpret_as_s32(v_reverse(v_reinterpret_as_u32(a)));
-}
-
-inline v_float32x4 v_reverse(const v_float32x4 &a) {
-  return v_reinterpret_as_f32(v_reverse(v_reinterpret_as_u32(a)));
-}
-
-inline v_uint64x2 v_reverse(const v_uint64x2 &a) {
-  return v_uint64x2(wasm_i8x16_shuffle(a.val, a.val, 8, 9, 10, 11, 12, 13, 14,
-                                       15, 0, 1, 2, 3, 4, 5, 6, 7));
-}
-
-inline v_int64x2 v_reverse(const v_int64x2 &a) {
-  return v_reinterpret_as_s64(v_reverse(v_reinterpret_as_u64(a)));
-}
-
-inline v_float64x2 v_reverse(const v_float64x2 &a) {
-  return v_reinterpret_as_f64(v_reverse(v_reinterpret_as_u64(a)));
-}
-
-#define OPENCV_HAL_IMPL_WASM_REDUCE_OP_4_SUM(_Tpvec, scalartype, regtype,      \
-                                             suffix, esuffix)                  \
-  inline scalartype v_reduce_sum(const _Tpvec &a) {                            \
-    regtype val = a.val;                                                       \
-    val = wasm_##suffix##_add(val, wasm_i8x16_shuffle(val, val, 8, 9, 10, 11,  \
-                                                      12, 13, 14, 15, 0, 1, 2, \
-                                                      3, 4, 5, 6, 7));         \
-    val = wasm_##suffix##_add(val, wasm_i8x16_shuffle(val, val, 4, 5, 6, 7, 8, \
-                                                      9, 10, 11, 12, 13, 14,   \
-                                                      15, 0, 1, 2, 3));        \
-    return (scalartype)wasm_##esuffix##_extract_lane(val, 0);                  \
-  }
-
-OPENCV_HAL_IMPL_WASM_REDUCE_OP_4_SUM(v_uint32x4, unsigned, v128_t, i32x4, i32x4)
-OPENCV_HAL_IMPL_WASM_REDUCE_OP_4_SUM(v_int32x4, int, v128_t, i32x4, i32x4)
-OPENCV_HAL_IMPL_WASM_REDUCE_OP_4_SUM(v_float32x4, float, v128_t, f32x4, f32x4)
-
-// To do: Optimize v_reduce_sum with wasm intrin.
-//        Now use fallback implementation as there is no widening op in wasm
-//        intrin.
-
-#define OPENCV_HAL_IMPL_FALLBACK_REDUCE_OP_SUM(_Tpvec, scalartype)             \
-  inline scalartype v_reduce_sum(const _Tpvec &a) {                            \
-    _Tpvec::lane_type a_[_Tpvec::nlanes];                                      \
-    wasm_v128_store(a_, a.val);                                                \
-    scalartype c = a_[0];                                                      \
-    for (int i = 1; i < _Tpvec::nlanes; i++)                                   \
-      c += a_[i];                                                              \
-    return c;                                                                  \
-  }
-
-OPENCV_HAL_IMPL_FALLBACK_REDUCE_OP_SUM(v_uint8x16, unsigned)
-OPENCV_HAL_IMPL_FALLBACK_REDUCE_OP_SUM(v_int8x16, int)
-OPENCV_HAL_IMPL_FALLBACK_REDUCE_OP_SUM(v_uint16x8, unsigned)
-OPENCV_HAL_IMPL_FALLBACK_REDUCE_OP_SUM(v_int16x8, int)
-
-#define OPENCV_HAL_IMPL_WASM_REDUCE_OP_2_SUM(_Tpvec, scalartype, regtype,      \
-                                             suffix, esuffix)                  \
-  inline scalartype v_reduce_sum(const _Tpvec &a) {                            \
-    regtype val = a.val;                                                       \
-    val = wasm_##suffix##_add(val, wasm_i8x16_shuffle(val, val, 8, 9, 10, 11,  \
-                                                      12, 13, 14, 15, 0, 1, 2, \
-                                                      3, 4, 5, 6, 7));         \
-    return (scalartype)wasm_##esuffix##_extract_lane(val, 0);                  \
-  }
-OPENCV_HAL_IMPL_WASM_REDUCE_OP_2_SUM(v_uint64x2, uint64, v128_t, i64x2, i64x2)
-OPENCV_HAL_IMPL_WASM_REDUCE_OP_2_SUM(v_int64x2, int64, v128_t, i64x2, i64x2)
-OPENCV_HAL_IMPL_WASM_REDUCE_OP_2_SUM(v_float64x2, double, v128_t, f64x2, f64x2)
-
-inline v_float32x4 v_reduce_sum4(const v_float32x4 &a, const v_float32x4 &b,
-                                 const v_float32x4 &c, const v_float32x4 &d) {
-  v128_t ac = wasm_f32x4_add(wasm_unpacklo_i32x4(a.val, c.val),
-                             wasm_unpackhi_i32x4(a.val, c.val));
-  v128_t bd = wasm_f32x4_add(wasm_unpacklo_i32x4(b.val, d.val),
-                             wasm_unpackhi_i32x4(b.val, d.val));
-  return v_float32x4(
-      wasm_f32x4_add(wasm_unpacklo_i32x4(ac, bd), wasm_unpackhi_i32x4(ac, bd)));
-}
-
-#define OPENCV_HAL_IMPL_WASM_REDUCE_OP(_Tpvec, scalartype, func, scalar_func)  \
-  inline scalartype v_reduce_##func(const _Tpvec &a) {                         \
-    scalartype buf[_Tpvec::nlanes];                                            \
-    v_store(buf, a);                                                           \
-    scalartype tmp = buf[0];                                                   \
-    for (int i = 1; i < _Tpvec::nlanes; ++i) {                                 \
-      tmp = scalar_func(tmp, buf[i]);                                          \
-    }                                                                          \
-    return tmp;                                                                \
-  }
-
-OPENCV_HAL_IMPL_WASM_REDUCE_OP(v_uint8x16, uchar, max, std::max)
-OPENCV_HAL_IMPL_WASM_REDUCE_OP(v_uint8x16, uchar, min, std::min)
-OPENCV_HAL_IMPL_WASM_REDUCE_OP(v_int8x16, schar, max, std::max)
-OPENCV_HAL_IMPL_WASM_REDUCE_OP(v_int8x16, schar, min, std::min)
-OPENCV_HAL_IMPL_WASM_REDUCE_OP(v_uint16x8, ushort, max, std::max)
-OPENCV_HAL_IMPL_WASM_REDUCE_OP(v_uint16x8, ushort, min, std::min)
-OPENCV_HAL_IMPL_WASM_REDUCE_OP(v_int16x8, short, max, std::max)
-OPENCV_HAL_IMPL_WASM_REDUCE_OP(v_int16x8, short, min, std::min)
-OPENCV_HAL_IMPL_WASM_REDUCE_OP(v_uint32x4, unsigned, max, std::max)
-OPENCV_HAL_IMPL_WASM_REDUCE_OP(v_uint32x4, unsigned, min, std::min)
-OPENCV_HAL_IMPL_WASM_REDUCE_OP(v_int32x4, int, max, std::max)
-OPENCV_HAL_IMPL_WASM_REDUCE_OP(v_int32x4, int, min, std::min)
-OPENCV_HAL_IMPL_WASM_REDUCE_OP(v_float32x4, float, max, std::max)
-OPENCV_HAL_IMPL_WASM_REDUCE_OP(v_float32x4, float, min, std::min)
-
-inline unsigned v_reduce_sad(const v_uint8x16 &a, const v_uint8x16 &b) {
-  v_uint16x8 l16, h16;
-  v_uint32x4 l16_l32, l16_h32, h16_l32, h16_h32;
-  v_expand(v_absdiff(a, b), l16, h16);
-  v_expand(l16, l16_l32, l16_h32);
-  v_expand(h16, h16_l32, h16_h32);
-  return v_reduce_sum(v_add(v_add(l16_l32, l16_h32), v_add(h16_l32, h16_h32)));
-}
-inline unsigned v_reduce_sad(const v_int8x16 &a, const v_int8x16 &b) {
-  v_uint16x8 l16, h16;
-  v_uint32x4 l16_l32, l16_h32, h16_l32, h16_h32;
-  v_expand(v_absdiff(a, b), l16, h16);
-  v_expand(l16, l16_l32, l16_h32);
-  v_expand(h16, h16_l32, h16_h32);
-  return v_reduce_sum(v_add(v_add(l16_l32, l16_h32), v_add(h16_l32, h16_h32)));
-}
-inline unsigned v_reduce_sad(const v_uint16x8 &a, const v_uint16x8 &b) {
-  v_uint32x4 l, h;
-  v_expand(v_absdiff(a, b), l, h);
-  return v_reduce_sum(v_add(l, h));
-}
-inline unsigned v_reduce_sad(const v_int16x8 &a, const v_int16x8 &b) {
-  v_uint32x4 l, h;
-  v_expand(v_absdiff(a, b), l, h);
-  return v_reduce_sum(v_add(l, h));
-}
-inline unsigned v_reduce_sad(const v_uint32x4 &a, const v_uint32x4 &b) {
-  return v_reduce_sum(v_absdiff(a, b));
-}
-inline unsigned v_reduce_sad(const v_int32x4 &a, const v_int32x4 &b) {
-  return v_reduce_sum(v_absdiff(a, b));
-}
-inline float v_reduce_sad(const v_float32x4 &a, const v_float32x4 &b) {
-  return v_reduce_sum(v_absdiff(a, b));
-}
-
-inline v_uint8x16 v_popcount(const v_uint8x16 &a) {
-  v128_t m1 = wasm_i32x4_splat(0x55555555);
-  v128_t m2 = wasm_i32x4_splat(0x33333333);
-  v128_t m4 = wasm_i32x4_splat(0x0f0f0f0f);
-  v128_t p = a.val;
-  p = wasm_i32x4_add(wasm_v128_and(wasm_u32x4_shr(p, 1), m1),
-                     wasm_v128_and(p, m1));
-  p = wasm_i32x4_add(wasm_v128_and(wasm_u32x4_shr(p, 2), m2),
-                     wasm_v128_and(p, m2));
-  p = wasm_i32x4_add(wasm_v128_and(wasm_u32x4_shr(p, 4), m4),
-                     wasm_v128_and(p, m4));
-  return v_uint8x16(p);
-}
-inline v_uint16x8 v_popcount(const v_uint16x8 &a) {
-  v_uint8x16 p = v_popcount(v_reinterpret_as_u8(a));
-  p = v_add(p, v_rotate_right<1>(p));
-  return v_and(v_reinterpret_as_u16(p), v_setall_u16(0x00ff));
-}
-inline v_uint32x4 v_popcount(const v_uint32x4 &a) {
-  v_uint8x16 p = v_popcount(v_reinterpret_as_u8(a));
-  p = v_add(p, v_rotate_right<1>(p));
-  p = v_add(p, v_rotate_right<2>(p));
-  return v_and(v_reinterpret_as_u32(p), v_setall_u32(0x000000ff));
-}
-inline v_uint64x2 v_popcount(const v_uint64x2 &a) {
-  uint64 a_[2], b_[2] = {0};
-  wasm_v128_store(a_, a.val);
-  for (int i = 0; i < 16; i++)
-    b_[i / 8] += popCountTable[((uint8_t *)a_)[i]];
-  return v_uint64x2(wasm_v128_load(b_));
-}
-inline v_uint8x16 v_popcount(const v_int8x16 &a) {
-  return v_popcount(v_reinterpret_as_u8(a));
-}
-inline v_uint16x8 v_popcount(const v_int16x8 &a) {
-  return v_popcount(v_reinterpret_as_u16(a));
-}
-inline v_uint32x4 v_popcount(const v_int32x4 &a) {
-  return v_popcount(v_reinterpret_as_u32(a));
-}
-inline v_uint64x2 v_popcount(const v_int64x2 &a) {
-  return v_popcount(v_reinterpret_as_u64(a));
-}
-
-#define OPENCV_HAL_IMPL_WASM_CHECK_SIGNS(_Tpvec, suffix, scalarType)           \
-  inline int v_signmask(const _Tpvec &a) {                                     \
-    _Tpvec::lane_type a_[_Tpvec::nlanes];                                      \
-    wasm_v128_store(a_, a.val);                                                \
-    int mask = 0;                                                              \
-    for (int i = 0; i < _Tpvec::nlanes; i++)                                   \
-      mask |= (reinterpret_int(a_[i]) < 0) << i;                               \
-    return mask;                                                               \
-  }                                                                            \
-  inline bool v_check_all(const _Tpvec &a) {                                   \
-    return wasm_i8x16_all_true(                                                \
-        wasm_##suffix##_lt(a.val, wasm_##suffix##_splat(0)));                  \
-  }                                                                            \
-  inline bool v_check_any(const _Tpvec &a) {                                   \
-    return wasm_i8x16_any_true(                                                \
-        wasm_##suffix##_lt(a.val, wasm_##suffix##_splat(0)));                  \
-    ;                                                                          \
-  }
-
-OPENCV_HAL_IMPL_WASM_CHECK_SIGNS(v_uint8x16, i8x16, schar)
-OPENCV_HAL_IMPL_WASM_CHECK_SIGNS(v_int8x16, i8x16, schar)
-OPENCV_HAL_IMPL_WASM_CHECK_SIGNS(v_uint16x8, i16x8, short)
-OPENCV_HAL_IMPL_WASM_CHECK_SIGNS(v_int16x8, i16x8, short)
-OPENCV_HAL_IMPL_WASM_CHECK_SIGNS(v_uint32x4, i32x4, int)
-OPENCV_HAL_IMPL_WASM_CHECK_SIGNS(v_int32x4, i32x4, int)
-OPENCV_HAL_IMPL_WASM_CHECK_SIGNS(v_float32x4, i32x4, float)
-OPENCV_HAL_IMPL_WASM_CHECK_SIGNS(v_float64x2, f64x2, double)
-
-#define OPENCV_HAL_IMPL_WASM_CHECK_ALL_ANY(_Tpvec, suffix, esuffix)            \
-  inline bool v_check_all(const _Tpvec &a) {                                   \
-    v128_t masked = v_reinterpret_as_##esuffix(a).val;                         \
-    masked = wasm_i32x4_replace_lane(masked, 0, 0xffffffff);                   \
-    masked = wasm_i32x4_replace_lane(masked, 2, 0xffffffff);                   \
-    return wasm_i8x16_all_true(                                                \
-        wasm_##suffix##_lt(masked, wasm_##suffix##_splat(0)));                 \
-  }                                                                            \
-  inline bool v_check_any(const _Tpvec &a) {                                   \
-    v128_t masked = v_reinterpret_as_##esuffix(a).val;                         \
-    masked = wasm_i32x4_replace_lane(masked, 0, 0x0);                          \
-    masked = wasm_i32x4_replace_lane(masked, 2, 0x0);                          \
-    return wasm_i8x16_any_true(                                                \
-        wasm_##suffix##_lt(masked, wasm_##suffix##_splat(0)));                 \
-  }
-
-OPENCV_HAL_IMPL_WASM_CHECK_ALL_ANY(v_int64x2, i32x4, s32)
-OPENCV_HAL_IMPL_WASM_CHECK_ALL_ANY(v_uint64x2, i32x4, u32)
-
-inline int v_scan_forward(const v_int8x16 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a)));
-}
-inline int v_scan_forward(const v_uint8x16 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a)));
-}
-inline int v_scan_forward(const v_int16x8 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 2;
-}
-inline int v_scan_forward(const v_uint16x8 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 2;
-}
-inline int v_scan_forward(const v_int32x4 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 4;
-}
-inline int v_scan_forward(const v_uint32x4 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 4;
-}
-inline int v_scan_forward(const v_float32x4 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 4;
-}
-inline int v_scan_forward(const v_int64x2 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 8;
-}
-inline int v_scan_forward(const v_uint64x2 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 8;
-}
-inline int v_scan_forward(const v_float64x2 &a) {
-  return trailingZeros32(v_signmask(v_reinterpret_as_s8(a))) / 8;
-}
-
-#define OPENCV_HAL_IMPL_WASM_SELECT(_Tpvec)                                    \
-  inline _Tpvec v_select(const _Tpvec &mask, const _Tpvec &a,                  \
-                         const _Tpvec &b) {                                    \
-    return _Tpvec(wasm_v128_bitselect(a.val, b.val, mask.val));                \
-  }
-
-OPENCV_HAL_IMPL_WASM_SELECT(v_uint8x16)
-OPENCV_HAL_IMPL_WASM_SELECT(v_int8x16)
-OPENCV_HAL_IMPL_WASM_SELECT(v_uint16x8)
-OPENCV_HAL_IMPL_WASM_SELECT(v_int16x8)
-OPENCV_HAL_IMPL_WASM_SELECT(v_uint32x4)
-OPENCV_HAL_IMPL_WASM_SELECT(v_int32x4)
-OPENCV_HAL_IMPL_WASM_SELECT(v_uint64x2)
-OPENCV_HAL_IMPL_WASM_SELECT(v_int64x2)
-OPENCV_HAL_IMPL_WASM_SELECT(v_float32x4)
-OPENCV_HAL_IMPL_WASM_SELECT(v_float64x2)
-
-#define OPENCV_HAL_IMPL_WASM_EXPAND(_Tpvec, _Tpwvec, _Tp, intrin)              \
-  inline void v_expand(const _Tpvec &a, _Tpwvec &b0, _Tpwvec &b1) {            \
-    b0.val = intrin(a.val);                                                    \
-    b1.val = __CV_CAT(intrin, _high)(a.val);                                   \
-  }                                                                            \
-  inline _Tpwvec v_expand_low(const _Tpvec &a) {                               \
-    return _Tpwvec(intrin(a.val));                                             \
-  }                                                                            \
-  inline _Tpwvec v_expand_high(const _Tpvec &a) {                              \
-    return _Tpwvec(__CV_CAT(intrin, _high)(a.val));                            \
-  }                                                                            \
-  inline _Tpwvec v_load_expand(const _Tp *ptr) {                               \
-    v128_t a = wasm_v128_load(ptr);                                            \
-    return _Tpwvec(intrin(a));                                                 \
-  }
-
-OPENCV_HAL_IMPL_WASM_EXPAND(v_uint8x16, v_uint16x8, uchar, v128_cvtu8x16_i16x8)
-OPENCV_HAL_IMPL_WASM_EXPAND(v_int8x16, v_int16x8, schar, v128_cvti8x16_i16x8)
-OPENCV_HAL_IMPL_WASM_EXPAND(v_uint16x8, v_uint32x4, ushort, v128_cvtu16x8_i32x4)
-OPENCV_HAL_IMPL_WASM_EXPAND(v_int16x8, v_int32x4, short, v128_cvti16x8_i32x4)
-OPENCV_HAL_IMPL_WASM_EXPAND(v_uint32x4, v_uint64x2, unsigned,
-                            v128_cvtu32x4_i64x2)
-OPENCV_HAL_IMPL_WASM_EXPAND(v_int32x4, v_int64x2, int, v128_cvti32x4_i64x2)
-
-#define OPENCV_HAL_IMPL_WASM_EXPAND_Q(_Tpvec, _Tp, intrin)                     \
-  inline _Tpvec v_load_expand_q(const _Tp *ptr) {                              \
-    v128_t a = wasm_v128_load(ptr);                                            \
-    return _Tpvec(intrin(a));                                                  \
-  }
-
-OPENCV_HAL_IMPL_WASM_EXPAND_Q(v_uint32x4, uchar, v128_cvtu8x16_i32x4)
-OPENCV_HAL_IMPL_WASM_EXPAND_Q(v_int32x4, schar, v128_cvti8x16_i32x4)
-
-#define OPENCV_HAL_IMPL_WASM_UNPACKS(_Tpvec, suffix)                           \
-  inline void v_zip(const _Tpvec &a0, const _Tpvec &a1, _Tpvec &b0,            \
-                    _Tpvec &b1) {                                              \
-    b0.val = wasm_unpacklo_##suffix(a0.val, a1.val);                           \
-    b1.val = wasm_unpackhi_##suffix(a0.val, a1.val);                           \
-  }                                                                            \
-  inline _Tpvec v_combine_low(const _Tpvec &a, const _Tpvec &b) {              \
-    return _Tpvec(wasm_unpacklo_i64x2(a.val, b.val));                          \
-  }                                                                            \
-  inline _Tpvec v_combine_high(const _Tpvec &a, const _Tpvec &b) {             \
-    return _Tpvec(wasm_unpackhi_i64x2(a.val, b.val));                          \
-  }                                                                            \
-  inline void v_recombine(const _Tpvec &a, const _Tpvec &b, _Tpvec &c,         \
-                          _Tpvec &d) {                                         \
-    c.val = wasm_unpacklo_i64x2(a.val, b.val);                                 \
-    d.val = wasm_unpackhi_i64x2(a.val, b.val);                                 \
-  }
-
-OPENCV_HAL_IMPL_WASM_UNPACKS(v_uint8x16, i8x16)
-OPENCV_HAL_IMPL_WASM_UNPACKS(v_int8x16, i8x16)
-OPENCV_HAL_IMPL_WASM_UNPACKS(v_uint16x8, i16x8)
-OPENCV_HAL_IMPL_WASM_UNPACKS(v_int16x8, i16x8)
-OPENCV_HAL_IMPL_WASM_UNPACKS(v_uint32x4, i32x4)
-OPENCV_HAL_IMPL_WASM_UNPACKS(v_int32x4, i32x4)
-OPENCV_HAL_IMPL_WASM_UNPACKS(v_float32x4, i32x4)
-OPENCV_HAL_IMPL_WASM_UNPACKS(v_float64x2, i64x2)
-
-template <int s, typename _Tpvec>
-inline _Tpvec v_extract(const _Tpvec &a, const _Tpvec &b) {
-  return v_rotate_right<s>(a, b);
-}
-
-inline v_int32x4 v_round(const v_float32x4 &a) {
-  v128_t h = wasm_f32x4_splat(0.5);
-  return v_int32x4(wasm_i32x4_trunc_saturate_f32x4(wasm_f32x4_add(a.val, h)));
-}
-
-inline v_int32x4 v_floor(const v_float32x4 &a) {
-  v128_t a1 = wasm_i32x4_trunc_saturate_f32x4(a.val);
-  v128_t mask = wasm_f32x4_lt(a.val, wasm_f32x4_convert_i32x4(a1));
-  return v_int32x4(wasm_i32x4_add(a1, mask));
-}
-
-inline v_int32x4 v_ceil(const v_float32x4 &a) {
-  v128_t a1 = wasm_i32x4_trunc_saturate_f32x4(a.val);
-  v128_t mask = wasm_f32x4_gt(a.val, wasm_f32x4_convert_i32x4(a1));
-  return v_int32x4(wasm_i32x4_sub(a1, mask));
-}
-
-inline v_int32x4 v_trunc(const v_float32x4 &a) {
-  return v_int32x4(wasm_i32x4_trunc_saturate_f32x4(a.val));
-}
-
-#define OPENCV_HAL_IMPL_WASM_MATH_FUNC(func, cfunc)                            \
-  inline v_int32x4 func(const v_float64x2 &a) {                                \
-    double a_[2];                                                              \
-    wasm_v128_store(a_, a.val);                                                \
-    int c_[4];                                                                 \
-    c_[0] = cfunc(a_[0]);                                                      \
-    c_[1] = cfunc(a_[1]);                                                      \
-    c_[2] = 0;                                                                 \
-    c_[3] = 0;                                                                 \
-    return v_int32x4(wasm_v128_load(c_));                                      \
-  }
-
-OPENCV_HAL_IMPL_WASM_MATH_FUNC(v_round, cvRound)
-OPENCV_HAL_IMPL_WASM_MATH_FUNC(v_floor, cvFloor)
-OPENCV_HAL_IMPL_WASM_MATH_FUNC(v_ceil, cvCeil)
-OPENCV_HAL_IMPL_WASM_MATH_FUNC(v_trunc, int)
-
-inline v_int32x4 v_round(const v_float64x2 &a, const v_float64x2 &b) {
-  double a_[2], b_[2];
-  wasm_v128_store(a_, a.val);
-  wasm_v128_store(b_, b.val);
-  int c_[4];
-  c_[0] = cvRound(a_[0]);
-  c_[1] = cvRound(a_[1]);
-  c_[2] = cvRound(b_[0]);
-  c_[3] = cvRound(b_[1]);
-  return v_int32x4(wasm_v128_load(c_));
-}
-
-#define OPENCV_HAL_IMPL_WASM_TRANSPOSE4x4(_Tpvec, suffix)                      \
-  inline void v_transpose4x4(const _Tpvec &a0, const _Tpvec &a1,               \
-                             const _Tpvec &a2, const _Tpvec &a3, _Tpvec &b0,   \
-                             _Tpvec &b1, _Tpvec &b2, _Tpvec &b3) {             \
-    v128_t t0 = wasm_unpacklo_##suffix(a0.val, a1.val);                        \
-    v128_t t1 = wasm_unpacklo_##suffix(a2.val, a3.val);                        \
-    v128_t t2 = wasm_unpackhi_##suffix(a0.val, a1.val);                        \
-    v128_t t3 = wasm_unpackhi_##suffix(a2.val, a3.val);                        \
-                                                                               \
-    b0.val = wasm_unpacklo_i64x2(t0, t1);                                      \
-    b1.val = wasm_unpackhi_i64x2(t0, t1);                                      \
-    b2.val = wasm_unpacklo_i64x2(t2, t3);                                      \
-    b3.val = wasm_unpackhi_i64x2(t2, t3);                                      \
-  }
-
-OPENCV_HAL_IMPL_WASM_TRANSPOSE4x4(v_uint32x4, i32x4)
-    OPENCV_HAL_IMPL_WASM_TRANSPOSE4x4(v_int32x4, i32x4)
-        OPENCV_HAL_IMPL_WASM_TRANSPOSE4x4(v_float32x4, i32x4)
-
-    // load deinterleave
-    inline void v_load_deinterleave(const uchar *ptr, v_uint8x16 &a,
-                                    v_uint8x16 &b) {
-  v128_t t00 = wasm_v128_load(ptr);
-  v128_t t01 = wasm_v128_load(ptr + 16);
-
-  a.val = wasm_i8x16_shuffle(t00, t01, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20,
-                             22, 24, 26, 28, 30);
-  b.val = wasm_i8x16_shuffle(t00, t01, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21,
-                             23, 25, 27, 29, 31);
-}
-
-inline void v_load_deinterleave(const uchar *ptr, v_uint8x16 &a, v_uint8x16 &b,
-                                v_uint8x16 &c) {
-  v128_t t00 = wasm_v128_load(ptr);
-  v128_t t01 = wasm_v128_load(ptr + 16);
-  v128_t t02 = wasm_v128_load(ptr + 32);
-
-  v128_t t10 = wasm_i8x16_shuffle(t00, t01, 0, 3, 6, 9, 12, 15, 18, 21, 24, 27,
-                                  30, 1, 2, 4, 5, 7);
-  v128_t t11 = wasm_i8x16_shuffle(t00, t01, 1, 4, 7, 10, 13, 16, 19, 22, 25, 28,
-                                  31, 0, 2, 3, 5, 6);
-  v128_t t12 = wasm_i8x16_shuffle(t00, t01, 2, 5, 8, 11, 14, 17, 20, 23, 26, 29,
-                                  0, 1, 3, 4, 6, 7);
-
-  a.val = wasm_i8x16_shuffle(t10, t02, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 17, 20,
-                             23, 26, 29);
-  b.val = wasm_i8x16_shuffle(t11, t02, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 18, 21,
-                             24, 27, 30);
-  c.val = wasm_i8x16_shuffle(t12, t02, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 19, 22,
-                             25, 28, 31);
-}
-
-inline void v_load_deinterleave(const uchar *ptr, v_uint8x16 &a, v_uint8x16 &b,
-                                v_uint8x16 &c, v_uint8x16 &d) {
-  v128_t u0 = wasm_v128_load(ptr);      // a0 b0 c0 d0 a1 b1 c1 d1 ...
-  v128_t u1 = wasm_v128_load(ptr + 16); // a4 b4 c4 d4 ...
-  v128_t u2 = wasm_v128_load(ptr + 32); // a8 b8 c8 d8 ...
-  v128_t u3 = wasm_v128_load(ptr + 48); // a12 b12 c12 d12 ...
-
-  v128_t v0 = wasm_i8x16_shuffle(u0, u1, 0, 4, 8, 12, 16, 20, 24, 28, 1, 5, 9,
-                                 13, 17, 21, 25, 29);
-  v128_t v1 = wasm_i8x16_shuffle(u2, u3, 0, 4, 8, 12, 16, 20, 24, 28, 1, 5, 9,
-                                 13, 17, 21, 25, 29);
-  v128_t v2 = wasm_i8x16_shuffle(u0, u1, 2, 6, 10, 14, 18, 22, 26, 30, 3, 7, 11,
-                                 15, 19, 23, 27, 31);
-  v128_t v3 = wasm_i8x16_shuffle(u2, u3, 2, 6, 10, 14, 18, 22, 26, 30, 3, 7, 11,
-                                 15, 19, 23, 27, 31);
-
-  a.val = wasm_i8x16_shuffle(v0, v1, 0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20,
-                             21, 22, 23);
-  b.val = wasm_i8x16_shuffle(v0, v1, 8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26,
-                             27, 28, 29, 30, 31);
-  c.val = wasm_i8x16_shuffle(v2, v3, 0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20,
-                             21, 22, 23);
-  d.val = wasm_i8x16_shuffle(v2, v3, 8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26,
-                             27, 28, 29, 30, 31);
-}
-
-inline void v_load_deinterleave(const ushort *ptr, v_uint16x8 &a,
-                                v_uint16x8 &b) {
-  v128_t v0 = wasm_v128_load(ptr);     // a0 b0 a1 b1 a2 b2 a3 b3
-  v128_t v1 = wasm_v128_load(ptr + 8); // a4 b4 a5 b5 a6 b6 a7 b7
-
-  a.val = wasm_i8x16_shuffle(v0, v1, 0, 1, 4, 5, 8, 9, 12, 13, 16, 17, 20, 21,
-                             24, 25, 28, 29); // a0 a1 a2 a3 a4 a5 a6 a7
-  b.val = wasm_i8x16_shuffle(v0, v1, 2, 3, 6, 7, 10, 11, 14, 15, 18, 19, 22, 23,
-                             26, 27, 30, 31); // b0 b1 ab b3 b4 b5 b6 b7
-}
-
-inline void v_load_deinterleave(const ushort *ptr, v_uint16x8 &a, v_uint16x8 &b,
-                                v_uint16x8 &c) {
-  v128_t t00 = wasm_v128_load(ptr);      // a0 b0 c0 a1 b1 c1 a2 b2
-  v128_t t01 = wasm_v128_load(ptr + 8);  // c2 a3 b3 c3 a4 b4 c4 a5
-  v128_t t02 = wasm_v128_load(ptr + 16); // b5 c5 a6 b6 c6 a7 b7 c7
-
-  v128_t t10 = wasm_i8x16_shuffle(t00, t01, 0, 1, 6, 7, 12, 13, 18, 19, 24, 25,
-                                  30, 31, 2, 3, 4, 5);
-  v128_t t11 = wasm_i8x16_shuffle(t00, t01, 2, 3, 8, 9, 14, 15, 20, 21, 26, 27,
-                                  0, 1, 4, 5, 6, 7);
-  v128_t t12 = wasm_i8x16_shuffle(t00, t01, 4, 5, 10, 11, 16, 17, 22, 23, 28,
-                                  29, 0, 1, 2, 3, 6, 7);
-
-  a.val = wasm_i8x16_shuffle(t10, t02, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 20,
-                             21, 26, 27);
-  b.val = wasm_i8x16_shuffle(t11, t02, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 22,
-                             23, 28, 29);
-  c.val = wasm_i8x16_shuffle(t12, t02, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 18, 19, 24,
-                             25, 30, 31);
-}
-
-inline void v_load_deinterleave(const ushort *ptr, v_uint16x8 &a, v_uint16x8 &b,
-                                v_uint16x8 &c, v_uint16x8 &d) {
-  v128_t u0 = wasm_v128_load(ptr);      // a0 b0 c0 d0 a1 b1 c1 d1
-  v128_t u1 = wasm_v128_load(ptr + 8);  // a2 b2 c2 d2 ...
-  v128_t u2 = wasm_v128_load(ptr + 16); // a4 b4 c4 d4 ...
-  v128_t u3 = wasm_v128_load(ptr + 24); // a6 b6 c6 d6 ...
-
-  v128_t v0 = wasm_i8x16_shuffle(u0, u1, 0, 1, 8, 9, 16, 17, 24, 25, 2, 3, 10,
-                                 11, 18, 19, 26, 27); // a0 a1 a2 a3 b0 b1 b2 b3
-  v128_t v1 = wasm_i8x16_shuffle(u2, u3, 0, 1, 8, 9, 16, 17, 24, 25, 2, 3, 10,
-                                 11, 18, 19, 26, 27); // a4 a5 a6 a7 b4 b5 b6 b7
-  v128_t v2 = wasm_i8x16_shuffle(u0, u1, 4, 5, 12, 13, 20, 21, 28, 29, 6, 7, 14,
-                                 15, 22, 23, 30, 31); // c0 c1 c2 c3 d0 d1 d2 d3
-  v128_t v3 = wasm_i8x16_shuffle(u2, u3, 4, 5, 12, 13, 20, 21, 28, 29, 6, 7, 14,
-                                 15, 22, 23, 30, 31); // c4 c5 c6 c7 d4 d5 d6 d7
-
-  a.val = wasm_i8x16_shuffle(v0, v1, 0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20,
-                             21, 22, 23);
-  b.val = wasm_i8x16_shuffle(v0, v1, 8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26,
-                             27, 28, 29, 30, 31);
-  c.val = wasm_i8x16_shuffle(v2, v3, 0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20,
-                             21, 22, 23);
-  d.val = wasm_i8x16_shuffle(v2, v3, 8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26,
-                             27, 28, 29, 30, 31);
-}
-
-inline void v_load_deinterleave(const unsigned *ptr, v_uint32x4 &a,
-                                v_uint32x4 &b) {
-  v128_t v0 = wasm_v128_load(ptr);     // a0 b0 a1 b1
-  v128_t v1 = wasm_v128_load(ptr + 4); // a2 b2 a3 b3
-
-  a.val = wasm_i8x16_shuffle(v0, v1, 0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19,
-                             24, 25, 26, 27); // a0 a1 a2 a3
-  b.val = wasm_i8x16_shuffle(v0, v1, 4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23,
-                             28, 29, 30, 31); // b0 b1 b2 b3
-}
-
-inline void v_load_deinterleave(const unsigned *ptr, v_uint32x4 &a,
-                                v_uint32x4 &b, v_uint32x4 &c) {
-  v128_t t00 = wasm_v128_load(ptr);     // a0 b0 c0 a1
-  v128_t t01 = wasm_v128_load(ptr + 4); // b2 c2 a3 b3
-  v128_t t02 = wasm_v128_load(ptr + 8); // c3 a4 b4 c4
-
-  v128_t t10 = wasm_i8x16_shuffle(t00, t01, 0, 1, 2, 3, 12, 13, 14, 15, 24, 25,
-                                  26, 27, 4, 5, 6, 7);
-  v128_t t11 = wasm_i8x16_shuffle(t00, t01, 4, 5, 6, 7, 16, 17, 18, 19, 28, 29,
-                                  30, 31, 0, 1, 2, 3);
-  v128_t t12 = wasm_i8x16_shuffle(t00, t01, 8, 9, 10, 11, 20, 21, 22, 23, 0, 1,
-                                  2, 3, 4, 5, 6, 7);
-
-  a.val = wasm_i8x16_shuffle(t10, t02, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 20,
-                             21, 22, 23);
-  b.val = wasm_i8x16_shuffle(t11, t02, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 24,
-                             25, 26, 27);
-  c.val = wasm_i8x16_shuffle(t12, t02, 0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19,
-                             28, 29, 30, 31);
-}
-
-inline void v_load_deinterleave(const unsigned *ptr, v_uint32x4 &a,
-                                v_uint32x4 &b, v_uint32x4 &c, v_uint32x4 &d) {
-  v_uint32x4 s0(wasm_v128_load(ptr));      // a0 b0 c0 d0
-  v_uint32x4 s1(wasm_v128_load(ptr + 4));  // a1 b1 c1 d1
-  v_uint32x4 s2(wasm_v128_load(ptr + 8));  // a2 b2 c2 d2
-  v_uint32x4 s3(wasm_v128_load(ptr + 12)); // a3 b3 c3 d3
-
-  v_transpose4x4(s0, s1, s2, s3, a, b, c, d);
-}
-
-inline void v_load_deinterleave(const float *ptr, v_float32x4 &a,
-                                v_float32x4 &b) {
-  v128_t v0 = wasm_v128_load(ptr);       // a0 b0 a1 b1
-  v128_t v1 = wasm_v128_load((ptr + 4)); // a2 b2 a3 b3
-
-  a.val = wasm_i8x16_shuffle(v0, v1, 0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19,
-                             24, 25, 26, 27); // a0 a1 a2 a3
-  b.val = wasm_i8x16_shuffle(v0, v1, 4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23,
-                             28, 29, 30, 31); // b0 b1 b2 b3
-}
-
-inline void v_load_deinterleave(const float *ptr, v_float32x4 &a,
-                                v_float32x4 &b, v_float32x4 &c) {
-  v128_t t00 = wasm_v128_load(ptr);     // a0 b0 c0 a1
-  v128_t t01 = wasm_v128_load(ptr + 4); // b2 c2 a3 b3
-  v128_t t02 = wasm_v128_load(ptr + 8); // c3 a4 b4 c4
-
-  v128_t t10 = wasm_i8x16_shuffle(t00, t01, 0, 1, 2, 3, 12, 13, 14, 15, 24, 25,
-                                  26, 27, 4, 5, 6, 7);
-  v128_t t11 = wasm_i8x16_shuffle(t00, t01, 4, 5, 6, 7, 16, 17, 18, 19, 28, 29,
-                                  30, 31, 0, 1, 2, 3);
-  v128_t t12 = wasm_i8x16_shuffle(t00, t01, 8, 9, 10, 11, 20, 21, 22, 23, 0, 1,
-                                  2, 3, 4, 5, 6, 7);
-
-  a.val = wasm_i8x16_shuffle(t10, t02, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 20,
-                             21, 22, 23);
-  b.val = wasm_i8x16_shuffle(t11, t02, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 24,
-                             25, 26, 27);
-  c.val = wasm_i8x16_shuffle(t12, t02, 0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19,
-                             28, 29, 30, 31);
-}
-
-inline void v_load_deinterleave(const float *ptr, v_float32x4 &a,
-                                v_float32x4 &b, v_float32x4 &c,
-                                v_float32x4 &d) {
-  v_float32x4 s0(wasm_v128_load(ptr));      // a0 b0 c0 d0
-  v_float32x4 s1(wasm_v128_load(ptr + 4));  // a1 b1 c1 d1
-  v_float32x4 s2(wasm_v128_load(ptr + 8));  // a2 b2 c2 d2
-  v_float32x4 s3(wasm_v128_load(ptr + 12)); // a3 b3 c3 d3
-
-  v_transpose4x4(s0, s1, s2, s3, a, b, c, d);
-}
-
-inline void v_load_deinterleave(const uint64 *ptr, v_uint64x2 &a,
-                                v_uint64x2 &b) {
-  v128_t t0 = wasm_v128_load(ptr);     // a0 b0
-  v128_t t1 = wasm_v128_load(ptr + 2); // a1 b1
-
-  a.val = wasm_unpacklo_i64x2(t0, t1);
-  b.val = wasm_unpackhi_i64x2(t0, t1);
-}
-
-inline void v_load_deinterleave(const uint64 *ptr, v_uint64x2 &a, v_uint64x2 &b,
-                                v_uint64x2 &c) {
-  v128_t t0 = wasm_v128_load(ptr);     // a0, b0
-  v128_t t1 = wasm_v128_load(ptr + 2); // c0, a1
-  v128_t t2 = wasm_v128_load(ptr + 4); // b1, c1
-
-  a.val = wasm_i8x16_shuffle(t0, t1, 0, 1, 2, 3, 4, 5, 6, 7, 24, 25, 26, 27, 28,
-                             29, 30, 31);
-  b.val = wasm_i8x16_shuffle(t0, t2, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
-                             19, 20, 21, 22, 23);
-  c.val = wasm_i8x16_shuffle(t1, t2, 0, 1, 2, 3, 4, 5, 6, 7, 24, 25, 26, 27, 28,
-                             29, 30, 31);
-}
-
-inline void v_load_deinterleave(const uint64 *ptr, v_uint64x2 &a, v_uint64x2 &b,
-                                v_uint64x2 &c, v_uint64x2 &d) {
-  v128_t t0 = wasm_v128_load(ptr);     // a0 b0
-  v128_t t1 = wasm_v128_load(ptr + 2); // c0 d0
-  v128_t t2 = wasm_v128_load(ptr + 4); // a1 b1
-  v128_t t3 = wasm_v128_load(ptr + 6); // c1 d1
-
-  a.val = wasm_unpacklo_i64x2(t0, t2);
-  b.val = wasm_unpackhi_i64x2(t0, t2);
-  c.val = wasm_unpacklo_i64x2(t1, t3);
-  d.val = wasm_unpackhi_i64x2(t1, t3);
-}
-
-// store interleave
-
-inline void v_store_interleave(uchar *ptr, const v_uint8x16 &a,
-                               const v_uint8x16 &b,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  v128_t v0 = wasm_unpacklo_i8x16(a.val, b.val);
-  v128_t v1 = wasm_unpackhi_i8x16(a.val, b.val);
-
-  wasm_v128_store(ptr, v0);
-  wasm_v128_store(ptr + 16, v1);
-}
-
-inline void v_store_interleave(uchar *ptr, const v_uint8x16 &a,
-                               const v_uint8x16 &b, const v_uint8x16 &c,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  v128_t t00 = wasm_i8x16_shuffle(a.val, b.val, 0, 16, 0, 1, 17, 0, 2, 18, 0, 3,
-                                  19, 0, 4, 20, 0, 5);
-  v128_t t01 = wasm_i8x16_shuffle(a.val, b.val, 21, 0, 6, 22, 0, 7, 23, 0, 8,
-                                  24, 0, 9, 25, 0, 10, 26);
-  v128_t t02 = wasm_i8x16_shuffle(a.val, b.val, 0, 11, 27, 0, 12, 28, 0, 13, 29,
-                                  0, 14, 30, 0, 15, 31, 0);
-
-  v128_t t10 = wasm_i8x16_shuffle(t00, c.val, 0, 1, 16, 3, 4, 17, 6, 7, 18, 9,
-                                  10, 19, 12, 13, 20, 15);
-  v128_t t11 = wasm_i8x16_shuffle(t01, c.val, 0, 21, 2, 3, 22, 5, 6, 23, 8, 9,
-                                  24, 11, 12, 25, 14, 15);
-  v128_t t12 = wasm_i8x16_shuffle(t02, c.val, 26, 1, 2, 27, 4, 5, 28, 7, 8, 29,
-                                  10, 11, 30, 13, 14, 31);
-
-  wasm_v128_store(ptr, t10);
-  wasm_v128_store(ptr + 16, t11);
-  wasm_v128_store(ptr + 32, t12);
-}
-
-inline void v_store_interleave(uchar *ptr, const v_uint8x16 &a,
-                               const v_uint8x16 &b, const v_uint8x16 &c,
-                               const v_uint8x16 &d,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  // a0 a1 a2 a3 ....
-  // b0 b1 b2 b3 ....
-  // c0 c1 c2 c3 ....
-  // d0 d1 d2 d3 ....
-  v128_t u0 = wasm_unpacklo_i8x16(a.val, c.val); // a0 c0 a1 c1 ...
-  v128_t u1 = wasm_unpackhi_i8x16(a.val, c.val); // a8 c8 a9 c9 ...
-  v128_t u2 = wasm_unpacklo_i8x16(b.val, d.val); // b0 d0 b1 d1 ...
-  v128_t u3 = wasm_unpackhi_i8x16(b.val, d.val); // b8 d8 b9 d9 ...
-
-  v128_t v0 = wasm_unpacklo_i8x16(u0, u2); // a0 b0 c0 d0 ...
-  v128_t v1 = wasm_unpackhi_i8x16(u0, u2); // a4 b4 c4 d4 ...
-  v128_t v2 = wasm_unpacklo_i8x16(u1, u3); // a8 b8 c8 d8 ...
-  v128_t v3 = wasm_unpackhi_i8x16(u1, u3); // a12 b12 c12 d12 ...
-
-  wasm_v128_store(ptr, v0);
-  wasm_v128_store(ptr + 16, v1);
-  wasm_v128_store(ptr + 32, v2);
-  wasm_v128_store(ptr + 48, v3);
-}
-
-inline void v_store_interleave(ushort *ptr, const v_uint16x8 &a,
-                               const v_uint16x8 &b,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  v128_t v0 = wasm_unpacklo_i16x8(a.val, b.val);
-  v128_t v1 = wasm_unpackhi_i16x8(a.val, b.val);
-
-  wasm_v128_store(ptr, v0);
-  wasm_v128_store(ptr + 8, v1);
-}
-
-inline void v_store_interleave(ushort *ptr, const v_uint16x8 &a,
-                               const v_uint16x8 &b, const v_uint16x8 &c,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  v128_t t00 = wasm_i8x16_shuffle(a.val, b.val, 0, 1, 16, 17, 0, 0, 2, 3, 18,
-                                  19, 0, 0, 4, 5, 20, 21);
-  v128_t t01 = wasm_i8x16_shuffle(a.val, b.val, 0, 0, 6, 7, 22, 23, 0, 0, 8, 9,
-                                  24, 25, 0, 0, 10, 11);
-  v128_t t02 = wasm_i8x16_shuffle(a.val, b.val, 26, 27, 0, 0, 12, 13, 28, 29, 0,
-                                  0, 14, 15, 30, 31, 0, 0);
-
-  v128_t t10 = wasm_i8x16_shuffle(t00, c.val, 0, 1, 2, 3, 16, 17, 6, 7, 8, 9,
-                                  18, 19, 12, 13, 14, 15);
-  v128_t t11 = wasm_i8x16_shuffle(t01, c.val, 20, 21, 2, 3, 4, 5, 22, 23, 8, 9,
-                                  10, 11, 24, 25, 14, 15);
-  v128_t t12 = wasm_i8x16_shuffle(t02, c.val, 0, 1, 26, 27, 4, 5, 6, 7, 28, 29,
-                                  10, 11, 12, 13, 30, 31);
-
-  wasm_v128_store(ptr, t10);
-  wasm_v128_store(ptr + 8, t11);
-  wasm_v128_store(ptr + 16, t12);
-}
-
-inline void v_store_interleave(ushort *ptr, const v_uint16x8 &a,
-                               const v_uint16x8 &b, const v_uint16x8 &c,
-                               const v_uint16x8 &d,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  // a0 a1 a2 a3 ....
-  // b0 b1 b2 b3 ....
-  // c0 c1 c2 c3 ....
-  // d0 d1 d2 d3 ....
-  v128_t u0 = wasm_unpacklo_i16x8(a.val, c.val); // a0 c0 a1 c1 ...
-  v128_t u1 = wasm_unpackhi_i16x8(a.val, c.val); // a4 c4 a5 c5 ...
-  v128_t u2 = wasm_unpacklo_i16x8(b.val, d.val); // b0 d0 b1 d1 ...
-  v128_t u3 = wasm_unpackhi_i16x8(b.val, d.val); // b4 d4 b5 d5 ...
-
-  v128_t v0 = wasm_unpacklo_i16x8(u0, u2); // a0 b0 c0 d0 ...
-  v128_t v1 = wasm_unpackhi_i16x8(u0, u2); // a2 b2 c2 d2 ...
-  v128_t v2 = wasm_unpacklo_i16x8(u1, u3); // a4 b4 c4 d4 ...
-  v128_t v3 = wasm_unpackhi_i16x8(u1, u3); // a6 b6 c6 d6 ...
-
-  wasm_v128_store(ptr, v0);
-  wasm_v128_store(ptr + 8, v1);
-  wasm_v128_store(ptr + 16, v2);
-  wasm_v128_store(ptr + 24, v3);
-}
-
-inline void v_store_interleave(unsigned *ptr, const v_uint32x4 &a,
-                               const v_uint32x4 &b,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  v128_t v0 = wasm_unpacklo_i32x4(a.val, b.val);
-  v128_t v1 = wasm_unpackhi_i32x4(a.val, b.val);
-
-  wasm_v128_store(ptr, v0);
-  wasm_v128_store(ptr + 4, v1);
-}
-
-inline void v_store_interleave(unsigned *ptr, const v_uint32x4 &a,
-                               const v_uint32x4 &b, const v_uint32x4 &c,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  v128_t t00 = wasm_i8x16_shuffle(a.val, b.val, 0, 1, 2, 3, 16, 17, 18, 19, 0,
-                                  0, 0, 0, 4, 5, 6, 7);
-  v128_t t01 = wasm_i8x16_shuffle(a.val, b.val, 20, 21, 22, 23, 0, 0, 0, 0, 8,
-                                  9, 10, 11, 24, 25, 26, 27);
-  v128_t t02 = wasm_i8x16_shuffle(a.val, b.val, 0, 0, 0, 0, 12, 13, 14, 15, 28,
-                                  29, 30, 31, 0, 0, 0, 0);
-
-  v128_t t10 = wasm_i8x16_shuffle(t00, c.val, 0, 1, 2, 3, 4, 5, 6, 7, 16, 17,
-                                  18, 19, 12, 13, 14, 15);
-  v128_t t11 = wasm_i8x16_shuffle(t01, c.val, 0, 1, 2, 3, 20, 21, 22, 23, 8, 9,
-                                  10, 11, 12, 13, 14, 15);
-  v128_t t12 = wasm_i8x16_shuffle(t02, c.val, 24, 25, 26, 27, 4, 5, 6, 7, 8, 9,
-                                  10, 11, 28, 29, 30, 31);
-
-  wasm_v128_store(ptr, t10);
-  wasm_v128_store(ptr + 4, t11);
-  wasm_v128_store(ptr + 8, t12);
-}
-
-inline void v_store_interleave(unsigned *ptr, const v_uint32x4 &a,
-                               const v_uint32x4 &b, const v_uint32x4 &c,
-                               const v_uint32x4 &d,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  v_uint32x4 v0, v1, v2, v3;
-  v_transpose4x4(a, b, c, d, v0, v1, v2, v3);
-
-  wasm_v128_store(ptr, v0.val);
-  wasm_v128_store(ptr + 4, v1.val);
-  wasm_v128_store(ptr + 8, v2.val);
-  wasm_v128_store(ptr + 12, v3.val);
-}
-
-// 2-channel, float only
-inline void v_store_interleave(float *ptr, const v_float32x4 &a,
-                               const v_float32x4 &b,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  v128_t v0 = wasm_unpacklo_i32x4(a.val, b.val);
-  v128_t v1 = wasm_unpackhi_i32x4(a.val, b.val);
-
-  wasm_v128_store(ptr, v0);
-  wasm_v128_store(ptr + 4, v1);
-}
-
-inline void v_store_interleave(float *ptr, const v_float32x4 &a,
-                               const v_float32x4 &b, const v_float32x4 &c,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  v128_t t00 = wasm_i8x16_shuffle(a.val, b.val, 0, 1, 2, 3, 16, 17, 18, 19, 0,
-                                  0, 0, 0, 4, 5, 6, 7);
-  v128_t t01 = wasm_i8x16_shuffle(a.val, b.val, 20, 21, 22, 23, 0, 0, 0, 0, 8,
-                                  9, 10, 11, 24, 25, 26, 27);
-  v128_t t02 = wasm_i8x16_shuffle(a.val, b.val, 0, 0, 0, 0, 12, 13, 14, 15, 28,
-                                  29, 30, 31, 0, 0, 0, 0);
-
-  v128_t t10 = wasm_i8x16_shuffle(t00, c.val, 0, 1, 2, 3, 4, 5, 6, 7, 16, 17,
-                                  18, 19, 12, 13, 14, 15);
-  v128_t t11 = wasm_i8x16_shuffle(t01, c.val, 0, 1, 2, 3, 20, 21, 22, 23, 8, 9,
-                                  10, 11, 12, 13, 14, 15);
-  v128_t t12 = wasm_i8x16_shuffle(t02, c.val, 24, 25, 26, 27, 4, 5, 6, 7, 8, 9,
-                                  10, 11, 28, 29, 30, 31);
-
-  wasm_v128_store(ptr, t10);
-  wasm_v128_store(ptr + 4, t11);
-  wasm_v128_store(ptr + 8, t12);
-}
-
-inline void v_store_interleave(float *ptr, const v_float32x4 &a,
-                               const v_float32x4 &b, const v_float32x4 &c,
-                               const v_float32x4 &d,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  v_float32x4 v0, v1, v2, v3;
-  v_transpose4x4(a, b, c, d, v0, v1, v2, v3);
-
-  wasm_v128_store(ptr, v0.val);
-  wasm_v128_store(ptr + 4, v1.val);
-  wasm_v128_store(ptr + 8, v2.val);
-  wasm_v128_store(ptr + 12, v3.val);
-}
-
-inline void v_store_interleave(uint64 *ptr, const v_uint64x2 &a,
-                               const v_uint64x2 &b,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  v128_t v0 = wasm_unpacklo_i64x2(a.val, b.val);
-  v128_t v1 = wasm_unpackhi_i64x2(a.val, b.val);
-
-  wasm_v128_store(ptr, v0);
-  wasm_v128_store(ptr + 2, v1);
-}
-
-inline void v_store_interleave(uint64 *ptr, const v_uint64x2 &a,
-                               const v_uint64x2 &b, const v_uint64x2 &c,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  v128_t v0 = wasm_i8x16_shuffle(a.val, b.val, 0, 1, 2, 3, 4, 5, 6, 7, 16, 17,
-                                 18, 19, 20, 21, 22, 23);
-  v128_t v1 = wasm_i8x16_shuffle(a.val, c.val, 16, 17, 18, 19, 20, 21, 22, 23,
-                                 8, 9, 10, 11, 12, 13, 14, 15);
-  v128_t v2 = wasm_i8x16_shuffle(b.val, c.val, 8, 9, 10, 11, 12, 13, 14, 15, 24,
-                                 25, 26, 27, 28, 29, 30, 31);
-
-  wasm_v128_store(ptr, v0);
-  wasm_v128_store(ptr + 2, v1);
-  wasm_v128_store(ptr + 4, v2);
-}
-
-inline void v_store_interleave(uint64 *ptr, const v_uint64x2 &a,
-                               const v_uint64x2 &b, const v_uint64x2 &c,
-                               const v_uint64x2 &d,
-                               hal::StoreMode /*mode*/ = hal::STORE_UNALIGNED) {
-  v128_t v0 = wasm_unpacklo_i64x2(a.val, b.val);
-  v128_t v1 = wasm_unpacklo_i64x2(c.val, d.val);
-  v128_t v2 = wasm_unpackhi_i64x2(a.val, b.val);
-  v128_t v3 = wasm_unpackhi_i64x2(c.val, d.val);
-
-  wasm_v128_store(ptr, v0);
-  wasm_v128_store(ptr + 2, v1);
-  wasm_v128_store(ptr + 4, v2);
-  wasm_v128_store(ptr + 6, v3);
-}
-
-#define OPENCV_HAL_IMPL_WASM_LOADSTORE_INTERLEAVE(_Tpvec0, _Tp0, suffix0,      \
-                                                  _Tpvec1, _Tp1, suffix1)      \
-  inline void v_load_deinterleave(const _Tp0 *ptr, _Tpvec0 &a0, _Tpvec0 &b0) { \
-    _Tpvec1 a1, b1;                                                            \
-    v_load_deinterleave((const _Tp1 *)ptr, a1, b1);                            \
-    a0 = v_reinterpret_as_##suffix0(a1);                                       \
-    b0 = v_reinterpret_as_##suffix0(b1);                                       \
-  }                                                                            \
-  inline void v_load_deinterleave(const _Tp0 *ptr, _Tpvec0 &a0, _Tpvec0 &b0,   \
-                                  _Tpvec0 &c0) {                               \
-    _Tpvec1 a1, b1, c1;                                                        \
-    v_load_deinterleave((const _Tp1 *)ptr, a1, b1, c1);                        \
-    a0 = v_reinterpret_as_##suffix0(a1);                                       \
-    b0 = v_reinterpret_as_##suffix0(b1);                                       \
-    c0 = v_reinterpret_as_##suffix0(c1);                                       \
-  }                                                                            \
-  inline void v_load_deinterleave(const _Tp0 *ptr, _Tpvec0 &a0, _Tpvec0 &b0,   \
-                                  _Tpvec0 &c0, _Tpvec0 &d0) {                  \
-    _Tpvec1 a1, b1, c1, d1;                                                    \
-    v_load_deinterleave((const _Tp1 *)ptr, a1, b1, c1, d1);                    \
-    a0 = v_reinterpret_as_##suffix0(a1);                                       \
-    b0 = v_reinterpret_as_##suffix0(b1);                                       \
-    c0 = v_reinterpret_as_##suffix0(c1);                                       \
-    d0 = v_reinterpret_as_##suffix0(d1);                                       \
-  }                                                                            \
-  inline void v_store_interleave(_Tp0 *ptr, const _Tpvec0 &a0,                 \
-                                 const _Tpvec0 &b0,                            \
-                                 hal::StoreMode mode = hal::STORE_UNALIGNED) { \
-    _Tpvec1 a1 = v_reinterpret_as_##suffix1(a0);                               \
-    _Tpvec1 b1 = v_reinterpret_as_##suffix1(b0);                               \
-    v_store_interleave((_Tp1 *)ptr, a1, b1, mode);                             \
-  }                                                                            \
-  inline void v_store_interleave(_Tp0 *ptr, const _Tpvec0 &a0,                 \
-                                 const _Tpvec0 &b0, const _Tpvec0 &c0,         \
-                                 hal::StoreMode mode = hal::STORE_UNALIGNED) { \
-    _Tpvec1 a1 = v_reinterpret_as_##suffix1(a0);                               \
-    _Tpvec1 b1 = v_reinterpret_as_##suffix1(b0);                               \
-    _Tpvec1 c1 = v_reinterpret_as_##suffix1(c0);                               \
-    v_store_interleave((_Tp1 *)ptr, a1, b1, c1, mode);                         \
-  }                                                                            \
-  inline void v_store_interleave(                                              \
-      _Tp0 *ptr, const _Tpvec0 &a0, const _Tpvec0 &b0, const _Tpvec0 &c0,      \
-      const _Tpvec0 &d0, hal::StoreMode mode = hal::STORE_UNALIGNED) {         \
-    _Tpvec1 a1 = v_reinterpret_as_##suffix1(a0);                               \
-    _Tpvec1 b1 = v_reinterpret_as_##suffix1(b0);                               \
-    _Tpvec1 c1 = v_reinterpret_as_##suffix1(c0);                               \
-    _Tpvec1 d1 = v_reinterpret_as_##suffix1(d0);                               \
-    v_store_interleave((_Tp1 *)ptr, a1, b1, c1, d1, mode);                     \
-  }
-
-OPENCV_HAL_IMPL_WASM_LOADSTORE_INTERLEAVE(v_int8x16, schar, s8, v_uint8x16,
-                                          uchar, u8)
-OPENCV_HAL_IMPL_WASM_LOADSTORE_INTERLEAVE(v_int16x8, short, s16, v_uint16x8,
-                                          ushort, u16)
-OPENCV_HAL_IMPL_WASM_LOADSTORE_INTERLEAVE(v_int32x4, int, s32, v_uint32x4,
-                                          unsigned, u32)
-OPENCV_HAL_IMPL_WASM_LOADSTORE_INTERLEAVE(v_int64x2, int64, s64, v_uint64x2,
-                                          uint64, u64)
-OPENCV_HAL_IMPL_WASM_LOADSTORE_INTERLEAVE(v_float64x2, double, f64, v_uint64x2,
-                                          uint64, u64)
-
-inline v_float32x4 v_cvt_f32(const v_int32x4 &a) {
-  return v_float32x4(wasm_f32x4_convert_i32x4(a.val));
-}
-
-inline v_float32x4 v_cvt_f32(const v_float64x2 &a) {
-  double a_[2];
-  wasm_v128_store(a_, a.val);
-  float c_[4];
-  c_[0] = (float)(a_[0]);
-  c_[1] = (float)(a_[1]);
-  c_[2] = 0;
-  c_[3] = 0;
-  return v_float32x4(wasm_v128_load(c_));
-}
-
-inline v_float32x4 v_cvt_f32(const v_float64x2 &a, const v_float64x2 &b) {
-  double a_[2], b_[2];
-  wasm_v128_store(a_, a.val);
-  wasm_v128_store(b_, b.val);
-  float c_[4];
-  c_[0] = (float)(a_[0]);
-  c_[1] = (float)(a_[1]);
-  c_[2] = (float)(b_[0]);
-  c_[3] = (float)(b_[1]);
-  return v_float32x4(wasm_v128_load(c_));
-}
-
-inline v_float64x2 v_cvt_f64(const v_int32x4 &a) {
-#ifdef __wasm_unimplemented_simd128__
-  v128_t p = v128_cvti32x4_i64x2(a.val);
-  return v_float64x2(wasm_f64x2_convert_i64x2(p));
-#else
-  int a_[4];
-  wasm_v128_store(a_, a.val);
-  double c_[2];
-  c_[0] = (double)(a_[0]);
-  c_[1] = (double)(a_[1]);
-  return v_float64x2(wasm_v128_load(c_));
-#endif
-}
-
-inline v_float64x2 v_cvt_f64_high(const v_int32x4 &a) {
-#ifdef __wasm_unimplemented_simd128__
-  v128_t p = v128_cvti32x4_i64x2_high(a.val);
-  return v_float64x2(wasm_f64x2_convert_i64x2(p));
-#else
-  int a_[4];
-  wasm_v128_store(a_, a.val);
-  double c_[2];
-  c_[0] = (double)(a_[2]);
-  c_[1] = (double)(a_[3]);
-  return v_float64x2(wasm_v128_load(c_));
-#endif
-}
-
-inline v_float64x2 v_cvt_f64(const v_float32x4 &a) {
-  float a_[4];
-  wasm_v128_store(a_, a.val);
-  double c_[2];
-  c_[0] = (double)(a_[0]);
-  c_[1] = (double)(a_[1]);
-  return v_float64x2(wasm_v128_load(c_));
-}
-
-inline v_float64x2 v_cvt_f64_high(const v_float32x4 &a) {
-  float a_[4];
-  wasm_v128_store(a_, a.val);
-  double c_[2];
-  c_[0] = (double)(a_[2]);
-  c_[1] = (double)(a_[3]);
-  return v_float64x2(wasm_v128_load(c_));
-}
-
-inline v_float64x2 v_cvt_f64(const v_int64x2 &a) {
-#ifdef __wasm_unimplemented_simd128__
-  return v_float64x2(wasm_f64x2_convert_i64x2(a.val));
-#else
-  int64 a_[2];
-  wasm_v128_store(a_, a.val);
-  double c_[2];
-  c_[0] = (double)(a_[0]);
-  c_[1] = (double)(a_[1]);
-  return v_float64x2(wasm_v128_load(c_));
-#endif
-}
-
-////////////// Lookup table access ////////////////////
-
-inline v_int8x16 v_lut(const schar *tab, const int *idx) {
-  return v_int8x16(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]],
-                   tab[idx[4]], tab[idx[5]], tab[idx[6]], tab[idx[7]],
-                   tab[idx[8]], tab[idx[9]], tab[idx[10]], tab[idx[11]],
-                   tab[idx[12]], tab[idx[13]], tab[idx[14]], tab[idx[15]]);
-}
-inline v_int8x16 v_lut_pairs(const schar *tab, const int *idx) {
-  return v_int8x16(tab[idx[0]], tab[idx[0] + 1], tab[idx[1]], tab[idx[1] + 1],
-                   tab[idx[2]], tab[idx[2] + 1], tab[idx[3]], tab[idx[3] + 1],
-                   tab[idx[4]], tab[idx[4] + 1], tab[idx[5]], tab[idx[5] + 1],
-                   tab[idx[6]], tab[idx[6] + 1], tab[idx[7]], tab[idx[7] + 1]);
-}
-inline v_int8x16 v_lut_quads(const schar *tab, const int *idx) {
-  return v_int8x16(
-      tab[idx[0]], tab[idx[0] + 1], tab[idx[0] + 2], tab[idx[0] + 3],
-      tab[idx[1]], tab[idx[1] + 1], tab[idx[1] + 2], tab[idx[1] + 3],
-      tab[idx[2]], tab[idx[2] + 1], tab[idx[2] + 2], tab[idx[2] + 3],
-      tab[idx[3]], tab[idx[3] + 1], tab[idx[3] + 2], tab[idx[3] + 3]);
-}
-inline v_uint8x16 v_lut(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v_lut((const schar *)tab, idx));
-}
-inline v_uint8x16 v_lut_pairs(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v_lut_pairs((const schar *)tab, idx));
-}
-inline v_uint8x16 v_lut_quads(const uchar *tab, const int *idx) {
-  return v_reinterpret_as_u8(v_lut_quads((const schar *)tab, idx));
-}
-
-inline v_int16x8 v_lut(const short *tab, const int *idx) {
-  return v_int16x8(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]],
-                   tab[idx[4]], tab[idx[5]], tab[idx[6]], tab[idx[7]]);
-}
-inline v_int16x8 v_lut_pairs(const short *tab, const int *idx) {
-  return v_int16x8(tab[idx[0]], tab[idx[0] + 1], tab[idx[1]], tab[idx[1] + 1],
-                   tab[idx[2]], tab[idx[2] + 1], tab[idx[3]], tab[idx[3] + 1]);
-}
-inline v_int16x8 v_lut_quads(const short *tab, const int *idx) {
-  return v_int16x8(tab[idx[0]], tab[idx[0] + 1], tab[idx[0] + 2],
-                   tab[idx[0] + 3], tab[idx[1]], tab[idx[1] + 1],
-                   tab[idx[1] + 2], tab[idx[1] + 3]);
-}
-inline v_uint16x8 v_lut(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v_lut((const short *)tab, idx));
-}
-inline v_uint16x8 v_lut_pairs(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v_lut_pairs((const short *)tab, idx));
-}
-inline v_uint16x8 v_lut_quads(const ushort *tab, const int *idx) {
-  return v_reinterpret_as_u16(v_lut_quads((const short *)tab, idx));
-}
-
-inline v_int32x4 v_lut(const int *tab, const int *idx) {
-  return v_int32x4(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]);
-}
-inline v_int32x4 v_lut_pairs(const int *tab, const int *idx) {
-  return v_int32x4(tab[idx[0]], tab[idx[0] + 1], tab[idx[1]], tab[idx[1] + 1]);
-}
-inline v_int32x4 v_lut_quads(const int *tab, const int *idx) {
-  return v_int32x4(wasm_v128_load(tab + idx[0]));
-}
-inline v_uint32x4 v_lut(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v_lut((const int *)tab, idx));
-}
-inline v_uint32x4 v_lut_pairs(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v_lut_pairs((const int *)tab, idx));
-}
-inline v_uint32x4 v_lut_quads(const unsigned *tab, const int *idx) {
-  return v_reinterpret_as_u32(v_lut_quads((const int *)tab, idx));
-}
-
-inline v_int64x2 v_lut(const int64_t *tab, const int *idx) {
-  return v_int64x2(tab[idx[0]], tab[idx[1]]);
-}
-inline v_int64x2 v_lut_pairs(const int64_t *tab, const int *idx) {
-  return v_int64x2(wasm_v128_load(tab + idx[0]));
-}
-inline v_uint64x2 v_lut(const uint64_t *tab, const int *idx) {
-  return v_reinterpret_as_u64(v_lut((const int64_t *)tab, idx));
-}
-inline v_uint64x2 v_lut_pairs(const uint64_t *tab, const int *idx) {
-  return v_reinterpret_as_u64(v_lut_pairs((const int64_t *)tab, idx));
-}
-
-inline v_float32x4 v_lut(const float *tab, const int *idx) {
-  return v_float32x4(tab[idx[0]], tab[idx[1]], tab[idx[2]], tab[idx[3]]);
-}
-inline v_float32x4 v_lut_pairs(const float *tab, const int *idx) {
-  return v_reinterpret_as_f32(v_lut_pairs((const int *)tab, idx));
-}
-inline v_float32x4 v_lut_quads(const float *tab, const int *idx) {
-  return v_reinterpret_as_f32(v_lut_quads((const int *)tab, idx));
-}
-
-inline v_float64x2 v_lut(const double *tab, const int *idx) {
-  return v_float64x2(tab[idx[0]], tab[idx[1]]);
-}
-inline v_float64x2 v_lut_pairs(const double *tab, const int *idx) {
-  return v_float64x2(wasm_v128_load(tab + idx[0]));
-}
-
-inline v_int32x4 v_lut(const int *tab, const v_int32x4 &idxvec) {
-  return v_int32x4(tab[wasm_i32x4_extract_lane(idxvec.val, 0)],
-                   tab[wasm_i32x4_extract_lane(idxvec.val, 1)],
-                   tab[wasm_i32x4_extract_lane(idxvec.val, 2)],
-                   tab[wasm_i32x4_extract_lane(idxvec.val, 3)]);
-}
-
-inline v_uint32x4 v_lut(const unsigned *tab, const v_int32x4 &idxvec) {
-  return v_reinterpret_as_u32(v_lut((const int *)tab, idxvec));
-}
-
-inline v_float32x4 v_lut(const float *tab, const v_int32x4 &idxvec) {
-  return v_float32x4(tab[wasm_i32x4_extract_lane(idxvec.val, 0)],
-                     tab[wasm_i32x4_extract_lane(idxvec.val, 1)],
-                     tab[wasm_i32x4_extract_lane(idxvec.val, 2)],
-                     tab[wasm_i32x4_extract_lane(idxvec.val, 3)]);
-}
-
-inline v_float64x2 v_lut(const double *tab, const v_int32x4 &idxvec) {
-  return v_float64x2(tab[wasm_i32x4_extract_lane(idxvec.val, 0)],
-                     tab[wasm_i32x4_extract_lane(idxvec.val, 1)]);
-}
-
-// loads pairs from the table and deinterleaves them, e.g. returns:
-//   x = (tab[idxvec[0], tab[idxvec[1]], tab[idxvec[2]], tab[idxvec[3]]),
-//   y = (tab[idxvec[0]+1], tab[idxvec[1]+1], tab[idxvec[2]+1],
-//   tab[idxvec[3]+1])
-// note that the indices are float's indices, not the float-pair indices.
-// in theory, this function can be used to implement bilinear interpolation,
-// when idxvec are the offsets within the image.
-inline void v_lut_deinterleave(const float *tab, const v_int32x4 &idxvec,
-                               v_float32x4 &x, v_float32x4 &y) {
-  x = v_float32x4(tab[wasm_i32x4_extract_lane(idxvec.val, 0)],
-                  tab[wasm_i32x4_extract_lane(idxvec.val, 1)],
-                  tab[wasm_i32x4_extract_lane(idxvec.val, 2)],
-                  tab[wasm_i32x4_extract_lane(idxvec.val, 3)]);
-  y = v_float32x4(tab[wasm_i32x4_extract_lane(idxvec.val, 0) + 1],
-                  tab[wasm_i32x4_extract_lane(idxvec.val, 1) + 1],
-                  tab[wasm_i32x4_extract_lane(idxvec.val, 2) + 1],
-                  tab[wasm_i32x4_extract_lane(idxvec.val, 3) + 1]);
-}
-
-inline void v_lut_deinterleave(const double *tab, const v_int32x4 &idxvec,
-                               v_float64x2 &x, v_float64x2 &y) {
-  v128_t xy0 = wasm_v128_load(tab + wasm_i32x4_extract_lane(idxvec.val, 0));
-  v128_t xy1 = wasm_v128_load(tab + wasm_i32x4_extract_lane(idxvec.val, 1));
-  x.val = wasm_unpacklo_i64x2(xy0, xy1);
-  y.val = wasm_unpacklo_i64x2(xy0, xy1);
-}
-
-inline v_int8x16 v_interleave_pairs(const v_int8x16 &vec) {
-  return v_int8x16(wasm_i8x16_shuffle(vec.val, vec.val, 0, 2, 1, 3, 4, 6, 5, 7,
-                                      8, 10, 9, 11, 12, 14, 13, 15));
-}
-inline v_uint8x16 v_interleave_pairs(const v_uint8x16 &vec) {
-  return v_reinterpret_as_u8(v_interleave_pairs(v_reinterpret_as_s8(vec)));
-}
-inline v_int8x16 v_interleave_quads(const v_int8x16 &vec) {
-  return v_int8x16(wasm_i8x16_shuffle(vec.val, vec.val, 0, 4, 1, 5, 2, 6, 3, 7,
-                                      8, 12, 9, 13, 10, 14, 11, 15));
-}
-inline v_uint8x16 v_interleave_quads(const v_uint8x16 &vec) {
-  return v_reinterpret_as_u8(v_interleave_quads(v_reinterpret_as_s8(vec)));
-}
-
-inline v_int16x8 v_interleave_pairs(const v_int16x8 &vec) {
-  return v_int16x8(wasm_i8x16_shuffle(vec.val, vec.val, 0, 1, 4, 5, 2, 3, 6, 7,
-                                      8, 9, 12, 13, 10, 11, 14, 15));
-}
-inline v_uint16x8 v_interleave_pairs(const v_uint16x8 &vec) {
-  return v_reinterpret_as_u16(v_interleave_pairs(v_reinterpret_as_s16(vec)));
-}
-inline v_int16x8 v_interleave_quads(const v_int16x8 &vec) {
-  return v_int16x8(wasm_i8x16_shuffle(vec.val, vec.val, 0, 1, 8, 9, 2, 3, 10,
-                                      11, 4, 5, 12, 13, 6, 7, 14, 15));
-}
-inline v_uint16x8 v_interleave_quads(const v_uint16x8 &vec) {
-  return v_reinterpret_as_u16(v_interleave_quads(v_reinterpret_as_s16(vec)));
-}
-
-inline v_int32x4 v_interleave_pairs(const v_int32x4 &vec) {
-  return v_int32x4(wasm_i8x16_shuffle(vec.val, vec.val, 0, 1, 2, 3, 8, 9, 10,
-                                      11, 4, 5, 6, 7, 12, 13, 14, 15));
-}
-inline v_uint32x4 v_interleave_pairs(const v_uint32x4 &vec) {
-  return v_reinterpret_as_u32(v_interleave_pairs(v_reinterpret_as_s32(vec)));
-}
-inline v_float32x4 v_interleave_pairs(const v_float32x4 &vec) {
-  return v_float32x4(wasm_i8x16_shuffle(vec.val, vec.val, 0, 1, 2, 3, 8, 9, 10,
-                                        11, 4, 5, 6, 7, 12, 13, 14, 15));
-}
-
-inline v_int8x16 v_pack_triplets(const v_int8x16 &vec) {
-  return v_int8x16(wasm_i8x16_shuffle(vec.val, vec.val, 0, 1, 2, 4, 5, 6, 8, 9,
-                                      10, 12, 13, 14, 16, 16, 16, 16));
-}
-inline v_uint8x16 v_pack_triplets(const v_uint8x16 &vec) {
-  return v_reinterpret_as_u8(v_pack_triplets(v_reinterpret_as_s8(vec)));
-}
-
-inline v_int16x8 v_pack_triplets(const v_int16x8 &vec) {
-  return v_int16x8(wasm_i8x16_shuffle(vec.val, vec.val, 0, 1, 2, 3, 4, 5, 8, 9,
-                                      10, 11, 12, 13, 14, 15, 6, 7));
-}
-inline v_uint16x8 v_pack_triplets(const v_uint16x8 &vec) {
-  return v_reinterpret_as_u16(v_pack_triplets(v_reinterpret_as_s16(vec)));
-}
-
-inline v_int32x4 v_pack_triplets(const v_int32x4 &vec) { return vec; }
-inline v_uint32x4 v_pack_triplets(const v_uint32x4 &vec) { return vec; }
-inline v_float32x4 v_pack_triplets(const v_float32x4 &vec) { return vec; }
-
-template <int i, typename _Tp>
-inline typename _Tp::lane_type v_extract_n(const _Tp &a) {
-  return v_rotate_right<i>(a).get0();
-}
-
-template <int i> inline v_uint32x4 v_broadcast_element(const v_uint32x4 &a) {
-  return v_setall_u32(v_extract_n<i>(a));
-}
-template <int i> inline v_int32x4 v_broadcast_element(const v_int32x4 &a) {
-  return v_setall_s32(v_extract_n<i>(a));
-}
-template <int i> inline v_float32x4 v_broadcast_element(const v_float32x4 &a) {
-  return v_setall_f32(v_extract_n<i>(a));
-}
-
-////////////// FP16 support ///////////////////////////
-
-inline v_float32x4 v_load_expand(const hfloat *ptr) {
-  float a[4];
-  for (int i = 0; i < 4; i++)
-    a[i] = ptr[i];
-  return v_float32x4(wasm_v128_load(a));
-}
-
-inline void v_pack_store(hfloat *ptr, const v_float32x4 &v) {
-  double v_[4];
-  wasm_v128_store(v_, v.val);
-  ptr[0] = hfloat(v_[0]);
-  ptr[1] = hfloat(v_[1]);
-  ptr[2] = hfloat(v_[2]);
-  ptr[3] = hfloat(v_[3]);
-}
-
-inline void v_cleanup() {}
-
-#include "intrin_math.hpp"
-inline v_float32x4 v_exp(const v_float32x4 &x) {
-  return v_exp_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline v_float32x4 v_log(const v_float32x4 &x) {
-  return v_log_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline void v_sincos(const v_float32x4 &x, v_float32x4 &s, v_float32x4 &c) {
-  v_sincos_default_32f<v_float32x4, v_int32x4>(x, s, c);
-}
-inline v_float32x4 v_sin(const v_float32x4 &x) {
-  return v_sin_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline v_float32x4 v_cos(const v_float32x4 &x) {
-  return v_cos_default_32f<v_float32x4, v_int32x4>(x);
-}
-inline v_float32x4 v_erf(const v_float32x4 &x) {
-  return v_erf_default_32f<v_float32x4, v_int32x4>(x);
-}
-
-inline v_float64x2 v_exp(const v_float64x2 &x) {
-  return v_exp_default_64f<v_float64x2, v_int64x2>(x);
-}
-inline v_float64x2 v_log(const v_float64x2 &x) {
-  return v_log_default_64f<v_float64x2, v_int64x2>(x);
-}
-inline void v_sincos(const v_float64x2 &x, v_float64x2 &s, v_float64x2 &c) {
-  v_sincos_default_64f<v_float64x2, v_int64x2>(x, s, c);
-}
-inline v_float64x2 v_sin(const v_float64x2 &x) {
-  return v_sin_default_64f<v_float64x2, v_int64x2>(x);
-}
-inline v_float64x2 v_cos(const v_float64x2 &x) {
-  return v_cos_default_64f<v_float64x2, v_int64x2>(x);
-}
-
-CV_CPU_OPTIMIZATION_HAL_NAMESPACE_END
-
-//! @endcond
-
-} // namespace cv
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/hal/msa_macros.h b/packages/react-native-executorch/third-party/include/opencv2/core/hal/msa_macros.h
deleted file mode 100644
index efd39ea22a..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/hal/msa_macros.h
+++ /dev/null
@@ -1,2079 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_CORE_HAL_MSA_MACROS_H
-#define OPENCV_CORE_HAL_MSA_MACROS_H
-
-#ifdef __mips_msa
-#include "msa.h"
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Define 64 bits vector types */
-typedef signed char v8i8 __attribute__((vector_size(8), aligned(8)));
-typedef unsigned char v8u8 __attribute__((vector_size(8), aligned(8)));
-typedef short v4i16 __attribute__((vector_size(8), aligned(8)));
-typedef unsigned short v4u16 __attribute__((vector_size(8), aligned(8)));
-typedef int v2i32 __attribute__((vector_size(8), aligned(8)));
-typedef unsigned int v2u32 __attribute__((vector_size(8), aligned(8)));
-typedef long long v1i64 __attribute__((vector_size(8), aligned(8)));
-typedef unsigned long long v1u64 __attribute__((vector_size(8), aligned(8)));
-typedef float v2f32 __attribute__((vector_size(8), aligned(8)));
-typedef double v1f64 __attribute__((vector_size(8), aligned(8)));
-
-/* Load values from the given memory a 64-bit vector. */
-#define msa_ld1_s8(__a) (*((v8i8 *)(__a)))
-#define msa_ld1_s16(__a) (*((v4i16 *)(__a)))
-#define msa_ld1_s32(__a) (*((v2i32 *)(__a)))
-#define msa_ld1_s64(__a) (*((v1i64 *)(__a)))
-#define msa_ld1_u8(__a) (*((v8u8 *)(__a)))
-#define msa_ld1_u16(__a) (*((v4u16 *)(__a)))
-#define msa_ld1_u32(__a) (*((v2u32 *)(__a)))
-#define msa_ld1_u64(__a) (*((v1u64 *)(__a)))
-#define msa_ld1_f32(__a) (*((v2f32 *)(__a)))
-#define msa_ld1_f64(__a) (*((v1f64 *)(__a)))
-
-/* Load values from the given memory address to a 128-bit vector */
-#define msa_ld1q_s8(__a) ((v16i8)__builtin_msa_ld_b(__a, 0))
-#define msa_ld1q_s16(__a) ((v8i16)__builtin_msa_ld_h(__a, 0))
-#define msa_ld1q_s32(__a) ((v4i32)__builtin_msa_ld_w(__a, 0))
-#define msa_ld1q_s64(__a) ((v2i64)__builtin_msa_ld_d(__a, 0))
-#define msa_ld1q_u8(__a) ((v16u8)__builtin_msa_ld_b(__a, 0))
-#define msa_ld1q_u16(__a) ((v8u16)__builtin_msa_ld_h(__a, 0))
-#define msa_ld1q_u32(__a) ((v4u32)__builtin_msa_ld_w(__a, 0))
-#define msa_ld1q_u64(__a) ((v2u64)__builtin_msa_ld_d(__a, 0))
-#define msa_ld1q_f32(__a) ((v4f32)__builtin_msa_ld_w(__a, 0))
-#define msa_ld1q_f64(__a) ((v2f64)__builtin_msa_ld_d(__a, 0))
-
-/* Store 64bits vector elements values to the given memory address. */
-#define msa_st1_s8(__a, __b) (*((v8i8 *)(__a)) = __b)
-#define msa_st1_s16(__a, __b) (*((v4i16 *)(__a)) = __b)
-#define msa_st1_s32(__a, __b) (*((v2i32 *)(__a)) = __b)
-#define msa_st1_s64(__a, __b) (*((v1i64 *)(__a)) = __b)
-#define msa_st1_u8(__a, __b) (*((v8u8 *)(__a)) = __b)
-#define msa_st1_u16(__a, __b) (*((v4u16 *)(__a)) = __b)
-#define msa_st1_u32(__a, __b) (*((v2u32 *)(__a)) = __b)
-#define msa_st1_u64(__a, __b) (*((v1u64 *)(__a)) = __b)
-#define msa_st1_f32(__a, __b) (*((v2f32 *)(__a)) = __b)
-#define msa_st1_f64(__a, __b) (*((v1f64 *)(__a)) = __b)
-
-/* Store the values of elements in the 128 bits vector __a to the given memory
- * address __a. */
-#define msa_st1q_s8(__a, __b) (__builtin_msa_st_b((v16i8)(__b), __a, 0))
-#define msa_st1q_s16(__a, __b) (__builtin_msa_st_h((v8i16)(__b), __a, 0))
-#define msa_st1q_s32(__a, __b) (__builtin_msa_st_w((v4i32)(__b), __a, 0))
-#define msa_st1q_s64(__a, __b) (__builtin_msa_st_d((v2i64)(__b), __a, 0))
-#define msa_st1q_u8(__a, __b) (__builtin_msa_st_b((v16i8)(__b), __a, 0))
-#define msa_st1q_u16(__a, __b) (__builtin_msa_st_h((v8i16)(__b), __a, 0))
-#define msa_st1q_u32(__a, __b) (__builtin_msa_st_w((v4i32)(__b), __a, 0))
-#define msa_st1q_u64(__a, __b) (__builtin_msa_st_d((v2i64)(__b), __a, 0))
-#define msa_st1q_f32(__a, __b) (__builtin_msa_st_w((v4i32)(__b), __a, 0))
-#define msa_st1q_f64(__a, __b) (__builtin_msa_st_d((v2i64)(__b), __a, 0))
-
-/* Store the value of the element with the index __c in vector __a to the given
- * memory address __a. */
-#define msa_st1_lane_s8(__a, __b, __c) (*((int8_t *)(__a)) = __b[__c])
-#define msa_st1_lane_s16(__a, __b, __c) (*((int16_t *)(__a)) = __b[__c])
-#define msa_st1_lane_s32(__a, __b, __c) (*((int32_t *)(__a)) = __b[__c])
-#define msa_st1_lane_s64(__a, __b, __c) (*((int64_t *)(__a)) = __b[__c])
-#define msa_st1_lane_u8(__a, __b, __c) (*((uint8_t *)(__a)) = __b[__c])
-#define msa_st1_lane_u16(__a, __b, __c) (*((uint16_t *)(__a)) = __b[__c])
-#define msa_st1_lane_u32(__a, __b, __c) (*((uint32_t *)(__a)) = __b[__c])
-#define msa_st1_lane_u64(__a, __b, __c) (*((uint64_t *)(__a)) = __b[__c])
-#define msa_st1_lane_f32(__a, __b, __c) (*((float *)(__a)) = __b[__c])
-#define msa_st1_lane_f64(__a, __b, __c) (*((double *)(__a)) = __b[__c])
-#define msa_st1q_lane_s8(__a, __b, __c)                                        \
-  (*((int8_t *)(__a)) = (int8_t)__builtin_msa_copy_s_b(__b, __c))
-#define msa_st1q_lane_s16(__a, __b, __c)                                       \
-  (*((int16_t *)(__a)) = (int16_t)__builtin_msa_copy_s_h(__b, __c))
-#define msa_st1q_lane_s32(__a, __b, __c)                                       \
-  (*((int32_t *)(__a)) = __builtin_msa_copy_s_w(__b, __c))
-#define msa_st1q_lane_s64(__a, __b, __c)                                       \
-  (*((int64_t *)(__a)) = __builtin_msa_copy_s_d(__b, __c))
-#define msa_st1q_lane_u8(__a, __b, __c)                                        \
-  (*((uint8_t *)(__a)) = (uint8_t)__builtin_msa_copy_u_b((v16i8)(__b), __c))
-#define msa_st1q_lane_u16(__a, __b, __c)                                       \
-  (*((uint16_t *)(__a)) = (uint16_t)__builtin_msa_copy_u_h((v8i16)(__b), __c))
-#define msa_st1q_lane_u32(__a, __b, __c)                                       \
-  (*((uint32_t *)(__a)) = __builtin_msa_copy_u_w((v4i32)(__b), __c))
-#define msa_st1q_lane_u64(__a, __b, __c)                                       \
-  (*((uint64_t *)(__a)) = __builtin_msa_copy_u_d((v2i64)(__b), __c))
-#define msa_st1q_lane_f32(__a, __b, __c) (*((float *)(__a)) = __b[__c])
-#define msa_st1q_lane_f64(__a, __b, __c) (*((double *)(__a)) = __b[__c])
-
-/* Duplicate elements for 64-bit doubleword vectors */
-#define msa_dup_n_s8(__a)                                                      \
-  ((v8i8)__builtin_msa_copy_s_d((v2i64)__builtin_msa_fill_b((int32_t)(__a)), 0))
-#define msa_dup_n_s16(__a)                                                     \
-  ((v4i16)__builtin_msa_copy_s_d((v2i64)__builtin_msa_fill_h((int32_t)(__a)),  \
-                                 0))
-#define msa_dup_n_s32(__a) ((v2i32){__a, __a})
-#define msa_dup_n_s64(__a) ((v1i64){__a})
-#define msa_dup_n_u8(__a)                                                      \
-  ((v8u8)__builtin_msa_copy_u_d((v2i64)__builtin_msa_fill_b((int32_t)(__a)), 0))
-#define msa_dup_n_u16(__a)                                                     \
-  ((v4u16)__builtin_msa_copy_u_d((v2i64)__builtin_msa_fill_h((int32_t)(__a)),  \
-                                 0))
-#define msa_dup_n_u32(__a) ((v2u32){__a, __a})
-#define msa_dup_n_u64(__a) ((v1u64){__a})
-#define msa_dup_n_f32(__a) ((v2f32){__a, __a})
-#define msa_dup_n_f64(__a) ((v1f64){__a})
-
-/* Duplicate elements for 128-bit quadword vectors */
-#define msa_dupq_n_s8(__a) (__builtin_msa_fill_b((int32_t)(__a)))
-#define msa_dupq_n_s16(__a) (__builtin_msa_fill_h((int32_t)(__a)))
-#define msa_dupq_n_s32(__a) (__builtin_msa_fill_w((int32_t)(__a)))
-#define msa_dupq_n_s64(__a) (__builtin_msa_fill_d((int64_t)(__a)))
-#define msa_dupq_n_u8(__a) ((v16u8)__builtin_msa_fill_b((int32_t)(__a)))
-#define msa_dupq_n_u16(__a) ((v8u16)__builtin_msa_fill_h((int32_t)(__a)))
-#define msa_dupq_n_u32(__a) ((v4u32)__builtin_msa_fill_w((int32_t)(__a)))
-#define msa_dupq_n_u64(__a) ((v2u64)__builtin_msa_fill_d((int64_t)(__a)))
-#define msa_dupq_n_f32(__a) ((v4f32){__a, __a, __a, __a})
-#define msa_dupq_n_f64(__a) ((v2f64){__a, __a})
-#define msa_dupq_lane_s8(__a, __b) (__builtin_msa_splat_b(__a, __b))
-#define msa_dupq_lane_s16(__a, __b) (__builtin_msa_splat_h(__a, __b))
-#define msa_dupq_lane_s32(__a, __b) (__builtin_msa_splat_w(__a, __b))
-#define msa_dupq_lane_s64(__a, __b) (__builtin_msa_splat_d(__a, __b))
-#define msa_dupq_lane_u8(__a, __b)                                             \
-  ((v16u8)__builtin_msa_splat_b((v16i8)(__a), __b))
-#define msa_dupq_lane_u16(__a, __b)                                            \
-  ((v8u16)__builtin_msa_splat_h((v8i16)(__a), __b))
-#define msa_dupq_lane_u32(__a, __b)                                            \
-  ((v4u32)__builtin_msa_splat_w((v4i32)(__a), __b))
-#define msa_dupq_lane_u64(__a, __b)                                            \
-  ((v2u64)__builtin_msa_splat_d((v2i64)(__a), __b))
-
-/* Create a 64 bits vector */
-#define msa_create_s8(__a) ((v8i8)((uint64_t)(__a)))
-#define msa_create_s16(__a) ((v4i16)((uint64_t)(__a)))
-#define msa_create_s32(__a) ((v2i32)((uint64_t)(__a)))
-#define msa_create_s64(__a) ((v1i64)((uint64_t)(__a)))
-#define msa_create_u8(__a) ((v8u8)((uint64_t)(__a)))
-#define msa_create_u16(__a) ((v4u16)((uint64_t)(__a)))
-#define msa_create_u32(__a) ((v2u32)((uint64_t)(__a)))
-#define msa_create_u64(__a) ((v1u64)((uint64_t)(__a)))
-#define msa_create_f32(__a) ((v2f32)((uint64_t)(__a)))
-#define msa_create_f64(__a) ((v1f64)((uint64_t)(__a)))
-
-/* Sign extends or zero extends each element in a 64 bits vector to twice its
- * original length, and places the results in a 128 bits vector. */
-/*Transform v8i8 to v8i16*/
-#define msa_movl_s8(__a)                                                       \
-  ((v8i16){(__a)[0], (__a)[1], (__a)[2], (__a)[3], (__a)[4], (__a)[5],         \
-           (__a)[6], (__a)[7]})
-
-/*Transform v8u8 to v8u16*/
-#define msa_movl_u8(__a)                                                       \
-  ((v8u16){(__a)[0], (__a)[1], (__a)[2], (__a)[3], (__a)[4], (__a)[5],         \
-           (__a)[6], (__a)[7]})
-
-/*Transform v4i16 to v8i16*/
-#define msa_movl_s16(__a) ((v4i32){(__a)[0], (__a)[1], (__a)[2], (__a)[3]})
-
-/*Transform v2i32 to v4i32*/
-#define msa_movl_s32(__a) ((v2i64){(__a)[0], (__a)[1]})
-
-/*Transform v4u16 to v8u16*/
-#define msa_movl_u16(__a) ((v4u32){(__a)[0], (__a)[1], (__a)[2], (__a)[3]})
-
-/*Transform v2u32 to v4u32*/
-#define msa_movl_u32(__a) ((v2u64){(__a)[0], (__a)[1]})
-
-/* Copies the least significant half of each element of a 128 bits vector into
- * the corresponding elements of a 64 bits vector. */
-#define msa_movn_s16(__a)                                                      \
-  ({                                                                           \
-    v16i8 __d = __builtin_msa_pckev_b(__builtin_msa_fill_b(0), (v16i8)(__a));  \
-    (v8i8) __builtin_msa_copy_s_d((v2i64)__d, 0);                              \
-  })
-
-#define msa_movn_s32(__a)                                                      \
-  ({                                                                           \
-    v8i16 __d = __builtin_msa_pckev_h(__builtin_msa_fill_h(0), (v8i16)(__a));  \
-    (v4i16) __builtin_msa_copy_s_d((v2i64)__d, 0);                             \
-  })
-
-#define msa_movn_s64(__a)                                                      \
-  ({                                                                           \
-    v4i32 __d = __builtin_msa_pckev_w(__builtin_msa_fill_w(0), (v4i32)(__a));  \
-    (v2i32) __builtin_msa_copy_s_d((v2i64)__d, 0);                             \
-  })
-
-#define msa_movn_u16(__a)                                                      \
-  ({                                                                           \
-    v16i8 __d = __builtin_msa_pckev_b(__builtin_msa_fill_b(0), (v16i8)(__a));  \
-    (v8u8) __builtin_msa_copy_u_d((v2i64)__d, 0);                              \
-  })
-
-#define msa_movn_u32(__a)                                                      \
-  ({                                                                           \
-    v8i16 __d = __builtin_msa_pckev_h(__builtin_msa_fill_h(0), (v8i16)(__a));  \
-    (v4u16) __builtin_msa_copy_u_d((v2i64)__d, 0);                             \
-  })
-
-#define msa_movn_u64(__a)                                                      \
-  ({                                                                           \
-    v4i32 __d = __builtin_msa_pckev_w(__builtin_msa_fill_w(0), (v4i32)(__a));  \
-    (v2u32) __builtin_msa_copy_u_d((v2i64)__d, 0);                             \
-  })
-
-/* qmovn */
-#define msa_qmovn_s16(__a)                                                     \
-  ({                                                                           \
-    v16i8 __d =                                                                \
-        __builtin_msa_pckev_b(__builtin_msa_fill_b(0),                         \
-                              (v16i8)__builtin_msa_sat_s_h((v8i16)(__a), 7));  \
-    (v8i8) __builtin_msa_copy_s_d((v2i64)__d, 0);                              \
-  })
-
-#define msa_qmovn_s32(__a)                                                     \
-  ({                                                                           \
-    v8i16 __d =                                                                \
-        __builtin_msa_pckev_h(__builtin_msa_fill_h(0),                         \
-                              (v8i16)__builtin_msa_sat_s_w((v4i32)(__a), 15)); \
-    (v4i16) __builtin_msa_copy_s_d((v2i64)__d, 0);                             \
-  })
-
-#define msa_qmovn_s64(__a)                                                     \
-  ({                                                                           \
-    v4i32 __d =                                                                \
-        __builtin_msa_pckev_w(__builtin_msa_fill_w(0),                         \
-                              (v4i32)__builtin_msa_sat_s_d((v2i64)(__a), 31)); \
-    (v2i32) __builtin_msa_copy_s_d((v2i64)__d, 0);                             \
-  })
-
-#define msa_qmovn_u16(__a)                                                     \
-  ({                                                                           \
-    v16i8 __d =                                                                \
-        __builtin_msa_pckev_b(__builtin_msa_fill_b(0),                         \
-                              (v16i8)__builtin_msa_sat_u_h((v8u16)(__a), 7));  \
-    (v8u8) __builtin_msa_copy_u_d((v2i64)__d, 0);                              \
-  })
-
-#define msa_qmovn_u32(__a)                                                     \
-  ({                                                                           \
-    v8i16 __d =                                                                \
-        __builtin_msa_pckev_h(__builtin_msa_fill_h(0),                         \
-                              (v8i16)__builtin_msa_sat_u_w((v4u32)(__a), 15)); \
-    (v4u16) __builtin_msa_copy_u_d((v2i64)__d, 0);                             \
-  })
-
-#define msa_qmovn_u64(__a)                                                     \
-  ({                                                                           \
-    v4i32 __d =                                                                \
-        __builtin_msa_pckev_w(__builtin_msa_fill_w(0),                         \
-                              (v4i32)__builtin_msa_sat_u_d((v2u64)(__a), 31)); \
-    (v2u32) __builtin_msa_copy_u_d((v2i64)__d, 0);                             \
-  })
-
-/* qmovun */
-#define msa_qmovun_s16(__a)                                                    \
-  ({                                                                           \
-    v8i16 __d = __builtin_msa_max_s_h(__builtin_msa_fill_h(0), (v8i16)(__a));  \
-    v16i8 __e = __builtin_msa_pckev_b(                                         \
-        __builtin_msa_fill_b(0), (v16i8)__builtin_msa_sat_u_h((v8u16)__d, 7)); \
-    (v8u8) __builtin_msa_copy_u_d((v2i64)__e, 0);                              \
-  })
-
-#define msa_qmovun_s32(__a)                                                    \
-  ({                                                                           \
-    v4i32 __d = __builtin_msa_max_s_w(__builtin_msa_fill_w(0), (v4i32)(__a));  \
-    v8i16 __e =                                                                \
-        __builtin_msa_pckev_h(__builtin_msa_fill_h(0),                         \
-                              (v8i16)__builtin_msa_sat_u_w((v4u32)__d, 15));   \
-    (v4u16) __builtin_msa_copy_u_d((v2i64)__e, 0);                             \
-  })
-
-#define msa_qmovun_s64(__a)                                                    \
-  ({                                                                           \
-    v2i64 __d = __builtin_msa_max_s_d(__builtin_msa_fill_d(0), (v2i64)(__a));  \
-    v4i32 __e =                                                                \
-        __builtin_msa_pckev_w(__builtin_msa_fill_w(0),                         \
-                              (v4i32)__builtin_msa_sat_u_d((v2u64)__d, 31));   \
-    (v2u32) __builtin_msa_copy_u_d((v2i64)__e, 0);                             \
-  })
-
-/* Right shift elements in a 128 bits vector by an immediate value, and places
- * the results in a 64 bits vector. */
-#define msa_shrn_n_s16(__a, __b)                                               \
-  ({                                                                           \
-    v16i8 __d = __builtin_msa_pckev_b(                                         \
-        __builtin_msa_fill_b(0),                                               \
-        (v16i8)__builtin_msa_srai_h((v8i16)(__a), (int)(__b)));                \
-    (v8i8) __builtin_msa_copy_s_d((v2i64)__d, 0);                              \
-  })
-
-#define msa_shrn_n_s32(__a, __b)                                               \
-  ({                                                                           \
-    v8i16 __d = __builtin_msa_pckev_h(                                         \
-        __builtin_msa_fill_h(0),                                               \
-        (v8i16)__builtin_msa_srai_w((v4i32)(__a), (int)(__b)));                \
-    (v4i16) __builtin_msa_copy_s_d((v2i64)__d, 0);                             \
-  })
-
-#define msa_shrn_n_s64(__a, __b)                                               \
-  ({                                                                           \
-    v4i32 __d = __builtin_msa_pckev_w(                                         \
-        __builtin_msa_fill_w(0),                                               \
-        (v4i32)__builtin_msa_srai_d((v2i64)(__a), (int)(__b)));                \
-    (v2i32) __builtin_msa_copy_s_d((v2i64)__d, 0);                             \
-  })
-
-#define msa_shrn_n_u16(__a, __b)                                               \
-  ({                                                                           \
-    v16i8 __d = __builtin_msa_pckev_b(                                         \
-        __builtin_msa_fill_b(0),                                               \
-        (v16i8)__builtin_msa_srli_h((v8i16)(__a), (int)(__b)));                \
-    (v8u8) __builtin_msa_copy_u_d((v2i64)__d, 0);                              \
-  })
-
-#define msa_shrn_n_u32(__a, __b)                                               \
-  ({                                                                           \
-    v8i16 __d = __builtin_msa_pckev_h(                                         \
-        __builtin_msa_fill_h(0),                                               \
-        (v8i16)__builtin_msa_srli_w((v4i32)(__a), (int)(__b)));                \
-    (v4u16) __builtin_msa_copy_u_d((v2i64)__d, 0);                             \
-  })
-
-#define msa_shrn_n_u64(__a, __b)                                               \
-  ({                                                                           \
-    v4i32 __d = __builtin_msa_pckev_w(                                         \
-        __builtin_msa_fill_w(0),                                               \
-        (v4i32)__builtin_msa_srli_d((v2i64)(__a), (int)(__b)));                \
-    (v2u32) __builtin_msa_copy_u_d((v2i64)__d, 0);                             \
-  })
-
-/* Right shift elements in a 128 bits vector by an immediate value, and places
- * the results in a 64 bits vector. */
-#define msa_rshrn_n_s16(__a, __b)                                              \
-  ({                                                                           \
-    v16i8 __d = __builtin_msa_pckev_b(                                         \
-        __builtin_msa_fill_b(0),                                               \
-        (v16i8)__builtin_msa_srari_h((v8i16)(__a), (int)__b));                 \
-    (v8i8) __builtin_msa_copy_s_d((v2i64)__d, 0);                              \
-  })
-
-#define msa_rshrn_n_s32(__a, __b)                                              \
-  ({                                                                           \
-    v8i16 __d = __builtin_msa_pckev_h(                                         \
-        __builtin_msa_fill_h(0),                                               \
-        (v8i16)__builtin_msa_srari_w((v4i32)(__a), (int)__b));                 \
-    (v4i16) __builtin_msa_copy_s_d((v2i64)__d, 0);                             \
-  })
-
-#define msa_rshrn_n_s64(__a, __b)                                              \
-  ({                                                                           \
-    v4i32 __d = __builtin_msa_pckev_w(                                         \
-        __builtin_msa_fill_w(0),                                               \
-        (v4i32)__builtin_msa_srari_d((v2i64)(__a), (int)__b));                 \
-    (v2i32) __builtin_msa_copy_s_d((v2i64)__d, 0);                             \
-  })
-
-#define msa_rshrn_n_u16(__a, __b)                                              \
-  ({                                                                           \
-    v16i8 __d = __builtin_msa_pckev_b(                                         \
-        __builtin_msa_fill_b(0),                                               \
-        (v16i8)__builtin_msa_srlri_h((v8i16)(__a), (int)__b));                 \
-    (v8u8) __builtin_msa_copy_u_d((v2i64)__d, 0);                              \
-  })
-
-#define msa_rshrn_n_u32(__a, __b)                                              \
-  ({                                                                           \
-    v8i16 __d = __builtin_msa_pckev_h(                                         \
-        __builtin_msa_fill_h(0),                                               \
-        (v8i16)__builtin_msa_srlri_w((v4i32)(__a), (int)__b));                 \
-    (v4u16) __builtin_msa_copy_u_d((v2i64)__d, 0);                             \
-  })
-
-#define msa_rshrn_n_u64(__a, __b)                                              \
-  ({                                                                           \
-    v4i32 __d = __builtin_msa_pckev_w(                                         \
-        __builtin_msa_fill_w(0),                                               \
-        (v4i32)__builtin_msa_srlri_d((v2i64)(__a), (int)__b));                 \
-    (v2u32) __builtin_msa_copy_u_d((v2i64)__d, 0);                             \
-  })
-
-/* Right shift elements in a 128 bits vector by an immediate value, saturate the
- * results and them in a 64 bits vector. */
-#define msa_qrshrn_n_s16(__a, __b)                                             \
-  ({                                                                           \
-    v8i16 __d = __builtin_msa_sat_s_h(                                         \
-        __builtin_msa_srari_h((v8i16)(__a), (int)(__b)), 7);                   \
-    v16i8 __e = __builtin_msa_pckev_b(__builtin_msa_fill_b(0), (v16i8)__d);    \
-    (v8i8) __builtin_msa_copy_s_d((v2i64)__e, 0);                              \
-  })
-
-#define msa_qrshrn_n_s32(__a, __b)                                             \
-  ({                                                                           \
-    v4i32 __d = __builtin_msa_sat_s_w(                                         \
-        __builtin_msa_srari_w((v4i32)(__a), (int)(__b)), 15);                  \
-    v8i16 __e = __builtin_msa_pckev_h(__builtin_msa_fill_h(0), (v8i16)__d);    \
-    (v4i16) __builtin_msa_copy_s_d((v2i64)__e, 0);                             \
-  })
-
-#define msa_qrshrn_n_s64(__a, __b)                                             \
-  ({                                                                           \
-    v2i64 __d = __builtin_msa_sat_s_d(                                         \
-        __builtin_msa_srari_d((v2i64)(__a), (int)(__b)), 31);                  \
-    v4i32 __e = __builtin_msa_pckev_w(__builtin_msa_fill_w(0), (v4i32)__d);    \
-    (v2i32) __builtin_msa_copy_s_d((v2i64)__e, 0);                             \
-  })
-
-#define msa_qrshrn_n_u16(__a, __b)                                             \
-  ({                                                                           \
-    v8u16 __d = __builtin_msa_sat_u_h(                                         \
-        (v8u16)__builtin_msa_srlri_h((v8i16)(__a), (int)(__b)), 7);            \
-    v16i8 __e = __builtin_msa_pckev_b(__builtin_msa_fill_b(0), (v16i8)__d);    \
-    (v8u8) __builtin_msa_copy_u_d((v2i64)__e, 0);                              \
-  })
-
-#define msa_qrshrn_n_u32(__a, __b)                                             \
-  ({                                                                           \
-    v4u32 __d = __builtin_msa_sat_u_w(                                         \
-        (v4u32)__builtin_msa_srlri_w((v4i32)(__a), (int)(__b)), 15);           \
-    v8i16 __e = __builtin_msa_pckev_h(__builtin_msa_fill_h(0), (v8i16)__d);    \
-    (v4u16) __builtin_msa_copy_u_d((v2i64)__e, 0);                             \
-  })
-
-#define msa_qrshrn_n_u64(__a, __b)                                             \
-  ({                                                                           \
-    v2u64 __d = __builtin_msa_sat_u_d(                                         \
-        (v2u64)__builtin_msa_srlri_d((v2i64)(__a), (int)(__b)), 31);           \
-    v4i32 __e = __builtin_msa_pckev_w(__builtin_msa_fill_w(0), (v4i32)__d);    \
-    (v2u32) __builtin_msa_copy_u_d((v2i64)__e, 0);                             \
-  })
-
-/* Right shift elements in a 128 bits vector by an immediate value, saturate the
-   results and them in a 64 bits vector. Input is signed and output is unsigned.
- */
-#define msa_qrshrun_n_s16(__a, __b)                                            \
-  ({                                                                           \
-    v8i16 __d = __builtin_msa_srlri_h(                                         \
-        __builtin_msa_max_s_h(__builtin_msa_fill_h(0), (v8i16)(__a)),          \
-        (int)(__b));                                                           \
-    v16i8 __e = __builtin_msa_pckev_b(                                         \
-        __builtin_msa_fill_b(0), (v16i8)__builtin_msa_sat_u_h((v8u16)__d, 7)); \
-    (v8u8) __builtin_msa_copy_u_d((v2i64)__e, 0);                              \
-  })
-
-#define msa_qrshrun_n_s32(__a, __b)                                            \
-  ({                                                                           \
-    v4i32 __d = __builtin_msa_srlri_w(                                         \
-        __builtin_msa_max_s_w(__builtin_msa_fill_w(0), (v4i32)(__a)),          \
-        (int)(__b));                                                           \
-    v8i16 __e =                                                                \
-        __builtin_msa_pckev_h(__builtin_msa_fill_h(0),                         \
-                              (v8i16)__builtin_msa_sat_u_w((v4u32)__d, 15));   \
-    (v4u16) __builtin_msa_copy_u_d((v2i64)__e, 0);                             \
-  })
-
-#define msa_qrshrun_n_s64(__a, __b)                                            \
-  ({                                                                           \
-    v2i64 __d = __builtin_msa_srlri_d(                                         \
-        __builtin_msa_max_s_d(__builtin_msa_fill_d(0), (v2i64)(__a)),          \
-        (int)(__b));                                                           \
-    v4i32 __e =                                                                \
-        __builtin_msa_pckev_w(__builtin_msa_fill_w(0),                         \
-                              (v4i32)__builtin_msa_sat_u_d((v2u64)__d, 31));   \
-    (v2u32) __builtin_msa_copy_u_d((v2i64)__e, 0);                             \
-  })
-
-/* pack */
-#define msa_pack_s16(__a, __b)                                                 \
-  (__builtin_msa_pckev_b((v16i8)(__b), (v16i8)(__a)))
-#define msa_pack_s32(__a, __b)                                                 \
-  (__builtin_msa_pckev_h((v8i16)(__b), (v8i16)(__a)))
-#define msa_pack_s64(__a, __b)                                                 \
-  (__builtin_msa_pckev_w((v4i32)(__b), (v4i32)(__a)))
-#define msa_pack_u16(__a, __b)                                                 \
-  ((v16u8)__builtin_msa_pckev_b((v16i8)(__b), (v16i8)(__a)))
-#define msa_pack_u32(__a, __b)                                                 \
-  ((v8u16)__builtin_msa_pckev_h((v8i16)(__b), (v8i16)(__a)))
-#define msa_pack_u64(__a, __b)                                                 \
-  ((v4u32)__builtin_msa_pckev_w((v4i32)(__b), (v4i32)(__a)))
-
-/* qpack */
-#define msa_qpack_s16(__a, __b)                                                \
-  (__builtin_msa_pckev_b((v16i8)__builtin_msa_sat_s_h((v8i16)(__b), 7),        \
-                         (v16i8)__builtin_msa_sat_s_h((v8i16)(__a), 7)))
-#define msa_qpack_s32(__a, __b)                                                \
-  (__builtin_msa_pckev_h((v8i16)__builtin_msa_sat_s_w((v4i32)(__b), 15),       \
-                         (v8i16)__builtin_msa_sat_s_w((v4i32)(__a), 15)))
-#define msa_qpack_s64(__a, __b)                                                \
-  (__builtin_msa_pckev_w((v4i32)__builtin_msa_sat_s_d((v2i64)(__b), 31),       \
-                         (v4i32)__builtin_msa_sat_s_d((v2i64)(__a), 31)))
-#define msa_qpack_u16(__a, __b)                                                \
-  ((v16u8)__builtin_msa_pckev_b(                                               \
-      (v16i8)__builtin_msa_sat_u_h((v8u16)(__b), 7),                           \
-      (v16i8)__builtin_msa_sat_u_h((v8u16)(__a), 7)))
-#define msa_qpack_u32(__a, __b)                                                \
-  ((v8u16)__builtin_msa_pckev_h(                                               \
-      (v8i16)__builtin_msa_sat_u_w((v4u32)(__b), 15),                          \
-      (v8i16)__builtin_msa_sat_u_w((v4u32)(__a), 15)))
-#define msa_qpack_u64(__a, __b)                                                \
-  ((v4u32)__builtin_msa_pckev_w(                                               \
-      (v4i32)__builtin_msa_sat_u_d((v2u64)(__b), 31),                          \
-      (v4i32)__builtin_msa_sat_u_d((v2u64)(__a), 31)))
-
-/* qpacku */
-#define msa_qpacku_s16(__a, __b)                                               \
-  ((v16u8)__builtin_msa_pckev_b(                                               \
-      (v16i8)__builtin_msa_sat_u_h(                                            \
-          (v8u16)(__builtin_msa_max_s_h(__builtin_msa_fill_h(0),               \
-                                        (v8i16)(__b))),                        \
-          7),                                                                  \
-      (v16i8)__builtin_msa_sat_u_h(                                            \
-          (v8u16)(__builtin_msa_max_s_h(__builtin_msa_fill_h(0),               \
-                                        (v8i16)(__a))),                        \
-          7)))
-#define msa_qpacku_s32(__a, __b)                                               \
-  ((v8u16)__builtin_msa_pckev_h(                                               \
-      (v8i16)__builtin_msa_sat_u_w(                                            \
-          (v4u32)(__builtin_msa_max_s_w(__builtin_msa_fill_w(0),               \
-                                        (v4i32)(__b))),                        \
-          15),                                                                 \
-      (v8i16)__builtin_msa_sat_u_w(                                            \
-          (v4u32)(__builtin_msa_max_s_w(__builtin_msa_fill_w(0),               \
-                                        (v4i32)(__a))),                        \
-          15)))
-#define msa_qpacku_s64(__a, __b)                                               \
-  ((v4u32)__builtin_msa_pckev_w(                                               \
-      (v4i32)__builtin_msa_sat_u_d(                                            \
-          (v2u64)(__builtin_msa_max_s_d(__builtin_msa_fill_d(0),               \
-                                        (v2i64)(__b))),                        \
-          31),                                                                 \
-      (v4i32)__builtin_msa_sat_u_d(                                            \
-          (v2u64)(__builtin_msa_max_s_d(__builtin_msa_fill_d(0),               \
-                                        (v2i64)(__a))),                        \
-          31)))
-
-/* packr */
-#define msa_packr_s16(__a, __b, __c)                                           \
-  (__builtin_msa_pckev_b(                                                      \
-      (v16i8)__builtin_msa_srai_h((v8i16)(__b), (int)(__c)),                   \
-      (v16i8)__builtin_msa_srai_h((v8i16)(__a), (int)(__c))))
-#define msa_packr_s32(__a, __b, __c)                                           \
-  (__builtin_msa_pckev_h(                                                      \
-      (v8i16)__builtin_msa_srai_w((v4i32)(__b), (int)(__c)),                   \
-      (v8i16)__builtin_msa_srai_w((v4i32)(__a), (int)(__c))))
-#define msa_packr_s64(__a, __b, __c)                                           \
-  (__builtin_msa_pckev_w(                                                      \
-      (v4i32)__builtin_msa_srai_d((v2i64)(__b), (int)(__c)),                   \
-      (v4i32)__builtin_msa_srai_d((v2i64)(__a), (int)(__c))))
-#define msa_packr_u16(__a, __b, __c)                                           \
-  ((v16u8)__builtin_msa_pckev_b(                                               \
-      (v16i8)__builtin_msa_srli_h((v8i16)(__b), (int)(__c)),                   \
-      (v16i8)__builtin_msa_srli_h((v8i16)(__a), (int)(__c))))
-#define msa_packr_u32(__a, __b, __c)                                           \
-  ((v8u16)__builtin_msa_pckev_h(                                               \
-      (v8i16)__builtin_msa_srli_w((v4i32)(__b), (int)(__c)),                   \
-      (v8i16)__builtin_msa_srli_w((v4i32)(__a), (int)(__c))))
-#define msa_packr_u64(__a, __b, __c)                                           \
-  ((v4u32)__builtin_msa_pckev_w(                                               \
-      (v4i32)__builtin_msa_srli_d((v2i64)(__b), (int)(__c)),                   \
-      (v4i32)__builtin_msa_srli_d((v2i64)(__a), (int)(__c))))
-
-/* rpackr */
-#define msa_rpackr_s16(__a, __b, __c)                                          \
-  (__builtin_msa_pckev_b(                                                      \
-      (v16i8)__builtin_msa_srari_h((v8i16)(__b), (int)(__c)),                  \
-      (v16i8)__builtin_msa_srari_h((v8i16)(__a), (int)(__c))))
-#define msa_rpackr_s32(__a, __b, __c)                                          \
-  (__builtin_msa_pckev_h(                                                      \
-      (v8i16)__builtin_msa_srari_w((v4i32)(__b), (int)(__c)),                  \
-      (v8i16)__builtin_msa_srari_w((v4i32)(__a), (int)(__c))))
-#define msa_rpackr_s64(__a, __b, __c)                                          \
-  (__builtin_msa_pckev_w(                                                      \
-      (v4i32)__builtin_msa_srari_d((v2i64)(__b), (int)(__c)),                  \
-      (v4i32)__builtin_msa_srari_d((v2i64)(__a), (int)(__c))))
-#define msa_rpackr_u16(__a, __b, __c)                                          \
-  ((v16u8)__builtin_msa_pckev_b(                                               \
-      (v16i8)__builtin_msa_srlri_h((v8i16)(__b), (int)(__c)),                  \
-      (v16i8)__builtin_msa_srlri_h((v8i16)(__a), (int)(__c))))
-#define msa_rpackr_u32(__a, __b, __c)                                          \
-  ((v8u16)__builtin_msa_pckev_h(                                               \
-      (v8i16)__builtin_msa_srlri_w((v4i32)(__b), (int)(__c)),                  \
-      (v8i16)__builtin_msa_srlri_w((v4i32)(__a), (int)(__c))))
-#define msa_rpackr_u64(__a, __b, __c)                                          \
-  ((v4u32)__builtin_msa_pckev_w(                                               \
-      (v4i32)__builtin_msa_srlri_d((v2i64)(__b), (int)(__c)),                  \
-      (v4i32)__builtin_msa_srlri_d((v2i64)(__a), (int)(__c))))
-
-/* qrpackr */
-#define msa_qrpackr_s16(__a, __b, __c)                                         \
-  (__builtin_msa_pckev_b(                                                      \
-      (v16i8)__builtin_msa_sat_s_h(                                            \
-          __builtin_msa_srari_h((v8i16)(__b), (int)(__c)), 7),                 \
-      (v16i8)__builtin_msa_sat_s_h(                                            \
-          __builtin_msa_srari_h((v8i16)(__a), (int)(__c)), 7)))
-#define msa_qrpackr_s32(__a, __b, __c)                                         \
-  (__builtin_msa_pckev_h(                                                      \
-      (v8i16)__builtin_msa_sat_s_w(                                            \
-          __builtin_msa_srari_w((v4i32)(__b), (int)(__c)), 15),                \
-      (v8i16)__builtin_msa_sat_s_w(                                            \
-          __builtin_msa_srari_w((v4i32)(__a), (int)(__c)), 15)))
-#define msa_qrpackr_s64(__a, __b, __c)                                         \
-  (__builtin_msa_pckev_w(                                                      \
-      (v4i32)__builtin_msa_sat_s_d(                                            \
-          __builtin_msa_srari_d((v2i64)(__b), (int)(__c)), 31),                \
-      (v4i32)__builtin_msa_sat_s_d(                                            \
-          __builtin_msa_srari_d((v2i64)(__a), (int)(__c)), 31)))
-#define msa_qrpackr_u16(__a, __b, __c)                                         \
-  ((v16u8)__builtin_msa_pckev_b(                                               \
-      (v16i8)__builtin_msa_sat_u_h(                                            \
-          (v8u16)__builtin_msa_srlri_h((v8i16)(__b), (int)(__c)), 7),          \
-      (v16i8)__builtin_msa_sat_u_h(                                            \
-          (v8u16)__builtin_msa_srlri_h((v8i16)(__a), (int)(__c)), 7)))
-#define msa_qrpackr_u32(__a, __b, __c)                                         \
-  ((v8u16)__builtin_msa_pckev_h(                                               \
-      (v8i16)__builtin_msa_sat_u_w(                                            \
-          (v4u32)__builtin_msa_srlri_w((v4i32)(__b), (int)(__c)), 15),         \
-      (v8i16)__builtin_msa_sat_u_w(                                            \
-          (v4u32)__builtin_msa_srlri_w((v4i32)(__a), (int)(__c)), 15)))
-#define msa_qrpackr_u64(__a, __b, __c)                                         \
-  ((v4u32)__builtin_msa_pckev_w(                                               \
-      (v4i32)__builtin_msa_sat_u_d(                                            \
-          (v2u64)__builtin_msa_srlri_d((v2i64)(__b), (int)(__c)), 31),         \
-      (v4i32)__builtin_msa_sat_u_d(                                            \
-          (v2u64)__builtin_msa_srlri_d((v2i64)(__a), (int)(__c)), 31)))
-
-/* qrpackru */
-#define msa_qrpackru_s16(__a, __b, __c)                                        \
-  ({                                                                           \
-    v8i16 __d = __builtin_msa_srlri_h(                                         \
-        __builtin_msa_max_s_h(__builtin_msa_fill_h(0), (v8i16)(__a)),          \
-        (int)(__c));                                                           \
-    v8i16 __e = __builtin_msa_srlri_h(                                         \
-        __builtin_msa_max_s_h(__builtin_msa_fill_h(0), (v8i16)(__b)),          \
-        (int)(__c));                                                           \
-    (v16u8)                                                                    \
-        __builtin_msa_pckev_b((v16i8)__builtin_msa_sat_u_h((v8u16)__e, 7),     \
-                              (v16i8)__builtin_msa_sat_u_h((v8u16)__d, 7));    \
-  })
-
-#define msa_qrpackru_s32(__a, __b, __c)                                        \
-  ({                                                                           \
-    v4i32 __d = __builtin_msa_srlri_w(                                         \
-        __builtin_msa_max_s_w(__builtin_msa_fill_w(0), (v4i32)(__a)),          \
-        (int)(__c));                                                           \
-    v4i32 __e = __builtin_msa_srlri_w(                                         \
-        __builtin_msa_max_s_w(__builtin_msa_fill_w(0), (v4i32)(__b)),          \
-        (int)(__c));                                                           \
-    (v8u16)                                                                    \
-        __builtin_msa_pckev_h((v8i16)__builtin_msa_sat_u_w((v4u32)__e, 15),    \
-                              (v8i16)__builtin_msa_sat_u_w((v4u32)__d, 15));   \
-  })
-
-#define msa_qrpackru_s64(__a, __b, __c)                                        \
-  ({                                                                           \
-    v2i64 __d = __builtin_msa_srlri_d(                                         \
-        __builtin_msa_max_s_d(__builtin_msa_fill_d(0), (v2i64)(__a)),          \
-        (int)(__c));                                                           \
-    v2i64 __e = __builtin_msa_srlri_d(                                         \
-        __builtin_msa_max_s_d(__builtin_msa_fill_d(0), (v2i64)(__b)),          \
-        (int)(__c));                                                           \
-    (v4u32)                                                                    \
-        __builtin_msa_pckev_w((v4i32)__builtin_msa_sat_u_d((v2u64)__e, 31),    \
-                              (v4i32)__builtin_msa_sat_u_d((v2u64)__d, 31));   \
-  })
-
-/* Minimum values between corresponding elements in the two vectors are written
- * to the returned vector. */
-#define msa_minq_s8(__a, __b) (__builtin_msa_min_s_b(__a, __b))
-#define msa_minq_s16(__a, __b) (__builtin_msa_min_s_h(__a, __b))
-#define msa_minq_s32(__a, __b) (__builtin_msa_min_s_w(__a, __b))
-#define msa_minq_s64(__a, __b) (__builtin_msa_min_s_d(__a, __b))
-#define msa_minq_u8(__a, __b) ((v16u8)__builtin_msa_min_u_b(__a, __b))
-#define msa_minq_u16(__a, __b) ((v8u16)__builtin_msa_min_u_h(__a, __b))
-#define msa_minq_u32(__a, __b) ((v4u32)__builtin_msa_min_u_w(__a, __b))
-#define msa_minq_u64(__a, __b) ((v2u64)__builtin_msa_min_u_d(__a, __b))
-#define msa_minq_f32(__a, __b) (__builtin_msa_fmin_w(__a, __b))
-#define msa_minq_f64(__a, __b) (__builtin_msa_fmin_d(__a, __b))
-
-/* Maximum values between corresponding elements in the two vectors are written
- * to the returned vector. */
-#define msa_maxq_s8(__a, __b) (__builtin_msa_max_s_b(__a, __b))
-#define msa_maxq_s16(__a, __b) (__builtin_msa_max_s_h(__a, __b))
-#define msa_maxq_s32(__a, __b) (__builtin_msa_max_s_w(__a, __b))
-#define msa_maxq_s64(__a, __b) (__builtin_msa_max_s_d(__a, __b))
-#define msa_maxq_u8(__a, __b) ((v16u8)__builtin_msa_max_u_b(__a, __b))
-#define msa_maxq_u16(__a, __b) ((v8u16)__builtin_msa_max_u_h(__a, __b))
-#define msa_maxq_u32(__a, __b) ((v4u32)__builtin_msa_max_u_w(__a, __b))
-#define msa_maxq_u64(__a, __b) ((v2u64)__builtin_msa_max_u_d(__a, __b))
-#define msa_maxq_f32(__a, __b) (__builtin_msa_fmax_w(__a, __b))
-#define msa_maxq_f64(__a, __b) (__builtin_msa_fmax_d(__a, __b))
-
-/* Vector type reinterpretion */
-#define MSA_TPV_REINTERPRET(_Tpv, Vec) ((_Tpv)(Vec))
-
-/* Add the odd elements in vector __a with the even elements in vector __b to
- * double width elements in the returned vector. */
-/* v8i16 msa_hadd_s16 ((v16i8)__a, (v16i8)__b) */
-#define msa_hadd_s16(__a, __b)                                                 \
-  (__builtin_msa_hadd_s_h((v16i8)(__a), (v16i8)(__b)))
-/* v4i32 msa_hadd_s32 ((v8i16)__a, (v8i16)__b) */
-#define msa_hadd_s32(__a, __b)                                                 \
-  (__builtin_msa_hadd_s_w((v8i16)(__a), (v8i16)(__b)))
-/* v2i64 msa_hadd_s64 ((v4i32)__a, (v4i32)__b) */
-#define msa_hadd_s64(__a, __b)                                                 \
-  (__builtin_msa_hadd_s_d((v4i32)(__a), (v4i32)(__b)))
-
-/* Copy even elements in __a to the left half and even elements in __b to the
- * right half and return the result vector. */
-#define msa_pckev_s8(__a, __b)                                                 \
-  (__builtin_msa_pckev_b((v16i8)(__a), (v16i8)(__b)))
-#define msa_pckev_s16(__a, __b)                                                \
-  (__builtin_msa_pckev_h((v8i16)(__a), (v8i16)(__b)))
-#define msa_pckev_s32(__a, __b)                                                \
-  (__builtin_msa_pckev_w((v4i32)(__a), (v4i32)(__b)))
-#define msa_pckev_s64(__a, __b)                                                \
-  (__builtin_msa_pckev_d((v2i64)(__a), (v2i64)(__b)))
-
-/* Copy even elements in __a to the left half and even elements in __b to the
- * right half and return the result vector. */
-#define msa_pckod_s8(__a, __b)                                                 \
-  (__builtin_msa_pckod_b((v16i8)(__a), (v16i8)(__b)))
-#define msa_pckod_s16(__a, __b)                                                \
-  (__builtin_msa_pckod_h((v8i16)(__a), (v8i16)(__b)))
-#define msa_pckod_s32(__a, __b)                                                \
-  (__builtin_msa_pckod_w((v4i32)(__a), (v4i32)(__b)))
-#define msa_pckod_s64(__a, __b)                                                \
-  (__builtin_msa_pckod_d((v2i64)(__a), (v2i64)(__b)))
-
-#ifdef _MIPSEB
-#define LANE_IMM0_1(x) (0b1 - ((x) & 0b1))
-#define LANE_IMM0_3(x) (0b11 - ((x) & 0b11))
-#define LANE_IMM0_7(x) (0b111 - ((x) & 0b111))
-#define LANE_IMM0_15(x) (0b1111 - ((x) & 0b1111))
-#else
-#define LANE_IMM0_1(x) ((x) & 0b1)
-#define LANE_IMM0_3(x) ((x) & 0b11)
-#define LANE_IMM0_7(x) ((x) & 0b111)
-#define LANE_IMM0_15(x) ((x) & 0b1111)
-#endif
-
-#define msa_get_lane_u8(__a, __b) ((uint8_t)(__a)[LANE_IMM0_7(__b)])
-#define msa_get_lane_s8(__a, __b) ((int8_t)(__a)[LANE_IMM0_7(__b)])
-#define msa_get_lane_u16(__a, __b) ((uint16_t)(__a)[LANE_IMM0_3(__b)])
-#define msa_get_lane_s16(__a, __b) ((int16_t)(__a)[LANE_IMM0_3(__b)])
-#define msa_get_lane_u32(__a, __b) ((uint32_t)(__a)[LANE_IMM0_1(__b)])
-#define msa_get_lane_s32(__a, __b) ((int32_t)(__a)[LANE_IMM0_1(__b)])
-#define msa_get_lane_f32(__a, __b) ((float)(__a)[LANE_IMM0_3(__b)])
-#define msa_get_lane_s64(__a, __b) ((int64_t)(__a)[LANE_IMM0_1(__b)])
-#define msa_get_lane_u64(__a, __b) ((uint64_t)(__a)[LANE_IMM0_1(__b)])
-#define msa_get_lane_f64(__a, __b) ((double)(__a)[LANE_IMM0_1(__b)])
-#define msa_getq_lane_u8(__a, imm0_15)                                         \
-  ((uint8_t)__builtin_msa_copy_u_b((v16i8)(__a), imm0_15))
-#define msa_getq_lane_s8(__a, imm0_15)                                         \
-  ((int8_t)__builtin_msa_copy_s_b(__a, imm0_15))
-#define msa_getq_lane_u16(__a, imm0_7)                                         \
-  ((uint16_t)__builtin_msa_copy_u_h((v8i16)(__a), imm0_7))
-#define msa_getq_lane_s16(__a, imm0_7)                                         \
-  ((int16_t)__builtin_msa_copy_s_h(__a, imm0_7))
-#define msa_getq_lane_u32(__a, imm0_3)                                         \
-  __builtin_msa_copy_u_w((v4i32)(__a), imm0_3)
-#define msa_getq_lane_s32 __builtin_msa_copy_s_w
-#define msa_getq_lane_f32(__a, __b) ((float)(__a)[LANE_IMM0_3(__b)])
-#define msa_getq_lane_f64(__a, __b) ((double)(__a)[LANE_IMM0_1(__b)])
-#if (__mips == 64)
-#define msa_getq_lane_u64(__a, imm0_1)                                         \
-  __builtin_msa_copy_u_d((v2i64)(__a), imm0_1)
-#define msa_getq_lane_s64 __builtin_msa_copy_s_d
-#else
-#define msa_getq_lane_u64(__a, imm0_1) ((uint64_t)(__a)[LANE_IMM0_1(imm0_1)])
-#define msa_getq_lane_s64(__a, imm0_1) ((int64_t)(__a)[LANE_IMM0_1(imm0_1)])
-#endif
-
-/* combine */
-#if (__mips == 64)
-#define __COMBINE_64_64(__TYPE, a, b)                                          \
-  ((__TYPE)((v2u64){((v1u64)(a))[0], ((v1u64)(b))[0]}))
-#else
-#define __COMBINE_64_64(__TYPE, a, b)                                          \
-  ((__TYPE)((v4u32){((v2u32)(a))[0], ((v2u32)(a))[1], ((v2u32)(b))[0],         \
-                    ((v2u32)(b))[1]}))
-#endif
-
-/* v16i8 msa_combine_s8 (v8i8 __a, v8i8 __b) */
-#define msa_combine_s8(__a, __b) __COMBINE_64_64(v16i8, __a, __b)
-
-/* v8i16 msa_combine_s16(v4i16 __a, v4i16 __b) */
-#define msa_combine_s16(__a, __b) __COMBINE_64_64(v8i16, __a, __b)
-
-/* v4i32 msa_combine_s32(v2i32 __a, v2i32 __b) */
-#define msa_combine_s32(__a, __b) __COMBINE_64_64(v4i32, __a, __b)
-
-/* v2i64 msa_combine_s64(v1i64 __a, v1i64 __b) */
-#define msa_combine_s64(__a, __b) __COMBINE_64_64(v2i64, __a, __b)
-
-/* v4f32 msa_combine_f32(v2f32 __a, v2f32 __b) */
-#define msa_combine_f32(__a, __b) __COMBINE_64_64(v4f32, __a, __b)
-
-/* v16u8 msa_combine_u8(v8u8 __a, v8u8 __b) */
-#define msa_combine_u8(__a, __b) __COMBINE_64_64(v16u8, __a, __b)
-
-/* v8u16 msa_combine_u16(v4u16 __a, v4u16 __b) */
-#define msa_combine_u16(__a, __b) __COMBINE_64_64(v8u16, __a, __b)
-
-/* v4u32 msa_combine_u32(v2u32 __a, v2u32 __b) */
-#define msa_combine_u32(__a, __b) __COMBINE_64_64(v4u32, __a, __b)
-
-/* v2u64 msa_combine_u64(v1u64 __a, v1u64 __b) */
-#define msa_combine_u64(__a, __b) __COMBINE_64_64(v2u64, __a, __b)
-
-/* v2f64 msa_combine_f64(v1f64 __a, v1f64 __b) */
-#define msa_combine_f64(__a, __b) __COMBINE_64_64(v2f64, __a, __b)
-
-/* get_low, get_high */
-#if (__mips == 64)
-#define __GET_LOW(__TYPE, a)                                                   \
-  ((__TYPE)((v1u64)(__builtin_msa_copy_u_d((v2i64)(a), 0))))
-#define __GET_HIGH(__TYPE, a)                                                  \
-  ((__TYPE)((v1u64)(__builtin_msa_copy_u_d((v2i64)(a), 1))))
-#else
-#define __GET_LOW(__TYPE, a) ((__TYPE)(((v2u64)(a))[0]))
-#define __GET_HIGH(__TYPE, a) ((__TYPE)(((v2u64)(a))[1]))
-#endif
-
-/* v8i8 msa_get_low_s8(v16i8 __a) */
-#define msa_get_low_s8(__a) __GET_LOW(v8i8, __a)
-
-/* v4i16 msa_get_low_s16(v8i16 __a) */
-#define msa_get_low_s16(__a) __GET_LOW(v4i16, __a)
-
-/* v2i32 msa_get_low_s32(v4i32 __a) */
-#define msa_get_low_s32(__a) __GET_LOW(v2i32, __a)
-
-/* v1i64 msa_get_low_s64(v2i64 __a) */
-#define msa_get_low_s64(__a) __GET_LOW(v1i64, __a)
-
-/* v8u8 msa_get_low_u8(v16u8 __a) */
-#define msa_get_low_u8(__a) __GET_LOW(v8u8, __a)
-
-/* v4u16 msa_get_low_u16(v8u16 __a) */
-#define msa_get_low_u16(__a) __GET_LOW(v4u16, __a)
-
-/* v2u32 msa_get_low_u32(v4u32 __a) */
-#define msa_get_low_u32(__a) __GET_LOW(v2u32, __a)
-
-/* v1u64 msa_get_low_u64(v2u64 __a) */
-#define msa_get_low_u64(__a) __GET_LOW(v1u64, __a)
-
-/* v2f32 msa_get_low_f32(v4f32 __a) */
-#define msa_get_low_f32(__a) __GET_LOW(v2f32, __a)
-
-/* v1f64 msa_get_low_f64(v2f64 __a) */
-#define msa_get_low_f64(__a) __GET_LOW(v1f64, __a)
-
-/* v8i8 msa_get_high_s8(v16i8 __a) */
-#define msa_get_high_s8(__a) __GET_HIGH(v8i8, __a)
-
-/* v4i16 msa_get_high_s16(v8i16 __a) */
-#define msa_get_high_s16(__a) __GET_HIGH(v4i16, __a)
-
-/* v2i32 msa_get_high_s32(v4i32 __a) */
-#define msa_get_high_s32(__a) __GET_HIGH(v2i32, __a)
-
-/* v1i64 msa_get_high_s64(v2i64 __a) */
-#define msa_get_high_s64(__a) __GET_HIGH(v1i64, __a)
-
-/* v8u8 msa_get_high_u8(v16u8 __a) */
-#define msa_get_high_u8(__a) __GET_HIGH(v8u8, __a)
-
-/* v4u16 msa_get_high_u16(v8u16 __a) */
-#define msa_get_high_u16(__a) __GET_HIGH(v4u16, __a)
-
-/* v2u32 msa_get_high_u32(v4u32 __a) */
-#define msa_get_high_u32(__a) __GET_HIGH(v2u32, __a)
-
-/* v1u64 msa_get_high_u64(v2u64 __a) */
-#define msa_get_high_u64(__a) __GET_HIGH(v1u64, __a)
-
-/* v2f32 msa_get_high_f32(v4f32 __a) */
-#define msa_get_high_f32(__a) __GET_HIGH(v2f32, __a)
-
-/* v1f64 msa_get_high_f64(v2f64 __a) */
-#define msa_get_high_f64(__a) __GET_HIGH(v1f64, __a)
-
-/* ri = ai * b[lane] */
-/* v4f32 msa_mulq_lane_f32(v4f32 __a, v4f32 __b, const int __lane) */
-#define msa_mulq_lane_f32(__a, __b, __lane)                                    \
-  ((__a) * msa_getq_lane_f32(__b, __lane))
-
-/* ri = ai + bi * c[lane] */
-/* v4f32 msa_mlaq_lane_f32(v4f32 __a, v4f32 __b, v4f32 __c, const int __lane) */
-#define msa_mlaq_lane_f32(__a, __b, __c, __lane)                               \
-  ((__a) + ((__b) * msa_getq_lane_f32(__c, __lane)))
-
-/* uint16_t msa_sum_u16(v8u16 __a)*/
-#define msa_sum_u16(__a)                                                       \
-  ({                                                                           \
-    v4u32 _b;                                                                  \
-    v2u64 _c;                                                                  \
-    _b = __builtin_msa_hadd_u_w(__a, __a);                                     \
-    _c = __builtin_msa_hadd_u_d(_b, _b);                                       \
-    (uint16_t)(_c[0] + _c[1]);                                                 \
-  })
-
-/* int16_t msa_sum_s16(v8i16 __a) */
-#define msa_sum_s16(__a)                                                       \
-  ({                                                                           \
-    v4i32 _b;                                                                  \
-    v2i64 _c;                                                                  \
-    _b = __builtin_msa_hadd_s_w(__a, __a);                                     \
-    _c = __builtin_msa_hadd_s_d(_b, _b);                                       \
-    (int32_t)(_c[0] + _c[1]);                                                  \
-  })
-
-/* uint32_t msa_sum_u32(v4u32 __a)*/
-#define msa_sum_u32(__a)                                                       \
-  ({                                                                           \
-    v2u64 _b;                                                                  \
-    _b = __builtin_msa_hadd_u_d(__a, __a);                                     \
-    (uint32_t)(_b[0] + _b[1]);                                                 \
-  })
-
-/* int32_t  msa_sum_s32(v4i32 __a)*/
-#define msa_sum_s32(__a)                                                       \
-  ({                                                                           \
-    v2i64 _b;                                                                  \
-    _b = __builtin_msa_hadd_s_d(__a, __a);                                     \
-    (int64_t)(_b[0] + _b[1]);                                                  \
-  })
-
-/* uint8_t msa_sum_u8(v16u8 __a)*/
-#define msa_sum_u8(__a)                                                        \
-  ({                                                                           \
-    v8u16 _b16;                                                                \
-    v4u32 _c32;                                                                \
-    _b16 = __builtin_msa_hadd_u_h(__a, __a);                                   \
-    _c32 = __builtin_msa_hadd_u_w(_b16, _b16);                                 \
-    (uint8_t)msa_sum_u32(_c32);                                                \
-  })
-
-/* int8_t msa_sum_s8(v16s8 __a)*/
-#define msa_sum_s8(__a)                                                        \
-  ({                                                                           \
-    v8i16 _b16;                                                                \
-    v4i32 _c32;                                                                \
-    _b16 = __builtin_msa_hadd_s_h(__a, __a);                                   \
-    _c32 = __builtin_msa_hadd_s_w(_b16, _b16);                                 \
-    (int16_t)msa_sum_s32(_c32);                                                \
-  })
-
-/* float msa_sum_f32(v4f32 __a)*/
-#define msa_sum_f32(__a) ((__a)[0] + (__a)[1] + (__a)[2] + (__a)[3])
-
-/* v8u16 msa_paddlq_u8(v16u8 __a) */
-#define msa_paddlq_u8(__a) (__builtin_msa_hadd_u_h(__a, __a))
-
-/* v8i16 msa_paddlq_s8(v16i8 __a) */
-#define msa_paddlq_s8(__a) (__builtin_msa_hadd_s_h(__a, __a))
-
-/* v4u32 msa_paddlq_u16 (v8u16 __a)*/
-#define msa_paddlq_u16(__a) (__builtin_msa_hadd_u_w(__a, __a))
-
-/* v4i32 msa_paddlq_s16 (v8i16 __a)*/
-#define msa_paddlq_s16(__a) (__builtin_msa_hadd_s_w(__a, __a))
-
-/* v2u64 msa_paddlq_u32(v4u32 __a) */
-#define msa_paddlq_u32(__a) (__builtin_msa_hadd_u_d(__a, __a))
-
-/* v2i64 msa_paddlq_s32(v4i32 __a) */
-#define msa_paddlq_s32(__a) (__builtin_msa_hadd_s_d(__a, __a))
-
-#define V8U8_2_V8U16(x)                                                        \
-  {(uint16_t)x[0], (uint16_t)x[1], (uint16_t)x[2], (uint16_t)x[3],             \
-   (uint16_t)x[4], (uint16_t)x[5], (uint16_t)x[6], (uint16_t)x[7]}
-#define V8U8_2_V8I16(x)                                                        \
-  {(int16_t)x[0], (int16_t)x[1], (int16_t)x[2], (int16_t)x[3],                 \
-   (int16_t)x[4], (int16_t)x[5], (int16_t)x[6], (int16_t)x[7]}
-#define V8I8_2_V8I16(x)                                                        \
-  {(int16_t)x[0], (int16_t)x[1], (int16_t)x[2], (int16_t)x[3],                 \
-   (int16_t)x[4], (int16_t)x[5], (int16_t)x[6], (int16_t)x[7]}
-#define V4U16_2_V4U32(x)                                                       \
-  {(uint32_t)x[0], (uint32_t)x[1], (uint32_t)x[2], (uint32_t)x[3]}
-#define V4U16_2_V4I32(x)                                                       \
-  {(int32_t)x[0], (int32_t)x[1], (int32_t)x[2], (int32_t)x[3]}
-#define V4I16_2_V4I32(x)                                                       \
-  {(int32_t)x[0], (int32_t)x[1], (int32_t)x[2], (int32_t)x[3]}
-#define V2U32_2_V2U64(x) {(uint64_t)x[0], (uint64_t)x[1]}
-#define V2U32_2_V2I64(x) {(int64_t)x[0], (int64_t)x[1]}
-
-/* v8u16 msa_mull_u8(v8u8 __a, v8u8 __b) */
-#define msa_mull_u8(__a, __b)                                                  \
-  ((v8u16)__builtin_msa_mulv_h((v8i16)V8U8_2_V8I16(__a),                       \
-                               (v8i16)V8U8_2_V8I16(__b)))
-
-/* v8i16 msa_mull_s8(v8i8 __a, v8i8 __b)*/
-#define msa_mull_s8(__a, __b)                                                  \
-  (__builtin_msa_mulv_h((v8i16)V8I8_2_V8I16(__a), (v8i16)V8I8_2_V8I16(__b)))
-
-/* v4u32 msa_mull_u16(v4u16 __a, v4u16 __b) */
-#define msa_mull_u16(__a, __b)                                                 \
-  ((v4u32)__builtin_msa_mulv_w((v4i32)V4U16_2_V4I32(__a),                      \
-                               (v4i32)V4U16_2_V4I32(__b)))
-
-/* v4i32 msa_mull_s16(v4i16 __a, v4i16 __b) */
-#define msa_mull_s16(__a, __b)                                                 \
-  (__builtin_msa_mulv_w((v4i32)V4I16_2_V4I32(__a), (v4i32)V4I16_2_V4I32(__b)))
-
-/* v2u64 msa_mull_u32(v2u32 __a, v2u32 __b) */
-#define msa_mull_u32(__a, __b)                                                 \
-  ((v2u64)__builtin_msa_mulv_d((v2i64)V2U32_2_V2I64(__a),                      \
-                               (v2i64)V2U32_2_V2I64(__b)))
-
-/* bitwise and: __builtin_msa_and_v */
-#define msa_andq_u8(__a, __b)                                                  \
-  ((v16u8)__builtin_msa_and_v((v16u8)(__a), (v16u8)(__b)))
-#define msa_andq_s8(__a, __b)                                                  \
-  ((v16i8)__builtin_msa_and_v((v16u8)(__a), (v16u8)(__b)))
-#define msa_andq_u16(__a, __b)                                                 \
-  ((v8u16)__builtin_msa_and_v((v16u8)(__a), (v16u8)(__b)))
-#define msa_andq_s16(__a, __b)                                                 \
-  ((v8i16)__builtin_msa_and_v((v16u8)(__a), (v16u8)(__b)))
-#define msa_andq_u32(__a, __b)                                                 \
-  ((v4u32)__builtin_msa_and_v((v16u8)(__a), (v16u8)(__b)))
-#define msa_andq_s32(__a, __b)                                                 \
-  ((v4i32)__builtin_msa_and_v((v16u8)(__a), (v16u8)(__b)))
-#define msa_andq_u64(__a, __b)                                                 \
-  ((v2u64)__builtin_msa_and_v((v16u8)(__a), (v16u8)(__b)))
-#define msa_andq_s64(__a, __b)                                                 \
-  ((v2i64)__builtin_msa_and_v((v16u8)(__a), (v16u8)(__b)))
-
-/* bitwise or: __builtin_msa_or_v */
-#define msa_orrq_u8(__a, __b)                                                  \
-  ((v16u8)__builtin_msa_or_v((v16u8)(__a), (v16u8)(__b)))
-#define msa_orrq_s8(__a, __b)                                                  \
-  ((v16i8)__builtin_msa_or_v((v16u8)(__a), (v16u8)(__b)))
-#define msa_orrq_u16(__a, __b)                                                 \
-  ((v8u16)__builtin_msa_or_v((v16u8)(__a), (v16u8)(__b)))
-#define msa_orrq_s16(__a, __b)                                                 \
-  ((v8i16)__builtin_msa_or_v((v16u8)(__a), (v16u8)(__b)))
-#define msa_orrq_u32(__a, __b)                                                 \
-  ((v4u32)__builtin_msa_or_v((v16u8)(__a), (v16u8)(__b)))
-#define msa_orrq_s32(__a, __b)                                                 \
-  ((v4i32)__builtin_msa_or_v((v16u8)(__a), (v16u8)(__b)))
-#define msa_orrq_u64(__a, __b)                                                 \
-  ((v2u64)__builtin_msa_or_v((v16u8)(__a), (v16u8)(__b)))
-#define msa_orrq_s64(__a, __b)                                                 \
-  ((v2i64)__builtin_msa_or_v((v16u8)(__a), (v16u8)(__b)))
-
-/* bitwise xor: __builtin_msa_xor_v */
-#define msa_eorq_u8(__a, __b)                                                  \
-  ((v16u8)__builtin_msa_xor_v((v16u8)(__a), (v16u8)(__b)))
-#define msa_eorq_s8(__a, __b)                                                  \
-  ((v16i8)__builtin_msa_xor_v((v16u8)(__a), (v16u8)(__b)))
-#define msa_eorq_u16(__a, __b)                                                 \
-  ((v8u16)__builtin_msa_xor_v((v16u8)(__a), (v16u8)(__b)))
-#define msa_eorq_s16(__a, __b)                                                 \
-  ((v8i16)__builtin_msa_xor_v((v16u8)(__a), (v16u8)(__b)))
-#define msa_eorq_u32(__a, __b)                                                 \
-  ((v4u32)__builtin_msa_xor_v((v16u8)(__a), (v16u8)(__b)))
-#define msa_eorq_s32(__a, __b)                                                 \
-  ((v4i32)__builtin_msa_xor_v((v16u8)(__a), (v16u8)(__b)))
-#define msa_eorq_u64(__a, __b)                                                 \
-  ((v2u64)__builtin_msa_xor_v((v16u8)(__a), (v16u8)(__b)))
-#define msa_eorq_s64(__a, __b)                                                 \
-  ((v2i64)__builtin_msa_xor_v((v16u8)(__a), (v16u8)(__b)))
-
-/* bitwise not: v16u8 __builtin_msa_xori_b (v16u8, 0xff) */
-#define msa_mvnq_u8(__a) ((v16u8)__builtin_msa_xori_b((v16u8)(__a), 0xFF))
-#define msa_mvnq_s8(__a) ((v16i8)__builtin_msa_xori_b((v16u8)(__a), 0xFF))
-#define msa_mvnq_u16(__a) ((v8u16)__builtin_msa_xori_b((v16u8)(__a), 0xFF))
-#define msa_mvnq_s16(__a) ((v8i16)__builtin_msa_xori_b((v16u8)(__a), 0xFF))
-#define msa_mvnq_u32(__a) ((v4u32)__builtin_msa_xori_b((v16u8)(__a), 0xFF))
-#define msa_mvnq_s32(__a) ((v4i32)__builtin_msa_xori_b((v16u8)(__a), 0xFF))
-#define msa_mvnq_u64(__a) ((v2u64)__builtin_msa_xori_b((v16u8)(__a), 0xFF))
-#define msa_mvnq_s64(__a) ((v2i64)__builtin_msa_xori_b((v16u8)(__a), 0xFF))
-
-/* compare equal: ceq -> ri = ai == bi ? 1...1:0...0 */
-#define msa_ceqq_u8(__a, __b)                                                  \
-  ((v16u8)__builtin_msa_ceq_b((v16i8)(__a), (v16i8)(__b)))
-#define msa_ceqq_s8(__a, __b)                                                  \
-  ((v16u8)__builtin_msa_ceq_b((v16i8)(__a), (v16i8)(__b)))
-#define msa_ceqq_u16(__a, __b)                                                 \
-  ((v8u16)__builtin_msa_ceq_h((v8i16)(__a), (v8i16)(__b)))
-#define msa_ceqq_s16(__a, __b)                                                 \
-  ((v8u16)__builtin_msa_ceq_h((v8i16)(__a), (v8i16)(__b)))
-#define msa_ceqq_u32(__a, __b)                                                 \
-  ((v4u32)__builtin_msa_ceq_w((v4i32)(__a), (v4i32)(__b)))
-#define msa_ceqq_s32(__a, __b)                                                 \
-  ((v4u32)__builtin_msa_ceq_w((v4i32)(__a), (v4i32)(__b)))
-#define msa_ceqq_f32(__a, __b)                                                 \
-  ((v4u32)__builtin_msa_fceq_w((v4f32)(__a), (v4f32)(__b)))
-#define msa_ceqq_u64(__a, __b)                                                 \
-  ((v2u64)__builtin_msa_ceq_d((v2i64)(__a), (v2i64)(__b)))
-#define msa_ceqq_s64(__a, __b)                                                 \
-  ((v2u64)__builtin_msa_ceq_d((v2i64)(__a), (v2i64)(__b)))
-#define msa_ceqq_f64(__a, __b)                                                 \
-  ((v2u64)__builtin_msa_fceq_d((v2f64)(__a), (v2f64)(__b)))
-
-/* Compare less-than: clt -> ri = ai < bi ? 1...1:0...0 */
-#define msa_cltq_u8(__a, __b)                                                  \
-  ((v16u8)__builtin_msa_clt_u_b((v16u8)(__a), (v16u8)(__b)))
-#define msa_cltq_s8(__a, __b)                                                  \
-  ((v16u8)__builtin_msa_clt_s_b((v16i8)(__a), (v16i8)(__b)))
-#define msa_cltq_u16(__a, __b)                                                 \
-  ((v8u16)__builtin_msa_clt_u_h((v8u16)(__a), (v8u16)(__b)))
-#define msa_cltq_s16(__a, __b)                                                 \
-  ((v8u16)__builtin_msa_clt_s_h((v8i16)(__a), (v8i16)(__b)))
-#define msa_cltq_u32(__a, __b)                                                 \
-  ((v4u32)__builtin_msa_clt_u_w((v4u32)(__a), (v4u32)(__b)))
-#define msa_cltq_s32(__a, __b)                                                 \
-  ((v4u32)__builtin_msa_clt_s_w((v4i32)(__a), (v4i32)(__b)))
-#define msa_cltq_f32(__a, __b)                                                 \
-  ((v4u32)__builtin_msa_fclt_w((v4f32)(__a), (v4f32)(__b)))
-#define msa_cltq_u64(__a, __b)                                                 \
-  ((v2u64)__builtin_msa_clt_u_d((v2u64)(__a), (v2u64)(__b)))
-#define msa_cltq_s64(__a, __b)                                                 \
-  ((v2u64)__builtin_msa_clt_s_d((v2i64)(__a), (v2i64)(__b)))
-#define msa_cltq_f64(__a, __b)                                                 \
-  ((v2u64)__builtin_msa_fclt_d((v2f64)(__a), (v2f64)(__b)))
-
-/* compare greater-than: cgt -> ri = ai > bi ? 1...1:0...0 */
-#define msa_cgtq_u8(__a, __b)                                                  \
-  ((v16u8)__builtin_msa_clt_u_b((v16u8)(__b), (v16u8)(__a)))
-#define msa_cgtq_s8(__a, __b)                                                  \
-  ((v16u8)__builtin_msa_clt_s_b((v16i8)(__b), (v16i8)(__a)))
-#define msa_cgtq_u16(__a, __b)                                                 \
-  ((v8u16)__builtin_msa_clt_u_h((v8u16)(__b), (v8u16)(__a)))
-#define msa_cgtq_s16(__a, __b)                                                 \
-  ((v8u16)__builtin_msa_clt_s_h((v8i16)(__b), (v8i16)(__a)))
-#define msa_cgtq_u32(__a, __b)                                                 \
-  ((v4u32)__builtin_msa_clt_u_w((v4u32)(__b), (v4u32)(__a)))
-#define msa_cgtq_s32(__a, __b)                                                 \
-  ((v4u32)__builtin_msa_clt_s_w((v4i32)(__b), (v4i32)(__a)))
-#define msa_cgtq_f32(__a, __b)                                                 \
-  ((v4u32)__builtin_msa_fclt_w((v4f32)(__b), (v4f32)(__a)))
-#define msa_cgtq_u64(__a, __b)                                                 \
-  ((v2u64)__builtin_msa_clt_u_d((v2u64)(__b), (v2u64)(__a)))
-#define msa_cgtq_s64(__a, __b)                                                 \
-  ((v2u64)__builtin_msa_clt_s_d((v2i64)(__b), (v2i64)(__a)))
-#define msa_cgtq_f64(__a, __b)                                                 \
-  ((v2u64)__builtin_msa_fclt_d((v2f64)(__b), (v2f64)(__a)))
-
-/* compare less-equal: cle -> ri = ai <= bi ? 1...1:0...0 */
-#define msa_cleq_u8(__a, __b)                                                  \
-  ((v16u8)__builtin_msa_cle_u_b((v16u8)(__a), (v16u8)(__b)))
-#define msa_cleq_s8(__a, __b)                                                  \
-  ((v16u8)__builtin_msa_cle_s_b((v16i8)(__a), (v16i8)(__b)))
-#define msa_cleq_u16(__a, __b)                                                 \
-  ((v8u16)__builtin_msa_cle_u_h((v8u16)(__a), (v8u16)(__b)))
-#define msa_cleq_s16(__a, __b)                                                 \
-  ((v8u16)__builtin_msa_cle_s_h((v8i16)(__a), (v8i16)(__b)))
-#define msa_cleq_u32(__a, __b)                                                 \
-  ((v4u32)__builtin_msa_cle_u_w((v4u32)(__a), (v4u32)(__b)))
-#define msa_cleq_s32(__a, __b)                                                 \
-  ((v4u32)__builtin_msa_cle_s_w((v4i32)(__a), (v4i32)(__b)))
-#define msa_cleq_f32(__a, __b)                                                 \
-  ((v4u32)__builtin_msa_fcle_w((v4f32)(__a), (v4f32)(__b)))
-#define msa_cleq_u64(__a, __b)                                                 \
-  ((v2u64)__builtin_msa_cle_u_d((v2u64)(__a), (v2u64)(__b)))
-#define msa_cleq_s64(__a, __b)                                                 \
-  ((v2u64)__builtin_msa_cle_s_d((v2i64)(__a), (v2i64)(__b)))
-#define msa_cleq_f64(__a, __b)                                                 \
-  ((v2u64)__builtin_msa_fcle_d((v2f64)(__a), (v2f64)(__b)))
-
-/* compare greater-equal: cge -> ri = ai >= bi ? 1...1:0...0 */
-#define msa_cgeq_u8(__a, __b)                                                  \
-  ((v16u8)__builtin_msa_cle_u_b((v16u8)(__b), (v16u8)(__a)))
-#define msa_cgeq_s8(__a, __b)                                                  \
-  ((v16u8)__builtin_msa_cle_s_b((v16i8)(__b), (v16i8)(__a)))
-#define msa_cgeq_u16(__a, __b)                                                 \
-  ((v8u16)__builtin_msa_cle_u_h((v8u16)(__b), (v8u16)(__a)))
-#define msa_cgeq_s16(__a, __b)                                                 \
-  ((v8u16)__builtin_msa_cle_s_h((v8i16)(__b), (v8i16)(__a)))
-#define msa_cgeq_u32(__a, __b)                                                 \
-  ((v4u32)__builtin_msa_cle_u_w((v4u32)(__b), (v4u32)(__a)))
-#define msa_cgeq_s32(__a, __b)                                                 \
-  ((v4u32)__builtin_msa_cle_s_w((v4i32)(__b), (v4i32)(__a)))
-#define msa_cgeq_f32(__a, __b)                                                 \
-  ((v4u32)__builtin_msa_fcle_w((v4f32)(__b), (v4f32)(__a)))
-#define msa_cgeq_u64(__a, __b)                                                 \
-  ((v2u64)__builtin_msa_cle_u_d((v2u64)(__b), (v2u64)(__a)))
-#define msa_cgeq_s64(__a, __b)                                                 \
-  ((v2u64)__builtin_msa_cle_s_d((v2i64)(__b), (v2i64)(__a)))
-#define msa_cgeq_f64(__a, __b)                                                 \
-  ((v2u64)__builtin_msa_fcle_d((v2f64)(__b), (v2f64)(__a)))
-
-/* Shift Left Logical: shl -> ri = ai << bi; */
-#define msa_shlq_u8(__a, __b)                                                  \
-  ((v16u8)__builtin_msa_sll_b((v16i8)(__a), (v16i8)(__b)))
-#define msa_shlq_s8(__a, __b)                                                  \
-  ((v16i8)__builtin_msa_sll_b((v16i8)(__a), (v16i8)(__b)))
-#define msa_shlq_u16(__a, __b)                                                 \
-  ((v8u16)__builtin_msa_sll_h((v8i16)(__a), (v8i16)(__b)))
-#define msa_shlq_s16(__a, __b)                                                 \
-  ((v8i16)__builtin_msa_sll_h((v8i16)(__a), (v8i16)(__b)))
-#define msa_shlq_u32(__a, __b)                                                 \
-  ((v4u32)__builtin_msa_sll_w((v4i32)(__a), (v4i32)(__b)))
-#define msa_shlq_s32(__a, __b)                                                 \
-  ((v4i32)__builtin_msa_sll_w((v4i32)(__a), (v4i32)(__b)))
-#define msa_shlq_u64(__a, __b)                                                 \
-  ((v2u64)__builtin_msa_sll_d((v2i64)(__a), (v2i64)(__b)))
-#define msa_shlq_s64(__a, __b)                                                 \
-  ((v2i64)__builtin_msa_sll_d((v2i64)(__a), (v2i64)(__b)))
-
-/* Immediate Shift Left Logical: shl -> ri = ai << imm; */
-#define msa_shlq_n_u8(__a, __imm)                                              \
-  ((v16u8)__builtin_msa_slli_b((v16i8)(__a), __imm))
-#define msa_shlq_n_s8(__a, __imm)                                              \
-  ((v16i8)__builtin_msa_slli_b((v16i8)(__a), __imm))
-#define msa_shlq_n_u16(__a, __imm)                                             \
-  ((v8u16)__builtin_msa_slli_h((v8i16)(__a), __imm))
-#define msa_shlq_n_s16(__a, __imm)                                             \
-  ((v8i16)__builtin_msa_slli_h((v8i16)(__a), __imm))
-#define msa_shlq_n_u32(__a, __imm)                                             \
-  ((v4u32)__builtin_msa_slli_w((v4i32)(__a), __imm))
-#define msa_shlq_n_s32(__a, __imm)                                             \
-  ((v4i32)__builtin_msa_slli_w((v4i32)(__a), __imm))
-#define msa_shlq_n_u64(__a, __imm)                                             \
-  ((v2u64)__builtin_msa_slli_d((v2i64)(__a), __imm))
-#define msa_shlq_n_s64(__a, __imm)                                             \
-  ((v2i64)__builtin_msa_slli_d((v2i64)(__a), __imm))
-
-/* shift right: shrq -> ri = ai >> bi; */
-#define msa_shrq_u8(__a, __b)                                                  \
-  ((v16u8)__builtin_msa_srl_b((v16i8)(__a), (v16i8)(__b)))
-#define msa_shrq_s8(__a, __b)                                                  \
-  ((v16i8)__builtin_msa_sra_b((v16i8)(__a), (v16i8)(__b)))
-#define msa_shrq_u16(__a, __b)                                                 \
-  ((v8u16)__builtin_msa_srl_h((v8i16)(__a), (v8i16)(__b)))
-#define msa_shrq_s16(__a, __b)                                                 \
-  ((v8i16)__builtin_msa_sra_h((v8i16)(__a), (v8i16)(__b)))
-#define msa_shrq_u32(__a, __b)                                                 \
-  ((v4u32)__builtin_msa_srl_w((v4i32)(__a), (v4i32)(__b)))
-#define msa_shrq_s32(__a, __b)                                                 \
-  ((v4i32)__builtin_msa_sra_w((v4i32)(__a), (v4i32)(__b)))
-#define msa_shrq_u64(__a, __b)                                                 \
-  ((v2u64)__builtin_msa_srl_d((v2i64)(__a), (v2i64)(__b)))
-#define msa_shrq_s64(__a, __b)                                                 \
-  ((v2i64)__builtin_msa_sra_d((v2i64)(__a), (v2i64)(__b)))
-
-/* Immediate Shift Right: shr -> ri = ai >> imm; */
-#define msa_shrq_n_u8(__a, __imm)                                              \
-  ((v16u8)__builtin_msa_srli_b((v16i8)(__a), __imm))
-#define msa_shrq_n_s8(__a, __imm)                                              \
-  ((v16i8)__builtin_msa_srai_b((v16i8)(__a), __imm))
-#define msa_shrq_n_u16(__a, __imm)                                             \
-  ((v8u16)__builtin_msa_srli_h((v8i16)(__a), __imm))
-#define msa_shrq_n_s16(__a, __imm)                                             \
-  ((v8i16)__builtin_msa_srai_h((v8i16)(__a), __imm))
-#define msa_shrq_n_u32(__a, __imm)                                             \
-  ((v4u32)__builtin_msa_srli_w((v4i32)(__a), __imm))
-#define msa_shrq_n_s32(__a, __imm)                                             \
-  ((v4i32)__builtin_msa_srai_w((v4i32)(__a), __imm))
-#define msa_shrq_n_u64(__a, __imm)                                             \
-  ((v2u64)__builtin_msa_srli_d((v2i64)(__a), __imm))
-#define msa_shrq_n_s64(__a, __imm)                                             \
-  ((v2i64)__builtin_msa_srai_d((v2i64)(__a), __imm))
-
-/* Immediate Shift Right Rounded: shr -> ri = ai >> (rounded)imm; */
-#define msa_rshrq_n_u8(__a, __imm)                                             \
-  ((v16u8)__builtin_msa_srlri_b((v16i8)(__a), __imm))
-#define msa_rshrq_n_s8(__a, __imm)                                             \
-  ((v16i8)__builtin_msa_srari_b((v16i8)(__a), __imm))
-#define msa_rshrq_n_u16(__a, __imm)                                            \
-  ((v8u16)__builtin_msa_srlri_h((v8i16)(__a), __imm))
-#define msa_rshrq_n_s16(__a, __imm)                                            \
-  ((v8i16)__builtin_msa_srari_h((v8i16)(__a), __imm))
-#define msa_rshrq_n_u32(__a, __imm)                                            \
-  ((v4u32)__builtin_msa_srlri_w((v4i32)(__a), __imm))
-#define msa_rshrq_n_s32(__a, __imm)                                            \
-  ((v4i32)__builtin_msa_srari_w((v4i32)(__a), __imm))
-#define msa_rshrq_n_u64(__a, __imm)                                            \
-  ((v2u64)__builtin_msa_srlri_d((v2i64)(__a), __imm))
-#define msa_rshrq_n_s64(__a, __imm)                                            \
-  ((v2i64)__builtin_msa_srari_d((v2i64)(__a), __imm))
-
-/* Vector saturating rounding shift left, qrshl -> ri = ai << bi; */
-#define msa_qrshrq_s32(a, b) ((v4i32)__msa_srar_w((v4i32)(a), (v4i32)(b)))
-
-/* Rename the msa builtin func to unify the name style for intrin_msa.hpp */
-#define msa_qaddq_u8 __builtin_msa_adds_u_b
-#define msa_qaddq_s8 __builtin_msa_adds_s_b
-#define msa_qaddq_u16 __builtin_msa_adds_u_h
-#define msa_qaddq_s16 __builtin_msa_adds_s_h
-#define msa_qaddq_u32 __builtin_msa_adds_u_w
-#define msa_qaddq_s32 __builtin_msa_adds_s_w
-#define msa_qaddq_u64 __builtin_msa_adds_u_d
-#define msa_qaddq_s64 __builtin_msa_adds_s_d
-#define msa_addq_u8(a, b) ((v16u8)__builtin_msa_addv_b((v16i8)(a), (v16i8)(b)))
-#define msa_addq_s8 __builtin_msa_addv_b
-#define msa_addq_u16(a, b) ((v8u16)__builtin_msa_addv_h((v8i16)(a), (v8i16)(b)))
-#define msa_addq_s16 __builtin_msa_addv_h
-#define msa_addq_u32(a, b) ((v4u32)__builtin_msa_addv_w((v4i32)(a), (v4i32)(b)))
-#define msa_addq_s32 __builtin_msa_addv_w
-#define msa_addq_f32 __builtin_msa_fadd_w
-#define msa_addq_u64(a, b) ((v2u64)__builtin_msa_addv_d((v2i64)(a), (v2i64)(b)))
-#define msa_addq_s64 __builtin_msa_addv_d
-#define msa_addq_f64 __builtin_msa_fadd_d
-#define msa_qsubq_u8 __builtin_msa_subs_u_b
-#define msa_qsubq_s8 __builtin_msa_subs_s_b
-#define msa_qsubq_u16 __builtin_msa_subs_u_h
-#define msa_qsubq_s16 __builtin_msa_subs_s_h
-#define msa_subq_u8(a, b) ((v16u8)__builtin_msa_subv_b((v16i8)(a), (v16i8)(b)))
-#define msa_subq_s8 __builtin_msa_subv_b
-#define msa_subq_u16(a, b) ((v8u16)__builtin_msa_subv_h((v8i16)(a), (v8i16)(b)))
-#define msa_subq_s16 __builtin_msa_subv_h
-#define msa_subq_u32(a, b) ((v4u32)__builtin_msa_subv_w((v4i32)(a), (v4i32)(b)))
-#define msa_subq_s32 __builtin_msa_subv_w
-#define msa_subq_f32 __builtin_msa_fsub_w
-#define msa_subq_u64(a, b) ((v2u64)__builtin_msa_subv_d((v2i64)(a), (v2i64)(b)))
-#define msa_subq_s64 __builtin_msa_subv_d
-#define msa_subq_f64 __builtin_msa_fsub_d
-#define msa_mulq_u8(a, b) ((v16u8)__builtin_msa_mulv_b((v16i8)(a), (v16i8)(b)))
-#define msa_mulq_s8(a, b) ((v16i8)__builtin_msa_mulv_b((v16i8)(a), (v16i8)(b)))
-#define msa_mulq_u16(a, b) ((v8u16)__builtin_msa_mulv_h((v8i16)(a), (v8i16)(b)))
-#define msa_mulq_s16(a, b) ((v8i16)__builtin_msa_mulv_h((v8i16)(a), (v8i16)(b)))
-#define msa_mulq_u32(a, b) ((v4u32)__builtin_msa_mulv_w((v4i32)(a), (v4i32)(b)))
-#define msa_mulq_s32(a, b) ((v4i32)__builtin_msa_mulv_w((v4i32)(a), (v4i32)(b)))
-#define msa_mulq_u64(a, b) ((v2u64)__builtin_msa_mulv_d((v2i64)(a), (v2i64)(b)))
-#define msa_mulq_s64(a, b) ((v2i64)__builtin_msa_mulv_d((v2i64)(a), (v2i64)(b)))
-#define msa_mulq_f32 __builtin_msa_fmul_w
-#define msa_mulq_f64 __builtin_msa_fmul_d
-#define msa_divq_f32 __builtin_msa_fdiv_w
-#define msa_divq_f64 __builtin_msa_fdiv_d
-#define msa_dotp_s_h __builtin_msa_dotp_s_h
-#define msa_dotp_s_w __builtin_msa_dotp_s_w
-#define msa_dotp_s_d __builtin_msa_dotp_s_d
-#define msa_dotp_u_h __builtin_msa_dotp_u_h
-#define msa_dotp_u_w __builtin_msa_dotp_u_w
-#define msa_dotp_u_d __builtin_msa_dotp_u_d
-#define msa_dpadd_s_h __builtin_msa_dpadd_s_h
-#define msa_dpadd_s_w __builtin_msa_dpadd_s_w
-#define msa_dpadd_s_d __builtin_msa_dpadd_s_d
-#define msa_dpadd_u_h __builtin_msa_dpadd_u_h
-#define msa_dpadd_u_w __builtin_msa_dpadd_u_w
-#define msa_dpadd_u_d __builtin_msa_dpadd_u_d
-
-#define ILVRL_B2(RTYPE, in0, in1, low, hi)                                     \
-  do {                                                                         \
-    low = (RTYPE)__builtin_msa_ilvr_b((v16i8)(in0), (v16i8)(in1));             \
-    hi = (RTYPE)__builtin_msa_ilvl_b((v16i8)(in0), (v16i8)(in1));              \
-  } while (0)
-#define ILVRL_B2_UB(...) ILVRL_B2(v16u8, __VA_ARGS__)
-#define ILVRL_B2_SB(...) ILVRL_B2(v16i8, __VA_ARGS__)
-#define ILVRL_B2_UH(...) ILVRL_B2(v8u16, __VA_ARGS__)
-#define ILVRL_B2_SH(...) ILVRL_B2(v8i16, __VA_ARGS__)
-#define ILVRL_B2_SW(...) ILVRL_B2(v4i32, __VA_ARGS__)
-
-#define ILVRL_H2(RTYPE, in0, in1, low, hi)                                     \
-  do {                                                                         \
-    low = (RTYPE)__builtin_msa_ilvr_h((v8i16)(in0), (v8i16)(in1));             \
-    hi = (RTYPE)__builtin_msa_ilvl_h((v8i16)(in0), (v8i16)(in1));              \
-  } while (0)
-#define ILVRL_H2_UB(...) ILVRL_H2(v16u8, __VA_ARGS__)
-#define ILVRL_H2_SB(...) ILVRL_H2(v16i8, __VA_ARGS__)
-#define ILVRL_H2_UH(...) ILVRL_H2(v8u16, __VA_ARGS__)
-#define ILVRL_H2_SH(...) ILVRL_H2(v8i16, __VA_ARGS__)
-#define ILVRL_H2_SW(...) ILVRL_H2(v4i32, __VA_ARGS__)
-#define ILVRL_H2_UW(...) ILVRL_H2(v4u32, __VA_ARGS__)
-
-#define ILVRL_W2(RTYPE, in0, in1, low, hi)                                     \
-  do {                                                                         \
-    low = (RTYPE)__builtin_msa_ilvr_w((v4i32)(in0), (v4i32)(in1));             \
-    hi = (RTYPE)__builtin_msa_ilvl_w((v4i32)(in0), (v4i32)(in1));              \
-  } while (0)
-#define ILVRL_W2_UB(...) ILVRL_W2(v16u8, __VA_ARGS__)
-#define ILVRL_W2_SH(...) ILVRL_W2(v8i16, __VA_ARGS__)
-#define ILVRL_W2_SW(...) ILVRL_W2(v4i32, __VA_ARGS__)
-#define ILVRL_W2_UW(...) ILVRL_W2(v4u32, __VA_ARGS__)
-
-/* absq, qabsq (r = |a|;) */
-#define msa_absq_s8(a) __builtin_msa_add_a_b(a, __builtin_msa_fill_b(0))
-#define msa_absq_s16(a) __builtin_msa_add_a_h(a, __builtin_msa_fill_h(0))
-#define msa_absq_s32(a) __builtin_msa_add_a_w(a, __builtin_msa_fill_w(0))
-#define msa_absq_s64(a) __builtin_msa_add_a_d(a, __builtin_msa_fill_d(0))
-#define msa_absq_f32(a) ((v4f32)__builtin_msa_bclri_w((v4u32)(a), 31))
-#define msa_absq_f64(a) ((v2f64)__builtin_msa_bclri_d((v2u64)(a), 63))
-#define msa_qabsq_s8(a) __builtin_msa_adds_a_b(a, __builtin_msa_fill_b(0))
-#define msa_qabsq_s16(a) __builtin_msa_adds_a_h(a, __builtin_msa_fill_h(0))
-#define msa_qabsq_s32(a) __builtin_msa_adds_a_w(a, __builtin_msa_fill_w(0))
-#define msa_qabsq_s64(a) __builtin_msa_adds_a_d(a, __builtin_msa_fill_d(0))
-
-/* abdq, qabdq (r = |a - b|;) */
-#define msa_abdq_u8 __builtin_msa_asub_u_b
-#define msa_abdq_s8 __builtin_msa_asub_s_b
-#define msa_abdq_u16 __builtin_msa_asub_u_h
-#define msa_abdq_s16 __builtin_msa_asub_s_h
-#define msa_abdq_u32 __builtin_msa_asub_u_w
-#define msa_abdq_s32 __builtin_msa_asub_s_w
-#define msa_abdq_u64 __builtin_msa_asub_u_d
-#define msa_abdq_s64 __builtin_msa_asub_s_d
-#define msa_abdq_f32(a, b) msa_absq_f32(__builtin_msa_fsub_w(a, b))
-#define msa_abdq_f64(a, b) msa_absq_f64(__builtin_msa_fsub_d(a, b))
-#define msa_qabdq_s8(a, b) msa_qabsq_s8(__builtin_msa_subs_s_b(a, b))
-#define msa_qabdq_s16(a, b) msa_qabsq_s16(__builtin_msa_subs_s_h(a, b))
-#define msa_qabdq_s32(a, b) msa_qabsq_s32(__builtin_msa_subs_s_w(a, b))
-#define msa_qabdq_s64(a, b) msa_qabsq_s64(__builtin_msa_subs_s_d(a, b))
-
-/* sqrtq, rsqrtq */
-#define msa_sqrtq_f32 __builtin_msa_fsqrt_w
-#define msa_sqrtq_f64 __builtin_msa_fsqrt_d
-#define msa_rsqrtq_f32 __builtin_msa_frsqrt_w
-#define msa_rsqrtq_f64 __builtin_msa_frsqrt_d
-
-/* mlaq: r = a + b * c; */
-__extension__ extern __inline v4i32
-    __attribute__((__always_inline__, __gnu_inline__, __artificial__))
-    msa_mlaq_s32(v4i32 __a, v4i32 __b, v4i32 __c) {
-  __asm__ volatile("maddv.w %w[__a], %w[__b], %w[__c]\n"
-                   // Outputs
-                   : [__a] "+f"(__a)
-                   // Inputs
-                   : [__b] "f"(__b), [__c] "f"(__c));
-  return __a;
-}
-
-__extension__ extern __inline v2i64
-    __attribute__((__always_inline__, __gnu_inline__, __artificial__))
-    msa_mlaq_s64(v2i64 __a, v2i64 __b, v2i64 __c) {
-  __asm__ volatile("maddv.d %w[__a], %w[__b], %w[__c]\n"
-                   // Outputs
-                   : [__a] "+f"(__a)
-                   // Inputs
-                   : [__b] "f"(__b), [__c] "f"(__c));
-  return __a;
-}
-
-__extension__ extern __inline v4f32
-    __attribute__((__always_inline__, __gnu_inline__, __artificial__))
-    msa_mlaq_f32(v4f32 __a, v4f32 __b, v4f32 __c) {
-  __asm__ volatile("fmadd.w %w[__a], %w[__b], %w[__c]\n"
-                   // Outputs
-                   : [__a] "+f"(__a)
-                   // Inputs
-                   : [__b] "f"(__b), [__c] "f"(__c));
-  return __a;
-}
-
-__extension__ extern __inline v2f64
-    __attribute__((__always_inline__, __gnu_inline__, __artificial__))
-    msa_mlaq_f64(v2f64 __a, v2f64 __b, v2f64 __c) {
-  __asm__ volatile("fmadd.d %w[__a], %w[__b], %w[__c]\n"
-                   // Outputs
-                   : [__a] "+f"(__a)
-                   // Inputs
-                   : [__b] "f"(__b), [__c] "f"(__c));
-  return __a;
-}
-
-/* cntq */
-#define msa_cntq_s8 __builtin_msa_pcnt_b
-#define msa_cntq_s16 __builtin_msa_pcnt_h
-#define msa_cntq_s32 __builtin_msa_pcnt_w
-#define msa_cntq_s64 __builtin_msa_pcnt_d
-
-/* bslq (a: mask; r = b(if a == 0); r = c(if a == 1);) */
-#define msa_bslq_u8 __builtin_msa_bsel_v
-
-/* ilvrq, ilvlq (For EL only, ilvrq: b0, a0, b1, a1; ilvlq: b2, a2, b3, a3;) */
-#define msa_ilvrq_s8 __builtin_msa_ilvr_b
-#define msa_ilvrq_s16 __builtin_msa_ilvr_h
-#define msa_ilvrq_s32 __builtin_msa_ilvr_w
-#define msa_ilvrq_s64 __builtin_msa_ilvr_d
-#define msa_ilvlq_s8 __builtin_msa_ilvl_b
-#define msa_ilvlq_s16 __builtin_msa_ilvl_h
-#define msa_ilvlq_s32 __builtin_msa_ilvl_w
-#define msa_ilvlq_s64 __builtin_msa_ilvl_d
-
-/* ilvevq, ilvodq (ilvevq: b0, a0, b2, a2; ilvodq: b1, a1, b3, a3; ) */
-#define msa_ilvevq_s8 __builtin_msa_ilvev_b
-#define msa_ilvevq_s16 __builtin_msa_ilvev_h
-#define msa_ilvevq_s32 __builtin_msa_ilvev_w
-#define msa_ilvevq_s64 __builtin_msa_ilvev_d
-#define msa_ilvodq_s8 __builtin_msa_ilvod_b
-#define msa_ilvodq_s16 __builtin_msa_ilvod_h
-#define msa_ilvodq_s32 __builtin_msa_ilvod_w
-#define msa_ilvodq_s64 __builtin_msa_ilvod_d
-
-/* extq (r = (a || b); a concatenation b and get elements from index c) */
-#ifdef _MIPSEB
-#define msa_extq_s8(a, b, c)                                                   \
-  (__builtin_msa_vshf_b(                                                       \
-      __builtin_msa_subv_b(                                                    \
-          (v16i8)((v2i64){0x1716151413121110, 0x1F1E1D1C1B1A1918}),            \
-          __builtin_msa_fill_b(c)),                                            \
-      a, b))
-#define msa_extq_s16(a, b, c)                                                  \
-  (__builtin_msa_vshf_h(                                                       \
-      __builtin_msa_subv_h(                                                    \
-          (v8i16)((v2i64){0x000B000A00090008, 0x000F000E000D000C}),            \
-          __builtin_msa_fill_h(c)),                                            \
-      a, b))
-#define msa_extq_s32(a, b, c)                                                  \
-  (__builtin_msa_vshf_w(                                                       \
-      __builtin_msa_subv_w(                                                    \
-          (v4i32)((v2i64){0x0000000500000004, 0x0000000700000006}),            \
-          __builtin_msa_fill_w(c)),                                            \
-      a, b))
-#define msa_extq_s64(a, b, c)                                                  \
-  (__builtin_msa_vshf_d(                                                       \
-      __builtin_msa_subv_d((v2i64){0x0000000000000002, 0x0000000000000003},    \
-                           __builtin_msa_fill_d(c)),                           \
-      a, b))
-#else
-#define msa_extq_s8(a, b, c)                                                   \
-  (__builtin_msa_vshf_b(                                                       \
-      __builtin_msa_addv_b(                                                    \
-          (v16i8)((v2i64){0x0706050403020100, 0x0F0E0D0C0B0A0908}),            \
-          __builtin_msa_fill_b(c)),                                            \
-      b, a))
-#define msa_extq_s16(a, b, c)                                                  \
-  (__builtin_msa_vshf_h(                                                       \
-      __builtin_msa_addv_h(                                                    \
-          (v8i16)((v2i64){0x0003000200010000, 0x0007000600050004}),            \
-          __builtin_msa_fill_h(c)),                                            \
-      b, a))
-#define msa_extq_s32(a, b, c)                                                  \
-  (__builtin_msa_vshf_w(                                                       \
-      __builtin_msa_addv_w(                                                    \
-          (v4i32)((v2i64){0x0000000100000000, 0x0000000300000002}),            \
-          __builtin_msa_fill_w(c)),                                            \
-      b, a))
-#define msa_extq_s64(a, b, c)                                                  \
-  (__builtin_msa_vshf_d(                                                       \
-      __builtin_msa_addv_d((v2i64){0x0000000000000000, 0x0000000000000001},    \
-                           __builtin_msa_fill_d(c)),                           \
-      b, a))
-#endif /* _MIPSEB */
-
-/* cvttruncq, cvttintq, cvtrintq */
-#define msa_cvttruncq_u32_f32 __builtin_msa_ftrunc_u_w
-#define msa_cvttruncq_s32_f32 __builtin_msa_ftrunc_s_w
-#define msa_cvttruncq_u64_f64 __builtin_msa_ftrunc_u_d
-#define msa_cvttruncq_s64_f64 __builtin_msa_ftrunc_s_d
-#define msa_cvttintq_u32_f32 __builtin_msa_ftint_u_w
-#define msa_cvttintq_s32_f32 __builtin_msa_ftint_s_w
-#define msa_cvttintq_u64_f64 __builtin_msa_ftint_u_d
-#define msa_cvttintq_s64_f64 __builtin_msa_ftint_s_d
-#define msa_cvtrintq_f32 __builtin_msa_frint_w
-#define msa_cvtrintq_f64 __builtin_msa_frint_d
-
-/* cvtfintq, cvtfq */
-#define msa_cvtfintq_f32_u32 __builtin_msa_ffint_u_w
-#define msa_cvtfintq_f32_s32 __builtin_msa_ffint_s_w
-#define msa_cvtfintq_f64_u64 __builtin_msa_ffint_u_d
-#define msa_cvtfintq_f64_s64 __builtin_msa_ffint_s_d
-#define msa_cvtfq_f32_f64 __builtin_msa_fexdo_w
-#define msa_cvtflq_f64_f32 __builtin_msa_fexupr_d
-#define msa_cvtfhq_f64_f32 __builtin_msa_fexupl_d
-
-#define msa_addl_u8(a, b)                                                      \
-  ((v8u16)__builtin_msa_addv_h((v8i16)V8U8_2_V8I16(a), (v8i16)V8U8_2_V8I16(b)))
-#define msa_addl_s8(a, b)                                                      \
-  (__builtin_msa_addv_h((v8i16)V8I8_2_V8I16(a), (v8i16)V8I8_2_V8I16(b)))
-#define msa_addl_u16(a, b)                                                     \
-  ((v4u32)__builtin_msa_addv_w((v4i32)V4U16_2_V4I32(a),                        \
-                               (v4i32)V4U16_2_V4I32(b)))
-#define msa_addl_s16(a, b)                                                     \
-  (__builtin_msa_addv_w((v4i32)V4I16_2_V4I32(a), (v4i32)V4I16_2_V4I32(b)))
-#define msa_subl_s16(a, b)                                                     \
-  (__builtin_msa_subv_w((v4i32)V4I16_2_V4I32(a), (v4i32)V4I16_2_V4I32(b)))
-#define msa_recpeq_f32 __builtin_msa_frcp_w
-#define msa_recpsq_f32(a, b)                                                   \
-  (__builtin_msa_fsub_w(msa_dupq_n_f32(2.0f), __builtin_msa_fmul_w(a, b)))
-
-#define MSA_INTERLEAVED_IMPL_LOAD2_STORE2(_Tp, _Tpv, _Tpvs, suffix, df,        \
-                                          nlanes)                              \
-  __extension__ extern __inline void                                           \
-      __attribute__((__always_inline__, __gnu_inline__,                        \
-                     __artificial__)) msa_ld2q_##suffix(const _Tp *ptr,        \
-                                                        _Tpv *a, _Tpv *b) {    \
-    _Tpv v0 = msa_ld1q_##suffix(ptr);                                          \
-    _Tpv v1 = msa_ld1q_##suffix(ptr + nlanes);                                 \
-    *a = (_Tpv)__builtin_msa_pckev_##df((_Tpvs)v1, (_Tpvs)v0);                 \
-    *b = (_Tpv)__builtin_msa_pckod_##df((_Tpvs)v1, (_Tpvs)v0);                 \
-  }                                                                            \
-  __extension__ extern __inline void                                           \
-      __attribute__((__always_inline__, __gnu_inline__,                        \
-                     __artificial__)) msa_st2q_##suffix(_Tp *ptr,              \
-                                                        const _Tpv a,          \
-                                                        const _Tpv b) {        \
-    msa_st1q_##suffix(ptr, (_Tpv)__builtin_msa_ilvr_##df((_Tpvs)b, (_Tpvs)a)); \
-    msa_st1q_##suffix(ptr + nlanes,                                            \
-                      (_Tpv)__builtin_msa_ilvl_##df((_Tpvs)b, (_Tpvs)a));      \
-  }
-
-MSA_INTERLEAVED_IMPL_LOAD2_STORE2(uint8_t, v16u8, v16i8, u8, b, 16)
-MSA_INTERLEAVED_IMPL_LOAD2_STORE2(int8_t, v16i8, v16i8, s8, b, 16)
-MSA_INTERLEAVED_IMPL_LOAD2_STORE2(uint16_t, v8u16, v8i16, u16, h, 8)
-MSA_INTERLEAVED_IMPL_LOAD2_STORE2(int16_t, v8i16, v8i16, s16, h, 8)
-MSA_INTERLEAVED_IMPL_LOAD2_STORE2(uint32_t, v4u32, v4i32, u32, w, 4)
-MSA_INTERLEAVED_IMPL_LOAD2_STORE2(int32_t, v4i32, v4i32, s32, w, 4)
-MSA_INTERLEAVED_IMPL_LOAD2_STORE2(float, v4f32, v4i32, f32, w, 4)
-MSA_INTERLEAVED_IMPL_LOAD2_STORE2(uint64_t, v2u64, v2i64, u64, d, 2)
-MSA_INTERLEAVED_IMPL_LOAD2_STORE2(int64_t, v2i64, v2i64, s64, d, 2)
-MSA_INTERLEAVED_IMPL_LOAD2_STORE2(double, v2f64, v2i64, f64, d, 2)
-
-#ifdef _MIPSEB
-#define MSA_INTERLEAVED_IMPL_LOAD3_8(_Tp, _Tpv, _Tpvs, suffix)                 \
-  __extension__ extern __inline void                                           \
-      __attribute__((__always_inline__, __gnu_inline__,                        \
-                     __artificial__)) msa_ld3q_##suffix(const _Tp *ptr,        \
-                                                        _Tpv *a, _Tpv *b,      \
-                                                        _Tpv *c) {             \
-    _Tpv v0 = msa_ld1q_##suffix(ptr);                                          \
-    _Tpv v1 = msa_ld1q_##suffix(ptr + 16);                                     \
-    _Tpv v2 = msa_ld1q_##suffix(ptr + 32);                                     \
-    _Tpvs v3 = __builtin_msa_vshf_b(                                           \
-        (_Tpvs)((v2i64){0x0704011F1F1F1F1F, 0x1F1C191613100D0A}), (_Tpvs)v0,   \
-        (_Tpvs)v1);                                                            \
-    *a = (_Tpv)__builtin_msa_vshf_b(                                           \
-        (_Tpvs)((v2i64){0x1716150E0B080502, 0x1F1E1D1C1B1A1918}), v3,          \
-        (_Tpvs)v2);                                                            \
-    v3 = __builtin_msa_vshf_b(                                                 \
-        (_Tpvs)((v2i64){0x0603001F1F1F1F1F, 0x1E1B1815120F0C09}), (_Tpvs)v0,   \
-        (_Tpvs)v1);                                                            \
-    *b = (_Tpv)__builtin_msa_vshf_b(                                           \
-        (_Tpvs)((v2i64){0x1716150D0A070401, 0x1F1E1D1C1B1A1918}), v3,          \
-        (_Tpvs)v2);                                                            \
-    v3 = __builtin_msa_vshf_b(                                                 \
-        (_Tpvs)((v2i64){0x05021F1F1F1F1F1F, 0x1D1A1714110E0B08}), (_Tpvs)v0,   \
-        (_Tpvs)v1);                                                            \
-    *c = (_Tpv)__builtin_msa_vshf_b(                                           \
-        (_Tpvs)((v2i64){0x17160F0C09060300, 0x1F1E1D1C1B1A1918}), v3,          \
-        (_Tpvs)v2);                                                            \
-  }
-#else
-#define MSA_INTERLEAVED_IMPL_LOAD3_8(_Tp, _Tpv, _Tpvs, suffix)                 \
-  __extension__ extern __inline void                                           \
-      __attribute__((__always_inline__, __gnu_inline__,                        \
-                     __artificial__)) msa_ld3q_##suffix(const _Tp *ptr,        \
-                                                        _Tpv *a, _Tpv *b,      \
-                                                        _Tpv *c) {             \
-    _Tpv v0 = msa_ld1q_##suffix(ptr);                                          \
-    _Tpv v1 = msa_ld1q_##suffix(ptr + 16);                                     \
-    _Tpv v2 = msa_ld1q_##suffix(ptr + 32);                                     \
-    _Tpvs v3 = __builtin_msa_vshf_b(                                           \
-        (_Tpvs)((v2i64){0x15120F0C09060300, 0x00000000001E1B18}), (_Tpvs)v1,   \
-        (_Tpvs)v0);                                                            \
-    *a = (_Tpv)__builtin_msa_vshf_b(                                           \
-        (_Tpvs)((v2i64){0x0706050403020100, 0x1D1A1714110A0908}), (_Tpvs)v2,   \
-        v3);                                                                   \
-    v3 = __builtin_msa_vshf_b(                                                 \
-        (_Tpvs)((v2i64){0x1613100D0A070401, 0x00000000001F1C19}), (_Tpvs)v1,   \
-        (_Tpvs)v0);                                                            \
-    *b = (_Tpv)__builtin_msa_vshf_b(                                           \
-        (_Tpvs)((v2i64){0x0706050403020100, 0x1E1B1815120A0908}), (_Tpvs)v2,   \
-        v3);                                                                   \
-    v3 = __builtin_msa_vshf_b(                                                 \
-        (_Tpvs)((v2i64){0x1714110E0B080502, 0x0000000000001D1A}), (_Tpvs)v1,   \
-        (_Tpvs)v0);                                                            \
-    *c = (_Tpv)__builtin_msa_vshf_b(                                           \
-        (_Tpvs)((v2i64){0x0706050403020100, 0x1F1C191613100908}), (_Tpvs)v2,   \
-        v3);                                                                   \
-  }
-#endif
-
-MSA_INTERLEAVED_IMPL_LOAD3_8(uint8_t, v16u8, v16i8, u8)
-MSA_INTERLEAVED_IMPL_LOAD3_8(int8_t, v16i8, v16i8, s8)
-
-#ifdef _MIPSEB
-#define MSA_INTERLEAVED_IMPL_LOAD3_16(_Tp, _Tpv, _Tpvs, suffix)                \
-  __extension__ extern __inline void                                           \
-      __attribute__((__always_inline__, __gnu_inline__,                        \
-                     __artificial__)) msa_ld3q_##suffix(const _Tp *ptr,        \
-                                                        _Tpv *a, _Tpv *b,      \
-                                                        _Tpv *c) {             \
-    _Tpv v0 = msa_ld1q_##suffix(ptr);                                          \
-    _Tpv v1 = msa_ld1q_##suffix(ptr + 8);                                      \
-    _Tpv v2 = msa_ld1q_##suffix(ptr + 16);                                     \
-    _Tpvs v3 = __builtin_msa_vshf_h(                                           \
-        (_Tpvs)((v2i64){0x00030000000F000F, 0x000F000C00090006}), (_Tpvs)v1,   \
-        (_Tpvs)v0);                                                            \
-    *a = (_Tpv)__builtin_msa_vshf_h(                                           \
-        (_Tpvs)((v2i64){0x000B000A00050002, 0x000F000E000D000C}), (_Tpvs)v2,   \
-        v3);                                                                   \
-    v3 = __builtin_msa_vshf_h(                                                 \
-        (_Tpvs)((v2i64){0x0002000F000F000F, 0x000E000B00080005}), (_Tpvs)v1,   \
-        (_Tpvs)v0);                                                            \
-    *b = (_Tpv)__builtin_msa_vshf_h(                                           \
-        (_Tpvs)((v2i64){0x000B000700040001, 0x000F000E000D000C}), (_Tpvs)v2,   \
-        v3);                                                                   \
-    v3 = __builtin_msa_vshf_h(                                                 \
-        (_Tpvs)((v2i64){0x0001000F000F000F, 0x000D000A00070004}), (_Tpvs)v1,   \
-        (_Tpvs)v0);                                                            \
-    *c = (_Tpv)__builtin_msa_vshf_h(                                           \
-        (_Tpvs)((v2i64){0x000B000600030000, 0x000F000E000D000C}), (_Tpvs)v2,   \
-        v3);                                                                   \
-  }
-#else
-#define MSA_INTERLEAVED_IMPL_LOAD3_16(_Tp, _Tpv, _Tpvs, suffix)                \
-  __extension__ extern __inline void                                           \
-      __attribute__((__always_inline__, __gnu_inline__,                        \
-                     __artificial__)) msa_ld3q_##suffix(const _Tp *ptr,        \
-                                                        _Tpv *a, _Tpv *b,      \
-                                                        _Tpv *c) {             \
-    _Tpv v0 = msa_ld1q_##suffix(ptr);                                          \
-    _Tpv v1 = msa_ld1q_##suffix(ptr + 8);                                      \
-    _Tpv v2 = msa_ld1q_##suffix(ptr + 16);                                     \
-    _Tpvs v3 = __builtin_msa_vshf_h(                                           \
-        (_Tpvs)((v2i64){0x0009000600030000, 0x00000000000F000C}), (_Tpvs)v1,   \
-        (_Tpvs)v0);                                                            \
-    *a = (_Tpv)__builtin_msa_vshf_h(                                           \
-        (_Tpvs)((v2i64){0x0003000200010000, 0x000D000A00050004}), (_Tpvs)v2,   \
-        v3);                                                                   \
-    v3 = __builtin_msa_vshf_h(                                                 \
-        (_Tpvs)((v2i64){0x000A000700040001, 0x000000000000000D}), (_Tpvs)v1,   \
-        (_Tpvs)v0);                                                            \
-    *b = (_Tpv)__builtin_msa_vshf_h(                                           \
-        (_Tpvs)((v2i64){0x0003000200010000, 0x000E000B00080004}), (_Tpvs)v2,   \
-        v3);                                                                   \
-    v3 = __builtin_msa_vshf_h(                                                 \
-        (_Tpvs)((v2i64){0x000B000800050002, 0x000000000000000E}), (_Tpvs)v1,   \
-        (_Tpvs)v0);                                                            \
-    *c = (_Tpv)__builtin_msa_vshf_h(                                           \
-        (_Tpvs)((v2i64){0x0003000200010000, 0x000F000C00090004}), (_Tpvs)v2,   \
-        v3);                                                                   \
-  }
-#endif
-
-MSA_INTERLEAVED_IMPL_LOAD3_16(uint16_t, v8u16, v8i16, u16)
-MSA_INTERLEAVED_IMPL_LOAD3_16(int16_t, v8i16, v8i16, s16)
-
-#define MSA_INTERLEAVED_IMPL_LOAD3_32(_Tp, _Tpv, _Tpvs, suffix)                \
-  __extension__ extern __inline void                                           \
-      __attribute__((__always_inline__, __gnu_inline__,                        \
-                     __artificial__)) msa_ld3q_##suffix(const _Tp *ptr,        \
-                                                        _Tpv *a, _Tpv *b,      \
-                                                        _Tpv *c) {             \
-    _Tpv v00 = msa_ld1q_##suffix(ptr);                                         \
-    _Tpv v01 = msa_ld1q_##suffix(ptr + 4);                                     \
-    _Tpv v02 = msa_ld1q_##suffix(ptr + 8);                                     \
-    _Tpvs v10 = __builtin_msa_ilvr_w(                                          \
-        (_Tpvs)__builtin_msa_ilvl_d((v2i64)v01, (v2i64)v01), (_Tpvs)v00);      \
-    _Tpvs v11 = __builtin_msa_ilvr_w(                                          \
-        (_Tpvs)v02, (_Tpvs)__builtin_msa_ilvl_d((v2i64)v00, (v2i64)v00));      \
-    _Tpvs v12 = __builtin_msa_ilvr_w(                                          \
-        (_Tpvs)__builtin_msa_ilvl_d((v2i64)v02, (v2i64)v02), (_Tpvs)v01);      \
-    *a = (_Tpv)__builtin_msa_ilvr_w(                                           \
-        (_Tpvs)__builtin_msa_ilvl_d((v2i64)v11, (v2i64)v11), v10);             \
-    *b = (_Tpv)__builtin_msa_ilvr_w(                                           \
-        v12, (_Tpvs)__builtin_msa_ilvl_d((v2i64)v10, (v2i64)v10));             \
-    *c = (_Tpv)__builtin_msa_ilvr_w(                                           \
-        (_Tpvs)__builtin_msa_ilvl_d((v2i64)v12, (v2i64)v12), v11);             \
-  }
-
-MSA_INTERLEAVED_IMPL_LOAD3_32(uint32_t, v4u32, v4i32, u32)
-MSA_INTERLEAVED_IMPL_LOAD3_32(int32_t, v4i32, v4i32, s32)
-MSA_INTERLEAVED_IMPL_LOAD3_32(float, v4f32, v4i32, f32)
-
-#define MSA_INTERLEAVED_IMPL_LOAD3_64(_Tp, _Tpv, suffix)                       \
-  __extension__ extern __inline void                                           \
-      __attribute__((__always_inline__, __gnu_inline__,                        \
-                     __artificial__)) msa_ld3q_##suffix(const _Tp *ptr,        \
-                                                        _Tpv *a, _Tpv *b,      \
-                                                        _Tpv *c) {             \
-    *((_Tp *)a) = *ptr;                                                        \
-    *((_Tp *)b) = *(ptr + 1);                                                  \
-    *((_Tp *)c) = *(ptr + 2);                                                  \
-    *((_Tp *)a + 1) = *(ptr + 3);                                              \
-    *((_Tp *)b + 1) = *(ptr + 4);                                              \
-    *((_Tp *)c + 1) = *(ptr + 5);                                              \
-  }
-
-MSA_INTERLEAVED_IMPL_LOAD3_64(uint64_t, v2u64, u64)
-MSA_INTERLEAVED_IMPL_LOAD3_64(int64_t, v2i64, s64)
-MSA_INTERLEAVED_IMPL_LOAD3_64(double, v2f64, f64)
-
-#ifdef _MIPSEB
-#define MSA_INTERLEAVED_IMPL_STORE3_8(_Tp, _Tpv, _Tpvs, suffix)                \
-  __extension__ extern __inline void __attribute__((                           \
-      __always_inline__, __gnu_inline__,                                       \
-      __artificial__)) msa_st3q_##suffix(_Tp *ptr, const _Tpv a, const _Tpv b, \
-                                         const _Tpv c) {                       \
-    _Tpvs v0 = __builtin_msa_vshf_b(                                           \
-        (_Tpvs)((v2i64){0x0F0E0D0C0B1F1F1F, 0x1F1E1D1C1B1A1F1F}), (_Tpvs)b,    \
-        (_Tpvs)a);                                                             \
-    _Tpvs v1 = __builtin_msa_vshf_b(                                           \
-        (_Tpvs)((v2i64){0x0D1C140C1B130B1A, 0x1F170F1E160E1D15}), (_Tpvs)c,    \
-        (_Tpvs)v0);                                                            \
-    msa_st1q_##suffix(ptr, (_Tpv)v1);                                          \
-    v0 = __builtin_msa_vshf_b(                                                 \
-        (_Tpvs)((v2i64){0x0A09080706051F1F, 0x19181716151F1F1F}), (_Tpvs)b,    \
-        (_Tpvs)a);                                                             \
-    v1 = __builtin_msa_vshf_b(                                                 \
-        (_Tpvs)((v2i64){0x1D14071C13061B12, 0x170A1F16091E1508}), (_Tpvs)c,    \
-        (_Tpvs)v0);                                                            \
-    msa_st1q_##suffix(ptr + 16, (_Tpv)v1);                                     \
-    v0 = __builtin_msa_vshf_b(                                                 \
-        (_Tpvs)((v2i64){0x04030201001F1F1F, 0x14131211101F1F1F}), (_Tpvs)b,    \
-        (_Tpvs)a);                                                             \
-    v1 = __builtin_msa_vshf_b(                                                 \
-        (_Tpvs)((v2i64){0x15021C14011B1300, 0x051F17041E16031D}), (_Tpvs)c,    \
-        (_Tpvs)v0);                                                            \
-    msa_st1q_##suffix(ptr + 32, (_Tpv)v1);                                     \
-  }
-#else
-#define MSA_INTERLEAVED_IMPL_STORE3_8(_Tp, _Tpv, _Tpvs, suffix)                \
-  __extension__ extern __inline void __attribute__((                           \
-      __always_inline__, __gnu_inline__,                                       \
-      __artificial__)) msa_st3q_##suffix(_Tp *ptr, const _Tpv a, const _Tpv b, \
-                                         const _Tpv c) {                       \
-    _Tpvs v0 = __builtin_msa_vshf_b(                                           \
-        (_Tpvs)((v2i64){0x0000050403020100, 0x0000001413121110}), (_Tpvs)b,    \
-        (_Tpvs)a);                                                             \
-    _Tpvs v1 = __builtin_msa_vshf_b(                                           \
-        (_Tpvs)((v2i64){0x0A02110901100800, 0x05140C04130B0312}), (_Tpvs)c,    \
-        (_Tpvs)v0);                                                            \
-    msa_st1q_##suffix(ptr, (_Tpv)v1);                                          \
-    v0 = __builtin_msa_vshf_b(                                                 \
-        (_Tpvs)((v2i64){0x0000000A09080706, 0x00001A1918171615}), (_Tpvs)b,    \
-        (_Tpvs)a);                                                             \
-    v1 = __builtin_msa_vshf_b(                                                 \
-        (_Tpvs)((v2i64){0x170A011609001508, 0x0D04190C03180B02}), (_Tpvs)c,    \
-        (_Tpvs)v0);                                                            \
-    msa_st1q_##suffix(ptr + 16, (_Tpv)v1);                                     \
-    v0 = __builtin_msa_vshf_b(                                                 \
-        (_Tpvs)((v2i64){0x0000000F0E0D0C0B, 0x0000001F1E1D1C1B}), (_Tpvs)b,    \
-        (_Tpvs)a);                                                             \
-    v1 = __builtin_msa_vshf_b(                                                 \
-        (_Tpvs)((v2i64){0x021C09011B08001A, 0x1F0C041E0B031D0A}), (_Tpvs)c,    \
-        (_Tpvs)v0);                                                            \
-    msa_st1q_##suffix(ptr + 32, (_Tpv)v1);                                     \
-  }
-#endif
-
-MSA_INTERLEAVED_IMPL_STORE3_8(uint8_t, v16u8, v16i8, u8)
-MSA_INTERLEAVED_IMPL_STORE3_8(int8_t, v16i8, v16i8, s8)
-
-#ifdef _MIPSEB
-#define MSA_INTERLEAVED_IMPL_STORE3_16(_Tp, _Tpv, _Tpvs, suffix)               \
-  __extension__ extern __inline void __attribute__((                           \
-      __always_inline__, __gnu_inline__,                                       \
-      __artificial__)) msa_st3q_##suffix(_Tp *ptr, const _Tpv a, const _Tpv b, \
-                                         const _Tpv c) {                       \
-    _Tpvs v0 = __builtin_msa_vshf_h(                                           \
-        (_Tpvs)((v2i64){0x000700060005000F, 0x000F000E000D000F}), (_Tpvs)b,    \
-        (_Tpvs)a);                                                             \
-    _Tpvs v1 = __builtin_msa_vshf_h(                                           \
-        (_Tpvs)((v2i64){0x000A0006000D0009, 0x000F000B0007000E}), (_Tpvs)c,    \
-        (_Tpvs)v0);                                                            \
-    msa_st1q_##suffix(ptr, (_Tpv)v1);                                          \
-    v0 = __builtin_msa_vshf_h(                                                 \
-        (_Tpvs)((v2i64){0x00040003000F000F, 0x000C000B000A000F}), (_Tpvs)b,    \
-        (_Tpvs)a);                                                             \
-    v1 = __builtin_msa_vshf_h(                                                 \
-        (_Tpvs)((v2i64){0x000E000A0003000D, 0x0005000F000B0004}), (_Tpvs)c,    \
-        (_Tpvs)v0);                                                            \
-    msa_st1q_##suffix(ptr + 8, (_Tpv)v1);                                      \
-    v0 = __builtin_msa_vshf_h(                                                 \
-        (_Tpvs)((v2i64){0x000200010000000F, 0x00090008000F000F}), (_Tpvs)b,    \
-        (_Tpvs)a);                                                             \
-    v1 = __builtin_msa_vshf_h(                                                 \
-        (_Tpvs)((v2i64){0x0001000E00090000, 0x000B0002000F000A}), (_Tpvs)c,    \
-        (_Tpvs)v0);                                                            \
-    msa_st1q_##suffix(ptr + 16, (_Tpv)v1);                                     \
-  }
-#else
-#define MSA_INTERLEAVED_IMPL_STORE3_16(_Tp, _Tpv, _Tpvs, suffix)               \
-  __extension__ extern __inline void __attribute__((                           \
-      __always_inline__, __gnu_inline__,                                       \
-      __artificial__)) msa_st3q_##suffix(_Tp *ptr, const _Tpv a, const _Tpv b, \
-                                         const _Tpv c) {                       \
-    _Tpvs v0 = __builtin_msa_vshf_h(                                           \
-        (_Tpvs)((v2i64){0x0000000200010000, 0x0000000A00090008}), (_Tpvs)b,    \
-        (_Tpvs)a);                                                             \
-    _Tpvs v1 = __builtin_msa_vshf_h(                                           \
-        (_Tpvs)((v2i64){0x0001000800040000, 0x0006000200090005}), (_Tpvs)c,    \
-        (_Tpvs)v0);                                                            \
-    msa_st1q_##suffix(ptr, (_Tpv)v1);                                          \
-    v0 = __builtin_msa_vshf_h(                                                 \
-        (_Tpvs)((v2i64){0x0000000500040003, 0x00000000000C000B}), (_Tpvs)b,    \
-        (_Tpvs)a);                                                             \
-    v1 = __builtin_msa_vshf_h(                                                 \
-        (_Tpvs)((v2i64){0x000B00040000000A, 0x0002000C00050001}), (_Tpvs)c,    \
-        (_Tpvs)v0);                                                            \
-    msa_st1q_##suffix(ptr + 8, (_Tpv)v1);                                      \
-    v0 = __builtin_msa_vshf_h(                                                 \
-        (_Tpvs)((v2i64){0x0000000000070006, 0x0000000F000E000D}), (_Tpvs)b,    \
-        (_Tpvs)a);                                                             \
-    v1 = __builtin_msa_vshf_h(                                                 \
-        (_Tpvs)((v2i64){0x00050000000D0004, 0x000F00060001000E}), (_Tpvs)c,    \
-        (_Tpvs)v0);                                                            \
-    msa_st1q_##suffix(ptr + 16, (_Tpv)v1);                                     \
-  }
-#endif
-
-MSA_INTERLEAVED_IMPL_STORE3_16(uint16_t, v8u16, v8i16, u16)
-MSA_INTERLEAVED_IMPL_STORE3_16(int16_t, v8i16, v8i16, s16)
-
-#ifdef _MIPSEB
-#define MSA_INTERLEAVED_IMPL_STORE3_32(_Tp, _Tpv, _Tpvs, suffix)               \
-  __extension__ extern __inline void __attribute__((                           \
-      __always_inline__, __gnu_inline__,                                       \
-      __artificial__)) msa_st3q_##suffix(_Tp *ptr, const _Tpv a, const _Tpv b, \
-                                         const _Tpv c) {                       \
-    _Tpvs v0 = __builtin_msa_vshf_w(                                           \
-        (_Tpvs)((v2i64){0x0000000300000007, 0x0000000700000006}), (_Tpvs)b,    \
-        (_Tpvs)a);                                                             \
-    _Tpvs v1 = __builtin_msa_vshf_w(                                           \
-        (_Tpvs)((v2i64){0x0000000300000006, 0x0000000700000005}), (_Tpvs)c,    \
-        (_Tpvs)v0);                                                            \
-    msa_st1q_##suffix(ptr, (_Tpv)v1);                                          \
-    v0 = __builtin_msa_vshf_w(                                                 \
-        (_Tpvs)((v2i64){0x0000000200000001, 0x0000000500000007}), (_Tpvs)b,    \
-        (_Tpvs)a);                                                             \
-    v1 = __builtin_msa_vshf_w(                                                 \
-        (_Tpvs)((v2i64){0x0000000700000004, 0x0000000500000002}), (_Tpvs)c,    \
-        (_Tpvs)v0);                                                            \
-    msa_st1q_##suffix(ptr + 4, (_Tpv)v1);                                      \
-    v0 = __builtin_msa_vshf_w(                                                 \
-        (_Tpvs)((v2i64){0x0000000000000007, 0x0000000400000007}), (_Tpvs)b,    \
-        (_Tpvs)a);                                                             \
-    v1 = __builtin_msa_vshf_w(                                                 \
-        (_Tpvs)((v2i64){0x0000000500000000, 0x0000000100000007}), (_Tpvs)c,    \
-        (_Tpvs)v0);                                                            \
-    msa_st1q_##suffix(ptr + 8, (_Tpv)v1);                                      \
-  }
-#else
-#define MSA_INTERLEAVED_IMPL_STORE3_32(_Tp, _Tpv, _Tpvs, suffix)               \
-  __extension__ extern __inline void __attribute__((                           \
-      __always_inline__, __gnu_inline__,                                       \
-      __artificial__)) msa_st3q_##suffix(_Tp *ptr, const _Tpv a, const _Tpv b, \
-                                         const _Tpv c) {                       \
-    _Tpvs v0 = __builtin_msa_vshf_w(                                           \
-        (_Tpvs)((v2i64){0x0000000100000000, 0x0000000000000004}), (_Tpvs)b,    \
-        (_Tpvs)a);                                                             \
-    _Tpvs v1 = __builtin_msa_vshf_w(                                           \
-        (_Tpvs)((v2i64){0x0000000200000000, 0x0000000100000004}), (_Tpvs)c,    \
-        (_Tpvs)v0);                                                            \
-    msa_st1q_##suffix(ptr, (_Tpv)v1);                                          \
-    v0 = __builtin_msa_vshf_w(                                                 \
-        (_Tpvs)((v2i64){0x0000000000000002, 0x0000000600000005}), (_Tpvs)b,    \
-        (_Tpvs)a);                                                             \
-    v1 = __builtin_msa_vshf_w(                                                 \
-        (_Tpvs)((v2i64){0x0000000500000002, 0x0000000300000000}), (_Tpvs)c,    \
-        (_Tpvs)v0);                                                            \
-    msa_st1q_##suffix(ptr + 4, (_Tpv)v1);                                      \
-    v0 = __builtin_msa_vshf_w(                                                 \
-        (_Tpvs)((v2i64){0x0000000000000003, 0x0000000000000007}), (_Tpvs)b,    \
-        (_Tpvs)a);                                                             \
-    v1 = __builtin_msa_vshf_w(                                                 \
-        (_Tpvs)((v2i64){0x0000000000000006, 0x0000000700000002}), (_Tpvs)c,    \
-        (_Tpvs)v0);                                                            \
-    msa_st1q_##suffix(ptr + 8, (_Tpv)v1);                                      \
-  }
-#endif
-
-MSA_INTERLEAVED_IMPL_STORE3_32(uint32_t, v4u32, v4i32, u32)
-MSA_INTERLEAVED_IMPL_STORE3_32(int32_t, v4i32, v4i32, s32)
-MSA_INTERLEAVED_IMPL_STORE3_32(float, v4f32, v4i32, f32)
-
-#define MSA_INTERLEAVED_IMPL_STORE3_64(_Tp, _Tpv, suffix)                      \
-  __extension__ extern __inline void __attribute__((                           \
-      __always_inline__, __gnu_inline__,                                       \
-      __artificial__)) msa_st3q_##suffix(_Tp *ptr, const _Tpv a, const _Tpv b, \
-                                         const _Tpv c) {                       \
-    *ptr = a[0];                                                               \
-    *(ptr + 1) = b[0];                                                         \
-    *(ptr + 2) = c[0];                                                         \
-    *(ptr + 3) = a[1];                                                         \
-    *(ptr + 4) = b[1];                                                         \
-    *(ptr + 5) = c[1];                                                         \
-  }
-
-MSA_INTERLEAVED_IMPL_STORE3_64(uint64_t, v2u64, u64)
-MSA_INTERLEAVED_IMPL_STORE3_64(int64_t, v2i64, s64)
-MSA_INTERLEAVED_IMPL_STORE3_64(double, v2f64, f64)
-
-#define MSA_INTERLEAVED_IMPL_LOAD4_STORE4(_Tp, _Tpv, _Tpvs, suffix, df,        \
-                                          nlanes)                              \
-  __extension__ extern __inline void                                           \
-      __attribute__((__always_inline__, __gnu_inline__,                        \
-                     __artificial__)) msa_ld4q_##suffix(const _Tp *ptr,        \
-                                                        _Tpv *a, _Tpv *b,      \
-                                                        _Tpv *c, _Tpv *d) {    \
-    _Tpv v0 = msa_ld1q_##suffix(ptr);                                          \
-    _Tpv v1 = msa_ld1q_##suffix(ptr + nlanes);                                 \
-    _Tpv v2 = msa_ld1q_##suffix(ptr + nlanes * 2);                             \
-    _Tpv v3 = msa_ld1q_##suffix(ptr + nlanes * 3);                             \
-    _Tpvs t0 = __builtin_msa_pckev_##df((_Tpvs)v1, (_Tpvs)v0);                 \
-    _Tpvs t1 = __builtin_msa_pckev_##df((_Tpvs)v3, (_Tpvs)v2);                 \
-    _Tpvs t2 = __builtin_msa_pckod_##df((_Tpvs)v1, (_Tpvs)v0);                 \
-    _Tpvs t3 = __builtin_msa_pckod_##df((_Tpvs)v3, (_Tpvs)v2);                 \
-    *a = (_Tpv)__builtin_msa_pckev_##df(t1, t0);                               \
-    *b = (_Tpv)__builtin_msa_pckev_##df(t3, t2);                               \
-    *c = (_Tpv)__builtin_msa_pckod_##df(t1, t0);                               \
-    *d = (_Tpv)__builtin_msa_pckod_##df(t3, t2);                               \
-  }                                                                            \
-  __extension__ extern __inline void __attribute__((                           \
-      __always_inline__, __gnu_inline__,                                       \
-      __artificial__)) msa_st4q_##suffix(_Tp *ptr, const _Tpv a, const _Tpv b, \
-                                         const _Tpv c, const _Tpv d) {         \
-    _Tpvs v0 = __builtin_msa_ilvr_##df((_Tpvs)c, (_Tpvs)a);                    \
-    _Tpvs v1 = __builtin_msa_ilvr_##df((_Tpvs)d, (_Tpvs)b);                    \
-    _Tpvs v2 = __builtin_msa_ilvl_##df((_Tpvs)c, (_Tpvs)a);                    \
-    _Tpvs v3 = __builtin_msa_ilvl_##df((_Tpvs)d, (_Tpvs)b);                    \
-    msa_st1q_##suffix(ptr, (_Tpv)__builtin_msa_ilvr_##df(v1, v0));             \
-    msa_st1q_##suffix(ptr + nlanes, (_Tpv)__builtin_msa_ilvl_##df(v1, v0));    \
-    msa_st1q_##suffix(ptr + 2 * nlanes,                                        \
-                      (_Tpv)__builtin_msa_ilvr_##df(v3, v2));                  \
-    msa_st1q_##suffix(ptr + 3 * nlanes,                                        \
-                      (_Tpv)__builtin_msa_ilvl_##df(v3, v2));                  \
-  }
-
-MSA_INTERLEAVED_IMPL_LOAD4_STORE4(uint8_t, v16u8, v16i8, u8, b, 16)
-MSA_INTERLEAVED_IMPL_LOAD4_STORE4(int8_t, v16i8, v16i8, s8, b, 16)
-MSA_INTERLEAVED_IMPL_LOAD4_STORE4(uint16_t, v8u16, v8i16, u16, h, 8)
-MSA_INTERLEAVED_IMPL_LOAD4_STORE4(int16_t, v8i16, v8i16, s16, h, 8)
-MSA_INTERLEAVED_IMPL_LOAD4_STORE4(uint32_t, v4u32, v4i32, u32, w, 4)
-MSA_INTERLEAVED_IMPL_LOAD4_STORE4(int32_t, v4i32, v4i32, s32, w, 4)
-MSA_INTERLEAVED_IMPL_LOAD4_STORE4(float, v4f32, v4i32, f32, w, 4)
-
-#define MSA_INTERLEAVED_IMPL_LOAD4_STORE4_64(_Tp, _Tpv, _Tpvs, suffix)         \
-  __extension__ extern __inline void                                           \
-      __attribute__((__always_inline__, __gnu_inline__,                        \
-                     __artificial__)) msa_ld4q_##suffix(const _Tp *ptr,        \
-                                                        _Tpv *a, _Tpv *b,      \
-                                                        _Tpv *c, _Tpv *d) {    \
-    _Tpv v0 = msa_ld1q_##suffix(ptr);                                          \
-    _Tpv v1 = msa_ld1q_##suffix(ptr + 2);                                      \
-    _Tpv v2 = msa_ld1q_##suffix(ptr + 4);                                      \
-    _Tpv v3 = msa_ld1q_##suffix(ptr + 6);                                      \
-    *a = (_Tpv)__builtin_msa_ilvr_d((_Tpvs)v2, (_Tpvs)v0);                     \
-    *b = (_Tpv)__builtin_msa_ilvl_d((_Tpvs)v2, (_Tpvs)v0);                     \
-    *c = (_Tpv)__builtin_msa_ilvr_d((_Tpvs)v3, (_Tpvs)v1);                     \
-    *d = (_Tpv)__builtin_msa_ilvl_d((_Tpvs)v3, (_Tpvs)v1);                     \
-  }                                                                            \
-  __extension__ extern __inline void __attribute__((                           \
-      __always_inline__, __gnu_inline__,                                       \
-      __artificial__)) msa_st4q_##suffix(_Tp *ptr, const _Tpv a, const _Tpv b, \
-                                         const _Tpv c, const _Tpv d) {         \
-    msa_st1q_##suffix(ptr, (_Tpv)__builtin_msa_ilvr_d((_Tpvs)b, (_Tpvs)a));    \
-    msa_st1q_##suffix(ptr + 2,                                                 \
-                      (_Tpv)__builtin_msa_ilvr_d((_Tpvs)d, (_Tpvs)c));         \
-    msa_st1q_##suffix(ptr + 4,                                                 \
-                      (_Tpv)__builtin_msa_ilvl_d((_Tpvs)b, (_Tpvs)a));         \
-    msa_st1q_##suffix(ptr + 6,                                                 \
-                      (_Tpv)__builtin_msa_ilvl_d((_Tpvs)d, (_Tpvs)c));         \
-  }
-
-MSA_INTERLEAVED_IMPL_LOAD4_STORE4_64(uint64_t, v2u64, v2i64, u64)
-MSA_INTERLEAVED_IMPL_LOAD4_STORE4_64(int64_t, v2i64, v2i64, s64)
-MSA_INTERLEAVED_IMPL_LOAD4_STORE4_64(double, v2f64, v2i64, f64)
-
-__extension__ extern __inline v8i16
-    __attribute__((__always_inline__, __gnu_inline__, __artificial__))
-    msa_qdmulhq_n_s16(v8i16 a, int16_t b) {
-  v8i16 a_lo, a_hi;
-  ILVRL_H2_SH(a, msa_dupq_n_s16(0), a_lo, a_hi);
-  return msa_packr_s32(
-      msa_shlq_n_s32(msa_mulq_s32(msa_paddlq_s16(a_lo), msa_dupq_n_s32(b)), 1),
-      msa_shlq_n_s32(msa_mulq_s32(msa_paddlq_s16(a_hi), msa_dupq_n_s32(b)), 1),
-      16);
-}
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-#endif /*__mips_msa*/
-#endif /* OPENCV_CORE_MSA_MACROS_H */
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/hal/simd_utils.impl.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/hal/simd_utils.impl.hpp
deleted file mode 100644
index 33c272ad85..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/hal/simd_utils.impl.hpp
+++ /dev/null
@@ -1,313 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html
-
-// This header is not standalone. Don't include directly, use "intrin.hpp"
-// instead.
-#ifdef OPENCV_HAL_INTRIN_HPP // defined in intrin.hpp
-
-#if CV_SIMD128 || CV_SIMD128_CPP
-
-template <typename _T> struct Type2Vec128_Traits;
-#define CV_INTRIN_DEF_TYPE2VEC128_TRAITS(type_, vec_type_)                     \
-  template <> struct Type2Vec128_Traits<type_> {                               \
-    typedef vec_type_ vec_type;                                                \
-  }
-
-CV_INTRIN_DEF_TYPE2VEC128_TRAITS(uchar, v_uint8x16);
-CV_INTRIN_DEF_TYPE2VEC128_TRAITS(schar, v_int8x16);
-CV_INTRIN_DEF_TYPE2VEC128_TRAITS(ushort, v_uint16x8);
-CV_INTRIN_DEF_TYPE2VEC128_TRAITS(short, v_int16x8);
-CV_INTRIN_DEF_TYPE2VEC128_TRAITS(unsigned, v_uint32x4);
-CV_INTRIN_DEF_TYPE2VEC128_TRAITS(int, v_int32x4);
-CV_INTRIN_DEF_TYPE2VEC128_TRAITS(float, v_float32x4);
-CV_INTRIN_DEF_TYPE2VEC128_TRAITS(uint64, v_uint64x2);
-CV_INTRIN_DEF_TYPE2VEC128_TRAITS(int64, v_int64x2);
-#if CV_SIMD128_64F
-CV_INTRIN_DEF_TYPE2VEC128_TRAITS(double, v_float64x2);
-#endif
-
-template <typename _T>
-static inline typename Type2Vec128_Traits<_T>::vec_type v_setall(const _T &a);
-
-template <>
-inline Type2Vec128_Traits<uchar>::vec_type v_setall<uchar>(const uchar &a) {
-  return v_setall_u8(a);
-}
-template <>
-inline Type2Vec128_Traits<schar>::vec_type v_setall<schar>(const schar &a) {
-  return v_setall_s8(a);
-}
-template <>
-inline Type2Vec128_Traits<ushort>::vec_type v_setall<ushort>(const ushort &a) {
-  return v_setall_u16(a);
-}
-template <>
-inline Type2Vec128_Traits<short>::vec_type v_setall<short>(const short &a) {
-  return v_setall_s16(a);
-}
-template <>
-inline Type2Vec128_Traits<uint>::vec_type v_setall<uint>(const uint &a) {
-  return v_setall_u32(a);
-}
-template <>
-inline Type2Vec128_Traits<int>::vec_type v_setall<int>(const int &a) {
-  return v_setall_s32(a);
-}
-template <>
-inline Type2Vec128_Traits<uint64>::vec_type v_setall<uint64>(const uint64 &a) {
-  return v_setall_u64(a);
-}
-template <>
-inline Type2Vec128_Traits<int64>::vec_type v_setall<int64>(const int64 &a) {
-  return v_setall_s64(a);
-}
-template <>
-inline Type2Vec128_Traits<float>::vec_type v_setall<float>(const float &a) {
-  return v_setall_f32(a);
-}
-#if CV_SIMD128_64F
-template <>
-inline Type2Vec128_Traits<double>::vec_type v_setall<double>(const double &a) {
-  return v_setall_f64(a);
-}
-#endif
-
-#endif // SIMD128
-
-#if CV_SIMD256
-
-template <typename _T> struct Type2Vec256_Traits;
-#define CV_INTRIN_DEF_TYPE2VEC256_TRAITS(type_, vec_type_)                     \
-  template <> struct Type2Vec256_Traits<type_> {                               \
-    typedef vec_type_ vec_type;                                                \
-  }
-
-CV_INTRIN_DEF_TYPE2VEC256_TRAITS(uchar, v_uint8x32);
-CV_INTRIN_DEF_TYPE2VEC256_TRAITS(schar, v_int8x32);
-CV_INTRIN_DEF_TYPE2VEC256_TRAITS(ushort, v_uint16x16);
-CV_INTRIN_DEF_TYPE2VEC256_TRAITS(short, v_int16x16);
-CV_INTRIN_DEF_TYPE2VEC256_TRAITS(unsigned, v_uint32x8);
-CV_INTRIN_DEF_TYPE2VEC256_TRAITS(int, v_int32x8);
-CV_INTRIN_DEF_TYPE2VEC256_TRAITS(float, v_float32x8);
-CV_INTRIN_DEF_TYPE2VEC256_TRAITS(uint64, v_uint64x4);
-CV_INTRIN_DEF_TYPE2VEC256_TRAITS(int64, v_int64x4);
-#if CV_SIMD256_64F
-CV_INTRIN_DEF_TYPE2VEC256_TRAITS(double, v_float64x4);
-#endif
-
-template <typename _T>
-static inline typename Type2Vec256_Traits<_T>::vec_type
-v256_setall(const _T &a);
-
-template <>
-inline Type2Vec256_Traits<uchar>::vec_type v256_setall<uchar>(const uchar &a) {
-  return v256_setall_u8(a);
-}
-template <>
-inline Type2Vec256_Traits<schar>::vec_type v256_setall<schar>(const schar &a) {
-  return v256_setall_s8(a);
-}
-template <>
-inline Type2Vec256_Traits<ushort>::vec_type
-v256_setall<ushort>(const ushort &a) {
-  return v256_setall_u16(a);
-}
-template <>
-inline Type2Vec256_Traits<short>::vec_type v256_setall<short>(const short &a) {
-  return v256_setall_s16(a);
-}
-template <>
-inline Type2Vec256_Traits<uint>::vec_type v256_setall<uint>(const uint &a) {
-  return v256_setall_u32(a);
-}
-template <>
-inline Type2Vec256_Traits<int>::vec_type v256_setall<int>(const int &a) {
-  return v256_setall_s32(a);
-}
-template <>
-inline Type2Vec256_Traits<uint64>::vec_type
-v256_setall<uint64>(const uint64 &a) {
-  return v256_setall_u64(a);
-}
-template <>
-inline Type2Vec256_Traits<int64>::vec_type v256_setall<int64>(const int64 &a) {
-  return v256_setall_s64(a);
-}
-template <>
-inline Type2Vec256_Traits<float>::vec_type v256_setall<float>(const float &a) {
-  return v256_setall_f32(a);
-}
-#if CV_SIMD256_64F
-template <>
-inline Type2Vec256_Traits<double>::vec_type
-v256_setall<double>(const double &a) {
-  return v256_setall_f64(a);
-}
-#endif
-
-#endif // SIMD256
-
-#if CV_SIMD512
-
-template <typename _T> struct Type2Vec512_Traits;
-#define CV_INTRIN_DEF_TYPE2VEC512_TRAITS(type_, vec_type_)                     \
-  template <> struct Type2Vec512_Traits<type_> {                               \
-    typedef vec_type_ vec_type;                                                \
-  }
-
-CV_INTRIN_DEF_TYPE2VEC512_TRAITS(uchar, v_uint8x64);
-CV_INTRIN_DEF_TYPE2VEC512_TRAITS(schar, v_int8x64);
-CV_INTRIN_DEF_TYPE2VEC512_TRAITS(ushort, v_uint16x32);
-CV_INTRIN_DEF_TYPE2VEC512_TRAITS(short, v_int16x32);
-CV_INTRIN_DEF_TYPE2VEC512_TRAITS(unsigned, v_uint32x16);
-CV_INTRIN_DEF_TYPE2VEC512_TRAITS(int, v_int32x16);
-CV_INTRIN_DEF_TYPE2VEC512_TRAITS(float, v_float32x16);
-CV_INTRIN_DEF_TYPE2VEC512_TRAITS(uint64, v_uint64x8);
-CV_INTRIN_DEF_TYPE2VEC512_TRAITS(int64, v_int64x8);
-#if CV_SIMD512_64F
-CV_INTRIN_DEF_TYPE2VEC512_TRAITS(double, v_float64x8);
-#endif
-
-template <typename _T>
-static inline typename Type2Vec512_Traits<_T>::vec_type
-v512_setall(const _T &a);
-
-template <>
-inline Type2Vec512_Traits<uchar>::vec_type v512_setall<uchar>(const uchar &a) {
-  return v512_setall_u8(a);
-}
-template <>
-inline Type2Vec512_Traits<schar>::vec_type v512_setall<schar>(const schar &a) {
-  return v512_setall_s8(a);
-}
-template <>
-inline Type2Vec512_Traits<ushort>::vec_type
-v512_setall<ushort>(const ushort &a) {
-  return v512_setall_u16(a);
-}
-template <>
-inline Type2Vec512_Traits<short>::vec_type v512_setall<short>(const short &a) {
-  return v512_setall_s16(a);
-}
-template <>
-inline Type2Vec512_Traits<uint>::vec_type v512_setall<uint>(const uint &a) {
-  return v512_setall_u32(a);
-}
-template <>
-inline Type2Vec512_Traits<int>::vec_type v512_setall<int>(const int &a) {
-  return v512_setall_s32(a);
-}
-template <>
-inline Type2Vec512_Traits<uint64>::vec_type
-v512_setall<uint64>(const uint64 &a) {
-  return v512_setall_u64(a);
-}
-template <>
-inline Type2Vec512_Traits<int64>::vec_type v512_setall<int64>(const int64 &a) {
-  return v512_setall_s64(a);
-}
-template <>
-inline Type2Vec512_Traits<float>::vec_type v512_setall<float>(const float &a) {
-  return v512_setall_f32(a);
-}
-#if CV_SIMD512_64F
-template <>
-inline Type2Vec512_Traits<double>::vec_type
-v512_setall<double>(const double &a) {
-  return v512_setall_f64(a);
-}
-#endif
-
-#endif // SIMD512
-
-#if CV_SIMD_SCALABLE
-template <typename _T> struct Type2Vec_Traits;
-#define CV_INTRIN_DEF_TYPE2VEC_TRAITS(type_, vec_type_)                        \
-  template <> struct Type2Vec_Traits<type_> {                                  \
-    typedef vec_type_ vec_type;                                                \
-  }
-
-CV_INTRIN_DEF_TYPE2VEC_TRAITS(uchar, v_uint8);
-CV_INTRIN_DEF_TYPE2VEC_TRAITS(schar, v_int8);
-CV_INTRIN_DEF_TYPE2VEC_TRAITS(ushort, v_uint16);
-CV_INTRIN_DEF_TYPE2VEC_TRAITS(short, v_int16);
-CV_INTRIN_DEF_TYPE2VEC_TRAITS(unsigned, v_uint32);
-CV_INTRIN_DEF_TYPE2VEC_TRAITS(int, v_int32);
-CV_INTRIN_DEF_TYPE2VEC_TRAITS(float, v_float32);
-CV_INTRIN_DEF_TYPE2VEC_TRAITS(uint64, v_uint64);
-CV_INTRIN_DEF_TYPE2VEC_TRAITS(int64, v_int64);
-#if CV_SIMD_SCALABLE_64F
-CV_INTRIN_DEF_TYPE2VEC_TRAITS(double, v_float64);
-#endif
-template <typename _T>
-static inline typename Type2Vec_Traits<_T>::vec_type v_setall(const _T &a);
-
-template <>
-inline Type2Vec_Traits<uchar>::vec_type v_setall<uchar>(const uchar &a) {
-  return v_setall_u8(a);
-}
-template <>
-inline Type2Vec_Traits<schar>::vec_type v_setall<schar>(const schar &a) {
-  return v_setall_s8(a);
-}
-template <>
-inline Type2Vec_Traits<ushort>::vec_type v_setall<ushort>(const ushort &a) {
-  return v_setall_u16(a);
-}
-template <>
-inline Type2Vec_Traits<short>::vec_type v_setall<short>(const short &a) {
-  return v_setall_s16(a);
-}
-template <>
-inline Type2Vec_Traits<uint>::vec_type v_setall<uint>(const uint &a) {
-  return v_setall_u32(a);
-}
-template <> inline Type2Vec_Traits<int>::vec_type v_setall<int>(const int &a) {
-  return v_setall_s32(a);
-}
-template <>
-inline Type2Vec_Traits<uint64>::vec_type v_setall<uint64>(const uint64 &a) {
-  return v_setall_u64(a);
-}
-template <>
-inline Type2Vec_Traits<int64>::vec_type v_setall<int64>(const int64 &a) {
-  return v_setall_s64(a);
-}
-template <>
-inline Type2Vec_Traits<float>::vec_type v_setall<float>(const float &a) {
-  return v_setall_f32(a);
-}
-#if CV_SIMD_SCALABLE_64F
-template <>
-inline Type2Vec_Traits<double>::vec_type v_setall<double>(const double &a) {
-  return v_setall_f64(a);
-}
-#endif
-#endif
-
-#if CV_SIMD_SCALABLE
-template <typename _T>
-static inline typename Type2Vec_Traits<_T>::vec_type vx_setall(const _T &a) {
-  return v_setall(a);
-}
-#elif CV_SIMD_WIDTH == 16
-template <typename _T>
-static inline typename Type2Vec128_Traits<_T>::vec_type vx_setall(const _T &a) {
-  return v_setall(a);
-}
-#elif CV_SIMD_WIDTH == 32
-template <typename _T>
-static inline typename Type2Vec256_Traits<_T>::vec_type vx_setall(const _T &a) {
-  return v256_setall(a);
-}
-#elif CV_SIMD_WIDTH == 64
-template <typename _T>
-static inline typename Type2Vec512_Traits<_T>::vec_type vx_setall(const _T &a) {
-  return v512_setall(a);
-}
-#else
-#error "Build configuration error, unsupported CV_SIMD_WIDTH"
-#endif
-
-#endif // OPENCV_HAL_INTRIN_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/mat.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/mat.hpp
deleted file mode 100644
index e2621f28f9..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/mat.hpp
+++ /dev/null
@@ -1,3842 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_CORE_MAT_HPP
-#define OPENCV_CORE_MAT_HPP
-
-#ifndef __cplusplus
-#error mat.hpp header must be compiled as C++
-#endif
-
-#include "opencv2/core/matx.hpp"
-#include "opencv2/core/types.hpp"
-
-#include "opencv2/core/bufferpool.hpp"
-
-#include <array>
-#include <type_traits>
-
-namespace cv {
-
-//! @addtogroup core_basic
-//! @{
-
-enum AccessFlag {
-  ACCESS_READ = 1 << 24,
-  ACCESS_WRITE = 1 << 25,
-  ACCESS_RW = 3 << 24,
-  ACCESS_MASK = ACCESS_RW,
-  ACCESS_FAST = 1 << 26
-};
-CV_ENUM_FLAGS(AccessFlag)
-__CV_ENUM_FLAGS_BITWISE_AND(AccessFlag, int, AccessFlag)
-
-CV__DEBUG_NS_BEGIN
-
-class CV_EXPORTS _OutputArray;
-
-//////////////////////// Input/Output Array Arguments
-////////////////////////////////////
-
-/** @brief This is the proxy class for passing read-only input arrays into
-OpenCV functions.
-
-It is defined as:
-@code
-    typedef const _InputArray& InputArray;
-@endcode
-where \ref cv::_InputArray is a class that can be constructed from \ref cv::Mat,
-\ref cv::Mat_<T>,
-\ref cv::Matx<T, m, n>, std::vector<T>, std::vector<std::vector<T>>,
-std::vector<Mat>, std::vector<Mat_<T>>, \ref cv::UMat, std::vector<UMat> or
-`double`. It can also be constructed from a matrix expression.
-
-Since this is mostly implementation-level class, and its interface may change in
-future versions, we do not describe it in details. There are a few key things,
-though, that should be kept in mind:
-
--   When you see in the reference manual or in OpenCV source code a function
-that takes InputArray, it means that you can actually pass `Mat`, `Matx`,
-`vector<T>` etc. (see above the complete list).
--   Optional input arguments: If some of the input arrays may be empty, pass
-cv::noArray() (or simply cv::Mat() as you probably did before).
--   The class is designed solely for passing parameters. That is, normally you
-*should not* declare class members, local and global variables of this type.
--   If you want to design your own function or a class method that can operate
-of arrays of multiple types, you can use InputArray (or OutputArray) for the
-respective parameters. Inside a function you should use _InputArray::getMat()
-method to construct a matrix header for the array (without copying data).
-_InputArray::kind() can be used to distinguish Mat from `vector<>` etc., but
-normally it is not needed.
-
-Here is how you can use a function that takes InputArray :
-@code
-    std::vector<Point2f> vec;
-    // points or a circle
-    for( int i = 0; i < 30; i++ )
-        vec.push_back(Point2f((float)(100 + 30*cos(i*CV_PI*2/5)),
-                              (float)(100 - 30*sin(i*CV_PI*2/5))));
-    cv::transform(vec, vec, cv::Matx23f(0.707, -0.707, 10, 0.707, 0.707, 20));
-@endcode
-That is, we form an STL vector containing points, and apply in-place affine
-transformation to the vector using the 2x3 matrix created inline as `Matx<float,
-2, 3>` instance.
-
-Here is how such a function can be implemented (for simplicity, we implement a
-very specific case of it, according to the assertion statement inside) :
-@code
-    void myAffineTransform(InputArray _src, OutputArray _dst, InputArray _m)
-    {
-        // get Mat headers for input arrays. This is O(1) operation,
-        // unless _src and/or _m are matrix expressions.
-        Mat src = _src.getMat(), m = _m.getMat();
-        CV_Assert( src.type() == CV_32FC2 && m.type() == CV_32F && m.size() ==
-Size(3, 2) );
-
-        // [re]create the output array so that it has the proper size and type.
-        // In case of Mat it calls Mat::create, in case of STL vector it calls
-vector::resize. _dst.create(src.size(), src.type()); Mat dst = _dst.getMat();
-
-        for( int i = 0; i < src.rows; i++ )
-            for( int j = 0; j < src.cols; j++ )
-            {
-                Point2f pt = src.at<Point2f>(i, j);
-                dst.at<Point2f>(i, j) = Point2f(m.at<float>(0, 0)*pt.x +
-                                                m.at<float>(0, 1)*pt.y +
-                                                m.at<float>(0, 2),
-                                                m.at<float>(1, 0)*pt.x +
-                                                m.at<float>(1, 1)*pt.y +
-                                                m.at<float>(1, 2));
-            }
-    }
-@endcode
-There is another related type, InputArrayOfArrays, which is currently defined as
-a synonym for InputArray:
-@code
-    typedef InputArray InputArrayOfArrays;
-@endcode
-It denotes function arguments that are either vectors of vectors or vectors of
-matrices. A separate synonym is needed to generate Python/Java etc. wrappers
-properly. At the function implementation level their use is similar, but
-_InputArray::getMat(idx) should be used to get header for the idx-th component
-of the outer vector and _InputArray::size().area() should be used to find the
-number of components (vectors/matrices) of the outer vector.
-
-In general, type support is limited to cv::Mat types. Other types are forbidden.
-But in some cases we need to support passing of custom non-general Mat types,
-like arrays of cv::KeyPoint, cv::DMatch, etc. This data is not intended to be
-interpreted as an image data, or processed somehow like regular cv::Mat. To pass
-such custom type use rawIn() / rawOut() / rawInOut() wrappers. Custom type is
-wrapped as Mat-compatible `CV_8UC<N>` values (N = sizeof(T), N <= CV_CN_MAX).
- */
-class CV_EXPORTS _InputArray {
-public:
-  enum KindFlag {
-    KIND_SHIFT = 16,
-    FIXED_TYPE = 0x8000 << KIND_SHIFT,
-    FIXED_SIZE = 0x4000 << KIND_SHIFT,
-    KIND_MASK = 31 << KIND_SHIFT,
-
-    NONE = 0 << KIND_SHIFT,
-    MAT = 1 << KIND_SHIFT,
-    MATX = 2 << KIND_SHIFT,
-    STD_VECTOR = 3 << KIND_SHIFT,
-    STD_VECTOR_VECTOR = 4 << KIND_SHIFT,
-    STD_VECTOR_MAT = 5 << KIND_SHIFT,
-#if OPENCV_ABI_COMPATIBILITY < 500
-    EXPR =
-        6
-        << KIND_SHIFT, //!< removed: https://github.com/opencv/opencv/pull/17046
-#endif
-    STD_BOOL_VECTOR = 12 << KIND_SHIFT,
-#if OPENCV_ABI_COMPATIBILITY < 500
-    STD_ARRAY =
-        14 << KIND_SHIFT, //!< removed:
-                          //!< https://github.com/opencv/opencv/issues/18897
-#endif
-    STD_ARRAY_MAT = 15 << KIND_SHIFT
-  };
-
-  _InputArray();
-  _InputArray(int _flags, void *_obj);
-  _InputArray(const Mat &m);
-  _InputArray(const MatExpr &expr);
-  _InputArray(const std::vector<Mat> &vec);
-  template <typename _Tp> _InputArray(const Mat_<_Tp> &m);
-  template <typename _Tp> _InputArray(const std::vector<_Tp> &vec);
-  _InputArray(const std::vector<bool> &vec);
-  template <typename _Tp> _InputArray(const std::vector<std::vector<_Tp>> &vec);
-  _InputArray(const std::vector<std::vector<bool>> &) = delete; // not supported
-  template <typename _Tp> _InputArray(const std::vector<Mat_<_Tp>> &vec);
-  template <typename _Tp> _InputArray(const _Tp *vec, int n);
-  template <typename _Tp, int m, int n>
-  _InputArray(const Matx<_Tp, m, n> &matx);
-  _InputArray(const double &val);
-
-  template <typename _Tp, std::size_t _Nm>
-  _InputArray(const std::array<_Tp, _Nm> &arr);
-  template <std::size_t _Nm> _InputArray(const std::array<Mat, _Nm> &arr);
-
-  template <typename _Tp> static _InputArray rawIn(const std::vector<_Tp> &vec);
-  template <typename _Tp, std::size_t _Nm>
-  static _InputArray rawIn(const std::array<_Tp, _Nm> &arr);
-
-  Mat getMat(int idx = -1) const;
-  Mat getMat_(int idx = -1) const;
-  void getMatVector(std::vector<Mat> &mv) const;
-
-  int getFlags() const;
-  void *getObj() const;
-  Size getSz() const;
-
-  _InputArray::KindFlag kind() const;
-  int dims(int i = -1) const;
-  int cols(int i = -1) const;
-  int rows(int i = -1) const;
-  Size size(int i = -1) const;
-  int sizend(int *sz, int i = -1) const;
-  bool sameSize(const _InputArray &arr) const;
-  size_t total(int i = -1) const;
-  int type(int i = -1) const;
-  int depth(int i = -1) const;
-  int channels(int i = -1) const;
-  bool isContinuous(int i = -1) const;
-  bool isSubmatrix(int i = -1) const;
-  bool empty() const;
-  void copyTo(const _OutputArray &arr) const;
-  void copyTo(const _OutputArray &arr, const _InputArray &mask) const;
-  size_t offset(int i = -1) const;
-  size_t step(int i = -1) const;
-  bool isMat() const;
-  bool isMatVector() const;
-  bool isMatx() const;
-  bool isVector() const;
-  ~_InputArray();
-
-protected:
-  int flags;
-  void *obj;
-  Size sz;
-
-  void init(int _flags, const void *_obj);
-  void init(int _flags, const void *_obj, Size _sz);
-};
-CV_ENUM_FLAGS(_InputArray::KindFlag)
-__CV_ENUM_FLAGS_BITWISE_AND(_InputArray::KindFlag, int, _InputArray::KindFlag)
-
-/** @brief This type is very similar to InputArray except that it is used for
-input/output and output function parameters.
-
-Just like with InputArray, OpenCV users should not care about OutputArray, they
-just pass `Mat`, `vector<T>` etc. to the functions. The same limitation as for
-`InputArray`: *Do not explicitly create OutputArray instances* applies here too.
-
-If you want to make your function polymorphic (i.e. accept different arrays as
-output parameters), it is also not very difficult. Take the sample above as the
-reference. Note that _OutputArray::create() needs to be called before
-_OutputArray::getMat(). This way you guarantee that the output array is properly
-allocated.
-
-Optional output parameters. If you do not need certain output array to be
-computed and returned to you, pass cv::noArray(), just like you would in the
-case of optional input array. At the implementation level, use
-_OutputArray::needed() to check if certain output array needs to be computed or
-not.
-
-There are several synonyms for OutputArray that are used to assist automatic
-Python/Java/... wrapper generators:
-@code
-    typedef OutputArray OutputArrayOfArrays;
-    typedef OutputArray InputOutputArray;
-    typedef OutputArray InputOutputArrayOfArrays;
-@endcode
- */
-class CV_EXPORTS _OutputArray : public _InputArray {
-public:
-  enum DepthMask {
-    DEPTH_MASK_8U = 1 << CV_8U,
-    DEPTH_MASK_8S = 1 << CV_8S,
-    DEPTH_MASK_16U = 1 << CV_16U,
-    DEPTH_MASK_16S = 1 << CV_16S,
-    DEPTH_MASK_32S = 1 << CV_32S,
-    DEPTH_MASK_32F = 1 << CV_32F,
-    DEPTH_MASK_64F = 1 << CV_64F,
-    DEPTH_MASK_16F = 1 << CV_16F,
-    DEPTH_MASK_ALL = (DEPTH_MASK_64F << 1) - 1,
-    DEPTH_MASK_ALL_BUT_8S = DEPTH_MASK_ALL & ~DEPTH_MASK_8S,
-    DEPTH_MASK_ALL_16F = (DEPTH_MASK_16F << 1) - 1,
-    DEPTH_MASK_FLT = DEPTH_MASK_32F + DEPTH_MASK_64F
-  };
-
-  _OutputArray();
-  _OutputArray(int _flags, void *_obj);
-  _OutputArray(Mat &m);
-  _OutputArray(std::vector<Mat> &vec);
-  template <typename _Tp> _OutputArray(std::vector<_Tp> &vec);
-  _OutputArray(std::vector<bool> &vec) = delete; // not supported
-  template <typename _Tp> _OutputArray(std::vector<std::vector<_Tp>> &vec);
-  _OutputArray(std::vector<std::vector<bool>> &) = delete; // not supported
-  template <typename _Tp> _OutputArray(std::vector<Mat_<_Tp>> &vec);
-  template <typename _Tp> _OutputArray(Mat_<_Tp> &m);
-  template <typename _Tp> _OutputArray(_Tp *vec, int n);
-  template <typename _Tp, int m, int n> _OutputArray(Matx<_Tp, m, n> &matx);
-
-  _OutputArray(const Mat &m);
-  _OutputArray(const std::vector<Mat> &vec);
-  template <typename _Tp> _OutputArray(const std::vector<_Tp> &vec);
-  template <typename _Tp>
-  _OutputArray(const std::vector<std::vector<_Tp>> &vec);
-  template <typename _Tp> _OutputArray(const std::vector<Mat_<_Tp>> &vec);
-  template <typename _Tp> _OutputArray(const Mat_<_Tp> &m);
-  template <typename _Tp> _OutputArray(const _Tp *vec, int n);
-  template <typename _Tp, int m, int n>
-  _OutputArray(const Matx<_Tp, m, n> &matx);
-
-  template <typename _Tp, std::size_t _Nm>
-  _OutputArray(std::array<_Tp, _Nm> &arr);
-  template <typename _Tp, std::size_t _Nm>
-  _OutputArray(const std::array<_Tp, _Nm> &arr);
-  template <std::size_t _Nm> _OutputArray(std::array<Mat, _Nm> &arr);
-  template <std::size_t _Nm> _OutputArray(const std::array<Mat, _Nm> &arr);
-
-  template <typename _Tp> static _OutputArray rawOut(std::vector<_Tp> &vec);
-  template <typename _Tp, std::size_t _Nm>
-  static _OutputArray rawOut(std::array<_Tp, _Nm> &arr);
-
-  bool fixedSize() const;
-  bool fixedType() const;
-  bool needed() const;
-  Mat &getMatRef(int i = -1) const;
-  void create(Size sz, int type, int i = -1, bool allowTransposed = false,
-              _OutputArray::DepthMask fixedDepthMask =
-                  static_cast<_OutputArray::DepthMask>(0)) const;
-  void create(int rows, int cols, int type, int i = -1,
-              bool allowTransposed = false,
-              _OutputArray::DepthMask fixedDepthMask =
-                  static_cast<_OutputArray::DepthMask>(0)) const;
-  void create(int dims, const int *size, int type, int i = -1,
-              bool allowTransposed = false,
-              _OutputArray::DepthMask fixedDepthMask =
-                  static_cast<_OutputArray::DepthMask>(0)) const;
-  void createSameSize(const _InputArray &arr, int mtype) const;
-  void release() const;
-  void clear() const;
-  void setTo(const _InputArray &value,
-             const _InputArray &mask = _InputArray()) const;
-
-  void assign(const Mat &m) const;
-
-  void assign(const std::vector<Mat> &v) const;
-
-  void move(Mat &m) const;
-};
-
-class CV_EXPORTS _InputOutputArray : public _OutputArray {
-public:
-  _InputOutputArray();
-  _InputOutputArray(int _flags, void *_obj);
-  _InputOutputArray(Mat &m);
-  _InputOutputArray(std::vector<Mat> &vec);
-  template <typename _Tp> _InputOutputArray(std::vector<_Tp> &vec);
-  _InputOutputArray(std::vector<bool> &vec) = delete; // not supported
-  template <typename _Tp> _InputOutputArray(std::vector<std::vector<_Tp>> &vec);
-  template <typename _Tp> _InputOutputArray(std::vector<Mat_<_Tp>> &vec);
-  template <typename _Tp> _InputOutputArray(Mat_<_Tp> &m);
-  template <typename _Tp> _InputOutputArray(_Tp *vec, int n);
-  template <typename _Tp, int m, int n>
-  _InputOutputArray(Matx<_Tp, m, n> &matx);
-
-  _InputOutputArray(const Mat &m);
-  _InputOutputArray(const std::vector<Mat> &vec);
-  template <typename _Tp> _InputOutputArray(const std::vector<_Tp> &vec);
-  template <typename _Tp>
-  _InputOutputArray(const std::vector<std::vector<_Tp>> &vec);
-  template <typename _Tp> _InputOutputArray(const std::vector<Mat_<_Tp>> &vec);
-  template <typename _Tp> _InputOutputArray(const Mat_<_Tp> &m);
-  template <typename _Tp> _InputOutputArray(const _Tp *vec, int n);
-  template <typename _Tp, int m, int n>
-  _InputOutputArray(const Matx<_Tp, m, n> &matx);
-
-  template <typename _Tp, std::size_t _Nm>
-  _InputOutputArray(std::array<_Tp, _Nm> &arr);
-  template <typename _Tp, std::size_t _Nm>
-  _InputOutputArray(const std::array<_Tp, _Nm> &arr);
-  template <std::size_t _Nm> _InputOutputArray(std::array<Mat, _Nm> &arr);
-  template <std::size_t _Nm> _InputOutputArray(const std::array<Mat, _Nm> &arr);
-
-  template <typename _Tp>
-  static _InputOutputArray rawInOut(std::vector<_Tp> &vec);
-  template <typename _Tp, std::size_t _Nm>
-  _InputOutputArray rawInOut(std::array<_Tp, _Nm> &arr);
-};
-
-/** Helper to wrap custom types. @see InputArray */
-template <typename _Tp> static inline _InputArray rawIn(_Tp &v);
-/** Helper to wrap custom types. @see InputArray */
-template <typename _Tp> static inline _OutputArray rawOut(_Tp &v);
-/** Helper to wrap custom types. @see InputArray */
-template <typename _Tp> static inline _InputOutputArray rawInOut(_Tp &v);
-
-CV__DEBUG_NS_END
-
-typedef const _InputArray &InputArray;
-typedef InputArray InputArrayOfArrays;
-typedef const _OutputArray &OutputArray;
-typedef OutputArray OutputArrayOfArrays;
-typedef const _InputOutputArray &InputOutputArray;
-typedef InputOutputArray InputOutputArrayOfArrays;
-
-/** @brief Returns an empty InputArray or OutputArray.
-
- This function is used to provide an "empty" or "null" array when certain
- functions take optional input or output arrays that you don't want to provide.
-
- Many OpenCV functions accept optional arguments as `cv::InputArray` or
- `cv::OutputArray`. When you don't want to pass any data for these optional
- parameters, you can use `cv::noArray()` to indicate that you are omitting them.
-
- @return An empty `cv::InputArray` or `cv::OutputArray` that can be used as a
- placeholder.
-
- @note This is often used when a function has optional arrays, and you do not
- want to provide a specific input or output array.
-
- @see cv::InputArray, cv::OutputArray
- */
-CV_EXPORTS InputOutputArray noArray();
-
-/////////////////////////////////// MatAllocator
-/////////////////////////////////////////
-
-/** @brief  Usage flags for allocator
-
- @warning  All flags except `USAGE_DEFAULT` are experimental.
-
- @warning  For the OpenCL allocator, `USAGE_ALLOCATE_SHARED_MEMORY` depends on
- OpenCV's optional, experimental integration with OpenCL SVM. To enable this
- integration, build OpenCV using the `WITH_OPENCL_SVM=ON` CMake option and, at
- runtime, call `cv::ocl::Context::getDefault().setUseSVM(true);` or similar
- code. Note that SVM is incompatible with OpenCL 1.x.
-*/
-enum UMatUsageFlags {
-  USAGE_DEFAULT = 0,
-
-  // buffer allocation policy is platform and usage specific
-  USAGE_ALLOCATE_HOST_MEMORY = 1 << 0,
-  USAGE_ALLOCATE_DEVICE_MEMORY = 1 << 1,
-  USAGE_ALLOCATE_SHARED_MEMORY =
-      1 << 2, // It is not equal to: USAGE_ALLOCATE_HOST_MEMORY |
-              // USAGE_ALLOCATE_DEVICE_MEMORY
-
-  __UMAT_USAGE_FLAGS_32BIT = 0x7fffffff // Binary compatibility hint
-};
-
-struct CV_EXPORTS UMatData;
-
-/** @brief  Custom array allocator
- */
-class CV_EXPORTS MatAllocator {
-public:
-  MatAllocator() {}
-  virtual ~MatAllocator() {}
-
-  // let's comment it off for now to detect and fix all the uses of allocator
-  // virtual void allocate(int dims, const int* sizes, int type, int*& refcount,
-  //                      uchar*& datastart, uchar*& data, size_t* step) = 0;
-  // virtual void deallocate(int* refcount, uchar* datastart, uchar* data) = 0;
-  virtual UMatData *allocate(int dims, const int *sizes, int type, void *data,
-                             size_t *step, AccessFlag flags,
-                             UMatUsageFlags usageFlags) const = 0;
-  virtual bool allocate(UMatData *data, AccessFlag accessflags,
-                        UMatUsageFlags usageFlags) const = 0;
-  virtual void deallocate(UMatData *data) const = 0;
-  virtual void map(UMatData *data, AccessFlag accessflags) const;
-  virtual void unmap(UMatData *data) const;
-  virtual void download(UMatData *data, void *dst, int dims, const size_t sz[],
-                        const size_t srcofs[], const size_t srcstep[],
-                        const size_t dststep[]) const;
-  virtual void upload(UMatData *data, const void *src, int dims,
-                      const size_t sz[], const size_t dstofs[],
-                      const size_t dststep[], const size_t srcstep[]) const;
-  virtual void copy(UMatData *srcdata, UMatData *dstdata, int dims,
-                    const size_t sz[], const size_t srcofs[],
-                    const size_t srcstep[], const size_t dstofs[],
-                    const size_t dststep[], bool sync) const;
-
-  // default implementation returns DummyBufferPoolController
-  virtual BufferPoolController *
-  getBufferPoolController(const char *id = NULL) const;
-};
-
-//////////////////////////////// MatCommaInitializer
-/////////////////////////////////////
-
-/** @brief  Comma-separated Matrix Initializer
-
- The class instances are usually not created explicitly.
- Instead, they are created on "matrix << firstValue" operator.
-
- The sample below initializes 2x2 rotation matrix:
-
- \code
- double angle = 30, a = cos(angle*CV_PI/180), b = sin(angle*CV_PI/180);
- Mat R = (Mat_<double>(2,2) << a, -b, b, a);
- \endcode
-*/
-template <typename _Tp> class MatCommaInitializer_ {
-public:
-  //! the constructor, created by "matrix << firstValue" operator, where matrix
-  //! is cv::Mat
-  MatCommaInitializer_(Mat_<_Tp> *_m);
-  //! the operator that takes the next value and put it to the matrix
-  template <typename T2> MatCommaInitializer_<_Tp> &operator,(T2 v);
-  //! another form of conversion operator
-  operator Mat_<_Tp>() const;
-
-protected:
-  MatIterator_<_Tp> it;
-};
-
-/////////////////////////////////////// Mat
-//////////////////////////////////////////////
-
-// note that umatdata might be allocated together
-// with the matrix data, not as a separate object.
-// therefore, it does not have constructor or destructor;
-// it should be explicitly initialized using init().
-struct CV_EXPORTS UMatData {
-  enum MemoryFlag {
-    COPY_ON_MAP = 1,
-    HOST_COPY_OBSOLETE = 2,
-    DEVICE_COPY_OBSOLETE = 4,
-    TEMP_UMAT = 8,
-    TEMP_COPIED_UMAT = 24,
-    USER_ALLOCATED = 32,
-    DEVICE_MEM_MAPPED = 64,
-    ASYNC_CLEANUP = 128
-  };
-  UMatData(const MatAllocator *allocator);
-  ~UMatData();
-
-  // provide atomic access to the structure
-  void lock();
-  void unlock();
-
-  bool hostCopyObsolete() const;
-  bool deviceCopyObsolete() const;
-  bool deviceMemMapped() const;
-  bool copyOnMap() const;
-  bool tempUMat() const;
-  bool tempCopiedUMat() const;
-  void markHostCopyObsolete(bool flag);
-  void markDeviceCopyObsolete(bool flag);
-  void markDeviceMemMapped(bool flag);
-
-  const MatAllocator *prevAllocator;
-  const MatAllocator *currAllocator;
-  int urefcount;
-  int refcount;
-  uchar *data;
-  uchar *origdata;
-  size_t size;
-
-  UMatData::MemoryFlag flags;
-  void *handle;
-  void *userdata;
-  int allocatorFlags_;
-  int mapcount;
-  UMatData *originalUMatData;
-  std::shared_ptr<void> allocatorContext;
-};
-CV_ENUM_FLAGS(UMatData::MemoryFlag)
-
-struct CV_EXPORTS MatSize {
-  explicit MatSize(int *_p) CV_NOEXCEPT;
-  int dims() const CV_NOEXCEPT;
-  Size operator()() const;
-  const int &operator[](int i) const;
-  int &operator[](int i);
-  operator const int *() const CV_NOEXCEPT; // TODO OpenCV 4.0: drop this
-  bool operator==(const MatSize &sz) const CV_NOEXCEPT;
-  bool operator!=(const MatSize &sz) const CV_NOEXCEPT;
-
-  int *p;
-};
-
-struct CV_EXPORTS MatStep {
-  MatStep() CV_NOEXCEPT;
-  explicit MatStep(size_t s) CV_NOEXCEPT;
-  const size_t &operator[](int i) const CV_NOEXCEPT;
-  size_t &operator[](int i) CV_NOEXCEPT;
-  operator size_t() const;
-  MatStep &operator=(size_t s);
-
-  size_t *p;
-  size_t buf[2];
-
-protected:
-  MatStep &operator=(const MatStep &);
-};
-
-/** @example samples/cpp/cout_mat.cpp
-An example demonstrating the serial out capabilities of cv::Mat
-*/
-
-/** @brief n-dimensional dense array class \anchor CVMat_Details
-
-The class Mat represents an n-dimensional dense numerical single-channel or
-multi-channel array. It can be used to store real or complex-valued vectors and
-matrices, grayscale or color images, voxel volumes, vector fields, point clouds,
-tensors, histograms (though, very high-dimensional histograms may be better
-stored in a SparseMat ). The data layout of the array `M` is defined by the
-array `M.step[]`, so that the address of element \f$(i_0,...,i_{M.dims-1})\f$,
-where \f$0\leq i_k<M.size[k]\f$, is computed as:
-\f[addr(M_{i_0,...,i_{M.dims-1}}) = M.data + M.step[0]*i_0 + M.step[1]*i_1 + ...
-+ M.step[M.dims-1]*i_{M.dims-1}\f] In case of a 2-dimensional array, the above
-formula is reduced to:
-\f[addr(M_{i,j}) = M.data + M.step[0]*i + M.step[1]*j\f]
-Note that `M.step[i] >= M.step[i+1]` (in fact, `M.step[i] >=
-M.step[i+1]*M.size[i+1]` ). This means that 2-dimensional matrices are stored
-row-by-row, 3-dimensional matrices are stored plane-by-plane, and so on.
-M.step[M.dims-1] is minimal and always equal to the element size M.elemSize() .
-
-So, the data layout in Mat is compatible with the majority of dense array types
-from the standard toolkits and SDKs, such as Numpy (ndarray), Win32 (independent
-device bitmaps), and others, that is, with any array that uses *steps* (or
-*strides*) to compute the position of a pixel. Due to this compatibility, it is
-possible to make a Mat header for user-allocated data and process it in-place
-using OpenCV functions.
-
-There are many different ways to create a Mat object. The most popular options
-are listed below:
-
-- Use the create(nrows, ncols, type) method or the similar Mat(nrows, ncols,
-type[, fillValue]) constructor. A new array of the specified size and type is
-allocated. type has the same meaning as in the cvCreateMat method. For example,
-CV_8UC1 means a 8-bit single-channel array, CV_32FC2 means a 2-channel (complex)
-floating-point array, and so on.
-@code
-   // make a 7x7 complex matrix filled with 1+3j.
-   Mat M(7,7,CV_32FC2,Scalar(1,3));
-   // and now turn M to a 100x60 15-channel 8-bit matrix.
-   // The old content will be deallocated
-   M.create(100,60,CV_8UC(15));
-@endcode
-As noted in the introduction to this chapter, create() allocates only a new
-array when the shape or type of the current array are different from the
-specified ones.
-
-- Create a multi-dimensional array:
-@code
-   // create a 100x100x100 8-bit array
-   int sz[] = {100, 100, 100};
-   Mat bigCube(3, sz, CV_8U, Scalar::all(0));
-@endcode
-It passes the number of dimensions =1 to the Mat constructor but the created
-array will be 2-dimensional with the number of columns set to 1. So, Mat::dims
-is always \>= 2 (can also be 0 when the array is empty).
-
-- Use a copy constructor or assignment operator where there can be an array or
-expression on the right side (see below). As noted in the introduction, the
-array assignment is an O(1) operation because it only copies the header and
-increases the reference counter. The Mat::clone() method can be used to get a
-full (deep) copy of the array when you need it.
-
-- Construct a header for a part of another array. It can be a single row, single
-column, several rows, several columns, rectangular region in the array (called a
-*minor* in algebra) or a diagonal. Such operations are also O(1) because the new
-header references the same data. You can actually modify a part of the array
-using this feature, for example:
-@code
-   // add the 5-th row, multiplied by 3 to the 3rd row
-   M.row(3) = M.row(3) + M.row(5)*3;
-   // now copy the 7-th column to the 1-st column
-   // M.col(1) = M.col(7); // this will not work
-   Mat M1 = M.col(1);
-   M.col(7).copyTo(M1);
-   // create a new 320x240 image
-   Mat img(Size(320,240),CV_8UC3);
-   // select a ROI
-   Mat roi(img, Rect(10,10,100,100));
-   // fill the ROI with (0,255,0) (which is green in RGB space);
-   // the original 320x240 image will be modified
-   roi = Scalar(0,255,0);
-@endcode
-Due to the additional datastart and dataend members, it is possible to compute a
-relative sub-array position in the main *container* array using locateROI():
-@code
-   Mat A = Mat::eye(10, 10, CV_32S);
-   // extracts A columns, 1 (inclusive) to 3 (exclusive).
-   Mat B = A(Range::all(), Range(1, 3));
-   // extracts B rows, 5 (inclusive) to 9 (exclusive).
-   // that is, C \~ A(Range(5, 9), Range(1, 3))
-   Mat C = B(Range(5, 9), Range::all());
-   Size size; Point ofs;
-   C.locateROI(size, ofs);
-   // size will be (width=10,height=10) and the ofs will be (x=1, y=5)
-@endcode
-As in case of whole matrices, if you need a deep copy, use the `clone()` method
-of the extracted sub-matrices.
-
-- Make a header for user-allocated data. It can be useful to do the following:
-   -# Process "foreign" data using OpenCV (for example, when you implement a
-DirectShow\* filter or a processing module for gstreamer, and so on). For
-example:
-   @code
-       Mat process_video_frame(const unsigned char* pixels,
-                               int width, int height, int step)
-       {
-           // wrap input buffer
-           Mat img(height, width, CV_8UC3, (unsigned char*)pixels, step);
-
-           Mat result;
-           GaussianBlur(img, result, Size(7, 7), 1.5, 1.5);
-
-           return result;
-       }
-   @endcode
-   -# Quickly initialize small matrices and/or get a super-fast element access.
-   @code
-       double m[3][3] = {{a, b, c}, {d, e, f}, {g, h, i}};
-       Mat M = Mat(3, 3, CV_64F, m).inv();
-   @endcode
-   .
-
-- Use MATLAB-style array initializers, zeros(), ones(), eye(), for example:
-@code
-   // create a double-precision identity matrix and add it to M.
-   M += Mat::eye(M.rows, M.cols, CV_64F);
-@endcode
-
-- Use a comma-separated initializer:
-@code
-   // create a 3x3 double-precision identity matrix
-   Mat M = (Mat_<double>(3,3) << 1, 0, 0, 0, 1, 0, 0, 0, 1);
-@endcode
-With this approach, you first call a constructor of the Mat class with the
-proper parameters, and then you just put `<< operator` followed by
-comma-separated values that can be constants, variables, expressions, and so on.
-Also, note the extra parentheses required to avoid compilation errors.
-
-Once the array is created, it is automatically managed via a reference-counting
-mechanism. If the array header is built on top of user-allocated data, you
-should handle the data by yourself. The array data is deallocated when no one
-points to it. If you want to release the data pointed by a array header before
-the array destructor is called, use Mat::release().
-
-The next important thing to learn about the array class is element access. This
-manual already described how to compute an address of each array element.
-Normally, you are not required to use the formula directly in the code. If you
-know the array element type (which can be retrieved using the method Mat::type()
-), you can access the element \f$M_{ij}\f$ of a 2-dimensional array as:
-@code
-   M.at<double>(i,j) += 1.f;
-@endcode
-assuming that `M` is a double-precision floating-point array. There are several
-variants of the method at for a different number of dimensions.
-
-If you need to process a whole row of a 2D array, the most efficient way is to
-get the pointer to the row first, and then just use the plain C operator [] :
-@code
-   // compute sum of positive matrix elements
-   // (assuming that M is a double-precision matrix)
-   double sum=0;
-   for(int i = 0; i < M.rows; i++)
-   {
-       const double* Mi = M.ptr<double>(i);
-       for(int j = 0; j < M.cols; j++)
-           sum += std::max(Mi[j], 0.);
-   }
-@endcode
-Some operations, like the one above, do not actually depend on the array shape.
-They just process elements of an array one by one (or elements from multiple
-arrays that have the same coordinates, for example, array addition). Such
-operations are called *element-wise*. It makes sense to check whether all the
-input/output arrays are continuous, namely, have no gaps at the end of each row.
-If yes, process them as a long single row:
-@code
-   // compute the sum of positive matrix elements, optimized variant
-   double sum=0;
-   int cols = M.cols, rows = M.rows;
-   if(M.isContinuous())
-   {
-       cols *= rows;
-       rows = 1;
-   }
-   for(int i = 0; i < rows; i++)
-   {
-       const double* Mi = M.ptr<double>(i);
-       for(int j = 0; j < cols; j++)
-           sum += std::max(Mi[j], 0.);
-   }
-@endcode
-In case of the continuous matrix, the outer loop body is executed just once. So,
-the overhead is smaller, which is especially noticeable in case of small
-matrices.
-
-Finally, there are STL-style iterators that are smart enough to skip gaps
-between successive rows:
-@code
-   // compute sum of positive matrix elements, iterator-based variant
-   double sum=0;
-   MatConstIterator_<double> it = M.begin<double>(), it_end = M.end<double>();
-   for(; it != it_end; ++it)
-       sum += std::max(*it, 0.);
-@endcode
-The matrix iterators are random-access iterators, so they can be passed to any
-STL algorithm, including std::sort().
-
-@note Matrix Expressions and arithmetic see MatExpr
-*/
-class CV_EXPORTS Mat {
-public:
-  /**
-  These are various constructors that form a matrix. As noted in the
-  AutomaticAllocation, often the default constructor is enough, and the proper
-  matrix will be allocated by an OpenCV function. The constructed matrix can
-  further be assigned to another matrix or matrix expression or can be allocated
-  with Mat::create . In the former case, the old content is de-referenced.
-   */
-  Mat() CV_NOEXCEPT;
-
-  /** @overload
-  @param rows Number of rows in a 2D array.
-  @param cols Number of columns in a 2D array.
-  @param type Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel
-  matrices, or CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to
-  CV_CN_MAX channels) matrices.
-  */
-  Mat(int rows, int cols, int type);
-
-  /** @overload
-  @param size 2D array size: Size(cols, rows) . In the Size() constructor, the
-  number of rows and the number of columns go in the reverse order.
-  @param type Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel
-  matrices, or CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to
-  CV_CN_MAX channels) matrices.
-    */
-  Mat(Size size, int type);
-
-  /** @overload
-  @param rows Number of rows in a 2D array.
-  @param cols Number of columns in a 2D array.
-  @param type Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel
-  matrices, or CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to
-  CV_CN_MAX channels) matrices.
-  @param s An optional value to initialize each matrix element with. To set all
-  the matrix elements to the particular value after the construction, use the
-  assignment operator Mat::operator=(const Scalar& value) .
-  */
-  Mat(int rows, int cols, int type, const Scalar &s);
-
-  /** @overload
-  @param size 2D array size: Size(cols, rows) . In the Size() constructor, the
-  number of rows and the number of columns go in the reverse order.
-  @param type Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel
-  matrices, or CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to
-  CV_CN_MAX channels) matrices.
-  @param s An optional value to initialize each matrix element with. To set all
-  the matrix elements to the particular value after the construction, use the
-  assignment operator Mat::operator=(const Scalar& value) .
-    */
-  Mat(Size size, int type, const Scalar &s);
-
-  /** @overload
-  @param ndims Array dimensionality.
-  @param sizes Array of integers specifying an n-dimensional array shape.
-  @param type Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel
-  matrices, or CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to
-  CV_CN_MAX channels) matrices.
-  */
-  Mat(int ndims, const int *sizes, int type);
-
-  /** @overload
-  @param sizes Array of integers specifying an n-dimensional array shape.
-  @param type Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel
-  matrices, or CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to
-  CV_CN_MAX channels) matrices.
-  */
-  Mat(const std::vector<int> &sizes, int type);
-
-  /** @overload
-  @param ndims Array dimensionality.
-  @param sizes Array of integers specifying an n-dimensional array shape.
-  @param type Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel
-  matrices, or CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to
-  CV_CN_MAX channels) matrices.
-  @param s An optional value to initialize each matrix element with. To set all
-  the matrix elements to the particular value after the construction, use the
-  assignment operator Mat::operator=(const Scalar& value) .
-  */
-  Mat(int ndims, const int *sizes, int type, const Scalar &s);
-
-  /** @overload
-  @param sizes Array of integers specifying an n-dimensional array shape.
-  @param type Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel
-  matrices, or CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to
-  CV_CN_MAX channels) matrices.
-  @param s An optional value to initialize each matrix element with. To set all
-  the matrix elements to the particular value after the construction, use the
-  assignment operator Mat::operator=(const Scalar& value) .
-  */
-  Mat(const std::vector<int> &sizes, int type, const Scalar &s);
-
-  /** @overload
-  @param m Array that (as a whole or partly) is assigned to the constructed
-  matrix. No data is copied by these constructors. Instead, the header pointing
-  to m data or its sub-array is constructed and associated with it. The
-  reference counter, if any, is incremented. So, when you modify the matrix
-  formed using such a constructor, you also modify the corresponding elements of
-  m . If you want to have an independent copy of the sub-array, use Mat::clone()
-  .
-  */
-  Mat(const Mat &m);
-
-  /** @overload
-  @param rows Number of rows in a 2D array.
-  @param cols Number of columns in a 2D array.
-  @param type Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel
-  matrices, or CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to
-  CV_CN_MAX channels) matrices.
-  @param data Pointer to the user data. Matrix constructors that take data and
-  step parameters do not allocate matrix data. Instead, they just initialize the
-  matrix header that points to the specified data, which means that no data is
-  copied. This operation is very efficient and can be used to process external
-  data using OpenCV functions. The external data is not automatically
-  deallocated, so you should take care of it.
-  @param step Number of bytes each matrix row occupies. The value should include
-  the padding bytes at the end of each row, if any. If the parameter is missing
-  (set to AUTO_STEP ), no padding is assumed and the actual step is calculated
-  as cols*elemSize(). See Mat::elemSize.
-  */
-  Mat(int rows, int cols, int type, void *data, size_t step = AUTO_STEP);
-
-  /** @overload
-  @param size 2D array size: Size(cols, rows) . In the Size() constructor, the
-  number of rows and the number of columns go in the reverse order.
-  @param type Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel
-  matrices, or CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to
-  CV_CN_MAX channels) matrices.
-  @param data Pointer to the user data. Matrix constructors that take data and
-  step parameters do not allocate matrix data. Instead, they just initialize the
-  matrix header that points to the specified data, which means that no data is
-  copied. This operation is very efficient and can be used to process external
-  data using OpenCV functions. The external data is not automatically
-  deallocated, so you should take care of it.
-  @param step Number of bytes each matrix row occupies. The value should include
-  the padding bytes at the end of each row, if any. If the parameter is missing
-  (set to AUTO_STEP ), no padding is assumed and the actual step is calculated
-  as cols*elemSize(). See Mat::elemSize.
-  */
-  Mat(Size size, int type, void *data, size_t step = AUTO_STEP);
-
-  /** @overload
-  @param ndims Array dimensionality.
-  @param sizes Array of integers specifying an n-dimensional array shape.
-  @param type Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel
-  matrices, or CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to
-  CV_CN_MAX channels) matrices.
-  @param data Pointer to the user data. Matrix constructors that take data and
-  step parameters do not allocate matrix data. Instead, they just initialize the
-  matrix header that points to the specified data, which means that no data is
-  copied. This operation is very efficient and can be used to process external
-  data using OpenCV functions. The external data is not automatically
-  deallocated, so you should take care of it.
-  @param steps Array of ndims-1 steps in case of a multi-dimensional array (the
-  last step is always set to the element size). If not specified, the matrix is
-  assumed to be continuous.
-  */
-  Mat(int ndims, const int *sizes, int type, void *data,
-      const size_t *steps = 0);
-
-  /** @overload
-  @param sizes Array of integers specifying an n-dimensional array shape.
-  @param type Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel
-  matrices, or CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to
-  CV_CN_MAX channels) matrices.
-  @param data Pointer to the user data. Matrix constructors that take data and
-  step parameters do not allocate matrix data. Instead, they just initialize the
-  matrix header that points to the specified data, which means that no data is
-  copied. This operation is very efficient and can be used to process external
-  data using OpenCV functions. The external data is not automatically
-  deallocated, so you should take care of it.
-  @param steps Array of ndims-1 steps in case of a multi-dimensional array (the
-  last step is always set to the element size). If not specified, the matrix is
-  assumed to be continuous.
-  */
-  Mat(const std::vector<int> &sizes, int type, void *data,
-      const size_t *steps = 0);
-
-  /** @overload
-  @param m Array that (as a whole or partly) is assigned to the constructed
-  matrix. No data is copied by these constructors. Instead, the header pointing
-  to m data or its sub-array is constructed and associated with it. The
-  reference counter, if any, is incremented. So, when you modify the matrix
-  formed using such a constructor, you also modify the corresponding elements of
-  m . If you want to have an independent copy of the sub-array, use Mat::clone()
-  .
-  @param rowRange Range of the m rows to take. As usual, the range start is
-  inclusive and the range end is exclusive. Use Range::all() to take all the
-  rows.
-  @param colRange Range of the m columns to take. Use Range::all() to take all
-  the columns.
-  */
-  Mat(const Mat &m, const Range &rowRange,
-      const Range &colRange = Range::all());
-
-  /** @overload
-  @param m Array that (as a whole or partly) is assigned to the constructed
-  matrix. No data is copied by these constructors. Instead, the header pointing
-  to m data or its sub-array is constructed and associated with it. The
-  reference counter, if any, is incremented. So, when you modify the matrix
-  formed using such a constructor, you also modify the corresponding elements of
-  m . If you want to have an independent copy of the sub-array, use Mat::clone()
-  .
-  @param roi Region of interest.
-  */
-  Mat(const Mat &m, const Rect &roi);
-
-  /** @overload
-  @param m Array that (as a whole or partly) is assigned to the constructed
-  matrix. No data is copied by these constructors. Instead, the header pointing
-  to m data or its sub-array is constructed and associated with it. The
-  reference counter, if any, is incremented. So, when you modify the matrix
-  formed using such a constructor, you also modify the corresponding elements of
-  m . If you want to have an independent copy of the sub-array, use Mat::clone()
-  .
-  @param ranges Array of selected ranges of m along each dimensionality.
-  */
-  Mat(const Mat &m, const Range *ranges);
-
-  /** @overload
-  @param m Array that (as a whole or partly) is assigned to the constructed
-  matrix. No data is copied by these constructors. Instead, the header pointing
-  to m data or its sub-array is constructed and associated with it. The
-  reference counter, if any, is incremented. So, when you modify the matrix
-  formed using such a constructor, you also modify the corresponding elements of
-  m . If you want to have an independent copy of the sub-array, use Mat::clone()
-  .
-  @param ranges Array of selected ranges of m along each dimensionality.
-  */
-  Mat(const Mat &m, const std::vector<Range> &ranges);
-
-  /** @overload
-  @param vec STL vector whose elements form the matrix. The matrix has a single
-  column and the number of rows equal to the number of vector elements. Type of
-  the matrix matches the type of vector elements. The constructor can handle
-  arbitrary types, for which there is a properly declared DataType . This means
-  that the vector elements must be primitive numbers or uni-type numerical
-  tuples of numbers. Mixed-type structures are not supported. The corresponding
-  constructor is explicit. Since STL vectors are not automatically converted to
-  Mat instances, you should write Mat(vec) explicitly. Unless you copy the data
-  into the matrix ( copyData=true ), no new elements will be added to the vector
-  because it can potentially yield vector data reallocation, and, thus, the
-  matrix data pointer will be invalid.
-  @param copyData Flag to specify whether the underlying data of the STL vector
-  should be copied to (true) or shared with (false) the newly constructed
-  matrix. When the data is copied, the allocated buffer is managed using Mat
-  reference counting mechanism. While the data is shared, the reference counter
-  is NULL, and you should not deallocate the data until the matrix is
-  destructed.
-  */
-  template <typename _Tp>
-  explicit Mat(const std::vector<_Tp> &vec, bool copyData = false);
-
-  /** @overload
-   */
-  template <typename _Tp, typename = typename std::enable_if<
-                              std::is_arithmetic<_Tp>::value>::type>
-  explicit Mat(const std::initializer_list<_Tp> list);
-
-  /** @overload
-   */
-  template <typename _Tp>
-  explicit Mat(const std::initializer_list<int> sizes,
-               const std::initializer_list<_Tp> list);
-
-  /** @overload
-   */
-  template <typename _Tp, size_t _Nm>
-  explicit Mat(const std::array<_Tp, _Nm> &arr, bool copyData = false);
-
-  /** @overload
-   */
-  template <typename _Tp, int n>
-  explicit Mat(const Vec<_Tp, n> &vec, bool copyData = true);
-
-  /** @overload
-   */
-  template <typename _Tp, int m, int n>
-  explicit Mat(const Matx<_Tp, m, n> &mtx, bool copyData = true);
-
-  /** @overload
-   */
-  template <typename _Tp>
-  explicit Mat(const Point_<_Tp> &pt, bool copyData = true);
-
-  /** @overload
-   */
-  template <typename _Tp>
-  explicit Mat(const Point3_<_Tp> &pt, bool copyData = true);
-
-  /** @overload
-   */
-  template <typename _Tp>
-  explicit Mat(const MatCommaInitializer_<_Tp> &commaInitializer);
-
-  //! destructor - calls release()
-  ~Mat();
-
-  /** @brief assignment operators
-
-  These are available assignment operators. Since they all are very different,
-  make sure to read the operator parameters description.
-  @param m Assigned, right-hand-side matrix. Matrix assignment is an O(1)
-  operation. This means that no data is copied but the data is shared and the
-  reference counter, if any, is incremented. Before assigning new data, the old
-  data is de-referenced via Mat::release .
-   */
-  Mat &operator=(const Mat &m);
-
-  /** @overload
-  @param expr Assigned matrix expression object. As opposite to the first form
-  of the assignment operation, the second form can reuse already allocated
-  matrix if it has the right size and type to fit the matrix expression result.
-  It is automatically handled by the real function that the matrix expressions
-  is expanded to. For example, C=A+B is expanded to add(A, B, C), and add takes
-  care of automatic C reallocation.
-  */
-  Mat &operator=(const MatExpr &expr);
-
-  /** @brief Creates a matrix header for the specified matrix row.
-
-  The method makes a new header for the specified matrix row and returns it.
-  This is an O(1) operation, regardless of the matrix size. The underlying data
-  of the new matrix is shared with the original matrix. Here is the example of
-  one of the classical basic matrix processing operations, axpy, used by LU and
-  many other algorithms:
-  @code
-      inline void matrix_axpy(Mat& A, int i, int j, double alpha)
-      {
-          A.row(i) += A.row(j)*alpha;
-      }
-  @endcode
-  @note In the current implementation, the following code does not work as
-  expected:
-  @code
-      Mat A;
-      ...
-      A.row(i) = A.row(j); // will not work
-  @endcode
-  This happens because A.row(i) forms a temporary header that is further
-  assigned to another header. Remember that each of these operations is O(1),
-  that is, no data is copied. Thus, the above assignment is not true if you may
-  have expected the j-th row to be copied to the i-th row. To achieve that, you
-  should either turn this simple assignment into an expression or use the
-  Mat::copyTo method:
-  @code
-      Mat A;
-      ...
-      // works, but looks a bit obscure.
-      A.row(i) = A.row(j) + 0;
-      // this is a bit longer, but the recommended method.
-      A.row(j).copyTo(A.row(i));
-  @endcode
-  @param y A 0-based row index.
-   */
-  Mat row(int y) const;
-
-  /** @brief Creates a matrix header for the specified matrix column.
-
-  The method makes a new header for the specified matrix column and returns it.
-  This is an O(1) operation, regardless of the matrix size. The underlying data
-  of the new matrix is shared with the original matrix. See also the Mat::row
-  description.
-  @param x A 0-based column index.
-   */
-  Mat col(int x) const;
-
-  /** @brief Creates a matrix header for the specified row span.
-
-  The method makes a new header for the specified row span of the matrix.
-  Similarly to Mat::row and Mat::col , this is an O(1) operation.
-  @param startrow An inclusive 0-based start index of the row span.
-  @param endrow An exclusive 0-based ending index of the row span.
-   */
-  Mat rowRange(int startrow, int endrow) const;
-
-  /** @overload
-  @param r Range structure containing both the start and the end indices.
-  */
-  Mat rowRange(const Range &r) const;
-
-  /** @brief Creates a matrix header for the specified column span.
-
-  The method makes a new header for the specified column span of the matrix.
-  Similarly to Mat::row and Mat::col , this is an O(1) operation.
-  @param startcol An inclusive 0-based start index of the column span.
-  @param endcol An exclusive 0-based ending index of the column span.
-   */
-  Mat colRange(int startcol, int endcol) const;
-
-  /** @overload
-  @param r Range structure containing both the start and the end indices.
-  */
-  Mat colRange(const Range &r) const;
-
-  /** @brief Extracts a diagonal from a matrix
-
-  The method makes a new header for the specified matrix diagonal. The new
-  matrix is represented as a single-column matrix. Similarly to Mat::row and
-  Mat::col, this is an O(1) operation.
-  @param d index of the diagonal, with the following values:
-  - `d=0` is the main diagonal.
-  - `d<0` is a diagonal from the lower half. For example, d=-1 means the
-  diagonal is set immediately below the main one.
-  - `d>0` is a diagonal from the upper half. For example, d=1 means the diagonal
-  is set immediately above the main one. For example:
-  @code
-      Mat m = (Mat_<int>(3,3) <<
-                  1,2,3,
-                  4,5,6,
-                  7,8,9);
-      Mat d0 = m.diag(0);
-      Mat d1 = m.diag(1);
-      Mat d_1 = m.diag(-1);
-  @endcode
-  The resulting matrices are
-  @code
-   d0 =
-     [1;
-      5;
-      9]
-   d1 =
-     [2;
-      6]
-   d_1 =
-     [4;
-      8]
-  @endcode
-   */
-  Mat diag(int d = 0) const;
-
-  /** @brief creates a diagonal matrix
-
-  The method creates a square diagonal matrix from specified main diagonal.
-  @param d One-dimensional matrix that represents the main diagonal.
-   */
-  CV_NODISCARD_STD static Mat diag(const Mat &d);
-
-  /** @brief Creates a full copy of the array and the underlying data.
-
-  The method creates a full copy of the array. The original step[] is not taken
-  into account. So, the array copy is a continuous array occupying
-  total()*elemSize() bytes.
-   */
-  CV_NODISCARD_STD Mat clone() const;
-
-  /** @brief Copies the matrix to another one.
-
-  The method copies the matrix data to another matrix. Before copying the data,
-  the method invokes :
-  @code
-      m.create(this->size(), this->type());
-  @endcode
-  so that the destination matrix is reallocated if needed. While m.copyTo(m);
-  works flawlessly, the function does not handle the case of a partial overlap
-  between the source and the destination matrices.
-
-  When the operation mask is specified, if the Mat::create call shown above
-  reallocates the matrix, the newly allocated matrix is initialized with all
-  zeros before copying the data.
-  @param m Destination matrix. If it does not have a proper size or type before
-  the operation, it is reallocated.
-   */
-  void copyTo(OutputArray m) const;
-
-  /** @overload
-  @param m Destination matrix. If it does not have a proper size or type before
-  the operation, it is reallocated.
-  @param mask Operation mask of the same size as \*this. Its non-zero elements
-  indicate which matrix elements need to be copied. The mask has to be of type
-  CV_8U and can have 1 or multiple channels.
-  */
-  void copyTo(OutputArray m, InputArray mask) const;
-
-  /** @brief Converts an array to another data type with optional scaling.
-
-  The method converts source pixel values to the target data type.
-  saturate_cast\<\> is applied at the end to avoid possible overflows:
-
-  \f[m(x,y) = saturate \_ cast<rType>( \alpha (*this)(x,y) +  \beta )\f]
-  @param m output matrix; if it does not have a proper size or type before the
-  operation, it is reallocated.
-  @param rtype desired output matrix type or, rather, the depth since the number
-  of channels are the same as the input has; if rtype is negative, the output
-  matrix will have the same type as the input.
-  @param alpha optional scale factor.
-  @param beta optional delta added to the scaled values.
-   */
-  void convertTo(OutputArray m, int rtype, double alpha = 1,
-                 double beta = 0) const;
-
-  /** @brief Provides a functional form of convertTo.
-
-  This is an internally used method called by the @ref MatrixExpressions engine.
-  @param m Destination array.
-  @param type Desired destination array depth (or -1 if it should be the same as
-  the source type).
-   */
-  void assignTo(Mat &m, int type = -1) const;
-
-  /** @brief Sets all or some of the array elements to the specified value.
-  @param s Assigned scalar converted to the actual array type.
-  */
-  Mat &operator=(const Scalar &s);
-
-  /** @brief Sets all or some of the array elements to the specified value.
-
-  This is an advanced variant of the Mat::operator=(const Scalar& s) operator.
-  @param value Assigned scalar converted to the actual array type.
-  @param mask Operation mask of the same size as \*this. Its non-zero elements
-  indicate which matrix elements need to be copied. The mask has to be of type
-  CV_8U and can have 1 or multiple channels
-   */
-  Mat &setTo(InputArray value, InputArray mask = noArray());
-
-  /** @brief Changes the shape and/or the number of channels of a 2D matrix
-  without copying the data.
-
-  The method makes a new matrix header for \*this elements. The new matrix may
-  have a different size and/or different number of channels. Any combination is
-  possible if:
-  -   No extra elements are included into the new matrix and no elements are
-  excluded. Consequently, the product rows\*cols\*channels() must stay the same
-  after the transformation.
-  -   No data is copied. That is, this is an O(1) operation. Consequently, if
-  you change the number of rows, or the operation changes the indices of
-  elements row in some other way, the matrix must be continuous. See
-  Mat::isContinuous .
-
-  For example, if there is a set of 3D points stored as an STL vector, and you
-  want to represent the points as a 3xN matrix, do the following:
-  @code
-      std::vector<Point3f> vec;
-      ...
-      Mat pointMat = Mat(vec). // convert vector to Mat, O(1) operation
-                        reshape(1). // make Nx3 1-channel matrix out of Nx1
-  3-channel.
-                                    // Also, an O(1) operation
-                           t(); // finally, transpose the Nx3 matrix.
-                                // This involves copying all the elements
-  @endcode
-  3-channel 2x2 matrix reshaped to 1-channel 4x3 matrix, each column has values
-  from one of original channels:
-  @code
-  Mat m(Size(2, 2), CV_8UC3, Scalar(1, 2, 3));
-  vector<int> new_shape {4, 3};
-  m = m.reshape(1, new_shape);
-  @endcode
-  or:
-  @code
-  Mat m(Size(2, 2), CV_8UC3, Scalar(1, 2, 3));
-  const int new_shape[] = {4, 3};
-  m = m.reshape(1, 2, new_shape);
-  @endcode
-  @param cn New number of channels. If the parameter is 0, the number of
-  channels remains the same.
-  @param rows New number of rows. If the parameter is 0, the number of rows
-  remains the same.
-   */
-  Mat reshape(int cn, int rows = 0) const;
-
-  /** @overload
-   * @param cn New number of channels. If the parameter is 0, the number of
-   * channels remains the same.
-   * @param newndims New number of dimentions.
-   * @param newsz Array with new matrix size by all dimentions. If some sizes
-   * are zero, the original sizes in those dimensions are presumed.
-   */
-  Mat reshape(int cn, int newndims, const int *newsz) const;
-
-  /** @overload
-   * @param cn New number of channels. If the parameter is 0, the number of
-   * channels remains the same.
-   * @param newshape Vector with new matrix size by all dimentions. If some
-   * sizes are zero, the original sizes in those dimensions are presumed.
-   */
-  Mat reshape(int cn, const std::vector<int> &newshape) const;
-
-  /** @brief Transposes a matrix.
-
-  The method performs matrix transposition by means of matrix expressions. It
-  does not perform the actual transposition but returns a temporary matrix
-  transposition object that can be further used as a part of more complex matrix
-  expressions or can be assigned to a matrix:
-  @code
-      Mat A1 = A + Mat::eye(A.size(), A.type())*lambda;
-      Mat C = A1.t()*A1; // compute (A + lambda*I)^t * (A + lamda*I)
-  @endcode
-   */
-  MatExpr t() const;
-
-  /** @brief Inverses a matrix.
-
-  The method performs a matrix inversion by means of matrix expressions. This
-  means that a temporary matrix inversion object is returned by the method and
-  can be used further as a part of more complex matrix expressions or can be
-  assigned to a matrix.
-  @param method Matrix inversion method. One of cv::DecompTypes
-   */
-  MatExpr inv(int method = DECOMP_LU) const;
-
-  /** @brief Performs an element-wise multiplication or division of the two
-  matrices.
-
-  The method returns a temporary object encoding per-element array
-  multiplication, with optional scale. Note that this is not a matrix
-  multiplication that corresponds to a simpler "\*" operator.
-
-  Example:
-  @code
-      Mat C = A.mul(5/B); // equivalent to divide(A, B, C, 5)
-  @endcode
-  @param m Another array of the same type and the same size as \*this, or a
-  matrix expression.
-  @param scale Optional scale factor.
-   */
-  MatExpr mul(InputArray m, double scale = 1) const;
-
-  /** @brief Computes a cross-product of two 3-element vectors.
-
-  The method computes a cross-product of two 3-element vectors. The vectors must
-  be 3-element floating-point vectors of the same shape and size. The result is
-  another 3-element vector of the same shape and type as operands.
-  @param m Another cross-product operand.
-   */
-  Mat cross(InputArray m) const;
-
-  /** @brief Computes a dot-product of two vectors.
-
-  The method computes a dot-product of two matrices. If the matrices are not
-  single-column or single-row vectors, the top-to-bottom left-to-right scan
-  ordering is used to treat them as 1D vectors. The vectors must have the same
-  size and type. If the matrices have more than one channel, the dot products
-  from all the channels are summed together.
-  @param m another dot-product operand.
-   */
-  double dot(InputArray m) const;
-
-  /** @brief Returns a zero array of the specified size and type.
-
-  The method returns a Matlab-style zero array initializer. It can be used to
-  quickly form a constant array as a function parameter, part of a matrix
-  expression, or as a matrix initializer:
-  @code
-      Mat A;
-      A = Mat::zeros(3, 3, CV_32F);
-  @endcode
-  In the example above, a new matrix is allocated only if A is not a 3x3
-  floating-point matrix. Otherwise, the existing matrix A is filled with zeros.
-  @param rows Number of rows.
-  @param cols Number of columns.
-  @param type Created matrix type.
-   */
-  CV_NODISCARD_STD static MatExpr zeros(int rows, int cols, int type);
-
-  /** @overload
-  @param size Alternative to the matrix size specification Size(cols, rows) .
-  @param type Created matrix type.
-  */
-  CV_NODISCARD_STD static MatExpr zeros(Size size, int type);
-
-  /** @overload
-  @param ndims Array dimensionality.
-  @param sz Array of integers specifying the array shape.
-  @param type Created matrix type.
-  */
-  CV_NODISCARD_STD static MatExpr zeros(int ndims, const int *sz, int type);
-
-  /** @brief Returns an array of all 1's of the specified size and type.
-
-  The method returns a Matlab-style 1's array initializer, similarly to
-  Mat::zeros. Note that using this method you can initialize an array with an
-  arbitrary value, using the following Matlab idiom:
-  @code
-      Mat A = Mat::ones(100, 100, CV_8U)*3; // make 100x100 matrix filled
-  with 3.
-  @endcode
-  The above operation does not form a 100x100 matrix of 1's and then multiply it
-  by 3. Instead, it just remembers the scale factor (3 in this case) and use it
-  when actually invoking the matrix initializer.
-  @note In case of multi-channels type, only the first channel will be
-  initialized with 1's, the others will be set to 0's.
-  @param rows Number of rows.
-  @param cols Number of columns.
-  @param type Created matrix type.
-   */
-  CV_NODISCARD_STD static MatExpr ones(int rows, int cols, int type);
-
-  /** @overload
-  @param size Alternative to the matrix size specification Size(cols, rows) .
-  @param type Created matrix type.
-  */
-  CV_NODISCARD_STD static MatExpr ones(Size size, int type);
-
-  /** @overload
-  @param ndims Array dimensionality.
-  @param sz Array of integers specifying the array shape.
-  @param type Created matrix type.
-  */
-  CV_NODISCARD_STD static MatExpr ones(int ndims, const int *sz, int type);
-
-  /** @brief Returns an identity matrix of the specified size and type.
-
-  The method returns a Matlab-style identity matrix initializer, similarly to
-  Mat::zeros. Similarly to Mat::ones, you can use a scale operation to create a
-  scaled identity matrix efficiently:
-  @code
-      // make a 4x4 diagonal matrix with 0.1's on the diagonal.
-      Mat A = Mat::eye(4, 4, CV_32F)*0.1;
-  @endcode
-  @note In case of multi-channels type, identity matrix will be initialized only
-  for the first channel, the others will be set to 0's
-  @param rows Number of rows.
-  @param cols Number of columns.
-  @param type Created matrix type.
-   */
-  CV_NODISCARD_STD static MatExpr eye(int rows, int cols, int type);
-
-  /** @overload
-  @param size Alternative matrix size specification as Size(cols, rows) .
-  @param type Created matrix type.
-  */
-  CV_NODISCARD_STD static MatExpr eye(Size size, int type);
-
-  /** @brief Allocates new array data if needed.
-
-  This is one of the key Mat methods. Most new-style OpenCV functions and
-  methods that produce arrays call this method for each output array. The method
-  uses the following algorithm:
-
-  -# If the current array shape and the type match the new ones, return
-  immediately. Otherwise, de-reference the previous data by calling
-  Mat::release.
-  -# Initialize the new header.
-  -# Allocate the new data of total()\*elemSize() bytes.
-  -# Allocate the new, associated with the data, reference counter and set it
-  to 1.
-
-  Such a scheme makes the memory management robust and efficient at the same
-  time and helps avoid extra typing for you. This means that usually there is no
-  need to explicitly allocate output arrays. That is, instead of writing:
-  @code
-      Mat color;
-      ...
-      Mat gray(color.rows, color.cols, color.depth());
-      cvtColor(color, gray, COLOR_BGR2GRAY);
-  @endcode
-  you can simply write:
-  @code
-      Mat color;
-      ...
-      Mat gray;
-      cvtColor(color, gray, COLOR_BGR2GRAY);
-  @endcode
-  because cvtColor, as well as the most of OpenCV functions, calls Mat::create()
-  for the output array internally.
-  @param rows New number of rows.
-  @param cols New number of columns.
-  @param type New matrix type.
-   */
-  void create(int rows, int cols, int type);
-
-  /** @overload
-  @param size Alternative new matrix size specification: Size(cols, rows)
-  @param type New matrix type.
-  */
-  void create(Size size, int type);
-
-  /** @overload
-  @param ndims New array dimensionality.
-  @param sizes Array of integers specifying a new array shape.
-  @param type New matrix type.
-  */
-  void create(int ndims, const int *sizes, int type);
-
-  /** @overload
-  @param sizes Array of integers specifying a new array shape.
-  @param type New matrix type.
-  */
-  void create(const std::vector<int> &sizes, int type);
-
-  /** @brief Increments the reference counter.
-
-  The method increments the reference counter associated with the matrix data.
-  If the matrix header points to an external data set (see Mat::Mat ), the
-  reference counter is NULL, and the method has no effect in this case.
-  Normally, to avoid memory leaks, the method should not be called explicitly.
-  It is called implicitly by the matrix assignment operator. The reference
-  counter increment is an atomic operation on the platforms that support it.
-  Thus, it is safe to operate on the same matrices asynchronously in different
-  threads.
-   */
-  void addref();
-
-  /** @brief Decrements the reference counter and deallocates the matrix if
-  needed.
-
-  The method decrements the reference counter associated with the matrix data.
-  When the reference counter reaches 0, the matrix data is deallocated and the
-  data and the reference counter pointers are set to NULL's. If the matrix
-  header points to an external data set (see Mat::Mat ), the reference counter
-  is NULL, and the method has no effect in this case.
-
-  This method can be called manually to force the matrix data deallocation. But
-  since this method is automatically called in the destructor, or by any other
-  method that changes the data pointer, it is usually not needed. The reference
-  counter decrement and check for 0 is an atomic operation on the platforms that
-  support it. Thus, it is safe to operate on the same matrices asynchronously in
-  different threads.
-   */
-  void release();
-
-  //! internal use function, consider to use 'release' method instead;
-  //! deallocates the matrix data
-  void deallocate();
-  //! internal use function; properly re-allocates _size, _step arrays
-  void copySize(const Mat &m);
-
-  /** @brief Reserves space for the certain number of rows.
-
-  The method reserves space for sz rows. If the matrix already has enough space
-  to store sz rows, nothing happens. If the matrix is reallocated, the first
-  Mat::rows rows are preserved. The method emulates the corresponding method of
-  the STL vector class.
-  @param sz Number of rows.
-   */
-  void reserve(size_t sz);
-
-  /** @brief Reserves space for the certain number of bytes.
-
-  The method reserves space for sz bytes. If the matrix already has enough space
-  to store sz bytes, nothing happens. If matrix has to be reallocated its
-  previous content could be lost.
-  @param sz Number of bytes.
-  */
-  void reserveBuffer(size_t sz);
-
-  /** @brief Changes the number of matrix rows.
-
-  The methods change the number of matrix rows. If the matrix is reallocated,
-  the first min(Mat::rows, sz) rows are preserved. The methods emulate the
-  corresponding methods of the STL vector class.
-  @param sz New number of rows.
-   */
-  void resize(size_t sz);
-
-  /** @overload
-  @param sz New number of rows.
-  @param s Value assigned to the newly added elements.
-   */
-  void resize(size_t sz, const Scalar &s);
-
-  //! internal function
-  void push_back_(const void *elem);
-
-  /** @brief Adds elements to the bottom of the matrix.
-
-  The methods add one or more elements to the bottom of the matrix. They emulate
-  the corresponding method of the STL vector class. When elem is Mat , its type
-  and the number of columns must be the same as in the container matrix.
-  @param elem Added element(s).
-   */
-  template <typename _Tp> void push_back(const _Tp &elem);
-
-  /** @overload
-  @param elem Added element(s).
-  */
-  template <typename _Tp> void push_back(const Mat_<_Tp> &elem);
-
-  /** @overload
-  @param elem Added element(s).
-  */
-  template <typename _Tp> void push_back(const std::vector<_Tp> &elem);
-
-  /** @overload
-  @param m Added line(s).
-  */
-  void push_back(const Mat &m);
-
-  /** @brief Removes elements from the bottom of the matrix.
-
-  The method removes one or more rows from the bottom of the matrix.
-  @param nelems Number of removed rows. If it is greater than the total number
-  of rows, an exception is thrown.
-   */
-  void pop_back(size_t nelems = 1);
-
-  /** @brief Locates the matrix header within a parent matrix.
-
-  After you extracted a submatrix from a matrix using Mat::row, Mat::col,
-  Mat::rowRange, Mat::colRange, and others, the resultant submatrix points just
-  to the part of the original big matrix. However, each submatrix contains
-  information (represented by datastart and dataend fields) that helps
-  reconstruct the original matrix size and the position of the extracted
-  submatrix within the original matrix. The method locateROI does exactly that.
-  @param wholeSize Output parameter that contains the size of the whole matrix
-  containing *this* as a part.
-  @param ofs Output parameter that contains an offset of *this* inside the whole
-  matrix.
-   */
-  void locateROI(Size &wholeSize, Point &ofs) const;
-
-  /** @brief Adjusts a submatrix size and position within the parent matrix.
-
-  The method is complimentary to Mat::locateROI . The typical use of these
-  functions is to determine the submatrix position within the parent matrix and
-  then shift the position somehow. Typically, it can be required for filtering
-  operations when pixels outside of the ROI should be taken into account. When
-  all the method parameters are positive, the ROI needs to grow in all
-  directions by the specified amount, for example:
-  @code
-      A.adjustROI(2, 2, 2, 2);
-  @endcode
-  In this example, the matrix size is increased by 4 elements in each direction.
-  The matrix is shifted by 2 elements to the left and 2 elements up, which
-  brings in all the necessary pixels for the filtering with the 5x5 kernel.
-
-  adjustROI forces the adjusted ROI to be inside of the parent matrix that is
-  boundaries of the adjusted ROI are constrained by boundaries of the parent
-  matrix. For example, if the submatrix A is located in the first row of a
-  parent matrix and you called A.adjustROI(2, 2, 2, 2) then A will not be
-  increased in the upward direction.
-
-  The function is used internally by the OpenCV filtering functions, like
-  filter2D , morphological operations, and so on.
-  @param dtop Shift of the top submatrix boundary upwards.
-  @param dbottom Shift of the bottom submatrix boundary downwards.
-  @param dleft Shift of the left submatrix boundary to the left.
-  @param dright Shift of the right submatrix boundary to the right.
-  @sa copyMakeBorder
-   */
-  Mat &adjustROI(int dtop, int dbottom, int dleft, int dright);
-
-  /** @brief Extracts a rectangular submatrix.
-
-  The operators make a new header for the specified sub-array of \*this . They
-  are the most generalized forms of Mat::row, Mat::col, Mat::rowRange, and
-  Mat::colRange . For example, `A(Range(0, 10), Range::all())` is equivalent to
-  `A.rowRange(0, 10)`. Similarly to all of the above, the operators are O(1)
-  operations, that is, no matrix data is copied.
-  @param rowRange Start and end row of the extracted submatrix. The upper
-  boundary is not included. To select all the rows, use Range::all().
-  @param colRange Start and end column of the extracted submatrix. The upper
-  boundary is not included. To select all the columns, use Range::all().
-   */
-  Mat operator()(Range rowRange, Range colRange) const;
-
-  /** @overload
-  @param roi Extracted submatrix specified as a rectangle.
-  */
-  Mat operator()(const Rect &roi) const;
-
-  /** @overload
-  @param ranges Array of selected ranges along each array dimension.
-  */
-  Mat operator()(const Range *ranges) const;
-
-  /** @overload
-  @param ranges Array of selected ranges along each array dimension.
-  */
-  Mat operator()(const std::vector<Range> &ranges) const;
-
-  template <typename _Tp> operator std::vector<_Tp>() const;
-  template <typename _Tp, int n> operator Vec<_Tp, n>() const;
-  template <typename _Tp, int m, int n> operator Matx<_Tp, m, n>() const;
-
-  template <typename _Tp, std::size_t _Nm>
-  operator std::array<_Tp, _Nm>() const;
-
-  /** @brief Reports whether the matrix is continuous or not.
-
-  The method returns true if the matrix elements are stored continuously without
-  gaps at the end of each row. Otherwise, it returns false. Obviously, 1x1 or
-  1xN matrices are always continuous. Matrices created with Mat::create are
-  always continuous. But if you extract a part of the matrix using Mat::col,
-  Mat::diag, and so on, or constructed a matrix header for externally allocated
-  data, such matrices may no longer have this property.
-
-  The continuity flag is stored as a bit in the Mat::flags field and is computed
-  automatically when you construct a matrix header. Thus, the continuity check
-  is a very fast operation, though theoretically it could be done as follows:
-  @code
-      // alternative implementation of Mat::isContinuous()
-      bool myCheckMatContinuity(const Mat& m)
-      {
-          //return (m.flags & Mat::CONTINUOUS_FLAG) != 0;
-          return m.rows == 1 || m.step == m.cols*m.elemSize();
-      }
-  @endcode
-  The method is used in quite a few of OpenCV functions. The point is that
-  element-wise operations (such as arithmetic and logical operations, math
-  functions, alpha blending, color space transformations, and others) do not
-  depend on the image geometry. Thus, if all the input and output arrays are
-  continuous, the functions can process them as very long single-row vectors.
-  The example below illustrates how an alpha-blending function can be
-  implemented:
-  @code
-      template<typename T>
-      void alphaBlendRGBA(const Mat& src1, const Mat& src2, Mat& dst)
-      {
-          const float alpha_scale = (float)std::numeric_limits<T>::max(),
-                      inv_scale = 1.f/alpha_scale;
-
-          CV_Assert( src1.type() == src2.type() &&
-                     src1.type() == CV_MAKETYPE(traits::Depth<T>::value, 4) &&
-                     src1.size() == src2.size());
-          Size size = src1.size();
-          dst.create(size, src1.type());
-
-          // here is the idiom: check the arrays for continuity and,
-          // if this is the case,
-          // treat the arrays as 1D vectors
-          if( src1.isContinuous() && src2.isContinuous() && dst.isContinuous() )
-          {
-              size.width *= size.height;
-              size.height = 1;
-          }
-          size.width *= 4;
-
-          for( int i = 0; i < size.height; i++ )
-          {
-              // when the arrays are continuous,
-              // the outer loop is executed only once
-              const T* ptr1 = src1.ptr<T>(i);
-              const T* ptr2 = src2.ptr<T>(i);
-              T* dptr = dst.ptr<T>(i);
-
-              for( int j = 0; j < size.width; j += 4 )
-              {
-                  float alpha = ptr1[j+3]*inv_scale, beta = ptr2[j+3]*inv_scale;
-                  dptr[j] = saturate_cast<T>(ptr1[j]*alpha + ptr2[j]*beta);
-                  dptr[j+1] = saturate_cast<T>(ptr1[j+1]*alpha +
-  ptr2[j+1]*beta); dptr[j+2] = saturate_cast<T>(ptr1[j+2]*alpha +
-  ptr2[j+2]*beta); dptr[j+3] = saturate_cast<T>((1 -
-  (1-alpha)*(1-beta))*alpha_scale);
-              }
-          }
-      }
-  @endcode
-  This approach, while being very simple, can boost the performance of a simple
-  element-operation by 10-20 percents, especially if the image is rather small
-  and the operation is quite simple.
-
-  Another OpenCV idiom in this function, a call of Mat::create for the
-  destination array, that allocates the destination array unless it already has
-  the proper size and type. And while the newly allocated arrays are always
-  continuous, you still need to check the destination array because Mat::create
-  does not always allocate a new matrix.
-   */
-  bool isContinuous() const;
-
-  //! returns true if the matrix is a submatrix of another matrix
-  bool isSubmatrix() const;
-
-  /** @brief Returns the matrix element size in bytes.
-
-  The method returns the matrix element size in bytes. For example, if the
-  matrix type is CV_16SC3 , the method returns 3\*sizeof(short) or 6.
-   */
-  size_t elemSize() const;
-
-  /** @brief Returns the size of each matrix element channel in bytes.
-
-  The method returns the matrix element channel size in bytes, that is, it
-  ignores the number of channels. For example, if the matrix type is CV_16SC3 ,
-  the method returns sizeof(short) or 2.
-   */
-  size_t elemSize1() const;
-
-  /** @brief Returns the type of a matrix element.
-
-  The method returns a matrix element type. This is an identifier compatible
-  with the CvMat type system, like CV_16SC3 or 16-bit signed 3-channel array,
-  and so on.
-   */
-  int type() const;
-
-  /** @brief Returns the depth of a matrix element.
-
-  The method returns the identifier of the matrix element depth (the type of
-  each individual channel). For example, for a 16-bit signed element array, the
-  method returns CV_16S . A complete list of matrix types contains the following
-  values:
-  -   CV_8U - 8-bit unsigned integers ( 0..255 )
-  -   CV_8S - 8-bit signed integers ( -128..127 )
-  -   CV_16U - 16-bit unsigned integers ( 0..65535 )
-  -   CV_16S - 16-bit signed integers ( -32768..32767 )
-  -   CV_32S - 32-bit signed integers ( -2147483648..2147483647 )
-  -   CV_32F - 32-bit floating-point numbers ( -FLT_MAX..FLT_MAX, INF, NAN )
-  -   CV_64F - 64-bit floating-point numbers ( -DBL_MAX..DBL_MAX, INF, NAN )
-   */
-  int depth() const;
-
-  /** @brief Returns the number of matrix channels.
-
-  The method returns the number of matrix channels.
-   */
-  int channels() const;
-
-  /** @brief Returns a normalized step.
-
-  The method returns a matrix step divided by Mat::elemSize1() . It can be
-  useful to quickly access an arbitrary matrix element.
-   */
-  size_t step1(int i = 0) const;
-
-  /** @brief Returns true if the array has no elements.
-
-  The method returns true if Mat::total() is 0 or if Mat::data is NULL. Because
-  of pop_back() and resize() methods `M.total() == 0` does not imply that
-  `M.data == NULL`.
-   */
-  bool empty() const;
-
-  /** @brief Returns the total number of array elements.
-
-  The method returns the number of array elements (a number of pixels if the
-  array represents an image).
-   */
-  size_t total() const;
-
-  /** @brief Returns the total number of array elements.
-
-   The method returns the number of elements within a certain sub-array slice
-   with startDim <= dim < endDim
-   */
-  size_t total(int startDim, int endDim = INT_MAX) const;
-
-  /**
-   * @param elemChannels Number of channels or number of columns the matrix
-   * should have. For a 2-D matrix, when the matrix has only 1 column, then it
-   * should have elemChannels channels; When the matrix has only 1 channel, then
-   * it should have elemChannels columns. For a 3-D matrix, it should have only
-   * one channel. Furthermore, if the number of planes is not one, then the
-   * number of rows within every plane has to be 1; if the number of rows within
-   *                     every plane is not 1, then the number of planes has to
-   * be 1.
-   * @param depth The depth the matrix should have. Set it to -1 when any depth
-   * is fine.
-   * @param requireContinuous Set it to true to require the matrix to be
-   * continuous
-   * @return -1 if the requirement is not satisfied.
-   *         Otherwise, it returns the number of elements in the matrix. Note
-   *         that an element may have multiple channels.
-   *
-   * The following code demonstrates its usage for a 2-d matrix:
-   * @snippet snippets/core_mat_checkVector.cpp example-2d
-   *
-   * The following code demonstrates its usage for a 3-d matrix:
-   * @snippet snippets/core_mat_checkVector.cpp example-3d
-   */
-  int checkVector(int elemChannels, int depth = -1,
-                  bool requireContinuous = true) const;
-
-  /** @brief Returns a pointer to the specified matrix row.
-
-  The methods return `uchar*` or typed pointer to the specified matrix row. See
-  the sample in Mat::isContinuous to know how to use these methods.
-  @param i0 A 0-based row index.
-   */
-  uchar *ptr(int i0 = 0);
-  /** @overload */
-  const uchar *ptr(int i0 = 0) const;
-
-  /** @overload
-  @param row Index along the dimension 0
-  @param col Index along the dimension 1
-  */
-  uchar *ptr(int row, int col);
-  /** @overload
-  @param row Index along the dimension 0
-  @param col Index along the dimension 1
-  */
-  const uchar *ptr(int row, int col) const;
-
-  /** @overload */
-  uchar *ptr(int i0, int i1, int i2);
-  /** @overload */
-  const uchar *ptr(int i0, int i1, int i2) const;
-
-  /** @overload */
-  uchar *ptr(const int *idx);
-  /** @overload */
-  const uchar *ptr(const int *idx) const;
-  /** @overload */
-  template <int n> uchar *ptr(const Vec<int, n> &idx);
-  /** @overload */
-  template <int n> const uchar *ptr(const Vec<int, n> &idx) const;
-
-  /** @overload */
-  template <typename _Tp> _Tp *ptr(int i0 = 0);
-  /** @overload */
-  template <typename _Tp> const _Tp *ptr(int i0 = 0) const;
-  /** @overload
-  @param row Index along the dimension 0
-  @param col Index along the dimension 1
-  */
-  template <typename _Tp> _Tp *ptr(int row, int col);
-  /** @overload
-  @param row Index along the dimension 0
-  @param col Index along the dimension 1
-  */
-  template <typename _Tp> const _Tp *ptr(int row, int col) const;
-  /** @overload */
-  template <typename _Tp> _Tp *ptr(int i0, int i1, int i2);
-  /** @overload */
-  template <typename _Tp> const _Tp *ptr(int i0, int i1, int i2) const;
-  /** @overload */
-  template <typename _Tp> _Tp *ptr(const int *idx);
-  /** @overload */
-  template <typename _Tp> const _Tp *ptr(const int *idx) const;
-  /** @overload */
-  template <typename _Tp, int n> _Tp *ptr(const Vec<int, n> &idx);
-  /** @overload */
-  template <typename _Tp, int n> const _Tp *ptr(const Vec<int, n> &idx) const;
-
-  /** @brief Returns a reference to the specified array element.
-
-  The template methods return a reference to the specified array element. For
-  the sake of higher performance, the index range checks are only performed in
-  the Debug configuration.
-
-  Note that the variants with a single index (i) can be used to access elements
-  of single-row or single-column 2-dimensional arrays. That is, if, for example,
-  A is a 1 x N floating-point matrix and B is an M x 1 integer matrix, you can
-  simply write `A.at<float>(k+4)` and `B.at<int>(2*i+1)` instead of
-  `A.at<float>(0,k+4)` and `B.at<int>(2*i+1,0)`, respectively.
-
-  The example below initializes a Hilbert matrix:
-  @code
-      Mat H(100, 100, CV_64F);
-      for(int i = 0; i < H.rows; i++)
-          for(int j = 0; j < H.cols; j++)
-              H.at<double>(i,j)=1./(i+j+1);
-  @endcode
-
-  Keep in mind that the size identifier used in the at operator cannot be chosen
-  at random. It depends on the image from which you are trying to retrieve the
-  data. The table below gives a better insight in this:
-   - If matrix is of type `CV_8U` then use `Mat.at<uchar>(y,x)`.
-   - If matrix is of type `CV_8S` then use `Mat.at<schar>(y,x)`.
-   - If matrix is of type `CV_16U` then use `Mat.at<ushort>(y,x)`.
-   - If matrix is of type `CV_16S` then use `Mat.at<short>(y,x)`.
-   - If matrix is of type `CV_32S`  then use `Mat.at<int>(y,x)`.
-   - If matrix is of type `CV_32F`  then use `Mat.at<float>(y,x)`.
-   - If matrix is of type `CV_64F` then use `Mat.at<double>(y,x)`.
-
-  @param i0 Index along the dimension 0
-   */
-  template <typename _Tp> _Tp &at(int i0 = 0);
-  /** @overload
-  @param i0 Index along the dimension 0
-  */
-  template <typename _Tp> const _Tp &at(int i0 = 0) const;
-  /** @overload
-  @param row Index along the dimension 0
-  @param col Index along the dimension 1
-  */
-  template <typename _Tp> _Tp &at(int row, int col);
-  /** @overload
-  @param row Index along the dimension 0
-  @param col Index along the dimension 1
-  */
-  template <typename _Tp> const _Tp &at(int row, int col) const;
-
-  /** @overload
-  @param i0 Index along the dimension 0
-  @param i1 Index along the dimension 1
-  @param i2 Index along the dimension 2
-  */
-  template <typename _Tp> _Tp &at(int i0, int i1, int i2);
-  /** @overload
-  @param i0 Index along the dimension 0
-  @param i1 Index along the dimension 1
-  @param i2 Index along the dimension 2
-  */
-  template <typename _Tp> const _Tp &at(int i0, int i1, int i2) const;
-
-  /** @overload
-  @param idx Array of Mat::dims indices.
-  */
-  template <typename _Tp> _Tp &at(const int *idx);
-  /** @overload
-  @param idx Array of Mat::dims indices.
-  */
-  template <typename _Tp> const _Tp &at(const int *idx) const;
-
-  /** @overload */
-  template <typename _Tp, int n> _Tp &at(const Vec<int, n> &idx);
-  /** @overload */
-  template <typename _Tp, int n> const _Tp &at(const Vec<int, n> &idx) const;
-
-  /** @overload
-  special versions for 2D arrays (especially convenient for referencing image
-  pixels)
-  @param pt Element position specified as Point(j,i) .
-  */
-  template <typename _Tp> _Tp &at(Point pt);
-  /** @overload
-  special versions for 2D arrays (especially convenient for referencing image
-  pixels)
-  @param pt Element position specified as Point(j,i) .
-  */
-  template <typename _Tp> const _Tp &at(Point pt) const;
-
-  /** @brief Returns the matrix iterator and sets it to the first matrix
-  element.
-
-  The methods return the matrix read-only or read-write iterators. The use of
-  matrix iterators is very similar to the use of bi-directional STL iterators.
-  In the example below, the alpha blending function is rewritten using the
-  matrix iterators:
-  @code
-      template<typename T>
-      void alphaBlendRGBA(const Mat& src1, const Mat& src2, Mat& dst)
-      {
-          typedef Vec<T, 4> VT;
-
-          const float alpha_scale = (float)std::numeric_limits<T>::max(),
-                      inv_scale = 1.f/alpha_scale;
-
-          CV_Assert( src1.type() == src2.type() &&
-                     src1.type() == traits::Type<VT>::value &&
-                     src1.size() == src2.size());
-          Size size = src1.size();
-          dst.create(size, src1.type());
-
-          MatConstIterator_<VT> it1 = src1.begin<VT>(), it1_end =
-  src1.end<VT>(); MatConstIterator_<VT> it2 = src2.begin<VT>(); MatIterator_<VT>
-  dst_it = dst.begin<VT>();
-
-          for( ; it1 != it1_end; ++it1, ++it2, ++dst_it )
-          {
-              VT pix1 = *it1, pix2 = *it2;
-              float alpha = pix1[3]*inv_scale, beta = pix2[3]*inv_scale;
-              *dst_it = VT(saturate_cast<T>(pix1[0]*alpha + pix2[0]*beta),
-                           saturate_cast<T>(pix1[1]*alpha + pix2[1]*beta),
-                           saturate_cast<T>(pix1[2]*alpha + pix2[2]*beta),
-                           saturate_cast<T>((1 -
-  (1-alpha)*(1-beta))*alpha_scale));
-          }
-      }
-  @endcode
-   */
-  template <typename _Tp> MatIterator_<_Tp> begin();
-  template <typename _Tp> MatConstIterator_<_Tp> begin() const;
-
-  /** @brief Same as begin() but for inverse traversal
-   */
-  template <typename _Tp> std::reverse_iterator<MatIterator_<_Tp>> rbegin();
-  template <typename _Tp>
-  std::reverse_iterator<MatConstIterator_<_Tp>> rbegin() const;
-
-  /** @brief Returns the matrix iterator and sets it to the after-last matrix
-  element.
-
-  The methods return the matrix read-only or read-write iterators, set to the
-  point following the last matrix element.
-   */
-  template <typename _Tp> MatIterator_<_Tp> end();
-  template <typename _Tp> MatConstIterator_<_Tp> end() const;
-
-  /** @brief Same as end() but for inverse traversal
-   */
-  template <typename _Tp> std::reverse_iterator<MatIterator_<_Tp>> rend();
-  template <typename _Tp>
-  std::reverse_iterator<MatConstIterator_<_Tp>> rend() const;
-
-  /** @brief Runs the given functor over all matrix elements in parallel.
-
-  The operation passed as argument has to be a function pointer, a function
-  object or a lambda(C++11).
-
-  Example 1. All of the operations below put 0xFF the first channel of all
-  matrix elements:
-  @code
-      Mat image(1920, 1080, CV_8UC3);
-      typedef cv::Point3_<uint8_t> Pixel;
-
-      // first. raw pointer access.
-      for (int r = 0; r < image.rows; ++r) {
-          Pixel* ptr = image.ptr<Pixel>(r, 0);
-          const Pixel* ptr_end = ptr + image.cols;
-          for (; ptr != ptr_end; ++ptr) {
-              ptr->x = 255;
-          }
-      }
-
-      // Using MatIterator. (Simple but there are a Iterator's overhead)
-      for (Pixel &p : cv::Mat_<Pixel>(image)) {
-          p.x = 255;
-      }
-
-      // Parallel execution with function object.
-      struct Operator {
-          void operator ()(Pixel &pixel, const int * position) {
-              pixel.x = 255;
-          }
-      };
-      image.forEach<Pixel>(Operator());
-
-      // Parallel execution using C++11 lambda.
-      image.forEach<Pixel>([](Pixel &p, const int * position) -> void {
-          p.x = 255;
-      });
-  @endcode
-  Example 2. Using the pixel's position:
-  @code
-      // Creating 3D matrix (255 x 255 x 255) typed uint8_t
-      // and initialize all elements by the value which equals elements
-  position.
-      // i.e. pixels (x,y,z) = (1,2,3) is (b,g,r) = (1,2,3).
-
-      int sizes[] = { 255, 255, 255 };
-      typedef cv::Point3_<uint8_t> Pixel;
-
-      Mat_<Pixel> image = Mat::zeros(3, sizes, CV_8UC3);
-
-      image.forEach<Pixel>([](Pixel& pixel, const int position[]) -> void {
-          pixel.x = position[0];
-          pixel.y = position[1];
-          pixel.z = position[2];
-      });
-  @endcode
-   */
-  template <typename _Tp, typename Functor>
-  void forEach(const Functor &operation);
-  /** @overload */
-  template <typename _Tp, typename Functor>
-  void forEach(const Functor &operation) const;
-
-  Mat(Mat &&m) CV_NOEXCEPT;
-  Mat &operator=(Mat &&m);
-
-  enum {
-    MAGIC_VAL = 0x42FF0000,
-    AUTO_STEP = 0,
-    CONTINUOUS_FLAG = CV_MAT_CONT_FLAG,
-    SUBMATRIX_FLAG = CV_SUBMAT_FLAG
-  };
-  enum { MAGIC_MASK = 0xFFFF0000, TYPE_MASK = 0x00000FFF, DEPTH_MASK = 7 };
-
-  /*! includes several bit-fields:
-       - the magic signature
-       - continuity flag
-       - depth
-       - number of channels
-   */
-  int flags;
-  //! the matrix dimensionality, >= 2
-  int dims;
-  //! the number of rows and columns or (-1, -1) when the matrix has more than 2
-  //! dimensions
-  int rows, cols;
-  //! pointer to the data
-  uchar *data;
-
-  //! helper fields used in locateROI and adjustROI
-  const uchar *datastart;
-  const uchar *dataend;
-  const uchar *datalimit;
-
-  //! custom allocator
-  MatAllocator *allocator;
-  //! and the standard allocator
-  static MatAllocator *getStdAllocator();
-  static MatAllocator *getDefaultAllocator();
-  static void setDefaultAllocator(MatAllocator *allocator);
-
-  //! internal use method: updates the continuity flag
-  void updateContinuityFlag();
-
-  //! interaction with UMat
-  UMatData *u;
-
-  MatSize size;
-  MatStep step;
-
-protected:
-  template <typename _Tp, typename Functor>
-  void forEach_impl(const Functor &operation);
-};
-
-///////////////////////////////// Mat_<_Tp> ////////////////////////////////////
-
-/** @brief Template matrix class derived from Mat
-
-@code{.cpp}
-    template<typename _Tp> class Mat_ : public Mat
-    {
-    public:
-        // ... some specific methods
-        //         and
-        // no new extra fields
-    };
-@endcode
-The class `Mat_<_Tp>` is a *thin* template wrapper on top of the Mat class. It
-does not have any extra data fields. Nor this class nor Mat has any virtual
-methods. Thus, references or pointers to these two classes can be freely but
-carefully converted one to another. For example:
-@code{.cpp}
-    // create a 100x100 8-bit matrix
-    Mat M(100,100,CV_8U);
-    // this will be compiled fine. no any data conversion will be done.
-    Mat_<float>& M1 = (Mat_<float>&)M;
-    // the program is likely to crash at the statement below
-    M1(99,99) = 1.f;
-@endcode
-While Mat is sufficient in most cases, Mat_ can be more convenient if you use a
-lot of element access operations and if you know matrix type at the compilation
-time. Note that `Mat::at(int y,int x)` and `Mat_::operator()(int y,int x)` do
-absolutely the same and run at the same speed, but the latter is certainly
-shorter:
-@code{.cpp}
-    Mat_<double> M(20,20);
-    for(int i = 0; i < M.rows; i++)
-        for(int j = 0; j < M.cols; j++)
-            M(i,j) = 1./(i+j+1);
-    Mat E, V;
-    eigen(M,E,V);
-    cout << E.at<double>(0,0)/E.at<double>(M.rows-1,0);
-@endcode
-To use Mat_ for multi-channel images/matrices, pass Vec as a Mat_ parameter:
-@code{.cpp}
-    // allocate a 320x240 color image and fill it with green (in RGB space)
-    Mat_<Vec3b> img(240, 320, Vec3b(0,255,0));
-    // now draw a diagonal white line
-    for(int i = 0; i < 100; i++)
-        img(i,i)=Vec3b(255,255,255);
-    // and now scramble the 2nd (red) channel of each pixel
-    for(int i = 0; i < img.rows; i++)
-        for(int j = 0; j < img.cols; j++)
-            img(i,j)[2] ^= (uchar)(i ^ j);
-@endcode
-Mat_ is fully compatible with C++11 range-based for loop. For example such loop
-can be used to safely apply look-up table:
-@code{.cpp}
-void applyTable(Mat_<uchar>& I, const uchar* const table)
-{
-    for(auto& pixel : I)
-    {
-        pixel = table[pixel];
-    }
-}
-@endcode
- */
-template <typename _Tp> class Mat_ : public Mat {
-public:
-  typedef _Tp value_type;
-  typedef typename DataType<_Tp>::channel_type channel_type;
-  typedef MatIterator_<_Tp> iterator;
-  typedef MatConstIterator_<_Tp> const_iterator;
-
-  //! default constructor
-  Mat_() CV_NOEXCEPT;
-  //! equivalent to Mat(_rows, _cols, DataType<_Tp>::type)
-  Mat_(int _rows, int _cols);
-  //! constructor that sets each matrix element to specified value
-  Mat_(int _rows, int _cols, const _Tp &value);
-  //! equivalent to Mat(_size, DataType<_Tp>::type)
-  explicit Mat_(Size _size);
-  //! constructor that sets each matrix element to specified value
-  Mat_(Size _size, const _Tp &value);
-  //! n-dim array constructor
-  Mat_(int _ndims, const int *_sizes);
-  //! n-dim array constructor that sets each matrix element to specified value
-  Mat_(int _ndims, const int *_sizes, const _Tp &value);
-  //! copy/conversion constructor. If m is of different type, it's converted
-  Mat_(const Mat &m);
-  //! copy constructor
-  Mat_(const Mat_ &m);
-  //! constructs a matrix on top of user-allocated data. step is in bytes(!!!),
-  //! regardless of the type
-  Mat_(int _rows, int _cols, _Tp *_data, size_t _step = AUTO_STEP);
-  //! constructs n-dim matrix on top of user-allocated data. steps are in
-  //! bytes(!!!), regardless of the type
-  Mat_(int _ndims, const int *_sizes, _Tp *_data, const size_t *_steps = 0);
-  //! selects a submatrix
-  Mat_(const Mat_ &m, const Range &rowRange,
-       const Range &colRange = Range::all());
-  //! selects a submatrix
-  Mat_(const Mat_ &m, const Rect &roi);
-  //! selects a submatrix, n-dim version
-  Mat_(const Mat_ &m, const Range *ranges);
-  //! selects a submatrix, n-dim version
-  Mat_(const Mat_ &m, const std::vector<Range> &ranges);
-  //! from a matrix expression
-  explicit Mat_(const MatExpr &e);
-  //! makes a matrix out of Vec, std::vector, Point_ or Point3_. The matrix will
-  //! have a single column
-  explicit Mat_(const std::vector<_Tp> &vec, bool copyData = false);
-  template <int n>
-  explicit Mat_(const Vec<typename DataType<_Tp>::channel_type, n> &vec,
-                bool copyData = true);
-  template <int m, int n>
-  explicit Mat_(const Matx<typename DataType<_Tp>::channel_type, m, n> &mtx,
-                bool copyData = true);
-  explicit Mat_(const Point_<typename DataType<_Tp>::channel_type> &pt,
-                bool copyData = true);
-  explicit Mat_(const Point3_<typename DataType<_Tp>::channel_type> &pt,
-                bool copyData = true);
-  explicit Mat_(const MatCommaInitializer_<_Tp> &commaInitializer);
-
-  Mat_(std::initializer_list<_Tp> values);
-  explicit Mat_(const std::initializer_list<int> sizes,
-                const std::initializer_list<_Tp> values);
-
-  template <std::size_t _Nm>
-  explicit Mat_(const std::array<_Tp, _Nm> &arr, bool copyData = false);
-
-  Mat_ &operator=(const Mat &m);
-  Mat_ &operator=(const Mat_ &m);
-  //! set all the elements to s.
-  Mat_ &operator=(const _Tp &s);
-  //! assign a matrix expression
-  Mat_ &operator=(const MatExpr &e);
-
-  //! iterators; they are smart enough to skip gaps in the end of rows
-  iterator begin();
-  iterator end();
-  const_iterator begin() const;
-  const_iterator end() const;
-
-  // reverse iterators
-  std::reverse_iterator<iterator> rbegin();
-  std::reverse_iterator<iterator> rend();
-  std::reverse_iterator<const_iterator> rbegin() const;
-  std::reverse_iterator<const_iterator> rend() const;
-
-  //! template methods for operation over all matrix elements.
-  // the operations take care of skipping gaps in the end of rows (if any)
-  template <typename Functor> void forEach(const Functor &operation);
-  template <typename Functor> void forEach(const Functor &operation) const;
-
-  //! equivalent to Mat::create(_rows, _cols, DataType<_Tp>::type)
-  void create(int _rows, int _cols);
-  //! equivalent to Mat::create(_size, DataType<_Tp>::type)
-  void create(Size _size);
-  //! equivalent to Mat::create(_ndims, _sizes, DatType<_Tp>::type)
-  void create(int _ndims, const int *_sizes);
-  //! equivalent to Mat::release()
-  void release();
-  //! cross-product
-  Mat_ cross(const Mat_ &m) const;
-  //! data type conversion
-  template <typename T2> operator Mat_<T2>() const;
-  //! overridden forms of Mat::row() etc.
-  Mat_ row(int y) const;
-  Mat_ col(int x) const;
-  Mat_ diag(int d = 0) const;
-  CV_NODISCARD_STD Mat_ clone() const;
-
-  //! overridden forms of Mat::elemSize() etc.
-  size_t elemSize() const;
-  size_t elemSize1() const;
-  int type() const;
-  int depth() const;
-  int channels() const;
-  size_t step1(int i = 0) const;
-  //! returns step()/sizeof(_Tp)
-  size_t stepT(int i = 0) const;
-
-  //! overridden forms of Mat::zeros() etc. Data type is omitted, of course
-  CV_NODISCARD_STD static MatExpr zeros(int rows, int cols);
-  CV_NODISCARD_STD static MatExpr zeros(Size size);
-  CV_NODISCARD_STD static MatExpr zeros(int _ndims, const int *_sizes);
-  CV_NODISCARD_STD static MatExpr ones(int rows, int cols);
-  CV_NODISCARD_STD static MatExpr ones(Size size);
-  CV_NODISCARD_STD static MatExpr ones(int _ndims, const int *_sizes);
-  CV_NODISCARD_STD static MatExpr eye(int rows, int cols);
-  CV_NODISCARD_STD static MatExpr eye(Size size);
-
-  //! some more overridden methods
-  Mat_ &adjustROI(int dtop, int dbottom, int dleft, int dright);
-  Mat_ operator()(const Range &rowRange, const Range &colRange) const;
-  Mat_ operator()(const Rect &roi) const;
-  Mat_ operator()(const Range *ranges) const;
-  Mat_ operator()(const std::vector<Range> &ranges) const;
-
-  //! more convenient forms of row and element access operators
-  _Tp *operator[](int y);
-  const _Tp *operator[](int y) const;
-
-  //! returns reference to the specified element
-  _Tp &operator()(const int *idx);
-  //! returns read-only reference to the specified element
-  const _Tp &operator()(const int *idx) const;
-
-  //! returns reference to the specified element
-  template <int n> _Tp &operator()(const Vec<int, n> &idx);
-  //! returns read-only reference to the specified element
-  template <int n> const _Tp &operator()(const Vec<int, n> &idx) const;
-
-  //! returns reference to the specified element (1D case)
-  _Tp &operator()(int idx0);
-  //! returns read-only reference to the specified element (1D case)
-  const _Tp &operator()(int idx0) const;
-  //! returns reference to the specified element (2D case)
-  _Tp &operator()(int row, int col);
-  //! returns read-only reference to the specified element (2D case)
-  const _Tp &operator()(int row, int col) const;
-  //! returns reference to the specified element (3D case)
-  _Tp &operator()(int idx0, int idx1, int idx2);
-  //! returns read-only reference to the specified element (3D case)
-  const _Tp &operator()(int idx0, int idx1, int idx2) const;
-
-  _Tp &operator()(Point pt);
-  const _Tp &operator()(Point pt) const;
-
-  //! conversion to vector.
-  operator std::vector<_Tp>() const;
-
-  //! conversion to array.
-  template <std::size_t _Nm> operator std::array<_Tp, _Nm>() const;
-
-  //! conversion to Vec
-  template <int n>
-  operator Vec<typename DataType<_Tp>::channel_type, n>() const;
-  //! conversion to Matx
-  template <int m, int n>
-  operator Matx<typename DataType<_Tp>::channel_type, m, n>() const;
-
-  Mat_(Mat_ &&m);
-  Mat_ &operator=(Mat_ &&m);
-
-  Mat_(Mat &&m);
-  Mat_ &operator=(Mat &&m);
-
-  Mat_(MatExpr &&e);
-};
-
-typedef Mat_<uchar> Mat1b;
-typedef Mat_<Vec2b> Mat2b;
-typedef Mat_<Vec3b> Mat3b;
-typedef Mat_<Vec4b> Mat4b;
-
-typedef Mat_<short> Mat1s;
-typedef Mat_<Vec2s> Mat2s;
-typedef Mat_<Vec3s> Mat3s;
-typedef Mat_<Vec4s> Mat4s;
-
-typedef Mat_<ushort> Mat1w;
-typedef Mat_<Vec2w> Mat2w;
-typedef Mat_<Vec3w> Mat3w;
-typedef Mat_<Vec4w> Mat4w;
-
-typedef Mat_<int> Mat1i;
-typedef Mat_<Vec2i> Mat2i;
-typedef Mat_<Vec3i> Mat3i;
-typedef Mat_<Vec4i> Mat4i;
-
-typedef Mat_<float> Mat1f;
-typedef Mat_<Vec2f> Mat2f;
-typedef Mat_<Vec3f> Mat3f;
-typedef Mat_<Vec4f> Mat4f;
-
-typedef Mat_<double> Mat1d;
-typedef Mat_<Vec2d> Mat2d;
-typedef Mat_<Vec3d> Mat3d;
-typedef Mat_<Vec4d> Mat4d;
-
-/////////////////////////// multi-dimensional sparse matrix
-/////////////////////////////
-
-/** @brief The class SparseMat represents multi-dimensional sparse numerical
-arrays.
-
-Such a sparse array can store elements of any type that Mat can store. *Sparse*
-means that only non-zero elements are stored (though, as a result of operations
-on a sparse matrix, some of its stored elements can actually become 0. It is up
-to you to detect such elements and delete them using SparseMat::erase ). The
-non-zero elements are stored in a hash table that grows when it is filled so
-that the search time is O(1) in average (regardless of whether element is there
-or not). Elements can be accessed using the following methods:
--   Query operations (SparseMat::ptr and the higher-level SparseMat::ref,
-SparseMat::value and SparseMat::find), for example:
-    @code
-        const int dims = 5;
-        int size[5] = {10, 10, 10, 10, 10};
-        SparseMat sparse_mat(dims, size, CV_32F);
-        for(int i = 0; i < 1000; i++)
-        {
-            int idx[dims];
-            for(int k = 0; k < dims; k++)
-                idx[k] = rand() % size[k];
-            sparse_mat.ref<float>(idx) += 1.f;
-        }
-        cout << "nnz = " << sparse_mat.nzcount() << endl;
-    @endcode
--   Sparse matrix iterators. They are similar to MatIterator but different from
-NAryMatIterator. That is, the iteration loop is familiar to STL users:
-    @code
-        // prints elements of a sparse floating-point matrix
-        // and the sum of elements.
-        SparseMatConstIterator_<float>
-            it = sparse_mat.begin<float>(),
-            it_end = sparse_mat.end<float>();
-        double s = 0;
-        int dims = sparse_mat.dims();
-        for(; it != it_end; ++it)
-        {
-            // print element indices and the element value
-            const SparseMat::Node* n = it.node();
-            printf("(");
-            for(int i = 0; i < dims; i++)
-                printf("%d%s", n->idx[i], i < dims-1 ? ", " : ")");
-            printf(": %g\n", it.value<float>());
-            s += *it;
-        }
-        printf("Element sum is %g\n", s);
-    @endcode
-    If you run this loop, you will notice that elements are not enumerated in a
-logical order (lexicographical, and so on). They come in the same order as they
-are stored in the hash table (semi-randomly). You may collect pointers to the
-nodes and sort them to get the proper ordering. Note, however, that pointers to
-the nodes may become invalid when you add more elements to the matrix. This may
-happen due to possible buffer reallocation.
--   Combination of the above 2 methods when you need to process 2 or more sparse
-matrices simultaneously. For example, this is how you can compute unnormalized
-cross-correlation of the 2 floating-point sparse matrices:
-    @code
-        double cross_corr(const SparseMat& a, const SparseMat& b)
-        {
-            const SparseMat *_a = &a, *_b = &b;
-            // if b contains less elements than a,
-            // it is faster to iterate through b
-            if(_a->nzcount() > _b->nzcount())
-                std::swap(_a, _b);
-            SparseMatConstIterator_<float> it = _a->begin<float>(),
-                                           it_end = _a->end<float>();
-            double ccorr = 0;
-            for(; it != it_end; ++it)
-            {
-                // take the next element from the first matrix
-                float avalue = *it;
-                const Node* anode = it.node();
-                // and try to find an element with the same index in the second
-matrix.
-                // since the hash value depends only on the element index,
-                // reuse the hash value stored in the node
-                float bvalue = _b->value<float>(anode->idx,&anode->hashval);
-                ccorr += avalue*bvalue;
-            }
-            return ccorr;
-        }
-    @endcode
- */
-class CV_EXPORTS SparseMat {
-public:
-  typedef SparseMatIterator iterator;
-  typedef SparseMatConstIterator const_iterator;
-
-  enum {
-    MAGIC_VAL = 0x42FD0000,
-    MAX_DIM = 32,
-    HASH_SCALE = 0x5bd1e995,
-    HASH_BIT = 0x80000000
-  };
-
-  //! the sparse matrix header
-  struct CV_EXPORTS Hdr {
-    Hdr(int _dims, const int *_sizes, int _type);
-    void clear();
-    int refcount;
-    int dims;
-    int valueOffset;
-    size_t nodeSize;
-    size_t nodeCount;
-    size_t freeList;
-    std::vector<uchar> pool;
-    std::vector<size_t> hashtab;
-    int size[MAX_DIM];
-  };
-
-  //! sparse matrix node - element of a hash table
-  struct CV_EXPORTS Node {
-    //! hash value
-    size_t hashval;
-    //! index of the next node in the same hash table entry
-    size_t next;
-    //! index of the matrix element
-    int idx[MAX_DIM];
-  };
-
-  /** @brief Various SparseMat constructors.
-   */
-  SparseMat();
-
-  /** @overload
-  @param dims Array dimensionality.
-  @param _sizes Sparce matrix size on all dementions.
-  @param _type Sparse matrix data type.
-  */
-  SparseMat(int dims, const int *_sizes, int _type);
-
-  /** @overload
-  @param m Source matrix for copy constructor. If m is dense matrix (ocvMat)
-  then it will be converted to sparse representation.
-  */
-  SparseMat(const SparseMat &m);
-
-  /** @overload
-  @param m Source matrix for copy constructor. If m is dense matrix (ocvMat)
-  then it will be converted to sparse representation.
-  */
-  explicit SparseMat(const Mat &m);
-
-  //! the destructor
-  ~SparseMat();
-
-  //! assignment operator. This is O(1) operation, i.e. no data is copied
-  SparseMat &operator=(const SparseMat &m);
-  //! equivalent to the corresponding constructor
-  SparseMat &operator=(const Mat &m);
-
-  //! creates full copy of the matrix
-  CV_NODISCARD_STD SparseMat clone() const;
-
-  //! copies all the data to the destination matrix. All the previous content of
-  //! m is erased
-  void copyTo(SparseMat &m) const;
-  //! converts sparse matrix to dense matrix.
-  void copyTo(Mat &m) const;
-  //! multiplies all the matrix elements by the specified scale factor alpha and
-  //! converts the results to the specified data type
-  void convertTo(SparseMat &m, int rtype, double alpha = 1) const;
-  //! converts sparse matrix to dense n-dim matrix with optional type conversion
-  //! and scaling.
-  /*!
-      @param [out] m - output matrix; if it does not have a proper size or type
-     before the operation, it is reallocated
-      @param [in] rtype - desired output matrix type or, rather, the depth since
-     the number of channels are the same as the input has; if rtype is negative,
-     the output matrix will have the same type as the input.
-      @param [in] alpha - optional scale factor
-      @param [in] beta - optional delta added to the scaled values
-  */
-  void convertTo(Mat &m, int rtype, double alpha = 1, double beta = 0) const;
-
-  // not used now
-  void assignTo(SparseMat &m, int type = -1) const;
-
-  //! reallocates sparse matrix.
-  /*!
-      If the matrix already had the proper size and type,
-      it is simply cleared with clear(), otherwise,
-      the old matrix is released (using release()) and the new one is allocated.
-  */
-  void create(int dims, const int *_sizes, int _type);
-  //! sets all the sparse matrix elements to 0, which means clearing the hash
-  //! table.
-  void clear();
-  //! manually increments the reference counter to the header.
-  void addref();
-  // decrements the header reference counter. When the counter reaches 0, the
-  // header and all the underlying data are deallocated.
-  void release();
-
-  //! converts sparse matrix to the old-style representation; all the elements
-  //! are copied.
-  // operator CvSparseMat*() const;
-  //! returns the size of each element in bytes (not including the overhead -
-  //! the space occupied by SparseMat::Node elements)
-  size_t elemSize() const;
-  //! returns elemSize()/channels()
-  size_t elemSize1() const;
-
-  //! returns type of sparse matrix elements
-  int type() const;
-  //! returns the depth of sparse matrix elements
-  int depth() const;
-  //! returns the number of channels
-  int channels() const;
-
-  //! returns the array of sizes, or NULL if the matrix is not allocated
-  const int *size() const;
-  //! returns the size of i-th matrix dimension (or 0)
-  int size(int i) const;
-  //! returns the matrix dimensionality
-  int dims() const;
-  //! returns the number of non-zero elements (=the number of hash table nodes)
-  size_t nzcount() const;
-
-  //! computes the element hash value (1D case)
-  size_t hash(int i0) const;
-  //! computes the element hash value (2D case)
-  size_t hash(int i0, int i1) const;
-  //! computes the element hash value (3D case)
-  size_t hash(int i0, int i1, int i2) const;
-  //! computes the element hash value (nD case)
-  size_t hash(const int *idx) const;
-
-  //!@{
-  /*!
-   specialized variants for 1D, 2D, 3D cases and the generic_type one for n-D
-   case. return pointer to the matrix element.
-    - if the element is there (it's non-zero), the pointer to it is returned
-    - if it's not there and createMissing=false, NULL pointer is returned
-    - if it's not there and createMissing=true, then the new element
-      is created and initialized with 0. Pointer to it is returned
-    - if the optional hashval pointer is not NULL, the element hash value is
-      not computed, but *hashval is taken instead.
-  */
-  //! returns pointer to the specified element (1D case)
-  uchar *ptr(int i0, bool createMissing, size_t *hashval = 0);
-  //! returns pointer to the specified element (2D case)
-  uchar *ptr(int i0, int i1, bool createMissing, size_t *hashval = 0);
-  //! returns pointer to the specified element (3D case)
-  uchar *ptr(int i0, int i1, int i2, bool createMissing, size_t *hashval = 0);
-  //! returns pointer to the specified element (nD case)
-  uchar *ptr(const int *idx, bool createMissing, size_t *hashval = 0);
-  //!@}
-
-  //!@{
-  /*!
-   return read-write reference to the specified sparse matrix element.
-
-   `ref<_Tp>(i0,...[,hashval])` is equivalent to
-   `*(_Tp*)ptr(i0,...,true[,hashval])`. The methods always return a valid
-   reference. If the element did not exist, it is created and initialized with
-   0.
-  */
-  //! returns reference to the specified element (1D case)
-  template <typename _Tp> _Tp &ref(int i0, size_t *hashval = 0);
-  //! returns reference to the specified element (2D case)
-  template <typename _Tp> _Tp &ref(int i0, int i1, size_t *hashval = 0);
-  //! returns reference to the specified element (3D case)
-  template <typename _Tp> _Tp &ref(int i0, int i1, int i2, size_t *hashval = 0);
-  //! returns reference to the specified element (nD case)
-  template <typename _Tp> _Tp &ref(const int *idx, size_t *hashval = 0);
-  //!@}
-
-  //!@{
-  /*!
-   return value of the specified sparse matrix element.
-
-   `value<_Tp>(i0,...[,hashval])` is equivalent to
-   @code
-   { const _Tp* p = find<_Tp>(i0,...[,hashval]); return p ? *p : _Tp(); }
-   @endcode
-
-   That is, if the element did not exist, the methods return 0.
-   */
-  //! returns value of the specified element (1D case)
-  template <typename _Tp> _Tp value(int i0, size_t *hashval = 0) const;
-  //! returns value of the specified element (2D case)
-  template <typename _Tp> _Tp value(int i0, int i1, size_t *hashval = 0) const;
-  //! returns value of the specified element (3D case)
-  template <typename _Tp>
-  _Tp value(int i0, int i1, int i2, size_t *hashval = 0) const;
-  //! returns value of the specified element (nD case)
-  template <typename _Tp> _Tp value(const int *idx, size_t *hashval = 0) const;
-  //!@}
-
-  //!@{
-  /*!
-   Return pointer to the specified sparse matrix element if it exists
-
-   `find<_Tp>(i0,...[,hashval])` is equivalent to `(_const
-   Tp*)ptr(i0,...false[,hashval])`.
-
-   If the specified element does not exist, the methods return NULL.
-  */
-  //! returns pointer to the specified element (1D case)
-  template <typename _Tp> const _Tp *find(int i0, size_t *hashval = 0) const;
-  //! returns pointer to the specified element (2D case)
-  template <typename _Tp>
-  const _Tp *find(int i0, int i1, size_t *hashval = 0) const;
-  //! returns pointer to the specified element (3D case)
-  template <typename _Tp>
-  const _Tp *find(int i0, int i1, int i2, size_t *hashval = 0) const;
-  //! returns pointer to the specified element (nD case)
-  template <typename _Tp>
-  const _Tp *find(const int *idx, size_t *hashval = 0) const;
-  //!@}
-
-  //! erases the specified element (2D case)
-  void erase(int i0, int i1, size_t *hashval = 0);
-  //! erases the specified element (3D case)
-  void erase(int i0, int i1, int i2, size_t *hashval = 0);
-  //! erases the specified element (nD case)
-  void erase(const int *idx, size_t *hashval = 0);
-
-  //!@{
-  /*!
-     return the sparse matrix iterator pointing to the first sparse matrix
-     element
-  */
-  //! returns the sparse matrix iterator at the matrix beginning
-  SparseMatIterator begin();
-  //! returns the sparse matrix iterator at the matrix beginning
-  template <typename _Tp> SparseMatIterator_<_Tp> begin();
-  //! returns the read-only sparse matrix iterator at the matrix beginning
-  SparseMatConstIterator begin() const;
-  //! returns the read-only sparse matrix iterator at the matrix beginning
-  template <typename _Tp> SparseMatConstIterator_<_Tp> begin() const;
-  //!@}
-  /*!
-     return the sparse matrix iterator pointing to the element following the
-     last sparse matrix element
-  */
-  //! returns the sparse matrix iterator at the matrix end
-  SparseMatIterator end();
-  //! returns the read-only sparse matrix iterator at the matrix end
-  SparseMatConstIterator end() const;
-  //! returns the typed sparse matrix iterator at the matrix end
-  template <typename _Tp> SparseMatIterator_<_Tp> end();
-  //! returns the typed read-only sparse matrix iterator at the matrix end
-  template <typename _Tp> SparseMatConstIterator_<_Tp> end() const;
-
-  //! returns the value stored in the sparse martix node
-  template <typename _Tp> _Tp &value(Node *n);
-  //! returns the value stored in the sparse martix node
-  template <typename _Tp> const _Tp &value(const Node *n) const;
-
-  ////////////// some internal-use methods ///////////////
-  Node *node(size_t nidx);
-  const Node *node(size_t nidx) const;
-
-  uchar *newNode(const int *idx, size_t hashval);
-  void removeNode(size_t hidx, size_t nidx, size_t previdx);
-  void resizeHashTab(size_t newsize);
-
-  int flags;
-  Hdr *hdr;
-};
-
-///////////////////////////////// SparseMat_<_Tp>
-///////////////////////////////////////
-
-/** @brief Template sparse n-dimensional array class derived from SparseMat
-
-SparseMat_ is a thin wrapper on top of SparseMat created in the same way as Mat_
-. It simplifies notation of some operations:
-@code
-    int sz[] = {10, 20, 30};
-    SparseMat_<double> M(3, sz);
-    ...
-    M.ref(1, 2, 3) = M(4, 5, 6) + M(7, 8, 9);
-@endcode
- */
-template <typename _Tp> class SparseMat_ : public SparseMat {
-public:
-  typedef SparseMatIterator_<_Tp> iterator;
-  typedef SparseMatConstIterator_<_Tp> const_iterator;
-
-  //! the default constructor
-  SparseMat_();
-  //! the full constructor equivalent to SparseMat(dims, _sizes,
-  //! DataType<_Tp>::type)
-  SparseMat_(int dims, const int *_sizes);
-  //! the copy constructor. If DataType<_Tp>.type != m.type(), the m elements
-  //! are converted
-  SparseMat_(const SparseMat &m);
-  //! the copy constructor. This is O(1) operation - no data is copied
-  SparseMat_(const SparseMat_ &m);
-  //! converts dense matrix to the sparse form
-  SparseMat_(const Mat &m);
-  //! converts the old-style sparse matrix to the C++ class. All the elements
-  //! are copied
-  // SparseMat_(const CvSparseMat* m);
-  //! the assignment operator. If DataType<_Tp>.type != m.type(), the m elements
-  //! are converted
-  SparseMat_ &operator=(const SparseMat &m);
-  //! the assignment operator. This is O(1) operation - no data is copied
-  SparseMat_ &operator=(const SparseMat_ &m);
-  //! converts dense matrix to the sparse form
-  SparseMat_ &operator=(const Mat &m);
-
-  //! makes full copy of the matrix. All the elements are duplicated
-  CV_NODISCARD_STD SparseMat_ clone() const;
-  //! equivalent to cv::SparseMat::create(dims, _sizes, DataType<_Tp>::type)
-  void create(int dims, const int *_sizes);
-  //! converts sparse matrix to the old-style CvSparseMat. All the elements are
-  //! copied
-  // operator CvSparseMat*() const;
-
-  //! returns type of the matrix elements
-  int type() const;
-  //! returns depth of the matrix elements
-  int depth() const;
-  //! returns the number of channels in each matrix element
-  int channels() const;
-
-  //! equivalent to SparseMat::ref<_Tp>(i0, hashval)
-  _Tp &ref(int i0, size_t *hashval = 0);
-  //! equivalent to SparseMat::ref<_Tp>(i0, i1, hashval)
-  _Tp &ref(int i0, int i1, size_t *hashval = 0);
-  //! equivalent to SparseMat::ref<_Tp>(i0, i1, i2, hashval)
-  _Tp &ref(int i0, int i1, int i2, size_t *hashval = 0);
-  //! equivalent to SparseMat::ref<_Tp>(idx, hashval)
-  _Tp &ref(const int *idx, size_t *hashval = 0);
-
-  //! equivalent to SparseMat::value<_Tp>(i0, hashval)
-  _Tp operator()(int i0, size_t *hashval = 0) const;
-  //! equivalent to SparseMat::value<_Tp>(i0, i1, hashval)
-  _Tp operator()(int i0, int i1, size_t *hashval = 0) const;
-  //! equivalent to SparseMat::value<_Tp>(i0, i1, i2, hashval)
-  _Tp operator()(int i0, int i1, int i2, size_t *hashval = 0) const;
-  //! equivalent to SparseMat::value<_Tp>(idx, hashval)
-  _Tp operator()(const int *idx, size_t *hashval = 0) const;
-
-  //! returns sparse matrix iterator pointing to the first sparse matrix element
-  SparseMatIterator_<_Tp> begin();
-  //! returns read-only sparse matrix iterator pointing to the first sparse
-  //! matrix element
-  SparseMatConstIterator_<_Tp> begin() const;
-  //! returns sparse matrix iterator pointing to the element following the last
-  //! sparse matrix element
-  SparseMatIterator_<_Tp> end();
-  //! returns read-only sparse matrix iterator pointing to the element following
-  //! the last sparse matrix element
-  SparseMatConstIterator_<_Tp> end() const;
-};
-
-////////////////////////////////// MatConstIterator
-/////////////////////////////////////
-
-class CV_EXPORTS MatConstIterator {
-public:
-  typedef uchar *value_type;
-  typedef ptrdiff_t difference_type;
-  typedef const uchar **pointer;
-  typedef uchar *reference;
-
-  typedef std::random_access_iterator_tag iterator_category;
-
-  //! default constructor
-  MatConstIterator();
-  //! constructor that sets the iterator to the beginning of the matrix
-  MatConstIterator(const Mat *_m);
-  //! constructor that sets the iterator to the specified element of the matrix
-  MatConstIterator(const Mat *_m, int _row, int _col = 0);
-  //! constructor that sets the iterator to the specified element of the matrix
-  MatConstIterator(const Mat *_m, Point _pt);
-  //! constructor that sets the iterator to the specified element of the matrix
-  MatConstIterator(const Mat *_m, const int *_idx);
-  //! copy constructor
-  MatConstIterator(const MatConstIterator &it);
-
-  //! copy operator
-  MatConstIterator &operator=(const MatConstIterator &it);
-  //! returns the current matrix element
-  const uchar *operator*() const;
-  //! returns the i-th matrix element, relative to the current
-  const uchar *operator[](ptrdiff_t i) const;
-
-  //! shifts the iterator forward by the specified number of elements
-  MatConstIterator &operator+=(ptrdiff_t ofs);
-  //! shifts the iterator backward by the specified number of elements
-  MatConstIterator &operator-=(ptrdiff_t ofs);
-  //! decrements the iterator
-  MatConstIterator &operator--();
-  //! decrements the iterator
-  MatConstIterator operator--(int);
-  //! increments the iterator
-  MatConstIterator &operator++();
-  //! increments the iterator
-  MatConstIterator operator++(int);
-  //! returns the current iterator position
-  Point pos() const;
-  //! returns the current iterator position
-  void pos(int *_idx) const;
-
-  ptrdiff_t lpos() const;
-  void seek(ptrdiff_t ofs, bool relative = false);
-  void seek(const int *_idx, bool relative = false);
-
-  const Mat *m;
-  size_t elemSize;
-  const uchar *ptr;
-  const uchar *sliceStart;
-  const uchar *sliceEnd;
-};
-
-////////////////////////////////// MatConstIterator_
-////////////////////////////////////
-
-/** @brief Matrix read-only iterator
- */
-template <typename _Tp> class MatConstIterator_ : public MatConstIterator {
-public:
-  typedef _Tp value_type;
-  typedef ptrdiff_t difference_type;
-  typedef const _Tp *pointer;
-  typedef const _Tp &reference;
-
-  typedef std::random_access_iterator_tag iterator_category;
-
-  //! default constructor
-  MatConstIterator_();
-  //! constructor that sets the iterator to the beginning of the matrix
-  MatConstIterator_(const Mat_<_Tp> *_m);
-  //! constructor that sets the iterator to the specified element of the matrix
-  MatConstIterator_(const Mat_<_Tp> *_m, int _row, int _col = 0);
-  //! constructor that sets the iterator to the specified element of the matrix
-  MatConstIterator_(const Mat_<_Tp> *_m, Point _pt);
-  //! constructor that sets the iterator to the specified element of the matrix
-  MatConstIterator_(const Mat_<_Tp> *_m, const int *_idx);
-  //! copy constructor
-  MatConstIterator_(const MatConstIterator_ &it);
-
-  //! copy operator
-  MatConstIterator_ &operator=(const MatConstIterator_ &it);
-  //! returns the current matrix element
-  const _Tp &operator*() const;
-  //! returns the i-th matrix element, relative to the current
-  const _Tp &operator[](ptrdiff_t i) const;
-
-  //! shifts the iterator forward by the specified number of elements
-  MatConstIterator_ &operator+=(ptrdiff_t ofs);
-  //! shifts the iterator backward by the specified number of elements
-  MatConstIterator_ &operator-=(ptrdiff_t ofs);
-  //! decrements the iterator
-  MatConstIterator_ &operator--();
-  //! decrements the iterator
-  MatConstIterator_ operator--(int);
-  //! increments the iterator
-  MatConstIterator_ &operator++();
-  //! increments the iterator
-  MatConstIterator_ operator++(int);
-  //! returns the current iterator position
-  Point pos() const;
-};
-
-//////////////////////////////////// MatIterator_
-///////////////////////////////////////
-
-/** @brief Matrix read-write iterator
- */
-template <typename _Tp> class MatIterator_ : public MatConstIterator_<_Tp> {
-public:
-  typedef _Tp *pointer;
-  typedef _Tp &reference;
-
-  typedef std::random_access_iterator_tag iterator_category;
-
-  //! the default constructor
-  MatIterator_();
-  //! constructor that sets the iterator to the beginning of the matrix
-  MatIterator_(Mat_<_Tp> *_m);
-  //! constructor that sets the iterator to the specified element of the matrix
-  MatIterator_(Mat_<_Tp> *_m, int _row, int _col = 0);
-  //! constructor that sets the iterator to the specified element of the matrix
-  MatIterator_(Mat_<_Tp> *_m, Point _pt);
-  //! constructor that sets the iterator to the specified element of the matrix
-  MatIterator_(Mat_<_Tp> *_m, const int *_idx);
-  //! copy constructor
-  MatIterator_(const MatIterator_ &it);
-  //! copy operator
-  MatIterator_ &operator=(const MatIterator_<_Tp> &it);
-
-  //! returns the current matrix element
-  _Tp &operator*() const;
-  //! returns the i-th matrix element, relative to the current
-  _Tp &operator[](ptrdiff_t i) const;
-
-  //! shifts the iterator forward by the specified number of elements
-  MatIterator_ &operator+=(ptrdiff_t ofs);
-  //! shifts the iterator backward by the specified number of elements
-  MatIterator_ &operator-=(ptrdiff_t ofs);
-  //! decrements the iterator
-  MatIterator_ &operator--();
-  //! decrements the iterator
-  MatIterator_ operator--(int);
-  //! increments the iterator
-  MatIterator_ &operator++();
-  //! increments the iterator
-  MatIterator_ operator++(int);
-};
-
-/////////////////////////////// SparseMatConstIterator
-//////////////////////////////////
-
-/**  @brief Read-Only Sparse Matrix Iterator.
-
- Here is how to use the iterator to compute the sum of floating-point sparse
- matrix elements:
-
- \code
- SparseMatConstIterator it = m.begin(), it_end = m.end();
- double s = 0;
- CV_Assert( m.type() == CV_32F );
- for( ; it != it_end; ++it )
-    s += it.value<float>();
- \endcode
-*/
-class CV_EXPORTS SparseMatConstIterator {
-public:
-  //! the default constructor
-  SparseMatConstIterator();
-  //! the full constructor setting the iterator to the first sparse matrix
-  //! element
-  SparseMatConstIterator(const SparseMat *_m);
-  //! the copy constructor
-  SparseMatConstIterator(const SparseMatConstIterator &it);
-
-  //! the assignment operator
-  SparseMatConstIterator &operator=(const SparseMatConstIterator &it);
-
-  //! template method returning the current matrix element
-  template <typename _Tp> const _Tp &value() const;
-  //! returns the current node of the sparse matrix. it.node->idx is the current
-  //! element index
-  const SparseMat::Node *node() const;
-
-  //! moves iterator to the previous element
-  SparseMatConstIterator &operator--();
-  //! moves iterator to the previous element
-  SparseMatConstIterator operator--(int);
-  //! moves iterator to the next element
-  SparseMatConstIterator &operator++();
-  //! moves iterator to the next element
-  SparseMatConstIterator operator++(int);
-
-  //! moves iterator to the element after the last element
-  void seekEnd();
-
-  const SparseMat *m;
-  size_t hashidx;
-  uchar *ptr;
-};
-
-////////////////////////////////// SparseMatIterator
-////////////////////////////////////
-
-/** @brief  Read-write Sparse Matrix Iterator
-
- The class is similar to cv::SparseMatConstIterator,
- but can be used for in-place modification of the matrix elements.
-*/
-class CV_EXPORTS SparseMatIterator : public SparseMatConstIterator {
-public:
-  //! the default constructor
-  SparseMatIterator();
-  //! the full constructor setting the iterator to the first sparse matrix
-  //! element
-  SparseMatIterator(SparseMat *_m);
-  //! the full constructor setting the iterator to the specified sparse matrix
-  //! element
-  SparseMatIterator(SparseMat *_m, const int *idx);
-  //! the copy constructor
-  SparseMatIterator(const SparseMatIterator &it);
-
-  //! the assignment operator
-  SparseMatIterator &operator=(const SparseMatIterator &it);
-  //! returns read-write reference to the current sparse matrix element
-  template <typename _Tp> _Tp &value() const;
-  //! returns pointer to the current sparse matrix node. it.node->idx is the
-  //! index of the current element (do not modify it!)
-  SparseMat::Node *node() const;
-
-  //! moves iterator to the next element
-  SparseMatIterator &operator++();
-  //! moves iterator to the next element
-  SparseMatIterator operator++(int);
-};
-
-/////////////////////////////// SparseMatConstIterator_
-/////////////////////////////////
-
-/** @brief  Template Read-Only Sparse Matrix Iterator Class.
-
- This is the derived from SparseMatConstIterator class that
- introduces more convenient operator *() for accessing the current element.
-*/
-template <typename _Tp>
-class SparseMatConstIterator_ : public SparseMatConstIterator {
-public:
-  typedef std::forward_iterator_tag iterator_category;
-
-  //! the default constructor
-  SparseMatConstIterator_();
-  //! the full constructor setting the iterator to the first sparse matrix
-  //! element
-  SparseMatConstIterator_(const SparseMat_<_Tp> *_m);
-  SparseMatConstIterator_(const SparseMat *_m);
-  //! the copy constructor
-  SparseMatConstIterator_(const SparseMatConstIterator_ &it);
-
-  //! the assignment operator
-  SparseMatConstIterator_ &operator=(const SparseMatConstIterator_ &it);
-  //! the element access operator
-  const _Tp &operator*() const;
-
-  //! moves iterator to the next element
-  SparseMatConstIterator_ &operator++();
-  //! moves iterator to the next element
-  SparseMatConstIterator_ operator++(int);
-};
-
-///////////////////////////////// SparseMatIterator_
-////////////////////////////////////
-
-/** @brief  Template Read-Write Sparse Matrix Iterator Class.
-
- This is the derived from cv::SparseMatConstIterator_ class that
- introduces more convenient operator *() for accessing the current element.
-*/
-template <typename _Tp>
-class SparseMatIterator_ : public SparseMatConstIterator_<_Tp> {
-public:
-  typedef std::forward_iterator_tag iterator_category;
-
-  //! the default constructor
-  SparseMatIterator_();
-  //! the full constructor setting the iterator to the first sparse matrix
-  //! element
-  SparseMatIterator_(SparseMat_<_Tp> *_m);
-  SparseMatIterator_(SparseMat *_m);
-  //! the copy constructor
-  SparseMatIterator_(const SparseMatIterator_ &it);
-
-  //! the assignment operator
-  SparseMatIterator_ &operator=(const SparseMatIterator_ &it);
-  //! returns the reference to the current element
-  _Tp &operator*() const;
-
-  //! moves the iterator to the next element
-  SparseMatIterator_ &operator++();
-  //! moves the iterator to the next element
-  SparseMatIterator_ operator++(int);
-};
-
-/////////////////////////////////// NAryMatIterator
-/////////////////////////////////////
-
-/** @brief n-ary multi-dimensional array iterator.
-
-Use the class to implement unary, binary, and, generally, n-ary element-wise
-operations on multi-dimensional arrays. Some of the arguments of an n-ary
-function may be continuous arrays, some may be not. It is possible to use
-conventional MatIterator 's for each array but incrementing all of the iterators
-after each small operations may be a big overhead. In this case consider using
-NAryMatIterator to iterate through several matrices simultaneously as long as
-they have the same geometry (dimensionality and all the dimension sizes are the
-same). On each iteration `it.planes[0]`, `it.planes[1]`,... will be the slices
-of the corresponding matrices.
-
-The example below illustrates how you can compute a normalized and threshold 3D
-color histogram:
-@code
-    void computeNormalizedColorHist(const Mat& image, Mat& hist, int N, double
-minProb)
-    {
-        const int histSize[] = {N, N, N};
-
-        // make sure that the histogram has a proper size and type
-        hist.create(3, histSize, CV_32F);
-
-        // and clear it
-        hist = Scalar(0);
-
-        // the loop below assumes that the image
-        // is a 8-bit 3-channel. check it.
-        CV_Assert(image.type() == CV_8UC3);
-        MatConstIterator_<Vec3b> it = image.begin<Vec3b>(),
-                                 it_end = image.end<Vec3b>();
-        for( ; it != it_end; ++it )
-        {
-            const Vec3b& pix = *it;
-            hist.at<float>(pix[0]*N/256, pix[1]*N/256, pix[2]*N/256) += 1.f;
-        }
-
-        minProb *= image.rows*image.cols;
-
-        // initialize iterator (the style is different from STL).
-        // after initialization the iterator will contain
-        // the number of slices or planes the iterator will go through.
-        // it simultaneously increments iterators for several matrices
-        // supplied as a null terminated list of pointers
-        const Mat* arrays[] = {&hist, 0};
-        Mat planes[1];
-        NAryMatIterator itNAry(arrays, planes, 1);
-        double s = 0;
-        // iterate through the matrix. on each iteration
-        // itNAry.planes[i] (of type Mat) will be set to the current plane
-        // of the i-th n-dim matrix passed to the iterator constructor.
-        for(int p = 0; p < itNAry.nplanes; p++, ++itNAry)
-        {
-            threshold(itNAry.planes[0], itNAry.planes[0], minProb, 0,
-THRESH_TOZERO); s += sum(itNAry.planes[0])[0];
-        }
-
-        s = 1./s;
-        itNAry = NAryMatIterator(arrays, planes, 1);
-        for(int p = 0; p < itNAry.nplanes; p++, ++itNAry)
-            itNAry.planes[0] *= s;
-    }
-@endcode
- */
-class CV_EXPORTS NAryMatIterator {
-public:
-  //! the default constructor
-  NAryMatIterator();
-  //! the full constructor taking arbitrary number of n-dim matrices
-  NAryMatIterator(const Mat **arrays, uchar **ptrs, int narrays = -1);
-  //! the full constructor taking arbitrary number of n-dim matrices
-  NAryMatIterator(const Mat **arrays, Mat *planes, int narrays = -1);
-  //! the separate iterator initialization method
-  void init(const Mat **arrays, Mat *planes, uchar **ptrs, int narrays = -1);
-
-  //! proceeds to the next plane of every iterated matrix
-  NAryMatIterator &operator++();
-  //! proceeds to the next plane of every iterated matrix (postfix increment
-  //! operator)
-  NAryMatIterator operator++(int);
-
-  //! the iterated arrays
-  const Mat **arrays;
-  //! the current planes
-  Mat *planes;
-  //! data pointers
-  uchar **ptrs;
-  //! the number of arrays
-  int narrays;
-  //! the number of hyper-planes that the iterator steps through
-  size_t nplanes;
-  //! the size of each segment (in elements)
-  size_t size;
-
-protected:
-  int iterdepth;
-  size_t idx;
-};
-
-///////////////////////////////// Matrix Expressions
-////////////////////////////////////
-
-class CV_EXPORTS MatOp {
-public:
-  MatOp();
-  virtual ~MatOp();
-
-  virtual bool elementWise(const MatExpr &expr) const;
-  virtual void assign(const MatExpr &expr, Mat &m, int type = -1) const = 0;
-  virtual void roi(const MatExpr &expr, const Range &rowRange,
-                   const Range &colRange, MatExpr &res) const;
-  virtual void diag(const MatExpr &expr, int d, MatExpr &res) const;
-  virtual void augAssignAdd(const MatExpr &expr, Mat &m) const;
-  virtual void augAssignSubtract(const MatExpr &expr, Mat &m) const;
-  virtual void augAssignMultiply(const MatExpr &expr, Mat &m) const;
-  virtual void augAssignDivide(const MatExpr &expr, Mat &m) const;
-  virtual void augAssignAnd(const MatExpr &expr, Mat &m) const;
-  virtual void augAssignOr(const MatExpr &expr, Mat &m) const;
-  virtual void augAssignXor(const MatExpr &expr, Mat &m) const;
-
-  virtual void add(const MatExpr &expr1, const MatExpr &expr2,
-                   MatExpr &res) const;
-  virtual void add(const MatExpr &expr1, const Scalar &s, MatExpr &res) const;
-
-  virtual void subtract(const MatExpr &expr1, const MatExpr &expr2,
-                        MatExpr &res) const;
-  virtual void subtract(const Scalar &s, const MatExpr &expr,
-                        MatExpr &res) const;
-
-  virtual void multiply(const MatExpr &expr1, const MatExpr &expr2,
-                        MatExpr &res, double scale = 1) const;
-  virtual void multiply(const MatExpr &expr1, double s, MatExpr &res) const;
-
-  virtual void divide(const MatExpr &expr1, const MatExpr &expr2, MatExpr &res,
-                      double scale = 1) const;
-  virtual void divide(double s, const MatExpr &expr, MatExpr &res) const;
-
-  virtual void abs(const MatExpr &expr, MatExpr &res) const;
-
-  virtual void transpose(const MatExpr &expr, MatExpr &res) const;
-  virtual void matmul(const MatExpr &expr1, const MatExpr &expr2,
-                      MatExpr &res) const;
-  virtual void invert(const MatExpr &expr, int method, MatExpr &res) const;
-
-  virtual Size size(const MatExpr &expr) const;
-  virtual int type(const MatExpr &expr) const;
-};
-
-/** @brief Matrix expression representation
-@anchor MatrixExpressions
-This is a list of implemented matrix operations that can be combined in
-arbitrary complex expressions (here A, B stand for matrices ( Mat ), s for a
-scalar ( Scalar ), alpha for a real-valued scalar ( double )):
--   Addition, subtraction, negation: `A+B`, `A-B`, `A+s`, `A-s`, `s+A`, `s-A`,
-`-A`
--   Scaling: `A*alpha`
--   Per-element multiplication and division: `A.mul(B)`, `A/B`, `alpha/A`
--   Matrix multiplication: `A*B`
--   Transposition: `A.t()` (means A<sup>T</sup>)
--   Matrix inversion and pseudo-inversion, solving linear systems and
-least-squares problems: `A.inv([method]) (~ A<sup>-1</sup>)`, `A.inv([method])*B
-(~ X: AX=B)`
--   Comparison: `A cmpop B`, `A cmpop alpha`, `alpha cmpop A`, where *cmpop* is
-one of
-  `>`, `>=`, `==`, `!=`, `<=`, `<`. The result of comparison is an 8-bit single
-channel mask whose elements are set to 255 (if the particular element or pair of
-elements satisfy the condition) or 0.
--   Bitwise logical operations: `A logicop B`, `A logicop s`, `s logicop A`,
-`~A`, where *logicop* is one of
-  `&`, `|`, `^`.
--   Element-wise minimum and maximum: `min(A, B)`, `min(A, alpha)`, `max(A, B)`,
-`max(A, alpha)`
--   Element-wise absolute value: `abs(A)`
--   Cross-product, dot-product: `A.cross(B)`, `A.dot(B)`
--   Any function of matrix or matrices and scalars that returns a matrix or a
-scalar, such as norm, mean, sum, countNonZero, trace, determinant, repeat, and
-others.
--   Matrix initializers ( Mat::eye(), Mat::zeros(), Mat::ones() ), matrix
-comma-separated initializers, matrix constructors and operators that extract
-sub-matrices (see Mat description).
--   Mat_<destination_type>() constructors to cast the result to the proper type.
-@note Comma-separated initializers and probably some other operations may
-require additional explicit Mat() or Mat_<T>() constructor calls to resolve a
-possible ambiguity.
-
-Here are examples of matrix expressions:
-@code
-    // compute pseudo-inverse of A, equivalent to A.inv(DECOMP_SVD)
-    SVD svd(A);
-    Mat pinvA = svd.vt.t()*Mat::diag(1./svd.w)*svd.u.t();
-
-    // compute the new vector of parameters in the Levenberg-Marquardt algorithm
-    x -= (A.t()*A +
-lambda*Mat::eye(A.cols,A.cols,A.type())).inv(DECOMP_CHOLESKY)*(A.t()*err);
-
-    // sharpen image using "unsharp mask" algorithm
-    Mat blurred; double sigma = 1, threshold = 5, amount = 1;
-    GaussianBlur(img, blurred, Size(), sigma, sigma);
-    Mat lowContrastMask = abs(img - blurred) < threshold;
-    Mat sharpened = img*(1+amount) + blurred*(-amount);
-    img.copyTo(sharpened, lowContrastMask);
-@endcode
-*/
-class CV_EXPORTS MatExpr {
-public:
-  MatExpr();
-  explicit MatExpr(const Mat &m);
-
-  MatExpr(const MatOp *_op, int _flags, const Mat &_a = Mat(),
-          const Mat &_b = Mat(), const Mat &_c = Mat(), double _alpha = 1,
-          double _beta = 1, const Scalar &_s = Scalar());
-
-  operator Mat() const;
-  template <typename _Tp> operator Mat_<_Tp>() const;
-
-  Size size() const;
-  int type() const;
-
-  MatExpr row(int y) const;
-  MatExpr col(int x) const;
-  MatExpr diag(int d = 0) const;
-  MatExpr operator()(const Range &rowRange, const Range &colRange) const;
-  MatExpr operator()(const Rect &roi) const;
-
-  MatExpr t() const;
-  MatExpr inv(int method = DECOMP_LU) const;
-  MatExpr mul(const MatExpr &e, double scale = 1) const;
-  MatExpr mul(const Mat &m, double scale = 1) const;
-
-  Mat cross(const Mat &m) const;
-  double dot(const Mat &m) const;
-
-  void swap(MatExpr &b);
-
-  const MatOp *op;
-  int flags;
-
-  Mat a, b, c;
-  double alpha, beta;
-  Scalar s;
-};
-
-//! @} core_basic
-
-//! @relates cv::MatExpr
-//! @{
-CV_EXPORTS MatExpr operator+(const Mat &a, const Mat &b);
-CV_EXPORTS MatExpr operator+(const Mat &a, const Scalar &s);
-CV_EXPORTS MatExpr operator+(const Scalar &s, const Mat &a);
-CV_EXPORTS MatExpr operator+(const MatExpr &e, const Mat &m);
-CV_EXPORTS MatExpr operator+(const Mat &m, const MatExpr &e);
-CV_EXPORTS MatExpr operator+(const MatExpr &e, const Scalar &s);
-CV_EXPORTS MatExpr operator+(const Scalar &s, const MatExpr &e);
-CV_EXPORTS MatExpr operator+(const MatExpr &e1, const MatExpr &e2);
-template <typename _Tp, int m, int n>
-static inline MatExpr operator+(const Mat &a, const Matx<_Tp, m, n> &b) {
-  return a + Mat(b);
-}
-template <typename _Tp, int m, int n>
-static inline MatExpr operator+(const Matx<_Tp, m, n> &a, const Mat &b) {
-  return Mat(a) + b;
-}
-
-CV_EXPORTS MatExpr operator-(const Mat &a, const Mat &b);
-CV_EXPORTS MatExpr operator-(const Mat &a, const Scalar &s);
-CV_EXPORTS MatExpr operator-(const Scalar &s, const Mat &a);
-CV_EXPORTS MatExpr operator-(const MatExpr &e, const Mat &m);
-CV_EXPORTS MatExpr operator-(const Mat &m, const MatExpr &e);
-CV_EXPORTS MatExpr operator-(const MatExpr &e, const Scalar &s);
-CV_EXPORTS MatExpr operator-(const Scalar &s, const MatExpr &e);
-CV_EXPORTS MatExpr operator-(const MatExpr &e1, const MatExpr &e2);
-template <typename _Tp, int m, int n>
-static inline MatExpr operator-(const Mat &a, const Matx<_Tp, m, n> &b) {
-  return a - Mat(b);
-}
-template <typename _Tp, int m, int n>
-static inline MatExpr operator-(const Matx<_Tp, m, n> &a, const Mat &b) {
-  return Mat(a) - b;
-}
-
-CV_EXPORTS MatExpr operator-(const Mat &m);
-CV_EXPORTS MatExpr operator-(const MatExpr &e);
-
-CV_EXPORTS MatExpr operator*(const Mat &a, const Mat &b);
-CV_EXPORTS MatExpr operator*(const Mat &a, double s);
-CV_EXPORTS MatExpr operator*(double s, const Mat &a);
-CV_EXPORTS MatExpr operator*(const MatExpr &e, const Mat &m);
-CV_EXPORTS MatExpr operator*(const Mat &m, const MatExpr &e);
-CV_EXPORTS MatExpr operator*(const MatExpr &e, double s);
-CV_EXPORTS MatExpr operator*(double s, const MatExpr &e);
-CV_EXPORTS MatExpr operator*(const MatExpr &e1, const MatExpr &e2);
-template <typename _Tp, int m, int n>
-static inline MatExpr operator*(const Mat &a, const Matx<_Tp, m, n> &b) {
-  return a * Mat(b);
-}
-template <typename _Tp, int m, int n>
-static inline MatExpr operator*(const Matx<_Tp, m, n> &a, const Mat &b) {
-  return Mat(a) * b;
-}
-
-CV_EXPORTS MatExpr operator/(const Mat &a, const Mat &b);
-CV_EXPORTS MatExpr operator/(const Mat &a, double s);
-CV_EXPORTS MatExpr operator/(double s, const Mat &a);
-CV_EXPORTS MatExpr operator/(const MatExpr &e, const Mat &m);
-CV_EXPORTS MatExpr operator/(const Mat &m, const MatExpr &e);
-CV_EXPORTS MatExpr operator/(const MatExpr &e, double s);
-CV_EXPORTS MatExpr operator/(double s, const MatExpr &e);
-CV_EXPORTS MatExpr operator/(const MatExpr &e1, const MatExpr &e2);
-template <typename _Tp, int m, int n>
-static inline MatExpr operator/(const Mat &a, const Matx<_Tp, m, n> &b) {
-  return a / Mat(b);
-}
-template <typename _Tp, int m, int n>
-static inline MatExpr operator/(const Matx<_Tp, m, n> &a, const Mat &b) {
-  return Mat(a) / b;
-}
-
-CV_EXPORTS MatExpr operator<(const Mat &a, const Mat &b);
-CV_EXPORTS MatExpr operator<(const Mat &a, double s);
-CV_EXPORTS MatExpr operator<(double s, const Mat &a);
-template <typename _Tp, int m, int n>
-static inline MatExpr operator<(const Mat &a, const Matx<_Tp, m, n> &b) {
-  return a < Mat(b);
-}
-template <typename _Tp, int m, int n>
-static inline MatExpr operator<(const Matx<_Tp, m, n> &a, const Mat &b) {
-  return Mat(a) < b;
-}
-
-CV_EXPORTS MatExpr operator<=(const Mat &a, const Mat &b);
-CV_EXPORTS MatExpr operator<=(const Mat &a, double s);
-CV_EXPORTS MatExpr operator<=(double s, const Mat &a);
-template <typename _Tp, int m, int n>
-static inline MatExpr operator<=(const Mat &a, const Matx<_Tp, m, n> &b) {
-  return a <= Mat(b);
-}
-template <typename _Tp, int m, int n>
-static inline MatExpr operator<=(const Matx<_Tp, m, n> &a, const Mat &b) {
-  return Mat(a) <= b;
-}
-
-CV_EXPORTS MatExpr operator==(const Mat &a, const Mat &b);
-CV_EXPORTS MatExpr operator==(const Mat &a, double s);
-CV_EXPORTS MatExpr operator==(double s, const Mat &a);
-template <typename _Tp, int m, int n>
-static inline MatExpr operator==(const Mat &a, const Matx<_Tp, m, n> &b) {
-  return a == Mat(b);
-}
-template <typename _Tp, int m, int n>
-static inline MatExpr operator==(const Matx<_Tp, m, n> &a, const Mat &b) {
-  return Mat(a) == b;
-}
-
-CV_EXPORTS MatExpr operator!=(const Mat &a, const Mat &b);
-CV_EXPORTS MatExpr operator!=(const Mat &a, double s);
-CV_EXPORTS MatExpr operator!=(double s, const Mat &a);
-template <typename _Tp, int m, int n>
-static inline MatExpr operator!=(const Mat &a, const Matx<_Tp, m, n> &b) {
-  return a != Mat(b);
-}
-template <typename _Tp, int m, int n>
-static inline MatExpr operator!=(const Matx<_Tp, m, n> &a, const Mat &b) {
-  return Mat(a) != b;
-}
-
-CV_EXPORTS MatExpr operator>=(const Mat &a, const Mat &b);
-CV_EXPORTS MatExpr operator>=(const Mat &a, double s);
-CV_EXPORTS MatExpr operator>=(double s, const Mat &a);
-template <typename _Tp, int m, int n>
-static inline MatExpr operator>=(const Mat &a, const Matx<_Tp, m, n> &b) {
-  return a >= Mat(b);
-}
-template <typename _Tp, int m, int n>
-static inline MatExpr operator>=(const Matx<_Tp, m, n> &a, const Mat &b) {
-  return Mat(a) >= b;
-}
-
-CV_EXPORTS MatExpr operator>(const Mat &a, const Mat &b);
-CV_EXPORTS MatExpr operator>(const Mat &a, double s);
-CV_EXPORTS MatExpr operator>(double s, const Mat &a);
-template <typename _Tp, int m, int n>
-static inline MatExpr operator>(const Mat &a, const Matx<_Tp, m, n> &b) {
-  return a > Mat(b);
-}
-template <typename _Tp, int m, int n>
-static inline MatExpr operator>(const Matx<_Tp, m, n> &a, const Mat &b) {
-  return Mat(a) > b;
-}
-
-CV_EXPORTS MatExpr operator&(const Mat &a, const Mat &b);
-CV_EXPORTS MatExpr operator&(const Mat &a, const Scalar &s);
-CV_EXPORTS MatExpr operator&(const Scalar &s, const Mat &a);
-template <typename _Tp, int m, int n>
-static inline MatExpr operator&(const Mat &a, const Matx<_Tp, m, n> &b) {
-  return a & Mat(b);
-}
-template <typename _Tp, int m, int n>
-static inline MatExpr operator&(const Matx<_Tp, m, n> &a, const Mat &b) {
-  return Mat(a) & b;
-}
-
-CV_EXPORTS MatExpr operator|(const Mat &a, const Mat &b);
-CV_EXPORTS MatExpr operator|(const Mat &a, const Scalar &s);
-CV_EXPORTS MatExpr operator|(const Scalar &s, const Mat &a);
-template <typename _Tp, int m, int n>
-static inline MatExpr operator|(const Mat &a, const Matx<_Tp, m, n> &b) {
-  return a | Mat(b);
-}
-template <typename _Tp, int m, int n>
-static inline MatExpr operator|(const Matx<_Tp, m, n> &a, const Mat &b) {
-  return Mat(a) | b;
-}
-
-CV_EXPORTS MatExpr operator^(const Mat &a, const Mat &b);
-CV_EXPORTS MatExpr operator^(const Mat &a, const Scalar &s);
-CV_EXPORTS MatExpr operator^(const Scalar &s, const Mat &a);
-template <typename _Tp, int m, int n>
-static inline MatExpr operator^(const Mat &a, const Matx<_Tp, m, n> &b) {
-  return a ^ Mat(b);
-}
-template <typename _Tp, int m, int n>
-static inline MatExpr operator^(const Matx<_Tp, m, n> &a, const Mat &b) {
-  return Mat(a) ^ b;
-}
-
-CV_EXPORTS MatExpr operator~(const Mat &m);
-
-CV_EXPORTS MatExpr min(const Mat &a, const Mat &b);
-CV_EXPORTS MatExpr min(const Mat &a, double s);
-CV_EXPORTS MatExpr min(double s, const Mat &a);
-template <typename _Tp, int m, int n>
-static inline MatExpr min(const Mat &a, const Matx<_Tp, m, n> &b) {
-  return min(a, Mat(b));
-}
-template <typename _Tp, int m, int n>
-static inline MatExpr min(const Matx<_Tp, m, n> &a, const Mat &b) {
-  return min(Mat(a), b);
-}
-
-CV_EXPORTS MatExpr max(const Mat &a, const Mat &b);
-CV_EXPORTS MatExpr max(const Mat &a, double s);
-CV_EXPORTS MatExpr max(double s, const Mat &a);
-template <typename _Tp, int m, int n>
-static inline MatExpr max(const Mat &a, const Matx<_Tp, m, n> &b) {
-  return max(a, Mat(b));
-}
-template <typename _Tp, int m, int n>
-static inline MatExpr max(const Matx<_Tp, m, n> &a, const Mat &b) {
-  return max(Mat(a), b);
-}
-
-/** @brief Calculates an absolute value of each matrix element.
-
-abs is a meta-function that is expanded to one of absdiff or convertScaleAbs
-forms:
-- C = abs(A-B) is equivalent to `absdiff(A, B, C)`
-- C = abs(A) is equivalent to `absdiff(A, Scalar::all(0), C)`
-- C = `Mat_<Vec<uchar,n> >(abs(A*alpha + beta))` is equivalent to
-`convertScaleAbs(A, C, alpha, beta)`
-
-The output matrix has the same size and the same type as the input one except
-for the last case, where C is depth=CV_8U .
-@param m matrix.
-@sa @ref MatrixExpressions, absdiff, convertScaleAbs
- */
-CV_EXPORTS MatExpr abs(const Mat &m);
-/** @overload
-@param e matrix expression.
-*/
-CV_EXPORTS MatExpr abs(const MatExpr &e);
-//! @} relates cv::MatExpr
-
-} // namespace cv
-
-#include "opencv2/core/mat.inl.hpp"
-
-#endif // OPENCV_CORE_MAT_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/mat.inl.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/mat.inl.hpp
deleted file mode 100644
index 61959fdccb..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/mat.inl.hpp
+++ /dev/null
@@ -1,2753 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Copyright (C) 2015, Itseez Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_CORE_MATRIX_OPERATIONS_HPP
-#define OPENCV_CORE_MATRIX_OPERATIONS_HPP
-
-#ifndef __cplusplus
-#error mat.inl.hpp header must be compiled as C++
-#endif
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4127 5054)
-#endif
-
-#if defined(CV_SKIP_DISABLE_CLANG_ENUM_WARNINGS)
-// nothing
-#elif defined(CV_FORCE_DISABLE_CLANG_ENUM_WARNINGS)
-#define CV_DISABLE_CLANG_ENUM_WARNINGS
-#elif defined(__clang__) && defined(__has_warning)
-#if __has_warning("-Wdeprecated-enum-enum-conversion") &&                      \
-    __has_warning("-Wdeprecated-anon-enum-enum-conversion")
-#define CV_DISABLE_CLANG_ENUM_WARNINGS
-#endif
-#endif
-#ifdef CV_DISABLE_CLANG_ENUM_WARNINGS
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-enum-enum-conversion"
-#pragma clang diagnostic ignored "-Wdeprecated-anon-enum-enum-conversion"
-#endif
-
-namespace cv {
-CV__DEBUG_NS_BEGIN
-
-//! @cond IGNORED
-
-////////////////////////// Custom (raw) type wrapper //////////////////////////
-
-template <typename _Tp> static inline int rawType() {
-  CV_StaticAssert(sizeof(_Tp) <= CV_CN_MAX, "sizeof(_Tp) is too large");
-  const int elemSize = sizeof(_Tp);
-  return (int)CV_MAKETYPE(CV_8U, elemSize);
-}
-
-//////////////////////// Input/Output Arrays ////////////////////////
-
-inline void _InputArray::init(int _flags, const void *_obj) {
-  flags = _flags;
-  obj = (void *)_obj;
-}
-
-inline void _InputArray::init(int _flags, const void *_obj, Size _sz) {
-  flags = _flags;
-  obj = (void *)_obj;
-  sz = _sz;
-}
-
-inline void *_InputArray::getObj() const { return obj; }
-inline int _InputArray::getFlags() const { return flags; }
-inline Size _InputArray::getSz() const { return sz; }
-
-inline _InputArray::_InputArray() { init(0 + NONE, 0); }
-inline _InputArray::_InputArray(int _flags, void *_obj) { init(_flags, _obj); }
-inline _InputArray::_InputArray(const Mat &m) { init(+MAT + ACCESS_READ, &m); }
-inline _InputArray::_InputArray(const std::vector<Mat> &vec) {
-  init(+STD_VECTOR_MAT + ACCESS_READ, &vec);
-}
-
-template <typename _Tp>
-inline _InputArray::_InputArray(const std::vector<_Tp> &vec) {
-  init(FIXED_TYPE + STD_VECTOR + traits::Type<_Tp>::value + ACCESS_READ, &vec);
-}
-
-template <typename _Tp, std::size_t _Nm>
-inline _InputArray::_InputArray(const std::array<_Tp, _Nm> &arr) {
-  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_READ,
-       arr.data(), Size(1, _Nm));
-}
-
-template <std::size_t _Nm>
-inline _InputArray::_InputArray(const std::array<Mat, _Nm> &arr) {
-  init(+STD_ARRAY_MAT + ACCESS_READ, arr.data(), Size(1, _Nm));
-}
-
-inline _InputArray::_InputArray(const std::vector<bool> &vec) {
-  init(FIXED_TYPE + STD_BOOL_VECTOR + traits::Type<bool>::value + ACCESS_READ,
-       &vec);
-}
-
-template <typename _Tp>
-inline _InputArray::_InputArray(const std::vector<std::vector<_Tp>> &vec) {
-  init(FIXED_TYPE + STD_VECTOR_VECTOR + traits::Type<_Tp>::value + ACCESS_READ,
-       &vec);
-}
-
-template <typename _Tp>
-inline _InputArray::_InputArray(const std::vector<Mat_<_Tp>> &vec) {
-  init(FIXED_TYPE + STD_VECTOR_MAT + traits::Type<_Tp>::value + ACCESS_READ,
-       &vec);
-}
-
-template <typename _Tp, int m, int n>
-inline _InputArray::_InputArray(const Matx<_Tp, m, n> &mtx) {
-  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_READ,
-       &mtx, Size(n, m));
-}
-
-template <typename _Tp> inline _InputArray::_InputArray(const _Tp *vec, int n) {
-  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_READ,
-       vec, Size(n, 1));
-}
-
-template <typename _Tp> inline _InputArray::_InputArray(const Mat_<_Tp> &m) {
-  init(FIXED_TYPE + MAT + traits::Type<_Tp>::value + ACCESS_READ, &m);
-}
-
-inline _InputArray::_InputArray(const double &val) {
-  init(FIXED_TYPE + FIXED_SIZE + MATX + CV_64F + ACCESS_READ, &val, Size(1, 1));
-}
-
-template <typename _Tp>
-inline _InputArray _InputArray::rawIn(const std::vector<_Tp> &vec) {
-  _InputArray v;
-  v.flags = _InputArray::FIXED_TYPE + _InputArray::STD_VECTOR + rawType<_Tp>() +
-            ACCESS_READ;
-  v.obj = (void *)&vec;
-  return v;
-}
-
-template <typename _Tp, std::size_t _Nm>
-inline _InputArray _InputArray::rawIn(const std::array<_Tp, _Nm> &arr) {
-  _InputArray v;
-  v.flags =
-      FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_READ;
-  v.obj = (void *)arr.data();
-  v.sz = Size(1, _Nm);
-  return v;
-}
-
-inline _InputArray::~_InputArray() {}
-
-inline Mat _InputArray::getMat(int i) const {
-  if (kind() == MAT && i < 0)
-    return *(const Mat *)obj;
-  return getMat_(i);
-}
-
-inline bool _InputArray::isMat() const { return kind() == _InputArray::MAT; }
-inline bool _InputArray::isMatVector() const {
-  return kind() == _InputArray::STD_VECTOR_MAT;
-}
-inline bool _InputArray::isMatx() const { return kind() == _InputArray::MATX; }
-inline bool _InputArray::isVector() const {
-  return kind() == _InputArray::STD_VECTOR ||
-         kind() == _InputArray::STD_BOOL_VECTOR ||
-         (kind() == _InputArray::MATX && (sz.width <= 1 || sz.height <= 1));
-}
-
-////////////////////////////////////////////////////////////////////////////////////////
-
-inline _OutputArray::_OutputArray() { init(+NONE + ACCESS_WRITE, 0); }
-inline _OutputArray::_OutputArray(int _flags, void *_obj) {
-  init(_flags + ACCESS_WRITE, _obj);
-}
-inline _OutputArray::_OutputArray(Mat &m) { init(+MAT + ACCESS_WRITE, &m); }
-inline _OutputArray::_OutputArray(std::vector<Mat> &vec) {
-  init(+STD_VECTOR_MAT + ACCESS_WRITE, &vec);
-}
-
-template <typename _Tp>
-inline _OutputArray::_OutputArray(std::vector<_Tp> &vec) {
-  init(FIXED_TYPE + STD_VECTOR + traits::Type<_Tp>::value + ACCESS_WRITE, &vec);
-}
-
-template <typename _Tp, std::size_t _Nm>
-inline _OutputArray::_OutputArray(std::array<_Tp, _Nm> &arr) {
-  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_WRITE,
-       arr.data(), Size(1, _Nm));
-}
-
-template <std::size_t _Nm>
-inline _OutputArray::_OutputArray(std::array<Mat, _Nm> &arr) {
-  init(+STD_ARRAY_MAT + ACCESS_WRITE, arr.data(), Size(1, _Nm));
-}
-
-template <typename _Tp>
-inline _OutputArray::_OutputArray(std::vector<std::vector<_Tp>> &vec) {
-  init(FIXED_TYPE + STD_VECTOR_VECTOR + traits::Type<_Tp>::value + ACCESS_WRITE,
-       &vec);
-}
-
-template <typename _Tp>
-inline _OutputArray::_OutputArray(std::vector<Mat_<_Tp>> &vec) {
-  init(FIXED_TYPE + STD_VECTOR_MAT + traits::Type<_Tp>::value + ACCESS_WRITE,
-       &vec);
-}
-
-template <typename _Tp> inline _OutputArray::_OutputArray(Mat_<_Tp> &m) {
-  init(FIXED_TYPE + MAT + traits::Type<_Tp>::value + ACCESS_WRITE, &m);
-}
-
-template <typename _Tp, int m, int n>
-inline _OutputArray::_OutputArray(Matx<_Tp, m, n> &mtx) {
-  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_WRITE,
-       &mtx, Size(n, m));
-}
-
-template <typename _Tp> inline _OutputArray::_OutputArray(_Tp *vec, int n) {
-  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_WRITE,
-       vec, Size(n, 1));
-}
-
-template <typename _Tp>
-inline _OutputArray::_OutputArray(const std::vector<_Tp> &vec) {
-  init(FIXED_TYPE + FIXED_SIZE + STD_VECTOR + traits::Type<_Tp>::value +
-           ACCESS_WRITE,
-       &vec);
-}
-
-template <typename _Tp, std::size_t _Nm>
-inline _OutputArray::_OutputArray(const std::array<_Tp, _Nm> &arr) {
-  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_WRITE,
-       arr.data(), Size(1, _Nm));
-}
-
-template <std::size_t _Nm>
-inline _OutputArray::_OutputArray(const std::array<Mat, _Nm> &arr) {
-  init(FIXED_SIZE + STD_ARRAY_MAT + ACCESS_WRITE, arr.data(), Size(1, _Nm));
-}
-
-template <typename _Tp>
-inline _OutputArray::_OutputArray(const std::vector<std::vector<_Tp>> &vec) {
-  init(FIXED_TYPE + FIXED_SIZE + STD_VECTOR_VECTOR + traits::Type<_Tp>::value +
-           ACCESS_WRITE,
-       &vec);
-}
-
-template <typename _Tp>
-inline _OutputArray::_OutputArray(const std::vector<Mat_<_Tp>> &vec) {
-  init(FIXED_TYPE + FIXED_SIZE + STD_VECTOR_MAT + traits::Type<_Tp>::value +
-           ACCESS_WRITE,
-       &vec);
-}
-
-template <typename _Tp> inline _OutputArray::_OutputArray(const Mat_<_Tp> &m) {
-  init(FIXED_TYPE + FIXED_SIZE + MAT + traits::Type<_Tp>::value + ACCESS_WRITE,
-       &m);
-}
-
-template <typename _Tp, int m, int n>
-inline _OutputArray::_OutputArray(const Matx<_Tp, m, n> &mtx) {
-  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_WRITE,
-       &mtx, Size(n, m));
-}
-
-template <typename _Tp>
-inline _OutputArray::_OutputArray(const _Tp *vec, int n) {
-  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_WRITE,
-       vec, Size(n, 1));
-}
-
-inline _OutputArray::_OutputArray(const Mat &m) {
-  init(FIXED_TYPE + FIXED_SIZE + MAT + ACCESS_WRITE, &m);
-}
-
-inline _OutputArray::_OutputArray(const std::vector<Mat> &vec) {
-  init(FIXED_SIZE + STD_VECTOR_MAT + ACCESS_WRITE, &vec);
-}
-
-template <typename _Tp>
-inline _OutputArray _OutputArray::rawOut(std::vector<_Tp> &vec) {
-  _OutputArray v;
-  v.flags = _InputArray::FIXED_TYPE + _InputArray::STD_VECTOR + rawType<_Tp>() +
-            ACCESS_WRITE;
-  v.obj = (void *)&vec;
-  return v;
-}
-
-template <typename _Tp, std::size_t _Nm>
-inline _OutputArray _OutputArray::rawOut(std::array<_Tp, _Nm> &arr) {
-  _OutputArray v;
-  v.flags =
-      FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_WRITE;
-  v.obj = (void *)arr.data();
-  v.sz = Size(1, _Nm);
-  return v;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////
-
-inline _InputOutputArray::_InputOutputArray() { init(0 + ACCESS_RW, 0); }
-inline _InputOutputArray::_InputOutputArray(int _flags, void *_obj) {
-  init(_flags + ACCESS_RW, _obj);
-}
-inline _InputOutputArray::_InputOutputArray(Mat &m) {
-  init(+MAT + ACCESS_RW, &m);
-}
-inline _InputOutputArray::_InputOutputArray(std::vector<Mat> &vec) {
-  init(+STD_VECTOR_MAT + ACCESS_RW, &vec);
-}
-
-template <typename _Tp>
-inline _InputOutputArray::_InputOutputArray(std::vector<_Tp> &vec) {
-  init(FIXED_TYPE + STD_VECTOR + traits::Type<_Tp>::value + ACCESS_RW, &vec);
-}
-
-template <typename _Tp, std::size_t _Nm>
-inline _InputOutputArray::_InputOutputArray(std::array<_Tp, _Nm> &arr) {
-  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_RW,
-       arr.data(), Size(1, _Nm));
-}
-
-template <std::size_t _Nm>
-inline _InputOutputArray::_InputOutputArray(std::array<Mat, _Nm> &arr) {
-  init(+STD_ARRAY_MAT + ACCESS_RW, arr.data(), Size(1, _Nm));
-}
-
-template <typename _Tp>
-inline _InputOutputArray::_InputOutputArray(
-    std::vector<std::vector<_Tp>> &vec) {
-  init(FIXED_TYPE + STD_VECTOR_VECTOR + traits::Type<_Tp>::value + ACCESS_RW,
-       &vec);
-}
-
-template <typename _Tp>
-inline _InputOutputArray::_InputOutputArray(std::vector<Mat_<_Tp>> &vec) {
-  init(FIXED_TYPE + STD_VECTOR_MAT + traits::Type<_Tp>::value + ACCESS_RW,
-       &vec);
-}
-
-template <typename _Tp>
-inline _InputOutputArray::_InputOutputArray(Mat_<_Tp> &m) {
-  init(FIXED_TYPE + MAT + traits::Type<_Tp>::value + ACCESS_RW, &m);
-}
-
-template <typename _Tp, int m, int n>
-inline _InputOutputArray::_InputOutputArray(Matx<_Tp, m, n> &mtx) {
-  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_RW,
-       &mtx, Size(n, m));
-}
-
-template <typename _Tp>
-inline _InputOutputArray::_InputOutputArray(_Tp *vec, int n) {
-  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_RW,
-       vec, Size(n, 1));
-}
-
-template <typename _Tp>
-inline _InputOutputArray::_InputOutputArray(const std::vector<_Tp> &vec) {
-  init(FIXED_TYPE + FIXED_SIZE + STD_VECTOR + traits::Type<_Tp>::value +
-           ACCESS_RW,
-       &vec);
-}
-
-template <typename _Tp, std::size_t _Nm>
-inline _InputOutputArray::_InputOutputArray(const std::array<_Tp, _Nm> &arr) {
-  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_RW,
-       arr.data(), Size(1, _Nm));
-}
-
-template <std::size_t _Nm>
-inline _InputOutputArray::_InputOutputArray(const std::array<Mat, _Nm> &arr) {
-  init(FIXED_SIZE + STD_ARRAY_MAT + ACCESS_RW, arr.data(), Size(1, _Nm));
-}
-
-template <typename _Tp>
-inline _InputOutputArray::_InputOutputArray(
-    const std::vector<std::vector<_Tp>> &vec) {
-  init(FIXED_TYPE + FIXED_SIZE + STD_VECTOR_VECTOR + traits::Type<_Tp>::value +
-           ACCESS_RW,
-       &vec);
-}
-
-template <typename _Tp>
-inline _InputOutputArray::_InputOutputArray(const std::vector<Mat_<_Tp>> &vec) {
-  init(FIXED_TYPE + FIXED_SIZE + STD_VECTOR_MAT + traits::Type<_Tp>::value +
-           ACCESS_RW,
-       &vec);
-}
-
-template <typename _Tp>
-inline _InputOutputArray::_InputOutputArray(const Mat_<_Tp> &m) {
-  init(FIXED_TYPE + FIXED_SIZE + MAT + traits::Type<_Tp>::value + ACCESS_RW,
-       &m);
-}
-
-template <typename _Tp, int m, int n>
-inline _InputOutputArray::_InputOutputArray(const Matx<_Tp, m, n> &mtx) {
-  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_RW,
-       &mtx, Size(n, m));
-}
-
-template <typename _Tp>
-inline _InputOutputArray::_InputOutputArray(const _Tp *vec, int n) {
-  init(FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_RW,
-       vec, Size(n, 1));
-}
-
-inline _InputOutputArray::_InputOutputArray(const Mat &m) {
-  init(FIXED_TYPE + FIXED_SIZE + MAT + ACCESS_RW, &m);
-}
-
-inline _InputOutputArray::_InputOutputArray(const std::vector<Mat> &vec) {
-  init(FIXED_SIZE + STD_VECTOR_MAT + ACCESS_RW, &vec);
-}
-
-template <typename _Tp>
-inline _InputOutputArray _InputOutputArray::rawInOut(std::vector<_Tp> &vec) {
-  _InputOutputArray v;
-  v.flags = _InputArray::FIXED_TYPE + _InputArray::STD_VECTOR + rawType<_Tp>() +
-            ACCESS_RW;
-  v.obj = (void *)&vec;
-  return v;
-}
-
-template <typename _Tp, std::size_t _Nm>
-inline _InputOutputArray
-_InputOutputArray::rawInOut(std::array<_Tp, _Nm> &arr) {
-  _InputOutputArray v;
-  v.flags =
-      FIXED_TYPE + FIXED_SIZE + MATX + traits::Type<_Tp>::value + ACCESS_RW;
-  v.obj = (void *)arr.data();
-  v.sz = Size(1, _Nm);
-  return v;
-}
-
-template <typename _Tp> static inline _InputArray rawIn(_Tp &v) {
-  return _InputArray::rawIn(v);
-}
-template <typename _Tp> static inline _OutputArray rawOut(_Tp &v) {
-  return _OutputArray::rawOut(v);
-}
-template <typename _Tp> static inline _InputOutputArray rawInOut(_Tp &v) {
-  return _InputOutputArray::rawInOut(v);
-}
-
-CV__DEBUG_NS_END
-
-//////////////////////////////////////////// Mat
-/////////////////////////////////////////////
-
-template <typename _Tp>
-inline Mat::Mat(const std::vector<_Tp> &vec, bool copyData)
-    : flags(+MAGIC_VAL + traits::Type<_Tp>::value + CV_MAT_CONT_FLAG), dims(2),
-      rows((int)vec.size()), cols(1), data(0), datastart(0), dataend(0),
-      datalimit(0), allocator(0), u(0), size(&rows), step(0) {
-  if (vec.empty())
-    return;
-  if (!copyData) {
-    step[0] = step[1] = sizeof(_Tp);
-    datastart = data = (uchar *)&vec[0];
-    datalimit = dataend = datastart + rows * step[0];
-  } else
-    Mat((int)vec.size(), 1, traits::Type<_Tp>::value, (uchar *)&vec[0])
-        .copyTo(*this);
-}
-
-template <typename _Tp, typename>
-inline Mat::Mat(const std::initializer_list<_Tp> list) : Mat() {
-  CV_Assert(list.size() != 0);
-  Mat((int)list.size(), 1, traits::Type<_Tp>::value, (uchar *)list.begin())
-      .copyTo(*this);
-}
-
-template <typename _Tp>
-inline Mat::Mat(const std::initializer_list<int> sizes,
-                const std::initializer_list<_Tp> list)
-    : Mat() {
-  size_t size_total = 1;
-  for (auto s : sizes)
-    size_total *= s;
-  CV_Assert(list.size() != 0);
-  CV_Assert(size_total == list.size());
-  Mat((int)sizes.size(), (int *)sizes.begin(), traits::Type<_Tp>::value,
-      (uchar *)list.begin())
-      .copyTo(*this);
-}
-
-template <typename _Tp, std::size_t _Nm>
-inline Mat::Mat(const std::array<_Tp, _Nm> &arr, bool copyData)
-    : flags(+MAGIC_VAL + traits::Type<_Tp>::value + CV_MAT_CONT_FLAG), dims(2),
-      rows((int)arr.size()), cols(1), data(0), datastart(0), dataend(0),
-      datalimit(0), allocator(0), u(0), size(&rows), step(0) {
-  if (arr.empty())
-    return;
-  if (!copyData) {
-    step[0] = step[1] = sizeof(_Tp);
-    datastart = data = (uchar *)arr.data();
-    datalimit = dataend = datastart + rows * step[0];
-  } else
-    Mat((int)arr.size(), 1, traits::Type<_Tp>::value, (uchar *)arr.data())
-        .copyTo(*this);
-}
-
-template <typename _Tp, int n>
-inline Mat::Mat(const Vec<_Tp, n> &vec, bool copyData)
-    : flags(+MAGIC_VAL + traits::Type<_Tp>::value + CV_MAT_CONT_FLAG), dims(2),
-      rows(n), cols(1), data(0), datastart(0), dataend(0), datalimit(0),
-      allocator(0), u(0), size(&rows), step(0) {
-  if (!copyData) {
-    step[0] = step[1] = sizeof(_Tp);
-    datastart = data = (uchar *)vec.val;
-    datalimit = dataend = datastart + rows * step[0];
-  } else
-    Mat(n, 1, traits::Type<_Tp>::value, (void *)vec.val).copyTo(*this);
-}
-
-template <typename _Tp, int m, int n>
-inline Mat::Mat(const Matx<_Tp, m, n> &M, bool copyData)
-    : flags(+MAGIC_VAL + traits::Type<_Tp>::value + CV_MAT_CONT_FLAG), dims(2),
-      rows(m), cols(n), data(0), datastart(0), dataend(0), datalimit(0),
-      allocator(0), u(0), size(&rows), step(0) {
-  if (!copyData) {
-    step[0] = cols * sizeof(_Tp);
-    step[1] = sizeof(_Tp);
-    datastart = data = (uchar *)M.val;
-    datalimit = dataend = datastart + rows * step[0];
-  } else
-    Mat(m, n, traits::Type<_Tp>::value, (uchar *)M.val).copyTo(*this);
-}
-
-template <typename _Tp>
-inline Mat::Mat(const Point_<_Tp> &pt, bool copyData)
-    : flags(+MAGIC_VAL + traits::Type<_Tp>::value + CV_MAT_CONT_FLAG), dims(2),
-      rows(2), cols(1), data(0), datastart(0), dataend(0), datalimit(0),
-      allocator(0), u(0), size(&rows), step(0) {
-  if (!copyData) {
-    step[0] = step[1] = sizeof(_Tp);
-    datastart = data = (uchar *)&pt.x;
-    datalimit = dataend = datastart + rows * step[0];
-  } else {
-    create(2, 1, traits::Type<_Tp>::value);
-    ((_Tp *)data)[0] = pt.x;
-    ((_Tp *)data)[1] = pt.y;
-  }
-}
-
-template <typename _Tp>
-inline Mat::Mat(const Point3_<_Tp> &pt, bool copyData)
-    : flags(+MAGIC_VAL + traits::Type<_Tp>::value + CV_MAT_CONT_FLAG), dims(2),
-      rows(3), cols(1), data(0), datastart(0), dataend(0), datalimit(0),
-      allocator(0), u(0), size(&rows), step(0) {
-  if (!copyData) {
-    step[0] = step[1] = sizeof(_Tp);
-    datastart = data = (uchar *)&pt.x;
-    datalimit = dataend = datastart + rows * step[0];
-  } else {
-    create(3, 1, traits::Type<_Tp>::value);
-    ((_Tp *)data)[0] = pt.x;
-    ((_Tp *)data)[1] = pt.y;
-    ((_Tp *)data)[2] = pt.z;
-  }
-}
-
-template <typename _Tp>
-inline Mat::Mat(const MatCommaInitializer_<_Tp> &commaInitializer)
-    : flags(+MAGIC_VAL + traits::Type<_Tp>::value + CV_MAT_CONT_FLAG), dims(0),
-      rows(0), cols(0), data(0), datastart(0), dataend(0), allocator(0), u(0),
-      size(&rows) {
-  *this = commaInitializer.operator Mat_<_Tp>();
-}
-
-inline Mat Mat::row(int y) const {
-  return Mat(*this, Range(y, y + 1), Range::all());
-}
-
-inline Mat Mat::col(int x) const {
-  return Mat(*this, Range::all(), Range(x, x + 1));
-}
-
-inline Mat Mat::rowRange(int startrow, int endrow) const {
-  return Mat(*this, Range(startrow, endrow), Range::all());
-}
-
-inline Mat Mat::rowRange(const Range &r) const {
-  return Mat(*this, r, Range::all());
-}
-
-inline Mat Mat::colRange(int startcol, int endcol) const {
-  return Mat(*this, Range::all(), Range(startcol, endcol));
-}
-
-inline Mat Mat::colRange(const Range &r) const {
-  return Mat(*this, Range::all(), r);
-}
-
-inline Mat Mat::operator()(Range _rowRange, Range _colRange) const {
-  return Mat(*this, _rowRange, _colRange);
-}
-
-inline Mat Mat::operator()(const Rect &roi) const { return Mat(*this, roi); }
-
-inline Mat Mat::operator()(const Range *ranges) const {
-  return Mat(*this, ranges);
-}
-
-inline Mat Mat::operator()(const std::vector<Range> &ranges) const {
-  return Mat(*this, ranges);
-}
-
-inline bool Mat::isContinuous() const { return (flags & CONTINUOUS_FLAG) != 0; }
-
-inline bool Mat::isSubmatrix() const { return (flags & SUBMATRIX_FLAG) != 0; }
-
-inline size_t Mat::elemSize() const {
-  size_t res = dims > 0 ? step.p[dims - 1] : 0;
-  CV_DbgAssert(res != 0);
-  return res;
-}
-
-inline size_t Mat::elemSize1() const { return CV_ELEM_SIZE1(flags); }
-
-inline int Mat::type() const { return CV_MAT_TYPE(flags); }
-
-inline int Mat::depth() const { return CV_MAT_DEPTH(flags); }
-
-inline int Mat::channels() const { return CV_MAT_CN(flags); }
-
-inline uchar *Mat::ptr(int y) {
-  CV_DbgAssert(y == 0 ||
-               (data && dims >= 1 && (unsigned)y < (unsigned)size.p[0]));
-  return data + step.p[0] * y;
-}
-
-inline const uchar *Mat::ptr(int y) const {
-  CV_DbgAssert(y == 0 ||
-               (data && dims >= 1 && (unsigned)y < (unsigned)size.p[0]));
-  return data + step.p[0] * y;
-}
-
-template <typename _Tp> inline _Tp *Mat::ptr(int y) {
-  CV_DbgAssert(y == 0 ||
-               (data && dims >= 1 && (unsigned)y < (unsigned)size.p[0]));
-  return (_Tp *)(data + step.p[0] * y);
-}
-
-template <typename _Tp> inline const _Tp *Mat::ptr(int y) const {
-  CV_DbgAssert(y == 0 ||
-               (data && dims >= 1 && (unsigned)y < (unsigned)size.p[0]));
-  return (const _Tp *)(data + step.p[0] * y);
-}
-
-inline uchar *Mat::ptr(int i0, int i1) {
-  CV_DbgAssert(dims >= 2);
-  CV_DbgAssert(data);
-  CV_DbgAssert((unsigned)i0 < (unsigned)size.p[0]);
-  CV_DbgAssert((unsigned)i1 < (unsigned)size.p[1]);
-  return data + i0 * step.p[0] + i1 * step.p[1];
-}
-
-inline const uchar *Mat::ptr(int i0, int i1) const {
-  CV_DbgAssert(dims >= 2);
-  CV_DbgAssert(data);
-  CV_DbgAssert((unsigned)i0 < (unsigned)size.p[0]);
-  CV_DbgAssert((unsigned)i1 < (unsigned)size.p[1]);
-  return data + i0 * step.p[0] + i1 * step.p[1];
-}
-
-template <typename _Tp> inline _Tp *Mat::ptr(int i0, int i1) {
-  CV_DbgAssert(dims >= 2);
-  CV_DbgAssert(data);
-  CV_DbgAssert((unsigned)i0 < (unsigned)size.p[0]);
-  CV_DbgAssert((unsigned)i1 < (unsigned)size.p[1]);
-  return (_Tp *)(data + i0 * step.p[0] + i1 * step.p[1]);
-}
-
-template <typename _Tp> inline const _Tp *Mat::ptr(int i0, int i1) const {
-  CV_DbgAssert(dims >= 2);
-  CV_DbgAssert(data);
-  CV_DbgAssert((unsigned)i0 < (unsigned)size.p[0]);
-  CV_DbgAssert((unsigned)i1 < (unsigned)size.p[1]);
-  return (const _Tp *)(data + i0 * step.p[0] + i1 * step.p[1]);
-}
-
-inline uchar *Mat::ptr(int i0, int i1, int i2) {
-  CV_DbgAssert(dims >= 3);
-  CV_DbgAssert(data);
-  CV_DbgAssert((unsigned)i0 < (unsigned)size.p[0]);
-  CV_DbgAssert((unsigned)i1 < (unsigned)size.p[1]);
-  CV_DbgAssert((unsigned)i2 < (unsigned)size.p[2]);
-  return data + i0 * step.p[0] + i1 * step.p[1] + i2 * step.p[2];
-}
-
-inline const uchar *Mat::ptr(int i0, int i1, int i2) const {
-  CV_DbgAssert(dims >= 3);
-  CV_DbgAssert(data);
-  CV_DbgAssert((unsigned)i0 < (unsigned)size.p[0]);
-  CV_DbgAssert((unsigned)i1 < (unsigned)size.p[1]);
-  CV_DbgAssert((unsigned)i2 < (unsigned)size.p[2]);
-  return data + i0 * step.p[0] + i1 * step.p[1] + i2 * step.p[2];
-}
-
-template <typename _Tp> inline _Tp *Mat::ptr(int i0, int i1, int i2) {
-  CV_DbgAssert(dims >= 3);
-  CV_DbgAssert(data);
-  CV_DbgAssert((unsigned)i0 < (unsigned)size.p[0]);
-  CV_DbgAssert((unsigned)i1 < (unsigned)size.p[1]);
-  CV_DbgAssert((unsigned)i2 < (unsigned)size.p[2]);
-  return (_Tp *)(data + i0 * step.p[0] + i1 * step.p[1] + i2 * step.p[2]);
-}
-
-template <typename _Tp>
-inline const _Tp *Mat::ptr(int i0, int i1, int i2) const {
-  CV_DbgAssert(dims >= 3);
-  CV_DbgAssert(data);
-  CV_DbgAssert((unsigned)i0 < (unsigned)size.p[0]);
-  CV_DbgAssert((unsigned)i1 < (unsigned)size.p[1]);
-  CV_DbgAssert((unsigned)i2 < (unsigned)size.p[2]);
-  return (const _Tp *)(data + i0 * step.p[0] + i1 * step.p[1] + i2 * step.p[2]);
-}
-
-inline uchar *Mat::ptr(const int *idx) {
-  int i, d = dims;
-  uchar *p = data;
-  CV_DbgAssert(d >= 1 && p);
-  for (i = 0; i < d; i++) {
-    CV_DbgAssert((unsigned)idx[i] < (unsigned)size.p[i]);
-    p += idx[i] * step.p[i];
-  }
-  return p;
-}
-
-inline const uchar *Mat::ptr(const int *idx) const {
-  int i, d = dims;
-  uchar *p = data;
-  CV_DbgAssert(d >= 1 && p);
-  for (i = 0; i < d; i++) {
-    CV_DbgAssert((unsigned)idx[i] < (unsigned)size.p[i]);
-    p += idx[i] * step.p[i];
-  }
-  return p;
-}
-
-template <typename _Tp> inline _Tp *Mat::ptr(const int *idx) {
-  int i, d = dims;
-  uchar *p = data;
-  CV_DbgAssert(d >= 1 && p);
-  for (i = 0; i < d; i++) {
-    CV_DbgAssert((unsigned)idx[i] < (unsigned)size.p[i]);
-    p += idx[i] * step.p[i];
-  }
-  return (_Tp *)p;
-}
-
-template <typename _Tp> inline const _Tp *Mat::ptr(const int *idx) const {
-  int i, d = dims;
-  uchar *p = data;
-  CV_DbgAssert(d >= 1 && p);
-  for (i = 0; i < d; i++) {
-    CV_DbgAssert((unsigned)idx[i] < (unsigned)size.p[i]);
-    p += idx[i] * step.p[i];
-  }
-  return (const _Tp *)p;
-}
-
-template <int n> inline uchar *Mat::ptr(const Vec<int, n> &idx) {
-  return Mat::ptr(idx.val);
-}
-
-template <int n> inline const uchar *Mat::ptr(const Vec<int, n> &idx) const {
-  return Mat::ptr(idx.val);
-}
-
-template <typename _Tp, int n> inline _Tp *Mat::ptr(const Vec<int, n> &idx) {
-  CV_DbgAssert(elemSize() == sizeof(_Tp));
-  return Mat::ptr<_Tp>(idx.val);
-}
-
-template <typename _Tp, int n>
-inline const _Tp *Mat::ptr(const Vec<int, n> &idx) const {
-  CV_DbgAssert(elemSize() == sizeof(_Tp));
-  return Mat::ptr<_Tp>(idx.val);
-}
-
-template <typename _Tp> inline _Tp &Mat::at(int i0, int i1) {
-  CV_DbgAssert(dims <= 2);
-  CV_DbgAssert(data);
-  CV_DbgAssert((unsigned)i0 < (unsigned)size.p[0]);
-  CV_DbgAssert((unsigned)(i1 * DataType<_Tp>::channels) <
-               (unsigned)(size.p[1] * channels()));
-  CV_DbgAssert(CV_ELEM_SIZE1(traits::Depth<_Tp>::value) == elemSize1());
-  return ((_Tp *)(data + step.p[0] * i0))[i1];
-}
-
-template <typename _Tp> inline const _Tp &Mat::at(int i0, int i1) const {
-  CV_DbgAssert(dims <= 2);
-  CV_DbgAssert(data);
-  CV_DbgAssert((unsigned)i0 < (unsigned)size.p[0]);
-  CV_DbgAssert((unsigned)(i1 * DataType<_Tp>::channels) <
-               (unsigned)(size.p[1] * channels()));
-  CV_DbgAssert(CV_ELEM_SIZE1(traits::Depth<_Tp>::value) == elemSize1());
-  return ((const _Tp *)(data + step.p[0] * i0))[i1];
-}
-
-template <typename _Tp> inline _Tp &Mat::at(Point pt) {
-  CV_DbgAssert(dims <= 2);
-  CV_DbgAssert(data);
-  CV_DbgAssert((unsigned)pt.y < (unsigned)size.p[0]);
-  CV_DbgAssert((unsigned)(pt.x * DataType<_Tp>::channels) <
-               (unsigned)(size.p[1] * channels()));
-  CV_DbgAssert(CV_ELEM_SIZE1(traits::Depth<_Tp>::value) == elemSize1());
-  return ((_Tp *)(data + step.p[0] * pt.y))[pt.x];
-}
-
-template <typename _Tp> inline const _Tp &Mat::at(Point pt) const {
-  CV_DbgAssert(dims <= 2);
-  CV_DbgAssert(data);
-  CV_DbgAssert((unsigned)pt.y < (unsigned)size.p[0]);
-  CV_DbgAssert((unsigned)(pt.x * DataType<_Tp>::channels) <
-               (unsigned)(size.p[1] * channels()));
-  CV_DbgAssert(CV_ELEM_SIZE1(traits::Depth<_Tp>::value) == elemSize1());
-  return ((const _Tp *)(data + step.p[0] * pt.y))[pt.x];
-}
-
-template <typename _Tp> inline _Tp &Mat::at(int i0) {
-  CV_DbgAssert(dims <= 2);
-  CV_DbgAssert(data);
-  CV_DbgAssert((unsigned)i0 < (unsigned)(size.p[0] * size.p[1]));
-  CV_DbgAssert(elemSize() == sizeof(_Tp));
-  if (isContinuous() || size.p[0] == 1)
-    return ((_Tp *)data)[i0];
-  if (size.p[1] == 1)
-    return *(_Tp *)(data + step.p[0] * i0);
-  int i = i0 / cols, j = i0 - i * cols;
-  return ((_Tp *)(data + step.p[0] * i))[j];
-}
-
-template <typename _Tp> inline const _Tp &Mat::at(int i0) const {
-  CV_DbgAssert(dims <= 2);
-  CV_DbgAssert(data);
-  CV_DbgAssert((unsigned)i0 < (unsigned)(size.p[0] * size.p[1]));
-  CV_DbgAssert(elemSize() == sizeof(_Tp));
-  if (isContinuous() || size.p[0] == 1)
-    return ((const _Tp *)data)[i0];
-  if (size.p[1] == 1)
-    return *(const _Tp *)(data + step.p[0] * i0);
-  int i = i0 / cols, j = i0 - i * cols;
-  return ((const _Tp *)(data + step.p[0] * i))[j];
-}
-
-template <typename _Tp> inline _Tp &Mat::at(int i0, int i1, int i2) {
-  CV_DbgAssert(elemSize() == sizeof(_Tp));
-  return *(_Tp *)ptr(i0, i1, i2);
-}
-
-template <typename _Tp>
-inline const _Tp &Mat::at(int i0, int i1, int i2) const {
-  CV_DbgAssert(elemSize() == sizeof(_Tp));
-  return *(const _Tp *)ptr(i0, i1, i2);
-}
-
-template <typename _Tp> inline _Tp &Mat::at(const int *idx) {
-  CV_DbgAssert(elemSize() == sizeof(_Tp));
-  return *(_Tp *)ptr(idx);
-}
-
-template <typename _Tp> inline const _Tp &Mat::at(const int *idx) const {
-  CV_DbgAssert(elemSize() == sizeof(_Tp));
-  return *(const _Tp *)ptr(idx);
-}
-
-template <typename _Tp, int n> inline _Tp &Mat::at(const Vec<int, n> &idx) {
-  CV_DbgAssert(elemSize() == sizeof(_Tp));
-  return *(_Tp *)ptr(idx.val);
-}
-
-template <typename _Tp, int n>
-inline const _Tp &Mat::at(const Vec<int, n> &idx) const {
-  CV_DbgAssert(elemSize() == sizeof(_Tp));
-  return *(const _Tp *)ptr(idx.val);
-}
-
-template <typename _Tp> inline MatConstIterator_<_Tp> Mat::begin() const {
-  if (empty())
-    return MatConstIterator_<_Tp>();
-  CV_DbgAssert(elemSize() == sizeof(_Tp));
-  return MatConstIterator_<_Tp>((const Mat_<_Tp> *)this);
-}
-
-template <typename _Tp>
-inline std::reverse_iterator<MatConstIterator_<_Tp>> Mat::rbegin() const {
-  if (empty())
-    return std::reverse_iterator<MatConstIterator_<_Tp>>();
-  CV_DbgAssert(elemSize() == sizeof(_Tp));
-  MatConstIterator_<_Tp> it((const Mat_<_Tp> *)this);
-  it += total();
-  return std::reverse_iterator<MatConstIterator_<_Tp>>(it);
-}
-
-template <typename _Tp> inline MatConstIterator_<_Tp> Mat::end() const {
-  if (empty())
-    return MatConstIterator_<_Tp>();
-  CV_DbgAssert(elemSize() == sizeof(_Tp));
-  MatConstIterator_<_Tp> it((const Mat_<_Tp> *)this);
-  it += total();
-  return it;
-}
-
-template <typename _Tp>
-inline std::reverse_iterator<MatConstIterator_<_Tp>> Mat::rend() const {
-  if (empty())
-    return std::reverse_iterator<MatConstIterator_<_Tp>>();
-  CV_DbgAssert(elemSize() == sizeof(_Tp));
-  return std::reverse_iterator<MatConstIterator_<_Tp>>((const Mat_<_Tp> *)this);
-}
-
-template <typename _Tp> inline MatIterator_<_Tp> Mat::begin() {
-  if (empty())
-    return MatIterator_<_Tp>();
-  CV_DbgAssert(elemSize() == sizeof(_Tp));
-  return MatIterator_<_Tp>((Mat_<_Tp> *)this);
-}
-
-template <typename _Tp>
-inline std::reverse_iterator<MatIterator_<_Tp>> Mat::rbegin() {
-  if (empty())
-    return std::reverse_iterator<MatIterator_<_Tp>>();
-  CV_DbgAssert(elemSize() == sizeof(_Tp));
-  MatIterator_<_Tp> it((Mat_<_Tp> *)this);
-  it += total();
-  return std::reverse_iterator<MatIterator_<_Tp>>(it);
-}
-
-template <typename _Tp> inline MatIterator_<_Tp> Mat::end() {
-  if (empty())
-    return MatIterator_<_Tp>();
-  CV_DbgAssert(elemSize() == sizeof(_Tp));
-  MatIterator_<_Tp> it((Mat_<_Tp> *)this);
-  it += total();
-  return it;
-}
-
-template <typename _Tp>
-inline std::reverse_iterator<MatIterator_<_Tp>> Mat::rend() {
-  if (empty())
-    return std::reverse_iterator<MatIterator_<_Tp>>();
-  CV_DbgAssert(elemSize() == sizeof(_Tp));
-  return std::reverse_iterator<MatIterator_<_Tp>>(
-      MatIterator_<_Tp>((Mat_<_Tp> *)this));
-}
-
-template <typename _Tp, typename Functor>
-inline void Mat::forEach(const Functor &operation) {
-  this->forEach_impl<_Tp>(operation);
-}
-
-template <typename _Tp, typename Functor>
-inline void Mat::forEach(const Functor &operation) const {
-  // call as not const
-  (const_cast<Mat *>(this))->forEach<_Tp>(operation);
-}
-
-template <typename _Tp> inline Mat::operator std::vector<_Tp>() const {
-  std::vector<_Tp> v;
-  copyTo(v);
-  return v;
-}
-
-template <typename _Tp, std::size_t _Nm>
-inline Mat::operator std::array<_Tp, _Nm>() const {
-  std::array<_Tp, _Nm> v;
-  copyTo(v);
-  return v;
-}
-
-template <typename _Tp, int n> inline Mat::operator Vec<_Tp, n>() const {
-  CV_Assert(data && dims <= 2 && (rows == 1 || cols == 1) &&
-            rows + cols - 1 == n && channels() == 1);
-
-  if (isContinuous() && type() == traits::Type<_Tp>::value)
-    return Vec<_Tp, n>((_Tp *)data);
-  Vec<_Tp, n> v;
-  Mat tmp(rows, cols, traits::Type<_Tp>::value, v.val);
-  convertTo(tmp, tmp.type());
-  return v;
-}
-
-template <typename _Tp, int m, int n>
-inline Mat::operator Matx<_Tp, m, n>() const {
-  CV_Assert(data && dims <= 2 && rows == m && cols == n && channels() == 1);
-
-  if (isContinuous() && type() == traits::Type<_Tp>::value)
-    return Matx<_Tp, m, n>((_Tp *)data);
-  Matx<_Tp, m, n> mtx;
-  Mat tmp(rows, cols, traits::Type<_Tp>::value, mtx.val);
-  convertTo(tmp, tmp.type());
-  return mtx;
-}
-
-template <typename _Tp> inline void Mat::push_back(const _Tp &elem) {
-  if (!data) {
-    *this = Mat(1, 1, traits::Type<_Tp>::value, (void *)&elem).clone();
-    return;
-  }
-  CV_Assert(traits::Type<_Tp>::value == type() && cols == 1
-            /* && dims == 2 (cols == 1 implies dims == 2) */);
-  const uchar *tmp = dataend + step[0];
-  if (!isSubmatrix() && isContinuous() && tmp <= datalimit) {
-    *(_Tp *)(data + (size.p[0]++) * step.p[0]) = elem;
-    dataend = tmp;
-  } else
-    push_back_(&elem);
-}
-
-template <typename _Tp> inline void Mat::push_back(const Mat_<_Tp> &m) {
-  push_back((const Mat &)m);
-}
-
-template <> inline void Mat::push_back(const MatExpr &expr) {
-  push_back(static_cast<Mat>(expr));
-}
-
-template <typename _Tp> inline void Mat::push_back(const std::vector<_Tp> &v) {
-  push_back(Mat(v));
-}
-
-///////////////////////////// MatSize ////////////////////////////
-
-inline MatSize::MatSize(int *_p) CV_NOEXCEPT : p(_p) {}
-
-inline int MatSize::dims() const CV_NOEXCEPT { return (p - 1)[0]; }
-
-inline Size MatSize::operator()() const {
-  CV_DbgAssert(dims() <= 2);
-  return Size(p[1], p[0]);
-}
-
-inline const int &MatSize::operator[](int i) const {
-  CV_DbgAssert(i < dims());
-#ifdef __OPENCV_BUILD
-  CV_DbgAssert(i >= 0);
-#endif
-  return p[i];
-}
-
-inline int &MatSize::operator[](int i) {
-  CV_DbgAssert(i < dims());
-#ifdef __OPENCV_BUILD
-  CV_DbgAssert(i >= 0);
-#endif
-  return p[i];
-}
-
-inline MatSize::operator const int *() const CV_NOEXCEPT { return p; }
-
-inline bool MatSize::operator!=(const MatSize &sz) const CV_NOEXCEPT {
-  return !(*this == sz);
-}
-
-///////////////////////////// MatStep ////////////////////////////
-
-inline MatStep::MatStep() CV_NOEXCEPT {
-  p = buf;
-  p[0] = p[1] = 0;
-}
-
-inline MatStep::MatStep(size_t s) CV_NOEXCEPT {
-  p = buf;
-  p[0] = s;
-  p[1] = 0;
-}
-
-inline const size_t &MatStep::operator[](int i) const CV_NOEXCEPT {
-  return p[i];
-}
-
-inline size_t &MatStep::operator[](int i) CV_NOEXCEPT { return p[i]; }
-
-inline MatStep::operator size_t() const {
-  CV_DbgAssert(p == buf);
-  return buf[0];
-}
-
-inline MatStep &MatStep::operator=(size_t s) {
-  CV_DbgAssert(p == buf);
-  buf[0] = s;
-  return *this;
-}
-
-////////////////////////////// Mat_<_Tp> ////////////////////////////
-
-template <typename _Tp> inline Mat_<_Tp>::Mat_() CV_NOEXCEPT : Mat() {
-  flags = (flags & ~CV_MAT_TYPE_MASK) + traits::Type<_Tp>::value;
-}
-
-template <typename _Tp>
-inline Mat_<_Tp>::Mat_(int _rows, int _cols)
-    : Mat(_rows, _cols, traits::Type<_Tp>::value) {}
-
-template <typename _Tp>
-inline Mat_<_Tp>::Mat_(int _rows, int _cols, const _Tp &value)
-    : Mat(_rows, _cols, traits::Type<_Tp>::value) {
-  *this = value;
-}
-
-template <typename _Tp>
-inline Mat_<_Tp>::Mat_(Size _sz)
-    : Mat(_sz.height, _sz.width, traits::Type<_Tp>::value) {}
-
-template <typename _Tp>
-inline Mat_<_Tp>::Mat_(Size _sz, const _Tp &value)
-    : Mat(_sz.height, _sz.width, traits::Type<_Tp>::value) {
-  *this = value;
-}
-
-template <typename _Tp>
-inline Mat_<_Tp>::Mat_(int _dims, const int *_sz)
-    : Mat(_dims, _sz, traits::Type<_Tp>::value) {}
-
-template <typename _Tp>
-inline Mat_<_Tp>::Mat_(int _dims, const int *_sz, const _Tp &_s)
-    : Mat(_dims, _sz, traits::Type<_Tp>::value, Scalar(_s)) {}
-
-template <typename _Tp>
-inline Mat_<_Tp>::Mat_(int _dims, const int *_sz, _Tp *_data,
-                       const size_t *_steps)
-    : Mat(_dims, _sz, traits::Type<_Tp>::value, _data, _steps) {}
-
-template <typename _Tp>
-inline Mat_<_Tp>::Mat_(const Mat_<_Tp> &m, const Range *ranges)
-    : Mat(m, ranges) {}
-
-template <typename _Tp>
-inline Mat_<_Tp>::Mat_(const Mat_<_Tp> &m, const std::vector<Range> &ranges)
-    : Mat(m, ranges) {}
-
-template <typename _Tp> inline Mat_<_Tp>::Mat_(const Mat &m) : Mat() {
-  flags = (flags & ~CV_MAT_TYPE_MASK) + traits::Type<_Tp>::value;
-  *this = m;
-}
-
-template <typename _Tp> inline Mat_<_Tp>::Mat_(const Mat_ &m) : Mat(m) {}
-
-template <typename _Tp>
-inline Mat_<_Tp>::Mat_(int _rows, int _cols, _Tp *_data, size_t steps)
-    : Mat(_rows, _cols, traits::Type<_Tp>::value, _data, steps) {}
-
-template <typename _Tp>
-inline Mat_<_Tp>::Mat_(const Mat_ &m, const Range &_rowRange,
-                       const Range &_colRange)
-    : Mat(m, _rowRange, _colRange) {}
-
-template <typename _Tp>
-inline Mat_<_Tp>::Mat_(const Mat_ &m, const Rect &roi) : Mat(m, roi) {}
-
-template <typename _Tp>
-template <int n>
-inline Mat_<_Tp>::Mat_(const Vec<typename DataType<_Tp>::channel_type, n> &vec,
-                       bool copyData)
-    : Mat(n / DataType<_Tp>::channels, 1, traits::Type<_Tp>::value,
-          (void *)&vec) {
-  CV_Assert(n % DataType<_Tp>::channels == 0);
-  if (copyData)
-    *this = clone();
-}
-
-template <typename _Tp>
-template <int m, int n>
-inline Mat_<_Tp>::Mat_(
-    const Matx<typename DataType<_Tp>::channel_type, m, n> &M, bool copyData)
-    : Mat(m, n / DataType<_Tp>::channels, traits::Type<_Tp>::value,
-          (void *)&M) {
-  CV_Assert(n % DataType<_Tp>::channels == 0);
-  if (copyData)
-    *this = clone();
-}
-
-template <typename _Tp>
-inline Mat_<_Tp>::Mat_(const Point_<typename DataType<_Tp>::channel_type> &pt,
-                       bool copyData)
-    : Mat(2 / DataType<_Tp>::channels, 1, traits::Type<_Tp>::value,
-          (void *)&pt) {
-  CV_Assert(2 % DataType<_Tp>::channels == 0);
-  if (copyData)
-    *this = clone();
-}
-
-template <typename _Tp>
-inline Mat_<_Tp>::Mat_(const Point3_<typename DataType<_Tp>::channel_type> &pt,
-                       bool copyData)
-    : Mat(3 / DataType<_Tp>::channels, 1, traits::Type<_Tp>::value,
-          (void *)&pt) {
-  CV_Assert(3 % DataType<_Tp>::channels == 0);
-  if (copyData)
-    *this = clone();
-}
-
-template <typename _Tp>
-inline Mat_<_Tp>::Mat_(const MatCommaInitializer_<_Tp> &commaInitializer)
-    : Mat(commaInitializer) {}
-
-template <typename _Tp>
-inline Mat_<_Tp>::Mat_(const std::vector<_Tp> &vec, bool copyData)
-    : Mat(vec, copyData) {}
-
-template <typename _Tp>
-inline Mat_<_Tp>::Mat_(std::initializer_list<_Tp> list) : Mat(list) {}
-
-template <typename _Tp>
-inline Mat_<_Tp>::Mat_(const std::initializer_list<int> sizes,
-                       std::initializer_list<_Tp> list)
-    : Mat(sizes, list) {}
-
-template <typename _Tp>
-template <std::size_t _Nm>
-inline Mat_<_Tp>::Mat_(const std::array<_Tp, _Nm> &arr, bool copyData)
-    : Mat(arr, copyData) {}
-
-template <typename _Tp> inline Mat_<_Tp> &Mat_<_Tp>::operator=(const Mat &m) {
-  if (m.empty()) {
-    release();
-    return *this;
-  }
-  if (traits::Type<_Tp>::value == m.type()) {
-    Mat::operator=(m);
-    return *this;
-  }
-  if (traits::Depth<_Tp>::value == m.depth()) {
-    return (*this = m.reshape(DataType<_Tp>::channels, m.dims, 0));
-  }
-  CV_Assert(DataType<_Tp>::channels == m.channels() || m.empty());
-  m.convertTo(*this, type());
-  return *this;
-}
-
-template <typename _Tp> inline Mat_<_Tp> &Mat_<_Tp>::operator=(const Mat_ &m) {
-  Mat::operator=(m);
-  return *this;
-}
-
-template <typename _Tp> inline Mat_<_Tp> &Mat_<_Tp>::operator=(const _Tp &s) {
-  typedef typename DataType<_Tp>::vec_type VT;
-  Mat::operator=(Scalar((const VT &)s));
-  return *this;
-}
-
-template <typename _Tp> inline void Mat_<_Tp>::create(int _rows, int _cols) {
-  Mat::create(_rows, _cols, traits::Type<_Tp>::value);
-}
-
-template <typename _Tp> inline void Mat_<_Tp>::create(Size _sz) {
-  Mat::create(_sz, traits::Type<_Tp>::value);
-}
-
-template <typename _Tp>
-inline void Mat_<_Tp>::create(int _dims, const int *_sz) {
-  Mat::create(_dims, _sz, traits::Type<_Tp>::value);
-}
-
-template <typename _Tp> inline void Mat_<_Tp>::release() {
-  Mat::release();
-  flags = (flags & ~CV_MAT_TYPE_MASK) + traits::Type<_Tp>::value;
-}
-
-template <typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::cross(const Mat_ &m) const {
-  return Mat_<_Tp>(Mat::cross(m));
-}
-
-template <typename _Tp>
-template <typename T2>
-inline Mat_<_Tp>::operator Mat_<T2>() const {
-  return Mat_<T2>(static_cast<const Mat &>(*this));
-}
-
-template <typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::row(int y) const {
-  return Mat_(*this, Range(y, y + 1), Range::all());
-}
-
-template <typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::col(int x) const {
-  return Mat_(*this, Range::all(), Range(x, x + 1));
-}
-
-template <typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::diag(int d) const {
-  return Mat_(Mat::diag(d));
-}
-
-template <typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::clone() const {
-  return Mat_(Mat::clone());
-}
-
-template <typename _Tp> inline size_t Mat_<_Tp>::elemSize() const {
-  CV_DbgAssert(Mat::elemSize() == sizeof(_Tp));
-  return sizeof(_Tp);
-}
-
-template <typename _Tp> inline size_t Mat_<_Tp>::elemSize1() const {
-  CV_DbgAssert(Mat::elemSize1() == sizeof(_Tp) / DataType<_Tp>::channels);
-  return sizeof(_Tp) / DataType<_Tp>::channels;
-}
-
-template <typename _Tp> inline int Mat_<_Tp>::type() const {
-  CV_DbgAssert(Mat::type() == traits::Type<_Tp>::value);
-  return traits::Type<_Tp>::value;
-}
-
-template <typename _Tp> inline int Mat_<_Tp>::depth() const {
-  CV_DbgAssert(Mat::depth() == traits::Depth<_Tp>::value);
-  return traits::Depth<_Tp>::value;
-}
-
-template <typename _Tp> inline int Mat_<_Tp>::channels() const {
-  CV_DbgAssert(Mat::channels() == DataType<_Tp>::channels);
-  return DataType<_Tp>::channels;
-}
-
-template <typename _Tp> inline size_t Mat_<_Tp>::stepT(int i) const {
-  return step.p[i] / elemSize();
-}
-
-template <typename _Tp> inline size_t Mat_<_Tp>::step1(int i) const {
-  return step.p[i] / elemSize1();
-}
-
-template <typename _Tp>
-inline Mat_<_Tp> &Mat_<_Tp>::adjustROI(int dtop, int dbottom, int dleft,
-                                       int dright) {
-  return (Mat_<_Tp> &)(Mat::adjustROI(dtop, dbottom, dleft, dright));
-}
-
-template <typename _Tp>
-inline Mat_<_Tp> Mat_<_Tp>::operator()(const Range &_rowRange,
-                                       const Range &_colRange) const {
-  return Mat_<_Tp>(*this, _rowRange, _colRange);
-}
-
-template <typename _Tp>
-inline Mat_<_Tp> Mat_<_Tp>::operator()(const Rect &roi) const {
-  return Mat_<_Tp>(*this, roi);
-}
-
-template <typename _Tp>
-inline Mat_<_Tp> Mat_<_Tp>::operator()(const Range *ranges) const {
-  return Mat_<_Tp>(*this, ranges);
-}
-
-template <typename _Tp>
-inline Mat_<_Tp> Mat_<_Tp>::operator()(const std::vector<Range> &ranges) const {
-  return Mat_<_Tp>(*this, ranges);
-}
-
-template <typename _Tp> inline _Tp *Mat_<_Tp>::operator[](int y) {
-  CV_DbgAssert(0 <= y && y < size.p[0]);
-  return (_Tp *)(data + y * step.p[0]);
-}
-
-template <typename _Tp> inline const _Tp *Mat_<_Tp>::operator[](int y) const {
-  CV_DbgAssert(0 <= y && y < size.p[0]);
-  return (const _Tp *)(data + y * step.p[0]);
-}
-
-template <typename _Tp> inline _Tp &Mat_<_Tp>::operator()(int i0, int i1) {
-  CV_DbgAssert(dims <= 2);
-  CV_DbgAssert(data);
-  CV_DbgAssert((unsigned)i0 < (unsigned)size.p[0]);
-  CV_DbgAssert((unsigned)i1 < (unsigned)size.p[1]);
-  CV_DbgAssert(type() == traits::Type<_Tp>::value);
-  return ((_Tp *)(data + step.p[0] * i0))[i1];
-}
-
-template <typename _Tp>
-inline const _Tp &Mat_<_Tp>::operator()(int i0, int i1) const {
-  CV_DbgAssert(dims <= 2);
-  CV_DbgAssert(data);
-  CV_DbgAssert((unsigned)i0 < (unsigned)size.p[0]);
-  CV_DbgAssert((unsigned)i1 < (unsigned)size.p[1]);
-  CV_DbgAssert(type() == traits::Type<_Tp>::value);
-  return ((const _Tp *)(data + step.p[0] * i0))[i1];
-}
-
-template <typename _Tp> inline _Tp &Mat_<_Tp>::operator()(Point pt) {
-  CV_DbgAssert(dims <= 2);
-  CV_DbgAssert(data);
-  CV_DbgAssert((unsigned)pt.y < (unsigned)size.p[0]);
-  CV_DbgAssert((unsigned)pt.x < (unsigned)size.p[1]);
-  CV_DbgAssert(type() == traits::Type<_Tp>::value);
-  return ((_Tp *)(data + step.p[0] * pt.y))[pt.x];
-}
-
-template <typename _Tp>
-inline const _Tp &Mat_<_Tp>::operator()(Point pt) const {
-  CV_DbgAssert(dims <= 2);
-  CV_DbgAssert(data);
-  CV_DbgAssert((unsigned)pt.y < (unsigned)size.p[0]);
-  CV_DbgAssert((unsigned)pt.x < (unsigned)size.p[1]);
-  CV_DbgAssert(type() == traits::Type<_Tp>::value);
-  return ((const _Tp *)(data + step.p[0] * pt.y))[pt.x];
-}
-
-template <typename _Tp> inline _Tp &Mat_<_Tp>::operator()(const int *idx) {
-  return Mat::at<_Tp>(idx);
-}
-
-template <typename _Tp>
-inline const _Tp &Mat_<_Tp>::operator()(const int *idx) const {
-  return Mat::at<_Tp>(idx);
-}
-
-template <typename _Tp>
-template <int n>
-inline _Tp &Mat_<_Tp>::operator()(const Vec<int, n> &idx) {
-  return Mat::at<_Tp>(idx);
-}
-
-template <typename _Tp>
-template <int n>
-inline const _Tp &Mat_<_Tp>::operator()(const Vec<int, n> &idx) const {
-  return Mat::at<_Tp>(idx);
-}
-
-template <typename _Tp> inline _Tp &Mat_<_Tp>::operator()(int i0) {
-  return this->at<_Tp>(i0);
-}
-
-template <typename _Tp> inline const _Tp &Mat_<_Tp>::operator()(int i0) const {
-  return this->at<_Tp>(i0);
-}
-
-template <typename _Tp>
-inline _Tp &Mat_<_Tp>::operator()(int i0, int i1, int i2) {
-  return this->at<_Tp>(i0, i1, i2);
-}
-
-template <typename _Tp>
-inline const _Tp &Mat_<_Tp>::operator()(int i0, int i1, int i2) const {
-  return this->at<_Tp>(i0, i1, i2);
-}
-
-template <typename _Tp> inline Mat_<_Tp>::operator std::vector<_Tp>() const {
-  std::vector<_Tp> v;
-  copyTo(v);
-  return v;
-}
-
-template <typename _Tp>
-template <std::size_t _Nm>
-inline Mat_<_Tp>::operator std::array<_Tp, _Nm>() const {
-  std::array<_Tp, _Nm> a;
-  copyTo(a);
-  return a;
-}
-
-template <typename _Tp>
-template <int n>
-inline Mat_<_Tp>::operator Vec<typename DataType<_Tp>::channel_type, n>()
-    const {
-  CV_Assert(n % DataType<_Tp>::channels == 0);
-
-#if defined _MSC_VER
-  const Mat *pMat =
-      (const Mat *)this; // workaround for MSVS <= 2012 compiler bugs (but
-                         // GCC 4.6 dislikes this workaround)
-  return pMat->operator Vec<typename DataType<_Tp>::channel_type, n>();
-#else
-  return this->Mat::operator Vec<typename DataType<_Tp>::channel_type, n>();
-#endif
-}
-
-template <typename _Tp>
-template <int m, int n>
-inline Mat_<_Tp>::operator Matx<typename DataType<_Tp>::channel_type, m, n>()
-    const {
-  CV_Assert(n % DataType<_Tp>::channels == 0);
-
-#if defined _MSC_VER
-  const Mat *pMat =
-      (const Mat *)this; // workaround for MSVS <= 2012 compiler bugs (but
-                         // GCC 4.6 dislikes this workaround)
-  Matx<typename DataType<_Tp>::channel_type, m, n> res =
-      pMat->operator Matx<typename DataType<_Tp>::channel_type, m, n>();
-  return res;
-#else
-  Matx<typename DataType<_Tp>::channel_type, m, n> res =
-      this->Mat::operator Matx<typename DataType<_Tp>::channel_type, m, n>();
-  return res;
-#endif
-}
-
-template <typename _Tp> inline MatConstIterator_<_Tp> Mat_<_Tp>::begin() const {
-  return Mat::begin<_Tp>();
-}
-
-template <typename _Tp>
-inline std::reverse_iterator<MatConstIterator_<_Tp>> Mat_<_Tp>::rbegin() const {
-  return Mat::rbegin<_Tp>();
-}
-
-template <typename _Tp> inline MatConstIterator_<_Tp> Mat_<_Tp>::end() const {
-  return Mat::end<_Tp>();
-}
-
-template <typename _Tp>
-inline std::reverse_iterator<MatConstIterator_<_Tp>> Mat_<_Tp>::rend() const {
-  return Mat::rend<_Tp>();
-}
-
-template <typename _Tp> inline MatIterator_<_Tp> Mat_<_Tp>::begin() {
-  return Mat::begin<_Tp>();
-}
-
-template <typename _Tp>
-inline std::reverse_iterator<MatIterator_<_Tp>> Mat_<_Tp>::rbegin() {
-  return Mat::rbegin<_Tp>();
-}
-
-template <typename _Tp> inline MatIterator_<_Tp> Mat_<_Tp>::end() {
-  return Mat::end<_Tp>();
-}
-
-template <typename _Tp>
-inline std::reverse_iterator<MatIterator_<_Tp>> Mat_<_Tp>::rend() {
-  return Mat::rend<_Tp>();
-}
-
-template <typename _Tp>
-template <typename Functor>
-inline void Mat_<_Tp>::forEach(const Functor &operation) {
-  Mat::forEach<_Tp, Functor>(operation);
-}
-
-template <typename _Tp>
-template <typename Functor>
-inline void Mat_<_Tp>::forEach(const Functor &operation) const {
-  Mat::forEach<_Tp, Functor>(operation);
-}
-
-template <typename _Tp> inline Mat_<_Tp>::Mat_(Mat_ &&m) : Mat(std::move(m)) {}
-
-template <typename _Tp> inline Mat_<_Tp> &Mat_<_Tp>::operator=(Mat_ &&m) {
-  Mat::operator=(std::move(m));
-  return *this;
-}
-
-template <typename _Tp> inline Mat_<_Tp>::Mat_(Mat &&m) : Mat() {
-  flags = (flags & ~CV_MAT_TYPE_MASK) + traits::Type<_Tp>::value;
-  *this = std::move(m);
-}
-
-template <typename _Tp> inline Mat_<_Tp> &Mat_<_Tp>::operator=(Mat &&m) {
-  if (m.empty()) {
-    release();
-    return *this;
-  }
-  if (traits::Type<_Tp>::value == m.type()) {
-    Mat::operator=((Mat &&)m);
-    return *this;
-  }
-  if (traits::Depth<_Tp>::value == m.depth()) {
-    Mat::operator=((Mat &&)m.reshape(DataType<_Tp>::channels, m.dims, 0));
-    return *this;
-  }
-  CV_DbgAssert(DataType<_Tp>::channels == m.channels());
-  m.convertTo(*this, type());
-  return *this;
-}
-
-template <typename _Tp> inline Mat_<_Tp>::Mat_(MatExpr &&e) : Mat() {
-  flags = (flags & ~CV_MAT_TYPE_MASK) + traits::Type<_Tp>::value;
-  *this = Mat(e);
-}
-
-///////////////////////////// SparseMat /////////////////////////////
-
-inline SparseMat SparseMat::clone() const {
-  SparseMat temp;
-  this->copyTo(temp);
-  return temp;
-}
-
-inline size_t SparseMat::elemSize() const { return CV_ELEM_SIZE(flags); }
-
-inline size_t SparseMat::elemSize1() const { return CV_ELEM_SIZE1(flags); }
-
-inline int SparseMat::type() const { return CV_MAT_TYPE(flags); }
-
-inline int SparseMat::depth() const { return CV_MAT_DEPTH(flags); }
-
-inline int SparseMat::channels() const { return CV_MAT_CN(flags); }
-
-inline const int *SparseMat::size() const { return hdr ? hdr->size : 0; }
-
-inline int SparseMat::size(int i) const {
-  if (hdr) {
-    CV_DbgAssert((unsigned)i < (unsigned)hdr->dims);
-    return hdr->size[i];
-  }
-  return 0;
-}
-
-inline int SparseMat::dims() const { return hdr ? hdr->dims : 0; }
-
-inline size_t SparseMat::nzcount() const { return hdr ? hdr->nodeCount : 0; }
-
-template <typename _Tp> inline _Tp &SparseMat::ref(int i0, size_t *hashval) {
-  return *(_Tp *)((SparseMat *)this)->ptr(i0, true, hashval);
-}
-
-template <typename _Tp>
-inline _Tp &SparseMat::ref(int i0, int i1, size_t *hashval) {
-  return *(_Tp *)((SparseMat *)this)->ptr(i0, i1, true, hashval);
-}
-
-template <typename _Tp>
-inline _Tp &SparseMat::ref(int i0, int i1, int i2, size_t *hashval) {
-  return *(_Tp *)((SparseMat *)this)->ptr(i0, i1, i2, true, hashval);
-}
-
-template <typename _Tp>
-inline _Tp &SparseMat::ref(const int *idx, size_t *hashval) {
-  return *(_Tp *)((SparseMat *)this)->ptr(idx, true, hashval);
-}
-
-template <typename _Tp>
-inline _Tp SparseMat::value(int i0, size_t *hashval) const {
-  const _Tp *p = (const _Tp *)((SparseMat *)this)->ptr(i0, false, hashval);
-  return p ? *p : _Tp();
-}
-
-template <typename _Tp>
-inline _Tp SparseMat::value(int i0, int i1, size_t *hashval) const {
-  const _Tp *p = (const _Tp *)((SparseMat *)this)->ptr(i0, i1, false, hashval);
-  return p ? *p : _Tp();
-}
-
-template <typename _Tp>
-inline _Tp SparseMat::value(int i0, int i1, int i2, size_t *hashval) const {
-  const _Tp *p =
-      (const _Tp *)((SparseMat *)this)->ptr(i0, i1, i2, false, hashval);
-  return p ? *p : _Tp();
-}
-
-template <typename _Tp>
-inline _Tp SparseMat::value(const int *idx, size_t *hashval) const {
-  const _Tp *p = (const _Tp *)((SparseMat *)this)->ptr(idx, false, hashval);
-  return p ? *p : _Tp();
-}
-
-template <typename _Tp>
-inline const _Tp *SparseMat::find(int i0, size_t *hashval) const {
-  return (const _Tp *)((SparseMat *)this)->ptr(i0, false, hashval);
-}
-
-template <typename _Tp>
-inline const _Tp *SparseMat::find(int i0, int i1, size_t *hashval) const {
-  return (const _Tp *)((SparseMat *)this)->ptr(i0, i1, false, hashval);
-}
-
-template <typename _Tp>
-inline const _Tp *SparseMat::find(int i0, int i1, int i2,
-                                  size_t *hashval) const {
-  return (const _Tp *)((SparseMat *)this)->ptr(i0, i1, i2, false, hashval);
-}
-
-template <typename _Tp>
-inline const _Tp *SparseMat::find(const int *idx, size_t *hashval) const {
-  return (const _Tp *)((SparseMat *)this)->ptr(idx, false, hashval);
-}
-
-template <typename _Tp> inline _Tp &SparseMat::value(Node *n) {
-  return *(_Tp *)((uchar *)n + hdr->valueOffset);
-}
-
-template <typename _Tp>
-inline const _Tp &SparseMat::value(const Node *n) const {
-  return *(const _Tp *)((const uchar *)n + hdr->valueOffset);
-}
-
-inline SparseMat::Node *SparseMat::node(size_t nidx) {
-  return (Node *)(void *)&hdr->pool[nidx];
-}
-
-inline const SparseMat::Node *SparseMat::node(size_t nidx) const {
-  return (const Node *)(const void *)&hdr->pool[nidx];
-}
-
-inline SparseMatIterator SparseMat::begin() { return SparseMatIterator(this); }
-
-inline SparseMatConstIterator SparseMat::begin() const {
-  return SparseMatConstIterator(this);
-}
-
-inline SparseMatIterator SparseMat::end() {
-  SparseMatIterator it(this);
-  it.seekEnd();
-  return it;
-}
-
-inline SparseMatConstIterator SparseMat::end() const {
-  SparseMatConstIterator it(this);
-  it.seekEnd();
-  return it;
-}
-
-template <typename _Tp> inline SparseMatIterator_<_Tp> SparseMat::begin() {
-  return SparseMatIterator_<_Tp>(this);
-}
-
-template <typename _Tp>
-inline SparseMatConstIterator_<_Tp> SparseMat::begin() const {
-  return SparseMatConstIterator_<_Tp>(this);
-}
-
-template <typename _Tp> inline SparseMatIterator_<_Tp> SparseMat::end() {
-  SparseMatIterator_<_Tp> it(this);
-  it.seekEnd();
-  return it;
-}
-
-template <typename _Tp>
-inline SparseMatConstIterator_<_Tp> SparseMat::end() const {
-  SparseMatConstIterator_<_Tp> it(this);
-  it.seekEnd();
-  return it;
-}
-
-///////////////////////////// SparseMat_ ////////////////////////////
-
-template <typename _Tp> inline SparseMat_<_Tp>::SparseMat_() {
-  flags = +MAGIC_VAL + traits::Type<_Tp>::value;
-}
-
-template <typename _Tp>
-inline SparseMat_<_Tp>::SparseMat_(int _dims, const int *_sizes)
-    : SparseMat(_dims, _sizes, traits::Type<_Tp>::value) {}
-
-template <typename _Tp> inline SparseMat_<_Tp>::SparseMat_(const SparseMat &m) {
-  if (m.type() == traits::Type<_Tp>::value)
-    *this = (const SparseMat_<_Tp> &)m;
-  else
-    m.convertTo(*this, traits::Type<_Tp>::value);
-}
-
-template <typename _Tp>
-inline SparseMat_<_Tp>::SparseMat_(const SparseMat_<_Tp> &m) {
-  this->flags = m.flags;
-  this->hdr = m.hdr;
-  if (this->hdr)
-    CV_XADD(&this->hdr->refcount, 1);
-}
-
-template <typename _Tp> inline SparseMat_<_Tp>::SparseMat_(const Mat &m) {
-  SparseMat sm(m);
-  *this = sm;
-}
-
-template <typename _Tp>
-inline SparseMat_<_Tp> &SparseMat_<_Tp>::operator=(const SparseMat_<_Tp> &m) {
-  if (this != &m) {
-    if (m.hdr)
-      CV_XADD(&m.hdr->refcount, 1);
-    release();
-    flags = m.flags;
-    hdr = m.hdr;
-  }
-  return *this;
-}
-
-template <typename _Tp>
-inline SparseMat_<_Tp> &SparseMat_<_Tp>::operator=(const SparseMat &m) {
-  if (m.type() == traits::Type<_Tp>::value)
-    return (*this = (const SparseMat_<_Tp> &)m);
-  m.convertTo(*this, traits::Type<_Tp>::value);
-  return *this;
-}
-
-template <typename _Tp>
-inline SparseMat_<_Tp> &SparseMat_<_Tp>::operator=(const Mat &m) {
-  return (*this = SparseMat(m));
-}
-
-template <typename _Tp> inline SparseMat_<_Tp> SparseMat_<_Tp>::clone() const {
-  SparseMat_<_Tp> m;
-  this->copyTo(m);
-  return m;
-}
-
-template <typename _Tp>
-inline void SparseMat_<_Tp>::create(int _dims, const int *_sizes) {
-  SparseMat::create(_dims, _sizes, traits::Type<_Tp>::value);
-}
-
-template <typename _Tp> inline int SparseMat_<_Tp>::type() const {
-  return traits::Type<_Tp>::value;
-}
-
-template <typename _Tp> inline int SparseMat_<_Tp>::depth() const {
-  return traits::Depth<_Tp>::value;
-}
-
-template <typename _Tp> inline int SparseMat_<_Tp>::channels() const {
-  return DataType<_Tp>::channels;
-}
-
-template <typename _Tp>
-inline _Tp &SparseMat_<_Tp>::ref(int i0, size_t *hashval) {
-  return SparseMat::ref<_Tp>(i0, hashval);
-}
-
-template <typename _Tp>
-inline _Tp SparseMat_<_Tp>::operator()(int i0, size_t *hashval) const {
-  return SparseMat::value<_Tp>(i0, hashval);
-}
-
-template <typename _Tp>
-inline _Tp &SparseMat_<_Tp>::ref(int i0, int i1, size_t *hashval) {
-  return SparseMat::ref<_Tp>(i0, i1, hashval);
-}
-
-template <typename _Tp>
-inline _Tp SparseMat_<_Tp>::operator()(int i0, int i1, size_t *hashval) const {
-  return SparseMat::value<_Tp>(i0, i1, hashval);
-}
-
-template <typename _Tp>
-inline _Tp &SparseMat_<_Tp>::ref(int i0, int i1, int i2, size_t *hashval) {
-  return SparseMat::ref<_Tp>(i0, i1, i2, hashval);
-}
-
-template <typename _Tp>
-inline _Tp SparseMat_<_Tp>::operator()(int i0, int i1, int i2,
-                                       size_t *hashval) const {
-  return SparseMat::value<_Tp>(i0, i1, i2, hashval);
-}
-
-template <typename _Tp>
-inline _Tp &SparseMat_<_Tp>::ref(const int *idx, size_t *hashval) {
-  return SparseMat::ref<_Tp>(idx, hashval);
-}
-
-template <typename _Tp>
-inline _Tp SparseMat_<_Tp>::operator()(const int *idx, size_t *hashval) const {
-  return SparseMat::value<_Tp>(idx, hashval);
-}
-
-template <typename _Tp>
-inline SparseMatIterator_<_Tp> SparseMat_<_Tp>::begin() {
-  return SparseMatIterator_<_Tp>(this);
-}
-
-template <typename _Tp>
-inline SparseMatConstIterator_<_Tp> SparseMat_<_Tp>::begin() const {
-  return SparseMatConstIterator_<_Tp>(this);
-}
-
-template <typename _Tp> inline SparseMatIterator_<_Tp> SparseMat_<_Tp>::end() {
-  SparseMatIterator_<_Tp> it(this);
-  it.seekEnd();
-  return it;
-}
-
-template <typename _Tp>
-inline SparseMatConstIterator_<_Tp> SparseMat_<_Tp>::end() const {
-  SparseMatConstIterator_<_Tp> it(this);
-  it.seekEnd();
-  return it;
-}
-
-////////////////////////// MatConstIterator /////////////////////////
-
-inline MatConstIterator::MatConstIterator()
-    : m(0), elemSize(0), ptr(0), sliceStart(0), sliceEnd(0) {}
-
-inline MatConstIterator::MatConstIterator(const Mat *_m)
-    : m(_m), elemSize(_m->elemSize()), ptr(0), sliceStart(0), sliceEnd(0) {
-  if (m && m->isContinuous()) {
-    CV_Assert(!m->empty());
-    sliceStart = m->ptr();
-    sliceEnd = sliceStart + m->total() * elemSize;
-  }
-  seek((const int *)0);
-}
-
-inline MatConstIterator::MatConstIterator(const Mat *_m, int _row, int _col)
-    : m(_m), elemSize(_m->elemSize()), ptr(0), sliceStart(0), sliceEnd(0) {
-  CV_Assert(m && m->dims <= 2);
-  if (m->isContinuous()) {
-    CV_Assert(!m->empty());
-    sliceStart = m->ptr();
-    sliceEnd = sliceStart + m->total() * elemSize;
-  }
-  int idx[] = {_row, _col};
-  seek(idx);
-}
-
-inline MatConstIterator::MatConstIterator(const Mat *_m, Point _pt)
-    : m(_m), elemSize(_m->elemSize()), ptr(0), sliceStart(0), sliceEnd(0) {
-  CV_Assert(m && m->dims <= 2);
-  if (m->isContinuous()) {
-    CV_Assert(!m->empty());
-    sliceStart = m->ptr();
-    sliceEnd = sliceStart + m->total() * elemSize;
-  }
-  int idx[] = {_pt.y, _pt.x};
-  seek(idx);
-}
-
-inline MatConstIterator::MatConstIterator(const MatConstIterator &it)
-    : m(it.m), elemSize(it.elemSize), ptr(it.ptr), sliceStart(it.sliceStart),
-      sliceEnd(it.sliceEnd) {}
-
-inline MatConstIterator &
-MatConstIterator::operator=(const MatConstIterator &it) {
-  m = it.m;
-  elemSize = it.elemSize;
-  ptr = it.ptr;
-  sliceStart = it.sliceStart;
-  sliceEnd = it.sliceEnd;
-  return *this;
-}
-
-inline const uchar *MatConstIterator::operator*() const { return ptr; }
-
-inline MatConstIterator &MatConstIterator::operator+=(ptrdiff_t ofs) {
-  if (!m || ofs == 0)
-    return *this;
-  ptrdiff_t ofsb = ofs * elemSize;
-  ptr += ofsb;
-  if (ptr < sliceStart || sliceEnd <= ptr) {
-    ptr -= ofsb;
-    seek(ofs, true);
-  }
-  return *this;
-}
-
-inline MatConstIterator &MatConstIterator::operator-=(ptrdiff_t ofs) {
-  return (*this += -ofs);
-}
-
-inline MatConstIterator &MatConstIterator::operator--() {
-  if (m && (ptr -= elemSize) < sliceStart) {
-    ptr += elemSize;
-    seek(-1, true);
-  }
-  return *this;
-}
-
-inline MatConstIterator MatConstIterator::operator--(int) {
-  MatConstIterator b = *this;
-  *this += -1;
-  return b;
-}
-
-inline MatConstIterator &MatConstIterator::operator++() {
-  if (m && (ptr += elemSize) >= sliceEnd) {
-    ptr -= elemSize;
-    seek(1, true);
-  }
-  return *this;
-}
-
-inline MatConstIterator MatConstIterator::operator++(int) {
-  MatConstIterator b = *this;
-  *this += 1;
-  return b;
-}
-
-static inline bool operator==(const MatConstIterator &a,
-                              const MatConstIterator &b) {
-  return a.m == b.m && a.ptr == b.ptr;
-}
-
-static inline bool operator!=(const MatConstIterator &a,
-                              const MatConstIterator &b) {
-  return !(a == b);
-}
-
-static inline bool operator<(const MatConstIterator &a,
-                             const MatConstIterator &b) {
-  return a.ptr < b.ptr;
-}
-
-static inline bool operator>(const MatConstIterator &a,
-                             const MatConstIterator &b) {
-  return a.ptr > b.ptr;
-}
-
-static inline bool operator<=(const MatConstIterator &a,
-                              const MatConstIterator &b) {
-  return a.ptr <= b.ptr;
-}
-
-static inline bool operator>=(const MatConstIterator &a,
-                              const MatConstIterator &b) {
-  return a.ptr >= b.ptr;
-}
-
-static inline ptrdiff_t operator-(const MatConstIterator &b,
-                                  const MatConstIterator &a) {
-  if (a.m != b.m)
-    return ((size_t)(-1) >> 1);
-  if (a.sliceEnd == b.sliceEnd)
-    return (b.ptr - a.ptr) / static_cast<ptrdiff_t>(b.elemSize);
-
-  return b.lpos() - a.lpos();
-}
-
-static inline MatConstIterator operator+(const MatConstIterator &a,
-                                         ptrdiff_t ofs) {
-  MatConstIterator b = a;
-  return b += ofs;
-}
-
-static inline MatConstIterator operator+(ptrdiff_t ofs,
-                                         const MatConstIterator &a) {
-  MatConstIterator b = a;
-  return b += ofs;
-}
-
-static inline MatConstIterator operator-(const MatConstIterator &a,
-                                         ptrdiff_t ofs) {
-  MatConstIterator b = a;
-  return b += -ofs;
-}
-
-inline const uchar *MatConstIterator::operator[](ptrdiff_t i) const {
-  return *(*this + i);
-}
-
-///////////////////////// MatConstIterator_ /////////////////////////
-
-template <typename _Tp> inline MatConstIterator_<_Tp>::MatConstIterator_() {}
-
-template <typename _Tp>
-inline MatConstIterator_<_Tp>::MatConstIterator_(const Mat_<_Tp> *_m)
-    : MatConstIterator(_m) {}
-
-template <typename _Tp>
-inline MatConstIterator_<_Tp>::MatConstIterator_(const Mat_<_Tp> *_m, int _row,
-                                                 int _col)
-    : MatConstIterator(_m, _row, _col) {}
-
-template <typename _Tp>
-inline MatConstIterator_<_Tp>::MatConstIterator_(const Mat_<_Tp> *_m, Point _pt)
-    : MatConstIterator(_m, _pt) {}
-
-template <typename _Tp>
-inline MatConstIterator_<_Tp>::MatConstIterator_(const MatConstIterator_ &it)
-    : MatConstIterator(it) {}
-
-template <typename _Tp>
-inline MatConstIterator_<_Tp> &
-MatConstIterator_<_Tp>::operator=(const MatConstIterator_ &it) {
-  MatConstIterator::operator=(it);
-  return *this;
-}
-
-template <typename _Tp>
-inline const _Tp &MatConstIterator_<_Tp>::operator*() const {
-  return *(_Tp *)(this->ptr);
-}
-
-template <typename _Tp>
-inline MatConstIterator_<_Tp> &
-MatConstIterator_<_Tp>::operator+=(ptrdiff_t ofs) {
-  MatConstIterator::operator+=(ofs);
-  return *this;
-}
-
-template <typename _Tp>
-inline MatConstIterator_<_Tp> &
-MatConstIterator_<_Tp>::operator-=(ptrdiff_t ofs) {
-  return (*this += -ofs);
-}
-
-template <typename _Tp>
-inline MatConstIterator_<_Tp> &MatConstIterator_<_Tp>::operator--() {
-  MatConstIterator::operator--();
-  return *this;
-}
-
-template <typename _Tp>
-inline MatConstIterator_<_Tp> MatConstIterator_<_Tp>::operator--(int) {
-  MatConstIterator_ b = *this;
-  MatConstIterator::operator--();
-  return b;
-}
-
-template <typename _Tp>
-inline MatConstIterator_<_Tp> &MatConstIterator_<_Tp>::operator++() {
-  MatConstIterator::operator++();
-  return *this;
-}
-
-template <typename _Tp>
-inline MatConstIterator_<_Tp> MatConstIterator_<_Tp>::operator++(int) {
-  MatConstIterator_ b = *this;
-  MatConstIterator::operator++();
-  return b;
-}
-
-template <typename _Tp> inline Point MatConstIterator_<_Tp>::pos() const {
-  if (!m)
-    return Point();
-  CV_DbgAssert(m->dims <= 2);
-  if (m->isContinuous()) {
-    ptrdiff_t ofs = (const _Tp *)ptr - (const _Tp *)m->data;
-    int y = (int)(ofs / m->cols);
-    int x = (int)(ofs - (ptrdiff_t)y * m->cols);
-    return Point(x, y);
-  } else {
-    ptrdiff_t ofs = (uchar *)ptr - m->data;
-    int y = (int)(ofs / m->step);
-    int x = (int)((ofs - y * m->step) / sizeof(_Tp));
-    return Point(x, y);
-  }
-}
-
-template <typename _Tp>
-static inline bool operator==(const MatConstIterator_<_Tp> &a,
-                              const MatConstIterator_<_Tp> &b) {
-  return a.m == b.m && a.ptr == b.ptr;
-}
-
-template <typename _Tp>
-static inline bool operator!=(const MatConstIterator_<_Tp> &a,
-                              const MatConstIterator_<_Tp> &b) {
-  return a.m != b.m || a.ptr != b.ptr;
-}
-
-template <typename _Tp>
-static inline MatConstIterator_<_Tp> operator+(const MatConstIterator_<_Tp> &a,
-                                               ptrdiff_t ofs) {
-  MatConstIterator t = (const MatConstIterator &)a + ofs;
-  return (MatConstIterator_<_Tp> &)t;
-}
-
-template <typename _Tp>
-static inline MatConstIterator_<_Tp>
-operator+(ptrdiff_t ofs, const MatConstIterator_<_Tp> &a) {
-  MatConstIterator t = (const MatConstIterator &)a + ofs;
-  return (MatConstIterator_<_Tp> &)t;
-}
-
-template <typename _Tp>
-static inline MatConstIterator_<_Tp> operator-(const MatConstIterator_<_Tp> &a,
-                                               ptrdiff_t ofs) {
-  MatConstIterator t = (const MatConstIterator &)a - ofs;
-  return (MatConstIterator_<_Tp> &)t;
-}
-
-template <typename _Tp>
-inline const _Tp &MatConstIterator_<_Tp>::operator[](ptrdiff_t i) const {
-  return *(_Tp *)MatConstIterator::operator[](i);
-}
-
-//////////////////////////// MatIterator_ ///////////////////////////
-
-template <typename _Tp>
-inline MatIterator_<_Tp>::MatIterator_() : MatConstIterator_<_Tp>() {}
-
-template <typename _Tp>
-inline MatIterator_<_Tp>::MatIterator_(Mat_<_Tp> *_m)
-    : MatConstIterator_<_Tp>(_m) {}
-
-template <typename _Tp>
-inline MatIterator_<_Tp>::MatIterator_(Mat_<_Tp> *_m, int _row, int _col)
-    : MatConstIterator_<_Tp>(_m, _row, _col) {}
-
-template <typename _Tp>
-inline MatIterator_<_Tp>::MatIterator_(Mat_<_Tp> *_m, Point _pt)
-    : MatConstIterator_<_Tp>(_m, _pt) {}
-
-template <typename _Tp>
-inline MatIterator_<_Tp>::MatIterator_(Mat_<_Tp> *_m, const int *_idx)
-    : MatConstIterator_<_Tp>(_m, _idx) {}
-
-template <typename _Tp>
-inline MatIterator_<_Tp>::MatIterator_(const MatIterator_ &it)
-    : MatConstIterator_<_Tp>(it) {}
-
-template <typename _Tp>
-inline MatIterator_<_Tp> &
-MatIterator_<_Tp>::operator=(const MatIterator_<_Tp> &it) {
-  MatConstIterator::operator=(it);
-  return *this;
-}
-
-template <typename _Tp> inline _Tp &MatIterator_<_Tp>::operator*() const {
-  return *(_Tp *)(this->ptr);
-}
-
-template <typename _Tp>
-inline MatIterator_<_Tp> &MatIterator_<_Tp>::operator+=(ptrdiff_t ofs) {
-  MatConstIterator::operator+=(ofs);
-  return *this;
-}
-
-template <typename _Tp>
-inline MatIterator_<_Tp> &MatIterator_<_Tp>::operator-=(ptrdiff_t ofs) {
-  MatConstIterator::operator+=(-ofs);
-  return *this;
-}
-
-template <typename _Tp>
-inline MatIterator_<_Tp> &MatIterator_<_Tp>::operator--() {
-  MatConstIterator::operator--();
-  return *this;
-}
-
-template <typename _Tp>
-inline MatIterator_<_Tp> MatIterator_<_Tp>::operator--(int) {
-  MatIterator_ b = *this;
-  MatConstIterator::operator--();
-  return b;
-}
-
-template <typename _Tp>
-inline MatIterator_<_Tp> &MatIterator_<_Tp>::operator++() {
-  MatConstIterator::operator++();
-  return *this;
-}
-
-template <typename _Tp>
-inline MatIterator_<_Tp> MatIterator_<_Tp>::operator++(int) {
-  MatIterator_ b = *this;
-  MatConstIterator::operator++();
-  return b;
-}
-
-template <typename _Tp>
-inline _Tp &MatIterator_<_Tp>::operator[](ptrdiff_t i) const {
-  return *(*this + i);
-}
-
-template <typename _Tp>
-static inline bool operator==(const MatIterator_<_Tp> &a,
-                              const MatIterator_<_Tp> &b) {
-  return a.m == b.m && a.ptr == b.ptr;
-}
-
-template <typename _Tp>
-static inline bool operator!=(const MatIterator_<_Tp> &a,
-                              const MatIterator_<_Tp> &b) {
-  return a.m != b.m || a.ptr != b.ptr;
-}
-
-template <typename _Tp>
-static inline MatIterator_<_Tp> operator+(const MatIterator_<_Tp> &a,
-                                          ptrdiff_t ofs) {
-  MatConstIterator t = (const MatConstIterator &)a + ofs;
-  return (MatIterator_<_Tp> &)t;
-}
-
-template <typename _Tp>
-static inline MatIterator_<_Tp> operator+(ptrdiff_t ofs,
-                                          const MatIterator_<_Tp> &a) {
-  MatConstIterator t = (const MatConstIterator &)a + ofs;
-  return (MatIterator_<_Tp> &)t;
-}
-
-template <typename _Tp>
-static inline MatIterator_<_Tp> operator-(const MatIterator_<_Tp> &a,
-                                          ptrdiff_t ofs) {
-  MatConstIterator t = (const MatConstIterator &)a - ofs;
-  return (MatIterator_<_Tp> &)t;
-}
-
-/////////////////////// SparseMatConstIterator //////////////////////
-
-inline SparseMatConstIterator::SparseMatConstIterator()
-    : m(0), hashidx(0), ptr(0) {}
-
-inline SparseMatConstIterator::SparseMatConstIterator(
-    const SparseMatConstIterator &it)
-    : m(it.m), hashidx(it.hashidx), ptr(it.ptr) {}
-
-inline SparseMatConstIterator &
-SparseMatConstIterator::operator=(const SparseMatConstIterator &it) {
-  if (this != &it) {
-    m = it.m;
-    hashidx = it.hashidx;
-    ptr = it.ptr;
-  }
-  return *this;
-}
-
-template <typename _Tp>
-inline const _Tp &SparseMatConstIterator::value() const {
-  return *(const _Tp *)ptr;
-}
-
-inline const SparseMat::Node *SparseMatConstIterator::node() const {
-  return (ptr && m && m->hdr)
-             ? (const SparseMat::Node *)(const void *)(ptr -
-                                                       m->hdr->valueOffset)
-             : 0;
-}
-
-inline SparseMatConstIterator SparseMatConstIterator::operator++(int) {
-  SparseMatConstIterator it = *this;
-  ++*this;
-  return it;
-}
-
-inline void SparseMatConstIterator::seekEnd() {
-  if (m && m->hdr) {
-    hashidx = m->hdr->hashtab.size();
-    ptr = 0;
-  }
-}
-
-static inline bool operator==(const SparseMatConstIterator &it1,
-                              const SparseMatConstIterator &it2) {
-  return it1.m == it2.m && it1.ptr == it2.ptr;
-}
-
-static inline bool operator!=(const SparseMatConstIterator &it1,
-                              const SparseMatConstIterator &it2) {
-  return !(it1 == it2);
-}
-
-///////////////////////// SparseMatIterator /////////////////////////
-
-inline SparseMatIterator::SparseMatIterator() {}
-
-inline SparseMatIterator::SparseMatIterator(SparseMat *_m)
-    : SparseMatConstIterator(_m) {}
-
-inline SparseMatIterator::SparseMatIterator(const SparseMatIterator &it)
-    : SparseMatConstIterator(it) {}
-
-inline SparseMatIterator &
-SparseMatIterator::operator=(const SparseMatIterator &it) {
-  (SparseMatConstIterator &)*this = it;
-  return *this;
-}
-
-template <typename _Tp> inline _Tp &SparseMatIterator::value() const {
-  return *(_Tp *)ptr;
-}
-
-inline SparseMat::Node *SparseMatIterator::node() const {
-  return (SparseMat::Node *)SparseMatConstIterator::node();
-}
-
-inline SparseMatIterator &SparseMatIterator::operator++() {
-  SparseMatConstIterator::operator++();
-  return *this;
-}
-
-inline SparseMatIterator SparseMatIterator::operator++(int) {
-  SparseMatIterator it = *this;
-  ++*this;
-  return it;
-}
-
-////////////////////// SparseMatConstIterator_ //////////////////////
-
-template <typename _Tp>
-inline SparseMatConstIterator_<_Tp>::SparseMatConstIterator_() {}
-
-template <typename _Tp>
-inline SparseMatConstIterator_<_Tp>::SparseMatConstIterator_(
-    const SparseMat_<_Tp> *_m)
-    : SparseMatConstIterator(_m) {}
-
-template <typename _Tp>
-inline SparseMatConstIterator_<_Tp>::SparseMatConstIterator_(
-    const SparseMat *_m)
-    : SparseMatConstIterator(_m) {
-  CV_Assert(_m->type() == traits::Type<_Tp>::value);
-}
-
-template <typename _Tp>
-inline SparseMatConstIterator_<_Tp>::SparseMatConstIterator_(
-    const SparseMatConstIterator_<_Tp> &it)
-    : SparseMatConstIterator(it) {}
-
-template <typename _Tp>
-inline SparseMatConstIterator_<_Tp> &SparseMatConstIterator_<_Tp>::operator=(
-    const SparseMatConstIterator_<_Tp> &it) {
-  return reinterpret_cast<SparseMatConstIterator_<_Tp> &>(
-      *reinterpret_cast<SparseMatConstIterator *>(this) =
-          reinterpret_cast<const SparseMatConstIterator &>(it));
-}
-
-template <typename _Tp>
-inline const _Tp &SparseMatConstIterator_<_Tp>::operator*() const {
-  return *(const _Tp *)this->ptr;
-}
-
-template <typename _Tp>
-inline SparseMatConstIterator_<_Tp> &
-SparseMatConstIterator_<_Tp>::operator++() {
-  SparseMatConstIterator::operator++();
-  return *this;
-}
-
-template <typename _Tp>
-inline SparseMatConstIterator_<_Tp>
-SparseMatConstIterator_<_Tp>::operator++(int) {
-  SparseMatConstIterator_<_Tp> it = *this;
-  SparseMatConstIterator::operator++();
-  return it;
-}
-
-///////////////////////// SparseMatIterator_ ////////////////////////
-
-template <typename _Tp> inline SparseMatIterator_<_Tp>::SparseMatIterator_() {}
-
-template <typename _Tp>
-inline SparseMatIterator_<_Tp>::SparseMatIterator_(SparseMat_<_Tp> *_m)
-    : SparseMatConstIterator_<_Tp>(_m) {}
-
-template <typename _Tp>
-inline SparseMatIterator_<_Tp>::SparseMatIterator_(SparseMat *_m)
-    : SparseMatConstIterator_<_Tp>(_m) {}
-
-template <typename _Tp>
-inline SparseMatIterator_<_Tp>::SparseMatIterator_(
-    const SparseMatIterator_<_Tp> &it)
-    : SparseMatConstIterator_<_Tp>(it) {}
-
-template <typename _Tp>
-inline SparseMatIterator_<_Tp> &
-SparseMatIterator_<_Tp>::operator=(const SparseMatIterator_<_Tp> &it) {
-  return reinterpret_cast<SparseMatIterator_<_Tp> &>(
-      *reinterpret_cast<SparseMatConstIterator *>(this) =
-          reinterpret_cast<const SparseMatConstIterator &>(it));
-}
-
-template <typename _Tp> inline _Tp &SparseMatIterator_<_Tp>::operator*() const {
-  return *(_Tp *)this->ptr;
-}
-
-template <typename _Tp>
-inline SparseMatIterator_<_Tp> &SparseMatIterator_<_Tp>::operator++() {
-  SparseMatConstIterator::operator++();
-  return *this;
-}
-
-template <typename _Tp>
-inline SparseMatIterator_<_Tp> SparseMatIterator_<_Tp>::operator++(int) {
-  SparseMatIterator_<_Tp> it = *this;
-  SparseMatConstIterator::operator++();
-  return it;
-}
-
-//////////////////////// MatCommaInitializer_ ///////////////////////
-
-template <typename _Tp>
-inline MatCommaInitializer_<_Tp>::MatCommaInitializer_(Mat_<_Tp> *_m)
-    : it(_m) {}
-
-template <typename _Tp>
-template <typename T2>
-inline MatCommaInitializer_<_Tp> &MatCommaInitializer_<_Tp>::operator,(T2 v) {
-  CV_DbgAssert(this->it < ((const Mat_<_Tp> *)this->it.m)->end());
-  *this->it = _Tp(v);
-  ++this->it;
-  return *this;
-}
-
-template <typename _Tp>
-inline MatCommaInitializer_<_Tp>::operator Mat_<_Tp>() const {
-  CV_DbgAssert(this->it == ((const Mat_<_Tp> *)this->it.m)->end());
-  return Mat_<_Tp>(*this->it.m);
-}
-
-template <typename _Tp, typename T2>
-static inline MatCommaInitializer_<_Tp> operator<<(const Mat_<_Tp> &m, T2 val) {
-  MatCommaInitializer_<_Tp> commaInitializer((Mat_<_Tp> *)&m);
-  return (commaInitializer, val);
-}
-
-///////////////////////// Matrix Expressions ////////////////////////
-
-inline Mat &Mat::operator=(const MatExpr &e) {
-  e.op->assign(e, *this);
-  return *this;
-}
-
-template <typename _Tp> inline Mat_<_Tp>::Mat_(const MatExpr &e) {
-  e.op->assign(e, *this, traits::Type<_Tp>::value);
-}
-
-template <typename _Tp>
-inline Mat_<_Tp> &Mat_<_Tp>::operator=(const MatExpr &e) {
-  e.op->assign(e, *this, traits::Type<_Tp>::value);
-  return *this;
-}
-
-template <typename _Tp> inline MatExpr Mat_<_Tp>::zeros(int rows, int cols) {
-  return Mat::zeros(rows, cols, traits::Type<_Tp>::value);
-}
-
-template <typename _Tp> inline MatExpr Mat_<_Tp>::zeros(Size sz) {
-  return Mat::zeros(sz, traits::Type<_Tp>::value);
-}
-
-template <typename _Tp> inline MatExpr Mat_<_Tp>::ones(int rows, int cols) {
-  return Mat::ones(rows, cols, traits::Type<_Tp>::value);
-}
-
-template <typename _Tp> inline MatExpr Mat_<_Tp>::ones(Size sz) {
-  return Mat::ones(sz, traits::Type<_Tp>::value);
-}
-
-template <typename _Tp> inline MatExpr Mat_<_Tp>::eye(int rows, int cols) {
-  return Mat::eye(rows, cols, traits::Type<_Tp>::value);
-}
-
-template <typename _Tp> inline MatExpr Mat_<_Tp>::eye(Size sz) {
-  return Mat::eye(sz, traits::Type<_Tp>::value);
-}
-
-inline MatExpr::MatExpr()
-    : op(0), flags(0), a(Mat()), b(Mat()), c(Mat()), alpha(0), beta(0), s() {}
-
-inline MatExpr::MatExpr(const MatOp *_op, int _flags, const Mat &_a,
-                        const Mat &_b, const Mat &_c, double _alpha,
-                        double _beta, const Scalar &_s)
-    : op(_op), flags(_flags), a(_a), b(_b), c(_c), alpha(_alpha), beta(_beta),
-      s(_s) {}
-
-inline MatExpr::operator Mat() const {
-  Mat m;
-  op->assign(*this, m);
-  return m;
-}
-
-template <typename _Tp> inline MatExpr::operator Mat_<_Tp>() const {
-  Mat_<_Tp> m;
-  op->assign(*this, m, traits::Type<_Tp>::value);
-  return m;
-}
-
-template <typename _Tp>
-static inline MatExpr min(const Mat_<_Tp> &a, const Mat_<_Tp> &b) {
-  return cv::min((const Mat &)a, (const Mat &)b);
-}
-
-template <typename _Tp>
-static inline MatExpr min(const Mat_<_Tp> &a, double s) {
-  return cv::min((const Mat &)a, s);
-}
-
-template <typename _Tp>
-static inline MatExpr min(double s, const Mat_<_Tp> &a) {
-  return cv::min((const Mat &)a, s);
-}
-
-template <typename _Tp>
-static inline MatExpr max(const Mat_<_Tp> &a, const Mat_<_Tp> &b) {
-  return cv::max((const Mat &)a, (const Mat &)b);
-}
-
-template <typename _Tp>
-static inline MatExpr max(const Mat_<_Tp> &a, double s) {
-  return cv::max((const Mat &)a, s);
-}
-
-template <typename _Tp>
-static inline MatExpr max(double s, const Mat_<_Tp> &a) {
-  return cv::max((const Mat &)a, s);
-}
-
-template <typename _Tp> static inline MatExpr abs(const Mat_<_Tp> &m) {
-  return cv::abs((const Mat &)m);
-}
-
-static inline Mat &operator+=(Mat &a, const MatExpr &b) {
-  b.op->augAssignAdd(b, a);
-  return a;
-}
-
-static inline const Mat &operator+=(const Mat &a, const MatExpr &b) {
-  b.op->augAssignAdd(b, (Mat &)a);
-  return a;
-}
-
-template <typename _Tp>
-static inline Mat_<_Tp> &operator+=(Mat_<_Tp> &a, const MatExpr &b) {
-  b.op->augAssignAdd(b, a);
-  return a;
-}
-
-template <typename _Tp>
-static inline const Mat_<_Tp> &operator+=(const Mat_<_Tp> &a,
-                                          const MatExpr &b) {
-  b.op->augAssignAdd(b, (Mat &)a);
-  return a;
-}
-
-static inline Mat &operator-=(Mat &a, const MatExpr &b) {
-  b.op->augAssignSubtract(b, a);
-  return a;
-}
-
-static inline const Mat &operator-=(const Mat &a, const MatExpr &b) {
-  b.op->augAssignSubtract(b, (Mat &)a);
-  return a;
-}
-
-template <typename _Tp>
-static inline Mat_<_Tp> &operator-=(Mat_<_Tp> &a, const MatExpr &b) {
-  b.op->augAssignSubtract(b, a);
-  return a;
-}
-
-template <typename _Tp>
-static inline const Mat_<_Tp> &operator-=(const Mat_<_Tp> &a,
-                                          const MatExpr &b) {
-  b.op->augAssignSubtract(b, (Mat &)a);
-  return a;
-}
-
-static inline Mat &operator*=(Mat &a, const MatExpr &b) {
-  b.op->augAssignMultiply(b, a);
-  return a;
-}
-
-static inline const Mat &operator*=(const Mat &a, const MatExpr &b) {
-  b.op->augAssignMultiply(b, (Mat &)a);
-  return a;
-}
-
-template <typename _Tp>
-static inline Mat_<_Tp> &operator*=(Mat_<_Tp> &a, const MatExpr &b) {
-  b.op->augAssignMultiply(b, a);
-  return a;
-}
-
-template <typename _Tp>
-static inline const Mat_<_Tp> &operator*=(const Mat_<_Tp> &a,
-                                          const MatExpr &b) {
-  b.op->augAssignMultiply(b, (Mat &)a);
-  return a;
-}
-
-static inline Mat &operator/=(Mat &a, const MatExpr &b) {
-  b.op->augAssignDivide(b, a);
-  return a;
-}
-
-static inline const Mat &operator/=(const Mat &a, const MatExpr &b) {
-  b.op->augAssignDivide(b, (Mat &)a);
-  return a;
-}
-
-template <typename _Tp>
-static inline Mat_<_Tp> &operator/=(Mat_<_Tp> &a, const MatExpr &b) {
-  b.op->augAssignDivide(b, a);
-  return a;
-}
-
-template <typename _Tp>
-static inline const Mat_<_Tp> &operator/=(const Mat_<_Tp> &a,
-                                          const MatExpr &b) {
-  b.op->augAssignDivide(b, (Mat &)a);
-  return a;
-}
-
-//////////////////////////////// UMat ////////////////////////////////
-
-inline bool UMatData::hostCopyObsolete() const {
-  return (flags & HOST_COPY_OBSOLETE) != 0;
-}
-inline bool UMatData::deviceCopyObsolete() const {
-  return (flags & DEVICE_COPY_OBSOLETE) != 0;
-}
-inline bool UMatData::deviceMemMapped() const {
-  return (flags & DEVICE_MEM_MAPPED) != 0;
-}
-inline bool UMatData::copyOnMap() const { return (flags & COPY_ON_MAP) != 0; }
-inline bool UMatData::tempUMat() const { return (flags & TEMP_UMAT) != 0; }
-inline bool UMatData::tempCopiedUMat() const {
-  return (flags & TEMP_COPIED_UMAT) == TEMP_COPIED_UMAT;
-}
-
-inline void UMatData::markDeviceMemMapped(bool flag) {
-  if (flag)
-    flags |= DEVICE_MEM_MAPPED;
-  else
-    flags &= ~DEVICE_MEM_MAPPED;
-}
-
-inline void UMatData::markHostCopyObsolete(bool flag) {
-  if (flag)
-    flags |= HOST_COPY_OBSOLETE;
-  else
-    flags &= ~HOST_COPY_OBSOLETE;
-}
-inline void UMatData::markDeviceCopyObsolete(bool flag) {
-  if (flag)
-    flags |= DEVICE_COPY_OBSOLETE;
-  else
-    flags &= ~DEVICE_COPY_OBSOLETE;
-}
-
-//! @endcond
-
-static inline void swap(MatExpr &a, MatExpr &b) { a.swap(b); }
-
-} // namespace cv
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-#ifdef CV_DISABLE_CLANG_ENUM_WARNINGS
-#undef CV_DISABLE_CLANG_ENUM_WARNINGS
-#pragma clang diagnostic pop
-#endif
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/matx.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/matx.hpp
deleted file mode 100644
index 66daab1ebb..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/matx.hpp
+++ /dev/null
@@ -1,603 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_CORE_MATX_HPP
-#define OPENCV_CORE_MATX_HPP
-
-#ifndef __cplusplus
-#error matx.hpp header must be compiled as C++
-#endif
-
-#include "opencv2/core/base.hpp"
-#include "opencv2/core/cvdef.h"
-#include "opencv2/core/saturate.hpp"
-#include "opencv2/core/traits.hpp"
-
-#include <initializer_list>
-
-namespace cv {
-
-//! @addtogroup core_basic
-//! @{
-
-//! @cond IGNORED
-// FIXIT Remove this (especially CV_EXPORTS modifier)
-struct CV_EXPORTS Matx_AddOp {
-  Matx_AddOp() {}
-  Matx_AddOp(const Matx_AddOp &) {}
-};
-struct CV_EXPORTS Matx_SubOp {
-  Matx_SubOp() {}
-  Matx_SubOp(const Matx_SubOp &) {}
-};
-struct CV_EXPORTS Matx_ScaleOp {
-  Matx_ScaleOp() {}
-  Matx_ScaleOp(const Matx_ScaleOp &) {}
-};
-struct CV_EXPORTS Matx_MulOp {
-  Matx_MulOp() {}
-  Matx_MulOp(const Matx_MulOp &) {}
-};
-struct CV_EXPORTS Matx_DivOp {
-  Matx_DivOp() {}
-  Matx_DivOp(const Matx_DivOp &) {}
-};
-struct CV_EXPORTS Matx_MatMulOp {
-  Matx_MatMulOp() {}
-  Matx_MatMulOp(const Matx_MatMulOp &) {}
-};
-struct CV_EXPORTS Matx_TOp {
-  Matx_TOp() {}
-  Matx_TOp(const Matx_TOp &) {}
-};
-//! @endcond
-
-////////////////////////////// Small Matrix ///////////////////////////
-
-/** @brief Template class for small matrices whose type and size are known at
-compilation time
-
-If you need a more flexible type, use Mat . The elements of the matrix M are
-accessible using the M(i,j) notation. Most of the common matrix operations (see
-also @ref MatrixExpressions ) are available. To do an operation on Matx that is
-not implemented, you can easily convert the matrix to Mat and backwards:
-@code{.cpp}
-    Matx33f m(1, 2, 3,
-              4, 5, 6,
-              7, 8, 9);
-    cout << sum(Mat(m*m.t())) << endl;
-@endcode
-Except of the plain constructor which takes a list of elements, Matx can be
-initialized from a C-array:
-@code{.cpp}
-    float values[] = { 1, 2, 3};
-    Matx31f m(values);
-@endcode
-In case if C++11 features are available, std::initializer_list can be also used
-to initialize Matx:
-@code{.cpp}
-    Matx31f m = { 1, 2, 3};
-@endcode
- */
-template <typename _Tp, int m, int n> class Matx {
-public:
-  enum {
-    rows = m,
-    cols = n,
-    channels = rows * cols,
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-    depth = traits::Type<_Tp>::value,
-    type = CV_MAKETYPE(depth, channels),
-#endif
-    shortdim = (m < n ? m : n)
-  };
-
-  typedef _Tp value_type;
-  typedef Matx<_Tp, m, n> mat_type;
-  typedef Matx<_Tp, shortdim, 1> diag_type;
-
-  //! default constructor
-  Matx();
-
-  explicit Matx(_Tp v0);                        //!< 1x1 matrix
-  Matx(_Tp v0, _Tp v1);                         //!< 1x2 or 2x1 matrix
-  Matx(_Tp v0, _Tp v1, _Tp v2);                 //!< 1x3 or 3x1 matrix
-  Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3);         //!< 1x4, 2x2 or 4x1 matrix
-  Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4); //!< 1x5 or 5x1 matrix
-  Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4,
-       _Tp v5); //!< 1x6, 2x3, 3x2 or 6x1 matrix
-  Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5,
-       _Tp v6); //!< 1x7 or 7x1 matrix
-  Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6,
-       _Tp v7); //!< 1x8, 2x4, 4x2 or 8x1 matrix
-  Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7,
-       _Tp v8); //!< 1x9, 3x3 or 9x1 matrix
-  Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8,
-       _Tp v9); //!< 1x10, 2x5 or 5x2 or 10x1 matrix
-  Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8,
-       _Tp v9, _Tp v10, _Tp v11); //!< 1x12, 2x6, 3x4, 4x3, 6x2 or 12x1 matrix
-  Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8,
-       _Tp v9, _Tp v10, _Tp v11, _Tp v12,
-       _Tp v13); //!< 1x14, 2x7, 7x2 or 14x1 matrix
-  Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8,
-       _Tp v9, _Tp v10, _Tp v11, _Tp v12, _Tp v13, _Tp v14,
-       _Tp v15);                  //!< 1x16, 4x4 or 16x1 matrix
-  explicit Matx(const _Tp *vals); //!< initialize from a plain array
-
-  Matx(std::initializer_list<_Tp>); //!< initialize from an initializer list
-
-  CV_NODISCARD_STD static Matx all(_Tp alpha);
-  CV_NODISCARD_STD static Matx zeros();
-  CV_NODISCARD_STD static Matx ones();
-  CV_NODISCARD_STD static Matx eye();
-  CV_NODISCARD_STD static Matx diag(const diag_type &d);
-  /** @brief Generates uniformly distributed random numbers
-  @param a Range boundary.
-  @param b The other range boundary (boundaries don't have to be ordered, the
-  lower boundary is inclusive, the upper one is exclusive).
-   */
-  CV_NODISCARD_STD static Matx randu(_Tp a, _Tp b);
-  /** @brief Generates normally distributed random numbers
-  @param a Mean value.
-  @param b Standard deviation.
-   */
-  CV_NODISCARD_STD static Matx randn(_Tp a, _Tp b);
-
-  //! dot product computed with the default precision
-  _Tp dot(const Matx<_Tp, m, n> &v) const;
-
-  //! dot product computed in double-precision arithmetics
-  double ddot(const Matx<_Tp, m, n> &v) const;
-
-  //! conversion to another data type
-  template <typename T2> operator Matx<T2, m, n>() const;
-
-  //! change the matrix shape
-  template <int m1, int n1> Matx<_Tp, m1, n1> reshape() const;
-
-  //! extract part of the matrix
-  template <int m1, int n1>
-  Matx<_Tp, m1, n1> get_minor(int base_row, int base_col) const;
-
-  //! extract the matrix row
-  Matx<_Tp, 1, n> row(int i) const;
-
-  //! extract the matrix column
-  Matx<_Tp, m, 1> col(int i) const;
-
-  //! extract the matrix diagonal
-  diag_type diag() const;
-
-  //! transpose the matrix
-  Matx<_Tp, n, m> t() const;
-
-  //! invert the matrix
-  Matx<_Tp, n, m> inv(int method = DECOMP_LU, bool *p_is_ok = NULL) const;
-
-  //! solve linear system
-  template <int l>
-  Matx<_Tp, n, l> solve(const Matx<_Tp, m, l> &rhs,
-                        int flags = DECOMP_LU) const;
-  Vec<_Tp, n> solve(const Vec<_Tp, m> &rhs, int method) const;
-
-  //! multiply two matrices element-wise
-  Matx<_Tp, m, n> mul(const Matx<_Tp, m, n> &a) const;
-
-  //! divide two matrices element-wise
-  Matx<_Tp, m, n> div(const Matx<_Tp, m, n> &a) const;
-
-  //! element access
-  const _Tp &operator()(int row, int col) const;
-  _Tp &operator()(int row, int col);
-
-  //! 1D element access
-  const _Tp &operator()(int i) const;
-  _Tp &operator()(int i);
-
-  Matx(const Matx<_Tp, m, n> &a, const Matx<_Tp, m, n> &b, Matx_AddOp);
-  Matx(const Matx<_Tp, m, n> &a, const Matx<_Tp, m, n> &b, Matx_SubOp);
-  template <typename _T2>
-  Matx(const Matx<_Tp, m, n> &a, _T2 alpha, Matx_ScaleOp);
-  Matx(const Matx<_Tp, m, n> &a, const Matx<_Tp, m, n> &b, Matx_MulOp);
-  Matx(const Matx<_Tp, m, n> &a, const Matx<_Tp, m, n> &b, Matx_DivOp);
-  template <int l>
-  Matx(const Matx<_Tp, m, l> &a, const Matx<_Tp, l, n> &b, Matx_MatMulOp);
-  Matx(const Matx<_Tp, n, m> &a, Matx_TOp);
-
-  _Tp val[m * n]; ///< matrix elements
-};
-
-typedef Matx<float, 1, 2> Matx12f;
-typedef Matx<double, 1, 2> Matx12d;
-typedef Matx<float, 1, 3> Matx13f;
-typedef Matx<double, 1, 3> Matx13d;
-typedef Matx<float, 1, 4> Matx14f;
-typedef Matx<double, 1, 4> Matx14d;
-typedef Matx<float, 1, 6> Matx16f;
-typedef Matx<double, 1, 6> Matx16d;
-
-typedef Matx<float, 2, 1> Matx21f;
-typedef Matx<double, 2, 1> Matx21d;
-typedef Matx<float, 3, 1> Matx31f;
-typedef Matx<double, 3, 1> Matx31d;
-typedef Matx<float, 4, 1> Matx41f;
-typedef Matx<double, 4, 1> Matx41d;
-typedef Matx<float, 6, 1> Matx61f;
-typedef Matx<double, 6, 1> Matx61d;
-
-typedef Matx<float, 2, 2> Matx22f;
-typedef Matx<double, 2, 2> Matx22d;
-typedef Matx<float, 2, 3> Matx23f;
-typedef Matx<double, 2, 3> Matx23d;
-typedef Matx<float, 3, 2> Matx32f;
-typedef Matx<double, 3, 2> Matx32d;
-
-typedef Matx<float, 3, 3> Matx33f;
-typedef Matx<double, 3, 3> Matx33d;
-
-typedef Matx<float, 3, 4> Matx34f;
-typedef Matx<double, 3, 4> Matx34d;
-typedef Matx<float, 4, 3> Matx43f;
-typedef Matx<double, 4, 3> Matx43d;
-
-typedef Matx<float, 4, 4> Matx44f;
-typedef Matx<double, 4, 4> Matx44d;
-typedef Matx<float, 6, 6> Matx66f;
-typedef Matx<double, 6, 6> Matx66d;
-
-template <typename _Tp, int m>
-static inline double determinant(const Matx<_Tp, m, m> &a);
-
-template <typename _Tp, int m, int n>
-static inline double trace(const Matx<_Tp, m, n> &a);
-
-template <typename _Tp, int m, int n>
-static inline double norm(const Matx<_Tp, m, n> &M);
-
-template <typename _Tp, int m, int n>
-static inline double norm(const Matx<_Tp, m, n> &M, int normType);
-
-template <typename _Tp1, typename _Tp2, int m, int n>
-static inline Matx<_Tp1, m, n> &operator+=(Matx<_Tp1, m, n> &a,
-                                           const Matx<_Tp2, m, n> &b);
-
-template <typename _Tp1, typename _Tp2, int m, int n>
-static inline Matx<_Tp1, m, n> &operator-=(Matx<_Tp1, m, n> &a,
-                                           const Matx<_Tp2, m, n> &b);
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> operator+(const Matx<_Tp, m, n> &a,
-                                        const Matx<_Tp, m, n> &b);
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> operator-(const Matx<_Tp, m, n> &a,
-                                        const Matx<_Tp, m, n> &b);
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> &operator*=(Matx<_Tp, m, n> &a, int alpha);
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> &operator*=(Matx<_Tp, m, n> &a, float alpha);
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> &operator*=(Matx<_Tp, m, n> &a, double alpha);
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> operator*(const Matx<_Tp, m, n> &a, int alpha);
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> operator*(const Matx<_Tp, m, n> &a, float alpha);
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> operator*(const Matx<_Tp, m, n> &a, double alpha);
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> operator*(int alpha, const Matx<_Tp, m, n> &a);
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> operator*(float alpha, const Matx<_Tp, m, n> &a);
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> operator*(double alpha, const Matx<_Tp, m, n> &a);
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> &operator/=(Matx<_Tp, m, n> &a, float alpha);
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> &operator/=(Matx<_Tp, m, n> &a, double alpha);
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> operator/(const Matx<_Tp, m, n> &a, float alpha);
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> operator/(const Matx<_Tp, m, n> &a, double alpha);
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> operator-(const Matx<_Tp, m, n> &a);
-
-template <typename _Tp, int m, int n, int l>
-static inline Matx<_Tp, m, n> operator*(const Matx<_Tp, m, l> &a,
-                                        const Matx<_Tp, l, n> &b);
-
-template <typename _Tp, int m, int n>
-static inline Vec<_Tp, m> operator*(const Matx<_Tp, m, n> &a,
-                                    const Vec<_Tp, n> &b);
-
-template <typename _Tp, int m, int n>
-static inline bool operator==(const Matx<_Tp, m, n> &a,
-                              const Matx<_Tp, m, n> &b);
-
-template <typename _Tp, int m, int n>
-static inline bool operator!=(const Matx<_Tp, m, n> &a,
-                              const Matx<_Tp, m, n> &b);
-
-/////////////////////// Vec (used as element of multi-channel images
-////////////////////////
-
-/** @brief Template class for short numerical vectors, a partial case of Matx
-
-This template class represents short numerical vectors (of 1, 2, 3, 4 ...
-elements) on which you can perform basic arithmetical operations, access
-individual elements using [] operator etc. The vectors are allocated on stack,
-as opposite to std::valarray, std::vector, cv::Mat etc., which elements are
-dynamically allocated in the heap.
-
-The template takes 2 parameters:
-@tparam _Tp element type
-@tparam cn the number of elements
-
-In addition to the universal notation like Vec<float, 3>, you can use shorter
-aliases for the most popular specialized variants of Vec, e.g. Vec3f ~
-Vec<float, 3>.
-
-It is possible to convert Vec\<T,2\> to/from Point_, Vec\<T,3\> to/from Point3_
-, and Vec\<T,4\> to CvScalar or Scalar_. Use operator[] to access the elements
-of Vec.
-
-All the expected vector operations are also implemented:
--   v1 = v2 + v3
--   v1 = v2 - v3
--   v1 = v2 \* scale
--   v1 = scale \* v2
--   v1 = -v2
--   v1 += v2 and other augmenting operations
--   v1 == v2, v1 != v2
--   norm(v1) (euclidean norm)
-The Vec class is commonly used to describe pixel types of multi-channel arrays.
-See Mat for details.
-*/
-template <typename _Tp, int cn> class Vec : public Matx<_Tp, cn, 1> {
-public:
-  typedef _Tp value_type;
-  enum {
-    channels = cn,
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-    depth = Matx<_Tp, cn, 1>::depth,
-    type = CV_MAKETYPE(depth, channels),
-#endif
-    _dummy_enum_finalizer = 0
-  };
-
-  //! default constructor
-  Vec();
-
-  Vec(_Tp v0);                                 //!< 1-element vector constructor
-  Vec(_Tp v0, _Tp v1);                         //!< 2-element vector constructor
-  Vec(_Tp v0, _Tp v1, _Tp v2);                 //!< 3-element vector constructor
-  Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3);         //!< 4-element vector constructor
-  Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4); //!< 5-element vector constructor
-  Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4,
-      _Tp v5); //!< 6-element vector constructor
-  Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5,
-      _Tp v6); //!< 7-element vector constructor
-  Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6,
-      _Tp v7); //!< 8-element vector constructor
-  Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7,
-      _Tp v8); //!< 9-element vector constructor
-  Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8,
-      _Tp v9); //!< 10-element vector constructor
-  Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8,
-      _Tp v9, _Tp v10, _Tp v11, _Tp v12,
-      _Tp v13); //!< 14-element vector constructor
-  explicit Vec(const _Tp *values);
-
-  Vec(std::initializer_list<_Tp>);
-
-  Vec(const Vec<_Tp, cn> &v);
-
-  static Vec all(_Tp alpha);
-  static Vec ones();
-  static Vec randn(_Tp a, _Tp b);
-  static Vec randu(_Tp a, _Tp b);
-  static Vec zeros();
-  static Vec diag(_Tp alpha) = delete;
-  static Vec eye() = delete;
-
-  //! per-element multiplication
-  Vec mul(const Vec<_Tp, cn> &v) const;
-
-  //! conjugation (makes sense for complex numbers and quaternions)
-  Vec conj() const;
-
-  /*!
-    cross product of the two 3D vectors.
-
-    For other dimensionalities the exception is raised
-  */
-  Vec cross(const Vec &v) const;
-  //! conversion to another data type
-  template <typename T2> operator Vec<T2, cn>() const;
-
-  /*! element access */
-  const _Tp &operator[](int i) const;
-  _Tp &operator[](int i);
-  const _Tp &operator()(int i) const;
-  _Tp &operator()(int i);
-
-  Vec<_Tp, cn> &operator=(const Vec<_Tp, cn> &rhs) = default;
-
-  Vec(const Matx<_Tp, cn, 1> &a, const Matx<_Tp, cn, 1> &b, Matx_AddOp);
-  Vec(const Matx<_Tp, cn, 1> &a, const Matx<_Tp, cn, 1> &b, Matx_SubOp);
-  template <typename _T2>
-  Vec(const Matx<_Tp, cn, 1> &a, _T2 alpha, Matx_ScaleOp);
-};
-
-/** @name Shorter aliases for the most popular specializations of Vec<T,n>
-  @{
-*/
-typedef Vec<uchar, 2> Vec2b;
-typedef Vec<uchar, 3> Vec3b;
-typedef Vec<uchar, 4> Vec4b;
-
-typedef Vec<short, 2> Vec2s;
-typedef Vec<short, 3> Vec3s;
-typedef Vec<short, 4> Vec4s;
-
-typedef Vec<ushort, 2> Vec2w;
-typedef Vec<ushort, 3> Vec3w;
-typedef Vec<ushort, 4> Vec4w;
-
-typedef Vec<int, 2> Vec2i;
-typedef Vec<int, 3> Vec3i;
-typedef Vec<int, 4> Vec4i;
-typedef Vec<int, 6> Vec6i;
-typedef Vec<int, 8> Vec8i;
-
-typedef Vec<float, 2> Vec2f;
-typedef Vec<float, 3> Vec3f;
-typedef Vec<float, 4> Vec4f;
-typedef Vec<float, 6> Vec6f;
-
-typedef Vec<double, 2> Vec2d;
-typedef Vec<double, 3> Vec3d;
-typedef Vec<double, 4> Vec4d;
-typedef Vec<double, 6> Vec6d;
-/** @} */
-
-template <typename _Tp, int cn>
-inline Vec<_Tp, cn> normalize(const Vec<_Tp, cn> &v);
-
-template <typename _Tp1, typename _Tp2, int cn>
-static inline Vec<_Tp1, cn> &operator+=(Vec<_Tp1, cn> &a,
-                                        const Vec<_Tp2, cn> &b);
-
-template <typename _Tp1, typename _Tp2, int cn>
-static inline Vec<_Tp1, cn> &operator-=(Vec<_Tp1, cn> &a,
-                                        const Vec<_Tp2, cn> &b);
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> operator+(const Vec<_Tp, cn> &a,
-                                     const Vec<_Tp, cn> &b);
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> operator-(const Vec<_Tp, cn> &a,
-                                     const Vec<_Tp, cn> &b);
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> &operator*=(Vec<_Tp, cn> &a, int alpha);
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> &operator*=(Vec<_Tp, cn> &a, float alpha);
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> &operator*=(Vec<_Tp, cn> &a, double alpha);
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> &operator/=(Vec<_Tp, cn> &a, int alpha);
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> &operator/=(Vec<_Tp, cn> &a, float alpha);
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> &operator/=(Vec<_Tp, cn> &a, double alpha);
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> operator*(const Vec<_Tp, cn> &a, int alpha);
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> operator*(int alpha, const Vec<_Tp, cn> &a);
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> operator*(const Vec<_Tp, cn> &a, float alpha);
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> operator*(float alpha, const Vec<_Tp, cn> &a);
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> operator*(const Vec<_Tp, cn> &a, double alpha);
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> operator*(double alpha, const Vec<_Tp, cn> &a);
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> operator/(const Vec<_Tp, cn> &a, int alpha);
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> operator/(const Vec<_Tp, cn> &a, float alpha);
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> operator/(const Vec<_Tp, cn> &a, double alpha);
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> operator-(const Vec<_Tp, cn> &a);
-
-template <typename _Tp>
-inline Vec<_Tp, 4> operator*(const Vec<_Tp, 4> &v1, const Vec<_Tp, 4> &v2);
-
-template <typename _Tp>
-inline Vec<_Tp, 4> &operator*=(Vec<_Tp, 4> &v1, const Vec<_Tp, 4> &v2);
-
-//! @} core_basic
-
-} // namespace cv
-
-#include "opencv2/core/matx.inl.hpp"
-
-#endif // OPENCV_CORE_MATX_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/matx.inl.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/matx.inl.hpp
deleted file mode 100644
index 270ea8fead..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/matx.inl.hpp
+++ /dev/null
@@ -1,1132 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_CORE_MATX_INL_HPP
-#define OPENCV_CORE_MATX_INL_HPP
-
-#ifndef __cplusplus
-#error matx.inl.hpp header must be compiled as C++
-#endif
-
-#include "opencv2/core/matx.hpp"
-
-namespace cv {
-
-//==============================================================================
-// Helpers
-
-namespace internal {
-
-template <typename _Tp, int m> struct Matx_DetOp {
-  double operator()(const Matx<_Tp, m, m> &a) const {
-    Matx<_Tp, m, m> temp = a;
-    double p = LU(temp.val, m * sizeof(_Tp), m, 0, 0, 0);
-    if (p == 0)
-      return p;
-    for (int i = 0; i < m; i++)
-      p *= temp(i, i);
-    return p;
-  }
-};
-
-template <typename _Tp> struct Matx_DetOp<_Tp, 1> {
-  double operator()(const Matx<_Tp, 1, 1> &a) const { return a(0, 0); }
-};
-
-template <typename _Tp> struct Matx_DetOp<_Tp, 2> {
-  double operator()(const Matx<_Tp, 2, 2> &a) const {
-    return a(0, 0) * a(1, 1) - a(0, 1) * a(1, 0);
-  }
-};
-
-template <typename _Tp> struct Matx_DetOp<_Tp, 3> {
-  double operator()(const Matx<_Tp, 3, 3> &a) const {
-    return a(0, 0) * (a(1, 1) * a(2, 2) - a(2, 1) * a(1, 2)) -
-           a(0, 1) * (a(1, 0) * a(2, 2) - a(2, 0) * a(1, 2)) +
-           a(0, 2) * (a(1, 0) * a(2, 1) - a(2, 0) * a(1, 1));
-  }
-};
-
-template <typename _Tp> Vec<_Tp, 2> inline conjugate(const Vec<_Tp, 2> &v) {
-  return Vec<_Tp, 2>(v[0], -v[1]);
-}
-
-template <typename _Tp> Vec<_Tp, 4> inline conjugate(const Vec<_Tp, 4> &v) {
-  return Vec<_Tp, 4>(v[0], -v[1], -v[2], -v[3]);
-}
-
-} // namespace internal
-
-//==============================================================================
-// Matx
-
-template <typename _Tp, int m, int n> class DataType<Matx<_Tp, m, n>> {
-public:
-  typedef Matx<_Tp, m, n> value_type;
-  typedef Matx<typename DataType<_Tp>::work_type, m, n> work_type;
-  typedef _Tp channel_type;
-  typedef value_type vec_type;
-
-  enum {
-    generic_type = 0,
-    channels = m * n,
-    fmt = traits::SafeFmt<channel_type>::fmt + ((channels - 1) << 8)
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-        ,
-    depth = DataType<channel_type>::depth,
-    type = CV_MAKETYPE(depth, channels)
-#endif
-  };
-};
-
-namespace traits {
-template <typename _Tp, int m, int n> struct Depth<Matx<_Tp, m, n>> {
-  enum { value = Depth<_Tp>::value };
-};
-template <typename _Tp, int m, int n> struct Type<Matx<_Tp, m, n>> {
-  enum { value = CV_MAKETYPE(Depth<_Tp>::value, n *m) };
-};
-} // namespace traits
-
-//! @brief  Comma-separated Matrix Initializer
-template <typename _Tp, int m, int n> class MatxCommaInitializer {
-public:
-  MatxCommaInitializer(Matx<_Tp, m, n> *_mtx);
-  template <typename T2> MatxCommaInitializer<_Tp, m, n> &operator,(T2 val);
-  Matx<_Tp, m, n> operator*() const;
-
-  Matx<_Tp, m, n> *dst;
-  int idx;
-};
-
-template <typename _Tp, typename _T2, int m, int n>
-static inline MatxCommaInitializer<_Tp, m, n>
-operator<<(const Matx<_Tp, m, n> &mtx, _T2 val) {
-  MatxCommaInitializer<_Tp, m, n> commaInitializer((Matx<_Tp, m, n> *)&mtx);
-  return (commaInitializer, val);
-}
-
-template <typename _Tp, int m, int n>
-inline MatxCommaInitializer<_Tp, m, n>::MatxCommaInitializer(
-    Matx<_Tp, m, n> *_mtx)
-    : dst(_mtx), idx(0) {}
-
-template <typename _Tp, int m, int n>
-template <typename _T2>
-inline MatxCommaInitializer<_Tp, m, n>
-    &MatxCommaInitializer<_Tp, m, n>::operator,(_T2 value) {
-  CV_DbgAssert(idx < m * n);
-  dst->val[idx++] = saturate_cast<_Tp>(value);
-  return *this;
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n> MatxCommaInitializer<_Tp, m, n>::operator*() const {
-  CV_DbgAssert(idx == n * m);
-  return *dst;
-}
-
-////////////////////////////////// Matx Implementation
-//////////////////////////////////////
-
-template <typename _Tp, int m, int n> inline Matx<_Tp, m, n>::Matx() {
-  for (int i = 0; i < channels; i++)
-    val[i] = _Tp(0);
-}
-
-template <typename _Tp, int m, int n> inline Matx<_Tp, m, n>::Matx(_Tp v0) {
-  val[0] = v0;
-  for (int i = 1; i < channels; i++)
-    val[i] = _Tp(0);
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1) {
-  CV_StaticAssert(channels >= 2, "Matx should have at least 2 elements.");
-  val[0] = v0;
-  val[1] = v1;
-  for (int i = 2; i < channels; i++)
-    val[i] = _Tp(0);
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2) {
-  CV_StaticAssert(channels >= 3, "Matx should have at least 3 elements.");
-  val[0] = v0;
-  val[1] = v1;
-  val[2] = v2;
-  for (int i = 3; i < channels; i++)
-    val[i] = _Tp(0);
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3) {
-  CV_StaticAssert(channels >= 4, "Matx should have at least 4 elements.");
-  val[0] = v0;
-  val[1] = v1;
-  val[2] = v2;
-  val[3] = v3;
-  for (int i = 4; i < channels; i++)
-    val[i] = _Tp(0);
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4) {
-  CV_StaticAssert(channels >= 5, "Matx should have at least 5 elements.");
-  val[0] = v0;
-  val[1] = v1;
-  val[2] = v2;
-  val[3] = v3;
-  val[4] = v4;
-  for (int i = 5; i < channels; i++)
-    val[i] = _Tp(0);
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5) {
-  CV_StaticAssert(channels >= 6, "Matx should have at least 6 elements.");
-  val[0] = v0;
-  val[1] = v1;
-  val[2] = v2;
-  val[3] = v3;
-  val[4] = v4;
-  val[5] = v5;
-  for (int i = 6; i < channels; i++)
-    val[i] = _Tp(0);
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5,
-                             _Tp v6) {
-  CV_StaticAssert(channels >= 7, "Matx should have at least 7 elements.");
-  val[0] = v0;
-  val[1] = v1;
-  val[2] = v2;
-  val[3] = v3;
-  val[4] = v4;
-  val[5] = v5;
-  val[6] = v6;
-  for (int i = 7; i < channels; i++)
-    val[i] = _Tp(0);
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5,
-                             _Tp v6, _Tp v7) {
-  CV_StaticAssert(channels >= 8, "Matx should have at least 8 elements.");
-  val[0] = v0;
-  val[1] = v1;
-  val[2] = v2;
-  val[3] = v3;
-  val[4] = v4;
-  val[5] = v5;
-  val[6] = v6;
-  val[7] = v7;
-  for (int i = 8; i < channels; i++)
-    val[i] = _Tp(0);
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5,
-                             _Tp v6, _Tp v7, _Tp v8) {
-  CV_StaticAssert(channels >= 9, "Matx should have at least 9 elements.");
-  val[0] = v0;
-  val[1] = v1;
-  val[2] = v2;
-  val[3] = v3;
-  val[4] = v4;
-  val[5] = v5;
-  val[6] = v6;
-  val[7] = v7;
-  val[8] = v8;
-  for (int i = 9; i < channels; i++)
-    val[i] = _Tp(0);
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5,
-                             _Tp v6, _Tp v7, _Tp v8, _Tp v9) {
-  CV_StaticAssert(channels >= 10, "Matx should have at least 10 elements.");
-  val[0] = v0;
-  val[1] = v1;
-  val[2] = v2;
-  val[3] = v3;
-  val[4] = v4;
-  val[5] = v5;
-  val[6] = v6;
-  val[7] = v7;
-  val[8] = v8;
-  val[9] = v9;
-  for (int i = 10; i < channels; i++)
-    val[i] = _Tp(0);
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5,
-                             _Tp v6, _Tp v7, _Tp v8, _Tp v9, _Tp v10, _Tp v11) {
-  CV_StaticAssert(channels >= 12, "Matx should have at least 12 elements.");
-  val[0] = v0;
-  val[1] = v1;
-  val[2] = v2;
-  val[3] = v3;
-  val[4] = v4;
-  val[5] = v5;
-  val[6] = v6;
-  val[7] = v7;
-  val[8] = v8;
-  val[9] = v9;
-  val[10] = v10;
-  val[11] = v11;
-  for (int i = 12; i < channels; i++)
-    val[i] = _Tp(0);
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5,
-                             _Tp v6, _Tp v7, _Tp v8, _Tp v9, _Tp v10, _Tp v11,
-                             _Tp v12, _Tp v13) {
-  CV_StaticAssert(channels >= 14, "Matx should have at least 14 elements.");
-  val[0] = v0;
-  val[1] = v1;
-  val[2] = v2;
-  val[3] = v3;
-  val[4] = v4;
-  val[5] = v5;
-  val[6] = v6;
-  val[7] = v7;
-  val[8] = v8;
-  val[9] = v9;
-  val[10] = v10;
-  val[11] = v11;
-  val[12] = v12;
-  val[13] = v13;
-  for (int i = 14; i < channels; i++)
-    val[i] = _Tp(0);
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5,
-                             _Tp v6, _Tp v7, _Tp v8, _Tp v9, _Tp v10, _Tp v11,
-                             _Tp v12, _Tp v13, _Tp v14, _Tp v15) {
-  CV_StaticAssert(channels >= 16, "Matx should have at least 16 elements.");
-  val[0] = v0;
-  val[1] = v1;
-  val[2] = v2;
-  val[3] = v3;
-  val[4] = v4;
-  val[5] = v5;
-  val[6] = v6;
-  val[7] = v7;
-  val[8] = v8;
-  val[9] = v9;
-  val[10] = v10;
-  val[11] = v11;
-  val[12] = v12;
-  val[13] = v13;
-  val[14] = v14;
-  val[15] = v15;
-  for (int i = 16; i < channels; i++)
-    val[i] = _Tp(0);
-}
-
-// WARNING: unreachable code using Ninja
-#if defined _MSC_VER && _MSC_VER >= 1920
-#pragma warning(push)
-#pragma warning(disable : 4702)
-#endif
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n>::Matx(const _Tp *values) {
-  for (int i = 0; i < channels; i++)
-    val[i] = values[i];
-}
-#if defined _MSC_VER && _MSC_VER >= 1920
-#pragma warning(pop)
-#endif
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n>::Matx(std::initializer_list<_Tp> list) {
-  CV_DbgAssert(list.size() == channels);
-  int i = 0;
-  for (const auto &elem : list) {
-    val[i++] = elem;
-  }
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n> Matx<_Tp, m, n>::all(_Tp alpha) {
-  Matx<_Tp, m, n> M;
-  for (int i = 0; i < m * n; i++)
-    M.val[i] = alpha;
-  return M;
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n> Matx<_Tp, m, n>::zeros() {
-  return all(0);
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n> Matx<_Tp, m, n>::ones() {
-  return all(1);
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n> Matx<_Tp, m, n>::eye() {
-  Matx<_Tp, m, n> M;
-  for (int i = 0; i < shortdim; i++)
-    M(i, i) = 1;
-  return M;
-}
-
-template <typename _Tp, int m, int n>
-inline _Tp Matx<_Tp, m, n>::dot(const Matx<_Tp, m, n> &M) const {
-  _Tp s = 0;
-  for (int i = 0; i < channels; i++)
-    s += val[i] * M.val[i];
-  return s;
-}
-
-template <typename _Tp, int m, int n>
-inline double Matx<_Tp, m, n>::ddot(const Matx<_Tp, m, n> &M) const {
-  double s = 0;
-  for (int i = 0; i < channels; i++)
-    s += (double)val[i] * M.val[i];
-  return s;
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n>
-Matx<_Tp, m, n>::diag(const typename Matx<_Tp, m, n>::diag_type &d) {
-  Matx<_Tp, m, n> M;
-  for (int i = 0; i < shortdim; i++)
-    M(i, i) = d(i, 0);
-  return M;
-}
-
-template <typename _Tp, int m, int n>
-template <typename T2>
-inline Matx<_Tp, m, n>::operator Matx<T2, m, n>() const {
-  Matx<T2, m, n> M;
-  for (int i = 0; i < m * n; i++)
-    M.val[i] = saturate_cast<T2>(val[i]);
-  return M;
-}
-
-template <typename _Tp, int m, int n>
-template <int m1, int n1>
-inline Matx<_Tp, m1, n1> Matx<_Tp, m, n>::reshape() const {
-  CV_StaticAssert(
-      m1 * n1 == m * n,
-      "Input and destination matrices must have the same number of elements");
-  return (const Matx<_Tp, m1, n1> &)*this;
-}
-
-template <typename _Tp, int m, int n>
-template <int m1, int n1>
-inline Matx<_Tp, m1, n1> Matx<_Tp, m, n>::get_minor(int base_row,
-                                                    int base_col) const {
-  CV_DbgAssert(0 <= base_row && base_row + m1 <= m && 0 <= base_col &&
-               base_col + n1 <= n);
-  Matx<_Tp, m1, n1> s;
-  for (int di = 0; di < m1; di++)
-    for (int dj = 0; dj < n1; dj++)
-      s(di, dj) = (*this)(base_row + di, base_col + dj);
-  return s;
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, 1, n> Matx<_Tp, m, n>::row(int i) const {
-  CV_DbgAssert((unsigned)i < (unsigned)m);
-  return Matx<_Tp, 1, n>(&val[i * n]);
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, 1> Matx<_Tp, m, n>::col(int j) const {
-  CV_DbgAssert((unsigned)j < (unsigned)n);
-  Matx<_Tp, m, 1> v;
-  for (int i = 0; i < m; i++)
-    v.val[i] = val[i * n + j];
-  return v;
-}
-
-template <typename _Tp, int m, int n>
-inline typename Matx<_Tp, m, n>::diag_type Matx<_Tp, m, n>::diag() const {
-  diag_type d;
-  for (int i = 0; i < shortdim; i++)
-    d.val[i] = val[i * n + i];
-  return d;
-}
-
-template <typename _Tp, int m, int n>
-inline const _Tp &Matx<_Tp, m, n>::operator()(int row_idx, int col_idx) const {
-  CV_DbgAssert((unsigned)row_idx < (unsigned)m &&
-               (unsigned)col_idx < (unsigned)n);
-  return this->val[row_idx * n + col_idx];
-}
-
-template <typename _Tp, int m, int n>
-inline _Tp &Matx<_Tp, m, n>::operator()(int row_idx, int col_idx) {
-  CV_DbgAssert((unsigned)row_idx < (unsigned)m &&
-               (unsigned)col_idx < (unsigned)n);
-  return val[row_idx * n + col_idx];
-}
-
-template <typename _Tp, int m, int n>
-inline const _Tp &Matx<_Tp, m, n>::operator()(int i) const {
-  CV_StaticAssert(
-      m == 1 || n == 1,
-      "Single index indexation requires matrix to be a column or a row");
-  CV_DbgAssert((unsigned)i < (unsigned)(m + n - 1));
-  return val[i];
-}
-
-template <typename _Tp, int m, int n>
-inline _Tp &Matx<_Tp, m, n>::operator()(int i) {
-  CV_StaticAssert(
-      m == 1 || n == 1,
-      "Single index indexation requires matrix to be a column or a row");
-  CV_DbgAssert((unsigned)i < (unsigned)(m + n - 1));
-  return val[i];
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n>::Matx(const Matx<_Tp, m, n> &a, const Matx<_Tp, m, n> &b,
-                             Matx_AddOp) {
-  for (int i = 0; i < channels; i++)
-    val[i] = saturate_cast<_Tp>(a.val[i] + b.val[i]);
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n>::Matx(const Matx<_Tp, m, n> &a, const Matx<_Tp, m, n> &b,
-                             Matx_SubOp) {
-  for (int i = 0; i < channels; i++)
-    val[i] = saturate_cast<_Tp>(a.val[i] - b.val[i]);
-}
-
-template <typename _Tp, int m, int n>
-template <typename _T2>
-inline Matx<_Tp, m, n>::Matx(const Matx<_Tp, m, n> &a, _T2 alpha,
-                             Matx_ScaleOp) {
-  for (int i = 0; i < channels; i++)
-    val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n>::Matx(const Matx<_Tp, m, n> &a, const Matx<_Tp, m, n> &b,
-                             Matx_MulOp) {
-  for (int i = 0; i < channels; i++)
-    val[i] = saturate_cast<_Tp>(a.val[i] * b.val[i]);
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n>::Matx(const Matx<_Tp, m, n> &a, const Matx<_Tp, m, n> &b,
-                             Matx_DivOp) {
-  for (int i = 0; i < channels; i++)
-    val[i] = saturate_cast<_Tp>(a.val[i] / b.val[i]);
-}
-
-template <typename _Tp, int m, int n>
-template <int l>
-inline Matx<_Tp, m, n>::Matx(const Matx<_Tp, m, l> &a, const Matx<_Tp, l, n> &b,
-                             Matx_MatMulOp) {
-  for (int i = 0; i < m; i++)
-    for (int j = 0; j < n; j++) {
-      _Tp s = 0;
-      for (int k = 0; k < l; k++)
-        s += a(i, k) * b(k, j);
-      val[i * n + j] = s;
-    }
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n>::Matx(const Matx<_Tp, n, m> &a, Matx_TOp) {
-  for (int i = 0; i < m; i++)
-    for (int j = 0; j < n; j++)
-      val[i * n + j] = a(j, i);
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n> Matx<_Tp, m, n>::mul(const Matx<_Tp, m, n> &a) const {
-  return Matx<_Tp, m, n>(*this, a, Matx_MulOp());
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n> Matx<_Tp, m, n>::div(const Matx<_Tp, m, n> &a) const {
-  return Matx<_Tp, m, n>(*this, a, Matx_DivOp());
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, n, m> Matx<_Tp, m, n>::t() const {
-  return Matx<_Tp, n, m>(*this, Matx_TOp());
-}
-
-template <typename _Tp, int m, int n>
-inline Vec<_Tp, n> Matx<_Tp, m, n>::solve(const Vec<_Tp, m> &rhs,
-                                          int method) const {
-  Matx<_Tp, n, 1> x = solve((const Matx<_Tp, m, 1> &)(rhs), method);
-  return (Vec<_Tp, n> &)(x);
-}
-
-template <typename _Tp, int m>
-static inline double determinant(const Matx<_Tp, m, m> &a) {
-  return cv::internal::Matx_DetOp<_Tp, m>()(a);
-}
-
-template <typename _Tp, int m, int n>
-static inline double trace(const Matx<_Tp, m, n> &a) {
-  _Tp s = 0;
-  for (int i = 0; i < std::min(m, n); i++)
-    s += a(i, i);
-  return s;
-}
-
-template <typename _Tp, int m, int n>
-static inline double norm(const Matx<_Tp, m, n> &M) {
-  return std::sqrt(normL2Sqr<_Tp, double>(M.val, m * n));
-}
-
-template <typename _Tp, int m, int n>
-static inline double norm(const Matx<_Tp, m, n> &M, int normType) {
-  switch (normType) {
-  case NORM_INF:
-    return (double)normInf<_Tp, typename DataType<_Tp>::work_type>(M.val,
-                                                                   m * n);
-  case NORM_L1:
-    return (double)normL1<_Tp, typename DataType<_Tp>::work_type>(M.val, m * n);
-  case NORM_L2SQR:
-    return (double)normL2Sqr<_Tp, typename DataType<_Tp>::work_type>(M.val,
-                                                                     m * n);
-  default:
-  case NORM_L2:
-    return std::sqrt((double)normL2Sqr<_Tp, typename DataType<_Tp>::work_type>(
-        M.val, m * n));
-  }
-}
-
-template <typename _Tp1, typename _Tp2, int m, int n>
-static inline Matx<_Tp1, m, n> &operator+=(Matx<_Tp1, m, n> &a,
-                                           const Matx<_Tp2, m, n> &b) {
-  for (int i = 0; i < m * n; i++)
-    a.val[i] = saturate_cast<_Tp1>(a.val[i] + b.val[i]);
-  return a;
-}
-
-template <typename _Tp1, typename _Tp2, int m, int n>
-static inline Matx<_Tp1, m, n> &operator-=(Matx<_Tp1, m, n> &a,
-                                           const Matx<_Tp2, m, n> &b) {
-  for (int i = 0; i < m * n; i++)
-    a.val[i] = saturate_cast<_Tp1>(a.val[i] - b.val[i]);
-  return a;
-}
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> operator+(const Matx<_Tp, m, n> &a,
-                                        const Matx<_Tp, m, n> &b) {
-  return Matx<_Tp, m, n>(a, b, Matx_AddOp());
-}
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> operator-(const Matx<_Tp, m, n> &a,
-                                        const Matx<_Tp, m, n> &b) {
-  return Matx<_Tp, m, n>(a, b, Matx_SubOp());
-}
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> &operator*=(Matx<_Tp, m, n> &a, int alpha) {
-  for (int i = 0; i < m * n; i++)
-    a.val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
-  return a;
-}
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> &operator*=(Matx<_Tp, m, n> &a, float alpha) {
-  for (int i = 0; i < m * n; i++)
-    a.val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
-  return a;
-}
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> &operator*=(Matx<_Tp, m, n> &a, double alpha) {
-  for (int i = 0; i < m * n; i++)
-    a.val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
-  return a;
-}
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> operator*(const Matx<_Tp, m, n> &a, int alpha) {
-  return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
-}
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> operator*(const Matx<_Tp, m, n> &a, float alpha) {
-  return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
-}
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> operator*(const Matx<_Tp, m, n> &a,
-                                        double alpha) {
-  return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
-}
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> operator*(int alpha, const Matx<_Tp, m, n> &a) {
-  return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
-}
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> operator*(float alpha, const Matx<_Tp, m, n> &a) {
-  return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
-}
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> operator*(double alpha,
-                                        const Matx<_Tp, m, n> &a) {
-  return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
-}
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> &operator/=(Matx<_Tp, m, n> &a, float alpha) {
-  for (int i = 0; i < m * n; i++)
-    a.val[i] = a.val[i] / alpha;
-  return a;
-}
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> &operator/=(Matx<_Tp, m, n> &a, double alpha) {
-  for (int i = 0; i < m * n; i++)
-    a.val[i] = a.val[i] / alpha;
-  return a;
-}
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> operator/(const Matx<_Tp, m, n> &a, float alpha) {
-  return Matx<_Tp, m, n>(a, 1.f / alpha, Matx_ScaleOp());
-}
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> operator/(const Matx<_Tp, m, n> &a,
-                                        double alpha) {
-  return Matx<_Tp, m, n>(a, 1. / alpha, Matx_ScaleOp());
-}
-
-template <typename _Tp, int m, int n>
-static inline Matx<_Tp, m, n> operator-(const Matx<_Tp, m, n> &a) {
-  return Matx<_Tp, m, n>(a, -1, Matx_ScaleOp());
-}
-
-template <typename _Tp, int m, int n, int l>
-static inline Matx<_Tp, m, n> operator*(const Matx<_Tp, m, l> &a,
-                                        const Matx<_Tp, l, n> &b) {
-  return Matx<_Tp, m, n>(a, b, Matx_MatMulOp());
-}
-
-template <typename _Tp, int m, int n>
-static inline Vec<_Tp, m> operator*(const Matx<_Tp, m, n> &a,
-                                    const Vec<_Tp, n> &b) {
-  Matx<_Tp, m, 1> c(a, b, Matx_MatMulOp());
-  return (const Vec<_Tp, m> &)(c);
-}
-
-template <typename _Tp, int m, int n>
-static inline bool operator==(const Matx<_Tp, m, n> &a,
-                              const Matx<_Tp, m, n> &b) {
-  for (int i = 0; i < m * n; i++)
-    if (a.val[i] != b.val[i])
-      return false;
-  return true;
-}
-
-template <typename _Tp, int m, int n>
-static inline bool operator!=(const Matx<_Tp, m, n> &a,
-                              const Matx<_Tp, m, n> &b) {
-  return !(a == b);
-}
-
-//==============================================================================
-// Vec
-
-template <typename _Tp, int cn> class DataType<Vec<_Tp, cn>> {
-public:
-  typedef Vec<_Tp, cn> value_type;
-  typedef Vec<typename DataType<_Tp>::work_type, cn> work_type;
-  typedef _Tp channel_type;
-  typedef value_type vec_type;
-
-  enum {
-    generic_type = 0,
-    channels = cn,
-    fmt = DataType<channel_type>::fmt + ((channels - 1) << 8),
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-    depth = DataType<channel_type>::depth,
-    type = CV_MAKETYPE(depth, channels),
-#endif
-    _dummy_enum_finalizer = 0
-  };
-};
-
-namespace traits {
-template <typename _Tp, int cn> struct Depth<Vec<_Tp, cn>> {
-  enum { value = Depth<_Tp>::value };
-};
-template <typename _Tp, int cn> struct Type<Vec<_Tp, cn>> {
-  enum { value = CV_MAKETYPE(Depth<_Tp>::value, cn) };
-};
-} // namespace traits
-
-/** @brief  Comma-separated Vec Initializer
- */
-template <typename _Tp, int m>
-class VecCommaInitializer : public MatxCommaInitializer<_Tp, m, 1> {
-public:
-  VecCommaInitializer(Vec<_Tp, m> *_vec);
-  template <typename T2> VecCommaInitializer<_Tp, m> &operator,(T2 val);
-  Vec<_Tp, m> operator*() const;
-};
-
-template <typename _Tp, typename _T2, int cn>
-static inline VecCommaInitializer<_Tp, cn> operator<<(const Vec<_Tp, cn> &vec,
-                                                      _T2 val) {
-  VecCommaInitializer<_Tp, cn> commaInitializer((Vec<_Tp, cn> *)&vec);
-  return (commaInitializer, val);
-}
-
-template <typename _Tp, int cn>
-inline VecCommaInitializer<_Tp, cn>::VecCommaInitializer(Vec<_Tp, cn> *_vec)
-    : MatxCommaInitializer<_Tp, cn, 1>(_vec) {}
-
-template <typename _Tp, int cn>
-template <typename _T2>
-inline VecCommaInitializer<_Tp, cn> &VecCommaInitializer<_Tp, cn>::operator,(
-    _T2 value) {
-  CV_DbgAssert(this->idx < cn);
-  this->dst->val[this->idx++] = saturate_cast<_Tp>(value);
-  return *this;
-}
-
-template <typename _Tp, int cn>
-inline Vec<_Tp, cn> VecCommaInitializer<_Tp, cn>::operator*() const {
-  CV_DbgAssert(this->idx == cn);
-  return *this->dst;
-}
-
-template <typename _Tp, int cn> inline Vec<_Tp, cn>::Vec() {}
-
-template <typename _Tp, int cn>
-inline Vec<_Tp, cn>::Vec(_Tp v0) : Matx<_Tp, cn, 1>(v0) {}
-
-template <typename _Tp, int cn>
-inline Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1) : Matx<_Tp, cn, 1>(v0, v1) {}
-
-template <typename _Tp, int cn>
-inline Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2)
-    : Matx<_Tp, cn, 1>(v0, v1, v2) {}
-
-template <typename _Tp, int cn>
-inline Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3)
-    : Matx<_Tp, cn, 1>(v0, v1, v2, v3) {}
-
-template <typename _Tp, int cn>
-inline Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4)
-    : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4) {}
-
-template <typename _Tp, int cn>
-inline Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5)
-    : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5) {}
-
-template <typename _Tp, int cn>
-inline Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6)
-    : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5, v6) {}
-
-template <typename _Tp, int cn>
-inline Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6,
-                         _Tp v7)
-    : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5, v6, v7) {}
-
-template <typename _Tp, int cn>
-inline Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6,
-                         _Tp v7, _Tp v8)
-    : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5, v6, v7, v8) {}
-
-template <typename _Tp, int cn>
-inline Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6,
-                         _Tp v7, _Tp v8, _Tp v9)
-    : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {}
-
-template <typename _Tp, int cn>
-inline Vec<_Tp, cn>::Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6,
-                         _Tp v7, _Tp v8, _Tp v9, _Tp v10, _Tp v11, _Tp v12,
-                         _Tp v13)
-    : Matx<_Tp, cn, 1>(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
-                       v13) {}
-
-template <typename _Tp, int cn>
-inline Vec<_Tp, cn>::Vec(const _Tp *values) : Matx<_Tp, cn, 1>(values) {}
-
-template <typename _Tp, int cn>
-inline Vec<_Tp, cn>::Vec(std::initializer_list<_Tp> list)
-    : Matx<_Tp, cn, 1>(list) {}
-
-template <typename _Tp, int cn>
-inline Vec<_Tp, cn>::Vec(const Vec<_Tp, cn> &m) : Matx<_Tp, cn, 1>(m.val) {}
-
-template <typename _Tp, int cn>
-inline Vec<_Tp, cn>::Vec(const Matx<_Tp, cn, 1> &a, const Matx<_Tp, cn, 1> &b,
-                         Matx_AddOp op)
-    : Matx<_Tp, cn, 1>(a, b, op) {}
-
-template <typename _Tp, int cn>
-inline Vec<_Tp, cn>::Vec(const Matx<_Tp, cn, 1> &a, const Matx<_Tp, cn, 1> &b,
-                         Matx_SubOp op)
-    : Matx<_Tp, cn, 1>(a, b, op) {}
-
-template <typename _Tp, int cn>
-template <typename _T2>
-inline Vec<_Tp, cn>::Vec(const Matx<_Tp, cn, 1> &a, _T2 alpha, Matx_ScaleOp op)
-    : Matx<_Tp, cn, 1>(a, alpha, op) {}
-
-template <typename _Tp, int cn>
-inline Vec<_Tp, cn> Vec<_Tp, cn>::all(_Tp alpha) {
-  Vec v;
-  for (int i = 0; i < cn; i++)
-    v.val[i] = alpha;
-  return v;
-}
-
-template <typename _Tp, int cn> inline Vec<_Tp, cn> Vec<_Tp, cn>::ones() {
-  return Vec::all(1);
-}
-
-template <typename _Tp, int cn> inline Vec<_Tp, cn> Vec<_Tp, cn>::zeros() {
-  return Vec::all(0);
-}
-
-template <typename _Tp, int cn>
-inline Vec<_Tp, cn> Vec<_Tp, cn>::mul(const Vec<_Tp, cn> &v) const {
-  Vec<_Tp, cn> w;
-  for (int i = 0; i < cn; i++)
-    w.val[i] = saturate_cast<_Tp>(this->val[i] * v.val[i]);
-  return w;
-}
-
-template <> inline Vec<float, 2> Vec<float, 2>::conj() const {
-  return cv::internal::conjugate(*this);
-}
-
-template <> inline Vec<double, 2> Vec<double, 2>::conj() const {
-  return cv::internal::conjugate(*this);
-}
-
-template <> inline Vec<float, 4> Vec<float, 4>::conj() const {
-  return cv::internal::conjugate(*this);
-}
-
-template <> inline Vec<double, 4> Vec<double, 4>::conj() const {
-  return cv::internal::conjugate(*this);
-}
-
-template <typename _Tp, int cn>
-inline Vec<_Tp, cn> Vec<_Tp, cn>::cross(const Vec<_Tp, cn> &) const {
-  CV_StaticAssert(
-      cn == 3, "for arbitrary-size vector there is no cross-product defined");
-  return Vec<_Tp, cn>();
-}
-
-template <>
-inline Vec<float, 3> Vec<float, 3>::cross(const Vec<float, 3> &v) const {
-  return Vec<float, 3>(this->val[1] * v.val[2] - this->val[2] * v.val[1],
-                       this->val[2] * v.val[0] - this->val[0] * v.val[2],
-                       this->val[0] * v.val[1] - this->val[1] * v.val[0]);
-}
-
-template <>
-inline Vec<double, 3> Vec<double, 3>::cross(const Vec<double, 3> &v) const {
-  return Vec<double, 3>(this->val[1] * v.val[2] - this->val[2] * v.val[1],
-                        this->val[2] * v.val[0] - this->val[0] * v.val[2],
-                        this->val[0] * v.val[1] - this->val[1] * v.val[0]);
-}
-
-template <typename _Tp, int cn>
-template <typename T2>
-inline Vec<_Tp, cn>::operator Vec<T2, cn>() const {
-  Vec<T2, cn> v;
-  for (int i = 0; i < cn; i++)
-    v.val[i] = saturate_cast<T2>(this->val[i]);
-  return v;
-}
-
-template <typename _Tp, int cn>
-inline const _Tp &Vec<_Tp, cn>::operator[](int i) const {
-  CV_DbgAssert((unsigned)i < (unsigned)cn);
-  return this->val[i];
-}
-
-template <typename _Tp, int cn> inline _Tp &Vec<_Tp, cn>::operator[](int i) {
-  CV_DbgAssert((unsigned)i < (unsigned)cn);
-  return this->val[i];
-}
-
-template <typename _Tp, int cn>
-inline const _Tp &Vec<_Tp, cn>::operator()(int i) const {
-  CV_DbgAssert((unsigned)i < (unsigned)cn);
-  return this->val[i];
-}
-
-template <typename _Tp, int cn> inline _Tp &Vec<_Tp, cn>::operator()(int i) {
-  CV_DbgAssert((unsigned)i < (unsigned)cn);
-  return this->val[i];
-}
-
-template <typename _Tp, int cn>
-inline Vec<_Tp, cn> normalize(const Vec<_Tp, cn> &v) {
-  double nv = norm(v);
-  return v * (nv ? 1. / nv : 0.);
-}
-
-template <typename _Tp1, typename _Tp2, int cn>
-static inline Vec<_Tp1, cn> &operator+=(Vec<_Tp1, cn> &a,
-                                        const Vec<_Tp2, cn> &b) {
-  for (int i = 0; i < cn; i++)
-    a.val[i] = saturate_cast<_Tp1>(a.val[i] + b.val[i]);
-  return a;
-}
-
-template <typename _Tp1, typename _Tp2, int cn>
-static inline Vec<_Tp1, cn> &operator-=(Vec<_Tp1, cn> &a,
-                                        const Vec<_Tp2, cn> &b) {
-  for (int i = 0; i < cn; i++)
-    a.val[i] = saturate_cast<_Tp1>(a.val[i] - b.val[i]);
-  return a;
-}
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> operator+(const Vec<_Tp, cn> &a,
-                                     const Vec<_Tp, cn> &b) {
-  return Vec<_Tp, cn>(a, b, Matx_AddOp());
-}
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> operator-(const Vec<_Tp, cn> &a,
-                                     const Vec<_Tp, cn> &b) {
-  return Vec<_Tp, cn>(a, b, Matx_SubOp());
-}
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> &operator*=(Vec<_Tp, cn> &a, int alpha) {
-  for (int i = 0; i < cn; i++)
-    a[i] = saturate_cast<_Tp>(a[i] * alpha);
-  return a;
-}
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> &operator*=(Vec<_Tp, cn> &a, float alpha) {
-  for (int i = 0; i < cn; i++)
-    a[i] = saturate_cast<_Tp>(a[i] * alpha);
-  return a;
-}
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> &operator*=(Vec<_Tp, cn> &a, double alpha) {
-  for (int i = 0; i < cn; i++)
-    a[i] = saturate_cast<_Tp>(a[i] * alpha);
-  return a;
-}
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> &operator/=(Vec<_Tp, cn> &a, int alpha) {
-  double ialpha = 1. / alpha;
-  for (int i = 0; i < cn; i++)
-    a[i] = saturate_cast<_Tp>(a[i] * ialpha);
-  return a;
-}
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> &operator/=(Vec<_Tp, cn> &a, float alpha) {
-  float ialpha = 1.f / alpha;
-  for (int i = 0; i < cn; i++)
-    a[i] = saturate_cast<_Tp>(a[i] * ialpha);
-  return a;
-}
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> &operator/=(Vec<_Tp, cn> &a, double alpha) {
-  double ialpha = 1. / alpha;
-  for (int i = 0; i < cn; i++)
-    a[i] = saturate_cast<_Tp>(a[i] * ialpha);
-  return a;
-}
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> operator*(const Vec<_Tp, cn> &a, int alpha) {
-  return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
-}
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> operator*(int alpha, const Vec<_Tp, cn> &a) {
-  return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
-}
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> operator*(const Vec<_Tp, cn> &a, float alpha) {
-  return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
-}
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> operator*(float alpha, const Vec<_Tp, cn> &a) {
-  return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
-}
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> operator*(const Vec<_Tp, cn> &a, double alpha) {
-  return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
-}
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> operator*(double alpha, const Vec<_Tp, cn> &a) {
-  return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
-}
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> operator/(const Vec<_Tp, cn> &a, int alpha) {
-  return Vec<_Tp, cn>(a, 1. / alpha, Matx_ScaleOp());
-}
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> operator/(const Vec<_Tp, cn> &a, float alpha) {
-  return Vec<_Tp, cn>(a, 1.f / alpha, Matx_ScaleOp());
-}
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> operator/(const Vec<_Tp, cn> &a, double alpha) {
-  return Vec<_Tp, cn>(a, 1. / alpha, Matx_ScaleOp());
-}
-
-template <typename _Tp, int cn>
-static inline Vec<_Tp, cn> operator-(const Vec<_Tp, cn> &a) {
-  Vec<_Tp, cn> t;
-  for (int i = 0; i < cn; i++)
-    t.val[i] = saturate_cast<_Tp>(-a.val[i]);
-  return t;
-}
-
-template <typename _Tp>
-inline Vec<_Tp, 4> operator*(const Vec<_Tp, 4> &v1, const Vec<_Tp, 4> &v2) {
-  return Vec<_Tp, 4>(saturate_cast<_Tp>(v1[0] * v2[0] - v1[1] * v2[1] -
-                                        v1[2] * v2[2] - v1[3] * v2[3]),
-                     saturate_cast<_Tp>(v1[0] * v2[1] + v1[1] * v2[0] +
-                                        v1[2] * v2[3] - v1[3] * v2[2]),
-                     saturate_cast<_Tp>(v1[0] * v2[2] - v1[1] * v2[3] +
-                                        v1[2] * v2[0] + v1[3] * v2[1]),
-                     saturate_cast<_Tp>(v1[0] * v2[3] + v1[1] * v2[2] -
-                                        v1[2] * v2[1] + v1[3] * v2[0]));
-}
-
-template <typename _Tp>
-inline Vec<_Tp, 4> &operator*=(Vec<_Tp, 4> &v1, const Vec<_Tp, 4> &v2) {
-  v1 = v1 * v2;
-  return v1;
-}
-
-} // namespace cv
-
-#endif // OPENCV_CORE_MATX_INL_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/neon_utils.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/neon_utils.hpp
deleted file mode 100644
index 10051a814a..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/neon_utils.hpp
+++ /dev/null
@@ -1,127 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2015, Itseez Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_HAL_NEON_UTILS_HPP
-#define OPENCV_HAL_NEON_UTILS_HPP
-
-#include "opencv2/core/cvdef.h"
-
-//! @addtogroup core_utils_neon
-//! @{
-
-#if CV_NEON
-
-inline int32x2_t cv_vrnd_s32_f32(float32x2_t v) {
-  static int32x2_t v_sign = vdup_n_s32(1 << 31),
-                   v_05 = vreinterpret_s32_f32(vdup_n_f32(0.5f));
-
-  int32x2_t v_addition =
-      vorr_s32(v_05, vand_s32(v_sign, vreinterpret_s32_f32(v)));
-  return vcvt_s32_f32(vadd_f32(v, vreinterpret_f32_s32(v_addition)));
-}
-
-inline int32x4_t cv_vrndq_s32_f32(float32x4_t v) {
-  static int32x4_t v_sign = vdupq_n_s32(1 << 31),
-                   v_05 = vreinterpretq_s32_f32(vdupq_n_f32(0.5f));
-
-  int32x4_t v_addition =
-      vorrq_s32(v_05, vandq_s32(v_sign, vreinterpretq_s32_f32(v)));
-  return vcvtq_s32_f32(vaddq_f32(v, vreinterpretq_f32_s32(v_addition)));
-}
-
-inline uint32x2_t cv_vrnd_u32_f32(float32x2_t v) {
-  static float32x2_t v_05 = vdup_n_f32(0.5f);
-  return vcvt_u32_f32(vadd_f32(v, v_05));
-}
-
-inline uint32x4_t cv_vrndq_u32_f32(float32x4_t v) {
-  static float32x4_t v_05 = vdupq_n_f32(0.5f);
-  return vcvtq_u32_f32(vaddq_f32(v, v_05));
-}
-
-inline float32x4_t cv_vrecpq_f32(float32x4_t val) {
-  float32x4_t reciprocal = vrecpeq_f32(val);
-  reciprocal = vmulq_f32(vrecpsq_f32(val, reciprocal), reciprocal);
-  reciprocal = vmulq_f32(vrecpsq_f32(val, reciprocal), reciprocal);
-  return reciprocal;
-}
-
-inline float32x2_t cv_vrecp_f32(float32x2_t val) {
-  float32x2_t reciprocal = vrecpe_f32(val);
-  reciprocal = vmul_f32(vrecps_f32(val, reciprocal), reciprocal);
-  reciprocal = vmul_f32(vrecps_f32(val, reciprocal), reciprocal);
-  return reciprocal;
-}
-
-inline float32x4_t cv_vrsqrtq_f32(float32x4_t val) {
-  float32x4_t e = vrsqrteq_f32(val);
-  e = vmulq_f32(vrsqrtsq_f32(vmulq_f32(e, e), val), e);
-  e = vmulq_f32(vrsqrtsq_f32(vmulq_f32(e, e), val), e);
-  return e;
-}
-
-inline float32x2_t cv_vrsqrt_f32(float32x2_t val) {
-  float32x2_t e = vrsqrte_f32(val);
-  e = vmul_f32(vrsqrts_f32(vmul_f32(e, e), val), e);
-  e = vmul_f32(vrsqrts_f32(vmul_f32(e, e), val), e);
-  return e;
-}
-
-inline float32x4_t cv_vsqrtq_f32(float32x4_t val) {
-  return cv_vrecpq_f32(cv_vrsqrtq_f32(val));
-}
-
-inline float32x2_t cv_vsqrt_f32(float32x2_t val) {
-  return cv_vrecp_f32(cv_vrsqrt_f32(val));
-}
-
-#endif
-
-//! @}
-
-#endif // OPENCV_HAL_NEON_UTILS_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/operations.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/operations.hpp
deleted file mode 100644
index 14333b219a..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/operations.hpp
+++ /dev/null
@@ -1,610 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                           License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Copyright (C) 2015, Itseez Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_CORE_OPERATIONS_HPP
-#define OPENCV_CORE_OPERATIONS_HPP
-
-#ifndef __cplusplus
-#error operations.hpp header must be compiled as C++
-#endif
-
-#include <cstdio>
-
-#if defined(__GNUC__) || defined(__clang__) // at least GCC 3.1+, clang 3.5+
-#if defined(                                                                   \
-    __MINGW_PRINTF_FORMAT) // https://sourceforge.net/p/mingw-w64/wiki2/gnu%20printf/.
-#define CV_FORMAT_PRINTF(string_idx, first_to_check)                           \
-  __attribute__((format(__MINGW_PRINTF_FORMAT, string_idx, first_to_check)))
-#else
-#define CV_FORMAT_PRINTF(string_idx, first_to_check)                           \
-  __attribute__((format(printf, string_idx, first_to_check)))
-#endif
-#else
-#define CV_FORMAT_PRINTF(A, B)
-#endif
-
-namespace cv {
-//! @cond IGNORED
-
-////////////////////////////// Matx methods depending on core API
-////////////////////////////////
-
-namespace internal {
-
-template <typename _Tp, int m, int n> struct Matx_FastInvOp {
-  bool operator()(const Matx<_Tp, m, n> &a, Matx<_Tp, n, m> &b,
-                  int method) const {
-    return invert(a, b, method) != 0;
-  }
-};
-
-template <typename _Tp, int m> struct Matx_FastInvOp<_Tp, m, m> {
-  bool operator()(const Matx<_Tp, m, m> &a, Matx<_Tp, m, m> &b,
-                  int method) const {
-    if (method == DECOMP_LU || method == DECOMP_CHOLESKY) {
-      Matx<_Tp, m, m> temp = a;
-
-      // assume that b is all 0's on input => make it a unity matrix
-      for (int i = 0; i < m; i++)
-        b(i, i) = (_Tp)1;
-
-      if (method == DECOMP_CHOLESKY)
-        return Cholesky(temp.val, m * sizeof(_Tp), m, b.val, m * sizeof(_Tp),
-                        m);
-
-      return LU(temp.val, m * sizeof(_Tp), m, b.val, m * sizeof(_Tp), m) != 0;
-    } else {
-      return invert(a, b, method) != 0;
-    }
-  }
-};
-
-template <typename _Tp> struct Matx_FastInvOp<_Tp, 2, 2> {
-  bool operator()(const Matx<_Tp, 2, 2> &a, Matx<_Tp, 2, 2> &b,
-                  int /*method*/) const {
-    _Tp d = (_Tp)determinant(a);
-    if (d == 0)
-      return false;
-    d = 1 / d;
-    b(1, 1) = a(0, 0) * d;
-    b(0, 0) = a(1, 1) * d;
-    b(0, 1) = -a(0, 1) * d;
-    b(1, 0) = -a(1, 0) * d;
-    return true;
-  }
-};
-
-template <typename _Tp> struct Matx_FastInvOp<_Tp, 3, 3> {
-  bool operator()(const Matx<_Tp, 3, 3> &a, Matx<_Tp, 3, 3> &b,
-                  int /*method*/) const {
-    _Tp d = (_Tp)determinant(a);
-    if (d == 0)
-      return false;
-    d = 1 / d;
-    b(0, 0) = (a(1, 1) * a(2, 2) - a(1, 2) * a(2, 1)) * d;
-    b(0, 1) = (a(0, 2) * a(2, 1) - a(0, 1) * a(2, 2)) * d;
-    b(0, 2) = (a(0, 1) * a(1, 2) - a(0, 2) * a(1, 1)) * d;
-
-    b(1, 0) = (a(1, 2) * a(2, 0) - a(1, 0) * a(2, 2)) * d;
-    b(1, 1) = (a(0, 0) * a(2, 2) - a(0, 2) * a(2, 0)) * d;
-    b(1, 2) = (a(0, 2) * a(1, 0) - a(0, 0) * a(1, 2)) * d;
-
-    b(2, 0) = (a(1, 0) * a(2, 1) - a(1, 1) * a(2, 0)) * d;
-    b(2, 1) = (a(0, 1) * a(2, 0) - a(0, 0) * a(2, 1)) * d;
-    b(2, 2) = (a(0, 0) * a(1, 1) - a(0, 1) * a(1, 0)) * d;
-    return true;
-  }
-};
-
-template <typename _Tp, int m, int l, int n> struct Matx_FastSolveOp {
-  bool operator()(const Matx<_Tp, m, l> &a, const Matx<_Tp, m, n> &b,
-                  Matx<_Tp, l, n> &x, int method) const {
-    return cv::solve(a, b, x, method);
-  }
-};
-
-template <typename _Tp, int m, int n> struct Matx_FastSolveOp<_Tp, m, m, n> {
-  bool operator()(const Matx<_Tp, m, m> &a, const Matx<_Tp, m, n> &b,
-                  Matx<_Tp, m, n> &x, int method) const {
-    if (method == DECOMP_LU || method == DECOMP_CHOLESKY) {
-      Matx<_Tp, m, m> temp = a;
-      x = b;
-      if (method == DECOMP_CHOLESKY)
-        return Cholesky(temp.val, m * sizeof(_Tp), m, x.val, n * sizeof(_Tp),
-                        n);
-
-      return LU(temp.val, m * sizeof(_Tp), m, x.val, n * sizeof(_Tp), n) != 0;
-    } else {
-      return cv::solve(a, b, x, method);
-    }
-  }
-};
-
-template <typename _Tp> struct Matx_FastSolveOp<_Tp, 2, 2, 1> {
-  bool operator()(const Matx<_Tp, 2, 2> &a, const Matx<_Tp, 2, 1> &b,
-                  Matx<_Tp, 2, 1> &x, int) const {
-    _Tp d = (_Tp)determinant(a);
-    if (d == 0)
-      return false;
-    d = 1 / d;
-    x(0) = (b(0) * a(1, 1) - b(1) * a(0, 1)) * d;
-    x(1) = (b(1) * a(0, 0) - b(0) * a(1, 0)) * d;
-    return true;
-  }
-};
-
-template <typename _Tp> struct Matx_FastSolveOp<_Tp, 3, 3, 1> {
-  bool operator()(const Matx<_Tp, 3, 3> &a, const Matx<_Tp, 3, 1> &b,
-                  Matx<_Tp, 3, 1> &x, int) const {
-    _Tp d = (_Tp)determinant(a);
-    if (d == 0)
-      return false;
-    d = 1 / d;
-    x(0) = d * (b(0) * (a(1, 1) * a(2, 2) - a(1, 2) * a(2, 1)) -
-                a(0, 1) * (b(1) * a(2, 2) - a(1, 2) * b(2)) +
-                a(0, 2) * (b(1) * a(2, 1) - a(1, 1) * b(2)));
-
-    x(1) = d * (a(0, 0) * (b(1) * a(2, 2) - a(1, 2) * b(2)) -
-                b(0) * (a(1, 0) * a(2, 2) - a(1, 2) * a(2, 0)) +
-                a(0, 2) * (a(1, 0) * b(2) - b(1) * a(2, 0)));
-
-    x(2) = d * (a(0, 0) * (a(1, 1) * b(2) - b(1) * a(2, 1)) -
-                a(0, 1) * (a(1, 0) * b(2) - b(1) * a(2, 0)) +
-                b(0) * (a(1, 0) * a(2, 1) - a(1, 1) * a(2, 0)));
-    return true;
-  }
-};
-
-} // namespace internal
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n> Matx<_Tp, m, n>::randu(_Tp a, _Tp b) {
-  Matx<_Tp, m, n> M;
-  cv::randu(M, Scalar(a), Scalar(b));
-  return M;
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, m, n> Matx<_Tp, m, n>::randn(_Tp a, _Tp b) {
-  Matx<_Tp, m, n> M;
-  cv::randn(M, Scalar(a), Scalar(b));
-  return M;
-}
-
-template <typename _Tp, int cn>
-inline Vec<_Tp, cn> Vec<_Tp, cn>::randu(_Tp a, _Tp b) {
-  Vec<_Tp, cn> V;
-  cv::randu(V, Scalar(a), Scalar(b));
-  return V;
-}
-
-template <typename _Tp, int cn>
-inline Vec<_Tp, cn> Vec<_Tp, cn>::randn(_Tp a, _Tp b) {
-  Vec<_Tp, cn> V;
-  cv::randn(V, Scalar(a), Scalar(b));
-  return V;
-}
-
-template <typename _Tp, int m, int n>
-inline Matx<_Tp, n, m> Matx<_Tp, m, n>::inv(int method,
-                                            bool *p_is_ok /*= NULL*/) const {
-  Matx<_Tp, n, m> b;
-  bool ok = cv::internal::Matx_FastInvOp<_Tp, m, n>()(*this, b, method);
-  if (p_is_ok)
-    *p_is_ok = ok;
-  return ok ? b : Matx<_Tp, n, m>::zeros();
-}
-
-template <typename _Tp, int m, int n>
-template <int l>
-inline Matx<_Tp, n, l> Matx<_Tp, m, n>::solve(const Matx<_Tp, m, l> &rhs,
-                                              int method) const {
-  Matx<_Tp, n, l> x;
-  bool ok =
-      cv::internal::Matx_FastSolveOp<_Tp, m, n, l>()(*this, rhs, x, method);
-  return ok ? x : Matx<_Tp, n, l>::zeros();
-}
-
-////////////////////////// Augmenting algebraic & logical operations
-/////////////////////////////
-
-#define CV_MAT_AUG_OPERATOR1(op, cvop, A, B)                                   \
-  static inline A &operator op(A & a, const B & b) {                           \
-    cvop;                                                                      \
-    return a;                                                                  \
-  }
-
-#define CV_MAT_AUG_OPERATOR(op, cvop, A, B)                                    \
-  CV_MAT_AUG_OPERATOR1(op, cvop, A, B)                                         \
-  CV_MAT_AUG_OPERATOR1(op, cvop, const A, B)
-
-#define CV_MAT_AUG_OPERATOR_T(op, cvop, A, B)                                  \
-  template <typename _Tp>                                                      \
-  CV_MAT_AUG_OPERATOR1(op, cvop, A, B)                                         \
-  template <typename _Tp>                                                      \
-  CV_MAT_AUG_OPERATOR1(op, cvop, const A, B)
-
-#define CV_MAT_AUG_OPERATOR_TN(op, cvop, A)                                    \
-  template <typename _Tp, int m, int n>                                        \
-  static inline A &operator op(A & a, const Matx<_Tp, m, n> &b) {              \
-    cvop;                                                                      \
-    return a;                                                                  \
-  }                                                                            \
-  template <typename _Tp, int m, int n>                                        \
-  static inline const A &operator op(const A & a, const Matx<_Tp, m, n> &b) {  \
-    cvop;                                                                      \
-    return a;                                                                  \
-  }
-
-CV_MAT_AUG_OPERATOR(+=, cv::add(a, b, (const Mat &)a), Mat, Mat)
-CV_MAT_AUG_OPERATOR(+=, cv::add(a, b, (const Mat &)a), Mat, Scalar)
-CV_MAT_AUG_OPERATOR_T(+=, cv::add(a, b, (const Mat &)a), Mat_<_Tp>, Mat)
-CV_MAT_AUG_OPERATOR_T(+=, cv::add(a, b, (const Mat &)a), Mat_<_Tp>, Scalar)
-CV_MAT_AUG_OPERATOR_T(+=, cv::add(a, b, (const Mat &)a), Mat_<_Tp>, Mat_<_Tp>)
-CV_MAT_AUG_OPERATOR_TN(+=, cv::add(a, Mat(b), (const Mat &)a), Mat)
-CV_MAT_AUG_OPERATOR_TN(+=, cv::add(a, Mat(b), (const Mat &)a), Mat_<_Tp>)
-
-CV_MAT_AUG_OPERATOR(-=, cv::subtract(a, b, (const Mat &)a), Mat, Mat)
-CV_MAT_AUG_OPERATOR(-=, cv::subtract(a, b, (const Mat &)a), Mat, Scalar)
-CV_MAT_AUG_OPERATOR_T(-=, cv::subtract(a, b, (const Mat &)a), Mat_<_Tp>, Mat)
-CV_MAT_AUG_OPERATOR_T(-=, cv::subtract(a, b, (const Mat &)a), Mat_<_Tp>, Scalar)
-CV_MAT_AUG_OPERATOR_T(-=, cv::subtract(a, b, (const Mat &)a), Mat_<_Tp>,
-                      Mat_<_Tp>)
-CV_MAT_AUG_OPERATOR_TN(-=, cv::subtract(a, Mat(b), (const Mat &)a), Mat)
-CV_MAT_AUG_OPERATOR_TN(-=, cv::subtract(a, Mat(b), (const Mat &)a), Mat_<_Tp>)
-
-CV_MAT_AUG_OPERATOR(*=, cv::gemm(a, b, 1, Mat(), 0, a, 0), Mat, Mat)
-CV_MAT_AUG_OPERATOR_T(*=, cv::gemm(a, b, 1, Mat(), 0, a, 0), Mat_<_Tp>, Mat)
-CV_MAT_AUG_OPERATOR_T(*=, cv::gemm(a, b, 1, Mat(), 0, a, 0), Mat_<_Tp>,
-                      Mat_<_Tp>)
-CV_MAT_AUG_OPERATOR(*=, a.convertTo(a, -1, b), Mat, double)
-CV_MAT_AUG_OPERATOR_T(*=, a.convertTo(a, -1, b), Mat_<_Tp>, double)
-CV_MAT_AUG_OPERATOR_TN(*=, cv::gemm(a, Mat(b), 1, Mat(), 0, a, 0), Mat)
-CV_MAT_AUG_OPERATOR_TN(*=, cv::gemm(a, Mat(b), 1, Mat(), 0, a, 0), Mat_<_Tp>)
-
-CV_MAT_AUG_OPERATOR(/=, cv::divide(a, b, (const Mat &)a), Mat, Mat)
-CV_MAT_AUG_OPERATOR_T(/=, cv::divide(a, b, (const Mat &)a), Mat_<_Tp>, Mat)
-CV_MAT_AUG_OPERATOR_T(/=, cv::divide(a, b, (const Mat &)a), Mat_<_Tp>,
-                      Mat_<_Tp>)
-CV_MAT_AUG_OPERATOR(/=, a.convertTo((Mat &)a, -1, 1. / b), Mat, double)
-CV_MAT_AUG_OPERATOR_T(/=, a.convertTo((Mat &)a, -1, 1. / b), Mat_<_Tp>, double)
-CV_MAT_AUG_OPERATOR_TN(/=, cv::divide(a, Mat(b), (const Mat &)a), Mat)
-CV_MAT_AUG_OPERATOR_TN(/=, cv::divide(a, Mat(b), (const Mat &)a), Mat_<_Tp>)
-
-CV_MAT_AUG_OPERATOR(&=, cv::bitwise_and(a, b, (const Mat &)a), Mat, Mat)
-CV_MAT_AUG_OPERATOR(&=, cv::bitwise_and(a, b, (const Mat &)a), Mat, Scalar)
-CV_MAT_AUG_OPERATOR_T(&=, cv::bitwise_and(a, b, (const Mat &)a), Mat_<_Tp>, Mat)
-CV_MAT_AUG_OPERATOR_T(&=, cv::bitwise_and(a, b, (const Mat &)a), Mat_<_Tp>,
-                      Scalar)
-CV_MAT_AUG_OPERATOR_T(&=, cv::bitwise_and(a, b, (const Mat &)a), Mat_<_Tp>,
-                      Mat_<_Tp>)
-CV_MAT_AUG_OPERATOR_TN(&=, cv::bitwise_and(a, Mat(b), (const Mat &)a), Mat)
-CV_MAT_AUG_OPERATOR_TN(&=, cv::bitwise_and(a, Mat(b), (const Mat &)a),
-                       Mat_<_Tp>)
-
-CV_MAT_AUG_OPERATOR(|=, cv::bitwise_or(a, b, (const Mat &)a), Mat, Mat)
-CV_MAT_AUG_OPERATOR(|=, cv::bitwise_or(a, b, (const Mat &)a), Mat, Scalar)
-CV_MAT_AUG_OPERATOR_T(|=, cv::bitwise_or(a, b, (const Mat &)a), Mat_<_Tp>, Mat)
-CV_MAT_AUG_OPERATOR_T(|=, cv::bitwise_or(a, b, (const Mat &)a), Mat_<_Tp>,
-                      Scalar)
-CV_MAT_AUG_OPERATOR_T(|=, cv::bitwise_or(a, b, (const Mat &)a), Mat_<_Tp>,
-                      Mat_<_Tp>)
-CV_MAT_AUG_OPERATOR_TN(|=, cv::bitwise_or(a, Mat(b), (const Mat &)a), Mat)
-CV_MAT_AUG_OPERATOR_TN(|=, cv::bitwise_or(a, Mat(b), (const Mat &)a), Mat_<_Tp>)
-
-CV_MAT_AUG_OPERATOR(^=, cv::bitwise_xor(a, b, (const Mat &)a), Mat, Mat)
-CV_MAT_AUG_OPERATOR(^=, cv::bitwise_xor(a, b, (const Mat &)a), Mat, Scalar)
-CV_MAT_AUG_OPERATOR_T(^=, cv::bitwise_xor(a, b, (const Mat &)a), Mat_<_Tp>, Mat)
-CV_MAT_AUG_OPERATOR_T(^=, cv::bitwise_xor(a, b, (const Mat &)a), Mat_<_Tp>,
-                      Scalar)
-CV_MAT_AUG_OPERATOR_T(^=, cv::bitwise_xor(a, b, (const Mat &)a), Mat_<_Tp>,
-                      Mat_<_Tp>)
-CV_MAT_AUG_OPERATOR_TN(^=, cv::bitwise_xor(a, Mat(b), (const Mat &)a), Mat)
-CV_MAT_AUG_OPERATOR_TN(^=, cv::bitwise_xor(a, Mat(b), (const Mat &)a),
-                       Mat_<_Tp>)
-
-#undef CV_MAT_AUG_OPERATOR_TN
-#undef CV_MAT_AUG_OPERATOR_T
-#undef CV_MAT_AUG_OPERATOR
-#undef CV_MAT_AUG_OPERATOR1
-
-///////////////////////////////////////////// SVD
-////////////////////////////////////////////////
-
-inline SVD::SVD() {}
-inline SVD::SVD(InputArray m, int flags) { operator()(m, flags); }
-inline void SVD::solveZ(InputArray m, OutputArray _dst) {
-  Mat mtx = m.getMat();
-  SVD svd(mtx, (mtx.rows >= mtx.cols ? 0 : SVD::FULL_UV));
-  _dst.create(svd.vt.cols, 1, svd.vt.type());
-  Mat dst = _dst.getMat();
-  svd.vt.row(svd.vt.rows - 1).reshape(1, svd.vt.cols).copyTo(dst);
-}
-
-template <typename _Tp, int m, int n, int nm>
-inline void SVD::compute(const Matx<_Tp, m, n> &a, Matx<_Tp, nm, 1> &w,
-                         Matx<_Tp, m, nm> &u, Matx<_Tp, n, nm> &vt) {
-  CV_StaticAssert(nm == MIN(m, n), "Invalid size of output vector.");
-  Mat _a(a, false), _u(u, false), _w(w, false), _vt(vt, false);
-  SVD::compute(_a, _w, _u, _vt);
-  CV_Assert(_w.data == (uchar *)&w.val[0] && _u.data == (uchar *)&u.val[0] &&
-            _vt.data == (uchar *)&vt.val[0]);
-}
-
-template <typename _Tp, int m, int n, int nm>
-inline void SVD::compute(const Matx<_Tp, m, n> &a, Matx<_Tp, nm, 1> &w) {
-  CV_StaticAssert(nm == MIN(m, n), "Invalid size of output vector.");
-  Mat _a(a, false), _w(w, false);
-  SVD::compute(_a, _w);
-  CV_Assert(_w.data == (uchar *)&w.val[0]);
-}
-
-template <typename _Tp, int m, int n, int nm, int nb>
-inline void SVD::backSubst(const Matx<_Tp, nm, 1> &w, const Matx<_Tp, m, nm> &u,
-                           const Matx<_Tp, n, nm> &vt,
-                           const Matx<_Tp, m, nb> &rhs, Matx<_Tp, n, nb> &dst) {
-  CV_StaticAssert(nm == MIN(m, n), "Invalid size of output vector.");
-  Mat _u(u, false), _w(w, false), _vt(vt, false), _rhs(rhs, false),
-      _dst(dst, false);
-  SVD::backSubst(_w, _u, _vt, _rhs, _dst);
-  CV_Assert(_dst.data == (uchar *)&dst.val[0]);
-}
-
-/////////////////////////////////// Multiply-with-Carry RNG
-//////////////////////////////////////
-
-inline RNG::RNG() { state = 0xffffffff; }
-inline RNG::RNG(uint64 _state) { state = _state ? _state : 0xffffffff; }
-
-inline RNG::operator uchar() { return (uchar)next(); }
-inline RNG::operator schar() { return (schar)next(); }
-inline RNG::operator ushort() { return (ushort)next(); }
-inline RNG::operator short() { return (short)next(); }
-inline RNG::operator int() { return (int)next(); }
-inline RNG::operator unsigned() { return next(); }
-inline RNG::operator float() { return next() * 2.3283064365386962890625e-10f; }
-inline RNG::operator double() {
-  unsigned t = next();
-  return (((uint64)t << 32) | next()) * 5.4210108624275221700372640043497e-20;
-}
-
-inline unsigned RNG::operator()(unsigned N) { return (unsigned)uniform(0, N); }
-inline unsigned RNG::operator()() { return next(); }
-
-inline int RNG::uniform(int a, int b) {
-  return a == b ? a : (int)(next() % (b - a) + a);
-}
-inline float RNG::uniform(float a, float b) {
-  return ((float)*this) * (b - a) + a;
-}
-inline double RNG::uniform(double a, double b) {
-  return ((double)*this) * (b - a) + a;
-}
-
-inline bool RNG::operator==(const RNG &other) const {
-  return state == other.state;
-}
-
-inline unsigned RNG::next() {
-  state = (uint64)(unsigned)state * /*CV_RNG_COEFF*/ 4164903690U +
-          (unsigned)(state >> 32);
-  return (unsigned)state;
-}
-
-//! returns the next uniformly-distributed random number of the specified type
-template <typename _Tp> static inline _Tp randu() { return (_Tp)theRNG(); }
-
-///////////////////////////////// Formatted output of cv::Mat
-////////////////////////////////////
-
-static inline Ptr<Formatted> format(InputArray mtx, Formatter::FormatType fmt) {
-  return Formatter::get(fmt)->format(mtx.getMat());
-}
-
-static inline int print(Ptr<Formatted> fmtd, FILE *stream = stdout) {
-  int written = 0;
-  fmtd->reset();
-  for (const char *str = fmtd->next(); str; str = fmtd->next())
-    written += fputs(str, stream);
-
-  return written;
-}
-
-static inline int print(const Mat &mtx, FILE *stream = stdout) {
-  return print(Formatter::get()->format(mtx), stream);
-}
-
-template <typename _Tp>
-static inline int print(const std::vector<Point_<_Tp>> &vec,
-                        FILE *stream = stdout) {
-  return print(Formatter::get()->format(Mat(vec)), stream);
-}
-
-template <typename _Tp>
-static inline int print(const std::vector<Point3_<_Tp>> &vec,
-                        FILE *stream = stdout) {
-  return print(Formatter::get()->format(Mat(vec)), stream);
-}
-
-template <typename _Tp, int m, int n>
-static inline int print(const Matx<_Tp, m, n> &matx, FILE *stream = stdout) {
-  return print(Formatter::get()->format(cv::Mat(matx)), stream);
-}
-
-//! @endcond
-
-///////////////////////////////// Formatted string generation
-////////////////////////////////////
-
-/** @brief Returns a text string formatted using the printf-like expression.
-
-The function acts like sprintf but forms and returns an STL string. It can be
-used to form an error message in the Exception constructor.
-@param fmt printf-compatible formatting specifiers.
-
-**Note**:
-|Type|Specifier|
-|-|-|
-|`const char*`|`%s`|
-|`char`|`%c`|
-|`float` / `double`|`%f`,`%g`|
-|`int`, `long`, `long long`|`%d`, `%ld`, ``%lld`|
-|`unsigned`, `unsigned long`, `unsigned long long`|`%u`, `%lu`, `%llu`|
-|`uint64` -> `uintmax_t`, `int64` -> `intmax_t`|`%ju`, `%jd`|
-|`size_t`|`%zu`|
-@ingroup core_utils
- */
-CV_EXPORTS String format(const char *fmt, ...) CV_FORMAT_PRINTF(1, 2);
-
-/****************************************************************************************\
-*                                  Auxiliary algorithms *
-\****************************************************************************************/
-
-/** @brief Splits an element set into equivalency classes.
-
-The generic function partition implements an \f$O(N^2)\f$ algorithm for
-splitting a set of \f$N\f$ elements into one or more equivalency classes, as
-described in <http://en.wikipedia.org/wiki/Disjoint-set_data_structure> . The
-function returns the number of equivalency classes.
-@param vec Set of elements stored as a vector.
-@param labels Output vector of labels. It contains as many elements as vec. Each
-label labels[i] is a 0-based cluster index of `vec[i]`.
-@param predicate Equivalence predicate (pointer to a boolean function of two
-arguments or an instance of the class that has the method bool operator()(const
-_Tp& a, const _Tp& b) ). The predicate returns true when the elements are
-certainly in the same class, and returns false if they may or may not be in the
-same class.
-@ingroup core_cluster
-*/
-template <typename _Tp, class _EqPredicate>
-int partition(const std::vector<_Tp> &vec, std::vector<int> &labels,
-              _EqPredicate predicate = _EqPredicate()) {
-  int i, j, N = (int)vec.size();
-  const _Tp *_vec = &vec[0];
-
-  const int PARENT = 0;
-  const int RANK = 1;
-
-  std::vector<int> _nodes(N * 2);
-  int (*nodes)[2] = (int (*)[2]) & _nodes[0];
-
-  // The first O(N) pass: create N single-vertex trees
-  for (i = 0; i < N; i++) {
-    nodes[i][PARENT] = -1;
-    nodes[i][RANK] = 0;
-  }
-
-  // The main O(N^2) pass: merge connected components
-  for (i = 0; i < N; i++) {
-    int root = i;
-
-    // find root
-    while (nodes[root][PARENT] >= 0)
-      root = nodes[root][PARENT];
-
-    for (j = 0; j < N; j++) {
-      if (i == j || !predicate(_vec[i], _vec[j]))
-        continue;
-      int root2 = j;
-
-      while (nodes[root2][PARENT] >= 0)
-        root2 = nodes[root2][PARENT];
-
-      if (root2 != root) {
-        // unite both trees
-        int rank = nodes[root][RANK], rank2 = nodes[root2][RANK];
-        if (rank > rank2)
-          nodes[root2][PARENT] = root;
-        else {
-          nodes[root][PARENT] = root2;
-          nodes[root2][RANK] += rank == rank2;
-          root = root2;
-        }
-        CV_Assert(nodes[root][PARENT] < 0);
-
-        int k = j, parent;
-
-        // compress the path from node2 to root
-        while ((parent = nodes[k][PARENT]) >= 0) {
-          nodes[k][PARENT] = root;
-          k = parent;
-        }
-
-        // compress the path from node to root
-        k = i;
-        while ((parent = nodes[k][PARENT]) >= 0) {
-          nodes[k][PARENT] = root;
-          k = parent;
-        }
-      }
-    }
-  }
-
-  // Final O(N) pass: enumerate classes
-  labels.resize(N);
-  int nclasses = 0;
-
-  for (i = 0; i < N; i++) {
-    int root = i;
-    while (nodes[root][PARENT] >= 0)
-      root = nodes[root][PARENT];
-    // re-use the rank as the class label
-    if (nodes[root][RANK] >= 0)
-      nodes[root][RANK] = ~nclasses++;
-    labels[i] = ~nodes[root][RANK];
-  }
-
-  return nclasses;
-}
-
-} // namespace cv
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/optim.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/optim.hpp
deleted file mode 100644
index c25d8e4ad5..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/optim.hpp
+++ /dev/null
@@ -1,362 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                           License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the OpenCV Foundation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_OPTIM_HPP
-#define OPENCV_OPTIM_HPP
-
-#include "opencv2/core.hpp"
-
-namespace cv {
-
-/** @addtogroup core_optim
-The algorithms in this section minimize or maximize function value within
-specified constraints or without any constraints.
-@{
-*/
-
-/** @brief Basic interface for all solvers
- */
-class CV_EXPORTS MinProblemSolver : public Algorithm {
-public:
-  /** @brief Represents function being optimized
-   */
-  class CV_EXPORTS Function {
-  public:
-    virtual ~Function() {}
-    virtual int getDims() const = 0;
-    virtual double getGradientEps() const;
-    virtual double calc(const double *x) const = 0;
-    virtual void getGradient(const double *x, double *grad);
-  };
-
-  /** @brief Getter for the optimized function.
-
-  The optimized function is represented by Function interface, which requires
-  derivatives to implement the calc(double*) and getDim() methods to evaluate
-  the function.
-
-  @return Smart-pointer to an object that implements Function interface - it
-  represents the function that is being optimized. It can be empty, if no
-  function was given so far.
-   */
-  virtual Ptr<Function> getFunction() const = 0;
-
-  /** @brief Setter for the optimized function.
-
-  *It should be called at least once before the call to* minimize(), as default
-  value is not usable.
-
-  @param f The new function to optimize.
-   */
-  virtual void setFunction(const Ptr<Function> &f) = 0;
-
-  /** @brief Getter for the previously set terminal criteria for this algorithm.
-
-  @return Deep copy of the terminal criteria used at the moment.
-   */
-  virtual TermCriteria getTermCriteria() const = 0;
-
-  /** @brief Set terminal criteria for solver.
-
-  This method *is not necessary* to be called before the first call to
-  minimize(), as the default value is sensible.
-
-  Algorithm stops when the number of function evaluations done exceeds
-  termcrit.maxCount, when the function values at the vertices of simplex are
-  within termcrit.epsilon range or simplex becomes so small that it can enclosed
-  in a box with termcrit.epsilon sides, whatever comes first.
-  @param termcrit Terminal criteria to be used, represented as cv::TermCriteria
-  structure.
-   */
-  virtual void setTermCriteria(const TermCriteria &termcrit) = 0;
-
-  /** @brief actually runs the algorithm and performs the minimization.
-
-  The sole input parameter determines the centroid of the starting simplex
-  (roughly, it tells where to start), all the others (terminal criteria, initial
-  step, function to be minimized) are supposed to be set via the setters before
-  the call to this method or the default values (not always sensible) will be
-  used.
-
-  @param x The initial point, that will become a centroid of an initial simplex.
-  After the algorithm will terminate, it will be set to the point where the
-  algorithm stops, the point of possible minimum.
-  @return The value of a function at the point found.
-   */
-  virtual double minimize(InputOutputArray x) = 0;
-};
-
-/** @brief This class is used to perform the non-linear non-constrained
-minimization of a function,
-
-defined on an `n`-dimensional Euclidean space, using the **Nelder-Mead method**,
-also known as
-**downhill simplex method**. The basic idea about the method can be obtained
-from <http://en.wikipedia.org/wiki/Nelder-Mead_method>.
-
-It should be noted, that this method, although deterministic, is rather a
-heuristic and therefore may converge to a local minima, not necessary a global
-one. It is iterative optimization technique, which at each step uses an
-information about the values of a function evaluated only at `n+1` points,
-arranged as a *simplex* in `n`-dimensional space (hence the second name of the
-method). At each step new point is chosen to evaluate function at, obtained
-value is compared with previous ones and based on this information simplex
-changes it's shape , slowly moving to the local minimum. Thus this method is
-using *only* function values to make decision, on contrary to, say, Nonlinear
-Conjugate Gradient method (which is also implemented in optim).
-
-Algorithm stops when the number of function evaluations done exceeds
-termcrit.maxCount, when the function values at the vertices of simplex are
-within termcrit.epsilon range or simplex becomes so small that it can enclosed
-in a box with termcrit.epsilon sides, whatever comes first, for some defined by
-user positive integer termcrit.maxCount and positive non-integer
-termcrit.epsilon.
-
-@note DownhillSolver is a derivative of the abstract interface
-cv::MinProblemSolver, which in turn is derived from the Algorithm interface and
-is used to encapsulate the functionality, common to all non-linear optimization
-algorithms in the optim module.
-
-@note term criteria should meet following condition:
-@code
-    termcrit.type == (TermCriteria::MAX_ITER + TermCriteria::EPS) &&
-termcrit.epsilon > 0 && termcrit.maxCount > 0
-@endcode
- */
-class CV_EXPORTS DownhillSolver : public MinProblemSolver {
-public:
-  /** @brief Returns the initial step that will be used in downhill simplex
-  algorithm.
-
-  @param step Initial step that will be used in algorithm. Note, that although
-  corresponding setter accepts column-vectors as well as row-vectors, this
-  method will return a row-vector.
-  @see DownhillSolver::setInitStep
-   */
-  virtual void getInitStep(OutputArray step) const = 0;
-
-  /** @brief Sets the initial step that will be used in downhill simplex
-  algorithm.
-
-  Step, together with initial point (given in DownhillSolver::minimize) are two
-  `n`-dimensional vectors that are used to determine the shape of initial
-  simplex. Roughly said, initial point determines the position of a simplex (it
-  will become simplex's centroid), while step determines the spread (size in
-  each dimension) of a simplex. To be more precise, if
-  \f$s,x_0\in\mathbb{R}^n\f$ are the initial step and initial point
-  respectively, the vertices of a simplex will be:
-  \f$v_0:=x_0-\frac{1}{2} s\f$ and \f$v_i:=x_0+s_i\f$ for \f$i=1,2,\dots,n\f$
-  where \f$s_i\f$ denotes projections of the initial step of *n*-th coordinate
-  (the result of projection is treated to be vector given by
-  \f$s_i:=e_i\cdot\left<e_i\cdot s\right>\f$, where \f$e_i\f$ form canonical
-  basis)
-
-  @param step Initial step that will be used in algorithm. Roughly said, it
-  determines the spread (size in each dimension) of an initial simplex.
-   */
-  virtual void setInitStep(InputArray step) = 0;
-
-  /** @brief This function returns the reference to the ready-to-use
-  DownhillSolver object.
-
-  All the parameters are optional, so this procedure can be called even without
-  parameters at all. In this case, the default values will be used. As default
-  value for terminal criteria are the only sensible ones,
-  MinProblemSolver::setFunction() and DownhillSolver::setInitStep() should be
-  called upon the obtained object, if the respective parameters were not given
-  to create(). Otherwise, the two ways (give parameters to
-  createDownhillSolver() or miss them out and call the
-  MinProblemSolver::setFunction() and DownhillSolver::setInitStep()) are
-  absolutely equivalent (and will drop the same errors in the same way, should
-  invalid input be detected).
-  @param f Pointer to the function that will be minimized, similarly to the one
-  you submit via MinProblemSolver::setFunction.
-  @param initStep Initial step, that will be used to construct the initial
-  simplex, similarly to the one you submit via MinProblemSolver::setInitStep.
-  @param termcrit Terminal criteria to the algorithm, similarly to the one you
-  submit via MinProblemSolver::setTermCriteria.
-   */
-  static Ptr<DownhillSolver>
-  create(const Ptr<MinProblemSolver::Function> &f =
-             Ptr<MinProblemSolver::Function>(),
-         InputArray initStep = Mat_<double>(1, 1, 0.0),
-         TermCriteria termcrit = TermCriteria(TermCriteria::MAX_ITER +
-                                                  TermCriteria::EPS,
-                                              5000, 0.000001));
-};
-
-/** @brief This class is used to perform the non-linear non-constrained
-minimization of a function with known gradient,
-
-defined on an *n*-dimensional Euclidean space, using the **Nonlinear Conjugate
-Gradient method**. The implementation was done based on the beautifully clear
-explanatory article [An Introduction to the Conjugate Gradient Method Without
-the Agonizing
-Pain](http://www.cs.cmu.edu/~quake-papers/painless-conjugate-gradient.pdf) by
-Jonathan Richard Shewchuk. The method can be seen as an adaptation of a standard
-Conjugate Gradient method (see, for example
-<http://en.wikipedia.org/wiki/Conjugate_gradient_method>) for numerically
-solving the systems of linear equations.
-
-It should be noted, that this method, although deterministic, is rather a
-heuristic method and therefore may converge to a local minima, not necessary a
-global one. What is even more disastrous, most of its behaviour is ruled by
-gradient, therefore it essentially cannot distinguish between local minima and
-maxima. Therefore, if it starts sufficiently near to the local maximum, it may
-converge to it. Another obvious restriction is that it should be possible to
-compute the gradient of a function at any point, thus it is preferable to have
-analytic expression for gradient and computational burden should be born by the
-user.
-
-The latter responsibility is accomplished via the getGradient method of a
-MinProblemSolver::Function interface (which represents function being
-optimized). This method takes point a point in *n*-dimensional space (first
-argument represents the array of coordinates of that point) and compute its
-gradient (it should be stored in the second argument as an array).
-
-@note class ConjGradSolver thus does not add any new methods to the basic
-MinProblemSolver interface.
-
-@note term criteria should meet following condition:
-@code
-    termcrit.type == (TermCriteria::MAX_ITER + TermCriteria::EPS) &&
-termcrit.epsilon > 0 && termcrit.maxCount > 0
-    // or
-    termcrit.type == TermCriteria::MAX_ITER) && termcrit.maxCount > 0
-@endcode
- */
-class CV_EXPORTS ConjGradSolver : public MinProblemSolver {
-public:
-  /** @brief This function returns the reference to the ready-to-use
-  ConjGradSolver object.
-
-  All the parameters are optional, so this procedure can be called even without
-  parameters at all. In this case, the default values will be used. As default
-  value for terminal criteria are the only sensible ones,
-  MinProblemSolver::setFunction() should be called upon the obtained object, if
-  the function was not given to create(). Otherwise, the two ways (submit it to
-  create() or miss it out and call the MinProblemSolver::setFunction()) are
-  absolutely equivalent (and will drop the same errors in the same way, should
-  invalid input be detected).
-  @param f Pointer to the function that will be minimized, similarly to the one
-  you submit via MinProblemSolver::setFunction.
-  @param termcrit Terminal criteria to the algorithm, similarly to the one you
-  submit via MinProblemSolver::setTermCriteria.
-  */
-  static Ptr<ConjGradSolver>
-  create(const Ptr<MinProblemSolver::Function> &f =
-             Ptr<ConjGradSolver::Function>(),
-         TermCriteria termcrit = TermCriteria(TermCriteria::MAX_ITER +
-                                                  TermCriteria::EPS,
-                                              5000, 0.000001));
-};
-
-//! return codes for cv::solveLP() function
-enum SolveLPResult {
-  SOLVELP_LOST = -3, //!< problem is feasible, but solver lost solution due to
-                     //!< floating-point arithmetic errors
-  SOLVELP_UNBOUNDED = -2, //!< problem is unbounded (target function can achieve
-                          //!< arbitrary high values)
-  SOLVELP_UNFEASIBLE = -1, //!< problem is unfeasible (there are no points that
-                           //!< satisfy all the constraints imposed)
-  SOLVELP_SINGLE = 0,      //!< there is only one maximum for target function
-  SOLVELP_MULTI = 1 //!< there are multiple maxima for target function - the
-                    //!< arbitrary one is returned
-};
-
-/** @brief Solve given (non-integer) linear programming problem using the
-Simplex Algorithm (Simplex Method).
-
-What we mean here by "linear programming problem" (or LP problem, for short) can
-be formulated as:
-
-\f[\mbox{Maximize } c\cdot x\\
- \mbox{Subject to:}\\
- Ax\leq b\\
- x\geq 0\f]
-
-Where \f$c\f$ is fixed `1`-by-`n` row-vector, \f$A\f$ is fixed `m`-by-`n`
-matrix, \f$b\f$ is fixed `m`-by-`1` column vector and \f$x\f$ is an arbitrary
-`n`-by-`1` column vector, which satisfies the constraints.
-
-Simplex algorithm is one of many algorithms that are designed to handle this
-sort of problems efficiently. Although it is not optimal in theoretical sense
-(there exist algorithms that can solve any problem written as above in
-polynomial time, while simplex method degenerates to exponential time for some
-special cases), it is well-studied, easy to implement and is shown to work well
-for real-life purposes.
-
-The particular implementation is taken almost verbatim from **Introduction to
-Algorithms, third edition** by T. H. Cormen, C. E. Leiserson, R. L. Rivest and
-Clifford Stein. In particular, the Bland's rule
-<http://en.wikipedia.org/wiki/Bland%27s_rule> is used to prevent cycling.
-
-@param Func This row-vector corresponds to \f$c\f$ in the LP problem formulation
-(see above). It should contain 32- or 64-bit floating point numbers. As a
-convenience, column-vector may be also submitted, in the latter case it is
-understood to correspond to \f$c^T\f$.
-@param Constr `m`-by-`n+1` matrix, whose rightmost column corresponds to \f$b\f$
-in formulation above and the remaining to \f$A\f$. It should contain 32- or
-64-bit floating point numbers.
-@param z The solution will be returned here as a column-vector - it corresponds
-to \f$c\f$ in the formulation above. It will contain 64-bit floating point
-numbers.
-@param constr_eps allowed numeric disparity for constraints
-@return One of cv::SolveLPResult
- */
-CV_EXPORTS_W int solveLP(InputArray Func, InputArray Constr, OutputArray z,
-                         double constr_eps);
-
-/** @overload */
-CV_EXPORTS_W int solveLP(InputArray Func, InputArray Constr, OutputArray z);
-
-//! @}
-
-} // namespace cv
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/parallel/backend/parallel_for.openmp.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/parallel/backend/parallel_for.openmp.hpp
deleted file mode 100644
index 6236b4c6cd..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/parallel/backend/parallel_for.openmp.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_CORE_PARALLEL_FOR_OPENMP_HPP
-#define OPENCV_CORE_PARALLEL_FOR_OPENMP_HPP
-
-#include "opencv2/core/parallel/parallel_backend.hpp"
-
-#if !defined(_OPENMP) && !defined(OPENCV_SKIP_OPENMP_PRESENSE_CHECK)
-#error "This file must be compiled with enabled OpenMP"
-#endif
-
-#include <omp.h>
-
-namespace cv {
-namespace parallel {
-namespace openmp {
-
-/** OpenMP parallel_for API implementation
- *
- * @sa setParallelForBackend
- * @ingroup core_parallel_backend
- */
-class ParallelForBackend : public ParallelForAPI {
-protected:
-  int numThreads;
-  int numThreadsMax;
-
-public:
-  ParallelForBackend() {
-    numThreads = 0;
-    numThreadsMax = omp_get_max_threads();
-  }
-
-  virtual ~ParallelForBackend() {}
-
-  virtual void parallel_for(int tasks, FN_parallel_for_body_cb_t body_callback,
-                            void *callback_data) CV_OVERRIDE {
-#pragma omp parallel for schedule(dynamic)                                     \
-    num_threads(numThreads > 0 ? numThreads : numThreadsMax)
-    for (int i = 0; i < tasks; ++i)
-      body_callback(i, i + 1, callback_data);
-  }
-
-  virtual int getThreadNum() const CV_OVERRIDE { return omp_get_thread_num(); }
-
-  virtual int getNumThreads() const CV_OVERRIDE {
-    return numThreads > 0 ? numThreads : numThreadsMax;
-  }
-
-  virtual int setNumThreads(int nThreads) CV_OVERRIDE {
-    int oldNumThreads = numThreads;
-    numThreads = nThreads;
-    // nothing needed as numThreads is used in #pragma omp parallel for directly
-    return oldNumThreads;
-  }
-
-  const char *getName() const CV_OVERRIDE { return "openmp"; }
-};
-
-} // namespace openmp
-} // namespace parallel
-} // namespace cv
-
-#endif // OPENCV_CORE_PARALLEL_FOR_OPENMP_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/parallel/backend/parallel_for.tbb.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/parallel/backend/parallel_for.tbb.hpp
deleted file mode 100644
index 65ccbf05a4..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/parallel/backend/parallel_for.tbb.hpp
+++ /dev/null
@@ -1,148 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_CORE_PARALLEL_FOR_TBB_HPP
-#define OPENCV_CORE_PARALLEL_FOR_TBB_HPP
-
-#include "opencv2/core/parallel/parallel_backend.hpp"
-#include <opencv2/core/utils/logger.hpp>
-
-#ifndef TBB_SUPPRESS_DEPRECATED_MESSAGES // supress warning
-#define TBB_SUPPRESS_DEPRECATED_MESSAGES 1
-#endif
-#include "tbb/tbb.h"
-#if !defined(TBB_INTERFACE_VERSION)
-#error "Unknows/unsupported TBB version"
-#endif
-
-#if TBB_INTERFACE_VERSION >= 8000
-#include "tbb/task_arena.h"
-#endif
-
-namespace cv {
-namespace parallel {
-namespace tbb {
-
-using namespace ::tbb;
-
-#if TBB_INTERFACE_VERSION >= 8000
-static tbb::task_arena &getArena() {
-  static tbb::task_arena tbbArena(tbb::task_arena::automatic);
-  return tbbArena;
-}
-#else
-static tbb::task_scheduler_init &getScheduler() {
-  static tbb::task_scheduler_init tbbScheduler(
-      tbb::task_scheduler_init::deferred);
-  return tbbScheduler;
-}
-#endif
-
-/** TBB parallel_for API implementation
- *
- * @sa setParallelForBackend
- * @ingroup core_parallel_backend
- */
-class ParallelForBackend : public ParallelForAPI {
-protected:
-  int numThreads;
-  int numThreadsMax;
-
-public:
-  ParallelForBackend() {
-    CV_LOG_INFO(NULL,
-                "Initializing TBB parallel backend: TBB_INTERFACE_VERSION="
-                    << TBB_INTERFACE_VERSION);
-    numThreads = 0;
-#if TBB_INTERFACE_VERSION >= 8000
-    (void)getArena();
-#else
-    (void)getScheduler();
-#endif
-  }
-
-  virtual ~ParallelForBackend() {}
-
-  class CallbackProxy {
-    const FN_parallel_for_body_cb_t &callback;
-    void *const callback_data;
-    const int tasks;
-
-  public:
-    inline CallbackProxy(int tasks_, FN_parallel_for_body_cb_t &callback_,
-                         void *callback_data_)
-        : callback(callback_), callback_data(callback_data_), tasks(tasks_) {
-      // nothing
-    }
-
-    void operator()(const tbb::blocked_range<int> &range) const {
-      this->callback(range.begin(), range.end(), callback_data);
-    }
-
-    void operator()() const {
-      tbb::parallel_for(tbb::blocked_range<int>(0, tasks), *this);
-    }
-  };
-
-  virtual void parallel_for(int tasks, FN_parallel_for_body_cb_t body_callback,
-                            void *callback_data) CV_OVERRIDE {
-    CallbackProxy task(tasks, body_callback, callback_data);
-#if TBB_INTERFACE_VERSION >= 8000
-    getArena().execute(task);
-#else
-    task();
-#endif
-  }
-
-  virtual int getThreadNum() const CV_OVERRIDE {
-#if TBB_INTERFACE_VERSION >= 9100
-    return tbb::this_task_arena::current_thread_index();
-#elif TBB_INTERFACE_VERSION >= 8000
-    return tbb::task_arena::current_thread_index();
-#else
-    return 0;
-#endif
-  }
-
-  virtual int getNumThreads() const CV_OVERRIDE {
-#if TBB_INTERFACE_VERSION >= 9100
-    return getArena().max_concurrency();
-#elif TBB_INTERFACE_VERSION >= 8000
-    return numThreads > 0 ? numThreads
-                          : tbb::task_scheduler_init::default_num_threads();
-#else
-    return getScheduler().is_active()
-               ? numThreads
-               : tbb::task_scheduler_init::default_num_threads();
-#endif
-  }
-
-  virtual int setNumThreads(int nThreads) CV_OVERRIDE {
-    int oldNumThreads = numThreads;
-    numThreads = nThreads;
-
-#if TBB_INTERFACE_VERSION >= 8000
-    auto &tbbArena = getArena();
-    if (tbbArena.is_active())
-      tbbArena.terminate();
-    if (numThreads > 0)
-      tbbArena.initialize(numThreads);
-#else
-    auto &tbbScheduler = getScheduler();
-    if (tbbScheduler.is_active())
-      tbbScheduler.terminate();
-    if (numThreads > 0)
-      tbbScheduler.initialize(numThreads);
-#endif
-    return oldNumThreads;
-  }
-
-  const char *getName() const CV_OVERRIDE { return "tbb"; }
-};
-
-} // namespace tbb
-} // namespace parallel
-} // namespace cv
-
-#endif // OPENCV_CORE_PARALLEL_FOR_TBB_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/parallel/parallel_backend.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/parallel/parallel_backend.hpp
deleted file mode 100644
index ff8af04ff8..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/parallel/parallel_backend.hpp
+++ /dev/null
@@ -1,108 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_CORE_PARALLEL_BACKEND_HPP
-#define OPENCV_CORE_PARALLEL_BACKEND_HPP
-
-#include "opencv2/core/cvdef.h"
-#include <memory>
-
-namespace cv {
-namespace parallel {
-#ifndef CV_API_CALL
-#define CV_API_CALL
-#endif
-
-/** @addtogroup core_parallel_backend
- * @{
- * API below is provided to resolve problem of CPU resource over-subscription by
- * multiple thread pools from different multi-threading frameworks. This is
- * common problem for cases when OpenCV compiled threading framework is
- * different from the Users Applications framework.
- *
- * Applications can replace OpenCV `parallel_for()` backend with own
- * implementation (to reuse Application's thread pool).
- *
- *
- * ### Backend API usage examples
- *
- * #### Intel TBB
- *
- * - include header with simple implementation of TBB backend:
- *   @snippet parallel_backend/example-tbb.cpp tbb_include
- * - execute backend replacement code:
- *   @snippet parallel_backend/example-tbb.cpp tbb_backend
- * - configuration of compiler/linker options is responsibility of Application's
- * scripts
- *
- * #### OpenMP
- *
- * - include header with simple implementation of OpenMP backend:
- *   @snippet parallel_backend/example-openmp.cpp openmp_include
- * - execute backend replacement code:
- *   @snippet parallel_backend/example-openmp.cpp openmp_backend
- * - Configuration of compiler/linker options is responsibility of Application's
- * scripts
- *
- *
- * ### Plugins support
- *
- * Runtime configuration options:
- * - change backend priority: `OPENCV_PARALLEL_PRIORITY_<backend>=9999`
- * - disable backend: `OPENCV_PARALLEL_PRIORITY_<backend>=0`
- * - specify list of backends with high priority (>100000):
- * `OPENCV_PARALLEL_PRIORITY_LIST=TBB,OPENMP`. Unknown backends are registered
- * as new plugins.
- *
- */
-
-/** Interface for parallel_for backends implementations
- *
- * @sa setParallelForBackend
- */
-class CV_EXPORTS ParallelForAPI {
-public:
-  virtual ~ParallelForAPI();
-
-  typedef void(CV_API_CALL *FN_parallel_for_body_cb_t)(int start, int end,
-                                                       void *data);
-
-  virtual void parallel_for(int tasks, FN_parallel_for_body_cb_t body_callback,
-                            void *callback_data) = 0;
-
-  virtual int getThreadNum() const = 0;
-
-  virtual int getNumThreads() const = 0;
-
-  virtual int setNumThreads(int nThreads) = 0;
-
-  virtual const char *getName() const = 0;
-};
-
-/** @brief Replace OpenCV parallel_for backend
- *
- * Application can replace OpenCV `parallel_for()` backend with own
- * implementation.
- *
- * @note This call is not thread-safe. Consider calling this function from the
- * `main()` before any other OpenCV processing functions (and without any other
- * created threads).
- */
-CV_EXPORTS void
-setParallelForBackend(const std::shared_ptr<ParallelForAPI> &api,
-                      bool propagateNumThreads = true);
-
-/** @brief Change OpenCV parallel_for backend
- *
- * @note This call is not thread-safe. Consider calling this function from the
- * `main()` before any other OpenCV processing functions (and without any other
- * created threads).
- */
-CV_EXPORTS_W bool setParallelForBackend(const std::string &backendName,
-                                        bool propagateNumThreads = true);
-
-//! @}
-} // namespace parallel
-} // namespace cv
-#endif // OPENCV_CORE_PARALLEL_BACKEND_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/persistence.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/persistence.hpp
deleted file mode 100644
index f851b8c5ea..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/persistence.hpp
+++ /dev/null
@@ -1,1321 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_CORE_PERSISTENCE_HPP
-#define OPENCV_CORE_PERSISTENCE_HPP
-
-#ifndef CV_DOXYGEN
-/// Define to support persistence legacy formats
-#define CV__LEGACY_PERSISTENCE
-#endif
-
-#ifndef __cplusplus
-#error persistence.hpp header must be compiled as C++
-#endif
-
-#include "opencv2/core/mat.hpp"
-#include "opencv2/core/types.hpp"
-
-namespace cv {
-
-/** @addtogroup core_xml
-
-XML/YAML/JSON file storages.     {#xml_storage}
-=======================
-Writing to a file storage.
---------------------------
-You can store and then restore various OpenCV data structures to/from XML
-(<http://www.w3c.org/XML>), YAML (<http://www.yaml.org>) or JSON
-(<http://www.json.org/>) formats. Also, it is possible to store and load
-arbitrarily complex data structures, which include OpenCV data structures, as
-well as primitive data types (integer and floating-point numbers and text
-strings) as their elements.
-
-Use the following procedure to write something to XML, YAML or JSON:
--# Create new FileStorage and open it for writing. It can be done with a single
-call to FileStorage::FileStorage constructor that takes a filename, or you can
-use the default constructor and then call FileStorage::open. Format of the file
-(XML, YAML or JSON) is determined from the filename extension (".xml",
-".yml"/".yaml" and ".json", respectively)
--# Write all the data you want using the streaming operator `<<`, just like in
-the case of STL streams.
--# Close the file using FileStorage::release. FileStorage destructor also closes
-the file.
-
-Here is an example:
-@code
-    #include "opencv2/core.hpp"
-    #include <time.h>
-
-    using namespace cv;
-
-    int main(int, char** argv)
-    {
-        FileStorage fs("test.yml", FileStorage::WRITE);
-
-        fs << "frameCount" << 5;
-        time_t rawtime; time(&rawtime);
-        fs << "calibrationDate" << asctime(localtime(&rawtime));
-        Mat cameraMatrix = (Mat_<double>(3,3) << 1000, 0, 320, 0, 1000, 240, 0,
-0, 1); Mat distCoeffs = (Mat_<double>(5,1) << 0.1, 0.01, -0.001, 0, 0); fs <<
-"cameraMatrix" << cameraMatrix << "distCoeffs" << distCoeffs; fs << "features"
-<< "["; for( int i = 0; i < 3; i++ )
-        {
-            int x = rand() % 640;
-            int y = rand() % 480;
-            uchar lbp = rand() % 256;
-
-            fs << "{:" << "x" << x << "y" << y << "lbp" << "[:";
-            for( int j = 0; j < 8; j++ )
-                fs << ((lbp >> j) & 1);
-            fs << "]" << "}";
-        }
-        fs << "]";
-        fs.release();
-        return 0;
-    }
-@endcode
-The sample above stores to YML an integer, a text string (calibration date), 2
-matrices, and a custom structure "feature", which includes feature coordinates
-and LBP (local binary pattern) value. Here is output of the sample:
-@code{.yaml}
-%YAML:1.0
-frameCount: 5
-calibrationDate: "Fri Jun 17 14:09:29 2011\n"
-cameraMatrix: !!opencv-matrix
-   rows: 3
-   cols: 3
-   dt: d
-   data: [ 1000., 0., 320., 0., 1000., 240., 0., 0., 1. ]
-distCoeffs: !!opencv-matrix
-   rows: 5
-   cols: 1
-   dt: d
-   data: [ 1.0000000000000001e-01, 1.0000000000000000e-02,
-       -1.0000000000000000e-03, 0., 0. ]
-features:
-   - { x:167, y:49, lbp:[ 1, 0, 0, 1, 1, 0, 1, 1 ] }
-   - { x:298, y:130, lbp:[ 0, 0, 0, 1, 0, 0, 1, 1 ] }
-   - { x:344, y:158, lbp:[ 1, 1, 0, 0, 0, 0, 1, 0 ] }
-@endcode
-
-As an exercise, you can replace ".yml" with ".xml" or ".json" in the sample
-above and see, how the corresponding XML file will look like.
-
-Several things can be noted by looking at the sample code and the output:
-
--   The produced YAML (and XML/JSON) consists of heterogeneous collections that
-can be nested. There are 2 types of collections: named collections (mappings)
-and unnamed collections (sequences). In mappings each element has a name and is
-accessed by name. This is similar to structures and std::map in C/C++ and
-dictionaries in Python. In sequences elements do not have names, they are
-accessed by indices. This is similar to arrays and std::vector in C/C++ and
-lists, tuples in Python. "Heterogeneous" means that elements of each single
-collection can have different types.
-
-    Top-level collection in YAML/XML/JSON is a mapping. Each matrix is stored as
-a mapping, and the matrix elements are stored as a sequence. Then, there is a
-sequence of features, where each feature is represented a mapping, and lbp value
-in a nested sequence.
-
--   When you write to a mapping (a structure), you write element name followed
-by its value. When you write to a sequence, you simply write the elements one by
-one. OpenCV data structures (such as cv::Mat) are written in absolutely the same
-way as simple C data structures - using `<<` operator.
-
--   To write a mapping, you first write the special string `{` to the storage,
-then write the elements as pairs (`fs << <element_name> << <element_value>`) and
-then write the closing
-    `}`.
-
--   To write a sequence, you first write the special string `[`, then write the
-elements, then write the closing `]`.
-
--   In YAML/JSON (but not XML), mappings and sequences can be written in a
-compact Python-like inline form. In the sample above matrix elements, as well as
-each feature, including its lbp value, is stored in such inline form. To store a
-mapping/sequence in a compact form, put `:` after the opening character, e.g.
-use `{:` instead of `{` and `[:` instead of `[`. When the data is written to
-XML, those extra `:` are ignored.
-
-Reading data from a file storage.
----------------------------------
-To read the previously written XML, YAML or JSON file, do the following:
--#  Open the file storage using FileStorage::FileStorage constructor or
-FileStorage::open method. In the current implementation the whole file is parsed
-and the whole representation of file storage is built in memory as a hierarchy
-of file nodes (see FileNode)
-
--#  Read the data you are interested in. Use FileStorage::operator [],
-FileNode::operator [] and/or FileNodeIterator.
-
--#  Close the storage using FileStorage::release.
-
-Here is how to read the file created by the code sample above:
-@code
-    FileStorage fs2("test.yml", FileStorage::READ);
-
-    // first method: use (type) operator on FileNode.
-    int frameCount = (int)fs2["frameCount"];
-
-    String date;
-    // second method: use FileNode::operator >>
-    fs2["calibrationDate"] >> date;
-
-    Mat cameraMatrix2, distCoeffs2;
-    fs2["cameraMatrix"] >> cameraMatrix2;
-    fs2["distCoeffs"] >> distCoeffs2;
-
-    cout << "frameCount: " << frameCount << endl
-         << "calibration date: " << date << endl
-         << "camera matrix: " << cameraMatrix2 << endl
-         << "distortion coeffs: " << distCoeffs2 << endl;
-
-    FileNode features = fs2["features"];
-    FileNodeIterator it = features.begin(), it_end = features.end();
-    int idx = 0;
-    std::vector<uchar> lbpval;
-
-    // iterate through a sequence using FileNodeIterator
-    for( ; it != it_end; ++it, idx++ )
-    {
-        cout << "feature #" << idx << ": ";
-        cout << "x=" << (int)(*it)["x"] << ", y=" << (int)(*it)["y"] << ", lbp:
-(";
-        // you can also easily read numerical arrays using FileNode >>
-std::vector operator.
-        (*it)["lbp"] >> lbpval;
-        for( int i = 0; i < (int)lbpval.size(); i++ )
-            cout << " " << (int)lbpval[i];
-        cout << ")" << endl;
-    }
-    fs2.release();
-@endcode
-
-Format specification    {#format_spec}
---------------------
-`([count]{u|c|w|s|i|f|d})`... where the characters correspond to fundamental C++
-types:
--   `u` 8-bit unsigned number
--   `c` 8-bit signed number
--   `w` 16-bit unsigned number
--   `s` 16-bit signed number
--   `i` 32-bit signed number
--   `f` single precision floating-point number
--   `d` double precision floating-point number
--   `r` pointer, 32 lower bits of which are written as a signed integer. The
-type can be used to store structures with links between the elements.
-
-`count` is the optional counter of values of a given type. For example, `2if`
-means that each array element is a structure of 2 integers, followed by a
-single-precision floating-point number. The equivalent notations of the above
-specification are `iif`, `2i1f` and so forth. Other examples: `u` means that the
-array consists of bytes, and `2d` means the array consists of pairs of doubles.
-
-@see @ref samples/cpp/tutorial_code/core/file_input_output/file_input_output.cpp
-*/
-
-//! @{
-
-/** @example
-samples/cpp/tutorial_code/core/file_input_output/file_input_output.cpp A
-complete example using the FileStorage interface Check @ref
-tutorial_file_input_output_with_xml_yml "the corresponding tutorial" for more
-details
-*/
-
-////////////////////////// XML & YAML I/O //////////////////////////
-
-class CV_EXPORTS FileNode;
-class CV_EXPORTS FileNodeIterator;
-
-/** @brief XML/YAML/JSON file storage class that encapsulates all the
-information necessary for writing or reading data to/from a file.
- */
-class CV_EXPORTS_W FileStorage {
-public:
-  //! file storage mode
-  enum Mode {
-    READ = 0,   //!< value, open the file for reading
-    WRITE = 1,  //!< value, open the file for writing
-    APPEND = 2, //!< value, open the file for appending
-    MEMORY = 4, /**< flag, read data from source or write data to the internal
-                   buffer (which is returned by FileStorage::release) */
-    FORMAT_MASK = (7 << 3), //!< mask for format flags
-    FORMAT_AUTO = 0,        //!< flag, auto format
-    FORMAT_XML = (1 << 3),  //!< flag, XML format
-    FORMAT_YAML = (2 << 3), //!< flag, YAML format
-    FORMAT_JSON = (3 << 3), //!< flag, JSON format
-
-    BASE64 = 64, //!< flag, write rawdata in Base64 by default. (consider using
-                 //!< WRITE_BASE64)
-    WRITE_BASE64 = BASE64 | WRITE, //!< flag, enable both WRITE and BASE64
-  };
-  enum State {
-    UNDEFINED = 0,      //!< Initial or uninitialized state.
-    VALUE_EXPECTED = 1, //!< Expecting a value in the current position.
-    NAME_EXPECTED = 2,  //!< Expecting a key/name in the current position.
-    INSIDE_MAP = 4 //!< Indicates being inside a map (a set of key-value pairs).
-  };
-
-  /** @brief The constructors.
-
-   The full constructor opens the file. Alternatively you can use the default
-   constructor and then call FileStorage::open.
-   */
-  CV_WRAP FileStorage();
-
-  /** @overload
-   @copydoc open()
-   */
-  CV_WRAP FileStorage(const String &filename, int flags,
-                      const String &encoding = String());
-
-  //! the destructor. calls release()
-  virtual ~FileStorage();
-
-  /** @brief Opens a file.
-
-   See description of parameters in FileStorage::FileStorage. The method calls
-   FileStorage::release before opening the file.
-   @param filename Name of the file to open or the text string to read the data
-   from. Extension of the file (.xml, .yml/.yaml or .json) determines its format
-   (XML, YAML or JSON respectively). Also you can append .gz to work with
-   compressed files, for example myHugeMatrix.xml.gz. If both FileStorage::WRITE
-   and FileStorage::MEMORY flags are specified, source is used just to specify
-   the output file format (e.g. mydata.xml, .yml etc.). A file name can also
-   contain parameters. You can use this format, "*?base64" (e.g.
-   "file.json?base64" (case sensitive)), as an alternative to
-   FileStorage::BASE64 flag.
-   @param flags Mode of operation. One of FileStorage::Mode
-   @param encoding Encoding of the file. Note that UTF-16 XML encoding is not
-   supported currently and you should use 8-bit encoding instead of it.
-   */
-  CV_WRAP virtual bool open(const String &filename, int flags,
-                            const String &encoding = String());
-
-  /** @brief Checks whether the file is opened.
-
-   @returns true if the object is associated with the current file and false
-   otherwise. It is a good practice to call this method after you tried to open
-   a file.
-   */
-  CV_WRAP virtual bool isOpened() const;
-
-  /** @brief Closes the file and releases all the memory buffers.
-
-   Call this method after all I/O operations with the storage are finished.
-   */
-  CV_WRAP virtual void release();
-
-  /** @brief Closes the file and releases all the memory buffers.
-
-   Call this method after all I/O operations with the storage are finished. If
-   the storage was opened for writing data and FileStorage::WRITE was specified
-   */
-  CV_WRAP virtual String releaseAndGetString();
-
-  /** @brief Returns the first element of the top-level mapping.
-   @returns The first element of the top-level mapping.
-   */
-  CV_WRAP FileNode getFirstTopLevelNode() const;
-
-  /** @brief Returns the top-level mapping
-   @param streamidx Zero-based index of the stream. In most cases there is only
-   one stream in the file. However, YAML supports multiple streams and so there
-   can be several.
-   @returns The top-level mapping.
-   */
-  CV_WRAP FileNode root(int streamidx = 0) const;
-
-  /** @brief Returns the specified element of the top-level mapping.
-   @param nodename Name of the file node.
-   @returns Node with the given name.
-   */
-  FileNode operator[](const String &nodename) const;
-
-  /** @overload */
-  CV_WRAP_AS(getNode) FileNode operator[](const char *nodename) const;
-
-  /**
-   * @brief Simplified writing API to use with bindings.
-   * @param name Name of the written object. When writing to sequences (a.k.a.
-   * "arrays"), pass an empty string.
-   * @param val Value of the written object.
-   */
-  CV_WRAP void write(const String &name, int val);
-  /// @overload
-  CV_WRAP void write(const String &name, int64_t val);
-  /// @overload
-  CV_WRAP void write(const String &name, double val);
-  /// @overload
-  CV_WRAP void write(const String &name, const String &val);
-  /// @overload
-  CV_WRAP void write(const String &name, const Mat &val);
-  /// @overload
-  CV_WRAP void write(const String &name, const std::vector<String> &val);
-
-  /** @brief Writes multiple numbers.
-
-   Writes one or more numbers of the specified format to the currently written
-   structure. Usually it is more convenient to use operator `<<` instead of this
-   method.
-   @param fmt Specification of each array element, see @ref format_spec "format
-   specification"
-   @param vec Pointer to the written array.
-   @param len Number of the uchar elements to write.
-   */
-  void writeRaw(const String &fmt, const void *vec, size_t len);
-
-  /** @brief Writes a comment.
-
-   The function writes a comment into file storage. The comments are skipped
-   when the storage is read.
-   @param comment The written comment, single-line or multi-line
-   @param append If true, the function tries to put the comment at the end of
-   current line. Else if the comment is multi-line, or if it does not fit at the
-   end of the current line, the comment starts a new line.
-   */
-  CV_WRAP void writeComment(const String &comment, bool append = false);
-
-  /** @brief Starts to write a nested structure (sequence or a mapping).
-  @param name name of the structure. When writing to sequences (a.k.a.
-  "arrays"), pass an empty string.
-  @param flags type of the structure (FileNode::MAP or FileNode::SEQ (both with
-  optional FileNode::FLOW)).
-  @param typeName optional name of the type you store. The effect of setting
-  this depends on the storage format. I.e. if the format has a specification for
-  storing type information, this parameter is used.
-  */
-  CV_WRAP void startWriteStruct(const String &name, int flags,
-                                const String &typeName = String());
-
-  /** @brief Finishes writing nested structure (should pair startWriteStruct())
-   */
-  CV_WRAP void endWriteStruct();
-
-  /** @brief Returns the normalized object name for the specified name of a
-  file.
-  @param filename Name of a file
-  @returns The normalized object name.
-   */
-  static String getDefaultObjectName(const String &filename);
-
-  /** @brief Returns the current format.
-   * @returns The current format, see FileStorage::Mode
-   */
-  CV_WRAP int getFormat() const;
-
-  int state;
-  std::string elname;
-
-  class Impl;
-  Ptr<Impl> p;
-};
-
-/** @brief File Storage Node class.
-
-The node is used to store each and every element of the file storage opened for
-reading. When XML/YAML file is read, it is first parsed and stored in the memory
-as a hierarchical collection of nodes. Each node can be a "leaf" that is contain
-a single number or a string, or be a collection of other nodes. There can be
-named collections (mappings) where each element has a name and it is accessed by
-a name, and ordered collections (sequences) where elements do not have names but
-rather accessed by index. Type of the file node can be determined using
-FileNode::type method.
-
-Note that file nodes are only used for navigating file storages opened for
-reading. When a file storage is opened for writing, no data is stored in memory
-after it is written.
- */
-class CV_EXPORTS_W_SIMPLE FileNode {
-public:
-  //! type of the file storage node
-  enum {
-    NONE = 0,     //!< empty node
-    INT = 1,      //!< an integer
-    REAL = 2,     //!< floating-point number
-    FLOAT = REAL, //!< synonym or REAL
-    STR = 3,      //!< text string in UTF-8 encoding
-    STRING = STR, //!< synonym for STR
-    SEQ = 4,      //!< sequence
-    MAP = 5,      //!< mapping
-    TYPE_MASK = 7,
-
-    FLOW = 8, //!< compact representation of a sequence or mapping. Used only by
-              //!< YAML writer
-    UNIFORM = 8, //!< if set, means that all the collection elements are numbers
-                 //!< of the same type (real's or int's).
-    //!< UNIFORM is used only when reading FileStorage; FLOW is used only when
-    //!< writing. So they share the same bit
-    EMPTY = 16, //!< empty structure (sequence or mapping)
-    NAMED = 32  //!< the node has a name (i.e. it is element of a mapping).
-  };
-  /** @brief The constructors.
-
-   These constructors are used to create a default file node, construct it from
-   obsolete structures or from the another file node.
-   */
-  CV_WRAP FileNode();
-
-  /** @overload
-   @param fs Pointer to the file storage structure.
-   @param blockIdx Index of the memory block where the file node is stored
-   @param ofs Offset in bytes from the beginning of the serialized storage
-
-   @deprecated
-   */
-  FileNode(const FileStorage *fs, size_t blockIdx, size_t ofs);
-
-  /** @overload
-   @param node File node to be used as initialization for the created file node.
-   */
-  FileNode(const FileNode &node);
-
-  FileNode &operator=(const FileNode &node);
-
-  /** @brief Returns element of a mapping node or a sequence node.
-   @param nodename Name of an element in the mapping node.
-   @returns Returns the element with the given identifier.
-   */
-  FileNode operator[](const String &nodename) const;
-
-  /** @overload
-   @param nodename Name of an element in the mapping node.
-   */
-  CV_WRAP_AS(getNode) FileNode operator[](const char *nodename) const;
-
-  /** @overload
-   @param i Index of an element in the sequence node.
-   */
-  CV_WRAP_AS(at) FileNode operator[](int i) const;
-
-  /** @brief Returns keys of a mapping node.
-   @returns Keys of a mapping node.
-   */
-  CV_WRAP std::vector<String> keys() const;
-
-  /** @brief Returns type of the node.
-   @returns Type of the node. See FileNode::Type
-   */
-  CV_WRAP int type() const;
-
-  //! returns true if the node is empty
-  CV_WRAP bool empty() const;
-  //! returns true if the node is a "none" object
-  CV_WRAP bool isNone() const;
-  //! returns true if the node is a sequence
-  CV_WRAP bool isSeq() const;
-  //! returns true if the node is a mapping
-  CV_WRAP bool isMap() const;
-  //! returns true if the node is an integer
-  CV_WRAP bool isInt() const;
-  //! returns true if the node is a floating-point number
-  CV_WRAP bool isReal() const;
-  //! returns true if the node is a text string
-  CV_WRAP bool isString() const;
-  //! returns true if the node has a name
-  CV_WRAP bool isNamed() const;
-  //! returns the node name or an empty string if the node is nameless
-  CV_WRAP std::string name() const;
-  //! returns the number of elements in the node, if it is a sequence or
-  //! mapping, or 1 otherwise.
-  CV_WRAP size_t size() const;
-  //! returns raw size of the FileNode in bytes
-  CV_WRAP size_t rawSize() const;
-  //! returns the node content as an integer. If the node stores floating-point
-  //! number, it is rounded.
-  operator int() const;
-  //! returns the node content as a signed 64bit integer. If the node stores
-  //! floating-point number, it is rounded.
-  operator int64_t() const;
-  //! returns the node content as float
-  operator float() const;
-  //! returns the node content as double
-  operator double() const;
-  //! returns the node content as text string
-  inline operator std::string() const { return this->string(); }
-
-  static bool isMap(int flags);
-  static bool isSeq(int flags);
-  static bool isCollection(int flags);
-  static bool isEmptyCollection(int flags);
-  static bool isFlow(int flags);
-
-  uchar *ptr();
-  const uchar *ptr() const;
-
-  //! returns iterator pointing to the first node element
-  FileNodeIterator begin() const;
-  //! returns iterator pointing to the element following the last node element
-  FileNodeIterator end() const;
-
-  /** @brief Reads node elements to the buffer with the specified format.
-
-  Usually it is more convenient to use operator `>>` instead of this method.
-  @param fmt Specification of each array element. See @ref format_spec "format
-  specification"
-  @param vec Pointer to the destination array.
-  @param len Number of bytes to read (buffer size limit). If it is greater than
-  number of remaining elements then all of them will be read.
-   */
-  void readRaw(const String &fmt, void *vec, size_t len) const;
-
-  /** Internal method used when reading FileStorage.
-   Sets the type (int, real or string) and value of the previously created node.
-   */
-  void setValue(int type, const void *value, int len = -1);
-
-  //! Simplified reading API to use with bindings.
-  CV_WRAP double real() const;
-  //! Simplified reading API to use with bindings.
-  CV_WRAP std::string string() const;
-  //! Simplified reading API to use with bindings.
-  CV_WRAP Mat mat() const;
-
-  // protected:
-  FileNode(FileStorage::Impl *fs, size_t blockIdx, size_t ofs);
-
-  FileStorage::Impl *fs;
-  size_t blockIdx;
-  size_t ofs;
-};
-
-/** @brief used to iterate through sequences and mappings.
-
- A standard STL notation, with node.begin(), node.end() denoting the beginning
- and the end of a sequence, stored in node. See the data reading sample in the
- beginning of the section.
- */
-class CV_EXPORTS FileNodeIterator {
-public:
-  /** @brief The constructors.
-
-   These constructors are used to create a default iterator, set it to specific
-   element in a file node or construct it from another iterator.
-   */
-  FileNodeIterator();
-
-  /** @overload
-   @param node File node - the collection to iterate over;
-      it can be a scalar (equivalent to 1-element collection) or "none"
-   (equivalent to empty collection).
-   @param seekEnd - true if iterator needs to be set after the last element of
-   the node; that is:
-          * node.begin() => FileNodeIterator(node, false)
-          * node.end() => FileNodeIterator(node, true)
-   */
-  FileNodeIterator(const FileNode &node, bool seekEnd);
-
-  /** @overload
-   @param it Iterator to be used as initialization for the created iterator.
-   */
-  FileNodeIterator(const FileNodeIterator &it);
-
-  FileNodeIterator &operator=(const FileNodeIterator &it);
-
-  //! returns the currently observed element
-  FileNode operator*() const;
-
-  //! moves iterator to the next node
-  FileNodeIterator &operator++();
-  //! moves iterator to the next node
-  FileNodeIterator operator++(int);
-  //! moves iterator forward by the specified offset (possibly negative)
-  FileNodeIterator &operator+=(int ofs);
-
-  /** @brief Reads node elements to the buffer with the specified format.
-
-  Usually it is more convenient to use operator `>>` instead of this method.
-  @param fmt Specification of each array element. See @ref format_spec "format
-  specification"
-  @param vec Pointer to the destination array.
-  @param len Number of bytes to read (buffer size limit). If it is greater than
-  number of remaining elements then all of them will be read.
-   */
-  FileNodeIterator &readRaw(const String &fmt, void *vec,
-                            size_t len = (size_t)INT_MAX);
-
-  //! returns the number of remaining (not read yet) elements
-  size_t remaining() const;
-
-  bool equalTo(const FileNodeIterator &it) const;
-
-protected:
-  FileStorage::Impl *fs;
-  size_t blockIdx;
-  size_t ofs;
-  size_t blockSize;
-  size_t nodeNElems;
-  size_t idx;
-};
-
-//! @} core_xml
-
-/////////////////// XML & YAML I/O implementation //////////////////
-
-CV_EXPORTS void write(FileStorage &fs, const String &name, int value);
-CV_EXPORTS void write(FileStorage &fs, const String &name, int64_t value);
-CV_EXPORTS void write(FileStorage &fs, const String &name, float value);
-CV_EXPORTS void write(FileStorage &fs, const String &name, double value);
-CV_EXPORTS void write(FileStorage &fs, const String &name, const String &value);
-CV_EXPORTS void write(FileStorage &fs, const String &name, const Mat &value);
-CV_EXPORTS void write(FileStorage &fs, const String &name,
-                      const SparseMat &value);
-#ifdef CV__LEGACY_PERSISTENCE
-CV_EXPORTS void write(FileStorage &fs, const String &name,
-                      const std::vector<KeyPoint> &value);
-CV_EXPORTS void write(FileStorage &fs, const String &name,
-                      const std::vector<DMatch> &value);
-#endif
-
-CV_EXPORTS void writeScalar(FileStorage &fs, int value);
-CV_EXPORTS void writeScalar(FileStorage &fs, int64_t value);
-CV_EXPORTS void writeScalar(FileStorage &fs, float value);
-CV_EXPORTS void writeScalar(FileStorage &fs, double value);
-CV_EXPORTS void writeScalar(FileStorage &fs, const String &value);
-
-CV_EXPORTS void read(const FileNode &node, int &value, int default_value);
-CV_EXPORTS void read(const FileNode &node, int64_t &value,
-                     int64_t default_value);
-CV_EXPORTS void read(const FileNode &node, float &value, float default_value);
-CV_EXPORTS void read(const FileNode &node, double &value, double default_value);
-CV_EXPORTS void read(const FileNode &node, std::string &value,
-                     const std::string &default_value);
-CV_EXPORTS void read(const FileNode &node, Mat &mat,
-                     const Mat &default_mat = Mat());
-CV_EXPORTS void read(const FileNode &node, SparseMat &mat,
-                     const SparseMat &default_mat = SparseMat());
-#ifdef CV__LEGACY_PERSISTENCE
-CV_EXPORTS void read(const FileNode &node, std::vector<KeyPoint> &keypoints);
-CV_EXPORTS void read(const FileNode &node, std::vector<DMatch> &matches);
-#endif
-CV_EXPORTS void read(const FileNode &node, KeyPoint &value,
-                     const KeyPoint &default_value);
-CV_EXPORTS void read(const FileNode &node, DMatch &value,
-                     const DMatch &default_value);
-
-template <typename _Tp>
-static inline void read(const FileNode &node, Point_<_Tp> &value,
-                        const Point_<_Tp> &default_value) {
-  std::vector<_Tp> temp;
-  FileNodeIterator it = node.begin();
-  it >> temp;
-  value = temp.size() != 2 ? default_value
-                           : Point_<_Tp>(saturate_cast<_Tp>(temp[0]),
-                                         saturate_cast<_Tp>(temp[1]));
-}
-
-template <typename _Tp>
-static inline void read(const FileNode &node, Point3_<_Tp> &value,
-                        const Point3_<_Tp> &default_value) {
-  std::vector<_Tp> temp;
-  FileNodeIterator it = node.begin();
-  it >> temp;
-  value = temp.size() != 3 ? default_value
-                           : Point3_<_Tp>(saturate_cast<_Tp>(temp[0]),
-                                          saturate_cast<_Tp>(temp[1]),
-                                          saturate_cast<_Tp>(temp[2]));
-}
-
-template <typename _Tp>
-static inline void read(const FileNode &node, Size_<_Tp> &value,
-                        const Size_<_Tp> &default_value) {
-  std::vector<_Tp> temp;
-  FileNodeIterator it = node.begin();
-  it >> temp;
-  value = temp.size() != 2 ? default_value
-                           : Size_<_Tp>(saturate_cast<_Tp>(temp[0]),
-                                        saturate_cast<_Tp>(temp[1]));
-}
-
-template <typename _Tp>
-static inline void read(const FileNode &node, Complex<_Tp> &value,
-                        const Complex<_Tp> &default_value) {
-  std::vector<_Tp> temp;
-  FileNodeIterator it = node.begin();
-  it >> temp;
-  value = temp.size() != 2 ? default_value
-                           : Complex<_Tp>(saturate_cast<_Tp>(temp[0]),
-                                          saturate_cast<_Tp>(temp[1]));
-}
-
-template <typename _Tp>
-static inline void read(const FileNode &node, Rect_<_Tp> &value,
-                        const Rect_<_Tp> &default_value) {
-  std::vector<_Tp> temp;
-  FileNodeIterator it = node.begin();
-  it >> temp;
-  value = temp.size() != 4 ? default_value
-                           : Rect_<_Tp>(saturate_cast<_Tp>(temp[0]),
-                                        saturate_cast<_Tp>(temp[1]),
-                                        saturate_cast<_Tp>(temp[2]),
-                                        saturate_cast<_Tp>(temp[3]));
-}
-
-template <typename _Tp, int cn>
-static inline void read(const FileNode &node, Vec<_Tp, cn> &value,
-                        const Vec<_Tp, cn> &default_value) {
-  std::vector<_Tp> temp;
-  FileNodeIterator it = node.begin();
-  it >> temp;
-  value = temp.size() != cn ? default_value : Vec<_Tp, cn>(&temp[0]);
-}
-
-template <typename _Tp, int m, int n>
-static inline void
-read(const FileNode &node, Matx<_Tp, m, n> &value,
-     const Matx<_Tp, m, n> &default_matx = Matx<_Tp, m, n>()) {
-  Mat temp;
-  read(node, temp); // read as a Mat class
-
-  if (temp.empty())
-    value = default_matx;
-  else
-    value = Matx<_Tp, m, n>(temp);
-}
-
-template <typename _Tp>
-static inline void read(const FileNode &node, Scalar_<_Tp> &value,
-                        const Scalar_<_Tp> &default_value) {
-  std::vector<_Tp> temp;
-  FileNodeIterator it = node.begin();
-  it >> temp;
-  value = temp.size() != 4 ? default_value
-                           : Scalar_<_Tp>(saturate_cast<_Tp>(temp[0]),
-                                          saturate_cast<_Tp>(temp[1]),
-                                          saturate_cast<_Tp>(temp[2]),
-                                          saturate_cast<_Tp>(temp[3]));
-}
-
-static inline void read(const FileNode &node, Range &value,
-                        const Range &default_value) {
-  Point2i temp(value.start, value.end);
-  const Point2i default_temp = Point2i(default_value.start, default_value.end);
-  read(node, temp, default_temp);
-  value.start = temp.x;
-  value.end = temp.y;
-}
-
-/** @brief Writes string to a file storage.
- */
-CV_EXPORTS FileStorage &operator<<(FileStorage &fs, const String &str);
-
-//! @cond IGNORED
-
-namespace internal {
-class CV_EXPORTS WriteStructContext {
-public:
-  WriteStructContext(FileStorage &_fs, const String &name, int flags,
-                     const String &typeName = String());
-  ~WriteStructContext();
-
-private:
-  FileStorage *fs;
-};
-
-template <typename _Tp, int numflag> class VecWriterProxy {
-public:
-  VecWriterProxy(FileStorage *_fs) : fs(_fs) {}
-  void operator()(const std::vector<_Tp> &vec) const {
-    size_t count = vec.size();
-    for (size_t i = 0; i < count; i++)
-      write(*fs, vec[i]);
-  }
-
-private:
-  FileStorage *fs;
-};
-
-template <typename _Tp> class VecWriterProxy<_Tp, 1> {
-public:
-  VecWriterProxy(FileStorage *_fs) : fs(_fs) {}
-  void operator()(const std::vector<_Tp> &vec) const {
-    int _fmt = traits::SafeFmt<_Tp>::fmt;
-    char fmt[] = {(char)((_fmt >> 8) + '1'), (char)_fmt, '\0'};
-    fs->writeRaw(fmt, !vec.empty() ? (uchar *)&vec[0] : 0,
-                 vec.size() * sizeof(_Tp));
-  }
-
-private:
-  FileStorage *fs;
-};
-
-template <typename _Tp, int numflag> class VecReaderProxy {
-public:
-  VecReaderProxy(FileNodeIterator *_it) : it(_it) {}
-  void operator()(std::vector<_Tp> &vec, size_t count) const {
-    count = std::min(count, it->remaining());
-    vec.resize(count);
-    for (size_t i = 0; i < count; i++, ++(*it))
-      read(**it, vec[i], _Tp());
-  }
-
-private:
-  FileNodeIterator *it;
-};
-
-template <typename _Tp> class VecReaderProxy<_Tp, 1> {
-public:
-  VecReaderProxy(FileNodeIterator *_it) : it(_it) {}
-  void operator()(std::vector<_Tp> &vec, size_t count) const {
-    size_t remaining = it->remaining();
-    size_t cn = DataType<_Tp>::channels;
-    int _fmt = traits::SafeFmt<_Tp>::fmt;
-    CV_Assert((_fmt >> 8) < 9);
-    char fmt[] = {(char)((_fmt >> 8) + '1'), (char)_fmt, '\0'};
-    CV_Assert((remaining % cn) == 0);
-    size_t remaining1 = remaining / cn;
-    count = count > remaining1 ? remaining1 : count;
-    vec.resize(count);
-    it->readRaw(fmt, !vec.empty() ? (uchar *)&vec[0] : 0, count * sizeof(_Tp));
-  }
-
-private:
-  FileNodeIterator *it;
-};
-
-} // namespace internal
-
-//! @endcond
-
-template <typename _Tp>
-static inline void write(FileStorage &fs, const _Tp &value) {
-  write(fs, String(), value);
-}
-
-template <> inline void write(FileStorage &fs, const int &value) {
-  writeScalar(fs, value);
-}
-
-template <> inline void write(FileStorage &fs, const float &value) {
-  writeScalar(fs, value);
-}
-
-template <> inline void write(FileStorage &fs, const double &value) {
-  writeScalar(fs, value);
-}
-
-template <> inline void write(FileStorage &fs, const String &value) {
-  writeScalar(fs, value);
-}
-
-template <typename _Tp>
-static inline void write(FileStorage &fs, const Point_<_Tp> &pt) {
-  write(fs, pt.x);
-  write(fs, pt.y);
-}
-
-template <typename _Tp>
-static inline void write(FileStorage &fs, const Point3_<_Tp> &pt) {
-  write(fs, pt.x);
-  write(fs, pt.y);
-  write(fs, pt.z);
-}
-
-template <typename _Tp>
-static inline void write(FileStorage &fs, const Size_<_Tp> &sz) {
-  write(fs, sz.width);
-  write(fs, sz.height);
-}
-
-template <typename _Tp>
-static inline void write(FileStorage &fs, const Complex<_Tp> &c) {
-  write(fs, c.re);
-  write(fs, c.im);
-}
-
-template <typename _Tp>
-static inline void write(FileStorage &fs, const Rect_<_Tp> &r) {
-  write(fs, r.x);
-  write(fs, r.y);
-  write(fs, r.width);
-  write(fs, r.height);
-}
-
-template <typename _Tp, int cn>
-static inline void write(FileStorage &fs, const Vec<_Tp, cn> &v) {
-  for (int i = 0; i < cn; i++)
-    write(fs, v.val[i]);
-}
-
-template <typename _Tp, int m, int n>
-static inline void write(FileStorage &fs, const Matx<_Tp, m, n> &x) {
-  write(fs, Mat(x)); // write as a Mat class
-}
-
-template <typename _Tp>
-static inline void write(FileStorage &fs, const Scalar_<_Tp> &s) {
-  write(fs, s.val[0]);
-  write(fs, s.val[1]);
-  write(fs, s.val[2]);
-  write(fs, s.val[3]);
-}
-
-static inline void write(FileStorage &fs, const Range &r) {
-  write(fs, r.start);
-  write(fs, r.end);
-}
-
-template <typename _Tp>
-static inline void write(FileStorage &fs, const std::vector<_Tp> &vec) {
-  cv::internal::VecWriterProxy<_Tp, traits::SafeFmt<_Tp>::fmt != 0> w(&fs);
-  w(vec);
-}
-
-template <typename _Tp>
-static inline void write(FileStorage &fs, const String &name,
-                         const Point_<_Tp> &pt) {
-  cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ + FileNode::FLOW);
-  write(fs, pt);
-}
-
-template <typename _Tp>
-static inline void write(FileStorage &fs, const String &name,
-                         const Point3_<_Tp> &pt) {
-  cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ + FileNode::FLOW);
-  write(fs, pt);
-}
-
-template <typename _Tp>
-static inline void write(FileStorage &fs, const String &name,
-                         const Size_<_Tp> &sz) {
-  cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ + FileNode::FLOW);
-  write(fs, sz);
-}
-
-template <typename _Tp>
-static inline void write(FileStorage &fs, const String &name,
-                         const Complex<_Tp> &c) {
-  cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ + FileNode::FLOW);
-  write(fs, c);
-}
-
-template <typename _Tp>
-static inline void write(FileStorage &fs, const String &name,
-                         const Rect_<_Tp> &r) {
-  cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ + FileNode::FLOW);
-  write(fs, r);
-}
-
-template <typename _Tp, int cn>
-static inline void write(FileStorage &fs, const String &name,
-                         const Vec<_Tp, cn> &v) {
-  cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ + FileNode::FLOW);
-  write(fs, v);
-}
-
-template <typename _Tp, int m, int n>
-static inline void write(FileStorage &fs, const String &name,
-                         const Matx<_Tp, m, n> &x) {
-  write(fs, name, Mat(x)); // write as a Mat class
-}
-
-template <typename _Tp>
-static inline void write(FileStorage &fs, const String &name,
-                         const Scalar_<_Tp> &s) {
-  cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ + FileNode::FLOW);
-  write(fs, s);
-}
-
-static inline void write(FileStorage &fs, const String &name, const Range &r) {
-  cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ + FileNode::FLOW);
-  write(fs, r);
-}
-
-static inline void write(FileStorage &fs, const String &name,
-                         const KeyPoint &kpt) {
-  cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ + FileNode::FLOW);
-  write(fs, kpt.pt.x);
-  write(fs, kpt.pt.y);
-  write(fs, kpt.size);
-  write(fs, kpt.angle);
-  write(fs, kpt.response);
-  write(fs, kpt.octave);
-  write(fs, kpt.class_id);
-}
-
-static inline void write(FileStorage &fs, const String &name, const DMatch &m) {
-  cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ + FileNode::FLOW);
-  write(fs, m.queryIdx);
-  write(fs, m.trainIdx);
-  write(fs, m.imgIdx);
-  write(fs, m.distance);
-}
-
-template <typename _Tp,
-          typename std::enable_if<std::is_enum<_Tp>::value>::type * = nullptr>
-static inline void write(FileStorage &fs, const String &name, const _Tp &val) {
-  write(fs, name, static_cast<int>(val));
-}
-
-template <typename _Tp>
-static inline void write(FileStorage &fs, const String &name,
-                         const std::vector<_Tp> &vec) {
-  cv::internal::WriteStructContext ws(
-      fs, name,
-      FileNode::SEQ + (traits::SafeFmt<_Tp>::fmt != 0 ? FileNode::FLOW : 0));
-  write(fs, vec);
-}
-
-template <typename _Tp>
-static inline void write(FileStorage &fs, const String &name,
-                         const std::vector<std::vector<_Tp>> &vec) {
-  cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ);
-  for (size_t i = 0; i < vec.size(); i++) {
-    cv::internal::WriteStructContext ws_(
-        fs, name,
-        FileNode::SEQ + (traits::SafeFmt<_Tp>::fmt != 0 ? FileNode::FLOW : 0));
-    write(fs, vec[i]);
-  }
-}
-
-#ifdef CV__LEGACY_PERSISTENCE
-// This code is not needed anymore, but it is preserved here to keep source
-// compatibility Implementation is similar to templates instantiations
-static inline void write(FileStorage &fs, const KeyPoint &kpt) {
-  write(fs, String(), kpt);
-}
-static inline void write(FileStorage &fs, const DMatch &m) {
-  write(fs, String(), m);
-}
-static inline void write(FileStorage &fs, const std::vector<KeyPoint> &vec) {
-  cv::internal::VecWriterProxy<KeyPoint, 0> w(&fs);
-  w(vec);
-}
-static inline void write(FileStorage &fs, const std::vector<DMatch> &vec) {
-  cv::internal::VecWriterProxy<DMatch, 0> w(&fs);
-  w(vec);
-}
-#endif
-
-static inline void read(const FileNode &node, bool &value, bool default_value) {
-  int temp;
-  read(node, temp, (int)default_value);
-  value = temp != 0;
-}
-
-static inline void read(const FileNode &node, uchar &value,
-                        uchar default_value) {
-  int temp;
-  read(node, temp, (int)default_value);
-  value = saturate_cast<uchar>(temp);
-}
-
-static inline void read(const FileNode &node, schar &value,
-                        schar default_value) {
-  int temp;
-  read(node, temp, (int)default_value);
-  value = saturate_cast<schar>(temp);
-}
-
-static inline void read(const FileNode &node, ushort &value,
-                        ushort default_value) {
-  int temp;
-  read(node, temp, (int)default_value);
-  value = saturate_cast<ushort>(temp);
-}
-
-static inline void read(const FileNode &node, short &value,
-                        short default_value) {
-  int temp;
-  read(node, temp, (int)default_value);
-  value = saturate_cast<short>(temp);
-}
-
-template <typename _Tp>
-static inline void read(FileNodeIterator &it, std::vector<_Tp> &vec,
-                        size_t maxCount = (size_t)INT_MAX) {
-  cv::internal::VecReaderProxy<_Tp, traits::SafeFmt<_Tp>::fmt != 0> r(&it);
-  r(vec, maxCount);
-}
-
-template <typename _Tp,
-          typename std::enable_if<std::is_enum<_Tp>::value>::type * = nullptr>
-static inline void read(const FileNode &node, _Tp &value,
-                        const _Tp &default_value = static_cast<_Tp>(0)) {
-  int temp;
-  read(node, temp, static_cast<int>(default_value));
-  value = static_cast<_Tp>(temp);
-}
-
-template <typename _Tp>
-static inline void
-read(const FileNode &node, std::vector<_Tp> &vec,
-     const std::vector<_Tp> &default_value = std::vector<_Tp>()) {
-  if (node.empty())
-    vec = default_value;
-  else {
-    FileNodeIterator it = node.begin();
-    read(it, vec);
-  }
-}
-
-static inline void read(const FileNode &node, std::vector<KeyPoint> &vec,
-                        const std::vector<KeyPoint> &default_value) {
-  if (node.empty())
-    vec = default_value;
-  else
-    read(node, vec);
-}
-
-static inline void read(const FileNode &node, std::vector<DMatch> &vec,
-                        const std::vector<DMatch> &default_value) {
-  if (node.empty())
-    vec = default_value;
-  else
-    read(node, vec);
-}
-
-/** @brief Writes data to a file storage.
- */
-template <typename _Tp>
-static inline FileStorage &operator<<(FileStorage &fs, const _Tp &value) {
-  if (!fs.isOpened())
-    return fs;
-  if (fs.state == FileStorage::NAME_EXPECTED + FileStorage::INSIDE_MAP)
-    CV_Error(Error::StsError, "No element name has been given");
-  write(fs, fs.elname, value);
-  if (fs.state & FileStorage::INSIDE_MAP)
-    fs.state = FileStorage::NAME_EXPECTED + FileStorage::INSIDE_MAP;
-  return fs;
-}
-
-/** @brief Writes data to a file storage.
- */
-static inline FileStorage &operator<<(FileStorage &fs, const char *str) {
-  return (fs << String(str));
-}
-
-/** @brief Writes data to a file storage.
- */
-static inline FileStorage &operator<<(FileStorage &fs, char *value) {
-  return (fs << String(value));
-}
-
-/** @brief Reads data from a file storage.
- */
-template <typename _Tp>
-static inline FileNodeIterator &operator>>(FileNodeIterator &it, _Tp &value) {
-  read(*it, value, _Tp());
-  return ++it;
-}
-
-/** @brief Reads data from a file storage.
- */
-template <typename _Tp>
-static inline FileNodeIterator &operator>>(FileNodeIterator &it,
-                                           std::vector<_Tp> &vec) {
-  cv::internal::VecReaderProxy<_Tp, traits::SafeFmt<_Tp>::fmt != 0> r(&it);
-  r(vec, (size_t)INT_MAX);
-  return it;
-}
-
-/** @brief Reads data from a file storage.
- */
-template <typename _Tp>
-static inline void operator>>(const FileNode &n, _Tp &value) {
-  read(n, value, _Tp());
-}
-
-/** @brief Reads data from a file storage.
- */
-template <typename _Tp>
-static inline void operator>>(const FileNode &n, std::vector<_Tp> &vec) {
-  FileNodeIterator it = n.begin();
-  it >> vec;
-}
-
-/** @brief Reads KeyPoint from a file storage.
- */
-// It needs special handling because it contains two types of fields, int &
-// float.
-static inline void operator>>(const FileNode &n, KeyPoint &kpt) {
-  FileNodeIterator it = n.begin();
-  it >> kpt.pt.x >> kpt.pt.y >> kpt.size >> kpt.angle >> kpt.response >>
-      kpt.octave >> kpt.class_id;
-}
-
-#ifdef CV__LEGACY_PERSISTENCE
-static inline void operator>>(const FileNode &n, std::vector<KeyPoint> &vec) {
-  read(n, vec);
-}
-static inline void operator>>(const FileNode &n, std::vector<DMatch> &vec) {
-  read(n, vec);
-}
-#endif
-
-/** @brief Reads DMatch from a file storage.
- */
-// It needs special handling because it contains two types of fields, int &
-// float.
-static inline void operator>>(const FileNode &n, DMatch &m) {
-  FileNodeIterator it = n.begin();
-  it >> m.queryIdx >> m.trainIdx >> m.imgIdx >> m.distance;
-}
-
-CV_EXPORTS bool operator==(const FileNodeIterator &it1,
-                           const FileNodeIterator &it2);
-CV_EXPORTS bool operator!=(const FileNodeIterator &it1,
-                           const FileNodeIterator &it2);
-
-static inline ptrdiff_t operator-(const FileNodeIterator &it1,
-                                  const FileNodeIterator &it2) {
-  return it2.remaining() - it1.remaining();
-}
-
-static inline bool operator<(const FileNodeIterator &it1,
-                             const FileNodeIterator &it2) {
-  return it1.remaining() > it2.remaining();
-}
-
-} // namespace cv
-
-#endif // OPENCV_CORE_PERSISTENCE_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/quaternion.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/quaternion.hpp
deleted file mode 100644
index 2deef3117c..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/quaternion.hpp
+++ /dev/null
@@ -1,1889 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2020, Huawei Technologies Co., Ltd. All rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//       http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Author: Liangqian Kong <chargerKong@126.com>
-//         Longbu Wang <riskiest@gmail.com>
-#ifndef OPENCV_CORE_QUATERNION_HPP
-#define OPENCV_CORE_QUATERNION_HPP
-
-#include <iostream>
-#include <opencv2/core.hpp>
-#include <opencv2/core/utils/logger.hpp>
-namespace cv {
-//! @addtogroup core_quaternion
-//! @{
-
-//! Unit quaternion flag
-enum QuatAssumeType {
-  /**
-   * This flag is specified by default.
-   * If this flag is specified, the input quaternions are assumed to be not unit
-   * quaternions. It can guarantee the correctness of the calculations, although
-   * the calculation speed will be slower than the flag QUAT_ASSUME_UNIT.
-   */
-  QUAT_ASSUME_NOT_UNIT,
-  /**
-   * If this flag is specified, the input quaternions are assumed to be unit
-   * quaternions which will save some computations. However, if this flag is
-   * specified without unit quaternion, the program correctness of the result
-   * will not be guaranteed.
-   */
-  QUAT_ASSUME_UNIT
-};
-
-class QuatEnum {
-public:
-  /** @brief Enum of Euler angles type.
-   *
-   * Without considering the possibility of using two different convertions for
-   * the definition of the rotation axes , there exists twelve possible
-   * sequences of rotation axes, divided into two groups:
-   * - Proper Euler angles (Z-X-Z, X-Y-X, Y-Z-Y, Z-Y-Z, X-Z-X, Y-X-Y)
-   * - Tait–Bryan angles (X-Y-Z, Y-Z-X, Z-X-Y, X-Z-Y, Z-Y-X, Y-X-Z).
-   *
-   * The three elemental rotations may be
-   * [extrinsic](https://en.wikipedia.org/wiki/Euler_angles#Definition_by_extrinsic_rotations)
-   * (rotations about the axes *xyz* of the original coordinate system, which is
-   * assumed to remain motionless), or
-   * [intrinsic](https://en.wikipedia.org/wiki/Euler_angles#Definition_by_intrinsic_rotations)(rotations
-   * about the axes of the rotating coordinate system *XYZ*, solidary with the
-   * moving body, which changes its orientation after each elemental rotation).
-   *
-   *
-   * Extrinsic and intrinsic rotations are relevant.
-   *
-   * The definition of the Euler angles is as following,
-   * - \f$\theta_1 \f$ represents the first rotation angle,
-   * - \f$\theta_2 \f$ represents the second rotation angle,
-   * - \f$\theta_3 \f$ represents the third rotation angle.
-   *
-   * For intrinsic rotations in the order of X-Y-Z, the rotation matrix R can be
-   * calculated by:\f[R =X(\theta_1) Y(\theta_2) Z(\theta_3) \f] For extrinsic
-   * rotations in the order of X-Y-Z, the rotation matrix R can be calculated
-   * by:\f[R =Z({\theta_3}) Y({\theta_2}) X({\theta_1})\f] where
-   * \f[X({\theta_1})={\begin{bmatrix}1&0&0\\0&\cos {\theta_1} &-\sin {\theta_1}
-   * \\0&\sin {\theta_1} &\cos {\theta_1} \\\end{bmatrix}},
-   * Y({\theta_2})={\begin{bmatrix}\cos \theta_{2}&0&\sin \theta_{2}\\0&1 &0
-   * \\\ -sin \theta_2& 0&\cos \theta_{2} \\\end{bmatrix}},
-   * Z({\theta_3})={\begin{bmatrix}\cos\theta_{3} &-\sin \theta_3&0\\\sin
-   * \theta_3 &\cos \theta_3 &0\\0&0&1\\\end{bmatrix}}.
-   * \f]
-   *
-   * The function is designed according to this set of conventions:
-   * - [Right handed](https://en.wikipedia.org/wiki/Right_hand_rule) reference
-   * frames are adopted, and the [right hand
-   * rule](https://en.wikipedia.org/wiki/Right_hand_rule) is used to determine
-   * the sign of angles.
-   * - Each matrix is meant to represent an [active
-   * rotation](https://en.wikipedia.org/wiki/Active_and_passive_transformation)
-   * (the composing and composed matrices are supposed to act on the coordinates
-   * of vectors defined in the initial fixed reference frame and give as a
-   * result the coordinates of a rotated vector defined in the same reference
-   * frame).
-   * - For \f$\theta_1\f$ and \f$\theta_3\f$, the valid range is (−π, π].
-   *
-   *   For \f$\theta_2\f$, the valid range is [−π/2, π/2] or [0, π].
-   *
-   *   For Tait–Bryan angles, the valid range of \f$\theta_2\f$ is [−π/2, π/2].
-   * When transforming a quaternion to Euler angles, the solution of Euler
-   * angles is unique in condition of \f$ \theta_2 \in (−π/2, π/2)\f$ . If
-   * \f$\theta_2 = −π/2 \f$ or \f$ \theta_2 = π/2\f$, there are infinite
-   * solutions. The common name for this situation is gimbal lock. For Proper
-   * Euler angles,the valid range of \f$\theta_2\f$ is in [0, π]. The solutions
-   * of Euler angles are unique in condition of  \f$ \theta_2 \in (0, π)\f$ . If
-   * \f$\theta_2 =0 \f$ or \f$\theta_2 =π \f$, there are infinite solutions and
-   * gimbal lock will occur.
-   */
-  enum EulerAnglesType {
-    INT_XYZ, ///< Intrinsic rotations with the Euler angles type X-Y-Z
-    INT_XZY, ///< Intrinsic rotations with the Euler angles type X-Z-Y
-    INT_YXZ, ///< Intrinsic rotations with the Euler angles type Y-X-Z
-    INT_YZX, ///< Intrinsic rotations with the Euler angles type Y-Z-X
-    INT_ZXY, ///< Intrinsic rotations with the Euler angles type Z-X-Y
-    INT_ZYX, ///< Intrinsic rotations with the Euler angles type Z-Y-X
-    INT_XYX, ///< Intrinsic rotations with the Euler angles type X-Y-X
-    INT_XZX, ///< Intrinsic rotations with the Euler angles type X-Z-X
-    INT_YXY, ///< Intrinsic rotations with the Euler angles type Y-X-Y
-    INT_YZY, ///< Intrinsic rotations with the Euler angles type Y-Z-Y
-    INT_ZXZ, ///< Intrinsic rotations with the Euler angles type Z-X-Z
-    INT_ZYZ, ///< Intrinsic rotations with the Euler angles type Z-Y-Z
-
-    EXT_XYZ, ///< Extrinsic rotations with the Euler angles type X-Y-Z
-    EXT_XZY, ///< Extrinsic rotations with the Euler angles type X-Z-Y
-    EXT_YXZ, ///< Extrinsic rotations with the Euler angles type Y-X-Z
-    EXT_YZX, ///< Extrinsic rotations with the Euler angles type Y-Z-X
-    EXT_ZXY, ///< Extrinsic rotations with the Euler angles type Z-X-Y
-    EXT_ZYX, ///< Extrinsic rotations with the Euler angles type Z-Y-X
-    EXT_XYX, ///< Extrinsic rotations with the Euler angles type X-Y-X
-    EXT_XZX, ///< Extrinsic rotations with the Euler angles type X-Z-X
-    EXT_YXY, ///< Extrinsic rotations with the Euler angles type Y-X-Y
-    EXT_YZY, ///< Extrinsic rotations with the Euler angles type Y-Z-Y
-    EXT_ZXZ, ///< Extrinsic rotations with the Euler angles type Z-X-Z
-    EXT_ZYZ, ///< Extrinsic rotations with the Euler angles type Z-Y-Z
-#ifndef CV_DOXYGEN
-    EULER_ANGLES_MAX_VALUE
-#endif
-  };
-};
-
-template <typename _Tp> class Quat;
-template <typename _Tp>
-std::ostream &operator<<(std::ostream &, const Quat<_Tp> &);
-
-/**
- * Quaternion is a number system that extends the complex numbers. It can be
- * expressed as a rotation in three-dimensional space. A quaternion is generally
- * represented in the form:
- *      \f[q = w + x\boldsymbol{i} + y\boldsymbol{j} + z\boldsymbol{k}\f]
- *      \f[q = [w, x, y, z]\f]
- *      \f[q = [w, \boldsymbol{v}] \f]
- *      \f[q = ||q||[\cos\psi, u_x\sin\psi,u_y\sin\psi,  u_z\sin\psi].\f]
- *      \f[q = ||q||[\cos\psi, \boldsymbol{u}\sin\psi]\f]
- * where \f$\psi = \frac{\theta}{2}\f$, \f$\theta\f$ represents rotation angle,
- * \f$\boldsymbol{u} = [u_x, u_y, u_z]\f$ represents normalized rotation axis,
- * and \f$||q||\f$ represents the norm of \f$q\f$.
- *
- * A unit quaternion is usually represents rotation, which has the form:
- *      \f[q = [\cos\psi, u_x\sin\psi,u_y\sin\psi,  u_z\sin\psi].\f]
- *
- * To create a quaternion representing the rotation around the axis
- * \f$\boldsymbol{u}\f$ with angle \f$\theta\f$, you can use
- * ```
- * using namespace cv;
- * double angle = CV_PI;
- * Vec3d axis = {0, 0, 1};
- * Quatd q = Quatd::createFromAngleAxis(angle, axis);
- * ```
- *
- * You can simply use four same type number to create a quaternion
- * ```
- * Quatd q(1, 2, 3, 4);
- * ```
- * Or use a Vec4d or Vec4f vector.
- * ```
- * Vec4d vec{1, 2, 3, 4};
- * Quatd q(vec);
- * ```
- *
- * ```
- * Vec4f vec{1, 2, 3, 4};
- * Quatf q(vec);
- * ```
- *
- * If you already have a 3x3 rotation matrix R, then you can use
- * ```
- * Quatd q = Quatd::createFromRotMat(R);
- * ```
- *
- * If you already have a rotation vector rvec which has the form of `angle *
- * axis`, then you can use
- * ```
- * Quatd q = Quatd::createFromRvec(rvec);
- * ```
- *
- * To extract the rotation matrix from quaternion, see toRotMat3x3()
- *
- * To extract the Vec4d or Vec4f, see toVec()
- *
- * To extract the rotation vector, see toRotVec()
- *
- * If there are two quaternions \f$q_0, q_1\f$ are needed to interpolate, you
- * can use nlerp(), slerp() or spline()
- * ```
- * Quatd::nlerp(q0, q1, t)
- *
- * Quatd::slerp(q0, q1, t)
- *
- * Quatd::spline(q0, q0, q1, q1, t)
- * ```
- * spline can smoothly connect rotations of  multiple quaternions
- *
- * Three ways to get an element in Quaternion
- * ```
- * Quatf q(1,2,3,4);
- * std::cout << q.w << std::endl; // w=1, x=2, y=3, z=4
- * std::cout << q[0] << std::endl; // q[0]=1, q[1]=2, q[2]=3, q[3]=4
- * std::cout << q.at(0) << std::endl;
- * ```
- */
-template <typename _Tp> class Quat {
-  static_assert(std::is_floating_point<_Tp>::value,
-                "Quaternion only make sense with type of float or double");
-  using value_type = _Tp;
-
-public:
-  static constexpr _Tp CV_QUAT_EPS = (_Tp)1.e-6;
-  static constexpr _Tp CV_QUAT_CONVERT_THRESHOLD = (_Tp)1.e-6;
-
-  Quat();
-
-  /**
-   * @brief From Vec4d or Vec4f.
-   */
-  explicit Quat(const Vec<_Tp, 4> &coeff);
-
-  /**
-   * @brief from four numbers.
-   */
-  Quat(_Tp w, _Tp x, _Tp y, _Tp z);
-
-  /**
-   * @brief from an angle, axis. Axis will be normalized in this function. And
-   * it generates
-   * \f[q = [\cos\psi, u_x\sin\psi,u_y\sin\psi,  u_z\sin\psi].\f]
-   * where \f$\psi = \frac{\theta}{2}\f$, \f$\theta\f$ is the rotation angle.
-   */
-  static Quat<_Tp> createFromAngleAxis(const _Tp angle,
-                                       const Vec<_Tp, 3> &axis);
-
-  /**
-   * @brief from a 3x3 rotation matrix.
-   */
-  static Quat<_Tp> createFromRotMat(InputArray R);
-
-  /**
-   * @brief from a rotation vector
-   * \f$r\f$ has the form \f$\theta \cdot \boldsymbol{u}\f$, where \f$\theta\f$
-   * represents rotation angle and \f$\boldsymbol{u}\f$ represents normalized
-   * rotation axis.
-   *
-   * Angle and axis could be easily derived as:
-   * \f[
-   * \begin{equation}
-   * \begin{split}
-   * \psi &= ||r||\\
-   * \boldsymbol{u} &= \frac{r}{\theta}
-   * \end{split}
-   * \end{equation}
-   * \f]
-   * Then a quaternion can be calculated by
-   *  \f[q = [\cos\psi, \boldsymbol{u}\sin\psi]\f]
-   *  where \f$\psi = \theta / 2 \f$
-   */
-  static Quat<_Tp> createFromRvec(InputArray rvec);
-
-  /**
-   * @brief
-   * from Euler angles
-   *
-   * A quaternion can be generated from Euler angles by combining the quaternion
-   * representations of the Euler rotations.
-   *
-   * For example, if we use intrinsic rotations in the order of
-   * X-Y-Z,\f$\theta_1 \f$ is rotation around the X-axis, \f$\theta_2 \f$ is
-   * rotation around the Y-axis,
-   * \f$\theta_3 \f$ is rotation around the Z-axis. The final quaternion q can
-   * be calculated by
-   *
-   * \f[ {q} = q_{X, \theta_1}  q_{Y, \theta_2} q_{Z, \theta_3}\f]
-   * where \f$ q_{X, \theta_1} \f$ is created from @ref createFromXRot,  \f$
-   * q_{Y, \theta_2} \f$ is created from @ref createFromYRot,
-   *  \f$ q_{Z, \theta_3} \f$ is created from @ref createFromZRot.
-   * @param angles the Euler angles in a vector of length 3
-   * @param eulerAnglesType the convertion Euler angles type
-   */
-  static Quat<_Tp>
-  createFromEulerAngles(const Vec<_Tp, 3> &angles,
-                        QuatEnum::EulerAnglesType eulerAnglesType);
-
-  /**
-   * @brief get a quaternion from a rotation about the Y-axis by \f$\theta\f$ .
-   * \f[q = \cos(\theta/2)+0 i+ sin(\theta/2) j +0k \f]
-   */
-  static Quat<_Tp> createFromYRot(const _Tp theta);
-
-  /**
-   * @brief get a quaternion from a rotation about the X-axis by \f$\theta\f$ .
-   * \f[q = \cos(\theta/2)+sin(\theta/2) i +0 j +0 k \f]
-   */
-  static Quat<_Tp> createFromXRot(const _Tp theta);
-
-  /**
-   * @brief get a quaternion from a rotation about the Z-axis by \f$\theta\f$.
-   * \f[q = \cos(\theta/2)+0 i +0 j +sin(\theta/2) k \f]
-   */
-  static Quat<_Tp> createFromZRot(const _Tp theta);
-
-  /**
-   * @brief a way to get element.
-   * @param index over a range [0, 3].
-   *
-   * A quaternion q
-   *
-   * q.at(0) is equivalent to q.w,
-   *
-   * q.at(1) is equivalent to q.x,
-   *
-   * q.at(2) is equivalent to q.y,
-   *
-   * q.at(3) is equivalent to q.z.
-   */
-  _Tp at(size_t index) const;
-
-  /**
-   * @brief return the conjugate of this quaternion.
-   * \f[q.conjugate() = (w, -x, -y, -z).\f]
-   */
-  Quat<_Tp> conjugate() const;
-
-  /**
-   *
-   * @brief return the value of exponential value.
-   * \f[\exp(q) = e^w (\cos||\boldsymbol{v}||+
-   * \frac{v}{||\boldsymbol{v}||})\sin||\boldsymbol{v}||\f] where
-   * \f$\boldsymbol{v} = [x, y, z].\f$
-   * @param q a quaternion.
-   *
-   * For example:
-   * ```
-   * Quatd q{1,2,3,4};
-   * cout << exp(q) << endl;
-   * ```
-   */
-  template <typename T> friend Quat<T> exp(const Quat<T> &q);
-
-  /**
-   * @brief return the value of exponential value.
-   * \f[\exp(q) = e^w (\cos||\boldsymbol{v}||+
-   * \frac{v}{||\boldsymbol{v}||}\sin||\boldsymbol{v}||)\f] where
-   * \f$\boldsymbol{v} = [x, y, z].\f$
-   *
-   * For example
-   * ```
-   * Quatd q{1,2,3,4};
-   * cout << q.exp() << endl;
-   * ```
-   */
-  Quat<_Tp> exp() const;
-
-  /**
-   * @brief return the value of logarithm function.
-   * \f[\ln(q) = \ln||q|| +
-   * \frac{\boldsymbol{v}}{||\boldsymbol{v}||}\arccos\frac{w}{||q||}.\f] where
-   * \f$\boldsymbol{v} = [x, y, z].\f$
-   * @param q a quaternion.
-   * @param assumeUnit if QUAT_ASSUME_UNIT, q assume to be a unit quaternion and
-   * this function will save some computations.
-   *
-   * For example
-   * ```
-   * Quatd q1{1,2,3,4};
-   * cout << log(q1) << endl;
-   * ```
-   */
-  template <typename T>
-  friend Quat<T> log(const Quat<T> &q, QuatAssumeType assumeUnit);
-
-  /**
-   * @brief return the value of logarithm function.
-   *  \f[\ln(q) = \ln||q|| +
-   * \frac{\boldsymbol{v}}{||\boldsymbol{v}||}\arccos\frac{w}{||q||}\f]. where
-   * \f$\boldsymbol{v} = [x, y, z].\f$
-   * @param assumeUnit if QUAT_ASSUME_UNIT, this quaternion assume to be a unit
-   * quaternion and this function will save some computations.
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * q.log();
-   *
-   * QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
-   * Quatd q1(1,2,3,4);
-   * q1.normalize().log(assumeUnit);
-   * ```
-   */
-  Quat<_Tp> log(QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
-
-  /**
-   * @brief return the value of power function with index \f$x\f$.
-   * \f[q^x = ||q||(cos(x\theta) + \boldsymbol{u}sin(x\theta))).\f]
-   * @param q a quaternion.
-   * @param x index of exponentiation.
-   * @param assumeUnit if QUAT_ASSUME_UNIT, quaternion q assume to be a unit
-   * quaternion and this function will save some computations.
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * power(q, 2.0);
-   *
-   * QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
-   * double angle = CV_PI;
-   * Vec3d axis{0, 0, 1};
-   * Quatd q1 = Quatd::createFromAngleAxis(angle, axis); //generate a unit quat
-   * by axis and angle power(q1, 2.0, assumeUnit);//This assumeUnit means q1 is
-   * a unit quaternion.
-   * ```
-   * @note the type of the index should be the same as the quaternion.
-   */
-  template <typename T>
-  friend Quat<T> power(const Quat<T> &q, const T x, QuatAssumeType assumeUnit);
-
-  /**
-   * @brief return the value of power function with index \f$x\f$.
-   * \f[q^x = ||q||(\cos(x\theta) + \boldsymbol{u}\sin(x\theta))).\f]
-   * @param x index of exponentiation.
-   * @param assumeUnit if QUAT_ASSUME_UNIT, this quaternion assume to be a unit
-   * quaternion and this function will save some computations.
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * q.power(2.0);
-   *
-   * QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
-   * double angle = CV_PI;
-   * Vec3d axis{0, 0, 1};
-   * Quatd q1 = Quatd::createFromAngleAxis(angle, axis); //generate a unit quat
-   * by axis and angle q1.power(2.0, assumeUnit); //This assumeUnt means q1 is a
-   * unit quaternion
-   * ```
-   */
-  Quat<_Tp> power(const _Tp x,
-                  QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
-
-  /**
-   * @brief return \f$\sqrt{q}\f$.
-   * @param q a quaternion.
-   * @param assumeUnit if QUAT_ASSUME_UNIT, quaternion q assume to be a unit
-   * quaternion and this function will save some computations.
-   *
-   * For example
-   * ```
-   * Quatf q(1,2,3,4);
-   * sqrt(q);
-   *
-   * QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
-   * q = {1,0,0,0};
-   * sqrt(q, assumeUnit); //This assumeUnit means q is a unit quaternion.
-   * ```
-   */
-  template <typename T>
-  friend Quat<T> sqrt(const Quat<T> &q, QuatAssumeType assumeUnit);
-
-  /**
-   * @brief return \f$\sqrt{q}\f$.
-   * @param assumeUnit if QUAT_ASSUME_UNIT, this quaternion assume to be a unit
-   * quaternion and this function will save some computations.
-   *
-   * For example
-   * ```
-   * Quatf q(1,2,3,4);
-   * q.sqrt();
-   *
-   * QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
-   * q = {1,0,0,0};
-   * q.sqrt(assumeUnit); //This assumeUnit means q is a unit quaternion
-   * ```
-   */
-  Quat<_Tp> sqrt(QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
-
-  /**
-   * @brief return the value of power function with quaternion \f$q\f$.
-   * \f[p^q = e^{q\ln(p)}.\f]
-   * @param p base quaternion of power function.
-   * @param q index quaternion of power function.
-   * @param assumeUnit if QUAT_ASSUME_UNIT, quaternion \f$p\f$ assume to be a
-   * unit quaternion and this function will save some computations.
-   *
-   * For example
-   * ```
-   * Quatd p(1,2,3,4);
-   * Quatd q(5,6,7,8);
-   * power(p, q);
-   *
-   * QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
-   * p = p.normalize();
-   * power(p, q, assumeUnit); //This assumeUnit means p is a unit quaternion
-   * ```
-   */
-  template <typename T>
-  friend Quat<T> power(const Quat<T> &p, const Quat<T> &q,
-                       QuatAssumeType assumeUnit);
-
-  /**
-   * @brief return the value of power function with quaternion \f$q\f$.
-   * \f[p^q = e^{q\ln(p)}.\f]
-   * @param q index quaternion of power function.
-   * @param assumeUnit if QUAT_ASSUME_UNIT, this quaternion assume to be a unit
-   * quaternion and this function will save some computations.
-   *
-   * For example
-   * ```
-   * Quatd p(1,2,3,4);
-   * Quatd q(5,6,7,8);
-   * p.power(q);
-   *
-   * QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
-   * p = p.normalize();
-   * p.power(q, assumeUnit); //This assumeUnit means p is a unit quaternion
-   * ```
-   */
-  Quat<_Tp> power(const Quat<_Tp> &q,
-                  QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
-
-  /**
-   * @brief return the crossProduct between \f$p = (a, b, c, d) = (a,
-   * \boldsymbol{u})\f$ and \f$q = (w, x, y, z) = (w, \boldsymbol{v})\f$.
-   * \f[p \times q = \frac{pq- qp}{2}\f]
-   * \f[p \times q = \boldsymbol{u} \times \boldsymbol{v}\f]
-   * \f[p \times q = (cz-dy)i + (dx-bz)j + (by-xc)k \f]
-   *
-   * For example
-   * ```
-   * Quatd q{1,2,3,4};
-   * Quatd p{5,6,7,8};
-   * crossProduct(p, q);
-   * ```
-   */
-  template <typename T>
-  friend Quat<T> crossProduct(const Quat<T> &p, const Quat<T> &q);
-
-  /**
-   * @brief return the crossProduct between \f$p = (a, b, c, d) = (a,
-   * \boldsymbol{u})\f$ and \f$q = (w, x, y, z) = (w, \boldsymbol{v})\f$.
-   * \f[p \times q = \frac{pq- qp}{2}.\f]
-   * \f[p \times q = \boldsymbol{u} \times \boldsymbol{v}.\f]
-   * \f[p \times q = (cz-dy)i + (dx-bz)j + (by-xc)k. \f]
-   *
-   * For example
-   * ```
-   * Quatd q{1,2,3,4};
-   * Quatd p{5,6,7,8};
-   * p.crossProduct(q)
-   * ```
-   */
-  Quat<_Tp> crossProduct(const Quat<_Tp> &q) const;
-
-  /**
-   * @brief return the norm of quaternion.
-   * \f[||q|| = \sqrt{w^2 + x^2 + y^2 + z^2}.\f]
-   */
-  _Tp norm() const;
-
-  /**
-   * @brief return a normalized \f$p\f$.
-   * \f[p = \frac{q}{||q||}\f]
-   * where \f$p\f$ satisfies \f$(p.x)^2 + (p.y)^2 + (p.z)^2 + (p.w)^2 = 1.\f$
-   */
-  Quat<_Tp> normalize() const;
-
-  /**
-   * @brief return \f$q^{-1}\f$ which is an inverse of \f$q\f$
-   * which satisfies \f$q * q^{-1} = 1\f$.
-   * @param q a quaternion.
-   * @param assumeUnit if QUAT_ASSUME_UNIT, quaternion q assume to be a unit
-   * quaternion and this function will save some computations.
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * inv(q);
-   *
-   * QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
-   * q = q.normalize();
-   * inv(q, assumeUnit);//This assumeUnit means p is a unit quaternion
-   * ```
-   */
-  template <typename T>
-  friend Quat<T> inv(const Quat<T> &q, QuatAssumeType assumeUnit);
-
-  /**
-   * @brief return \f$q^{-1}\f$ which is an inverse of \f$q\f$
-   * satisfying \f$q * q^{-1} = 1\f$.
-   * @param assumeUnit if QUAT_ASSUME_UNIT, quaternion q assume to be a unit
-   * quaternion and this function will save some computations.
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * q.inv();
-   *
-   * QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
-   * q = q.normalize();
-   * q.inv(assumeUnit);  //assumeUnit means p is a unit quaternion
-   * ```
-   */
-  Quat<_Tp> inv(QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
-
-  /**
-   * @brief return sinh value of quaternion q, sinh could be calculated as:
-   * \f[\sinh(p) = \sin(w)\cos(||\boldsymbol{v}||) +
-   * \cosh(w)\frac{v}{||\boldsymbol{v}||}\sin||\boldsymbol{v}||\f] where
-   * \f$\boldsymbol{v} = [x, y, z].\f$
-   * @param q a quaternion.
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * sinh(q);
-   * ```
-   */
-  template <typename T> friend Quat<T> sinh(const Quat<T> &q);
-
-  /**
-   * @brief return sinh value of this quaternion, sinh could be calculated as:
-   * \f$\sinh(p) = \sin(w)\cos(||\boldsymbol{v}||) +
-   * \cosh(w)\frac{v}{||\boldsymbol{v}||}\sin||\boldsymbol{v}||\f$ where
-   * \f$\boldsymbol{v} = [x, y, z].\f$
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * q.sinh();
-   * ```
-   */
-  Quat<_Tp> sinh() const;
-
-  /**
-   * @brief return cosh value of quaternion q, cosh could be calculated as:
-   * \f[\cosh(p) = \cosh(w) * \cos(||\boldsymbol{v}||) +
-   * \sinh(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}\sin(||\boldsymbol{v}||)\f]
-   * where \f$\boldsymbol{v} = [x, y, z].\f$
-   * @param q a quaternion.
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * cosh(q);
-   * ```
-   */
-  template <typename T> friend Quat<T> cosh(const Quat<T> &q);
-
-  /**
-   * @brief return cosh value of this quaternion, cosh could be calculated as:
-   * \f[\cosh(p) = \cosh(w) * \cos(||\boldsymbol{v}||) +
-   * \sinh(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}sin(||\boldsymbol{v}||)\f]
-   * where \f$\boldsymbol{v} = [x, y, z].\f$
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * q.cosh();
-   * ```
-   */
-  Quat<_Tp> cosh() const;
-
-  /**
-   * @brief return tanh value of quaternion q, tanh could be calculated as:
-   * \f[ \tanh(q) = \frac{\sinh(q)}{\cosh(q)}.\f]
-   * @param q a quaternion.
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * tanh(q);
-   * ```
-   * @sa sinh, cosh
-   */
-  template <typename T> friend Quat<T> tanh(const Quat<T> &q);
-
-  /**
-   * @brief return tanh value of this quaternion, tanh could be calculated as:
-   * \f[ \tanh(q) = \frac{\sinh(q)}{\cosh(q)}.\f]
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * q.tanh();
-   * ```
-   * @sa sinh, cosh
-   */
-  Quat<_Tp> tanh() const;
-
-  /**
-   * @brief return tanh value of quaternion q, sin could be calculated as:
-   * \f[\sin(p) = \sin(w) * \cosh(||\boldsymbol{v}||) +
-   * \cos(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}\sinh(||\boldsymbol{v}||)\f]
-   * where \f$\boldsymbol{v} = [x, y, z].\f$
-   * @param q a quaternion.
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * sin(q);
-   * ```
-   */
-  template <typename T> friend Quat<T> sin(const Quat<T> &q);
-
-  /**
-   * @brief return sin value of this quaternion, sin could be calculated as:
-   * \f[\sin(p) = \sin(w) * \cosh(||\boldsymbol{v}||) +
-   * \cos(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}\sinh(||\boldsymbol{v}||)\f]
-   * where \f$\boldsymbol{v} = [x, y, z].\f$
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * q.sin();
-   * ```
-   */
-  Quat<_Tp> sin() const;
-
-  /**
-   * @brief return sin value of quaternion q, cos could be calculated as:
-   * \f[\cos(p) = \cos(w) * \cosh(||\boldsymbol{v}||) -
-   * \sin(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}\sinh(||\boldsymbol{v}||)\f]
-   * where \f$\boldsymbol{v} = [x, y, z].\f$
-   * @param q a quaternion.
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * cos(q);
-   * ```
-   */
-  template <typename T> friend Quat<T> cos(const Quat<T> &q);
-
-  /**
-   * @brief return cos value of this quaternion, cos could be calculated as:
-   * \f[\cos(p) = \cos(w) * \cosh(||\boldsymbol{v}||) -
-   * \sin(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}\sinh(||\boldsymbol{v}||)\f]
-   * where \f$\boldsymbol{v} = [x, y, z].\f$
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * q.cos();
-   * ```
-   */
-  Quat<_Tp> cos() const;
-
-  /**
-   * @brief return tan value of quaternion q, tan could be calculated as:
-   * \f[\tan(q) = \frac{\sin(q)}{\cos(q)}.\f]
-   * @param q a quaternion.
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * tan(q);
-   * ```
-   */
-  template <typename T> friend Quat<T> tan(const Quat<T> &q);
-
-  /**
-   * @brief return tan value of this quaternion, tan could be calculated as:
-   * \f[\tan(q) = \frac{\sin(q)}{\cos(q)}.\f]
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * q.tan();
-   * ```
-   */
-  Quat<_Tp> tan() const;
-
-  /**
-   * @brief return arcsin value of quaternion q, arcsin could be calculated as:
-   * \f[\arcsin(q) =
-   * -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arcsinh(q\frac{\boldsymbol{v}}{||\boldsymbol{v}||})\f]
-   * where \f$\boldsymbol{v} = [x, y, z].\f$
-   * @param q a quaternion.
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * asin(q);
-   * ```
-   */
-  template <typename T> friend Quat<T> asin(const Quat<T> &q);
-
-  /**
-   * @brief return arcsin value of this quaternion, arcsin could be calculated
-   * as:
-   * \f[\arcsin(q) =
-   * -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arcsinh(q\frac{\boldsymbol{v}}{||\boldsymbol{v}||})\f]
-   * where \f$\boldsymbol{v} = [x, y, z].\f$
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * q.asin();
-   * ```
-   */
-  Quat<_Tp> asin() const;
-
-  /**
-   * @brief return arccos value of quaternion q, arccos could be calculated as:
-   * \f[\arccos(q) = -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arccosh(q)\f]
-   * where \f$\boldsymbol{v} = [x, y, z].\f$
-   * @param q a quaternion.
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * acos(q);
-   * ```
-   */
-  template <typename T> friend Quat<T> acos(const Quat<T> &q);
-
-  /**
-   * @brief return arccos value of this quaternion, arccos could be calculated
-   * as:
-   * \f[\arccos(q) = -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arccosh(q)\f]
-   * where \f$\boldsymbol{v} = [x, y, z].\f$
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * q.acos();
-   * ```
-   */
-  Quat<_Tp> acos() const;
-
-  /**
-   * @brief return arctan value of quaternion q, arctan could be calculated as:
-   * \f[\arctan(q) =
-   * -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arctanh(q\frac{\boldsymbol{v}}{||\boldsymbol{v}||})\f]
-   * where \f$\boldsymbol{v} = [x, y, z].\f$
-   * @param q a quaternion.
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * atan(q);
-   * ```
-   */
-  template <typename T> friend Quat<T> atan(const Quat<T> &q);
-
-  /**
-   * @brief return arctan value of this quaternion, arctan could be calculated
-   * as:
-   * \f[\arctan(q) =
-   * -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arctanh(q\frac{\boldsymbol{v}}{||\boldsymbol{v}||})\f]
-   * where \f$\boldsymbol{v} = [x, y, z].\f$
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * q.atan();
-   * ```
-   */
-  Quat<_Tp> atan() const;
-
-  /**
-   * @brief return arcsinh value of quaternion q, arcsinh could be calculated
-   * as:
-   * \f[arcsinh(q) = \ln(q + \sqrt{q^2 + 1})\f].
-   * @param q a quaternion.
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * asinh(q);
-   * ```
-   */
-  template <typename T> friend Quat<T> asinh(const Quat<T> &q);
-
-  /**
-   * @brief return arcsinh value of this quaternion, arcsinh could be calculated
-   * as:
-   * \f[arcsinh(q) = \ln(q + \sqrt{q^2 + 1})\f].
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * q.asinh();
-   * ```
-   */
-  Quat<_Tp> asinh() const;
-
-  /**
-   * @brief return arccosh value of quaternion q, arccosh could be calculated
-   * as:
-   * \f[arccosh(q) = \ln(q + \sqrt{q^2 - 1})\f].
-   * @param q a quaternion.
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * acosh(q);
-   * ```
-   */
-  template <typename T> friend Quat<T> acosh(const Quat<T> &q);
-
-  /**
-   * @brief return arccosh value of this quaternion, arccosh could be calculated
-   * as:
-   * \f[arcosh(q) = \ln(q + \sqrt{q^2 - 1})\f].
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * q.acosh();
-   * ```
-   */
-  Quat<_Tp> acosh() const;
-
-  /**
-   * @brief return arctanh value of quaternion q, arctanh could be calculated
-   * as:
-   * \f[arctanh(q) = \frac{\ln(q + 1) - \ln(1 - q)}{2}\f].
-   * @param q a quaternion.
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * atanh(q);
-   * ```
-   */
-  template <typename T> friend Quat<T> atanh(const Quat<T> &q);
-
-  /**
-   * @brief return arctanh value of this quaternion, arctanh could be calculated
-   * as:
-   * \f[arcsinh(q) = \frac{\ln(q + 1) - \ln(1 - q)}{2}\f].
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * q.atanh();
-   * ```
-   */
-  Quat<_Tp> atanh() const;
-
-  /**
-   * @brief return true if this quaternion is a unit quaternion.
-   * @param eps tolerance scope of normalization. The eps could be defined as
-   *
-   * \f[eps = |1 - dotValue|\f] where \f[dotValue = (this.w^2 + this.x^2 +
-   * this,y^2 + this.z^2).\f] And this function will consider it is normalized
-   * when the dotValue over a range \f$[1-eps, 1+eps]\f$.
-   */
-  bool isNormal(_Tp eps = CV_QUAT_EPS) const;
-
-  /**
-   * @brief to throw an error if this quaternion is not a unit quaternion.
-   * @param eps tolerance scope of normalization.
-   * @sa isNormal
-   */
-  void assertNormal(_Tp eps = CV_QUAT_EPS) const;
-
-  /**
-   * @brief transform a quaternion to a 3x3 rotation matrix.
-   * @param assumeUnit if QUAT_ASSUME_UNIT, this quaternion assume to be a unit
-   quaternion and
-   * this function will save some computations. Otherwise, this function will
-   normalize this
-   * quaternion at first then do the transformation.
-   *
-   * @note Matrix A which is to be rotated should have the form
-   * \f[\begin{bmatrix}
-   * x_0& x_1& x_2&...&x_n\\
-   * y_0& y_1& y_2&...&y_n\\
-   * z_0& z_1& z_2&...&z_n
-   * \end{bmatrix}\f]
-   * where the same subscript represents a point. The shape of A assume to be
-   [3, n]
-   * The points matrix A can be rotated by toRotMat3x3() * A.
-   * The result has 3 rows and n columns too.
-
-   * For example
-   * ```
-   * double angle = CV_PI;
-   * Vec3d axis{0,0,1};
-   * Quatd q_unit = Quatd::createFromAngleAxis(angle, axis); //quaternion could
-   also be get by interpolation by two or more quaternions.
-   *
-   * //assume there is two points (1,0,0) and (1,0,1) to be rotated
-   * Mat pointsA = (Mat_<double>(2, 3) << 1,0,0,1,0,1);
-   * //change the shape
-   * pointsA = pointsA.t();
-   * // rotate 180 degrees around the z axis
-   * Mat new_point = q_unit.toRotMat3x3() * pointsA;
-   * // print two points
-   * cout << new_point << endl;
-   * ```
-   */
-  Matx<_Tp, 3, 3>
-  toRotMat3x3(QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
-
-  /**
-   * @brief transform a quaternion to a 4x4 rotation matrix.
-   * @param assumeUnit if QUAT_ASSUME_UNIT, this quaternion assume to be a unit
-   * quaternion and this function will save some computations. Otherwise, this
-   * function will normalize this quaternion at first then do the
-   * transformation.
-   *
-   * The operations is similar as toRotMat3x3
-   * except that the points matrix should have the form
-   * \f[\begin{bmatrix}
-   * x_0& x_1& x_2&...&x_n\\
-   * y_0& y_1& y_2&...&y_n\\
-   * z_0& z_1& z_2&...&z_n\\
-   * 0&0&0&...&0
-   * \end{bmatrix}\f]
-   *
-   * @sa toRotMat3x3
-   */
-
-  Matx<_Tp, 4, 4>
-  toRotMat4x4(QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
-
-  /**
-   * @brief transform the this quaternion to a Vec<T, 4>.
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * q.toVec();
-   * ```
-   */
-  Vec<_Tp, 4> toVec() const;
-
-  /**
-   * @brief transform this quaternion to a Rotation vector.
-   * @param assumeUnit if QUAT_ASSUME_UNIT, this quaternion assume to be a unit
-   * quaternion and this function will save some computations. Rotation vector
-   * rVec is defined as:
-   * \f[ rVec = [\theta v_x, \theta v_y, \theta v_z]\f]
-   * where \f$\theta\f$ represents rotation angle, and \f$\boldsymbol{v}\f$
-   * represents the normalized rotation axis.
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * q.toRotVec();
-   *
-   * QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
-   * q.normalize().toRotVec(assumeUnit); //answer is same as q.toRotVec().
-   * ```
-   */
-  Vec<_Tp, 3> toRotVec(QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
-
-  /**
-   * @brief get the angle of quaternion, it returns the rotation angle.
-   * @param assumeUnit if QUAT_ASSUME_UNIT, this quaternion assume to be a unit
-   * quaternion and this function will save some computations.
-   * \f[\psi = 2 *arccos(\frac{w}{||q||})\f]
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * q.getAngle();
-   *
-   * QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
-   * q.normalize().getAngle(assumeUnit);//same as q.getAngle().
-   * ```
-   * @note It always return the value between \f$[0, 2\pi]\f$.
-   */
-  _Tp getAngle(QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
-
-  /**
-   * @brief get the axis of quaternion, it returns a vector of length 3.
-   * @param assumeUnit if QUAT_ASSUME_UNIT, this quaternion assume to be a unit
-   * quaternion and this function will save some computations.
-   *
-   * the unit axis \f$\boldsymbol{u}\f$ is defined by
-   * \f[\begin{equation}
-   *    \begin{split}
-   *      \boldsymbol{v}
-   *      &= \boldsymbol{u} ||\boldsymbol{v}||\\
-   *      &= \boldsymbol{u}||q||sin(\frac{\theta}{2})
-   *    \end{split}
-   *    \end{equation}\f]
-   *  where \f$v=[x, y ,z]\f$ and \f$\theta\f$ represents rotation angle.
-   *
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * q.getAxis();
-   *
-   * QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
-   * q.normalize().getAxis(assumeUnit);//same as q.getAxis()
-   * ```
-   */
-  Vec<_Tp, 3> getAxis(QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
-
-  /**
-   * @brief return the dot between quaternion \f$q\f$ and this quaternion.
-   *
-   * dot(p, q) is a good metric of how close the quaternions are.
-   * Indeed, consider the unit quaternion difference \f$p^{-1} * q\f$, its real
-   * part is dot(p, q). At the same time its real part is equal to
-   * \f$\cos(\beta/2)\f$ where \f$\beta\f$ is an angle of rotation between p and
-   * q, i.e., Therefore, the closer dot(p, q) to 1, the smaller rotation between
-   * them.
-   * \f[p \cdot q = p.w \cdot q.w + p.x \cdot q.x + p.y \cdot q.y + p.z \cdot
-   * q.z\f]
-   * @param q the other quaternion.
-   *
-   * For example
-   * ```
-   * Quatd q(1,2,3,4);
-   * Quatd p(5,6,7,8);
-   * p.dot(q);
-   * ```
-   */
-  _Tp dot(Quat<_Tp> q) const;
-
-  /**
-   * @brief To calculate the interpolation from \f$q_0\f$ to \f$q_1\f$ by Linear
-   * Interpolation(Nlerp) For two quaternions, this interpolation curve can be
-   * displayed as:
-   * \f[Lerp(q_0, q_1, t) = (1 - t)q_0 + tq_1.\f]
-   * Obviously, the lerp will interpolate along a straight line if we think of
-   * \f$q_0\f$ and \f$q_1\f$ as a vector in a two-dimensional space. When \f$t =
-   * 0\f$, it returns \f$q_0\f$ and when \f$t= 1\f$, it returns \f$q_1\f$.
-   * \f$t\f$ should to be ranged in \f$[0, 1]\f$ normally.
-   * @param q0 a quaternion used in linear interpolation.
-   * @param q1 a quaternion used in linear interpolation.
-   * @param t percent of vector \f$\overrightarrow{q_0q_1}\f$ over a range [0,
-   * 1].
-   * @note it returns a non-unit quaternion.
-   */
-  static Quat<_Tp> lerp(const Quat<_Tp> &q0, const Quat &q1, const _Tp t);
-
-  /**
-   * @brief To calculate the interpolation from \f$q_0\f$ to \f$q_1\f$ by
-   Normalized Linear Interpolation(Nlerp).
-   * it returns a normalized quaternion of Linear Interpolation(Lerp).
-   * \f[ Nlerp(q_0, q_1, t) = \frac{(1 - t)q_0 + tq_1}{||(1 - t)q_0 +
-   tq_1||}.\f]
-   * The interpolation will always choose the shortest path but the constant
-   speed is not guaranteed.
-   * @param q0 a quaternion used in normalized linear interpolation.
-   * @param q1 a quaternion used in normalized linear interpolation.
-   * @param t percent of vector \f$\overrightarrow{q_0q_1}\f$ over a range [0,
-   1].
-   * @param assumeUnit if QUAT_ASSUME_UNIT, all input quaternions assume to be
-   unit quaternion. Otherwise, all inputs quaternion will be normalized inside
-   the function.
-   * @sa lerp
-   */
-  static Quat<_Tp> nlerp(const Quat<_Tp> &q0, const Quat &q1, const _Tp t,
-                         QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT);
-
-  /**
-   @brief To calculate the interpolation between \f$q_0\f$ and \f$q_1\f$ by
-  Spherical Linear Interpolation(Slerp), which can be defined as:
-  \f[ Slerp(q_0, q_1, t) = \frac{\sin((1-t)\theta)}{\sin(\theta)}q_0 +
-  \frac{\sin(t\theta)}{\sin(\theta)}q_1\f] where \f$\theta\f$ can be calculated
-  as:
-  \f[\theta=cos^{-1}(q_0\cdot q_1)\f]
-  resulting from the both of their norm is unit.
-  @param q0 a quaternion used in Slerp.
-  @param q1 a quaternion used in Slerp.
-  @param t percent of angle between \f$q_0\f$ and \f$q_1\f$ over a range [0, 1].
-  @param assumeUnit if QUAT_ASSUME_UNIT, all input quaternions assume to be unit
-  quaternions. Otherwise, all input quaternions will be normalized inside the
-  function.
-  @param directChange if QUAT_ASSUME_UNIT, the interpolation will choose the
-  nearest path.
-  @note If the interpolation angle is small, the error between Nlerp and Slerp
-  is not so large. To improve efficiency and avoid zero division error, we use
-  Nlerp instead of Slerp.
-  */
-  static Quat<_Tp> slerp(const Quat<_Tp> &q0, const Quat &q1, const _Tp t,
-                         QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT,
-                         bool directChange = true);
-
-  /**
-   * @brief To calculate the interpolation between
-   * \f$q_0\f$,\f$q_1\f$,\f$q_2\f$,\f$q_3\f$  by Spherical and
-   * quadrangle(Squad). This could be defined as:
-   * \f[Squad(q_i, s_i, s_{i+1}, q_{i+1}, t) = Slerp(Slerp(q_i, q_{i+1}, t),
-   * Slerp(s_i, s_{i+1}, t), 2t(1-t))\f] where
-   * \f[s_i = q_i\exp(-\frac{\log(q^*_iq_{i+1}) + \log(q^*_iq_{i-1})}{4})\f]
-   *
-   * The Squad expression is analogous to the \f$B\acute{e}zier\f$ curve, but
-   * involves spherical linear interpolation instead of simple linear
-   * interpolation. Each \f$s_i\f$ needs to be calculated by three quaternions.
-   *
-   * @param q0 the first quaternion.
-   * @param s0 the second quaternion.
-   * @param s1 the third quaternion.
-   * @param q1 thr fourth quaternion.
-   * @param t interpolation parameter of quadratic and linear interpolation over
-   * a range \f$[0, 1]\f$.
-   * @param assumeUnit if QUAT_ASSUME_UNIT, all input quaternions assume to be
-   * unit quaternion. Otherwise, all input quaternions will be normalized inside
-   * the function.
-   * @param directChange if QUAT_ASSUME_UNIT, squad will find the nearest path
-   * to interpolate.
-   * @sa interPoint, spline
-   */
-  static Quat<_Tp> squad(const Quat<_Tp> &q0, const Quat<_Tp> &s0,
-                         const Quat<_Tp> &s1, const Quat<_Tp> &q1, const _Tp t,
-                         QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT,
-                         bool directChange = true);
-
-  /**
-   * @brief This is the part calculation of squad.
-   * To calculate the intermedia quaternion \f$s_i\f$ between each three
-   * quaternion
-   * \f[s_i = q_i\exp(-\frac{\log(q^*_iq_{i+1}) + \log(q^*_iq_{i-1})}{4}).\f]
-   * @param q0 the first quaternion.
-   * @param q1 the second quaternion.
-   * @param q2 the third quaternion.
-   * @param assumeUnit if QUAT_ASSUME_UNIT, all input quaternions assume to be
-   * unit quaternion. Otherwise, all input quaternions will be normalized inside
-   * the function.
-   * @sa squad
-   */
-  static Quat<_Tp> interPoint(const Quat<_Tp> &q0, const Quat<_Tp> &q1,
-                              const Quat<_Tp> &q2,
-                              QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT);
-
-  /**
-   * @brief to calculate a quaternion which is the result of a \f$C^1\f$
-   * continuous spline curve constructed by squad at the ratio t. Here, the
-   * interpolation values are between \f$q_1\f$ and \f$q_2\f$. \f$q_0\f$ and
-   * \f$q_2\f$ are used to ensure the \f$C^1\f$ continuity. if t = 0, it returns
-   * \f$q_1\f$, if t = 1, it returns \f$q_2\f$.
-   * @param q0 the first input quaternion to ensure \f$C^1\f$ continuity.
-   * @param q1 the second input quaternion.
-   * @param q2 the third input quaternion.
-   * @param q3 the fourth input quaternion the same use of \f$q1\f$.
-   * @param t ratio over a range [0, 1].
-   * @param assumeUnit if QUAT_ASSUME_UNIT, \f$q_0, q_1, q_2, q_3\f$ assume to
-   * be unit quaternion. Otherwise, all input quaternions will be normalized
-   * inside the function.
-   *
-   * For example:
-   *
-   * If there are three double quaternions \f$v_0, v_1, v_2\f$ waiting to be
-   * interpolated.
-   *
-   * Interpolation between \f$v_0\f$ and \f$v_1\f$ with a ratio \f$t_0\f$ could
-   * be calculated as
-   * ```
-   * Quatd::spline(v0, v0, v1, v2, t0);
-   * ```
-   * Interpolation between \f$v_1\f$ and \f$v_2\f$ with a ratio \f$t_0\f$ could
-   * be calculated as
-   * ```
-   * Quatd::spline(v0, v1, v2, v2, t0);
-   * ```
-   * @sa squad, slerp
-   */
-  static Quat<_Tp> spline(const Quat<_Tp> &q0, const Quat<_Tp> &q1,
-                          const Quat<_Tp> &q2, const Quat<_Tp> &q3, const _Tp t,
-                          QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT);
-
-  /**
-   * @brief Return opposite quaternion \f$-p\f$
-   * which satisfies \f$p + (-p) = 0.\f$
-   *
-   * For example
-   * ```
-   * Quatd q{1, 2, 3, 4};
-   * std::cout << -q << std::endl; // [-1, -2, -3, -4]
-   * ```
-   */
-  Quat<_Tp> operator-() const;
-
-  /**
-   * @brief return true if two quaternions p and q are nearly equal, i.e. when
-   * the absolute value of each \f$p_i\f$ and \f$q_i\f$ is less than
-   * CV_QUAT_EPS.
-   */
-  bool operator==(const Quat<_Tp> &) const;
-
-  /**
-   * @brief Addition operator of two quaternions p and q.
-   * It returns a new quaternion that each value is the sum of \f$p_i\f$ and
-   * \f$q_i\f$.
-   *
-   * For example
-   * ```
-   * Quatd p{1, 2, 3, 4};
-   * Quatd q{5, 6, 7, 8};
-   * std::cout << p + q << std::endl; //[6, 8, 10, 12]
-   * ```
-   */
-  Quat<_Tp> operator+(const Quat<_Tp> &) const;
-
-  /**
-   * @brief Addition assignment operator of two quaternions p and q.
-   * It adds right operand to the left operand and assign the result to left
-   * operand.
-   *
-   * For example
-   * ```
-   * Quatd p{1, 2, 3, 4};
-   * Quatd q{5, 6, 7, 8};
-   * p += q; // equivalent to p = p + q
-   * std::cout << p << std::endl; //[6, 8, 10, 12]
-   *
-   * ```
-   */
-  Quat<_Tp> &operator+=(const Quat<_Tp> &);
-
-  /**
-   * @brief Subtraction operator of two quaternions p and q.
-   * It returns a new quaternion that each value is the sum of \f$p_i\f$ and
-   * \f$-q_i\f$.
-   *
-   * For example
-   * ```
-   * Quatd p{1, 2, 3, 4};
-   * Quatd q{5, 6, 7, 8};
-   * std::cout << p - q << std::endl; //[-4, -4, -4, -4]
-   * ```
-   */
-  Quat<_Tp> operator-(const Quat<_Tp> &) const;
-
-  /**
-   * @brief Subtraction assignment operator of two quaternions p and q.
-   * It subtracts right operand from the left operand and assign the result to
-   * left operand.
-   *
-   * For example
-   * ```
-   * Quatd p{1, 2, 3, 4};
-   * Quatd q{5, 6, 7, 8};
-   * p -= q; // equivalent to p = p - q
-   * std::cout << p << std::endl; //[-4, -4, -4, -4]
-   *
-   * ```
-   */
-  Quat<_Tp> &operator-=(const Quat<_Tp> &);
-
-  /**
-   * @brief Multiplication assignment operator of two quaternions q and p.
-   * It multiplies right operand with the left operand and assign the result to
-   * left operand.
-   *
-   * Rule of quaternion multiplication:
-   * \f[
-   * \begin{equation}
-   * \begin{split}
-   * p * q &= [p_0, \boldsymbol{u}]*[q_0, \boldsymbol{v}]\\
-   * &=[p_0q_0 - \boldsymbol{u}\cdot \boldsymbol{v}, p_0\boldsymbol{v} +
-   * q_0\boldsymbol{u}+ \boldsymbol{u}\times \boldsymbol{v}].
-   * \end{split}
-   * \end{equation}
-   * \f]
-   * where \f$\cdot\f$ means dot product and \f$\times \f$ means cross product.
-   *
-   * For example
-   * ```
-   * Quatd p{1, 2, 3, 4};
-   * Quatd q{5, 6, 7, 8};
-   * p *= q; // equivalent to p = p * q
-   * std::cout << p << std::endl; //[-60, 12, 30, 24]
-   * ```
-   */
-  Quat<_Tp> &operator*=(const Quat<_Tp> &);
-
-  /**
-   * @brief Multiplication assignment operator of a quaternions and a scalar.
-   * It multiplies right operand with the left operand and assign the result to
-   * left operand.
-   *
-   * Rule of quaternion multiplication with a scalar:
-   * \f[
-   * \begin{equation}
-   * \begin{split}
-   * p * s &= [w, x, y, z] * s\\
-   * &=[w * s, x * s, y * s, z * s].
-   * \end{split}
-   * \end{equation}
-   * \f]
-   *
-   * For example
-   * ```
-   * Quatd p{1, 2, 3, 4};
-   * double s = 2.0;
-   * p *= s; // equivalent to p = p * s
-   * std::cout << p << std::endl; //[2.0, 4.0, 6.0, 8.0]
-   * ```
-   * @note the type of scalar should be equal to the quaternion.
-   */
-  Quat<_Tp> &operator*=(const _Tp s);
-
-  /**
-   * @brief Multiplication operator of two quaternions q and p.
-   * Multiplies values on either side of the operator.
-   *
-   * Rule of quaternion multiplication:
-   * \f[
-   * \begin{equation}
-   * \begin{split}
-   * p * q &= [p_0, \boldsymbol{u}]*[q_0, \boldsymbol{v}]\\
-   * &=[p_0q_0 - \boldsymbol{u}\cdot \boldsymbol{v}, p_0\boldsymbol{v} +
-   * q_0\boldsymbol{u}+ \boldsymbol{u}\times \boldsymbol{v}].
-   * \end{split}
-   * \end{equation}
-   * \f]
-   * where \f$\cdot\f$ means dot product and \f$\times \f$ means cross product.
-   *
-   * For example
-   * ```
-   * Quatd p{1, 2, 3, 4};
-   * Quatd q{5, 6, 7, 8};
-   * std::cout << p * q << std::endl; //[-60, 12, 30, 24]
-   * ```
-   */
-  Quat<_Tp> operator*(const Quat<_Tp> &) const;
-
-  /**
-   * @brief Division operator of a quaternions and a scalar.
-   * It divides left operand with the right operand and assign the result to
-   * left operand.
-   *
-   * Rule of quaternion division with a scalar:
-   * \f[
-   * \begin{equation}
-   * \begin{split}
-   * p / s &= [w, x, y, z] / s\\
-   * &=[w/s, x/s, y/s, z/s].
-   * \end{split}
-   * \end{equation}
-   * \f]
-   *
-   * For example
-   * ```
-   * Quatd p{1, 2, 3, 4};
-   * double s = 2.0;
-   * p /= s; // equivalent to p = p / s
-   * std::cout << p << std::endl; //[0.5, 1, 1.5, 2]
-   * ```
-   * @note the type of scalar should be equal to this quaternion.
-   */
-  Quat<_Tp> operator/(const _Tp s) const;
-
-  /**
-   * @brief Division operator of two quaternions p and q.
-   * Divides left hand operand by right hand operand.
-   *
-   * Rule of quaternion division with a scalar:
-   * \f[
-   * \begin{equation}
-   * \begin{split}
-   * p / q &= p * q.inv()\\
-   * \end{split}
-   * \end{equation}
-   * \f]
-   *
-   * For example
-   * ```
-   * Quatd p{1, 2, 3, 4};
-   * Quatd q{5, 6, 7, 8};
-   * std::cout << p / q << std::endl; // equivalent to p * q.inv()
-   * ```
-   */
-  Quat<_Tp> operator/(const Quat<_Tp> &) const;
-
-  /**
-   * @brief Division assignment operator of a quaternions and a scalar.
-   * It divides left operand with the right operand and assign the result to
-   * left operand.
-   *
-   * Rule of quaternion division with a scalar:
-   * \f[
-   * \begin{equation}
-   * \begin{split}
-   * p / s &= [w, x, y, z] / s\\
-   * &=[w / s, x / s, y / s, z / s].
-   * \end{split}
-   * \end{equation}
-   * \f]
-   *
-   * For example
-   * ```
-   * Quatd p{1, 2, 3, 4};
-   * double s = 2.0;;
-   * p /= s; // equivalent to p = p / s
-   * std::cout << p << std::endl; //[0.5, 1.0, 1.5, 2.0]
-   * ```
-   * @note the type of scalar should be equal to the quaternion.
-   */
-  Quat<_Tp> &operator/=(const _Tp s);
-
-  /**
-   * @brief Division assignment operator of two quaternions p and q;
-   * It divides left operand with the right operand and assign the result to
-   * left operand.
-   *
-   * Rule of quaternion division with a quaternion:
-   * \f[
-   * \begin{equation}
-   * \begin{split}
-   * p / q&= p * q.inv()\\
-   * \end{split}
-   * \end{equation}
-   * \f]
-   *
-   * For example
-   * ```
-   * Quatd p{1, 2, 3, 4};
-   * Quatd q{5, 6, 7, 8};
-   * p /= q; // equivalent to p = p * q.inv()
-   * std::cout << p << std::endl;
-   * ```
-   */
-  Quat<_Tp> &operator/=(const Quat<_Tp> &);
-
-  _Tp &operator[](std::size_t n);
-
-  const _Tp &operator[](std::size_t n) const;
-
-  /**
-   * @brief Subtraction operator of a scalar and a quaternions.
-   * Subtracts right hand operand from left hand operand.
-   *
-   * For example
-   * ```
-   * Quatd p{1, 2, 3, 4};
-   * double scalar = 2.0;
-   * std::cout << scalar - p << std::endl; //[1.0, -2, -3, -4]
-   * ```
-   * @note the type of scalar should be equal to the quaternion.
-   */
-  template <typename T>
-  friend Quat<T> cv::operator-(const T s, const Quat<T> &);
-
-  /**
-   * @brief Subtraction operator of a quaternions and a scalar.
-   * Subtracts right hand operand from left hand operand.
-   *
-   * For example
-   * ```
-   * Quatd p{1, 2, 3, 4};
-   * double scalar = 2.0;
-   * std::cout << p - scalar << std::endl; //[-1.0, 2, 3, 4]
-   * ```
-   * @note the type of scalar should be equal to the quaternion.
-   */
-  template <typename T>
-  friend Quat<T> cv::operator-(const Quat<T> &, const T s);
-
-  /**
-   * @brief Addition operator of a quaternions and a scalar.
-   * Adds right hand operand from left hand operand.
-   *
-   * For example
-   * ```
-   * Quatd p{1, 2, 3, 4};
-   * double scalar = 2.0;
-   * std::cout << scalar + p << std::endl; //[3.0, 2, 3, 4]
-   * ```
-   * @note the type of scalar should be equal to the quaternion.
-   */
-  template <typename T>
-  friend Quat<T> cv::operator+(const T s, const Quat<T> &);
-
-  /**
-   * @brief Addition operator of a quaternions and a scalar.
-   * Adds right hand operand from left hand operand.
-   *
-   * For example
-   * ```
-   * Quatd p{1, 2, 3, 4};
-   * double scalar = 2.0;
-   * std::cout << p + scalar << std::endl; //[3.0, 2, 3, 4]
-   * ```
-   * @note the type of scalar should be equal to the quaternion.
-   */
-  template <typename T>
-  friend Quat<T> cv::operator+(const Quat<T> &, const T s);
-
-  /**
-   * @brief Multiplication operator of a scalar and a quaternions.
-   * It multiplies right operand with the left operand and assign the result to
-   * left operand.
-   *
-   * Rule of quaternion multiplication with a scalar:
-   * \f[
-   * \begin{equation}
-   * \begin{split}
-   * p * s &= [w, x, y, z] * s\\
-   * &=[w * s, x * s, y * s, z * s].
-   * \end{split}
-   * \end{equation}
-   * \f]
-   *
-   * For example
-   * ```
-   * Quatd p{1, 2, 3, 4};
-   * double s = 2.0;
-   * std::cout << s * p << std::endl; //[2.0, 4.0, 6.0, 8.0]
-   * ```
-   * @note the type of scalar should be equal to the quaternion.
-   */
-  template <typename T>
-  friend Quat<T> cv::operator*(const T s, const Quat<T> &);
-
-  /**
-   * @brief Multiplication operator of a quaternion and a scalar.
-   * It multiplies right operand with the left operand and assign the result to
-   * left operand.
-   *
-   * Rule of quaternion multiplication with a scalar:
-   * \f[
-   * \begin{equation}
-   * \begin{split}
-   * p * s &= [w, x, y, z] * s\\
-   * &=[w * s, x * s, y * s, z * s].
-   * \end{split}
-   * \end{equation}
-   * \f]
-   *
-   * For example
-   * ```
-   * Quatd p{1, 2, 3, 4};
-   * double s = 2.0;
-   * std::cout << p * s << std::endl; //[2.0, 4.0, 6.0, 8.0]
-   * ```
-   * @note the type of scalar should be equal to the quaternion.
-   */
-  template <typename T>
-  friend Quat<T> cv::operator*(const Quat<T> &, const T s);
-
-  template <typename S>
-  friend std::ostream &cv::operator<<(std::ostream &, const Quat<S> &);
-
-  /**
-   * @brief Transform a quaternion q to Euler angles.
-   *
-   *
-   * When transforming a quaternion \f$q = w + x\boldsymbol{i} + y\boldsymbol{j}
-   * + z\boldsymbol{k}\f$ to Euler angles, rotation matrix M can be calculated
-   * by:
-   * \f[ \begin{aligned} {M}
-   * &={\begin{bmatrix}1-2(y^{2}+z^{2})&2(xy-zx)&2(xz+yw)\\2(xy+zw)&1-2(x^{2}+z^{2})&2(yz-xw)\\2(xz-yw)&2(yz+xw)&1-2(x^{2}+y^{2})\end{bmatrix}}\end{aligned}.\f]
-   * On the other hand, the rotation matrix can be obtained from Euler angles.
-   * Using intrinsic rotations with Euler angles type XYZ as an example,
-   * \f$\theta_1 \f$, \f$\theta_2 \f$, \f$\theta_3 \f$ are three angles for
-   * Euler angles, the rotation matrix R can be calculated by:\f[R
-   * =X(\theta_1)Y(\theta_2)Z(\theta_3)
-   * ={\begin{bmatrix}\cos\theta_{2}\cos\theta_{3}&-\cos\theta_{2}\sin\theta_{3}&\sin\theta_{2}\\\cos\theta_{1}\sin\theta_{3}+\cos\theta_{3}\sin\theta_{1}\sin\theta_{2}&\cos\theta_{1}\cos\theta_{3}-\sin\theta_{1}\sin\theta_{2}\sin\theta_{3}&-\cos\theta_{2}\sin\theta_{1}\\\sin\theta_{1}\sin\theta_{3}-\cos\theta_{1}\cos\theta_{3}\sin\theta_{2}&\cos\theta_{3}\sin\theta_{1}+\cos\theta_{1}\sin\theta_{2}\sin\theta_{3}&\cos\theta_{1}\cos_{2}\end{bmatrix}}\f]
-   * Rotation matrix M and R are equal. As long as \f$ s_{2} \neq 1 \f$, by
-   * comparing each element of two matrices ,the solution is\f$\begin{cases}
-   * \theta_1 = \arctan2(-m_{23},m_{33})\\\theta_2 = arcsin(m_{13}) \\\theta_3 =
-   * \arctan2(-m_{12},m_{11}) \end{cases}\f$.
-   *
-   * When \f$ s_{2}=1\f$ or \f$ s_{2}=-1\f$, the gimbal lock occurs. The
-   * function will prompt "WARNING: Gimbal Lock will occur. Euler angles is
-   * non-unique. For intrinsic rotations, we set the third angle to 0, and for
-   * external rotation, we set the first angle to 0.".
-   *
-   * When \f$ s_{2}=1\f$ ,
-   * The rotation matrix R is \f$R =
-   * {\begin{bmatrix}0&0&1\\\sin(\theta_1+\theta_3)&\cos(\theta_1+\theta_3)&0\\-\cos(\theta_1+\theta_3)&\sin(\theta_1+\theta_3)&0\end{bmatrix}}\f$.
-   *
-   * The number of solutions is infinite with the condition \f$\begin{cases}
-   * \theta_1+\theta_3 = \arctan2(m_{21},m_{22})\\ \theta_2=\pi/2
-   * \end{cases}\ \f$.
-   *
-   * We set \f$ \theta_3 = 0\f$, the solution is \f$\begin{cases}
-   * \theta_1=\arctan2(m_{21},m_{22})\\ \theta_2=\pi/2\\ \theta_3=0
-   * \end{cases}\f$.
-   *
-   * When \f$ s_{2}=-1\f$,
-   * The rotation matrix R is
-   * \f$X_{1}Y_{2}Z_{3}={\begin{bmatrix}0&0&-1\\-\sin(\theta_1-\theta_3)&\cos(\theta_1-\theta_3)&0\\\cos(\theta_1-\theta_3)&\sin(\theta_1-\theta_3)&0\end{bmatrix}}\f$.
-   *
-   * The number of solutions is infinite with the condition \f$\begin{cases}
-   * \theta_1+\theta_3 = \arctan2(m_{32},m_{22})\\ \theta_2=\pi/2
-   * \end{cases}\ \f$.
-   *
-   * We set \f$ \theta_3 = 0\f$, the solution is \f$
-   * \begin{cases}\theta_1=\arctan2(m_{32},m_{22})
-   * \\ \theta_2=-\pi/2\\  \theta_3=0\end{cases}\f$.
-   *
-   * Since \f$ sin \theta\in [-1,1] \f$ and \f$ cos \theta \in [-1,1] \f$, the
-   * unnormalized quaternion will cause computational troubles. For this reason,
-   * this function will normalize the quaternion at first and @ref
-   * QuatAssumeType is not needed.
-   *
-   * When the gimbal lock occurs, we set \f$\theta_3 = 0\f$ for intrinsic
-   * rotations or \f$\theta_1 = 0\f$ for extrinsic rotations.
-   *
-   * As a result, for every Euler angles type, we can get solution as shown in
-   * the following table. EulerAnglesType  | Ordinary | \f$\theta_2 = π/2\f$ |
-   * \f$\theta_2 = -π/2\f$
-   * ------------- | -------------| -------------| -------------
-   * INT_XYZ|\f$ \theta_1 = \arctan2(-m_{23},m_{33})\\\theta_2 = \arcsin(m_{13})
-   * \\\theta_3= \arctan2(-m_{12},m_{11}) \f$|\f$
-   * \theta_1=\arctan2(m_{21},m_{22})\\ \theta_2=\pi/2\\ \theta_3=0 \f$|\f$
-   * \theta_1=\arctan2(m_{32},m_{22})\\ \theta_2=-\pi/2\\ \theta_3=0 \f$
-   * INT_XZY|\f$ \theta_1 = \arctan2(m_{32},m_{22})\\\theta_2 = -\arcsin(m_{12})
-   * \\\theta_3= \arctan2(m_{13},m_{11}) \f$|\f$
-   * \theta_1=\arctan2(m_{31},m_{33})\\ \theta_2=\pi/2\\ \theta_3=0 \f$|\f$
-   * \theta_1=\arctan2(-m_{23},m_{33})\\ \theta_2=-\pi/2\\ \theta_3=0 \f$
-   * INT_YXZ|\f$ \theta_1 = \arctan2(m_{13},m_{33})\\\theta_2 = -\arcsin(m_{23})
-   * \\\theta_3= \arctan2(m_{21},m_{22}) \f$|\f$
-   * \theta_1=\arctan2(m_{12},m_{11})\\ \theta_2=\pi/2\\ \theta_3=0 \f$|\f$
-   * \theta_1=\arctan2(-m_{12},m_{11})\\ \theta_2=-\pi/2\\ \theta_3=0 \f$
-   * INT_YZX|\f$ \theta_1 = \arctan2(-m_{31},m_{11})\\\theta_2 = \arcsin(m_{21})
-   * \\\theta_3= \arctan2(-m_{23},m_{22}) \f$|\f$
-   * \theta_1=\arctan2(m_{13},m_{33})\\ \theta_2=\pi/2\\ \theta_3=0 \f$|\f$
-   * \theta_1=\arctan2(m_{13},m_{12})\\ \theta_2=-\pi/2\\ \theta_3=0 \f$
-   * INT_ZXY|\f$ \theta_1 = \arctan2(-m_{12},m_{22})\\\theta_2 = \arcsin(m_{32})
-   * \\\theta_3= \arctan2(-m_{31},m_{33}) \f$|\f$
-   * \theta_1=\arctan2(m_{21},m_{11})\\ \theta_2=\pi/2\\ \theta_3=0 \f$|\f$
-   * \theta_1=\arctan2(m_{21},m_{11})\\ \theta_2=-\pi/2\\ \theta_3=0 \f$
-   * INT_ZYX|\f$ \theta_1 = \arctan2(m_{21},m_{11})\\\theta_2 = \arcsin(-m_{31})
-   * \\\theta_3= \arctan2(m_{32},m_{33}) \f$|\f$
-   * \theta_1=\arctan2(m_{23},m_{22})\\ \theta_2=\pi/2\\ \theta_3=0 \f$|\f$
-   * \theta_1=\arctan2(-m_{12},m_{22})\\ \theta_2=-\pi/2\\ \theta_3=0 \f$
-   * EXT_XYZ|\f$ \theta_1 = \arctan2(m_{32},m_{33})\\\theta_2 = \arcsin(-m_{31})
-   * \\\ \theta_3 = \arctan2(m_{21},m_{11})\f$|\f$ \theta_1=
-   * 0\\ \theta_2=\pi/2\\ \theta_3=\arctan2(m_{23},m_{22}) \f$|\f$
-   * \theta_1=0\\ \theta_2=-\pi/2\\ \theta_3=\arctan2(-m_{12},m_{22}) \f$
-   * EXT_XZY|\f$ \theta_1 = \arctan2(-m_{23},m_{22})\\\theta_2 = \arcsin(m_{21})
-   * \\\theta_3=  \arctan2(-m_{31},m_{11})\f$|\f$ \theta_1=
-   * 0\\ \theta_2=\pi/2\\ \theta_3=\arctan2(m_{13},m_{33}) \f$|\f$
-   * \theta_1=0\\ \theta_2=-\pi/2\\ \theta_3=\arctan2(m_{13},m_{12}) \f$
-   * EXT_YXZ|\f$ \theta_1 = \arctan2(-m_{31},m_{33}) \\\theta_2 =
-   * \arcsin(m_{32}) \\\theta_3= \arctan2(-m_{12},m_{22})\f$|\f$ \theta_1=
-   * 0\\ \theta_2=\pi/2\\ \theta_3=\arctan2(m_{21},m_{11}) \f$|\f$
-   * \theta_1=0\\ \theta_2=-\pi/2\\ \theta_3=\arctan2(m_{21},m_{11}) \f$
-   * EXT_YZX|\f$ \theta_1 = \arctan2(m_{13},m_{11})\\\theta_2 = -\arcsin(m_{12})
-   * \\\theta_3= \arctan2(m_{32},m_{22})\f$|\f$ \theta_1=
-   * 0\\ \theta_2=\pi/2\\ \theta_3=\arctan2(m_{31},m_{33}) \f$|\f$
-   * \theta_1=0\\ \theta_2=-\pi/2\\ \theta_3=\arctan2(-m_{23},m_{33}) \f$
-   * EXT_ZXY|\f$ \theta_1 = \arctan2(m_{21},m_{22})\\\theta_2 = -\arcsin(m_{23})
-   * \\\theta_3= \arctan2(m_{13},m_{33})\f$|\f$ \theta_1=
-   * 0\\ \theta_2=\pi/2\\ \theta_3=\arctan2(m_{12},m_{11}) \f$|\f$ \theta_1=
-   * 0\\ \theta_2=-\pi/2\\ \theta_3=\arctan2(-m_{12},m_{11}) \f$ EXT_ZYX|\f$
-   * \theta_1 = \arctan2(-m_{12},m_{11})\\\theta_2 = \arcsin(m_{13}) \\\theta_3=
-   * \arctan2(-m_{23},m_{33})\f$|\f$
-   * \theta_1=0\\ \theta_2=\pi/2\\ \theta_3=\arctan2(m_{21},m_{22}) \f$|\f$
-   * \theta_1=0\\ \theta_2=-\pi/2\\ \theta_3=\arctan2(m_{32},m_{22}) \f$
-   *
-   *  EulerAnglesType  | Ordinary | \f$\theta_2 = 0\f$ | \f$\theta_2 = π\f$
-   * ------------- | -------------| -------------| -------------
-   * INT_XYX| \f$ \theta_1 = \arctan2(m_{21},-m_{31})\\\theta_2 =\arccos(m_{11})
-   * \\\theta_3 = \arctan2(m_{12},m_{13}) \f$| \f$
-   * \theta_1=\arctan2(m_{32},m_{33})\\ \theta_2=0\\ \theta_3=0 \f$| \f$
-   * \theta_1=\arctan2(m_{23},m_{22})\\ \theta_2=\pi\\ \theta_3=0 \f$ INT_XZX|
-   * \f$ \theta_1 = \arctan2(m_{31},m_{21})\\\theta_2 = \arccos(m_{11})
-   * \\\theta_3 = \arctan2(m_{13},-m_{12}) \f$| \f$
-   * \theta_1=\arctan2(m_{32},m_{33})\\ \theta_2=0\\ \theta_3=0 \f$| \f$
-   * \theta_1=\arctan2(-m_{32},m_{33})\\ \theta_2=\pi\\ \theta_3=0 \f$ INT_YXY|
-   * \f$ \theta_1 = \arctan2(m_{12},m_{32})\\\theta_2 = \arccos(m_{22})
-   * \\\theta_3 = \arctan2(m_{21},-m_{23}) \f$| \f$
-   * \theta_1=\arctan2(m_{13},m_{11})\\ \theta_2=0\\ \theta_3=0 \f$| \f$
-   * \theta_1=\arctan2(-m_{31},m_{11})\\ \theta_2=\pi\\ \theta_3=0 \f$ INT_YZY|
-   * \f$ \theta_1 = \arctan2(m_{32},-m_{12})\\\theta_2 = \arccos(m_{22})
-   * \\\theta_3 =\arctan2(m_{23},m_{21}) \f$| \f$
-   * \theta_1=\arctan2(m_{13},m_{11})\\ \theta_2=0\\ \theta_3=0 \f$| \f$
-   * \theta_1=\arctan2(m_{13},-m_{11})\\ \theta_2=\pi\\ \theta_3=0 \f$ INT_ZXZ|
-   * \f$ \theta_1 = \arctan2(-m_{13},m_{23})\\\theta_2 = \arccos(m_{33})
-   * \\\theta_3 =\arctan2(m_{31},m_{32}) \f$| \f$
-   * \theta_1=\arctan2(m_{21},m_{22})\\ \theta_2=0\\ \theta_3=0 \f$| \f$
-   * \theta_1=\arctan2(m_{21},m_{11})\\ \theta_2=\pi\\ \theta_3=0 \f$ INT_ZYZ|
-   * \f$ \theta_1 = \arctan2(m_{23},m_{13})\\\theta_2 = \arccos(m_{33})
-   * \\\theta_3 = \arctan2(m_{32},-m_{31}) \f$| \f$
-   * \theta_1=\arctan2(m_{21},m_{11})\\ \theta_2=0\\ \theta_3=0 \f$| \f$
-   * \theta_1=\arctan2(m_{21},m_{11})\\ \theta_2=\pi\\ \theta_3=0 \f$ EXT_XYX|
-   * \f$ \theta_1 = \arctan2(m_{12},m_{13}) \\\theta_2 = \arccos(m_{11})
-   * \\\theta_3 = \arctan2(m_{21},-m_{31})\f$| \f$
-   * \theta_1=0\\ \theta_2=0\\ \theta_3=\arctan2(m_{32},m_{33}) \f$| \f$
-   * \theta_1= 0\\ \theta_2=\pi\\ \theta_3= \arctan2(m_{23},m_{22}) \f$ EXT_XZX|
-   * \f$ \theta_1 = \arctan2(m_{13},-m_{12})\\\theta_2 = \arccos(m_{11})
-   * \\\theta_3 = \arctan2(m_{31},m_{21})\f$| \f$ \theta_1=
-   * 0\\ \theta_2=0\\ \theta_3=\arctan2(m_{32},m_{33}) \f$| \f$ \theta_1=
-   * 0\\ \theta_2=\pi\\ \theta_3=\arctan2(-m_{32},m_{33}) \f$ EXT_YXY| \f$
-   * \theta_1 = \arctan2(m_{21},-m_{23})\\\theta_2 = \arccos(m_{22}) \\\theta_3
-   * = \arctan2(m_{12},m_{32}) \f$| \f$ \theta_1=
-   * 0\\ \theta_2=0\\ \theta_3=\arctan2(m_{13},m_{11}) \f$| \f$ \theta_1=
-   * 0\\ \theta_2=\pi\\ \theta_3=\arctan2(-m_{31},m_{11}) \f$ EXT_YZY| \f$
-   * \theta_1 = \arctan2(m_{23},m_{21}) \\\theta_2 = \arccos(m_{22}) \\\theta_3
-   * = \arctan2(m_{32},-m_{12}) \f$| \f$ \theta_1=
-   * 0\\ \theta_2=0\\ \theta_3=\arctan2(m_{13},m_{11}) \f$| \f$
-   * \theta_1=0\\ \theta_2=\pi\\ \theta_3=\arctan2(m_{13},-m_{11}) \f$ EXT_ZXZ|
-   * \f$ \theta_1 = \arctan2(m_{31},m_{32}) \\\theta_2 = \arccos(m_{33})
-   * \\\theta_3 = \arctan2(-m_{13},m_{23})\f$| \f$
-   * \theta_1=0\\ \theta_2=0\\ \theta_3=\arctan2(m_{21},m_{22}) \f$| \f$
-   * \theta_1= 0\\ \theta_2=\pi\\ \theta_3=\arctan2(m_{21},m_{11}) \f$ EXT_ZYZ|
-   * \f$ \theta_1 = \arctan2(m_{32},-m_{31})\\\theta_2 = \arccos(m_{33})
-   * \\\theta_3 = \arctan2(m_{23},m_{13}) \f$| \f$
-   * \theta_1=0\\ \theta_2=0\\ \theta_3=\arctan2(m_{21},m_{11}) \f$| \f$
-   * \theta_1= 0\\ \theta_2=\pi\\ \theta_3=\arctan2(m_{21},m_{11}) \f$
-   *
-   * @param eulerAnglesType the convertion Euler angles type
-   */
-
-  Vec<_Tp, 3> toEulerAngles(QuatEnum::EulerAnglesType eulerAnglesType);
-
-  _Tp w, x, y, z;
-};
-
-template <typename T>
-Quat<T> inv(const Quat<T> &q, QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT);
-
-template <typename T> Quat<T> sinh(const Quat<T> &q);
-
-template <typename T> Quat<T> cosh(const Quat<T> &q);
-
-template <typename T> Quat<T> tanh(const Quat<T> &q);
-
-template <typename T> Quat<T> sin(const Quat<T> &q);
-
-template <typename T> Quat<T> cos(const Quat<T> &q);
-
-template <typename T> Quat<T> tan(const Quat<T> &q);
-
-template <typename T> Quat<T> asinh(const Quat<T> &q);
-
-template <typename T> Quat<T> acosh(const Quat<T> &q);
-
-template <typename T> Quat<T> atanh(const Quat<T> &q);
-
-template <typename T> Quat<T> asin(const Quat<T> &q);
-
-template <typename T> Quat<T> acos(const Quat<T> &q);
-
-template <typename T> Quat<T> atan(const Quat<T> &q);
-
-template <typename T>
-Quat<T> power(const Quat<T> &q, const Quat<T> &p,
-              QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT);
-
-template <typename T> Quat<T> exp(const Quat<T> &q);
-
-template <typename T>
-Quat<T> log(const Quat<T> &q, QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT);
-
-template <typename T>
-Quat<T> power(const Quat<T> &q, const T x,
-              QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT);
-
-template <typename T> Quat<T> crossProduct(const Quat<T> &p, const Quat<T> &q);
-
-template <typename S>
-Quat<S> sqrt(const Quat<S> &q,
-             QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT);
-
-template <typename T> Quat<T> operator*(const T, const Quat<T> &);
-
-template <typename T> Quat<T> operator*(const Quat<T> &, const T);
-
-template <typename S> std::ostream &operator<<(std::ostream &, const Quat<S> &);
-
-using Quatd = Quat<double>;
-using Quatf = Quat<float>;
-
-//! @} core
-} // namespace cv
-
-#include "opencv2/core/quaternion.inl.hpp"
-
-#endif /* OPENCV_CORE_QUATERNION_HPP */
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/quaternion.inl.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/quaternion.inl.hpp
deleted file mode 100644
index 9d6cb16b36..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/quaternion.inl.hpp
+++ /dev/null
@@ -1,907 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2020, Huawei Technologies Co., Ltd. All rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//       http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Author: Liangqian Kong <chargerKong@126.com>
-//         Longbu Wang <riskiest@gmail.com>
-
-#ifndef OPENCV_CORE_QUATERNION_INL_HPP
-#define OPENCV_CORE_QUATERNION_INL_HPP
-
-#ifndef OPENCV_CORE_QUATERNION_HPP
-#error This is not a standalone header. Include quaternion.hpp instead.
-#endif
-
-//@cond IGNORE
-///////////////////////////////////////////////////////////////////////////////////////
-// Implementation
-namespace cv {
-
-template <typename T> Quat<T>::Quat() : w(0), x(0), y(0), z(0) {}
-
-template <typename T>
-Quat<T>::Quat(const Vec<T, 4> &coeff)
-    : w(coeff[0]), x(coeff[1]), y(coeff[2]), z(coeff[3]) {}
-
-template <typename T>
-Quat<T>::Quat(const T qw, const T qx, const T qy, const T qz)
-    : w(qw), x(qx), y(qy), z(qz) {}
-
-template <typename T>
-Quat<T> Quat<T>::createFromAngleAxis(const T angle, const Vec<T, 3> &axis) {
-  T w, x, y, z;
-  T vNorm = std::sqrt(axis.dot(axis));
-  if (vNorm < CV_QUAT_EPS) {
-    CV_Error(Error::StsBadArg, "this quaternion does not represent a rotation");
-  }
-  const T angle_half = angle * T(0.5);
-  w = std::cos(angle_half);
-  const T sin_v = std::sin(angle_half);
-  const T sin_norm = sin_v / vNorm;
-  x = sin_norm * axis[0];
-  y = sin_norm * axis[1];
-  z = sin_norm * axis[2];
-  return Quat<T>(w, x, y, z);
-}
-
-template <typename T> Quat<T> Quat<T>::createFromRotMat(InputArray _R) {
-  CV_CheckTypeEQ(_R.type(), cv::traits::Type<T>::value, "");
-  if (_R.rows() != 3 || _R.cols() != 3) {
-    CV_Error(Error::StsBadArg, "Cannot convert matrix to quaternion: rotation "
-                               "matrix should be a 3x3 matrix");
-  }
-  Matx<T, 3, 3> R;
-  _R.copyTo(R);
-
-  T S, w, x, y, z;
-  T trace = R(0, 0) + R(1, 1) + R(2, 2);
-  if (trace > 0) {
-    S = std::sqrt(trace + 1) * T(2);
-    x = (R(1, 2) - R(2, 1)) / S;
-    y = (R(2, 0) - R(0, 2)) / S;
-    z = (R(0, 1) - R(1, 0)) / S;
-    w = -T(0.25) * S;
-  } else if (R(0, 0) > R(1, 1) && R(0, 0) > R(2, 2)) {
-
-    S = std::sqrt(T(1.0) + R(0, 0) - R(1, 1) - R(2, 2)) * T(2);
-    x = -T(0.25) * S;
-    y = -(R(1, 0) + R(0, 1)) / S;
-    z = -(R(0, 2) + R(2, 0)) / S;
-    w = (R(1, 2) - R(2, 1)) / S;
-  } else if (R(1, 1) > R(2, 2)) {
-    S = std::sqrt(T(1.0) - R(0, 0) + R(1, 1) - R(2, 2)) * T(2);
-    x = (R(0, 1) + R(1, 0)) / S;
-    y = T(0.25) * S;
-    z = (R(1, 2) + R(2, 1)) / S;
-    w = (R(0, 2) - R(2, 0)) / S;
-  } else {
-    S = std::sqrt(T(1.0) - R(0, 0) - R(1, 1) + R(2, 2)) * T(2);
-    x = (R(0, 2) + R(2, 0)) / S;
-    y = (R(1, 2) + R(2, 1)) / S;
-    z = T(0.25) * S;
-    w = -(R(0, 1) - R(1, 0)) / S;
-  }
-  return Quat<T>(w, x, y, z);
-}
-
-template <typename T> Quat<T> Quat<T>::createFromRvec(InputArray _rvec) {
-  if (!((_rvec.cols() == 1 && _rvec.rows() == 3) ||
-        (_rvec.cols() == 3 && _rvec.rows() == 1))) {
-    CV_Error(Error::StsBadArg, "Cannot convert rotation vector to quaternion: "
-                               "The length of rotation vector should be 3");
-  }
-  Vec<T, 3> rvec;
-  _rvec.copyTo(rvec);
-  T psi = std::sqrt(rvec.dot(rvec));
-  if (abs(psi) < CV_QUAT_EPS) {
-    return Quat<T>(1, 0, 0, 0);
-  }
-  Vec<T, 3> axis = rvec / psi;
-  return createFromAngleAxis(psi, axis);
-}
-
-template <typename T> inline Quat<T> Quat<T>::operator-() const {
-  return Quat<T>(-w, -x, -y, -z);
-}
-
-template <typename T> inline bool Quat<T>::operator==(const Quat<T> &q) const {
-  return (abs(w - q.w) < CV_QUAT_EPS && abs(x - q.x) < CV_QUAT_EPS &&
-          abs(y - q.y) < CV_QUAT_EPS && abs(z - q.z) < CV_QUAT_EPS);
-}
-
-template <typename T>
-inline Quat<T> Quat<T>::operator+(const Quat<T> &q1) const {
-  return Quat<T>(w + q1.w, x + q1.x, y + q1.y, z + q1.z);
-}
-
-template <typename T> inline Quat<T> operator+(const T a, const Quat<T> &q) {
-  return Quat<T>(q.w + a, q.x, q.y, q.z);
-}
-
-template <typename T> inline Quat<T> operator+(const Quat<T> &q, const T a) {
-  return Quat<T>(q.w + a, q.x, q.y, q.z);
-}
-
-template <typename T> inline Quat<T> operator-(const T a, const Quat<T> &q) {
-  return Quat<T>(a - q.w, -q.x, -q.y, -q.z);
-}
-
-template <typename T> inline Quat<T> operator-(const Quat<T> &q, const T a) {
-  return Quat<T>(q.w - a, q.x, q.y, q.z);
-}
-
-template <typename T>
-inline Quat<T> Quat<T>::operator-(const Quat<T> &q1) const {
-  return Quat<T>(w - q1.w, x - q1.x, y - q1.y, z - q1.z);
-}
-
-template <typename T> inline Quat<T> &Quat<T>::operator+=(const Quat<T> &q1) {
-  w += q1.w;
-  x += q1.x;
-  y += q1.y;
-  z += q1.z;
-  return *this;
-}
-
-template <typename T> inline Quat<T> &Quat<T>::operator-=(const Quat<T> &q1) {
-  w -= q1.w;
-  x -= q1.x;
-  y -= q1.y;
-  z -= q1.z;
-  return *this;
-}
-
-template <typename T>
-inline Quat<T> Quat<T>::operator*(const Quat<T> &q1) const {
-  Vec<T, 4> q{w, x, y, z};
-  Vec<T, 4> q2{q1.w, q1.x, q1.y, q1.z};
-  return Quat<T>(q * q2);
-}
-
-template <typename T> Quat<T> operator*(const Quat<T> &q1, const T a) {
-  return Quat<T>(a * q1.w, a * q1.x, a * q1.y, a * q1.z);
-}
-
-template <typename T> Quat<T> operator*(const T a, const Quat<T> &q1) {
-  return Quat<T>(a * q1.w, a * q1.x, a * q1.y, a * q1.z);
-}
-
-template <typename T> inline Quat<T> &Quat<T>::operator*=(const Quat<T> &q1) {
-  T qw, qx, qy, qz;
-  qw = w * q1.w - x * q1.x - y * q1.y - z * q1.z;
-  qx = x * q1.w + w * q1.x + y * q1.z - z * q1.y;
-  qy = y * q1.w + w * q1.y + z * q1.x - x * q1.z;
-  qz = z * q1.w + w * q1.z + x * q1.y - y * q1.x;
-  w = qw;
-  x = qx;
-  y = qy;
-  z = qz;
-  return *this;
-}
-
-template <typename T> inline Quat<T> &Quat<T>::operator/=(const Quat<T> &q1) {
-  Quat<T> q(*this * q1.inv());
-  w = q.w;
-  x = q.x;
-  y = q.y;
-  z = q.z;
-  return *this;
-}
-template <typename T> Quat<T> &Quat<T>::operator*=(const T q1) {
-  w *= q1;
-  x *= q1;
-  y *= q1;
-  z *= q1;
-  return *this;
-}
-
-template <typename T> inline Quat<T> &Quat<T>::operator/=(const T a) {
-  const T a_inv = 1.0 / a;
-  w *= a_inv;
-  x *= a_inv;
-  y *= a_inv;
-  z *= a_inv;
-  return *this;
-}
-
-template <typename T> inline Quat<T> Quat<T>::operator/(const T a) const {
-  const T a_inv = T(1.0) / a;
-  return Quat<T>(w * a_inv, x * a_inv, y * a_inv, z * a_inv);
-}
-
-template <typename T>
-inline Quat<T> Quat<T>::operator/(const Quat<T> &q) const {
-  return *this * q.inv();
-}
-
-template <typename T> inline const T &Quat<T>::operator[](std::size_t n) const {
-  switch (n) {
-  case 0:
-    return w;
-  case 1:
-    return x;
-  case 2:
-    return y;
-  case 3:
-    return z;
-  default:
-    CV_Error(Error::StsOutOfRange, "subscript exceeds the index range");
-  }
-}
-
-template <typename T> inline T &Quat<T>::operator[](std::size_t n) {
-  switch (n) {
-  case 0:
-    return w;
-  case 1:
-    return x;
-  case 2:
-    return y;
-  case 3:
-    return z;
-  default:
-    CV_Error(Error::StsOutOfRange, "subscript exceeds the index range");
-  }
-}
-
-template <typename T>
-std::ostream &operator<<(std::ostream &os, const Quat<T> &q) {
-  os << "Quat " << Vec<T, 4>{q.w, q.x, q.y, q.z};
-  return os;
-}
-
-template <typename T> inline T Quat<T>::at(size_t index) const {
-  return (*this)[index];
-}
-
-template <typename T> inline Quat<T> Quat<T>::conjugate() const {
-  return Quat<T>(w, -x, -y, -z);
-}
-
-template <typename T> inline T Quat<T>::norm() const {
-  return std::sqrt(dot(*this));
-}
-
-template <typename T> Quat<T> exp(const Quat<T> &q) { return q.exp(); }
-
-template <typename T> Quat<T> Quat<T>::exp() const {
-  Vec<T, 3> v{x, y, z};
-  T normV = std::sqrt(v.dot(v));
-  T k = normV < CV_QUAT_EPS ? 1 : std::sin(normV) / normV;
-  return std::exp(w) * Quat<T>(std::cos(normV), v[0] * k, v[1] * k, v[2] * k);
-}
-
-template <typename T> Quat<T> log(const Quat<T> &q, QuatAssumeType assumeUnit) {
-  return q.log(assumeUnit);
-}
-
-template <typename T> Quat<T> Quat<T>::log(QuatAssumeType assumeUnit) const {
-  Vec<T, 3> v{x, y, z};
-  T vNorm = std::sqrt(v.dot(v));
-  if (assumeUnit) {
-    T k = vNorm < CV_QUAT_EPS ? 1 : std::acos(w) / vNorm;
-    return Quat<T>(0, v[0] * k, v[1] * k, v[2] * k);
-  }
-  T qNorm = norm();
-  if (qNorm < CV_QUAT_EPS) {
-    CV_Error(Error::StsBadArg,
-             "Cannot apply this quaternion to log function: undefined");
-  }
-  T k = vNorm < CV_QUAT_EPS ? 1 : std::acos(w / qNorm) / vNorm;
-  return Quat<T>(std::log(qNorm), v[0] * k, v[1] * k, v[2] * k);
-}
-
-template <typename T>
-inline Quat<T> power(const Quat<T> &q1, const T alpha,
-                     QuatAssumeType assumeUnit) {
-  return q1.power(alpha, assumeUnit);
-}
-
-template <typename T>
-inline Quat<T> Quat<T>::power(const T alpha, QuatAssumeType assumeUnit) const {
-  if (x * x + y * y + z * z > CV_QUAT_EPS) {
-    T angle = getAngle(assumeUnit);
-    Vec<T, 3> axis = getAxis(assumeUnit);
-    if (assumeUnit) {
-      return createFromAngleAxis(alpha * angle, axis);
-    }
-    return std::pow(norm(), alpha) * createFromAngleAxis(alpha * angle, axis);
-  } else {
-    return std::pow(norm(), alpha) * Quat<T>(w, x, y, z);
-  }
-}
-
-template <typename T>
-inline Quat<T> sqrt(const Quat<T> &q, QuatAssumeType assumeUnit) {
-  return q.sqrt(assumeUnit);
-}
-
-template <typename T>
-inline Quat<T> Quat<T>::sqrt(QuatAssumeType assumeUnit) const {
-  return power(0.5, assumeUnit);
-}
-
-template <typename T>
-inline Quat<T> power(const Quat<T> &p, const Quat<T> &q,
-                     QuatAssumeType assumeUnit) {
-  return p.power(q, assumeUnit);
-}
-
-template <typename T>
-inline Quat<T> Quat<T>::power(const Quat<T> &q,
-                              QuatAssumeType assumeUnit) const {
-  return cv::exp(q * log(assumeUnit));
-}
-
-template <typename T> inline T Quat<T>::dot(Quat<T> q1) const {
-  return w * q1.w + x * q1.x + y * q1.y + z * q1.z;
-}
-
-template <typename T>
-inline Quat<T> crossProduct(const Quat<T> &p, const Quat<T> &q) {
-  return p.crossProduct(q);
-}
-
-template <typename T>
-inline Quat<T> Quat<T>::crossProduct(const Quat<T> &q) const {
-  return Quat<T>(0, y * q.z - z * q.y, z * q.x - x * q.z, x * q.y - q.x * y);
-}
-
-template <typename T> inline Quat<T> Quat<T>::normalize() const {
-  T normVal = norm();
-  if (normVal < CV_QUAT_EPS) {
-    CV_Error(Error::StsBadArg,
-             "Cannot normalize this quaternion: the norm is too small.");
-  }
-  return Quat<T>(w / normVal, x / normVal, y / normVal, z / normVal);
-}
-
-template <typename T>
-inline Quat<T> inv(const Quat<T> &q, QuatAssumeType assumeUnit) {
-  return q.inv(assumeUnit);
-}
-
-template <typename T>
-inline Quat<T> Quat<T>::inv(QuatAssumeType assumeUnit) const {
-  if (assumeUnit) {
-    return conjugate();
-  }
-  T norm2 = dot(*this);
-  if (norm2 < CV_QUAT_EPS) {
-    CV_Error(Error::StsBadArg,
-             "This quaternion do not have inverse quaternion");
-  }
-  return conjugate() / norm2;
-}
-
-template <typename T> inline Quat<T> sinh(const Quat<T> &q) { return q.sinh(); }
-
-template <typename T> inline Quat<T> Quat<T>::sinh() const {
-  Vec<T, 3> v{x, y, z};
-  T vNorm = std::sqrt(v.dot(v));
-  T k = vNorm < CV_QUAT_EPS ? 1 : std::cosh(w) * std::sin(vNorm) / vNorm;
-  return Quat<T>(std::sinh(w) * std::cos(vNorm), v[0] * k, v[1] * k, v[2] * k);
-}
-
-template <typename T> inline Quat<T> cosh(const Quat<T> &q) { return q.cosh(); }
-
-template <typename T> inline Quat<T> Quat<T>::cosh() const {
-  Vec<T, 3> v{x, y, z};
-  T vNorm = std::sqrt(v.dot(v));
-  T k = vNorm < CV_QUAT_EPS ? 1 : std::sinh(w) * std::sin(vNorm) / vNorm;
-  return Quat<T>(std::cosh(w) * std::cos(vNorm), v[0] * k, v[1] * k, v[2] * k);
-}
-
-template <typename T> inline Quat<T> tanh(const Quat<T> &q) { return q.tanh(); }
-
-template <typename T> inline Quat<T> Quat<T>::tanh() const {
-  return sinh() * cosh().inv();
-}
-
-template <typename T> inline Quat<T> sin(const Quat<T> &q) { return q.sin(); }
-
-template <typename T> inline Quat<T> Quat<T>::sin() const {
-  Vec<T, 3> v{x, y, z};
-  T vNorm = std::sqrt(v.dot(v));
-  T k = vNorm < CV_QUAT_EPS ? 1 : std::cos(w) * std::sinh(vNorm) / vNorm;
-  return Quat<T>(std::sin(w) * std::cosh(vNorm), v[0] * k, v[1] * k, v[2] * k);
-}
-
-template <typename T> inline Quat<T> cos(const Quat<T> &q) { return q.cos(); }
-
-template <typename T> inline Quat<T> Quat<T>::cos() const {
-  Vec<T, 3> v{x, y, z};
-  T vNorm = std::sqrt(v.dot(v));
-  T k = vNorm < CV_QUAT_EPS ? 1 : std::sin(w) * std::sinh(vNorm) / vNorm;
-  return Quat<T>(std::cos(w) * std::cosh(vNorm), -v[0] * k, -v[1] * k,
-                 -v[2] * k);
-}
-
-template <typename T> inline Quat<T> tan(const Quat<T> &q) { return q.tan(); }
-
-template <typename T> inline Quat<T> Quat<T>::tan() const {
-  return sin() * cos().inv();
-}
-
-template <typename T> inline Quat<T> asinh(const Quat<T> &q) {
-  return q.asinh();
-}
-
-template <typename T> inline Quat<T> Quat<T>::asinh() const {
-  return cv::log(*this + cv::power(*this * *this + Quat<T>(1, 0, 0, 0), 0.5));
-}
-
-template <typename T> inline Quat<T> acosh(const Quat<T> &q) {
-  return q.acosh();
-}
-
-template <typename T> inline Quat<T> Quat<T>::acosh() const {
-  return cv::log(*this + cv::power(*this * *this - Quat<T>(1, 0, 0, 0), 0.5));
-}
-
-template <typename T> inline Quat<T> atanh(const Quat<T> &q) {
-  return q.atanh();
-}
-
-template <typename T> inline Quat<T> Quat<T>::atanh() const {
-  Quat<T> ident(1, 0, 0, 0);
-  Quat<T> c1 = (ident + *this).log();
-  Quat<T> c2 = (ident - *this).log();
-  return 0.5 * (c1 - c2);
-}
-
-template <typename T> inline Quat<T> asin(const Quat<T> &q) { return q.asin(); }
-
-template <typename T> inline Quat<T> Quat<T>::asin() const {
-  Quat<T> v(0, x, y, z);
-  T vNorm = v.norm();
-  T k = vNorm < CV_QUAT_EPS ? 1 : vNorm;
-  return -v / k * (*this * v / k).asinh();
-}
-
-template <typename T> inline Quat<T> acos(const Quat<T> &q) { return q.acos(); }
-
-template <typename T> inline Quat<T> Quat<T>::acos() const {
-  Quat<T> v(0, x, y, z);
-  T vNorm = v.norm();
-  T k = vNorm < CV_QUAT_EPS ? 1 : vNorm;
-  return -v / k * acosh();
-}
-
-template <typename T> inline Quat<T> atan(const Quat<T> &q) { return q.atan(); }
-
-template <typename T> inline Quat<T> Quat<T>::atan() const {
-  Quat<T> v(0, x, y, z);
-  T vNorm = v.norm();
-  T k = vNorm < CV_QUAT_EPS ? 1 : vNorm;
-  return -v / k * (*this * v / k).atanh();
-}
-
-template <typename T>
-inline T Quat<T>::getAngle(QuatAssumeType assumeUnit) const {
-  if (assumeUnit) {
-    return 2 * std::acos(w);
-  }
-  if (norm() < CV_QUAT_EPS) {
-    CV_Error(Error::StsBadArg, "This quaternion does not represent a rotation");
-  }
-  return 2 * std::acos(w / norm());
-}
-
-template <typename T>
-inline Vec<T, 3> Quat<T>::getAxis(QuatAssumeType assumeUnit) const {
-  T angle = getAngle(assumeUnit);
-  const T sin_v = std::sin(angle * 0.5);
-  if (assumeUnit) {
-    return Vec<T, 3>{x, y, z} / sin_v;
-  }
-  return Vec<T, 3>{x, y, z} / (norm() * sin_v);
-}
-
-template <typename T>
-Matx<T, 4, 4> Quat<T>::toRotMat4x4(QuatAssumeType assumeUnit) const {
-  T a = w, b = x, c = y, d = z;
-  if (!assumeUnit) {
-    Quat<T> qTemp = normalize();
-    a = qTemp.w;
-    b = qTemp.x;
-    c = qTemp.y;
-    d = qTemp.z;
-  }
-  Matx<T, 4, 4> R{
-      1 - 2 * (c * c + d * d),
-      2 * (b * c - a * d),
-      2 * (b * d + a * c),
-      0,
-      2 * (b * c + a * d),
-      1 - 2 * (b * b + d * d),
-      2 * (c * d - a * b),
-      0,
-      2 * (b * d - a * c),
-      2 * (c * d + a * b),
-      1 - 2 * (b * b + c * c),
-      0,
-      0,
-      0,
-      0,
-      1,
-  };
-  return R;
-}
-
-template <typename T>
-Matx<T, 3, 3> Quat<T>::toRotMat3x3(QuatAssumeType assumeUnit) const {
-  T a = w, b = x, c = y, d = z;
-  if (!assumeUnit) {
-    Quat<T> qTemp = normalize();
-    a = qTemp.w;
-    b = qTemp.x;
-    c = qTemp.y;
-    d = qTemp.z;
-  }
-  Matx<T, 3, 3> R{1 - 2 * (c * c + d * d), 2 * (b * c - a * d),
-                  2 * (b * d + a * c),     2 * (b * c + a * d),
-                  1 - 2 * (b * b + d * d), 2 * (c * d - a * b),
-                  2 * (b * d - a * c),     2 * (c * d + a * b),
-                  1 - 2 * (b * b + c * c)};
-  return R;
-}
-
-template <typename T>
-Vec<T, 3> Quat<T>::toRotVec(QuatAssumeType assumeUnit) const {
-  T angle = getAngle(assumeUnit);
-  Vec<T, 3> axis = getAxis(assumeUnit);
-  return angle * axis;
-}
-
-template <typename T> Vec<T, 4> Quat<T>::toVec() const {
-  return Vec<T, 4>{w, x, y, z};
-}
-
-template <typename T>
-Quat<T> Quat<T>::lerp(const Quat<T> &q0, const Quat<T> &q1, const T t) {
-  return (1 - t) * q0 + t * q1;
-}
-
-template <typename T>
-Quat<T> Quat<T>::slerp(const Quat<T> &q0, const Quat<T> &q1, const T t,
-                       QuatAssumeType assumeUnit, bool directChange) {
-  Quat<T> v0(q0);
-  Quat<T> v1(q1);
-  if (!assumeUnit) {
-    v0 = v0.normalize();
-    v1 = v1.normalize();
-  }
-  T cosTheta = v0.dot(v1);
-  constexpr T DOT_THRESHOLD = 0.995;
-  if (std::abs(cosTheta) > DOT_THRESHOLD) {
-    return nlerp(v0, v1, t, QUAT_ASSUME_UNIT);
-  }
-
-  if (directChange && cosTheta < 0) {
-    v0 = -v0;
-    cosTheta = -cosTheta;
-  }
-  T sinTheta = std::sqrt(1 - cosTheta * cosTheta);
-  T angle = atan2(sinTheta, cosTheta);
-  return (std::sin((1 - t) * angle) / (sinTheta)*v0 +
-          std::sin(t * angle) / (sinTheta)*v1)
-      .normalize();
-}
-
-template <typename T>
-inline Quat<T> Quat<T>::nlerp(const Quat<T> &q0, const Quat<T> &q1, const T t,
-                              QuatAssumeType assumeUnit) {
-  Quat<T> v0(q0), v1(q1);
-  if (v1.dot(v0) < 0) {
-    v0 = -v0;
-  }
-  if (assumeUnit) {
-    return ((1 - t) * v0 + t * v1).normalize();
-  }
-  v0 = v0.normalize();
-  v1 = v1.normalize();
-  return ((1 - t) * v0 + t * v1).normalize();
-}
-
-template <typename T> inline bool Quat<T>::isNormal(T eps) const {
-
-  double normVar = norm();
-  if ((normVar > 1 - eps) && (normVar < 1 + eps))
-    return true;
-  return false;
-}
-
-template <typename T> inline void Quat<T>::assertNormal(T eps) const {
-  if (!isNormal(eps))
-    CV_Error(Error::StsBadArg, "Quaternion should be normalized");
-}
-
-template <typename T>
-inline Quat<T> Quat<T>::squad(const Quat<T> &q0, const Quat<T> &q1,
-                              const Quat<T> &q2, const Quat<T> &q3, const T t,
-                              QuatAssumeType assumeUnit, bool directChange) {
-  Quat<T> v0(q0), v1(q1), v2(q2), v3(q3);
-  if (!assumeUnit) {
-    v0 = v0.normalize();
-    v1 = v1.normalize();
-    v2 = v2.normalize();
-    v3 = v3.normalize();
-  }
-
-  Quat<T> c0 = slerp(v0, v3, t, assumeUnit, directChange);
-  Quat<T> c1 = slerp(v1, v2, t, assumeUnit, directChange);
-  return slerp(c0, c1, 2 * t * (1 - t), assumeUnit, directChange);
-}
-
-template <typename T>
-Quat<T> Quat<T>::interPoint(const Quat<T> &q0, const Quat<T> &q1,
-                            const Quat<T> &q2, QuatAssumeType assumeUnit) {
-  Quat<T> v0(q0), v1(q1), v2(q2);
-  if (!assumeUnit) {
-    v0 = v0.normalize();
-    v1 = v1.normalize();
-    v2 = v2.normalize();
-  }
-  return v1 * cv::exp(-(cv::log(v1.conjugate() * v0, assumeUnit) +
-                        (cv::log(v1.conjugate() * v2, assumeUnit))) /
-                      4);
-}
-
-template <typename T>
-Quat<T> Quat<T>::spline(const Quat<T> &q0, const Quat<T> &q1, const Quat<T> &q2,
-                        const Quat<T> &q3, const T t,
-                        QuatAssumeType assumeUnit) {
-  Quat<T> v0(q0), v1(q1), v2(q2), v3(q3);
-  if (!assumeUnit) {
-    v0 = v0.normalize();
-    v1 = v1.normalize();
-    v2 = v2.normalize();
-    v3 = v3.normalize();
-  }
-  T cosTheta;
-  std::vector<Quat<T>> vec{v0, v1, v2, v3};
-  for (size_t i = 0; i < 3; ++i) {
-    cosTheta = vec[i].dot(vec[i + 1]);
-    if (cosTheta < 0) {
-      vec[i + 1] = -vec[i + 1];
-    }
-  }
-  Quat<T> s1 = interPoint(vec[0], vec[1], vec[2], QUAT_ASSUME_UNIT);
-  Quat<T> s2 = interPoint(vec[1], vec[2], vec[3], QUAT_ASSUME_UNIT);
-  return squad(vec[1], s1, s2, vec[2], t, assumeUnit, QUAT_ASSUME_NOT_UNIT);
-}
-
-namespace detail {
-
-template <typename T>
-static Quat<T> createFromAxisRot(int axis, const T theta) {
-  if (axis == 0)
-    return Quat<T>::createFromXRot(theta);
-  if (axis == 1)
-    return Quat<T>::createFromYRot(theta);
-  if (axis == 2)
-    return Quat<T>::createFromZRot(theta);
-  CV_Assert(0);
-}
-
-inline bool isIntAngleType(QuatEnum::EulerAnglesType eulerAnglesType) {
-  return eulerAnglesType < QuatEnum::EXT_XYZ;
-}
-
-inline bool isTaitBryan(QuatEnum::EulerAnglesType eulerAnglesType) {
-  return eulerAnglesType / 6 == 1 || eulerAnglesType / 6 == 3;
-}
-} // namespace detail
-
-template <typename T> Quat<T> Quat<T>::createFromYRot(const T theta) {
-  return Quat<T>{std::cos(theta * 0.5f), 0, std::sin(theta * 0.5f), 0};
-}
-
-template <typename T> Quat<T> Quat<T>::createFromXRot(const T theta) {
-  return Quat<T>{std::cos(theta * 0.5f), std::sin(theta * 0.5f), 0, 0};
-}
-
-template <typename T> Quat<T> Quat<T>::createFromZRot(const T theta) {
-  return Quat<T>{std::cos(theta * 0.5f), 0, 0, std::sin(theta * 0.5f)};
-}
-
-template <typename T>
-Quat<T>
-Quat<T>::createFromEulerAngles(const Vec<T, 3> &angles,
-                               QuatEnum::EulerAnglesType eulerAnglesType) {
-  CV_Assert(eulerAnglesType <
-            QuatEnum::EulerAnglesType::EULER_ANGLES_MAX_VALUE);
-  static const int rotationAxis[24][3] = {
-      {0, 1, 2}, ///< Intrinsic rotations with the Euler angles type X-Y-Z
-      {0, 2, 1}, ///< Intrinsic rotations with the Euler angles type X-Z-Y
-      {1, 0, 2}, ///< Intrinsic rotations with the Euler angles type Y-X-Z
-      {1, 2, 0}, ///< Intrinsic rotations with the Euler angles type Y-Z-X
-      {2, 0, 1}, ///< Intrinsic rotations with the Euler angles type Z-X-Y
-      {2, 1, 0}, ///< Intrinsic rotations with the Euler angles type Z-Y-X
-      {0, 1, 0}, ///< Intrinsic rotations with the Euler angles type X-Y-X
-      {0, 2, 0}, ///< Intrinsic rotations with the Euler angles type X-Z-X
-      {1, 0, 1}, ///< Intrinsic rotations with the Euler angles type Y-X-Y
-      {1, 2, 1}, ///< Intrinsic rotations with the Euler angles type Y-Z-Y
-      {2, 0, 2}, ///< Intrinsic rotations with the Euler angles type Z-X-Z
-      {2, 1, 2}, ///< Intrinsic rotations with the Euler angles type Z-Y-Z
-      {0, 1, 2}, ///< Extrinsic rotations with the Euler angles type X-Y-Z
-      {0, 2, 1}, ///< Extrinsic rotations with the Euler angles type X-Z-Y
-      {1, 0, 2}, ///< Extrinsic rotations with the Euler angles type Y-X-Z
-      {1, 2, 0}, ///< Extrinsic rotations with the Euler angles type Y-Z-X
-      {2, 0, 1}, ///< Extrinsic rotations with the Euler angles type Z-X-Y
-      {2, 1, 0}, ///< Extrinsic rotations with the Euler angles type Z-Y-X
-      {0, 1, 0}, ///< Extrinsic rotations with the Euler angles type X-Y-X
-      {0, 2, 0}, ///< Extrinsic rotations with the Euler angles type X-Z-X
-      {1, 0, 1}, ///< Extrinsic rotations with the Euler angles type Y-X-Y
-      {1, 2, 1}, ///< Extrinsic rotations with the Euler angles type Y-Z-Y
-      {2, 0, 2}, ///< Extrinsic rotations with the Euler angles type Z-X-Z
-      {2, 1, 2}  ///< Extrinsic rotations with the Euler angles type Z-Y-Z
-  };
-  Quat<T> q1 =
-      detail::createFromAxisRot(rotationAxis[eulerAnglesType][0], angles(0));
-  Quat<T> q2 =
-      detail::createFromAxisRot(rotationAxis[eulerAnglesType][1], angles(1));
-  Quat<T> q3 =
-      detail::createFromAxisRot(rotationAxis[eulerAnglesType][2], angles(2));
-  if (detail::isIntAngleType(eulerAnglesType)) {
-    return q1 * q2 * q3;
-  } else // (!detail::isIntAngleType<T>(eulerAnglesType))
-  {
-    return q3 * q2 * q1;
-  }
-}
-
-template <typename T>
-Vec<T, 3> Quat<T>::toEulerAngles(QuatEnum::EulerAnglesType eulerAnglesType) {
-  CV_Assert(eulerAnglesType <
-            QuatEnum::EulerAnglesType::EULER_ANGLES_MAX_VALUE);
-  Matx33d R = toRotMat3x3();
-  enum {
-    C_ZERO,
-    C_PI,
-    C_PI_2,
-    N_CONSTANTS,
-    R_0_0 = N_CONSTANTS,
-    R_0_1,
-    R_0_2,
-    R_1_0,
-    R_1_1,
-    R_1_2,
-    R_2_0,
-    R_2_1,
-    R_2_2
-  };
-  static const T constants_[N_CONSTANTS] = {
-      0,               // C_ZERO
-      (T)CV_PI,        // C_PI
-      (T)(CV_PI * 0.5) // C_PI_2, -C_PI_2
-  };
-  static const int rotationR_[24][12] = {
-      {+R_0_2, +R_1_0, +R_1_1, C_PI_2, +R_2_1, +R_1_1, -C_PI_2, -R_1_2, +R_2_2,
-       +R_0_2, -R_0_1, +R_0_0}, // INT_XYZ
-      {+R_0_1, -R_1_2, +R_2_2, -C_PI_2, +R_2_0, +R_2_2, C_PI_2, +R_2_1, +R_1_1,
-       -R_0_1, +R_0_2, +R_0_0}, // INT_XZY
-      {+R_1_2, -R_0_1, +R_0_0, -C_PI_2, +R_0_1, +R_0_0, C_PI_2, +R_0_2, +R_2_2,
-       -R_1_2, +R_1_0, +R_1_1}, // INT_YXZ
-      {+R_1_0, +R_0_2, +R_2_2, C_PI_2, +R_0_2, +R_0_1, -C_PI_2, -R_2_0, +R_0_0,
-       +R_1_0, -R_1_2, +R_1_1}, // INT_YZX
-      {+R_2_1, +R_1_0, +R_0_0, C_PI_2, +R_1_0, +R_0_0, -C_PI_2, -R_0_1, +R_1_1,
-       +R_2_1, -R_2_0, +R_2_2}, // INT_ZXY
-      {+R_2_0, -R_0_1, +R_1_1, -C_PI_2, +R_1_2, +R_1_1, C_PI_2, +R_1_0, +R_0_0,
-       -R_2_0, +R_2_1, +R_2_2}, // INT_ZYX
-      {+R_0_0, +R_2_1, +R_2_2, C_ZERO, +R_1_2, +R_1_1, C_PI, +R_1_0, -R_2_0,
-       +R_0_0, +R_0_1, +R_0_2}, // INT_XYX
-      {+R_0_0, +R_2_1, +R_2_2, C_ZERO, -R_2_1, +R_2_2, C_PI, +R_2_0, +R_1_0,
-       +R_0_0, +R_0_2, -R_0_1}, // INT_XZX
-      {+R_1_1, +R_0_2, +R_0_0, C_ZERO, -R_2_0, +R_0_0, C_PI, +R_0_1, +R_2_1,
-       +R_1_1, +R_1_0, -R_1_2}, // INT_YXY
-      {+R_1_1, +R_0_2, +R_0_0, C_ZERO, +R_0_2, -R_0_0, C_PI, +R_2_1, -R_0_1,
-       +R_1_1, +R_1_2, +R_1_0}, // INT_YZY
-      {+R_2_2, +R_1_0, +R_1_1, C_ZERO, +R_1_0, +R_0_0, C_PI, +R_0_2, -R_1_2,
-       +R_2_2, +R_2_0, +R_2_1}, // INT_ZXZ
-      {+R_2_2, +R_1_0, +R_0_0, C_ZERO, +R_1_0, +R_0_0, C_PI, +R_1_2, +R_0_2,
-       +R_2_2, +R_2_1, -R_2_0}, // INT_ZYZ
-
-      {+R_2_0, -C_PI_2, -R_0_1, +R_1_1, C_PI_2, +R_1_2, +R_1_1, +R_2_1, +R_2_2,
-       -R_2_0, +R_1_0, +R_0_0}, // EXT_XYZ
-      {+R_1_0, C_PI_2, +R_0_2, +R_2_2, -C_PI_2, +R_0_2, +R_0_1, -R_1_2, +R_1_1,
-       +R_1_0, -R_2_0, +R_0_0}, // EXT_XZY
-      {+R_2_1, C_PI_2, +R_1_0, +R_0_0, -C_PI_2, +R_1_0, +R_0_0, -R_2_0, +R_2_2,
-       +R_2_1, -R_0_1, +R_1_1}, // EXT_YXZ
-      {+R_0_2, -C_PI_2, -R_1_2, +R_2_2, C_PI_2, +R_2_0, +R_2_2, +R_0_2, +R_0_0,
-       -R_0_1, +R_2_1, +R_1_1}, // EXT_YZX
-      {+R_1_2, -C_PI_2, -R_0_1, +R_0_0, C_PI_2, +R_0_1, +R_0_0, +R_1_0, +R_1_1,
-       -R_1_2, +R_0_2, +R_2_2}, // EXT_ZXY
-      {+R_0_2, C_PI_2, +R_1_0, +R_1_1, -C_PI_2, +R_2_1, +R_1_1, -R_0_1, +R_0_0,
-       +R_0_2, -R_1_2, +R_2_2}, // EXT_ZYX
-      {+R_0_0, C_ZERO, +R_2_1, +R_2_2, C_PI, +R_1_2, +R_1_1, +R_0_1, +R_0_2,
-       +R_0_0, +R_1_0, -R_2_0}, // EXT_XYX
-      {+R_0_0, C_ZERO, +R_2_1, +R_2_2, C_PI, +R_2_1, +R_2_2, +R_0_2, -R_0_1,
-       +R_0_0, +R_2_0, +R_1_0}, // EXT_XZX
-      {+R_1_1, C_ZERO, +R_0_2, +R_0_0, C_PI, -R_2_0, +R_0_0, +R_1_0, -R_1_2,
-       +R_1_1, +R_0_1, +R_2_1}, // EXT_YXY
-      {+R_1_1, C_ZERO, +R_0_2, +R_0_0, C_PI, +R_0_2, -R_0_0, +R_1_2, +R_1_0,
-       +R_1_1, +R_2_1, -R_0_1}, // EXT_YZY
-      {+R_2_2, C_ZERO, +R_1_0, +R_1_1, C_PI, +R_1_0, +R_0_0, +R_2_0, +R_2_1,
-       +R_2_2, +R_0_2, -R_1_2}, // EXT_ZXZ
-      {+R_2_2, C_ZERO, +R_1_0, +R_0_0, C_PI, +R_1_0, +R_0_0, +R_2_1, -R_2_0,
-       +R_2_2, +R_1_2, +R_0_2}, // EXT_ZYZ
-  };
-  T rotationR[12];
-  for (int i = 0; i < 12; i++) {
-    int id = rotationR_[eulerAnglesType][i];
-    unsigned idx = std::abs(id);
-    T value = 0.0f;
-    if (idx < N_CONSTANTS) {
-      value = constants_[idx];
-    } else {
-      unsigned r_idx = idx - N_CONSTANTS;
-      CV_DbgAssert(r_idx < 9);
-      value = R.val[r_idx];
-    }
-    bool isNegative = id < 0;
-    if (isNegative)
-      value = -value;
-    rotationR[i] = value;
-  }
-  Vec<T, 3> angles;
-  if (detail::isIntAngleType(eulerAnglesType)) {
-    if (abs(rotationR[0] - 1) < CV_QUAT_CONVERT_THRESHOLD) {
-      CV_LOG_WARNING(NULL, "Gimbal Lock occurs. Euler angles are non-unique, "
-                           "we set the third angle to 0");
-      angles = {std::atan2(rotationR[1], rotationR[2]), rotationR[3], 0};
-      return angles;
-    } else if (abs(rotationR[0] + 1) < CV_QUAT_CONVERT_THRESHOLD) {
-      CV_LOG_WARNING(NULL, "Gimbal Lock occurs. Euler angles are non-unique, "
-                           "we set the third angle to 0");
-      angles = {std::atan2(rotationR[4], rotationR[5]), rotationR[6], 0};
-      return angles;
-    }
-  } else // (!detail::isIntAngleType<T>(eulerAnglesType))
-  {
-    if (abs(rotationR[0] - 1) < CV_QUAT_CONVERT_THRESHOLD) {
-      CV_LOG_WARNING(NULL, "Gimbal Lock occurs. Euler angles are non-unique, "
-                           "we set the first angle to 0");
-      angles = {0, rotationR[1], std::atan2(rotationR[2], rotationR[3])};
-      return angles;
-    } else if (abs(rotationR[0] + 1) < CV_QUAT_CONVERT_THRESHOLD) {
-      CV_LOG_WARNING(NULL, "Gimbal Lock occurs. Euler angles are non-unique, "
-                           "we set the first angle to 0");
-      angles = {0, rotationR[4], std::atan2(rotationR[5], rotationR[6])};
-      return angles;
-    }
-  }
-
-  angles(0) = std::atan2(rotationR[7], rotationR[8]);
-  if (detail::isTaitBryan(eulerAnglesType))
-    angles(1) = std::acos(rotationR[9]);
-  else
-    angles(1) = std::asin(rotationR[9]);
-  angles(2) = std::atan2(rotationR[10], rotationR[11]);
-  return angles;
-}
-
-} // namespace cv
-//! @endcond
-
-#endif /*OPENCV_CORE_QUATERNION_INL_HPP*/
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/saturate.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/saturate.hpp
deleted file mode 100644
index bfdef218a5..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/saturate.hpp
+++ /dev/null
@@ -1,347 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Copyright (C) 2014, Itseez Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_CORE_SATURATE_HPP
-#define OPENCV_CORE_SATURATE_HPP
-
-#include "opencv2/core/cvdef.h"
-#include "opencv2/core/fast_math.hpp"
-#include <climits>
-
-namespace cv {
-
-//! @addtogroup core_utils
-//! @{
-
-/////////////// saturate_cast (used in image & signal processing)
-//////////////////////
-
-/** @brief Template function for accurate conversion from one primitive type to
- another.
-
- The function saturate_cast resembles the standard C++ cast operations, such as
- static_cast\<T\>() and others. It perform an efficient and accurate conversion
- from one primitive type to another (see the introduction chapter). saturate in
- the name means that when the input value v is out of the range of the target
- type, the result is not formed just by taking low bits of the input, but
- instead the value is clipped. For example:
- @code
- uchar a = saturate_cast<uchar>(-100); // a = 0 (UCHAR_MIN)
- short b = saturate_cast<short>(33333.33333); // b = 32767 (SHRT_MAX)
- @endcode
- Such clipping is done when the target type is unsigned char , signed char ,
- unsigned short or signed short . For 32-bit integers, no clipping is done.
-
- When the parameter is a floating-point value and the target type is an integer
- (8-, 16- or 32-bit), the floating-point value is first rounded to the nearest
- integer and then clipped if needed (when the target type is 8- or 16-bit).
-
- @param v Function parameter.
- @sa add, subtract, multiply, divide, Mat::convertTo
- */
-template <typename _Tp> static inline _Tp saturate_cast(uchar v) {
-  return _Tp(v);
-}
-/** @overload */
-template <typename _Tp> static inline _Tp saturate_cast(schar v) {
-  return _Tp(v);
-}
-/** @overload */
-template <typename _Tp> static inline _Tp saturate_cast(ushort v) {
-  return _Tp(v);
-}
-/** @overload */
-template <typename _Tp> static inline _Tp saturate_cast(short v) {
-  return _Tp(v);
-}
-/** @overload */
-template <typename _Tp> static inline _Tp saturate_cast(unsigned v) {
-  return _Tp(v);
-}
-/** @overload */
-template <typename _Tp> static inline _Tp saturate_cast(int v) {
-  return _Tp(v);
-}
-/** @overload */
-template <typename _Tp> static inline _Tp saturate_cast(float v) {
-  return _Tp(v);
-}
-/** @overload */
-template <typename _Tp> static inline _Tp saturate_cast(double v) {
-  return _Tp(v);
-}
-/** @overload */
-template <typename _Tp> static inline _Tp saturate_cast(int64 v) {
-  return _Tp(v);
-}
-/** @overload */
-template <typename _Tp> static inline _Tp saturate_cast(uint64 v) {
-  return _Tp(v);
-}
-
-template <> inline uchar saturate_cast<uchar>(schar v) {
-  return (uchar)std::max((int)v, 0);
-}
-template <> inline uchar saturate_cast<uchar>(ushort v) {
-  return (uchar)std::min((unsigned)v, (unsigned)UCHAR_MAX);
-}
-template <> inline uchar saturate_cast<uchar>(int v) {
-  return (uchar)((unsigned)v <= UCHAR_MAX ? v : v > 0 ? UCHAR_MAX : 0);
-}
-template <> inline uchar saturate_cast<uchar>(short v) {
-  return saturate_cast<uchar>((int)v);
-}
-template <> inline uchar saturate_cast<uchar>(unsigned v) {
-  return (uchar)std::min(v, (unsigned)UCHAR_MAX);
-}
-template <> inline uchar saturate_cast<uchar>(float v) {
-  int iv = cvRound(v);
-  return saturate_cast<uchar>(iv);
-}
-template <> inline uchar saturate_cast<uchar>(double v) {
-  int iv = cvRound(v);
-  return saturate_cast<uchar>(iv);
-}
-template <> inline uchar saturate_cast<uchar>(int64 v) {
-  return (uchar)((uint64)v <= (uint64)UCHAR_MAX ? v : v > 0 ? UCHAR_MAX : 0);
-}
-template <> inline uchar saturate_cast<uchar>(uint64 v) {
-  return (uchar)std::min(v, (uint64)UCHAR_MAX);
-}
-
-template <> inline schar saturate_cast<schar>(uchar v) {
-  return (schar)std::min((int)v, SCHAR_MAX);
-}
-template <> inline schar saturate_cast<schar>(ushort v) {
-  return (schar)std::min((unsigned)v, (unsigned)SCHAR_MAX);
-}
-template <> inline schar saturate_cast<schar>(int v) {
-  return (schar)((unsigned)(v - SCHAR_MIN) <= (unsigned)UCHAR_MAX ? v
-                 : v > 0                                          ? SCHAR_MAX
-                                                                  : SCHAR_MIN);
-}
-template <> inline schar saturate_cast<schar>(short v) {
-  return saturate_cast<schar>((int)v);
-}
-template <> inline schar saturate_cast<schar>(unsigned v) {
-  return (schar)std::min(v, (unsigned)SCHAR_MAX);
-}
-template <> inline schar saturate_cast<schar>(float v) {
-  int iv = cvRound(v);
-  return saturate_cast<schar>(iv);
-}
-template <> inline schar saturate_cast<schar>(double v) {
-  int iv = cvRound(v);
-  return saturate_cast<schar>(iv);
-}
-template <> inline schar saturate_cast<schar>(int64 v) {
-  return (schar)((uint64)((int64)v - SCHAR_MIN) <= (uint64)UCHAR_MAX ? v
-                 : v > 0                                             ? SCHAR_MAX
-                         : SCHAR_MIN);
-}
-template <> inline schar saturate_cast<schar>(uint64 v) {
-  return (schar)std::min(v, (uint64)SCHAR_MAX);
-}
-
-template <> inline ushort saturate_cast<ushort>(schar v) {
-  return (ushort)std::max((int)v, 0);
-}
-template <> inline ushort saturate_cast<ushort>(short v) {
-  return (ushort)std::max((int)v, 0);
-}
-template <> inline ushort saturate_cast<ushort>(int v) {
-  return (ushort)((unsigned)v <= (unsigned)USHRT_MAX ? v
-                  : v > 0                            ? USHRT_MAX
-                                                     : 0);
-}
-template <> inline ushort saturate_cast<ushort>(unsigned v) {
-  return (ushort)std::min(v, (unsigned)USHRT_MAX);
-}
-template <> inline ushort saturate_cast<ushort>(float v) {
-  int iv = cvRound(v);
-  return saturate_cast<ushort>(iv);
-}
-template <> inline ushort saturate_cast<ushort>(double v) {
-  int iv = cvRound(v);
-  return saturate_cast<ushort>(iv);
-}
-template <> inline ushort saturate_cast<ushort>(int64 v) {
-  return (ushort)((uint64)v <= (uint64)USHRT_MAX ? v : v > 0 ? USHRT_MAX : 0);
-}
-template <> inline ushort saturate_cast<ushort>(uint64 v) {
-  return (ushort)std::min(v, (uint64)USHRT_MAX);
-}
-
-template <> inline short saturate_cast<short>(ushort v) {
-  return (short)std::min((int)v, SHRT_MAX);
-}
-template <> inline short saturate_cast<short>(int v) {
-  return (short)((unsigned)(v - SHRT_MIN) <= (unsigned)USHRT_MAX ? v
-                 : v > 0                                         ? SHRT_MAX
-                                                                 : SHRT_MIN);
-}
-template <> inline short saturate_cast<short>(unsigned v) {
-  return (short)std::min(v, (unsigned)SHRT_MAX);
-}
-template <> inline short saturate_cast<short>(float v) {
-  int iv = cvRound(v);
-  return saturate_cast<short>(iv);
-}
-template <> inline short saturate_cast<short>(double v) {
-  int iv = cvRound(v);
-  return saturate_cast<short>(iv);
-}
-template <> inline short saturate_cast<short>(int64 v) {
-  return (short)((uint64)((int64)v - SHRT_MIN) <= (uint64)USHRT_MAX ? v
-                 : v > 0                                            ? SHRT_MAX
-                                                                    : SHRT_MIN);
-}
-template <> inline short saturate_cast<short>(uint64 v) {
-  return (short)std::min(v, (uint64)SHRT_MAX);
-}
-
-template <> inline int saturate_cast<int>(unsigned v) {
-  return (int)std::min(v, (unsigned)INT_MAX);
-}
-template <> inline int saturate_cast<int>(int64 v) {
-  return (int)((uint64)(v - INT_MIN) <= (uint64)UINT_MAX ? v
-               : v > 0                                   ? INT_MAX
-                                                         : INT_MIN);
-}
-template <> inline int saturate_cast<int>(uint64 v) {
-  return (int)std::min(v, (uint64)INT_MAX);
-}
-template <> inline int saturate_cast<int>(float v) { return cvRound(v); }
-template <> inline int saturate_cast<int>(double v) { return cvRound(v); }
-
-template <> inline unsigned saturate_cast<unsigned>(schar v) {
-  return (unsigned)std::max(v, (schar)0);
-}
-template <> inline unsigned saturate_cast<unsigned>(short v) {
-  return (unsigned)std::max(v, (short)0);
-}
-template <> inline unsigned saturate_cast<unsigned>(int v) {
-  return (unsigned)std::max(v, (int)0);
-}
-template <> inline unsigned saturate_cast<unsigned>(int64 v) {
-  return (unsigned)((uint64)v <= (uint64)UINT_MAX ? v : v > 0 ? UINT_MAX : 0);
-}
-template <> inline unsigned saturate_cast<unsigned>(uint64 v) {
-  return (unsigned)std::min(v, (uint64)UINT_MAX);
-}
-// we intentionally do not clip negative numbers, to make -1 become 0xffffffff
-// etc.
-template <> inline unsigned saturate_cast<unsigned>(float v) {
-  return static_cast<unsigned>(cvRound(v));
-}
-template <> inline unsigned saturate_cast<unsigned>(double v) {
-  return static_cast<unsigned>(cvRound(v));
-}
-
-template <> inline uint64 saturate_cast<uint64>(schar v) {
-  return (uint64)std::max(v, (schar)0);
-}
-template <> inline uint64 saturate_cast<uint64>(short v) {
-  return (uint64)std::max(v, (short)0);
-}
-template <> inline uint64 saturate_cast<uint64>(int v) {
-  return (uint64)std::max(v, (int)0);
-}
-template <> inline uint64 saturate_cast<uint64>(int64 v) {
-  return (uint64)std::max(v, (int64)0);
-}
-
-template <> inline int64 saturate_cast<int64>(uint64 v) {
-  return (int64)std::min(v, (uint64)LLONG_MAX);
-}
-
-/** @overload */
-template <typename _Tp> static inline _Tp saturate_cast(hfloat v) {
-  return saturate_cast<_Tp>((float)v);
-}
-
-// in theory, we could use a LUT for 8u/8s->16f conversion,
-// but with hardware support for FP32->FP16 conversion the current approach is
-// preferable
-template <> inline hfloat saturate_cast<hfloat>(uchar v) {
-  return hfloat((float)v);
-}
-template <> inline hfloat saturate_cast<hfloat>(schar v) {
-  return hfloat((float)v);
-}
-template <> inline hfloat saturate_cast<hfloat>(ushort v) {
-  return hfloat((float)v);
-}
-template <> inline hfloat saturate_cast<hfloat>(short v) {
-  return hfloat((float)v);
-}
-template <> inline hfloat saturate_cast<hfloat>(unsigned v) {
-  return hfloat((float)v);
-}
-template <> inline hfloat saturate_cast<hfloat>(int v) {
-  return hfloat((float)v);
-}
-template <> inline hfloat saturate_cast<hfloat>(uint64 v) {
-  return hfloat((float)v);
-}
-template <> inline hfloat saturate_cast<hfloat>(int64 v) {
-  return hfloat((float)v);
-}
-template <> inline hfloat saturate_cast<hfloat>(float v) { return hfloat(v); }
-template <> inline hfloat saturate_cast<hfloat>(double v) {
-  return hfloat((float)v);
-}
-
-//! @}
-
-} // namespace cv
-
-#endif // OPENCV_CORE_SATURATE_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/simd_intrinsics.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/simd_intrinsics.hpp
deleted file mode 100644
index a1f3917866..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/simd_intrinsics.hpp
+++ /dev/null
@@ -1,90 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_CORE_SIMD_INTRINSICS_HPP
-#define OPENCV_CORE_SIMD_INTRINSICS_HPP
-
-/**
-Helper header to support SIMD intrinsics (universal intrinsics) in user code.
-Intrinsics documentation:
-https://docs.opencv.org/4.x/df/d91/group__core__hal__intrin.html
-
-
-Checks of target CPU instruction set based on compiler definitions don't work
-well enough. More reliable solutions require utilization of configuration
-systems (like CMake).
-
-So, probably you need to specify your own configuration.
-
-You can do that via CMake in this way:
-    add_definitions(/DOPENCV_SIMD_CONFIG_HEADER=opencv_simd_config_custom.hpp)
-or
-    add_definitions(/DOPENCV_SIMD_CONFIG_INCLUDE_DIR=1)
-
-Additionally you may need to add include directory to your files:
-    include_directories("${CMAKE_CURRENT_LIST_DIR}/opencv_config_${MYTARGET}")
-
-These files can be pre-generated for target configurations of your application
-or generated by CMake on the fly (use CMAKE_BINARY_DIR for that).
-
-Notes:
-- H/W capability checks are still responsibility of your application
-- runtime dispatching is not covered by this helper header
-*/
-
-#ifdef __OPENCV_BUILD
-#error "Use core/hal/intrin.hpp during OpenCV build"
-#endif
-
-#ifdef OPENCV_HAL_INTRIN_HPP
-#error "core/simd_intrinsics.hpp must be included before core/hal/intrin.hpp"
-#endif
-
-#include "opencv2/core/cvdef.h"
-
-#ifdef OPENCV_SIMD_CONFIG_HEADER
-#include CVAUX_STR(OPENCV_SIMD_CONFIG_HEADER)
-#elif defined(OPENCV_SIMD_CONFIG_INCLUDE_DIR)
-#include "opencv_simd_config.hpp" // corresponding directory should be added via -I compiler parameter
-#else                             // custom config headers
-
-#if (!defined(CV_AVX_512F) || !CV_AVX_512F) &&                                 \
-    (defined(__AVX512__) || defined(__AVX512F__))
-#include <immintrin.h>
-#undef CV_AVX_512F
-#define CV_AVX_512F 1
-#ifndef OPENCV_SIMD_DONT_ASSUME_SKX // Skylake-X with AVX-512F/CD/BW/DQ/VL
-#undef CV_AVX512_SKX
-#define CV_AVX512_SKX 1
-#undef CV_AVX_512CD
-#define CV_AVX_512CD 1
-#undef CV_AVX_512BW
-#define CV_AVX_512BW 1
-#undef CV_AVX_512DQ
-#define CV_AVX_512DQ 1
-#undef CV_AVX_512VL
-#define CV_AVX_512VL 1
-#endif
-#endif // AVX512
-
-// GCC/Clang: -mavx2
-// MSVC: /arch:AVX2
-#if defined __AVX2__
-#include <immintrin.h>
-#undef CV_AVX2
-#define CV_AVX2 1
-#if defined __F16C__
-#undef CV_FP16
-#define CV_FP16 1
-#endif
-#endif
-
-#endif
-
-// SSE / NEON / VSX is handled by cv_cpu_dispatch.h compatibility block
-#include "cv_cpu_dispatch.h"
-
-#include "hal/intrin.hpp"
-
-#endif // OPENCV_CORE_SIMD_INTRINSICS_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/softfloat.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/softfloat.hpp
deleted file mode 100644
index 68c1ed7777..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/softfloat.hpp
+++ /dev/null
@@ -1,657 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html
-
-// This file is based on files from package issued with the following license:
-
-/*============================================================================
-
-This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3c, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#pragma once
-#ifndef softfloat_h
-#define softfloat_h 1
-
-#include "cvdef.h"
-
-namespace cv {
-
-/** @addtogroup core_utils_softfloat
-
-  [SoftFloat](http://www.jhauser.us/arithmetic/SoftFloat.html) is a software
- implementation of floating-point calculations according to IEEE 754 standard.
-  All calculations are done in integers, that's why they are machine-independent
- and bit-exact. This library can be useful in accuracy-critical parts like
- look-up tables generation, tests, etc. OpenCV contains a subset of SoftFloat
- partially rewritten to C++.
-
-  ### Types
-
-  There are two basic types: @ref softfloat and @ref softdouble.
-  These types are binary compatible with float and double types respectively
-  and support conversions to/from them.
-  Other types from original SoftFloat library like fp16 or fp128 were thrown
- away as well as quiet/signaling NaN support, on-the-fly rounding mode switch
-  and exception flags (though exceptions can be implemented in the future).
-
-  ### Operations
-
-  Both types support the following:
-  - Construction from signed and unsigned 32-bit and 64 integers,
-  float/double or raw binary representation
-  - Conversions between each other, to float or double and to int
-  using @ref cvRound, @ref cvTrunc, @ref cvFloor, @ref cvCeil or a bunch of
-  saturate_cast functions
-  - Add, subtract, multiply, divide, remainder, square root, FMA with absolute
- precision
-  - Comparison operations
-  - Explicit sign, exponent and significand manipulation through get/set
- methods, number state indicators (isInf, isNan, isSubnormal)
-  - Type-specific constants like eps, minimum/maximum value, best pi
- approximation, etc.
-  - min(), max(), abs(), exp(), log() and pow() functions
-
-*/
-//! @{
-
-struct softfloat;
-struct softdouble;
-
-struct CV_EXPORTS softfloat {
-public:
-  /** @brief Default constructor */
-  softfloat() { v = 0; }
-  /** @brief Copy constructor */
-  softfloat(const softfloat &c) { v = c.v; }
-  /** @brief Assign constructor */
-  softfloat &operator=(const softfloat &c) {
-    if (&c != this)
-      v = c.v;
-    return *this;
-  }
-  /** @brief Construct from raw
-
-  Builds new value from raw binary representation
-  */
-  static const softfloat fromRaw(const uint32_t a) {
-    softfloat x;
-    x.v = a;
-    return x;
-  }
-
-  /** @brief Construct from integer */
-  explicit softfloat(const uint32_t);
-  explicit softfloat(const uint64_t);
-  explicit softfloat(const int32_t);
-  explicit softfloat(const int64_t);
-
-#ifdef CV_INT32_T_IS_LONG_INT
-  // for platforms with int32_t = long int
-  explicit softfloat(const int a) {
-    *this = softfloat(static_cast<int32_t>(a));
-  }
-#endif
-
-  /** @brief Construct from float */
-  explicit softfloat(const float a) {
-    Cv32suf s;
-    s.f = a;
-    v = s.u;
-  }
-
-  /** @brief Type casts  */
-  operator softdouble() const;
-  operator float() const {
-    Cv32suf s;
-    s.u = v;
-    return s.f;
-  }
-
-  /** @brief Basic arithmetics */
-  softfloat operator+(const softfloat &) const;
-  softfloat operator-(const softfloat &) const;
-  softfloat operator*(const softfloat &) const;
-  softfloat operator/(const softfloat &) const;
-  softfloat operator-() const {
-    softfloat x;
-    x.v = v ^ (1U << 31);
-    return x;
-  }
-
-  /** @brief Remainder operator
-
-  A quote from original SoftFloat manual:
-
-  > The IEEE Standard remainder operation computes the value
-  > a - n * b, where n is the integer closest to a / b.
-  > If a / b is exactly halfway between two integers, n is the even integer
-  > closest to a / b. The IEEE Standard’s remainder operation is always exact
-  and so requires no rounding. > Depending on the relative magnitudes of the
-  operands, the remainder functions > can take considerably longer to execute
-  than the other SoftFloat functions. > This is an inherent characteristic of
-  the remainder operation itself and is not a flaw > in the SoftFloat
-  implementation.
-  */
-  softfloat operator%(const softfloat &) const;
-
-  softfloat &operator+=(const softfloat &a) {
-    *this = *this + a;
-    return *this;
-  }
-  softfloat &operator-=(const softfloat &a) {
-    *this = *this - a;
-    return *this;
-  }
-  softfloat &operator*=(const softfloat &a) {
-    *this = *this * a;
-    return *this;
-  }
-  softfloat &operator/=(const softfloat &a) {
-    *this = *this / a;
-    return *this;
-  }
-  softfloat &operator%=(const softfloat &a) {
-    *this = *this % a;
-    return *this;
-  }
-
-  /** @brief Comparison operations
-
-   - Any operation with NaN produces false
-     + The only exception is when x is NaN: x != y for any y.
-   - Positive and negative zeros are equal
-  */
-  bool operator==(const softfloat &) const;
-  bool operator!=(const softfloat &) const;
-  bool operator>(const softfloat &) const;
-  bool operator>=(const softfloat &) const;
-  bool operator<(const softfloat &) const;
-  bool operator<=(const softfloat &) const;
-
-  /** @brief NaN state indicator */
-  inline bool isNaN() const { return (v & 0x7fffffff) > 0x7f800000; }
-  /** @brief Inf state indicator */
-  inline bool isInf() const { return (v & 0x7fffffff) == 0x7f800000; }
-  /** @brief Subnormal number indicator */
-  inline bool isSubnormal() const { return ((v >> 23) & 0xFF) == 0; }
-
-  /** @brief Get sign bit */
-  inline bool getSign() const { return (v >> 31) != 0; }
-  /** @brief Construct a copy with new sign bit */
-  inline softfloat setSign(bool sign) const {
-    softfloat x;
-    x.v = (v & ((1U << 31) - 1)) | ((uint32_t)sign << 31);
-    return x;
-  }
-  /** @brief Get 0-based exponent */
-  inline int getExp() const { return ((v >> 23) & 0xFF) - 127; }
-  /** @brief Construct a copy with new 0-based exponent */
-  inline softfloat setExp(int e) const {
-    softfloat x;
-    x.v = (v & 0x807fffff) | (((e + 127) & 0xFF) << 23);
-    return x;
-  }
-
-  /** @brief Get a fraction part
-
-  Returns a number 1 <= x < 2 with the same significand
-  */
-  inline softfloat getFrac() const {
-    uint_fast32_t vv = (v & 0x007fffff) | (127 << 23);
-    return softfloat::fromRaw(vv);
-  }
-  /** @brief Construct a copy with provided significand
-
-  Constructs a copy of a number with significand taken from parameter
-  */
-  inline softfloat setFrac(const softfloat &s) const {
-    softfloat x;
-    x.v = (v & 0xff800000) | (s.v & 0x007fffff);
-    return x;
-  }
-
-  /** @brief Zero constant */
-  static softfloat zero() { return softfloat::fromRaw(0); }
-  /** @brief Positive infinity constant */
-  static softfloat inf() { return softfloat::fromRaw(0xFF << 23); }
-  /** @brief Default NaN constant */
-  static softfloat nan() { return softfloat::fromRaw(0x7fffffff); }
-  /** @brief One constant */
-  static softfloat one() { return softfloat::fromRaw(127 << 23); }
-  /** @brief Smallest normalized value */
-  static softfloat min() { return softfloat::fromRaw(0x01 << 23); }
-  /** @brief Difference between 1 and next representable value */
-  static softfloat eps() { return softfloat::fromRaw((127 - 23) << 23); }
-  /** @brief Biggest finite value */
-  static softfloat max() { return softfloat::fromRaw((0xFF << 23) - 1); }
-  /** @brief Correct pi approximation */
-  static softfloat pi() { return softfloat::fromRaw(0x40490fdb); }
-
-  uint32_t v;
-};
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-
-struct CV_EXPORTS softdouble {
-public:
-  /** @brief Default constructor */
-  softdouble() : v(0) {}
-  /** @brief Copy constructor */
-  softdouble(const softdouble &c) { v = c.v; }
-  /** @brief Assign constructor */
-  softdouble &operator=(const softdouble &c) {
-    if (&c != this)
-      v = c.v;
-    return *this;
-  }
-  /** @brief Construct from raw
-
-  Builds new value from raw binary representation
-  */
-  static softdouble fromRaw(const uint64_t a) {
-    softdouble x;
-    x.v = a;
-    return x;
-  }
-
-  /** @brief Construct from integer */
-  explicit softdouble(const uint32_t);
-  explicit softdouble(const uint64_t);
-  explicit softdouble(const int32_t);
-  explicit softdouble(const int64_t);
-
-#ifdef CV_INT32_T_IS_LONG_INT
-  // for platforms with int32_t = long int
-  explicit softdouble(const int a) {
-    *this = softdouble(static_cast<int32_t>(a));
-  }
-#endif
-
-  /** @brief Construct from double */
-  explicit softdouble(const double a) {
-    Cv64suf s;
-    s.f = a;
-    v = s.u;
-  }
-
-  /** @brief Type casts  */
-  operator softfloat() const;
-  operator double() const {
-    Cv64suf s;
-    s.u = v;
-    return s.f;
-  }
-
-  /** @brief Basic arithmetics */
-  softdouble operator+(const softdouble &) const;
-  softdouble operator-(const softdouble &) const;
-  softdouble operator*(const softdouble &) const;
-  softdouble operator/(const softdouble &) const;
-  softdouble operator-() const {
-    softdouble x;
-    x.v = v ^ (1ULL << 63);
-    return x;
-  }
-
-  /** @brief Remainder operator
-
-  A quote from original SoftFloat manual:
-
-  > The IEEE Standard remainder operation computes the value
-  > a - n * b, where n is the integer closest to a / b.
-  > If a / b is exactly halfway between two integers, n is the even integer
-  > closest to a / b. The IEEE Standard’s remainder operation is always exact
-  and so requires no rounding. > Depending on the relative magnitudes of the
-  operands, the remainder functions > can take considerably longer to execute
-  than the other SoftFloat functions. > This is an inherent characteristic of
-  the remainder operation itself and is not a flaw > in the SoftFloat
-  implementation.
-  */
-  softdouble operator%(const softdouble &) const;
-
-  softdouble &operator+=(const softdouble &a) {
-    *this = *this + a;
-    return *this;
-  }
-  softdouble &operator-=(const softdouble &a) {
-    *this = *this - a;
-    return *this;
-  }
-  softdouble &operator*=(const softdouble &a) {
-    *this = *this * a;
-    return *this;
-  }
-  softdouble &operator/=(const softdouble &a) {
-    *this = *this / a;
-    return *this;
-  }
-  softdouble &operator%=(const softdouble &a) {
-    *this = *this % a;
-    return *this;
-  }
-
-  /** @brief Comparison operations
-
-   - Any operation with NaN produces false
-     + The only exception is when x is NaN: x != y for any y.
-   - Positive and negative zeros are equal
-  */
-  bool operator==(const softdouble &) const;
-  bool operator!=(const softdouble &) const;
-  bool operator>(const softdouble &) const;
-  bool operator>=(const softdouble &) const;
-  bool operator<(const softdouble &) const;
-  bool operator<=(const softdouble &) const;
-
-  /** @brief NaN state indicator */
-  inline bool isNaN() const {
-    return (v & 0x7fffffffffffffff) > 0x7ff0000000000000;
-  }
-  /** @brief Inf state indicator */
-  inline bool isInf() const {
-    return (v & 0x7fffffffffffffff) == 0x7ff0000000000000;
-  }
-  /** @brief Subnormal number indicator */
-  inline bool isSubnormal() const { return ((v >> 52) & 0x7FF) == 0; }
-
-  /** @brief Get sign bit */
-  inline bool getSign() const { return (v >> 63) != 0; }
-  /** @brief Construct a copy with new sign bit */
-  softdouble setSign(bool sign) const {
-    softdouble x;
-    x.v = (v & ((1ULL << 63) - 1)) | ((uint_fast64_t)(sign) << 63);
-    return x;
-  }
-  /** @brief Get 0-based exponent */
-  inline int getExp() const { return ((v >> 52) & 0x7FF) - 1023; }
-  /** @brief Construct a copy with new 0-based exponent */
-  inline softdouble setExp(int e) const {
-    softdouble x;
-    x.v =
-        (v & 0x800FFFFFFFFFFFFF) | ((uint_fast64_t)((e + 1023) & 0x7FF) << 52);
-    return x;
-  }
-
-  /** @brief Get a fraction part
-
-  Returns a number 1 <= x < 2 with the same significand
-  */
-  inline softdouble getFrac() const {
-    uint_fast64_t vv = (v & 0x000FFFFFFFFFFFFF) | ((uint_fast64_t)(1023) << 52);
-    return softdouble::fromRaw(vv);
-  }
-  /** @brief Construct a copy with provided significand
-
-  Constructs a copy of a number with significand taken from parameter
-  */
-  inline softdouble setFrac(const softdouble &s) const {
-    softdouble x;
-    x.v = (v & 0xFFF0000000000000) | (s.v & 0x000FFFFFFFFFFFFF);
-    return x;
-  }
-
-  /** @brief Zero constant */
-  static softdouble zero() { return softdouble::fromRaw(0); }
-  /** @brief Positive infinity constant */
-  static softdouble inf() {
-    return softdouble::fromRaw((uint_fast64_t)(0x7FF) << 52);
-  }
-  /** @brief Default NaN constant */
-  static softdouble nan() {
-    return softdouble::fromRaw(CV_BIG_INT(0x7FFFFFFFFFFFFFFF));
-  }
-  /** @brief One constant */
-  static softdouble one() {
-    return softdouble::fromRaw((uint_fast64_t)(1023) << 52);
-  }
-  /** @brief Smallest normalized value */
-  static softdouble min() {
-    return softdouble::fromRaw((uint_fast64_t)(0x01) << 52);
-  }
-  /** @brief Difference between 1 and next representable value */
-  static softdouble eps() {
-    return softdouble::fromRaw((uint_fast64_t)(1023 - 52) << 52);
-  }
-  /** @brief Biggest finite value */
-  static softdouble max() {
-    return softdouble::fromRaw(((uint_fast64_t)(0x7FF) << 52) - 1);
-  }
-  /** @brief Correct pi approximation */
-  static softdouble pi() {
-    return softdouble::fromRaw(CV_BIG_INT(0x400921FB54442D18));
-  }
-
-  uint64_t v;
-};
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-
-/** @brief Fused Multiplication and Addition
-
-Computes (a*b)+c with single rounding
-*/
-CV_EXPORTS softfloat mulAdd(const softfloat &a, const softfloat &b,
-                            const softfloat &c);
-CV_EXPORTS softdouble mulAdd(const softdouble &a, const softdouble &b,
-                             const softdouble &c);
-
-/** @brief Square root */
-CV_EXPORTS softfloat sqrt(const softfloat &a);
-CV_EXPORTS softdouble sqrt(const softdouble &a);
-} // namespace cv
-
-/*----------------------------------------------------------------------------
-| Ported from OpenCV and added for usability
-*----------------------------------------------------------------------------*/
-
-/** @brief Truncates number to integer with minimum magnitude */
-CV_EXPORTS int cvTrunc(const cv::softfloat &a);
-CV_EXPORTS int cvTrunc(const cv::softdouble &a);
-
-/** @brief Rounds a number to nearest even integer */
-CV_EXPORTS int cvRound(const cv::softfloat &a);
-CV_EXPORTS int cvRound(const cv::softdouble &a);
-
-/** @brief Rounds a number to nearest even long long integer */
-CV_EXPORTS int64_t cvRound64(const cv::softdouble &a);
-
-/** @brief Rounds a number down to integer */
-CV_EXPORTS int cvFloor(const cv::softfloat &a);
-CV_EXPORTS int cvFloor(const cv::softdouble &a);
-
-/** @brief Rounds number up to integer */
-CV_EXPORTS int cvCeil(const cv::softfloat &a);
-CV_EXPORTS int cvCeil(const cv::softdouble &a);
-
-namespace cv {
-/** @brief Saturate casts */
-template <typename _Tp> static inline _Tp saturate_cast(softfloat a) {
-  return _Tp(a);
-}
-template <typename _Tp> static inline _Tp saturate_cast(softdouble a) {
-  return _Tp(a);
-}
-
-template <> inline uchar saturate_cast<uchar>(softfloat a) {
-  return (uchar)std::max(std::min(cvRound(a), (int)UCHAR_MAX), 0);
-}
-template <> inline uchar saturate_cast<uchar>(softdouble a) {
-  return (uchar)std::max(std::min(cvRound(a), (int)UCHAR_MAX), 0);
-}
-
-template <> inline schar saturate_cast<schar>(softfloat a) {
-  return (schar)std::min(std::max(cvRound(a), (int)SCHAR_MIN), (int)SCHAR_MAX);
-}
-template <> inline schar saturate_cast<schar>(softdouble a) {
-  return (schar)std::min(std::max(cvRound(a), (int)SCHAR_MIN), (int)SCHAR_MAX);
-}
-
-template <> inline ushort saturate_cast<ushort>(softfloat a) {
-  return (ushort)std::max(std::min(cvRound(a), (int)USHRT_MAX), 0);
-}
-template <> inline ushort saturate_cast<ushort>(softdouble a) {
-  return (ushort)std::max(std::min(cvRound(a), (int)USHRT_MAX), 0);
-}
-
-template <> inline short saturate_cast<short>(softfloat a) {
-  return (short)std::min(std::max(cvRound(a), (int)SHRT_MIN), (int)SHRT_MAX);
-}
-template <> inline short saturate_cast<short>(softdouble a) {
-  return (short)std::min(std::max(cvRound(a), (int)SHRT_MIN), (int)SHRT_MAX);
-}
-
-template <> inline int saturate_cast<int>(softfloat a) { return cvRound(a); }
-template <> inline int saturate_cast<int>(softdouble a) { return cvRound(a); }
-
-template <> inline int64_t saturate_cast<int64_t>(softfloat a) {
-  return cvRound(a);
-}
-template <> inline int64_t saturate_cast<int64_t>(softdouble a) {
-  return cvRound64(a);
-}
-
-/** @brief Saturate cast to unsigned integer and unsigned long long integer
-We intentionally do not clip negative numbers, to make -1 become 0xffffffff etc.
-*/
-template <> inline unsigned saturate_cast<unsigned>(softfloat a) {
-  return cvRound(a);
-}
-template <> inline unsigned saturate_cast<unsigned>(softdouble a) {
-  return cvRound(a);
-}
-
-template <> inline uint64_t saturate_cast<uint64_t>(softfloat a) {
-  return cvRound(a);
-}
-template <> inline uint64_t saturate_cast<uint64_t>(softdouble a) {
-  return cvRound64(a);
-}
-
-/** @brief Min and Max functions */
-inline softfloat min(const softfloat &a, const softfloat &b) {
-  return (a > b) ? b : a;
-}
-inline softdouble min(const softdouble &a, const softdouble &b) {
-  return (a > b) ? b : a;
-}
-
-inline softfloat max(const softfloat &a, const softfloat &b) {
-  return (a > b) ? a : b;
-}
-inline softdouble max(const softdouble &a, const softdouble &b) {
-  return (a > b) ? a : b;
-}
-
-/** @brief Absolute value */
-inline softfloat abs(softfloat a) {
-  softfloat x;
-  x.v = a.v & ((1U << 31) - 1);
-  return x;
-}
-inline softdouble abs(softdouble a) {
-  softdouble x;
-  x.v = a.v & ((1ULL << 63) - 1);
-  return x;
-}
-
-/** @brief Exponent
-
-Special cases:
-- exp(NaN) is NaN
-- exp(-Inf) == 0
-- exp(+Inf) == +Inf
-*/
-CV_EXPORTS softfloat exp(const softfloat &a);
-CV_EXPORTS softdouble exp(const softdouble &a);
-
-/** @brief Natural logarithm
-
-Special cases:
-- log(NaN), log(x < 0) are NaN
-- log(0) == -Inf
-*/
-CV_EXPORTS softfloat log(const softfloat &a);
-CV_EXPORTS softdouble log(const softdouble &a);
-
-/** @brief Raising to the power
-
-Special cases:
-- x**NaN is NaN for any x
-- ( |x| == 1 )**Inf is NaN
-- ( |x|  > 1 )**+Inf or ( |x| < 1 )**-Inf is +Inf
-- ( |x|  > 1 )**-Inf or ( |x| < 1 )**+Inf is 0
-- x ** 0 == 1 for any x
-- x ** 1 == 1 for any x
-- NaN ** y is NaN for any other y
-- Inf**(y < 0) == 0
-- Inf ** y is +Inf for any other y
-- (x < 0)**y is NaN for any other y if x can't be correctly rounded to integer
-- 0 ** 0 == 1
-- 0 ** (y < 0) is +Inf
-- 0 ** (y > 0) is 0
-*/
-CV_EXPORTS softfloat pow(const softfloat &a, const softfloat &b);
-CV_EXPORTS softdouble pow(const softdouble &a, const softdouble &b);
-
-/** @brief Cube root
-
-Special cases:
-- cbrt(NaN) is NaN
-- cbrt(+/-Inf) is +/-Inf
-*/
-CV_EXPORTS softfloat cbrt(const softfloat &a);
-
-/** @brief Sine
-
-Special cases:
-- sin(Inf) or sin(NaN) is NaN
-- sin(x) == x when sin(x) is close to zero
-*/
-CV_EXPORTS softdouble sin(const softdouble &a);
-
-/** @brief Cosine
- *
-Special cases:
-- cos(Inf) or cos(NaN) is NaN
-- cos(x) == +/- 1 when cos(x) is close to +/- 1
-*/
-CV_EXPORTS softdouble cos(const softdouble &a);
-
-//! @} core_utils_softfloat
-
-} // namespace cv
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/sse_utils.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/sse_utils.hpp
deleted file mode 100644
index 0809510ccf..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/sse_utils.hpp
+++ /dev/null
@@ -1,861 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2015, Itseez Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_CORE_SSE_UTILS_HPP
-#define OPENCV_CORE_SSE_UTILS_HPP
-
-#ifndef __cplusplus
-#error sse_utils.hpp header must be compiled as C++
-#endif
-
-#include "opencv2/core/cvdef.h"
-
-//! @addtogroup core_utils_sse
-//! @{
-
-#if CV_SSE2
-
-inline void _mm_deinterleave_epi8(__m128i &v_r0, __m128i &v_r1, __m128i &v_g0,
-                                  __m128i &v_g1) {
-  __m128i layer1_chunk0 = _mm_unpacklo_epi8(v_r0, v_g0);
-  __m128i layer1_chunk1 = _mm_unpackhi_epi8(v_r0, v_g0);
-  __m128i layer1_chunk2 = _mm_unpacklo_epi8(v_r1, v_g1);
-  __m128i layer1_chunk3 = _mm_unpackhi_epi8(v_r1, v_g1);
-
-  __m128i layer2_chunk0 = _mm_unpacklo_epi8(layer1_chunk0, layer1_chunk2);
-  __m128i layer2_chunk1 = _mm_unpackhi_epi8(layer1_chunk0, layer1_chunk2);
-  __m128i layer2_chunk2 = _mm_unpacklo_epi8(layer1_chunk1, layer1_chunk3);
-  __m128i layer2_chunk3 = _mm_unpackhi_epi8(layer1_chunk1, layer1_chunk3);
-
-  __m128i layer3_chunk0 = _mm_unpacklo_epi8(layer2_chunk0, layer2_chunk2);
-  __m128i layer3_chunk1 = _mm_unpackhi_epi8(layer2_chunk0, layer2_chunk2);
-  __m128i layer3_chunk2 = _mm_unpacklo_epi8(layer2_chunk1, layer2_chunk3);
-  __m128i layer3_chunk3 = _mm_unpackhi_epi8(layer2_chunk1, layer2_chunk3);
-
-  __m128i layer4_chunk0 = _mm_unpacklo_epi8(layer3_chunk0, layer3_chunk2);
-  __m128i layer4_chunk1 = _mm_unpackhi_epi8(layer3_chunk0, layer3_chunk2);
-  __m128i layer4_chunk2 = _mm_unpacklo_epi8(layer3_chunk1, layer3_chunk3);
-  __m128i layer4_chunk3 = _mm_unpackhi_epi8(layer3_chunk1, layer3_chunk3);
-
-  v_r0 = _mm_unpacklo_epi8(layer4_chunk0, layer4_chunk2);
-  v_r1 = _mm_unpackhi_epi8(layer4_chunk0, layer4_chunk2);
-  v_g0 = _mm_unpacklo_epi8(layer4_chunk1, layer4_chunk3);
-  v_g1 = _mm_unpackhi_epi8(layer4_chunk1, layer4_chunk3);
-}
-
-inline void _mm_deinterleave_epi8(__m128i &v_r0, __m128i &v_r1, __m128i &v_g0,
-                                  __m128i &v_g1, __m128i &v_b0, __m128i &v_b1) {
-  __m128i layer1_chunk0 = _mm_unpacklo_epi8(v_r0, v_g1);
-  __m128i layer1_chunk1 = _mm_unpackhi_epi8(v_r0, v_g1);
-  __m128i layer1_chunk2 = _mm_unpacklo_epi8(v_r1, v_b0);
-  __m128i layer1_chunk3 = _mm_unpackhi_epi8(v_r1, v_b0);
-  __m128i layer1_chunk4 = _mm_unpacklo_epi8(v_g0, v_b1);
-  __m128i layer1_chunk5 = _mm_unpackhi_epi8(v_g0, v_b1);
-
-  __m128i layer2_chunk0 = _mm_unpacklo_epi8(layer1_chunk0, layer1_chunk3);
-  __m128i layer2_chunk1 = _mm_unpackhi_epi8(layer1_chunk0, layer1_chunk3);
-  __m128i layer2_chunk2 = _mm_unpacklo_epi8(layer1_chunk1, layer1_chunk4);
-  __m128i layer2_chunk3 = _mm_unpackhi_epi8(layer1_chunk1, layer1_chunk4);
-  __m128i layer2_chunk4 = _mm_unpacklo_epi8(layer1_chunk2, layer1_chunk5);
-  __m128i layer2_chunk5 = _mm_unpackhi_epi8(layer1_chunk2, layer1_chunk5);
-
-  __m128i layer3_chunk0 = _mm_unpacklo_epi8(layer2_chunk0, layer2_chunk3);
-  __m128i layer3_chunk1 = _mm_unpackhi_epi8(layer2_chunk0, layer2_chunk3);
-  __m128i layer3_chunk2 = _mm_unpacklo_epi8(layer2_chunk1, layer2_chunk4);
-  __m128i layer3_chunk3 = _mm_unpackhi_epi8(layer2_chunk1, layer2_chunk4);
-  __m128i layer3_chunk4 = _mm_unpacklo_epi8(layer2_chunk2, layer2_chunk5);
-  __m128i layer3_chunk5 = _mm_unpackhi_epi8(layer2_chunk2, layer2_chunk5);
-
-  __m128i layer4_chunk0 = _mm_unpacklo_epi8(layer3_chunk0, layer3_chunk3);
-  __m128i layer4_chunk1 = _mm_unpackhi_epi8(layer3_chunk0, layer3_chunk3);
-  __m128i layer4_chunk2 = _mm_unpacklo_epi8(layer3_chunk1, layer3_chunk4);
-  __m128i layer4_chunk3 = _mm_unpackhi_epi8(layer3_chunk1, layer3_chunk4);
-  __m128i layer4_chunk4 = _mm_unpacklo_epi8(layer3_chunk2, layer3_chunk5);
-  __m128i layer4_chunk5 = _mm_unpackhi_epi8(layer3_chunk2, layer3_chunk5);
-
-  v_r0 = _mm_unpacklo_epi8(layer4_chunk0, layer4_chunk3);
-  v_r1 = _mm_unpackhi_epi8(layer4_chunk0, layer4_chunk3);
-  v_g0 = _mm_unpacklo_epi8(layer4_chunk1, layer4_chunk4);
-  v_g1 = _mm_unpackhi_epi8(layer4_chunk1, layer4_chunk4);
-  v_b0 = _mm_unpacklo_epi8(layer4_chunk2, layer4_chunk5);
-  v_b1 = _mm_unpackhi_epi8(layer4_chunk2, layer4_chunk5);
-}
-
-inline void _mm_deinterleave_epi8(__m128i &v_r0, __m128i &v_r1, __m128i &v_g0,
-                                  __m128i &v_g1, __m128i &v_b0, __m128i &v_b1,
-                                  __m128i &v_a0, __m128i &v_a1) {
-  __m128i layer1_chunk0 = _mm_unpacklo_epi8(v_r0, v_b0);
-  __m128i layer1_chunk1 = _mm_unpackhi_epi8(v_r0, v_b0);
-  __m128i layer1_chunk2 = _mm_unpacklo_epi8(v_r1, v_b1);
-  __m128i layer1_chunk3 = _mm_unpackhi_epi8(v_r1, v_b1);
-  __m128i layer1_chunk4 = _mm_unpacklo_epi8(v_g0, v_a0);
-  __m128i layer1_chunk5 = _mm_unpackhi_epi8(v_g0, v_a0);
-  __m128i layer1_chunk6 = _mm_unpacklo_epi8(v_g1, v_a1);
-  __m128i layer1_chunk7 = _mm_unpackhi_epi8(v_g1, v_a1);
-
-  __m128i layer2_chunk0 = _mm_unpacklo_epi8(layer1_chunk0, layer1_chunk4);
-  __m128i layer2_chunk1 = _mm_unpackhi_epi8(layer1_chunk0, layer1_chunk4);
-  __m128i layer2_chunk2 = _mm_unpacklo_epi8(layer1_chunk1, layer1_chunk5);
-  __m128i layer2_chunk3 = _mm_unpackhi_epi8(layer1_chunk1, layer1_chunk5);
-  __m128i layer2_chunk4 = _mm_unpacklo_epi8(layer1_chunk2, layer1_chunk6);
-  __m128i layer2_chunk5 = _mm_unpackhi_epi8(layer1_chunk2, layer1_chunk6);
-  __m128i layer2_chunk6 = _mm_unpacklo_epi8(layer1_chunk3, layer1_chunk7);
-  __m128i layer2_chunk7 = _mm_unpackhi_epi8(layer1_chunk3, layer1_chunk7);
-
-  __m128i layer3_chunk0 = _mm_unpacklo_epi8(layer2_chunk0, layer2_chunk4);
-  __m128i layer3_chunk1 = _mm_unpackhi_epi8(layer2_chunk0, layer2_chunk4);
-  __m128i layer3_chunk2 = _mm_unpacklo_epi8(layer2_chunk1, layer2_chunk5);
-  __m128i layer3_chunk3 = _mm_unpackhi_epi8(layer2_chunk1, layer2_chunk5);
-  __m128i layer3_chunk4 = _mm_unpacklo_epi8(layer2_chunk2, layer2_chunk6);
-  __m128i layer3_chunk5 = _mm_unpackhi_epi8(layer2_chunk2, layer2_chunk6);
-  __m128i layer3_chunk6 = _mm_unpacklo_epi8(layer2_chunk3, layer2_chunk7);
-  __m128i layer3_chunk7 = _mm_unpackhi_epi8(layer2_chunk3, layer2_chunk7);
-
-  __m128i layer4_chunk0 = _mm_unpacklo_epi8(layer3_chunk0, layer3_chunk4);
-  __m128i layer4_chunk1 = _mm_unpackhi_epi8(layer3_chunk0, layer3_chunk4);
-  __m128i layer4_chunk2 = _mm_unpacklo_epi8(layer3_chunk1, layer3_chunk5);
-  __m128i layer4_chunk3 = _mm_unpackhi_epi8(layer3_chunk1, layer3_chunk5);
-  __m128i layer4_chunk4 = _mm_unpacklo_epi8(layer3_chunk2, layer3_chunk6);
-  __m128i layer4_chunk5 = _mm_unpackhi_epi8(layer3_chunk2, layer3_chunk6);
-  __m128i layer4_chunk6 = _mm_unpacklo_epi8(layer3_chunk3, layer3_chunk7);
-  __m128i layer4_chunk7 = _mm_unpackhi_epi8(layer3_chunk3, layer3_chunk7);
-
-  v_r0 = _mm_unpacklo_epi8(layer4_chunk0, layer4_chunk4);
-  v_r1 = _mm_unpackhi_epi8(layer4_chunk0, layer4_chunk4);
-  v_g0 = _mm_unpacklo_epi8(layer4_chunk1, layer4_chunk5);
-  v_g1 = _mm_unpackhi_epi8(layer4_chunk1, layer4_chunk5);
-  v_b0 = _mm_unpacklo_epi8(layer4_chunk2, layer4_chunk6);
-  v_b1 = _mm_unpackhi_epi8(layer4_chunk2, layer4_chunk6);
-  v_a0 = _mm_unpacklo_epi8(layer4_chunk3, layer4_chunk7);
-  v_a1 = _mm_unpackhi_epi8(layer4_chunk3, layer4_chunk7);
-}
-
-inline void _mm_interleave_epi8(__m128i &v_r0, __m128i &v_r1, __m128i &v_g0,
-                                __m128i &v_g1) {
-  __m128i v_mask = _mm_set1_epi16(0x00ff);
-
-  __m128i layer4_chunk0 = _mm_packus_epi16(_mm_and_si128(v_r0, v_mask),
-                                           _mm_and_si128(v_r1, v_mask));
-  __m128i layer4_chunk2 =
-      _mm_packus_epi16(_mm_srli_epi16(v_r0, 8), _mm_srli_epi16(v_r1, 8));
-  __m128i layer4_chunk1 = _mm_packus_epi16(_mm_and_si128(v_g0, v_mask),
-                                           _mm_and_si128(v_g1, v_mask));
-  __m128i layer4_chunk3 =
-      _mm_packus_epi16(_mm_srli_epi16(v_g0, 8), _mm_srli_epi16(v_g1, 8));
-
-  __m128i layer3_chunk0 =
-      _mm_packus_epi16(_mm_and_si128(layer4_chunk0, v_mask),
-                       _mm_and_si128(layer4_chunk1, v_mask));
-  __m128i layer3_chunk2 = _mm_packus_epi16(_mm_srli_epi16(layer4_chunk0, 8),
-                                           _mm_srli_epi16(layer4_chunk1, 8));
-  __m128i layer3_chunk1 =
-      _mm_packus_epi16(_mm_and_si128(layer4_chunk2, v_mask),
-                       _mm_and_si128(layer4_chunk3, v_mask));
-  __m128i layer3_chunk3 = _mm_packus_epi16(_mm_srli_epi16(layer4_chunk2, 8),
-                                           _mm_srli_epi16(layer4_chunk3, 8));
-
-  __m128i layer2_chunk0 =
-      _mm_packus_epi16(_mm_and_si128(layer3_chunk0, v_mask),
-                       _mm_and_si128(layer3_chunk1, v_mask));
-  __m128i layer2_chunk2 = _mm_packus_epi16(_mm_srli_epi16(layer3_chunk0, 8),
-                                           _mm_srli_epi16(layer3_chunk1, 8));
-  __m128i layer2_chunk1 =
-      _mm_packus_epi16(_mm_and_si128(layer3_chunk2, v_mask),
-                       _mm_and_si128(layer3_chunk3, v_mask));
-  __m128i layer2_chunk3 = _mm_packus_epi16(_mm_srli_epi16(layer3_chunk2, 8),
-                                           _mm_srli_epi16(layer3_chunk3, 8));
-
-  __m128i layer1_chunk0 =
-      _mm_packus_epi16(_mm_and_si128(layer2_chunk0, v_mask),
-                       _mm_and_si128(layer2_chunk1, v_mask));
-  __m128i layer1_chunk2 = _mm_packus_epi16(_mm_srli_epi16(layer2_chunk0, 8),
-                                           _mm_srli_epi16(layer2_chunk1, 8));
-  __m128i layer1_chunk1 =
-      _mm_packus_epi16(_mm_and_si128(layer2_chunk2, v_mask),
-                       _mm_and_si128(layer2_chunk3, v_mask));
-  __m128i layer1_chunk3 = _mm_packus_epi16(_mm_srli_epi16(layer2_chunk2, 8),
-                                           _mm_srli_epi16(layer2_chunk3, 8));
-
-  v_r0 = _mm_packus_epi16(_mm_and_si128(layer1_chunk0, v_mask),
-                          _mm_and_si128(layer1_chunk1, v_mask));
-  v_g0 = _mm_packus_epi16(_mm_srli_epi16(layer1_chunk0, 8),
-                          _mm_srli_epi16(layer1_chunk1, 8));
-  v_r1 = _mm_packus_epi16(_mm_and_si128(layer1_chunk2, v_mask),
-                          _mm_and_si128(layer1_chunk3, v_mask));
-  v_g1 = _mm_packus_epi16(_mm_srli_epi16(layer1_chunk2, 8),
-                          _mm_srli_epi16(layer1_chunk3, 8));
-}
-
-inline void _mm_interleave_epi8(__m128i &v_r0, __m128i &v_r1, __m128i &v_g0,
-                                __m128i &v_g1, __m128i &v_b0, __m128i &v_b1) {
-  __m128i v_mask = _mm_set1_epi16(0x00ff);
-
-  __m128i layer4_chunk0 = _mm_packus_epi16(_mm_and_si128(v_r0, v_mask),
-                                           _mm_and_si128(v_r1, v_mask));
-  __m128i layer4_chunk3 =
-      _mm_packus_epi16(_mm_srli_epi16(v_r0, 8), _mm_srli_epi16(v_r1, 8));
-  __m128i layer4_chunk1 = _mm_packus_epi16(_mm_and_si128(v_g0, v_mask),
-                                           _mm_and_si128(v_g1, v_mask));
-  __m128i layer4_chunk4 =
-      _mm_packus_epi16(_mm_srli_epi16(v_g0, 8), _mm_srli_epi16(v_g1, 8));
-  __m128i layer4_chunk2 = _mm_packus_epi16(_mm_and_si128(v_b0, v_mask),
-                                           _mm_and_si128(v_b1, v_mask));
-  __m128i layer4_chunk5 =
-      _mm_packus_epi16(_mm_srli_epi16(v_b0, 8), _mm_srli_epi16(v_b1, 8));
-
-  __m128i layer3_chunk0 =
-      _mm_packus_epi16(_mm_and_si128(layer4_chunk0, v_mask),
-                       _mm_and_si128(layer4_chunk1, v_mask));
-  __m128i layer3_chunk3 = _mm_packus_epi16(_mm_srli_epi16(layer4_chunk0, 8),
-                                           _mm_srli_epi16(layer4_chunk1, 8));
-  __m128i layer3_chunk1 =
-      _mm_packus_epi16(_mm_and_si128(layer4_chunk2, v_mask),
-                       _mm_and_si128(layer4_chunk3, v_mask));
-  __m128i layer3_chunk4 = _mm_packus_epi16(_mm_srli_epi16(layer4_chunk2, 8),
-                                           _mm_srli_epi16(layer4_chunk3, 8));
-  __m128i layer3_chunk2 =
-      _mm_packus_epi16(_mm_and_si128(layer4_chunk4, v_mask),
-                       _mm_and_si128(layer4_chunk5, v_mask));
-  __m128i layer3_chunk5 = _mm_packus_epi16(_mm_srli_epi16(layer4_chunk4, 8),
-                                           _mm_srli_epi16(layer4_chunk5, 8));
-
-  __m128i layer2_chunk0 =
-      _mm_packus_epi16(_mm_and_si128(layer3_chunk0, v_mask),
-                       _mm_and_si128(layer3_chunk1, v_mask));
-  __m128i layer2_chunk3 = _mm_packus_epi16(_mm_srli_epi16(layer3_chunk0, 8),
-                                           _mm_srli_epi16(layer3_chunk1, 8));
-  __m128i layer2_chunk1 =
-      _mm_packus_epi16(_mm_and_si128(layer3_chunk2, v_mask),
-                       _mm_and_si128(layer3_chunk3, v_mask));
-  __m128i layer2_chunk4 = _mm_packus_epi16(_mm_srli_epi16(layer3_chunk2, 8),
-                                           _mm_srli_epi16(layer3_chunk3, 8));
-  __m128i layer2_chunk2 =
-      _mm_packus_epi16(_mm_and_si128(layer3_chunk4, v_mask),
-                       _mm_and_si128(layer3_chunk5, v_mask));
-  __m128i layer2_chunk5 = _mm_packus_epi16(_mm_srli_epi16(layer3_chunk4, 8),
-                                           _mm_srli_epi16(layer3_chunk5, 8));
-
-  __m128i layer1_chunk0 =
-      _mm_packus_epi16(_mm_and_si128(layer2_chunk0, v_mask),
-                       _mm_and_si128(layer2_chunk1, v_mask));
-  __m128i layer1_chunk3 = _mm_packus_epi16(_mm_srli_epi16(layer2_chunk0, 8),
-                                           _mm_srli_epi16(layer2_chunk1, 8));
-  __m128i layer1_chunk1 =
-      _mm_packus_epi16(_mm_and_si128(layer2_chunk2, v_mask),
-                       _mm_and_si128(layer2_chunk3, v_mask));
-  __m128i layer1_chunk4 = _mm_packus_epi16(_mm_srli_epi16(layer2_chunk2, 8),
-                                           _mm_srli_epi16(layer2_chunk3, 8));
-  __m128i layer1_chunk2 =
-      _mm_packus_epi16(_mm_and_si128(layer2_chunk4, v_mask),
-                       _mm_and_si128(layer2_chunk5, v_mask));
-  __m128i layer1_chunk5 = _mm_packus_epi16(_mm_srli_epi16(layer2_chunk4, 8),
-                                           _mm_srli_epi16(layer2_chunk5, 8));
-
-  v_r0 = _mm_packus_epi16(_mm_and_si128(layer1_chunk0, v_mask),
-                          _mm_and_si128(layer1_chunk1, v_mask));
-  v_g1 = _mm_packus_epi16(_mm_srli_epi16(layer1_chunk0, 8),
-                          _mm_srli_epi16(layer1_chunk1, 8));
-  v_r1 = _mm_packus_epi16(_mm_and_si128(layer1_chunk2, v_mask),
-                          _mm_and_si128(layer1_chunk3, v_mask));
-  v_b0 = _mm_packus_epi16(_mm_srli_epi16(layer1_chunk2, 8),
-                          _mm_srli_epi16(layer1_chunk3, 8));
-  v_g0 = _mm_packus_epi16(_mm_and_si128(layer1_chunk4, v_mask),
-                          _mm_and_si128(layer1_chunk5, v_mask));
-  v_b1 = _mm_packus_epi16(_mm_srli_epi16(layer1_chunk4, 8),
-                          _mm_srli_epi16(layer1_chunk5, 8));
-}
-
-inline void _mm_interleave_epi8(__m128i &v_r0, __m128i &v_r1, __m128i &v_g0,
-                                __m128i &v_g1, __m128i &v_b0, __m128i &v_b1,
-                                __m128i &v_a0, __m128i &v_a1) {
-  __m128i v_mask = _mm_set1_epi16(0x00ff);
-
-  __m128i layer4_chunk0 = _mm_packus_epi16(_mm_and_si128(v_r0, v_mask),
-                                           _mm_and_si128(v_r1, v_mask));
-  __m128i layer4_chunk4 =
-      _mm_packus_epi16(_mm_srli_epi16(v_r0, 8), _mm_srli_epi16(v_r1, 8));
-  __m128i layer4_chunk1 = _mm_packus_epi16(_mm_and_si128(v_g0, v_mask),
-                                           _mm_and_si128(v_g1, v_mask));
-  __m128i layer4_chunk5 =
-      _mm_packus_epi16(_mm_srli_epi16(v_g0, 8), _mm_srli_epi16(v_g1, 8));
-  __m128i layer4_chunk2 = _mm_packus_epi16(_mm_and_si128(v_b0, v_mask),
-                                           _mm_and_si128(v_b1, v_mask));
-  __m128i layer4_chunk6 =
-      _mm_packus_epi16(_mm_srli_epi16(v_b0, 8), _mm_srli_epi16(v_b1, 8));
-  __m128i layer4_chunk3 = _mm_packus_epi16(_mm_and_si128(v_a0, v_mask),
-                                           _mm_and_si128(v_a1, v_mask));
-  __m128i layer4_chunk7 =
-      _mm_packus_epi16(_mm_srli_epi16(v_a0, 8), _mm_srli_epi16(v_a1, 8));
-
-  __m128i layer3_chunk0 =
-      _mm_packus_epi16(_mm_and_si128(layer4_chunk0, v_mask),
-                       _mm_and_si128(layer4_chunk1, v_mask));
-  __m128i layer3_chunk4 = _mm_packus_epi16(_mm_srli_epi16(layer4_chunk0, 8),
-                                           _mm_srli_epi16(layer4_chunk1, 8));
-  __m128i layer3_chunk1 =
-      _mm_packus_epi16(_mm_and_si128(layer4_chunk2, v_mask),
-                       _mm_and_si128(layer4_chunk3, v_mask));
-  __m128i layer3_chunk5 = _mm_packus_epi16(_mm_srli_epi16(layer4_chunk2, 8),
-                                           _mm_srli_epi16(layer4_chunk3, 8));
-  __m128i layer3_chunk2 =
-      _mm_packus_epi16(_mm_and_si128(layer4_chunk4, v_mask),
-                       _mm_and_si128(layer4_chunk5, v_mask));
-  __m128i layer3_chunk6 = _mm_packus_epi16(_mm_srli_epi16(layer4_chunk4, 8),
-                                           _mm_srli_epi16(layer4_chunk5, 8));
-  __m128i layer3_chunk3 =
-      _mm_packus_epi16(_mm_and_si128(layer4_chunk6, v_mask),
-                       _mm_and_si128(layer4_chunk7, v_mask));
-  __m128i layer3_chunk7 = _mm_packus_epi16(_mm_srli_epi16(layer4_chunk6, 8),
-                                           _mm_srli_epi16(layer4_chunk7, 8));
-
-  __m128i layer2_chunk0 =
-      _mm_packus_epi16(_mm_and_si128(layer3_chunk0, v_mask),
-                       _mm_and_si128(layer3_chunk1, v_mask));
-  __m128i layer2_chunk4 = _mm_packus_epi16(_mm_srli_epi16(layer3_chunk0, 8),
-                                           _mm_srli_epi16(layer3_chunk1, 8));
-  __m128i layer2_chunk1 =
-      _mm_packus_epi16(_mm_and_si128(layer3_chunk2, v_mask),
-                       _mm_and_si128(layer3_chunk3, v_mask));
-  __m128i layer2_chunk5 = _mm_packus_epi16(_mm_srli_epi16(layer3_chunk2, 8),
-                                           _mm_srli_epi16(layer3_chunk3, 8));
-  __m128i layer2_chunk2 =
-      _mm_packus_epi16(_mm_and_si128(layer3_chunk4, v_mask),
-                       _mm_and_si128(layer3_chunk5, v_mask));
-  __m128i layer2_chunk6 = _mm_packus_epi16(_mm_srli_epi16(layer3_chunk4, 8),
-                                           _mm_srli_epi16(layer3_chunk5, 8));
-  __m128i layer2_chunk3 =
-      _mm_packus_epi16(_mm_and_si128(layer3_chunk6, v_mask),
-                       _mm_and_si128(layer3_chunk7, v_mask));
-  __m128i layer2_chunk7 = _mm_packus_epi16(_mm_srli_epi16(layer3_chunk6, 8),
-                                           _mm_srli_epi16(layer3_chunk7, 8));
-
-  __m128i layer1_chunk0 =
-      _mm_packus_epi16(_mm_and_si128(layer2_chunk0, v_mask),
-                       _mm_and_si128(layer2_chunk1, v_mask));
-  __m128i layer1_chunk4 = _mm_packus_epi16(_mm_srli_epi16(layer2_chunk0, 8),
-                                           _mm_srli_epi16(layer2_chunk1, 8));
-  __m128i layer1_chunk1 =
-      _mm_packus_epi16(_mm_and_si128(layer2_chunk2, v_mask),
-                       _mm_and_si128(layer2_chunk3, v_mask));
-  __m128i layer1_chunk5 = _mm_packus_epi16(_mm_srli_epi16(layer2_chunk2, 8),
-                                           _mm_srli_epi16(layer2_chunk3, 8));
-  __m128i layer1_chunk2 =
-      _mm_packus_epi16(_mm_and_si128(layer2_chunk4, v_mask),
-                       _mm_and_si128(layer2_chunk5, v_mask));
-  __m128i layer1_chunk6 = _mm_packus_epi16(_mm_srli_epi16(layer2_chunk4, 8),
-                                           _mm_srli_epi16(layer2_chunk5, 8));
-  __m128i layer1_chunk3 =
-      _mm_packus_epi16(_mm_and_si128(layer2_chunk6, v_mask),
-                       _mm_and_si128(layer2_chunk7, v_mask));
-  __m128i layer1_chunk7 = _mm_packus_epi16(_mm_srli_epi16(layer2_chunk6, 8),
-                                           _mm_srli_epi16(layer2_chunk7, 8));
-
-  v_r0 = _mm_packus_epi16(_mm_and_si128(layer1_chunk0, v_mask),
-                          _mm_and_si128(layer1_chunk1, v_mask));
-  v_b0 = _mm_packus_epi16(_mm_srli_epi16(layer1_chunk0, 8),
-                          _mm_srli_epi16(layer1_chunk1, 8));
-  v_r1 = _mm_packus_epi16(_mm_and_si128(layer1_chunk2, v_mask),
-                          _mm_and_si128(layer1_chunk3, v_mask));
-  v_b1 = _mm_packus_epi16(_mm_srli_epi16(layer1_chunk2, 8),
-                          _mm_srli_epi16(layer1_chunk3, 8));
-  v_g0 = _mm_packus_epi16(_mm_and_si128(layer1_chunk4, v_mask),
-                          _mm_and_si128(layer1_chunk5, v_mask));
-  v_a0 = _mm_packus_epi16(_mm_srli_epi16(layer1_chunk4, 8),
-                          _mm_srli_epi16(layer1_chunk5, 8));
-  v_g1 = _mm_packus_epi16(_mm_and_si128(layer1_chunk6, v_mask),
-                          _mm_and_si128(layer1_chunk7, v_mask));
-  v_a1 = _mm_packus_epi16(_mm_srli_epi16(layer1_chunk6, 8),
-                          _mm_srli_epi16(layer1_chunk7, 8));
-}
-
-inline void _mm_deinterleave_epi16(__m128i &v_r0, __m128i &v_r1, __m128i &v_g0,
-                                   __m128i &v_g1) {
-  __m128i layer1_chunk0 = _mm_unpacklo_epi16(v_r0, v_g0);
-  __m128i layer1_chunk1 = _mm_unpackhi_epi16(v_r0, v_g0);
-  __m128i layer1_chunk2 = _mm_unpacklo_epi16(v_r1, v_g1);
-  __m128i layer1_chunk3 = _mm_unpackhi_epi16(v_r1, v_g1);
-
-  __m128i layer2_chunk0 = _mm_unpacklo_epi16(layer1_chunk0, layer1_chunk2);
-  __m128i layer2_chunk1 = _mm_unpackhi_epi16(layer1_chunk0, layer1_chunk2);
-  __m128i layer2_chunk2 = _mm_unpacklo_epi16(layer1_chunk1, layer1_chunk3);
-  __m128i layer2_chunk3 = _mm_unpackhi_epi16(layer1_chunk1, layer1_chunk3);
-
-  __m128i layer3_chunk0 = _mm_unpacklo_epi16(layer2_chunk0, layer2_chunk2);
-  __m128i layer3_chunk1 = _mm_unpackhi_epi16(layer2_chunk0, layer2_chunk2);
-  __m128i layer3_chunk2 = _mm_unpacklo_epi16(layer2_chunk1, layer2_chunk3);
-  __m128i layer3_chunk3 = _mm_unpackhi_epi16(layer2_chunk1, layer2_chunk3);
-
-  v_r0 = _mm_unpacklo_epi16(layer3_chunk0, layer3_chunk2);
-  v_r1 = _mm_unpackhi_epi16(layer3_chunk0, layer3_chunk2);
-  v_g0 = _mm_unpacklo_epi16(layer3_chunk1, layer3_chunk3);
-  v_g1 = _mm_unpackhi_epi16(layer3_chunk1, layer3_chunk3);
-}
-
-inline void _mm_deinterleave_epi16(__m128i &v_r0, __m128i &v_r1, __m128i &v_g0,
-                                   __m128i &v_g1, __m128i &v_b0,
-                                   __m128i &v_b1) {
-  __m128i layer1_chunk0 = _mm_unpacklo_epi16(v_r0, v_g1);
-  __m128i layer1_chunk1 = _mm_unpackhi_epi16(v_r0, v_g1);
-  __m128i layer1_chunk2 = _mm_unpacklo_epi16(v_r1, v_b0);
-  __m128i layer1_chunk3 = _mm_unpackhi_epi16(v_r1, v_b0);
-  __m128i layer1_chunk4 = _mm_unpacklo_epi16(v_g0, v_b1);
-  __m128i layer1_chunk5 = _mm_unpackhi_epi16(v_g0, v_b1);
-
-  __m128i layer2_chunk0 = _mm_unpacklo_epi16(layer1_chunk0, layer1_chunk3);
-  __m128i layer2_chunk1 = _mm_unpackhi_epi16(layer1_chunk0, layer1_chunk3);
-  __m128i layer2_chunk2 = _mm_unpacklo_epi16(layer1_chunk1, layer1_chunk4);
-  __m128i layer2_chunk3 = _mm_unpackhi_epi16(layer1_chunk1, layer1_chunk4);
-  __m128i layer2_chunk4 = _mm_unpacklo_epi16(layer1_chunk2, layer1_chunk5);
-  __m128i layer2_chunk5 = _mm_unpackhi_epi16(layer1_chunk2, layer1_chunk5);
-
-  __m128i layer3_chunk0 = _mm_unpacklo_epi16(layer2_chunk0, layer2_chunk3);
-  __m128i layer3_chunk1 = _mm_unpackhi_epi16(layer2_chunk0, layer2_chunk3);
-  __m128i layer3_chunk2 = _mm_unpacklo_epi16(layer2_chunk1, layer2_chunk4);
-  __m128i layer3_chunk3 = _mm_unpackhi_epi16(layer2_chunk1, layer2_chunk4);
-  __m128i layer3_chunk4 = _mm_unpacklo_epi16(layer2_chunk2, layer2_chunk5);
-  __m128i layer3_chunk5 = _mm_unpackhi_epi16(layer2_chunk2, layer2_chunk5);
-
-  v_r0 = _mm_unpacklo_epi16(layer3_chunk0, layer3_chunk3);
-  v_r1 = _mm_unpackhi_epi16(layer3_chunk0, layer3_chunk3);
-  v_g0 = _mm_unpacklo_epi16(layer3_chunk1, layer3_chunk4);
-  v_g1 = _mm_unpackhi_epi16(layer3_chunk1, layer3_chunk4);
-  v_b0 = _mm_unpacklo_epi16(layer3_chunk2, layer3_chunk5);
-  v_b1 = _mm_unpackhi_epi16(layer3_chunk2, layer3_chunk5);
-}
-
-inline void _mm_deinterleave_epi16(__m128i &v_r0, __m128i &v_r1, __m128i &v_g0,
-                                   __m128i &v_g1, __m128i &v_b0, __m128i &v_b1,
-                                   __m128i &v_a0, __m128i &v_a1) {
-  __m128i layer1_chunk0 = _mm_unpacklo_epi16(v_r0, v_b0);
-  __m128i layer1_chunk1 = _mm_unpackhi_epi16(v_r0, v_b0);
-  __m128i layer1_chunk2 = _mm_unpacklo_epi16(v_r1, v_b1);
-  __m128i layer1_chunk3 = _mm_unpackhi_epi16(v_r1, v_b1);
-  __m128i layer1_chunk4 = _mm_unpacklo_epi16(v_g0, v_a0);
-  __m128i layer1_chunk5 = _mm_unpackhi_epi16(v_g0, v_a0);
-  __m128i layer1_chunk6 = _mm_unpacklo_epi16(v_g1, v_a1);
-  __m128i layer1_chunk7 = _mm_unpackhi_epi16(v_g1, v_a1);
-
-  __m128i layer2_chunk0 = _mm_unpacklo_epi16(layer1_chunk0, layer1_chunk4);
-  __m128i layer2_chunk1 = _mm_unpackhi_epi16(layer1_chunk0, layer1_chunk4);
-  __m128i layer2_chunk2 = _mm_unpacklo_epi16(layer1_chunk1, layer1_chunk5);
-  __m128i layer2_chunk3 = _mm_unpackhi_epi16(layer1_chunk1, layer1_chunk5);
-  __m128i layer2_chunk4 = _mm_unpacklo_epi16(layer1_chunk2, layer1_chunk6);
-  __m128i layer2_chunk5 = _mm_unpackhi_epi16(layer1_chunk2, layer1_chunk6);
-  __m128i layer2_chunk6 = _mm_unpacklo_epi16(layer1_chunk3, layer1_chunk7);
-  __m128i layer2_chunk7 = _mm_unpackhi_epi16(layer1_chunk3, layer1_chunk7);
-
-  __m128i layer3_chunk0 = _mm_unpacklo_epi16(layer2_chunk0, layer2_chunk4);
-  __m128i layer3_chunk1 = _mm_unpackhi_epi16(layer2_chunk0, layer2_chunk4);
-  __m128i layer3_chunk2 = _mm_unpacklo_epi16(layer2_chunk1, layer2_chunk5);
-  __m128i layer3_chunk3 = _mm_unpackhi_epi16(layer2_chunk1, layer2_chunk5);
-  __m128i layer3_chunk4 = _mm_unpacklo_epi16(layer2_chunk2, layer2_chunk6);
-  __m128i layer3_chunk5 = _mm_unpackhi_epi16(layer2_chunk2, layer2_chunk6);
-  __m128i layer3_chunk6 = _mm_unpacklo_epi16(layer2_chunk3, layer2_chunk7);
-  __m128i layer3_chunk7 = _mm_unpackhi_epi16(layer2_chunk3, layer2_chunk7);
-
-  v_r0 = _mm_unpacklo_epi16(layer3_chunk0, layer3_chunk4);
-  v_r1 = _mm_unpackhi_epi16(layer3_chunk0, layer3_chunk4);
-  v_g0 = _mm_unpacklo_epi16(layer3_chunk1, layer3_chunk5);
-  v_g1 = _mm_unpackhi_epi16(layer3_chunk1, layer3_chunk5);
-  v_b0 = _mm_unpacklo_epi16(layer3_chunk2, layer3_chunk6);
-  v_b1 = _mm_unpackhi_epi16(layer3_chunk2, layer3_chunk6);
-  v_a0 = _mm_unpacklo_epi16(layer3_chunk3, layer3_chunk7);
-  v_a1 = _mm_unpackhi_epi16(layer3_chunk3, layer3_chunk7);
-}
-
-#if CV_SSE4_1
-
-inline void _mm_interleave_epi16(__m128i &v_r0, __m128i &v_r1, __m128i &v_g0,
-                                 __m128i &v_g1) {
-  __m128i v_mask = _mm_set1_epi32(0x0000ffff);
-
-  __m128i layer3_chunk0 = _mm_packus_epi32(_mm_and_si128(v_r0, v_mask),
-                                           _mm_and_si128(v_r1, v_mask));
-  __m128i layer3_chunk2 =
-      _mm_packus_epi32(_mm_srli_epi32(v_r0, 16), _mm_srli_epi32(v_r1, 16));
-  __m128i layer3_chunk1 = _mm_packus_epi32(_mm_and_si128(v_g0, v_mask),
-                                           _mm_and_si128(v_g1, v_mask));
-  __m128i layer3_chunk3 =
-      _mm_packus_epi32(_mm_srli_epi32(v_g0, 16), _mm_srli_epi32(v_g1, 16));
-
-  __m128i layer2_chunk0 =
-      _mm_packus_epi32(_mm_and_si128(layer3_chunk0, v_mask),
-                       _mm_and_si128(layer3_chunk1, v_mask));
-  __m128i layer2_chunk2 = _mm_packus_epi32(_mm_srli_epi32(layer3_chunk0, 16),
-                                           _mm_srli_epi32(layer3_chunk1, 16));
-  __m128i layer2_chunk1 =
-      _mm_packus_epi32(_mm_and_si128(layer3_chunk2, v_mask),
-                       _mm_and_si128(layer3_chunk3, v_mask));
-  __m128i layer2_chunk3 = _mm_packus_epi32(_mm_srli_epi32(layer3_chunk2, 16),
-                                           _mm_srli_epi32(layer3_chunk3, 16));
-
-  __m128i layer1_chunk0 =
-      _mm_packus_epi32(_mm_and_si128(layer2_chunk0, v_mask),
-                       _mm_and_si128(layer2_chunk1, v_mask));
-  __m128i layer1_chunk2 = _mm_packus_epi32(_mm_srli_epi32(layer2_chunk0, 16),
-                                           _mm_srli_epi32(layer2_chunk1, 16));
-  __m128i layer1_chunk1 =
-      _mm_packus_epi32(_mm_and_si128(layer2_chunk2, v_mask),
-                       _mm_and_si128(layer2_chunk3, v_mask));
-  __m128i layer1_chunk3 = _mm_packus_epi32(_mm_srli_epi32(layer2_chunk2, 16),
-                                           _mm_srli_epi32(layer2_chunk3, 16));
-
-  v_r0 = _mm_packus_epi32(_mm_and_si128(layer1_chunk0, v_mask),
-                          _mm_and_si128(layer1_chunk1, v_mask));
-  v_g0 = _mm_packus_epi32(_mm_srli_epi32(layer1_chunk0, 16),
-                          _mm_srli_epi32(layer1_chunk1, 16));
-  v_r1 = _mm_packus_epi32(_mm_and_si128(layer1_chunk2, v_mask),
-                          _mm_and_si128(layer1_chunk3, v_mask));
-  v_g1 = _mm_packus_epi32(_mm_srli_epi32(layer1_chunk2, 16),
-                          _mm_srli_epi32(layer1_chunk3, 16));
-}
-
-inline void _mm_interleave_epi16(__m128i &v_r0, __m128i &v_r1, __m128i &v_g0,
-                                 __m128i &v_g1, __m128i &v_b0, __m128i &v_b1) {
-  __m128i v_mask = _mm_set1_epi32(0x0000ffff);
-
-  __m128i layer3_chunk0 = _mm_packus_epi32(_mm_and_si128(v_r0, v_mask),
-                                           _mm_and_si128(v_r1, v_mask));
-  __m128i layer3_chunk3 =
-      _mm_packus_epi32(_mm_srli_epi32(v_r0, 16), _mm_srli_epi32(v_r1, 16));
-  __m128i layer3_chunk1 = _mm_packus_epi32(_mm_and_si128(v_g0, v_mask),
-                                           _mm_and_si128(v_g1, v_mask));
-  __m128i layer3_chunk4 =
-      _mm_packus_epi32(_mm_srli_epi32(v_g0, 16), _mm_srli_epi32(v_g1, 16));
-  __m128i layer3_chunk2 = _mm_packus_epi32(_mm_and_si128(v_b0, v_mask),
-                                           _mm_and_si128(v_b1, v_mask));
-  __m128i layer3_chunk5 =
-      _mm_packus_epi32(_mm_srli_epi32(v_b0, 16), _mm_srli_epi32(v_b1, 16));
-
-  __m128i layer2_chunk0 =
-      _mm_packus_epi32(_mm_and_si128(layer3_chunk0, v_mask),
-                       _mm_and_si128(layer3_chunk1, v_mask));
-  __m128i layer2_chunk3 = _mm_packus_epi32(_mm_srli_epi32(layer3_chunk0, 16),
-                                           _mm_srli_epi32(layer3_chunk1, 16));
-  __m128i layer2_chunk1 =
-      _mm_packus_epi32(_mm_and_si128(layer3_chunk2, v_mask),
-                       _mm_and_si128(layer3_chunk3, v_mask));
-  __m128i layer2_chunk4 = _mm_packus_epi32(_mm_srli_epi32(layer3_chunk2, 16),
-                                           _mm_srli_epi32(layer3_chunk3, 16));
-  __m128i layer2_chunk2 =
-      _mm_packus_epi32(_mm_and_si128(layer3_chunk4, v_mask),
-                       _mm_and_si128(layer3_chunk5, v_mask));
-  __m128i layer2_chunk5 = _mm_packus_epi32(_mm_srli_epi32(layer3_chunk4, 16),
-                                           _mm_srli_epi32(layer3_chunk5, 16));
-
-  __m128i layer1_chunk0 =
-      _mm_packus_epi32(_mm_and_si128(layer2_chunk0, v_mask),
-                       _mm_and_si128(layer2_chunk1, v_mask));
-  __m128i layer1_chunk3 = _mm_packus_epi32(_mm_srli_epi32(layer2_chunk0, 16),
-                                           _mm_srli_epi32(layer2_chunk1, 16));
-  __m128i layer1_chunk1 =
-      _mm_packus_epi32(_mm_and_si128(layer2_chunk2, v_mask),
-                       _mm_and_si128(layer2_chunk3, v_mask));
-  __m128i layer1_chunk4 = _mm_packus_epi32(_mm_srli_epi32(layer2_chunk2, 16),
-                                           _mm_srli_epi32(layer2_chunk3, 16));
-  __m128i layer1_chunk2 =
-      _mm_packus_epi32(_mm_and_si128(layer2_chunk4, v_mask),
-                       _mm_and_si128(layer2_chunk5, v_mask));
-  __m128i layer1_chunk5 = _mm_packus_epi32(_mm_srli_epi32(layer2_chunk4, 16),
-                                           _mm_srli_epi32(layer2_chunk5, 16));
-
-  v_r0 = _mm_packus_epi32(_mm_and_si128(layer1_chunk0, v_mask),
-                          _mm_and_si128(layer1_chunk1, v_mask));
-  v_g1 = _mm_packus_epi32(_mm_srli_epi32(layer1_chunk0, 16),
-                          _mm_srli_epi32(layer1_chunk1, 16));
-  v_r1 = _mm_packus_epi32(_mm_and_si128(layer1_chunk2, v_mask),
-                          _mm_and_si128(layer1_chunk3, v_mask));
-  v_b0 = _mm_packus_epi32(_mm_srli_epi32(layer1_chunk2, 16),
-                          _mm_srli_epi32(layer1_chunk3, 16));
-  v_g0 = _mm_packus_epi32(_mm_and_si128(layer1_chunk4, v_mask),
-                          _mm_and_si128(layer1_chunk5, v_mask));
-  v_b1 = _mm_packus_epi32(_mm_srli_epi32(layer1_chunk4, 16),
-                          _mm_srli_epi32(layer1_chunk5, 16));
-}
-
-inline void _mm_interleave_epi16(__m128i &v_r0, __m128i &v_r1, __m128i &v_g0,
-                                 __m128i &v_g1, __m128i &v_b0, __m128i &v_b1,
-                                 __m128i &v_a0, __m128i &v_a1) {
-  __m128i v_mask = _mm_set1_epi32(0x0000ffff);
-
-  __m128i layer3_chunk0 = _mm_packus_epi32(_mm_and_si128(v_r0, v_mask),
-                                           _mm_and_si128(v_r1, v_mask));
-  __m128i layer3_chunk4 =
-      _mm_packus_epi32(_mm_srli_epi32(v_r0, 16), _mm_srli_epi32(v_r1, 16));
-  __m128i layer3_chunk1 = _mm_packus_epi32(_mm_and_si128(v_g0, v_mask),
-                                           _mm_and_si128(v_g1, v_mask));
-  __m128i layer3_chunk5 =
-      _mm_packus_epi32(_mm_srli_epi32(v_g0, 16), _mm_srli_epi32(v_g1, 16));
-  __m128i layer3_chunk2 = _mm_packus_epi32(_mm_and_si128(v_b0, v_mask),
-                                           _mm_and_si128(v_b1, v_mask));
-  __m128i layer3_chunk6 =
-      _mm_packus_epi32(_mm_srli_epi32(v_b0, 16), _mm_srli_epi32(v_b1, 16));
-  __m128i layer3_chunk3 = _mm_packus_epi32(_mm_and_si128(v_a0, v_mask),
-                                           _mm_and_si128(v_a1, v_mask));
-  __m128i layer3_chunk7 =
-      _mm_packus_epi32(_mm_srli_epi32(v_a0, 16), _mm_srli_epi32(v_a1, 16));
-
-  __m128i layer2_chunk0 =
-      _mm_packus_epi32(_mm_and_si128(layer3_chunk0, v_mask),
-                       _mm_and_si128(layer3_chunk1, v_mask));
-  __m128i layer2_chunk4 = _mm_packus_epi32(_mm_srli_epi32(layer3_chunk0, 16),
-                                           _mm_srli_epi32(layer3_chunk1, 16));
-  __m128i layer2_chunk1 =
-      _mm_packus_epi32(_mm_and_si128(layer3_chunk2, v_mask),
-                       _mm_and_si128(layer3_chunk3, v_mask));
-  __m128i layer2_chunk5 = _mm_packus_epi32(_mm_srli_epi32(layer3_chunk2, 16),
-                                           _mm_srli_epi32(layer3_chunk3, 16));
-  __m128i layer2_chunk2 =
-      _mm_packus_epi32(_mm_and_si128(layer3_chunk4, v_mask),
-                       _mm_and_si128(layer3_chunk5, v_mask));
-  __m128i layer2_chunk6 = _mm_packus_epi32(_mm_srli_epi32(layer3_chunk4, 16),
-                                           _mm_srli_epi32(layer3_chunk5, 16));
-  __m128i layer2_chunk3 =
-      _mm_packus_epi32(_mm_and_si128(layer3_chunk6, v_mask),
-                       _mm_and_si128(layer3_chunk7, v_mask));
-  __m128i layer2_chunk7 = _mm_packus_epi32(_mm_srli_epi32(layer3_chunk6, 16),
-                                           _mm_srli_epi32(layer3_chunk7, 16));
-
-  __m128i layer1_chunk0 =
-      _mm_packus_epi32(_mm_and_si128(layer2_chunk0, v_mask),
-                       _mm_and_si128(layer2_chunk1, v_mask));
-  __m128i layer1_chunk4 = _mm_packus_epi32(_mm_srli_epi32(layer2_chunk0, 16),
-                                           _mm_srli_epi32(layer2_chunk1, 16));
-  __m128i layer1_chunk1 =
-      _mm_packus_epi32(_mm_and_si128(layer2_chunk2, v_mask),
-                       _mm_and_si128(layer2_chunk3, v_mask));
-  __m128i layer1_chunk5 = _mm_packus_epi32(_mm_srli_epi32(layer2_chunk2, 16),
-                                           _mm_srli_epi32(layer2_chunk3, 16));
-  __m128i layer1_chunk2 =
-      _mm_packus_epi32(_mm_and_si128(layer2_chunk4, v_mask),
-                       _mm_and_si128(layer2_chunk5, v_mask));
-  __m128i layer1_chunk6 = _mm_packus_epi32(_mm_srli_epi32(layer2_chunk4, 16),
-                                           _mm_srli_epi32(layer2_chunk5, 16));
-  __m128i layer1_chunk3 =
-      _mm_packus_epi32(_mm_and_si128(layer2_chunk6, v_mask),
-                       _mm_and_si128(layer2_chunk7, v_mask));
-  __m128i layer1_chunk7 = _mm_packus_epi32(_mm_srli_epi32(layer2_chunk6, 16),
-                                           _mm_srli_epi32(layer2_chunk7, 16));
-
-  v_r0 = _mm_packus_epi32(_mm_and_si128(layer1_chunk0, v_mask),
-                          _mm_and_si128(layer1_chunk1, v_mask));
-  v_b0 = _mm_packus_epi32(_mm_srli_epi32(layer1_chunk0, 16),
-                          _mm_srli_epi32(layer1_chunk1, 16));
-  v_r1 = _mm_packus_epi32(_mm_and_si128(layer1_chunk2, v_mask),
-                          _mm_and_si128(layer1_chunk3, v_mask));
-  v_b1 = _mm_packus_epi32(_mm_srli_epi32(layer1_chunk2, 16),
-                          _mm_srli_epi32(layer1_chunk3, 16));
-  v_g0 = _mm_packus_epi32(_mm_and_si128(layer1_chunk4, v_mask),
-                          _mm_and_si128(layer1_chunk5, v_mask));
-  v_a0 = _mm_packus_epi32(_mm_srli_epi32(layer1_chunk4, 16),
-                          _mm_srli_epi32(layer1_chunk5, 16));
-  v_g1 = _mm_packus_epi32(_mm_and_si128(layer1_chunk6, v_mask),
-                          _mm_and_si128(layer1_chunk7, v_mask));
-  v_a1 = _mm_packus_epi32(_mm_srli_epi32(layer1_chunk6, 16),
-                          _mm_srli_epi32(layer1_chunk7, 16));
-}
-
-#endif // CV_SSE4_1
-
-inline void _mm_deinterleave_ps(__m128 &v_r0, __m128 &v_r1, __m128 &v_g0,
-                                __m128 &v_g1) {
-  __m128 layer1_chunk0 = _mm_unpacklo_ps(v_r0, v_g0);
-  __m128 layer1_chunk1 = _mm_unpackhi_ps(v_r0, v_g0);
-  __m128 layer1_chunk2 = _mm_unpacklo_ps(v_r1, v_g1);
-  __m128 layer1_chunk3 = _mm_unpackhi_ps(v_r1, v_g1);
-
-  __m128 layer2_chunk0 = _mm_unpacklo_ps(layer1_chunk0, layer1_chunk2);
-  __m128 layer2_chunk1 = _mm_unpackhi_ps(layer1_chunk0, layer1_chunk2);
-  __m128 layer2_chunk2 = _mm_unpacklo_ps(layer1_chunk1, layer1_chunk3);
-  __m128 layer2_chunk3 = _mm_unpackhi_ps(layer1_chunk1, layer1_chunk3);
-
-  v_r0 = _mm_unpacklo_ps(layer2_chunk0, layer2_chunk2);
-  v_r1 = _mm_unpackhi_ps(layer2_chunk0, layer2_chunk2);
-  v_g0 = _mm_unpacklo_ps(layer2_chunk1, layer2_chunk3);
-  v_g1 = _mm_unpackhi_ps(layer2_chunk1, layer2_chunk3);
-}
-
-inline void _mm_deinterleave_ps(__m128 &v_r0, __m128 &v_r1, __m128 &v_g0,
-                                __m128 &v_g1, __m128 &v_b0, __m128 &v_b1) {
-  __m128 layer1_chunk0 = _mm_unpacklo_ps(v_r0, v_g1);
-  __m128 layer1_chunk1 = _mm_unpackhi_ps(v_r0, v_g1);
-  __m128 layer1_chunk2 = _mm_unpacklo_ps(v_r1, v_b0);
-  __m128 layer1_chunk3 = _mm_unpackhi_ps(v_r1, v_b0);
-  __m128 layer1_chunk4 = _mm_unpacklo_ps(v_g0, v_b1);
-  __m128 layer1_chunk5 = _mm_unpackhi_ps(v_g0, v_b1);
-
-  __m128 layer2_chunk0 = _mm_unpacklo_ps(layer1_chunk0, layer1_chunk3);
-  __m128 layer2_chunk1 = _mm_unpackhi_ps(layer1_chunk0, layer1_chunk3);
-  __m128 layer2_chunk2 = _mm_unpacklo_ps(layer1_chunk1, layer1_chunk4);
-  __m128 layer2_chunk3 = _mm_unpackhi_ps(layer1_chunk1, layer1_chunk4);
-  __m128 layer2_chunk4 = _mm_unpacklo_ps(layer1_chunk2, layer1_chunk5);
-  __m128 layer2_chunk5 = _mm_unpackhi_ps(layer1_chunk2, layer1_chunk5);
-
-  v_r0 = _mm_unpacklo_ps(layer2_chunk0, layer2_chunk3);
-  v_r1 = _mm_unpackhi_ps(layer2_chunk0, layer2_chunk3);
-  v_g0 = _mm_unpacklo_ps(layer2_chunk1, layer2_chunk4);
-  v_g1 = _mm_unpackhi_ps(layer2_chunk1, layer2_chunk4);
-  v_b0 = _mm_unpacklo_ps(layer2_chunk2, layer2_chunk5);
-  v_b1 = _mm_unpackhi_ps(layer2_chunk2, layer2_chunk5);
-}
-
-inline void _mm_deinterleave_ps(__m128 &v_r0, __m128 &v_r1, __m128 &v_g0,
-                                __m128 &v_g1, __m128 &v_b0, __m128 &v_b1,
-                                __m128 &v_a0, __m128 &v_a1) {
-  __m128 layer1_chunk0 = _mm_unpacklo_ps(v_r0, v_b0);
-  __m128 layer1_chunk1 = _mm_unpackhi_ps(v_r0, v_b0);
-  __m128 layer1_chunk2 = _mm_unpacklo_ps(v_r1, v_b1);
-  __m128 layer1_chunk3 = _mm_unpackhi_ps(v_r1, v_b1);
-  __m128 layer1_chunk4 = _mm_unpacklo_ps(v_g0, v_a0);
-  __m128 layer1_chunk5 = _mm_unpackhi_ps(v_g0, v_a0);
-  __m128 layer1_chunk6 = _mm_unpacklo_ps(v_g1, v_a1);
-  __m128 layer1_chunk7 = _mm_unpackhi_ps(v_g1, v_a1);
-
-  __m128 layer2_chunk0 = _mm_unpacklo_ps(layer1_chunk0, layer1_chunk4);
-  __m128 layer2_chunk1 = _mm_unpackhi_ps(layer1_chunk0, layer1_chunk4);
-  __m128 layer2_chunk2 = _mm_unpacklo_ps(layer1_chunk1, layer1_chunk5);
-  __m128 layer2_chunk3 = _mm_unpackhi_ps(layer1_chunk1, layer1_chunk5);
-  __m128 layer2_chunk4 = _mm_unpacklo_ps(layer1_chunk2, layer1_chunk6);
-  __m128 layer2_chunk5 = _mm_unpackhi_ps(layer1_chunk2, layer1_chunk6);
-  __m128 layer2_chunk6 = _mm_unpacklo_ps(layer1_chunk3, layer1_chunk7);
-  __m128 layer2_chunk7 = _mm_unpackhi_ps(layer1_chunk3, layer1_chunk7);
-
-  v_r0 = _mm_unpacklo_ps(layer2_chunk0, layer2_chunk4);
-  v_r1 = _mm_unpackhi_ps(layer2_chunk0, layer2_chunk4);
-  v_g0 = _mm_unpacklo_ps(layer2_chunk1, layer2_chunk5);
-  v_g1 = _mm_unpackhi_ps(layer2_chunk1, layer2_chunk5);
-  v_b0 = _mm_unpacklo_ps(layer2_chunk2, layer2_chunk6);
-  v_b1 = _mm_unpackhi_ps(layer2_chunk2, layer2_chunk6);
-  v_a0 = _mm_unpacklo_ps(layer2_chunk3, layer2_chunk7);
-  v_a1 = _mm_unpackhi_ps(layer2_chunk3, layer2_chunk7);
-}
-
-inline void _mm_interleave_ps(__m128 &v_r0, __m128 &v_r1, __m128 &v_g0,
-                              __m128 &v_g1) {
-  enum { mask_lo = _MM_SHUFFLE(2, 0, 2, 0), mask_hi = _MM_SHUFFLE(3, 1, 3, 1) };
-
-  __m128 layer2_chunk0 = _mm_shuffle_ps(v_r0, v_r1, mask_lo);
-  __m128 layer2_chunk2 = _mm_shuffle_ps(v_r0, v_r1, mask_hi);
-  __m128 layer2_chunk1 = _mm_shuffle_ps(v_g0, v_g1, mask_lo);
-  __m128 layer2_chunk3 = _mm_shuffle_ps(v_g0, v_g1, mask_hi);
-
-  __m128 layer1_chunk0 = _mm_shuffle_ps(layer2_chunk0, layer2_chunk1, mask_lo);
-  __m128 layer1_chunk2 = _mm_shuffle_ps(layer2_chunk0, layer2_chunk1, mask_hi);
-  __m128 layer1_chunk1 = _mm_shuffle_ps(layer2_chunk2, layer2_chunk3, mask_lo);
-  __m128 layer1_chunk3 = _mm_shuffle_ps(layer2_chunk2, layer2_chunk3, mask_hi);
-
-  v_r0 = _mm_shuffle_ps(layer1_chunk0, layer1_chunk1, mask_lo);
-  v_g0 = _mm_shuffle_ps(layer1_chunk0, layer1_chunk1, mask_hi);
-  v_r1 = _mm_shuffle_ps(layer1_chunk2, layer1_chunk3, mask_lo);
-  v_g1 = _mm_shuffle_ps(layer1_chunk2, layer1_chunk3, mask_hi);
-}
-
-inline void _mm_interleave_ps(__m128 &v_r0, __m128 &v_r1, __m128 &v_g0,
-                              __m128 &v_g1, __m128 &v_b0, __m128 &v_b1) {
-  enum { mask_lo = _MM_SHUFFLE(2, 0, 2, 0), mask_hi = _MM_SHUFFLE(3, 1, 3, 1) };
-
-  __m128 layer2_chunk0 = _mm_shuffle_ps(v_r0, v_r1, mask_lo);
-  __m128 layer2_chunk3 = _mm_shuffle_ps(v_r0, v_r1, mask_hi);
-  __m128 layer2_chunk1 = _mm_shuffle_ps(v_g0, v_g1, mask_lo);
-  __m128 layer2_chunk4 = _mm_shuffle_ps(v_g0, v_g1, mask_hi);
-  __m128 layer2_chunk2 = _mm_shuffle_ps(v_b0, v_b1, mask_lo);
-  __m128 layer2_chunk5 = _mm_shuffle_ps(v_b0, v_b1, mask_hi);
-
-  __m128 layer1_chunk0 = _mm_shuffle_ps(layer2_chunk0, layer2_chunk1, mask_lo);
-  __m128 layer1_chunk3 = _mm_shuffle_ps(layer2_chunk0, layer2_chunk1, mask_hi);
-  __m128 layer1_chunk1 = _mm_shuffle_ps(layer2_chunk2, layer2_chunk3, mask_lo);
-  __m128 layer1_chunk4 = _mm_shuffle_ps(layer2_chunk2, layer2_chunk3, mask_hi);
-  __m128 layer1_chunk2 = _mm_shuffle_ps(layer2_chunk4, layer2_chunk5, mask_lo);
-  __m128 layer1_chunk5 = _mm_shuffle_ps(layer2_chunk4, layer2_chunk5, mask_hi);
-
-  v_r0 = _mm_shuffle_ps(layer1_chunk0, layer1_chunk1, mask_lo);
-  v_g1 = _mm_shuffle_ps(layer1_chunk0, layer1_chunk1, mask_hi);
-  v_r1 = _mm_shuffle_ps(layer1_chunk2, layer1_chunk3, mask_lo);
-  v_b0 = _mm_shuffle_ps(layer1_chunk2, layer1_chunk3, mask_hi);
-  v_g0 = _mm_shuffle_ps(layer1_chunk4, layer1_chunk5, mask_lo);
-  v_b1 = _mm_shuffle_ps(layer1_chunk4, layer1_chunk5, mask_hi);
-}
-
-inline void _mm_interleave_ps(__m128 &v_r0, __m128 &v_r1, __m128 &v_g0,
-                              __m128 &v_g1, __m128 &v_b0, __m128 &v_b1,
-                              __m128 &v_a0, __m128 &v_a1) {
-  enum { mask_lo = _MM_SHUFFLE(2, 0, 2, 0), mask_hi = _MM_SHUFFLE(3, 1, 3, 1) };
-
-  __m128 layer2_chunk0 = _mm_shuffle_ps(v_r0, v_r1, mask_lo);
-  __m128 layer2_chunk4 = _mm_shuffle_ps(v_r0, v_r1, mask_hi);
-  __m128 layer2_chunk1 = _mm_shuffle_ps(v_g0, v_g1, mask_lo);
-  __m128 layer2_chunk5 = _mm_shuffle_ps(v_g0, v_g1, mask_hi);
-  __m128 layer2_chunk2 = _mm_shuffle_ps(v_b0, v_b1, mask_lo);
-  __m128 layer2_chunk6 = _mm_shuffle_ps(v_b0, v_b1, mask_hi);
-  __m128 layer2_chunk3 = _mm_shuffle_ps(v_a0, v_a1, mask_lo);
-  __m128 layer2_chunk7 = _mm_shuffle_ps(v_a0, v_a1, mask_hi);
-
-  __m128 layer1_chunk0 = _mm_shuffle_ps(layer2_chunk0, layer2_chunk1, mask_lo);
-  __m128 layer1_chunk4 = _mm_shuffle_ps(layer2_chunk0, layer2_chunk1, mask_hi);
-  __m128 layer1_chunk1 = _mm_shuffle_ps(layer2_chunk2, layer2_chunk3, mask_lo);
-  __m128 layer1_chunk5 = _mm_shuffle_ps(layer2_chunk2, layer2_chunk3, mask_hi);
-  __m128 layer1_chunk2 = _mm_shuffle_ps(layer2_chunk4, layer2_chunk5, mask_lo);
-  __m128 layer1_chunk6 = _mm_shuffle_ps(layer2_chunk4, layer2_chunk5, mask_hi);
-  __m128 layer1_chunk3 = _mm_shuffle_ps(layer2_chunk6, layer2_chunk7, mask_lo);
-  __m128 layer1_chunk7 = _mm_shuffle_ps(layer2_chunk6, layer2_chunk7, mask_hi);
-
-  v_r0 = _mm_shuffle_ps(layer1_chunk0, layer1_chunk1, mask_lo);
-  v_b0 = _mm_shuffle_ps(layer1_chunk0, layer1_chunk1, mask_hi);
-  v_r1 = _mm_shuffle_ps(layer1_chunk2, layer1_chunk3, mask_lo);
-  v_b1 = _mm_shuffle_ps(layer1_chunk2, layer1_chunk3, mask_hi);
-  v_g0 = _mm_shuffle_ps(layer1_chunk4, layer1_chunk5, mask_lo);
-  v_a0 = _mm_shuffle_ps(layer1_chunk4, layer1_chunk5, mask_hi);
-  v_g1 = _mm_shuffle_ps(layer1_chunk6, layer1_chunk7, mask_lo);
-  v_a1 = _mm_shuffle_ps(layer1_chunk6, layer1_chunk7, mask_hi);
-}
-
-#endif // CV_SSE2
-
-//! @}
-
-#endif // OPENCV_CORE_SSE_UTILS_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/traits.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/traits.hpp
deleted file mode 100644
index 4501545c87..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/traits.hpp
+++ /dev/null
@@ -1,417 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_CORE_TRAITS_HPP
-#define OPENCV_CORE_TRAITS_HPP
-
-#include "opencv2/core/cvdef.h"
-
-namespace cv {
-
-// #define OPENCV_TRAITS_ENABLE_DEPRECATED
-
-//! @addtogroup core_basic
-//! @{
-
-/** @brief Template "trait" class for OpenCV primitive data types.
-
-@note Deprecated. This is replaced by "single purpose" traits: traits::Type and
-traits::Depth
-
-A primitive OpenCV data type is one of unsigned char, bool, signed char,
-unsigned short, signed short, int, float, double, or a tuple of values of one of
-these types, where all the values in the tuple have the same type. Any primitive
-type from the list can be defined by an identifier in the form
-CV_\<bit-depth\>{U|S|F}C(\<number_of_channels\>), for example: uchar \~ CV_8UC1,
-3-element floating-point tuple \~ CV_32FC3, and so on. A universal OpenCV
-structure that is able to store a single instance of such a primitive data type
-is Vec. Multiple instances of such a type can be stored in a std::vector, Mat,
-Mat_, SparseMat, SparseMat_, or any other container that is able to store Vec
-instances.
-
-The DataType class is basically used to provide a description of such primitive
-data types without adding any fields or methods to the corresponding classes
-(and it is actually impossible to add anything to primitive C/C++ data types).
-This technique is known in C++ as class traits. It is not DataType itself that
-is used but its specialized versions, such as:
-@code
-    template<> class DataType<uchar>
-    {
-        typedef uchar value_type;
-        typedef int work_type;
-        typedef uchar channel_type;
-        enum { channel_type = CV_8U, channels = 1, fmt='u', type = CV_8U };
-    };
-    ...
-    template<typename _Tp> DataType<std::complex<_Tp> >
-    {
-        typedef std::complex<_Tp> value_type;
-        typedef std::complex<_Tp> work_type;
-        typedef _Tp channel_type;
-        // DataDepth is another helper trait class
-        enum { depth = DataDepth<_Tp>::value, channels=2,
-            fmt=(channels-1)*256+DataDepth<_Tp>::fmt,
-            type=CV_MAKETYPE(depth, channels) };
-    };
-    ...
-@endcode
-The main purpose of this class is to convert compilation-time type information
-to an OpenCV-compatible data type identifier, for example:
-@code
-    // allocates a 30x40 floating-point matrix
-    Mat A(30, 40, DataType<float>::type);
-
-    Mat B = Mat_<std::complex<double> >(3, 3);
-    // the statement below will print 6, 2 , that is depth == CV_64F, channels
-== 2 cout << B.depth() << ", " << B.channels() << endl;
-@endcode
-So, such traits are used to tell OpenCV which data type you are working with,
-even if such a type is not native to OpenCV. For example, the matrix B
-initialization above is compiled because OpenCV defines the proper specialized
-template class DataType\<complex\<_Tp\> \> . This mechanism is also useful (and
-used in OpenCV this way) for generic algorithms implementations.
-
-@note Default values were dropped to stop confusing developers about using of
-unsupported types (see #7599)
-*/
-template <typename _Tp> class DataType {
-public:
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-  typedef _Tp value_type;
-  typedef value_type work_type;
-  typedef value_type channel_type;
-  typedef value_type vec_type;
-  enum {
-    generic_type = 1,
-    depth = -1,
-    channels = 1,
-    fmt = 0,
-    type = CV_MAKETYPE(depth, channels)
-  };
-#endif
-};
-
-template <> class DataType<bool> {
-public:
-  typedef bool value_type;
-  typedef int work_type;
-  typedef value_type channel_type;
-  typedef value_type vec_type;
-  enum {
-    generic_type = 0,
-    depth = CV_8U,
-    channels = 1,
-    fmt = (int)'u',
-    type = CV_MAKETYPE(depth, channels)
-  };
-};
-
-template <> class DataType<uchar> {
-public:
-  typedef uchar value_type;
-  typedef int work_type;
-  typedef value_type channel_type;
-  typedef value_type vec_type;
-  enum {
-    generic_type = 0,
-    depth = CV_8U,
-    channels = 1,
-    fmt = (int)'u',
-    type = CV_MAKETYPE(depth, channels)
-  };
-};
-
-template <> class DataType<schar> {
-public:
-  typedef schar value_type;
-  typedef int work_type;
-  typedef value_type channel_type;
-  typedef value_type vec_type;
-  enum {
-    generic_type = 0,
-    depth = CV_8S,
-    channels = 1,
-    fmt = (int)'c',
-    type = CV_MAKETYPE(depth, channels)
-  };
-};
-
-template <> class DataType<char> {
-public:
-  typedef schar value_type;
-  typedef int work_type;
-  typedef value_type channel_type;
-  typedef value_type vec_type;
-  enum {
-    generic_type = 0,
-    depth = CV_8S,
-    channels = 1,
-    fmt = (int)'c',
-    type = CV_MAKETYPE(depth, channels)
-  };
-};
-
-template <> class DataType<ushort> {
-public:
-  typedef ushort value_type;
-  typedef int work_type;
-  typedef value_type channel_type;
-  typedef value_type vec_type;
-  enum {
-    generic_type = 0,
-    depth = CV_16U,
-    channels = 1,
-    fmt = (int)'w',
-    type = CV_MAKETYPE(depth, channels)
-  };
-};
-
-template <> class DataType<short> {
-public:
-  typedef short value_type;
-  typedef int work_type;
-  typedef value_type channel_type;
-  typedef value_type vec_type;
-  enum {
-    generic_type = 0,
-    depth = CV_16S,
-    channels = 1,
-    fmt = (int)'s',
-    type = CV_MAKETYPE(depth, channels)
-  };
-};
-
-template <> class DataType<int> {
-public:
-  typedef int value_type;
-  typedef value_type work_type;
-  typedef value_type channel_type;
-  typedef value_type vec_type;
-  enum {
-    generic_type = 0,
-    depth = CV_32S,
-    channels = 1,
-    fmt = (int)'i',
-    type = CV_MAKETYPE(depth, channels)
-  };
-};
-
-template <> class DataType<float> {
-public:
-  typedef float value_type;
-  typedef value_type work_type;
-  typedef value_type channel_type;
-  typedef value_type vec_type;
-  enum {
-    generic_type = 0,
-    depth = CV_32F,
-    channels = 1,
-    fmt = (int)'f',
-    type = CV_MAKETYPE(depth, channels)
-  };
-};
-
-template <> class DataType<double> {
-public:
-  typedef double value_type;
-  typedef value_type work_type;
-  typedef value_type channel_type;
-  typedef value_type vec_type;
-  enum {
-    generic_type = 0,
-    depth = CV_64F,
-    channels = 1,
-    fmt = (int)'d',
-    type = CV_MAKETYPE(depth, channels)
-  };
-};
-
-template <> class DataType<hfloat> {
-public:
-  typedef hfloat value_type;
-  typedef float work_type;
-  typedef value_type channel_type;
-  typedef value_type vec_type;
-  enum {
-    generic_type = 0,
-    depth = CV_16F,
-    channels = 1,
-    fmt = (int)'h',
-    type = CV_MAKETYPE(depth, channels)
-  };
-};
-
-/** @brief A helper class for cv::DataType
-
-The class is specialized for each fundamental numerical data type supported by
-OpenCV. It provides DataDepth<T>::value constant.
-*/
-template <typename _Tp> class DataDepth {
-public:
-  enum { value = DataType<_Tp>::depth, fmt = DataType<_Tp>::fmt };
-};
-
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-
-template <int _depth> class TypeDepth {
-#ifdef OPENCV_TRAITS_ENABLE_LEGACY_DEFAULTS
-  enum { depth = CV_USRTYPE1 };
-  typedef void value_type;
-#endif
-};
-
-template <> class TypeDepth<CV_8U> {
-  enum { depth = CV_8U };
-  typedef uchar value_type;
-};
-
-template <> class TypeDepth<CV_8S> {
-  enum { depth = CV_8S };
-  typedef schar value_type;
-};
-
-template <> class TypeDepth<CV_16U> {
-  enum { depth = CV_16U };
-  typedef ushort value_type;
-};
-
-template <> class TypeDepth<CV_16S> {
-  enum { depth = CV_16S };
-  typedef short value_type;
-};
-
-template <> class TypeDepth<CV_32S> {
-  enum { depth = CV_32S };
-  typedef int value_type;
-};
-
-template <> class TypeDepth<CV_32F> {
-  enum { depth = CV_32F };
-  typedef float value_type;
-};
-
-template <> class TypeDepth<CV_64F> {
-  enum { depth = CV_64F };
-  typedef double value_type;
-};
-
-template <> class TypeDepth<CV_16F> {
-  enum { depth = CV_16F };
-  typedef hfloat value_type;
-};
-
-#endif
-
-//! @}
-
-namespace traits {
-
-namespace internal {
-#define CV_CREATE_MEMBER_CHECK(X)                                              \
-  template <typename T> class CheckMember_##X {                                \
-    struct Fallback {                                                          \
-      int X;                                                                   \
-    };                                                                         \
-    struct Derived : T, Fallback {};                                           \
-    template <typename U, U> struct Check;                                     \
-    typedef char CV_NO[1];                                                     \
-    typedef char CV_YES[2];                                                    \
-    template <typename U> static CV_NO &func(Check<int Fallback::*, &U::X> *); \
-    template <typename U> static CV_YES &func(...);                            \
-                                                                               \
-  public:                                                                      \
-    typedef CheckMember_##X type;                                              \
-    enum { value = sizeof(func<Derived>(0)) == sizeof(CV_YES) };               \
-  };
-
-CV_CREATE_MEMBER_CHECK(fmt)
-CV_CREATE_MEMBER_CHECK(type)
-
-} // namespace internal
-
-template <typename T> struct Depth {
-  enum { value = DataType<T>::depth };
-};
-
-template <typename T> struct Type {
-  enum { value = DataType<T>::type };
-};
-
-/** Similar to traits::Type<T> but has value = -1 in case of unknown type
- * (instead of compiler error) */
-template <typename T,
-          bool available = internal::CheckMember_type<DataType<T>>::value>
-struct SafeType {};
-
-template <typename T> struct SafeType<T, false> {
-  enum { value = -1 };
-};
-
-template <typename T> struct SafeType<T, true> {
-  enum { value = Type<T>::value };
-};
-
-template <typename T,
-          bool available = internal::CheckMember_fmt<DataType<T>>::value>
-struct SafeFmt {};
-
-template <typename T> struct SafeFmt<T, false> {
-  enum { fmt = 0 };
-};
-
-template <typename T> struct SafeFmt<T, true> {
-  enum { fmt = DataType<T>::fmt };
-};
-
-} // namespace traits
-
-} // namespace cv
-
-#endif // OPENCV_CORE_TRAITS_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/types.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/types.hpp
deleted file mode 100644
index 21f57014a5..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/types.hpp
+++ /dev/null
@@ -1,2368 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_CORE_TYPES_HPP
-#define OPENCV_CORE_TYPES_HPP
-
-#ifndef __cplusplus
-#error types.hpp header must be compiled as C++
-#endif
-
-#include <cfloat>
-#include <climits>
-#include <limits>
-#include <vector>
-
-#include "opencv2/core/cvdef.h"
-#include "opencv2/core/cvstd.hpp"
-#include "opencv2/core/matx.hpp"
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4459) // declaration of '...' hides global declaration
-#endif
-
-namespace cv {
-
-//! @addtogroup core_basic
-//! @{
-
-//////////////////////////////// Complex //////////////////////////////
-
-/** @brief  A complex number class.
-
-  The template class is similar and compatible with std::complex, however it
-  provides slightly more convenient access to the real and imaginary parts using
-  through the simple field access, as opposite to std::complex::real() and
-  std::complex::imag().
-*/
-template <typename _Tp> class Complex {
-public:
-  //! default constructor
-  Complex();
-  Complex(_Tp _re, _Tp _im = 0);
-
-  //! conversion to another data type
-  template <typename T2> operator Complex<T2>() const;
-  //! conjugation
-  Complex conj() const;
-
-  _Tp re, im; ///< the real and the imaginary parts
-};
-
-typedef Complex<float> Complexf;
-typedef Complex<double> Complexd;
-
-template <typename _Tp> class DataType<Complex<_Tp>> {
-public:
-  typedef Complex<_Tp> value_type;
-  typedef value_type work_type;
-  typedef _Tp channel_type;
-
-  enum {
-    generic_type = 0,
-    channels = 2,
-    fmt = DataType<channel_type>::fmt + ((channels - 1) << 8)
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-        ,
-    depth = DataType<channel_type>::depth,
-    type = CV_MAKETYPE(depth, channels)
-#endif
-  };
-
-  typedef Vec<channel_type, channels> vec_type;
-};
-
-namespace traits {
-template <typename _Tp> struct Depth<Complex<_Tp>> {
-  enum { value = Depth<_Tp>::value };
-};
-template <typename _Tp> struct Type<Complex<_Tp>> {
-  enum { value = CV_MAKETYPE(Depth<_Tp>::value, 2) };
-};
-} // namespace traits
-
-//////////////////////////////// Point_ ////////////////////////////////
-
-/** @brief Template class for 2D points specified by its coordinates `x` and
-`y`.
-
-An instance of the class is interchangeable with C structures, CvPoint and
-CvPoint2D32f . There is also a cast operator to convert point coordinates to the
-specified type. The conversion from floating-point coordinates to integer
-coordinates is done by rounding. Commonly, the conversion uses this operation
-for each of the coordinates. Besides the class members listed in the declaration
-above, the following operations on points are implemented:
-@code
-    pt1 = pt2 + pt3;
-    pt1 = pt2 - pt3;
-    pt1 = pt2 * a;
-    pt1 = a * pt2;
-    pt1 = pt2 / a;
-    pt1 += pt2;
-    pt1 -= pt2;
-    pt1 *= a;
-    pt1 /= a;
-    double value = norm(pt); // L2 norm
-    pt1 == pt2;
-    pt1 != pt2;
-@endcode
-For your convenience, the following type aliases are defined:
-@code
-    typedef Point_<int> Point2i;
-    typedef Point2i Point;
-    typedef Point_<float> Point2f;
-    typedef Point_<double> Point2d;
-@endcode
-Example:
-@code
-    Point2f a(0.3f, 0.f), b(0.f, 0.4f);
-    Point pt = (a + b)*10.f;
-    cout << pt.x << ", " << pt.y << endl;
-@endcode
-*/
-template <typename _Tp> class Point_ {
-public:
-  typedef _Tp value_type;
-
-  //! default constructor
-  Point_();
-  Point_(_Tp _x, _Tp _y);
-#if (defined(__GNUC__) && __GNUC__ < 5) &&                                     \
-    !defined(__clang__) // GCC 4.x bug. Details:
-                        // https://github.com/opencv/opencv/pull/20837
-  Point_(const Point_ &pt);
-  Point_(Point_ &&pt) CV_NOEXCEPT = default;
-#elif OPENCV_ABI_COMPATIBILITY < 500
-  Point_(const Point_ &pt) = default;
-  Point_(Point_ &&pt) CV_NOEXCEPT = default;
-#endif
-  Point_(const Size_<_Tp> &sz);
-  Point_(const Vec<_Tp, 2> &v);
-
-#if (defined(__GNUC__) && __GNUC__ < 5) &&                                     \
-    !defined(__clang__) // GCC 4.x bug. Details:
-                        // https://github.com/opencv/opencv/pull/20837
-  Point_ &operator=(const Point_ &pt);
-  Point_ &operator=(Point_ &&pt) CV_NOEXCEPT = default;
-#elif OPENCV_ABI_COMPATIBILITY < 500
-  Point_ &operator=(const Point_ &pt) = default;
-  Point_ &operator=(Point_ &&pt) CV_NOEXCEPT = default;
-#endif
-  //! conversion to another data type
-  template <typename _Tp2> operator Point_<_Tp2>() const;
-
-  //! conversion to the old-style C structures
-  operator Vec<_Tp, 2>() const;
-
-  //! dot product
-  _Tp dot(const Point_ &pt) const;
-  //! dot product computed in double-precision arithmetics
-  double ddot(const Point_ &pt) const;
-  //! cross-product
-  double cross(const Point_ &pt) const;
-  //! checks whether the point is inside the specified rectangle
-  bool inside(const Rect_<_Tp> &r) const;
-  _Tp x; //!< x coordinate of the point
-  _Tp y; //!< y coordinate of the point
-};
-
-typedef Point_<int> Point2i;
-typedef Point_<int64> Point2l;
-typedef Point_<float> Point2f;
-typedef Point_<double> Point2d;
-typedef Point2i Point;
-
-template <typename _Tp> class DataType<Point_<_Tp>> {
-public:
-  typedef Point_<_Tp> value_type;
-  typedef Point_<typename DataType<_Tp>::work_type> work_type;
-  typedef _Tp channel_type;
-
-  enum {
-    generic_type = 0,
-    channels = 2,
-    fmt = traits::SafeFmt<channel_type>::fmt + ((channels - 1) << 8)
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-        ,
-    depth = DataType<channel_type>::depth,
-    type = CV_MAKETYPE(depth, channels)
-#endif
-  };
-
-  typedef Vec<channel_type, channels> vec_type;
-};
-
-namespace traits {
-template <typename _Tp> struct Depth<Point_<_Tp>> {
-  enum { value = Depth<_Tp>::value };
-};
-template <typename _Tp> struct Type<Point_<_Tp>> {
-  enum { value = CV_MAKETYPE(Depth<_Tp>::value, 2) };
-};
-} // namespace traits
-
-//////////////////////////////// Point3_ ////////////////////////////////
-
-/** @brief Template class for 3D points specified by its coordinates `x`, `y`
-and `z`.
-
-An instance of the class is interchangeable with the C structure CvPoint2D32f .
-Similarly to Point_ , the coordinates of 3D points can be converted to another
-type. The vector arithmetic and comparison operations are also supported.
-
-The following Point3_\<\> aliases are available:
-@code
-    typedef Point3_<int> Point3i;
-    typedef Point3_<float> Point3f;
-    typedef Point3_<double> Point3d;
-@endcode
-@see cv::Point3i, cv::Point3f and cv::Point3d
-*/
-template <typename _Tp> class Point3_ {
-public:
-  typedef _Tp value_type;
-
-  //! default constructor
-  Point3_();
-  Point3_(_Tp _x, _Tp _y, _Tp _z);
-#if OPENCV_ABI_COMPATIBILITY < 500
-  Point3_(const Point3_ &pt) = default;
-  Point3_(Point3_ &&pt) CV_NOEXCEPT = default;
-#endif
-  explicit Point3_(const Point_<_Tp> &pt);
-  Point3_(const Vec<_Tp, 3> &v);
-
-#if OPENCV_ABI_COMPATIBILITY < 500
-  Point3_ &operator=(const Point3_ &pt) = default;
-  Point3_ &operator=(Point3_ &&pt) CV_NOEXCEPT = default;
-#endif
-  //! conversion to another data type
-  template <typename _Tp2> operator Point3_<_Tp2>() const;
-  //! conversion to cv::Vec<>
-  operator Vec<_Tp, 3>() const;
-
-  //! dot product
-  _Tp dot(const Point3_ &pt) const;
-  //! dot product computed in double-precision arithmetics
-  double ddot(const Point3_ &pt) const;
-  //! cross product of the 2 3D points
-  Point3_ cross(const Point3_ &pt) const;
-  _Tp x; //!< x coordinate of the 3D point
-  _Tp y; //!< y coordinate of the 3D point
-  _Tp z; //!< z coordinate of the 3D point
-};
-
-typedef Point3_<int> Point3i;
-typedef Point3_<float> Point3f;
-typedef Point3_<double> Point3d;
-
-template <typename _Tp> class DataType<Point3_<_Tp>> {
-public:
-  typedef Point3_<_Tp> value_type;
-  typedef Point3_<typename DataType<_Tp>::work_type> work_type;
-  typedef _Tp channel_type;
-
-  enum {
-    generic_type = 0,
-    channels = 3,
-    fmt = traits::SafeFmt<channel_type>::fmt + ((channels - 1) << 8)
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-        ,
-    depth = DataType<channel_type>::depth,
-    type = CV_MAKETYPE(depth, channels)
-#endif
-  };
-
-  typedef Vec<channel_type, channels> vec_type;
-};
-
-namespace traits {
-template <typename _Tp> struct Depth<Point3_<_Tp>> {
-  enum { value = Depth<_Tp>::value };
-};
-template <typename _Tp> struct Type<Point3_<_Tp>> {
-  enum { value = CV_MAKETYPE(Depth<_Tp>::value, 3) };
-};
-} // namespace traits
-
-//////////////////////////////// Size_ ////////////////////////////////
-
-/** @brief Template class for specifying the size of an image or rectangle.
-
-The class includes two members called width and height. The structure can be
-converted to and from the old OpenCV structures CvSize and CvSize2D32f . The
-same set of arithmetic and comparison operations as for Point_ is available.
-
-OpenCV defines the following Size_\<\> aliases:
-@code
-    typedef Size_<int> Size2i;
-    typedef Size2i Size;
-    typedef Size_<float> Size2f;
-@endcode
-*/
-template <typename _Tp> class Size_ {
-public:
-  typedef _Tp value_type;
-
-  //! default constructor
-  Size_();
-  Size_(_Tp _width, _Tp _height);
-#if OPENCV_ABI_COMPATIBILITY < 500
-  Size_(const Size_ &sz) = default;
-  Size_(Size_ &&sz) CV_NOEXCEPT = default;
-#endif
-  Size_(const Point_<_Tp> &pt);
-
-#if OPENCV_ABI_COMPATIBILITY < 500
-  Size_ &operator=(const Size_ &sz) = default;
-  Size_ &operator=(Size_ &&sz) CV_NOEXCEPT = default;
-#endif
-  //! the area (width*height)
-  _Tp area() const;
-  //! aspect ratio (width/height)
-  double aspectRatio() const;
-  //! true if empty
-  bool empty() const;
-
-  //! conversion of another data type.
-  template <typename _Tp2> operator Size_<_Tp2>() const;
-
-  _Tp width;  //!< the width
-  _Tp height; //!< the height
-};
-
-typedef Size_<int> Size2i;
-typedef Size_<int64> Size2l;
-typedef Size_<float> Size2f;
-typedef Size_<double> Size2d;
-typedef Size2i Size;
-
-template <typename _Tp> class DataType<Size_<_Tp>> {
-public:
-  typedef Size_<_Tp> value_type;
-  typedef Size_<typename DataType<_Tp>::work_type> work_type;
-  typedef _Tp channel_type;
-
-  enum {
-    generic_type = 0,
-    channels = 2,
-    fmt = DataType<channel_type>::fmt + ((channels - 1) << 8)
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-        ,
-    depth = DataType<channel_type>::depth,
-    type = CV_MAKETYPE(depth, channels)
-#endif
-  };
-
-  typedef Vec<channel_type, channels> vec_type;
-};
-
-namespace traits {
-template <typename _Tp> struct Depth<Size_<_Tp>> {
-  enum { value = Depth<_Tp>::value };
-};
-template <typename _Tp> struct Type<Size_<_Tp>> {
-  enum { value = CV_MAKETYPE(Depth<_Tp>::value, 2) };
-};
-} // namespace traits
-
-//////////////////////////////// Rect_ ////////////////////////////////
-
-/** @brief Template class for 2D rectangles
-
-described by the following parameters:
--   Coordinates of the top-left corner. This is a default interpretation of
-Rect_::x and Rect_::y in OpenCV. Though, in your algorithms you may count x and
-y from the bottom-left corner.
--   Rectangle width and height.
-
-OpenCV typically assumes that the top and left boundary of the rectangle are
-inclusive, while the right and bottom boundaries are not. For example, the
-method Rect_::contains returns true if
-
-\f[x  \leq pt.x < x+width,
-      y  \leq pt.y < y+height\f]
-
-Virtually every loop over an image ROI in OpenCV (where ROI is specified by
-Rect_\<int\> ) is implemented as:
-@code
-    for(int y = roi.y; y < roi.y + roi.height; y++)
-        for(int x = roi.x; x < roi.x + roi.width; x++)
-        {
-            // ...
-        }
-@endcode
-In addition to the class members, the following operations on rectangles are
-implemented:
--   \f$\texttt{rect} = \texttt{rect} \pm \texttt{point}\f$ (shifting a rectangle
-by a certain offset)
--   \f$\texttt{rect} = \texttt{rect} \pm \texttt{size}\f$ (expanding or
-shrinking a rectangle by a certain amount)
--   rect += point, rect -= point, rect += size, rect -= size (augmenting
-operations)
--   rect = rect1 & rect2 (rectangle intersection)
--   rect = rect1 | rect2 (minimum area rectangle containing rect1 and rect2 )
--   rect &= rect1, rect |= rect1 (and the corresponding augmenting operations)
--   rect == rect1, rect != rect1 (rectangle comparison)
-
-This is an example how the partial ordering on rectangles can be established
-(rect1 \f$\subseteq\f$ rect2):
-@code
-    template<typename _Tp> inline bool
-    operator <= (const Rect_<_Tp>& r1, const Rect_<_Tp>& r2)
-    {
-        return (r1 & r2) == r1;
-    }
-@endcode
-For your convenience, the Rect_\<\> alias is available: cv::Rect
-*/
-template <typename _Tp> class Rect_ {
-public:
-  typedef _Tp value_type;
-
-  //! default constructor
-  Rect_();
-  Rect_(_Tp _x, _Tp _y, _Tp _width, _Tp _height);
-#if OPENCV_ABI_COMPATIBILITY < 500
-  Rect_(const Rect_ &r) = default;
-  Rect_(Rect_ &&r) CV_NOEXCEPT = default;
-#endif
-  Rect_(const Point_<_Tp> &org, const Size_<_Tp> &sz);
-  Rect_(const Point_<_Tp> &pt1, const Point_<_Tp> &pt2);
-
-#if OPENCV_ABI_COMPATIBILITY < 500
-  Rect_ &operator=(const Rect_ &r) = default;
-  Rect_ &operator=(Rect_ &&r) CV_NOEXCEPT = default;
-#endif
-  //! the top-left corner
-  Point_<_Tp> tl() const;
-  //! the bottom-right corner
-  Point_<_Tp> br() const;
-
-  //! size (width, height) of the rectangle
-  Size_<_Tp> size() const;
-  //! area (width*height) of the rectangle
-  _Tp area() const;
-  //! true if empty
-  bool empty() const;
-
-  //! conversion to another data type
-  template <typename _Tp2> operator Rect_<_Tp2>() const;
-
-  //! checks whether the rectangle contains the point
-  /*! @warning After OpenCV 4.11.0, when calling Rect.contains() with
-   * cv::Point2f / cv::Point2d point, point should not convert/round to int.
-   * ```
-   * Rect_<int> r(0,0,500,500); Point_<float> pt(250.0f, 499.9f);
-   * r.contains(pt) returns false.(OpenCV 4.10.0 or before)
-   * r.contains(pt) returns true. (OpenCV 4.11.0 or later)
-   * ```
-   */
-  template <typename _Tp2> inline bool contains(const Point_<_Tp2> &pt) const;
-
-  _Tp x;      //!< x coordinate of the top-left corner
-  _Tp y;      //!< y coordinate of the top-left corner
-  _Tp width;  //!< width of the rectangle
-  _Tp height; //!< height of the rectangle
-};
-
-typedef Rect_<int> Rect2i;
-typedef Rect_<float> Rect2f;
-typedef Rect_<double> Rect2d;
-typedef Rect2i Rect;
-
-template <typename _Tp> class DataType<Rect_<_Tp>> {
-public:
-  typedef Rect_<_Tp> value_type;
-  typedef Rect_<typename DataType<_Tp>::work_type> work_type;
-  typedef _Tp channel_type;
-
-  enum {
-    generic_type = 0,
-    channels = 4,
-    fmt = traits::SafeFmt<channel_type>::fmt + ((channels - 1) << 8)
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-        ,
-    depth = DataType<channel_type>::depth,
-    type = CV_MAKETYPE(depth, channels)
-#endif
-  };
-
-  typedef Vec<channel_type, channels> vec_type;
-};
-
-namespace traits {
-template <typename _Tp> struct Depth<Rect_<_Tp>> {
-  enum { value = Depth<_Tp>::value };
-};
-template <typename _Tp> struct Type<Rect_<_Tp>> {
-  enum { value = CV_MAKETYPE(Depth<_Tp>::value, 4) };
-};
-} // namespace traits
-
-///////////////////////////// RotatedRect /////////////////////////////
-
-/** @brief The class represents rotated (i.e. not up-right) rectangles on a
-plane.
-
-Each rectangle is specified by the center point (mass center), length of each
-side (represented by #Size2f structure) and the rotation angle in degrees.
-
-The sample below demonstrates how to use RotatedRect:
-@snippet snippets/core_various.cpp RotatedRect_demo
-![image](pics/rotatedrect.png)
-
-@sa CamShift, fitEllipse, minAreaRect, CvBox2D
-*/
-class CV_EXPORTS_W_SIMPLE RotatedRect {
-public:
-  //! default constructor
-  CV_WRAP RotatedRect();
-  /** full constructor
-  @param center The rectangle mass center.
-  @param size Width and height of the rectangle.
-  @param angle The rotation angle in a clockwise direction. When the angle is 0,
-  90, 180, 270 etc., the rectangle becomes an up-right rectangle.
-  */
-  CV_WRAP RotatedRect(const Point2f &center, const Size2f &size, float angle);
-  /**
-  Any 3 end points of the RotatedRect. They must be given in order (either
-  clockwise or anticlockwise).
-   */
-  CV_WRAP RotatedRect(const Point2f &point1, const Point2f &point2,
-                      const Point2f &point3);
-
-  /** returns 4 vertices of the rotated rectangle
-  @param pts The points array for storing rectangle vertices. The order is
-  _bottomLeft_, _topLeft_, topRight, bottomRight.
-  @note _Bottom_, _Top_, _Left_ and _Right_ sides refer to the original
-  rectangle (angle is 0), so after 180 degree rotation _bottomLeft_ point will
-  be located at the top right corner of the rectangle.
-  */
-  void points(Point2f pts[]) const;
-
-  CV_WRAP void points(CV_OUT std::vector<Point2f> &pts) const;
-
-  //! returns the minimal up-right integer rectangle containing the rotated
-  //! rectangle
-  CV_WRAP Rect boundingRect() const;
-  //! returns the minimal (exact) floating point rectangle containing the
-  //! rotated rectangle, not intended for use with images
-  CV_WRAP Rect2f boundingRect2f() const;
-  //! returns the rectangle mass center
-  CV_PROP_RW Point2f center;
-  //! returns width and height of the rectangle
-  CV_PROP_RW Size2f size;
-  //! returns the rotation angle. When the angle is 0, 90, 180, 270 etc., the
-  //! rectangle becomes an up-right rectangle.
-  CV_PROP_RW float angle;
-};
-
-template <> class DataType<RotatedRect> {
-public:
-  typedef RotatedRect value_type;
-  typedef value_type work_type;
-  typedef float channel_type;
-
-  enum {
-    generic_type = 0,
-    channels = (int)sizeof(value_type) / sizeof(channel_type), // 5
-    fmt = traits::SafeFmt<channel_type>::fmt + ((channels - 1) << 8)
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-        ,
-    depth = DataType<channel_type>::depth,
-    type = CV_MAKETYPE(depth, channels)
-#endif
-  };
-
-  typedef Vec<channel_type, channels> vec_type;
-};
-
-namespace traits {
-template <> struct Depth<RotatedRect> {
-  enum { value = Depth<float>::value };
-};
-template <> struct Type<RotatedRect> {
-  enum {
-    value = CV_MAKETYPE(Depth<float>::value,
-                        (int)sizeof(RotatedRect) / sizeof(float))
-  };
-};
-} // namespace traits
-
-//////////////////////////////// Range /////////////////////////////////
-
-/** @brief Template class specifying a continuous subsequence (slice) of a
-sequence.
-
-The class is used to specify a row or a column span in a matrix ( Mat ) and for
-many other purposes. Range(a,b) is basically the same as a:b in Matlab or a..b
-in Python. As in Python, start is an inclusive left boundary of the range and
-end is an exclusive right boundary of the range. Such a half-opened interval is
-usually denoted as \f$[start,end)\f$ .
-
-The static method Range::all() returns a special variable that means "the whole
-sequence" or "the whole range", just like " : " in Matlab or " ... " in Python.
-All the methods and functions in OpenCV that take Range support this special
-Range::all() value. But, of course, in case of your own custom processing, you
-will probably have to check and handle it explicitly:
-@code
-    void my_function(..., const Range& r, ....)
-    {
-        if(r == Range::all()) {
-            // process all the data
-        }
-        else {
-            // process [r.start, r.end)
-        }
-    }
-@endcode
-*/
-class CV_EXPORTS Range {
-public:
-  Range();
-  Range(int _start, int _end);
-  int size() const;
-  bool empty() const;
-  static Range all();
-
-  int start, end;
-};
-
-template <> class DataType<Range> {
-public:
-  typedef Range value_type;
-  typedef value_type work_type;
-  typedef int channel_type;
-
-  enum {
-    generic_type = 0,
-    channels = 2,
-    fmt = traits::SafeFmt<channel_type>::fmt + ((channels - 1) << 8)
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-        ,
-    depth = DataType<channel_type>::depth,
-    type = CV_MAKETYPE(depth, channels)
-#endif
-  };
-
-  typedef Vec<channel_type, channels> vec_type;
-};
-
-namespace traits {
-template <> struct Depth<Range> {
-  enum { value = Depth<int>::value };
-};
-template <> struct Type<Range> {
-  enum { value = CV_MAKETYPE(Depth<int>::value, 2) };
-};
-} // namespace traits
-
-//////////////////////////////// Scalar_ ///////////////////////////////
-
-/** @brief Template class for a 4-element vector derived from Vec.
-
-Being derived from Vec\<_Tp, 4\> , Scalar\_ and Scalar can be used just as
-typical 4-element vectors. In addition, they can be converted to/from CvScalar .
-The type Scalar is widely used in OpenCV to pass pixel values.
-*/
-template <typename _Tp> class Scalar_ : public Vec<_Tp, 4> {
-public:
-  //! default constructor
-  Scalar_();
-  Scalar_(_Tp v0, _Tp v1, _Tp v2 = 0, _Tp v3 = 0);
-  Scalar_(_Tp v0);
-
-  Scalar_(const Scalar_ &s);
-  Scalar_(Scalar_ &&s) CV_NOEXCEPT;
-
-  Scalar_ &operator=(const Scalar_ &s);
-  Scalar_ &operator=(Scalar_ &&s) CV_NOEXCEPT;
-
-  template <typename _Tp2, int cn> Scalar_(const Vec<_Tp2, cn> &v);
-
-  //! returns a scalar with all elements set to v0
-  static Scalar_<_Tp> all(_Tp v0);
-
-  //! conversion to another data type
-  template <typename T2> operator Scalar_<T2>() const;
-
-  //! per-element product
-  Scalar_<_Tp> mul(const Scalar_<_Tp> &a, double scale = 1) const;
-
-  //! returns (v0, -v1, -v2, -v3)
-  Scalar_<_Tp> conj() const;
-
-  //! returns true iff v1 == v2 == v3 == 0
-  bool isReal() const;
-};
-
-typedef Scalar_<double> Scalar;
-
-template <typename _Tp> class DataType<Scalar_<_Tp>> {
-public:
-  typedef Scalar_<_Tp> value_type;
-  typedef Scalar_<typename DataType<_Tp>::work_type> work_type;
-  typedef _Tp channel_type;
-
-  enum {
-    generic_type = 0,
-    channels = 4,
-    fmt = traits::SafeFmt<channel_type>::fmt + ((channels - 1) << 8)
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-        ,
-    depth = DataType<channel_type>::depth,
-    type = CV_MAKETYPE(depth, channels)
-#endif
-  };
-
-  typedef Vec<channel_type, channels> vec_type;
-};
-
-namespace traits {
-template <typename _Tp> struct Depth<Scalar_<_Tp>> {
-  enum { value = Depth<_Tp>::value };
-};
-template <typename _Tp> struct Type<Scalar_<_Tp>> {
-  enum { value = CV_MAKETYPE(Depth<_Tp>::value, 4) };
-};
-} // namespace traits
-
-/////////////////////////////// KeyPoint ////////////////////////////////
-
-/** @brief Data structure for salient point detectors.
-
-The class instance stores a keypoint, i.e. a point feature found by one of many
-available keypoint detectors, such as Harris corner detector, #FAST,
-%StarDetector, %SURF, %SIFT etc.
-
-The keypoint is characterized by the 2D position, scale (proportional to the
-diameter of the neighborhood that needs to be taken into account), orientation
-and some other parameters. The keypoint neighborhood is then analyzed by another
-algorithm that builds a descriptor (usually represented as a feature vector).
-The keypoints representing the same object in different images can then be
-matched using %KDTree or another method.
-*/
-class CV_EXPORTS_W_SIMPLE KeyPoint {
-public:
-  //! the default constructor
-  CV_WRAP KeyPoint();
-  /**
-  @param pt x & y coordinates of the keypoint
-  @param size keypoint diameter
-  @param angle keypoint orientation
-  @param response keypoint detector response on the keypoint (that is, strength
-  of the keypoint)
-  @param octave pyramid octave in which the keypoint has been detected
-  @param class_id object id
-   */
-  KeyPoint(Point2f pt, float size, float angle = -1, float response = 0,
-           int octave = 0, int class_id = -1);
-  /**
-  @param x x-coordinate of the keypoint
-  @param y y-coordinate of the keypoint
-  @param size keypoint diameter
-  @param angle keypoint orientation
-  @param response keypoint detector response on the keypoint (that is, strength
-  of the keypoint)
-  @param octave pyramid octave in which the keypoint has been detected
-  @param class_id object id
-   */
-  CV_WRAP KeyPoint(float x, float y, float size, float angle = -1,
-                   float response = 0, int octave = 0, int class_id = -1);
-
-  size_t hash() const;
-
-  /**
-  This method converts vector of keypoints to vector of points or the reverse,
-  where each keypoint is assigned the same size and the same orientation.
-
-  @param keypoints Keypoints obtained from any feature detection algorithm like
-  SIFT/SURF/ORB
-  @param points2f Array of (x,y) coordinates of each keypoint
-  @param keypointIndexes Array of indexes of keypoints to be converted to
-  points. (Acts like a mask to convert only specified keypoints)
-  */
-  CV_WRAP static void
-  convert(const std::vector<KeyPoint> &keypoints,
-          CV_OUT std::vector<Point2f> &points2f,
-          const std::vector<int> &keypointIndexes = std::vector<int>());
-  /** @overload
-  @param points2f Array of (x,y) coordinates of each keypoint
-  @param keypoints Keypoints obtained from any feature detection algorithm like
-  SIFT/SURF/ORB
-  @param size keypoint diameter
-  @param response keypoint detector response on the keypoint (that is, strength
-  of the keypoint)
-  @param octave pyramid octave in which the keypoint has been detected
-  @param class_id object id
-  */
-  CV_WRAP static void convert(const std::vector<Point2f> &points2f,
-                              CV_OUT std::vector<KeyPoint> &keypoints,
-                              float size = 1, float response = 1,
-                              int octave = 0, int class_id = -1);
-
-  /**
-  This method computes overlap for pair of keypoints. Overlap is the ratio
-  between area of keypoint regions' intersection and area of keypoint regions'
-  union (considering keypoint region as circle). If they don't overlap, we get
-  zero. If they coincide at same location with same size, we get 1.
-  @param kp1 First keypoint
-  @param kp2 Second keypoint
-  */
-  CV_WRAP static float overlap(const KeyPoint &kp1, const KeyPoint &kp2);
-
-  CV_PROP_RW Point2f pt; //!< coordinates of the keypoints
-  CV_PROP_RW float size; //!< diameter of the meaningful keypoint neighborhood
-  CV_PROP_RW float
-      angle; //!< computed orientation of the keypoint (-1 if not applicable);
-             //!< it's in [0,360) degrees and measured relative to
-             //!< image coordinate system, ie in clockwise.
-  CV_PROP_RW float response; //!< the response by which the most strong
-                             //!< keypoints have been selected. Can be used for
-                             //!< the further sorting or subsampling
-  CV_PROP_RW int octave; //!< octave (pyramid layer) from which the keypoint has
-                         //!< been extracted
-  CV_PROP_RW int class_id; //!< object class (if the keypoints need to be
-                           //!< clustered by an object they belong to)
-};
-
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-template <> class DataType<KeyPoint> {
-public:
-  typedef KeyPoint value_type;
-  typedef float work_type;
-  typedef float channel_type;
-
-  enum {
-    generic_type = 0,
-    depth = DataType<channel_type>::depth,
-    channels = (int)(sizeof(value_type) / sizeof(channel_type)), // 7
-    fmt = DataType<channel_type>::fmt + ((channels - 1) << 8),
-    type = CV_MAKETYPE(depth, channels)
-  };
-
-  typedef Vec<channel_type, channels> vec_type;
-};
-#endif
-
-//////////////////////////////// DMatch /////////////////////////////////
-
-/** @brief Class for matching keypoint descriptors
-
-query descriptor index, train descriptor index, train image index, and distance
-between descriptors.
-*/
-class CV_EXPORTS_W_SIMPLE DMatch {
-public:
-  CV_WRAP DMatch();
-  CV_WRAP DMatch(int _queryIdx, int _trainIdx, float _distance);
-  CV_WRAP DMatch(int _queryIdx, int _trainIdx, int _imgIdx, float _distance);
-
-  CV_PROP_RW int queryIdx; //!< query descriptor index
-  CV_PROP_RW int trainIdx; //!< train descriptor index
-  CV_PROP_RW int imgIdx;   //!< train image index
-
-  CV_PROP_RW float distance;
-
-  // less is better
-  bool operator<(const DMatch &m) const;
-};
-
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-template <> class DataType<DMatch> {
-public:
-  typedef DMatch value_type;
-  typedef int work_type;
-  typedef int channel_type;
-
-  enum {
-    generic_type = 0,
-    depth = DataType<channel_type>::depth,
-    channels = (int)(sizeof(value_type) / sizeof(channel_type)), // 4
-    fmt = DataType<channel_type>::fmt + ((channels - 1) << 8),
-    type = CV_MAKETYPE(depth, channels)
-  };
-
-  typedef Vec<channel_type, channels> vec_type;
-};
-#endif
-
-///////////////////////////// TermCriteria //////////////////////////////
-
-/** @brief The class defining termination criteria for iterative algorithms.
-
-You can initialize it by default constructor and then override any parameters,
-or the structure may be fully initialized using the advanced variant of the
-constructor.
-*/
-class CV_EXPORTS TermCriteria {
-public:
-  /**
-    Criteria type, can be one of: COUNT, EPS or COUNT + EPS
-  */
-  enum Type {
-    COUNT = 1, //!< the maximum number of iterations or elements to compute
-    MAX_ITER = COUNT, //!< ditto
-    EPS = 2 //!< the desired accuracy or change in parameters at which the
-            //!< iterative algorithm stops
-  };
-
-  //! default constructor
-  TermCriteria();
-  /**
-  @param type The type of termination criteria, one of TermCriteria::Type
-  @param maxCount The maximum number of iterations or elements to compute.
-  @param epsilon The desired accuracy or change in parameters at which the
-  iterative algorithm stops.
-  */
-  TermCriteria(int type, int maxCount, double epsilon);
-
-  inline bool isValid() const {
-    const bool isCount = (type & COUNT) && maxCount > 0;
-    const bool isEps = (type & EPS) && !cvIsNaN(epsilon);
-    return isCount || isEps;
-  }
-
-  int type;     //!< the type of termination criteria: COUNT, EPS or COUNT + EPS
-  int maxCount; //!< the maximum number of iterations/elements
-  double epsilon; //!< the desired accuracy
-};
-
-//! @} core_basic
-
-///////////////////////// raster image moments //////////////////////////
-
-//! @addtogroup imgproc_shape
-//! @{
-
-/** @brief struct returned by cv::moments
-
-The spatial moments \f$\texttt{Moments::m}_{ji}\f$ are computed as:
-
-\f[\texttt{m} _{ji}= \sum _{x,y}  \left ( \texttt{array} (x,y)  \cdot x^j  \cdot
-y^i \right )\f]
-
-The central moments \f$\texttt{Moments::mu}_{ji}\f$ are computed as:
-
-\f[\texttt{mu} _{ji}= \sum _{x,y}  \left ( \texttt{array} (x,y)  \cdot (x -
-\bar{x} )^j  \cdot (y -  \bar{y} )^i \right )\f]
-
-where \f$(\bar{x}, \bar{y})\f$ is the mass center:
-
-\f[\bar{x} = \frac{\texttt{m}_{10}}{\texttt{m}_{00}} , \; \bar{y} =
-\frac{\texttt{m}_{01}}{\texttt{m}_{00}}\f]
-
-The normalized central moments \f$\texttt{Moments::nu}_{ij}\f$ are computed as:
-
-\f[\texttt{nu} _{ji}= \frac{\texttt{mu}_{ji}}{\texttt{m}_{00}^{(i+j)/2+1}} .\f]
-
-@note
-\f$\texttt{mu}_{00}=\texttt{m}_{00}\f$, \f$\texttt{nu}_{00}=1\f$
-\f$\texttt{nu}_{10}=\texttt{mu}_{10}=\texttt{mu}_{01}=\texttt{mu}_{10}=0\f$ ,
-hence the values are not stored.
-
-The moments of a contour are defined in the same way but computed using the
-Green's formula (see <http://en.wikipedia.org/wiki/Green_theorem>). So, due to a
-limited raster resolution, the moments computed for a contour are slightly
-different from the moments computed for the same rasterized contour.
-
-@note
-Since the contour moments are computed using Green formula, you may get
-seemingly odd results for contours with self-intersections, e.g. a zero area
-(m00) for butterfly-shaped contours.
- */
-class CV_EXPORTS_W_MAP Moments {
-public:
-  //! the default constructor
-  Moments();
-  //! the full constructor
-  Moments(double m00, double m10, double m01, double m20, double m11,
-          double m02, double m30, double m21, double m12, double m03);
-  ////! the conversion from CvMoments
-  // Moments( const CvMoments& moments );
-  ////! the conversion to CvMoments
-  // operator CvMoments() const;
-
-  //! @name spatial moments
-  //! @{
-  CV_PROP_RW double m00, m10, m01, m20, m11, m02, m30, m21, m12, m03;
-  //! @}
-
-  //! @name central moments
-  //! @{
-  CV_PROP_RW double mu20, mu11, mu02, mu30, mu21, mu12, mu03;
-  //! @}
-
-  //! @name central normalized moments
-  //! @{
-  CV_PROP_RW double nu20, nu11, nu02, nu30, nu21, nu12, nu03;
-  //! @}
-};
-
-template <> class DataType<Moments> {
-public:
-  typedef Moments value_type;
-  typedef double work_type;
-  typedef double channel_type;
-
-  enum {
-    generic_type = 0,
-    channels = (int)(sizeof(value_type) / sizeof(channel_type)), // 24
-    fmt = DataType<channel_type>::fmt + ((channels - 1) << 8)
-#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
-        ,
-    depth = DataType<channel_type>::depth,
-    type = CV_MAKETYPE(depth, channels)
-#endif
-  };
-
-  typedef Vec<channel_type, channels> vec_type;
-};
-
-namespace traits {
-template <> struct Depth<Moments> {
-  enum { value = Depth<double>::value };
-};
-template <> struct Type<Moments> {
-  enum {
-    value = CV_MAKETYPE(Depth<double>::value,
-                        (int)(sizeof(Moments) / sizeof(double)))
-  };
-};
-} // namespace traits
-
-//! @} imgproc_shape
-
-//! @cond IGNORED
-
-/////////////////////////////////////////////////////////////////////////
-///////////////////////////// Implementation ////////////////////////////
-/////////////////////////////////////////////////////////////////////////
-
-//////////////////////////////// Complex ////////////////////////////////
-
-template <typename _Tp> inline Complex<_Tp>::Complex() : re(0), im(0) {}
-
-template <typename _Tp>
-inline Complex<_Tp>::Complex(_Tp _re, _Tp _im) : re(_re), im(_im) {}
-
-template <typename _Tp>
-template <typename T2>
-inline Complex<_Tp>::operator Complex<T2>() const {
-  return Complex<T2>(saturate_cast<T2>(re), saturate_cast<T2>(im));
-}
-
-template <typename _Tp> inline Complex<_Tp> Complex<_Tp>::conj() const {
-  return Complex<_Tp>(re, -im);
-}
-
-template <typename _Tp>
-static inline bool operator==(const Complex<_Tp> &a, const Complex<_Tp> &b) {
-  return a.re == b.re && a.im == b.im;
-}
-
-template <typename _Tp>
-static inline bool operator!=(const Complex<_Tp> &a, const Complex<_Tp> &b) {
-  return a.re != b.re || a.im != b.im;
-}
-
-template <typename _Tp>
-static inline Complex<_Tp> operator+(const Complex<_Tp> &a,
-                                     const Complex<_Tp> &b) {
-  return Complex<_Tp>(a.re + b.re, a.im + b.im);
-}
-
-template <typename _Tp>
-static inline Complex<_Tp> &operator+=(Complex<_Tp> &a, const Complex<_Tp> &b) {
-  a.re += b.re;
-  a.im += b.im;
-  return a;
-}
-
-template <typename _Tp>
-static inline Complex<_Tp> operator-(const Complex<_Tp> &a,
-                                     const Complex<_Tp> &b) {
-  return Complex<_Tp>(a.re - b.re, a.im - b.im);
-}
-
-template <typename _Tp>
-static inline Complex<_Tp> &operator-=(Complex<_Tp> &a, const Complex<_Tp> &b) {
-  a.re -= b.re;
-  a.im -= b.im;
-  return a;
-}
-
-template <typename _Tp>
-static inline Complex<_Tp> operator-(const Complex<_Tp> &a) {
-  return Complex<_Tp>(-a.re, -a.im);
-}
-
-template <typename _Tp>
-static inline Complex<_Tp> operator*(const Complex<_Tp> &a,
-                                     const Complex<_Tp> &b) {
-  return Complex<_Tp>(a.re * b.re - a.im * b.im, a.re * b.im + a.im * b.re);
-}
-
-template <typename _Tp>
-static inline Complex<_Tp> operator*(const Complex<_Tp> &a, _Tp b) {
-  return Complex<_Tp>(a.re * b, a.im * b);
-}
-
-template <typename _Tp>
-static inline Complex<_Tp> operator*(_Tp b, const Complex<_Tp> &a) {
-  return Complex<_Tp>(a.re * b, a.im * b);
-}
-
-template <typename _Tp>
-static inline Complex<_Tp> operator+(const Complex<_Tp> &a, _Tp b) {
-  return Complex<_Tp>(a.re + b, a.im);
-}
-
-template <typename _Tp>
-static inline Complex<_Tp> operator-(const Complex<_Tp> &a, _Tp b) {
-  return Complex<_Tp>(a.re - b, a.im);
-}
-
-template <typename _Tp>
-static inline Complex<_Tp> operator+(_Tp b, const Complex<_Tp> &a) {
-  return Complex<_Tp>(a.re + b, a.im);
-}
-
-template <typename _Tp>
-static inline Complex<_Tp> operator-(_Tp b, const Complex<_Tp> &a) {
-  return Complex<_Tp>(b - a.re, -a.im);
-}
-
-template <typename _Tp>
-static inline Complex<_Tp> &operator+=(Complex<_Tp> &a, _Tp b) {
-  a.re += b;
-  return a;
-}
-
-template <typename _Tp>
-static inline Complex<_Tp> &operator-=(Complex<_Tp> &a, _Tp b) {
-  a.re -= b;
-  return a;
-}
-
-template <typename _Tp>
-static inline Complex<_Tp> &operator*=(Complex<_Tp> &a, _Tp b) {
-  a.re *= b;
-  a.im *= b;
-  return a;
-}
-
-template <typename _Tp> static inline double abs(const Complex<_Tp> &a) {
-  return std::sqrt((double)a.re * a.re + (double)a.im * a.im);
-}
-
-template <typename _Tp>
-static inline Complex<_Tp> operator/(const Complex<_Tp> &a,
-                                     const Complex<_Tp> &b) {
-  double t = 1. / ((double)b.re * b.re + (double)b.im * b.im);
-  return Complex<_Tp>((_Tp)((a.re * b.re + a.im * b.im) * t),
-                      (_Tp)((-a.re * b.im + a.im * b.re) * t));
-}
-
-template <typename _Tp>
-static inline Complex<_Tp> &operator/=(Complex<_Tp> &a, const Complex<_Tp> &b) {
-  a = a / b;
-  return a;
-}
-
-template <typename _Tp>
-static inline Complex<_Tp> operator/(const Complex<_Tp> &a, _Tp b) {
-  _Tp t = (_Tp)1 / b;
-  return Complex<_Tp>(a.re * t, a.im * t);
-}
-
-template <typename _Tp>
-static inline Complex<_Tp> operator/(_Tp b, const Complex<_Tp> &a) {
-  return Complex<_Tp>(b) / a;
-}
-
-template <typename _Tp>
-static inline Complex<_Tp> operator/=(const Complex<_Tp> &a, _Tp b) {
-  _Tp t = (_Tp)1 / b;
-  a.re *= t;
-  a.im *= t;
-  return a;
-}
-
-//////////////////////////////// 2D Point ///////////////////////////////
-
-template <typename _Tp> inline Point_<_Tp>::Point_() : x(0), y(0) {}
-
-template <typename _Tp>
-inline Point_<_Tp>::Point_(_Tp _x, _Tp _y) : x(_x), y(_y) {}
-
-#if (defined(__GNUC__) && __GNUC__ < 5) &&                                     \
-    !defined(__clang__) // GCC 4.x bug. Details:
-                        // https://github.com/opencv/opencv/pull/20837
-template <typename _Tp>
-inline Point_<_Tp>::Point_(const Point_ &pt) : x(pt.x), y(pt.y) {}
-#endif
-
-template <typename _Tp>
-inline Point_<_Tp>::Point_(const Size_<_Tp> &sz) : x(sz.width), y(sz.height) {}
-
-template <typename _Tp>
-inline Point_<_Tp>::Point_(const Vec<_Tp, 2> &v) : x(v[0]), y(v[1]) {}
-
-#if (defined(__GNUC__) && __GNUC__ < 5) &&                                     \
-    !defined(__clang__) // GCC 4.x bug. Details:
-                        // https://github.com/opencv/opencv/pull/20837
-template <typename _Tp>
-inline Point_<_Tp> &Point_<_Tp>::operator=(const Point_ &pt) {
-  x = pt.x;
-  y = pt.y;
-  return *this;
-}
-#endif
-
-template <typename _Tp>
-template <typename _Tp2>
-inline Point_<_Tp>::operator Point_<_Tp2>() const {
-  return Point_<_Tp2>(saturate_cast<_Tp2>(x), saturate_cast<_Tp2>(y));
-}
-
-template <typename _Tp> inline Point_<_Tp>::operator Vec<_Tp, 2>() const {
-  return Vec<_Tp, 2>(x, y);
-}
-
-template <typename _Tp> inline _Tp Point_<_Tp>::dot(const Point_ &pt) const {
-  return saturate_cast<_Tp>(x * pt.x + y * pt.y);
-}
-
-template <typename _Tp>
-inline double Point_<_Tp>::ddot(const Point_ &pt) const {
-  return (double)x * (double)(pt.x) + (double)y * (double)(pt.y);
-}
-
-template <typename _Tp>
-inline double Point_<_Tp>::cross(const Point_ &pt) const {
-  return (double)x * pt.y - (double)y * pt.x;
-}
-
-template <typename _Tp>
-inline bool Point_<_Tp>::inside(const Rect_<_Tp> &r) const {
-  return r.contains(*this);
-}
-
-template <typename _Tp>
-static inline Point_<_Tp> &operator+=(Point_<_Tp> &a, const Point_<_Tp> &b) {
-  a.x += b.x;
-  a.y += b.y;
-  return a;
-}
-
-template <typename _Tp>
-static inline Point_<_Tp> &operator-=(Point_<_Tp> &a, const Point_<_Tp> &b) {
-  a.x -= b.x;
-  a.y -= b.y;
-  return a;
-}
-
-template <typename _Tp>
-static inline Point_<_Tp> &operator*=(Point_<_Tp> &a, int b) {
-  a.x = saturate_cast<_Tp>(a.x * b);
-  a.y = saturate_cast<_Tp>(a.y * b);
-  return a;
-}
-
-template <typename _Tp>
-static inline Point_<_Tp> &operator*=(Point_<_Tp> &a, float b) {
-  a.x = saturate_cast<_Tp>(a.x * b);
-  a.y = saturate_cast<_Tp>(a.y * b);
-  return a;
-}
-
-template <typename _Tp>
-static inline Point_<_Tp> &operator*=(Point_<_Tp> &a, double b) {
-  a.x = saturate_cast<_Tp>(a.x * b);
-  a.y = saturate_cast<_Tp>(a.y * b);
-  return a;
-}
-
-template <typename _Tp>
-static inline Point_<_Tp> &operator/=(Point_<_Tp> &a, int b) {
-  a.x = saturate_cast<_Tp>(a.x / b);
-  a.y = saturate_cast<_Tp>(a.y / b);
-  return a;
-}
-
-template <typename _Tp>
-static inline Point_<_Tp> &operator/=(Point_<_Tp> &a, float b) {
-  a.x = saturate_cast<_Tp>(a.x / b);
-  a.y = saturate_cast<_Tp>(a.y / b);
-  return a;
-}
-
-template <typename _Tp>
-static inline Point_<_Tp> &operator/=(Point_<_Tp> &a, double b) {
-  a.x = saturate_cast<_Tp>(a.x / b);
-  a.y = saturate_cast<_Tp>(a.y / b);
-  return a;
-}
-
-template <typename _Tp> static inline double norm(const Point_<_Tp> &pt) {
-  return std::sqrt((double)pt.x * pt.x + (double)pt.y * pt.y);
-}
-
-template <typename _Tp>
-static inline bool operator==(const Point_<_Tp> &a, const Point_<_Tp> &b) {
-  return a.x == b.x && a.y == b.y;
-}
-
-template <typename _Tp>
-static inline bool operator!=(const Point_<_Tp> &a, const Point_<_Tp> &b) {
-  return a.x != b.x || a.y != b.y;
-}
-
-template <typename _Tp>
-static inline Point_<_Tp> operator+(const Point_<_Tp> &a,
-                                    const Point_<_Tp> &b) {
-  return Point_<_Tp>(saturate_cast<_Tp>(a.x + b.x),
-                     saturate_cast<_Tp>(a.y + b.y));
-}
-
-template <typename _Tp>
-static inline Point_<_Tp> operator-(const Point_<_Tp> &a,
-                                    const Point_<_Tp> &b) {
-  return Point_<_Tp>(saturate_cast<_Tp>(a.x - b.x),
-                     saturate_cast<_Tp>(a.y - b.y));
-}
-
-template <typename _Tp>
-static inline Point_<_Tp> operator-(const Point_<_Tp> &a) {
-  return Point_<_Tp>(saturate_cast<_Tp>(-a.x), saturate_cast<_Tp>(-a.y));
-}
-
-template <typename _Tp>
-static inline Point_<_Tp> operator*(const Point_<_Tp> &a, int b) {
-  return Point_<_Tp>(saturate_cast<_Tp>(a.x * b), saturate_cast<_Tp>(a.y * b));
-}
-
-template <typename _Tp>
-static inline Point_<_Tp> operator*(int a, const Point_<_Tp> &b) {
-  return Point_<_Tp>(saturate_cast<_Tp>(b.x * a), saturate_cast<_Tp>(b.y * a));
-}
-
-template <typename _Tp>
-static inline Point_<_Tp> operator*(const Point_<_Tp> &a, float b) {
-  return Point_<_Tp>(saturate_cast<_Tp>(a.x * b), saturate_cast<_Tp>(a.y * b));
-}
-
-template <typename _Tp>
-static inline Point_<_Tp> operator*(float a, const Point_<_Tp> &b) {
-  return Point_<_Tp>(saturate_cast<_Tp>(b.x * a), saturate_cast<_Tp>(b.y * a));
-}
-
-template <typename _Tp>
-static inline Point_<_Tp> operator*(const Point_<_Tp> &a, double b) {
-  return Point_<_Tp>(saturate_cast<_Tp>(a.x * b), saturate_cast<_Tp>(a.y * b));
-}
-
-template <typename _Tp>
-static inline Point_<_Tp> operator*(double a, const Point_<_Tp> &b) {
-  return Point_<_Tp>(saturate_cast<_Tp>(b.x * a), saturate_cast<_Tp>(b.y * a));
-}
-
-template <typename _Tp>
-static inline Point_<_Tp> operator*(const Matx<_Tp, 2, 2> &a,
-                                    const Point_<_Tp> &b) {
-  Matx<_Tp, 2, 1> tmp = a * Vec<_Tp, 2>(b.x, b.y);
-  return Point_<_Tp>(tmp.val[0], tmp.val[1]);
-}
-
-template <typename _Tp>
-static inline Point3_<_Tp> operator*(const Matx<_Tp, 3, 3> &a,
-                                     const Point_<_Tp> &b) {
-  Matx<_Tp, 3, 1> tmp = a * Vec<_Tp, 3>(b.x, b.y, 1);
-  return Point3_<_Tp>(tmp.val[0], tmp.val[1], tmp.val[2]);
-}
-
-template <typename _Tp>
-static inline Point_<_Tp> operator/(const Point_<_Tp> &a, int b) {
-  Point_<_Tp> tmp(a);
-  tmp /= b;
-  return tmp;
-}
-
-template <typename _Tp>
-static inline Point_<_Tp> operator/(const Point_<_Tp> &a, float b) {
-  Point_<_Tp> tmp(a);
-  tmp /= b;
-  return tmp;
-}
-
-template <typename _Tp>
-static inline Point_<_Tp> operator/(const Point_<_Tp> &a, double b) {
-  Point_<_Tp> tmp(a);
-  tmp /= b;
-  return tmp;
-}
-
-template <typename _AccTp>
-static inline _AccTp normL2Sqr(const Point_<int> &pt);
-template <typename _AccTp>
-static inline _AccTp normL2Sqr(const Point_<int64> &pt);
-template <typename _AccTp>
-static inline _AccTp normL2Sqr(const Point_<float> &pt);
-template <typename _AccTp>
-static inline _AccTp normL2Sqr(const Point_<double> &pt);
-
-template <> inline int normL2Sqr<int>(const Point_<int> &pt) {
-  return pt.dot(pt);
-}
-template <> inline int64 normL2Sqr<int64>(const Point_<int64> &pt) {
-  return pt.dot(pt);
-}
-template <> inline float normL2Sqr<float>(const Point_<float> &pt) {
-  return pt.dot(pt);
-}
-template <> inline double normL2Sqr<double>(const Point_<int> &pt) {
-  return pt.dot(pt);
-}
-
-template <> inline double normL2Sqr<double>(const Point_<float> &pt) {
-  return pt.ddot(pt);
-}
-template <> inline double normL2Sqr<double>(const Point_<double> &pt) {
-  return pt.ddot(pt);
-}
-
-//////////////////////////////// 3D Point ///////////////////////////////
-
-template <typename _Tp> inline Point3_<_Tp>::Point3_() : x(0), y(0), z(0) {}
-
-template <typename _Tp>
-inline Point3_<_Tp>::Point3_(_Tp _x, _Tp _y, _Tp _z) : x(_x), y(_y), z(_z) {}
-
-template <typename _Tp>
-inline Point3_<_Tp>::Point3_(const Point_<_Tp> &pt)
-    : x(pt.x), y(pt.y), z(_Tp()) {}
-
-template <typename _Tp>
-inline Point3_<_Tp>::Point3_(const Vec<_Tp, 3> &v)
-    : x(v[0]), y(v[1]), z(v[2]) {}
-
-template <typename _Tp>
-template <typename _Tp2>
-inline Point3_<_Tp>::operator Point3_<_Tp2>() const {
-  return Point3_<_Tp2>(saturate_cast<_Tp2>(x), saturate_cast<_Tp2>(y),
-                       saturate_cast<_Tp2>(z));
-}
-
-template <typename _Tp> inline Point3_<_Tp>::operator Vec<_Tp, 3>() const {
-  return Vec<_Tp, 3>(x, y, z);
-}
-
-template <typename _Tp> inline _Tp Point3_<_Tp>::dot(const Point3_ &pt) const {
-  return saturate_cast<_Tp>(x * pt.x + y * pt.y + z * pt.z);
-}
-
-template <typename _Tp>
-inline double Point3_<_Tp>::ddot(const Point3_ &pt) const {
-  return (double)x * pt.x + (double)y * pt.y + (double)z * pt.z;
-}
-
-template <typename _Tp>
-inline Point3_<_Tp> Point3_<_Tp>::cross(const Point3_<_Tp> &pt) const {
-  return Point3_<_Tp>(y * pt.z - z * pt.y, z * pt.x - x * pt.z,
-                      x * pt.y - y * pt.x);
-}
-
-template <typename _Tp>
-static inline Point3_<_Tp> &operator+=(Point3_<_Tp> &a, const Point3_<_Tp> &b) {
-  a.x += b.x;
-  a.y += b.y;
-  a.z += b.z;
-  return a;
-}
-
-template <typename _Tp>
-static inline Point3_<_Tp> &operator-=(Point3_<_Tp> &a, const Point3_<_Tp> &b) {
-  a.x -= b.x;
-  a.y -= b.y;
-  a.z -= b.z;
-  return a;
-}
-
-template <typename _Tp>
-static inline Point3_<_Tp> &operator*=(Point3_<_Tp> &a, int b) {
-  a.x = saturate_cast<_Tp>(a.x * b);
-  a.y = saturate_cast<_Tp>(a.y * b);
-  a.z = saturate_cast<_Tp>(a.z * b);
-  return a;
-}
-
-template <typename _Tp>
-static inline Point3_<_Tp> &operator*=(Point3_<_Tp> &a, float b) {
-  a.x = saturate_cast<_Tp>(a.x * b);
-  a.y = saturate_cast<_Tp>(a.y * b);
-  a.z = saturate_cast<_Tp>(a.z * b);
-  return a;
-}
-
-template <typename _Tp>
-static inline Point3_<_Tp> &operator*=(Point3_<_Tp> &a, double b) {
-  a.x = saturate_cast<_Tp>(a.x * b);
-  a.y = saturate_cast<_Tp>(a.y * b);
-  a.z = saturate_cast<_Tp>(a.z * b);
-  return a;
-}
-
-template <typename _Tp>
-static inline Point3_<_Tp> &operator/=(Point3_<_Tp> &a, int b) {
-  a.x = saturate_cast<_Tp>(a.x / b);
-  a.y = saturate_cast<_Tp>(a.y / b);
-  a.z = saturate_cast<_Tp>(a.z / b);
-  return a;
-}
-
-template <typename _Tp>
-static inline Point3_<_Tp> &operator/=(Point3_<_Tp> &a, float b) {
-  a.x = saturate_cast<_Tp>(a.x / b);
-  a.y = saturate_cast<_Tp>(a.y / b);
-  a.z = saturate_cast<_Tp>(a.z / b);
-  return a;
-}
-
-template <typename _Tp>
-static inline Point3_<_Tp> &operator/=(Point3_<_Tp> &a, double b) {
-  a.x = saturate_cast<_Tp>(a.x / b);
-  a.y = saturate_cast<_Tp>(a.y / b);
-  a.z = saturate_cast<_Tp>(a.z / b);
-  return a;
-}
-
-template <typename _Tp> static inline double norm(const Point3_<_Tp> &pt) {
-  return std::sqrt((double)pt.x * pt.x + (double)pt.y * pt.y +
-                   (double)pt.z * pt.z);
-}
-
-template <typename _Tp>
-static inline bool operator==(const Point3_<_Tp> &a, const Point3_<_Tp> &b) {
-  return a.x == b.x && a.y == b.y && a.z == b.z;
-}
-
-template <typename _Tp>
-static inline bool operator!=(const Point3_<_Tp> &a, const Point3_<_Tp> &b) {
-  return a.x != b.x || a.y != b.y || a.z != b.z;
-}
-
-template <typename _Tp>
-static inline Point3_<_Tp> operator+(const Point3_<_Tp> &a,
-                                     const Point3_<_Tp> &b) {
-  return Point3_<_Tp>(saturate_cast<_Tp>(a.x + b.x),
-                      saturate_cast<_Tp>(a.y + b.y),
-                      saturate_cast<_Tp>(a.z + b.z));
-}
-
-template <typename _Tp>
-static inline Point3_<_Tp> operator-(const Point3_<_Tp> &a,
-                                     const Point3_<_Tp> &b) {
-  return Point3_<_Tp>(saturate_cast<_Tp>(a.x - b.x),
-                      saturate_cast<_Tp>(a.y - b.y),
-                      saturate_cast<_Tp>(a.z - b.z));
-}
-
-template <typename _Tp>
-static inline Point3_<_Tp> operator-(const Point3_<_Tp> &a) {
-  return Point3_<_Tp>(saturate_cast<_Tp>(-a.x), saturate_cast<_Tp>(-a.y),
-                      saturate_cast<_Tp>(-a.z));
-}
-
-template <typename _Tp>
-static inline Point3_<_Tp> operator*(const Point3_<_Tp> &a, int b) {
-  return Point3_<_Tp>(saturate_cast<_Tp>(a.x * b), saturate_cast<_Tp>(a.y * b),
-                      saturate_cast<_Tp>(a.z * b));
-}
-
-template <typename _Tp>
-static inline Point3_<_Tp> operator*(int a, const Point3_<_Tp> &b) {
-  return Point3_<_Tp>(saturate_cast<_Tp>(b.x * a), saturate_cast<_Tp>(b.y * a),
-                      saturate_cast<_Tp>(b.z * a));
-}
-
-template <typename _Tp>
-static inline Point3_<_Tp> operator*(const Point3_<_Tp> &a, float b) {
-  return Point3_<_Tp>(saturate_cast<_Tp>(a.x * b), saturate_cast<_Tp>(a.y * b),
-                      saturate_cast<_Tp>(a.z * b));
-}
-
-template <typename _Tp>
-static inline Point3_<_Tp> operator*(float a, const Point3_<_Tp> &b) {
-  return Point3_<_Tp>(saturate_cast<_Tp>(b.x * a), saturate_cast<_Tp>(b.y * a),
-                      saturate_cast<_Tp>(b.z * a));
-}
-
-template <typename _Tp>
-static inline Point3_<_Tp> operator*(const Point3_<_Tp> &a, double b) {
-  return Point3_<_Tp>(saturate_cast<_Tp>(a.x * b), saturate_cast<_Tp>(a.y * b),
-                      saturate_cast<_Tp>(a.z * b));
-}
-
-template <typename _Tp>
-static inline Point3_<_Tp> operator*(double a, const Point3_<_Tp> &b) {
-  return Point3_<_Tp>(saturate_cast<_Tp>(b.x * a), saturate_cast<_Tp>(b.y * a),
-                      saturate_cast<_Tp>(b.z * a));
-}
-
-template <typename _Tp>
-static inline Point3_<_Tp> operator*(const Matx<_Tp, 3, 3> &a,
-                                     const Point3_<_Tp> &b) {
-  Matx<_Tp, 3, 1> tmp = a * Vec<_Tp, 3>(b.x, b.y, b.z);
-  return Point3_<_Tp>(tmp.val[0], tmp.val[1], tmp.val[2]);
-}
-
-template <typename _Tp>
-static inline Matx<_Tp, 4, 1> operator*(const Matx<_Tp, 4, 4> &a,
-                                        const Point3_<_Tp> &b) {
-  return a * Matx<_Tp, 4, 1>(b.x, b.y, b.z, 1);
-}
-
-template <typename _Tp>
-static inline Point3_<_Tp> operator/(const Point3_<_Tp> &a, int b) {
-  Point3_<_Tp> tmp(a);
-  tmp /= b;
-  return tmp;
-}
-
-template <typename _Tp>
-static inline Point3_<_Tp> operator/(const Point3_<_Tp> &a, float b) {
-  Point3_<_Tp> tmp(a);
-  tmp /= b;
-  return tmp;
-}
-
-template <typename _Tp>
-static inline Point3_<_Tp> operator/(const Point3_<_Tp> &a, double b) {
-  Point3_<_Tp> tmp(a);
-  tmp /= b;
-  return tmp;
-}
-
-////////////////////////////////// Size /////////////////////////////////
-
-template <typename _Tp> inline Size_<_Tp>::Size_() : width(0), height(0) {}
-
-template <typename _Tp>
-inline Size_<_Tp>::Size_(_Tp _width, _Tp _height)
-    : width(_width), height(_height) {}
-
-template <typename _Tp>
-inline Size_<_Tp>::Size_(const Point_<_Tp> &pt) : width(pt.x), height(pt.y) {}
-
-template <typename _Tp>
-template <typename _Tp2>
-inline Size_<_Tp>::operator Size_<_Tp2>() const {
-  return Size_<_Tp2>(saturate_cast<_Tp2>(width), saturate_cast<_Tp2>(height));
-}
-
-template <typename _Tp> inline _Tp Size_<_Tp>::area() const {
-  const _Tp result = width * height;
-  CV_DbgAssert(!std::numeric_limits<_Tp>::is_integer || width == 0 ||
-               result / width ==
-                   height); // make sure the result fits in the return value
-  return result;
-}
-
-template <typename _Tp> inline double Size_<_Tp>::aspectRatio() const {
-  return width / static_cast<double>(height);
-}
-
-template <typename _Tp> inline bool Size_<_Tp>::empty() const {
-  return width <= 0 || height <= 0;
-}
-
-template <typename _Tp>
-static inline Size_<_Tp> &operator*=(Size_<_Tp> &a, _Tp b) {
-  a.width *= b;
-  a.height *= b;
-  return a;
-}
-
-template <typename _Tp>
-static inline Size_<_Tp> operator*(const Size_<_Tp> &a, _Tp b) {
-  Size_<_Tp> tmp(a);
-  tmp *= b;
-  return tmp;
-}
-
-template <typename _Tp>
-static inline Size_<_Tp> &operator/=(Size_<_Tp> &a, _Tp b) {
-  a.width /= b;
-  a.height /= b;
-  return a;
-}
-
-template <typename _Tp>
-static inline Size_<_Tp> operator/(const Size_<_Tp> &a, _Tp b) {
-  Size_<_Tp> tmp(a);
-  tmp /= b;
-  return tmp;
-}
-
-template <typename _Tp>
-static inline Size_<_Tp> &operator+=(Size_<_Tp> &a, const Size_<_Tp> &b) {
-  a.width += b.width;
-  a.height += b.height;
-  return a;
-}
-
-template <typename _Tp>
-static inline Size_<_Tp> operator+(const Size_<_Tp> &a, const Size_<_Tp> &b) {
-  Size_<_Tp> tmp(a);
-  tmp += b;
-  return tmp;
-}
-
-template <typename _Tp>
-static inline Size_<_Tp> &operator-=(Size_<_Tp> &a, const Size_<_Tp> &b) {
-  a.width -= b.width;
-  a.height -= b.height;
-  return a;
-}
-
-template <typename _Tp>
-static inline Size_<_Tp> operator-(const Size_<_Tp> &a, const Size_<_Tp> &b) {
-  Size_<_Tp> tmp(a);
-  tmp -= b;
-  return tmp;
-}
-
-template <typename _Tp>
-static inline bool operator==(const Size_<_Tp> &a, const Size_<_Tp> &b) {
-  return a.width == b.width && a.height == b.height;
-}
-
-template <typename _Tp>
-static inline bool operator!=(const Size_<_Tp> &a, const Size_<_Tp> &b) {
-  return !(a == b);
-}
-
-////////////////////////////////// Rect /////////////////////////////////
-
-template <typename _Tp>
-inline Rect_<_Tp>::Rect_() : x(0), y(0), width(0), height(0) {}
-
-template <typename _Tp>
-inline Rect_<_Tp>::Rect_(_Tp _x, _Tp _y, _Tp _width, _Tp _height)
-    : x(_x), y(_y), width(_width), height(_height) {}
-
-template <typename _Tp>
-inline Rect_<_Tp>::Rect_(const Point_<_Tp> &org, const Size_<_Tp> &sz)
-    : x(org.x), y(org.y), width(sz.width), height(sz.height) {}
-
-template <typename _Tp>
-inline Rect_<_Tp>::Rect_(const Point_<_Tp> &pt1, const Point_<_Tp> &pt2) {
-  x = std::min(pt1.x, pt2.x);
-  y = std::min(pt1.y, pt2.y);
-  width = std::max(pt1.x, pt2.x) - x;
-  height = std::max(pt1.y, pt2.y) - y;
-}
-
-template <typename _Tp> inline Point_<_Tp> Rect_<_Tp>::tl() const {
-  return Point_<_Tp>(x, y);
-}
-
-template <typename _Tp> inline Point_<_Tp> Rect_<_Tp>::br() const {
-  return Point_<_Tp>(x + width, y + height);
-}
-
-template <typename _Tp> inline Size_<_Tp> Rect_<_Tp>::size() const {
-  return Size_<_Tp>(width, height);
-}
-
-template <typename _Tp> inline _Tp Rect_<_Tp>::area() const {
-  const _Tp result = width * height;
-  CV_DbgAssert(!std::numeric_limits<_Tp>::is_integer || width == 0 ||
-               result / width ==
-                   height); // make sure the result fits in the return value
-  return result;
-}
-
-template <typename _Tp> inline bool Rect_<_Tp>::empty() const {
-  return width <= 0 || height <= 0;
-}
-
-template <typename _Tp>
-template <typename _Tp2>
-inline Rect_<_Tp>::operator Rect_<_Tp2>() const {
-  return Rect_<_Tp2>(saturate_cast<_Tp2>(x), saturate_cast<_Tp2>(y),
-                     saturate_cast<_Tp2>(width), saturate_cast<_Tp2>(height));
-}
-
-template <typename _Tp>
-template <typename _Tp2>
-inline bool Rect_<_Tp>::contains(const Point_<_Tp2> &pt) const {
-  return x <= pt.x && pt.x < x + width && y <= pt.y && pt.y < y + height;
-}
-// See https://github.com/opencv/opencv/issues/26016
-template <>
-template <>
-inline bool Rect_<int>::contains(const Point_<double> &pt) const {
-  // std::numeric_limits<int>::digits is 31.
-  // std::numeric_limits<double>::digits is 53.
-  // So conversion int->double does not lead to accuracy errors.
-  const Rect_<double> _rect(static_cast<double>(x), static_cast<double>(y),
-                            static_cast<double>(width),
-                            static_cast<double>(height));
-  return _rect.contains(pt);
-}
-template <>
-template <>
-inline bool Rect_<int>::contains(const Point_<float> &_pt) const {
-  // std::numeric_limits<float>::digits is 24.
-  // std::numeric_limits<double>::digits is 53.
-  // So conversion float->double does not lead to accuracy errors.
-  return contains(
-      Point_<double>(static_cast<double>(_pt.x), static_cast<double>(_pt.y)));
-}
-
-template <typename _Tp>
-static inline Rect_<_Tp> &operator+=(Rect_<_Tp> &a, const Point_<_Tp> &b) {
-  a.x += b.x;
-  a.y += b.y;
-  return a;
-}
-
-template <typename _Tp>
-static inline Rect_<_Tp> &operator-=(Rect_<_Tp> &a, const Point_<_Tp> &b) {
-  a.x -= b.x;
-  a.y -= b.y;
-  return a;
-}
-
-template <typename _Tp>
-static inline Rect_<_Tp> &operator+=(Rect_<_Tp> &a, const Size_<_Tp> &b) {
-  a.width += b.width;
-  a.height += b.height;
-  return a;
-}
-
-template <typename _Tp>
-static inline Rect_<_Tp> &operator-=(Rect_<_Tp> &a, const Size_<_Tp> &b) {
-  const _Tp width = a.width - b.width;
-  const _Tp height = a.height - b.height;
-  CV_DbgAssert(width >= 0 && height >= 0);
-  a.width = width;
-  a.height = height;
-  return a;
-}
-
-template <typename _Tp>
-static inline Rect_<_Tp> &operator&=(Rect_<_Tp> &a, const Rect_<_Tp> &b) {
-  if (a.empty() || b.empty()) {
-    a = Rect();
-    return a;
-  }
-  const Rect_<_Tp> &Rx_min = (a.x < b.x) ? a : b;
-  const Rect_<_Tp> &Rx_max = (a.x < b.x) ? b : a;
-  const Rect_<_Tp> &Ry_min = (a.y < b.y) ? a : b;
-  const Rect_<_Tp> &Ry_max = (a.y < b.y) ? b : a;
-  // Looking at the formula below, we will compute Rx_min.width - (Rx_max.x -
-  // Rx_min.x) but we want to avoid overflows. Rx_min.width >= 0 and (Rx_max.x -
-  // Rx_min.x) >= 0 by definition so the difference does not overflow. The only
-  // thing that can overflow is (Rx_max.x - Rx_min.x). And it can only overflow
-  // if Rx_min.x < 0. Let us first deal with the following case.
-  if ((Rx_min.x < 0 && Rx_min.x + Rx_min.width < Rx_max.x) ||
-      (Ry_min.y < 0 && Ry_min.y + Ry_min.height < Ry_max.y)) {
-    a = Rect();
-    return a;
-  }
-  // We now know that either Rx_min.x >= 0, or
-  // Rx_min.x < 0 && Rx_min.x + Rx_min.width >= Rx_max.x and therefore
-  // Rx_min.width >= (Rx_max.x - Rx_min.x) which means (Rx_max.x - Rx_min.x)
-  // is inferior to a valid int and therefore does not overflow.
-  a.width = std::min(Rx_min.width - (Rx_max.x - Rx_min.x), Rx_max.width);
-  a.height = std::min(Ry_min.height - (Ry_max.y - Ry_min.y), Ry_max.height);
-  a.x = Rx_max.x;
-  a.y = Ry_max.y;
-  if (a.empty())
-    a = Rect();
-  return a;
-}
-
-template <typename _Tp>
-static inline Rect_<_Tp> &operator|=(Rect_<_Tp> &a, const Rect_<_Tp> &b) {
-  if (a.empty()) {
-    a = b;
-  } else if (!b.empty()) {
-    _Tp x1 = std::min(a.x, b.x);
-    _Tp y1 = std::min(a.y, b.y);
-    a.width = std::max(a.x + a.width, b.x + b.width) - x1;
-    a.height = std::max(a.y + a.height, b.y + b.height) - y1;
-    a.x = x1;
-    a.y = y1;
-  }
-  return a;
-}
-
-template <typename _Tp>
-static inline bool operator==(const Rect_<_Tp> &a, const Rect_<_Tp> &b) {
-  return a.x == b.x && a.y == b.y && a.width == b.width && a.height == b.height;
-}
-
-template <typename _Tp>
-static inline bool operator!=(const Rect_<_Tp> &a, const Rect_<_Tp> &b) {
-  return a.x != b.x || a.y != b.y || a.width != b.width || a.height != b.height;
-}
-
-template <typename _Tp>
-static inline Rect_<_Tp> operator+(const Rect_<_Tp> &a, const Point_<_Tp> &b) {
-  return Rect_<_Tp>(a.x + b.x, a.y + b.y, a.width, a.height);
-}
-
-template <typename _Tp>
-static inline Rect_<_Tp> operator-(const Rect_<_Tp> &a, const Point_<_Tp> &b) {
-  return Rect_<_Tp>(a.x - b.x, a.y - b.y, a.width, a.height);
-}
-
-template <typename _Tp>
-static inline Rect_<_Tp> operator+(const Rect_<_Tp> &a, const Size_<_Tp> &b) {
-  return Rect_<_Tp>(a.x, a.y, a.width + b.width, a.height + b.height);
-}
-
-template <typename _Tp>
-static inline Rect_<_Tp> operator-(const Rect_<_Tp> &a, const Size_<_Tp> &b) {
-  const _Tp width = a.width - b.width;
-  const _Tp height = a.height - b.height;
-  CV_DbgAssert(width >= 0 && height >= 0);
-  return Rect_<_Tp>(a.x, a.y, width, height);
-}
-
-template <typename _Tp>
-static inline Rect_<_Tp> operator&(const Rect_<_Tp> &a, const Rect_<_Tp> &b) {
-  Rect_<_Tp> c = a;
-  return c &= b;
-}
-
-template <typename _Tp>
-static inline Rect_<_Tp> operator|(const Rect_<_Tp> &a, const Rect_<_Tp> &b) {
-  Rect_<_Tp> c = a;
-  return c |= b;
-}
-
-/**
- * @brief measure dissimilarity between two sample sets
- *
- * computes the complement of the Jaccard Index as described in
- * <https://en.wikipedia.org/wiki/Jaccard_index>. For rectangles this reduces to
- * computing the intersection over the union.
- */
-template <typename _Tp>
-static inline double jaccardDistance(const Rect_<_Tp> &a, const Rect_<_Tp> &b) {
-  _Tp Aa = a.area();
-  _Tp Ab = b.area();
-
-  if ((Aa + Ab) <= std::numeric_limits<_Tp>::epsilon()) {
-    // jaccard_index = 1 -> distance = 0
-    return 0.0;
-  }
-
-  double Aab = (a & b).area();
-  // distance = 1 - jaccard_index
-  return 1.0 - Aab / (Aa + Ab - Aab);
-}
-
-/** @brief Finds out if there is any intersection between two rectangles
- *
- * mainly useful for language bindings
- * @param a First rectangle
- * @param b Second rectangle
- * @return the area of the intersection
- */
-CV_EXPORTS_W inline double rectangleIntersectionArea(const Rect2d &a,
-                                                     const Rect2d &b) {
-  return (a & b).area();
-}
-
-////////////////////////////// RotatedRect //////////////////////////////
-
-inline RotatedRect::RotatedRect() : center(), size(), angle(0) {}
-
-inline RotatedRect::RotatedRect(const Point2f &_center, const Size2f &_size,
-                                float _angle)
-    : center(_center), size(_size), angle(_angle) {}
-
-///////////////////////////////// Range /////////////////////////////////
-
-inline Range::Range() : start(0), end(0) {}
-
-inline Range::Range(int _start, int _end) : start(_start), end(_end) {}
-
-inline int Range::size() const { return end - start; }
-
-inline bool Range::empty() const { return start == end; }
-
-inline Range Range::all() { return Range(INT_MIN, INT_MAX); }
-
-static inline bool operator==(const Range &r1, const Range &r2) {
-  return r1.start == r2.start && r1.end == r2.end;
-}
-
-static inline bool operator!=(const Range &r1, const Range &r2) {
-  return !(r1 == r2);
-}
-
-static inline bool operator!(const Range &r) { return r.start == r.end; }
-
-static inline Range operator&(const Range &r1, const Range &r2) {
-  Range r(std::max(r1.start, r2.start), std::min(r1.end, r2.end));
-  r.end = std::max(r.end, r.start);
-  return r;
-}
-
-static inline Range &operator&=(Range &r1, const Range &r2) {
-  r1 = r1 & r2;
-  return r1;
-}
-
-static inline Range operator+(const Range &r1, int delta) {
-  return Range(r1.start + delta, r1.end + delta);
-}
-
-static inline Range operator+(int delta, const Range &r1) {
-  return Range(r1.start + delta, r1.end + delta);
-}
-
-static inline Range operator-(const Range &r1, int delta) {
-  return r1 + (-delta);
-}
-
-///////////////////////////////// Scalar ////////////////////////////////
-
-template <typename _Tp> inline Scalar_<_Tp>::Scalar_() {
-  this->val[0] = this->val[1] = this->val[2] = this->val[3] = 0;
-}
-
-template <typename _Tp>
-inline Scalar_<_Tp>::Scalar_(_Tp v0, _Tp v1, _Tp v2, _Tp v3) {
-  this->val[0] = v0;
-  this->val[1] = v1;
-  this->val[2] = v2;
-  this->val[3] = v3;
-}
-
-template <typename _Tp>
-inline Scalar_<_Tp>::Scalar_(const Scalar_<_Tp> &s) : Vec<_Tp, 4>(s) {}
-
-template <typename _Tp>
-inline Scalar_<_Tp>::Scalar_(Scalar_<_Tp> &&s) CV_NOEXCEPT {
-  this->val[0] = std::move(s.val[0]);
-  this->val[1] = std::move(s.val[1]);
-  this->val[2] = std::move(s.val[2]);
-  this->val[3] = std::move(s.val[3]);
-}
-
-template <typename _Tp>
-inline Scalar_<_Tp> &Scalar_<_Tp>::operator=(const Scalar_<_Tp> &s) {
-  this->val[0] = s.val[0];
-  this->val[1] = s.val[1];
-  this->val[2] = s.val[2];
-  this->val[3] = s.val[3];
-  return *this;
-}
-
-template <typename _Tp>
-inline Scalar_<_Tp> &Scalar_<_Tp>::operator=(Scalar_<_Tp> &&s) CV_NOEXCEPT {
-  this->val[0] = std::move(s.val[0]);
-  this->val[1] = std::move(s.val[1]);
-  this->val[2] = std::move(s.val[2]);
-  this->val[3] = std::move(s.val[3]);
-  return *this;
-}
-
-template <typename _Tp>
-template <typename _Tp2, int cn>
-inline Scalar_<_Tp>::Scalar_(const Vec<_Tp2, cn> &v) {
-  int i;
-  for (i = 0; i < (cn < 4 ? cn : 4); i++)
-    this->val[i] = cv::saturate_cast<_Tp>(v.val[i]);
-  for (; i < 4; i++)
-    this->val[i] = 0;
-}
-
-template <typename _Tp> inline Scalar_<_Tp>::Scalar_(_Tp v0) {
-  this->val[0] = v0;
-  this->val[1] = this->val[2] = this->val[3] = 0;
-}
-
-template <typename _Tp> inline Scalar_<_Tp> Scalar_<_Tp>::all(_Tp v0) {
-  return Scalar_<_Tp>(v0, v0, v0, v0);
-}
-
-template <typename _Tp>
-inline Scalar_<_Tp> Scalar_<_Tp>::mul(const Scalar_<_Tp> &a,
-                                      double scale) const {
-  return Scalar_<_Tp>(saturate_cast<_Tp>(this->val[0] * a.val[0] * scale),
-                      saturate_cast<_Tp>(this->val[1] * a.val[1] * scale),
-                      saturate_cast<_Tp>(this->val[2] * a.val[2] * scale),
-                      saturate_cast<_Tp>(this->val[3] * a.val[3] * scale));
-}
-
-template <typename _Tp> inline Scalar_<_Tp> Scalar_<_Tp>::conj() const {
-  return Scalar_<_Tp>(
-      saturate_cast<_Tp>(this->val[0]), saturate_cast<_Tp>(-this->val[1]),
-      saturate_cast<_Tp>(-this->val[2]), saturate_cast<_Tp>(-this->val[3]));
-}
-
-template <typename _Tp> inline bool Scalar_<_Tp>::isReal() const {
-  return this->val[1] == 0 && this->val[2] == 0 && this->val[3] == 0;
-}
-
-template <typename _Tp>
-template <typename T2>
-inline Scalar_<_Tp>::operator Scalar_<T2>() const {
-  return Scalar_<T2>(
-      saturate_cast<T2>(this->val[0]), saturate_cast<T2>(this->val[1]),
-      saturate_cast<T2>(this->val[2]), saturate_cast<T2>(this->val[3]));
-}
-
-template <typename _Tp>
-static inline Scalar_<_Tp> &operator+=(Scalar_<_Tp> &a, const Scalar_<_Tp> &b) {
-  a.val[0] += b.val[0];
-  a.val[1] += b.val[1];
-  a.val[2] += b.val[2];
-  a.val[3] += b.val[3];
-  return a;
-}
-
-template <typename _Tp>
-static inline Scalar_<_Tp> &operator-=(Scalar_<_Tp> &a, const Scalar_<_Tp> &b) {
-  a.val[0] -= b.val[0];
-  a.val[1] -= b.val[1];
-  a.val[2] -= b.val[2];
-  a.val[3] -= b.val[3];
-  return a;
-}
-
-template <typename _Tp>
-static inline Scalar_<_Tp> &operator*=(Scalar_<_Tp> &a, _Tp v) {
-  a.val[0] *= v;
-  a.val[1] *= v;
-  a.val[2] *= v;
-  a.val[3] *= v;
-  return a;
-}
-
-template <typename _Tp>
-static inline bool operator==(const Scalar_<_Tp> &a, const Scalar_<_Tp> &b) {
-  return a.val[0] == b.val[0] && a.val[1] == b.val[1] && a.val[2] == b.val[2] &&
-         a.val[3] == b.val[3];
-}
-
-template <typename _Tp>
-static inline bool operator!=(const Scalar_<_Tp> &a, const Scalar_<_Tp> &b) {
-  return a.val[0] != b.val[0] || a.val[1] != b.val[1] || a.val[2] != b.val[2] ||
-         a.val[3] != b.val[3];
-}
-
-template <typename _Tp>
-static inline Scalar_<_Tp> operator+(const Scalar_<_Tp> &a,
-                                     const Scalar_<_Tp> &b) {
-  return Scalar_<_Tp>(a.val[0] + b.val[0], a.val[1] + b.val[1],
-                      a.val[2] + b.val[2], a.val[3] + b.val[3]);
-}
-
-template <typename _Tp>
-static inline Scalar_<_Tp> operator-(const Scalar_<_Tp> &a,
-                                     const Scalar_<_Tp> &b) {
-  return Scalar_<_Tp>(saturate_cast<_Tp>(a.val[0] - b.val[0]),
-                      saturate_cast<_Tp>(a.val[1] - b.val[1]),
-                      saturate_cast<_Tp>(a.val[2] - b.val[2]),
-                      saturate_cast<_Tp>(a.val[3] - b.val[3]));
-}
-
-template <typename _Tp>
-static inline Scalar_<_Tp> operator*(const Scalar_<_Tp> &a, _Tp alpha) {
-  return Scalar_<_Tp>(a.val[0] * alpha, a.val[1] * alpha, a.val[2] * alpha,
-                      a.val[3] * alpha);
-}
-
-template <typename _Tp>
-static inline Scalar_<_Tp> operator*(_Tp alpha, const Scalar_<_Tp> &a) {
-  return a * alpha;
-}
-
-template <typename _Tp>
-static inline Scalar_<_Tp> operator-(const Scalar_<_Tp> &a) {
-  return Scalar_<_Tp>(
-      saturate_cast<_Tp>(-a.val[0]), saturate_cast<_Tp>(-a.val[1]),
-      saturate_cast<_Tp>(-a.val[2]), saturate_cast<_Tp>(-a.val[3]));
-}
-
-template <typename _Tp>
-static inline Scalar_<_Tp> operator*(const Scalar_<_Tp> &a,
-                                     const Scalar_<_Tp> &b) {
-  return Scalar_<_Tp>(
-      saturate_cast<_Tp>(a[0] * b[0] - a[1] * b[1] - a[2] * b[2] - a[3] * b[3]),
-      saturate_cast<_Tp>(a[0] * b[1] + a[1] * b[0] + a[2] * b[3] - a[3] * b[2]),
-      saturate_cast<_Tp>(a[0] * b[2] - a[1] * b[3] + a[2] * b[0] + a[3] * b[1]),
-      saturate_cast<_Tp>(a[0] * b[3] + a[1] * b[2] - a[2] * b[1] +
-                         a[3] * b[0]));
-}
-
-template <typename _Tp>
-static inline Scalar_<_Tp> &operator*=(Scalar_<_Tp> &a, const Scalar_<_Tp> &b) {
-  a = a * b;
-  return a;
-}
-
-template <typename _Tp>
-static inline Scalar_<_Tp> operator/(const Scalar_<_Tp> &a, _Tp alpha) {
-  return Scalar_<_Tp>(a.val[0] / alpha, a.val[1] / alpha, a.val[2] / alpha,
-                      a.val[3] / alpha);
-}
-
-template <typename _Tp>
-static inline Scalar_<float> operator/(const Scalar_<float> &a, float alpha) {
-  float s = 1 / alpha;
-  return Scalar_<float>(a.val[0] * s, a.val[1] * s, a.val[2] * s, a.val[3] * s);
-}
-
-template <typename _Tp>
-static inline Scalar_<double> operator/(const Scalar_<double> &a,
-                                        double alpha) {
-  double s = 1 / alpha;
-  return Scalar_<double>(a.val[0] * s, a.val[1] * s, a.val[2] * s,
-                         a.val[3] * s);
-}
-
-template <typename _Tp>
-static inline Scalar_<_Tp> &operator/=(Scalar_<_Tp> &a, _Tp alpha) {
-  a = a / alpha;
-  return a;
-}
-
-template <typename _Tp>
-static inline Scalar_<_Tp> operator/(_Tp a, const Scalar_<_Tp> &b) {
-  _Tp s = a / (b[0] * b[0] + b[1] * b[1] + b[2] * b[2] + b[3] * b[3]);
-  return b.conj() * s;
-}
-
-template <typename _Tp>
-static inline Scalar_<_Tp> operator/(const Scalar_<_Tp> &a,
-                                     const Scalar_<_Tp> &b) {
-  return a * ((_Tp)1 / b);
-}
-
-template <typename _Tp>
-static inline Scalar_<_Tp> &operator/=(Scalar_<_Tp> &a, const Scalar_<_Tp> &b) {
-  a = a / b;
-  return a;
-}
-
-template <typename _Tp>
-static inline Scalar operator*(const Matx<_Tp, 4, 4> &a, const Scalar &b) {
-  Matx<double, 4, 1> c((Matx<double, 4, 4>)a, b, Matx_MatMulOp());
-  return reinterpret_cast<const Scalar &>(c);
-}
-
-template <>
-inline Scalar operator*(const Matx<double, 4, 4> &a, const Scalar &b) {
-  Matx<double, 4, 1> c(a, b, Matx_MatMulOp());
-  return reinterpret_cast<const Scalar &>(c);
-}
-
-//////////////////////////////// KeyPoint ///////////////////////////////
-
-inline KeyPoint::KeyPoint()
-    : pt(0, 0), size(0), angle(-1), response(0), octave(0), class_id(-1) {}
-
-inline KeyPoint::KeyPoint(Point2f _pt, float _size, float _angle,
-                          float _response, int _octave, int _class_id)
-    : pt(_pt), size(_size), angle(_angle), response(_response), octave(_octave),
-      class_id(_class_id) {}
-
-inline KeyPoint::KeyPoint(float x, float y, float _size, float _angle,
-                          float _response, int _octave, int _class_id)
-    : pt(x, y), size(_size), angle(_angle), response(_response),
-      octave(_octave), class_id(_class_id) {}
-
-///////////////////////////////// DMatch ////////////////////////////////
-
-inline DMatch::DMatch()
-    : queryIdx(-1), trainIdx(-1), imgIdx(-1), distance(FLT_MAX) {}
-
-inline DMatch::DMatch(int _queryIdx, int _trainIdx, float _distance)
-    : queryIdx(_queryIdx), trainIdx(_trainIdx), imgIdx(-1),
-      distance(_distance) {}
-
-inline DMatch::DMatch(int _queryIdx, int _trainIdx, int _imgIdx,
-                      float _distance)
-    : queryIdx(_queryIdx), trainIdx(_trainIdx), imgIdx(_imgIdx),
-      distance(_distance) {}
-
-inline bool DMatch::operator<(const DMatch &m) const {
-  return distance < m.distance;
-}
-
-////////////////////////////// TermCriteria /////////////////////////////
-
-inline TermCriteria::TermCriteria() : type(0), maxCount(0), epsilon(0) {}
-
-inline TermCriteria::TermCriteria(int _type, int _maxCount, double _epsilon)
-    : type(_type), maxCount(_maxCount), epsilon(_epsilon) {}
-
-//! @endcond
-
-} // namespace cv
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-#endif // OPENCV_CORE_TYPES_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/types_c.h b/packages/react-native-executorch/third-party/include/opencv2/core/types_c.h
deleted file mode 100644
index b541259743..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/types_c.h
+++ /dev/null
@@ -1,2064 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_CORE_TYPES_H
-#define OPENCV_CORE_TYPES_H
-
-#ifdef CV__ENABLE_C_API_CTORS // invalid C API ctors (must be removed)
-#if defined(_WIN32) && !defined(CV__SKIP_MESSAGE_MALFORMED_C_API_CTORS)
-#error                                                                         \
-    "C API ctors don't work on Win32: https://github.com/opencv/opencv/issues/15990"
-#endif
-#endif
-
-// #define CV__VALIDATE_UNUNITIALIZED_VARS 1  // C++11 & GCC only
-
-#ifdef __cplusplus
-
-#ifdef CV__VALIDATE_UNUNITIALIZED_VARS
-#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
-#define CV_STRUCT_INITIALIZER                                                  \
-  {                                                                            \
-      0,                                                                       \
-  }
-#else
-#if defined(__GNUC__) &&                                                       \
-    __GNUC__ == 4 // GCC 4.x warns on "= {}" initialization, fixed in GCC 5.0
-#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
-#endif
-#define CV_STRUCT_INITIALIZER                                                  \
-  {                                                                            \
-  }
-#endif
-
-#else
-#define CV_STRUCT_INITIALIZER {0}
-#endif
-
-#ifdef HAVE_IPL
-#ifndef __IPL_H__
-#if defined _WIN32
-#include <ipl.h>
-#else
-#include <ipl/ipl.h>
-#endif
-#endif
-#elif defined __IPL_H__
-#define HAVE_IPL
-#endif
-
-#include "opencv2/core/cvdef.h"
-
-#ifndef SKIP_INCLUDES
-#include <assert.h>
-#include <float.h>
-#include <stdlib.h>
-#include <string.h>
-#endif // SKIP_INCLUDES
-
-#ifndef CV_DEFAULT
-#ifdef __cplusplus
-#define CV_DEFAULT(val) = val
-#else
-#define CV_DEFAULT(val)
-#endif
-#endif
-
-#ifndef CV_EXTERN_C_FUNCPTR
-#ifdef __cplusplus
-#define CV_EXTERN_C_FUNCPTR(x)                                                 \
-  extern "C" {                                                                 \
-  typedef x;                                                                   \
-  }
-#else
-#define CV_EXTERN_C_FUNCPTR(x) typedef x
-#endif
-#endif
-
-#ifndef CVAPI
-#define CVAPI(rettype) CV_EXTERN_C CV_EXPORTS rettype CV_CDECL
-#endif
-
-#ifndef CV_IMPL
-#define CV_IMPL CV_EXTERN_C
-#endif
-
-#ifdef __cplusplus
-#include "opencv2/core.hpp"
-#endif
-
-/** @addtogroup core_c
-    @{
-*/
-
-/** @brief This is the "metatype" used *only* as a function parameter.
-
-It denotes that the function accepts arrays of multiple types, such as
-IplImage*, CvMat* or even CvSeq* sometimes. The particular array type is
-determined at runtime by analyzing the first 4 bytes of the header. In C++
-interface the role of CvArr is played by InputArray and OutputArray.
- */
-typedef void CvArr;
-
-typedef int CVStatus;
-
-/** @see cv::Error::Code */
-enum {
-  CV_StsOk = 0,             /**< everything is ok                */
-  CV_StsBackTrace = -1,     /**< pseudo error for back trace     */
-  CV_StsError = -2,         /**< unknown /unspecified error      */
-  CV_StsInternal = -3,      /**< internal error (bad state)      */
-  CV_StsNoMem = -4,         /**< insufficient memory             */
-  CV_StsBadArg = -5,        /**< function arg/param is bad       */
-  CV_StsBadFunc = -6,       /**< unsupported function            */
-  CV_StsNoConv = -7,        /**< iter. didn't converge           */
-  CV_StsAutoTrace = -8,     /**< tracing                         */
-  CV_HeaderIsNull = -9,     /**< image header is NULL            */
-  CV_BadImageSize = -10,    /**< image size is invalid           */
-  CV_BadOffset = -11,       /**< offset is invalid               */
-  CV_BadDataPtr = -12,      /**/
-  CV_BadStep = -13,         /**< image step is wrong, this may happen for a
-                               non-continuous matrix */
-  CV_BadModelOrChSeq = -14, /**/
-  CV_BadNumChannels = -15,  /**< bad number of channels, for example, some
-                               functions accept only single channel matrices */
-  CV_BadNumChannel1U = -16, /**/
-  CV_BadDepth = -17, /**< input image depth is not supported by the function */
-  CV_BadAlphaChannel = -18, /**/
-  CV_BadOrder = -19,        /**< number of dimensions is out of range */
-  CV_BadOrigin = -20,       /**< incorrect input origin               */
-  CV_BadAlign = -21,        /**< incorrect input align                */
-  CV_BadCallBack = -22,     /**/
-  CV_BadTileSize = -23,     /**/
-  CV_BadCOI = -24,          /**< input COI is not supported           */
-  CV_BadROISize = -25,      /**< incorrect input roi                  */
-  CV_MaskIsTiled = -26,     /**/
-  CV_StsNullPtr = -27,      /**< null pointer */
-  CV_StsVecLengthErr = -28, /**< incorrect vector length */
-  CV_StsFilterStructContentErr = -29, /**< incorrect filter structure content */
-  CV_StsKernelStructContentErr = -30, /**< incorrect transform kernel content */
-  CV_StsFilterOffsetErr = -31,        /**< incorrect filter offset value */
-  CV_StsBadSize = -201,   /**< the input/output structure size is incorrect  */
-  CV_StsDivByZero = -202, /**< division by zero */
-  CV_StsInplaceNotSupported = -203, /**< in-place operation is not supported */
-  CV_StsObjectNotFound = -204,      /**< request can't be completed */
-  CV_StsUnmatchedFormats = -205, /**< formats of input/output arrays differ */
-  CV_StsBadFlag = -206,          /**< flag is wrong or not supported */
-  CV_StsBadPoint = -207,         /**< bad CvPoint */
-  CV_StsBadMask = -208, /**< bad format of mask (neither 8uC1 nor 8sC1)*/
-  CV_StsUnmatchedSizes =
-      -209, /**< sizes of input/output structures do not match */
-  CV_StsUnsupportedFormat =
-      -210, /**< the data format/type is not supported by the function*/
-  CV_StsOutOfRange = -211, /**< some of parameters are out of range */
-  CV_StsParseError = -212, /**< invalid syntax/structure of the parsed file */
-  CV_StsNotImplemented =
-      -213, /**< the requested function/feature is not implemented */
-  CV_StsBadMemBlock = -214,     /**< an allocated block has been corrupted */
-  CV_StsAssert = -215,          /**< assertion failed   */
-  CV_GpuNotSupported = -216,    /**< no CUDA support    */
-  CV_GpuApiCallError = -217,    /**< GPU API call error */
-  CV_OpenGlNotSupported = -218, /**< no OpenGL support  */
-  CV_OpenGlApiCallError = -219, /**< OpenGL API call error */
-  CV_OpenCLApiCallError = -220, /**< OpenCL API call error */
-  CV_OpenCLDoubleNotSupported = -221,
-  CV_OpenCLInitError = -222, /**< OpenCL initialization error */
-  CV_OpenCLNoAMDBlasFft = -223
-};
-
-/****************************************************************************************\
-*                             Common macros and inline functions *
-\****************************************************************************************/
-
-/** absolute value without jumps */
-#ifndef __cplusplus
-#define CV_IABS(a) (((a) ^ ((a) < 0 ? -1 : 0)) - ((a) < 0 ? -1 : 0))
-#else
-#define CV_IABS(a) abs(a)
-#endif
-
-#define cvInvSqrt(value) ((float)(1. / sqrt(value)))
-#define cvSqrt(value) ((float)sqrt(value))
-
-/*************** Random number generation *******************/
-
-typedef uint64 CvRNG;
-
-#define CV_RNG_COEFF 4164903690U
-
-/** @brief Initializes a random number generator state.
-
-The function initializes a random number generator and returns the state. The
-pointer to the state can be then passed to the cvRandInt, cvRandReal and
-cvRandArr functions. In the current implementation a multiply-with-carry
-generator is used.
-@param seed 64-bit value used to initiate a random sequence
-@sa the C++ class RNG replaced CvRNG.
- */
-CV_INLINE CvRNG cvRNG(int64 seed CV_DEFAULT(-1)) {
-  CvRNG rng = seed ? (uint64)seed : (uint64)(int64)-1;
-  return rng;
-}
-
-/** @brief Returns a 32-bit unsigned integer and updates RNG.
-
-The function returns a uniformly-distributed random 32-bit unsigned integer and
-updates the RNG state. It is similar to the rand() function from the C runtime
-library, except that OpenCV functions always generates a 32-bit random number,
-regardless of the platform.
-@param rng CvRNG state initialized by cvRNG.
- */
-CV_INLINE unsigned cvRandInt(CvRNG *rng) {
-  uint64 temp = *rng;
-  temp = (uint64)(unsigned)temp * CV_RNG_COEFF + (temp >> 32);
-  *rng = temp;
-  return (unsigned)temp;
-}
-
-/** @brief Returns a floating-point random number and updates RNG.
-
-The function returns a uniformly-distributed random floating-point number
-between 0 and 1 (1 is not included).
-@param rng RNG state initialized by cvRNG
- */
-CV_INLINE double cvRandReal(CvRNG *rng) {
-  return cvRandInt(rng) * 2.3283064365386962890625e-10 /* 2^-32 */;
-}
-
-/****************************************************************************************\
-*                                  Image type (IplImage) *
-\****************************************************************************************/
-
-#ifndef HAVE_IPL
-
-/*
- * The following definitions (until #endif)
- * is an extract from IPL headers.
- * Copyright (c) 1995 Intel Corporation.
- */
-#define IPL_DEPTH_SIGN 0x80000000
-
-#define IPL_DEPTH_1U 1
-#define IPL_DEPTH_8U 8
-#define IPL_DEPTH_16U 16
-#define IPL_DEPTH_32F 32
-
-#define IPL_DEPTH_8S (IPL_DEPTH_SIGN | 8)
-#define IPL_DEPTH_16S (IPL_DEPTH_SIGN | 16)
-#define IPL_DEPTH_32S (IPL_DEPTH_SIGN | 32)
-
-#define IPL_DATA_ORDER_PIXEL 0
-#define IPL_DATA_ORDER_PLANE 1
-
-#define IPL_ORIGIN_TL 0
-#define IPL_ORIGIN_BL 1
-
-#define IPL_ALIGN_4BYTES 4
-#define IPL_ALIGN_8BYTES 8
-#define IPL_ALIGN_16BYTES 16
-#define IPL_ALIGN_32BYTES 32
-
-#define IPL_ALIGN_DWORD IPL_ALIGN_4BYTES
-#define IPL_ALIGN_QWORD IPL_ALIGN_8BYTES
-
-#define IPL_BORDER_CONSTANT 0
-#define IPL_BORDER_REPLICATE 1
-#define IPL_BORDER_REFLECT 2
-#define IPL_BORDER_WRAP 3
-
-#ifdef __cplusplus
-typedef struct _IplImage IplImage;
-CV_EXPORTS _IplImage cvIplImage(const cv::Mat &m);
-#endif
-
-/** The IplImage is taken from the Intel Image Processing Library, in which the
-format is native. OpenCV only supports a subset of possible IplImage formats, as
-outlined in the parameter list above.
-
-In addition to the above restrictions, OpenCV handles ROIs differently. OpenCV
-functions require that the image size or ROI size of all source and destination
-images match exactly. On the other hand, the Intel Image Processing Library
-processes the area of intersection between the source and destination images (or
-ROIs), allowing them to vary independently.
-*/
-typedef struct _IplImage {
-  int nSize;        /**< sizeof(IplImage) */
-  int ID;           /**< version (=0)*/
-  int nChannels;    /**< Most of OpenCV functions support 1,2,3 or 4 channels */
-  int alphaChannel; /**< Ignored by OpenCV */
-  int depth;        /**< Pixel depth in bits: IPL_DEPTH_8U, IPL_DEPTH_8S,
-                       IPL_DEPTH_16S,        IPL_DEPTH_32S, IPL_DEPTH_32F and
-                       IPL_DEPTH_64F        are supported.  */
-  char colorModel[4];  /**< Ignored by OpenCV */
-  char channelSeq[4];  /**< ditto */
-  int dataOrder;       /**< 0 - interleaved color channels, 1 - separate color
-                          channels.       cvCreateImage can only create interleaved
-                          images
-                        */
-  int origin;          /**< 0 - top-left origin,
-                          1 - bottom-left origin (Windows bitmaps style).  */
-  int align;           /**< Alignment of image rows (4 or 8).
-                          OpenCV ignores it and uses widthStep instead.    */
-  int width;           /**< Image width in pixels.                           */
-  int height;          /**< Image height in pixels.                          */
-  struct _IplROI *roi; /**< Image ROI. If NULL, the whole image is selected. */
-  struct _IplImage *maskROI;     /**< Must be NULL. */
-  void *imageId;                 /**< "           " */
-  struct _IplTileInfo *tileInfo; /**< "           " */
-  int imageSize;                 /**< Image data size in bytes
-                                    (==image->height*image->widthStep
-                                    in case of interleaved data)*/
-  char *imageData;               /**< Pointer to aligned image data.         */
-  int widthStep;                 /**< Size of aligned image row in bytes.    */
-  int BorderMode[4];             /**< Ignored by OpenCV.                     */
-  int BorderConst[4];            /**< Ditto.                                 */
-  char *imageDataOrigin;         /**< Pointer to very origin of image data
-                                    (not necessarily aligned) -
-                                    needed for correct deallocation */
-
-#if defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus)
-  _IplImage() {
-    memset(this, 0, sizeof(*this)); // valid for POD structure
-    nSize = sizeof(IplImage);
-  }
-  _IplImage(const cv::Mat &m) { *this = cvIplImage(m); }
-#endif
-} IplImage;
-
-CV_INLINE IplImage cvIplImage() {
-#if !(defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus))
-  IplImage self = CV_STRUCT_INITIALIZER;
-  self.nSize = sizeof(IplImage);
-  return self;
-#else
-  return _IplImage();
-#endif
-}
-
-typedef struct _IplTileInfo IplTileInfo;
-
-typedef struct _IplROI {
-  int coi; /**< 0 - no COI (all channels are selected), 1 - 0th channel is
-              selected ...*/
-  int xOffset;
-  int yOffset;
-  int width;
-  int height;
-} IplROI;
-
-typedef struct _IplConvKernel {
-  int nCols;
-  int nRows;
-  int anchorX;
-  int anchorY;
-  int *values;
-  int nShiftR;
-} IplConvKernel;
-
-typedef struct _IplConvKernelFP {
-  int nCols;
-  int nRows;
-  int anchorX;
-  int anchorY;
-  float *values;
-} IplConvKernelFP;
-
-#define IPL_IMAGE_HEADER 1
-#define IPL_IMAGE_DATA 2
-#define IPL_IMAGE_ROI 4
-
-#endif /*HAVE_IPL*/
-
-/** extra border mode */
-#define IPL_BORDER_REFLECT_101 4
-#define IPL_BORDER_TRANSPARENT 5
-
-#define IPL_IMAGE_MAGIC_VAL ((int)sizeof(IplImage))
-#define CV_TYPE_NAME_IMAGE "opencv-image"
-
-#define CV_IS_IMAGE_HDR(img)                                                   \
-  ((img) != NULL && ((const IplImage *)(img))->nSize == sizeof(IplImage))
-
-#define CV_IS_IMAGE(img)                                                       \
-  (CV_IS_IMAGE_HDR(img) && ((IplImage *)img)->imageData != NULL)
-
-/** for storing double-precision
-   floating point data in IplImage's */
-#define IPL_DEPTH_64F 64
-
-/** get reference to pixel at (col,row),
-   for multi-channel images (col) should be multiplied by number of channels */
-#define CV_IMAGE_ELEM(image, elemtype, row, col)                               \
-  (((elemtype *)((image)->imageData + (image)->widthStep * (row)))[(col)])
-
-/****************************************************************************************\
-*                                  Matrix type (CvMat) *
-\****************************************************************************************/
-
-#define CV_AUTO_STEP 0x7fffffff
-#define CV_WHOLE_ARR cvSlice(0, 0x3fffffff)
-
-#define CV_MAGIC_MASK 0xFFFF0000
-#define CV_MAT_MAGIC_VAL 0x42420000
-#define CV_TYPE_NAME_MAT "opencv-matrix"
-
-#ifdef __cplusplus
-typedef struct CvMat CvMat;
-CV_INLINE CvMat cvMat(const cv::Mat &m);
-#endif
-
-/** Matrix elements are stored row by row. Element (i, j) (i - 0-based row
-index, j - 0-based column index) of a matrix can be retrieved or modified using
-CV_MAT_ELEM macro:
-
-    uchar pixval = CV_MAT_ELEM(grayimg, uchar, i, j)
-    CV_MAT_ELEM(cameraMatrix, float, 0, 2) = image.width*0.5f;
-
-To access multiple-channel matrices, you can use
-CV_MAT_ELEM(matrix, type, i, j\*nchannels + channel_idx).
-
-@deprecated CvMat is now obsolete; consider using Mat instead.
- */
-typedef struct CvMat {
-  int type;
-  int step;
-
-  /* for internal use only */
-  int *refcount;
-  int hdr_refcount;
-
-  union {
-    uchar *ptr;
-    short *s;
-    int *i;
-    float *fl;
-    double *db;
-  } data;
-
-#ifdef __cplusplus
-  union {
-    int rows;
-    int height;
-  };
-
-  union {
-    int cols;
-    int width;
-  };
-#else
-  int rows;
-  int cols;
-#endif
-
-#if defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus)
-  CvMat() {}
-  CvMat(const cv::Mat &m) { *this = cvMat(m); }
-#endif
-} CvMat;
-
-#define CV_IS_MAT_HDR(mat)                                                     \
-  ((mat) != NULL &&                                                            \
-   (((const CvMat *)(mat))->type & CV_MAGIC_MASK) == CV_MAT_MAGIC_VAL &&       \
-   ((const CvMat *)(mat))->cols > 0 && ((const CvMat *)(mat))->rows > 0)
-
-#define CV_IS_MAT_HDR_Z(mat)                                                   \
-  ((mat) != NULL &&                                                            \
-   (((const CvMat *)(mat))->type & CV_MAGIC_MASK) == CV_MAT_MAGIC_VAL &&       \
-   ((const CvMat *)(mat))->cols >= 0 && ((const CvMat *)(mat))->rows >= 0)
-
-#define CV_IS_MAT(mat)                                                         \
-  (CV_IS_MAT_HDR(mat) && ((const CvMat *)(mat))->data.ptr != NULL)
-
-#define CV_IS_MASK_ARR(mat) (((mat)->type & (CV_MAT_TYPE_MASK & ~CV_8SC1)) == 0)
-
-#define CV_ARE_TYPES_EQ(mat1, mat2)                                            \
-  ((((mat1)->type ^ (mat2)->type) & CV_MAT_TYPE_MASK) == 0)
-
-#define CV_ARE_CNS_EQ(mat1, mat2)                                              \
-  ((((mat1)->type ^ (mat2)->type) & CV_MAT_CN_MASK) == 0)
-
-#define CV_ARE_DEPTHS_EQ(mat1, mat2)                                           \
-  ((((mat1)->type ^ (mat2)->type) & CV_MAT_DEPTH_MASK) == 0)
-
-#define CV_ARE_SIZES_EQ(mat1, mat2)                                            \
-  ((mat1)->rows == (mat2)->rows && (mat1)->cols == (mat2)->cols)
-
-#define CV_IS_MAT_CONST(mat) (((mat)->rows | (mat)->cols) == 1)
-
-#define IPL2CV_DEPTH(depth)                                                    \
-  ((((CV_8U) + (CV_16U << 4) + (CV_32F << 8) + (CV_64F << 16) +                \
-     (CV_8S << 20) + (CV_16S << 24) + (CV_32S << 28)) >>                       \
-    ((((depth) & 0xF0) >> 2) + (((depth) & IPL_DEPTH_SIGN) ? 20 : 0))) &       \
-   15)
-
-/** Inline constructor. No data is allocated internally!!!
- * (Use together with cvCreateData, or use cvCreateMat instead to
- * get a matrix with allocated data):
- */
-CV_INLINE CvMat cvMat(int rows, int cols, int type,
-                      void *data CV_DEFAULT(NULL)) {
-  CvMat m;
-
-  assert((unsigned)CV_MAT_DEPTH(type) <= CV_64F);
-  type = CV_MAT_TYPE(type);
-  m.type = CV_MAT_MAGIC_VAL | CV_MAT_CONT_FLAG | type;
-  m.cols = cols;
-  m.rows = rows;
-  m.step = m.cols * CV_ELEM_SIZE(type);
-  m.data.ptr = (uchar *)data;
-  m.refcount = NULL;
-  m.hdr_refcount = 0;
-
-  return m;
-}
-
-#ifdef __cplusplus
-
-CV_INLINE CvMat cvMat(const cv::Mat &m) {
-  CvMat self;
-  CV_DbgAssert(m.dims <= 2);
-  self = cvMat(m.rows, m.dims == 1 ? 1 : m.cols, m.type(), m.data);
-  self.step = (int)m.step[0];
-  self.type = (self.type & ~cv::Mat::CONTINUOUS_FLAG) |
-              (m.flags & cv::Mat::CONTINUOUS_FLAG);
-  return self;
-}
-CV_INLINE CvMat cvMat() {
-#if !defined(CV__ENABLE_C_API_CTORS)
-  CvMat self = CV_STRUCT_INITIALIZER;
-  return self;
-#else
-  return CvMat();
-#endif
-}
-CV_INLINE CvMat cvMat(const CvMat &m) {
-#if !defined(CV__ENABLE_C_API_CTORS)
-  CvMat self = CV_STRUCT_INITIALIZER;
-  memcpy(&self, &m, sizeof(self));
-  return self;
-#else
-  return CvMat(m);
-#endif
-}
-
-#endif // __cplusplus
-
-#define CV_MAT_ELEM_PTR_FAST(mat, row, col, pix_size)                          \
-  (assert((unsigned)(row) < (unsigned)(mat).rows &&                            \
-          (unsigned)(col) < (unsigned)(mat).cols),                             \
-   (mat).data.ptr + (size_t)(mat).step * (row) + (pix_size) * (col))
-
-#define CV_MAT_ELEM_PTR(mat, row, col)                                         \
-  CV_MAT_ELEM_PTR_FAST(mat, row, col, CV_ELEM_SIZE((mat).type))
-
-#define CV_MAT_ELEM(mat, elemtype, row, col)                                   \
-  (*(elemtype *)CV_MAT_ELEM_PTR_FAST(mat, row, col, sizeof(elemtype)))
-
-/** @brief Returns the particular element of single-channel floating-point
-matrix.
-
-The function is a fast replacement for cvGetReal2D in the case of single-channel
-floating-point matrices. It is faster because it is inline, it does fewer checks
-for array type and array element type, and it checks for the row and column
-ranges only in debug mode.
-@param mat Input matrix
-@param row The zero-based index of row
-@param col The zero-based index of column
- */
-CV_INLINE double cvmGet(const CvMat *mat, int row, int col) {
-  int type;
-
-  type = CV_MAT_TYPE(mat->type);
-  assert((unsigned)row < (unsigned)mat->rows &&
-         (unsigned)col < (unsigned)mat->cols);
-
-  if (type == CV_32FC1)
-    return ((float *)(void *)(mat->data.ptr + (size_t)mat->step * row))[col];
-  else {
-    assert(type == CV_64FC1);
-    return ((double *)(void *)(mat->data.ptr + (size_t)mat->step * row))[col];
-  }
-}
-
-/** @brief Sets a specific element of a single-channel floating-point matrix.
-
-The function is a fast replacement for cvSetReal2D in the case of single-channel
-floating-point matrices. It is faster because it is inline, it does fewer checks
-for array type and array element type, and it checks for the row and column
-ranges only in debug mode.
-@param mat The matrix
-@param row The zero-based index of row
-@param col The zero-based index of column
-@param value The new value of the matrix element
- */
-CV_INLINE void cvmSet(CvMat *mat, int row, int col, double value) {
-  int type;
-  type = CV_MAT_TYPE(mat->type);
-  assert((unsigned)row < (unsigned)mat->rows &&
-         (unsigned)col < (unsigned)mat->cols);
-
-  if (type == CV_32FC1)
-    ((float *)(void *)(mat->data.ptr + (size_t)mat->step * row))[col] =
-        (float)value;
-  else {
-    assert(type == CV_64FC1);
-    ((double *)(void *)(mat->data.ptr + (size_t)mat->step * row))[col] = value;
-  }
-}
-
-CV_INLINE int cvIplDepth(int type) {
-  int depth = CV_MAT_DEPTH(type);
-  return CV_ELEM_SIZE1(depth) * 8 |
-         (depth == CV_8S || depth == CV_16S || depth == CV_32S ? IPL_DEPTH_SIGN
-                                                               : 0);
-}
-
-/****************************************************************************************\
-*                       Multi-dimensional dense array (CvMatND) *
-\****************************************************************************************/
-
-#define CV_MATND_MAGIC_VAL 0x42430000
-#define CV_TYPE_NAME_MATND "opencv-nd-matrix"
-
-#ifdef __cplusplus
-typedef struct CvMatND CvMatND;
-CV_EXPORTS CvMatND cvMatND(const cv::Mat &m);
-#endif
-
-/**
-  @deprecated consider using cv::Mat instead
-  */
-typedef struct CvMatND {
-  int type;
-  int dims;
-
-  int *refcount;
-  int hdr_refcount;
-
-  union {
-    uchar *ptr;
-    float *fl;
-    double *db;
-    int *i;
-    short *s;
-  } data;
-
-  struct {
-    int size;
-    int step;
-  } dim[CV_MAX_DIM];
-
-#if defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus)
-  CvMatND() {}
-  CvMatND(const cv::Mat &m) { *this = cvMatND(m); }
-#endif
-} CvMatND;
-
-CV_INLINE CvMatND cvMatND() {
-#if !(defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus))
-  CvMatND self = CV_STRUCT_INITIALIZER;
-  return self;
-#else
-  return CvMatND();
-#endif
-}
-
-#define CV_IS_MATND_HDR(mat)                                                   \
-  ((mat) != NULL &&                                                            \
-   (((const CvMatND *)(mat))->type & CV_MAGIC_MASK) == CV_MATND_MAGIC_VAL)
-
-#define CV_IS_MATND(mat)                                                       \
-  (CV_IS_MATND_HDR(mat) && ((const CvMatND *)(mat))->data.ptr != NULL)
-
-/****************************************************************************************\
-*                      Multi-dimensional sparse array (CvSparseMat) *
-\****************************************************************************************/
-
-#define CV_SPARSE_MAT_MAGIC_VAL 0x42440000
-#define CV_TYPE_NAME_SPARSE_MAT "opencv-sparse-matrix"
-
-struct CvSet;
-
-typedef struct CvSparseMat {
-  int type;
-  int dims;
-  int *refcount;
-  int hdr_refcount;
-
-  struct CvSet *heap;
-  void **hashtable;
-  int hashsize;
-  int valoffset;
-  int idxoffset;
-  int size[CV_MAX_DIM];
-
-#ifdef __cplusplus
-  CV_EXPORTS void copyToSparseMat(cv::SparseMat &m) const;
-#endif
-} CvSparseMat;
-
-#ifdef __cplusplus
-CV_EXPORTS CvSparseMat *cvCreateSparseMat(const cv::SparseMat &m);
-#endif
-
-#define CV_IS_SPARSE_MAT_HDR(mat)                                              \
-  ((mat) != NULL && (((const CvSparseMat *)(mat))->type & CV_MAGIC_MASK) ==    \
-                        CV_SPARSE_MAT_MAGIC_VAL)
-
-#define CV_IS_SPARSE_MAT(mat) CV_IS_SPARSE_MAT_HDR(mat)
-
-/**************** iteration through a sparse array *****************/
-
-typedef struct CvSparseNode {
-  unsigned hashval;
-  struct CvSparseNode *next;
-} CvSparseNode;
-
-typedef struct CvSparseMatIterator {
-  CvSparseMat *mat;
-  CvSparseNode *node;
-  int curidx;
-} CvSparseMatIterator;
-
-#define CV_NODE_VAL(mat, node) ((void *)((uchar *)(node) + (mat)->valoffset))
-#define CV_NODE_IDX(mat, node) ((int *)((uchar *)(node) + (mat)->idxoffset))
-
-/****************************************************************************************\
-*                                         Histogram *
-\****************************************************************************************/
-
-typedef int CvHistType;
-
-#define CV_HIST_MAGIC_VAL 0x42450000
-#define CV_HIST_UNIFORM_FLAG (1 << 10)
-
-/** indicates whether bin ranges are set already or not */
-#define CV_HIST_RANGES_FLAG (1 << 11)
-
-#define CV_HIST_ARRAY 0
-#define CV_HIST_SPARSE 1
-#define CV_HIST_TREE CV_HIST_SPARSE
-
-/** should be used as a parameter only,
-   it turns to CV_HIST_UNIFORM_FLAG of hist->type */
-#define CV_HIST_UNIFORM 1
-
-typedef struct CvHistogram {
-  int type;
-  CvArr *bins;
-  float thresh[CV_MAX_DIM][2]; /**< For uniform histograms. */
-  float **thresh2; /**< For non-uniform histograms.                  */
-  CvMatND mat;     /**< Embedded matrix header for array histograms. */
-} CvHistogram;
-
-#define CV_IS_HIST(hist)                                                       \
-  ((hist) != NULL &&                                                           \
-   (((CvHistogram *)(hist))->type & CV_MAGIC_MASK) == CV_HIST_MAGIC_VAL &&     \
-   (hist)->bins != NULL)
-
-#define CV_IS_UNIFORM_HIST(hist) (((hist)->type & CV_HIST_UNIFORM_FLAG) != 0)
-
-#define CV_IS_SPARSE_HIST(hist) CV_IS_SPARSE_MAT((hist)->bins)
-
-#define CV_HIST_HAS_RANGES(hist) (((hist)->type & CV_HIST_RANGES_FLAG) != 0)
-
-/****************************************************************************************\
-*                      Other supplementary data type definitions *
-\****************************************************************************************/
-
-/*************************************** CvRect
- * *****************************************/
-/** @sa Rect_ */
-typedef struct CvRect {
-  int x;
-  int y;
-  int width;
-  int height;
-
-#ifdef CV__VALIDATE_UNUNITIALIZED_VARS
-  CvRect() __attribute__((warning("Non-initialized variable"))) {};
-  template <typename _Tp> CvRect(const std::initializer_list<_Tp> list) {
-    CV_Assert(list.size() == 0 || list.size() == 4);
-    x = y = width = height = 0;
-    if (list.size() == 4) {
-      x = list.begin()[0];
-      y = list.begin()[1];
-      width = list.begin()[2];
-      height = list.begin()[3];
-    }
-  };
-#elif defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus)
-  CvRect(int _x = 0, int _y = 0, int w = 0, int h = 0)
-      : x(_x), y(_y), width(w), height(h) {}
-  template <typename _Tp>
-  CvRect(const cv::Rect_<_Tp> &r)
-      : x(cv::saturate_cast<int>(r.x)), y(cv::saturate_cast<int>(r.y)),
-        width(cv::saturate_cast<int>(r.width)),
-        height(cv::saturate_cast<int>(r.height)) {}
-#endif
-#ifdef __cplusplus
-  template <typename _Tp> operator cv::Rect_<_Tp>() const {
-    return cv::Rect_<_Tp>((_Tp)x, (_Tp)y, (_Tp)width, (_Tp)height);
-  }
-#endif
-} CvRect;
-
-/** constructs CvRect structure. */
-CV_INLINE CvRect cvRect(int x, int y, int width, int height) {
-#if !(defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus))
-  CvRect r = {x, y, width, height};
-#else
-  CvRect r(x, y, width, height);
-#endif
-  return r;
-}
-#ifdef __cplusplus
-CV_INLINE CvRect cvRect(const cv::Rect &rc) {
-  return cvRect(rc.x, rc.y, rc.width, rc.height);
-}
-#endif
-
-CV_INLINE IplROI cvRectToROI(CvRect rect, int coi) {
-  IplROI roi;
-  roi.xOffset = rect.x;
-  roi.yOffset = rect.y;
-  roi.width = rect.width;
-  roi.height = rect.height;
-  roi.coi = coi;
-
-  return roi;
-}
-
-CV_INLINE CvRect cvROIToRect(IplROI roi) {
-  return cvRect(roi.xOffset, roi.yOffset, roi.width, roi.height);
-}
-
-/*********************************** CvTermCriteria
- * *************************************/
-
-#define CV_TERMCRIT_ITER 1
-#define CV_TERMCRIT_NUMBER CV_TERMCRIT_ITER
-#define CV_TERMCRIT_EPS 2
-
-/** @sa TermCriteria
- */
-typedef struct CvTermCriteria {
-  int type; /**< may be combination of
-               CV_TERMCRIT_ITER
-               CV_TERMCRIT_EPS */
-  int max_iter;
-  double epsilon;
-#if defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus)
-  CvTermCriteria(int _type = 0, int _iter = 0, double _eps = 0)
-      : type(_type), max_iter(_iter), epsilon(_eps) {}
-  CvTermCriteria(const cv::TermCriteria &t)
-      : type(t.type), max_iter(t.maxCount), epsilon(t.epsilon) {}
-#endif
-#ifdef __cplusplus
-  operator cv::TermCriteria() const {
-    return cv::TermCriteria(type, max_iter, epsilon);
-  }
-#endif
-} CvTermCriteria;
-
-CV_INLINE CvTermCriteria cvTermCriteria(int type, int max_iter,
-                                        double epsilon) {
-#if !(defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus))
-  CvTermCriteria t = {type, max_iter, (float)epsilon};
-#else
-  CvTermCriteria t(type, max_iter, epsilon);
-#endif
-  return t;
-}
-#ifdef __cplusplus
-CV_INLINE CvTermCriteria cvTermCriteria(const cv::TermCriteria &t) {
-  return cvTermCriteria(t.type, t.maxCount, t.epsilon);
-}
-#endif
-
-/******************************* CvPoint and variants
- * ***********************************/
-
-typedef struct CvPoint {
-  int x;
-  int y;
-
-#ifdef CV__VALIDATE_UNUNITIALIZED_VARS
-  CvPoint() __attribute__((warning("Non-initialized variable"))) {}
-  template <typename _Tp> CvPoint(const std::initializer_list<_Tp> list) {
-    CV_Assert(list.size() == 0 || list.size() == 2);
-    x = y = 0;
-    if (list.size() == 2) {
-      x = list.begin()[0];
-      y = list.begin()[1];
-    }
-  };
-#elif defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus)
-  CvPoint(int _x = 0, int _y = 0) : x(_x), y(_y) {}
-  template <typename _Tp>
-  CvPoint(const cv::Point_<_Tp> &pt) : x((int)pt.x), y((int)pt.y) {}
-#endif
-#ifdef __cplusplus
-  template <typename _Tp> operator cv::Point_<_Tp>() const {
-    return cv::Point_<_Tp>(cv::saturate_cast<_Tp>(x),
-                           cv::saturate_cast<_Tp>(y));
-  }
-#endif
-} CvPoint;
-
-/** constructs CvPoint structure. */
-CV_INLINE CvPoint cvPoint(int x, int y) {
-#if !(defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus))
-  CvPoint p = {x, y};
-#else
-  CvPoint p(x, y);
-#endif
-  return p;
-}
-#ifdef __cplusplus
-CV_INLINE CvPoint cvPoint(const cv::Point &pt) { return cvPoint(pt.x, pt.y); }
-#endif
-
-typedef struct CvPoint2D32f {
-  float x;
-  float y;
-
-#ifdef CV__VALIDATE_UNUNITIALIZED_VARS
-  CvPoint2D32f() __attribute__((warning("Non-initialized variable"))) {}
-  template <typename _Tp> CvPoint2D32f(const std::initializer_list<_Tp> list) {
-    CV_Assert(list.size() == 0 || list.size() == 2);
-    x = y = 0;
-    if (list.size() == 2) {
-      x = list.begin()[0];
-      y = list.begin()[1];
-    }
-  };
-#elif defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus)
-  CvPoint2D32f(float _x = 0, float _y = 0) : x(_x), y(_y) {}
-  template <typename _Tp>
-  CvPoint2D32f(const cv::Point_<_Tp> &pt) : x((float)pt.x), y((float)pt.y) {}
-#endif
-#ifdef __cplusplus
-  template <typename _Tp> operator cv::Point_<_Tp>() const {
-    return cv::Point_<_Tp>(cv::saturate_cast<_Tp>(x),
-                           cv::saturate_cast<_Tp>(y));
-  }
-#endif
-} CvPoint2D32f;
-
-/** constructs CvPoint2D32f structure. */
-CV_INLINE CvPoint2D32f cvPoint2D32f(double x, double y) {
-#if !(defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus))
-  CvPoint2D32f p = {(float)x, (float)y};
-#else
-  CvPoint2D32f p((float)x, (float)y);
-#endif
-  return p;
-}
-
-#ifdef __cplusplus
-template <typename _Tp> CvPoint2D32f cvPoint2D32f(const cv::Point_<_Tp> &pt) {
-#if !(defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus))
-  CvPoint2D32f p = {(float)pt.x, (float)pt.y};
-#else
-  CvPoint2D32f p((float)pt.x, (float)pt.y);
-#endif
-  return p;
-}
-#endif
-
-/** converts CvPoint to CvPoint2D32f. */
-CV_INLINE CvPoint2D32f cvPointTo32f(CvPoint point) {
-  return cvPoint2D32f((float)point.x, (float)point.y);
-}
-
-/** converts CvPoint2D32f to CvPoint. */
-CV_INLINE CvPoint cvPointFrom32f(CvPoint2D32f point) {
-#if !(defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus))
-  CvPoint ipt = {cvRound(point.x), cvRound(point.y)};
-#else
-  CvPoint ipt(cvRound(point.x), cvRound(point.y));
-#endif
-  return ipt;
-}
-
-typedef struct CvPoint3D32f {
-  float x;
-  float y;
-  float z;
-
-#ifdef CV__VALIDATE_UNUNITIALIZED_VARS
-  CvPoint3D32f() __attribute__((warning("Non-initialized variable"))) {}
-  template <typename _Tp> CvPoint3D32f(const std::initializer_list<_Tp> list) {
-    CV_Assert(list.size() == 0 || list.size() == 3);
-    x = y = z = 0;
-    if (list.size() == 3) {
-      x = list.begin()[0];
-      y = list.begin()[1];
-      z = list.begin()[2];
-    }
-  };
-#elif defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus)
-  CvPoint3D32f(float _x = 0, float _y = 0, float _z = 0)
-      : x(_x), y(_y), z(_z) {}
-  template <typename _Tp>
-  CvPoint3D32f(const cv::Point3_<_Tp> &pt)
-      : x((float)pt.x), y((float)pt.y), z((float)pt.z) {}
-#endif
-#ifdef __cplusplus
-  template <typename _Tp> operator cv::Point3_<_Tp>() const {
-    return cv::Point3_<_Tp>(cv::saturate_cast<_Tp>(x),
-                            cv::saturate_cast<_Tp>(y),
-                            cv::saturate_cast<_Tp>(z));
-  }
-#endif
-} CvPoint3D32f;
-
-/** constructs CvPoint3D32f structure. */
-CV_INLINE CvPoint3D32f cvPoint3D32f(double x, double y, double z) {
-#if !(defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus))
-  CvPoint3D32f p = {(float)x, (float)y, (float)z};
-#else
-  CvPoint3D32f p((float)x, (float)y, (float)z);
-#endif
-  return p;
-}
-
-#ifdef __cplusplus
-template <typename _Tp> CvPoint3D32f cvPoint3D32f(const cv::Point3_<_Tp> &pt) {
-#if !(defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus))
-  CvPoint3D32f p = {(float)pt.x, (float)pt.y, (float)pt.z};
-#else
-  CvPoint3D32f p((float)pt.x, (float)pt.y, (float)pt.z);
-#endif
-  return p;
-}
-#endif
-
-typedef struct CvPoint2D64f {
-  double x;
-  double y;
-#ifdef CV__VALIDATE_UNUNITIALIZED_VARS
-  CvPoint2D64f() __attribute__((warning("Non-initialized variable"))) {}
-  template <typename _Tp> CvPoint2D64f(const std::initializer_list<_Tp> list) {
-    CV_Assert(list.size() == 0 || list.size() == 2);
-    x = y = 0;
-    if (list.size() == 2) {
-      x = list.begin()[0];
-      y = list.begin()[1];
-    }
-  };
-#endif
-} CvPoint2D64f;
-
-/** constructs CvPoint2D64f structure.*/
-CV_INLINE CvPoint2D64f cvPoint2D64f(double x, double y) {
-  CvPoint2D64f p = {x, y};
-  return p;
-}
-
-typedef struct CvPoint3D64f {
-  double x;
-  double y;
-  double z;
-#ifdef CV__VALIDATE_UNUNITIALIZED_VARS
-  CvPoint3D64f() __attribute__((warning("Non-initialized variable"))) {}
-  template <typename _Tp> CvPoint3D64f(const std::initializer_list<_Tp> list) {
-    CV_Assert(list.size() == 0 || list.size() == 3);
-    x = y = z = 0;
-    if (list.size() == 3) {
-      x = list.begin()[0];
-      y = list.begin()[1];
-      z = list.begin()[2];
-    }
-  };
-#endif
-} CvPoint3D64f;
-
-/** constructs CvPoint3D64f structure. */
-CV_INLINE CvPoint3D64f cvPoint3D64f(double x, double y, double z) {
-  CvPoint3D64f p = {x, y, z};
-  return p;
-}
-
-/******************************** CvSize's & CvBox
- * **************************************/
-
-typedef struct CvSize {
-  int width;
-  int height;
-
-#ifdef CV__VALIDATE_UNUNITIALIZED_VARS
-  CvSize() __attribute__((warning("Non-initialized variable"))) {}
-  template <typename _Tp> CvSize(const std::initializer_list<_Tp> list) {
-    CV_Assert(list.size() == 0 || list.size() == 2);
-    width = 0;
-    height = 0;
-    if (list.size() == 2) {
-      width = list.begin()[0];
-      height = list.begin()[1];
-    }
-  };
-#elif defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus)
-  CvSize(int w = 0, int h = 0) : width(w), height(h) {}
-  template <typename _Tp>
-  CvSize(const cv::Size_<_Tp> &sz)
-      : width(cv::saturate_cast<int>(sz.width)),
-        height(cv::saturate_cast<int>(sz.height)) {}
-#endif
-#ifdef __cplusplus
-  template <typename _Tp> operator cv::Size_<_Tp>() const {
-    return cv::Size_<_Tp>(cv::saturate_cast<_Tp>(width),
-                          cv::saturate_cast<_Tp>(height));
-  }
-#endif
-} CvSize;
-
-/** constructs CvSize structure. */
-CV_INLINE CvSize cvSize(int width, int height) {
-#if !(defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus))
-  CvSize s = {width, height};
-#else
-  CvSize s(width, height);
-#endif
-  return s;
-}
-
-#ifdef __cplusplus
-CV_INLINE CvSize cvSize(const cv::Size &sz) {
-#if !(defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus))
-  CvSize s = {sz.width, sz.height};
-#else
-  CvSize s(sz.width, sz.height);
-#endif
-  return s;
-}
-#endif
-
-typedef struct CvSize2D32f {
-  float width;
-  float height;
-
-#ifdef CV__VALIDATE_UNUNITIALIZED_VARS
-  CvSize2D32f() __attribute__((warning("Non-initialized variable"))) {}
-  template <typename _Tp> CvSize2D32f(const std::initializer_list<_Tp> list) {
-    CV_Assert(list.size() == 0 || list.size() == 2);
-    width = 0;
-    height = 0;
-    if (list.size() == 2) {
-      width = list.begin()[0];
-      height = list.begin()[1];
-    }
-  };
-#elif defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus)
-  CvSize2D32f(float w = 0, float h = 0) : width(w), height(h) {}
-  template <typename _Tp>
-  CvSize2D32f(const cv::Size_<_Tp> &sz)
-      : width(cv::saturate_cast<float>(sz.width)),
-        height(cv::saturate_cast<float>(sz.height)) {}
-#endif
-#ifdef __cplusplus
-  template <typename _Tp> operator cv::Size_<_Tp>() const {
-    return cv::Size_<_Tp>(cv::saturate_cast<_Tp>(width),
-                          cv::saturate_cast<_Tp>(height));
-  }
-#endif
-} CvSize2D32f;
-
-/** constructs CvSize2D32f structure. */
-CV_INLINE CvSize2D32f cvSize2D32f(double width, double height) {
-#if !(defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus))
-  CvSize2D32f s = {(float)width, (float)height};
-#else
-  CvSize2D32f s((float)width, (float)height);
-#endif
-  return s;
-}
-#ifdef __cplusplus
-template <typename _Tp> CvSize2D32f cvSize2D32f(const cv::Size_<_Tp> &sz) {
-#if !(defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus))
-  CvSize2D32f s = {(float)sz.width, (float)sz.height};
-#else
-  CvSize2D32f s((float)sz.width, (float)sz.height);
-#endif
-  return s;
-}
-#endif
-
-/** @sa RotatedRect
- */
-typedef struct CvBox2D {
-  CvPoint2D32f center; /**< Center of the box.                          */
-  CvSize2D32f size;    /**< Box width and length.                       */
-  float angle;         /**< Angle between the horizontal axis           */
-                       /**< and the first side (i.e. length) in degrees */
-
-#if defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus)
-  CvBox2D(CvPoint2D32f c = CvPoint2D32f(), CvSize2D32f s = CvSize2D32f(),
-          float a = 0)
-      : center(c), size(s), angle(a) {}
-  CvBox2D(const cv::RotatedRect &rr)
-      : center(rr.center), size(rr.size), angle(rr.angle) {}
-#endif
-#ifdef __cplusplus
-  operator cv::RotatedRect() const {
-    return cv::RotatedRect(center, size, angle);
-  }
-#endif
-} CvBox2D;
-
-#ifdef __cplusplus
-CV_INLINE CvBox2D cvBox2D(CvPoint2D32f c = CvPoint2D32f(),
-                          CvSize2D32f s = CvSize2D32f(), float a = 0) {
-  CvBox2D self;
-  self.center = c;
-  self.size = s;
-  self.angle = a;
-  return self;
-}
-CV_INLINE CvBox2D cvBox2D(const cv::RotatedRect &rr) {
-  CvBox2D self;
-  self.center = cvPoint2D32f(rr.center);
-  self.size = cvSize2D32f(rr.size);
-  self.angle = rr.angle;
-  return self;
-}
-#endif
-
-/** Line iterator state: */
-typedef struct CvLineIterator {
-  /** Pointer to the current point: */
-  uchar *ptr;
-
-  /* Bresenham algorithm state: */
-  int err;
-  int plus_delta;
-  int minus_delta;
-  int plus_step;
-  int minus_step;
-} CvLineIterator;
-
-/************************************* CvSlice
- * ******************************************/
-#define CV_WHOLE_SEQ_END_INDEX 0x3fffffff
-#define CV_WHOLE_SEQ cvSlice(0, CV_WHOLE_SEQ_END_INDEX)
-
-typedef struct CvSlice {
-  int start_index, end_index;
-
-#ifdef CV__VALIDATE_UNUNITIALIZED_VARS
-  CvSlice() __attribute__((warning("Non-initialized variable"))) {}
-  template <typename _Tp> CvSlice(const std::initializer_list<_Tp> list) {
-    CV_Assert(list.size() == 0 || list.size() == 2);
-    start_index = end_index = 0;
-    if (list.size() == 2) {
-      start_index = list.begin()[0];
-      end_index = list.begin()[1];
-    }
-  };
-#endif
-#if defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus) &&                 \
-    !defined(__CUDACC__)
-  CvSlice(int start = 0, int end = 0) : start_index(start), end_index(end) {}
-  CvSlice(const cv::Range &r) {
-    *this = (r.start != INT_MIN && r.end != INT_MAX)
-                ? CvSlice(r.start, r.end)
-                : CvSlice(0, CV_WHOLE_SEQ_END_INDEX);
-  }
-  operator cv::Range() const {
-    return (start_index == 0 && end_index == CV_WHOLE_SEQ_END_INDEX)
-               ? cv::Range::all()
-               : cv::Range(start_index, end_index);
-  }
-#endif
-} CvSlice;
-
-CV_INLINE CvSlice cvSlice(int start, int end) {
-#if !(defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus) &&               \
-      !defined(__CUDACC__))
-  CvSlice slice = {start, end};
-#else
-  CvSlice slice(start, end);
-#endif
-  return slice;
-}
-
-#if defined(__cplusplus)
-CV_INLINE CvSlice cvSlice(const cv::Range &r) {
-  CvSlice slice = (r.start != INT_MIN && r.end != INT_MAX)
-                      ? cvSlice(r.start, r.end)
-                      : cvSlice(0, CV_WHOLE_SEQ_END_INDEX);
-  return slice;
-}
-#endif
-
-/************************************* CvScalar
- * *****************************************/
-/** @sa Scalar_
- */
-typedef struct CvScalar {
-  double val[4];
-
-#ifdef CV__VALIDATE_UNUNITIALIZED_VARS
-  CvScalar() __attribute__((warning("Non-initialized variable"))) {}
-  CvScalar(const std::initializer_list<double> list) {
-    CV_Assert(list.size() == 0 || list.size() == 4);
-    val[0] = val[1] = val[2] = val[3] = 0;
-    if (list.size() == 4) {
-      val[0] = list.begin()[0];
-      val[1] = list.begin()[1];
-      val[2] = list.begin()[2];
-      val[3] = list.begin()[3];
-    }
-  };
-#elif defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus)
-  CvScalar() {}
-  CvScalar(double d0, double d1 = 0, double d2 = 0, double d3 = 0) {
-    val[0] = d0;
-    val[1] = d1;
-    val[2] = d2;
-    val[3] = d3;
-  }
-  template <typename _Tp> CvScalar(const cv::Scalar_<_Tp> &s) {
-    val[0] = s.val[0];
-    val[1] = s.val[1];
-    val[2] = s.val[2];
-    val[3] = s.val[3];
-  }
-  template <typename _Tp, int cn> CvScalar(const cv::Vec<_Tp, cn> &v) {
-    int i;
-    for (i = 0; i < (cn < 4 ? cn : 4); i++)
-      val[i] = v.val[i];
-    for (; i < 4; i++)
-      val[i] = 0;
-  }
-#endif
-#ifdef __cplusplus
-  template <typename _Tp> operator cv::Scalar_<_Tp>() const {
-    return cv::Scalar_<_Tp>(
-        cv::saturate_cast<_Tp>(val[0]), cv::saturate_cast<_Tp>(val[1]),
-        cv::saturate_cast<_Tp>(val[2]), cv::saturate_cast<_Tp>(val[3]));
-  }
-#endif
-} CvScalar;
-
-CV_INLINE CvScalar cvScalar(double val0, double val1 CV_DEFAULT(0),
-                            double val2 CV_DEFAULT(0),
-                            double val3 CV_DEFAULT(0)) {
-#if !(defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus))
-  CvScalar scalar = CV_STRUCT_INITIALIZER;
-#else
-  CvScalar scalar;
-#endif
-  scalar.val[0] = val0;
-  scalar.val[1] = val1;
-  scalar.val[2] = val2;
-  scalar.val[3] = val3;
-  return scalar;
-}
-
-#ifdef __cplusplus
-CV_INLINE CvScalar cvScalar() {
-#if !(defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus))
-  CvScalar scalar = CV_STRUCT_INITIALIZER;
-#else
-  CvScalar scalar;
-#endif
-  scalar.val[0] = scalar.val[1] = scalar.val[2] = scalar.val[3] = 0;
-  return scalar;
-}
-CV_INLINE CvScalar cvScalar(const cv::Scalar &s) {
-#if !(defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus))
-  CvScalar scalar = CV_STRUCT_INITIALIZER;
-#else
-  CvScalar scalar;
-#endif
-  scalar.val[0] = s.val[0];
-  scalar.val[1] = s.val[1];
-  scalar.val[2] = s.val[2];
-  scalar.val[3] = s.val[3];
-  return scalar;
-}
-#endif
-
-CV_INLINE CvScalar cvRealScalar(double val0) {
-#if !(defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus))
-  CvScalar scalar = CV_STRUCT_INITIALIZER;
-#else
-  CvScalar scalar;
-#endif
-  scalar.val[0] = val0;
-  scalar.val[1] = scalar.val[2] = scalar.val[3] = 0;
-  return scalar;
-}
-
-CV_INLINE CvScalar cvScalarAll(double val0123) {
-#if !(defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus))
-  CvScalar scalar = CV_STRUCT_INITIALIZER;
-#else
-  CvScalar scalar;
-#endif
-  scalar.val[0] = val0123;
-  scalar.val[1] = val0123;
-  scalar.val[2] = val0123;
-  scalar.val[3] = val0123;
-  return scalar;
-}
-
-/****************************************************************************************\
-*                                   Dynamic Data structures *
-\****************************************************************************************/
-
-/******************************** Memory storage
- * ****************************************/
-
-typedef struct CvMemBlock {
-  struct CvMemBlock *prev;
-  struct CvMemBlock *next;
-} CvMemBlock;
-
-#define CV_STORAGE_MAGIC_VAL 0x42890000
-
-typedef struct CvMemStorage {
-  int signature;
-  CvMemBlock *bottom;          /**< First allocated block.                   */
-  CvMemBlock *top;             /**< Current memory block - top of the stack. */
-  struct CvMemStorage *parent; /**< We get new blocks from parent as needed. */
-  int block_size;              /**< Block size.                              */
-  int free_space;              /**< Remaining free space in current block.   */
-} CvMemStorage;
-
-#define CV_IS_STORAGE(storage)                                                 \
-  ((storage) != NULL && (((CvMemStorage *)(storage))->signature &              \
-                         CV_MAGIC_MASK) == CV_STORAGE_MAGIC_VAL)
-
-typedef struct CvMemStoragePos {
-  CvMemBlock *top;
-  int free_space;
-} CvMemStoragePos;
-
-/*********************************** Sequence
- * *******************************************/
-
-typedef struct CvSeqBlock {
-  struct CvSeqBlock *prev; /**< Previous sequence block.                   */
-  struct CvSeqBlock *next; /**< Next sequence block.                       */
-  int start_index;         /**< Index of the first element in the block +  */
-                           /**< sequence->first->start_index.              */
-  int count;               /**< Number of elements in the block.           */
-  schar *data;             /**< Pointer to the first element of the block. */
-} CvSeqBlock;
-
-#define CV_TREE_NODE_FIELDS(node_type)                                         \
-  int flags;                /**< Miscellaneous flags.     */                   \
-  int header_size;          /**< Size of sequence header. */                   \
-  struct node_type *h_prev; /**< Previous sequence.       */                   \
-  struct node_type *h_next; /**< Next sequence.           */                   \
-  struct node_type *v_prev; /**< 2nd previous sequence.   */                   \
-  struct node_type *v_next  /**< 2nd next sequence.       */
-
-/**
-   Read/Write sequence.
-   Elements can be dynamically inserted to or deleted from the sequence.
-*/
-#define CV_SEQUENCE_FIELDS()                                                   \
-  CV_TREE_NODE_FIELDS(CvSeq);                                                  \
-  int total;               /**< Total number of elements.            */        \
-  int elem_size;           /**< Size of sequence element in bytes.   */        \
-  schar *block_max;        /**< Maximal bound of the last block.     */        \
-  schar *ptr;              /**< Current write pointer.               */        \
-  int delta_elems;         /**< Grow seq this many at a time.        */        \
-  CvMemStorage *storage;   /**< Where the seq is stored.             */        \
-  CvSeqBlock *free_blocks; /**< Free blocks list.                    */        \
-  CvSeqBlock *first;       /**< Pointer to the first sequence block. */
-
-typedef struct CvSeq {
-  CV_SEQUENCE_FIELDS()
-} CvSeq;
-
-#define CV_TYPE_NAME_SEQ "opencv-sequence"
-#define CV_TYPE_NAME_SEQ_TREE "opencv-sequence-tree"
-
-/*************************************** Set
- * ********************************************/
-/** @brief Set
-  Order is not preserved. There can be gaps between sequence elements.
-  After the element has been inserted it stays in the same place all the time.
-  The MSB(most-significant or sign bit) of the first field (flags) is 0 iff the
-  element exists.
-*/
-#define CV_SET_ELEM_FIELDS(elem_type)                                          \
-  int flags;                                                                   \
-  struct elem_type *next_free;
-
-typedef struct CvSetElem {
-  CV_SET_ELEM_FIELDS(CvSetElem)
-} CvSetElem;
-
-#define CV_SET_FIELDS()                                                        \
-  CV_SEQUENCE_FIELDS()                                                         \
-  CvSetElem *free_elems;                                                       \
-  int active_count;
-
-typedef struct CvSet {
-  CV_SET_FIELDS()
-} CvSet;
-
-#define CV_SET_ELEM_IDX_MASK ((1 << 26) - 1)
-#define CV_SET_ELEM_FREE_FLAG (1 << (sizeof(int) * 8 - 1))
-
-/** Checks whether the element pointed by ptr belongs to a set or not */
-#define CV_IS_SET_ELEM(ptr) (((CvSetElem *)(ptr))->flags >= 0)
-
-/************************************* Graph
- * ********************************************/
-
-/** @name Graph
-
-We represent a graph as a set of vertices. Vertices contain their adjacency
-lists (more exactly, pointers to first incoming or outcoming edge (or 0 if
-isolated vertex)). Edges are stored in another set. There is a singly-linked
-list of incoming/outcoming edges for each vertex.
-
-Each edge consists of:
-
-- Two pointers to the starting and ending vertices (vtx[0] and vtx[1]
-respectively).
-
-    A graph may be oriented or not. In the latter case, edges between vertex i
-to vertex j are not distinguished during search operations.
-
-- Two pointers to next edges for the starting and ending vertices, where next[0]
-points to the next edge in the vtx[0] adjacency list and next[1] points to the
-next edge in the vtx[1] adjacency list.
-
-@see CvGraphEdge, CvGraphVtx, CvGraphVtx2D, CvGraph
-@{
-*/
-#define CV_GRAPH_EDGE_FIELDS()                                                 \
-  int flags;                                                                   \
-  float weight;                                                                \
-  struct CvGraphEdge *next[2];                                                 \
-  struct CvGraphVtx *vtx[2];
-
-#define CV_GRAPH_VERTEX_FIELDS()                                               \
-  int flags;                                                                   \
-  struct CvGraphEdge *first;
-
-typedef struct CvGraphEdge {
-  CV_GRAPH_EDGE_FIELDS()
-} CvGraphEdge;
-
-typedef struct CvGraphVtx {
-  CV_GRAPH_VERTEX_FIELDS()
-} CvGraphVtx;
-
-typedef struct CvGraphVtx2D {
-  CV_GRAPH_VERTEX_FIELDS()
-  CvPoint2D32f *ptr;
-} CvGraphVtx2D;
-
-/**
-   Graph is "derived" from the set (this is set a of vertices)
-   and includes another set (edges)
-*/
-#define CV_GRAPH_FIELDS()                                                      \
-  CV_SET_FIELDS()                                                              \
-  CvSet *edges;
-
-typedef struct CvGraph {
-  CV_GRAPH_FIELDS()
-} CvGraph;
-
-#define CV_TYPE_NAME_GRAPH "opencv-graph"
-
-/** @} */
-
-/*********************************** Chain/Contour
- * *************************************/
-
-typedef struct CvChain {
-  CV_SEQUENCE_FIELDS()
-  CvPoint origin;
-} CvChain;
-
-#define CV_CONTOUR_FIELDS()                                                    \
-  CV_SEQUENCE_FIELDS()                                                         \
-  CvRect rect;                                                                 \
-  int color;                                                                   \
-  int reserved[3];
-
-typedef struct CvContour {
-  CV_CONTOUR_FIELDS()
-} CvContour;
-
-typedef CvContour CvPoint2DSeq;
-
-/****************************************************************************************\
-*                                    Sequence types *
-\****************************************************************************************/
-
-#define CV_SEQ_MAGIC_VAL 0x42990000
-
-#define CV_IS_SEQ(seq)                                                         \
-  ((seq) != NULL &&                                                            \
-   (((CvSeq *)(seq))->flags & CV_MAGIC_MASK) == CV_SEQ_MAGIC_VAL)
-
-#define CV_SET_MAGIC_VAL 0x42980000
-#define CV_IS_SET(set)                                                         \
-  ((set) != NULL &&                                                            \
-   (((CvSeq *)(set))->flags & CV_MAGIC_MASK) == CV_SET_MAGIC_VAL)
-
-#define CV_SEQ_ELTYPE_BITS 12
-#define CV_SEQ_ELTYPE_MASK ((1 << CV_SEQ_ELTYPE_BITS) - 1)
-
-#define CV_SEQ_ELTYPE_POINT CV_32SC2 /**< (x,y) */
-#define CV_SEQ_ELTYPE_CODE CV_8UC1   /**< freeman code: 0..7 */
-#define CV_SEQ_ELTYPE_GENERIC 0
-#define CV_SEQ_ELTYPE_PTR CV_MAKE_TYPE(CV_8U, 8 /*sizeof(void*)*/)
-#define CV_SEQ_ELTYPE_PPOINT CV_SEQ_ELTYPE_PTR /**< &(x,y) */
-#define CV_SEQ_ELTYPE_INDEX CV_32SC1           /**< #(x,y) */
-#define CV_SEQ_ELTYPE_GRAPH_EDGE 0     /**< &next_o, &next_d, &vtx_o, &vtx_d */
-#define CV_SEQ_ELTYPE_GRAPH_VERTEX 0   /**< first_edge, &(x,y) */
-#define CV_SEQ_ELTYPE_TRIAN_ATR 0      /**< vertex of the binary tree   */
-#define CV_SEQ_ELTYPE_CONNECTED_COMP 0 /**< connected component  */
-#define CV_SEQ_ELTYPE_POINT3D CV_32FC3 /**< (x,y,z)  */
-
-#define CV_SEQ_KIND_BITS 2
-#define CV_SEQ_KIND_MASK (((1 << CV_SEQ_KIND_BITS) - 1) << CV_SEQ_ELTYPE_BITS)
-
-/** types of sequences */
-#define CV_SEQ_KIND_GENERIC (0 << CV_SEQ_ELTYPE_BITS)
-#define CV_SEQ_KIND_CURVE (1 << CV_SEQ_ELTYPE_BITS)
-#define CV_SEQ_KIND_BIN_TREE (2 << CV_SEQ_ELTYPE_BITS)
-
-/** types of sparse sequences (sets) */
-#define CV_SEQ_KIND_GRAPH (1 << CV_SEQ_ELTYPE_BITS)
-#define CV_SEQ_KIND_SUBDIV2D (2 << CV_SEQ_ELTYPE_BITS)
-
-#define CV_SEQ_FLAG_SHIFT (CV_SEQ_KIND_BITS + CV_SEQ_ELTYPE_BITS)
-
-/** flags for curves */
-#define CV_SEQ_FLAG_CLOSED (1 << CV_SEQ_FLAG_SHIFT)
-#define CV_SEQ_FLAG_SIMPLE (0 << CV_SEQ_FLAG_SHIFT)
-#define CV_SEQ_FLAG_CONVEX (0 << CV_SEQ_FLAG_SHIFT)
-#define CV_SEQ_FLAG_HOLE (2 << CV_SEQ_FLAG_SHIFT)
-
-/** flags for graphs */
-#define CV_GRAPH_FLAG_ORIENTED (1 << CV_SEQ_FLAG_SHIFT)
-
-#define CV_GRAPH CV_SEQ_KIND_GRAPH
-#define CV_ORIENTED_GRAPH (CV_SEQ_KIND_GRAPH | CV_GRAPH_FLAG_ORIENTED)
-
-/** point sets */
-#define CV_SEQ_POINT_SET (CV_SEQ_KIND_GENERIC | CV_SEQ_ELTYPE_POINT)
-#define CV_SEQ_POINT3D_SET (CV_SEQ_KIND_GENERIC | CV_SEQ_ELTYPE_POINT3D)
-#define CV_SEQ_POLYLINE (CV_SEQ_KIND_CURVE | CV_SEQ_ELTYPE_POINT)
-#define CV_SEQ_POLYGON (CV_SEQ_FLAG_CLOSED | CV_SEQ_POLYLINE)
-#define CV_SEQ_CONTOUR CV_SEQ_POLYGON
-#define CV_SEQ_SIMPLE_POLYGON (CV_SEQ_FLAG_SIMPLE | CV_SEQ_POLYGON)
-
-/** chain-coded curves */
-#define CV_SEQ_CHAIN (CV_SEQ_KIND_CURVE | CV_SEQ_ELTYPE_CODE)
-#define CV_SEQ_CHAIN_CONTOUR (CV_SEQ_FLAG_CLOSED | CV_SEQ_CHAIN)
-
-/** binary tree for the contour */
-#define CV_SEQ_POLYGON_TREE (CV_SEQ_KIND_BIN_TREE | CV_SEQ_ELTYPE_TRIAN_ATR)
-
-/** sequence of the connected components */
-#define CV_SEQ_CONNECTED_COMP                                                  \
-  (CV_SEQ_KIND_GENERIC | CV_SEQ_ELTYPE_CONNECTED_COMP)
-
-/** sequence of the integer numbers */
-#define CV_SEQ_INDEX (CV_SEQ_KIND_GENERIC | CV_SEQ_ELTYPE_INDEX)
-
-#define CV_SEQ_ELTYPE(seq) ((seq)->flags & CV_SEQ_ELTYPE_MASK)
-#define CV_SEQ_KIND(seq) ((seq)->flags & CV_SEQ_KIND_MASK)
-
-/** flag checking */
-#define CV_IS_SEQ_INDEX(seq)                                                   \
-  ((CV_SEQ_ELTYPE(seq) == CV_SEQ_ELTYPE_INDEX) &&                              \
-   (CV_SEQ_KIND(seq) == CV_SEQ_KIND_GENERIC))
-
-#define CV_IS_SEQ_CURVE(seq) (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE)
-#define CV_IS_SEQ_CLOSED(seq) (((seq)->flags & CV_SEQ_FLAG_CLOSED) != 0)
-#define CV_IS_SEQ_CONVEX(seq) 0
-#define CV_IS_SEQ_HOLE(seq) (((seq)->flags & CV_SEQ_FLAG_HOLE) != 0)
-#define CV_IS_SEQ_SIMPLE(seq) 1
-
-/** type checking macros */
-#define CV_IS_SEQ_POINT_SET(seq)                                               \
-  ((CV_SEQ_ELTYPE(seq) == CV_32SC2 || CV_SEQ_ELTYPE(seq) == CV_32FC2))
-
-#define CV_IS_SEQ_POINT_SUBSET(seq)                                            \
-  (CV_IS_SEQ_INDEX(seq) || CV_SEQ_ELTYPE(seq) == CV_SEQ_ELTYPE_PPOINT)
-
-#define CV_IS_SEQ_POLYLINE(seq)                                                \
-  (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE && CV_IS_SEQ_POINT_SET(seq))
-
-#define CV_IS_SEQ_POLYGON(seq)                                                 \
-  (CV_IS_SEQ_POLYLINE(seq) && CV_IS_SEQ_CLOSED(seq))
-
-#define CV_IS_SEQ_CHAIN(seq)                                                   \
-  (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE && (seq)->elem_size == 1)
-
-#define CV_IS_SEQ_CONTOUR(seq)                                                 \
-  (CV_IS_SEQ_CLOSED(seq) && (CV_IS_SEQ_POLYLINE(seq) || CV_IS_SEQ_CHAIN(seq)))
-
-#define CV_IS_SEQ_CHAIN_CONTOUR(seq)                                           \
-  (CV_IS_SEQ_CHAIN(seq) && CV_IS_SEQ_CLOSED(seq))
-
-#define CV_IS_SEQ_POLYGON_TREE(seq)                                            \
-  (CV_SEQ_ELTYPE(seq) == CV_SEQ_ELTYPE_TRIAN_ATR &&                            \
-   CV_SEQ_KIND(seq) == CV_SEQ_KIND_BIN_TREE)
-
-#define CV_IS_GRAPH(seq)                                                       \
-  (CV_IS_SET(seq) && CV_SEQ_KIND((CvSet *)(seq)) == CV_SEQ_KIND_GRAPH)
-
-#define CV_IS_GRAPH_ORIENTED(seq) (((seq)->flags & CV_GRAPH_FLAG_ORIENTED) != 0)
-
-#define CV_IS_SUBDIV2D(seq)                                                    \
-  (CV_IS_SET(seq) && CV_SEQ_KIND((CvSet *)(seq)) == CV_SEQ_KIND_SUBDIV2D)
-
-/****************************************************************************************/
-/*                            Sequence writer & reader */
-/****************************************************************************************/
-
-#define CV_SEQ_WRITER_FIELDS()                                                 \
-  int header_size;                                                             \
-  CvSeq *seq;        /**< the sequence written */                              \
-  CvSeqBlock *block; /**< current block */                                     \
-  schar *ptr;        /**< pointer to free space */                             \
-  schar *block_min;  /**< pointer to the beginning of block*/                  \
-  schar *block_max;  /**< pointer to the end of block */
-
-typedef struct CvSeqWriter {
-  CV_SEQ_WRITER_FIELDS()
-} CvSeqWriter;
-
-#define CV_SEQ_READER_FIELDS()                                                 \
-  int header_size;                                                             \
-  CvSeq *seq;        /**< sequence, beign read */                              \
-  CvSeqBlock *block; /**< current block */                                     \
-  schar *ptr;        /**< pointer to element be read next */                   \
-  schar *block_min;  /**< pointer to the beginning of block */                 \
-  schar *block_max;  /**< pointer to the end of block */                       \
-  int delta_index;   /**< = seq->first->start_index   */                       \
-  schar *prev_elem;  /**< pointer to previous element */
-
-typedef struct CvSeqReader {
-  CV_SEQ_READER_FIELDS()
-} CvSeqReader;
-
-/****************************************************************************************/
-/*                                Operations on sequences */
-/****************************************************************************************/
-
-#define CV_SEQ_ELEM(seq, elem_type, index)                                     \
-  /** assert gives some guarantee that <seq> parameter is valid */             \
-  (assert(sizeof((seq)->first[0]) == sizeof(CvSeqBlock) &&                     \
-          (seq)->elem_size == sizeof(elem_type)),                              \
-   (elem_type *)((seq)->first &&                                               \
-                         (unsigned)index < (unsigned)((seq)->first->count)     \
-                     ? (seq)->first->data + (index) * sizeof(elem_type)        \
-                     : cvGetSeqElem((CvSeq *)(seq), (index))))
-#define CV_GET_SEQ_ELEM(elem_type, seq, index)                                 \
-  CV_SEQ_ELEM((seq), elem_type, (index))
-
-/** Add element to sequence: */
-#define CV_WRITE_SEQ_ELEM_VAR(elem_ptr, writer)                                \
-  {                                                                            \
-    if ((writer).ptr >= (writer).block_max) {                                  \
-      cvCreateSeqBlock(&writer);                                               \
-    }                                                                          \
-    memcpy((writer).ptr, elem_ptr, (writer).seq->elem_size);                   \
-    (writer).ptr += (writer).seq->elem_size;                                   \
-  }
-
-#define CV_WRITE_SEQ_ELEM(elem, writer)                                        \
-  {                                                                            \
-    assert((writer).seq->elem_size == sizeof(elem));                           \
-    if ((writer).ptr >= (writer).block_max) {                                  \
-      cvCreateSeqBlock(&writer);                                               \
-    }                                                                          \
-    assert((writer).ptr <= (writer).block_max - sizeof(elem));                 \
-    memcpy((writer).ptr, &(elem), sizeof(elem));                               \
-    (writer).ptr += sizeof(elem);                                              \
-  }
-
-/** Move reader position forward: */
-#define CV_NEXT_SEQ_ELEM(elem_size, reader)                                    \
-  {                                                                            \
-    if (((reader).ptr += (elem_size)) >= (reader).block_max) {                 \
-      cvChangeSeqBlock(&(reader), 1);                                          \
-    }                                                                          \
-  }
-
-/** Move reader position backward: */
-#define CV_PREV_SEQ_ELEM(elem_size, reader)                                    \
-  {                                                                            \
-    if (((reader).ptr -= (elem_size)) < (reader).block_min) {                  \
-      cvChangeSeqBlock(&(reader), -1);                                         \
-    }                                                                          \
-  }
-
-/** Read element and move read position forward: */
-#define CV_READ_SEQ_ELEM(elem, reader)                                         \
-  {                                                                            \
-    assert((reader).seq->elem_size == sizeof(elem));                           \
-    memcpy(&(elem), (reader).ptr, sizeof((elem)));                             \
-    CV_NEXT_SEQ_ELEM(sizeof(elem), reader)                                     \
-  }
-
-/** Read element and move read position backward: */
-#define CV_REV_READ_SEQ_ELEM(elem, reader)                                     \
-  {                                                                            \
-    assert((reader).seq->elem_size == sizeof(elem));                           \
-    memcpy(&(elem), (reader).ptr, sizeof((elem)));                             \
-    CV_PREV_SEQ_ELEM(sizeof(elem), reader)                                     \
-  }
-
-#define CV_READ_CHAIN_POINT(_pt, reader)                                       \
-  {                                                                            \
-    (_pt) = (reader).pt;                                                       \
-    if ((reader).ptr) {                                                        \
-      CV_READ_SEQ_ELEM((reader).code, (reader));                               \
-      assert(((reader).code & ~7) == 0);                                       \
-      (reader).pt.x += (reader).deltas[(int)(reader).code][0];                 \
-      (reader).pt.y += (reader).deltas[(int)(reader).code][1];                 \
-    }                                                                          \
-  }
-
-#define CV_CURRENT_POINT(reader) (*((CvPoint *)((reader).ptr)))
-#define CV_PREV_POINT(reader) (*((CvPoint *)((reader).prev_elem)))
-
-#define CV_READ_EDGE(pt1, pt2, reader)                                         \
-  {                                                                            \
-    assert(sizeof(pt1) == sizeof(CvPoint) && sizeof(pt2) == sizeof(CvPoint) && \
-           reader.seq->elem_size == sizeof(CvPoint));                          \
-    (pt1) = CV_PREV_POINT(reader);                                             \
-    (pt2) = CV_CURRENT_POINT(reader);                                          \
-    (reader).prev_elem = (reader).ptr;                                         \
-    CV_NEXT_SEQ_ELEM(sizeof(CvPoint), (reader));                               \
-  }
-
-/************ Graph macros ************/
-
-/** Return next graph edge for given vertex: */
-#define CV_NEXT_GRAPH_EDGE(edge, vertex)                                       \
-  (assert((edge)->vtx[0] == (vertex) || (edge)->vtx[1] == (vertex)),           \
-   (edge)->next[(edge)->vtx[1] == (vertex)])
-
-/****************************************************************************************\
-*             Data structures for persistence (a.k.a serialization)
-functionality        *
-\****************************************************************************************/
-
-#if 0
-
-/** "black box" file storage */
-typedef struct CvFileStorage CvFileStorage;
-
-/** Storage flags: */
-#define CV_STORAGE_READ 0
-#define CV_STORAGE_WRITE 1
-#define CV_STORAGE_WRITE_TEXT CV_STORAGE_WRITE
-#define CV_STORAGE_WRITE_BINARY CV_STORAGE_WRITE
-#define CV_STORAGE_APPEND 2
-#define CV_STORAGE_MEMORY 4
-#define CV_STORAGE_FORMAT_MASK (7 << 3)
-#define CV_STORAGE_FORMAT_AUTO 0
-#define CV_STORAGE_FORMAT_XML 8
-#define CV_STORAGE_FORMAT_YAML 16
-#define CV_STORAGE_FORMAT_JSON 24
-#define CV_STORAGE_BASE64 64
-#define CV_STORAGE_WRITE_BASE64 (CV_STORAGE_BASE64 | CV_STORAGE_WRITE)
-
-/** @brief List of attributes. :
-
-In the current implementation, attributes are used to pass extra parameters when writing user
-objects (see cvWrite). XML attributes inside tags are not supported, aside from the object type
-specification (type_id attribute).
-@see cvAttrList, cvAttrValue
- */
-typedef struct CvAttrList
-{
-    const char** attr;         /**< NULL-terminated array of (attribute_name,attribute_value) pairs. */
-    struct CvAttrList* next;   /**< Pointer to next chunk of the attributes list.                    */
-}
-CvAttrList;
-
-/** initializes CvAttrList structure */
-CV_INLINE CvAttrList cvAttrList( const char** attr CV_DEFAULT(NULL),
-                                 CvAttrList* next CV_DEFAULT(NULL) )
-{
-    CvAttrList l;
-    l.attr = attr;
-    l.next = next;
-
-    return l;
-}
-
-struct CvTypeInfo;
-
-#define CV_NODE_NONE 0
-#define CV_NODE_INT 1
-#define CV_NODE_INTEGER CV_NODE_INT
-#define CV_NODE_REAL 2
-#define CV_NODE_FLOAT CV_NODE_REAL
-#define CV_NODE_STR 3
-#define CV_NODE_STRING CV_NODE_STR
-#define CV_NODE_REF 4 /**< not used */
-#define CV_NODE_SEQ 5
-#define CV_NODE_MAP 6
-#define CV_NODE_TYPE_MASK 7
-
-#define CV_NODE_TYPE(flags) ((flags) & CV_NODE_TYPE_MASK)
-
-/** file node flags */
-#define CV_NODE_FLOW 8 /**<Used only for writing structures in YAML format. */
-#define CV_NODE_USER 16
-#define CV_NODE_EMPTY 32
-#define CV_NODE_NAMED 64
-
-#define CV_NODE_IS_INT(flags) (CV_NODE_TYPE(flags) == CV_NODE_INT)
-#define CV_NODE_IS_REAL(flags) (CV_NODE_TYPE(flags) == CV_NODE_REAL)
-#define CV_NODE_IS_STRING(flags) (CV_NODE_TYPE(flags) == CV_NODE_STRING)
-#define CV_NODE_IS_SEQ(flags) (CV_NODE_TYPE(flags) == CV_NODE_SEQ)
-#define CV_NODE_IS_MAP(flags) (CV_NODE_TYPE(flags) == CV_NODE_MAP)
-#define CV_NODE_IS_COLLECTION(flags) (CV_NODE_TYPE(flags) >= CV_NODE_SEQ)
-#define CV_NODE_IS_FLOW(flags) (((flags) & CV_NODE_FLOW) != 0)
-#define CV_NODE_IS_EMPTY(flags) (((flags) & CV_NODE_EMPTY) != 0)
-#define CV_NODE_IS_USER(flags) (((flags) & CV_NODE_USER) != 0)
-#define CV_NODE_HAS_NAME(flags) (((flags) & CV_NODE_NAMED) != 0)
-
-#define CV_NODE_SEQ_SIMPLE 256
-#define CV_NODE_SEQ_IS_SIMPLE(seq) (((seq)->flags & CV_NODE_SEQ_SIMPLE) != 0)
-
-typedef struct CvString
-{
-    int len;
-    char* ptr;
-}
-CvString;
-
-/** All the keys (names) of elements in the read file storage
-   are stored in the hash to speed up the lookup operations: */
-typedef struct CvStringHashNode
-{
-    unsigned hashval;
-    CvString str;
-    struct CvStringHashNode* next;
-}
-CvStringHashNode;
-
-typedef struct CvGenericHash CvFileNodeHash;
-
-/** Basic element of the file storage - scalar or collection: */
-typedef struct CvFileNode
-{
-    int tag;
-    struct CvTypeInfo* info; /**< type information
-            (only for user-defined object, for others it is 0) */
-    union
-    {
-        double f; /**< scalar floating-point number */
-        int i;    /**< scalar integer number */
-        CvString str; /**< text string */
-        CvSeq* seq; /**< sequence (ordered collection of file nodes) */
-        CvFileNodeHash* map; /**< map (collection of named file nodes) */
-    } data;
-}
-CvFileNode;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-typedef int (CV_CDECL *CvIsInstanceFunc)( const void* struct_ptr );
-typedef void (CV_CDECL *CvReleaseFunc)( void** struct_dblptr );
-typedef void* (CV_CDECL *CvReadFunc)( CvFileStorage* storage, CvFileNode* node );
-typedef void (CV_CDECL *CvWriteFunc)( CvFileStorage* storage, const char* name,
-                                      const void* struct_ptr, CvAttrList attributes );
-typedef void* (CV_CDECL *CvCloneFunc)( const void* struct_ptr );
-#ifdef __cplusplus
-}
-#endif
-
-/** @brief Type information
-
-The structure contains information about one of the standard or user-defined types. Instances of the
-type may or may not contain a pointer to the corresponding CvTypeInfo structure. In any case, there
-is a way to find the type info structure for a given object using the cvTypeOf function.
-Alternatively, type info can be found by type name using cvFindType, which is used when an object
-is read from file storage. The user can register a new type with cvRegisterType that adds the type
-information structure into the beginning of the type list. Thus, it is possible to create
-specialized types from generic standard types and override the basic methods.
- */
-typedef struct CvTypeInfo
-{
-    int flags; /**< not used */
-    int header_size; /**< sizeof(CvTypeInfo) */
-    struct CvTypeInfo* prev; /**< previous registered type in the list */
-    struct CvTypeInfo* next; /**< next registered type in the list */
-    const char* type_name; /**< type name, written to file storage */
-    CvIsInstanceFunc is_instance; /**< checks if the passed object belongs to the type */
-    CvReleaseFunc release; /**< releases object (memory etc.) */
-    CvReadFunc read; /**< reads object from file storage */
-    CvWriteFunc write; /**< writes object to file storage */
-    CvCloneFunc clone; /**< creates a copy of the object */
-}
-CvTypeInfo;
-#endif
-
-/** @} */
-
-#endif /*OPENCV_CORE_TYPES_H*/
-
-/* End of file. */
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/utility.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/utility.hpp
deleted file mode 100644
index e457fb9c29..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/utility.hpp
+++ /dev/null
@@ -1,1296 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Copyright (C) 2015, Itseez Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_CORE_UTILITY_H
-#define OPENCV_CORE_UTILITY_H
-
-#ifndef __cplusplus
-#error utility.hpp header must be compiled as C++
-#endif
-
-#if defined(check)
-#  warning Detected Apple 'check' macro definition, it can cause build conflicts. Please, include this header before any Apple headers.
-#endif
-
-#include "opencv2/core.hpp"
-#include <ostream>
-
-#include <functional>
-
-#if !defined(_M_CEE)
-#include <mutex> // std::mutex, std::lock_guard
-#endif
-
-namespace cv {
-
-//! @addtogroup core_utils
-//! @{
-
-/** @brief  Automatically Allocated Buffer Class
-
- The class is used for temporary buffers in functions and methods.
- If a temporary buffer is usually small (a few K's of memory),
- but its size depends on the parameters, it makes sense to create a small
- fixed-size array on stack and use it if it's large enough. If the required
- buffer size is larger than the fixed size, another buffer of sufficient size is
- allocated dynamically and released after the processing. Therefore, in typical
- cases, when the buffer size is small, there is no overhead associated with
- malloc()/free(). At the same time, there is no limit on the size of processed
- data.
-
- This is what AutoBuffer does. The template takes 2 parameters - type of the
- buffer elements and the number of stack-allocated elements. Here is how the
- class is used:
-
- \code
- void my_func(const cv::Mat& m)
- {
-    cv::AutoBuffer<float> buf(1000); // create automatic buffer containing 1000
- floats
-
-    buf.allocate(m.rows); // if m.rows <= 1000, the pre-allocated buffer is
- used,
-                          // otherwise the buffer of "m.rows" floats will be
- allocated
-                          // dynamically and deallocated in cv::AutoBuffer
- destructor
-    ...
- }
- \endcode
-*/
-#ifdef OPENCV_ENABLE_MEMORY_SANITIZER
-template <typename _Tp, size_t fixed_size = 0>
-class AutoBuffer
-#else
-template <typename _Tp, size_t fixed_size = 1024 / sizeof(_Tp) + 8>
-class AutoBuffer
-#endif
-{
-public:
-  typedef _Tp value_type;
-
-  //! the default constructor
-  AutoBuffer();
-  //! constructor taking the real buffer size
-  explicit AutoBuffer(size_t _size);
-
-  //! the copy constructor
-  AutoBuffer(const AutoBuffer<_Tp, fixed_size> &buf);
-  //! the assignment operator
-  AutoBuffer<_Tp, fixed_size> &
-  operator=(const AutoBuffer<_Tp, fixed_size> &buf);
-
-  //! destructor. calls deallocate()
-  ~AutoBuffer();
-
-  //! allocates the new buffer of size _size. if the _size is small enough,
-  //! stack-allocated buffer is used
-  void allocate(size_t _size);
-  //! deallocates the buffer if it was dynamically allocated
-  void deallocate();
-  //! resizes the buffer and preserves the content
-  void resize(size_t _size);
-  //! returns the current buffer size
-  size_t size() const;
-  //! returns pointer to the real buffer, stack-allocated or heap-allocated
-  inline _Tp *data() { return ptr; }
-  //! returns read-only pointer to the real buffer, stack-allocated or
-  //! heap-allocated
-  inline const _Tp *data() const { return ptr; }
-
-#if !defined(                                                                  \
-    OPENCV_DISABLE_DEPRECATED_COMPATIBILITY) // use to .data() calls instead
-  //! returns pointer to the real buffer, stack-allocated or heap-allocated
-  operator _Tp *() { return ptr; }
-  //! returns read-only pointer to the real buffer, stack-allocated or
-  //! heap-allocated
-  operator const _Tp *() const { return ptr; }
-#else
-  //! returns a reference to the element at specified location. No bounds
-  //! checking is performed in Release builds.
-  inline _Tp &operator[](size_t i) {
-    CV_DbgCheckLT(i, sz, "out of range");
-    return ptr[i];
-  }
-  //! returns a reference to the element at specified location. No bounds
-  //! checking is performed in Release builds.
-  inline const _Tp &operator[](size_t i) const {
-    CV_DbgCheckLT(i, sz, "out of range");
-    return ptr[i];
-  }
-#endif
-
-protected:
-  //! pointer to the real buffer, can point to buf if the buffer is small enough
-  _Tp *ptr;
-  //! size of the real buffer
-  size_t sz;
-  //! pre-allocated buffer. At least 1 element to confirm C++ standard
-  //! requirements
-  _Tp buf[(fixed_size > 0) ? fixed_size : 1];
-};
-
-/**  @brief Sets/resets the break-on-error mode.
-
-When the break-on-error mode is set, the default error handler issues a hardware
-exception, which can make debugging more convenient.
-
-\return the previous state
- */
-CV_EXPORTS bool setBreakOnError(bool flag);
-
-extern "C" typedef int (*ErrorCallback)(int status, const char *func_name,
-                                        const char *err_msg,
-                                        const char *file_name, int line,
-                                        void *userdata);
-
-/** @brief Sets the new error handler and the optional user data.
-
-  The function sets the new error handler, called from cv::error().
-
-  \param errCallback the new error handler. If NULL, the default error handler
-  is used.
-  \param userdata the optional user data pointer, passed to the callback.
-  \param prevUserdata the optional output parameter where the previous user data
-  pointer is stored
-
-  \return the previous error handler
-*/
-CV_EXPORTS ErrorCallback redirectError(ErrorCallback errCallback,
-                                       void *userdata = 0,
-                                       void **prevUserdata = 0);
-
-/** @brief Generates a unique temporary file name.
-
-This function generates a full, unique file path for a temporary file,
-which can be used to create temporary files for various purposes.
-
-@param suffix (optional) The desired file extension or suffix for the temporary
-file (e.g., ".png", ".txt"). If no suffix is provided (suffix = 0), the file
-will not have a specific extension.
-
-@return cv::String A full unique path for the temporary file.
-
-@note
-- The function does not create the file, it only generates the name.
-- The file name is unique for the system session.
-- Works cross-platform (Windows, Linux, macOS).
- */
-CV_EXPORTS String tempfile(const char *suffix = 0);
-
-/** @brief Searches for files matching the specified pattern in a directory.
-
-This function searches for files that match a given pattern (e.g., `*.jpg`)
-in the specified directory. The search can be limited to the directory itself
-or be recursive, including subdirectories.
-
-@param pattern The file search pattern, which can include wildcards like `*`
-(for matching multiple characters) or `?` (for matching a single character).
-
-@param result  Output vector where the file paths matching the search
-pattern will be stored.
-@param recursive (optional) Boolean flag indicating whether to search
-subdirectories recursively. If true, the search will include all subdirectories.
-The default value is `false`.
- */
-CV_EXPORTS void glob(String pattern, std::vector<String> &result,
-                     bool recursive = false);
-
-/** @brief OpenCV will try to set the number of threads for subsequent parallel
-regions.
-
-If threads == 1, OpenCV will disable threading optimizations and run all it's
-functions sequentially. Passing threads \< 0 will reset threads number to system
-default. The function is not thread-safe. It must not be called in parallel
-region or concurrent threads.
-
-OpenCV will try to run its functions with specified threads number, but some
-behaviour differs from framework:
--   `TBB` - User-defined parallel constructions will run with the same threads
-number, if another is not specified. If later on user creates his own scheduler,
-OpenCV will use it.
--   `OpenMP` - No special defined behaviour.
--   `Concurrency` - If threads == 1, OpenCV will disable threading optimizations
-and run its functions sequentially.
--   `GCD` - Supports only values \<= 0.
--   `C=` - No special defined behaviour.
-@param nthreads Number of threads used by OpenCV.
-@sa getNumThreads, getThreadNum
- */
-CV_EXPORTS_W void setNumThreads(int nthreads);
-
-/** @brief Returns the number of threads used by OpenCV for parallel regions.
-
-Always returns 1 if OpenCV is built without threading support.
-
-The exact meaning of return value depends on the threading framework used by
-OpenCV library:
-- `TBB` - The number of threads, that OpenCV will try to use for parallel
-regions. If there is any tbb::thread_scheduler_init in user code conflicting
-with OpenCV, then function returns default number of threads used by TBB
-library.
-- `OpenMP` - An upper bound on the number of threads that could be used to form
-a new team.
-- `Concurrency` - The number of threads, that OpenCV will try to use for
-parallel regions.
-- `GCD` - Unsupported; returns the GCD thread pool limit (512) for
-compatibility.
-- `C=` - The number of threads, that OpenCV will try to use for parallel
-regions, if before called setNumThreads with threads \> 0, otherwise returns the
-number of logical CPUs, available for the process.
-@sa setNumThreads, getThreadNum
- */
-CV_EXPORTS_W int getNumThreads();
-
-/** @brief Returns the index of the currently executed thread within the current
-parallel region. Always returns 0 if called outside of parallel region.
-
-@deprecated Current implementation doesn't corresponding to this documentation.
-
-The exact meaning of the return value depends on the threading framework used by
-OpenCV library:
-- `TBB` - Unsupported with current 4.1 TBB release. Maybe will be supported in
-future.
-- `OpenMP` - The thread number, within the current team, of the calling thread.
-- `Concurrency` - An ID for the virtual processor that the current context is
-executing on (0 for master thread and unique number for others, but not
-necessary 1,2,3,...).
-- `GCD` - System calling thread's ID. Never returns 0 inside parallel region.
-- `C=` - The index of the current parallel task.
-@sa setNumThreads, getNumThreads
- */
-CV_EXPORTS_W int getThreadNum();
-
-/** @brief Returns full configuration time cmake output.
-
-Returned value is raw cmake output including version control system revision,
-compiler version, compiler flags, enabled modules and third party libraries,
-etc. Output format depends on target architecture.
- */
-CV_EXPORTS_W const String &getBuildInformation();
-
-/** @brief Returns library version string
-
-For example "3.4.1-dev".
-
-@sa getMajorVersion, getMinorVersion, getRevisionVersion
-*/
-CV_EXPORTS_W String getVersionString();
-
-/** @brief Returns major library version */
-CV_EXPORTS_W int getVersionMajor();
-
-/** @brief Returns minor library version */
-CV_EXPORTS_W int getVersionMinor();
-
-/** @brief Returns revision field of the library version */
-CV_EXPORTS_W int getVersionRevision();
-
-/** @brief Returns the number of ticks.
-
-The function returns the number of ticks after the certain event (for example,
-when the machine was turned on). It can be used to initialize RNG or to measure
-a function execution time by reading the tick count before and after the
-function call.
-@sa getTickFrequency, TickMeter
- */
-CV_EXPORTS_W int64 getTickCount();
-
-/** @brief Returns the number of ticks per second.
-
-The function returns the number of ticks per second. That is, the following code
-computes the execution time in seconds:
-@code
-    double t = (double)getTickCount();
-    // do something ...
-    t = ((double)getTickCount() - t)/getTickFrequency();
-@endcode
-@sa getTickCount, TickMeter
- */
-CV_EXPORTS_W double getTickFrequency();
-
-/** @brief a Class to measure passing time.
-
-The class computes passing time by counting the number of ticks per second. That
-is, the following code computes the execution time in seconds:
-@snippet snippets/core_various.cpp TickMeter_total
-
-It is also possible to compute the average time over multiple runs:
-@snippet snippets/core_various.cpp TickMeter_average
-
-@sa getTickCount, getTickFrequency
-*/
-class CV_EXPORTS_W TickMeter {
-public:
-  //! the default constructor
-  CV_WRAP TickMeter() { reset(); }
-
-  //! starts counting ticks.
-  CV_WRAP void start() { startTime = cv::getTickCount(); }
-
-  //! stops counting ticks.
-  CV_WRAP void stop() {
-    const int64 time = cv::getTickCount();
-    if (startTime == 0)
-      return;
-    ++counter;
-    lastTime = time - startTime;
-    sumTime += lastTime;
-    startTime = 0;
-  }
-
-  //! returns counted ticks.
-  CV_WRAP int64 getTimeTicks() const { return sumTime; }
-
-  //! returns passed time in microseconds.
-  CV_WRAP double getTimeMicro() const { return getTimeMilli() * 1e3; }
-
-  //! returns passed time in milliseconds.
-  CV_WRAP double getTimeMilli() const { return getTimeSec() * 1e3; }
-
-  //! returns passed time in seconds.
-  CV_WRAP double getTimeSec() const {
-    return (double)getTimeTicks() / getTickFrequency();
-  }
-
-  //! returns counted ticks of the last iteration.
-  CV_WRAP int64 getLastTimeTicks() const { return lastTime; }
-
-  //! returns passed time of the last iteration in microseconds.
-  CV_WRAP double getLastTimeMicro() const { return getLastTimeMilli() * 1e3; }
-
-  //! returns passed time of the last iteration in milliseconds.
-  CV_WRAP double getLastTimeMilli() const { return getLastTimeSec() * 1e3; }
-
-  //! returns passed time of the last iteration in seconds.
-  CV_WRAP double getLastTimeSec() const {
-    return (double)getLastTimeTicks() / getTickFrequency();
-  }
-
-  //! returns internal counter value.
-  CV_WRAP int64 getCounter() const { return counter; }
-
-  //! returns average FPS (frames per second) value.
-  CV_WRAP double getFPS() const {
-    const double sec = getTimeSec();
-    if (sec < DBL_EPSILON)
-      return 0.;
-    return counter / sec;
-  }
-
-  //! returns average time in seconds
-  CV_WRAP double getAvgTimeSec() const {
-    if (counter <= 0)
-      return 0.;
-    return getTimeSec() / counter;
-  }
-
-  //! returns average time in milliseconds
-  CV_WRAP double getAvgTimeMilli() const { return getAvgTimeSec() * 1e3; }
-
-  //! resets internal values.
-  CV_WRAP void reset() {
-    counter = 0;
-    sumTime = 0;
-    startTime = 0;
-    lastTime = 0;
-  }
-
-private:
-  int64 counter;
-  int64 sumTime;
-  int64 startTime;
-  int64 lastTime;
-};
-
-/** @brief output operator
-@code
-TickMeter tm;
-tm.start();
-// do something ...
-tm.stop();
-std::cout << tm;
-@endcode
-*/
-
-static inline std::ostream &operator<<(std::ostream &out, const TickMeter &tm) {
-  return out << tm.getTimeSec() << "sec";
-}
-
-/** @brief Returns the number of CPU ticks.
-
-The function returns the current number of CPU ticks on some architectures (such
-as x86, x64, PowerPC). On other platforms the function is equivalent to
-getTickCount. It can also be used for very accurate time measurements, as well
-as for RNG initialization. Note that in case of multi-CPU systems a thread, from
-which getCPUTickCount is called, can be suspended and resumed at another CPU
-with its own counter. So, theoretically (and practically) the subsequent calls
-to the function do not necessary return the monotonously increasing values.
-Also, since a modern CPU varies the CPU frequency depending on the load, the
-number of CPU clocks spent in some code cannot be directly converted to time
-units. Therefore, getTickCount is generally a preferable solution for measuring
-execution time.
- */
-CV_EXPORTS_W int64 getCPUTickCount();
-
-/** @brief Returns true if the specified feature is supported by the host
-hardware.
-
-The function returns true if the host hardware supports the specified feature.
-When user calls setUseOptimized(false), the subsequent calls to
-checkHardwareSupport() will return false until setUseOptimized(true) is called.
-This way user can dynamically switch on and off the optimized code in OpenCV.
-@param feature The feature of interest, one of cv::CpuFeatures
- */
-CV_EXPORTS_W bool checkHardwareSupport(int feature);
-
-/** @brief Returns feature name by ID
-
-Returns empty string if feature is not defined
-*/
-CV_EXPORTS_W String getHardwareFeatureName(int feature);
-
-/** @brief Returns list of CPU features enabled during compilation.
-
-Returned value is a string containing space separated list of CPU features with
-following markers:
-
-- no markers - baseline features
-- prefix `*` - features enabled in dispatcher
-- suffix `?` - features enabled but not available in HW
-
-Example: `SSE SSE2 SSE3 *SSE4.1 *SSE4.2 *FP16 *AVX *AVX2 *AVX512-SKX?`
-*/
-CV_EXPORTS_W std::string getCPUFeaturesLine();
-
-/** @brief Returns the number of logical CPUs available for the process.
- */
-CV_EXPORTS_W int getNumberOfCPUs();
-
-/** @brief Aligns a pointer to the specified number of bytes.
-
-The function returns the aligned pointer of the same type as the input pointer:
-\f[\texttt{(_Tp*)(((size_t)ptr + n-1) & -n)}\f]
-@param ptr Aligned pointer.
-@param n Alignment size that must be a power of two.
- */
-template <typename _Tp>
-static inline _Tp *alignPtr(_Tp *ptr, int n = (int)sizeof(_Tp)) {
-  CV_DbgAssert((n & (n - 1)) == 0); // n is a power of 2
-  return (_Tp *)(((size_t)ptr + n - 1) & -n);
-}
-
-/** @brief Aligns a buffer size to the specified number of bytes.
-
-The function returns the minimum number that is greater than or equal to sz and
-is divisible by n :
-\f[\texttt{(sz + n-1) & -n}\f]
-@param sz Buffer size to align.
-@param n Alignment size that must be a power of two.
- */
-static inline size_t alignSize(size_t sz, int n) {
-  CV_DbgAssert((n & (n - 1)) == 0); // n is a power of 2
-  return (sz + n - 1) & -n;
-}
-
-/** @brief Integer division with result round up.
-
-Use this function instead of `ceil((float)a / b)` expressions.
-
-@sa alignSize
-*/
-static inline int divUp(int a, unsigned int b) {
-  CV_DbgAssert(a >= 0);
-  return (a + b - 1) / b;
-}
-/** @overload */
-static inline size_t divUp(size_t a, unsigned int b) { return (a + b - 1) / b; }
-
-/** @brief Round first value up to the nearest multiple of second value.
-
-Use this function instead of `ceil((float)a / b) * b` expressions.
-
-@sa divUp
-*/
-static inline int roundUp(int a, unsigned int b) {
-  CV_DbgAssert(a >= 0);
-  return a + b - 1 - (a + b - 1) % b;
-}
-/** @overload */
-static inline size_t roundUp(size_t a, unsigned int b) {
-  return a + b - 1 - (a + b - 1) % b;
-}
-
-/** @brief Alignment check of passed values
-
-Usage: `isAligned<sizeof(int)>(...)`
-
-@note Alignment(N) must be a power of 2 (2**k, 2^k)
-*/
-template <int N, typename T> static inline bool isAligned(const T &data) {
-  CV_StaticAssert((N & (N - 1)) == 0, ""); // power of 2
-  return (((size_t)data) & (N - 1)) == 0;
-}
-/** @overload */
-template <int N> static inline bool isAligned(const void *p1) {
-  return isAligned<N>((size_t)p1);
-}
-/** @overload */
-template <int N> static inline bool isAligned(const void *p1, const void *p2) {
-  return isAligned<N>(((size_t)p1) | ((size_t)p2));
-}
-/** @overload */
-template <int N>
-static inline bool isAligned(const void *p1, const void *p2, const void *p3) {
-  return isAligned<N>(((size_t)p1) | ((size_t)p2) | ((size_t)p3));
-}
-/** @overload */
-template <int N>
-static inline bool isAligned(const void *p1, const void *p2, const void *p3,
-                             const void *p4) {
-  return isAligned<N>(((size_t)p1) | ((size_t)p2) | ((size_t)p3) |
-                      ((size_t)p4));
-}
-
-/*! @brief Flags that allow to midify some functions behavior. Used as set of
- * flags.
- */
-enum AlgorithmHint {
-  ALGO_HINT_DEFAULT =
-      0, //!< Default algorithm behaviour defined during OpenCV build
-  ALGO_HINT_ACCURATE = 1, //!< Use generic portable implementation
-  ALGO_HINT_APPROX =
-      2, //!< Allow alternative approximations to get faster implementation.
-         //!< Behaviour and result depends on a platform
-};
-
-/*! @brief Returns AlgorithmHint defined during OpenCV compilation. Defines
- * #ALGO_HINT_DEFAULT behavior.
- */
-CV_EXPORTS_W AlgorithmHint getDefaultAlgorithmHint();
-
-/** @brief Enables or disables the optimized code.
-
-The function can be used to dynamically turn on and off optimized dispatched
-code (code that uses SSE4.2, AVX/AVX2, and other instructions on the platforms
-that support it). It sets a global flag that is further checked by OpenCV
-functions. Since the flag is not checked in the inner OpenCV loops, it is only
-safe to call the function on the very top level in your application where you
-can be sure that no other OpenCV function is currently executed.
-
-By default, the optimized code is enabled unless you disable it in CMake. The
-current status can be retrieved using useOptimized.
-@param onoff The boolean flag specifying whether the optimized code should be
-used (onoff=true) or not (onoff=false).
- */
-CV_EXPORTS_W void setUseOptimized(bool onoff);
-
-/** @brief Returns the status of optimized code usage.
-
-The function returns true if the optimized code is enabled. Otherwise, it
-returns false.
- */
-CV_EXPORTS_W bool useOptimized();
-
-static inline size_t getElemSize(int type) {
-  return (size_t)CV_ELEM_SIZE(type);
-}
-
-/////////////////////////////// Parallel Primitives
-/////////////////////////////////////
-
-/** @brief Base class for parallel data processors
-
-@ingroup core_parallel
-*/
-class CV_EXPORTS ParallelLoopBody {
-public:
-  virtual ~ParallelLoopBody();
-  virtual void operator()(const Range &range) const = 0;
-};
-
-/** @brief Parallel data processor
-
-@ingroup core_parallel
-*/
-CV_EXPORTS void parallel_for_(const Range &range, const ParallelLoopBody &body,
-                              double nstripes = -1.);
-
-//! @ingroup core_parallel
-class ParallelLoopBodyLambdaWrapper : public ParallelLoopBody {
-private:
-  std::function<void(const Range &)> m_functor;
-
-public:
-  inline ParallelLoopBodyLambdaWrapper(
-      std::function<void(const Range &)> functor)
-      : m_functor(functor) {
-    // nothing
-  }
-
-  virtual void operator()(const cv::Range &range) const CV_OVERRIDE {
-    m_functor(range);
-  }
-};
-
-//! @ingroup core_parallel
-static inline void parallel_for_(const Range &range,
-                                 std::function<void(const Range &)> functor,
-                                 double nstripes = -1.) {
-  parallel_for_(range, ParallelLoopBodyLambdaWrapper(functor), nstripes);
-}
-
-/////////////////////////////// forEach method of cv::Mat
-///////////////////////////////
-template <typename _Tp, typename Functor>
-inline void Mat::forEach_impl(const Functor &operation) {
-  if (false) {
-    operation(*reinterpret_cast<_Tp *>(0), reinterpret_cast<int *>(0));
-    // If your compiler fails in this line.
-    // Please check that your functor signature is
-    //     (_Tp&, const int*)   <- multi-dimensional
-    //  or (_Tp&, void*)        <- in case you don't need current idx.
-  }
-
-  CV_Assert(!empty());
-  CV_Assert(this->total() / this->size[this->dims - 1] <= INT_MAX);
-  const int LINES =
-      static_cast<int>(this->total() / this->size[this->dims - 1]);
-
-  class PixelOperationWrapper : public ParallelLoopBody {
-  public:
-    PixelOperationWrapper(Mat_<_Tp> *const frame, const Functor &_operation)
-        : mat(frame), op(_operation) {}
-    virtual ~PixelOperationWrapper() {}
-    // ! Overloaded virtual operator
-    // convert range call to row call.
-    virtual void operator()(const Range &range) const CV_OVERRIDE {
-      const int DIMS = mat->dims;
-      const int COLS = mat->size[DIMS - 1];
-      if (DIMS <= 2) {
-        for (int row = range.start; row < range.end; ++row) {
-          this->rowCall2(row, COLS);
-        }
-      } else {
-        std::vector<int> idx(DIMS); /// idx is modified in this->rowCall
-        idx[DIMS - 2] = range.start - 1;
-
-        for (int line_num = range.start; line_num < range.end; ++line_num) {
-          idx[DIMS - 2]++;
-          for (int i = DIMS - 2; i >= 0; --i) {
-            if (idx[i] >= mat->size[i]) {
-              idx[i - 1] += idx[i] / mat->size[i];
-              idx[i] %= mat->size[i];
-              continue; // carry-over;
-            } else {
-              break;
-            }
-          }
-          this->rowCall(&idx[0], COLS, DIMS);
-        }
-      }
-    }
-
-  private:
-    Mat_<_Tp> *const mat;
-    const Functor op;
-    // ! Call operator for each elements in this row.
-    inline void rowCall(int *const idx, const int COLS, const int DIMS) const {
-      int &col = idx[DIMS - 1];
-      col = 0;
-      _Tp *pixel = &(mat->template at<_Tp>(idx));
-
-      while (col < COLS) {
-        op(*pixel, const_cast<const int *>(idx));
-        pixel++;
-        col++;
-      }
-      col = 0;
-    }
-    // ! Call operator for each elements in this row. 2d mat special version.
-    inline void rowCall2(const int row, const int COLS) const {
-      union Index {
-        int body[2];
-        operator const int *() const {
-          return reinterpret_cast<const int *>(this);
-        }
-        int &operator[](const int i) { return body[i]; }
-      } idx = {{row, 0}};
-      // Special union is needed to avoid
-      // "error: array subscript is above array bounds [-Werror=array-bounds]"
-      // when call the functor `op` such that access idx[3].
-
-      _Tp *pixel = &(mat->template at<_Tp>(idx));
-      const _Tp *const pixel_end = pixel + COLS;
-      while (pixel < pixel_end) {
-        op(*pixel++, static_cast<const int *>(idx));
-        idx[1]++;
-      }
-    }
-    PixelOperationWrapper &operator=(const PixelOperationWrapper &) {
-      CV_Assert(false);
-      // We can not remove this implementation because Visual Studio warning
-      // C4822.
-      return *this;
-    }
-  };
-
-  parallel_for_(
-      cv::Range(0, LINES),
-      PixelOperationWrapper(reinterpret_cast<Mat_<_Tp> *>(this), operation));
-}
-
-/////////////////////////// Synchronization Primitives
-//////////////////////////////////
-
-#if !defined(_M_CEE)
-#ifndef OPENCV_DISABLE_THREAD_SUPPORT
-typedef std::recursive_mutex Mutex;
-typedef std::lock_guard<cv::Mutex> AutoLock;
-#else  // OPENCV_DISABLE_THREAD_SUPPORT
-// Custom (failing) implementation of `std::recursive_mutex`.
-struct Mutex {
-  void lock() {
-    CV_Error(cv::Error::StsNotImplemented,
-             "cv::Mutex is disabled by OPENCV_DISABLE_THREAD_SUPPORT=ON");
-  }
-  void unlock() {
-    CV_Error(cv::Error::StsNotImplemented,
-             "cv::Mutex is disabled by OPENCV_DISABLE_THREAD_SUPPORT=ON");
-  }
-};
-// Stub for cv::AutoLock when threads are disabled.
-struct AutoLock {
-  AutoLock(Mutex &) {}
-};
-#endif // OPENCV_DISABLE_THREAD_SUPPORT
-#endif // !defined(_M_CEE)
-
-/** @brief Designed for command line parsing
-
-The sample below demonstrates how to use CommandLineParser:
-@code
-    CommandLineParser parser(argc, argv, keys);
-    parser.about("Application name v1.0.0");
-
-    if (parser.has("help"))
-    {
-        parser.printMessage();
-        return 0;
-    }
-
-    int N = parser.get<int>("N");
-    double fps = parser.get<double>("fps");
-    String path = parser.get<String>("path");
-
-    use_time_stamp = parser.has("timestamp");
-
-    String img1 = parser.get<String>(0);
-    String img2 = parser.get<String>(1);
-
-    int repeat = parser.get<int>(2);
-
-    if (!parser.check())
-    {
-        parser.printErrors();
-        return 0;
-    }
-@endcode
-
-### Keys syntax
-
-The keys parameter is a string containing several blocks, each one is enclosed
-in curly braces and describes one argument. Each argument contains three parts
-separated by the `|` symbol:
-
--# argument names is a list of option synonyms separated by standard space
-characters ' ' (to mark argument as positional, prefix it with the `@` symbol)
--# default value will be used if the argument was not provided (can be empty)
--# help message (can be empty)
-
-For example:
-
-@code{.cpp}
-    const String keys =
-        "{help h usage ? |      | print this message   }"
-        "{@image1        |      | image1 for compare   }"
-        "{@image2        |<none>| image2 for compare   }"
-        "{@repeat        |1     | number               }"
-        "{path           |.     | path to file         }"
-        "{fps            | -1.0 | fps for output video }"
-        "{N count        |100   | count of objects     }"
-        "{ts timestamp   |      | use time stamp       }"
-        ;
-}
-@endcode
-
-Note that there are no default values for `help` and `timestamp` so we can check
-their presence using the `has()` method. Arguments with default values are
-considered to be always present. Use the `get()` method in these cases to check
-their actual value instead. Note that whitespace characters other than standard
-spaces are considered part of the string. Additionally, leading and trailing
-standard spaces around the help messages are ignored.
-
-String keys like `get<String>("@image1")` return the empty string `""` by
-default - even with an empty default value. Use the special `<none>` default
-value to enforce that the returned string must not be empty. (like in
-`get<String>("@image2")`)
-
-### Usage
-
-For the described keys:
-
-@code{.sh}
-    # Good call (3 positional parameters: image1, image2 and repeat; N is 200,
-ts is true) $ ./app -N=200 1.png 2.jpg 19 -ts
-
-    # Bad call
-    $ ./app -fps=aaa
-    ERRORS:
-    Parameter 'fps': can not convert: [aaa] to [double]
-@endcode
- */
-class CV_EXPORTS CommandLineParser {
-public:
-  /** @brief Constructor
-
-  Initializes command line parser object
-
-  @param argc number of command line arguments (from main())
-  @param argv array of command line arguments (from main())
-  @param keys string describing acceptable command line parameters (see class
-  description for syntax)
-  */
-  CommandLineParser(int argc, const char *const argv[], const String &keys);
-
-  /** @brief Copy constructor */
-  CommandLineParser(const CommandLineParser &parser);
-
-  /** @brief Assignment operator */
-  CommandLineParser &operator=(const CommandLineParser &parser);
-
-  /** @brief Destructor */
-  ~CommandLineParser();
-
-  /** @brief Returns application path
-
-  This method returns the path to the executable from the command line
-  (`argv[0]`).
-
-  For example, if the application has been started with such a command:
-  @code{.sh}
-  $ ./bin/my-executable
-  @endcode
-  this method will return `./bin`.
-  */
-  String getPathToApplication() const;
-
-  /** @brief Access arguments by name
-
-  Returns argument converted to selected type. If the argument is not known or
-  can not be converted to selected type, the error flag is set (can be checked
-  with @ref check).
-
-  For example, define:
-  @code{.cpp}
-  String keys = "{N count||}";
-  @endcode
-
-  Call:
-  @code{.sh}
-  $ ./my-app -N=20
-  # or
-  $ ./my-app --count=20
-  @endcode
-
-  Access:
-  @code{.cpp}
-  int N = parser.get<int>("N");
-  @endcode
-
-  @param name name of the argument
-  @param space_delete remove spaces from the left and right of the string
-  @tparam T the argument will be converted to this type if possible
-
-  @note You can access positional arguments by their `@`-prefixed name:
-  @code{.cpp}
-  parser.get<String>("@image");
-  @endcode
-   */
-  template <typename T>
-  T get(const String &name, bool space_delete = true) const {
-    T val = T();
-    getByName(name, space_delete, ParamType<T>::type, (void *)&val);
-    return val;
-  }
-
-  /** @brief Access positional arguments by index
-
-  Returns argument converted to selected type. Indexes are counted from zero.
-
-  For example, define:
-  @code{.cpp}
-  String keys = "{@arg1||}{@arg2||}"
-  @endcode
-
-  Call:
-  @code{.sh}
-  ./my-app abc qwe
-  @endcode
-
-  Access arguments:
-  @code{.cpp}
-  String val_1 = parser.get<String>(0); // returns "abc", arg1
-  String val_2 = parser.get<String>(1); // returns "qwe", arg2
-  @endcode
-
-  @param index index of the argument
-  @param space_delete remove spaces from the left and right of the string
-  @tparam T the argument will be converted to this type if possible
-   */
-  template <typename T> T get(int index, bool space_delete = true) const {
-    T val = T();
-    getByIndex(index, space_delete, ParamType<T>::type, (void *)&val);
-    return val;
-  }
-
-  /** @brief Check if field was provided in the command line
-
-  @param name argument name to check
-  */
-  bool has(const String &name) const;
-
-  /** @brief Check for parsing errors
-
-  Returns false if error occurred while accessing the parameters (bad
-  conversion, missing arguments, etc.). Call @ref printErrors to print error
-  messages list.
-   */
-  bool check() const;
-
-  /** @brief Set the about message
-
-  The about message will be shown when @ref printMessage is called, right before
-  arguments table.
-   */
-  void about(const String &message);
-
-  /** @brief Print help message
-
-  This method will print standard help message containing the about message and
-  arguments description.
-
-  @sa about
-  */
-  void printMessage() const;
-
-  /** @brief Print list of errors occurred
-
-  @sa check
-  */
-  void printErrors() const;
-
-protected:
-  void getByName(const String &name, bool space_delete, Param type,
-                 void *dst) const;
-  void getByIndex(int index, bool space_delete, Param type, void *dst) const;
-
-  struct Impl;
-  Impl *impl;
-};
-
-//! @} core_utils
-
-//! @cond IGNORED
-
-/////////////////////////////// AutoBuffer implementation
-///////////////////////////////////////////
-
-template <typename _Tp, size_t fixed_size>
-inline AutoBuffer<_Tp, fixed_size>::AutoBuffer() {
-  ptr = buf;
-  sz = fixed_size;
-}
-
-template <typename _Tp, size_t fixed_size>
-inline AutoBuffer<_Tp, fixed_size>::AutoBuffer(size_t _size) {
-  ptr = buf;
-  sz = fixed_size;
-  allocate(_size);
-}
-
-template <typename _Tp, size_t fixed_size>
-inline AutoBuffer<_Tp, fixed_size>::AutoBuffer(
-    const AutoBuffer<_Tp, fixed_size> &abuf) {
-  ptr = buf;
-  sz = fixed_size;
-  allocate(abuf.size());
-  for (size_t i = 0; i < sz; i++)
-    ptr[i] = abuf.ptr[i];
-}
-
-template <typename _Tp, size_t fixed_size>
-inline AutoBuffer<_Tp, fixed_size> &AutoBuffer<_Tp, fixed_size>::operator=(
-    const AutoBuffer<_Tp, fixed_size> &abuf) {
-  if (this != &abuf) {
-    deallocate();
-    allocate(abuf.size());
-    for (size_t i = 0; i < sz; i++)
-      ptr[i] = abuf.ptr[i];
-  }
-  return *this;
-}
-
-template <typename _Tp, size_t fixed_size>
-inline AutoBuffer<_Tp, fixed_size>::~AutoBuffer() {
-  deallocate();
-}
-
-template <typename _Tp, size_t fixed_size>
-inline void AutoBuffer<_Tp, fixed_size>::allocate(size_t _size) {
-  if (_size <= sz) {
-    sz = _size;
-    return;
-  }
-  deallocate();
-  sz = _size;
-  if (_size > fixed_size) {
-    ptr = new _Tp[_size];
-  }
-}
-
-template <typename _Tp, size_t fixed_size>
-inline void AutoBuffer<_Tp, fixed_size>::deallocate() {
-  if (ptr != buf) {
-    delete[] ptr;
-    ptr = buf;
-    sz = fixed_size;
-  }
-}
-
-template <typename _Tp, size_t fixed_size>
-inline void AutoBuffer<_Tp, fixed_size>::resize(size_t _size) {
-  if (_size <= sz) {
-    sz = _size;
-    return;
-  }
-  size_t i, prevsize = sz, minsize = MIN(prevsize, _size);
-  _Tp *prevptr = ptr;
-
-  ptr = _size > fixed_size ? new _Tp[_size] : buf;
-  sz = _size;
-
-  if (ptr != prevptr)
-    for (i = 0; i < minsize; i++)
-      ptr[i] = prevptr[i];
-  for (i = prevsize; i < _size; i++)
-    ptr[i] = _Tp();
-
-  if (prevptr != buf)
-    delete[] prevptr;
-}
-
-template <typename _Tp, size_t fixed_size>
-inline size_t AutoBuffer<_Tp, fixed_size>::size() const {
-  return sz;
-}
-
-//! @endcond
-
-// Basic Node class for tree building
-template <class OBJECT> class CV_EXPORTS Node {
-public:
-  Node() { m_pParent = 0; }
-  Node(OBJECT &payload) : m_payload(payload) { m_pParent = 0; }
-  ~Node() {
-    removeChilds();
-    if (m_pParent) {
-      int idx = m_pParent->findChild(this);
-      if (idx >= 0)
-        m_pParent->m_childs.erase(m_pParent->m_childs.begin() + idx);
-    }
-  }
-
-  Node<OBJECT> *findChild(OBJECT &payload) const {
-    for (size_t i = 0; i < this->m_childs.size(); i++) {
-      if (this->m_childs[i]->m_payload == payload)
-        return this->m_childs[i];
-    }
-    return NULL;
-  }
-
-  int findChild(Node<OBJECT> *pNode) const {
-    for (size_t i = 0; i < this->m_childs.size(); i++) {
-      if (this->m_childs[i] == pNode)
-        return (int)i;
-    }
-    return -1;
-  }
-
-  void addChild(Node<OBJECT> *pNode) {
-    if (!pNode)
-      return;
-
-    CV_Assert(pNode->m_pParent == 0);
-    pNode->m_pParent = this;
-    this->m_childs.push_back(pNode);
-  }
-
-  void removeChilds() {
-    for (size_t i = 0; i < m_childs.size(); i++) {
-      m_childs[i]->m_pParent = 0; // avoid excessive parent vector trimming
-      delete m_childs[i];
-    }
-    m_childs.clear();
-  }
-
-  int getDepth() {
-    int count = 0;
-    Node *pParent = m_pParent;
-    while (pParent)
-      count++, pParent = pParent->m_pParent;
-    return count;
-  }
-
-public:
-  OBJECT m_payload;
-  Node<OBJECT> *m_pParent;
-  std::vector<Node<OBJECT> *> m_childs;
-};
-
-namespace samples {
-
-//! @addtogroup core_utils_samples
-// This section describes utility functions for OpenCV samples.
-//
-// @note Implementation of these utilities is not thread-safe.
-//
-//! @{
-
-/** @brief Try to find requested data file
-
-Search directories:
-
-1. Directories passed via `addSamplesDataSearchPath()`
-2. OPENCV_SAMPLES_DATA_PATH_HINT environment variable
-3. OPENCV_SAMPLES_DATA_PATH environment variable
-   If parameter value is not empty and nothing is found then stop searching.
-4. Detects build/install path based on:
-   a. current working directory (CWD)
-   b. and/or binary module location (opencv_core/opencv_world, doesn't work with
-static linkage)
-5. Scan `<source>/{,data,samples/data}` directories if build directory is
-detected or the current directory is in source tree.
-6. Scan `<install>/share/OpenCV` directory if install directory is detected.
-
-@see cv::utils::findDataFile
-
-@param relative_path Relative path to data file
-@param required Specify "file not found" handling.
-       If true, function prints information message and raises cv::Exception.
-       If false, function returns empty result
-@param silentMode Disables messages
-@return Returns path (absolute or relative to the current directory) or empty
-string if file is not found
-*/
-CV_EXPORTS_W cv::String findFile(const cv::String &relative_path,
-                                 bool required = true, bool silentMode = false);
-
-CV_EXPORTS_W cv::String findFileOrKeep(const cv::String &relative_path,
-                                       bool silentMode = false);
-
-inline cv::String findFileOrKeep(const cv::String &relative_path,
-                                 bool silentMode) {
-  cv::String res = findFile(relative_path, false, silentMode);
-  if (res.empty())
-    return relative_path;
-  return res;
-}
-
-/** @brief Override search data path by adding new search location
-
-Use this only to override default behavior
-Passed paths are used in LIFO order.
-
-@param path Path to used samples data
-*/
-CV_EXPORTS_W void addSamplesDataSearchPath(const cv::String &path);
-
-/** @brief Append samples search data sub directory
-
-General usage is to add OpenCV modules name
-(`<opencv_contrib>/modules/<name>/samples/data` -> `<name>/samples/data` +
-`modules/<name>/samples/data`). Passed subdirectories are used in LIFO order.
-
-@param subdir samples data sub directory
-*/
-CV_EXPORTS_W void addSamplesDataSearchSubDirectory(const cv::String &subdir);
-
-//! @}
-} // namespace samples
-
-namespace utils {
-
-CV_EXPORTS int getThreadID();
-
-} // namespace utils
-
-} // namespace cv
-
-#ifdef CV_COLLECT_IMPL_DATA
-#include "opencv2/core/utils/instrumentation.hpp"
-#else
-/// Collect implementation data on OpenCV function call. Requires
-/// ENABLE_IMPL_COLLECTION build option.
-#define CV_IMPL_ADD(impl)
-#endif
-
-#endif // OPENCV_CORE_UTILITY_H
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/utils/allocator_stats.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/utils/allocator_stats.hpp
deleted file mode 100644
index b6552d28ac..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/utils/allocator_stats.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_CORE_ALLOCATOR_STATS_HPP
-#define OPENCV_CORE_ALLOCATOR_STATS_HPP
-
-#include "../cvdef.h"
-
-namespace cv {
-namespace utils {
-
-class AllocatorStatisticsInterface {
-protected:
-  AllocatorStatisticsInterface() {}
-  virtual ~AllocatorStatisticsInterface() {}
-
-public:
-  virtual uint64_t getCurrentUsage() const = 0;
-  virtual uint64_t getTotalUsage() const = 0;
-  virtual uint64_t getNumberOfAllocations() const = 0;
-  virtual uint64_t getPeakUsage() const = 0;
-
-  /** set peak usage = current usage */
-  virtual void resetPeakUsage() = 0;
-};
-
-} // namespace utils
-} // namespace cv
-
-#endif // OPENCV_CORE_ALLOCATOR_STATS_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/utils/allocator_stats.impl.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/utils/allocator_stats.impl.hpp
deleted file mode 100644
index a15639165d..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/utils/allocator_stats.impl.hpp
+++ /dev/null
@@ -1,111 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_CORE_ALLOCATOR_STATS_IMPL_HPP
-#define OPENCV_CORE_ALLOCATOR_STATS_IMPL_HPP
-
-#include "./allocator_stats.hpp"
-
-// #define OPENCV_DISABLE_ALLOCATOR_STATS
-
-#include <atomic>
-
-#ifndef OPENCV_ALLOCATOR_STATS_COUNTER_TYPE
-#if defined(__GNUC__) &&                                                       \
-    ((defined(__SIZEOF_POINTER__) && __SIZEOF_POINTER__ == 4) ||               \
-     (defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4) &&                           \
-      !defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)))
-#define OPENCV_ALLOCATOR_STATS_COUNTER_TYPE int
-#endif
-#endif
-
-#ifndef OPENCV_ALLOCATOR_STATS_COUNTER_TYPE
-#define OPENCV_ALLOCATOR_STATS_COUNTER_TYPE long long
-#endif
-
-namespace cv {
-namespace utils {
-
-#ifdef CV__ALLOCATOR_STATS_LOG
-namespace {
-#endif
-
-class AllocatorStatistics : public AllocatorStatisticsInterface {
-#ifdef OPENCV_DISABLE_ALLOCATOR_STATS
-
-public:
-  AllocatorStatistics() {}
-  ~AllocatorStatistics() CV_OVERRIDE {}
-
-  uint64_t getCurrentUsage() const CV_OVERRIDE { return 0; }
-  uint64_t getTotalUsage() const CV_OVERRIDE { return 0; }
-  uint64_t getNumberOfAllocations() const CV_OVERRIDE { return 0; }
-  uint64_t getPeakUsage() const CV_OVERRIDE { return 0; }
-
-  /** set peak usage = current usage */
-  void resetPeakUsage() CV_OVERRIDE {};
-
-  void onAllocate(size_t /*sz*/) {}
-  void onFree(size_t /*sz*/) {}
-
-#else
-
-protected:
-  typedef OPENCV_ALLOCATOR_STATS_COUNTER_TYPE counter_t;
-  std::atomic<counter_t> curr, total, total_allocs, peak;
-
-public:
-  AllocatorStatistics() {}
-  ~AllocatorStatistics() CV_OVERRIDE {}
-
-  uint64_t getCurrentUsage() const CV_OVERRIDE { return (uint64_t)curr.load(); }
-  uint64_t getTotalUsage() const CV_OVERRIDE { return (uint64_t)total.load(); }
-  uint64_t getNumberOfAllocations() const CV_OVERRIDE {
-    return (uint64_t)total_allocs.load();
-  }
-  uint64_t getPeakUsage() const CV_OVERRIDE { return (uint64_t)peak.load(); }
-
-  /** set peak usage = current usage */
-  void resetPeakUsage() CV_OVERRIDE { peak.store(curr.load()); }
-
-  // Controller interface
-  void onAllocate(size_t sz) {
-#ifdef CV__ALLOCATOR_STATS_LOG
-    CV__ALLOCATOR_STATS_LOG(cv::format("allocate: %lld (curr=%lld)",
-                                       (long long int)sz,
-                                       (long long int)curr.load()));
-#endif
-
-    counter_t new_curr = curr.fetch_add((counter_t)sz) + (counter_t)sz;
-
-    // peak = std::max((uint64_t)peak, new_curr);
-    auto prev_peak = peak.load();
-    while (prev_peak < new_curr) {
-      if (peak.compare_exchange_weak(prev_peak, new_curr))
-        break;
-    }
-    // end of peak = max(...)
-
-    total += (counter_t)sz;
-    total_allocs++;
-  }
-  void onFree(size_t sz) {
-#ifdef CV__ALLOCATOR_STATS_LOG
-    CV__ALLOCATOR_STATS_LOG(cv::format("free: %lld (curr=%lld)",
-                                       (long long int)sz,
-                                       (long long int)curr.load()));
-#endif
-    curr -= (counter_t)sz;
-  }
-#endif // OPENCV_DISABLE_ALLOCATOR_STATS
-};
-
-#ifdef CV__ALLOCATOR_STATS_LOG
-} // namespace
-#endif
-
-} // namespace utils
-} // namespace cv
-
-#endif // OPENCV_CORE_ALLOCATOR_STATS_IMPL_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/utils/filesystem.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/utils/filesystem.hpp
deleted file mode 100644
index 536722d6b5..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/utils/filesystem.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_UTILS_FILESYSTEM_HPP
-#define OPENCV_UTILS_FILESYSTEM_HPP
-
-namespace cv {
-namespace utils {
-namespace fs {
-
-CV_EXPORTS bool exists(const cv::String &path);
-CV_EXPORTS bool isDirectory(const cv::String &path);
-
-CV_EXPORTS void remove_all(const cv::String &path);
-
-CV_EXPORTS cv::String getcwd();
-
-/** @brief Converts path p to a canonical absolute path
- * Symlinks are processed if there is support for them on running platform.
- *
- * @param path input path. Target file/directory should exist.
- */
-CV_EXPORTS cv::String canonical(const cv::String &path);
-
-/** Join path components */
-CV_EXPORTS cv::String join(const cv::String &base, const cv::String &path);
-
-/** Get parent directory */
-CV_EXPORTS cv::String getParent(const cv::String &path);
-CV_EXPORTS std::wstring getParent(const std::wstring &path);
-
-/**
- * Generate a list of all files that match the globbing pattern.
- *
- * Result entries are prefixed by base directory path.
- *
- * @param directory base directory
- * @param pattern filter pattern (based on '*'/'?' symbols). Use empty string to
- * disable filtering and return all results
- * @param[out] result result of globing.
- * @param recursive scan nested directories too
- * @param includeDirectories include directories into results list
- */
-CV_EXPORTS void glob(const cv::String &directory, const cv::String &pattern,
-                     CV_OUT std::vector<cv::String> &result,
-                     bool recursive = false, bool includeDirectories = false);
-
-/**
- * Generate a list of all files that match the globbing pattern.
- *
- * @param directory base directory
- * @param pattern filter pattern (based on '*'/'?' symbols). Use empty string to
- * disable filtering and return all results
- * @param[out] result globbing result with relative paths from base directory
- * @param recursive scan nested directories too
- * @param includeDirectories include directories into results list
- */
-CV_EXPORTS void glob_relative(const cv::String &directory,
-                              const cv::String &pattern,
-                              CV_OUT std::vector<cv::String> &result,
-                              bool recursive = false,
-                              bool includeDirectories = false);
-
-CV_EXPORTS bool createDirectory(const cv::String &path);
-CV_EXPORTS bool createDirectories(const cv::String &path);
-
-#if defined(__OPENCV_BUILD) || defined(BUILD_PLUGIN)
-// TODO
-// CV_EXPORTS cv::String getTempDirectory();
-
-/**
- * @brief Returns directory to store OpenCV cache files
- * Create sub-directory in common OpenCV cache directory if it doesn't exist.
- * @param sub_directory_name name of sub-directory. NULL or "" value asks to
- * return root cache directory.
- * @param configuration_name optional name of configuration parameter name which
- * overrides default behavior.
- * @return Path to cache directory. Returns empty string if cache directories
- * support is not available. Returns "disabled" if cache disabled by user.
- */
-CV_EXPORTS cv::String getCacheDirectory(const char *sub_directory_name,
-                                        const char *configuration_name = NULL);
-
-#endif
-
-} // namespace fs
-} // namespace utils
-} // namespace cv
-
-#endif // OPENCV_UTILS_FILESYSTEM_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/utils/fp_control_utils.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/utils/fp_control_utils.hpp
deleted file mode 100644
index 7aaf5fcf33..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/utils/fp_control_utils.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_CORE_FP_CONTROL_UTILS_HPP
-#define OPENCV_CORE_FP_CONTROL_UTILS_HPP
-
-namespace cv {
-
-namespace details {
-
-struct FPDenormalsModeState {
-  uint32_t reserved[16]; // 64-bytes
-}; // FPDenormalsModeState
-
-CV_EXPORTS void setFPDenormalsIgnoreHint(bool ignore,
-                                         CV_OUT FPDenormalsModeState &state);
-CV_EXPORTS int saveFPDenormalsState(CV_OUT FPDenormalsModeState &state);
-CV_EXPORTS bool restoreFPDenormalsState(const FPDenormalsModeState &state);
-
-class FPDenormalsIgnoreHintScope {
-public:
-  inline explicit FPDenormalsIgnoreHintScope(bool ignore = true) {
-    details::setFPDenormalsIgnoreHint(ignore, saved_state);
-  }
-
-  inline explicit FPDenormalsIgnoreHintScope(
-      const FPDenormalsModeState &state) {
-    details::saveFPDenormalsState(saved_state);
-    details::restoreFPDenormalsState(state);
-  }
-
-  inline ~FPDenormalsIgnoreHintScope() {
-    details::restoreFPDenormalsState(saved_state);
-  }
-
-protected:
-  FPDenormalsModeState saved_state;
-}; // FPDenormalsIgnoreHintScope
-
-class FPDenormalsIgnoreHintScopeNOOP {
-public:
-  inline FPDenormalsIgnoreHintScopeNOOP(bool ignore = true) {
-    CV_UNUSED(ignore);
-  }
-  inline FPDenormalsIgnoreHintScopeNOOP(const FPDenormalsModeState &state) {
-    CV_UNUSED(state);
-  }
-  inline ~FPDenormalsIgnoreHintScopeNOOP() {}
-}; // FPDenormalsIgnoreHintScopeNOOP
-
-} // namespace details
-
-// Should depend on target compilation architecture only
-// Note: previously added archs should NOT be removed to preserve ABI
-// compatibility
-#if defined(OPENCV_SUPPORTS_FP_DENORMALS_HINT)
-  // preserve configuration overloading through ports
-#elif defined(__i386__) || defined(__x86_64__) || defined(_M_X64) ||           \
-    defined(_X86_)
-typedef details::FPDenormalsIgnoreHintScope FPDenormalsIgnoreHintScope;
-#define OPENCV_SUPPORTS_FP_DENORMALS_HINT 1
-#else
-#define OPENCV_SUPPORTS_FP_DENORMALS_HINT 0
-typedef details::FPDenormalsIgnoreHintScopeNOOP FPDenormalsIgnoreHintScope;
-#endif
-
-} // namespace cv
-
-#endif // OPENCV_CORE_FP_CONTROL_UTILS_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/utils/instrumentation.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/utils/instrumentation.hpp
deleted file mode 100644
index 6d8630132a..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/utils/instrumentation.hpp
+++ /dev/null
@@ -1,127 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_UTILS_INSTR_HPP
-#define OPENCV_UTILS_INSTR_HPP
-
-#include <opencv2/core/utility.hpp>
-#include <opencv2/core/utils/tls.hpp>
-
-namespace cv {
-
-//! @addtogroup core_utils
-//! @{
-
-#ifdef CV_COLLECT_IMPL_DATA
-CV_EXPORTS void
-setImpl(int flags); // set implementation flags and reset storage arrays
-CV_EXPORTS void
-addImpl(int flag,
-        const char *func =
-            0); // add implementation and function name to storage arrays
-// Get stored implementation flags and functions names arrays
-// Each implementation entry correspond to function name entry, so you can find
-// which implementation was executed in which function
-CV_EXPORTS int getImpl(std::vector<int> &impl, std::vector<String> &funName);
-
-CV_EXPORTS bool useCollection(); // return implementation collection state
-CV_EXPORTS void
-setUseCollection(bool flag); // set implementation collection state
-
-#define CV_IMPL_PLAIN 0x01 // native CPU OpenCV implementation
-#define CV_IMPL_OCL 0x02   // OpenCL implementation
-#define CV_IMPL_IPP 0x04   // IPP implementation
-#define CV_IMPL_MT 0x10    // multithreaded implementation
-
-#undef CV_IMPL_ADD
-#define CV_IMPL_ADD(impl)                                                      \
-  if (cv::useCollection()) {                                                   \
-    cv::addImpl(impl, CV_Func);                                                \
-  }
-#endif
-
-// Instrumentation external interface
-namespace instr {
-
-#if !defined OPENCV_ABI_CHECK
-
-enum TYPE {
-  TYPE_GENERAL = 0, // OpenCV API function, e.g. exported function
-  TYPE_MARKER,      // Information marker
-  TYPE_WRAPPER,     // Wrapper function for implementation
-  TYPE_FUN,         // Simple function call
-};
-
-enum IMPL {
-  IMPL_PLAIN = 0,
-  IMPL_IPP,
-  IMPL_OPENCL,
-};
-
-struct NodeDataTls {
-  NodeDataTls() { m_ticksTotal = 0; }
-  uint64 m_ticksTotal;
-};
-
-class CV_EXPORTS NodeData {
-public:
-  NodeData(const char *funName = 0, const char *fileName = NULL,
-           int lineNum = 0, void *retAddress = NULL, bool alwaysExpand = false,
-           cv::instr::TYPE instrType = TYPE_GENERAL,
-           cv::instr::IMPL implType = IMPL_PLAIN);
-  NodeData(NodeData &ref);
-  ~NodeData();
-  NodeData &operator=(const NodeData &);
-
-  cv::String m_funName;
-  cv::instr::TYPE m_instrType;
-  cv::instr::IMPL m_implType;
-  const char *m_fileName;
-  int m_lineNum;
-  void *m_retAddress;
-  bool m_alwaysExpand;
-  bool m_funError;
-
-  volatile int m_counter;
-  volatile uint64 m_ticksTotal;
-  TLSDataAccumulator<NodeDataTls> m_tls;
-  int m_threads;
-
-  // No synchronization
-  double getTotalMs() const {
-    return ((double)m_ticksTotal / cv::getTickFrequency()) * 1000;
-  }
-  double getMeanMs() const {
-    return (((double)m_ticksTotal / m_counter) / cv::getTickFrequency()) * 1000;
-  }
-};
-bool operator==(const NodeData &lhs, const NodeData &rhs);
-
-typedef Node<NodeData> InstrNode;
-
-CV_EXPORTS InstrNode *getTrace();
-
-#endif // !defined OPENCV_ABI_CHECK
-
-CV_EXPORTS bool useInstrumentation();
-CV_EXPORTS void setUseInstrumentation(bool flag);
-CV_EXPORTS void resetTrace();
-
-enum FLAGS {
-  FLAGS_NONE = 0,
-  FLAGS_MAPPING = 0x01,
-  FLAGS_EXPAND_SAME_NAMES = 0x02,
-};
-
-CV_EXPORTS void setFlags(FLAGS modeFlags);
-static inline void setFlags(int modeFlags) { setFlags((FLAGS)modeFlags); }
-CV_EXPORTS FLAGS getFlags();
-
-} // namespace instr
-
-//! @}
-
-} // namespace cv
-
-#endif // OPENCV_UTILS_TLS_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/utils/logger.defines.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/utils/logger.defines.hpp
deleted file mode 100644
index 69383dd8c1..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/utils/logger.defines.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_LOGGER_DEFINES_HPP
-#define OPENCV_LOGGER_DEFINES_HPP
-
-//! @addtogroup core_logging
-//! @{
-
-// Supported logging levels and their semantic
-#define CV_LOG_LEVEL_SILENT 0 //!< for using in setLogLevel() call
-#define CV_LOG_LEVEL_FATAL                                                     \
-  1 //!< Fatal (critical) error (unrecoverable internal error)
-#define CV_LOG_LEVEL_ERROR 2 //!< Error message
-#define CV_LOG_LEVEL_WARN 3  //!< Warning message
-#define CV_LOG_LEVEL_INFO 4  //!< Info message
-#define CV_LOG_LEVEL_DEBUG                                                     \
-  5 //!< Debug message. Disabled in the "Release" build.
-#define CV_LOG_LEVEL_VERBOSE                                                   \
-  6 //!< Verbose (trace) messages. Requires verbosity level. Disabled in the
-    //!< "Release" build.
-
-namespace cv {
-namespace utils {
-namespace logging {
-
-//! Supported logging levels and their semantic
-enum LogLevel {
-  LOG_LEVEL_SILENT = 0, //!< for using in setLogVevel() call
-  LOG_LEVEL_FATAL =
-      1, //!< Fatal (critical) error (unrecoverable internal error)
-  LOG_LEVEL_ERROR = 2,   //!< Error message
-  LOG_LEVEL_WARNING = 3, //!< Warning message
-  LOG_LEVEL_INFO = 4,    //!< Info message
-  LOG_LEVEL_DEBUG = 5,   //!< Debug message. Disabled in the "Release" build.
-  LOG_LEVEL_VERBOSE = 6, //!< Verbose (trace) messages. Requires verbosity
-                         //!< level. Disabled in the "Release" build.
-#ifndef CV_DOXYGEN
-  ENUM_LOG_LEVEL_FORCE_INT = INT_MAX
-#endif
-};
-
-} // namespace logging
-} // namespace utils
-} // namespace cv
-
-//! @}
-
-#endif // OPENCV_LOGGER_DEFINES_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/utils/logger.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/utils/logger.hpp
deleted file mode 100644
index 213158ce61..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/utils/logger.hpp
+++ /dev/null
@@ -1,258 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_LOGGER_HPP
-#define OPENCV_LOGGER_HPP
-
-#include <iostream>
-#include <limits.h> // INT_MAX
-#include <sstream>
-
-#include "logger.defines.hpp"
-#include "logtag.hpp"
-
-namespace cv {
-namespace utils {
-namespace logging {
-
-//! @addtogroup core_logging
-//! @{
-
-/** Set global logging level
-@return previous logging level
-*/
-CV_EXPORTS LogLevel setLogLevel(LogLevel logLevel);
-/** Get global logging level */
-CV_EXPORTS LogLevel getLogLevel();
-
-CV_EXPORTS void registerLogTag(cv::utils::logging::LogTag *plogtag);
-
-CV_EXPORTS void setLogTagLevel(const char *tag,
-                               cv::utils::logging::LogLevel level);
-
-CV_EXPORTS cv::utils::logging::LogLevel getLogTagLevel(const char *tag);
-
-namespace internal {
-
-/** Get global log tag */
-CV_EXPORTS cv::utils::logging::LogTag *getGlobalLogTag();
-
-/** Write log message */
-CV_EXPORTS void writeLogMessage(LogLevel logLevel, const char *message);
-
-/** Write log message */
-CV_EXPORTS void writeLogMessageEx(LogLevel logLevel, const char *tag,
-                                  const char *file, int line, const char *func,
-                                  const char *message);
-
-} // namespace internal
-
-struct LogTagAuto : public LogTag {
-  inline LogTagAuto(const char *_name, LogLevel _level)
-      : LogTag(_name, _level) {
-    registerLogTag(this);
-  }
-};
-
-/**
- * \def CV_LOG_STRIP_LEVEL
- *
- * Define CV_LOG_STRIP_LEVEL=CV_LOG_LEVEL_[DEBUG|INFO|WARN|ERROR|FATAL|SILENT]
- * to compile out anything at that and before that logging level
- */
-#ifndef CV_LOG_STRIP_LEVEL
-#if defined NDEBUG
-#define CV_LOG_STRIP_LEVEL CV_LOG_LEVEL_DEBUG
-#else
-#define CV_LOG_STRIP_LEVEL CV_LOG_LEVEL_VERBOSE
-#endif
-#endif
-
-#define CV_LOGTAG_PTR_CAST(expr)                                               \
-  static_cast<const cv::utils::logging::LogTag *>(expr)
-
-// CV_LOGTAG_EXPAND_NAME is intended to be re-defined (undef and then define
-// again) to allows logging users to use a shorter name argument when calling
-// CV_LOG_WITH_TAG or its related macros such as CV_LOG_INFO.
-//
-// This macro is intended to modify the tag argument as a string (token), via
-// preprocessor token pasting or metaprogramming techniques. A typical usage
-// is to apply a prefix, such as
-// ...... #define CV_LOGTAG_EXPAND_NAME(tag) cv_logtag_##tag
-//
-// It is permitted to re-define to a hard-coded expression, ignoring the tag.
-// This would work identically like the CV_LOGTAG_FALLBACK macro.
-//
-// Important: When the logging macro is called with tag being NULL, a
-// user-defined CV_LOGTAG_EXPAND_NAME may expand it into cv_logtag_0,
-// cv_logtag_NULL, or cv_logtag_nullptr. Use with care. Also be mindful of C++
-// symbol redefinitions.
-//
-// If there is significant amount of logging code with tag being NULL, it is
-// recommended to use (re-define) CV_LOGTAG_FALLBACK to inject locally a default
-// tag at the beginning of a compilation unit, to minimize lines of code
-// changes.
-//
-#define CV_LOGTAG_EXPAND_NAME(tag) tag
-
-// CV_LOGTAG_FALLBACK is intended to be re-defined (undef and then define again)
-// by any other compilation units to provide a log tag when the logging
-// statement does not specify one. The macro needs to expand into a C++
-// expression that can be static_cast into (cv::utils::logging::LogTag*). Null
-// (nullptr) is permitted.
-#define CV_LOGTAG_FALLBACK nullptr
-
-// CV_LOGTAG_GLOBAL is the tag used when a log tag is not specified in the
-// logging statement nor the compilation unit. The macro needs to expand into a
-// C++ expression that can be static_cast into (cv::utils::logging::LogTag*).
-// Must be non-null. Do not re-define.
-#define CV_LOGTAG_GLOBAL cv::utils::logging::internal::getGlobalLogTag()
-
-#define CV_LOG_WITH_TAG(tag, msgLevel, extra_check0, extra_check1, ...)        \
-  for (;;) {                                                                   \
-    extra_check0;                                                              \
-    const auto cv_temp_msglevel = (cv::utils::logging::LogLevel)(msgLevel);    \
-    if (cv_temp_msglevel >= (CV_LOG_STRIP_LEVEL))                              \
-      break;                                                                   \
-    auto cv_temp_logtagptr = CV_LOGTAG_PTR_CAST(CV_LOGTAG_EXPAND_NAME(tag));   \
-    if (!cv_temp_logtagptr)                                                    \
-      cv_temp_logtagptr = CV_LOGTAG_PTR_CAST(CV_LOGTAG_FALLBACK);              \
-    if (!cv_temp_logtagptr)                                                    \
-      cv_temp_logtagptr = CV_LOGTAG_PTR_CAST(CV_LOGTAG_GLOBAL);                \
-    if (cv_temp_logtagptr && (cv_temp_msglevel > cv_temp_logtagptr->level))    \
-      break;                                                                   \
-    extra_check1;                                                              \
-    std::stringstream cv_temp_logstream;                                       \
-    cv_temp_logstream << __VA_ARGS__;                                          \
-    cv::utils::logging::internal::writeLogMessageEx(                           \
-        cv_temp_msglevel,                                                      \
-        (cv_temp_logtagptr ? cv_temp_logtagptr->name : nullptr), __FILE__,     \
-        __LINE__, CV_Func, cv_temp_logstream.str().c_str());                   \
-    break;                                                                     \
-  }
-
-#define CV_LOG_FATAL(tag, ...)                                                 \
-  CV_LOG_WITH_TAG(tag, cv::utils::logging::LOG_LEVEL_FATAL, , , __VA_ARGS__)
-#define CV_LOG_ERROR(tag, ...)                                                 \
-  CV_LOG_WITH_TAG(tag, cv::utils::logging::LOG_LEVEL_ERROR, , , __VA_ARGS__)
-#define CV_LOG_WARNING(tag, ...)                                               \
-  CV_LOG_WITH_TAG(tag, cv::utils::logging::LOG_LEVEL_WARNING, , , __VA_ARGS__)
-#define CV_LOG_INFO(tag, ...)                                                  \
-  CV_LOG_WITH_TAG(tag, cv::utils::logging::LOG_LEVEL_INFO, , , __VA_ARGS__)
-#define CV_LOG_DEBUG(tag, ...)                                                 \
-  CV_LOG_WITH_TAG(tag, cv::utils::logging::LOG_LEVEL_DEBUG, , , __VA_ARGS__)
-#define CV_LOG_VERBOSE(tag, v, ...)                                            \
-  CV_LOG_WITH_TAG(tag, (cv::utils::logging::LOG_LEVEL_VERBOSE + (int)(v)), , , \
-                  __VA_ARGS__)
-
-#if CV_LOG_STRIP_LEVEL <= CV_LOG_LEVEL_INFO
-#undef CV_LOG_INFO
-#define CV_LOG_INFO(tag, ...)
-#endif
-
-#if CV_LOG_STRIP_LEVEL <= CV_LOG_LEVEL_DEBUG
-#undef CV_LOG_DEBUG
-#define CV_LOG_DEBUG(tag, ...)
-#endif
-
-#if CV_LOG_STRIP_LEVEL <= CV_LOG_LEVEL_VERBOSE
-#undef CV_LOG_VERBOSE
-#define CV_LOG_VERBOSE(tag, v, ...)
-#endif
-
-//! @cond IGNORED
-#define CV__LOG_ONCE_CHECK_PRE                                                 \
-  static bool _cv_log_once_##__LINE__ = false;                                 \
-  if (_cv_log_once_##__LINE__)                                                 \
-    break;
-
-#define CV__LOG_ONCE_CHECK_POST _cv_log_once_##__LINE__ = true;
-
-#define CV__LOG_IF_CHECK(logging_cond)                                         \
-  if (!(logging_cond))                                                         \
-    break;
-
-//! @endcond
-
-// CV_LOG_ONCE_XXX macros
-
-#define CV_LOG_ONCE_ERROR(tag, ...)                                            \
-  CV_LOG_WITH_TAG(tag, cv::utils::logging::LOG_LEVEL_ERROR,                    \
-                  CV__LOG_ONCE_CHECK_PRE, CV__LOG_ONCE_CHECK_POST,             \
-                  __VA_ARGS__)
-#define CV_LOG_ONCE_WARNING(tag, ...)                                          \
-  CV_LOG_WITH_TAG(tag, cv::utils::logging::LOG_LEVEL_WARNING,                  \
-                  CV__LOG_ONCE_CHECK_PRE, CV__LOG_ONCE_CHECK_POST,             \
-                  __VA_ARGS__)
-#define CV_LOG_ONCE_INFO(tag, ...)                                             \
-  CV_LOG_WITH_TAG(tag, cv::utils::logging::LOG_LEVEL_INFO,                     \
-                  CV__LOG_ONCE_CHECK_PRE, CV__LOG_ONCE_CHECK_POST,             \
-                  __VA_ARGS__)
-#define CV_LOG_ONCE_DEBUG(tag, ...)                                            \
-  CV_LOG_WITH_TAG(tag, cv::utils::logging::LOG_LEVEL_DEBUG,                    \
-                  CV__LOG_ONCE_CHECK_PRE, CV__LOG_ONCE_CHECK_POST,             \
-                  __VA_ARGS__)
-#define CV_LOG_ONCE_VERBOSE(tag, v, ...)                                       \
-  CV_LOG_WITH_TAG(tag, (cv::utils::logging::LOG_LEVEL_VERBOSE + (int)(v)),     \
-                  CV__LOG_ONCE_CHECK_PRE, CV__LOG_ONCE_CHECK_POST,             \
-                  __VA_ARGS__)
-
-#if CV_LOG_STRIP_LEVEL <= CV_LOG_LEVEL_INFO
-#undef CV_LOG_ONCE_INFO
-#define CV_LOG_ONCE_INFO(tag, ...)
-#endif
-
-#if CV_LOG_STRIP_LEVEL <= CV_LOG_LEVEL_DEBUG
-#undef CV_LOG_ONCE_DEBUG
-#define CV_LOG_ONCE_DEBUG(tag, ...)
-#endif
-
-#if CV_LOG_STRIP_LEVEL <= CV_LOG_LEVEL_VERBOSE
-#undef CV_LOG_ONCE_VERBOSE
-#define CV_LOG_ONCE_VERBOSE(tag, v, ...)
-#endif
-
-// CV_LOG_IF_XXX macros
-
-#define CV_LOG_IF_FATAL(tag, logging_cond, ...)                                \
-  CV_LOG_WITH_TAG(tag, cv::utils::logging::LOG_LEVEL_FATAL, ,                  \
-                  CV__LOG_IF_CHECK(logging_cond), __VA_ARGS__)
-#define CV_LOG_IF_ERROR(tag, logging_cond, ...)                                \
-  CV_LOG_WITH_TAG(tag, cv::utils::logging::LOG_LEVEL_ERROR, ,                  \
-                  CV__LOG_IF_CHECK(logging_cond), __VA_ARGS__)
-#define CV_LOG_IF_WARNING(tag, logging_cond, ...)                              \
-  CV_LOG_WITH_TAG(tag, cv::utils::logging::LOG_LEVEL_WARNING, ,                \
-                  CV__LOG_IF_CHECK(logging_cond), __VA_ARGS__)
-#define CV_LOG_IF_INFO(tag, logging_cond, ...)                                 \
-  CV_LOG_WITH_TAG(tag, cv::utils::logging::LOG_LEVEL_INFO, ,                   \
-                  CV__LOG_IF_CHECK(logging_cond), __VA_ARGS__)
-#define CV_LOG_IF_DEBUG(tag, logging_cond, ...)                                \
-  CV_LOG_WITH_TAG(tag, cv::utils::logging::LOG_LEVEL_DEBUG, ,                  \
-                  CV__LOG_IF_CHECK(logging_cond), __VA_ARGS__)
-#define CV_LOG_IF_VERBOSE(tag, v, logging_cond, ...)                           \
-  CV_LOG_WITH_TAG(tag, (cv::utils::logging::LOG_LEVEL_VERBOSE + (int)(v)), ,   \
-                  CV__LOG_IF_CHECK(logging_cond), __VA_ARGS__)
-
-#if CV_LOG_STRIP_LEVEL <= CV_LOG_LEVEL_INFO
-#undef CV_LOG_IF_INFO
-#define CV_LOG_IF_INFO(tag, logging_cond, ...)
-#endif
-
-#if CV_LOG_STRIP_LEVEL <= CV_LOG_LEVEL_DEBUG
-#undef CV_LOG_IF_DEBUG
-#define CV_LOG_IF_DEBUG(tag, logging_cond, ...)
-#endif
-
-#if CV_LOG_STRIP_LEVEL <= CV_LOG_LEVEL_VERBOSE
-#undef CV_LOG_IF_VERBOSE
-#define CV_LOG_IF_VERBOSE(tag, v, logging_cond, ...)
-#endif
-
-//! @}
-
-} // namespace logging
-} // namespace utils
-} // namespace cv
-
-#endif // OPENCV_LOGGER_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/utils/logtag.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/utils/logtag.hpp
deleted file mode 100644
index ac1cb9f3d8..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/utils/logtag.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_CORE_LOGTAG_HPP
-#define OPENCV_CORE_LOGTAG_HPP
-
-#include "logger.defines.hpp"
-#include "opencv2/core/cvstd.hpp"
-
-namespace cv {
-namespace utils {
-namespace logging {
-
-struct LogTag {
-  const char *name;
-  LogLevel level;
-
-  inline LogTag(const char *_name, LogLevel _level)
-      : name(_name), level(_level) {}
-};
-
-} // namespace logging
-} // namespace utils
-} // namespace cv
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/utils/tls.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/utils/tls.hpp
deleted file mode 100644
index ae7b14845f..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/utils/tls.hpp
+++ /dev/null
@@ -1,230 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_UTILS_TLS_HPP
-#define OPENCV_UTILS_TLS_HPP
-
-#ifndef OPENCV_CORE_UTILITY_H
-#error                                                                         \
-    "tls.hpp must be included after opencv2/core/utility.hpp or opencv2/core.hpp"
-#endif
-
-namespace cv {
-
-//! @addtogroup core_utils
-//! @{
-
-namespace details {
-class TlsStorage;
-}
-
-/** TLS container base implementation
- *
- * Don't use directly.
- *
- * @sa TLSData, TLSDataAccumulator templates
- */
-class CV_EXPORTS TLSDataContainer {
-protected:
-  TLSDataContainer();
-  virtual ~TLSDataContainer();
-
-  /// @deprecated use detachData() instead
-  void gatherData(std::vector<void *> &data) const;
-  /// get TLS data and detach all data from threads (similar to cleanup() call)
-  void detachData(std::vector<void *> &data);
-
-  void *getData() const;
-  void release();
-
-protected:
-  virtual void *createDataInstance() const = 0;
-  virtual void deleteDataInstance(void *pData) const = 0;
-
-private:
-  int key_;
-
-  friend class cv::details::TlsStorage; // core/src/system.cpp
-
-public:
-  void cleanup(); //!< Release created TLS data container objects. It is similar
-                  //!< to release() call, but it keeps TLS container valid.
-
-private:
-  // Disable copy/assign (noncopyable pattern)
-  TLSDataContainer(TLSDataContainer &) = delete;
-  TLSDataContainer &operator=(const TLSDataContainer &) = delete;
-};
-
-/** @brief Simple TLS data class
- *
- * @sa TLSDataAccumulator
- */
-template <typename T> class TLSData : protected TLSDataContainer {
-public:
-  inline TLSData() {}
-  inline ~TLSData() { release(); }
-
-  inline T *get() const {
-    return (T *)getData();
-  } //!< Get data associated with key
-  inline T &getRef() const {
-    T *ptr = (T *)getData();
-    CV_DbgAssert(ptr);
-    return *ptr;
-  } //!< Get data associated with key
-
-  /// Release associated thread data
-  inline void cleanup() { TLSDataContainer::cleanup(); }
-
-protected:
-  /// Wrapper to allocate data by template
-  virtual void *createDataInstance() const CV_OVERRIDE { return new T; }
-  /// Wrapper to release data by template
-  virtual void deleteDataInstance(void *pData) const CV_OVERRIDE {
-    delete (T *)pData;
-  }
-};
-
-/// TLS data accumulator with gathering methods
-template <typename T> class TLSDataAccumulator : public TLSData<T> {
-  mutable cv::Mutex mutex;
-  mutable std::vector<T *> dataFromTerminatedThreads;
-  std::vector<T *> detachedData;
-  bool cleanupMode;
-
-public:
-  TLSDataAccumulator() : cleanupMode(false) {}
-  ~TLSDataAccumulator() { release(); }
-
-  /** @brief Get data from all threads
-   * @deprecated replaced by detachData()
-   *
-   * Lifetime of vector data is valid until next
-   * detachData()/cleanup()/release() calls
-   *
-   * @param[out] data result buffer (should be empty)
-   */
-  void gather(std::vector<T *> &data) const {
-    CV_Assert(cleanupMode == false); // state is not valid
-    CV_Assert(data.empty());
-    {
-      std::vector<void *> &dataVoid =
-          reinterpret_cast<std::vector<void *> &>(data);
-      TLSDataContainer::gatherData(dataVoid);
-    }
-    {
-      AutoLock lock(mutex);
-      data.reserve(data.size() + dataFromTerminatedThreads.size());
-      for (typename std::vector<T *>::const_iterator i =
-               dataFromTerminatedThreads.begin();
-           i != dataFromTerminatedThreads.end(); ++i) {
-        data.push_back((T *)*i);
-      }
-    }
-  }
-
-  /** @brief Get and detach data from all threads
-   *
-   * Call cleanupDetachedData() when returned vector is not needed anymore.
-   *
-   * @return Vector with associated data. Content is preserved (including
-   * lifetime of attached data pointers) until next
-   * detachData()/cleanupDetachedData()/cleanup()/release() calls
-   */
-  std::vector<T *> &detachData() {
-    CV_Assert(cleanupMode == false); // state is not valid
-    std::vector<void *> dataVoid;
-    {
-      TLSDataContainer::detachData(dataVoid);
-    }
-    {
-      AutoLock lock(mutex);
-      detachedData.reserve(dataVoid.size() + dataFromTerminatedThreads.size());
-      for (typename std::vector<T *>::const_iterator i =
-               dataFromTerminatedThreads.begin();
-           i != dataFromTerminatedThreads.end(); ++i) {
-        detachedData.push_back((T *)*i);
-      }
-      dataFromTerminatedThreads.clear();
-      for (typename std::vector<void *>::const_iterator i = dataVoid.begin();
-           i != dataVoid.end(); ++i) {
-        detachedData.push_back((T *)(void *)*i);
-      }
-    }
-    dataVoid.clear();
-    return detachedData;
-  }
-
-  /// Release associated thread data returned by detachData() call
-  void cleanupDetachedData() {
-    AutoLock lock(mutex);
-    cleanupMode = true;
-    _cleanupDetachedData();
-    cleanupMode = false;
-  }
-
-  /// Release associated thread data
-  void cleanup() {
-    cleanupMode = true;
-    TLSDataContainer::cleanup();
-
-    AutoLock lock(mutex);
-    _cleanupDetachedData();
-    _cleanupTerminatedData();
-    cleanupMode = false;
-  }
-
-  /// Release associated thread data and free TLS key
-  void release() {
-    cleanupMode = true;
-    TLSDataContainer::release();
-    {
-      AutoLock lock(mutex);
-      _cleanupDetachedData();
-      _cleanupTerminatedData();
-    }
-  }
-
-protected:
-  // synchronized
-  void _cleanupDetachedData() {
-    for (typename std::vector<T *>::iterator i = detachedData.begin();
-         i != detachedData.end(); ++i) {
-      deleteDataInstance((T *)*i);
-    }
-    detachedData.clear();
-  }
-
-  // synchronized
-  void _cleanupTerminatedData() {
-    for (typename std::vector<T *>::iterator i =
-             dataFromTerminatedThreads.begin();
-         i != dataFromTerminatedThreads.end(); ++i) {
-      deleteDataInstance((T *)*i);
-    }
-    dataFromTerminatedThreads.clear();
-  }
-
-protected:
-  virtual void *createDataInstance() const CV_OVERRIDE {
-    // Note: we can collect all allocated data here, but this would require
-    // raced mutex locks
-    return new T;
-  }
-  virtual void deleteDataInstance(void *pData) const CV_OVERRIDE {
-    if (cleanupMode) {
-      delete (T *)pData;
-    } else {
-      AutoLock lock(mutex);
-      dataFromTerminatedThreads.push_back((T *)pData);
-    }
-  }
-};
-
-//! @}
-
-} // namespace cv
-
-#endif // OPENCV_UTILS_TLS_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/utils/trace.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/utils/trace.hpp
deleted file mode 100644
index 6d8405bae9..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/utils/trace.hpp
+++ /dev/null
@@ -1,281 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_TRACE_HPP
-#define OPENCV_TRACE_HPP
-
-#include <opencv2/core/cvdef.h>
-
-namespace cv {
-namespace utils {
-namespace trace {
-
-//! @addtogroup core_logging
-//! @{
-
-//! Macro to trace function
-#define CV_TRACE_FUNCTION()
-
-#define CV_TRACE_FUNCTION_SKIP_NESTED()
-
-//! Trace code scope.
-//! @note Dynamic names are not supported in this macro (on stack or heap). Use
-//! string literals here only, like "initialize".
-#define CV_TRACE_REGION(name_as_static_string_literal)
-//! mark completed of the current opened region and create new one
-//! @note Dynamic names are not supported in this macro (on stack or heap). Use
-//! string literals here only, like "step1".
-#define CV_TRACE_REGION_NEXT(name_as_static_string_literal)
-
-//! Macro to trace argument value
-#define CV_TRACE_ARG(arg_id)
-
-//! Macro to trace argument value (expanded version)
-#define CV_TRACE_ARG_VALUE(arg_id, arg_name, value)
-
-//! @cond IGNORED
-#define CV_TRACE_NS cv::utils::trace
-
-#if !defined(OPENCV_DISABLE_TRACE) && defined(__EMSCRIPTEN__)
-#define OPENCV_DISABLE_TRACE 1
-#endif
-
-namespace details {
-
-#ifndef __OPENCV_TRACE
-#if defined __OPENCV_BUILD && !defined __OPENCV_TESTS && !defined __OPENCV_APPS
-#define __OPENCV_TRACE 1
-#else
-#define __OPENCV_TRACE 0
-#endif
-#endif
-
-#ifndef CV_TRACE_FILENAME
-#define CV_TRACE_FILENAME __FILE__
-#endif
-
-#ifndef CV__TRACE_FUNCTION
-#if defined _MSC_VER
-#define CV__TRACE_FUNCTION __FUNCSIG__
-#elif defined __GNUC__
-#define CV__TRACE_FUNCTION __PRETTY_FUNCTION__
-#else
-#define CV__TRACE_FUNCTION "<unknown>"
-#endif
-#endif
-
-//! Thread-local instance (usually allocated on stack)
-class CV_EXPORTS Region {
-public:
-  struct LocationExtraData;
-  struct LocationStaticStorage {
-    LocationExtraData **ppExtra; ///< implementation specific data
-    const char *name;     ///< region name (function name or other custom name)
-    const char *filename; ///< source code filename
-    int line;             ///< source code line
-    int flags; ///< flags (implementation code path: Plain, IPP, OpenCL)
-  };
-
-  Region(const LocationStaticStorage &location);
-  inline ~Region() {
-    if (implFlags != 0)
-      destroy();
-    CV_DbgAssert(implFlags == 0);
-    CV_DbgAssert(pImpl == NULL);
-  }
-
-  class Impl;
-  Impl *pImpl;   // NULL if current region is not active
-  int implFlags; // see RegionFlag, 0 if region is ignored
-
-  bool isActive() const { return pImpl != NULL; }
-
-  void destroy();
-
-private:
-  Region(const Region &);            // disabled
-  Region &operator=(const Region &); // disabled
-};
-
-//! Specify region flags
-enum RegionLocationFlag {
-  REGION_FLAG_FUNCTION =
-      (1 << 0), ///< region is function (=1) / nested named region (=0)
-  REGION_FLAG_APP_CODE =
-      (1 << 1), ///< region is Application code (=1) / OpenCV library code (=0)
-  REGION_FLAG_SKIP_NESTED = (1 << 2), ///< avoid processing of nested regions
-
-  REGION_FLAG_IMPL_IPP = (1 << 16),    ///< region is part of IPP code path
-  REGION_FLAG_IMPL_OPENCL = (2 << 16), ///< region is part of OpenCL code path
-  REGION_FLAG_IMPL_OPENVX = (3 << 16), ///< region is part of OpenVX code path
-
-  REGION_FLAG_IMPL_MASK = (15 << 16),
-
-  REGION_FLAG_REGION_FORCE = (1 << 30),
-  REGION_FLAG_REGION_NEXT =
-      (1 << 31), ///< close previous region (see #CV_TRACE_REGION_NEXT macro)
-
-  ENUM_REGION_FLAG_FORCE_INT = INT_MAX
-};
-
-struct CV_EXPORTS TraceArg {
-public:
-  struct ExtraData;
-  ExtraData **ppExtra;
-  const char *name;
-  int flags;
-};
-/** @brief Add meta information to current region (function)
- * See CV_TRACE_ARG macro
- * @param arg argument information structure (global static cache)
- * @param value argument value (can by dynamic string literal in case of string,
- * static allocation is not required)
- */
-CV_EXPORTS void traceArg(const TraceArg &arg, const char *value);
-//! @overload
-CV_EXPORTS void traceArg(const TraceArg &arg, int value);
-//! @overload
-CV_EXPORTS void traceArg(const TraceArg &arg, int64 value);
-//! @overload
-CV_EXPORTS void traceArg(const TraceArg &arg, double value);
-
-#define CV__TRACE_LOCATION_VARNAME(loc_id)                                     \
-  CVAUX_CONCAT(CVAUX_CONCAT(__cv_trace_location_, loc_id), __LINE__)
-#define CV__TRACE_LOCATION_EXTRA_VARNAME(loc_id)                               \
-  CVAUX_CONCAT(CVAUX_CONCAT(__cv_trace_location_extra_, loc_id), __LINE__)
-
-#define CV__TRACE_DEFINE_LOCATION_(loc_id, name, flags)                        \
-  static CV_TRACE_NS::details::Region::LocationExtraData                       \
-      *CV__TRACE_LOCATION_EXTRA_VARNAME(loc_id) = 0;                           \
-  static const CV_TRACE_NS::details::Region::LocationStaticStorage             \
-      CV__TRACE_LOCATION_VARNAME(loc_id) = {                                   \
-          &(CV__TRACE_LOCATION_EXTRA_VARNAME(loc_id)), name,                   \
-          CV_TRACE_FILENAME, __LINE__, flags};
-
-#define CV__TRACE_DEFINE_LOCATION_FN(name, flags)                              \
-  CV__TRACE_DEFINE_LOCATION_(                                                  \
-      fn, name, ((flags) | CV_TRACE_NS::details::REGION_FLAG_FUNCTION))
-
-#define CV__TRACE_OPENCV_FUNCTION()                                            \
-  CV__TRACE_DEFINE_LOCATION_FN(CV__TRACE_FUNCTION, 0);                         \
-  const CV_TRACE_NS::details::Region __region_fn(                              \
-      CV__TRACE_LOCATION_VARNAME(fn));
-
-#define CV__TRACE_OPENCV_FUNCTION_NAME(name)                                   \
-  CV__TRACE_DEFINE_LOCATION_FN(name, 0);                                       \
-  const CV_TRACE_NS::details::Region __region_fn(                              \
-      CV__TRACE_LOCATION_VARNAME(fn));
-
-#define CV__TRACE_APP_FUNCTION()                                               \
-  CV__TRACE_DEFINE_LOCATION_FN(CV__TRACE_FUNCTION,                             \
-                               CV_TRACE_NS::details::REGION_FLAG_APP_CODE);    \
-  const CV_TRACE_NS::details::Region __region_fn(                              \
-      CV__TRACE_LOCATION_VARNAME(fn));
-
-#define CV__TRACE_APP_FUNCTION_NAME(name)                                      \
-  CV__TRACE_DEFINE_LOCATION_FN(name,                                           \
-                               CV_TRACE_NS::details::REGION_FLAG_APP_CODE);    \
-  const CV_TRACE_NS::details::Region __region_fn(                              \
-      CV__TRACE_LOCATION_VARNAME(fn));
-
-#define CV__TRACE_OPENCV_FUNCTION_SKIP_NESTED()                                \
-  CV__TRACE_DEFINE_LOCATION_FN(CV__TRACE_FUNCTION,                             \
-                               CV_TRACE_NS::details::REGION_FLAG_SKIP_NESTED); \
-  const CV_TRACE_NS::details::Region __region_fn(                              \
-      CV__TRACE_LOCATION_VARNAME(fn));
-
-#define CV__TRACE_OPENCV_FUNCTION_NAME_SKIP_NESTED(name)                       \
-  CV__TRACE_DEFINE_LOCATION_FN(name,                                           \
-                               CV_TRACE_NS::details::REGION_FLAG_SKIP_NESTED); \
-  const CV_TRACE_NS::details::Region __region_fn(                              \
-      CV__TRACE_LOCATION_VARNAME(fn));
-
-#define CV__TRACE_APP_FUNCTION_SKIP_NESTED()                                   \
-  CV__TRACE_DEFINE_LOCATION_FN(                                                \
-      CV__TRACE_FUNCTION, CV_TRACE_NS::details::REGION_FLAG_SKIP_NESTED |      \
-                              CV_TRACE_NS::details::REGION_FLAG_APP_CODE);     \
-  const CV_TRACE_NS::details::Region __region_fn(                              \
-      CV__TRACE_LOCATION_VARNAME(fn));
-
-#define CV__TRACE_REGION_(name_as_static_string_literal, flags)                \
-  CV__TRACE_DEFINE_LOCATION_(region, name_as_static_string_literal, flags);    \
-  CV_TRACE_NS::details::Region CVAUX_CONCAT(__region_, __LINE__)(              \
-      CV__TRACE_LOCATION_VARNAME(region));
-
-#define CV__TRACE_REGION(name_as_static_string_literal)                        \
-  CV__TRACE_REGION_(name_as_static_string_literal, 0)
-#define CV__TRACE_REGION_NEXT(name_as_static_string_literal)                   \
-  CV__TRACE_REGION_(name_as_static_string_literal,                             \
-                    CV_TRACE_NS::details::REGION_FLAG_REGION_NEXT)
-
-#define CV__TRACE_ARG_VARNAME(arg_id)                                          \
-  CVAUX_CONCAT(__cv_trace_arg_##arg_id, __LINE__)
-#define CV__TRACE_ARG_EXTRA_VARNAME(arg_id)                                    \
-  CVAUX_CONCAT(__cv_trace_arg_extra_##arg_id, __LINE__)
-
-#define CV__TRACE_DEFINE_ARG_(arg_id, name, flags)                             \
-  static CV_TRACE_NS::details::TraceArg::ExtraData                             \
-      *CV__TRACE_ARG_EXTRA_VARNAME(arg_id) = 0;                                \
-  static const CV_TRACE_NS::details::TraceArg CV__TRACE_ARG_VARNAME(           \
-      arg_id) = {&(CV__TRACE_ARG_EXTRA_VARNAME(arg_id)), name, flags};
-
-#define CV__TRACE_ARG_VALUE(arg_id, arg_name, value)                           \
-  CV__TRACE_DEFINE_ARG_(arg_id, arg_name, 0);                                  \
-  CV_TRACE_NS::details::traceArg((CV__TRACE_ARG_VARNAME(arg_id)), value);
-
-#define CV__TRACE_ARG(arg_id) CV_TRACE_ARG_VALUE(arg_id, #arg_id, (arg_id))
-
-} // namespace details
-
-#ifndef OPENCV_DISABLE_TRACE
-#undef CV_TRACE_FUNCTION
-#undef CV_TRACE_FUNCTION_SKIP_NESTED
-#if __OPENCV_TRACE
-#define CV_TRACE_FUNCTION CV__TRACE_OPENCV_FUNCTION
-#define CV_TRACE_FUNCTION_SKIP_NESTED CV__TRACE_OPENCV_FUNCTION_SKIP_NESTED
-#else
-#define CV_TRACE_FUNCTION CV__TRACE_APP_FUNCTION
-#define CV_TRACE_FUNCTION_SKIP_NESTED CV__TRACE_APP_FUNCTION_SKIP_NESTED
-#endif
-
-#undef CV_TRACE_REGION
-#define CV_TRACE_REGION CV__TRACE_REGION
-
-#undef CV_TRACE_REGION_NEXT
-#define CV_TRACE_REGION_NEXT CV__TRACE_REGION_NEXT
-
-#undef CV_TRACE_ARG_VALUE
-#define CV_TRACE_ARG_VALUE(arg_id, arg_name, value)                            \
-  if (__region_fn.isActive()) {                                                \
-    CV__TRACE_ARG_VALUE(arg_id, arg_name, value);                              \
-  }
-
-#undef CV_TRACE_ARG
-#define CV_TRACE_ARG CV__TRACE_ARG
-
-#endif // OPENCV_DISABLE_TRACE
-
-#ifdef OPENCV_TRACE_VERBOSE
-#define CV_TRACE_FUNCTION_VERBOSE CV_TRACE_FUNCTION
-#define CV_TRACE_REGION_VERBOSE CV_TRACE_REGION
-#define CV_TRACE_REGION_NEXT_VERBOSE CV_TRACE_REGION_NEXT
-#define CV_TRACE_ARG_VALUE_VERBOSE CV_TRACE_ARG_VALUE
-#define CV_TRACE_ARG_VERBOSE CV_TRACE_ARG
-#else
-#define CV_TRACE_FUNCTION_VERBOSE(...)
-#define CV_TRACE_REGION_VERBOSE(...)
-#define CV_TRACE_REGION_NEXT_VERBOSE(...)
-#define CV_TRACE_ARG_VALUE_VERBOSE(...)
-#define CV_TRACE_ARG_VERBOSE(...)
-#endif
-
-//! @endcond
-
-//! @}
-
-} // namespace trace
-} // namespace utils
-} // namespace cv
-
-#endif // OPENCV_TRACE_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/version.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/version.hpp
deleted file mode 100644
index 349818deb6..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/version.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_VERSION_HPP
-#define OPENCV_VERSION_HPP
-
-#define CV_VERSION_MAJOR 4
-#define CV_VERSION_MINOR 11
-#define CV_VERSION_REVISION 0
-#define CV_VERSION_STATUS ""
-
-#define CVAUX_STR_EXP(__A) #__A
-#define CVAUX_STR(__A) CVAUX_STR_EXP(__A)
-
-#define CVAUX_STRW_EXP(__A) L## #__A
-#define CVAUX_STRW(__A) CVAUX_STRW_EXP(__A)
-
-#define CV_VERSION                                                             \
-  CVAUX_STR(CV_VERSION_MAJOR)                                                  \
-  "." CVAUX_STR(CV_VERSION_MINOR) "." CVAUX_STR(CV_VERSION_REVISION)           \
-      CV_VERSION_STATUS
-
-/* old  style version constants*/
-#define CV_MAJOR_VERSION CV_VERSION_MAJOR
-#define CV_MINOR_VERSION CV_VERSION_MINOR
-#define CV_SUBMINOR_VERSION CV_VERSION_REVISION
-
-#endif // OPENCV_VERSION_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/core/vsx_utils.hpp b/packages/react-native-executorch/third-party/include/opencv2/core/vsx_utils.hpp
deleted file mode 100644
index 4cc4054cea..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/core/vsx_utils.hpp
+++ /dev/null
@@ -1,1115 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html
-
-#ifndef OPENCV_HAL_VSX_UTILS_HPP
-#define OPENCV_HAL_VSX_UTILS_HPP
-
-#include "opencv2/core/cvdef.h"
-
-#ifndef SKIP_INCLUDES
-#include <assert.h>
-#endif
-
-//! @addtogroup core_utils_vsx
-//! @{
-#if CV_VSX
-
-#define __VSX_S16__(c, v)                                                      \
-  (c) { v, v, v, v, v, v, v, v, v, v, v, v, v, v, v, v }
-#define __VSX_S8__(c, v)                                                       \
-  (c) { v, v, v, v, v, v, v, v }
-#define __VSX_S4__(c, v)                                                       \
-  (c) { v, v, v, v }
-#define __VSX_S2__(c, v)                                                       \
-  (c) { v, v }
-
-typedef __vector unsigned char vec_uchar16;
-#define vec_uchar16_set(...)                                                   \
-  (vec_uchar16) { __VA_ARGS__ }
-#define vec_uchar16_sp(c) (__VSX_S16__(vec_uchar16, (unsigned char)c))
-#define vec_uchar16_c(v) ((vec_uchar16)(v))
-#define vec_uchar16_z vec_uchar16_sp(0)
-
-typedef __vector signed char vec_char16;
-#define vec_char16_set(...)                                                    \
-  (vec_char16) { __VA_ARGS__ }
-#define vec_char16_sp(c) (__VSX_S16__(vec_char16, (signed char)c))
-#define vec_char16_c(v) ((vec_char16)(v))
-#define vec_char16_z vec_char16_sp(0)
-
-typedef __vector unsigned short vec_ushort8;
-#define vec_ushort8_set(...)                                                   \
-  (vec_ushort8) { __VA_ARGS__ }
-#define vec_ushort8_sp(c) (__VSX_S8__(vec_ushort8, (unsigned short)c))
-#define vec_ushort8_c(v) ((vec_ushort8)(v))
-#define vec_ushort8_z vec_ushort8_sp(0)
-
-typedef __vector signed short vec_short8;
-#define vec_short8_set(...)                                                    \
-  (vec_short8) { __VA_ARGS__ }
-#define vec_short8_sp(c) (__VSX_S8__(vec_short8, (signed short)c))
-#define vec_short8_c(v) ((vec_short8)(v))
-#define vec_short8_z vec_short8_sp(0)
-
-typedef __vector unsigned int vec_uint4;
-#define vec_uint4_set(...)                                                     \
-  (vec_uint4) { __VA_ARGS__ }
-#define vec_uint4_sp(c) (__VSX_S4__(vec_uint4, (unsigned int)c))
-#define vec_uint4_c(v) ((vec_uint4)(v))
-#define vec_uint4_z vec_uint4_sp(0)
-
-typedef __vector signed int vec_int4;
-#define vec_int4_set(...)                                                      \
-  (vec_int4) { __VA_ARGS__ }
-#define vec_int4_sp(c) (__VSX_S4__(vec_int4, (signed int)c))
-#define vec_int4_c(v) ((vec_int4)(v))
-#define vec_int4_z vec_int4_sp(0)
-
-typedef __vector float vec_float4;
-#define vec_float4_set(...)                                                    \
-  (vec_float4) { __VA_ARGS__ }
-#define vec_float4_sp(c) (__VSX_S4__(vec_float4, c))
-#define vec_float4_c(v) ((vec_float4)(v))
-#define vec_float4_z vec_float4_sp(0)
-
-typedef __vector unsigned long long vec_udword2;
-#define vec_udword2_set(...)                                                   \
-  (vec_udword2) { __VA_ARGS__ }
-#define vec_udword2_sp(c) (__VSX_S2__(vec_udword2, (unsigned long long)c))
-#define vec_udword2_c(v) ((vec_udword2)(v))
-#define vec_udword2_z vec_udword2_sp(0)
-
-typedef __vector signed long long vec_dword2;
-#define vec_dword2_set(...)                                                    \
-  (vec_dword2) { __VA_ARGS__ }
-#define vec_dword2_sp(c) (__VSX_S2__(vec_dword2, (signed long long)c))
-#define vec_dword2_c(v) ((vec_dword2)(v))
-#define vec_dword2_z vec_dword2_sp(0)
-
-typedef __vector double vec_double2;
-#define vec_double2_set(...)                                                   \
-  (vec_double2) { __VA_ARGS__ }
-#define vec_double2_c(v) ((vec_double2)(v))
-#define vec_double2_sp(c) (__VSX_S2__(vec_double2, c))
-#define vec_double2_z vec_double2_sp(0)
-
-#define vec_bchar16 __vector __bool char
-#define vec_bchar16_set(...)                                                   \
-  (vec_bchar16) { __VA_ARGS__ }
-#define vec_bchar16_c(v) ((vec_bchar16)(v))
-
-#define vec_bshort8 __vector __bool short
-#define vec_bshort8_set(...)                                                   \
-  (vec_bshort8) { __VA_ARGS__ }
-#define vec_bshort8_c(v) ((vec_bshort8)(v))
-
-#define vec_bint4 __vector __bool int
-#define vec_bint4_set(...)                                                     \
-  (vec_bint4) { __VA_ARGS__ }
-#define vec_bint4_c(v) ((vec_bint4)(v))
-
-#define vec_bdword2 __vector __bool long long
-#define vec_bdword2_set(...)                                                   \
-  (vec_bdword2) { __VA_ARGS__ }
-#define vec_bdword2_c(v) ((vec_bdword2)(v))
-
-#define VSX_FINLINE(tp) extern inline tp __attribute__((always_inline))
-
-#define VSX_REDIRECT_1RG(rt, rg, fnm, fn2)                                     \
-  VSX_FINLINE(rt) fnm(const rg &a) { return fn2(a); }
-
-#define VSX_REDIRECT_2RG(rt, rg, fnm, fn2)                                     \
-  VSX_FINLINE(rt) fnm(const rg &a, const rg &b) { return fn2(a, b); }
-
-/*
- * GCC VSX compatibility
- **/
-#if defined(__GNUG__) && !defined(__clang__)
-
-// inline asm helper
-#define VSX_IMPL_1RG(rt, rg, opc, fnm)                                         \
-  VSX_FINLINE(rt) fnm(const rg &a) {                                           \
-    rt rs;                                                                     \
-    __asm__ __volatile__(#opc " %x0,%x1" : "=wa"(rs) : "wa"(a));               \
-    return rs;                                                                 \
-  }
-
-#define VSX_IMPL_1VRG(rt, rg, opc, fnm)                                        \
-  VSX_FINLINE(rt) fnm(const rg &a) {                                           \
-    rt rs;                                                                     \
-    __asm__ __volatile__(#opc " %0,%1" : "=v"(rs) : "v"(a));                   \
-    return rs;                                                                 \
-  }
-
-#define VSX_IMPL_2VRG_F(rt, rg, fopc, fnm)                                     \
-  VSX_FINLINE(rt) fnm(const rg &a, const rg &b) {                              \
-    rt rs;                                                                     \
-    __asm__ __volatile__(fopc : "=v"(rs) : "v"(a), "v"(b));                    \
-    return rs;                                                                 \
-  }
-
-#define VSX_IMPL_2VRG(rt, rg, opc, fnm)                                        \
-  VSX_IMPL_2VRG_F(rt, rg, #opc " %0,%1,%2", fnm)
-
-#if __GNUG__ < 8
-
-// Support for int4 -> dword2 expanding multiply was added in GCC 8.
-#ifdef vec_mule
-#undef vec_mule
-#endif
-#ifdef vec_mulo
-#undef vec_mulo
-#endif
-
-VSX_REDIRECT_2RG(vec_ushort8, vec_uchar16, vec_mule, __builtin_vec_mule)
-VSX_REDIRECT_2RG(vec_short8, vec_char16, vec_mule, __builtin_vec_mule)
-VSX_REDIRECT_2RG(vec_int4, vec_short8, vec_mule, __builtin_vec_mule)
-VSX_REDIRECT_2RG(vec_uint4, vec_ushort8, vec_mule, __builtin_vec_mule)
-VSX_REDIRECT_2RG(vec_ushort8, vec_uchar16, vec_mulo, __builtin_vec_mulo)
-VSX_REDIRECT_2RG(vec_short8, vec_char16, vec_mulo, __builtin_vec_mulo)
-VSX_REDIRECT_2RG(vec_int4, vec_short8, vec_mulo, __builtin_vec_mulo)
-VSX_REDIRECT_2RG(vec_uint4, vec_ushort8, vec_mulo, __builtin_vec_mulo)
-
-// dword2 support arrived in ISA 2.07 and GCC 8+
-VSX_IMPL_2VRG(vec_dword2, vec_int4, vmulosw, vec_mule)
-VSX_IMPL_2VRG(vec_udword2, vec_uint4, vmulouw, vec_mule)
-VSX_IMPL_2VRG(vec_dword2, vec_int4, vmulesw, vec_mulo)
-VSX_IMPL_2VRG(vec_udword2, vec_uint4, vmuleuw, vec_mulo)
-
-#endif
-
-#if __GNUG__ < 7
-// up to GCC 6 vec_mul only supports precisions and llong
-#ifdef vec_mul
-#undef vec_mul
-#endif
-/*
- * there's no a direct instruction for supporting 8-bit, 16-bit multiplication
- *in ISA 2.07, XLC Implement it by using instruction "multiply even", "multiply
- *odd" and "permute"
- **/
-#define VSX_IMPL_MULH(Tvec, cperm)                                             \
-  VSX_FINLINE(Tvec) vec_mul(const Tvec &a, const Tvec &b) {                    \
-    static const vec_uchar16 ev_od = {cperm};                                  \
-    return vec_perm((Tvec)vec_mule(a, b), (Tvec)vec_mulo(a, b), ev_od);        \
-  }
-#define VSX_IMPL_MULH_P16                                                      \
-  0, 16, 2, 18, 4, 20, 6, 22, 8, 24, 10, 26, 12, 28, 14, 30
-VSX_IMPL_MULH(vec_char16, VSX_IMPL_MULH_P16)
-VSX_IMPL_MULH(vec_uchar16, VSX_IMPL_MULH_P16)
-#define VSX_IMPL_MULH_P8                                                       \
-  0, 1, 16, 17, 4, 5, 20, 21, 8, 9, 24, 25, 12, 13, 28, 29
-VSX_IMPL_MULH(vec_short8, VSX_IMPL_MULH_P8)
-VSX_IMPL_MULH(vec_ushort8, VSX_IMPL_MULH_P8)
-// vmuluwm can be used for unsigned or signed integers, that's what they said
-VSX_IMPL_2VRG(vec_int4, vec_int4, vmuluwm, vec_mul)
-VSX_IMPL_2VRG(vec_uint4, vec_uint4, vmuluwm, vec_mul)
-// redirect to GCC builtin vec_mul, since it already supports precisions and
-// llong
-VSX_REDIRECT_2RG(vec_float4, vec_float4, vec_mul, __builtin_vec_mul)
-VSX_REDIRECT_2RG(vec_double2, vec_double2, vec_mul, __builtin_vec_mul)
-VSX_REDIRECT_2RG(vec_dword2, vec_dword2, vec_mul, __builtin_vec_mul)
-VSX_REDIRECT_2RG(vec_udword2, vec_udword2, vec_mul, __builtin_vec_mul)
-#endif // __GNUG__ < 7
-
-#if __GNUG__ < 6
-/*
- * Instruction "compare greater than or equal" in ISA 2.07 only supports single
- * and double precision.
- * In XLC and new versions of GCC implement integers by using instruction
- *"greater than" and NOR.
- **/
-#ifdef vec_cmpge
-#undef vec_cmpge
-#endif
-#ifdef vec_cmple
-#undef vec_cmple
-#endif
-#define vec_cmple(a, b) vec_cmpge(b, a)
-#define VSX_IMPL_CMPGE(rt, rg, opc, fnm)                                       \
-  VSX_IMPL_2VRG_F(rt, rg, #opc " %0,%2,%1\n\t xxlnor %x0,%x0,%x0", fnm)
-
-VSX_IMPL_CMPGE(vec_bchar16, vec_char16, vcmpgtsb, vec_cmpge)
-VSX_IMPL_CMPGE(vec_bchar16, vec_uchar16, vcmpgtub, vec_cmpge)
-VSX_IMPL_CMPGE(vec_bshort8, vec_short8, vcmpgtsh, vec_cmpge)
-VSX_IMPL_CMPGE(vec_bshort8, vec_ushort8, vcmpgtuh, vec_cmpge)
-VSX_IMPL_CMPGE(vec_bint4, vec_int4, vcmpgtsw, vec_cmpge)
-VSX_IMPL_CMPGE(vec_bint4, vec_uint4, vcmpgtuw, vec_cmpge)
-VSX_IMPL_CMPGE(vec_bdword2, vec_dword2, vcmpgtsd, vec_cmpge)
-VSX_IMPL_CMPGE(vec_bdword2, vec_udword2, vcmpgtud, vec_cmpge)
-
-// redirect to GCC builtin cmpge, since it already supports precisions
-VSX_REDIRECT_2RG(vec_bint4, vec_float4, vec_cmpge, __builtin_vec_cmpge)
-VSX_REDIRECT_2RG(vec_bdword2, vec_double2, vec_cmpge, __builtin_vec_cmpge)
-
-// up to gcc5 vec_nor doesn't support bool long long
-#undef vec_nor
-template <typename T>
-VSX_REDIRECT_2RG(T, T, vec_nor, __builtin_vec_nor)
-
-VSX_FINLINE(vec_bdword2) vec_nor(const vec_bdword2 &a, const vec_bdword2 &b) {
-  return vec_bdword2_c(__builtin_vec_nor(vec_dword2_c(a), vec_dword2_c(b)));
-}
-
-// vec_packs doesn't support double words in gcc4 and old versions of gcc5
-#undef vec_packs
-VSX_REDIRECT_2RG(vec_char16, vec_short8, vec_packs, __builtin_vec_packs)
-VSX_REDIRECT_2RG(vec_uchar16, vec_ushort8, vec_packs, __builtin_vec_packs)
-VSX_REDIRECT_2RG(vec_short8, vec_int4, vec_packs, __builtin_vec_packs)
-VSX_REDIRECT_2RG(vec_ushort8, vec_uint4, vec_packs, __builtin_vec_packs)
-
-VSX_IMPL_2VRG_F(vec_int4, vec_dword2, "vpksdss %0,%2,%1", vec_packs)
-VSX_IMPL_2VRG_F(vec_uint4, vec_udword2, "vpkudus %0,%2,%1", vec_packs)
-#endif // __GNUG__ < 6
-
-#if __GNUG__ < 5
-// vec_xxpermdi in gcc4 missing little-endian supports just like clang
-#define vec_permi(a, b, c) vec_xxpermdi(b, a, (3 ^ (((c) & 1) << 1 | (c) >> 1)))
-// same as vec_xxpermdi
-#undef vec_vbpermq
-VSX_IMPL_2VRG(vec_udword2, vec_uchar16, vbpermq, vec_vbpermq)
-VSX_IMPL_2VRG(vec_dword2, vec_char16, vbpermq, vec_vbpermq)
-#else
-#define vec_permi vec_xxpermdi
-#endif // __GNUG__ < 5
-
-// shift left double by word immediate
-#ifndef vec_sldw
-#define vec_sldw __builtin_vsx_xxsldwi
-#endif
-
-// vector population count
-VSX_IMPL_1VRG(vec_uchar16, vec_uchar16, vpopcntb, vec_popcntu)
-VSX_IMPL_1VRG(vec_uchar16, vec_char16, vpopcntb, vec_popcntu)
-VSX_IMPL_1VRG(vec_ushort8, vec_ushort8, vpopcnth, vec_popcntu)
-VSX_IMPL_1VRG(vec_ushort8, vec_short8, vpopcnth, vec_popcntu)
-VSX_IMPL_1VRG(vec_uint4, vec_uint4, vpopcntw, vec_popcntu)
-VSX_IMPL_1VRG(vec_uint4, vec_int4, vpopcntw, vec_popcntu)
-VSX_IMPL_1VRG(vec_udword2, vec_udword2, vpopcntd, vec_popcntu)
-VSX_IMPL_1VRG(vec_udword2, vec_dword2, vpopcntd, vec_popcntu)
-
-// converts between single and double-precision
-VSX_REDIRECT_1RG(vec_float4, vec_double2, vec_cvfo, __builtin_vsx_xvcvdpsp)
-VSX_REDIRECT_1RG(vec_double2, vec_float4, vec_cvfo, __builtin_vsx_xvcvspdp)
-
-// converts word and doubleword to double-precision
-#undef vec_ctd
-VSX_IMPL_1RG(vec_double2, vec_int4, xvcvsxwdp, vec_ctdo)
-VSX_IMPL_1RG(vec_double2, vec_uint4, xvcvuxwdp, vec_ctdo)
-VSX_IMPL_1RG(vec_double2, vec_dword2, xvcvsxddp, vec_ctd)
-VSX_IMPL_1RG(vec_double2, vec_udword2, xvcvuxddp, vec_ctd)
-
-// converts word and doubleword to single-precision
-#undef vec_ctf
-VSX_IMPL_1RG(vec_float4, vec_int4, xvcvsxwsp, vec_ctf)
-VSX_IMPL_1RG(vec_float4, vec_uint4, xvcvuxwsp, vec_ctf)
-VSX_IMPL_1RG(vec_float4, vec_dword2, xvcvsxdsp, vec_ctfo)
-VSX_IMPL_1RG(vec_float4, vec_udword2, xvcvuxdsp, vec_ctfo)
-
-// converts single and double precision to signed word
-#undef vec_cts
-VSX_IMPL_1RG(vec_int4, vec_double2, xvcvdpsxws, vec_ctso)
-VSX_IMPL_1RG(vec_int4, vec_float4, xvcvspsxws, vec_cts)
-
-// converts single and double precision to unsigned word
-#undef vec_ctu
-VSX_IMPL_1RG(vec_uint4, vec_double2, xvcvdpuxws, vec_ctuo)
-VSX_IMPL_1RG(vec_uint4, vec_float4, xvcvspuxws, vec_ctu)
-
-// converts single and double precision to signed doubleword
-#undef vec_ctsl
-VSX_IMPL_1RG(vec_dword2, vec_double2, xvcvdpsxds, vec_ctsl)
-VSX_IMPL_1RG(vec_dword2, vec_float4, xvcvspsxds, vec_ctslo)
-
-// converts single and double precision to unsigned doubleword
-#undef vec_ctul
-VSX_IMPL_1RG(vec_udword2, vec_double2, xvcvdpuxds, vec_ctul)
-VSX_IMPL_1RG(vec_udword2, vec_float4, xvcvspuxds, vec_ctulo)
-
-// just in case if GCC doesn't define it
-#ifndef vec_xl
-#define vec_xl vec_vsx_ld
-#define vec_xst vec_vsx_st
-#endif
-
-#endif // GCC VSX compatibility
-
-/*
- * CLANG VSX compatibility
- **/
-#if defined(__clang__) && !defined(__IBMCPP__)
-
-/*
- * CLANG doesn't support %x<n> in the inline asm template which fixes register
- * number when using any of the register constraints wa, wd, wf
- *
- * For more explanation checkout PowerPC and IBM RS6000 in
- * https://gcc.gnu.org/onlinedocs/gcc/Machine-Constraints.html Also there's
- * already an open bug https://bugs.llvm.org/show_bug.cgi?id=31837
- *
- * So we're not able to use inline asm and only use built-in functions that
- * CLANG supports and use __builtin_convertvector if clang missing any of vector
- * conversions built-in functions
- *
- * todo: clang asm template bug is fixed, need to reconsider the current
- * workarounds.
- */
-
-// convert vector helper
-#define VSX_IMPL_CONVERT(rt, rg, fnm)                                          \
-  VSX_FINLINE(rt) fnm(const rg &a) { return __builtin_convertvector(a, rt); }
-
-#ifndef vec_permi
-#if __clang_major__ < 5
-// implement vec_permi in a dirty way
-#define VSX_IMPL_CLANG_4_PERMI(Tvec)                                           \
-  VSX_FINLINE(Tvec)                                                            \
-  vec_permi(const Tvec &a, const Tvec &b, unsigned const char c) {             \
-    switch (c) {                                                               \
-    case 0:                                                                    \
-      return vec_mergeh(a, b);                                                 \
-    case 1:                                                                    \
-      return vec_mergel(vec_mergeh(a, a), b);                                  \
-    case 2:                                                                    \
-      return vec_mergeh(vec_mergel(a, a), b);                                  \
-    default:                                                                   \
-      return vec_mergel(a, b);                                                 \
-    }                                                                          \
-  }
-VSX_IMPL_CLANG_4_PERMI(vec_udword2)
-VSX_IMPL_CLANG_4_PERMI(vec_dword2)
-VSX_IMPL_CLANG_4_PERMI(vec_double2)
-
-// vec_xxsldwi is missing in clang 4
-#define vec_xxsldwi(a, b, c) vec_sld(a, b, (c) * 4)
-#else
-// vec_xxpermdi is missing little-endian supports in clang 4 just like gcc4
-#define vec_permi(a, b, c) vec_xxpermdi(b, a, (3 ^ (((c) & 1) << 1 | (c) >> 1)))
-#endif // __clang_major__ < 5
-#endif
-
-// shift left double by word immediate
-#ifndef vec_sldw
-#define vec_sldw vec_xxsldwi
-#endif
-
-#if __clang_major__ < 13
-// Implement vec_rsqrt since clang only supports vec_rsqrte
-#ifndef vec_rsqrt
-VSX_FINLINE(vec_float4) vec_rsqrt(const vec_float4 &a) {
-  return vec_div(vec_float4_sp(1), vec_sqrt(a));
-}
-
-VSX_FINLINE(vec_double2) vec_rsqrt(const vec_double2 &a) {
-  return vec_div(vec_double2_sp(1), vec_sqrt(a));
-}
-#endif
-
-// vec_promote missing support for doubleword
-VSX_FINLINE(vec_dword2) vec_promote(long long a, int b) {
-  vec_dword2 ret = vec_dword2_z;
-  ret[b & 1] = a;
-  return ret;
-}
-
-VSX_FINLINE(vec_udword2) vec_promote(unsigned long long a, int b) {
-  vec_udword2 ret = vec_udword2_z;
-  ret[b & 1] = a;
-  return ret;
-}
-#endif
-
-// vec_popcnt should return unsigned but clang has different thought just like
-// gcc in vec_vpopcnt
-#define VSX_IMPL_POPCNTU(Tvec, Tvec2, ucast)                                   \
-  VSX_FINLINE(Tvec) vec_popcntu(const Tvec2 &a) { return ucast(vec_popcnt(a)); }
-VSX_IMPL_POPCNTU(vec_uchar16, vec_char16, vec_uchar16_c);
-VSX_IMPL_POPCNTU(vec_ushort8, vec_short8, vec_ushort8_c);
-VSX_IMPL_POPCNTU(vec_uint4, vec_int4, vec_uint4_c);
-VSX_IMPL_POPCNTU(vec_udword2, vec_dword2, vec_udword2_c);
-// redirect unsigned types
-VSX_REDIRECT_1RG(vec_uchar16, vec_uchar16, vec_popcntu, vec_popcnt)
-VSX_REDIRECT_1RG(vec_ushort8, vec_ushort8, vec_popcntu, vec_popcnt)
-VSX_REDIRECT_1RG(vec_uint4, vec_uint4, vec_popcntu, vec_popcnt)
-VSX_REDIRECT_1RG(vec_udword2, vec_udword2, vec_popcntu, vec_popcnt)
-
-// converts between single and double precision
-VSX_REDIRECT_1RG(vec_float4, vec_double2, vec_cvfo, __builtin_vsx_xvcvdpsp)
-VSX_REDIRECT_1RG(vec_double2, vec_float4, vec_cvfo, __builtin_vsx_xvcvspdp)
-
-// converts word and doubleword to double-precision
-#ifdef vec_ctd
-#undef vec_ctd
-#endif
-VSX_REDIRECT_1RG(vec_double2, vec_int4, vec_ctdo, __builtin_vsx_xvcvsxwdp)
-VSX_REDIRECT_1RG(vec_double2, vec_uint4, vec_ctdo, __builtin_vsx_xvcvuxwdp)
-
-VSX_IMPL_CONVERT(vec_double2, vec_dword2, vec_ctd)
-VSX_IMPL_CONVERT(vec_double2, vec_udword2, vec_ctd)
-
-// converts word and doubleword to single-precision
-#if __clang_major__ > 4
-#undef vec_ctf
-#endif
-VSX_IMPL_CONVERT(vec_float4, vec_int4, vec_ctf)
-VSX_IMPL_CONVERT(vec_float4, vec_uint4, vec_ctf)
-VSX_REDIRECT_1RG(vec_float4, vec_dword2, vec_ctfo, __builtin_vsx_xvcvsxdsp)
-VSX_REDIRECT_1RG(vec_float4, vec_udword2, vec_ctfo, __builtin_vsx_xvcvuxdsp)
-
-// converts single and double precision to signed word
-#if __clang_major__ > 4
-#undef vec_cts
-#endif
-VSX_REDIRECT_1RG(vec_int4, vec_double2, vec_ctso, __builtin_vsx_xvcvdpsxws)
-VSX_IMPL_CONVERT(vec_int4, vec_float4, vec_cts)
-
-// converts single and double precision to unsigned word
-#if __clang_major__ > 4
-#undef vec_ctu
-#endif
-VSX_REDIRECT_1RG(vec_uint4, vec_double2, vec_ctuo, __builtin_vsx_xvcvdpuxws)
-VSX_IMPL_CONVERT(vec_uint4, vec_float4, vec_ctu)
-
-// converts single and double precision to signed doubleword
-#ifdef vec_ctsl
-#undef vec_ctsl
-#endif
-VSX_IMPL_CONVERT(vec_dword2, vec_double2, vec_ctsl)
-// __builtin_convertvector unable to convert, xvcvspsxds is missing on it
-VSX_FINLINE(vec_dword2) vec_ctslo(const vec_float4 &a) {
-  return vec_ctsl(vec_cvfo(a));
-}
-
-// converts single and double precision to unsigned doubleword
-#ifdef vec_ctul
-#undef vec_ctul
-#endif
-VSX_IMPL_CONVERT(vec_udword2, vec_double2, vec_ctul)
-// __builtin_convertvector unable to convert, xvcvspuxds is missing on it
-VSX_FINLINE(vec_udword2) vec_ctulo(const vec_float4 &a) {
-  return vec_ctul(vec_cvfo(a));
-}
-
-#endif // CLANG VSX compatibility
-
-/*
- * Common GCC, CLANG compatibility
- **/
-#if defined(__GNUG__) && !defined(__IBMCPP__)
-
-#ifdef vec_cvf
-#undef vec_cvf
-#endif
-
-#define VSX_IMPL_CONV_EVEN_4_2(rt, rg, fnm, fn2)                               \
-  VSX_FINLINE(rt) fnm(const rg &a) { return fn2(vec_sldw(a, a, 1)); }
-
-VSX_IMPL_CONV_EVEN_4_2(vec_double2, vec_float4, vec_cvf, vec_cvfo)
-VSX_IMPL_CONV_EVEN_4_2(vec_double2, vec_int4, vec_ctd, vec_ctdo)
-VSX_IMPL_CONV_EVEN_4_2(vec_double2, vec_uint4, vec_ctd, vec_ctdo)
-
-VSX_IMPL_CONV_EVEN_4_2(vec_dword2, vec_float4, vec_ctsl, vec_ctslo)
-VSX_IMPL_CONV_EVEN_4_2(vec_udword2, vec_float4, vec_ctul, vec_ctulo)
-
-#define VSX_IMPL_CONV_EVEN_2_4(rt, rg, fnm, fn2)                               \
-  VSX_FINLINE(rt) fnm(const rg &a) {                                           \
-    rt v4 = fn2(a);                                                            \
-    return vec_sldw(v4, v4, 3);                                                \
-  }
-
-VSX_IMPL_CONV_EVEN_2_4(vec_float4, vec_double2, vec_cvf, vec_cvfo)
-VSX_IMPL_CONV_EVEN_2_4(vec_float4, vec_dword2, vec_ctf, vec_ctfo)
-VSX_IMPL_CONV_EVEN_2_4(vec_float4, vec_udword2, vec_ctf, vec_ctfo)
-
-VSX_IMPL_CONV_EVEN_2_4(vec_int4, vec_double2, vec_cts, vec_ctso)
-VSX_IMPL_CONV_EVEN_2_4(vec_uint4, vec_double2, vec_ctu, vec_ctuo)
-
-// Only for Eigen!
-/*
- * changing behavior of conversion intrinsics for gcc has effect on Eigen
- * so we redefine old behavior again only on gcc, clang
- */
-#if !defined(__clang__) || __clang_major__ > 4
-// ignoring second arg since Eigen only truncates toward zero
-#define VSX_IMPL_CONV_2VARIANT(rt, rg, fnm, fn2)                               \
-  VSX_FINLINE(rt) fnm(const rg &a, int only_truncate) {                        \
-    assert(only_truncate == 0);                                                \
-    CV_UNUSED(only_truncate);                                                  \
-    return fn2(a);                                                             \
-  }
-VSX_IMPL_CONV_2VARIANT(vec_int4, vec_float4, vec_cts, vec_cts)
-VSX_IMPL_CONV_2VARIANT(vec_uint4, vec_float4, vec_ctu, vec_ctu)
-VSX_IMPL_CONV_2VARIANT(vec_float4, vec_int4, vec_ctf, vec_ctf)
-VSX_IMPL_CONV_2VARIANT(vec_float4, vec_uint4, vec_ctf, vec_ctf)
-// define vec_cts for converting double precision to signed doubleword
-// which isn't compatible with xlc but its okay since Eigen only uses it for gcc
-VSX_IMPL_CONV_2VARIANT(vec_dword2, vec_double2, vec_cts, vec_ctsl)
-#endif // Eigen
-
-#endif // Common GCC, CLANG compatibility
-
-/*
- * XLC VSX compatibility
- **/
-#if defined(__IBMCPP__)
-
-// vector population count
-#define vec_popcntu vec_popcnt
-
-// overload and redirect with setting second arg to zero
-// since we only support conversions without the second arg
-#define VSX_IMPL_OVERLOAD_Z2(rt, rg, fnm)                                      \
-  VSX_FINLINE(rt) fnm(const rg &a) { return fnm(a, 0); }
-
-VSX_IMPL_OVERLOAD_Z2(vec_double2, vec_int4, vec_ctd)
-VSX_IMPL_OVERLOAD_Z2(vec_double2, vec_uint4, vec_ctd)
-VSX_IMPL_OVERLOAD_Z2(vec_double2, vec_dword2, vec_ctd)
-VSX_IMPL_OVERLOAD_Z2(vec_double2, vec_udword2, vec_ctd)
-
-VSX_IMPL_OVERLOAD_Z2(vec_float4, vec_int4, vec_ctf)
-VSX_IMPL_OVERLOAD_Z2(vec_float4, vec_uint4, vec_ctf)
-VSX_IMPL_OVERLOAD_Z2(vec_float4, vec_dword2, vec_ctf)
-VSX_IMPL_OVERLOAD_Z2(vec_float4, vec_udword2, vec_ctf)
-
-VSX_IMPL_OVERLOAD_Z2(vec_int4, vec_double2, vec_cts)
-VSX_IMPL_OVERLOAD_Z2(vec_int4, vec_float4, vec_cts)
-
-VSX_IMPL_OVERLOAD_Z2(vec_uint4, vec_double2, vec_ctu)
-VSX_IMPL_OVERLOAD_Z2(vec_uint4, vec_float4, vec_ctu)
-
-VSX_IMPL_OVERLOAD_Z2(vec_dword2, vec_double2, vec_ctsl)
-VSX_IMPL_OVERLOAD_Z2(vec_dword2, vec_float4, vec_ctsl)
-
-VSX_IMPL_OVERLOAD_Z2(vec_udword2, vec_double2, vec_ctul)
-VSX_IMPL_OVERLOAD_Z2(vec_udword2, vec_float4, vec_ctul)
-
-// fixme: implement conversions of odd-numbered elements in a dirty way
-// since xlc doesn't support VSX registers operand in inline asm.
-#define VSX_IMPL_CONV_ODD_4_2(rt, rg, fnm, fn2)                                \
-  VSX_FINLINE(rt) fnm(const rg &a) { return fn2(vec_sldw(a, a, 3)); }
-
-VSX_IMPL_CONV_ODD_4_2(vec_double2, vec_float4, vec_cvfo, vec_cvf)
-VSX_IMPL_CONV_ODD_4_2(vec_double2, vec_int4, vec_ctdo, vec_ctd)
-VSX_IMPL_CONV_ODD_4_2(vec_double2, vec_uint4, vec_ctdo, vec_ctd)
-
-VSX_IMPL_CONV_ODD_4_2(vec_dword2, vec_float4, vec_ctslo, vec_ctsl)
-VSX_IMPL_CONV_ODD_4_2(vec_udword2, vec_float4, vec_ctulo, vec_ctul)
-
-#define VSX_IMPL_CONV_ODD_2_4(rt, rg, fnm, fn2)                                \
-  VSX_FINLINE(rt) fnm(const rg &a) {                                           \
-    rt v4 = fn2(a);                                                            \
-    return vec_sldw(v4, v4, 1);                                                \
-  }
-
-VSX_IMPL_CONV_ODD_2_4(vec_float4, vec_double2, vec_cvfo, vec_cvf)
-VSX_IMPL_CONV_ODD_2_4(vec_float4, vec_dword2, vec_ctfo, vec_ctf)
-VSX_IMPL_CONV_ODD_2_4(vec_float4, vec_udword2, vec_ctfo, vec_ctf)
-
-VSX_IMPL_CONV_ODD_2_4(vec_int4, vec_double2, vec_ctso, vec_cts)
-VSX_IMPL_CONV_ODD_2_4(vec_uint4, vec_double2, vec_ctuo, vec_ctu)
-
-#endif // XLC VSX compatibility
-
-// ignore GCC warning that caused by -Wunused-but-set-variable in rare cases
-#if defined(__GNUG__) && !defined(__clang__)
-#define VSX_UNUSED(Tvec) Tvec __attribute__((__unused__))
-#else // CLANG, XLC
-#define VSX_UNUSED(Tvec) Tvec
-#endif
-
-// gcc can find his way in casting log int and XLC, CLANG ambiguous
-#if defined(__clang__) || defined(__IBMCPP__)
-VSX_FINLINE(vec_udword2) vec_splats(uint64 v) {
-  return vec_splats((unsigned long long)v);
-}
-
-VSX_FINLINE(vec_dword2) vec_splats(int64 v) { return vec_splats((long long)v); }
-
-VSX_FINLINE(vec_udword2) vec_promote(uint64 a, int b) {
-  return vec_promote((unsigned long long)a, b);
-}
-
-VSX_FINLINE(vec_dword2) vec_promote(int64 a, int b) {
-  return vec_promote((long long)a, b);
-}
-#endif
-
-/*
- * implement vsx_ld(offset, pointer), vsx_st(vector, offset, pointer)
- * load and set using offset depend on the pointer type
- *
- * implement vsx_ldf(offset, pointer), vsx_stf(vector, offset, pointer)
- * load and set using offset depend on fixed bytes size
- *
- * Note: In clang vec_xl and vec_xst fails to load unaligned addresses
- * so we are using vec_vsx_ld, vec_vsx_st instead
- */
-
-#if defined(__clang__) && !defined(__IBMCPP__)
-#define vsx_ldf vec_vsx_ld
-#define vsx_stf vec_vsx_st
-#else // GCC , XLC
-#define vsx_ldf vec_xl
-#define vsx_stf vec_xst
-#endif
-
-#define VSX_OFFSET(o, p) ((o) * sizeof(*(p)))
-#define vsx_ld(o, p) vsx_ldf(VSX_OFFSET(o, p), p)
-#define vsx_st(v, o, p) vsx_stf(v, VSX_OFFSET(o, p), p)
-
-/*
- * implement vsx_ld2(offset, pointer), vsx_st2(vector, offset, pointer) to load
- * and store double words In GCC vec_xl and vec_xst it maps to vec_vsx_ld,
- * vec_vsx_st which doesn't support long long and in CLANG we are using
- * vec_vsx_ld, vec_vsx_st because vec_xl, vec_xst fails to load unaligned
- * addresses
- *
- * In XLC vec_xl and vec_xst fail to cast int64(long int) to long long
- */
-#if (defined(__GNUG__) || defined(__clang__)) && !defined(__IBMCPP__)
-VSX_FINLINE(vec_udword2) vsx_ld2(long o, const uint64 *p) {
-  return vec_udword2_c(vsx_ldf(VSX_OFFSET(o, p), (unsigned int *)p));
-}
-
-VSX_FINLINE(vec_dword2) vsx_ld2(long o, const int64 *p) {
-  return vec_dword2_c(vsx_ldf(VSX_OFFSET(o, p), (int *)p));
-}
-
-VSX_FINLINE(void) vsx_st2(const vec_udword2 &vec, long o, uint64 *p) {
-  vsx_stf(vec_uint4_c(vec), VSX_OFFSET(o, p), (unsigned int *)p);
-}
-
-VSX_FINLINE(void) vsx_st2(const vec_dword2 &vec, long o, int64 *p) {
-  vsx_stf(vec_int4_c(vec), VSX_OFFSET(o, p), (int *)p);
-}
-#else // XLC
-VSX_FINLINE(vec_udword2) vsx_ld2(long o, const uint64 *p) {
-  return vsx_ldf(VSX_OFFSET(o, p), (unsigned long long *)p);
-}
-
-VSX_FINLINE(vec_dword2) vsx_ld2(long o, const int64 *p) {
-  return vsx_ldf(VSX_OFFSET(o, p), (long long *)p);
-}
-
-VSX_FINLINE(void) vsx_st2(const vec_udword2 &vec, long o, uint64 *p) {
-  vsx_stf(vec, VSX_OFFSET(o, p), (unsigned long long *)p);
-}
-
-VSX_FINLINE(void) vsx_st2(const vec_dword2 &vec, long o, int64 *p) {
-  vsx_stf(vec, VSX_OFFSET(o, p), (long long *)p);
-}
-#endif
-
-// Store lower 8 byte
-#define vec_st_l8(v, p) *((uint64 *)(p)) = vec_extract(vec_udword2_c(v), 0)
-
-// Store higher 8 byte
-#define vec_st_h8(v, p) *((uint64 *)(p)) = vec_extract(vec_udword2_c(v), 1)
-
-// Load 64-bits of integer data to lower part
-#define VSX_IMPL_LOAD_L8(Tvec, Tp)                                             \
-  VSX_FINLINE(Tvec) vec_ld_l8(const Tp *p) {                                   \
-    return ((Tvec)vec_promote(*((uint64 *)p), 0));                             \
-  }
-
-VSX_IMPL_LOAD_L8(vec_uchar16, uchar)
-VSX_IMPL_LOAD_L8(vec_char16, schar)
-VSX_IMPL_LOAD_L8(vec_ushort8, ushort)
-VSX_IMPL_LOAD_L8(vec_short8, short)
-VSX_IMPL_LOAD_L8(vec_uint4, uint)
-VSX_IMPL_LOAD_L8(vec_int4, int)
-VSX_IMPL_LOAD_L8(vec_float4, float)
-VSX_IMPL_LOAD_L8(vec_udword2, uint64)
-VSX_IMPL_LOAD_L8(vec_dword2, int64)
-VSX_IMPL_LOAD_L8(vec_double2, double)
-
-// logical not
-#define vec_not(a) vec_nor(a, a)
-
-// power9 yaya
-// not equal
-#ifndef vec_cmpne
-#define vec_cmpne(a, b) vec_not(vec_cmpeq(a, b))
-#endif
-
-// absolute difference
-#ifndef _ARCH_PWR9
-#undef vec_absd
-#define vec_absd(a, b) vec_sub(vec_max(a, b), vec_min(a, b))
-#endif
-
-/*
- * Implement vec_unpacklu and vec_unpackhu
- * since vec_unpackl, vec_unpackh only support signed integers
- **/
-#define VSX_IMPL_UNPACKU(rt, rg, zero)                                         \
-  VSX_FINLINE(rt) vec_unpacklu(const rg &a) {                                  \
-    return (rt)(vec_mergel(a, zero));                                          \
-  }                                                                            \
-  VSX_FINLINE(rt) vec_unpackhu(const rg &a) {                                  \
-    return (rt)(vec_mergeh(a, zero));                                          \
-  }
-
-VSX_IMPL_UNPACKU(vec_ushort8, vec_uchar16, vec_uchar16_z)
-VSX_IMPL_UNPACKU(vec_uint4, vec_ushort8, vec_ushort8_z)
-VSX_IMPL_UNPACKU(vec_udword2, vec_uint4, vec_uint4_z)
-
-/*
- * Implement vec_mergesqe and vec_mergesqo
- * Merges the sequence values of even and odd elements of two vectors
- */
-#define VSX_IMPL_PERM(rt, fnm, ...)                                            \
-  VSX_FINLINE(rt) fnm(const rt &a, const rt &b) {                              \
-    static const vec_uchar16 perm = {__VA_ARGS__};                             \
-    return vec_perm(a, b, perm);                                               \
-  }
-
-// 16
-#define perm16_mergesqe                                                        \
-  0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30
-#define perm16_mergesqo                                                        \
-  1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31
-VSX_IMPL_PERM(vec_uchar16, vec_mergesqe, perm16_mergesqe)
-VSX_IMPL_PERM(vec_uchar16, vec_mergesqo, perm16_mergesqo)
-VSX_IMPL_PERM(vec_char16, vec_mergesqe, perm16_mergesqe)
-VSX_IMPL_PERM(vec_char16, vec_mergesqo, perm16_mergesqo)
-// 8
-#define perm8_mergesqe 0, 1, 4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29
-#define perm8_mergesqo                                                         \
-  2, 3, 6, 7, 10, 11, 14, 15, 18, 19, 22, 23, 26, 27, 30, 31
-VSX_IMPL_PERM(vec_ushort8, vec_mergesqe, perm8_mergesqe)
-VSX_IMPL_PERM(vec_ushort8, vec_mergesqo, perm8_mergesqo)
-VSX_IMPL_PERM(vec_short8, vec_mergesqe, perm8_mergesqe)
-VSX_IMPL_PERM(vec_short8, vec_mergesqo, perm8_mergesqo)
-// 4
-#define perm4_mergesqe 0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27
-#define perm4_mergesqo                                                         \
-  4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31
-VSX_IMPL_PERM(vec_uint4, vec_mergesqe, perm4_mergesqe)
-VSX_IMPL_PERM(vec_uint4, vec_mergesqo, perm4_mergesqo)
-VSX_IMPL_PERM(vec_int4, vec_mergesqe, perm4_mergesqe)
-VSX_IMPL_PERM(vec_int4, vec_mergesqo, perm4_mergesqo)
-VSX_IMPL_PERM(vec_float4, vec_mergesqe, perm4_mergesqe)
-VSX_IMPL_PERM(vec_float4, vec_mergesqo, perm4_mergesqo)
-// 2
-VSX_REDIRECT_2RG(vec_double2, vec_double2, vec_mergesqe, vec_mergeh)
-VSX_REDIRECT_2RG(vec_double2, vec_double2, vec_mergesqo, vec_mergel)
-VSX_REDIRECT_2RG(vec_dword2, vec_dword2, vec_mergesqe, vec_mergeh)
-VSX_REDIRECT_2RG(vec_dword2, vec_dword2, vec_mergesqo, vec_mergel)
-VSX_REDIRECT_2RG(vec_udword2, vec_udword2, vec_mergesqe, vec_mergeh)
-VSX_REDIRECT_2RG(vec_udword2, vec_udword2, vec_mergesqo, vec_mergel)
-
-/*
- * Implement vec_mergesqh and vec_mergesql
- * Merges the sequence most and least significant halves of two vectors
- */
-#define VSX_IMPL_MERGESQHL(Tvec)                                               \
-  VSX_FINLINE(Tvec) vec_mergesqh(const Tvec &a, const Tvec &b) {               \
-    return (Tvec)vec_mergeh(vec_udword2_c(a), vec_udword2_c(b));               \
-  }                                                                            \
-  VSX_FINLINE(Tvec) vec_mergesql(const Tvec &a, const Tvec &b) {               \
-    return (Tvec)vec_mergel(vec_udword2_c(a), vec_udword2_c(b));               \
-  }
-VSX_IMPL_MERGESQHL(vec_uchar16)
-VSX_IMPL_MERGESQHL(vec_char16)
-VSX_IMPL_MERGESQHL(vec_ushort8)
-VSX_IMPL_MERGESQHL(vec_short8)
-VSX_IMPL_MERGESQHL(vec_uint4)
-VSX_IMPL_MERGESQHL(vec_int4)
-VSX_IMPL_MERGESQHL(vec_float4)
-VSX_REDIRECT_2RG(vec_udword2, vec_udword2, vec_mergesqh, vec_mergeh)
-VSX_REDIRECT_2RG(vec_udword2, vec_udword2, vec_mergesql, vec_mergel)
-VSX_REDIRECT_2RG(vec_dword2, vec_dword2, vec_mergesqh, vec_mergeh)
-VSX_REDIRECT_2RG(vec_dword2, vec_dword2, vec_mergesql, vec_mergel)
-VSX_REDIRECT_2RG(vec_double2, vec_double2, vec_mergesqh, vec_mergeh)
-VSX_REDIRECT_2RG(vec_double2, vec_double2, vec_mergesql, vec_mergel)
-
-// 2 and 4 channels interleave for all types except 2 lanes
-#define VSX_IMPL_ST_INTERLEAVE(Tp, Tvec)                                       \
-  VSX_FINLINE(void) vec_st_interleave(const Tvec &a, const Tvec &b, Tp *ptr) { \
-    vsx_stf(vec_mergeh(a, b), 0, ptr);                                         \
-    vsx_stf(vec_mergel(a, b), 16, ptr);                                        \
-  }                                                                            \
-  VSX_FINLINE(void)                                                            \
-  vec_st_interleave(const Tvec &a, const Tvec &b, const Tvec &c,               \
-                    const Tvec &d, Tp *ptr) {                                  \
-    Tvec ac = vec_mergeh(a, c);                                                \
-    Tvec bd = vec_mergeh(b, d);                                                \
-    vsx_stf(vec_mergeh(ac, bd), 0, ptr);                                       \
-    vsx_stf(vec_mergel(ac, bd), 16, ptr);                                      \
-    ac = vec_mergel(a, c);                                                     \
-    bd = vec_mergel(b, d);                                                     \
-    vsx_stf(vec_mergeh(ac, bd), 32, ptr);                                      \
-    vsx_stf(vec_mergel(ac, bd), 48, ptr);                                      \
-  }
-VSX_IMPL_ST_INTERLEAVE(uchar, vec_uchar16)
-VSX_IMPL_ST_INTERLEAVE(schar, vec_char16)
-VSX_IMPL_ST_INTERLEAVE(ushort, vec_ushort8)
-VSX_IMPL_ST_INTERLEAVE(short, vec_short8)
-VSX_IMPL_ST_INTERLEAVE(uint, vec_uint4)
-VSX_IMPL_ST_INTERLEAVE(int, vec_int4)
-VSX_IMPL_ST_INTERLEAVE(float, vec_float4)
-
-// 2 and 4 channels deinterleave for 16 lanes
-#define VSX_IMPL_ST_DINTERLEAVE_8(Tp, Tvec)                                    \
-  VSX_FINLINE(void) vec_ld_deinterleave(const Tp *ptr, Tvec &a, Tvec &b) {     \
-    Tvec v0 = vsx_ld(0, ptr);                                                  \
-    Tvec v1 = vsx_ld(16, ptr);                                                 \
-    a = vec_mergesqe(v0, v1);                                                  \
-    b = vec_mergesqo(v0, v1);                                                  \
-  }                                                                            \
-  VSX_FINLINE(void)                                                            \
-  vec_ld_deinterleave(const Tp *ptr, Tvec &a, Tvec &b, Tvec &c, Tvec &d) {     \
-    Tvec v0 = vsx_ld(0, ptr);                                                  \
-    Tvec v1 = vsx_ld(16, ptr);                                                 \
-    Tvec v2 = vsx_ld(32, ptr);                                                 \
-    Tvec v3 = vsx_ld(48, ptr);                                                 \
-    Tvec m0 = vec_mergesqe(v0, v1);                                            \
-    Tvec m1 = vec_mergesqe(v2, v3);                                            \
-    a = vec_mergesqe(m0, m1);                                                  \
-    c = vec_mergesqo(m0, m1);                                                  \
-    m0 = vec_mergesqo(v0, v1);                                                 \
-    m1 = vec_mergesqo(v2, v3);                                                 \
-    b = vec_mergesqe(m0, m1);                                                  \
-    d = vec_mergesqo(m0, m1);                                                  \
-  }
-VSX_IMPL_ST_DINTERLEAVE_8(uchar, vec_uchar16)
-VSX_IMPL_ST_DINTERLEAVE_8(schar, vec_char16)
-
-// 2 and 4 channels deinterleave for 8 lanes
-#define VSX_IMPL_ST_DINTERLEAVE_16(Tp, Tvec)                                   \
-  VSX_FINLINE(void) vec_ld_deinterleave(const Tp *ptr, Tvec &a, Tvec &b) {     \
-    Tvec v0 = vsx_ld(0, ptr);                                                  \
-    Tvec v1 = vsx_ld(8, ptr);                                                  \
-    a = vec_mergesqe(v0, v1);                                                  \
-    b = vec_mergesqo(v0, v1);                                                  \
-  }                                                                            \
-  VSX_FINLINE(void)                                                            \
-  vec_ld_deinterleave(const Tp *ptr, Tvec &a, Tvec &b, Tvec &c, Tvec &d) {     \
-    Tvec v0 = vsx_ld(0, ptr);                                                  \
-    Tvec v1 = vsx_ld(8, ptr);                                                  \
-    Tvec m0 = vec_mergeh(v0, v1);                                              \
-    Tvec m1 = vec_mergel(v0, v1);                                              \
-    Tvec ab0 = vec_mergeh(m0, m1);                                             \
-    Tvec cd0 = vec_mergel(m0, m1);                                             \
-    v0 = vsx_ld(16, ptr);                                                      \
-    v1 = vsx_ld(24, ptr);                                                      \
-    m0 = vec_mergeh(v0, v1);                                                   \
-    m1 = vec_mergel(v0, v1);                                                   \
-    Tvec ab1 = vec_mergeh(m0, m1);                                             \
-    Tvec cd1 = vec_mergel(m0, m1);                                             \
-    a = vec_mergesqh(ab0, ab1);                                                \
-    b = vec_mergesql(ab0, ab1);                                                \
-    c = vec_mergesqh(cd0, cd1);                                                \
-    d = vec_mergesql(cd0, cd1);                                                \
-  }
-VSX_IMPL_ST_DINTERLEAVE_16(ushort, vec_ushort8)
-VSX_IMPL_ST_DINTERLEAVE_16(short, vec_short8)
-
-// 2 and 4 channels deinterleave for 4 lanes
-#define VSX_IMPL_ST_DINTERLEAVE_32(Tp, Tvec)                                   \
-  VSX_FINLINE(void) vec_ld_deinterleave(const Tp *ptr, Tvec &a, Tvec &b) {     \
-    a = vsx_ld(0, ptr);                                                        \
-    b = vsx_ld(4, ptr);                                                        \
-    Tvec m0 = vec_mergeh(a, b);                                                \
-    Tvec m1 = vec_mergel(a, b);                                                \
-    a = vec_mergeh(m0, m1);                                                    \
-    b = vec_mergel(m0, m1);                                                    \
-  }                                                                            \
-  VSX_FINLINE(void)                                                            \
-  vec_ld_deinterleave(const Tp *ptr, Tvec &a, Tvec &b, Tvec &c, Tvec &d) {     \
-    Tvec v0 = vsx_ld(0, ptr);                                                  \
-    Tvec v1 = vsx_ld(4, ptr);                                                  \
-    Tvec v2 = vsx_ld(8, ptr);                                                  \
-    Tvec v3 = vsx_ld(12, ptr);                                                 \
-    Tvec m0 = vec_mergeh(v0, v2);                                              \
-    Tvec m1 = vec_mergeh(v1, v3);                                              \
-    a = vec_mergeh(m0, m1);                                                    \
-    b = vec_mergel(m0, m1);                                                    \
-    m0 = vec_mergel(v0, v2);                                                   \
-    m1 = vec_mergel(v1, v3);                                                   \
-    c = vec_mergeh(m0, m1);                                                    \
-    d = vec_mergel(m0, m1);                                                    \
-  }
-VSX_IMPL_ST_DINTERLEAVE_32(uint, vec_uint4)
-VSX_IMPL_ST_DINTERLEAVE_32(int, vec_int4)
-VSX_IMPL_ST_DINTERLEAVE_32(float, vec_float4)
-
-// 2 and 4 channels interleave and deinterleave for 2 lanes
-#define VSX_IMPL_ST_D_INTERLEAVE_64(Tp, Tvec, ld_func, st_func)                \
-  VSX_FINLINE(void) vec_st_interleave(const Tvec &a, const Tvec &b, Tp *ptr) { \
-    st_func(vec_mergeh(a, b), 0, ptr);                                         \
-    st_func(vec_mergel(a, b), 2, ptr);                                         \
-  }                                                                            \
-  VSX_FINLINE(void)                                                            \
-  vec_st_interleave(const Tvec &a, const Tvec &b, const Tvec &c,               \
-                    const Tvec &d, Tp *ptr) {                                  \
-    st_func(vec_mergeh(a, b), 0, ptr);                                         \
-    st_func(vec_mergeh(c, d), 2, ptr);                                         \
-    st_func(vec_mergel(a, b), 4, ptr);                                         \
-    st_func(vec_mergel(c, d), 6, ptr);                                         \
-  }                                                                            \
-  VSX_FINLINE(void) vec_ld_deinterleave(const Tp *ptr, Tvec &a, Tvec &b) {     \
-    Tvec m0 = ld_func(0, ptr);                                                 \
-    Tvec m1 = ld_func(2, ptr);                                                 \
-    a = vec_mergeh(m0, m1);                                                    \
-    b = vec_mergel(m0, m1);                                                    \
-  }                                                                            \
-  VSX_FINLINE(void)                                                            \
-  vec_ld_deinterleave(const Tp *ptr, Tvec &a, Tvec &b, Tvec &c, Tvec &d) {     \
-    Tvec v0 = ld_func(0, ptr);                                                 \
-    Tvec v1 = ld_func(2, ptr);                                                 \
-    Tvec v2 = ld_func(4, ptr);                                                 \
-    Tvec v3 = ld_func(6, ptr);                                                 \
-    a = vec_mergeh(v0, v2);                                                    \
-    b = vec_mergel(v0, v2);                                                    \
-    c = vec_mergeh(v1, v3);                                                    \
-    d = vec_mergel(v1, v3);                                                    \
-  }
-VSX_IMPL_ST_D_INTERLEAVE_64(int64, vec_dword2, vsx_ld2, vsx_st2)
-VSX_IMPL_ST_D_INTERLEAVE_64(uint64, vec_udword2, vsx_ld2, vsx_st2)
-VSX_IMPL_ST_D_INTERLEAVE_64(double, vec_double2, vsx_ld, vsx_st)
-
-/* 3 channels */
-#define VSX_IMPL_ST_INTERLEAVE_3CH_16(Tp, Tvec)                                \
-  VSX_FINLINE(void)                                                            \
-  vec_st_interleave(const Tvec &a, const Tvec &b, const Tvec &c, Tp *ptr) {    \
-    static const vec_uchar16 a12 = {0, 16, 0,  1, 17, 0,  2, 18,               \
-                                    0, 3,  19, 0, 4,  20, 0, 5};               \
-    static const vec_uchar16 a123 = {0,  1, 16, 3,  4,  17, 6,  7,             \
-                                     18, 9, 10, 19, 12, 13, 20, 15};           \
-    vsx_st(vec_perm(vec_perm(a, b, a12), c, a123), 0, ptr);                    \
-    static const vec_uchar16 b12 = {21, 0,  6, 22, 0,  7, 23, 0,               \
-                                    8,  24, 0, 9,  25, 0, 10, 26};             \
-    static const vec_uchar16 b123 = {0, 21, 2,  3,  22, 5,  6,  23,            \
-                                     8, 9,  24, 11, 12, 25, 14, 15};           \
-    vsx_st(vec_perm(vec_perm(a, b, b12), c, b123), 16, ptr);                   \
-    static const vec_uchar16 c12 = {0,  11, 27, 0,  12, 28, 0,  13,            \
-                                    29, 0,  14, 30, 0,  15, 31, 0};            \
-    static const vec_uchar16 c123 = {26, 1,  2,  27, 4,  5,  28, 7,            \
-                                     8,  29, 10, 11, 30, 13, 14, 31};          \
-    vsx_st(vec_perm(vec_perm(a, b, c12), c, c123), 32, ptr);                   \
-  }                                                                            \
-  VSX_FINLINE(void)                                                            \
-  vec_ld_deinterleave(const Tp *ptr, Tvec &a, Tvec &b, Tvec &c) {              \
-    Tvec v1 = vsx_ld(0, ptr);                                                  \
-    Tvec v2 = vsx_ld(16, ptr);                                                 \
-    Tvec v3 = vsx_ld(32, ptr);                                                 \
-    static const vec_uchar16 a12_perm = {0,  3,  6,  9, 12, 15, 18, 21,        \
-                                         24, 27, 30, 0, 0,  0,  0,  0};        \
-    static const vec_uchar16 a123_perm = {0, 1, 2,  3,  4,  5,  6,  7,         \
-                                          8, 9, 10, 17, 20, 23, 26, 29};       \
-    a = vec_perm(vec_perm(v1, v2, a12_perm), v3, a123_perm);                   \
-    static const vec_uchar16 b12_perm = {1,  4,  7,  10, 13, 16, 19, 22,       \
-                                         25, 28, 31, 0,  0,  0,  0,  0};       \
-    static const vec_uchar16 b123_perm = {0, 1, 2,  3,  4,  5,  6,  7,         \
-                                          8, 9, 10, 18, 21, 24, 27, 30};       \
-    b = vec_perm(vec_perm(v1, v2, b12_perm), v3, b123_perm);                   \
-    static const vec_uchar16 c12_perm = {2,  5,  8, 11, 14, 17, 20, 23,        \
-                                         26, 29, 0, 0,  0,  0,  0,  0};        \
-    static const vec_uchar16 c123_perm = {0, 1, 2,  3,  4,  5,  6,  7,         \
-                                          8, 9, 16, 19, 22, 25, 28, 31};       \
-    c = vec_perm(vec_perm(v1, v2, c12_perm), v3, c123_perm);                   \
-  }
-VSX_IMPL_ST_INTERLEAVE_3CH_16(uchar, vec_uchar16)
-VSX_IMPL_ST_INTERLEAVE_3CH_16(schar, vec_char16)
-
-#define VSX_IMPL_ST_INTERLEAVE_3CH_8(Tp, Tvec)                                 \
-  VSX_FINLINE(void)                                                            \
-  vec_st_interleave(const Tvec &a, const Tvec &b, const Tvec &c, Tp *ptr) {    \
-    static const vec_uchar16 a12 = {0,  1,  16, 17, 0, 0, 2,  3,               \
-                                    18, 19, 0,  0,  4, 5, 20, 21};             \
-    static const vec_uchar16 a123 = {0, 1, 2,  3,  16, 17, 6,  7,              \
-                                     8, 9, 18, 19, 12, 13, 14, 15};            \
-    vsx_st(vec_perm(vec_perm(a, b, a12), c, a123), 0, ptr);                    \
-    static const vec_uchar16 b12 = {0, 0, 6,  7,  22, 23, 0,  0,               \
-                                    8, 9, 24, 25, 0,  0,  10, 11};             \
-    static const vec_uchar16 b123 = {20, 21, 2,  3,  4,  5,  22, 23,           \
-                                     8,  9,  10, 11, 24, 25, 14, 15};          \
-    vsx_st(vec_perm(vec_perm(a, b, b12), c, b123), 8, ptr);                    \
-    static const vec_uchar16 c12 = {26, 27, 0,  0,  12, 13, 28, 29,            \
-                                    0,  0,  14, 15, 30, 31, 0,  0};            \
-    static const vec_uchar16 c123 = {0,  1,  26, 27, 4,  5,  6,  7,            \
-                                     28, 29, 10, 11, 12, 13, 30, 31};          \
-    vsx_st(vec_perm(vec_perm(a, b, c12), c, c123), 16, ptr);                   \
-  }                                                                            \
-  VSX_FINLINE(void)                                                            \
-  vec_ld_deinterleave(const Tp *ptr, Tvec &a, Tvec &b, Tvec &c) {              \
-    Tvec v1 = vsx_ld(0, ptr);                                                  \
-    Tvec v2 = vsx_ld(8, ptr);                                                  \
-    Tvec v3 = vsx_ld(16, ptr);                                                 \
-    static const vec_uchar16 a12_perm = {0,  1,  6,  7,  12, 13, 18, 19,       \
-                                         24, 25, 30, 31, 0,  0,  0,  0};       \
-    static const vec_uchar16 a123_perm = {0, 1, 2,  3,  4,  5,  6,  7,         \
-                                          8, 9, 10, 11, 20, 21, 26, 27};       \
-    a = vec_perm(vec_perm(v1, v2, a12_perm), v3, a123_perm);                   \
-    static const vec_uchar16 b12_perm = {2,  3,  8, 9, 14, 15, 20, 21,         \
-                                         26, 27, 0, 0, 0,  0,  0,  0};         \
-    static const vec_uchar16 b123_perm = {0, 1, 2,  3,  4,  5,  6,  7,         \
-                                          8, 9, 16, 17, 22, 23, 28, 29};       \
-    b = vec_perm(vec_perm(v1, v2, b12_perm), v3, b123_perm);                   \
-    static const vec_uchar16 c12_perm = {4,  5,  10, 11, 16, 17, 22, 23,       \
-                                         28, 29, 0,  0,  0,  0,  0,  0};       \
-    static const vec_uchar16 c123_perm = {0, 1, 2,  3,  4,  5,  6,  7,         \
-                                          8, 9, 18, 19, 24, 25, 30, 31};       \
-    c = vec_perm(vec_perm(v1, v2, c12_perm), v3, c123_perm);                   \
-  }
-VSX_IMPL_ST_INTERLEAVE_3CH_8(ushort, vec_ushort8)
-VSX_IMPL_ST_INTERLEAVE_3CH_8(short, vec_short8)
-
-#define VSX_IMPL_ST_INTERLEAVE_3CH_4(Tp, Tvec)                                 \
-  VSX_FINLINE(void)                                                            \
-  vec_st_interleave(const Tvec &a, const Tvec &b, const Tvec &c, Tp *ptr) {    \
-    Tvec hbc = vec_mergeh(b, c);                                               \
-    static const vec_uchar16 ahbc = {0,  1,  2,  3,  16, 17, 18, 19,           \
-                                     20, 21, 22, 23, 4,  5,  6,  7};           \
-    vsx_st(vec_perm(a, hbc, ahbc), 0, ptr);                                    \
-    Tvec lab = vec_mergel(a, b);                                               \
-    vsx_st(vec_sld(lab, hbc, 8), 4, ptr);                                      \
-    static const vec_uchar16 clab = {8,  9,  10, 11, 24, 25, 26, 27,           \
-                                     28, 29, 30, 31, 12, 13, 14, 15};          \
-    vsx_st(vec_perm(c, lab, clab), 8, ptr);                                    \
-  }                                                                            \
-  VSX_FINLINE(void)                                                            \
-  vec_ld_deinterleave(const Tp *ptr, Tvec &a, Tvec &b, Tvec &c) {              \
-    Tvec v1 = vsx_ld(0, ptr);                                                  \
-    Tvec v2 = vsx_ld(4, ptr);                                                  \
-    Tvec v3 = vsx_ld(8, ptr);                                                  \
-    static const vec_uchar16 flp = {0,  1,  2,  3,  12, 13, 14, 15,            \
-                                    16, 17, 18, 19, 28, 29, 30, 31};           \
-    a = vec_perm(v1, vec_sld(v3, v2, 8), flp);                                 \
-    static const vec_uchar16 flp2 = {28, 29, 30, 31, 0,  1,  2,  3,            \
-                                     12, 13, 14, 15, 16, 17, 18, 19};          \
-    b = vec_perm(v2, vec_sld(v1, v3, 8), flp2);                                \
-    c = vec_perm(vec_sld(v2, v1, 8), v3, flp);                                 \
-  }
-VSX_IMPL_ST_INTERLEAVE_3CH_4(uint, vec_uint4)
-VSX_IMPL_ST_INTERLEAVE_3CH_4(int, vec_int4)
-VSX_IMPL_ST_INTERLEAVE_3CH_4(float, vec_float4)
-
-#define VSX_IMPL_ST_INTERLEAVE_3CH_2(Tp, Tvec, ld_func, st_func)               \
-  VSX_FINLINE(void)                                                            \
-  vec_st_interleave(const Tvec &a, const Tvec &b, const Tvec &c, Tp *ptr) {    \
-    st_func(vec_mergeh(a, b), 0, ptr);                                         \
-    st_func(vec_permi(c, a, 1), 2, ptr);                                       \
-    st_func(vec_mergel(b, c), 4, ptr);                                         \
-  }                                                                            \
-  VSX_FINLINE(void)                                                            \
-  vec_ld_deinterleave(const Tp *ptr, Tvec &a, Tvec &b, Tvec &c) {              \
-    Tvec v1 = ld_func(0, ptr);                                                 \
-    Tvec v2 = ld_func(2, ptr);                                                 \
-    Tvec v3 = ld_func(4, ptr);                                                 \
-    a = vec_permi(v1, v2, 1);                                                  \
-    b = vec_permi(v1, v3, 2);                                                  \
-    c = vec_permi(v2, v3, 1);                                                  \
-  }
-VSX_IMPL_ST_INTERLEAVE_3CH_2(int64, vec_dword2, vsx_ld2, vsx_st2)
-VSX_IMPL_ST_INTERLEAVE_3CH_2(uint64, vec_udword2, vsx_ld2, vsx_st2)
-VSX_IMPL_ST_INTERLEAVE_3CH_2(double, vec_double2, vsx_ld, vsx_st)
-
-#endif // CV_VSX
-
-//! @}
-
-#endif // OPENCV_HAL_VSX_UTILS_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/cvconfig.h b/packages/react-native-executorch/third-party/include/opencv2/cvconfig.h
deleted file mode 100644
index 585effeb09..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/cvconfig.h
+++ /dev/null
@@ -1,155 +0,0 @@
-#ifndef OPENCV_CVCONFIG_H_INCLUDED
-#define OPENCV_CVCONFIG_H_INCLUDED
-
-/* OpenCV compiled as static or dynamic libs */
-/* #undef BUILD_SHARED_LIBS */
-
-/* OpenCV intrinsics optimized code */
-#define CV_ENABLE_INTRINSICS
-
-/* OpenCV additional optimized code */
-/* #undef CV_DISABLE_OPTIMIZATION */
-
-/* Compile for 'real' NVIDIA GPU architectures */
-#define CUDA_ARCH_BIN ""
-
-/* NVIDIA GPU features are used */
-#define CUDA_ARCH_FEATURES ""
-
-/* Compile for 'virtual' NVIDIA PTX architectures */
-#define CUDA_ARCH_PTX ""
-
-/* AMD's Basic Linear Algebra Subprograms Library*/
-/* #undef HAVE_CLAMDBLAS */
-
-/* AMD's OpenCL Fast Fourier Transform Library*/
-/* #undef HAVE_CLAMDFFT */
-
-/* Clp support */
-/* #undef HAVE_CLP */
-
-/* NVIDIA CUDA Runtime API*/
-/* #undef HAVE_CUDA */
-
-/* NVIDIA CUDA Basic Linear Algebra Subprograms (BLAS) API*/
-/* #undef HAVE_CUBLAS */
-
-/* NVIDIA CUDA Deep Neural Network (cuDNN) API*/
-/* #undef HAVE_CUDNN */
-
-/* NVIDIA CUDA Fast Fourier Transform (FFT) API*/
-/* #undef HAVE_CUFFT */
-
-/* DirectX */
-/* #undef HAVE_DIRECTX */
-/* #undef HAVE_DIRECTX_NV12 */
-/* #undef HAVE_D3D11 */
-/* #undef HAVE_D3D10 */
-/* #undef HAVE_D3D9 */
-
-/* Eigen Matrix & Linear Algebra Library */
-/* #undef HAVE_EIGEN */
-
-/* Geospatial Data Abstraction Library */
-/* #undef HAVE_GDAL */
-
-/* Halide support */
-/* #undef HAVE_HALIDE */
-
-/* Vulkan support */
-/* #undef HAVE_VULKAN */
-
-/* Define to 1 if you have the <inttypes.h> header file. */
-/* #undef HAVE_INTTYPES_H */
-
-/* Intel Integrated Performance Primitives */
-/* #undef HAVE_IPP */
-/* #undef HAVE_IPP_ICV */
-/* #undef HAVE_IPP_IW */
-/* #undef HAVE_IPP_IW_LL */
-
-/* JPEG-2000 codec */
-/* #undef HAVE_OPENJPEG */
-/* #undef HAVE_JASPER */
-
-/* AVIF codec */
-/* #undef HAVE_AVIF */
-
-/* IJG JPEG codec */
-/* #undef HAVE_JPEG */
-
-/* JPEG XL codec */
-/* #undef HAVE_JPEGXL */
-
-/* GDCM DICOM codec */
-/* #undef HAVE_GDCM */
-
-/* NVIDIA Video Decoding API*/
-/* #undef HAVE_NVCUVID */
-/* #undef HAVE_NVCUVID_HEADER */
-/* #undef HAVE_DYNLINK_NVCUVID_HEADER */
-
-/* NVIDIA Video Encoding API*/
-/* #undef HAVE_NVCUVENC */
-
-/* OpenCL Support */
-/* #undef HAVE_OPENCL */
-/* #undef HAVE_OPENCL_STATIC */
-/* #undef HAVE_OPENCL_SVM */
-
-/* NVIDIA OpenCL D3D Extensions support */
-/* #undef HAVE_OPENCL_D3D11_NV */
-
-/* OpenEXR codec */
-/* #undef HAVE_OPENEXR */
-
-/* OpenGL support*/
-/* #undef HAVE_OPENGL */
-
-/* PNG codec */
-/* #undef HAVE_PNG */
-
-/* PNG codec */
-/* #undef HAVE_SPNG */
-
-/* Posix threads (pthreads) */
-#define HAVE_PTHREAD
-
-/* parallel_for with pthreads */
-/* #undef HAVE_PTHREADS_PF */
-
-/* Intel Threading Building Blocks */
-/* #undef HAVE_TBB */
-
-/* Ste||ar Group High Performance ParallelX */
-/* #undef HAVE_HPX */
-
-/* TIFF codec */
-/* #undef HAVE_TIFF */
-
-/* Define if your processor stores words with the most significant byte
-   first (like Motorola and SPARC, unlike Intel and VAX). */
-/* #undef WORDS_BIGENDIAN */
-
-/* VA library (libva) */
-/* #undef HAVE_VA */
-
-/* Intel VA-API/OpenCL */
-/* #undef HAVE_VA_INTEL */
-
-/* Lapack */
-/* #undef HAVE_LAPACK */
-
-/* Library was compiled with functions instrumentation */
-/* #undef ENABLE_INSTRUMENTATION */
-
-/* OpenVX */
-/* #undef HAVE_OPENVX */
-
-/* OpenCV trace utilities */
-/* #undef OPENCV_TRACE */
-
-/* Library QR-code decoding */
-/* #undef HAVE_QUIRC */
-
-#endif // OPENCV_CVCONFIG_H_INCLUDED
diff --git a/packages/react-native-executorch/third-party/include/opencv2/dnn.hpp b/packages/react-native-executorch/third-party/include/opencv2/dnn.hpp
deleted file mode 100644
index 1331eec537..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/dnn.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-//
-// Copyright (C) 2024 nihui
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//         http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#include "opencv2/dnn/dnn.hpp"
diff --git a/packages/react-native-executorch/third-party/include/opencv2/dnn/dnn.hpp b/packages/react-native-executorch/third-party/include/opencv2/dnn/dnn.hpp
deleted file mode 100644
index 662e95d4b4..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/dnn/dnn.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-//
-// Copyright (C) 2024 nihui
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//         http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef OPENCV_DNN_HPP
-#define OPENCV_DNN_HPP
-
-#include "opencv2/core.hpp"
-
-namespace cv {
-namespace dnn {
-
-enum SoftNMSMethod { SOFTNMS_LINEAR = 1, SOFTNMS_GAUSSIAN = 2 };
-
-CV_EXPORTS void NMSBoxes(const std::vector<Rect> &bboxes,
-                         const std::vector<float> &scores,
-                         const float score_threshold, const float nms_threshold,
-                         CV_OUT std::vector<int> &indices,
-                         const float eta = 1.f, const int top_k = 0);
-
-CV_EXPORTS void NMSBoxesBatched(const std::vector<Rect> &bboxes,
-                                const std::vector<float> &scores,
-                                const std::vector<int> &class_ids,
-                                const float score_threshold,
-                                const float nms_threshold,
-                                CV_OUT std::vector<int> &indices,
-                                const float eta = 1.f, const int top_k = 0);
-
-CV_EXPORTS_W void
-softNMSBoxes(const std::vector<Rect> &bboxes, const std::vector<float> &scores,
-             CV_OUT std::vector<float> &updated_scores,
-             const float score_threshold, const float nms_threshold,
-             CV_OUT std::vector<int> &indices, size_t top_k = 0,
-             const float sigma = 0.5, SoftNMSMethod method = SOFTNMS_GAUSSIAN);
-
-} // namespace dnn
-} // namespace cv
-
-#endif // OPENCV_DNN_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/features2d.hpp b/packages/react-native-executorch/third-party/include/opencv2/features2d.hpp
deleted file mode 100644
index b794f96b62..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/features2d.hpp
+++ /dev/null
@@ -1,1756 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                           License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_FEATURES_2D_HPP
-#define OPENCV_FEATURES_2D_HPP
-
-#include "opencv2/core.hpp"
-#include "opencv2/opencv_modules.hpp"
-
-#ifdef HAVE_OPENCV_FLANN
-#include "opencv2/flann/miniflann.hpp"
-#endif
-
-/**
-  @defgroup features2d 2D Features Framework
-  @{
-    @defgroup features2d_main Feature Detection and Description
-    @defgroup features2d_match Descriptor Matchers
-
-    Matchers of keypoint descriptors in OpenCV have wrappers with a common
-  interface that enables you to easily switch between different algorithms
-  solving the same problem. This section is devoted to matching descriptors that
-  are represented as vectors in a multidimensional space. All objects that
-  implement vector descriptor matchers inherit the DescriptorMatcher interface.
-
-    @defgroup features2d_draw Drawing Function of Keypoints and Matches
-    @defgroup features2d_category Object Categorization
-
-    This section describes approaches based on local 2D features and used to
-  categorize objects.
-
-    @defgroup feature2d_hal Hardware Acceleration Layer
-    @{
-        @defgroup features2d_hal_interface Interface
-    @}
-  @}
- */
-
-namespace cv {
-
-//! @addtogroup features2d_main
-//! @{
-
-// //! writes vector of keypoints to the file storage
-// CV_EXPORTS void write(FileStorage& fs, const String& name, const
-// std::vector<KeyPoint>& keypoints);
-// //! reads vector of keypoints from the specified file storage node
-// CV_EXPORTS void read(const FileNode& node, CV_OUT std::vector<KeyPoint>&
-// keypoints);
-
-/** @brief A class filters a vector of keypoints.
-
- Because now it is difficult to provide a convenient interface for all usage
- scenarios of the keypoints filter class, it has only several needed by now
- static methods.
- */
-class CV_EXPORTS KeyPointsFilter {
-public:
-  KeyPointsFilter() {}
-
-  /*
-   * Remove keypoints within borderPixels of an image edge.
-   */
-  static void runByImageBorder(std::vector<KeyPoint> &keypoints, Size imageSize,
-                               int borderSize);
-  /*
-   * Remove keypoints of sizes out of range.
-   */
-  static void runByKeypointSize(std::vector<KeyPoint> &keypoints, float minSize,
-                                float maxSize = FLT_MAX);
-  /*
-   * Remove keypoints from some image by mask for pixels of this image.
-   */
-  static void runByPixelsMask(std::vector<KeyPoint> &keypoints,
-                              const Mat &mask);
-  /*
-   * Remove objects from some image and a vector of points by mask for pixels of
-   * this image
-   */
-  static void
-  runByPixelsMask2VectorPoint(std::vector<KeyPoint> &keypoints,
-                              std::vector<std::vector<Point>> &removeFrom,
-                              const Mat &mask);
-  /*
-   * Remove duplicated keypoints.
-   */
-  static void removeDuplicated(std::vector<KeyPoint> &keypoints);
-  /*
-   * Remove duplicated keypoints and sort the remaining keypoints
-   */
-  static void removeDuplicatedSorted(std::vector<KeyPoint> &keypoints);
-
-  /*
-   * Retain the specified number of the best keypoints (according to the
-   * response)
-   */
-  static void retainBest(std::vector<KeyPoint> &keypoints, int npoints);
-};
-
-/************************************ Base Classes
- * ************************************/
-
-/** @brief Abstract base class for 2D image feature detectors and descriptor
- * extractors
- */
-#ifdef __EMSCRIPTEN__
-class CV_EXPORTS_W Feature2D : public Algorithm
-#else
-class CV_EXPORTS_W Feature2D : public virtual Algorithm
-#endif
-{
-public:
-  virtual ~Feature2D();
-
-  /** @brief Detects keypoints in an image (first variant) or image set (second
-  variant).
-
-  @param image Image.
-  @param keypoints The detected keypoints. In the second variant of the method
-  keypoints[i] is a set of keypoints detected in images[i] .
-  @param mask Mask specifying where to look for keypoints (optional). It must be
-  a 8-bit integer matrix with non-zero values in the region of interest.
-   */
-  CV_WRAP virtual void detect(InputArray image,
-                              CV_OUT std::vector<KeyPoint> &keypoints,
-                              InputArray mask = noArray());
-
-  /** @overload
-  @param images Image set.
-  @param keypoints The detected keypoints. In the second variant of the method
-  keypoints[i] is a set of keypoints detected in images[i] .
-  @param masks Masks for each input image specifying where to look for keypoints
-  (optional). masks[i] is a mask for images[i].
-  */
-  CV_WRAP virtual void
-  detect(InputArrayOfArrays images,
-         CV_OUT std::vector<std::vector<KeyPoint>> &keypoints,
-         InputArrayOfArrays masks = noArray());
-
-  /** @brief Computes the descriptors for a set of keypoints detected in an
-  image (first variant) or image set (second variant).
-
-  @param image Image.
-  @param keypoints Input collection of keypoints. Keypoints for which a
-  descriptor cannot be computed are removed. Sometimes new keypoints can be
-  added, for example: SIFT duplicates keypoint with several dominant
-  orientations (for each orientation).
-  @param descriptors Computed descriptors. In the second variant of the method
-  descriptors[i] are descriptors computed for a keypoints[i]. Row j is the
-  keypoints (or keypoints[i]) is the descriptor for keypoint j-th keypoint.
-   */
-  CV_WRAP virtual void
-  compute(InputArray image, CV_OUT CV_IN_OUT std::vector<KeyPoint> &keypoints,
-          OutputArray descriptors);
-
-  /** @overload
-
-  @param images Image set.
-  @param keypoints Input collection of keypoints. Keypoints for which a
-  descriptor cannot be computed are removed. Sometimes new keypoints can be
-  added, for example: SIFT duplicates keypoint with several dominant
-  orientations (for each orientation).
-  @param descriptors Computed descriptors. In the second variant of the method
-  descriptors[i] are descriptors computed for a keypoints[i]. Row j is the
-  keypoints (or keypoints[i]) is the descriptor for keypoint j-th keypoint.
-  */
-  CV_WRAP virtual void
-  compute(InputArrayOfArrays images,
-          CV_OUT CV_IN_OUT std::vector<std::vector<KeyPoint>> &keypoints,
-          OutputArrayOfArrays descriptors);
-
-  /** Detects keypoints and computes the descriptors */
-  CV_WRAP virtual void detectAndCompute(InputArray image, InputArray mask,
-                                        CV_OUT std::vector<KeyPoint> &keypoints,
-                                        OutputArray descriptors,
-                                        bool useProvidedKeypoints = false);
-
-  CV_WRAP virtual int descriptorSize() const;
-  CV_WRAP virtual int descriptorType() const;
-  CV_WRAP virtual int defaultNorm() const;
-
-  CV_WRAP void write(const String &fileName) const;
-
-  CV_WRAP void read(const String &fileName);
-
-  virtual void write(FileStorage &) const CV_OVERRIDE;
-
-  // see corresponding cv::Algorithm method
-  CV_WRAP virtual void read(const FileNode &) CV_OVERRIDE;
-
-  //! Return true if detector object is empty
-  CV_WRAP virtual bool empty() const CV_OVERRIDE;
-  CV_WRAP virtual String getDefaultName() const CV_OVERRIDE;
-
-  // see corresponding cv::Algorithm method
-  CV_WRAP inline void write(FileStorage &fs, const String &name) const {
-    Algorithm::write(fs, name);
-  }
-#if CV_VERSION_MAJOR < 5
-  inline void write(const Ptr<FileStorage> &fs, const String &name) const {
-    CV_Assert(fs);
-    Algorithm::write(*fs, name);
-  }
-#endif
-};
-
-/** Feature detectors in OpenCV have wrappers with a common interface that
-enables you to easily switch between different algorithms solving the same
-problem. All objects that implement keypoint detectors inherit the
-FeatureDetector interface. */
-typedef Feature2D FeatureDetector;
-
-/** Extractors of keypoint descriptors in OpenCV have wrappers with a common
-interface that enables you to easily switch between different algorithms solving
-the same problem. This section is devoted to computing descriptors represented
-as vectors in a multidimensional space. All objects that implement the vector
-descriptor extractors inherit the DescriptorExtractor interface.
- */
-typedef Feature2D DescriptorExtractor;
-
-/** @brief Class for implementing the wrapper which makes detectors and
-extractors to be affine invariant, described as ASIFT in @cite YM11 .
-*/
-class CV_EXPORTS_W AffineFeature : public Feature2D {
-public:
-  /**
-  @param backend The detector/extractor you want to use as backend.
-  @param maxTilt The highest power index of tilt factor. 5 is used in the paper
-  as tilt sampling range n.
-  @param minTilt The lowest power index of tilt factor. 0 is used in the paper.
-  @param tiltStep Tilt sampling step \f$\delta_t\f$ in Algorithm 1 in the paper.
-  @param rotateStepBase Rotation sampling step factor b in Algorithm 1 in the
-  paper.
-  */
-  CV_WRAP static Ptr<AffineFeature> create(const Ptr<Feature2D> &backend,
-                                           int maxTilt = 5, int minTilt = 0,
-                                           float tiltStep = 1.4142135623730951f,
-                                           float rotateStepBase = 72);
-
-  CV_WRAP virtual void setViewParams(const std::vector<float> &tilts,
-                                     const std::vector<float> &rolls) = 0;
-  CV_WRAP virtual void getViewParams(std::vector<float> &tilts,
-                                     std::vector<float> &rolls) const = 0;
-  CV_WRAP virtual String getDefaultName() const CV_OVERRIDE;
-};
-
-typedef AffineFeature AffineFeatureDetector;
-typedef AffineFeature AffineDescriptorExtractor;
-
-/** @brief Class for extracting keypoints and computing descriptors using the
-Scale Invariant Feature Transform (SIFT) algorithm by D. Lowe @cite Lowe04 .
-*/
-class CV_EXPORTS_W SIFT : public Feature2D {
-public:
-  /**
-  @param nfeatures The number of best features to retain. The features are
-  ranked by their scores (measured in SIFT algorithm as the local contrast)
-
-  @param nOctaveLayers The number of layers in each octave. 3 is the value used
-  in D. Lowe paper. The number of octaves is computed automatically from the
-  image resolution.
-
-  @param contrastThreshold The contrast threshold used to filter out weak
-  features in semi-uniform (low-contrast) regions. The larger the threshold, the
-  less features are produced by the detector.
-
-  @note The contrast threshold will be divided by nOctaveLayers when the
-  filtering is applied. When nOctaveLayers is set to default and if you want to
-  use the value used in D. Lowe paper, 0.03, set this argument to 0.09.
-
-  @param edgeThreshold The threshold used to filter out edge-like features. Note
-  that the its meaning is different from the contrastThreshold, i.e. the larger
-  the edgeThreshold, the less features are filtered out (more features are
-  retained).
-
-  @param sigma The sigma of the Gaussian applied to the input image at the
-  octave \#0. If your image is captured with a weak camera with soft lenses, you
-  might want to reduce the number.
-
-  @param enable_precise_upscale Whether to enable precise upscaling in the scale
-  pyramid, which maps index \f$\texttt{x}\f$ to \f$\texttt{2x}\f$. This prevents
-  localization bias. The option is disabled by default.
-  */
-  CV_WRAP static Ptr<SIFT> create(int nfeatures = 0, int nOctaveLayers = 3,
-                                  double contrastThreshold = 0.04,
-                                  double edgeThreshold = 10, double sigma = 1.6,
-                                  bool enable_precise_upscale = false);
-
-  /** @brief Create SIFT with specified descriptorType.
-  @param nfeatures The number of best features to retain. The features are
-  ranked by their scores (measured in SIFT algorithm as the local contrast)
-
-  @param nOctaveLayers The number of layers in each octave. 3 is the value used
-  in D. Lowe paper. The number of octaves is computed automatically from the
-  image resolution.
-
-  @param contrastThreshold The contrast threshold used to filter out weak
-  features in semi-uniform (low-contrast) regions. The larger the threshold, the
-  less features are produced by the detector.
-
-  @note The contrast threshold will be divided by nOctaveLayers when the
-  filtering is applied. When nOctaveLayers is set to default and if you want to
-  use the value used in D. Lowe paper, 0.03, set this argument to 0.09.
-
-  @param edgeThreshold The threshold used to filter out edge-like features. Note
-  that the its meaning is different from the contrastThreshold, i.e. the larger
-  the edgeThreshold, the less features are filtered out (more features are
-  retained).
-
-  @param sigma The sigma of the Gaussian applied to the input image at the
-  octave \#0. If your image is captured with a weak camera with soft lenses, you
-  might want to reduce the number.
-
-  @param descriptorType The type of descriptors. Only CV_32F and CV_8U are
-  supported.
-
-  @param enable_precise_upscale Whether to enable precise upscaling in the scale
-  pyramid, which maps index \f$\texttt{x}\f$ to \f$\texttt{2x}\f$. This prevents
-  localization bias. The option is disabled by default.
-  */
-  CV_WRAP static Ptr<SIFT> create(int nfeatures, int nOctaveLayers,
-                                  double contrastThreshold,
-                                  double edgeThreshold, double sigma,
-                                  int descriptorType,
-                                  bool enable_precise_upscale = false);
-
-  CV_WRAP virtual String getDefaultName() const CV_OVERRIDE;
-
-  CV_WRAP virtual void setNFeatures(int maxFeatures) = 0;
-  CV_WRAP virtual int getNFeatures() const = 0;
-
-  CV_WRAP virtual void setNOctaveLayers(int nOctaveLayers) = 0;
-  CV_WRAP virtual int getNOctaveLayers() const = 0;
-
-  CV_WRAP virtual void setContrastThreshold(double contrastThreshold) = 0;
-  CV_WRAP virtual double getContrastThreshold() const = 0;
-
-  CV_WRAP virtual void setEdgeThreshold(double edgeThreshold) = 0;
-  CV_WRAP virtual double getEdgeThreshold() const = 0;
-
-  CV_WRAP virtual void setSigma(double sigma) = 0;
-  CV_WRAP virtual double getSigma() const = 0;
-};
-
-typedef SIFT SiftFeatureDetector;
-typedef SIFT SiftDescriptorExtractor;
-
-/** @brief Class implementing the BRISK keypoint detector and descriptor
- * extractor, described in @cite LCS11 .
- */
-class CV_EXPORTS_W BRISK : public Feature2D {
-public:
-  /** @brief The BRISK constructor
-
-  @param thresh AGAST detection threshold score.
-  @param octaves detection octaves. Use 0 to do single scale.
-  @param patternScale apply this scale to the pattern used for sampling the
-  neighbourhood of a keypoint.
-   */
-  CV_WRAP static Ptr<BRISK> create(int thresh = 30, int octaves = 3,
-                                   float patternScale = 1.0f);
-
-  /** @brief The BRISK constructor for a custom pattern
-
-  @param radiusList defines the radii (in pixels) where the samples around a
-  keypoint are taken (for keypoint scale 1).
-  @param numberList defines the number of sampling points on the sampling
-  circle. Must be the same size as radiusList..
-  @param dMax threshold for the short pairings used for descriptor formation (in
-  pixels for keypoint scale 1).
-  @param dMin threshold for the long pairings used for orientation determination
-  (in pixels for keypoint scale 1).
-  @param indexChange index remapping of the bits. */
-  CV_WRAP static Ptr<BRISK>
-  create(const std::vector<float> &radiusList,
-         const std::vector<int> &numberList, float dMax = 5.85f,
-         float dMin = 8.2f,
-         const std::vector<int> &indexChange = std::vector<int>());
-
-  /** @brief The BRISK constructor for a custom pattern, detection threshold and
-  octaves
-
-  @param thresh AGAST detection threshold score.
-  @param octaves detection octaves. Use 0 to do single scale.
-  @param radiusList defines the radii (in pixels) where the samples around a
-  keypoint are taken (for keypoint scale 1).
-  @param numberList defines the number of sampling points on the sampling
-  circle. Must be the same size as radiusList..
-  @param dMax threshold for the short pairings used for descriptor formation (in
-  pixels for keypoint scale 1).
-  @param dMin threshold for the long pairings used for orientation determination
-  (in pixels for keypoint scale 1).
-  @param indexChange index remapping of the bits. */
-  CV_WRAP static Ptr<BRISK>
-  create(int thresh, int octaves, const std::vector<float> &radiusList,
-         const std::vector<int> &numberList, float dMax = 5.85f,
-         float dMin = 8.2f,
-         const std::vector<int> &indexChange = std::vector<int>());
-  CV_WRAP virtual String getDefaultName() const CV_OVERRIDE;
-
-  /** @brief Set detection threshold.
-  @param threshold AGAST detection threshold score.
-  */
-  CV_WRAP virtual void setThreshold(int threshold) = 0;
-  CV_WRAP virtual int getThreshold() const = 0;
-
-  /** @brief Set detection octaves.
-  @param octaves detection octaves. Use 0 to do single scale.
-  */
-  CV_WRAP virtual void setOctaves(int octaves) = 0;
-  CV_WRAP virtual int getOctaves() const = 0;
-  /** @brief Set detection patternScale.
-  @param patternScale apply this scale to the pattern used for sampling the
-  neighbourhood of a keypoint.
-  */
-  CV_WRAP virtual void setPatternScale(float patternScale) = 0;
-  CV_WRAP virtual float getPatternScale() const = 0;
-};
-
-/** @brief Class implementing the ORB (*oriented BRIEF*) keypoint detector and
-descriptor extractor
-
-described in @cite RRKB11 . The algorithm uses FAST in pyramids to detect stable
-keypoints, selects the strongest features using FAST or Harris response, finds
-their orientation using first-order moments and computes the descriptors using
-BRIEF (where the coordinates of random point pairs (or k-tuples) are rotated
-according to the measured orientation).
- */
-class CV_EXPORTS_W ORB : public Feature2D {
-public:
-  enum ScoreType { HARRIS_SCORE = 0, FAST_SCORE = 1 };
-  static const int kBytes = 32;
-
-  /** @brief The ORB constructor
-
-  @param nfeatures The maximum number of features to retain.
-  @param scaleFactor Pyramid decimation ratio, greater than 1. scaleFactor==2
-  means the classical pyramid, where each next level has 4x less pixels than the
-  previous, but such a big scale factor will degrade feature matching scores
-  dramatically. On the other hand, too close to 1 scale factor will mean that to
-  cover certain scale range you will need more pyramid levels and so the speed
-  will suffer.
-  @param nlevels The number of pyramid levels. The smallest level will have
-  linear size equal to input_image_linear_size/pow(scaleFactor, nlevels -
-  firstLevel).
-  @param edgeThreshold This is size of the border where the features are not
-  detected. It should roughly match the patchSize parameter.
-  @param firstLevel The level of pyramid to put source image to. Previous layers
-  are filled with upscaled source image.
-  @param WTA_K The number of points that produce each element of the oriented
-  BRIEF descriptor. The default value 2 means the BRIEF where we take a random
-  point pair and compare their brightnesses, so we get 0/1 response. Other
-  possible values are 3 and 4. For example, 3 means that we take 3 random points
-  (of course, those point coordinates are random, but they are generated from
-  the pre-defined seed, so each element of BRIEF descriptor is computed
-  deterministically from the pixel rectangle), find point of maximum brightness
-  and output index of the winner (0, 1 or 2). Such output will occupy 2 bits,
-  and therefore it will need a special variant of Hamming distance, denoted as
-  NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to
-  compute each bin (that will also occupy 2 bits with possible values 0, 1, 2 or
-  3).
-  @param scoreType The default HARRIS_SCORE means that Harris algorithm is used
-  to rank features (the score is written to KeyPoint::score and is used to
-  retain best nfeatures features); FAST_SCORE is alternative value of the
-  parameter that produces slightly less stable keypoints, but it is a little
-  faster to compute.
-  @param patchSize size of the patch used by the oriented BRIEF descriptor. Of
-  course, on smaller pyramid layers the perceived image area covered by a
-  feature will be larger.
-  @param fastThreshold the fast threshold
-   */
-  CV_WRAP static Ptr<ORB> create(int nfeatures = 500, float scaleFactor = 1.2f,
-                                 int nlevels = 8, int edgeThreshold = 31,
-                                 int firstLevel = 0, int WTA_K = 2,
-                                 ORB::ScoreType scoreType = ORB::HARRIS_SCORE,
-                                 int patchSize = 31, int fastThreshold = 20);
-
-  CV_WRAP virtual void setMaxFeatures(int maxFeatures) = 0;
-  CV_WRAP virtual int getMaxFeatures() const = 0;
-
-  CV_WRAP virtual void setScaleFactor(double scaleFactor) = 0;
-  CV_WRAP virtual double getScaleFactor() const = 0;
-
-  CV_WRAP virtual void setNLevels(int nlevels) = 0;
-  CV_WRAP virtual int getNLevels() const = 0;
-
-  CV_WRAP virtual void setEdgeThreshold(int edgeThreshold) = 0;
-  CV_WRAP virtual int getEdgeThreshold() const = 0;
-
-  CV_WRAP virtual void setFirstLevel(int firstLevel) = 0;
-  CV_WRAP virtual int getFirstLevel() const = 0;
-
-  CV_WRAP virtual void setWTA_K(int wta_k) = 0;
-  CV_WRAP virtual int getWTA_K() const = 0;
-
-  CV_WRAP virtual void setScoreType(ORB::ScoreType scoreType) = 0;
-  CV_WRAP virtual ORB::ScoreType getScoreType() const = 0;
-
-  CV_WRAP virtual void setPatchSize(int patchSize) = 0;
-  CV_WRAP virtual int getPatchSize() const = 0;
-
-  CV_WRAP virtual void setFastThreshold(int fastThreshold) = 0;
-  CV_WRAP virtual int getFastThreshold() const = 0;
-  CV_WRAP virtual String getDefaultName() const CV_OVERRIDE;
-};
-
-/** @brief Maximally stable extremal region extractor
-
-The class encapsulates all the parameters of the %MSER extraction algorithm (see
-[wiki article](http://en.wikipedia.org/wiki/Maximally_stable_extremal_regions)).
-
-- there are two different implementation of %MSER: one for grey image, one for
-color image
-
-- the grey image algorithm is taken from: @cite nister2008linear ;  the paper
-claims to be faster than union-find method; it actually get 1.5~2m/s on my
-centrino L7200 1.2GHz laptop.
-
-- the color image algorithm is taken from: @cite forssen2007maximally ; it
-should be much slower than grey image method ( 3~4 times )
-
-- (Python) A complete example showing the use of the %MSER detector can be found
-at samples/python/mser.py
-*/
-class CV_EXPORTS_W MSER : public Feature2D {
-public:
-  /** @brief Full constructor for %MSER detector
-
-  @param delta it compares \f$(size_{i}-size_{i-delta})/size_{i-delta}\f$
-  @param min_area prune the area which smaller than minArea
-  @param max_area prune the area which bigger than maxArea
-  @param max_variation prune the area have similar size to its children
-  @param min_diversity for color image, trace back to cut off mser with
-  diversity less than min_diversity
-  @param max_evolution  for color image, the evolution steps
-  @param area_threshold for color image, the area threshold to cause
-  re-initialize
-  @param min_margin for color image, ignore too small margin
-  @param edge_blur_size for color image, the aperture size for edge blur
-   */
-  CV_WRAP static Ptr<MSER>
-  create(int delta = 5, int min_area = 60, int max_area = 14400,
-         double max_variation = 0.25, double min_diversity = .2,
-         int max_evolution = 200, double area_threshold = 1.01,
-         double min_margin = 0.003, int edge_blur_size = 5);
-
-  /** @brief Detect %MSER regions
-
-  @param image input image (8UC1, 8UC3 or 8UC4, must be greater or equal than
-  3x3)
-  @param msers resulting list of point sets
-  @param bboxes resulting bounding boxes
-  */
-  CV_WRAP virtual void
-  detectRegions(InputArray image, CV_OUT std::vector<std::vector<Point>> &msers,
-                CV_OUT std::vector<Rect> &bboxes) = 0;
-
-  CV_WRAP virtual void setDelta(int delta) = 0;
-  CV_WRAP virtual int getDelta() const = 0;
-
-  CV_WRAP virtual void setMinArea(int minArea) = 0;
-  CV_WRAP virtual int getMinArea() const = 0;
-
-  CV_WRAP virtual void setMaxArea(int maxArea) = 0;
-  CV_WRAP virtual int getMaxArea() const = 0;
-
-  CV_WRAP virtual void setMaxVariation(double maxVariation) = 0;
-  CV_WRAP virtual double getMaxVariation() const = 0;
-
-  CV_WRAP virtual void setMinDiversity(double minDiversity) = 0;
-  CV_WRAP virtual double getMinDiversity() const = 0;
-
-  CV_WRAP virtual void setMaxEvolution(int maxEvolution) = 0;
-  CV_WRAP virtual int getMaxEvolution() const = 0;
-
-  CV_WRAP virtual void setAreaThreshold(double areaThreshold) = 0;
-  CV_WRAP virtual double getAreaThreshold() const = 0;
-
-  CV_WRAP virtual void setMinMargin(double min_margin) = 0;
-  CV_WRAP virtual double getMinMargin() const = 0;
-
-  CV_WRAP virtual void setEdgeBlurSize(int edge_blur_size) = 0;
-  CV_WRAP virtual int getEdgeBlurSize() const = 0;
-
-  CV_WRAP virtual void setPass2Only(bool f) = 0;
-  CV_WRAP virtual bool getPass2Only() const = 0;
-
-  CV_WRAP virtual String getDefaultName() const CV_OVERRIDE;
-};
-
-/** @brief Wrapping class for feature detection using the FAST method. :
- */
-class CV_EXPORTS_W FastFeatureDetector : public Feature2D {
-public:
-  enum DetectorType { TYPE_5_8 = 0, TYPE_7_12 = 1, TYPE_9_16 = 2 };
-  enum { THRESHOLD = 10000, NONMAX_SUPPRESSION = 10001, FAST_N = 10002 };
-
-  CV_WRAP static Ptr<FastFeatureDetector> create(
-      int threshold = 10, bool nonmaxSuppression = true,
-      FastFeatureDetector::DetectorType type = FastFeatureDetector::TYPE_9_16);
-
-  CV_WRAP virtual void setThreshold(int threshold) = 0;
-  CV_WRAP virtual int getThreshold() const = 0;
-
-  CV_WRAP virtual void setNonmaxSuppression(bool f) = 0;
-  CV_WRAP virtual bool getNonmaxSuppression() const = 0;
-
-  CV_WRAP virtual void setType(FastFeatureDetector::DetectorType type) = 0;
-  CV_WRAP virtual FastFeatureDetector::DetectorType getType() const = 0;
-  CV_WRAP virtual String getDefaultName() const CV_OVERRIDE;
-};
-
-/** @overload */
-CV_EXPORTS void FAST(InputArray image, CV_OUT std::vector<KeyPoint> &keypoints,
-                     int threshold, bool nonmaxSuppression = true);
-
-/** @brief Detects corners using the FAST algorithm
-
-@param image grayscale image where keypoints (corners) are detected.
-@param keypoints keypoints detected on the image.
-@param threshold threshold on difference between intensity of the central pixel
-and pixels of a circle around this pixel.
-@param nonmaxSuppression if true, non-maximum suppression is applied to detected
-corners (keypoints).
-@param type one of the three neighborhoods as defined in the paper:
-FastFeatureDetector::TYPE_9_16, FastFeatureDetector::TYPE_7_12,
-FastFeatureDetector::TYPE_5_8
-
-Detects corners using the FAST algorithm by @cite Rosten06 .
-
-@note In Python API, types are given as cv.FAST_FEATURE_DETECTOR_TYPE_5_8,
-cv.FAST_FEATURE_DETECTOR_TYPE_7_12 and cv.FAST_FEATURE_DETECTOR_TYPE_9_16. For
-corner detection, use cv.FAST.detect() method.
- */
-CV_EXPORTS void FAST(InputArray image, CV_OUT std::vector<KeyPoint> &keypoints,
-                     int threshold, bool nonmaxSuppression,
-                     FastFeatureDetector::DetectorType type);
-
-/** @brief Wrapping class for feature detection using the AGAST method. :
- */
-class CV_EXPORTS_W AgastFeatureDetector : public Feature2D {
-public:
-  enum DetectorType {
-    AGAST_5_8 = 0,
-    AGAST_7_12d = 1,
-    AGAST_7_12s = 2,
-    OAST_9_16 = 3,
-  };
-
-  enum {
-    THRESHOLD = 10000,
-    NONMAX_SUPPRESSION = 10001,
-  };
-
-  CV_WRAP static Ptr<AgastFeatureDetector>
-  create(int threshold = 10, bool nonmaxSuppression = true,
-         AgastFeatureDetector::DetectorType type =
-             AgastFeatureDetector::OAST_9_16);
-
-  CV_WRAP virtual void setThreshold(int threshold) = 0;
-  CV_WRAP virtual int getThreshold() const = 0;
-
-  CV_WRAP virtual void setNonmaxSuppression(bool f) = 0;
-  CV_WRAP virtual bool getNonmaxSuppression() const = 0;
-
-  CV_WRAP virtual void setType(AgastFeatureDetector::DetectorType type) = 0;
-  CV_WRAP virtual AgastFeatureDetector::DetectorType getType() const = 0;
-  CV_WRAP virtual String getDefaultName() const CV_OVERRIDE;
-};
-
-/** @overload */
-CV_EXPORTS void AGAST(InputArray image, CV_OUT std::vector<KeyPoint> &keypoints,
-                      int threshold, bool nonmaxSuppression = true);
-
-/** @brief Detects corners using the AGAST algorithm
-
-@param image grayscale image where keypoints (corners) are detected.
-@param keypoints keypoints detected on the image.
-@param threshold threshold on difference between intensity of the central pixel
-and pixels of a circle around this pixel.
-@param nonmaxSuppression if true, non-maximum suppression is applied to detected
-corners (keypoints).
-@param type one of the four neighborhoods as defined in the paper:
-AgastFeatureDetector::AGAST_5_8, AgastFeatureDetector::AGAST_7_12d,
-AgastFeatureDetector::AGAST_7_12s, AgastFeatureDetector::OAST_9_16
-
-For non-Intel platforms, there is a tree optimised variant of AGAST with same
-numerical results. The 32-bit binary tree tables were generated automatically
-from original code using perl script. The perl script and examples of tree
-generation are placed in features2d/doc folder. Detects corners using the AGAST
-algorithm by @cite mair2010_agast .
-
- */
-CV_EXPORTS void AGAST(InputArray image, CV_OUT std::vector<KeyPoint> &keypoints,
-                      int threshold, bool nonmaxSuppression,
-                      AgastFeatureDetector::DetectorType type);
-
-/** @brief Wrapping class for feature detection using the goodFeaturesToTrack
- * function. :
- */
-class CV_EXPORTS_W GFTTDetector : public Feature2D {
-public:
-  CV_WRAP static Ptr<GFTTDetector>
-  create(int maxCorners = 1000, double qualityLevel = 0.01,
-         double minDistance = 1, int blockSize = 3,
-         bool useHarrisDetector = false, double k = 0.04);
-  CV_WRAP static Ptr<GFTTDetector>
-  create(int maxCorners, double qualityLevel, double minDistance, int blockSize,
-         int gradiantSize, bool useHarrisDetector = false, double k = 0.04);
-  CV_WRAP virtual void setMaxFeatures(int maxFeatures) = 0;
-  CV_WRAP virtual int getMaxFeatures() const = 0;
-
-  CV_WRAP virtual void setQualityLevel(double qlevel) = 0;
-  CV_WRAP virtual double getQualityLevel() const = 0;
-
-  CV_WRAP virtual void setMinDistance(double minDistance) = 0;
-  CV_WRAP virtual double getMinDistance() const = 0;
-
-  CV_WRAP virtual void setBlockSize(int blockSize) = 0;
-  CV_WRAP virtual int getBlockSize() const = 0;
-
-  CV_WRAP virtual void setGradientSize(int gradientSize_) = 0;
-  CV_WRAP virtual int getGradientSize() = 0;
-
-  CV_WRAP virtual void setHarrisDetector(bool val) = 0;
-  CV_WRAP virtual bool getHarrisDetector() const = 0;
-
-  CV_WRAP virtual void setK(double k) = 0;
-  CV_WRAP virtual double getK() const = 0;
-  CV_WRAP virtual String getDefaultName() const CV_OVERRIDE;
-};
-
-/** @brief Class for extracting blobs from an image. :
-
-The class implements a simple algorithm for extracting blobs from an image:
-
-1.  Convert the source image to binary images by applying thresholding with
-several thresholds from minThreshold (inclusive) to maxThreshold (exclusive)
-with distance thresholdStep between neighboring thresholds.
-2.  Extract connected components from every binary image by findContours and
-calculate their centers.
-3.  Group centers from several binary images by their coordinates. Close centers
-form one group that corresponds to one blob, which is controlled by the
-minDistBetweenBlobs parameter.
-4.  From the groups, estimate final centers of blobs and their radiuses and
-return as locations and sizes of keypoints.
-
-This class performs several filtrations of returned blobs. You should set
-filterBy\* to true/false to turn on/off corresponding filtration. Available
-filtrations:
-
--   **By color**. This filter compares the intensity of a binary image at the
-center of a blob to blobColor. If they differ, the blob is filtered out. Use
-blobColor = 0 to extract dark blobs and blobColor = 255 to extract light blobs.
--   **By area**. Extracted blobs have an area between minArea (inclusive) and
-maxArea (exclusive).
--   **By circularity**. Extracted blobs have circularity
-(\f$\frac{4*\pi*Area}{perimeter * perimeter}\f$) between minCircularity
-(inclusive) and maxCircularity (exclusive).
--   **By ratio of the minimum inertia to maximum inertia**. Extracted blobs have
-this ratio between minInertiaRatio (inclusive) and maxInertiaRatio (exclusive).
--   **By convexity**. Extracted blobs have convexity (area / area of blob convex
-hull) between minConvexity (inclusive) and maxConvexity (exclusive).
-
-Default values of parameters are tuned to extract dark circular blobs.
- */
-class CV_EXPORTS_W SimpleBlobDetector : public Feature2D {
-public:
-  struct CV_EXPORTS_W_SIMPLE Params {
-    CV_WRAP Params();
-    CV_PROP_RW float thresholdStep;
-    CV_PROP_RW float minThreshold;
-    CV_PROP_RW float maxThreshold;
-    CV_PROP_RW size_t minRepeatability;
-    CV_PROP_RW float minDistBetweenBlobs;
-
-    CV_PROP_RW bool filterByColor;
-    CV_PROP_RW uchar blobColor;
-
-    CV_PROP_RW bool filterByArea;
-    CV_PROP_RW float minArea, maxArea;
-
-    CV_PROP_RW bool filterByCircularity;
-    CV_PROP_RW float minCircularity, maxCircularity;
-
-    CV_PROP_RW bool filterByInertia;
-    CV_PROP_RW float minInertiaRatio, maxInertiaRatio;
-
-    CV_PROP_RW bool filterByConvexity;
-    CV_PROP_RW float minConvexity, maxConvexity;
-
-    CV_PROP_RW bool collectContours;
-
-    void read(const FileNode &fn);
-    void write(FileStorage &fs) const;
-  };
-
-  CV_WRAP static Ptr<SimpleBlobDetector>
-  create(const SimpleBlobDetector::Params &parameters =
-             SimpleBlobDetector::Params());
-
-  CV_WRAP virtual void setParams(const SimpleBlobDetector::Params &params) = 0;
-  CV_WRAP virtual SimpleBlobDetector::Params getParams() const = 0;
-
-  CV_WRAP virtual String getDefaultName() const CV_OVERRIDE;
-  CV_WRAP virtual const std::vector<std::vector<cv::Point>> &
-  getBlobContours() const;
-};
-
-/** @brief Class implementing the KAZE keypoint detector and descriptor
-extractor, described in @cite ABD12 .
-
-@note AKAZE descriptor can only be used with KAZE or AKAZE keypoints .. [ABD12]
-KAZE Features. Pablo F. Alcantarilla, Adrien Bartoli and Andrew J. Davison. In
-European Conference on Computer Vision (ECCV), Fiorenze, Italy, October 2012.
-*/
-class CV_EXPORTS_W KAZE : public Feature2D {
-public:
-  enum DiffusivityType {
-    DIFF_PM_G1 = 0,
-    DIFF_PM_G2 = 1,
-    DIFF_WEICKERT = 2,
-    DIFF_CHARBONNIER = 3
-  };
-
-  /** @brief The KAZE constructor
-
-  @param extended Set to enable extraction of extended (128-byte) descriptor.
-  @param upright Set to enable use of upright descriptors (non
-  rotation-invariant).
-  @param threshold Detector response threshold to accept point
-  @param nOctaves Maximum octave evolution of the image
-  @param nOctaveLayers Default number of sublevels per scale level
-  @param diffusivity Diffusivity type. DIFF_PM_G1, DIFF_PM_G2, DIFF_WEICKERT or
-  DIFF_CHARBONNIER
-   */
-  CV_WRAP static Ptr<KAZE>
-  create(bool extended = false, bool upright = false, float threshold = 0.001f,
-         int nOctaves = 4, int nOctaveLayers = 4,
-         KAZE::DiffusivityType diffusivity = KAZE::DIFF_PM_G2);
-
-  CV_WRAP virtual void setExtended(bool extended) = 0;
-  CV_WRAP virtual bool getExtended() const = 0;
-
-  CV_WRAP virtual void setUpright(bool upright) = 0;
-  CV_WRAP virtual bool getUpright() const = 0;
-
-  CV_WRAP virtual void setThreshold(double threshold) = 0;
-  CV_WRAP virtual double getThreshold() const = 0;
-
-  CV_WRAP virtual void setNOctaves(int octaves) = 0;
-  CV_WRAP virtual int getNOctaves() const = 0;
-
-  CV_WRAP virtual void setNOctaveLayers(int octaveLayers) = 0;
-  CV_WRAP virtual int getNOctaveLayers() const = 0;
-
-  CV_WRAP virtual void setDiffusivity(KAZE::DiffusivityType diff) = 0;
-  CV_WRAP virtual KAZE::DiffusivityType getDiffusivity() const = 0;
-  CV_WRAP virtual String getDefaultName() const CV_OVERRIDE;
-};
-
-/** @brief Class implementing the AKAZE keypoint detector and descriptor
-extractor, described in @cite ANB13.
-
-@details AKAZE descriptors can only be used with KAZE or AKAZE keypoints. This
-class is thread-safe.
-
-@note When you need descriptors use Feature2D::detectAndCompute, which
-provides better performance. When using Feature2D::detect followed by
-Feature2D::compute scale space pyramid is computed twice.
-
-@note AKAZE implements T-API. When image is passed as UMat some parts of the
-algorithm will use OpenCL.
-
-@note [ANB13] Fast Explicit Diffusion for Accelerated Features in Nonlinear
-Scale Spaces. Pablo F. Alcantarilla, Jesús Nuevo and Adrien Bartoli. In
-British Machine Vision Conference (BMVC), Bristol, UK, September 2013.
-
-*/
-class CV_EXPORTS_W AKAZE : public Feature2D {
-public:
-  // AKAZE descriptor type
-  enum DescriptorType {
-    DESCRIPTOR_KAZE_UPRIGHT =
-        2, ///< Upright descriptors, not invariant to rotation
-    DESCRIPTOR_KAZE = 3,
-    DESCRIPTOR_MLDB_UPRIGHT =
-        4, ///< Upright descriptors, not invariant to rotation
-    DESCRIPTOR_MLDB = 5
-  };
-
-  /** @brief The AKAZE constructor
-
-  @param descriptor_type Type of the extracted descriptor: DESCRIPTOR_KAZE,
-  DESCRIPTOR_KAZE_UPRIGHT, DESCRIPTOR_MLDB or DESCRIPTOR_MLDB_UPRIGHT.
-  @param descriptor_size Size of the descriptor in bits. 0 -\> Full size
-  @param descriptor_channels Number of channels in the descriptor (1, 2, 3)
-  @param threshold Detector response threshold to accept point
-  @param nOctaves Maximum octave evolution of the image
-  @param nOctaveLayers Default number of sublevels per scale level
-  @param diffusivity Diffusivity type. DIFF_PM_G1, DIFF_PM_G2, DIFF_WEICKERT or
-  DIFF_CHARBONNIER
-  @param max_points Maximum amount of returned points. In case if image contains
-  more features, then the features with highest response are returned.
-  Negative value means no limitation.
-   */
-  CV_WRAP static Ptr<AKAZE>
-  create(AKAZE::DescriptorType descriptor_type = AKAZE::DESCRIPTOR_MLDB,
-         int descriptor_size = 0, int descriptor_channels = 3,
-         float threshold = 0.001f, int nOctaves = 4, int nOctaveLayers = 4,
-         KAZE::DiffusivityType diffusivity = KAZE::DIFF_PM_G2,
-         int max_points = -1);
-
-  CV_WRAP virtual void setDescriptorType(AKAZE::DescriptorType dtype) = 0;
-  CV_WRAP virtual AKAZE::DescriptorType getDescriptorType() const = 0;
-
-  CV_WRAP virtual void setDescriptorSize(int dsize) = 0;
-  CV_WRAP virtual int getDescriptorSize() const = 0;
-
-  CV_WRAP virtual void setDescriptorChannels(int dch) = 0;
-  CV_WRAP virtual int getDescriptorChannels() const = 0;
-
-  CV_WRAP virtual void setThreshold(double threshold) = 0;
-  CV_WRAP virtual double getThreshold() const = 0;
-
-  CV_WRAP virtual void setNOctaves(int octaves) = 0;
-  CV_WRAP virtual int getNOctaves() const = 0;
-
-  CV_WRAP virtual void setNOctaveLayers(int octaveLayers) = 0;
-  CV_WRAP virtual int getNOctaveLayers() const = 0;
-
-  CV_WRAP virtual void setDiffusivity(KAZE::DiffusivityType diff) = 0;
-  CV_WRAP virtual KAZE::DiffusivityType getDiffusivity() const = 0;
-  CV_WRAP virtual String getDefaultName() const CV_OVERRIDE;
-
-  CV_WRAP virtual void setMaxPoints(int max_points) = 0;
-  CV_WRAP virtual int getMaxPoints() const = 0;
-};
-
-/****************************************************************************************\
-*                                      Distance *
-\****************************************************************************************/
-
-template <typename T> struct CV_EXPORTS Accumulator {
-  typedef T Type;
-};
-
-template <> struct Accumulator<unsigned char> {
-  typedef float Type;
-};
-template <> struct Accumulator<unsigned short> {
-  typedef float Type;
-};
-template <> struct Accumulator<char> {
-  typedef float Type;
-};
-template <> struct Accumulator<short> {
-  typedef float Type;
-};
-
-/*
- * Squared Euclidean distance functor
- */
-template <class T> struct CV_EXPORTS SL2 {
-  static const NormTypes normType = NORM_L2SQR;
-  typedef T ValueType;
-  typedef typename Accumulator<T>::Type ResultType;
-
-  ResultType operator()(const T *a, const T *b, int size) const {
-    return normL2Sqr<ValueType, ResultType>(a, b, size);
-  }
-};
-
-/*
- * Euclidean distance functor
- */
-template <class T> struct L2 {
-  static const NormTypes normType = NORM_L2;
-  typedef T ValueType;
-  typedef typename Accumulator<T>::Type ResultType;
-
-  ResultType operator()(const T *a, const T *b, int size) const {
-    return (ResultType)std::sqrt(
-        (double)normL2Sqr<ValueType, ResultType>(a, b, size));
-  }
-};
-
-/*
- * Manhattan distance (city block distance) functor
- */
-template <class T> struct L1 {
-  static const NormTypes normType = NORM_L1;
-  typedef T ValueType;
-  typedef typename Accumulator<T>::Type ResultType;
-
-  ResultType operator()(const T *a, const T *b, int size) const {
-    return normL1<ValueType, ResultType>(a, b, size);
-  }
-};
-
-//! @} features2d_main
-
-/****************************************************************************************\
-*                                  DescriptorMatcher *
-\****************************************************************************************/
-
-//! @addtogroup features2d_match
-//! @{
-
-/** @brief Abstract base class for matching keypoint descriptors.
-
-It has two groups of match methods: for matching descriptors of an image with
-another image or with an image set.
- */
-class CV_EXPORTS_W DescriptorMatcher : public Algorithm {
-public:
-  enum MatcherType {
-    FLANNBASED = 1,
-    BRUTEFORCE = 2,
-    BRUTEFORCE_L1 = 3,
-    BRUTEFORCE_HAMMING = 4,
-    BRUTEFORCE_HAMMINGLUT = 5,
-    BRUTEFORCE_SL2 = 6
-  };
-
-  virtual ~DescriptorMatcher();
-
-  /** @brief Adds descriptors to train a CPU(trainDescCollectionis) or
-  GPU(utrainDescCollectionis) descriptor collection.
-
-  If the collection is not empty, the new descriptors are added to existing
-  train descriptors.
-
-  @param descriptors Descriptors to add. Each descriptors[i] is a set of
-  descriptors from the same train image.
-   */
-  CV_WRAP virtual void add(InputArrayOfArrays descriptors);
-
-  /** @brief Returns a constant link to the train descriptor collection
-   * trainDescCollection .
-   */
-  CV_WRAP const std::vector<Mat> &getTrainDescriptors() const;
-
-  /** @brief Clears the train descriptor collections.
-   */
-  CV_WRAP virtual void clear() CV_OVERRIDE;
-
-  /** @brief Returns true if there are no train descriptors in the both
-   * collections.
-   */
-  CV_WRAP virtual bool empty() const CV_OVERRIDE;
-
-  /** @brief Returns true if the descriptor matcher supports masking permissible
-   * matches.
-   */
-  CV_WRAP virtual bool isMaskSupported() const = 0;
-
-  /** @brief Trains a descriptor matcher
-
-  Trains a descriptor matcher (for example, the flann index). In all methods to
-  match, the method train() is run every time before matching. Some descriptor
-  matchers (for example, BruteForceMatcher) have an empty implementation of this
-  method. Other matchers really train their inner structures (for example,
-  FlannBasedMatcher trains flann::Index ).
-   */
-  CV_WRAP virtual void train();
-
-  /** @brief Finds the best match for each descriptor from a query set.
-
-  @param queryDescriptors Query set of descriptors.
-  @param trainDescriptors Train set of descriptors. This set is not added to the
-  train descriptors collection stored in the class object.
-  @param matches Matches. If a query descriptor is masked out in mask , no match
-  is added for this descriptor. So, matches size may be smaller than the query
-  descriptors count.
-  @param mask Mask specifying permissible matches between an input query and
-  train matrices of descriptors.
-
-  In the first variant of this method, the train descriptors are passed as an
-  input argument. In the second variant of the method, train descriptors
-  collection that was set by DescriptorMatcher::add is used. Optional mask (or
-  masks) can be passed to specify which query and training descriptors can be
-  matched. Namely, queryDescriptors[i] can be matched with trainDescriptors[j]
-  only if mask.at\<uchar\>(i,j) is non-zero.
-   */
-  CV_WRAP void match(InputArray queryDescriptors, InputArray trainDescriptors,
-                     CV_OUT std::vector<DMatch> &matches,
-                     InputArray mask = noArray()) const;
-
-  /** @brief Finds the k best matches for each descriptor from a query set.
-
-  @param queryDescriptors Query set of descriptors.
-  @param trainDescriptors Train set of descriptors. This set is not added to the
-  train descriptors collection stored in the class object.
-  @param mask Mask specifying permissible matches between an input query and
-  train matrices of descriptors.
-  @param matches Matches. Each matches[i] is k or less matches for the same
-  query descriptor.
-  @param k Count of best matches found per each query descriptor or less if a
-  query descriptor has less than k possible matches in total.
-  @param compactResult Parameter used when the mask (or masks) is not empty. If
-  compactResult is false, the matches vector has the same size as
-  queryDescriptors rows. If compactResult is true, the matches vector does not
-  contain matches for fully masked-out query descriptors.
-
-  These extended variants of DescriptorMatcher::match methods find several best
-  matches for each query descriptor. The matches are returned in the distance
-  increasing order. See DescriptorMatcher::match for the details about query and
-  train descriptors.
-   */
-  CV_WRAP void knnMatch(InputArray queryDescriptors,
-                        InputArray trainDescriptors,
-                        CV_OUT std::vector<std::vector<DMatch>> &matches, int k,
-                        InputArray mask = noArray(),
-                        bool compactResult = false) const;
-
-  /** @brief For each query descriptor, finds the training descriptors not
-  farther than the specified distance.
-
-  @param queryDescriptors Query set of descriptors.
-  @param trainDescriptors Train set of descriptors. This set is not added to the
-  train descriptors collection stored in the class object.
-  @param matches Found matches.
-  @param compactResult Parameter used when the mask (or masks) is not empty. If
-  compactResult is false, the matches vector has the same size as
-  queryDescriptors rows. If compactResult is true, the matches vector does not
-  contain matches for fully masked-out query descriptors.
-  @param maxDistance Threshold for the distance between matched descriptors.
-  Distance means here metric distance (e.g. Hamming distance), not the distance
-  between coordinates (which is measured in Pixels)!
-  @param mask Mask specifying permissible matches between an input query and
-  train matrices of descriptors.
-
-  For each query descriptor, the methods find such training descriptors that the
-  distance between the query descriptor and the training descriptor is equal or
-  smaller than maxDistance. Found matches are returned in the distance
-  increasing order.
-   */
-  CV_WRAP void radiusMatch(InputArray queryDescriptors,
-                           InputArray trainDescriptors,
-                           CV_OUT std::vector<std::vector<DMatch>> &matches,
-                           float maxDistance, InputArray mask = noArray(),
-                           bool compactResult = false) const;
-
-  /** @overload
-  @param queryDescriptors Query set of descriptors.
-  @param matches Matches. If a query descriptor is masked out in mask , no match
-  is added for this descriptor. So, matches size may be smaller than the query
-  descriptors count.
-  @param masks Set of masks. Each masks[i] specifies permissible matches between
-  the input query descriptors and stored train descriptors from the i-th image
-  trainDescCollection[i].
-  */
-  CV_WRAP void match(InputArray queryDescriptors,
-                     CV_OUT std::vector<DMatch> &matches,
-                     InputArrayOfArrays masks = noArray());
-  /** @overload
-  @param queryDescriptors Query set of descriptors.
-  @param matches Matches. Each matches[i] is k or less matches for the same
-  query descriptor.
-  @param k Count of best matches found per each query descriptor or less if a
-  query descriptor has less than k possible matches in total.
-  @param masks Set of masks. Each masks[i] specifies permissible matches between
-  the input query descriptors and stored train descriptors from the i-th image
-  trainDescCollection[i].
-  @param compactResult Parameter used when the mask (or masks) is not empty. If
-  compactResult is false, the matches vector has the same size as
-  queryDescriptors rows. If compactResult is true, the matches vector does not
-  contain matches for fully masked-out query descriptors.
-  */
-  CV_WRAP void knnMatch(InputArray queryDescriptors,
-                        CV_OUT std::vector<std::vector<DMatch>> &matches, int k,
-                        InputArrayOfArrays masks = noArray(),
-                        bool compactResult = false);
-  /** @overload
-  @param queryDescriptors Query set of descriptors.
-  @param matches Found matches.
-  @param maxDistance Threshold for the distance between matched descriptors.
-  Distance means here metric distance (e.g. Hamming distance), not the distance
-  between coordinates (which is measured in Pixels)!
-  @param masks Set of masks. Each masks[i] specifies permissible matches between
-  the input query descriptors and stored train descriptors from the i-th image
-  trainDescCollection[i].
-  @param compactResult Parameter used when the mask (or masks) is not empty. If
-  compactResult is false, the matches vector has the same size as
-  queryDescriptors rows. If compactResult is true, the matches vector does not
-  contain matches for fully masked-out query descriptors.
-  */
-  CV_WRAP void radiusMatch(InputArray queryDescriptors,
-                           CV_OUT std::vector<std::vector<DMatch>> &matches,
-                           float maxDistance,
-                           InputArrayOfArrays masks = noArray(),
-                           bool compactResult = false);
-
-  CV_WRAP void write(const String &fileName) const {
-    FileStorage fs(fileName, FileStorage::WRITE);
-    write(fs);
-  }
-
-  CV_WRAP void read(const String &fileName) {
-    FileStorage fs(fileName, FileStorage::READ);
-    read(fs.root());
-  }
-  // Reads matcher object from a file node
-  // see corresponding cv::Algorithm method
-  CV_WRAP virtual void read(const FileNode &) CV_OVERRIDE;
-  // Writes matcher object to a file storage
-  virtual void write(FileStorage &) const CV_OVERRIDE;
-
-  /** @brief Clones the matcher.
-
-  @param emptyTrainData If emptyTrainData is false, the method creates a deep
-  copy of the object, that is, copies both parameters and train data. If
-  emptyTrainData is true, the method creates an object copy with the current
-  parameters but with empty train data.
-   */
-  CV_WRAP CV_NODISCARD_STD virtual Ptr<DescriptorMatcher>
-  clone(bool emptyTrainData = false) const = 0;
-
-  /** @brief Creates a descriptor matcher of a given type with the default
-  parameters (using default constructor).
-
-  @param descriptorMatcherType Descriptor matcher type. Now the following
-  matcher types are supported:
-  -   `BruteForce` (it uses L2 )
-  -   `BruteForce-L1`
-  -   `BruteForce-Hamming`
-  -   `BruteForce-Hamming(2)`
-  -   `FlannBased`
-   */
-  CV_WRAP static Ptr<DescriptorMatcher>
-  create(const String &descriptorMatcherType);
-
-  CV_WRAP static Ptr<DescriptorMatcher>
-  create(const DescriptorMatcher::MatcherType &matcherType);
-
-  // see corresponding cv::Algorithm method
-  CV_WRAP inline void write(FileStorage &fs, const String &name) const {
-    Algorithm::write(fs, name);
-  }
-#if CV_VERSION_MAJOR < 5
-  inline void write(const Ptr<FileStorage> &fs, const String &name) const {
-    CV_Assert(fs);
-    Algorithm::write(*fs, name);
-  }
-#endif
-
-protected:
-  /**
-   * Class to work with descriptors from several images as with one merged
-   * matrix. It is used e.g. in FlannBasedMatcher.
-   */
-  class CV_EXPORTS DescriptorCollection {
-  public:
-    DescriptorCollection();
-    DescriptorCollection(const DescriptorCollection &collection);
-    virtual ~DescriptorCollection();
-
-    // Vector of matrices "descriptors" will be merged to one matrix
-    // "mergedDescriptors" here.
-    void set(const std::vector<Mat> &descriptors);
-    virtual void clear();
-
-    const Mat &getDescriptors() const;
-    Mat getDescriptor(int imgIdx, int localDescIdx) const;
-    Mat getDescriptor(int globalDescIdx) const;
-    void getLocalIdx(int globalDescIdx, int &imgIdx, int &localDescIdx) const;
-
-    int size() const;
-
-  protected:
-    Mat mergedDescriptors;
-    std::vector<int> startIdxs;
-  };
-
-  //! In fact the matching is implemented only by the following two methods.
-  //! These methods suppose that the class object has been trained already.
-  //! Public match methods call these methods after calling train().
-  virtual void knnMatchImpl(InputArray queryDescriptors,
-                            std::vector<std::vector<DMatch>> &matches, int k,
-                            InputArrayOfArrays masks = noArray(),
-                            bool compactResult = false) = 0;
-  virtual void radiusMatchImpl(InputArray queryDescriptors,
-                               std::vector<std::vector<DMatch>> &matches,
-                               float maxDistance,
-                               InputArrayOfArrays masks = noArray(),
-                               bool compactResult = false) = 0;
-
-  static bool isPossibleMatch(InputArray mask, int queryIdx, int trainIdx);
-  static bool isMaskedOut(InputArrayOfArrays masks, int queryIdx);
-
-  CV_NODISCARD_STD static Mat clone_op(Mat m) { return m.clone(); }
-  void checkMasks(InputArrayOfArrays masks, int queryDescriptorsCount) const;
-
-  //! Collection of descriptors from train images.
-  std::vector<Mat> trainDescCollection;
-};
-
-/** @brief Brute-force descriptor matcher.
-
-For each descriptor in the first set, this matcher finds the closest descriptor
-in the second set by trying each one. This descriptor matcher supports masking
-permissible matches of descriptor sets.
- */
-class CV_EXPORTS_W BFMatcher : public DescriptorMatcher {
-public:
-  /** @brief Brute-force matcher constructor (obsolete). Please use
-   * BFMatcher.create()
-   *
-   *
-   */
-  CV_WRAP BFMatcher(int normType = NORM_L2, bool crossCheck = false);
-
-  virtual ~BFMatcher() {}
-
-  virtual bool isMaskSupported() const CV_OVERRIDE { return true; }
-
-  /** @brief Brute-force matcher create method.
-  @param normType One of NORM_L1, NORM_L2, NORM_HAMMING, NORM_HAMMING2. L1 and
-  L2 norms are preferable choices for SIFT and SURF descriptors, NORM_HAMMING
-  should be used with ORB, BRISK and BRIEF, NORM_HAMMING2 should be used with
-  ORB when WTA_K==3 or 4 (see ORB::ORB constructor description).
-  @param crossCheck If it is false, this is will be default BFMatcher behaviour
-  when it finds the k nearest neighbors for each query descriptor. If
-  crossCheck==true, then the knnMatch() method with k=1 will only return pairs
-  (i,j) such that for i-th query descriptor the j-th descriptor in the matcher's
-  collection is the nearest and vice versa, i.e. the BFMatcher will only return
-  consistent pairs. Such technique usually produces best results with minimal
-  number of outliers when there are enough matches. This is alternative to the
-  ratio test, used by D. Lowe in SIFT paper.
-   */
-  CV_WRAP static Ptr<BFMatcher> create(int normType = NORM_L2,
-                                       bool crossCheck = false);
-
-  CV_NODISCARD_STD virtual Ptr<DescriptorMatcher>
-  clone(bool emptyTrainData = false) const CV_OVERRIDE;
-
-protected:
-  virtual void knnMatchImpl(InputArray queryDescriptors,
-                            std::vector<std::vector<DMatch>> &matches, int k,
-                            InputArrayOfArrays masks = noArray(),
-                            bool compactResult = false) CV_OVERRIDE;
-  virtual void radiusMatchImpl(InputArray queryDescriptors,
-                               std::vector<std::vector<DMatch>> &matches,
-                               float maxDistance,
-                               InputArrayOfArrays masks = noArray(),
-                               bool compactResult = false) CV_OVERRIDE;
-
-  int normType;
-  bool crossCheck;
-};
-
-#if defined(HAVE_OPENCV_FLANN) || defined(CV_DOXYGEN)
-
-/** @brief Flann-based descriptor matcher.
-
-This matcher trains cv::flann::Index on a train descriptor collection and calls
-its nearest search methods to find the best matches. So, this matcher may be
-faster when matching a large train collection than the brute force matcher.
-FlannBasedMatcher does not support masking permissible matches of descriptor
-sets because flann::Index does not support this. :
- */
-class CV_EXPORTS_W FlannBasedMatcher : public DescriptorMatcher {
-public:
-  CV_WRAP FlannBasedMatcher(const Ptr<flann::IndexParams> &indexParams =
-                                makePtr<flann::KDTreeIndexParams>(),
-                            const Ptr<flann::SearchParams> &searchParams =
-                                makePtr<flann::SearchParams>());
-
-  virtual void add(InputArrayOfArrays descriptors) CV_OVERRIDE;
-  virtual void clear() CV_OVERRIDE;
-
-  // Reads matcher object from a file node
-  virtual void read(const FileNode &) CV_OVERRIDE;
-  // Writes matcher object to a file storage
-  virtual void write(FileStorage &) const CV_OVERRIDE;
-
-  virtual void train() CV_OVERRIDE;
-  virtual bool isMaskSupported() const CV_OVERRIDE;
-
-  CV_WRAP static Ptr<FlannBasedMatcher> create();
-
-  CV_NODISCARD_STD virtual Ptr<DescriptorMatcher>
-  clone(bool emptyTrainData = false) const CV_OVERRIDE;
-
-protected:
-  static void convertToDMatches(const DescriptorCollection &descriptors,
-                                const Mat &indices, const Mat &distances,
-                                std::vector<std::vector<DMatch>> &matches);
-
-  virtual void knnMatchImpl(InputArray queryDescriptors,
-                            std::vector<std::vector<DMatch>> &matches, int k,
-                            InputArrayOfArrays masks = noArray(),
-                            bool compactResult = false) CV_OVERRIDE;
-  virtual void radiusMatchImpl(InputArray queryDescriptors,
-                               std::vector<std::vector<DMatch>> &matches,
-                               float maxDistance,
-                               InputArrayOfArrays masks = noArray(),
-                               bool compactResult = false) CV_OVERRIDE;
-
-  Ptr<flann::IndexParams> indexParams;
-  Ptr<flann::SearchParams> searchParams;
-  Ptr<flann::Index> flannIndex;
-
-  DescriptorCollection mergedDescriptors;
-  int addedDescCount;
-};
-
-#endif
-
-//! @} features2d_match
-
-/****************************************************************************************\
-*                                   Drawing functions *
-\****************************************************************************************/
-
-//! @addtogroup features2d_draw
-//! @{
-
-enum struct DrawMatchesFlags {
-  DEFAULT =
-      0, //!< Output image matrix will be created (Mat::create),
-         //!< i.e. existing memory of output image may be reused.
-         //!< Two source image, matches and single keypoints will be drawn.
-         //!< For each keypoint only the center point will be drawn (without
-         //!< the circle around keypoint with keypoint size and orientation).
-  DRAW_OVER_OUTIMG =
-      1, //!< Output image matrix will not be created (Mat::create).
-         //!< Matches will be drawn on existing content of output image.
-  NOT_DRAW_SINGLE_POINTS = 2, //!< Single keypoints will not be drawn.
-  DRAW_RICH_KEYPOINTS = 4 //!< For each keypoint the circle around keypoint with
-                          //!< keypoint size and orientation will be drawn.
-};
-CV_ENUM_FLAGS(DrawMatchesFlags)
-
-/** @brief Draws keypoints.
-
-@param image Source image.
-@param keypoints Keypoints from the source image.
-@param outImage Output image. Its content depends on the flags value defining
-what is drawn in the output image. See possible flags bit values below.
-@param color Color of keypoints.
-@param flags Flags setting drawing features. Possible flags bit values are
-defined by DrawMatchesFlags. See details above in drawMatches .
-
-@note
-For Python API, flags are modified as cv.DRAW_MATCHES_FLAGS_DEFAULT,
-cv.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS,
-cv.DRAW_MATCHES_FLAGS_DRAW_OVER_OUTIMG,
-cv.DRAW_MATCHES_FLAGS_NOT_DRAW_SINGLE_POINTS
- */
-CV_EXPORTS_W void
-drawKeypoints(InputArray image, const std::vector<KeyPoint> &keypoints,
-              InputOutputArray outImage, const Scalar &color = Scalar::all(-1),
-              DrawMatchesFlags flags = DrawMatchesFlags::DEFAULT);
-
-/** @brief Draws the found matches of keypoints from two images.
-
-@param img1 First source image.
-@param keypoints1 Keypoints from the first source image.
-@param img2 Second source image.
-@param keypoints2 Keypoints from the second source image.
-@param matches1to2 Matches from the first image to the second one, which means
-that keypoints1[i] has a corresponding point in keypoints2[matches[i]] .
-@param outImg Output image. Its content depends on the flags value defining what
-is drawn in the output image. See possible flags bit values below.
-@param matchColor Color of matches (lines and connected keypoints). If
-matchColor==Scalar::all(-1) , the color is generated randomly.
-@param singlePointColor Color of single keypoints (circles), which means that
-keypoints do not have the matches. If singlePointColor==Scalar::all(-1) , the
-color is generated randomly.
-@param matchesMask Mask determining which matches are drawn. If the mask is
-empty, all matches are drawn.
-@param flags Flags setting drawing features. Possible flags bit values are
-defined by DrawMatchesFlags.
-
-This function draws matches of keypoints from two images in the output image.
-Match is a line connecting two keypoints (circles). See cv::DrawMatchesFlags.
- */
-CV_EXPORTS_W void
-drawMatches(InputArray img1, const std::vector<KeyPoint> &keypoints1,
-            InputArray img2, const std::vector<KeyPoint> &keypoints2,
-            const std::vector<DMatch> &matches1to2, InputOutputArray outImg,
-            const Scalar &matchColor = Scalar::all(-1),
-            const Scalar &singlePointColor = Scalar::all(-1),
-            const std::vector<char> &matchesMask = std::vector<char>(),
-            DrawMatchesFlags flags = DrawMatchesFlags::DEFAULT);
-
-/** @overload */
-CV_EXPORTS_W void
-drawMatches(InputArray img1, const std::vector<KeyPoint> &keypoints1,
-            InputArray img2, const std::vector<KeyPoint> &keypoints2,
-            const std::vector<DMatch> &matches1to2, InputOutputArray outImg,
-            const int matchesThickness,
-            const Scalar &matchColor = Scalar::all(-1),
-            const Scalar &singlePointColor = Scalar::all(-1),
-            const std::vector<char> &matchesMask = std::vector<char>(),
-            DrawMatchesFlags flags = DrawMatchesFlags::DEFAULT);
-
-CV_EXPORTS_AS(drawMatchesKnn)
-void drawMatches(InputArray img1, const std::vector<KeyPoint> &keypoints1,
-                 InputArray img2, const std::vector<KeyPoint> &keypoints2,
-                 const std::vector<std::vector<DMatch>> &matches1to2,
-                 InputOutputArray outImg,
-                 const Scalar &matchColor = Scalar::all(-1),
-                 const Scalar &singlePointColor = Scalar::all(-1),
-                 const std::vector<std::vector<char>> &matchesMask =
-                     std::vector<std::vector<char>>(),
-                 DrawMatchesFlags flags = DrawMatchesFlags::DEFAULT);
-
-//! @} features2d_draw
-
-/****************************************************************************************\
-*   Functions to evaluate the feature detectors and [generic] descriptor
-extractors      *
-\****************************************************************************************/
-
-//! @addtogroup features2d_main
-//! @{
-
-CV_EXPORTS void evaluateFeatureDetector(
-    const Mat &img1, const Mat &img2, const Mat &H1to2,
-    std::vector<KeyPoint> *keypoints1, std::vector<KeyPoint> *keypoints2,
-    float &repeatability, int &correspCount,
-    const Ptr<FeatureDetector> &fdetector = Ptr<FeatureDetector>());
-
-CV_EXPORTS void computeRecallPrecisionCurve(
-    const std::vector<std::vector<DMatch>> &matches1to2,
-    const std::vector<std::vector<uchar>> &correctMatches1to2Mask,
-    std::vector<Point2f> &recallPrecisionCurve);
-
-CV_EXPORTS float getRecall(const std::vector<Point2f> &recallPrecisionCurve,
-                           float l_precision);
-CV_EXPORTS int getNearestPoint(const std::vector<Point2f> &recallPrecisionCurve,
-                               float l_precision);
-
-//! @}
-
-/****************************************************************************************\
-*                                     Bag of visual words *
-\****************************************************************************************/
-
-//! @addtogroup features2d_category
-//! @{
-
-/** @brief Abstract base class for training the *bag of visual words* vocabulary
-from a set of descriptors.
-
-For details, see, for example, *Visual Categorization with Bags of Keypoints* by
-Gabriella Csurka, Christopher R. Dance, Lixin Fan, Jutta Willamowski, Cedric
-Bray, 2004. :
- */
-class CV_EXPORTS_W BOWTrainer {
-public:
-  BOWTrainer();
-  virtual ~BOWTrainer();
-
-  /** @brief Adds descriptors to a training set.
-
-  @param descriptors Descriptors to add to a training set. Each row of the
-  descriptors matrix is a descriptor.
-
-  The training set is clustered using clustermethod to construct the vocabulary.
-   */
-  CV_WRAP void add(const Mat &descriptors);
-
-  /** @brief Returns a training set of descriptors.
-   */
-  CV_WRAP const std::vector<Mat> &getDescriptors() const;
-
-  /** @brief Returns the count of all descriptors stored in the training set.
-   */
-  CV_WRAP int descriptorsCount() const;
-
-  CV_WRAP virtual void clear();
-
-  /** @overload */
-  CV_WRAP virtual Mat cluster() const = 0;
-
-  /** @brief Clusters train descriptors.
-
-  @param descriptors Descriptors to cluster. Each row of the descriptors matrix
-  is a descriptor. Descriptors are not added to the inner train descriptor set.
-
-  The vocabulary consists of cluster centers. So, this method returns the
-  vocabulary. In the first variant of the method, train descriptors stored in
-  the object are clustered. In the second variant, input descriptors are
-  clustered.
-   */
-  CV_WRAP virtual Mat cluster(const Mat &descriptors) const = 0;
-
-protected:
-  std::vector<Mat> descriptors;
-  int size;
-};
-
-/** @brief kmeans -based class to train visual vocabulary using the *bag of
- * visual words* approach. :
- */
-class CV_EXPORTS_W BOWKMeansTrainer : public BOWTrainer {
-public:
-  /** @brief The constructor.
-
-  @see cv::kmeans
-  */
-  CV_WRAP BOWKMeansTrainer(int clusterCount,
-                           const TermCriteria &termcrit = TermCriteria(),
-                           int attempts = 3, int flags = KMEANS_PP_CENTERS);
-  virtual ~BOWKMeansTrainer();
-
-  // Returns trained vocabulary (i.e. cluster centers).
-  CV_WRAP virtual Mat cluster() const CV_OVERRIDE;
-  CV_WRAP virtual Mat cluster(const Mat &descriptors) const CV_OVERRIDE;
-
-protected:
-  int clusterCount;
-  TermCriteria termcrit;
-  int attempts;
-  int flags;
-};
-
-/** @brief Class to compute an image descriptor using the *bag of visual words*.
-
-Such a computation consists of the following steps:
-
-1.  Compute descriptors for a given image and its keypoints set.
-2.  Find the nearest visual words from the vocabulary for each keypoint
-descriptor.
-3.  Compute the bag-of-words image descriptor as is a normalized histogram of
-vocabulary words encountered in the image. The i-th bin of the histogram is a
-frequency of i-th word of the vocabulary in the given image.
- */
-class CV_EXPORTS_W BOWImgDescriptorExtractor {
-public:
-  /** @brief The constructor.
-
-  @param dextractor Descriptor extractor that is used to compute descriptors for
-  an input image and its keypoints.
-  @param dmatcher Descriptor matcher that is used to find the nearest word of
-  the trained vocabulary for each keypoint descriptor of the image.
-   */
-  CV_WRAP BOWImgDescriptorExtractor(const Ptr<Feature2D> &dextractor,
-                                    const Ptr<DescriptorMatcher> &dmatcher);
-  /** @overload */
-  BOWImgDescriptorExtractor(const Ptr<DescriptorMatcher> &dmatcher);
-  virtual ~BOWImgDescriptorExtractor();
-
-  /** @brief Sets a visual vocabulary.
-
-  @param vocabulary Vocabulary (can be trained using the inheritor of BOWTrainer
-  ). Each row of the vocabulary is a visual word (cluster center).
-   */
-  CV_WRAP void setVocabulary(const Mat &vocabulary);
-
-  /** @brief Returns the set vocabulary.
-   */
-  CV_WRAP const Mat &getVocabulary() const;
-
-  /** @brief Computes an image descriptor using the set visual vocabulary.
-
-  @param image Image, for which the descriptor is computed.
-  @param keypoints Keypoints detected in the input image.
-  @param imgDescriptor Computed output image descriptor.
-  @param pointIdxsOfClusters Indices of keypoints that belong to the cluster.
-  This means that pointIdxsOfClusters[i] are keypoint indices that belong to the
-  i -th cluster (word of vocabulary) returned if it is non-zero.
-  @param descriptors Descriptors of the image keypoints that are returned if
-  they are non-zero.
-   */
-  void compute(InputArray image, std::vector<KeyPoint> &keypoints,
-               OutputArray imgDescriptor,
-               std::vector<std::vector<int>> *pointIdxsOfClusters = 0,
-               Mat *descriptors = 0);
-  /** @overload
-  @param keypointDescriptors Computed descriptors to match with vocabulary.
-  @param imgDescriptor Computed output image descriptor.
-  @param pointIdxsOfClusters Indices of keypoints that belong to the cluster.
-  This means that pointIdxsOfClusters[i] are keypoint indices that belong to the
-  i -th cluster (word of vocabulary) returned if it is non-zero.
-  */
-  void compute(InputArray keypointDescriptors, OutputArray imgDescriptor,
-               std::vector<std::vector<int>> *pointIdxsOfClusters = 0);
-  // compute() is not constant because DescriptorMatcher::match is not constant
-
-  CV_WRAP_AS(compute)
-  void compute2(const Mat &image, std::vector<KeyPoint> &keypoints,
-                CV_OUT Mat &imgDescriptor) {
-    compute(image, keypoints, imgDescriptor);
-  }
-
-  /** @brief Returns an image descriptor size if the vocabulary is set.
-   * Otherwise, it returns 0.
-   */
-  CV_WRAP int descriptorSize() const;
-
-  /** @brief Returns an image descriptor type.
-   */
-  CV_WRAP int descriptorType() const;
-
-protected:
-  Mat vocabulary;
-  Ptr<DescriptorExtractor> dextractor;
-  Ptr<DescriptorMatcher> dmatcher;
-};
-
-//! @} features2d_category
-
-} /* namespace cv */
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/features2d/features2d.hpp b/packages/react-native-executorch/third-party/include/opencv2/features2d/features2d.hpp
deleted file mode 100644
index 922caa2a12..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/features2d/features2d.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifdef __OPENCV_BUILD
-#error this is a compatibility header which should not be used inside the OpenCV library
-#endif
-
-#include "opencv2/features2d.hpp"
diff --git a/packages/react-native-executorch/third-party/include/opencv2/features2d/hal/interface.h b/packages/react-native-executorch/third-party/include/opencv2/features2d/hal/interface.h
deleted file mode 100644
index 06a473c43f..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/features2d/hal/interface.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#ifndef OPENCV_FEATURE2D_HAL_INTERFACE_H
-#define OPENCV_FEATURE2D_HAL_INTERFACE_H
-
-#include "opencv2/core/cvdef.h"
-//! @addtogroup features2d_hal_interface
-//! @{
-
-//! @name Fast feature detector types
-//! @sa cv::FastFeatureDetector
-//! @{
-#define CV_HAL_TYPE_5_8 0
-#define CV_HAL_TYPE_7_12 1
-#define CV_HAL_TYPE_9_16 2
-//! @}
-
-//! @name Key point
-//! @sa cv::KeyPoint
-//! @{
-struct CV_EXPORTS cvhalKeyPoint {
-  float x;
-  float y;
-  float size;
-  float angle;
-  float response;
-  int octave;
-  int class_id;
-};
-//! @}
-
-//! @}
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/highgui.hpp b/packages/react-native-executorch/third-party/include/opencv2/highgui.hpp
deleted file mode 100644
index 21560eee0a..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/highgui.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-//
-// Copyright (C) 2021 nihui
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//         http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#include "opencv2/highgui/highgui.hpp"
diff --git a/packages/react-native-executorch/third-party/include/opencv2/highgui/highgui.hpp b/packages/react-native-executorch/third-party/include/opencv2/highgui/highgui.hpp
deleted file mode 100644
index 3345c35bf5..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/highgui/highgui.hpp
+++ /dev/null
@@ -1,113 +0,0 @@
-//
-// Copyright (C) 2021 nihui
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//         http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef OPENCV_HIGHGUI_HPP
-#define OPENCV_HIGHGUI_HPP
-
-#include "opencv2/core.hpp"
-
-enum {
-  CV_LOAD_IMAGE_UNCHANGED = -1,
-  CV_LOAD_IMAGE_GRAYSCALE = 0,
-  CV_LOAD_IMAGE_COLOR = 1,
-};
-
-enum { CV_IMWRITE_JPEG_QUALITY = 1 };
-
-enum {
-  CV_CAP_PROP_FRAME_WIDTH = 3,
-  CV_CAP_PROP_FRAME_HEIGHT = 4,
-  CV_CAP_PROP_FPS = 5,
-};
-
-namespace cv {
-
-enum ImreadModes {
-  IMREAD_UNCHANGED = -1,
-  IMREAD_GRAYSCALE = 0,
-  IMREAD_COLOR = 1
-};
-
-enum ImwriteFlags { IMWRITE_JPEG_QUALITY = 1 };
-
-enum VideoCaptureProperties {
-  CAP_PROP_FRAME_WIDTH = 3,
-  CAP_PROP_FRAME_HEIGHT = 4,
-  CAP_PROP_FPS = 5,
-};
-
-CV_EXPORTS_W Mat imread(const String &filename, int flags = IMREAD_COLOR);
-
-CV_EXPORTS_W bool imwrite(const String &filename, InputArray img,
-                          const std::vector<int> &params = std::vector<int>());
-
-CV_EXPORTS_W Mat imdecode(InputArray buf, int flags);
-
-CV_EXPORTS_W bool imencode(const String &ext, InputArray img,
-                           CV_OUT std::vector<uchar> &buf,
-                           const std::vector<int> &params = std::vector<int>());
-
-CV_EXPORTS_W void imshow(const String &winname, InputArray mat);
-
-CV_EXPORTS_W int waitKey(int delay = 0);
-
-class VideoCaptureImpl;
-class CV_EXPORTS_W VideoCapture {
-public:
-  VideoCapture();
-
-  ~VideoCapture();
-
-  bool open(int index);
-
-  bool isOpened() const;
-
-  void release();
-
-  VideoCapture &operator>>(Mat &bgr_image);
-
-  bool set(int propId, double value);
-
-  double get(int propId) const;
-
-private:
-  VideoCaptureImpl *const d;
-};
-
-class VideoWriterImpl;
-class CV_EXPORTS_W VideoWriter {
-public:
-  VideoWriter();
-
-  ~VideoWriter();
-
-  bool open(const String &name, int port);
-
-  bool isOpened() const;
-
-  void release();
-
-  VideoWriter &operator<<(const Mat &bgr_image);
-
-  void write(const Mat &image);
-
-protected:
-  VideoWriterImpl *const d;
-};
-
-} // namespace cv
-
-#endif // OPENCV_HIGHGUI_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/imgproc.hpp b/packages/react-native-executorch/third-party/include/opencv2/imgproc.hpp
deleted file mode 100644
index f529c3229d..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/imgproc.hpp
+++ /dev/null
@@ -1,5956 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                           License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_IMGPROC_HPP
-#define OPENCV_IMGPROC_HPP
-
-#include "opencv2/core.hpp"
-
-/**
-@defgroup imgproc Image Processing
-
-This module offers a comprehensive suite of image processing functions, enabling
-tasks such as those listed above.
-
-@{
-    @defgroup imgproc_filter Image Filtering
-
-    Functions and classes described in this section are used to perform various
-linear or non-linear filtering operations on 2D images (represented as Mat's).
-It means that for each pixel location
-    \f$(x,y)\f$ in the source image (normally, rectangular), its neighborhood is
-considered and used to compute the response. In case of a linear filter, it is a
-weighted sum of pixel values. In case of morphological operations, it is the
-minimum or maximum values, and so on. The computed response is stored in the
-destination image at the same location \f$(x,y)\f$. It means that the output
-image will be of the same size as the input image. Normally, the functions
-support multi-channel arrays, in which case every channel is processed
-independently. Therefore, the output image will also have the same number of
-channels as the input one.
-
-    Another common feature of the functions and classes described in this
-section is that, unlike simple arithmetic functions, they need to extrapolate
-values of some non-existing pixels. For example, if you want to smooth an image
-using a Gaussian \f$3 \times 3\f$ filter, then, when processing the left-most
-pixels in each row, you need pixels to the left of them, that is, outside of the
-image. You can let these pixels be the same as the left-most image pixels
-("replicated border" extrapolation method), or assume that all the non-existing
-pixels are zeros ("constant border" extrapolation method), and so on. OpenCV
-enables you to specify the extrapolation method. For details, see #BorderTypes
-
-    @anchor filter_depths
-    ### Depth combinations
-    Input depth (src.depth()) | Output depth (ddepth)
-    --------------------------|----------------------
-    CV_8U                     | -1/CV_16S/CV_32F/CV_64F
-    CV_16U/CV_16S             | -1/CV_32F/CV_64F
-    CV_32F                    | -1/CV_32F
-    CV_64F                    | -1/CV_64F
-
-    @note when ddepth=-1, the output image will have the same depth as the
-source.
-
-    @note if you need double floating-point accuracy and using single
-floating-point input data (CV_32F input and CV_64F output depth combination),
-you can use @ref Mat.convertTo to convert the input data to the desired
-precision.
-
-    @defgroup imgproc_transform Geometric Image Transformations
-
-    The functions in this section perform various geometrical transformations of
-2D images. They do not change the image content but deform the pixel grid and
-map this deformed grid to the destination image. In fact, to avoid sampling
-artifacts, the mapping is done in the reverse order, from destination to the
-source. That is, for each pixel \f$(x, y)\f$ of the destination image, the
-    functions compute coordinates of the corresponding "donor" pixel in the
-source image and copy the pixel value:
-
-    \f[\texttt{dst} (x,y)= \texttt{src} (f_x(x,y), f_y(x,y))\f]
-
-    In case when you specify the forward mapping \f$\left<g_x, g_y\right>:
-\texttt{src} \rightarrow
-    \texttt{dst}\f$, the OpenCV functions first compute the corresponding
-inverse mapping
-    \f$\left<f_x, f_y\right>: \texttt{dst} \rightarrow \texttt{src}\f$ and then
-use the above formula.
-
-    The actual implementations of the geometrical transformations, from the most
-generic remap and to the simplest and the fastest resize, need to solve two main
-problems with the above formula:
-
-    - Extrapolation of non-existing pixels. Similarly to the filtering functions
-described in the previous section, for some \f$(x,y)\f$, either one of
-\f$f_x(x,y)\f$, or \f$f_y(x,y)\f$, or both of them may fall outside of the
-image. In this case, an extrapolation method needs to be used. OpenCV provides
-the same selection of extrapolation methods as in the filtering functions. In
-    addition, it provides the method #BORDER_TRANSPARENT. This means that the
-corresponding pixels in the destination image will not be modified at all.
-
-    - Interpolation of pixel values. Usually \f$f_x(x,y)\f$ and \f$f_y(x,y)\f$
-are floating-point numbers. This means that \f$\left<f_x, f_y\right>\f$ can be
-either an affine or perspective transformation, or radial lens distortion
-correction, and so on. So, a pixel value at fractional coordinates needs to be
-retrieved. In the simplest case, the coordinates can be just rounded to the
-    nearest integer coordinates and the corresponding pixel can be used. This is
-called a nearest-neighbor interpolation. However, a better result can be
-achieved by using more sophisticated [interpolation
-methods](http://en.wikipedia.org/wiki/Multivariate_interpolation) , where a
-polynomial function is fit into some neighborhood of the computed pixel
-\f$(f_x(x,y), f_y(x,y))\f$, and then the value of the polynomial at
-\f$(f_x(x,y), f_y(x,y))\f$ is taken as the interpolated pixel value. In OpenCV,
-you can choose between several interpolation methods. See #resize for details.
-
-    @note The geometrical transformations do not work with `CV_8S` or `CV_32S`
-images.
-
-    @defgroup imgproc_misc Miscellaneous Image Transformations
-    @defgroup imgproc_draw Drawing Functions
-
-    Drawing functions work with matrices/images of arbitrary depth. The
-boundaries of the shapes can be rendered with antialiasing (implemented only for
-8-bit images for now). All the functions include the parameter color that uses
-an RGB value (that may be constructed with the Scalar constructor ) for color
-images and brightness for grayscale images. For color images, the channel
-ordering is normally *Blue, Green, Red*. This is what imshow, imread, and
-imwrite expect. So, if you form a color using the Scalar constructor, it should
-look like:
-
-    \f[\texttt{Scalar} (blue \_ component, green \_ component, red \_
-component[, alpha \_ component])\f]
-
-    If you are using your own image rendering and I/O functions, you can use any
-channel ordering. The drawing functions process each channel independently and
-do not depend on the channel order or even on the used color space. The whole
-image can be converted from BGR to RGB or to a different color space using
-cvtColor .
-
-    If a drawn figure is partially or completely outside the image, the drawing
-functions clip it. Also, many drawing functions can handle pixel coordinates
-specified with sub-pixel accuracy. This means that the coordinates can be passed
-as fixed-point numbers encoded as integers. The number of fractional bits is
-specified by the shift parameter and the real point coordinates are calculated
-as
-    \f$\texttt{Point}(x,y)\rightarrow\texttt{Point2f}(x*2^{-shift},y*2^{-shift})\f$
-. This feature is especially effective when rendering antialiased shapes.
-
-    @note The functions do not support alpha-transparency when the target image
-is 4-channel. In this case, the color[3] is simply copied to the repainted
-pixels. Thus, if you want to paint semi-transparent shapes, you can paint them
-in a separate buffer and then blend it with the main image.
-
-    @defgroup imgproc_color_conversions Color Space Conversions
-    @defgroup imgproc_colormap ColorMaps in OpenCV
-
-    The human perception isn't built for observing fine changes in grayscale
-images. Human eyes are more sensitive to observing changes between colors, so
-you often need to recolor your grayscale images to get a clue about them. OpenCV
-now comes with various colormaps to enhance the visualization in your computer
-vision application.
-
-    In OpenCV you only need applyColorMap to apply a colormap on a given image.
-The following sample code reads the path to an image from command line, applies
-a Jet colormap on it and shows the result:
-
-    @include snippets/imgproc_applyColorMap.cpp
-
-    @see #ColormapTypes
-
-    @defgroup imgproc_subdiv2d Planar Subdivision
-
-    The Subdiv2D class described in this section is used to perform various
-planar subdivision on a set of 2D points (represented as vector of Point2f).
-OpenCV subdivides a plane into triangles using the Delaunay's algorithm, which
-corresponds to the dual graph of the Voronoi diagram. In the figure below, the
-Delaunay's triangulation is marked with black lines and the Voronoi diagram with
-red lines.
-
-    ![Delaunay triangulation (black) and Voronoi
-(red)](pics/delaunay_voronoi.png)
-
-    The subdivisions can be used for the 3D piece-wise transformation of a
-plane, morphing, fast location of points on the plane, building special graphs
-(such as NNG,RNG), and so forth.
-
-    @defgroup imgproc_hist Histograms
-    @defgroup imgproc_shape Structural Analysis and Shape Descriptors
-    @defgroup imgproc_motion Motion Analysis and Object Tracking
-    @defgroup imgproc_feature Feature Detection
-    @defgroup imgproc_object Object Detection
-    @defgroup imgproc_segmentation Image Segmentation
-    @defgroup imgproc_hal Hardware Acceleration Layer
-    @{
-        @defgroup imgproc_hal_functions Functions
-        @defgroup imgproc_hal_interface Interface
-    @}
-  @}
-*/
-
-namespace cv {
-
-/** @addtogroup imgproc
-@{
-*/
-
-//! @addtogroup imgproc_filter
-//! @{
-
-enum SpecialFilter { FILTER_SCHARR = -1 };
-
-//! type of morphological operation
-enum MorphTypes {
-  MORPH_ERODE = 0,  //!< see #erode
-  MORPH_DILATE = 1, //!< see #dilate
-  MORPH_OPEN = 2,   //!< an opening operation
-                    //!< \f[\texttt{dst} = \mathrm{open} ( \texttt{src} ,
-                    //!< \texttt{element} )= \mathrm{dilate} ( \mathrm{erode} (
-                    //!< \texttt{src} , \texttt{element} ))\f]
-  MORPH_CLOSE = 3,  //!< a closing operation
-                    //!< \f[\texttt{dst} = \mathrm{close} ( \texttt{src} ,
-                    //!< \texttt{element} )= \mathrm{erode} ( \mathrm{dilate} (
-                    //!< \texttt{src} , \texttt{element} ))\f]
-  MORPH_GRADIENT = 4, //!< a morphological gradient
-                      //!< \f[\texttt{dst} = \mathrm{morph\_grad} ( \texttt{src}
-                      //!< , \texttt{element} )= \mathrm{dilate} ( \texttt{src}
-                      //!< , \texttt{element} )- \mathrm{erode} ( \texttt{src} ,
-                      //!< \texttt{element} )\f]
-  MORPH_TOPHAT = 5,   //!< "top hat"
-                      //!< \f[\texttt{dst} = \mathrm{tophat} ( \texttt{src} ,
-                      //!< \texttt{element} )= \texttt{src} - \mathrm{open} (
-                      //!< \texttt{src} , \texttt{element} )\f]
-  MORPH_BLACKHAT = 6, //!< "black hat"
-                      //!< \f[\texttt{dst} = \mathrm{blackhat} ( \texttt{src} ,
-                      //!< \texttt{element} )= \mathrm{close} ( \texttt{src} ,
-                      //!< \texttt{element} )- \texttt{src}\f]
-  MORPH_HITMISS = 7   //!< "hit or miss"
-                      //!<   .- Only supported for CV_8UC1 binary images. A
-                      //!<   tutorial can be found in the documentation
-};
-
-//! shape of the structuring element
-enum MorphShapes {
-  MORPH_RECT = 0,  //!< a rectangular structuring element:  \f[E_{ij}=1\f]
-  MORPH_CROSS = 1, //!< a cross-shaped structuring element:
-                   //!< \f[E_{ij} = \begin{cases} 1 & \texttt{if }
-                   //!< {i=\texttt{anchor.y } {or } {j=\texttt{anchor.x}}} \\0 &
-                   //!< \texttt{otherwise} \end{cases}\f]
-  MORPH_ELLIPSE =
-      2 //!< an elliptic structuring element, that is, a filled ellipse
-        //!< inscribed into the rectangle Rect(0, 0, esize.width, esize.height)
-};
-
-//! @} imgproc_filter
-
-//! @addtogroup imgproc_transform
-//! @{
-
-//! interpolation algorithm
-enum InterpolationFlags {
-  /** nearest neighbor interpolation */
-  INTER_NEAREST = 0,
-  /** bilinear interpolation */
-  INTER_LINEAR = 1,
-  /** bicubic interpolation */
-  INTER_CUBIC = 2,
-  /** resampling using pixel area relation. It may be a preferred method for
-  image decimation, as it gives moire'-free results. But when the image is
-  zoomed, it is similar to the INTER_NEAREST method. */
-  INTER_AREA = 3,
-  /** Lanczos interpolation over 8x8 neighborhood */
-  INTER_LANCZOS4 = 4,
-  /** Bit exact bilinear interpolation */
-  INTER_LINEAR_EXACT = 5,
-  /** Bit exact nearest neighbor interpolation. This will produce same results
-  as the nearest neighbor method in PIL, scikit-image or Matlab. */
-  INTER_NEAREST_EXACT = 6,
-  /** mask for interpolation codes */
-  INTER_MAX = 7,
-  /** flag, fills all of the destination image pixels. If some of them
-  correspond to outliers in the source image, they are set to zero */
-  WARP_FILL_OUTLIERS = 8,
-  /** flag, inverse transformation
-
-  For example, #linearPolar or #logPolar transforms:
-  - flag is __not__ set: \f$dst( \rho , \phi ) = src(x,y)\f$
-  - flag is set: \f$dst(x,y) = src( \rho , \phi )\f$
-  */
-  WARP_INVERSE_MAP = 16,
-  WARP_RELATIVE_MAP = 32
-};
-
-/** \brief Specify the polar mapping mode
-@sa warpPolar
-*/
-enum WarpPolarMode {
-  WARP_POLAR_LINEAR = 0, ///< Remaps an image to/from polar space.
-  WARP_POLAR_LOG = 256   ///< Remaps an image to/from semilog-polar space.
-};
-
-enum InterpolationMasks {
-  INTER_BITS = 5,
-  INTER_BITS2 = INTER_BITS * 2,
-  INTER_TAB_SIZE = 1 << INTER_BITS,
-  INTER_TAB_SIZE2 = INTER_TAB_SIZE * INTER_TAB_SIZE
-};
-
-//! @} imgproc_transform
-
-//! @addtogroup imgproc_misc
-//! @{
-
-//! Distance types for Distance Transform and M-estimators
-//! @see distanceTransform, fitLine
-enum DistanceTypes {
-  DIST_USER = -1,  //!< User defined distance
-  DIST_L1 = 1,     //!< distance = |x1-x2| + |y1-y2|
-  DIST_L2 = 2,     //!< the simple euclidean distance
-  DIST_C = 3,      //!< distance = max(|x1-x2|,|y1-y2|)
-  DIST_L12 = 4,    //!< L1-L2 metric: distance = 2(sqrt(1+x*x/2) - 1))
-  DIST_FAIR = 5,   //!< distance = c^2(|x|/c-log(1+|x|/c)), c = 1.3998
-  DIST_WELSCH = 6, //!< distance = c^2/2(1-exp(-(x/c)^2)), c = 2.9846
-  DIST_HUBER = 7   //!< distance = |x|<c ? x^2/2 : c(|x|-c/2), c=1.345
-};
-
-//! Mask size for distance transform
-enum DistanceTransformMasks {
-  DIST_MASK_3 = 3,      //!< mask=3
-  DIST_MASK_5 = 5,      //!< mask=5
-  DIST_MASK_PRECISE = 0 //!<
-};
-
-//! type of the threshold operation
-//! ![threshold types](pics/threshold.png)
-enum ThresholdTypes {
-  THRESH_BINARY =
-      0, //!< \f[\texttt{dst} (x,y) =  \fork{\texttt{maxval}}{if
-         //!< \(\texttt{src}(x,y) > \texttt{thresh}\)}{0}{otherwise}\f]
-  THRESH_BINARY_INV =
-      1, //!< \f[\texttt{dst} (x,y) =  \fork{0}{if \(\texttt{src}(x,y) >
-         //!< \texttt{thresh}\)}{\texttt{maxval}}{otherwise}\f]
-  THRESH_TRUNC = 2, //!< \f[\texttt{dst} (x,y) =  \fork{\texttt{threshold}}{if
-                    //!< \(\texttt{src}(x,y) >
-                    //!< \texttt{thresh}\)}{\texttt{src}(x,y)}{otherwise}\f]
-  THRESH_TOZERO =
-      3, //!< \f[\texttt{dst} (x,y) =  \fork{\texttt{src}(x,y)}{if
-         //!< \(\texttt{src}(x,y) > \texttt{thresh}\)}{0}{otherwise}\f]
-  THRESH_TOZERO_INV =
-      4, //!< \f[\texttt{dst} (x,y) =  \fork{0}{if \(\texttt{src}(x,y) >
-         //!< \texttt{thresh}\)}{\texttt{src}(x,y)}{otherwise}\f]
-  THRESH_MASK = 7,
-  THRESH_OTSU =
-      8, //!< flag, use Otsu algorithm to choose the optimal threshold value
-  THRESH_TRIANGLE =
-      16 //!< flag, use Triangle algorithm to choose the optimal threshold value
-};
-
-//! adaptive threshold algorithm
-//! @see adaptiveThreshold
-enum AdaptiveThresholdTypes {
-  /** the threshold value \f$T(x,y)\f$ is a mean of the \f$\texttt{blockSize}
-  \times
-  \texttt{blockSize}\f$ neighborhood of \f$(x, y)\f$ minus C */
-  ADAPTIVE_THRESH_MEAN_C = 0,
-  /** the threshold value \f$T(x, y)\f$ is a weighted sum (cross-correlation
-  with a Gaussian window) of the \f$\texttt{blockSize} \times
-  \texttt{blockSize}\f$ neighborhood of \f$(x, y)\f$ minus C . The default sigma
-  (standard deviation) is used for the specified blockSize . See
-  #getGaussianKernel*/
-  ADAPTIVE_THRESH_GAUSSIAN_C = 1
-};
-
-//! class of the pixel in GrabCut algorithm
-enum GrabCutClasses {
-  GC_BGD = 0,    //!< an obvious background pixels
-  GC_FGD = 1,    //!< an obvious foreground (object) pixel
-  GC_PR_BGD = 2, //!< a possible background pixel
-  GC_PR_FGD = 3  //!< a possible foreground pixel
-};
-
-//! GrabCut algorithm flags
-enum GrabCutModes {
-  /** The function initializes the state and the mask using the provided
-  rectangle. After that it runs iterCount iterations of the algorithm. */
-  GC_INIT_WITH_RECT = 0,
-  /** The function initializes the state using the provided mask. Note that
-  GC_INIT_WITH_RECT and GC_INIT_WITH_MASK can be combined. Then, all the pixels
-  outside of the ROI are automatically initialized with GC_BGD .*/
-  GC_INIT_WITH_MASK = 1,
-  /** The value means that the algorithm should just resume. */
-  GC_EVAL = 2,
-  /** The value means that the algorithm should just run the grabCut algorithm
-     (a single iteration) with the fixed model */
-  GC_EVAL_FREEZE_MODEL = 3
-};
-
-//! distanceTransform algorithm flags
-enum DistanceTransformLabelTypes {
-  /** each connected component of zeros in src (as well as all the non-zero
-  pixels closest to the connected component) will be assigned the same label */
-  DIST_LABEL_CCOMP = 0,
-  /** each zero pixel (and all the non-zero pixels closest to it) gets its own
-     label. */
-  DIST_LABEL_PIXEL = 1
-};
-
-//! floodfill algorithm flags
-enum FloodFillFlags {
-  /** If set, the difference between the current pixel and seed pixel is
-  considered. Otherwise, the difference between neighbor pixels is considered
-  (that is, the range is floating). */
-  FLOODFILL_FIXED_RANGE = 1 << 16,
-  /** If set, the function does not change the image ( newVal is ignored), and
-  only fills the mask with the value specified in bits 8-16 of flags as
-  described above. This option only make sense in function variants that have
-  the mask parameter. */
-  FLOODFILL_MASK_ONLY = 1 << 17
-};
-
-//! @} imgproc_misc
-
-//! @addtogroup imgproc_shape
-//! @{
-
-//! connected components statistics
-enum ConnectedComponentsTypes {
-  CC_STAT_LEFT = 0, //!< The leftmost (x) coordinate which is the inclusive
-                    //!< start of the bounding box in the horizontal direction.
-  CC_STAT_TOP = 1,  //!< The topmost (y) coordinate which is the inclusive start
-                    //!< of the bounding box in the vertical direction.
-  CC_STAT_WIDTH = 2,  //!< The horizontal size of the bounding box
-  CC_STAT_HEIGHT = 3, //!< The vertical size of the bounding box
-  CC_STAT_AREA = 4,   //!< The total area (in pixels) of the connected component
-#ifndef CV_DOXYGEN
-  CC_STAT_MAX =
-      5 //!< Max enumeration value. Used internally only for memory allocation
-#endif
-};
-
-//! connected components algorithm
-enum ConnectedComponentsAlgorithmsTypes {
-  CCL_DEFAULT =
-      -1, //!< Spaghetti @cite Bolelli2019 algorithm for 8-way connectivity,
-          //!< Spaghetti4C @cite Bolelli2021 algorithm for 4-way connectivity.
-  CCL_WU = 0, //!< SAUF @cite Wu2009 algorithm for 8-way connectivity, SAUF
-              //!< algorithm for 4-way connectivity. The parallel implementation
-              //!< described in @cite Bolelli2017 is available for SAUF.
-  CCL_GRANA = 1, //!< BBDT @cite Grana2010 algorithm for 8-way connectivity,
-                 //!< SAUF algorithm for 4-way connectivity. The parallel
-                 //!< implementation described in @cite Bolelli2017 is available
-                 //!< for both BBDT and SAUF.
-  CCL_BOLELLI =
-      2, //!< Spaghetti @cite Bolelli2019 algorithm for 8-way connectivity,
-         //!< Spaghetti4C @cite Bolelli2021 algorithm for 4-way connectivity.
-         //!< The parallel implementation described in @cite Bolelli2017 is
-         //!< available for both Spaghetti and Spaghetti4C.
-  CCL_SAUF = 3, //!< Same as CCL_WU. It is preferable to use the flag with the
-                //!< name of the algorithm (CCL_SAUF) rather than the one with
-                //!< the name of the first author (CCL_WU).
-  CCL_BBDT = 4, //!< Same as CCL_GRANA. It is preferable to use the flag with
-                //!< the name of the algorithm (CCL_BBDT) rather than the one
-                //!< with the name of the first author (CCL_GRANA).
-  CCL_SPAGHETTI =
-      5, //!< Same as CCL_BOLELLI. It is preferable to use the flag with the
-         //!< name of the algorithm (CCL_SPAGHETTI) rather than the one with the
-         //!< name of the first author (CCL_BOLELLI).
-};
-
-//! mode of the contour retrieval algorithm
-enum RetrievalModes {
-  /** retrieves only the extreme outer contours. It sets
-  `hierarchy[i][2]=hierarchy[i][3]=-1` for all the contours. */
-  RETR_EXTERNAL = 0,
-  /** retrieves all of the contours without establishing any hierarchical
-     relationships. */
-  RETR_LIST = 1,
-  /** retrieves all of the contours and organizes them into a two-level
-  hierarchy. At the top level, there are external boundaries of the components.
-  At the second level, there are boundaries of the holes. If there is another
-  contour inside a hole of a connected component, it is still put at the top
-  level. */
-  RETR_CCOMP = 2,
-  /** retrieves all of the contours and reconstructs a full hierarchy of nested
-     contours.*/
-  RETR_TREE = 3,
-  RETR_FLOODFILL = 4 //!<
-};
-
-//! the contour approximation algorithm
-enum ContourApproximationModes {
-  /** stores absolutely all the contour points. That is, any 2 subsequent points
-  (x1,y1) and (x2,y2) of the contour will be either horizontal, vertical or
-  diagonal neighbors, that is, max(abs(x1-x2),abs(y2-y1))==1. */
-  CHAIN_APPROX_NONE = 1,
-  /** compresses horizontal, vertical, and diagonal segments and leaves only
-  their end points. For example, an up-right rectangular contour is encoded with
-  4 points. */
-  CHAIN_APPROX_SIMPLE = 2,
-  /** applies one of the flavors of the Teh-Chin chain approximation algorithm
-     @cite TehChin89 */
-  CHAIN_APPROX_TC89_L1 = 3,
-  /** applies one of the flavors of the Teh-Chin chain approximation algorithm
-     @cite TehChin89 */
-  CHAIN_APPROX_TC89_KCOS = 4
-};
-
-/** @brief Shape matching methods
-
-\f$A\f$ denotes object1,\f$B\f$ denotes object2
-
-\f$\begin{array}{l} m^A_i =  \mathrm{sign} (h^A_i)  \cdot \log{h^A_i} \\ m^B_i =
-\mathrm{sign} (h^B_i)  \cdot \log{h^B_i} \end{array}\f$
-
-and \f$h^A_i, h^B_i\f$ are the Hu moments of \f$A\f$ and \f$B\f$ , respectively.
-*/
-enum ShapeMatchModes {
-  CONTOURS_MATCH_I1 = 1, //!< \f[I_1(A,B) =  \sum _{i=1...7}  \left |
-                         //!< \frac{1}{m^A_i} -  \frac{1}{m^B_i} \right |\f]
-  CONTOURS_MATCH_I2 =
-      2, //!< \f[I_2(A,B) =  \sum _{i=1...7}  \left | m^A_i - m^B_i  \right |\f]
-  CONTOURS_MATCH_I3 = 3 //!< \f[I_3(A,B) =  \max _{i=1...7}  \frac{ \left| m^A_i
-                        //!< - m^B_i \right| }{ \left| m^A_i \right| }\f]
-};
-
-//! @} imgproc_shape
-
-//! @addtogroup imgproc_feature
-//! @{
-
-//! Variants of a Hough transform
-enum HoughModes {
-
-  /** classical or standard Hough transform. Every line is represented by two
-  floating-point numbers \f$(\rho, \theta)\f$ , where \f$\rho\f$ is a distance
-  between (0,0) point and the line, and \f$\theta\f$ is the angle between x-axis
-  and the normal to the line. Thus, the matrix must be (the created sequence
-  will be) of CV_32FC2 type */
-  HOUGH_STANDARD = 0,
-  /** probabilistic Hough transform (more efficient in case if the picture
-  contains a few long linear segments). It returns line segments rather than the
-  whole line. Each segment is represented by starting and ending points, and the
-  matrix must be (the created sequence will be) of the CV_32SC4 type. */
-  HOUGH_PROBABILISTIC = 1,
-  /** multi-scale variant of the classical Hough transform. The lines are
-  encoded the same way as HOUGH_STANDARD. */
-  HOUGH_MULTI_SCALE = 2,
-  HOUGH_GRADIENT = 3, //!< basically *21HT*, described in @cite Yuen90
-  HOUGH_GRADIENT_ALT =
-      4, //!< variation of HOUGH_GRADIENT to get better accuracy
-};
-
-//! Variants of Line Segment %Detector
-enum LineSegmentDetectorModes {
-  LSD_REFINE_NONE = 0, //!< No refinement applied
-  LSD_REFINE_STD = 1,  //!< Standard refinement is applied. E.g. breaking arches
-                       //!< into smaller straighter line approximations.
-  LSD_REFINE_ADV =
-      2 //!< Advanced refinement. Number of false alarms is calculated, lines
-        //!< are refined through increase of precision, decrement in size, etc.
-};
-
-//! @} imgproc_feature
-
-/** Histogram comparison methods
-  @ingroup imgproc_hist
-*/
-enum HistCompMethods {
-  /** Correlation
-  \f[d(H_1,H_2) =  \frac{\sum_I (H_1(I) - \bar{H_1}) (H_2(I) -
-  \bar{H_2})}{\sqrt{\sum_I(H_1(I) - \bar{H_1})^2 \sum_I(H_2(I) -
-  \bar{H_2})^2}}\f] where
-  \f[\bar{H_k} =  \frac{1}{N} \sum _J H_k(J)\f]
-  and \f$N\f$ is a total number of histogram bins. */
-  HISTCMP_CORREL = 0,
-  /** Chi-Square
-  \f[d(H_1,H_2) =  \sum _I  \frac{\left(H_1(I)-H_2(I)\right)^2}{H_1(I)}\f] */
-  HISTCMP_CHISQR = 1,
-  /** Intersection
-  \f[d(H_1,H_2) =  \sum _I  \min (H_1(I), H_2(I))\f] */
-  HISTCMP_INTERSECT = 2,
-  /** Bhattacharyya distance
-  (In fact, OpenCV computes Hellinger distance, which is related to
-  Bhattacharyya coefficient.)
-  \f[d(H_1,H_2) =  \sqrt{1 - \frac{1}{\sqrt{\bar{H_1} \bar{H_2} N^2}} \sum_I
-  \sqrt{H_1(I) \cdot H_2(I)}}\f] */
-  HISTCMP_BHATTACHARYYA = 3,
-  HISTCMP_HELLINGER =
-      HISTCMP_BHATTACHARYYA, //!< Synonym for HISTCMP_BHATTACHARYYA
-  /** Alternative Chi-Square
-  \f[d(H_1,H_2) =  2 * \sum _I
-  \frac{\left(H_1(I)-H_2(I)\right)^2}{H_1(I)+H_2(I)}\f] This alternative formula
-  is regularly used for texture comparison. See e.g. @cite Puzicha1997 */
-  HISTCMP_CHISQR_ALT = 4,
-  /** Kullback-Leibler divergence
-  \f[d(H_1,H_2) = \sum _I H_1(I) \log \left(\frac{H_1(I)}{H_2(I)}\right)\f] */
-  HISTCMP_KL_DIV = 5
-};
-
-/** the color conversion codes
-@see @ref imgproc_color_conversions
-@ingroup imgproc_color_conversions
- */
-enum ColorConversionCodes {
-  COLOR_BGR2BGRA = 0, //!< add alpha channel to RGB or BGR image
-  COLOR_RGB2RGBA = COLOR_BGR2BGRA,
-
-  COLOR_BGRA2BGR = 1, //!< remove alpha channel from RGB or BGR image
-  COLOR_RGBA2RGB = COLOR_BGRA2BGR,
-
-  COLOR_BGR2RGBA = 2, //!< convert between RGB and BGR color spaces (with or
-                      //!< without alpha channel)
-  COLOR_RGB2BGRA = COLOR_BGR2RGBA,
-
-  COLOR_RGBA2BGR = 3,
-  COLOR_BGRA2RGB = COLOR_RGBA2BGR,
-
-  COLOR_BGR2RGB = 4,
-  COLOR_RGB2BGR = COLOR_BGR2RGB,
-
-  COLOR_BGRA2RGBA = 5,
-  COLOR_RGBA2BGRA = COLOR_BGRA2RGBA,
-
-  COLOR_BGR2GRAY = 6, //!< convert between RGB/BGR and grayscale, @ref
-                      //!< color_convert_rgb_gray "color conversions"
-  COLOR_RGB2GRAY = 7,
-  COLOR_GRAY2BGR = 8,
-  COLOR_GRAY2RGB = COLOR_GRAY2BGR,
-  COLOR_GRAY2BGRA = 9,
-  COLOR_GRAY2RGBA = COLOR_GRAY2BGRA,
-  COLOR_BGRA2GRAY = 10,
-  COLOR_RGBA2GRAY = 11,
-
-  COLOR_BGR2BGR565 = 12, //!< convert between RGB/BGR and BGR565 (16-bit images)
-  COLOR_RGB2BGR565 = 13,
-  COLOR_BGR5652BGR = 14,
-  COLOR_BGR5652RGB = 15,
-  COLOR_BGRA2BGR565 = 16,
-  COLOR_RGBA2BGR565 = 17,
-  COLOR_BGR5652BGRA = 18,
-  COLOR_BGR5652RGBA = 19,
-
-  COLOR_GRAY2BGR565 =
-      20, //!< convert between grayscale to BGR565 (16-bit images)
-  COLOR_BGR5652GRAY = 21,
-
-  COLOR_BGR2BGR555 = 22, //!< convert between RGB/BGR and BGR555 (16-bit images)
-  COLOR_RGB2BGR555 = 23,
-  COLOR_BGR5552BGR = 24,
-  COLOR_BGR5552RGB = 25,
-  COLOR_BGRA2BGR555 = 26,
-  COLOR_RGBA2BGR555 = 27,
-  COLOR_BGR5552BGRA = 28,
-  COLOR_BGR5552RGBA = 29,
-
-  COLOR_GRAY2BGR555 =
-      30, //!< convert between grayscale and BGR555 (16-bit images)
-  COLOR_BGR5552GRAY = 31,
-
-  COLOR_BGR2XYZ = 32, //!< convert RGB/BGR to CIE XYZ, @ref
-                      //!< color_convert_rgb_xyz "color conversions"
-  COLOR_RGB2XYZ = 33,
-  COLOR_XYZ2BGR = 34,
-  COLOR_XYZ2RGB = 35,
-
-  COLOR_BGR2YCrCb = 36, //!< convert RGB/BGR to luma-chroma (aka YCC), @ref
-                        //!< color_convert_rgb_ycrcb "color conversions"
-  COLOR_RGB2YCrCb = 37,
-  COLOR_YCrCb2BGR = 38,
-  COLOR_YCrCb2RGB = 39,
-
-  COLOR_BGR2HSV =
-      40, //!< convert RGB/BGR to HSV (hue saturation value) with H range 0..180
-          //!< if 8 bit image, @ref color_convert_rgb_hsv "color conversions"
-  COLOR_RGB2HSV = 41,
-
-  COLOR_BGR2Lab = 44, //!< convert RGB/BGR to CIE Lab, @ref
-                      //!< color_convert_rgb_lab "color conversions"
-  COLOR_RGB2Lab = 45,
-
-  COLOR_BGR2Luv = 50, //!< convert RGB/BGR to CIE Luv, @ref
-                      //!< color_convert_rgb_luv "color conversions"
-  COLOR_RGB2Luv = 51,
-  COLOR_BGR2HLS = 52, //!< convert RGB/BGR to HLS (hue lightness saturation)
-                      //!< with H range 0..180 if 8 bit image, @ref
-                      //!< color_convert_rgb_hls "color conversions"
-  COLOR_RGB2HLS = 53,
-
-  COLOR_HSV2BGR = 54, //!< backward conversions HSV to RGB/BGR with H range
-                      //!< 0..180 if 8 bit image
-  COLOR_HSV2RGB = 55,
-
-  COLOR_Lab2BGR = 56,
-  COLOR_Lab2RGB = 57,
-  COLOR_Luv2BGR = 58,
-  COLOR_Luv2RGB = 59,
-  COLOR_HLS2BGR = 60, //!< backward conversions HLS to RGB/BGR with H range
-                      //!< 0..180 if 8 bit image
-  COLOR_HLS2RGB = 61,
-
-  COLOR_BGR2HSV_FULL =
-      66, //!< convert RGB/BGR to HSV (hue saturation value) with H range 0..255
-          //!< if 8 bit image, @ref color_convert_rgb_hsv "color conversions"
-  COLOR_RGB2HSV_FULL = 67,
-  COLOR_BGR2HLS_FULL = 68, //!< convert RGB/BGR to HLS (hue lightness
-                           //!< saturation) with H range 0..255 if 8 bit image,
-                           //!< @ref color_convert_rgb_hls "color conversions"
-  COLOR_RGB2HLS_FULL = 69,
-
-  COLOR_HSV2BGR_FULL = 70, //!< backward conversions HSV to RGB/BGR with H range
-                           //!< 0..255 if 8 bit image
-  COLOR_HSV2RGB_FULL = 71,
-  COLOR_HLS2BGR_FULL = 72, //!< backward conversions HLS to RGB/BGR with H range
-                           //!< 0..255 if 8 bit image
-  COLOR_HLS2RGB_FULL = 73,
-
-  COLOR_LBGR2Lab = 74,
-  COLOR_LRGB2Lab = 75,
-  COLOR_LBGR2Luv = 76,
-  COLOR_LRGB2Luv = 77,
-
-  COLOR_Lab2LBGR = 78,
-  COLOR_Lab2LRGB = 79,
-  COLOR_Luv2LBGR = 80,
-  COLOR_Luv2LRGB = 81,
-
-  COLOR_BGR2YUV = 82, //!< convert between RGB/BGR and YUV
-  COLOR_RGB2YUV = 83,
-  COLOR_YUV2BGR = 84,
-  COLOR_YUV2RGB = 85,
-
-  COLOR_YUV2RGB_NV12 =
-      90, //!< convert between 4:2:0-subsampled YUV NV12 and RGB, two planes (in
-          //!< one or separate arrays): Y and U/V interleaved, see @ref
-          //!< color_convert_rgb_yuv_42x
-  COLOR_YUV2BGR_NV12 =
-      91, //!< convert between 4:2:0-subsampled YUV NV12 and BGR, two planes (in
-          //!< one or separate arrays): Y and U/V interleaved, see @ref
-          //!< color_convert_rgb_yuv_42x
-  COLOR_YUV2RGB_NV21 =
-      92, //!< convert between 4:2:0-subsampled YUV NV21 and RGB, two planes (in
-          //!< one or separate arrays): Y and V/U interleaved, see @ref
-          //!< color_convert_rgb_yuv_42x
-  COLOR_YUV2BGR_NV21 =
-      93, //!< convert between 4:2:0-subsampled YUV NV21 and BGR, two planes (in
-          //!< one or separate arrays): Y and V/U interleaved, see @ref
-          //!< color_convert_rgb_yuv_42x
-  COLOR_YUV420sp2RGB = COLOR_YUV2RGB_NV21, //!< synonym to NV21
-  COLOR_YUV420sp2BGR = COLOR_YUV2BGR_NV21, //!< synonym to NV21
-
-  COLOR_YUV2RGBA_NV12 =
-      94, //!< convert between 4:2:0-subsampled YUV NV12 and RGBA, two planes
-          //!< (in one or separate arrays): Y and U/V interleaved, see @ref
-          //!< color_convert_rgb_yuv_42x
-  COLOR_YUV2BGRA_NV12 =
-      95, //!< convert between 4:2:0-subsampled YUV NV12 and BGRA, two planes
-          //!< (in one or separate arrays): Y and U/V interleaved, see @ref
-          //!< color_convert_rgb_yuv_42x
-  COLOR_YUV2RGBA_NV21 =
-      96, //!< convert between 4:2:0-subsampled YUV NV21 and RGBA, two planes
-          //!< (in one or separate arrays): Y and V/U interleaved, see @ref
-          //!< color_convert_rgb_yuv_42x
-  COLOR_YUV2BGRA_NV21 =
-      97, //!< convert between 4:2:0-subsampled YUV NV21 and BGRA, two planes
-          //!< (in one or separate arrays): Y and V/U interleaved, see @ref
-          //!< color_convert_rgb_yuv_42x
-  COLOR_YUV420sp2RGBA = COLOR_YUV2RGBA_NV21, //!< synonym to NV21
-  COLOR_YUV420sp2BGRA = COLOR_YUV2BGRA_NV21, //!< synonym to NV21
-
-  COLOR_YUV2RGB_YV12 =
-      98, //!< convert between 4:2:0-subsampled YUV YV12 and RGB, three planes
-          //!< in one array: Y, V and U, see @ref color_convert_rgb_yuv_42x
-  COLOR_YUV2BGR_YV12 =
-      99, //!< convert between 4:2:0-subsampled YUV YV12 and BGR, three planes
-          //!< in one array: Y, V and U, see @ref color_convert_rgb_yuv_42x
-  COLOR_YUV2RGB_IYUV =
-      100, //!< convert between 4:2:0-subsampled YUV IYUV and RGB, three planes
-           //!< in one array: Y, U and V, see @ref color_convert_rgb_yuv_42x
-  COLOR_YUV2BGR_IYUV =
-      101, //!< convert between 4:2:0-subsampled YUV IYUV and BGR, three planes
-           //!< in one array: Y, U and V, see @ref color_convert_rgb_yuv_42x
-  COLOR_YUV2RGB_I420 = COLOR_YUV2RGB_IYUV, //!< synonym to IYUV
-  COLOR_YUV2BGR_I420 = COLOR_YUV2BGR_IYUV, //!< synonym to IYUV
-  COLOR_YUV420p2RGB = COLOR_YUV2RGB_YV12,  //!< synonym to YV12
-  COLOR_YUV420p2BGR = COLOR_YUV2BGR_YV12,  //!< synonym to YV12
-
-  COLOR_YUV2RGBA_YV12 =
-      102, //!< convert between 4:2:0-subsampled YUV YV12 and RGBA, three planes
-           //!< in one array: Y, V and U, see @ref color_convert_rgb_yuv_42x
-  COLOR_YUV2BGRA_YV12 =
-      103, //!< convert between 4:2:0-subsampled YUV YV12 and BGRA, three planes
-           //!< in one array: Y, V and U, see @ref color_convert_rgb_yuv_42x
-  COLOR_YUV2RGBA_IYUV =
-      104, //!< convert between 4:2:0-subsampled YUV YV12 and RGBA, three planes
-           //!< in one array: Y, U and V, see @ref color_convert_rgb_yuv_42x
-  COLOR_YUV2BGRA_IYUV =
-      105, //!< convert between 4:2:0-subsampled YUV YV12 and BGRA, three planes
-           //!< in one array: Y, U and V, see @ref color_convert_rgb_yuv_42x
-  COLOR_YUV2RGBA_I420 = COLOR_YUV2RGBA_IYUV, //!< synonym to IYUV
-  COLOR_YUV2BGRA_I420 = COLOR_YUV2BGRA_IYUV, //!< synonym to IYUV
-  COLOR_YUV420p2RGBA = COLOR_YUV2RGBA_YV12,  //!< synonym to YV12
-  COLOR_YUV420p2BGRA = COLOR_YUV2BGRA_YV12,  //!< synonym to YV12
-
-  COLOR_YUV2GRAY_420 = 106, //!< extract Y channel from YUV 4:2:0 image
-  COLOR_YUV2GRAY_NV21 = COLOR_YUV2GRAY_420, //!< synonym to COLOR_YUV2GRAY_420
-  COLOR_YUV2GRAY_NV12 = COLOR_YUV2GRAY_420, //!< synonym to COLOR_YUV2GRAY_420
-  COLOR_YUV2GRAY_YV12 = COLOR_YUV2GRAY_420, //!< synonym to COLOR_YUV2GRAY_420
-  COLOR_YUV2GRAY_IYUV = COLOR_YUV2GRAY_420, //!< synonym to COLOR_YUV2GRAY_420
-  COLOR_YUV2GRAY_I420 = COLOR_YUV2GRAY_420, //!< synonym to COLOR_YUV2GRAY_420
-  COLOR_YUV420sp2GRAY = COLOR_YUV2GRAY_420, //!< synonym to COLOR_YUV2GRAY_420
-  COLOR_YUV420p2GRAY = COLOR_YUV2GRAY_420,  //!< synonym to COLOR_YUV2GRAY_420
-
-  COLOR_YUV2RGB_UYVY =
-      107, //!< convert between YUV UYVY and RGB, YUV is 4:2:2-subsampled and
-           //!< interleaved as U/Y1/V/Y2, see @ref color_convert_rgb_yuv_42x
-  COLOR_YUV2BGR_UYVY =
-      108, //!< convert between YUV UYVY and BGR, YUV is 4:2:2-subsampled and
-           //!< interleaved as U/Y1/V/Y2, see @ref color_convert_rgb_yuv_42x
-  // COLOR_YUV2RGB_VYUY = 109, //!< convert between YUV VYUY and RGB, YUV is
-  // 4:2:2-subsampled and interleaved as V/Y1/U/Y2, see @ref
-  // color_convert_rgb_yuv_42x COLOR_YUV2BGR_VYUY = 110, //!< convert between
-  // YUV VYUY and BGR, YUV is 4:2:2-subsampled and interleaved as V/Y1/U/Y2, see
-  // @ref color_convert_rgb_yuv_42x
-  COLOR_YUV2RGB_Y422 = COLOR_YUV2RGB_UYVY, //!< synonym to UYVY
-  COLOR_YUV2BGR_Y422 = COLOR_YUV2BGR_UYVY, //!< synonym to UYVY
-  COLOR_YUV2RGB_UYNV = COLOR_YUV2RGB_UYVY, //!< synonym to UYVY
-  COLOR_YUV2BGR_UYNV = COLOR_YUV2BGR_UYVY, //!< synonym to UYVY
-
-  COLOR_YUV2RGBA_UYVY =
-      111, //!< convert between YUV UYVY and RGBA, YUV is 4:2:2-subsampled and
-           //!< interleaved as U/Y1/V/Y2, see @ref color_convert_rgb_yuv_42x
-  COLOR_YUV2BGRA_UYVY =
-      112, //!< convert between YUV UYVY and BGRA, YUV is 4:2:2-subsampled and
-           //!< interleaved as U/Y1/V/Y2, see @ref color_convert_rgb_yuv_42x
-  // COLOR_YUV2RGBA_VYUY = 113, //!< convert between YUV VYUY and RGBA, YUV is
-  // 4:2:2-subsampled and interleaved as V/Y1/U/Y2, see @ref
-  // color_convert_rgb_yuv_42x COLOR_YUV2BGRA_VYUY = 114, //!< convert between
-  // YUV VYUY and BGRA, YUV is 4:2:2-subsampled and interleaved as V/Y1/U/Y2,
-  // see @ref color_convert_rgb_yuv_42x
-  COLOR_YUV2RGBA_Y422 = COLOR_YUV2RGBA_UYVY, //!< synonym to UYVY
-  COLOR_YUV2BGRA_Y422 = COLOR_YUV2BGRA_UYVY, //!< synonym to UYVY
-  COLOR_YUV2RGBA_UYNV = COLOR_YUV2RGBA_UYVY, //!< synonym to UYVY
-  COLOR_YUV2BGRA_UYNV = COLOR_YUV2BGRA_UYVY, //!< synonym to UYVY
-
-  COLOR_YUV2RGB_YUY2 =
-      115, //!< convert between YUV YUY2 and RGB, YUV is 4:2:2-subsampled and
-           //!< interleaved as Y1/U/Y2/V, see @ref color_convert_rgb_yuv_42x
-  COLOR_YUV2BGR_YUY2 =
-      116, //!< convert between YUV YUY2 and BGR, YUV is 4:2:2-subsampled and
-           //!< interleaved as Y1/U/Y2/V, see @ref color_convert_rgb_yuv_42x
-  COLOR_YUV2RGB_YVYU =
-      117, //!< convert between YUV YVYU and RGB, YUV is 4:2:2-subsampled and
-           //!< interleaved as Y1/V/Y2/U, see @ref color_convert_rgb_yuv_42x
-  COLOR_YUV2BGR_YVYU =
-      118, //!< convert between YUV YVYU and BGR, YUV is 4:2:2-subsampled and
-           //!< interleaved as Y1/V/Y2/U, see @ref color_convert_rgb_yuv_42x
-  COLOR_YUV2RGB_YUYV = COLOR_YUV2RGB_YUY2, //!< synonym to YUY2
-  COLOR_YUV2BGR_YUYV = COLOR_YUV2BGR_YUY2, //!< synonym to YUY2
-  COLOR_YUV2RGB_YUNV = COLOR_YUV2RGB_YUY2, //!< synonym to YUY2
-  COLOR_YUV2BGR_YUNV = COLOR_YUV2BGR_YUY2, //!< synonym to YUY2
-
-  COLOR_YUV2RGBA_YUY2 =
-      119, //!< convert between YUV YUY2 and RGBA, YUV is 4:2:2-subsampled and
-           //!< interleaved as Y1/U/Y2/V, see @ref color_convert_rgb_yuv_42x
-  COLOR_YUV2BGRA_YUY2 =
-      120, //!< convert between YUV YUY2 and BGRA, YUV is 4:2:2-subsampled and
-           //!< interleaved as Y1/U/Y2/V, see @ref color_convert_rgb_yuv_42x
-  COLOR_YUV2RGBA_YVYU =
-      121, //!< convert between YUV YVYU and RGBA, YUV is 4:2:2-subsampled and
-           //!< interleaved as Y1/V/Y2/U, see @ref color_convert_rgb_yuv_42x
-  COLOR_YUV2BGRA_YVYU =
-      122, //!< convert between YUV YVYU and BGRA, YUV is 4:2:2-subsampled and
-           //!< interleaved as Y1/V/Y2/U, see @ref color_convert_rgb_yuv_42x
-  COLOR_YUV2RGBA_YUYV = COLOR_YUV2RGBA_YUY2, //!< synonym to YUY2
-  COLOR_YUV2BGRA_YUYV = COLOR_YUV2BGRA_YUY2, //!< synonym to YUY2
-  COLOR_YUV2RGBA_YUNV = COLOR_YUV2RGBA_YUY2, //!< synonym to YUY2
-  COLOR_YUV2BGRA_YUNV = COLOR_YUV2BGRA_YUY2, //!< synonym to YUY2
-
-  COLOR_YUV2GRAY_UYVY = 123, //!< extract Y channel from YUV 4:2:2 image
-  COLOR_YUV2GRAY_YUY2 = 124, //!< extract Y channel from YUV 4:2:2 image
-  // CV_YUV2GRAY_VYUY  = CV_YUV2GRAY_UYVY, //!< synonym to COLOR_YUV2GRAY_UYVY
-  COLOR_YUV2GRAY_Y422 = COLOR_YUV2GRAY_UYVY, //!< synonym to COLOR_YUV2GRAY_UYVY
-  COLOR_YUV2GRAY_UYNV = COLOR_YUV2GRAY_UYVY, //!< synonym to COLOR_YUV2GRAY_UYVY
-  COLOR_YUV2GRAY_YVYU = COLOR_YUV2GRAY_YUY2, //!< synonym to COLOR_YUV2GRAY_YUY2
-  COLOR_YUV2GRAY_YUYV = COLOR_YUV2GRAY_YUY2, //!< synonym to COLOR_YUV2GRAY_YUY2
-  COLOR_YUV2GRAY_YUNV = COLOR_YUV2GRAY_YUY2, //!< synonym to COLOR_YUV2GRAY_YUY2
-
-  //! alpha premultiplication
-  COLOR_RGBA2mRGBA = 125,
-  COLOR_mRGBA2RGBA = 126,
-
-  COLOR_RGB2YUV_I420 =
-      127, //!< convert between RGB and 4:2:0-subsampled YUV I420, three planes
-           //!< in one array: Y, U and V, see @ref color_convert_rgb_yuv_42x
-  COLOR_BGR2YUV_I420 =
-      128, //!< convert between BGR and 4:2:0-subsampled YUV I420, three planes
-           //!< in one array: Y, U and V, see @ref color_convert_rgb_yuv_42x
-  COLOR_RGB2YUV_IYUV = COLOR_RGB2YUV_I420, //!< synonym to I420
-  COLOR_BGR2YUV_IYUV = COLOR_BGR2YUV_I420, //!< synonym to I420
-
-  COLOR_RGBA2YUV_I420 =
-      129, //!< convert between RGBA and 4:2:0-subsampled YUV I420, three planes
-           //!< in one array: Y, U and V, see @ref color_convert_rgb_yuv_42x
-  COLOR_BGRA2YUV_I420 =
-      130, //!< convert between BGRA and 4:2:0-subsampled YUV I420, three planes
-           //!< in one array: Y, U and V, see @ref color_convert_rgb_yuv_42x
-  COLOR_RGBA2YUV_IYUV = COLOR_RGBA2YUV_I420, //!< synonym to I420
-  COLOR_BGRA2YUV_IYUV = COLOR_BGRA2YUV_I420, //!< synonym to I420
-  COLOR_RGB2YUV_YV12 =
-      131, //!< convert between RGB and 4:2:0-subsampled YUV YV12, three planes
-           //!< in one array: Y, V and U, see @ref color_convert_rgb_yuv_42x
-  COLOR_BGR2YUV_YV12 =
-      132, //!< convert between BGR and 4:2:0-subsampled YUV YV12, three planes
-           //!< in one array: Y, V and U, see @ref color_convert_rgb_yuv_42x
-  COLOR_RGBA2YUV_YV12 =
-      133, //!< convert between RGBA and 4:2:0-subsampled YUV YV12, three planes
-           //!< in one array: Y, V and U, see @ref color_convert_rgb_yuv_42x
-  COLOR_BGRA2YUV_YV12 =
-      134, //!< convert between BGRA and 4:2:0-subsampled YUV YV12, three planes
-           //!< in one array: Y, V and U, see @ref color_convert_rgb_yuv_42x
-
-  //! Demosaicing, see @ref color_convert_bayer "color conversions" for
-  //! additional information
-  COLOR_BayerBG2BGR = 46, //!< equivalent to RGGB Bayer pattern
-  COLOR_BayerGB2BGR = 47, //!< equivalent to GRBG Bayer pattern
-  COLOR_BayerRG2BGR = 48, //!< equivalent to BGGR Bayer pattern
-  COLOR_BayerGR2BGR = 49, //!< equivalent to GBRG Bayer pattern
-
-  COLOR_BayerRGGB2BGR = COLOR_BayerBG2BGR,
-  COLOR_BayerGRBG2BGR = COLOR_BayerGB2BGR,
-  COLOR_BayerBGGR2BGR = COLOR_BayerRG2BGR,
-  COLOR_BayerGBRG2BGR = COLOR_BayerGR2BGR,
-
-  COLOR_BayerRGGB2RGB = COLOR_BayerBGGR2BGR,
-  COLOR_BayerGRBG2RGB = COLOR_BayerGBRG2BGR,
-  COLOR_BayerBGGR2RGB = COLOR_BayerRGGB2BGR,
-  COLOR_BayerGBRG2RGB = COLOR_BayerGRBG2BGR,
-
-  COLOR_BayerBG2RGB = COLOR_BayerRG2BGR, //!< equivalent to RGGB Bayer pattern
-  COLOR_BayerGB2RGB = COLOR_BayerGR2BGR, //!< equivalent to GRBG Bayer pattern
-  COLOR_BayerRG2RGB = COLOR_BayerBG2BGR, //!< equivalent to BGGR Bayer pattern
-  COLOR_BayerGR2RGB = COLOR_BayerGB2BGR, //!< equivalent to GBRG Bayer pattern
-
-  COLOR_BayerBG2GRAY = 86, //!< equivalent to RGGB Bayer pattern
-  COLOR_BayerGB2GRAY = 87, //!< equivalent to GRBG Bayer pattern
-  COLOR_BayerRG2GRAY = 88, //!< equivalent to BGGR Bayer pattern
-  COLOR_BayerGR2GRAY = 89, //!< equivalent to GBRG Bayer pattern
-
-  COLOR_BayerRGGB2GRAY = COLOR_BayerBG2GRAY,
-  COLOR_BayerGRBG2GRAY = COLOR_BayerGB2GRAY,
-  COLOR_BayerBGGR2GRAY = COLOR_BayerRG2GRAY,
-  COLOR_BayerGBRG2GRAY = COLOR_BayerGR2GRAY,
-
-  //! Demosaicing using Variable Number of Gradients
-  COLOR_BayerBG2BGR_VNG = 62, //!< equivalent to RGGB Bayer pattern
-  COLOR_BayerGB2BGR_VNG = 63, //!< equivalent to GRBG Bayer pattern
-  COLOR_BayerRG2BGR_VNG = 64, //!< equivalent to BGGR Bayer pattern
-  COLOR_BayerGR2BGR_VNG = 65, //!< equivalent to GBRG Bayer pattern
-
-  COLOR_BayerRGGB2BGR_VNG = COLOR_BayerBG2BGR_VNG,
-  COLOR_BayerGRBG2BGR_VNG = COLOR_BayerGB2BGR_VNG,
-  COLOR_BayerBGGR2BGR_VNG = COLOR_BayerRG2BGR_VNG,
-  COLOR_BayerGBRG2BGR_VNG = COLOR_BayerGR2BGR_VNG,
-
-  COLOR_BayerRGGB2RGB_VNG = COLOR_BayerBGGR2BGR_VNG,
-  COLOR_BayerGRBG2RGB_VNG = COLOR_BayerGBRG2BGR_VNG,
-  COLOR_BayerBGGR2RGB_VNG = COLOR_BayerRGGB2BGR_VNG,
-  COLOR_BayerGBRG2RGB_VNG = COLOR_BayerGRBG2BGR_VNG,
-
-  COLOR_BayerBG2RGB_VNG =
-      COLOR_BayerRG2BGR_VNG, //!< equivalent to RGGB Bayer pattern
-  COLOR_BayerGB2RGB_VNG =
-      COLOR_BayerGR2BGR_VNG, //!< equivalent to GRBG Bayer pattern
-  COLOR_BayerRG2RGB_VNG =
-      COLOR_BayerBG2BGR_VNG, //!< equivalent to BGGR Bayer pattern
-  COLOR_BayerGR2RGB_VNG =
-      COLOR_BayerGB2BGR_VNG, //!< equivalent to GBRG Bayer pattern
-
-  //! Edge-Aware Demosaicing
-  COLOR_BayerBG2BGR_EA = 135, //!< equivalent to RGGB Bayer pattern
-  COLOR_BayerGB2BGR_EA = 136, //!< equivalent to GRBG Bayer pattern
-  COLOR_BayerRG2BGR_EA = 137, //!< equivalent to BGGR Bayer pattern
-  COLOR_BayerGR2BGR_EA = 138, //!< equivalent to GBRG Bayer pattern
-
-  COLOR_BayerRGGB2BGR_EA = COLOR_BayerBG2BGR_EA,
-  COLOR_BayerGRBG2BGR_EA = COLOR_BayerGB2BGR_EA,
-  COLOR_BayerBGGR2BGR_EA = COLOR_BayerRG2BGR_EA,
-  COLOR_BayerGBRG2BGR_EA = COLOR_BayerGR2BGR_EA,
-
-  COLOR_BayerRGGB2RGB_EA = COLOR_BayerBGGR2BGR_EA,
-  COLOR_BayerGRBG2RGB_EA = COLOR_BayerGBRG2BGR_EA,
-  COLOR_BayerBGGR2RGB_EA = COLOR_BayerRGGB2BGR_EA,
-  COLOR_BayerGBRG2RGB_EA = COLOR_BayerGRBG2BGR_EA,
-
-  COLOR_BayerBG2RGB_EA =
-      COLOR_BayerRG2BGR_EA, //!< equivalent to RGGB Bayer pattern
-  COLOR_BayerGB2RGB_EA =
-      COLOR_BayerGR2BGR_EA, //!< equivalent to GRBG Bayer pattern
-  COLOR_BayerRG2RGB_EA =
-      COLOR_BayerBG2BGR_EA, //!< equivalent to BGGR Bayer pattern
-  COLOR_BayerGR2RGB_EA =
-      COLOR_BayerGB2BGR_EA, //!< equivalent to GBRG Bayer pattern
-
-  //! Demosaicing with alpha channel
-  COLOR_BayerBG2BGRA = 139, //!< equivalent to RGGB Bayer pattern
-  COLOR_BayerGB2BGRA = 140, //!< equivalent to GRBG Bayer pattern
-  COLOR_BayerRG2BGRA = 141, //!< equivalent to BGGR Bayer pattern
-  COLOR_BayerGR2BGRA = 142, //!< equivalent to GBRG Bayer pattern
-
-  COLOR_BayerRGGB2BGRA = COLOR_BayerBG2BGRA,
-  COLOR_BayerGRBG2BGRA = COLOR_BayerGB2BGRA,
-  COLOR_BayerBGGR2BGRA = COLOR_BayerRG2BGRA,
-  COLOR_BayerGBRG2BGRA = COLOR_BayerGR2BGRA,
-
-  COLOR_BayerRGGB2RGBA = COLOR_BayerBGGR2BGRA,
-  COLOR_BayerGRBG2RGBA = COLOR_BayerGBRG2BGRA,
-  COLOR_BayerBGGR2RGBA = COLOR_BayerRGGB2BGRA,
-  COLOR_BayerGBRG2RGBA = COLOR_BayerGRBG2BGRA,
-
-  COLOR_BayerBG2RGBA = COLOR_BayerRG2BGRA, //!< equivalent to RGGB Bayer pattern
-  COLOR_BayerGB2RGBA = COLOR_BayerGR2BGRA, //!< equivalent to GRBG Bayer pattern
-  COLOR_BayerRG2RGBA = COLOR_BayerBG2BGRA, //!< equivalent to BGGR Bayer pattern
-  COLOR_BayerGR2RGBA = COLOR_BayerGB2BGRA, //!< equivalent to GBRG Bayer pattern
-
-  COLOR_RGB2YUV_UYVY =
-      143, //!< convert between RGB and YUV UYVU, YUV is 4:2:2 and interleaved
-           //!< as U/Y1/V/Y2, see @ref color_convert_rgb_yuv_42x
-  COLOR_BGR2YUV_UYVY =
-      144, //!< convert between BGR and YUV UYVU, YUV is 4:2:2 and interleaved
-           //!< as U/Y1/V/Y2, see @ref color_convert_rgb_yuv_42x
-  COLOR_RGB2YUV_Y422 = COLOR_RGB2YUV_UYVY, //!< synonym to UYVY
-  COLOR_BGR2YUV_Y422 = COLOR_BGR2YUV_UYVY, //!< synonym to UYVY
-  COLOR_RGB2YUV_UYNV = COLOR_RGB2YUV_UYVY, //!< synonym to UYVY
-  COLOR_BGR2YUV_UYNV = COLOR_BGR2YUV_UYVY, //!< synonym to UYVY
-
-  COLOR_RGBA2YUV_UYVY =
-      145, //!< convert between RGBA and YUV UYVU, YUV is 4:2:2 and interleaved
-           //!< as U/Y1/V/Y2, see @ref color_convert_rgb_yuv_42x
-  COLOR_BGRA2YUV_UYVY =
-      146, //!< convert between BGRA and YUV UYVU, YUV is 4:2:2 and interleaved
-           //!< as U/Y1/V/Y2, see @ref color_convert_rgb_yuv_42x
-  COLOR_RGBA2YUV_Y422 = COLOR_RGBA2YUV_UYVY, //!< synonym to UYVY
-  COLOR_BGRA2YUV_Y422 = COLOR_BGRA2YUV_UYVY, //!< synonym to UYVY
-  COLOR_RGBA2YUV_UYNV = COLOR_RGBA2YUV_UYVY, //!< synonym to UYVY
-  COLOR_BGRA2YUV_UYNV = COLOR_BGRA2YUV_UYVY, //!< synonym to UYVY
-
-  COLOR_RGB2YUV_YUY2 =
-      147, //!< convert between RGB and YUV YUY2, YUV is 4:2:2 and interleaved
-           //!< as Y1/U/Y2/V, see @ref color_convert_rgb_yuv_42x
-  COLOR_BGR2YUV_YUY2 =
-      148, //!< convert between BGR and YUV YUY2, YUV is 4:2:2 and interleaved
-           //!< as Y1/U/Y2/V, see @ref color_convert_rgb_yuv_42x
-  COLOR_RGB2YUV_YVYU =
-      149, //!< convert between RGB and YUV YVYU, YUV is 4:2:2 and interleaved
-           //!< as Y1/V/Y2/U, see @ref color_convert_rgb_yuv_42x
-  COLOR_BGR2YUV_YVYU =
-      150, //!< convert between BGR and YUV YVYU, YUV is 4:2:2 and interleaved
-           //!< as Y1/V/Y2/U, see @ref color_convert_rgb_yuv_42x
-  COLOR_RGB2YUV_YUYV = COLOR_RGB2YUV_YUY2, //!< synonym to YUY2
-  COLOR_BGR2YUV_YUYV = COLOR_BGR2YUV_YUY2, //!< synonym to YUY2
-  COLOR_RGB2YUV_YUNV = COLOR_RGB2YUV_YUY2, //!< synonym to YUY2
-  COLOR_BGR2YUV_YUNV = COLOR_BGR2YUV_YUY2, //!< synonym to YUY2
-
-  COLOR_RGBA2YUV_YUY2 =
-      151, //!< convert between RGBA and YUV YUY2, YUV is 4:2:2 and interleaved
-           //!< as Y1/U/Y2/V, see @ref color_convert_rgb_yuv_42x
-  COLOR_BGRA2YUV_YUY2 =
-      152, //!< convert between BGRA and YUV YUY2, YUV is 4:2:2 and interleaved
-           //!< as Y1/U/Y2/V, see @ref color_convert_rgb_yuv_42x
-  COLOR_RGBA2YUV_YVYU =
-      153, //!< convert between RGBA and YUV YVYU, YUV is 4:2:2 and interleaved
-           //!< as Y1/V/Y2/U, see @ref color_convert_rgb_yuv_42x
-  COLOR_BGRA2YUV_YVYU =
-      154, //!< convert between BGRA and YUV YVYU, YUV is 4:2:2 and interleaved
-           //!< as Y1/V/Y2/U, see @ref color_convert_rgb_yuv_42x
-  COLOR_RGBA2YUV_YUYV = COLOR_RGBA2YUV_YUY2, //!< synonym to YUY2
-  COLOR_BGRA2YUV_YUYV = COLOR_BGRA2YUV_YUY2, //!< synonym to YUY2
-  COLOR_RGBA2YUV_YUNV = COLOR_RGBA2YUV_YUY2, //!< synonym to YUY2
-  COLOR_BGRA2YUV_YUNV = COLOR_BGRA2YUV_YUY2, //!< synonym to YUY2
-
-  COLOR_COLORCVT_MAX = 155
-};
-
-//! @addtogroup imgproc_shape
-//! @{
-
-//! types of intersection between rectangles
-enum RectanglesIntersectTypes {
-  INTERSECT_NONE = 0,    //!< No intersection
-  INTERSECT_PARTIAL = 1, //!< There is a partial intersection
-  INTERSECT_FULL = 2 //!< One of the rectangle is fully enclosed in the other
-};
-
-/** types of line
-@ingroup imgproc_draw
-*/
-enum LineTypes {
-  FILLED = -1,
-  LINE_4 = 4,  //!< 4-connected line
-  LINE_8 = 8,  //!< 8-connected line
-  LINE_AA = 16 //!< antialiased line
-};
-
-/** Only a subset of Hershey fonts <https://en.wikipedia.org/wiki/Hershey_fonts>
-are supported
-@ingroup imgproc_draw
-*/
-enum HersheyFonts {
-  FONT_HERSHEY_SIMPLEX = 0, //!< normal size sans-serif font
-  FONT_HERSHEY_PLAIN = 1,   //!< small size sans-serif font
-  FONT_HERSHEY_DUPLEX = 2,  //!< normal size sans-serif font (more complex than
-                            //!< FONT_HERSHEY_SIMPLEX)
-  FONT_HERSHEY_COMPLEX = 3, //!< normal size serif font
-  FONT_HERSHEY_TRIPLEX =
-      4, //!< normal size serif font (more complex than FONT_HERSHEY_COMPLEX)
-  FONT_HERSHEY_COMPLEX_SMALL = 5,  //!< smaller version of FONT_HERSHEY_COMPLEX
-  FONT_HERSHEY_SCRIPT_SIMPLEX = 6, //!< hand-writing style font
-  FONT_HERSHEY_SCRIPT_COMPLEX =
-      7,           //!< more complex variant of FONT_HERSHEY_SCRIPT_SIMPLEX
-  FONT_ITALIC = 16 //!< flag for italic font
-};
-
-/** Possible set of marker types used for the cv::drawMarker function
-@ingroup imgproc_draw
-*/
-enum MarkerTypes {
-  MARKER_CROSS = 0,        //!< A crosshair marker shape
-  MARKER_TILTED_CROSS = 1, //!< A 45 degree tilted crosshair marker shape
-  MARKER_STAR =
-      2, //!< A star marker shape, combination of cross and tilted cross
-  MARKER_DIAMOND = 3,      //!< A diamond marker shape
-  MARKER_SQUARE = 4,       //!< A square marker shape
-  MARKER_TRIANGLE_UP = 5,  //!< An upwards pointing triangle marker shape
-  MARKER_TRIANGLE_DOWN = 6 //!< A downwards pointing triangle marker shape
-};
-
-/** @brief finds arbitrary template in the grayscale image using Generalized
- * Hough Transform
- */
-class CV_EXPORTS_W GeneralizedHough : public Algorithm {
-public:
-  //! set template to search
-  CV_WRAP virtual void setTemplate(InputArray templ,
-                                   Point templCenter = Point(-1, -1)) = 0;
-  CV_WRAP virtual void setTemplate(InputArray edges, InputArray dx,
-                                   InputArray dy,
-                                   Point templCenter = Point(-1, -1)) = 0;
-
-  //! find template on image
-  CV_WRAP virtual void detect(InputArray image, OutputArray positions,
-                              OutputArray votes = noArray()) = 0;
-  CV_WRAP virtual void detect(InputArray edges, InputArray dx, InputArray dy,
-                              OutputArray positions,
-                              OutputArray votes = noArray()) = 0;
-
-  //! Canny low threshold.
-  CV_WRAP virtual void setCannyLowThresh(int cannyLowThresh) = 0;
-  CV_WRAP virtual int getCannyLowThresh() const = 0;
-
-  //! Canny high threshold.
-  CV_WRAP virtual void setCannyHighThresh(int cannyHighThresh) = 0;
-  CV_WRAP virtual int getCannyHighThresh() const = 0;
-
-  //! Minimum distance between the centers of the detected objects.
-  CV_WRAP virtual void setMinDist(double minDist) = 0;
-  CV_WRAP virtual double getMinDist() const = 0;
-
-  //! Inverse ratio of the accumulator resolution to the image resolution.
-  CV_WRAP virtual void setDp(double dp) = 0;
-  CV_WRAP virtual double getDp() const = 0;
-
-  //! Maximal size of inner buffers.
-  CV_WRAP virtual void setMaxBufferSize(int maxBufferSize) = 0;
-  CV_WRAP virtual int getMaxBufferSize() const = 0;
-};
-
-/** @brief finds arbitrary template in the grayscale image using Generalized
-Hough Transform
-
-Detects position only without translation and rotation @cite Ballard1981 .
-*/
-class CV_EXPORTS_W GeneralizedHoughBallard : public GeneralizedHough {
-public:
-  //! R-Table levels.
-  CV_WRAP virtual void setLevels(int levels) = 0;
-  CV_WRAP virtual int getLevels() const = 0;
-
-  //! The accumulator threshold for the template centers at the detection stage.
-  //! The smaller it is, the more false positions may be detected.
-  CV_WRAP virtual void setVotesThreshold(int votesThreshold) = 0;
-  CV_WRAP virtual int getVotesThreshold() const = 0;
-};
-
-/** @brief finds arbitrary template in the grayscale image using Generalized
-Hough Transform
-
-Detects position, translation and rotation @cite Guil1999 .
-*/
-class CV_EXPORTS_W GeneralizedHoughGuil : public GeneralizedHough {
-public:
-  //! Angle difference in degrees between two points in feature.
-  CV_WRAP virtual void setXi(double xi) = 0;
-  CV_WRAP virtual double getXi() const = 0;
-
-  //! Feature table levels.
-  CV_WRAP virtual void setLevels(int levels) = 0;
-  CV_WRAP virtual int getLevels() const = 0;
-
-  //! Maximal difference between angles that treated as equal.
-  CV_WRAP virtual void setAngleEpsilon(double angleEpsilon) = 0;
-  CV_WRAP virtual double getAngleEpsilon() const = 0;
-
-  //! Minimal rotation angle to detect in degrees.
-  CV_WRAP virtual void setMinAngle(double minAngle) = 0;
-  CV_WRAP virtual double getMinAngle() const = 0;
-
-  //! Maximal rotation angle to detect in degrees.
-  CV_WRAP virtual void setMaxAngle(double maxAngle) = 0;
-  CV_WRAP virtual double getMaxAngle() const = 0;
-
-  //! Angle step in degrees.
-  CV_WRAP virtual void setAngleStep(double angleStep) = 0;
-  CV_WRAP virtual double getAngleStep() const = 0;
-
-  //! Angle votes threshold.
-  CV_WRAP virtual void setAngleThresh(int angleThresh) = 0;
-  CV_WRAP virtual int getAngleThresh() const = 0;
-
-  //! Minimal scale to detect.
-  CV_WRAP virtual void setMinScale(double minScale) = 0;
-  CV_WRAP virtual double getMinScale() const = 0;
-
-  //! Maximal scale to detect.
-  CV_WRAP virtual void setMaxScale(double maxScale) = 0;
-  CV_WRAP virtual double getMaxScale() const = 0;
-
-  //! Scale step.
-  CV_WRAP virtual void setScaleStep(double scaleStep) = 0;
-  CV_WRAP virtual double getScaleStep() const = 0;
-
-  //! Scale votes threshold.
-  CV_WRAP virtual void setScaleThresh(int scaleThresh) = 0;
-  CV_WRAP virtual int getScaleThresh() const = 0;
-
-  //! Position votes threshold.
-  CV_WRAP virtual void setPosThresh(int posThresh) = 0;
-  CV_WRAP virtual int getPosThresh() const = 0;
-};
-
-//! @} imgproc_shape
-
-//! @addtogroup imgproc_hist
-//! @{
-
-/** @brief Base class for Contrast Limited Adaptive Histogram Equalization.
- */
-class CV_EXPORTS_W CLAHE : public Algorithm {
-public:
-  /** @brief Equalizes the histogram of a grayscale image using Contrast Limited
-  Adaptive Histogram Equalization.
-
-  @param src Source image of type CV_8UC1 or CV_16UC1.
-  @param dst Destination image.
-   */
-  CV_WRAP virtual void apply(InputArray src, OutputArray dst) = 0;
-
-  /** @brief Sets threshold for contrast limiting.
-
-  @param clipLimit threshold value.
-  */
-  CV_WRAP virtual void setClipLimit(double clipLimit) = 0;
-
-  //! Returns threshold value for contrast limiting.
-  CV_WRAP virtual double getClipLimit() const = 0;
-
-  /** @brief Sets size of grid for histogram equalization. Input image will be
-  divided into equally sized rectangular tiles.
-
-  @param tileGridSize defines the number of tiles in row and column.
-  */
-  CV_WRAP virtual void setTilesGridSize(Size tileGridSize) = 0;
-
-  //!@brief Returns Size defines the number of tiles in row and column.
-  CV_WRAP virtual Size getTilesGridSize() const = 0;
-
-  CV_WRAP virtual void collectGarbage() = 0;
-};
-
-//! @} imgproc_hist
-
-//! @addtogroup imgproc_subdiv2d
-//! @{
-
-class CV_EXPORTS_W Subdiv2D {
-public:
-  /** Subdiv2D point location cases */
-  enum {
-    PTLOC_ERROR = -2,        //!< Point location error
-    PTLOC_OUTSIDE_RECT = -1, //!< Point outside the subdivision bounding rect
-    PTLOC_INSIDE = 0,        //!< Point inside some facet
-    PTLOC_VERTEX = 1, //!< Point coincides with one of the subdivision vertices
-    PTLOC_ON_EDGE = 2 //!< Point on some edge
-  };
-
-  /** Subdiv2D edge type navigation (see: getEdge()) */
-  enum {
-    NEXT_AROUND_ORG = 0x00,
-    NEXT_AROUND_DST = 0x22,
-    PREV_AROUND_ORG = 0x11,
-    PREV_AROUND_DST = 0x33,
-    NEXT_AROUND_LEFT = 0x13,
-    NEXT_AROUND_RIGHT = 0x31,
-    PREV_AROUND_LEFT = 0x20,
-    PREV_AROUND_RIGHT = 0x02
-  };
-
-  /** creates an empty Subdiv2D object.
-  To create a new empty Delaunay subdivision you need to use the #initDelaunay
-  function.
-   */
-  CV_WRAP Subdiv2D();
-
-  /** @overload
-
-  @param rect Rectangle that includes all of the 2D points that are to be added
-  to the subdivision.
-
-  The function creates an empty Delaunay subdivision where 2D points can be
-  added using the function insert() . All of the points to be added must be
-  within the specified rectangle, otherwise a runtime error is raised.
-   */
-  CV_WRAP Subdiv2D(Rect rect);
-
-  /** @brief Creates a new empty Delaunay subdivision
-
-  @param rect Rectangle that includes all of the 2D points that are to be added
-  to the subdivision.
-
-   */
-  CV_WRAP void initDelaunay(Rect rect);
-
-  /** @brief Insert a single point into a Delaunay triangulation.
-
-  @param pt Point to insert.
-
-  The function inserts a single point into a subdivision and modifies the
-  subdivision topology appropriately. If a point with the same coordinates
-  exists already, no new point is added.
-  @returns the ID of the point.
-
-  @note If the point is outside of the triangulation specified rect a runtime
-  error is raised.
-   */
-  CV_WRAP int insert(Point2f pt);
-
-  /** @brief Insert multiple points into a Delaunay triangulation.
-
-  @param ptvec Points to insert.
-
-  The function inserts a vector of points into a subdivision and modifies the
-  subdivision topology appropriately.
-   */
-  CV_WRAP void insert(const std::vector<Point2f> &ptvec);
-
-  /** @brief Returns the location of a point within a Delaunay triangulation.
-
-  @param pt Point to locate.
-  @param edge Output edge that the point belongs to or is located to the right
-  of it.
-  @param vertex Optional output vertex the input point coincides with.
-
-  The function locates the input point within the subdivision and gives one of
-  the triangle edges or vertices.
-
-  @returns an integer which specify one of the following five cases for point
-  location:
-  -  The point falls into some facet. The function returns #PTLOC_INSIDE and
-  edge will contain one of edges of the facet.
-  -  The point falls onto the edge. The function returns #PTLOC_ON_EDGE and edge
-  will contain this edge.
-  -  The point coincides with one of the subdivision vertices. The function
-  returns #PTLOC_VERTEX and vertex will contain a pointer to the vertex.
-  -  The point is outside the subdivision reference rectangle. The function
-  returns #PTLOC_OUTSIDE_RECT and no pointers are filled.
-  -  One of input arguments is invalid. A runtime error is raised or, if silent
-  or "parent" error processing mode is selected, #PTLOC_ERROR is returned.
-   */
-  CV_WRAP int locate(Point2f pt, CV_OUT int &edge, CV_OUT int &vertex);
-
-  /** @brief Finds the subdivision vertex closest to the given point.
-
-  @param pt Input point.
-  @param nearestPt Output subdivision vertex point.
-
-  The function is another function that locates the input point within the
-  subdivision. It finds the subdivision vertex that is the closest to the input
-  point. It is not necessarily one of vertices of the facet containing the input
-  point, though the facet (located using locate() ) is used as a starting point.
-
-  @returns vertex ID.
-   */
-  CV_WRAP int findNearest(Point2f pt, CV_OUT Point2f *nearestPt = 0);
-
-  /** @brief Returns a list of all edges.
-
-  @param edgeList Output vector.
-
-  The function gives each edge as a 4 numbers vector, where each two are one of
-  the edge vertices. i.e. org_x = v[0], org_y = v[1], dst_x = v[2], dst_y =
-  v[3].
-   */
-  CV_WRAP void getEdgeList(CV_OUT std::vector<Vec4f> &edgeList) const;
-
-  /** @brief Returns a list of the leading edge ID connected to each triangle.
-
-  @param leadingEdgeList Output vector.
-
-  The function gives one edge ID for each triangle.
-   */
-  CV_WRAP void
-  getLeadingEdgeList(CV_OUT std::vector<int> &leadingEdgeList) const;
-
-  /** @brief Returns a list of all triangles.
-
-  @param triangleList Output vector.
-
-  The function gives each triangle as a 6 numbers vector, where each two are one
-  of the triangle vertices. i.e. p1_x = v[0], p1_y = v[1], p2_x = v[2], p2_y =
-  v[3], p3_x = v[4], p3_y = v[5].
-   */
-  CV_WRAP void getTriangleList(CV_OUT std::vector<Vec6f> &triangleList) const;
-
-  /** @brief Returns a list of all Voronoi facets.
-
-  @param idx Vector of vertices IDs to consider. For all vertices you can pass
-  empty vector.
-  @param facetList Output vector of the Voronoi facets.
-  @param facetCenters Output vector of the Voronoi facets center points.
-
-   */
-  CV_WRAP void
-  getVoronoiFacetList(const std::vector<int> &idx,
-                      CV_OUT std::vector<std::vector<Point2f>> &facetList,
-                      CV_OUT std::vector<Point2f> &facetCenters);
-
-  /** @brief Returns vertex location from vertex ID.
-
-  @param vertex vertex ID.
-  @param firstEdge Optional. The first edge ID which is connected to the vertex.
-  @returns vertex (x,y)
-
-   */
-  CV_WRAP Point2f getVertex(int vertex, CV_OUT int *firstEdge = 0) const;
-
-  /** @brief Returns one of the edges related to the given edge.
-
-  @param edge Subdivision edge ID.
-  @param nextEdgeType Parameter specifying which of the related edges to return.
-  The following values are possible:
-  -   NEXT_AROUND_ORG next around the edge origin ( eOnext on the picture below
-  if e is the input edge)
-  -   NEXT_AROUND_DST next around the edge vertex ( eDnext )
-  -   PREV_AROUND_ORG previous around the edge origin (reversed eRnext )
-  -   PREV_AROUND_DST previous around the edge destination (reversed eLnext )
-  -   NEXT_AROUND_LEFT next around the left facet ( eLnext )
-  -   NEXT_AROUND_RIGHT next around the right facet ( eRnext )
-  -   PREV_AROUND_LEFT previous around the left facet (reversed eOnext )
-  -   PREV_AROUND_RIGHT previous around the right facet (reversed eDnext )
-
-  ![sample output](pics/quadedge.png)
-
-  @returns edge ID related to the input edge.
-   */
-  CV_WRAP int getEdge(int edge, int nextEdgeType) const;
-
-  /** @brief Returns next edge around the edge origin.
-
-  @param edge Subdivision edge ID.
-
-  @returns an integer which is next edge ID around the edge origin: eOnext on
-  the picture above if e is the input edge).
-   */
-  CV_WRAP int nextEdge(int edge) const;
-
-  /** @brief Returns another edge of the same quad-edge.
-
-  @param edge Subdivision edge ID.
-  @param rotate Parameter specifying which of the edges of the same quad-edge as
-  the input one to return. The following values are possible:
-  -   0 - the input edge ( e on the picture below if e is the input edge)
-  -   1 - the rotated edge ( eRot )
-  -   2 - the reversed edge (reversed e (in green))
-  -   3 - the reversed rotated edge (reversed eRot (in green))
-
-  @returns one of the edges ID of the same quad-edge as the input edge.
-   */
-  CV_WRAP int rotateEdge(int edge, int rotate) const;
-  CV_WRAP int symEdge(int edge) const;
-
-  /** @brief Returns the edge origin.
-
-  @param edge Subdivision edge ID.
-  @param orgpt Output vertex location.
-
-  @returns vertex ID.
-   */
-  CV_WRAP int edgeOrg(int edge, CV_OUT Point2f *orgpt = 0) const;
-
-  /** @brief Returns the edge destination.
-
-  @param edge Subdivision edge ID.
-  @param dstpt Output vertex location.
-
-  @returns vertex ID.
-   */
-  CV_WRAP int edgeDst(int edge, CV_OUT Point2f *dstpt = 0) const;
-
-protected:
-  int newEdge();
-  void deleteEdge(int edge);
-  int newPoint(Point2f pt, bool isvirtual, int firstEdge = 0);
-  void deletePoint(int vtx);
-  void setEdgePoints(int edge, int orgPt, int dstPt);
-  void splice(int edgeA, int edgeB);
-  int connectEdges(int edgeA, int edgeB);
-  void swapEdges(int edge);
-  int isRightOf(Point2f pt, int edge) const;
-  void calcVoronoi();
-  void clearVoronoi();
-  void checkSubdiv() const;
-
-  struct CV_EXPORTS Vertex {
-    Vertex();
-    Vertex(Point2f pt, bool isvirtual, int firstEdge = 0);
-    bool isvirtual() const;
-    bool isfree() const;
-
-    int firstEdge;
-    int type;
-    Point2f pt;
-  };
-
-  struct CV_EXPORTS QuadEdge {
-    QuadEdge();
-    QuadEdge(int edgeidx);
-    bool isfree() const;
-
-    int next[4];
-    int pt[4];
-  };
-
-  //! All of the vertices
-  std::vector<Vertex> vtx;
-  //! All of the edges
-  std::vector<QuadEdge> qedges;
-  int freeQEdge;
-  int freePoint;
-  bool validGeometry;
-
-  int recentEdge;
-  //! Top left corner of the bounding rect
-  Point2f topLeft;
-  //! Bottom right corner of the bounding rect
-  Point2f bottomRight;
-};
-
-//! @} imgproc_subdiv2d
-
-//! @addtogroup imgproc_feature
-//! @{
-
-/** @example samples/cpp/lsd_lines.cpp
-An example using the LineSegmentDetector
-\image html building_lsd.png "Sample output image" width=434 height=300
-*/
-
-/** @brief Line segment detector class
-
-following the algorithm described at @cite Rafael12 .
-
-@note Implementation has been removed from OpenCV version 3.4.6 to 3.4.15 and
-version 4.1.0 to 4.5.3 due original code license conflict. restored again after
-[Computation of a NFA](https://github.com/rafael-grompone-von-gioi/binomial_nfa)
-code published under the MIT license.
-*/
-class CV_EXPORTS_W LineSegmentDetector : public Algorithm {
-public:
-  /** @brief Finds lines in the input image.
-
-  This is the output of the default parameters of the algorithm on the above
-  shown image.
-
-  ![image](pics/building_lsd.png)
-
-  @param image A grayscale (CV_8UC1) input image. If only a roi needs to be
-  selected, use: `lsd_ptr-\>detect(image(roi), lines, ...); lines +=
-  Scalar(roi.x, roi.y, roi.x, roi.y);`
-  @param lines A vector of Vec4f elements specifying the beginning and ending
-  point of a line. Where Vec4f is (x1, y1, x2, y2), point 1 is the start, point
-  2 - end. Returned lines are strictly oriented depending on the gradient.
-  @param width Vector of widths of the regions, where the lines are found. E.g.
-  Width of line.
-  @param prec Vector of precisions with which the lines are found.
-  @param nfa Vector containing number of false alarms in the line region, with
-  precision of 10%. The bigger the value, logarithmically better the detection.
-  - -1 corresponds to 10 mean false alarms
-  - 0 corresponds to 1 mean false alarm
-  - 1 corresponds to 0.1 mean false alarms
-  This vector will be calculated only when the objects type is #LSD_REFINE_ADV.
-  */
-  CV_WRAP virtual void detect(InputArray image, OutputArray lines,
-                              OutputArray width = noArray(),
-                              OutputArray prec = noArray(),
-                              OutputArray nfa = noArray()) = 0;
-
-  /** @brief Draws the line segments on a given image.
-  @param image The image, where the lines will be drawn. Should be bigger or
-  equal to the image, where the lines were found.
-  @param lines A vector of the lines that needed to be drawn.
-   */
-  CV_WRAP virtual void drawSegments(InputOutputArray image,
-                                    InputArray lines) = 0;
-
-  /** @brief Draws two groups of lines in blue and red, counting the non
-  overlapping (mismatching) pixels.
-
-  @param size The size of the image, where lines1 and lines2 were found.
-  @param lines1 The first group of lines that needs to be drawn. It is
-  visualized in blue color.
-  @param lines2 The second group of lines. They visualized in red color.
-  @param image Optional image, where the lines will be drawn. The image should
-  be color(3-channel) in order for lines1 and lines2 to be drawn in the above
-  mentioned colors.
-   */
-  CV_WRAP virtual int compareSegments(const Size &size, InputArray lines1,
-                                      InputArray lines2,
-                                      InputOutputArray image = noArray()) = 0;
-
-  virtual ~LineSegmentDetector() {}
-};
-
-/** @brief Creates a smart pointer to a LineSegmentDetector object and
-initializes it.
-
-The LineSegmentDetector algorithm is defined using the standard values. Only
-advanced users may want to edit those, as to tailor it for their own
-application.
-
-@param refine The way found lines will be refined, see #LineSegmentDetectorModes
-@param scale The scale of the image that will be used to find the lines. Range
-(0..1].
-@param sigma_scale Sigma for Gaussian filter. It is computed as sigma =
-sigma_scale/scale.
-@param quant Bound to the quantization error on the gradient norm.
-@param ang_th Gradient angle tolerance in degrees.
-@param log_eps Detection threshold: -log10(NFA) \> log_eps. Used only when
-advance refinement is chosen.
-@param density_th Minimal density of aligned region points in the enclosing
-rectangle.
-@param n_bins Number of bins in pseudo-ordering of gradient modulus.
- */
-CV_EXPORTS_W Ptr<LineSegmentDetector>
-createLineSegmentDetector(int refine = LSD_REFINE_STD, double scale = 0.8,
-                          double sigma_scale = 0.6, double quant = 2.0,
-                          double ang_th = 22.5, double log_eps = 0,
-                          double density_th = 0.7, int n_bins = 1024);
-
-//! @} imgproc_feature
-
-//! @addtogroup imgproc_filter
-//! @{
-
-/** @brief Returns Gaussian filter coefficients.
-
-The function computes and returns the \f$\texttt{ksize} \times 1\f$ matrix of
-Gaussian filter coefficients:
-
-\f[G_i= \alpha *e^{-(i-( \texttt{ksize} -1)/2)^2/(2* \texttt{sigma}^2)},\f]
-
-where \f$i=0..\texttt{ksize}-1\f$ and \f$\alpha\f$ is the scale factor chosen so
-that \f$\sum_i G_i=1\f$.
-
-Two of such generated kernels can be passed to sepFilter2D. Those functions
-automatically recognize smoothing kernels (a symmetrical kernel with sum of
-weights equal to 1) and handle them accordingly. You may also use the
-higher-level GaussianBlur.
-@param ksize Aperture size. It should be odd ( \f$\texttt{ksize} \mod 2 = 1\f$ )
-and positive.
-@param sigma Gaussian standard deviation. If it is non-positive, it is computed
-from ksize as `sigma = 0.3*((ksize-1)*0.5 - 1) + 0.8`.
-@param ktype Type of filter coefficients. It can be CV_32F or CV_64F .
-@sa  sepFilter2D, getDerivKernels, getStructuringElement, GaussianBlur
- */
-CV_EXPORTS_W Mat getGaussianKernel(int ksize, double sigma, int ktype = CV_64F);
-
-/** @brief Returns filter coefficients for computing spatial image derivatives.
-
-The function computes and returns the filter coefficients for spatial image
-derivatives. When `ksize=FILTER_SCHARR`, the Scharr \f$3 \times 3\f$ kernels are
-generated (see #Scharr). Otherwise, Sobel kernels are generated (see #Sobel).
-The filters are normally passed to #sepFilter2D or to
-
-@param kx Output matrix of row filter coefficients. It has the type ktype .
-@param ky Output matrix of column filter coefficients. It has the type ktype .
-@param dx Derivative order in respect of x.
-@param dy Derivative order in respect of y.
-@param ksize Aperture size. It can be FILTER_SCHARR, 1, 3, 5, or 7.
-@param normalize Flag indicating whether to normalize (scale down) the filter
-coefficients or not. Theoretically, the coefficients should have the denominator
-\f$=2^{ksize*2-dx-dy-2}\f$. If you are going to filter floating-point images,
-you are likely to use the normalized kernels. But if you compute derivatives of
-an 8-bit image, store the results in a 16-bit image, and wish to preserve all
-the fractional bits, you may want to set normalize=false .
-@param ktype Type of filter coefficients. It can be CV_32f or CV_64F .
- */
-CV_EXPORTS_W void getDerivKernels(OutputArray kx, OutputArray ky, int dx,
-                                  int dy, int ksize, bool normalize = false,
-                                  int ktype = CV_32F);
-
-/** @brief Returns Gabor filter coefficients.
-
-For more details about gabor filter equations and parameters, see: [Gabor
-Filter](http://en.wikipedia.org/wiki/Gabor_filter).
-
-@param ksize Size of the filter returned.
-@param sigma Standard deviation of the gaussian envelope.
-@param theta Orientation of the normal to the parallel stripes of a Gabor
-function.
-@param lambd Wavelength of the sinusoidal factor.
-@param gamma Spatial aspect ratio.
-@param psi Phase offset.
-@param ktype Type of filter coefficients. It can be CV_32F or CV_64F .
- */
-CV_EXPORTS_W Mat getGaborKernel(Size ksize, double sigma, double theta,
-                                double lambd, double gamma,
-                                double psi = CV_PI * 0.5, int ktype = CV_64F);
-
-//! returns "magic" border value for erosion and dilation. It is automatically
-//! transformed to Scalar::all(-DBL_MAX) for dilation.
-static inline Scalar morphologyDefaultBorderValue() {
-  return Scalar::all(DBL_MAX);
-}
-
-/** @brief Returns a structuring element of the specified size and shape for
-morphological operations.
-
-The function constructs and returns the structuring element that can be further
-passed to #erode, #dilate or #morphologyEx. But you can also construct an
-arbitrary binary mask yourself and use it as the structuring element.
-
-@param shape Element shape that could be one of #MorphShapes
-@param ksize Size of the structuring element.
-@param anchor Anchor position within the element. The default value \f$(-1,
--1)\f$ means that the anchor is at the center. Note that only the shape of a
-cross-shaped element depends on the anchor position. In other cases the anchor
-just regulates how much the result of the morphological operation is shifted.
- */
-CV_EXPORTS_W Mat getStructuringElement(int shape, Size ksize,
-                                       Point anchor = Point(-1, -1));
-
-/** @example samples/cpp/tutorial_code/ImgProc/Smoothing/Smoothing.cpp
-Sample code for simple filters
-![Sample screenshot](Smoothing_Tutorial_Result_Median_Filter.jpg)
-Check @ref tutorial_gausian_median_blur_bilateral_filter "the corresponding
-tutorial" for more details
- */
-
-/** @brief Blurs an image using the median filter.
-
-The function smoothes an image using the median filter with the
-\f$\texttt{ksize} \times
-\texttt{ksize}\f$ aperture. Each channel of a multi-channel image is processed
-independently. In-place operation is supported.
-
-@note The median filter uses #BORDER_REPLICATE internally to cope with border
-pixels, see #BorderTypes
-
-@param src input 1-, 3-, or 4-channel image; when ksize is 3 or 5, the image
-depth should be CV_8U, CV_16U, or CV_32F, for larger aperture sizes, it can only
-be CV_8U.
-@param dst destination array of the same size and type as src.
-@param ksize aperture linear size; it must be odd and greater than 1, for
-example: 3, 5, 7 ...
-@sa  bilateralFilter, blur, boxFilter, GaussianBlur
- */
-CV_EXPORTS_W void medianBlur(InputArray src, OutputArray dst, int ksize);
-
-/** @brief Blurs an image using a Gaussian filter.
-
-The function convolves the source image with the specified Gaussian kernel.
-In-place filtering is supported.
-
-@param src input image; the image can have any number of channels, which are
-processed independently, but the depth should be CV_8U, CV_16U, CV_16S, CV_32F
-or CV_64F.
-@param dst output image of the same size and type as src.
-@param ksize Gaussian kernel size. ksize.width and ksize.height can differ but
-they both must be positive and odd. Or, they can be zero's and then they are
-computed from sigma.
-@param sigmaX Gaussian kernel standard deviation in X direction.
-@param sigmaY Gaussian kernel standard deviation in Y direction; if sigmaY is
-zero, it is set to be equal to sigmaX, if both sigmas are zeros, they are
-computed from ksize.width and ksize.height, respectively (see #getGaussianKernel
-for details); to fully control the result regardless of possible future
-modifications of all this semantics, it is recommended to specify all of ksize,
-sigmaX, and sigmaY.
-@param borderType pixel extrapolation method, see #BorderTypes. #BORDER_WRAP is
-not supported.
-@param hint Implementation modfication flags. See #AlgorithmHint
-
-@sa  sepFilter2D, filter2D, blur, boxFilter, bilateralFilter, medianBlur
- */
-CV_EXPORTS_W void GaussianBlur(InputArray src, OutputArray dst, Size ksize,
-                               double sigmaX, double sigmaY = 0,
-                               int borderType = BORDER_DEFAULT,
-                               AlgorithmHint hint = cv::ALGO_HINT_DEFAULT);
-
-/** @brief Applies the bilateral filter to an image.
-
-The function applies bilateral filtering to the input image, as described in
-http://www.dai.ed.ac.uk/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.html
-bilateralFilter can reduce unwanted noise very well while keeping edges fairly
-sharp. However, it is very slow compared to most filters.
-
-_Sigma values_: For simplicity, you can set the 2 sigma values to be the same.
-If they are small (\< 10), the filter will not have much effect, whereas if they
-are large (\> 150), they will have a very strong effect, making the image look
-"cartoonish".
-
-_Filter size_: Large filters (d \> 5) are very slow, so it is recommended to use
-d=5 for real-time applications, and perhaps d=9 for offline applications that
-need heavy noise filtering.
-
-This filter does not work inplace.
-@param src Source 8-bit or floating-point, 1-channel or 3-channel image.
-@param dst Destination image of the same size and type as src .
-@param d Diameter of each pixel neighborhood that is used during filtering. If
-it is non-positive, it is computed from sigmaSpace.
-@param sigmaColor Filter sigma in the color space. A larger value of the
-parameter means that farther colors within the pixel neighborhood (see
-sigmaSpace) will be mixed together, resulting in larger areas of semi-equal
-color.
-@param sigmaSpace Filter sigma in the coordinate space. A larger value of the
-parameter means that farther pixels will influence each other as long as their
-colors are close enough (see sigmaColor
-). When d\>0, it specifies the neighborhood size regardless of sigmaSpace.
-Otherwise, d is proportional to sigmaSpace.
-@param borderType border mode used to extrapolate pixels outside of the image,
-see #BorderTypes
- */
-CV_EXPORTS_W void bilateralFilter(InputArray src, OutputArray dst, int d,
-                                  double sigmaColor, double sigmaSpace,
-                                  int borderType = BORDER_DEFAULT);
-
-/** @brief Blurs an image using the box filter.
-
-The function smooths an image using the kernel:
-
-\f[\texttt{K} =  \alpha \begin{bmatrix} 1 & 1 & 1 &  \cdots & 1 & 1  \\ 1 & 1 &
-1 &  \cdots & 1 & 1  \\ \hdotsfor{6} \\ 1 & 1 & 1 &  \cdots & 1 & 1
-\end{bmatrix}\f]
-
-where
-
-\f[\alpha = \begin{cases} \frac{1}{\texttt{ksize.width*ksize.height}} &
-\texttt{when } \texttt{normalize=true}  \\1 & \texttt{otherwise}\end{cases}\f]
-
-Unnormalized box filter is useful for computing various integral characteristics
-over each pixel neighborhood, such as covariance matrices of image derivatives
-(used in dense optical flow algorithms, and so on). If you need to compute pixel
-sums over variable-size windows, use #integral.
-
-@param src input image.
-@param dst output image of the same size and type as src.
-@param ddepth the output image depth (-1 to use src.depth()).
-@param ksize blurring kernel size.
-@param anchor anchor point; default value Point(-1,-1) means that the anchor is
-at the kernel center.
-@param normalize flag, specifying whether the kernel is normalized by its area
-or not.
-@param borderType border mode used to extrapolate pixels outside of the image,
-see #BorderTypes. #BORDER_WRAP is not supported.
-@sa  blur, bilateralFilter, GaussianBlur, medianBlur, integral
- */
-CV_EXPORTS_W void boxFilter(InputArray src, OutputArray dst, int ddepth,
-                            Size ksize, Point anchor = Point(-1, -1),
-                            bool normalize = true,
-                            int borderType = BORDER_DEFAULT);
-
-/** @brief Calculates the normalized sum of squares of the pixel values
-overlapping the filter.
-
-For every pixel \f$ (x, y) \f$ in the source image, the function calculates the
-sum of squares of those neighboring pixel values which overlap the filter placed
-over the pixel \f$ (x, y) \f$.
-
-The unnormalized square box filter can be useful in computing local image
-statistics such as the local variance and standard deviation around the
-neighborhood of a pixel.
-
-@param src input image
-@param dst output image of the same size and type as src
-@param ddepth the output image depth (-1 to use src.depth())
-@param ksize kernel size
-@param anchor kernel anchor point. The default value of Point(-1, -1) denotes
-that the anchor is at the kernel center.
-@param normalize flag, specifying whether the kernel is to be normalized by it's
-area or not.
-@param borderType border mode used to extrapolate pixels outside of the image,
-see #BorderTypes. #BORDER_WRAP is not supported.
-@sa boxFilter
-*/
-CV_EXPORTS_W void sqrBoxFilter(InputArray src, OutputArray dst, int ddepth,
-                               Size ksize, Point anchor = Point(-1, -1),
-                               bool normalize = true,
-                               int borderType = BORDER_DEFAULT);
-
-/** @brief Blurs an image using the normalized box filter.
-
-The function smooths an image using the kernel:
-
-\f[\texttt{K} =  \frac{1}{\texttt{ksize.width*ksize.height}} \begin{bmatrix} 1 &
-1 & 1 &  \cdots & 1 & 1  \\ 1 & 1 & 1 &  \cdots & 1 & 1  \\ \hdotsfor{6} \\ 1 &
-1 & 1 &  \cdots & 1 & 1  \\ \end{bmatrix}\f]
-
-The call `blur(src, dst, ksize, anchor, borderType)` is equivalent to
-`boxFilter(src, dst, src.type(), ksize, anchor, true, borderType)`.
-
-@param src input image; it can have any number of channels, which are processed
-independently, but the depth should be CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
-@param dst output image of the same size and type as src.
-@param ksize blurring kernel size.
-@param anchor anchor point; default value Point(-1,-1) means that the anchor is
-at the kernel center.
-@param borderType border mode used to extrapolate pixels outside of the image,
-see #BorderTypes. #BORDER_WRAP is not supported.
-@sa  boxFilter, bilateralFilter, GaussianBlur, medianBlur
- */
-CV_EXPORTS_W void blur(InputArray src, OutputArray dst, Size ksize,
-                       Point anchor = Point(-1, -1),
-                       int borderType = BORDER_DEFAULT);
-
-/** @brief Blurs an image using the stackBlur.
-
-The function applies and stackBlur to an image.
-stackBlur can generate similar results as Gaussian blur, and the time
-consumption does not increase with the increase of kernel size. It creates a
-kind of moving stack of colors whilst scanning through the image. Thereby it
-just has to add one new block of color to the right side of the stack and remove
-the leftmost color. The remaining colors on the topmost layer of the stack are
-either added on or reduced by one, depending on if they are on the right or on
-the left side of the stack. The only supported borderType is BORDER_REPLICATE.
-Original paper was proposed by Mario Klingemann, which can be found
-http://underdestruction.com/2004/02/25/stackblur-2004.
-
-@param src input image. The number of channels can be arbitrary, but the depth
-should be one of CV_8U, CV_16U, CV_16S or CV_32F.
-@param dst output image of the same size and type as src.
-@param ksize stack-blurring kernel size. The ksize.width and ksize.height can
-differ but they both must be positive and odd.
-*/
-CV_EXPORTS_W void stackBlur(InputArray src, OutputArray dst, Size ksize);
-
-/** @brief Convolves an image with the kernel.
-
-The function applies an arbitrary linear filter to an image. In-place operation
-is supported. When the aperture is partially outside the image, the function
-interpolates outlier pixel values according to the specified border mode.
-
-The function does actually compute correlation, not the convolution:
-
-\f[\texttt{dst} (x,y) =  \sum _{ \substack{0\leq x' <
-\texttt{kernel.cols}\\{0\leq y' < \texttt{kernel.rows}}}}  \texttt{kernel}
-(x',y')* \texttt{src} (x+x'- \texttt{anchor.x} ,y+y'- \texttt{anchor.y} )\f]
-
-That is, the kernel is not mirrored around the anchor point. If you need a real
-convolution, flip the kernel using #flip and set the new anchor to `(kernel.cols
-- anchor.x - 1, kernel.rows - anchor.y - 1)`.
-
-The function uses the DFT-based algorithm in case of sufficiently large kernels
-(~`11 x 11` or larger) and the direct algorithm for small kernels.
-
-@param src input image.
-@param dst output image of the same size and the same number of channels as src.
-@param ddepth desired depth of the destination image, see @ref filter_depths
-"combinations"
-@param kernel convolution kernel (or rather a correlation kernel), a
-single-channel floating point matrix; if you want to apply different kernels to
-different channels, split the image into separate color planes using split and
-process them individually.
-@param anchor anchor of the kernel that indicates the relative position of a
-filtered point within the kernel; the anchor should lie within the kernel;
-default value (-1,-1) means that the anchor is at the kernel center.
-@param delta optional value added to the filtered pixels before storing them in
-dst.
-@param borderType pixel extrapolation method, see #BorderTypes. #BORDER_WRAP is
-not supported.
-@sa  sepFilter2D, dft, matchTemplate
- */
-CV_EXPORTS_W void filter2D(InputArray src, OutputArray dst, int ddepth,
-                           InputArray kernel, Point anchor = Point(-1, -1),
-                           double delta = 0, int borderType = BORDER_DEFAULT);
-
-/** @brief Applies a separable linear filter to an image.
-
-The function applies a separable linear filter to the image. That is, first,
-every row of src is filtered with the 1D kernel kernelX. Then, every column of
-the result is filtered with the 1D kernel kernelY. The final result shifted by
-delta is stored in dst .
-
-@param src Source image.
-@param dst Destination image of the same size and the same number of channels as
-src .
-@param ddepth Destination image depth, see @ref filter_depths "combinations"
-@param kernelX Coefficients for filtering each row.
-@param kernelY Coefficients for filtering each column.
-@param anchor Anchor position within the kernel. The default value \f$(-1,-1)\f$
-means that the anchor is at the kernel center.
-@param delta Value added to the filtered results before storing them.
-@param borderType Pixel extrapolation method, see #BorderTypes. #BORDER_WRAP is
-not supported.
-@sa  filter2D, Sobel, GaussianBlur, boxFilter, blur
- */
-CV_EXPORTS_W void sepFilter2D(InputArray src, OutputArray dst, int ddepth,
-                              InputArray kernelX, InputArray kernelY,
-                              Point anchor = Point(-1, -1), double delta = 0,
-                              int borderType = BORDER_DEFAULT);
-
-/** @example samples/cpp/tutorial_code/ImgTrans/Sobel_Demo.cpp
-Sample code using Sobel and/or Scharr OpenCV functions to make a simple Edge
-Detector
-![Sample screenshot](Sobel_Derivatives_Tutorial_Result.jpg)
-Check @ref tutorial_sobel_derivatives "the corresponding tutorial" for more
-details
-*/
-
-/** @brief Calculates the first, second, third, or mixed image derivatives using
-an extended Sobel operator.
-
-In all cases except one, the \f$\texttt{ksize} \times \texttt{ksize}\f$
-separable kernel is used to calculate the derivative. When \f$\texttt{ksize =
-1}\f$, the \f$3 \times 1\f$ or \f$1 \times 3\f$ kernel is used (that is, no
-Gaussian smoothing is done). `ksize = 1` can only be used for the first or the
-second x- or y- derivatives.
-
-There is also the special value `ksize = #FILTER_SCHARR (-1)` that corresponds
-to the \f$3\times3\f$ Scharr filter that may give more accurate results than the
-\f$3\times3\f$ Sobel. The Scharr aperture is
-
-\f[\vecthreethree{-3}{0}{3}{-10}{0}{10}{-3}{0}{3}\f]
-
-for the x-derivative, or transposed for the y-derivative.
-
-The function calculates an image derivative by convolving the image with the
-appropriate kernel:
-
-\f[\texttt{dst} =  \frac{\partial^{xorder+yorder} \texttt{src}}{\partial
-x^{xorder} \partial y^{yorder}}\f]
-
-The Sobel operators combine Gaussian smoothing and differentiation, so the
-result is more or less resistant to the noise. Most often, the function is
-called with ( xorder = 1, yorder = 0, ksize = 3) or ( xorder = 0, yorder = 1,
-ksize = 3) to calculate the first x- or y- image derivative. The first case
-corresponds to a kernel of:
-
-\f[\vecthreethree{-1}{0}{1}{-2}{0}{2}{-1}{0}{1}\f]
-
-The second case corresponds to a kernel of:
-
-\f[\vecthreethree{-1}{-2}{-1}{0}{0}{0}{1}{2}{1}\f]
-
-@param src input image.
-@param dst output image of the same size and the same number of channels as src
-.
-@param ddepth output image depth, see @ref filter_depths "combinations"; in the
-case of 8-bit input images it will result in truncated derivatives.
-@param dx order of the derivative x.
-@param dy order of the derivative y.
-@param ksize size of the extended Sobel kernel; it must be 1, 3, 5, or 7.
-@param scale optional scale factor for the computed derivative values; by
-default, no scaling is applied (see #getDerivKernels for details).
-@param delta optional delta value that is added to the results prior to storing
-them in dst.
-@param borderType pixel extrapolation method, see #BorderTypes. #BORDER_WRAP is
-not supported.
-@sa  Scharr, Laplacian, sepFilter2D, filter2D, GaussianBlur, cartToPolar
- */
-CV_EXPORTS_W void Sobel(InputArray src, OutputArray dst, int ddepth, int dx,
-                        int dy, int ksize = 3, double scale = 1,
-                        double delta = 0, int borderType = BORDER_DEFAULT);
-
-/** @brief Calculates the first order image derivative in both x and y using a
-Sobel operator
-
-Equivalent to calling:
-
-@code
-Sobel( src, dx, CV_16SC1, 1, 0, 3 );
-Sobel( src, dy, CV_16SC1, 0, 1, 3 );
-@endcode
-
-@param src input image.
-@param dx output image with first-order derivative in x.
-@param dy output image with first-order derivative in y.
-@param ksize size of Sobel kernel. It must be 3.
-@param borderType pixel extrapolation method, see #BorderTypes.
-                  Only #BORDER_DEFAULT=#BORDER_REFLECT_101 and #BORDER_REPLICATE
-are supported.
-
-@sa Sobel
- */
-
-CV_EXPORTS_W void spatialGradient(InputArray src, OutputArray dx,
-                                  OutputArray dy, int ksize = 3,
-                                  int borderType = BORDER_DEFAULT);
-
-/** @brief Calculates the first x- or y- image derivative using Scharr operator.
-
-The function computes the first x- or y- spatial image derivative using the
-Scharr operator. The call
-
-\f[\texttt{Scharr(src, dst, ddepth, dx, dy, scale, delta, borderType)}\f]
-
-is equivalent to
-
-\f[\texttt{Sobel(src, dst, ddepth, dx, dy, FILTER_SCHARR, scale, delta,
-borderType)} .\f]
-
-@param src input image.
-@param dst output image of the same size and the same number of channels as src.
-@param ddepth output image depth, see @ref filter_depths "combinations"
-@param dx order of the derivative x.
-@param dy order of the derivative y.
-@param scale optional scale factor for the computed derivative values; by
-default, no scaling is applied (see #getDerivKernels for details).
-@param delta optional delta value that is added to the results prior to storing
-them in dst.
-@param borderType pixel extrapolation method, see #BorderTypes. #BORDER_WRAP is
-not supported.
-@sa  cartToPolar
- */
-CV_EXPORTS_W void Scharr(InputArray src, OutputArray dst, int ddepth, int dx,
-                         int dy, double scale = 1, double delta = 0,
-                         int borderType = BORDER_DEFAULT);
-
-/** @example samples/cpp/laplace.cpp
-An example using Laplace transformations for edge detection
-*/
-
-/** @brief Calculates the Laplacian of an image.
-
-The function calculates the Laplacian of the source image by adding up the
-second x and y derivatives calculated using the Sobel operator:
-
-\f[\texttt{dst} =  \Delta \texttt{src} =  \frac{\partial^2
-\texttt{src}}{\partial x^2} +  \frac{\partial^2 \texttt{src}}{\partial y^2}\f]
-
-This is done when `ksize > 1`. When `ksize == 1`, the Laplacian is computed by
-filtering the image with the following \f$3 \times 3\f$ aperture:
-
-\f[\vecthreethree {0}{1}{0}{1}{-4}{1}{0}{1}{0}\f]
-
-@param src Source image.
-@param dst Destination image of the same size and the same number of channels as
-src .
-@param ddepth Desired depth of the destination image, see @ref filter_depths
-"combinations".
-@param ksize Aperture size used to compute the second-derivative filters. See
-#getDerivKernels for details. The size must be positive and odd.
-@param scale Optional scale factor for the computed Laplacian values. By
-default, no scaling is applied. See #getDerivKernels for details.
-@param delta Optional delta value that is added to the results prior to storing
-them in dst .
-@param borderType Pixel extrapolation method, see #BorderTypes. #BORDER_WRAP is
-not supported.
-@sa  Sobel, Scharr
- */
-CV_EXPORTS_W void Laplacian(InputArray src, OutputArray dst, int ddepth,
-                            int ksize = 1, double scale = 1, double delta = 0,
-                            int borderType = BORDER_DEFAULT);
-
-//! @} imgproc_filter
-
-//! @addtogroup imgproc_feature
-//! @{
-
-/** @example samples/cpp/edge.cpp
-This program demonstrates usage of the Canny edge detector
-
-Check @ref tutorial_canny_detector "the corresponding tutorial" for more details
-*/
-
-/** @brief Finds edges in an image using the Canny algorithm @cite Canny86 .
-
-The function finds edges in the input image and marks them in the output map
-edges using the Canny algorithm. The smallest value between threshold1 and
-threshold2 is used for edge linking. The largest value is used to find initial
-segments of strong edges. See <http://en.wikipedia.org/wiki/Canny_edge_detector>
-
-@param image 8-bit input image.
-@param edges output edge map; single channels 8-bit image, which has the same
-size as image .
-@param threshold1 first threshold for the hysteresis procedure.
-@param threshold2 second threshold for the hysteresis procedure.
-@param apertureSize aperture size for the Sobel operator.
-@param L2gradient a flag, indicating whether a more accurate \f$L_2\f$ norm
-\f$=\sqrt{(dI/dx)^2 + (dI/dy)^2}\f$ should be used to calculate the image
-gradient magnitude ( L2gradient=true ), or whether the default \f$L_1\f$ norm
-\f$=|dI/dx|+|dI/dy|\f$ is enough ( L2gradient=false ).
- */
-CV_EXPORTS_W void Canny(InputArray image, OutputArray edges, double threshold1,
-                        double threshold2, int apertureSize = 3,
-                        bool L2gradient = false);
-
-/** \overload
-
-Finds edges in an image using the Canny algorithm with custom image gradient.
-
-@param dx 16-bit x derivative of input image (CV_16SC1 or CV_16SC3).
-@param dy 16-bit y derivative of input image (same type as dx).
-@param edges output edge map; single channels 8-bit image, which has the same
-size as image .
-@param threshold1 first threshold for the hysteresis procedure.
-@param threshold2 second threshold for the hysteresis procedure.
-@param L2gradient a flag, indicating whether a more accurate \f$L_2\f$ norm
-\f$=\sqrt{(dI/dx)^2 + (dI/dy)^2}\f$ should be used to calculate the image
-gradient magnitude ( L2gradient=true ), or whether the default \f$L_1\f$ norm
-\f$=|dI/dx|+|dI/dy|\f$ is enough ( L2gradient=false ).
- */
-CV_EXPORTS_W void Canny(InputArray dx, InputArray dy, OutputArray edges,
-                        double threshold1, double threshold2,
-                        bool L2gradient = false);
-
-/** @brief Calculates the minimal eigenvalue of gradient matrices for corner
-detection.
-
-The function is similar to cornerEigenValsAndVecs but it calculates and stores
-only the minimal eigenvalue of the covariance matrix of derivatives, that is,
-\f$\min(\lambda_1, \lambda_2)\f$ in terms of the formulae in the
-cornerEigenValsAndVecs description.
-
-@param src Input single-channel 8-bit or floating-point image.
-@param dst Image to store the minimal eigenvalues. It has the type CV_32FC1 and
-the same size as src .
-@param blockSize Neighborhood size (see the details on #cornerEigenValsAndVecs
-).
-@param ksize Aperture parameter for the Sobel operator.
-@param borderType Pixel extrapolation method. See #BorderTypes. #BORDER_WRAP is
-not supported.
- */
-CV_EXPORTS_W void cornerMinEigenVal(InputArray src, OutputArray dst,
-                                    int blockSize, int ksize = 3,
-                                    int borderType = BORDER_DEFAULT);
-
-/** @brief Harris corner detector.
-
-The function runs the Harris corner detector on the image. Similarly to
-cornerMinEigenVal and cornerEigenValsAndVecs , for each pixel \f$(x, y)\f$ it
-calculates a \f$2\times2\f$ gradient covariance matrix \f$M^{(x,y)}\f$ over a
-\f$\texttt{blockSize} \times \texttt{blockSize}\f$ neighborhood. Then, it
-computes the following characteristic:
-
-\f[\texttt{dst} (x,y) =  \mathrm{det} M^{(x,y)} - k  \cdot \left ( \mathrm{tr}
-M^{(x,y)} \right )^2\f]
-
-Corners in the image can be found as the local maxima of this response map.
-
-@param src Input single-channel 8-bit or floating-point image.
-@param dst Image to store the Harris detector responses. It has the type
-CV_32FC1 and the same size as src .
-@param blockSize Neighborhood size (see the details on #cornerEigenValsAndVecs
-).
-@param ksize Aperture parameter for the Sobel operator.
-@param k Harris detector free parameter. See the formula above.
-@param borderType Pixel extrapolation method. See #BorderTypes. #BORDER_WRAP is
-not supported.
- */
-CV_EXPORTS_W void cornerHarris(InputArray src, OutputArray dst, int blockSize,
-                               int ksize, double k,
-                               int borderType = BORDER_DEFAULT);
-
-/** @brief Calculates eigenvalues and eigenvectors of image blocks for corner
-detection.
-
-For every pixel \f$p\f$ , the function cornerEigenValsAndVecs considers a
-blockSize \f$\times\f$ blockSize neighborhood \f$S(p)\f$ . It calculates the
-covariation matrix of derivatives over the neighborhood as:
-
-\f[M =  \begin{bmatrix} \sum _{S(p)}(dI/dx)^2 &  \sum _{S(p)}dI/dx dI/dy \\ \sum
-_{S(p)}dI/dx dI/dy &  \sum _{S(p)}(dI/dy)^2 \end{bmatrix}\f]
-
-where the derivatives are computed using the Sobel operator.
-
-After that, it finds eigenvectors and eigenvalues of \f$M\f$ and stores them in
-the destination image as
-\f$(\lambda_1, \lambda_2, x_1, y_1, x_2, y_2)\f$ where
-
--   \f$\lambda_1, \lambda_2\f$ are the non-sorted eigenvalues of \f$M\f$
--   \f$x_1, y_1\f$ are the eigenvectors corresponding to \f$\lambda_1\f$
--   \f$x_2, y_2\f$ are the eigenvectors corresponding to \f$\lambda_2\f$
-
-The output of the function can be used for robust edge or corner detection.
-
-@param src Input single-channel 8-bit or floating-point image.
-@param dst Image to store the results. It has the same size as src and the type
-CV_32FC(6) .
-@param blockSize Neighborhood size (see details below).
-@param ksize Aperture parameter for the Sobel operator.
-@param borderType Pixel extrapolation method. See #BorderTypes. #BORDER_WRAP is
-not supported.
-
-@sa  cornerMinEigenVal, cornerHarris, preCornerDetect
- */
-CV_EXPORTS_W void cornerEigenValsAndVecs(InputArray src, OutputArray dst,
-                                         int blockSize, int ksize,
-                                         int borderType = BORDER_DEFAULT);
-
-/** @brief Calculates a feature map for corner detection.
-
-The function calculates the complex spatial derivative-based function of the
-source image
-
-\f[\texttt{dst} = (D_x  \texttt{src} )^2  \cdot D_{yy}  \texttt{src} + (D_y
-\texttt{src} )^2  \cdot D_{xx}  \texttt{src} - 2 D_x  \texttt{src} \cdot D_y
-\texttt{src} \cdot D_{xy}  \texttt{src}\f]
-
-where \f$D_x\f$,\f$D_y\f$ are the first image derivatives,
-\f$D_{xx}\f$,\f$D_{yy}\f$ are the second image derivatives, and \f$D_{xy}\f$ is
-the mixed derivative.
-
-The corners can be found as local maximums of the functions, as shown below:
-@code
-    Mat corners, dilated_corners;
-    preCornerDetect(image, corners, 3);
-    // dilation with 3x3 rectangular structuring element
-    dilate(corners, dilated_corners, Mat(), 1);
-    Mat corner_mask = corners == dilated_corners;
-@endcode
-
-@param src Source single-channel 8-bit of floating-point image.
-@param dst Output image that has the type CV_32F and the same size as src .
-@param ksize %Aperture size of the Sobel .
-@param borderType Pixel extrapolation method. See #BorderTypes. #BORDER_WRAP is
-not supported.
- */
-CV_EXPORTS_W void preCornerDetect(InputArray src, OutputArray dst, int ksize,
-                                  int borderType = BORDER_DEFAULT);
-
-/** @brief Refines the corner locations.
-
-The function iterates to find the sub-pixel accurate location of corners or
-radial saddle points as described in @cite forstner1987fast, and as shown on the
-figure below.
-
-![image](pics/cornersubpix.png)
-
-Sub-pixel accurate corner locator is based on the observation that every vector
-from the center \f$q\f$ to a point \f$p\f$ located within a neighborhood of
-\f$q\f$ is orthogonal to the image gradient at \f$p\f$ subject to image and
-measurement noise. Consider the expression:
-
-\f[\epsilon _i = {DI_{p_i}}^T  \cdot (q - p_i)\f]
-
-where \f${DI_{p_i}}\f$ is an image gradient at one of the points \f$p_i\f$ in a
-neighborhood of \f$q\f$ . The value of \f$q\f$ is to be found so that
-\f$\epsilon_i\f$ is minimized. A system of equations may be set up with
-\f$\epsilon_i\f$ set to zero:
-
-\f[\sum _i(DI_{p_i}  \cdot {DI_{p_i}}^T) \cdot q -  \sum _i(DI_{p_i}  \cdot
-{DI_{p_i}}^T  \cdot p_i)\f]
-
-where the gradients are summed within a neighborhood ("search window") of
-\f$q\f$ . Calling the first gradient term \f$G\f$ and the second gradient term
-\f$b\f$ gives:
-
-\f[q = G^{-1}  \cdot b\f]
-
-The algorithm sets the center of the neighborhood window at this new center
-\f$q\f$ and then iterates until the center stays within a set threshold.
-
-@param image Input single-channel, 8-bit or float image.
-@param corners Initial coordinates of the input corners and refined coordinates
-provided for output.
-@param winSize Half of the side length of the search window. For example, if
-winSize=Size(5,5) , then a \f$(5*2+1) \times (5*2+1) = 11 \times 11\f$ search
-window is used.
-@param zeroZone Half of the size of the dead region in the middle of the search
-zone over which the summation in the formula below is not done. It is used
-sometimes to avoid possible singularities of the autocorrelation matrix. The
-value of (-1,-1) indicates that there is no such a size.
-@param criteria Criteria for termination of the iterative process of corner
-refinement. That is, the process of corner position refinement stops either
-after criteria.maxCount iterations or when the corner position moves by less
-than criteria.epsilon on some iteration.
- */
-CV_EXPORTS_W void cornerSubPix(InputArray image, InputOutputArray corners,
-                               Size winSize, Size zeroZone,
-                               TermCriteria criteria);
-
-/** @brief Determines strong corners on an image.
-
-The function finds the most prominent corners in the image or in the specified
-image region, as described in @cite Shi94
-
--   Function calculates the corner quality measure at every source image pixel
-using the #cornerMinEigenVal or #cornerHarris .
--   Function performs a non-maximum suppression (the local maximums in *3 x 3*
-neighborhood are retained).
--   The corners with the minimal eigenvalue less than
-    \f$\texttt{qualityLevel} \cdot \max_{x,y} qualityMeasureMap(x,y)\f$ are
-rejected.
--   The remaining corners are sorted by the quality measure in the descending
-order.
--   Function throws away each corner for which there is a stronger corner at a
-distance less than maxDistance.
-
-The function can be used to initialize a point-based tracker of an object.
-
-@note If the function is called with different values A and B of the parameter
-qualityLevel , and A \> B, the vector of returned corners with qualityLevel=A
-will be the prefix of the output vector with qualityLevel=B .
-
-@param image Input 8-bit or floating-point 32-bit, single-channel image.
-@param corners Output vector of detected corners.
-@param maxCorners Maximum number of corners to return. If there are more corners
-than are found, the strongest of them is returned. `maxCorners <= 0` implies
-that no limit on the maximum is set and all detected corners are returned.
-@param qualityLevel Parameter characterizing the minimal accepted quality of
-image corners. The parameter value is multiplied by the best corner quality
-measure, which is the minimal eigenvalue (see #cornerMinEigenVal ) or the Harris
-function response (see #cornerHarris ). The corners with the quality measure
-less than the product are rejected. For example, if the best corner has the
-quality measure = 1500, and the qualityLevel=0.01 , then all the corners with
-the quality measure less than 15 are rejected.
-@param minDistance Minimum possible Euclidean distance between the returned
-corners.
-@param mask Optional region of interest. If the image is not empty (it needs to
-have the type CV_8UC1 and the same size as image ), it specifies the region in
-which the corners are detected.
-@param blockSize Size of an average block for computing a derivative covariation
-matrix over each pixel neighborhood. See cornerEigenValsAndVecs .
-@param useHarrisDetector Parameter indicating whether to use a Harris detector
-(see #cornerHarris) or #cornerMinEigenVal.
-@param k Free parameter of the Harris detector.
-
-@sa  cornerMinEigenVal, cornerHarris, calcOpticalFlowPyrLK,
-estimateRigidTransform,
- */
-
-CV_EXPORTS_W void
-goodFeaturesToTrack(InputArray image, OutputArray corners, int maxCorners,
-                    double qualityLevel, double minDistance,
-                    InputArray mask = noArray(), int blockSize = 3,
-                    bool useHarrisDetector = false, double k = 0.04);
-
-CV_EXPORTS_W void goodFeaturesToTrack(InputArray image, OutputArray corners,
-                                      int maxCorners, double qualityLevel,
-                                      double minDistance, InputArray mask,
-                                      int blockSize, int gradientSize,
-                                      bool useHarrisDetector = false,
-                                      double k = 0.04);
-
-/** @brief Same as above, but returns also quality measure of the detected
-corners.
-
-@param image Input 8-bit or floating-point 32-bit, single-channel image.
-@param corners Output vector of detected corners.
-@param maxCorners Maximum number of corners to return. If there are more corners
-than are found, the strongest of them is returned. `maxCorners <= 0` implies
-that no limit on the maximum is set and all detected corners are returned.
-@param qualityLevel Parameter characterizing the minimal accepted quality of
-image corners. The parameter value is multiplied by the best corner quality
-measure, which is the minimal eigenvalue (see #cornerMinEigenVal ) or the Harris
-function response (see #cornerHarris ). The corners with the quality measure
-less than the product are rejected. For example, if the best corner has the
-quality measure = 1500, and the qualityLevel=0.01 , then all the corners with
-the quality measure less than 15 are rejected.
-@param minDistance Minimum possible Euclidean distance between the returned
-corners.
-@param mask Region of interest. If the image is not empty (it needs to have the
-type CV_8UC1 and the same size as image ), it specifies the region in which the
-corners are detected.
-@param cornersQuality Output vector of quality measure of the detected corners.
-@param blockSize Size of an average block for computing a derivative covariation
-matrix over each pixel neighborhood. See cornerEigenValsAndVecs .
-@param gradientSize Aperture parameter for the Sobel operator used for
-derivatives computation. See cornerEigenValsAndVecs .
-@param useHarrisDetector Parameter indicating whether to use a Harris detector
-(see #cornerHarris) or #cornerMinEigenVal.
-@param k Free parameter of the Harris detector.
- */
-CV_EXPORTS CV_WRAP_AS(goodFeaturesToTrackWithQuality) void goodFeaturesToTrack(
-    InputArray image, OutputArray corners, int maxCorners, double qualityLevel,
-    double minDistance, InputArray mask, OutputArray cornersQuality,
-    int blockSize = 3, int gradientSize = 3, bool useHarrisDetector = false,
-    double k = 0.04);
-
-/** @example samples/cpp/tutorial_code/ImgTrans/houghlines.cpp
-An example using the Hough line detector
-![Sample input image](Hough_Lines_Tutorial_Original_Image.jpg) ![Output
-image](Hough_Lines_Tutorial_Result.jpg)
-*/
-
-/** @brief Finds lines in a binary image using the standard Hough transform.
-
-The function implements the standard or standard multi-scale Hough transform
-algorithm for line detection. See
-<http://homepages.inf.ed.ac.uk/rbf/HIPR2/hough.htm> for a good explanation of
-Hough transform.
-
-@param image 8-bit, single-channel binary source image. The image may be
-modified by the function.
-@param lines Output vector of lines. Each line is represented by a 2 or 3
-element vector
-\f$(\rho, \theta)\f$ or \f$(\rho, \theta, \textrm{votes})\f$, where \f$\rho\f$
-is the distance from the coordinate origin \f$(0,0)\f$ (top-left corner of the
-image), \f$\theta\f$ is the line rotation angle in radians ( \f$0 \sim
-\textrm{vertical line}, \pi/2 \sim \textrm{horizontal line}\f$ ), and
-\f$\textrm{votes}\f$ is the value of accumulator.
-@param rho Distance resolution of the accumulator in pixels.
-@param theta Angle resolution of the accumulator in radians.
-@param threshold %Accumulator threshold parameter. Only those lines are returned
-that get enough votes ( \f$>\texttt{threshold}\f$ ).
-@param srn For the multi-scale Hough transform, it is a divisor for the distance
-resolution rho. The coarse accumulator distance resolution is rho and the
-accurate accumulator resolution is rho/srn. If both srn=0 and stn=0, the
-classical Hough transform is used. Otherwise, both these parameters should be
-positive.
-@param stn For the multi-scale Hough transform, it is a divisor for the distance
-resolution theta.
-@param min_theta For standard and multi-scale Hough transform, minimum angle to
-check for lines. Must fall between 0 and max_theta.
-@param max_theta For standard and multi-scale Hough transform, an upper bound
-for the angle. Must fall between min_theta and CV_PI. The actual maximum angle
-in the accumulator may be slightly less than max_theta, depending on the
-parameters min_theta and theta.
-@param use_edgeval True if you want to use weighted Hough transform.
- */
-CV_EXPORTS_W void HoughLines(InputArray image, OutputArray lines, double rho,
-                             double theta, int threshold, double srn = 0,
-                             double stn = 0, double min_theta = 0,
-                             double max_theta = CV_PI,
-                             bool use_edgeval = false);
-
-/** @brief Finds line segments in a binary image using the probabilistic Hough
-transform.
-
-The function implements the probabilistic Hough transform algorithm for line
-detection, described in @cite Matas00
-
-See the line detection example below:
-@include snippets/imgproc_HoughLinesP.cpp
-This is a sample picture the function parameters have been tuned for:
-
-![image](pics/building.jpg)
-
-And this is the output of the above program in case of the probabilistic Hough
-transform:
-
-![image](pics/houghp.png)
-
-@param image 8-bit, single-channel binary source image. The image may be
-modified by the function.
-@param lines Output vector of lines. Each line is represented by a 4-element
-vector
-\f$(x_1, y_1, x_2, y_2)\f$ , where \f$(x_1,y_1)\f$ and \f$(x_2, y_2)\f$ are the
-ending points of each detected line segment.
-@param rho Distance resolution of the accumulator in pixels.
-@param theta Angle resolution of the accumulator in radians.
-@param threshold %Accumulator threshold parameter. Only those lines are returned
-that get enough votes ( \f$>\texttt{threshold}\f$ ).
-@param minLineLength Minimum line length. Line segments shorter than that are
-rejected.
-@param maxLineGap Maximum allowed gap between points on the same line to link
-them.
-
-@sa LineSegmentDetector
- */
-CV_EXPORTS_W void HoughLinesP(InputArray image, OutputArray lines, double rho,
-                              double theta, int threshold,
-                              double minLineLength = 0, double maxLineGap = 0);
-
-/** @brief Finds lines in a set of points using the standard Hough transform.
-
-The function finds lines in a set of points using a modification of the Hough
-transform.
-@include snippets/imgproc_HoughLinesPointSet.cpp
-@param point Input vector of points. Each vector must be encoded as a Point
-vector \f$(x,y)\f$. Type must be CV_32FC2 or CV_32SC2.
-@param lines Output vector of found lines. Each vector is encoded as a
-vector<Vec3d> \f$(votes, rho, theta)\f$. The larger the value of 'votes', the
-higher the reliability of the Hough line.
-@param lines_max Max count of Hough lines.
-@param threshold %Accumulator threshold parameter. Only those lines are returned
-that get enough votes ( \f$>\texttt{threshold}\f$ ).
-@param min_rho Minimum value for \f$\rho\f$ for the accumulator (Note:
-\f$\rho\f$ can be negative. The absolute value \f$|\rho|\f$ is the distance of a
-line to the origin.).
-@param max_rho Maximum value for \f$\rho\f$ for the accumulator.
-@param rho_step Distance resolution of the accumulator.
-@param min_theta Minimum angle value of the accumulator in radians.
-@param max_theta Upper bound for the angle value of the accumulator in radians.
-The actual maximum angle may be slightly less than max_theta, depending on the
-parameters min_theta and theta_step.
-@param theta_step Angle resolution of the accumulator in radians.
- */
-CV_EXPORTS_W void HoughLinesPointSet(InputArray point, OutputArray lines,
-                                     int lines_max, int threshold,
-                                     double min_rho, double max_rho,
-                                     double rho_step, double min_theta,
-                                     double max_theta, double theta_step);
-
-/** @example samples/cpp/tutorial_code/ImgTrans/houghcircles.cpp
-An example using the Hough circle detector
-*/
-
-/** @brief Finds circles in a grayscale image using the Hough transform.
-
-The function finds circles in a grayscale image using a modification of the
-Hough transform.
-
-Example: :
-@include snippets/imgproc_HoughLinesCircles.cpp
-
-@note Usually the function detects the centers of circles well. However, it may
-fail to find correct radii. You can assist to the function by specifying the
-radius range ( minRadius and maxRadius ) if you know it. Or, in the case of
-#HOUGH_GRADIENT method you may set maxRadius to a negative number to return
-centers only without radius search, and find the correct radius using an
-additional procedure.
-
-It also helps to smooth image a bit unless it's already soft. For example,
-GaussianBlur() with 7x7 kernel and 1.5x1.5 sigma or similar blurring may help.
-
-@param image 8-bit, single-channel, grayscale input image.
-@param circles Output vector of found circles. Each vector is encoded as  3 or 4
-element floating-point vector \f$(x, y, radius)\f$ or \f$(x, y, radius,
-votes)\f$ .
-@param method Detection method, see #HoughModes. The available methods are
-#HOUGH_GRADIENT and #HOUGH_GRADIENT_ALT.
-@param dp Inverse ratio of the accumulator resolution to the image resolution.
-For example, if dp=1 , the accumulator has the same resolution as the input
-image. If dp=2 , the accumulator has half as big width and height. For
-#HOUGH_GRADIENT_ALT the recommended value is dp=1.5, unless some small very
-circles need to be detected.
-@param minDist Minimum distance between the centers of the detected circles. If
-the parameter is too small, multiple neighbor circles may be falsely detected in
-addition to a true one. If it is too large, some circles may be missed.
-@param param1 First method-specific parameter. In case of #HOUGH_GRADIENT and
-#HOUGH_GRADIENT_ALT, it is the higher threshold of the two passed to the Canny
-edge detector (the lower one is twice smaller). Note that #HOUGH_GRADIENT_ALT
-uses #Scharr algorithm to compute image derivatives, so the threshold value
-should normally be higher, such as 300 or normally exposed and contrasty images.
-@param param2 Second method-specific parameter. In case of #HOUGH_GRADIENT, it
-is the accumulator threshold for the circle centers at the detection stage. The
-smaller it is, the more false circles may be detected. Circles, corresponding to
-the larger accumulator values, will be returned first. In the case of
-#HOUGH_GRADIENT_ALT algorithm, this is the circle "perfectness" measure. The
-closer it to 1, the better shaped circles algorithm selects. In most cases 0.9
-should be fine. If you want get better detection of small circles, you may
-decrease it to 0.85, 0.8 or even less. But then also try to limit the search
-range [minRadius, maxRadius] to avoid many false circles.
-@param minRadius Minimum circle radius.
-@param maxRadius Maximum circle radius. If <= 0, uses the maximum image
-dimension. If < 0, #HOUGH_GRADIENT returns centers without finding the radius.
-#HOUGH_GRADIENT_ALT always computes circle radiuses.
-
-@sa fitEllipse, minEnclosingCircle
- */
-CV_EXPORTS_W void HoughCircles(InputArray image, OutputArray circles,
-                               int method, double dp, double minDist,
-                               double param1 = 100, double param2 = 100,
-                               int minRadius = 0, int maxRadius = 0);
-
-//! @} imgproc_feature
-
-//! @addtogroup imgproc_filter
-//! @{
-
-/** @example samples/cpp/tutorial_code/ImgProc/Morphology_2.cpp
-Advanced morphology Transformations sample code
-![Sample screenshot](Morphology_2_Tutorial_Result.jpg)
-Check @ref tutorial_opening_closing_hats "the corresponding tutorial" for more
-details
-*/
-
-/** @brief Erodes an image by using a specific structuring element.
-
-The function erodes the source image using the specified structuring element
-that determines the shape of a pixel neighborhood over which the minimum is
-taken:
-
-\f[\texttt{dst} (x,y) =  \min _{(x',y'):  \, \texttt{element} (x',y') \ne0 }
-\texttt{src} (x+x',y+y')\f]
-
-The function supports the in-place mode. Erosion can be applied several (
-iterations ) times. In case of multi-channel images, each channel is processed
-independently.
-
-@param src input image; the number of channels can be arbitrary, but the depth
-should be one of CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
-@param dst output image of the same size and type as src.
-@param kernel structuring element used for erosion; if `element=Mat()`, a `3 x
-3` rectangular structuring element is used. Kernel can be created using
-#getStructuringElement.
-@param anchor position of the anchor within the element; default value (-1, -1)
-means that the anchor is at the element center.
-@param iterations number of times erosion is applied.
-@param borderType pixel extrapolation method, see #BorderTypes. #BORDER_WRAP is
-not supported.
-@param borderValue border value in case of a constant border
-@sa  dilate, morphologyEx, getStructuringElement
- */
-CV_EXPORTS_W void
-erode(InputArray src, OutputArray dst, InputArray kernel,
-      Point anchor = Point(-1, -1), int iterations = 1,
-      int borderType = BORDER_CONSTANT,
-      const Scalar &borderValue = morphologyDefaultBorderValue());
-
-/** @example samples/cpp/tutorial_code/ImgProc/Morphology_1.cpp
-Erosion and Dilation sample code
-![Sample Screenshot-Erosion](Morphology_1_Tutorial_Erosion_Result.jpg)![Sample
-Screenshot-Dilation](Morphology_1_Tutorial_Dilation_Result.jpg) Check @ref
-tutorial_erosion_dilatation "the corresponding tutorial" for more details
-*/
-
-/** @brief Dilates an image by using a specific structuring element.
-
-The function dilates the source image using the specified structuring element
-that determines the shape of a pixel neighborhood over which the maximum is
-taken:
-\f[\texttt{dst} (x,y) =  \max _{(x',y'):  \, \texttt{element} (x',y') \ne0 }
-\texttt{src} (x+x',y+y')\f]
-
-The function supports the in-place mode. Dilation can be applied several (
-iterations ) times. In case of multi-channel images, each channel is processed
-independently.
-
-@param src input image; the number of channels can be arbitrary, but the depth
-should be one of CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
-@param dst output image of the same size and type as src.
-@param kernel structuring element used for dilation; if element=Mat(), a 3 x 3
-rectangular structuring element is used. Kernel can be created using
-#getStructuringElement
-@param anchor position of the anchor within the element; default value (-1, -1)
-means that the anchor is at the element center.
-@param iterations number of times dilation is applied.
-@param borderType pixel extrapolation method, see #BorderTypes. #BORDER_WRAP is
-not suported.
-@param borderValue border value in case of a constant border
-@sa  erode, morphologyEx, getStructuringElement
- */
-CV_EXPORTS_W void
-dilate(InputArray src, OutputArray dst, InputArray kernel,
-       Point anchor = Point(-1, -1), int iterations = 1,
-       int borderType = BORDER_CONSTANT,
-       const Scalar &borderValue = morphologyDefaultBorderValue());
-
-/** @brief Performs advanced morphological transformations.
-
-The function cv::morphologyEx can perform advanced morphological transformations
-using an erosion and dilation as basic operations.
-
-Any of the operations can be done in-place. In case of multi-channel images,
-each channel is processed independently.
-
-@param src Source image. The number of channels can be arbitrary. The depth
-should be one of CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
-@param dst Destination image of the same size and type as source image.
-@param op Type of a morphological operation, see #MorphTypes
-@param kernel Structuring element. It can be created using
-#getStructuringElement.
-@param anchor Anchor position with the kernel. Negative values mean that the
-anchor is at the kernel center.
-@param iterations Number of times erosion and dilation are applied.
-@param borderType Pixel extrapolation method, see #BorderTypes. #BORDER_WRAP is
-not supported.
-@param borderValue Border value in case of a constant border. The default value
-has a special meaning.
-@sa  dilate, erode, getStructuringElement
-@note The number of iterations is the number of times erosion or dilatation
-operation will be applied. For instance, an opening operation (#MORPH_OPEN) with
-two iterations is equivalent to apply successively: erode -> erode -> dilate ->
-dilate (and not erode -> dilate -> erode -> dilate).
- */
-CV_EXPORTS_W void
-morphologyEx(InputArray src, OutputArray dst, int op, InputArray kernel,
-             Point anchor = Point(-1, -1), int iterations = 1,
-             int borderType = BORDER_CONSTANT,
-             const Scalar &borderValue = morphologyDefaultBorderValue());
-
-//! @} imgproc_filter
-
-//! @addtogroup imgproc_transform
-//! @{
-
-/** @brief Resizes an image.
-
-The function resize resizes the image src down to or up to the specified size.
-Note that the initial dst type or size are not taken into account. Instead, the
-size and type are derived from the `src`,`dsize`,`fx`, and `fy`. If you want to
-resize src so that it fits the pre-created dst, you may call the function as
-follows:
-@code
-    // explicitly specify dsize=dst.size(); fx and fy will be computed from
-that. resize(src, dst, dst.size(), 0, 0, interpolation);
-@endcode
-If you want to decimate the image by factor of 2 in each direction, you can call
-the function this way:
-@code
-    // specify fx and fy and let the function compute the destination image
-size. resize(src, dst, Size(), 0.5, 0.5, interpolation);
-@endcode
-To shrink an image, it will generally look best with #INTER_AREA interpolation,
-whereas to enlarge an image, it will generally look best with #INTER_CUBIC
-(slow) or #INTER_LINEAR (faster but still looks OK).
-
-@param src input image.
-@param dst output image; it has the size dsize (when it is non-zero) or the size
-computed from src.size(), fx, and fy; the type of dst is the same as of src.
-@param dsize output image size; if it equals zero (`None` in Python), it is
-computed as:
- \f[\texttt{dsize = Size(round(fx*src.cols), round(fy*src.rows))}\f]
- Either dsize or both fx and fy must be non-zero.
-@param fx scale factor along the horizontal axis; when it equals 0, it is
-computed as
-\f[\texttt{(double)dsize.width/src.cols}\f]
-@param fy scale factor along the vertical axis; when it equals 0, it is computed
-as
-\f[\texttt{(double)dsize.height/src.rows}\f]
-@param interpolation interpolation method, see #InterpolationFlags
-
-@sa  warpAffine, warpPerspective, remap
- */
-CV_EXPORTS_W void resize(InputArray src, OutputArray dst, Size dsize,
-                         double fx = 0, double fy = 0,
-                         int interpolation = INTER_LINEAR);
-
-/** @brief Applies an affine transformation to an image.
-
-The function warpAffine transforms the source image using the specified matrix:
-
-\f[\texttt{dst} (x,y) =  \texttt{src} ( \texttt{M} _{11} x +  \texttt{M} _{12} y
-+  \texttt{M} _{13}, \texttt{M} _{21} x +  \texttt{M} _{22} y +  \texttt{M}
-_{23})\f]
-
-when the flag #WARP_INVERSE_MAP is set. Otherwise, the transformation is first
-inverted with #invertAffineTransform and then put in the formula above instead
-of M. The function cannot operate in-place.
-
-@param src input image.
-@param dst output image that has the size dsize and the same type as src .
-@param M \f$2\times 3\f$ transformation matrix.
-@param dsize size of the output image.
-@param flags combination of interpolation methods (see #InterpolationFlags) and
-the optional flag #WARP_INVERSE_MAP that means that M is the inverse
-transformation (
-\f$\texttt{dst}\rightarrow\texttt{src}\f$ ).
-@param borderMode pixel extrapolation method (see #BorderTypes); when
-borderMode=#BORDER_TRANSPARENT, it means that the pixels in the destination
-image corresponding to the "outliers" in the source image are not modified by
-the function.
-@param borderValue value used in case of a constant border; by default, it is 0.
-
-@sa  warpPerspective, resize, remap, getRectSubPix, transform
- */
-CV_EXPORTS_W void warpAffine(InputArray src, OutputArray dst, InputArray M,
-                             Size dsize, int flags = INTER_LINEAR,
-                             int borderMode = BORDER_CONSTANT,
-                             const Scalar &borderValue = Scalar());
-
-/** @example samples/cpp/warpPerspective_demo.cpp
-An example program shows using cv::getPerspectiveTransform and
-cv::warpPerspective for image warping
-*/
-
-/** @brief Applies a perspective transformation to an image.
-
-The function warpPerspective transforms the source image using the specified
-matrix:
-
-\f[\texttt{dst} (x,y) =  \texttt{src} \left ( \frac{M_{11} x + M_{12} y +
-M_{13}}{M_{31} x + M_{32} y + M_{33}} ,
-     \frac{M_{21} x + M_{22} y + M_{23}}{M_{31} x + M_{32} y + M_{33}} \right
-)\f]
-
-when the flag #WARP_INVERSE_MAP is set. Otherwise, the transformation is first
-inverted with invert and then put in the formula above instead of M. The
-function cannot operate in-place.
-
-@param src input image.
-@param dst output image that has the size dsize and the same type as src .
-@param M \f$3\times 3\f$ transformation matrix.
-@param dsize size of the output image.
-@param flags combination of interpolation methods (#INTER_LINEAR or
-#INTER_NEAREST) and the optional flag #WARP_INVERSE_MAP, that sets M as the
-inverse transformation (
-\f$\texttt{dst}\rightarrow\texttt{src}\f$ ).
-@param borderMode pixel extrapolation method (#BORDER_CONSTANT or
-#BORDER_REPLICATE).
-@param borderValue value used in case of a constant border; by default, it
-equals 0.
-
-@sa  warpAffine, resize, remap, getRectSubPix, perspectiveTransform
- */
-CV_EXPORTS_W void warpPerspective(InputArray src, OutputArray dst, InputArray M,
-                                  Size dsize, int flags = INTER_LINEAR,
-                                  int borderMode = BORDER_CONSTANT,
-                                  const Scalar &borderValue = Scalar());
-
-/** @brief Applies a generic geometrical transformation to an image.
-
-The function remap transforms the source image using the specified map:
-
-\f[\texttt{dst} (x,y) =  \texttt{src} (map_x(x,y),map_y(x,y))\f]
-
-with the WARP_RELATIVE_MAP flag :
-
-\f[\texttt{dst} (x,y) =  \texttt{src} (x+map_x(x,y),y+map_y(x,y))\f]
-
-where values of pixels with non-integer coordinates are computed using one of
-available interpolation methods. \f$map_x\f$ and \f$map_y\f$ can be encoded as
-separate floating-point maps in \f$map_1\f$ and \f$map_2\f$ respectively, or
-interleaved floating-point maps of \f$(x,y)\f$ in
-\f$map_1\f$, or fixed-point maps created by using #convertMaps. The reason you
-might want to convert from floating to fixed-point representations of a map is
-that they can yield much faster
-(\~2x) remapping operations. In the converted case, \f$map_1\f$ contains pairs
-(cvFloor(x), cvFloor(y)) and \f$map_2\f$ contains indices in a table of
-interpolation coefficients.
-
-This function cannot operate in-place.
-
-@param src Source image.
-@param dst Destination image. It has the same size as map1 and the same type as
-src .
-@param map1 The first map of either (x,y) points or just x values having the
-type CV_16SC2 , CV_32FC1, or CV_32FC2. See #convertMaps for details on
-converting a floating point representation to fixed-point for speed.
-@param map2 The second map of y values having the type CV_16UC1, CV_32FC1, or
-none (empty map if map1 is (x,y) points), respectively.
-@param interpolation Interpolation method (see #InterpolationFlags). The methods
-#INTER_AREA #INTER_LINEAR_EXACT and #INTER_NEAREST_EXACT are not supported by
-this function. The extra flag WARP_RELATIVE_MAP can be ORed to the interpolation
-method (e.g. INTER_LINEAR | WARP_RELATIVE_MAP)
-@param borderMode Pixel extrapolation method (see #BorderTypes). When
-borderMode=#BORDER_TRANSPARENT, it means that the pixels in the destination
-image that corresponds to the "outliers" in the source image are not modified by
-the function.
-@param borderValue Value used in case of a constant border. By default, it is 0.
-@note
-Due to current implementation limitations the size of an input and output images
-should be less than 32767x32767.
- */
-CV_EXPORTS_W void remap(InputArray src, OutputArray dst, InputArray map1,
-                        InputArray map2, int interpolation,
-                        int borderMode = BORDER_CONSTANT,
-                        const Scalar &borderValue = Scalar());
-
-/** @brief Converts image transformation maps from one representation to
-another.
-
-The function converts a pair of maps for remap from one representation to
-another. The following options ( (map1.type(), map2.type()) \f$\rightarrow\f$
-(dstmap1.type(), dstmap2.type()) ) are supported:
-
-- \f$\texttt{(CV_32FC1, CV_32FC1)} \rightarrow \texttt{(CV_16SC2, CV_16UC1)}\f$.
-This is the most frequently used conversion operation, in which the original
-floating-point maps (see #remap) are converted to a more compact and much faster
-fixed-point representation. The first output array contains the rounded
-coordinates and the second array (created only when nninterpolation=false )
-contains indices in the interpolation tables.
-
-- \f$\texttt{(CV_32FC2)} \rightarrow \texttt{(CV_16SC2, CV_16UC1)}\f$. The same
-as above but the original maps are stored in one 2-channel matrix.
-
-- Reverse conversion. Obviously, the reconstructed floating-point maps will not
-be exactly the same as the originals.
-
-@param map1 The first input map of type CV_16SC2, CV_32FC1, or CV_32FC2 .
-@param map2 The second input map of type CV_16UC1, CV_32FC1, or none (empty
-matrix), respectively.
-@param dstmap1 The first output map that has the type dstmap1type and the same
-size as src .
-@param dstmap2 The second output map.
-@param dstmap1type Type of the first output map that should be CV_16SC2,
-CV_32FC1, or CV_32FC2 .
-@param nninterpolation Flag indicating whether the fixed-point maps are used for
-the nearest-neighbor or for a more complex interpolation.
-
-@sa  remap, undistort, initUndistortRectifyMap
- */
-CV_EXPORTS_W void convertMaps(InputArray map1, InputArray map2,
-                              OutputArray dstmap1, OutputArray dstmap2,
-                              int dstmap1type, bool nninterpolation = false);
-
-/** @brief Calculates an affine matrix of 2D rotation.
-
-The function calculates the following matrix:
-
-\f[\begin{bmatrix} \alpha &  \beta & (1- \alpha )  \cdot \texttt{center.x} -
-\beta \cdot \texttt{center.y} \\ - \beta &  \alpha &  \beta \cdot
-\texttt{center.x} + (1- \alpha )  \cdot \texttt{center.y} \end{bmatrix}\f]
-
-where
-
-\f[\begin{array}{l} \alpha =  \texttt{scale} \cdot \cos \texttt{angle} ,
-\\ \beta =  \texttt{scale} \cdot \sin \texttt{angle} \end{array}\f]
-
-The transformation maps the rotation center to itself. If this is not the
-target, adjust the shift.
-
-@param center Center of the rotation in the source image.
-@param angle Rotation angle in degrees. Positive values mean counter-clockwise
-rotation (the coordinate origin is assumed to be the top-left corner).
-@param scale Isotropic scale factor.
-
-@sa  getAffineTransform, warpAffine, transform
- */
-CV_EXPORTS_W Mat getRotationMatrix2D(Point2f center, double angle,
-                                     double scale);
-
-/** @sa getRotationMatrix2D */
-CV_EXPORTS Matx23d getRotationMatrix2D_(Point2f center, double angle,
-                                        double scale);
-
-inline Mat getRotationMatrix2D(Point2f center, double angle, double scale) {
-  return Mat(getRotationMatrix2D_(center, angle, scale), true);
-}
-
-/** @brief Calculates an affine transform from three pairs of the corresponding
-points.
-
-The function calculates the \f$2 \times 3\f$ matrix of an affine transform so
-that:
-
-\f[\begin{bmatrix} x'_i \\ y'_i \end{bmatrix} = \texttt{map_matrix} \cdot
-\begin{bmatrix} x_i \\ y_i \\ 1 \end{bmatrix}\f]
-
-where
-
-\f[dst(i)=(x'_i,y'_i), src(i)=(x_i, y_i), i=0,1,2\f]
-
-@param src Coordinates of triangle vertices in the source image.
-@param dst Coordinates of the corresponding triangle vertices in the destination
-image.
-
-@sa  warpAffine, transform
- */
-CV_EXPORTS Mat getAffineTransform(const Point2f src[], const Point2f dst[]);
-
-/** @brief Inverts an affine transformation.
-
-The function computes an inverse affine transformation represented by \f$2
-\times 3\f$ matrix M:
-
-\f[\begin{bmatrix} a_{11} & a_{12} & b_1  \\ a_{21} & a_{22} & b_2
-\end{bmatrix}\f]
-
-The result is also a \f$2 \times 3\f$ matrix of the same type as M.
-
-@param M Original affine transformation.
-@param iM Output reverse affine transformation.
- */
-CV_EXPORTS_W void invertAffineTransform(InputArray M, OutputArray iM);
-
-/** @brief Calculates a perspective transform from four pairs of the
-corresponding points.
-
-The function calculates the \f$3 \times 3\f$ matrix of a perspective transform
-so that:
-
-\f[\begin{bmatrix} t_i x'_i \\ t_i y'_i \\ t_i \end{bmatrix} =
-\texttt{map_matrix} \cdot \begin{bmatrix} x_i \\ y_i \\ 1 \end{bmatrix}\f]
-
-where
-
-\f[dst(i)=(x'_i,y'_i), src(i)=(x_i, y_i), i=0,1,2,3\f]
-
-@param src Coordinates of quadrangle vertices in the source image.
-@param dst Coordinates of the corresponding quadrangle vertices in the
-destination image.
-@param solveMethod method passed to cv::solve (#DecompTypes)
-
-@sa  findHomography, warpPerspective, perspectiveTransform
- */
-CV_EXPORTS_W Mat getPerspectiveTransform(InputArray src, InputArray dst,
-                                         int solveMethod = DECOMP_LU);
-
-/** @overload */
-CV_EXPORTS Mat getPerspectiveTransform(const Point2f src[], const Point2f dst[],
-                                       int solveMethod = DECOMP_LU);
-
-CV_EXPORTS_W Mat getAffineTransform(InputArray src, InputArray dst);
-
-/** @brief Retrieves a pixel rectangle from an image with sub-pixel accuracy.
-
-The function getRectSubPix extracts pixels from src:
-
-\f[patch(x, y) = src(x +  \texttt{center.x} - ( \texttt{dst.cols} -1)*0.5, y +
-\texttt{center.y} - ( \texttt{dst.rows} -1)*0.5)\f]
-
-where the values of the pixels at non-integer coordinates are retrieved using
-bilinear interpolation. Every channel of multi-channel images is processed
-independently. Also the image should be a single channel or three channel image.
-While the center of the rectangle must be inside the image, parts of the
-rectangle may be outside.
-
-@param image Source image.
-@param patchSize Size of the extracted patch.
-@param center Floating point coordinates of the center of the extracted
-rectangle within the source image. The center must be inside the image.
-@param patch Extracted patch that has the size patchSize and the same number of
-channels as src .
-@param patchType Depth of the extracted pixels. By default, they have the same
-depth as src .
-
-@sa  warpAffine, warpPerspective
- */
-CV_EXPORTS_W void getRectSubPix(InputArray image, Size patchSize,
-                                Point2f center, OutputArray patch,
-                                int patchType = -1);
-
-/** @example samples/cpp/polar_transforms.cpp
-An example using the cv::linearPolar and cv::logPolar operations
-*/
-
-/** @brief Remaps an image to semilog-polar coordinates space.
-
-@deprecated This function produces same result as cv::warpPolar(src, dst,
-src.size(), center, maxRadius, flags+WARP_POLAR_LOG);
-
-@internal
-Transform the source image using the following transformation (See @ref
-polar_remaps_reference_image "Polar remaps reference image d)"):
-\f[\begin{array}{l}
-  dst( \rho , \phi ) = src(x,y) \\
-  dst.size() \leftarrow src.size()
-\end{array}\f]
-
-where
-\f[\begin{array}{l}
-  I = (dx,dy) = (x - center.x,y - center.y) \\
-  \rho = M \cdot log_e(\texttt{magnitude} (I)) ,\\
-  \phi = Kangle \cdot \texttt{angle} (I) \\
-\end{array}\f]
-
-and
-\f[\begin{array}{l}
-  M = src.cols / log_e(maxRadius) \\
-  Kangle = src.rows / 2\Pi \\
-\end{array}\f]
-
-The function emulates the human "foveal" vision and can be used for fast scale
-and rotation-invariant template matching, for object tracking and so forth.
-@param src Source image
-@param dst Destination image. It will have same size and type as src.
-@param center The transformation center; where the output precision is maximal
-@param M Magnitude scale parameter. It determines the radius of the bounding
-circle to transform too.
-@param flags A combination of interpolation methods, see #InterpolationFlags
-
-@note
--   The function can not operate in-place.
--   To calculate magnitude and angle in degrees #cartToPolar is used internally
-thus angles are measured from 0 to 360 with accuracy about 0.3 degrees.
-
-@sa cv::linearPolar
-@endinternal
-*/
-CV_EXPORTS_W void logPolar(InputArray src, OutputArray dst, Point2f center,
-                           double M, int flags);
-
-/** @brief Remaps an image to polar coordinates space.
-
-@deprecated This function produces same result as cv::warpPolar(src, dst,
-src.size(), center, maxRadius, flags)
-
-@internal
-Transform the source image using the following transformation (See @ref
-polar_remaps_reference_image "Polar remaps reference image c)"):
-\f[\begin{array}{l}
-  dst( \rho , \phi ) = src(x,y) \\
-  dst.size() \leftarrow src.size()
-\end{array}\f]
-
-where
-\f[\begin{array}{l}
-  I = (dx,dy) = (x - center.x,y - center.y) \\
-  \rho = Kmag \cdot \texttt{magnitude} (I) ,\\
-  \phi = angle \cdot \texttt{angle} (I)
-\end{array}\f]
-
-and
-\f[\begin{array}{l}
-  Kx = src.cols / maxRadius \\
-  Ky = src.rows / 2\Pi
-\end{array}\f]
-
-
-@param src Source image
-@param dst Destination image. It will have same size and type as src.
-@param center The transformation center;
-@param maxRadius The radius of the bounding circle to transform. It determines
-the inverse magnitude scale parameter too.
-@param flags A combination of interpolation methods, see #InterpolationFlags
-
-@note
--   The function can not operate in-place.
--   To calculate magnitude and angle in degrees #cartToPolar is used internally
-thus angles are measured from 0 to 360 with accuracy about 0.3 degrees.
-
-@sa cv::logPolar
-@endinternal
-*/
-CV_EXPORTS_W void linearPolar(InputArray src, OutputArray dst, Point2f center,
-                              double maxRadius, int flags);
-
-/** \brief Remaps an image to polar or semilog-polar coordinates space
-
-@anchor polar_remaps_reference_image
-![Polar remaps reference](pics/polar_remap_doc.png)
-
-Transform the source image using the following transformation:
-\f[
-dst(\rho , \phi ) = src(x,y)
-\f]
-
-where
-\f[
-\begin{array}{l}
-\vec{I} = (x - center.x, \;y - center.y) \\
-\phi = Kangle \cdot \texttt{angle} (\vec{I}) \\
-\rho = \left\{\begin{matrix}
-Klin \cdot \texttt{magnitude} (\vec{I}) & default \\
-Klog \cdot log_e(\texttt{magnitude} (\vec{I})) & if \; semilog \\
-\end{matrix}\right.
-\end{array}
-\f]
-
-and
-\f[
-\begin{array}{l}
-Kangle = dsize.height / 2\Pi \\
-Klin = dsize.width / maxRadius \\
-Klog = dsize.width / log_e(maxRadius) \\
-\end{array}
-\f]
-
-
-\par Linear vs semilog mapping
-
-Polar mapping can be linear or semi-log. Add one of #WarpPolarMode to `flags` to
-specify the polar mapping mode.
-
-Linear is the default mode.
-
-The semilog mapping emulates the human "foveal" vision that permit very high
-acuity on the line of sight (central vision) in contrast to peripheral vision
-where acuity is minor.
-
-\par Option on `dsize`:
-
-- if both values in `dsize <=0 ` (default),
-the destination image will have (almost) same area of source bounding circle:
-\f[\begin{array}{l}
-dsize.area  \leftarrow (maxRadius^2 \cdot \Pi) \\
-dsize.width = \texttt{cvRound}(maxRadius) \\
-dsize.height = \texttt{cvRound}(maxRadius \cdot \Pi) \\
-\end{array}\f]
-
-
-- if only `dsize.height <= 0`,
-the destination image area will be proportional to the bounding circle area but
-scaled by `Kx * Kx`:
-\f[\begin{array}{l}
-dsize.height = \texttt{cvRound}(dsize.width \cdot \Pi) \\
-\end{array}
-\f]
-
-- if both values in `dsize > 0 `,
-the destination image will have the given size therefore the area of the
-bounding circle will be scaled to `dsize`.
-
-
-\par Reverse mapping
-
-You can get reverse mapping adding #WARP_INVERSE_MAP to `flags`
-\snippet polar_transforms.cpp InverseMap
-
-In addiction, to calculate the original coordinate from a polar mapped
-coordinate \f$(rho, phi)->(x, y)\f$:
-\snippet polar_transforms.cpp InverseCoordinate
-
-@param src Source image.
-@param dst Destination image. It will have same type as src.
-@param dsize The destination image size (see description for valid options).
-@param center The transformation center.
-@param maxRadius The radius of the bounding circle to transform. It determines
-the inverse magnitude scale parameter too.
-@param flags A combination of interpolation methods, #InterpolationFlags +
-#WarpPolarMode.
-            - Add #WARP_POLAR_LINEAR to select linear polar mapping (default)
-            - Add #WARP_POLAR_LOG to select semilog polar mapping
-            - Add #WARP_INVERSE_MAP for reverse mapping.
-@note
--  The function can not operate in-place.
--  To calculate magnitude and angle in degrees #cartToPolar is used internally
-thus angles are measured from 0 to 360 with accuracy about 0.3 degrees.
--  This function uses #remap. Due to current implementation limitations the size
-of an input and output images should be less than 32767x32767.
-
-@sa cv::remap
-*/
-CV_EXPORTS_W void warpPolar(InputArray src, OutputArray dst, Size dsize,
-                            Point2f center, double maxRadius, int flags);
-
-//! @} imgproc_transform
-
-//! @addtogroup imgproc_misc
-//! @{
-
-/** @brief Calculates the integral of an image.
-
-The function calculates one or more integral images for the source image as
-follows:
-
-\f[\texttt{sum} (X,Y) =  \sum _{x<X,y<Y}  \texttt{image} (x,y)\f]
-
-\f[\texttt{sqsum} (X,Y) =  \sum _{x<X,y<Y}  \texttt{image} (x,y)^2\f]
-
-\f[\texttt{tilted} (X,Y) =  \sum _{y<Y,abs(x-X+1) \leq Y-y-1}  \texttt{image}
-(x,y)\f]
-
-Using these integral images, you can calculate sum, mean, and standard deviation
-over a specific up-right or rotated rectangular region of the image in a
-constant time, for example:
-
-\f[\sum _{x_1 \leq x < x_2,  \, y_1  \leq y < y_2}  \texttt{image} (x,y) =
-\texttt{sum} (x_2,y_2)- \texttt{sum} (x_1,y_2)- \texttt{sum} (x_2,y_1)+
-\texttt{sum} (x_1,y_1)\f]
-
-It makes possible to do a fast blurring or fast block correlation with a
-variable window size, for example. In case of multi-channel images, sums for
-each channel are accumulated independently.
-
-As a practical example, the next figure shows the calculation of the integral of
-a straight rectangle Rect(4,4,3,2) and of a tilted rectangle Rect(5,1,2,3) . The
-selected pixels in the original image are shown, as well as the relative pixels
-in the integral images sum and tilted .
-
-![integral calculation example](pics/integral.png)
-
-@param src input image as \f$W \times H\f$, 8-bit or floating-point (32f or
-64f).
-@param sum integral image as \f$(W+1)\times (H+1)\f$ , 32-bit integer or
-floating-point (32f or 64f).
-@param sqsum integral image for squared pixel values; it is \f$(W+1)\times
-(H+1)\f$, double-precision floating-point (64f) array.
-@param tilted integral for the image rotated by 45 degrees; it is \f$(W+1)\times
-(H+1)\f$ array with the same data type as sum.
-@param sdepth desired depth of the integral and the tilted integral images,
-CV_32S, CV_32F, or CV_64F.
-@param sqdepth desired depth of the integral image of squared pixel values,
-CV_32F or CV_64F.
- */
-CV_EXPORTS_AS(integral3)
-void integral(InputArray src, OutputArray sum, OutputArray sqsum,
-              OutputArray tilted, int sdepth = -1, int sqdepth = -1);
-
-/** @overload */
-CV_EXPORTS_W void integral(InputArray src, OutputArray sum, int sdepth = -1);
-
-/** @overload */
-CV_EXPORTS_AS(integral2)
-void integral(InputArray src, OutputArray sum, OutputArray sqsum,
-              int sdepth = -1, int sqdepth = -1);
-
-//! @} imgproc_misc
-
-//! @addtogroup imgproc_motion
-//! @{
-
-/** @brief Adds an image to the accumulator image.
-
-The function adds src or some of its elements to dst :
-
-\f[\texttt{dst} (x,y)  \leftarrow \texttt{dst} (x,y) +  \texttt{src} (x,y) \quad
-\text{if} \quad \texttt{mask} (x,y)  \ne 0\f]
-
-The function supports multi-channel images. Each channel is processed
-independently.
-
-The function cv::accumulate can be used, for example, to collect statistics of a
-scene background viewed by a still camera and for the further
-foreground-background segmentation.
-
-@param src Input image of type CV_8UC(n), CV_16UC(n), CV_32FC(n) or CV_64FC(n),
-where n is a positive integer.
-@param dst %Accumulator image with the same number of channels as input image,
-and a depth of CV_32F or CV_64F.
-@param mask Optional operation mask.
-
-@sa  accumulateSquare, accumulateProduct, accumulateWeighted
- */
-CV_EXPORTS_W void accumulate(InputArray src, InputOutputArray dst,
-                             InputArray mask = noArray());
-
-/** @brief Adds the square of a source image to the accumulator image.
-
-The function adds the input image src or its selected region, raised to a power
-of 2, to the accumulator dst :
-
-\f[\texttt{dst} (x,y)  \leftarrow \texttt{dst} (x,y) +  \texttt{src} (x,y)^2
-\quad \text{if} \quad \texttt{mask} (x,y)  \ne 0\f]
-
-The function supports multi-channel images. Each channel is processed
-independently.
-
-@param src Input image as 1- or 3-channel, 8-bit or 32-bit floating point.
-@param dst %Accumulator image with the same number of channels as input image,
-32-bit or 64-bit floating-point.
-@param mask Optional operation mask.
-
-@sa  accumulateSquare, accumulateProduct, accumulateWeighted
- */
-CV_EXPORTS_W void accumulateSquare(InputArray src, InputOutputArray dst,
-                                   InputArray mask = noArray());
-
-/** @brief Adds the per-element product of two input images to the accumulator
-image.
-
-The function adds the product of two images or their selected regions to the
-accumulator dst :
-
-\f[\texttt{dst} (x,y)  \leftarrow \texttt{dst} (x,y) +  \texttt{src1} (x,y)
-\cdot \texttt{src2} (x,y)  \quad \text{if} \quad \texttt{mask} (x,y)  \ne 0\f]
-
-The function supports multi-channel images. Each channel is processed
-independently.
-
-@param src1 First input image, 1- or 3-channel, 8-bit or 32-bit floating point.
-@param src2 Second input image of the same type and the same size as src1 .
-@param dst %Accumulator image with the same number of channels as input images,
-32-bit or 64-bit floating-point.
-@param mask Optional operation mask.
-
-@sa  accumulate, accumulateSquare, accumulateWeighted
- */
-CV_EXPORTS_W void accumulateProduct(InputArray src1, InputArray src2,
-                                    InputOutputArray dst,
-                                    InputArray mask = noArray());
-
-/** @brief Updates a running average.
-
-The function calculates the weighted sum of the input image src and the
-accumulator dst so that dst becomes a running average of a frame sequence:
-
-\f[\texttt{dst} (x,y)  \leftarrow (1- \texttt{alpha} )  \cdot \texttt{dst} (x,y)
-+  \texttt{alpha} \cdot \texttt{src} (x,y)  \quad \text{if} \quad \texttt{mask}
-(x,y)  \ne 0\f]
-
-That is, alpha regulates the update speed (how fast the accumulator "forgets"
-about earlier images). The function supports multi-channel images. Each channel
-is processed independently.
-
-@param src Input image as 1- or 3-channel, 8-bit or 32-bit floating point.
-@param dst %Accumulator image with the same number of channels as input image,
-32-bit or 64-bit floating-point.
-@param alpha Weight of the input image.
-@param mask Optional operation mask.
-
-@sa  accumulate, accumulateSquare, accumulateProduct
- */
-CV_EXPORTS_W void accumulateWeighted(InputArray src, InputOutputArray dst,
-                                     double alpha, InputArray mask = noArray());
-
-/** @brief The function is used to detect translational shifts that occur
-between two images.
-
-The operation takes advantage of the Fourier shift theorem for detecting the
-translational shift in the frequency domain. It can be used for fast image
-registration as well as motion estimation. For more information please see
-<http://en.wikipedia.org/wiki/Phase_correlation>
-
-Calculates the cross-power spectrum of two supplied source arrays. The arrays
-are padded if needed with getOptimalDFTSize.
-
-The function performs the following equations:
-- First it applies a Hanning window (see
-<http://en.wikipedia.org/wiki/Hann_function>) to each image to remove possible
-edge effects. This window is cached until the array size changes to speed up
-processing time.
-- Next it computes the forward DFTs of each source array:
-\f[\mathbf{G}_a = \mathcal{F}\{src_1\}, \; \mathbf{G}_b =
-\mathcal{F}\{src_2\}\f] where \f$\mathcal{F}\f$ is the forward DFT.
-- It then computes the cross-power spectrum of each frequency domain array:
-\f[R = \frac{ \mathbf{G}_a \mathbf{G}_b^*}{|\mathbf{G}_a \mathbf{G}_b^*|}\f]
-- Next the cross-correlation is converted back into the time domain via the
-inverse DFT:
-\f[r = \mathcal{F}^{-1}\{R\}\f]
-- Finally, it computes the peak location and computes a 5x5 weighted centroid
-around the peak to achieve sub-pixel accuracy.
-\f[(\Delta x, \Delta y) = \texttt{weightedCentroid} \{\arg \max_{(x,
-y)}\{r\}\}\f]
-- If non-zero, the response parameter is computed as the sum of the elements of
-r within the 5x5 centroid around the peak location. It is normalized to a
-maximum of 1 (meaning there is a single peak) and will be smaller when there are
-multiple peaks.
-
-@param src1 Source floating point array (CV_32FC1 or CV_64FC1)
-@param src2 Source floating point array (CV_32FC1 or CV_64FC1)
-@param window Floating point array with windowing coefficients to reduce edge
-effects (optional).
-@param response Signal power within the 5x5 centroid around the peak, between 0
-and 1 (optional).
-@returns detected phase shift (sub-pixel) between the two arrays.
-
-@sa dft, getOptimalDFTSize, idft, mulSpectrums createHanningWindow
- */
-CV_EXPORTS_W Point2d phaseCorrelate(InputArray src1, InputArray src2,
-                                    InputArray window = noArray(),
-                                    CV_OUT double *response = 0);
-
-/** @brief This function computes a Hanning window coefficients in two
-dimensions.
-
-See (http://en.wikipedia.org/wiki/Hann_function) and
-(http://en.wikipedia.org/wiki/Window_function) for more information.
-
-An example is shown below:
-@code
-    // create hanning window of size 100x100 and type CV_32F
-    Mat hann;
-    createHanningWindow(hann, Size(100, 100), CV_32F);
-@endcode
-@param dst Destination array to place Hann coefficients in
-@param winSize The window size specifications (both width and height must be >
-1)
-@param type Created array type
- */
-CV_EXPORTS_W void createHanningWindow(OutputArray dst, Size winSize, int type);
-
-/** @brief Performs the per-element division of the first Fourier spectrum by
-the second Fourier spectrum.
-
-The function cv::divSpectrums performs the per-element division of the first
-array by the second array. The arrays are CCS-packed or complex matrices that
-are results of a real or complex Fourier transform.
-
-@param a first input array.
-@param b second input array of the same size and type as src1 .
-@param c output array of the same size and type as src1 .
-@param flags operation flags; currently, the only supported flag is
-cv::DFT_ROWS, which indicates that each row of src1 and src2 is an independent
-1D Fourier spectrum. If you do not want to use this flag, then simply add a `0`
-as value.
-@param conjB optional flag that conjugates the second input array before the
-multiplication (true) or not (false).
-*/
-CV_EXPORTS_W void divSpectrums(InputArray a, InputArray b, OutputArray c,
-                               int flags, bool conjB = false);
-
-//! @} imgproc_motion
-
-//! @addtogroup imgproc_misc
-//! @{
-
-/** @brief Applies a fixed-level threshold to each array element.
-
-The function applies fixed-level thresholding to a multiple-channel array. The
-function is typically used to get a bi-level (binary) image out of a grayscale
-image ( #compare could be also used for this purpose) or for removing a noise,
-that is, filtering out pixels with too small or too large values. There are
-several types of thresholding supported by the function. They are determined by
-type parameter.
-
-Also, the special values #THRESH_OTSU or #THRESH_TRIANGLE may be combined with
-one of the above values. In these cases, the function determines the optimal
-threshold value using the Otsu's or Triangle algorithm and uses it instead of
-the specified thresh.
-
-@note Currently, the Otsu's and Triangle methods are implemented only for 8-bit
-single-channel images.
-
-@param src input array (multiple-channel, 8-bit or 32-bit floating point).
-@param dst output array of the same size  and type and the same number of
-channels as src.
-@param thresh threshold value.
-@param maxval maximum value to use with the #THRESH_BINARY and
-#THRESH_BINARY_INV thresholding types.
-@param type thresholding type (see #ThresholdTypes).
-@return the computed threshold value if Otsu's or Triangle methods used.
-
-@sa  adaptiveThreshold, findContours, compare, min, max
- */
-CV_EXPORTS_W double threshold(InputArray src, OutputArray dst, double thresh,
-                              double maxval, int type);
-
-/** @brief Applies an adaptive threshold to an array.
-
-The function transforms a grayscale image to a binary image according to the
-formulae:
--   **THRESH_BINARY**
-    \f[dst(x,y) =  \fork{\texttt{maxValue}}{if \(src(x,y) >
-T(x,y)\)}{0}{otherwise}\f]
--   **THRESH_BINARY_INV**
-    \f[dst(x,y) =  \fork{0}{if \(src(x,y) >
-T(x,y)\)}{\texttt{maxValue}}{otherwise}\f] where \f$T(x,y)\f$ is a threshold
-calculated individually for each pixel (see adaptiveMethod parameter).
-
-The function can process the image in-place.
-
-@param src Source 8-bit single-channel image.
-@param dst Destination image of the same size and the same type as src.
-@param maxValue Non-zero value assigned to the pixels for which the condition is
-satisfied
-@param adaptiveMethod Adaptive thresholding algorithm to use, see
-#AdaptiveThresholdTypes. The #BORDER_REPLICATE | #BORDER_ISOLATED is used to
-process boundaries.
-@param thresholdType Thresholding type that must be either #THRESH_BINARY or
-#THRESH_BINARY_INV, see #ThresholdTypes.
-@param blockSize Size of a pixel neighborhood that is used to calculate a
-threshold value for the pixel: 3, 5, 7, and so on.
-@param C Constant subtracted from the mean or weighted mean (see the details
-below). Normally, it is positive but may be zero or negative as well.
-
-@sa  threshold, blur, GaussianBlur
- */
-CV_EXPORTS_W void adaptiveThreshold(InputArray src, OutputArray dst,
-                                    double maxValue, int adaptiveMethod,
-                                    int thresholdType, int blockSize, double C);
-
-//! @} imgproc_misc
-
-//! @addtogroup imgproc_filter
-//! @{
-
-/** @example samples/cpp/tutorial_code/ImgProc/Pyramids/Pyramids.cpp
-An example using pyrDown and pyrUp functions
-*/
-
-/** @brief Blurs an image and downsamples it.
-
-By default, size of the output image is computed as `Size((src.cols+1)/2,
-(src.rows+1)/2)`, but in any case, the following conditions should be satisfied:
-
-\f[\begin{array}{l} | \texttt{dstsize.width} *2-src.cols| \leq 2 \\ |
-\texttt{dstsize.height} *2-src.rows| \leq 2 \end{array}\f]
-
-The function performs the downsampling step of the Gaussian pyramid
-construction. First, it convolves the source image with the kernel:
-
-\f[\frac{1}{256} \begin{bmatrix} 1 & 4 & 6 & 4 & 1  \\ 4 & 16 & 24 & 16 & 4 \\ 6
-& 24 & 36 & 24 & 6  \\ 4 & 16 & 24 & 16 & 4  \\ 1 & 4 & 6 & 4 & 1
-\end{bmatrix}\f]
-
-Then, it downsamples the image by rejecting even rows and columns.
-
-@param src input image.
-@param dst output image; it has the specified size and the same type as src.
-@param dstsize size of the output image.
-@param borderType Pixel extrapolation method, see #BorderTypes (#BORDER_CONSTANT
-isn't supported)
- */
-CV_EXPORTS_W void pyrDown(InputArray src, OutputArray dst,
-                          const Size &dstsize = Size(),
-                          int borderType = BORDER_DEFAULT);
-
-/** @brief Upsamples an image and then blurs it.
-
-By default, size of the output image is computed as `Size(src.cols\*2,
-(src.rows\*2)`, but in any case, the following conditions should be satisfied:
-
-\f[\begin{array}{l} | \texttt{dstsize.width} -src.cols*2| \leq  (
-\texttt{dstsize.width}   \mod  2)  \\ | \texttt{dstsize.height} -src.rows*2|
-\leq  ( \texttt{dstsize.height}   \mod  2) \end{array}\f]
-
-The function performs the upsampling step of the Gaussian pyramid construction,
-though it can actually be used to construct the Laplacian pyramid. First, it
-upsamples the source image by injecting even zero rows and columns and then
-convolves the result with the same kernel as in pyrDown multiplied by 4.
-
-@param src input image.
-@param dst output image. It has the specified size and the same type as src .
-@param dstsize size of the output image.
-@param borderType Pixel extrapolation method, see #BorderTypes (only
-#BORDER_DEFAULT is supported)
- */
-CV_EXPORTS_W void pyrUp(InputArray src, OutputArray dst,
-                        const Size &dstsize = Size(),
-                        int borderType = BORDER_DEFAULT);
-
-/** @brief Constructs the Gaussian pyramid for an image.
-
-The function constructs a vector of images and builds the Gaussian pyramid by
-recursively applying pyrDown to the previously built pyramid layers, starting
-from `dst[0]==src`.
-
-@param src Source image. Check pyrDown for the list of supported types.
-@param dst Destination vector of maxlevel+1 images of the same type as src.
-dst[0] will be the same as src. dst[1] is the next pyramid layer, a smoothed and
-down-sized src, and so on.
-@param maxlevel 0-based index of the last (the smallest) pyramid layer. It must
-be non-negative.
-@param borderType Pixel extrapolation method, see #BorderTypes (#BORDER_CONSTANT
-isn't supported)
- */
-CV_EXPORTS void buildPyramid(InputArray src, OutputArrayOfArrays dst,
-                             int maxlevel, int borderType = BORDER_DEFAULT);
-
-//! @} imgproc_filter
-
-//! @addtogroup imgproc_hist
-//! @{
-
-/** @example samples/cpp/demhist.cpp
-An example for creating histograms of an image
-*/
-
-/** @brief Calculates a histogram of a set of arrays.
-
-The function cv::calcHist calculates the histogram of one or more arrays. The
-elements of a tuple used to increment a histogram bin are taken from the
-corresponding input arrays at the same location. The sample below shows how to
-compute a 2D Hue-Saturation histogram for a color image. :
-@include snippets/imgproc_calcHist.cpp
-
-@param images Source arrays. They all should have the same depth, CV_8U, CV_16U
-or CV_32F , and the same size. Each of them can have an arbitrary number of
-channels.
-@param nimages Number of source images.
-@param channels List of the dims channels used to compute the histogram. The
-first array channels are numerated from 0 to images[0].channels()-1 , the second
-array channels are counted from images[0].channels() to images[0].channels() +
-images[1].channels()-1, and so on.
-@param mask Optional mask. If the matrix is not empty, it must be an 8-bit array
-of the same size as images[i] . The non-zero mask elements mark the array
-elements counted in the histogram.
-@param hist Output histogram, which is a dense or sparse dims -dimensional
-array.
-@param dims Histogram dimensionality that must be positive and not greater than
-CV_MAX_DIMS (equal to 32 in the current OpenCV version).
-@param histSize Array of histogram sizes in each dimension.
-@param ranges Array of the dims arrays of the histogram bin boundaries in each
-dimension. When the histogram is uniform ( uniform =true), then for each
-dimension i it is enough to specify the lower (inclusive) boundary \f$L_0\f$ of
-the 0-th histogram bin and the upper (exclusive) boundary
-\f$U_{\texttt{histSize}[i]-1}\f$ for the last histogram bin histSize[i]-1 . That
-is, in case of a uniform histogram each of ranges[i] is an array of 2 elements.
-When the histogram is not uniform ( uniform=false ), then each of ranges[i]
-contains histSize[i]+1 elements:
-\f$L_0, U_0=L_1, U_1=L_2, ...,
-U_{\texttt{histSize[i]}-2}=L_{\texttt{histSize[i]}-1},
-U_{\texttt{histSize[i]}-1}\f$ . The array elements, that are not between
-\f$L_0\f$ and \f$U_{\texttt{histSize[i]}-1}\f$ , are not counted in the
-histogram.
-@param uniform Flag indicating whether the histogram is uniform or not (see
-above).
-@param accumulate Accumulation flag. If it is set, the histogram is not cleared
-in the beginning when it is allocated. This feature enables you to compute a
-single histogram from several sets of arrays, or to update the histogram in
-time.
-*/
-CV_EXPORTS void calcHist(const Mat *images, int nimages, const int *channels,
-                         InputArray mask, OutputArray hist, int dims,
-                         const int *histSize, const float **ranges,
-                         bool uniform = true, bool accumulate = false);
-
-/** @overload
-
-this variant uses %SparseMat for output
-*/
-CV_EXPORTS void calcHist(const Mat *images, int nimages, const int *channels,
-                         InputArray mask, SparseMat &hist, int dims,
-                         const int *histSize, const float **ranges,
-                         bool uniform = true, bool accumulate = false);
-
-/** @overload
-
-this variant supports only uniform histograms.
-
-ranges argument is either empty vector or a flattened vector of
-histSize.size()*2 elements (histSize.size() element pairs). The first and second
-elements of each pair specify the lower and upper boundaries.
-*/
-CV_EXPORTS_W void calcHist(InputArrayOfArrays images,
-                           const std::vector<int> &channels, InputArray mask,
-                           OutputArray hist, const std::vector<int> &histSize,
-                           const std::vector<float> &ranges,
-                           bool accumulate = false);
-
-/** @brief Calculates the back projection of a histogram.
-
-The function cv::calcBackProject calculates the back project of the histogram.
-That is, similarly to #calcHist , at each location (x, y) the function collects
-the values from the selected channels in the input images and finds the
-corresponding histogram bin. But instead of incrementing it, the function reads
-the bin value, scales it by scale , and stores in backProject(x,y) . In terms of
-statistics, the function computes probability of each element value in respect
-with the empirical probability distribution represented by the histogram. See
-how, for example, you can find and track a bright-colored object in a scene:
-
-- Before tracking, show the object to the camera so that it covers almost the
-whole frame. Calculate a hue histogram. The histogram may have strong maximums,
-corresponding to the dominant colors in the object.
-
-- When tracking, calculate a back projection of a hue plane of each input video
-frame using that pre-computed histogram. Threshold the back projection to
-suppress weak colors. It may also make sense to suppress pixels with
-non-sufficient color saturation and too dark or too bright pixels.
-
-- Find connected components in the resulting picture and choose, for example,
-the largest component.
-
-This is an approximate algorithm of the CamShift color object tracker.
-
-@param images Source arrays. They all should have the same depth, CV_8U, CV_16U
-or CV_32F , and the same size. Each of them can have an arbitrary number of
-channels.
-@param nimages Number of source images.
-@param channels The list of channels used to compute the back projection. The
-number of channels must match the histogram dimensionality. The first array
-channels are numerated from 0 to images[0].channels()-1 , the second array
-channels are counted from images[0].channels() to images[0].channels() +
-images[1].channels()-1, and so on.
-@param hist Input histogram that can be dense or sparse.
-@param backProject Destination back projection array that is a single-channel
-array of the same size and depth as images[0] .
-@param ranges Array of arrays of the histogram bin boundaries in each dimension.
-See #calcHist .
-@param scale Optional scale factor for the output back projection.
-@param uniform Flag indicating whether the histogram is uniform or not (see
-#calcHist).
-
-@sa calcHist, compareHist
- */
-CV_EXPORTS void calcBackProject(const Mat *images, int nimages,
-                                const int *channels, InputArray hist,
-                                OutputArray backProject, const float **ranges,
-                                double scale = 1, bool uniform = true);
-
-/** @overload */
-CV_EXPORTS void calcBackProject(const Mat *images, int nimages,
-                                const int *channels, const SparseMat &hist,
-                                OutputArray backProject, const float **ranges,
-                                double scale = 1, bool uniform = true);
-
-/** @overload */
-CV_EXPORTS_W void calcBackProject(InputArrayOfArrays images,
-                                  const std::vector<int> &channels,
-                                  InputArray hist, OutputArray dst,
-                                  const std::vector<float> &ranges,
-                                  double scale);
-
-/** @brief Compares two histograms.
-
-The function cv::compareHist compares two dense or two sparse histograms using
-the specified method.
-
-The function returns \f$d(H_1, H_2)\f$ .
-
-While the function works well with 1-, 2-, 3-dimensional dense histograms, it
-may not be suitable for high-dimensional sparse histograms. In such histograms,
-because of aliasing and sampling problems, the coordinates of non-zero histogram
-bins can slightly shift. To compare such histograms or more general sparse
-configurations of weighted points, consider using the #EMD function.
-
-@param H1 First compared histogram.
-@param H2 Second compared histogram of the same size as H1 .
-@param method Comparison method, see #HistCompMethods
- */
-CV_EXPORTS_W double compareHist(InputArray H1, InputArray H2, int method);
-
-/** @overload */
-CV_EXPORTS double compareHist(const SparseMat &H1, const SparseMat &H2,
-                              int method);
-
-/** @brief Equalizes the histogram of a grayscale image.
-
-The function equalizes the histogram of the input image using the following
-algorithm:
-
-- Calculate the histogram \f$H\f$ for src .
-- Normalize the histogram so that the sum of histogram bins is 255.
-- Compute the integral of the histogram:
-\f[H'_i =  \sum _{0  \le j < i} H(j)\f]
-- Transform the image using \f$H'\f$ as a look-up table: \f$\texttt{dst}(x,y) =
-H'(\texttt{src}(x,y))\f$
-
-The algorithm normalizes the brightness and increases the contrast of the image.
-
-@param src Source 8-bit single channel image.
-@param dst Destination image of the same size and type as src .
- */
-CV_EXPORTS_W void equalizeHist(InputArray src, OutputArray dst);
-
-/** @brief Creates a smart pointer to a cv::CLAHE class and initializes it.
-
-@param clipLimit Threshold for contrast limiting.
-@param tileGridSize Size of grid for histogram equalization. Input image will be
-divided into equally sized rectangular tiles. tileGridSize defines the number of
-tiles in row and column.
- */
-CV_EXPORTS_W Ptr<CLAHE> createCLAHE(double clipLimit = 40.0,
-                                    Size tileGridSize = Size(8, 8));
-
-/** @brief Computes the "minimal work" distance between two weighted point
-configurations.
-
-The function computes the earth mover distance and/or a lower boundary of the
-distance between the two weighted point configurations. One of the applications
-described in @cite RubnerSept98,
-@cite Rubner2000 is multi-dimensional histogram comparison for image retrieval.
-EMD is a transportation problem that is solved using some modification of a
-simplex algorithm, thus the complexity is exponential in the worst case, though,
-on average it is much faster. In the case of a real metric the lower boundary
-can be calculated even faster (using linear-time algorithm) and it can be used
-to determine roughly whether the two signatures are far enough so that they
-cannot relate to the same object.
-
-@param signature1 First signature, a \f$\texttt{size1}\times \texttt{dims}+1\f$
-floating-point matrix. Each row stores the point weight followed by the point
-coordinates. The matrix is allowed to have a single column (weights only) if the
-user-defined cost matrix is used. The weights must be non-negative and have at
-least one non-zero value.
-@param signature2 Second signature of the same format as signature1 , though the
-number of rows may be different. The total weights may be different. In this
-case an extra "dummy" point is added to either signature1 or signature2. The
-weights must be non-negative and have at least one non-zero value.
-@param distType Used metric. See #DistanceTypes.
-@param cost User-defined \f$\texttt{size1}\times \texttt{size2}\f$ cost matrix.
-Also, if a cost matrix is used, lower boundary lowerBound cannot be calculated
-because it needs a metric function.
-@param lowerBound Optional input/output parameter: lower boundary of a distance
-between the two signatures that is a distance between mass centers. The lower
-boundary may not be calculated if the user-defined cost matrix is used, the
-total weights of point configurations are not equal, or if the signatures
-consist of weights only (the signature matrices have a single column). You
-**must** initialize \*lowerBound . If the calculated distance between mass
-centers is greater or equal to \*lowerBound (it means that the signatures are
-far enough), the function does not calculate EMD. In any case \*lowerBound is
-set to the calculated distance between mass centers on return. Thus, if you want
-to calculate both distance between mass centers and EMD, \*lowerBound should be
-set to 0.
-@param flow Resultant \f$\texttt{size1} \times \texttt{size2}\f$ flow matrix:
-\f$\texttt{flow}_{i,j}\f$ is a flow from \f$i\f$ -th point of signature1 to
-\f$j\f$ -th point of signature2 .
- */
-CV_EXPORTS float EMD(InputArray signature1, InputArray signature2, int distType,
-                     InputArray cost = noArray(), float *lowerBound = 0,
-                     OutputArray flow = noArray());
-
-CV_EXPORTS_AS(EMD)
-float wrapperEMD(InputArray signature1, InputArray signature2, int distType,
-                 InputArray cost = noArray(),
-                 CV_IN_OUT Ptr<float> lowerBound = Ptr<float>(),
-                 OutputArray flow = noArray());
-
-//! @} imgproc_hist
-
-//! @addtogroup imgproc_segmentation
-//! @{
-
-/** @example samples/cpp/watershed.cpp
-An example using the watershed algorithm
-*/
-
-/** @brief Performs a marker-based image segmentation using the watershed
-algorithm.
-
-The function implements one of the variants of watershed, non-parametric
-marker-based segmentation algorithm, described in @cite Meyer92 .
-
-Before passing the image to the function, you have to roughly outline the
-desired regions in the image markers with positive (\>0) indices. So, every
-region is represented as one or more connected components with the pixel values
-1, 2, 3, and so on. Such markers can be retrieved from a binary mask using
-#findContours and #drawContours (see the watershed.cpp demo). The markers are
-"seeds" of the future image regions. All the other pixels in markers , whose
-relation to the outlined regions is not known and should be defined by the
-algorithm, should be set to 0's. In the function output, each pixel in markers
-is set to a value of the "seed" components or to -1 at boundaries between the
-regions.
-
-@note Any two neighbor connected components are not necessarily separated by a
-watershed boundary
-(-1's pixels); for example, they can touch each other in the initial marker
-image passed to the function.
-
-@param image Input 8-bit 3-channel image.
-@param markers Input/output 32-bit single-channel image (map) of markers. It
-should have the same size as image .
-
-@sa findContours
- */
-CV_EXPORTS_W void watershed(InputArray image, InputOutputArray markers);
-
-//! @} imgproc_segmentation
-
-//! @addtogroup imgproc_filter
-//! @{
-
-/** @brief Performs initial step of meanshift segmentation of an image.
-
-The function implements the filtering stage of meanshift segmentation, that is,
-the output of the function is the filtered "posterized" image with color
-gradients and fine-grain texture flattened. At every pixel (X,Y) of the input
-image (or down-sized input image, see below) the function executes meanshift
-iterations, that is, the pixel (X,Y) neighborhood in the joint space-color
-hyperspace is considered:
-
-\f[(x,y): X- \texttt{sp} \le x  \le X+ \texttt{sp} , Y- \texttt{sp} \le y  \le
-Y+ \texttt{sp} , ||(R,G,B)-(r,g,b)||   \le \texttt{sr}\f]
-
-where (R,G,B) and (r,g,b) are the vectors of color components at (X,Y) and
-(x,y), respectively (though, the algorithm does not depend on the color space
-used, so any 3-component color space can be used instead). Over the neighborhood
-the average spatial value (X',Y') and average color vector (R',G',B') are found
-and they act as the neighborhood center on the next iteration:
-
-\f[(X,Y)~(X',Y'), (R,G,B)~(R',G',B').\f]
-
-After the iterations over, the color components of the initial pixel (that is,
-the pixel from where the iterations started) are set to the final value (average
-color at the last iteration):
-
-\f[I(X,Y) <- (R*,G*,B*)\f]
-
-When maxLevel \> 0, the gaussian pyramid of maxLevel+1 levels is built, and the
-above procedure is run on the smallest layer first. After that, the results are
-propagated to the larger layer and the iterations are run again only on those
-pixels where the layer colors differ by more than sr from the lower-resolution
-layer of the pyramid. That makes boundaries of color regions sharper. Note that
-the results will be actually different from the ones obtained by running the
-meanshift procedure on the whole original image (i.e. when maxLevel==0).
-
-@param src The source 8-bit, 3-channel image.
-@param dst The destination image of the same format and the same size as the
-source.
-@param sp The spatial window radius.
-@param sr The color window radius.
-@param maxLevel Maximum level of the pyramid for the segmentation.
-@param termcrit Termination criteria: when to stop meanshift iterations.
- */
-CV_EXPORTS_W void
-pyrMeanShiftFiltering(InputArray src, OutputArray dst, double sp, double sr,
-                      int maxLevel = 1,
-                      TermCriteria termcrit = TermCriteria(
-                          TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1));
-
-//! @}
-
-//! @addtogroup imgproc_segmentation
-//! @{
-
-/** @example samples/cpp/grabcut.cpp
-An example using the GrabCut algorithm
-![Sample Screenshot](grabcut_output1.jpg)
-*/
-
-/** @brief Runs the GrabCut algorithm.
-
-The function implements the [GrabCut image segmentation
-algorithm](http://en.wikipedia.org/wiki/GrabCut).
-
-@param img Input 8-bit 3-channel image.
-@param mask Input/output 8-bit single-channel mask. The mask is initialized by
-the function when mode is set to #GC_INIT_WITH_RECT. Its elements may have one
-of the #GrabCutClasses.
-@param rect ROI containing a segmented object. The pixels outside of the ROI are
-marked as "obvious background". The parameter is only used when
-mode==#GC_INIT_WITH_RECT .
-@param bgdModel Temporary array for the background model. Do not modify it while
-you are processing the same image.
-@param fgdModel Temporary arrays for the foreground model. Do not modify it
-while you are processing the same image.
-@param iterCount Number of iterations the algorithm should make before returning
-the result. Note that the result can be refined with further calls with
-mode==#GC_INIT_WITH_MASK or mode==GC_EVAL .
-@param mode Operation mode that could be one of the #GrabCutModes
- */
-CV_EXPORTS_W void grabCut(InputArray img, InputOutputArray mask, Rect rect,
-                          InputOutputArray bgdModel, InputOutputArray fgdModel,
-                          int iterCount, int mode = GC_EVAL);
-
-//! @} imgproc_segmentation
-
-//! @addtogroup imgproc_misc
-//! @{
-
-/** @example samples/cpp/distrans.cpp
-An example on using the distance transform
-*/
-
-/** @brief Calculates the distance to the closest zero pixel for each pixel of
-the source image.
-
-The function cv::distanceTransform calculates the approximate or precise
-distance from every binary image pixel to the nearest zero pixel. For zero image
-pixels, the distance will obviously be zero.
-
-When maskSize == #DIST_MASK_PRECISE and distanceType == #DIST_L2 , the function
-runs the algorithm described in @cite Felzenszwalb04 . This algorithm is
-parallelized with the TBB library.
-
-In other cases, the algorithm @cite Borgefors86 is used. This means that for a
-pixel the function finds the shortest path to the nearest zero pixel consisting
-of basic shifts: horizontal, vertical, diagonal, or knight's move (the latest is
-available for a \f$5\times 5\f$ mask). The overall distance is calculated as a
-sum of these basic distances. Since the distance function should be symmetric,
-all of the horizontal and vertical shifts must have the same cost (denoted as a
-), all the diagonal shifts must have the same cost (denoted as `b`), and all
-knight's moves must have the same cost (denoted as `c`). For the #DIST_C and
-#DIST_L1 types, the distance is calculated precisely, whereas for #DIST_L2
-(Euclidean distance) the distance can be calculated only with a relative error
-(a \f$5\times 5\f$ mask gives more accurate results). For `a`,`b`, and `c`,
-OpenCV uses the values suggested in the original paper:
-- DIST_L1: `a = 1, b = 2`
-- DIST_L2:
-    - `3 x 3`: `a=0.955, b=1.3693`
-    - `5 x 5`: `a=1, b=1.4, c=2.1969`
-- DIST_C: `a = 1, b = 1`
-
-Typically, for a fast, coarse distance estimation #DIST_L2, a \f$3\times 3\f$
-mask is used. For a more accurate distance estimation #DIST_L2, a \f$5\times
-5\f$ mask or the precise algorithm is used. Note that both the precise and the
-approximate algorithms are linear on the number of pixels.
-
-This variant of the function does not only compute the minimum distance for each
-pixel \f$(x, y)\f$ but also identifies the nearest connected component
-consisting of zero pixels (labelType==#DIST_LABEL_CCOMP) or the nearest zero
-pixel (labelType==#DIST_LABEL_PIXEL). Index of the component/pixel is stored in
-`labels(x, y)`. When labelType==#DIST_LABEL_CCOMP, the function automatically
-finds connected components of zero pixels in the input image and marks them with
-distinct labels. When labelType==#DIST_LABEL_PIXEL, the function scans through
-the input image and marks all the zero pixels with distinct labels.
-
-In this mode, the complexity is still linear. That is, the function provides a
-very fast way to compute the Voronoi diagram for a binary image. Currently, the
-second variant can use only the approximate distance transform algorithm, i.e.
-maskSize=#DIST_MASK_PRECISE is not supported yet.
-
-@param src 8-bit, single-channel (binary) source image.
-@param dst Output image with calculated distances. It is a 8-bit or 32-bit
-floating-point, single-channel image of the same size as src.
-@param labels Output 2D array of labels (the discrete Voronoi diagram). It has
-the type CV_32SC1 and the same size as src.
-@param distanceType Type of distance, see #DistanceTypes
-@param maskSize Size of the distance transform mask, see
-#DistanceTransformMasks. #DIST_MASK_PRECISE is not supported by this variant. In
-case of the #DIST_L1 or #DIST_C distance type, the parameter is forced to 3
-because a \f$3\times 3\f$ mask gives the same result as \f$5\times 5\f$ or any
-larger aperture.
-@param labelType Type of the label array to build, see
-#DistanceTransformLabelTypes.
- */
-CV_EXPORTS_AS(distanceTransformWithLabels)
-void distanceTransform(InputArray src, OutputArray dst, OutputArray labels,
-                       int distanceType, int maskSize,
-                       int labelType = DIST_LABEL_CCOMP);
-
-/** @overload
-@param src 8-bit, single-channel (binary) source image.
-@param dst Output image with calculated distances. It is a 8-bit or 32-bit
-floating-point, single-channel image of the same size as src .
-@param distanceType Type of distance, see #DistanceTypes
-@param maskSize Size of the distance transform mask, see
-#DistanceTransformMasks. In case of the #DIST_L1 or #DIST_C distance type, the
-parameter is forced to 3 because a \f$3\times 3\f$ mask gives the same result as
-\f$5\times 5\f$ or any larger aperture.
-@param dstType Type of output image. It can be CV_8U or CV_32F. Type CV_8U can
-be used only for the first variant of the function and distanceType == #DIST_L1.
-*/
-CV_EXPORTS_W void distanceTransform(InputArray src, OutputArray dst,
-                                    int distanceType, int maskSize,
-                                    int dstType = CV_32F);
-
-/** @brief Fills a connected component with the given color.
-
-The function cv::floodFill fills a connected component starting from the seed
-point with the specified color. The connectivity is determined by the
-color/brightness closeness of the neighbor pixels. The pixel at \f$(x,y)\f$ is
-considered to belong to the repainted domain if:
-
-- in case of a grayscale image and floating range
-\f[\texttt{src} (x',y')- \texttt{loDiff} \leq \texttt{src} (x,y)  \leq
-\texttt{src} (x',y')+ \texttt{upDiff}\f]
-
-
-- in case of a grayscale image and fixed range
-\f[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)- \texttt{loDiff}
-\leq \texttt{src} (x,y)  \leq \texttt{src} ( \texttt{seedPoint} .x,
-\texttt{seedPoint} .y)+ \texttt{upDiff}\f]
-
-
-- in case of a color image and floating range
-\f[\texttt{src} (x',y')_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq
-\texttt{src} (x',y')_r+ \texttt{upDiff} _r,\f]
-\f[\texttt{src} (x',y')_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq
-\texttt{src} (x',y')_g+ \texttt{upDiff} _g\f] and
-\f[\texttt{src} (x',y')_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq
-\texttt{src} (x',y')_b+ \texttt{upDiff} _b\f]
-
-
-- in case of a color image and fixed range
-\f[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r-
-\texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} (
-\texttt{seedPoint} .x, \texttt{seedPoint} .y)_r+ \texttt{upDiff} _r,\f]
-\f[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g-
-\texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} (
-\texttt{seedPoint} .x, \texttt{seedPoint} .y)_g+ \texttt{upDiff} _g\f] and
-\f[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b-
-\texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} (
-\texttt{seedPoint} .x, \texttt{seedPoint} .y)_b+ \texttt{upDiff} _b\f]
-
-
-where \f$src(x',y')\f$ is the value of one of pixel neighbors that is already
-known to belong to the component. That is, to be added to the connected
-component, a color/brightness of the pixel should be close enough to:
-- Color/brightness of one of its neighbors that already belong to the connected
-component in case of a floating range.
-- Color/brightness of the seed point in case of a fixed range.
-
-Use these functions to either mark a connected component with the specified
-color in-place, or build a mask and then extract the contour, or copy the region
-to another image, and so on.
-
-@param image Input/output 1- or 3-channel, 8-bit, or floating-point image. It is
-modified by the function unless the #FLOODFILL_MASK_ONLY flag is set in the
-second variant of the function. See the details below.
-@param mask Operation mask that should be a single-channel 8-bit image, 2 pixels
-wider and 2 pixels taller than image. If an empty Mat is passed it will be
-created automatically. Since this is both an input and output parameter, you
-must take responsibility of initializing it. Flood-filling cannot go across
-non-zero pixels in the input mask. For example, an edge detector output can be
-used as a mask to stop filling at edges. On output, pixels in the mask
-corresponding to filled pixels in the image are set to 1 or to the specified
-value in flags as described below. Additionally, the function fills the border
-of the mask with ones to simplify internal processing. It is therefore possible
-to use the same mask in multiple calls to the function to make sure the filled
-areas do not overlap.
-@param seedPoint Starting point.
-@param newVal New value of the repainted domain pixels.
-@param loDiff Maximal lower brightness/color difference between the currently
-observed pixel and one of its neighbors belonging to the component, or a seed
-pixel being added to the component.
-@param upDiff Maximal upper brightness/color difference between the currently
-observed pixel and one of its neighbors belonging to the component, or a seed
-pixel being added to the component.
-@param rect Optional output parameter set by the function to the minimum
-bounding rectangle of the repainted domain.
-@param flags Operation flags. The first 8 bits contain a connectivity value. The
-default value of 4 means that only the four nearest neighbor pixels (those that
-share an edge) are considered. A connectivity value of 8 means that the eight
-nearest neighbor pixels (those that share a corner) will be considered. The next
-8 bits (8-16) contain a value between 1 and 255 with which to fill the mask (the
-default value is 1). For example, 4 | ( 255 \<\< 8 ) will consider 4 nearest
-neighbours and fill the mask with a value of 255. The following additional
-options occupy higher bits and therefore may be further combined with the
-connectivity and mask fill values using bit-wise or (|), see #FloodFillFlags.
-
-@note Since the mask is larger than the filled image, a pixel \f$(x, y)\f$ in
-image corresponds to the pixel \f$(x+1, y+1)\f$ in the mask .
-
-@sa findContours
- */
-CV_EXPORTS_W int floodFill(InputOutputArray image, InputOutputArray mask,
-                           Point seedPoint, Scalar newVal,
-                           CV_OUT Rect *rect = 0, Scalar loDiff = Scalar(),
-                           Scalar upDiff = Scalar(), int flags = 4);
-
-/** @example samples/cpp/ffilldemo.cpp
-An example using the FloodFill technique
-*/
-
-/** @overload
-
-variant without `mask` parameter
-*/
-CV_EXPORTS int floodFill(InputOutputArray image, Point seedPoint, Scalar newVal,
-                         CV_OUT Rect *rect = 0, Scalar loDiff = Scalar(),
-                         Scalar upDiff = Scalar(), int flags = 4);
-
-//! Performs linear blending of two images:
-//! \f[ \texttt{dst}(i,j) = \texttt{weights1}(i,j)*\texttt{src1}(i,j) +
-//! \texttt{weights2}(i,j)*\texttt{src2}(i,j) \f]
-//! @param src1 It has a type of CV_8UC(n) or CV_32FC(n), where n is a positive
-//! integer.
-//! @param src2 It has the same type and size as src1.
-//! @param weights1 It has a type of CV_32FC1 and the same size with src1.
-//! @param weights2 It has a type of CV_32FC1 and the same size with src1.
-//! @param dst It is created if it does not have the same size and type with
-//! src1.
-CV_EXPORTS_W void blendLinear(InputArray src1, InputArray src2,
-                              InputArray weights1, InputArray weights2,
-                              OutputArray dst);
-
-//! @} imgproc_misc
-
-//! @addtogroup imgproc_color_conversions
-//! @{
-
-/** @brief Converts an image from one color space to another.
-
-The function converts an input image from one color space to another. In case of
-a transformation to-from RGB color space, the order of the channels should be
-specified explicitly (RGB or BGR). Note that the default color format in OpenCV
-is often referred to as RGB but it is actually BGR (the bytes are reversed). So
-the first byte in a standard (24-bit) color image will be an 8-bit Blue
-component, the second byte will be Green, and the third byte will be Red. The
-fourth, fifth, and sixth bytes would then be the second pixel (Blue, then Green,
-then Red), and so on.
-
-The conventional ranges for R, G, and B channel values are:
--   0 to 255 for CV_8U images
--   0 to 65535 for CV_16U images
--   0 to 1 for CV_32F images
-
-In case of linear transformations, the range does not matter. But in case of a
-non-linear transformation, an input RGB image should be normalized to the proper
-value range to get the correct results, for example, for RGB \f$\rightarrow\f$
-L\*u\*v\* transformation. For example, if you have a 32-bit floating-point image
-directly converted from an 8-bit image without any scaling, then it will have
-the 0..255 value range instead of 0..1 assumed by the function. So, before
-calling #cvtColor , you need first to scale the image down:
-@code
-    img *= 1./255;
-    cvtColor(img, img, COLOR_BGR2Luv);
-@endcode
-If you use #cvtColor with 8-bit images, the conversion will have some
-information lost. For many applications, this will not be noticeable but it is
-recommended to use 32-bit images in applications that need the full range of
-colors or that convert an image before an operation and then convert back.
-
-If conversion adds the alpha channel, its value will set to the maximum of
-corresponding channel range: 255 for CV_8U, 65535 for CV_16U, 1 for CV_32F.
-
-@param src input image: 8-bit unsigned, 16-bit unsigned ( CV_16UC... ), or
-single-precision floating-point.
-@param dst output image of the same size and depth as src.
-@param code color space conversion code (see #ColorConversionCodes).
-@param dstCn number of channels in the destination image; if the parameter is 0,
-the number of the channels is derived automatically from src and code.
-@param hint Implementation modfication flags. See #AlgorithmHint
-
-@see @ref imgproc_color_conversions
- */
-CV_EXPORTS_W void cvtColor(InputArray src, OutputArray dst, int code,
-                           int dstCn = 0,
-                           AlgorithmHint hint = cv::ALGO_HINT_DEFAULT);
-
-/** @brief Converts an image from one color space to another where the source
-image is stored in two planes.
-
-This function only supports YUV420 to RGB conversion as of now.
-
-@param src1 8-bit image (#CV_8U) of the Y plane.
-@param src2 image containing interleaved U/V plane.
-@param dst output image.
-@param code Specifies the type of conversion. It can take any of the following
-values:
-- #COLOR_YUV2BGR_NV12
-- #COLOR_YUV2RGB_NV12
-- #COLOR_YUV2BGRA_NV12
-- #COLOR_YUV2RGBA_NV12
-- #COLOR_YUV2BGR_NV21
-- #COLOR_YUV2RGB_NV21
-- #COLOR_YUV2BGRA_NV21
-- #COLOR_YUV2RGBA_NV21
-@param hint Implementation modfication flags. See #AlgorithmHint
-*/
-CV_EXPORTS_W void cvtColorTwoPlane(InputArray src1, InputArray src2,
-                                   OutputArray dst, int code,
-                                   AlgorithmHint hint = cv::ALGO_HINT_DEFAULT);
-
-/** @brief main function for all demosaicing processes
-
-@param src input image: 8-bit unsigned or 16-bit unsigned.
-@param dst output image of the same size and depth as src.
-@param code Color space conversion code (see the description below).
-@param dstCn number of channels in the destination image; if the parameter is 0,
-the number of the channels is derived automatically from src and code.
-
-The function can do the following transformations:
-
--   Demosaicing using bilinear interpolation
-
-    #COLOR_BayerBG2BGR , #COLOR_BayerGB2BGR , #COLOR_BayerRG2BGR ,
-#COLOR_BayerGR2BGR
-
-    #COLOR_BayerBG2GRAY , #COLOR_BayerGB2GRAY , #COLOR_BayerRG2GRAY ,
-#COLOR_BayerGR2GRAY
-
--   Demosaicing using Variable Number of Gradients.
-
-    #COLOR_BayerBG2BGR_VNG , #COLOR_BayerGB2BGR_VNG , #COLOR_BayerRG2BGR_VNG ,
-#COLOR_BayerGR2BGR_VNG
-
--   Edge-Aware Demosaicing.
-
-    #COLOR_BayerBG2BGR_EA , #COLOR_BayerGB2BGR_EA , #COLOR_BayerRG2BGR_EA ,
-#COLOR_BayerGR2BGR_EA
-
--   Demosaicing with alpha channel
-
-    #COLOR_BayerBG2BGRA , #COLOR_BayerGB2BGRA , #COLOR_BayerRG2BGRA ,
-#COLOR_BayerGR2BGRA
-
-@sa cvtColor
-*/
-CV_EXPORTS_W void demosaicing(InputArray src, OutputArray dst, int code,
-                              int dstCn = 0);
-
-//! @} imgproc_color_conversions
-
-//! @addtogroup imgproc_shape
-//! @{
-
-/** @brief Calculates all of the moments up to the third order of a polygon or
-rasterized shape.
-
-The function computes moments, up to the 3rd order, of a vector shape or a
-rasterized shape. The results are returned in the structure cv::Moments.
-
-@param array Single chanel raster image (CV_8U, CV_16U, CV_16S, CV_32F, CV_64F)
-or an array (
-\f$1 \times N\f$ or \f$N \times 1\f$ ) of 2D points (Point or Point2f).
-@param binaryImage If it is true, all non-zero image pixels are treated as 1's.
-The parameter is used for images only.
-@returns moments.
-
-@note Only applicable to contour moments calculations from Python bindings: Note
-that the numpy type for the input array should be either np.int32 or np.float32.
-
-@sa  contourArea, arcLength
- */
-CV_EXPORTS_W Moments moments(InputArray array, bool binaryImage = false);
-
-/** @brief Calculates seven Hu invariants.
-
-The function calculates seven Hu invariants (introduced in @cite Hu62; see also
-<http://en.wikipedia.org/wiki/Image_moment>) defined as:
-
-\f[\begin{array}{l} hu[0]= \eta _{20}+ \eta _{02} \\ hu[1]=( \eta _{20}- \eta
-_{02})^{2}+4 \eta _{11}^{2} \\ hu[2]=( \eta _{30}-3 \eta _{12})^{2}+ (3 \eta
-_{21}- \eta _{03})^{2} \\ hu[3]=( \eta _{30}+ \eta _{12})^{2}+ ( \eta _{21}+
-\eta _{03})^{2} \\ hu[4]=( \eta _{30}-3 \eta _{12})( \eta _{30}+ \eta _{12})[(
-\eta _{30}+ \eta _{12})^{2}-3( \eta _{21}+ \eta _{03})^{2}]+(3 \eta _{21}- \eta
-_{03})( \eta _{21}+ \eta _{03})[3( \eta _{30}+ \eta _{12})^{2}-( \eta _{21}+
-\eta _{03})^{2}] \\ hu[5]=( \eta _{20}- \eta _{02})[( \eta _{30}+ \eta
-_{12})^{2}- ( \eta _{21}+ \eta _{03})^{2}]+4 \eta _{11}( \eta _{30}+ \eta
-_{12})( \eta _{21}+ \eta _{03}) \\ hu[6]=(3 \eta _{21}- \eta _{03})( \eta _{21}+
-\eta _{03})[3( \eta _{30}+ \eta _{12})^{2}-( \eta _{21}+ \eta _{03})^{2}]-( \eta
-_{30}-3 \eta _{12})( \eta _{21}+ \eta _{03})[3( \eta _{30}+ \eta _{12})^{2}-(
-\eta _{21}+ \eta _{03})^{2}] \\ \end{array}\f]
-
-where \f$\eta_{ji}\f$ stands for \f$\texttt{Moments::nu}_{ji}\f$ .
-
-These values are proved to be invariants to the image scale, rotation, and
-reflection except the seventh one, whose sign is changed by reflection. This
-invariance is proved with the assumption of infinite image resolution. In case
-of raster images, the computed Hu invariants for the original and transformed
-images are a bit different.
-
-@param moments Input moments computed with moments .
-@param hu Output Hu invariants.
-
-@sa matchShapes
- */
-CV_EXPORTS void HuMoments(const Moments &moments, double hu[7]);
-
-/** @overload */
-CV_EXPORTS_W void HuMoments(const Moments &m, OutputArray hu);
-
-//! @} imgproc_shape
-
-//! @addtogroup imgproc_object
-//! @{
-
-//! type of the template matching operation
-enum TemplateMatchModes {
-  TM_SQDIFF = 0, /*!< \f[R(x,y)= \sum _{x',y'} (T(x',y')-I(x+x',y+y'))^2\f]
-                      with mask:
-                      \f[R(x,y)= \sum _{x',y'} \left( (T(x',y')-I(x+x',y+y'))
-                    \cdot M(x',y') \right)^2\f] */
-  TM_SQDIFF_NORMED =
-      1,        /*!< \f[R(x,y)= \frac{\sum_{x',y'}
-                   (T(x',y')-I(x+x',y+y'))^2}{\sqrt{\sum_{        x',y'}T(x',y')^2
-                   \cdot
-                   \sum_{x',y'} I(x+x',y+y')^2}}\f]        with mask:
-                     \f[R(x,y)= \frac{\sum _{x',y'} \left( (T(x',y')-I(x+x',y+y'))
-                   \cdot        M(x',y') \right)^2}{\sqrt{\sum_{x',y'} \left( T(x',y')
-                   \cdot        M(x',y') \right)^2 \cdot \sum_{x',y'} \left(
-                   I(x+x',y+y')
-                   \cdot        M(x',y') \right)^2}}\f] */
-  TM_CCORR = 2, /*!< \f[R(x,y)= \sum _{x',y'} (T(x',y') \cdot I(x+x',y+y'))\f]
-                     with mask:
-                     \f[R(x,y)= \sum _{x',y'} (T(x',y') \cdot I(x+x',y+y') \cdot
-                   M(x',y') ^2)\f] */
-  TM_CCORR_NORMED =
-      3, /*!< \f[R(x,y)= \frac{\sum_{x',y'} (T(x',y') \cdot
-            I(x+x',y+y'))}{\sqrt{
-                 \sum_{x',y'}T(x',y')^2 \cdot \sum_{x',y'} I(x+x',y+y')^2}}\f]
-              with mask:
-              \f[R(x,y)= \frac{\sum_{x',y'} (T(x',y') \cdot I(x+x',y+y') \cdot
-                 M(x',y')^2)}{\sqrt{\sum_{x',y'} \left( T(x',y') \cdot M(x',y')
-                 \right)^2 \cdot \sum_{x',y'} \left( I(x+x',y+y') \cdot M(x',y')
-                 \right)^2}}\f] */
-  TM_CCOEFF =
-      4, /*!< \f[R(x,y)= \sum _{x',y'} (T'(x',y') \cdot I'(x+x',y+y'))\f]
-              where
-              \f[\begin{array}{l} T'(x',y')=T(x',y') - 1/(w \cdot h) \cdot \sum
-            _{ x'',y''} T(x'',y'') \\ I'(x+x',y+y')=I(x+x',y+y') - 1/(w \cdot h)
-                 \cdot \sum _{x'',y''} I(x+x'',y+y'') \end{array}\f]
-              with mask:
-              \f[\begin{array}{l} T'(x',y')=M(x',y') \cdot \left( T(x',y') -
-                 \frac{1}{\sum _{x'',y''} M(x'',y'')} \cdot \sum _{x'',y''}
-                 (T(x'',y'') \cdot M(x'',y'')) \right) \\ I'(x+x',y+y')=M(x',y')
-                 \cdot \left( I(x+x',y+y') - \frac{1}{\sum _{x'',y''}
-            M(x'',y'')}
-                 \cdot \sum _{x'',y''} (I(x+x'',y+y'') \cdot M(x'',y'')) \right)
-                 \end{array} \f] */
-  TM_CCOEFF_NORMED =
-      5 /*!< \f[R(x,y)= \frac{ \sum_{x',y'} (T'(x',y') \cdot I'(x+x',y+y')) }{
-                \sqrt{\sum_{x',y'}T'(x',y')^2 \cdot \sum_{x',y'}
-           I'(x+x',y+y')^2}
-                }\f] */
-};
-
-/** @example
-samples/cpp/tutorial_code/Histograms_Matching/MatchTemplate_Demo.cpp An example
-using Template Matching algorithm
-*/
-
-/** @brief Compares a template against overlapped image regions.
-
-The function slides through image , compares the overlapped patches of size \f$w
-\times h\f$ against templ using the specified method and stores the comparison
-results in result . #TemplateMatchModes describes the formulae for the available
-comparison methods ( \f$I\f$ denotes image, \f$T\f$ template, \f$R\f$ result,
-\f$M\f$ the optional mask ). The summation is done over template and/or the
-image patch: \f$x' = 0...w-1, y' = 0...h-1\f$
-
-After the function finishes the comparison, the best matches can be found as
-global minimums (when #TM_SQDIFF was used) or maximums (when #TM_CCORR or
-#TM_CCOEFF was used) using the #minMaxLoc function. In case of a color image,
-template summation in the numerator and each sum in the denominator is done over
-all of the channels and separate mean values are used for each channel. That is,
-the function can take a color template and a color image. The result will still
-be a single-channel image, which is easier to analyze.
-
-@param image Image where the search is running. It must be 8-bit or 32-bit
-floating-point.
-@param templ Searched template. It must be not greater than the source image and
-have the same data type.
-@param result Map of comparison results. It must be single-channel 32-bit
-floating-point. If image is \f$W \times H\f$ and templ is \f$w \times h\f$ ,
-then result is \f$(W-w+1) \times (H-h+1)\f$ .
-@param method Parameter specifying the comparison method, see
-#TemplateMatchModes
-@param mask Optional mask. It must have the same size as templ. It must either
-have the same number of channels as template or only one channel, which is then
-used for all template and image channels. If the data type is #CV_8U, the mask
-is interpreted as a binary mask, meaning only elements where mask is nonzero are
-used and are kept unchanged independent of the actual mask value (weight equals
-1). For data tpye #CV_32F, the mask values are used as weights. The exact
-formulas are documented in #TemplateMatchModes.
- */
-CV_EXPORTS_W void matchTemplate(InputArray image, InputArray templ,
-                                OutputArray result, int method,
-                                InputArray mask = noArray());
-
-//! @}
-
-//! @addtogroup imgproc_shape
-//! @{
-
-/** @example samples/cpp/connected_components.cpp
-This program demonstrates connected components and use of the trackbar
-*/
-
-/** @brief computes the connected components labeled image of boolean image
-
-image with 4 or 8 way connectivity - returns N, the total number of labels [0,
-N-1] where 0 represents the background label. ltype specifies the output label
-image type, an important consideration based on the total number of labels or
-alternatively the total number of pixels in the source image. ccltype specifies
-the connected components labeling algorithm to use, currently Bolelli
-(Spaghetti) @cite Bolelli2019, Grana (BBDT) @cite Grana2010 and Wu's (SAUF)
-@cite Wu2009 algorithms are supported, see the
-#ConnectedComponentsAlgorithmsTypes for details. Note that SAUF algorithm forces
-a row major ordering of labels while Spaghetti and BBDT do not.
-This function uses parallel version of the algorithms if at least one allowed
-parallel framework is enabled and if the rows of the image are at least twice
-the number returned by #getNumberOfCPUs.
-
-@param image the 8-bit single-channel image to be labeled
-@param labels destination labeled image
-@param connectivity 8 or 4 for 8-way or 4-way connectivity respectively
-@param ltype output image label type. Currently CV_32S and CV_16U are supported.
-@param ccltype connected components algorithm type (see the
-#ConnectedComponentsAlgorithmsTypes).
-*/
-CV_EXPORTS_AS(connectedComponentsWithAlgorithm)
-int connectedComponents(InputArray image, OutputArray labels, int connectivity,
-                        int ltype, int ccltype);
-
-/** @overload
-
-@param image the 8-bit single-channel image to be labeled
-@param labels destination labeled image
-@param connectivity 8 or 4 for 8-way or 4-way connectivity respectively
-@param ltype output image label type. Currently CV_32S and CV_16U are supported.
-*/
-CV_EXPORTS_W int connectedComponents(InputArray image, OutputArray labels,
-                                     int connectivity = 8, int ltype = CV_32S);
-
-/** @brief computes the connected components labeled image of boolean image and
-also produces a statistics output for each label
-
-image with 4 or 8 way connectivity - returns N, the total number of labels [0,
-N-1] where 0 represents the background label. ltype specifies the output label
-image type, an important consideration based on the total number of labels or
-alternatively the total number of pixels in the source image. ccltype specifies
-the connected components labeling algorithm to use, currently Bolelli
-(Spaghetti) @cite Bolelli2019, Grana (BBDT) @cite Grana2010 and Wu's (SAUF)
-@cite Wu2009 algorithms are supported, see the
-#ConnectedComponentsAlgorithmsTypes for details. Note that SAUF algorithm forces
-a row major ordering of labels while Spaghetti and BBDT do not.
-This function uses parallel version of the algorithms (statistics included) if
-at least one allowed parallel framework is enabled and if the rows of the image
-are at least twice the number returned by #getNumberOfCPUs.
-
-@param image the 8-bit single-channel image to be labeled
-@param labels destination labeled image
-@param stats statistics output for each label, including the background label.
-Statistics are accessed via stats(label, COLUMN) where COLUMN is one of
-#ConnectedComponentsTypes, selecting the statistic. The data type is CV_32S.
-@param centroids centroid output for each label, including the background label.
-Centroids are accessed via centroids(label, 0) for x and centroids(label, 1) for
-y. The data type CV_64F.
-@param connectivity 8 or 4 for 8-way or 4-way connectivity respectively
-@param ltype output image label type. Currently CV_32S and CV_16U are supported.
-@param ccltype connected components algorithm type (see
-#ConnectedComponentsAlgorithmsTypes).
-*/
-CV_EXPORTS_AS(connectedComponentsWithStatsWithAlgorithm)
-int connectedComponentsWithStats(InputArray image, OutputArray labels,
-                                 OutputArray stats, OutputArray centroids,
-                                 int connectivity, int ltype, int ccltype);
-
-/** @overload
-@param image the 8-bit single-channel image to be labeled
-@param labels destination labeled image
-@param stats statistics output for each label, including the background label.
-Statistics are accessed via stats(label, COLUMN) where COLUMN is one of
-#ConnectedComponentsTypes, selecting the statistic. The data type is CV_32S.
-@param centroids centroid output for each label, including the background label.
-Centroids are accessed via centroids(label, 0) for x and centroids(label, 1) for
-y. The data type CV_64F.
-@param connectivity 8 or 4 for 8-way or 4-way connectivity respectively
-@param ltype output image label type. Currently CV_32S and CV_16U are supported.
-*/
-CV_EXPORTS_W int
-connectedComponentsWithStats(InputArray image, OutputArray labels,
-                             OutputArray stats, OutputArray centroids,
-                             int connectivity = 8, int ltype = CV_32S);
-
-/** @brief Finds contours in a binary image.
-
-The function retrieves contours from the binary image using the algorithm @cite
-Suzuki85 . The contours are a useful tool for shape analysis and object
-detection and recognition. See squares.cpp in the OpenCV sample directory.
-@note Since opencv 3.2 source image is not modified by this function.
-
-@param image Source, an 8-bit single-channel image. Non-zero pixels are treated
-as 1's. Zero pixels remain 0's, so the image is treated as binary . You can use
-#compare, #inRange, #threshold , #adaptiveThreshold, #Canny, and others to
-create a binary image out of a grayscale or color one. If mode equals to
-#RETR_CCOMP or #RETR_FLOODFILL, the input can also be a 32-bit integer image of
-labels (CV_32SC1).
-@param contours Detected contours. Each contour is stored as a vector of points
-(e.g. std::vector<std::vector<cv::Point> >).
-@param hierarchy Optional output vector (e.g. std::vector<cv::Vec4i>),
-containing information about the image topology. It has as many elements as the
-number of contours. For each i-th contour contours[i], the elements
-hierarchy[i][0] , hierarchy[i][1] , hierarchy[i][2] , and hierarchy[i][3] are
-set to 0-based indices in contours of the next and previous contours at the same
-hierarchical level, the first child contour and the parent contour,
-respectively. If for the contour i there are no next, previous, parent, or
-nested contours, the corresponding elements of hierarchy[i] will be negative.
-@note In Python, hierarchy is nested inside a top level array. Use
-hierarchy[0][i] to access hierarchical elements of i-th contour.
-@param mode Contour retrieval mode, see #RetrievalModes
-@param method Contour approximation method, see #ContourApproximationModes
-@param offset Optional offset by which every contour point is shifted. This is
-useful if the contours are extracted from the image ROI and then they should be
-analyzed in the whole image context.
- */
-CV_EXPORTS_W void findContours(InputArray image, OutputArrayOfArrays contours,
-                               OutputArray hierarchy, int mode, int method,
-                               Point offset = Point());
-
-/** @overload */
-CV_EXPORTS void findContours(InputArray image, OutputArrayOfArrays contours,
-                             int mode, int method, Point offset = Point());
-
-//! @brief Find contours using link runs algorithm
-//!
-//! This function implements an algorithm different from cv::findContours:
-//! - doesn't allocate temporary image internally, thus it has reduced memory
-//! consumption
-//! - supports CV_8UC1 images only
-//! - outputs 2-level hierarhy only (RETR_CCOMP mode)
-//! - doesn't support approximation change other than CHAIN_APPROX_SIMPLE
-//! In all other aspects this function is compatible with cv::findContours.
-CV_EXPORTS_W void findContoursLinkRuns(InputArray image,
-                                       OutputArrayOfArrays contours,
-                                       OutputArray hierarchy);
-
-//! @overload
-CV_EXPORTS_W void findContoursLinkRuns(InputArray image,
-                                       OutputArrayOfArrays contours);
-
-/** @brief Approximates a polygonal curve(s) with the specified precision.
-
-The function cv::approxPolyDP approximates a curve or a polygon with another
-curve/polygon with less vertices so that the distance between them is less or
-equal to the specified precision. It uses the Douglas-Peucker algorithm
-<http://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm>
-
-@param curve Input vector of a 2D point stored in std::vector or Mat
-@param approxCurve Result of the approximation. The type should match the type
-of the input curve.
-@param epsilon Parameter specifying the approximation accuracy. This is the
-maximum distance between the original curve and its approximation.
-@param closed If true, the approximated curve is closed (its first and last
-vertices are connected). Otherwise, it is not closed.
- */
-CV_EXPORTS_W void approxPolyDP(InputArray curve, OutputArray approxCurve,
-                               double epsilon, bool closed);
-
-/** @brief Approximates a polygon with a convex hull with a specified accuracy
-and number of sides.
-
-The cv::approxPolyN function approximates a polygon with a convex hull
-so that the difference between the contour area of the original contour and the
-new polygon is minimal. It uses a greedy algorithm for contracting two vertices
-into one in such a way that the additional area is minimal. Straight lines
-formed by each edge of the convex contour are drawn and the areas of the
-resulting triangles are considered. Each vertex will lie either on the original
-contour or outside it.
-
-The algorithm based on the paper @cite LowIlie2003 .
-
-@param curve Input vector of a 2D points stored in std::vector or Mat, points
-must be float or integer.
-@param approxCurve Result of the approximation. The type is vector of a 2D point
-(Point2f or Point) in std::vector or Mat.
-@param nsides The parameter defines the number of sides of the result polygon.
-@param epsilon_percentage defines the percentage of the maximum of additional
-area. If it equals -1, it is not used. Otherwise algorighm stops if additional
-area is greater than contourArea(_curve) * percentage. If additional area
-exceeds the limit, algorithm returns as many vertices as there were at the
-moment the limit was exceeded.
-@param ensure_convex If it is true, algorithm creates a convex hull of input
-contour. Otherwise input vector should be convex.
- */
-CV_EXPORTS_W void approxPolyN(InputArray curve, OutputArray approxCurve,
-                              int nsides, float epsilon_percentage = -1.0,
-                              bool ensure_convex = true);
-
-/** @brief Calculates a contour perimeter or a curve length.
-
-The function computes a curve length or a closed contour perimeter.
-
-@param curve Input vector of 2D points, stored in std::vector or Mat.
-@param closed Flag indicating whether the curve is closed or not.
- */
-CV_EXPORTS_W double arcLength(InputArray curve, bool closed);
-
-/** @brief Calculates the up-right bounding rectangle of a point set or non-zero
-pixels of gray-scale image.
-
-The function calculates and returns the minimal up-right bounding rectangle for
-the specified point set or non-zero pixels of gray-scale image.
-
-@param array Input gray-scale image or 2D point set, stored in std::vector or
-Mat.
- */
-CV_EXPORTS_W Rect boundingRect(InputArray array);
-
-/** @brief Calculates a contour area.
-
-The function computes a contour area. Similarly to moments , the area is
-computed using the Green formula. Thus, the returned area and the number of
-non-zero pixels, if you draw the contour using #drawContours or #fillPoly , can
-be different. Also, the function will most certainly give a wrong results for
-contours with self-intersections.
-
-Example:
-@code
-    vector<Point> contour;
-    contour.push_back(Point2f(0, 0));
-    contour.push_back(Point2f(10, 0));
-    contour.push_back(Point2f(10, 10));
-    contour.push_back(Point2f(5, 4));
-
-    double area0 = contourArea(contour);
-    vector<Point> approx;
-    approxPolyDP(contour, approx, 5, true);
-    double area1 = contourArea(approx);
-
-    cout << "area0 =" << area0 << endl <<
-            "area1 =" << area1 << endl <<
-            "approx poly vertices" << approx.size() << endl;
-@endcode
-@param contour Input vector of 2D points (contour vertices), stored in
-std::vector or Mat.
-@param oriented Oriented area flag. If it is true, the function returns a signed
-area value, depending on the contour orientation (clockwise or
-counter-clockwise). Using this feature you can determine orientation of a
-contour by taking the sign of an area. By default, the parameter is false, which
-means that the absolute value is returned.
- */
-CV_EXPORTS_W double contourArea(InputArray contour, bool oriented = false);
-
-/** @brief Finds a rotated rectangle of the minimum area enclosing the input 2D
-point set.
-
-The function calculates and returns the minimum-area bounding rectangle
-(possibly rotated) for a specified point set. Developer should keep in mind that
-the returned RotatedRect can contain negative indices when data is close to the
-containing Mat element boundary.
-
-@param points Input vector of 2D points, stored in std::vector\<\> or Mat
- */
-CV_EXPORTS_W RotatedRect minAreaRect(InputArray points);
-
-/** @brief Finds the four vertices of a rotated rect. Useful to draw the rotated
-rectangle.
-
-The function finds the four vertices of a rotated rectangle. This function is
-useful to draw the rectangle. In C++, instead of using this function, you can
-directly use RotatedRect::points method. Please visit the @ref
-tutorial_bounding_rotated_ellipses "tutorial on Creating Bounding rotated boxes
-and ellipses for contours" for more information.
-
-@param box The input rotated rectangle. It may be the output of @ref
-minAreaRect.
-@param points The output array of four vertices of rectangles.
- */
-CV_EXPORTS_W void boxPoints(RotatedRect box, OutputArray points);
-
-/** @brief Finds a circle of the minimum area enclosing a 2D point set.
-
-The function finds the minimal enclosing circle of a 2D point set using an
-iterative algorithm.
-
-@param points Input vector of 2D points, stored in std::vector\<\> or Mat
-@param center Output center of the circle.
-@param radius Output radius of the circle.
- */
-CV_EXPORTS_W void minEnclosingCircle(InputArray points, CV_OUT Point2f &center,
-                                     CV_OUT float &radius);
-
-/** @example samples/cpp/minarea.cpp
- */
-
-/** @brief Finds a triangle of minimum area enclosing a 2D point set and returns
-its area.
-
-The function finds a triangle of minimum area enclosing the given set of 2D
-points and returns its area. The output for a given 2D point set is shown in the
-image below. 2D points are depicted in *red* and the enclosing triangle in
-*yellow*.
-
-![Sample output of the minimum enclosing triangle
-function](pics/minenclosingtriangle.png)
-
-The implementation of the algorithm is based on O'Rourke's @cite ORourke86 and
-Klee and Laskowski's
-@cite KleeLaskowski85 papers. O'Rourke provides a \f$\theta(n)\f$ algorithm for
-finding the minimal enclosing triangle of a 2D convex polygon with n vertices.
-Since the #minEnclosingTriangle function takes a 2D point set as input an
-additional preprocessing step of computing the convex hull of the 2D point set
-is required. The complexity of the #convexHull function is \f$O(n log(n))\f$
-which is higher than \f$\theta(n)\f$. Thus the overall complexity of the
-function is \f$O(n log(n))\f$.
-
-@param points Input vector of 2D points with depth CV_32S or CV_32F, stored in
-std::vector\<\> or Mat
-@param triangle Output vector of three 2D points defining the vertices of the
-triangle. The depth of the OutputArray must be CV_32F.
- */
-CV_EXPORTS_W double minEnclosingTriangle(InputArray points,
-                                         CV_OUT OutputArray triangle);
-
-/** @brief Compares two shapes.
-
-The function compares two shapes. All three implemented methods use the Hu
-invariants (see #HuMoments)
-
-@param contour1 First contour or grayscale image.
-@param contour2 Second contour or grayscale image.
-@param method Comparison method, see #ShapeMatchModes
-@param parameter Method-specific parameter (not supported now).
- */
-CV_EXPORTS_W double matchShapes(InputArray contour1, InputArray contour2,
-                                int method, double parameter);
-
-/** @example samples/cpp/convexhull.cpp
-An example using the convexHull functionality
-*/
-
-/** @brief Finds the convex hull of a point set.
-
-The function cv::convexHull finds the convex hull of a 2D point set using the
-Sklansky's algorithm @cite Sklansky82 that has *O(N logN)* complexity in the
-current implementation.
-
-@param points Input 2D point set, stored in std::vector or Mat.
-@param hull Output convex hull. It is either an integer vector of indices or
-vector of points. In the first case, the hull elements are 0-based indices of
-the convex hull points in the original array (since the set of convex hull
-points is a subset of the original point set). In the second case, hull elements
-are the convex hull points themselves.
-@param clockwise Orientation flag. If it is true, the output convex hull is
-oriented clockwise. Otherwise, it is oriented counter-clockwise. The assumed
-coordinate system has its X axis pointing to the right, and its Y axis pointing
-upwards.
-@param returnPoints Operation flag. In case of a matrix, when the flag is true,
-the function returns convex hull points. Otherwise, it returns indices of the
-convex hull points. When the output array is std::vector, the flag is ignored,
-and the output depends on the type of the vector: std::vector\<int\> implies
-returnPoints=false, std::vector\<Point\> implies returnPoints=true.
-
-@note `points` and `hull` should be different arrays, inplace processing isn't
-supported.
-
-Check @ref tutorial_hull "the corresponding tutorial" for more details.
-
-useful links:
-
-https://www.learnopencv.com/convex-hull-using-opencv-in-python-and-c/
- */
-CV_EXPORTS_W void convexHull(InputArray points, OutputArray hull,
-                             bool clockwise = false, bool returnPoints = true);
-
-/** @brief Finds the convexity defects of a contour.
-
-The figure below displays convexity defects of a hand contour:
-
-![image](pics/defects.png)
-
-@param contour Input contour.
-@param convexhull Convex hull obtained using convexHull that should contain
-indices of the contour points that make the hull.
-@param convexityDefects The output vector of convexity defects. In C++ and the
-new Python/Java interface each convexity defect is represented as 4-element
-integer vector (a.k.a. #Vec4i): (start_index, end_index, farthest_pt_index,
-fixpt_depth), where indices are 0-based indices in the original contour of the
-convexity defect beginning, end and the farthest point, and fixpt_depth is
-fixed-point approximation (with 8 fractional bits) of the distance between the
-farthest contour point and the hull. That is, to get the floating-point value of
-the depth will be fixpt_depth/256.0.
- */
-CV_EXPORTS_W void convexityDefects(InputArray contour, InputArray convexhull,
-                                   OutputArray convexityDefects);
-
-/** @brief Tests a contour convexity.
-
-The function tests whether the input contour is convex or not. The contour must
-be simple, that is, without self-intersections. Otherwise, the function output
-is undefined.
-
-@param contour Input vector of 2D points, stored in std::vector\<\> or Mat
- */
-CV_EXPORTS_W bool isContourConvex(InputArray contour);
-
-/** @example samples/cpp/intersectExample.cpp
-Examples of how intersectConvexConvex works
-*/
-
-/** @brief Finds intersection of two convex polygons
-
-@param p1 First polygon
-@param p2 Second polygon
-@param p12 Output polygon describing the intersecting area
-@param handleNested When true, an intersection is found if one of the polygons
-is fully enclosed in the other. When false, no intersection is found. If the
-polygons share a side or the vertex of one polygon lies on an edge of the other,
-they are not considered nested and an intersection will be found regardless of
-the value of handleNested.
-
-@returns Area of intersecting polygon. May be negative, if algorithm has not
-converged, e.g. non-convex input.
-
-@note intersectConvexConvex doesn't confirm that both polygons are convex and
-will return invalid results if they aren't.
- */
-CV_EXPORTS_W float intersectConvexConvex(InputArray p1, InputArray p2,
-                                         OutputArray p12,
-                                         bool handleNested = true);
-
-/** @example samples/cpp/fitellipse.cpp
-An example using the fitEllipse technique
-*/
-
-/** @brief Fits an ellipse around a set of 2D points.
-
-The function calculates the ellipse that fits (in a least-squares sense) a set
-of 2D points best of all. It returns the rotated rectangle in which the ellipse
-is inscribed. The first algorithm described by @cite Fitzgibbon95 is used.
-Developer should keep in mind that it is possible that the returned
-ellipse/rotatedRect data contains negative indices, due to the data points being
-close to the border of the containing Mat element.
-
-@param points Input 2D point set, stored in std::vector\<\> or Mat
- */
-CV_EXPORTS_W RotatedRect fitEllipse(InputArray points);
-
-/** @brief Fits an ellipse around a set of 2D points.
-
- The function calculates the ellipse that fits a set of 2D points.
- It returns the rotated rectangle in which the ellipse is inscribed.
- The Approximate Mean Square (AMS) proposed by @cite Taubin1991 is used.
-
- For an ellipse, this basis set is \f$ \chi= \left(x^2, x y, y^2, x, y, 1\right)
- \f$, which is a set of six free coefficients \f$
- A^T=\left\{A_{\text{xx}},A_{\text{xy}},A_{\text{yy}},A_x,A_y,A_0\right\} \f$.
- However, to specify an ellipse, all that is needed is five numbers; the major
- and minor axes lengths \f$ (a,b) \f$, the position \f$ (x_0,y_0) \f$, and the
- orientation \f$ \theta \f$. This is because the basis set includes lines,
- quadratics, parabolic and hyperbolic functions as well as elliptical functions
- as possible fits. If the fit is found to be a parabolic or hyperbolic function
- then the standard #fitEllipse method is used. The AMS method restricts the fit
- to parabolic, hyperbolic and elliptical curves by imposing the condition that
- \f$ A^T ( D_x^T D_x  +   D_y^T D_y) A = 1 \f$ where the matrices \f$ Dx \f$ and
- \f$ Dy \f$ are the partial derivatives of the design matrix \f$ D \f$ with
- respect to x and y. The matrices are formed row by row applying the following
- to each of the points in the set:
- \f{align*}{
- D(i,:)&=\left\{x_i^2, x_i y_i, y_i^2, x_i, y_i, 1\right\} &
- D_x(i,:)&=\left\{2 x_i,y_i,0,1,0,0\right\} &
- D_y(i,:)&=\left\{0,x_i,2 y_i,0,1,0\right\}
- \f}
- The AMS method minimizes the cost function
- \f{equation*}{
- \epsilon ^2=\frac{ A^T D^T D A }{ A^T (D_x^T D_x +  D_y^T D_y) A^T }
- \f}
-
- The minimum cost is found by solving the generalized eigenvalue problem.
-
- \f{equation*}{
- D^T D A = \lambda  \left( D_x^T D_x +  D_y^T D_y\right) A
- \f}
-
- @param points Input 2D point set, stored in std::vector\<\> or Mat
- */
-CV_EXPORTS_W RotatedRect fitEllipseAMS(InputArray points);
-
-/** @brief Fits an ellipse around a set of 2D points.
-
- The function calculates the ellipse that fits a set of 2D points.
- It returns the rotated rectangle in which the ellipse is inscribed.
- The Direct least square (Direct) method by @cite oy1998NumericallySD is used.
-
- For an ellipse, this basis set is \f$ \chi= \left(x^2, x y, y^2, x, y, 1\right)
- \f$, which is a set of six free coefficients \f$
- A^T=\left\{A_{\text{xx}},A_{\text{xy}},A_{\text{yy}},A_x,A_y,A_0\right\} \f$.
- However, to specify an ellipse, all that is needed is five numbers; the major
- and minor axes lengths \f$ (a,b) \f$, the position \f$ (x_0,y_0) \f$, and the
- orientation \f$ \theta \f$. This is because the basis set includes lines,
- quadratics, parabolic and hyperbolic functions as well as elliptical functions
- as possible fits. The Direct method confines the fit to ellipses by ensuring
- that \f$ 4 A_{xx} A_{yy}- A_{xy}^2 > 0 \f$. The condition imposed is that \f$ 4
- A_{xx} A_{yy}- A_{xy}^2=1 \f$ which satisfies the inequality and as the
- coefficients can be arbitrarily scaled is not overly restrictive.
-
- \f{equation*}{
- \epsilon ^2= A^T D^T D A \quad \text{with} \quad A^T C A =1 \quad \text{and}
- \quad C=\left(\begin{matrix}
- 0 & 0  & 2  & 0  & 0  &  0  \\
- 0 & -1  & 0  & 0  & 0  &  0 \\
- 2 & 0  & 0  & 0  & 0  &  0 \\
- 0 & 0  & 0  & 0  & 0  &  0 \\
- 0 & 0  & 0  & 0  & 0  &  0 \\
- 0 & 0  & 0  & 0  & 0  &  0
- \end{matrix} \right)
- \f}
-
- The minimum cost is found by solving the generalized eigenvalue problem.
-
- \f{equation*}{
- D^T D A = \lambda  \left( C\right) A
- \f}
-
- The system produces only one positive eigenvalue \f$ \lambda\f$ which is chosen
- as the solution with its eigenvector \f$\mathbf{u}\f$. These are used to find
- the coefficients
-
- \f{equation*}{
- A = \sqrt{\frac{1}{\mathbf{u}^T C \mathbf{u}}}  \mathbf{u}
- \f}
- The scaling factor guarantees that  \f$A^T C A =1\f$.
-
- @param points Input 2D point set, stored in std::vector\<\> or Mat
- */
-CV_EXPORTS_W RotatedRect fitEllipseDirect(InputArray points);
-
-/** @brief Fits a line to a 2D or 3D point set.
-
-The function fitLine fits a line to a 2D or 3D point set by minimizing \f$\sum_i
-\rho(r_i)\f$ where
-\f$r_i\f$ is a distance between the \f$i^{th}\f$ point, the line and
-\f$\rho(r)\f$ is a distance function, one of the following:
--  DIST_L2
-\f[\rho (r) = r^2/2  \quad \text{(the simplest and the fastest least-squares
-method)}\f]
-- DIST_L1
-\f[\rho (r) = r\f]
-- DIST_L12
-\f[\rho (r) = 2  \cdot ( \sqrt{1 + \frac{r^2}{2}} - 1)\f]
-- DIST_FAIR
-\f[\rho \left (r \right ) = C^2  \cdot \left (  \frac{r}{C} -  \log{\left(1 +
-\frac{r}{C}\right)} \right )  \quad \text{where} \quad C=1.3998\f]
-- DIST_WELSCH
-\f[\rho \left (r \right ) =  \frac{C^2}{2} \cdot \left ( 1 -
-\exp{\left(-\left(\frac{r}{C}\right)^2\right)} \right )  \quad \text{where}
-\quad C=2.9846\f]
-- DIST_HUBER
-\f[\rho (r) =  \fork{r^2/2}{if \(r < C\)}{C \cdot (r-C/2)}{otherwise} \quad
-\text{where} \quad C=1.345\f]
-
-The algorithm is based on the M-estimator (
-<http://en.wikipedia.org/wiki/M-estimator> ) technique that iteratively fits the
-line using the weighted least-squares algorithm. After each iteration the
-weights \f$w_i\f$ are adjusted to be inversely proportional to \f$\rho(r_i)\f$ .
-
-@param points Input vector of 2D or 3D points, stored in std::vector\<\> or Mat.
-@param line Output line parameters. In case of 2D fitting, it should be a vector
-of 4 elements (like Vec4f) - (vx, vy, x0, y0), where (vx, vy) is a normalized
-vector collinear to the line and (x0, y0) is a point on the line. In case of 3D
-fitting, it should be a vector of 6 elements (like Vec6f) - (vx, vy, vz, x0, y0,
-z0), where (vx, vy, vz) is a normalized vector collinear to the line and (x0,
-y0, z0) is a point on the line.
-@param distType Distance used by the M-estimator, see #DistanceTypes
-@param param Numerical parameter ( C ) for some types of distances. If it is 0,
-an optimal value is chosen.
-@param reps Sufficient accuracy for the radius (distance between the coordinate
-origin and the line).
-@param aeps Sufficient accuracy for the angle. 0.01 would be a good default
-value for reps and aeps.
- */
-CV_EXPORTS_W void fitLine(InputArray points, OutputArray line, int distType,
-                          double param, double reps, double aeps);
-
-/** @brief Performs a point-in-contour test.
-
-The function determines whether the point is inside a contour, outside, or lies
-on an edge (or coincides with a vertex). It returns positive (inside), negative
-(outside), or zero (on an edge) value, correspondingly. When measureDist=false ,
-the return value is +1, -1, and 0, respectively. Otherwise, the return value is
-a signed distance between the point and the nearest contour edge.
-
-See below a sample output of the function where each image pixel is tested
-against the contour:
-
-![sample output](pics/pointpolygon.png)
-
-@param contour Input contour.
-@param pt Point tested against the contour.
-@param measureDist If true, the function estimates the signed distance from the
-point to the nearest contour edge. Otherwise, the function only checks if the
-point is inside a contour or not.
- */
-CV_EXPORTS_W double pointPolygonTest(InputArray contour, Point2f pt,
-                                     bool measureDist);
-
-/** @brief Finds out if there is any intersection between two rotated
-rectangles.
-
-If there is then the vertices of the intersecting region are returned as well.
-
-Below are some examples of intersection configurations. The hatched pattern
-indicates the intersecting region and the red vertices are returned by the
-function.
-
-![intersection examples](pics/intersection.png)
-
-@param rect1 First rectangle
-@param rect2 Second rectangle
-@param intersectingRegion The output array of the vertices of the intersecting
-region. It returns at most 8 vertices. Stored as std::vector\<cv::Point2f\> or
-cv::Mat as Mx1 of type CV_32FC2.
-@returns One of #RectanglesIntersectTypes
- */
-CV_EXPORTS_W int rotatedRectangleIntersection(const RotatedRect &rect1,
-                                              const RotatedRect &rect2,
-                                              OutputArray intersectingRegion);
-
-/** @brief Creates a smart pointer to a cv::GeneralizedHoughBallard class and
- * initializes it.
- */
-CV_EXPORTS_W Ptr<GeneralizedHoughBallard> createGeneralizedHoughBallard();
-
-/** @brief Creates a smart pointer to a cv::GeneralizedHoughGuil class and
- * initializes it.
- */
-CV_EXPORTS_W Ptr<GeneralizedHoughGuil> createGeneralizedHoughGuil();
-
-//! @} imgproc_shape
-
-//! @addtogroup imgproc_colormap
-//! @{
-
-//! GNU Octave/MATLAB equivalent colormaps
-enum ColormapTypes {
-  COLORMAP_AUTUMN = 0,   //!< ![autumn](pics/colormaps/colorscale_autumn.jpg)
-  COLORMAP_BONE = 1,     //!< ![bone](pics/colormaps/colorscale_bone.jpg)
-  COLORMAP_JET = 2,      //!< ![jet](pics/colormaps/colorscale_jet.jpg)
-  COLORMAP_WINTER = 3,   //!< ![winter](pics/colormaps/colorscale_winter.jpg)
-  COLORMAP_RAINBOW = 4,  //!< ![rainbow](pics/colormaps/colorscale_rainbow.jpg)
-  COLORMAP_OCEAN = 5,    //!< ![ocean](pics/colormaps/colorscale_ocean.jpg)
-  COLORMAP_SUMMER = 6,   //!< ![summer](pics/colormaps/colorscale_summer.jpg)
-  COLORMAP_SPRING = 7,   //!< ![spring](pics/colormaps/colorscale_spring.jpg)
-  COLORMAP_COOL = 8,     //!< ![cool](pics/colormaps/colorscale_cool.jpg)
-  COLORMAP_HSV = 9,      //!< ![HSV](pics/colormaps/colorscale_hsv.jpg)
-  COLORMAP_PINK = 10,    //!< ![pink](pics/colormaps/colorscale_pink.jpg)
-  COLORMAP_HOT = 11,     //!< ![hot](pics/colormaps/colorscale_hot.jpg)
-  COLORMAP_PARULA = 12,  //!< ![parula](pics/colormaps/colorscale_parula.jpg)
-  COLORMAP_MAGMA = 13,   //!< ![magma](pics/colormaps/colorscale_magma.jpg)
-  COLORMAP_INFERNO = 14, //!< ![inferno](pics/colormaps/colorscale_inferno.jpg)
-  COLORMAP_PLASMA = 15,  //!< ![plasma](pics/colormaps/colorscale_plasma.jpg)
-  COLORMAP_VIRIDIS = 16, //!< ![viridis](pics/colormaps/colorscale_viridis.jpg)
-  COLORMAP_CIVIDIS = 17, //!< ![cividis](pics/colormaps/colorscale_cividis.jpg)
-  COLORMAP_TWILIGHT =
-      18, //!< ![twilight](pics/colormaps/colorscale_twilight.jpg)
-  COLORMAP_TWILIGHT_SHIFTED =
-      19, //!< ![twilight
-          //!< shifted](pics/colormaps/colorscale_twilight_shifted.jpg)
-  COLORMAP_TURBO = 20, //!< ![turbo](pics/colormaps/colorscale_turbo.jpg)
-  COLORMAP_DEEPGREEN =
-      21 //!< ![deepgreen](pics/colormaps/colorscale_deepgreen.jpg)
-};
-
-/** @example samples/cpp/falsecolor.cpp
-An example using applyColorMap function
-*/
-
-/** @brief Applies a GNU Octave/MATLAB equivalent colormap on a given image.
-
-@param src The source image, grayscale or colored of type CV_8UC1 or CV_8UC3. If
-CV_8UC3, then the CV_8UC1 image is generated internally using
-cv::COLOR_BGR2GRAY.
-@param dst The result is the colormapped source image. Note: Mat::create is
-called on dst.
-@param colormap The colormap to apply, see #ColormapTypes
-*/
-CV_EXPORTS_W void applyColorMap(InputArray src, OutputArray dst, int colormap);
-
-/** @brief Applies a user colormap on a given image.
-
-@param src The source image, grayscale or colored of type CV_8UC1 or CV_8UC3. If
-CV_8UC3, then the CV_8UC1 image is generated internally using
-cv::COLOR_BGR2GRAY.
-@param dst The result is the colormapped source image of the same number of
-channels as userColor. Note: Mat::create is called on dst.
-@param userColor The colormap to apply of type CV_8UC1 or CV_8UC3 and size 256
-*/
-CV_EXPORTS_W void applyColorMap(InputArray src, OutputArray dst,
-                                InputArray userColor);
-
-//! @} imgproc_colormap
-
-//! @addtogroup imgproc_draw
-//! @{
-
-/** OpenCV color channel order is BGR[A] */
-#define CV_RGB(r, g, b) cv::Scalar((b), (g), (r), 0)
-
-/** @brief Draws a line segment connecting two points.
-
-The function line draws the line segment between pt1 and pt2 points in the
-image. The line is clipped by the image boundaries. For non-antialiased lines
-with integer coordinates, the 8-connected or 4-connected Bresenham algorithm is
-used. Thick lines are drawn with rounding endings. Antialiased lines are drawn
-using Gaussian filtering.
-
-@param img Image.
-@param pt1 First point of the line segment.
-@param pt2 Second point of the line segment.
-@param color Line color.
-@param thickness Line thickness.
-@param lineType Type of the line. See #LineTypes.
-@param shift Number of fractional bits in the point coordinates.
- */
-CV_EXPORTS_W void line(InputOutputArray img, Point pt1, Point pt2,
-                       const Scalar &color, int thickness = 1,
-                       int lineType = LINE_8, int shift = 0);
-
-/** @brief Draws an arrow segment pointing from the first point to the second
-one.
-
-The function cv::arrowedLine draws an arrow between pt1 and pt2 points in the
-image. See also #line.
-
-@param img Image.
-@param pt1 The point the arrow starts from.
-@param pt2 The point the arrow points to.
-@param color Line color.
-@param thickness Line thickness.
-@param line_type Type of the line. See #LineTypes
-@param shift Number of fractional bits in the point coordinates.
-@param tipLength The length of the arrow tip in relation to the arrow length
- */
-CV_EXPORTS_W void arrowedLine(InputOutputArray img, Point pt1, Point pt2,
-                              const Scalar &color, int thickness = 1,
-                              int line_type = 8, int shift = 0,
-                              double tipLength = 0.1);
-
-/** @brief Draws a simple, thick, or filled up-right rectangle.
-
-The function cv::rectangle draws a rectangle outline or a filled rectangle whose
-two opposite corners are pt1 and pt2.
-
-@param img Image.
-@param pt1 Vertex of the rectangle.
-@param pt2 Vertex of the rectangle opposite to pt1 .
-@param color Rectangle color or brightness (grayscale image).
-@param thickness Thickness of lines that make up the rectangle. Negative values,
-like #FILLED, mean that the function has to draw a filled rectangle.
-@param lineType Type of the line. See #LineTypes
-@param shift Number of fractional bits in the point coordinates.
- */
-CV_EXPORTS_W void rectangle(InputOutputArray img, Point pt1, Point pt2,
-                            const Scalar &color, int thickness = 1,
-                            int lineType = LINE_8, int shift = 0);
-
-/** @overload
-
-use `rec` parameter as alternative specification of the drawn rectangle: `r.tl()
-and r.br()-Point(1,1)` are opposite corners
-*/
-CV_EXPORTS_W void rectangle(InputOutputArray img, Rect rec, const Scalar &color,
-                            int thickness = 1, int lineType = LINE_8,
-                            int shift = 0);
-
-/** @example samples/cpp/tutorial_code/ImgProc/basic_drawing/Drawing_2.cpp
-An example using drawing functions
-*/
-
-/** @brief Draws a circle.
-
-The function cv::circle draws a simple or filled circle with a given center and
-radius.
-@param img Image where the circle is drawn.
-@param center Center of the circle.
-@param radius Radius of the circle.
-@param color Circle color.
-@param thickness Thickness of the circle outline, if positive. Negative values,
-like #FILLED, mean that a filled circle is to be drawn.
-@param lineType Type of the circle boundary. See #LineTypes
-@param shift Number of fractional bits in the coordinates of the center and in
-the radius value.
- */
-CV_EXPORTS_W void circle(InputOutputArray img, Point center, int radius,
-                         const Scalar &color, int thickness = 1,
-                         int lineType = LINE_8, int shift = 0);
-
-/** @brief Draws a simple or thick elliptic arc or fills an ellipse sector.
-
-The function cv::ellipse with more parameters draws an ellipse outline, a filled
-ellipse, an elliptic arc, or a filled ellipse sector. The drawing code uses
-general parametric form. A piecewise-linear curve is used to approximate the
-elliptic arc boundary. If you need more control of the ellipse rendering, you
-can retrieve the curve using #ellipse2Poly and then render it with #polylines or
-fill it with #fillPoly. If you use the first variant of the function and want to
-draw the whole ellipse, not an arc, pass `startAngle=0` and `endAngle=360`. If
-`startAngle` is greater than `endAngle`, they are swapped. The figure below
-explains the meaning of the parameters to draw the blue arc.
-
-![Parameters of Elliptic Arc](pics/ellipse.svg)
-
-@param img Image.
-@param center Center of the ellipse.
-@param axes Half of the size of the ellipse main axes.
-@param angle Ellipse rotation angle in degrees.
-@param startAngle Starting angle of the elliptic arc in degrees.
-@param endAngle Ending angle of the elliptic arc in degrees.
-@param color Ellipse color.
-@param thickness Thickness of the ellipse arc outline, if positive. Otherwise,
-this indicates that a filled ellipse sector is to be drawn.
-@param lineType Type of the ellipse boundary. See #LineTypes
-@param shift Number of fractional bits in the coordinates of the center and
-values of axes.
- */
-CV_EXPORTS_W void ellipse(InputOutputArray img, Point center, Size axes,
-                          double angle, double startAngle, double endAngle,
-                          const Scalar &color, int thickness = 1,
-                          int lineType = LINE_8, int shift = 0);
-
-/** @overload
-@param img Image.
-@param box Alternative ellipse representation via RotatedRect. This means that
-the function draws an ellipse inscribed in the rotated rectangle.
-@param color Ellipse color.
-@param thickness Thickness of the ellipse arc outline, if positive. Otherwise,
-this indicates that a filled ellipse sector is to be drawn.
-@param lineType Type of the ellipse boundary. See #LineTypes
-*/
-CV_EXPORTS_W void ellipse(InputOutputArray img, const RotatedRect &box,
-                          const Scalar &color, int thickness = 1,
-                          int lineType = LINE_8);
-
-/* -----------------------------------------------------------------------------------------
- */
-/* ADDING A SET OF PREDEFINED MARKERS WHICH COULD BE USED TO HIGHLIGHT POSITIONS
- * IN AN IMAGE */
-/* -----------------------------------------------------------------------------------------
- */
-
-/** @brief Draws a marker on a predefined position in an image.
-
-The function cv::drawMarker draws a marker on a given position in the image. For
-the moment several marker types are supported, see #MarkerTypes for more
-information.
-
-@param img Image.
-@param position The point where the crosshair is positioned.
-@param color Line color.
-@param markerType The specific type of marker you want to use, see #MarkerTypes
-@param thickness Line thickness.
-@param line_type Type of the line, See #LineTypes
-@param markerSize The length of the marker axis [default = 20 pixels]
- */
-CV_EXPORTS_W void drawMarker(InputOutputArray img, Point position,
-                             const Scalar &color, int markerType = MARKER_CROSS,
-                             int markerSize = 20, int thickness = 1,
-                             int line_type = 8);
-
-/* -----------------------------------------------------------------------------------------
- */
-/* END OF MARKER SECTION */
-/* -----------------------------------------------------------------------------------------
- */
-
-/** @brief Fills a convex polygon.
-
-The function cv::fillConvexPoly draws a filled convex polygon. This function is
-much faster than the function #fillPoly . It can fill not only convex polygons
-but any monotonic polygon without self-intersections, that is, a polygon whose
-contour intersects every horizontal line (scan line) twice at the most (though,
-its top-most and/or the bottom edge could be horizontal).
-
-@param img Image.
-@param points Polygon vertices.
-@param color Polygon color.
-@param lineType Type of the polygon boundaries. See #LineTypes
-@param shift Number of fractional bits in the vertex coordinates.
- */
-CV_EXPORTS_W void fillConvexPoly(InputOutputArray img, InputArray points,
-                                 const Scalar &color, int lineType = LINE_8,
-                                 int shift = 0);
-
-/** @overload */
-CV_EXPORTS void fillConvexPoly(InputOutputArray img, const Point *pts, int npts,
-                               const Scalar &color, int lineType = LINE_8,
-                               int shift = 0);
-
-/** @example samples/cpp/tutorial_code/ImgProc/basic_drawing/Drawing_1.cpp
-An example using drawing functions
-Check @ref tutorial_random_generator_and_text "the corresponding tutorial" for
-more details
-*/
-
-/** @brief Fills the area bounded by one or more polygons.
-
-The function cv::fillPoly fills an area bounded by several polygonal contours.
-The function can fill complex areas, for example, areas with holes, contours
-with self-intersections (some of their parts), and so forth.
-
-@param img Image.
-@param pts Array of polygons where each polygon is represented as an array of
-points.
-@param color Polygon color.
-@param lineType Type of the polygon boundaries. See #LineTypes
-@param shift Number of fractional bits in the vertex coordinates.
-@param offset Optional offset of all points of the contours.
- */
-CV_EXPORTS_W void fillPoly(InputOutputArray img, InputArrayOfArrays pts,
-                           const Scalar &color, int lineType = LINE_8,
-                           int shift = 0, Point offset = Point());
-
-/** @overload */
-CV_EXPORTS void fillPoly(InputOutputArray img, const Point **pts,
-                         const int *npts, int ncontours, const Scalar &color,
-                         int lineType = LINE_8, int shift = 0,
-                         Point offset = Point());
-
-/** @brief Draws several polygonal curves.
-
-@param img Image.
-@param pts Array of polygonal curves.
-@param isClosed Flag indicating whether the drawn polylines are closed or not.
-If they are closed, the function draws a line from the last vertex of each curve
-to its first vertex.
-@param color Polyline color.
-@param thickness Thickness of the polyline edges.
-@param lineType Type of the line segments. See #LineTypes
-@param shift Number of fractional bits in the vertex coordinates.
-
-The function cv::polylines draws one or more polygonal curves.
- */
-CV_EXPORTS_W void polylines(InputOutputArray img, InputArrayOfArrays pts,
-                            bool isClosed, const Scalar &color,
-                            int thickness = 1, int lineType = LINE_8,
-                            int shift = 0);
-
-/** @overload */
-CV_EXPORTS void polylines(InputOutputArray img, const Point *const *pts,
-                          const int *npts, int ncontours, bool isClosed,
-                          const Scalar &color, int thickness = 1,
-                          int lineType = LINE_8, int shift = 0);
-
-/** @example samples/cpp/contours2.cpp
-An example program illustrates the use of cv::findContours and cv::drawContours
-\image html WindowsQtContoursOutput.png "Screenshot of the program"
-*/
-
-/** @example samples/cpp/segment_objects.cpp
-An example using drawContours to clean up a background segmentation result
-*/
-
-/** @brief Draws contours outlines or filled contours.
-
-The function draws contour outlines in the image if \f$\texttt{thickness} \ge
-0\f$ or fills the area bounded by the contours if \f$\texttt{thickness}<0\f$ .
-The example below shows how to retrieve connected components from the binary
-image and label them: :
-@include snippets/imgproc_drawContours.cpp
-
-@param image Destination image.
-@param contours All the input contours. Each contour is stored as a point
-vector.
-@param contourIdx Parameter indicating a contour to draw. If it is negative, all
-the contours are drawn.
-@param color Color of the contours.
-@param thickness Thickness of lines the contours are drawn with. If it is
-negative (for example, thickness=#FILLED ), the contour interiors are drawn.
-@param lineType Line connectivity. See #LineTypes
-@param hierarchy Optional information about hierarchy. It is only needed if you
-want to draw only some of the contours (see maxLevel ).
-@param maxLevel Maximal level for drawn contours. If it is 0, only the specified
-contour is drawn. If it is 1, the function draws the contour(s) and all the
-nested contours. If it is 2, the function draws the contours, all the nested
-contours, all the nested-to-nested contours, and so on. This parameter is only
-taken into account when there is hierarchy available.
-@param offset Optional contour shift parameter. Shift all the drawn contours by
-the specified
-\f$\texttt{offset}=(dx,dy)\f$ .
-@note When thickness=#FILLED, the function is designed to handle connected
-components with holes correctly even when no hierarchy data is provided. This is
-done by analyzing all the outlines together using even-odd rule. This may give
-incorrect results if you have a joint collection of separately retrieved
-contours. In order to solve this problem, you need to call #drawContours
-separately for each sub-group of contours, or iterate over the collection using
-contourIdx parameter.
- */
-CV_EXPORTS_W void drawContours(InputOutputArray image,
-                               InputArrayOfArrays contours, int contourIdx,
-                               const Scalar &color, int thickness = 1,
-                               int lineType = LINE_8,
-                               InputArray hierarchy = noArray(),
-                               int maxLevel = INT_MAX, Point offset = Point());
-
-/** @brief Clips the line against the image rectangle.
-
-The function cv::clipLine calculates a part of the line segment that is entirely
-within the specified rectangle. It returns false if the line segment is
-completely outside the rectangle. Otherwise, it returns true .
-@param imgSize Image size. The image rectangle is Rect(0, 0, imgSize.width,
-imgSize.height) .
-@param pt1 First line point.
-@param pt2 Second line point.
- */
-CV_EXPORTS bool clipLine(Size imgSize, CV_IN_OUT Point &pt1,
-                         CV_IN_OUT Point &pt2);
-
-/** @overload
-@param imgSize Image size. The image rectangle is Rect(0, 0, imgSize.width,
-imgSize.height) .
-@param pt1 First line point.
-@param pt2 Second line point.
-*/
-CV_EXPORTS bool clipLine(Size2l imgSize, CV_IN_OUT Point2l &pt1,
-                         CV_IN_OUT Point2l &pt2);
-
-/** @overload
-@param imgRect Image rectangle.
-@param pt1 First line point.
-@param pt2 Second line point.
-*/
-CV_EXPORTS_W bool clipLine(Rect imgRect, CV_OUT CV_IN_OUT Point &pt1,
-                           CV_OUT CV_IN_OUT Point &pt2);
-
-/** @brief Approximates an elliptic arc with a polyline.
-
-The function ellipse2Poly computes the vertices of a polyline that approximates
-the specified elliptic arc. It is used by #ellipse. If `arcStart` is greater
-than `arcEnd`, they are swapped.
-
-@param center Center of the arc.
-@param axes Half of the size of the ellipse main axes. See #ellipse for details.
-@param angle Rotation angle of the ellipse in degrees. See #ellipse for details.
-@param arcStart Starting angle of the elliptic arc in degrees.
-@param arcEnd Ending angle of the elliptic arc in degrees.
-@param delta Angle between the subsequent polyline vertices. It defines the
-approximation accuracy.
-@param pts Output vector of polyline vertices.
- */
-CV_EXPORTS_W void ellipse2Poly(Point center, Size axes, int angle, int arcStart,
-                               int arcEnd, int delta,
-                               CV_OUT std::vector<Point> &pts);
-
-/** @overload
-@param center Center of the arc.
-@param axes Half of the size of the ellipse main axes. See #ellipse for details.
-@param angle Rotation angle of the ellipse in degrees. See #ellipse for details.
-@param arcStart Starting angle of the elliptic arc in degrees.
-@param arcEnd Ending angle of the elliptic arc in degrees.
-@param delta Angle between the subsequent polyline vertices. It defines the
-approximation accuracy.
-@param pts Output vector of polyline vertices.
-*/
-CV_EXPORTS void ellipse2Poly(Point2d center, Size2d axes, int angle,
-                             int arcStart, int arcEnd, int delta,
-                             CV_OUT std::vector<Point2d> &pts);
-
-/** @brief Draws a text string.
-
-The function cv::putText renders the specified text string in the image. Symbols
-that cannot be rendered using the specified font are replaced by question marks.
-See #getTextSize for a text rendering code example.
-
-@param img Image.
-@param text Text string to be drawn.
-@param org Bottom-left corner of the text string in the image.
-@param fontFace Font type, see #HersheyFonts.
-@param fontScale Font scale factor that is multiplied by the font-specific base
-size.
-@param color Text color.
-@param thickness Thickness of the lines used to draw a text.
-@param lineType Line type. See #LineTypes
-@param bottomLeftOrigin When true, the image data origin is at the bottom-left
-corner. Otherwise, it is at the top-left corner.
- */
-CV_EXPORTS_W void putText(InputOutputArray img, const String &text, Point org,
-                          int fontFace, double fontScale, Scalar color,
-                          int thickness = 1, int lineType = LINE_8,
-                          bool bottomLeftOrigin = false);
-
-/** @brief Calculates the width and height of a text string.
-
-The function cv::getTextSize calculates and returns the size of a box that
-contains the specified text. That is, the following code renders some text, the
-tight box surrounding it, and the baseline: :
-@code
-    String text = "Funny text inside the box";
-    int fontFace = FONT_HERSHEY_SCRIPT_SIMPLEX;
-    double fontScale = 2;
-    int thickness = 3;
-
-    Mat img(600, 800, CV_8UC3, Scalar::all(0));
-
-    int baseline=0;
-    Size textSize = getTextSize(text, fontFace,
-                                fontScale, thickness, &baseline);
-    baseline += thickness;
-
-    // center the text
-    Point textOrg((img.cols - textSize.width)/2,
-                  (img.rows + textSize.height)/2);
-
-    // draw the box
-    rectangle(img, textOrg + Point(0, baseline),
-              textOrg + Point(textSize.width, -textSize.height),
-              Scalar(0,0,255));
-    // ... and the baseline first
-    line(img, textOrg + Point(0, thickness),
-         textOrg + Point(textSize.width, thickness),
-         Scalar(0, 0, 255));
-
-    // then put the text itself
-    putText(img, text, textOrg, fontFace, fontScale,
-            Scalar::all(255), thickness, 8);
-@endcode
-
-@param text Input text string.
-@param fontFace Font to use, see #HersheyFonts.
-@param fontScale Font scale factor that is multiplied by the font-specific base
-size.
-@param thickness Thickness of lines used to render the text. See #putText for
-details.
-@param[out] baseLine y-coordinate of the baseline relative to the bottom-most
-text point.
-@return The size of a box that contains the specified text.
-
-@see putText
- */
-CV_EXPORTS_W Size getTextSize(const String &text, int fontFace,
-                              double fontScale, int thickness,
-                              CV_OUT int *baseLine);
-
-/** @brief Calculates the font-specific size to use to achieve a given height in
-pixels.
-
-@param fontFace Font to use, see cv::HersheyFonts.
-@param pixelHeight Pixel height to compute the fontScale for
-@param thickness Thickness of lines used to render the text.See putText for
-details.
-@return The fontSize to use for cv::putText
-
-@see cv::putText
-*/
-CV_EXPORTS_W double getFontScaleFromHeight(const int fontFace,
-                                           const int pixelHeight,
-                                           const int thickness = 1);
-
-class FontFaceImpl;
-class CV_EXPORTS_W FontFace {
-public:
-  FontFace();
-  FontFace(const String &fontPath);
-
-  ~FontFace();
-
-protected:
-  void set_glyph(int count, const unsigned int *unicode,
-                 const unsigned char *bitmaps);
-
-public:
-  FontFaceImpl *const d;
-};
-
-enum PutTextFlags {
-  PUT_TEXT_ALIGN_LEFT = 0, // put the text to the right from the origin
-  PUT_TEXT_ALIGN_CENTER =
-      1, // center the text at the origin; not implemented yet
-  PUT_TEXT_ALIGN_RIGHT = 2, // put the text to the left of the origin
-  PUT_TEXT_ALIGN_MASK = 3,  // alignment mask
-  PUT_TEXT_ORIGIN_TL = 0,
-  PUT_TEXT_ORIGIN_BL =
-      32,             // treat the target image as having bottom-left origin
-  PUT_TEXT_WRAP = 128 // wrap text to the next line if it does not fit
-};
-
-CV_EXPORTS_W Point putText(InputOutputArray img, const String &text, Point org,
-                           Scalar color, const FontFace &fface, int size,
-                           int weight = 0,
-                           PutTextFlags flags = PUT_TEXT_ALIGN_LEFT,
-                           Range wrap = Range());
-
-CV_EXPORTS_W Rect getTextSize(Size imgsize, const String &text, Point org,
-                              const FontFace &fontface, int size,
-                              int weight = 0,
-                              PutTextFlags flags = PUT_TEXT_ALIGN_LEFT,
-                              Range wrap = Range());
-
-/** @brief Class for iterating over all pixels on a raster line segment.
-
-The class LineIterator is used to get each pixel of a raster line connecting
-two specified points.
-It can be treated as a versatile implementation of the Bresenham algorithm
-where you can stop at each pixel and do some extra processing, for
-example, grab pixel values along the line or draw a line with an effect
-(for example, with XOR operation).
-
-The number of pixels along the line is stored in LineIterator::count.
-The method LineIterator::pos returns the current position in the image:
-
-@code{.cpp}
-// grabs pixels along the line (pt1, pt2)
-// from 8-bit 3-channel image to the buffer
-LineIterator it(img, pt1, pt2, 8);
-LineIterator it2 = it;
-vector<Vec3b> buf(it.count);
-
-for(int i = 0; i < it.count; i++, ++it)
-    buf[i] = *(const Vec3b*)*it;
-
-// alternative way of iterating through the line
-for(int i = 0; i < it2.count; i++, ++it2)
-{
-    Vec3b val = img.at<Vec3b>(it2.pos());
-    CV_Assert(buf[i] == val);
-}
-@endcode
-*/
-class CV_EXPORTS LineIterator {
-public:
-  /** @brief Initializes iterator object for the given line and image.
-
-  The returned iterator can be used to traverse all pixels on a line that
-  connects the given two points.
-  The line will be clipped on the image boundaries.
-
-  @param img Underlying image.
-  @param pt1 First endpoint of the line.
-  @param pt2 The other endpoint of the line.
-  @param connectivity Pixel connectivity of the iterator. Valid values are 4
-  (iterator can move up, down, left and right) and 8 (iterator can also move
-  diagonally).
-  @param leftToRight If true, the line is traversed from the leftmost endpoint
-  to the rightmost endpoint. Otherwise, the line is traversed from \p pt1 to \p
-  pt2.
-  */
-  LineIterator(const Mat &img, Point pt1, Point pt2, int connectivity = 8,
-               bool leftToRight = false) {
-    init(&img, Rect(0, 0, img.cols, img.rows), pt1, pt2, connectivity,
-         leftToRight);
-    ptmode = false;
-  }
-  LineIterator(Point pt1, Point pt2, int connectivity = 8,
-               bool leftToRight = false) {
-    init(0,
-         Rect(std::min(pt1.x, pt2.x), std::min(pt1.y, pt2.y),
-              std::max(pt1.x, pt2.x) - std::min(pt1.x, pt2.x) + 1,
-              std::max(pt1.y, pt2.y) - std::min(pt1.y, pt2.y) + 1),
-         pt1, pt2, connectivity, leftToRight);
-    ptmode = true;
-  }
-  LineIterator(Size boundingAreaSize, Point pt1, Point pt2,
-               int connectivity = 8, bool leftToRight = false) {
-    init(0, Rect(0, 0, boundingAreaSize.width, boundingAreaSize.height), pt1,
-         pt2, connectivity, leftToRight);
-    ptmode = true;
-  }
-  LineIterator(Rect boundingAreaRect, Point pt1, Point pt2,
-               int connectivity = 8, bool leftToRight = false) {
-    init(0, boundingAreaRect, pt1, pt2, connectivity, leftToRight);
-    ptmode = true;
-  }
-  void init(const Mat *img, Rect boundingAreaRect, Point pt1, Point pt2,
-            int connectivity, bool leftToRight);
-
-  /** @brief Returns pointer to the current pixel.
-   */
-  uchar *operator*();
-
-  /** @brief Moves iterator to the next pixel on the line.
-
-  This is the prefix version (++it).
-  */
-  LineIterator &operator++();
-
-  /** @brief Moves iterator to the next pixel on the line.
-
-  This is the postfix version (it++).
-  */
-  LineIterator operator++(int);
-
-  /** @brief Returns coordinates of the current pixel.
-   */
-  Point pos() const;
-
-  uchar *ptr;
-  const uchar *ptr0;
-  int step, elemSize;
-  int err, count;
-  int minusDelta, plusDelta;
-  int minusStep, plusStep;
-  int minusShift, plusShift;
-  Point p;
-  bool ptmode;
-};
-
-//! @cond IGNORED
-
-// === LineIterator implementation ===
-
-inline uchar *LineIterator::operator*() { return ptmode ? 0 : ptr; }
-
-inline LineIterator &LineIterator::operator++() {
-  int mask = err < 0 ? -1 : 0;
-  err += minusDelta + (plusDelta & mask);
-  if (!ptmode) {
-    ptr += minusStep + (plusStep & mask);
-  } else {
-    p.x += minusShift + (plusShift & mask);
-    p.y += minusStep + (plusStep & mask);
-  }
-  return *this;
-}
-
-inline LineIterator LineIterator::operator++(int) {
-  LineIterator it = *this;
-  ++(*this);
-  return it;
-}
-
-inline Point LineIterator::pos() const {
-  if (!ptmode) {
-    size_t offset = (size_t)(ptr - ptr0);
-    int y = (int)(offset / step);
-    int x = (int)((offset - (size_t)y * step) / elemSize);
-    return Point(x, y);
-  }
-  return p;
-}
-
-//! @endcond
-
-//! @} imgproc_draw
-
-//! @} imgproc
-
-} // namespace cv
-
-#include "./imgproc/segmentation.hpp"
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/imgproc/bindings.hpp b/packages/react-native-executorch/third-party/include/opencv2/imgproc/bindings.hpp
deleted file mode 100644
index 610bb28482..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/imgproc/bindings.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_IMGPROC_BINDINGS_HPP
-#define OPENCV_IMGPROC_BINDINGS_HPP
-
-// This file contains special overloads for OpenCV bindings
-// No need to use these functions in C++ code.
-
-namespace cv {
-
-/** @brief Finds lines in a binary image using the standard Hough transform and
- * get accumulator.
- *
- * @note This function is for bindings use only. Use original function in C++
- * code
- *
- * @sa HoughLines
- */
-CV_WRAP static inline void
-HoughLinesWithAccumulator(InputArray image, OutputArray lines, double rho,
-                          double theta, int threshold, double srn = 0,
-                          double stn = 0, double min_theta = 0,
-                          double max_theta = CV_PI) {
-  std::vector<Vec3f> lines_acc;
-  HoughLines(image, lines_acc, rho, theta, threshold, srn, stn, min_theta,
-             max_theta);
-  Mat(lines_acc).copyTo(lines);
-}
-
-} // namespace cv
-
-#endif // OPENCV_IMGPROC_BINDINGS_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/imgproc/detail/gcgraph.hpp b/packages/react-native-executorch/third-party/include/opencv2/imgproc/detail/gcgraph.hpp
deleted file mode 100644
index ba934a1fb2..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/imgproc/detail/gcgraph.hpp
+++ /dev/null
@@ -1,355 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                        Intel License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000, Intel Corporation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of Intel Corporation may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_IMGPROC_DETAIL_GCGRAPH_HPP
-#define OPENCV_IMGPROC_DETAIL_GCGRAPH_HPP
-
-//! @cond IGNORED
-
-namespace cv {
-namespace detail {
-template <class TWeight> class GCGraph {
-public:
-  GCGraph();
-  GCGraph(unsigned int vtxCount, unsigned int edgeCount);
-  ~GCGraph();
-  void create(unsigned int vtxCount, unsigned int edgeCount);
-  int addVtx();
-  void addEdges(int i, int j, TWeight w, TWeight revw);
-  void addTermWeights(int i, TWeight sourceW, TWeight sinkW);
-  TWeight maxFlow();
-  bool inSourceSegment(int i);
-
-private:
-  class Vtx {
-  public:
-    Vtx *next; // initialized and used in maxFlow() only
-    int parent;
-    int first;
-    int ts;
-    int dist;
-    TWeight weight;
-    uchar t;
-  };
-  class Edge {
-  public:
-    int dst;
-    int next;
-    TWeight weight;
-  };
-
-  std::vector<Vtx> vtcs;
-  std::vector<Edge> edges;
-  TWeight flow;
-};
-
-template <class TWeight> GCGraph<TWeight>::GCGraph() { flow = 0; }
-template <class TWeight>
-GCGraph<TWeight>::GCGraph(unsigned int vtxCount, unsigned int edgeCount) {
-  create(vtxCount, edgeCount);
-}
-template <class TWeight> GCGraph<TWeight>::~GCGraph() {}
-template <class TWeight>
-void GCGraph<TWeight>::create(unsigned int vtxCount, unsigned int edgeCount) {
-  vtcs.reserve(vtxCount);
-  edges.reserve(edgeCount + 2);
-  flow = 0;
-}
-
-template <class TWeight> int GCGraph<TWeight>::addVtx() {
-  Vtx v;
-  memset(&v, 0, sizeof(Vtx));
-  vtcs.push_back(v);
-  return (int)vtcs.size() - 1;
-}
-
-template <class TWeight>
-void GCGraph<TWeight>::addEdges(int i, int j, TWeight w, TWeight revw) {
-  CV_Assert(i >= 0 && i < (int)vtcs.size());
-  CV_Assert(j >= 0 && j < (int)vtcs.size());
-  CV_Assert(w >= 0 && revw >= 0);
-  CV_Assert(i != j);
-
-  if (!edges.size())
-    edges.resize(2);
-
-  Edge fromI, toI;
-  fromI.dst = j;
-  fromI.next = vtcs[i].first;
-  fromI.weight = w;
-  vtcs[i].first = (int)edges.size();
-  edges.push_back(fromI);
-
-  toI.dst = i;
-  toI.next = vtcs[j].first;
-  toI.weight = revw;
-  vtcs[j].first = (int)edges.size();
-  edges.push_back(toI);
-}
-
-template <class TWeight>
-void GCGraph<TWeight>::addTermWeights(int i, TWeight sourceW, TWeight sinkW) {
-  CV_Assert(i >= 0 && i < (int)vtcs.size());
-
-  TWeight dw = vtcs[i].weight;
-  if (dw > 0)
-    sourceW += dw;
-  else
-    sinkW -= dw;
-  flow += (sourceW < sinkW) ? sourceW : sinkW;
-  vtcs[i].weight = sourceW - sinkW;
-}
-
-template <class TWeight> TWeight GCGraph<TWeight>::maxFlow() {
-  CV_Assert(!vtcs.empty());
-  CV_Assert(!edges.empty());
-  const int TERMINAL = -1, ORPHAN = -2;
-  Vtx stub, *nilNode = &stub, *first = nilNode, *last = nilNode;
-  int curr_ts = 0;
-  stub.next = nilNode;
-  Vtx *vtxPtr = &vtcs[0];
-  Edge *edgePtr = &edges[0];
-
-  std::vector<Vtx *> orphans;
-
-  // initialize the active queue and the graph vertices
-  for (int i = 0; i < (int)vtcs.size(); i++) {
-    Vtx *v = vtxPtr + i;
-    v->ts = 0;
-    if (v->weight != 0) {
-      last = last->next = v;
-      v->dist = 1;
-      v->parent = TERMINAL;
-      v->t = v->weight < 0;
-    } else
-      v->parent = 0;
-  }
-  first = first->next;
-  last->next = nilNode;
-  nilNode->next = 0;
-
-  // run the search-path -> augment-graph -> restore-trees loop
-  for (;;) {
-    Vtx *v, *u;
-    int e0 = -1, ei = 0, ej = 0;
-    TWeight minWeight, weight;
-    uchar vt;
-
-    // grow S & T search trees, find an edge connecting them
-    while (first != nilNode) {
-      v = first;
-      if (v->parent) {
-        vt = v->t;
-        for (ei = v->first; ei != 0; ei = edgePtr[ei].next) {
-          if (edgePtr[ei ^ vt].weight == 0)
-            continue;
-          u = vtxPtr + edgePtr[ei].dst;
-          if (!u->parent) {
-            u->t = vt;
-            u->parent = ei ^ 1;
-            u->ts = v->ts;
-            u->dist = v->dist + 1;
-            if (!u->next) {
-              u->next = nilNode;
-              last = last->next = u;
-            }
-            continue;
-          }
-
-          if (u->t != vt) {
-            e0 = ei ^ vt;
-            break;
-          }
-
-          if (u->dist > v->dist + 1 && u->ts <= v->ts) {
-            // reassign the parent
-            u->parent = ei ^ 1;
-            u->ts = v->ts;
-            u->dist = v->dist + 1;
-          }
-        }
-        if (e0 > 0)
-          break;
-      }
-      // exclude the vertex from the active list
-      first = first->next;
-      v->next = 0;
-    }
-
-    if (e0 <= 0)
-      break;
-
-    // find the minimum edge weight along the path
-    minWeight = edgePtr[e0].weight;
-    CV_Assert(minWeight > 0);
-    // k = 1: source tree, k = 0: destination tree
-    for (int k = 1; k >= 0; k--) {
-      for (v = vtxPtr + edgePtr[e0 ^ k].dst;; v = vtxPtr + edgePtr[ei].dst) {
-        if ((ei = v->parent) < 0)
-          break;
-        weight = edgePtr[ei ^ k].weight;
-        minWeight = MIN(minWeight, weight);
-        CV_Assert(minWeight > 0);
-      }
-      weight = fabs(v->weight);
-      minWeight = MIN(minWeight, weight);
-      CV_Assert(minWeight > 0);
-    }
-
-    // modify weights of the edges along the path and collect orphans
-    edgePtr[e0].weight -= minWeight;
-    edgePtr[e0 ^ 1].weight += minWeight;
-    flow += minWeight;
-
-    // k = 1: source tree, k = 0: destination tree
-    for (int k = 1; k >= 0; k--) {
-      for (v = vtxPtr + edgePtr[e0 ^ k].dst;; v = vtxPtr + edgePtr[ei].dst) {
-        if ((ei = v->parent) < 0)
-          break;
-        edgePtr[ei ^ (k ^ 1)].weight += minWeight;
-        if ((edgePtr[ei ^ k].weight -= minWeight) == 0) {
-          orphans.push_back(v);
-          v->parent = ORPHAN;
-        }
-      }
-
-      v->weight = v->weight + minWeight * (1 - k * 2);
-      if (v->weight == 0) {
-        orphans.push_back(v);
-        v->parent = ORPHAN;
-      }
-    }
-
-    // restore the search trees by finding new parents for the orphans
-    curr_ts++;
-    while (!orphans.empty()) {
-      Vtx *v2 = orphans.back();
-      orphans.pop_back();
-
-      int d, minDist = INT_MAX;
-      e0 = 0;
-      vt = v2->t;
-
-      for (ei = v2->first; ei != 0; ei = edgePtr[ei].next) {
-        if (edgePtr[ei ^ (vt ^ 1)].weight == 0)
-          continue;
-        u = vtxPtr + edgePtr[ei].dst;
-        if (u->t != vt || u->parent == 0)
-          continue;
-        // compute the distance to the tree root
-        for (d = 0;;) {
-          if (u->ts == curr_ts) {
-            d += u->dist;
-            break;
-          }
-          ej = u->parent;
-          d++;
-          if (ej < 0) {
-            if (ej == ORPHAN)
-              d = INT_MAX - 1;
-            else {
-              u->ts = curr_ts;
-              u->dist = 1;
-            }
-            break;
-          }
-          u = vtxPtr + edgePtr[ej].dst;
-        }
-
-        // update the distance
-        if (++d < INT_MAX) {
-          if (d < minDist) {
-            minDist = d;
-            e0 = ei;
-          }
-          for (u = vtxPtr + edgePtr[ei].dst; u->ts != curr_ts;
-               u = vtxPtr + edgePtr[u->parent].dst) {
-            u->ts = curr_ts;
-            u->dist = --d;
-          }
-        }
-      }
-
-      if ((v2->parent = e0) > 0) {
-        v2->ts = curr_ts;
-        v2->dist = minDist;
-        continue;
-      }
-
-      /* no parent is found */
-      v2->ts = 0;
-      for (ei = v2->first; ei != 0; ei = edgePtr[ei].next) {
-        u = vtxPtr + edgePtr[ei].dst;
-        ej = u->parent;
-        if (u->t != vt || !ej)
-          continue;
-        if (edgePtr[ei ^ (vt ^ 1)].weight && !u->next) {
-          u->next = nilNode;
-          last = last->next = u;
-        }
-        if (ej > 0 && vtxPtr + edgePtr[ej].dst == v2) {
-          orphans.push_back(u);
-          u->parent = ORPHAN;
-        }
-      }
-    }
-  }
-  return flow;
-}
-
-template <class TWeight> bool GCGraph<TWeight>::inSourceSegment(int i) {
-  CV_Assert(i >= 0 && i < (int)vtcs.size());
-  return vtcs[i].t == 0;
-}
-
-} // namespace detail
-} // namespace cv
-
-//! @endcond
-
-#endif // OPENCV_IMGPROC_DETAIL_GCGRAPH_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/imgproc/detail/legacy.hpp b/packages/react-native-executorch/third-party/include/opencv2/imgproc/detail/legacy.hpp
deleted file mode 100644
index 0252e6acfc..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/imgproc/detail/legacy.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html
-
-#ifndef OPENCV_IMGPROC_DETAIL_LEGACY_HPP
-#define OPENCV_IMGPROC_DETAIL_LEGACY_HPP
-
-#include "opencv2/imgproc.hpp"
-
-namespace cv {
-
-#ifdef __OPENCV_BUILD
-
-CV_EXPORTS void findContours_legacy(InputArray _image,
-                                    OutputArrayOfArrays _contours,
-                                    OutputArray _hierarchy, int mode,
-                                    int method, Point offset = Point());
-CV_EXPORTS void findContours_legacy(InputArray image,
-                                    OutputArrayOfArrays contours, int mode,
-                                    int method, Point offset = Point());
-
-CV_EXPORTS float EMD_legacy(InputArray _signature1, InputArray _signature2,
-                            int distType, InputArray _cost, float *lowerBound,
-                            OutputArray _flow);
-
-CV_EXPORTS float wrapperEMD_legacy(InputArray _signature1,
-                                   InputArray _signature2, int distType,
-                                   InputArray _cost, Ptr<float> lowerBound,
-                                   OutputArray _flow);
-
-#endif
-
-} // namespace cv
-
-#endif // OPENCV_IMGPROC_DETAIL_LEGACY_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/imgproc/hal/hal.hpp b/packages/react-native-executorch/third-party/include/opencv2/imgproc/hal/hal.hpp
deleted file mode 100644
index c92be32de6..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/imgproc/hal/hal.hpp
+++ /dev/null
@@ -1,246 +0,0 @@
-#ifndef CV_IMGPROC_HAL_HPP
-#define CV_IMGPROC_HAL_HPP
-
-#include "opencv2/core/cvdef.h"
-#include "opencv2/core/cvstd.hpp"
-#include "opencv2/core/hal/interface.h"
-#include "opencv2/core/utility.hpp"
-
-namespace cv {
-namespace hal {
-
-//! @addtogroup imgproc_hal_functions
-//! @{
-
-//---------------------------
-//! @cond IGNORED
-
-struct CV_EXPORTS Filter2D {
-  CV_DEPRECATED static Ptr<hal::Filter2D> create(uchar *, size_t, int, int, int,
-                                                 int, int, int, int, int,
-                                                 double, int, int, bool, bool);
-  virtual void apply(uchar *, size_t, uchar *, size_t, int, int, int, int, int,
-                     int) = 0;
-  virtual ~Filter2D() {}
-};
-
-struct CV_EXPORTS SepFilter2D {
-  CV_DEPRECATED static Ptr<hal::SepFilter2D>
-  create(int, int, int, uchar *, int, uchar *, int, int, int, double, int);
-  virtual void apply(uchar *, size_t, uchar *, size_t, int, int, int, int, int,
-                     int) = 0;
-  virtual ~SepFilter2D() {}
-};
-
-struct CV_EXPORTS Morph {
-  CV_DEPRECATED static Ptr<hal::Morph> create(int, int, int, int, int, int,
-                                              uchar *, size_t, int, int, int,
-                                              int, int, const double *, int,
-                                              bool, bool);
-  virtual void apply(uchar *, size_t, uchar *, size_t, int, int, int, int, int,
-                     int, int, int, int, int) = 0;
-  virtual ~Morph() {}
-};
-
-//! @endcond
-//---------------------------
-
-CV_EXPORTS void filter2D(int stype, int dtype, int kernel_type, uchar *src_data,
-                         size_t src_step, uchar *dst_data, size_t dst_step,
-                         int width, int height, int full_width, int full_height,
-                         int offset_x, int offset_y, uchar *kernel_data,
-                         size_t kernel_step, int kernel_width,
-                         int kernel_height, int anchor_x, int anchor_y,
-                         double delta, int borderType, bool isSubmatrix);
-
-CV_EXPORTS void sepFilter2D(int stype, int dtype, int ktype, uchar *src_data,
-                            size_t src_step, uchar *dst_data, size_t dst_step,
-                            int width, int height, int full_width,
-                            int full_height, int offset_x, int offset_y,
-                            uchar *kernelx_data, int kernelx_len,
-                            uchar *kernely_data, int kernely_len, int anchor_x,
-                            int anchor_y, double delta, int borderType);
-
-CV_EXPORTS void morph(int op, int src_type, int dst_type, uchar *src_data,
-                      size_t src_step, uchar *dst_data, size_t dst_step,
-                      int width, int height, int roi_width, int roi_height,
-                      int roi_x, int roi_y, int roi_width2, int roi_height2,
-                      int roi_x2, int roi_y2, int kernel_type,
-                      uchar *kernel_data, size_t kernel_step, int kernel_width,
-                      int kernel_height, int anchor_x, int anchor_y,
-                      int borderType, const double borderValue[4],
-                      int iterations, bool isSubmatrix);
-
-CV_EXPORTS void resize(int src_type, const uchar *src_data, size_t src_step,
-                       int src_width, int src_height, uchar *dst_data,
-                       size_t dst_step, int dst_width, int dst_height,
-                       double inv_scale_x, double inv_scale_y,
-                       int interpolation);
-
-CV_EXPORTS void warpAffine(int src_type, const uchar *src_data, size_t src_step,
-                           int src_width, int src_height, uchar *dst_data,
-                           size_t dst_step, int dst_width, int dst_height,
-                           const double M[6], int interpolation, int borderType,
-                           const double borderValue[4]);
-
-CV_EXPORTS void warpAffineBlocklineNN(int *adelta, int *bdelta, short *xy,
-                                      int X0, int Y0, int bw);
-
-CV_EXPORTS void warpAffineBlockline(int *adelta, int *bdelta, short *xy,
-                                    short *alpha, int X0, int Y0, int bw);
-
-CV_EXPORTS void warpPerspective(int src_type, const uchar *src_data,
-                                size_t src_step, int src_width, int src_height,
-                                uchar *dst_data, size_t dst_step, int dst_width,
-                                int dst_height, const double M[9],
-                                int interpolation, int borderType,
-                                const double borderValue[4]);
-
-CV_EXPORTS void warpPerspectiveBlocklineNN(const double *M, short *xy,
-                                           double X0, double Y0, double W0,
-                                           int bw);
-
-CV_EXPORTS void warpPerspectiveBlockline(const double *M, short *xy,
-                                         short *alpha, double X0, double Y0,
-                                         double W0, int bw);
-
-CV_EXPORTS void cvtBGRtoBGR(const uchar *src_data, size_t src_step,
-                            uchar *dst_data, size_t dst_step, int width,
-                            int height, int depth, int scn, int dcn,
-                            bool swapBlue);
-
-CV_EXPORTS void cvtBGRtoBGR5x5(const uchar *src_data, size_t src_step,
-                               uchar *dst_data, size_t dst_step, int width,
-                               int height, int scn, bool swapBlue,
-                               int greenBits);
-
-CV_EXPORTS void cvtBGR5x5toBGR(const uchar *src_data, size_t src_step,
-                               uchar *dst_data, size_t dst_step, int width,
-                               int height, int dcn, bool swapBlue,
-                               int greenBits);
-
-CV_EXPORTS void cvtBGRtoGray(const uchar *src_data, size_t src_step,
-                             uchar *dst_data, size_t dst_step, int width,
-                             int height, int depth, int scn, bool swapBlue);
-
-CV_EXPORTS void cvtGraytoBGR(const uchar *src_data, size_t src_step,
-                             uchar *dst_data, size_t dst_step, int width,
-                             int height, int depth, int dcn);
-
-CV_EXPORTS void cvtBGR5x5toGray(const uchar *src_data, size_t src_step,
-                                uchar *dst_data, size_t dst_step, int width,
-                                int height, int greenBits);
-
-CV_EXPORTS void cvtGraytoBGR5x5(const uchar *src_data, size_t src_step,
-                                uchar *dst_data, size_t dst_step, int width,
-                                int height, int greenBits);
-CV_EXPORTS void cvtBGRtoYUV(const uchar *src_data, size_t src_step,
-                            uchar *dst_data, size_t dst_step, int width,
-                            int height, int depth, int scn, bool swapBlue,
-                            bool isCbCr,
-                            AlgorithmHint hint = ALGO_HINT_DEFAULT);
-
-CV_EXPORTS void cvtYUVtoBGR(const uchar *src_data, size_t src_step,
-                            uchar *dst_data, size_t dst_step, int width,
-                            int height, int depth, int dcn, bool swapBlue,
-                            bool isCbCr,
-                            AlgorithmHint hint = ALGO_HINT_DEFAULT);
-
-CV_EXPORTS void cvtBGRtoXYZ(const uchar *src_data, size_t src_step,
-                            uchar *dst_data, size_t dst_step, int width,
-                            int height, int depth, int scn, bool swapBlue);
-
-CV_EXPORTS void cvtXYZtoBGR(const uchar *src_data, size_t src_step,
-                            uchar *dst_data, size_t dst_step, int width,
-                            int height, int depth, int dcn, bool swapBlue);
-
-CV_EXPORTS void cvtBGRtoHSV(const uchar *src_data, size_t src_step,
-                            uchar *dst_data, size_t dst_step, int width,
-                            int height, int depth, int scn, bool swapBlue,
-                            bool isFullRange, bool isHSV);
-
-CV_EXPORTS void cvtHSVtoBGR(const uchar *src_data, size_t src_step,
-                            uchar *dst_data, size_t dst_step, int width,
-                            int height, int depth, int dcn, bool swapBlue,
-                            bool isFullRange, bool isHSV);
-
-CV_EXPORTS void cvtBGRtoLab(const uchar *src_data, size_t src_step,
-                            uchar *dst_data, size_t dst_step, int width,
-                            int height, int depth, int scn, bool swapBlue,
-                            bool isLab, bool srgb);
-
-CV_EXPORTS void cvtLabtoBGR(const uchar *src_data, size_t src_step,
-                            uchar *dst_data, size_t dst_step, int width,
-                            int height, int depth, int dcn, bool swapBlue,
-                            bool isLab, bool srgb);
-
-CV_EXPORTS void cvtTwoPlaneYUVtoBGR(const uchar *src_data, size_t src_step,
-                                    uchar *dst_data, size_t dst_step,
-                                    int dst_width, int dst_height, int dcn,
-                                    bool swapBlue, int uIdx,
-                                    AlgorithmHint hint = ALGO_HINT_DEFAULT);
-
-//! Separate Y and UV planes
-CV_EXPORTS void cvtTwoPlaneYUVtoBGR(const uchar *y_data, const uchar *uv_data,
-                                    size_t src_step, uchar *dst_data,
-                                    size_t dst_step, int dst_width,
-                                    int dst_height, int dcn, bool swapBlue,
-                                    int uIdx,
-                                    AlgorithmHint hint = ALGO_HINT_DEFAULT);
-
-CV_EXPORTS void cvtTwoPlaneYUVtoBGR(const uchar *y_data, size_t y_step,
-                                    const uchar *uv_data, size_t uv_step,
-                                    uchar *dst_data, size_t dst_step,
-                                    int dst_width, int dst_height, int dcn,
-                                    bool swapBlue, int uIdx,
-                                    AlgorithmHint hint = ALGO_HINT_DEFAULT);
-
-CV_EXPORTS void cvtThreePlaneYUVtoBGR(const uchar *src_data, size_t src_step,
-                                      uchar *dst_data, size_t dst_step,
-                                      int dst_width, int dst_height, int dcn,
-                                      bool swapBlue, int uIdx,
-                                      AlgorithmHint hint = ALGO_HINT_DEFAULT);
-
-CV_EXPORTS void cvtBGRtoThreePlaneYUV(const uchar *src_data, size_t src_step,
-                                      uchar *dst_data, size_t dst_step,
-                                      int width, int height, int scn,
-                                      bool swapBlue, int uIdx,
-                                      AlgorithmHint hint = ALGO_HINT_DEFAULT);
-
-//! Separate Y and UV planes
-CV_EXPORTS void cvtBGRtoTwoPlaneYUV(const uchar *src_data, size_t src_step,
-                                    uchar *y_data, uchar *uv_data,
-                                    size_t dst_step, int width, int height,
-                                    int scn, bool swapBlue, int uIdx);
-
-CV_EXPORTS void cvtOnePlaneYUVtoBGR(const uchar *src_data, size_t src_step,
-                                    uchar *dst_data, size_t dst_step, int width,
-                                    int height, int dcn, bool swapBlue,
-                                    int uIdx, int ycn,
-                                    AlgorithmHint hint = ALGO_HINT_DEFAULT);
-
-CV_EXPORTS void cvtOnePlaneBGRtoYUV(const uchar *src_data, size_t src_step,
-                                    uchar *dst_data, size_t dst_step, int width,
-                                    int height, int scn, bool swapBlue,
-                                    int uIdx, int ycn,
-                                    AlgorithmHint hint = ALGO_HINT_DEFAULT);
-
-CV_EXPORTS void cvtRGBAtoMultipliedRGBA(const uchar *src_data, size_t src_step,
-                                        uchar *dst_data, size_t dst_step,
-                                        int width, int height);
-
-CV_EXPORTS void cvtMultipliedRGBAtoRGBA(const uchar *src_data, size_t src_step,
-                                        uchar *dst_data, size_t dst_step,
-                                        int width, int height);
-
-CV_EXPORTS void integral(int depth, int sdepth, int sqdepth, const uchar *src,
-                         size_t srcstep, uchar *sum, size_t sumstep,
-                         uchar *sqsum, size_t sqsumstep, uchar *tilted,
-                         size_t tstep, int width, int height, int cn);
-
-//! @}
-
-} // namespace hal
-} // namespace cv
-
-#endif // CV_IMGPROC_HAL_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/imgproc/hal/interface.h b/packages/react-native-executorch/third-party/include/opencv2/imgproc/hal/interface.h
deleted file mode 100644
index 35bf44322c..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/imgproc/hal/interface.h
+++ /dev/null
@@ -1,52 +0,0 @@
-#ifndef OPENCV_IMGPROC_HAL_INTERFACE_H
-#define OPENCV_IMGPROC_HAL_INTERFACE_H
-
-//! @addtogroup imgproc_hal_interface
-//! @{
-
-//! @name Interpolation modes
-//! @sa cv::InterpolationFlags
-//! @{
-#define CV_HAL_INTER_NEAREST 0
-#define CV_HAL_INTER_LINEAR 1
-#define CV_HAL_INTER_CUBIC 2
-#define CV_HAL_INTER_AREA 3
-#define CV_HAL_INTER_LANCZOS4 4
-#define CV_HAL_INTER_LINEAR_EXACT 5
-#define CV_HAL_INTER_NEAREST_EXACT 6
-#define CV_HAL_INTER_MAX 7
-#define CV_HAL_WARP_FILL_OUTLIERS 8
-#define CV_HAL_WARP_INVERSE_MAP 16
-#define CV_HAL_WARP_RELATIVE_MAP 32
-//! @}
-
-//! @name Morphology operations
-//! @sa cv::MorphTypes
-//! @{
-#define CV_HAL_MORPH_ERODE 0
-#define CV_HAL_MORPH_DILATE 1
-//! @}
-
-//! @name Threshold types
-//! @sa cv::ThresholdTypes
-//! @{
-#define CV_HAL_THRESH_BINARY 0
-#define CV_HAL_THRESH_BINARY_INV 1
-#define CV_HAL_THRESH_TRUNC 2
-#define CV_HAL_THRESH_TOZERO 3
-#define CV_HAL_THRESH_TOZERO_INV 4
-#define CV_HAL_THRESH_MASK 7
-#define CV_HAL_THRESH_OTSU 8
-#define CV_HAL_THRESH_TRIANGLE 16
-//! @}
-
-//! @name Adaptive threshold algorithm
-//! @sa cv::AdaptiveThresholdTypes
-//! @{
-#define CV_HAL_ADAPTIVE_THRESH_MEAN_C 0
-#define CV_HAL_ADAPTIVE_THRESH_GAUSSIAN_C 1
-//! @}
-
-//! @}
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/imgproc/imgproc.hpp b/packages/react-native-executorch/third-party/include/opencv2/imgproc/imgproc.hpp
deleted file mode 100644
index f90f8d2246..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/imgproc/imgproc.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                           License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifdef __OPENCV_BUILD
-#error this is a compatibility header which should not be used inside the OpenCV library
-#endif
-
-#include "opencv2/imgproc.hpp"
diff --git a/packages/react-native-executorch/third-party/include/opencv2/imgproc/imgproc_c.h b/packages/react-native-executorch/third-party/include/opencv2/imgproc/imgproc_c.h
deleted file mode 100644
index 02ba3f7ff8..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/imgproc/imgproc_c.h
+++ /dev/null
@@ -1,1261 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                           License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_IMGPROC_IMGPROC_C_H
-#define OPENCV_IMGPROC_IMGPROC_C_H
-
-#include "opencv2/imgproc/types_c.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** @addtogroup imgproc_c
-@{
-*/
-
-/*********************** Background statistics accumulation
- * *****************************/
-
-/** @brief Adds image to accumulator
-@see cv::accumulate
-*/
-CVAPI(void)
-cvAcc(const CvArr *image, CvArr *sum, const CvArr *mask CV_DEFAULT(NULL));
-
-/** @brief Adds squared image to accumulator
-@see cv::accumulateSquare
-*/
-CVAPI(void)
-cvSquareAcc(const CvArr *image, CvArr *sqsum,
-            const CvArr *mask CV_DEFAULT(NULL));
-
-/** @brief Adds a product of two images to accumulator
-@see cv::accumulateProduct
-*/
-CVAPI(void)
-cvMultiplyAcc(const CvArr *image1, const CvArr *image2, CvArr *acc,
-              const CvArr *mask CV_DEFAULT(NULL));
-
-/** @brief Adds image to accumulator with weights: acc = acc*(1-alpha) +
-image*alpha
-@see cv::accumulateWeighted
-*/
-CVAPI(void)
-cvRunningAvg(const CvArr *image, CvArr *acc, double alpha,
-             const CvArr *mask CV_DEFAULT(NULL));
-
-/****************************************************************************************\
-*                                    Image Processing *
-\****************************************************************************************/
-
-/** Copies source 2D array inside of the larger destination array and
-   makes a border of the specified type (IPL_BORDER_*) around the copied area.
- */
-CVAPI(void)
-cvCopyMakeBorder(const CvArr *src, CvArr *dst, CvPoint offset, int bordertype,
-                 CvScalar value CV_DEFAULT(cvScalarAll(0)));
-
-/** @brief Smooths the image in one of several ways.
-
-@param src The source image
-@param dst The destination image
-@param smoothtype Type of the smoothing, see SmoothMethod_c
-@param size1 The first parameter of the smoothing operation, the aperture width.
-Must be a positive odd number (1, 3, 5, ...)
-@param size2 The second parameter of the smoothing operation, the aperture
-height. Ignored by CV_MEDIAN and CV_BILATERAL methods. In the case of simple
-scaled/non-scaled and Gaussian blur if size2 is zero, it is set to size1.
-Otherwise it must be a positive odd number.
-@param sigma1 In the case of a Gaussian parameter this parameter may specify
-Gaussian \f$\sigma\f$ (standard deviation). If it is zero, it is calculated from
-the kernel size:
-\f[\sigma  = 0.3 (n/2 - 1) + 0.8  \quad   \text{where}   \quad  n=
-\begin{array}{l l} \mbox{\texttt{size1} for horizontal kernel}
-\\ \mbox{\texttt{size2} for vertical kernel} \end{array}\f] Using standard sigma
-for small kernels ( \f$3\times 3\f$ to \f$7\times 7\f$ ) gives better speed. If
-sigma1 is not zero, while size1 and size2 are zeros, the kernel size is
-calculated from the sigma (to provide accurate enough operation).
-@param sigma2 additional parameter for bilateral filtering
-
-@see cv::GaussianBlur, cv::blur, cv::medianBlur, cv::bilateralFilter.
- */
-CVAPI(void)
-cvSmooth(const CvArr *src, CvArr *dst, int smoothtype CV_DEFAULT(CV_GAUSSIAN),
-         int size1 CV_DEFAULT(3), int size2 CV_DEFAULT(0),
-         double sigma1 CV_DEFAULT(0), double sigma2 CV_DEFAULT(0));
-
-/** @brief Convolves an image with the kernel.
-
-@param src input image.
-@param dst output image of the same size and the same number of channels as src.
-@param kernel convolution kernel (or rather a correlation kernel), a
-single-channel floating point matrix; if you want to apply different kernels to
-different channels, split the image into separate color planes using split and
-process them individually.
-@param anchor anchor of the kernel that indicates the relative position of a
-filtered point within the kernel; the anchor should lie within the kernel;
-default value (-1,-1) means that the anchor is at the kernel center.
-
-@see cv::filter2D
- */
-CVAPI(void)
-cvFilter2D(const CvArr *src, CvArr *dst, const CvMat *kernel,
-           CvPoint anchor CV_DEFAULT(cvPoint(-1, -1)));
-
-/** @brief Finds integral image: SUM(X,Y) = sum(x<X,y<Y)I(x,y)
-@see cv::integral
-*/
-CVAPI(void)
-cvIntegral(const CvArr *image, CvArr *sum, CvArr *sqsum CV_DEFAULT(NULL),
-           CvArr *tilted_sum CV_DEFAULT(NULL));
-
-/** @brief Smoothes the input image with gaussian kernel and then down-samples
-   it.
-
-   dst_width = floor(src_width/2)[+1],
-   dst_height = floor(src_height/2)[+1]
-   @see cv::pyrDown
-*/
-CVAPI(void)
-cvPyrDown(const CvArr *src, CvArr *dst, int filter CV_DEFAULT(CV_GAUSSIAN_5x5));
-
-/** @brief Up-samples image and smoothes the result with gaussian kernel.
-
-   dst_width = src_width*2,
-   dst_height = src_height*2
-   @see cv::pyrUp
-*/
-CVAPI(void)
-cvPyrUp(const CvArr *src, CvArr *dst, int filter CV_DEFAULT(CV_GAUSSIAN_5x5));
-
-/** @brief Builds pyramid for an image
-@see buildPyramid
-*/
-CVAPI(CvMat **)
-cvCreatePyramid(const CvArr *img, int extra_layers, double rate,
-                const CvSize *layer_sizes CV_DEFAULT(0),
-                CvArr *bufarr CV_DEFAULT(0), int calc CV_DEFAULT(1),
-                int filter CV_DEFAULT(CV_GAUSSIAN_5x5));
-
-/** @brief Releases pyramid */
-CVAPI(void) cvReleasePyramid(CvMat ***pyramid, int extra_layers);
-
-/** @brief Filters image using meanshift algorithm
-@see cv::pyrMeanShiftFiltering
-*/
-CVAPI(void)
-cvPyrMeanShiftFiltering(const CvArr *src, CvArr *dst, double sp, double sr,
-                        int max_level CV_DEFAULT(1),
-                        CvTermCriteria termcrit CV_DEFAULT(cvTermCriteria(
-                            CV_TERMCRIT_ITER + CV_TERMCRIT_EPS, 5, 1)));
-
-/** @brief Segments image using seed "markers"
-@see cv::watershed
-*/
-CVAPI(void) cvWatershed(const CvArr *image, CvArr *markers);
-
-/** @brief Calculates an image derivative using generalized Sobel
-
-   (aperture_size = 1,3,5,7) or Scharr (aperture_size = -1) operator.
-   Scharr can be used only for the first dx or dy derivative
-@see cv::Sobel
-*/
-CVAPI(void)
-cvSobel(const CvArr *src, CvArr *dst, int xorder, int yorder,
-        int aperture_size CV_DEFAULT(3));
-
-/** @brief Calculates the image Laplacian: (d2/dx + d2/dy)I
-@see cv::Laplacian
-*/
-CVAPI(void)
-cvLaplace(const CvArr *src, CvArr *dst, int aperture_size CV_DEFAULT(3));
-
-/** @brief Converts input array pixels from one color space to another
-@see cv::cvtColor
-*/
-CVAPI(void) cvCvtColor(const CvArr *src, CvArr *dst, int code);
-
-/** @brief Resizes image (input array is resized to fit the destination array)
-@see cv::resize
-*/
-CVAPI(void)
-cvResize(const CvArr *src, CvArr *dst,
-         int interpolation CV_DEFAULT(CV_INTER_LINEAR));
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 5054)
-#endif
-/** @brief Warps image with affine transform
-@note ::cvGetQuadrangleSubPix is similar to ::cvWarpAffine, but the outliers are
-extrapolated using replication border mode.
-@see cv::warpAffine
-*/
-CVAPI(void)
-cvWarpAffine(const CvArr *src, CvArr *dst, const CvMat *map_matrix,
-             int flags CV_DEFAULT(+CV_INTER_LINEAR + CV_WARP_FILL_OUTLIERS),
-             CvScalar fillval CV_DEFAULT(cvScalarAll(0)));
-
-/** @brief Computes affine transform matrix for mapping src[i] to dst[i]
-(i=0,1,2)
-@see cv::getAffineTransform
-*/
-CVAPI(CvMat *)
-cvGetAffineTransform(const CvPoint2D32f *src, const CvPoint2D32f *dst,
-                     CvMat *map_matrix);
-
-/** @brief Computes rotation_matrix matrix
-@see cv::getRotationMatrix2D
-*/
-CVAPI(CvMat *)
-cv2DRotationMatrix(CvPoint2D32f center, double angle, double scale,
-                   CvMat *map_matrix);
-
-/** @brief Warps image with perspective (projective) transform
-@see cv::warpPerspective
-*/
-CVAPI(void)
-cvWarpPerspective(const CvArr *src, CvArr *dst, const CvMat *map_matrix,
-                  int flags CV_DEFAULT(+CV_INTER_LINEAR +
-                                       CV_WARP_FILL_OUTLIERS),
-                  CvScalar fillval CV_DEFAULT(cvScalarAll(0)));
-
-/** @brief Computes perspective transform matrix for mapping src[i] to dst[i]
-(i=0,1,2,3)
-@see cv::getPerspectiveTransform
-*/
-CVAPI(CvMat *)
-cvGetPerspectiveTransform(const CvPoint2D32f *src, const CvPoint2D32f *dst,
-                          CvMat *map_matrix);
-
-/** @brief Performs generic geometric transformation using the specified
-coordinate maps
-@see cv::remap
-*/
-CVAPI(void)
-cvRemap(const CvArr *src, CvArr *dst, const CvArr *mapx, const CvArr *mapy,
-        int flags CV_DEFAULT(+CV_INTER_LINEAR + CV_WARP_FILL_OUTLIERS),
-        CvScalar fillval CV_DEFAULT(cvScalarAll(0)));
-
-/** @brief Converts mapx & mapy from floating-point to integer formats for
-cvRemap
-@see cv::convertMaps
-*/
-CVAPI(void)
-cvConvertMaps(const CvArr *mapx, const CvArr *mapy, CvArr *mapxy,
-              CvArr *mapalpha);
-
-/** @brief Performs forward or inverse log-polar image transform
-@see cv::warpPolar
-*/
-CVAPI(void)
-cvLogPolar(const CvArr *src, CvArr *dst, CvPoint2D32f center, double M,
-           int flags CV_DEFAULT(+CV_INTER_LINEAR + CV_WARP_FILL_OUTLIERS));
-
-/** Performs forward or inverse linear-polar image transform
-@see cv::warpPolar
-*/
-CVAPI(void)
-cvLinearPolar(const CvArr *src, CvArr *dst, CvPoint2D32f center,
-              double maxRadius,
-              int flags CV_DEFAULT(+CV_INTER_LINEAR + CV_WARP_FILL_OUTLIERS));
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-/** @brief Returns a structuring element of the specified size and shape for
-morphological operations.
-
-@note the created structuring element IplConvKernel\* element must be released
-in the end using `cvReleaseStructuringElement(&element)`.
-
-@param cols Width of the structuring element
-@param rows Height of the structuring element
-@param anchor_x x-coordinate of the anchor
-@param anchor_y y-coordinate of the anchor
-@param shape element shape that could be one of the cv::MorphShapes_c
-@param values integer array of cols*rows elements that specifies the custom
-shape of the structuring element, when shape=CV_SHAPE_CUSTOM.
-
-@see cv::getStructuringElement
- */
-CVAPI(IplConvKernel *)
-cvCreateStructuringElementEx(int cols, int rows, int anchor_x, int anchor_y,
-                             int shape, int *values CV_DEFAULT(NULL));
-
-/** @brief releases structuring element
-@see cvCreateStructuringElementEx
-*/
-CVAPI(void) cvReleaseStructuringElement(IplConvKernel **element);
-
-/** @brief erodes input image (applies minimum filter) one or more times.
-   If element pointer is NULL, 3x3 rectangular element is used
-@see cv::erode
-*/
-CVAPI(void)
-cvErode(const CvArr *src, CvArr *dst, IplConvKernel *element CV_DEFAULT(NULL),
-        int iterations CV_DEFAULT(1));
-
-/** @brief dilates input image (applies maximum filter) one or more times.
-
-   If element pointer is NULL, 3x3 rectangular element is used
-@see cv::dilate
-*/
-CVAPI(void)
-cvDilate(const CvArr *src, CvArr *dst, IplConvKernel *element CV_DEFAULT(NULL),
-         int iterations CV_DEFAULT(1));
-
-/** @brief Performs complex morphological transformation
-@see cv::morphologyEx
-*/
-CVAPI(void)
-cvMorphologyEx(const CvArr *src, CvArr *dst, CvArr *temp,
-               IplConvKernel *element, int operation,
-               int iterations CV_DEFAULT(1));
-
-/** @brief Calculates all spatial and central moments up to the 3rd order
-@see cv::moments
-*/
-CVAPI(void)
-cvMoments(const CvArr *arr, CvMoments *moments, int binary CV_DEFAULT(0));
-
-/** @brief Retrieve spatial moments */
-CVAPI(double) cvGetSpatialMoment(CvMoments *moments, int x_order, int y_order);
-/** @brief Retrieve central moments */
-CVAPI(double) cvGetCentralMoment(CvMoments *moments, int x_order, int y_order);
-/** @brief Retrieve normalized central moments */
-CVAPI(double)
-cvGetNormalizedCentralMoment(CvMoments *moments, int x_order, int y_order);
-
-/** @brief Calculates 7 Hu's invariants from precalculated spatial and central
-moments
-@see cv::HuMoments
-*/
-CVAPI(void) cvGetHuMoments(CvMoments *moments, CvHuMoments *hu_moments);
-
-/*********************************** data sampling
- * **************************************/
-
-/** @brief Fetches pixels that belong to the specified line segment and stores
-them to the buffer.
-
-   Returns the number of retrieved points.
-@see cv::LineSegmentDetector
-*/
-CVAPI(int)
-cvSampleLine(const CvArr *image, CvPoint pt1, CvPoint pt2, void *buffer,
-             int connectivity CV_DEFAULT(8));
-
-/** @brief Retrieves the rectangular image region with specified center from the
-input array.
-
- dst(x,y) <- src(x + center.x - dst_width/2, y + center.y - dst_height/2).
- Values of pixels with fractional coordinates are retrieved using bilinear
-interpolation
-@see cv::getRectSubPix
-*/
-CVAPI(void) cvGetRectSubPix(const CvArr *src, CvArr *dst, CvPoint2D32f center);
-
-/** @brief Retrieves quadrangle from the input array.
-
-    matrixarr = ( a11  a12 | b1 )   dst(x,y) <- src(A[x y]' + b)
-                ( a21  a22 | b2 )   (bilinear interpolation is used to retrieve
-pixels with fractional coordinates)
-@see cvWarpAffine
-*/
-CVAPI(void)
-cvGetQuadrangleSubPix(const CvArr *src, CvArr *dst, const CvMat *map_matrix);
-
-/** @brief Measures similarity between template and overlapped windows in the
-source image and fills the resultant image with the measurements
-@see cv::matchTemplate
-*/
-CVAPI(void)
-cvMatchTemplate(const CvArr *image, const CvArr *templ, CvArr *result,
-                int method);
-
-/** @brief Computes earth mover distance between
-   two weighted point sets (called signatures)
-@see cv::EMD
-*/
-CVAPI(float)
-cvCalcEMD2(const CvArr *signature1, const CvArr *signature2, int distance_type,
-           CvDistanceFunction distance_func CV_DEFAULT(NULL),
-           const CvArr *cost_matrix CV_DEFAULT(NULL),
-           CvArr *flow CV_DEFAULT(NULL), float *lower_bound CV_DEFAULT(NULL),
-           void *userdata CV_DEFAULT(NULL));
-
-/****************************************************************************************\
-*                              Contours retrieving *
-\****************************************************************************************/
-
-/** @brief Retrieves outer and optionally inner boundaries of white (non-zero)
-connected components in the black (zero) background
-@see cv::findContours, cvStartFindContours, cvFindNextContour,
-cvSubstituteContour, cvEndFindContours
-*/
-CVAPI(int)
-cvFindContours(CvArr *image, CvMemStorage *storage, CvSeq **first_contour,
-               int header_size CV_DEFAULT(sizeof(CvContour)),
-               int mode CV_DEFAULT(CV_RETR_LIST),
-               int method CV_DEFAULT(CV_CHAIN_APPROX_SIMPLE),
-               CvPoint offset CV_DEFAULT(cvPoint(0, 0)));
-
-/** @brief Initializes contour retrieving process.
-
-   Calls cvStartFindContours.
-   Calls cvFindNextContour until null pointer is returned
-   or some other condition becomes true.
-   Calls cvEndFindContours at the end.
-@see cvFindContours
-*/
-CVAPI(CvContourScanner)
-cvStartFindContours(CvArr *image, CvMemStorage *storage,
-                    int header_size CV_DEFAULT(sizeof(CvContour)),
-                    int mode CV_DEFAULT(CV_RETR_LIST),
-                    int method CV_DEFAULT(CV_CHAIN_APPROX_SIMPLE),
-                    CvPoint offset CV_DEFAULT(cvPoint(0, 0)));
-
-/** @brief Retrieves next contour
-@see cvFindContours
-*/
-CVAPI(CvSeq *) cvFindNextContour(CvContourScanner scanner);
-
-/** @brief Substitutes the last retrieved contour with the new one
-
-   (if the substitutor is null, the last retrieved contour is removed from the
-tree)
-@see cvFindContours
-*/
-CVAPI(void) cvSubstituteContour(CvContourScanner scanner, CvSeq *new_contour);
-
-/** @brief Releases contour scanner and returns pointer to the first outer
-contour
-@see cvFindContours
-*/
-CVAPI(CvSeq *) cvEndFindContours(CvContourScanner *scanner);
-
-/** @brief Approximates Freeman chain(s) with a polygonal curve.
-
-This is a standalone contour approximation routine, not represented in the new
-interface. When cvFindContours retrieves contours as Freeman chains, it calls
-the function to get approximated contours, represented as polygons.
-
-@param src_seq Pointer to the approximated Freeman chain that can refer to other
-chains.
-@param storage Storage location for the resulting polylines.
-@param method Approximation method (see the description of the function
-:ocvFindContours ).
-@param parameter Method parameter (not used now).
-@param minimal_perimeter Approximates only those contours whose perimeters are
-not less than minimal_perimeter . Other chains are removed from the resulting
-structure.
-@param recursive Recursion flag. If it is non-zero, the function approximates
-all chains that can be obtained from chain by using the h_next or v_next links.
-Otherwise, the single input chain is approximated.
-@see cvStartReadChainPoints, cvReadChainPoint
- */
-CVAPI(CvSeq *)
-cvApproxChains(CvSeq *src_seq, CvMemStorage *storage,
-               int method CV_DEFAULT(CV_CHAIN_APPROX_SIMPLE),
-               double parameter CV_DEFAULT(0),
-               int minimal_perimeter CV_DEFAULT(0),
-               int recursive CV_DEFAULT(0));
-
-/** @brief Initializes Freeman chain reader.
-
-   The reader is used to iteratively get coordinates of all the chain points.
-   If the Freeman codes should be read as is, a simple sequence reader should be
-used
-@see cvApproxChains
-*/
-CVAPI(void) cvStartReadChainPoints(CvChain *chain, CvChainPtReader *reader);
-
-/** @brief Retrieves the next chain point
-@see cvApproxChains
-*/
-CVAPI(CvPoint) cvReadChainPoint(CvChainPtReader *reader);
-
-/****************************************************************************************\
-*                            Contour Processing and Shape Analysis *
-\****************************************************************************************/
-
-/** @brief Approximates a single polygonal curve (contour) or
-   a tree of polygonal curves (contours)
-@see cv::approxPolyDP
-*/
-CVAPI(CvSeq *)
-cvApproxPoly(const void *src_seq, int header_size, CvMemStorage *storage,
-             int method, double eps, int recursive CV_DEFAULT(0));
-
-/** @brief Calculates perimeter of a contour or length of a part of contour
-@see cv::arcLength
-*/
-CVAPI(double)
-cvArcLength(const void *curve, CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ),
-            int is_closed CV_DEFAULT(-1));
-
-/** same as cvArcLength for closed contour
- */
-CV_INLINE double cvContourPerimeter(const void *contour) {
-  return cvArcLength(contour, CV_WHOLE_SEQ, 1);
-}
-
-/** @brief Calculates contour bounding rectangle (update=1) or
-   just retrieves pre-calculated rectangle (update=0)
-@see cv::boundingRect
-*/
-CVAPI(CvRect) cvBoundingRect(CvArr *points, int update CV_DEFAULT(0));
-
-/** @brief Calculates area of a contour or contour segment
-@see cv::contourArea
-*/
-CVAPI(double)
-cvContourArea(const CvArr *contour, CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ),
-              int oriented CV_DEFAULT(0));
-
-/** @brief Finds minimum area rotated rectangle bounding a set of points
-@see cv::minAreaRect
-*/
-CVAPI(CvBox2D)
-cvMinAreaRect2(const CvArr *points, CvMemStorage *storage CV_DEFAULT(NULL));
-
-/** @brief Finds minimum enclosing circle for a set of points
-@see cv::minEnclosingCircle
-*/
-CVAPI(int)
-cvMinEnclosingCircle(const CvArr *points, CvPoint2D32f *center, float *radius);
-
-/** @brief Compares two contours by matching their moments
-@see cv::matchShapes
-*/
-CVAPI(double)
-cvMatchShapes(const void *object1, const void *object2, int method,
-              double parameter CV_DEFAULT(0));
-
-/** @brief Calculates exact convex hull of 2d point set
-@see cv::convexHull
-*/
-CVAPI(CvSeq *)
-cvConvexHull2(const CvArr *input, void *hull_storage CV_DEFAULT(NULL),
-              int orientation CV_DEFAULT(CV_CLOCKWISE),
-              int return_points CV_DEFAULT(0));
-
-/** @brief Checks whether the contour is convex or not (returns 1 if convex, 0
-if not)
-@see cv::isContourConvex
-*/
-CVAPI(int) cvCheckContourConvexity(const CvArr *contour);
-
-/** @brief Finds convexity defects for the contour
-@see cv::convexityDefects
-*/
-CVAPI(CvSeq *)
-cvConvexityDefects(const CvArr *contour, const CvArr *convexhull,
-                   CvMemStorage *storage CV_DEFAULT(NULL));
-
-/** @brief Fits ellipse into a set of 2d points
-@see cv::fitEllipse
-*/
-CVAPI(CvBox2D) cvFitEllipse2(const CvArr *points);
-
-/** @brief Finds minimum rectangle containing two given rectangles */
-CVAPI(CvRect) cvMaxRect(const CvRect *rect1, const CvRect *rect2);
-
-/** @brief Finds coordinates of the box vertices */
-CVAPI(void) cvBoxPoints(CvBox2D box, CvPoint2D32f pt[4]);
-
-/** @brief Initializes sequence header for a matrix (column or row vector) of
-   points
-
-   a wrapper for cvMakeSeqHeaderForArray (it does not initialize bounding
-   rectangle!!!) */
-CVAPI(CvSeq *)
-cvPointSeqFromMat(int seq_kind, const CvArr *mat, CvContour *contour_header,
-                  CvSeqBlock *block);
-
-/** @brief Checks whether the point is inside polygon, outside, on an edge (at a
-vertex).
-
-   Returns positive, negative or zero value, correspondingly.
-   Optionally, measures a signed distance between
-   the point and the nearest polygon edge (measure_dist=1)
-@see cv::pointPolygonTest
-*/
-CVAPI(double)
-cvPointPolygonTest(const CvArr *contour, CvPoint2D32f pt, int measure_dist);
-
-/****************************************************************************************\
-*                                  Histogram functions *
-\****************************************************************************************/
-
-/** @brief Creates a histogram.
-
-The function creates a histogram of the specified size and returns a pointer to
-the created histogram. If the array ranges is 0, the histogram bin ranges must
-be specified later via the function cvSetHistBinRanges. Though cvCalcHist and
-cvCalcBackProject may process 8-bit images without setting bin ranges, they
-assume they are equally spaced in 0 to 255 bins.
-
-@param dims Number of histogram dimensions.
-@param sizes Array of the histogram dimension sizes.
-@param type Histogram representation format. CV_HIST_ARRAY means that the
-histogram data is represented as a multi-dimensional dense array CvMatND.
-CV_HIST_SPARSE means that histogram data is represented as a multi-dimensional
-sparse array CvSparseMat.
-@param ranges Array of ranges for the histogram bins. Its meaning depends on the
-uniform parameter value. The ranges are used when the histogram is calculated or
-backprojected to determine which histogram bin corresponds to which value/tuple
-of values from the input image(s).
-@param uniform Uniformity flag. If not zero, the histogram has evenly spaced
-bins and for every
-\f$0<=i<cDims\f$ ranges[i] is an array of two numbers: lower and upper
-boundaries for the i-th histogram dimension. The whole range [lower,upper] is
-then split into dims[i] equal parts to determine the i-th input tuple value
-ranges for every histogram bin. And if uniform=0 , then the i-th element of the
-ranges array contains dims[i]+1 elements: \f$\texttt{lower}_0,
-\texttt{upper}_0, \texttt{lower}_1, \texttt{upper}_1 = \texttt{lower}_2,
-...
-\texttt{upper}_{dims[i]-1}\f$ where \f$\texttt{lower}_j\f$ and
-\f$\texttt{upper}_j\f$ are lower and upper boundaries of the i-th input tuple
-value for the j-th bin, respectively. In either case, the input values that are
-beyond the specified range for a histogram bin are not counted by cvCalcHist and
-filled with 0 by cvCalcBackProject.
- */
-CVAPI(CvHistogram *)
-cvCreateHist(int dims, int *sizes, int type, float **ranges CV_DEFAULT(NULL),
-             int uniform CV_DEFAULT(1));
-
-/** @brief Sets the bounds of the histogram bins.
-
-This is a standalone function for setting bin ranges in the histogram. For a
-more detailed description of the parameters ranges and uniform, see the
-:ocvCalcHist function that can initialize the ranges as well. Ranges for the
-histogram bins must be set before the histogram is calculated or the backproject
-of the histogram is calculated.
-
-@param hist Histogram.
-@param ranges Array of bin ranges arrays. See :ocvCreateHist for details.
-@param uniform Uniformity flag. See :ocvCreateHist for details.
- */
-CVAPI(void)
-cvSetHistBinRanges(CvHistogram *hist, float **ranges,
-                   int uniform CV_DEFAULT(1));
-
-/** @brief Makes a histogram out of an array.
-
-The function initializes the histogram, whose header and bins are allocated by
-the user. cvReleaseHist does not need to be called afterwards. Only dense
-histograms can be initialized this way. The function returns hist.
-
-@param dims Number of the histogram dimensions.
-@param sizes Array of the histogram dimension sizes.
-@param hist Histogram header initialized by the function.
-@param data Array used to store histogram bins.
-@param ranges Histogram bin ranges. See cvCreateHist for details.
-@param uniform Uniformity flag. See cvCreateHist for details.
- */
-CVAPI(CvHistogram *)
-cvMakeHistHeaderForArray(int dims, int *sizes, CvHistogram *hist, float *data,
-                         float **ranges CV_DEFAULT(NULL),
-                         int uniform CV_DEFAULT(1));
-
-/** @brief Releases the histogram.
-
-The function releases the histogram (header and the data). The pointer to the
-histogram is cleared by the function. If \*hist pointer is already NULL, the
-function does nothing.
-
-@param hist Double pointer to the released histogram.
- */
-CVAPI(void) cvReleaseHist(CvHistogram **hist);
-
-/** @brief Clears the histogram.
-
-The function sets all of the histogram bins to 0 in case of a dense histogram
-and removes all histogram bins in case of a sparse array.
-
-@param hist Histogram.
- */
-CVAPI(void) cvClearHist(CvHistogram *hist);
-
-/** @brief Finds the minimum and maximum histogram bins.
-
-The function finds the minimum and maximum histogram bins and their positions.
-All of output arguments are optional. Among several extremas with the same value
-the ones with the minimum index (in the lexicographical order) are returned. In
-case of several maximums or minimums, the earliest in the lexicographical order
-(extrema locations) is returned.
-
-@param hist Histogram.
-@param min_value Pointer to the minimum value of the histogram.
-@param max_value Pointer to the maximum value of the histogram.
-@param min_idx Pointer to the array of coordinates for the minimum.
-@param max_idx Pointer to the array of coordinates for the maximum.
- */
-CVAPI(void)
-cvGetMinMaxHistValue(const CvHistogram *hist, float *min_value,
-                     float *max_value, int *min_idx CV_DEFAULT(NULL),
-                     int *max_idx CV_DEFAULT(NULL));
-
-/** @brief Normalizes the histogram.
-
-The function normalizes the histogram bins by scaling them so that the sum of
-the bins becomes equal to factor.
-
-@param hist Pointer to the histogram.
-@param factor Normalization factor.
- */
-CVAPI(void) cvNormalizeHist(CvHistogram *hist, double factor);
-
-/** @brief Thresholds the histogram.
-
-The function clears histogram bins that are below the specified threshold.
-
-@param hist Pointer to the histogram.
-@param threshold Threshold level.
- */
-CVAPI(void) cvThreshHist(CvHistogram *hist, double threshold);
-
-/** Compares two histogram */
-CVAPI(double)
-cvCompareHist(const CvHistogram *hist1, const CvHistogram *hist2, int method);
-
-/** @brief Copies a histogram.
-
-The function makes a copy of the histogram. If the second histogram pointer
-\*dst is NULL, a new histogram of the same size as src is created. Otherwise,
-both histograms must have equal types and sizes. Then the function copies the
-bin values of the source histogram to the destination histogram and sets the
-same bin value ranges as in src.
-
-@param src Source histogram.
-@param dst Pointer to the destination histogram.
- */
-CVAPI(void) cvCopyHist(const CvHistogram *src, CvHistogram **dst);
-
-/** @brief Calculates bayesian probabilistic histograms
-   (each or src and dst is an array of _number_ histograms */
-CVAPI(void)
-cvCalcBayesianProb(CvHistogram **src, int number, CvHistogram **dst);
-
-/** @brief Calculates array histogram
-@see cv::calcHist
-*/
-CVAPI(void)
-cvCalcArrHist(CvArr **arr, CvHistogram *hist, int accumulate CV_DEFAULT(0),
-              const CvArr *mask CV_DEFAULT(NULL));
-
-/** @overload */
-CV_INLINE void cvCalcHist(IplImage **image, CvHistogram *hist,
-                          int accumulate CV_DEFAULT(0),
-                          const CvArr *mask CV_DEFAULT(NULL)) {
-  cvCalcArrHist((CvArr **)image, hist, accumulate, mask);
-}
-
-/** @brief Calculates back project
-@see cvCalcBackProject, cv::calcBackProject
-*/
-CVAPI(void)
-cvCalcArrBackProject(CvArr **image, CvArr *dst, const CvHistogram *hist);
-
-#define cvCalcBackProject(image, dst, hist)                                    \
-  cvCalcArrBackProject((CvArr **)image, dst, hist)
-
-/** @brief Locates a template within an image by using a histogram comparison.
-
-The function calculates the back projection by comparing histograms of the
-source image patches with the given histogram. The function is similar to
-matchTemplate, but instead of comparing the raster patch with all its possible
-positions within the search window, the function CalcBackProjectPatch compares
-histograms. See the algorithm diagram below:
-
-![image](pics/backprojectpatch.png)
-
-@param image Source images (though, you may pass CvMat\*\* as well).
-@param dst Destination image.
-@param range
-@param hist Histogram.
-@param method Comparison method passed to cvCompareHist (see the function
-description).
-@param factor Normalization factor for histograms that affects the normalization
-scale of the destination image. Pass 1 if not sure.
-
-@see cvCalcBackProjectPatch
- */
-CVAPI(void)
-cvCalcArrBackProjectPatch(CvArr **image, CvArr *dst, CvSize range,
-                          CvHistogram *hist, int method, double factor);
-
-#define cvCalcBackProjectPatch(image, dst, range, hist, method, factor)        \
-  cvCalcArrBackProjectPatch((CvArr **)image, dst, range, hist, method, factor)
-
-/** @brief Divides one histogram by another.
-
-The function calculates the object probability density from two histograms as:
-
-\f[\texttt{disthist} (I)= \forkthree{0}{if
-\(\texttt{hist1}(I)=0\)}{\texttt{scale}}{if \(\texttt{hist1}(I) \ne 0\) and
-\(\texttt{hist2}(I) > \texttt{hist1}(I)\)}{\frac{\texttt{hist2}(I) \cdot
-\texttt{scale}}{\texttt{hist1}(I)}}{if \(\texttt{hist1}(I) \ne 0\) and
-\(\texttt{hist2}(I) \le \texttt{hist1}(I)\)}\f]
-
-@param hist1 First histogram (the divisor).
-@param hist2 Second histogram.
-@param dst_hist Destination histogram.
-@param scale Scale factor for the destination histogram.
- */
-CVAPI(void)
-cvCalcProbDensity(const CvHistogram *hist1, const CvHistogram *hist2,
-                  CvHistogram *dst_hist, double scale CV_DEFAULT(255));
-
-/** @brief equalizes histogram of 8-bit single-channel image
-@see cv::equalizeHist
-*/
-CVAPI(void) cvEqualizeHist(const CvArr *src, CvArr *dst);
-
-/** @brief Applies distance transform to binary image
-@see cv::distanceTransform
-*/
-CVAPI(void)
-cvDistTransform(const CvArr *src, CvArr *dst,
-                int distance_type CV_DEFAULT(CV_DIST_L2),
-                int mask_size CV_DEFAULT(3), const float *mask CV_DEFAULT(NULL),
-                CvArr *labels CV_DEFAULT(NULL),
-                int labelType CV_DEFAULT(CV_DIST_LABEL_CCOMP));
-
-/** @brief Applies fixed-level threshold to grayscale image.
-
-   This is a basic operation applied before retrieving contours
-@see cv::threshold
-*/
-CVAPI(double)
-cvThreshold(const CvArr *src, CvArr *dst, double threshold, double max_value,
-            int threshold_type);
-
-/** @brief Applies adaptive threshold to grayscale image.
-
-   The two parameters for methods CV_ADAPTIVE_THRESH_MEAN_C and
-   CV_ADAPTIVE_THRESH_GAUSSIAN_C are:
-   neighborhood size (3, 5, 7 etc.),
-   and a constant subtracted from mean (...,-3,-2,-1,0,1,2,3,...)
-@see cv::adaptiveThreshold
-*/
-CVAPI(void)
-cvAdaptiveThreshold(const CvArr *src, CvArr *dst, double max_value,
-                    int adaptive_method CV_DEFAULT(CV_ADAPTIVE_THRESH_MEAN_C),
-                    int threshold_type CV_DEFAULT(CV_THRESH_BINARY),
-                    int block_size CV_DEFAULT(3), double param1 CV_DEFAULT(5));
-
-/** @brief Fills the connected component until the color difference gets large
-enough
-@see cv::floodFill
-*/
-CVAPI(void)
-cvFloodFill(CvArr *image, CvPoint seed_point, CvScalar new_val,
-            CvScalar lo_diff CV_DEFAULT(cvScalarAll(0)),
-            CvScalar up_diff CV_DEFAULT(cvScalarAll(0)),
-            CvConnectedComp *comp CV_DEFAULT(NULL), int flags CV_DEFAULT(4),
-            CvArr *mask CV_DEFAULT(NULL));
-
-/****************************************************************************************\
-*                                  Feature detection *
-\****************************************************************************************/
-
-/** @brief Runs canny edge detector
-@see cv::Canny
-*/
-CVAPI(void)
-cvCanny(const CvArr *image, CvArr *edges, double threshold1, double threshold2,
-        int aperture_size CV_DEFAULT(3));
-
-/** @brief Calculates constraint image for corner detection
-
-   Dx^2 * Dyy + Dxx * Dy^2 - 2 * Dx * Dy * Dxy.
-   Applying threshold to the result gives coordinates of corners
-@see cv::preCornerDetect
-*/
-CVAPI(void)
-cvPreCornerDetect(const CvArr *image, CvArr *corners,
-                  int aperture_size CV_DEFAULT(3));
-
-/** @brief Calculates eigen values and vectors of 2x2
-   gradient covariation matrix at every image pixel
-@see cv::cornerEigenValsAndVecs
-*/
-CVAPI(void)
-cvCornerEigenValsAndVecs(const CvArr *image, CvArr *eigenvv, int block_size,
-                         int aperture_size CV_DEFAULT(3));
-
-/** @brief Calculates minimal eigenvalue for 2x2 gradient covariation matrix at
-   every image pixel
-@see cv::cornerMinEigenVal
-*/
-CVAPI(void)
-cvCornerMinEigenVal(const CvArr *image, CvArr *eigenval, int block_size,
-                    int aperture_size CV_DEFAULT(3));
-
-/** @brief Harris corner detector:
-
-   Calculates det(M) - k*(trace(M)^2), where M is 2x2 gradient covariation
-matrix for each pixel
-@see cv::cornerHarris
-*/
-CVAPI(void)
-cvCornerHarris(const CvArr *image, CvArr *harris_response, int block_size,
-               int aperture_size CV_DEFAULT(3), double k CV_DEFAULT(0.04));
-
-/** @brief Adjust corner position using some sort of gradient search
-@see cv::cornerSubPix
-*/
-CVAPI(void)
-cvFindCornerSubPix(const CvArr *image, CvPoint2D32f *corners, int count,
-                   CvSize win, CvSize zero_zone, CvTermCriteria criteria);
-
-/** @brief Finds a sparse set of points within the selected region
-   that seem to be easy to track
-@see cv::goodFeaturesToTrack
-*/
-CVAPI(void)
-cvGoodFeaturesToTrack(const CvArr *image, CvArr *eig_image, CvArr *temp_image,
-                      CvPoint2D32f *corners, int *corner_count,
-                      double quality_level, double min_distance,
-                      const CvArr *mask CV_DEFAULT(NULL),
-                      int block_size CV_DEFAULT(3),
-                      int use_harris CV_DEFAULT(0), double k CV_DEFAULT(0.04));
-
-/** @brief Finds lines on binary image using one of several methods.
-
-   line_storage is either memory storage or 1 x _max number of lines_ CvMat, its
-   number of columns is changed by the function.
-   method is one of CV_HOUGH_*;
-   rho, theta and threshold are used for each of those methods;
-   param1 ~ line length, param2 ~ line gap - for probabilistic,
-   param1 ~ srn, param2 ~ stn - for multi-scale
-@see cv::HoughLines
-*/
-CVAPI(CvSeq *)
-cvHoughLines2(CvArr *image, void *line_storage, int method, double rho,
-              double theta, int threshold, double param1 CV_DEFAULT(0),
-              double param2 CV_DEFAULT(0), double min_theta CV_DEFAULT(0),
-              double max_theta CV_DEFAULT(CV_PI));
-
-/** @brief Finds circles in the image
-@see cv::HoughCircles
-*/
-CVAPI(CvSeq *)
-cvHoughCircles(CvArr *image, void *circle_storage, int method, double dp,
-               double min_dist, double param1 CV_DEFAULT(100),
-               double param2 CV_DEFAULT(100), int min_radius CV_DEFAULT(0),
-               int max_radius CV_DEFAULT(0));
-
-/** @brief Fits a line into set of 2d or 3d points in a robust way (M-estimator
-technique)
-@see cv::fitLine
-*/
-CVAPI(void)
-cvFitLine(const CvArr *points, int dist_type, double param, double reps,
-          double aeps, float *line);
-
-/****************************************************************************************\
-*                                     Drawing *
-\****************************************************************************************/
-
-/****************************************************************************************\
-*       Drawing functions work with images/matrices of arbitrary type. *
-*       For color images the channel order is BGR[A] *
-*       Antialiasing is supported only for 8-bit image now. *
-*       All the functions include parameter color that means rgb value (that may
-be      *
-*       constructed with CV_RGB macro) for color images and brightness *
-*       for grayscale images. *
-*       If a drawn figure is partially or completely outside of the image, it is
-clipped.*
-\****************************************************************************************/
-
-#define CV_FILLED -1
-
-#define CV_AA 16
-
-/** @brief Draws 4-connected, 8-connected or antialiased line segment connecting
-two points
-@see cv::line
-*/
-CVAPI(void)
-cvLine(CvArr *img, CvPoint pt1, CvPoint pt2, CvScalar color,
-       int thickness CV_DEFAULT(1), int line_type CV_DEFAULT(8),
-       int shift CV_DEFAULT(0));
-
-/** @brief Draws a rectangle given two opposite corners of the rectangle (pt1 &
-pt2)
-
-   if thickness<0 (e.g. thickness == CV_FILLED), the filled box is drawn
-@see cv::rectangle
-*/
-CVAPI(void)
-cvRectangle(CvArr *img, CvPoint pt1, CvPoint pt2, CvScalar color,
-            int thickness CV_DEFAULT(1), int line_type CV_DEFAULT(8),
-            int shift CV_DEFAULT(0));
-
-/** @brief Draws a rectangle specified by a CvRect structure
-@see cv::rectangle
-*/
-CVAPI(void)
-cvRectangleR(CvArr *img, CvRect r, CvScalar color, int thickness CV_DEFAULT(1),
-             int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
-
-/** @brief Draws a circle with specified center and radius.
-
-   Thickness works in the same way as with cvRectangle
-@see cv::circle
-*/
-CVAPI(void)
-cvCircle(CvArr *img, CvPoint center, int radius, CvScalar color,
-         int thickness CV_DEFAULT(1), int line_type CV_DEFAULT(8),
-         int shift CV_DEFAULT(0));
-
-/** @brief Draws ellipse outline, filled ellipse, elliptic arc or filled
-elliptic sector
-
-   depending on _thickness_, _start_angle_ and _end_angle_ parameters. The
-resultant figure is rotated by _angle_. All the angles are in degrees
-@see cv::ellipse
-*/
-CVAPI(void)
-cvEllipse(CvArr *img, CvPoint center, CvSize axes, double angle,
-          double start_angle, double end_angle, CvScalar color,
-          int thickness CV_DEFAULT(1), int line_type CV_DEFAULT(8),
-          int shift CV_DEFAULT(0));
-
-CV_INLINE void cvEllipseBox(CvArr *img, CvBox2D box, CvScalar color,
-                            int thickness CV_DEFAULT(1),
-                            int line_type CV_DEFAULT(8),
-                            int shift CV_DEFAULT(0)) {
-  CvSize axes =
-      cvSize(cvRound(box.size.width * 0.5), cvRound(box.size.height * 0.5));
-
-  cvEllipse(img, cvPointFrom32f(box.center), axes, box.angle, 0, 360, color,
-            thickness, line_type, shift);
-}
-
-/** @brief Fills convex or monotonous polygon.
-@see cv::fillConvexPoly
-*/
-CVAPI(void)
-cvFillConvexPoly(CvArr *img, const CvPoint *pts, int npts, CvScalar color,
-                 int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
-
-/** @brief Fills an area bounded by one or more arbitrary polygons
-@see cv::fillPoly
-*/
-CVAPI(void)
-cvFillPoly(CvArr *img, CvPoint **pts, const int *npts, int contours,
-           CvScalar color, int line_type CV_DEFAULT(8),
-           int shift CV_DEFAULT(0));
-
-/** @brief Draws one or more polygonal curves
-@see cv::polylines
-*/
-CVAPI(void)
-cvPolyLine(CvArr *img, CvPoint **pts, const int *npts, int contours,
-           int is_closed, CvScalar color, int thickness CV_DEFAULT(1),
-           int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
-
-#define cvDrawRect cvRectangle
-#define cvDrawLine cvLine
-#define cvDrawCircle cvCircle
-#define cvDrawEllipse cvEllipse
-#define cvDrawPolyLine cvPolyLine
-
-/** @brief Clips the line segment connecting *pt1 and *pt2
-   by the rectangular window
-
-   (0<=x<img_size.width, 0<=y<img_size.height).
-@see cv::clipLine
-*/
-CVAPI(int) cvClipLine(CvSize img_size, CvPoint *pt1, CvPoint *pt2);
-
-/** @brief Initializes line iterator.
-
-Initially, line_iterator->ptr will point to pt1 (or pt2, see left_to_right
-description) location in the image. Returns the number of pixels on the line
-between the ending points.
-@see cv::LineIterator
-*/
-CVAPI(int)
-cvInitLineIterator(const CvArr *image, CvPoint pt1, CvPoint pt2,
-                   CvLineIterator *line_iterator,
-                   int connectivity CV_DEFAULT(8),
-                   int left_to_right CV_DEFAULT(0));
-
-#define CV_NEXT_LINE_POINT(line_iterator)                                      \
-  {                                                                            \
-    int _line_iterator_mask = (line_iterator).err < 0 ? -1 : 0;                \
-    (line_iterator).err += (line_iterator).minus_delta +                       \
-                           ((line_iterator).plus_delta & _line_iterator_mask); \
-    (line_iterator).ptr += (line_iterator).minus_step +                        \
-                           ((line_iterator).plus_step & _line_iterator_mask);  \
-  }
-
-#define CV_FONT_HERSHEY_SIMPLEX 0
-#define CV_FONT_HERSHEY_PLAIN 1
-#define CV_FONT_HERSHEY_DUPLEX 2
-#define CV_FONT_HERSHEY_COMPLEX 3
-#define CV_FONT_HERSHEY_TRIPLEX 4
-#define CV_FONT_HERSHEY_COMPLEX_SMALL 5
-#define CV_FONT_HERSHEY_SCRIPT_SIMPLEX 6
-#define CV_FONT_HERSHEY_SCRIPT_COMPLEX 7
-
-#define CV_FONT_ITALIC 16
-
-#define CV_FONT_VECTOR0 CV_FONT_HERSHEY_SIMPLEX
-
-/** Font structure */
-typedef struct CvFont {
-  const char *nameFont; // Qt:nameFont
-  CvScalar color;   // Qt:ColorFont -> cvScalar(blue_component, green_component,
-                    // red_component[, alpha_component])
-  int font_face;    // Qt: bool italic         /** =CV_FONT_* */
-  const int *ascii; //!< font data and metrics
-  const int *greek;
-  const int *cyrillic;
-  float hscale, vscale;
-  float shear;   //!< slope coefficient: 0 - normal, >0 - italic
-  int thickness; //!< Qt: weight               /** letters thickness */
-  float dx;      //!< horizontal interval between letters
-  int line_type; //!< Qt: PointSize
-} CvFont;
-
-/** @brief Initializes font structure (OpenCV 1.x API).
-
-The function initializes the font structure that can be passed to text rendering
-functions.
-
-@param font Pointer to the font structure initialized by the function
-@param font_face Font name identifier. See cv::HersheyFonts and corresponding
-old CV_* identifiers.
-@param hscale Horizontal scale. If equal to 1.0f , the characters have the
-original width depending on the font type. If equal to 0.5f , the characters are
-of half the original width.
-@param vscale Vertical scale. If equal to 1.0f , the characters have the
-original height depending on the font type. If equal to 0.5f , the characters
-are of half the original height.
-@param shear Approximate tangent of the character slope relative to the vertical
-line. A zero value means a non-italic font, 1.0f means about a 45 degree slope,
-etc.
-@param thickness Thickness of the text strokes
-@param line_type Type of the strokes, see line description
-
-@sa cvPutText
- */
-CVAPI(void)
-cvInitFont(CvFont *font, int font_face, double hscale, double vscale,
-           double shear CV_DEFAULT(0), int thickness CV_DEFAULT(1),
-           int line_type CV_DEFAULT(8));
-
-CV_INLINE CvFont cvFont(double scale, int thickness CV_DEFAULT(1)) {
-  CvFont font;
-  cvInitFont(&font, CV_FONT_HERSHEY_PLAIN, scale, scale, 0, thickness, CV_AA);
-  return font;
-}
-
-/** @brief Renders text stroke with specified font and color at specified
-location. CvFont should be initialized with cvInitFont
-@see cvInitFont, cvGetTextSize, cvFont, cv::putText
-*/
-CVAPI(void)
-cvPutText(CvArr *img, const char *text, CvPoint org, const CvFont *font,
-          CvScalar color);
-
-/** @brief Calculates bounding box of text stroke (useful for alignment)
-@see cv::getTextSize
-*/
-CVAPI(void)
-cvGetTextSize(const char *text_string, const CvFont *font, CvSize *text_size,
-              int *baseline);
-
-/** @brief Unpacks color value
-
-if arrtype is CV_8UC?, _color_ is treated as packed color value, otherwise the
-first channels (depending on arrtype) of destination scalar are set to the same
-value = _color_
-*/
-CVAPI(CvScalar) cvColorToScalar(double packed_color, int arrtype);
-
-/** @brief Returns the polygon points which make up the given ellipse.
-
-The ellipse is define by the box of size 'axes' rotated 'angle' around the
-'center'. A partial sweep of the ellipse arc can be done by specifying arc_start
-and arc_end to be something other than 0 and 360, respectively. The input array
-'pts' must be large enough to hold the result. The total number of points stored
-into 'pts' is returned by this function.
-@see cv::ellipse2Poly
-*/
-CVAPI(int)
-cvEllipse2Poly(CvPoint center, CvSize axes, int angle, int arc_start,
-               int arc_end, CvPoint *pts, int delta);
-
-/** @brief Draws contour outlines or filled interiors on the image
-@see cv::drawContours
-*/
-CVAPI(void)
-cvDrawContours(CvArr *img, CvSeq *contour, CvScalar external_color,
-               CvScalar hole_color, int max_level, int thickness CV_DEFAULT(1),
-               int line_type CV_DEFAULT(8),
-               CvPoint offset CV_DEFAULT(cvPoint(0, 0)));
-
-/** @} */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/imgproc/segmentation.hpp b/packages/react-native-executorch/third-party/include/opencv2/imgproc/segmentation.hpp
deleted file mode 100644
index f487eda49c..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/imgproc/segmentation.hpp
+++ /dev/null
@@ -1,168 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_IMGPROC_SEGMENTATION_HPP
-#define OPENCV_IMGPROC_SEGMENTATION_HPP
-
-#include "opencv2/imgproc.hpp"
-
-namespace cv {
-
-namespace segmentation {
-
-//! @addtogroup imgproc_segmentation
-//! @{
-
-/** @brief Intelligent Scissors image segmentation
- *
- * This class is used to find the path (contour) between two points
- * which can be used for image segmentation.
- *
- * Usage example:
- * @snippet snippets/imgproc_segmentation.cpp usage_example_intelligent_scissors
- *
- * Reference: <a
- * href="http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.138.3811&rep=rep1&type=pdf">"Intelligent
- * Scissors for Image Composition"</a> algorithm designed by Eric N. Mortensen
- * and William A. Barrett, Brigham Young University
- * @cite Mortensen95intelligentscissors
- */
-class CV_EXPORTS_W_SIMPLE IntelligentScissorsMB {
-public:
-  CV_WRAP
-  IntelligentScissorsMB();
-
-  /** @brief Specify weights of feature functions
-   *
-   * Consider keeping weights normalized (sum of weights equals to 1.0)
-   * Discrete dynamic programming (DP) goal is minimization of costs between
-   * pixels.
-   *
-   * @param weight_non_edge Specify cost of non-edge pixels (default: 0.43f)
-   * @param weight_gradient_direction Specify cost of gradient direction
-   * function (default: 0.43f)
-   * @param weight_gradient_magnitude Specify cost of gradient magnitude
-   * function (default: 0.14f)
-   */
-  CV_WRAP
-  IntelligentScissorsMB &setWeights(float weight_non_edge,
-                                    float weight_gradient_direction,
-                                    float weight_gradient_magnitude);
-
-  /** @brief Specify gradient magnitude max value threshold
-   *
-   * Zero limit value is used to disable gradient magnitude thresholding
-   * (default behavior, as described in original article). Otherwize pixels with
-   * `gradient magnitude >= threshold` have zero cost.
-   *
-   * @note Thresholding should be used for images with irregular regions (to
-   * avoid stuck on parameters from high-contract areas, like embedded logos).
-   *
-   * @param gradient_magnitude_threshold_max Specify gradient magnitude max
-   * value threshold (default: 0, disabled)
-   */
-  CV_WRAP
-  IntelligentScissorsMB &
-  setGradientMagnitudeMaxLimit(float gradient_magnitude_threshold_max = 0.0f);
-
-  /** @brief Switch to "Laplacian Zero-Crossing" edge feature extractor and
-   * specify its parameters
-   *
-   * This feature extractor is used by default according to article.
-   *
-   * Implementation has additional filtering for regions with low-amplitude
-   * noise. This filtering is enabled through parameter of minimal gradient
-   * amplitude (use some small value 4, 8, 16).
-   *
-   * @note Current implementation of this feature extractor is based on
-   * processing of grayscale images (color image is converted to grayscale image
-   * first).
-   *
-   * @note Canny edge detector is a bit slower, but provides better results
-   * (especially on color images): use setEdgeFeatureCannyParameters().
-   *
-   * @param gradient_magnitude_min_value Minimal gradient magnitude value for
-   * edge pixels (default: 0, check is disabled)
-   */
-  CV_WRAP
-  IntelligentScissorsMB &setEdgeFeatureZeroCrossingParameters(
-      float gradient_magnitude_min_value = 0.0f);
-
-  /** @brief Switch edge feature extractor to use Canny edge detector
-   *
-   * @note "Laplacian Zero-Crossing" feature extractor is used by default
-   * (following to original article)
-   *
-   * @sa Canny
-   */
-  CV_WRAP
-  IntelligentScissorsMB &setEdgeFeatureCannyParameters(double threshold1,
-                                                       double threshold2,
-                                                       int apertureSize = 3,
-                                                       bool L2gradient = false);
-
-  /** @brief Specify input image and extract image features
-   *
-   * @param image input image. Type is #CV_8UC1 / #CV_8UC3
-   */
-  CV_WRAP
-  IntelligentScissorsMB &applyImage(InputArray image);
-
-  /** @brief Specify custom features of input image
-   *
-   * Customized advanced variant of applyImage() call.
-   *
-   * @param non_edge Specify cost of non-edge pixels. Type is CV_8UC1. Expected
-   * values are `{0, 1}`.
-   * @param gradient_direction Specify gradient direction feature. Type is
-   * CV_32FC2. Values are expected to be normalized: `x^2 + y^2 == 1`
-   * @param gradient_magnitude Specify cost of gradient magnitude function: Type
-   * is CV_32FC1. Values should be in range `[0, 1]`.
-   * @param image **Optional parameter**. Must be specified if subset of
-   * features is specified (non-specified features are calculated internally)
-   */
-  CV_WRAP
-  IntelligentScissorsMB &applyImageFeatures(InputArray non_edge,
-                                            InputArray gradient_direction,
-                                            InputArray gradient_magnitude,
-                                            InputArray image = noArray());
-
-  /** @brief Prepares a map of optimal paths for the given source point on the
-   * image
-   *
-   * @note applyImage() / applyImageFeatures() must be called before this call
-   *
-   * @param sourcePt The source point used to find the paths
-   */
-  CV_WRAP void buildMap(const Point &sourcePt);
-
-  /** @brief Extracts optimal contour for the given target point on the image
-   *
-   * @note buildMap() must be called before this call
-   *
-   * @param targetPt The target point
-   * @param[out] contour The list of pixels which contains optimal path between
-   * the source and the target points of the image. Type is CV_32SC2 (compatible
-   * with `std::vector<Point>`)
-   * @param backward Flag to indicate reverse order of retrieved pixels (use
-   * "true" value to fetch points from the target to the source point)
-   */
-  CV_WRAP void getContour(const Point &targetPt, OutputArray contour,
-                          bool backward = false) const;
-
-#ifndef CV_DOXYGEN
-  struct Impl;
-  inline Impl *getImpl() const { return impl.get(); }
-
-protected:
-  std::shared_ptr<Impl> impl;
-#endif
-};
-
-//! @}
-
-} // namespace segmentation
-} // namespace cv
-
-#endif // OPENCV_IMGPROC_SEGMENTATION_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/imgproc/types_c.h b/packages/react-native-executorch/third-party/include/opencv2/imgproc/types_c.h
deleted file mode 100644
index 0515c29d16..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/imgproc/types_c.h
+++ /dev/null
@@ -1,632 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                           License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_IMGPROC_TYPES_C_H
-#define OPENCV_IMGPROC_TYPES_C_H
-
-#include "opencv2/core/core_c.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** @addtogroup imgproc_c
-  @{
-*/
-
-/** Connected component structure */
-typedef struct CvConnectedComp {
-  double area;    /**<area of the connected component  */
-  CvScalar value; /**<average color of the connected component */
-  CvRect rect;    /**<ROI of the component  */
-  CvSeq *contour; /**<optional component boundary
-                    (the contour might have child contours corresponding to the
-                    holes)*/
-} CvConnectedComp;
-
-/** Image smooth methods */
-enum SmoothMethod_c {
-  /** linear convolution with \f$\texttt{size1}\times\texttt{size2}\f$ box
-  kernel (all 1's). If you want to smooth different pixels with different-size
-  box kernels, you can use the integral image that is computed using integral */
-  CV_BLUR_NO_SCALE = 0,
-  /** linear convolution with \f$\texttt{size1}\times\texttt{size2}\f$ box
-  kernel (all 1's) with subsequent scaling by
-  \f$1/(\texttt{size1}\cdot\texttt{size2})\f$ */
-  CV_BLUR = 1,
-  /** linear convolution with a \f$\texttt{size1}\times\texttt{size2}\f$
-     Gaussian kernel */
-  CV_GAUSSIAN = 2,
-  /** median filter with a \f$\texttt{size1}\times\texttt{size1}\f$ square
-     aperture */
-  CV_MEDIAN = 3,
-  /** bilateral filter with a \f$\texttt{size1}\times\texttt{size1}\f$ square
-  aperture, color sigma= sigma1 and spatial sigma= sigma2. If size1=0, the
-  aperture square side is set to cvRound(sigma2\*1.5)\*2+1. See
-  cv::bilateralFilter */
-  CV_BILATERAL = 4
-};
-
-/** Filters used in pyramid decomposition */
-enum { CV_GAUSSIAN_5x5 = 7 };
-
-/** Special filters */
-enum { CV_SCHARR = -1, CV_MAX_SOBEL_KSIZE = 7 };
-
-/** Constants for color conversion */
-enum {
-  CV_BGR2BGRA = 0,
-  CV_RGB2RGBA = CV_BGR2BGRA,
-
-  CV_BGRA2BGR = 1,
-  CV_RGBA2RGB = CV_BGRA2BGR,
-
-  CV_BGR2RGBA = 2,
-  CV_RGB2BGRA = CV_BGR2RGBA,
-
-  CV_RGBA2BGR = 3,
-  CV_BGRA2RGB = CV_RGBA2BGR,
-
-  CV_BGR2RGB = 4,
-  CV_RGB2BGR = CV_BGR2RGB,
-
-  CV_BGRA2RGBA = 5,
-  CV_RGBA2BGRA = CV_BGRA2RGBA,
-
-  CV_BGR2GRAY = 6,
-  CV_RGB2GRAY = 7,
-  CV_GRAY2BGR = 8,
-  CV_GRAY2RGB = CV_GRAY2BGR,
-  CV_GRAY2BGRA = 9,
-  CV_GRAY2RGBA = CV_GRAY2BGRA,
-  CV_BGRA2GRAY = 10,
-  CV_RGBA2GRAY = 11,
-
-  CV_BGR2BGR565 = 12,
-  CV_RGB2BGR565 = 13,
-  CV_BGR5652BGR = 14,
-  CV_BGR5652RGB = 15,
-  CV_BGRA2BGR565 = 16,
-  CV_RGBA2BGR565 = 17,
-  CV_BGR5652BGRA = 18,
-  CV_BGR5652RGBA = 19,
-
-  CV_GRAY2BGR565 = 20,
-  CV_BGR5652GRAY = 21,
-
-  CV_BGR2BGR555 = 22,
-  CV_RGB2BGR555 = 23,
-  CV_BGR5552BGR = 24,
-  CV_BGR5552RGB = 25,
-  CV_BGRA2BGR555 = 26,
-  CV_RGBA2BGR555 = 27,
-  CV_BGR5552BGRA = 28,
-  CV_BGR5552RGBA = 29,
-
-  CV_GRAY2BGR555 = 30,
-  CV_BGR5552GRAY = 31,
-
-  CV_BGR2XYZ = 32,
-  CV_RGB2XYZ = 33,
-  CV_XYZ2BGR = 34,
-  CV_XYZ2RGB = 35,
-
-  CV_BGR2YCrCb = 36,
-  CV_RGB2YCrCb = 37,
-  CV_YCrCb2BGR = 38,
-  CV_YCrCb2RGB = 39,
-
-  CV_BGR2HSV = 40,
-  CV_RGB2HSV = 41,
-
-  CV_BGR2Lab = 44,
-  CV_RGB2Lab = 45,
-
-  CV_BayerBG2BGR = 46,
-  CV_BayerGB2BGR = 47,
-  CV_BayerRG2BGR = 48,
-  CV_BayerGR2BGR = 49,
-
-  CV_BayerBG2RGB = CV_BayerRG2BGR,
-  CV_BayerGB2RGB = CV_BayerGR2BGR,
-  CV_BayerRG2RGB = CV_BayerBG2BGR,
-  CV_BayerGR2RGB = CV_BayerGB2BGR,
-
-  CV_BGR2Luv = 50,
-  CV_RGB2Luv = 51,
-  CV_BGR2HLS = 52,
-  CV_RGB2HLS = 53,
-
-  CV_HSV2BGR = 54,
-  CV_HSV2RGB = 55,
-
-  CV_Lab2BGR = 56,
-  CV_Lab2RGB = 57,
-  CV_Luv2BGR = 58,
-  CV_Luv2RGB = 59,
-  CV_HLS2BGR = 60,
-  CV_HLS2RGB = 61,
-
-  CV_BayerBG2BGR_VNG = 62,
-  CV_BayerGB2BGR_VNG = 63,
-  CV_BayerRG2BGR_VNG = 64,
-  CV_BayerGR2BGR_VNG = 65,
-
-  CV_BayerBG2RGB_VNG = CV_BayerRG2BGR_VNG,
-  CV_BayerGB2RGB_VNG = CV_BayerGR2BGR_VNG,
-  CV_BayerRG2RGB_VNG = CV_BayerBG2BGR_VNG,
-  CV_BayerGR2RGB_VNG = CV_BayerGB2BGR_VNG,
-
-  CV_BGR2HSV_FULL = 66,
-  CV_RGB2HSV_FULL = 67,
-  CV_BGR2HLS_FULL = 68,
-  CV_RGB2HLS_FULL = 69,
-
-  CV_HSV2BGR_FULL = 70,
-  CV_HSV2RGB_FULL = 71,
-  CV_HLS2BGR_FULL = 72,
-  CV_HLS2RGB_FULL = 73,
-
-  CV_LBGR2Lab = 74,
-  CV_LRGB2Lab = 75,
-  CV_LBGR2Luv = 76,
-  CV_LRGB2Luv = 77,
-
-  CV_Lab2LBGR = 78,
-  CV_Lab2LRGB = 79,
-  CV_Luv2LBGR = 80,
-  CV_Luv2LRGB = 81,
-
-  CV_BGR2YUV = 82,
-  CV_RGB2YUV = 83,
-  CV_YUV2BGR = 84,
-  CV_YUV2RGB = 85,
-
-  CV_BayerBG2GRAY = 86,
-  CV_BayerGB2GRAY = 87,
-  CV_BayerRG2GRAY = 88,
-  CV_BayerGR2GRAY = 89,
-
-  // YUV 4:2:0 formats family
-  CV_YUV2RGB_NV12 = 90,
-  CV_YUV2BGR_NV12 = 91,
-  CV_YUV2RGB_NV21 = 92,
-  CV_YUV2BGR_NV21 = 93,
-  CV_YUV420sp2RGB = CV_YUV2RGB_NV21,
-  CV_YUV420sp2BGR = CV_YUV2BGR_NV21,
-
-  CV_YUV2RGBA_NV12 = 94,
-  CV_YUV2BGRA_NV12 = 95,
-  CV_YUV2RGBA_NV21 = 96,
-  CV_YUV2BGRA_NV21 = 97,
-  CV_YUV420sp2RGBA = CV_YUV2RGBA_NV21,
-  CV_YUV420sp2BGRA = CV_YUV2BGRA_NV21,
-
-  CV_YUV2RGB_YV12 = 98,
-  CV_YUV2BGR_YV12 = 99,
-  CV_YUV2RGB_IYUV = 100,
-  CV_YUV2BGR_IYUV = 101,
-  CV_YUV2RGB_I420 = CV_YUV2RGB_IYUV,
-  CV_YUV2BGR_I420 = CV_YUV2BGR_IYUV,
-  CV_YUV420p2RGB = CV_YUV2RGB_YV12,
-  CV_YUV420p2BGR = CV_YUV2BGR_YV12,
-
-  CV_YUV2RGBA_YV12 = 102,
-  CV_YUV2BGRA_YV12 = 103,
-  CV_YUV2RGBA_IYUV = 104,
-  CV_YUV2BGRA_IYUV = 105,
-  CV_YUV2RGBA_I420 = CV_YUV2RGBA_IYUV,
-  CV_YUV2BGRA_I420 = CV_YUV2BGRA_IYUV,
-  CV_YUV420p2RGBA = CV_YUV2RGBA_YV12,
-  CV_YUV420p2BGRA = CV_YUV2BGRA_YV12,
-
-  CV_YUV2GRAY_420 = 106,
-  CV_YUV2GRAY_NV21 = CV_YUV2GRAY_420,
-  CV_YUV2GRAY_NV12 = CV_YUV2GRAY_420,
-  CV_YUV2GRAY_YV12 = CV_YUV2GRAY_420,
-  CV_YUV2GRAY_IYUV = CV_YUV2GRAY_420,
-  CV_YUV2GRAY_I420 = CV_YUV2GRAY_420,
-  CV_YUV420sp2GRAY = CV_YUV2GRAY_420,
-  CV_YUV420p2GRAY = CV_YUV2GRAY_420,
-
-  // YUV 4:2:2 formats family
-  CV_YUV2RGB_UYVY = 107,
-  CV_YUV2BGR_UYVY = 108,
-  // CV_YUV2RGB_VYUY = 109,
-  // CV_YUV2BGR_VYUY = 110,
-  CV_YUV2RGB_Y422 = CV_YUV2RGB_UYVY,
-  CV_YUV2BGR_Y422 = CV_YUV2BGR_UYVY,
-  CV_YUV2RGB_UYNV = CV_YUV2RGB_UYVY,
-  CV_YUV2BGR_UYNV = CV_YUV2BGR_UYVY,
-
-  CV_YUV2RGBA_UYVY = 111,
-  CV_YUV2BGRA_UYVY = 112,
-  // CV_YUV2RGBA_VYUY = 113,
-  // CV_YUV2BGRA_VYUY = 114,
-  CV_YUV2RGBA_Y422 = CV_YUV2RGBA_UYVY,
-  CV_YUV2BGRA_Y422 = CV_YUV2BGRA_UYVY,
-  CV_YUV2RGBA_UYNV = CV_YUV2RGBA_UYVY,
-  CV_YUV2BGRA_UYNV = CV_YUV2BGRA_UYVY,
-
-  CV_YUV2RGB_YUY2 = 115,
-  CV_YUV2BGR_YUY2 = 116,
-  CV_YUV2RGB_YVYU = 117,
-  CV_YUV2BGR_YVYU = 118,
-  CV_YUV2RGB_YUYV = CV_YUV2RGB_YUY2,
-  CV_YUV2BGR_YUYV = CV_YUV2BGR_YUY2,
-  CV_YUV2RGB_YUNV = CV_YUV2RGB_YUY2,
-  CV_YUV2BGR_YUNV = CV_YUV2BGR_YUY2,
-
-  CV_YUV2RGBA_YUY2 = 119,
-  CV_YUV2BGRA_YUY2 = 120,
-  CV_YUV2RGBA_YVYU = 121,
-  CV_YUV2BGRA_YVYU = 122,
-  CV_YUV2RGBA_YUYV = CV_YUV2RGBA_YUY2,
-  CV_YUV2BGRA_YUYV = CV_YUV2BGRA_YUY2,
-  CV_YUV2RGBA_YUNV = CV_YUV2RGBA_YUY2,
-  CV_YUV2BGRA_YUNV = CV_YUV2BGRA_YUY2,
-
-  CV_YUV2GRAY_UYVY = 123,
-  CV_YUV2GRAY_YUY2 = 124,
-  // CV_YUV2GRAY_VYUY = CV_YUV2GRAY_UYVY,
-  CV_YUV2GRAY_Y422 = CV_YUV2GRAY_UYVY,
-  CV_YUV2GRAY_UYNV = CV_YUV2GRAY_UYVY,
-  CV_YUV2GRAY_YVYU = CV_YUV2GRAY_YUY2,
-  CV_YUV2GRAY_YUYV = CV_YUV2GRAY_YUY2,
-  CV_YUV2GRAY_YUNV = CV_YUV2GRAY_YUY2,
-
-  // alpha premultiplication
-  CV_RGBA2mRGBA = 125,
-  CV_mRGBA2RGBA = 126,
-
-  CV_RGB2YUV_I420 = 127,
-  CV_BGR2YUV_I420 = 128,
-  CV_RGB2YUV_IYUV = CV_RGB2YUV_I420,
-  CV_BGR2YUV_IYUV = CV_BGR2YUV_I420,
-
-  CV_RGBA2YUV_I420 = 129,
-  CV_BGRA2YUV_I420 = 130,
-  CV_RGBA2YUV_IYUV = CV_RGBA2YUV_I420,
-  CV_BGRA2YUV_IYUV = CV_BGRA2YUV_I420,
-  CV_RGB2YUV_YV12 = 131,
-  CV_BGR2YUV_YV12 = 132,
-  CV_RGBA2YUV_YV12 = 133,
-  CV_BGRA2YUV_YV12 = 134,
-
-  // Edge-Aware Demosaicing
-  CV_BayerBG2BGR_EA = 135,
-  CV_BayerGB2BGR_EA = 136,
-  CV_BayerRG2BGR_EA = 137,
-  CV_BayerGR2BGR_EA = 138,
-
-  CV_BayerBG2RGB_EA = CV_BayerRG2BGR_EA,
-  CV_BayerGB2RGB_EA = CV_BayerGR2BGR_EA,
-  CV_BayerRG2RGB_EA = CV_BayerBG2BGR_EA,
-  CV_BayerGR2RGB_EA = CV_BayerGB2BGR_EA,
-
-  CV_BayerBG2BGRA = 139,
-  CV_BayerGB2BGRA = 140,
-  CV_BayerRG2BGRA = 141,
-  CV_BayerGR2BGRA = 142,
-
-  CV_BayerBG2RGBA = CV_BayerRG2BGRA,
-  CV_BayerGB2RGBA = CV_BayerGR2BGRA,
-  CV_BayerRG2RGBA = CV_BayerBG2BGRA,
-  CV_BayerGR2RGBA = CV_BayerGB2BGRA,
-
-  CV_COLORCVT_MAX = 143
-};
-
-/** Sub-pixel interpolation methods */
-enum {
-  CV_INTER_NN = 0,
-  CV_INTER_LINEAR = 1,
-  CV_INTER_CUBIC = 2,
-  CV_INTER_AREA = 3,
-  CV_INTER_LANCZOS4 = 4
-};
-
-/** ... and other image warping flags */
-enum {
-  CV_WARP_FILL_OUTLIERS = 8,
-  CV_WARP_INVERSE_MAP = 16,
-  CV_WARP_RELATIVE_MAP = 32
-};
-
-/** Shapes of a structuring element for morphological operations
-@see cv::MorphShapes, cv::getStructuringElement
-*/
-enum MorphShapes_c {
-  CV_SHAPE_RECT = 0,
-  CV_SHAPE_CROSS = 1,
-  CV_SHAPE_ELLIPSE = 2,
-  CV_SHAPE_CUSTOM = 100 //!< custom structuring element
-};
-
-/** Morphological operations */
-enum {
-  CV_MOP_ERODE = 0,
-  CV_MOP_DILATE = 1,
-  CV_MOP_OPEN = 2,
-  CV_MOP_CLOSE = 3,
-  CV_MOP_GRADIENT = 4,
-  CV_MOP_TOPHAT = 5,
-  CV_MOP_BLACKHAT = 6
-};
-
-/** Spatial and central moments */
-typedef struct CvMoments {
-  double m00, m10, m01, m20, m11, m02, m30, m21, m12,
-      m03;                                         /**< spatial moments */
-  double mu20, mu11, mu02, mu30, mu21, mu12, mu03; /**< central moments */
-  double inv_sqrt_m00; /**< m00 != 0 ? 1/sqrt(m00) : 0 */
-
-#if defined(CV__ENABLE_C_API_CTORS) && defined(__cplusplus)
-  CvMoments() {}
-  CvMoments(const cv::Moments &m) {
-    m00 = m.m00;
-    m10 = m.m10;
-    m01 = m.m01;
-    m20 = m.m20;
-    m11 = m.m11;
-    m02 = m.m02;
-    m30 = m.m30;
-    m21 = m.m21;
-    m12 = m.m12;
-    m03 = m.m03;
-    mu20 = m.mu20;
-    mu11 = m.mu11;
-    mu02 = m.mu02;
-    mu30 = m.mu30;
-    mu21 = m.mu21;
-    mu12 = m.mu12;
-    mu03 = m.mu03;
-    double am00 = std::abs(m.m00);
-    inv_sqrt_m00 = am00 > DBL_EPSILON ? 1. / std::sqrt(am00) : 0;
-  }
-  operator cv::Moments() const {
-    return cv::Moments(m00, m10, m01, m20, m11, m02, m30, m21, m12, m03);
-  }
-#endif
-} CvMoments;
-
-#ifdef __cplusplus
-} // extern "C"
-
-CV_INLINE CvMoments cvMoments() {
-#if !defined(CV__ENABLE_C_API_CTORS)
-  CvMoments self = CV_STRUCT_INITIALIZER;
-  return self;
-#else
-  return CvMoments();
-#endif
-}
-
-CV_INLINE CvMoments cvMoments(const cv::Moments &m) {
-#if !defined(CV__ENABLE_C_API_CTORS)
-  double am00 = std::abs(m.m00);
-  CvMoments self = {
-      m.m00,  m.m10,  m.m01,
-      m.m20,  m.m11,  m.m02,
-      m.m30,  m.m21,  m.m12,
-      m.m03,  m.mu20, m.mu11,
-      m.mu02, m.mu30, m.mu21,
-      m.mu12, m.mu03, am00 > DBL_EPSILON ? 1. / std::sqrt(am00) : 0};
-  return self;
-#else
-  return CvMoments(m);
-#endif
-}
-
-extern "C" {
-#endif // __cplusplus
-
-/** Hu invariants */
-typedef struct CvHuMoments {
-  double hu1, hu2, hu3, hu4, hu5, hu6, hu7; /**< Hu invariants */
-} CvHuMoments;
-
-/** Template matching methods */
-enum {
-  CV_TM_SQDIFF = 0,
-  CV_TM_SQDIFF_NORMED = 1,
-  CV_TM_CCORR = 2,
-  CV_TM_CCORR_NORMED = 3,
-  CV_TM_CCOEFF = 4,
-  CV_TM_CCOEFF_NORMED = 5
-};
-
-typedef float(CV_CDECL *CvDistanceFunction)(const float *a, const float *b,
-                                            void *user_param);
-
-/** Contour retrieval modes */
-enum {
-  CV_RETR_EXTERNAL = 0,
-  CV_RETR_LIST = 1,
-  CV_RETR_CCOMP = 2,
-  CV_RETR_TREE = 3,
-  CV_RETR_FLOODFILL = 4
-};
-
-/** Contour approximation methods */
-enum {
-  CV_CHAIN_CODE = 0,
-  CV_CHAIN_APPROX_NONE = 1,
-  CV_CHAIN_APPROX_SIMPLE = 2,
-  CV_CHAIN_APPROX_TC89_L1 = 3,
-  CV_CHAIN_APPROX_TC89_KCOS = 4,
-  CV_LINK_RUNS = 5
-};
-
-/*
-Internal structure that is used for sequential retrieving contours from the
-image. It supports both hierarchical and plane variants of Suzuki algorithm.
-*/
-typedef struct _CvContourScanner *CvContourScanner;
-
-/** Freeman chain reader state */
-typedef struct CvChainPtReader {
-  CV_SEQ_READER_FIELDS()
-  char code;
-  CvPoint pt;
-  schar deltas[8][2];
-} CvChainPtReader;
-
-/** initializes 8-element array for fast access to 3x3 neighborhood of a pixel
- */
-#define CV_INIT_3X3_DELTAS(deltas, step, nch)                                  \
-  ((deltas)[0] = (nch), (deltas)[1] = -(step) + (nch), (deltas)[2] = -(step),  \
-   (deltas)[3] = -(step) - (nch), (deltas)[4] = -(nch),                        \
-   (deltas)[5] = (step) - (nch), (deltas)[6] = (step),                         \
-   (deltas)[7] = (step) + (nch))
-
-/** Contour approximation algorithms */
-enum { CV_POLY_APPROX_DP = 0 };
-
-/** Shape matching methods */
-enum {
-  CV_CONTOURS_MATCH_I1 = 1, //!< \f[I_1(A,B) =  \sum _{i=1...7}  \left |
-                            //!< \frac{1}{m^A_i} -  \frac{1}{m^B_i} \right |\f]
-  CV_CONTOURS_MATCH_I2 =
-      2, //!< \f[I_2(A,B) =  \sum _{i=1...7}  \left | m^A_i - m^B_i  \right |\f]
-  CV_CONTOURS_MATCH_I3 =
-      3 //!< \f[I_3(A,B) =  \max _{i=1...7}  \frac{ \left| m^A_i - m^B_i \right|
-        //!< }{ \left| m^A_i \right| }\f]
-};
-
-/** Shape orientation */
-enum { CV_CLOCKWISE = 1, CV_COUNTER_CLOCKWISE = 2 };
-
-/** Convexity defect */
-typedef struct CvConvexityDefect {
-  CvPoint *start;       /**< point of the contour where the defect begins */
-  CvPoint *end;         /**< point of the contour where the defect ends */
-  CvPoint *depth_point; /**< the farthest from the convex hull point within the
-                           defect */
-  float depth; /**< distance between the farthest point and the convex hull */
-} CvConvexityDefect;
-
-/** Histogram comparison methods */
-enum {
-  CV_COMP_CORREL = 0,
-  CV_COMP_CHISQR = 1,
-  CV_COMP_INTERSECT = 2,
-  CV_COMP_BHATTACHARYYA = 3,
-  CV_COMP_HELLINGER = CV_COMP_BHATTACHARYYA,
-  CV_COMP_CHISQR_ALT = 4,
-  CV_COMP_KL_DIV = 5
-};
-
-/** Mask size for distance transform */
-enum { CV_DIST_MASK_3 = 3, CV_DIST_MASK_5 = 5, CV_DIST_MASK_PRECISE = 0 };
-
-/** Content of output label array: connected components or pixels */
-enum { CV_DIST_LABEL_CCOMP = 0, CV_DIST_LABEL_PIXEL = 1 };
-
-/** Distance types for Distance Transform and M-estimators */
-enum {
-  CV_DIST_USER = -1,  /**< User defined distance */
-  CV_DIST_L1 = 1,     /**< distance = |x1-x2| + |y1-y2| */
-  CV_DIST_L2 = 2,     /**< the simple euclidean distance */
-  CV_DIST_C = 3,      /**< distance = max(|x1-x2|,|y1-y2|) */
-  CV_DIST_L12 = 4,    /**< L1-L2 metric: distance = 2(sqrt(1+x*x/2) - 1)) */
-  CV_DIST_FAIR = 5,   /**< distance = c^2(|x|/c-log(1+|x|/c)), c = 1.3998 */
-  CV_DIST_WELSCH = 6, /**< distance = c^2/2(1-exp(-(x/c)^2)), c = 2.9846 */
-  CV_DIST_HUBER = 7   /**< distance = |x|<c ? x^2/2 : c(|x|-c/2), c=1.345 */
-};
-
-/** Threshold types */
-enum {
-  CV_THRESH_BINARY = 0, /**< value = value > threshold ? max_value : 0       */
-  CV_THRESH_BINARY_INV = 1, /**< value = value > threshold ? 0 : max_value */
-  CV_THRESH_TRUNC = 2,  /**< value = value > threshold ? threshold : value   */
-  CV_THRESH_TOZERO = 3, /**< value = value > threshold ? value : 0           */
-  CV_THRESH_TOZERO_INV = 4, /**< value = value > threshold ? 0 : value */
-  CV_THRESH_MASK = 7,
-  CV_THRESH_OTSU =
-      8, /**< use Otsu algorithm to choose the optimal threshold value;
-            combine the flag with one of the above CV_THRESH_* values */
-  CV_THRESH_TRIANGLE =
-      16 /**< use Triangle algorithm to choose the optimal threshold value;
-           combine the flag with one of the above CV_THRESH_* values, but not
-           with CV_THRESH_OTSU */
-};
-
-/** Adaptive threshold methods */
-enum { CV_ADAPTIVE_THRESH_MEAN_C = 0, CV_ADAPTIVE_THRESH_GAUSSIAN_C = 1 };
-
-/** FloodFill flags */
-enum {
-  CV_FLOODFILL_FIXED_RANGE = (1 << 16),
-  CV_FLOODFILL_MASK_ONLY = (1 << 17)
-};
-
-/** Canny edge detector flags */
-enum { CV_CANNY_L2_GRADIENT = (1 << 31) };
-
-/** Variants of a Hough transform */
-enum {
-  CV_HOUGH_STANDARD = 0,
-  CV_HOUGH_PROBABILISTIC = 1,
-  CV_HOUGH_MULTI_SCALE = 2,
-  CV_HOUGH_GRADIENT = 3
-};
-
-/* Fast search data structures  */
-struct CvFeatureTree;
-struct CvLSH;
-struct CvLSHOperations;
-
-/** @} */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/opencv.hpp b/packages/react-native-executorch/third-party/include/opencv2/opencv.hpp
deleted file mode 100644
index 399fe0626f..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/opencv.hpp
+++ /dev/null
@@ -1,102 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                           License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009-2010, Willow Garage Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_ALL_HPP
-#define OPENCV_ALL_HPP
-
-// File that defines what modules where included during the build of OpenCV
-// These are purely the defines of the correct HAVE_OPENCV_modulename values
-#include "opencv2/opencv_modules.hpp"
-
-// Then the list of defines is checked to include the correct headers
-// Core library is always included --> without no OpenCV functionality available
-#include "opencv2/core.hpp"
-
-// Then the optional modules are checked
-#ifdef HAVE_OPENCV_CALIB3D
-#include "opencv2/calib3d.hpp"
-#endif
-#ifdef HAVE_OPENCV_FEATURES2D
-#include "opencv2/features2d.hpp"
-#endif
-#ifdef HAVE_OPENCV_DNN
-#include "opencv2/dnn.hpp"
-#endif
-#ifdef HAVE_OPENCV_FLANN
-#include "opencv2/flann.hpp"
-#endif
-#ifdef HAVE_OPENCV_HIGHGUI
-#include "opencv2/highgui.hpp"
-#endif
-#ifdef HAVE_OPENCV_IMGCODECS
-#include "opencv2/imgcodecs.hpp"
-#endif
-#ifdef HAVE_OPENCV_IMGPROC
-#include "opencv2/imgproc.hpp"
-#endif
-#ifdef HAVE_OPENCV_ML
-#include "opencv2/ml.hpp"
-#endif
-#ifdef HAVE_OPENCV_OBJDETECT
-#include "opencv2/objdetect.hpp"
-#endif
-#ifdef HAVE_OPENCV_PHOTO
-#include "opencv2/photo.hpp"
-#endif
-#ifdef HAVE_OPENCV_STITCHING
-#include "opencv2/stitching.hpp"
-#endif
-#ifdef HAVE_OPENCV_VIDEO
-#include "opencv2/video.hpp"
-#endif
-#ifdef HAVE_OPENCV_VIDEOIO
-#include "opencv2/videoio.hpp"
-#endif
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/opencv_modules.hpp b/packages/react-native-executorch/third-party/include/opencv2/opencv_modules.hpp
deleted file mode 100644
index c409845a67..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/opencv_modules.hpp
+++ /dev/null
@@ -1,19 +0,0 @@
-/*
- *      ** File generated automatically, do not modify **
- *
- * This file defines the list of modules available in current build
- * configuration
- *
- *
- */
-
-// This definition means that OpenCV is built with enabled non-free code.
-// For example, patented algorithms for non-profit/non-commercial use only.
-/* #undef OPENCV_ENABLE_NONFREE */
-
-#define HAVE_OPENCV_CORE
-#define HAVE_OPENCV_FEATURES2D
-#define HAVE_OPENCV_HIGHGUI
-#define HAVE_OPENCV_IMGPROC
-#define HAVE_OPENCV_PHOTO
-#define HAVE_OPENCV_VIDEO
diff --git a/packages/react-native-executorch/third-party/include/opencv2/photo.hpp b/packages/react-native-executorch/third-party/include/opencv2/photo.hpp
deleted file mode 100644
index af6465da7b..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/photo.hpp
+++ /dev/null
@@ -1,975 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                           License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2008-2012, Willow Garage Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_PHOTO_HPP
-#define OPENCV_PHOTO_HPP
-
-#include "opencv2/core.hpp"
-#include "opencv2/imgproc.hpp"
-
-/**
-@defgroup photo Computational Photography
-
-This module includes photo processing algorithms
-@{
-    @defgroup photo_inpaint Inpainting
-    @defgroup photo_denoise Denoising
-    @defgroup photo_hdr HDR imaging
-
-    This section describes high dynamic range imaging algorithms namely
-tonemapping, exposure alignment, camera calibration with multiple exposures and
-exposure fusion.
-
-    @defgroup photo_decolor Contrast Preserving Decolorization
-
-    Useful links:
-
-    http://www.cse.cuhk.edu.hk/leojia/projects/color2gray/index.html
-
-    @defgroup photo_clone Seamless Cloning
-
-    Useful links:
-
-    https://www.learnopencv.com/seamless-cloning-using-opencv-python-cpp
-
-    @defgroup photo_render Non-Photorealistic Rendering
-
-    Useful links:
-
-    http://www.inf.ufrgs.br/~eslgastal/DomainTransform
-
-    https://www.learnopencv.com/non-photorealistic-rendering-using-opencv-python-c/
-
-@}
-  */
-
-namespace cv {
-
-//! @addtogroup photo
-//! @{
-
-//! @addtogroup photo_inpaint
-//! @{
-//! the inpainting algorithm
-enum {
-  INPAINT_NS = 0, //!< Use Navier-Stokes based method
-  INPAINT_TELEA =
-      1 //!< Use the algorithm proposed by Alexandru Telea @cite Telea04
-};
-
-/** @brief Restores the selected region in an image using the region
-neighborhood.
-
-@param src Input 8-bit, 16-bit unsigned or 32-bit float 1-channel or 8-bit
-3-channel image.
-@param inpaintMask Inpainting mask, 8-bit 1-channel image. Non-zero pixels
-indicate the area that needs to be inpainted.
-@param dst Output image with the same size and type as src .
-@param inpaintRadius Radius of a circular neighborhood of each point inpainted
-that is considered by the algorithm.
-@param flags Inpainting method that could be cv::INPAINT_NS or cv::INPAINT_TELEA
-
-The function reconstructs the selected image area from the pixel near the area
-boundary. The function may be used to remove dust and scratches from a scanned
-photo, or to remove undesirable objects from still images or video. See
-<http://en.wikipedia.org/wiki/Inpainting> for more details.
-
-@note
-   -   An example using the inpainting technique can be found at
-        opencv_source_code/samples/cpp/inpaint.cpp
-   -   (Python) An example using the inpainting technique can be found at
-        opencv_source_code/samples/python/inpaint.py
- */
-CV_EXPORTS_W void inpaint(InputArray src, InputArray inpaintMask,
-                          OutputArray dst, double inpaintRadius, int flags);
-
-//! @} photo_inpaint
-
-//! @addtogroup photo_denoise
-//! @{
-
-/** @brief Perform image denoising using Non-local Means Denoising algorithm
-<http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/> with several
-computational optimizations. Noise expected to be a gaussian white noise
-
-@param src Input 8-bit 1-channel, 2-channel, 3-channel or 4-channel image.
-@param dst Output image with the same size and type as src .
-@param templateWindowSize Size in pixels of the template patch that is used to
-compute weights. Should be odd. Recommended value 7 pixels
-@param searchWindowSize Size in pixels of the window that is used to compute
-weighted average for given pixel. Should be odd. Affect performance linearly:
-greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
-@param h Parameter regulating filter strength. Big h value perfectly removes
-noise but also removes image details, smaller h value preserves details but also
-preserves some noise
-
-This function expected to be applied to grayscale images. For colored images
-look at fastNlMeansDenoisingColored. Advanced usage of this functions can be
-manual denoising of colored image in different colorspaces. Such approach is
-used in fastNlMeansDenoisingColored by converting image to CIELAB colorspace and
-then separately denoise L and AB components with different h parameter.
- */
-CV_EXPORTS_W void fastNlMeansDenoising(InputArray src, OutputArray dst,
-                                       float h = 3, int templateWindowSize = 7,
-                                       int searchWindowSize = 21);
-
-/** @brief Perform image denoising using Non-local Means Denoising algorithm
-<http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/> with several
-computational optimizations. Noise expected to be a gaussian white noise
-
-@param src Input 8-bit or 16-bit (only with NORM_L1) 1-channel,
-2-channel, 3-channel or 4-channel image.
-@param dst Output image with the same size and type as src .
-@param templateWindowSize Size in pixels of the template patch that is used to
-compute weights. Should be odd. Recommended value 7 pixels
-@param searchWindowSize Size in pixels of the window that is used to compute
-weighted average for given pixel. Should be odd. Affect performance linearly:
-greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
-@param h Array of parameters regulating filter strength, either one
-parameter applied to all channels or one per channel in dst. Big h value
-perfectly removes noise but also removes image details, smaller h
-value preserves details but also preserves some noise
-@param normType Type of norm used for weight calculation. Can be either NORM_L2
-or NORM_L1
-
-This function expected to be applied to grayscale images. For colored images
-look at fastNlMeansDenoisingColored. Advanced usage of this functions can be
-manual denoising of colored image in different colorspaces. Such approach is
-used in fastNlMeansDenoisingColored by converting image to CIELAB colorspace and
-then separately denoise L and AB components with different h parameter.
- */
-CV_EXPORTS_W void fastNlMeansDenoising(InputArray src, OutputArray dst,
-                                       const std::vector<float> &h,
-                                       int templateWindowSize = 7,
-                                       int searchWindowSize = 21,
-                                       int normType = NORM_L2);
-
-/** @brief Modification of fastNlMeansDenoising function for colored images
-
-@param src Input 8-bit 3-channel image.
-@param dst Output image with the same size and type as src .
-@param templateWindowSize Size in pixels of the template patch that is used to
-compute weights. Should be odd. Recommended value 7 pixels
-@param searchWindowSize Size in pixels of the window that is used to compute
-weighted average for given pixel. Should be odd. Affect performance linearly:
-greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
-@param h Parameter regulating filter strength for luminance component. Bigger h
-value perfectly removes noise but also removes image details, smaller h value
-preserves details but also preserves some noise
-@param hColor The same as h but for color components. For most images value
-equals 10 will be enough to remove colored noise and do not distort colors
-
-The function converts image to CIELAB colorspace and then separately denoise L
-and AB components with given h parameters using fastNlMeansDenoising function.
- */
-CV_EXPORTS_W void fastNlMeansDenoisingColored(InputArray src, OutputArray dst,
-                                              float h = 3, float hColor = 3,
-                                              int templateWindowSize = 7,
-                                              int searchWindowSize = 21);
-
-/** @brief Modification of fastNlMeansDenoising function for images sequence
-where consecutive images have been captured in small period of time. For example
-video. This version of the function is for grayscale images or for manual
-manipulation with colorspaces. See @cite Buades2005DenoisingIS for more details
-(open access
-[here](https://static.aminer.org/pdf/PDF/000/317/196/spatio_temporal_wiener_filtering_of_image_sequences_using_a_parametric.pdf)).
-
-@param srcImgs Input 8-bit 1-channel, 2-channel, 3-channel or
-4-channel images sequence. All images should have the same type and
-size.
-@param imgToDenoiseIndex Target image to denoise index in srcImgs sequence
-@param temporalWindowSize Number of surrounding images to use for target image
-denoising. Should be odd. Images from imgToDenoiseIndex - temporalWindowSize / 2
-to imgToDenoiseIndex + temporalWindowSize / 2 from srcImgs will be used to
-denoise srcImgs[imgToDenoiseIndex] image.
-@param dst Output image with the same size and type as srcImgs images.
-@param templateWindowSize Size in pixels of the template patch that is used to
-compute weights. Should be odd. Recommended value 7 pixels
-@param searchWindowSize Size in pixels of the window that is used to compute
-weighted average for given pixel. Should be odd. Affect performance linearly:
-greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
-@param h Parameter regulating filter strength. Bigger h value
-perfectly removes noise but also removes image details, smaller h
-value preserves details but also preserves some noise
- */
-CV_EXPORTS_W void fastNlMeansDenoisingMulti(InputArrayOfArrays srcImgs,
-                                            OutputArray dst,
-                                            int imgToDenoiseIndex,
-                                            int temporalWindowSize, float h = 3,
-                                            int templateWindowSize = 7,
-                                            int searchWindowSize = 21);
-
-/** @brief Modification of fastNlMeansDenoising function for images sequence
-where consecutive images have been captured in small period of time. For example
-video. This version of the function is for grayscale images or for manual
-manipulation with colorspaces. See @cite Buades2005DenoisingIS for more details
-(open access
-[here](https://static.aminer.org/pdf/PDF/000/317/196/spatio_temporal_wiener_filtering_of_image_sequences_using_a_parametric.pdf)).
-
-@param srcImgs Input 8-bit or 16-bit (only with NORM_L1) 1-channel,
-2-channel, 3-channel or 4-channel images sequence. All images should
-have the same type and size.
-@param imgToDenoiseIndex Target image to denoise index in srcImgs sequence
-@param temporalWindowSize Number of surrounding images to use for target image
-denoising. Should be odd. Images from imgToDenoiseIndex - temporalWindowSize / 2
-to imgToDenoiseIndex + temporalWindowSize / 2 from srcImgs will be used to
-denoise srcImgs[imgToDenoiseIndex] image.
-@param dst Output image with the same size and type as srcImgs images.
-@param templateWindowSize Size in pixels of the template patch that is used to
-compute weights. Should be odd. Recommended value 7 pixels
-@param searchWindowSize Size in pixels of the window that is used to compute
-weighted average for given pixel. Should be odd. Affect performance linearly:
-greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
-@param h Array of parameters regulating filter strength, either one
-parameter applied to all channels or one per channel in dst. Big h value
-perfectly removes noise but also removes image details, smaller h
-value preserves details but also preserves some noise
-@param normType Type of norm used for weight calculation. Can be either NORM_L2
-or NORM_L1
- */
-CV_EXPORTS_W void
-fastNlMeansDenoisingMulti(InputArrayOfArrays srcImgs, OutputArray dst,
-                          int imgToDenoiseIndex, int temporalWindowSize,
-                          const std::vector<float> &h,
-                          int templateWindowSize = 7, int searchWindowSize = 21,
-                          int normType = NORM_L2);
-
-/** @brief Modification of fastNlMeansDenoisingMulti function for colored images
-sequences
-
-@param srcImgs Input 8-bit 3-channel images sequence. All images should have the
-same type and size.
-@param imgToDenoiseIndex Target image to denoise index in srcImgs sequence
-@param temporalWindowSize Number of surrounding images to use for target image
-denoising. Should be odd. Images from imgToDenoiseIndex - temporalWindowSize / 2
-to imgToDenoiseIndex + temporalWindowSize / 2 from srcImgs will be used to
-denoise srcImgs[imgToDenoiseIndex] image.
-@param dst Output image with the same size and type as srcImgs images.
-@param templateWindowSize Size in pixels of the template patch that is used to
-compute weights. Should be odd. Recommended value 7 pixels
-@param searchWindowSize Size in pixels of the window that is used to compute
-weighted average for given pixel. Should be odd. Affect performance linearly:
-greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
-@param h Parameter regulating filter strength for luminance component. Bigger h
-value perfectly removes noise but also removes image details, smaller h value
-preserves details but also preserves some noise.
-@param hColor The same as h but for color components.
-
-The function converts images to CIELAB colorspace and then separately denoise L
-and AB components with given h parameters using fastNlMeansDenoisingMulti
-function.
- */
-CV_EXPORTS_W void fastNlMeansDenoisingColoredMulti(
-    InputArrayOfArrays srcImgs, OutputArray dst, int imgToDenoiseIndex,
-    int temporalWindowSize, float h = 3, float hColor = 3,
-    int templateWindowSize = 7, int searchWindowSize = 21);
-
-/** @brief Primal-dual algorithm is an algorithm for solving special types of
-variational problems (that is, finding a function to minimize some functional).
-As the image denoising, in particular, may be seen as the variational problem,
-primal-dual algorithm then can be used to perform denoising and this is exactly
-what is implemented.
-
-It should be noted, that this implementation was taken from the July 2013 blog
-entry
-@cite MA13 , which also contained (slightly more general) ready-to-use source
-code on Python. Subsequently, that code was rewritten on C++ with the usage of
-openCV by Vadim Pisarevsky at the end of July 2013 and finally it was slightly
-adapted by later authors.
-
-Although the thorough discussion and justification of the algorithm involved may
-be found in
-@cite ChambolleEtAl, it might make sense to skim over it here, following @cite
-MA13 . To begin with, we consider the 1-byte gray-level images as the functions
-from the rectangular domain of pixels (it may be seen as set
-\f$\left\{(x,y)\in\mathbb{N}\times\mathbb{N}\mid 1\leq x\leq n,\;1\leq y\leq
-m\right\}\f$ for some
-\f$m,\;n\in\mathbb{N}\f$) into \f$\{0,1,\dots,255\}\f$. We shall denote the
-noised images as \f$f_i\f$ and with this view, given some image \f$x\f$ of the
-same size, we may measure how bad it is by the formula
-
-\f[\left\|\left\|\nabla x\right\|\right\| +
-\lambda\sum_i\left\|\left\|x-f_i\right\|\right\|\f]
-
-\f$\|\|\cdot\|\|\f$ here denotes \f$L_2\f$-norm and as you see, the first addend
-states that we want our image to be smooth (ideally, having zero gradient, thus
-being constant) and the second states that we want our result to be close to the
-observations we've got. If we treat \f$x\f$ as a function, this is exactly the
-functional what we seek to minimize and here the Primal-Dual algorithm comes
-into play.
-
-@param observations This array should contain one or more noised versions of the
-image that is to be restored.
-@param result Here the denoised image will be stored. There is no need to do
-pre-allocation of storage space, as it will be automatically allocated, if
-necessary.
-@param lambda Corresponds to \f$\lambda\f$ in the formulas above. As it is
-enlarged, the smooth (blurred) images are treated more favorably than detailed
-(but maybe more noised) ones. Roughly speaking, as it becomes smaller, the
-result will be more blur but more sever outliers will be removed.
-@param niters Number of iterations that the algorithm will run. Of course, as
-more iterations as better, but it is hard to quantitatively refine this
-statement, so just use the default and increase it if the results are poor.
- */
-CV_EXPORTS_W void denoise_TVL1(const std::vector<Mat> &observations,
-                               Mat &result, double lambda = 1.0,
-                               int niters = 30);
-
-//! @} photo_denoise
-
-//! @addtogroup photo_hdr
-//! @{
-
-enum { LDR_SIZE = 256 };
-
-/** @brief Base class for tonemapping algorithms - tools that are used to map
- * HDR image to 8-bit range.
- */
-class CV_EXPORTS_W Tonemap : public Algorithm {
-public:
-  /** @brief Tonemaps image
-
-  @param src source image - CV_32FC3 Mat (float 32 bits 3 channels)
-  @param dst destination image - CV_32FC3 Mat with values in [0, 1] range
-   */
-  CV_WRAP virtual void process(InputArray src, OutputArray dst) = 0;
-
-  CV_WRAP virtual float getGamma() const = 0;
-  CV_WRAP virtual void setGamma(float gamma) = 0;
-};
-
-/** @brief Creates simple linear mapper with gamma correction
-
-@param gamma positive value for gamma correction. Gamma value of 1.0 implies no
-correction, gamma equal to 2.2f is suitable for most displays. Generally gamma
-\> 1 brightens the image and gamma \< 1 darkens it.
- */
-CV_EXPORTS_W Ptr<Tonemap> createTonemap(float gamma = 1.0f);
-
-/** @brief Adaptive logarithmic mapping is a fast global tonemapping algorithm
-that scales the image in logarithmic domain.
-
-Since it's a global operator the same function is applied to all the pixels, it
-is controlled by the bias parameter.
-
-Optional saturation enhancement is possible as described in @cite FL02 .
-
-For more information see @cite DM03 .
- */
-class CV_EXPORTS_W TonemapDrago : public Tonemap {
-public:
-  CV_WRAP virtual float getSaturation() const = 0;
-  CV_WRAP virtual void setSaturation(float saturation) = 0;
-
-  CV_WRAP virtual float getBias() const = 0;
-  CV_WRAP virtual void setBias(float bias) = 0;
-};
-
-/** @brief Creates TonemapDrago object
-
-@param gamma gamma value for gamma correction. See createTonemap
-@param saturation positive saturation enhancement value. 1.0 preserves
-saturation, values greater than 1 increase saturation and values less than 1
-decrease it.
-@param bias value for bias function in [0, 1] range. Values from 0.7 to 0.9
-usually give best results, default value is 0.85.
- */
-CV_EXPORTS_W Ptr<TonemapDrago> createTonemapDrago(float gamma = 1.0f,
-                                                  float saturation = 1.0f,
-                                                  float bias = 0.85f);
-
-/** @brief This is a global tonemapping operator that models human visual
-system.
-
-Mapping function is controlled by adaptation parameter, that is computed using
-light adaptation and color adaptation.
-
-For more information see @cite RD05 .
- */
-class CV_EXPORTS_W TonemapReinhard : public Tonemap {
-public:
-  CV_WRAP virtual float getIntensity() const = 0;
-  CV_WRAP virtual void setIntensity(float intensity) = 0;
-
-  CV_WRAP virtual float getLightAdaptation() const = 0;
-  CV_WRAP virtual void setLightAdaptation(float light_adapt) = 0;
-
-  CV_WRAP virtual float getColorAdaptation() const = 0;
-  CV_WRAP virtual void setColorAdaptation(float color_adapt) = 0;
-};
-
-/** @brief Creates TonemapReinhard object
-
-@param gamma gamma value for gamma correction. See createTonemap
-@param intensity result intensity in [-8, 8] range. Greater intensity produces
-brighter results.
-@param light_adapt light adaptation in [0, 1] range. If 1 adaptation is based
-only on pixel value, if 0 it's global, otherwise it's a weighted mean of this
-two cases.
-@param color_adapt chromatic adaptation in [0, 1] range. If 1 channels are
-treated independently, if 0 adaptation level is the same for each channel.
- */
-CV_EXPORTS_W Ptr<TonemapReinhard>
-createTonemapReinhard(float gamma = 1.0f, float intensity = 0.0f,
-                      float light_adapt = 1.0f, float color_adapt = 0.0f);
-
-/** @brief This algorithm transforms image to contrast using gradients on all
-levels of gaussian pyramid, transforms contrast values to HVS response and
-scales the response. After this the image is reconstructed from new contrast
-values.
-
-For more information see @cite MM06 .
- */
-class CV_EXPORTS_W TonemapMantiuk : public Tonemap {
-public:
-  CV_WRAP virtual float getScale() const = 0;
-  CV_WRAP virtual void setScale(float scale) = 0;
-
-  CV_WRAP virtual float getSaturation() const = 0;
-  CV_WRAP virtual void setSaturation(float saturation) = 0;
-};
-
-/** @brief Creates TonemapMantiuk object
-
-@param gamma gamma value for gamma correction. See createTonemap
-@param scale contrast scale factor. HVS response is multiplied by this
-parameter, thus compressing dynamic range. Values from 0.6 to 0.9 produce best
-results.
-@param saturation saturation enhancement value. See createTonemapDrago
- */
-CV_EXPORTS_W Ptr<TonemapMantiuk> createTonemapMantiuk(float gamma = 1.0f,
-                                                      float scale = 0.7f,
-                                                      float saturation = 1.0f);
-
-/** @brief The base class for algorithms that align images of the same scene
- * with different exposures
- */
-class CV_EXPORTS_W AlignExposures : public Algorithm {
-public:
-  /** @brief Aligns images
-
-  @param src vector of input images
-  @param dst vector of aligned images
-  @param times vector of exposure time values for each image
-  @param response 256x1 matrix with inverse camera response function for each
-  pixel value, it should have the same number of channels as images.
-   */
-  CV_WRAP virtual void process(InputArrayOfArrays src, std::vector<Mat> &dst,
-                               InputArray times, InputArray response) = 0;
-};
-
-/** @brief This algorithm converts images to median threshold bitmaps (1 for
-pixels brighter than median luminance and 0 otherwise) and than aligns the
-resulting bitmaps using bit operations.
-
-It is invariant to exposure, so exposure values and camera response are not
-necessary.
-
-In this implementation new image regions are filled with zeros.
-
-For more information see @cite GW03 .
- */
-class CV_EXPORTS_W AlignMTB : public AlignExposures {
-public:
-  CV_WRAP virtual void process(InputArrayOfArrays src, std::vector<Mat> &dst,
-                               InputArray times,
-                               InputArray response) CV_OVERRIDE = 0;
-
-  /** @brief Short version of process, that doesn't take extra arguments.
-
-  @param src vector of input images
-  @param dst vector of aligned images
-   */
-  CV_WRAP virtual void process(InputArrayOfArrays src,
-                               std::vector<Mat> &dst) = 0;
-
-  /** @brief Calculates shift between two images, i. e. how to shift the second
-  image to correspond it with the first.
-
-  @param img0 first image
-  @param img1 second image
-   */
-  CV_WRAP virtual Point calculateShift(InputArray img0, InputArray img1) = 0;
-  /** @brief Helper function, that shift Mat filling new regions with zeros.
-
-  @param src input image
-  @param dst result image
-  @param shift shift value
-   */
-  CV_WRAP virtual void shiftMat(InputArray src, OutputArray dst,
-                                const Point shift) = 0;
-  /** @brief Computes median threshold and exclude bitmaps of given image.
-
-  @param img input image
-  @param tb median threshold bitmap
-  @param eb exclude bitmap
-   */
-  CV_WRAP virtual void computeBitmaps(InputArray img, OutputArray tb,
-                                      OutputArray eb) = 0;
-
-  CV_WRAP virtual int getMaxBits() const = 0;
-  CV_WRAP virtual void setMaxBits(int max_bits) = 0;
-
-  CV_WRAP virtual int getExcludeRange() const = 0;
-  CV_WRAP virtual void setExcludeRange(int exclude_range) = 0;
-
-  CV_WRAP virtual bool getCut() const = 0;
-  CV_WRAP virtual void setCut(bool value) = 0;
-};
-
-/** @brief Creates AlignMTB object
-
-@param max_bits logarithm to the base 2 of maximal shift in each dimension.
-Values of 5 and 6 are usually good enough (31 and 63 pixels shift respectively).
-@param exclude_range range for exclusion bitmap that is constructed to suppress
-noise around the median value.
-@param cut if true cuts images, otherwise fills the new regions with zeros.
- */
-CV_EXPORTS_W Ptr<AlignMTB>
-createAlignMTB(int max_bits = 6, int exclude_range = 4, bool cut = true);
-
-/** @brief The base class for camera response calibration algorithms.
- */
-class CV_EXPORTS_W CalibrateCRF : public Algorithm {
-public:
-  /** @brief Recovers inverse camera response.
-
-  @param src vector of input images
-  @param dst 256x1 matrix with inverse camera response function
-  @param times vector of exposure time values for each image
-   */
-  CV_WRAP virtual void process(InputArrayOfArrays src, OutputArray dst,
-                               InputArray times) = 0;
-};
-
-/** @brief Inverse camera response function is extracted for each brightness
-value by minimizing an objective function as linear system. Objective function
-is constructed using pixel values on the same position in all images, extra term
-is added to make the result smoother.
-
-For more information see @cite DM97 .
- */
-class CV_EXPORTS_W CalibrateDebevec : public CalibrateCRF {
-public:
-  CV_WRAP virtual float getLambda() const = 0;
-  CV_WRAP virtual void setLambda(float lambda) = 0;
-
-  CV_WRAP virtual int getSamples() const = 0;
-  CV_WRAP virtual void setSamples(int samples) = 0;
-
-  CV_WRAP virtual bool getRandom() const = 0;
-  CV_WRAP virtual void setRandom(bool random) = 0;
-};
-
-/** @brief Creates CalibrateDebevec object
-
-@param samples number of pixel locations to use
-@param lambda smoothness term weight. Greater values produce smoother results,
-but can alter the response.
-@param random if true sample pixel locations are chosen at random, otherwise
-they form a rectangular grid.
- */
-CV_EXPORTS_W Ptr<CalibrateDebevec> createCalibrateDebevec(int samples = 70,
-                                                          float lambda = 10.0f,
-                                                          bool random = false);
-
-/** @brief Inverse camera response function is extracted for each brightness
-value by minimizing an objective function as linear system. This algorithm uses
-all image pixels.
-
-For more information see @cite RB99 .
- */
-class CV_EXPORTS_W CalibrateRobertson : public CalibrateCRF {
-public:
-  CV_WRAP virtual int getMaxIter() const = 0;
-  CV_WRAP virtual void setMaxIter(int max_iter) = 0;
-
-  CV_WRAP virtual float getThreshold() const = 0;
-  CV_WRAP virtual void setThreshold(float threshold) = 0;
-
-  CV_WRAP virtual Mat getRadiance() const = 0;
-};
-
-/** @brief Creates CalibrateRobertson object
-
-@param max_iter maximal number of Gauss-Seidel solver iterations.
-@param threshold target difference between results of two successive steps of
-the minimization.
- */
-CV_EXPORTS_W Ptr<CalibrateRobertson>
-createCalibrateRobertson(int max_iter = 30, float threshold = 0.01f);
-
-/** @brief The base class algorithms that can merge exposure sequence to a
- * single image.
- */
-class CV_EXPORTS_W MergeExposures : public Algorithm {
-public:
-  /** @brief Merges images.
-
-  @param src vector of input images
-  @param dst result image
-  @param times vector of exposure time values for each image
-  @param response 256x1 matrix with inverse camera response function for each
-  pixel value, it should have the same number of channels as images.
-   */
-  CV_WRAP virtual void process(InputArrayOfArrays src, OutputArray dst,
-                               InputArray times, InputArray response) = 0;
-};
-
-/** @brief The resulting HDR image is calculated as weighted average of the
-exposures considering exposure values and camera response.
-
-For more information see @cite DM97 .
- */
-class CV_EXPORTS_W MergeDebevec : public MergeExposures {
-public:
-  CV_WRAP virtual void process(InputArrayOfArrays src, OutputArray dst,
-                               InputArray times,
-                               InputArray response) CV_OVERRIDE = 0;
-  CV_WRAP virtual void process(InputArrayOfArrays src, OutputArray dst,
-                               InputArray times) = 0;
-};
-
-/** @brief Creates MergeDebevec object
- */
-CV_EXPORTS_W Ptr<MergeDebevec> createMergeDebevec();
-
-/** @brief Pixels are weighted using contrast, saturation and well-exposedness
-measures, than images are combined using laplacian pyramids.
-
-The resulting image weight is constructed as weighted average of contrast,
-saturation and well-exposedness measures.
-
-The resulting image doesn't require tonemapping and can be converted to 8-bit
-image by multiplying by 255, but it's recommended to apply gamma correction
-and/or linear tonemapping.
-
-For more information see @cite MK07 .
- */
-class CV_EXPORTS_W MergeMertens : public MergeExposures {
-public:
-  CV_WRAP virtual void process(InputArrayOfArrays src, OutputArray dst,
-                               InputArray times,
-                               InputArray response) CV_OVERRIDE = 0;
-  /** @brief Short version of process, that doesn't take extra arguments.
-
-  @param src vector of input images
-  @param dst result image
-   */
-  CV_WRAP virtual void process(InputArrayOfArrays src, OutputArray dst) = 0;
-
-  CV_WRAP virtual float getContrastWeight() const = 0;
-  CV_WRAP virtual void setContrastWeight(float contrast_weiht) = 0;
-
-  CV_WRAP virtual float getSaturationWeight() const = 0;
-  CV_WRAP virtual void setSaturationWeight(float saturation_weight) = 0;
-
-  CV_WRAP virtual float getExposureWeight() const = 0;
-  CV_WRAP virtual void setExposureWeight(float exposure_weight) = 0;
-};
-
-/** @brief Creates MergeMertens object
-
-@param contrast_weight contrast measure weight. See MergeMertens.
-@param saturation_weight saturation measure weight
-@param exposure_weight well-exposedness measure weight
- */
-CV_EXPORTS_W Ptr<MergeMertens>
-createMergeMertens(float contrast_weight = 1.0f, float saturation_weight = 1.0f,
-                   float exposure_weight = 0.0f);
-
-/** @brief The resulting HDR image is calculated as weighted average of the
-exposures considering exposure values and camera response.
-
-For more information see @cite RB99 .
- */
-class CV_EXPORTS_W MergeRobertson : public MergeExposures {
-public:
-  CV_WRAP virtual void process(InputArrayOfArrays src, OutputArray dst,
-                               InputArray times,
-                               InputArray response) CV_OVERRIDE = 0;
-  CV_WRAP virtual void process(InputArrayOfArrays src, OutputArray dst,
-                               InputArray times) = 0;
-};
-
-/** @brief Creates MergeRobertson object
- */
-CV_EXPORTS_W Ptr<MergeRobertson> createMergeRobertson();
-
-//! @} photo_hdr
-
-//! @addtogroup photo_decolor
-//! @{
-
-/** @brief Transforms a color image to a grayscale image. It is a basic tool in
-digital printing, stylized black-and-white photograph rendering, and in many
-single channel image processing applications
-@cite CL12 .
-
-@param src Input 8-bit 3-channel image.
-@param grayscale Output 8-bit 1-channel image.
-@param color_boost Output 8-bit 3-channel image.
-
-This function is to be applied on color images.
- */
-CV_EXPORTS_W void decolor(InputArray src, OutputArray grayscale,
-                          OutputArray color_boost);
-
-//! @} photo_decolor
-
-//! @addtogroup photo_clone
-//! @{
-
-//! Flags for the seamlessClone algorithm
-enum SeamlessCloneFlags {
-  /**
-  @brief Normal seamless cloning.
-  This method is ideal for inserting objects with complex outlines into a new
-  background. It preserves the original appearance and lighting of the inserted
-  object, ensuring a natural blend.
-   */
-  NORMAL_CLONE = 1,
-
-  /**
-  @brief Mixed seamless cloning.
-  This method addresses cases where simple color-based selection or alpha
-  masking is time-consuming and may result in undesirable halos. By combining
-  structure from the source and texture from the destination, mixed seamless
-  cloning is highly effective, even with loosely defined selections.
-   */
-  MIXED_CLONE = 2,
-
-  /**
-  @brief Monochrome transfer cloning.
-  This method allows users to replace specific features of an object, such as
-  grayscale textures or patterns, with alternative features. It is particularly
-  useful for artistic effects or targeted object modifications.
-   */
-  MONOCHROME_TRANSFER = 3,
-
-  /**
-  @brief Enhanced normal seamless cloning.
-  Similar to `NORMAL_CLONE`, but with an advanced approach to ROI (Region of
-  Interest) calculation. This mode processes a larger source region by
-  considering the entire mask area instead of only the bounding rectangle of
-  non-zero pixels.
-   */
-  NORMAL_CLONE_WIDE = 9,
-
-  /**
-  @brief Enhanced mixed seamless cloning.
-  Similar to `MIXED_CLONE`, but with an advanced approach to ROI (Region of
-  Interest) calculation. This mode processes a larger source region by
-  considering the entire mask area instead of only the bounding rectangle of
-  non-zero pixels.
-   */
-  MIXED_CLONE_WIDE = 10,
-
-  /**
-  @brief Enhanced monochrome transfer cloning.
-  Similar to `MONOCHROME_TRANSFER`, but with an advanced approach to ROI (Region
-  of Interest) calculation. This mode processes a larger source region by
-  considering the entire mask area instead of only the bounding rectangle of
-  non-zero pixels.
-   */
-  MONOCHROME_TRANSFER_WIDE = 11
-};
-
-/** @example samples/cpp/tutorial_code/photo/seamless_cloning/cloning_demo.cpp
-An example using seamlessClone function
-*/
-/** @brief Performs seamless cloning to blend a region from a source image into
-a destination image. This function is designed for local image editing, allowing
-changes restricted to a region (manually selected as the ROI) to be applied
-effortlessly and seamlessly. These changes can range from slight distortions to
-complete replacement by novel content @cite PM03.
-
-@param src The source image (8-bit 3-channel), from which a region will be
-blended into the destination.
-@param dst The destination image (8-bit 3-channel), where the src image will be
-blended.
-@param mask A binary mask (8-bit, 1, 3, or 4-channel) specifying the region in
-the source image to blend. Non-zero pixels indicate the region to be blended. If
-an empty Mat is provided, a mask with all non-zero pixels is created internally.
-@param p The point where the center of the src image is placed in the dst image.
-@param blend The output image that stores the result of the seamless cloning. It
-has the same size and type as `dst`.
-@param flags Flags that control the type of cloning method, can take values of
-`cv::SeamlessCloneFlags`.
- */
-CV_EXPORTS_W void seamlessClone(InputArray src, InputArray dst, InputArray mask,
-                                Point p, OutputArray blend, int flags);
-
-/** @brief Given an original color image, two differently colored versions of
-this image can be mixed seamlessly.
-
-@param src Input 8-bit 3-channel image.
-@param mask Input 8-bit 1 or 3-channel image.
-@param dst Output image with the same size and type as src .
-@param red_mul R-channel multiply factor.
-@param green_mul G-channel multiply factor.
-@param blue_mul B-channel multiply factor.
-
-Multiplication factor is between .5 to 2.5.
- */
-CV_EXPORTS_W void colorChange(InputArray src, InputArray mask, OutputArray dst,
-                              float red_mul = 1.0f, float green_mul = 1.0f,
-                              float blue_mul = 1.0f);
-
-/** @brief Applying an appropriate non-linear transformation to the gradient
-field inside the selection and then integrating back with a Poisson solver,
-modifies locally the apparent illumination of an image.
-
-@param src Input 8-bit 3-channel image.
-@param mask Input 8-bit 1 or 3-channel image.
-@param dst Output image with the same size and type as src.
-@param alpha Value ranges between 0-2.
-@param beta Value ranges between 0-2.
-
-This is useful to highlight under-exposed foreground objects or to reduce
-specular reflections.
- */
-CV_EXPORTS_W void illuminationChange(InputArray src, InputArray mask,
-                                     OutputArray dst, float alpha = 0.2f,
-                                     float beta = 0.4f);
-
-/** @brief By retaining only the gradients at edge locations, before integrating
-with the Poisson solver, one washes out the texture of the selected region,
-giving its contents a flat aspect. Here Canny Edge %Detector is used.
-
-@param src Input 8-bit 3-channel image.
-@param mask Input 8-bit 1 or 3-channel image.
-@param dst Output image with the same size and type as src.
-@param low_threshold %Range from 0 to 100.
-@param high_threshold Value \> 100.
-@param kernel_size The size of the Sobel kernel to be used.
-
-@note
-The algorithm assumes that the color of the source image is close to that of the
-destination. This assumption means that when the colors don't match, the source
-image color gets tinted toward the color of the destination image.
- */
-CV_EXPORTS_W void textureFlattening(InputArray src, InputArray mask,
-                                    OutputArray dst, float low_threshold = 30,
-                                    float high_threshold = 45,
-                                    int kernel_size = 3);
-
-//! @} photo_clone
-
-//! @addtogroup photo_render
-//! @{
-
-//! Edge preserving filters
-enum {
-  RECURS_FILTER = 1,  //!< Recursive Filtering
-  NORMCONV_FILTER = 2 //!< Normalized Convolution Filtering
-};
-
-/** @brief Filtering is the fundamental operation in image and video processing.
-Edge-preserving smoothing filters are used in many different applications @cite
-EM11 .
-
-@param src Input 8-bit 3-channel image.
-@param dst Output 8-bit 3-channel image.
-@param flags Edge preserving filters: cv::RECURS_FILTER or cv::NORMCONV_FILTER
-@param sigma_s %Range between 0 to 200.
-@param sigma_r %Range between 0 to 1.
- */
-CV_EXPORTS_W void edgePreservingFilter(InputArray src, OutputArray dst,
-                                       int flags = 1, float sigma_s = 60,
-                                       float sigma_r = 0.4f);
-
-/** @brief This filter enhances the details of a particular image.
-
-@param src Input 8-bit 3-channel image.
-@param dst Output image with the same size and type as src.
-@param sigma_s %Range between 0 to 200.
-@param sigma_r %Range between 0 to 1.
- */
-CV_EXPORTS_W void detailEnhance(InputArray src, OutputArray dst,
-                                float sigma_s = 10, float sigma_r = 0.15f);
-
-/** @example
-samples/cpp/tutorial_code/photo/non_photorealistic_rendering/npr_demo.cpp An
-example using non-photorealistic line drawing functions
-*/
-/** @brief Pencil-like non-photorealistic line drawing
-
-@param src Input 8-bit 3-channel image.
-@param dst1 Output 8-bit 1-channel image.
-@param dst2 Output image with the same size and type as src.
-@param sigma_s %Range between 0 to 200.
-@param sigma_r %Range between 0 to 1.
-@param shade_factor %Range between 0 to 0.1.
- */
-CV_EXPORTS_W void pencilSketch(InputArray src, OutputArray dst1,
-                               OutputArray dst2, float sigma_s = 60,
-                               float sigma_r = 0.07f,
-                               float shade_factor = 0.02f);
-
-/** @brief Stylization aims to produce digital imagery with a wide variety of
-effects not focused on photorealism. Edge-aware filters are ideal for
-stylization, as they can abstract regions of low contrast while preserving, or
-enhancing, high-contrast features.
-
-@param src Input 8-bit 3-channel image.
-@param dst Output image with the same size and type as src.
-@param sigma_s %Range between 0 to 200.
-@param sigma_r %Range between 0 to 1.
- */
-CV_EXPORTS_W void stylization(InputArray src, OutputArray dst,
-                              float sigma_s = 60, float sigma_r = 0.45f);
-
-//! @} photo_render
-
-//! @} photo
-
-} // namespace cv
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/photo/legacy/constants_c.h b/packages/react-native-executorch/third-party/include/opencv2/photo/legacy/constants_c.h
deleted file mode 100644
index b22a75dd2d..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/photo/legacy/constants_c.h
+++ /dev/null
@@ -1,10 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_PHOTO_LEGACY_CONSTANTS_H
-#define OPENCV_PHOTO_LEGACY_CONSTANTS_H
-
-enum InpaintingModes { CV_INPAINT_NS = 0, CV_INPAINT_TELEA = 1 };
-
-#endif // OPENCV_PHOTO_LEGACY_CONSTANTS_H
diff --git a/packages/react-native-executorch/third-party/include/opencv2/photo/photo.hpp b/packages/react-native-executorch/third-party/include/opencv2/photo/photo.hpp
deleted file mode 100644
index 0295eff96d..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/photo/photo.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifdef __OPENCV_BUILD
-#error this is a compatibility header which should not be used inside the OpenCV library
-#endif
-
-#include "opencv2/photo.hpp"
diff --git a/packages/react-native-executorch/third-party/include/opencv2/video.hpp b/packages/react-native-executorch/third-party/include/opencv2/video.hpp
deleted file mode 100644
index 538ce8052b..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/video.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_VIDEO_HPP
-#define OPENCV_VIDEO_HPP
-
-/**
-  @defgroup video Video Analysis
-  @{
-    @defgroup video_motion Motion Analysis
-    @defgroup video_track Object Tracking
-  @}
-*/
-
-#include "opencv2/video/background_segm.hpp"
-#include "opencv2/video/tracking.hpp"
-
-#endif // OPENCV_VIDEO_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/video/background_segm.hpp b/packages/react-native-executorch/third-party/include/opencv2/video/background_segm.hpp
deleted file mode 100644
index bd0c63ec6f..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/video/background_segm.hpp
+++ /dev/null
@@ -1,341 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_BACKGROUND_SEGM_HPP
-#define OPENCV_BACKGROUND_SEGM_HPP
-
-#include "opencv2/core.hpp"
-
-namespace cv {
-
-//! @addtogroup video_motion
-//! @{
-
-/** @brief Base class for background/foreground segmentation. :
-
-The class is only used to define the common interface for the whole family of
-background/foreground segmentation algorithms.
- */
-class CV_EXPORTS_W BackgroundSubtractor : public Algorithm {
-public:
-  /** @brief Computes a foreground mask.
-
-  @param image Next video frame.
-  @param fgmask The output foreground mask as an 8-bit binary image.
-  @param learningRate The value between 0 and 1 that indicates how fast the
-  background model is learnt. Negative parameter value makes the algorithm to
-  use some automatically chosen learning rate. 0 means that the background model
-  is not updated at all, 1 means that the background model is completely
-  reinitialized from the last frame.
-   */
-  CV_WRAP virtual void apply(InputArray image, OutputArray fgmask,
-                             double learningRate = -1) = 0;
-
-  /** @brief Computes a background image.
-
-  @param backgroundImage The output background image.
-
-  @note Sometimes the background image can be very blurry, as it contain the
-  average background statistics.
-   */
-  CV_WRAP virtual void
-  getBackgroundImage(OutputArray backgroundImage) const = 0;
-};
-
-/** @brief Gaussian Mixture-based Background/Foreground Segmentation Algorithm.
-
-The class implements the Gaussian mixture model background subtraction described
-in @cite Zivkovic2004 and @cite Zivkovic2006 .
- */
-class CV_EXPORTS_W BackgroundSubtractorMOG2 : public BackgroundSubtractor {
-public:
-  /** @brief Returns the number of last frames that affect the background model
-   */
-  CV_WRAP virtual int getHistory() const = 0;
-  /** @brief Sets the number of last frames that affect the background model
-   */
-  CV_WRAP virtual void setHistory(int history) = 0;
-
-  /** @brief Returns the number of gaussian components in the background model
-   */
-  CV_WRAP virtual int getNMixtures() const = 0;
-  /** @brief Sets the number of gaussian components in the background model.
-
-  The model needs to be reinitalized to reserve memory.
-  */
-  CV_WRAP virtual void
-  setNMixtures(int nmixtures) = 0; // needs reinitialization!
-
-  /** @brief Returns the "background ratio" parameter of the algorithm
-
-  If a foreground pixel keeps semi-constant value for about
-  backgroundRatio\*history frames, it's considered background and added to the
-  model as a center of a new component. It corresponds to TB parameter in the
-  paper.
-   */
-  CV_WRAP virtual double getBackgroundRatio() const = 0;
-  /** @brief Sets the "background ratio" parameter of the algorithm
-   */
-  CV_WRAP virtual void setBackgroundRatio(double ratio) = 0;
-
-  /** @brief Returns the variance threshold for the pixel-model match
-
-  The main threshold on the squared Mahalanobis distance to decide if the sample
-  is well described by the background model or not. Related to Cthr from the
-  paper.
-   */
-  CV_WRAP virtual double getVarThreshold() const = 0;
-  /** @brief Sets the variance threshold for the pixel-model match
-   */
-  CV_WRAP virtual void setVarThreshold(double varThreshold) = 0;
-
-  /** @brief Returns the variance threshold for the pixel-model match used for
-  new mixture component generation
-
-  Threshold for the squared Mahalanobis distance that helps decide when a sample
-  is close to the existing components (corresponds to Tg in the paper). If a
-  pixel is not close to any component, it is considered foreground or added as a
-  new component. 3 sigma =\> Tg=3\*3=9 is default. A smaller Tg value generates
-  more components. A higher Tg value may result in a small number of components
-  but they can grow too large.
-   */
-  CV_WRAP virtual double getVarThresholdGen() const = 0;
-  /** @brief Sets the variance threshold for the pixel-model match used for new
-   * mixture component generation
-   */
-  CV_WRAP virtual void setVarThresholdGen(double varThresholdGen) = 0;
-
-  /** @brief Returns the initial variance of each gaussian component
-   */
-  CV_WRAP virtual double getVarInit() const = 0;
-  /** @brief Sets the initial variance of each gaussian component
-   */
-  CV_WRAP virtual void setVarInit(double varInit) = 0;
-
-  CV_WRAP virtual double getVarMin() const = 0;
-  CV_WRAP virtual void setVarMin(double varMin) = 0;
-
-  CV_WRAP virtual double getVarMax() const = 0;
-  CV_WRAP virtual void setVarMax(double varMax) = 0;
-
-  /** @brief Returns the complexity reduction threshold
-
-  This parameter defines the number of samples needed to accept to prove the
-  component exists. CT=0.05 is a default value for all the samples. By setting
-  CT=0 you get an algorithm very similar to the standard Stauffer&Grimson
-  algorithm.
-   */
-  CV_WRAP virtual double getComplexityReductionThreshold() const = 0;
-  /** @brief Sets the complexity reduction threshold
-   */
-  CV_WRAP virtual void setComplexityReductionThreshold(double ct) = 0;
-
-  /** @brief Returns the shadow detection flag
-
-  If true, the algorithm detects shadows and marks them. See
-  createBackgroundSubtractorMOG2 for details.
-   */
-  CV_WRAP virtual bool getDetectShadows() const = 0;
-  /** @brief Enables or disables shadow detection
-   */
-  CV_WRAP virtual void setDetectShadows(bool detectShadows) = 0;
-
-  /** @brief Returns the shadow value
-
-  Shadow value is the value used to mark shadows in the foreground mask. Default
-  value is 127. Value 0 in the mask always means background, 255 means
-  foreground.
-   */
-  CV_WRAP virtual int getShadowValue() const = 0;
-  /** @brief Sets the shadow value
-   */
-  CV_WRAP virtual void setShadowValue(int value) = 0;
-
-  /** @brief Returns the shadow threshold
-
-  A shadow is detected if pixel is a darker version of the background. The
-  shadow threshold (Tau in the paper) is a threshold defining how much darker
-  the shadow can be. Tau= 0.5 means that if a pixel is more than twice darker
-  then it is not shadow. See Prati, Mikic, Trivedi and Cucchiara, *Detecting
-  Moving Shadows...*, IEEE PAMI,2003.
-   */
-  CV_WRAP virtual double getShadowThreshold() const = 0;
-  /** @brief Sets the shadow threshold
-   */
-  CV_WRAP virtual void setShadowThreshold(double threshold) = 0;
-
-  /** @brief Computes a foreground mask.
-
-  @param image Next video frame. Floating point frame will be used without
-  scaling and should be in range \f$[0,255]\f$.
-  @param fgmask The output foreground mask as an 8-bit binary image.
-  @param learningRate The value between 0 and 1 that indicates how fast the
-  background model is learnt. Negative parameter value makes the algorithm to
-  use some automatically chosen learning rate. 0 means that the background model
-  is not updated at all, 1 means that the background model is completely
-  reinitialized from the last frame.
-   */
-  CV_WRAP virtual void apply(InputArray image, OutputArray fgmask,
-                             double learningRate = -1) CV_OVERRIDE = 0;
-};
-
-/** @brief Creates MOG2 Background Subtractor
-
-@param history Length of the history.
-@param varThreshold Threshold on the squared Mahalanobis distance between the
-pixel and the model to decide whether a pixel is well described by the
-background model. This parameter does not affect the background update.
-@param detectShadows If true, the algorithm will detect shadows and mark them.
-It decreases the speed a bit, so if you do not need this feature, set the
-parameter to false.
- */
-CV_EXPORTS_W Ptr<BackgroundSubtractorMOG2>
-createBackgroundSubtractorMOG2(int history = 500, double varThreshold = 16,
-                               bool detectShadows = true);
-
-/** @brief K-nearest neighbours - based Background/Foreground Segmentation
-Algorithm.
-
-The class implements the K-nearest neighbours background subtraction described
-in @cite Zivkovic2006 . Very efficient if number of foreground pixels is low.
- */
-class CV_EXPORTS_W BackgroundSubtractorKNN : public BackgroundSubtractor {
-public:
-  /** @brief Returns the number of last frames that affect the background model
-   */
-  CV_WRAP virtual int getHistory() const = 0;
-  /** @brief Sets the number of last frames that affect the background model
-   */
-  CV_WRAP virtual void setHistory(int history) = 0;
-
-  /** @brief Returns the number of data samples in the background model
-   */
-  CV_WRAP virtual int getNSamples() const = 0;
-  /** @brief Sets the number of data samples in the background model.
-
-  The model needs to be reinitalized to reserve memory.
-  */
-  CV_WRAP virtual void setNSamples(int _nN) = 0; // needs reinitialization!
-
-  /** @brief Returns the threshold on the squared distance between the pixel and
-  the sample
-
-  The threshold on the squared distance between the pixel and the sample to
-  decide whether a pixel is close to a data sample.
-   */
-  CV_WRAP virtual double getDist2Threshold() const = 0;
-  /** @brief Sets the threshold on the squared distance
-   */
-  CV_WRAP virtual void setDist2Threshold(double _dist2Threshold) = 0;
-
-  /** @brief Returns the number of neighbours, the k in the kNN.
-
-  K is the number of samples that need to be within dist2Threshold in order to
-  decide that that pixel is matching the kNN background model.
-   */
-  CV_WRAP virtual int getkNNSamples() const = 0;
-  /** @brief Sets the k in the kNN. How many nearest neighbours need to match.
-   */
-  CV_WRAP virtual void setkNNSamples(int _nkNN) = 0;
-
-  /** @brief Returns the shadow detection flag
-
-  If true, the algorithm detects shadows and marks them. See
-  createBackgroundSubtractorKNN for details.
-   */
-  CV_WRAP virtual bool getDetectShadows() const = 0;
-  /** @brief Enables or disables shadow detection
-   */
-  CV_WRAP virtual void setDetectShadows(bool detectShadows) = 0;
-
-  /** @brief Returns the shadow value
-
-  Shadow value is the value used to mark shadows in the foreground mask. Default
-  value is 127. Value 0 in the mask always means background, 255 means
-  foreground.
-   */
-  CV_WRAP virtual int getShadowValue() const = 0;
-  /** @brief Sets the shadow value
-   */
-  CV_WRAP virtual void setShadowValue(int value) = 0;
-
-  /** @brief Returns the shadow threshold
-
-  A shadow is detected if pixel is a darker version of the background. The
-  shadow threshold (Tau in the paper) is a threshold defining how much darker
-  the shadow can be. Tau= 0.5 means that if a pixel is more than twice darker
-  then it is not shadow. See Prati, Mikic, Trivedi and Cucchiara, *Detecting
-  Moving Shadows...*, IEEE PAMI,2003.
-   */
-  CV_WRAP virtual double getShadowThreshold() const = 0;
-  /** @brief Sets the shadow threshold
-   */
-  CV_WRAP virtual void setShadowThreshold(double threshold) = 0;
-};
-
-/** @brief Creates KNN Background Subtractor
-
-@param history Length of the history.
-@param dist2Threshold Threshold on the squared distance between the pixel and
-the sample to decide whether a pixel is close to that sample. This parameter
-does not affect the background update.
-@param detectShadows If true, the algorithm will detect shadows and mark them.
-It decreases the speed a bit, so if you do not need this feature, set the
-parameter to false.
- */
-CV_EXPORTS_W Ptr<BackgroundSubtractorKNN>
-createBackgroundSubtractorKNN(int history = 500, double dist2Threshold = 400.0,
-                              bool detectShadows = true);
-
-//! @} video_motion
-
-} // namespace cv
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/video/detail/tracking.detail.hpp b/packages/react-native-executorch/third-party/include/opencv2/video/detail/tracking.detail.hpp
deleted file mode 100644
index ff21b149df..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/video/detail/tracking.detail.hpp
+++ /dev/null
@@ -1,435 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_VIDEO_DETAIL_TRACKING_HPP
-#define OPENCV_VIDEO_DETAIL_TRACKING_HPP
-
-/*
- * Partially based on:
- * ====================================================================================================================
- *  - [AAM] S. Salti, A. Cavallaro, L. Di Stefano, Adaptive Appearance Modeling
- * for Video Tracking: Survey and Evaluation
- *  - [AMVOT] X. Li, W. Hu, C. Shen, Z. Zhang, A. Dick, A. van den Hengel, A
- * Survey of Appearance Models in Visual Object Tracking
- *
- * This Tracking API has been designed with PlantUML. If you modify this API
- * please change UML files under modules/tracking/doc/uml
- *
- */
-
-#include "opencv2/core.hpp"
-
-namespace cv {
-namespace detail {
-inline namespace tracking {
-
-/** @addtogroup tracking_detail
-@{
-*/
-
-/************************************ TrackerFeature Base Classes
- * ************************************/
-
-/** @brief Abstract base class for TrackerFeature that represents the feature.
- */
-class CV_EXPORTS TrackerFeature {
-public:
-  virtual ~TrackerFeature();
-
-  /** @brief Compute the features in the images collection
-  @param images The images
-  @param response The output response
-  */
-  void compute(const std::vector<Mat> &images, Mat &response);
-
-protected:
-  virtual bool computeImpl(const std::vector<Mat> &images, Mat &response) = 0;
-};
-
-/** @brief Class that manages the extraction and selection of features
-
-@cite AAM Feature Extraction and Feature Set Refinement (Feature Processing and
-Feature Selection). See table I and section III C @cite AMVOT Appearance
-modelling -\> Visual representation (Table II, section 3.1 - 3.2)
-
-TrackerFeatureSet is an aggregation of TrackerFeature
-
-@sa
-   TrackerFeature
-
-*/
-class CV_EXPORTS TrackerFeatureSet {
-public:
-  TrackerFeatureSet();
-
-  ~TrackerFeatureSet();
-
-  /** @brief Extract features from the images collection
-  @param images The input images
-  */
-  void extraction(const std::vector<Mat> &images);
-
-  /** @brief Add TrackerFeature in the collection. Return true if TrackerFeature
-  is added, false otherwise
-  @param feature The TrackerFeature class
-  */
-  bool addTrackerFeature(const Ptr<TrackerFeature> &feature);
-
-  /** @brief Get the TrackerFeature collection (TrackerFeature name,
-   * TrackerFeature pointer)
-   */
-  const std::vector<Ptr<TrackerFeature>> &getTrackerFeatures() const;
-
-  /** @brief Get the responses
-  @note Be sure to call extraction before getResponses Example
-  TrackerFeatureSet::getResponses
-  */
-  const std::vector<Mat> &getResponses() const;
-
-private:
-  void clearResponses();
-  bool blockAddTrackerFeature;
-
-  std::vector<Ptr<TrackerFeature>> features; // list of features
-  std::vector<Mat> responses;                // list of response after compute
-};
-
-/************************************ TrackerSampler Base Classes
- * ************************************/
-
-/** @brief Abstract base class for TrackerSamplerAlgorithm that represents the
-algorithm for the specific sampler.
-*/
-class CV_EXPORTS TrackerSamplerAlgorithm {
-public:
-  virtual ~TrackerSamplerAlgorithm();
-
-  /** @brief Computes the regions starting from a position in an image.
-
-  Return true if samples are computed, false otherwise
-
-  @param image The current frame
-  @param boundingBox The bounding box from which regions can be calculated
-
-  @param sample The computed samples @cite AAM Fig. 1 variable Sk
-  */
-  virtual bool sampling(const Mat &image, const Rect &boundingBox,
-                        std::vector<Mat> &sample) = 0;
-};
-
-/**
- * \brief Class that manages the sampler in order to select regions for the
- * update the model of the tracker [AAM] Sampling e Labeling. See table I and
- * section III B
- */
-
-/** @brief Class that manages the sampler in order to select regions for the
-update the model of the tracker
-
-@cite AAM Sampling e Labeling. See table I and section III B
-
-TrackerSampler is an aggregation of TrackerSamplerAlgorithm
-@sa
-   TrackerSamplerAlgorithm
- */
-class CV_EXPORTS TrackerSampler {
-public:
-  TrackerSampler();
-
-  ~TrackerSampler();
-
-  /** @brief Computes the regions starting from a position in an image
-  @param image The current frame
-  @param boundingBox The bounding box from which regions can be calculated
-  */
-  void sampling(const Mat &image, Rect boundingBox);
-
-  /** @brief Return the collection of the TrackerSamplerAlgorithm
-   */
-  const std::vector<Ptr<TrackerSamplerAlgorithm>> &getSamplers() const;
-
-  /** @brief Return the samples from all TrackerSamplerAlgorithm, @cite AAM Fig.
-   * 1 variable Sk
-   */
-  const std::vector<Mat> &getSamples() const;
-
-  /** @brief Add TrackerSamplerAlgorithm in the collection. Return true if
-  sampler is added, false otherwise
-  @param sampler The TrackerSamplerAlgorithm
-  */
-  bool addTrackerSamplerAlgorithm(const Ptr<TrackerSamplerAlgorithm> &sampler);
-
-private:
-  std::vector<Ptr<TrackerSamplerAlgorithm>> samplers;
-  std::vector<Mat> samples;
-  bool blockAddTrackerSampler;
-
-  void clearSamples();
-};
-
-/************************************ TrackerModel Base Classes
- * ************************************/
-
-/** @brief Abstract base class for TrackerTargetState that represents a possible
-state of the target.
-
-See @cite AAM \f$\hat{x}^{i}_{k}\f$ all the states candidates.
-
-Inherits this class with your Target state, In own implementation you can add
-scale variation, width, height, orientation, etc.
-*/
-class CV_EXPORTS TrackerTargetState {
-public:
-  virtual ~TrackerTargetState() {}
-  /** @brief Get the position
-   * @return The position
-   */
-  Point2f getTargetPosition() const;
-
-  /** @brief Set the position
-   * @param position The position
-   */
-  void setTargetPosition(const Point2f &position);
-  /** @brief Get the width of the target
-   * @return The width of the target
-   */
-  int getTargetWidth() const;
-
-  /** @brief Set the width of the target
-   * @param width The width of the target
-   */
-  void setTargetWidth(int width);
-  /** @brief Get the height of the target
-   * @return The height of the target
-   */
-  int getTargetHeight() const;
-
-  /** @brief Set the height of the target
-   * @param height The height of the target
-   */
-  void setTargetHeight(int height);
-
-protected:
-  Point2f targetPosition;
-  int targetWidth;
-  int targetHeight;
-};
-
-/** @brief Represents the model of the target at frame \f$k\f$ (all states and
-scores)
-
-See @cite AAM The set of the pair \f$\langle \hat{x}^{i}_{k}, C^{i}_{k}
-\rangle\f$
-@sa TrackerTargetState
-*/
-typedef std::vector<std::pair<Ptr<TrackerTargetState>, float>> ConfidenceMap;
-
-/** @brief Represents the estimate states for all frames
-
-@cite AAM \f$x_{k}\f$ is the trajectory of the target up to time \f$k\f$
-
-@sa TrackerTargetState
-*/
-typedef std::vector<Ptr<TrackerTargetState>> Trajectory;
-
-/** @brief Abstract base class for TrackerStateEstimator that estimates the most
-likely target state.
-
-See @cite AAM State estimator
-
-See @cite AMVOT Statistical modeling (Fig. 3), Table III (generative) - IV
-(discriminative) - V (hybrid)
-*/
-class CV_EXPORTS TrackerStateEstimator {
-public:
-  virtual ~TrackerStateEstimator();
-
-  /** @brief Estimate the most likely target state, return the estimated state
-  @param confidenceMaps The overall appearance model as a list of
-  :cConfidenceMap
-  */
-  Ptr<TrackerTargetState>
-  estimate(const std::vector<ConfidenceMap> &confidenceMaps);
-
-  /** @brief Update the ConfidenceMap with the scores
-  @param confidenceMaps The overall appearance model as a list of
-  :cConfidenceMap
-  */
-  void update(std::vector<ConfidenceMap> &confidenceMaps);
-
-  /** @brief Create TrackerStateEstimator by tracker state estimator type
-  @param trackeStateEstimatorType The TrackerStateEstimator name
-
-  The modes available now:
-
-  -   "BOOSTING" -- Boosting-based discriminative appearance models. See @cite
-  AMVOT section 4.4
-
-  The modes available soon:
-
-  -   "SVM" -- SVM-based discriminative appearance models. See @cite AMVOT
-  section 4.5
-  */
-  static Ptr<TrackerStateEstimator>
-  create(const String &trackeStateEstimatorType);
-
-  /** @brief Get the name of the specific TrackerStateEstimator
-   */
-  String getClassName() const;
-
-protected:
-  virtual Ptr<TrackerTargetState>
-  estimateImpl(const std::vector<ConfidenceMap> &confidenceMaps) = 0;
-  virtual void updateImpl(std::vector<ConfidenceMap> &confidenceMaps) = 0;
-  String className;
-};
-
-/** @brief Abstract class that represents the model of the target.
-
-It must be instantiated by specialized tracker
-
-See @cite AAM Ak
-
-Inherits this with your TrackerModel
-*/
-class CV_EXPORTS TrackerModel {
-public:
-  TrackerModel();
-
-  virtual ~TrackerModel();
-
-  /** @brief Set TrackerEstimator, return true if the tracker state estimator is
-  added, false otherwise
-  @param trackerStateEstimator The TrackerStateEstimator
-  @note You can add only one TrackerStateEstimator
-  */
-  bool
-  setTrackerStateEstimator(Ptr<TrackerStateEstimator> trackerStateEstimator);
-
-  /** @brief Estimate the most likely target location
-
-  @cite AAM ME, Model Estimation table I
-  @param responses Features extracted from TrackerFeatureSet
-  */
-  void modelEstimation(const std::vector<Mat> &responses);
-
-  /** @brief Update the model
-
-  @cite AAM MU, Model Update table I
-  */
-  void modelUpdate();
-
-  /** @brief Run the TrackerStateEstimator, return true if is possible to
-   * estimate a new state, false otherwise
-   */
-  bool runStateEstimator();
-
-  /** @brief Set the current TrackerTargetState in the Trajectory
-  @param lastTargetState The current TrackerTargetState
-  */
-  void setLastTargetState(const Ptr<TrackerTargetState> &lastTargetState);
-
-  /** @brief Get the last TrackerTargetState from Trajectory
-   */
-  Ptr<TrackerTargetState> getLastTargetState() const;
-
-  /** @brief Get the list of the ConfidenceMap
-   */
-  const std::vector<ConfidenceMap> &getConfidenceMaps() const;
-
-  /** @brief Get the last ConfidenceMap for the current frame
-   */
-  const ConfidenceMap &getLastConfidenceMap() const;
-
-  /** @brief Get the TrackerStateEstimator
-   */
-  Ptr<TrackerStateEstimator> getTrackerStateEstimator() const;
-
-private:
-  void clearCurrentConfidenceMap();
-
-protected:
-  std::vector<ConfidenceMap> confidenceMaps;
-  Ptr<TrackerStateEstimator> stateEstimator;
-  ConfidenceMap currentConfidenceMap;
-  Trajectory trajectory;
-  int maxCMLength;
-
-  virtual void modelEstimationImpl(const std::vector<Mat> &responses) = 0;
-  virtual void modelUpdateImpl() = 0;
-};
-
-/************************************ Specific TrackerStateEstimator Classes
- * ************************************/
-
-// None
-
-/************************************ Specific TrackerSamplerAlgorithm Classes
- * ************************************/
-
-/** @brief TrackerSampler based on CSC (current state centered), used by MIL
- * algorithm TrackerMIL
- */
-class CV_EXPORTS TrackerSamplerCSC : public TrackerSamplerAlgorithm {
-public:
-  ~TrackerSamplerCSC();
-
-  enum MODE {
-    MODE_INIT_POS = 1,  //!< mode for init positive samples
-    MODE_INIT_NEG = 2,  //!< mode for init negative samples
-    MODE_TRACK_POS = 3, //!< mode for update positive samples
-    MODE_TRACK_NEG = 4, //!< mode for update negative samples
-    MODE_DETECT = 5     //!< mode for detect samples
-  };
-
-  struct CV_EXPORTS Params {
-    Params();
-    float initInRad; //!< radius for gathering positive instances during init
-    float trackInPosRad; //!< radius for gathering positive instances during
-                         //!< tracking
-    float searchWinSize; //!< size of search window
-    int initMaxNegNum;   //!< # negative samples to use during init
-    int trackMaxPosNum;  //!< # positive samples to use during training
-    int trackMaxNegNum;  //!< # negative samples to use during training
-  };
-
-  /** @brief Constructor
-  @param parameters TrackerSamplerCSC parameters TrackerSamplerCSC::Params
-  */
-  TrackerSamplerCSC(const TrackerSamplerCSC::Params &parameters =
-                        TrackerSamplerCSC::Params());
-
-  /** @brief Set the sampling mode of TrackerSamplerCSC
-  @param samplingMode The sampling mode
-
-  The modes are:
-
-  -   "MODE_INIT_POS = 1" -- for the positive sampling in initialization step
-  -   "MODE_INIT_NEG = 2" -- for the negative sampling in initialization step
-  -   "MODE_TRACK_POS = 3" -- for the positive sampling in update step
-  -   "MODE_TRACK_NEG = 4" -- for the negative sampling in update step
-  -   "MODE_DETECT = 5" -- for the sampling in detection step
-  */
-  void setMode(int samplingMode);
-
-  bool sampling(const Mat &image, const Rect &boundingBox,
-                std::vector<Mat> &sample) CV_OVERRIDE;
-
-private:
-  Params params;
-  int mode;
-  RNG rng;
-
-  std::vector<Mat> sampleImage(const Mat &img, int x, int y, int w, int h,
-                               float inrad, float outrad = 0,
-                               int maxnum = 1000000);
-};
-
-//! @}
-
-} // namespace tracking
-} // namespace detail
-} // namespace cv
-
-#endif // OPENCV_VIDEO_DETAIL_TRACKING_HPP
diff --git a/packages/react-native-executorch/third-party/include/opencv2/video/legacy/constants_c.h b/packages/react-native-executorch/third-party/include/opencv2/video/legacy/constants_c.h
deleted file mode 100644
index 3a914009e1..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/video/legacy/constants_c.h
+++ /dev/null
@@ -1,15 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level
-// directory of this distribution and at http://opencv.org/license.html.
-
-#ifndef OPENCV_VIDEO_LEGACY_CONSTANTS_H
-#define OPENCV_VIDEO_LEGACY_CONSTANTS_H
-
-enum {
-  CV_LKFLOW_PYR_A_READY = 1,
-  CV_LKFLOW_PYR_B_READY = 2,
-  CV_LKFLOW_INITIAL_GUESSES = 4,
-  CV_LKFLOW_GET_MIN_EIGENVALS = 8
-};
-
-#endif // OPENCV_VIDEO_LEGACY_CONSTANTS_H
diff --git a/packages/react-native-executorch/third-party/include/opencv2/video/tracking.hpp b/packages/react-native-executorch/third-party/include/opencv2/video/tracking.hpp
deleted file mode 100644
index a6e6b98dd9..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/video/tracking.hpp
+++ /dev/null
@@ -1,1014 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_TRACKING_HPP
-#define OPENCV_TRACKING_HPP
-
-#include "opencv2/core.hpp"
-#include "opencv2/imgproc.hpp"
-
-namespace cv {
-
-//! @addtogroup video_track
-//! @{
-
-enum {
-  OPTFLOW_USE_INITIAL_FLOW = 4,
-  OPTFLOW_LK_GET_MIN_EIGENVALS = 8,
-  OPTFLOW_FARNEBACK_GAUSSIAN = 256
-};
-
-/** @brief Finds an object center, size, and orientation.
-
-@param probImage Back projection of the object histogram. See calcBackProject.
-@param window Initial search window.
-@param criteria Stop criteria for the underlying meanShift.
-returns
-(in old interfaces) Number of iterations CAMSHIFT took to converge
-The function implements the CAMSHIFT object tracking algorithm @cite Bradski98 .
-First, it finds an object center using meanShift and then adjusts the window
-size and finds the optimal rotation. The function returns the rotated rectangle
-structure that includes the object position, size, and orientation. The next
-position of the search window can be obtained with RotatedRect::boundingRect()
-
-See the OpenCV sample camshiftdemo.c that tracks colored objects.
-
-@note
--   (Python) A sample explaining the camshift tracking algorithm can be found at
-    opencv_source_code/samples/python/camshift.py
- */
-CV_EXPORTS_W RotatedRect CamShift(InputArray probImage, CV_IN_OUT Rect &window,
-                                  TermCriteria criteria);
-/** @example samples/cpp/camshiftdemo.cpp
-An example using the mean-shift tracking algorithm
-*/
-
-/** @brief Finds an object on a back projection image.
-
-@param probImage Back projection of the object histogram. See calcBackProject
-for details.
-@param window Initial search window.
-@param criteria Stop criteria for the iterative search algorithm.
-returns
-:   Number of iterations CAMSHIFT took to converge.
-The function implements the iterative object search algorithm. It takes the
-input back projection of an object and the initial position. The mass center in
-window of the back projection image is computed and the search window center
-shifts to the mass center. The procedure is repeated until the specified number
-of iterations criteria.maxCount is done or until the window center shifts by
-less than criteria.epsilon. The algorithm is used inside CamShift and, unlike
-CamShift , the search window size or orientation do not change during the
-search. You can simply pass the output of calcBackProject to this function. But
-better results can be obtained if you pre-filter the back projection and remove
-the noise. For example, you can do this by retrieving connected components with
-findContours , throwing away contours with small area ( contourArea ), and
-rendering the remaining contours with drawContours.
-
- */
-CV_EXPORTS_W int meanShift(InputArray probImage, CV_IN_OUT Rect &window,
-                           TermCriteria criteria);
-
-/** @brief Constructs the image pyramid which can be passed to
-calcOpticalFlowPyrLK.
-
-@param img 8-bit input image.
-@param pyramid output pyramid.
-@param winSize window size of optical flow algorithm. Must be not less than
-winSize argument of calcOpticalFlowPyrLK. It is needed to calculate required
-padding for pyramid levels.
-@param maxLevel 0-based maximal pyramid level number.
-@param withDerivatives set to precompute gradients for the every pyramid level.
-If pyramid is constructed without the gradients then calcOpticalFlowPyrLK will
-calculate them internally.
-@param pyrBorder the border mode for pyramid layers.
-@param derivBorder the border mode for gradients.
-@param tryReuseInputImage put ROI of input image into the pyramid if possible.
-You can pass false to force data copying.
-@return number of levels in constructed pyramid. Can be less than maxLevel.
- */
-CV_EXPORTS_W int buildOpticalFlowPyramid(
-    InputArray img, OutputArrayOfArrays pyramid, Size winSize, int maxLevel,
-    bool withDerivatives = true, int pyrBorder = BORDER_REFLECT_101,
-    int derivBorder = BORDER_CONSTANT, bool tryReuseInputImage = true);
-
-/** @example samples/cpp/lkdemo.cpp
-An example using the Lucas-Kanade optical flow algorithm
-*/
-
-/** @brief Calculates an optical flow for a sparse feature set using the
-iterative Lucas-Kanade method with pyramids.
-
-@param prevImg first 8-bit input image or pyramid constructed by
-buildOpticalFlowPyramid.
-@param nextImg second input image or pyramid of the same size and the same type
-as prevImg.
-@param prevPts vector of 2D points for which the flow needs to be found; point
-coordinates must be single-precision floating-point numbers.
-@param nextPts output vector of 2D points (with single-precision floating-point
-coordinates) containing the calculated new positions of input features in the
-second image; when OPTFLOW_USE_INITIAL_FLOW flag is passed, the vector must have
-the same size as in the input.
-@param status output status vector (of unsigned chars); each element of the
-vector is set to 1 if the flow for the corresponding features has been found,
-otherwise, it is set to 0.
-@param err output vector of errors; each element of the vector is set to an
-error for the corresponding feature, type of the error measure can be set in
-flags parameter; if the flow wasn't found then the error is not defined (use the
-status parameter to find such cases).
-@param winSize size of the search window at each pyramid level.
-@param maxLevel 0-based maximal pyramid level number; if set to 0, pyramids are
-not used (single level), if set to 1, two levels are used, and so on; if
-pyramids are passed to input then algorithm will use as many levels as pyramids
-have but no more than maxLevel.
-@param criteria parameter, specifying the termination criteria of the iterative
-search algorithm (after the specified maximum number of iterations
-criteria.maxCount or when the search window moves by less than criteria.epsilon.
-@param flags operation flags:
- -   **OPTFLOW_USE_INITIAL_FLOW** uses initial estimations, stored in nextPts;
-if the flag is not set, then prevPts is copied to nextPts and is considered the
-initial estimate.
- -   **OPTFLOW_LK_GET_MIN_EIGENVALS** use minimum eigen values as an error
-measure (see minEigThreshold description); if the flag is not set, then L1
-distance between patches around the original and a moved point, divided by
-number of pixels in a window, is used as a error measure.
-@param minEigThreshold the algorithm calculates the minimum eigen value of a 2x2
-normal matrix of optical flow equations (this matrix is called a spatial
-gradient matrix in @cite Bouguet00), divided by number of pixels in a window; if
-this value is less than minEigThreshold, then a corresponding feature is
-filtered out and its flow is not processed, so it allows to remove bad points
-and get a performance boost.
-
-The function implements a sparse iterative version of the Lucas-Kanade optical
-flow in pyramids. See
-@cite Bouguet00 . The function is parallelized with the TBB library.
-
-@note Some examples:
-
--   An example using the Lucas-Kanade optical flow algorithm can be found at
-    opencv_source_code/samples/cpp/lkdemo.cpp
--   (Python) An example using the Lucas-Kanade optical flow algorithm can be
-found at opencv_source_code/samples/python/lk_track.py
--   (Python) An example using the Lucas-Kanade tracker for homography matching
-can be found at opencv_source_code/samples/python/lk_homography.py
- */
-CV_EXPORTS_W void
-calcOpticalFlowPyrLK(InputArray prevImg, InputArray nextImg, InputArray prevPts,
-                     InputOutputArray nextPts, OutputArray status,
-                     OutputArray err, Size winSize = Size(21, 21),
-                     int maxLevel = 3,
-                     TermCriteria criteria = TermCriteria(TermCriteria::COUNT +
-                                                              TermCriteria::EPS,
-                                                          30, 0.01),
-                     int flags = 0, double minEigThreshold = 1e-4);
-
-/** @brief Computes a dense optical flow using the Gunnar Farneback's algorithm.
-
-@param prev first 8-bit single-channel input image.
-@param next second input image of the same size and the same type as prev.
-@param flow computed flow image that has the same size as prev and type
-CV_32FC2.
-@param pyr_scale parameter, specifying the image scale (\<1) to build pyramids
-for each image; pyr_scale=0.5 means a classical pyramid, where each next layer
-is twice smaller than the previous one.
-@param levels number of pyramid layers including the initial image; levels=1
-means that no extra layers are created and only the original images are used.
-@param winsize averaging window size; larger values increase the algorithm
-robustness to image noise and give more chances for fast motion detection, but
-yield more blurred motion field.
-@param iterations number of iterations the algorithm does at each pyramid level.
-@param poly_n size of the pixel neighborhood used to find polynomial expansion
-in each pixel; larger values mean that the image will be approximated with
-smoother surfaces, yielding more robust algorithm and more blurred motion field,
-typically poly_n =5 or 7.
-@param poly_sigma standard deviation of the Gaussian that is used to smooth
-derivatives used as a basis for the polynomial expansion; for poly_n=5, you can
-set poly_sigma=1.1, for poly_n=7, a good value would be poly_sigma=1.5.
-@param flags operation flags that can be a combination of the following:
- -   **OPTFLOW_USE_INITIAL_FLOW** uses the input flow as an initial flow
-approximation.
- -   **OPTFLOW_FARNEBACK_GAUSSIAN** uses the Gaussian
-\f$\texttt{winsize}\times\texttt{winsize}\f$ filter instead of a box filter of
-the same size for optical flow estimation; usually, this option gives z more
-accurate flow than with a box filter, at the cost of lower speed; normally,
-winsize for a Gaussian window should be set to a larger value to achieve the
-same level of robustness.
-
-The function finds an optical flow for each prev pixel using the @cite
-Farneback2003 algorithm so that
-
-\f[\texttt{prev} (y,x)  \sim \texttt{next} ( y + \texttt{flow} (y,x)[1],  x +
-\texttt{flow} (y,x)[0])\f]
-
-@note Some examples:
-
--   An example using the optical flow algorithm described by Gunnar Farneback
-can be found at opencv_source_code/samples/cpp/fback.cpp
--   (Python) An example using the optical flow algorithm described by Gunnar
-Farneback can be found at opencv_source_code/samples/python/opt_flow.py
- */
-CV_EXPORTS_W void calcOpticalFlowFarneback(InputArray prev, InputArray next,
-                                           InputOutputArray flow,
-                                           double pyr_scale, int levels,
-                                           int winsize, int iterations,
-                                           int poly_n, double poly_sigma,
-                                           int flags);
-
-/** @brief Computes an optimal affine transformation between two 2D point sets.
-
-@param src First input 2D point set stored in std::vector or Mat, or an image
-stored in Mat.
-@param dst Second input 2D point set of the same size and the same type as A, or
-another image.
-@param fullAffine If true, the function finds an optimal affine transformation
-with no additional restrictions (6 degrees of freedom). Otherwise, the class of
-transformations to choose from is limited to combinations of translation,
-rotation, and uniform scaling (4 degrees of freedom).
-
-The function finds an optimal affine transform *[A|b]* (a 2 x 3 floating-point
-matrix) that approximates best the affine transformation between:
-
-*   Two point sets
-*   Two raster images. In this case, the function first finds some features in
-the src image and finds the corresponding features in dst image. After that, the
-problem is reduced to the first case. In case of point sets, the problem is
-formulated as follows: you need to find a 2x2 matrix *A* and 2x1 vector *b* so
-that:
-
-\f[[A^*|b^*] = arg  \min _{[A|b]}  \sum _i  \| \texttt{dst}[i] - A {
-\texttt{src}[i]}^T - b  \| ^2\f] where src[i] and dst[i] are the i-th points in
-src and dst, respectively
-\f$[A|b]\f$ can be either arbitrary (when fullAffine=true ) or have a form of
-\f[\begin{bmatrix} a_{11} & a_{12} & b_1  \\ -a_{12} & a_{11} & b_2
-\end{bmatrix}\f] when fullAffine=false.
-
-@deprecated Use cv::estimateAffine2D, cv::estimateAffinePartial2D instead. If
-you are using this function with images, extract points using
-cv::calcOpticalFlowPyrLK and then use the estimation functions.
-
-@sa
-estimateAffine2D, estimateAffinePartial2D, getAffineTransform,
-getPerspectiveTransform, findHomography
- */
-CV_DEPRECATED CV_EXPORTS Mat estimateRigidTransform(InputArray src,
-                                                    InputArray dst,
-                                                    bool fullAffine);
-
-enum {
-  MOTION_TRANSLATION = 0,
-  MOTION_EUCLIDEAN = 1,
-  MOTION_AFFINE = 2,
-  MOTION_HOMOGRAPHY = 3
-};
-
-/** @brief Computes the Enhanced Correlation Coefficient value between two
-images @cite EP08 .
-
-@param templateImage single-channel template image; CV_8U or CV_32F array.
-@param inputImage single-channel input image to be warped to provide an image
-similar to templateImage, same type as templateImage.
-@param inputMask An optional mask to indicate valid values of inputImage.
-
-@sa
-findTransformECC
- */
-
-CV_EXPORTS_W double computeECC(InputArray templateImage, InputArray inputImage,
-                               InputArray inputMask = noArray());
-
-/** @example samples/cpp/image_alignment.cpp
-An example using the image alignment ECC algorithm
-*/
-
-/** @brief Finds the geometric transform (warp) between two images in terms of
-the ECC criterion @cite EP08 .
-
-@param templateImage single-channel template image; CV_8U or CV_32F array.
-@param inputImage single-channel input image which should be warped with the
-final warpMatrix in order to provide an image similar to templateImage, same
-type as templateImage.
-@param warpMatrix floating-point \f$2\times 3\f$ or \f$3\times 3\f$ mapping
-matrix (warp).
-@param motionType parameter, specifying the type of motion:
- -   **MOTION_TRANSLATION** sets a translational motion model; warpMatrix is
-\f$2\times 3\f$ with the first \f$2\times 2\f$ part being the unity matrix and
-the rest two parameters being estimated.
- -   **MOTION_EUCLIDEAN** sets a Euclidean (rigid) transformation as motion
-model; three parameters are estimated; warpMatrix is \f$2\times 3\f$.
- -   **MOTION_AFFINE** sets an affine motion model (DEFAULT); six parameters are
-estimated; warpMatrix is \f$2\times 3\f$.
- -   **MOTION_HOMOGRAPHY** sets a homography as a motion model; eight parameters
-are estimated;\`warpMatrix\` is \f$3\times 3\f$.
-@param criteria parameter, specifying the termination criteria of the ECC
-algorithm; criteria.epsilon defines the threshold of the increment in the
-correlation coefficient between two iterations (a negative criteria.epsilon
-makes criteria.maxcount the only termination criterion). Default values are
-shown in the declaration above.
-@param inputMask An optional mask to indicate valid values of inputImage.
-@param gaussFiltSize An optional value indicating size of gaussian blur filter;
-(DEFAULT: 5)
-
-The function estimates the optimum transformation (warpMatrix) with respect to
-ECC criterion
-(@cite EP08), that is
-
-\f[\texttt{warpMatrix} = \arg\max_{W}
-\texttt{ECC}(\texttt{templateImage}(x,y),\texttt{inputImage}(x',y'))\f]
-
-where
-
-\f[\begin{bmatrix} x' \\ y' \end{bmatrix} = W \cdot \begin{bmatrix} x \\ y \\ 1
-\end{bmatrix}\f]
-
-(the equation holds with homogeneous coordinates for homography). It returns the
-final enhanced correlation coefficient, that is the correlation coefficient
-between the template image and the final warped input image. When a \f$3\times
-3\f$ matrix is given with motionType =0, 1 or 2, the third row is ignored.
-
-Unlike findHomography and estimateRigidTransform, the function findTransformECC
-implements an area-based alignment that builds on intensity similarities. In
-essence, the function updates the initial transformation that roughly aligns the
-images. If this information is missing, the identity warp (unity matrix) is used
-as an initialization. Note that if images undergo strong
-displacements/rotations, an initial transformation that roughly aligns the
-images is necessary (e.g., a simple euclidean/similarity transform that allows
-for the images showing the same image content approximately). Use inverse
-warping in the second image to take an image close to the first one, i.e. use
-the flag WARP_INVERSE_MAP with warpAffine or warpPerspective. See also the
-OpenCV sample image_alignment.cpp that demonstrates the use of the function.
-Note that the function throws an exception if algorithm does not converges.
-
-@sa
-computeECC, estimateAffine2D, estimateAffinePartial2D, findHomography
- */
-CV_EXPORTS_W double findTransformECC(InputArray templateImage,
-                                     InputArray inputImage,
-                                     InputOutputArray warpMatrix,
-                                     int motionType, TermCriteria criteria,
-                                     InputArray inputMask, int gaussFiltSize);
-
-/** @overload */
-CV_EXPORTS_W
-double findTransformECC(InputArray templateImage, InputArray inputImage,
-                        InputOutputArray warpMatrix,
-                        int motionType = MOTION_AFFINE,
-                        TermCriteria criteria = TermCriteria(
-                            TermCriteria::COUNT + TermCriteria::EPS, 50, 0.001),
-                        InputArray inputMask = noArray());
-
-/** @example samples/cpp/kalman.cpp
-An example using the standard Kalman filter
-*/
-
-/** @brief Kalman filter class.
-
-The class implements a standard Kalman filter
-<http://en.wikipedia.org/wiki/Kalman_filter>,
-@cite Welch95 . However, you can modify transitionMatrix, controlMatrix, and
-measurementMatrix to get an extended Kalman filter functionality.
-@note In C API when CvKalman\* kalmanFilter structure is not needed anymore, it
-should be released with cvReleaseKalman(&kalmanFilter)
- */
-class CV_EXPORTS_W KalmanFilter {
-public:
-  CV_WRAP KalmanFilter();
-  /** @overload
-  @param dynamParams Dimensionality of the state.
-  @param measureParams Dimensionality of the measurement.
-  @param controlParams Dimensionality of the control vector.
-  @param type Type of the created matrices that should be CV_32F or CV_64F.
-  */
-  CV_WRAP KalmanFilter(int dynamParams, int measureParams,
-                       int controlParams = 0, int type = CV_32F);
-
-  /** @brief Re-initializes Kalman filter. The previous content is destroyed.
-
-  @param dynamParams Dimensionality of the state.
-  @param measureParams Dimensionality of the measurement.
-  @param controlParams Dimensionality of the control vector.
-  @param type Type of the created matrices that should be CV_32F or CV_64F.
-   */
-  void init(int dynamParams, int measureParams, int controlParams = 0,
-            int type = CV_32F);
-
-  /** @brief Computes a predicted state.
-
-  @param control The optional input control
-   */
-  CV_WRAP const Mat &predict(const Mat &control = Mat());
-
-  /** @brief Updates the predicted state from the measurement.
-
-  @param measurement The measured system parameters
-   */
-  CV_WRAP const Mat &correct(const Mat &measurement);
-
-  CV_PROP_RW Mat statePre; //!< predicted state (x'(k)): x(k)=A*x(k-1)+B*u(k)
-  CV_PROP_RW Mat
-      statePost; //!< corrected state (x(k)): x(k)=x'(k)+K(k)*(z(k)-H*x'(k))
-  CV_PROP_RW Mat transitionMatrix; //!< state transition matrix (A)
-  CV_PROP_RW Mat
-      controlMatrix; //!< control matrix (B) (not used if there is no control)
-  CV_PROP_RW Mat measurementMatrix; //!< measurement matrix (H)
-  CV_PROP_RW Mat processNoiseCov;   //!< process noise covariance matrix (Q)
-  CV_PROP_RW Mat
-      measurementNoiseCov;    //!< measurement noise covariance matrix (R)
-  CV_PROP_RW Mat errorCovPre; //!< priori error estimate covariance matrix
-                              //!< (P'(k)): P'(k)=A*P(k-1)*At + Q)*/
-  CV_PROP_RW Mat
-      gain; //!< Kalman gain matrix (K(k)): K(k)=P'(k)*Ht*inv(H*P'(k)*Ht+R)
-  CV_PROP_RW Mat errorCovPost; //!< posteriori error estimate covariance matrix
-                               //!< (P(k)): P(k)=(I-K(k)*H)*P'(k)
-
-  // temporary matrices
-  Mat temp1;
-  Mat temp2;
-  Mat temp3;
-  Mat temp4;
-  Mat temp5;
-};
-
-/** @brief Read a .flo file
-
- @param path Path to the file to be loaded
-
- The function readOpticalFlow loads a flow field from a file and returns it as a
- single matrix. Resulting Mat has a type CV_32FC2 - floating-point, 2-channel.
- First channel corresponds to the flow in the horizontal direction (u), second -
- vertical (v).
- */
-CV_EXPORTS_W Mat readOpticalFlow(const String &path);
-/** @brief Write a .flo to disk
-
- @param path Path to the file to be written
- @param flow Flow field to be stored
-
- The function stores a flow field in a file, returns true on success, false
- otherwise. The flow field must be a 2-channel, floating-point matrix
- (CV_32FC2). First channel corresponds to the flow in the horizontal direction
- (u), second - vertical (v).
- */
-CV_EXPORTS_W bool writeOpticalFlow(const String &path, InputArray flow);
-
-/**
-   Base class for dense optical flow algorithms
-*/
-class CV_EXPORTS_W DenseOpticalFlow : public Algorithm {
-public:
-  /** @brief Calculates an optical flow.
-
-  @param I0 first 8-bit single-channel input image.
-  @param I1 second input image of the same size and the same type as prev.
-  @param flow computed flow image that has the same size as prev and type
-  CV_32FC2.
-   */
-  CV_WRAP virtual void calc(InputArray I0, InputArray I1,
-                            InputOutputArray flow) = 0;
-  /** @brief Releases all inner buffers.
-   */
-  CV_WRAP virtual void collectGarbage() = 0;
-};
-
-/** @brief Base interface for sparse optical flow algorithms.
- */
-class CV_EXPORTS_W SparseOpticalFlow : public Algorithm {
-public:
-  /** @brief Calculates a sparse optical flow.
-
-  @param prevImg First input image.
-  @param nextImg Second input image of the same size and the same type as
-  prevImg.
-  @param prevPts Vector of 2D points for which the flow needs to be found.
-  @param nextPts Output vector of 2D points containing the calculated new
-  positions of input features in the second image.
-  @param status Output status vector. Each element of the vector is set to 1 if
-  the flow for the corresponding features has been found. Otherwise, it is set
-  to 0.
-  @param err Optional output vector that contains error response for each point
-  (inverse confidence).
-   */
-  CV_WRAP virtual void calc(InputArray prevImg, InputArray nextImg,
-                            InputArray prevPts, InputOutputArray nextPts,
-                            OutputArray status,
-                            OutputArray err = cv::noArray()) = 0;
-};
-
-/** @brief Class computing a dense optical flow using the Gunnar Farneback's
- * algorithm.
- */
-class CV_EXPORTS_W FarnebackOpticalFlow : public DenseOpticalFlow {
-public:
-  CV_WRAP virtual int getNumLevels() const = 0;
-  CV_WRAP virtual void setNumLevels(int numLevels) = 0;
-
-  CV_WRAP virtual double getPyrScale() const = 0;
-  CV_WRAP virtual void setPyrScale(double pyrScale) = 0;
-
-  CV_WRAP virtual bool getFastPyramids() const = 0;
-  CV_WRAP virtual void setFastPyramids(bool fastPyramids) = 0;
-
-  CV_WRAP virtual int getWinSize() const = 0;
-  CV_WRAP virtual void setWinSize(int winSize) = 0;
-
-  CV_WRAP virtual int getNumIters() const = 0;
-  CV_WRAP virtual void setNumIters(int numIters) = 0;
-
-  CV_WRAP virtual int getPolyN() const = 0;
-  CV_WRAP virtual void setPolyN(int polyN) = 0;
-
-  CV_WRAP virtual double getPolySigma() const = 0;
-  CV_WRAP virtual void setPolySigma(double polySigma) = 0;
-
-  CV_WRAP virtual int getFlags() const = 0;
-  CV_WRAP virtual void setFlags(int flags) = 0;
-
-  CV_WRAP static Ptr<FarnebackOpticalFlow>
-  create(int numLevels = 5, double pyrScale = 0.5, bool fastPyramids = false,
-         int winSize = 13, int numIters = 10, int polyN = 5,
-         double polySigma = 1.1, int flags = 0);
-};
-
-/** @brief Variational optical flow refinement
-
-This class implements variational refinement of the input flow field, i.e.
-it uses input flow to initialize the minimization of the following functional:
-\f$E(U) = \int_{\Omega} \delta \Psi(E_I) + \gamma \Psi(E_G) + \alpha \Psi(E_S)
-\f$, where \f$E_I,E_G,E_S\f$ are color constancy, gradient constancy and
-smoothness terms respectively. \f$\Psi(s^2)=\sqrt{s^2+\epsilon^2}\f$ is a robust
-penalizer to limit the influence of outliers. A complete formulation and a
-description of the minimization procedure can be found in @cite Brox2004
-*/
-class CV_EXPORTS_W VariationalRefinement : public DenseOpticalFlow {
-public:
-  /** @brief @ref calc function overload to handle separate horizontal (u) and
-  vertical (v) flow components (to avoid extra splits/merges) */
-  CV_WRAP virtual void calcUV(InputArray I0, InputArray I1,
-                              InputOutputArray flow_u,
-                              InputOutputArray flow_v) = 0;
-
-  /** @brief Number of outer (fixed-point) iterations in the minimization
-  procedure.
-  @see setFixedPointIterations */
-  CV_WRAP virtual int getFixedPointIterations() const = 0;
-  /** @copybrief getFixedPointIterations @see getFixedPointIterations */
-  CV_WRAP virtual void setFixedPointIterations(int val) = 0;
-
-  /** @brief Number of inner successive over-relaxation (SOR) iterations
-      in the minimization procedure to solve the respective linear system.
-  @see setSorIterations */
-  CV_WRAP virtual int getSorIterations() const = 0;
-  /** @copybrief getSorIterations @see getSorIterations */
-  CV_WRAP virtual void setSorIterations(int val) = 0;
-
-  /** @brief Relaxation factor in SOR
-  @see setOmega */
-  CV_WRAP virtual float getOmega() const = 0;
-  /** @copybrief getOmega @see getOmega */
-  CV_WRAP virtual void setOmega(float val) = 0;
-
-  /** @brief Weight of the smoothness term
-  @see setAlpha */
-  CV_WRAP virtual float getAlpha() const = 0;
-  /** @copybrief getAlpha @see getAlpha */
-  CV_WRAP virtual void setAlpha(float val) = 0;
-
-  /** @brief Weight of the color constancy term
-  @see setDelta */
-  CV_WRAP virtual float getDelta() const = 0;
-  /** @copybrief getDelta @see getDelta */
-  CV_WRAP virtual void setDelta(float val) = 0;
-
-  /** @brief Weight of the gradient constancy term
-  @see setGamma */
-  CV_WRAP virtual float getGamma() const = 0;
-  /** @copybrief getGamma @see getGamma */
-  CV_WRAP virtual void setGamma(float val) = 0;
-
-  /** @brief Norm value shift for robust penalizer
-  @see setEpsilon */
-  CV_WRAP virtual float getEpsilon() const = 0;
-  /** @copybrief getEpsilon @see getEpsilon */
-  CV_WRAP virtual void setEpsilon(float val) = 0;
-
-  /** @brief Creates an instance of VariationalRefinement
-   */
-  CV_WRAP static Ptr<VariationalRefinement> create();
-};
-
-/** @brief DIS optical flow algorithm.
-
-This class implements the Dense Inverse Search (DIS) optical flow algorithm.
-More details about the algorithm can be found at @cite Kroeger2016 . Includes
-three presets with preselected parameters to provide reasonable trade-off
-between speed and quality. However, even the slowest preset is still relatively
-fast, use DeepFlow if you need better quality and don't care about speed.
-
-This implementation includes several additional features compared to the
-algorithm described in the paper, including spatial propagation of flow vectors
-(@ref getUseSpatialPropagation), as well as an option to utilize an initial flow
-approximation passed to @ref calc (which is, essentially, temporal propagation,
-if the previous frame's flow field is passed).
-*/
-class CV_EXPORTS_W DISOpticalFlow : public DenseOpticalFlow {
-public:
-  enum { PRESET_ULTRAFAST = 0, PRESET_FAST = 1, PRESET_MEDIUM = 2 };
-
-  /** @brief Finest level of the Gaussian pyramid on which the flow is computed
-     (zero level corresponds to the original image resolution). The final flow
-     is obtained by bilinear upscaling.
-      @see setFinestScale */
-  CV_WRAP virtual int getFinestScale() const = 0;
-  /** @copybrief getFinestScale @see getFinestScale */
-  CV_WRAP virtual void setFinestScale(int val) = 0;
-
-  /** @brief Size of an image patch for matching (in pixels). Normally, default
-     8x8 patches work well enough in most cases.
-      @see setPatchSize */
-  CV_WRAP virtual int getPatchSize() const = 0;
-  /** @copybrief getPatchSize @see getPatchSize */
-  CV_WRAP virtual void setPatchSize(int val) = 0;
-
-  /** @brief Stride between neighbor patches. Must be less than patch size.
-     Lower values correspond to higher flow quality.
-      @see setPatchStride */
-  CV_WRAP virtual int getPatchStride() const = 0;
-  /** @copybrief getPatchStride @see getPatchStride */
-  CV_WRAP virtual void setPatchStride(int val) = 0;
-
-  /** @brief Maximum number of gradient descent iterations in the patch inverse
-     search stage. Higher values may improve quality in some cases.
-      @see setGradientDescentIterations */
-  CV_WRAP virtual int getGradientDescentIterations() const = 0;
-  /** @copybrief getGradientDescentIterations @see getGradientDescentIterations
-   */
-  CV_WRAP virtual void setGradientDescentIterations(int val) = 0;
-
-  /** @brief Number of fixed point iterations of variational refinement per
-  scale. Set to zero to disable variational refinement completely. Higher values
-  will typically result in more smooth and high-quality flow.
-  @see setGradientDescentIterations */
-  CV_WRAP virtual int getVariationalRefinementIterations() const = 0;
-  /** @copybrief getGradientDescentIterations @see getGradientDescentIterations
-   */
-  CV_WRAP virtual void setVariationalRefinementIterations(int val) = 0;
-
-  /** @brief Weight of the smoothness term
-  @see setVariationalRefinementAlpha */
-  CV_WRAP virtual float getVariationalRefinementAlpha() const = 0;
-  /** @copybrief getVariationalRefinementAlpha @see
-   * getVariationalRefinementAlpha */
-  CV_WRAP virtual void setVariationalRefinementAlpha(float val) = 0;
-
-  /** @brief Weight of the color constancy term
-  @see setVariationalRefinementDelta */
-  CV_WRAP virtual float getVariationalRefinementDelta() const = 0;
-  /** @copybrief getVariationalRefinementDelta @see
-   * getVariationalRefinementDelta */
-  CV_WRAP virtual void setVariationalRefinementDelta(float val) = 0;
-
-  /** @brief Weight of the gradient constancy term
-  @see setVariationalRefinementGamma */
-  CV_WRAP virtual float getVariationalRefinementGamma() const = 0;
-  /** @copybrief getVariationalRefinementGamma @see
-   * getVariationalRefinementGamma */
-  CV_WRAP virtual void setVariationalRefinementGamma(float val) = 0;
-
-  /** @brief Norm value shift for robust penalizer
-  @see setVariationalRefinementEpsilon */
-  CV_WRAP virtual float getVariationalRefinementEpsilon() const = 0;
-  /** @copybrief getVariationalRefinementEpsilon @see
-   * getVariationalRefinementEpsilon */
-  CV_WRAP virtual void setVariationalRefinementEpsilon(float val) = 0;
-
-  /** @brief Whether to use mean-normalization of patches when computing patch
-  distance. It is turned on by default as it typically provides a noticeable
-  quality boost because of increased robustness to illumination variations. Turn
-  it off if you are certain that your sequence doesn't contain any changes in
-  illumination.
-  @see setUseMeanNormalization */
-  CV_WRAP virtual bool getUseMeanNormalization() const = 0;
-  /** @copybrief getUseMeanNormalization @see getUseMeanNormalization */
-  CV_WRAP virtual void setUseMeanNormalization(bool val) = 0;
-
-  /** @brief Whether to use spatial propagation of good optical flow vectors.
-  This option is turned on by default, as it tends to work better on average and
-  can sometimes help recover from major errors introduced by the coarse-to-fine
-  scheme employed by the DIS optical flow algorithm. Turning this option off can
-  make the output flow field a bit smoother, however.
-  @see setUseSpatialPropagation */
-  CV_WRAP virtual bool getUseSpatialPropagation() const = 0;
-  /** @copybrief getUseSpatialPropagation @see getUseSpatialPropagation */
-  CV_WRAP virtual void setUseSpatialPropagation(bool val) = 0;
-
-  /** @brief Creates an instance of DISOpticalFlow
-
-  @param preset one of PRESET_ULTRAFAST, PRESET_FAST and PRESET_MEDIUM
-  */
-  CV_WRAP static Ptr<DISOpticalFlow>
-  create(int preset = DISOpticalFlow::PRESET_FAST);
-};
-
-/** @brief Class used for calculating a sparse optical flow.
-
-The class can calculate an optical flow for a sparse feature set using the
-iterative Lucas-Kanade method with pyramids.
-
-@sa calcOpticalFlowPyrLK
-
-*/
-class CV_EXPORTS_W SparsePyrLKOpticalFlow : public SparseOpticalFlow {
-public:
-  CV_WRAP virtual Size getWinSize() const = 0;
-  CV_WRAP virtual void setWinSize(Size winSize) = 0;
-
-  CV_WRAP virtual int getMaxLevel() const = 0;
-  CV_WRAP virtual void setMaxLevel(int maxLevel) = 0;
-
-  CV_WRAP virtual TermCriteria getTermCriteria() const = 0;
-  CV_WRAP virtual void setTermCriteria(TermCriteria &crit) = 0;
-
-  CV_WRAP virtual int getFlags() const = 0;
-  CV_WRAP virtual void setFlags(int flags) = 0;
-
-  CV_WRAP virtual double getMinEigThreshold() const = 0;
-  CV_WRAP virtual void setMinEigThreshold(double minEigThreshold) = 0;
-
-  CV_WRAP static Ptr<SparsePyrLKOpticalFlow> create(
-      Size winSize = Size(21, 21), int maxLevel = 3,
-      TermCriteria crit = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS,
-                                       30, 0.01),
-      int flags = 0, double minEigThreshold = 1e-4);
-};
-
-/** @brief Base abstract class for the long-term tracker
- */
-class CV_EXPORTS_W Tracker {
-protected:
-  Tracker();
-
-public:
-  virtual ~Tracker();
-
-  /** @brief Initialize the tracker with a known bounding box that surrounded
-  the target
-  @param image The initial frame
-  @param boundingBox The initial bounding box
-  */
-  CV_WRAP virtual void init(InputArray image, const Rect &boundingBox) = 0;
-
-  /** @brief Update the tracker, find the new most likely bounding box for the
-  target
-  @param image The current frame
-  @param boundingBox The bounding box that represent the new target location, if
-  true was returned, not modified otherwise
-
-  @return True means that target was located and false means that tracker cannot
-  locate target in current frame. Note, that latter *does not* imply that
-  tracker has failed, maybe target is indeed missing from the frame (say, out of
-  sight)
-  */
-  CV_WRAP virtual bool update(InputArray image, CV_OUT Rect &boundingBox) = 0;
-};
-
-/** @brief The MIL algorithm trains a classifier in an online manner to separate
-the object from the background.
-
-Multiple Instance Learning avoids the drift problem for a robust tracking. The
-implementation is based on @cite MIL .
-
-Original code can be found here
-<http://vision.ucsd.edu/~bbabenko/project_miltrack.shtml>
- */
-class CV_EXPORTS_W TrackerMIL : public Tracker {
-protected:
-  TrackerMIL(); // use ::create()
-public:
-  virtual ~TrackerMIL() CV_OVERRIDE;
-
-  struct CV_EXPORTS_W_SIMPLE Params {
-    CV_WRAP Params();
-    // parameters for sampler
-    CV_PROP_RW float samplerInitInRadius; //!< radius for gathering positive
-                                          //!< instances during init
-    CV_PROP_RW int
-        samplerInitMaxNegNum; //!< # negative samples to use during init
-    CV_PROP_RW float samplerSearchWinSize; //!< size of search window
-    CV_PROP_RW float samplerTrackInRadius; //!< radius for gathering positive
-                                           //!< instances during tracking
-    CV_PROP_RW int
-        samplerTrackMaxPosNum; //!< # positive samples to use during tracking
-    CV_PROP_RW int
-        samplerTrackMaxNegNum; //!< # negative samples to use during tracking
-    CV_PROP_RW int featureSetNumFeatures; //!< # features
-  };
-
-  /** @brief Create MIL tracker instance
-   *  @param parameters MIL parameters TrackerMIL::Params
-   */
-  static CV_WRAP Ptr<TrackerMIL>
-  create(const TrackerMIL::Params &parameters = TrackerMIL::Params());
-
-  // void init(InputArray image, const Rect& boundingBox) CV_OVERRIDE;
-  // bool update(InputArray image, CV_OUT Rect& boundingBox) CV_OVERRIDE;
-};
-
-/** @brief the GOTURN (Generic Object Tracking Using Regression Networks)
- * tracker
- *
- *  GOTURN (@cite GOTURN) is kind of trackers based on Convolutional Neural
- * Networks (CNN). While taking all advantages of CNN trackers, GOTURN is much
- * faster due to offline training without online fine-tuning nature. GOTURN
- * tracker addresses the problem of single target tracking: given a bounding box
- * label of an object in the first frame of the video, we track that object
- * through the rest of the video. NOTE: Current method of GOTURN does not handle
- * occlusions; however, it is fairly robust to viewpoint changes, lighting
- * changes, and deformations. Inputs of GOTURN are two RGB patches representing
- * Target and Search patches resized to 227x227. Outputs of GOTURN are predicted
- * bounding box coordinates, relative to Search patch coordinate system, in
- * format X1,Y1,X2,Y2. Original paper is here:
- * <http://davheld.github.io/GOTURN/GOTURN.pdf> As long as original authors
- * implementation: <https://github.com/davheld/GOTURN#train-the-tracker>
- *  Implementation of training algorithm is placed in separately here due to
- * 3d-party dependencies: <https://github.com/Auron-X/GOTURN_Training_Toolkit>
- *  GOTURN architecture goturn.prototxt and trained model goturn.caffemodel are
- * accessible on opencv_extra GitHub repository.
- */
-class CV_EXPORTS_W TrackerGOTURN : public Tracker {
-protected:
-  TrackerGOTURN(); // use ::create()
-public:
-  virtual ~TrackerGOTURN() CV_OVERRIDE;
-
-  struct CV_EXPORTS_W_SIMPLE Params {
-    CV_WRAP Params();
-    CV_PROP_RW std::string modelTxt;
-    CV_PROP_RW std::string modelBin;
-  };
-
-  /** @brief Constructor
-  @param parameters GOTURN parameters TrackerGOTURN::Params
-  */
-  static CV_WRAP Ptr<TrackerGOTURN>
-  create(const TrackerGOTURN::Params &parameters = TrackerGOTURN::Params());
-
-  // void init(InputArray image, const Rect& boundingBox) CV_OVERRIDE;
-  // bool update(InputArray image, CV_OUT Rect& boundingBox) CV_OVERRIDE;
-};
-
-class CV_EXPORTS_W TrackerDaSiamRPN : public Tracker {
-protected:
-  TrackerDaSiamRPN(); // use ::create()
-public:
-  virtual ~TrackerDaSiamRPN() CV_OVERRIDE;
-
-  struct CV_EXPORTS_W_SIMPLE Params {
-    CV_WRAP Params();
-    CV_PROP_RW std::string model;
-    CV_PROP_RW std::string kernel_cls1;
-    CV_PROP_RW std::string kernel_r1;
-    CV_PROP_RW int backend;
-    CV_PROP_RW int target;
-  };
-
-  /** @brief Constructor
-  @param parameters DaSiamRPN parameters TrackerDaSiamRPN::Params
-  */
-  static CV_WRAP Ptr<TrackerDaSiamRPN> create(
-      const TrackerDaSiamRPN::Params &parameters = TrackerDaSiamRPN::Params());
-
-  /** @brief Return tracking score
-   */
-  CV_WRAP virtual float getTrackingScore() = 0;
-
-  // void init(InputArray image, const Rect& boundingBox) CV_OVERRIDE;
-  // bool update(InputArray image, CV_OUT Rect& boundingBox) CV_OVERRIDE;
-};
-
-/** @brief the Nano tracker is a super lightweight dnn-based general object
- * tracking.
- *
- *  Nano tracker is much faster and extremely lightweight due to special model
- * structure, the whole model size is about 1.9 MB. Nano tracker needs two
- * models: one for feature extraction (backbone) and the another for
- * localization (neckhead). Model download link:
- * https://github.com/HonglinChu/SiamTrackers/tree/master/NanoTrack/models/nanotrackv2
- *  Original repo is here: https://github.com/HonglinChu/NanoTrack
- *  Author: HongLinChu, 1628464345@qq.com
- */
-class CV_EXPORTS_W TrackerNano : public Tracker {
-protected:
-  TrackerNano(); // use ::create()
-public:
-  virtual ~TrackerNano() CV_OVERRIDE;
-
-  struct CV_EXPORTS_W_SIMPLE Params {
-    CV_WRAP Params();
-    CV_PROP_RW std::string backbone;
-    CV_PROP_RW std::string neckhead;
-    CV_PROP_RW int backend;
-    CV_PROP_RW int target;
-  };
-
-  /** @brief Constructor
-  @param parameters NanoTrack parameters TrackerNano::Params
-  */
-  static CV_WRAP Ptr<TrackerNano>
-  create(const TrackerNano::Params &parameters = TrackerNano::Params());
-
-  /** @brief Return tracking score
-   */
-  CV_WRAP virtual float getTrackingScore() = 0;
-
-  // void init(InputArray image, const Rect& boundingBox) CV_OVERRIDE;
-  // bool update(InputArray image, CV_OUT Rect& boundingBox) CV_OVERRIDE;
-};
-
-/** @brief the VIT tracker is a super lightweight dnn-based general object
- * tracking.
- *
- *  VIT tracker is much faster and extremely lightweight due to special model
- * structure, the model file is about 767KB. Model download link:
- * https://github.com/opencv/opencv_zoo/tree/main/models/object_tracking_vittrack
- *  Author: PengyuLiu, 1872918507@qq.com
- */
-class CV_EXPORTS_W TrackerVit : public Tracker {
-protected:
-  TrackerVit(); // use ::create()
-public:
-  virtual ~TrackerVit() CV_OVERRIDE;
-
-  struct CV_EXPORTS_W_SIMPLE Params {
-    CV_WRAP Params();
-    CV_PROP_RW std::string net;
-    CV_PROP_RW int backend;
-    CV_PROP_RW int target;
-    CV_PROP_RW Scalar meanvalue;
-    CV_PROP_RW Scalar stdvalue;
-    CV_PROP_RW float tracking_score_threshold;
-  };
-
-  /** @brief Constructor
-  @param parameters vit tracker parameters TrackerVit::Params
-  */
-  static CV_WRAP Ptr<TrackerVit>
-  create(const TrackerVit::Params &parameters = TrackerVit::Params());
-
-  /** @brief Return tracking score
-   */
-  CV_WRAP virtual float getTrackingScore() = 0;
-
-  // void init(InputArray image, const Rect& boundingBox) CV_OVERRIDE;
-  // bool update(InputArray image, CV_OUT Rect& boundingBox) CV_OVERRIDE;
-};
-
-//! @} video_track
-
-} // namespace cv
-
-#endif
diff --git a/packages/react-native-executorch/third-party/include/opencv2/video/video.hpp b/packages/react-native-executorch/third-party/include/opencv2/video/video.hpp
deleted file mode 100644
index 74f106762e..0000000000
--- a/packages/react-native-executorch/third-party/include/opencv2/video/video.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this
-license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                          License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without
-modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright
-notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote
-products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is"
-and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are
-disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any
-direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifdef __OPENCV_BUILD
-#error this is a compatibility header which should not be used inside the OpenCV library
-#endif
-
-#include "opencv2/video.hpp"
diff --git a/packages/react-native-executorch/third-party/include/pthreadpool/pthreadpool.h b/packages/react-native-executorch/third-party/include/pthreadpool/pthreadpool.h
deleted file mode 100644
index 3219789db0..0000000000
--- a/packages/react-native-executorch/third-party/include/pthreadpool/pthreadpool.h
+++ /dev/null
@@ -1,3350 +0,0 @@
-// Copyright (c) 2017 Facebook Inc.
-// Copyright (c) 2015-2017 Georgia Institute of Technology
-// All rights reserved.
-//
-// Copyright 2019 Google LLC
-//
-// This source code is licensed under the BSD-style license found in the
-// LICENSE file in the root directory of this source tree.
-
-#ifndef __PTHREADPOOL_INCLUDE_PTHREADPOOL_H_
-#define __PTHREADPOOL_INCLUDE_PTHREADPOOL_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-typedef struct pthreadpool *pthreadpool_t;
-
-typedef void (*pthreadpool_task_1d_t)(void *, size_t);
-typedef void (*pthreadpool_task_1d_with_thread_t)(void *, size_t, size_t);
-typedef void (*pthreadpool_task_1d_tile_1d_t)(void *, size_t, size_t);
-typedef void (*pthreadpool_task_1d_tile_1d_dynamic_t)(void *, size_t, size_t);
-typedef void (*pthreadpool_task_1d_tile_1d_dynamic_with_id_t)(void *, uint32_t,
-                                                              size_t, size_t);
-typedef void (*pthreadpool_task_2d_t)(void *, size_t, size_t);
-typedef void (*pthreadpool_task_2d_with_thread_t)(void *, size_t, size_t,
-                                                  size_t);
-typedef void (*pthreadpool_task_2d_tile_1d_t)(void *, size_t, size_t, size_t);
-typedef void (*pthreadpool_task_2d_tile_1d_dynamic_t)(void *, size_t, size_t,
-                                                      size_t);
-typedef void (*pthreadpool_task_2d_tile_2d_t)(void *, size_t, size_t, size_t,
-                                              size_t);
-typedef void (*pthreadpool_task_2d_tile_2d_dynamic_t)(void *, size_t, size_t,
-                                                      size_t, size_t);
-typedef void (*pthreadpool_task_3d_t)(void *, size_t, size_t, size_t);
-typedef void (*pthreadpool_task_3d_tile_1d_t)(void *, size_t, size_t, size_t,
-                                              size_t);
-typedef void (*pthreadpool_task_3d_tile_1d_with_thread_t)(void *, size_t,
-                                                          size_t, size_t,
-                                                          size_t, size_t);
-typedef void (*pthreadpool_task_3d_tile_1d_dynamic_t)(void *, size_t, size_t,
-                                                      size_t, size_t);
-typedef void (*pthreadpool_task_3d_tile_2d_t)(void *, size_t, size_t, size_t,
-                                              size_t, size_t);
-typedef void (*pthreadpool_task_3d_tile_2d_dynamic_t)(void *, size_t, size_t,
-                                                      size_t, size_t, size_t);
-typedef void (*pthreadpool_task_4d_t)(void *, size_t, size_t, size_t, size_t);
-typedef void (*pthreadpool_task_4d_tile_1d_t)(void *, size_t, size_t, size_t,
-                                              size_t, size_t);
-typedef void (*pthreadpool_task_4d_tile_2d_t)(void *, size_t, size_t, size_t,
-                                              size_t, size_t, size_t);
-typedef void (*pthreadpool_task_4d_tile_2d_dynamic_t)(void *, size_t, size_t,
-                                                      size_t, size_t, size_t,
-                                                      size_t);
-typedef void (*pthreadpool_task_5d_t)(void *, size_t, size_t, size_t, size_t,
-                                      size_t);
-typedef void (*pthreadpool_task_5d_tile_1d_t)(void *, size_t, size_t, size_t,
-                                              size_t, size_t, size_t);
-typedef void (*pthreadpool_task_5d_tile_2d_t)(void *, size_t, size_t, size_t,
-                                              size_t, size_t, size_t, size_t);
-typedef void (*pthreadpool_task_6d_t)(void *, size_t, size_t, size_t, size_t,
-                                      size_t, size_t);
-typedef void (*pthreadpool_task_6d_tile_1d_t)(void *, size_t, size_t, size_t,
-                                              size_t, size_t, size_t, size_t);
-typedef void (*pthreadpool_task_6d_tile_2d_t)(void *, size_t, size_t, size_t,
-                                              size_t, size_t, size_t, size_t,
-                                              size_t);
-
-typedef void (*pthreadpool_task_1d_with_id_t)(void *, uint32_t, size_t);
-typedef void (*pthreadpool_task_2d_tile_1d_with_id_t)(void *, uint32_t, size_t,
-                                                      size_t, size_t);
-typedef void (*pthreadpool_task_2d_tile_1d_dynamic_with_id_t)(void *, uint32_t,
-                                                              size_t, size_t,
-                                                              size_t);
-typedef void (*pthreadpool_task_2d_tile_2d_with_id_t)(void *, uint32_t, size_t,
-                                                      size_t, size_t, size_t);
-typedef void (*pthreadpool_task_2d_tile_2d_dynamic_with_id_t)(void *, uint32_t,
-                                                              size_t, size_t,
-                                                              size_t, size_t);
-typedef void (*pthreadpool_task_3d_tile_1d_with_id_t)(void *, uint32_t, size_t,
-                                                      size_t, size_t, size_t);
-typedef void (*pthreadpool_task_3d_tile_1d_dynamic_with_id_t)(void *, uint32_t,
-                                                              size_t, size_t,
-                                                              size_t, size_t);
-typedef void (*pthreadpool_task_3d_tile_2d_with_id_t)(void *, uint32_t, size_t,
-                                                      size_t, size_t, size_t,
-                                                      size_t);
-typedef void (*pthreadpool_task_3d_tile_2d_dynamic_with_id_t)(void *, uint32_t,
-                                                              size_t, size_t,
-                                                              size_t, size_t,
-                                                              size_t);
-typedef void (*pthreadpool_task_4d_tile_2d_with_id_t)(void *, uint32_t, size_t,
-                                                      size_t, size_t, size_t,
-                                                      size_t, size_t);
-typedef void (*pthreadpool_task_4d_tile_2d_dynamic_with_id_t)(void *, uint32_t,
-                                                              size_t, size_t,
-                                                              size_t, size_t,
-                                                              size_t, size_t);
-
-typedef void (*pthreadpool_task_1d_tile_1d_dynamic_with_id_with_thread_t)(
-    void *, uint32_t, size_t, size_t, size_t);
-typedef void (*pthreadpool_task_2d_tile_1d_with_id_with_thread_t)(
-    void *, uint32_t, size_t, size_t, size_t, size_t);
-typedef void (*pthreadpool_task_2d_tile_1d_dynamic_with_id_with_thread_t)(
-    void *, uint32_t, size_t, size_t, size_t, size_t);
-typedef void (*pthreadpool_task_3d_tile_1d_with_id_with_thread_t)(
-    void *, uint32_t, size_t, size_t, size_t, size_t, size_t);
-typedef void (*pthreadpool_task_3d_tile_1d_dynamic_with_id_with_thread_t)(
-    void *, uint32_t, size_t, size_t, size_t, size_t, size_t);
-
-/**
- * Disable support for denormalized numbers to the maximum extent possible for
- * the duration of the computation.
- *
- * Handling denormalized floating-point numbers is often implemented in
- * microcode, and incurs significant performance degradation. This hint
- * instructs the thread pool to disable support for denormalized numbers before
- * running the computation by manipulating architecture-specific control
- * registers, and restore the initial value of control registers after the
- * computation is complete. The thread pool temporary disables denormalized
- * numbers on all threads involved in the computation (i.e. the caller threads,
- * and potentially worker threads).
- *
- * Disabling denormalized numbers may have a small negative effect on results'
- * accuracy. As various architectures differ in capabilities to control
- * processing of denormalized numbers, using this flag may also hurt results'
- * reproducibility across different instruction set architectures.
- */
-#define PTHREADPOOL_FLAG_DISABLE_DENORMALS 0x00000001
-
-/**
- * Yield worker threads to the system scheduler after the operation is finished.
- *
- * Force workers to use kernel wait (instead of active spin-wait by default) for
- * new commands after this command is processed. This flag affects only the
- * immediate next operation on this thread pool. To make the thread pool always
- * use kernel wait, pass this flag to all parallelization functions.
- */
-#define PTHREADPOOL_FLAG_YIELD_WORKERS 0x00000002
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * Create a thread pool with the specified number of threads.
- *
- * @param  threads_count  the number of threads in the thread pool.
- *    A value of 0 has special interpretation: it creates a thread pool with as
- *    many threads as there are logical processors in the system.
- *
- * @returns  A pointer to an opaque thread pool object if the call is
- *    successful, or NULL pointer if the call failed.
- */
-pthreadpool_t pthreadpool_create(size_t threads_count);
-
-/**
- * Query the number of threads in a thread pool.
- *
- * @param  threadpool  the thread pool to query.
- *
- * @returns  The number of threads in the thread pool.
- */
-size_t pthreadpool_get_threads_count(pthreadpool_t threadpool);
-
-/**
- * Process items on a 1D grid.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range; i++)
- *     function(context, i);
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each item.
- * @param context     the first argument passed to the specified function.
- * @param range       the number of items on the 1D grid to process. The
- *    specified function will be called once for each item.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_1d(pthreadpool_t threadpool,
-                                pthreadpool_task_1d_t function, void *context,
-                                size_t range, uint32_t flags);
-
-/**
- * Process items on a 1D grid passing along the current thread id.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range; i++)
- *     function(context, thread_index, i);
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each item.
- * @param context     the first argument passed to the specified function.
- * @param range       the number of items on the 1D grid to process. The
- *    specified function will be called once for each item.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_1d_with_thread(
-    pthreadpool_t threadpool, pthreadpool_task_1d_with_thread_t function,
-    void *context, size_t range, uint32_t flags);
-
-/**
- * Process items on a 1D grid using a microarchitecture-aware task function.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   uint32_t uarch_index = cpuinfo_initialize() ?
- *       cpuinfo_get_current_uarch_index() : default_uarch_index;
- *   if (uarch_index > max_uarch_index) uarch_index = default_uarch_index;
- *   for (size_t i = 0; i < range; i++)
- *     function(context, uarch_index, i);
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool           the thread pool to use for parallelisation. If
- *    threadpool is NULL, all items are processed serially on the calling
- *    thread.
- * @param function             the function to call for each item.
- * @param context              the first argument passed to the specified
- *    function.
- * @param default_uarch_index  the microarchitecture index to use when
- *    pthreadpool is configured without cpuinfo, cpuinfo initialization failed,
- *    or index returned by cpuinfo_get_current_uarch_index() exceeds the
- *    max_uarch_index value.
- * @param max_uarch_index      the maximum microarchitecture index expected by
- *    the specified function. If the index returned by
- *    cpuinfo_get_current_uarch_index() exceeds this value, default_uarch_index
- *    will be used instead. default_uarch_index can exceed max_uarch_index.
- * @param range                the number of items on the 1D grid to process.
- *    The specified function will be called once for each item.
- * @param flags                a bitwise combination of zero or more optional
- *    flags (PTHREADPOOL_FLAG_DISABLE_DENORMALS or
- *    PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_1d_with_uarch(
-    pthreadpool_t threadpool, pthreadpool_task_1d_with_id_t function,
-    void *context, uint32_t default_uarch_index, uint32_t max_uarch_index,
-    size_t range, uint32_t flags);
-
-/**
- * Process items on a 1D grid with specified maximum tile size.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range; i += tile)
- *     function(context, i, min(range - i, tile));
- *
- * When the call returns, all items have been processed and the thread pool is
- * ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool,
- *    the calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each tile.
- * @param context     the first argument passed to the specified function.
- * @param range       the number of items on the 1D grid to process.
- * @param tile        the maximum number of items on the 1D grid to process in
- *    one function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_1d_tile_1d(pthreadpool_t threadpool,
-                                        pthreadpool_task_1d_tile_1d_t function,
-                                        void *context, size_t range,
-                                        size_t tile, uint32_t flags);
-
-/**
- * Process items on a 1D grid with specified prefered tile size.
- *
- * The function repeatedly calls
- *
- *   function(context, i, count)
- *
- * in parallel where `i` is in the range `[0, range)` and a multiple of the
- * provided @a tile and `count` is an integer multiple of @a tile unless `i
- * + count == range`.
- *
- * The `count`s are chosen such as to minimize the number of calls to @a
- * function while keeping the computation load balanced across all threads.
- *
- * When the call returns, all items have been processed and the thread pool is
- * ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool,
- *    the calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each interval of the given range.
- * @param context     the first argument passed to the specified function.
- * @param range       the number of items on the 1D grid to process.
- * @param tile        the preferred multiple number of items on the 1D grid to
- *     process in each function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_1d_tile_1d_dynamic(
-    pthreadpool_t threadpool, pthreadpool_task_1d_tile_1d_dynamic_t function,
-    void *context, size_t range, size_t tile, uint32_t flags);
-
-/**
- * Process items on a 1D grid with specified prefered tile size, passing along
- * the current thread id.
- *
- * The function repeatedly calls
- *
- *   function(context, thread_id, i, count)
- *
- * in parallel where `i` is in the range `[0, range)` and a multiple of the
- * provided @a tile and `count` is an integer multiple of @a tile unless `i
- * + count == range`.
- *
- * The `count`s are chosen such as to minimize the number of calls to @a
- * function while keeping the computation load balanced across all threads.
- *
- * When the call returns, all items have been processed and the thread pool is
- * ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool,
- *    the calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each interval of the given range.
- * @param context     the first argument passed to the specified function.
- * @param range       the number of items on the 1D grid to process.
- * @param tile        the preferred multiple number of items on the 1D grid to
- *     process in each function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_1d_tile_1d_dynamic_with_thread(
-    pthreadpool_t threadpool,
-    pthreadpool_task_1d_tile_1d_dynamic_with_id_t function, void *context,
-    size_t range, size_t tile, uint32_t flags);
-
-/**
- * Process items on a 1D grid with specified prefered tile size, passing along
- * the current uarch index and thread id.
- *
- * The function repeatedly calls
- *
- *   function(context, uarch_index, thread_id, i, count)
- *
- * in parallel where `i` is in the range `[0, range)` and a multiple of the
- * provided @a tile and `count` is an integer multiple of @a tile unless `i
- * + count == range`.
- *
- * The `count`s are chosen such as to minimize the number of calls to @a
- * function while keeping the computation load balanced across all threads.
- *
- * When the call returns, all items have been processed and the thread pool is
- * ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool,
- *    the calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each interval of the given range.
- * @param context     the first argument passed to the specified function.
- * @param range       the number of items on the 1D grid to process.
- * @param tile        the preferred multiple number of items on the 1D grid to
- *     process in each function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_1d_tile_1d_dynamic_with_uarch_with_thread(
-    pthreadpool_t threadpool,
-    pthreadpool_task_1d_tile_1d_dynamic_with_id_with_thread_t function,
-    void *context, uint32_t default_uarch_index, uint32_t max_uarch_index,
-    size_t range, size_t tile, uint32_t flags);
-
-/**
- * Process items on a 2D grid.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       function(context, i, j);
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each item.
- * @param context     the first argument passed to the specified function.
- * @param range_i     the number of items to process along the first dimension
- *    of the 2D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 2D grid.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_2d(pthreadpool_t threadpool,
-                                pthreadpool_task_2d_t function, void *context,
-                                size_t range_i, size_t range_j, uint32_t flags);
-
-/**
- * Process items on a 2D grid passing along the current thread id.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       function(context, thread_index, i, j);
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each item.
- * @param context     the first argument passed to the specified function.
- * @param range_i     the number of items to process along the first dimension
- *    of the 2D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 2D grid.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_2d_with_thread(
-    pthreadpool_t threadpool, pthreadpool_task_2d_with_thread_t function,
-    void *context, size_t range_i, size_t range_j, uint32_t flags);
-
-/**
- * Process items on a 2D grid with the specified maximum tile size along the
- * last grid dimension.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j += tile_j)
- *       function(context, i, j, min(range_j - j, tile_j));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each tile.
- * @param context     the first argument passed to the specified function.
- * @param range_i     the number of items to process along the first dimension
- *    of the 2D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 2D grid.
- * @param tile_j      the maximum number of items along the second dimension of
- *    the 2D grid to process in one function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_2d_tile_1d(pthreadpool_t threadpool,
-                                        pthreadpool_task_2d_tile_1d_t function,
-                                        void *context, size_t range_i,
-                                        size_t range_j, size_t tile_j,
-                                        uint32_t flags);
-
-/**
- * Process items on a 2D grid with the specified maximum tile size along the
- * last grid dimension using a microarchitecture-aware task function.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   uint32_t uarch_index = cpuinfo_initialize() ?
- *       cpuinfo_get_current_uarch_index() : default_uarch_index;
- *   if (uarch_index > max_uarch_index) uarch_index = default_uarch_index;
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j += tile_j)
- *       function(context, uarch_index, i, j, min(range_j - j, tile_j));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each tile.
- * @param context     the first argument passed to the specified function.
- * @param default_uarch_index  the microarchitecture index to use when
- *    pthreadpool is configured without cpuinfo, cpuinfo initialization failed,
- *    or index returned by cpuinfo_get_current_uarch_index() exceeds the
- *    max_uarch_index value.
- * @param max_uarch_index      the maximum microarchitecture index expected by
- *    the specified function. If the index returned by
- *    cpuinfo_get_current_uarch_index() exceeds this value, default_uarch_index
- *    will be used instead. default_uarch_index can exceed max_uarch_index.
- * @param range_i     the number of items to process along the first dimension
- *    of the 2D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 2D grid.
- * @param tile_j      the maximum number of items along the second dimension of
- *    the 2D grid to process in one function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_2d_tile_1d_with_uarch(
-    pthreadpool_t threadpool, pthreadpool_task_2d_tile_1d_with_id_t function,
-    void *context, uint32_t default_uarch_index, uint32_t max_uarch_index,
-    size_t range_i, size_t range_j, size_t tile_j, uint32_t flags);
-
-/**
- * Process items on a 2D grid with the specified maximum tile size along the
- * last grid dimension using a microarchitecture-aware task function and passing
- * along the current thread id.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   uint32_t uarch_index = cpuinfo_initialize() ?
- *       cpuinfo_get_current_uarch_index() : default_uarch_index;
- *   if (uarch_index > max_uarch_index) uarch_index = default_uarch_index;
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j += tile_j)
- *       function(context, uarch_index, thread_index, i, j, min(range_j - j,
- * tile_j));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each tile.
- * @param context     the first argument passed to the specified function.
- * @param default_uarch_index  the microarchitecture index to use when
- *    pthreadpool is configured without cpuinfo, cpuinfo initialization failed,
- *    or index returned by cpuinfo_get_current_uarch_index() exceeds the
- *    max_uarch_index value.
- * @param max_uarch_index      the maximum microarchitecture index expected by
- *    the specified function. If the index returned by
- *    cpuinfo_get_current_uarch_index() exceeds this value, default_uarch_index
- *    will be used instead. default_uarch_index can exceed max_uarch_index.
- * @param range_i     the number of items to process along the first dimension
- *    of the 2D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 2D grid.
- * @param tile_j      the maximum number of items along the second dimension of
- *    the 2D grid to process in one function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_2d_tile_1d_with_uarch_with_thread(
-    pthreadpool_t threadpool,
-    pthreadpool_task_2d_tile_1d_with_id_with_thread_t function, void *context,
-    uint32_t default_uarch_index, uint32_t max_uarch_index, size_t range_i,
-    size_t range_j, size_t tile_j, uint32_t flags);
-
-/**
- * Process items on a 2D grid with specified prefered tile size along the
- * last grid dimension.
- *
- * The function repeatedly calls
- *
- *   function(context, i, j, count_j)
- *
- * in parallel where `i` is in the range `[0, range_i)`, `j` is in the range
- * `[0, range_j)` and a multiple of the provided @a tile_j, and `count_j` is an
- * integer multiple of @a tile_j unless `j + count_j == range_j`.
- *
- * The `count`s are chosen such as to minimize the number of calls to @a
- * function while keeping the computation load balanced across all threads.
- *
- * When the call returns, all items have been processed and the thread pool is
- * ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool,
- *    the calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each interval of the given range.
- * @param context     the first argument passed to the specified function.
- * @param range_i       the number of items on the first dimension of the 2D
- *     grid to process.
- * @param range_j       the number of items on the second dimension of the 2D
- *     grid to process.
- * @param tile_j        the preferred multiple number of items on the second
- *     dimension of the 2D grid to process in each function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_2d_tile_1d_dynamic(
-    pthreadpool_t threadpool, pthreadpool_task_2d_tile_1d_dynamic_t function,
-    void *context, size_t range_i, size_t range_j, size_t tile_j,
-    uint32_t flags);
-
-/**
- * Process items on a 2D grid with specified prefered tile size along the
- * last grid dimension, passing along the current thread id.
- *
- * The function repeatedly calls
- *
- *   function(context, thread_id, i, j, count_j)
- *
- * in parallel where `i` is in the range `[0, range_i)`, `j` is in the range
- * `[0, range_j)` and a multiple of the provided @a tile_j, and `count_j` is an
- * integer multiple of @a tile_j unless `j + count_j == range_j`.
- *
- * The `count`s are chosen such as to minimize the number of calls to @a
- * function while keeping the computation load balanced across all threads.
- *
- * When the call returns, all items have been processed and the thread pool is
- * ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool,
- *    the calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each interval of the given range.
- * @param context     the first argument passed to the specified function.
- * @param range_i       the number of items on the first dimension of the 2D
- *     grid to process.
- * @param range_j       the number of items on the second dimension of the 2D
- *     grid to process.
- * @param tile_j        the preferred multiple number of items on the second
- *     dimension of the 2D grid to process in each function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_2d_tile_1d_dynamic_with_thread(
-    pthreadpool_t threadpool,
-    pthreadpool_task_2d_tile_1d_dynamic_with_id_t function, void *context,
-    size_t range_i, size_t range_j, size_t tile_j, uint32_t flags);
-
-/**
- * Process items on a 2D grid with specified prefered tile size along the
- * last grid dimension, passing along the current uarch index and thread id.
- *
- * The function repeatedly calls
- *
- *   function(context, uarch_index, thread_id, i, j, count_j)
- *
- * in parallel where `i` is in the range `[0, range_i)`, `j` is in the range
- * `[0, range_j)` and a multiple of the provided @a tile_j, and `count_j` is an
- * integer multiple of @a tile_j unless `j + count_j == range_j`.
- *
- * The `count`s are chosen such as to minimize the number of calls to @a
- * function while keeping the computation load balanced across all threads.
- *
- * When the call returns, all items have been processed and the thread pool is
- * ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool,
- *    the calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each interval of the given range.
- * @param context     the first argument passed to the specified function.
- * @param range_i       the number of items on the first dimension of the 2D
- *     grid to process.
- * @param range_j       the number of items on the second dimension of the 2D
- *     grid to process.
- * @param tile_j        the preferred multiple number of items on the second
- *     dimension of the 2D grid to process in each function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_2d_tile_1d_dynamic_with_uarch_with_thread(
-    pthreadpool_t threadpool,
-    pthreadpool_task_2d_tile_1d_dynamic_with_id_with_thread_t function,
-    void *context, uint32_t default_uarch_index, uint32_t max_uarch_index,
-    size_t range_i, size_t range_j, size_t tile_j, uint32_t flags);
-
-/**
- * Process items on a 2D grid with the specified maximum tile size along each
- * grid dimension.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i += tile_i)
- *     for (size_t j = 0; j < range_j; j += tile_j)
- *       function(context, i, j,
- *         min(range_i - i, tile_i), min(range_j - j, tile_j));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each tile.
- * @param context     the first argument passed to the specified function.
- * @param range_i     the number of items to process along the first dimension
- *    of the 2D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 2D grid.
- * @param tile_j      the maximum number of items along the first dimension of
- *    the 2D grid to process in one function call.
- * @param tile_j      the maximum number of items along the second dimension of
- *    the 2D grid to process in one function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_2d_tile_2d(pthreadpool_t threadpool,
-                                        pthreadpool_task_2d_tile_2d_t function,
-                                        void *context, size_t range_i,
-                                        size_t range_j, size_t tile_i,
-                                        size_t tile_j, uint32_t flags);
-
-/**
- * Process items on a 2D grid with specified prefered tile size along each grid
- * dimension.
- *
- * The function repeatedly calls
- *
- *   function(context, i, j, count_i, count_j)
- *
- * in parallel where `i` is in the range `[0, range_i)` and a multiple of the
- * provided @a tile_i, `j` is in the range `[0, range_j)` and a multiple of the
- * provided @a tile_j, and `count_i` and `count_j` are integer multiples of @a
- * tile__i and @a tile_j, unless `i + count_i == range_i` or `j + count_j ==
- * range_j`, respectivly.
- *
- * The `count`s are chosen such as to minimize the number of calls to @a
- * function while keeping the computation load balanced across all threads.
- *
- * When the call returns, all items have been processed and the thread pool is
- * ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool,
- *    the calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *                    is NULL, all items are processed serially on the calling
- *                    thread.
- * @param function    the function to call for each interval of the given range.
- * @param context     the first argument passed to the specified function.
- * @param range_i     the number of items on the first dimension of the 2D
- *                    grid to process.
- * @param range_j     the number of items on the second dimension of the 2D
- *                    grid to process.
- * @param tile_i      the preferred multiple number of items on the first
- *                    dimension of the 2D grid to process in each function call.
- * @param tile_j      the preferred multiple number of items on the second
- *                    dimension of the 2D grid to process in each function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *                    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or
- *                    PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_2d_tile_2d_dynamic(
-    pthreadpool_t threadpool, pthreadpool_task_2d_tile_2d_dynamic_t function,
-    void *context, size_t range_i, size_t range_j, size_t tile_i, size_t tile_j,
-    uint32_t flags);
-
-/**
- * Process items on a 2D grid with specified prefered tile size along each grid
- * dimension using a microarchitecture-aware task function.
- *
- * The function repeatedly calls
- *
- *   function(context, uarch_index, i, j, count_i, count_j)
- *
- * in parallel where `i` is in the range `[0, range_i)` and a multiple of the
- * provided @a tile_i, `j` is in the range `[0, range_j)` and a multiple of the
- * provided @a tile_j, and `count_i` and `count_j` are integer multiples of @a
- * tile__i and @a tile_j, unless `i + count_i == range_i` or `j + count_j ==
- * range_j`, respectivly.
- *
- * The `count`s are chosen such as to minimize the number of calls to @a
- * function while keeping the computation load balanced across all threads.
- *
- * When the call returns, all items have been processed and the thread pool is
- * ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool,
- *    the calls are serialized.
- *
- * @param threadpool           the thread pool to use for parallelisation. If
- *                             threadpool is NULL, all items are processed
- *                             serially on the calling thread.
- * @param function             the function to call for each interval of the
- *                             given range.
- * @param context              the first argument passed to the specified
- *                             function.
- * @param default_uarch_index  the microarchitecture index to use when
- *                             pthreadpool is configured without cpuinfo,
- *                             cpuinfo initialization failed, or index returned
- *                             by cpuinfo_get_current_uarch_index() exceeds
- *                             the max_uarch_index value.
- * @param max_uarch_index      the maximum microarchitecture index expected
- *                             by the specified function. If the index returned
- *                             by cpuinfo_get_current_uarch_index() exceeds this
- *                             value, default_uarch_index will be used instead.
- *                             default_uarch_index can exceed max_uarch_index.
- * @param range_i              the number of items on the first dimension of the
- *                             2D grid to process.
- * @param range_j              the number of items on the second dimension of
- *                             the 2D grid to process.
- * @param tile_i               the preferred multiple number of items on the
- *                             first dimension of the 2D grid to process in each
- *                             function call.
- * @param tile_j               the preferred multiple number of items on the
- *                             second dimension of the 2D grid to process in
- *                             each function call.
- * @param flags                a bitwise combination of zero or more optional
- *                             flags (PTHREADPOOL_FLAG_DISABLE_DENORMALS or
- *                             PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_2d_tile_2d_dynamic_with_uarch(
-    pthreadpool_t threadpool,
-    pthreadpool_task_2d_tile_2d_dynamic_with_id_t function, void *context,
-    uint32_t default_uarch_index, uint32_t max_uarch_index, size_t range_i,
-    size_t range_j, size_t tile_i, size_t tile_j, uint32_t flags);
-
-/**
- * Process items on a 2D grid with specified prefered tile size along each grid
- * dimension passing along the current thread id.
- *
- * The function repeatedly calls
- *
- *   function(context, thread_id, i, j, count_i, count_j)
- *
- * in parallel where `i` is in the range `[0, range_i)` and a multiple of the
- * provided @a tile_i, `j` is in the range `[0, range_j)` and a multiple of the
- * provided @a tile_j, and `count_i` and `count_j` are integer multiples of @a
- * tile__i and @a tile_j, unless `i + count_i == range_i` or `j + count_j ==
- * range_j`, respectivly.
- *
- * The `count`s are chosen such as to minimize the number of calls to @a
- * function while keeping the computation load balanced across all threads.
- *
- * When the call returns, all items have been processed and the thread pool is
- * ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool,
- *    the calls are serialized.
- *
- * @param threadpool           the thread pool to use for parallelisation. If
- *                             threadpool is NULL, all items are processed
- *                             serially on the calling thread.
- * @param function             the function to call for each interval of the
- *                             given range.
- * @param context              the first argument passed to the specified
- *                             function.
- * @param range_i              the number of items on the first dimension of the
- *                             2D grid to process.
- * @param range_j              the number of items on the second dimension of
- *                             the 2D grid to process.
- * @param tile_i               the preferred multiple number of items on the
- *                             first dimension of the 2D grid to process in each
- *                             function call.
- * @param tile_j               the preferred multiple number of items on the
- *                             second dimension of the 2D grid to process in
- *                             each function call.
- * @param flags                a bitwise combination of zero or more optional
- *                             flags (PTHREADPOOL_FLAG_DISABLE_DENORMALS or
- *                             PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_2d_tile_2d_dynamic_with_thread(
-    pthreadpool_t threadpool,
-    pthreadpool_task_2d_tile_2d_dynamic_with_id_t function, void *context,
-    size_t range_i, size_t range_j, size_t tile_i, size_t tile_j,
-    uint32_t flags);
-
-/**
- * Process items on a 2D grid with the specified maximum tile size along each
- * grid dimension using a microarchitecture-aware task function.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   uint32_t uarch_index = cpuinfo_initialize() ?
- *       cpuinfo_get_current_uarch_index() : default_uarch_index;
- *   if (uarch_index > max_uarch_index) uarch_index = default_uarch_index;
- *   for (size_t i = 0; i < range_i; i += tile_i)
- *     for (size_t j = 0; j < range_j; j += tile_j)
- *       function(context, uarch_index, i, j,
- *         min(range_i - i, tile_i), min(range_j - j, tile_j));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool           the thread pool to use for parallelisation. If
- *    threadpool is NULL, all items are processed serially on the calling
- *    thread.
- * @param function             the function to call for each tile.
- * @param context              the first argument passed to the specified
- *    function.
- * @param default_uarch_index  the microarchitecture index to use when
- *                             pthreadpool is configured without cpuinfo,
- *                             cpuinfo initialization failed, or index returned
- *                             by cpuinfo_get_current_uarch_index() exceeds
- *                             the max_uarch_index value.
- * @param max_uarch_index      the maximum microarchitecture index expected
- *                             by the specified function. If the index returned
- *                             by cpuinfo_get_current_uarch_index() exceeds this
- *                             value, default_uarch_index will be used instead.
- *                             default_uarch_index can exceed max_uarch_index.
- * @param range_i              the number of items to process along the first
- *    dimension of the 2D grid.
- * @param range_j              the number of items to process along the second
- *    dimension of the 2D grid.
- * @param tile_j               the maximum number of items along the first
- *    dimension of the 2D grid to process in one function call.
- * @param tile_j               the maximum number of items along the second
- *    dimension of the 2D grid to process in one function call.
- * @param flags                a bitwise combination of zero or more optional
- *    flags (PTHREADPOOL_FLAG_DISABLE_DENORMALS or
- *    PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_2d_tile_2d_with_uarch(
-    pthreadpool_t threadpool, pthreadpool_task_2d_tile_2d_with_id_t function,
-    void *context, uint32_t default_uarch_index, uint32_t max_uarch_index,
-    size_t range_i, size_t range_j, size_t tile_i, size_t tile_j,
-    uint32_t flags);
-
-/**
- * Process items on a 3D grid.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k++)
- *         function(context, i, j, k);
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each tile.
- * @param context     the first argument passed to the specified function.
- * @param range_i     the number of items to process along the first dimension
- *    of the 3D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 3D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 3D grid.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_3d(pthreadpool_t threadpool,
-                                pthreadpool_task_3d_t function, void *context,
-                                size_t range_i, size_t range_j, size_t range_k,
-                                uint32_t flags);
-
-/**
- * Process items on a 3D grid with the specified maximum tile size along the
- * last grid dimension.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k += tile_k)
- *         function(context, i, j, k, min(range_k - k, tile_k));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each tile.
- * @param context     the first argument passed to the specified function.
- * @param range_i     the number of items to process along the first dimension
- *    of the 3D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 3D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 3D grid.
- * @param tile_k      the maximum number of items along the third dimension of
- *    the 3D grid to process in one function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_3d_tile_1d(pthreadpool_t threadpool,
-                                        pthreadpool_task_3d_tile_1d_t function,
-                                        void *context, size_t range_i,
-                                        size_t range_j, size_t range_k,
-                                        size_t tile_k, uint32_t flags);
-
-/**
- * Process items on a 3D grid with the specified maximum tile size along the
- * last grid dimension and passing along the current thread id.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k += tile_k)
- *         function(context, thread_index, i, j, k, min(range_k - k, tile_k));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each tile.
- * @param context     the first argument passed to the specified function.
- * @param range_i     the number of items to process along the first dimension
- *    of the 3D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 3D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 3D grid.
- * @param tile_k      the maximum number of items along the third dimension of
- *    the 3D grid to process in one function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_3d_tile_1d_with_thread(
-    pthreadpool_t threadpool,
-    pthreadpool_task_3d_tile_1d_with_thread_t function, void *context,
-    size_t range_i, size_t range_j, size_t range_k, size_t tile_k,
-    uint32_t flags);
-
-/**
- * Process items on a 3D grid with the specified maximum tile size along the
- * last grid dimension using a microarchitecture-aware task function.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   uint32_t uarch_index = cpuinfo_initialize() ?
- *       cpuinfo_get_current_uarch_index() : default_uarch_index;
- *   if (uarch_index > max_uarch_index) uarch_index = default_uarch_index;
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k += tile_k)
- *         function(context, uarch_index, i, j, k, min(range_k - k, tile_k));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool           the thread pool to use for parallelisation. If
- *    threadpool is NULL, all items are processed serially on the calling
- *    thread.
- * @param function             the function to call for each tile.
- * @param context              the first argument passed to the specified
- *    function.
- * @param default_uarch_index  the microarchitecture index to use when
- *    pthreadpool is configured without cpuinfo, cpuinfo initialization failed,
- *    or index returned by cpuinfo_get_current_uarch_index() exceeds the
- *    max_uarch_index value.
- * @param max_uarch_index      the maximum microarchitecture index expected by
- *    the specified function. If the index returned by
- *    cpuinfo_get_current_uarch_index() exceeds this value, default_uarch_index
- *    will be used instead. default_uarch_index can exceed max_uarch_index.
- * @param range_i              the number of items to process along the first
- *    dimension of the 3D grid.
- * @param range_j              the number of items to process along the second
- *    dimension of the 3D grid.
- * @param range_k              the number of items to process along the third
- *    dimension of the 3D grid.
- * @param tile_k               the maximum number of items along the third
- *    dimension of the 3D grid to process in one function call.
- * @param flags                a bitwise combination of zero or more optional
- *    flags (PTHREADPOOL_FLAG_DISABLE_DENORMALS or
- *    PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_3d_tile_1d_with_uarch(
-    pthreadpool_t threadpool, pthreadpool_task_3d_tile_1d_with_id_t function,
-    void *context, uint32_t default_uarch_index, uint32_t max_uarch_index,
-    size_t range_i, size_t range_j, size_t range_k, size_t tile_k,
-    uint32_t flags);
-
-/**
- * Process items on a 3D grid with the specified maximum tile size along the
- * last grid dimension using a microarchitecture-aware task function and passing
- * along the current thread id.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   uint32_t uarch_index = cpuinfo_initialize() ?
- *       cpuinfo_get_current_uarch_index() : default_uarch_index;
- *   if (uarch_index > max_uarch_index) uarch_index = default_uarch_index;
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k += tile_k)
- *         function(context, uarch_index, thread_index, i, j, k, min(range_k -
- * k, tile_k));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool           the thread pool to use for parallelisation. If
- *    threadpool is NULL, all items are processed serially on the calling
- *    thread.
- * @param function             the function to call for each tile.
- * @param context              the first argument passed to the specified
- *    function.
- * @param default_uarch_index  the microarchitecture index to use when
- *    pthreadpool is configured without cpuinfo, cpuinfo initialization failed,
- *    or index returned by cpuinfo_get_current_uarch_index() exceeds the
- *    max_uarch_index value.
- * @param max_uarch_index      the maximum microarchitecture index expected by
- *    the specified function. If the index returned by
- *    cpuinfo_get_current_uarch_index() exceeds this value, default_uarch_index
- *    will be used instead. default_uarch_index can exceed max_uarch_index.
- * @param range_i              the number of items to process along the first
- *    dimension of the 3D grid.
- * @param range_j              the number of items to process along the second
- *    dimension of the 3D grid.
- * @param range_k              the number of items to process along the third
- *    dimension of the 3D grid.
- * @param tile_k               the maximum number of items along the third
- *    dimension of the 3D grid to process in one function call.
- * @param flags                a bitwise combination of zero or more optional
- *    flags (PTHREADPOOL_FLAG_DISABLE_DENORMALS or
- *    PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_3d_tile_1d_with_uarch_with_thread(
-    pthreadpool_t threadpool,
-    pthreadpool_task_3d_tile_1d_with_id_with_thread_t function, void *context,
-    uint32_t default_uarch_index, uint32_t max_uarch_index, size_t range_i,
-    size_t range_j, size_t range_k, size_t tile_k, uint32_t flags);
-
-/**
- * Process items on a 3D grid with specified prefered tile size along the last
- * grid dimension, passing along the thread ID.
- *
- * The function repeatedly calls
- *
- *   function(context, thread_id, i, j, k, count_k)
- *
- * in parallel where:
- *  - `i` is in the range `[0, range_i)`,
- *  - `j` is in the range `[0, range_j)`,
- *  - `k` is in the range `[0, range_k)` and a multiple of the provided @a
- *    tile_k,
- *  - `count_k` is an integer multiple of @a tile_k, unless `k + count_k ==
- *    range_k`.
- *
- * The `count`s are chosen such as to minimize the number of calls to @a
- * function while keeping the computation load balanced across all threads.
- *
- * When the call returns, all items have been processed and the thread pool is
- * ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool,
- *    the calls are serialized.
- *
- * @param threadpool           the thread pool to use for parallelisation. If
- *                             threadpool is NULL, all items are processed
- *                             serially on the calling thread.
- * @param function             the function to call for each interval of the
- *                             given range.
- * @param context              the first argument passed to the specified
- *                             function.
- * @param range_i              the number of items on the first dimension of the
- *                             3D grid to process.
- * @param range_j              the number of items on the second dimension of
- *                             the 3D grid to process.
- * @param range_k              the number of items on the third dimension of the
- *                             3D grid to process.
- * @param tile_k               the preferred multiple number of items on the
- *                             third dimension of the 3D grid to process in each
- *                             function call.
- * @param flags                a bitwise combination of zero or more optional
- *                             flags (PTHREADPOOL_FLAG_DISABLE_DENORMALS or
- *                             PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_3d_tile_1d_dynamic_with_thread(
-    pthreadpool_t threadpool,
-    pthreadpool_task_3d_tile_1d_dynamic_with_id_t function, void *context,
-    size_t range_i, size_t range_j, size_t range_k, size_t tile_k,
-    uint32_t flags);
-
-/**
- * Process items on a 3D grid with specified prefered tile size along the last
- * grid dimension, passing along the thread ID.
- *
- * The function repeatedly calls
- *
- *   function(context, uarch_index, thread_index, i, j, k, count_k)
- *
- * in parallel where:
- *  - `i` is in the range `[0, range_i)`,
- *  - `j` is in the range `[0, range_j)`,
- *  - `k` is in the range `[0, range_k)` and a multiple of the provided @a
- *    tile_k,
- *  - `count_k` is an integer multiple of @a tile_k, unless `k + count_k ==
- *    range_k`.
- *
- * The `count`s are chosen such as to minimize the number of calls to @a
- * function while keeping the computation load balanced across all threads.
- *
- * When the call returns, all items have been processed and the thread pool is
- * ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool,
- *    the calls are serialized.
- *
- * @param threadpool           the thread pool to use for parallelisation. If
- *                             threadpool is NULL, all items are processed
- *                             serially on the calling thread.
- * @param function             the function to call for each interval of the
- *                             given range.
- * @param context              the first argument passed to the specified
- *                             function.
- * @param default_uarch_index  the microarchitecture index to use when
- *                             pthreadpool is configured without cpuinfo,
- *                             cpuinfo initialization failed, or index returned
- *                             by cpuinfo_get_current_uarch_index() exceeds the
- *                             max_uarch_index value.
- * @param max_uarch_index      the maximum microarchitecture index expected by
- *                             the specified function. If the index returned by
- *                             cpuinfo_get_current_uarch_index() exceeds this
- *                             value, default_uarch_index will be used instead.
- *                             default_uarch_index can exceed max_uarch_index.
- * @param range_i              the number of items on the first dimension of the
- *                             3D grid to process.
- * @param range_j              the number of items on the second dimension of
- *                             the 3D grid to process.
- * @param range_k              the number of items on the third dimension of the
- *                             3D grid to process.
- * @param tile_k               the preferred multiple number of items on the
- *                             third dimension of the 3D grid to process in each
- *                             function call.
- * @param flags                a bitwise combination of zero or more optional
- *                             flags (PTHREADPOOL_FLAG_DISABLE_DENORMALS or
- *                             PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_3d_tile_1d_dynamic_with_uarch_with_thread(
-    pthreadpool_t threadpool,
-    pthreadpool_task_3d_tile_1d_dynamic_with_id_with_thread_t function,
-    void *context, uint32_t default_uarch_index, uint32_t max_uarch_index,
-    size_t range_i, size_t range_j, size_t range_k, size_t tile_k,
-    uint32_t flags);
-
-/**
- * Process items on a 3D grid with the specified maximum tile size along the
- * last two grid dimensions.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j += tile_j)
- *       for (size_t k = 0; k < range_k; k += tile_k)
- *         function(context, i, j, k,
- *           min(range_j - j, tile_j), min(range_k - k, tile_k));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each tile.
- * @param context     the first argument passed to the specified function.
- * @param range_i     the number of items to process along the first dimension
- *    of the 3D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 3D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 3D grid.
- * @param tile_j      the maximum number of items along the second dimension of
- *    the 3D grid to process in one function call.
- * @param tile_k      the maximum number of items along the third dimension of
- *    the 3D grid to process in one function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_3d_tile_2d(pthreadpool_t threadpool,
-                                        pthreadpool_task_3d_tile_2d_t function,
-                                        void *context, size_t range_i,
-                                        size_t range_j, size_t range_k,
-                                        size_t tile_j, size_t tile_k,
-                                        uint32_t flags);
-
-/**
- * Process items on a 3D grid with specified prefered tile size along the last
- * two grid dimensions.
- *
- * The function repeatedly calls
- *
- *   function(context, i, j, k, count_j, count_k)
- *
- * in parallel where:
- *  - `i` is in the range `[0, range_i)`,
- *  - `j` is in the range `[0, range_j)` and a multiple of the provided @a
- *    tile_j,
- *  - `k` is in the range `[0, range_k)` and a multiple of the provided @a
- *    tile_k,
- *  - `count_j` and `count_k` are integer multiples of @a tile__j and @a tile_k,
- *    unless `j + count_j == range_j` or `k + count_k == range_k`, respectivly.
- *
- * The `count`s are chosen such as to minimize the number of calls to @a
- * function while keeping the computation load balanced across all threads.
- *
- * When the call returns, all items have been processed and the thread pool is
- * ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool,
- *    the calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *                    is NULL, all items are processed serially on the calling
- *                    thread.
- * @param function    the function to call for each interval of the given range.
- * @param context     the first argument passed to the specified function.
- * @param range_i     the number of items on the first dimension of the 3D
- *                    grid to process.
- * @param range_j     the number of items on the second dimension of the 3D
- *                    grid to process.
- * @param range_k     the number of items on the third dimension of the 3D
- *                    grid to process.
- * @param tile_j      the preferred multiple number of items on the second
- *                    dimension of the 3D grid to process in each function call.
- * @param tile_k      the preferred multiple number of items on the third
- *                    dimension of the 3D grid to process in each function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *                    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or
- *                    PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_3d_tile_2d_dynamic(
-    pthreadpool_t threadpool, pthreadpool_task_3d_tile_2d_dynamic_t function,
-    void *context, size_t range_i, size_t range_j, size_t range_k,
-    size_t tile_j, size_t tile_k, uint32_t flags);
-
-/**
- * Process items on a 3D grid with specified prefered tile size along the last
- * two grid dimensions using a microarchitecture-aware task function.
- *
- * The function repeatedly calls
- *
- *   function(context, uarch_index, i, j, k, count_j, count_k)
- *
- * in parallel where:
- *  - `i` is in the range `[0, range_i)`,
- *  - `j` is in the range `[0, range_j)` and a multiple of the provided @a
- *    tile_j,
- *  - `k` is in the range `[0, range_k)` and a multiple of the provided @a
- *    tile_k,
- *  - `count_j` and `count_k` are integer multiples of @a tile__j and @a tile_k,
- *    unless `j + count_j == range_j` or `k + count_k == range_k`, respectivly.
- *
- * The `count`s are chosen such as to minimize the number of calls to @a
- * function while keeping the computation load balanced across all threads.
- *
- * When the call returns, all items have been processed and the thread pool is
- * ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool,
- *    the calls are serialized.
- *
- * @param threadpool           the thread pool to use for parallelisation. If
- *                             threadpool is NULL, all items are processed
- *                             serially on the calling thread.
- * @param function             the function to call for each interval of the
- *                             given range.
- * @param context              the first argument passed to the specified
- *                             function.
- * @param default_uarch_index  the microarchitecture index to use when
- *                             pthreadpool is configured without cpuinfo,
- *                             cpuinfo initialization failed, or index returned
- *                             by cpuinfo_get_current_uarch_index() exceeds
- *                             the max_uarch_index value.
- * @param max_uarch_index      the maximum microarchitecture index expected
- *                             by the specified function. If the index returned
- *                             by cpuinfo_get_current_uarch_index() exceeds this
- *                             value, default_uarch_index will be used instead.
- *                             default_uarch_index can exceed max_uarch_index.
- * @param range_i              the number of items on the first dimension of the
- *                             3D grid to process.
- * @param range_j              the number of items on the second dimension of
- *                             the 3D grid to process.
- * @param range_k              the number of items on the third dimension of the
- *                             3D grid to process.
- * @param tile_j               the preferred multiple number of items on the
- *                             second dimension of the 3D grid to process in
- *                             each function call.
- * @param tile_k               the preferred multiple number of items on the
- *                             third dimension of the 3D grid to process in each
- *                             function call.
- * @param flags                a bitwise combination of zero or more optional
- *                             flags (PTHREADPOOL_FLAG_DISABLE_DENORMALS or
- *                             PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_3d_tile_2d_dynamic_with_uarch(
-    pthreadpool_t threadpool,
-    pthreadpool_task_3d_tile_2d_dynamic_with_id_t function, void *context,
-    uint32_t default_uarch_index, uint32_t max_uarch_index, size_t range_i,
-    size_t range_j, size_t range_k, size_t tile_j, size_t tile_k,
-    uint32_t flags);
-
-/**
- * Process items on a 3D grid with specified prefered tile size along the last
- * two grid dimensions passing along the thread ID.
- *
- * The function repeatedly calls
- *
- *   function(context, thread_id, i, j, k, count_j, count_k)
- *
- * in parallel where:
- *  - `i` is in the range `[0, range_i)`,
- *  - `j` is in the range `[0, range_j)` and a multiple of the provided @a
- *    tile_j,
- *  - `k` is in the range `[0, range_k)` and a multiple of the provided @a
- *    tile_k,
- *  - `count_j` and `count_k` are integer multiples of @a tile__j and @a tile_k,
- *    unless `j + count_j == range_j` or `k + count_k == range_k`, respectivly.
- *
- * The `count`s are chosen such as to minimize the number of calls to @a
- * function while keeping the computation load balanced across all threads.
- *
- * When the call returns, all items have been processed and the thread pool is
- * ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool,
- *    the calls are serialized.
- *
- * @param threadpool           the thread pool to use for parallelisation. If
- *                             threadpool is NULL, all items are processed
- *                             serially on the calling thread.
- * @param function             the function to call for each interval of the
- *                             given range.
- * @param context              the first argument passed to the specified
- *                             function.
- * @param range_i              the number of items on the first dimension of the
- *                             3D grid to process.
- * @param range_j              the number of items on the second dimension of
- *                             the 3D grid to process.
- * @param range_k              the number of items on the third dimension of the
- *                             3D grid to process.
- * @param tile_j               the preferred multiple number of items on the
- *                             second dimension of the 3D grid to process in
- *                             each function call.
- * @param tile_k               the preferred multiple number of items on the
- *                             third dimension of the 3D grid to process in each
- *                             function call.
- * @param flags                a bitwise combination of zero or more optional
- *                             flags (PTHREADPOOL_FLAG_DISABLE_DENORMALS or
- *                             PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_3d_tile_2d_dynamic_with_thread(
-    pthreadpool_t threadpool,
-    pthreadpool_task_3d_tile_2d_dynamic_with_id_t function, void *context,
-    size_t range_i, size_t range_j, size_t range_k, size_t tile_j,
-    size_t tile_k, uint32_t flags);
-
-/**
- * Process items on a 3D grid with the specified maximum tile size along the
- * last two grid dimensions using a microarchitecture-aware task function.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   uint32_t uarch_index = cpuinfo_initialize() ?
- *       cpuinfo_get_current_uarch_index() : default_uarch_index;
- *   if (uarch_index > max_uarch_index) uarch_index = default_uarch_index;
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j += tile_j)
- *       for (size_t k = 0; k < range_k; k += tile_k)
- *         function(context, uarch_index, i, j, k,
- *           min(range_j - j, tile_j), min(range_k - k, tile_k));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool           the thread pool to use for parallelisation. If
- *    threadpool is NULL, all items are processed serially on the calling
- *    thread.
- * @param function             the function to call for each tile.
- * @param context              the first argument passed to the specified
- *    function.
- * @param default_uarch_index  the microarchitecture index to use when
- *    pthreadpool is configured without cpuinfo, cpuinfo initialization failed,
- *    or index returned by cpuinfo_get_current_uarch_index() exceeds the
- *    max_uarch_index value.
- * @param max_uarch_index      the maximum microarchitecture index expected by
- *    the specified function. If the index returned by
- *    cpuinfo_get_current_uarch_index() exceeds this value, default_uarch_index
- *    will be used instead. default_uarch_index can exceed max_uarch_index.
- * @param range_i              the number of items to process along the first
- *    dimension of the 3D grid.
- * @param range_j              the number of items to process along the second
- *    dimension of the 3D grid.
- * @param range_k              the number of items to process along the third
- *    dimension of the 3D grid.
- * @param tile_j               the maximum number of items along the second
- *    dimension of the 3D grid to process in one function call.
- * @param tile_k               the maximum number of items along the third
- *    dimension of the 3D grid to process in one function call.
- * @param flags                a bitwise combination of zero or more optional
- *    flags (PTHREADPOOL_FLAG_DISABLE_DENORMALS or
- *    PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_3d_tile_2d_with_uarch(
-    pthreadpool_t threadpool, pthreadpool_task_3d_tile_2d_with_id_t function,
-    void *context, uint32_t default_uarch_index, uint32_t max_uarch_index,
-    size_t range_i, size_t range_j, size_t range_k, size_t tile_j,
-    size_t tile_k, uint32_t flags);
-
-/**
- * Process items on a 4D grid.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k++)
- *         for (size_t l = 0; l < range_l; l++)
- *           function(context, i, j, k, l);
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each tile.
- * @param context     the first argument passed to the specified function.
- * @param range_i     the number of items to process along the first dimension
- *    of the 4D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 4D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 4D grid.
- * @param range_l     the number of items to process along the fourth dimension
- *    of the 4D grid.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_4d(pthreadpool_t threadpool,
-                                pthreadpool_task_4d_t function, void *context,
-                                size_t range_i, size_t range_j, size_t range_k,
-                                size_t range_l, uint32_t flags);
-
-/**
- * Process items on a 4D grid with the specified maximum tile size along the
- * last grid dimension.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k++)
- *         for (size_t l = 0; l < range_l; l += tile_l)
- *           function(context, i, j, k, l, min(range_l - l, tile_l));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each tile.
- * @param context     the first argument passed to the specified function.
- * @param range_i     the number of items to process along the first dimension
- *    of the 4D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 4D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 4D grid.
- * @param range_l     the number of items to process along the fourth dimension
- *    of the 4D grid.
- * @param tile_l      the maximum number of items along the fourth dimension of
- *    the 4D grid to process in one function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_4d_tile_1d(pthreadpool_t threadpool,
-                                        pthreadpool_task_4d_tile_1d_t function,
-                                        void *context, size_t range_i,
-                                        size_t range_j, size_t range_k,
-                                        size_t range_l, size_t tile_l,
-                                        uint32_t flags);
-
-/**
- * Process items on a 4D grid with the specified maximum tile size along the
- * last two grid dimensions.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k += tile_k)
- *         for (size_t l = 0; l < range_l; l += tile_l)
- *           function(context, i, j, k, l,
- *             min(range_k - k, tile_k), min(range_l - l, tile_l));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each tile.
- * @param context     the first argument passed to the specified function.
- * @param range_i     the number of items to process along the first dimension
- *    of the 4D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 4D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 4D grid.
- * @param range_l     the number of items to process along the fourth dimension
- *    of the 4D grid.
- * @param tile_k      the maximum number of items along the third dimension of
- *    the 4D grid to process in one function call.
- * @param tile_l      the maximum number of items along the fourth dimension of
- *    the 4D grid to process in one function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_4d_tile_2d(pthreadpool_t threadpool,
-                                        pthreadpool_task_4d_tile_2d_t function,
-                                        void *context, size_t range_i,
-                                        size_t range_j, size_t range_k,
-                                        size_t range_l, size_t tile_k,
-                                        size_t tile_l, uint32_t flags);
-
-/**
- * Process items on a 4D grid with the specified maximum tile size along the
- * last two grid dimensions using a microarchitecture-aware task function.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   uint32_t uarch_index = cpuinfo_initialize() ?
- *       cpuinfo_get_current_uarch_index() : default_uarch_index;
- *   if (uarch_index > max_uarch_index) uarch_index = default_uarch_index;
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k += tile_k)
- *         for (size_t l = 0; l < range_l; l += tile_l)
- *           function(context, uarch_index, i, j, k, l,
- *             min(range_k - k, tile_k), min(range_l - l, tile_l));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool           the thread pool to use for parallelisation. If
- *    threadpool is NULL, all items are processed serially on the calling
- *    thread.
- * @param function             the function to call for each tile.
- * @param context              the first argument passed to the specified
- *    function.
- * @param default_uarch_index  the microarchitecture index to use when
- *    pthreadpool is configured without cpuinfo, cpuinfo initialization failed,
- *    or index returned by cpuinfo_get_current_uarch_index() exceeds the
- *    max_uarch_index value.
- * @param max_uarch_index      the maximum microarchitecture index expected by
- *    the specified function. If the index returned by
- *    cpuinfo_get_current_uarch_index() exceeds this value, default_uarch_index
- *    will be used instead. default_uarch_index can exceed max_uarch_index.
- * @param range_i              the number of items to process along the first
- *    dimension of the 4D grid.
- * @param range_j              the number of items to process along the second
- *    dimension of the 4D grid.
- * @param range_k              the number of items to process along the third
- *    dimension of the 4D grid.
- * @param range_l              the number of items to process along the fourth
- *    dimension of the 4D grid.
- * @param tile_k               the maximum number of items along the third
- *    dimension of the 4D grid to process in one function call.
- * @param tile_l               the maximum number of items along the fourth
- *    dimension of the 4D grid to process in one function call.
- * @param flags                a bitwise combination of zero or more optional
- *    flags (PTHREADPOOL_FLAG_DISABLE_DENORMALS or
- *    PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_4d_tile_2d_with_uarch(
-    pthreadpool_t threadpool, pthreadpool_task_4d_tile_2d_with_id_t function,
-    void *context, uint32_t default_uarch_index, uint32_t max_uarch_index,
-    size_t range_i, size_t range_j, size_t range_k, size_t range_l,
-    size_t tile_k, size_t tile_l, uint32_t flags);
-
-/**
- * Process items on a 4D grid with specified prefered tile size along the last
- * two grid dimensions.
- *
- * The function repeatedly calls
- *
- *   function(context, i, j, k, l, count_k, count_l)
- *
- * in parallel where:
- *  - `i` is in the range `[0, range_i)`,
- *  - `j` is in the range `[0, range_j)`,
- *  - `k` is in the range `[0, range_k)` and a multiple of the provided @a
- *    tile_k,
- *  - `l` is in the range `[0, range_l)` and a multiple of the provided @a
- *    tile_l,
- *  - `count_k` and `count_l` are integer multiples of @a tile_k and @a tile_l,
- *    unless `k + count_k == range_k` or `l + count_l == range_l`, respectivly.
- *
- * The `count`s are chosen such as to minimize the number of calls to @a
- * function while keeping the computation load balanced across all threads.
- *
- * When the call returns, all items have been processed and the thread pool is
- * ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool,
- *    the calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *                    is NULL, all items are processed serially on the calling
- *                    thread.
- * @param function    the function to call for each interval of the given range.
- * @param context     the first argument passed to the specified function.
- * @param range_i     the number of items on the first dimension of the 4D
- *                    grid to process.
- * @param range_j     the number of items on the second dimension of the 4D
- *                    grid to process.
- * @param range_k     the number of items on the third dimension of the 4D
- *                    grid to process.
- * @param range_l     the number of items on the fourth dimension of the 4D
- *                    grid to process.
- * @param tile_k      the preferred multiple number of items on the third
- *                    dimension of the 4D grid to process in each function call.
- * @param tile_l      the preferred multiple number of items on the fourth
- *                    dimension of the 4D grid to process in each function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *                    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or
- *                    PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_4d_tile_2d_dynamic(
-    pthreadpool_t threadpool, pthreadpool_task_4d_tile_2d_dynamic_t function,
-    void *context, size_t range_i, size_t range_j, size_t range_k,
-    size_t range_l, size_t tile_k, size_t tile_l, uint32_t flags);
-
-/**
- * Process items on a 4D grid with specified prefered tile size along the last
- * two grid dimensions using a microarchitecture-aware task function.
- *
- * The function repeatedly calls
- *
- *   function(context, uarch_index, i, j, k, l, count_k, count_l)
- *
- * in parallel where:
- *  - `i` is in the range `[0, range_i)`,
- *  - `j` is in the range `[0, range_j)`,
- *  - `k` is in the range `[0, range_k)` and a multiple of the provided @a
- *    tile_k,
- *  - `l` is in the range `[0, range_l)` and a multiple of the provided @a
- *    tile_l,
- *  - `count_k` and `count_l` are integer multiples of @a tile_k and @a tile_l,
- *    unless `k + count_k == range_k` or `l + count_l == range_l`, respectivly.
- *
- * The `count`s are chosen such as to minimize the number of calls to @a
- * function while keeping the computation load balanced across all threads.
- *
- * When the call returns, all items have been processed and the thread pool is
- * ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool,
- *    the calls are serialized.
- *
- * @param threadpool           the thread pool to use for parallelisation. If
- *                             threadpool is NULL, all items are processed
- *                             serially on the calling thread.
- * @param function             the function to call for each interval of the
- *                             given range.
- * @param context              the first argument passed to the specified
- *                             function.
- * @param default_uarch_index  the microarchitecture index to use when
- *                             pthreadpool is configured without cpuinfo,
- *                             cpuinfo initialization failed, or index returned
- *                             by cpuinfo_get_current_uarch_index() exceeds
- *                             the max_uarch_index value.
- * @param max_uarch_index      the maximum microarchitecture index expected
- *                             by the specified function. If the index returned
- *                             by cpuinfo_get_current_uarch_index() exceeds this
- *                             value, default_uarch_index will be used instead.
- *                             default_uarch_index can exceed max_uarch_index.
- * @param range_i              the number of items on the first dimension of the
- *                             4D grid to process.
- * @param range_j              the number of items on the second dimension of
- *                             the 4D grid to process.
- * @param range_k              the number of items on the third dimension of the
- *                             4D grid to process.
- * @param range_l              the number of items on the fourth dimension of
- *                             the 4D grid to process.
- * @param tile_k               the preferred multiple number of items on the
- *                             third dimension of the 4D grid to process in each
- *                             function call.
- * @param tile_l               the preferred multiple number of items on the
- *                             fourth dimension of the 4D grid to process in
- *                             each function call.
- * @param flags                a bitwise combination of zero or more optional
- *                             flags (PTHREADPOOL_FLAG_DISABLE_DENORMALS or
- *                             PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_4d_tile_2d_dynamic_with_uarch(
-    pthreadpool_t threadpool,
-    pthreadpool_task_4d_tile_2d_dynamic_with_id_t function, void *context,
-    uint32_t default_uarch_index, uint32_t max_uarch_index, size_t range_i,
-    size_t range_j, size_t range_k, size_t range_l, size_t tile_k,
-    size_t tile_l, uint32_t flags);
-
-/**
- * Process items on a 5D grid.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k++)
- *         for (size_t l = 0; l < range_l; l++)
- *           for (size_t m = 0; m < range_m; m++)
- *             function(context, i, j, k, l, m);
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each tile.
- * @param context     the first argument passed to the specified function.
- * @param range_i     the number of items to process along the first dimension
- *    of the 5D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 5D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 5D grid.
- * @param range_l     the number of items to process along the fourth dimension
- *    of the 5D grid.
- * @param range_m     the number of items to process along the fifth dimension
- *    of the 5D grid.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_5d(pthreadpool_t threadpool,
-                                pthreadpool_task_5d_t function, void *context,
-                                size_t range_i, size_t range_j, size_t range_k,
-                                size_t range_l, size_t range_m, uint32_t flags);
-
-/**
- * Process items on a 5D grid with the specified maximum tile size along the
- * last grid dimension.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k++)
- *         for (size_t l = 0; l < range_l; l++)
- *           for (size_t m = 0; m < range_m; m += tile_m)
- *             function(context, i, j, k, l, m, min(range_m - m, tile_m));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each tile.
- * @param context     the first argument passed to the specified function.
- * @param range_i     the number of items to process along the first dimension
- *    of the 5D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 5D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 5D grid.
- * @param range_l     the number of items to process along the fourth dimension
- *    of the 5D grid.
- * @param range_m     the number of items to process along the fifth dimension
- *    of the 5D grid.
- * @param tile_m      the maximum number of items along the fifth dimension of
- *    the 5D grid to process in one function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_5d_tile_1d(pthreadpool_t threadpool,
-                                        pthreadpool_task_5d_tile_1d_t function,
-                                        void *context, size_t range_i,
-                                        size_t range_j, size_t range_k,
-                                        size_t range_l, size_t range_m,
-                                        size_t tile_m, uint32_t flags);
-
-/**
- * Process items on a 5D grid with the specified maximum tile size along the
- * last two grid dimensions.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k++)
- *         for (size_t l = 0; l < range_l; l += tile_l)
- *           for (size_t m = 0; m < range_m; m += tile_m)
- *             function(context, i, j, k, l, m,
- *               min(range_l - l, tile_l), min(range_m - m, tile_m));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each tile.
- * @param context     the first argument passed to the specified function.
- * @param range_i     the number of items to process along the first dimension
- *    of the 5D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 5D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 5D grid.
- * @param range_l     the number of items to process along the fourth dimension
- *    of the 5D grid.
- * @param range_m     the number of items to process along the fifth dimension
- *    of the 5D grid.
- * @param tile_l      the maximum number of items along the fourth dimension of
- *    the 5D grid to process in one function call.
- * @param tile_m      the maximum number of items along the fifth dimension of
- *    the 5D grid to process in one function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_5d_tile_2d(pthreadpool_t threadpool,
-                                        pthreadpool_task_5d_tile_2d_t function,
-                                        void *context, size_t range_i,
-                                        size_t range_j, size_t range_k,
-                                        size_t range_l, size_t range_m,
-                                        size_t tile_l, size_t tile_m,
-                                        uint32_t flags);
-
-/**
- * Process items on a 6D grid.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k++)
- *         for (size_t l = 0; l < range_l; l++)
- *           for (size_t m = 0; m < range_m; m++)
- *             for (size_t n = 0; n < range_n; n++)
- *               function(context, i, j, k, l, m, n);
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each tile.
- * @param context     the first argument passed to the specified function.
- * @param range_i     the number of items to process along the first dimension
- *    of the 6D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 6D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 6D grid.
- * @param range_l     the number of items to process along the fourth dimension
- *    of the 6D grid.
- * @param range_m     the number of items to process along the fifth dimension
- *    of the 6D grid.
- * @param range_n     the number of items to process along the sixth dimension
- *    of the 6D grid.
- * @param tile_n      the maximum number of items along the sixth dimension of
- *    the 6D grid to process in one function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_6d(pthreadpool_t threadpool,
-                                pthreadpool_task_6d_t function, void *context,
-                                size_t range_i, size_t range_j, size_t range_k,
-                                size_t range_l, size_t range_m, size_t range_n,
-                                uint32_t flags);
-
-/**
- * Process items on a 6D grid with the specified maximum tile size along the
- * last grid dimension.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k++)
- *         for (size_t l = 0; l < range_l; l++)
- *           for (size_t m = 0; m < range_m; m++)
- *             for (size_t n = 0; n < range_n; n += tile_n)
- *               function(context, i, j, k, l, m, n, min(range_n - n, tile_n));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each tile.
- * @param context     the first argument passed to the specified function.
- * @param range_i     the number of items to process along the first dimension
- *    of the 6D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 6D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 6D grid.
- * @param range_l     the number of items to process along the fourth dimension
- *    of the 6D grid.
- * @param range_m     the number of items to process along the fifth dimension
- *    of the 6D grid.
- * @param range_n     the number of items to process along the sixth dimension
- *    of the 6D grid.
- * @param tile_n      the maximum number of items along the sixth dimension of
- *    the 6D grid to process in one function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_6d_tile_1d(pthreadpool_t threadpool,
-                                        pthreadpool_task_6d_tile_1d_t function,
-                                        void *context, size_t range_i,
-                                        size_t range_j, size_t range_k,
-                                        size_t range_l, size_t range_m,
-                                        size_t range_n, size_t tile_n,
-                                        uint32_t flags);
-
-/**
- * Process items on a 6D grid with the specified maximum tile size along the
- * last two grid dimensions.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k++)
- *         for (size_t l = 0; l < range_l; l++)
- *           for (size_t m = 0; m < range_m; m += tile_m)
- *             for (size_t n = 0; n < range_n; n += tile_n)
- *               function(context, i, j, k, l, m, n,
- *                 min(range_m - m, tile_m), min(range_n - n, tile_n));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each tile.
- * @param context     the first argument passed to the specified function.
- * @param range_i     the number of items to process along the first dimension
- *    of the 6D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 6D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 6D grid.
- * @param range_l     the number of items to process along the fourth dimension
- *    of the 6D grid.
- * @param range_m     the number of items to process along the fifth dimension
- *    of the 6D grid.
- * @param range_n     the number of items to process along the sixth dimension
- *    of the 6D grid.
- * @param tile_m      the maximum number of items along the fifth dimension of
- *    the 6D grid to process in one function call.
- * @param tile_n      the maximum number of items along the sixth dimension of
- *    the 6D grid to process in one function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-void pthreadpool_parallelize_6d_tile_2d(pthreadpool_t threadpool,
-                                        pthreadpool_task_6d_tile_2d_t function,
-                                        void *context, size_t range_i,
-                                        size_t range_j, size_t range_k,
-                                        size_t range_l, size_t range_m,
-                                        size_t range_n, size_t tile_m,
-                                        size_t tile_n, uint32_t flags);
-
-/**
- * Terminates threads in the thread pool and releases associated resources.
- *
- * @warning  Accessing the thread pool after a call to this function constitutes
- *    undefined behaviour and may cause data corruption.
- *
- * @param[in,out]  threadpool  The thread pool to destroy.
- */
-void pthreadpool_destroy(pthreadpool_t threadpool);
-
-#ifndef PTHREADPOOL_NO_DEPRECATED_API
-
-/* Legacy API for compatibility with pre-existing users (e.g. NNPACK) */
-#if defined(__GNUC__)
-#define PTHREADPOOL_DEPRECATED __attribute__((__deprecated__))
-#else
-#define PTHREADPOOL_DEPRECATED
-#endif
-
-typedef void (*pthreadpool_function_1d_t)(void *, size_t);
-typedef void (*pthreadpool_function_1d_tiled_t)(void *, size_t, size_t);
-typedef void (*pthreadpool_function_2d_t)(void *, size_t, size_t);
-typedef void (*pthreadpool_function_2d_tiled_t)(void *, size_t, size_t, size_t,
-                                                size_t);
-typedef void (*pthreadpool_function_3d_tiled_t)(void *, size_t, size_t, size_t,
-                                                size_t, size_t, size_t);
-typedef void (*pthreadpool_function_4d_tiled_t)(void *, size_t, size_t, size_t,
-                                                size_t, size_t, size_t, size_t,
-                                                size_t);
-
-void pthreadpool_compute_1d(pthreadpool_t threadpool,
-                            pthreadpool_function_1d_t function, void *argument,
-                            size_t range) PTHREADPOOL_DEPRECATED;
-
-void pthreadpool_compute_1d_tiled(pthreadpool_t threadpool,
-                                  pthreadpool_function_1d_tiled_t function,
-                                  void *argument, size_t range,
-                                  size_t tile) PTHREADPOOL_DEPRECATED;
-
-void pthreadpool_compute_2d(pthreadpool_t threadpool,
-                            pthreadpool_function_2d_t function, void *argument,
-                            size_t range_i,
-                            size_t range_j) PTHREADPOOL_DEPRECATED;
-
-void pthreadpool_compute_2d_tiled(pthreadpool_t threadpool,
-                                  pthreadpool_function_2d_tiled_t function,
-                                  void *argument, size_t range_i,
-                                  size_t range_j, size_t tile_i,
-                                  size_t tile_j) PTHREADPOOL_DEPRECATED;
-
-void pthreadpool_compute_3d_tiled(pthreadpool_t threadpool,
-                                  pthreadpool_function_3d_tiled_t function,
-                                  void *argument, size_t range_i,
-                                  size_t range_j, size_t range_k, size_t tile_i,
-                                  size_t tile_j,
-                                  size_t tile_k) PTHREADPOOL_DEPRECATED;
-
-void pthreadpool_compute_4d_tiled(pthreadpool_t threadpool,
-                                  pthreadpool_function_4d_tiled_t function,
-                                  void *argument, size_t range_i,
-                                  size_t range_j, size_t range_k,
-                                  size_t range_l, size_t tile_i, size_t tile_j,
-                                  size_t tile_k,
-                                  size_t tile_l) PTHREADPOOL_DEPRECATED;
-
-#endif /* PTHREADPOOL_NO_DEPRECATED_API */
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#ifdef __cplusplus
-
-namespace libpthreadpool {
-namespace detail {
-namespace { // NOLINT: Naming this namespace would expose it.
-
-template <class T> void call_wrapper_1d(void *arg, size_t i) {
-  (*static_cast<const T *>(arg))(i);
-}
-
-template <class T>
-void call_wrapper_1d_tile_1d(void *arg, size_t range_i, size_t tile_i) {
-  (*static_cast<const T *>(arg))(range_i, tile_i);
-}
-
-template <class T>
-void call_wrapper_1d_tile_1d_dynamic(void *arg, size_t range_i, size_t tile_i) {
-  (*static_cast<const T *>(arg))(range_i, tile_i);
-}
-
-template <class T> void call_wrapper_2d(void *functor, size_t i, size_t j) {
-  (*static_cast<const T *>(functor))(i, j);
-}
-
-template <class T>
-void call_wrapper_2d_tile_1d(void *functor, size_t i, size_t range_j,
-                             size_t tile_j) {
-  (*static_cast<const T *>(functor))(i, range_j, tile_j);
-}
-
-template <class T>
-void call_wrapper_2d_tile_1d_dynamic(void *functor, size_t i, size_t range_j,
-                                     size_t tile_j) {
-  (*static_cast<const T *>(functor))(i, range_j, tile_j);
-}
-
-template <class T>
-void call_wrapper_2d_tile_2d(void *functor, size_t range_i, size_t range_j,
-                             size_t tile_i, size_t tile_j) {
-  (*static_cast<const T *>(functor))(range_i, range_j, tile_i, tile_j);
-}
-
-template <class T>
-void call_wrapper_2d_tile_2d_dynamic(void *functor, size_t range_i,
-                                     size_t range_j, size_t tile_i,
-                                     size_t tile_j) {
-  (*static_cast<const T *>(functor))(range_i, range_j, tile_i, tile_j);
-}
-
-template <class T>
-void call_wrapper_3d(void *functor, size_t i, size_t j, size_t k) {
-  (*static_cast<const T *>(functor))(i, j, k);
-}
-
-template <class T>
-void call_wrapper_3d_tile_1d(void *functor, size_t i, size_t j, size_t range_k,
-                             size_t tile_k) {
-  (*static_cast<const T *>(functor))(i, j, range_k, tile_k);
-}
-
-template <class T>
-void call_wrapper_3d_tile_2d(void *functor, size_t i, size_t range_j,
-                             size_t range_k, size_t tile_j, size_t tile_k) {
-  (*static_cast<const T *>(functor))(i, range_j, range_k, tile_j, tile_k);
-}
-
-template <class T>
-void call_wrapper_3d_tile_2d_dynamic(void *functor, size_t i, size_t range_j,
-                                     size_t range_k, size_t tile_j,
-                                     size_t tile_k) {
-  (*static_cast<const T *>(functor))(i, range_j, range_k, tile_j, tile_k);
-}
-
-template <class T>
-void call_wrapper_4d(void *functor, size_t i, size_t j, size_t k, size_t l) {
-  (*static_cast<const T *>(functor))(i, j, k, l);
-}
-
-template <class T>
-void call_wrapper_4d_tile_1d(void *functor, size_t i, size_t j, size_t k,
-                             size_t range_l, size_t tile_l) {
-  (*static_cast<const T *>(functor))(i, j, k, range_l, tile_l);
-}
-
-template <class T>
-void call_wrapper_4d_tile_2d(void *functor, size_t i, size_t j, size_t range_k,
-                             size_t range_l, size_t tile_k, size_t tile_l) {
-  (*static_cast<const T *>(functor))(i, j, range_k, range_l, tile_k, tile_l);
-}
-
-template <class T>
-void call_wrapper_4d_tile_2d_dynamic(void *functor, size_t i, size_t j,
-                                     size_t range_k, size_t range_l,
-                                     size_t tile_k, size_t tile_l) {
-  (*static_cast<const T *>(functor))(i, j, range_k, range_l, tile_k, tile_l);
-}
-
-template <class T>
-void call_wrapper_5d(void *functor, size_t i, size_t j, size_t k, size_t l,
-                     size_t m) {
-  (*static_cast<const T *>(functor))(i, j, k, l, m);
-}
-
-template <class T>
-void call_wrapper_5d_tile_1d(void *functor, size_t i, size_t j, size_t k,
-                             size_t l, size_t range_m, size_t tile_m) {
-  (*static_cast<const T *>(functor))(i, j, k, l, range_m, tile_m);
-}
-
-template <class T>
-void call_wrapper_5d_tile_2d(void *functor, size_t i, size_t j, size_t k,
-                             size_t range_l, size_t range_m, size_t tile_l,
-                             size_t tile_m) {
-  (*static_cast<const T *>(functor))(i, j, k, range_l, range_m, tile_l, tile_m);
-}
-
-template <class T>
-void call_wrapper_6d(void *functor, size_t i, size_t j, size_t k, size_t l,
-                     size_t m, size_t n) {
-  (*static_cast<const T *>(functor))(i, j, k, l, m, n);
-}
-
-template <class T>
-void call_wrapper_6d_tile_1d(void *functor, size_t i, size_t j, size_t k,
-                             size_t l, size_t m, size_t range_n,
-                             size_t tile_n) {
-  (*static_cast<const T *>(functor))(i, j, k, l, m, range_n, tile_n);
-}
-
-template <class T>
-void call_wrapper_6d_tile_2d(void *functor, size_t i, size_t j, size_t k,
-                             size_t l, size_t range_m, size_t range_n,
-                             size_t tile_m, size_t tile_n) {
-  (*static_cast<const T *>(functor))(i, j, k, l, range_m, range_n, tile_m,
-                                     tile_n);
-}
-
-} /* namespace */
-} /* namespace detail */
-} /* namespace libpthreadpool */
-
-/**
- * Process items on a 1D grid.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range; i++)
- *     functor(i);
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param functor     the functor to call for each item.
- * @param range       the number of items on the 1D grid to process. The
- *    specified functor will be called once for each item.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-template <class T>
-inline void pthreadpool_parallelize_1d(pthreadpool_t threadpool,
-                                       const T &functor, size_t range,
-                                       uint32_t flags = 0) {
-  pthreadpool_parallelize_1d(
-      threadpool, &libpthreadpool::detail::call_wrapper_1d<const T>,
-      const_cast<void *>(static_cast<const void *>(&functor)), range, flags);
-}
-
-/**
- * Process items on a 1D grid with specified maximum tile size.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range; i += tile)
- *     functor(i, min(range - i, tile));
- *
- * When the call returns, all items have been processed and the thread pool is
- * ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool,
- *    the calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param functor     the functor to call for each tile.
- * @param range       the number of items on the 1D grid to process.
- * @param tile        the maximum number of items on the 1D grid to process in
- *    one functor call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-template <class T>
-inline void pthreadpool_parallelize_1d_tile_1d(pthreadpool_t threadpool,
-                                               const T &functor, size_t range,
-                                               size_t tile,
-                                               uint32_t flags = 0) {
-  pthreadpool_parallelize_1d_tile_1d(
-      threadpool, &libpthreadpool::detail::call_wrapper_1d_tile_1d<const T>,
-      const_cast<void *>(static_cast<const void *>(&functor)), range, tile,
-      flags);
-}
-
-/**
- * Process items on a 1D grid with specified prefered tile size.
- *
- * The function repeatedly calls
- *
- *   function(context, i, count)
- *
- * in parallel where `i` is in the range `[0, range)` and a multiple of the
- * provided @a tile and `count` is an integer multiple of @a tile unless `i
- * + count == range`.
- *
- * The `count`s are chosen such as to minimize the number of calls to @a
- * function while keeping the computation load balanced across all threads.
- *
- * When the call returns, all items have been processed and the thread pool is
- * ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool,
- *    the calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each interval of the given range.
- * @param context     the first argument passed to the specified function.
- * @param range       the number of items on the 1D grid to process.
- * @param tile        the preferred multiple number of items on the 1D grid to
- *     process in each function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-template <class T>
-inline void
-pthreadpool_parallelize_1d_tile_1d_dynamic(pthreadpool_t threadpool,
-                                           const T &functor, size_t range,
-                                           size_t tile, uint32_t flags = 0) {
-  pthreadpool_parallelize_1d_tile_1d_dynamic(
-      threadpool,
-      &libpthreadpool::detail::call_wrapper_1d_tile_1d_dynamic<const T>,
-      const_cast<void *>(static_cast<const void *>(&functor)), range, tile,
-      flags);
-}
-
-/**
- * Process items on a 2D grid.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       functor(i, j);
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param functor     the functor to call for each item.
- * @param range_i     the number of items to process along the first dimension
- *    of the 2D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 2D grid.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-template <class T>
-inline void pthreadpool_parallelize_2d(pthreadpool_t threadpool,
-                                       const T &functor, size_t range_i,
-                                       size_t range_j, uint32_t flags = 0) {
-  pthreadpool_parallelize_2d(
-      threadpool, &libpthreadpool::detail::call_wrapper_2d<const T>,
-      const_cast<void *>(static_cast<const void *>(&functor)), range_i, range_j,
-      flags);
-}
-
-/**
- * Process items on a 2D grid with the specified maximum tile size along the
- * last grid dimension.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j += tile_j)
- *       functor(i, j, min(range_j - j, tile_j));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param functor     the functor to call for each tile.
- * @param range_i     the number of items to process along the first dimension
- *    of the 2D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 2D grid.
- * @param tile_j      the maximum number of items along the second dimension of
- *    the 2D grid to process in one functor call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-template <class T>
-inline void pthreadpool_parallelize_2d_tile_1d(pthreadpool_t threadpool,
-                                               const T &functor, size_t range_i,
-                                               size_t range_j, size_t tile_j,
-                                               uint32_t flags = 0) {
-  pthreadpool_parallelize_2d_tile_1d(
-      threadpool, &libpthreadpool::detail::call_wrapper_2d_tile_1d<const T>,
-      const_cast<void *>(static_cast<const void *>(&functor)), range_i, range_j,
-      tile_j, flags);
-}
-
-/**
- * Process items on a 2D grid with specified prefered tile size along the
- * last grid dimension.
- *
- * The function repeatedly calls
- *
- *   function(context, i, j, count_j)
- *
- * in parallel where `i` is in the range `[0, range_i)`, `j` is in the range
- * `[0, range_j)` and a multiple of the provided @a tile_j, and `count_j` is an
- * integer multiple of @a tile_j unless `j + count_j == range_j`.
- *
- * The `count`s are chosen such as to minimize the number of calls to @a
- * function while keeping the computation load balanced across all threads.
- *
- * When the call returns, all items have been processed and the thread pool is
- * ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool,
- *    the calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each interval of the given range.
- * @param context     the first argument passed to the specified function.
- * @param range_i       the number of items on the first dimension of the 2D
- *     grid to process.
- * @param range_j       the number of items on the second dimension of the 2D
- *     grid to process.
- * @param tile_j        the preferred multiple number of items on the second
- *     dimension of the 2D grid to process in each function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-template <class T>
-inline void pthreadpool_parallelize_2d_tile_1d_dynamic(
-    pthreadpool_t threadpool, const T &functor, size_t range_i, size_t range_j,
-    size_t tile_j, uint32_t flags = 0) {
-  pthreadpool_parallelize_2d_tile_1d_dynamic(
-      threadpool,
-      &libpthreadpool::detail::call_wrapper_2d_tile_1d_dynamic<const T>,
-      const_cast<void *>(static_cast<const void *>(&functor)), range_i, range_j,
-      tile_j, flags);
-}
-
-/**
- * Process items on a 2D grid with the specified maximum tile size along each
- * grid dimension.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i += tile_i)
- *     for (size_t j = 0; j < range_j; j += tile_j)
- *       functor(i, j,
- *         min(range_i - i, tile_i), min(range_j - j, tile_j));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param functor     the functor to call for each tile.
- * @param range_i     the number of items to process along the first dimension
- *    of the 2D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 2D grid.
- * @param tile_j      the maximum number of items along the first dimension of
- *    the 2D grid to process in one functor call.
- * @param tile_j      the maximum number of items along the second dimension of
- *    the 2D grid to process in one functor call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-template <class T>
-inline void pthreadpool_parallelize_2d_tile_2d(pthreadpool_t threadpool,
-                                               const T &functor, size_t range_i,
-                                               size_t range_j, size_t tile_i,
-                                               size_t tile_j,
-                                               uint32_t flags = 0) {
-  pthreadpool_parallelize_2d_tile_2d(
-      threadpool, &libpthreadpool::detail::call_wrapper_2d_tile_2d<const T>,
-      const_cast<void *>(static_cast<const void *>(&functor)), range_i, range_j,
-      tile_i, tile_j, flags);
-}
-
-/**
- * Process items on a 2D grid with specified prefered tile size along each grid
- * dimension.
- *
- * The function repeatedly calls
- *
- *   function(context, i, j, count_i, count_j)
- *
- * in parallel where `i` is in the range `[0, range_i)` and a multiple of the
- * provided @a tile_i, `j` is in the range `[0, range_j)` and a multiple of the
- * provided @a tile_j, and `count_i` and `count_j` are integer multiples of @a
- * tile__i and @a tile_j, unless `i + count_i == range_i` or `j + count_j ==
- * range_j`, respectivly.
- *
- * The `count`s are chosen such as to minimize the number of calls to @a
- * function while keeping the computation load balanced across all threads.
- *
- * When the call returns, all items have been processed and the thread pool is
- * ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool,
- *    the calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each interval of the given range.
- * @param context     the first argument passed to the specified function.
- * @param range_i       the number of items on the first dimension of the 2D
- *     grid to process.
- * @param range_j       the number of items on the second dimension of the 2D
- *     grid to process.
- * @param tile_i        the preferred multiple number of items on the first
- *     dimension of the 2D grid to process in each function call.
- * @param tile_j        the preferred multiple number of items on the second
- *     dimension of the 2D grid to process in each function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-template <class T>
-inline void pthreadpool_parallelize_2d_tile_2d_dynamic(
-    pthreadpool_t threadpool, const T &functor, size_t range_i, size_t range_j,
-    size_t tile_i, size_t tile_j, uint32_t flags = 0) {
-  pthreadpool_parallelize_2d_tile_2d_dynamic(
-      threadpool,
-      &libpthreadpool::detail::call_wrapper_2d_tile_2d_dynamic<const T>,
-      const_cast<void *>(static_cast<const void *>(&functor)), range_i, range_j,
-      tile_i, tile_j, flags);
-}
-
-/**
- * Process items on a 3D grid.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k++)
- *         functor(i, j, k);
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param functor     the functor to call for each tile.
- * @param range_i     the number of items to process along the first dimension
- *    of the 3D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 3D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 3D grid.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-template <class T>
-inline void pthreadpool_parallelize_3d(pthreadpool_t threadpool,
-                                       const T &functor, size_t range_i,
-                                       size_t range_j, size_t range_k,
-                                       uint32_t flags = 0) {
-  pthreadpool_parallelize_3d(
-      threadpool, &libpthreadpool::detail::call_wrapper_3d<const T>,
-      const_cast<void *>(static_cast<const void *>(&functor)), range_i, range_j,
-      range_k, flags);
-}
-
-/**
- * Process items on a 3D grid with the specified maximum tile size along the
- * last grid dimension.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k += tile_k)
- *         functor(i, j, k, min(range_k - k, tile_k));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param functor     the functor to call for each tile.
- * @param range_i     the number of items to process along the first dimension
- *    of the 3D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 3D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 3D grid.
- * @param tile_k      the maximum number of items along the third dimension of
- *    the 3D grid to process in one functor call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-template <class T>
-inline void pthreadpool_parallelize_3d_tile_1d(pthreadpool_t threadpool,
-                                               const T &functor, size_t range_i,
-                                               size_t range_j, size_t range_k,
-                                               size_t tile_k,
-                                               uint32_t flags = 0) {
-  pthreadpool_parallelize_3d_tile_1d(
-      threadpool, &libpthreadpool::detail::call_wrapper_3d_tile_1d<const T>,
-      const_cast<void *>(static_cast<const void *>(&functor)), range_i, range_j,
-      range_k, tile_k, flags);
-}
-
-/**
- * Process items on a 3D grid with the specified maximum tile size along the
- * last two grid dimensions.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j += tile_j)
- *       for (size_t k = 0; k < range_k; k += tile_k)
- *         functor(i, j, k,
- *           min(range_j - j, tile_j), min(range_k - k, tile_k));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param functor     the functor to call for each tile.
- * @param range_i     the number of items to process along the first dimension
- *    of the 3D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 3D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 3D grid.
- * @param tile_j      the maximum number of items along the second dimension of
- *    the 3D grid to process in one functor call.
- * @param tile_k      the maximum number of items along the third dimension of
- *    the 3D grid to process in one functor call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-template <class T>
-inline void pthreadpool_parallelize_3d_tile_2d(pthreadpool_t threadpool,
-                                               const T &functor, size_t range_i,
-                                               size_t range_j, size_t range_k,
-                                               size_t tile_j, size_t tile_k,
-                                               uint32_t flags = 0) {
-  pthreadpool_parallelize_3d_tile_2d(
-      threadpool, &libpthreadpool::detail::call_wrapper_3d_tile_2d<const T>,
-      const_cast<void *>(static_cast<const void *>(&functor)), range_i, range_j,
-      range_k, tile_j, tile_k, flags);
-}
-
-/**
- * Process items on a 3D grid with specified prefered tile size along the last
- * two grid dimensions.
- *
- * The function repeatedly calls
- *
- *   function(context, i, j, k, count_j, count_k)
- *
- * in parallel where:
- *  - `i` is in the range `[0, range_i)`,
- *  - `j` is in the range `[0, range_j)` and a multiple of the provided @a
- *    tile_j,
- *  - `k` is in the range `[0, range_k)` and a multiple of the provided @a
- *    tile_k,
- *  - `count_j` and `count_k` are integer multiples of @a tile__j and @a tile_k,
- *    unless `j + count_j == range_j` or `k + count_k == range_k`, respectivly.
- *
- * The `count`s are chosen such as to minimize the number of calls to @a
- * function while keeping the computation load balanced across all threads.
- *
- * When the call returns, all items have been processed and the thread pool is
- * ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool,
- *    the calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param function    the function to call for each interval of the given range.
- * @param context     the first argument passed to the specified function.
- * @param range_i       the number of items on the first dimension of the 3D
- *     grid to process.
- * @param range_j       the number of items on the second dimension of the 3D
- *     grid to process.
- * @param range_k       the number of items on the third dimension of the 3D
- *     grid to process.
- * @param tile_j        the preferred multiple number of items on the second
- *     dimension of the 3D grid to process in each function call.
- * @param tile_k        the preferred multiple number of items on the third
- *     dimension of the 3D grid to process in each function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-template <class T>
-inline void pthreadpool_parallelize_3d_tile_2d_dynamic(
-    pthreadpool_t threadpool, const T &functor, size_t range_i, size_t range_j,
-    size_t range_k, size_t tile_j, size_t tile_k, uint32_t flags = 0) {
-  pthreadpool_parallelize_3d_tile_2d_dynamic(
-      threadpool,
-      &libpthreadpool::detail::call_wrapper_3d_tile_2d_dynamic<const T>,
-      const_cast<void *>(static_cast<const void *>(&functor)), range_i, range_j,
-      range_k, tile_j, tile_k, flags);
-}
-
-/**
- * Process items on a 4D grid.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k++)
- *         for (size_t l = 0; l < range_l; l++)
- *           functor(i, j, k, l);
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param functor     the functor to call for each tile.
- * @param range_i     the number of items to process along the first dimension
- *    of the 4D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 4D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 4D grid.
- * @param range_l     the number of items to process along the fourth dimension
- *    of the 4D grid.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-template <class T>
-inline void pthreadpool_parallelize_4d(pthreadpool_t threadpool,
-                                       const T &functor, size_t range_i,
-                                       size_t range_j, size_t range_k,
-                                       size_t range_l, uint32_t flags = 0) {
-  pthreadpool_parallelize_4d(
-      threadpool, &libpthreadpool::detail::call_wrapper_4d<const T>,
-      const_cast<void *>(static_cast<const void *>(&functor)), range_i, range_j,
-      range_k, range_l, flags);
-}
-
-/**
- * Process items on a 4D grid with the specified maximum tile size along the
- * last grid dimension.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k++)
- *         for (size_t l = 0; l < range_l; l += tile_l)
- *           functor(i, j, k, l, min(range_l - l, tile_l));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param functor     the functor to call for each tile.
- * @param range_i     the number of items to process along the first dimension
- *    of the 4D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 4D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 4D grid.
- * @param range_l     the number of items to process along the fourth dimension
- *    of the 4D grid.
- * @param tile_l      the maximum number of items along the fourth dimension of
- *    the 4D grid to process in one functor call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-template <class T>
-inline void pthreadpool_parallelize_4d_tile_1d(pthreadpool_t threadpool,
-                                               const T &functor, size_t range_i,
-                                               size_t range_j, size_t range_k,
-                                               size_t range_l, size_t tile_l,
-                                               uint32_t flags = 0) {
-  pthreadpool_parallelize_4d_tile_1d(
-      threadpool, &libpthreadpool::detail::call_wrapper_4d_tile_1d<const T>,
-      const_cast<void *>(static_cast<const void *>(&functor)), range_i, range_j,
-      range_k, range_l, tile_l, flags);
-}
-
-/**
- * Process items on a 4D grid with the specified maximum tile size along the
- * last two grid dimensions.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k += tile_k)
- *         for (size_t l = 0; l < range_l; l += tile_l)
- *           functor(i, j, k, l,
- *             min(range_k - k, tile_k), min(range_l - l, tile_l));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param functor     the functor to call for each tile.
- * @param range_i     the number of items to process along the first dimension
- *    of the 4D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 4D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 4D grid.
- * @param range_l     the number of items to process along the fourth dimension
- *    of the 4D grid.
- * @param tile_k      the maximum number of items along the third dimension of
- *    the 4D grid to process in one functor call.
- * @param tile_l      the maximum number of items along the fourth dimension of
- *    the 4D grid to process in one functor call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-template <class T>
-inline void pthreadpool_parallelize_4d_tile_2d(pthreadpool_t threadpool,
-                                               const T &functor, size_t range_i,
-                                               size_t range_j, size_t range_k,
-                                               size_t range_l, size_t tile_k,
-                                               size_t tile_l,
-                                               uint32_t flags = 0) {
-  pthreadpool_parallelize_4d_tile_2d(
-      threadpool, &libpthreadpool::detail::call_wrapper_4d_tile_2d<const T>,
-      const_cast<void *>(static_cast<const void *>(&functor)), range_i, range_j,
-      range_k, range_l, tile_k, tile_l, flags);
-}
-
-/**
- * Process items on a 4D grid with specified prefered tile size along the last
- * two grid dimensions.
- *
- * The function repeatedly calls
- *
- *   function(context, i, j, k, l, count_k, count_l)
- *
- * in parallel where:
- *  - `i` is in the range `[0, range_i)`,
- *  - `j` is in the range `[0, range_j)`,
- *  - `k` is in the range `[0, range_k)` and a multiple of the provided @a
- *    tile_k,
- *  - `l` is in the range `[0, range_l)` and a multiple of the provided @a
- *    tile_l,
- *  - `count_k` and `count_l` are integer multiples of @a tile_k and @a tile_l,
- *    unless `k + count_k == range_k` or `l + count_l == range_l`, respectivly.
- *
- * The `count`s are chosen such as to minimize the number of calls to @a
- * function while keeping the computation load balanced across all threads.
- *
- * When the call returns, all items have been processed and the thread pool is
- * ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool,
- *    the calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *                    is NULL, all items are processed serially on the calling
- *                    thread.
- * @param function    the function to call for each interval of the given range.
- * @param context     the first argument passed to the specified function.
- * @param range_i     the number of items on the first dimension of the 4D
- *                    grid to process.
- * @param range_j     the number of items on the second dimension of the 4D
- *                    grid to process.
- * @param range_k     the number of items on the third dimension of the 4D
- *                    grid to process.
- * @param range_l     the number of items on the fourth dimension of the 4D
- *                    grid to process.
- * @param tile_k      the preferred multiple number of items on the third
- *                    dimension of the 4D grid to process in each function call.
- * @param tile_l      the preferred multiple number of items on the fourth
- *                    dimension of the 4D grid to process in each function call.
- * @param flags       a bitwise combination of zero or more optional flags
- *                    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or
- *                    PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-template <class T>
-inline void pthreadpool_parallelize_4d_tile_2d_dynamic(
-    pthreadpool_t threadpool, const T &functor, size_t range_i, size_t range_j,
-    size_t range_k, size_t range_l, size_t tile_k, size_t tile_l,
-    uint32_t flags = 0) {
-  pthreadpool_parallelize_3d_tile_2d_dynamic(
-      threadpool,
-      &libpthreadpool::detail::call_wrapper_4d_tile_2d_dynamic<const T>,
-      const_cast<void *>(static_cast<const void *>(&functor)), range_i, range_j,
-      range_k, range_l, tile_k, tile_l, flags);
-}
-
-/**
- * Process items on a 5D grid.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k++)
- *         for (size_t l = 0; l < range_l; l++)
- *           for (size_t m = 0; m < range_m; m++)
- *             functor(i, j, k, l, m);
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param functor     the functor to call for each tile.
- * @param range_i     the number of items to process along the first dimension
- *    of the 5D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 5D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 5D grid.
- * @param range_l     the number of items to process along the fourth dimension
- *    of the 5D grid.
- * @param range_m     the number of items to process along the fifth dimension
- *    of the 5D grid.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-template <class T>
-inline void
-pthreadpool_parallelize_5d(pthreadpool_t threadpool, const T &functor,
-                           size_t range_i, size_t range_j, size_t range_k,
-                           size_t range_l, size_t range_m, uint32_t flags = 0) {
-  pthreadpool_parallelize_5d(
-      threadpool, &libpthreadpool::detail::call_wrapper_5d<const T>,
-      const_cast<void *>(static_cast<const void *>(&functor)), range_i, range_j,
-      range_k, range_l, range_m, flags);
-}
-
-/**
- * Process items on a 5D grid with the specified maximum tile size along the
- * last grid dimension.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k++)
- *         for (size_t l = 0; l < range_l; l++)
- *           for (size_t m = 0; m < range_m; m += tile_m)
- *             functor(i, j, k, l, m, min(range_m - m, tile_m));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param functor     the functor to call for each tile.
- * @param range_i     the number of items to process along the first dimension
- *    of the 5D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 5D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 5D grid.
- * @param range_l     the number of items to process along the fourth dimension
- *    of the 5D grid.
- * @param range_m     the number of items to process along the fifth dimension
- *    of the 5D grid.
- * @param tile_m      the maximum number of items along the fifth dimension of
- *    the 5D grid to process in one functor call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-template <class T>
-inline void pthreadpool_parallelize_5d_tile_1d(pthreadpool_t threadpool,
-                                               const T &functor, size_t range_i,
-                                               size_t range_j, size_t range_k,
-                                               size_t range_l, size_t range_m,
-                                               size_t tile_m,
-                                               uint32_t flags = 0) {
-  pthreadpool_parallelize_5d_tile_1d(
-      threadpool, &libpthreadpool::detail::call_wrapper_5d_tile_1d<const T>,
-      const_cast<void *>(static_cast<const void *>(&functor)), range_i, range_j,
-      range_k, range_l, range_m, tile_m, flags);
-}
-
-/**
- * Process items on a 5D grid with the specified maximum tile size along the
- * last two grid dimensions.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k++)
- *         for (size_t l = 0; l < range_l; l += tile_l)
- *           for (size_t m = 0; m < range_m; m += tile_m)
- *             functor(i, j, k, l, m,
- *               min(range_l - l, tile_l), min(range_m - m, tile_m));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param functor     the functor to call for each tile.
- * @param range_i     the number of items to process along the first dimension
- *    of the 5D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 5D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 5D grid.
- * @param range_l     the number of items to process along the fourth dimension
- *    of the 5D grid.
- * @param range_m     the number of items to process along the fifth dimension
- *    of the 5D grid.
- * @param tile_l      the maximum number of items along the fourth dimension of
- *    the 5D grid to process in one functor call.
- * @param tile_m      the maximum number of items along the fifth dimension of
- *    the 5D grid to process in one functor call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-template <class T>
-inline void pthreadpool_parallelize_5d_tile_2d(pthreadpool_t threadpool,
-                                               const T &functor, size_t range_i,
-                                               size_t range_j, size_t range_k,
-                                               size_t range_l, size_t range_m,
-                                               size_t tile_l, size_t tile_m,
-                                               uint32_t flags = 0) {
-  pthreadpool_parallelize_5d_tile_2d(
-      threadpool, &libpthreadpool::detail::call_wrapper_5d_tile_2d<const T>,
-      const_cast<void *>(static_cast<const void *>(&functor)), range_i, range_j,
-      range_k, range_l, range_m, tile_l, tile_m, flags);
-}
-
-/**
- * Process items on a 6D grid.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k++)
- *         for (size_t l = 0; l < range_l; l++)
- *           for (size_t m = 0; m < range_m; m++)
- *             for (size_t n = 0; n < range_n; n++)
- *               functor(i, j, k, l, m, n);
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param functor     the functor to call for each tile.
- * @param range_i     the number of items to process along the first dimension
- *    of the 6D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 6D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 6D grid.
- * @param range_l     the number of items to process along the fourth dimension
- *    of the 6D grid.
- * @param range_m     the number of items to process along the fifth dimension
- *    of the 6D grid.
- * @param range_n     the number of items to process along the sixth dimension
- *    of the 6D grid.
- * @param tile_n      the maximum number of items along the sixth dimension of
- *    the 6D grid to process in one functor call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-template <class T>
-inline void pthreadpool_parallelize_6d(pthreadpool_t threadpool,
-                                       const T &functor, size_t range_i,
-                                       size_t range_j, size_t range_k,
-                                       size_t range_l, size_t range_m,
-                                       size_t range_n, uint32_t flags = 0) {
-  pthreadpool_parallelize_6d(
-      threadpool, &libpthreadpool::detail::call_wrapper_6d<const T>,
-      const_cast<void *>(static_cast<const void *>(&functor)), range_i, range_j,
-      range_k, range_l, range_m, range_n, flags);
-}
-
-/**
- * Process items on a 6D grid with the specified maximum tile size along the
- * last grid dimension.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k++)
- *         for (size_t l = 0; l < range_l; l++)
- *           for (size_t m = 0; m < range_m; m++)
- *             for (size_t n = 0; n < range_n; n += tile_n)
- *               functor(i, j, k, l, m, n, min(range_n - n, tile_n));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param functor     the functor to call for each tile.
- * @param range_i     the number of items to process along the first dimension
- *    of the 6D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 6D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 6D grid.
- * @param range_l     the number of items to process along the fourth dimension
- *    of the 6D grid.
- * @param range_m     the number of items to process along the fifth dimension
- *    of the 6D grid.
- * @param range_n     the number of items to process along the sixth dimension
- *    of the 6D grid.
- * @param tile_n      the maximum number of items along the sixth dimension of
- *    the 6D grid to process in one functor call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-template <class T>
-inline void pthreadpool_parallelize_6d_tile_1d(pthreadpool_t threadpool,
-                                               const T &functor, size_t range_i,
-                                               size_t range_j, size_t range_k,
-                                               size_t range_l, size_t range_m,
-                                               size_t range_n, size_t tile_n,
-                                               uint32_t flags = 0) {
-  pthreadpool_parallelize_6d_tile_1d(
-      threadpool, &libpthreadpool::detail::call_wrapper_6d_tile_1d<const T>,
-      const_cast<void *>(static_cast<const void *>(&functor)), range_i, range_j,
-      range_k, range_l, range_m, range_n, tile_n, flags);
-}
-
-/**
- * Process items on a 6D grid with the specified maximum tile size along the
- * last two grid dimensions.
- *
- * The function implements a parallel version of the following snippet:
- *
- *   for (size_t i = 0; i < range_i; i++)
- *     for (size_t j = 0; j < range_j; j++)
- *       for (size_t k = 0; k < range_k; k++)
- *         for (size_t l = 0; l < range_l; l++)
- *           for (size_t m = 0; m < range_m; m += tile_m)
- *             for (size_t n = 0; n < range_n; n += tile_n)
- *               functor(i, j, k, l, m, n,
- *                 min(range_m - m, tile_m), min(range_n - n, tile_n));
- *
- * When the function returns, all items have been processed and the thread pool
- * is ready for a new task.
- *
- * @note If multiple threads call this function with the same thread pool, the
- *    calls are serialized.
- *
- * @param threadpool  the thread pool to use for parallelisation. If threadpool
- *    is NULL, all items are processed serially on the calling thread.
- * @param functor     the functor to call for each tile.
- * @param range_i     the number of items to process along the first dimension
- *    of the 6D grid.
- * @param range_j     the number of items to process along the second dimension
- *    of the 6D grid.
- * @param range_k     the number of items to process along the third dimension
- *    of the 6D grid.
- * @param range_l     the number of items to process along the fourth dimension
- *    of the 6D grid.
- * @param range_m     the number of items to process along the fifth dimension
- *    of the 6D grid.
- * @param range_n     the number of items to process along the sixth dimension
- *    of the 6D grid.
- * @param tile_m      the maximum number of items along the fifth dimension of
- *    the 6D grid to process in one functor call.
- * @param tile_n      the maximum number of items along the sixth dimension of
- *    the 6D grid to process in one functor call.
- * @param flags       a bitwise combination of zero or more optional flags
- *    (PTHREADPOOL_FLAG_DISABLE_DENORMALS or PTHREADPOOL_FLAG_YIELD_WORKERS)
- */
-template <class T>
-inline void pthreadpool_parallelize_6d_tile_2d(
-    pthreadpool_t threadpool, const T &functor, size_t range_i, size_t range_j,
-    size_t range_k, size_t range_l, size_t range_m, size_t range_n,
-    size_t tile_m, size_t tile_n, uint32_t flags = 0) {
-  pthreadpool_parallelize_6d_tile_2d(
-      threadpool, &libpthreadpool::detail::call_wrapper_6d_tile_2d<const T>,
-      const_cast<void *>(static_cast<const void *>(&functor)), range_i, range_j,
-      range_k, range_l, range_m, range_n, tile_m, tile_n, flags);
-}
-
-#endif /* __cplusplus */
-
-#endif /* __PTHREADPOOL_INCLUDE_PTHREADPOOL_H_ */
diff --git a/packages/react-native-executorch/third-party/include/re2/filtered_re2.h b/packages/react-native-executorch/third-party/include/re2/filtered_re2.h
deleted file mode 100644
index f85ce32a22..0000000000
--- a/packages/react-native-executorch/third-party/include/re2/filtered_re2.h
+++ /dev/null
@@ -1,112 +0,0 @@
-// Copyright 2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_FILTERED_RE2_H_
-#define RE2_FILTERED_RE2_H_
-
-// The class FilteredRE2 is used as a wrapper to multiple RE2 regexps.
-// It provides a prefilter mechanism that helps in cutting down the
-// number of regexps that need to be actually searched.
-//
-// By design, it does not include a string matching engine. This is to
-// allow the user of the class to use their favorite string matching
-// engine. The overall flow is: Add all the regexps using Add, then
-// Compile the FilteredRE2. Compile returns strings that need to be
-// matched. Note that the returned strings are lowercased and distinct.
-// For applying regexps to a search text, the caller does the string
-// matching using the returned strings. When doing the string match,
-// note that the caller has to do that in a case-insensitive way or
-// on a lowercased version of the search text. Then call FirstMatch
-// or AllMatches with a vector of indices of strings that were found
-// in the text to get the actual regexp matches.
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "absl/strings/string_view.h"
-#include "re2/re2.h"
-
-namespace re2 {
-
-class PrefilterTree;
-
-class FilteredRE2 {
-public:
-  FilteredRE2();
-  explicit FilteredRE2(int min_atom_len);
-  ~FilteredRE2();
-
-  // Not copyable.
-  FilteredRE2(const FilteredRE2 &) = delete;
-  FilteredRE2 &operator=(const FilteredRE2 &) = delete;
-  // Movable.
-  FilteredRE2(FilteredRE2 &&other);
-  FilteredRE2 &operator=(FilteredRE2 &&other);
-
-  // Uses RE2 constructor to create a RE2 object (re). Returns
-  // re->error_code(). If error_code is other than NoError, then re is
-  // deleted and not added to re2_vec_.
-  RE2::ErrorCode Add(absl::string_view pattern, const RE2::Options &options,
-                     int *id);
-
-  // Prepares the regexps added by Add for filtering.  Returns a set
-  // of strings that the caller should check for in candidate texts.
-  // The returned strings are lowercased and distinct. When doing
-  // string matching, it should be performed in a case-insensitive
-  // way or the search text should be lowercased first.  Call after
-  // all Add calls are done.
-  void Compile(std::vector<std::string> *strings_to_match);
-
-  // Returns the index of the first matching regexp.
-  // Returns -1 on no match. Can be called prior to Compile.
-  // Does not do any filtering: simply tries to Match the
-  // regexps in a loop.
-  int SlowFirstMatch(absl::string_view text) const;
-
-  // Returns the index of the first matching regexp.
-  // Returns -1 on no match. Compile has to be called before
-  // calling this.
-  int FirstMatch(absl::string_view text, const std::vector<int> &atoms) const;
-
-  // Returns the indices of all matching regexps, after first clearing
-  // matched_regexps.
-  bool AllMatches(absl::string_view text, const std::vector<int> &atoms,
-                  std::vector<int> *matching_regexps) const;
-
-  // Returns the indices of all potentially matching regexps after first
-  // clearing potential_regexps.
-  // A regexp is potentially matching if it passes the filter.
-  // If a regexp passes the filter it may still not match.
-  // A regexp that does not pass the filter is guaranteed to not match.
-  void AllPotentials(const std::vector<int> &atoms,
-                     std::vector<int> *potential_regexps) const;
-
-  // The number of regexps added.
-  int NumRegexps() const { return static_cast<int>(re2_vec_.size()); }
-
-  // Get the individual RE2 objects.
-  const RE2 &GetRE2(int regexpid) const { return *re2_vec_[regexpid]; }
-
-private:
-  // Print prefilter.
-  void PrintPrefilter(int regexpid);
-
-  // Useful for testing and debugging.
-  void RegexpsGivenStrings(const std::vector<int> &matched_atoms,
-                           std::vector<int> *passed_regexps);
-
-  // All the regexps in the FilteredRE2.
-  std::vector<RE2 *> re2_vec_;
-
-  // Has the FilteredRE2 been compiled using Compile()
-  bool compiled_;
-
-  // An AND-OR tree of string atoms used for filtering regexps.
-  std::unique_ptr<PrefilterTree> prefilter_tree_;
-};
-
-} // namespace re2
-
-#endif // RE2_FILTERED_RE2_H_
diff --git a/packages/react-native-executorch/third-party/include/re2/re2.h b/packages/react-native-executorch/third-party/include/re2/re2.h
deleted file mode 100644
index 4be96db642..0000000000
--- a/packages/react-native-executorch/third-party/include/re2/re2.h
+++ /dev/null
@@ -1,1041 +0,0 @@
-// Copyright 2003-2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_RE2_H_
-#define RE2_RE2_H_
-
-// C++ interface to the re2 regular-expression library.
-// RE2 supports Perl-style regular expressions (with extensions like
-// \d, \w, \s, ...).
-//
-// -----------------------------------------------------------------------
-// REGEXP SYNTAX:
-//
-// This module uses the re2 library and hence supports
-// its syntax for regular expressions, which is similar to Perl's with
-// some of the more complicated things thrown away.  In particular,
-// backreferences and generalized assertions are not available, nor is \Z.
-//
-// See https://github.com/google/re2/wiki/Syntax for the syntax
-// supported by RE2, and a comparison with PCRE and PERL regexps.
-//
-// For those not familiar with Perl's regular expressions,
-// here are some examples of the most commonly used extensions:
-//
-//   "hello (\\w+) world"  -- \w matches a "word" character
-//   "version (\\d+)"      -- \d matches a digit
-//   "hello\\s+world"      -- \s matches any whitespace character
-//   "\\b(\\w+)\\b"        -- \b matches non-empty string at word boundary
-//   "(?i)hello"           -- (?i) turns on case-insensitive matching
-//   "/\\*(.*?)\\*/"       -- .*? matches . minimum no. of times possible
-//
-// The double backslashes are needed when writing C++ string literals.
-// However, they should NOT be used when writing C++11 raw string literals:
-//
-//   R"(hello (\w+) world)"  -- \w matches a "word" character
-//   R"(version (\d+))"      -- \d matches a digit
-//   R"(hello\s+world)"      -- \s matches any whitespace character
-//   R"(\b(\w+)\b)"          -- \b matches non-empty string at word boundary
-//   R"((?i)hello)"          -- (?i) turns on case-insensitive matching
-//   R"(/\*(.*?)\*/)"        -- .*? matches . minimum no. of times possible
-//
-// When using UTF-8 encoding, case-insensitive matching will perform
-// simple case folding, not full case folding.
-//
-// -----------------------------------------------------------------------
-// MATCHING INTERFACE:
-//
-// The "FullMatch" operation checks that supplied text matches a
-// supplied pattern exactly.
-//
-// Example: successful match
-//    ABSL_CHECK(RE2::FullMatch("hello", "h.*o"));
-//
-// Example: unsuccessful match (requires full match):
-//    ABSL_CHECK(!RE2::FullMatch("hello", "e"));
-//
-// -----------------------------------------------------------------------
-// UTF-8 AND THE MATCHING INTERFACE:
-//
-// By default, the pattern and input text are interpreted as UTF-8.
-// The RE2::Latin1 option causes them to be interpreted as Latin-1.
-//
-// Example:
-//    ABSL_CHECK(RE2::FullMatch(utf8_string, RE2(utf8_pattern)));
-//    ABSL_CHECK(RE2::FullMatch(latin1_string, RE2(latin1_pattern,
-//                                                 RE2::Latin1)));
-//
-// -----------------------------------------------------------------------
-// SUBMATCH EXTRACTION:
-//
-// You can supply extra pointer arguments to extract submatches.
-// On match failure, none of the pointees will have been modified.
-// On match success, the submatches will be converted (as necessary) and
-// their values will be assigned to their pointees until all conversions
-// have succeeded or one conversion has failed.
-// On conversion failure, the pointees will be in an indeterminate state
-// because the caller has no way of knowing which conversion failed.
-// However, conversion cannot fail for types like string and string_view
-// that do not inspect the submatch contents. Hence, in the common case
-// where all of the pointees are of such types, failure is always due to
-// match failure and thus none of the pointees will have been modified.
-//
-// Example: extracts "ruby" into "s" and 1234 into "i"
-//    int i;
-//    std::string s;
-//    ABSL_CHECK(RE2::FullMatch("ruby:1234", "(\\w+):(\\d+)", &s, &i));
-//
-// Example: extracts "ruby" into "s" and no value into "i"
-//    absl::optional<int> i;
-//    std::string s;
-//    ABSL_CHECK(RE2::FullMatch("ruby", "(\\w+)(?::(\\d+))?", &s, &i));
-//
-// Example: fails because string cannot be stored in integer
-//    ABSL_CHECK(!RE2::FullMatch("ruby", "(.*)", &i));
-//
-// Example: fails because there aren't enough sub-patterns
-//    ABSL_CHECK(!RE2::FullMatch("ruby:1234", "\\w+:\\d+", &s));
-//
-// Example: does not try to extract any extra sub-patterns
-//    ABSL_CHECK(RE2::FullMatch("ruby:1234", "(\\w+):(\\d+)", &s));
-//
-// Example: does not try to extract into NULL
-//    ABSL_CHECK(RE2::FullMatch("ruby:1234", "(\\w+):(\\d+)", NULL, &i));
-//
-// Example: integer overflow causes failure
-//    ABSL_CHECK(!RE2::FullMatch("ruby:1234567891234", "\\w+:(\\d+)", &i));
-//
-// NOTE(rsc): Asking for submatches slows successful matches quite a bit.
-// This may get a little faster in the future, but right now is slower
-// than PCRE.  On the other hand, failed matches run *very* fast (faster
-// than PCRE), as do matches without submatch extraction.
-//
-// -----------------------------------------------------------------------
-// PARTIAL MATCHES
-//
-// You can use the "PartialMatch" operation when you want the pattern
-// to match any substring of the text.
-//
-// Example: simple search for a string:
-//      ABSL_CHECK(RE2::PartialMatch("hello", "ell"));
-//
-// Example: find first number in a string
-//      int number;
-//      ABSL_CHECK(RE2::PartialMatch("x*100 + 20", "(\\d+)", &number));
-//      ABSL_CHECK_EQ(number, 100);
-//
-// -----------------------------------------------------------------------
-// PRE-COMPILED REGULAR EXPRESSIONS
-//
-// RE2 makes it easy to use any string as a regular expression, without
-// requiring a separate compilation step.
-//
-// If speed is of the essence, you can create a pre-compiled "RE2"
-// object from the pattern and use it multiple times.  If you do so,
-// you can typically parse text faster than with sscanf.
-//
-// Example: precompile pattern for faster matching:
-//    RE2 pattern("h.*o");
-//    while (ReadLine(&str)) {
-//      if (RE2::FullMatch(str, pattern)) ...;
-//    }
-//
-// -----------------------------------------------------------------------
-// SCANNING TEXT INCREMENTALLY
-//
-// The "Consume" operation may be useful if you want to repeatedly
-// match regular expressions at the front of a string and skip over
-// them as they match.  This requires use of the string_view type,
-// which represents a sub-range of a real string.
-//
-// Example: read lines of the form "var = value" from a string.
-//      std::string contents = ...;         // Fill string somehow
-//      absl::string_view input(contents);  // Wrap a string_view around it
-//
-//      std::string var;
-//      int value;
-//      while (RE2::Consume(&input, "(\\w+) = (\\d+)\n", &var, &value)) {
-//        ...;
-//      }
-//
-// Each successful call to "Consume" will set "var/value", and also
-// advance "input" so it points past the matched text.  Note that if the
-// regular expression matches an empty string, input will advance
-// by 0 bytes.  If the regular expression being used might match
-// an empty string, the loop body must check for this case and either
-// advance the string or break out of the loop.
-//
-// The "FindAndConsume" operation is similar to "Consume" but does not
-// anchor your match at the beginning of the string.  For example, you
-// could extract all words from a string by repeatedly calling
-//     RE2::FindAndConsume(&input, "(\\w+)", &word)
-//
-// -----------------------------------------------------------------------
-// USING VARIABLE NUMBER OF ARGUMENTS
-//
-// The above operations require you to know the number of arguments
-// when you write the code.  This is not always possible or easy (for
-// example, the regular expression may be calculated at run time).
-// You can use the "N" version of the operations when the number of
-// match arguments are determined at run time.
-//
-// Example:
-//   const RE2::Arg* args[10];
-//   int n;
-//   // ... populate args with pointers to RE2::Arg values ...
-//   // ... set n to the number of RE2::Arg objects ...
-//   bool match = RE2::FullMatchN(input, pattern, args, n);
-//
-// The last statement is equivalent to
-//
-//   bool match = RE2::FullMatch(input, pattern,
-//                               *args[0], *args[1], ..., *args[n - 1]);
-//
-// -----------------------------------------------------------------------
-// PARSING HEX/OCTAL/C-RADIX NUMBERS
-//
-// By default, if you pass a pointer to a numeric value, the
-// corresponding text is interpreted as a base-10 number.  You can
-// instead wrap the pointer with a call to one of the operators Hex(),
-// Octal(), or CRadix() to interpret the text in another base.  The
-// CRadix operator interprets C-style "0" (base-8) and "0x" (base-16)
-// prefixes, but defaults to base-10.
-//
-// Example:
-//   int a, b, c, d;
-//   ABSL_CHECK(RE2::FullMatch("100 40 0100 0x40", "(.*) (.*) (.*) (.*)",
-//         RE2::Octal(&a), RE2::Hex(&b), RE2::CRadix(&c), RE2::CRadix(&d));
-// will leave 64 in a, b, c, and d.
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <algorithm>
-#include <map>
-#include <string>
-#include <type_traits>
-#include <vector>
-
-#include "absl/base/call_once.h"
-#include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
-#include "re2/stringpiece.h"
-
-#if defined(__APPLE__)
-#include <TargetConditionals.h>
-#endif
-
-namespace re2 {
-class Prog;
-class Regexp;
-} // namespace re2
-
-namespace re2 {
-
-// Interface for regular expression matching.  Also corresponds to a
-// pre-compiled regular expression.  An "RE2" object is safe for
-// concurrent use by multiple threads.
-class RE2 {
-public:
-  // We convert user-passed pointers into special Arg objects
-  class Arg;
-  class Options;
-
-  // Defined in set.h.
-  class Set;
-
-  enum ErrorCode {
-    NoError = 0,
-
-    // Unexpected error
-    ErrorInternal,
-
-    // Parse errors
-    ErrorBadEscape,         // bad escape sequence
-    ErrorBadCharClass,      // bad character class
-    ErrorBadCharRange,      // bad character class range
-    ErrorMissingBracket,    // missing closing ]
-    ErrorMissingParen,      // missing closing )
-    ErrorUnexpectedParen,   // unexpected closing )
-    ErrorTrailingBackslash, // trailing \ at end of regexp
-    ErrorRepeatArgument,    // repeat argument missing, e.g. "*"
-    ErrorRepeatSize,        // bad repetition argument
-    ErrorRepeatOp,          // bad repetition operator
-    ErrorBadPerlOp,         // bad perl operator
-    ErrorBadUTF8,           // invalid UTF-8 in regexp
-    ErrorBadNamedCapture,   // bad named capture group
-    ErrorPatternTooLarge    // pattern too large (compile failed)
-  };
-
-  // Predefined common options.
-  // If you need more complicated things, instantiate
-  // an Option class, possibly passing one of these to
-  // the Option constructor, change the settings, and pass that
-  // Option class to the RE2 constructor.
-  enum CannedOptions {
-    DefaultOptions = 0,
-    Latin1, // treat input as Latin-1 (default UTF-8)
-    POSIX,  // POSIX syntax, leftmost-longest match
-    Quiet   // do not log about regexp parse errors
-  };
-
-  // Need to have the const char* and const std::string& forms for implicit
-  // conversions when passing string literals to FullMatch and PartialMatch.
-  // Otherwise the absl::string_view form would be sufficient.
-  RE2(const char *pattern);
-  RE2(const std::string &pattern);
-  RE2(absl::string_view pattern);
-  RE2(absl::string_view pattern, const Options &options);
-  ~RE2();
-
-  // Not copyable.
-  // RE2 objects are expensive. You should probably use std::shared_ptr<RE2>
-  // instead. If you really must copy, RE2(first.pattern(), first.options())
-  // effectively does so: it produces a second object that mimics the first.
-  RE2(const RE2 &) = delete;
-  RE2 &operator=(const RE2 &) = delete;
-  // Not movable.
-  // RE2 objects are thread-safe and logically immutable. You should probably
-  // use std::unique_ptr<RE2> instead. Otherwise, consider std::deque<RE2> if
-  // direct emplacement into a container is desired. If you really must move,
-  // be prepared to submit a design document along with your feature request.
-  RE2(RE2 &&) = delete;
-  RE2 &operator=(RE2 &&) = delete;
-
-  // Returns whether RE2 was created properly.
-  bool ok() const { return error_code() == NoError; }
-
-  // The string specification for this RE2.  E.g.
-  //   RE2 re("ab*c?d+");
-  //   re.pattern();    // "ab*c?d+"
-  const std::string &pattern() const { return *pattern_; }
-
-  // If RE2 could not be created properly, returns an error string.
-  // Else returns the empty string.
-  const std::string &error() const { return *error_; }
-
-  // If RE2 could not be created properly, returns an error code.
-  // Else returns RE2::NoError (== 0).
-  ErrorCode error_code() const { return error_code_; }
-
-  // If RE2 could not be created properly, returns the offending
-  // portion of the regexp.
-  const std::string &error_arg() const { return *error_arg_; }
-
-  // Returns the program size, a very approximate measure of a regexp's "cost".
-  // Larger numbers are more expensive than smaller numbers.
-  int ProgramSize() const;
-  int ReverseProgramSize() const;
-
-  // If histogram is not null, outputs the program fanout
-  // as a histogram bucketed by powers of 2.
-  // Returns the number of the largest non-empty bucket.
-  int ProgramFanout(std::vector<int> *histogram) const;
-  int ReverseProgramFanout(std::vector<int> *histogram) const;
-
-  // Returns the underlying Regexp; not for general use.
-  // Returns entire_regexp_ so that callers don't need
-  // to know about prefix_ and prefix_foldcase_.
-  re2::Regexp *Regexp() const { return entire_regexp_; }
-
-  /***** The array-based matching interface ******/
-
-  // The functions here have names ending in 'N' and are used to implement
-  // the functions whose names are the prefix before the 'N'. It is sometimes
-  // useful to invoke them directly, but the syntax is awkward, so the 'N'-less
-  // versions should be preferred.
-  static bool FullMatchN(absl::string_view text, const RE2 &re,
-                         const Arg *const args[], int n);
-  static bool PartialMatchN(absl::string_view text, const RE2 &re,
-                            const Arg *const args[], int n);
-  static bool ConsumeN(absl::string_view *input, const RE2 &re,
-                       const Arg *const args[], int n);
-  static bool FindAndConsumeN(absl::string_view *input, const RE2 &re,
-                              const Arg *const args[], int n);
-
-private:
-  template <typename F, typename SP>
-  static inline bool Apply(F f, SP sp, const RE2 &re) {
-    return f(sp, re, NULL, 0);
-  }
-
-  template <typename F, typename SP, typename... A>
-  static inline bool Apply(F f, SP sp, const RE2 &re, const A &...a) {
-    const Arg *const args[] = {&a...};
-    const int n = sizeof...(a);
-    return f(sp, re, args, n);
-  }
-
-public:
-  // In order to allow FullMatch() et al. to be called with a varying number
-  // of arguments of varying types, we use two layers of variadic templates.
-  // The first layer constructs the temporary Arg objects. The second layer
-  // (above) constructs the array of pointers to the temporary Arg objects.
-
-  /***** The useful part: the matching interface *****/
-
-  // Matches "text" against "re".  If pointer arguments are
-  // supplied, copies matched sub-patterns into them.
-  //
-  // You can pass in a "const char*" or a "std::string" for "text".
-  // You can pass in a "const char*" or a "std::string" or a "RE2" for "re".
-  //
-  // The provided pointer arguments can be pointers to any scalar numeric
-  // type, or one of:
-  //    std::string        (matched piece is copied to string)
-  //    absl::string_view  (string_view is mutated to point to matched piece)
-  //    absl::optional<T>  (T is a supported numeric or string type as above)
-  //    T                  ("bool T::ParseFrom(const char*, size_t)" must exist)
-  //    (void*)NULL        (the corresponding matched sub-pattern is not copied)
-  //
-  // Returns true iff all of the following conditions are satisfied:
-  //   a. "text" matches "re" fully - from the beginning to the end of "text".
-  //   b. The number of matched sub-patterns is >= number of supplied pointers.
-  //   c. The "i"th argument has a suitable type for holding the
-  //      string captured as the "i"th sub-pattern.  If you pass in
-  //      NULL for the "i"th argument, or pass fewer arguments than
-  //      number of sub-patterns, the "i"th captured sub-pattern is
-  //      ignored.
-  //
-  // CAVEAT: An optional sub-pattern that does not exist in the
-  // matched string is assigned the null string.  Therefore, the
-  // following returns false because the null string - absence of
-  // a string (not even the empty string) - is not a valid number:
-  //
-  //    int number;
-  //    RE2::FullMatch("abc", "[a-z]+(\\d+)?", &number);
-  //
-  // Use absl::optional<int> instead to handle this case correctly.
-  template <typename... A>
-  static bool FullMatch(absl::string_view text, const RE2 &re, A &&...a) {
-    return Apply(FullMatchN, text, re, Arg(std::forward<A>(a))...);
-  }
-
-  // Like FullMatch(), except that "re" is allowed to match a substring
-  // of "text".
-  //
-  // Returns true iff all of the following conditions are satisfied:
-  //   a. "text" matches "re" partially - for some substring of "text".
-  //   b. The number of matched sub-patterns is >= number of supplied pointers.
-  //   c. The "i"th argument has a suitable type for holding the
-  //      string captured as the "i"th sub-pattern.  If you pass in
-  //      NULL for the "i"th argument, or pass fewer arguments than
-  //      number of sub-patterns, the "i"th captured sub-pattern is
-  //      ignored.
-  template <typename... A>
-  static bool PartialMatch(absl::string_view text, const RE2 &re, A &&...a) {
-    return Apply(PartialMatchN, text, re, Arg(std::forward<A>(a))...);
-  }
-
-  // Like FullMatch() and PartialMatch(), except that "re" has to match
-  // a prefix of the text, and "input" is advanced past the matched
-  // text.  Note: "input" is modified iff this routine returns true
-  // and "re" matched a non-empty substring of "input".
-  //
-  // Returns true iff all of the following conditions are satisfied:
-  //   a. "input" matches "re" partially - for some prefix of "input".
-  //   b. The number of matched sub-patterns is >= number of supplied pointers.
-  //   c. The "i"th argument has a suitable type for holding the
-  //      string captured as the "i"th sub-pattern.  If you pass in
-  //      NULL for the "i"th argument, or pass fewer arguments than
-  //      number of sub-patterns, the "i"th captured sub-pattern is
-  //      ignored.
-  template <typename... A>
-  static bool Consume(absl::string_view *input, const RE2 &re, A &&...a) {
-    return Apply(ConsumeN, input, re, Arg(std::forward<A>(a))...);
-  }
-
-  // Like Consume(), but does not anchor the match at the beginning of
-  // the text.  That is, "re" need not start its match at the beginning
-  // of "input".  For example, "FindAndConsume(s, "(\\w+)", &word)" finds
-  // the next word in "s" and stores it in "word".
-  //
-  // Returns true iff all of the following conditions are satisfied:
-  //   a. "input" matches "re" partially - for some substring of "input".
-  //   b. The number of matched sub-patterns is >= number of supplied pointers.
-  //   c. The "i"th argument has a suitable type for holding the
-  //      string captured as the "i"th sub-pattern.  If you pass in
-  //      NULL for the "i"th argument, or pass fewer arguments than
-  //      number of sub-patterns, the "i"th captured sub-pattern is
-  //      ignored.
-  template <typename... A>
-  static bool FindAndConsume(absl::string_view *input, const RE2 &re,
-                             A &&...a) {
-    return Apply(FindAndConsumeN, input, re, Arg(std::forward<A>(a))...);
-  }
-
-  // Replace the first match of "re" in "str" with "rewrite".
-  // Within "rewrite", backslash-escaped digits (\1 to \9) can be
-  // used to insert text matching corresponding parenthesized group
-  // from the pattern.  \0 in "rewrite" refers to the entire matching
-  // text.  E.g.,
-  //
-  //   std::string s = "yabba dabba doo";
-  //   ABSL_CHECK(RE2::Replace(&s, "b+", "d"));
-  //
-  // will leave "s" containing "yada dabba doo"
-  //
-  // Returns true if the pattern matches and a replacement occurs,
-  // false otherwise.
-  static bool Replace(std::string *str, const RE2 &re,
-                      absl::string_view rewrite);
-
-  // Like Replace(), except replaces successive non-overlapping occurrences
-  // of the pattern in the string with the rewrite. E.g.
-  //
-  //   std::string s = "yabba dabba doo";
-  //   ABSL_CHECK(RE2::GlobalReplace(&s, "b+", "d"));
-  //
-  // will leave "s" containing "yada dada doo"
-  // Replacements are not subject to re-matching.
-  //
-  // Because GlobalReplace only replaces non-overlapping matches,
-  // replacing "ana" within "banana" makes only one replacement, not two.
-  //
-  // Returns the number of replacements made.
-  static int GlobalReplace(std::string *str, const RE2 &re,
-                           absl::string_view rewrite);
-
-  // Like Replace, except that if the pattern matches, "rewrite"
-  // is copied into "out" with substitutions.  The non-matching
-  // portions of "text" are ignored.
-  //
-  // Returns true iff a match occurred and the extraction happened
-  // successfully;  if no match occurs, the string is left unaffected.
-  //
-  // REQUIRES: "text" must not alias any part of "*out".
-  static bool Extract(absl::string_view text, const RE2 &re,
-                      absl::string_view rewrite, std::string *out);
-
-  // Escapes all potentially meaningful regexp characters in
-  // 'unquoted'.  The returned string, used as a regular expression,
-  // will match exactly the original string.  For example,
-  //           1.5-2.0?
-  // may become:
-  //           1\.5\-2\.0\?
-  static std::string QuoteMeta(absl::string_view unquoted);
-
-  // Computes range for any strings matching regexp. The min and max can in
-  // some cases be arbitrarily precise, so the caller gets to specify the
-  // maximum desired length of string returned.
-  //
-  // Assuming PossibleMatchRange(&min, &max, N) returns successfully, any
-  // string s that is an anchored match for this regexp satisfies
-  //   min <= s && s <= max.
-  //
-  // Note that PossibleMatchRange() will only consider the first copy of an
-  // infinitely repeated element (i.e., any regexp element followed by a '*' or
-  // '+' operator). Regexps with "{N}" constructions are not affected, as those
-  // do not compile down to infinite repetitions.
-  //
-  // Returns true on success, false on error.
-  bool PossibleMatchRange(std::string *min, std::string *max, int maxlen) const;
-
-  // Generic matching interface
-
-  // Type of match.
-  enum Anchor {
-    UNANCHORED,   // No anchoring
-    ANCHOR_START, // Anchor at start only
-    ANCHOR_BOTH   // Anchor at start and end
-  };
-
-  // Return the number of capturing sub-patterns, or -1 if the
-  // regexp wasn't valid on construction.  The overall match ($0)
-  // does not count: if the regexp is "(a)(b)", returns 2.
-  int NumberOfCapturingGroups() const { return num_captures_; }
-
-  // Return a map from names to capturing indices.
-  // The map records the index of the leftmost group
-  // with the given name.
-  // Only valid until the re is deleted.
-  const std::map<std::string, int> &NamedCapturingGroups() const;
-
-  // Return a map from capturing indices to names.
-  // The map has no entries for unnamed groups.
-  // Only valid until the re is deleted.
-  const std::map<int, std::string> &CapturingGroupNames() const;
-
-  // General matching routine.
-  // Match against text starting at offset startpos
-  // and stopping the search at offset endpos.
-  // Returns true if match found, false if not.
-  // On a successful match, fills in submatch[] (up to nsubmatch entries)
-  // with information about submatches.
-  // I.e. matching RE2("(foo)|(bar)baz") on "barbazbla" will return true, with
-  // submatch[0] = "barbaz", submatch[1].data() = NULL, submatch[2] = "bar",
-  // submatch[3].data() = NULL, ..., up to submatch[nsubmatch-1].data() = NULL.
-  // Caveat: submatch[] may be clobbered even on match failure.
-  //
-  // Don't ask for more match information than you will use:
-  // runs much faster with nsubmatch == 1 than nsubmatch > 1, and
-  // runs even faster if nsubmatch == 0.
-  // Doesn't make sense to use nsubmatch > 1 + NumberOfCapturingGroups(),
-  // but will be handled correctly.
-  //
-  // Passing text == absl::string_view() will be handled like any other
-  // empty string, but note that on return, it will not be possible to tell
-  // whether submatch i matched the empty string or did not match:
-  // either way, submatch[i].data() == NULL.
-  bool Match(absl::string_view text, size_t startpos, size_t endpos,
-             Anchor re_anchor, absl::string_view *submatch,
-             int nsubmatch) const;
-
-  // Check that the given rewrite string is suitable for use with this
-  // regular expression.  It checks that:
-  //   * The regular expression has enough parenthesized subexpressions
-  //     to satisfy all of the \N tokens in rewrite
-  //   * The rewrite string doesn't have any syntax errors.  E.g.,
-  //     '\' followed by anything other than a digit or '\'.
-  // A true return value guarantees that Replace() and Extract() won't
-  // fail because of a bad rewrite string.
-  bool CheckRewriteString(absl::string_view rewrite, std::string *error) const;
-
-  // Returns the maximum submatch needed for the rewrite to be done by
-  // Replace(). E.g. if rewrite == "foo \\2,\\1", returns 2.
-  static int MaxSubmatch(absl::string_view rewrite);
-
-  // Append the "rewrite" string, with backslash substitutions from "vec",
-  // to string "out".
-  // Returns true on success.  This method can fail because of a malformed
-  // rewrite string.  CheckRewriteString guarantees that the rewrite will
-  // be sucessful.
-  bool Rewrite(std::string *out, absl::string_view rewrite,
-               const absl::string_view *vec, int veclen) const;
-
-  // Constructor options
-  class Options {
-  public:
-    // The options are (defaults in parentheses):
-    //
-    //   utf8             (true)  text and pattern are UTF-8; otherwise Latin-1
-    //   posix_syntax     (false) restrict regexps to POSIX egrep syntax
-    //   longest_match    (false) search for longest match, not first match
-    //   log_errors       (true)  log syntax and execution errors to ERROR
-    //   max_mem          (see below)  approx. max memory footprint of RE2
-    //   literal          (false) interpret string as literal, not regexp
-    //   never_nl         (false) never match \n, even if it is in regexp
-    //   dot_nl           (false) dot matches everything including new line
-    //   never_capture    (false) parse all parens as non-capturing
-    //   case_sensitive   (true)  match is case-sensitive (regexp can override
-    //                              with (?i) unless in posix_syntax mode)
-    //
-    // The following options are only consulted when posix_syntax == true.
-    // When posix_syntax == false, these features are always enabled and
-    // cannot be turned off; to perform multi-line matching in that case,
-    // begin the regexp with (?m).
-    //   perl_classes     (false) allow Perl's \d \s \w \D \S \W
-    //   word_boundary    (false) allow Perl's \b \B (word boundary and not)
-    //   one_line         (false) ^ and $ only match beginning and end of text
-    //
-    // The max_mem option controls how much memory can be used
-    // to hold the compiled form of the regexp (the Prog) and
-    // its cached DFA graphs.  Code Search placed limits on the number
-    // of Prog instructions and DFA states: 10,000 for both.
-    // In RE2, those limits would translate to about 240 KB per Prog
-    // and perhaps 2.5 MB per DFA (DFA state sizes vary by regexp; RE2 does a
-    // better job of keeping them small than Code Search did).
-    // Each RE2 has two Progs (one forward, one reverse), and each Prog
-    // can have two DFAs (one first match, one longest match).
-    // That makes 4 DFAs:
-    //
-    //   forward, first-match    - used for UNANCHORED or ANCHOR_START searches
-    //                               if opt.longest_match() == false
-    //   forward, longest-match  - used for all ANCHOR_BOTH searches,
-    //                               and the other two kinds if
-    //                               opt.longest_match() == true
-    //   reverse, first-match    - never used
-    //   reverse, longest-match  - used as second phase for unanchored searches
-    //
-    // The RE2 memory budget is statically divided between the two
-    // Progs and then the DFAs: two thirds to the forward Prog
-    // and one third to the reverse Prog.  The forward Prog gives half
-    // of what it has left over to each of its DFAs.  The reverse Prog
-    // gives it all to its longest-match DFA.
-    //
-    // Once a DFA fills its budget, it flushes its cache and starts over.
-    // If this happens too often, RE2 falls back on the NFA implementation.
-
-    // For now, make the default budget something close to Code Search.
-    static const int kDefaultMaxMem = 8 << 20;
-
-    enum Encoding { EncodingUTF8 = 1, EncodingLatin1 };
-
-    Options()
-        : max_mem_(kDefaultMaxMem), encoding_(EncodingUTF8),
-          posix_syntax_(false), longest_match_(false), log_errors_(true),
-          literal_(false), never_nl_(false), dot_nl_(false),
-          never_capture_(false), case_sensitive_(true), perl_classes_(false),
-          word_boundary_(false), one_line_(false) {}
-
-    /*implicit*/ Options(CannedOptions);
-
-    int64_t max_mem() const { return max_mem_; }
-    void set_max_mem(int64_t m) { max_mem_ = m; }
-
-    Encoding encoding() const { return encoding_; }
-    void set_encoding(Encoding encoding) { encoding_ = encoding; }
-
-    bool posix_syntax() const { return posix_syntax_; }
-    void set_posix_syntax(bool b) { posix_syntax_ = b; }
-
-    bool longest_match() const { return longest_match_; }
-    void set_longest_match(bool b) { longest_match_ = b; }
-
-    bool log_errors() const { return log_errors_; }
-    void set_log_errors(bool b) { log_errors_ = b; }
-
-    bool literal() const { return literal_; }
-    void set_literal(bool b) { literal_ = b; }
-
-    bool never_nl() const { return never_nl_; }
-    void set_never_nl(bool b) { never_nl_ = b; }
-
-    bool dot_nl() const { return dot_nl_; }
-    void set_dot_nl(bool b) { dot_nl_ = b; }
-
-    bool never_capture() const { return never_capture_; }
-    void set_never_capture(bool b) { never_capture_ = b; }
-
-    bool case_sensitive() const { return case_sensitive_; }
-    void set_case_sensitive(bool b) { case_sensitive_ = b; }
-
-    bool perl_classes() const { return perl_classes_; }
-    void set_perl_classes(bool b) { perl_classes_ = b; }
-
-    bool word_boundary() const { return word_boundary_; }
-    void set_word_boundary(bool b) { word_boundary_ = b; }
-
-    bool one_line() const { return one_line_; }
-    void set_one_line(bool b) { one_line_ = b; }
-
-    void Copy(const Options &src) { *this = src; }
-
-    int ParseFlags() const;
-
-  private:
-    int64_t max_mem_;
-    Encoding encoding_;
-    bool posix_syntax_;
-    bool longest_match_;
-    bool log_errors_;
-    bool literal_;
-    bool never_nl_;
-    bool dot_nl_;
-    bool never_capture_;
-    bool case_sensitive_;
-    bool perl_classes_;
-    bool word_boundary_;
-    bool one_line_;
-  };
-
-  // Returns the options set in the constructor.
-  const Options &options() const { return options_; }
-
-  // Argument converters; see below.
-  template <typename T> static Arg CRadix(T *ptr);
-  template <typename T> static Arg Hex(T *ptr);
-  template <typename T> static Arg Octal(T *ptr);
-
-  // Controls the maximum count permitted by GlobalReplace(); -1 is unlimited.
-  // FOR FUZZING ONLY.
-  static void FUZZING_ONLY_set_maximum_global_replace_count(int i);
-
-private:
-  void Init(absl::string_view pattern, const Options &options);
-
-  bool DoMatch(absl::string_view text, Anchor re_anchor, size_t *consumed,
-               const Arg *const args[], int n) const;
-
-  re2::Prog *ReverseProg() const;
-
-  // First cache line is relatively cold fields.
-  const std::string *pattern_;   // string regular expression
-  Options options_;              // option flags
-  re2::Regexp *entire_regexp_;   // parsed regular expression
-  re2::Regexp *suffix_regexp_;   // parsed regular expression, prefix_ removed
-  const std::string *error_;     // error indicator (or points to empty string)
-  const std::string *error_arg_; // fragment of regexp showing error (or ditto)
-
-  // Second cache line is relatively hot fields.
-  // These are ordered oddly to pack everything.
-  int num_captures_;          // number of capturing groups
-  ErrorCode error_code_ : 29; // error code (29 bits is more than enough)
-  bool longest_match_ : 1;    // cached copy of options_.longest_match()
-  bool is_one_pass_ : 1;      // can use prog_->SearchOnePass?
-  bool prefix_foldcase_ : 1;  // prefix_ is ASCII case-insensitive
-  std::string prefix_;        // required prefix (before suffix_regexp_)
-  re2::Prog *prog_;           // compiled program for regexp
-
-  // Reverse Prog for DFA execution only
-  mutable re2::Prog *rprog_;
-  // Map from capture names to indices
-  mutable const std::map<std::string, int> *named_groups_;
-  // Map from capture indices to names
-  mutable const std::map<int, std::string> *group_names_;
-
-  mutable absl::once_flag rprog_once_;
-  mutable absl::once_flag named_groups_once_;
-  mutable absl::once_flag group_names_once_;
-};
-
-/***** Implementation details *****/
-
-namespace re2_internal {
-
-// Types for which the 3-ary Parse() function template has specializations.
-template <typename T> struct Parse3ary : public std::false_type {};
-template <> struct Parse3ary<void> : public std::true_type {};
-template <> struct Parse3ary<std::string> : public std::true_type {};
-template <> struct Parse3ary<absl::string_view> : public std::true_type {};
-template <> struct Parse3ary<char> : public std::true_type {};
-template <> struct Parse3ary<signed char> : public std::true_type {};
-template <> struct Parse3ary<unsigned char> : public std::true_type {};
-template <> struct Parse3ary<float> : public std::true_type {};
-template <> struct Parse3ary<double> : public std::true_type {};
-
-template <typename T> bool Parse(const char *str, size_t n, T *dest);
-
-// Types for which the 4-ary Parse() function template has specializations.
-template <typename T> struct Parse4ary : public std::false_type {};
-template <> struct Parse4ary<long> : public std::true_type {};
-template <> struct Parse4ary<unsigned long> : public std::true_type {};
-template <> struct Parse4ary<short> : public std::true_type {};
-template <> struct Parse4ary<unsigned short> : public std::true_type {};
-template <> struct Parse4ary<int> : public std::true_type {};
-template <> struct Parse4ary<unsigned int> : public std::true_type {};
-template <> struct Parse4ary<long long> : public std::true_type {};
-template <> struct Parse4ary<unsigned long long> : public std::true_type {};
-
-template <typename T> bool Parse(const char *str, size_t n, T *dest, int radix);
-
-// Support absl::optional<T> for all T with a stock parser.
-template <typename T>
-struct Parse3ary<absl::optional<T>> : public Parse3ary<T> {};
-template <typename T>
-struct Parse4ary<absl::optional<T>> : public Parse4ary<T> {};
-
-template <typename T>
-bool Parse(const char *str, size_t n, absl::optional<T> *dest) {
-  if (str == NULL) {
-    if (dest != NULL)
-      dest->reset();
-    return true;
-  }
-  T tmp;
-  if (Parse(str, n, &tmp)) {
-    if (dest != NULL)
-      dest->emplace(std::move(tmp));
-    return true;
-  }
-  return false;
-}
-
-template <typename T>
-bool Parse(const char *str, size_t n, absl::optional<T> *dest, int radix) {
-  if (str == NULL) {
-    if (dest != NULL)
-      dest->reset();
-    return true;
-  }
-  T tmp;
-  if (Parse(str, n, &tmp, radix)) {
-    if (dest != NULL)
-      dest->emplace(std::move(tmp));
-    return true;
-  }
-  return false;
-}
-
-} // namespace re2_internal
-
-class RE2::Arg {
-private:
-  template <typename T>
-  using CanParse3ary =
-      typename std::enable_if<re2_internal::Parse3ary<T>::value, int>::type;
-
-  template <typename T>
-  using CanParse4ary =
-      typename std::enable_if<re2_internal::Parse4ary<T>::value, int>::type;
-
-  template <typename T>
-  using CanParseFrom = typename std::enable_if<
-      std::is_member_function_pointer<
-          decltype(static_cast<bool (T::*)(const char *, size_t)>(
-              &T::ParseFrom))>::value,
-      int>::type;
-
-public:
-  Arg() : Arg(nullptr) {}
-  Arg(std::nullptr_t ptr) : arg_(ptr), parser_(DoNothing) {}
-
-  template <typename T, CanParse3ary<T> = 0>
-  Arg(T *ptr) : arg_(ptr), parser_(DoParse3ary<T>) {}
-
-  template <typename T, CanParse4ary<T> = 0>
-  Arg(T *ptr) : arg_(ptr), parser_(DoParse4ary<T>) {}
-
-  template <typename T, CanParseFrom<T> = 0>
-  Arg(T *ptr) : arg_(ptr), parser_(DoParseFrom<T>) {}
-
-  typedef bool (*Parser)(const char *str, size_t n, void *dest);
-
-  template <typename T>
-  Arg(T *ptr, Parser parser) : arg_(ptr), parser_(parser) {}
-
-  bool Parse(const char *str, size_t n) const {
-    return (*parser_)(str, n, arg_);
-  }
-
-private:
-  static bool DoNothing(const char * /*str*/, size_t /*n*/, void * /*dest*/) {
-    return true;
-  }
-
-  template <typename T>
-  static bool DoParse3ary(const char *str, size_t n, void *dest) {
-    return re2_internal::Parse(str, n, reinterpret_cast<T *>(dest));
-  }
-
-  template <typename T>
-  static bool DoParse4ary(const char *str, size_t n, void *dest) {
-    return re2_internal::Parse(str, n, reinterpret_cast<T *>(dest), 10);
-  }
-
-  template <typename T>
-  static bool DoParseFrom(const char *str, size_t n, void *dest) {
-    if (dest == NULL)
-      return true;
-    return reinterpret_cast<T *>(dest)->ParseFrom(str, n);
-  }
-
-  void *arg_;
-  Parser parser_;
-};
-
-template <typename T> inline RE2::Arg RE2::CRadix(T *ptr) {
-  return RE2::Arg(ptr, [](const char *str, size_t n, void *dest) -> bool {
-    return re2_internal::Parse(str, n, reinterpret_cast<T *>(dest), 0);
-  });
-}
-
-template <typename T> inline RE2::Arg RE2::Hex(T *ptr) {
-  return RE2::Arg(ptr, [](const char *str, size_t n, void *dest) -> bool {
-    return re2_internal::Parse(str, n, reinterpret_cast<T *>(dest), 16);
-  });
-}
-
-template <typename T> inline RE2::Arg RE2::Octal(T *ptr) {
-  return RE2::Arg(ptr, [](const char *str, size_t n, void *dest) -> bool {
-    return re2_internal::Parse(str, n, reinterpret_cast<T *>(dest), 8);
-  });
-}
-
-// Silence warnings about missing initializers for members of LazyRE2.
-#if defined(__GNUC__)
-#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
-#endif
-
-// Helper for writing global or static RE2s safely.
-// Write
-//     static LazyRE2 re = {".*"};
-// and then use *re instead of writing
-//     static RE2 re(".*");
-// The former is more careful about multithreaded
-// situations than the latter.
-//
-// N.B. This class never deletes the RE2 object that
-// it constructs: that's a feature, so that it can be used
-// for global and function static variables.
-class LazyRE2 {
-private:
-  struct NoArg {};
-
-public:
-  typedef RE2 element_type; // support std::pointer_traits
-
-  // Constructor omitted to preserve braced initialization in C++98.
-
-  // Pretend to be a pointer to Type (never NULL due to on-demand creation):
-  RE2 &operator*() const { return *get(); }
-  RE2 *operator->() const { return get(); }
-
-  // Named accessor/initializer:
-  RE2 *get() const {
-    absl::call_once(once_, &LazyRE2::Init, this);
-    return ptr_;
-  }
-
-  // All data fields must be public to support {"foo"} initialization.
-  const char *pattern_;
-  RE2::CannedOptions options_;
-  NoArg barrier_against_excess_initializers_;
-
-  mutable RE2 *ptr_;
-  mutable absl::once_flag once_;
-
-private:
-  static void Init(const LazyRE2 *lazy_re2) {
-    lazy_re2->ptr_ = new RE2(lazy_re2->pattern_, lazy_re2->options_);
-  }
-
-  void operator=(const LazyRE2 &); // disallowed
-};
-
-namespace hooks {
-
-// Most platforms support thread_local. Older versions of iOS don't support
-// thread_local, but for the sake of brevity, we lump together all versions
-// of Apple platforms that aren't macOS. If an iOS application really needs
-// the context pointee someday, we can get more specific then...
-//
-// As per https://github.com/google/re2/issues/325, thread_local support in
-// MinGW seems to be buggy. (FWIW, Abseil folks also avoid it.)
-#define RE2_HAVE_THREAD_LOCAL
-#if (defined(__APPLE__) && !(defined(TARGET_OS_OSX) && TARGET_OS_OSX)) ||      \
-    defined(__MINGW32__)
-#undef RE2_HAVE_THREAD_LOCAL
-#endif
-
-// A hook must not make any assumptions regarding the lifetime of the context
-// pointee beyond the current invocation of the hook. Pointers and references
-// obtained via the context pointee should be considered invalidated when the
-// hook returns. Hence, any data about the context pointee (e.g. its pattern)
-// would have to be copied in order for it to be kept for an indefinite time.
-//
-// A hook must not use RE2 for matching. Control flow reentering RE2::Match()
-// could result in infinite mutual recursion. To discourage that possibility,
-// RE2 will not maintain the context pointer correctly when used in that way.
-#ifdef RE2_HAVE_THREAD_LOCAL
-extern thread_local const RE2 *context;
-#endif
-
-struct DFAStateCacheReset {
-  int64_t state_budget;
-  size_t state_cache_size;
-};
-
-struct DFASearchFailure {
-  // Nothing yet...
-};
-
-#define DECLARE_HOOK(type)                                                     \
-  using type##Callback = void(const type &);                                   \
-  void Set##type##Hook(type##Callback *cb);                                    \
-  type##Callback *Get##type##Hook();
-
-DECLARE_HOOK(DFAStateCacheReset)
-DECLARE_HOOK(DFASearchFailure)
-
-#undef DECLARE_HOOK
-
-} // namespace hooks
-
-} // namespace re2
-
-using re2::LazyRE2;
-using re2::RE2;
-
-#endif // RE2_RE2_H_
diff --git a/packages/react-native-executorch/third-party/include/re2/set.h b/packages/react-native-executorch/third-party/include/re2/set.h
deleted file mode 100644
index 9a02450759..0000000000
--- a/packages/react-native-executorch/third-party/include/re2/set.h
+++ /dev/null
@@ -1,86 +0,0 @@
-// Copyright 2010 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_SET_H_
-#define RE2_SET_H_
-
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "absl/strings/string_view.h"
-#include "re2/re2.h"
-
-namespace re2 {
-class Prog;
-class Regexp;
-} // namespace re2
-
-namespace re2 {
-
-// An RE2::Set represents a collection of regexps that can
-// be searched for simultaneously.
-class RE2::Set {
-public:
-  enum ErrorKind {
-    kNoError = 0,
-    kNotCompiled,  // The set is not compiled.
-    kOutOfMemory,  // The DFA ran out of memory.
-    kInconsistent, // The result is inconsistent. This should never happen.
-  };
-
-  struct ErrorInfo {
-    ErrorKind kind;
-  };
-
-  Set(const RE2::Options &options, RE2::Anchor anchor);
-  ~Set();
-
-  // Not copyable.
-  Set(const Set &) = delete;
-  Set &operator=(const Set &) = delete;
-  // Movable.
-  Set(Set &&other);
-  Set &operator=(Set &&other);
-
-  // Adds pattern to the set using the options passed to the constructor.
-  // Returns the index that will identify the regexp in the output of Match(),
-  // or -1 if the regexp cannot be parsed.
-  // Indices are assigned in sequential order starting from 0.
-  // Errors do not increment the index; if error is not NULL, *error will hold
-  // the error message from the parser.
-  int Add(absl::string_view pattern, std::string *error);
-
-  // Compiles the set in preparation for matching.
-  // Returns false if the compiler runs out of memory.
-  // Add() must not be called again after Compile().
-  // Compile() must be called before Match().
-  bool Compile();
-
-  // Returns true if text matches at least one of the regexps in the set.
-  // Fills v (if not NULL) with the indices of the matching regexps.
-  // Callers must not expect v to be sorted.
-  bool Match(absl::string_view text, std::vector<int> *v) const;
-
-  // As above, but populates error_info (if not NULL) when none of the regexps
-  // in the set matched. This can inform callers when DFA execution fails, for
-  // example, because they might wish to handle that case differently.
-  bool Match(absl::string_view text, std::vector<int> *v,
-             ErrorInfo *error_info) const;
-
-private:
-  typedef std::pair<std::string, re2::Regexp *> Elem;
-
-  RE2::Options options_;
-  RE2::Anchor anchor_;
-  std::vector<Elem> elem_;
-  bool compiled_;
-  int size_;
-  std::unique_ptr<re2::Prog> prog_;
-};
-
-} // namespace re2
-
-#endif // RE2_SET_H_
diff --git a/packages/react-native-executorch/third-party/include/re2/stringpiece.h b/packages/react-native-executorch/third-party/include/re2/stringpiece.h
deleted file mode 100644
index 3b2a450684..0000000000
--- a/packages/react-native-executorch/third-party/include/re2/stringpiece.h
+++ /dev/null
@@ -1,18 +0,0 @@
-// Copyright 2022 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef RE2_STRINGPIECE_H_
-#define RE2_STRINGPIECE_H_
-
-#include "absl/strings/string_view.h"
-
-namespace re2 {
-
-// Until RE2 requires C++17 and uses std::string_view, allow users to
-// continue to #include "re2/stringpiece.h" and use re2::StringPiece.
-using StringPiece = absl::string_view;
-
-} // namespace re2
-
-#endif // RE2_STRINGPIECE_H_
diff --git a/packages/react-native-executorch/third-party/include/torch/headeronly/macros/Export.h b/packages/react-native-executorch/third-party/include/torch/headeronly/macros/Export.h
deleted file mode 100644
index 8dd25419ef..0000000000
--- a/packages/react-native-executorch/third-party/include/torch/headeronly/macros/Export.h
+++ /dev/null
@@ -1,153 +0,0 @@
-#pragma once
-
-#ifndef C10_MACROS_EXPORT_H_
-#define C10_MACROS_EXPORT_H_
-
-#ifndef C10_USING_CUSTOM_GENERATED_MACROS
-#include <torch/headeronly/macros/cmake_macros.h>
-#endif // C10_USING_CUSTOM_GENERATED_MACROS
-
-/* Header file to define the common scaffolding for exported symbols.
- *
- * Export is by itself a quite tricky situation to deal with, and if you are
- * hitting this file, make sure you start with the background here:
- * - Linux: https://gcc.gnu.org/wiki/Visibility
- * - Windows:
- * https://docs.microsoft.com/en-us/cpp/cpp/dllexport-dllimport?view=vs-2017
- *
- * Do NOT include this file directly. Instead, use c10/macros/Macros.h
- */
-
-// You do not need to edit this part of file unless you are changing the core
-// pytorch export abstractions.
-//
-// This part defines the C10 core export and import macros. This is controlled
-// by whether we are building shared libraries or not, which is determined
-// during build time and codified in c10/core/cmake_macros.h.
-// When the library is built as a shared lib, EXPORT and IMPORT will contain
-// visibility attributes. If it is being built as a static lib, then EXPORT
-// and IMPORT basically have no effect.
-
-// As a rule of thumb, you should almost NEVER mix static and shared builds for
-// libraries that depend on c10. AKA, if c10 is built as a static library, we
-// recommend everything dependent on c10 to be built statically. If c10 is built
-// as a shared library, everything dependent on it should be built as shared. In
-// the PyTorch project, all native libraries shall use the macro
-// C10_BUILD_SHARED_LIB to check whether pytorch is building shared or static
-// libraries.
-
-// For build systems that do not directly depend on CMake and directly build
-// from the source directory (such as Buck), one may not have a cmake_macros.h
-// file at all. In this case, the build system is responsible for providing
-// correct macro definitions corresponding to the cmake_macros.h.in file.
-//
-// In such scenarios, one should define the macro
-//     C10_USING_CUSTOM_GENERATED_MACROS
-// to inform this header that it does not need to include the cmake_macros.h
-// file.
-
-#ifdef _WIN32
-#define C10_HIDDEN
-#if defined(C10_BUILD_SHARED_LIBS)
-#define C10_EXPORT __declspec(dllexport)
-#define C10_IMPORT __declspec(dllimport)
-#else
-#define C10_EXPORT
-#define C10_IMPORT
-#endif
-#else // _WIN32
-#if defined(__GNUC__)
-#define C10_EXPORT __attribute__((__visibility__("default")))
-#define C10_HIDDEN __attribute__((__visibility__("hidden")))
-#else // defined(__GNUC__)
-#define C10_EXPORT
-#define C10_HIDDEN
-#endif // defined(__GNUC__)
-#define C10_IMPORT C10_EXPORT
-#endif // _WIN32
-
-#ifdef NO_EXPORT
-#undef C10_EXPORT
-#define C10_EXPORT
-#endif
-
-// Definition of an adaptive XX_API macro, that depends on whether you are
-// building the library itself or not, routes to XX_EXPORT and XX_IMPORT.
-// Basically, you will need to do this for each shared library that you are
-// building, and the instruction is as follows: assuming that you are building
-// a library called libawesome.so. You should:
-// (1) for your cmake target (usually done by "add_library(awesome, ...)"),
-//     define a macro called AWESOME_BUILD_MAIN_LIB using
-//     target_compile_options.
-// (2) define the AWESOME_API macro similar to the one below.
-// And in the source file of your awesome library, use AWESOME_API to
-// annotate public symbols.
-
-// Here, for the C10 library, we will define the macro C10_API for both import
-// and export.
-
-// This one is being used by libc10.so
-#ifdef C10_BUILD_MAIN_LIB
-#define C10_API C10_EXPORT
-#else
-#define C10_API C10_IMPORT
-#endif
-
-// This one is being used by libtorch.so
-#ifdef CAFFE2_BUILD_MAIN_LIB
-#define TORCH_API C10_EXPORT
-#else
-#define TORCH_API C10_IMPORT
-#endif
-
-// You may be wondering why we have TORCH_CUDA_CPP_API and TORCH_CUDA_CU_API
-// belonging to the same library instead of just one TORCH_CUDA_API. Well, it
-// can indeed just be one TORCH_CUDA_API (and used to be)! TORCH_CUDA_CPP_API
-// and TORCH_CUDA_CU_API are artifacts of when we needed a split build to
-// avoid relocation marker linking errors. The context is as follows:
-//
-// Once upon a time, there _was_ only TORCH_CUDA_API. All was happy until we
-// tried to compile PyTorch for CUDA 11.1, which ran into relocation marker
-// issues when linking big binaries.
-// (https://github.com/pytorch/pytorch/issues/39968) We had two choices:
-//    (1) Stop supporting so many GPU architectures
-//    (2) Do something else
-// We chose #2 and decided to split the behemoth that was torch_cuda into two
-// smaller libraries, one with most of the core kernel functions (torch_cuda_cu)
-// and the other that had..well..everything else (torch_cuda_cpp). The idea was
-// this: instead of linking our static libraries (like the hefty
-// libcudnn_static.a) with another huge library, torch_cuda, and run into pesky
-// relocation marker issues, we could link our static libraries to a smaller
-// part of torch_cuda (torch_cuda_cpp) and avoid the issues.
-
-// libtorch_cuda.so (where torch_cuda_cu and torch_cuda_cpp are a part of the
-// same api)
-#ifdef TORCH_CUDA_BUILD_MAIN_LIB
-#define TORCH_CUDA_CPP_API C10_EXPORT
-#define TORCH_CUDA_CU_API C10_EXPORT
-#else
-#define TORCH_CUDA_CPP_API C10_IMPORT
-#define TORCH_CUDA_CU_API C10_IMPORT
-#endif
-
-#if defined(TORCH_HIP_BUILD_MAIN_LIB)
-#define TORCH_HIP_CPP_API C10_EXPORT
-#define TORCH_HIP_API C10_EXPORT
-#else
-#define TORCH_HIP_CPP_API C10_IMPORT
-#define TORCH_HIP_API C10_IMPORT
-#endif
-
-#if defined(TORCH_XPU_BUILD_MAIN_LIB)
-#define TORCH_XPU_API C10_EXPORT
-#else
-#define TORCH_XPU_API C10_IMPORT
-#endif
-
-// Enums only need to be exported on windows for non-CUDA files
-#if defined(_WIN32) && defined(__CUDACC__)
-#define C10_API_ENUM C10_API
-#else
-#define C10_API_ENUM
-#endif
-#endif // C10_MACROS_EXPORT_H_
diff --git a/packages/react-native-executorch/third-party/include/torch/headeronly/macros/Macros.h b/packages/react-native-executorch/third-party/include/torch/headeronly/macros/Macros.h
deleted file mode 100644
index 0151b51a96..0000000000
--- a/packages/react-native-executorch/third-party/include/torch/headeronly/macros/Macros.h
+++ /dev/null
@@ -1,659 +0,0 @@
-#define C10_USING_CUSTOM_GENERATED_MACROS
-#ifndef C10_MACROS_MACROS_H_
-#define C10_MACROS_MACROS_H_
-
-#ifdef __cplusplus
-#include <cassert>
-#else
-#include <assert.h>
-#endif
-
-/* Main entry for torch/headeronly/macros (used to be c10/macros).
- *
- * In your code, include torch/headeronly/macros/Macros.h directly, instead of
- * individual files in this folder.
- */
-
-// For build systems that do not directly depend on CMake and directly build
-// from the source directory (such as Buck), one may not have a cmake_macros.h
-// file at all. In this case, the build system is responsible for providing
-// correct macro definitions corresponding to the cmake_macros.h.in file.
-//
-// In such scenarios, one should define the macro
-//     C10_USING_CUSTOM_GENERATED_MACROS
-// to inform this header that it does not need to include the cmake_macros.h
-// file.
-
-#ifndef C10_USING_CUSTOM_GENERATED_MACROS
-#include <torch/headeronly/macros/cmake_macros.h>
-#endif // C10_USING_CUSTOM_GENERATED_MACROS
-
-#include <torch/headeronly/macros/Export.h>
-
-#if defined(__clang__)
-#define __ubsan_ignore_float_divide_by_zero__                                  \
-  __attribute__((no_sanitize("float-divide-by-zero")))
-#define __ubsan_ignore_undefined__ __attribute__((no_sanitize("undefined")))
-#define __ubsan_ignore_signed_int_overflow__                                   \
-  __attribute__((no_sanitize("signed-integer-overflow")))
-#define __ubsan_ignore_pointer_overflow__                                      \
-  __attribute__((no_sanitize("pointer-overflow")))
-#define __ubsan_ignore_function__ __attribute__((no_sanitize("function")))
-#define __ubsan_ignore_float_cast_overflow__                                   \
-  __attribute__((no_sanitize("float-cast-overflow")))
-#else
-#define __ubsan_ignore_float_divide_by_zero__
-#define __ubsan_ignore_undefined__
-#define __ubsan_ignore_signed_int_overflow__
-#define __ubsan_ignore_pointer_overflow__
-#define __ubsan_ignore_function__
-#define __ubsan_ignore_float_cast_overflow__
-#endif
-
-// Detect address sanitizer as some stuff doesn't work with it
-#undef C10_ASAN_ENABLED
-
-// for clang
-#if defined(__has_feature)
-#if ((__has_feature(address_sanitizer)))
-#define C10_ASAN_ENABLED 1
-#endif
-#endif
-
-// for gcc
-#if defined(__SANITIZE_ADDRESS__)
-#if __SANITIZE_ADDRESS__
-#if !defined(C10_ASAN_ENABLED)
-#define C10_ASAN_ENABLED 1
-#endif
-#endif
-#endif
-
-#if !defined(C10_ASAN_ENABLED)
-#define C10_ASAN_ENABLED 0
-#endif
-
-// Detect undefined-behavior sanitizer (UBSAN)
-#undef C10_UBSAN_ENABLED
-
-// for clang or gcc >= 14
-// NB: gcc 14 adds support for Clang's __has_feature
-//   https://gcc.gnu.org/gcc-14/changes.html
-//   gcc < 14 doesn't have a macro for UBSAN
-//   (e.g. __SANITIZE_UNDEFINED__ does not exist in gcc)
-//   https://github.com/google/sanitizers/issues/765
-#if defined(__has_feature)
-#if ((__has_feature(undefined_behavior_sanitizer)))
-#define C10_UBSAN_ENABLED 1
-#endif
-#endif
-
-#if !defined(C10_UBSAN_ENABLED)
-#define C10_UBSAN_ENABLED 0
-#endif
-
-// Disable the copy and assignment operator for a class. Note that this will
-// disable the usage of the class in std containers.
-#define C10_DISABLE_COPY_AND_ASSIGN(classname)                                 \
-  classname(const classname &) = delete;                                       \
-  classname &operator=(const classname &) = delete
-
-#define C10_CONCATENATE_IMPL(s1, s2) s1##s2
-#define C10_CONCATENATE(s1, s2) C10_CONCATENATE_IMPL(s1, s2)
-
-#define C10_MACRO_EXPAND(args) args
-
-#define C10_STRINGIZE_IMPL(x) #x
-#define C10_STRINGIZE(x) C10_STRINGIZE_IMPL(x)
-
-/**
- * C10_ANONYMOUS_VARIABLE(str) introduces a new identifier which starts with
- * str and ends with a unique number.
- */
-#ifdef __COUNTER__
-#define C10_UID __COUNTER__
-#define C10_ANONYMOUS_VARIABLE(str) C10_CONCATENATE(str, __COUNTER__)
-#else
-#define C10_UID __LINE__
-#define C10_ANONYMOUS_VARIABLE(str) C10_CONCATENATE(str, __LINE__)
-#endif
-
-#ifdef __has_cpp_attribute
-#define C10_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
-#else
-#define C10_HAS_CPP_ATTRIBUTE(x) (0)
-#endif
-
-#ifndef FBCODE_CAFFE2
-/// DEPRECATED: Warn if a type or return value is discarded.
-#define C10_NODISCARD [[nodiscard]]
-
-/// DEPRECATED: Suppress an unused variable.
-#define C10_UNUSED [[maybe_unused]]
-#endif
-
-#if !defined(__has_attribute)
-#define __has_attribute(x) 0
-#endif
-
-// Direct port of LLVM_ATTRIBUTE_USED.
-#if __has_attribute(used)
-#define C10_USED __attribute__((__used__))
-#else
-#define C10_USED
-#endif
-
-#define C10_RESTRICT __restrict
-
-#ifdef __cplusplus
-
-// Simply define the namespace, in case a dependent library want to refer to
-// the c10 namespace but not any nontrivial files.
-namespace c10 {}
-namespace c10::cuda {}
-namespace c10::hip {}
-namespace c10::xpu {}
-
-// Since C10 is the core library for caffe2 (and aten), we will simply reroute
-// all abstractions defined in c10 to be available in caffe2 as well.
-// This is only for backwards compatibility. Please use the symbols from the
-// c10 namespace where possible.
-namespace caffe2 {
-using namespace c10;
-}
-namespace at {
-using namespace c10;
-}
-namespace at::cuda {
-using namespace c10::cuda;
-} // namespace at::cuda
-
-// WARNING!!! THIS IS A GIANT HACK!!!
-// This line means you cannot simultaneously include c10/hip
-// and c10/cuda and then use them from the at::cuda namespace.
-// This is true in practice, because HIPIFY works inplace on
-// files in ATen/cuda, so it assumes that c10::hip is available
-// from at::cuda.  This namespace makes that happen.  When
-// HIPIFY is no longer out-of-place, we can switch the cuda
-// here to hip and everyone is happy.
-namespace at::cuda {
-using namespace c10::hip;
-} // namespace at::cuda
-
-namespace at::xpu {
-using namespace c10::xpu;
-} // namespace at::xpu
-
-#endif // __cplusplus
-
-// C10_LIKELY/C10_UNLIKELY
-//
-// These macros provide parentheses, so you can use these macros as:
-//
-//    if C10_LIKELY(some_expr) {
-//      ...
-//    }
-//
-// NB: static_cast to boolean is mandatory in C++, because __builtin_expect
-// takes a long argument, which means you may trigger the wrong conversion
-// without it.
-//
-#if defined(__GNUC__) || defined(__ICL) || defined(__clang__)
-#define C10_LIKELY(expr) (__builtin_expect(static_cast<bool>(expr), 1))
-#define C10_UNLIKELY(expr) (__builtin_expect(static_cast<bool>(expr), 0))
-#else
-#define C10_LIKELY(expr) (expr)
-#define C10_UNLIKELY(expr) (expr)
-#endif
-
-/// C10_NOINLINE - Functions whose declaration is annotated with this will not
-/// be inlined.
-#ifdef __GNUC__
-#define C10_NOINLINE __attribute__((noinline))
-#elif _MSC_VER
-#define C10_NOINLINE __declspec(noinline)
-#else
-#define C10_NOINLINE
-#endif
-
-#if defined(_MSC_VER)
-#define C10_ALWAYS_INLINE __forceinline
-#elif __has_attribute(always_inline) || defined(__GNUC__)
-#define C10_ALWAYS_INLINE __attribute__((__always_inline__)) inline
-#else
-#define C10_ALWAYS_INLINE inline
-#endif
-
-// Unlike C10_ALWAYS_INLINE, C10_ALWAYS_INLINE_ATTRIBUTE can be used
-// on a lambda.
-#if defined(_MSC_VER)
-// MSVC 14.39 is reasonably recent and doesn't like
-// [[msvc::forceinline]] on a lambda, so don't try to use it.
-#define C10_ALWAYS_INLINE_ATTRIBUTE
-#elif __has_attribute(always_inline) || defined(__GNUC__)
-#define C10_ALWAYS_INLINE_ATTRIBUTE __attribute__((__always_inline__))
-#else
-#define C10_ALWAYS_INLINE_ATTRIBUTE
-#endif
-
-#if defined(_MSC_VER)
-#define C10_ATTR_VISIBILITY_HIDDEN
-#elif defined(__GNUC__)
-#define C10_ATTR_VISIBILITY_HIDDEN __attribute__((__visibility__("hidden")))
-#else
-#define C10_ATTR_VISIBILITY_HIDDEN
-#endif
-
-#define C10_ERASE C10_ALWAYS_INLINE C10_ATTR_VISIBILITY_HIDDEN
-
-#ifdef __cplusplus
-#include <cstdint>
-#else
-#include <stdint.h>
-#endif
-
-#ifdef __HIPCC__
-// Unlike CUDA, HIP requires a HIP header to be included for __host__ to work.
-// We do this #include here so that C10_HOST_DEVICE and friends will Just Work.
-// See https://github.com/ROCm/hip/issues/441
-#include <hip/hip_runtime.h>
-#endif
-
-#if defined(__CUDACC__) || defined(__HIPCC__)
-// Designates functions callable from the host (CPU) and the device (GPU)
-#define C10_HOST_DEVICE __host__ __device__
-#define C10_DEVICE __device__
-#define C10_HOST __host__
-// constants from
-// (https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#features-and-technical-specifications)
-// The maximum number of threads per multiprocessor is 1024 for Turing
-// architecture (7.5), 1536 for Geforce Ampere (8.6)/Jetson Orin (8.7), and
-// 2048 for all other architectures. You'll get warnings if you exceed these
-// constants. Hence, the following macros adjust the input values from the user
-// to resolve potential warnings.
-#if __CUDA_ARCH__ == 750
-constexpr uint32_t CUDA_MAX_THREADS_PER_SM = 1024;
-#elif __CUDA_ARCH__ == 860 || __CUDA_ARCH__ == 870 || __CUDA_ARCH__ == 890 ||  \
-    __CUDA_ARCH__ == 1200
-constexpr uint32_t CUDA_MAX_THREADS_PER_SM = 1536;
-#else
-constexpr uint32_t CUDA_MAX_THREADS_PER_SM = 2048;
-#endif
-// CUDA_MAX_THREADS_PER_BLOCK is same for all architectures currently
-constexpr uint32_t CUDA_MAX_THREADS_PER_BLOCK = 1024;
-// CUDA_THREADS_PER_BLOCK_FALLBACK is the "canonical fallback" choice of block
-// size. 256 is a good number for this fallback and should give good occupancy
-// and versatility across all architectures.
-constexpr uint32_t CUDA_THREADS_PER_BLOCK_FALLBACK = 256;
-// NOTE: if you are thinking of constexpr-ify the inputs to launch bounds, it
-//       turns out that although __launch_bounds__ can take constexpr, it
-//       can't take a constexpr that has anything to do with templates.
-//       Currently we use launch_bounds that depend on template arguments in
-//       Loops.cuh, Reduce.cuh and LossCTC.cuh. Hence, C10_MAX_THREADS_PER_BLOCK
-//       and C10_MIN_BLOCKS_PER_SM are kept as macros.
-// Suppose you were planning to write __launch_bounds__(a, b), based on your
-// performance tuning on a modern GPU. Instead, you should write
-// __launch_bounds__(C10_MAX_THREADS_PER_BLOCK(a), C10_MIN_BLOCKS_PER_SM(a, b)),
-// which will also properly respect limits on old architectures.
-#define C10_MAX_THREADS_PER_BLOCK(val)                                         \
-  (((val) <= CUDA_MAX_THREADS_PER_BLOCK) ? (val)                               \
-                                         : CUDA_THREADS_PER_BLOCK_FALLBACK)
-#define C10_MIN_BLOCKS_PER_SM(threads_per_block, blocks_per_sm)                \
-  ((((threads_per_block) * (blocks_per_sm) <= CUDA_MAX_THREADS_PER_SM)         \
-        ? (blocks_per_sm)                                                      \
-        : ((CUDA_MAX_THREADS_PER_SM + (threads_per_block) - 1) /               \
-           (threads_per_block))))
-// C10_LAUNCH_BOUNDS is analogous to __launch_bounds__
-#define C10_LAUNCH_BOUNDS_0                                                    \
-  __launch_bounds__(256,                                                       \
-                    4) // default launch bounds that should give good occupancy
-                       // and versatility across all architectures.
-#define C10_LAUNCH_BOUNDS_1(max_threads_per_block)                             \
-  __launch_bounds__((C10_MAX_THREADS_PER_BLOCK((max_threads_per_block))))
-#define C10_LAUNCH_BOUNDS_2(max_threads_per_block, min_blocks_per_sm)          \
-  __launch_bounds__(                                                           \
-      (C10_MAX_THREADS_PER_BLOCK((max_threads_per_block))),                    \
-      (C10_MIN_BLOCKS_PER_SM((max_threads_per_block), (min_blocks_per_sm))))
-#else
-#define C10_HOST_DEVICE
-#define C10_HOST
-#define C10_DEVICE
-#endif
-
-#if defined(USE_ROCM)
-#define C10_HIP_HOST_DEVICE __host__ __device__
-#else
-#define C10_HIP_HOST_DEVICE
-#endif
-
-#if defined(USE_ROCM)
-// C10_WARP_SIZE is only allowed for device code.
-// Host code _must_ use at::cuda::warp_size()
-// HIP header used to define warpSize as a constexpr that was either 32 or 64
-// depending on the target device, and then always set it to 64 for host code.
-// Host pass of HIP compiler needs C10_WARP_SIZE defined to _something_ so we
-// set it to something unreasonable to trigger obvious host code errors.
-
-namespace at::cuda {
-TORCH_CUDA_CPP_API int warp_size();
-}
-#ifdef __HIPCC__
-static inline int __host__ C10_WARP_SIZE_INTERNAL() {
-  return at::cuda::warp_size();
-}
-
-static inline constexpr int __device__ C10_WARP_SIZE_INTERNAL() {
-#if defined(__GFX9__)
-  return 64;
-#else  // __GFX9__
-  return 32;
-#endif // __GFX9__
-}
-#else  // __HIPCC__
-static inline int C10_WARP_SIZE_INTERNAL() { return at::cuda::warp_size(); }
-#endif // __HIPCC__
-
-#define C10_WARP_SIZE (C10_WARP_SIZE_INTERNAL())
-#define C10_WARP_SIZE_STATIC 64
-
-#else // defined(USE_ROCM)
-#define C10_WARP_SIZE 32
-#endif
-
-#if defined(_MSC_VER) && _MSC_VER <= 1900
-#define __func__ __FUNCTION__
-#endif
-
-// CUDA_KERNEL_ASSERT checks the assertion
-// even when NDEBUG is defined. This is useful for important assertions in CUDA
-// code that would otherwise be suppressed when building Release.
-#if defined(__ANDROID__) || defined(__APPLE__) || defined(__FreeBSD__)
-// Those platforms do not support assert()
-#define CUDA_KERNEL_ASSERT(cond)
-#define CUDA_KERNEL_ASSERT_MSG(cond, msg)
-#define CUDA_KERNEL_ASSERT_PRINTF(cond, msg, ...)
-#define SYCL_KERNEL_ASSERT(cond)
-#elif defined(_MSC_VER)
-#if defined(NDEBUG)
-extern "C" {
-C10_IMPORT
-#if defined(__SYCL_DEVICE_ONLY__)
-extern SYCL_EXTERNAL void _wassert(const wchar_t *wexpr, const wchar_t *wfile,
-                                   unsigned line);
-#else
-#if defined(__CUDA_ARCH__)
-__host__ __device__
-#endif // __CUDA_ARCH__
-    void _wassert(wchar_t const *_Message, wchar_t const *_File,
-                  unsigned _Line);
-#endif // __SYCL_DEVICE_ONLY__
-}
-#endif // NDEBUG
-#define CUDA_KERNEL_ASSERT(cond)                                               \
-  if (C10_UNLIKELY(!(cond))) {                                                 \
-    (void)(_wassert(_CRT_WIDE(#cond), _CRT_WIDE(__FILE__),                     \
-                    static_cast<unsigned>(__LINE__)),                          \
-           0);                                                                 \
-  }
-// TODO: This doesn't assert the message because I (chilli) couldn't figure out
-// a nice way to convert a char* to a wchar_t*
-#define CUDA_KERNEL_ASSERT_MSG(cond, msg)                                      \
-  if (C10_UNLIKELY(!(cond))) {                                                 \
-    (void)(_wassert(_CRT_WIDE(#cond), _CRT_WIDE(__FILE__),                     \
-                    static_cast<unsigned>(__LINE__)),                          \
-           0);                                                                 \
-  }
-#define CUDA_KERNEL_ASSERT_PRINTF(cond, msg, ...)                              \
-  if (C10_UNLIKELY(!(cond))) {                                                 \
-    (void)(printf(                                                             \
-        "[CUDA_KERNEL_ASSERT] " __FILE__ ":" C10_STRINGIZE(                    \
-            __LINE__) ": %s: block: [%d,%d,%d], thread: [%d,%d,%d]: "          \
-                      "Assertion failed: `" #cond "`: " msg "\n",              \
-        __func__, blockIdx.x, blockIdx.y, blockIdx.z, threadIdx.x,             \
-        threadIdx.y, threadIdx.z, ##__VA_ARGS__));                             \
-    (void)(_wassert(_CRT_WIDE(#cond), _CRT_WIDE(__FILE__),                     \
-                    static_cast<unsigned>(__LINE__)),                          \
-           0);                                                                 \
-  }
-#define SYCL_KERNEL_ASSERT(cond)                                               \
-  if (C10_UNLIKELY(!(cond))) {                                                 \
-    (void)(_wassert(_CRT_WIDE(#cond), _CRT_WIDE(__FILE__),                     \
-                    static_cast<unsigned>(__LINE__)),                          \
-           0);                                                                 \
-  }
-#else // __APPLE__, _MSC_VER
-#if defined(NDEBUG)
-extern "C" {
-#if defined(__SYCL_DEVICE_ONLY__)
-extern SYCL_EXTERNAL void __assert_fail(const char *expr, const char *file,
-                                        unsigned int line, const char *func);
-#elif (defined(__EMSCRIPTEN__))
-// As defined in assert.h in the Emscripten stdlib
-_Noreturn void __assert_fail(const char *expr, const char *file, int line,
-                             const char *func);
-#else // __SYCL_DEVICE_ONLY__
-#if (defined(__CUDA_ARCH__) && !(defined(__clang__) && defined(__CUDA__)))
-// CUDA supports __assert_fail function which are common for both device
-// and host side code.
-__host__ __device__
-#endif
-
-    // This forward declaration matching the declaration of __assert_fail
-    // exactly how it is in glibc in case parts of the program are compiled with
-    // different NDEBUG settings. Otherwise we might get 'ambiguous declaration'
-    // error. Note: On ROCm - this declaration serves for host side compilation.
-    void __assert_fail(const char *assertion, const char *file,
-                       unsigned int line, const char *function) noexcept
-    __attribute__((__noreturn__));
-
-#endif // __SYCL_DEVICE_ONLY__
-}
-#endif // NDEBUG
-// ROCm disables kernel assert by default for performance considerations.
-// Though ROCm supports __assert_fail, it uses kernel printf which has
-// a non-negligible performance impact even if the assert condition is
-// never triggered. We choose to use abort() instead which will still
-// terminate the application but without a more useful error message.
-#if !defined(C10_USE_ROCM_KERNEL_ASSERT) && defined(USE_ROCM)
-#define CUDA_KERNEL_ASSERT(cond)                                               \
-  if C10_UNLIKELY (!(cond)) {                                                  \
-    abort();                                                                   \
-  }
-#define CUDA_KERNEL_ASSERT_MSG(cond, msg)                                      \
-  if C10_UNLIKELY (!(cond)) {                                                  \
-    abort();                                                                   \
-  }
-#define CUDA_KERNEL_ASSERT_PRINTF(cond, msg, ...)                              \
-  if C10_UNLIKELY (!(cond)) {                                                  \
-    abort();                                                                   \
-  }
-#define SYCL_KERNEL_ASSERT(cond)                                               \
-  if C10_UNLIKELY (!(cond)) {                                                  \
-    abort();                                                                   \
-  }
-#else
-#define CUDA_KERNEL_ASSERT(cond)                                               \
-  if (C10_UNLIKELY(!(cond))) {                                                 \
-    __assert_fail(#cond, __FILE__, static_cast<unsigned int>(__LINE__),        \
-                  __func__);                                                   \
-  }
-#define CUDA_KERNEL_ASSERT_MSG(cond, msg)                                      \
-  if (C10_UNLIKELY(!(cond))) {                                                 \
-    __assert_fail(msg, __FILE__, static_cast<unsigned int>(__LINE__),          \
-                  __func__);                                                   \
-  }
-#define CUDA_KERNEL_ASSERT_PRINTF(cond, msg, ...)                              \
-  if (C10_UNLIKELY(!(cond))) {                                                 \
-    printf("[CUDA_KERNEL_ASSERT] " __FILE__ ":" C10_STRINGIZE(                 \
-               __LINE__) ": %s: block: [%d,%d,%d], thread: [%d,%d,%d]: "       \
-                         "Assertion failed: `" #cond "`: " msg "\n",           \
-           __func__, blockIdx.x, blockIdx.y, blockIdx.z, threadIdx.x,          \
-           threadIdx.y, threadIdx.z, ##__VA_ARGS__);                           \
-    __assert_fail(#cond, __FILE__, static_cast<unsigned int>(__LINE__),        \
-                  __func__);                                                   \
-  }
-#define SYCL_KERNEL_ASSERT(cond)                                               \
-  if (C10_UNLIKELY(!(cond))) {                                                 \
-    __assert_fail(#cond, __FILE__, static_cast<unsigned int>(__LINE__),        \
-                  __func__);                                                   \
-  }
-#endif //  C10_USE_ROCM_KERNEL_ASSERT && USE_ROCM
-#endif // __APPLE__
-
-// Compile-time switch to control how assertions are logged inside CUDA kernels.
-// If C10_CUDA_VERBOSE_ASSERT is defined,  CUDA_KERNEL_ASSERT_VERBOSE will
-// take addition information passed to the macro and forward them to
-// CUDA_KERNEL_ASSERT_PRINTF If C10_CUDA_VERBOSE_ASSERT is not defined,
-// CUDA_KERNEL_ASSERT_VERBOSE will behave the same as CUDA_KERNEL_ASSERT.
-#ifdef C10_ENABLE_VERBOSE_ASSERT
-#define CUDA_KERNEL_ASSERT_VERBOSE(cond, ...)                                  \
-  CUDA_KERNEL_ASSERT_PRINTF(cond, __VA_ARGS__)
-#else
-#define CUDA_KERNEL_ASSERT_VERBOSE(cond, ...) CUDA_KERNEL_ASSERT(cond)
-#endif
-
-#ifdef __APPLE__
-#include <TargetConditionals.h>
-#endif
-
-#if defined(__ANDROID__)
-#define C10_ANDROID 1
-#define C10_MOBILE 1
-#elif (defined(__APPLE__) &&                                                   \
-       (TARGET_IPHONE_SIMULATOR || TARGET_OS_SIMULATOR || TARGET_OS_IPHONE))
-#define C10_IOS 1
-#define C10_MOBILE 1
-#endif // ANDROID / IOS
-
-#if defined(C10_MOBILE) && C10_MOBILE
-#define C10_ALWAYS_INLINE_UNLESS_MOBILE inline
-#else
-#define C10_ALWAYS_INLINE_UNLESS_MOBILE C10_ALWAYS_INLINE
-#endif
-
-#if !defined(FBCODE_CAFFE2) && !defined(C10_NODEPRECATED)
-#define CONSTEXPR_EXCEPT_WIN_CUDA constexpr
-#define C10_HOST_CONSTEXPR_EXCEPT_WIN_CUDA constexpr
-
-#define STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(field, val)                   \
-  static constexpr const char field[] = val;
-#define STATIC_CONST_STR_OUT_OF_LINE_FOR_WIN_CUDA(cls, field, val)
-#endif // !defined(FBCODE_CAFFE2) && !defined(C10_NODEPRECATED)
-
-#ifndef HAS_DEMANGLE
-#if defined(__ANDROID__) || defined(_WIN32) || defined(__EMSCRIPTEN__)
-#define HAS_DEMANGLE 0
-#elif defined(__APPLE__) &&                                                    \
-    (TARGET_IPHONE_SIMULATOR || TARGET_OS_SIMULATOR || TARGET_OS_IPHONE)
-#define HAS_DEMANGLE 0
-#else
-#define HAS_DEMANGLE 1
-#endif
-#endif // HAS_DEMANGLE
-
-#define _C10_PRAGMA__(string) _Pragma(#string)
-#define _C10_PRAGMA_(string) _C10_PRAGMA__(string)
-
-#ifdef __clang__
-#define C10_CLANG_DIAGNOSTIC_PUSH() _Pragma("clang diagnostic push")
-#define C10_CLANG_DIAGNOSTIC_POP() _Pragma("clang diagnostic pop")
-#define C10_CLANG_DIAGNOSTIC_IGNORE(flag)                                      \
-  _C10_PRAGMA_(clang diagnostic ignored flag)
-#define C10_CLANG_HAS_WARNING(flag) __has_warning(flag)
-#else
-#define C10_CLANG_DIAGNOSTIC_PUSH()
-#define C10_CLANG_DIAGNOSTIC_POP()
-#define C10_CLANG_DIAGNOSTIC_IGNORE(flag)
-#define C10_CLANG_HAS_WARNING(flag) 0
-#endif
-
-#ifdef __clang__
-
-#define C10_DIAGNOSTIC_PUSH_AND_IGNORED_IF_DEFINED(warning)                    \
-  _C10_PRAGMA_(clang diagnostic push)                                          \
-  _C10_PRAGMA_(clang diagnostic ignored "-Wunknown-warning-option")            \
-  _C10_PRAGMA_(clang diagnostic ignored warning)
-
-#define C10_DIAGNOSTIC_POP() _C10_PRAGMA_(clang diagnostic pop)
-
-#elif __GNUC__
-
-#define C10_DIAGNOSTIC_PUSH_AND_IGNORED_IF_DEFINED(warning)                    \
-  _C10_PRAGMA_(GCC diagnostic push)                                            \
-  _C10_PRAGMA_(GCC diagnostic ignored "-Wpragmas")                             \
-  _C10_PRAGMA_(GCC diagnostic ignored warning)
-
-#define C10_DIAGNOSTIC_POP() _C10_PRAGMA_(GCC diagnostic pop)
-
-#else
-
-#define C10_DIAGNOSTIC_PUSH_AND_IGNORED_IF_DEFINED(warning)
-#define C10_DIAGNOSTIC_POP()
-
-#endif
-
-// This macro is used to find older C++ compilers
-// that don't support move optimization for return values.
-
-#if (defined(__GNUC__) && __GNUC__ < 13) ||                                    \
-    (defined(__clang_major__) && __clang_major__ < 13)
-#define C10_RETURN_MOVE_IF_OLD_COMPILER 1
-#else
-#define C10_RETURN_MOVE_IF_OLD_COMPILER 0
-#endif
-
-// The HIDDEN_NAMESPACE_BEGIN and HIDDEN_NAMESPACE_END below
-// are needed for maintaining robustness in our header APIs in
-// torch/headeronly and torch/csrc/stable under the namespaces
-// torch::headeronly and torch::stable respectively. We enforce
-// hidden visibility for these APIs because we want to enable
-// loading custom extensions compiled against different libtorch
-// versions where these APIs may have changed.
-
-// Helper macros to handle 1-3 hidden namespace levels when not windows
-#define _HIDDEN_NS_GET_MACRO(_1, _2, _3, NAME, ...) NAME
-#define _HIDDEN_NS_1(n1) namespace n1 __attribute__((visibility("hidden"))) {
-#define _HIDDEN_NS_2(n1, n2)                                                   \
-  namespace n1 {                                                               \
-  namespace n2 __attribute__((visibility("hidden"))) {
-#define _HIDDEN_NS_3(n1, n2, n3)                                               \
-  namespace n1::n2 {                                                           \
-  namespace n3 __attribute__((visibility("hidden"))) {
-
-// Helper macros to close namespaces when not windows
-#define _HIDDEN_NS_END_1(n1) }
-#define _HIDDEN_NS_END_N(n1, ...)                                              \
-  }                                                                            \
-  }
-
-// Helper macros to join strs with :: (for win, where symbols are hidden by
-// default)
-#define _EXPAND(...) __VA_ARGS__
-#define _JOIN_GET_MACRO(_1, _2, _3, NAME, ...) NAME
-#define _JOIN_NS1(a) a
-#define _JOIN_NS2(a, b) a::b
-#define _JOIN_NS3(a, b, c) a::b::c
-
-#if !defined(HIDDEN_NAMESPACE_BEGIN)
-#if defined(__GNUG__) && !defined(_WIN32)
-#define HIDDEN_NAMESPACE_BEGIN(...)                                            \
-  _HIDDEN_NS_GET_MACRO(__VA_ARGS__, _HIDDEN_NS_3, _HIDDEN_NS_2,                \
-                       _HIDDEN_NS_1)(__VA_ARGS__)
-#else
-#define HIDDEN_NAMESPACE_BEGIN(...)                                            \
-  namespace _EXPAND(_JOIN_GET_MACRO(__VA_ARGS__, _JOIN_NS3, _JOIN_NS2,         \
-                                    _JOIN_NS1)(__VA_ARGS__)) {
-#endif
-#endif
-
-#if !defined(HIDDEN_NAMESPACE_END)
-#if defined(__GNUG__) && !defined(_WIN32)
-#define HIDDEN_NAMESPACE_END(...)                                              \
-  _HIDDEN_NS_GET_MACRO(__VA_ARGS__, _HIDDEN_NS_END_N, _HIDDEN_NS_END_N,        \
-                       _HIDDEN_NS_END_1)(__VA_ARGS__)
-#else
-#define HIDDEN_NAMESPACE_END(...) }
-#endif
-#endif
-
-#endif // C10_MACROS_MACROS_H_
diff --git a/packages/react-native-executorch/third-party/include/torch/headeronly/util/BFloat16.h b/packages/react-native-executorch/third-party/include/torch/headeronly/util/BFloat16.h
deleted file mode 100644
index 87c49e27b0..0000000000
--- a/packages/react-native-executorch/third-party/include/torch/headeronly/util/BFloat16.h
+++ /dev/null
@@ -1,478 +0,0 @@
-#pragma once
-
-// Defines the bloat16 type (brain floating-point). This representation uses
-// 1 bit for the sign, 8 bits for the exponent and 7 bits for the mantissa.
-
-#include <torch/headeronly/macros/Macros.h>
-#include <torch/headeronly/util/bit_cast.h>
-
-#include <cmath>
-#include <cstdint>
-#include <cstring>
-#include <iosfwd>
-#include <ostream>
-
-#if defined(__CUDACC__) && !defined(USE_ROCM)
-#include <cuda_bf16.h>
-#endif
-
-#if defined(CL_SYCL_LANGUAGE_VERSION)
-#include <CL/sycl.hpp> // for SYCL 1.2.1
-#elif defined(SYCL_LANGUAGE_VERSION)
-#include <sycl/sycl.hpp> // for SYCL 2020
-#endif
-
-namespace c10 {
-
-struct alignas(2) BFloat16 {
-  uint16_t x;
-
-  // HIP wants __host__ __device__ tag, CUDA does not
-#if defined(USE_ROCM) && defined(__HIPCC__)
-  C10_HOST_DEVICE BFloat16() = default;
-#else
-  BFloat16() = default;
-#endif
-
-  struct from_bits_t {};
-  static constexpr C10_HOST_DEVICE from_bits_t from_bits() {
-    return from_bits_t();
-  }
-
-  constexpr C10_HOST_DEVICE BFloat16(unsigned short bits,
-                                     from_bits_t /*unused*/)
-      : x(bits) {}
-  /* implicit */ inline C10_HOST_DEVICE BFloat16(float value);
-  inline C10_HOST_DEVICE operator float() const;
-
-#if defined(__CUDACC__) && !defined(USE_ROCM)
-  inline C10_HOST_DEVICE BFloat16(const __nv_bfloat16 &value);
-  explicit inline C10_HOST_DEVICE operator __nv_bfloat16() const;
-#endif
-
-#if defined(SYCL_EXT_ONEAPI_BFLOAT16_MATH_FUNCTIONS)
-  inline C10_HOST_DEVICE BFloat16(const sycl::ext::oneapi::bfloat16 &value);
-  explicit inline C10_HOST_DEVICE operator sycl::ext::oneapi::bfloat16() const;
-#endif
-};
-
-inline std::ostream &operator<<(std::ostream &out, const BFloat16 &value) {
-  out << (float)value;
-  return out;
-}
-
-namespace detail {
-inline C10_HOST_DEVICE float f32_from_bits(uint16_t src) {
-  float res = 0;
-  uint32_t tmp = src;
-  tmp <<= 16;
-
-#if defined(USE_ROCM) && defined(__HIPCC__)
-  float *tempRes;
-
-  // We should be using memcpy in order to respect the strict aliasing rule
-  // but it fails in the HIP environment.
-  tempRes = reinterpret_cast<float *>(&tmp);
-  res = *tempRes;
-#else
-  std::memcpy(&res, &tmp, sizeof(tmp));
-#endif
-
-  return res;
-}
-
-inline C10_HOST_DEVICE uint16_t bits_from_f32(float src) {
-  uint32_t res = 0;
-
-#if defined(USE_ROCM) && defined(__HIPCC__)
-  // We should be using memcpy in order to respect the strict aliasing rule
-  // but it fails in the HIP environment.
-  uint32_t *tempRes = reinterpret_cast<uint32_t *>(&src);
-  res = *tempRes;
-#else
-  std::memcpy(&res, &src, sizeof(res));
-#endif
-
-  return res >> 16;
-}
-
-inline C10_HOST_DEVICE uint16_t round_to_nearest_even(float src) {
-#if defined(USE_ROCM) && defined(__HIPCC__)
-  if (src != src) {
-#elif defined(_MSC_VER)
-  if (isnan(src)) {
-#else
-  if (std::isnan(src)) {
-#endif
-    return UINT16_C(0x7FC0);
-  } else {
-    const uint32_t U32 = c10::bit_cast<uint32_t>(src);
-    uint32_t rounding_bias = ((U32 >> 16) & 1) + UINT32_C(0x7FFF);
-    return static_cast<uint16_t>((U32 + rounding_bias) >> 16);
-  }
-}
-
-} // namespace detail
-
-//-------- the following is copied from c10/util/BFloat16-inl.h ---------//
-C10_CLANG_DIAGNOSTIC_PUSH()
-#if C10_CLANG_HAS_WARNING("-Wimplicit-int-float-conversion")
-C10_CLANG_DIAGNOSTIC_IGNORE("-Wimplicit-int-float-conversion")
-#endif
-
-/// Constructors
-inline C10_HOST_DEVICE BFloat16::BFloat16(float value)
-    :
-#if defined(__CUDACC__) && !defined(USE_ROCM) && defined(__CUDA_ARCH__) &&     \
-    __CUDA_ARCH__ >= 800
-      x(__bfloat16_as_ushort(__float2bfloat16(value)))
-#elif defined(__SYCL_DEVICE_ONLY__) &&                                         \
-    defined(SYCL_EXT_ONEAPI_BFLOAT16_MATH_FUNCTIONS)
-      x(c10::bit_cast<uint16_t>(sycl::ext::oneapi::bfloat16(value)))
-#else
-      // RNE by default
-      x(detail::round_to_nearest_even(value))
-#endif
-{
-}
-
-/// Implicit conversions
-inline C10_HOST_DEVICE BFloat16::operator float() const {
-#if defined(__CUDACC__) && !defined(USE_ROCM)
-  return __bfloat162float(*reinterpret_cast<const __nv_bfloat16 *>(&x));
-#elif defined(__SYCL_DEVICE_ONLY__) &&                                         \
-    defined(SYCL_EXT_ONEAPI_BFLOAT16_MATH_FUNCTIONS)
-  return float(*reinterpret_cast<const sycl::ext::oneapi::bfloat16 *>(&x));
-#else
-  return detail::f32_from_bits(x);
-#endif
-}
-
-#if defined(__CUDACC__) && !defined(USE_ROCM)
-inline C10_HOST_DEVICE BFloat16::BFloat16(const __nv_bfloat16 &value) {
-  x = *reinterpret_cast<const unsigned short *>(&value);
-}
-inline C10_HOST_DEVICE BFloat16::operator __nv_bfloat16() const {
-  return *reinterpret_cast<const __nv_bfloat16 *>(&x);
-}
-#endif
-
-#if defined(SYCL_EXT_ONEAPI_BFLOAT16_MATH_FUNCTIONS)
-inline C10_HOST_DEVICE
-BFloat16::BFloat16(const sycl::ext::oneapi::bfloat16 &value) {
-  x = *reinterpret_cast<const unsigned short *>(&value);
-}
-inline C10_HOST_DEVICE BFloat16::operator sycl::ext::oneapi::bfloat16() const {
-  return *reinterpret_cast<const sycl::ext::oneapi::bfloat16 *>(&x);
-}
-#endif
-
-// CUDA intrinsics
-
-#if defined(__CUDACC__) || defined(__HIPCC__)
-inline C10_DEVICE BFloat16 __ldg(const BFloat16 *ptr) {
-#if !defined(USE_ROCM) && defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 800
-  return __ldg(reinterpret_cast<const __nv_bfloat16 *>(ptr));
-#else
-  return *ptr;
-#endif
-}
-#endif
-
-/// Arithmetic
-
-inline C10_HOST_DEVICE BFloat16 operator+(const BFloat16 &a,
-                                          const BFloat16 &b) {
-  return static_cast<float>(a) + static_cast<float>(b);
-}
-
-inline C10_HOST_DEVICE BFloat16 operator-(const BFloat16 &a,
-                                          const BFloat16 &b) {
-  return static_cast<float>(a) - static_cast<float>(b);
-}
-
-inline C10_HOST_DEVICE BFloat16 operator*(const BFloat16 &a,
-                                          const BFloat16 &b) {
-  return static_cast<float>(a) * static_cast<float>(b);
-}
-
-inline C10_HOST_DEVICE BFloat16 operator/(const BFloat16 &a, const BFloat16 &b)
-    __ubsan_ignore_float_divide_by_zero__ {
-  return static_cast<float>(a) / static_cast<float>(b);
-}
-
-inline C10_HOST_DEVICE BFloat16 operator-(const BFloat16 &a) {
-  return -static_cast<float>(a);
-}
-
-inline C10_HOST_DEVICE BFloat16 &operator+=(BFloat16 &a, const BFloat16 &b) {
-  a = a + b;
-  return a;
-}
-
-inline C10_HOST_DEVICE BFloat16 &operator-=(BFloat16 &a, const BFloat16 &b) {
-  a = a - b;
-  return a;
-}
-
-inline C10_HOST_DEVICE BFloat16 &operator*=(BFloat16 &a, const BFloat16 &b) {
-  a = a * b;
-  return a;
-}
-
-inline C10_HOST_DEVICE BFloat16 &operator/=(BFloat16 &a, const BFloat16 &b) {
-  a = a / b;
-  return a;
-}
-
-inline C10_HOST_DEVICE BFloat16 &operator|(BFloat16 &a, const BFloat16 &b) {
-  a.x = a.x | b.x;
-  return a;
-}
-
-inline C10_HOST_DEVICE BFloat16 &operator^(BFloat16 &a, const BFloat16 &b) {
-  a.x = a.x ^ b.x;
-  return a;
-}
-
-inline C10_HOST_DEVICE BFloat16 &operator&(BFloat16 &a, const BFloat16 &b) {
-  a.x = a.x & b.x;
-  return a;
-}
-
-/// Arithmetic with floats
-
-inline C10_HOST_DEVICE float operator+(BFloat16 a, float b) {
-  return static_cast<float>(a) + b;
-}
-inline C10_HOST_DEVICE float operator-(BFloat16 a, float b) {
-  return static_cast<float>(a) - b;
-}
-inline C10_HOST_DEVICE float operator*(BFloat16 a, float b) {
-  return static_cast<float>(a) * b;
-}
-inline C10_HOST_DEVICE float operator/(BFloat16 a, float b) {
-  return static_cast<float>(a) / b;
-}
-
-inline C10_HOST_DEVICE float operator+(float a, BFloat16 b) {
-  return a + static_cast<float>(b);
-}
-inline C10_HOST_DEVICE float operator-(float a, BFloat16 b) {
-  return a - static_cast<float>(b);
-}
-inline C10_HOST_DEVICE float operator*(float a, BFloat16 b) {
-  return a * static_cast<float>(b);
-}
-inline C10_HOST_DEVICE float operator/(float a, BFloat16 b) {
-  return a / static_cast<float>(b);
-}
-
-inline C10_HOST_DEVICE float &operator+=(float &a, const BFloat16 &b) {
-  return a += static_cast<float>(b);
-}
-inline C10_HOST_DEVICE float &operator-=(float &a, const BFloat16 &b) {
-  return a -= static_cast<float>(b);
-}
-inline C10_HOST_DEVICE float &operator*=(float &a, const BFloat16 &b) {
-  return a *= static_cast<float>(b);
-}
-inline C10_HOST_DEVICE float &operator/=(float &a, const BFloat16 &b) {
-  return a /= static_cast<float>(b);
-}
-
-/// Arithmetic with doubles
-
-inline C10_HOST_DEVICE double operator+(BFloat16 a, double b) {
-  return static_cast<double>(a) + b;
-}
-inline C10_HOST_DEVICE double operator-(BFloat16 a, double b) {
-  return static_cast<double>(a) - b;
-}
-inline C10_HOST_DEVICE double operator*(BFloat16 a, double b) {
-  return static_cast<double>(a) * b;
-}
-inline C10_HOST_DEVICE double operator/(BFloat16 a, double b) {
-  return static_cast<double>(a) / b;
-}
-
-inline C10_HOST_DEVICE double operator+(double a, BFloat16 b) {
-  return a + static_cast<double>(b);
-}
-inline C10_HOST_DEVICE double operator-(double a, BFloat16 b) {
-  return a - static_cast<double>(b);
-}
-inline C10_HOST_DEVICE double operator*(double a, BFloat16 b) {
-  return a * static_cast<double>(b);
-}
-inline C10_HOST_DEVICE double operator/(double a, BFloat16 b) {
-  return a / static_cast<double>(b);
-}
-
-/// Arithmetic with ints
-
-inline C10_HOST_DEVICE BFloat16 operator+(BFloat16 a, int b) {
-  // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
-  return a + static_cast<BFloat16>(b);
-}
-inline C10_HOST_DEVICE BFloat16 operator-(BFloat16 a, int b) {
-  // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
-  return a - static_cast<BFloat16>(b);
-}
-inline C10_HOST_DEVICE BFloat16 operator*(BFloat16 a, int b) {
-  // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
-  return a * static_cast<BFloat16>(b);
-}
-inline C10_HOST_DEVICE BFloat16 operator/(BFloat16 a, int b) {
-  // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
-  return a / static_cast<BFloat16>(b);
-}
-
-inline C10_HOST_DEVICE BFloat16 operator+(int a, BFloat16 b) {
-  // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
-  return static_cast<BFloat16>(a) + b;
-}
-inline C10_HOST_DEVICE BFloat16 operator-(int a, BFloat16 b) {
-  // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
-  return static_cast<BFloat16>(a) - b;
-}
-inline C10_HOST_DEVICE BFloat16 operator*(int a, BFloat16 b) {
-  // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
-  return static_cast<BFloat16>(a) * b;
-}
-inline C10_HOST_DEVICE BFloat16 operator/(int a, BFloat16 b) {
-  // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
-  return static_cast<BFloat16>(a) / b;
-}
-
-//// Arithmetic with int64_t
-
-inline C10_HOST_DEVICE BFloat16 operator+(BFloat16 a, int64_t b) {
-  // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
-  return a + static_cast<BFloat16>(b);
-}
-inline C10_HOST_DEVICE BFloat16 operator-(BFloat16 a, int64_t b) {
-  // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
-  return a - static_cast<BFloat16>(b);
-}
-inline C10_HOST_DEVICE BFloat16 operator*(BFloat16 a, int64_t b) {
-  // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
-  return a * static_cast<BFloat16>(b);
-}
-inline C10_HOST_DEVICE BFloat16 operator/(BFloat16 a, int64_t b) {
-  // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
-  return a / static_cast<BFloat16>(b);
-}
-
-inline C10_HOST_DEVICE BFloat16 operator+(int64_t a, BFloat16 b) {
-  // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
-  return static_cast<BFloat16>(a) + b;
-}
-inline C10_HOST_DEVICE BFloat16 operator-(int64_t a, BFloat16 b) {
-  // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
-  return static_cast<BFloat16>(a) - b;
-}
-inline C10_HOST_DEVICE BFloat16 operator*(int64_t a, BFloat16 b) {
-  // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
-  return static_cast<BFloat16>(a) * b;
-}
-inline C10_HOST_DEVICE BFloat16 operator/(int64_t a, BFloat16 b) {
-  // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
-  return static_cast<BFloat16>(a) / b;
-}
-
-// Overloading < and > operators, because std::max and std::min use them.
-
-inline C10_HOST_DEVICE bool operator>(BFloat16 &lhs, BFloat16 &rhs) {
-  return float(lhs) > float(rhs);
-}
-
-inline C10_HOST_DEVICE bool operator<(BFloat16 &lhs, BFloat16 &rhs) {
-  return float(lhs) < float(rhs);
-}
-
-C10_CLANG_DIAGNOSTIC_POP()
-} // namespace c10
-
-HIDDEN_NAMESPACE_BEGIN(torch, headeronly)
-
-namespace detail {
-using c10::detail::bits_from_f32;
-using c10::detail::f32_from_bits;
-using c10::detail::round_to_nearest_even;
-} // namespace detail
-
-using c10::BFloat16;
-using c10::operator+;
-using c10::operator-;
-using c10::operator*;
-using c10::operator/;
-using c10::operator+=;
-using c10::operator-=;
-using c10::operator*=;
-using c10::operator/=;
-using c10::operator<;
-using c10::operator>;
-using c10::operator<<;
-HIDDEN_NAMESPACE_END(torch, headeronly)
-
-namespace std {
-
-template <> class numeric_limits<c10::BFloat16> {
-public:
-  static constexpr bool is_signed = true;
-  static constexpr bool is_specialized = true;
-  static constexpr bool is_integer = false;
-  static constexpr bool is_exact = false;
-  static constexpr bool has_infinity = true;
-  static constexpr bool has_quiet_NaN = true;
-  static constexpr bool has_signaling_NaN = true;
-  static constexpr auto has_denorm = numeric_limits<float>::has_denorm;
-  static constexpr auto has_denorm_loss =
-      numeric_limits<float>::has_denorm_loss;
-  static constexpr auto round_style = numeric_limits<float>::round_style;
-  static constexpr bool is_iec559 = false;
-  static constexpr bool is_bounded = true;
-  static constexpr bool is_modulo = false;
-  static constexpr int digits = 8;
-  static constexpr int digits10 = 2;
-  static constexpr int max_digits10 = 4;
-  static constexpr int radix = 2;
-  static constexpr int min_exponent = -125;
-  static constexpr int min_exponent10 = -37;
-  static constexpr int max_exponent = 128;
-  static constexpr int max_exponent10 = 38;
-  static constexpr auto traps = numeric_limits<float>::traps;
-  static constexpr auto tinyness_before =
-      numeric_limits<float>::tinyness_before;
-
-  static constexpr c10::BFloat16 min() {
-    return c10::BFloat16(0x0080, c10::BFloat16::from_bits());
-  }
-  static constexpr c10::BFloat16 lowest() {
-    return c10::BFloat16(0xFF7F, c10::BFloat16::from_bits());
-  }
-  static constexpr c10::BFloat16 max() {
-    return c10::BFloat16(0x7F7F, c10::BFloat16::from_bits());
-  }
-  static constexpr c10::BFloat16 epsilon() {
-    return c10::BFloat16(0x3C00, c10::BFloat16::from_bits());
-  }
-  static constexpr c10::BFloat16 round_error() {
-    return c10::BFloat16(0x3F00, c10::BFloat16::from_bits());
-  }
-  static constexpr c10::BFloat16 infinity() {
-    return c10::BFloat16(0x7F80, c10::BFloat16::from_bits());
-  }
-  static constexpr c10::BFloat16 quiet_NaN() {
-    return c10::BFloat16(0x7FC0, c10::BFloat16::from_bits());
-  }
-  static constexpr c10::BFloat16 signaling_NaN() {
-    return c10::BFloat16(0x7F80, c10::BFloat16::from_bits());
-  }
-  static constexpr c10::BFloat16 denorm_min() {
-    return c10::BFloat16(0x0001, c10::BFloat16::from_bits());
-  }
-};
-
-} // namespace std
diff --git a/packages/react-native-executorch/third-party/include/torch/headeronly/util/Half.h b/packages/react-native-executorch/third-party/include/torch/headeronly/util/Half.h
deleted file mode 100644
index 5e76c07a64..0000000000
--- a/packages/react-native-executorch/third-party/include/torch/headeronly/util/Half.h
+++ /dev/null
@@ -1,782 +0,0 @@
-#pragma once
-
-/// Defines the Half type (half-precision floating-point) including conversions
-/// to standard C types and basic arithmetic operations. Note that arithmetic
-/// operations are implemented by converting to floating point and
-/// performing the operation in float32, instead of using CUDA half intrinsics.
-/// Most uses of this type within ATen are memory bound, including the
-/// element-wise kernels, and the half intrinsics aren't efficient on all GPUs.
-/// If you are writing a compute bound kernel, you can use the CUDA half
-/// intrinsics directly on the Half type from device code.
-
-#include <torch/headeronly/macros/Macros.h>
-#include <torch/headeronly/util/bit_cast.h>
-#include <torch/headeronly/util/floating_point_utils.h>
-
-#if defined(__cplusplus)
-#include <cmath>
-#elif !defined(__OPENCL_VERSION__)
-#include <math.h>
-#endif
-
-#ifdef _MSC_VER
-#include <intrin.h>
-#endif
-
-#include <cstdint>
-#include <cstring>
-#include <ostream>
-
-#ifdef __CUDACC__
-#include <cuda_fp16.h>
-#endif
-
-#ifdef __HIPCC__
-#include <hip/hip_fp16.h>
-#endif
-
-#if defined(CL_SYCL_LANGUAGE_VERSION)
-#include <CL/sycl.hpp> // for SYCL 1.2.1
-#elif defined(SYCL_LANGUAGE_VERSION)
-#include <sycl/sycl.hpp> // for SYCL 2020
-#endif
-
-#if (defined(CPU_CAPABILITY_AVX2) || defined(CPU_CAPABILITY_AVX512)) &&        \
-    !defined(__APPLE__)
-#include <torch/headeronly/cpu/vec/vec_half.h>
-#endif
-
-#if defined(__aarch64__) && !defined(__CUDACC__)
-#include <arm_neon.h>
-#endif
-
-#if defined(__GNUC__) || defined(__clang__)
-#if defined(__x86_64__) || defined(_M_X64) || defined(__i386) ||               \
-    defined(_M_IX86)
-#if defined(__F16C__) && !(defined(__CUDA_ARCH__) || defined(__CUDACC__) ||    \
-                           defined(__HIP_DEVICE_COMPILE__))
-#define C10_X86_F16 1
-#include <immintrin.h> // import conversion ops from f16cintrin.h
-#endif // defined(__F16C__) && !(defined(__CUDA_ARCH__) || defined(__CUDACC__)
-       // || defined(__HIP_DEVICE_COMPILE__))
-#endif // __x86_64__ || _M_X64 || __i386 || _M_IX86
-#endif // __GNUC__ || __clang__
-
-namespace c10 {
-
-struct alignas(2) Half {
-  unsigned short x;
-
-  struct from_bits_t {};
-  C10_HOST_DEVICE static constexpr from_bits_t from_bits() {
-    return from_bits_t();
-  }
-
-  // HIP wants __host__ __device__ tag, CUDA does not
-#if defined(USE_ROCM)
-  C10_HOST_DEVICE Half() = default;
-#else
-  Half() = default;
-#endif
-
-  constexpr C10_HOST_DEVICE Half(unsigned short bits, from_bits_t /*unused*/)
-      : x(bits) {}
-#if defined(__aarch64__) && !defined(__CUDACC__)
-  inline Half(float16_t value);
-  inline operator float16_t() const;
-#else
-  inline C10_HOST_DEVICE Half(float value);
-  inline C10_HOST_DEVICE operator float() const;
-#endif
-
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  inline C10_HOST_DEVICE Half(const __half &value);
-  inline C10_HOST_DEVICE operator __half() const;
-#endif
-#ifdef SYCL_LANGUAGE_VERSION
-  inline C10_HOST_DEVICE Half(const sycl::half &value);
-  inline C10_HOST_DEVICE operator sycl::half() const;
-#endif
-};
-
-inline std::ostream &operator<<(std::ostream &out, const Half &value) {
-  out << (float)value;
-  return out;
-}
-
-namespace detail {
-/*
- * Convert a 16-bit floating-point number in IEEE half-precision format, in bit
- * representation, to a 32-bit floating-point number in IEEE single-precision
- * format.
- *
- * @note The implementation relies on IEEE-like (no assumption about rounding
- * mode and no operations on denormals) floating-point operations and bitcasts
- * between integer and floating-point variables.
- */
-C10_HOST_DEVICE inline float fp16_ieee_to_fp32_value(uint16_t h) {
-#ifdef C10_X86_F16
-  return _cvtsh_ss(h);
-#else
-  /*
-   * Extend the half-precision floating-point number to 32 bits and shift to the
-   * upper part of the 32-bit word:
-   *      +---+-----+------------+-------------------+
-   *      | S |EEEEE|MM MMMM MMMM|0000 0000 0000 0000|
-   *      +---+-----+------------+-------------------+
-   * Bits  31  26-30    16-25            0-15
-   *
-   * S - sign bit, E - bits of the biased exponent, M - bits of the mantissa, 0
-   * - zero bits.
-   */
-  const uint32_t w = (uint32_t)h << 16;
-  /*
-   * Extract the sign of the input number into the high bit of the 32-bit word:
-   *
-   *      +---+----------------------------------+
-   *      | S |0000000 00000000 00000000 00000000|
-   *      +---+----------------------------------+
-   * Bits  31                 0-31
-   */
-  const uint32_t sign = w & UINT32_C(0x80000000);
-  /*
-   * Extract mantissa and biased exponent of the input number into the high bits
-   * of the 32-bit word:
-   *
-   *      +-----+------------+---------------------+
-   *      |EEEEE|MM MMMM MMMM|0 0000 0000 0000 0000|
-   *      +-----+------------+---------------------+
-   * Bits  27-31    17-26            0-16
-   */
-  const uint32_t two_w = w + w;
-
-  /*
-   * Shift mantissa and exponent into bits 23-28 and bits 13-22 so they become
-   * mantissa and exponent of a single-precision floating-point number:
-   *
-   *       S|Exponent |          Mantissa
-   *      +-+---+-----+------------+----------------+
-   *      |0|000|EEEEE|MM MMMM MMMM|0 0000 0000 0000|
-   *      +-+---+-----+------------+----------------+
-   * Bits   | 23-31   |           0-22
-   *
-   * Next, there are some adjustments to the exponent:
-   * - The exponent needs to be corrected by the difference in exponent bias
-   * between single-precision and half-precision formats (0x7F - 0xF = 0x70)
-   * - Inf and NaN values in the inputs should become Inf and NaN values after
-   * conversion to the single-precision number. Therefore, if the biased
-   * exponent of the half-precision input was 0x1F (max possible value), the
-   * biased exponent of the single-precision output must be 0xFF (max possible
-   * value). We do this correction in two steps:
-   *   - First, we adjust the exponent by (0xFF - 0x1F) = 0xE0 (see exp_offset
-   * below) rather than by 0x70 suggested by the difference in the exponent bias
-   * (see above).
-   *   - Then we multiply the single-precision result of exponent adjustment by
-   * 2**(-112) to reverse the effect of exponent adjustment by 0xE0 less the
-   * necessary exponent adjustment by 0x70 due to difference in exponent bias.
-   *     The floating-point multiplication hardware would ensure than Inf and
-   * NaN would retain their value on at least partially IEEE754-compliant
-   * implementations.
-   *
-   * Note that the above operations do not handle denormal inputs (where biased
-   * exponent == 0). However, they also do not operate on denormal inputs, and
-   * do not produce denormal results.
-   */
-  constexpr uint32_t exp_offset = UINT32_C(0xE0) << 23;
-  // const float exp_scale = 0x1.0p-112f;
-  constexpr uint32_t scale_bits = (uint32_t)15 << 23;
-  float exp_scale_val = 0;
-#if defined(_MSC_VER) && defined(__clang__)
-  __builtin_memcpy(&exp_scale_val, &scale_bits, sizeof(exp_scale_val));
-#else
-  std::memcpy(&exp_scale_val, &scale_bits, sizeof(exp_scale_val));
-#endif
-
-  const float exp_scale = exp_scale_val;
-  const float normalized_value =
-      fp32_from_bits((two_w >> 4) + exp_offset) * exp_scale;
-
-  /*
-   * Convert denormalized half-precision inputs into single-precision results
-   * (always normalized). Zero inputs are also handled here.
-   *
-   * In a denormalized number the biased exponent is zero, and mantissa has
-   * on-zero bits. First, we shift mantissa into bits 0-9 of the 32-bit word.
-   *
-   *                  zeros           |  mantissa
-   *      +---------------------------+------------+
-   *      |0000 0000 0000 0000 0000 00|MM MMMM MMMM|
-   *      +---------------------------+------------+
-   * Bits             10-31                0-9
-   *
-   * Now, remember that denormalized half-precision numbers are represented as:
-   *    FP16 = mantissa * 2**(-24).
-   * The trick is to construct a normalized single-precision number with the
-   * same mantissa and thehalf-precision input and with an exponent which would
-   * scale the corresponding mantissa bits to 2**(-24). A normalized
-   * single-precision floating-point number is represented as: FP32 = (1 +
-   * mantissa * 2**(-23)) * 2**(exponent - 127) Therefore, when the biased
-   * exponent is 126, a unit change in the mantissa of the input denormalized
-   * half-precision number causes a change of the constructed single-precision
-   * number by 2**(-24), i.e. the same amount.
-   *
-   * The last step is to adjust the bias of the constructed single-precision
-   * number. When the input half-precision number is zero, the constructed
-   * single-precision number has the value of FP32 = 1 * 2**(126 - 127) =
-   * 2**(-1) = 0.5 Therefore, we need to subtract 0.5 from the constructed
-   * single-precision number to get the numerical equivalent of the input
-   * half-precision number.
-   */
-  constexpr uint32_t magic_mask = UINT32_C(126) << 23;
-  constexpr float magic_bias = 0.5f;
-  const float denormalized_value =
-      fp32_from_bits((two_w >> 17) | magic_mask) - magic_bias;
-
-  /*
-   * - Choose either results of conversion of input as a normalized number, or
-   * as a denormalized number, depending on the input exponent. The variable
-   * two_w contains input exponent in bits 27-31, therefore if its smaller than
-   * 2**27, the input is either a denormal number, or zero.
-   * - Combine the result of conversion of exponent and mantissa with the sign
-   * of the input number.
-   */
-  constexpr uint32_t denormalized_cutoff = UINT32_C(1) << 27;
-  const uint32_t result =
-      sign | (two_w < denormalized_cutoff ? fp32_to_bits(denormalized_value)
-                                          : fp32_to_bits(normalized_value));
-  return fp32_from_bits(result);
-#endif // C10_X86_F16
-}
-
-/*
- * Convert a 32-bit floating-point number in IEEE single-precision format to a
- * 16-bit floating-point number in IEEE half-precision format, in bit
- * representation.
- *
- * @note The implementation relies on IEEE-like (no assumption about rounding
- * mode and no operations on denormals) floating-point operations and bitcasts
- * between integer and floating-point variables.
- */
-inline uint16_t fp16_ieee_from_fp32_value(float f) {
-#ifdef C10_X86_F16
-  return _cvtss_sh(f, _MM_FROUND_TO_NEAREST_INT);
-#else
-  // const float scale_to_inf = 0x1.0p+112f;
-  // const float scale_to_zero = 0x1.0p-110f;
-  constexpr uint32_t scale_to_inf_bits = (uint32_t)239 << 23;
-  constexpr uint32_t scale_to_zero_bits = (uint32_t)17 << 23;
-  float scale_to_inf_val = 0, scale_to_zero_val = 0;
-  std::memcpy(&scale_to_inf_val, &scale_to_inf_bits, sizeof(scale_to_inf_val));
-  std::memcpy(&scale_to_zero_val, &scale_to_zero_bits,
-              sizeof(scale_to_zero_val));
-  const float scale_to_inf = scale_to_inf_val;
-  const float scale_to_zero = scale_to_zero_val;
-
-#if defined(_MSC_VER) && _MSC_VER == 1916
-  float base = ((signbit(f) != 0 ? -f : f) * scale_to_inf) * scale_to_zero;
-#else
-  float base = (fabsf(f) * scale_to_inf) * scale_to_zero;
-#endif
-
-  const uint32_t w = fp32_to_bits(f);
-  const uint32_t shl1_w = w + w;
-  const uint32_t sign = w & UINT32_C(0x80000000);
-  uint32_t bias = shl1_w & UINT32_C(0xFF000000);
-  if (bias < UINT32_C(0x71000000)) {
-    bias = UINT32_C(0x71000000);
-  }
-
-  base = fp32_from_bits((bias >> 1) + UINT32_C(0x07800000)) + base;
-  const uint32_t bits = fp32_to_bits(base);
-  const uint32_t exp_bits = (bits >> 13) & UINT32_C(0x00007C00);
-  const uint32_t mantissa_bits = bits & UINT32_C(0x00000FFF);
-  const uint32_t nonsign = exp_bits + mantissa_bits;
-  return static_cast<uint16_t>(
-      (sign >> 16) |
-      (shl1_w > UINT32_C(0xFF000000) ? UINT16_C(0x7E00) : nonsign));
-#endif // C10_X86_F16
-}
-
-/*
- * Convert a 16-bit floating-point number in IEEE half-precision format, in bit
- * representation, to a 32-bit floating-point number in IEEE single-precision
- * format, in bit representation.
- *
- * @note The implementation doesn't use any floating-point operations.
- */
-inline uint32_t fp16_ieee_to_fp32_bits(uint16_t h) {
-  /*
-   * Extend the half-precision floating-point number to 32 bits and shift to the
-   * upper part of the 32-bit word:
-   *      +---+-----+------------+-------------------+
-   *      | S |EEEEE|MM MMMM MMMM|0000 0000 0000 0000|
-   *      +---+-----+------------+-------------------+
-   * Bits  31  26-30    16-25            0-15
-   *
-   * S - sign bit, E - bits of the biased exponent, M - bits of the mantissa, 0
-   * - zero bits.
-   */
-  const uint32_t w = (uint32_t)h << 16;
-  /*
-   * Extract the sign of the input number into the high bit of the 32-bit word:
-   *
-   *      +---+----------------------------------+
-   *      | S |0000000 00000000 00000000 00000000|
-   *      +---+----------------------------------+
-   * Bits  31                 0-31
-   */
-  const uint32_t sign = w & UINT32_C(0x80000000);
-  /*
-   * Extract mantissa and biased exponent of the input number into the bits 0-30
-   * of the 32-bit word:
-   *
-   *      +---+-----+------------+-------------------+
-   *      | 0 |EEEEE|MM MMMM MMMM|0000 0000 0000 0000|
-   *      +---+-----+------------+-------------------+
-   * Bits  30  27-31     17-26            0-16
-   */
-  const uint32_t nonsign = w & UINT32_C(0x7FFFFFFF);
-  /*
-   * Renorm shift is the number of bits to shift mantissa left to make the
-   * half-precision number normalized. If the initial number is normalized, some
-   * of its high 6 bits (sign == 0 and 5-bit exponent) equals one. In this case
-   * renorm_shift == 0. If the number is denormalize, renorm_shift > 0. Note
-   * that if we shift denormalized nonsign by renorm_shift, the unit bit of
-   * mantissa will shift into exponent, turning the biased exponent into 1, and
-   * making mantissa normalized (i.e. without leading 1).
-   */
-#ifdef _MSC_VER
-  unsigned long nonsign_bsr;
-  _BitScanReverse(&nonsign_bsr, (unsigned long)nonsign);
-  uint32_t renorm_shift = (uint32_t)nonsign_bsr ^ 31;
-#else
-  uint32_t renorm_shift = __builtin_clz(nonsign);
-#endif
-  renorm_shift = renorm_shift > 5 ? renorm_shift - 5 : 0;
-  /*
-   * Iff half-precision number has exponent of 15, the addition overflows
-   * it into bit 31, and the subsequent shift turns the high 9 bits
-   * into 1. Thus inf_nan_mask == 0x7F800000 if the half-precision number
-   * had exponent of 15 (i.e. was NaN or infinity) 0x00000000 otherwise
-   */
-  const int32_t inf_nan_mask =
-      ((int32_t)(nonsign + 0x04000000) >> 8) & INT32_C(0x7F800000);
-  /*
-   * Iff nonsign is 0, it overflows into 0xFFFFFFFF, turning bit 31
-   * into 1. Otherwise, bit 31 remains 0. The signed shift right by 31
-   * broadcasts bit 31 into all bits of the zero_mask. Thus zero_mask ==
-   * 0xFFFFFFFF if the half-precision number was zero (+0.0h or -0.0h)
-   * 0x00000000 otherwise
-   */
-  const int32_t zero_mask = (int32_t)(nonsign - 1) >> 31;
-  /*
-   * 1. Shift nonsign left by renorm_shift to normalize it (if the input
-   * was denormal)
-   * 2. Shift nonsign right by 3 so the exponent (5 bits originally)
-   * becomes an 8-bit field and 10-bit mantissa shifts into the 10 high
-   * bits of the 23-bit mantissa of IEEE single-precision number.
-   * 3. Add 0x70 to the exponent (starting at bit 23) to compensate the
-   * different in exponent bias (0x7F for single-precision number less 0xF
-   * for half-precision number).
-   * 4. Subtract renorm_shift from the exponent (starting at bit 23) to
-   * account for renormalization. As renorm_shift is less than 0x70, this
-   * can be combined with step 3.
-   * 5. Binary OR with inf_nan_mask to turn the exponent into 0xFF if the
-   * input was NaN or infinity.
-   * 6. Binary ANDNOT with zero_mask to turn the mantissa and exponent
-   * into zero if the input was zero.
-   * 7. Combine with the sign of the input number.
-   */
-  return sign |
-         ((((nonsign << renorm_shift >> 3) + ((0x70 - renorm_shift) << 23)) |
-           inf_nan_mask) &
-          ~zero_mask);
-}
-
-#ifdef C10_X86_F16
-#undef C10_X86_F16
-#endif // C10_X86_F16
-
-#if defined(__aarch64__) && !defined(__CUDACC__)
-inline float16_t fp16_from_bits(uint16_t h) {
-  return c10::bit_cast<float16_t>(h);
-}
-
-inline uint16_t fp16_to_bits(float16_t f) { return c10::bit_cast<uint16_t>(f); }
-
-// According to https://godbolt.org/z/frExdbsWG it would translate to single
-// fcvt s0, h0
-inline float native_fp16_to_fp32_value(uint16_t h) {
-  return static_cast<float>(fp16_from_bits(h));
-}
-
-inline uint16_t native_fp16_from_fp32_value(float f) {
-  return fp16_to_bits(static_cast<float16_t>(f));
-}
-#endif
-
-} // namespace detail
-
-//---------- below is copied from c10/util/Half-inl.h ----------------//
-C10_CLANG_DIAGNOSTIC_PUSH()
-#if C10_CLANG_HAS_WARNING("-Wimplicit-int-float-conversion")
-C10_CLANG_DIAGNOSTIC_IGNORE("-Wimplicit-int-float-conversion")
-#endif
-
-#if defined(__aarch64__) && !defined(__CUDACC__)
-/// Constructors
-inline Half::Half(float16_t value) : x(detail::fp16_to_bits(value)) {}
-inline Half::operator float16_t() const { return detail::fp16_from_bits(x); }
-#else
-
-inline C10_HOST_DEVICE Half::Half(float value)
-    :
-#if defined(__CUDA_ARCH__) || defined(__HIP_DEVICE_COMPILE__)
-      x(__half_as_short(__float2half(value)))
-#elif defined(__SYCL_DEVICE_ONLY__)
-      x(c10::bit_cast<uint16_t>(sycl::half(value)))
-#elif (defined(CPU_CAPABILITY_AVX2) || defined(CPU_CAPABILITY_AVX512)) &&      \
-    !defined(__APPLE__)
-      x(at::vec::float2half_scalar(value))
-#else
-      x(detail::fp16_ieee_from_fp32_value(value))
-#endif
-{
-}
-
-/// Implicit conversions
-
-inline C10_HOST_DEVICE Half::operator float() const {
-#if defined(__CUDA_ARCH__) || defined(__HIP_DEVICE_COMPILE__)
-  return __half2float(*reinterpret_cast<const __half *>(&x));
-#elif defined(__SYCL_DEVICE_ONLY__)
-  return float(c10::bit_cast<sycl::half>(x));
-#elif (defined(CPU_CAPABILITY_AVX2) || defined(CPU_CAPABILITY_AVX512)) &&      \
-    !defined(__APPLE__)
-  return at::vec::half2float_scalar(x);
-#elif defined(__aarch64__) && !defined(__CUDACC__)
-  return detail::native_fp16_to_fp32_value(x);
-#else
-  return detail::fp16_ieee_to_fp32_value(x);
-#endif
-}
-
-#endif /* !defined(__aarch64__) || defined(__CUDACC__)                         \
-        */
-
-#if defined(__CUDACC__) || defined(__HIPCC__)
-inline C10_HOST_DEVICE Half::Half(const __half &value) {
-  x = *reinterpret_cast<const unsigned short *>(&value);
-}
-inline C10_HOST_DEVICE Half::operator __half() const {
-  return *reinterpret_cast<const __half *>(&x);
-}
-#endif
-
-#ifdef SYCL_LANGUAGE_VERSION
-inline C10_HOST_DEVICE Half::Half(const sycl::half &value) {
-  x = *reinterpret_cast<const unsigned short *>(&value);
-}
-inline C10_HOST_DEVICE Half::operator sycl::half() const {
-  return *reinterpret_cast<const sycl::half *>(&x);
-}
-#endif
-
-// CUDA intrinsics
-
-#if (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 350)) ||                      \
-    (defined(__clang__) && defined(__CUDA__))
-inline __device__ Half __ldg(const Half *ptr) {
-  return __ldg(reinterpret_cast<const __half *>(ptr));
-}
-#endif
-
-/// Arithmetic
-
-inline C10_HOST_DEVICE Half operator+(const Half &a, const Half &b) {
-  return static_cast<float>(a) + static_cast<float>(b);
-}
-
-inline C10_HOST_DEVICE Half operator-(const Half &a, const Half &b) {
-  return static_cast<float>(a) - static_cast<float>(b);
-}
-
-inline C10_HOST_DEVICE Half operator*(const Half &a, const Half &b) {
-  return static_cast<float>(a) * static_cast<float>(b);
-}
-
-inline C10_HOST_DEVICE Half operator/(const Half &a, const Half &b)
-    __ubsan_ignore_float_divide_by_zero__ {
-  return static_cast<float>(a) / static_cast<float>(b);
-}
-
-inline C10_HOST_DEVICE Half operator-(const Half &a) {
-#if (defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 530) ||                        \
-    defined(__HIP_DEVICE_COMPILE__)
-  return __hneg(a);
-#elif defined(__SYCL_DEVICE_ONLY__)
-  return -c10::bit_cast<sycl::half>(a);
-#else
-  return -static_cast<float>(a);
-#endif
-}
-
-inline C10_HOST_DEVICE Half &operator+=(Half &a, const Half &b) {
-  a = a + b;
-  return a;
-}
-
-inline C10_HOST_DEVICE Half &operator-=(Half &a, const Half &b) {
-  a = a - b;
-  return a;
-}
-
-inline C10_HOST_DEVICE Half &operator*=(Half &a, const Half &b) {
-  a = a * b;
-  return a;
-}
-
-inline C10_HOST_DEVICE Half &operator/=(Half &a, const Half &b) {
-  a = a / b;
-  return a;
-}
-
-/// Arithmetic with floats
-
-inline C10_HOST_DEVICE float operator+(Half a, float b) {
-  return static_cast<float>(a) + b;
-}
-inline C10_HOST_DEVICE float operator-(Half a, float b) {
-  return static_cast<float>(a) - b;
-}
-inline C10_HOST_DEVICE float operator*(Half a, float b) {
-  return static_cast<float>(a) * b;
-}
-inline C10_HOST_DEVICE float
-operator/(Half a, float b) __ubsan_ignore_float_divide_by_zero__ {
-  return static_cast<float>(a) / b;
-}
-
-inline C10_HOST_DEVICE float operator+(float a, Half b) {
-  return a + static_cast<float>(b);
-}
-inline C10_HOST_DEVICE float operator-(float a, Half b) {
-  return a - static_cast<float>(b);
-}
-inline C10_HOST_DEVICE float operator*(float a, Half b) {
-  return a * static_cast<float>(b);
-}
-inline C10_HOST_DEVICE float
-operator/(float a, Half b) __ubsan_ignore_float_divide_by_zero__ {
-  return a / static_cast<float>(b);
-}
-
-inline C10_HOST_DEVICE float &operator+=(float &a, const Half &b) {
-  return a += static_cast<float>(b);
-}
-inline C10_HOST_DEVICE float &operator-=(float &a, const Half &b) {
-  return a -= static_cast<float>(b);
-}
-inline C10_HOST_DEVICE float &operator*=(float &a, const Half &b) {
-  return a *= static_cast<float>(b);
-}
-inline C10_HOST_DEVICE float &operator/=(float &a, const Half &b) {
-  return a /= static_cast<float>(b);
-}
-
-/// Arithmetic with doubles
-
-inline C10_HOST_DEVICE double operator+(Half a, double b) {
-  return static_cast<double>(a) + b;
-}
-inline C10_HOST_DEVICE double operator-(Half a, double b) {
-  return static_cast<double>(a) - b;
-}
-inline C10_HOST_DEVICE double operator*(Half a, double b) {
-  return static_cast<double>(a) * b;
-}
-inline C10_HOST_DEVICE double
-operator/(Half a, double b) __ubsan_ignore_float_divide_by_zero__ {
-  return static_cast<double>(a) / b;
-}
-
-inline C10_HOST_DEVICE double operator+(double a, Half b) {
-  return a + static_cast<double>(b);
-}
-inline C10_HOST_DEVICE double operator-(double a, Half b) {
-  return a - static_cast<double>(b);
-}
-inline C10_HOST_DEVICE double operator*(double a, Half b) {
-  return a * static_cast<double>(b);
-}
-inline C10_HOST_DEVICE double
-operator/(double a, Half b) __ubsan_ignore_float_divide_by_zero__ {
-  return a / static_cast<double>(b);
-}
-
-/// Arithmetic with ints
-
-inline C10_HOST_DEVICE Half operator+(Half a, int b) {
-  // NOLINTNEXTLINE(cppcoreguidelines-narrowing-conversions,bugprone-narrowing-conversions)
-  return a + static_cast<Half>(b);
-}
-inline C10_HOST_DEVICE Half operator-(Half a, int b) {
-  // NOLINTNEXTLINE(cppcoreguidelines-narrowing-conversions,bugprone-narrowing-conversions)
-  return a - static_cast<Half>(b);
-}
-inline C10_HOST_DEVICE Half operator*(Half a, int b) {
-  // NOLINTNEXTLINE(cppcoreguidelines-narrowing-conversions,bugprone-narrowing-conversions)
-  return a * static_cast<Half>(b);
-}
-inline C10_HOST_DEVICE Half operator/(Half a, int b) {
-  // NOLINTNEXTLINE(cppcoreguidelines-narrowing-conversions,bugprone-narrowing-conversions)
-  return a / static_cast<Half>(b);
-}
-
-inline C10_HOST_DEVICE Half operator+(int a, Half b) {
-  // NOLINTNEXTLINE(cppcoreguidelines-narrowing-conversions,bugprone-narrowing-conversions)
-  return static_cast<Half>(a) + b;
-}
-inline C10_HOST_DEVICE Half operator-(int a, Half b) {
-  // NOLINTNEXTLINE(cppcoreguidelines-narrowing-conversions,bugprone-narrowing-conversions)
-  return static_cast<Half>(a) - b;
-}
-inline C10_HOST_DEVICE Half operator*(int a, Half b) {
-  // NOLINTNEXTLINE(cppcoreguidelines-narrowing-conversions,bugprone-narrowing-conversions)
-  return static_cast<Half>(a) * b;
-}
-inline C10_HOST_DEVICE Half operator/(int a, Half b) {
-  // NOLINTNEXTLINE(cppcoreguidelines-narrowing-conversions,bugprone-narrowing-conversions)
-  return static_cast<Half>(a) / b;
-}
-
-//// Arithmetic with int64_t
-
-inline C10_HOST_DEVICE Half operator+(Half a, int64_t b) {
-  // NOLINTNEXTLINE(cppcoreguidelines-narrowing-conversions,bugprone-narrowing-conversions)
-  return a + static_cast<Half>(b);
-}
-inline C10_HOST_DEVICE Half operator-(Half a, int64_t b) {
-  // NOLINTNEXTLINE(cppcoreguidelines-narrowing-conversions,bugprone-narrowing-conversions)
-  return a - static_cast<Half>(b);
-}
-inline C10_HOST_DEVICE Half operator*(Half a, int64_t b) {
-  // NOLINTNEXTLINE(cppcoreguidelines-narrowing-conversions,bugprone-narrowing-conversions)
-  return a * static_cast<Half>(b);
-}
-inline C10_HOST_DEVICE Half operator/(Half a, int64_t b) {
-  // NOLINTNEXTLINE(cppcoreguidelines-narrowing-conversions,bugprone-narrowing-conversions)
-  return a / static_cast<Half>(b);
-}
-
-inline C10_HOST_DEVICE Half operator+(int64_t a, Half b) {
-  // NOLINTNEXTLINE(cppcoreguidelines-narrowing-conversions,bugprone-narrowing-conversions)
-  return static_cast<Half>(a) + b;
-}
-inline C10_HOST_DEVICE Half operator-(int64_t a, Half b) {
-  // NOLINTNEXTLINE(cppcoreguidelines-narrowing-conversions,bugprone-narrowing-conversions)
-  return static_cast<Half>(a) - b;
-}
-inline C10_HOST_DEVICE Half operator*(int64_t a, Half b) {
-  // NOLINTNEXTLINE(cppcoreguidelines-narrowing-conversions,bugprone-narrowing-conversions)
-  return static_cast<Half>(a) * b;
-}
-inline C10_HOST_DEVICE Half operator/(int64_t a, Half b) {
-  // NOLINTNEXTLINE(cppcoreguidelines-narrowing-conversions,bugprone-narrowing-conversions)
-  return static_cast<Half>(a) / b;
-}
-
-/// NOTE: we do not define comparisons directly and instead rely on the implicit
-/// conversion from c10::Half to float.
-
-C10_CLANG_DIAGNOSTIC_POP()
-
-} // namespace c10
-
-HIDDEN_NAMESPACE_BEGIN(torch, headeronly)
-
-using c10::Half;
-using c10::operator+;
-using c10::operator-;
-using c10::operator*;
-using c10::operator/;
-using c10::operator+=;
-using c10::operator-=;
-using c10::operator*=;
-using c10::operator/=;
-using c10::operator<<;
-
-namespace detail {
-#if defined(__aarch64__) && !defined(__CUDACC__)
-using c10::detail::fp16_from_bits;
-using c10::detail::fp16_to_bits;
-using c10::detail::native_fp16_from_fp32_value;
-using c10::detail::native_fp16_to_fp32_value;
-#endif
-
-using c10::detail::fp16_ieee_from_fp32_value;
-using c10::detail::fp16_ieee_to_fp32_bits;
-using c10::detail::fp16_ieee_to_fp32_value;
-} // namespace detail
-
-HIDDEN_NAMESPACE_END(torch, headeronly)
-
-namespace std {
-
-template <> class numeric_limits<c10::Half> {
-public:
-  static constexpr bool is_specialized = true;
-  static constexpr bool is_signed = true;
-  static constexpr bool is_integer = false;
-  static constexpr bool is_exact = false;
-  static constexpr bool has_infinity = true;
-  static constexpr bool has_quiet_NaN = true;
-  static constexpr bool has_signaling_NaN = true;
-  static constexpr auto has_denorm = numeric_limits<float>::has_denorm;
-  static constexpr auto has_denorm_loss =
-      numeric_limits<float>::has_denorm_loss;
-  static constexpr auto round_style = numeric_limits<float>::round_style;
-  static constexpr bool is_iec559 = true;
-  static constexpr bool is_bounded = true;
-  static constexpr bool is_modulo = false;
-  static constexpr int digits = 11;
-  static constexpr int digits10 = 3;
-  static constexpr int max_digits10 = 5;
-  static constexpr int radix = 2;
-  static constexpr int min_exponent = -13;
-  static constexpr int min_exponent10 = -4;
-  static constexpr int max_exponent = 16;
-  static constexpr int max_exponent10 = 4;
-  static constexpr auto traps = numeric_limits<float>::traps;
-  static constexpr auto tinyness_before =
-      numeric_limits<float>::tinyness_before;
-  static constexpr c10::Half min() {
-    return c10::Half(0x0400, c10::Half::from_bits());
-  }
-  static constexpr c10::Half lowest() {
-    return c10::Half(0xFBFF, c10::Half::from_bits());
-  }
-  static constexpr c10::Half max() {
-    return c10::Half(0x7BFF, c10::Half::from_bits());
-  }
-  static constexpr c10::Half epsilon() {
-    return c10::Half(0x1400, c10::Half::from_bits());
-  }
-  static constexpr c10::Half round_error() {
-    return c10::Half(0x3800, c10::Half::from_bits());
-  }
-  static constexpr c10::Half infinity() {
-    return c10::Half(0x7C00, c10::Half::from_bits());
-  }
-  static constexpr c10::Half quiet_NaN() {
-    return c10::Half(0x7E00, c10::Half::from_bits());
-  }
-  static constexpr c10::Half signaling_NaN() {
-    return c10::Half(0x7D00, c10::Half::from_bits());
-  }
-  static constexpr c10::Half denorm_min() {
-    return c10::Half(0x0001, c10::Half::from_bits());
-  }
-};
-
-} // namespace std
diff --git a/packages/react-native-executorch/third-party/include/torch/headeronly/util/TypeSafeSignMath.h b/packages/react-native-executorch/third-party/include/torch/headeronly/util/TypeSafeSignMath.h
deleted file mode 100644
index 37d4e838e7..0000000000
--- a/packages/react-native-executorch/third-party/include/torch/headeronly/util/TypeSafeSignMath.h
+++ /dev/null
@@ -1,141 +0,0 @@
-#pragma once
-
-#include <limits>
-#include <torch/headeronly/macros/Macros.h>
-#include <type_traits>
-
-C10_CLANG_DIAGNOSTIC_PUSH()
-#if C10_CLANG_HAS_WARNING("-Wstring-conversion")
-C10_CLANG_DIAGNOSTIC_IGNORE("-Wstring-conversion")
-#endif
-#if C10_CLANG_HAS_WARNING("-Wimplicit-int-float-conversion")
-C10_CLANG_DIAGNOSTIC_IGNORE("-Wimplicit-int-float-conversion")
-#endif
-
-namespace c10 {
-
-/// Returns false since we cannot have x < 0 if x is unsigned.
-template <typename T>
-inline constexpr bool is_negative(const T & /*x*/,
-                                  std::true_type /*is_unsigned*/) {
-  return false;
-}
-
-/// Returns true if a signed variable x < 0
-template <typename T>
-inline constexpr bool is_negative(const T &x, std::false_type /*is_unsigned*/) {
-  return x < T(0);
-}
-
-/// Returns true if x < 0
-/// NOTE: Will fail on an unsigned custom type
-///       For the most part it's possible to fix this if
-///       the custom type has a constexpr constructor.
-///       However, notably, c10::Half does not :-(
-template <typename T> inline constexpr bool is_negative(const T &x) {
-  return is_negative(x, std::is_unsigned<T>());
-}
-
-/// Returns the sign of an unsigned variable x as 0, 1
-template <typename T>
-inline constexpr int signum(const T &x, std::true_type /*is_unsigned*/) {
-  return T(0) < x;
-}
-
-/// Returns the sign of a signed variable x as -1, 0, 1
-template <typename T>
-inline constexpr int signum(const T &x, std::false_type /*is_unsigned*/) {
-  return (T(0) < x) - (x < T(0));
-}
-
-/// Returns the sign of x as -1, 0, 1
-/// NOTE: Will fail on an unsigned custom type
-///       For the most part it's possible to fix this if
-///       the custom type has a constexpr constructor.
-///       However, notably, c10::Half does not :-(
-template <typename T> inline constexpr int signum(const T &x) {
-  return signum(x, std::is_unsigned<T>());
-}
-
-/// Returns true if a and b are not both negative
-template <typename T, typename U>
-inline constexpr bool signs_differ(const T &a, const U &b) {
-  return is_negative(a) != is_negative(b);
-}
-
-// Suppress sign compare warning when compiling with GCC
-// as later does not account for short-circuit rule before
-// raising the warning, see https://godbolt.org/z/Tr3Msnz99
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wsign-compare"
-#endif
-
-/// Returns true if x is greater than the greatest value of the type Limit
-template <typename Limit, typename T>
-inline constexpr bool greater_than_max(const T &x) {
-  constexpr bool can_overflow =
-      std::numeric_limits<T>::digits > std::numeric_limits<Limit>::digits;
-  return can_overflow && x > std::numeric_limits<Limit>::max();
-}
-
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-
-/// Returns true if x < lowest(Limit). Standard comparison
-template <typename Limit, typename T>
-inline constexpr bool less_than_lowest(const T &x,
-                                       std::false_type /*limit_is_unsigned*/,
-                                       std::false_type /*x_is_unsigned*/) {
-  return x < std::numeric_limits<Limit>::lowest();
-}
-
-/// Returns false since all the limit is signed and therefore includes
-/// negative values but x cannot be negative because it is unsigned
-template <typename Limit, typename T>
-inline constexpr bool less_than_lowest(const T & /*x*/,
-                                       std::false_type /*limit_is_unsigned*/,
-                                       std::true_type /*x_is_unsigned*/) {
-  return false;
-}
-
-/// Returns true if x < 0, where 0 is constructed from T.
-/// Limit is not signed, so its lower value is zero
-template <typename Limit, typename T>
-inline constexpr bool less_than_lowest(const T &x,
-                                       std::true_type /*limit_is_unsigned*/,
-                                       std::false_type /*x_is_unsigned*/) {
-  return x < T(0);
-}
-
-/// Returns false sign both types are unsigned
-template <typename Limit, typename T>
-inline constexpr bool less_than_lowest(const T & /*x*/,
-                                       std::true_type /*limit_is_unsigned*/,
-                                       std::true_type /*x_is_unsigned*/) {
-  return false;
-}
-
-/// Returns true if x is less than the lowest value of type T
-/// NOTE: Will fail on an unsigned custom type
-///       For the most part it's possible to fix this if
-///       the custom type has a constexpr constructor.
-///       However, notably, c10::Half does not :
-template <typename Limit, typename T>
-inline constexpr bool less_than_lowest(const T &x) {
-  return less_than_lowest<Limit>(x, std::is_unsigned<Limit>(),
-                                 std::is_unsigned<T>());
-}
-
-} // namespace c10
-
-C10_CLANG_DIAGNOSTIC_POP()
-
-HIDDEN_NAMESPACE_BEGIN(torch, headeronly)
-using c10::greater_than_max;
-using c10::is_negative;
-using c10::less_than_lowest;
-using c10::signs_differ;
-using c10::signum;
-HIDDEN_NAMESPACE_END(torch, headeronly)
diff --git a/packages/react-native-executorch/third-party/include/torch/headeronly/util/bit_cast.h b/packages/react-native-executorch/third-party/include/torch/headeronly/util/bit_cast.h
deleted file mode 100644
index 8e77c6cf71..0000000000
--- a/packages/react-native-executorch/third-party/include/torch/headeronly/util/bit_cast.h
+++ /dev/null
@@ -1,49 +0,0 @@
-#pragma once
-
-#include <cstring>
-#include <type_traits>
-
-#include <torch/headeronly/macros/Macros.h>
-
-#if __has_include(<bit>) && (defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L)
-#include <bit>
-#define C10_HAVE_STD_BIT_CAST 1
-#else
-#define C10_HAVE_STD_BIT_CAST 0
-#endif // __has_include(<bit>) && (__cplusplus >= 202002L ||
-       // (defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L))
-
-HIDDEN_NAMESPACE_BEGIN(torch, headeronly)
-
-#if C10_HAVE_STD_BIT_CAST
-using std::bit_cast;
-#else
-// Implementations of std::bit_cast() from C++ 20.
-//
-// This is a less sketchy version of reinterpret_cast.
-//
-// See https://en.cppreference.com/w/cpp/numeric/bit_cast for more
-// information as well as the source of our implementations.
-template <class To, class From>
-C10_HOST_DEVICE std::enable_if_t<sizeof(To) == sizeof(From) &&
-                                     std::is_trivially_copyable_v<From> &&
-                                     std::is_trivially_copyable_v<To>,
-                                 To>
-// constexpr support needs compiler magic
-bit_cast(const From &src) noexcept {
-  static_assert(std::is_trivially_constructible_v<To>,
-                "This implementation additionally requires "
-                "destination type to be trivially constructible");
-
-  To dst;
-  std::memcpy(&dst, &src, sizeof(To));
-  return dst;
-}
-#endif // C10_HAVE_STD_BIT_CAST
-#undef C10_HAVE_STD_BIT_CAST
-
-HIDDEN_NAMESPACE_END(torch, headeronly)
-
-namespace c10 {
-using torch::headeronly::bit_cast;
-} // namespace c10
diff --git a/packages/react-native-executorch/third-party/include/torch/headeronly/util/complex.h b/packages/react-native-executorch/third-party/include/torch/headeronly/util/complex.h
deleted file mode 100644
index 8fdb3f958d..0000000000
--- a/packages/react-native-executorch/third-party/include/torch/headeronly/util/complex.h
+++ /dev/null
@@ -1,593 +0,0 @@
-#pragma once
-
-#include <complex>
-
-#include <torch/headeronly/macros/Macros.h>
-#include <torch/headeronly/util/Half.h>
-
-#if defined(__CUDACC__) || defined(__HIPCC__)
-#include <thrust/complex.h>
-#endif
-
-C10_CLANG_DIAGNOSTIC_PUSH()
-#if C10_CLANG_HAS_WARNING("-Wimplicit-float-conversion")
-C10_CLANG_DIAGNOSTIC_IGNORE("-Wimplicit-float-conversion")
-#endif
-#if C10_CLANG_HAS_WARNING("-Wfloat-conversion")
-C10_CLANG_DIAGNOSTIC_IGNORE("-Wfloat-conversion")
-#endif
-
-namespace c10 {
-
-// c10::complex is an implementation of complex numbers that aims
-// to work on all devices supported by PyTorch
-//
-// Most of the APIs duplicates std::complex
-// Reference: https://en.cppreference.com/w/cpp/numeric/complex
-//
-// [NOTE: Complex Operator Unification]
-// Operators currently use a mix of std::complex, thrust::complex, and
-// c10::complex internally. The end state is that all operators will use
-// c10::complex internally.  Until then, there may be some hacks to support all
-// variants.
-//
-//
-// [Note on Constructors]
-//
-// The APIs of constructors are mostly copied from C++ standard:
-//   https://en.cppreference.com/w/cpp/numeric/complex/complex
-//
-// Since C++14, all constructors are constexpr in std::complex
-//
-// There are three types of constructors:
-// - initializing from real and imag:
-//     `constexpr complex( const T& re = T(), const T& im = T() );`
-// - implicitly-declared copy constructor
-// - converting constructors
-//
-// Converting constructors:
-// - std::complex defines converting constructor between float/double/long
-// double,
-//   while we define converting constructor between float/double.
-// - For these converting constructors, upcasting is implicit, downcasting is
-//   explicit.
-// - We also define explicit casting from std::complex/thrust::complex
-//   - Note that the conversion from thrust is not constexpr, because
-//     thrust does not define them as constexpr ????
-//
-//
-// [Operator =]
-//
-// The APIs of operator = are mostly copied from C++ standard:
-//   https://en.cppreference.com/w/cpp/numeric/complex/operator%3D
-//
-// Since C++20, all operator= are constexpr. Although we are not building with
-// C++20, we also obey this behavior.
-//
-// There are three types of assign operator:
-// - Assign a real value from the same scalar type
-//   - In std, this is templated as complex& operator=(const T& x)
-//     with specialization `complex& operator=(T x)` for float/double/long
-//     double Since we only support float and double, on will use `complex&
-//     operator=(T x)`
-// - Copy assignment operator and converting assignment operator
-//   - There is no specialization of converting assignment operators, which type
-//   is
-//     convertible is solely dependent on whether the scalar type is convertible
-//
-// In addition to the standard assignment, we also provide assignment operators
-// with std and thrust
-//
-//
-// [Casting operators]
-//
-// std::complex does not have casting operators. We define casting operators
-// casting to std::complex and thrust::complex
-//
-//
-// [Operator ""]
-//
-// std::complex has custom literals `i`, `if` and `il` defined in namespace
-// `std::literals::complex_literals`. We define our own custom literals in the
-// namespace `c10::complex_literals`. Our custom literals does not follow the
-// same behavior as in std::complex, instead, we define _if, _id to construct
-// float/double complex literals.
-//
-//
-// [real() and imag()]
-//
-// In C++20, there are two overload of these functions, one it to return the
-// real/imag, another is to set real/imag, they are both constexpr. We follow
-// this design.
-//
-//
-// [Operator +=,-=,*=,/=]
-//
-// Since C++20, these operators become constexpr. In our implementation, they
-// are also constexpr.
-//
-// There are two types of such operators: operating with a real number, or
-// operating with another complex number. For the operating with a real number,
-// the generic template form has argument type `const T &`, while the overload
-// for float/double/long double has `T`. We will follow the same type as
-// float/double/long double in std.
-//
-// [Unary operator +-]
-//
-// Since C++20, they are constexpr. We also make them expr
-//
-// [Binary operators +-*/]
-//
-// Each operator has three versions (taking + as example):
-// - complex + complex
-// - complex + real
-// - real + complex
-//
-// [Operator ==, !=]
-//
-// Each operator has three versions (taking == as example):
-// - complex == complex
-// - complex == real
-// - real == complex
-//
-// Some of them are removed on C++20, but we decide to keep them
-//
-// [Operator <<, >>]
-//
-// These are implemented by casting to std::complex
-//
-//
-//
-// TODO(@zasdfgbnm): c10::complex<c10::Half> is not currently supported,
-// because:
-//  - lots of members and functions of c10::Half are not constexpr
-//  - thrust::complex only support float and double
-
-template <typename T> struct alignas(sizeof(T) * 2) complex {
-  using value_type = T;
-
-  T real_ = T(0);
-  T imag_ = T(0);
-
-  constexpr complex() = default;
-  C10_HOST_DEVICE constexpr complex(const T &re, const T &im = T())
-      : real_(re), imag_(im) {}
-  template <typename U>
-  explicit constexpr complex(const std::complex<U> &other)
-      : complex(other.real(), other.imag()) {}
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  template <typename U>
-  explicit C10_HOST_DEVICE complex(const thrust::complex<U> &other)
-      : real_(other.real()), imag_(other.imag()) {}
-// NOTE can not be implemented as follow due to ROCm bug:
-//   explicit C10_HOST_DEVICE complex(const thrust::complex<U> &other):
-//   complex(other.real(), other.imag()) {}
-#endif
-
-  // Use SFINAE to specialize casting constructor for c10::complex<float> and
-  // c10::complex<double>
-  template <typename U = T>
-  C10_HOST_DEVICE explicit constexpr complex(
-      const std::enable_if_t<std::is_same_v<U, float>, complex<double>> &other)
-      : real_(other.real_), imag_(other.imag_) {}
-  template <typename U = T>
-  C10_HOST_DEVICE constexpr complex(
-      const std::enable_if_t<std::is_same_v<U, double>, complex<float>> &other)
-      : real_(other.real_), imag_(other.imag_) {}
-
-  constexpr complex<T> &operator=(T re) {
-    real_ = re;
-    imag_ = 0;
-    return *this;
-  }
-
-  constexpr complex<T> &operator+=(T re) {
-    real_ += re;
-    return *this;
-  }
-
-  constexpr complex<T> &operator-=(T re) {
-    real_ -= re;
-    return *this;
-  }
-
-  constexpr complex<T> &operator*=(T re) {
-    real_ *= re;
-    imag_ *= re;
-    return *this;
-  }
-
-  constexpr complex<T> &operator/=(T re) {
-    real_ /= re;
-    imag_ /= re;
-    return *this;
-  }
-
-  template <typename U> constexpr complex<T> &operator=(const complex<U> &rhs) {
-    real_ = rhs.real();
-    imag_ = rhs.imag();
-    return *this;
-  }
-
-  template <typename U>
-  constexpr complex<T> &operator+=(const complex<U> &rhs) {
-    real_ += rhs.real();
-    imag_ += rhs.imag();
-    return *this;
-  }
-
-  template <typename U>
-  constexpr complex<T> &operator-=(const complex<U> &rhs) {
-    real_ -= rhs.real();
-    imag_ -= rhs.imag();
-    return *this;
-  }
-
-  template <typename U>
-  constexpr complex<T> &operator*=(const complex<U> &rhs) {
-    // (a + bi) * (c + di) = (a*c - b*d) + (a * d + b * c) i
-    T a = real_;
-    T b = imag_;
-    U c = rhs.real();
-    U d = rhs.imag();
-    real_ = a * c - b * d;
-    imag_ = a * d + b * c;
-    return *this;
-  }
-
-#ifdef __APPLE__
-#define FORCE_INLINE_APPLE __attribute__((always_inline))
-#else
-#define FORCE_INLINE_APPLE
-#endif
-  template <typename U>
-  constexpr FORCE_INLINE_APPLE complex<T> &
-  operator/=(const complex<U> &rhs) __ubsan_ignore_float_divide_by_zero__ {
-    // (a + bi) / (c + di) = (ac + bd)/(c^2 + d^2) + (bc - ad)/(c^2 + d^2) i
-    // the calculation below follows numpy's complex division
-    T a = real_;
-    T b = imag_;
-    U c = rhs.real();
-    U d = rhs.imag();
-
-#if defined(__GNUC__) && !defined(__clang__)
-    // std::abs is already constexpr by gcc
-    auto abs_c = std::abs(c);
-    auto abs_d = std::abs(d);
-#else
-    auto abs_c = c < 0 ? -c : c;
-    auto abs_d = d < 0 ? -d : d;
-#endif
-
-    if (abs_c >= abs_d) {
-      if (abs_c == U(0) && abs_d == U(0)) {
-        /* divide by zeros should yield a complex inf or nan */
-        real_ = a / abs_c;
-        imag_ = b / abs_d;
-      } else {
-        auto rat = d / c;
-        auto scl = U(1.0) / (c + d * rat);
-        real_ = (a + b * rat) * scl;
-        imag_ = (b - a * rat) * scl;
-      }
-    } else {
-      auto rat = c / d;
-      auto scl = U(1.0) / (d + c * rat);
-      real_ = (a * rat + b) * scl;
-      imag_ = (b * rat - a) * scl;
-    }
-    return *this;
-  }
-#undef FORCE_INLINE_APPLE
-
-  template <typename U>
-  constexpr complex<T> &operator=(const std::complex<U> &rhs) {
-    real_ = rhs.real();
-    imag_ = rhs.imag();
-    return *this;
-  }
-
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  template <typename U>
-  C10_HOST_DEVICE complex<T> &operator=(const thrust::complex<U> &rhs) {
-    real_ = rhs.real();
-    imag_ = rhs.imag();
-    return *this;
-  }
-#endif
-
-  template <typename U> explicit constexpr operator std::complex<U>() const {
-    return std::complex<U>(std::complex<T>(real(), imag()));
-  }
-
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  template <typename U>
-  C10_HOST_DEVICE explicit operator thrust::complex<U>() const {
-    return static_cast<thrust::complex<U>>(thrust::complex<T>(real(), imag()));
-  }
-#endif
-
-  // consistent with NumPy behavior
-  explicit constexpr operator bool() const { return real() || imag(); }
-
-  C10_HOST_DEVICE constexpr T real() const { return real_; }
-  constexpr void real(T value) { real_ = value; }
-  C10_HOST_DEVICE constexpr T imag() const { return imag_; }
-  constexpr void imag(T value) { imag_ = value; }
-};
-
-namespace complex_literals {
-
-constexpr complex<float> operator""_if(long double imag) {
-  return complex<float>(0.0f, static_cast<float>(imag));
-}
-
-constexpr complex<double> operator""_id(long double imag) {
-  return complex<double>(0.0, static_cast<double>(imag));
-}
-
-constexpr complex<float> operator""_if(unsigned long long imag) {
-  return complex<float>(0.0f, static_cast<float>(imag));
-}
-
-constexpr complex<double> operator""_id(unsigned long long imag) {
-  return complex<double>(0.0, static_cast<double>(imag));
-}
-
-} // namespace complex_literals
-
-template <typename T> constexpr complex<T> operator+(const complex<T> &val) {
-  return val;
-}
-
-template <typename T> constexpr complex<T> operator-(const complex<T> &val) {
-  return complex<T>(-val.real(), -val.imag());
-}
-
-template <typename T>
-constexpr complex<T> operator+(const complex<T> &lhs, const complex<T> &rhs) {
-  complex<T> result = lhs;
-  return result += rhs;
-}
-
-template <typename T>
-constexpr complex<T> operator+(const complex<T> &lhs, const T &rhs) {
-  complex<T> result = lhs;
-  return result += rhs;
-}
-
-template <typename T>
-constexpr complex<T> operator+(const T &lhs, const complex<T> &rhs) {
-  return complex<T>(lhs + rhs.real(), rhs.imag());
-}
-
-template <typename T>
-constexpr complex<T> operator-(const complex<T> &lhs, const complex<T> &rhs) {
-  complex<T> result = lhs;
-  return result -= rhs;
-}
-
-template <typename T>
-constexpr complex<T> operator-(const complex<T> &lhs, const T &rhs) {
-  complex<T> result = lhs;
-  return result -= rhs;
-}
-
-template <typename T>
-constexpr complex<T> operator-(const T &lhs, const complex<T> &rhs) {
-  complex<T> result = -rhs;
-  return result += lhs;
-}
-
-template <typename T>
-constexpr complex<T> operator*(const complex<T> &lhs, const complex<T> &rhs) {
-  complex<T> result = lhs;
-  return result *= rhs;
-}
-
-template <typename T>
-constexpr complex<T> operator*(const complex<T> &lhs, const T &rhs) {
-  complex<T> result = lhs;
-  return result *= rhs;
-}
-
-template <typename T>
-constexpr complex<T> operator*(const T &lhs, const complex<T> &rhs) {
-  complex<T> result = rhs;
-  return result *= lhs;
-}
-
-template <typename T>
-constexpr complex<T> operator/(const complex<T> &lhs, const complex<T> &rhs) {
-  complex<T> result = lhs;
-  return result /= rhs;
-}
-
-template <typename T>
-constexpr complex<T> operator/(const complex<T> &lhs, const T &rhs) {
-  complex<T> result = lhs;
-  return result /= rhs;
-}
-
-template <typename T>
-constexpr complex<T> operator/(const T &lhs, const complex<T> &rhs) {
-  complex<T> result(lhs, T());
-  return result /= rhs;
-}
-
-// Define operators between integral scalars and c10::complex. std::complex does
-// not support this when T is a floating-point number. This is useful because it
-// saves a lot of "static_cast" when operate a complex and an integer. This
-// makes the code both less verbose and potentially more efficient.
-#define COMPLEX_INTEGER_OP_TEMPLATE_CONDITION                                  \
-  typename std::enable_if_t<                                                   \
-      std::is_floating_point_v<fT> && std::is_integral_v<iT>, int> = 0
-
-template <typename fT, typename iT, COMPLEX_INTEGER_OP_TEMPLATE_CONDITION>
-constexpr c10::complex<fT> operator+(const c10::complex<fT> &a, const iT &b) {
-  return a + static_cast<fT>(b);
-}
-
-template <typename fT, typename iT, COMPLEX_INTEGER_OP_TEMPLATE_CONDITION>
-constexpr c10::complex<fT> operator+(const iT &a, const c10::complex<fT> &b) {
-  return static_cast<fT>(a) + b;
-}
-
-template <typename fT, typename iT, COMPLEX_INTEGER_OP_TEMPLATE_CONDITION>
-constexpr c10::complex<fT> operator-(const c10::complex<fT> &a, const iT &b) {
-  return a - static_cast<fT>(b);
-}
-
-template <typename fT, typename iT, COMPLEX_INTEGER_OP_TEMPLATE_CONDITION>
-constexpr c10::complex<fT> operator-(const iT &a, const c10::complex<fT> &b) {
-  return static_cast<fT>(a) - b;
-}
-
-template <typename fT, typename iT, COMPLEX_INTEGER_OP_TEMPLATE_CONDITION>
-constexpr c10::complex<fT> operator*(const c10::complex<fT> &a, const iT &b) {
-  return a * static_cast<fT>(b);
-}
-
-template <typename fT, typename iT, COMPLEX_INTEGER_OP_TEMPLATE_CONDITION>
-constexpr c10::complex<fT> operator*(const iT &a, const c10::complex<fT> &b) {
-  return static_cast<fT>(a) * b;
-}
-
-template <typename fT, typename iT, COMPLEX_INTEGER_OP_TEMPLATE_CONDITION>
-constexpr c10::complex<fT> operator/(const c10::complex<fT> &a, const iT &b) {
-  return a / static_cast<fT>(b);
-}
-
-template <typename fT, typename iT, COMPLEX_INTEGER_OP_TEMPLATE_CONDITION>
-constexpr c10::complex<fT> operator/(const iT &a, const c10::complex<fT> &b) {
-  return static_cast<fT>(a) / b;
-}
-
-#undef COMPLEX_INTEGER_OP_TEMPLATE_CONDITION
-
-template <typename T>
-constexpr bool operator==(const complex<T> &lhs, const complex<T> &rhs) {
-  return (lhs.real() == rhs.real()) && (lhs.imag() == rhs.imag());
-}
-
-template <typename T>
-constexpr bool operator==(const complex<T> &lhs, const T &rhs) {
-  return (lhs.real() == rhs) && (lhs.imag() == T());
-}
-
-template <typename T>
-constexpr bool operator==(const T &lhs, const complex<T> &rhs) {
-  return (lhs == rhs.real()) && (T() == rhs.imag());
-}
-
-template <typename T>
-constexpr bool operator!=(const complex<T> &lhs, const complex<T> &rhs) {
-  return !(lhs == rhs);
-}
-
-template <typename T>
-constexpr bool operator!=(const complex<T> &lhs, const T &rhs) {
-  return !(lhs == rhs);
-}
-
-template <typename T>
-constexpr bool operator!=(const T &lhs, const complex<T> &rhs) {
-  return !(lhs == rhs);
-}
-
-template <typename T, typename CharT, typename Traits>
-std::basic_ostream<CharT, Traits> &
-operator<<(std::basic_ostream<CharT, Traits> &os, const complex<T> &x) {
-  return (os << static_cast<std::complex<T>>(x));
-}
-
-template <typename T, typename CharT, typename Traits>
-std::basic_istream<CharT, Traits> &
-operator>>(std::basic_istream<CharT, Traits> &is, complex<T> &x) {
-  std::complex<T> tmp;
-  is >> tmp;
-  x = tmp;
-  return is;
-}
-
-template <typename T>
-C10_HOST_DEVICE complex<T> polar(const T &r, const T &theta = T()) {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<complex<T>>(thrust::polar(r, theta));
-#else
-  // std::polar() requires r >= 0, so spell out the explicit implementation to
-  // avoid a branch.
-  return complex<T>(r * std::cos(theta), r * std::sin(theta));
-#endif
-}
-
-template <> struct alignas(4) complex<Half> {
-  Half real_;
-  Half imag_;
-
-  // Constructors
-  complex() = default;
-  // Half constructor is not constexpr so the following constructor can't
-  // be constexpr
-  C10_HOST_DEVICE explicit inline complex(const Half &real, const Half &imag)
-      : real_(real), imag_(imag) {}
-  C10_HOST_DEVICE inline complex(const c10::complex<float> &value)
-      : real_(value.real()), imag_(value.imag()) {}
-
-  // Conversion operator
-  inline C10_HOST_DEVICE operator c10::complex<float>() const {
-    return {real_, imag_};
-  }
-
-  constexpr C10_HOST_DEVICE Half real() const { return real_; }
-  constexpr C10_HOST_DEVICE Half imag() const { return imag_; }
-
-  C10_HOST_DEVICE complex<Half> &operator+=(const complex<Half> &other) {
-    real_ = static_cast<float>(real_) + static_cast<float>(other.real_);
-    imag_ = static_cast<float>(imag_) + static_cast<float>(other.imag_);
-    return *this;
-  }
-
-  C10_HOST_DEVICE complex<Half> &operator-=(const complex<Half> &other) {
-    real_ = static_cast<float>(real_) - static_cast<float>(other.real_);
-    imag_ = static_cast<float>(imag_) - static_cast<float>(other.imag_);
-    return *this;
-  }
-
-  C10_HOST_DEVICE complex<Half> &operator*=(const complex<Half> &other) {
-    auto a = static_cast<float>(real_);
-    auto b = static_cast<float>(imag_);
-    auto c = static_cast<float>(other.real());
-    auto d = static_cast<float>(other.imag());
-    real_ = a * c - b * d;
-    imag_ = a * d + b * c;
-    return *this;
-  }
-};
-
-} // namespace c10
-
-HIDDEN_NAMESPACE_BEGIN(torch, headeronly)
-using c10::complex;
-using c10::operator+;
-using c10::operator-;
-using c10::operator*;
-using c10::operator/;
-using c10::operator+=;
-using c10::operator-=;
-using c10::operator*=;
-using c10::operator/=;
-using c10::operator==;
-using c10::operator!=;
-using c10::operator<<;
-using c10::operator>>;
-using c10::polar;
-
-namespace complex_literals {
-using c10::complex_literals::operator""_if;
-using c10::complex_literals::operator""_id;
-} // namespace complex_literals
-
-HIDDEN_NAMESPACE_END(torch, headeronly)
-
-C10_CLANG_DIAGNOSTIC_POP()
diff --git a/packages/react-native-executorch/third-party/include/torch/headeronly/util/floating_point_utils.h b/packages/react-native-executorch/third-party/include/torch/headeronly/util/floating_point_utils.h
deleted file mode 100644
index 1a9731dbe2..0000000000
--- a/packages/react-native-executorch/third-party/include/torch/headeronly/util/floating_point_utils.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <torch/headeronly/macros/Macros.h>
-#include <torch/headeronly/util/bit_cast.h>
-
-HIDDEN_NAMESPACE_BEGIN(torch, headeronly, detail)
-
-C10_HOST_DEVICE inline float fp32_from_bits(uint32_t w) {
-#if defined(__OPENCL_VERSION__)
-  return as_float(w);
-#elif defined(__CUDA_ARCH__) || defined(__HIP_DEVICE_COMPILE__)
-  return __uint_as_float((unsigned int)w);
-#elif defined(__INTEL_COMPILER)
-  return _castu32_f32(w);
-#else
-  return torch::headeronly::bit_cast<float>(w);
-#endif
-}
-
-C10_HOST_DEVICE inline uint32_t fp32_to_bits(float f) {
-#if defined(__OPENCL_VERSION__)
-  return as_uint(f);
-#elif defined(__CUDA_ARCH__) || defined(__HIP_DEVICE_COMPILE__)
-  return (uint32_t)__float_as_uint(f);
-#elif defined(__INTEL_COMPILER)
-  return _castf32_u32(f);
-#else
-  return torch::headeronly::bit_cast<uint32_t>(f);
-#endif
-}
-
-HIDDEN_NAMESPACE_END(torch, headeronly, detail)
-
-namespace c10::detail {
-using torch::headeronly::detail::fp32_from_bits;
-using torch::headeronly::detail::fp32_to_bits;
-} // namespace c10::detail
diff --git a/packages/react-native-executorch/third-party/ios/ExecutorchLib.xcframework/Info.plist b/packages/react-native-executorch/third-party/ios/ExecutorchLib.xcframework/Info.plist
deleted file mode 100644
index aaba93b395..0000000000
--- a/packages/react-native-executorch/third-party/ios/ExecutorchLib.xcframework/Info.plist
+++ /dev/null
@@ -1,43 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>AvailableLibraries</key>
-	<array>
-		<dict>
-			<key>BinaryPath</key>
-			<string>ExecutorchLib.framework/ExecutorchLib</string>
-			<key>LibraryIdentifier</key>
-			<string>ios-arm64-simulator</string>
-			<key>LibraryPath</key>
-			<string>ExecutorchLib.framework</string>
-			<key>SupportedArchitectures</key>
-			<array>
-				<string>arm64</string>
-			</array>
-			<key>SupportedPlatform</key>
-			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
-		</dict>
-		<dict>
-			<key>BinaryPath</key>
-			<string>ExecutorchLib.framework/ExecutorchLib</string>
-			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
-			<key>LibraryPath</key>
-			<string>ExecutorchLib.framework</string>
-			<key>SupportedArchitectures</key>
-			<array>
-				<string>arm64</string>
-			</array>
-			<key>SupportedPlatform</key>
-			<string>ios</string>
-		</dict>
-	</array>
-	<key>CFBundlePackageType</key>
-	<string>XFWK</string>
-	<key>XCFrameworkFormatVersion</key>
-	<string>1.0</string>
-</dict>
-</plist>
diff --git a/packages/react-native-executorch/third-party/ios/ExecutorchLib.xcframework/ios-arm64-simulator/ExecutorchLib.framework/ExecutorchLib b/packages/react-native-executorch/third-party/ios/ExecutorchLib.xcframework/ios-arm64-simulator/ExecutorchLib.framework/ExecutorchLib
deleted file mode 100755
index d081c6501b..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/ExecutorchLib.xcframework/ios-arm64-simulator/ExecutorchLib.framework/ExecutorchLib and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/ExecutorchLib.xcframework/ios-arm64-simulator/ExecutorchLib.framework/Info.plist b/packages/react-native-executorch/third-party/ios/ExecutorchLib.xcframework/ios-arm64-simulator/ExecutorchLib.framework/Info.plist
deleted file mode 100644
index 4b7da1be30..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/ExecutorchLib.xcframework/ios-arm64-simulator/ExecutorchLib.framework/Info.plist and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/ExecutorchLib.xcframework/ios-arm64-simulator/ExecutorchLib.framework/mlx.metallib b/packages/react-native-executorch/third-party/ios/ExecutorchLib.xcframework/ios-arm64-simulator/ExecutorchLib.framework/mlx.metallib
deleted file mode 100644
index 104cc44a31..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/ExecutorchLib.xcframework/ios-arm64-simulator/ExecutorchLib.framework/mlx.metallib and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/ExecutorchLib.xcframework/ios-arm64/ExecutorchLib.framework/ExecutorchLib b/packages/react-native-executorch/third-party/ios/ExecutorchLib.xcframework/ios-arm64/ExecutorchLib.framework/ExecutorchLib
deleted file mode 100755
index d389c9502b..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/ExecutorchLib.xcframework/ios-arm64/ExecutorchLib.framework/ExecutorchLib and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/ExecutorchLib.xcframework/ios-arm64/ExecutorchLib.framework/Info.plist b/packages/react-native-executorch/third-party/ios/ExecutorchLib.xcframework/ios-arm64/ExecutorchLib.framework/Info.plist
deleted file mode 100644
index 38f26327ea..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/ExecutorchLib.xcframework/ios-arm64/ExecutorchLib.framework/Info.plist and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/ExecutorchLib.xcframework/ios-arm64/ExecutorchLib.framework/mlx.metallib b/packages/react-native-executorch/third-party/ios/ExecutorchLib.xcframework/ios-arm64/ExecutorchLib.framework/mlx.metallib
deleted file mode 100644
index 104cc44a31..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/ExecutorchLib.xcframework/ios-arm64/ExecutorchLib.framework/mlx.metallib and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/ExecutorchLib/ExecutorchLib.xcodeproj/project.pbxproj b/packages/react-native-executorch/third-party/ios/ExecutorchLib/ExecutorchLib.xcodeproj/project.pbxproj
deleted file mode 100644
index c51f7098ea..0000000000
--- a/packages/react-native-executorch/third-party/ios/ExecutorchLib/ExecutorchLib.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,511 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 56;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		0E4A7F472D67549100D8DCBA /* Metal.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 0E4A7F442D67549100D8DCBA /* Metal.framework */; };
-		0E4A7F482D67549100D8DCBA /* MetalPerformanceShaders.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 0E4A7F452D67549100D8DCBA /* MetalPerformanceShaders.framework */; };
-		0E4A7F492D67549100D8DCBA /* MetalPerformanceShadersGraph.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 0E4A7F462D67549100D8DCBA /* MetalPerformanceShadersGraph.framework */; };
-		5576B4B92CEF970E005027B7 /* ETModel.mm in Sources */ = {isa = PBXBuildFile; fileRef = 5576B4B82CEF970C005027B7 /* ETModel.mm */; };
-		A1MLX0001RESBUILD0001 /* mlx.metallib in Resources */ = {isa = PBXBuildFile; fileRef = A1MLX0001FILEREF0001 /* mlx.metallib */; };
-		55EA2C572CB90E7D004315B3 /* Accelerate.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 55EA2C562CB90E7D004315B3 /* Accelerate.framework */; };
-		55EA2C592CB90E80004315B3 /* CoreML.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 55EA2C582CB90E80004315B3 /* CoreML.framework */; };
-		55EA2C5B2CB90E85004315B3 /* libsqlite3.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = 55EA2C5A2CB90E85004315B3 /* libsqlite3.tbd */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXFileReference section */
-		0E4A7F442D67549100D8DCBA /* Metal.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Metal.framework; path = System/Library/Frameworks/Metal.framework; sourceTree = SDKROOT; };
-		0E4A7F452D67549100D8DCBA /* MetalPerformanceShaders.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = MetalPerformanceShaders.framework; path = System/Library/Frameworks/MetalPerformanceShaders.framework; sourceTree = SDKROOT; };
-		0E4A7F462D67549100D8DCBA /* MetalPerformanceShadersGraph.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = MetalPerformanceShadersGraph.framework; path = System/Library/Frameworks/MetalPerformanceShadersGraph.framework; sourceTree = SDKROOT; };
-		5576B4B62CEF9705005027B7 /* ETModel.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ETModel.h; sourceTree = "<group>"; };
-		5576B4B82CEF970C005027B7 /* ETModel.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = ETModel.mm; sourceTree = "<group>"; };
-		A1MLX0001FILEREF0001 /* mlx.metallib */ = {isa = PBXFileReference; lastKnownFileType = archive.metal-library; path = mlx.metallib; sourceTree = "<group>"; };
-		55EA2C1C2CB90C22004315B3 /* ExecutorchLib.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = ExecutorchLib.framework; sourceTree = BUILT_PRODUCTS_DIR; };
-		55EA2C562CB90E7D004315B3 /* Accelerate.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Accelerate.framework; path = System/Library/Frameworks/Accelerate.framework; sourceTree = SDKROOT; };
-		55EA2C582CB90E80004315B3 /* CoreML.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreML.framework; path = System/Library/Frameworks/CoreML.framework; sourceTree = SDKROOT; };
-		55EA2C5A2CB90E85004315B3 /* libsqlite3.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = libsqlite3.tbd; path = usr/lib/libsqlite3.tbd; sourceTree = SDKROOT; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		55EA2C192CB90C22004315B3 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				0E4A7F472D67549100D8DCBA /* Metal.framework in Frameworks */,
-				0E4A7F482D67549100D8DCBA /* MetalPerformanceShaders.framework in Frameworks */,
-				0E4A7F492D67549100D8DCBA /* MetalPerformanceShadersGraph.framework in Frameworks */,
-				55EA2C5B2CB90E85004315B3 /* libsqlite3.tbd in Frameworks */,
-				55EA2C592CB90E80004315B3 /* CoreML.framework in Frameworks */,
-				55EA2C572CB90E7D004315B3 /* Accelerate.framework in Frameworks */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		55EA2C122CB90C22004315B3 = {
-			isa = PBXGroup;
-			children = (
-				55EA2C1E2CB90C22004315B3 /* ExecutorchLib */,
-				55EA2C1D2CB90C22004315B3 /* Products */,
-				55EA2C552CB90E7D004315B3 /* Frameworks */,
-			);
-			sourceTree = "<group>";
-		};
-		55EA2C1D2CB90C22004315B3 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				55EA2C1C2CB90C22004315B3 /* ExecutorchLib.framework */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		55EA2C1E2CB90C22004315B3 /* ExecutorchLib */ = {
-			isa = PBXGroup;
-			children = (
-				55EA2C352CB90C7A004315B3 /* Exported */,
-				A1MLX0001FILEREF0001 /* mlx.metallib */,
-			);
-			path = ExecutorchLib;
-			sourceTree = "<group>";
-		};
-		55EA2C352CB90C7A004315B3 /* Exported */ = {
-			isa = PBXGroup;
-			children = (
-				5576B4B82CEF970C005027B7 /* ETModel.mm */,
-				5576B4B62CEF9705005027B7 /* ETModel.h */,
-			);
-			path = Exported;
-			sourceTree = "<group>";
-		};
-		55EA2C552CB90E7D004315B3 /* Frameworks */ = {
-			isa = PBXGroup;
-			children = (
-				0E4A7F442D67549100D8DCBA /* Metal.framework */,
-				0E4A7F452D67549100D8DCBA /* MetalPerformanceShaders.framework */,
-				0E4A7F462D67549100D8DCBA /* MetalPerformanceShadersGraph.framework */,
-				55EA2C5A2CB90E85004315B3 /* libsqlite3.tbd */,
-				55EA2C582CB90E80004315B3 /* CoreML.framework */,
-				55EA2C562CB90E7D004315B3 /* Accelerate.framework */,
-			);
-			name = Frameworks;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXNativeTarget section */
-		55EA2C1B2CB90C22004315B3 /* ExecutorchLib */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 55EA2C232CB90C22004315B3 /* Build configuration list for PBXNativeTarget "ExecutorchLib" */;
-			buildPhases = (
-				55EA2C182CB90C22004315B3 /* Sources */,
-				55EA2C192CB90C22004315B3 /* Frameworks */,
-				55EA2C1A2CB90C22004315B3 /* Resources */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = ExecutorchLib;
-			packageProductDependencies = (
-			);
-			productName = ExecutorchLib;
-			productReference = 55EA2C1C2CB90C22004315B3 /* ExecutorchLib.framework */;
-			productType = "com.apple.product-type.framework";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		55EA2C132CB90C22004315B3 /* Project object */ = {
-			isa = PBXProject;
-			attributes = {
-				BuildIndependentTargetsInParallel = 1;
-				LastUpgradeCheck = 1540;
-				TargetAttributes = {
-					55EA2C1B2CB90C22004315B3 = {
-						CreatedOnToolsVersion = 15.4;
-					};
-				};
-			};
-			buildConfigurationList = 55EA2C162CB90C22004315B3 /* Build configuration list for PBXProject "ExecutorchLib" */;
-			compatibilityVersion = "Xcode 14.0";
-			developmentRegion = en;
-			hasScannedForEncodings = 0;
-			knownRegions = (
-				en,
-				Base,
-			);
-			mainGroup = 55EA2C122CB90C22004315B3;
-			packageReferences = (
-			);
-			productRefGroup = 55EA2C1D2CB90C22004315B3 /* Products */;
-			projectDirPath = "";
-			projectRoot = "";
-			targets = (
-				55EA2C1B2CB90C22004315B3 /* ExecutorchLib */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXResourcesBuildPhase section */
-		55EA2C1A2CB90C22004315B3 /* Resources */ = {
-			isa = PBXResourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				A1MLX0001RESBUILD0001 /* mlx.metallib in Resources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXResourcesBuildPhase section */
-
-/* Begin PBXSourcesBuildPhase section */
-		55EA2C182CB90C22004315B3 /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				5576B4B92CEF970E005027B7 /* ETModel.mm in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin XCBuildConfiguration section */
-		55EA2C212CB90C22004315B3 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
-				CLANG_ANALYZER_NONNULL = YES;
-				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
-				CLANG_CXX_LANGUAGE_STANDARD = "gnu++20";
-				CLANG_ENABLE_MODULES = YES;
-				CLANG_ENABLE_OBJC_ARC = YES;
-				CLANG_ENABLE_OBJC_WEAK = YES;
-				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
-				CLANG_WARN_BOOL_CONVERSION = YES;
-				CLANG_WARN_COMMA = YES;
-				CLANG_WARN_CONSTANT_CONVERSION = YES;
-				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
-				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
-				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
-				CLANG_WARN_EMPTY_BODY = YES;
-				CLANG_WARN_ENUM_CONVERSION = YES;
-				CLANG_WARN_INFINITE_RECURSION = YES;
-				CLANG_WARN_INT_CONVERSION = YES;
-				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
-				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
-				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
-				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
-				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
-				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
-				CLANG_WARN_STRICT_PROTOTYPES = YES;
-				CLANG_WARN_SUSPICIOUS_MOVE = YES;
-				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
-				CLANG_WARN_UNREACHABLE_CODE = YES;
-				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
-				COPY_PHASE_STRIP = NO;
-				CURRENT_PROJECT_VERSION = 1;
-				DEBUG_INFORMATION_FORMAT = dwarf;
-				ENABLE_STRICT_OBJC_MSGSEND = YES;
-				ENABLE_TESTABILITY = YES;
-				ENABLE_USER_SCRIPT_SANDBOXING = YES;
-				GCC_C_LANGUAGE_STANDARD = gnu17;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_NO_COMMON_BLOCKS = YES;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					"DEBUG=1",
-					"$(inherited)",
-				);
-				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
-				GCC_WARN_UNDECLARED_SELECTOR = YES;
-				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
-				GCC_WARN_UNUSED_FUNCTION = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				IPHONEOS_DEPLOYMENT_TARGET = 17.0;
-				LOCALIZATION_PREFERS_STRING_CATALOGS = YES;
-				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
-				MTL_FAST_MATH = YES;
-				ONLY_ACTIVE_ARCH = YES;
-				SDKROOT = iphoneos;
-				VERSIONING_SYSTEM = "apple-generic";
-				VERSION_INFO_PREFIX = "";
-			};
-			name = Debug;
-		};
-		55EA2C222CB90C22004315B3 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
-				CLANG_ANALYZER_NONNULL = YES;
-				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
-				CLANG_CXX_LANGUAGE_STANDARD = "gnu++20";
-				CLANG_ENABLE_MODULES = YES;
-				CLANG_ENABLE_OBJC_ARC = YES;
-				CLANG_ENABLE_OBJC_WEAK = YES;
-				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
-				CLANG_WARN_BOOL_CONVERSION = YES;
-				CLANG_WARN_COMMA = YES;
-				CLANG_WARN_CONSTANT_CONVERSION = YES;
-				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
-				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
-				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
-				CLANG_WARN_EMPTY_BODY = YES;
-				CLANG_WARN_ENUM_CONVERSION = YES;
-				CLANG_WARN_INFINITE_RECURSION = YES;
-				CLANG_WARN_INT_CONVERSION = YES;
-				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
-				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
-				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
-				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
-				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
-				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
-				CLANG_WARN_STRICT_PROTOTYPES = YES;
-				CLANG_WARN_SUSPICIOUS_MOVE = YES;
-				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
-				CLANG_WARN_UNREACHABLE_CODE = YES;
-				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
-				COPY_PHASE_STRIP = NO;
-				CURRENT_PROJECT_VERSION = 1;
-				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
-				ENABLE_NS_ASSERTIONS = NO;
-				ENABLE_STRICT_OBJC_MSGSEND = YES;
-				ENABLE_USER_SCRIPT_SANDBOXING = YES;
-				GCC_C_LANGUAGE_STANDARD = gnu17;
-				GCC_NO_COMMON_BLOCKS = YES;
-				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
-				GCC_WARN_UNDECLARED_SELECTOR = YES;
-				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
-				GCC_WARN_UNUSED_FUNCTION = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				IPHONEOS_DEPLOYMENT_TARGET = 17.0;
-				LOCALIZATION_PREFERS_STRING_CATALOGS = YES;
-				MTL_ENABLE_DEBUG_INFO = NO;
-				MTL_FAST_MATH = YES;
-				SDKROOT = iphoneos;
-				VALIDATE_PRODUCT = YES;
-				VERSIONING_SYSTEM = "apple-generic";
-				VERSION_INFO_PREFIX = "";
-			};
-			name = Release;
-		};
-		55EA2C242CB90C22004315B3 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALLOW_TARGET_PLATFORM_SPECIALIZATION = NO;
-				BUILD_LIBRARY_FOR_DISTRIBUTION = NO;
-				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 1;
-				DEFINES_MODULE = YES;
-				DEVELOPMENT_TEAM = B357MU264T;
-				DYLIB_COMPATIBILITY_VERSION = 1;
-				DYLIB_CURRENT_VERSION = 1;
-				DYLIB_INSTALL_NAME_BASE = "@rpath";
-				ENABLE_MODULE_VERIFIER = YES;
-				EXCLUDED_ARCHS = x86_64;
-				GENERATE_INFOPLIST_FILE = YES;
-				HEADER_SEARCH_PATHS = (
-					"$(inherited)",
-					"$(TEMP_DIR)/cmake/include",
-				);
-				INFOPLIST_KEY_NSHumanReadableCopyright = "";
-				INSTALL_PATH = "$(LOCAL_LIBRARY_DIR)/Frameworks";
-				IPHONEOS_DEPLOYMENT_TARGET = 17.0;
-				LD_RUNPATH_SEARCH_PATHS = (
-					"$(inherited)",
-					"@executable_path/Frameworks",
-					"@loader_path/Frameworks",
-				);
-				LIBRARY_SEARCH_PATHS = (
-					"$(inherited)",
-					"$(TEMP_DIR)/cmake/lib",
-				);
-				MARKETING_VERSION = 1.0;
-				MODULE_VERIFIER_SUPPORTED_LANGUAGES = "objective-c objective-c++";
-				MODULE_VERIFIER_SUPPORTED_LANGUAGE_STANDARDS = "gnu17 gnu++20";
-				"OTHER_LDFLAGS[sdk=iphoneos*]" = (
-					"$(inherited)",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libkernels_optimized_ios.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libkernels_llm_ios.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libkernels_torchao_ios.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libkernels_quantized_ios.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libbackend_xnnpack_ios.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libbackend_coreml_ios.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libbackend_mps_ios.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libbackend_mlx_ios.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libexecutorch_ios.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libexecutorch_llm_ios.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libthreadpool_ios.a",
-				);
-				"OTHER_LDFLAGS[sdk=iphonesimulator*]" = (
-					"$(inherited)",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libkernels_optimized_simulator.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libkernels_llm_simulator.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libkernels_torchao_simulator.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libkernels_quantized_simulator.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libbackend_xnnpack_simulator.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libbackend_coreml_simulator.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libbackend_mps_simulator.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libexecutorch_simulator.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libexecutorch_llm_simulator.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libthreadpool_simulator.a",
-				);
-				PRODUCT_BUNDLE_IDENTIFIER = com.swmansion.Executorch;
-				PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)";
-				SKIP_INSTALL = YES;
-				SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
-				SUPPORTS_MACCATALYST = NO;
-				SUPPORTS_MAC_DESIGNED_FOR_IPHONE_IPAD = NO;
-				SUPPORTS_XR_DESIGNED_FOR_IPHONE_IPAD = NO;
-				SWIFT_EMIT_LOC_STRINGS = YES;
-				TARGETED_DEVICE_FAMILY = "1,2";
-			};
-			name = Debug;
-		};
-		55EA2C252CB90C22004315B3 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALLOW_TARGET_PLATFORM_SPECIALIZATION = NO;
-				BUILD_LIBRARY_FOR_DISTRIBUTION = NO;
-				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 1;
-				DEFINES_MODULE = YES;
-				DEVELOPMENT_TEAM = B357MU264T;
-				DYLIB_COMPATIBILITY_VERSION = 1;
-				DYLIB_CURRENT_VERSION = 1;
-				DYLIB_INSTALL_NAME_BASE = "@rpath";
-				ENABLE_MODULE_VERIFIER = YES;
-				EXCLUDED_ARCHS = x86_64;
-				GENERATE_INFOPLIST_FILE = YES;
-				HEADER_SEARCH_PATHS = (
-					"$(inherited)",
-					"$(TEMP_DIR)/cmake/include",
-				);
-				INFOPLIST_KEY_NSHumanReadableCopyright = "";
-				INSTALL_PATH = "$(LOCAL_LIBRARY_DIR)/Frameworks";
-				IPHONEOS_DEPLOYMENT_TARGET = 17.0;
-				LD_RUNPATH_SEARCH_PATHS = (
-					"$(inherited)",
-					"@executable_path/Frameworks",
-					"@loader_path/Frameworks",
-				);
-				LIBRARY_SEARCH_PATHS = (
-					"$(inherited)",
-					"$(TEMP_DIR)/cmake/lib",
-				);
-				MARKETING_VERSION = 1.0;
-				MODULE_VERIFIER_SUPPORTED_LANGUAGES = "objective-c objective-c++";
-				MODULE_VERIFIER_SUPPORTED_LANGUAGE_STANDARDS = "gnu17 gnu++20";
-				"OTHER_LDFLAGS[sdk=iphoneos*]" = (
-					"$(inherited)",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libkernels_optimized_ios.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libkernels_llm_ios.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libkernels_torchao_ios.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libkernels_quantized_ios.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libbackend_xnnpack_ios.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libbackend_coreml_ios.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libbackend_mps_ios.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libbackend_mlx_ios.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libexecutorch_ios.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libexecutorch_llm_ios.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libthreadpool_ios.a",
-				);
-				"OTHER_LDFLAGS[sdk=iphonesimulator*]" = (
-					"$(inherited)",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libkernels_optimized_simulator.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libkernels_llm_simulator.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libkernels_torchao_simulator.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libkernels_quantized_simulator.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libbackend_xnnpack_simulator.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libbackend_coreml_simulator.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libbackend_mps_simulator.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libexecutorch_simulator.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libexecutorch_llm_simulator.a",
-					"-force_load",
-					"$(PROJECT_DIR)/../../../third-party/ios/libs/executorch/libthreadpool_simulator.a",
-				);
-				PRODUCT_BUNDLE_IDENTIFIER = com.swmansion.Executorch;
-				PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)";
-				SKIP_INSTALL = YES;
-				SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
-				SUPPORTS_MACCATALYST = NO;
-				SUPPORTS_MAC_DESIGNED_FOR_IPHONE_IPAD = NO;
-				SUPPORTS_XR_DESIGNED_FOR_IPHONE_IPAD = NO;
-				SWIFT_EMIT_LOC_STRINGS = YES;
-				TARGETED_DEVICE_FAMILY = "1,2";
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		55EA2C162CB90C22004315B3 /* Build configuration list for PBXProject "ExecutorchLib" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				55EA2C212CB90C22004315B3 /* Debug */,
-				55EA2C222CB90C22004315B3 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		55EA2C232CB90C22004315B3 /* Build configuration list for PBXNativeTarget "ExecutorchLib" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				55EA2C242CB90C22004315B3 /* Debug */,
-				55EA2C252CB90C22004315B3 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 55EA2C132CB90C22004315B3 /* Project object */;
-}
diff --git a/packages/react-native-executorch/third-party/ios/ExecutorchLib/ExecutorchLib/Exported/ETModel.h b/packages/react-native-executorch/third-party/ios/ExecutorchLib/ExecutorchLib/Exported/ETModel.h
deleted file mode 100644
index 79b547ad3d..0000000000
--- a/packages/react-native-executorch/third-party/ios/ExecutorchLib/ExecutorchLib/Exported/ETModel.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#ifndef ETModel_hpp
-#define ETModel_hpp
-
-#import <UIKit/UIKit.h>
-
-@interface ETModel : NSObject
-
-- (NSNumber *)loadModel:(NSString *)filePath;
-- (NSNumber *)loadMethod:(NSString *)methodName;
-- (NSNumber *)loadForward;
-- (NSArray *)execute:(NSString *)methodName
-              inputs:(NSArray *)inputs
-              shapes:(NSArray *)shapes
-          inputTypes:(NSArray *)inputTypes;
-- (NSArray *)forward:(NSArray *)inputs
-              shapes:(NSArray *)shapes
-          inputTypes:(NSArray *)inputTypes;
-- (NSNumber *)getNumberOfInputs;
-- (NSNumber *)getInputType:(NSNumber *)index;
-- (NSArray *)getInputShape:(NSNumber *)index;
-- (NSNumber *)getNumberOfOutputs;
-- (NSNumber *)getOutputType:(NSNumber *)index;
-- (NSArray *)getOutputShape:(NSNumber *)index;
-
-@end
-
-#endif // ETModel_hpp
diff --git a/packages/react-native-executorch/third-party/ios/ExecutorchLib/ExecutorchLib/Exported/ETModel.mm b/packages/react-native-executorch/third-party/ios/ExecutorchLib/ExecutorchLib/Exported/ETModel.mm
deleted file mode 100644
index 905bb8b7cc..0000000000
--- a/packages/react-native-executorch/third-party/ios/ExecutorchLib/ExecutorchLib/Exported/ETModel.mm
+++ /dev/null
@@ -1,54 +0,0 @@
-#import "ETModel.h"
-
-@implementation ETModel
-
-- (NSNumber *)loadModel:(NSString *)filePath {
-  return @(0);
-}
-
-- (NSNumber *)loadMethod:(NSString *)methodName {
-  return @(0);
-}
-
-- (NSNumber *)loadForward {
-  return @(0);
-}
-
-- (NSNumber *)getNumberOfInputs {
-  return @(0);
-}
-
-- (NSNumber *)getInputType:(NSNumber *)index {
-  return @(0);
-}
-
-- (NSArray *)getInputShape:(NSNumber *)index {
-  return @[];
-}
-
-- (NSNumber *)getNumberOfOutputs {
-  return @(0);
-}
-
-- (NSNumber *)getOutputType:(NSNumber *)index {
-  return @(0);
-}
-
-- (NSArray *)getOutputShape:(NSNumber *)index {
-  return @[];
-}
-
-- (NSArray *)execute:(NSString *)methodName
-              inputs:(NSArray *)inputs
-              shapes:(NSArray *)shapes
-          inputTypes:(NSArray *)inputTypes {
-  return @[];
-}
-
-- (NSArray *)forward:(NSArray *)inputs
-              shapes:(NSArray *)shapes
-          inputTypes:(NSArray *)inputTypes {
-  return @[];
-}
-
-@end
diff --git a/packages/react-native-executorch/third-party/ios/ExecutorchLib/ExecutorchLib/mlx.metallib b/packages/react-native-executorch/third-party/ios/ExecutorchLib/ExecutorchLib/mlx.metallib
deleted file mode 100644
index 104cc44a31..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/ExecutorchLib/ExecutorchLib/mlx.metallib and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/ExecutorchLib/build.sh b/packages/react-native-executorch/third-party/ios/ExecutorchLib/build.sh
deleted file mode 100755
index 0a410e237d..0000000000
--- a/packages/react-native-executorch/third-party/ios/ExecutorchLib/build.sh
+++ /dev/null
@@ -1,56 +0,0 @@
-#!/bin/bash
-
-# Builds ExecutorchLib.xcframework for iOS and iOS Simulator
-#
-# This script:
-# 1. Cleans previous builds
-# 2. Archives the framework for iOS device (arm64)
-# 3. Archives the framework for iOS Simulator (arm64)
-# 4. Combines both archives into a single .xcframework
-#
-# Output: ./output/ExecutorchLib.xcframework
-#
-# Usage: ./build.sh
-
-# --- Configuration ---
-PROJECT_NAME="ExecutorchLib" # Replace with your Xcode project name
-SCHEME_NAME="ExecutorchLib"  # Replace with your scheme name
-OUTPUT_FOLDER="output"       # Choose your desired output folder
-
-# --- Derived Variables ---
-BUILD_FOLDER="build"
-ARCHIVE_PATH_IOS="$BUILD_FOLDER/$SCHEME_NAME-iOS"
-ARCHIVE_PATH_SIMULATOR="$BUILD_FOLDER/$SCHEME_NAME-iOS_Simulator"
-FRAMEWORK_NAME="$SCHEME_NAME.framework"
-XCFRAMEWORK_NAME="$SCHEME_NAME.xcframework"
-XCFRAMEWORK_PATH="$OUTPUT_FOLDER/$XCFRAMEWORK_NAME"
-
-# --- Script ---
-rm -rf "$BUILD_FOLDER" "$OUTPUT_FOLDER"
-
-xcodebuild clean -project "$PROJECT_NAME.xcodeproj" -scheme "$SCHEME_NAME"
-
-xcodebuild archive \
-  -project "$PROJECT_NAME.xcodeproj" \
-  -scheme "$SCHEME_NAME" \
-  -configuration Release \
-  -destination "generic/platform=iOS" \
-  -archivePath "$ARCHIVE_PATH_IOS" \
-  SKIP_INSTALL=NO \
-  BUILD_LIBRARY_FOR_DISTRIBUTION=YES \
-  CODE_SIGNING_ALLOWED=NO
-
-xcodebuild archive \
-  -project "$PROJECT_NAME.xcodeproj" \
-  -scheme "$SCHEME_NAME" \
-  -configuration Release \
-  -destination "generic/platform=iOS Simulator" \
-  -archivePath "$ARCHIVE_PATH_SIMULATOR" \
-  SKIP_INSTALL=NO \
-  BUILD_LIBRARY_FOR_DISTRIBUTION=YES \
-  CODE_SIGNING_ALLOWED=NO
-
-xcodebuild -create-xcframework \
-  -framework "$ARCHIVE_PATH_IOS.xcarchive/Products/Library/Frameworks/$FRAMEWORK_NAME" \
-  -framework "$ARCHIVE_PATH_SIMULATOR.xcarchive/Products/Library/Frameworks/$FRAMEWORK_NAME" \
-  -output "$XCFRAMEWORK_PATH"
diff --git a/packages/react-native-executorch/third-party/ios/libs/cpuinfo/libcpuinfo.a b/packages/react-native-executorch/third-party/ios/libs/cpuinfo/libcpuinfo.a
deleted file mode 100644
index b5d3895694..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/cpuinfo/libcpuinfo.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/libs/executorch/libbackend_coreml_ios.a b/packages/react-native-executorch/third-party/ios/libs/executorch/libbackend_coreml_ios.a
deleted file mode 100644
index 796b9d6796..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/executorch/libbackend_coreml_ios.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/libs/executorch/libbackend_coreml_simulator.a b/packages/react-native-executorch/third-party/ios/libs/executorch/libbackend_coreml_simulator.a
deleted file mode 100644
index 8f113a2954..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/executorch/libbackend_coreml_simulator.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/libs/executorch/libbackend_mlx_ios.a b/packages/react-native-executorch/third-party/ios/libs/executorch/libbackend_mlx_ios.a
deleted file mode 100644
index 24e85578c7..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/executorch/libbackend_mlx_ios.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/libs/executorch/libbackend_mps_ios.a b/packages/react-native-executorch/third-party/ios/libs/executorch/libbackend_mps_ios.a
deleted file mode 100644
index a8bf9728a9..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/executorch/libbackend_mps_ios.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/libs/executorch/libbackend_mps_simulator.a b/packages/react-native-executorch/third-party/ios/libs/executorch/libbackend_mps_simulator.a
deleted file mode 100644
index 5cce760012..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/executorch/libbackend_mps_simulator.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/libs/executorch/libbackend_xnnpack_ios.a b/packages/react-native-executorch/third-party/ios/libs/executorch/libbackend_xnnpack_ios.a
deleted file mode 100644
index 2093739b1a..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/executorch/libbackend_xnnpack_ios.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/libs/executorch/libbackend_xnnpack_simulator.a b/packages/react-native-executorch/third-party/ios/libs/executorch/libbackend_xnnpack_simulator.a
deleted file mode 100644
index 360569eb71..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/executorch/libbackend_xnnpack_simulator.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/libs/executorch/libexecutorch_ios.a b/packages/react-native-executorch/third-party/ios/libs/executorch/libexecutorch_ios.a
deleted file mode 100644
index ebe540bbbf..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/executorch/libexecutorch_ios.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/libs/executorch/libexecutorch_llm_ios.a b/packages/react-native-executorch/third-party/ios/libs/executorch/libexecutorch_llm_ios.a
deleted file mode 100644
index a312c92a1e..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/executorch/libexecutorch_llm_ios.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/libs/executorch/libexecutorch_llm_simulator.a b/packages/react-native-executorch/third-party/ios/libs/executorch/libexecutorch_llm_simulator.a
deleted file mode 100644
index 8435e5b35a..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/executorch/libexecutorch_llm_simulator.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/libs/executorch/libexecutorch_simulator.a b/packages/react-native-executorch/third-party/ios/libs/executorch/libexecutorch_simulator.a
deleted file mode 100644
index e5a58d122d..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/executorch/libexecutorch_simulator.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/libs/executorch/libkernels_llm_ios.a b/packages/react-native-executorch/third-party/ios/libs/executorch/libkernels_llm_ios.a
deleted file mode 100644
index ce8352f8d7..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/executorch/libkernels_llm_ios.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/libs/executorch/libkernels_llm_simulator.a b/packages/react-native-executorch/third-party/ios/libs/executorch/libkernels_llm_simulator.a
deleted file mode 100644
index c8a6cd42a4..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/executorch/libkernels_llm_simulator.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/libs/executorch/libkernels_optimized_ios.a b/packages/react-native-executorch/third-party/ios/libs/executorch/libkernels_optimized_ios.a
deleted file mode 100644
index 7b530c9e28..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/executorch/libkernels_optimized_ios.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/libs/executorch/libkernels_optimized_simulator.a b/packages/react-native-executorch/third-party/ios/libs/executorch/libkernels_optimized_simulator.a
deleted file mode 100644
index 666ab17b07..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/executorch/libkernels_optimized_simulator.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/libs/executorch/libkernels_quantized_ios.a b/packages/react-native-executorch/third-party/ios/libs/executorch/libkernels_quantized_ios.a
deleted file mode 100644
index 2aa82a12d6..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/executorch/libkernels_quantized_ios.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/libs/executorch/libkernels_quantized_simulator.a b/packages/react-native-executorch/third-party/ios/libs/executorch/libkernels_quantized_simulator.a
deleted file mode 100644
index 567ca5555f..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/executorch/libkernels_quantized_simulator.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/libs/executorch/libkernels_torchao_ios.a b/packages/react-native-executorch/third-party/ios/libs/executorch/libkernels_torchao_ios.a
deleted file mode 100644
index b0d3385e72..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/executorch/libkernels_torchao_ios.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/libs/executorch/libkernels_torchao_simulator.a b/packages/react-native-executorch/third-party/ios/libs/executorch/libkernels_torchao_simulator.a
deleted file mode 100644
index 662a2ac890..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/executorch/libkernels_torchao_simulator.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/libs/executorch/libthreadpool_ios.a b/packages/react-native-executorch/third-party/ios/libs/executorch/libthreadpool_ios.a
deleted file mode 100644
index 4d59154358..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/executorch/libthreadpool_ios.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/libs/executorch/libthreadpool_simulator.a b/packages/react-native-executorch/third-party/ios/libs/executorch/libthreadpool_simulator.a
deleted file mode 100644
index 1ec1dbe74e..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/executorch/libthreadpool_simulator.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/libs/executorch/mlx.metallib b/packages/react-native-executorch/third-party/ios/libs/executorch/mlx.metallib
deleted file mode 100644
index 104cc44a31..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/executorch/mlx.metallib and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/libs/pthreadpool/physical-arm64-release/libpthreadpool.a b/packages/react-native-executorch/third-party/ios/libs/pthreadpool/physical-arm64-release/libpthreadpool.a
deleted file mode 100644
index 652afff7bf..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/pthreadpool/physical-arm64-release/libpthreadpool.a and /dev/null differ
diff --git a/packages/react-native-executorch/third-party/ios/libs/pthreadpool/simulator-arm64-debug/libpthreadpool.a b/packages/react-native-executorch/third-party/ios/libs/pthreadpool/simulator-arm64-debug/libpthreadpool.a
deleted file mode 100644
index e3c3053a15..0000000000
Binary files a/packages/react-native-executorch/third-party/ios/libs/pthreadpool/simulator-arm64-debug/libpthreadpool.a and /dev/null differ
diff --git a/packages/react-native-executorch/tsconfig.build.json b/packages/react-native-executorch/tsconfig.build.json
new file mode 100644
index 0000000000..3c0636adf2
--- /dev/null
+++ b/packages/react-native-executorch/tsconfig.build.json
@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig",
+  "exclude": ["example", "lib"]
+}
diff --git a/packages/react-native-executorch/tsconfig.doc.json b/packages/react-native-executorch/tsconfig.doc.json
deleted file mode 100644
index 6104102d09..0000000000
--- a/packages/react-native-executorch/tsconfig.doc.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "include": ["src/**/*"],
-  "compilerOptions": {
-    "noEmit": true,
-    "skipLibCheck": true,
-    "jsx": "react"
-  }
-}
diff --git a/packages/react-native-executorch/tsconfig.json b/packages/react-native-executorch/tsconfig.json
index 841c9645ac..f355221ebe 100644
--- a/packages/react-native-executorch/tsconfig.json
+++ b/packages/react-native-executorch/tsconfig.json
@@ -1,25 +1,31 @@
 {
-  "extends": "../../tsconfig.json",
   "compilerOptions": {
-    "rootDir": "src",
-    "tsBuildInfoFile": "./lib/typescript/tsconfig.tsbuildinfo",
-    "composite": true,
-    "allowJs": false,
+    "rootDir": ".",
+    "stripInternal": true,
+    "paths": {
+      "react-native-executorch": ["./src/index"]
+    },
     "allowUnreachableCode": false,
     "allowUnusedLabels": false,
+    "customConditions": ["react-native-strict-api"],
     "esModuleInterop": true,
     "forceConsistentCasingInFileNames": true,
-    "module": "esnext",
-    "moduleResolution": "node",
+    "jsx": "react-jsx",
+    "lib": ["ESNext"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "noEmit": true,
     "noFallthroughCasesInSwitch": true,
     "noImplicitReturns": true,
+    "noImplicitUseStrict": false,
     "noStrictGenericChecks": false,
+    "noUncheckedIndexedAccess": true,
     "noUnusedLocals": true,
     "noUnusedParameters": true,
-    "noUncheckedIndexedAccess": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
     "strict": true,
-    "types": ["react", "node"]
-  },
-  "include": ["src"],
-  "exclude": ["node_modules", "lib"]
+    "target": "ESNext",
+    "verbatimModuleSyntax": true
+  }
 }
diff --git a/skills/react-native-executorch/SKILL.md b/skills/react-native-executorch/SKILL.md
deleted file mode 100644
index 6771e1ad0c..0000000000
--- a/skills/react-native-executorch/SKILL.md
+++ /dev/null
@@ -1,141 +0,0 @@
----
-name: react-native-executorch
-description: Build on-device AI features in React Native and Expo apps with React Native ExecuTorch. Use when adding AI to a mobile app without cloud dependencies — chatbots and assistants, image classification, object detection, OCR, semantic or instance segmentation, style transfer, image generation, pose estimation, speech-to-text, text-to-speech, voice activity detection, semantic search with embeddings, tokenization, privacy filtering / PII redaction, or vision-language image understanding. Also use when the user mentions offline AI, on-device ML, privacy-preserving AI, reducing cloud API cost or latency, running models locally on mobile, or downloading and managing ML models. Covers initExecutorch, every public hook (useLLM, useClassification, useObjectDetection, useOCR, useVerticalOCR, useSemanticSegmentation, useInstanceSegmentation, useStyleTransfer, useTextToImage, useImageEmbeddings, usePoseEstimation, useSpeechToText, useTextToSpeech, useVAD, useTextEmbeddings, useTokenizer, usePrivacyFilter, useExecutorchModule), tool calling, structured output, VLMs, model loading via Expo or bare resource-fetcher adapters, and error handling.
----
-
-# React Native ExecuTorch
-
-Software Mansion's production patterns for on-device AI in React Native and Expo using [React Native ExecuTorch](https://github.com/software-mansion/react-native-executorch).
-
-Targets the current published API (v0.10.x). Load at most one reference file per question. For hook signatures, model constants, or config options not covered here, webfetch the matching page from [docs.swmansion.com/react-native-executorch](https://docs.swmansion.com/react-native-executorch/docs/).
-
-## Decision Tree
-
-```
-What does the feature need?
-│
-├── Generate / chat with text?
-│   └── useLLM                                          → see llm.md
-│       ├── Plain chat → standard useLLM
-│       ├── Image + text input → useLLM with a VLM model (LFM2_VL_*)
-│       ├── Tool / function calling → configure with toolsConfig
-│       └── Structured JSON output → getStructuredOutputPrompt
-│
-├── Understand or transform images?
-│   ├── What is in this image? → useClassification      → see vision.md
-│   ├── Where are the objects? → useObjectDetection     → see vision.md
-│   ├── Per-pixel class → useSemanticSegmentation       → see vision.md
-│   ├── Per-instance segmentation → useInstanceSegmentation → see vision.md
-│   ├── Human pose keypoints → usePoseEstimation        → see vision.md
-│   ├── Read text from image → useOCR / useVerticalOCR  → see vision.md
-│   ├── Apply artistic style → useStyleTransfer         → see vision.md
-│   ├── Generate image from prompt → useTextToImage     → see vision.md
-│   └── Embed image as vector → useImageEmbeddings      → see vision.md
-│
-├── Speech / audio?
-│   ├── Transcribe speech → useSpeechToText             → see speech.md
-│   ├── Synthesize speech → useTextToSpeech             → see speech.md
-│   └── Detect speech segments → useVAD                 → see speech.md
-│
-├── Text utilities?
-│   ├── Embed text as vector → useTextEmbeddings        → see vision.md
-│   ├── Count or inspect tokens → useTokenizer          → see setup.md
-│   └── Redact PII from text → usePrivacyFilter         → see setup.md
-│
-├── Full RAG pipeline (retrieval + generation + vector store)?
-│   └── react-native-rag (sibling library)              → see setup.md
-│
-└── Custom `.pte` model not covered by a dedicated hook?
-    └── useExecutorchModule                             → see setup.md
-```
-
-## Critical Rules
-
-- **Call `initExecutorch()` at app entry, before any other API.** The library does not bundle a network/file layer — you must register a resource-fetcher adapter (`ExpoResourceFetcher` for Expo, `BareResourceFetcher` for bare RN). Any hook called before initialization throws `ResourceFetcherAdapterNotInitialized`.
-
-- **Check `isReady` before calling `forward` / `generate` / `transcribe`.** All hooks load asynchronously. Inference before the model is ready throws `ModuleNotLoaded`.
-
-- **Interrupt LLM generation before unmounting.** Unmounting while `isGenerating` is `true` crashes. Call `llm.interrupt()` and wait for `isGenerating === false` before navigating away.
-
-- **Use quantized model variants on mobile.** Full-precision variants exceed device memory on most phones. Every supported model ships a `_QUANTIZED` variant — prefer it unless you've measured otherwise.
-
-- **Audio for speech-to-text and VAD must be 16 kHz mono.** Mismatched sample rates produce silently garbled transcriptions. Decode with `new AudioContext({ sampleRate: 16000 })`.
-
-- **Audio from text-to-speech is 24 kHz.** Create the playback context with `new AudioContext({ sampleRate: 24000 })`.
-
-- **The New Architecture (Fabric) is required.** Old architecture is unsupported. Expo Go is unsupported — use a custom dev build (`npx expo prebuild`). iOS release builds need a real device (the simulator lacks the Metal APIs ExecuTorch relies on).
-
-## Minimal Setup
-
-```tsx
-// App.tsx (Expo)
-import { initExecutorch } from 'react-native-executorch';
-import { ExpoResourceFetcher } from 'react-native-executorch-expo-resource-fetcher';
-
-initExecutorch({ resourceFetcher: ExpoResourceFetcher });
-```
-
-```tsx
-// App.tsx (bare React Native)
-import { initExecutorch } from 'react-native-executorch';
-import { BareResourceFetcher } from 'react-native-executorch-bare-resource-fetcher';
-
-initExecutorch({ resourceFetcher: BareResourceFetcher });
-```
-
-Full setup, Metro config for bundled `.pte` files, custom adapters, model-loading strategies, and error handling: see [setup.md](./references/setup.md).
-
-## Hook Quick Reference
-
-| Hook | Purpose | Reference |
-|---|---|---|
-| `useLLM` | Text generation, chat, tool calling, VLM | [llm.md](./references/llm.md) |
-| `useClassification` | Image categorisation | [vision.md](./references/vision.md) |
-| `useObjectDetection` | Bounding-box detection (YOLO26, RF-DETR, SSDLite) | [vision.md](./references/vision.md) |
-| `useSemanticSegmentation` | Per-pixel class segmentation | [vision.md](./references/vision.md) |
-| `useInstanceSegmentation` | Per-instance segmentation | [vision.md](./references/vision.md) |
-| `usePoseEstimation` | COCO 17-keypoint human pose | [vision.md](./references/vision.md) |
-| `useStyleTransfer` | Artistic image filters | [vision.md](./references/vision.md) |
-| `useTextToImage` | Stable Diffusion image generation | [vision.md](./references/vision.md) |
-| `useImageEmbeddings` | CLIP image embeddings | [vision.md](./references/vision.md) |
-| `useOCR` | Horizontal text OCR | [vision.md](./references/vision.md) |
-| `useVerticalOCR` | Vertical text OCR (experimental, CJK) | [vision.md](./references/vision.md) |
-| `useTextEmbeddings` | Sentence embeddings for similarity / RAG | [vision.md](./references/vision.md) |
-| `useSpeechToText` | Whisper transcription (batch + streaming) | [speech.md](./references/speech.md) |
-| `useTextToSpeech` | Kokoro TTS (batch + streaming, phoneme input) | [speech.md](./references/speech.md) |
-| `useVAD` | FSMN voice activity detection | [speech.md](./references/speech.md) |
-| `useTokenizer` | HuggingFace-compatible tokenization | [setup.md](./references/setup.md) |
-| `usePrivacyFilter` | On-device PII / privacy redaction | [setup.md](./references/setup.md) |
-| `useExecutorchModule` | Custom `.pte` model inference | [setup.md](./references/setup.md) |
-
-Every hook also has a non-React `Module` counterpart (e.g. `LLMModule.fromModelName(...)`, `ClassificationModule.fromModelName(...)`) for use outside React components.
-
-## Common Pitfalls
-
-| Symptom | Likely cause | Fix |
-|---|---|---|
-| `ResourceFetcherAdapterNotInitialized` | `initExecutorch` not called | Call it at app entry with an adapter |
-| `ModuleNotLoaded` | Inference before model finished loading | Gate calls on `isReady` |
-| `MemoryAllocationFailed` on launch | Model too large for device | Switch to `_QUANTIZED` variant or smaller parameter count |
-| App crashes on screen navigation | Unmount during active generation | `llm.interrupt()` and await `isGenerating === false` |
-| Whisper produces garbled text | Wrong sample rate | Decode audio at 16 kHz mono |
-| TTS output sounds chipmunked | Playback context at wrong rate | Create `AudioContext({ sampleRate: 24000 })` |
-| Build fails on iOS simulator (release) | Simulator lacks Metal APIs | Build release on real device |
-
-Full error code list and recovery patterns: [setup.md](./references/setup.md).
-
-## References
-
-| File | When to read |
-|---|---|
-| [llm.md](./references/llm.md) | `useLLM` functional + managed modes, tool calling, structured output (JSON Schema / Zod), interrupting, vision-language models, generation config |
-| [vision.md](./references/vision.md) | Image classification, object detection, semantic + instance segmentation, pose estimation, OCR (horizontal + vertical), style transfer, text-to-image, image + text embeddings |
-| [speech.md](./references/speech.md) | Speech-to-text (Whisper batch + streaming with timestamps), text-to-speech (Kokoro batch + streaming, phoneme input, voice catalogue), voice activity detection, audio sample-rate requirements |
-| [setup.md](./references/setup.md) | `initExecutorch`, Expo / bare resource-fetcher adapters, model loading strategies, Metro config, error codes and recovery, `useExecutorchModule` for custom `.pte` models, `useTokenizer`, `usePrivacyFilter`, full model catalogue |
-
-## External Resources
-
-- Official docs: https://docs.swmansion.com/react-native-executorch
-- API reference: https://docs.swmansion.com/react-native-executorch/docs/api-reference
-- Source: https://github.com/software-mansion/react-native-executorch
-- Pre-exported models: https://huggingface.co/software-mansion
diff --git a/skills/react-native-executorch/references/llm.md b/skills/react-native-executorch/references/llm.md
deleted file mode 100644
index a0ef1eccac..0000000000
--- a/skills/react-native-executorch/references/llm.md
+++ /dev/null
@@ -1,257 +0,0 @@
-# LLMs
-
-Run Large Language Models on-device for text generation, chat, tool / function calling, structured JSON output, and vision-language understanding.
-
-Pick models via the typed `models` registry: `models.llm.<model>({ quant?, backend? })`. Calling with no args returns the platform default (quantized variant when one is published). Passing a backend a model doesn't ship is a compile-time error. For full API surface and config options, webfetch [useLLM API reference](https://docs.swmansion.com/react-native-executorch/docs/api-reference/functions/useLLM).
-
----
-
-## Functional mode (stateless)
-
-```tsx
-import { useLLM, models, Message } from 'react-native-executorch';
-
-const llm = useLLM({ model: models.llm.lfm2_5_1_2b_instruct() });
-
-const onGenerate = async () => {
-  const chat: Message[] = [
-    { role: 'system', content: 'You are a helpful assistant' },
-    { role: 'user', content: 'What is the meaning of life?' },
-  ];
-  const response = await llm.generate(chat);
-  console.log(response);
-};
-
-return (
-  <View>
-    <Button onPress={onGenerate} title="Generate" disabled={!llm.isReady} />
-    <Text>{llm.response}</Text>
-  </View>
-);
-```
-
-Each `generate()` call is independent — the hook does not keep history.
-
----
-
-## Managed mode (stateful chat)
-
-For multi-turn chats, configure once and let the hook manage `messageHistory`:
-
-```tsx
-import { useEffect } from 'react';
-import { useLLM, models, MessageCountContextStrategy } from 'react-native-executorch';
-
-const llm = useLLM({ model: models.llm.lfm2_5_1_2b_instruct() });
-
-useEffect(() => {
-  llm.configure({
-    chatConfig: {
-      systemPrompt: 'You are a helpful assistant',
-      contextStrategy: new MessageCountContextStrategy(6), // keep last 6 messages
-    },
-    generationConfig: {
-      temperature: 0.7,
-      topp: 0.9,
-      outputTokenBatchSize: 15,
-      batchTimeInterval: 100,
-    },
-  });
-}, []);
-
-// Send messages — appended to llm.messageHistory automatically
-llm.sendMessage('Hello!');
-```
-
-Render the chat from `llm.messageHistory`. `llm.response` streams the in-progress assistant message; `llm.isGenerating` is true during generation.
-
----
-
-## Interrupting
-
-Always interrupt before unmounting — an in-flight generation will crash the app on tear-down.
-
-```tsx
-{llm.isGenerating && <Button onPress={llm.interrupt} title="Stop" />}
-
-useEffect(() => {
-  return () => {
-    if (llm.isGenerating) llm.interrupt();
-  };
-}, []);
-```
-
-If you're navigating away programmatically, await until `isGenerating` becomes `false` before unmounting.
-
----
-
-## Tool / function calling
-
-Define tools with a name, description, and JSON-schema-like parameter spec. Implement `executeToolCallback` to actually run the tool. Models with strong tool-calling support: `models.llm.hammer2_1_*`, `models.llm.qwen3_*`.
-
-```tsx
-import { useEffect } from 'react';
-import {
-  useLLM,
-  models,
-  DEFAULT_SYSTEM_PROMPT,
-  LLMTool,
-  ToolCall,
-} from 'react-native-executorch';
-
-const TOOLS: LLMTool[] = [
-  {
-    name: 'get_weather',
-    description: 'Get current weather in a given location.',
-    parameters: {
-      type: 'dict',
-      properties: {
-        location: { type: 'string', description: 'Location to check weather for' },
-      },
-      required: ['location'],
-    },
-  },
-];
-
-const executeTool = async (call: ToolCall): Promise<string | null> => {
-  switch (call.toolName) {
-    case 'get_weather':
-      return 'It is sunny and 21°C.';
-    default:
-      return null;
-  }
-};
-
-const llm = useLLM({ model: models.llm.hammer2_1_1_5b() });
-
-useEffect(() => {
-  llm.configure({
-    chatConfig: {
-      systemPrompt: `${DEFAULT_SYSTEM_PROMPT} Current time: ${new Date().toString()}`,
-    },
-    toolsConfig: {
-      tools: TOOLS,
-      executeToolCallback: executeTool,
-      displayToolCalls: true,
-    },
-  });
-}, []);
-```
-
-In functional mode, pass tools as the second argument: `llm.generate(chat, TOOLS)`.
-
----
-
-## Structured JSON output
-
-Use `getStructuredOutputPrompt` to build a system prompt from a JSON Schema or Zod schema, then validate the response with `fixAndValidateStructuredOutput`.
-
-```tsx
-import * as z from 'zod/v4';
-import {
-  useLLM,
-  models,
-  getStructuredOutputPrompt,
-  fixAndValidateStructuredOutput,
-} from 'react-native-executorch';
-
-const schema = z.object({
-  username: z.string().meta({ description: 'User asking the question' }),
-  bid: z.number().meta({ description: 'Offer in the user message' }),
-  currency: z.optional(z.string()),
-});
-
-const llm = useLLM({ model: models.llm.qwen3_4b() });
-
-useEffect(() => {
-  const instructions = getStructuredOutputPrompt(schema);
-  llm.configure({
-    chatConfig: {
-      systemPrompt:
-        `Parse the user's message and return JSON. Don't reply to the user. ${instructions} /no_think`,
-    },
-  });
-}, []);
-
-useEffect(() => {
-  const last = llm.messageHistory.at(-1);
-  if (!llm.isGenerating && last?.role === 'assistant') {
-    try {
-      const parsed = fixAndValidateStructuredOutput(last.content, schema);
-      console.log(parsed); // typed by Zod
-    } catch (e) {
-      console.warn('Output did not match schema', e);
-    }
-  }
-}, [llm.messageHistory, llm.isGenerating]);
-```
-
-`getStructuredOutputPrompt` accepts both JSON Schema (`jsonschema`) and Zod schemas.
-
----
-
-## Vision-Language Models (VLM)
-
-Some LLMs accept image + text input. They live under `models.llm` too — pick them by capability. Pass an image alongside text via `imagePath` (managed) or `mediaPath` on a `Message` (functional).
-
-```tsx
-import { useLLM, models, Message } from 'react-native-executorch';
-
-const llm = useLLM({ model: models.llm.lfm2_5_vl_1_6b() });
-
-// Managed
-llm.sendMessage('What is in this image?', { imagePath: '/path/to/image.jpg' });
-
-// Functional
-const chat: Message[] = [
-  { role: 'user', content: 'Describe this image.', mediaPath: '/path/to/image.jpg' },
-];
-await llm.generate(chat);
-```
-
-`imagePath` / `mediaPath` must be a local filesystem path. To use a remote image, download it first (e.g. via the resource-fetcher adapter — see [setup.md](./setup.md)).
-
----
-
-## Choosing options on the accessor
-
-```ts
-// Platform default (quantized when published).
-models.llm.llama3_2_3b();
-
-// Non-quantized variant.
-models.llm.llama3_2_3b({ quant: false });
-
-// Explicit backend — only the backends the model actually ships are accepted.
-models.llm.qwen3_4b({ backend: 'xnnpack' });
-```
-
----
-
-## Model selection
-
-| Device tier | Parameter range | Recommended accessors |
-|---|---|---|
-| Low-end | 135M–500M | `models.llm.smollm2_1_135m`, `models.llm.smollm2_1_360m`, `models.llm.lfm2_5_350m` |
-| Mid-range | 0.5B–1.7B | `models.llm.llama3_2_1b`, `models.llm.qwen3_0_6b`, `models.llm.smollm2_1_1_7b`, `models.llm.lfm2_5_1_2b_instruct`, `models.llm.hammer2_1_1_5b`, `models.llm.bielik_v3_0_1_5b` |
-| High-end | 1.7B–4B | `models.llm.llama3_2_3b`, `models.llm.qwen3_4b`, `models.llm.qwen3_5_2b`, `models.llm.phi_4_mini_4b`, `models.llm.hammer2_1_3b` |
-| VLM | 450M / 1.6B | `models.llm.lfm2_5_vl_450m`, `models.llm.lfm2_5_vl_1_6b` |
-
-Full per-device benchmarks: webfetch [Inference time benchmarks](https://docs.swmansion.com/react-native-executorch/docs/benchmarks/inference-time).
-
----
-
-## Troubleshooting
-
-- **Crash on unmount.** Active generation was not interrupted — call `llm.interrupt()` and wait for `isGenerating === false`.
-- **Out-of-memory at load.** Pick a smaller accessor or stay on the default (quantized) variant.
-- **Poor output quality.** Try a larger model, raise `temperature` / `topp`, or improve the system prompt. For Qwen 3 reasoning models, pass `/no_think` in the prompt to skip the thinking phase.
-- **Tool calls never fire.** Use a tool-tuned model (`models.llm.hammer2_1_*`) and ensure `executeToolCallback` is set.
-
----
-
-## See also
-
-- [useLLM API reference](https://docs.swmansion.com/react-native-executorch/docs/api-reference/functions/useLLM)
-- [LLMModule (non-hook) API](https://docs.swmansion.com/react-native-executorch/docs/typescript-api/natural-language-processing/LLMModule)
-- [LLM HuggingFace collection](https://huggingface.co/collections/software-mansion/llm)
diff --git a/skills/react-native-executorch/references/setup.md b/skills/react-native-executorch/references/setup.md
deleted file mode 100644
index 987e0a677d..0000000000
--- a/skills/react-native-executorch/references/setup.md
+++ /dev/null
@@ -1,378 +0,0 @@
-# Setup, Model Loading & Utilities
-
-Installation, initialization, model loading strategies, error handling, custom `.pte` models, tokenization, and PII redaction.
-
-For the full getting-started guide, webfetch [Getting Started](https://docs.swmansion.com/react-native-executorch/docs/fundamentals/getting-started). For version compatibility, webfetch [Compatibility](https://docs.swmansion.com/react-native-executorch/docs/other/compatibility).
-
----
-
-## Installation
-
-```bash
-npm install react-native-executorch
-
-# Expo projects
-npm install react-native-executorch-expo-resource-fetcher
-
-# Bare React Native projects
-npm install react-native-executorch-bare-resource-fetcher
-```
-
-### Prerequisites
-
-- **New Architecture (Fabric) required.** Old architecture is unsupported.
-- **Expo Go is not supported.** Use a custom dev build (`npx expo prebuild`).
-- **iOS release builds require a real device.** The simulator lacks Metal APIs ExecuTorch relies on.
-
----
-
-## Initialization
-
-Register a resource-fetcher adapter at app entry **before any other API**:
-
-```tsx
-// Expo
-import { initExecutorch } from 'react-native-executorch';
-import { ExpoResourceFetcher } from 'react-native-executorch-expo-resource-fetcher';
-
-initExecutorch({ resourceFetcher: ExpoResourceFetcher });
-```
-
-```tsx
-// Bare React Native
-import { initExecutorch } from 'react-native-executorch';
-import { BareResourceFetcher } from 'react-native-executorch-bare-resource-fetcher';
-
-initExecutorch({ resourceFetcher: BareResourceFetcher });
-```
-
-Calling any hook or module before `initExecutorch` throws `ResourceFetcherAdapterNotInitialized`.
-
-If neither adapter fits (custom CDN, private auth, custom caching), implement the `ResourceFetcherAdapter` interface yourself — webfetch [Custom Adapter](https://docs.swmansion.com/react-native-executorch/docs/resource-fetcher/custom-adapter).
-
-For teardown (e.g. in tests), call `cleanupExecutorch()`.
-
----
-
-## Metro config (bundled `.pte` models)
-
-To `require('../assets/model.pte')`, register the extensions:
-
-```js
-// metro.config.js
-const { getDefaultConfig } = require('expo/metro-config');
-
-const config = getDefaultConfig(__dirname);
-config.resolver.assetExts.push('pte');
-config.resolver.assetExts.push('bin');
-
-module.exports = config;
-```
-
----
-
-## Model loading strategies
-
-Every hook accepts a `model` prop. Pick the strategy by model size and UX requirements.
-
-```
-How large is the model?
-├── A published Software Mansion model?
-│   └── Use the `models` registry accessor (recommended)
-│       useLLM({ model: models.llm.llama3_2_1b() })
-│
-├── Small (< 512 MB) and must work offline from launch?
-│   └── Bundle as an asset
-│       useLLM({ model: { modelSource: require('../assets/model.pte'), … } })
-│
-├── Large (> 512 MB) or optional feature?
-│   └── Remote URL (downloaded + cached on first use)
-│       useLLM({ model: { modelSource: 'https://…/model.pte', … } })
-│
-└── User-managed / fine-tuned models?
-    └── Local file path
-        useLLM({ model: { modelSource: 'file:///var/mobile/…/model.pte', … } })
-```
-
-### `models` registry (recommended)
-
-`models.<category>.<model>({ quant?, backend? })` — typed accessors that resolve to the right URL and backend per platform. Default is the quantized variant when one is published; iOS prefers CoreML, Android prefers XNNPACK, for multi-backend models.
-
-```tsx
-import { useLLM, useObjectDetection, useOCR, models } from 'react-native-executorch';
-
-useLLM({ model: models.llm.llama3_2_3b() });                 // platform default, quantized
-useLLM({ model: models.llm.llama3_2_3b({ quant: false }) }); // full precision
-useObjectDetection({ model: models.object_detection.rf_detr_nano({ backend: 'xnnpack' }) });
-useOCR({ model: models.ocr.craft({ language: 'en' }) });
-```
-
-Available top-level categories: `llm`, `classification`, `object_detection`, `pose_estimation`, `semantic_segmentation`, `instance_segmentation`, `style_transfer`, `speech_to_text`, `text_to_speech`, `text_embedding`, `image_embedding`, `image_generation`, `vad`, `ocr`, `privacy_filter`. Per-category accessors are listed in [llm.md](./llm.md), [vision.md](./vision.md), [speech.md](./speech.md), and the privacy filter section below.
-
-### `preventLoad`
-
-Every hook accepts `preventLoad: true` to defer model download/load until you're ready:
-
-```tsx
-const llm = useLLM({ model: models.llm.llama3_2_1b(), preventLoad: true });
-// Flip to false (or omit) to start loading
-```
-
-### Download progress
-
-Hooks expose `downloadProgress` (0–1):
-
-```tsx
-const llm = useLLM({ model: models.llm.llama3_2_1b() });
-<Text>{Math.round(llm.downloadProgress * 100)}%</Text>
-```
-
----
-
-## Resource fetcher
-
-For advanced download management — pause, resume, cancel, list, delete — the adapters expose a Promise-based API. For the full surface, webfetch [ResourceFetcher](https://docs.swmansion.com/react-native-executorch/docs/utilities/resource-fetcher).
-
-```tsx
-import { ExpoResourceFetcher } from 'react-native-executorch-expo-resource-fetcher';
-
-// Download with progress
-const uris = await ExpoResourceFetcher.fetch(
-  (p) => console.log(`${Math.round(p * 100)}%`),
-  'https://example.com/model.pte',
-  'https://example.com/tokenizer.bin'
-);
-// uris: string[] of local file paths (no `file://` prefix), or null if interrupted
-```
-
-```ts
-await ExpoResourceFetcher.pauseFetching('https://…/model.pte');
-const uris = await ExpoResourceFetcher.resumeFetching('https://…/model.pte');
-await ExpoResourceFetcher.cancelFetching('https://…/model.pte');
-
-const files = await ExpoResourceFetcher.listDownloadedFiles();
-const models = await ExpoResourceFetcher.listDownloadedModels();
-const bytes = await ExpoResourceFetcher.getFilesTotalSize('https://…/model.pte');
-await ExpoResourceFetcher.deleteResources('https://…/model.pte');
-```
-
-`BareResourceFetcher` exposes the same API but does **not** support pause/resume on Android — use Expo's if you need it cross-platform.
-
-Downloaded files are stored in the app's documents directory.
-
----
-
-## Error handling
-
-All errors inherit from `RnExecutorchError` with a `code` from `RnExecutorchErrorCode`. For the full table, webfetch [Error Handling](https://docs.swmansion.com/react-native-executorch/docs/utilities/error-handling).
-
-| Error code | When | Recovery |
-|---|---|---|
-| `ResourceFetcherAdapterNotInitialized` | Any API used before `initExecutorch()` | Call `initExecutorch({ resourceFetcher })` at app entry |
-| `ModuleNotLoaded` | Inference before `isReady === true` | Gate on `isReady` |
-| `ModelGenerating` | New inference while one is running | Wait or call `interrupt()` |
-| `InvalidConfig` | Bad params (e.g. `topp > 1`) | Validate config |
-| `ResourceFetcherDownloadFailed` | Network error during download | Retry with backoff |
-| `MemoryAllocationFailed` | Model too large for device | Switch to a smaller / quantized accessor |
-| `DownloadInterrupted` | Download did not complete | Retry |
-| `StreamingNotStarted` | `streamInsert` before `stream()` is active | Start `stream()` first |
-| `StreamingInProgress` | `stream()` while one is active | Wait or call `streamStop()` |
-| `InvalidUserInput` | Empty / malformed input | Validate before calling |
-| `FileReadFailed` | Bad image path, unsupported format | Verify path and format |
-| `LanguageNotSupported` | OCR / multilingual model asked for an unpublished language | Use a supported code |
-
-### Pattern
-
-```tsx
-import { RnExecutorchError, RnExecutorchErrorCode } from 'react-native-executorch';
-
-try {
-  await model.forward(imageUri);
-} catch (err) {
-  if (err instanceof RnExecutorchError) {
-    switch (err.code) {
-      case RnExecutorchErrorCode.ModuleNotLoaded:
-        // Model still loading — show loading state
-        break;
-      case RnExecutorchErrorCode.ModelGenerating:
-        // Already busy — wait or interrupt
-        break;
-      case RnExecutorchErrorCode.MemoryAllocationFailed:
-        // Device can't fit the model — fall back to a smaller one
-        break;
-      default:
-        console.error('ExecuTorch error:', err.code, err.message);
-    }
-  } else {
-    throw err;
-  }
-}
-```
-
----
-
-## Custom models — `useExecutorchModule`
-
-For `.pte` models not covered by a dedicated hook, use `useExecutorchModule` to run arbitrary tensor I/O.
-
-### Exporting
-
-1. Export your PyTorch model to `.pte` using the [ExecuTorch export tutorial](https://pytorch.org/executorch/stable/tutorials/export-to-executorch-tutorial.html).
-2. Pick a backend: XNNPACK (CPU, cross-platform) or Core ML (iOS, uses ANE).
-3. Load it via asset, URL, or local path.
-
-### Running
-
-```tsx
-import { useExecutorchModule, ScalarType } from 'react-native-executorch';
-
-const m = useExecutorchModule({
-  modelSource: require('../assets/custom_model.pte'),
-});
-
-const run = async () => {
-  const input = {
-    dataPtr: new Float32Array([1.0, 2.0, 3.0]),
-    sizes: [1, 3],
-    scalarType: ScalarType.FLOAT,
-  };
-
-  const output = await m.forward([input]);
-  // output: TensorPtr[] — output[0].dataPtr is an ArrayBuffer; interpret per scalarType
-};
-```
-
-`TensorPtr`: `{ dataPtr: ArrayBuffer | TypedArray, sizes: number[], scalarType: ScalarType }`.
-
-You own preprocessing (resize, normalize, color conversion) and postprocessing. Shapes must match your exported model exactly.
-
-### Non-hook usage
-
-For services or non-React contexts, use the module class directly via `fromModelName`:
-
-```ts
-import { ClassificationModule, models } from 'react-native-executorch';
-
-const m = await ClassificationModule.fromModelName(models.classification.efficientnet_v2_s());
-```
-
-Every hook has a corresponding module: `LLMModule`, `ObjectDetectionModule`, `OCRModule`, `SpeechToTextModule`, `TextToSpeechModule`, etc.
-
----
-
-## Tokenization — `useTokenizer`
-
-HuggingFace-compatible BPE / WordPiece tokenizer. Mostly useful for counting tokens before sending text to embedding models or LLMs.
-
-```tsx
-import { useTokenizer, models } from 'react-native-executorch';
-
-const tokenizer = useTokenizer({ tokenizer: models.text_embedding.all_minilm_l6_v2() });
-
-const ids = await tokenizer.encode('Hello, world!');
-const text = await tokenizer.decode(ids);
-
-const vocab = await tokenizer.getVocabSize();
-const id = await tokenizer.tokenToId('hello');
-const token = await tokenizer.idToToken(id);
-```
-
-You usually don't need this — `useLLM` and `useTextEmbeddings` tokenize internally.
-
----
-
-## Privacy filter — `usePrivacyFilter`
-
-On-device PII detection. Returns `PiiEntity[]` with `{ label, text, startToken, endToken }`. Useful for redacting messages before they leave the device.
-
-```tsx
-import { usePrivacyFilter, models } from 'react-native-executorch';
-
-const pf = usePrivacyFilter({ model: models.privacy_filter.openai() });
-
-const entities = await pf.generate(
-  'Email me at jane@example.com — my account is 1234-5678-0001.'
-);
-// entities: [
-//   { label: 'private_email', text: 'jane@example.com', startToken: …, endToken: … },
-//   { label: 'account_number', text: '1234-5678-0001', startToken: …, endToken: … },
-// ]
-```
-
-**Available accessors:**
-
-- `models.privacy_filter.openai` — 8 entity types (account_number, private_address, private_date, private_email, private_person, private_phone, private_url, secret). Label list: `PRIVACY_FILTER_OPENAI_LABELS`.
-- `models.privacy_filter.nemotron` — 55 entity types. Label list: `PRIVACY_FILTER_NEMOTRON_LABELS`.
-
-Long inputs are processed in 50%-overlapping sliding windows automatically — no manual chunking required. The window size is set by the exported model's input shape.
-
-For a custom fine-tune, pass a `PrivacyFilterModelSources` object directly (with your own `modelSource`, `tokenizerSource`, and `labelNames`). Optional `viterbiBiases` shift the precision/recall tradeoff.
-
----
-
-## RAG with `react-native-rag`
-
-For retrieval-augmented generation — vector stores, persistence, document ingestion, and a `useRAG` hook — use the sibling library [react-native-rag](https://github.com/software-mansion-labs/react-native-rag). It plugs straight into the `models` registry through `ExecuTorchEmbeddings` and `ExecuTorchLLM` wrappers, so you keep one model-selection convention across both libraries.
-
-```bash
-npm install react-native-rag
-# Optional SQLite-backed persistence (otherwise an in-memory store is used)
-npm install @react-native-rag/op-sqlite
-```
-
-```tsx
-import { useRAG, MemoryVectorStore, ExecuTorchEmbeddings, ExecuTorchLLM } from 'react-native-rag';
-import { models } from 'react-native-executorch';
-
-const vectorStore = new MemoryVectorStore({
-  embeddings: new ExecuTorchEmbeddings(models.text_embedding.all_minilm_l6_v2()),
-});
-
-const llm = new ExecuTorchLLM(models.llm.lfm2_5_1_2b_instruct());
-
-export default function App() {
-  const rag = useRAG({ vectorStore, llm });
-
-  // rag.addDocument(text), rag.query(question) → rag.response (streamed)
-  return <Text>{rag.response}</Text>;
-}
-```
-
-**When to reach for `react-native-rag` vs. rolling your own:**
-
-- **Use the library** when you need document ingestion + chunking + retrieval + generation as one pipeline, persistent vector storage across launches, or want a hook-based API symmetric with `useLLM` / `useTextEmbeddings`.
-- **Roll your own** (just `useTextEmbeddings` + cosine similarity + `useLLM`) when the corpus is small and ephemeral, or you need custom retrieval logic the library doesn't expose. The `useTextEmbeddings` example in [vision.md](./vision.md) shows the minimal building blocks.
-
-Both `ExecuTorchEmbeddings` and `ExecuTorchLLM` accept any model accessor from the registry — same `{ quant, backend }` options apply. Custom components (vector stores, splitters, embedders) implement the library's `Embeddings` / `LLM` / `VectorStore` / `TextSplitter` interfaces.
-
----
-
-## Device constraints
-
-| Tier | Parameter range | Examples |
-|---|---|---|
-| Low-end | 135M–500M | `models.llm.smollm2_1_135m`, `models.llm.smollm2_1_360m` |
-| Mid-range | 500M–1.7B | `models.llm.qwen3_0_6b`, `models.llm.smollm2_1_1_7b`, `models.llm.llama3_2_1b` |
-| High-end | 1.7B–4B | `models.llm.qwen3_4b`, `models.llm.phi_4_mini_4b`, `models.llm.llama3_2_3b` |
-
-For per-model memory and inference benchmarks: webfetch [Benchmarks](https://docs.swmansion.com/react-native-executorch/docs/benchmarks/inference-time).
-
-**Guidelines:**
-
-- Stay on the default (quantized) variant unless you've measured a need for full precision.
-- Test on the lowest-spec device you plan to support.
-- Provide a cloud fallback for devices that can't fit the model.
-- Surface a cleanup UI via `ExpoResourceFetcher.deleteResources` — downloaded models can be huge.
-- Always show loading states. Model download and inference are seconds-to-minutes operations.
-
----
-
-## See also
-
-- [Getting started](https://docs.swmansion.com/react-native-executorch/docs/fundamentals/getting-started)
-- [Loading models](https://docs.swmansion.com/react-native-executorch/docs/fundamentals/loading-models)
-- [Resource fetcher](https://docs.swmansion.com/react-native-executorch/docs/utilities/resource-fetcher)
-- [Error handling](https://docs.swmansion.com/react-native-executorch/docs/utilities/error-handling)
-- [useExecutorchModule API reference](https://docs.swmansion.com/react-native-executorch/docs/api-reference/functions/useExecutorchModule)
-- [useTokenizer API reference](https://docs.swmansion.com/react-native-executorch/docs/api-reference/functions/useTokenizer)
-- [usePrivacyFilter API reference](https://docs.swmansion.com/react-native-executorch/docs/api-reference/functions/usePrivacyFilter)
diff --git a/skills/react-native-executorch/references/speech.md b/skills/react-native-executorch/references/speech.md
deleted file mode 100644
index a43d5f2c63..0000000000
--- a/skills/react-native-executorch/references/speech.md
+++ /dev/null
@@ -1,290 +0,0 @@
-# Speech & Audio
-
-Speech-to-text (Whisper), text-to-speech (Kokoro), and voice activity detection (FSMN). All audio is exchanged as `Float32Array` PCM through `react-native-audio-api`.
-
-Pick models through the typed `models` registry:
-
-- `models.speech_to_text.<model>({ quant?, backend? })`
-- `models.text_to_speech.kokoro.<locale>.<voice>()` — bundles model + voice + phonemizer per language
-- `models.vad.fsmn_vad()`
-
----
-
-## Critical audio rules
-
-- **STT input: 16 kHz mono.** Mismatched sample rates produce silently garbled transcriptions.
-- **VAD input: 16 kHz mono.** Same constraint as STT.
-- **TTS output: 24 kHz.** Create the playback `AudioContext` with `{ sampleRate: 24000 }`.
-
----
-
-## Speech-to-text — `useSpeechToText`
-
-### One-shot transcription
-
-```tsx
-import { useSpeechToText, models } from 'react-native-executorch';
-import { AudioContext } from 'react-native-audio-api';
-import * as FileSystem from 'expo-file-system';
-
-const stt = useSpeechToText({ model: models.speech_to_text.whisper_tiny_en() });
-
-const { uri } = await FileSystem.downloadAsync(
-  'https://example.com/file.mp3',
-  FileSystem.cacheDirectory + 'audio.mp3'
-);
-
-const audioContext = new AudioContext({ sampleRate: 16000 });
-const decoded = await audioContext.decodeAudioData(uri);
-const buffer = decoded.getChannelData(0); // Float32Array @ 16 kHz mono
-
-const { text } = await stt.transcribe(buffer);
-```
-
-### Multilingual
-
-Use a multilingual Whisper accessor and pass a language code:
-
-```tsx
-const stt = useSpeechToText({ model: models.speech_to_text.whisper_tiny() });
-const { text } = await stt.transcribe(buffer, { language: 'es' });
-```
-
-### Word-level timestamps
-
-Pass `verbose: true` to get segments with per-word timing, log-probs, and compression ratios:
-
-```ts
-const result = await stt.transcribe(buffer, { verbose: true });
-// {
-//   task: 'transcription',
-//   text: '…',
-//   duration: 9.05,
-//   language: 'en',
-//   segments: [
-//     {
-//       start: 0,
-//       end: 5.4,
-//       text: '…',
-//       words: [{ word: 'Example', start: 0, end: 1.4 }, …],
-//       tokens: [...],
-//       temperature: 0.0,
-//       avgLogProb: -1.235,
-//       compressionRatio: 1.63,
-//     },
-//   ],
-// }
-```
-
-### Streaming transcription
-
-For audio longer than 30 s, use streaming. It applies the whisper-streaming algorithm so audio is chunked without cutting mid-sentence.
-
-```tsx
-import React, { useEffect, useRef, useState } from 'react';
-import { Button, SafeAreaView, Text, View } from 'react-native';
-import { useSpeechToText, models } from 'react-native-executorch';
-import { AudioManager, AudioRecorder } from 'react-native-audio-api';
-
-export default function StreamingStt() {
-  const stt = useSpeechToText({ model: models.speech_to_text.whisper_tiny_en() });
-  const [text, setText] = useState('');
-  const isRecording = useRef(false);
-  const [recorder] = useState(() => new AudioRecorder());
-
-  useEffect(() => {
-    AudioManager.setAudioSessionOptions({
-      iosCategory: 'playAndRecord',
-      iosMode: 'spokenAudio',
-      iosOptions: ['allowBluetooth', 'defaultToSpeaker'],
-    });
-    AudioManager.requestRecordingPermissions();
-  }, []);
-
-  const start = async () => {
-    isRecording.current = true;
-    setText('');
-
-    const sampleRate = 16000;
-    recorder.onAudioReady(
-      { sampleRate, bufferLength: 0.1 * sampleRate, channelCount: 1 },
-      (chunk) => stt.streamInsert(chunk.buffer.getChannelData(0))
-    );
-    await recorder.start();
-
-    let committed = '';
-    for await (const { committed: c, nonCommitted } of stt.stream({ verbose: false })) {
-      if (!isRecording.current) break;
-      if (c.text) committed += c.text;
-      setText(committed + nonCommitted.text);
-    }
-  };
-
-  const stop = () => {
-    isRecording.current = false;
-    recorder.stop();
-    stt.streamStop();
-  };
-
-  return (
-    <SafeAreaView>
-      <View style={{ padding: 20 }}>
-        <Text>{text || 'Press start to speak…'}</Text>
-        <Button title="Start" onPress={start} disabled={stt.isGenerating} />
-        <Button title="Stop" color="red" onPress={stop} />
-      </View>
-    </SafeAreaView>
-  );
-}
-```
-
-**Available STT accessors:**
-
-| Accessor | Languages |
-|---|---|
-| `models.speech_to_text.whisper_tiny_en` / `whisper_base_en` / `whisper_small_en` | English only |
-| `models.speech_to_text.whisper_tiny` / `whisper_base` / `whisper_small` | Multilingual |
-
----
-
-## Text-to-speech — `useTextToSpeech`
-
-Pick a Kokoro preset that bundles the model, a voice, and the phonemizer for that language:
-
-```tsx
-import { useTextToSpeech, models } from 'react-native-executorch';
-import { AudioContext } from 'react-native-audio-api';
-
-const tts = useTextToSpeech({
-  model: models.text_to_speech.kokoro.en_us.heart(),
-});
-
-const audioContext = new AudioContext({ sampleRate: 24000 });
-
-const speak = async (text: string) => {
-  const waveform = await tts.forward({ text, speed: 1.0 }); // Float32Array @ 24 kHz
-
-  const buffer = audioContext.createBuffer(1, waveform.length, 24000);
-  buffer.getChannelData(0).set(waveform);
-
-  const source = audioContext.createBufferSource();
-  source.buffer = buffer;
-  source.connect(audioContext.destination);
-  source.start();
-};
-```
-
-### Streaming TTS
-
-Stream chunks for lower time-to-first-audio on long text:
-
-```tsx
-await tts.stream({
-  text: 'Long text streamed chunk by chunk…',
-  speed: 1.0,
-  onBegin: async () => console.log('start'),
-  onNext: async (chunk) =>
-    new Promise<void>((resolve) => {
-      const buffer = audioContext.createBuffer(1, chunk.length, 24000);
-      buffer.getChannelData(0).set(chunk);
-      const source = audioContext.createBufferSource();
-      source.buffer = buffer;
-      source.connect(audioContext.destination);
-      source.onEnded = () => resolve();
-      source.start();
-    }),
-  onEnd: async () => console.log('done'),
-  stopAutomatically: true,
-});
-```
-
-### Phoneme input
-
-If you already have phonemes (e.g. from a custom pronunciation pipeline), skip the phonemizer:
-
-```tsx
-const waveform = await tts.forwardFromPhonemes({ phonemes: 'hɛloʊ', speed: 1.0 });
-
-await tts.streamFromPhonemes({
-  phonemes: 'hɛloʊ wɜːld',
-  speed: 1.0,
-  onNext: async (chunk) => { /* play */ },
-});
-```
-
-### Available TTS presets
-
-`models.text_to_speech.kokoro.<locale>.<voice>` — locale + voice combinations:
-
-| Locale | Voices |
-|---|---|
-| `en_us` | `heart`, `river`, `sarah`, `adam`, `michael`, `santa` |
-| `en_gb` | `emma`, `daniel` |
-| `fr` | `siwis` |
-| `es` | `dora`, `alex` |
-| `it` | `sara`, `nicola` |
-| `pt` | `dora`, `santa` |
-| `hi` | `alpha`, `omega`, `psi` |
-| `pl` | `mateusz` |
-| `de` | `anna` |
-
----
-
-## Voice activity detection — `useVAD`
-
-Detects speech segments in an audio buffer. Useful for trimming silence, segmenting recordings, or gating STT.
-
-```tsx
-import { useVAD, models } from 'react-native-executorch';
-import { AudioContext } from 'react-native-audio-api';
-import * as FileSystem from 'expo-file-system';
-
-const vad = useVAD({ model: models.vad.fsmn_vad() });
-
-const { uri } = await FileSystem.downloadAsync(
-  'https://example.com/file.mp3',
-  FileSystem.cacheDirectory + 'vad.mp3'
-);
-
-const audioContext = new AudioContext({ sampleRate: 16000 });
-const decoded = await audioContext.decodeAudioDataSource(uri);
-const buffer = decoded.getChannelData(0);
-
-const segments = await vad.forward(buffer);
-// segments: { start: number, end: number }[]
-// start/end are sample indices — divide by 16000 to get seconds
-```
-
-To concatenate detected speech into a single buffer:
-
-```ts
-const total = segments.reduce((s, seg) => s + (seg.end - seg.start), 0);
-const out = audioContext.createBuffer(1, total, decoded.sampleRate);
-const dst = out.getChannelData(0);
-let off = 0;
-for (const seg of segments) {
-  const slice = buffer.subarray(seg.start, seg.end);
-  dst.set(slice, off);
-  off += slice.length;
-}
-```
-
----
-
-## Troubleshooting
-
-- **Whisper output is garbled.** Audio is not 16 kHz mono — check the `AudioContext` sample rate and that you're reading channel 0.
-- **TTS sounds chipmunked or slow.** Playback `AudioContext` is at the wrong rate. Always use `{ sampleRate: 24000 }` for Kokoro output.
-- **`StreamingNotStarted` when calling `streamInsert`.** You must start `stream()` before inserting chunks.
-- **`StreamingInProgress` on a second `stream()` call.** Call `streamStop()` and wait before starting again.
-- **VAD segments look wrong in seconds.** They're sample indices — divide by 16000.
-- **iOS microphone is silent.** `AudioManager.requestRecordingPermissions()` must be called and the user must accept; verify the app has microphone Info.plist entitlements.
-
----
-
-## See also
-
-- [useSpeechToText API reference](https://docs.swmansion.com/react-native-executorch/docs/api-reference/functions/useSpeechToText)
-- [useTextToSpeech API reference](https://docs.swmansion.com/react-native-executorch/docs/api-reference/functions/useTextToSpeech)
-- [useVAD API reference](https://docs.swmansion.com/react-native-executorch/docs/api-reference/functions/useVAD)
-- [react-native-audio-api](https://docs.swmansion.com/react-native-audio-api/)
diff --git a/skills/react-native-executorch/references/vision.md b/skills/react-native-executorch/references/vision.md
deleted file mode 100644
index e01564de0e..0000000000
--- a/skills/react-native-executorch/references/vision.md
+++ /dev/null
@@ -1,268 +0,0 @@
-# Vision
-
-Image understanding and transformation: classification, object detection, semantic / instance segmentation, pose estimation, OCR, style transfer, text-to-image generation, and image / text embeddings.
-
-All models are selected through the typed `models` registry: `models.<category>.<model>({ quant?, backend? })`. Calling with no args returns the platform default (CoreML on iOS / XNNPACK on Android for multi-backend models, quantized variant when published). Passing a backend a model doesn't ship is a compile-time error.
-
-Every hook accepts image input as one of: a remote URL (`https://…`), a local file URI (`file://…`), a base64 string, or — for bundled assets — `require('../assets/img.jpg')`. Remote images are cached automatically.
-
----
-
-## Image classification — `useClassification`
-
-```tsx
-import { useClassification, models } from 'react-native-executorch';
-
-const model = useClassification({ model: models.classification.efficientnet_v2_s() });
-
-const labels = await model.forward('https://example.com/puppy.png');
-// labels: Record<string, number> — ImageNet1k label → probability
-
-const topThree = Object.entries(labels)
-  .sort(([, a], [, b]) => b - a)
-  .slice(0, 3);
-```
-
-For the full ImageNet1k label set, import `Imagenet1kLabel`.
-
----
-
-## Object detection — `useObjectDetection`
-
-```tsx
-import { useObjectDetection, models } from 'react-native-executorch';
-
-const model = useObjectDetection({ model: models.object_detection.yolo26n() });
-
-const detections = await model.forward('https://example.com/street.jpg', {
-  detectionThreshold: 0.5, // minimum confidence (0–1)
-  iouThreshold: 0.45,      // NMS aggressiveness (0–1)
-  inputSize: 640,          // for multi-size YOLO models (384 / 512 / 640)
-  classesOfInterest: ['PERSON', 'CAR'], // filter
-});
-
-for (const d of detections) {
-  console.log(d.bbox, d.label, d.score);
-}
-```
-
-`forward` returns `Detection[]` with `{ bbox: { x1, y1, x2, y2 }, label, score }`. Coordinates are pixel-space relative to the input image.
-
-YOLO models support multiple input sizes — call `model.getAvailableInputSizes()` to enumerate them.
-
-**Available accessors:** `models.object_detection.yolo26n` / `yolo26s` / `yolo26m` / `yolo26l` / `yolo26x`, `models.object_detection.rf_detr_nano`, `models.object_detection.ssdlite_320_mobilenet_v3_large`.
-
----
-
-## Semantic segmentation — `useSemanticSegmentation`
-
-Pixel-level classification.
-
-```tsx
-import { useSemanticSegmentation, models, DeeplabLabel } from 'react-native-executorch';
-
-const model = useSemanticSegmentation({
-  model: models.semantic_segmentation.deeplab_v3_resnet50(),
-});
-
-// Pass classesOfInterest + resizeToInput to also get per-class probability maps
-const out = await model.forward(imageUri, ['CAT', 'DOG', 'PERSON'], true);
-const argmax = out[DeeplabLabel.ARGMAX];        // class id per pixel
-const catProbs = out['CAT'];                    // probability per pixel
-```
-
-**Tradeoff:** `resizeToInput: true` upsamples to the original image size — more memory and slower. With `false`, indices map to a 224×224 grid.
-
-**Available accessors:** `models.semantic_segmentation.deeplab_v3_resnet50` / `deeplab_v3_resnet101` / `deeplab_v3_mobilenet_v3_large` / `lraspp_mobilenet_v3_large` / `fcn_resnet50` / `fcn_resnet101` / `selfie_segmentation`.
-
----
-
-## Instance segmentation — `useInstanceSegmentation`
-
-Per-instance masks (one mask per detected object).
-
-```tsx
-import { useInstanceSegmentation, models } from 'react-native-executorch';
-
-const model = useInstanceSegmentation({
-  model: models.instance_segmentation.yolo26n(),
-});
-
-const instances = await model.forward('https://example.com/street.jpg');
-// instances: { bbox, label, score, mask }[]
-```
-
-**Available accessors:** `models.instance_segmentation.yolo26n` … `yolo26x`, `rf_detr_nano`, `fastsam_s`, `fastsam_x`.
-
----
-
-## Pose estimation — `usePoseEstimation`
-
-Detects humans and their COCO 17-keypoint skeletons (nose, eyes, ears, shoulders, elbows, wrists, hips, knees, ankles).
-
-```tsx
-import { usePoseEstimation, models, CocoKeypoint } from 'react-native-executorch';
-
-const model = usePoseEstimation({ model: models.pose_estimation.yolo26n() });
-
-const poses = await model.forward('https://example.com/person.jpg');
-// poses: { bbox, score, keypoints: { x, y, confidence }[] }[]
-
-for (const pose of poses) {
-  const nose = pose.keypoints[CocoKeypoint.NOSE];
-  console.log('Nose at', nose.x, nose.y, 'conf', nose.confidence);
-}
-```
-
-Use the `CocoKeypoint` enum to index into `keypoints` by name.
-
----
-
-## OCR — `useOCR` and `useVerticalOCR`
-
-The OCR pipeline ships a CRAFT detector plus per-alphabet CRNN recognizers. Pick one with a language code via `models.ocr.craft({ language })`.
-
-```tsx
-import { useOCR, models } from 'react-native-executorch';
-
-const ocr = useOCR({ model: models.ocr.craft({ language: 'en' }) });
-
-const detections = await ocr.forward('https://example.com/receipt.jpg');
-for (const d of detections) {
-  console.log(d.text, d.score, d.bbox); // bbox = 4-point polygon
-}
-```
-
-`OCRDetection`:
-```ts
-interface OCRDetection {
-  bbox: { x: number; y: number }[]; // 4 corner points (supports rotated/skewed text)
-  text: string;
-  score: number; // 0–1
-}
-```
-
-**Vertical / CJK text** — use `useVerticalOCR` with `independentCharacters: true`:
-
-```tsx
-import { useVerticalOCR, models } from 'react-native-executorch';
-
-const ocr = useVerticalOCR({
-  model: models.ocr.craft({ language: 'ch_sim' }),
-  independentCharacters: true, // recommended for CJK; set false for vertical Latin
-});
-
-const detections = await ocr.forward(imageUri);
-```
-
-**Alphabet matching matters.** Latin and Cyrillic share a detector but use different recognizers. Pass the language code that matches the script you want to read. Unsupported languages throw `LanguageNotSupported`. Full alphabet support list: webfetch [OCR Supported Alphabets](https://docs.swmansion.com/react-native-executorch/docs/api-reference#ocr-supported-alphabets).
-
----
-
-## Style transfer — `useStyleTransfer`
-
-Apply one of four pre-trained artistic styles to an image.
-
-```tsx
-import { useStyleTransfer, models } from 'react-native-executorch';
-
-const model = useStyleTransfer({ model: models.style_transfer.candy() });
-
-// Default: returns PixelData (raw RGB buffer)
-const pixelData = await model.forward(imageUri);
-
-// Pass 'url' as second arg to get a file URI back
-const styledUri = await model.forward(imageUri, 'url');
-```
-
-**Available accessors:** `models.style_transfer.candy` / `mosaic` / `rain_princess` / `udnie`.
-
-Generated images are written to the app's temporary directory. Expect a few seconds of inference per image.
-
----
-
-## Text-to-image — `useTextToImage`
-
-On-device Stable Diffusion (BK-SDM tiny).
-
-```tsx
-import { useTextToImage, models } from 'react-native-executorch';
-
-const model = useTextToImage({ model: models.image_generation.bk_sdm_tiny_vpred_256() });
-
-const image = await model.generate('a medieval castle by the sea', 256, 25);
-// image: base64 PNG. Render with <Image source={{ uri: `data:image/png;base64,${image}` }} />
-```
-
-Signature: `generate(prompt, imageSize?, numSteps?)`. Image size must be a multiple of 32. Expect 20–60 s per image depending on device, size, and step count. Use `bk_sdm_tiny_vpred_256` on lower-end devices; `bk_sdm_tiny_vpred_512` on high-end devices.
-
----
-
-## Image embeddings — `useImageEmbeddings`
-
-CLIP-based image vectors for similarity / search. Pair with `useTextEmbeddings` (using the CLIP text encoder) for cross-modal retrieval.
-
-```tsx
-import { useImageEmbeddings, models } from 'react-native-executorch';
-
-const model = useImageEmbeddings({
-  model: models.image_embedding.clip_vit_base_patch32_image(),
-});
-
-const v1 = await model.forward(imageUri1); // Float32Array
-const v2 = await model.forward(imageUri2);
-
-// Returned vectors are L2-normalized — cosine similarity = dot product
-const sim = v1.reduce((s, x, i) => s + x * v2[i], 0);
-```
-
-Images are auto-resized to 224 × 224.
-
----
-
-## Text embeddings — `useTextEmbeddings`
-
-Sentence-level embeddings for semantic search, similarity, clustering, or RAG. Listed under vision because the CLIP text encoder is the cross-modal pair to image embeddings.
-
-```tsx
-import { useTextEmbeddings, models } from 'react-native-executorch';
-
-const model = useTextEmbeddings({
-  model: models.text_embedding.all_minilm_l6_v2(),
-});
-
-const v1 = await model.forward('Hello world');
-const v2 = await model.forward('Greetings everyone');
-const cosine = v1.reduce((s, x, i) => s + x * v2[i], 0); // pre-normalized
-```
-
-| Accessor | Max tokens | Dim | Use case |
-|---|---|---|---|
-| `models.text_embedding.all_minilm_l6_v2` | 254 | 384 | General purpose |
-| `models.text_embedding.all_mpnet_base_v2` | 382 | 768 | Higher quality, slower |
-| `models.text_embedding.multi_qa_minilm_l6_cos_v1` | 509 | 384 | Q&A / semantic search |
-| `models.text_embedding.multi_qa_mpnet_base_dot_v1` | 510 | 768 | Q&A / semantic search |
-| `models.text_embedding.distiluse_base_multilingual_cased_v2` | 128 | 512 | Multilingual |
-| `models.text_embedding.paraphrase_multilingual_minilm_l12_v2` | 128 | 384 | Multilingual paraphrase |
-| `models.text_embedding.clip_vit_base_patch32_text` | 74 | 512 | Pair with image embeddings (CLIP) |
-
-Text exceeding `Max tokens` is truncated. Use `useTokenizer` (see [setup.md](./setup.md)) to count first.
-
-**Building a full RAG pipeline?** Don't roll your own — use [react-native-rag](https://github.com/software-mansion-labs/react-native-rag) (sibling library). It wraps `useTextEmbeddings` + `useLLM` with `ExecuTorchEmbeddings` / `ExecuTorchLLM`, ships a `MemoryVectorStore` + an op-sqlite persistence plugin, and exposes a `useRAG` hook. See [setup.md](./setup.md) for an end-to-end example.
-
----
-
-## Troubleshooting
-
-- **`MemoryAllocationFailed` at load.** Step down to a smaller accessor (e.g. `yolo26n` instead of `yolo26x`) or pass `{ quant: true }` if a quantized variant is published.
-- **`LanguageNotSupported` from OCR.** The requested language has no published CRAFT/CRNN recognizer pair. Use `'en'` for Latin or the relevant ISO code for the script you need.
-- **Style transfer or text-to-image is slow.** Both are compute-heavy; show a progress indicator. For text-to-image, lower `numSteps` and use the 256 model on mid-range devices.
-- **Image embeddings cosine similarity outside [-1, 1].** Vectors are pre-normalized — the dot product is already the cosine. If you see anomalies, verify you're not double-normalizing.
-
----
-
-## See also
-
-- [API reference](https://docs.swmansion.com/react-native-executorch/docs/api-reference) — per-hook signatures
-- [HuggingFace collections](https://huggingface.co/software-mansion) — pre-exported model artefacts
-- [setup.md](./setup.md) — loading strategies, error handling, custom `.pte` models
diff --git a/yarn.lock b/yarn.lock
index 36ccc4a04f..c81176245e 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -5,13 +5,6 @@ __metadata:
   version: 8
   cacheKey: 10
 
-"@adobe/css-tools@npm:^4.4.0":
-  version: 4.5.0
-  resolution: "@adobe/css-tools@npm:4.5.0"
-  checksum: 10/a332050614f7e08928aba518ac65534621672590bdfc2079886e9ead90da78c7fe2498152c5083318e93ee909260ec13854c21ac77c24053f7d30c5d2d2adcc1
-  languageName: node
-  linkType: hard
-
 "@ark/schema@npm:0.56.0":
   version: 0.56.0
   resolution: "@ark/schema@npm:0.56.0"
@@ -28,7 +21,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/code-frame@npm:^7.0.0, @babel/code-frame@npm:^7.12.13, @babel/code-frame@npm:^7.20.0, @babel/code-frame@npm:^7.27.1, @babel/code-frame@npm:^7.28.6, @babel/code-frame@npm:^7.29.0":
+"@babel/code-frame@npm:^7.12.13, @babel/code-frame@npm:^7.20.0, @babel/code-frame@npm:^7.28.6, @babel/code-frame@npm:^7.29.0":
   version: 7.29.0
   resolution: "@babel/code-frame@npm:7.29.0"
   dependencies:
@@ -50,14 +43,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/compat-data@npm:^7.20.5, @babel/compat-data@npm:^7.28.6, @babel/compat-data@npm:^7.29.0":
+"@babel/compat-data@npm:^7.28.6, @babel/compat-data@npm:^7.29.0":
   version: 7.29.0
   resolution: "@babel/compat-data@npm:7.29.0"
   checksum: 10/7f21beedb930ed8fbf7eabafc60e6e6521c1d905646bf1317a61b2163339157fe797efeb85962bf55136e166b01fd1a6b526a15974b92a8b877d564dcb6c9580
   languageName: node
   linkType: hard
 
-"@babel/core@npm:^7.11.6, @babel/core@npm:^7.12.3, @babel/core@npm:^7.20.0, @babel/core@npm:^7.21.3, @babel/core@npm:^7.23.9, @babel/core@npm:^7.25.1, @babel/core@npm:^7.25.2, @babel/core@npm:^7.27.4, @babel/core@npm:^7.29.0":
+"@babel/core@npm:^7.11.6, @babel/core@npm:^7.12.3, @babel/core@npm:^7.20.0, @babel/core@npm:^7.25.1, @babel/core@npm:^7.25.2":
   version: 7.29.0
   resolution: "@babel/core@npm:7.29.0"
   dependencies:
@@ -94,7 +87,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/generator@npm:^7.20.5, @babel/generator@npm:^7.27.5, @babel/generator@npm:^7.29.0, @babel/generator@npm:^7.29.1, @babel/generator@npm:^7.7.2":
+"@babel/generator@npm:^7.20.5, @babel/generator@npm:^7.29.0, @babel/generator@npm:^7.29.1":
   version: 7.29.1
   resolution: "@babel/generator@npm:7.29.1"
   dependencies:
@@ -138,7 +131,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/helper-compilation-targets@npm:^7.20.7, @babel/helper-compilation-targets@npm:^7.27.1, @babel/helper-compilation-targets@npm:^7.28.6":
+"@babel/helper-compilation-targets@npm:^7.27.1, @babel/helper-compilation-targets@npm:^7.28.6":
   version: 7.28.6
   resolution: "@babel/helper-compilation-targets@npm:7.28.6"
   dependencies:
@@ -151,7 +144,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/helper-create-class-features-plugin@npm:^7.18.6, @babel/helper-create-class-features-plugin@npm:^7.28.6":
+"@babel/helper-create-class-features-plugin@npm:^7.28.6":
   version: 7.28.6
   resolution: "@babel/helper-create-class-features-plugin@npm:7.28.6"
   dependencies:
@@ -168,6 +161,23 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-create-class-features-plugin@npm:^7.29.7":
+  version: 7.29.7
+  resolution: "@babel/helper-create-class-features-plugin@npm:7.29.7"
+  dependencies:
+    "@babel/helper-annotate-as-pure": "npm:^7.29.7"
+    "@babel/helper-member-expression-to-functions": "npm:^7.29.7"
+    "@babel/helper-optimise-call-expression": "npm:^7.29.7"
+    "@babel/helper-replace-supers": "npm:^7.29.7"
+    "@babel/helper-skip-transparent-expression-wrappers": "npm:^7.29.7"
+    "@babel/traverse": "npm:^7.29.7"
+    semver: "npm:^6.3.1"
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: 10/74f871e5389beca9fb52670f2bd83abdd6dc7b7a10f34679ffab5eabf91077dccaabf55438b9f3c897258fb81fbb80bfbf469b836a404abb7e64b4d7c141a8da
+  languageName: node
+  linkType: hard
+
 "@babel/helper-create-regexp-features-plugin@npm:^7.18.6, @babel/helper-create-regexp-features-plugin@npm:^7.27.1, @babel/helper-create-regexp-features-plugin@npm:^7.28.5":
   version: 7.28.5
   resolution: "@babel/helper-create-regexp-features-plugin@npm:7.28.5"
@@ -196,15 +206,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/helper-environment-visitor@npm:^7.18.9":
-  version: 7.24.7
-  resolution: "@babel/helper-environment-visitor@npm:7.24.7"
-  dependencies:
-    "@babel/types": "npm:^7.24.7"
-  checksum: 10/079d86e65701b29ebc10baf6ed548d17c19b808a07aa6885cc141b690a78581b180ee92b580d755361dc3b16adf975b2d2058b8ce6c86675fcaf43cf22f2f7c6
-  languageName: node
-  linkType: hard
-
 "@babel/helper-globals@npm:^7.28.0":
   version: 7.28.0
   resolution: "@babel/helper-globals@npm:7.28.0"
@@ -229,6 +230,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-member-expression-to-functions@npm:^7.29.7":
+  version: 7.29.7
+  resolution: "@babel/helper-member-expression-to-functions@npm:7.29.7"
+  dependencies:
+    "@babel/traverse": "npm:^7.29.7"
+    "@babel/types": "npm:^7.29.7"
+  checksum: 10/bb8dc59a65b4404260e0b7ff70f491de5a1607876f61736d26605ab3cba5b368827b0551acd3458212f5cfa99cbcd48bb66a96497b0fe00af09a6a2cbea4276b
+  languageName: node
+  linkType: hard
+
 "@babel/helper-module-imports@npm:^7.25.9, @babel/helper-module-imports@npm:^7.28.6":
   version: 7.28.6
   resolution: "@babel/helper-module-imports@npm:7.28.6"
@@ -262,6 +273,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-module-transforms@npm:^7.29.7":
+  version: 7.29.7
+  resolution: "@babel/helper-module-transforms@npm:7.29.7"
+  dependencies:
+    "@babel/helper-module-imports": "npm:^7.29.7"
+    "@babel/helper-validator-identifier": "npm:^7.29.7"
+    "@babel/traverse": "npm:^7.29.7"
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: 10/33251b1fb44d726194a974a0078b1269511d130a2609357ff829b479e9e4dca96ecd5384c534a477095f665ffb01503d3e680699c2002e5b62e6ca1a272f1892
+  languageName: node
+  linkType: hard
+
 "@babel/helper-optimise-call-expression@npm:^7.27.1":
   version: 7.27.1
   resolution: "@babel/helper-optimise-call-expression@npm:7.27.1"
@@ -271,7 +295,16 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/helper-plugin-utils@npm:^7.0.0, @babel/helper-plugin-utils@npm:^7.10.4, @babel/helper-plugin-utils@npm:^7.12.13, @babel/helper-plugin-utils@npm:^7.14.5, @babel/helper-plugin-utils@npm:^7.18.6, @babel/helper-plugin-utils@npm:^7.20.2, @babel/helper-plugin-utils@npm:^7.27.1, @babel/helper-plugin-utils@npm:^7.28.6, @babel/helper-plugin-utils@npm:^7.8.0":
+"@babel/helper-optimise-call-expression@npm:^7.29.7":
+  version: 7.29.7
+  resolution: "@babel/helper-optimise-call-expression@npm:7.29.7"
+  dependencies:
+    "@babel/types": "npm:^7.29.7"
+  checksum: 10/6b477e01b403fd48349336cb1d94722bff4fa54af2841b5fa950c557b796f4ecc14724052252ed1362ccfc23d1c09c54dc03e182fea59d3dc5bd69f8c626ba25
+  languageName: node
+  linkType: hard
+
+"@babel/helper-plugin-utils@npm:^7.0.0, @babel/helper-plugin-utils@npm:^7.10.4, @babel/helper-plugin-utils@npm:^7.12.13, @babel/helper-plugin-utils@npm:^7.14.5, @babel/helper-plugin-utils@npm:^7.18.6, @babel/helper-plugin-utils@npm:^7.27.1, @babel/helper-plugin-utils@npm:^7.28.6, @babel/helper-plugin-utils@npm:^7.8.0":
   version: 7.28.6
   resolution: "@babel/helper-plugin-utils@npm:7.28.6"
   checksum: 10/21c853bbc13dbdddf03309c9a0477270124ad48989e1ad6524b83e83a77524b333f92edd2caae645c5a7ecf264ec6d04a9ebe15aeb54c7f33c037b71ec521e4a
@@ -285,7 +318,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/helper-remap-async-to-generator@npm:^7.18.9, @babel/helper-remap-async-to-generator@npm:^7.27.1":
+"@babel/helper-remap-async-to-generator@npm:^7.27.1":
   version: 7.27.1
   resolution: "@babel/helper-remap-async-to-generator@npm:7.27.1"
   dependencies:
@@ -311,7 +344,20 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/helper-skip-transparent-expression-wrappers@npm:^7.20.0, @babel/helper-skip-transparent-expression-wrappers@npm:^7.27.1":
+"@babel/helper-replace-supers@npm:^7.29.7":
+  version: 7.29.7
+  resolution: "@babel/helper-replace-supers@npm:7.29.7"
+  dependencies:
+    "@babel/helper-member-expression-to-functions": "npm:^7.29.7"
+    "@babel/helper-optimise-call-expression": "npm:^7.29.7"
+    "@babel/traverse": "npm:^7.29.7"
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: 10/4aa7b48a6078db99bba24b67f63f97cd08ad9b3c476dcca196c6421dc2080f3566d683fba64c772e2f9597603d42ad4ac2ce9ccf0559643823c540f08cf0efa7
+  languageName: node
+  linkType: hard
+
+"@babel/helper-skip-transparent-expression-wrappers@npm:^7.27.1":
   version: 7.27.1
   resolution: "@babel/helper-skip-transparent-expression-wrappers@npm:7.27.1"
   dependencies:
@@ -321,6 +367,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-skip-transparent-expression-wrappers@npm:^7.29.7":
+  version: 7.29.7
+  resolution: "@babel/helper-skip-transparent-expression-wrappers@npm:7.29.7"
+  dependencies:
+    "@babel/traverse": "npm:^7.29.7"
+    "@babel/types": "npm:^7.29.7"
+  checksum: 10/a5800bfcdca6cef7f6fe33ac02a0f05ff33da9746f97806553f249733f7ba8400290a17f3831d7faa5d91656f254ab749931f53c8a29f301d958d7dd00499637
+  languageName: node
+  linkType: hard
+
 "@babel/helper-string-parser@npm:^7.27.1":
   version: 7.27.1
   resolution: "@babel/helper-string-parser@npm:7.27.1"
@@ -356,6 +412,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-validator-option@npm:^7.29.7":
+  version: 7.29.7
+  resolution: "@babel/helper-validator-option@npm:7.29.7"
+  checksum: 10/aeb6aa966f59300d3cc2fea7c68e1dfd7ad011fc10e535c8e2b2de3094b27c859428dc7220f16420350f8b1cde99da120b673be04bcb0c2f37b56258c96bed58
+  languageName: node
+  linkType: hard
+
 "@babel/helper-wrap-function@npm:^7.27.1":
   version: 7.28.6
   resolution: "@babel/helper-wrap-function@npm:7.28.6"
@@ -377,7 +440,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/parser@npm:^7.1.0, @babel/parser@npm:^7.14.7, @babel/parser@npm:^7.20.7, @babel/parser@npm:^7.23.9, @babel/parser@npm:^7.25.3, @babel/parser@npm:^7.28.6, @babel/parser@npm:^7.29.0":
+"@babel/parser@npm:^7.1.0, @babel/parser@npm:^7.14.7, @babel/parser@npm:^7.20.7, @babel/parser@npm:^7.25.3, @babel/parser@npm:^7.28.6, @babel/parser@npm:^7.29.0":
   version: 7.29.0
   resolution: "@babel/parser@npm:7.29.0"
   dependencies:
@@ -458,32 +521,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-proposal-async-generator-functions@npm:^7.0.0":
-  version: 7.20.7
-  resolution: "@babel/plugin-proposal-async-generator-functions@npm:7.20.7"
-  dependencies:
-    "@babel/helper-environment-visitor": "npm:^7.18.9"
-    "@babel/helper-plugin-utils": "npm:^7.20.2"
-    "@babel/helper-remap-async-to-generator": "npm:^7.18.9"
-    "@babel/plugin-syntax-async-generators": "npm:^7.8.4"
-  peerDependencies:
-    "@babel/core": ^7.0.0-0
-  checksum: 10/111109ee118c9e69982f08d5e119eab04190b36a0f40e22e873802d941956eee66d2aa5a15f5321e51e3f9aa70a91136451b987fe15185ef8cc547ac88937723
-  languageName: node
-  linkType: hard
-
-"@babel/plugin-proposal-class-properties@npm:^7.18.0":
-  version: 7.18.6
-  resolution: "@babel/plugin-proposal-class-properties@npm:7.18.6"
-  dependencies:
-    "@babel/helper-create-class-features-plugin": "npm:^7.18.6"
-    "@babel/helper-plugin-utils": "npm:^7.18.6"
-  peerDependencies:
-    "@babel/core": ^7.0.0-0
-  checksum: 10/49a78a2773ec0db56e915d9797e44fd079ab8a9b2e1716e0df07c92532f2c65d76aeda9543883916b8e0ff13606afeffa67c5b93d05b607bc87653ad18a91422
-  languageName: node
-  linkType: hard
-
 "@babel/plugin-proposal-decorators@npm:^7.12.9":
   version: 7.29.0
   resolution: "@babel/plugin-proposal-decorators@npm:7.29.0"
@@ -497,7 +534,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-proposal-export-default-from@npm:^7.0.0, @babel/plugin-proposal-export-default-from@npm:^7.24.7":
+"@babel/plugin-proposal-export-default-from@npm:^7.24.7":
   version: 7.27.1
   resolution: "@babel/plugin-proposal-export-default-from@npm:7.27.1"
   dependencies:
@@ -508,70 +545,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-proposal-nullish-coalescing-operator@npm:^7.18.0":
-  version: 7.18.6
-  resolution: "@babel/plugin-proposal-nullish-coalescing-operator@npm:7.18.6"
-  dependencies:
-    "@babel/helper-plugin-utils": "npm:^7.18.6"
-    "@babel/plugin-syntax-nullish-coalescing-operator": "npm:^7.8.3"
-  peerDependencies:
-    "@babel/core": ^7.0.0-0
-  checksum: 10/949c9ddcdecdaec766ee610ef98f965f928ccc0361dd87cf9f88cf4896a6ccd62fce063d4494778e50da99dea63d270a1be574a62d6ab81cbe9d85884bf55a7d
-  languageName: node
-  linkType: hard
-
-"@babel/plugin-proposal-numeric-separator@npm:^7.0.0":
-  version: 7.18.6
-  resolution: "@babel/plugin-proposal-numeric-separator@npm:7.18.6"
-  dependencies:
-    "@babel/helper-plugin-utils": "npm:^7.18.6"
-    "@babel/plugin-syntax-numeric-separator": "npm:^7.10.4"
-  peerDependencies:
-    "@babel/core": ^7.0.0-0
-  checksum: 10/f370ea584c55bf4040e1f78c80b4eeb1ce2e6aaa74f87d1a48266493c33931d0b6222d8cee3a082383d6bb648ab8d6b7147a06f974d3296ef3bc39c7851683ec
-  languageName: node
-  linkType: hard
-
-"@babel/plugin-proposal-object-rest-spread@npm:^7.20.0":
-  version: 7.20.7
-  resolution: "@babel/plugin-proposal-object-rest-spread@npm:7.20.7"
-  dependencies:
-    "@babel/compat-data": "npm:^7.20.5"
-    "@babel/helper-compilation-targets": "npm:^7.20.7"
-    "@babel/helper-plugin-utils": "npm:^7.20.2"
-    "@babel/plugin-syntax-object-rest-spread": "npm:^7.8.3"
-    "@babel/plugin-transform-parameters": "npm:^7.20.7"
-  peerDependencies:
-    "@babel/core": ^7.0.0-0
-  checksum: 10/cb0f8f2ff98d7bb64ee91c28b20e8ab15d9bc7043f0932cbb9e51e1bbfb623b12f206a1171e070299c9cf21948c320b710d6d72a42f68a5bfd2702354113a1c5
-  languageName: node
-  linkType: hard
-
-"@babel/plugin-proposal-optional-catch-binding@npm:^7.0.0":
-  version: 7.18.6
-  resolution: "@babel/plugin-proposal-optional-catch-binding@npm:7.18.6"
-  dependencies:
-    "@babel/helper-plugin-utils": "npm:^7.18.6"
-    "@babel/plugin-syntax-optional-catch-binding": "npm:^7.8.3"
-  peerDependencies:
-    "@babel/core": ^7.0.0-0
-  checksum: 10/7b5b39fb5d8d6d14faad6cb68ece5eeb2fd550fb66b5af7d7582402f974f5bc3684641f7c192a5a57e0f59acfae4aada6786be1eba030881ddc590666eff4d1e
-  languageName: node
-  linkType: hard
-
-"@babel/plugin-proposal-optional-chaining@npm:^7.20.0":
-  version: 7.21.0
-  resolution: "@babel/plugin-proposal-optional-chaining@npm:7.21.0"
-  dependencies:
-    "@babel/helper-plugin-utils": "npm:^7.20.2"
-    "@babel/helper-skip-transparent-expression-wrappers": "npm:^7.20.0"
-    "@babel/plugin-syntax-optional-chaining": "npm:^7.8.3"
-  peerDependencies:
-    "@babel/core": ^7.0.0-0
-  checksum: 10/522cd133aff5c94c0ef36ff83c64f03deee183815da68b65b6950e81972ace3b514e032df07ea76d0f9ec8cc7a49578092907adfa17fccb4612117557c04a882
-  languageName: node
-  linkType: hard
-
 "@babel/plugin-proposal-private-property-in-object@npm:7.21.0-placeholder-for-preset-env.2":
   version: 7.21.0-placeholder-for-preset-env.2
   resolution: "@babel/plugin-proposal-private-property-in-object@npm:7.21.0-placeholder-for-preset-env.2"
@@ -636,7 +609,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-syntax-dynamic-import@npm:^7.8.0, @babel/plugin-syntax-dynamic-import@npm:^7.8.3":
+"@babel/plugin-syntax-dynamic-import@npm:^7.8.3":
   version: 7.8.3
   resolution: "@babel/plugin-syntax-dynamic-import@npm:7.8.3"
   dependencies:
@@ -647,7 +620,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-syntax-export-default-from@npm:^7.0.0, @babel/plugin-syntax-export-default-from@npm:^7.24.7":
+"@babel/plugin-syntax-export-default-from@npm:^7.24.7":
   version: 7.28.6
   resolution: "@babel/plugin-syntax-export-default-from@npm:7.28.6"
   dependencies:
@@ -658,7 +631,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-syntax-flow@npm:^7.12.1, @babel/plugin-syntax-flow@npm:^7.18.0, @babel/plugin-syntax-flow@npm:^7.27.1":
+"@babel/plugin-syntax-flow@npm:^7.12.1, @babel/plugin-syntax-flow@npm:^7.27.1":
   version: 7.28.6
   resolution: "@babel/plugin-syntax-flow@npm:7.28.6"
   dependencies:
@@ -713,7 +686,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-syntax-jsx@npm:^7.27.1, @babel/plugin-syntax-jsx@npm:^7.28.6, @babel/plugin-syntax-jsx@npm:^7.7.2":
+"@babel/plugin-syntax-jsx@npm:^7.27.1, @babel/plugin-syntax-jsx@npm:^7.28.6":
   version: 7.28.6
   resolution: "@babel/plugin-syntax-jsx@npm:7.28.6"
   dependencies:
@@ -746,7 +719,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-syntax-nullish-coalescing-operator@npm:^7.0.0, @babel/plugin-syntax-nullish-coalescing-operator@npm:^7.8.3":
+"@babel/plugin-syntax-nullish-coalescing-operator@npm:^7.8.3":
   version: 7.8.3
   resolution: "@babel/plugin-syntax-nullish-coalescing-operator@npm:7.8.3"
   dependencies:
@@ -790,7 +763,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-syntax-optional-chaining@npm:^7.0.0, @babel/plugin-syntax-optional-chaining@npm:^7.8.3":
+"@babel/plugin-syntax-optional-chaining@npm:^7.8.3":
   version: 7.8.3
   resolution: "@babel/plugin-syntax-optional-chaining@npm:7.8.3"
   dependencies:
@@ -823,7 +796,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-syntax-typescript@npm:^7.27.1, @babel/plugin-syntax-typescript@npm:^7.28.6, @babel/plugin-syntax-typescript@npm:^7.7.2":
+"@babel/plugin-syntax-typescript@npm:^7.28.6":
   version: 7.28.6
   resolution: "@babel/plugin-syntax-typescript@npm:7.28.6"
   dependencies:
@@ -834,6 +807,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-syntax-typescript@npm:^7.29.7":
+  version: 7.29.7
+  resolution: "@babel/plugin-syntax-typescript@npm:7.29.7"
+  dependencies:
+    "@babel/helper-plugin-utils": "npm:^7.29.7"
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 10/ef454d2a7a6209dd4255361c072c94ab1293e7ad4b06e7e744d08bb308065d4d6544964eae9b2357c3b33d8d939f9e32d4aa95905bc464407cd8f7101dee4443
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-syntax-unicode-sets-regex@npm:^7.18.6":
   version: 7.18.6
   resolution: "@babel/plugin-syntax-unicode-sets-regex@npm:7.18.6"
@@ -846,7 +830,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-arrow-functions@npm:^7.0.0, @babel/plugin-transform-arrow-functions@npm:^7.24.7, @babel/plugin-transform-arrow-functions@npm:^7.27.1":
+"@babel/plugin-transform-arrow-functions@npm:^7.24.7, @babel/plugin-transform-arrow-functions@npm:^7.27.1":
   version: 7.27.1
   resolution: "@babel/plugin-transform-arrow-functions@npm:7.27.1"
   dependencies:
@@ -870,7 +854,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-async-to-generator@npm:^7.20.0, @babel/plugin-transform-async-to-generator@npm:^7.24.7, @babel/plugin-transform-async-to-generator@npm:^7.28.6":
+"@babel/plugin-transform-async-to-generator@npm:^7.24.7, @babel/plugin-transform-async-to-generator@npm:^7.28.6":
   version: 7.28.6
   resolution: "@babel/plugin-transform-async-to-generator@npm:7.28.6"
   dependencies:
@@ -894,7 +878,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-block-scoping@npm:^7.0.0, @babel/plugin-transform-block-scoping@npm:^7.25.0, @babel/plugin-transform-block-scoping@npm:^7.28.6":
+"@babel/plugin-transform-block-scoping@npm:^7.25.0, @babel/plugin-transform-block-scoping@npm:^7.28.6":
   version: 7.28.6
   resolution: "@babel/plugin-transform-block-scoping@npm:7.28.6"
   dependencies:
@@ -905,7 +889,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-class-properties@npm:^7.25.4, @babel/plugin-transform-class-properties@npm:^7.27.1, @babel/plugin-transform-class-properties@npm:^7.28.6":
+"@babel/plugin-transform-class-properties@npm:^7.25.4, @babel/plugin-transform-class-properties@npm:^7.28.6":
   version: 7.28.6
   resolution: "@babel/plugin-transform-class-properties@npm:7.28.6"
   dependencies:
@@ -929,7 +913,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-classes@npm:^7.0.0, @babel/plugin-transform-classes@npm:^7.25.4, @babel/plugin-transform-classes@npm:^7.28.4, @babel/plugin-transform-classes@npm:^7.28.6":
+"@babel/plugin-transform-classes@npm:^7.25.4, @babel/plugin-transform-classes@npm:^7.28.6":
   version: 7.28.6
   resolution: "@babel/plugin-transform-classes@npm:7.28.6"
   dependencies:
@@ -945,7 +929,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-computed-properties@npm:^7.0.0, @babel/plugin-transform-computed-properties@npm:^7.24.7, @babel/plugin-transform-computed-properties@npm:^7.28.6":
+"@babel/plugin-transform-computed-properties@npm:^7.24.7, @babel/plugin-transform-computed-properties@npm:^7.28.6":
   version: 7.28.6
   resolution: "@babel/plugin-transform-computed-properties@npm:7.28.6"
   dependencies:
@@ -957,7 +941,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-destructuring@npm:^7.20.0, @babel/plugin-transform-destructuring@npm:^7.24.8, @babel/plugin-transform-destructuring@npm:^7.28.5":
+"@babel/plugin-transform-destructuring@npm:^7.24.8, @babel/plugin-transform-destructuring@npm:^7.28.5":
   version: 7.28.5
   resolution: "@babel/plugin-transform-destructuring@npm:7.28.5"
   dependencies:
@@ -1038,7 +1022,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-export-namespace-from@npm:^7.25.2, @babel/plugin-transform-export-namespace-from@npm:^7.25.9, @babel/plugin-transform-export-namespace-from@npm:^7.27.1":
+"@babel/plugin-transform-export-namespace-from@npm:^7.25.9, @babel/plugin-transform-export-namespace-from@npm:^7.27.1":
   version: 7.27.1
   resolution: "@babel/plugin-transform-export-namespace-from@npm:7.27.1"
   dependencies:
@@ -1049,7 +1033,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-flow-strip-types@npm:^7.20.0, @babel/plugin-transform-flow-strip-types@npm:^7.25.2, @babel/plugin-transform-flow-strip-types@npm:^7.26.5":
+"@babel/plugin-transform-flow-strip-types@npm:^7.25.2, @babel/plugin-transform-flow-strip-types@npm:^7.26.5":
   version: 7.27.1
   resolution: "@babel/plugin-transform-flow-strip-types@npm:7.27.1"
   dependencies:
@@ -1073,7 +1057,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-function-name@npm:^7.0.0, @babel/plugin-transform-function-name@npm:^7.25.1, @babel/plugin-transform-function-name@npm:^7.27.1":
+"@babel/plugin-transform-function-name@npm:^7.25.1, @babel/plugin-transform-function-name@npm:^7.27.1":
   version: 7.27.1
   resolution: "@babel/plugin-transform-function-name@npm:7.27.1"
   dependencies:
@@ -1097,7 +1081,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-literals@npm:^7.0.0, @babel/plugin-transform-literals@npm:^7.25.2, @babel/plugin-transform-literals@npm:^7.27.1":
+"@babel/plugin-transform-literals@npm:^7.25.2, @babel/plugin-transform-literals@npm:^7.27.1":
   version: 7.27.1
   resolution: "@babel/plugin-transform-literals@npm:7.27.1"
   dependencies:
@@ -1142,7 +1126,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-modules-commonjs@npm:^7.0.0, @babel/plugin-transform-modules-commonjs@npm:^7.24.8, @babel/plugin-transform-modules-commonjs@npm:^7.27.1, @babel/plugin-transform-modules-commonjs@npm:^7.28.6":
+"@babel/plugin-transform-modules-commonjs@npm:^7.24.8, @babel/plugin-transform-modules-commonjs@npm:^7.27.1, @babel/plugin-transform-modules-commonjs@npm:^7.28.6":
   version: 7.28.6
   resolution: "@babel/plugin-transform-modules-commonjs@npm:7.28.6"
   dependencies:
@@ -1154,6 +1138,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-modules-commonjs@npm:^7.29.7":
+  version: 7.29.7
+  resolution: "@babel/plugin-transform-modules-commonjs@npm:7.29.7"
+  dependencies:
+    "@babel/helper-module-transforms": "npm:^7.29.7"
+    "@babel/helper-plugin-utils": "npm:^7.29.7"
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 10/7d816febde2d65bde5607ef355d751ba6c5a2d68ffe47c37b809e3ed2f829603751d4b5a5506f4299936d95fc73909243f9074f98dd32201277ec4131fc3ff33
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-modules-systemjs@npm:^7.29.0":
   version: 7.29.4
   resolution: "@babel/plugin-transform-modules-systemjs@npm:7.29.4"
@@ -1180,7 +1176,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-named-capturing-groups-regex@npm:^7.0.0, @babel/plugin-transform-named-capturing-groups-regex@npm:^7.24.7, @babel/plugin-transform-named-capturing-groups-regex@npm:^7.29.0":
+"@babel/plugin-transform-named-capturing-groups-regex@npm:^7.24.7, @babel/plugin-transform-named-capturing-groups-regex@npm:^7.29.0":
   version: 7.29.0
   resolution: "@babel/plugin-transform-named-capturing-groups-regex@npm:7.29.0"
   dependencies:
@@ -1203,7 +1199,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-nullish-coalescing-operator@npm:^7.24.7, @babel/plugin-transform-nullish-coalescing-operator@npm:^7.27.1, @babel/plugin-transform-nullish-coalescing-operator@npm:^7.28.6":
+"@babel/plugin-transform-nullish-coalescing-operator@npm:^7.24.7, @babel/plugin-transform-nullish-coalescing-operator@npm:^7.28.6":
   version: 7.28.6
   resolution: "@babel/plugin-transform-nullish-coalescing-operator@npm:7.28.6"
   dependencies:
@@ -1275,7 +1271,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-parameters@npm:^7.0.0, @babel/plugin-transform-parameters@npm:^7.20.7, @babel/plugin-transform-parameters@npm:^7.24.7, @babel/plugin-transform-parameters@npm:^7.27.7":
+"@babel/plugin-transform-parameters@npm:^7.24.7, @babel/plugin-transform-parameters@npm:^7.27.7":
   version: 7.27.7
   resolution: "@babel/plugin-transform-parameters@npm:7.27.7"
   dependencies:
@@ -1322,7 +1318,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-react-display-name@npm:^7.0.0, @babel/plugin-transform-react-display-name@npm:^7.24.7, @babel/plugin-transform-react-display-name@npm:^7.28.0":
+"@babel/plugin-transform-react-display-name@npm:^7.24.7, @babel/plugin-transform-react-display-name@npm:^7.28.0":
   version: 7.28.0
   resolution: "@babel/plugin-transform-react-display-name@npm:7.28.0"
   dependencies:
@@ -1344,7 +1340,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-react-jsx-self@npm:^7.0.0, @babel/plugin-transform-react-jsx-self@npm:^7.24.7":
+"@babel/plugin-transform-react-jsx-self@npm:^7.24.7":
   version: 7.27.1
   resolution: "@babel/plugin-transform-react-jsx-self@npm:7.27.1"
   dependencies:
@@ -1355,7 +1351,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-react-jsx-source@npm:^7.0.0, @babel/plugin-transform-react-jsx-source@npm:^7.24.7":
+"@babel/plugin-transform-react-jsx-source@npm:^7.24.7":
   version: 7.27.1
   resolution: "@babel/plugin-transform-react-jsx-source@npm:7.27.1"
   dependencies:
@@ -1366,7 +1362,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-react-jsx@npm:^7.0.0, @babel/plugin-transform-react-jsx@npm:^7.25.2, @babel/plugin-transform-react-jsx@npm:^7.27.1":
+"@babel/plugin-transform-react-jsx@npm:^7.25.2, @babel/plugin-transform-react-jsx@npm:^7.27.1":
   version: 7.28.6
   resolution: "@babel/plugin-transform-react-jsx@npm:7.28.6"
   dependencies:
@@ -1442,7 +1438,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-runtime@npm:^7.0.0, @babel/plugin-transform-runtime@npm:^7.24.7":
+"@babel/plugin-transform-runtime@npm:^7.24.7":
   version: 7.29.0
   resolution: "@babel/plugin-transform-runtime@npm:7.29.0"
   dependencies:
@@ -1458,7 +1454,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-shorthand-properties@npm:^7.0.0, @babel/plugin-transform-shorthand-properties@npm:^7.24.7, @babel/plugin-transform-shorthand-properties@npm:^7.27.1":
+"@babel/plugin-transform-shorthand-properties@npm:^7.24.7, @babel/plugin-transform-shorthand-properties@npm:^7.27.1":
   version: 7.27.1
   resolution: "@babel/plugin-transform-shorthand-properties@npm:7.27.1"
   dependencies:
@@ -1469,7 +1465,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-spread@npm:^7.0.0, @babel/plugin-transform-spread@npm:^7.24.7, @babel/plugin-transform-spread@npm:^7.28.6":
+"@babel/plugin-transform-spread@npm:^7.24.7, @babel/plugin-transform-spread@npm:^7.28.6":
   version: 7.28.6
   resolution: "@babel/plugin-transform-spread@npm:7.28.6"
   dependencies:
@@ -1481,7 +1477,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-sticky-regex@npm:^7.0.0, @babel/plugin-transform-sticky-regex@npm:^7.24.7, @babel/plugin-transform-sticky-regex@npm:^7.27.1":
+"@babel/plugin-transform-sticky-regex@npm:^7.24.7, @babel/plugin-transform-sticky-regex@npm:^7.27.1":
   version: 7.27.1
   resolution: "@babel/plugin-transform-sticky-regex@npm:7.27.1"
   dependencies:
@@ -1525,7 +1521,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-typescript@npm:^7.25.2, @babel/plugin-transform-typescript@npm:^7.28.5, @babel/plugin-transform-typescript@npm:^7.5.0":
+"@babel/plugin-transform-typescript@npm:^7.25.2, @babel/plugin-transform-typescript@npm:^7.28.5":
   version: 7.28.6
   resolution: "@babel/plugin-transform-typescript@npm:7.28.6"
   dependencies:
@@ -1540,6 +1536,21 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-typescript@npm:^7.29.7":
+  version: 7.29.7
+  resolution: "@babel/plugin-transform-typescript@npm:7.29.7"
+  dependencies:
+    "@babel/helper-annotate-as-pure": "npm:^7.29.7"
+    "@babel/helper-create-class-features-plugin": "npm:^7.29.7"
+    "@babel/helper-plugin-utils": "npm:^7.29.7"
+    "@babel/helper-skip-transparent-expression-wrappers": "npm:^7.29.7"
+    "@babel/plugin-syntax-typescript": "npm:^7.29.7"
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 10/88d39bcdfee418795ad65097fff88f491e87793b958fe334273a20f74693b64369456a6d666eb0f1e98c9ecb633c99bcccf90562593e64eb92cc9dd040f25c1c
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-unicode-escapes@npm:^7.27.1":
   version: 7.27.1
   resolution: "@babel/plugin-transform-unicode-escapes@npm:7.27.1"
@@ -1563,7 +1574,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-unicode-regex@npm:^7.0.0, @babel/plugin-transform-unicode-regex@npm:^7.24.7, @babel/plugin-transform-unicode-regex@npm:^7.27.1":
+"@babel/plugin-transform-unicode-regex@npm:^7.24.7, @babel/plugin-transform-unicode-regex@npm:^7.27.1":
   version: 7.27.1
   resolution: "@babel/plugin-transform-unicode-regex@npm:7.27.1"
   dependencies:
@@ -1587,7 +1598,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/preset-env@npm:^7.25.2, @babel/preset-env@npm:^7.25.3":
+"@babel/preset-env@npm:^7.25.2":
   version: 7.29.0
   resolution: "@babel/preset-env@npm:7.29.0"
   dependencies:
@@ -1696,7 +1707,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/preset-typescript@npm:^7.23.0, @babel/preset-typescript@npm:^7.24.7, @babel/preset-typescript@npm:^7.27.1":
+"@babel/preset-typescript@npm:^7.23.0, @babel/preset-typescript@npm:^7.24.7":
   version: 7.28.5
   resolution: "@babel/preset-typescript@npm:7.28.5"
   dependencies:
@@ -1711,6 +1722,21 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/preset-typescript@npm:^7.28.5":
+  version: 7.29.7
+  resolution: "@babel/preset-typescript@npm:7.29.7"
+  dependencies:
+    "@babel/helper-plugin-utils": "npm:^7.29.7"
+    "@babel/helper-validator-option": "npm:^7.29.7"
+    "@babel/plugin-syntax-jsx": "npm:^7.29.7"
+    "@babel/plugin-transform-modules-commonjs": "npm:^7.29.7"
+    "@babel/plugin-transform-typescript": "npm:^7.29.7"
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 10/487c5b5ee80afd656a8e6254c0638559fa4cd8d11b8d9ef9328cd5c403b8dfd1003690246910681de0f12e879d38fdf91aa2592f51ab9761e5197a3b36508919
+  languageName: node
+  linkType: hard
+
 "@babel/runtime@npm:^7.20.0, @babel/runtime@npm:^7.25.0":
   version: 7.28.6
   resolution: "@babel/runtime@npm:7.28.6"
@@ -1718,7 +1744,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/template@npm:^7.0.0, @babel/template@npm:^7.25.0, @babel/template@npm:^7.28.6, @babel/template@npm:^7.3.3":
+"@babel/template@npm:^7.25.0, @babel/template@npm:^7.28.6, @babel/template@npm:^7.3.3":
   version: 7.28.6
   resolution: "@babel/template@npm:7.28.6"
   dependencies:
@@ -1770,7 +1796,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/types@npm:^7.0.0, @babel/types@npm:^7.20.7, @babel/types@npm:^7.21.3, @babel/types@npm:^7.24.7, @babel/types@npm:^7.26.0, @babel/types@npm:^7.27.1, @babel/types@npm:^7.27.3, @babel/types@npm:^7.28.2, @babel/types@npm:^7.28.5, @babel/types@npm:^7.28.6, @babel/types@npm:^7.29.0, @babel/types@npm:^7.3.3, @babel/types@npm:^7.4.4":
+"@babel/types@npm:^7.0.0, @babel/types@npm:^7.20.7, @babel/types@npm:^7.26.0, @babel/types@npm:^7.27.1, @babel/types@npm:^7.27.3, @babel/types@npm:^7.28.2, @babel/types@npm:^7.28.5, @babel/types@npm:^7.28.6, @babel/types@npm:^7.29.0, @babel/types@npm:^7.3.3, @babel/types@npm:^7.4.4":
   version: 7.29.0
   resolution: "@babel/types@npm:7.29.0"
   dependencies:
@@ -1790,13 +1816,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@bcoe/v8-coverage@npm:^0.2.3":
-  version: 0.2.3
-  resolution: "@bcoe/v8-coverage@npm:0.2.3"
-  checksum: 10/1a1f0e356a3bb30b5f1ced6f79c413e6ebacf130421f15fac5fcd8be5ddf98aedb4404d7f5624e3285b700e041f9ef938321f3ca4d359d5b716f96afa120d88d
-  languageName: node
-  linkType: hard
-
 "@cspell/cspell-bundled-dicts@npm:8.19.4":
   version: 8.19.4
   resolution: "@cspell/cspell-bundled-dicts@npm:8.19.4"
@@ -2375,43 +2394,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@egjs/hammerjs@npm:^2.0.17":
-  version: 2.0.17
-  resolution: "@egjs/hammerjs@npm:2.0.17"
-  dependencies:
-    "@types/hammerjs": "npm:^2.0.36"
-  checksum: 10/f695129d45edfcfd6c5f2d1d36186da36ffade013991972ce23721a6b7ad7f214ce282abc4023e3f6b63062620852a63e897b523f247804afc7acd188fee9d9d
-  languageName: node
-  linkType: hard
-
-"@emnapi/core@npm:^1.4.3":
-  version: 1.8.1
-  resolution: "@emnapi/core@npm:1.8.1"
-  dependencies:
-    "@emnapi/wasi-threads": "npm:1.1.0"
-    tslib: "npm:^2.4.0"
-  checksum: 10/904ea60c91fc7d8aeb4a8f2c433b8cfb47c50618f2b6f37429fc5093c857c6381c60628a5cfbc3a7b0d75b0a288f21d4ed2d4533e82f92c043801ef255fd6a5c
-  languageName: node
-  linkType: hard
-
-"@emnapi/runtime@npm:^1.4.3":
-  version: 1.8.1
-  resolution: "@emnapi/runtime@npm:1.8.1"
-  dependencies:
-    tslib: "npm:^2.4.0"
-  checksum: 10/26725e202d4baefdc4a6ba770f703dfc80825a27c27a08c22bac1e1ce6f8f75c47b4fe9424d9b63239463c33ef20b650f08d710da18dfa1164a95e5acb865dba
-  languageName: node
-  linkType: hard
-
-"@emnapi/wasi-threads@npm:1.1.0":
-  version: 1.1.0
-  resolution: "@emnapi/wasi-threads@npm:1.1.0"
-  dependencies:
-    tslib: "npm:^2.4.0"
-  checksum: 10/0d557e75262d2f4c95cb2a456ba0785ef61f919ce488c1d76e5e3acfd26e00c753ef928cd80068363e0c166ba8cc0141305daf0f81aad5afcd421f38f11e0f4e
-  languageName: node
-  linkType: hard
-
 "@es-joy/jsdoccomment@npm:~0.84.0":
   version: 0.84.0
   resolution: "@es-joy/jsdoccomment@npm:0.84.0"
@@ -2484,13 +2466,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@expo-google-fonts/material-symbols@npm:^0.4.1":
-  version: 0.4.34
-  resolution: "@expo-google-fonts/material-symbols@npm:0.4.34"
-  checksum: 10/e7d3a27e0647c0841d908ecb87fb914dd75b2d4cc4c7dedbfd539bfb0e782f4db6cd52443c75f070bd2fe18b36e1f12dac5af4d6524f8dcf372bc73e22067f09
-  languageName: node
-  linkType: hard
-
 "@expo/cli@npm:^56.1.13":
   version: 56.1.13
   resolution: "@expo/cli@npm:56.1.13"
@@ -2567,82 +2542,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@expo/cli@npm:^56.1.14":
-  version: 56.1.14
-  resolution: "@expo/cli@npm:56.1.14"
-  dependencies:
-    "@expo/code-signing-certificates": "npm:^0.0.6"
-    "@expo/config": "npm:~56.0.9"
-    "@expo/config-plugins": "npm:~56.0.8"
-    "@expo/devcert": "npm:^1.2.1"
-    "@expo/env": "npm:~2.3.0"
-    "@expo/image-utils": "npm:^0.10.1"
-    "@expo/inline-modules": "npm:^0.0.11"
-    "@expo/json-file": "npm:^10.2.0"
-    "@expo/log-box": "npm:^56.0.12"
-    "@expo/metro": "npm:~56.0.0"
-    "@expo/metro-config": "npm:~56.0.13"
-    "@expo/metro-file-map": "npm:^56.0.3"
-    "@expo/osascript": "npm:^2.6.0"
-    "@expo/package-manager": "npm:^1.12.1"
-    "@expo/plist": "npm:^0.7.0"
-    "@expo/prebuild-config": "npm:^56.0.15"
-    "@expo/require-utils": "npm:^56.1.3"
-    "@expo/router-server": "npm:^56.0.13"
-    "@expo/schema-utils": "npm:^56.0.0"
-    "@expo/spawn-async": "npm:^1.8.0"
-    "@expo/ws-tunnel": "npm:^1.0.1"
-    "@expo/xcpretty": "npm:^4.4.4"
-    "@react-native/dev-middleware": "npm:0.85.3"
-    accepts: "npm:^1.3.8"
-    arg: "npm:^5.0.2"
-    bplist-creator: "npm:0.1.0"
-    bplist-parser: "npm:^0.3.1"
-    chalk: "npm:^4.0.0"
-    ci-info: "npm:^3.3.0"
-    compression: "npm:^1.7.4"
-    connect: "npm:^3.7.0"
-    debug: "npm:^4.3.4"
-    dnssd-advertise: "npm:^1.1.4"
-    expo-server: "npm:^56.0.5"
-    fetch-nodeshim: "npm:^0.4.10"
-    getenv: "npm:^2.0.0"
-    glob: "npm:^13.0.0"
-    lan-network: "npm:^0.2.1"
-    multitars: "npm:^1.0.0"
-    node-forge: "npm:^1.3.3"
-    npm-package-arg: "npm:^11.0.0"
-    ora: "npm:^3.4.0"
-    picomatch: "npm:^4.0.4"
-    pretty-format: "npm:^29.7.0"
-    progress: "npm:^2.0.3"
-    prompts: "npm:^2.3.2"
-    resolve-from: "npm:^5.0.0"
-    semver: "npm:^7.6.0"
-    send: "npm:^0.19.0"
-    slugify: "npm:^1.3.4"
-    stacktrace-parser: "npm:^0.1.10"
-    structured-headers: "npm:^0.4.1"
-    terminal-link: "npm:^2.1.1"
-    toqr: "npm:^0.1.1"
-    wrap-ansi: "npm:^7.0.0"
-    ws: "npm:^8.12.1"
-    zod: "npm:^3.25.76"
-  peerDependencies:
-    expo: "*"
-    expo-router: "*"
-    react-native: "*"
-  peerDependenciesMeta:
-    expo-router:
-      optional: true
-    react-native:
-      optional: true
-  bin:
-    expo-internal: main.js
-  checksum: 10/874b77e9036d7383d52fe020762a6c845b264180c359e26203ddf38101d08e629a0a8a2da4240ed937a70b5267f21565ddbcdb0d4e141aa542f18e608c50539f
-  languageName: node
-  linkType: hard
-
 "@expo/code-signing-certificates@npm:^0.0.6":
   version: 0.0.6
   resolution: "@expo/code-signing-certificates@npm:0.0.6"
@@ -2775,34 +2674,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@expo/fingerprint@npm:^0.19.4":
-  version: 0.19.4
-  resolution: "@expo/fingerprint@npm:0.19.4"
+"@expo/image-utils@npm:^0.10.1":
+  version: 0.10.1
+  resolution: "@expo/image-utils@npm:0.10.1"
   dependencies:
-    "@expo/env": "npm:^2.3.0"
+    "@expo/require-utils": "npm:^56.1.3"
     "@expo/spawn-async": "npm:^1.8.0"
-    arg: "npm:^5.0.2"
-    chalk: "npm:^4.1.2"
-    debug: "npm:^4.3.4"
-    getenv: "npm:^2.0.0"
-    glob: "npm:^13.0.0"
-    ignore: "npm:^5.3.1"
-    minimatch: "npm:^10.2.2"
-    resolve-from: "npm:^5.0.0"
-    semver: "npm:^7.6.0"
-  bin:
-    fingerprint: bin/cli.js
-  checksum: 10/fa56a2fcb87267def6911a4456a3afd2c01e3f905f941f9ddb16094252f6b6a016771e7b29ea0b56f5d1cf6aefcae8c80916f36518baafafacd4ff9baf4642a8
-  languageName: node
-  linkType: hard
-
-"@expo/image-utils@npm:^0.10.1":
-  version: 0.10.1
-  resolution: "@expo/image-utils@npm:0.10.1"
-  dependencies:
-    "@expo/require-utils": "npm:^56.1.3"
-    "@expo/spawn-async": "npm:^1.8.0"
-    chalk: "npm:^4.0.0"
+    chalk: "npm:^4.0.0"
     getenv: "npm:^2.0.0"
     jimp-compact: "npm:0.16.1"
     parse-png: "npm:^2.1.0"
@@ -2820,15 +2698,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@expo/inline-modules@npm:^0.0.11":
-  version: 0.0.11
-  resolution: "@expo/inline-modules@npm:0.0.11"
-  dependencies:
-    "@expo/config-plugins": "npm:~56.0.8"
-  checksum: 10/bb352924ca987b3ba18452b64c4cbea908f0438fc99de7523ec2be9711009cc044fad523639bf51bc6bb9a95fbb576aafee52719f7f142b41979824811d71f10
-  languageName: node
-  linkType: hard
-
 "@expo/json-file@npm:^10.2.0, @expo/json-file@npm:~10.2.0":
   version: 10.2.0
   resolution: "@expo/json-file@npm:10.2.0"
@@ -2849,7 +2718,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@expo/log-box@npm:^56.0.12, @expo/log-box@npm:~56.0.12":
+"@expo/log-box@npm:^56.0.12":
   version: 56.0.12
   resolution: "@expo/log-box@npm:56.0.12"
   dependencies:
@@ -2916,50 +2785,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@expo/metro-runtime@npm:^56.0.13":
-  version: 56.0.13
-  resolution: "@expo/metro-runtime@npm:56.0.13"
-  dependencies:
-    "@expo/log-box": "npm:^56.0.12"
-    anser: "npm:^1.4.9"
-    pretty-format: "npm:^29.7.0"
-    stacktrace-parser: "npm:^0.1.10"
-    whatwg-fetch: "npm:^3.0.0"
-  peerDependencies:
-    "@expo/log-box": ^56.0.12
-    expo: "*"
-    react: "*"
-    react-dom: "*"
-    react-native: "*"
-  peerDependenciesMeta:
-    react-dom:
-      optional: true
-  checksum: 10/a0b02c7a523a886e7b4e0b3d0034cd02383440e7f1f7c6d5d4f89d863f188259662feee27f54a128144bbf32fbacb6c1d7655abe18b4d8b6a7e9133abedf5474
-  languageName: node
-  linkType: hard
-
-"@expo/metro-runtime@npm:^56.0.14":
-  version: 56.0.14
-  resolution: "@expo/metro-runtime@npm:56.0.14"
-  dependencies:
-    "@expo/log-box": "npm:^56.0.12"
-    anser: "npm:^1.4.9"
-    pretty-format: "npm:^29.7.0"
-    stacktrace-parser: "npm:^0.1.10"
-    whatwg-fetch: "npm:^3.0.0"
-  peerDependencies:
-    "@expo/log-box": ^56.0.12
-    expo: "*"
-    react: "*"
-    react-dom: "*"
-    react-native: "*"
-  peerDependenciesMeta:
-    react-dom:
-      optional: true
-  checksum: 10/28bd77689c3a9752883855fea57e047b67bc174ac7a43e43b8675f651c4e731bb6602d9c4e3a53c28cfb7387b52268897164990303a7950fe57cc64242be9a23
-  languageName: node
-  linkType: hard
-
 "@expo/metro-runtime@npm:^6.1.2":
   version: 6.1.2
   resolution: "@expo/metro-runtime@npm:6.1.2"
@@ -3054,24 +2879,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@expo/prebuild-config@npm:^56.0.15":
-  version: 56.0.15
-  resolution: "@expo/prebuild-config@npm:56.0.15"
-  dependencies:
-    "@expo/config": "npm:~56.0.9"
-    "@expo/config-plugins": "npm:~56.0.8"
-    "@expo/config-types": "npm:^56.0.5"
-    "@expo/image-utils": "npm:^0.10.1"
-    "@expo/json-file": "npm:^10.2.0"
-    "@react-native/normalize-colors": "npm:0.85.3"
-    debug: "npm:^4.3.1"
-    expo-modules-autolinking: "npm:~56.0.15"
-    resolve-from: "npm:^5.0.0"
-    semver: "npm:^7.6.0"
-  checksum: 10/1ffdcd92b0bb25579e6a44b50ab85d589c7f5ca1bca187f65b9de0228f1f048d802866b67757cced08e33b8f3cd1e974b67840ea80c0d1297ddc65c960354a8c
-  languageName: node
-  linkType: hard
-
 "@expo/require-utils@npm:^56.1.3":
   version: 56.1.3
   resolution: "@expo/require-utils@npm:56.1.3"
@@ -3116,34 +2923,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@expo/router-server@npm:^56.0.13":
-  version: 56.0.13
-  resolution: "@expo/router-server@npm:56.0.13"
-  dependencies:
-    debug: "npm:^4.3.4"
-  peerDependencies:
-    "@expo/metro-runtime": ^56.0.14
-    expo: "*"
-    expo-constants: ^56.0.17
-    expo-font: ^56.0.5
-    expo-router: "*"
-    expo-server: ^56.0.5
-    react: "*"
-    react-dom: "*"
-    react-server-dom-webpack: ~19.0.1 || ~19.1.2 || ~19.2.1
-  peerDependenciesMeta:
-    "@expo/metro-runtime":
-      optional: true
-    expo-router:
-      optional: true
-    react-dom:
-      optional: true
-    react-server-dom-webpack:
-      optional: true
-  checksum: 10/370caebba936bc23e8bcc4555516a8954ffbe06c09596970449069f301f363b8a475650a8efebebda29b7545adc2e7a68c01a401c3c4f75170e2c51773ad8177
-  languageName: node
-  linkType: hard
-
 "@expo/schema-utils@npm:^0.1.8":
   version: 0.1.8
   resolution: "@expo/schema-utils@npm:0.1.8"
@@ -3181,71 +2960,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@expo/ui@npm:^56.0.15":
-  version: 56.0.15
-  resolution: "@expo/ui@npm:56.0.15"
-  dependencies:
-    sf-symbols-typescript: "npm:^2.1.0"
-    vaul: "npm:^1.1.2"
-  peerDependencies:
-    "@babel/core": "*"
-    expo: "*"
-    react: "*"
-    react-dom: "*"
-    react-native: "*"
-    react-native-reanimated: "*"
-    react-native-worklets: "*"
-  peerDependenciesMeta:
-    "@babel/core":
-      optional: true
-    react-dom:
-      optional: true
-    react-native-reanimated:
-      optional: true
-    react-native-worklets:
-      optional: true
-  checksum: 10/f19ba4ed5c76273d9abb4b8291fe4adba41da9423f80deb5e747554019dcf98e303f41bb598cba8d3ee6d3f4db617ced36dab85c8b931c3b190eaa917f0bc023
-  languageName: node
-  linkType: hard
-
-"@expo/ui@npm:^56.0.16":
-  version: 56.0.16
-  resolution: "@expo/ui@npm:56.0.16"
-  dependencies:
-    sf-symbols-typescript: "npm:^2.1.0"
-    vaul: "npm:^1.1.2"
-  peerDependencies:
-    "@babel/core": "*"
-    expo: "*"
-    react: "*"
-    react-dom: "*"
-    react-native: "*"
-    react-native-reanimated: "*"
-    react-native-worklets: "*"
-  peerDependenciesMeta:
-    "@babel/core":
-      optional: true
-    react-dom:
-      optional: true
-    react-native-reanimated:
-      optional: true
-    react-native-worklets:
-      optional: true
-  checksum: 10/802cd77ddf024e485060600d8bdbfb46a7bad0c68a0c2e69f11925fba797d3a07f8948c2e2e3e335e80710a2f63b354edeb1db7d24b5c0bcf7b7d94f17610384
-  languageName: node
-  linkType: hard
-
-"@expo/vector-icons@npm:^15.0.2":
-  version: 15.1.1
-  resolution: "@expo/vector-icons@npm:15.1.1"
-  peerDependencies:
-    expo-font: ">=14.0.4"
-    react: "*"
-    react-native: "*"
-  checksum: 10/204fafd5141c81bd55dd33f6c00cdc48ec1d37b6460be6fa3f851ccb235e1fad1097f22d034470daa49a5b839d058bbcadda1efd349c670c2fdce2ae65fb9bba
-  languageName: node
-  linkType: hard
-
 "@expo/ws-tunnel@npm:^1.0.1":
   version: 1.0.6
   resolution: "@expo/ws-tunnel@npm:1.0.6"
@@ -3275,29 +2989,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@hapi/hoek@npm:^9.0.0, @hapi/hoek@npm:^9.3.0":
-  version: 9.3.0
-  resolution: "@hapi/hoek@npm:9.3.0"
-  checksum: 10/ad83a223787749f3873bce42bd32a9a19673765bf3edece0a427e138859ff729469e68d5fdf9ff6bbee6fb0c8e21bab61415afa4584f527cfc40b59ea1957e70
-  languageName: node
-  linkType: hard
-
-"@hapi/topo@npm:^5.1.0":
-  version: 5.1.0
-  resolution: "@hapi/topo@npm:5.1.0"
-  dependencies:
-    "@hapi/hoek": "npm:^9.0.0"
-  checksum: 10/084bfa647015f4fd3fdd51fadb2747d09ef2f5e1443d6cbada2988b0c88494f85edf257ec606c790db146ac4e34ff57f3fcb22e3299b8e06ed5c87ba7583495c
-  languageName: node
-  linkType: hard
-
-"@huggingface/jinja@npm:^0.5.0":
-  version: 0.5.5
-  resolution: "@huggingface/jinja@npm:0.5.5"
-  checksum: 10/9575f8a689ab2c31f2540ea2dd82da2bcddb536196c3de3ae8f3b2fa06f01f47eb6a0513b410bbeac90fea7123733a15bf5d484f45fe3132bc16232a60f0dce3
-  languageName: node
-  linkType: hard
-
 "@humanwhocodes/config-array@npm:^0.13.0":
   version: 0.13.0
   resolution: "@humanwhocodes/config-array@npm:0.13.0"
@@ -3366,542 +3057,118 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@istanbuljs/schema@npm:^0.1.2, @istanbuljs/schema@npm:^0.1.3":
+"@istanbuljs/schema@npm:^0.1.2":
   version: 0.1.3
   resolution: "@istanbuljs/schema@npm:0.1.3"
   checksum: 10/a9b1e49acdf5efc2f5b2359f2df7f90c5c725f2656f16099e8b2cd3a000619ecca9fc48cf693ba789cf0fd989f6e0df6a22bc05574be4223ecdbb7997d04384b
   languageName: node
   linkType: hard
 
-"@jest/console@npm:30.2.0":
-  version: 30.2.0
-  resolution: "@jest/console@npm:30.2.0"
+"@jest/create-cache-key-function@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "@jest/create-cache-key-function@npm:29.7.0"
+  dependencies:
+    "@jest/types": "npm:^29.6.3"
+  checksum: 10/061ef63b13ec8c8e5d08e4456f03b5cf8c7f9c1cab4fed8402e1479153cafce6eea80420e308ef62027abb7e29b825fcfa06551856bd021d98e92e381bf91723
+  languageName: node
+  linkType: hard
+
+"@jest/environment@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "@jest/environment@npm:29.7.0"
   dependencies:
-    "@jest/types": "npm:30.2.0"
+    "@jest/fake-timers": "npm:^29.7.0"
+    "@jest/types": "npm:^29.6.3"
     "@types/node": "npm:*"
-    chalk: "npm:^4.1.2"
-    jest-message-util: "npm:30.2.0"
-    jest-util: "npm:30.2.0"
-    slash: "npm:^3.0.0"
-  checksum: 10/7cda9793962afa5c7fcfdde0ff5012694683b17941ee3c6a55ea9fd9a02f1c51ec4b4c767b867e1226f85a26af1d0f0d72c6a344e34c5bc4300312ebffd6e50b
+    jest-mock: "npm:^29.7.0"
+  checksum: 10/90b5844a9a9d8097f2cf107b1b5e57007c552f64315da8c1f51217eeb0a9664889d3f145cdf8acf23a84f4d8309a6675e27d5b059659a004db0ea9546d1c81a8
   languageName: node
   linkType: hard
 
-"@jest/console@npm:^29.7.0":
+"@jest/fake-timers@npm:^29.7.0":
   version: 29.7.0
-  resolution: "@jest/console@npm:29.7.0"
+  resolution: "@jest/fake-timers@npm:29.7.0"
   dependencies:
     "@jest/types": "npm:^29.6.3"
+    "@sinonjs/fake-timers": "npm:^10.0.2"
     "@types/node": "npm:*"
-    chalk: "npm:^4.0.0"
     jest-message-util: "npm:^29.7.0"
+    jest-mock: "npm:^29.7.0"
     jest-util: "npm:^29.7.0"
-    slash: "npm:^3.0.0"
-  checksum: 10/4a80c750e8a31f344233cb9951dee9b77bf6b89377cb131f8b3cde07ff218f504370133a5963f6a786af4d2ce7f85642db206ff7a15f99fe58df4c38ac04899e
+  checksum: 10/9b394e04ffc46f91725ecfdff34c4e043eb7a16e1d78964094c9db3fde0b1c8803e45943a980e8c740d0a3d45661906de1416ca5891a538b0660481a3a828c27
   languageName: node
   linkType: hard
 
-"@jest/core@npm:30.2.0":
-  version: 30.2.0
-  resolution: "@jest/core@npm:30.2.0"
+"@jest/schemas@npm:^29.6.3":
+  version: 29.6.3
+  resolution: "@jest/schemas@npm:29.6.3"
   dependencies:
-    "@jest/console": "npm:30.2.0"
-    "@jest/pattern": "npm:30.0.1"
-    "@jest/reporters": "npm:30.2.0"
-    "@jest/test-result": "npm:30.2.0"
-    "@jest/transform": "npm:30.2.0"
-    "@jest/types": "npm:30.2.0"
-    "@types/node": "npm:*"
-    ansi-escapes: "npm:^4.3.2"
-    chalk: "npm:^4.1.2"
-    ci-info: "npm:^4.2.0"
-    exit-x: "npm:^0.2.2"
-    graceful-fs: "npm:^4.2.11"
-    jest-changed-files: "npm:30.2.0"
-    jest-config: "npm:30.2.0"
-    jest-haste-map: "npm:30.2.0"
-    jest-message-util: "npm:30.2.0"
-    jest-regex-util: "npm:30.0.1"
-    jest-resolve: "npm:30.2.0"
-    jest-resolve-dependencies: "npm:30.2.0"
-    jest-runner: "npm:30.2.0"
-    jest-runtime: "npm:30.2.0"
-    jest-snapshot: "npm:30.2.0"
-    jest-util: "npm:30.2.0"
-    jest-validate: "npm:30.2.0"
-    jest-watcher: "npm:30.2.0"
-    micromatch: "npm:^4.0.8"
-    pretty-format: "npm:30.2.0"
-    slash: "npm:^3.0.0"
-  peerDependencies:
-    node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
-  peerDependenciesMeta:
-    node-notifier:
-      optional: true
-  checksum: 10/6763bb1efd937778f009821cd94c3705d3c31a156258a224b8745c1e0887976683f5413745ffb361b526f0fa2692e36aaa963aa197cc77ba932cff9d6d28af9d
+    "@sinclair/typebox": "npm:^0.27.8"
+  checksum: 10/910040425f0fc93cd13e68c750b7885590b8839066dfa0cd78e7def07bbb708ad869381f725945d66f2284de5663bbecf63e8fdd856e2ae6e261ba30b1687e93
   languageName: node
   linkType: hard
 
-"@jest/core@npm:^29.7.0":
+"@jest/transform@npm:^29.7.0":
   version: 29.7.0
-  resolution: "@jest/core@npm:29.7.0"
+  resolution: "@jest/transform@npm:29.7.0"
   dependencies:
-    "@jest/console": "npm:^29.7.0"
-    "@jest/reporters": "npm:^29.7.0"
-    "@jest/test-result": "npm:^29.7.0"
-    "@jest/transform": "npm:^29.7.0"
+    "@babel/core": "npm:^7.11.6"
     "@jest/types": "npm:^29.6.3"
-    "@types/node": "npm:*"
-    ansi-escapes: "npm:^4.2.1"
+    "@jridgewell/trace-mapping": "npm:^0.3.18"
+    babel-plugin-istanbul: "npm:^6.1.1"
     chalk: "npm:^4.0.0"
-    ci-info: "npm:^3.2.0"
-    exit: "npm:^0.1.2"
+    convert-source-map: "npm:^2.0.0"
+    fast-json-stable-stringify: "npm:^2.1.0"
     graceful-fs: "npm:^4.2.9"
-    jest-changed-files: "npm:^29.7.0"
-    jest-config: "npm:^29.7.0"
     jest-haste-map: "npm:^29.7.0"
-    jest-message-util: "npm:^29.7.0"
     jest-regex-util: "npm:^29.6.3"
-    jest-resolve: "npm:^29.7.0"
-    jest-resolve-dependencies: "npm:^29.7.0"
-    jest-runner: "npm:^29.7.0"
-    jest-runtime: "npm:^29.7.0"
-    jest-snapshot: "npm:^29.7.0"
     jest-util: "npm:^29.7.0"
-    jest-validate: "npm:^29.7.0"
-    jest-watcher: "npm:^29.7.0"
     micromatch: "npm:^4.0.4"
-    pretty-format: "npm:^29.7.0"
+    pirates: "npm:^4.0.4"
     slash: "npm:^3.0.0"
-    strip-ansi: "npm:^6.0.0"
-  peerDependencies:
-    node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
-  peerDependenciesMeta:
-    node-notifier:
-      optional: true
-  checksum: 10/ab6ac2e562d083faac7d8152ec1cc4eccc80f62e9579b69ed40aedf7211a6b2d57024a6cd53c4e35fd051c39a236e86257d1d99ebdb122291969a0a04563b51e
+    write-file-atomic: "npm:^4.0.2"
+  checksum: 10/30f42293545ab037d5799c81d3e12515790bb58513d37f788ce32d53326d0d72ebf5b40f989e6896739aa50a5f77be44686e510966370d58511d5ad2637c68c1
   languageName: node
   linkType: hard
 
-"@jest/create-cache-key-function@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "@jest/create-cache-key-function@npm:29.7.0"
+"@jest/types@npm:^29.6.3":
+  version: 29.6.3
+  resolution: "@jest/types@npm:29.6.3"
   dependencies:
-    "@jest/types": "npm:^29.6.3"
-  checksum: 10/061ef63b13ec8c8e5d08e4456f03b5cf8c7f9c1cab4fed8402e1479153cafce6eea80420e308ef62027abb7e29b825fcfa06551856bd021d98e92e381bf91723
-  languageName: node
-  linkType: hard
-
-"@jest/diff-sequences@npm:30.0.1":
-  version: 30.0.1
-  resolution: "@jest/diff-sequences@npm:30.0.1"
-  checksum: 10/0ddb7c7ba92d6057a2ee51a9cfc2155b77cca707fe959167466ea02dcb0687018cc3c22b9622f25f3a417d6ad370e2d4dcfedf9f1410dc9c02954a7484423cc7
+    "@jest/schemas": "npm:^29.6.3"
+    "@types/istanbul-lib-coverage": "npm:^2.0.0"
+    "@types/istanbul-reports": "npm:^3.0.0"
+    "@types/node": "npm:*"
+    "@types/yargs": "npm:^17.0.8"
+    chalk: "npm:^4.0.0"
+  checksum: 10/f74bf512fd09bbe2433a2ad460b04668b7075235eea9a0c77d6a42222c10a79b9747dc2b2a623f140ed40d6865a2ed8f538f3cbb75169120ea863f29a7ed76cd
   languageName: node
   linkType: hard
 
-"@jest/environment@npm:30.2.0":
-  version: 30.2.0
-  resolution: "@jest/environment@npm:30.2.0"
+"@jridgewell/gen-mapping@npm:^0.3.12, @jridgewell/gen-mapping@npm:^0.3.13, @jridgewell/gen-mapping@npm:^0.3.5":
+  version: 0.3.13
+  resolution: "@jridgewell/gen-mapping@npm:0.3.13"
   dependencies:
-    "@jest/fake-timers": "npm:30.2.0"
-    "@jest/types": "npm:30.2.0"
-    "@types/node": "npm:*"
-    jest-mock: "npm:30.2.0"
-  checksum: 10/e168a4ff328980eb9fde5e43aea80807fd0b2dbd4579ae8f68a03415a1e58adf5661db298054fa2351c7cb2b5a74bf67b8ab996656cf5927d0b0d0b6e2c2966b
+    "@jridgewell/sourcemap-codec": "npm:^1.5.0"
+    "@jridgewell/trace-mapping": "npm:^0.3.24"
+  checksum: 10/902f8261dcf450b4af7b93f9656918e02eec80a2169e155000cb2059f90113dd98f3ccf6efc6072cee1dd84cac48cade51da236972d942babc40e4c23da4d62a
   languageName: node
   linkType: hard
 
-"@jest/environment@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "@jest/environment@npm:29.7.0"
+"@jridgewell/remapping@npm:^2.3.5":
+  version: 2.3.5
+  resolution: "@jridgewell/remapping@npm:2.3.5"
   dependencies:
-    "@jest/fake-timers": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
-    "@types/node": "npm:*"
-    jest-mock: "npm:^29.7.0"
-  checksum: 10/90b5844a9a9d8097f2cf107b1b5e57007c552f64315da8c1f51217eeb0a9664889d3f145cdf8acf23a84f4d8309a6675e27d5b059659a004db0ea9546d1c81a8
+    "@jridgewell/gen-mapping": "npm:^0.3.5"
+    "@jridgewell/trace-mapping": "npm:^0.3.24"
+  checksum: 10/c2bb01856e65b506d439455f28aceacf130d6c023d1d4e3b48705e88def3571753e1a887daa04b078b562316c92d26ce36408a60534bceca3f830aec88a339ad
   languageName: node
   linkType: hard
 
-"@jest/expect-utils@npm:30.2.0":
-  version: 30.2.0
-  resolution: "@jest/expect-utils@npm:30.2.0"
-  dependencies:
-    "@jest/get-type": "npm:30.1.0"
-  checksum: 10/f2442f1bceb3411240d0f16fd0074377211b4373d3b8b2dc28929e861b6527a6deb403a362c25afa511d933cda4dfbdc98d4a08eeb51ee4968f7cb0299562349
-  languageName: node
-  linkType: hard
-
-"@jest/expect-utils@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "@jest/expect-utils@npm:29.7.0"
-  dependencies:
-    jest-get-type: "npm:^29.6.3"
-  checksum: 10/ef8d379778ef574a17bde2801a6f4469f8022a46a5f9e385191dc73bb1fc318996beaed4513fbd7055c2847227a1bed2469977821866534593a6e52a281499ee
-  languageName: node
-  linkType: hard
-
-"@jest/expect@npm:30.2.0":
-  version: 30.2.0
-  resolution: "@jest/expect@npm:30.2.0"
-  dependencies:
-    expect: "npm:30.2.0"
-    jest-snapshot: "npm:30.2.0"
-  checksum: 10/d950d95a64d5c6a39d56171dabb8dbe59423096231bb4f21d8ee0019878e6626701ac9d782803dc2589e2799ed39704031f818533f8a3e571b57032eafa85d12
-  languageName: node
-  linkType: hard
-
-"@jest/expect@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "@jest/expect@npm:29.7.0"
-  dependencies:
-    expect: "npm:^29.7.0"
-    jest-snapshot: "npm:^29.7.0"
-  checksum: 10/fea6c3317a8da5c840429d90bfe49d928e89c9e89fceee2149b93a11b7e9c73d2f6e4d7cdf647163da938fc4e2169e4490be6bae64952902bc7a701033fd4880
-  languageName: node
-  linkType: hard
-
-"@jest/fake-timers@npm:30.2.0":
-  version: 30.2.0
-  resolution: "@jest/fake-timers@npm:30.2.0"
-  dependencies:
-    "@jest/types": "npm:30.2.0"
-    "@sinonjs/fake-timers": "npm:^13.0.0"
-    "@types/node": "npm:*"
-    jest-message-util: "npm:30.2.0"
-    jest-mock: "npm:30.2.0"
-    jest-util: "npm:30.2.0"
-  checksum: 10/c2df66576ba8049b07d5f239777243e21fcdaa09a446be1e55fac709d6273e2a926c1562e0372c3013142557ed9d386381624023549267a667b6e1b656e37fe6
-  languageName: node
-  linkType: hard
-
-"@jest/fake-timers@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "@jest/fake-timers@npm:29.7.0"
-  dependencies:
-    "@jest/types": "npm:^29.6.3"
-    "@sinonjs/fake-timers": "npm:^10.0.2"
-    "@types/node": "npm:*"
-    jest-message-util: "npm:^29.7.0"
-    jest-mock: "npm:^29.7.0"
-    jest-util: "npm:^29.7.0"
-  checksum: 10/9b394e04ffc46f91725ecfdff34c4e043eb7a16e1d78964094c9db3fde0b1c8803e45943a980e8c740d0a3d45661906de1416ca5891a538b0660481a3a828c27
-  languageName: node
-  linkType: hard
-
-"@jest/get-type@npm:30.1.0":
-  version: 30.1.0
-  resolution: "@jest/get-type@npm:30.1.0"
-  checksum: 10/e2a95fbb49ce2d15547db8af5602626caf9b05f62a5e583b4a2de9bd93a2bfe7175f9bbb2b8a5c3909ce261d467b6991d7265bb1d547cb60e7e97f571f361a70
-  languageName: node
-  linkType: hard
-
-"@jest/globals@npm:30.2.0":
-  version: 30.2.0
-  resolution: "@jest/globals@npm:30.2.0"
-  dependencies:
-    "@jest/environment": "npm:30.2.0"
-    "@jest/expect": "npm:30.2.0"
-    "@jest/types": "npm:30.2.0"
-    jest-mock: "npm:30.2.0"
-  checksum: 10/d4a331d3847cebb3acefe120350d8a6bb5517c1403de7cd2b4dc67be425f37ba0511beee77d6837b4da2d93a25a06d6f829ad7837da365fae45e1da57523525c
-  languageName: node
-  linkType: hard
-
-"@jest/globals@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "@jest/globals@npm:29.7.0"
-  dependencies:
-    "@jest/environment": "npm:^29.7.0"
-    "@jest/expect": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
-    jest-mock: "npm:^29.7.0"
-  checksum: 10/97dbb9459135693ad3a422e65ca1c250f03d82b2a77f6207e7fa0edd2c9d2015fbe4346f3dc9ebff1678b9d8da74754d4d440b7837497f8927059c0642a22123
-  languageName: node
-  linkType: hard
-
-"@jest/pattern@npm:30.0.1":
-  version: 30.0.1
-  resolution: "@jest/pattern@npm:30.0.1"
-  dependencies:
-    "@types/node": "npm:*"
-    jest-regex-util: "npm:30.0.1"
-  checksum: 10/afd03b4d3eadc9c9970cf924955dee47984a7e767901fe6fa463b17b246f0ddeec07b3e82c09715c54bde3c8abb92074160c0d79967bd23778724f184e7f5b7b
-  languageName: node
-  linkType: hard
-
-"@jest/reporters@npm:30.2.0":
-  version: 30.2.0
-  resolution: "@jest/reporters@npm:30.2.0"
-  dependencies:
-    "@bcoe/v8-coverage": "npm:^0.2.3"
-    "@jest/console": "npm:30.2.0"
-    "@jest/test-result": "npm:30.2.0"
-    "@jest/transform": "npm:30.2.0"
-    "@jest/types": "npm:30.2.0"
-    "@jridgewell/trace-mapping": "npm:^0.3.25"
-    "@types/node": "npm:*"
-    chalk: "npm:^4.1.2"
-    collect-v8-coverage: "npm:^1.0.2"
-    exit-x: "npm:^0.2.2"
-    glob: "npm:^10.3.10"
-    graceful-fs: "npm:^4.2.11"
-    istanbul-lib-coverage: "npm:^3.0.0"
-    istanbul-lib-instrument: "npm:^6.0.0"
-    istanbul-lib-report: "npm:^3.0.0"
-    istanbul-lib-source-maps: "npm:^5.0.0"
-    istanbul-reports: "npm:^3.1.3"
-    jest-message-util: "npm:30.2.0"
-    jest-util: "npm:30.2.0"
-    jest-worker: "npm:30.2.0"
-    slash: "npm:^3.0.0"
-    string-length: "npm:^4.0.2"
-    v8-to-istanbul: "npm:^9.0.1"
-  peerDependencies:
-    node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
-  peerDependenciesMeta:
-    node-notifier:
-      optional: true
-  checksum: 10/3848b59bf740c10c4e5c234dcc41c54adbd74932bf05d1d1582d09d86e9baa86ddaf3c43903505fd042ba1203c2889a732137d08058ce9dc0069ba33b5d5373d
-  languageName: node
-  linkType: hard
-
-"@jest/reporters@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "@jest/reporters@npm:29.7.0"
-  dependencies:
-    "@bcoe/v8-coverage": "npm:^0.2.3"
-    "@jest/console": "npm:^29.7.0"
-    "@jest/test-result": "npm:^29.7.0"
-    "@jest/transform": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
-    "@jridgewell/trace-mapping": "npm:^0.3.18"
-    "@types/node": "npm:*"
-    chalk: "npm:^4.0.0"
-    collect-v8-coverage: "npm:^1.0.0"
-    exit: "npm:^0.1.2"
-    glob: "npm:^7.1.3"
-    graceful-fs: "npm:^4.2.9"
-    istanbul-lib-coverage: "npm:^3.0.0"
-    istanbul-lib-instrument: "npm:^6.0.0"
-    istanbul-lib-report: "npm:^3.0.0"
-    istanbul-lib-source-maps: "npm:^4.0.0"
-    istanbul-reports: "npm:^3.1.3"
-    jest-message-util: "npm:^29.7.0"
-    jest-util: "npm:^29.7.0"
-    jest-worker: "npm:^29.7.0"
-    slash: "npm:^3.0.0"
-    string-length: "npm:^4.0.1"
-    strip-ansi: "npm:^6.0.0"
-    v8-to-istanbul: "npm:^9.0.1"
-  peerDependencies:
-    node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
-  peerDependenciesMeta:
-    node-notifier:
-      optional: true
-  checksum: 10/a17d1644b26dea14445cedd45567f4ba7834f980be2ef74447204e14238f121b50d8b858fde648083d2cd8f305f81ba434ba49e37a5f4237a6f2a61180cc73dc
-  languageName: node
-  linkType: hard
-
-"@jest/schemas@npm:30.0.5":
-  version: 30.0.5
-  resolution: "@jest/schemas@npm:30.0.5"
-  dependencies:
-    "@sinclair/typebox": "npm:^0.34.0"
-  checksum: 10/40df4db55d4aeed09d1c7e19caf23788309cea34490a1c5d584c913494195e698b9967e996afc27226cac6d76e7512fe73ae6b9584480695c60dd18a5459cdba
-  languageName: node
-  linkType: hard
-
-"@jest/schemas@npm:^29.6.3":
-  version: 29.6.3
-  resolution: "@jest/schemas@npm:29.6.3"
-  dependencies:
-    "@sinclair/typebox": "npm:^0.27.8"
-  checksum: 10/910040425f0fc93cd13e68c750b7885590b8839066dfa0cd78e7def07bbb708ad869381f725945d66f2284de5663bbecf63e8fdd856e2ae6e261ba30b1687e93
-  languageName: node
-  linkType: hard
-
-"@jest/snapshot-utils@npm:30.2.0":
-  version: 30.2.0
-  resolution: "@jest/snapshot-utils@npm:30.2.0"
-  dependencies:
-    "@jest/types": "npm:30.2.0"
-    chalk: "npm:^4.1.2"
-    graceful-fs: "npm:^4.2.11"
-    natural-compare: "npm:^1.4.0"
-  checksum: 10/6b30ab2b0682117e3ce775e70b5be1eb01e1ea53a74f12ac7090cd1a5f37e9b795cd8de83853afa7b4b799c96b1c482499aa993ca2034ea0679525d32b7f9625
-  languageName: node
-  linkType: hard
-
-"@jest/source-map@npm:30.0.1":
-  version: 30.0.1
-  resolution: "@jest/source-map@npm:30.0.1"
-  dependencies:
-    "@jridgewell/trace-mapping": "npm:^0.3.25"
-    callsites: "npm:^3.1.0"
-    graceful-fs: "npm:^4.2.11"
-  checksum: 10/161b27cdf8d9d80fd99374d55222b90478864c6990514be6ebee72b7184a034224c9aceed12c476f3a48d48601bf8ed2e0c047a5a81bd907dc192ebe71365ed4
-  languageName: node
-  linkType: hard
-
-"@jest/source-map@npm:^29.6.3":
-  version: 29.6.3
-  resolution: "@jest/source-map@npm:29.6.3"
-  dependencies:
-    "@jridgewell/trace-mapping": "npm:^0.3.18"
-    callsites: "npm:^3.0.0"
-    graceful-fs: "npm:^4.2.9"
-  checksum: 10/bcc5a8697d471396c0003b0bfa09722c3cd879ad697eb9c431e6164e2ea7008238a01a07193dfe3cbb48b1d258eb7251f6efcea36f64e1ebc464ea3c03ae2deb
-  languageName: node
-  linkType: hard
-
-"@jest/test-result@npm:30.2.0":
-  version: 30.2.0
-  resolution: "@jest/test-result@npm:30.2.0"
-  dependencies:
-    "@jest/console": "npm:30.2.0"
-    "@jest/types": "npm:30.2.0"
-    "@types/istanbul-lib-coverage": "npm:^2.0.6"
-    collect-v8-coverage: "npm:^1.0.2"
-  checksum: 10/f58f79c3c3ba6dd15325e05b0b5a300777cd8cc38327f622608b6fe849b1073ee9633e33d1e5d7ef5b97a1ce71543d0ad92674b7a279f53033143e8dd7c22959
-  languageName: node
-  linkType: hard
-
-"@jest/test-result@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "@jest/test-result@npm:29.7.0"
-  dependencies:
-    "@jest/console": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
-    "@types/istanbul-lib-coverage": "npm:^2.0.0"
-    collect-v8-coverage: "npm:^1.0.0"
-  checksum: 10/c073ab7dfe3c562bff2b8fee6cc724ccc20aa96bcd8ab48ccb2aa309b4c0c1923a9e703cea386bd6ae9b71133e92810475bb9c7c22328fc63f797ad3324ed189
-  languageName: node
-  linkType: hard
-
-"@jest/test-sequencer@npm:30.2.0":
-  version: 30.2.0
-  resolution: "@jest/test-sequencer@npm:30.2.0"
-  dependencies:
-    "@jest/test-result": "npm:30.2.0"
-    graceful-fs: "npm:^4.2.11"
-    jest-haste-map: "npm:30.2.0"
-    slash: "npm:^3.0.0"
-  checksum: 10/7923964b27048b2233858b32aa1b34d4dd9e404311626d944a706bcdcaa0b1585f43f2ffa3fa893ecbf133566f31ba2b79ab5eaaaf674b8558c6c7029ecbea5e
-  languageName: node
-  linkType: hard
-
-"@jest/test-sequencer@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "@jest/test-sequencer@npm:29.7.0"
-  dependencies:
-    "@jest/test-result": "npm:^29.7.0"
-    graceful-fs: "npm:^4.2.9"
-    jest-haste-map: "npm:^29.7.0"
-    slash: "npm:^3.0.0"
-  checksum: 10/4420c26a0baa7035c5419b0892ff8ffe9a41b1583ec54a10db3037cd46a7e29dd3d7202f8aa9d376e9e53be5f8b1bc0d16e1de6880a6d319b033b01dc4c8f639
-  languageName: node
-  linkType: hard
-
-"@jest/transform@npm:30.2.0":
-  version: 30.2.0
-  resolution: "@jest/transform@npm:30.2.0"
-  dependencies:
-    "@babel/core": "npm:^7.27.4"
-    "@jest/types": "npm:30.2.0"
-    "@jridgewell/trace-mapping": "npm:^0.3.25"
-    babel-plugin-istanbul: "npm:^7.0.1"
-    chalk: "npm:^4.1.2"
-    convert-source-map: "npm:^2.0.0"
-    fast-json-stable-stringify: "npm:^2.1.0"
-    graceful-fs: "npm:^4.2.11"
-    jest-haste-map: "npm:30.2.0"
-    jest-regex-util: "npm:30.0.1"
-    jest-util: "npm:30.2.0"
-    micromatch: "npm:^4.0.8"
-    pirates: "npm:^4.0.7"
-    slash: "npm:^3.0.0"
-    write-file-atomic: "npm:^5.0.1"
-  checksum: 10/c75d72d524c2a50ea6c05778a9b76a6e48bc228a3390896a6edd4416f7b4954ee0a07e229ed7b4949ce8889324b70034c784751e3fc455a25648bd8dcad17d0d
-  languageName: node
-  linkType: hard
-
-"@jest/transform@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "@jest/transform@npm:29.7.0"
-  dependencies:
-    "@babel/core": "npm:^7.11.6"
-    "@jest/types": "npm:^29.6.3"
-    "@jridgewell/trace-mapping": "npm:^0.3.18"
-    babel-plugin-istanbul: "npm:^6.1.1"
-    chalk: "npm:^4.0.0"
-    convert-source-map: "npm:^2.0.0"
-    fast-json-stable-stringify: "npm:^2.1.0"
-    graceful-fs: "npm:^4.2.9"
-    jest-haste-map: "npm:^29.7.0"
-    jest-regex-util: "npm:^29.6.3"
-    jest-util: "npm:^29.7.0"
-    micromatch: "npm:^4.0.4"
-    pirates: "npm:^4.0.4"
-    slash: "npm:^3.0.0"
-    write-file-atomic: "npm:^4.0.2"
-  checksum: 10/30f42293545ab037d5799c81d3e12515790bb58513d37f788ce32d53326d0d72ebf5b40f989e6896739aa50a5f77be44686e510966370d58511d5ad2637c68c1
-  languageName: node
-  linkType: hard
-
-"@jest/types@npm:30.2.0":
-  version: 30.2.0
-  resolution: "@jest/types@npm:30.2.0"
-  dependencies:
-    "@jest/pattern": "npm:30.0.1"
-    "@jest/schemas": "npm:30.0.5"
-    "@types/istanbul-lib-coverage": "npm:^2.0.6"
-    "@types/istanbul-reports": "npm:^3.0.4"
-    "@types/node": "npm:*"
-    "@types/yargs": "npm:^17.0.33"
-    chalk: "npm:^4.1.2"
-  checksum: 10/f50fcaea56f873a51d19254ab16762f2ea8ca88e3e08da2e496af5da2b67c322915a4fcd0153803cc05063ffe87ebef2ab4330e0a1b06ab984a26c916cbfc26b
-  languageName: node
-  linkType: hard
-
-"@jest/types@npm:^29.6.3":
-  version: 29.6.3
-  resolution: "@jest/types@npm:29.6.3"
-  dependencies:
-    "@jest/schemas": "npm:^29.6.3"
-    "@types/istanbul-lib-coverage": "npm:^2.0.0"
-    "@types/istanbul-reports": "npm:^3.0.0"
-    "@types/node": "npm:*"
-    "@types/yargs": "npm:^17.0.8"
-    chalk: "npm:^4.0.0"
-  checksum: 10/f74bf512fd09bbe2433a2ad460b04668b7075235eea9a0c77d6a42222c10a79b9747dc2b2a623f140ed40d6865a2ed8f538f3cbb75169120ea863f29a7ed76cd
-  languageName: node
-  linkType: hard
-
-"@jridgewell/gen-mapping@npm:^0.3.12, @jridgewell/gen-mapping@npm:^0.3.13, @jridgewell/gen-mapping@npm:^0.3.5":
-  version: 0.3.13
-  resolution: "@jridgewell/gen-mapping@npm:0.3.13"
-  dependencies:
-    "@jridgewell/sourcemap-codec": "npm:^1.5.0"
-    "@jridgewell/trace-mapping": "npm:^0.3.24"
-  checksum: 10/902f8261dcf450b4af7b93f9656918e02eec80a2169e155000cb2059f90113dd98f3ccf6efc6072cee1dd84cac48cade51da236972d942babc40e4c23da4d62a
-  languageName: node
-  linkType: hard
-
-"@jridgewell/remapping@npm:^2.3.5":
-  version: 2.3.5
-  resolution: "@jridgewell/remapping@npm:2.3.5"
-  dependencies:
-    "@jridgewell/gen-mapping": "npm:^0.3.5"
-    "@jridgewell/trace-mapping": "npm:^0.3.24"
-  checksum: 10/c2bb01856e65b506d439455f28aceacf130d6c023d1d4e3b48705e88def3571753e1a887daa04b078b562316c92d26ce36408a60534bceca3f830aec88a339ad
-  languageName: node
-  linkType: hard
-
-"@jridgewell/resolve-uri@npm:^3.1.0":
-  version: 3.1.2
-  resolution: "@jridgewell/resolve-uri@npm:3.1.2"
-  checksum: 10/97106439d750a409c22c8bff822d648f6a71f3aa9bc8e5129efdc36343cd3096ddc4eeb1c62d2fe48e9bdd4db37b05d4646a17114ecebd3bbcacfa2de51c3c1d
+"@jridgewell/resolve-uri@npm:^3.1.0":
+  version: 3.1.2
+  resolution: "@jridgewell/resolve-uri@npm:3.1.2"
+  checksum: 10/97106439d750a409c22c8bff822d648f6a71f3aa9bc8e5129efdc36343cd3096ddc4eeb1c62d2fe48e9bdd4db37b05d4646a17114ecebd3bbcacfa2de51c3c1d
   languageName: node
   linkType: hard
 
@@ -3922,7 +3189,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@jridgewell/trace-mapping@npm:^0.3.12, @jridgewell/trace-mapping@npm:^0.3.18, @jridgewell/trace-mapping@npm:^0.3.23, @jridgewell/trace-mapping@npm:^0.3.24, @jridgewell/trace-mapping@npm:^0.3.25, @jridgewell/trace-mapping@npm:^0.3.28":
+"@jridgewell/trace-mapping@npm:^0.3.18, @jridgewell/trace-mapping@npm:^0.3.24, @jridgewell/trace-mapping@npm:^0.3.25, @jridgewell/trace-mapping@npm:^0.3.28":
   version: 0.3.31
   resolution: "@jridgewell/trace-mapping@npm:0.3.31"
   dependencies:
@@ -3983,17 +3250,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@napi-rs/wasm-runtime@npm:^0.2.11":
-  version: 0.2.12
-  resolution: "@napi-rs/wasm-runtime@npm:0.2.12"
-  dependencies:
-    "@emnapi/core": "npm:^1.4.3"
-    "@emnapi/runtime": "npm:^1.4.3"
-    "@tybys/wasm-util": "npm:^0.10.0"
-  checksum: 10/5fd518182427980c28bc724adf06c5f32f9a8915763ef560b5f7d73607d30cd15ac86d0cbd2eb80d4cfab23fc80d0876d89ca36a9daadcb864bc00917c94187c
-  languageName: node
-  linkType: hard
-
 "@nicolo-ribaudo/eslint-scope-5-internals@npm:5.1.1-v1":
   version: 5.1.1-v1
   resolution: "@nicolo-ribaudo/eslint-scope-5-internals@npm:5.1.1-v1"
@@ -4003,13 +3259,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@nodable/entities@npm:^2.1.0":
-  version: 2.1.0
-  resolution: "@nodable/entities@npm:2.1.0"
-  checksum: 10/355c55e82aebe45d4b962d16530951df51e19e3e63a27ea61ad3260c0807064619b270b9c83db10e8394f42760abd5b7f7c5b5117678c4246ce8364a4aafc637
-  languageName: node
-  linkType: hard
-
 "@nodelib/fs.scandir@npm:2.1.5":
   version: 2.1.5
   resolution: "@nodelib/fs.scandir@npm:2.1.5"
@@ -4361,21 +3610,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@radix-ui/react-slot@npm:^1.2.0":
-  version: 1.2.4
-  resolution: "@radix-ui/react-slot@npm:1.2.4"
-  dependencies:
-    "@radix-ui/react-compose-refs": "npm:1.1.2"
-  peerDependencies:
-    "@types/react": "*"
-    react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
-  peerDependenciesMeta:
-    "@types/react":
-      optional: true
-  checksum: 10/b37e37455b92789758980359d73ab5a5f5d1c12af480c775519bd15c556b891642d472accf05b30d520751489ca74cdb8fd7866064abc7942f0437371be28e51
-  languageName: node
-  linkType: hard
-
 "@radix-ui/react-tabs@npm:^1.1.12":
   version: 1.1.13
   resolution: "@radix-ui/react-tabs@npm:1.1.13"
@@ -4474,394 +3708,34 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@react-native-community/cli-clean@npm:20.0.0":
-  version: 20.0.0
-  resolution: "@react-native-community/cli-clean@npm:20.0.0"
-  dependencies:
-    "@react-native-community/cli-tools": "npm:20.0.0"
-    chalk: "npm:^4.1.2"
-    execa: "npm:^5.0.0"
-    fast-glob: "npm:^3.3.2"
-  checksum: 10/56a261a83eb4fc60e81778659ace53997cc5d045fc09c7e7a3a991eaae60347a7349868bcc5b45db73d3234fc714fe6adbaf641669eddd94cfcfe1037dd616c1
+"@react-native/assets-registry@npm:0.81.5":
+  version: 0.81.5
+  resolution: "@react-native/assets-registry@npm:0.81.5"
+  checksum: 10/1ba7e8c4fcc0fa7984f8a0b2809cbcd5bd14d01810691016b1a9484273b8e9b9c3be38dd3aa9370f0a1042741347e9590361d90be0c82943ec24c35393276d93
   languageName: node
   linkType: hard
 
-"@react-native-community/cli-clean@npm:20.1.2":
-  version: 20.1.2
-  resolution: "@react-native-community/cli-clean@npm:20.1.2"
-  dependencies:
-    "@react-native-community/cli-tools": "npm:20.1.2"
-    execa: "npm:^5.0.0"
-    fast-glob: "npm:^3.3.2"
-    picocolors: "npm:^1.1.1"
-  checksum: 10/66580b22ac10ed87aa1a121f5226d1bf88e1d87864cf21bcafc2f450133b908f31e44c784e881cc4cbcccb1cfedcca22bad0f09e0951ed5bd13400b2b724f9c5
+"@react-native/assets-registry@npm:0.83.6":
+  version: 0.83.6
+  resolution: "@react-native/assets-registry@npm:0.83.6"
+  checksum: 10/9ae3c3a4d8831149ec1c96aff7a93392505c22b3bbbddc55d9fa9ae6ff3ea7a8d824fbb923b07f4bd185c74afbd1c9dbc53f7c3a1a161f902a9df91430595c4c
   languageName: node
   linkType: hard
 
-"@react-native-community/cli-config-android@npm:20.0.0":
-  version: 20.0.0
-  resolution: "@react-native-community/cli-config-android@npm:20.0.0"
-  dependencies:
-    "@react-native-community/cli-tools": "npm:20.0.0"
-    chalk: "npm:^4.1.2"
-    fast-glob: "npm:^3.3.2"
-    fast-xml-parser: "npm:^4.4.1"
-  checksum: 10/fbd897df48793b050429e77114b8fcf42364b8847a199873818977cb8102ce303bb3e4fbf1842fd66608d96409e27835111e19e80c670dc6067066e53d4c500f
+"@react-native/assets-registry@npm:0.85.3":
+  version: 0.85.3
+  resolution: "@react-native/assets-registry@npm:0.85.3"
+  checksum: 10/614892869515ec035b5e64c4ef310c6bd531bcd623941a40db08255e2b2ba7d988801092b5014a558af2e899388b63d1a818cf42dcb5d014bc87ec72dcc8d336
   languageName: node
   linkType: hard
 
-"@react-native-community/cli-config-android@npm:20.1.2":
-  version: 20.1.2
-  resolution: "@react-native-community/cli-config-android@npm:20.1.2"
-  dependencies:
-    "@react-native-community/cli-tools": "npm:20.1.2"
-    fast-glob: "npm:^3.3.2"
-    fast-xml-parser: "npm:^5.3.6"
-    picocolors: "npm:^1.1.1"
-  checksum: 10/873af8992640a7585322e01fb99870ddf8894cb69a30d11e2c3babd50c9039ab1c62b630e9a58bbe9249c332c4a66386e9d4250a4200b5f7a5be86635850d43d
-  languageName: node
-  linkType: hard
-
-"@react-native-community/cli-config-apple@npm:20.0.0":
-  version: 20.0.0
-  resolution: "@react-native-community/cli-config-apple@npm:20.0.0"
-  dependencies:
-    "@react-native-community/cli-tools": "npm:20.0.0"
-    chalk: "npm:^4.1.2"
-    execa: "npm:^5.0.0"
-    fast-glob: "npm:^3.3.2"
-  checksum: 10/7c4e01c894199db48c15265d6d336ece4e103bf23e282e09f08eaa9e03b2237e8dae659e41a2f5fe7f091c9b31f22b3756bdd0f92b8eb6483d279c71b7fc6c99
-  languageName: node
-  linkType: hard
-
-"@react-native-community/cli-config-apple@npm:20.1.2":
-  version: 20.1.2
-  resolution: "@react-native-community/cli-config-apple@npm:20.1.2"
-  dependencies:
-    "@react-native-community/cli-tools": "npm:20.1.2"
-    execa: "npm:^5.0.0"
-    fast-glob: "npm:^3.3.2"
-    picocolors: "npm:^1.1.1"
-  checksum: 10/262089e3ca1ba161fa1c4c1945b10a731a5c39db35f07e44c94d1fcf0676819d2eccfced3ec56f724efee31b7c1ff8d6c0b1842363575708f0cf86df5a4315e9
-  languageName: node
-  linkType: hard
-
-"@react-native-community/cli-config@npm:20.0.0":
-  version: 20.0.0
-  resolution: "@react-native-community/cli-config@npm:20.0.0"
-  dependencies:
-    "@react-native-community/cli-tools": "npm:20.0.0"
-    chalk: "npm:^4.1.2"
-    cosmiconfig: "npm:^9.0.0"
-    deepmerge: "npm:^4.3.0"
-    fast-glob: "npm:^3.3.2"
-    joi: "npm:^17.2.1"
-  checksum: 10/aaf5e5cb07105abe0eb179b2ed230f24546068780cee02986b5d71447f928f5bff0e2fbc84e02302cf60f2795da8fa919eb204da41f9421f2cfaec9dc53c98c7
-  languageName: node
-  linkType: hard
-
-"@react-native-community/cli-config@npm:20.1.2":
-  version: 20.1.2
-  resolution: "@react-native-community/cli-config@npm:20.1.2"
-  dependencies:
-    "@react-native-community/cli-tools": "npm:20.1.2"
-    cosmiconfig: "npm:^9.0.0"
-    deepmerge: "npm:^4.3.0"
-    fast-glob: "npm:^3.3.2"
-    joi: "npm:^17.2.1"
-    picocolors: "npm:^1.1.1"
-  checksum: 10/c43f19458c514c1108162238abb7f8b096156b6377841c6959d46a7fe6ffea170050a6e77c2eaf19800efd40b865297e8cc04043d38f881e6e36d62eccd81164
-  languageName: node
-  linkType: hard
-
-"@react-native-community/cli-doctor@npm:20.0.0":
-  version: 20.0.0
-  resolution: "@react-native-community/cli-doctor@npm:20.0.0"
-  dependencies:
-    "@react-native-community/cli-config": "npm:20.0.0"
-    "@react-native-community/cli-platform-android": "npm:20.0.0"
-    "@react-native-community/cli-platform-apple": "npm:20.0.0"
-    "@react-native-community/cli-platform-ios": "npm:20.0.0"
-    "@react-native-community/cli-tools": "npm:20.0.0"
-    chalk: "npm:^4.1.2"
-    command-exists: "npm:^1.2.8"
-    deepmerge: "npm:^4.3.0"
-    envinfo: "npm:^7.13.0"
-    execa: "npm:^5.0.0"
-    node-stream-zip: "npm:^1.9.1"
-    ora: "npm:^5.4.1"
-    semver: "npm:^7.5.2"
-    wcwidth: "npm:^1.0.1"
-    yaml: "npm:^2.2.1"
-  checksum: 10/c78de0b83287c1db03e780123a83c3f26a8883dc54b5b3a1c34e2d3ed1050e39fbf597b95d8899f878b5ef61a89e05493c62d644e84293008eb4da73a4feb2a8
-  languageName: node
-  linkType: hard
-
-"@react-native-community/cli-doctor@npm:20.1.2":
-  version: 20.1.2
-  resolution: "@react-native-community/cli-doctor@npm:20.1.2"
-  dependencies:
-    "@react-native-community/cli-config": "npm:20.1.2"
-    "@react-native-community/cli-platform-android": "npm:20.1.2"
-    "@react-native-community/cli-platform-apple": "npm:20.1.2"
-    "@react-native-community/cli-platform-ios": "npm:20.1.2"
-    "@react-native-community/cli-tools": "npm:20.1.2"
-    command-exists: "npm:^1.2.8"
-    deepmerge: "npm:^4.3.0"
-    envinfo: "npm:^7.13.0"
-    execa: "npm:^5.0.0"
-    node-stream-zip: "npm:^1.9.1"
-    ora: "npm:^5.4.1"
-    picocolors: "npm:^1.1.1"
-    semver: "npm:^7.5.2"
-    wcwidth: "npm:^1.0.1"
-    yaml: "npm:^2.2.1"
-  checksum: 10/6e02acff8a0dd27512a347124dbf68b37ac76f33ad05a46a19646acea1101c695167543553d3e8d8e3ce4e3181f04d73840937afde02245d9f4a7671d831ddaa
-  languageName: node
-  linkType: hard
-
-"@react-native-community/cli-platform-android@npm:20.0.0":
-  version: 20.0.0
-  resolution: "@react-native-community/cli-platform-android@npm:20.0.0"
-  dependencies:
-    "@react-native-community/cli-config-android": "npm:20.0.0"
-    "@react-native-community/cli-tools": "npm:20.0.0"
-    chalk: "npm:^4.1.2"
-    execa: "npm:^5.0.0"
-    logkitty: "npm:^0.7.1"
-  checksum: 10/a5b4da7a329e3723d4285f60b18068e78a18451cc948ef79088f1dfbfffc22413a7e94a3c3cc91aee27cf9438bb6b57212b5275e7e5d7af7db41011c4c628f12
-  languageName: node
-  linkType: hard
-
-"@react-native-community/cli-platform-android@npm:20.1.2":
-  version: 20.1.2
-  resolution: "@react-native-community/cli-platform-android@npm:20.1.2"
-  dependencies:
-    "@react-native-community/cli-config-android": "npm:20.1.2"
-    "@react-native-community/cli-tools": "npm:20.1.2"
-    execa: "npm:^5.0.0"
-    logkitty: "npm:^0.7.1"
-    picocolors: "npm:^1.1.1"
-  checksum: 10/ff3cd9bd288f4237abc3ab2675efa056feb63bef01d49b843a5ecc7d65bee377512aece43ee4f110c11485640fabded055b61df0149525dc91169dc80b8c7f6e
-  languageName: node
-  linkType: hard
-
-"@react-native-community/cli-platform-apple@npm:20.0.0":
-  version: 20.0.0
-  resolution: "@react-native-community/cli-platform-apple@npm:20.0.0"
-  dependencies:
-    "@react-native-community/cli-config-apple": "npm:20.0.0"
-    "@react-native-community/cli-tools": "npm:20.0.0"
-    chalk: "npm:^4.1.2"
-    execa: "npm:^5.0.0"
-    fast-xml-parser: "npm:^4.4.1"
-  checksum: 10/a1a4c0fcdf9e3c819e0804de2447aed230d1f16c36107728374121deda60acd644550c0f5aeb98f6cd25846da9e6358617c67aaf895eab6e9a81cff1030cf8dd
-  languageName: node
-  linkType: hard
-
-"@react-native-community/cli-platform-apple@npm:20.1.2":
-  version: 20.1.2
-  resolution: "@react-native-community/cli-platform-apple@npm:20.1.2"
-  dependencies:
-    "@react-native-community/cli-config-apple": "npm:20.1.2"
-    "@react-native-community/cli-tools": "npm:20.1.2"
-    execa: "npm:^5.0.0"
-    fast-xml-parser: "npm:^5.3.6"
-    picocolors: "npm:^1.1.1"
-  checksum: 10/b1d4409f8a081e94400acf41cfefa0c8663afdf8280598e7731a85a4f161f64f381e876fdace394baec0d72db716fb58aa1e18ce8eeacc37fc70c5a261ba71f6
-  languageName: node
-  linkType: hard
-
-"@react-native-community/cli-platform-ios@npm:20.0.0":
-  version: 20.0.0
-  resolution: "@react-native-community/cli-platform-ios@npm:20.0.0"
-  dependencies:
-    "@react-native-community/cli-platform-apple": "npm:20.0.0"
-  checksum: 10/c7fc89332a7cb9fa71c1c5d4fe928d39b0514c74fdcc85251a7a35344f1f5e9e3b4cd23a85a70ce447dded6e6552a5edfa848cf07d8b26127a0c3b05ce3e1768
-  languageName: node
-  linkType: hard
-
-"@react-native-community/cli-platform-ios@npm:20.1.2":
-  version: 20.1.2
-  resolution: "@react-native-community/cli-platform-ios@npm:20.1.2"
-  dependencies:
-    "@react-native-community/cli-platform-apple": "npm:20.1.2"
-  checksum: 10/711c5366a62a5dfd26fd987bab126ff958faf29e7e2bfab1d29c1c8dfc12be12c03d8291f2fefab4ea90836fe41e90f7bb626b6fa3a9d023cdc39f726aa34512
-  languageName: node
-  linkType: hard
-
-"@react-native-community/cli-server-api@npm:20.0.0":
-  version: 20.0.0
-  resolution: "@react-native-community/cli-server-api@npm:20.0.0"
-  dependencies:
-    "@react-native-community/cli-tools": "npm:20.0.0"
-    body-parser: "npm:^1.20.3"
-    compression: "npm:^1.7.1"
-    connect: "npm:^3.6.5"
-    errorhandler: "npm:^1.5.1"
-    nocache: "npm:^3.0.1"
-    open: "npm:^6.2.0"
-    pretty-format: "npm:^29.7.0"
-    serve-static: "npm:^1.13.1"
-    ws: "npm:^6.2.3"
-  checksum: 10/1d58c5a4a451c861db13065898f6c825b8c811fb37fa588fc76edede10d4899fd786055137339eda4033335db97630419017b4f843f4f36a1b00b37296710f47
-  languageName: node
-  linkType: hard
-
-"@react-native-community/cli-server-api@npm:20.1.2":
-  version: 20.1.2
-  resolution: "@react-native-community/cli-server-api@npm:20.1.2"
-  dependencies:
-    "@react-native-community/cli-tools": "npm:20.1.2"
-    body-parser: "npm:^2.2.2"
-    compression: "npm:^1.7.1"
-    connect: "npm:^3.6.5"
-    errorhandler: "npm:^1.5.1"
-    nocache: "npm:^3.0.1"
-    open: "npm:^6.2.0"
-    pretty-format: "npm:^29.7.0"
-    serve-static: "npm:^1.13.1"
-    strict-url-sanitise: "npm:0.0.1"
-    ws: "npm:^6.2.3"
-  checksum: 10/29447084fdc1a0b3f38a62bc781aa71877b835dd8ee5855d30237289350bb3daeb1a27ca9a3b0d97b86d0f85bddcd67c3907968fdaee7c2f5cc7cab72723d1d1
-  languageName: node
-  linkType: hard
-
-"@react-native-community/cli-tools@npm:20.0.0":
-  version: 20.0.0
-  resolution: "@react-native-community/cli-tools@npm:20.0.0"
-  dependencies:
-    "@vscode/sudo-prompt": "npm:^9.0.0"
-    appdirsjs: "npm:^1.2.4"
-    chalk: "npm:^4.1.2"
-    execa: "npm:^5.0.0"
-    find-up: "npm:^5.0.0"
-    launch-editor: "npm:^2.9.1"
-    mime: "npm:^2.4.1"
-    ora: "npm:^5.4.1"
-    prompts: "npm:^2.4.2"
-    semver: "npm:^7.5.2"
-  checksum: 10/5418844eb46e159d05d6ca4af38e054ffd157ae016576eed4d10bb3bdc345bdb8ca30e3cc5a27aff4a7a49727fd4b1da88f7855469ebbfbbdd042ad58951b764
-  languageName: node
-  linkType: hard
-
-"@react-native-community/cli-tools@npm:20.1.2":
-  version: 20.1.2
-  resolution: "@react-native-community/cli-tools@npm:20.1.2"
-  dependencies:
-    "@vscode/sudo-prompt": "npm:^9.0.0"
-    appdirsjs: "npm:^1.2.4"
-    execa: "npm:^5.0.0"
-    find-up: "npm:^5.0.0"
-    launch-editor: "npm:^2.9.1"
-    mime: "npm:^2.4.1"
-    ora: "npm:^5.4.1"
-    picocolors: "npm:^1.1.1"
-    prompts: "npm:^2.4.2"
-    semver: "npm:^7.5.2"
-  checksum: 10/6eeeeb38495c9f6636840da0ef564db99d6e69d7672dd4cdeff4b8cc128d00de56d2ea74c0c7fda6c743d1f0a642d481c44f6cdd38d8f57ccdd53e9608930bca
-  languageName: node
-  linkType: hard
-
-"@react-native-community/cli-types@npm:20.0.0":
-  version: 20.0.0
-  resolution: "@react-native-community/cli-types@npm:20.0.0"
-  dependencies:
-    joi: "npm:^17.2.1"
-  checksum: 10/b64b03ff09eb3952c37ba96544156f0b6ffa76e616361a48254e645f914beaa844943ff77ee1fba46445ef8b45f726109fc9ad249afb9d360602cb03db846368
-  languageName: node
-  linkType: hard
-
-"@react-native-community/cli-types@npm:20.1.2":
-  version: 20.1.2
-  resolution: "@react-native-community/cli-types@npm:20.1.2"
-  dependencies:
-    joi: "npm:^17.2.1"
-  checksum: 10/b40aaa3e5ccdad210f67760be01cff34760b7107c0afc93a394733317a88eca2a8b8490b977c8d74d98822d2c2117a1a7101c33105bcdd03277c071c7daca510
-  languageName: node
-  linkType: hard
-
-"@react-native-community/cli@npm:20.0.0":
-  version: 20.0.0
-  resolution: "@react-native-community/cli@npm:20.0.0"
-  dependencies:
-    "@react-native-community/cli-clean": "npm:20.0.0"
-    "@react-native-community/cli-config": "npm:20.0.0"
-    "@react-native-community/cli-doctor": "npm:20.0.0"
-    "@react-native-community/cli-server-api": "npm:20.0.0"
-    "@react-native-community/cli-tools": "npm:20.0.0"
-    "@react-native-community/cli-types": "npm:20.0.0"
-    chalk: "npm:^4.1.2"
-    commander: "npm:^9.4.1"
-    deepmerge: "npm:^4.3.0"
-    execa: "npm:^5.0.0"
-    find-up: "npm:^5.0.0"
-    fs-extra: "npm:^8.1.0"
-    graceful-fs: "npm:^4.1.3"
-    prompts: "npm:^2.4.2"
-    semver: "npm:^7.5.2"
-  bin:
-    rnc-cli: build/bin.js
-  checksum: 10/9f52dce4f6c25d414ba4549153b70daef7708f5603f88f90147c9ec4dd29118f62995294eb20cb3f7c4018367bda66dac344d25ed0e9ffaad6b62a94b29ba75b
-  languageName: node
-  linkType: hard
-
-"@react-native-community/cli@npm:latest":
-  version: 20.1.2
-  resolution: "@react-native-community/cli@npm:20.1.2"
-  dependencies:
-    "@react-native-community/cli-clean": "npm:20.1.2"
-    "@react-native-community/cli-config": "npm:20.1.2"
-    "@react-native-community/cli-doctor": "npm:20.1.2"
-    "@react-native-community/cli-server-api": "npm:20.1.2"
-    "@react-native-community/cli-tools": "npm:20.1.2"
-    "@react-native-community/cli-types": "npm:20.1.2"
-    commander: "npm:^9.4.1"
-    deepmerge: "npm:^4.3.0"
-    execa: "npm:^5.0.0"
-    find-up: "npm:^5.0.0"
-    fs-extra: "npm:^8.1.0"
-    graceful-fs: "npm:^4.1.3"
-    picocolors: "npm:^1.1.1"
-    prompts: "npm:^2.4.2"
-    semver: "npm:^7.5.2"
-  bin:
-    rnc-cli: build/bin.js
-  checksum: 10/85c0f4d2ca4dbbeb47f9439bf0da22abd18a39fccf2736dc47efcc47accbc377c32aa0b75408308fd47a60658e72266e2c645f7f9675a1faf5e4c7dc737c20a8
-  languageName: node
-  linkType: hard
-
-"@react-native-masked-view/masked-view@npm:^0.3.2":
-  version: 0.3.2
-  resolution: "@react-native-masked-view/masked-view@npm:0.3.2"
-  peerDependencies:
-    react: ">=16"
-    react-native: ">=0.57"
-  checksum: 10/04ffbc01083aa563ca1e2d7ef6759e7b326b8129f5bb1aa5f3142348adab06d5e321a400cf70a5434324dfa906add383f8214640697c48c9e5311b30bfea03d9
-  languageName: node
-  linkType: hard
-
-"@react-native/assets-registry@npm:0.81.5":
-  version: 0.81.5
-  resolution: "@react-native/assets-registry@npm:0.81.5"
-  checksum: 10/1ba7e8c4fcc0fa7984f8a0b2809cbcd5bd14d01810691016b1a9484273b8e9b9c3be38dd3aa9370f0a1042741347e9590361d90be0c82943ec24c35393276d93
-  languageName: node
-  linkType: hard
-
-"@react-native/assets-registry@npm:0.85.3":
-  version: 0.85.3
-  resolution: "@react-native/assets-registry@npm:0.85.3"
-  checksum: 10/614892869515ec035b5e64c4ef310c6bd531bcd623941a40db08255e2b2ba7d988801092b5014a558af2e899388b63d1a818cf42dcb5d014bc87ec72dcc8d336
-  languageName: node
-  linkType: hard
-
-"@react-native/babel-plugin-codegen@npm:0.81.5":
-  version: 0.81.5
-  resolution: "@react-native/babel-plugin-codegen@npm:0.81.5"
+"@react-native/babel-plugin-codegen@npm:0.83.6":
+  version: 0.83.6
+  resolution: "@react-native/babel-plugin-codegen@npm:0.83.6"
   dependencies:
     "@babel/traverse": "npm:^7.25.3"
-    "@react-native/codegen": "npm:0.81.5"
-  checksum: 10/e8a4bb4c0d6f79e1162aeadb45e0495cb7515f75adda35de77c2b21be345b0e0e45ff7c4710a0ea285b9a42a8354ac66995f7bb5e7fbb144dbff3c67e1b6c9c7
+    "@react-native/codegen": "npm:0.83.6"
+  checksum: 10/eef3f3fec061c51a7dc042da93fc6e1d9712256ea8d76fb1f1b9ad3813a3a4a3385d33f184cedf2a0adc76112024922510787067678ee52828c053ea8947a08a
   languageName: node
   linkType: hard
 
@@ -4875,9 +3749,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@react-native/babel-preset@npm:0.81.5":
-  version: 0.81.5
-  resolution: "@react-native/babel-preset@npm:0.81.5"
+"@react-native/babel-preset@npm:0.83.6":
+  version: 0.83.6
+  resolution: "@react-native/babel-preset@npm:0.83.6"
   dependencies:
     "@babel/core": "npm:^7.25.2"
     "@babel/plugin-proposal-export-default-from": "npm:^7.24.7"
@@ -4920,73 +3794,47 @@ __metadata:
     "@babel/plugin-transform-typescript": "npm:^7.25.2"
     "@babel/plugin-transform-unicode-regex": "npm:^7.24.7"
     "@babel/template": "npm:^7.25.0"
-    "@react-native/babel-plugin-codegen": "npm:0.81.5"
-    babel-plugin-syntax-hermes-parser: "npm:0.29.1"
+    "@react-native/babel-plugin-codegen": "npm:0.83.6"
+    babel-plugin-syntax-hermes-parser: "npm:0.32.0"
     babel-plugin-transform-flow-enums: "npm:^0.0.2"
     react-refresh: "npm:^0.14.0"
   peerDependencies:
     "@babel/core": "*"
-  checksum: 10/c077e01b093be9f93e08b36dd7bc425d897749f76f9a2912cff8589f9ad3e36be0d6b54542ec6fbf13bd4b87ff7648b17a275930c546665d7b8accf4c89b6ff3
+  checksum: 10/204cf777078649203c18b5ed5765577641312ab47dbaa4415bb3805ec928c0ef36177e3036984d4d44dc986477e3bf68a0b59642e67b2a121831acf25b286a30
   languageName: node
   linkType: hard
 
-"@react-native/babel-preset@npm:0.85.3":
-  version: 0.85.3
-  resolution: "@react-native/babel-preset@npm:0.85.3"
+"@react-native/codegen@npm:0.81.5":
+  version: 0.81.5
+  resolution: "@react-native/codegen@npm:0.81.5"
   dependencies:
     "@babel/core": "npm:^7.25.2"
-    "@babel/plugin-proposal-export-default-from": "npm:^7.24.7"
-    "@babel/plugin-syntax-dynamic-import": "npm:^7.8.3"
-    "@babel/plugin-syntax-export-default-from": "npm:^7.24.7"
-    "@babel/plugin-syntax-nullish-coalescing-operator": "npm:^7.8.3"
-    "@babel/plugin-syntax-optional-chaining": "npm:^7.8.3"
-    "@babel/plugin-transform-async-generator-functions": "npm:^7.25.4"
-    "@babel/plugin-transform-async-to-generator": "npm:^7.24.7"
-    "@babel/plugin-transform-block-scoping": "npm:^7.25.0"
-    "@babel/plugin-transform-class-properties": "npm:^7.25.4"
-    "@babel/plugin-transform-classes": "npm:^7.25.4"
-    "@babel/plugin-transform-destructuring": "npm:^7.24.8"
-    "@babel/plugin-transform-flow-strip-types": "npm:^7.25.2"
-    "@babel/plugin-transform-for-of": "npm:^7.24.7"
-    "@babel/plugin-transform-modules-commonjs": "npm:^7.24.8"
-    "@babel/plugin-transform-named-capturing-groups-regex": "npm:^7.24.7"
-    "@babel/plugin-transform-nullish-coalescing-operator": "npm:^7.24.7"
-    "@babel/plugin-transform-optional-catch-binding": "npm:^7.24.7"
-    "@babel/plugin-transform-optional-chaining": "npm:^7.24.8"
-    "@babel/plugin-transform-private-methods": "npm:^7.24.7"
-    "@babel/plugin-transform-private-property-in-object": "npm:^7.24.7"
-    "@babel/plugin-transform-react-display-name": "npm:^7.24.7"
-    "@babel/plugin-transform-react-jsx": "npm:^7.25.2"
-    "@babel/plugin-transform-react-jsx-self": "npm:^7.24.7"
-    "@babel/plugin-transform-react-jsx-source": "npm:^7.24.7"
-    "@babel/plugin-transform-regenerator": "npm:^7.24.7"
-    "@babel/plugin-transform-runtime": "npm:^7.24.7"
-    "@babel/plugin-transform-typescript": "npm:^7.25.2"
-    "@babel/plugin-transform-unicode-regex": "npm:^7.24.7"
-    "@react-native/babel-plugin-codegen": "npm:0.85.3"
-    babel-plugin-syntax-hermes-parser: "npm:0.33.3"
-    babel-plugin-transform-flow-enums: "npm:^0.0.2"
-    react-refresh: "npm:^0.14.0"
+    "@babel/parser": "npm:^7.25.3"
+    glob: "npm:^7.1.1"
+    hermes-parser: "npm:0.29.1"
+    invariant: "npm:^2.2.4"
+    nullthrows: "npm:^1.1.1"
+    yargs: "npm:^17.6.2"
   peerDependencies:
     "@babel/core": "*"
-  checksum: 10/0750392facf3e1e1439accb030d04a9dc3e0242a25b5a3938f31f2a4db1cfbc7e527c11e2673c21d52d993c54e6438044db623dabf1d0a40ded065b748677220
+  checksum: 10/eb162a2b4232e6b6a345a659688c488610ba918e40dc8e4a9d17ed4fd3e026ca8066825128533ea5955b0eb58b3af0f8beb813f188bc506d8989285572f5d34f
   languageName: node
   linkType: hard
 
-"@react-native/codegen@npm:0.81.5":
-  version: 0.81.5
-  resolution: "@react-native/codegen@npm:0.81.5"
+"@react-native/codegen@npm:0.83.6":
+  version: 0.83.6
+  resolution: "@react-native/codegen@npm:0.83.6"
   dependencies:
     "@babel/core": "npm:^7.25.2"
     "@babel/parser": "npm:^7.25.3"
     glob: "npm:^7.1.1"
-    hermes-parser: "npm:0.29.1"
+    hermes-parser: "npm:0.32.0"
     invariant: "npm:^2.2.4"
     nullthrows: "npm:^1.1.1"
     yargs: "npm:^17.6.2"
   peerDependencies:
     "@babel/core": "*"
-  checksum: 10/eb162a2b4232e6b6a345a659688c488610ba918e40dc8e4a9d17ed4fd3e026ca8066825128533ea5955b0eb58b3af0f8beb813f188bc506d8989285572f5d34f
+  checksum: 10/5f819725e455953b387ae098ab05da0950f790ab5337f1131c779895f0de576c4b491f1017b7ce10c3530e55566859d398386e0e65baaa19089c5c5edb430e37
   languageName: node
   linkType: hard
 
@@ -5030,6 +3878,29 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@react-native/community-cli-plugin@npm:0.83.6":
+  version: 0.83.6
+  resolution: "@react-native/community-cli-plugin@npm:0.83.6"
+  dependencies:
+    "@react-native/dev-middleware": "npm:0.83.6"
+    debug: "npm:^4.4.0"
+    invariant: "npm:^2.2.4"
+    metro: "npm:^0.83.6"
+    metro-config: "npm:^0.83.6"
+    metro-core: "npm:^0.83.6"
+    semver: "npm:^7.1.3"
+  peerDependencies:
+    "@react-native-community/cli": "*"
+    "@react-native/metro-config": "*"
+  peerDependenciesMeta:
+    "@react-native-community/cli":
+      optional: true
+    "@react-native/metro-config":
+      optional: true
+  checksum: 10/48ef4b15aa34d3b39217d8ce1b4508259f88da5526a08107cc92a38a07876c41cad09de1d8eb12955ac5e992b44492a071fd73b5a4315da8b1e9c276a349f479
+  languageName: node
+  linkType: hard
+
 "@react-native/community-cli-plugin@npm:0.85.3":
   version: 0.85.3
   resolution: "@react-native/community-cli-plugin@npm:0.85.3"
@@ -5060,6 +3931,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@react-native/debugger-frontend@npm:0.83.6":
+  version: 0.83.6
+  resolution: "@react-native/debugger-frontend@npm:0.83.6"
+  checksum: 10/d9f40d58e88f80fefca26cccd7e44637fe61a7f8bd68727b1b3a6f8070ef030c54f805fdc34dd67e6e214a1def8c835bed7e7b2d2e1b0d19c342fb733e0f9460
+  languageName: node
+  linkType: hard
+
 "@react-native/debugger-frontend@npm:0.85.3":
   version: 0.85.3
   resolution: "@react-native/debugger-frontend@npm:0.85.3"
@@ -5067,6 +3945,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@react-native/debugger-shell@npm:0.83.6":
+  version: 0.83.6
+  resolution: "@react-native/debugger-shell@npm:0.83.6"
+  dependencies:
+    cross-spawn: "npm:^7.0.6"
+    fb-dotslash: "npm:0.5.8"
+  checksum: 10/d4f2c3096b7a976f1881db60a6a8e66d7951662f311cb4b9cc368bc753cb3e15c29cfdb1d6bf0f975a102eba78c94994d62dea5fdb37ef1d04f50f865af57a0a
+  languageName: node
+  linkType: hard
+
 "@react-native/debugger-shell@npm:0.85.3":
   version: 0.85.3
   resolution: "@react-native/debugger-shell@npm:0.85.3"
@@ -5097,6 +3985,26 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@react-native/dev-middleware@npm:0.83.6":
+  version: 0.83.6
+  resolution: "@react-native/dev-middleware@npm:0.83.6"
+  dependencies:
+    "@isaacs/ttlcache": "npm:^1.4.1"
+    "@react-native/debugger-frontend": "npm:0.83.6"
+    "@react-native/debugger-shell": "npm:0.83.6"
+    chrome-launcher: "npm:^0.15.2"
+    chromium-edge-launcher: "npm:^0.2.0"
+    connect: "npm:^3.6.5"
+    debug: "npm:^4.4.0"
+    invariant: "npm:^2.2.4"
+    nullthrows: "npm:^1.1.1"
+    open: "npm:^7.0.3"
+    serve-static: "npm:^1.16.2"
+    ws: "npm:^7.5.10"
+  checksum: 10/16b9bd3f6219ca9584408d436a6d837ee81496ee2919a39b112820a145d237e143123a2ed0b810aa3004d62fdf9aad291ece7a31f282a95098ad5a0a76df4af2
+  languageName: node
+  linkType: hard
+
 "@react-native/dev-middleware@npm:0.85.3":
   version: 0.85.3
   resolution: "@react-native/dev-middleware@npm:0.85.3"
@@ -5117,29 +4025,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@react-native/eslint-config@npm:0.81.5":
-  version: 0.81.5
-  resolution: "@react-native/eslint-config@npm:0.81.5"
-  dependencies:
-    "@babel/core": "npm:^7.25.2"
-    "@babel/eslint-parser": "npm:^7.25.1"
-    "@react-native/eslint-plugin": "npm:0.81.5"
-    "@typescript-eslint/eslint-plugin": "npm:^7.1.1"
-    "@typescript-eslint/parser": "npm:^7.1.1"
-    eslint-config-prettier: "npm:^8.5.0"
-    eslint-plugin-eslint-comments: "npm:^3.2.0"
-    eslint-plugin-ft-flow: "npm:^2.0.1"
-    eslint-plugin-jest: "npm:^27.9.0"
-    eslint-plugin-react: "npm:^7.30.1"
-    eslint-plugin-react-hooks: "npm:^5.2.0"
-    eslint-plugin-react-native: "npm:^4.0.0"
-  peerDependencies:
-    eslint: ">=8"
-    prettier: ">=2"
-  checksum: 10/59b017aed747a177caa95672158188d0ce1eee3fb9b60bd73a51841f0f28abab56b4c9d4056bdf8d2469579207d8afab433b60290b8f6a0c3f949505464a316d
-  languageName: node
-  linkType: hard
-
 "@react-native/eslint-config@npm:^0.79.0":
   version: 0.79.7
   resolution: "@react-native/eslint-config@npm:0.79.7"
@@ -5170,13 +4055,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@react-native/eslint-plugin@npm:0.81.5":
-  version: 0.81.5
-  resolution: "@react-native/eslint-plugin@npm:0.81.5"
-  checksum: 10/57bea5be68fd90ac6e0b699fc0ce814e5cbda9f9319dfedb36b186e2d022102b44c9db7aed71464f8c631a5efa0af0bfc44d154c26f498a478feb29c4a0141f7
-  languageName: node
-  linkType: hard
-
 "@react-native/gradle-plugin@npm:0.81.5":
   version: 0.81.5
   resolution: "@react-native/gradle-plugin@npm:0.81.5"
@@ -5184,6 +4062,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@react-native/gradle-plugin@npm:0.83.6":
+  version: 0.83.6
+  resolution: "@react-native/gradle-plugin@npm:0.83.6"
+  checksum: 10/b2d83f8277edd931e0ff228698e1ec6aefffcd71fa93cf23b9564b5a72788e8fbccc13543eb89f9510781ae86e5041e517d5f8f3e04a5a48925580edb0ab12a0
+  languageName: node
+  linkType: hard
+
 "@react-native/gradle-plugin@npm:0.85.3":
   version: 0.85.3
   resolution: "@react-native/gradle-plugin@npm:0.85.3"
@@ -5198,6 +4083,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@react-native/js-polyfills@npm:0.83.6":
+  version: 0.83.6
+  resolution: "@react-native/js-polyfills@npm:0.83.6"
+  checksum: 10/455dd7f69ec7b187790c3a2db1bc128199cf340ea36702ebaaee87d37c20dbbcbf75c69c0c91e82f4b320af9bb7a70fe537b0842454f2add2040902edfdaf164
+  languageName: node
+  linkType: hard
+
 "@react-native/js-polyfills@npm:0.85.3":
   version: 0.85.3
   resolution: "@react-native/js-polyfills@npm:0.85.3"
@@ -5205,62 +4097,17 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@react-native/metro-babel-transformer@npm:0.81.5":
+"@react-native/normalize-colors@npm:0.81.5":
   version: 0.81.5
-  resolution: "@react-native/metro-babel-transformer@npm:0.81.5"
-  dependencies:
-    "@babel/core": "npm:^7.25.2"
-    "@react-native/babel-preset": "npm:0.81.5"
-    hermes-parser: "npm:0.29.1"
-    nullthrows: "npm:^1.1.1"
-  peerDependencies:
-    "@babel/core": "*"
-  checksum: 10/401cd5e396a0c04865164c8321c29c17b9cdfbfef5efdf771befb77f830fd28c0bafe116f6d51930e684372f37b4a47f143a404341780187ae9e9fab0da39af4
-  languageName: node
-  linkType: hard
-
-"@react-native/metro-babel-transformer@npm:0.85.3":
-  version: 0.85.3
-  resolution: "@react-native/metro-babel-transformer@npm:0.85.3"
-  dependencies:
-    "@babel/core": "npm:^7.25.2"
-    "@react-native/babel-preset": "npm:0.85.3"
-    hermes-parser: "npm:0.33.3"
-    nullthrows: "npm:^1.1.1"
-  peerDependencies:
-    "@babel/core": "*"
-  checksum: 10/114fe0708f01903956ad8684e7bbad717a8ea46f083e09f8eb3a67fada2f09dc0b56da5f7401bd31cf0d3bb8c007f7334396d049b80d3a3895d6e32a99ac32fe
-  languageName: node
-  linkType: hard
-
-"@react-native/metro-config@npm:0.81.5":
-  version: 0.81.5
-  resolution: "@react-native/metro-config@npm:0.81.5"
-  dependencies:
-    "@react-native/js-polyfills": "npm:0.81.5"
-    "@react-native/metro-babel-transformer": "npm:0.81.5"
-    metro-config: "npm:^0.83.1"
-    metro-runtime: "npm:^0.83.1"
-  checksum: 10/13af9cb8f743e8ae51fe0c77db4c61070ef31074b985911ad03b53ec79985f3ba261f1b0026bc62b1b070a3954c8928b73d2d956fc13bad6ece3699b3f5d7254
-  languageName: node
-  linkType: hard
-
-"@react-native/metro-config@npm:^0.85.3":
-  version: 0.85.3
-  resolution: "@react-native/metro-config@npm:0.85.3"
-  dependencies:
-    "@react-native/js-polyfills": "npm:0.85.3"
-    "@react-native/metro-babel-transformer": "npm:0.85.3"
-    metro-config: "npm:^0.84.3"
-    metro-runtime: "npm:^0.84.3"
-  checksum: 10/9a0af6d190df911b5e1b5b346b82e2dffeb6a703c832391e3f7b8bd1ac13751d5a2d7a0ef852cdae8b8474fee07783f49b9daa2a9e8b55c9539bd59f4dd609fc
+  resolution: "@react-native/normalize-colors@npm:0.81.5"
+  checksum: 10/9a703b228b0e694436385f4438a684599f3b4f1ea16e3eb06f02b3bc2f9e091e3a754b4d25f0ad43ed7169ef5658603b30d0d78ee6bef338939313f16d85f077
   languageName: node
   linkType: hard
 
-"@react-native/normalize-colors@npm:0.81.5":
-  version: 0.81.5
-  resolution: "@react-native/normalize-colors@npm:0.81.5"
-  checksum: 10/9a703b228b0e694436385f4438a684599f3b4f1ea16e3eb06f02b3bc2f9e091e3a754b4d25f0ad43ed7169ef5658603b30d0d78ee6bef338939313f16d85f077
+"@react-native/normalize-colors@npm:0.83.6":
+  version: 0.83.6
+  resolution: "@react-native/normalize-colors@npm:0.83.6"
+  checksum: 10/b59b27a7889293f1dce5fcfb12151e0927099c3446f0f603e1f2d5e90cb91634cbf5d0d4dc6d67ee7ada4680f3533e96845ec64084cc97944280faf94caa209c
   languageName: node
   linkType: hard
 
@@ -5271,13 +4118,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@react-native/typescript-config@npm:0.81.5":
-  version: 0.81.5
-  resolution: "@react-native/typescript-config@npm:0.81.5"
-  checksum: 10/fbcc83ec60d6820a0d5d86644c33284bba35aa3312fd9b620f50f3de5343ed3aac9808aa6915d2a1726f69bbe877c1b92452954e661a2fee16c60c1be88fc8c5
-  languageName: node
-  linkType: hard
-
 "@react-native/virtualized-lists@npm:0.81.5":
   version: 0.81.5
   resolution: "@react-native/virtualized-lists@npm:0.81.5"
@@ -5295,6 +4135,23 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@react-native/virtualized-lists@npm:0.83.6":
+  version: 0.83.6
+  resolution: "@react-native/virtualized-lists@npm:0.83.6"
+  dependencies:
+    invariant: "npm:^2.2.4"
+    nullthrows: "npm:^1.1.1"
+  peerDependencies:
+    "@types/react": ^19.2.0
+    react: "*"
+    react-native: "*"
+  peerDependenciesMeta:
+    "@types/react":
+      optional: true
+  checksum: 10/1f888e09f09a16071978fc7e2c7aa69a2a212fbaf82fae69e74ecd181d8aa0e878a3942e42557bf3dc73e8c93e0f98b7c52fe30836228b33803e3053e39fb1dc
+  languageName: node
+  linkType: hard
+
 "@react-native/virtualized-lists@npm:0.85.3":
   version: 0.85.3
   resolution: "@react-native/virtualized-lists@npm:0.85.3"
@@ -5347,64 +4204,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@react-navigation/core@npm:^7.17.2":
-  version: 7.17.2
-  resolution: "@react-navigation/core@npm:7.17.2"
-  dependencies:
-    "@react-navigation/routers": "npm:^7.5.3"
-    escape-string-regexp: "npm:^4.0.0"
-    fast-deep-equal: "npm:^3.1.3"
-    nanoid: "npm:^3.3.11"
-    query-string: "npm:^7.1.3"
-    react-is: "npm:^19.1.0"
-    use-latest-callback: "npm:^0.2.4"
-    use-sync-external-store: "npm:^1.5.0"
-  peerDependencies:
-    react: ">= 18.2.0"
-  checksum: 10/79d63f1e6f50a63bcaa21dd920a29fde2c88845e12dead83c9abf9ff3b837f993b9179685bcc6c7f21d4c2ccde60abfc57853e62b9dd397264455a867fd92ec3
-  languageName: node
-  linkType: hard
-
-"@react-navigation/drawer@npm:^7.9.4":
-  version: 7.9.9
-  resolution: "@react-navigation/drawer@npm:7.9.9"
-  dependencies:
-    "@react-navigation/elements": "npm:^2.9.15"
-    color: "npm:^4.2.3"
-    react-native-drawer-layout: "npm:^4.2.2"
-    use-latest-callback: "npm:^0.2.4"
-  peerDependencies:
-    "@react-navigation/native": ^7.2.2
-    react: ">= 18.2.0"
-    react-native: "*"
-    react-native-gesture-handler: ">= 2.0.0"
-    react-native-reanimated: ">= 2.0.0"
-    react-native-safe-area-context: ">= 4.0.0"
-    react-native-screens: ">= 4.0.0"
-  checksum: 10/61b03e33ee444b5714048cee96e45c9249e305c5796cd9098ccfd5c30c7838c5c5c72cfccc0681528c7e6f636a16843a31fcd58adbc58cc984e83bcea521b1b2
-  languageName: node
-  linkType: hard
-
-"@react-navigation/elements@npm:^2.9.15":
-  version: 2.9.15
-  resolution: "@react-navigation/elements@npm:2.9.15"
-  dependencies:
-    color: "npm:^4.2.3"
-    use-latest-callback: "npm:^0.2.4"
-    use-sync-external-store: "npm:^1.5.0"
-  peerDependencies:
-    "@react-native-masked-view/masked-view": ">= 0.2.0"
-    "@react-navigation/native": ^7.2.2
-    react: ">= 18.2.0"
-    react-native: "*"
-    react-native-safe-area-context: ">= 4.0.0"
-  peerDependenciesMeta:
-    "@react-native-masked-view/masked-view":
-      optional: true
-  checksum: 10/414e0fddc1a9fc7b857a7b351cfbc85cc964d5ff3ab6d1708be1853270ccc64e7cf55e680ab6b26320082f1e0fc0a3c7604977b5cd8298436568fe35ebde4827
-  languageName: node
-  linkType: hard
-
 "@react-navigation/elements@npm:^2.9.8":
   version: 2.9.8
   resolution: "@react-navigation/elements@npm:2.9.8"
@@ -5459,22 +4258,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@react-navigation/native@npm:^7.2.2":
-  version: 7.2.2
-  resolution: "@react-navigation/native@npm:7.2.2"
-  dependencies:
-    "@react-navigation/core": "npm:^7.17.2"
-    escape-string-regexp: "npm:^4.0.0"
-    fast-deep-equal: "npm:^3.1.3"
-    nanoid: "npm:^3.3.11"
-    use-latest-callback: "npm:^0.2.4"
-  peerDependencies:
-    react: ">= 18.2.0"
-    react-native: "*"
-  checksum: 10/83e8c4f9979378a932c7cce8106e2fde1774b5ff902e9da9b96e0a188183706a9e24bcfbd0f3e63fb5a5211617e66d69c8c0ee89696f93c12c1c4ed4998e9d00
-  languageName: node
-  linkType: hard
-
 "@react-navigation/routers@npm:^7.5.3":
   version: 7.5.3
   resolution: "@react-navigation/routers@npm:7.5.3"
@@ -5484,55 +4267,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@shopify/react-native-skia@npm:2.6.2":
-  version: 2.6.2
-  resolution: "@shopify/react-native-skia@npm:2.6.2"
-  dependencies:
-    canvaskit-wasm: "npm:0.41.0"
-    react-native-skia-android: "npm:147.1.0"
-    react-native-skia-apple-ios: "npm:147.1.0"
-    react-native-skia-apple-macos: "npm:147.1.0"
-    react-native-skia-apple-tvos: "npm:147.1.0"
-    react-reconciler: "npm:0.31.0"
-  peerDependencies:
-    react: ">=19.0"
-    react-native: ">=0.78"
-    react-native-reanimated: ">=3.19.1"
-  peerDependenciesMeta:
-    react-native:
-      optional: true
-    react-native-reanimated:
-      optional: true
-  bin:
-    install-skia: scripts/install-libs.js
-    setup-skia-web: scripts/setup-canvaskit.js
-  checksum: 10/cdcdb6058ec21d836f874a0a37b385448d06d4faadc8b5b134c1f37826bba04cf6aedbc9dea2d42cb79f0b1bfe7a692571f374c378614dfb84ae120366d1887b
-  languageName: node
-  linkType: hard
-
-"@sideway/address@npm:^4.1.5":
-  version: 4.1.5
-  resolution: "@sideway/address@npm:4.1.5"
-  dependencies:
-    "@hapi/hoek": "npm:^9.0.0"
-  checksum: 10/c4c73ac0339504f34e016d3a687118e7ddf197c1c968579572123b67b230be84caa705f0f634efdfdde7f2e07a6e0224b3c70665dc420d8bc95bf400cfc4c998
-  languageName: node
-  linkType: hard
-
-"@sideway/formula@npm:^3.0.1":
-  version: 3.0.1
-  resolution: "@sideway/formula@npm:3.0.1"
-  checksum: 10/8d3ee7f80df4e5204b2cbe92a2a711ca89684965a5c9eb3b316b7051212d3522e332a65a0bb2a07cc708fcd1d0b27fcb30f43ff0bcd5089d7006c7160a89eefe
-  languageName: node
-  linkType: hard
-
-"@sideway/pinpoint@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "@sideway/pinpoint@npm:2.0.0"
-  checksum: 10/1ed21800128b2b23280ba4c9db26c8ff6142b97a8683f17639fd7f2128aa09046461574800b30fb407afc5b663c2331795ccf3b654d4b38fa096e41a5c786bf8
-  languageName: node
-  linkType: hard
-
 "@sinclair/typebox@npm:^0.27.8":
   version: 0.27.10
   resolution: "@sinclair/typebox@npm:0.27.10"
@@ -5540,13 +4274,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@sinclair/typebox@npm:^0.34.0":
-  version: 0.34.48
-  resolution: "@sinclair/typebox@npm:0.34.48"
-  checksum: 10/186eebb338255db7cfd77c2f94be0ad91816c7b5ee994c3adb95e0474ae98b769574c2b6b1f26a81613d7148ed20b11e02528f4263d8d95e3ca8dcf8faaf5306
-  languageName: node
-  linkType: hard
-
 "@sindresorhus/base62@npm:^1.0.0":
   version: 1.0.0
   resolution: "@sindresorhus/base62@npm:1.0.0"
@@ -5554,7 +4281,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@sinonjs/commons@npm:^3.0.0, @sinonjs/commons@npm:^3.0.1":
+"@sindresorhus/merge-streams@npm:^2.1.0":
+  version: 2.3.0
+  resolution: "@sindresorhus/merge-streams@npm:2.3.0"
+  checksum: 10/798bcb53cd1ace9df84fcdd1ba86afdc9e0cd84f5758d26ae9b1eefd8e8887e5fc30051132b9e74daf01bb41fa5a2faf1369361f83d76a3b3d7ee938058fd71c
+  languageName: node
+  linkType: hard
+
+"@sinonjs/commons@npm:^3.0.0":
   version: 3.0.1
   resolution: "@sinonjs/commons@npm:3.0.1"
   dependencies:
@@ -5572,188 +4306,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@sinonjs/fake-timers@npm:^13.0.0":
-  version: 13.0.5
-  resolution: "@sinonjs/fake-timers@npm:13.0.5"
-  dependencies:
-    "@sinonjs/commons": "npm:^3.0.1"
-  checksum: 10/11ee417968fc4dce1896ab332ac13f353866075a9d2a88ed1f6258f17cc4f7d93e66031b51fcddb8c203aa4d53fd980b0ae18aba06269f4682164878a992ec3f
-  languageName: node
-  linkType: hard
-
-"@svgr/babel-plugin-add-jsx-attribute@npm:8.0.0":
-  version: 8.0.0
-  resolution: "@svgr/babel-plugin-add-jsx-attribute@npm:8.0.0"
-  peerDependencies:
-    "@babel/core": ^7.0.0-0
-  checksum: 10/3fc8e35d16f5abe0af5efe5851f27581225ac405d6a1ca44cda0df064cddfcc29a428c48c2e4bef6cebf627c9ac2f652a096030edb02cf5a120ce28d3c234710
-  languageName: node
-  linkType: hard
-
-"@svgr/babel-plugin-remove-jsx-attribute@npm:8.0.0":
-  version: 8.0.0
-  resolution: "@svgr/babel-plugin-remove-jsx-attribute@npm:8.0.0"
-  peerDependencies:
-    "@babel/core": ^7.0.0-0
-  checksum: 10/ff992893c6c4ac802713ba3a97c13be34e62e6d981c813af40daabcd676df68a72a61bd1e692bb1eda3587f1b1d700ea462222ae2153bb0f46886632d4f88d08
-  languageName: node
-  linkType: hard
-
-"@svgr/babel-plugin-remove-jsx-empty-expression@npm:8.0.0":
-  version: 8.0.0
-  resolution: "@svgr/babel-plugin-remove-jsx-empty-expression@npm:8.0.0"
-  peerDependencies:
-    "@babel/core": ^7.0.0-0
-  checksum: 10/0fb691b63a21bac00da3aa2dccec50d0d5a5b347ff408d60803b84410d8af168f2656e4ba1ee1f24dab0ae4e4af77901f2928752bb0434c1f6788133ec599ec8
-  languageName: node
-  linkType: hard
-
-"@svgr/babel-plugin-replace-jsx-attribute-value@npm:8.0.0":
-  version: 8.0.0
-  resolution: "@svgr/babel-plugin-replace-jsx-attribute-value@npm:8.0.0"
-  peerDependencies:
-    "@babel/core": ^7.0.0-0
-  checksum: 10/1edda65ef4f4dd8f021143c8ec276a08f6baa6f733b8e8ee2e7775597bf6b97afb47fdeefd579d6ae6c959fe2e634f55cd61d99377631212228c8cfb351b8921
-  languageName: node
-  linkType: hard
-
-"@svgr/babel-plugin-svg-dynamic-title@npm:8.0.0":
-  version: 8.0.0
-  resolution: "@svgr/babel-plugin-svg-dynamic-title@npm:8.0.0"
-  peerDependencies:
-    "@babel/core": ^7.0.0-0
-  checksum: 10/876cec891488992e6a9aebb8155e2bea4ec461b4718c51de36e988e00e271c6d9d01ef6be17b9effd44b2b3d7db0b41c161a5904a46ae6f38b26b387ad7f3709
-  languageName: node
-  linkType: hard
-
-"@svgr/babel-plugin-svg-em-dimensions@npm:8.0.0":
-  version: 8.0.0
-  resolution: "@svgr/babel-plugin-svg-em-dimensions@npm:8.0.0"
-  peerDependencies:
-    "@babel/core": ^7.0.0-0
-  checksum: 10/be0e2d391164428327d9ec469a52cea7d93189c6b0e2c290999e048f597d777852f701c64dca44cd45b31ed14a7f859520326e2e4ad7c3a4545d0aa235bc7e9a
-  languageName: node
-  linkType: hard
-
-"@svgr/babel-plugin-transform-react-native-svg@npm:8.1.0":
-  version: 8.1.0
-  resolution: "@svgr/babel-plugin-transform-react-native-svg@npm:8.1.0"
-  peerDependencies:
-    "@babel/core": ^7.0.0-0
-  checksum: 10/85b434a57572f53bd2b9f0606f253e1fcf57b4a8c554ec3f2d43ed17f50d8cae200cb3aaf1ec9d626e1456e8b135dce530ae047eb0bed6d4bf98a752d6640459
-  languageName: node
-  linkType: hard
-
-"@svgr/babel-plugin-transform-svg-component@npm:8.0.0":
-  version: 8.0.0
-  resolution: "@svgr/babel-plugin-transform-svg-component@npm:8.0.0"
-  peerDependencies:
-    "@babel/core": ^7.0.0-0
-  checksum: 10/86ca139c0be0e7df05f103c5f10874387ada1434ca0286584ba9cd367c259d74bf9c86700b856449f46cf674bd6f0cf18f8f034f6d3f0e2ce5e5435c25dbff4b
-  languageName: node
-  linkType: hard
-
-"@svgr/babel-preset@npm:8.1.0":
-  version: 8.1.0
-  resolution: "@svgr/babel-preset@npm:8.1.0"
-  dependencies:
-    "@svgr/babel-plugin-add-jsx-attribute": "npm:8.0.0"
-    "@svgr/babel-plugin-remove-jsx-attribute": "npm:8.0.0"
-    "@svgr/babel-plugin-remove-jsx-empty-expression": "npm:8.0.0"
-    "@svgr/babel-plugin-replace-jsx-attribute-value": "npm:8.0.0"
-    "@svgr/babel-plugin-svg-dynamic-title": "npm:8.0.0"
-    "@svgr/babel-plugin-svg-em-dimensions": "npm:8.0.0"
-    "@svgr/babel-plugin-transform-react-native-svg": "npm:8.1.0"
-    "@svgr/babel-plugin-transform-svg-component": "npm:8.0.0"
-  peerDependencies:
-    "@babel/core": ^7.0.0-0
-  checksum: 10/3a67930f080b8891e1e8e2595716b879c944d253112bae763dce59807ba23454d162216c8d66a0a0e3d4f38a649ecd6c387e545d1e1261dd69a68e9a3392ee08
-  languageName: node
-  linkType: hard
-
-"@svgr/core@npm:^8.1.0":
-  version: 8.1.0
-  resolution: "@svgr/core@npm:8.1.0"
-  dependencies:
-    "@babel/core": "npm:^7.21.3"
-    "@svgr/babel-preset": "npm:8.1.0"
-    camelcase: "npm:^6.2.0"
-    cosmiconfig: "npm:^8.1.3"
-    snake-case: "npm:^3.0.4"
-  checksum: 10/bc98cd5fc349ab9dcf0c13c2279164726d45878cdac8999090765379c6e897a1b24aca641c12a3c33f578d06f7a09252fb090962a4695c753fb02b627a56bfe6
-  languageName: node
-  linkType: hard
-
-"@svgr/hast-util-to-babel-ast@npm:8.0.0":
-  version: 8.0.0
-  resolution: "@svgr/hast-util-to-babel-ast@npm:8.0.0"
-  dependencies:
-    "@babel/types": "npm:^7.21.3"
-    entities: "npm:^4.4.0"
-  checksum: 10/243aa9c92d66aa3f1fc82851fe1fa376808a08fcc02719fed38ebfb4e25cf3e3c1282c185300c29953d047c36acb9e3ac588d46b0af55a3b7a5186a6badec8a9
-  languageName: node
-  linkType: hard
-
-"@svgr/plugin-jsx@npm:^8.1.0":
-  version: 8.1.0
-  resolution: "@svgr/plugin-jsx@npm:8.1.0"
-  dependencies:
-    "@babel/core": "npm:^7.21.3"
-    "@svgr/babel-preset": "npm:8.1.0"
-    "@svgr/hast-util-to-babel-ast": "npm:8.0.0"
-    svg-parser: "npm:^2.0.4"
-  peerDependencies:
-    "@svgr/core": "*"
-  checksum: 10/0418a9780753d3544912ee2dad5d2cf8d12e1ba74df8053651b3886aeda54d5f0f7d2dece0af5e0d838332c4f139a57f0dabaa3ca1afa4d1a765efce6a7656f2
-  languageName: node
-  linkType: hard
-
-"@svgr/plugin-svgo@npm:^8.1.0":
-  version: 8.1.0
-  resolution: "@svgr/plugin-svgo@npm:8.1.0"
-  dependencies:
-    cosmiconfig: "npm:^8.1.3"
-    deepmerge: "npm:^4.3.1"
-    svgo: "npm:^3.0.2"
-  peerDependencies:
-    "@svgr/core": "*"
-  checksum: 10/59d9d214cebaacca9ca71a561f463d8b7e5a68ca9443e4792a42d903acd52259b1790c0680bc6afecc3f00a255a6cbd7ea278a9f625bac443620ea58a590c2d0
-  languageName: node
-  linkType: hard
-
-"@testing-library/jest-dom@npm:^6.9.1":
-  version: 6.9.1
-  resolution: "@testing-library/jest-dom@npm:6.9.1"
-  dependencies:
-    "@adobe/css-tools": "npm:^4.4.0"
-    aria-query: "npm:^5.0.0"
-    css.escape: "npm:^1.5.1"
-    dom-accessibility-api: "npm:^0.6.3"
-    picocolors: "npm:^1.1.1"
-    redent: "npm:^3.0.0"
-  checksum: 10/409b4f519e4c68f4d31e3b0317338cc19098b9029513fca61aa2af8270086ae3956a1eaedd19bbce2d2c9e2cf9ff27a616c06556be7a26e101c0d529a0062233
-  languageName: node
-  linkType: hard
-
-"@testing-library/user-event@npm:^14.6.1":
-  version: 14.6.1
-  resolution: "@testing-library/user-event@npm:14.6.1"
-  peerDependencies:
-    "@testing-library/dom": ">=7.21.4"
-  checksum: 10/34b74fff56a0447731a94b40d4cf246deb8dbc1c1e3aec93acd1c3377a760bb062e979f1572bb34ec164ad28ee2a391744b42d0d6d6cc16c4ce527e5e09610e1
-  languageName: node
-  linkType: hard
-
-"@tybys/wasm-util@npm:^0.10.0":
-  version: 0.10.1
-  resolution: "@tybys/wasm-util@npm:0.10.1"
-  dependencies:
-    tslib: "npm:^2.4.0"
-  checksum: 10/7fe0d239397aebb002ac4855d30c197c06a05ea8df8511350a3a5b1abeefe26167c60eda8a5508337571161e4c4b53d7c1342296123f9607af8705369de9fa7f
-  languageName: node
-  linkType: hard
-
-"@types/babel__core@npm:*, @types/babel__core@npm:^7.1.14, @types/babel__core@npm:^7.20.5":
+"@types/babel__core@npm:^7.1.14":
   version: 7.20.5
   resolution: "@types/babel__core@npm:7.20.5"
   dependencies:
@@ -5819,14 +4372,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/hammerjs@npm:^2.0.36":
-  version: 2.0.46
-  resolution: "@types/hammerjs@npm:2.0.46"
-  checksum: 10/1b6502d668f45ca49fb488c01f7938d3aa75e989d70c64801c8feded7d659ca1a118f745c1b604d220efe344c93231767d5cc68c05e00e069c14539b6143cfd9
-  languageName: node
-  linkType: hard
-
-"@types/istanbul-lib-coverage@npm:*, @types/istanbul-lib-coverage@npm:^2.0.0, @types/istanbul-lib-coverage@npm:^2.0.1, @types/istanbul-lib-coverage@npm:^2.0.6":
+"@types/istanbul-lib-coverage@npm:*, @types/istanbul-lib-coverage@npm:^2.0.0":
   version: 2.0.6
   resolution: "@types/istanbul-lib-coverage@npm:2.0.6"
   checksum: 10/3feac423fd3e5449485afac999dcfcb3d44a37c830af898b689fadc65d26526460bedb889db278e0d4d815a670331796494d073a10ee6e3a6526301fe7415778
@@ -5842,7 +4388,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/istanbul-reports@npm:^3.0.0, @types/istanbul-reports@npm:^3.0.4":
+"@types/istanbul-reports@npm:^3.0.0":
   version: 3.0.4
   resolution: "@types/istanbul-reports@npm:3.0.4"
   dependencies:
@@ -5851,26 +4397,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/jest@npm:^29.5.13":
-  version: 29.5.14
-  resolution: "@types/jest@npm:29.5.14"
-  dependencies:
-    expect: "npm:^29.0.0"
-    pretty-format: "npm:^29.0.0"
-  checksum: 10/59ec7a9c4688aae8ee529316c43853468b6034f453d08a2e1064b281af9c81234cec986be796288f1bbb29efe943bc950e70c8fa8faae1e460d50e3cf9760f9b
-  languageName: node
-  linkType: hard
-
-"@types/jest@npm:^30.0.0":
-  version: 30.0.0
-  resolution: "@types/jest@npm:30.0.0"
-  dependencies:
-    expect: "npm:^30.0.0"
-    pretty-format: "npm:^30.0.0"
-  checksum: 10/cdeaa924c68b5233d9ff92861a89e7042df2b0f197633729bcf3a31e65bd4e9426e751c5665b5ac2de0b222b33f100a5502da22aefce3d2c62931c715e88f209
-  languageName: node
-  linkType: hard
-
 "@types/json-schema@npm:^7.0.9":
   version: 7.0.15
   resolution: "@types/json-schema@npm:7.0.15"
@@ -5912,26 +4438,25 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/react-refresh@npm:^0":
-  version: 0.14.7
-  resolution: "@types/react-refresh@npm:0.14.7"
+"@types/react@npm:^19.1.12":
+  version: 19.2.17
+  resolution: "@types/react@npm:19.2.17"
   dependencies:
-    "@types/babel__core": "npm:*"
     csstype: "npm:^3.2.2"
-  checksum: 10/c4eca39a4e6991ad637044294045824784a048cbf84c8972361c686af7c17a32ffb11e3a24be519f7961a6690fce4a92a8007e2a060197dca43b0b66eff56bc6
+  checksum: 10/8debb092bd0bb9c99176a31824c7587c27c775a6526b60060e7b9e8dc2af53aee2ffadc7a1e3845953792437db5699d34a9054e198c9d4e54a74728ff47c6725
   languageName: node
   linkType: hard
 
-"@types/react-test-renderer@npm:^19.1.0":
-  version: 19.1.0
-  resolution: "@types/react-test-renderer@npm:19.1.0"
+"@types/react@npm:~19.1.10":
+  version: 19.1.17
+  resolution: "@types/react@npm:19.1.17"
   dependencies:
-    "@types/react": "npm:*"
-  checksum: 10/2ef3aec0f2fd638902cda606d70c8531d66f8e8944334427986b99dcac9755ee60b700c5c3a19ac354680f9c45669e98077b84f79cac60e950bdb7d38aebffde
+    csstype: "npm:^3.0.2"
+  checksum: 10/b21d0ce3296e758e0bbbaa177bea0ed2d7c6a08810d3889d2e7777b2d7ff76d9454690b964883ce2c9d3da73412380dd6cff05794cbd54890e0ef1f3c4b4332d
   languageName: node
   linkType: hard
 
-"@types/react@npm:*, @types/react@npm:^19.1.0, @types/react@npm:~19.2.0, @types/react@npm:~19.2.14":
+"@types/react@npm:~19.2.0":
   version: 19.2.14
   resolution: "@types/react@npm:19.2.14"
   dependencies:
@@ -5940,15 +4465,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/react@npm:~19.1.10":
-  version: 19.1.17
-  resolution: "@types/react@npm:19.1.17"
-  dependencies:
-    csstype: "npm:^3.0.2"
-  checksum: 10/b21d0ce3296e758e0bbbaa177bea0ed2d7c6a08810d3889d2e7777b2d7ff76d9454690b964883ce2c9d3da73412380dd6cff05794cbd54890e0ef1f3c4b4332d
-  languageName: node
-  linkType: hard
-
 "@types/semver@npm:^7.3.12":
   version: 7.7.1
   resolution: "@types/semver@npm:7.7.1"
@@ -5956,7 +4472,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/stack-utils@npm:^2.0.0, @types/stack-utils@npm:^2.0.3":
+"@types/stack-utils@npm:^2.0.0":
   version: 2.0.3
   resolution: "@types/stack-utils@npm:2.0.3"
   checksum: 10/72576cc1522090fe497337c2b99d9838e320659ac57fa5560fcbdcbafcf5d0216c6b3a0a8a4ee4fdb3b1f5e3420aa4f6223ab57b82fef3578bec3206425c6cf5
@@ -5984,7 +4500,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/yargs@npm:^17.0.33, @types/yargs@npm:^17.0.8":
+"@types/yargs@npm:^17.0.8":
   version: 17.0.35
   resolution: "@types/yargs@npm:17.0.35"
   dependencies:
@@ -6188,155 +4704,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@unrs/resolver-binding-android-arm-eabi@npm:1.11.1":
-  version: 1.11.1
-  resolution: "@unrs/resolver-binding-android-arm-eabi@npm:1.11.1"
-  conditions: os=android & cpu=arm
-  languageName: node
-  linkType: hard
-
-"@unrs/resolver-binding-android-arm64@npm:1.11.1":
-  version: 1.11.1
-  resolution: "@unrs/resolver-binding-android-arm64@npm:1.11.1"
-  conditions: os=android & cpu=arm64
-  languageName: node
-  linkType: hard
-
-"@unrs/resolver-binding-darwin-arm64@npm:1.11.1":
-  version: 1.11.1
-  resolution: "@unrs/resolver-binding-darwin-arm64@npm:1.11.1"
-  conditions: os=darwin & cpu=arm64
-  languageName: node
-  linkType: hard
-
-"@unrs/resolver-binding-darwin-x64@npm:1.11.1":
-  version: 1.11.1
-  resolution: "@unrs/resolver-binding-darwin-x64@npm:1.11.1"
-  conditions: os=darwin & cpu=x64
-  languageName: node
-  linkType: hard
-
-"@unrs/resolver-binding-freebsd-x64@npm:1.11.1":
-  version: 1.11.1
-  resolution: "@unrs/resolver-binding-freebsd-x64@npm:1.11.1"
-  conditions: os=freebsd & cpu=x64
-  languageName: node
-  linkType: hard
-
-"@unrs/resolver-binding-linux-arm-gnueabihf@npm:1.11.1":
-  version: 1.11.1
-  resolution: "@unrs/resolver-binding-linux-arm-gnueabihf@npm:1.11.1"
-  conditions: os=linux & cpu=arm
-  languageName: node
-  linkType: hard
-
-"@unrs/resolver-binding-linux-arm-musleabihf@npm:1.11.1":
-  version: 1.11.1
-  resolution: "@unrs/resolver-binding-linux-arm-musleabihf@npm:1.11.1"
-  conditions: os=linux & cpu=arm
-  languageName: node
-  linkType: hard
-
-"@unrs/resolver-binding-linux-arm64-gnu@npm:1.11.1":
-  version: 1.11.1
-  resolution: "@unrs/resolver-binding-linux-arm64-gnu@npm:1.11.1"
-  conditions: os=linux & cpu=arm64 & libc=glibc
-  languageName: node
-  linkType: hard
-
-"@unrs/resolver-binding-linux-arm64-musl@npm:1.11.1":
-  version: 1.11.1
-  resolution: "@unrs/resolver-binding-linux-arm64-musl@npm:1.11.1"
-  conditions: os=linux & cpu=arm64 & libc=musl
-  languageName: node
-  linkType: hard
-
-"@unrs/resolver-binding-linux-ppc64-gnu@npm:1.11.1":
-  version: 1.11.1
-  resolution: "@unrs/resolver-binding-linux-ppc64-gnu@npm:1.11.1"
-  conditions: os=linux & cpu=ppc64 & libc=glibc
-  languageName: node
-  linkType: hard
-
-"@unrs/resolver-binding-linux-riscv64-gnu@npm:1.11.1":
-  version: 1.11.1
-  resolution: "@unrs/resolver-binding-linux-riscv64-gnu@npm:1.11.1"
-  conditions: os=linux & cpu=riscv64 & libc=glibc
-  languageName: node
-  linkType: hard
-
-"@unrs/resolver-binding-linux-riscv64-musl@npm:1.11.1":
-  version: 1.11.1
-  resolution: "@unrs/resolver-binding-linux-riscv64-musl@npm:1.11.1"
-  conditions: os=linux & cpu=riscv64 & libc=musl
-  languageName: node
-  linkType: hard
-
-"@unrs/resolver-binding-linux-s390x-gnu@npm:1.11.1":
-  version: 1.11.1
-  resolution: "@unrs/resolver-binding-linux-s390x-gnu@npm:1.11.1"
-  conditions: os=linux & cpu=s390x & libc=glibc
-  languageName: node
-  linkType: hard
-
-"@unrs/resolver-binding-linux-x64-gnu@npm:1.11.1":
-  version: 1.11.1
-  resolution: "@unrs/resolver-binding-linux-x64-gnu@npm:1.11.1"
-  conditions: os=linux & cpu=x64 & libc=glibc
-  languageName: node
-  linkType: hard
-
-"@unrs/resolver-binding-linux-x64-musl@npm:1.11.1":
-  version: 1.11.1
-  resolution: "@unrs/resolver-binding-linux-x64-musl@npm:1.11.1"
-  conditions: os=linux & cpu=x64 & libc=musl
-  languageName: node
-  linkType: hard
-
-"@unrs/resolver-binding-wasm32-wasi@npm:1.11.1":
-  version: 1.11.1
-  resolution: "@unrs/resolver-binding-wasm32-wasi@npm:1.11.1"
-  dependencies:
-    "@napi-rs/wasm-runtime": "npm:^0.2.11"
-  conditions: cpu=wasm32
-  languageName: node
-  linkType: hard
-
-"@unrs/resolver-binding-win32-arm64-msvc@npm:1.11.1":
-  version: 1.11.1
-  resolution: "@unrs/resolver-binding-win32-arm64-msvc@npm:1.11.1"
-  conditions: os=win32 & cpu=arm64
-  languageName: node
-  linkType: hard
-
-"@unrs/resolver-binding-win32-ia32-msvc@npm:1.11.1":
-  version: 1.11.1
-  resolution: "@unrs/resolver-binding-win32-ia32-msvc@npm:1.11.1"
-  conditions: os=win32 & cpu=ia32
-  languageName: node
-  linkType: hard
-
-"@unrs/resolver-binding-win32-x64-msvc@npm:1.11.1":
-  version: 1.11.1
-  resolution: "@unrs/resolver-binding-win32-x64-msvc@npm:1.11.1"
-  conditions: os=win32 & cpu=x64
-  languageName: node
-  linkType: hard
-
-"@vscode/sudo-prompt@npm:^9.0.0":
-  version: 9.3.2
-  resolution: "@vscode/sudo-prompt@npm:9.3.2"
-  checksum: 10/2eabbf59ba784c5828d9f45cde2ada83f51796d88dea05ed0c270a98545ad5f47c8d48e54c2ed335273ec75499e9700ee8b48f1d9bf2bb3e42050faf1070d8c3
-  languageName: node
-  linkType: hard
-
-"@webgpu/types@npm:0.1.21":
-  version: 0.1.21
-  resolution: "@webgpu/types@npm:0.1.21"
-  checksum: 10/73fc5f2bebb1abf084b146c26c237c6450747b8119cdf3733643ff90968f6e7790d0ae0ad6aa6dc7b0783a502571d348a76d22c8e8466b3b7f7c9ee956da7e5b
-  languageName: node
-  linkType: hard
-
 "@xmldom/xmldom@npm:^0.8.8":
   version: 0.8.13
   resolution: "@xmldom/xmldom@npm:0.8.13"
@@ -6360,7 +4727,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"accepts@npm:^1.3.8, accepts@npm:~1.3.8":
+"accepts@npm:^1.3.8":
   version: 1.3.8
   resolution: "accepts@npm:1.3.8"
   dependencies:
@@ -6434,7 +4801,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ansi-escapes@npm:^4.2.1, ansi-escapes@npm:^4.3.2":
+"ansi-escapes@npm:^4.2.1":
   version: 4.3.2
   resolution: "ansi-escapes@npm:4.3.2"
   dependencies:
@@ -6443,17 +4810,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ansi-fragments@npm:^0.2.1":
-  version: 0.2.1
-  resolution: "ansi-fragments@npm:0.2.1"
-  dependencies:
-    colorette: "npm:^1.0.7"
-    slice-ansi: "npm:^2.0.0"
-    strip-ansi: "npm:^5.0.0"
-  checksum: 10/2380829941c8884290f65ed0af9ed2e0449efc24d8d15d0bc451f0836f14a70076ddd1322dc2c60372874c4598228ca707edf578ed353f8054cfbf872a7ecac2
-  languageName: node
-  linkType: hard
-
 "ansi-regex@npm:^4.1.0":
   version: 4.1.1
   resolution: "ansi-regex@npm:4.1.1"
@@ -6475,7 +4831,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ansi-styles@npm:^3.2.0, ansi-styles@npm:^3.2.1":
+"ansi-styles@npm:^3.2.1":
   version: 3.2.1
   resolution: "ansi-styles@npm:3.2.1"
   dependencies:
@@ -6493,7 +4849,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ansi-styles@npm:^5.0.0, ansi-styles@npm:^5.2.0":
+"ansi-styles@npm:^5.0.0":
   version: 5.2.0
   resolution: "ansi-styles@npm:5.2.0"
   checksum: 10/d7f4e97ce0623aea6bc0d90dcd28881ee04cba06c570b97fd3391bd7a268eedfd9d5e2dd4fdcbdd82b8105df5faf6f24aaedc08eaf3da898e702db5948f63469
@@ -6507,7 +4863,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"anymatch@npm:^3.0.3, anymatch@npm:^3.1.3":
+"anymatch@npm:^3.0.3":
   version: 3.1.3
   resolution: "anymatch@npm:3.1.3"
   dependencies:
@@ -6517,13 +4873,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"appdirsjs@npm:^1.2.4":
-  version: 1.2.7
-  resolution: "appdirsjs@npm:1.2.7"
-  checksum: 10/8f6cb9cc18de2b38e2f5efddf764c5f0331aba4168ee28cb7370b98e1dc69316352b9a936acf4d628b4dcc510d77b1645ed4b68ab2231e302f835d35e11348d3
-  languageName: node
-  linkType: hard
-
 "are-docs-informative@npm:^0.0.2":
   version: 0.0.2
   resolution: "are-docs-informative@npm:0.0.2"
@@ -6563,13 +4912,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"aria-query@npm:^5.0.0":
-  version: 5.3.2
-  resolution: "aria-query@npm:5.3.2"
-  checksum: 10/b2fe9bc98bd401bc322ccb99717c1ae2aaf53ea0d468d6e7aebdc02fac736e4a99b46971ee05b783b08ade23c675b2d8b60e4a1222a95f6e27bc4d2a0bfdcc03
-  languageName: node
-  linkType: hard
-
 "arkregex@npm:0.0.5":
   version: 0.0.5
   resolution: "arkregex@npm:0.0.5"
@@ -6703,13 +5045,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"astral-regex@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "astral-regex@npm:1.0.0"
-  checksum: 10/93417fc0879531cd95ace2560a54df865c9461a3ac0714c60cbbaa5f1f85d2bee85489e78d82f70b911b71ac25c5f05fc5a36017f44c9bb33c701bee229ff848
-  languageName: node
-  linkType: hard
-
 "async-function@npm:^1.0.0":
   version: 1.0.0
   resolution: "async-function@npm:1.0.0"
@@ -6740,23 +5075,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"babel-jest@npm:30.2.0":
-  version: 30.2.0
-  resolution: "babel-jest@npm:30.2.0"
-  dependencies:
-    "@jest/transform": "npm:30.2.0"
-    "@types/babel__core": "npm:^7.20.5"
-    babel-plugin-istanbul: "npm:^7.0.1"
-    babel-preset-jest: "npm:30.2.0"
-    chalk: "npm:^4.1.2"
-    graceful-fs: "npm:^4.2.11"
-    slash: "npm:^3.0.0"
-  peerDependencies:
-    "@babel/core": ^7.11.0 || ^8.0.0-0
-  checksum: 10/4c7351a366cf8ac2b8a2e4e438867693eb9d83ed24c29c648da4576f700767aaf72a5d14337fc3f92c50b069f5025b26c7b89e3b7b867914b7cf8997fc15f095
-  languageName: node
-  linkType: hard
-
 "babel-jest@npm:^29.7.0":
   version: 29.7.0
   resolution: "babel-jest@npm:29.7.0"
@@ -6787,28 +5105,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"babel-plugin-istanbul@npm:^7.0.1":
-  version: 7.0.1
-  resolution: "babel-plugin-istanbul@npm:7.0.1"
-  dependencies:
-    "@babel/helper-plugin-utils": "npm:^7.0.0"
-    "@istanbuljs/load-nyc-config": "npm:^1.0.0"
-    "@istanbuljs/schema": "npm:^0.1.3"
-    istanbul-lib-instrument: "npm:^6.0.2"
-    test-exclude: "npm:^6.0.0"
-  checksum: 10/fe9f865f975aaa7a033de9ccb2b63fdcca7817266c5e98d3e02ac7ffd774c695093d215302796cb3770a71ef4574e7a9b298504c3c0c104cf4b48c8eda67b2a6
-  languageName: node
-  linkType: hard
-
-"babel-plugin-jest-hoist@npm:30.2.0":
-  version: 30.2.0
-  resolution: "babel-plugin-jest-hoist@npm:30.2.0"
-  dependencies:
-    "@types/babel__core": "npm:^7.20.5"
-  checksum: 10/360e87a9aa35f4cf208a10ba79e1821ea906f9e3399db2a9762cbc5076fd59f808e571d88b5b1106738d22e23f9ddefbb8137b2780b2abd401c8573b85c8a2f5
-  languageName: node
-  linkType: hard
-
 "babel-plugin-jest-hoist@npm:^29.6.3":
   version: 29.6.3
   resolution: "babel-plugin-jest-hoist@npm:29.6.3"
@@ -6894,6 +5190,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"babel-plugin-syntax-hermes-parser@npm:0.32.0":
+  version: 0.32.0
+  resolution: "babel-plugin-syntax-hermes-parser@npm:0.32.0"
+  dependencies:
+    hermes-parser: "npm:0.32.0"
+  checksum: 10/ec76abeefabf940e2d571db3b47d022a9be7602286133291e8e047d4855af6a8afc079e4631bc9a56209d751fad54b5199932a55753b1e2b56a719d20e2d5065
+  languageName: node
+  linkType: hard
+
 "babel-plugin-syntax-hermes-parser@npm:0.33.3, babel-plugin-syntax-hermes-parser@npm:^0.33.3":
   version: 0.33.3
   resolution: "babel-plugin-syntax-hermes-parser@npm:0.33.3"
@@ -6921,7 +5226,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"babel-preset-current-node-syntax@npm:^1.0.0, babel-preset-current-node-syntax@npm:^1.2.0":
+"babel-preset-current-node-syntax@npm:^1.0.0":
   version: 1.2.0
   resolution: "babel-preset-current-node-syntax@npm:1.2.0"
   dependencies:
@@ -7008,18 +5313,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"babel-preset-jest@npm:30.2.0":
-  version: 30.2.0
-  resolution: "babel-preset-jest@npm:30.2.0"
-  dependencies:
-    babel-plugin-jest-hoist: "npm:30.2.0"
-    babel-preset-current-node-syntax: "npm:^1.2.0"
-  peerDependencies:
-    "@babel/core": ^7.11.0 || ^8.0.0-beta.1
-  checksum: 10/f75e155a8cf63ea1c5ca942bf757b934427630a1eeafdf861e9117879b3367931fc521da3c41fd52f8d59d705d1093ffb46c9474b3fd4d765d194bea5659d7d9
-  languageName: node
-  linkType: hard
-
 "babel-preset-jest@npm:^29.6.3":
   version: 29.6.3
   resolution: "babel-preset-jest@npm:29.6.3"
@@ -7046,39 +5339,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"bare-rn@workspace:apps/bare-rn":
-  version: 0.0.0-use.local
-  resolution: "bare-rn@workspace:apps/bare-rn"
-  dependencies:
-    "@babel/core": "npm:^7.25.2"
-    "@babel/plugin-transform-export-namespace-from": "npm:^7.25.2"
-    "@babel/preset-env": "npm:^7.25.3"
-    "@babel/runtime": "npm:^7.25.0"
-    "@dr.pogodin/react-native-fs": "npm:^2.36.2"
-    "@kesha-antonov/react-native-background-downloader": "npm:^4.4.5"
-    "@react-native-community/cli": "npm:20.0.0"
-    "@react-native-community/cli-platform-android": "npm:20.0.0"
-    "@react-native-community/cli-platform-ios": "npm:20.0.0"
-    "@react-native/babel-preset": "npm:0.81.5"
-    "@react-native/eslint-config": "npm:0.81.5"
-    "@react-native/metro-config": "npm:0.81.5"
-    "@react-native/typescript-config": "npm:0.81.5"
-    "@types/jest": "npm:^29.5.13"
-    "@types/react": "npm:^19.1.0"
-    "@types/react-test-renderer": "npm:^19.1.0"
-    eslint: "npm:^8.19.0"
-    jest: "npm:^29.6.3"
-    prettier: "npm:2.8.8"
-    react: "npm:19.1.0"
-    react-native: "npm:0.81.5"
-    react-native-executorch: "workspace:*"
-    react-native-executorch-bare-resource-fetcher: "workspace:*"
-    react-native-safe-area-context: "npm:^5.5.2"
-    react-test-renderer: "npm:19.1.0"
-    typescript: "npm:^5.8.3"
-  languageName: unknown
-  linkType: soft
-
 "base64-js@npm:^1.3.1, base64-js@npm:^1.5.1":
   version: 1.5.1
   resolution: "base64-js@npm:1.5.1"
@@ -7109,61 +5369,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"bl@npm:^4.1.0":
-  version: 4.1.0
-  resolution: "bl@npm:4.1.0"
-  dependencies:
-    buffer: "npm:^5.5.0"
-    inherits: "npm:^2.0.4"
-    readable-stream: "npm:^3.4.0"
-  checksum: 10/b7904e66ed0bdfc813c06ea6c3e35eafecb104369dbf5356d0f416af90c1546de3b74e5b63506f0629acf5e16a6f87c3798f16233dcff086e9129383aa02ab55
-  languageName: node
-  linkType: hard
-
-"body-parser@npm:^1.20.3":
-  version: 1.20.4
-  resolution: "body-parser@npm:1.20.4"
-  dependencies:
-    bytes: "npm:~3.1.2"
-    content-type: "npm:~1.0.5"
-    debug: "npm:2.6.9"
-    depd: "npm:2.0.0"
-    destroy: "npm:~1.2.0"
-    http-errors: "npm:~2.0.1"
-    iconv-lite: "npm:~0.4.24"
-    on-finished: "npm:~2.4.1"
-    qs: "npm:~6.14.0"
-    raw-body: "npm:~2.5.3"
-    type-is: "npm:~1.6.18"
-    unpipe: "npm:~1.0.0"
-  checksum: 10/ff67e28d3f426707be8697a75fdf8d564dc50c341b41f054264d8ab6e2924e519c7ce8acc9d0de05328fdc41e1d9f3f200aec9c1cfb1867d6b676a410d97c689
-  languageName: node
-  linkType: hard
-
-"body-parser@npm:^2.2.2":
-  version: 2.2.2
-  resolution: "body-parser@npm:2.2.2"
-  dependencies:
-    bytes: "npm:^3.1.2"
-    content-type: "npm:^1.0.5"
-    debug: "npm:^4.4.3"
-    http-errors: "npm:^2.0.0"
-    iconv-lite: "npm:^0.7.0"
-    on-finished: "npm:^2.4.1"
-    qs: "npm:^6.14.1"
-    raw-body: "npm:^3.0.1"
-    type-is: "npm:^2.0.1"
-  checksum: 10/69671f67d4d5ae5974593901a92d639757231da1725ed6de4d35e86cde9ce7650afdf1cd28df9b6f7892ea7f9eb03ccb30c70fe27d679275ae4cb4aae5ce1b21
-  languageName: node
-  linkType: hard
-
-"boolbase@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "boolbase@npm:1.0.0"
-  checksum: 10/3e25c80ef626c3a3487c73dbfc70ac322ec830666c9ad915d11b701142fab25ec1e63eff2c450c74347acfd2de854ccde865cd79ef4db1683f7c7b046ea43bb0
-  languageName: node
-  linkType: hard
-
 "bplist-creator@npm:0.1.0":
   version: 0.1.0
   resolution: "bplist-creator@npm:0.1.0"
@@ -7259,16 +5464,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"buffer@npm:^5.5.0":
-  version: 5.7.1
-  resolution: "buffer@npm:5.7.1"
-  dependencies:
-    base64-js: "npm:^1.3.1"
-    ieee754: "npm:^1.1.13"
-  checksum: 10/997434d3c6e3b39e0be479a80288875f71cd1c07d75a3855e6f08ef848a3c966023f79534e22e415ff3a5112708ce06127277ab20e527146d55c84566405c7c6
-  languageName: node
-  linkType: hard
-
 "buffer@npm:^6.0.3":
   version: 6.0.3
   resolution: "buffer@npm:6.0.3"
@@ -7279,7 +5474,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"bytes@npm:3.1.2, bytes@npm:^3.1.2, bytes@npm:~3.1.2":
+"bytes@npm:3.1.2":
   version: 3.1.2
   resolution: "bytes@npm:3.1.2"
   checksum: 10/a10abf2ba70c784471d6b4f58778c0beeb2b5d405148e66affa91f23a9f13d07603d0a0354667310ae1d6dc141474ffd44e2a074be0f6e2254edb8fc21445388
@@ -7344,27 +5539,20 @@ __metadata:
   languageName: node
   linkType: hard
 
-"camelcase@npm:^5.0.0, camelcase@npm:^5.3.1":
+"camelcase@npm:^5.3.1":
   version: 5.3.1
   resolution: "camelcase@npm:5.3.1"
   checksum: 10/e6effce26b9404e3c0f301498184f243811c30dfe6d0b9051863bd8e4034d09c8c2923794f280d6827e5aa055f6c434115ff97864a16a963366fb35fd673024b
   languageName: node
   linkType: hard
 
-"camelcase@npm:^6.2.0, camelcase@npm:^6.3.0":
+"camelcase@npm:^6.2.0":
   version: 6.3.0
   resolution: "camelcase@npm:6.3.0"
   checksum: 10/8c96818a9076434998511251dcb2761a94817ea17dbdc37f47ac080bd088fc62c7369429a19e2178b993497132c8cbcf5cc1f44ba963e76782ba469c0474938d
   languageName: node
   linkType: hard
 
-"camelize@npm:^1.0.0":
-  version: 1.0.1
-  resolution: "camelize@npm:1.0.1"
-  checksum: 10/0e147b4299ac6363c50050716aadfae42831257ec56ce54773ffd2a94a88abb2e2540c5ccc38345e8a39963105b76d86cb24477165a36b78c9958fb304513db3
-  languageName: node
-  linkType: hard
-
 "caniuse-lite@npm:^1.0.30001759":
   version: 1.0.30001774
   resolution: "caniuse-lite@npm:1.0.30001774"
@@ -7372,15 +5560,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"canvaskit-wasm@npm:0.41.0":
-  version: 0.41.0
-  resolution: "canvaskit-wasm@npm:0.41.0"
-  dependencies:
-    "@webgpu/types": "npm:0.1.21"
-  checksum: 10/3c24e892da8046aa17ba5f47aae8d855c9277aba849ee983e0562c70e9f50178d9dcd16f9420a8b6278adf9dd815f5c4dac09346e88fbcf4d968f959c93eb560
-  languageName: node
-  linkType: hard
-
 "chalk-template@npm:^1.1.0":
   version: 1.1.2
   resolution: "chalk-template@npm:1.1.2"
@@ -7418,13 +5597,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"char-regex@npm:^1.0.2":
-  version: 1.0.2
-  resolution: "char-regex@npm:1.0.2"
-  checksum: 10/1ec5c2906adb9f84e7f6732a40baef05d7c85401b82ffcbc44b85fbd0f7a2b0c2a96f2eb9cf55cae3235dc12d4023003b88f09bcae8be9ae894f52ed746f4d48
-  languageName: node
-  linkType: hard
-
 "character-entities-legacy@npm:^1.0.0":
   version: 1.1.4
   resolution: "character-entities-legacy@npm:1.1.4"
@@ -7515,27 +5687,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ci-info@npm:^4.2.0":
-  version: 4.4.0
-  resolution: "ci-info@npm:4.4.0"
-  checksum: 10/dfded0c630267d89660c8abb988ac8395a382bdfefedcc03e3e2858523312c5207db777c239c34774e3fcff11f015477c19d2ac8a58ea58aa476614a2e64f434
-  languageName: node
-  linkType: hard
-
-"cjs-module-lexer@npm:^1.0.0":
-  version: 1.4.3
-  resolution: "cjs-module-lexer@npm:1.4.3"
-  checksum: 10/d2b92f919a2dedbfd61d016964fce8da0035f827182ed6839c97cac56e8a8077cfa6a59388adfe2bc588a19cef9bbe830d683a76a6e93c51f65852062cfe2591
-  languageName: node
-  linkType: hard
-
-"cjs-module-lexer@npm:^2.1.0":
-  version: 2.2.0
-  resolution: "cjs-module-lexer@npm:2.2.0"
-  checksum: 10/fc8eb5c1919504366d8260a150d93c4e857740e770467dc59ca0cc34de4b66c93075559a5af65618f359187866b1be40e036f4e1a1bab2f1e06001c216415f74
-  languageName: node
-  linkType: hard
-
 "clean-stack@npm:^2.0.0":
   version: 2.2.0
   resolution: "clean-stack@npm:2.2.0"
@@ -7562,16 +5713,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"cli-cursor@npm:^3.1.0":
-  version: 3.1.0
-  resolution: "cli-cursor@npm:3.1.0"
-  dependencies:
-    restore-cursor: "npm:^3.1.0"
-  checksum: 10/2692784c6cd2fd85cfdbd11f53aea73a463a6d64a77c3e098b2b4697a20443f430c220629e1ca3b195ea5ac4a97a74c2ee411f3807abf6df2b66211fec0c0a29
-  languageName: node
-  linkType: hard
-
-"cli-spinners@npm:^2.0.0, cli-spinners@npm:^2.5.0":
+"cli-spinners@npm:^2.0.0":
   version: 2.9.2
   resolution: "cli-spinners@npm:2.9.2"
   checksum: 10/a0a863f442df35ed7294424f5491fa1756bd8d2e4ff0c8736531d886cec0ece4d85e8663b77a5afaf1d296e3cbbebff92e2e99f52bbea89b667cbe789b994794
@@ -7585,17 +5727,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"cliui@npm:^6.0.0":
-  version: 6.0.0
-  resolution: "cliui@npm:6.0.0"
-  dependencies:
-    string-width: "npm:^4.2.0"
-    strip-ansi: "npm:^6.0.0"
-    wrap-ansi: "npm:^6.2.0"
-  checksum: 10/44afbcc29df0899e87595590792a871cd8c4bc7d6ce92832d9ae268d141a77022adafca1aeaeccff618b62a613b8354e57fe22a275c199ec04baf00d381ef6ab
-  languageName: node
-  linkType: hard
-
 "cliui@npm:^8.0.1":
   version: 8.0.1
   resolution: "cliui@npm:8.0.1"
@@ -7614,20 +5745,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"co@npm:^4.6.0":
-  version: 4.6.0
-  resolution: "co@npm:4.6.0"
-  checksum: 10/a5d9f37091c70398a269e625cedff5622f200ed0aa0cff22ee7b55ed74a123834b58711776eb0f1dc58eb6ebbc1185aa7567b57bd5979a948c6e4f85073e2c05
-  languageName: node
-  linkType: hard
-
-"collect-v8-coverage@npm:^1.0.0, collect-v8-coverage@npm:^1.0.2":
-  version: 1.0.3
-  resolution: "collect-v8-coverage@npm:1.0.3"
-  checksum: 10/656443261fb7b79cf79e89cba4b55622b07c1d4976c630829d7c5c585c73cda1c2ff101f316bfb19bb9e2c58d724c7db1f70a21e213dcd14099227c5e6019860
-  languageName: node
-  linkType: hard
-
 "color-convert@npm:^1.9.0":
   version: 1.9.3
   resolution: "color-convert@npm:1.9.3"
@@ -7680,20 +5797,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"colorette@npm:^1.0.7":
-  version: 1.4.0
-  resolution: "colorette@npm:1.4.0"
-  checksum: 10/c8d6c8c3ef5a99acfc3dd9a68f48019f1479ec347551387e4a1762e40f69e98ce19d4dc321ffb4919d1f28a7bdc90c39d4e9a901f4c474fd2124ad93a00c0454
-  languageName: node
-  linkType: hard
-
-"command-exists@npm:^1.2.8":
-  version: 1.2.9
-  resolution: "command-exists@npm:1.2.9"
-  checksum: 10/46fb3c4d626ca5a9d274f8fe241230817496abc34d12911505370b7411999e183c11adff7078dd8a03ec4cf1391290facda40c6a4faac8203ae38c985eaedd63
-  languageName: node
-  linkType: hard
-
 "commander@npm:^12.0.0":
   version: 12.1.0
   resolution: "commander@npm:12.1.0"
@@ -7722,13 +5825,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"commander@npm:^9.4.1":
-  version: 9.5.0
-  resolution: "commander@npm:9.5.0"
-  checksum: 10/41c49b3d0f94a1fbeb0463c85b13f15aa15a9e0b4d5e10a49c0a1d58d4489b549d62262b052ae0aa6cfda53299bee487bfe337825df15e342114dde543f82906
-  languageName: node
-  linkType: hard
-
 "comment-json@npm:^4.2.5":
   version: 4.5.1
   resolution: "comment-json@npm:4.5.1"
@@ -7756,7 +5852,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"compression@npm:^1.7.1, compression@npm:^1.7.4":
+"compression@npm:^1.7.4":
   version: 1.8.1
   resolution: "compression@npm:1.8.1"
   dependencies:
@@ -7771,50 +5867,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"computer-vision@workspace:apps/computer-vision":
-  version: 0.0.0-use.local
-  resolution: "computer-vision@workspace:apps/computer-vision"
-  dependencies:
-    "@babel/core": "npm:^7.29.0"
-    "@expo/log-box": "npm:~56.0.12"
-    "@expo/vector-icons": "npm:^15.0.2"
-    "@react-native/metro-config": "npm:^0.85.3"
-    "@react-navigation/drawer": "npm:^7.9.4"
-    "@react-navigation/native": "npm:^7.2.2"
-    "@shopify/react-native-skia": "npm:2.6.2"
-    "@types/react": "npm:~19.2.0"
-    "@types/react-refresh": "npm:^0"
-    babel-preset-expo: "npm:~56.0.14"
-    expo: "npm:~56.0.9"
-    expo-build-properties: "npm:~56.0.17"
-    expo-constants: "npm:~56.0.17"
-    expo-font: "npm:~56.0.5"
-    expo-linking: "npm:~56.0.13"
-    expo-router: "npm:~56.2.9"
-    expo-status-bar: "npm:~56.0.4"
-    metro-config: "npm:^0.84.0"
-    react: "npm:19.2.3"
-    react-native: "npm:0.85.3"
-    react-native-device-info: "npm:^15.0.2"
-    react-native-executorch: "workspace:*"
-    react-native-executorch-expo-resource-fetcher: "workspace:*"
-    react-native-gesture-handler: "npm:~2.31.1"
-    react-native-image-picker: "npm:^8.2.1"
-    react-native-loading-spinner-overlay: "npm:^3.0.1"
-    react-native-nitro-image: "npm:0.13.1"
-    react-native-nitro-modules: "npm:0.35.4"
-    react-native-reanimated: "npm:4.3.1"
-    react-native-safe-area-context: "npm:~5.7.0"
-    react-native-screens: "npm:~4.25.2"
-    react-native-svg: "npm:15.15.4"
-    react-native-svg-transformer: "npm:^1.5.3"
-    react-native-vision-camera: "npm:^5.0.6"
-    react-native-vision-camera-worklets: "npm:^5.0.6"
-    react-native-worklets: "npm:0.8.3"
-    react-refresh: "npm:^0.18.0"
-  languageName: unknown
-  linkType: soft
-
 "concat-map@npm:0.0.1":
   version: 0.0.1
   resolution: "concat-map@npm:0.0.1"
@@ -7834,13 +5886,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"content-type@npm:^1.0.5, content-type@npm:~1.0.5":
-  version: 1.0.5
-  resolution: "content-type@npm:1.0.5"
-  checksum: 10/585847d98dc7fb8035c02ae2cb76c7a9bd7b25f84c447e5ed55c45c2175e83617c8813871b4ee22f368126af6b2b167df655829007b21aa10302873ea9c62662
-  languageName: node
-  linkType: hard
-
 "convert-source-map@npm:^2.0.0":
   version: 2.0.0
   resolution: "convert-source-map@npm:2.0.0"
@@ -7864,60 +5909,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"cosmiconfig@npm:^8.1.3":
-  version: 8.3.6
-  resolution: "cosmiconfig@npm:8.3.6"
-  dependencies:
-    import-fresh: "npm:^3.3.0"
-    js-yaml: "npm:^4.1.0"
-    parse-json: "npm:^5.2.0"
-    path-type: "npm:^4.0.0"
-  peerDependencies:
-    typescript: ">=4.9.5"
-  peerDependenciesMeta:
-    typescript:
-      optional: true
-  checksum: 10/91d082baca0f33b1c085bf010f9ded4af43cbedacba8821da0fb5667184d0a848addc52c31fadd080007f904a555319c238cf5f4c03e6d58ece2e4876b2e73d6
-  languageName: node
-  linkType: hard
-
-"cosmiconfig@npm:^9.0.0":
-  version: 9.0.0
-  resolution: "cosmiconfig@npm:9.0.0"
-  dependencies:
-    env-paths: "npm:^2.2.1"
-    import-fresh: "npm:^3.3.0"
-    js-yaml: "npm:^4.1.0"
-    parse-json: "npm:^5.2.0"
-  peerDependencies:
-    typescript: ">=4.9.5"
-  peerDependenciesMeta:
-    typescript:
-      optional: true
-  checksum: 10/8bdf1dfbb6fdb3755195b6886dc0649a3c742ec75afa4cb8da7b070936aed22a4f4e5b7359faafe03180358f311dbc300d248fd6586c458203d376a40cc77826
-  languageName: node
-  linkType: hard
-
-"create-jest@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "create-jest@npm:29.7.0"
-  dependencies:
-    "@jest/types": "npm:^29.6.3"
-    chalk: "npm:^4.0.0"
-    exit: "npm:^0.1.2"
-    graceful-fs: "npm:^4.2.9"
-    jest-config: "npm:^29.7.0"
-    jest-util: "npm:^29.7.0"
-    prompts: "npm:^2.0.1"
-  bin:
-    create-jest: bin/create-jest.js
-  checksum: 10/847b4764451672b4174be4d5c6d7d63442ec3aa5f3de52af924e4d996d87d7801c18e125504f25232fc75840f6625b3ac85860fac6ce799b5efae7bdcaf4a2b7
-  languageName: node
-  linkType: hard
-
-"cross-spawn@npm:^7.0.0, cross-spawn@npm:^7.0.2, cross-spawn@npm:^7.0.3, cross-spawn@npm:^7.0.6":
-  version: 7.0.6
-  resolution: "cross-spawn@npm:7.0.6"
+"cross-spawn@npm:^7.0.0, cross-spawn@npm:^7.0.2, cross-spawn@npm:^7.0.3, cross-spawn@npm:^7.0.6":
+  version: 7.0.6
+  resolution: "cross-spawn@npm:7.0.6"
   dependencies:
     path-key: "npm:^3.1.0"
     shebang-command: "npm:^2.0.0"
@@ -8065,90 +6059,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"css-color-keywords@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "css-color-keywords@npm:1.0.0"
-  checksum: 10/8f125e3ad477bd03c77b533044bd9e8a6f7c0da52d49bbc0bbe38327b3829d6ba04d368ca49dd9ff3b667d2fc8f1698d891c198bbf8feade1a5501bf5a296408
-  languageName: node
-  linkType: hard
-
-"css-select@npm:^5.1.0":
-  version: 5.2.2
-  resolution: "css-select@npm:5.2.2"
-  dependencies:
-    boolbase: "npm:^1.0.0"
-    css-what: "npm:^6.1.0"
-    domhandler: "npm:^5.0.2"
-    domutils: "npm:^3.0.1"
-    nth-check: "npm:^2.0.1"
-  checksum: 10/ebb6a88446433312d1a16301afd1c5f75090805b730dbbdccb0338b0d6ca7922410375f16dde06673ef7da086e2cf3b9ad91afe9a8e0d2ee3625795cb5e0170d
-  languageName: node
-  linkType: hard
-
-"css-to-react-native@npm:^3.0.0":
-  version: 3.2.0
-  resolution: "css-to-react-native@npm:3.2.0"
-  dependencies:
-    camelize: "npm:^1.0.0"
-    css-color-keywords: "npm:^1.0.0"
-    postcss-value-parser: "npm:^4.0.2"
-  checksum: 10/62ef744254e333abc696efdc945ecf13ad6ba7b726d0a39c0405b2fcb86542aa2f3fe7b7b6770f67ae9679d98b159b4d66353107bf7d6144a445eafcf5fa250a
-  languageName: node
-  linkType: hard
-
-"css-tree@npm:^1.1.3":
-  version: 1.1.3
-  resolution: "css-tree@npm:1.1.3"
-  dependencies:
-    mdn-data: "npm:2.0.14"
-    source-map: "npm:^0.6.1"
-  checksum: 10/29710728cc4b136f1e9b23ee1228ec403ec9f3d487bc94a9c5dbec563c1e08c59bc917dd6f82521a35e869ff655c298270f43ca673265005b0cd05b292eb05ab
-  languageName: node
-  linkType: hard
-
-"css-tree@npm:^2.3.1":
-  version: 2.3.1
-  resolution: "css-tree@npm:2.3.1"
-  dependencies:
-    mdn-data: "npm:2.0.30"
-    source-map-js: "npm:^1.0.1"
-  checksum: 10/e5e39b82eb4767c664fa5c2cd9968c8c7e6b7fd2c0079b52680a28466d851e2826d5e64699c449d933c0e8ca0554beca43c41a9fcb09fb6a46139d462dbdf0df
-  languageName: node
-  linkType: hard
-
-"css-tree@npm:~2.2.0":
-  version: 2.2.1
-  resolution: "css-tree@npm:2.2.1"
-  dependencies:
-    mdn-data: "npm:2.0.28"
-    source-map-js: "npm:^1.0.1"
-  checksum: 10/1959c4b0e268bf8db1b3a1776a5ba9ae3a464ccd1226bfa62799cb0a3d0039006e21fb95cec4dec9d687a9a9b90f692dff2d230b631527ece700f4bfb419aaf3
-  languageName: node
-  linkType: hard
-
-"css-what@npm:^6.1.0":
-  version: 6.2.2
-  resolution: "css-what@npm:6.2.2"
-  checksum: 10/3c5a53be94728089bd1716f915f7f96adde5dd8bf374610eb03982266f3d860bf1ebaf108cda30509d02ef748fe33eaa59aa75911e2c49ee05a85ef1f9fb5223
-  languageName: node
-  linkType: hard
-
-"css.escape@npm:^1.5.1":
-  version: 1.5.1
-  resolution: "css.escape@npm:1.5.1"
-  checksum: 10/f6d38088d870a961794a2580b2b2af1027731bb43261cfdce14f19238a88664b351cc8978abc20f06cc6bbde725699dec8deb6fe9816b139fc3f2af28719e774
-  languageName: node
-  linkType: hard
-
-"csso@npm:^5.0.5":
-  version: 5.0.5
-  resolution: "csso@npm:5.0.5"
-  dependencies:
-    css-tree: "npm:~2.2.0"
-  checksum: 10/4036fb2b9f8ed6b948349136b39e0b19ffb5edee934893a37b55e9a116186c4ae2a9d3ba66fbdbc07fa44a853fb478cd2d8733e4743473dcd364e7f21444ff34
-  languageName: node
-  linkType: hard
-
 "csstype@npm:^3.0.2, csstype@npm:^3.2.2":
   version: 3.2.3
   resolution: "csstype@npm:3.2.3"
@@ -8189,13 +6099,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"dayjs@npm:^1.8.15":
-  version: 1.11.19
-  resolution: "dayjs@npm:1.11.19"
-  checksum: 10/185b820d68492b83a3ce2b8ddc7543034edc1dfd1423183f6ae4707b29929a3cc56503a81826309279f9084680c15966b99456e74cf41f7d1f6a2f98f9c7196f
-  languageName: node
-  linkType: hard
-
 "debug@npm:2.6.9, debug@npm:^2.6.9":
   version: 2.6.9
   resolution: "debug@npm:2.6.9"
@@ -8205,7 +6108,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"debug@npm:4, debug@npm:^4.0.0, debug@npm:^4.1.0, debug@npm:^4.1.1, debug@npm:^4.3.1, debug@npm:^4.3.2, debug@npm:^4.3.4, debug@npm:^4.3.5, debug@npm:^4.4.0, debug@npm:^4.4.3":
+"debug@npm:4, debug@npm:^4.0.0, debug@npm:^4.1.0, debug@npm:^4.3.1, debug@npm:^4.3.2, debug@npm:^4.3.4, debug@npm:^4.3.5, debug@npm:^4.4.0, debug@npm:^4.4.3":
   version: 4.4.3
   resolution: "debug@npm:4.4.3"
   dependencies:
@@ -8226,13 +6129,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"decamelize@npm:^1.2.0":
-  version: 1.2.0
-  resolution: "decamelize@npm:1.2.0"
-  checksum: 10/ad8c51a7e7e0720c70ec2eeb1163b66da03e7616d7b98c9ef43cce2416395e84c1e9548dd94f5f6ffecfee9f8b94251fc57121a8b021f2ff2469b2bae247b8aa
-  languageName: node
-  linkType: hard
-
 "decode-named-character-reference@npm:^1.0.0":
   version: 1.3.0
   resolution: "decode-named-character-reference@npm:1.3.0"
@@ -8256,30 +6152,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"dedent@npm:^1.0.0":
-  version: 1.7.2
-  resolution: "dedent@npm:1.7.2"
-  peerDependencies:
-    babel-plugin-macros: ^3.1.0
-  peerDependenciesMeta:
-    babel-plugin-macros:
-      optional: true
-  checksum: 10/30b9062290dca72b0f5a6cd3667633448cef8cd0dec602eab61015741269ad49df90cabf0521f9a32d134ceab4e21aa7f097258c55cc3baadef94874686d6480
-  languageName: node
-  linkType: hard
-
-"dedent@npm:^1.6.0":
-  version: 1.7.1
-  resolution: "dedent@npm:1.7.1"
-  peerDependencies:
-    babel-plugin-macros: ^3.1.0
-  peerDependenciesMeta:
-    babel-plugin-macros:
-      optional: true
-  checksum: 10/78785ef592e37e0b1ca7a7a5964c8f3dee1abdff46c5bb49864168579c122328f6bb55c769bc7e005046a7381c3372d3859f0f78ab083950fa146e1c24873f4f
-  languageName: node
-  linkType: hard
-
 "deep-is@npm:^0.1.3":
   version: 0.1.4
   resolution: "deep-is@npm:0.1.4"
@@ -8287,7 +6159,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"deepmerge@npm:^4.2.2, deepmerge@npm:^4.3.0, deepmerge@npm:^4.3.1":
+"deepmerge@npm:^4.3.1":
   version: 4.3.1
   resolution: "deepmerge@npm:4.3.1"
   checksum: 10/058d9e1b0ff1a154468bf3837aea436abcfea1ba1d165ddaaf48ca93765fdd01a30d33c36173da8fbbed951dd0a267602bc782fe288b0fc4b7e1e7091afc4529
@@ -8325,6 +6197,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"del-cli@npm:^6.0.0":
+  version: 6.0.0
+  resolution: "del-cli@npm:6.0.0"
+  dependencies:
+    del: "npm:^8.0.0"
+    meow: "npm:^13.2.0"
+  bin:
+    del: cli.js
+    del-cli: cli.js
+  checksum: 10/5441e55c9181f364e84a1d211e53a03476a806e795f6b7d576673f164a9f76e0dc846413a47730f6224913974ba54dabb1884f854a9cf4d418084872bdaaa229
+  languageName: node
+  linkType: hard
+
 "del@npm:^6.1.1":
   version: 6.1.1
   resolution: "del@npm:6.1.1"
@@ -8341,6 +6226,21 @@ __metadata:
   languageName: node
   linkType: hard
 
+"del@npm:^8.0.0":
+  version: 8.0.1
+  resolution: "del@npm:8.0.1"
+  dependencies:
+    globby: "npm:^14.0.2"
+    is-glob: "npm:^4.0.3"
+    is-path-cwd: "npm:^3.0.0"
+    is-path-inside: "npm:^4.0.0"
+    p-map: "npm:^7.0.2"
+    presentable-error: "npm:^0.0.1"
+    slash: "npm:^5.1.0"
+  checksum: 10/53ed4a379a68c90e7d6d3bcce09c49229e77de9a946d0a5fc25f45b16c950cb8665986b7d0d0423416c03bfd43e0f31e528c5a19c558fe47449be9d6fae7f846
+  languageName: node
+  linkType: hard
+
 "depd@npm:2.0.0, depd@npm:~2.0.0":
   version: 2.0.0
   resolution: "depd@npm:2.0.0"
@@ -8355,7 +6255,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"destroy@npm:1.2.0, destroy@npm:~1.2.0":
+"destroy@npm:1.2.0":
   version: 1.2.0
   resolution: "destroy@npm:1.2.0"
   checksum: 10/0acb300b7478a08b92d810ab229d5afe0d2f4399272045ab22affa0d99dbaf12637659411530a6fcd597a9bdac718fc94373a61a95b4651bbc7b83684a565e38
@@ -8369,13 +6269,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"detect-newline@npm:^3.0.0, detect-newline@npm:^3.1.0":
-  version: 3.1.0
-  resolution: "detect-newline@npm:3.1.0"
-  checksum: 10/ae6cd429c41ad01b164c59ea36f264a2c479598e61cba7c99da24175a7ab80ddf066420f2bec9a1c57a6bead411b4655ff15ad7d281c000a89791f48cbe939e7
-  languageName: node
-  linkType: hard
-
 "detect-node-es@npm:^1.1.0":
   version: 1.1.0
   resolution: "detect-node-es@npm:1.1.0"
@@ -8392,13 +6285,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"diff-sequences@npm:^29.6.3":
-  version: 29.6.3
-  resolution: "diff-sequences@npm:29.6.3"
-  checksum: 10/179daf9d2f9af5c57ad66d97cb902a538bcf8ed64963fa7aa0c329b3de3665ce2eb6ffdc2f69f29d445fa4af2517e5e55e5b6e00c00a9ae4f43645f97f7078cb
-  languageName: node
-  linkType: hard
-
 "dir-glob@npm:^3.0.1":
   version: 3.0.1
   resolution: "dir-glob@npm:3.0.1"
@@ -8433,61 +6319,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"dom-accessibility-api@npm:^0.6.3":
-  version: 0.6.3
-  resolution: "dom-accessibility-api@npm:0.6.3"
-  checksum: 10/83d3371f8226487fbad36e160d44f1d9017fb26d46faba6a06fcad15f34633fc827b8c3e99d49f71d5f3253d866e2131826866fd0a3c86626f8eccfc361881ff
-  languageName: node
-  linkType: hard
-
-"dom-serializer@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "dom-serializer@npm:2.0.0"
-  dependencies:
-    domelementtype: "npm:^2.3.0"
-    domhandler: "npm:^5.0.2"
-    entities: "npm:^4.2.0"
-  checksum: 10/e3bf9027a64450bca0a72297ecdc1e3abb7a2912268a9f3f5d33a2e29c1e2c3502c6e9f860fc6625940bfe0cfb57a44953262b9e94df76872fdfb8151097eeb3
-  languageName: node
-  linkType: hard
-
-"domelementtype@npm:^2.3.0":
-  version: 2.3.0
-  resolution: "domelementtype@npm:2.3.0"
-  checksum: 10/ee837a318ff702622f383409d1f5b25dd1024b692ef64d3096ff702e26339f8e345820f29a68bcdcea8cfee3531776b3382651232fbeae95612d6f0a75efb4f6
-  languageName: node
-  linkType: hard
-
-"domhandler@npm:^5.0.2, domhandler@npm:^5.0.3":
-  version: 5.0.3
-  resolution: "domhandler@npm:5.0.3"
-  dependencies:
-    domelementtype: "npm:^2.3.0"
-  checksum: 10/809b805a50a9c6884a29f38aec0a4e1b4537f40e1c861950ed47d10b049febe6b79ab72adaeeebb3cc8fc1cd33f34e97048a72a9265103426d93efafa78d3e96
-  languageName: node
-  linkType: hard
-
-"domutils@npm:^3.0.1":
-  version: 3.2.2
-  resolution: "domutils@npm:3.2.2"
-  dependencies:
-    dom-serializer: "npm:^2.0.0"
-    domelementtype: "npm:^2.3.0"
-    domhandler: "npm:^5.0.3"
-  checksum: 10/2e08842151aa406f50fe5e6d494f4ec73c2373199fa00d1f77b56ec604e566b7f226312ae35ab8160bb7f27a27c7285d574c8044779053e499282ca9198be210
-  languageName: node
-  linkType: hard
-
-"dot-case@npm:^3.0.4":
-  version: 3.0.4
-  resolution: "dot-case@npm:3.0.4"
-  dependencies:
-    no-case: "npm:^3.0.4"
-    tslib: "npm:^2.0.3"
-  checksum: 10/a65e3519414856df0228b9f645332f974f2bf5433370f544a681122eab59e66038fc3349b4be1cdc47152779dac71a5864f1ccda2f745e767c46e9c6543b1169
-  languageName: node
-  linkType: hard
-
 "dunder-proto@npm:^1.0.0, dunder-proto@npm:^1.0.1":
   version: 1.0.1
   resolution: "dunder-proto@npm:1.0.1"
@@ -8520,13 +6351,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"emittery@npm:^0.13.1":
-  version: 0.13.1
-  resolution: "emittery@npm:0.13.1"
-  checksum: 10/fbe214171d878b924eedf1757badf58a5dce071cd1fa7f620fa841a0901a80d6da47ff05929d53163105e621ce11a71b9d8acb1148ffe1745e045145f6e69521
-  languageName: node
-  linkType: hard
-
 "emoji-regex@npm:^8.0.0":
   version: 8.0.0
   resolution: "emoji-regex@npm:8.0.0"
@@ -8564,21 +6388,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"entities@npm:^4.2.0, entities@npm:^4.4.0":
-  version: 4.5.0
-  resolution: "entities@npm:4.5.0"
-  checksum: 10/ede2a35c9bce1aeccd055a1b445d41c75a14a2bb1cd22e242f20cf04d236cdcd7f9c859eb83f76885327bfae0c25bf03303665ee1ce3d47c5927b98b0e3e3d48
-  languageName: node
-  linkType: hard
-
-"entities@npm:~2.0.0":
-  version: 2.0.3
-  resolution: "entities@npm:2.0.3"
-  checksum: 10/01b95aa975dabd2b0bba0b894571c5401e624a1cd2144577add99ff1eca7d582a2bccaa36e9696e9e83258c00c9c8678461fac63e5fa3c014b82ea418bed04f8
-  languageName: node
-  linkType: hard
-
-"env-paths@npm:^2.2.0, env-paths@npm:^2.2.1":
+"env-paths@npm:^2.2.0":
   version: 2.2.1
   resolution: "env-paths@npm:2.2.1"
   checksum: 10/65b5df55a8bab92229ab2b40dad3b387fad24613263d103a97f91c9fe43ceb21965cd3392b1ccb5d77088021e525c4e0481adb309625d0cb94ade1d1fb8dc17e
@@ -8592,24 +6402,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"envinfo@npm:^7.13.0":
-  version: 7.21.0
-  resolution: "envinfo@npm:7.21.0"
-  bin:
-    envinfo: dist/cli.js
-  checksum: 10/2469a72802ded4e43c007dcd1c5dd44d8049b7d18276874dcc3f3f14a54bc72806fa35e82760974ca1442d82f5f9df3651048204e72791f81bcdd5f07422a561
-  languageName: node
-  linkType: hard
-
-"error-ex@npm:^1.3.1":
-  version: 1.3.4
-  resolution: "error-ex@npm:1.3.4"
-  dependencies:
-    is-arrayish: "npm:^0.2.1"
-  checksum: 10/ae3939fd4a55b1404e877df2080c6b59acc516d5b7f08a181040f78f38b4e2399633bfed2d9a21b91c803713fff7295ac70bebd8f3657ef352a95c2cd9aa2e4b
-  languageName: node
-  linkType: hard
-
 "error-stack-parser@npm:^2.0.6":
   version: 2.1.4
   resolution: "error-stack-parser@npm:2.1.4"
@@ -8619,16 +6411,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"errorhandler@npm:^1.5.1":
-  version: 1.5.2
-  resolution: "errorhandler@npm:1.5.2"
-  dependencies:
-    accepts: "npm:~1.3.8"
-    escape-html: "npm:~1.0.3"
-  checksum: 10/7ce0a598cc2c52840e32b46d2da8c7b0a4594aa67e93db46112cf791d4c8a4a1299af7f7aa65253d2e9d42af4d275c96387c0d186427df5ee93d33670bdac541
-  languageName: node
-  linkType: hard
-
 "es-abstract@npm:^1.17.5, es-abstract@npm:^1.23.2, es-abstract@npm:^1.23.3, es-abstract@npm:^1.23.5, es-abstract@npm:^1.23.6, es-abstract@npm:^1.23.9, es-abstract@npm:^1.24.0, es-abstract@npm:^1.24.1":
   version: 1.24.1
   resolution: "es-abstract@npm:1.24.1"
@@ -8930,15 +6712,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"eslint-plugin-react-hooks@npm:^5.2.0":
-  version: 5.2.0
-  resolution: "eslint-plugin-react-hooks@npm:5.2.0"
-  peerDependencies:
-    eslint: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0
-  checksum: 10/ebb79e9cf69ae06e3a7876536653c5e556b5fd8cd9dc49577f10a6e728360e7b6f5ce91f4339b33e93b26e3bb23805418f8b5e75db80baddd617b1dffe73bed1
-  languageName: node
-  linkType: hard
-
 "eslint-plugin-react-native-globals@npm:^0.1.1":
   version: 0.1.2
   resolution: "eslint-plugin-react-native-globals@npm:0.1.2"
@@ -9026,7 +6799,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"eslint@npm:^8.19.0, eslint@npm:^8.57.0":
+"eslint@npm:^8.57.0":
   version: 8.57.1
   resolution: "eslint@npm:8.57.1"
   dependencies:
@@ -9176,64 +6949,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"execa@npm:^5.0.0, execa@npm:^5.1.1":
-  version: 5.1.1
-  resolution: "execa@npm:5.1.1"
-  dependencies:
-    cross-spawn: "npm:^7.0.3"
-    get-stream: "npm:^6.0.0"
-    human-signals: "npm:^2.1.0"
-    is-stream: "npm:^2.0.0"
-    merge-stream: "npm:^2.0.0"
-    npm-run-path: "npm:^4.0.1"
-    onetime: "npm:^5.1.2"
-    signal-exit: "npm:^3.0.3"
-    strip-final-newline: "npm:^2.0.0"
-  checksum: 10/8ada91f2d70f7dff702c861c2c64f21dfdc1525628f3c0454fd6f02fce65f7b958616cbd2b99ca7fa4d474e461a3d363824e91b3eb881705231abbf387470597
-  languageName: node
-  linkType: hard
-
-"exit-x@npm:^0.2.2":
-  version: 0.2.2
-  resolution: "exit-x@npm:0.2.2"
-  checksum: 10/ee043053e6c1e237adf5ad9c4faf9f085b606f64a4ff859e2b138fab63fe642711d00c9af452a9134c4c92c55f752e818bfabab78c24d345022db163f3137027
-  languageName: node
-  linkType: hard
-
-"exit@npm:^0.1.2":
-  version: 0.1.2
-  resolution: "exit@npm:0.1.2"
-  checksum: 10/387555050c5b3c10e7a9e8df5f43194e95d7737c74532c409910e585d5554eaff34960c166643f5e23d042196529daad059c292dcf1fb61b8ca878d3677f4b87
-  languageName: node
-  linkType: hard
-
-"expect@npm:30.2.0, expect@npm:^30.0.0":
-  version: 30.2.0
-  resolution: "expect@npm:30.2.0"
-  dependencies:
-    "@jest/expect-utils": "npm:30.2.0"
-    "@jest/get-type": "npm:30.1.0"
-    jest-matcher-utils: "npm:30.2.0"
-    jest-message-util: "npm:30.2.0"
-    jest-mock: "npm:30.2.0"
-    jest-util: "npm:30.2.0"
-  checksum: 10/cf98ab45ab2e9f2fb9943a3ae0097f72d63a94be179a19fd2818d8fdc3b7681d31cc8ef540606eb8dd967d9c44d73fef263a614e9de260c22943ffb122ad66fd
-  languageName: node
-  linkType: hard
-
-"expect@npm:^29.0.0, expect@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "expect@npm:29.7.0"
-  dependencies:
-    "@jest/expect-utils": "npm:^29.7.0"
-    jest-get-type: "npm:^29.6.3"
-    jest-matcher-utils: "npm:^29.7.0"
-    jest-message-util: "npm:^29.7.0"
-    jest-util: "npm:^29.7.0"
-  checksum: 10/63f97bc51f56a491950fb525f9ad94f1916e8a014947f8d8445d3847a665b5471b768522d659f5e865db20b6c2033d2ac10f35fcbd881a4d26407a4f6f18451a
-  languageName: node
-  linkType: hard
-
 "expo-asset@npm:~56.0.15":
   version: 56.0.15
   resolution: "expo-asset@npm:56.0.15"
@@ -9248,66 +6963,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"expo-asset@npm:~56.0.16":
-  version: 56.0.16
-  resolution: "expo-asset@npm:56.0.16"
-  dependencies:
-    "@expo/image-utils": "npm:^0.10.1"
-    expo-constants: "npm:~56.0.17"
-  peerDependencies:
-    expo: "*"
-    react: "*"
-    react-native: "*"
-  checksum: 10/f06bddde1788fa3b9a9f0d8143570e0bd94a6f52f439f127b1129f1836dd3b74b5b46d2df7b91e6fd38a0bb6be39538d17730f8df03156d247d472c5d5a6abfe
-  languageName: node
-  linkType: hard
-
-"expo-brightness@npm:~56.0.5":
-  version: 56.0.5
-  resolution: "expo-brightness@npm:56.0.5"
-  peerDependencies:
-    expo: "*"
-    react-native: "*"
-  checksum: 10/10c1d0ab238f7752de521d191f9774c40d2a2f17111229d6cc9d2f316355baf1f7530925de100984bf85ef80e4f380733dcaa18a2152123124180a58122df939
-  languageName: node
-  linkType: hard
-
-"expo-build-properties@npm:~56.0.16":
-  version: 56.0.16
-  resolution: "expo-build-properties@npm:56.0.16"
-  dependencies:
-    "@expo/schema-utils": "npm:^56.0.0"
-    resolve-from: "npm:^5.0.0"
-    semver: "npm:^7.6.0"
-  peerDependencies:
-    expo: "*"
-  checksum: 10/a45c4a0b68e5eb3ac4bdb524ac4927d3dde80d2b0a983078b5cf6ba9b41d6c0b16a67adf5a675ff0b9a441fd9906a77a635db83aa331db5214cb77273bd70d46
-  languageName: node
-  linkType: hard
-
-"expo-build-properties@npm:~56.0.17":
-  version: 56.0.17
-  resolution: "expo-build-properties@npm:56.0.17"
-  dependencies:
-    "@expo/schema-utils": "npm:^56.0.0"
-    resolve-from: "npm:^5.0.0"
-    semver: "npm:^7.6.0"
-  peerDependencies:
-    expo: "*"
-  checksum: 10/6464e525bef833ac8b8db5f427b73ecc839450b15e758f51c228c5f746a2f40967fff16b4a0cbaf2051073b9b2169797c2f0c97fbcdb7a9df63e6326ed2597e4
-  languageName: node
-  linkType: hard
-
-"expo-calendar@npm:~56.0.8":
-  version: 56.0.8
-  resolution: "expo-calendar@npm:56.0.8"
-  peerDependencies:
-    expo: "*"
-    react-native: "*"
-  checksum: 10/360d778e417b734b038e3c585d9c17e48c2370157752bdfde82486a34a2d137ceed9697d69c3698e757f991ba9cc55c17bb31bb5a956c646efa4e237acae0fcd
-  languageName: node
-  linkType: hard
-
 "expo-constants@npm:~56.0.16":
   version: 56.0.16
   resolution: "expo-constants@npm:56.0.16"
@@ -9320,27 +6975,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"expo-constants@npm:~56.0.17":
-  version: 56.0.17
-  resolution: "expo-constants@npm:56.0.17"
-  dependencies:
-    "@expo/env": "npm:~2.3.0"
-  peerDependencies:
-    expo: "*"
-    react-native: "*"
-  checksum: 10/b1421125005e32ff07cd1fcc0a66aa570c996c805dd47d462baa0f9d1c1de77bf19ba6b2e5743747b1c071934fab321049a3d292b4cd8d9633848029ecbb2e14
-  languageName: node
-  linkType: hard
-
-"expo-document-picker@npm:~56.0.4":
-  version: 56.0.4
-  resolution: "expo-document-picker@npm:56.0.4"
-  peerDependencies:
-    expo: "*"
-  checksum: 10/b5aa1f8bf53fad7475e4c75e269ec0f7945df049a9b15a06b7772141d1e31565823905a0f826ae55ed61d89908812ddfd7f1652b82269520df465a1e958343b0
-  languageName: node
-  linkType: hard
-
 "expo-file-system@npm:~56.0.7":
   version: 56.0.7
   resolution: "expo-file-system@npm:56.0.7"
@@ -9364,20 +6998,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"expo-glass-effect@npm:^56.0.4":
-  version: 56.0.4
-  resolution: "expo-glass-effect@npm:56.0.4"
-  peerDependencies:
-    expo: "*"
-    react: "*"
-    react-native: "*"
-  checksum: 10/ca3142258a62e312d2a879c0cbf379de0bb40c7b99964e16937b197cd691337b99b91a4f79e08fe60b0f4f7dddc8ba74e415dc8b2a6ad53820d13f403ad4c83b
-  languageName: node
-  linkType: hard
-
-"expo-keep-awake@npm:~56.0.3":
-  version: 56.0.3
-  resolution: "expo-keep-awake@npm:56.0.3"
+"expo-keep-awake@npm:~56.0.3":
+  version: 56.0.3
+  resolution: "expo-keep-awake@npm:56.0.3"
   peerDependencies:
     expo: "*"
     react: "*"
@@ -9385,19 +7008,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"expo-linking@npm:~56.0.13":
-  version: 56.0.13
-  resolution: "expo-linking@npm:56.0.13"
-  dependencies:
-    expo-constants: "npm:~56.0.16"
-    invariant: "npm:^2.2.4"
-  peerDependencies:
-    react: "*"
-    react-native: "*"
-  checksum: 10/1d60735de1fe63b465be8c2212d9fa0076f82d6e5665e2e5493579b4033584d2fc1518085ec06a51b8f73931135dad4edd80ff68d46027764610f1aa9b748836
-  languageName: node
-  linkType: hard
-
 "expo-modules-autolinking@npm:~56.0.14":
   version: 56.0.14
   resolution: "expo-modules-autolinking@npm:56.0.14"
@@ -9412,20 +7022,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"expo-modules-autolinking@npm:~56.0.15":
-  version: 56.0.15
-  resolution: "expo-modules-autolinking@npm:56.0.15"
-  dependencies:
-    "@expo/require-utils": "npm:^56.1.3"
-    "@expo/spawn-async": "npm:^1.8.0"
-    chalk: "npm:^4.1.0"
-    commander: "npm:^7.2.0"
-  bin:
-    expo-modules-autolinking: bin/expo-modules-autolinking.js
-  checksum: 10/789b10f2bb1700da265dc33961ee78941da6a0baee8e3ddf82d666546d273aba2c913c3eca106b565274ee2a26882e7c0bea26f2f8ffe506f145dafc55799fa5
-  languageName: node
-  linkType: hard
-
 "expo-modules-core@npm:~56.0.14":
   version: 56.0.14
   resolution: "expo-modules-core@npm:56.0.14"
@@ -9444,24 +7040,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"expo-modules-core@npm:~56.0.15":
-  version: 56.0.15
-  resolution: "expo-modules-core@npm:56.0.15"
-  dependencies:
-    "@expo/expo-modules-macros-plugin": "npm:~0.0.9"
-    expo-modules-jsi: "npm:~56.0.8"
-    invariant: "npm:^2.2.4"
-  peerDependencies:
-    react: "*"
-    react-native: "*"
-    react-native-worklets: ^0.7.4 || ^0.8.0
-  peerDependenciesMeta:
-    react-native-worklets:
-      optional: true
-  checksum: 10/43c33619bef4ea2ea0467e6fb37b1c0fb4a9d18c8747f37cf2a8c017373b049a342b9a7c25b8262292bf07244da04609c96f2eb71048cab562d46c1c716582b3
-  languageName: node
-  linkType: hard
-
 "expo-modules-jsi@npm:~56.0.7":
   version: 56.0.7
   resolution: "expo-modules-jsi@npm:56.0.7"
@@ -9471,145 +7049,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"expo-modules-jsi@npm:~56.0.8":
-  version: 56.0.8
-  resolution: "expo-modules-jsi@npm:56.0.8"
-  peerDependencies:
-    react-native: "*"
-  checksum: 10/846f49adf69810afffa26e5340b74dc28984f239ed6ceb328bb0c109d3598449540e65945a297368884f50306c06a1d18e6cd30e5564ca0766bb3ad947cf37ad
-  languageName: node
-  linkType: hard
-
-"expo-router@npm:~56.2.8":
-  version: 56.2.8
-  resolution: "expo-router@npm:56.2.8"
-  dependencies:
-    "@expo/log-box": "npm:^56.0.12"
-    "@expo/metro-runtime": "npm:^56.0.13"
-    "@expo/schema-utils": "npm:^56.0.0"
-    "@expo/ui": "npm:^56.0.15"
-    "@radix-ui/react-slot": "npm:^1.2.0"
-    "@radix-ui/react-tabs": "npm:^1.1.12"
-    "@react-native-masked-view/masked-view": "npm:^0.3.2"
-    "@testing-library/jest-dom": "npm:^6.9.1"
-    "@testing-library/user-event": "npm:^14.6.1"
-    client-only: "npm:^0.0.1"
-    color: "npm:^4.2.3"
-    debug: "npm:^4.3.4"
-    escape-string-regexp: "npm:^4.0.0"
-    expo-glass-effect: "npm:^56.0.4"
-    expo-server: "npm:^56.0.4"
-    expo-symbols: "npm:^56.0.5"
-    fast-deep-equal: "npm:^3.1.3"
-    invariant: "npm:^2.2.4"
-    nanoid: "npm:^3.3.8"
-    query-string: "npm:^7.1.3"
-    react-fast-compare: "npm:^3.2.2"
-    react-is: "npm:^19.1.0"
-    react-native-drawer-layout: "npm:^4.2.2"
-    react-native-screens: "npm:^4.25.2"
-    server-only: "npm:^0.0.1"
-    sf-symbols-typescript: "npm:^2.1.0"
-    shallowequal: "npm:^1.1.0"
-    vaul: "npm:^1.1.2"
-  peerDependencies:
-    "@expo/log-box": ^56.0.12
-    "@expo/metro-runtime": ^56.0.13
-    "@testing-library/react-native": ">= 13.2.0"
-    expo: "*"
-    expo-constants: ^56.0.16
-    expo-linking: ^56.0.13
-    react: "*"
-    react-dom: "*"
-    react-native: "*"
-    react-native-gesture-handler: "*"
-    react-native-reanimated: "*"
-    react-native-safe-area-context: ">= 5.4.0"
-    react-native-screens: ^4.25.2
-    react-native-web: "*"
-    react-server-dom-webpack: ~19.0.4 || ~19.1.5 || ~19.2.4
-  peerDependenciesMeta:
-    "@testing-library/react-native":
-      optional: true
-    react-dom:
-      optional: true
-    react-native-gesture-handler:
-      optional: true
-    react-native-reanimated:
-      optional: true
-    react-native-web:
-      optional: true
-    react-server-dom-webpack:
-      optional: true
-  checksum: 10/b78b7576040d0fba4e949e20b31e7751d6b48c9dde5b13d75496fcbaf17e2270f9d90cb90b6cb4399fec47b6d28cd9e9ab0ac459604ef3e442bedc4a688acbba
-  languageName: node
-  linkType: hard
-
-"expo-router@npm:~56.2.9":
-  version: 56.2.9
-  resolution: "expo-router@npm:56.2.9"
-  dependencies:
-    "@expo/log-box": "npm:^56.0.12"
-    "@expo/metro-runtime": "npm:^56.0.14"
-    "@expo/schema-utils": "npm:^56.0.0"
-    "@expo/ui": "npm:^56.0.16"
-    "@radix-ui/react-slot": "npm:^1.2.0"
-    "@radix-ui/react-tabs": "npm:^1.1.12"
-    "@react-native-masked-view/masked-view": "npm:^0.3.2"
-    "@testing-library/jest-dom": "npm:^6.9.1"
-    "@testing-library/user-event": "npm:^14.6.1"
-    client-only: "npm:^0.0.1"
-    color: "npm:^4.2.3"
-    debug: "npm:^4.3.4"
-    escape-string-regexp: "npm:^4.0.0"
-    expo-glass-effect: "npm:^56.0.4"
-    expo-server: "npm:^56.0.5"
-    expo-symbols: "npm:^56.0.6"
-    fast-deep-equal: "npm:^3.1.3"
-    invariant: "npm:^2.2.4"
-    nanoid: "npm:^3.3.8"
-    query-string: "npm:^7.1.3"
-    react-fast-compare: "npm:^3.2.2"
-    react-is: "npm:^19.1.0"
-    react-native-drawer-layout: "npm:^4.2.2"
-    react-native-screens: "npm:^4.25.2"
-    server-only: "npm:^0.0.1"
-    sf-symbols-typescript: "npm:^2.1.0"
-    shallowequal: "npm:^1.1.0"
-    vaul: "npm:^1.1.2"
-  peerDependencies:
-    "@expo/log-box": ^56.0.12
-    "@expo/metro-runtime": ^56.0.14
-    "@testing-library/react-native": ">= 13.2.0"
-    expo: "*"
-    expo-constants: ^56.0.17
-    expo-linking: ^56.0.13
-    react: "*"
-    react-dom: "*"
-    react-native: "*"
-    react-native-gesture-handler: "*"
-    react-native-reanimated: "*"
-    react-native-safe-area-context: ">= 5.4.0"
-    react-native-screens: ^4.25.2
-    react-native-web: "*"
-    react-server-dom-webpack: ~19.0.4 || ~19.1.5 || ~19.2.4
-  peerDependenciesMeta:
-    "@testing-library/react-native":
-      optional: true
-    react-dom:
-      optional: true
-    react-native-gesture-handler:
-      optional: true
-    react-native-reanimated:
-      optional: true
-    react-native-web:
-      optional: true
-    react-server-dom-webpack:
-      optional: true
-  checksum: 10/46d60ae1ba3a965546066f4b66cfd70e66802c37f0718a0b29c67351f4e1f1ce1ba347eb1125db2ecc7be7be79620a02417e61d680f7886c14d4d00b6c0bff7e
-  languageName: node
-  linkType: hard
-
 "expo-router@npm:~6.0.17":
   version: 6.0.23
   resolution: "expo-router@npm:6.0.23"
@@ -9686,54 +7125,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"expo-server@npm:^56.0.5":
-  version: 56.0.5
-  resolution: "expo-server@npm:56.0.5"
-  checksum: 10/0fa69600d65d09f100d513c431ce5152531d588db46fc56d18a9d029b0d758d061d9981afa394c0d30a01ae580050ad0c570f3a58f6a296d719dbf8812952fe1
-  languageName: node
-  linkType: hard
-
-"expo-status-bar@npm:~56.0.4":
-  version: 56.0.4
-  resolution: "expo-status-bar@npm:56.0.4"
-  peerDependencies:
-    expo: "*"
-    react: "*"
-    react-native: "*"
-  checksum: 10/a43556df4b7b57f2bdb46ce36c8d468b52d01f968ac4aa105e0e22a78e09921ec507637f9e4187a07f8bc78291a5765fd962a51575aa6dbe4c7f177d437dc869
-  languageName: node
-  linkType: hard
-
-"expo-symbols@npm:^56.0.5":
-  version: 56.0.5
-  resolution: "expo-symbols@npm:56.0.5"
-  dependencies:
-    "@expo-google-fonts/material-symbols": "npm:^0.4.1"
-    sf-symbols-typescript: "npm:^2.0.0"
-  peerDependencies:
-    expo: "*"
-    expo-font: "*"
-    react: "*"
-    react-native: "*"
-  checksum: 10/2b4dc0b78956a9738e0e4d7e35e5888e1b188e3318028f7bd44d0f13c5aab0b2ec756cf33dccffbacd4ddfa7bdde8761836db59873b601a4312be401c8819d79
-  languageName: node
-  linkType: hard
-
-"expo-symbols@npm:^56.0.6":
-  version: 56.0.6
-  resolution: "expo-symbols@npm:56.0.6"
-  dependencies:
-    "@expo-google-fonts/material-symbols": "npm:^0.4.1"
-    sf-symbols-typescript: "npm:^2.0.0"
-  peerDependencies:
-    expo: "*"
-    expo-font: "*"
-    react: "*"
-    react-native: "*"
-  checksum: 10/9c6c49c6019849274f57789ffc9c9e684a46459203734b0fef6271d617899325be53803a37de37083e5c46578c2b18f76acb302f717a83c3e4a4cc66cdcac0c8
-  languageName: node
-  linkType: hard
-
 "expo@npm:^56.0.8":
   version: 56.0.8
   resolution: "expo@npm:56.0.8"
@@ -9788,60 +7179,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"expo@npm:~56.0.9":
-  version: 56.0.9
-  resolution: "expo@npm:56.0.9"
-  dependencies:
-    "@babel/runtime": "npm:^7.20.0"
-    "@expo/cli": "npm:^56.1.14"
-    "@expo/config": "npm:~56.0.9"
-    "@expo/config-plugins": "npm:~56.0.8"
-    "@expo/devtools": "npm:~56.0.2"
-    "@expo/dom-webview": "npm:~56.0.5"
-    "@expo/fingerprint": "npm:^0.19.4"
-    "@expo/local-build-cache-provider": "npm:^56.0.8"
-    "@expo/log-box": "npm:^56.0.12"
-    "@expo/metro": "npm:~56.0.0"
-    "@expo/metro-config": "npm:~56.0.13"
-    "@ungap/structured-clone": "npm:^1.3.0"
-    babel-preset-expo: "npm:~56.0.14"
-    expo-asset: "npm:~56.0.16"
-    expo-constants: "npm:~56.0.17"
-    expo-file-system: "npm:~56.0.7"
-    expo-font: "npm:~56.0.5"
-    expo-keep-awake: "npm:~56.0.3"
-    expo-modules-autolinking: "npm:~56.0.15"
-    expo-modules-core: "npm:~56.0.15"
-    pretty-format: "npm:^29.7.0"
-    react-refresh: "npm:^0.14.2"
-    whatwg-url-minimum: "npm:^0.1.2"
-  peerDependencies:
-    "@expo/dom-webview": "*"
-    "@expo/metro-runtime": "*"
-    react: "*"
-    react-dom: "*"
-    react-native: "*"
-    react-native-web: "*"
-    react-native-webview: "*"
-  peerDependenciesMeta:
-    "@expo/dom-webview":
-      optional: true
-    "@expo/metro-runtime":
-      optional: true
-    react-dom:
-      optional: true
-    react-native-web:
-      optional: true
-    react-native-webview:
-      optional: true
-  bin:
-    expo: bin/cli
-    expo-modules-autolinking: bin/autolinking
-    fingerprint: bin/fingerprint
-  checksum: 10/fe25e8905e16040eef97177fc3f6993a6eb56df2f563efaeed8ac86cf1d2038b44df83a6364fe5c9bc6066e7aef1bdfa40da30fcc5692fd169f3b86eccc0a4f4
-  languageName: node
-  linkType: hard
-
 "exponential-backoff@npm:^3.1.1":
   version: 3.1.3
   resolution: "exponential-backoff@npm:3.1.3"
@@ -9870,7 +7207,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fast-glob@npm:^3.2.9, fast-glob@npm:^3.3.2, fast-glob@npm:^3.3.3":
+"fast-glob@npm:^3.2.9, fast-glob@npm:^3.3.3":
   version: 3.3.3
   resolution: "fast-glob@npm:3.3.3"
   dependencies:
@@ -9897,42 +7234,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fast-xml-builder@npm:^1.2.0":
-  version: 1.2.0
-  resolution: "fast-xml-builder@npm:1.2.0"
-  dependencies:
-    path-expression-matcher: "npm:^1.5.0"
-    xml-naming: "npm:^0.1.0"
-  checksum: 10/5948add7796879d03b6c779cbb17f2f203a41cdf23dfaaa4789c65078a36376cd0709a6586701e980e3d244ebd5fdb35db1235ccb5e4fb9e9abfd8c51e7b8813
-  languageName: node
-  linkType: hard
-
-"fast-xml-parser@npm:^4.4.1":
-  version: 4.5.6
-  resolution: "fast-xml-parser@npm:4.5.6"
-  dependencies:
-    strnum: "npm:^1.0.5"
-  bin:
-    fxparser: src/cli/cli.js
-  checksum: 10/dd77cce4b1b322400339147b72b2d315bddc12c6ed3ca82bfc87543ced6dd8d81a6e0b429489e2f048f39258aa2023580654c8934881c633b9d58a6e79672349
-  languageName: node
-  linkType: hard
-
-"fast-xml-parser@npm:^5.3.6":
-  version: 5.8.0
-  resolution: "fast-xml-parser@npm:5.8.0"
-  dependencies:
-    "@nodable/entities": "npm:^2.1.0"
-    fast-xml-builder: "npm:^1.2.0"
-    path-expression-matcher: "npm:^1.5.0"
-    strnum: "npm:^2.3.0"
-    xml-naming: "npm:^0.1.0"
-  bin:
-    fxparser: src/cli/cli.js
-  checksum: 10/0167d17d5275c95e005639f8fca7b4d88fec3fd013063725280f4e982313b1c798e4565d5ced7f61ce10e8f0d876a1976492cc8ac27da3080915ff549fd00705
-  languageName: node
-  linkType: hard
-
 "fastq@npm:^1.6.0":
   version: 1.20.1
   resolution: "fastq@npm:1.20.1"
@@ -10028,7 +7329,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"find-up@npm:^4.0.0, find-up@npm:^4.1.0":
+"find-up@npm:^4.1.0":
   version: 4.1.0
   resolution: "find-up@npm:4.1.0"
   dependencies:
@@ -10127,17 +7428,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fs-extra@npm:^8.1.0":
-  version: 8.1.0
-  resolution: "fs-extra@npm:8.1.0"
-  dependencies:
-    graceful-fs: "npm:^4.2.0"
-    jsonfile: "npm:^4.0.0"
-    universalify: "npm:^0.1.0"
-  checksum: 10/6fb12449f5349be724a138b4a7b45fe6a317d2972054517f5971959c26fbd17c0e145731a11c7324460262baa33e0a799b183ceace98f7a372c95fbb6f20f5de
-  languageName: node
-  linkType: hard
-
 "fs-minipass@npm:^3.0.0":
   version: 3.0.3
   resolution: "fs-minipass@npm:3.0.3"
@@ -10154,7 +7444,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fsevents@npm:^2.3.2, fsevents@npm:^2.3.3":
+"fsevents@npm:^2.3.2":
   version: 2.3.3
   resolution: "fsevents@npm:2.3.3"
   dependencies:
@@ -10164,7 +7454,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fsevents@patch:fsevents@npm%3A^2.3.2#optional!builtin<compat/fsevents>, fsevents@patch:fsevents@npm%3A^2.3.3#optional!builtin<compat/fsevents>":
+"fsevents@patch:fsevents@npm%3A^2.3.2#optional!builtin<compat/fsevents>":
   version: 2.3.3
   resolution: "fsevents@patch:fsevents@npm%3A2.3.3#optional!builtin<compat/fsevents>::version=2.3.3&hash=df0bf1"
   dependencies:
@@ -10222,7 +7512,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"get-caller-file@npm:^2.0.1, get-caller-file@npm:^2.0.5":
+"get-caller-file@npm:^2.0.5":
   version: 2.0.5
   resolution: "get-caller-file@npm:2.0.5"
   checksum: 10/b9769a836d2a98c3ee734a88ba712e62703f1df31b94b784762c433c27a386dd6029ff55c2a920c392e33657d80191edbf18c61487e198844844516f843496b9
@@ -10283,13 +7573,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"get-stream@npm:^6.0.0":
-  version: 6.0.1
-  resolution: "get-stream@npm:6.0.1"
-  checksum: 10/781266d29725f35c59f1d214aedc92b0ae855800a980800e2923b3fbc4e56b3cb6e462c42e09a1cf1a00c64e056a78fa407cbe06c7c92b7e5cd49b4b85c2a497
-  languageName: node
-  linkType: hard
-
 "get-symbol-description@npm:^1.1.0":
   version: 1.1.0
   resolution: "get-symbol-description@npm:1.1.0"
@@ -10326,7 +7609,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"glob@npm:^10.3.10, glob@npm:^10.5.0":
+"glob@npm:^10.5.0":
   version: 10.5.0
   resolution: "glob@npm:10.5.0"
   dependencies:
@@ -10409,6 +7692,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"globby@npm:^14.0.2":
+  version: 14.1.0
+  resolution: "globby@npm:14.1.0"
+  dependencies:
+    "@sindresorhus/merge-streams": "npm:^2.1.0"
+    fast-glob: "npm:^3.3.3"
+    ignore: "npm:^7.0.3"
+    path-type: "npm:^6.0.0"
+    slash: "npm:^5.1.0"
+    unicorn-magic: "npm:^0.3.0"
+  checksum: 10/e527ff54f0dddf60abfabd0d9e799768619d957feecd8b13ef60481f270bfdce0d28f6b09267c60f8064798fb3003b8ec991375f7fe0233fbce5304e1741368c
+  languageName: node
+  linkType: hard
+
 "gopd@npm:^1.0.1, gopd@npm:^1.2.0":
   version: 1.2.0
   resolution: "gopd@npm:1.2.0"
@@ -10416,7 +7713,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"graceful-fs@npm:^4.1.3, graceful-fs@npm:^4.1.6, graceful-fs@npm:^4.2.0, graceful-fs@npm:^4.2.11, graceful-fs@npm:^4.2.4, graceful-fs@npm:^4.2.6, graceful-fs@npm:^4.2.9":
+"graceful-fs@npm:^4.1.6, graceful-fs@npm:^4.2.0, graceful-fs@npm:^4.2.4, graceful-fs@npm:^4.2.6, graceful-fs@npm:^4.2.9":
   version: 4.2.11
   resolution: "graceful-fs@npm:4.2.11"
   checksum: 10/bf152d0ed1dc159239db1ba1f74fdbc40cb02f626770dcd5815c427ce0688c2635a06ed69af364396da4636d0408fcf7d4afdf7881724c3307e46aff30ca49e2
@@ -10494,6 +7791,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"hermes-compiler@npm:0.14.1":
+  version: 0.14.1
+  resolution: "hermes-compiler@npm:0.14.1"
+  checksum: 10/dbb0f4886532b26262721fa34de5947502b265cea8574f6094915abf59d31c757da6a41730cb6f6d088ec7607d659e8b4036782d227dcf072e9a49152bbef756
+  languageName: node
+  linkType: hard
+
 "hermes-compiler@npm:250829098.0.10":
   version: 250829098.0.10
   resolution: "hermes-compiler@npm:250829098.0.10"
@@ -10515,6 +7819,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"hermes-estree@npm:0.32.0":
+  version: 0.32.0
+  resolution: "hermes-estree@npm:0.32.0"
+  checksum: 10/65a30a86a5a560152a2de1842c7bc7ecdadebd62e9cdd7d1809a824de7bc19e8d6a42907d3caff91d9f823862405d4b200447aa0bc25ba16072937e93d0acbd5
+  languageName: node
+  linkType: hard
+
 "hermes-estree@npm:0.33.3":
   version: 0.33.3
   resolution: "hermes-estree@npm:0.33.3"
@@ -10547,6 +7858,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"hermes-parser@npm:0.32.0":
+  version: 0.32.0
+  resolution: "hermes-parser@npm:0.32.0"
+  dependencies:
+    hermes-estree: "npm:0.32.0"
+  checksum: 10/496210490cb45e97df14796d94aec6c817c4cefa20f1dbe3ba1df323cc58c930033cfec93f3ecfad6b90e09166fc9ffc4f665843d25b4862523aa70dacbae81f
+  languageName: node
+  linkType: hard
+
 "hermes-parser@npm:0.33.3, hermes-parser@npm:^0.33.3":
   version: 0.33.3
   resolution: "hermes-parser@npm:0.33.3"
@@ -10565,15 +7885,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"hoist-non-react-statics@npm:^3.3.0":
-  version: 3.3.2
-  resolution: "hoist-non-react-statics@npm:3.3.2"
-  dependencies:
-    react-is: "npm:^16.7.0"
-  checksum: 10/1acbe85f33e5a39f90c822ad4d28b24daeb60f71c545279431dc98c312cd28a54f8d64788e477fe21dc502b0e3cf58589ebe5c1ad22af27245370391c2d24ea6
-  languageName: node
-  linkType: hard
-
 "hosted-git-info@npm:^7.0.0":
   version: 7.0.2
   resolution: "hosted-git-info@npm:7.0.2"
@@ -10590,13 +7901,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"html-escaper@npm:^2.0.0":
-  version: 2.0.2
-  resolution: "html-escaper@npm:2.0.2"
-  checksum: 10/034d74029dcca544a34fb6135e98d427acd73019796ffc17383eaa3ec2fe1c0471dcbbc8f8ed39e46e86d43ccd753a160631615e4048285e313569609b66d5b7
-  languageName: node
-  linkType: hard
-
 "http-cache-semantics@npm:^4.1.1":
   version: 4.2.0
   resolution: "http-cache-semantics@npm:4.2.0"
@@ -10604,7 +7908,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"http-errors@npm:^2.0.0, http-errors@npm:~2.0.1":
+"http-errors@npm:~2.0.1":
   version: 2.0.1
   resolution: "http-errors@npm:2.0.1"
   dependencies:
@@ -10651,14 +7955,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"human-signals@npm:^2.1.0":
-  version: 2.1.0
-  resolution: "human-signals@npm:2.1.0"
-  checksum: 10/df59be9e0af479036798a881d1f136c4a29e0b518d4abb863afbd11bf30efa3eeb1d0425fc65942dcc05ab3bf40205ea436b0ff389f2cd20b75b8643d539bf86
-  languageName: node
-  linkType: hard
-
-"iconv-lite@npm:^0.7.0, iconv-lite@npm:^0.7.2, iconv-lite@npm:~0.7.0":
+"iconv-lite@npm:^0.7.2":
   version: 0.7.2
   resolution: "iconv-lite@npm:0.7.2"
   dependencies:
@@ -10667,16 +7964,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"iconv-lite@npm:~0.4.24":
-  version: 0.4.24
-  resolution: "iconv-lite@npm:0.4.24"
-  dependencies:
-    safer-buffer: "npm:>= 2.1.2 < 3"
-  checksum: 10/6d3a2dac6e5d1fb126d25645c25c3a1209f70cceecc68b8ef51ae0da3cdc078c151fade7524a30b12a3094926336831fca09c666ef55b37e2c69638b5d6bd2e3
-  languageName: node
-  linkType: hard
-
-"ieee754@npm:^1.1.13, ieee754@npm:^1.2.1":
+"ieee754@npm:^1.2.1":
   version: 1.2.1
   resolution: "ieee754@npm:1.2.1"
   checksum: 10/d9f2557a59036f16c282aaeb107832dc957a93d73397d89bbad4eb1130560560eb695060145e8e6b3b498b15ab95510226649a0b8f52ae06583575419fe10fc4
@@ -10690,6 +7978,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"ignore@npm:^7.0.3":
+  version: 7.0.5
+  resolution: "ignore@npm:7.0.5"
+  checksum: 10/f134b96a4de0af419196f52c529d5c6120c4456ff8a6b5a14ceaaa399f883e15d58d2ce651c9b69b9388491d4669dda47285d307e827de9304a53a1824801bc6
+  languageName: node
+  linkType: hard
+
 "image-size@npm:^1.0.2":
   version: 1.2.1
   resolution: "image-size@npm:1.2.1"
@@ -10701,7 +7996,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"import-fresh@npm:^3.2.1, import-fresh@npm:^3.3.0, import-fresh@npm:^3.3.1":
+"import-fresh@npm:^3.2.1, import-fresh@npm:^3.3.1":
   version: 3.3.1
   resolution: "import-fresh@npm:3.3.1"
   dependencies:
@@ -10711,18 +8006,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"import-local@npm:^3.0.2, import-local@npm:^3.2.0":
-  version: 3.2.0
-  resolution: "import-local@npm:3.2.0"
-  dependencies:
-    pkg-dir: "npm:^4.2.0"
-    resolve-cwd: "npm:^3.0.0"
-  bin:
-    import-local-fixture: fixtures/cli.js
-  checksum: 10/0b0b0b412b2521739fbb85eeed834a3c34de9bc67e670b3d0b86248fc460d990a7b116ad056c084b87a693ef73d1f17268d6a5be626bb43c998a8b1c8a230004
-  languageName: node
-  linkType: hard
-
 "import-meta-resolve@npm:^4.1.0":
   version: 4.2.0
   resolution: "import-meta-resolve@npm:4.2.0"
@@ -10754,7 +8037,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"inherits@npm:2, inherits@npm:^2.0.3, inherits@npm:^2.0.4, inherits@npm:~2.0.3, inherits@npm:~2.0.4":
+"inherits@npm:2, inherits@npm:~2.0.3, inherits@npm:~2.0.4":
   version: 2.0.4
   resolution: "inherits@npm:2.0.4"
   checksum: 10/cd45e923bee15186c07fa4c89db0aace24824c482fb887b528304694b2aa6ff8a898da8657046a5dcf3e46cd6db6c61629551f9215f208d7c3f157cf9b290521
@@ -10833,13 +8116,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-arrayish@npm:^0.2.1":
-  version: 0.2.1
-  resolution: "is-arrayish@npm:0.2.1"
-  checksum: 10/73ced84fa35e59e2c57da2d01e12cd01479f381d7f122ce41dcbb713f09dbfc651315832cd2bf8accba7681a69e4d6f1e03941d94dd10040d415086360e7005e
-  languageName: node
-  linkType: hard
-
 "is-arrayish@npm:^0.3.1":
   version: 0.3.4
   resolution: "is-arrayish@npm:0.3.4"
@@ -10948,13 +8224,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-fullwidth-code-point@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "is-fullwidth-code-point@npm:2.0.0"
-  checksum: 10/eef9c6e15f68085fec19ff6a978a6f1b8f48018fd1265035552078ee945573594933b09bbd6f562553e2a241561439f1ef5339276eba68d272001343084cfab8
-  languageName: node
-  linkType: hard
-
 "is-fullwidth-code-point@npm:^3.0.0":
   version: 3.0.0
   resolution: "is-fullwidth-code-point@npm:3.0.0"
@@ -10962,13 +8231,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-generator-fn@npm:^2.0.0, is-generator-fn@npm:^2.1.0":
-  version: 2.1.0
-  resolution: "is-generator-fn@npm:2.1.0"
-  checksum: 10/a6ad5492cf9d1746f73b6744e0c43c0020510b59d56ddcb78a91cbc173f09b5e6beff53d75c9c5a29feb618bfef2bf458e025ecf3a57ad2268e2fb2569f56215
-  languageName: node
-  linkType: hard
-
 "is-generator-function@npm:^1.0.10":
   version: 1.1.2
   resolution: "is-generator-function@npm:1.1.2"
@@ -11018,13 +8280,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-interactive@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "is-interactive@npm:1.0.0"
-  checksum: 10/824808776e2d468b2916cdd6c16acacebce060d844c35ca6d82267da692e92c3a16fdba624c50b54a63f38bdc4016055b6f443ce57d7147240de4f8cdabaf6f9
-  languageName: node
-  linkType: hard
-
 "is-map@npm:^2.0.3":
   version: 2.0.3
   resolution: "is-map@npm:2.0.3"
@@ -11063,6 +8318,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"is-path-cwd@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "is-path-cwd@npm:3.0.0"
+  checksum: 10/bc34d13b6a03dfca4a3ab6a8a5ba78ae4b24f4f1db4b2b031d2760c60d0913bd16a4b980dcb4e590adfc906649d5f5132684079a3972bd219da49deebb9adea8
+  languageName: node
+  linkType: hard
+
 "is-path-inside@npm:^3.0.2, is-path-inside@npm:^3.0.3":
   version: 3.0.3
   resolution: "is-path-inside@npm:3.0.3"
@@ -11070,6 +8332,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"is-path-inside@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "is-path-inside@npm:4.0.0"
+  checksum: 10/8810fa11c58e6360b82c3e0d6cd7d9c7d0392d3ac9eb10f980b81f9839f40ac6d1d6d6f05d069db0d227759801228f0b072e1b6c343e4469b065ab5fe0b68fe5
+  languageName: node
+  linkType: hard
+
 "is-regex@npm:^1.2.1":
   version: 1.2.1
   resolution: "is-regex@npm:1.2.1"
@@ -11153,13 +8422,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-unicode-supported@npm:^0.1.0":
-  version: 0.1.0
-  resolution: "is-unicode-supported@npm:0.1.0"
-  checksum: 10/a2aab86ee7712f5c2f999180daaba5f361bdad1efadc9610ff5b8ab5495b86e4f627839d085c6530363c6d6d4ecbde340fb8e54bdb83da4ba8e0865ed5513c52
-  languageName: node
-  linkType: hard
-
 "is-weakmap@npm:^2.0.2":
   version: 2.0.2
   resolution: "is-weakmap@npm:2.0.2"
@@ -11193,13 +8455,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-wsl@npm:^1.1.0":
-  version: 1.1.0
-  resolution: "is-wsl@npm:1.1.0"
-  checksum: 10/ea157d232351e68c92bd62fc541771096942fe72f69dff452dd26dcc31466258c570a3b04b8cda2e01cd2968255b02951b8670d08ea4ed76d6b1a646061ac4fe
-  languageName: node
-  linkType: hard
-
 "is-wsl@npm:^2.1.1, is-wsl@npm:^2.2.0":
   version: 2.2.0
   resolution: "is-wsl@npm:2.2.0"
@@ -11230,7 +8485,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"istanbul-lib-coverage@npm:^3.0.0, istanbul-lib-coverage@npm:^3.2.0":
+"istanbul-lib-coverage@npm:^3.2.0":
   version: 3.2.2
   resolution: "istanbul-lib-coverage@npm:3.2.2"
   checksum: 10/40bbdd1e937dfd8c830fa286d0f665e81b7a78bdabcd4565f6d5667c99828bda3db7fb7ac6b96a3e2e8a2461ddbc5452d9f8bc7d00cb00075fa6a3e99f5b6a81
@@ -11250,62 +8505,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"istanbul-lib-instrument@npm:^6.0.0, istanbul-lib-instrument@npm:^6.0.2":
-  version: 6.0.3
-  resolution: "istanbul-lib-instrument@npm:6.0.3"
-  dependencies:
-    "@babel/core": "npm:^7.23.9"
-    "@babel/parser": "npm:^7.23.9"
-    "@istanbuljs/schema": "npm:^0.1.3"
-    istanbul-lib-coverage: "npm:^3.2.0"
-    semver: "npm:^7.5.4"
-  checksum: 10/aa5271c0008dfa71b6ecc9ba1e801bf77b49dc05524e8c30d58aaf5b9505e0cd12f25f93165464d4266a518c5c75284ecb598fbd89fec081ae77d2c9d3327695
-  languageName: node
-  linkType: hard
-
-"istanbul-lib-report@npm:^3.0.0":
-  version: 3.0.1
-  resolution: "istanbul-lib-report@npm:3.0.1"
-  dependencies:
-    istanbul-lib-coverage: "npm:^3.0.0"
-    make-dir: "npm:^4.0.0"
-    supports-color: "npm:^7.1.0"
-  checksum: 10/86a83421ca1cf2109a9f6d193c06c31ef04a45e72a74579b11060b1e7bb9b6337a4e6f04abfb8857e2d569c271273c65e855ee429376a0d7c91ad91db42accd1
-  languageName: node
-  linkType: hard
-
-"istanbul-lib-source-maps@npm:^4.0.0":
-  version: 4.0.1
-  resolution: "istanbul-lib-source-maps@npm:4.0.1"
-  dependencies:
-    debug: "npm:^4.1.1"
-    istanbul-lib-coverage: "npm:^3.0.0"
-    source-map: "npm:^0.6.1"
-  checksum: 10/5526983462799aced011d776af166e350191b816821ea7bcf71cab3e5272657b062c47dc30697a22a43656e3ced78893a42de677f9ccf276a28c913190953b82
-  languageName: node
-  linkType: hard
-
-"istanbul-lib-source-maps@npm:^5.0.0":
-  version: 5.0.6
-  resolution: "istanbul-lib-source-maps@npm:5.0.6"
-  dependencies:
-    "@jridgewell/trace-mapping": "npm:^0.3.23"
-    debug: "npm:^4.1.1"
-    istanbul-lib-coverage: "npm:^3.0.0"
-  checksum: 10/569dd0a392ee3464b1fe1accbaef5cc26de3479eacb5b91d8c67ebb7b425d39fd02247d85649c3a0e9c29b600809fa60b5af5a281a75a89c01f385b1e24823a2
-  languageName: node
-  linkType: hard
-
-"istanbul-reports@npm:^3.1.3":
-  version: 3.2.0
-  resolution: "istanbul-reports@npm:3.2.0"
-  dependencies:
-    html-escaper: "npm:^2.0.0"
-    istanbul-lib-report: "npm:^3.0.0"
-  checksum: 10/6773a1d5c7d47eeec75b317144fe2a3b1da84a44b6282bebdc856e09667865e58c9b025b75b3d87f5bc62939126cbba4c871ee84254537d934ba5da5d4c4ec4e
-  languageName: node
-  linkType: hard
-
 "iterator.prototype@npm:^1.1.5":
   version: 1.1.5
   resolution: "iterator.prototype@npm:1.1.5"
@@ -11320,744 +8519,95 @@ __metadata:
   languageName: node
   linkType: hard
 
-"jackspeak@npm:^3.1.2":
-  version: 3.4.3
-  resolution: "jackspeak@npm:3.4.3"
-  dependencies:
-    "@isaacs/cliui": "npm:^8.0.2"
-    "@pkgjs/parseargs": "npm:^0.11.0"
-  dependenciesMeta:
-    "@pkgjs/parseargs":
-      optional: true
-  checksum: 10/96f8786eaab98e4bf5b2a5d6d9588ea46c4d06bbc4f2eb861fdd7b6b182b16f71d8a70e79820f335d52653b16d4843b29dd9cdcf38ae80406756db9199497cf3
-  languageName: node
-  linkType: hard
-
-"jest-changed-files@npm:30.2.0":
-  version: 30.2.0
-  resolution: "jest-changed-files@npm:30.2.0"
-  dependencies:
-    execa: "npm:^5.1.1"
-    jest-util: "npm:30.2.0"
-    p-limit: "npm:^3.1.0"
-  checksum: 10/ff2275ed5839b88c12ffa66fdc5c17ba02d3e276be6b558bed92872c282d050c3fdd1a275a81187cbe35c16d6d40337b85838772836463c7a2fbd1cba9785ca0
-  languageName: node
-  linkType: hard
-
-"jest-changed-files@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-changed-files@npm:29.7.0"
-  dependencies:
-    execa: "npm:^5.0.0"
-    jest-util: "npm:^29.7.0"
-    p-limit: "npm:^3.1.0"
-  checksum: 10/3d93742e56b1a73a145d55b66e96711fbf87ef89b96c2fab7cfdfba8ec06612591a982111ca2b712bb853dbc16831ec8b43585a2a96b83862d6767de59cbf83d
-  languageName: node
-  linkType: hard
-
-"jest-circus@npm:30.2.0":
-  version: 30.2.0
-  resolution: "jest-circus@npm:30.2.0"
-  dependencies:
-    "@jest/environment": "npm:30.2.0"
-    "@jest/expect": "npm:30.2.0"
-    "@jest/test-result": "npm:30.2.0"
-    "@jest/types": "npm:30.2.0"
-    "@types/node": "npm:*"
-    chalk: "npm:^4.1.2"
-    co: "npm:^4.6.0"
-    dedent: "npm:^1.6.0"
-    is-generator-fn: "npm:^2.1.0"
-    jest-each: "npm:30.2.0"
-    jest-matcher-utils: "npm:30.2.0"
-    jest-message-util: "npm:30.2.0"
-    jest-runtime: "npm:30.2.0"
-    jest-snapshot: "npm:30.2.0"
-    jest-util: "npm:30.2.0"
-    p-limit: "npm:^3.1.0"
-    pretty-format: "npm:30.2.0"
-    pure-rand: "npm:^7.0.0"
-    slash: "npm:^3.0.0"
-    stack-utils: "npm:^2.0.6"
-  checksum: 10/68bfc65d92385db1017643988215e4ff5af0b10bcab86fb749a063be6bb7d5eb556dc53dd21bedf833a19aa6ae1a781a8d27b2bea25562de02d294b3017435a9
-  languageName: node
-  linkType: hard
-
-"jest-circus@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-circus@npm:29.7.0"
-  dependencies:
-    "@jest/environment": "npm:^29.7.0"
-    "@jest/expect": "npm:^29.7.0"
-    "@jest/test-result": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
-    "@types/node": "npm:*"
-    chalk: "npm:^4.0.0"
-    co: "npm:^4.6.0"
-    dedent: "npm:^1.0.0"
-    is-generator-fn: "npm:^2.0.0"
-    jest-each: "npm:^29.7.0"
-    jest-matcher-utils: "npm:^29.7.0"
-    jest-message-util: "npm:^29.7.0"
-    jest-runtime: "npm:^29.7.0"
-    jest-snapshot: "npm:^29.7.0"
-    jest-util: "npm:^29.7.0"
-    p-limit: "npm:^3.1.0"
-    pretty-format: "npm:^29.7.0"
-    pure-rand: "npm:^6.0.0"
-    slash: "npm:^3.0.0"
-    stack-utils: "npm:^2.0.3"
-  checksum: 10/716a8e3f40572fd0213bcfc1da90274bf30d856e5133af58089a6ce45089b63f4d679bd44e6be9d320e8390483ebc3ae9921981993986d21639d9019b523123d
-  languageName: node
-  linkType: hard
-
-"jest-cli@npm:30.2.0":
-  version: 30.2.0
-  resolution: "jest-cli@npm:30.2.0"
-  dependencies:
-    "@jest/core": "npm:30.2.0"
-    "@jest/test-result": "npm:30.2.0"
-    "@jest/types": "npm:30.2.0"
-    chalk: "npm:^4.1.2"
-    exit-x: "npm:^0.2.2"
-    import-local: "npm:^3.2.0"
-    jest-config: "npm:30.2.0"
-    jest-util: "npm:30.2.0"
-    jest-validate: "npm:30.2.0"
-    yargs: "npm:^17.7.2"
-  peerDependencies:
-    node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
-  peerDependenciesMeta:
-    node-notifier:
-      optional: true
-  bin:
-    jest: ./bin/jest.js
-  checksum: 10/1cc8304f0e2608801c84cdecce9565a6178f668a6475aed3767a1d82cc539915f98e7404d7c387510313684011dc3095c15397d6725f73aac80fbd96c4155faa
-  languageName: node
-  linkType: hard
-
-"jest-cli@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-cli@npm:29.7.0"
-  dependencies:
-    "@jest/core": "npm:^29.7.0"
-    "@jest/test-result": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
-    chalk: "npm:^4.0.0"
-    create-jest: "npm:^29.7.0"
-    exit: "npm:^0.1.2"
-    import-local: "npm:^3.0.2"
-    jest-config: "npm:^29.7.0"
-    jest-util: "npm:^29.7.0"
-    jest-validate: "npm:^29.7.0"
-    yargs: "npm:^17.3.1"
-  peerDependencies:
-    node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
-  peerDependenciesMeta:
-    node-notifier:
-      optional: true
-  bin:
-    jest: bin/jest.js
-  checksum: 10/6cc62b34d002c034203065a31e5e9a19e7c76d9e8ef447a6f70f759c0714cb212c6245f75e270ba458620f9c7b26063cd8cf6cd1f7e3afd659a7cc08add17307
-  languageName: node
-  linkType: hard
-
-"jest-config@npm:30.2.0":
-  version: 30.2.0
-  resolution: "jest-config@npm:30.2.0"
-  dependencies:
-    "@babel/core": "npm:^7.27.4"
-    "@jest/get-type": "npm:30.1.0"
-    "@jest/pattern": "npm:30.0.1"
-    "@jest/test-sequencer": "npm:30.2.0"
-    "@jest/types": "npm:30.2.0"
-    babel-jest: "npm:30.2.0"
-    chalk: "npm:^4.1.2"
-    ci-info: "npm:^4.2.0"
-    deepmerge: "npm:^4.3.1"
-    glob: "npm:^10.3.10"
-    graceful-fs: "npm:^4.2.11"
-    jest-circus: "npm:30.2.0"
-    jest-docblock: "npm:30.2.0"
-    jest-environment-node: "npm:30.2.0"
-    jest-regex-util: "npm:30.0.1"
-    jest-resolve: "npm:30.2.0"
-    jest-runner: "npm:30.2.0"
-    jest-util: "npm:30.2.0"
-    jest-validate: "npm:30.2.0"
-    micromatch: "npm:^4.0.8"
-    parse-json: "npm:^5.2.0"
-    pretty-format: "npm:30.2.0"
-    slash: "npm:^3.0.0"
-    strip-json-comments: "npm:^3.1.1"
-  peerDependencies:
-    "@types/node": "*"
-    esbuild-register: ">=3.4.0"
-    ts-node: ">=9.0.0"
-  peerDependenciesMeta:
-    "@types/node":
-      optional: true
-    esbuild-register:
-      optional: true
-    ts-node:
-      optional: true
-  checksum: 10/296786b0a3d62de77e2f691f208d54ab541c1a73f87747d922eda643c6f25b89125ef3150170c07a6c8a316a30c15428e46237d499f688b0777f38de8a61ad16
-  languageName: node
-  linkType: hard
-
-"jest-config@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-config@npm:29.7.0"
-  dependencies:
-    "@babel/core": "npm:^7.11.6"
-    "@jest/test-sequencer": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
-    babel-jest: "npm:^29.7.0"
-    chalk: "npm:^4.0.0"
-    ci-info: "npm:^3.2.0"
-    deepmerge: "npm:^4.2.2"
-    glob: "npm:^7.1.3"
-    graceful-fs: "npm:^4.2.9"
-    jest-circus: "npm:^29.7.0"
-    jest-environment-node: "npm:^29.7.0"
-    jest-get-type: "npm:^29.6.3"
-    jest-regex-util: "npm:^29.6.3"
-    jest-resolve: "npm:^29.7.0"
-    jest-runner: "npm:^29.7.0"
-    jest-util: "npm:^29.7.0"
-    jest-validate: "npm:^29.7.0"
-    micromatch: "npm:^4.0.4"
-    parse-json: "npm:^5.2.0"
-    pretty-format: "npm:^29.7.0"
-    slash: "npm:^3.0.0"
-    strip-json-comments: "npm:^3.1.1"
-  peerDependencies:
-    "@types/node": "*"
-    ts-node: ">=9.0.0"
-  peerDependenciesMeta:
-    "@types/node":
-      optional: true
-    ts-node:
-      optional: true
-  checksum: 10/6bdf570e9592e7d7dd5124fc0e21f5fe92bd15033513632431b211797e3ab57eaa312f83cc6481b3094b72324e369e876f163579d60016677c117ec4853cf02b
-  languageName: node
-  linkType: hard
-
-"jest-diff@npm:30.2.0":
-  version: 30.2.0
-  resolution: "jest-diff@npm:30.2.0"
-  dependencies:
-    "@jest/diff-sequences": "npm:30.0.1"
-    "@jest/get-type": "npm:30.1.0"
-    chalk: "npm:^4.1.2"
-    pretty-format: "npm:30.2.0"
-  checksum: 10/1fb9e4fb7dff81814b4f69eaa7db28e184d62306a3a8ea2447d02ca53d2cfa771e83ede513f67ec5239dffacfaac32ff2b49866d211e4c7516f51c1fc06ede42
-  languageName: node
-  linkType: hard
-
-"jest-diff@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-diff@npm:29.7.0"
-  dependencies:
-    chalk: "npm:^4.0.0"
-    diff-sequences: "npm:^29.6.3"
-    jest-get-type: "npm:^29.6.3"
-    pretty-format: "npm:^29.7.0"
-  checksum: 10/6f3a7eb9cd9de5ea9e5aa94aed535631fa6f80221832952839b3cb59dd419b91c20b73887deb0b62230d06d02d6b6cf34ebb810b88d904bb4fe1e2e4f0905c98
-  languageName: node
-  linkType: hard
-
-"jest-docblock@npm:30.2.0":
-  version: 30.2.0
-  resolution: "jest-docblock@npm:30.2.0"
-  dependencies:
-    detect-newline: "npm:^3.1.0"
-  checksum: 10/e01a7d1193947ed0f9713c26bfc7852e51cb758cafec807e5665a0a8d582473a43778bee099f8aa5c70b2941963e5341f4b10bd86b036a4fa3bcec0f4c04e099
-  languageName: node
-  linkType: hard
-
-"jest-docblock@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-docblock@npm:29.7.0"
-  dependencies:
-    detect-newline: "npm:^3.0.0"
-  checksum: 10/8d48818055bc96c9e4ec2e217a5a375623c0d0bfae8d22c26e011074940c202aa2534a3362294c81d981046885c05d304376afba9f2874143025981148f3e96d
-  languageName: node
-  linkType: hard
-
-"jest-each@npm:30.2.0":
-  version: 30.2.0
-  resolution: "jest-each@npm:30.2.0"
-  dependencies:
-    "@jest/get-type": "npm:30.1.0"
-    "@jest/types": "npm:30.2.0"
-    chalk: "npm:^4.1.2"
-    jest-util: "npm:30.2.0"
-    pretty-format: "npm:30.2.0"
-  checksum: 10/f95e7dc1cef4b6a77899325702a214834ae25d01276cc31279654dc7e04f63c1925a37848dd16a0d16508c0fd3d182145f43c10af93952b7a689df3aeac198e9
-  languageName: node
-  linkType: hard
-
-"jest-each@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-each@npm:29.7.0"
-  dependencies:
-    "@jest/types": "npm:^29.6.3"
-    chalk: "npm:^4.0.0"
-    jest-get-type: "npm:^29.6.3"
-    jest-util: "npm:^29.7.0"
-    pretty-format: "npm:^29.7.0"
-  checksum: 10/bd1a077654bdaa013b590deb5f7e7ade68f2e3289180a8c8f53bc8a49f3b40740c0ec2d3a3c1aee906f682775be2bebbac37491d80b634d15276b0aa0f2e3fda
-  languageName: node
-  linkType: hard
-
-"jest-environment-node@npm:30.2.0":
-  version: 30.2.0
-  resolution: "jest-environment-node@npm:30.2.0"
-  dependencies:
-    "@jest/environment": "npm:30.2.0"
-    "@jest/fake-timers": "npm:30.2.0"
-    "@jest/types": "npm:30.2.0"
-    "@types/node": "npm:*"
-    jest-mock: "npm:30.2.0"
-    jest-util: "npm:30.2.0"
-    jest-validate: "npm:30.2.0"
-  checksum: 10/7918bfea7367bd3e12dbbc4ea5afb193b5c47e480a6d1382512f051e2f028458fc9f5ef2f6260737ad41a0b1894661790ff3aaf3cbb4148a33ce2ce7aec64847
-  languageName: node
-  linkType: hard
-
-"jest-environment-node@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-environment-node@npm:29.7.0"
-  dependencies:
-    "@jest/environment": "npm:^29.7.0"
-    "@jest/fake-timers": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
-    "@types/node": "npm:*"
-    jest-mock: "npm:^29.7.0"
-    jest-util: "npm:^29.7.0"
-  checksum: 10/9cf7045adf2307cc93aed2f8488942e39388bff47ec1df149a997c6f714bfc66b2056768973770d3f8b1bf47396c19aa564877eb10ec978b952c6018ed1bd637
-  languageName: node
-  linkType: hard
-
-"jest-get-type@npm:^29.6.3":
-  version: 29.6.3
-  resolution: "jest-get-type@npm:29.6.3"
-  checksum: 10/88ac9102d4679d768accae29f1e75f592b760b44277df288ad76ce5bf038c3f5ce3719dea8aa0f035dac30e9eb034b848ce716b9183ad7cc222d029f03e92205
-  languageName: node
-  linkType: hard
-
-"jest-haste-map@npm:30.2.0":
-  version: 30.2.0
-  resolution: "jest-haste-map@npm:30.2.0"
-  dependencies:
-    "@jest/types": "npm:30.2.0"
-    "@types/node": "npm:*"
-    anymatch: "npm:^3.1.3"
-    fb-watchman: "npm:^2.0.2"
-    fsevents: "npm:^2.3.3"
-    graceful-fs: "npm:^4.2.11"
-    jest-regex-util: "npm:30.0.1"
-    jest-util: "npm:30.2.0"
-    jest-worker: "npm:30.2.0"
-    micromatch: "npm:^4.0.8"
-    walker: "npm:^1.0.8"
-  dependenciesMeta:
-    fsevents:
-      optional: true
-  checksum: 10/a88be6b0b672144aa30fe2d72e630d639c8d8729ee2cef84d0f830eac2005ac021cd8354f8ed8ecd74223f6a8b281efb62f466f5c9e01ed17650e38761051f4c
-  languageName: node
-  linkType: hard
-
-"jest-haste-map@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-haste-map@npm:29.7.0"
-  dependencies:
-    "@jest/types": "npm:^29.6.3"
-    "@types/graceful-fs": "npm:^4.1.3"
-    "@types/node": "npm:*"
-    anymatch: "npm:^3.0.3"
-    fb-watchman: "npm:^2.0.0"
-    fsevents: "npm:^2.3.2"
-    graceful-fs: "npm:^4.2.9"
-    jest-regex-util: "npm:^29.6.3"
-    jest-util: "npm:^29.7.0"
-    jest-worker: "npm:^29.7.0"
-    micromatch: "npm:^4.0.4"
-    walker: "npm:^1.0.8"
-  dependenciesMeta:
-    fsevents:
-      optional: true
-  checksum: 10/8531b42003581cb18a69a2774e68c456fb5a5c3280b1b9b77475af9e346b6a457250f9d756bfeeae2fe6cbc9ef28434c205edab9390ee970a919baddfa08bb85
-  languageName: node
-  linkType: hard
-
-"jest-leak-detector@npm:30.2.0":
-  version: 30.2.0
-  resolution: "jest-leak-detector@npm:30.2.0"
-  dependencies:
-    "@jest/get-type": "npm:30.1.0"
-    pretty-format: "npm:30.2.0"
-  checksum: 10/c430d6ed7910b2174738fbdca4ea64cbfe805216414c0d143c1090148f1389fec99d0733c0a8ed0a86709c89b4a4085b4749ac3a2cbc7deaf3ca87457afd24fc
-  languageName: node
-  linkType: hard
-
-"jest-leak-detector@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-leak-detector@npm:29.7.0"
-  dependencies:
-    jest-get-type: "npm:^29.6.3"
-    pretty-format: "npm:^29.7.0"
-  checksum: 10/e3950e3ddd71e1d0c22924c51a300a1c2db6cf69ec1e51f95ccf424bcc070f78664813bef7aed4b16b96dfbdeea53fe358f8aeaaea84346ae15c3735758f1605
-  languageName: node
-  linkType: hard
-
-"jest-matcher-utils@npm:30.2.0":
-  version: 30.2.0
-  resolution: "jest-matcher-utils@npm:30.2.0"
-  dependencies:
-    "@jest/get-type": "npm:30.1.0"
-    chalk: "npm:^4.1.2"
-    jest-diff: "npm:30.2.0"
-    pretty-format: "npm:30.2.0"
-  checksum: 10/f3f1ecf68ca63c9d1d80a175637a8fc655edfd1ee83220f6e3f6bd464ecbe2f93148fdd440a5a5e5a2b0b2cc8ee84ddc3dcef58a6dbc66821c792f48d260c6d4
-  languageName: node
-  linkType: hard
-
-"jest-matcher-utils@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-matcher-utils@npm:29.7.0"
-  dependencies:
-    chalk: "npm:^4.0.0"
-    jest-diff: "npm:^29.7.0"
-    jest-get-type: "npm:^29.6.3"
-    pretty-format: "npm:^29.7.0"
-  checksum: 10/981904a494299cf1e3baed352f8a3bd8b50a8c13a662c509b6a53c31461f94ea3bfeffa9d5efcfeb248e384e318c87de7e3baa6af0f79674e987482aa189af40
-  languageName: node
-  linkType: hard
-
-"jest-message-util@npm:30.2.0":
-  version: 30.2.0
-  resolution: "jest-message-util@npm:30.2.0"
-  dependencies:
-    "@babel/code-frame": "npm:^7.27.1"
-    "@jest/types": "npm:30.2.0"
-    "@types/stack-utils": "npm:^2.0.3"
-    chalk: "npm:^4.1.2"
-    graceful-fs: "npm:^4.2.11"
-    micromatch: "npm:^4.0.8"
-    pretty-format: "npm:30.2.0"
-    slash: "npm:^3.0.0"
-    stack-utils: "npm:^2.0.6"
-  checksum: 10/e29ec76e8c8e4da5f5b25198be247535626ccf3a940e93fdd51fc6a6bcf70feaa2921baae3806182a090431d90b08c939eb13fb64249b171d2e9ae3a452a8fd2
-  languageName: node
-  linkType: hard
-
-"jest-message-util@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-message-util@npm:29.7.0"
-  dependencies:
-    "@babel/code-frame": "npm:^7.12.13"
-    "@jest/types": "npm:^29.6.3"
-    "@types/stack-utils": "npm:^2.0.0"
-    chalk: "npm:^4.0.0"
-    graceful-fs: "npm:^4.2.9"
-    micromatch: "npm:^4.0.4"
-    pretty-format: "npm:^29.7.0"
-    slash: "npm:^3.0.0"
-    stack-utils: "npm:^2.0.3"
-  checksum: 10/31d53c6ed22095d86bab9d14c0fa70c4a92c749ea6ceece82cf30c22c9c0e26407acdfbdb0231435dc85a98d6d65ca0d9cbcd25cd1abb377fe945e843fb770b9
-  languageName: node
-  linkType: hard
-
-"jest-mock@npm:30.2.0":
-  version: 30.2.0
-  resolution: "jest-mock@npm:30.2.0"
-  dependencies:
-    "@jest/types": "npm:30.2.0"
-    "@types/node": "npm:*"
-    jest-util: "npm:30.2.0"
-  checksum: 10/cde9b56805f90bf811a9231873ee88a0fb83bf4bf50972ae76960725da65220fcb119688f2e90e1ef33fbfd662194858d7f43809d881f1c41bb55d94e62adeab
-  languageName: node
-  linkType: hard
-
-"jest-mock@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-mock@npm:29.7.0"
-  dependencies:
-    "@jest/types": "npm:^29.6.3"
-    "@types/node": "npm:*"
-    jest-util: "npm:^29.7.0"
-  checksum: 10/ae51d1b4f898724be5e0e52b2268a68fcd876d9b20633c864a6dd6b1994cbc48d62402b0f40f3a1b669b30ebd648821f086c26c08ffde192ced951ff4670d51c
-  languageName: node
-  linkType: hard
-
-"jest-pnp-resolver@npm:^1.2.2, jest-pnp-resolver@npm:^1.2.3":
-  version: 1.2.3
-  resolution: "jest-pnp-resolver@npm:1.2.3"
-  peerDependencies:
-    jest-resolve: "*"
-  peerDependenciesMeta:
-    jest-resolve:
-      optional: true
-  checksum: 10/db1a8ab2cb97ca19c01b1cfa9a9c8c69a143fde833c14df1fab0766f411b1148ff0df878adea09007ac6a2085ec116ba9a996a6ad104b1e58c20adbf88eed9b2
-  languageName: node
-  linkType: hard
-
-"jest-regex-util@npm:30.0.1":
-  version: 30.0.1
-  resolution: "jest-regex-util@npm:30.0.1"
-  checksum: 10/fa8dac80c3e94db20d5e1e51d1bdf101cf5ede8f4e0b8f395ba8b8ea81e71804ffd747452a6bb6413032865de98ac656ef8ae43eddd18d980b6442a2764ed562
-  languageName: node
-  linkType: hard
-
-"jest-regex-util@npm:^29.6.3":
-  version: 29.6.3
-  resolution: "jest-regex-util@npm:29.6.3"
-  checksum: 10/0518beeb9bf1228261695e54f0feaad3606df26a19764bc19541e0fc6e2a3737191904607fb72f3f2ce85d9c16b28df79b7b1ec9443aa08c3ef0e9efda6f8f2a
-  languageName: node
-  linkType: hard
-
-"jest-resolve-dependencies@npm:30.2.0":
-  version: 30.2.0
-  resolution: "jest-resolve-dependencies@npm:30.2.0"
-  dependencies:
-    jest-regex-util: "npm:30.0.1"
-    jest-snapshot: "npm:30.2.0"
-  checksum: 10/0ff1a574f8c07f2e54a4ac8ab17aea00dfe2982e99b03fbd44f4211a94b8e5a59fdc43a59f9d6c0578a10a7b56a0611ad5ab40e4893973ff3f40dd414433b194
-  languageName: node
-  linkType: hard
-
-"jest-resolve-dependencies@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-resolve-dependencies@npm:29.7.0"
-  dependencies:
-    jest-regex-util: "npm:^29.6.3"
-    jest-snapshot: "npm:^29.7.0"
-  checksum: 10/1e206f94a660d81e977bcfb1baae6450cb4a81c92e06fad376cc5ea16b8e8c6ea78c383f39e95591a9eb7f925b6a1021086c38941aa7c1b8a6a813c2f6e93675
-  languageName: node
-  linkType: hard
-
-"jest-resolve@npm:30.2.0":
-  version: 30.2.0
-  resolution: "jest-resolve@npm:30.2.0"
-  dependencies:
-    chalk: "npm:^4.1.2"
-    graceful-fs: "npm:^4.2.11"
-    jest-haste-map: "npm:30.2.0"
-    jest-pnp-resolver: "npm:^1.2.3"
-    jest-util: "npm:30.2.0"
-    jest-validate: "npm:30.2.0"
-    slash: "npm:^3.0.0"
-    unrs-resolver: "npm:^1.7.11"
-  checksum: 10/e1f03da6811a946f5d885ea739a973975d099cc760641f9e1f90ac9c6621408538ba1e909f789d45d6e8d2411b78fb09230f16f15669621aa407aed7511fdf01
-  languageName: node
-  linkType: hard
-
-"jest-resolve@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-resolve@npm:29.7.0"
+"jackspeak@npm:^3.1.2":
+  version: 3.4.3
+  resolution: "jackspeak@npm:3.4.3"
   dependencies:
-    chalk: "npm:^4.0.0"
-    graceful-fs: "npm:^4.2.9"
-    jest-haste-map: "npm:^29.7.0"
-    jest-pnp-resolver: "npm:^1.2.2"
-    jest-util: "npm:^29.7.0"
-    jest-validate: "npm:^29.7.0"
-    resolve: "npm:^1.20.0"
-    resolve.exports: "npm:^2.0.0"
-    slash: "npm:^3.0.0"
-  checksum: 10/faa466fd9bc69ea6c37a545a7c6e808e073c66f46ab7d3d8a6ef084f8708f201b85d5fe1799789578b8b47fa1de47b9ee47b414d1863bc117a49e032ba77b7c7
+    "@isaacs/cliui": "npm:^8.0.2"
+    "@pkgjs/parseargs": "npm:^0.11.0"
+  dependenciesMeta:
+    "@pkgjs/parseargs":
+      optional: true
+  checksum: 10/96f8786eaab98e4bf5b2a5d6d9588ea46c4d06bbc4f2eb861fdd7b6b182b16f71d8a70e79820f335d52653b16d4843b29dd9cdcf38ae80406756db9199497cf3
   languageName: node
   linkType: hard
 
-"jest-runner@npm:30.2.0":
-  version: 30.2.0
-  resolution: "jest-runner@npm:30.2.0"
-  dependencies:
-    "@jest/console": "npm:30.2.0"
-    "@jest/environment": "npm:30.2.0"
-    "@jest/test-result": "npm:30.2.0"
-    "@jest/transform": "npm:30.2.0"
-    "@jest/types": "npm:30.2.0"
-    "@types/node": "npm:*"
-    chalk: "npm:^4.1.2"
-    emittery: "npm:^0.13.1"
-    exit-x: "npm:^0.2.2"
-    graceful-fs: "npm:^4.2.11"
-    jest-docblock: "npm:30.2.0"
-    jest-environment-node: "npm:30.2.0"
-    jest-haste-map: "npm:30.2.0"
-    jest-leak-detector: "npm:30.2.0"
-    jest-message-util: "npm:30.2.0"
-    jest-resolve: "npm:30.2.0"
-    jest-runtime: "npm:30.2.0"
-    jest-util: "npm:30.2.0"
-    jest-watcher: "npm:30.2.0"
-    jest-worker: "npm:30.2.0"
-    p-limit: "npm:^3.1.0"
-    source-map-support: "npm:0.5.13"
-  checksum: 10/d3706aa70e64a7ef8b38360d34ea6c261ba4d0b42136d7fb603c4fa71c24fa81f22c39ed2e39ee0db2363a42827810291f3ceb6a299e5996b41d701ad9b24184
-  languageName: node
-  linkType: hard
-
-"jest-runner@npm:^29.7.0":
+"jest-environment-node@npm:^29.7.0":
   version: 29.7.0
-  resolution: "jest-runner@npm:29.7.0"
+  resolution: "jest-environment-node@npm:29.7.0"
   dependencies:
-    "@jest/console": "npm:^29.7.0"
     "@jest/environment": "npm:^29.7.0"
-    "@jest/test-result": "npm:^29.7.0"
-    "@jest/transform": "npm:^29.7.0"
+    "@jest/fake-timers": "npm:^29.7.0"
     "@jest/types": "npm:^29.6.3"
     "@types/node": "npm:*"
-    chalk: "npm:^4.0.0"
-    emittery: "npm:^0.13.1"
-    graceful-fs: "npm:^4.2.9"
-    jest-docblock: "npm:^29.7.0"
-    jest-environment-node: "npm:^29.7.0"
-    jest-haste-map: "npm:^29.7.0"
-    jest-leak-detector: "npm:^29.7.0"
-    jest-message-util: "npm:^29.7.0"
-    jest-resolve: "npm:^29.7.0"
-    jest-runtime: "npm:^29.7.0"
+    jest-mock: "npm:^29.7.0"
     jest-util: "npm:^29.7.0"
-    jest-watcher: "npm:^29.7.0"
-    jest-worker: "npm:^29.7.0"
-    p-limit: "npm:^3.1.0"
-    source-map-support: "npm:0.5.13"
-  checksum: 10/9d8748a494bd90f5c82acea99be9e99f21358263ce6feae44d3f1b0cd90991b5df5d18d607e73c07be95861ee86d1cbab2a3fc6ca4b21805f07ac29d47c1da1e
+  checksum: 10/9cf7045adf2307cc93aed2f8488942e39388bff47ec1df149a997c6f714bfc66b2056768973770d3f8b1bf47396c19aa564877eb10ec978b952c6018ed1bd637
   languageName: node
   linkType: hard
 
-"jest-runtime@npm:30.2.0":
-  version: 30.2.0
-  resolution: "jest-runtime@npm:30.2.0"
-  dependencies:
-    "@jest/environment": "npm:30.2.0"
-    "@jest/fake-timers": "npm:30.2.0"
-    "@jest/globals": "npm:30.2.0"
-    "@jest/source-map": "npm:30.0.1"
-    "@jest/test-result": "npm:30.2.0"
-    "@jest/transform": "npm:30.2.0"
-    "@jest/types": "npm:30.2.0"
-    "@types/node": "npm:*"
-    chalk: "npm:^4.1.2"
-    cjs-module-lexer: "npm:^2.1.0"
-    collect-v8-coverage: "npm:^1.0.2"
-    glob: "npm:^10.3.10"
-    graceful-fs: "npm:^4.2.11"
-    jest-haste-map: "npm:30.2.0"
-    jest-message-util: "npm:30.2.0"
-    jest-mock: "npm:30.2.0"
-    jest-regex-util: "npm:30.0.1"
-    jest-resolve: "npm:30.2.0"
-    jest-snapshot: "npm:30.2.0"
-    jest-util: "npm:30.2.0"
-    slash: "npm:^3.0.0"
-    strip-bom: "npm:^4.0.0"
-  checksum: 10/81a3a9951420863f001e74c510bf35b85ae983f636f43ee1ffa1618b5a8ddafb681bc2810f71814bc8c8373e9593c89576b2325daf3c765e50057e48d5941df3
+"jest-get-type@npm:^29.6.3":
+  version: 29.6.3
+  resolution: "jest-get-type@npm:29.6.3"
+  checksum: 10/88ac9102d4679d768accae29f1e75f592b760b44277df288ad76ce5bf038c3f5ce3719dea8aa0f035dac30e9eb034b848ce716b9183ad7cc222d029f03e92205
   languageName: node
   linkType: hard
 
-"jest-runtime@npm:^29.7.0":
+"jest-haste-map@npm:^29.7.0":
   version: 29.7.0
-  resolution: "jest-runtime@npm:29.7.0"
+  resolution: "jest-haste-map@npm:29.7.0"
   dependencies:
-    "@jest/environment": "npm:^29.7.0"
-    "@jest/fake-timers": "npm:^29.7.0"
-    "@jest/globals": "npm:^29.7.0"
-    "@jest/source-map": "npm:^29.6.3"
-    "@jest/test-result": "npm:^29.7.0"
-    "@jest/transform": "npm:^29.7.0"
     "@jest/types": "npm:^29.6.3"
+    "@types/graceful-fs": "npm:^4.1.3"
     "@types/node": "npm:*"
-    chalk: "npm:^4.0.0"
-    cjs-module-lexer: "npm:^1.0.0"
-    collect-v8-coverage: "npm:^1.0.0"
-    glob: "npm:^7.1.3"
+    anymatch: "npm:^3.0.3"
+    fb-watchman: "npm:^2.0.0"
+    fsevents: "npm:^2.3.2"
     graceful-fs: "npm:^4.2.9"
-    jest-haste-map: "npm:^29.7.0"
-    jest-message-util: "npm:^29.7.0"
-    jest-mock: "npm:^29.7.0"
     jest-regex-util: "npm:^29.6.3"
-    jest-resolve: "npm:^29.7.0"
-    jest-snapshot: "npm:^29.7.0"
     jest-util: "npm:^29.7.0"
-    slash: "npm:^3.0.0"
-    strip-bom: "npm:^4.0.0"
-  checksum: 10/59eb58eb7e150e0834a2d0c0d94f2a0b963ae7182cfa6c63f2b49b9c6ef794e5193ef1634e01db41420c36a94cefc512cdd67a055cd3e6fa2f41eaf0f82f5a20
-  languageName: node
-  linkType: hard
-
-"jest-snapshot@npm:30.2.0":
-  version: 30.2.0
-  resolution: "jest-snapshot@npm:30.2.0"
-  dependencies:
-    "@babel/core": "npm:^7.27.4"
-    "@babel/generator": "npm:^7.27.5"
-    "@babel/plugin-syntax-jsx": "npm:^7.27.1"
-    "@babel/plugin-syntax-typescript": "npm:^7.27.1"
-    "@babel/types": "npm:^7.27.3"
-    "@jest/expect-utils": "npm:30.2.0"
-    "@jest/get-type": "npm:30.1.0"
-    "@jest/snapshot-utils": "npm:30.2.0"
-    "@jest/transform": "npm:30.2.0"
-    "@jest/types": "npm:30.2.0"
-    babel-preset-current-node-syntax: "npm:^1.2.0"
-    chalk: "npm:^4.1.2"
-    expect: "npm:30.2.0"
-    graceful-fs: "npm:^4.2.11"
-    jest-diff: "npm:30.2.0"
-    jest-matcher-utils: "npm:30.2.0"
-    jest-message-util: "npm:30.2.0"
-    jest-util: "npm:30.2.0"
-    pretty-format: "npm:30.2.0"
-    semver: "npm:^7.7.2"
-    synckit: "npm:^0.11.8"
-  checksum: 10/119390b49f397ed622ba7c375fc15f97af67c4fc49a34cf829c86ee732be2b06ad3c7171c76bb842a0e84a234783f1a4c721909aa316fbe00c6abc7c5962dfbc
+    jest-worker: "npm:^29.7.0"
+    micromatch: "npm:^4.0.4"
+    walker: "npm:^1.0.8"
+  dependenciesMeta:
+    fsevents:
+      optional: true
+  checksum: 10/8531b42003581cb18a69a2774e68c456fb5a5c3280b1b9b77475af9e346b6a457250f9d756bfeeae2fe6cbc9ef28434c205edab9390ee970a919baddfa08bb85
   languageName: node
   linkType: hard
 
-"jest-snapshot@npm:^29.7.0":
+"jest-message-util@npm:^29.7.0":
   version: 29.7.0
-  resolution: "jest-snapshot@npm:29.7.0"
+  resolution: "jest-message-util@npm:29.7.0"
   dependencies:
-    "@babel/core": "npm:^7.11.6"
-    "@babel/generator": "npm:^7.7.2"
-    "@babel/plugin-syntax-jsx": "npm:^7.7.2"
-    "@babel/plugin-syntax-typescript": "npm:^7.7.2"
-    "@babel/types": "npm:^7.3.3"
-    "@jest/expect-utils": "npm:^29.7.0"
-    "@jest/transform": "npm:^29.7.0"
+    "@babel/code-frame": "npm:^7.12.13"
     "@jest/types": "npm:^29.6.3"
-    babel-preset-current-node-syntax: "npm:^1.0.0"
+    "@types/stack-utils": "npm:^2.0.0"
     chalk: "npm:^4.0.0"
-    expect: "npm:^29.7.0"
     graceful-fs: "npm:^4.2.9"
-    jest-diff: "npm:^29.7.0"
-    jest-get-type: "npm:^29.6.3"
-    jest-matcher-utils: "npm:^29.7.0"
-    jest-message-util: "npm:^29.7.0"
-    jest-util: "npm:^29.7.0"
-    natural-compare: "npm:^1.4.0"
+    micromatch: "npm:^4.0.4"
     pretty-format: "npm:^29.7.0"
-    semver: "npm:^7.5.3"
-  checksum: 10/cb19a3948256de5f922d52f251821f99657339969bf86843bd26cf3332eae94883e8260e3d2fba46129a27c3971c1aa522490e460e16c7fad516e82d10bbf9f8
+    slash: "npm:^3.0.0"
+    stack-utils: "npm:^2.0.3"
+  checksum: 10/31d53c6ed22095d86bab9d14c0fa70c4a92c749ea6ceece82cf30c22c9c0e26407acdfbdb0231435dc85a98d6d65ca0d9cbcd25cd1abb377fe945e843fb770b9
   languageName: node
   linkType: hard
 
-"jest-util@npm:30.2.0":
-  version: 30.2.0
-  resolution: "jest-util@npm:30.2.0"
+"jest-mock@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest-mock@npm:29.7.0"
   dependencies:
-    "@jest/types": "npm:30.2.0"
+    "@jest/types": "npm:^29.6.3"
     "@types/node": "npm:*"
-    chalk: "npm:^4.1.2"
-    ci-info: "npm:^4.2.0"
-    graceful-fs: "npm:^4.2.11"
-    picomatch: "npm:^4.0.2"
-  checksum: 10/cf2f2fb83417ea69f9992121561c95cf4e9aad7946819b771b8b52addf78811101b33b51d0a39fa0c305f2751dab262feed7699de052659ff03d51827c8862f5
+    jest-util: "npm:^29.7.0"
+  checksum: 10/ae51d1b4f898724be5e0e52b2268a68fcd876d9b20633c864a6dd6b1994cbc48d62402b0f40f3a1b669b30ebd648821f086c26c08ffde192ced951ff4670d51c
+  languageName: node
+  linkType: hard
+
+"jest-regex-util@npm:^29.6.3":
+  version: 29.6.3
+  resolution: "jest-regex-util@npm:29.6.3"
+  checksum: 10/0518beeb9bf1228261695e54f0feaad3606df26a19764bc19541e0fc6e2a3737191904607fb72f3f2ce85d9c16b28df79b7b1ec9443aa08c3ef0e9efda6f8f2a
   languageName: node
   linkType: hard
 
@@ -12075,20 +8625,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"jest-validate@npm:30.2.0":
-  version: 30.2.0
-  resolution: "jest-validate@npm:30.2.0"
-  dependencies:
-    "@jest/get-type": "npm:30.1.0"
-    "@jest/types": "npm:30.2.0"
-    camelcase: "npm:^6.3.0"
-    chalk: "npm:^4.1.2"
-    leven: "npm:^3.1.0"
-    pretty-format: "npm:30.2.0"
-  checksum: 10/61e66c6df29a1e181f8de063678dd2096bb52cc8a8ead3c9a3f853d54eca458ad04c7fb81931d9274affb67d0504a91a2a520456a139a26665810c3bf039b677
-  languageName: node
-  linkType: hard
-
 "jest-validate@npm:^29.7.0":
   version: 29.7.0
   resolution: "jest-validate@npm:29.7.0"
@@ -12103,51 +8639,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"jest-watcher@npm:30.2.0":
-  version: 30.2.0
-  resolution: "jest-watcher@npm:30.2.0"
-  dependencies:
-    "@jest/test-result": "npm:30.2.0"
-    "@jest/types": "npm:30.2.0"
-    "@types/node": "npm:*"
-    ansi-escapes: "npm:^4.3.2"
-    chalk: "npm:^4.1.2"
-    emittery: "npm:^0.13.1"
-    jest-util: "npm:30.2.0"
-    string-length: "npm:^4.0.2"
-  checksum: 10/fa38d06dcc59dbbd6a9ff22dea499d3c81ed376d9993b82d01797a99bf466d48641a99b9f3670a4b5480ca31144c5e017b96b7059e4d7541358fb48cf517a2db
-  languageName: node
-  linkType: hard
-
-"jest-watcher@npm:^29.7.0":
-  version: 29.7.0
-  resolution: "jest-watcher@npm:29.7.0"
-  dependencies:
-    "@jest/test-result": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
-    "@types/node": "npm:*"
-    ansi-escapes: "npm:^4.2.1"
-    chalk: "npm:^4.0.0"
-    emittery: "npm:^0.13.1"
-    jest-util: "npm:^29.7.0"
-    string-length: "npm:^4.0.1"
-  checksum: 10/4f616e0345676631a7034b1d94971aaa719f0cd4a6041be2aa299be437ea047afd4fe05c48873b7963f5687a2f6c7cbf51244be8b14e313b97bfe32b1e127e55
-  languageName: node
-  linkType: hard
-
-"jest-worker@npm:30.2.0":
-  version: 30.2.0
-  resolution: "jest-worker@npm:30.2.0"
-  dependencies:
-    "@types/node": "npm:*"
-    "@ungap/structured-clone": "npm:^1.3.0"
-    jest-util: "npm:30.2.0"
-    merge-stream: "npm:^2.0.0"
-    supports-color: "npm:^8.1.1"
-  checksum: 10/9354b0c71c80173f673da6bbc0ddaad26e4395b06532f7332e0c1e93e855b873b10139b040e01eda77f3dc5a0b67613e2bd7c56c4947ee771acfc3611de2ca29
-  languageName: node
-  linkType: hard
-
 "jest-worker@npm:^29.7.0":
   version: 29.7.0
   resolution: "jest-worker@npm:29.7.0"
@@ -12160,44 +8651,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"jest@npm:^29.6.3":
-  version: 29.7.0
-  resolution: "jest@npm:29.7.0"
-  dependencies:
-    "@jest/core": "npm:^29.7.0"
-    "@jest/types": "npm:^29.6.3"
-    import-local: "npm:^3.0.2"
-    jest-cli: "npm:^29.7.0"
-  peerDependencies:
-    node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
-  peerDependenciesMeta:
-    node-notifier:
-      optional: true
-  bin:
-    jest: bin/jest.js
-  checksum: 10/97023d78446098c586faaa467fbf2c6b07ff06e2c85a19e3926adb5b0effe9ac60c4913ae03e2719f9c01ae8ffd8d92f6b262cedb9555ceeb5d19263d8c6362a
-  languageName: node
-  linkType: hard
-
-"jest@npm:^30.2.0":
-  version: 30.2.0
-  resolution: "jest@npm:30.2.0"
-  dependencies:
-    "@jest/core": "npm:30.2.0"
-    "@jest/types": "npm:30.2.0"
-    import-local: "npm:^3.2.0"
-    jest-cli: "npm:30.2.0"
-  peerDependencies:
-    node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
-  peerDependenciesMeta:
-    node-notifier:
-      optional: true
-  bin:
-    jest: ./bin/jest.js
-  checksum: 10/61c9d100750e4354cd7305d1f3ba253ffde4deaf12cb4be4d42d54f2dd5986e383a39c4a8691dbdc3839c69094a52413ed36f1886540ac37b71914a990b810d0
-  languageName: node
-  linkType: hard
-
 "jimp-compact@npm:0.16.1":
   version: 0.16.1
   resolution: "jimp-compact@npm:0.16.1"
@@ -12205,19 +8658,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"joi@npm:^17.2.1":
-  version: 17.13.4
-  resolution: "joi@npm:17.13.4"
-  dependencies:
-    "@hapi/hoek": "npm:^9.3.0"
-    "@hapi/topo": "npm:^5.1.0"
-    "@sideway/address": "npm:^4.1.5"
-    "@sideway/formula": "npm:^3.0.1"
-    "@sideway/pinpoint": "npm:^2.0.0"
-  checksum: 10/0e407d4cc6cb0830b93c2d107f8b85113338473296025c31a931589359b58883e61fd183dd7532d3ab1ee014a01a20830a8fca90d9f0217d0c0894ee2cbf9ff5
-  languageName: node
-  linkType: hard
-
 "js-tokens@npm:^3.0.0 || ^4.0.0, js-tokens@npm:^4.0.0":
   version: 4.0.0
   resolution: "js-tokens@npm:4.0.0"
@@ -12278,13 +8718,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"json-parse-even-better-errors@npm:^2.3.0":
-  version: 2.3.1
-  resolution: "json-parse-even-better-errors@npm:2.3.1"
-  checksum: 10/5f3a99009ed5f2a5a67d06e2f298cc97bc86d462034173308156f15b43a6e850be8511dc204b9b94566305da2947f7d90289657237d210351a39059ff9d666cf
-  languageName: node
-  linkType: hard
-
 "json-schema-traverse@npm:^0.4.1":
   version: 0.4.1
   resolution: "json-schema-traverse@npm:0.4.1"
@@ -12308,18 +8741,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"jsonfile@npm:^4.0.0":
-  version: 4.0.0
-  resolution: "jsonfile@npm:4.0.0"
-  dependencies:
-    graceful-fs: "npm:^4.1.6"
-  dependenciesMeta:
-    graceful-fs:
-      optional: true
-  checksum: 10/17796f0ab1be8479827d3683433f97ebe0a1c6932c3360fa40348eac36904d69269aab26f8b16da311882d94b42e9208e8b28e490bf926364f3ac9bff134c226
-  languageName: node
-  linkType: hard
-
 "jsonfile@npm:^6.0.1":
   version: 6.2.0
   resolution: "jsonfile@npm:6.2.0"
@@ -12333,22 +8754,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"jsonrepair@npm:^3.12.0":
-  version: 3.13.2
-  resolution: "jsonrepair@npm:3.13.2"
-  bin:
-    jsonrepair: bin/cli.js
-  checksum: 10/c0c1ec46af1d8e396c22e4d41e4d85eff2c713afdb71b6634a72ed4f356b79259affadb4e79b31042e4c1634313ddc0b3d7960fd74f5fba918198ecc74fe5e82
-  languageName: node
-  linkType: hard
-
-"jsonschema@npm:^1.5.0":
-  version: 1.5.0
-  resolution: "jsonschema@npm:1.5.0"
-  checksum: 10/46bf49b388ba922073bcb3c8d5e90af9d29fc8303dc866fd440182c88d6b4fd2807679fd39cdefb4113156d104ea47da9c0ff4bbcb0032c9fa29461cb1a92182
-  languageName: node
-  linkType: hard
-
 "jsx-ast-utils@npm:^2.4.1 || ^3.0.0":
   version: 3.3.5
   resolution: "jsx-ast-utils@npm:3.3.5"
@@ -12393,16 +8798,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"launch-editor@npm:^2.9.1":
-  version: 2.13.1
-  resolution: "launch-editor@npm:2.13.1"
-  dependencies:
-    picocolors: "npm:^1.1.1"
-    shell-quote: "npm:^1.8.3"
-  checksum: 10/641aafaad6bafe5d33a13d89eff29082b032c1c5c1aa19fb9fa3b54ffcf26a3419f461a7583f6450bd5b11863b061b60049e38c2d5135492bf46f2ed3a2cbc0e
-  languageName: node
-  linkType: hard
-
 "leven@npm:^3.1.0":
   version: 3.1.0
   resolution: "leven@npm:3.1.0"
@@ -12550,65 +8945,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"lines-and-columns@npm:^1.1.6":
-  version: 1.2.4
-  resolution: "lines-and-columns@npm:1.2.4"
-  checksum: 10/0c37f9f7fa212b38912b7145e1cd16a5f3cd34d782441c3e6ca653485d326f58b3caccda66efce1c5812bde4961bbde3374fae4b0d11bf1226152337f3894aa5
-  languageName: node
-  linkType: hard
-
-"linkify-it@npm:^2.0.0":
-  version: 2.2.0
-  resolution: "linkify-it@npm:2.2.0"
-  dependencies:
-    uc.micro: "npm:^1.0.1"
-  checksum: 10/eb51435f581208b44be468a48ab942204fdbadcc71cf9855a8880167b91d59375824cc2f7be9da41b123d25a24a086fe9a832bad0dcdcc78b6005499ed33eff9
-  languageName: node
-  linkType: hard
-
-"llm@workspace:apps/llm":
-  version: 0.0.0-use.local
-  resolution: "llm@workspace:apps/llm"
-  dependencies:
-    "@babel/core": "npm:^7.29.0"
-    "@expo/log-box": "npm:~56.0.12"
-    "@react-native/metro-config": "npm:^0.85.3"
-    "@react-navigation/drawer": "npm:^7.9.4"
-    "@react-navigation/native": "npm:^7.2.2"
-    "@types/react": "npm:~19.2.14"
-    "@types/react-refresh": "npm:^0"
-    babel-preset-expo: "npm:~56.0.14"
-    expo: "npm:^56.0.8"
-    expo-brightness: "npm:~56.0.5"
-    expo-build-properties: "npm:~56.0.16"
-    expo-calendar: "npm:~56.0.8"
-    expo-constants: "npm:~56.0.16"
-    expo-document-picker: "npm:~56.0.4"
-    expo-font: "npm:~56.0.5"
-    expo-linking: "npm:~56.0.13"
-    expo-router: "npm:~56.2.8"
-    expo-status-bar: "npm:~56.0.4"
-    metro-config: "npm:^0.84.0"
-    react: "npm:19.2.3"
-    react-native: "npm:0.85.3"
-    react-native-audio-api: "npm:0.12.2"
-    react-native-device-info: "npm:^15.0.2"
-    react-native-executorch: "workspace:*"
-    react-native-executorch-expo-resource-fetcher: "workspace:*"
-    react-native-gesture-handler: "npm:~2.31.1"
-    react-native-image-picker: "npm:^8.2.1"
-    react-native-loading-spinner-overlay: "npm:^3.0.1"
-    react-native-markdown-display: "npm:^7.0.2"
-    react-native-reanimated: "npm:~4.3.0"
-    react-native-safe-area-context: "npm:~5.7.0"
-    react-native-screens: "npm:~4.25.2"
-    react-native-svg: "npm:15.15.4"
-    react-native-svg-transformer: "npm:^1.5.3"
-    react-native-worklets: "npm:0.8.1"
-    react-refresh: "npm:^0.18.0"
-  languageName: unknown
-  linkType: soft
-
 "locate-path@npm:^5.0.0":
   version: 5.0.0
   resolution: "locate-path@npm:5.0.0"
@@ -12664,29 +9000,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"log-symbols@npm:^4.1.0":
-  version: 4.1.0
-  resolution: "log-symbols@npm:4.1.0"
-  dependencies:
-    chalk: "npm:^4.1.0"
-    is-unicode-supported: "npm:^0.1.0"
-  checksum: 10/fce1497b3135a0198803f9f07464165e9eb83ed02ceb2273930a6f8a508951178d8cf4f0378e9d28300a2ed2bc49050995d2bd5f53ab716bb15ac84d58c6ef74
-  languageName: node
-  linkType: hard
-
-"logkitty@npm:^0.7.1":
-  version: 0.7.1
-  resolution: "logkitty@npm:0.7.1"
-  dependencies:
-    ansi-fragments: "npm:^0.2.1"
-    dayjs: "npm:^1.8.15"
-    yargs: "npm:^15.1.0"
-  bin:
-    logkitty: bin/logkitty.js
-  checksum: 10/1b9ab873198f31d42f353ab05cee93678b66788de159ea8ff2425afb20bf929eb021cbd2890d7dbdea59ddacdc029e8d8d0d485a35af0583435ff36daeef180c
-  languageName: node
-  linkType: hard
-
 "loose-envify@npm:^1.0.0, loose-envify@npm:^1.4.0":
   version: 1.4.0
   resolution: "loose-envify@npm:1.4.0"
@@ -12698,15 +9011,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"lower-case@npm:^2.0.2":
-  version: 2.0.2
-  resolution: "lower-case@npm:2.0.2"
-  dependencies:
-    tslib: "npm:^2.0.3"
-  checksum: 10/83a0a5f159ad7614bee8bf976b96275f3954335a84fad2696927f609ddae902802c4f3312d86668722e668bef41400254807e1d3a7f2e8c3eede79691aa1f010
-  languageName: node
-  linkType: hard
-
 "lru-cache@npm:^10.0.1, lru-cache@npm:^10.2.0":
   version: 10.4.3
   resolution: "lru-cache@npm:10.4.3"
@@ -12730,15 +9034,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"make-dir@npm:^4.0.0":
-  version: 4.0.0
-  resolution: "make-dir@npm:4.0.0"
-  dependencies:
-    semver: "npm:^7.5.3"
-  checksum: 10/bf0731a2dd3aab4db6f3de1585cea0b746bb73eb5a02e3d8d72757e376e64e6ada190b1eddcde5b2f24a81b688a9897efd5018737d05e02e2a671dda9cff8a8a
-  languageName: node
-  linkType: hard
-
 "make-fetch-happen@npm:^15.0.0":
   version: 15.0.4
   resolution: "make-fetch-happen@npm:15.0.4"
@@ -12767,21 +9062,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"markdown-it@npm:^10.0.0":
-  version: 10.0.0
-  resolution: "markdown-it@npm:10.0.0"
-  dependencies:
-    argparse: "npm:^1.0.7"
-    entities: "npm:~2.0.0"
-    linkify-it: "npm:^2.0.0"
-    mdurl: "npm:^1.0.1"
-    uc.micro: "npm:^1.0.5"
-  bin:
-    markdown-it: bin/markdown-it.js
-  checksum: 10/16f0fcd75f8b369e4adda56d5f161d8a7102e53dae749300293dd3fc386743e8f06a3ee7045a9571cf0e675e215182b5acc8e27fb2a23d166f65f8fdfe8882ba
-  languageName: node
-  linkType: hard
-
 "marky@npm:^1.2.2":
   version: 1.3.0
   resolution: "marky@npm:1.3.0"
@@ -12824,66 +9104,24 @@ __metadata:
     micromark-util-normalize-identifier: "npm:^2.0.0"
     micromark-util-symbol: "npm:^2.0.0"
     micromark-util-types: "npm:^2.0.0"
-    unist-util-stringify-position: "npm:^4.0.0"
-  checksum: 10/96f2bfb3b240c3d20a57db5d215faed795abf495c65ca2a4d61c0cf796011bc980619aa032d7984b05b67c15edc0eccd12a004a848952d3a598d108cf14901ab
-  languageName: node
-  linkType: hard
-
-"mdast-util-to-string@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "mdast-util-to-string@npm:2.0.0"
-  checksum: 10/0b2113ada10e002fbccb014170506dabe2f2ddacaacbe4bc1045c33f986652c5a162732a2c057c5335cdb58419e2ad23e368e5be226855d4d4e280b81c4e9ec2
-  languageName: node
-  linkType: hard
-
-"mdast-util-to-string@npm:^4.0.0":
-  version: 4.0.0
-  resolution: "mdast-util-to-string@npm:4.0.0"
-  dependencies:
-    "@types/mdast": "npm:^4.0.0"
-  checksum: 10/f4a5dbb9ea03521d7d3e26a9ba5652a1d6fbd55706dddd2155427517085688830e0ecd3f12418cfd40892640886eb39a4034c3c967d85e01e2fa64cfb53cff05
-  languageName: node
-  linkType: hard
-
-"mdn-data@npm:2.0.14":
-  version: 2.0.14
-  resolution: "mdn-data@npm:2.0.14"
-  checksum: 10/64c629fcf14807e30d6dc79f97cbcafa16db066f53a294299f3932b3beb0eb0d1386d3a7fe408fc67348c449a4e0999360c894ba4c81eb209d7be4e36503de0e
-  languageName: node
-  linkType: hard
-
-"mdn-data@npm:2.0.28":
-  version: 2.0.28
-  resolution: "mdn-data@npm:2.0.28"
-  checksum: 10/aec475e0c078af00498ce2f9434d96a1fdebba9814d14b8f72cd6d5475293f4b3972d0538af2d5c5053d35e1b964af08b7d162b98e9846e9343990b75e4baef1
-  languageName: node
-  linkType: hard
-
-"mdn-data@npm:2.0.30":
-  version: 2.0.30
-  resolution: "mdn-data@npm:2.0.30"
-  checksum: 10/e4944322bf3e0461a2daa2aee7e14e208960a036289531e4ef009e53d32bd41528350c070c4a33be867980443fe4c0523518d99318423cffa7c825fe7b1154e2
-  languageName: node
-  linkType: hard
-
-"mdurl@npm:^1.0.1":
-  version: 1.0.1
-  resolution: "mdurl@npm:1.0.1"
-  checksum: 10/ada367d01c9e81d07328101f187d5bd8641b71f33eab075df4caed935a24fa679e625f07108801d8250a5e4a99e5cd4be7679957a11424a3aa3e740d2bb2d5cb
+    unist-util-stringify-position: "npm:^4.0.0"
+  checksum: 10/96f2bfb3b240c3d20a57db5d215faed795abf495c65ca2a4d61c0cf796011bc980619aa032d7984b05b67c15edc0eccd12a004a848952d3a598d108cf14901ab
   languageName: node
   linkType: hard
 
-"media-typer@npm:0.3.0":
-  version: 0.3.0
-  resolution: "media-typer@npm:0.3.0"
-  checksum: 10/38e0984db39139604756903a01397e29e17dcb04207bb3e081412ce725ab17338ecc47220c1b186b6bbe79a658aad1b0d41142884f5a481f36290cdefbe6aa46
+"mdast-util-to-string@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "mdast-util-to-string@npm:2.0.0"
+  checksum: 10/0b2113ada10e002fbccb014170506dabe2f2ddacaacbe4bc1045c33f986652c5a162732a2c057c5335cdb58419e2ad23e368e5be226855d4d4e280b81c4e9ec2
   languageName: node
   linkType: hard
 
-"media-typer@npm:^1.1.0":
-  version: 1.1.0
-  resolution: "media-typer@npm:1.1.0"
-  checksum: 10/a58dd60804df73c672942a7253ccc06815612326dc1c0827984b1a21704466d7cde351394f47649e56cf7415e6ee2e26e000e81b51b3eebb5a93540e8bf93cbd
+"mdast-util-to-string@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "mdast-util-to-string@npm:4.0.0"
+  dependencies:
+    "@types/mdast": "npm:^4.0.0"
+  checksum: 10/f4a5dbb9ea03521d7d3e26a9ba5652a1d6fbd55706dddd2155427517085688830e0ecd3f12418cfd40892640886eb39a4034c3c967d85e01e2fa64cfb53cff05
   languageName: node
   linkType: hard
 
@@ -12894,6 +9132,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"meow@npm:^13.2.0":
+  version: 13.2.0
+  resolution: "meow@npm:13.2.0"
+  checksum: 10/4eff5bc921fed0b8a471ad79069d741a0210036d717547d0c7f36fdaf84ef7a3036225f38b6a53830d84dc9cbf8b944b097fde62381b8b5b215119e735ce1063
+  languageName: node
+  linkType: hard
+
 "merge-stream@npm:^2.0.0":
   version: 2.0.0
   resolution: "merge-stream@npm:2.0.0"
@@ -12920,6 +9165,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"metro-babel-transformer@npm:0.83.7":
+  version: 0.83.7
+  resolution: "metro-babel-transformer@npm:0.83.7"
+  dependencies:
+    "@babel/core": "npm:^7.25.2"
+    flow-enums-runtime: "npm:^0.0.6"
+    hermes-parser: "npm:0.35.0"
+    metro-cache-key: "npm:0.83.7"
+    nullthrows: "npm:^1.1.1"
+  checksum: 10/b213f9479daf690b11117c63a628e036ffcbb993fee571565142a34c9ae5c7ef1839eb7759c676d910edd58c1f442337f4d834de794904397091205f275b7f24
+  languageName: node
+  linkType: hard
+
 "metro-babel-transformer@npm:0.84.4":
   version: 0.84.4
   resolution: "metro-babel-transformer@npm:0.84.4"
@@ -12942,6 +9200,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"metro-cache-key@npm:0.83.7":
+  version: 0.83.7
+  resolution: "metro-cache-key@npm:0.83.7"
+  dependencies:
+    flow-enums-runtime: "npm:^0.0.6"
+  checksum: 10/bc0110eb61ce5903dae3992528f6933146889883d0999f8f01464a3b5bdd255dffa6a562bb921738004194cdf55d175b96cfaffdc17a5df6468c629b22ff7286
+  languageName: node
+  linkType: hard
+
 "metro-cache-key@npm:0.84.4":
   version: 0.84.4
   resolution: "metro-cache-key@npm:0.84.4"
@@ -12963,6 +9230,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"metro-cache@npm:0.83.7":
+  version: 0.83.7
+  resolution: "metro-cache@npm:0.83.7"
+  dependencies:
+    exponential-backoff: "npm:^3.1.1"
+    flow-enums-runtime: "npm:^0.0.6"
+    https-proxy-agent: "npm:^7.0.5"
+    metro-core: "npm:0.83.7"
+  checksum: 10/3f080c954fcb6e5894f7b6c4d7d8cdf03ecd1a5c175a5dcdb2d9c1751f135f7fdadea3014456524288baa3a4504a313bfd7872080f75b4da2f7c60c91b6bd88e
+  languageName: node
+  linkType: hard
+
 "metro-cache@npm:0.84.4":
   version: 0.84.4
   resolution: "metro-cache@npm:0.84.4"
@@ -12991,7 +9270,23 @@ __metadata:
   languageName: node
   linkType: hard
 
-"metro-config@npm:0.84.4, metro-config@npm:^0.84.0, metro-config@npm:^0.84.3":
+"metro-config@npm:0.83.7, metro-config@npm:^0.83.6":
+  version: 0.83.7
+  resolution: "metro-config@npm:0.83.7"
+  dependencies:
+    connect: "npm:^3.6.5"
+    flow-enums-runtime: "npm:^0.0.6"
+    jest-validate: "npm:^29.7.0"
+    metro: "npm:0.83.7"
+    metro-cache: "npm:0.83.7"
+    metro-core: "npm:0.83.7"
+    metro-runtime: "npm:0.83.7"
+    yaml: "npm:^2.6.1"
+  checksum: 10/e73a76b1b5a2bd27d1e1cd3b221ddef4ec7a19a00379bd9ad124038d7705810b75fcaa44a7dd6e20f70950c0309ed78f9510821bfe8fda7910dad93c827419c8
+  languageName: node
+  linkType: hard
+
+"metro-config@npm:0.84.4, metro-config@npm:^0.84.3":
   version: 0.84.4
   resolution: "metro-config@npm:0.84.4"
   dependencies:
@@ -13018,6 +9313,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"metro-core@npm:0.83.7, metro-core@npm:^0.83.6":
+  version: 0.83.7
+  resolution: "metro-core@npm:0.83.7"
+  dependencies:
+    flow-enums-runtime: "npm:^0.0.6"
+    lodash.throttle: "npm:^4.1.1"
+    metro-resolver: "npm:0.83.7"
+  checksum: 10/afa1e5121452dcc9a882c96c04830a9a3062ea06a648c60e353df6ed568795c75c7c8e923e415777c2f88ed3ebb687daf21b1a98b169c4b509c71ac77046129b
+  languageName: node
+  linkType: hard
+
 "metro-core@npm:0.84.4, metro-core@npm:^0.84.3":
   version: 0.84.4
   resolution: "metro-core@npm:0.84.4"
@@ -13046,6 +9352,23 @@ __metadata:
   languageName: node
   linkType: hard
 
+"metro-file-map@npm:0.83.7":
+  version: 0.83.7
+  resolution: "metro-file-map@npm:0.83.7"
+  dependencies:
+    debug: "npm:^4.4.0"
+    fb-watchman: "npm:^2.0.0"
+    flow-enums-runtime: "npm:^0.0.6"
+    graceful-fs: "npm:^4.2.4"
+    invariant: "npm:^2.2.4"
+    jest-worker: "npm:^29.7.0"
+    micromatch: "npm:^4.0.4"
+    nullthrows: "npm:^1.1.1"
+    walker: "npm:^1.0.7"
+  checksum: 10/175fee3f2d407bbc01b6312ecab63ce515d3d7de97c9404a563a390c24d03074cd3e983d46d31dba56806dda53c52adc4c40ec29d23dd620e82f43f8f36db371
+  languageName: node
+  linkType: hard
+
 "metro-file-map@npm:0.84.4":
   version: 0.84.4
   resolution: "metro-file-map@npm:0.84.4"
@@ -13073,62 +9396,23 @@ __metadata:
   languageName: node
   linkType: hard
 
-"metro-minify-terser@npm:0.84.4":
-  version: 0.84.4
-  resolution: "metro-minify-terser@npm:0.84.4"
+"metro-minify-terser@npm:0.83.7":
+  version: 0.83.7
+  resolution: "metro-minify-terser@npm:0.83.7"
   dependencies:
     flow-enums-runtime: "npm:^0.0.6"
     terser: "npm:^5.15.0"
-  checksum: 10/e0893b5672a4ad2bc6e2c492f9994a3eae6e633e49f2e5a52738e80260e37bb5143219ce2c337c22dd16cee850e68b99d1ba4bc378d7cc8e9cd60d636aa051b5
+  checksum: 10/195bc658adbd4b49e13e4df6c00bbabd868a9449def0ee8d87d2706868e10731c337697130381a07e4477bb67f2d2f16dea2f369a1bdb80f78e15a0c4abab70b
   languageName: node
   linkType: hard
 
-"metro-react-native-babel-preset@npm:^0.77.0":
-  version: 0.77.0
-  resolution: "metro-react-native-babel-preset@npm:0.77.0"
+"metro-minify-terser@npm:0.84.4":
+  version: 0.84.4
+  resolution: "metro-minify-terser@npm:0.84.4"
   dependencies:
-    "@babel/core": "npm:^7.20.0"
-    "@babel/plugin-proposal-async-generator-functions": "npm:^7.0.0"
-    "@babel/plugin-proposal-class-properties": "npm:^7.18.0"
-    "@babel/plugin-proposal-export-default-from": "npm:^7.0.0"
-    "@babel/plugin-proposal-nullish-coalescing-operator": "npm:^7.18.0"
-    "@babel/plugin-proposal-numeric-separator": "npm:^7.0.0"
-    "@babel/plugin-proposal-object-rest-spread": "npm:^7.20.0"
-    "@babel/plugin-proposal-optional-catch-binding": "npm:^7.0.0"
-    "@babel/plugin-proposal-optional-chaining": "npm:^7.20.0"
-    "@babel/plugin-syntax-dynamic-import": "npm:^7.8.0"
-    "@babel/plugin-syntax-export-default-from": "npm:^7.0.0"
-    "@babel/plugin-syntax-flow": "npm:^7.18.0"
-    "@babel/plugin-syntax-nullish-coalescing-operator": "npm:^7.0.0"
-    "@babel/plugin-syntax-optional-chaining": "npm:^7.0.0"
-    "@babel/plugin-transform-arrow-functions": "npm:^7.0.0"
-    "@babel/plugin-transform-async-to-generator": "npm:^7.20.0"
-    "@babel/plugin-transform-block-scoping": "npm:^7.0.0"
-    "@babel/plugin-transform-classes": "npm:^7.0.0"
-    "@babel/plugin-transform-computed-properties": "npm:^7.0.0"
-    "@babel/plugin-transform-destructuring": "npm:^7.20.0"
-    "@babel/plugin-transform-flow-strip-types": "npm:^7.20.0"
-    "@babel/plugin-transform-function-name": "npm:^7.0.0"
-    "@babel/plugin-transform-literals": "npm:^7.0.0"
-    "@babel/plugin-transform-modules-commonjs": "npm:^7.0.0"
-    "@babel/plugin-transform-named-capturing-groups-regex": "npm:^7.0.0"
-    "@babel/plugin-transform-parameters": "npm:^7.0.0"
-    "@babel/plugin-transform-react-display-name": "npm:^7.0.0"
-    "@babel/plugin-transform-react-jsx": "npm:^7.0.0"
-    "@babel/plugin-transform-react-jsx-self": "npm:^7.0.0"
-    "@babel/plugin-transform-react-jsx-source": "npm:^7.0.0"
-    "@babel/plugin-transform-runtime": "npm:^7.0.0"
-    "@babel/plugin-transform-shorthand-properties": "npm:^7.0.0"
-    "@babel/plugin-transform-spread": "npm:^7.0.0"
-    "@babel/plugin-transform-sticky-regex": "npm:^7.0.0"
-    "@babel/plugin-transform-typescript": "npm:^7.5.0"
-    "@babel/plugin-transform-unicode-regex": "npm:^7.0.0"
-    "@babel/template": "npm:^7.0.0"
-    babel-plugin-transform-flow-enums: "npm:^0.0.2"
-    react-refresh: "npm:^0.4.0"
-  peerDependencies:
-    "@babel/core": "*"
-  checksum: 10/b83b34aa682dd135228722a09b5e1d0c6657cf2ccb610bd49627f67924bfca8bd53d9de780ab8e2cab7899fa09cd867bb870f4fa2ea63ce42c87cdfd40bd08a8
+    flow-enums-runtime: "npm:^0.0.6"
+    terser: "npm:^5.15.0"
+  checksum: 10/e0893b5672a4ad2bc6e2c492f9994a3eae6e633e49f2e5a52738e80260e37bb5143219ce2c337c22dd16cee850e68b99d1ba4bc378d7cc8e9cd60d636aa051b5
   languageName: node
   linkType: hard
 
@@ -13141,6 +9425,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"metro-resolver@npm:0.83.7":
+  version: 0.83.7
+  resolution: "metro-resolver@npm:0.83.7"
+  dependencies:
+    flow-enums-runtime: "npm:^0.0.6"
+  checksum: 10/cf29c2e05a0cf1455be40ee66cf47d8876c41f3412eec68c6d168455d0bbe3f40501bc40d5862be2e526fc82900ee9216b8f85596bc343f5e69ddc841978a2d9
+  languageName: node
+  linkType: hard
+
 "metro-resolver@npm:0.84.4":
   version: 0.84.4
   resolution: "metro-resolver@npm:0.84.4"
@@ -13160,6 +9453,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"metro-runtime@npm:0.83.7, metro-runtime@npm:^0.83.6":
+  version: 0.83.7
+  resolution: "metro-runtime@npm:0.83.7"
+  dependencies:
+    "@babel/runtime": "npm:^7.25.0"
+    flow-enums-runtime: "npm:^0.0.6"
+  checksum: 10/4d7f57ff4ae50d56eb857293ae3d16c76df07b14852c6f697719602cc9fdd43906df9a11b6340b78ca3ad324cd87646a238dc9ab3061387023ba68c80efae6ab
+  languageName: node
+  linkType: hard
+
 "metro-runtime@npm:0.84.4, metro-runtime@npm:^0.84.3":
   version: 0.84.4
   resolution: "metro-runtime@npm:0.84.4"
@@ -13187,6 +9490,23 @@ __metadata:
   languageName: node
   linkType: hard
 
+"metro-source-map@npm:0.83.7, metro-source-map@npm:^0.83.6":
+  version: 0.83.7
+  resolution: "metro-source-map@npm:0.83.7"
+  dependencies:
+    "@babel/traverse": "npm:^7.29.0"
+    "@babel/types": "npm:^7.29.0"
+    flow-enums-runtime: "npm:^0.0.6"
+    invariant: "npm:^2.2.4"
+    metro-symbolicate: "npm:0.83.7"
+    nullthrows: "npm:^1.1.1"
+    ob1: "npm:0.83.7"
+    source-map: "npm:^0.5.6"
+    vlq: "npm:^1.0.0"
+  checksum: 10/f1f8d5a411d65f14ffe2778229bc5236b57028bfc9821808f353f56fbe6344050b403b5fa843618cb086c6043028a96b4206c2dea870d4b1d03ee1d85e52e7c6
+  languageName: node
+  linkType: hard
+
 "metro-source-map@npm:0.84.4, metro-source-map@npm:^0.84.3":
   version: 0.84.4
   resolution: "metro-source-map@npm:0.84.4"
@@ -13220,6 +9540,22 @@ __metadata:
   languageName: node
   linkType: hard
 
+"metro-symbolicate@npm:0.83.7":
+  version: 0.83.7
+  resolution: "metro-symbolicate@npm:0.83.7"
+  dependencies:
+    flow-enums-runtime: "npm:^0.0.6"
+    invariant: "npm:^2.2.4"
+    metro-source-map: "npm:0.83.7"
+    nullthrows: "npm:^1.1.1"
+    source-map: "npm:^0.5.6"
+    vlq: "npm:^1.0.0"
+  bin:
+    metro-symbolicate: src/index.js
+  checksum: 10/a371abce2c8cf5d61aeeceeb36b342f7ddb5bc178d8aa73e8df679c4c0698e93022c090776414413aff0c9b6027cec3fb1067ea91baa1af1ee63bc1221b7aa0f
+  languageName: node
+  linkType: hard
+
 "metro-symbolicate@npm:0.84.4":
   version: 0.84.4
   resolution: "metro-symbolicate@npm:0.84.4"
@@ -13250,6 +9586,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"metro-transform-plugins@npm:0.83.7":
+  version: 0.83.7
+  resolution: "metro-transform-plugins@npm:0.83.7"
+  dependencies:
+    "@babel/core": "npm:^7.25.2"
+    "@babel/generator": "npm:^7.29.1"
+    "@babel/template": "npm:^7.28.6"
+    "@babel/traverse": "npm:^7.29.0"
+    flow-enums-runtime: "npm:^0.0.6"
+    nullthrows: "npm:^1.1.1"
+  checksum: 10/df2a7140ed83c78dddcf2c86f26a642318df1827a51f019f8bed5636167bbf86e483eede0cc68afc1e87c9da51d48d2bf75635c55d125a345769d3869d7feb31
+  languageName: node
+  linkType: hard
+
 "metro-transform-plugins@npm:0.84.4":
   version: 0.84.4
   resolution: "metro-transform-plugins@npm:0.84.4"
@@ -13285,6 +9635,27 @@ __metadata:
   languageName: node
   linkType: hard
 
+"metro-transform-worker@npm:0.83.7":
+  version: 0.83.7
+  resolution: "metro-transform-worker@npm:0.83.7"
+  dependencies:
+    "@babel/core": "npm:^7.25.2"
+    "@babel/generator": "npm:^7.29.1"
+    "@babel/parser": "npm:^7.29.0"
+    "@babel/types": "npm:^7.29.0"
+    flow-enums-runtime: "npm:^0.0.6"
+    metro: "npm:0.83.7"
+    metro-babel-transformer: "npm:0.83.7"
+    metro-cache: "npm:0.83.7"
+    metro-cache-key: "npm:0.83.7"
+    metro-minify-terser: "npm:0.83.7"
+    metro-source-map: "npm:0.83.7"
+    metro-transform-plugins: "npm:0.83.7"
+    nullthrows: "npm:^1.1.1"
+  checksum: 10/f99098f488782e25248e065e71ee72b413b08a855aafb672b1d62eaa53ab7570a475f560f65b22112ffa9f6b7129d843f5b2022f441377066c674e0bedc0b58c
+  languageName: node
+  linkType: hard
+
 "metro-transform-worker@npm:0.84.4":
   version: 0.84.4
   resolution: "metro-transform-worker@npm:0.84.4"
@@ -13356,6 +9727,55 @@ __metadata:
   languageName: node
   linkType: hard
 
+"metro@npm:0.83.7, metro@npm:^0.83.6":
+  version: 0.83.7
+  resolution: "metro@npm:0.83.7"
+  dependencies:
+    "@babel/code-frame": "npm:^7.29.0"
+    "@babel/core": "npm:^7.25.2"
+    "@babel/generator": "npm:^7.29.1"
+    "@babel/parser": "npm:^7.29.0"
+    "@babel/template": "npm:^7.28.6"
+    "@babel/traverse": "npm:^7.29.0"
+    "@babel/types": "npm:^7.29.0"
+    accepts: "npm:^2.0.0"
+    ci-info: "npm:^2.0.0"
+    connect: "npm:^3.6.5"
+    debug: "npm:^4.4.0"
+    error-stack-parser: "npm:^2.0.6"
+    flow-enums-runtime: "npm:^0.0.6"
+    graceful-fs: "npm:^4.2.4"
+    hermes-parser: "npm:0.35.0"
+    image-size: "npm:^1.0.2"
+    invariant: "npm:^2.2.4"
+    jest-worker: "npm:^29.7.0"
+    jsc-safe-url: "npm:^0.2.2"
+    lodash.throttle: "npm:^4.1.1"
+    metro-babel-transformer: "npm:0.83.7"
+    metro-cache: "npm:0.83.7"
+    metro-cache-key: "npm:0.83.7"
+    metro-config: "npm:0.83.7"
+    metro-core: "npm:0.83.7"
+    metro-file-map: "npm:0.83.7"
+    metro-resolver: "npm:0.83.7"
+    metro-runtime: "npm:0.83.7"
+    metro-source-map: "npm:0.83.7"
+    metro-symbolicate: "npm:0.83.7"
+    metro-transform-plugins: "npm:0.83.7"
+    metro-transform-worker: "npm:0.83.7"
+    mime-types: "npm:^3.0.1"
+    nullthrows: "npm:^1.1.1"
+    serialize-error: "npm:^2.1.0"
+    source-map: "npm:^0.5.6"
+    throat: "npm:^5.0.0"
+    ws: "npm:^7.5.10"
+    yargs: "npm:^17.6.2"
+  bin:
+    metro: src/cli.js
+  checksum: 10/c641c560fe2ca7a9d72028df044e16880966415b2139cc25617098b917f15fe32e349f2448c4b0e8d08cd655f4491eb3e09577cd360ea3fea98e9eb7dc56f444
+  languageName: node
+  linkType: hard
+
 "metro@npm:0.84.4, metro@npm:^0.84.3":
   version: 0.84.4
   resolution: "metro@npm:0.84.4"
@@ -13684,7 +10104,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"mime-types@npm:~2.1.24, mime-types@npm:~2.1.34":
+"mime-types@npm:~2.1.34":
   version: 2.1.35
   resolution: "mime-types@npm:2.1.35"
   dependencies:
@@ -13702,15 +10122,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"mime@npm:^2.4.1":
-  version: 2.6.0
-  resolution: "mime@npm:2.6.0"
-  bin:
-    mime: cli.js
-  checksum: 10/7da117808b5cd0203bb1b5e33445c330fe213f4d8ee2402a84d62adbde9716ca4fb90dd6d9ab4e77a4128c6c5c24a9c4c9f6a4d720b095b1b342132d02dba58d
-  languageName: node
-  linkType: hard
-
 "mimic-fn@npm:^1.0.0":
   version: 1.2.0
   resolution: "mimic-fn@npm:1.2.0"
@@ -13725,13 +10136,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"min-indent@npm:^1.0.0":
-  version: 1.0.1
-  resolution: "min-indent@npm:1.0.1"
-  checksum: 10/bfc6dd03c5eaf623a4963ebd94d087f6f4bbbfd8c41329a7f09706b0cb66969c4ddd336abeb587bc44bc6f08e13bf90f0b374f9d71f9f01e04adc2cd6f083ef1
-  languageName: node
-  linkType: hard
-
 "minimatch@npm:^10.2.2":
   version: 10.2.5
   resolution: "minimatch@npm:10.2.5"
@@ -13926,15 +10330,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"napi-postinstall@npm:^0.3.0":
-  version: 0.3.4
-  resolution: "napi-postinstall@npm:0.3.4"
-  bin:
-    napi-postinstall: lib/cli.js
-  checksum: 10/5541381508f9e1051ff3518701c7130ebac779abb3a1ffe9391fcc3cab4cc0569b0ba0952357db3f6b12909c3bb508359a7a60261ffd795feebbdab967175832
-  languageName: node
-  linkType: hard
-
 "natural-compare@npm:^1.4.0":
   version: 1.4.0
   resolution: "natural-compare@npm:1.4.0"
@@ -13963,23 +10358,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"no-case@npm:^3.0.4":
-  version: 3.0.4
-  resolution: "no-case@npm:3.0.4"
-  dependencies:
-    lower-case: "npm:^2.0.2"
-    tslib: "npm:^2.0.3"
-  checksum: 10/0b2ebc113dfcf737d48dde49cfebf3ad2d82a8c3188e7100c6f375e30eafbef9e9124aadc3becef237b042fd5eb0aad2fd78669c20972d045bbe7fea8ba0be5c
-  languageName: node
-  linkType: hard
-
-"nocache@npm:^3.0.1":
-  version: 3.0.4
-  resolution: "nocache@npm:3.0.4"
-  checksum: 10/e980eac3c6c81ff6336728e10e798a251b48866822a3fbf98f74b800cafe2b1a8ac8f676a48ac454d4db9509cd501d72ffb9d5509c30b054b5d8800117a079fc
-  languageName: node
-  linkType: hard
-
 "node-exports-info@npm:^1.6.0":
   version: 1.6.0
   resolution: "node-exports-info@npm:1.6.0"
@@ -14046,13 +10424,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"node-stream-zip@npm:^1.9.1":
-  version: 1.15.0
-  resolution: "node-stream-zip@npm:1.15.0"
-  checksum: 10/3fb56144d23456e1b42fe9d24656999e4ef6aeccce3cae43fc97ba6c341ee448aeceb4dc8fb57ee78eab1a6da49dd46c9650fdb2f16b137630a335df9560c647
-  languageName: node
-  linkType: hard
-
 "nopt@npm:^9.0.0":
   version: 9.0.0
   resolution: "nopt@npm:9.0.0"
@@ -14083,7 +10454,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"npm-run-path@npm:^4.0.0, npm-run-path@npm:^4.0.1":
+"npm-run-path@npm:^4.0.0":
   version: 4.0.1
   resolution: "npm-run-path@npm:4.0.1"
   dependencies:
@@ -14092,15 +10463,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"nth-check@npm:^2.0.1":
-  version: 2.1.1
-  resolution: "nth-check@npm:2.1.1"
-  dependencies:
-    boolbase: "npm:^1.0.0"
-  checksum: 10/5afc3dafcd1573b08877ca8e6148c52abd565f1d06b1eb08caf982e3fa289a82f2cae697ffb55b5021e146d60443f1590a5d6b944844e944714a5b549675bcd3
-  languageName: node
-  linkType: hard
-
 "nullthrows@npm:^1.1.1":
   version: 1.1.1
   resolution: "nullthrows@npm:1.1.1"
@@ -14117,6 +10479,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"ob1@npm:0.83.7":
+  version: 0.83.7
+  resolution: "ob1@npm:0.83.7"
+  dependencies:
+    flow-enums-runtime: "npm:^0.0.6"
+  checksum: 10/ae366176de833457e77db78b60f2c514550f16eb53a08f5c53bc660d0e5d3126d782107d71b77a49d3bfdc8b1c614320510efea5318864e6ed49d915f7ef4b89
+  languageName: node
+  linkType: hard
+
 "ob1@npm:0.84.4":
   version: 0.84.4
   resolution: "ob1@npm:0.84.4"
@@ -14204,21 +10575,21 @@ __metadata:
   languageName: node
   linkType: hard
 
-"on-finished@npm:^2.4.1, on-finished@npm:~2.4.1":
-  version: 2.4.1
-  resolution: "on-finished@npm:2.4.1"
+"on-finished@npm:~2.3.0":
+  version: 2.3.0
+  resolution: "on-finished@npm:2.3.0"
   dependencies:
     ee-first: "npm:1.1.1"
-  checksum: 10/8e81472c5028125c8c39044ac4ab8ba51a7cdc19a9fbd4710f5d524a74c6d8c9ded4dd0eed83f28d3d33ac1d7a6a439ba948ccb765ac6ce87f30450a26bfe2ea
+  checksum: 10/1db595bd963b0124d6fa261d18320422407b8f01dc65863840f3ddaaf7bcad5b28ff6847286703ca53f4ec19595bd67a2f1253db79fc4094911ec6aa8df1671b
   languageName: node
   linkType: hard
 
-"on-finished@npm:~2.3.0":
-  version: 2.3.0
-  resolution: "on-finished@npm:2.3.0"
+"on-finished@npm:~2.4.1":
+  version: 2.4.1
+  resolution: "on-finished@npm:2.4.1"
   dependencies:
     ee-first: "npm:1.1.1"
-  checksum: 10/1db595bd963b0124d6fa261d18320422407b8f01dc65863840f3ddaaf7bcad5b28ff6847286703ca53f4ec19595bd67a2f1253db79fc4094911ec6aa8df1671b
+  checksum: 10/8e81472c5028125c8c39044ac4ab8ba51a7cdc19a9fbd4710f5d524a74c6d8c9ded4dd0eed83f28d3d33ac1d7a6a439ba948ccb765ac6ce87f30450a26bfe2ea
   languageName: node
   linkType: hard
 
@@ -14247,7 +10618,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"onetime@npm:^5.1.0, onetime@npm:^5.1.2":
+"onetime@npm:^5.1.0":
   version: 5.1.2
   resolution: "onetime@npm:5.1.2"
   dependencies:
@@ -14256,15 +10627,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"open@npm:^6.2.0":
-  version: 6.4.0
-  resolution: "open@npm:6.4.0"
-  dependencies:
-    is-wsl: "npm:^1.1.0"
-  checksum: 10/9b1cfda7a649f432c8bfa281796d28b5a49f7afcb470d9054ca94c7d0b1e8273432f55134dd953eb593ffce244de1b701ee89e6fe9c25ea8215eb1ca1ae8a1a9
-  languageName: node
-  linkType: hard
-
 "open@npm:^7.0.3":
   version: 7.4.2
   resolution: "open@npm:7.4.2"
@@ -14303,23 +10665,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ora@npm:^5.4.1":
-  version: 5.4.1
-  resolution: "ora@npm:5.4.1"
-  dependencies:
-    bl: "npm:^4.1.0"
-    chalk: "npm:^4.1.0"
-    cli-cursor: "npm:^3.1.0"
-    cli-spinners: "npm:^2.5.0"
-    is-interactive: "npm:^1.0.0"
-    is-unicode-supported: "npm:^0.1.0"
-    log-symbols: "npm:^4.1.0"
-    strip-ansi: "npm:^6.0.0"
-    wcwidth: "npm:^1.0.1"
-  checksum: 10/8d071828f40090a8e1c6e8f350c6eb065808e9ab2b3e57fa37e0d5ae78cb46dac00117c8f12c3c8b8da2923454afbd8265e08c10b69881170c5b269f451e7fef
-  languageName: node
-  linkType: hard
-
 "own-keys@npm:^1.0.1":
   version: 1.0.1
   resolution: "own-keys@npm:1.0.1"
@@ -14340,7 +10685,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"p-limit@npm:^3.0.2, p-limit@npm:^3.1.0":
+"p-limit@npm:^3.0.2":
   version: 3.1.0
   resolution: "p-limit@npm:3.1.0"
   dependencies:
@@ -14438,18 +10783,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"parse-json@npm:^5.2.0":
-  version: 5.2.0
-  resolution: "parse-json@npm:5.2.0"
-  dependencies:
-    "@babel/code-frame": "npm:^7.0.0"
-    error-ex: "npm:^1.3.1"
-    json-parse-even-better-errors: "npm:^2.3.0"
-    lines-and-columns: "npm:^1.1.6"
-  checksum: 10/62085b17d64da57f40f6afc2ac1f4d95def18c4323577e1eced571db75d9ab59b297d1d10582920f84b15985cbfc6b6d450ccbf317644cfa176f3ed982ad87e2
-  languageName: node
-  linkType: hard
-
 "parse-png@npm:^2.1.0":
   version: 2.1.0
   resolution: "parse-png@npm:2.1.0"
@@ -14473,13 +10806,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"path-dirname@npm:^1.0.2":
-  version: 1.0.2
-  resolution: "path-dirname@npm:1.0.2"
-  checksum: 10/0d2f6604ae05a252a0025318685f290e2764ecf9c5436f203cdacfc8c0b17c24cdedaa449d766beb94ab88cc7fc70a09ec21e7933f31abc2b719180883e5e33f
-  languageName: node
-  linkType: hard
-
 "path-exists@npm:^4.0.0":
   version: 4.0.0
   resolution: "path-exists@npm:4.0.0"
@@ -14487,13 +10813,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"path-expression-matcher@npm:^1.5.0":
-  version: 1.5.0
-  resolution: "path-expression-matcher@npm:1.5.0"
-  checksum: 10/28303bb9ee6831e6df14c10cd3f3f7b2d7c8d7f788d8bdb7440136fd696064c82a3e264999a0764d28e39f698275fc03a5493bec93c57ef4a22566280367dd64
-  languageName: node
-  linkType: hard
-
 "path-is-absolute@npm:^1.0.0":
   version: 1.0.1
   resolution: "path-is-absolute@npm:1.0.1"
@@ -14542,7 +10861,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"picocolors@npm:^1.0.0, picocolors@npm:^1.1.1":
+"path-type@npm:^6.0.0":
+  version: 6.0.0
+  resolution: "path-type@npm:6.0.0"
+  checksum: 10/b9f6eaf7795c48d5c9bc4c6bc3ac61315b8d36975a73497ab2e02b764c0836b71fb267ea541863153f633a069a1c2ed3c247cb781633842fc571c655ac57c00e
+  languageName: node
+  linkType: hard
+
+"picocolors@npm:^1.1.1":
   version: 1.1.1
   resolution: "picocolors@npm:1.1.1"
   checksum: 10/e1cf46bf84886c79055fdfa9dcb3e4711ad259949e3565154b004b260cd356c5d54b31a1437ce9782624bf766272fe6b0154f5f0c744fb7af5d454d2b60db045
@@ -14563,22 +10889,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"pirates@npm:^4.0.4, pirates@npm:^4.0.7":
+"pirates@npm:^4.0.4":
   version: 4.0.7
   resolution: "pirates@npm:4.0.7"
   checksum: 10/2427f371366081ae42feb58214f04805d6b41d6b84d74480ebcc9e0ddbd7105a139f7c653daeaf83ad8a1a77214cf07f64178e76de048128fec501eab3305a96
   languageName: node
   linkType: hard
 
-"pkg-dir@npm:^4.2.0":
-  version: 4.2.0
-  resolution: "pkg-dir@npm:4.2.0"
-  dependencies:
-    find-up: "npm:^4.0.0"
-  checksum: 10/9863e3f35132bf99ae1636d31ff1e1e3501251d480336edb1c211133c8d58906bed80f154a1d723652df1fda91e01c7442c2eeaf9dc83157c7ae89087e43c8d6
-  languageName: node
-  linkType: hard
-
 "plist@npm:^3.0.5":
   version: 3.1.0
   resolution: "plist@npm:3.1.0"
@@ -14604,13 +10921,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"postcss-value-parser@npm:^4.0.2":
-  version: 4.2.0
-  resolution: "postcss-value-parser@npm:4.2.0"
-  checksum: 10/e4e4486f33b3163a606a6ed94f9c196ab49a37a7a7163abfcd469e5f113210120d70b8dd5e33d64636f41ad52316a3725655421eb9a1094f1bcab1db2f555c62
-  languageName: node
-  linkType: hard
-
 "postcss@npm:^8.5.14":
   version: 8.5.15
   resolution: "postcss@npm:8.5.15"
@@ -14629,6 +10939,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"presentable-error@npm:^0.0.1":
+  version: 0.0.1
+  resolution: "presentable-error@npm:0.0.1"
+  checksum: 10/013809ee7a47ced847a8d860e9b89a56cdd8c4f1ad04ad8da1e58fd60843f77f497d204146bb15aaa9793d3b94ad8626eed01256fc9eb5839a545af2000a5fa4
+  languageName: node
+  linkType: hard
+
 "prettier-linter-helpers@npm:^1.0.1":
   version: 1.0.1
   resolution: "prettier-linter-helpers@npm:1.0.1"
@@ -14651,15 +10968,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"prettier@npm:2.8.8":
-  version: 2.8.8
-  resolution: "prettier@npm:2.8.8"
-  bin:
-    prettier: bin-prettier.js
-  checksum: 10/00cdb6ab0281f98306cd1847425c24cbaaa48a5ff03633945ab4c701901b8e96ad558eb0777364ffc312f437af9b5a07d0f45346266e8245beaf6247b9c62b24
-  languageName: node
-  linkType: hard
-
 "prettier@npm:^3.3.3":
   version: 3.8.1
   resolution: "prettier@npm:3.8.1"
@@ -14669,18 +10977,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"pretty-format@npm:30.2.0, pretty-format@npm:^30.0.0":
-  version: 30.2.0
-  resolution: "pretty-format@npm:30.2.0"
-  dependencies:
-    "@jest/schemas": "npm:30.0.5"
-    ansi-styles: "npm:^5.2.0"
-    react-is: "npm:^18.3.1"
-  checksum: 10/725890d648e3400575eebc99a334a4cd1498e0d36746313913706bbeea20ada27e17c184a3cd45c50f705c16111afa829f3450233fc0fda5eed293c69757e926
-  languageName: node
-  linkType: hard
-
-"pretty-format@npm:^29.0.0, pretty-format@npm:^29.7.0":
+"pretty-format@npm:^29.7.0":
   version: 29.7.0
   resolution: "pretty-format@npm:29.7.0"
   dependencies:
@@ -14721,7 +11018,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"prompts@npm:^2.0.1, prompts@npm:^2.3.2, prompts@npm:^2.4.2":
+"prompts@npm:^2.3.2, prompts@npm:^2.4.2":
   version: 2.4.2
   resolution: "prompts@npm:2.4.2"
   dependencies:
@@ -14731,7 +11028,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"prop-types@npm:^15.5.10, prop-types@npm:^15.7.2, prop-types@npm:^15.8.1":
+"prop-types@npm:^15.8.1":
   version: 15.8.1
   resolution: "prop-types@npm:15.8.1"
   dependencies:
@@ -14759,38 +11056,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"pure-rand@npm:^6.0.0":
-  version: 6.1.0
-  resolution: "pure-rand@npm:6.1.0"
-  checksum: 10/256aa4bcaf9297256f552914e03cbdb0039c8fe1db11fa1e6d3f80790e16e563eb0a859a1e61082a95e224fc0c608661839439f8ecc6a3db4e48d46d99216ee4
-  languageName: node
-  linkType: hard
-
-"pure-rand@npm:^7.0.0":
-  version: 7.0.1
-  resolution: "pure-rand@npm:7.0.1"
-  checksum: 10/c61a576fda5032ec9763ecb000da4a8f19263b9e2f9ae9aa2759c8fbd9dc6b192b2ce78391ebd41abb394a5fedb7bcc4b03c9e6141ac8ab20882dd5717698b80
-  languageName: node
-  linkType: hard
-
-"qs@npm:^6.14.1":
-  version: 6.15.0
-  resolution: "qs@npm:6.15.0"
-  dependencies:
-    side-channel: "npm:^1.1.0"
-  checksum: 10/a3458f2f389285c3512e0ebc55522ee370ac7cb720ba9f0eff3e30fb2bb07631caf556c08e2a3d4481a371ac14faa9ceb7442a0610c5a7e55b23a5bdee7b701c
-  languageName: node
-  linkType: hard
-
-"qs@npm:~6.14.0":
-  version: 6.14.2
-  resolution: "qs@npm:6.14.2"
-  dependencies:
-    side-channel: "npm:^1.1.0"
-  checksum: 10/682933a85bb4b7bd0d66e13c0a40d9e612b5e4bcc2cb9238f711a9368cd22d91654097a74fff93551e58146db282c56ac094957dfdc60ce64ea72c3c9d7779ac
-  languageName: node
-  linkType: hard
-
 "query-string@npm:^7.1.3":
   version: 7.1.3
   resolution: "query-string@npm:7.1.3"
@@ -14826,30 +11091,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"raw-body@npm:^3.0.1":
-  version: 3.0.2
-  resolution: "raw-body@npm:3.0.2"
-  dependencies:
-    bytes: "npm:~3.1.2"
-    http-errors: "npm:~2.0.1"
-    iconv-lite: "npm:~0.7.0"
-    unpipe: "npm:~1.0.0"
-  checksum: 10/4168c82157bd69175d5bd960e59b74e253e237b358213694946a427a6f750a18b8e150f036fed3421b3e83294b071a4e2bb01037a79ccacdac05360c63d3ebba
-  languageName: node
-  linkType: hard
-
-"raw-body@npm:~2.5.3":
-  version: 2.5.3
-  resolution: "raw-body@npm:2.5.3"
-  dependencies:
-    bytes: "npm:~3.1.2"
-    http-errors: "npm:~2.0.1"
-    iconv-lite: "npm:~0.4.24"
-    unpipe: "npm:~1.0.0"
-  checksum: 10/f35759fe5a6548e7c529121ead1de4dd163f899749a5896c42e278479df2d9d7f98b5bb17312737c03617765e5a1433e586f717616e5cfbebc13b4738b820601
-  languageName: node
-  linkType: hard
-
 "react-devtools-core@npm:^6.1.5":
   version: 6.1.5
   resolution: "react-devtools-core@npm:6.1.5"
@@ -14867,23 +11108,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"react-freeze@npm:^1.0.0":
-  version: 1.0.4
-  resolution: "react-freeze@npm:1.0.4"
-  peerDependencies:
-    react: ">=17.0.0"
-  checksum: 10/1dc433319341ec3dca84513c4197ef4f4c8232604d35f83546a8abfb41d9591f934b66aaaa4dc3dc8b1b65f488705a2a48ae6c1d9792660119a9cdedeab4ca8f
-  languageName: node
-  linkType: hard
-
-"react-is@npm:^16.13.1, react-is@npm:^16.7.0":
+"react-is@npm:^16.13.1":
   version: 16.13.1
   resolution: "react-is@npm:16.13.1"
   checksum: 10/5aa564a1cde7d391ac980bedee21202fc90bdea3b399952117f54fb71a932af1e5902020144fb354b4690b2414a0c7aafe798eb617b76a3d441d956db7726fdf
   languageName: node
   linkType: hard
 
-"react-is@npm:^18.0.0, react-is@npm:^18.3.1":
+"react-is@npm:^18.0.0":
   version: 18.3.1
   resolution: "react-is@npm:18.3.1"
   checksum: 10/d5f60c87d285af24b1e1e7eaeb123ec256c3c8bdea7061ab3932e3e14685708221bf234ec50b21e10dd07f008f1b966a2730a0ce4ff67905b3872ff2042aec22
@@ -14897,25 +11129,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"react-native-audio-api@npm:0.12.2":
-  version: 0.12.2
-  resolution: "react-native-audio-api@npm:0.12.2"
-  dependencies:
-    semver: "npm:^7.7.3"
-  peerDependencies:
-    react: "*"
-    react-native: "*"
-    react-native-worklets: ">= 0.6.0"
-  peerDependenciesMeta:
-    react-native-worklets:
-      optional: true
-  bin:
-    setup-rn-audio-api-web: scripts/setup-rn-audio-api-web.js
-  checksum: 10/ed495058382188c8beb51ce89f2ef14d846dc0c0a07c65a7b4c71aa106fb7ea14aa8660b05fb33941c038d1a7ab2ba4ab3eb039fe481841938c45396903c6060
-  languageName: node
-  linkType: hard
-
-"react-native-builder-bob@npm:^0.40.12":
+"react-native-builder-bob@npm:^0.40.18":
   version: 0.40.18
   resolution: "react-native-builder-bob@npm:0.40.18"
   dependencies:
@@ -14947,31 +11161,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"react-native-device-info@npm:^15.0.2":
-  version: 15.0.2
-  resolution: "react-native-device-info@npm:15.0.2"
-  peerDependencies:
-    react-native: "*"
-  checksum: 10/9f945a16bd1aebefc60868e22552375bc630eb98d5505d8cdc847d7841a226540408e7ea174cbb4eb5bfec17235eaca731d154082f64e4935e2a4d2e0244b39b
-  languageName: node
-  linkType: hard
-
-"react-native-drawer-layout@npm:^4.2.2":
-  version: 4.2.2
-  resolution: "react-native-drawer-layout@npm:4.2.2"
-  dependencies:
-    color: "npm:^4.2.3"
-    use-latest-callback: "npm:^0.2.4"
-  peerDependencies:
-    react: ">= 18.2.0"
-    react-native: "*"
-    react-native-gesture-handler: ">= 2.0.0"
-    react-native-reanimated: ">= 2.0.0"
-  checksum: 10/eb21cd0004b642c1489d045654486ec7e2f2be7dec0cedad3fa0cb65c23f1df19b60108ffa7b6c14db94b1962d095f2a6e4a76e275ac30ff3ebcd12ba565c99a
-  languageName: node
-  linkType: hard
-
-"react-native-executorch-bare-resource-fetcher@workspace:*, react-native-executorch-bare-resource-fetcher@workspace:packages/bare-resource-fetcher":
+"react-native-executorch-bare-resource-fetcher@workspace:packages/bare-resource-fetcher":
   version: 0.0.0-use.local
   resolution: "react-native-executorch-bare-resource-fetcher@workspace:packages/bare-resource-fetcher"
   dependencies:
@@ -14990,7 +11180,7 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"react-native-executorch-expo-resource-fetcher@workspace:*, react-native-executorch-expo-resource-fetcher@workspace:packages/expo-resource-fetcher":
+"react-native-executorch-expo-resource-fetcher@workspace:packages/expo-resource-fetcher":
   version: 0.0.0-use.local
   resolution: "react-native-executorch-expo-resource-fetcher@workspace:packages/expo-resource-fetcher"
   dependencies:
@@ -15055,60 +11245,21 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "react-native-executorch@workspace:packages/react-native-executorch"
   dependencies:
-    "@huggingface/jinja": "npm:^0.5.0"
-    "@react-native-community/cli": "npm:latest"
-    "@types/jest": "npm:^30.0.0"
-    "@types/react": "npm:~19.2.0"
-    jest: "npm:^30.2.0"
-    jsonrepair: "npm:^3.12.0"
-    jsonschema: "npm:^1.5.0"
-    metro-react-native-babel-preset: "npm:^0.77.0"
-    react: "npm:19.2.3"
-    react-native: "npm:0.85.3"
-    react-native-builder-bob: "npm:^0.40.12"
-    react-native-device-info: "npm:^15.0.2"
+    "@react-native/babel-preset": "npm:0.83.6"
+    "@types/react": "npm:^19.1.12"
+    del-cli: "npm:^6.0.0"
+    react: "npm:19.2.0"
+    react-native: "npm:0.83.6"
+    react-native-builder-bob: "npm:^0.40.18"
+    react-native-worklets: "npm:0.9.1"
     typescript: "npm:~5.9.2"
-    zod: "npm:^4.3.6"
   peerDependencies:
     react: "*"
     react-native: "*"
+    react-native-worklets: "*"
   languageName: unknown
   linkType: soft
 
-"react-native-fit-image@npm:^1.5.5":
-  version: 1.5.5
-  resolution: "react-native-fit-image@npm:1.5.5"
-  dependencies:
-    prop-types: "npm:^15.5.10"
-  checksum: 10/f12effdf21af83eaaff510635eb076a8d069650496ed9c3286a38e8ca43d47393a99769b339e69244d57a0cb566f96dd315ee8d99443302499174298129ca688
-  languageName: node
-  linkType: hard
-
-"react-native-gesture-handler@npm:~2.31.1":
-  version: 2.31.1
-  resolution: "react-native-gesture-handler@npm:2.31.1"
-  dependencies:
-    "@egjs/hammerjs": "npm:^2.0.17"
-    "@types/react-test-renderer": "npm:^19.1.0"
-    hoist-non-react-statics: "npm:^3.3.0"
-    invariant: "npm:^2.2.4"
-  peerDependencies:
-    react: "*"
-    react-native: "*"
-  checksum: 10/0f02d989fddae1a59f3595b8039da04e8332206e0e8f7e05548b1ab2e57b6efa1b37d634ac8e5cc85b1844363a78f2f1400ace26164319b2140e994b0e779ea3
-  languageName: node
-  linkType: hard
-
-"react-native-image-picker@npm:^8.2.1":
-  version: 8.2.1
-  resolution: "react-native-image-picker@npm:8.2.1"
-  peerDependencies:
-    react: "*"
-    react-native: "*"
-  checksum: 10/d726950f2ab025462f5fbb788b2331672fc5bca1ac44899892736448ed3ee2d3ea49db9d6fee3bcbba4b4e064efeb646924e1cbd8522a23edd28c960f1db66aa
-  languageName: node
-  linkType: hard
-
 "react-native-is-edge-to-edge@npm:^1.1.6":
   version: 1.2.1
   resolution: "react-native-is-edge-to-edge@npm:1.2.1"
@@ -15119,41 +11270,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"react-native-is-edge-to-edge@npm:^1.3.1":
-  version: 1.3.1
-  resolution: "react-native-is-edge-to-edge@npm:1.3.1"
-  peerDependencies:
-    react: "*"
-    react-native: "*"
-  checksum: 10/dc82d54e0bf8f89208a538bb0d14e4891af6efae27ed5b7b21be683a72c38c5219ab9be1ea9bd40aa1c905d481174e649d0b71aeceaa9946e6c707f251568282
-  languageName: node
-  linkType: hard
-
-"react-native-loading-spinner-overlay@npm:^3.0.1":
-  version: 3.0.1
-  resolution: "react-native-loading-spinner-overlay@npm:3.0.1"
-  peerDependencies:
-    react: "*"
-    react-native: "*"
-  checksum: 10/ee43760031b25f2f3bf55fe8f32a19a134d21a4fa949948a28594dbf8268fc3d8cf5f35549b9df6b42edad007563ca664a2085a6f05a38748ece4574b86346ad
-  languageName: node
-  linkType: hard
-
-"react-native-markdown-display@npm:^7.0.2":
-  version: 7.0.2
-  resolution: "react-native-markdown-display@npm:7.0.2"
-  dependencies:
-    css-to-react-native: "npm:^3.0.0"
-    markdown-it: "npm:^10.0.0"
-    prop-types: "npm:^15.7.2"
-    react-native-fit-image: "npm:^1.5.5"
-  peerDependencies:
-    react: ">=16.2.0"
-    react-native: ">=0.50.4"
-  checksum: 10/d7fb3eb7797cc5ba136fd76326c163d83e8dc3ce318891fd4749ac484f74741527c98654d405379e5c8115f9fb935f164710f89601102048bd2f07dd5767ef0c
-  languageName: node
-  linkType: hard
-
 "react-native-monorepo-config@npm:^0.3.3":
   version: 0.3.3
   resolution: "react-native-monorepo-config@npm:0.3.3"
@@ -15164,255 +11280,128 @@ __metadata:
   languageName: node
   linkType: hard
 
-"react-native-nitro-image@npm:0.13.1":
-  version: 0.13.1
-  resolution: "react-native-nitro-image@npm:0.13.1"
-  peerDependencies:
-    react: "*"
-    react-native: "*"
-    react-native-nitro-modules: "*"
-  checksum: 10/1b922566a01a59f164c061875edd9751e3e6694e621424c512f8776b40c3463c4e4fe4121932f9b1f610d20ac2cea51c07a8884a2b2ba4d33c3ea7b595c586e1
-  languageName: node
-  linkType: hard
-
-"react-native-nitro-modules@npm:0.35.4":
-  version: 0.35.4
-  resolution: "react-native-nitro-modules@npm:0.35.4"
-  peerDependencies:
-    react: "*"
-    react-native: "*"
-  checksum: 10/2672ab29e8b7abb38ccf799b96b54dd9fa112b398a112c272f5a67adbf0415908e4565bc7782571ce06cf5fdd4a6d04f49a127d66acae4cedc5f41d385323ede
-  languageName: node
-  linkType: hard
-
-"react-native-reanimated@npm:4.3.1":
-  version: 4.3.1
-  resolution: "react-native-reanimated@npm:4.3.1"
-  dependencies:
-    react-native-is-edge-to-edge: "npm:^1.3.1"
-    semver: "npm:^7.7.3"
-  peerDependencies:
-    react: "*"
-    react-native: 0.81 - 0.85
-    react-native-worklets: 0.8.x
-  checksum: 10/f47d50cc35def5038e68d9013bf976849207237e238ab597e0b8c07d003b0a54d73692185f1a49dc33ab3d7a9d345660a6e70796f28545a7340649806bf17b5c
-  languageName: node
-  linkType: hard
-
-"react-native-reanimated@npm:~4.3.0":
-  version: 4.3.0
-  resolution: "react-native-reanimated@npm:4.3.0"
-  dependencies:
-    react-native-is-edge-to-edge: "npm:^1.3.1"
-    semver: "npm:^7.7.3"
-  peerDependencies:
-    react: "*"
-    react-native: 0.81 - 0.85
-    react-native-worklets: 0.8.x
-  checksum: 10/f65cdf9d89e140cf66a8a8acca8c43903ea0f1a8a67761481b4a96dffd9571a4adc0a4b0f53c16343907b1036e6276c386e2ec8d23324e1b05d53031f34b23b3
-  languageName: node
-  linkType: hard
-
-"react-native-safe-area-context@npm:^5.5.2, react-native-safe-area-context@npm:~5.7.0":
-  version: 5.7.0
-  resolution: "react-native-safe-area-context@npm:5.7.0"
-  peerDependencies:
-    react: "*"
-    react-native: "*"
-  checksum: 10/9f5d3469c18c90c527c4068560ce4dcc7689e9fc8ddc68b8a5e76c94a6eafdba975ced89a48e08fecfd1303331e8c2498722bc249fcd87b1c5ea64ef3abd1d00
-  languageName: node
-  linkType: hard
-
-"react-native-screens@npm:^4.25.2, react-native-screens@npm:~4.25.2":
-  version: 4.25.2
-  resolution: "react-native-screens@npm:4.25.2"
-  dependencies:
-    react-freeze: "npm:^1.0.0"
-    warn-once: "npm:^0.1.0"
-  peerDependencies:
-    react: "*"
-    react-native: ">=0.82.0"
-  checksum: 10/b0fca70d7aafbd8ff993c0e0329ee78fe453391eaff9556e87fb619d0d58b93b497e47ff5477a1028ecad35d4165f47c833ccb22049e59c5d55a1c55a13029b0
-  languageName: node
-  linkType: hard
-
-"react-native-skia-android@npm:147.1.0":
-  version: 147.1.0
-  resolution: "react-native-skia-android@npm:147.1.0"
-  checksum: 10/4e653ff0530fe19cd49e95ebc8906e5336894e529a1bb2c3aac4de2bd2c0f56403a76dbf598f4e3c59dc1a0841f6eae1d7506886bf14b2fdb9182b2de767fb0e
-  languageName: node
-  linkType: hard
-
-"react-native-skia-apple-ios@npm:147.1.0":
-  version: 147.1.0
-  resolution: "react-native-skia-apple-ios@npm:147.1.0"
-  checksum: 10/642e505a211af3bef79ace6cb95298b0addff05ef8ffb53dd66615026cee3ded14283cef40ae4c823c7d072eb4d6c30730d725901286c77c738703fb050448b7
-  languageName: node
-  linkType: hard
-
-"react-native-skia-apple-macos@npm:147.1.0":
-  version: 147.1.0
-  resolution: "react-native-skia-apple-macos@npm:147.1.0"
-  checksum: 10/a341b2c82a9a38d11e1dfb492a287989d7f9bd59be77af84b2fbbe86f06592ad31df7e4bddf21a04db34e9313a7bc472e263c0bc5a0539e0eaf56fce99d3ece5
-  languageName: node
-  linkType: hard
-
-"react-native-skia-apple-tvos@npm:147.1.0":
-  version: 147.1.0
-  resolution: "react-native-skia-apple-tvos@npm:147.1.0"
-  checksum: 10/ce0a58089bcef3ba0faa786db64be39bd8e397c7c5565a3631dd8a21eb913994e9adc7d9c4e47027aa47ce3b1e6d9e3e351e82a7d20c6d1258ddae7ba9ea6d27
-  languageName: node
-  linkType: hard
-
-"react-native-svg-transformer@npm:^1.5.3":
-  version: 1.5.3
-  resolution: "react-native-svg-transformer@npm:1.5.3"
-  dependencies:
-    "@svgr/core": "npm:^8.1.0"
-    "@svgr/plugin-jsx": "npm:^8.1.0"
-    "@svgr/plugin-svgo": "npm:^8.1.0"
-    path-dirname: "npm:^1.0.2"
-  peerDependencies:
-    react-native: ">=0.59.0"
-    react-native-svg: ">=12.0.0"
-  checksum: 10/1c66bce6073b3e4144a71d931ff6e1305485154f858f5c8d2f5292f2fcac1ee0155fb6c0958a4ee03cb6267bed57481ab887325b8685240c2ba51cafa0c05185
-  languageName: node
-  linkType: hard
-
-"react-native-svg@npm:15.15.4":
-  version: 15.15.4
-  resolution: "react-native-svg@npm:15.15.4"
-  dependencies:
-    css-select: "npm:^5.1.0"
-    css-tree: "npm:^1.1.3"
-    warn-once: "npm:0.1.1"
-  peerDependencies:
-    react: "*"
-    react-native: "*"
-  checksum: 10/07b1e9826533ecb4ad731602e720bb4208c18ba0a5f259a17f5ee3aa9b02b1006bb5ae59c81d9d49773c898578a0728724a1085d03939e64e8ddf4ef6c842fdf
-  languageName: node
-  linkType: hard
-
-"react-native-vision-camera-worklets@npm:^5.0.6":
-  version: 5.0.6
-  resolution: "react-native-vision-camera-worklets@npm:5.0.6"
-  peerDependencies:
-    react: "*"
-    react-native: "*"
-    react-native-nitro-modules: "*"
-    react-native-vision-camera: "*"
-    react-native-worklets: "*"
-  checksum: 10/d418740db5ea0a8a50969a04f31d9049bfcab71cda642db0e7629370adc226f76f9283ef4cfd4dd6965231570905751336acf5c793a5793b46a7e4ffcf8f28ed
-  languageName: node
-  linkType: hard
-
-"react-native-vision-camera@npm:^5.0.6":
-  version: 5.0.6
-  resolution: "react-native-vision-camera@npm:5.0.6"
-  peerDependencies:
-    react: "*"
-    react-native: "*"
-    react-native-nitro-image: "*"
-    react-native-nitro-modules: "*"
-  checksum: 10/03a3e853ad4771dca7e6fff03c858b0eab80d07ef200f42431f9176671b5c63acbb40c9b795899cf99a07d71df0ffd90121f7b7c80f305c772121bdb51752db9
-  languageName: node
-  linkType: hard
-
-"react-native-worklets@npm:0.8.1":
-  version: 0.8.1
-  resolution: "react-native-worklets@npm:0.8.1"
+"react-native-worklets@npm:0.9.1":
+  version: 0.9.1
+  resolution: "react-native-worklets@npm:0.9.1"
   dependencies:
     "@babel/plugin-transform-arrow-functions": "npm:^7.27.1"
-    "@babel/plugin-transform-class-properties": "npm:^7.27.1"
-    "@babel/plugin-transform-classes": "npm:^7.28.4"
-    "@babel/plugin-transform-nullish-coalescing-operator": "npm:^7.27.1"
-    "@babel/plugin-transform-optional-chaining": "npm:^7.27.1"
+    "@babel/plugin-transform-class-properties": "npm:^7.28.6"
+    "@babel/plugin-transform-classes": "npm:^7.28.6"
+    "@babel/plugin-transform-nullish-coalescing-operator": "npm:^7.28.6"
+    "@babel/plugin-transform-optional-chaining": "npm:^7.28.6"
     "@babel/plugin-transform-shorthand-properties": "npm:^7.27.1"
     "@babel/plugin-transform-template-literals": "npm:^7.27.1"
     "@babel/plugin-transform-unicode-regex": "npm:^7.27.1"
-    "@babel/preset-typescript": "npm:^7.27.1"
+    "@babel/preset-typescript": "npm:^7.28.5"
     convert-source-map: "npm:^2.0.0"
-    semver: "npm:^7.7.3"
+    semver: "npm:^7.7.4"
   peerDependencies:
     "@babel/core": "*"
     "@react-native/metro-config": "*"
     react: "*"
-    react-native: 0.81 - 0.85
-  checksum: 10/4d01fc18a51c68cae24a928604c2bed62eef3b9521d21a7cbcadf92b141c4f73730917782824acd80e62e86e4bbfe5c850362b8c154103abe2c2f2ab6d2416b4
+    react-native: 0.83 - 0.86
+  checksum: 10/03ec3dfcff65311af247149135d2727e60851c99c12b67927093f8022a618115ad3dda29b707fcb77a7a8a0fe0a68efea065bfa3053020df8dc6f7b402d4d16f
   languageName: node
   linkType: hard
 
-"react-native-worklets@npm:0.8.3":
-  version: 0.8.3
-  resolution: "react-native-worklets@npm:0.8.3"
+"react-native@npm:0.81.5":
+  version: 0.81.5
+  resolution: "react-native@npm:0.81.5"
   dependencies:
-    "@babel/plugin-transform-arrow-functions": "npm:^7.27.1"
-    "@babel/plugin-transform-class-properties": "npm:^7.27.1"
-    "@babel/plugin-transform-classes": "npm:^7.28.4"
-    "@babel/plugin-transform-nullish-coalescing-operator": "npm:^7.27.1"
-    "@babel/plugin-transform-optional-chaining": "npm:^7.27.1"
-    "@babel/plugin-transform-shorthand-properties": "npm:^7.27.1"
-    "@babel/plugin-transform-template-literals": "npm:^7.27.1"
-    "@babel/plugin-transform-unicode-regex": "npm:^7.27.1"
-    "@babel/preset-typescript": "npm:^7.27.1"
-    convert-source-map: "npm:^2.0.0"
-    semver: "npm:^7.7.3"
+    "@jest/create-cache-key-function": "npm:^29.7.0"
+    "@react-native/assets-registry": "npm:0.81.5"
+    "@react-native/codegen": "npm:0.81.5"
+    "@react-native/community-cli-plugin": "npm:0.81.5"
+    "@react-native/gradle-plugin": "npm:0.81.5"
+    "@react-native/js-polyfills": "npm:0.81.5"
+    "@react-native/normalize-colors": "npm:0.81.5"
+    "@react-native/virtualized-lists": "npm:0.81.5"
+    abort-controller: "npm:^3.0.0"
+    anser: "npm:^1.4.9"
+    ansi-regex: "npm:^5.0.0"
+    babel-jest: "npm:^29.7.0"
+    babel-plugin-syntax-hermes-parser: "npm:0.29.1"
+    base64-js: "npm:^1.5.1"
+    commander: "npm:^12.0.0"
+    flow-enums-runtime: "npm:^0.0.6"
+    glob: "npm:^7.1.1"
+    invariant: "npm:^2.2.4"
+    jest-environment-node: "npm:^29.7.0"
+    memoize-one: "npm:^5.0.0"
+    metro-runtime: "npm:^0.83.1"
+    metro-source-map: "npm:^0.83.1"
+    nullthrows: "npm:^1.1.1"
+    pretty-format: "npm:^29.7.0"
+    promise: "npm:^8.3.0"
+    react-devtools-core: "npm:^6.1.5"
+    react-refresh: "npm:^0.14.0"
+    regenerator-runtime: "npm:^0.13.2"
+    scheduler: "npm:0.26.0"
+    semver: "npm:^7.1.3"
+    stacktrace-parser: "npm:^0.1.10"
+    whatwg-fetch: "npm:^3.0.0"
+    ws: "npm:^6.2.3"
+    yargs: "npm:^17.6.2"
   peerDependencies:
-    "@babel/core": "*"
-    "@react-native/metro-config": "*"
-    react: "*"
-    react-native: 0.81 - 0.85
-  checksum: 10/7b200ec7f0a909e3fc4294721d5dc78e10beb5cb6280a3398dbd7df47db77f8130e605c475768659110b0a7355f4361ea9e85cac40176157d622b4b2060e447a
+    "@types/react": ^19.1.0
+    react: ^19.1.0
+  peerDependenciesMeta:
+    "@types/react":
+      optional: true
+  bin:
+    react-native: cli.js
+  checksum: 10/ee472f6cb3a86d9e154e3ac43830424403c8b5d23c6f613f0ac39953b7123352bdb6056270078d98ebbf77ac26fb00d86e50a9c4521a2db93072281937a8d9b0
   languageName: node
   linkType: hard
-
-"react-native@npm:0.81.5":
-  version: 0.81.5
-  resolution: "react-native@npm:0.81.5"
+
+"react-native@npm:0.83.6":
+  version: 0.83.6
+  resolution: "react-native@npm:0.83.6"
   dependencies:
     "@jest/create-cache-key-function": "npm:^29.7.0"
-    "@react-native/assets-registry": "npm:0.81.5"
-    "@react-native/codegen": "npm:0.81.5"
-    "@react-native/community-cli-plugin": "npm:0.81.5"
-    "@react-native/gradle-plugin": "npm:0.81.5"
-    "@react-native/js-polyfills": "npm:0.81.5"
-    "@react-native/normalize-colors": "npm:0.81.5"
-    "@react-native/virtualized-lists": "npm:0.81.5"
+    "@react-native/assets-registry": "npm:0.83.6"
+    "@react-native/codegen": "npm:0.83.6"
+    "@react-native/community-cli-plugin": "npm:0.83.6"
+    "@react-native/gradle-plugin": "npm:0.83.6"
+    "@react-native/js-polyfills": "npm:0.83.6"
+    "@react-native/normalize-colors": "npm:0.83.6"
+    "@react-native/virtualized-lists": "npm:0.83.6"
     abort-controller: "npm:^3.0.0"
     anser: "npm:^1.4.9"
     ansi-regex: "npm:^5.0.0"
     babel-jest: "npm:^29.7.0"
-    babel-plugin-syntax-hermes-parser: "npm:0.29.1"
+    babel-plugin-syntax-hermes-parser: "npm:0.32.0"
     base64-js: "npm:^1.5.1"
     commander: "npm:^12.0.0"
     flow-enums-runtime: "npm:^0.0.6"
     glob: "npm:^7.1.1"
+    hermes-compiler: "npm:0.14.1"
     invariant: "npm:^2.2.4"
     jest-environment-node: "npm:^29.7.0"
     memoize-one: "npm:^5.0.0"
-    metro-runtime: "npm:^0.83.1"
-    metro-source-map: "npm:^0.83.1"
+    metro-runtime: "npm:^0.83.6"
+    metro-source-map: "npm:^0.83.6"
     nullthrows: "npm:^1.1.1"
     pretty-format: "npm:^29.7.0"
     promise: "npm:^8.3.0"
     react-devtools-core: "npm:^6.1.5"
     react-refresh: "npm:^0.14.0"
     regenerator-runtime: "npm:^0.13.2"
-    scheduler: "npm:0.26.0"
+    scheduler: "npm:0.27.0"
     semver: "npm:^7.1.3"
     stacktrace-parser: "npm:^0.1.10"
     whatwg-fetch: "npm:^3.0.0"
-    ws: "npm:^6.2.3"
+    ws: "npm:^7.5.10"
     yargs: "npm:^17.6.2"
   peerDependencies:
-    "@types/react": ^19.1.0
-    react: ^19.1.0
+    "@types/react": ^19.1.1
+    react: ^19.2.0
   peerDependenciesMeta:
     "@types/react":
       optional: true
   bin:
     react-native: cli.js
-  checksum: 10/ee472f6cb3a86d9e154e3ac43830424403c8b5d23c6f613f0ac39953b7123352bdb6056270078d98ebbf77ac26fb00d86e50a9c4521a2db93072281937a8d9b0
+  checksum: 10/d57fc43d7a7c9e0e55efac941ebe6d5781f91d28db8f78eba822e74fe5decdc1f5a8f024b18d79dc08928e8dbc374469df1a910aa58f2241e2e7c637f1366f20
   languageName: node
   linkType: hard
 
@@ -15467,17 +11456,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"react-reconciler@npm:0.31.0":
-  version: 0.31.0
-  resolution: "react-reconciler@npm:0.31.0"
-  dependencies:
-    scheduler: "npm:^0.25.0"
-  peerDependencies:
-    react: ^19.0.0
-  checksum: 10/e7235fa08947296c2084a89dc264651fd7cb9dc3a26c3b132b84ecf2a30c46b9b98cd004c30adfe2a24741cd1e49a618858a48080008ce2b4e964a2c4233041e
-  languageName: node
-  linkType: hard
-
 "react-refresh@npm:^0.14.0, react-refresh@npm:^0.14.2":
   version: 0.14.2
   resolution: "react-refresh@npm:0.14.2"
@@ -15485,20 +11463,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"react-refresh@npm:^0.18.0":
-  version: 0.18.0
-  resolution: "react-refresh@npm:0.18.0"
-  checksum: 10/504c331c19776bf8320c23bad7f80b3a28de03301ed7523b0dd21d3f02bf2b53bbdd5aa52469b187bc90f358614b2ba303c088a0765c95f4f0a68c43a7d67b1d
-  languageName: node
-  linkType: hard
-
-"react-refresh@npm:^0.4.0":
-  version: 0.4.3
-  resolution: "react-refresh@npm:0.4.3"
-  checksum: 10/0cb1e09311e1203e817c4a5004127b634c1ed1cbc312fc7400b330152383ca4376dbd87c4913f790eee548f1254e4f9026cfcfbd6176cfeb2703e97d9700a183
-  languageName: node
-  linkType: hard
-
 "react-remove-scroll-bar@npm:^2.3.7":
   version: 2.3.8
   resolution: "react-remove-scroll-bar@npm:2.3.8"
@@ -15550,18 +11514,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"react-test-renderer@npm:19.1.0":
-  version: 19.1.0
-  resolution: "react-test-renderer@npm:19.1.0"
-  dependencies:
-    react-is: "npm:^19.1.0"
-    scheduler: "npm:^0.26.0"
-  peerDependencies:
-    react: ^19.1.0
-  checksum: 10/73ae0ea779bacd0ff084dd3644b763a4431d68adf9c6acffdaa3d0810aab5322f24c95c60259c23b77f38b5f36d9d614ffaa46d91a33840536f2d4b7188dcc89
-  languageName: node
-  linkType: hard
-
 "react@npm:19.1.0":
   version: 19.1.0
   resolution: "react@npm:19.1.0"
@@ -15569,6 +11521,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"react@npm:19.2.0":
+  version: 19.2.0
+  resolution: "react@npm:19.2.0"
+  checksum: 10/e13bcdb8e994c3cfa922743cb75ca8deb60531bf02f584d2d8dab940a8132ce8a2e6ef16f8ed7f372b4072e7a7eeff589b2812dabbedfa73e6e46201dac8a9d0
+  languageName: node
+  linkType: hard
+
 "react@npm:19.2.3":
   version: 19.2.3
   resolution: "react@npm:19.2.3"
@@ -15576,27 +11535,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"readable-stream@npm:^3.4.0":
-  version: 3.6.2
-  resolution: "readable-stream@npm:3.6.2"
-  dependencies:
-    inherits: "npm:^2.0.3"
-    string_decoder: "npm:^1.1.1"
-    util-deprecate: "npm:^1.0.1"
-  checksum: 10/d9e3e53193adcdb79d8f10f2a1f6989bd4389f5936c6f8b870e77570853561c362bee69feca2bbb7b32368ce96a85504aa4cedf7cf80f36e6a9de30d64244048
-  languageName: node
-  linkType: hard
-
-"redent@npm:^3.0.0":
-  version: 3.0.0
-  resolution: "redent@npm:3.0.0"
-  dependencies:
-    indent-string: "npm:^4.0.0"
-    strip-indent: "npm:^3.0.0"
-  checksum: 10/fa1ef20404a2d399235e83cc80bd55a956642e37dd197b4b612ba7327bf87fa32745aeb4a1634b2bab25467164ab4ed9c15be2c307923dd08b0fe7c52431ae6b
-  languageName: node
-  linkType: hard
-
 "reflect.getprototypeof@npm:^1.0.6, reflect.getprototypeof@npm:^1.0.9":
   version: 1.0.10
   resolution: "reflect.getprototypeof@npm:1.0.10"
@@ -15689,13 +11627,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"require-main-filename@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "require-main-filename@npm:2.0.0"
-  checksum: 10/8604a570c06a69c9d939275becc33a65676529e1c3e5a9f42d58471674df79357872b96d70bb93a0380a62d60dc9031c98b1a9dad98c946ffdd61b7ac0c8cedd
-  languageName: node
-  linkType: hard
-
 "reserved-identifiers@npm:^1.0.0":
   version: 1.2.0
   resolution: "reserved-identifiers@npm:1.2.0"
@@ -15703,15 +11634,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"resolve-cwd@npm:^3.0.0":
-  version: 3.0.0
-  resolution: "resolve-cwd@npm:3.0.0"
-  dependencies:
-    resolve-from: "npm:^5.0.0"
-  checksum: 10/546e0816012d65778e580ad62b29e975a642989108d9a3c5beabfb2304192fa3c9f9146fbdfe213563c6ff51975ae41bac1d3c6e047dd9572c94863a057b4d81
-  languageName: node
-  linkType: hard
-
 "resolve-from@npm:^4.0.0":
   version: 4.0.0
   resolution: "resolve-from@npm:4.0.0"
@@ -15733,14 +11655,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"resolve.exports@npm:^2.0.0":
-  version: 2.0.3
-  resolution: "resolve.exports@npm:2.0.3"
-  checksum: 10/536efee0f30a10fac8604e6cdc7844dbc3f4313568d09f06db4f7ed8a5b8aeb8585966fe975083d1f2dfbc87cf5f8bc7ab65a5c23385c14acbb535ca79f8398a
-  languageName: node
-  linkType: hard
-
-"resolve@npm:^1.20.0, resolve@npm:^1.22.11":
+"resolve@npm:^1.22.11":
   version: 1.22.11
   resolution: "resolve@npm:1.22.11"
   dependencies:
@@ -15769,7 +11684,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"resolve@patch:resolve@npm%3A^1.20.0#optional!builtin<compat/resolve>, resolve@patch:resolve@npm%3A^1.22.11#optional!builtin<compat/resolve>":
+"resolve@patch:resolve@npm%3A^1.22.11#optional!builtin<compat/resolve>":
   version: 1.22.11
   resolution: "resolve@patch:resolve@npm%3A1.22.11#optional!builtin<compat/resolve>::version=1.22.11&hash=c3c19d"
   dependencies:
@@ -15808,16 +11723,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"restore-cursor@npm:^3.1.0":
-  version: 3.1.0
-  resolution: "restore-cursor@npm:3.1.0"
-  dependencies:
-    onetime: "npm:^5.1.0"
-    signal-exit: "npm:^3.0.2"
-  checksum: 10/f877dd8741796b909f2a82454ec111afb84eb45890eb49ac947d87991379406b3b83ff9673a46012fca0d7844bb989f45cc5b788254cf1a39b6b5a9659de0630
-  languageName: node
-  linkType: hard
-
 "retry@npm:^0.13.1":
   version: 0.13.1
   resolution: "retry@npm:0.13.1"
@@ -15865,7 +11770,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"safe-buffer@npm:5.2.1, safe-buffer@npm:~5.2.0":
+"safe-buffer@npm:5.2.1":
   version: 5.2.1
   resolution: "safe-buffer@npm:5.2.1"
   checksum: 10/32872cd0ff68a3ddade7a7617b8f4c2ae8764d8b7d884c651b74457967a9e0e886267d3ecc781220629c44a865167b61c375d2da6c720c840ecd73f45d5d9451
@@ -15893,7 +11798,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"safer-buffer@npm:>= 2.1.2 < 3, safer-buffer@npm:>= 2.1.2 < 3.0.0":
+"safer-buffer@npm:>= 2.1.2 < 3.0.0":
   version: 2.1.2
   resolution: "safer-buffer@npm:2.1.2"
   checksum: 10/7eaf7a0cf37cc27b42fb3ef6a9b1df6e93a1c6d98c6c6702b02fe262d5fcbd89db63320793b99b21cb5348097d0a53de81bd5f4e8b86e20cc9412e3f1cfb4e83
@@ -15907,14 +11812,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"sax@npm:^1.5.0":
-  version: 1.6.0
-  resolution: "sax@npm:1.6.0"
-  checksum: 10/0909cedcd9f011ceeac80c0240a92d64ef712cf6c04e0f6ee236a8d812f86a59f61bee6bb5da28d75306db050b99e0593051ea77351795822253b984af6cf044
-  languageName: node
-  linkType: hard
-
-"scheduler@npm:0.26.0, scheduler@npm:^0.26.0":
+"scheduler@npm:0.26.0":
   version: 0.26.0
   resolution: "scheduler@npm:0.26.0"
   checksum: 10/1ecf2e5d7de1a7a132796834afe14a2d589ba7e437615bd8c06f3e0786a3ac3434655e67aac8755d9b14e05754c177e49c064261de2673aaa3c926bc98caa002
@@ -15928,13 +11826,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"scheduler@npm:^0.25.0":
-  version: 0.25.0
-  resolution: "scheduler@npm:0.25.0"
-  checksum: 10/e661e38503ab29a153429a99203fefa764f28b35c079719eb5efdd2c1c1086522f6653d8ffce388209682c23891a6d1d32fa6badf53c35fb5b9cd0c55ace42de
-  languageName: node
-  linkType: hard
-
 "semver@npm:^6.3.0, semver@npm:^6.3.1":
   version: 6.3.1
   resolution: "semver@npm:6.3.1"
@@ -15944,7 +11835,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"semver@npm:^7.1.3, semver@npm:^7.3.5, semver@npm:^7.3.7, semver@npm:^7.5.2, semver@npm:^7.5.3, semver@npm:^7.5.4, semver@npm:^7.6.0, semver@npm:^7.7.1, semver@npm:^7.7.2, semver@npm:^7.7.3, semver@npm:^7.7.4":
+"semver@npm:^7.1.3, semver@npm:^7.3.5, semver@npm:^7.3.7, semver@npm:^7.5.4, semver@npm:^7.6.0, semver@npm:^7.7.1, semver@npm:^7.7.4":
   version: 7.7.4
   resolution: "semver@npm:7.7.4"
   bin:
@@ -15990,7 +11881,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"serve-static@npm:^1.13.1, serve-static@npm:^1.16.2":
+"serve-static@npm:^1.16.2":
   version: 1.16.3
   resolution: "serve-static@npm:1.16.3"
   dependencies:
@@ -16009,13 +11900,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"set-blocking@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "set-blocking@npm:2.0.0"
-  checksum: 10/8980ebf7ae9eb945bb036b6e283c547ee783a1ad557a82babf758a065e2fb6ea337fd82cac30dd565c1e606e423f30024a19fff7afbf4977d784720c4026a8ef
-  languageName: node
-  linkType: hard
-
 "set-function-length@npm:^1.2.2":
   version: 1.2.2
   resolution: "set-function-length@npm:1.2.2"
@@ -16060,7 +11944,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"sf-symbols-typescript@npm:^2.0.0, sf-symbols-typescript@npm:^2.1.0":
+"sf-symbols-typescript@npm:^2.1.0":
   version: 2.2.0
   resolution: "sf-symbols-typescript@npm:2.2.0"
   checksum: 10/8623e148bf86151692d3ccb3149122c091b256162a39f4c4f78472811ffe92e3c77a83841a7381a5dc0bc6505ebb73e7ca8901cb077004872d7ee1cb4e5be9d4
@@ -16090,7 +11974,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"shell-quote@npm:^1.6.1, shell-quote@npm:^1.8.3":
+"shell-quote@npm:^1.6.1":
   version: 1.8.4
   resolution: "shell-quote@npm:1.8.4"
   checksum: 10/a3e3796385f2cd5cf0b78207a4439f0c7395c0833fc75b2473084b5d298c109c5c0fa687fcd1c04e4b4484866e5bb8eaae7efae443b80fff71ea7e29baf11f0c
@@ -16145,7 +12029,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"signal-exit@npm:^3.0.2, signal-exit@npm:^3.0.3, signal-exit@npm:^3.0.7":
+"signal-exit@npm:^3.0.2, signal-exit@npm:^3.0.7":
   version: 3.0.7
   resolution: "signal-exit@npm:3.0.7"
   checksum: 10/a2f098f247adc367dffc27845853e9959b9e88b01cb301658cfe4194352d8d2bb32e18467c786a7fe15f1d44b233ea35633d076d5e737870b7139949d1ab6318
@@ -16193,14 +12077,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"slice-ansi@npm:^2.0.0":
-  version: 2.1.0
-  resolution: "slice-ansi@npm:2.1.0"
-  dependencies:
-    ansi-styles: "npm:^3.2.0"
-    astral-regex: "npm:^1.0.0"
-    is-fullwidth-code-point: "npm:^2.0.0"
-  checksum: 10/4e82995aa59cef7eb03ef232d73c2239a15efa0ace87a01f3012ebb942e963fbb05d448ce7391efcd52ab9c32724164aba2086f5143e0445c969221dde3b6b1e
+"slash@npm:^5.1.0":
+  version: 5.1.0
+  resolution: "slash@npm:5.1.0"
+  checksum: 10/2c41ec6fb1414cd9bba0fa6b1dd00e8be739e3fe85d079c69d4b09ca5f2f86eafd18d9ce611c0c0f686428638a36c272a6ac14799146a8295f259c10cc45cde4
   languageName: node
   linkType: hard
 
@@ -16218,16 +12098,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"snake-case@npm:^3.0.4":
-  version: 3.0.4
-  resolution: "snake-case@npm:3.0.4"
-  dependencies:
-    dot-case: "npm:^3.0.4"
-    tslib: "npm:^2.0.3"
-  checksum: 10/0a7a79900bbb36f8aaa922cf111702a3647ac6165736d5dc96d3ef367efc50465cac70c53cd172c382b022dac72ec91710608e5393de71f76d7142e6fd80e8a3
-  languageName: node
-  linkType: hard
-
 "socks-proxy-agent@npm:^8.0.3":
   version: 8.0.5
   resolution: "socks-proxy-agent@npm:8.0.5"
@@ -16249,23 +12119,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"source-map-js@npm:^1.0.1, source-map-js@npm:^1.2.1":
+"source-map-js@npm:^1.2.1":
   version: 1.2.1
   resolution: "source-map-js@npm:1.2.1"
   checksum: 10/ff9d8c8bf096d534a5b7707e0382ef827b4dd360a577d3f34d2b9f48e12c9d230b5747974ee7c607f0df65113732711bb701fe9ece3c7edbd43cb2294d707df3
   languageName: node
   linkType: hard
 
-"source-map-support@npm:0.5.13":
-  version: 0.5.13
-  resolution: "source-map-support@npm:0.5.13"
-  dependencies:
-    buffer-from: "npm:^1.0.0"
-    source-map: "npm:^0.6.0"
-  checksum: 10/d1514a922ac9c7e4786037eeff6c3322f461cd25da34bb9fefb15387b3490531774e6e31d95ab6d5b84a3e139af9c3a570ccaee6b47bd7ea262691ed3a8bc34e
-  languageName: node
-  linkType: hard
-
 "source-map-support@npm:~0.5.20":
   version: 0.5.21
   resolution: "source-map-support@npm:0.5.21"
@@ -16283,7 +12143,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"source-map@npm:^0.6.0, source-map@npm:^0.6.1":
+"source-map@npm:^0.6.0":
   version: 0.6.1
   resolution: "source-map@npm:0.6.1"
   checksum: 10/59ef7462f1c29d502b3057e822cdbdae0b0e565302c4dd1a95e11e793d8d9d62006cdc10e0fd99163ca33ff2071360cf50ee13f90440806e7ed57d81cba2f7ff
@@ -16314,37 +12174,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"speech@workspace:apps/speech":
-  version: 0.0.0-use.local
-  resolution: "speech@workspace:apps/speech"
-  dependencies:
-    "@babel/core": "npm:^7.29.0"
-    "@expo/vector-icons": "npm:^15.0.2"
-    "@react-native/metro-config": "npm:^0.85.3"
-    "@types/react": "npm:~19.2.14"
-    "@types/react-refresh": "npm:^0"
-    babel-preset-expo: "npm:~56.0.14"
-    buffer: "npm:^6.0.3"
-    expo: "npm:~56.0.9"
-    expo-build-properties: "npm:~56.0.17"
-    expo-font: "npm:~56.0.5"
-    expo-status-bar: "npm:~56.0.4"
-    metro-config: "npm:^0.84.0"
-    react: "npm:19.2.3"
-    react-native: "npm:0.85.3"
-    react-native-audio-api: "npm:0.12.2"
-    react-native-device-info: "npm:^15.0.2"
-    react-native-executorch: "workspace:*"
-    react-native-executorch-expo-resource-fetcher: "workspace:*"
-    react-native-reanimated: "npm:4.3.1"
-    react-native-safe-area-context: "npm:~5.7.0"
-    react-native-svg: "npm:15.15.4"
-    react-native-svg-transformer: "npm:^1.5.3"
-    react-native-worklets: "npm:0.8.3"
-    react-refresh: "npm:^0.18.0"
-  languageName: unknown
-  linkType: soft
-
 "split-on-first@npm:^1.0.0":
   version: 1.1.0
   resolution: "split-on-first@npm:1.1.0"
@@ -16368,7 +12197,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"stack-utils@npm:^2.0.3, stack-utils@npm:^2.0.6":
+"stack-utils@npm:^2.0.3":
   version: 2.0.6
   resolution: "stack-utils@npm:2.0.6"
   dependencies:
@@ -16431,23 +12260,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"strict-url-sanitise@npm:0.0.1":
-  version: 0.0.1
-  resolution: "strict-url-sanitise@npm:0.0.1"
-  checksum: 10/cab6ae551f998f18ea7fb14176a9d835f5b304e5419c61851de897c830ccc20c2848bbb50ced242227114e06a3f6379dcc9179a84bc0a7b8cf81f5192b5b4789
-  languageName: node
-  linkType: hard
-
-"string-length@npm:^4.0.1, string-length@npm:^4.0.2":
-  version: 4.0.2
-  resolution: "string-length@npm:4.0.2"
-  dependencies:
-    char-regex: "npm:^1.0.2"
-    strip-ansi: "npm:^6.0.0"
-  checksum: 10/ce85533ef5113fcb7e522bcf9e62cb33871aa99b3729cec5595f4447f660b0cefd542ca6df4150c97a677d58b0cb727a3fe09ac1de94071d05526c73579bf505
-  languageName: node
-  linkType: hard
-
 "string-natural-compare@npm:^3.0.1":
   version: 3.0.1
   resolution: "string-natural-compare@npm:3.0.1"
@@ -16546,15 +12358,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"string_decoder@npm:^1.1.1":
-  version: 1.3.0
-  resolution: "string_decoder@npm:1.3.0"
-  dependencies:
-    safe-buffer: "npm:~5.2.0"
-  checksum: 10/54d23f4a6acae0e93f999a585e673be9e561b65cd4cca37714af1e893ab8cd8dfa52a9e4f58f48f87b4a44918d3a9254326cb80ed194bf2e4c226e2b21767e56
-  languageName: node
-  linkType: hard
-
 "strip-ansi-cjs@npm:strip-ansi@^6.0.1, strip-ansi@npm:^6.0.0, strip-ansi@npm:^6.0.1":
   version: 6.0.1
   resolution: "strip-ansi@npm:6.0.1"
@@ -16564,7 +12367,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"strip-ansi@npm:^5.0.0, strip-ansi@npm:^5.2.0":
+"strip-ansi@npm:^5.2.0":
   version: 5.2.0
   resolution: "strip-ansi@npm:5.2.0"
   dependencies:
@@ -16582,13 +12385,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"strip-bom@npm:^4.0.0":
-  version: 4.0.0
-  resolution: "strip-bom@npm:4.0.0"
-  checksum: 10/9dbcfbaf503c57c06af15fe2c8176fb1bf3af5ff65003851a102749f875a6dbe0ab3b30115eccf6e805e9d756830d3e40ec508b62b3f1ddf3761a20ebe29d3f3
-  languageName: node
-  linkType: hard
-
 "strip-final-newline@npm:^2.0.0":
   version: 2.0.0
   resolution: "strip-final-newline@npm:2.0.0"
@@ -16596,15 +12392,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"strip-indent@npm:^3.0.0":
-  version: 3.0.0
-  resolution: "strip-indent@npm:3.0.0"
-  dependencies:
-    min-indent: "npm:^1.0.0"
-  checksum: 10/18f045d57d9d0d90cd16f72b2313d6364fd2cb4bf85b9f593523ad431c8720011a4d5f08b6591c9d580f446e78855c5334a30fb91aa1560f5d9f95ed1b4a0530
-  languageName: node
-  linkType: hard
-
 "strip-json-comments@npm:^3.1.1":
   version: 3.1.1
   resolution: "strip-json-comments@npm:3.1.1"
@@ -16612,20 +12399,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"strnum@npm:^1.0.5":
-  version: 1.1.2
-  resolution: "strnum@npm:1.1.2"
-  checksum: 10/ccd6297a1fdaf0fc8ea0ea904acdae76878d49a4b0d98a70155df4bc081fd88eac5ec99fb150f3d1d1af065c1898d38420705259ba6c39aa850c671bcd54e35d
-  languageName: node
-  linkType: hard
-
-"strnum@npm:^2.3.0":
-  version: 2.3.0
-  resolution: "strnum@npm:2.3.0"
-  checksum: 10/ce79c86bb2b96f053eb28e14924c13604e22977dcdece9aa914c25e16cc5c4bbe048976fe0b2a4decf08a1e13600b820749cea25463fc0e5fee3078339e0a457
-  languageName: node
-  linkType: hard
-
 "structured-headers@npm:^0.4.1":
   version: 0.4.1
   resolution: "structured-headers@npm:0.4.1"
@@ -16651,7 +12424,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"supports-color@npm:^8.0.0, supports-color@npm:^8.1.1":
+"supports-color@npm:^8.0.0":
   version: 8.1.1
   resolution: "supports-color@npm:8.1.1"
   dependencies:
@@ -16677,31 +12450,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"svg-parser@npm:^2.0.4":
-  version: 2.0.4
-  resolution: "svg-parser@npm:2.0.4"
-  checksum: 10/ec196da6ea21481868ab26911970e35488361c39ead1c6cdd977ba16c885c21a91ddcbfd113bfb01f79a822e2a751ef85b2f7f95e2cb9245558ebce12c34af1f
-  languageName: node
-  linkType: hard
-
-"svgo@npm:^3.0.2":
-  version: 3.3.3
-  resolution: "svgo@npm:3.3.3"
-  dependencies:
-    commander: "npm:^7.2.0"
-    css-select: "npm:^5.1.0"
-    css-tree: "npm:^2.3.1"
-    css-what: "npm:^6.1.0"
-    csso: "npm:^5.0.5"
-    picocolors: "npm:^1.0.0"
-    sax: "npm:^1.5.0"
-  bin:
-    svgo: ./bin/svgo
-  checksum: 10/f3c1b4d05d1704483e53515d5995af5f06a2718df85e3a8320f57bb256b8dc926b84c87a1a9b98e9d3ca1224314cc0676a803bdd03163508292f2d45c7077096
-  languageName: node
-  linkType: hard
-
-"synckit@npm:^0.11.12, synckit@npm:^0.11.4, synckit@npm:^0.11.8":
+"synckit@npm:^0.11.12, synckit@npm:^0.11.4":
   version: 0.11.12
   resolution: "synckit@npm:0.11.12"
   dependencies:
@@ -16758,41 +12507,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"text-embeddings@workspace:apps/text-embeddings":
-  version: 0.0.0-use.local
-  resolution: "text-embeddings@workspace:apps/text-embeddings"
-  dependencies:
-    "@babel/core": "npm:^7.29.0"
-    "@expo/log-box": "npm:~56.0.12"
-    "@expo/vector-icons": "npm:^15.0.2"
-    "@react-native/metro-config": "npm:^0.85.3"
-    "@react-navigation/drawer": "npm:^7.9.4"
-    "@react-navigation/native": "npm:^7.2.2"
-    "@types/react": "npm:~19.2.14"
-    "@types/react-refresh": "npm:^0"
-    babel-preset-expo: "npm:~56.0.14"
-    expo: "npm:~56.0.9"
-    expo-build-properties: "npm:~56.0.17"
-    expo-constants: "npm:~56.0.17"
-    expo-font: "npm:~56.0.5"
-    expo-linking: "npm:~56.0.13"
-    expo-router: "npm:~56.2.9"
-    expo-status-bar: "npm:~56.0.4"
-    react: "npm:19.2.3"
-    react-native: "npm:0.85.3"
-    react-native-executorch: "workspace:*"
-    react-native-executorch-expo-resource-fetcher: "workspace:*"
-    react-native-gesture-handler: "npm:~2.31.1"
-    react-native-image-picker: "npm:^8.2.1"
-    react-native-reanimated: "npm:4.3.1"
-    react-native-safe-area-context: "npm:~5.7.0"
-    react-native-screens: "npm:~4.25.2"
-    react-native-svg: "npm:15.15.4"
-    react-native-worklets: "npm:0.8.3"
-    react-refresh: "npm:^0.18.0"
-  languageName: unknown
-  linkType: soft
-
 "text-table@npm:^0.2.0":
   version: 0.2.0
   resolution: "text-table@npm:0.2.0"
@@ -16883,7 +12597,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"tslib@npm:^2.0.0, tslib@npm:^2.0.3, tslib@npm:^2.1.0, tslib@npm:^2.4.0":
+"tslib@npm:^2.0.0, tslib@npm:^2.1.0":
   version: 2.8.1
   resolution: "tslib@npm:2.8.1"
   checksum: 10/3e2e043d5c2316461cb54e5c7fe02c30ef6dccb3384717ca22ae5c6b5bc95232a6241df19c622d9c73b809bea33b187f6dbc73030963e29950c2141bc32a79f7
@@ -16938,27 +12652,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"type-is@npm:^2.0.1":
-  version: 2.0.1
-  resolution: "type-is@npm:2.0.1"
-  dependencies:
-    content-type: "npm:^1.0.5"
-    media-typer: "npm:^1.1.0"
-    mime-types: "npm:^3.0.0"
-  checksum: 10/bacdb23c872dacb7bd40fbd9095e6b2fca2895eedbb689160c05534d7d4810a7f4b3fd1ae87e96133c505958f6d602967a68db5ff577b85dd6be76eaa75d58af
-  languageName: node
-  linkType: hard
-
-"type-is@npm:~1.6.18":
-  version: 1.6.18
-  resolution: "type-is@npm:1.6.18"
-  dependencies:
-    media-typer: "npm:0.3.0"
-    mime-types: "npm:~2.1.24"
-  checksum: 10/0bd9eeae5efd27d98fd63519f999908c009e148039d8e7179a074f105362d4fcc214c38b24f6cda79c87e563cbd12083a4691381ed28559220d4a10c2047bed4
-  languageName: node
-  linkType: hard
-
 "typed-array-buffer@npm:^1.0.3":
   version: 1.0.3
   resolution: "typed-array-buffer@npm:1.0.3"
@@ -17012,7 +12705,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"typescript@npm:^5.8.3, typescript@npm:~5.9.2":
+"typescript@npm:~5.9.2":
   version: 5.9.3
   resolution: "typescript@npm:5.9.3"
   bin:
@@ -17022,7 +12715,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"typescript@patch:typescript@npm%3A^5.8.3#optional!builtin<compat/typescript>, typescript@patch:typescript@npm%3A~5.9.2#optional!builtin<compat/typescript>":
+"typescript@patch:typescript@npm%3A~5.9.2#optional!builtin<compat/typescript>":
   version: 5.9.3
   resolution: "typescript@patch:typescript@npm%3A5.9.3#optional!builtin<compat/typescript>::version=5.9.3&hash=5adc0c"
   bin:
@@ -17032,13 +12725,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"uc.micro@npm:^1.0.1, uc.micro@npm:^1.0.5":
-  version: 1.0.6
-  resolution: "uc.micro@npm:1.0.6"
-  checksum: 10/6898bb556319a38e9cf175e3628689347bd26fec15fc6b29fa38e0045af63075ff3fea4cf1fdba9db46c9f0cbf07f2348cd8844889dd31ebd288c29fe0d27e7a
-  languageName: node
-  linkType: hard
-
 "unbox-primitive@npm:^1.1.0":
   version: 1.1.0
   resolution: "unbox-primitive@npm:1.1.0"
@@ -17096,6 +12782,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"unicorn-magic@npm:^0.3.0":
+  version: 0.3.0
+  resolution: "unicorn-magic@npm:0.3.0"
+  checksum: 10/bdd7d7c522f9456f32a0b77af23f8854f9a7db846088c3868ec213f9550683ab6a2bdf3803577eacbafddb4e06900974385841ccb75338d17346ccef45f9cb01
+  languageName: node
+  linkType: hard
+
 "unique-filename@npm:^5.0.0":
   version: 5.0.0
   resolution: "unique-filename@npm:5.0.0"
@@ -17132,13 +12825,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"universalify@npm:^0.1.0":
-  version: 0.1.2
-  resolution: "universalify@npm:0.1.2"
-  checksum: 10/40cdc60f6e61070fe658ca36016a8f4ec216b29bf04a55dce14e3710cc84c7448538ef4dad3728d0bfe29975ccd7bfb5f414c45e7b78883567fb31b246f02dff
-  languageName: node
-  linkType: hard
-
 "universalify@npm:^2.0.0":
   version: 2.0.1
   resolution: "universalify@npm:2.0.1"
@@ -17153,73 +12839,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"unrs-resolver@npm:^1.7.11":
-  version: 1.11.1
-  resolution: "unrs-resolver@npm:1.11.1"
-  dependencies:
-    "@unrs/resolver-binding-android-arm-eabi": "npm:1.11.1"
-    "@unrs/resolver-binding-android-arm64": "npm:1.11.1"
-    "@unrs/resolver-binding-darwin-arm64": "npm:1.11.1"
-    "@unrs/resolver-binding-darwin-x64": "npm:1.11.1"
-    "@unrs/resolver-binding-freebsd-x64": "npm:1.11.1"
-    "@unrs/resolver-binding-linux-arm-gnueabihf": "npm:1.11.1"
-    "@unrs/resolver-binding-linux-arm-musleabihf": "npm:1.11.1"
-    "@unrs/resolver-binding-linux-arm64-gnu": "npm:1.11.1"
-    "@unrs/resolver-binding-linux-arm64-musl": "npm:1.11.1"
-    "@unrs/resolver-binding-linux-ppc64-gnu": "npm:1.11.1"
-    "@unrs/resolver-binding-linux-riscv64-gnu": "npm:1.11.1"
-    "@unrs/resolver-binding-linux-riscv64-musl": "npm:1.11.1"
-    "@unrs/resolver-binding-linux-s390x-gnu": "npm:1.11.1"
-    "@unrs/resolver-binding-linux-x64-gnu": "npm:1.11.1"
-    "@unrs/resolver-binding-linux-x64-musl": "npm:1.11.1"
-    "@unrs/resolver-binding-wasm32-wasi": "npm:1.11.1"
-    "@unrs/resolver-binding-win32-arm64-msvc": "npm:1.11.1"
-    "@unrs/resolver-binding-win32-ia32-msvc": "npm:1.11.1"
-    "@unrs/resolver-binding-win32-x64-msvc": "npm:1.11.1"
-    napi-postinstall: "npm:^0.3.0"
-  dependenciesMeta:
-    "@unrs/resolver-binding-android-arm-eabi":
-      optional: true
-    "@unrs/resolver-binding-android-arm64":
-      optional: true
-    "@unrs/resolver-binding-darwin-arm64":
-      optional: true
-    "@unrs/resolver-binding-darwin-x64":
-      optional: true
-    "@unrs/resolver-binding-freebsd-x64":
-      optional: true
-    "@unrs/resolver-binding-linux-arm-gnueabihf":
-      optional: true
-    "@unrs/resolver-binding-linux-arm-musleabihf":
-      optional: true
-    "@unrs/resolver-binding-linux-arm64-gnu":
-      optional: true
-    "@unrs/resolver-binding-linux-arm64-musl":
-      optional: true
-    "@unrs/resolver-binding-linux-ppc64-gnu":
-      optional: true
-    "@unrs/resolver-binding-linux-riscv64-gnu":
-      optional: true
-    "@unrs/resolver-binding-linux-riscv64-musl":
-      optional: true
-    "@unrs/resolver-binding-linux-s390x-gnu":
-      optional: true
-    "@unrs/resolver-binding-linux-x64-gnu":
-      optional: true
-    "@unrs/resolver-binding-linux-x64-musl":
-      optional: true
-    "@unrs/resolver-binding-wasm32-wasi":
-      optional: true
-    "@unrs/resolver-binding-win32-arm64-msvc":
-      optional: true
-    "@unrs/resolver-binding-win32-ia32-msvc":
-      optional: true
-    "@unrs/resolver-binding-win32-x64-msvc":
-      optional: true
-  checksum: 10/4de653508cbaae47883a896bd5cdfef0e5e87b428d62620d16fd35cd534beaebf08ebf0cf2f8b4922aa947b2fe745180facf6cc3f39ba364f7ce0f974cb06a70
-  languageName: node
-  linkType: hard
-
 "update-browserslist-db@npm:^1.2.0":
   version: 1.2.3
   resolution: "update-browserslist-db@npm:1.2.3"
@@ -17292,13 +12911,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"util-deprecate@npm:^1.0.1":
-  version: 1.0.2
-  resolution: "util-deprecate@npm:1.0.2"
-  checksum: 10/474acf1146cb2701fe3b074892217553dfcf9a031280919ba1b8d651a068c9b15d863b7303cb15bd00a862b498e6cf4ad7b4a08fb134edd5a6f7641681cb54a2
-  languageName: node
-  linkType: hard
-
 "utils-merge@npm:1.0.1":
   version: 1.0.1
   resolution: "utils-merge@npm:1.0.1"
@@ -17315,17 +12927,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"v8-to-istanbul@npm:^9.0.1":
-  version: 9.3.0
-  resolution: "v8-to-istanbul@npm:9.3.0"
-  dependencies:
-    "@jridgewell/trace-mapping": "npm:^0.3.12"
-    "@types/istanbul-lib-coverage": "npm:^2.0.1"
-    convert-source-map: "npm:^2.0.0"
-  checksum: 10/fb1d70f1176cb9dc46cabbb3fd5c52c8f3e8738b61877b6e7266029aed0870b04140e3f9f4550ac32aebcfe1d0f38b0bac57e1e8fb97d68fec82f2b416148166
-  languageName: node
-  linkType: hard
-
 "validate-npm-package-name@npm:^5.0.0":
   version: 5.0.1
   resolution: "validate-npm-package-name@npm:5.0.1"
@@ -17382,7 +12983,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"warn-once@npm:0.1.1, warn-once@npm:^0.1.0, warn-once@npm:^0.1.1":
+"warn-once@npm:^0.1.1":
   version: 0.1.1
   resolution: "warn-once@npm:0.1.1"
   checksum: 10/e6a5a1f5a8dba7744399743d3cfb571db4c3947897875d4962a7c5b1bf2195ab4518c838cb4cea652e71729f21bba2e98dc75686f5fccde0fabbd894e2ed0c0d
@@ -17458,13 +13059,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"which-module@npm:^2.0.0":
-  version: 2.0.1
-  resolution: "which-module@npm:2.0.1"
-  checksum: 10/1967b7ce17a2485544a4fdd9063599f0f773959cca24176dbe8f405e55472d748b7c549cd7920ff6abb8f1ab7db0b0f1b36de1a21c57a8ff741f4f1e792c52be
-  languageName: node
-  linkType: hard
-
 "which-typed-array@npm:^1.1.16, which-typed-array@npm:^1.1.19":
   version: 1.1.20
   resolution: "which-typed-array@npm:1.1.20"
@@ -17520,17 +13114,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"wrap-ansi@npm:^6.2.0":
-  version: 6.2.0
-  resolution: "wrap-ansi@npm:6.2.0"
-  dependencies:
-    ansi-styles: "npm:^4.0.0"
-    string-width: "npm:^4.1.0"
-    strip-ansi: "npm:^6.0.0"
-  checksum: 10/0d64f2d438e0b555e693b95aee7b2689a12c3be5ac458192a1ce28f542a6e9e59ddfecc37520910c2c88eb1f82a5411260566dba5064e8f9895e76e169e76187
-  languageName: node
-  linkType: hard
-
 "wrap-ansi@npm:^8.1.0":
   version: 8.1.0
   resolution: "wrap-ansi@npm:8.1.0"
@@ -17559,16 +13142,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"write-file-atomic@npm:^5.0.1":
-  version: 5.0.1
-  resolution: "write-file-atomic@npm:5.0.1"
-  dependencies:
-    imurmurhash: "npm:^0.1.4"
-    signal-exit: "npm:^4.0.1"
-  checksum: 10/648efddba54d478d0e4330ab6f239976df3b9752b123db5dc9405d9b5af768fa9d70ce60c52fdbe61d1200d24350bc4fbcbaf09288496c2be050de126bd95b7e
-  languageName: node
-  linkType: hard
-
 "ws@npm:^6.2.3":
   version: 6.2.3
   resolution: "ws@npm:6.2.3"
@@ -17625,13 +13198,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"xml-naming@npm:^0.1.0":
-  version: 0.1.0
-  resolution: "xml-naming@npm:0.1.0"
-  checksum: 10/45abd94ba64a508bda3f4d0b70e49811a3c3542596252c213caf47c858bbe9bba365ebba8eeff68e2a876e22a1bf6855d90cd2019b2f28012cebb167a4df2293
-  languageName: node
-  linkType: hard
-
 "xml2js@npm:0.6.0":
   version: 0.6.0
   resolution: "xml2js@npm:0.6.0"
@@ -17656,13 +13222,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"y18n@npm:^4.0.0":
-  version: 4.0.3
-  resolution: "y18n@npm:4.0.3"
-  checksum: 10/392870b2a100bbc643bc035fe3a89cef5591b719c7bdc8721bcdb3d27ab39fa4870acdca67b0ee096e146d769f311d68eda6b8195a6d970f227795061923013f
-  languageName: node
-  linkType: hard
-
 "y18n@npm:^5.0.5":
   version: 5.0.8
   resolution: "y18n@npm:5.0.8"
@@ -17691,7 +13250,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"yaml@npm:^2.2.1, yaml@npm:^2.6.1, yaml@npm:^2.7.1":
+"yaml@npm:^2.6.1, yaml@npm:^2.7.1":
   version: 2.8.3
   resolution: "yaml@npm:2.8.3"
   bin:
@@ -17700,16 +13259,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"yargs-parser@npm:^18.1.2":
-  version: 18.1.3
-  resolution: "yargs-parser@npm:18.1.3"
-  dependencies:
-    camelcase: "npm:^5.0.0"
-    decamelize: "npm:^1.2.0"
-  checksum: 10/235bcbad5b7ca13e5abc54df61d42f230857c6f83223a38e4ed7b824681875b7f8b6ed52139d88a3ad007050f28dc0324b3c805deac7db22ae3b4815dae0e1bf
-  languageName: node
-  linkType: hard
-
 "yargs-parser@npm:^21.1.1":
   version: 21.1.1
   resolution: "yargs-parser@npm:21.1.1"
@@ -17717,26 +13266,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"yargs@npm:^15.1.0":
-  version: 15.4.1
-  resolution: "yargs@npm:15.4.1"
-  dependencies:
-    cliui: "npm:^6.0.0"
-    decamelize: "npm:^1.2.0"
-    find-up: "npm:^4.1.0"
-    get-caller-file: "npm:^2.0.1"
-    require-directory: "npm:^2.1.1"
-    require-main-filename: "npm:^2.0.0"
-    set-blocking: "npm:^2.0.0"
-    string-width: "npm:^4.2.0"
-    which-module: "npm:^2.0.0"
-    y18n: "npm:^4.0.0"
-    yargs-parser: "npm:^18.1.2"
-  checksum: 10/bbcc82222996c0982905b668644ca363eebe6ffd6a572fbb52f0c0e8146661d8ce5af2a7df546968779bb03d1e4186f3ad3d55dfaadd1c4f0d5187c0e3a5ba16
-  languageName: node
-  linkType: hard
-
-"yargs@npm:^17.3.1, yargs@npm:^17.5.1, yargs@npm:^17.6.2, yargs@npm:^17.7.2":
+"yargs@npm:^17.5.1, yargs@npm:^17.6.2":
   version: 17.7.2
   resolution: "yargs@npm:17.7.2"
   dependencies:
@@ -17764,10 +13294,3 @@ __metadata:
   checksum: 10/f0c963ec40cd96858451d1690404d603d36507c1fc9682f2dae59ab38b578687d542708a7fdbf645f77926f78c9ed558f57c3d3aa226c285f798df0c4da16995
   languageName: node
   linkType: hard
-
-"zod@npm:^4.3.6":
-  version: 4.3.6
-  resolution: "zod@npm:4.3.6"
-  checksum: 10/25fc0f62e01b557b4644bf0b393bbaf47542ab30877c37837ea8caf314a8713d220c7d7fe51f68ffa72f0e1018ddfa34d96f1973d23033f5a2a5a9b6b9d9da01
-  languageName: node
-  linkType: hard